diff --git a/Cargo.lock b/Cargo.lock index 78f6e6a761..5919465b9b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1909,20 +1909,6 @@ dependencies = [ "digest 0.10.7", ] -[[package]] -name = "blake3" -version = "1.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2468ef7d57b3fb7e16b576e8377cdbde2320c60e1491e961d11da40fc4f02a2d" -dependencies = [ - "arrayref", - "arrayvec", - "cc", - "cfg-if", - "constant_time_eq", - "cpufeatures", -] - [[package]] name = "block-buffer" version = "0.10.4" @@ -2297,12 +2283,6 @@ dependencies = [ "unicode-xid", ] -[[package]] -name = "constant_time_eq" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b" - [[package]] name = "convert_case" version = "0.10.0" @@ -2836,14 +2816,12 @@ version = "0.1.8" dependencies = [ "anyhow", "e3-fhe-params", - "e3-greco-helpers", - "e3-polynomial 0.1.8", + "e3-polynomial", "e3-zk-helpers", "fhe", "fhe-traits", "rand 0.8.5", "thiserror 1.0.69", - "zkfhe-greco", ] [[package]] @@ -3158,20 +3136,6 @@ dependencies = [ "vfs", ] -[[package]] -name = "e3-greco-helpers" -version = "0.1.8" -dependencies = [ - "e3-fhe-params", - "e3-zk-helpers", - "fhe", - "fhe-math", - "fhe-traits", - "num-bigint", - "rand 0.8.5", - "zkfhe-greco", -] - [[package]] name = "e3-indexer" version = "0.1.8" @@ -3319,17 +3283,6 @@ dependencies = [ "thiserror 1.0.69", ] -[[package]] -name = "e3-polynomial" -version = "0.1.8" -source = "git+https://github.com/gnosisguild/enclave?branch=main#ebf6f386dcefd6ab9c5060d4b8932ed1fa1132b9" -dependencies = [ - "num-bigint", - "num-traits", - "serde", - "thiserror 1.0.69", -] - [[package]] name = "e3-program-server" version = "0.1.8" @@ -3372,18 +3325,6 @@ dependencies = [ "taceo-poseidon2", ] -[[package]] -name = "e3-safe" -version = "0.1.8" -source = "git+https://github.com/gnosisguild/enclave#ebf6f386dcefd6ab9c5060d4b8932ed1fa1132b9" -dependencies = [ - "ark-bn254 0.5.0", - "ark-ff 0.5.0", - "hex", - "sha3", - "taceo-poseidon2", -] - [[package]] name = "e3-sdk" version = "0.1.8" @@ -3582,10 +3523,11 @@ dependencies = [ "clap", "e3-fhe-params", "e3-parity-matrix", - "e3-polynomial 0.1.8", - "e3-safe 0.1.8", + "e3-polynomial", + "e3-safe", "fhe", "fhe-math", + "fhe-traits", "itertools 0.14.0", "ndarray", "num-bigint", @@ -9647,54 +9589,6 @@ dependencies = [ "tiny-keccak", ] -[[package]] -name = "zkfhe-greco" -version = "0.1.0" -source = "git+https://github.com/gnosisguild/zkfhe-generator#31e91b2032c12ef0945f74afac0608f711d25501" -dependencies = [ - "anyhow", - "ark-bn254 0.5.0", - "ark-ff 0.5.0", - "blake3", - "e3-polynomial 0.1.8 (git+https://github.com/gnosisguild/enclave?branch=main)", - "fhe", - "fhe-math", - "fhe-traits", - "itertools 0.14.0", - "num-bigint", - "num-traits", - "rand 0.8.5", - "rayon", - "serde", - "serde_json", - "tempfile", - "toml", - "zkfhe-shared", -] - -[[package]] -name = "zkfhe-shared" -version = "0.1.0" -source = "git+https://github.com/gnosisguild/zkfhe-generator#31e91b2032c12ef0945f74afac0608f711d25501" -dependencies = [ - "anyhow", - "ark-bn254 0.5.0", - "ark-ff 0.5.0", - "chrono", - "e3-polynomial 0.1.8 (git+https://github.com/gnosisguild/enclave?branch=main)", - "e3-safe 0.1.8 (git+https://github.com/gnosisguild/enclave)", - "fhe", - "fhe-math", - "fhe-traits", - "num-bigint", - "num-traits", - "rand 0.8.5", - "serde", - "serde_json", - "thiserror 1.0.69", - "toml", -] - [[package]] name = "zstd" version = "0.13.3" diff --git a/Cargo.toml b/Cargo.toml index b7e6eccab1..f0e664887e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,7 +16,6 @@ members = [ "crates/fhe", "crates/fhe-params", "crates/fs", - "crates/greco-helpers", "crates/indexer", "crates/init", "crates/keyshare", @@ -88,7 +87,6 @@ e3-evm-helpers = { version = "0.1.8", path = "./crates/evm-helpers" } e3-fhe = { version = "0.1.8", path = "./crates/fhe" } e3-fhe-params = { version = "0.1.8", path = "./crates/fhe-params" } e3-fs = { version = "0.1.8", path = "./crates/fs" } -e3-greco-helpers = { version = "0.1.8", path = "./crates/greco-helpers" } e3-indexer = { version = "0.1.8", path = "./crates/indexer" } e3-multithread = { version = "0.1.8", path = "./crates/multithread" } e3-keyshare = { version = "0.1.8", path = "./crates/keyshare" } @@ -148,7 +146,6 @@ futures = "=0.3.31" futures-util = "=0.3.31" glob = "=0.3.2" git2 = "=0.20.2" -greco = { package = "e3-greco-generator", git = "https://github.com/gnosisguild/greco" } hex = "=0.4.3" lazy_static = "=1.5.0" num = "=0.4.3" diff --git a/circuits/lib/src/configs/insecure/threshold.nr b/circuits/lib/src/configs/insecure/threshold.nr index cbbaeb5c22..9d091191fb 100644 --- a/circuits/lib/src/configs/insecure/threshold.nr +++ b/circuits/lib/src/configs/insecure/threshold.nr @@ -13,9 +13,8 @@ use crate::core::threshold::user_data_encryption::Configs as UserDataEncryptionC // Global configs for threshold insecure preset pub global N: u32 = 512; pub global L: u32 = 2; -pub global PLAINTEXT_MODULUS: Field = 10; +pub global PLAINTEXT_MODULUS: Field = 100; pub global QIS: [Field; L] = [68719403009, 68719230977]; -pub global Q_MOD_T_MOD_P: Field = 3; pub global Q_MOD_T: Field = 3; pub global Q_INVERSE_MOD_T: Field = 7; pub global T_INV_MOD_Q: Field = 1416703358393105942938; @@ -69,35 +68,34 @@ user_data_encryption (CIRCUIT 6) ------------------------------------- ************************************/ -// user_data_encryption - bit parameters -pub global USER_DATA_ENCRYPTION_BIT_PK: u32 = 36; -pub global USER_DATA_ENCRYPTION_BIT_CT: u32 = 36; -pub global USER_DATA_ENCRYPTION_BIT_U: u32 = 2; -pub global USER_DATA_ENCRYPTION_BIT_E0: u32 = 6; -pub global USER_DATA_ENCRYPTION_BIT_E1: u32 = 6; -pub global USER_DATA_ENCRYPTION_BIT_K: u32 = 4; -pub global USER_DATA_ENCRYPTION_BIT_R1: u32 = 10; -pub global USER_DATA_ENCRYPTION_BIT_R2: u32 = 36; -pub global USER_DATA_ENCRYPTION_BIT_P1: u32 = 10; -pub global USER_DATA_ENCRYPTION_BIT_P2: u32 = 36; - -// user_data_encryption - bounds -pub global USER_DATA_ENCRYPTION_K0IS: [Field; L] = [61847462708, 20615769293]; +pub global USER_DATA_ENCRYPTION_BIT_PK: u32 = 35; +pub global USER_DATA_ENCRYPTION_BIT_CT: u32 = 35; +pub global USER_DATA_ENCRYPTION_BIT_U: u32 = 1; +pub global USER_DATA_ENCRYPTION_BIT_E0: u32 = 5; +pub global USER_DATA_ENCRYPTION_BIT_E1: u32 = 5; +pub global USER_DATA_ENCRYPTION_BIT_K: u32 = 6; +pub global USER_DATA_ENCRYPTION_BIT_R1: u32 = 9; +pub global USER_DATA_ENCRYPTION_BIT_R2: u32 = 35; +pub global USER_DATA_ENCRYPTION_BIT_P1: u32 = 9; +pub global USER_DATA_ENCRYPTION_BIT_P2: u32 = 35; + +pub global USER_DATA_ENCRYPTION_Q_MOD_T_MOD_P: Field = + 21888242871839275222246405745257275088548364400416034343698204186575808495610; +pub global USER_DATA_ENCRYPTION_K0IS: [Field; L] = [61160268678, 8933500027]; pub global USER_DATA_ENCRYPTION_PK_BOUNDS: [Field; L] = [34359701504, 34359615488]; pub global USER_DATA_ENCRYPTION_E0_BOUND: Field = 20; pub global USER_DATA_ENCRYPTION_E1_BOUND: Field = 20; pub global USER_DATA_ENCRYPTION_U_BOUND: Field = 1; -pub global USER_DATA_ENCRYPTION_K1_LOW_BOUND: Field = 5; -pub global USER_DATA_ENCRYPTION_K1_UP_BOUND: Field = 4; -pub global USER_DATA_ENCRYPTION_R1_LOW_BOUNDS: [Field; L] = [261, 258]; -pub global USER_DATA_ENCRYPTION_R1_UP_BOUNDS: [Field; L] = [260, 258]; +pub global USER_DATA_ENCRYPTION_K1_LOW_BOUND: Field = 50; +pub global USER_DATA_ENCRYPTION_K1_UP_BOUND: Field = 49; +pub global USER_DATA_ENCRYPTION_R1_LOW_BOUNDS: [Field; L] = [301, 263]; +pub global USER_DATA_ENCRYPTION_R1_UP_BOUNDS: [Field; L] = [300, 263]; pub global USER_DATA_ENCRYPTION_R2_BOUNDS: [Field; L] = [34359701504, 34359615488]; pub global USER_DATA_ENCRYPTION_P1_BOUNDS: [Field; L] = [256, 256]; pub global USER_DATA_ENCRYPTION_P2_BOUNDS: [Field; L] = [34359701504, 34359615488]; -// greco - configs pub global USER_DATA_ENCRYPTION_CONFIGS: UserDataEncryptionConfigs = UserDataEncryptionConfigs::new( - Q_MOD_T, + USER_DATA_ENCRYPTION_Q_MOD_T_MOD_P, QIS, USER_DATA_ENCRYPTION_K0IS, USER_DATA_ENCRYPTION_PK_BOUNDS, diff --git a/crates/Dockerfile b/crates/Dockerfile index 5c4155b3ea..b8aedf9838 100644 --- a/crates/Dockerfile +++ b/crates/Dockerfile @@ -44,7 +44,6 @@ COPY --from=evm-builder /build/packages/enclave-contracts/deployed_contracts.jso # find crates/* -name "Cargo.toml" -not -path "*/support/*" -printf "COPY %p %p\n" | sed 's|COPY \(.*\) crates/|COPY \1 ./|' COPY crates/aggregator/Cargo.toml ./aggregator/Cargo.toml COPY crates/bfv-client/Cargo.toml ./bfv-client/Cargo.toml -COPY crates/greco-helpers/Cargo.toml ./greco-helpers/Cargo.toml COPY crates/cli/Cargo.toml ./cli/Cargo.toml COPY crates/ciphernode-builder/Cargo.toml ./ciphernode-builder/Cargo.toml COPY crates/compute-provider/Cargo.toml ./compute-provider/Cargo.toml diff --git a/crates/bfv-client/Cargo.toml b/crates/bfv-client/Cargo.toml index 3278d1b3d3..bce207d670 100644 --- a/crates/bfv-client/Cargo.toml +++ b/crates/bfv-client/Cargo.toml @@ -9,11 +9,9 @@ repository = "https://github.com/gnosisguild/enclave/crates/bfv-client" [dependencies] anyhow.workspace = true e3-fhe-params = { workspace = true } -e3-greco-helpers = { workspace = true } +e3-zk-helpers = { workspace = true } fhe.workspace = true fhe-traits.workspace = true -greco = { package = "zkfhe-greco", git = "https://github.com/gnosisguild/zkfhe-generator" } rand.workspace = true thiserror = { workspace = true } e3-polynomial = { workspace = true } -e3-zk-helpers = { workspace = true } diff --git a/crates/bfv-client/src/client.rs b/crates/bfv-client/src/client.rs index c9c6829cc4..7487daff81 100644 --- a/crates/bfv-client/src/client.rs +++ b/crates/bfv-client/src/client.rs @@ -5,18 +5,13 @@ // or FITNESS FOR A PARTICULAR PURPOSE. use anyhow::{anyhow, Result}; -use e3_fhe_params::build_bfv_params_arc; -use e3_greco_helpers::{bfv_ciphertext_to_greco, bfv_public_key_to_greco}; -use e3_polynomial::CrtPolynomial; -use e3_zk_helpers::commitments::{ - compute_ciphertext_commitment, compute_pk_aggregation_commitment, -}; -use e3_zk_helpers::utils::calculate_bit_width; -use fhe::bfv::{Ciphertext, Encoding, Plaintext, PublicKey}; +use e3_fhe_params::{build_bfv_params_arc, DEFAULT_BFV_PRESET}; +use e3_zk_helpers::circuits::threshold::user_data_encryption::Witness as UserDataEncryptionWitness; +use e3_zk_helpers::circuits::Computation; +use e3_zk_helpers::threshold::UserDataEncryptionCircuitInput; +use fhe::bfv::{Ciphertext, Encoding, Plaintext, PublicKey, SecretKey}; use fhe::Error as FheError; use fhe_traits::{DeserializeParametrized, FheEncoder, FheEncrypter, Serialize}; -use greco::bounds::GrecoBounds; -use greco::vectors::GrecoVectors; use rand::thread_rng; /// Encrypt some data using BFV homomorphic encryption @@ -106,33 +101,45 @@ where let plaintext = Plaintext::try_encode(&data, Encoding::poly(), ¶ms) .map_err(|e: FheError| anyhow!("Error encoding plaintext: {}", e))?; - let (cipher_text, u_rns, e0_rns, e1_rns) = pk - .try_encrypt_extended(&plaintext, &mut thread_rng()) - .map_err(|e| anyhow!("Error encrypting data: {}", e))?; + let witness = UserDataEncryptionWitness::compute( + DEFAULT_BFV_PRESET, + &UserDataEncryptionCircuitInput { + public_key: pk, + plaintext: plaintext, + }, + )?; - let (_, bounds) = GrecoBounds::compute(¶ms, 0)?; + let encrypted_data = witness.ciphertext.clone(); + let circuit_inputs = witness.to_json()?.to_string(); - let bit_pk = calculate_bit_width(&bounds.pk_bounds[0].to_string())?; + Ok(VerifiableEncryptionResult { + encrypted_data, + circuit_inputs, + }) +} - // Create Greco input validation ZK proof - let input_val_vectors = GrecoVectors::compute( - &plaintext, - &u_rns, - &e0_rns, - &e1_rns, - &cipher_text, - &pk, - ¶ms, - bit_pk, - ) - .map_err(|e| anyhow!("Error computing input validation vectors: {}", e))?; +/// Generates a new public/secret key pair and returns the public key. +/// +/// # Arguments +/// * `degree` - Polynomial degree for BFV parameters +/// * `plaintext_modulus` - Plaintext modulus for BFV parameters +/// * `moduli` - Vector of moduli for BFV parameters +/// +/// # Returns +/// Raw bytes of the public key +pub fn generate_public_key( + degree: usize, + plaintext_modulus: u64, + moduli: Vec, +) -> Result> { + let params = build_bfv_params_arc(degree, plaintext_modulus, &moduli, None); - let standard_input_val = input_val_vectors.standard_form(); + // Generate keys. + let mut rng = thread_rng(); + let sk = SecretKey::random(¶ms, &mut rng); + let pk = PublicKey::new(&sk, &mut rng); - Ok(VerifiableEncryptionResult { - encrypted_data: cipher_text.to_bytes(), - circuit_inputs: standard_input_val.to_json().to_string(), - }) + Ok(pk.to_bytes()) } pub fn compute_pk_commitment( @@ -141,39 +148,17 @@ pub fn compute_pk_commitment( plaintext_modulus: u64, moduli: Vec, ) -> Result<[u8; 32]> { + use e3_zk_helpers::circuits::threshold::user_data_encryption::utils::compute_public_key_commitment; + let params = build_bfv_params_arc(degree, plaintext_modulus, &moduli, None); let public_key = PublicKey::from_bytes(&public_key, ¶ms) .map_err(|e| anyhow!("Error deserializing public key: {}", e))?; - let (_, bounds) = GrecoBounds::compute(¶ms, 0)?; - let bit_pk = calculate_bit_width(&bounds.pk_bounds[0].to_string())?; - - let (pk0is, pk1is) = bfv_public_key_to_greco(&public_key, ¶ms); + let commitment = compute_public_key_commitment(¶ms, &public_key) + .map_err(|e| anyhow!("Error computing public key commitment: {}", e))?; - let pk0 = CrtPolynomial::from_bigint_vectors(pk0is); - let pk1 = CrtPolynomial::from_bigint_vectors(pk1is); - - let commitment_bigint = compute_pk_aggregation_commitment(&pk0, &pk1, bit_pk); - - let bytes = commitment_bigint.to_bytes_be().1; - - if bytes.len() > 32 { - return Err(anyhow!( - "Commitment must be at most 32 bytes, got {}", - bytes.len() - )); - } - - let mut padded_bytes = vec![0u8; 32]; - let start_idx = 32 - bytes.len(); - padded_bytes[start_idx..].copy_from_slice(&bytes); - - let public_key_hash: [u8; 32] = padded_bytes - .try_into() - .map_err(|_| anyhow!("Failed to convert padded bytes to array"))?; - - Ok(public_key_hash) + Ok(commitment) } pub fn compute_ct_commitment( @@ -182,39 +167,17 @@ pub fn compute_ct_commitment( plaintext_modulus: u64, moduli: Vec, ) -> Result<[u8; 32]> { + use e3_zk_helpers::circuits::threshold::user_data_encryption::utils::compute_ciphertext_commitment; + let params = build_bfv_params_arc(degree, plaintext_modulus, &moduli, None); let ct = Ciphertext::from_bytes(&ct, ¶ms) .map_err(|e| anyhow!("Error deserializing ciphertext: {}", e))?; - let (ct0is, ct1is) = bfv_ciphertext_to_greco(&ct, ¶ms); - - let (_, bounds) = GrecoBounds::compute(¶ms, 0)?; - let bit_ct = calculate_bit_width(&bounds.pk_bounds[0].to_string())?; - - let ct0 = CrtPolynomial::from_bigint_vectors(ct0is); - let ct1 = CrtPolynomial::from_bigint_vectors(ct1is); - - let commitment_bigint = compute_ciphertext_commitment(&ct0, &ct1, bit_ct); - - let bytes = commitment_bigint.to_bytes_be().1; - - if bytes.len() > 32 { - return Err(anyhow!( - "Commitment must be at most 32 bytes, got {}", - bytes.len() - )); - } - - let mut padded_bytes = vec![0u8; 32]; - let start_idx = 32 - bytes.len(); - padded_bytes[start_idx..].copy_from_slice(&bytes); - - let ciphertext_hash: [u8; 32] = padded_bytes - .try_into() - .map_err(|_| anyhow!("Failed to convert padded bytes to array"))?; + let commitment = compute_ciphertext_commitment(¶ms, &ct) + .map_err(|e| anyhow!("Error computing ciphertext commitment: {}", e))?; - Ok(ciphertext_hash) + Ok(commitment) } #[cfg(test)] diff --git a/crates/fhe-params/src/constants.rs b/crates/fhe-params/src/constants.rs index ee35c7641c..d072259df0 100644 --- a/crates/fhe-params/src/constants.rs +++ b/crates/fhe-params/src/constants.rs @@ -16,7 +16,7 @@ pub mod insecure_512 { /// Threshold BFV parameters pub mod threshold { - pub const PLAINTEXT_MODULUS: u64 = 10; + pub const PLAINTEXT_MODULUS: u64 = 100; pub const MODULI: &[u64] = &[0xffffee001, 0xffffc4001]; pub const ERROR1_VARIANCE: &str = "3"; pub const ERROR1_VARIANCE_BIGUINT: u32 = 3; diff --git a/crates/greco-helpers/Cargo.toml b/crates/greco-helpers/Cargo.toml deleted file mode 100644 index cec4b15967..0000000000 --- a/crates/greco-helpers/Cargo.toml +++ /dev/null @@ -1,19 +0,0 @@ -[package] -name = "e3-greco-helpers" -version.workspace = true -edition.workspace = true -license.workspace = true -description = "E3 - Greco conversion helpers" -repository = "https://github.com/gnosisguild/enclave/crates/greco-helpers" - -[dependencies] -fhe = { workspace = true } -fhe-math = { git = "https://github.com/gnosisguild/fhe.rs" } -num-bigint = { workspace = true } -e3-zk-helpers = { workspace = true } - -[dev-dependencies] -e3-fhe-params = { workspace = true } -fhe-traits = { workspace = true } -greco = { package = "zkfhe-greco", git = "https://github.com/gnosisguild/zkfhe-generator" } -rand = { workspace = true } diff --git a/crates/greco-helpers/src/lib.rs b/crates/greco-helpers/src/lib.rs deleted file mode 100644 index c3760b5fc5..0000000000 --- a/crates/greco-helpers/src/lib.rs +++ /dev/null @@ -1,355 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-only -// -// This file is provided WITHOUT ANY WARRANTY; -// without even the implied warranty of MERCHANTABILITY -// or FITNESS FOR A PARTICULAR PURPOSE. - -use e3_zk_helpers::utils::get_zkp_modulus; -use fhe::bfv::{BfvParameters, Ciphertext, PublicKey}; -use fhe_math::rq::Representation; -use num_bigint::BigInt; -use std::sync::Arc; - -/// Converts a BFV coefficient (in [0, qi)) to centered format [-(qi-1)/2, (qi-1)/2]. -fn convert_bfv_coefficient_to_centered(coeff: u64, qi: u64) -> BigInt { - let qi_bigint = BigInt::from(qi); - let coeff_bigint = BigInt::from(coeff); - - // Center: convert from [0, qi) to [-(qi-1)/2, (qi-1)/2] - // If coeff > qi/2, it represents a negative centered value - if coeff > (qi / 2) { - &coeff_bigint - &qi_bigint - } else { - coeff_bigint - } -} - -/// Converts BFV coefficients to greco-formatted coefficients (centered, reversed, standard form). -fn convert_bfv_coefficients_to_greco( - bfv_coeffs: &[u64], - qi: u64, - zkp_modulus: &BigInt, -) -> Vec { - bfv_coeffs - .iter() - .rev() - .map(|coeff| { - let centered = convert_bfv_coefficient_to_centered(*coeff, qi); - // Reduce mod ZKP modulus to get standard form - // Handle negative values correctly - let centered_mod = centered % zkp_modulus; - if centered_mod < BigInt::from(0) { - centered_mod + zkp_modulus - } else { - centered_mod - } - }) - .collect() -} - -/// Converts a BFV ciphertext to Greco format. -/// -/// Takes a BFV ciphertext and converts it to Greco format, returning ct0is and ct1is -/// as vectors of coefficient vectors (one vector per modulus, standard form). -/// -/// # Arguments -/// * `ct` - BFV ciphertext -/// * `params` - BFV parameters -/// -/// # Returns -/// A tuple of (ct0is, ct1is) where each is Vec> (one vector per modulus) -pub fn bfv_ciphertext_to_greco( - ct: &Ciphertext, - params: &Arc, -) -> (Vec>, Vec>) { - let moduli = params.moduli(); - let degree = params.degree(); - let zkp_modulus = get_zkp_modulus(); - - let ct0_poly = &ct.c[0]; - let ct1_poly = &ct.c[1]; - - let mut ct0_power = ct0_poly.clone(); - let mut ct1_power = ct1_poly.clone(); - ct0_power.change_representation(Representation::PowerBasis); - ct1_power.change_representation(Representation::PowerBasis); - - let mut ct0is = Vec::with_capacity(moduli.len()); - let mut ct1is = Vec::with_capacity(moduli.len()); - - for (i, qi) in moduli.iter().enumerate() { - let mut ct0_modulus = Vec::with_capacity(degree); - let mut ct1_modulus = Vec::with_capacity(degree); - - for j in 0..degree { - let ct0_coeff = ct0_power.coefficients()[(i, j)]; - let ct1_coeff = ct1_power.coefficients()[(i, j)]; - - ct0_modulus.push(ct0_coeff); - ct1_modulus.push(ct1_coeff); - } - - ct0is.push(convert_bfv_coefficients_to_greco( - &ct0_modulus, - *qi, - &zkp_modulus, - )); - ct1is.push(convert_bfv_coefficients_to_greco( - &ct1_modulus, - *qi, - &zkp_modulus, - )); - } - - (ct0is, ct1is) -} - -/// Converts a BFV public key to Greco format. -/// -/// Takes a BFV public key and converts it to Greco format, returning pk0is and pk1is -/// as vectors of coefficient vectors (one vector per modulus, standard form). -/// -/// # Arguments -/// * `pk` - BFV public key -/// * `params` - BFV parameters -/// -/// # Returns -/// A tuple of (pk0is, pk1is) where each is Vec> (one vector per modulus) -pub fn bfv_public_key_to_greco( - pk: &PublicKey, - params: &Arc, -) -> (Vec>, Vec>) { - let moduli = params.moduli(); - let degree = params.degree(); - let zkp_modulus = get_zkp_modulus(); - - // Access pk0 and pk1 polynomials from the public key - // PublicKey has a .c field that is a Ciphertext, which contains .c with the polynomials - let pk0_poly = &pk.c.c[0]; - let pk1_poly = &pk.c.c[1]; - - // Convert polynomials to power basis representation to access coefficients - let mut pk0_power = pk0_poly.clone(); - let mut pk1_power = pk1_poly.clone(); - pk0_power.change_representation(Representation::PowerBasis); - pk1_power.change_representation(Representation::PowerBasis); - - let mut pk0is = Vec::with_capacity(moduli.len()); - let mut pk1is = Vec::with_capacity(moduli.len()); - - // Extract coefficients for each modulus - for (i, qi) in moduli.iter().enumerate() { - let mut pk0_modulus = Vec::with_capacity(degree); - let mut pk1_modulus = Vec::with_capacity(degree); - - for j in 0..degree { - // Access coefficient at (modulus_index, coefficient_index) - let pk0_coeff = pk0_power.coefficients()[(i, j)]; - let pk1_coeff = pk1_power.coefficients()[(i, j)]; - - pk0_modulus.push(pk0_coeff); - pk1_modulus.push(pk1_coeff); - } - - // Convert to greco format (centers, reverses, and reduces mod ZKP modulus) - pk0is.push(convert_bfv_coefficients_to_greco( - &pk0_modulus, - *qi, - &zkp_modulus, - )); - pk1is.push(convert_bfv_coefficients_to_greco( - &pk1_modulus, - *qi, - &zkp_modulus, - )); - } - - (pk0is, pk1is) -} - -#[cfg(test)] -mod tests { - use super::*; - use e3_fhe_params::BfvParamSet; - use e3_fhe_params::DEFAULT_BFV_PRESET; - use e3_zk_helpers::utils::calculate_bit_width; - use fhe::bfv::{Encoding, Plaintext, PublicKey, SecretKey}; - use fhe_traits::FheEncoder; - use greco::bounds::GrecoBounds; - use greco::vectors::GrecoVectors; - use rand::thread_rng; - - #[test] - fn test_bfv_public_key_to_greco() { - let params = BfvParamSet::from(DEFAULT_BFV_PRESET).build_arc(); - - let mut rng = thread_rng(); - let sk = SecretKey::random(¶ms, &mut rng); - let pk = PublicKey::new(&sk, &mut rng); - - // Get expected pk0is and pk1is from GrecoVectors - let (_, bounds) = GrecoBounds::compute(¶ms, 0).unwrap(); - let bit_pk = calculate_bit_width(&bounds.pk_bounds[0].to_string()).unwrap(); - - let vote = vec![1u64, 0u64, 0u64]; - let pt = Plaintext::try_encode(&vote, Encoding::poly(), ¶ms).unwrap(); - let (ct, u_rns, e0_rns, e1_rns) = pk.try_encrypt_extended(&pt, &mut rng).unwrap(); - - let greco_vectors = - GrecoVectors::compute(&pt, &u_rns, &e0_rns, &e1_rns, &ct, &pk, ¶ms, bit_pk) - .unwrap(); - let standard_vectors = greco_vectors.standard_form(); - let expected_pk0is = &standard_vectors.pk0is; - let expected_pk1is = &standard_vectors.pk1is; - - // Convert using our function - let (actual_pk0is, actual_pk1is) = bfv_public_key_to_greco(&pk, ¶ms); - - // Verify the structure matches - assert_eq!(actual_pk0is.len(), expected_pk0is.len()); - assert_eq!(actual_pk1is.len(), expected_pk1is.len()); - assert_eq!(actual_pk0is.len(), params.moduli().len()); - - // Verify coefficients match for each modulus - for (i, (actual_pk0i, expected_pk0i)) in - actual_pk0is.iter().zip(expected_pk0is.iter()).enumerate() - { - assert_eq!( - actual_pk0i.len(), - expected_pk0i.len(), - "pk0is[{}] length mismatch", - i - ); - assert_eq!( - actual_pk0i.len(), - params.degree(), - "pk0is[{}] should have degree coefficients", - i - ); - - for (j, (actual_coeff, expected_coeff)) in - actual_pk0i.iter().zip(expected_pk0i.iter()).enumerate() - { - assert_eq!( - actual_coeff, expected_coeff, - "pk0is[{}][{}] coefficient mismatch", - i, j - ); - } - } - - for (i, (actual_pk1i, expected_pk1i)) in - actual_pk1is.iter().zip(expected_pk1is.iter()).enumerate() - { - assert_eq!( - actual_pk1i.len(), - expected_pk1i.len(), - "pk1is[{}] length mismatch", - i - ); - assert_eq!( - actual_pk1i.len(), - params.degree(), - "pk1is[{}] should have degree coefficients", - i - ); - - for (j, (actual_coeff, expected_coeff)) in - actual_pk1i.iter().zip(expected_pk1i.iter()).enumerate() - { - assert_eq!( - actual_coeff, expected_coeff, - "pk1is[{}][{}] coefficient mismatch", - i, j - ); - } - } - } - - #[test] - fn test_bfv_ciphertext_to_greco() { - let params = BfvParamSet::from(DEFAULT_BFV_PRESET).build_arc(); - - let mut rng = thread_rng(); - let sk = SecretKey::random(¶ms, &mut rng); - let pk = PublicKey::new(&sk, &mut rng); - - // Get expected ct0is and ct1is from GrecoVectors - let (_, bounds) = GrecoBounds::compute(¶ms, 0).unwrap(); - let bit_pk = calculate_bit_width(&bounds.pk_bounds[0].to_string()).unwrap(); - - let vote = vec![1u64, 0u64, 0u64]; - let pt = Plaintext::try_encode(&vote, Encoding::poly(), ¶ms).unwrap(); - let (ct, u_rns, e0_rns, e1_rns) = pk.try_encrypt_extended(&pt, &mut rng).unwrap(); - - let greco_vectors = - GrecoVectors::compute(&pt, &u_rns, &e0_rns, &e1_rns, &ct, &pk, ¶ms, bit_pk) - .unwrap(); - let standard_vectors = greco_vectors.standard_form(); - let expected_ct0is = &standard_vectors.ct0is; - let expected_ct1is = &standard_vectors.ct1is; - - // Convert using our function - let (actual_ct0is, actual_ct1is) = bfv_ciphertext_to_greco(&ct, ¶ms); - - // Verify the structure matches - assert_eq!(actual_ct0is.len(), expected_ct0is.len()); - assert_eq!(actual_ct1is.len(), expected_ct1is.len()); - assert_eq!(actual_ct0is.len(), params.moduli().len()); - - // Verify coefficients match for each modulus - for (i, (actual_ct0i, expected_ct0i)) in - actual_ct0is.iter().zip(expected_ct0is.iter()).enumerate() - { - assert_eq!( - actual_ct0i.len(), - expected_ct0i.len(), - "ct0is[{}] length mismatch", - i - ); - assert_eq!( - actual_ct0i.len(), - params.degree(), - "ct0is[{}] should have degree coefficients", - i - ); - - for (j, (actual_coeff, expected_coeff)) in - actual_ct0i.iter().zip(expected_ct0i.iter()).enumerate() - { - assert_eq!( - actual_coeff, expected_coeff, - "ct0is[{}][{}] coefficient mismatch", - i, j - ); - } - } - - for (i, (actual_ct1i, expected_ct1i)) in - actual_ct1is.iter().zip(expected_ct1is.iter()).enumerate() - { - assert_eq!( - actual_ct1i.len(), - expected_ct1i.len(), - "ct1is[{}] length mismatch", - i - ); - assert_eq!( - actual_ct1i.len(), - params.degree(), - "ct1is[{}] should have degree coefficients", - i - ); - - for (j, (actual_coeff, expected_coeff)) in - actual_ct1i.iter().zip(expected_ct1i.iter()).enumerate() - { - assert_eq!( - actual_coeff, expected_coeff, - "ct1is[{}][{}] coefficient mismatch", - i, j - ); - } - } - } -} diff --git a/crates/wasm/src/lib.rs b/crates/wasm/src/lib.rs index a187a4734b..62bf299cf7 100644 --- a/crates/wasm/src/lib.rs +++ b/crates/wasm/src/lib.rs @@ -6,6 +6,7 @@ use e3_bfv_client::client::{ bfv_encrypt, bfv_verifiable_encrypt, compute_pk_commitment as _compute_pk_commitment, + generate_public_key as _generate_public_key, }; use e3_fhe_params::{BfvParamSet, BfvPreset}; use serde::{Deserialize, Serialize}; @@ -41,7 +42,18 @@ pub fn bfv_encrypt_number( Ok(encrypted_data) } +/// Generate a public key from JavaScript. #[wasm_bindgen] +pub fn generate_public_key( + degree: usize, + plaintext_modulus: u64, + moduli: Vec, +) -> Result, JsValue> { + let public_key = _generate_public_key(degree, plaintext_modulus, moduli) + .map_err(|e| JsValue::from_str(&format!("{}", e)))?; + Ok(public_key) +} + /// A function to compute the public key commitment for a given public key. /// /// # Arguments @@ -54,6 +66,7 @@ pub fn bfv_encrypt_number( /// # Panics /// /// Panics if the public key cannot be computed +#[wasm_bindgen] pub fn compute_pk_commitment( public_key: Vec, degree: usize, diff --git a/crates/zk-helpers/Cargo.toml b/crates/zk-helpers/Cargo.toml index 750dbe3d48..6624dc343c 100644 --- a/crates/zk-helpers/Cargo.toml +++ b/crates/zk-helpers/Cargo.toml @@ -16,6 +16,7 @@ e3-safe = { workspace = true } e3-fhe-params = { workspace = true } fhe = { workspace = true } fhe-math = { workspace = true } +fhe-traits = { workspace = true } num-bigint = { workspace = true } num-traits = { workspace = true } thiserror = { workspace = true } diff --git a/crates/zk-helpers/src/bin/zk_cli.rs b/crates/zk-helpers/src/bin/zk_cli.rs index ede0f515f6..d29475d8bb 100644 --- a/crates/zk-helpers/src/bin/zk_cli.rs +++ b/crates/zk-helpers/src/bin/zk_cli.rs @@ -12,7 +12,7 @@ use anyhow::{anyhow, Context, Result}; use clap::{arg, command, Parser}; -use e3_fhe_params::{build_pair_for_preset, BfvPreset, ParameterType}; +use e3_fhe_params::{BfvPreset, ParameterType}; use e3_zk_helpers::ciphernodes_committee::CiphernodesCommitteeSize; use e3_zk_helpers::circuits::dkg::pk::circuit::{PkCircuit, PkCircuitInput}; use e3_zk_helpers::circuits::dkg::share_computation::circuit::{ @@ -21,6 +21,9 @@ use e3_zk_helpers::circuits::dkg::share_computation::circuit::{ use e3_zk_helpers::codegen::{write_artifacts, CircuitCodegen}; use e3_zk_helpers::computation::DkgInputType; use e3_zk_helpers::registry::{Circuit, CircuitRegistry}; +use e3_zk_helpers::threshold::{ + UserDataEncryptionCircuit, UserDataEncryptionCircuitInput, UserDataEncryptionSample, +}; use e3_zk_helpers::{PkSample, ShareComputationSample}; use std::io::Write; use std::path::PathBuf; @@ -149,6 +152,7 @@ fn main() -> Result<()> { let mut registry = CircuitRegistry::new(); registry.register(Arc::new(PkCircuit)); registry.register(Arc::new(ShareComputationCircuit)); + registry.register(Arc::new(UserDataEncryptionCircuit)); // Handle list circuits flag. if args.list_circuits { @@ -179,10 +183,6 @@ fn main() -> Result<()> { anyhow!("unknown circuit: {}. Available: {}", circuit, available) })?; - // Build threshold and DKG params from the preset (insecure → 512, secure → 8192). - let (threshold_params, dkg_params) = - build_pair_for_preset(preset).map_err(|e| anyhow!("failed to build params: {}", e))?; - // Validate preset matches circuit's supported parameter type (THRESHOLD or DKG). let circuit_param_type = circuit_meta.supported_parameter(); let preset_ok = match circuit_param_type { @@ -239,11 +239,7 @@ fn main() -> Result<()> { let circuit_name = circuit_meta.name(); let artifacts = match circuit_name { name if name == ::NAME => { - let sample = PkSample::generate( - &threshold_params, - &dkg_params, - CiphernodesCommitteeSize::Small, - )?; + let sample = PkSample::generate(preset, CiphernodesCommitteeSize::Small); let circuit = PkCircuit; circuit.codegen( preset, @@ -257,13 +253,13 @@ fn main() -> Result<()> { .search_defaults() .ok_or_else(|| anyhow!("missing search_defaults for preset"))?; let sample = ShareComputationSample::generate( - &threshold_params, - &dkg_params, + preset, CiphernodesCommitteeSize::Small, dkg_input_type, sd.z, sd.lambda, - )?; + ); + let circuit = ShareComputationCircuit; circuit.codegen( preset, @@ -277,6 +273,18 @@ fn main() -> Result<()> { }, )? } + name if name == ::NAME => { + let sample = UserDataEncryptionSample::generate(preset); + let circuit = UserDataEncryptionCircuit; + + circuit.codegen( + preset, + &UserDataEncryptionCircuitInput { + public_key: sample.public_key, + plaintext: sample.plaintext, + }, + )? + } name => return Err(anyhow!("circuit {} not yet implemented", name)), }; diff --git a/crates/zk-helpers/src/circuits/codegen.rs b/crates/zk-helpers/src/circuits/codegen.rs index 538be4217a..e3f8a8d8f3 100644 --- a/crates/zk-helpers/src/circuits/codegen.rs +++ b/crates/zk-helpers/src/circuits/codegen.rs @@ -9,46 +9,45 @@ //! [`CircuitCodegen`] is implemented by circuits that can produce [`Artifacts`] //! (Prover.toml and configs.nr). Use [`write_artifacts`] to write them to disk. -use crate::computation::Configs; -use crate::computation::Toml; use crate::errors::CircuitsErrors; use std::path::Path; +/// Prover TOML file content (witness and circuit inputs). +pub type CodegenToml = String; +/// Noir configs file content (global constants for the prover). +pub type CodegenConfigs = String; + /// Generated files for a circuit: Prover TOML and Noir configs. #[derive(Debug, Clone)] pub struct Artifacts { /// Prover.toml content (witness and circuit inputs). - pub toml: Toml, + pub toml: CodegenToml, /// configs.nr content (constants for the Noir prover). - pub configs: Configs, + pub configs: CodegenConfigs, } /// Trait for circuits that can generate Prover.toml and configs.nr from circuit-specific input. pub trait CircuitCodegen: crate::registry::Circuit { /// Circuit-specific BFV threshold parameters preset. - type BfvThresholdParametersPreset; + type Preset; /// Circuit-specific codegen input (e.g. preset + public key). type Input; /// Error type for codegen failures. type Error; /// Produces [`Artifacts`] for this circuit from the given input. - fn codegen( - &self, - preset: Self::BfvThresholdParametersPreset, - input: &Self::Input, - ) -> Result; + fn codegen(&self, preset: Self::Preset, input: &Self::Input) -> Result; } /// Writes the Prover TOML string to `path/Prover.toml`, or `./Prover.toml` if `path` is `None`. -pub fn write_toml(toml: &Toml, path: Option<&Path>) -> Result<(), CircuitsErrors> { +pub fn write_toml(toml: &CodegenToml, path: Option<&Path>) -> Result<(), CircuitsErrors> { let toml_path = path.unwrap_or_else(|| Path::new(".")); let toml_path = toml_path.join("Prover.toml"); Ok(std::fs::write(toml_path, toml)?) } /// Writes the Noir configs string to `path/configs.nr`, or `./configs.nr` if `path` is `None`. -pub fn write_configs(configs: &Configs, path: Option<&Path>) -> Result<(), CircuitsErrors> { +pub fn write_configs(configs: &CodegenConfigs, path: Option<&Path>) -> Result<(), CircuitsErrors> { let configs_path = path.unwrap_or_else(|| Path::new(".")); let configs_path = configs_path.join("configs.nr"); Ok(std::fs::write(configs_path, configs)?) @@ -57,8 +56,8 @@ pub fn write_configs(configs: &Configs, path: Option<&Path>) -> Result<(), Circu /// Writes Prover.toml (if `toml` is `Some`) and always configs.nr into the given directory /// (or current directory if `path` is `None`). pub fn write_artifacts( - toml: Option<&Toml>, - configs: &Configs, + toml: Option<&CodegenToml>, + configs: &CodegenConfigs, path: Option<&Path>, ) -> Result<(), CircuitsErrors> { if let Some(t) = toml { diff --git a/crates/zk-helpers/src/circuits/computation.rs b/crates/zk-helpers/src/circuits/computation.rs index 2178a83b8d..1eed828568 100644 --- a/crates/zk-helpers/src/circuits/computation.rs +++ b/crates/zk-helpers/src/circuits/computation.rs @@ -19,46 +19,32 @@ pub enum DkgInputType { SmudgingNoise, } -/// Prover TOML file content (witness and circuit inputs). -pub type Toml = String; -/// Noir configs file content (global constants for the prover). -pub type Configs = String; - /// Generic computation from parameters and input to a result. pub trait Computation: Sized { - type BfvThresholdParametersPreset; + type Preset; type Input; type Error; /// Computes the result from parameters and input. - fn compute( - preset: Self::BfvThresholdParametersPreset, - input: &Self::Input, - ) -> Result; + fn compute(preset: Self::Preset, input: &Self::Input) -> Result; + + /// Converts the result to a JSON [`serde_json::Value`] for serialization. + /// Default: `serde_json::to_value(self)` when `Self: serde::Serialize`. + fn to_json(&self) -> serde_json::Result + where + Self: serde::Serialize, + { + serde_json::to_value(self) + } } /// Circuit-specific computation: parameters and input produce bounds, bits, witness, etc. pub trait CircuitComputation: crate::registry::Circuit { - type BfvThresholdParametersPreset; + type Preset; type Input; type Output; type Error; /// Computes circuit-specific data (bounds, bits, witness) from parameters and input. - fn compute( - preset: Self::BfvThresholdParametersPreset, - input: &Self::Input, - ) -> Result; -} - -/// Converts a value to a JSON [`serde_json::Value`] for serialization. -pub trait ConvertToJson { - fn convert_to_json(&self) -> serde_json::Result; -} - -/// Any `Serialize` type can be converted to JSON for round-trip tests and artifact generation. -impl ConvertToJson for T { - fn convert_to_json(&self) -> serde_json::Result { - serde_json::to_value(self) - } + fn compute(preset: Self::Preset, input: &Self::Input) -> Result; } diff --git a/crates/zk-helpers/src/circuits/dkg/pk/codegen.rs b/crates/zk-helpers/src/circuits/dkg/pk/codegen.rs index 219fb0894b..8c3d99b025 100644 --- a/crates/zk-helpers/src/circuits/dkg/pk/codegen.rs +++ b/crates/zk-helpers/src/circuits/dkg/pk/codegen.rs @@ -6,27 +6,27 @@ //! Code generation for the public-key BFV circuit: Prover.toml and configs.nr. -use crate::circuits::dkg::pk::circuit::{PkCircuit, PkCircuitInput}; -use crate::{ - crt_polynomial_to_toml_json, Artifacts, Bits, Circuit, CircuitCodegen, CircuitComputation, - CircuitsErrors, Configs, PkComputationOutput, Toml, Witness, -}; +use crate::circuits::dkg::pk::circuit::PkCircuit; +use crate::circuits::dkg::pk::circuit::PkCircuitInput; +use crate::circuits::dkg::pk::computation::{Bits, PkComputationOutput, Witness}; +use crate::Artifacts; +use crate::Circuit; +use crate::CircuitCodegen; +use crate::CircuitComputation; +use crate::CircuitsErrors; +use crate::CodegenConfigs; +use crate::CodegenToml; +use crate::Computation; use e3_fhe_params::BfvPreset; -use serde::{Deserialize, Serialize}; -use serde_json; /// Implementation of [`CircuitCodegen`] for [`PkCircuit`]. impl CircuitCodegen for PkCircuit { - type BfvThresholdParametersPreset = BfvPreset; + type Preset = BfvPreset; type Input = PkCircuitInput; type Error = CircuitsErrors; - fn codegen( - &self, - preset: Self::BfvThresholdParametersPreset, - input: &Self::Input, - ) -> Result { + fn codegen(&self, preset: Self::Preset, input: &Self::Input) -> Result { let PkComputationOutput { witness, bits, .. } = PkCircuit::compute(preset, input)?; let toml = generate_toml(witness)?; @@ -36,27 +36,17 @@ impl CircuitCodegen for PkCircuit { } } -/// JSON-serializable structure for Prover.toml (pk0is, pk1is arrays). -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct TomlJson { - /// First component of the public key per modulus (for the prover). - pub pk0is: Vec, - /// Second component of the public key per modulus (for the prover). - pub pk1is: Vec, -} - /// Builds the Prover TOML string from the pk witness (pk0is, pk1is). -pub fn generate_toml(witness: Witness) -> Result { - let pk0is = crt_polynomial_to_toml_json(&witness.pk0is); - let pk1is = crt_polynomial_to_toml_json(&witness.pk1is); +pub fn generate_toml(witness: Witness) -> Result { + let json = witness + .to_json() + .map_err(|e| CircuitsErrors::SerdeJson(e))?; - let toml_json = TomlJson { pk0is, pk1is }; - - Ok(toml::to_string(&toml_json)?) + Ok(toml::to_string(&json)?) } /// Builds the configs.nr string (N, L, bit parameters) for the Noir prover. -pub fn generate_configs(preset: BfvPreset, bits: &Bits) -> Configs { +pub fn generate_configs(preset: BfvPreset, bits: &Bits) -> CodegenConfigs { format!( r#" pub global N: u32 = {}; @@ -82,18 +72,18 @@ pub global {}_BIT_PK: u32 = {}; mod tests { use super::*; use crate::ciphernodes_committee::CiphernodesCommitteeSize; - use crate::circuits::computation::Computation; use crate::codegen::write_artifacts; use crate::prepare_pk_sample_for_test; - use crate::Bounds; - use e3_fhe_params::DEFAULT_BFV_PRESET; + use crate::utils::compute_pk_bit; + + use e3_fhe_params::{build_pair_for_preset, DEFAULT_BFV_PRESET}; use tempfile::TempDir; #[test] fn test_toml_generation_and_structure() { + let (_, dkg_params) = build_pair_for_preset(DEFAULT_BFV_PRESET).unwrap(); let sample = - prepare_pk_sample_for_test(DEFAULT_BFV_PRESET, CiphernodesCommitteeSize::Small) - .unwrap(); + prepare_pk_sample_for_test(DEFAULT_BFV_PRESET, CiphernodesCommitteeSize::Small); let artifacts = PkCircuit .codegen( @@ -138,8 +128,7 @@ mod tests { assert!(configs_path.exists()); let configs_content = std::fs::read_to_string(&configs_path).unwrap(); - let bounds = Bounds::compute(DEFAULT_BFV_PRESET, &()).unwrap(); - let bits = Bits::compute(DEFAULT_BFV_PRESET, &bounds).unwrap(); + let pk_bit = compute_pk_bit(&dkg_params); assert!(configs_content .contains(format!("N: u32 = {}", DEFAULT_BFV_PRESET.metadata().degree).as_str())); @@ -149,7 +138,7 @@ mod tests { format!( "{}_BIT_PK: u32 = {}", ::PREFIX, - bits.pk_bit + pk_bit ) .as_str() )); diff --git a/crates/zk-helpers/src/circuits/dkg/pk/computation.rs b/crates/zk-helpers/src/circuits/dkg/pk/computation.rs index ed371db3cc..2f4ebe3e5f 100644 --- a/crates/zk-helpers/src/circuits/dkg/pk/computation.rs +++ b/crates/zk-helpers/src/circuits/dkg/pk/computation.rs @@ -9,11 +9,12 @@ //! [`Constants`], [`Bounds`], [`Bits`], and [`Witness`] are produced from BFV parameters //! and (for witness) a public key. They implement [`Computation`] and are used by codegen. -use crate::calculate_bit_width; -use crate::dkg::pk::PkCircuitInput; +use crate::circuits::dkg::pk::circuit::PkCircuit; +use crate::circuits::dkg::pk::circuit::PkCircuitInput; +use crate::crt_polynomial_to_toml_json; use crate::get_zkp_modulus; +use crate::utils::compute_pk_bit; use crate::CircuitsErrors; -use crate::PkCircuit; use crate::{CircuitComputation, Computation}; use e3_fhe_params::build_pair_for_preset; use e3_fhe_params::BfvPreset; @@ -31,17 +32,14 @@ pub struct PkComputationOutput { /// Implementation of [`CircuitComputation`] for [`PkCircuit`]. impl CircuitComputation for PkCircuit { - type BfvThresholdParametersPreset = BfvPreset; + type Preset = BfvPreset; type Input = PkCircuitInput; type Output = PkComputationOutput; type Error = CircuitsErrors; - fn compute( - preset: Self::BfvThresholdParametersPreset, - input: &Self::Input, - ) -> Result { + fn compute(preset: Self::Preset, input: &Self::Input) -> Result { let bounds = Bounds::compute(preset, &())?; - let bits = Bits::compute(preset, &bounds)?; + let bits = Bits::compute(preset, &())?; let witness = Witness::compute(preset, input)?; Ok(PkComputationOutput { @@ -83,20 +81,17 @@ pub struct Witness { } impl Computation for Configs { - type BfvThresholdParametersPreset = BfvPreset; + type Preset = BfvPreset; type Input = (); type Error = CircuitsErrors; - fn compute( - preset: Self::BfvThresholdParametersPreset, - _: &Self::Input, - ) -> Result { + fn compute(preset: Self::Preset, _: &Self::Input) -> Result { let (_, dkg_params) = build_pair_for_preset(preset).map_err(|e| CircuitsErrors::Sample(e.to_string()))?; let moduli = dkg_params.moduli().to_vec(); let bounds = Bounds::compute(preset, &())?; - let bits = Bits::compute(preset, &bounds)?; + let bits = Bits::compute(preset, &())?; Ok(Configs { n: dkg_params.degree(), @@ -109,29 +104,26 @@ impl Computation for Configs { } impl Computation for Bits { - type BfvThresholdParametersPreset = BfvPreset; - type Input = Bounds; - type Error = crate::utils::ZkHelpersUtilsError; - - fn compute( - _: Self::BfvThresholdParametersPreset, - input: &Self::Input, - ) -> Result { + type Preset = BfvPreset; + type Input = (); + type Error = CircuitsErrors; + + fn compute(preset: Self::Preset, _: &Self::Input) -> Result { + let (_, dkg_params) = + build_pair_for_preset(preset).map_err(|e| CircuitsErrors::Sample(e.to_string()))?; + Ok(Bits { - pk_bit: calculate_bit_width(&input.pk_bound.to_string())?, + pk_bit: compute_pk_bit(&dkg_params), }) } } impl Computation for Bounds { - type BfvThresholdParametersPreset = BfvPreset; + type Preset = BfvPreset; type Input = (); type Error = CircuitsErrors; - fn compute( - preset: Self::BfvThresholdParametersPreset, - _: &Self::Input, - ) -> Result { + fn compute(preset: Self::Preset, _: &Self::Input) -> Result { let (_, dkg_params) = build_pair_for_preset(preset).map_err(|e| CircuitsErrors::Sample(e.to_string()))?; @@ -152,14 +144,11 @@ impl Computation for Bounds { } impl Computation for Witness { - type BfvThresholdParametersPreset = BfvPreset; + type Preset = BfvPreset; type Input = PkCircuitInput; type Error = CircuitsErrors; - fn compute( - preset: Self::BfvThresholdParametersPreset, - input: &Self::Input, - ) -> Result { + fn compute(preset: Self::Preset, input: &Self::Input) -> Result { let (_, dkg_params) = build_pair_for_preset(preset).map_err(|e| CircuitsErrors::Sample(e.to_string()))?; let moduli = dkg_params.moduli(); @@ -180,54 +169,44 @@ impl Computation for Witness { Ok(Witness { pk0is, pk1is }) } + + // Used as witness for Nargo execution. + fn to_json(&self) -> serde_json::Result { + let pk0is = crt_polynomial_to_toml_json(&self.pk0is); + let pk1is = crt_polynomial_to_toml_json(&self.pk1is); + + let json = serde_json::json!({ + "pk0is": pk0is, + "pk1is": pk1is, + }); + + Ok(json) + } } #[cfg(test)] mod tests { use super::*; - use crate::ciphernodes_committee::CiphernodesCommitteeSize; - use crate::prepare_pk_sample_for_test; - use crate::ConvertToJson; - use e3_fhe_params::BfvPreset; use e3_fhe_params::DEFAULT_BFV_PRESET; #[test] fn test_bound_and_bits_computation_consistency() { + let (_, dkg_params) = build_pair_for_preset(DEFAULT_BFV_PRESET).unwrap(); + let bounds = Bounds::compute(DEFAULT_BFV_PRESET, &()).unwrap(); - let bits = Bits::compute(DEFAULT_BFV_PRESET, &bounds).unwrap(); - let expected_bits = calculate_bit_width(&bounds.pk_bound.to_string()).unwrap(); + let bits = Bits::compute(DEFAULT_BFV_PRESET, &()).unwrap(); + let expected_bits = compute_pk_bit(&dkg_params); assert_eq!(bounds.pk_bound, BigUint::from(1125899906777088u128)); assert_eq!(bits.pk_bit, expected_bits); } - #[test] - fn test_witness_reduction_and_json_roundtrip() { - let sample = prepare_pk_sample_for_test( - BfvPreset::InsecureThreshold512, - CiphernodesCommitteeSize::Small, - ) - .unwrap(); - let witness = Witness::compute( - DEFAULT_BFV_PRESET, - &PkCircuitInput { - public_key: sample.dkg_public_key, - }, - ) - .unwrap(); - let json = witness.convert_to_json().unwrap(); - let decoded: Witness = serde_json::from_value(json.clone()).unwrap(); - - assert_eq!(decoded.pk0is, witness.pk0is); - assert_eq!(decoded.pk1is, witness.pk1is); - } - #[test] fn test_constants_json_roundtrip() { let constants = Configs::compute(DEFAULT_BFV_PRESET, &()).unwrap(); - let json = constants.convert_to_json().unwrap(); + let json = constants.to_json().unwrap(); let decoded: Configs = serde_json::from_value(json).unwrap(); assert_eq!(decoded.n, constants.n); diff --git a/crates/zk-helpers/src/circuits/dkg/pk/mod.rs b/crates/zk-helpers/src/circuits/dkg/pk/mod.rs index 570fcd6093..6cb4b8a4f6 100644 --- a/crates/zk-helpers/src/circuits/dkg/pk/mod.rs +++ b/crates/zk-helpers/src/circuits/dkg/pk/mod.rs @@ -10,6 +10,6 @@ pub mod computation; pub mod sample; pub use circuit::{PkCircuit, PkCircuitInput}; -pub use codegen::{generate_configs, generate_toml, TomlJson}; +pub use codegen::{generate_configs, generate_toml}; pub use computation::{Bits, Bounds, Configs, PkComputationOutput, Witness}; pub use sample::{prepare_pk_sample_for_test, PkSample}; diff --git a/crates/zk-helpers/src/circuits/dkg/pk/sample.rs b/crates/zk-helpers/src/circuits/dkg/pk/sample.rs index 4edfa5e4c7..ed87a576c6 100644 --- a/crates/zk-helpers/src/circuits/dkg/pk/sample.rs +++ b/crates/zk-helpers/src/circuits/dkg/pk/sample.rs @@ -8,12 +8,10 @@ use crate::ciphernodes_committee::CiphernodesCommittee; use crate::ciphernodes_committee::CiphernodesCommitteeSize; -use crate::CircuitsErrors; use e3_fhe_params::build_pair_for_preset; use e3_fhe_params::BfvPreset; -use fhe::bfv::{BfvParameters, PublicKey, SecretKey}; +use fhe::bfv::{PublicKey, SecretKey}; use rand::thread_rng; -use std::sync::Arc; /// Sample data for the **pk** circuit: committee and DKG public key only. #[derive(Debug, Clone)] @@ -26,30 +24,27 @@ pub struct PkSample { impl PkSample { /// Generates sample data for the pk circuit. - pub fn generate( - _threshold_params: &Arc, - dkg_params: &Arc, - committee_size: CiphernodesCommitteeSize, - ) -> Result { + pub fn generate(preset: BfvPreset, committee_size: CiphernodesCommitteeSize) -> Self { + let (_, dkg_params) = build_pair_for_preset(preset).unwrap(); + let mut rng = thread_rng(); let committee = committee_size.values(); - let dkg_secret_key = SecretKey::random(dkg_params, &mut rng); + let dkg_secret_key = SecretKey::random(&dkg_params, &mut rng); let dkg_public_key = PublicKey::new(&dkg_secret_key, &mut rng); - Ok(Self { + + Self { committee, dkg_public_key, - }) + } } } /// Prepares a pk sample for testing using a threshold preset (DKG params come from its pair). pub fn prepare_pk_sample_for_test( - threshold_preset: BfvPreset, + preset: BfvPreset, committee: CiphernodesCommitteeSize, -) -> Result { - let (threshold_params, dkg_params) = build_pair_for_preset(threshold_preset) - .map_err(|e| CircuitsErrors::Sample(e.to_string()))?; - PkSample::generate(&threshold_params, &dkg_params, committee) +) -> PkSample { + PkSample::generate(preset, committee) } #[cfg(test)] @@ -64,8 +59,7 @@ mod tests { let sample = prepare_pk_sample_for_test( BfvPreset::InsecureThreshold512, CiphernodesCommitteeSize::Small, - ) - .unwrap(); + ); assert_eq!(sample.committee.n, committee.n); assert_eq!(sample.committee.threshold, committee.threshold); diff --git a/crates/zk-helpers/src/circuits/dkg/share_computation/codegen.rs b/crates/zk-helpers/src/circuits/dkg/share_computation/codegen.rs index 2a3d8bd4d9..33f892d0f4 100644 --- a/crates/zk-helpers/src/circuits/dkg/share_computation/codegen.rs +++ b/crates/zk-helpers/src/circuits/dkg/share_computation/codegen.rs @@ -6,14 +6,14 @@ //! Code generation for the share-computation BFV circuit: Prover.toml and configs.nr. -use crate::bigint_3d_to_json_values; use crate::bigint_to_field; use crate::circuits::computation::CircuitComputation; +use crate::circuits::computation::Computation; use crate::circuits::dkg::share_computation::{ Bits, ShareComputationCircuit, ShareComputationCircuitInput, ShareComputationOutput, Witness, }; -use crate::circuits::{Artifacts, CircuitCodegen, CircuitsErrors, Toml}; -use crate::computation::Configs; +use crate::circuits::{Artifacts, CircuitCodegen, CircuitsErrors, CodegenToml}; +use crate::codegen::CodegenConfigs; use crate::computation::DkgInputType; use crate::crt_polynomial_to_toml_json; use crate::poly_coefficients_to_toml_json; @@ -23,20 +23,15 @@ use e3_fhe_params::BfvPreset; use e3_parity_matrix::{build_generator_matrix, null_space, ParityMatrixConfig}; use num_bigint::BigInt; use num_bigint::BigUint; -use serde::{Deserialize, Serialize}; use serde_json; /// Implementation of [`CircuitCodegen`] for [`ShareComputationCircuit`]. impl CircuitCodegen for ShareComputationCircuit { - type BfvThresholdParametersPreset = BfvPreset; + type Preset = BfvPreset; type Input = ShareComputationCircuitInput; type Error = CircuitsErrors; - fn codegen( - &self, - preset: Self::BfvThresholdParametersPreset, - input: &Self::Input, - ) -> Result { + fn codegen(&self, preset: Self::Preset, input: &Self::Input) -> Result { let ShareComputationOutput { witness, bits, .. } = ShareComputationCircuit::compute(preset, input)?; @@ -52,38 +47,34 @@ impl CircuitCodegen for ShareComputationCircuit { } } -/// JSON-serializable structure for Prover.toml (sk_secret or e_sm_secret, y, expected_secret_commitment). -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct TomlJson { - expected_secret_commitment: String, - /// Either {"sk_secret": {...}} or {"e_sm_secret": [...]}; flattened so the key appears at top level. - #[serde(flatten)] - secret: serde_json::Value, - y: Vec>>, // [N][L][N_PARTIES+1] -} - pub fn generate_toml( witness: &Witness, dkg_input_type: DkgInputType, -) -> Result { - let secret = match dkg_input_type { - DkgInputType::SecretKey => serde_json::json!({ - "sk_secret": poly_coefficients_to_toml_json(witness.secret_crt.limb(0).coefficients()) - }), - DkgInputType::SmudgingNoise => serde_json::json!({ - "e_sm_secret": crt_polynomial_to_toml_json(&witness.secret_crt) - }), +) -> Result { + let mut json = witness + .to_json() + .map_err(|e| CircuitsErrors::SerdeJson(e))?; + + let obj = json.as_object_mut().ok_or(CircuitsErrors::Other( + "witness json is not an object".to_string(), + ))?; + + obj.remove("secret_crt"); + + let (key, value) = match dkg_input_type { + DkgInputType::SecretKey => ( + "sk_secret", + poly_coefficients_to_toml_json(witness.secret_crt.limb(0).coefficients()), + ), + DkgInputType::SmudgingNoise => ( + "e_sm_secret", + serde_json::Value::Array(crt_polynomial_to_toml_json(&witness.secret_crt)), + ), }; - let y = bigint_3d_to_json_values(&witness.y); - - let toml_json = TomlJson { - expected_secret_commitment: witness.expected_secret_commitment.to_string(), - secret, - y, - }; + obj.insert(key.to_string(), value); - Ok(toml::to_string(&toml_json)?) + Ok(toml::to_string(&json)?) } /// Builds the PARITY_MATRIX constant string for Noir (one matrix per modulus via null_space). @@ -139,7 +130,7 @@ pub fn generate_configs( bits: &Bits, n_parties: usize, threshold: usize, -) -> Result { +) -> Result { let (threshold_params, _) = build_pair_for_preset(preset).map_err(|e| CircuitsErrors::Sample(e.to_string()))?; let config_name = preset.metadata().security.as_config_str(); @@ -229,8 +220,8 @@ mod tests { BfvPreset::InsecureThreshold512, CiphernodesCommitteeSize::Small, DkgInputType::SecretKey, - ) - .unwrap(); + ); + let input = share_computation_input_from_sample(&sample, DkgInputType::SecretKey); let artifacts = ShareComputationCircuit diff --git a/crates/zk-helpers/src/circuits/dkg/share_computation/computation.rs b/crates/zk-helpers/src/circuits/dkg/share_computation/computation.rs index c0e2751534..ed4159ee32 100644 --- a/crates/zk-helpers/src/circuits/dkg/share_computation/computation.rs +++ b/crates/zk-helpers/src/circuits/dkg/share_computation/computation.rs @@ -10,15 +10,15 @@ //! and (for witness) secret plus shares. Witness values are normalized to [0, q_j) per modulus //! and then to the ZKP field modulus so the Noir circuit's range check and parity check succeed. -use crate::calculate_bit_width; use crate::circuits::commitments::{ compute_share_computation_e_sm_commitment, compute_share_computation_sk_commitment, }; use crate::computation::DkgInputType; use crate::dkg::share_computation::ShareComputationCircuit; use crate::dkg::share_computation::ShareComputationCircuitInput; -use crate::get_zkp_modulus; use crate::CircuitsErrors; +use crate::{bigint_3d_to_json_values, get_zkp_modulus}; +use crate::{calculate_bit_width, crt_polynomial_to_toml_json}; use crate::{CircuitComputation, Computation}; use e3_fhe_params::build_pair_for_preset; use e3_fhe_params::BfvPreset; @@ -38,15 +38,12 @@ pub struct ShareComputationOutput { /// Implementation of [`CircuitComputation`] for [`ShareComputationCircuit`]. impl CircuitComputation for ShareComputationCircuit { - type BfvThresholdParametersPreset = BfvPreset; + type Preset = BfvPreset; type Input = ShareComputationCircuitInput; type Output = ShareComputationOutput; type Error = CircuitsErrors; - fn compute( - preset: Self::BfvThresholdParametersPreset, - input: &Self::Input, - ) -> Result { + fn compute(preset: Self::Preset, input: &Self::Input) -> Result { let bounds = Bounds::compute(preset, input)?; let bits = Bits::compute(preset, &bounds)?; let witness = Witness::compute(preset, input)?; @@ -99,14 +96,11 @@ pub struct Witness { } impl Computation for Configs { - type BfvThresholdParametersPreset = BfvPreset; + type Preset = BfvPreset; type Input = ShareComputationCircuitInput; type Error = CircuitsErrors; - fn compute( - preset: Self::BfvThresholdParametersPreset, - input: &Self::Input, - ) -> Result { + fn compute(preset: Self::Preset, input: &Self::Input) -> Result { let (threshold_params, _) = build_pair_for_preset(preset).map_err(|e| CircuitsErrors::Sample(e.to_string()))?; @@ -126,41 +120,35 @@ impl Computation for Configs { } impl Computation for Bits { - type BfvThresholdParametersPreset = BfvPreset; + type Preset = BfvPreset; type Input = Bounds; type Error = crate::utils::ZkHelpersUtilsError; - fn compute( - preset: Self::BfvThresholdParametersPreset, - input: &Self::Input, - ) -> Result { + fn compute(preset: Self::Preset, input: &Self::Input) -> Result { let (threshold_params, _) = build_pair_for_preset(preset) .map_err(|e| crate::utils::ZkHelpersUtilsError::ParseBound(e.to_string()))?; let mut bit_share = 0; for &qi in threshold_params.moduli() { let share_bound = BigUint::from(qi - 1); - let bit_width = calculate_bit_width(&share_bound.to_string())?; + let bit_width = calculate_bit_width(BigInt::from(share_bound)); bit_share = bit_share.max(bit_width); } Ok(Bits { - bit_sk_secret: calculate_bit_width(&input.sk_bound.to_string())?, - bit_e_sm_secret: calculate_bit_width(&input.e_sm_bound.to_string())?, + bit_sk_secret: calculate_bit_width(BigInt::from(input.sk_bound.clone())), + bit_e_sm_secret: calculate_bit_width(BigInt::from(input.e_sm_bound.clone())), bit_share, }) } } impl Computation for Bounds { - type BfvThresholdParametersPreset = BfvPreset; + type Preset = BfvPreset; type Input = ShareComputationCircuitInput; type Error = CircuitsErrors; - fn compute( - preset: Self::BfvThresholdParametersPreset, - input: &Self::Input, - ) -> Result { + fn compute(preset: Self::Preset, input: &Self::Input) -> Result { let (threshold_params, _) = build_pair_for_preset(preset).map_err(|e| CircuitsErrors::Sample(e.to_string()))?; let defaults = preset @@ -188,14 +176,11 @@ impl Computation for Bounds { } impl Computation for Witness { - type BfvThresholdParametersPreset = BfvPreset; + type Preset = BfvPreset; type Input = ShareComputationCircuitInput; type Error = CircuitsErrors; - fn compute( - preset: Self::BfvThresholdParametersPreset, - input: &Self::Input, - ) -> Result { + fn compute(preset: Self::Preset, input: &Self::Input) -> Result { let (threshold_params, _) = build_pair_for_preset(preset).map_err(|e| CircuitsErrors::Sample(e.to_string()))?; let moduli = threshold_params.moduli(); @@ -258,6 +243,21 @@ impl Computation for Witness { expected_secret_commitment, }) } + + // Used as witness for Nargo execution. + fn to_json(&self) -> serde_json::Result { + let secret_crt = crt_polynomial_to_toml_json(&self.secret_crt); + let y = bigint_3d_to_json_values(&self.y); + let expected_secret_commitment = self.expected_secret_commitment.to_string(); + + let json = serde_json::json!({ + "secret_crt": secret_crt, + "y": y, + "expected_secret_commitment": expected_secret_commitment, + }); + + Ok(json) + } } #[cfg(test)] @@ -267,7 +267,6 @@ mod tests { use crate::ciphernodes_committee::CiphernodesCommitteeSize; use crate::computation::DkgInputType; use crate::dkg::share_computation::ShareComputationCircuitInput; - use crate::ConvertToJson; use crate::{prepare_share_computation_sample_for_test, ShareComputationSample}; use e3_fhe_params::BfvPreset; use e3_fhe_params::DEFAULT_BFV_PRESET; @@ -292,47 +291,24 @@ mod tests { BfvPreset::InsecureThreshold512, CiphernodesCommitteeSize::Small, DkgInputType::SecretKey, - ) - .unwrap(); + ); + let input = share_computation_input_from_sample(&sample, DkgInputType::SecretKey); let bounds = Bounds::compute(DEFAULT_BFV_PRESET, &input).unwrap(); let bits = Bits::compute(DEFAULT_BFV_PRESET, &bounds).unwrap(); - let expected_sk_bits = calculate_bit_width(&bounds.sk_bound.to_string()).unwrap(); + let expected_sk_bits = calculate_bit_width(BigInt::from(bounds.sk_bound.clone())); assert_eq!(bits.bit_sk_secret, expected_sk_bits); } - #[test] - fn test_witness_reduction_and_json_roundtrip() { - let sample = prepare_share_computation_sample_for_test( - BfvPreset::InsecureThreshold512, - CiphernodesCommitteeSize::Small, - DkgInputType::SecretKey, - ) - .unwrap(); - let input = share_computation_input_from_sample(&sample, DkgInputType::SecretKey); - let witness = Witness::compute(DEFAULT_BFV_PRESET, &input).unwrap(); - let json = witness.convert_to_json().unwrap(); - let decoded: Witness = serde_json::from_value(json).unwrap(); - - assert_eq!( - decoded.secret_crt.limbs.len(), - witness.secret_crt.limbs.len() - ); - assert_eq!( - decoded.expected_secret_commitment, - witness.expected_secret_commitment - ); - } - #[test] fn test_witness_smudging_noise_secret_consistency() { let sample = prepare_share_computation_sample_for_test( BfvPreset::InsecureThreshold512, CiphernodesCommitteeSize::Small, DkgInputType::SmudgingNoise, - ) - .unwrap(); + ); + let input = share_computation_input_from_sample(&sample, DkgInputType::SmudgingNoise); let witness = Witness::compute(DEFAULT_BFV_PRESET, &input).unwrap(); let degree = witness.secret_crt.limb(0).coefficients().len(); @@ -356,12 +332,12 @@ mod tests { BfvPreset::InsecureThreshold512, CiphernodesCommitteeSize::Small, DkgInputType::SecretKey, - ) - .unwrap(); + ); + let input = share_computation_input_from_sample(&sample, DkgInputType::SecretKey); let constants = Configs::compute(DEFAULT_BFV_PRESET, &input).unwrap(); - let json = constants.convert_to_json().unwrap(); + let json = constants.to_json().unwrap(); let decoded: Configs = serde_json::from_value(json).unwrap(); assert_eq!(decoded.n, constants.n); diff --git a/crates/zk-helpers/src/circuits/dkg/share_computation/sample.rs b/crates/zk-helpers/src/circuits/dkg/share_computation/sample.rs index 43cad33cd1..01b97283d5 100644 --- a/crates/zk-helpers/src/circuits/dkg/share_computation/sample.rs +++ b/crates/zk-helpers/src/circuits/dkg/share_computation/sample.rs @@ -16,12 +16,11 @@ use e3_fhe_params::BfvPreset; use e3_parity_matrix::build_generator_matrix; use e3_parity_matrix::{null_space, ParityMatrix, ParityMatrixConfig}; use e3_polynomial::CrtPolynomial; -use fhe::bfv::{BfvParameters, PublicKey, SecretKey}; +use fhe::bfv::{PublicKey, SecretKey}; use fhe::trbfv::{ShareManager, TRBFV}; use num_bigint::BigInt; use num_bigint::BigUint; use rand::thread_rng; -use std::sync::Arc; /// Shamir secret shares: one limb per CRT modulus (rows = parties, cols = polynomial coefficients). pub type SecretShares = Vec>; @@ -45,21 +44,22 @@ pub struct ShareComputationSample { impl ShareComputationSample { /// Generates sample data for the share-computation circuit. pub fn generate( - threshold_params: &Arc, - dkg_params: &Arc, + preset: BfvPreset, committee_size: CiphernodesCommitteeSize, dkg_input_type: DkgInputType, num_ciphertexts: u128, // z in the search defaults lambda: u32, - ) -> Result { + ) -> Self { + let (threshold_params, dkg_params) = build_pair_for_preset(preset).unwrap(); + let mut rng = thread_rng(); let committee = committee_size.values(); - let dkg_secret_key = SecretKey::random(dkg_params, &mut rng); + let dkg_secret_key = SecretKey::random(&dkg_params, &mut rng); let dkg_public_key = PublicKey::new(&dkg_secret_key, &mut rng); let trbfv = TRBFV::new(committee.n, committee.threshold, threshold_params.clone()) - .map_err(|e| CircuitsErrors::Sample(format!("Failed to create TRBFV: {:?}", e)))?; + .unwrap_or_else(|e| panic!("Failed to create TRBFV: {:?}", e)); let mut share_manager = ShareManager::new(committee.n, committee.threshold, threshold_params.clone()); @@ -72,33 +72,23 @@ impl ShareComputationSample { t: committee.threshold, n: committee.n, }) - .map_err(|e| { - CircuitsErrors::Sample(format!("Failed to build generator matrix: {:?}", e)) - })?; - let h = null_space(&g, &q).map_err(|e| { - CircuitsErrors::Sample(format!("Failed to compute null space: {:?}", e)) - })?; + .unwrap(); + let h = null_space(&g, &q).unwrap(); parity_matrix.push(h); } let (secret, secret_sss) = match dkg_input_type { DkgInputType::SecretKey => { - let threshold_secret_key = SecretKey::random(threshold_params, &mut rng); + let threshold_secret_key = SecretKey::random(&threshold_params, &mut rng); let sk_poly = share_manager .coeffs_to_poly_level0(threshold_secret_key.coeffs.clone().as_ref()) - .map_err(|e| { - CircuitsErrors::Sample(format!( - "Failed to convert SK coeffs to poly: {:?}", - e - )) - })?; + .unwrap(); let sk_sss_u64 = share_manager .generate_secret_shares_from_poly(sk_poly.clone(), rng) - .map_err(|e| { - CircuitsErrors::Sample(format!("Failed to generate SK shares: {:?}", e)) - })?; + .unwrap(); + let secret_sss: SecretShares = sk_sss_u64 .into_iter() .map(|arr| arr.mapv(BigInt::from)) @@ -111,7 +101,7 @@ impl ShareComputationSample { .collect(); let mut secret_crt = CrtPolynomial::from_mod_q_polynomial(&sk_coeffs, threshold_params.moduli()); - secret_crt.center(threshold_params.moduli())?; + secret_crt.center(threshold_params.moduli()).unwrap(); (secret_crt, secret_sss) } @@ -123,15 +113,15 @@ impl ShareComputationSample { "Failed to generate smudging error: {:?}", e )) - })?; - let esi_poly = share_manager.bigints_to_poly(&esi_coeffs).map_err(|e| { - CircuitsErrors::Sample(format!("Failed to convert error to poly: {:?}", e)) - })?; + }) + .unwrap(); + let esi_poly = share_manager.bigints_to_poly(&esi_coeffs).unwrap(); let esi_sss_u64 = share_manager .generate_secret_shares_from_poly(esi_poly.clone(), rng) .map_err(|e| { CircuitsErrors::Sample(format!("Failed to generate error shares: {:?}", e)) - })?; + }) + .unwrap(); let secret_sss: SecretShares = esi_sss_u64 .into_iter() .map(|arr| arr.mapv(BigInt::from)) @@ -139,42 +129,37 @@ impl ShareComputationSample { let mut secret_crt = CrtPolynomial::from_mod_q_polynomial(&esi_coeffs, threshold_params.moduli()); - secret_crt.center(threshold_params.moduli())?; + secret_crt.center(threshold_params.moduli()).unwrap(); (secret_crt, secret_sss) } }; - Ok(Self { + Self { committee, dkg_public_key, secret, secret_sss, parity_matrix, - }) + } } } /// Prepares a share-computation sample for testing using a threshold preset. pub fn prepare_share_computation_sample_for_test( - threshold_preset: BfvPreset, + preset: BfvPreset, committee: CiphernodesCommitteeSize, dkg_input_type: DkgInputType, -) -> Result { - let (threshold_params, dkg_params) = build_pair_for_preset(threshold_preset) - .map_err(|e| CircuitsErrors::Sample(e.to_string()))?; - let defaults = threshold_preset - .search_defaults() - .ok_or_else(|| CircuitsErrors::Sample("preset has no search defaults".to_string()))?; +) -> ShareComputationSample { + let defaults = preset.search_defaults().unwrap(); + ShareComputationSample::generate( - &threshold_params, - &dkg_params, + preset, committee, dkg_input_type, defaults.z, defaults.lambda, ) - .map_err(|e| CircuitsErrors::Sample(e.to_string())) } #[cfg(test)] @@ -191,8 +176,7 @@ mod tests { BfvPreset::InsecureThreshold512, CiphernodesCommitteeSize::Small, DkgInputType::SecretKey, - ) - .unwrap(); + ); assert_eq!(sample.committee.n, committee.n); assert_eq!(sample.committee.threshold, committee.threshold); @@ -209,8 +193,7 @@ mod tests { BfvPreset::InsecureThreshold512, CiphernodesCommitteeSize::Small, DkgInputType::SmudgingNoise, - ) - .unwrap(); + ); assert_eq!(sample.committee.n, committee.n); assert_eq!(sample.committee.threshold, committee.threshold); diff --git a/crates/zk-helpers/src/circuits/errors.rs b/crates/zk-helpers/src/circuits/errors.rs index f59b6569c2..5dcea58433 100644 --- a/crates/zk-helpers/src/circuits/errors.rs +++ b/crates/zk-helpers/src/circuits/errors.rs @@ -25,6 +25,8 @@ pub enum CircuitsErrors { ZkHelpers(#[from] ZkHelpersUtilsError), #[error("Sample error: {0}")] Sample(String), + #[error("Serde JSON error: {0}")] + SerdeJson(#[from] serde_json::Error), #[error("Unexpected error: {0}")] Other(String), } diff --git a/crates/zk-helpers/src/circuits/mod.rs b/crates/zk-helpers/src/circuits/mod.rs index 4ebd750f62..09ce541a62 100644 --- a/crates/zk-helpers/src/circuits/mod.rs +++ b/crates/zk-helpers/src/circuits/mod.rs @@ -9,15 +9,17 @@ pub mod commitments; pub mod computation; pub mod errors; -pub use codegen::{write_artifacts, Artifacts, CircuitCodegen}; +pub use codegen::{write_artifacts, Artifacts, CircuitCodegen, CodegenConfigs, CodegenToml}; pub use commitments::*; -pub use computation::{CircuitComputation, Computation, Configs, ConvertToJson, Toml}; +pub use computation::{CircuitComputation, Computation}; pub use errors::CircuitsErrors; pub mod dkg; -pub use dkg::pk::codegen::{generate_configs, generate_toml, TomlJson}; +pub use dkg::pk::codegen::{generate_configs, generate_toml}; pub use dkg::pk::computation::{Bits, Bounds, PkComputationOutput, Witness}; pub use dkg::pk::{prepare_pk_sample_for_test, PkCircuit, PkSample}; pub use dkg::share_computation::{ prepare_share_computation_sample_for_test, SecretShares, ShareComputationSample, }; + +pub mod threshold; diff --git a/crates/zk-helpers/src/circuits/threshold/mod.rs b/crates/zk-helpers/src/circuits/threshold/mod.rs new file mode 100644 index 0000000000..1724e4edb3 --- /dev/null +++ b/crates/zk-helpers/src/circuits/threshold/mod.rs @@ -0,0 +1,8 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +pub mod user_data_encryption; +pub use user_data_encryption::*; diff --git a/crates/zk-helpers/src/circuits/threshold/user_data_encryption/circuit.rs b/crates/zk-helpers/src/circuits/threshold/user_data_encryption/circuit.rs new file mode 100644 index 0000000000..e4960a2e9d --- /dev/null +++ b/crates/zk-helpers/src/circuits/threshold/user_data_encryption/circuit.rs @@ -0,0 +1,25 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +use crate::computation::DkgInputType; +use crate::registry::Circuit; +use e3_fhe_params::ParameterType; +use fhe::bfv::{Plaintext, PublicKey}; + +#[derive(Debug)] +pub struct UserDataEncryptionCircuit; + +impl Circuit for UserDataEncryptionCircuit { + const NAME: &'static str = "user-data-encryption"; + const PREFIX: &'static str = "USER_DATA_ENCRYPTION"; + const SUPPORTED_PARAMETER: ParameterType = ParameterType::THRESHOLD; + const DKG_INPUT_TYPE: Option = None; +} + +pub struct UserDataEncryptionCircuitInput { + pub public_key: PublicKey, + pub plaintext: Plaintext, +} diff --git a/crates/zk-helpers/src/circuits/threshold/user_data_encryption/codegen.rs b/crates/zk-helpers/src/circuits/threshold/user_data_encryption/codegen.rs new file mode 100644 index 0000000000..369a565f95 --- /dev/null +++ b/crates/zk-helpers/src/circuits/threshold/user_data_encryption/codegen.rs @@ -0,0 +1,275 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +//! Code generation for the public-key BFV circuit: Prover.toml and configs.nr. + +use crate::circuits::computation::Computation; +use crate::threshold::user_data_encryption::circuit::UserDataEncryptionCircuit; +use crate::threshold::user_data_encryption::computation::{Configs, Witness}; +use crate::threshold::user_data_encryption::UserDataEncryptionCircuitInput; +use crate::utils::join_display; +use crate::Circuit; +use crate::CircuitCodegen; +use crate::CircuitsErrors; +use crate::{Artifacts, CodegenConfigs, CodegenToml}; + +use e3_fhe_params::BfvPreset; +use serde::{Deserialize, Serialize}; +use serde_json; + +/// Implementation of [`CircuitCodegen`] for [`UserDataEncryptionCircuit`]. +impl CircuitCodegen for UserDataEncryptionCircuit { + type Preset = BfvPreset; + type Input = UserDataEncryptionCircuitInput; + type Error = CircuitsErrors; + + fn codegen(&self, preset: Self::Preset, input: &Self::Input) -> Result { + let witness = Witness::compute(preset, input)?; + let configs = Configs::compute(preset, &())?; + + let toml = generate_toml(witness)?; + let configs = generate_configs(preset, &configs); + + Ok(Artifacts { toml, configs }) + } +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct TomlJson { + pub pk0is: Vec, + pub pk1is: Vec, + pub ct0is: Vec, + pub ct1is: Vec, + pub u: serde_json::Value, + pub e0: serde_json::Value, + pub e0is: Vec, + pub e0_quotients: Vec, + pub e1: serde_json::Value, + pub k1: serde_json::Value, + pub r1is: Vec, + pub r2is: Vec, + pub p1is: Vec, + pub p2is: Vec, + pub pk_commitment: String, +} + +pub fn generate_toml(witness: Witness) -> Result { + let json = witness + .to_json() + .map_err(|e| CircuitsErrors::SerdeJson(e))?; + + Ok(toml::to_string(&json)?) +} + +pub fn generate_configs(preset: BfvPreset, configs: &Configs) -> CodegenConfigs { + let prefix = ::PREFIX; + + let qis_str = join_display(&configs.moduli, ", "); + let k0is_str = join_display(&configs.k0is, ", "); + let pk_bounds_str = join_display(&configs.bounds.pk_bounds, ", "); + let r1_low_bounds_str = join_display(&configs.bounds.r1_low_bounds, ", "); + let r1_up_bounds_str = join_display(&configs.bounds.r1_up_bounds, ", "); + let r2_bounds_str = join_display(&configs.bounds.r2_bounds, ", "); + let p1_bounds_str = join_display(&configs.bounds.p1_bounds, ", "); + let p2_bounds_str = join_display(&configs.bounds.p2_bounds, ", "); + + format!( + r#"use crate::core::threshold::user_data_encryption::Configs as UserDataEncryptionConfigs; + +// Global configs for User Data Encryption circuit +pub global N: u32 = {}; +pub global L: u32 = {}; +pub global QIS: [Field; L] = [{}]; + +/************************************ +------------------------------------- +user_data_encryption (USED FOR DATA ENCRYPTION) +------------------------------------- +************************************/ + +pub global {}_BIT_PK: u32 = {}; +pub global {}_BIT_CT: u32 = {}; +pub global {}_BIT_U: u32 = {}; +pub global {}_BIT_E0: u32 = {}; +pub global {}_BIT_E1: u32 = {}; +pub global {}_BIT_K: u32 = {}; +pub global {}_BIT_R1: u32 = {}; +pub global {}_BIT_R2: u32 = {}; +pub global {}_BIT_P1: u32 = {}; +pub global {}_BIT_P2: u32 = {}; + +pub global {}_Q_MOD_T_MOD_P: Field = {}; +pub global {}_K0IS: [Field; L] = [{}]; +pub global {}_PK_BOUNDS: [Field; L] = [{}]; +pub global {}_E0_BOUND: Field = {}; +pub global {}_E1_BOUND: Field = {}; +pub global {}_U_BOUND: Field = {}; +pub global {}_K1_LOW_BOUND: Field = {}; +pub global {}_K1_UP_BOUND: Field = {}; +pub global {}_R1_LOW_BOUNDS: [Field; L] = [{}]; +pub global {}_R1_UP_BOUNDS: [Field; L] = [{}]; +pub global {}_R2_BOUNDS: [Field; L] = [{}]; +pub global {}_P1_BOUNDS: [Field; L] = [{}]; +pub global {}_P2_BOUNDS: [Field; L] = [{}]; + +pub global {}_CONFIGS: UserDataEncryptionConfigs = UserDataEncryptionConfigs::new( +{}_Q_MOD_T_MOD_P, +QIS, +{}_K0IS, +{}_PK_BOUNDS, +{}_E0_BOUND, +{}_E1_BOUND, +{}_U_BOUND, +{}_R1_LOW_BOUNDS, +{}_R1_UP_BOUNDS, +{}_R2_BOUNDS, +{}_P1_BOUNDS, +{}_P2_BOUNDS, +{}_K1_LOW_BOUND, +{}_K1_UP_BOUND +); +"#, + preset.metadata().degree, // N + preset.metadata().num_moduli, // L + qis_str, // QIS array + prefix, + configs.bits.pk_bit, // BIT_PK + prefix, + configs.bits.ct_bit, // BIT_CT + prefix, + configs.bits.u_bit, // BIT_U + prefix, + configs.bits.e0_bit, // BIT_E0 + prefix, + configs.bits.e1_bit, // BIT_E1 + prefix, + configs.bits.k_bit, // BIT_K + prefix, + configs.bits.r1_bit, // BIT_R1 + prefix, + configs.bits.r2_bit, // BIT_R2 + prefix, + configs.bits.p1_bit, // BIT_P1 + prefix, + configs.bits.p2_bit, // BIT_P2 + prefix, + configs.q_mod_t_mod_p, // Q_MOD_T_MOD_P + prefix, + k0is_str, // K0IS array + prefix, + pk_bounds_str, // PK_BOUNDS array + prefix, + configs.bounds.e0_bound, // E0_BOUND + prefix, + configs.bounds.e1_bound, // E1_BOUND + prefix, + configs.bounds.u_bound, // U_BOUND + prefix, + configs.bounds.k1_low_bound, // K1_LOW_BOUND + prefix, + configs.bounds.k1_up_bound, // K1_UP_BOUND + prefix, + r1_low_bounds_str, // R1_LOW_BOUNDS array + prefix, + r1_up_bounds_str, // R1_UP_BOUNDS array + prefix, + r2_bounds_str, // R2_BOUNDS array + prefix, + p1_bounds_str, // P1_BOUNDS array + prefix, + p2_bounds_str, // P2_BOUNDS array + prefix, + prefix, + prefix, + prefix, + prefix, + prefix, + prefix, + prefix, + prefix, + prefix, + prefix, + prefix, + prefix, + prefix, + ) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::circuits::computation::Computation; + use crate::codegen::write_artifacts; + use crate::threshold::user_data_encryption::computation::{Bits, Bounds}; + use crate::threshold::user_data_encryption::sample::UserDataEncryptionSample; + + use e3_fhe_params::DEFAULT_BFV_PRESET; + use tempfile::TempDir; + + #[test] + fn test_toml_generation_and_structure() { + let sample = UserDataEncryptionSample::generate(DEFAULT_BFV_PRESET); + let artifacts = UserDataEncryptionCircuit + .codegen( + DEFAULT_BFV_PRESET, + &UserDataEncryptionCircuitInput { + public_key: sample.public_key, + plaintext: sample.plaintext, + }, + ) + .unwrap(); + + let parsed: toml::Value = artifacts.toml.parse().unwrap(); + let pk0is = parsed + .get("pk0is") + .and_then(|value| value.as_array()) + .unwrap(); + let pk1is = parsed + .get("pk1is") + .and_then(|value| value.as_array()) + .unwrap(); + assert!(!pk0is.is_empty()); + assert!(!pk1is.is_empty()); + + let temp_dir = TempDir::new().unwrap(); + write_artifacts( + Some(&artifacts.toml), + &artifacts.configs, + Some(temp_dir.path()), + ) + .unwrap(); + + let output_path = temp_dir.path().join("Prover.toml"); + assert!(output_path.exists()); + + let content = std::fs::read_to_string(&output_path).unwrap(); + assert!(content.contains("pk0is")); + assert!(content.contains("pk1is")); + + assert!(artifacts.toml.contains("[[pk0is]]")); + assert!(artifacts.toml.contains("[[pk1is]]")); + + let configs_path = temp_dir.path().join("configs.nr"); + assert!(configs_path.exists()); + + let configs_content = std::fs::read_to_string(&configs_path).unwrap(); + let bounds = Bounds::compute(DEFAULT_BFV_PRESET, &()).unwrap(); + let bits = Bits::compute(DEFAULT_BFV_PRESET, &bounds).unwrap(); + + assert!(configs_content + .contains(format!("N: u32 = {}", DEFAULT_BFV_PRESET.metadata().degree).as_str())); + assert!(configs_content + .contains(format!("L: u32 = {}", DEFAULT_BFV_PRESET.metadata().num_moduli).as_str())); + assert!(configs_content.contains( + format!( + "{}_BIT_PK: u32 = {}", + ::PREFIX, + bits.pk_bit + ) + .as_str() + )); + } +} diff --git a/crates/zk-helpers/src/circuits/threshold/user_data_encryption/computation.rs b/crates/zk-helpers/src/circuits/threshold/user_data_encryption/computation.rs new file mode 100644 index 0000000000..a94daddd90 --- /dev/null +++ b/crates/zk-helpers/src/circuits/threshold/user_data_encryption/computation.rs @@ -0,0 +1,960 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +//! Computation types for the user data encryption circuit: constants, bounds, bit widths, and witness. +//! +//! [`Configs`], [`Bounds`], [`Bits`], and [`Witness`] are produced from BFV parameters +//! and (for witness) a public key. They implement [`Computation`] and are used by codegen. + +use crate::calculate_bit_width; +use crate::commitments::compute_pk_aggregation_commitment; +use crate::compute_ciphertext_commitment; +use crate::crt_polynomial_to_toml_json; +use crate::get_zkp_modulus; +use crate::polynomial_to_toml_json; +use crate::threshold::user_data_encryption::circuit::UserDataEncryptionCircuit; +use crate::threshold::user_data_encryption::circuit::UserDataEncryptionCircuitInput; +use crate::utils::compute_pk_bit; +use crate::CircuitsErrors; +use crate::{CircuitComputation, Computation}; +use e3_fhe_params::build_pair_for_preset; +use e3_fhe_params::BfvPreset; +use e3_polynomial::center; +use e3_polynomial::reduce; +use e3_polynomial::CrtPolynomial; +use e3_polynomial::Polynomial; +use fhe::bfv::SecretKey; +use fhe_math::rq::Poly; +use fhe_math::rq::Representation; +use fhe_math::zq::Modulus; +use fhe_traits::Serialize as FheSerialize; +use itertools::izip; +use num_bigint::BigInt; +use num_bigint::BigUint; +use num_bigint::ToBigInt; +use num_traits::Signed; +use num_traits::ToPrimitive; +use num_traits::Zero; +use rand::thread_rng; +use rayon::iter::ParallelIterator; +use rayon::prelude::ParallelBridge; +use serde::{Deserialize, Serialize}; +use std::ops::Deref; + +/// Output of [`CircuitComputation::compute`] for [`UserDataEncryptionCircuit`]: bounds, bit widths, and witness. +#[derive(Debug)] +pub struct UserDataEncryptionComputationOutput { + pub bounds: Bounds, + pub bits: Bits, + pub witness: Witness, +} + +/// Implementation of [`CircuitComputation`] for [`UserDataEncryptionCircuit`]. +impl CircuitComputation for UserDataEncryptionCircuit { + type Preset = BfvPreset; + type Input = UserDataEncryptionCircuitInput; + type Output = UserDataEncryptionComputationOutput; + type Error = CircuitsErrors; + + fn compute(preset: Self::Preset, input: &Self::Input) -> Result { + let bounds = Bounds::compute(preset, &())?; + let bits = Bits::compute(preset, &bounds)?; + let witness = Witness::compute(preset, input)?; + + Ok(UserDataEncryptionComputationOutput { + bounds, + bits, + witness, + }) + } +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct Configs { + pub n: usize, + pub l: usize, + pub moduli: Vec, + pub q_mod_t_mod_p: BigInt, + pub k0is: Vec, + pub bits: Bits, + pub bounds: Bounds, +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub struct Bits { + pub pk_bit: u32, + pub ct_bit: u32, + pub u_bit: u32, + pub e0_bit: u32, + pub e1_bit: u32, + pub k_bit: u32, + pub r1_bit: u32, + pub r2_bit: u32, + pub p1_bit: u32, + pub p2_bit: u32, +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub struct Bounds { + pub pk_bounds: Vec, + pub u_bound: BigUint, + pub e0_bound: BigUint, + pub e1_bound: BigUint, + pub k1_low_bound: BigUint, + pub k1_up_bound: BigUint, + pub r1_low_bounds: Vec, + pub r1_up_bounds: Vec, + pub r2_bounds: Vec, + pub p1_bounds: Vec, + pub p2_bounds: Vec, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct Witness { + pub pk0is: CrtPolynomial, + pub pk1is: CrtPolynomial, + pub ct0is: CrtPolynomial, + pub ct1is: CrtPolynomial, + pub r1is: CrtPolynomial, + pub r2is: CrtPolynomial, + pub p1is: CrtPolynomial, + pub p2is: CrtPolynomial, + pub e0is: CrtPolynomial, + pub e0_quotients: CrtPolynomial, + pub e0: Polynomial, + pub e1: Polynomial, + pub u: Polynomial, + pub k1: Polynomial, + pub pk_commitment: BigInt, + pub ct_commitment: BigInt, + pub ciphertext: Vec, +} + +impl Computation for Configs { + type Preset = BfvPreset; + type Input = (); + type Error = CircuitsErrors; + + fn compute(preset: Self::Preset, _: &Self::Input) -> Result { + let (threshold_params, _) = + build_pair_for_preset(preset).map_err(|e| CircuitsErrors::Sample(e.to_string()))?; + + let moduli = threshold_params.moduli().to_vec(); + let ctx = threshold_params.ctx_at_level(0)?; + let modulus = BigInt::from(ctx.modulus().clone()); + let t = BigInt::from(threshold_params.plaintext()); + let p = get_zkp_modulus(); + + let q_mod_t = center(&reduce(&modulus, &t), &t); + let q_mod_t_mod_p = reduce(&q_mod_t, &p); + + let mut k0is: Vec = Vec::new(); + + for qi in ctx.moduli_operators() { + let k0qi = BigInt::from(qi.inv(qi.neg(threshold_params.plaintext())).ok_or_else( + || { + CircuitsErrors::Fhe(fhe::Error::MathError(fhe_math::Error::Default( + "Failed to calculate modulus inverse for k0qi".into(), + ))) + }, + )?); + + k0is.push(k0qi.to_u64().unwrap_or(0)); + } + + let bounds = Bounds::compute(preset, &())?; + let bits = Bits::compute(preset, &bounds)?; + + Ok(Configs { + n: threshold_params.degree(), + l: moduli.len(), + q_mod_t_mod_p, + k0is, + moduli, + bits, + bounds, + }) + } +} + +impl Computation for Bits { + type Preset = BfvPreset; + type Input = Bounds; + type Error = CircuitsErrors; + + fn compute(_: Self::Preset, input: &Self::Input) -> Result { + let max_pk_bound = input.pk_bounds.iter().max().unwrap(); + + let pk_bit = calculate_bit_width(BigInt::from(max_pk_bound.clone())); + // We can safely assume that the ct bound is the same as the pk bound. + let ct_bit = calculate_bit_width(BigInt::from(max_pk_bound.clone())); + let u_bit = calculate_bit_width(BigInt::from(input.u_bound.clone())); + let e0_bit = calculate_bit_width(BigInt::from(input.e0_bound.clone())); + let e1_bit = calculate_bit_width(BigInt::from(input.e1_bound.clone())); + + // For k1, use the maximum of low and up bounds + let k1_low_bit = calculate_bit_width(BigInt::from(input.k1_low_bound.clone())); + let k1_up_bit = calculate_bit_width(BigInt::from(input.k1_up_bound.clone())); + let k_bit = k1_low_bit.max(k1_up_bit); + + // For r1, use the maximum of all low and up bounds + let mut r1_bit = 0; + for bound in input.r1_low_bounds.iter().chain(input.r1_up_bounds.iter()) { + r1_bit = r1_bit.max(calculate_bit_width(BigInt::from(bound.clone()))); + } + + // For r2, use the maximum of all bounds + let mut r2_bit = 0; + for bound in &input.r2_bounds { + r2_bit = r2_bit.max(calculate_bit_width(BigInt::from(bound.clone()))); + } + + // For p1, use the maximum of all bounds + let mut p1_bit = 0; + for bound in &input.p1_bounds { + p1_bit = p1_bit.max(calculate_bit_width(BigInt::from(bound.clone()))); + } + + // For p2, use the maximum of all bounds + let mut p2_bit = 0; + for bound in &input.p2_bounds { + p2_bit = p2_bit.max(calculate_bit_width(BigInt::from(bound.clone()))); + } + + Ok(Bits { + pk_bit, + ct_bit, + u_bit, + e0_bit, + e1_bit, + k_bit, + r1_bit, + r2_bit, + p1_bit, + p2_bit, + }) + } +} + +impl Computation for Bounds { + type Preset = BfvPreset; + type Input = (); + type Error = CircuitsErrors; + + fn compute(preset: Self::Preset, _: &Self::Input) -> Result { + let (threshold_params, _) = + build_pair_for_preset(preset).map_err(|e| CircuitsErrors::Sample(e.to_string()))?; + + let n = BigInt::from(threshold_params.degree()); + let ctx = threshold_params.ctx_at_level(0)?; + + let t = BigInt::from(threshold_params.plaintext()); + + // CBD bound + let cbd_bound = (threshold_params.variance() * 2) as u64; + // Uniform bound + let uniform_bound = (threshold_params.get_error1_variance() * BigUint::from(3u32)) + .sqrt() + .to_bigint() + .ok_or_else(|| { + CircuitsErrors::Other("Failed to convert uniform bound to BigInt".into()) + })?; + + let u_bound = SecretKey::sk_bound() as u128; // u_bound is the same as sk_bound + + // e0 = e1 in the fhe.rs + let e0_bound: u128 = if threshold_params.get_error1_variance() <= &BigUint::from(16u32) { + cbd_bound as u128 + } else { + uniform_bound.to_u128().unwrap() + }; + let e1_bound = cbd_bound; // e1 = e2 in the fhe.rs + + let ptxt_up_bound = (t.clone() - BigInt::from(1)) / BigInt::from(2); + let ptxt_low_bound: BigInt = if (t.clone() % BigInt::from(2)) == BigInt::from(1) { + -1 * ptxt_up_bound.clone() + } else { + -1 * ptxt_up_bound.clone() - BigInt::from(1) + }; + + let k1_low_bound: BigInt = BigInt::from(-1) * ptxt_low_bound.clone(); + let k1_up_bound: BigInt = ptxt_up_bound.clone(); + + // Calculate bounds for each CRT basis + let _num_moduli = ctx.moduli().len(); + let mut pk_bounds: Vec = Vec::new(); + let mut r1_low_bounds: Vec = Vec::new(); + let mut r1_up_bounds: Vec = Vec::new(); + let mut r2_bounds: Vec = Vec::new(); + let mut p1_bounds: Vec = Vec::new(); + let mut p2_bounds: Vec = Vec::new(); + let mut moduli: Vec = Vec::new(); + let mut k0is: Vec = Vec::new(); + + for qi in ctx.moduli_operators() { + let qi_bigint = BigInt::from(qi.modulus()); + let qi_bound = (&qi_bigint - BigInt::from(1)) / BigInt::from(2); + + moduli.push(qi.modulus()); + + // Calculate k0qi for bounds + let k0qi = BigInt::from(qi.inv(qi.neg(threshold_params.plaintext())).ok_or_else( + || { + CircuitsErrors::Fhe(fhe::Error::MathError(fhe_math::Error::Default( + "Failed to calculate modulus inverse for k0qi".into(), + ))) + }, + )?); + k0is.push(k0qi.to_u64().unwrap_or(0)); + + // PK and R2 bounds (same as qi_bound) + pk_bounds.push(qi_bound.clone()); + r2_bounds.push(qi_bound.clone()); + + let e0_bound_i = e0_bound % qi_bigint.clone(); + + // R1 bounds (more complex calculation) + let r1_low: BigInt = (&ptxt_low_bound * k0qi.abs() + - &((&n * u_bound + BigInt::from(2)) * &qi_bound + e0_bound_i.clone())) + / &qi_bigint; + let r1_up: BigInt = (&ptxt_up_bound * k0qi.abs() + + ((&n * u_bound + BigInt::from(2)) * &qi_bound + e0_bound_i.clone())) + / &qi_bigint; + + r1_low_bounds.push(BigInt::from(-1) * r1_low.clone()); + r1_up_bounds.push(r1_up.clone()); + + // P1 and P2 bounds + let p1_bound: BigInt = + ((&n * u_bound + BigInt::from(2)) * &qi_bound + e1_bound) / &qi_bigint; + p1_bounds.push(p1_bound.clone()); + p2_bounds.push(qi_bound.clone()); + } + + Ok(Bounds { + pk_bounds: pk_bounds + .iter() + .map(|b| BigUint::from(b.to_u128().unwrap())) + .collect(), + u_bound: BigUint::from(u_bound as u64), + e0_bound: BigUint::from(e0_bound), + e1_bound: BigUint::from(e1_bound), + k1_low_bound: BigUint::from(k1_low_bound.to_u128().unwrap()), + k1_up_bound: BigUint::from(k1_up_bound.to_u128().unwrap()), + r1_low_bounds: r1_low_bounds + .iter() + .map(|b| BigUint::from(b.to_u128().unwrap())) + .collect(), + r1_up_bounds: r1_up_bounds + .iter() + .map(|b| BigUint::from(b.to_u128().unwrap())) + .collect(), + r2_bounds: r2_bounds + .iter() + .map(|b| BigUint::from(b.to_u128().unwrap())) + .collect(), + p1_bounds: p1_bounds + .iter() + .map(|b| BigUint::from(b.to_u128().unwrap())) + .collect(), + p2_bounds: p2_bounds + .iter() + .map(|b| BigUint::from(b.to_u128().unwrap())) + .collect(), + }) + } +} + +impl Computation for Witness { + type Preset = BfvPreset; + type Input = UserDataEncryptionCircuitInput; + type Error = CircuitsErrors; + + fn compute(preset: Self::Preset, input: &Self::Input) -> Result { + let (threshold_params, _) = + build_pair_for_preset(preset).map_err(|e| CircuitsErrors::Sample(e.to_string()))?; + + let pk_bit = compute_pk_bit(&threshold_params); + + let pk = input.public_key.clone(); + let pt = input.plaintext.clone(); + + // Encrypt using the provided public key to ensure ciphertext matches the key. + let (ct, u_rns, e0_rns, e1_rns) = input + .public_key + .try_encrypt_extended(&input.plaintext, &mut thread_rng())?; + + // Context and plaintext modulus (use same ctx for e0 reconstruction and loop). + let ctx = threshold_params.ctx_at_level(pt.level())?; + + // Reconstruct e0 in mod Q so that e0_poly row i matches e0_rns row i (same ctx). + let mut e0_power = e0_rns.clone(); + e0_power.change_representation(Representation::PowerBasis); + let e0_mod_q: Vec = Vec::::from(&e0_power); + let e0_bigints: Vec = e0_mod_q.iter().map(|c| c.to_bigint().unwrap()).collect(); + let e0 = (*Poly::from_bigints(&e0_bigints, &ctx) + .map_err(|e| CircuitsErrors::Other(e.to_string()))?) + .clone(); + + let t = Modulus::new(threshold_params.plaintext()) + .map_err(|e| CircuitsErrors::Fhe(fhe::Error::from(e)))?; + let n: u64 = ctx.degree as u64; + + // Calculate k1 (independent of qi), center and reverse + let q_mod_t = (ctx.modulus() % t.modulus()).to_u64().unwrap(); // [q]_t + let mut k1_u64 = pt.value.deref().to_vec(); // m + t.scalar_mul_vec(&mut k1_u64, q_mod_t); // k1 = [q*m]_t + + let mut k1 = Polynomial::from_u64_vector(k1_u64); + + k1.reverse(); + k1.center(&BigInt::from(t.modulus())); + + // Extract single vectors of u, e1, and e2 as Vec, center and reverse + let mut u_rns_copy = u_rns.clone(); + let mut e0_rns_copy = e0_rns.clone(); + let mut e0_poly_copy = e0.clone(); + let mut e1_rns_copy = e1_rns.clone(); + + u_rns_copy.change_representation(Representation::PowerBasis); + e0_rns_copy.change_representation(Representation::PowerBasis); + e0_poly_copy.change_representation(Representation::PowerBasis); + e1_rns_copy.change_representation(Representation::PowerBasis); + + // Extract coefficients using the current API + let u: Vec = + unsafe { + ctx.moduli_operators()[0] + .center_vec_vt(u_rns_copy.coefficients().row(0).as_slice().ok_or_else( + || CircuitsErrors::Other("Cannot center coefficients.".into()), + )?) + .iter() + .rev() + .map(|&x| BigInt::from(x)) + .collect() + }; + + let mut e0_vec = Polynomial::new(e0_bigints.clone()); + + e0_vec.reverse(); + + // Center the coefficients mod Q + let q_bigint = BigInt::from(ctx.modulus().clone()); + + e0_vec.center(&q_bigint); + + let e1: Vec = + unsafe { + ctx.moduli_operators()[0] + .center_vec_vt(e1_rns_copy.coefficients().row(0).as_slice().ok_or_else( + || CircuitsErrors::Other("Cannot center coefficients.".into()), + )?) + .iter() + .rev() + .map(|&x| BigInt::from(x)) + .collect() + }; + + // Extract and convert ciphertext and public key polynomials + let mut ct0 = ct.c[0].clone(); + let mut ct1 = ct.c[1].clone(); + ct0.change_representation(Representation::PowerBasis); + ct1.change_representation(Representation::PowerBasis); + + let mut pk0: Poly = pk.c.c[0].clone(); + let mut pk1: Poly = pk.c.c[1].clone(); + pk0.change_representation(Representation::PowerBasis); + pk1.change_representation(Representation::PowerBasis); + + // Create cyclotomic polynomial x^N + 1 + let mut cyclo = vec![BigInt::from(0u64); (n + 1) as usize]; + + cyclo[0] = BigInt::from(1u64); // x^N term + cyclo[n as usize] = BigInt::from(1u64); // x^0 term + + let ct0_coeffs = ct0.coefficients(); + let ct1_coeffs = ct1.coefficients(); + let pk0_coeffs = pk0.coefficients(); + let pk1_coeffs = pk1.coefficients(); + let e0_coeffs = e0_rns_copy.coefficients(); + let e0_poly_coeffs = e0_poly_copy.coefficients(); + + let ct0_coeffs_rows = ct0_coeffs.rows(); + let ct1_coeffs_rows = ct1_coeffs.rows(); + let pk0_coeffs_rows = pk0_coeffs.rows(); + let pk1_coeffs_rows = pk1_coeffs.rows(); + let e0_coeffs_rows = e0_coeffs.rows(); + let e0_poly_coeffs_rows = e0_poly_coeffs.rows(); + + // Perform the main computation logic + let results: Vec<_> = izip!( + ctx.moduli_operators(), + ct0_coeffs_rows, + ct1_coeffs_rows, + pk0_coeffs_rows, + pk1_coeffs_rows, + e0_coeffs_rows, + e0_poly_coeffs_rows, + ) + .enumerate() + .par_bridge() + .map( + |( + i, + (qi, ct0_coeffs, ct1_coeffs, pk0_coeffs, pk1_coeffs, e0_coeffs, e0_poly_coeffs), + )| { + // --------------------------------------------------- ct0i --------------------------------------------------- + + // Convert to vectors of bigint, center, and reverse order. + let mut ct0i = Polynomial::from_u64_vector(ct0_coeffs.to_vec()); + let mut ct1i = Polynomial::from_u64_vector(ct1_coeffs.to_vec()); + let mut pk0i = Polynomial::from_u64_vector(pk0_coeffs.to_vec()); + let mut pk1i = Polynomial::from_u64_vector(pk1_coeffs.to_vec()); + + ct0i.reverse(); + ct1i.reverse(); + pk0i.reverse(); + pk1i.reverse(); + + let qi_bigint = BigInt::from(qi.modulus()); + + ct0i.reduce(&qi_bigint); + ct0i.center(&qi_bigint); + ct1i.reduce(&qi_bigint); + ct1i.center(&qi_bigint); + pk0i.reduce(&qi_bigint); + pk0i.center(&qi_bigint); + pk1i.reduce(&qi_bigint); + pk1i.center(&qi_bigint); + + let e0i: Vec = unsafe { + qi.center_vec_vt( + e0_coeffs + .as_slice() + .ok_or_else(|| "Cannot center coefficients.".to_string()) + .unwrap(), + ) + .iter() + .rev() + .map(|&x| BigInt::from(x)) + .collect() + }; + + // Explicitly check e1is[i] == e1 mod qi (after centering and reversal) + let e0i_from_poly: Vec = unsafe { + qi.center_vec_vt( + e0_poly_coeffs + .as_slice() + .ok_or_else(|| "Cannot center coefficients.".to_string()) + .unwrap(), + ) + .iter() + .rev() + .map(|&x| BigInt::from(x)) + .collect() + }; + + // Check that e0i equals e0 reduced modulo q_i (from e0_poly) + assert_eq!(e0i, e0i_from_poly); + + // Compute e0_quotients[i] = (e0 - e0i) / qi for each coefficient + // This is used for CRT consistency check: e0[j] = e0i[j] + e0_quotients[i][j] * qi + let e0_quotient: Vec = e0_vec + .coefficients() + .iter() + .zip(e0i.iter()) + .map(|(e0_coeff, e0i_coeff)| { + let diff = e0_coeff - e0i_coeff; + // Division should be exact since e0 = e0i (mod qi) + let quotient = &diff / &qi_bigint; + // Verify the CRT relationship + assert_eq!(e0_coeff, &(e0i_coeff + "ient * &qi_bigint)); + quotient + }) + .collect(); + + // k0qi = -t^{-1} mod qi + let koqi_u64 = qi.inv(qi.neg(t.modulus())).unwrap(); + let k0qi = BigInt::from(koqi_u64); // Do not need to center this + + // ki = k1 * k0qi + let ki_poly = Polynomial::new(k1.coefficients().to_vec()).scalar_mul(&k0qi); + let ki = ki_poly.coefficients().to_vec(); + + // Calculate ct0i_hat = pk0 * ui + e0i + ki + let ct0i_hat = { + let pk0i_poly = pk0i.clone(); + let u_poly = Polynomial::new(u.clone()); + let pk0i_times_u = pk0i_poly.mul(&u_poly); + assert_eq!((pk0i_times_u.coefficients().len() as u64) - 1, 2 * (n - 1)); + + let e0i_poly = Polynomial::new(e0i.clone()); + let ki_poly = Polynomial::new(ki.clone()); + let e0_plus_ki = e0i_poly.add(&ki_poly); + assert_eq!((e0_plus_ki.coefficients().len() as u64) - 1, n - 1); + + pk0i_times_u.add(&e0_plus_ki).coefficients().to_vec() + }; + assert_eq!((ct0i_hat.len() as u64) - 1, 2 * (n - 1)); + + // Check whether ct0i_hat mod R_qi (the ring) is equal to ct0i + let mut ct0i_hat_mod_rqi = Polynomial::new(ct0i_hat.clone()); + + ct0i_hat_mod_rqi = ct0i_hat_mod_rqi.reduce_by_cyclotomic(&cyclo).unwrap(); + + ct0i_hat_mod_rqi.reduce(&qi_bigint); + ct0i_hat_mod_rqi.center(&qi_bigint); + + assert_eq!(&ct0i, &ct0i_hat_mod_rqi); + + // Compute r2i numerator = ct0i - ct0i_hat and reduce/center the polynomial + let ct0i_poly = ct0i.clone(); + let ct0i_hat_poly = Polynomial::new(ct0i_hat.clone()); + let ct0i_minus_ct0i_hat = ct0i_poly.sub(&ct0i_hat_poly).coefficients().to_vec(); + assert_eq!((ct0i_minus_ct0i_hat.len() as u64) - 1, 2 * (n - 1)); + + let mut ct0i_minus_ct0i_hat_mod_zqi = Polynomial::new(ct0i_minus_ct0i_hat.clone()); + + ct0i_minus_ct0i_hat_mod_zqi.reduce(&qi_bigint); + ct0i_minus_ct0i_hat_mod_zqi.center(&qi_bigint); + + // Compute r2i as the quotient of numerator divided by the cyclotomic polynomial + // to produce: (ct0i - ct0i_hat) / (x^N + 1) mod Z_qi. Remainder should be empty. + let ct0i_minus_ct0i_hat_poly = ct0i_minus_ct0i_hat_mod_zqi.clone(); + let cyclo_poly = Polynomial::new(cyclo.clone()); + let (r2i_poly, r2i_rem_poly) = ct0i_minus_ct0i_hat_poly.div(&cyclo_poly).unwrap(); + let r2i = r2i_poly.coefficients().to_vec(); + let r2i_rem = r2i_rem_poly.coefficients().to_vec(); + assert!(r2i_rem.iter().all(|x| x.is_zero())); + assert_eq!((r2i.len() as u64) - 1, n - 2); // Order(r2i) = N - 2 + + // Assert that (ct0i - ct0i_hat) = (r2i * cyclo) mod Z_qi + let r2i_poly = Polynomial::new(r2i.clone()); + let r2i_times_cyclo = r2i_poly.mul(&cyclo_poly).coefficients().to_vec(); + + let mut r2i_times_cyclo_mod_zqi = Polynomial::new(r2i_times_cyclo.clone()); + + r2i_times_cyclo_mod_zqi.reduce(&qi_bigint); + r2i_times_cyclo_mod_zqi.center(&qi_bigint); + + assert_eq!(&ct0i_minus_ct0i_hat_mod_zqi, &r2i_times_cyclo_mod_zqi); + assert_eq!((r2i_times_cyclo.len() as u64) - 1, 2 * (n - 1)); + + // Calculate r1i = (ct0i - ct0i_hat - r2i * cyclo) / qi mod Z_p. Remainder should be empty. + let ct0i_minus_ct0i_hat_poly = Polynomial::new(ct0i_minus_ct0i_hat.clone()); + let r2i_times_cyclo_poly = Polynomial::new(r2i_times_cyclo.clone()); + let r1i_num = ct0i_minus_ct0i_hat_poly + .sub(&r2i_times_cyclo_poly) + .coefficients() + .to_vec(); + assert_eq!((r1i_num.len() as u64) - 1, 2 * (n - 1)); + + let r1i_num_poly = Polynomial::new(r1i_num.clone()); + let qi_poly = Polynomial::new(vec![qi_bigint.clone()]); + let (r1i_poly, r1i_rem_poly) = r1i_num_poly.div(&qi_poly).unwrap(); + let r1i = r1i_poly.coefficients().to_vec(); + let r1i_rem = r1i_rem_poly.coefficients().to_vec(); + assert!(r1i_rem.iter().all(|x| x.is_zero())); + assert_eq!((r1i.len() as u64) - 1, 2 * (n - 1)); // Order(r1i) = 2*(N-1) + let r1i_poly_check = Polynomial::new(r1i.clone()); + assert_eq!( + &r1i_num, + &r1i_poly_check.mul(&qi_poly).coefficients().to_vec() + ); + + // Assert that ct0i = ct0i_hat + r1i * qi + r2i * cyclo mod Z_p + let r1i_poly = Polynomial::new(r1i.clone()); + let r1i_times_qi = r1i_poly.scalar_mul(&qi_bigint).coefficients().to_vec(); + let ct0i_hat_poly = Polynomial::new(ct0i_hat.clone()); + let r1i_times_qi_poly = Polynomial::new(r1i_times_qi.clone()); + let r2i_times_cyclo_poly = Polynomial::new(r2i_times_cyclo.clone()); + let mut ct0i_calculated = ct0i_hat_poly + .add(&r1i_times_qi_poly) + .add(&r2i_times_cyclo_poly) + .coefficients() + .to_vec(); + + while !ct0i_calculated.is_empty() && ct0i_calculated[0].is_zero() { + ct0i_calculated.remove(0); + } + + assert_eq!(&ct0i, &Polynomial::new(ct0i_calculated.clone())); + + // --------------------------------------------------- ct1i --------------------------------------------------- + + // Calculate ct1i_hat = pk1i * ui + e1 + let ct1i_hat = { + let pk1i_poly = pk1i.clone(); + let u_poly = Polynomial::new(u.clone()); + let pk1i_times_u = pk1i_poly.mul(&u_poly); + assert_eq!((pk1i_times_u.coefficients().len() as u64) - 1, 2 * (n - 1)); + + let e1_poly = Polynomial::new(e1.clone()); + pk1i_times_u.add(&e1_poly).coefficients().to_vec() + }; + assert_eq!((ct1i_hat.len() as u64) - 1, 2 * (n - 1)); + + // Check whether ct1i_hat mod R_qi (the ring) is equal to ct1i + let mut ct1i_hat_mod_rqi = Polynomial::new(ct1i_hat.clone()); + + ct1i_hat_mod_rqi = ct1i_hat_mod_rqi.reduce_by_cyclotomic(&cyclo).unwrap(); + ct1i_hat_mod_rqi.reduce(&qi_bigint); + ct1i_hat_mod_rqi.center(&qi_bigint); + + assert_eq!(&ct1i, &ct1i_hat_mod_rqi); + + // Compute p2i numerator = ct1i - ct1i_hat + let ct1i_poly = ct1i.clone(); + let ct1i_hat_poly = Polynomial::new(ct1i_hat.clone()); + let ct1i_minus_ct1i_hat = ct1i_poly.sub(&ct1i_hat_poly).coefficients().to_vec(); + assert_eq!((ct1i_minus_ct1i_hat.len() as u64) - 1, 2 * (n - 1)); + let mut ct1i_minus_ct1i_hat_mod_zqi = Polynomial::new(ct1i_minus_ct1i_hat.clone()); + + ct1i_minus_ct1i_hat_mod_zqi.reduce(&qi_bigint); + ct1i_minus_ct1i_hat_mod_zqi.center(&qi_bigint); + + // Compute p2i as the quotient of numerator divided by the cyclotomic polynomial, + // and reduce/center the resulting coefficients to produce: + // (ct1i - ct1i_hat) / (x^N + 1) mod Z_qi. Remainder should be empty. + let ct1i_minus_ct1i_hat_poly = ct1i_minus_ct1i_hat_mod_zqi.clone(); + let (p2i_poly, p2i_rem_poly) = + ct1i_minus_ct1i_hat_poly.div(&cyclo_poly.clone()).unwrap(); + let p2i = p2i_poly.coefficients().to_vec(); + let p2i_rem = p2i_rem_poly.coefficients().to_vec(); + assert!(p2i_rem.iter().all(|x| x.is_zero())); + assert_eq!((p2i.len() as u64) - 1, n - 2); // Order(p2i) = N - 2 + + // Assert that (ct1i - ct1i_hat) = (p2i * cyclo) mod Z_qi + let p2i_poly = Polynomial::new(p2i.clone()); + let p2i_times_cyclo: Vec = + p2i_poly.mul(&cyclo_poly).coefficients().to_vec(); + let mut p2i_times_cyclo_mod_zqi = Polynomial::new(p2i_times_cyclo.clone()); + + p2i_times_cyclo_mod_zqi.reduce(&qi_bigint); + p2i_times_cyclo_mod_zqi.center(&qi_bigint); + + assert_eq!(&ct1i_minus_ct1i_hat_mod_zqi, &p2i_times_cyclo_mod_zqi); + assert_eq!((p2i_times_cyclo.len() as u64) - 1, 2 * (n - 1)); + + // Calculate p1i = (ct1i - ct1i_hat - p2i * cyclo) / qi mod Z_p. Remainder should be empty. + let ct1i_minus_ct1i_hat_poly = Polynomial::new(ct1i_minus_ct1i_hat.clone()); + let p2i_times_cyclo_poly = Polynomial::new(p2i_times_cyclo.clone()); + let p1i_num = ct1i_minus_ct1i_hat_poly + .sub(&p2i_times_cyclo_poly) + .coefficients() + .to_vec(); + assert_eq!((p1i_num.len() as u64) - 1, 2 * (n - 1)); + + let p1i_num_poly = Polynomial::new(p1i_num.clone()); + let qi_poly = Polynomial::new(vec![BigInt::from(qi.modulus())]); + let (p1i_poly, p1i_rem_poly) = p1i_num_poly.div(&qi_poly).unwrap(); + let p1i = p1i_poly.coefficients().to_vec(); + let p1i_rem = p1i_rem_poly.coefficients().to_vec(); + assert!(p1i_rem.iter().all(|x| x.is_zero())); + assert_eq!((p1i.len() as u64) - 1, 2 * (n - 1)); // Order(p1i) = 2*(N-1) + let p1i_poly_check = Polynomial::new(p1i.clone()); + assert_eq!( + &p1i_num, + &p1i_poly_check.mul(&qi_poly).coefficients().to_vec() + ); + + // Assert that ct1i = ct1i_hat + p1i * qi + p2i * cyclo mod Z_p + let p1i_poly = Polynomial::new(p1i.clone()); + let p1i_times_qi = p1i_poly.scalar_mul(&qi_bigint).coefficients().to_vec(); + let ct1i_hat_poly = Polynomial::new(ct1i_hat.clone()); + let p1i_times_qi_poly = Polynomial::new(p1i_times_qi.clone()); + let p2i_times_cyclo_poly = Polynomial::new(p2i_times_cyclo.clone()); + let mut ct1i_calculated = ct1i_hat_poly + .add(&p1i_times_qi_poly) + .add(&p2i_times_cyclo_poly) + .coefficients() + .to_vec(); + + while !ct1i_calculated.is_empty() && ct1i_calculated[0].is_zero() { + ct1i_calculated.remove(0); + } + + assert_eq!(&ct1i, &Polynomial::new(ct1i_calculated.clone())); + ( + i, + r2i, + r1i, + k0qi, + ct0i, + ct1i, + pk0i, + pk1i, + p1i, + p2i, + e0i, + e0_quotient, + ) + }, + ) + .collect(); + + // Sort by modulus index so CRT limbs are in order + let mut results = results.clone(); + results.sort_by_key(|(i, ..)| *i); + + // results elements: (i, r2i, r1i, k0qi, ct0i, ct1i, pk0i, pk1i, p1i, p2i, e0i, e0_quotient) + let mut pk0is = CrtPolynomial::from_bigint_vectors( + results + .iter() + .map(|row| row.6.clone()) + .map(|pk0i| pk0i.coefficients().to_vec()) + .collect(), + ); + let mut pk1is = CrtPolynomial::from_bigint_vectors( + results + .iter() + .map(|row| row.7.clone()) + .map(|pk1i| pk1i.coefficients().to_vec()) + .collect(), + ); + let mut ct0is = CrtPolynomial::from_bigint_vectors( + results + .iter() + .map(|row| row.4.clone()) + .map(|ct0i| ct0i.coefficients().to_vec()) + .collect(), + ); + let mut ct1is = CrtPolynomial::from_bigint_vectors( + results + .iter() + .map(|row| row.5.clone()) + .map(|ct1i| ct1i.coefficients().to_vec()) + .collect(), + ); + let mut r1is = + CrtPolynomial::from_bigint_vectors(results.iter().map(|row| row.2.clone()).collect()); + let mut r2is = + CrtPolynomial::from_bigint_vectors(results.iter().map(|row| row.1.clone()).collect()); + let mut p1is = + CrtPolynomial::from_bigint_vectors(results.iter().map(|row| row.8.clone()).collect()); + let mut p2is = + CrtPolynomial::from_bigint_vectors(results.iter().map(|row| row.9.clone()).collect()); + let mut e0is = + CrtPolynomial::from_bigint_vectors(results.iter().map(|row| row.10.clone()).collect()); + let mut e0_quotients = + CrtPolynomial::from_bigint_vectors(results.iter().map(|row| row.11.clone()).collect()); + + let mut e1 = Polynomial::new(e1); + let mut u = Polynomial::new(u); + + let zkp_modulus = get_zkp_modulus(); + + pk0is.reduce_uniform(&zkp_modulus); + pk1is.reduce_uniform(&zkp_modulus); + ct0is.reduce_uniform(&zkp_modulus); + ct1is.reduce_uniform(&zkp_modulus); + r1is.reduce_uniform(&zkp_modulus); + r2is.reduce_uniform(&zkp_modulus); + p1is.reduce_uniform(&zkp_modulus); + p2is.reduce_uniform(&zkp_modulus); + e0is.reduce_uniform(&zkp_modulus); + e0_quotients.reduce_uniform(&zkp_modulus); + e1.reduce(&zkp_modulus); + u.reduce(&zkp_modulus); + e0_vec.reduce(&zkp_modulus); + k1.reduce(&zkp_modulus); + + let pk_commitment = compute_pk_aggregation_commitment(&pk0is, &pk1is, pk_bit); + let ct_commitment = compute_ciphertext_commitment(&ct0is, &ct1is, pk_bit); + + Ok(Witness { + pk0is, + pk1is, + ct0is, + ct1is, + r1is, + r2is, + p1is, + p2is, + e0is, + e0_quotients, + e0: e0_vec, + e1, + u, + k1: k1, + pk_commitment, + ct_commitment, + ciphertext: ct.to_bytes(), + }) + } + + // Used as witness for Nargo execution. + fn to_json(&self) -> serde_json::Result { + let pk0is = crt_polynomial_to_toml_json(&self.pk0is); + let pk1is = crt_polynomial_to_toml_json(&self.pk1is); + let ct0is = crt_polynomial_to_toml_json(&self.ct0is); + let ct1is = crt_polynomial_to_toml_json(&self.ct1is); + let u = polynomial_to_toml_json(&self.u); + let e0 = polynomial_to_toml_json(&self.e0); + let e0is = crt_polynomial_to_toml_json(&self.e0is); + let e0_quotients = crt_polynomial_to_toml_json(&self.e0_quotients); + let e1 = polynomial_to_toml_json(&self.e1); + let k1 = polynomial_to_toml_json(&self.k1); + let r1is = crt_polynomial_to_toml_json(&self.r1is); + let r2is = crt_polynomial_to_toml_json(&self.r2is); + let p1is = crt_polynomial_to_toml_json(&self.p1is); + let p2is = crt_polynomial_to_toml_json(&self.p2is); + let pk_commitment = self.pk_commitment.to_string(); + + let json = serde_json::json!({ + "pk0is": pk0is, + "pk1is": pk1is, + "ct0is": ct0is, + "ct1is": ct1is, + "u": u, + "e0": e0, + "e0is": e0is, + "e0_quotients": e0_quotients, + "e1": e1, + "k1": k1, + "r1is": r1is, + "r2is": r2is, + "p1is": p1is, + "p2is": p2is, + "pk_commitment": pk_commitment + }); + + Ok(json) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + use e3_fhe_params::DEFAULT_BFV_PRESET; + + #[test] + fn test_bound_and_bits_computation_consistency() { + let bounds = Bounds::compute(DEFAULT_BFV_PRESET, &()).unwrap(); + let bits = Bits::compute(DEFAULT_BFV_PRESET, &bounds).unwrap(); + + let max_pk_bound = bounds.pk_bounds.iter().max().unwrap(); + let expected_bits = calculate_bit_width(BigInt::from(max_pk_bound.clone())); + + assert_eq!(max_pk_bound.clone(), BigUint::from(34359701504u64)); + assert_eq!(bits.pk_bit, expected_bits); + } + + #[test] + fn test_constants_json_roundtrip() { + let constants = Configs::compute(DEFAULT_BFV_PRESET, &()).unwrap(); + + let json = constants.to_json().unwrap(); + let decoded: Configs = serde_json::from_value(json).unwrap(); + + assert_eq!(decoded.n, constants.n); + assert_eq!(decoded.l, constants.l); + assert_eq!(decoded.moduli, constants.moduli); + assert_eq!(decoded.bits, constants.bits); + assert_eq!(decoded.bounds, constants.bounds); + } +} diff --git a/crates/zk-helpers/src/circuits/threshold/user_data_encryption/mod.rs b/crates/zk-helpers/src/circuits/threshold/user_data_encryption/mod.rs new file mode 100644 index 0000000000..aac70235fb --- /dev/null +++ b/crates/zk-helpers/src/circuits/threshold/user_data_encryption/mod.rs @@ -0,0 +1,22 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +//! User data encryption circuit. +//! +//! This circuit proves data encryption with a BFV public key (pk0, pk1) and produces +//! Prover.toml and configs.nr for the Noir prover. See [`UserDataEncryptionCircuit`] and +//! [`UserDataEncryptionCircuitInput`]. + +pub mod circuit; +pub mod codegen; +pub mod computation; +pub mod sample; +pub mod utils; +pub use circuit::*; +pub use codegen::*; +pub use computation::*; +pub use sample::*; +pub use utils::*; diff --git a/crates/zk-helpers/src/circuits/threshold/user_data_encryption/sample.rs b/crates/zk-helpers/src/circuits/threshold/user_data_encryption/sample.rs new file mode 100644 index 0000000000..827adfa293 --- /dev/null +++ b/crates/zk-helpers/src/circuits/threshold/user_data_encryption/sample.rs @@ -0,0 +1,59 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +//! Sample data generation for user data encryption circuit. +//! +//! [`Sample`] produces a random BFV key pair and plaintext; the public key and plaintext are used as input +//! for codegen and tests. + +use e3_fhe_params::{build_pair_for_preset, BfvPreset}; +use fhe::bfv::{Encoding, Plaintext, PublicKey, SecretKey}; +use fhe_traits::FheEncoder; +use rand::thread_rng; + +/// A sample BFV public key and plaintext for user data encryption circuit codegen or tests. +#[derive(Debug, Clone)] +pub struct UserDataEncryptionSample { + pub public_key: PublicKey, + pub plaintext: Plaintext, +} + +impl UserDataEncryptionSample { + /// Generates a random secret key, public key, and plaintext for the given BFV parameters. + pub fn generate(preset: BfvPreset) -> Self { + let (threshold_params, _) = build_pair_for_preset(preset).unwrap(); + + let mut rng = thread_rng(); + + let secret_key = SecretKey::random(&threshold_params, &mut rng); + let public_key = PublicKey::new(&secret_key, &mut rng); + + let plaintext = + Plaintext::try_encode(&[1u64], Encoding::poly(), &threshold_params).unwrap(); + + Self { + public_key, + plaintext, + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use e3_fhe_params::DEFAULT_BFV_PRESET; + + #[test] + fn test_generate_sample() { + let sample = UserDataEncryptionSample::generate(DEFAULT_BFV_PRESET); + + assert_eq!(sample.public_key.c.c.len(), 2); + assert_eq!( + sample.plaintext.value.len(), + DEFAULT_BFV_PRESET.metadata().degree + ); + } +} diff --git a/crates/zk-helpers/src/circuits/threshold/user_data_encryption/utils.rs b/crates/zk-helpers/src/circuits/threshold/user_data_encryption/utils.rs new file mode 100644 index 0000000000..8b192bbbdc --- /dev/null +++ b/crates/zk-helpers/src/circuits/threshold/user_data_encryption/utils.rs @@ -0,0 +1,231 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +use crate::utils::{compute_pk_bit, get_zkp_modulus, ZkHelpersUtilsError}; +use e3_polynomial::{CrtPolynomial, CrtPolynomialError}; +use fhe::bfv::{BfvParameters, Ciphertext, PublicKey}; + +/// Converts a BFV ciphertext to Greco format. +/// +/// Takes a BFV ciphertext and converts it to Greco format, returning ct0is and ct1is +/// as CRT polynomials. +/// +/// # Arguments +/// * `params` - BFV parameters +/// * `ct` - BFV ciphertext +/// +/// # Returns +/// A tuple of (ct0is, ct1is) where each is CrtPolynomial +/// +/// # Errors +/// Returns [`CrtPolynomialError::ModuliLengthMismatch`] if `moduli.len() != self.limbs.len()`. +pub fn bfv_ciphertext_to_greco( + params: &BfvParameters, + ciphertext: &Ciphertext, +) -> Result<(CrtPolynomial, CrtPolynomial), CrtPolynomialError> { + let moduli = params.moduli(); + let zkp_modulus = get_zkp_modulus(); + + let mut ct0is = CrtPolynomial::from_fhe_polynomial(&ciphertext.c[0]); + let mut ct1is = CrtPolynomial::from_fhe_polynomial(&ciphertext.c[1]); + + ct0is.reverse(); + ct1is.reverse(); + + ct0is.center(&moduli)?; + ct1is.center(&moduli)?; + + ct0is.reduce_uniform(&zkp_modulus); + ct1is.reduce_uniform(&zkp_modulus); + + Ok((ct0is, ct1is)) +} + +/// Converts a BFV public key to Greco format. +/// +/// Takes a BFV public key and converts it to Greco format, returning pk0is and pk1is +/// as CRT polynomials. +/// +/// # Arguments +/// * `params` - BFV parameters +/// * `public_key` - BFV public key +/// +/// # Returns +/// A tuple of (pk0is, pk1is) where each is CrtPolynomial +/// +/// # Errors +/// Returns [`CrtPolynomialError::ModuliLengthMismatch`] if `moduli.len() != self.limbs.len()`. +pub fn bfv_public_key_to_greco( + params: &BfvParameters, + public_key: &PublicKey, +) -> Result<(CrtPolynomial, CrtPolynomial), CrtPolynomialError> { + let moduli = params.moduli(); + let zkp_modulus = get_zkp_modulus(); + + let mut pk0is = CrtPolynomial::from_fhe_polynomial(&public_key.c.c[0]); + let mut pk1is = CrtPolynomial::from_fhe_polynomial(&public_key.c.c[1]); + + pk0is.reverse(); + pk1is.reverse(); + + pk0is.center(&moduli)?; + pk1is.center(&moduli)?; + + pk0is.reduce_uniform(&zkp_modulus); + pk1is.reduce_uniform(&zkp_modulus); + + Ok((pk0is, pk1is)) +} + +/// Computes the commitment of the public key. +/// +/// # Arguments +/// * `params` - BFV parameters +/// * `public_key` - BFV public key +/// +/// # Returns +/// The commitment of the public key +/// +/// # Errors +/// Returns [`ZkHelpersUtilsError::ConversionError`] if the conversion fails. +/// Returns [`ZkHelpersUtilsError::CommitmentTooLong`] if the commitment is too long. +pub fn compute_public_key_commitment( + params: &BfvParameters, + public_key: &PublicKey, +) -> Result<[u8; 32], ZkHelpersUtilsError> { + use crate::commitments::compute_pk_aggregation_commitment; + + let (pk0is, pk1is) = bfv_public_key_to_greco(¶ms, &public_key).map_err(|e| { + ZkHelpersUtilsError::ConversionError(format!( + "Failed to convert public key to greco: {}", + e + )) + })?; + + let pk_bit = compute_pk_bit(params); + let commitment = compute_pk_aggregation_commitment(&pk0is, &pk1is, pk_bit); + + let bytes = commitment.to_bytes_be().1; + + if bytes.len() > 32 { + return Err(ZkHelpersUtilsError::CommitmentTooLong(bytes.len())); + } + + let mut padded_bytes = vec![0u8; 32]; + let start_idx = 32 - bytes.len(); + padded_bytes[start_idx..].copy_from_slice(&bytes); + + let public_key_hash: [u8; 32] = padded_bytes.try_into().map_err(|_| { + ZkHelpersUtilsError::ConversionError("Failed to convert padded bytes to array".into()) + })?; + + Ok(public_key_hash) +} + +/// Computes the commitment of the ciphertext. +/// +/// # Arguments +/// * `params` - BFV parameters +/// * `ciphertext` - BFV ciphertext +/// +/// # Returns +/// The commitment of the ciphertext +/// +/// # Errors +/// Returns [`ZkHelpersUtilsError::ConversionError`] if the conversion fails. +/// Returns [`ZkHelpersUtilsError::CommitmentTooLong`] if the commitment is too long. +pub fn compute_ciphertext_commitment( + params: &BfvParameters, + ciphertext: &Ciphertext, +) -> Result<[u8; 32], ZkHelpersUtilsError> { + use crate::commitments::compute_ciphertext_commitment; + + let (ct0is, ct1is) = bfv_ciphertext_to_greco(¶ms, &ciphertext).map_err(|e| { + ZkHelpersUtilsError::ConversionError(format!( + "Failed to convert ciphertext to greco: {}", + e + )) + })?; + + let pk_bit = compute_pk_bit(params); + let commitment = compute_ciphertext_commitment(&ct0is, &ct1is, pk_bit); + + let bytes = commitment.to_bytes_be().1; + + if bytes.len() > 32 { + return Err(ZkHelpersUtilsError::CommitmentTooLong(bytes.len())); + } + + let mut padded_bytes = vec![0u8; 32]; + let start_idx = 32 - bytes.len(); + padded_bytes[start_idx..].copy_from_slice(&bytes); + + let ciphertext_hash: [u8; 32] = padded_bytes.try_into().map_err(|_| { + ZkHelpersUtilsError::ConversionError("Failed to convert padded bytes to array".into()) + })?; + + Ok(ciphertext_hash) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::circuits::computation::Computation; + use crate::threshold::user_data_encryption::computation::Witness; + use crate::threshold::user_data_encryption::sample::UserDataEncryptionSample; + use crate::threshold::UserDataEncryptionCircuitInput; + use e3_fhe_params::{build_pair_for_preset, DEFAULT_BFV_PRESET}; + use fhe_traits::DeserializeParametrized; + + #[test] + fn test_bfv_public_key_to_greco() { + let (threshold_params, _) = build_pair_for_preset(DEFAULT_BFV_PRESET).unwrap(); + let sample = UserDataEncryptionSample::generate(DEFAULT_BFV_PRESET); + + let witness = Witness::compute( + DEFAULT_BFV_PRESET, + &UserDataEncryptionCircuitInput { + public_key: sample.public_key.clone(), + plaintext: sample.plaintext, + }, + ) + .unwrap(); + + // Convert using our function + let (actual_pk0is, actual_pk1is) = + bfv_public_key_to_greco(&threshold_params, &sample.public_key).unwrap(); + + // Verify the structure matches + assert_eq!(actual_pk0is, witness.pk0is); + assert_eq!(actual_pk1is, witness.pk1is); + } + + #[test] + fn test_bfv_ciphertext_to_greco() { + let (threshold_params, _) = build_pair_for_preset(DEFAULT_BFV_PRESET).unwrap(); + + let sample = UserDataEncryptionSample::generate(DEFAULT_BFV_PRESET); + + let witness = Witness::compute( + DEFAULT_BFV_PRESET, + &UserDataEncryptionCircuitInput { + public_key: sample.public_key.clone(), + plaintext: sample.plaintext, + }, + ) + .unwrap(); + + let ciphertext = Ciphertext::from_bytes(&witness.ciphertext, &threshold_params).unwrap(); + + // Convert using our function + let (actual_ct0is, actual_ct1is) = + bfv_ciphertext_to_greco(&threshold_params, &ciphertext).unwrap(); + + // Verify the structure matches + assert_eq!(actual_ct0is, witness.ct0is); + assert_eq!(actual_ct1is, witness.ct1is); + } +} diff --git a/crates/zk-helpers/src/utils.rs b/crates/zk-helpers/src/utils.rs index 73c1865119..ba3e085af8 100644 --- a/crates/zk-helpers/src/utils.rs +++ b/crates/zk-helpers/src/utils.rs @@ -16,10 +16,12 @@ use ark_bn254::Fr as Field; use ark_bn254::Fr as FieldElement; use ark_ff::PrimeField; -use e3_polynomial::CrtPolynomial; +use e3_polynomial::{CrtPolynomial, Polynomial}; use e3_safe::SafeSponge; +use fhe::bfv::BfvParameters; use num_bigint::BigInt; use num_traits::Zero; +use std::fmt::Display; use std::str::FromStr; use thiserror::Error as ThisError; @@ -27,6 +29,12 @@ use thiserror::Error as ThisError; pub enum ZkHelpersUtilsError { #[error("Failed to parse bound: {0}")] ParseBound(String), + + #[error("Conversion error: {0}")] + ConversionError(String), + + #[error("Commitment too long: {0}")] + CommitmentTooLong(usize), } pub type Result = std::result::Result; @@ -64,6 +72,21 @@ pub fn to_string_3d_vec(vec: &[Vec>]) -> Vec>> { vec.iter().map(|d1| to_string_2d_vec(d1)).collect() } +/// Join a vector of values into a string with the given separator. +/// +/// # Arguments +/// * `vec` - Slice of values to join +/// * `sep` - Separator to use between values +/// +/// # Returns +/// A string with the values joined by the separator +pub fn join_display(vec: &[T], sep: &str) -> String { + vec.iter() + .map(|x| x.to_string()) + .collect::>() + .join(sep) +} + /// Compute SAFE sponge hash with the given domain separator and inputs. /// /// This is a convenience wrapper around the SAFE sponge API that performs @@ -113,25 +136,34 @@ pub fn bigint_to_field(value: &BigInt) -> FieldElement { FieldElement::from_le_bytes_mod_order(&bytes) } -/// Calculate bit width from a bound string. +/// Calculate bit width from a bound. /// /// # Arguments -/// * `bound_str` - String representation of the bound value +/// * `bound` - Bound value /// /// # Returns -/// The calculated bit width, or an error if the bound cannot be parsed -/// -/// # Errors -/// Returns `ZkHelpersUtilsError::ParseBound` if the bound string cannot be parsed as a BigInt -pub fn calculate_bit_width(bound_str: &str) -> Result { - let bound = BigInt::from_str(bound_str) - .map_err(|e| ZkHelpersUtilsError::ParseBound(format!("{bound_str}: {e}")))?; - +/// The calculated bit width +pub fn calculate_bit_width(bound: BigInt) -> u32 { if bound <= BigInt::from(0) { - return Ok(1); // Minimum 1 bit + return 1; // Minimum 1 bit } - Ok(bound.bits() as u32) + bound.bits() as u32 +} + +/// Computes the bit width of the public key. +/// +/// # Arguments +/// * `params` - BFV parameters +/// +/// # Returns +/// The bit width of the public key +pub fn compute_pk_bit(params: &BfvParameters) -> u32 { + let moduli = params.moduli(); + let modulus = BigInt::from(moduli.iter().copied().max().unwrap()); + let bound = (modulus - BigInt::from(1)) / BigInt::from(2); + + calculate_bit_width(bound) } /// Get the ZKP modulus as a BigInt. @@ -188,26 +220,35 @@ pub fn bigint_3d_to_json_values(y: &[Vec>]) -> Vec serde_json::Value { + poly_coefficients_to_toml_json(polynomial.coefficients()) +} + #[cfg(test)] mod tests { use super::*; #[test] fn calculate_bit_width_handles_zero_and_positive_bounds() { - assert_eq!(calculate_bit_width("0").unwrap(), 1); - assert_eq!(calculate_bit_width("1").unwrap(), 1); - assert_eq!(calculate_bit_width("2").unwrap(), 2); - assert_eq!(calculate_bit_width("3").unwrap(), 2); - assert_eq!(calculate_bit_width("4").unwrap(), 3); - assert_eq!(calculate_bit_width("7").unwrap(), 3); - assert_eq!(calculate_bit_width("8").unwrap(), 4); + assert_eq!(calculate_bit_width(BigInt::from(0)), 1); + assert_eq!(calculate_bit_width(BigInt::from(1)), 1); + assert_eq!(calculate_bit_width(BigInt::from(2)), 2); + assert_eq!(calculate_bit_width(BigInt::from(3)), 2); + assert_eq!(calculate_bit_width(BigInt::from(4)), 3); + assert_eq!(calculate_bit_width(BigInt::from(7)), 3); + assert_eq!(calculate_bit_width(BigInt::from(8)), 4); } #[test] - fn calculate_bit_width_rejects_invalid_input() { - let err = calculate_bit_width("nope").unwrap_err(); - let msg = format!("{err}"); - assert!(msg.contains("Failed to parse bound")); + fn calculate_bit_width_handles_negative_bounds() { + assert_eq!(calculate_bit_width(BigInt::from(-1)), 1); } #[test] diff --git a/examples/CRISP/Cargo.lock b/examples/CRISP/Cargo.lock index 9b8ee32528..d48e0996f6 100644 --- a/examples/CRISP/Cargo.lock +++ b/examples/CRISP/Cargo.lock @@ -1448,12 +1448,6 @@ dependencies = [ "rand 0.8.5", ] -[[package]] -name = "arrayref" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb" - [[package]] name = "arrayvec" version = "0.7.6" @@ -1655,20 +1649,6 @@ dependencies = [ "wyz", ] -[[package]] -name = "blake3" -version = "1.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2468ef7d57b3fb7e16b576e8377cdbde2320c60e1491e961d11da40fc4f02a2d" -dependencies = [ - "arrayref", - "arrayvec", - "cc", - "cfg-if 1.0.4", - "constant_time_eq", - "cpufeatures", -] - [[package]] name = "block-buffer" version = "0.10.4" @@ -1954,12 +1934,6 @@ dependencies = [ "unicode-xid 0.2.6", ] -[[package]] -name = "constant_time_eq" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b" - [[package]] name = "convert_case" version = "0.6.0" @@ -2099,7 +2073,7 @@ name = "crisp-zk-inputs" version = "0.1.0" dependencies = [ "e3-fhe-params", - "e3-polynomial 0.1.8", + "e3-polynomial", "getrandom 0.2.17", "js-sys", "num-bigint", @@ -2373,14 +2347,12 @@ version = "0.1.8" dependencies = [ "anyhow", "e3-fhe-params", - "e3-greco-helpers", - "e3-polynomial 0.1.8", + "e3-polynomial", "e3-zk-helpers", "fhe", "fhe-traits", "rand 0.8.5", "thiserror 1.0.69", - "zkfhe-greco", ] [[package]] @@ -2432,16 +2404,6 @@ dependencies = [ "thiserror 1.0.69", ] -[[package]] -name = "e3-greco-helpers" -version = "0.1.8" -dependencies = [ - "e3-zk-helpers", - "fhe", - "fhe-math", - "num-bigint", -] - [[package]] name = "e3-indexer" version = "0.1.8" @@ -2479,17 +2441,6 @@ dependencies = [ "thiserror 1.0.69", ] -[[package]] -name = "e3-polynomial" -version = "0.1.8" -source = "git+https://github.com/gnosisguild/enclave?branch=main#e29a5a1308e2395fea85cc2f9540ab8c9d16a668" -dependencies = [ - "num-bigint", - "num-traits", - "serde", - "thiserror 1.0.69", -] - [[package]] name = "e3-program-server" version = "0.1.8" @@ -2516,18 +2467,6 @@ dependencies = [ "taceo-poseidon2", ] -[[package]] -name = "e3-safe" -version = "0.1.8" -source = "git+https://github.com/gnosisguild/enclave#e29a5a1308e2395fea85cc2f9540ab8c9d16a668" -dependencies = [ - "ark-bn254 0.5.0", - "ark-ff 0.5.0", - "hex", - "sha3", - "taceo-poseidon2", -] - [[package]] name = "e3-sdk" version = "0.1.8" @@ -2584,10 +2523,11 @@ dependencies = [ "clap", "e3-fhe-params", "e3-parity-matrix", - "e3-polynomial 0.1.8", - "e3-safe 0.1.8", + "e3-polynomial", + "e3-safe", "fhe", "fhe-math", + "fhe-traits", "itertools 0.14.0", "ndarray", "num-bigint", @@ -6793,7 +6733,7 @@ dependencies = [ "ark-ff 0.5.0", "e3-bfv-client", "e3-fhe-params", - "e3-polynomial 0.1.8", + "e3-polynomial", "e3-sdk", "e3-zk-helpers", "eyre", @@ -6808,7 +6748,6 @@ dependencies = [ "rayon", "serde", "serde_json", - "zkfhe-greco", ] [[package]] @@ -6821,54 +6760,6 @@ dependencies = [ "tiny-keccak", ] -[[package]] -name = "zkfhe-greco" -version = "0.1.0" -source = "git+https://github.com/gnosisguild/zkfhe-generator#f93990c3064b636dff0b6efead48a3a4341c90db" -dependencies = [ - "anyhow", - "ark-bn254 0.5.0", - "ark-ff 0.5.0", - "blake3", - "e3-polynomial 0.1.8 (git+https://github.com/gnosisguild/enclave?branch=main)", - "fhe", - "fhe-math", - "fhe-traits", - "itertools 0.14.0", - "num-bigint", - "num-traits", - "rand 0.8.5", - "rayon", - "serde", - "serde_json", - "tempfile", - "toml", - "zkfhe-shared", -] - -[[package]] -name = "zkfhe-shared" -version = "0.1.0" -source = "git+https://github.com/gnosisguild/zkfhe-generator#f93990c3064b636dff0b6efead48a3a4341c90db" -dependencies = [ - "anyhow", - "ark-bn254 0.5.0", - "ark-ff 0.5.0", - "chrono", - "e3-polynomial 0.1.8 (git+https://github.com/gnosisguild/enclave?branch=main)", - "e3-safe 0.1.8 (git+https://github.com/gnosisguild/enclave)", - "fhe", - "fhe-math", - "fhe-traits", - "num-bigint", - "num-traits", - "rand 0.8.5", - "serde", - "serde_json", - "thiserror 1.0.69", - "toml", -] - [[package]] name = "zstd" version = "0.13.3" diff --git a/examples/CRISP/circuits/src/main.nr b/examples/CRISP/circuits/src/main.nr index 4083eb1cfd..680887d846 100644 --- a/examples/CRISP/circuits/src/main.nr +++ b/examples/CRISP/circuits/src/main.nr @@ -4,11 +4,11 @@ // without even the implied warranty of MERCHANTABILITY // or FITNESS FOR A PARTICULAR PURPOSE. -use lib::configs::insecure::threshold::{ - L, N, Q_MOD_T_MOD_P, USER_DATA_ENCRYPTION_BIT_CT, USER_DATA_ENCRYPTION_BIT_E0, - USER_DATA_ENCRYPTION_BIT_E1, USER_DATA_ENCRYPTION_BIT_K, USER_DATA_ENCRYPTION_BIT_P1, - USER_DATA_ENCRYPTION_BIT_P2, USER_DATA_ENCRYPTION_BIT_PK, USER_DATA_ENCRYPTION_BIT_R1, - USER_DATA_ENCRYPTION_BIT_R2, USER_DATA_ENCRYPTION_BIT_U, USER_DATA_ENCRYPTION_CONFIGS, +use lib::configs::default::threshold::{ + L, N, USER_DATA_ENCRYPTION_BIT_CT, USER_DATA_ENCRYPTION_BIT_E0, USER_DATA_ENCRYPTION_BIT_E1, + USER_DATA_ENCRYPTION_BIT_K, USER_DATA_ENCRYPTION_BIT_P1, USER_DATA_ENCRYPTION_BIT_P2, + USER_DATA_ENCRYPTION_BIT_PK, USER_DATA_ENCRYPTION_BIT_R1, USER_DATA_ENCRYPTION_BIT_R2, + USER_DATA_ENCRYPTION_BIT_U, USER_DATA_ENCRYPTION_CONFIGS, USER_DATA_ENCRYPTION_Q_MOD_T_MOD_P, }; use lib::core::threshold::user_data_encryption::UserDataEncryption; use lib::math::commitments::compute_ciphertext_commitment; @@ -176,7 +176,7 @@ fn main( let ct_commitment = compute_ciphertext_commitment::<512, 2, 36>(ct0is, ct1is); if is_mask_vote == false { - check_coefficient_values_with_balance(k1, Q_MOD_T_MOD_P, balance); + check_coefficient_values_with_balance(k1, USER_DATA_ENCRYPTION_Q_MOD_T_MOD_P, balance); validate_signature(hashed_message, public_key_x, public_key_y, signature); let voter_address = address_to_field(derive_address(public_key_x, public_key_y)); diff --git a/examples/CRISP/crates/zk-inputs-wasm/src/lib.rs b/examples/CRISP/crates/zk-inputs-wasm/src/lib.rs index e637c3498f..d3c7ce5c8b 100644 --- a/examples/CRISP/crates/zk-inputs-wasm/src/lib.rs +++ b/examples/CRISP/crates/zk-inputs-wasm/src/lib.rs @@ -184,10 +184,10 @@ impl ZKInputsGenerator { let ct0 = CrtPolynomial::from_bigint_vectors(ct0is_vec); let ct1 = CrtPolynomial::from_bigint_vectors(ct1is_vec); - match self.generator.compute_commitment(&ct0, &ct1) { - Ok(commitment) => Ok(commitment.to_string()), - Err(e) => Err(JsValue::from_str(&e.to_string())), - } + Ok(self + .generator + .compute_ciphertext_commitment(&ct0, &ct1) + .to_string()) } /// Encrypt a vote from JavaScript. @@ -281,8 +281,8 @@ mod tests { .unwrap() .as_string() .unwrap(); - assert!(inputs_str.contains("params")); assert!(inputs_str.contains("pk0is")); + assert!(inputs_str.contains("prev_ct0is")); } #[wasm_bindgen_test] @@ -318,7 +318,7 @@ mod tests { .unwrap() .as_string() .unwrap(); - assert!(inputs_str.contains("params")); assert!(inputs_str.contains("pk0is")); + assert!(inputs_str.contains("prev_ct0is")); } } diff --git a/examples/CRISP/crates/zk-inputs/Cargo.toml b/examples/CRISP/crates/zk-inputs/Cargo.toml index f3863cacd0..7e7cf9f6d7 100644 --- a/examples/CRISP/crates/zk-inputs/Cargo.toml +++ b/examples/CRISP/crates/zk-inputs/Cargo.toml @@ -13,7 +13,6 @@ fhe-math.workspace = true fhe-traits.workspace = true e3-bfv-client = { workspace = true } e3-fhe-params = { workspace = true } -greco = { package = "zkfhe-greco", git = "https://github.com/gnosisguild/zkfhe-generator" } e3-zk-helpers = { workspace = true } e3-polynomial = { workspace = true, features = ["serde"] } serde.workspace = true diff --git a/examples/CRISP/crates/zk-inputs/src/ciphertext_addition.rs b/examples/CRISP/crates/zk-inputs/src/ciphertext_addition.rs index a757b2048c..869a4b68bf 100644 --- a/examples/CRISP/crates/zk-inputs/src/ciphertext_addition.rs +++ b/examples/CRISP/crates/zk-inputs/src/ciphertext_addition.rs @@ -6,19 +6,20 @@ use e3_polynomial::{CrtPolynomial, Polynomial}; use e3_zk_helpers::commitments::compute_ciphertext_commitment; +use e3_zk_helpers::crt_polynomial_to_toml_json; +use e3_zk_helpers::utils::compute_pk_bit; use e3_zk_helpers::utils::get_zkp_modulus; use eyre::{Context, Result}; use fhe::bfv::BfvParameters; use fhe::bfv::Ciphertext; use num_bigint::BigInt; -use std::sync::Arc; /// Set of inputs for validation of a ciphertext addition. /// /// This struct contains all the necessary data to prove that a ciphertext addition /// was performed correctly in the zero-knowledge proof system. #[derive(Clone, Debug)] -pub struct CiphertextAdditionInputs { +pub struct CiphertextAdditionWitness { pub prev_ct0is: CrtPolynomial, pub prev_ct1is: CrtPolynomial, pub sum_ct0is: CrtPolynomial, @@ -28,25 +29,23 @@ pub struct CiphertextAdditionInputs { pub prev_ct_commitment: BigInt, } -impl CiphertextAdditionInputs { +impl CiphertextAdditionWitness { /// Computes the ciphertext addition inputs for zero-knowledge proof validation. /// /// # Arguments + /// * `params` - BFV parameters /// * `prev_ct` - The existing ciphertext to add to - /// * `ct` - The ciphertext being added (from Greco) + /// * `ct` - The ciphertext being added /// * `sum_ct` - The result of the ciphertext addition - /// * `params` - BFV parameters - /// * `bit_ct` - Bit width for ciphertext bounds (used for packing) /// /// # Returns /// CiphertextAdditionInputs containing all necessary proof data pub fn compute( + params: &BfvParameters, prev_ct: &Ciphertext, ct: &Ciphertext, sum_ct: &Ciphertext, - params: Arc, - bit_ct: u32, - ) -> Result { + ) -> Result { let moduli = params.moduli(); let mut crt_polynomials = [ @@ -98,9 +97,10 @@ impl CiphertextAdditionInputs { r0.reduce_uniform(zkp_modulus); r1.reduce_uniform(zkp_modulus); - let prev_ct_commitment = compute_ciphertext_commitment(&prev_ct0, &prev_ct1, bit_ct); + let pk_bit = compute_pk_bit(params); + let prev_ct_commitment = compute_ciphertext_commitment(&prev_ct0, &prev_ct1, pk_bit); - Ok(CiphertextAdditionInputs { + Ok(CiphertextAdditionWitness { prev_ct0is: prev_ct0, prev_ct1is: prev_ct1, sum_ct0is: sum_ct0, @@ -173,70 +173,30 @@ impl CiphertextAdditionInputs { Ok(CrtPolynomial::new(quotient_limbs)) } -} - -#[cfg(test)] -mod tests { - use super::*; - use e3_fhe_params::{BfvParamSet, BfvPreset}; - use e3_zk_helpers::utils::calculate_bit_width; - use fhe::bfv::{Encoding, Plaintext, PublicKey, SecretKey}; - use fhe_traits::FheEncoder; - use greco::bounds::GrecoBounds; - use rand::thread_rng; - - fn test_bit_ct(params: &Arc) -> u32 { - let (_, bounds) = GrecoBounds::compute(params, 0).unwrap(); - calculate_bit_width(&bounds.pk_bounds[0].to_string()).unwrap() - } - - fn create_test_generator() -> (Arc, PublicKey, SecretKey) { - let param_set: BfvParamSet = BfvPreset::InsecureThreshold512.into(); - let bfv_params = param_set.build_arc(); - - let mut rng = thread_rng(); - let sk = SecretKey::random(&bfv_params, &mut rng); - let pk = PublicKey::new(&sk, &mut rng); - (bfv_params, pk, sk) - } - - fn create_test_plaintext(params: &Arc, vote: u8) -> Plaintext { - let mut message_data = vec![3u64; params.degree()]; - message_data[0] = if vote == 1 { 1 } else { 0 }; - Plaintext::try_encode(&message_data, Encoding::poly(), params).unwrap() - } - - #[test] - fn test_compute_basic_functionality() { - let (bfv_params, pk, _sk) = create_test_generator(); - let mut rng = thread_rng(); - - // Create test plaintexts. - let pt1 = create_test_plaintext(&bfv_params, 0); - let pt2 = create_test_plaintext(&bfv_params, 1); - - // Encrypt plaintexts. - let (ct1, _u1, _e0_1, _e1_1) = pk.try_encrypt_extended(&pt1, &mut rng).unwrap(); - let (ct2, _u2, _e0_2, _e1_2) = pk.try_encrypt_extended(&pt2, &mut rng).unwrap(); - - // Compute sum. - let sum_ct = &ct1 + &ct2; - - // Compute ciphertext addition inputs. - let bit_ct = test_bit_ct(&bfv_params); - let result = - CiphertextAdditionInputs::compute(&ct1, &ct2, &sum_ct, bfv_params.clone(), bit_ct); - - assert!(result.is_ok()); - let inputs = result.unwrap(); - - let num_moduli = bfv_params.moduli().len(); - assert_eq!(inputs.prev_ct0is.limbs.len(), num_moduli); - assert_eq!(inputs.prev_ct1is.limbs.len(), num_moduli); - assert_eq!(inputs.sum_ct0is.limbs.len(), num_moduli); - assert_eq!(inputs.sum_ct1is.limbs.len(), num_moduli); - assert_eq!(inputs.r0is.limbs.len(), num_moduli); - assert_eq!(inputs.r1is.limbs.len(), num_moduli); + /// Serializes the witness to a JSON string. + /// + /// # Returns + /// The JSON string representation of the witness. + pub fn to_json(&self) -> Result { + let prev_ct0is = crt_polynomial_to_toml_json(&self.prev_ct0is); + let prev_ct1is = crt_polynomial_to_toml_json(&self.prev_ct1is); + let sum_ct0is = crt_polynomial_to_toml_json(&self.sum_ct0is); + let sum_ct1is = crt_polynomial_to_toml_json(&self.sum_ct1is); + let r0is = crt_polynomial_to_toml_json(&self.r0is); + let r1is = crt_polynomial_to_toml_json(&self.r1is); + let prev_ct_commitment = self.prev_ct_commitment.to_string(); + + let json = serde_json::json!({ + "prev_ct0is": prev_ct0is, + "prev_ct1is": prev_ct1is, + "sum_ct0is": sum_ct0is, + "sum_ct1is": sum_ct1is, + "sum_r0is": r0is, + "sum_r1is": r1is, + "prev_ct_commitment": prev_ct_commitment, + }); + + Ok(json) } } diff --git a/examples/CRISP/crates/zk-inputs/src/lib.rs b/examples/CRISP/crates/zk-inputs/src/lib.rs index 314dc45c64..63c3f5d123 100644 --- a/examples/CRISP/crates/zk-inputs/src/lib.rs +++ b/examples/CRISP/crates/zk-inputs/src/lib.rs @@ -8,12 +8,18 @@ //! //! This crate contains the main logic for generating CRISP inputs for zero-knowledge proofs. +use crate::ciphertext_addition::CiphertextAdditionWitness; use e3_fhe_params::build_bfv_params_arc; use e3_fhe_params::default_param_set; use e3_fhe_params::BfvParamSet; +use e3_fhe_params::DEFAULT_BFV_PRESET; use e3_polynomial::CrtPolynomial; use e3_zk_helpers::commitments::compute_ciphertext_commitment; -use e3_zk_helpers::utils::calculate_bit_width; +use e3_zk_helpers::threshold::UserDataEncryptionCircuit; +use e3_zk_helpers::threshold::UserDataEncryptionCircuitInput; +use e3_zk_helpers::utils::compute_pk_bit; +use e3_zk_helpers::CircuitComputation; +use e3_zk_helpers::Computation; use eyre::{Context, Result}; use fhe::bfv::BfvParameters; use fhe::bfv::Ciphertext; @@ -21,16 +27,12 @@ use fhe::bfv::PublicKey; use fhe::bfv::SecretKey; use fhe::bfv::{Encoding, Plaintext}; use fhe_traits::{DeserializeParametrized, FheEncoder, Serialize}; -use greco::bounds::GrecoBounds; -use greco::vectors::GrecoVectors; use num_bigint::BigInt; use num_traits::Zero; use rand::thread_rng; use std::sync::Arc; mod ciphertext_addition; -use crate::ciphertext_addition::CiphertextAdditionInputs; -mod serialization; -use serialization::{construct_inputs, serialize_inputs_to_json}; +mod utils; pub struct ZKInputsGenerator { bfv_params: Arc, @@ -90,30 +92,19 @@ impl ZKInputsGenerator { let pt = Plaintext::try_encode(&vote, Encoding::poly(), &self.bfv_params) .with_context(|| "Failed to encode plaintext")?; - // Encrypt using the provided public key to ensure ciphertext matches the key. - let (ct, u_rns, e0_rns, e1_rns) = pk - .try_encrypt_extended(&pt, &mut thread_rng()) - .with_context(|| "Failed to encrypt plaintext")?; - - let (_, bounds) = GrecoBounds::compute(&self.bfv_params, 0)?; - - let bit_pk = calculate_bit_width(&bounds.pk_bounds[0].to_string())?; + let user_data_encryption_computation_output = UserDataEncryptionCircuit::compute( + DEFAULT_BFV_PRESET, + &UserDataEncryptionCircuitInput { + public_key: pk, + plaintext: pt, + }, + )?; - // Compute the vectors of the GRECO inputs. - let greco_vectors = GrecoVectors::compute( - &pt, - &u_rns, - &e0_rns, - &e1_rns, - &ct, - &pk, + let ct = Ciphertext::from_bytes( + &user_data_encryption_computation_output.witness.ciphertext, &self.bfv_params, - bit_pk, ) - .with_context(|| "Failed to compute vectors")?; - - let (crypto_params, bounds) = GrecoBounds::compute(&self.bfv_params, 0) - .with_context(|| "Failed to compute bounds")?; + .with_context(|| "Failed to deserialize ciphertext")?; // Ciphertext Addition Section. // Deserialize the previous ciphertext. @@ -124,25 +115,18 @@ impl ZKInputsGenerator { let sum_ct = &ct + &prev_ct; // Compute the inputs of the ciphertext addition. - // bit_pk - let ciphertext_addition_inputs = CiphertextAdditionInputs::compute( - &prev_ct, - &ct, - &sum_ct, - self.bfv_params.clone(), - bit_pk, - ) - .with_context(|| "Failed to compute ciphertext addition inputs")?; - - // Construct Inputs Section. - let inputs = construct_inputs( - &crypto_params, - &bounds, - &greco_vectors.standard_form(), - &ciphertext_addition_inputs, - ); + let ciphertext_addition_inputs = + CiphertextAdditionWitness::compute(&self.bfv_params, &prev_ct, &ct, &sum_ct) + .with_context(|| "Failed to compute ciphertext addition inputs")?; + + let ciphertext_addition_witness_json = ciphertext_addition_inputs.to_json()?; + let user_data_encryption_witness_json = + user_data_encryption_computation_output.witness.to_json()?; + let inputs_json = utils::merge_json_objects( + ciphertext_addition_witness_json, + user_data_encryption_witness_json, + )?; - let inputs_json = serialize_inputs_to_json(&inputs)?; // For updates, return the sum ciphertext (ct + prev_ct) let ciphertext_bytes = sum_ct.to_bytes(); @@ -172,30 +156,19 @@ impl ZKInputsGenerator { let pt = Plaintext::try_encode(&vote, Encoding::poly(), &self.bfv_params) .with_context(|| "Failed to encode plaintext")?; - // Encrypt using the provided public key to ensure ciphertext matches the key. - let (ct, u_rns, e0_rns, e1_rns) = pk - .try_encrypt_extended(&pt, &mut thread_rng()) - .with_context(|| "Failed to encrypt plaintext")?; - - let (_, bounds) = GrecoBounds::compute(&self.bfv_params, 0)?; - - let bit_pk = calculate_bit_width(&bounds.pk_bounds[0].to_string())?; + let user_data_encryption_computation_output = UserDataEncryptionCircuit::compute( + DEFAULT_BFV_PRESET, + &UserDataEncryptionCircuitInput { + public_key: pk, + plaintext: pt, + }, + )?; - // Compute the vectors of the GRECO inputs. - let greco_vectors = GrecoVectors::compute( - &pt, - &u_rns, - &e0_rns, - &e1_rns, - &ct, - &pk, + let ct = Ciphertext::from_bytes( + &user_data_encryption_computation_output.witness.ciphertext, &self.bfv_params, - bit_pk, ) - .with_context(|| "Failed to compute vectors")?; - - let (crypto_params, bounds) = GrecoBounds::compute(&self.bfv_params, 0) - .with_context(|| "Failed to compute bounds")?; + .with_context(|| "Failed to deserialize ciphertext")?; // Ciphertext Addition Section. // Deserialize the previous ciphertext. @@ -206,28 +179,22 @@ impl ZKInputsGenerator { let sum_ct = &ct + &prev_ct; // Compute the inputs of the ciphertext addition. - let mut ciphertext_addition_inputs = CiphertextAdditionInputs::compute( - &prev_ct, - &ct, - &sum_ct, - self.bfv_params.clone(), - bit_pk, - ) - .with_context(|| "Failed to compute ciphertext addition inputs")?; + let mut ciphertext_addition_inputs = + CiphertextAdditionWitness::compute(&self.bfv_params, &prev_ct, &ct, &sum_ct) + .with_context(|| "Failed to compute ciphertext addition inputs")?; // IMPORTANT: First-in-slot votes have no previous ciphertext; set prev_ct_commitment to 0 // so the on-chain verifier accepts the proof. ciphertext_addition_inputs.prev_ct_commitment = BigInt::zero(); - // Construct Inputs Section. - let inputs = construct_inputs( - &crypto_params, - &bounds, - &greco_vectors.standard_form(), - &ciphertext_addition_inputs, - ); + let ciphertext_addition_witness_json = ciphertext_addition_inputs.to_json()?; + let user_data_encryption_witness_json = + user_data_encryption_computation_output.witness.to_json()?; + let inputs_json = utils::merge_json_objects( + ciphertext_addition_witness_json, + user_data_encryption_witness_json, + )?; - let inputs_json = serialize_inputs_to_json(&inputs)?; let ciphertext_bytes = ct.to_bytes(); Ok((ciphertext_bytes, inputs_json)) @@ -281,11 +248,14 @@ impl ZKInputsGenerator { /// /// # Returns /// The commitment as a BigInt. - pub fn compute_commitment(&self, ct0: &CrtPolynomial, ct1: &CrtPolynomial) -> Result { - let (_, bounds) = GrecoBounds::compute(&self.bfv_params, 0)?; - let bit = calculate_bit_width(&bounds.pk_bounds[0].to_string())?; + pub fn compute_ciphertext_commitment( + &self, + ct0: &CrtPolynomial, + ct1: &CrtPolynomial, + ) -> BigInt { + let pk_bit = compute_pk_bit(&self.bfv_params); - Ok(compute_ciphertext_commitment(ct0, ct1, bit)) + compute_ciphertext_commitment(ct0, ct1, pk_bit) } } @@ -316,10 +286,10 @@ mod tests { let (ciphertext_bytes, json_output) = result.unwrap(); // Verify ciphertext is not empty assert!(!ciphertext_bytes.is_empty()); - // Verify it's valid JSON and contains expected fields. - assert!(json_output.contains("params")); + // Verify it's valid JSON and contains expected fields from both witnesses. assert!(json_output.contains("pk0is")); - assert!(json_output.contains("crypto")); + assert!(json_output.contains("prev_ct0is")); + assert!(json_output.contains("sum_ct0is")); } #[test] @@ -339,10 +309,10 @@ mod tests { let (ciphertext_bytes, json_output) = result.unwrap(); // Verify ciphertext is not empty assert!(!ciphertext_bytes.is_empty()); - // Verify it's valid JSON and contains expected fields. - assert!(json_output.contains("params")); + // Verify it's valid JSON and contains expected fields from both witnesses. assert!(json_output.contains("pk0is")); - assert!(json_output.contains("crypto")); + assert!(json_output.contains("prev_ct0is")); + assert!(json_output.contains("sum_ct0is")); } #[test] @@ -361,10 +331,10 @@ mod tests { let (ciphertext_bytes, json_output) = result.unwrap(); // Verify ciphertext is not empty assert!(!ciphertext_bytes.is_empty()); - // Verify it's valid JSON and contains expected fields. - assert!(json_output.contains("params")); + // Verify it's valid JSON and contains expected fields from both witnesses. assert!(json_output.contains("pk0is")); - assert!(json_output.contains("crypto")); + assert!(json_output.contains("prev_ct0is")); + assert!(json_output.contains("sum_ct0is")); } #[test] @@ -398,9 +368,9 @@ mod tests { assert!(result.is_ok()); let (ciphertext_bytes, json_output) = result.unwrap(); assert!(!ciphertext_bytes.is_empty()); - assert!(json_output.contains("params")); assert!(json_output.contains("pk0is")); - assert!(json_output.contains("crypto")); + assert!(json_output.contains("prev_ct0is")); + assert!(json_output.contains("sum_ct0is")); } // Error handling tests @@ -465,8 +435,7 @@ mod tests { let parsed: serde_json::Value = serde_json::from_str(&json_output).expect("Invalid JSON output"); - // Check required top-level fields. - assert!(parsed.get("params").is_some()); + // Check required top-level fields (ciphertext addition + user data encryption witnesses). assert!(parsed.get("prev_ct0is").is_some()); assert!(parsed.get("prev_ct1is").is_some()); assert!(parsed.get("sum_ct0is").is_some()); diff --git a/examples/CRISP/crates/zk-inputs/src/serialization.rs b/examples/CRISP/crates/zk-inputs/src/serialization.rs deleted file mode 100644 index 1397a6960b..0000000000 --- a/examples/CRISP/crates/zk-inputs/src/serialization.rs +++ /dev/null @@ -1,460 +0,0 @@ -// SPDX-License-Identifier: LGPL-3.0-only -// -// This file is provided WITHOUT ANY WARRANTY; -// without even the implied warranty of MERCHANTABILITY -// or FITNESS FOR A PARTICULAR PURPOSE. - -//! Serialization module for CRISP ZK inputs data. -//! -//! This module handles the serialization of inputs data to JSON format. - -use crate::ciphertext_addition::CiphertextAdditionInputs; -use eyre::{Context, Result}; -use greco::bounds::GrecoBounds; -use greco::bounds::GrecoCryptographicParameters; -use greco::vectors::GrecoVectors; -use num_bigint::BigInt; -use serde::Serialize; - -#[derive(Serialize)] -pub struct ZKInputs { - prev_ct0is: Vec, - prev_ct1is: Vec, - prev_ct_commitment: String, - sum_ct0is: Vec, - sum_ct1is: Vec, - sum_r0is: Vec, - sum_r1is: Vec, - params: serde_json::Value, - ct0is: Vec, - ct1is: Vec, - pk0is: Vec, - pk1is: Vec, - r1is: Vec, - r2is: Vec, - p1is: Vec, - p2is: Vec, - u: serde_json::Value, - e0: serde_json::Value, - e0is: Vec, - e0_quotients: Vec, - e1: serde_json::Value, - k1: serde_json::Value, - pk_commitment: String, -} - -/// Converts a 1D vector of BigInt to a vector of strings. -fn to_string_1d_vec(vec: &[BigInt]) -> Vec { - vec.iter().map(|x| x.to_string()).collect() -} - -/// Constructs a ZKInputs from GRECO bounds and vectors. -/// -/// # Arguments -/// * `crypto_params` - Cryptographic parameters from GRECO -/// * `bounds` - Bounds from GRECO -/// * `vectors_standard` - Standard form vectors from GRECO -/// * `ciphertext_addition_inputs_standard` - Standard form ciphertext addition inputs -/// -/// # Returns -/// A ZKInputs struct ready for JSON serialization -pub fn construct_inputs( - crypto_params: &GrecoCryptographicParameters, - bounds: &GrecoBounds, - vectors_standard: &GrecoVectors, - ciphertext_addition_inputs_standard: &CiphertextAdditionInputs, -) -> ZKInputs { - let mut params_json = serde_json::Map::new(); - - // Add crypto params. - let crypto_json = serde_json::json!({ - "q_mod_t": crypto_params.q_mod_t.to_string(), - "qis": crypto_params.moduli.iter().map(|b| b.to_string()).collect::>(), - "k0is": crypto_params.k0is.iter().map(|b| b.to_string()).collect::>(), - }); - params_json.insert("crypto".to_string(), crypto_json); - - // Add bounds. - let bounds_json = serde_json::json!({ - "e0_bound": bounds.e0_bound.to_string(), - "e1_bound": bounds.e1_bound.to_string(), - "u_bound": bounds.u_bound.to_string(), - "k1_low_bound": bounds.k1_low_bound.to_string(), - "k1_up_bound": bounds.k1_up_bound.to_string(), - "p1_bounds": bounds.p1_bounds.iter().map(|b| b.to_string()).collect::>(), - "p2_bounds": bounds.p2_bounds.iter().map(|b| b.to_string()).collect::>(), - "pk_bounds": bounds.pk_bounds.iter().map(|b| b.to_string()).collect::>(), - "r1_low_bounds": bounds.r1_low_bounds.iter().map(|b| b.to_string()).collect::>(), - "r1_up_bounds": bounds.r1_up_bounds.iter().map(|b| b.to_string()).collect::>(), - "r2_bounds": bounds.r2_bounds.iter().map(|b| b.to_string()).collect::>(), - }); - params_json.insert("bounds".to_string(), bounds_json); - - ZKInputs { - prev_ct0is: ciphertext_addition_inputs_standard - .prev_ct0is - .limbs - .iter() - .map(|limb| { - serde_json::json!({ - "coefficients": to_string_1d_vec(limb.coefficients()) - }) - }) - .collect(), - prev_ct1is: ciphertext_addition_inputs_standard - .prev_ct1is - .limbs - .iter() - .map(|limb| { - serde_json::json!({ - "coefficients": to_string_1d_vec(limb.coefficients()) - }) - }) - .collect(), - prev_ct_commitment: ciphertext_addition_inputs_standard - .prev_ct_commitment - .to_string(), - sum_ct0is: ciphertext_addition_inputs_standard - .sum_ct0is - .limbs - .iter() - .map(|limb| { - serde_json::json!({ - "coefficients": to_string_1d_vec(limb.coefficients()) - }) - }) - .collect(), - sum_ct1is: ciphertext_addition_inputs_standard - .sum_ct1is - .limbs - .iter() - .map(|limb| { - serde_json::json!({ - "coefficients": to_string_1d_vec(limb.coefficients()) - }) - }) - .collect(), - sum_r0is: ciphertext_addition_inputs_standard - .r0is - .limbs - .iter() - .map(|limb| { - serde_json::json!({ - "coefficients": to_string_1d_vec(limb.coefficients()) - }) - }) - .collect(), - sum_r1is: ciphertext_addition_inputs_standard - .r1is - .limbs - .iter() - .map(|limb| { - serde_json::json!({ - "coefficients": to_string_1d_vec(limb.coefficients()) - }) - }) - .collect(), - params: serde_json::Value::Object(params_json), - ct0is: vectors_standard - .ct0is - .iter() - .map(|v| { - serde_json::json!({ - "coefficients": to_string_1d_vec(v) - }) - }) - .collect(), - ct1is: vectors_standard - .ct1is - .iter() - .map(|v| { - serde_json::json!({ - "coefficients": to_string_1d_vec(v) - }) - }) - .collect(), - pk0is: vectors_standard - .pk0is - .iter() - .map(|v| { - serde_json::json!({ - "coefficients": to_string_1d_vec(v) - }) - }) - .collect(), - pk1is: vectors_standard - .pk1is - .iter() - .map(|v| { - serde_json::json!({ - "coefficients": to_string_1d_vec(v) - }) - }) - .collect(), - r1is: vectors_standard - .r1is - .iter() - .map(|v| { - serde_json::json!({ - "coefficients": to_string_1d_vec(v) - }) - }) - .collect(), - r2is: vectors_standard - .r2is - .iter() - .map(|v| { - serde_json::json!({ - "coefficients": to_string_1d_vec(v) - }) - }) - .collect(), - p1is: vectors_standard - .p1is - .iter() - .map(|v| { - serde_json::json!({ - "coefficients": to_string_1d_vec(v) - }) - }) - .collect(), - p2is: vectors_standard - .p2is - .iter() - .map(|v| { - serde_json::json!({ - "coefficients": to_string_1d_vec(v) - }) - }) - .collect(), - e0is: vectors_standard - .e0is - .iter() - .map(|v| { - serde_json::json!({ - "coefficients": to_string_1d_vec(v) - }) - }) - .collect(), - u: serde_json::json!({ - "coefficients": to_string_1d_vec(&vectors_standard.u) - }), - e0: serde_json::json!({ - "coefficients": to_string_1d_vec(&vectors_standard.e0) - }), - e0_quotients: vectors_standard - .e0_quotients - .iter() - .map(|v| { - serde_json::json!({ - "coefficients": to_string_1d_vec(v) - }) - }) - .collect(), - e1: serde_json::json!({ - "coefficients": to_string_1d_vec(&vectors_standard.e1) - }), - k1: serde_json::json!({ - "coefficients": to_string_1d_vec(&vectors_standard.k1) - }), - pk_commitment: vectors_standard.pk_commitment.to_string(), - } -} - -/// Serializes a ZKInputs to JSON string. -/// -/// # Arguments -/// * `inputs` - The ZKInputs to serialize -/// -/// # Returns -/// JSON string representation of the inputs -pub fn serialize_inputs_to_json(inputs: &ZKInputs) -> Result { - serde_json::to_string(inputs).with_context(|| "Failed to serialize inputs to JSON") -} - -#[cfg(test)] -mod tests { - use super::*; - use num_bigint::BigInt; - use num_bigint::BigUint; - use serde_json::Value; - - fn create_mock_crypto_params() -> GrecoCryptographicParameters { - GrecoCryptographicParameters { - q_mod_t: BigInt::from(12345), - moduli: vec![1000007u64, 1000009u64], - k0is: vec![1u64, 2u64], - } - } - - fn create_mock_bounds() -> GrecoBounds { - GrecoBounds { - e0_bound: BigUint::from(100u64), - e1_bound: BigUint::from(100u64), - u_bound: BigUint::from(200u64), - k1_low_bound: BigUint::from(10u64), - k1_up_bound: BigUint::from(20u64), - p1_bounds: vec![BigUint::from(30u64), BigUint::from(40u64)], - p2_bounds: vec![BigUint::from(50u64), BigUint::from(60u64)], - pk_bounds: vec![BigUint::from(70u64), BigUint::from(80u64)], - r1_low_bounds: vec![BigUint::from(90u64), BigUint::from(100u64)], - r1_up_bounds: vec![BigUint::from(110u64), BigUint::from(120u64)], - r2_bounds: vec![BigUint::from(130u64), BigUint::from(140u64)], - } - } - - fn create_mock_vectors() -> GrecoVectors { - GrecoVectors { - ct0is: vec![ - vec![BigInt::from(1), BigInt::from(2)], - vec![BigInt::from(3), BigInt::from(4)], - ], - ct1is: vec![ - vec![BigInt::from(5), BigInt::from(6)], - vec![BigInt::from(7), BigInt::from(8)], - ], - pk0is: vec![ - vec![BigInt::from(9), BigInt::from(10)], - vec![BigInt::from(11), BigInt::from(12)], - ], - pk1is: vec![ - vec![BigInt::from(13), BigInt::from(14)], - vec![BigInt::from(15), BigInt::from(16)], - ], - k0is: vec![BigInt::from(17), BigInt::from(18)], - r1is: vec![ - vec![BigInt::from(21), BigInt::from(22)], - vec![BigInt::from(23), BigInt::from(24)], - ], - r2is: vec![ - vec![BigInt::from(25), BigInt::from(26)], - vec![BigInt::from(27), BigInt::from(28)], - ], - p1is: vec![ - vec![BigInt::from(29), BigInt::from(30)], - vec![BigInt::from(31), BigInt::from(32)], - ], - p2is: vec![ - vec![BigInt::from(33), BigInt::from(34)], - vec![BigInt::from(35), BigInt::from(36)], - ], - e0is: vec![ - vec![BigInt::from(43), BigInt::from(44)], - vec![BigInt::from(45), BigInt::from(46)], - ], - e0_quotients: vec![ - vec![BigInt::from(47), BigInt::from(48)], - vec![BigInt::from(49), BigInt::from(50)], - ], - u: vec![BigInt::from(37), BigInt::from(38)], - e0: vec![BigInt::from(39), BigInt::from(40)], - e1: vec![BigInt::from(41), BigInt::from(42)], - k1: vec![BigInt::from(43), BigInt::from(44)], - pk_commitment: BigInt::from(45), - } - } - - fn create_mock_ciphertext_addition_inputs() -> CiphertextAdditionInputs { - use e3_polynomial::{CrtPolynomial, Polynomial}; - - CiphertextAdditionInputs { - prev_ct0is: CrtPolynomial::new(vec![ - Polynomial::new(vec![BigInt::from(1), BigInt::from(2)]), - Polynomial::new(vec![BigInt::from(1), BigInt::from(2)]), - ]), - prev_ct1is: CrtPolynomial::new(vec![ - Polynomial::new(vec![BigInt::from(3), BigInt::from(4)]), - Polynomial::new(vec![BigInt::from(3), BigInt::from(4)]), - ]), - prev_ct_commitment: BigInt::from(0), - sum_ct0is: CrtPolynomial::new(vec![ - Polynomial::new(vec![BigInt::from(5), BigInt::from(6)]), - Polynomial::new(vec![BigInt::from(5), BigInt::from(6)]), - ]), - sum_ct1is: CrtPolynomial::new(vec![ - Polynomial::new(vec![BigInt::from(7), BigInt::from(8)]), - Polynomial::new(vec![BigInt::from(7), BigInt::from(8)]), - ]), - r0is: CrtPolynomial::new(vec![ - Polynomial::new(vec![BigInt::from(9), BigInt::from(10)]), - Polynomial::new(vec![BigInt::from(9), BigInt::from(10)]), - ]), - r1is: CrtPolynomial::new(vec![ - Polynomial::new(vec![BigInt::from(11), BigInt::from(12)]), - Polynomial::new(vec![BigInt::from(11), BigInt::from(12)]), - ]), - } - } - - #[test] - fn test_construct_inputs_basic() { - let crypto_params = create_mock_crypto_params(); - let bounds = create_mock_bounds(); - let vectors = create_mock_vectors(); - let ciphertext_addition_inputs = create_mock_ciphertext_addition_inputs(); - - let inputs = construct_inputs( - &crypto_params, - &bounds, - &vectors, - &ciphertext_addition_inputs, - ); - - // Verify basic structure. - assert!(inputs.params.is_object()); - assert_eq!(inputs.prev_ct0is.len(), 2); // 2 moduli - assert_eq!(inputs.prev_ct1is.len(), 2); // 2 moduli - assert_eq!(inputs.sum_ct0is.len(), 2); // 2 moduli - assert_eq!(inputs.sum_ct1is.len(), 2); // 2 moduli - assert_eq!(inputs.sum_r0is.len(), 2); // 2 moduli - assert_eq!(inputs.sum_r1is.len(), 2); // 2 moduli - assert_eq!(inputs.ct0is.len(), 2); - assert_eq!(inputs.ct1is.len(), 2); - assert_eq!(inputs.pk0is.len(), 2); - assert_eq!(inputs.pk1is.len(), 2); - assert!(inputs.u.is_object()); - assert!(inputs.e0.is_object()); - assert!(inputs.e1.is_object()); - assert!(inputs.k1.is_object()); - assert!(inputs.pk_commitment.len() > 0); - } - - #[test] - fn test_serialize_inputs_to_json() { - let crypto_params = create_mock_crypto_params(); - let bounds = create_mock_bounds(); - let vectors = create_mock_vectors(); - let ciphertext_addition_inputs = create_mock_ciphertext_addition_inputs(); - - let inputs = construct_inputs( - &crypto_params, - &bounds, - &vectors, - &ciphertext_addition_inputs, - ); - - let json_result = serialize_inputs_to_json(&inputs); - assert!(json_result.is_ok()); - - let json_string = json_result.unwrap(); - assert!(!json_string.is_empty()); - - // Verify it's valid JSON. - let parsed: Value = serde_json::from_str(&json_string).unwrap(); - assert!(parsed.is_object()); - - // Verify required fields exist. - assert!(parsed.get("params").is_some()); - assert!(parsed.get("prev_ct0is").is_some()); - assert!(parsed.get("prev_ct1is").is_some()); - assert!(parsed.get("sum_ct0is").is_some()); - assert!(parsed.get("sum_ct1is").is_some()); - assert!(parsed.get("sum_r0is").is_some()); - assert!(parsed.get("sum_r1is").is_some()); - assert!(parsed.get("ct0is").is_some()); - assert!(parsed.get("ct1is").is_some()); - assert!(parsed.get("pk0is").is_some()); - assert!(parsed.get("pk1is").is_some()); - assert!(parsed.get("pk_commitment").is_some()); - } -} diff --git a/examples/CRISP/crates/zk-inputs/src/utils.rs b/examples/CRISP/crates/zk-inputs/src/utils.rs new file mode 100644 index 0000000000..7686207a53 --- /dev/null +++ b/examples/CRISP/crates/zk-inputs/src/utils.rs @@ -0,0 +1,17 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// +// This file is provided WITHOUT ANY WARRANTY; +// without even the implied warranty of MERCHANTABILITY +// or FITNESS FOR A PARTICULAR PURPOSE. + +use eyre::{Context, Result}; + +/// Merges two JSON objects into one. All keys end up at the same level; keys from `b` overwrite `a` on conflict. +pub fn merge_json_objects(a: serde_json::Value, b: serde_json::Value) -> Result { + let mut merged: serde_json::Map = + serde_json::from_value(a).with_context(|| "First value is not a JSON object")?; + let other: serde_json::Map = + serde_json::from_value(b).with_context(|| "Second value is not a JSON object")?; + merged.extend(other); + serde_json::to_string(&merged).with_context(|| "Failed to serialize merged JSON") +} diff --git a/examples/CRISP/packages/crisp-contracts/contracts/CRISPVerifier.sol b/examples/CRISP/packages/crisp-contracts/contracts/CRISPVerifier.sol index 61f74fbb76..68144fa398 100644 --- a/examples/CRISP/packages/crisp-contracts/contracts/CRISPVerifier.sol +++ b/examples/CRISP/packages/crisp-contracts/contracts/CRISPVerifier.sol @@ -8,145 +8,145 @@ pragma solidity >=0.8.21; uint256 constant N = 524288; uint256 constant LOG_N = 19; uint256 constant NUMBER_OF_PUBLIC_INPUTS = 22; -uint256 constant VK_HASH = 0x2b0041358baea9b8c5aefe9d8b81e37afb5d47caef0f98834fb622b4c6a5baa4; +uint256 constant VK_HASH = 0x0d1810a5380726df7f2b08f92f82c487f3d760adc1a8a40f9a60100ff78d5447; library HonkVerificationKey { - function loadVerificationKey() internal pure returns (Honk.VerificationKey memory) { - Honk.VerificationKey memory vk = Honk.VerificationKey({ - circuitSize: uint256(524288), - logCircuitSize: uint256(19), - publicInputsSize: uint256(22), - ql: Honk.G1Point({ - x: uint256(0x0d306d1d0c63613a48dc5abe4b2d7d89e680fc23e7bb9d336cfb508f74bcfaf3), - y: uint256(0x29429b5c554e27fcac103767a9f6f2bab4aae92dfb15fd6bc48514e4314faffb) - }), - qr: Honk.G1Point({ - x: uint256(0x12aa83a3bb7c76aa0c9ab474db4e54b58bf32db8a0eb3c8f8f77df9153dad683), - y: uint256(0x1a7319cfed3b28a31452d319dd658b434ed14bbcefa15454a4b5222deb719ac8) - }), - qo: Honk.G1Point({ - x: uint256(0x043209f3c3339044bc2f357345b0cdaa38fff6764c552ab6b594a13508e9f5cb), - y: uint256(0x1154d66255304bf2cf33d5f8c787581f9da9c9fcfec6f27a55fa41c40896cde3) - }), - q4: Honk.G1Point({ - x: uint256(0x25c3c2dd37835eb64ad767434d7dcca998202ea1b40ea8566f1fa5502ca7cdaa), - y: uint256(0x119dd1ff560c0d3166d0077cff431634c26419c4183f51552eb746e41014c78b) - }), - qm: Honk.G1Point({ - x: uint256(0x13d119792e7e750790cf48119095b26413c1441d811ed78bc471374043d6f4f2), - y: uint256(0x0a9c42dc2ec320da7f3be004c85731dfc8de9f97d78e6cdd25e3e0c5aa26e366) - }), - qc: Honk.G1Point({ - x: uint256(0x0db38a1631e43c2a46fd673796e30dd05ea573144d7568287c42766e97e27a11), - y: uint256(0x2e07cbcb06ab00c6e66e91073939d6569895e3cf8a9362a7618210293cab7123) - }), - qLookup: Honk.G1Point({ - x: uint256(0x111ada27d4243c5df982e1cd77f2d9aff394ba4f2ba2faf8ec1a8e5b6d78d1e7), - y: uint256(0x1cf81a5fe339ef18222213e43155e149d0211317fe0a68d795681f31ef25ad0f) - }), - qArith: Honk.G1Point({ - x: uint256(0x0e6e2cfb84841f47a5fa298f450fd5243d507fcdb00f4c48f1e243cf57049a67), - y: uint256(0x00d9ab0bb955c983e38300c94e5ae861a08885fc8bb305d91e67f11c874a1001) - }), - qDeltaRange: Honk.G1Point({ - x: uint256(0x2ba1b435d3f81aa89afed52806855ff1d8b90c2a7aee4ee8fd52eb625a3b7ebd), - y: uint256(0x0007a55c032aade5d159dd462c04c83e64098ec3c1151d9c8f9eef8f2b1fba05) - }), - qElliptic: Honk.G1Point({ - x: uint256(0x2b24f14283de6577a18ef01dbc9022725fb5c62a82fd8c4713f0e62f6253a595), - y: uint256(0x0d044e82b87a1ad728e0523fb22bc6762e5e0938afc863f91b255cef0bd5af18) - }), - qMemory: Honk.G1Point({ - x: uint256(0x0df15372ccc6ce24c6751d8c896204faef619787c6c02b21978672ecba3d24a7), - y: uint256(0x143888f072a0e5872f7d1e8ac3781f077628ea2d6f2e13025ae7fe2060c4acc4) - }), - qNnf: Honk.G1Point({ - x: uint256(0x1b72e8b6ba56d190a83fa6d1970de92ae5ab6f927bcef54624d9bbbb46dc4e9d), - y: uint256(0x0c97aefa71025d186851d72ed7094b649e2e691ff943f6a6941f1a0bef03351e) - }), - qPoseidon2External: Honk.G1Point({ - x: uint256(0x23d582f227815530d77e689696ed98a5d1fc9f673b8b24397fdae321e6914f8f), - y: uint256(0x270ff538446d18c614d2a48011428aaae8b1a2f8d11d83ce4896af795a9a63f8) - }), - qPoseidon2Internal: Honk.G1Point({ - x: uint256(0x08183c7bc115e1108efc636a0ae1f642aaa943272a215ed2228b1cd77a9f1e3c), - y: uint256(0x21f39dc097acbf0fedd82157aa1aab463983efc62a6c662dc65565403a763daa) - }), - s1: Honk.G1Point({ - x: uint256(0x0040fbe6b6de18f635fbfe6df0390a99dd432b0bb7c570db5e74bf9a070ca7c2), - y: uint256(0x25062102553ab2e993c4e14223952c978de971f23a461e10b9bd04f0fdeab4d5) - }), - s2: Honk.G1Point({ - x: uint256(0x22a3a51c8383d307eebb0fc19bfa4936e2c618e0220229b184918f15987f3e26), - y: uint256(0x27b77c9721777a091171595b7841a7510b2fb232fb7150088d25232d1b06fb79) - }), - s3: Honk.G1Point({ - x: uint256(0x2dcca1266a5c5d36ada653c4763f4117c3195eb90f64a862660955d8c5057996), - y: uint256(0x0731e236fdd155990552885f3fcb1aea9dd2367bedc1b19b76ad0d7e8fc6a940) - }), - s4: Honk.G1Point({ - x: uint256(0x14ad36c110bdde3d7015314b9be1047dc9c680eb68de696f74ec149596132b09), - y: uint256(0x2cb9687e59419594e09a6e5e57b054e31e70d7ff41ab966abcb7922cf9376c0c) - }), - t1: Honk.G1Point({ - x: uint256(0x1f16b037f0b4c96ea2a30a118a44e139881c0db8a4d6c9fde7db5c1c1738e61f), - y: uint256(0x00c7781bda34afc32dedfb0d0f6b16c987c83375da000e180b44ad25685fc2ae) - }), - t2: Honk.G1Point({ - x: uint256(0x29345f914a28707887bee191c3a928191de584827a6d1a78ccce1d7629ca9dc0), - y: uint256(0x1920cebd0b33ac9713424e3bc03d53d79dc72f6afc24c90e56593094a213444c) - }), - t3: Honk.G1Point({ - x: uint256(0x261c990958bc2ef77a45467d9639ab2c68cf787ff7bce55ce3074dfdaedc8f8f), - y: uint256(0x23c1c05424a40360a61e46f4deab04988a6f5b71dda351e0da608cff1f332ee0) - }), - t4: Honk.G1Point({ - x: uint256(0x2b651d2fd644b2972d72ec439dc69d3339d0b052a296bfc48c6a08396aaca078), - y: uint256(0x2d7e8c1ecb92e2490049b50efc811df63f1ca97e58d5e82852dbec0c29715d71) - }), - id1: Honk.G1Point({ - x: uint256(0x103a82e5af3ccf8643340b5f15768479a4782a49162765bc61e6fc846726021c), - y: uint256(0x0dd1ee161e5b8ff32d37fb77678dec1bb40bd4b8cd74858604d3ab6eaaed3310) - }), - id2: Honk.G1Point({ - x: uint256(0x17de68e6aee588fe846863e52d2465668f70642ac0b8fa0fcc3a3604a28e3ec7), - y: uint256(0x1a6fce004d6919a0bfcb90700446fcda044728ac7d372ca53046dec27043c1c3) - }), - id3: Honk.G1Point({ - x: uint256(0x14a6b51bfb858091c94eff6a421fdab3fbc85f2c83822a7eadc8b1a4c4e60a27), - y: uint256(0x1262e534b80be874e870d42a49a16680742ed79775e56423ee5c575ffff49829) - }), - id4: Honk.G1Point({ - x: uint256(0x138bcba7c660c48a5043506dcc3155b6a8e42ac5fbc6740711318258083c4019), - y: uint256(0x27d9d0e5d7fc355126383d930123a4b27c01cb762d9c54b5ff76b0da55a4b0cf) - }), - lagrangeFirst: Honk.G1Point({ - x: uint256(0x0000000000000000000000000000000000000000000000000000000000000001), - y: uint256(0x0000000000000000000000000000000000000000000000000000000000000002) - }), - lagrangeLast: Honk.G1Point({ - x: uint256(0x0acf43d755049cab0c892f5431e112f0f1fc59eaad7fe2a4d5acf910a9ad4ec2), - y: uint256(0x1672c20921ffdc4da8f5357b4a85ba97d3131364017d9a511d7c620c1672b9f7) - }) - }); - return vk; - } + function loadVerificationKey() internal pure returns (Honk.VerificationKey memory) { + Honk.VerificationKey memory vk = Honk.VerificationKey({ + circuitSize: uint256(524288), + logCircuitSize: uint256(19), + publicInputsSize: uint256(22), + ql: Honk.G1Point({ + x: uint256(0x1eb01d05127f0ed707dc8503d0a7d25885baea8b0c98563efd70ac55f817516d), + y: uint256(0x0cf0a717cac3de516e6a477c2687bcd08bb32c42fa7d1b2cc2e7f2f6b198fc89) + }), + qr: Honk.G1Point({ + x: uint256(0x301817b52c30490b01e12cb8e2fdc4a21db112a43ce6d81daa39bcc74fbf6a76), + y: uint256(0x0dcd3414d404788c8c805231fa02cbcd59329213a5cba9c4ed7e1011cf69e08f) + }), + qo: Honk.G1Point({ + x: uint256(0x17d862c243c5c9a412625c224562afcf1d26c1c6a84e9ccceeb2dfaa9bdcd971), + y: uint256(0x17624640a73d43956c92e313ba2c35290f9861c5853ffa853b83a1d82be4fadf) + }), + q4: Honk.G1Point({ + x: uint256(0x1111073639e9841771bce62416eaa019d23f8fb0be159f81a4f63459eaed8b40), + y: uint256(0x05081b930ce6c8bdb65ed56b4235bd5f373d83fea4c26dbb8967a51bfede3e2c) + }), + qm: Honk.G1Point({ + x: uint256(0x046b9d72697187909ab4befcaefede5d4173c5a26629764c8401559e9679a5a0), + y: uint256(0x27967fdef3f0fb79ecabfda958a0c0f0c5c6a282d89a076a6c882e051dbbf52e) + }), + qc: Honk.G1Point({ + x: uint256(0x1346e6ddaa85d629ae3097601e59853da73d237101071c8033457d8b6eac41e0), + y: uint256(0x0e89865836f7649ecf008469f45b1f03372a22c85e77ebbdd6dc55445d70388b) + }), + qLookup: Honk.G1Point({ + x: uint256(0x111ada27d4243c5df982e1cd77f2d9aff394ba4f2ba2faf8ec1a8e5b6d78d1e7), + y: uint256(0x1cf81a5fe339ef18222213e43155e149d0211317fe0a68d795681f31ef25ad0f) + }), + qArith: Honk.G1Point({ + x: uint256(0x244dc3908821783bb977a87c1763bbe886db610a6e514d24a490eb283210a724), + y: uint256(0x2b11c1f1176f2f7e5861d2ad44379615b88ac5bbef644f5be7325820d8efa6e6) + }), + qDeltaRange: Honk.G1Point({ + x: uint256(0x1525c94dbf851bfe5106f1161bdcfad88a1344573ba46dffe4038f7adbcf42fa), + y: uint256(0x1904ec19ea7983af8357ac58ccd1ed56d9bf7a8cac2b566965c70e73a84395c6) + }), + qElliptic: Honk.G1Point({ + x: uint256(0x11eba2db2ab62fb9bec21edb7288f8c0b9308be71c17b7785624bdfb307926a7), + y: uint256(0x04145b1eabf74671d40172eb7be7f99ff4dd8f15eb0d2902c333508ef42a382d) + }), + qMemory: Honk.G1Point({ + x: uint256(0x236299c1959f6e2adc7d43d8ad8fc5ccf43319f46ad93fafd9a00be053b257b4), + y: uint256(0x166f10cd084ef75ba9c076ca1e15bde5ed98b185ecf45cb5512934dc9c492d3c) + }), + qNnf: Honk.G1Point({ + x: uint256(0x1d3e7e3f4080f0bdd2a1a5bc2bfa36f64097c596221a3b3f62ede9ab7a6855d6), + y: uint256(0x0bb8145dc0311f1a28c94223158e14b221c6a6ba88ba63b61a1ecbb6bbf69ba7) + }), + qPoseidon2External: Honk.G1Point({ + x: uint256(0x12e23206a31483962cfec35d3907edfef6f50fefa5a9667ed0de944f5643bc46), + y: uint256(0x06ba4ff51c864bfba1dbf99e0e9dd90bc78cd2814af3cfec455ba8cd9f917ae0) + }), + qPoseidon2Internal: Honk.G1Point({ + x: uint256(0x1779bf22b880563164904fffbaf98feb7b78ce9c79409a2dc06803faa7738d14), + y: uint256(0x2f1b4a1b1e6e9431171cc29177216d390bacdc5bc4e6520701ebf90c1dd737b9) + }), + s1: Honk.G1Point({ + x: uint256(0x02150c3a7adf0e555a6ec3a39623e6598d67b8b6c3f6861c2c34579391adce83), + y: uint256(0x20166c3c8229270370e3c98a6eeab77c380a4dce5c8f7c880b5ef0e15658416f) + }), + s2: Honk.G1Point({ + x: uint256(0x2eed284bee3073de97d763d6580bf565a9f1bd5c6a4b74100a844f928bcb6cb2), + y: uint256(0x19fb446bd293ba31c99260ac26158e97bd21dcd212e52f1e508970023e99c16a) + }), + s3: Honk.G1Point({ + x: uint256(0x249f33e330bdd131510a7d5c9b4e3ddf52c90e09bdce5b7b24f8eacf3497118e), + y: uint256(0x133e60ef293c37d5bb698943f56d41e00eadce2fac70ca77e910ae2bc9f62d77) + }), + s4: Honk.G1Point({ + x: uint256(0x1f370faf2a53ec17468cabb2f6ac57af3b1dd0f892d909458849b8f4e4c6d572), + y: uint256(0x26bd449fecf6ee20800d3ff09c39c4eef2d3d99f63411a7516a3b781192d99e4) + }), + t1: Honk.G1Point({ + x: uint256(0x1f16b037f0b4c96ea2a30a118a44e139881c0db8a4d6c9fde7db5c1c1738e61f), + y: uint256(0x00c7781bda34afc32dedfb0d0f6b16c987c83375da000e180b44ad25685fc2ae) + }), + t2: Honk.G1Point({ + x: uint256(0x29345f914a28707887bee191c3a928191de584827a6d1a78ccce1d7629ca9dc0), + y: uint256(0x1920cebd0b33ac9713424e3bc03d53d79dc72f6afc24c90e56593094a213444c) + }), + t3: Honk.G1Point({ + x: uint256(0x261c990958bc2ef77a45467d9639ab2c68cf787ff7bce55ce3074dfdaedc8f8f), + y: uint256(0x23c1c05424a40360a61e46f4deab04988a6f5b71dda351e0da608cff1f332ee0) + }), + t4: Honk.G1Point({ + x: uint256(0x2b651d2fd644b2972d72ec439dc69d3339d0b052a296bfc48c6a08396aaca078), + y: uint256(0x2d7e8c1ecb92e2490049b50efc811df63f1ca97e58d5e82852dbec0c29715d71) + }), + id1: Honk.G1Point({ + x: uint256(0x0a9bc8fccb44c78872a06dd9016b80b7084d6a70ce55c27f061c99ab1f26818c), + y: uint256(0x1eac735269ae23618ad9589c0f69badabec3708c2f9e3d85c9e507cb2910779b) + }), + id2: Honk.G1Point({ + x: uint256(0x23a69b03367031d28ddf924a90ec5ceac5303e626aa020ed4f1b34a21b5e3216), + y: uint256(0x102d01605aa60b548deeecf33ec29a55caae77bf3f2438d9c5bbb0142146bc8e) + }), + id3: Honk.G1Point({ + x: uint256(0x279ea1e4647feb583d86fe589ad0fdca967707ab42b832e0a573c84ab0027c4f), + y: uint256(0x27ba04b7a10f3d381a372463d50944b9de0eb6f6a580f5b071b30e0457d745ac) + }), + id4: Honk.G1Point({ + x: uint256(0x12e25ecddf78a4cbea4ff6f1768f7a7c1ea402c02cbfbcb30074a4f588658278), + y: uint256(0x0ad9b38fa164e6d267da400101391f08124db7c7119026a66ae10ebb0f894c47) + }), + lagrangeFirst: Honk.G1Point({ + x: uint256(0x0000000000000000000000000000000000000000000000000000000000000001), + y: uint256(0x0000000000000000000000000000000000000000000000000000000000000002) + }), + lagrangeLast: Honk.G1Point({ + x: uint256(0x2861c109e91e85da8c005bf4560aab5a2ebf9cc5445abac0b943acde2dc148d1), + y: uint256(0x1b7fc9728e18fac8e6ffc450286c5d43f985591a689d27076642e91be48ad25e) + }) + }); + return vk; + } } pragma solidity ^0.8.27; interface IVerifier { - function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external returns (bool); + function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external returns (bool); } type Fr is uint256; -using {add as +} for Fr global; -using {sub as -} for Fr global; -using {mul as *} for Fr global; +using { add as + } for Fr global; +using { sub as - } for Fr global; +using { mul as * } for Fr global; -using {exp as ^} for Fr global; -using {notEqual as !=} for Fr global; -using {equal as ==} for Fr global; +using { exp as ^ } for Fr global; +using { notEqual as != } for Fr global; +using { equal as == } for Fr global; uint256 constant SUBGROUP_SIZE = 256; uint256 constant MODULUS = 21888242871839275222246405745257275088548364400416034343698204186575808495617; // Prime field order @@ -159,135 +159,135 @@ Fr constant ZERO = Fr.wrap(0); // Instantiation library FrLib { - function from(uint256 value) internal pure returns (Fr) { - unchecked { - return Fr.wrap(value % MODULUS); - } - } - - function fromBytes32(bytes32 value) internal pure returns (Fr) { - unchecked { - return Fr.wrap(uint256(value) % MODULUS); - } - } - - function toBytes32(Fr value) internal pure returns (bytes32) { - unchecked { - return bytes32(Fr.unwrap(value)); - } - } - - function invert(Fr value) internal view returns (Fr) { - uint256 v = Fr.unwrap(value); - uint256 result; - - // Call the modexp precompile to invert in the field - assembly { - let free := mload(0x40) - mstore(free, 0x20) - mstore(add(free, 0x20), 0x20) - mstore(add(free, 0x40), 0x20) - mstore(add(free, 0x60), v) - mstore(add(free, 0x80), sub(MODULUS, 2)) - mstore(add(free, 0xa0), MODULUS) - let success := staticcall(gas(), 0x05, free, 0xc0, 0x00, 0x20) - if iszero(success) { - revert(0, 0) - } - result := mload(0x00) - mstore(0x40, add(free, 0x80)) - } - - return Fr.wrap(result); - } - - function pow(Fr base, uint256 v) internal view returns (Fr) { - uint256 b = Fr.unwrap(base); - uint256 result; - - // Call the modexp precompile to invert in the field - assembly { - let free := mload(0x40) - mstore(free, 0x20) - mstore(add(free, 0x20), 0x20) - mstore(add(free, 0x40), 0x20) - mstore(add(free, 0x60), b) - mstore(add(free, 0x80), v) - mstore(add(free, 0xa0), MODULUS) - let success := staticcall(gas(), 0x05, free, 0xc0, 0x00, 0x20) - if iszero(success) { - revert(0, 0) - } - result := mload(0x00) - mstore(0x40, add(free, 0x80)) - } - - return Fr.wrap(result); - } - - function div(Fr numerator, Fr denominator) internal view returns (Fr) { - unchecked { - return numerator * invert(denominator); - } - } - - function sqr(Fr value) internal pure returns (Fr) { - unchecked { - return value * value; - } - } - - function unwrap(Fr value) internal pure returns (uint256) { - unchecked { - return Fr.unwrap(value); - } - } - - function neg(Fr value) internal pure returns (Fr) { - unchecked { - return Fr.wrap(MODULUS - Fr.unwrap(value)); - } + function from(uint256 value) internal pure returns (Fr) { + unchecked { + return Fr.wrap(value % MODULUS); + } + } + + function fromBytes32(bytes32 value) internal pure returns (Fr) { + unchecked { + return Fr.wrap(uint256(value) % MODULUS); + } + } + + function toBytes32(Fr value) internal pure returns (bytes32) { + unchecked { + return bytes32(Fr.unwrap(value)); + } + } + + function invert(Fr value) internal view returns (Fr) { + uint256 v = Fr.unwrap(value); + uint256 result; + + // Call the modexp precompile to invert in the field + assembly { + let free := mload(0x40) + mstore(free, 0x20) + mstore(add(free, 0x20), 0x20) + mstore(add(free, 0x40), 0x20) + mstore(add(free, 0x60), v) + mstore(add(free, 0x80), sub(MODULUS, 2)) + mstore(add(free, 0xa0), MODULUS) + let success := staticcall(gas(), 0x05, free, 0xc0, 0x00, 0x20) + if iszero(success) { + revert(0, 0) + } + result := mload(0x00) + mstore(0x40, add(free, 0x80)) + } + + return Fr.wrap(result); + } + + function pow(Fr base, uint256 v) internal view returns (Fr) { + uint256 b = Fr.unwrap(base); + uint256 result; + + // Call the modexp precompile to invert in the field + assembly { + let free := mload(0x40) + mstore(free, 0x20) + mstore(add(free, 0x20), 0x20) + mstore(add(free, 0x40), 0x20) + mstore(add(free, 0x60), b) + mstore(add(free, 0x80), v) + mstore(add(free, 0xa0), MODULUS) + let success := staticcall(gas(), 0x05, free, 0xc0, 0x00, 0x20) + if iszero(success) { + revert(0, 0) + } + result := mload(0x00) + mstore(0x40, add(free, 0x80)) + } + + return Fr.wrap(result); + } + + function div(Fr numerator, Fr denominator) internal view returns (Fr) { + unchecked { + return numerator * invert(denominator); } + } + + function sqr(Fr value) internal pure returns (Fr) { + unchecked { + return value * value; + } + } + + function unwrap(Fr value) internal pure returns (uint256) { + unchecked { + return Fr.unwrap(value); + } + } + + function neg(Fr value) internal pure returns (Fr) { + unchecked { + return Fr.wrap(MODULUS - Fr.unwrap(value)); + } + } } // Free functions function add(Fr a, Fr b) pure returns (Fr) { - unchecked { - return Fr.wrap(addmod(Fr.unwrap(a), Fr.unwrap(b), MODULUS)); - } + unchecked { + return Fr.wrap(addmod(Fr.unwrap(a), Fr.unwrap(b), MODULUS)); + } } function mul(Fr a, Fr b) pure returns (Fr) { - unchecked { - return Fr.wrap(mulmod(Fr.unwrap(a), Fr.unwrap(b), MODULUS)); - } + unchecked { + return Fr.wrap(mulmod(Fr.unwrap(a), Fr.unwrap(b), MODULUS)); + } } function sub(Fr a, Fr b) pure returns (Fr) { - unchecked { - return Fr.wrap(addmod(Fr.unwrap(a), MODULUS - Fr.unwrap(b), MODULUS)); - } + unchecked { + return Fr.wrap(addmod(Fr.unwrap(a), MODULUS - Fr.unwrap(b), MODULUS)); + } } function exp(Fr base, Fr exponent) pure returns (Fr) { - if (Fr.unwrap(exponent) == 0) return Fr.wrap(1); - // Implement exponent with a loop as we will overflow otherwise - for (uint256 i = 1; i < Fr.unwrap(exponent); i += i) { - base = base * base; - } - return base; + if (Fr.unwrap(exponent) == 0) return Fr.wrap(1); + // Implement exponent with a loop as we will overflow otherwise + for (uint256 i = 1; i < Fr.unwrap(exponent); i += i) { + base = base * base; + } + return base; } function notEqual(Fr a, Fr b) pure returns (bool) { - unchecked { - return Fr.unwrap(a) != Fr.unwrap(b); - } + unchecked { + return Fr.unwrap(a) != Fr.unwrap(b); + } } function equal(Fr a, Fr b) pure returns (bool) { - unchecked { - return Fr.unwrap(a) == Fr.unwrap(b); - } + unchecked { + return Fr.unwrap(a) == Fr.unwrap(b); + } } uint256 constant CONST_PROOF_SIZE_LOG_N = 28; @@ -308,1332 +308,1325 @@ uint256 constant NUMBER_OF_ALPHAS = NUMBER_OF_SUBRELATIONS - 1; // ENUM FOR WIRES enum WIRE { - Q_M, - Q_C, - Q_L, - Q_R, - Q_O, - Q_4, - Q_LOOKUP, - Q_ARITH, - Q_RANGE, - Q_ELLIPTIC, - Q_MEMORY, - Q_NNF, - Q_POSEIDON2_EXTERNAL, - Q_POSEIDON2_INTERNAL, - SIGMA_1, - SIGMA_2, - SIGMA_3, - SIGMA_4, - ID_1, - ID_2, - ID_3, - ID_4, - TABLE_1, - TABLE_2, - TABLE_3, - TABLE_4, - LAGRANGE_FIRST, - LAGRANGE_LAST, - W_L, - W_R, - W_O, - W_4, - Z_PERM, - LOOKUP_INVERSES, - LOOKUP_READ_COUNTS, - LOOKUP_READ_TAGS, - W_L_SHIFT, - W_R_SHIFT, - W_O_SHIFT, - W_4_SHIFT, - Z_PERM_SHIFT + Q_M, + Q_C, + Q_L, + Q_R, + Q_O, + Q_4, + Q_LOOKUP, + Q_ARITH, + Q_RANGE, + Q_ELLIPTIC, + Q_MEMORY, + Q_NNF, + Q_POSEIDON2_EXTERNAL, + Q_POSEIDON2_INTERNAL, + SIGMA_1, + SIGMA_2, + SIGMA_3, + SIGMA_4, + ID_1, + ID_2, + ID_3, + ID_4, + TABLE_1, + TABLE_2, + TABLE_3, + TABLE_4, + LAGRANGE_FIRST, + LAGRANGE_LAST, + W_L, + W_R, + W_O, + W_4, + Z_PERM, + LOOKUP_INVERSES, + LOOKUP_READ_COUNTS, + LOOKUP_READ_TAGS, + W_L_SHIFT, + W_R_SHIFT, + W_O_SHIFT, + W_4_SHIFT, + Z_PERM_SHIFT } library Honk { - struct G1Point { - uint256 x; - uint256 y; - } - - struct VerificationKey { - // Misc Params - uint256 circuitSize; - uint256 logCircuitSize; - uint256 publicInputsSize; - // Selectors - G1Point qm; - G1Point qc; - G1Point ql; - G1Point qr; - G1Point qo; - G1Point q4; - G1Point qLookup; // Lookup - G1Point qArith; // Arithmetic widget - G1Point qDeltaRange; // Delta Range sort - G1Point qMemory; // Memory - G1Point qNnf; // Non-native Field - G1Point qElliptic; // Auxillary - G1Point qPoseidon2External; - G1Point qPoseidon2Internal; - // Copy cnstraints - G1Point s1; - G1Point s2; - G1Point s3; - G1Point s4; - // Copy identity - G1Point id1; - G1Point id2; - G1Point id3; - G1Point id4; - // Precomputed lookup table - G1Point t1; - G1Point t2; - G1Point t3; - G1Point t4; - // Fixed first and last - G1Point lagrangeFirst; - G1Point lagrangeLast; - } - - struct RelationParameters { - // challenges - Fr eta; - Fr etaTwo; - Fr etaThree; - Fr beta; - Fr gamma; - // derived - Fr publicInputsDelta; - } - - struct Proof { - // Pairing point object - Fr[PAIRING_POINTS_SIZE] pairingPointObject; - // Free wires - G1Point w1; - G1Point w2; - G1Point w3; - G1Point w4; - // Lookup helpers - Permutations - G1Point zPerm; - // Lookup helpers - logup - G1Point lookupReadCounts; - G1Point lookupReadTags; - G1Point lookupInverses; - // Sumcheck - Fr[BATCHED_RELATION_PARTIAL_LENGTH][CONST_PROOF_SIZE_LOG_N] sumcheckUnivariates; - Fr[NUMBER_OF_ENTITIES] sumcheckEvaluations; - // Shplemini - G1Point[CONST_PROOF_SIZE_LOG_N - 1] geminiFoldComms; - Fr[CONST_PROOF_SIZE_LOG_N] geminiAEvaluations; - G1Point shplonkQ; - G1Point kzgQuotient; - } - - struct ZKProof { - // Pairing point object - Fr[PAIRING_POINTS_SIZE] pairingPointObject; - // Commitments to wire polynomials - G1Point w1; - G1Point w2; - G1Point w3; - G1Point w4; - // Commitments to logup witness polynomials - G1Point lookupReadCounts; - G1Point lookupReadTags; - G1Point lookupInverses; - // Commitment to grand permutation polynomial - G1Point zPerm; - G1Point[3] libraCommitments; - // Sumcheck - Fr libraSum; - Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH][CONST_PROOF_SIZE_LOG_N] sumcheckUnivariates; - Fr[NUMBER_OF_ENTITIES] sumcheckEvaluations; - Fr libraEvaluation; - // ZK - G1Point geminiMaskingPoly; - Fr geminiMaskingEval; - // Shplemini - G1Point[CONST_PROOF_SIZE_LOG_N - 1] geminiFoldComms; - Fr[CONST_PROOF_SIZE_LOG_N] geminiAEvaluations; - Fr[4] libraPolyEvals; - G1Point shplonkQ; - G1Point kzgQuotient; - } + struct G1Point { + uint256 x; + uint256 y; + } + + struct VerificationKey { + // Misc Params + uint256 circuitSize; + uint256 logCircuitSize; + uint256 publicInputsSize; + // Selectors + G1Point qm; + G1Point qc; + G1Point ql; + G1Point qr; + G1Point qo; + G1Point q4; + G1Point qLookup; // Lookup + G1Point qArith; // Arithmetic widget + G1Point qDeltaRange; // Delta Range sort + G1Point qMemory; // Memory + G1Point qNnf; // Non-native Field + G1Point qElliptic; // Auxillary + G1Point qPoseidon2External; + G1Point qPoseidon2Internal; + // Copy cnstraints + G1Point s1; + G1Point s2; + G1Point s3; + G1Point s4; + // Copy identity + G1Point id1; + G1Point id2; + G1Point id3; + G1Point id4; + // Precomputed lookup table + G1Point t1; + G1Point t2; + G1Point t3; + G1Point t4; + // Fixed first and last + G1Point lagrangeFirst; + G1Point lagrangeLast; + } + + struct RelationParameters { + // challenges + Fr eta; + Fr etaTwo; + Fr etaThree; + Fr beta; + Fr gamma; + // derived + Fr publicInputsDelta; + } + + struct Proof { + // Pairing point object + Fr[PAIRING_POINTS_SIZE] pairingPointObject; + // Free wires + G1Point w1; + G1Point w2; + G1Point w3; + G1Point w4; + // Lookup helpers - Permutations + G1Point zPerm; + // Lookup helpers - logup + G1Point lookupReadCounts; + G1Point lookupReadTags; + G1Point lookupInverses; + // Sumcheck + Fr[BATCHED_RELATION_PARTIAL_LENGTH][CONST_PROOF_SIZE_LOG_N] sumcheckUnivariates; + Fr[NUMBER_OF_ENTITIES] sumcheckEvaluations; + // Shplemini + G1Point[CONST_PROOF_SIZE_LOG_N - 1] geminiFoldComms; + Fr[CONST_PROOF_SIZE_LOG_N] geminiAEvaluations; + G1Point shplonkQ; + G1Point kzgQuotient; + } + + struct ZKProof { + // Pairing point object + Fr[PAIRING_POINTS_SIZE] pairingPointObject; + // Commitments to wire polynomials + G1Point w1; + G1Point w2; + G1Point w3; + G1Point w4; + // Commitments to logup witness polynomials + G1Point lookupReadCounts; + G1Point lookupReadTags; + G1Point lookupInverses; + // Commitment to grand permutation polynomial + G1Point zPerm; + G1Point[3] libraCommitments; + // Sumcheck + Fr libraSum; + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH][CONST_PROOF_SIZE_LOG_N] sumcheckUnivariates; + Fr[NUMBER_OF_ENTITIES] sumcheckEvaluations; + Fr libraEvaluation; + // ZK + G1Point geminiMaskingPoly; + Fr geminiMaskingEval; + // Shplemini + G1Point[CONST_PROOF_SIZE_LOG_N - 1] geminiFoldComms; + Fr[CONST_PROOF_SIZE_LOG_N] geminiAEvaluations; + Fr[4] libraPolyEvals; + G1Point shplonkQ; + G1Point kzgQuotient; + } } // ZKTranscript library to generate fiat shamir challenges, the ZK transcript only differest struct ZKTranscript { - // Oink - Honk.RelationParameters relationParameters; - Fr[NUMBER_OF_ALPHAS] alphas; - Fr[CONST_PROOF_SIZE_LOG_N] gateChallenges; - // Sumcheck - Fr libraChallenge; - Fr[CONST_PROOF_SIZE_LOG_N] sumCheckUChallenges; - // Shplemini - Fr rho; - Fr geminiR; - Fr shplonkNu; - Fr shplonkZ; - // Derived - Fr publicInputsDelta; + // Oink + Honk.RelationParameters relationParameters; + Fr[NUMBER_OF_ALPHAS] alphas; + Fr[CONST_PROOF_SIZE_LOG_N] gateChallenges; + // Sumcheck + Fr libraChallenge; + Fr[CONST_PROOF_SIZE_LOG_N] sumCheckUChallenges; + // Shplemini + Fr rho; + Fr geminiR; + Fr shplonkNu; + Fr shplonkZ; + // Derived + Fr publicInputsDelta; } library ZKTranscriptLib { - function generateTranscript( - Honk.ZKProof memory proof, - bytes32[] calldata publicInputs, - uint256 vkHash, - uint256 publicInputsSize, - uint256 logN - ) external pure returns (ZKTranscript memory t) { - Fr previousChallenge; - (t.relationParameters, previousChallenge) = - generateRelationParametersChallenges(proof, publicInputs, vkHash, publicInputsSize, previousChallenge); - - (t.alphas, previousChallenge) = generateAlphaChallenges(previousChallenge, proof); - - (t.gateChallenges, previousChallenge) = generateGateChallenges(previousChallenge, logN); - (t.libraChallenge, previousChallenge) = generateLibraChallenge(previousChallenge, proof); - (t.sumCheckUChallenges, previousChallenge) = generateSumcheckChallenges(proof, previousChallenge, logN); - - (t.rho, previousChallenge) = generateRhoChallenge(proof, previousChallenge); - - (t.geminiR, previousChallenge) = generateGeminiRChallenge(proof, previousChallenge, logN); - - (t.shplonkNu, previousChallenge) = generateShplonkNuChallenge(proof, previousChallenge, logN); - - (t.shplonkZ, previousChallenge) = generateShplonkZChallenge(proof, previousChallenge); - return t; - } - - function splitChallenge(Fr challenge) internal pure returns (Fr first, Fr second) { - uint256 challengeU256 = uint256(Fr.unwrap(challenge)); - uint256 lo = challengeU256 & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; - uint256 hi = challengeU256 >> 128; - first = FrLib.fromBytes32(bytes32(lo)); - second = FrLib.fromBytes32(bytes32(hi)); - } - - function generateRelationParametersChallenges( - Honk.ZKProof memory proof, - bytes32[] calldata publicInputs, - uint256 vkHash, - uint256 publicInputsSize, - Fr previousChallenge - ) internal pure returns (Honk.RelationParameters memory rp, Fr nextPreviousChallenge) { - (rp.eta, rp.etaTwo, rp.etaThree, previousChallenge) = - generateEtaChallenge(proof, publicInputs, vkHash, publicInputsSize); - - (rp.beta, rp.gamma, nextPreviousChallenge) = generateBetaAndGammaChallenges(previousChallenge, proof); - } - - function generateEtaChallenge( - Honk.ZKProof memory proof, - bytes32[] calldata publicInputs, - uint256 vkHash, - uint256 publicInputsSize - ) internal pure returns (Fr eta, Fr etaTwo, Fr etaThree, Fr previousChallenge) { - bytes32[] memory round0 = new bytes32[](1 + publicInputsSize + 6); - round0[0] = bytes32(vkHash); - - for (uint256 i = 0; i < publicInputsSize - PAIRING_POINTS_SIZE; i++) { - round0[1 + i] = bytes32(publicInputs[i]); - } - for (uint256 i = 0; i < PAIRING_POINTS_SIZE; i++) { - round0[1 + publicInputsSize - PAIRING_POINTS_SIZE + i] = FrLib.toBytes32(proof.pairingPointObject[i]); - } - - // Create the first challenge - // Note: w4 is added to the challenge later on - round0[1 + publicInputsSize] = bytes32(proof.w1.x); - round0[1 + publicInputsSize + 1] = bytes32(proof.w1.y); - round0[1 + publicInputsSize + 2] = bytes32(proof.w2.x); - round0[1 + publicInputsSize + 3] = bytes32(proof.w2.y); - round0[1 + publicInputsSize + 4] = bytes32(proof.w3.x); - round0[1 + publicInputsSize + 5] = bytes32(proof.w3.y); - - previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(round0))); - (eta, etaTwo) = splitChallenge(previousChallenge); - previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(Fr.unwrap(previousChallenge)))); - - (etaThree,) = splitChallenge(previousChallenge); - } - - function generateBetaAndGammaChallenges(Fr previousChallenge, Honk.ZKProof memory proof) - internal - pure - returns (Fr beta, Fr gamma, Fr nextPreviousChallenge) + function generateTranscript( + Honk.ZKProof memory proof, + bytes32[] calldata publicInputs, + uint256 vkHash, + uint256 publicInputsSize, + uint256 logN + ) external pure returns (ZKTranscript memory t) { + Fr previousChallenge; + (t.relationParameters, previousChallenge) = generateRelationParametersChallenges( + proof, + publicInputs, + vkHash, + publicInputsSize, + previousChallenge + ); + + (t.alphas, previousChallenge) = generateAlphaChallenges(previousChallenge, proof); + + (t.gateChallenges, previousChallenge) = generateGateChallenges(previousChallenge, logN); + (t.libraChallenge, previousChallenge) = generateLibraChallenge(previousChallenge, proof); + (t.sumCheckUChallenges, previousChallenge) = generateSumcheckChallenges(proof, previousChallenge, logN); + + (t.rho, previousChallenge) = generateRhoChallenge(proof, previousChallenge); + + (t.geminiR, previousChallenge) = generateGeminiRChallenge(proof, previousChallenge, logN); + + (t.shplonkNu, previousChallenge) = generateShplonkNuChallenge(proof, previousChallenge, logN); + + (t.shplonkZ, previousChallenge) = generateShplonkZChallenge(proof, previousChallenge); + return t; + } + + function splitChallenge(Fr challenge) internal pure returns (Fr first, Fr second) { + uint256 challengeU256 = uint256(Fr.unwrap(challenge)); + uint256 lo = challengeU256 & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; + uint256 hi = challengeU256 >> 128; + first = FrLib.fromBytes32(bytes32(lo)); + second = FrLib.fromBytes32(bytes32(hi)); + } + + function generateRelationParametersChallenges( + Honk.ZKProof memory proof, + bytes32[] calldata publicInputs, + uint256 vkHash, + uint256 publicInputsSize, + Fr previousChallenge + ) internal pure returns (Honk.RelationParameters memory rp, Fr nextPreviousChallenge) { + (rp.eta, rp.etaTwo, rp.etaThree, previousChallenge) = generateEtaChallenge(proof, publicInputs, vkHash, publicInputsSize); + + (rp.beta, rp.gamma, nextPreviousChallenge) = generateBetaAndGammaChallenges(previousChallenge, proof); + } + + function generateEtaChallenge( + Honk.ZKProof memory proof, + bytes32[] calldata publicInputs, + uint256 vkHash, + uint256 publicInputsSize + ) internal pure returns (Fr eta, Fr etaTwo, Fr etaThree, Fr previousChallenge) { + bytes32[] memory round0 = new bytes32[](1 + publicInputsSize + 6); + round0[0] = bytes32(vkHash); + + for (uint256 i = 0; i < publicInputsSize - PAIRING_POINTS_SIZE; i++) { + round0[1 + i] = bytes32(publicInputs[i]); + } + for (uint256 i = 0; i < PAIRING_POINTS_SIZE; i++) { + round0[1 + publicInputsSize - PAIRING_POINTS_SIZE + i] = FrLib.toBytes32(proof.pairingPointObject[i]); + } + + // Create the first challenge + // Note: w4 is added to the challenge later on + round0[1 + publicInputsSize] = bytes32(proof.w1.x); + round0[1 + publicInputsSize + 1] = bytes32(proof.w1.y); + round0[1 + publicInputsSize + 2] = bytes32(proof.w2.x); + round0[1 + publicInputsSize + 3] = bytes32(proof.w2.y); + round0[1 + publicInputsSize + 4] = bytes32(proof.w3.x); + round0[1 + publicInputsSize + 5] = bytes32(proof.w3.y); + + previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(round0))); + (eta, etaTwo) = splitChallenge(previousChallenge); + previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(Fr.unwrap(previousChallenge)))); + + (etaThree, ) = splitChallenge(previousChallenge); + } + + function generateBetaAndGammaChallenges( + Fr previousChallenge, + Honk.ZKProof memory proof + ) internal pure returns (Fr beta, Fr gamma, Fr nextPreviousChallenge) { + bytes32[7] memory round1; + round1[0] = FrLib.toBytes32(previousChallenge); + round1[1] = bytes32(proof.lookupReadCounts.x); + round1[2] = bytes32(proof.lookupReadCounts.y); + round1[3] = bytes32(proof.lookupReadTags.x); + round1[4] = bytes32(proof.lookupReadTags.y); + round1[5] = bytes32(proof.w4.x); + round1[6] = bytes32(proof.w4.y); + + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(round1))); + (beta, gamma) = splitChallenge(nextPreviousChallenge); + } + + // Alpha challenges non-linearise the gate contributions + function generateAlphaChallenges( + Fr previousChallenge, + Honk.ZKProof memory proof + ) internal pure returns (Fr[NUMBER_OF_ALPHAS] memory alphas, Fr nextPreviousChallenge) { + // Generate the original sumcheck alpha 0 by hashing zPerm and zLookup + uint256[5] memory alpha0; + alpha0[0] = Fr.unwrap(previousChallenge); + alpha0[1] = proof.lookupInverses.x; + alpha0[2] = proof.lookupInverses.y; + alpha0[3] = proof.zPerm.x; + alpha0[4] = proof.zPerm.y; + + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(alpha0))); + Fr alpha; + (alpha, ) = splitChallenge(nextPreviousChallenge); + + // Compute powers of alpha for batching subrelations + alphas[0] = alpha; + for (uint256 i = 1; i < NUMBER_OF_ALPHAS; i++) { + alphas[i] = alphas[i - 1] * alpha; + } + } + + function generateGateChallenges( + Fr previousChallenge, + uint256 logN + ) internal pure returns (Fr[CONST_PROOF_SIZE_LOG_N] memory gateChallenges, Fr nextPreviousChallenge) { + previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(Fr.unwrap(previousChallenge)))); + (gateChallenges[0], ) = splitChallenge(previousChallenge); + for (uint256 i = 1; i < logN; i++) { + gateChallenges[i] = gateChallenges[i - 1] * gateChallenges[i - 1]; + } + nextPreviousChallenge = previousChallenge; + } + + function generateLibraChallenge( + Fr previousChallenge, + Honk.ZKProof memory proof + ) internal pure returns (Fr libraChallenge, Fr nextPreviousChallenge) { + // 2 comm, 1 sum, 1 challenge + uint256[4] memory challengeData; + challengeData[0] = Fr.unwrap(previousChallenge); + challengeData[1] = proof.libraCommitments[0].x; + challengeData[2] = proof.libraCommitments[0].y; + challengeData[3] = Fr.unwrap(proof.libraSum); + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(challengeData))); + (libraChallenge, ) = splitChallenge(nextPreviousChallenge); + } + + function generateSumcheckChallenges( + Honk.ZKProof memory proof, + Fr prevChallenge, + uint256 logN + ) internal pure returns (Fr[CONST_PROOF_SIZE_LOG_N] memory sumcheckChallenges, Fr nextPreviousChallenge) { + for (uint256 i = 0; i < logN; i++) { + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH + 1] memory univariateChal; + univariateChal[0] = prevChallenge; + + for (uint256 j = 0; j < ZK_BATCHED_RELATION_PARTIAL_LENGTH; j++) { + univariateChal[j + 1] = proof.sumcheckUnivariates[i][j]; + } + prevChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(univariateChal))); + + (sumcheckChallenges[i], ) = splitChallenge(prevChallenge); + } + nextPreviousChallenge = prevChallenge; + } + + // We add Libra claimed eval + 3 comm + 1 more eval + function generateRhoChallenge(Honk.ZKProof memory proof, Fr prevChallenge) internal pure returns (Fr rho, Fr nextPreviousChallenge) { + uint256[NUMBER_OF_ENTITIES + 9] memory rhoChallengeElements; + rhoChallengeElements[0] = Fr.unwrap(prevChallenge); + uint256 i; + for (i = 1; i <= NUMBER_OF_ENTITIES; i++) { + rhoChallengeElements[i] = Fr.unwrap(proof.sumcheckEvaluations[i - 1]); + } + rhoChallengeElements[i] = Fr.unwrap(proof.libraEvaluation); + + i += 1; + rhoChallengeElements[i] = proof.libraCommitments[1].x; + rhoChallengeElements[i + 1] = proof.libraCommitments[1].y; + i += 2; + rhoChallengeElements[i] = proof.libraCommitments[2].x; + rhoChallengeElements[i + 1] = proof.libraCommitments[2].y; + i += 2; + rhoChallengeElements[i] = proof.geminiMaskingPoly.x; + rhoChallengeElements[i + 1] = proof.geminiMaskingPoly.y; + + i += 2; + rhoChallengeElements[i] = Fr.unwrap(proof.geminiMaskingEval); + + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(rhoChallengeElements))); + (rho, ) = splitChallenge(nextPreviousChallenge); + } + + function generateGeminiRChallenge( + Honk.ZKProof memory proof, + Fr prevChallenge, + uint256 logN + ) internal pure returns (Fr geminiR, Fr nextPreviousChallenge) { + uint256[] memory gR = new uint256[]((logN - 1) * 2 + 1); + gR[0] = Fr.unwrap(prevChallenge); + + for (uint256 i = 0; i < logN - 1; i++) { + gR[1 + i * 2] = proof.geminiFoldComms[i].x; + gR[2 + i * 2] = proof.geminiFoldComms[i].y; + } + + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(gR))); + + (geminiR, ) = splitChallenge(nextPreviousChallenge); + } + + function generateShplonkNuChallenge( + Honk.ZKProof memory proof, + Fr prevChallenge, + uint256 logN + ) internal pure returns (Fr shplonkNu, Fr nextPreviousChallenge) { + uint256[] memory shplonkNuChallengeElements = new uint256[](logN + 1 + 4); + shplonkNuChallengeElements[0] = Fr.unwrap(prevChallenge); + + for (uint256 i = 1; i <= logN; i++) { + shplonkNuChallengeElements[i] = Fr.unwrap(proof.geminiAEvaluations[i - 1]); + } + + uint256 libraIdx = 0; + for (uint256 i = logN + 1; i <= logN + 4; i++) { + shplonkNuChallengeElements[i] = Fr.unwrap(proof.libraPolyEvals[libraIdx]); + libraIdx++; + } + + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(shplonkNuChallengeElements))); + (shplonkNu, ) = splitChallenge(nextPreviousChallenge); + } + + function generateShplonkZChallenge( + Honk.ZKProof memory proof, + Fr prevChallenge + ) internal pure returns (Fr shplonkZ, Fr nextPreviousChallenge) { + uint256[3] memory shplonkZChallengeElements; + shplonkZChallengeElements[0] = Fr.unwrap(prevChallenge); + + shplonkZChallengeElements[1] = proof.shplonkQ.x; + shplonkZChallengeElements[2] = proof.shplonkQ.y; + + nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(shplonkZChallengeElements))); + (shplonkZ, ) = splitChallenge(nextPreviousChallenge); + } + + function loadProof(bytes calldata proof, uint256 logN) internal pure returns (Honk.ZKProof memory p) { + uint256 boundary = 0x0; + + // Pairing point object + for (uint256 i = 0; i < PAIRING_POINTS_SIZE; i++) { + p.pairingPointObject[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + boundary += FIELD_ELEMENT_SIZE; + } + // Commitments + p.w1 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.w2 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.w3 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + + // Lookup / Permutation Helper Commitments + p.lookupReadCounts = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.lookupReadTags = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.w4 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.lookupInverses = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.zPerm = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.libraCommitments[0] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + + p.libraSum = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + boundary += FIELD_ELEMENT_SIZE; + // Sumcheck univariates + for (uint256 i = 0; i < logN; i++) { + for (uint256 j = 0; j < ZK_BATCHED_RELATION_PARTIAL_LENGTH; j++) { + p.sumcheckUnivariates[i][j] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + boundary += FIELD_ELEMENT_SIZE; + } + } + + // Sumcheck evaluations + for (uint256 i = 0; i < NUMBER_OF_ENTITIES; i++) { + p.sumcheckEvaluations[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + boundary += FIELD_ELEMENT_SIZE; + } + + p.libraEvaluation = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + boundary += FIELD_ELEMENT_SIZE; + + p.libraCommitments[1] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.libraCommitments[2] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.geminiMaskingPoly = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + p.geminiMaskingEval = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + boundary += FIELD_ELEMENT_SIZE; + + // Gemini + // Read gemini fold univariates + for (uint256 i = 0; i < logN - 1; i++) { + p.geminiFoldComms[i] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + } + + // Read gemini a evaluations + for (uint256 i = 0; i < logN; i++) { + p.geminiAEvaluations[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + boundary += FIELD_ELEMENT_SIZE; + } + + for (uint256 i = 0; i < 4; i++) { + p.libraPolyEvals[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); + boundary += FIELD_ELEMENT_SIZE; + } + + // Shplonk + p.shplonkQ = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + boundary += GROUP_ELEMENT_SIZE; + // KZG + p.kzgQuotient = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + } +} + +// Field arithmetic libraries + +library RelationsLib { + Fr internal constant GRUMPKIN_CURVE_B_PARAMETER_NEGATED = Fr.wrap(17); // -(-17) + + function accumulateRelationEvaluations( + Fr[NUMBER_OF_ENTITIES] memory purportedEvaluations, + Honk.RelationParameters memory rp, + Fr[NUMBER_OF_ALPHAS] memory alphas, + Fr powPartialEval + ) internal pure returns (Fr accumulator) { + Fr[NUMBER_OF_SUBRELATIONS] memory evaluations; + + // Accumulate all relations in Ultra Honk - each with varying number of subrelations + accumulateArithmeticRelation(purportedEvaluations, evaluations, powPartialEval); + accumulatePermutationRelation(purportedEvaluations, rp, evaluations, powPartialEval); + accumulateLogDerivativeLookupRelation(purportedEvaluations, rp, evaluations, powPartialEval); + accumulateDeltaRangeRelation(purportedEvaluations, evaluations, powPartialEval); + accumulateEllipticRelation(purportedEvaluations, evaluations, powPartialEval); + accumulateMemoryRelation(purportedEvaluations, rp, evaluations, powPartialEval); + accumulateNnfRelation(purportedEvaluations, evaluations, powPartialEval); + accumulatePoseidonExternalRelation(purportedEvaluations, evaluations, powPartialEval); + accumulatePoseidonInternalRelation(purportedEvaluations, evaluations, powPartialEval); + + // batch the subrelations with the alpha challenges to obtain the full honk relation + accumulator = scaleAndBatchSubrelations(evaluations, alphas); + } + + /** + * Aesthetic helper function that is used to index by enum into proof.sumcheckEvaluations, it avoids + * the relation checking code being cluttered with uint256 type casting, which is often a different colour in code + * editors, and thus is noisy. + */ + function wire(Fr[NUMBER_OF_ENTITIES] memory p, WIRE _wire) internal pure returns (Fr) { + return p[uint256(_wire)]; + } + + uint256 internal constant NEG_HALF_MODULO_P = 0x183227397098d014dc2822db40c0ac2e9419f4243cdcb848a1f0fac9f8000000; + /** + * Ultra Arithmetic Relation + * + */ + + function accumulateArithmeticRelation( + Fr[NUMBER_OF_ENTITIES] memory p, + Fr[NUMBER_OF_SUBRELATIONS] memory evals, + Fr domainSep + ) internal pure { + // Relation 0 + Fr q_arith = wire(p, WIRE.Q_ARITH); { - bytes32[7] memory round1; - round1[0] = FrLib.toBytes32(previousChallenge); - round1[1] = bytes32(proof.lookupReadCounts.x); - round1[2] = bytes32(proof.lookupReadCounts.y); - round1[3] = bytes32(proof.lookupReadTags.x); - round1[4] = bytes32(proof.lookupReadTags.y); - round1[5] = bytes32(proof.w4.x); - round1[6] = bytes32(proof.w4.y); - - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(round1))); - (beta, gamma) = splitChallenge(nextPreviousChallenge); - } - - // Alpha challenges non-linearise the gate contributions - function generateAlphaChallenges(Fr previousChallenge, Honk.ZKProof memory proof) - internal - pure - returns (Fr[NUMBER_OF_ALPHAS] memory alphas, Fr nextPreviousChallenge) + Fr neg_half = Fr.wrap(NEG_HALF_MODULO_P); + + Fr accum = (q_arith - Fr.wrap(3)) * (wire(p, WIRE.Q_M) * wire(p, WIRE.W_R) * wire(p, WIRE.W_L)) * neg_half; + accum = + accum + + (wire(p, WIRE.Q_L) * wire(p, WIRE.W_L)) + + (wire(p, WIRE.Q_R) * wire(p, WIRE.W_R)) + + (wire(p, WIRE.Q_O) * wire(p, WIRE.W_O)) + + (wire(p, WIRE.Q_4) * wire(p, WIRE.W_4)) + + wire(p, WIRE.Q_C); + accum = accum + (q_arith - ONE) * wire(p, WIRE.W_4_SHIFT); + accum = accum * q_arith; + accum = accum * domainSep; + evals[0] = accum; + } + + // Relation 1 { - // Generate the original sumcheck alpha 0 by hashing zPerm and zLookup - uint256[5] memory alpha0; - alpha0[0] = Fr.unwrap(previousChallenge); - alpha0[1] = proof.lookupInverses.x; - alpha0[2] = proof.lookupInverses.y; - alpha0[3] = proof.zPerm.x; - alpha0[4] = proof.zPerm.y; - - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(alpha0))); - Fr alpha; - (alpha,) = splitChallenge(nextPreviousChallenge); - - // Compute powers of alpha for batching subrelations - alphas[0] = alpha; - for (uint256 i = 1; i < NUMBER_OF_ALPHAS; i++) { - alphas[i] = alphas[i - 1] * alpha; - } - } - - function generateGateChallenges(Fr previousChallenge, uint256 logN) - internal - pure - returns (Fr[CONST_PROOF_SIZE_LOG_N] memory gateChallenges, Fr nextPreviousChallenge) + Fr accum = wire(p, WIRE.W_L) + wire(p, WIRE.W_4) - wire(p, WIRE.W_L_SHIFT) + wire(p, WIRE.Q_M); + accum = accum * (q_arith - Fr.wrap(2)); + accum = accum * (q_arith - ONE); + accum = accum * q_arith; + accum = accum * domainSep; + evals[1] = accum; + } + } + + function accumulatePermutationRelation( + Fr[NUMBER_OF_ENTITIES] memory p, + Honk.RelationParameters memory rp, + Fr[NUMBER_OF_SUBRELATIONS] memory evals, + Fr domainSep + ) internal pure { + Fr grand_product_numerator; + Fr grand_product_denominator; + { - previousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(Fr.unwrap(previousChallenge)))); - (gateChallenges[0],) = splitChallenge(previousChallenge); - for (uint256 i = 1; i < logN; i++) { - gateChallenges[i] = gateChallenges[i - 1] * gateChallenges[i - 1]; - } - nextPreviousChallenge = previousChallenge; - } - - function generateLibraChallenge(Fr previousChallenge, Honk.ZKProof memory proof) - internal - pure - returns (Fr libraChallenge, Fr nextPreviousChallenge) + Fr num = wire(p, WIRE.W_L) + wire(p, WIRE.ID_1) * rp.beta + rp.gamma; + num = num * (wire(p, WIRE.W_R) + wire(p, WIRE.ID_2) * rp.beta + rp.gamma); + num = num * (wire(p, WIRE.W_O) + wire(p, WIRE.ID_3) * rp.beta + rp.gamma); + num = num * (wire(p, WIRE.W_4) + wire(p, WIRE.ID_4) * rp.beta + rp.gamma); + + grand_product_numerator = num; + } { - // 2 comm, 1 sum, 1 challenge - uint256[4] memory challengeData; - challengeData[0] = Fr.unwrap(previousChallenge); - challengeData[1] = proof.libraCommitments[0].x; - challengeData[2] = proof.libraCommitments[0].y; - challengeData[3] = Fr.unwrap(proof.libraSum); - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(challengeData))); - (libraChallenge,) = splitChallenge(nextPreviousChallenge); - } - - function generateSumcheckChallenges(Honk.ZKProof memory proof, Fr prevChallenge, uint256 logN) - internal - pure - returns (Fr[CONST_PROOF_SIZE_LOG_N] memory sumcheckChallenges, Fr nextPreviousChallenge) + Fr den = wire(p, WIRE.W_L) + wire(p, WIRE.SIGMA_1) * rp.beta + rp.gamma; + den = den * (wire(p, WIRE.W_R) + wire(p, WIRE.SIGMA_2) * rp.beta + rp.gamma); + den = den * (wire(p, WIRE.W_O) + wire(p, WIRE.SIGMA_3) * rp.beta + rp.gamma); + den = den * (wire(p, WIRE.W_4) + wire(p, WIRE.SIGMA_4) * rp.beta + rp.gamma); + + grand_product_denominator = den; + } + + // Contribution 2 { - for (uint256 i = 0; i < logN; i++) { - Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH + 1] memory univariateChal; - univariateChal[0] = prevChallenge; + Fr acc = (wire(p, WIRE.Z_PERM) + wire(p, WIRE.LAGRANGE_FIRST)) * grand_product_numerator; - for (uint256 j = 0; j < ZK_BATCHED_RELATION_PARTIAL_LENGTH; j++) { - univariateChal[j + 1] = proof.sumcheckUnivariates[i][j]; - } - prevChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(univariateChal))); + acc = acc - ((wire(p, WIRE.Z_PERM_SHIFT) + (wire(p, WIRE.LAGRANGE_LAST) * rp.publicInputsDelta)) * grand_product_denominator); + acc = acc * domainSep; + evals[2] = acc; + } - (sumcheckChallenges[i],) = splitChallenge(prevChallenge); - } - nextPreviousChallenge = prevChallenge; + // Contribution 3 + { + Fr acc = (wire(p, WIRE.LAGRANGE_LAST) * wire(p, WIRE.Z_PERM_SHIFT)) * domainSep; + evals[3] = acc; } + } + + function accumulateLogDerivativeLookupRelation( + Fr[NUMBER_OF_ENTITIES] memory p, + Honk.RelationParameters memory rp, + Fr[NUMBER_OF_SUBRELATIONS] memory evals, + Fr domainSep + ) internal pure { + Fr write_term; + Fr read_term; - // We add Libra claimed eval + 3 comm + 1 more eval - function generateRhoChallenge(Honk.ZKProof memory proof, Fr prevChallenge) - internal - pure - returns (Fr rho, Fr nextPreviousChallenge) + // Calculate the write term (the table accumulation) { - uint256[NUMBER_OF_ENTITIES + 9] memory rhoChallengeElements; - rhoChallengeElements[0] = Fr.unwrap(prevChallenge); - uint256 i; - for (i = 1; i <= NUMBER_OF_ENTITIES; i++) { - rhoChallengeElements[i] = Fr.unwrap(proof.sumcheckEvaluations[i - 1]); - } - rhoChallengeElements[i] = Fr.unwrap(proof.libraEvaluation); - - i += 1; - rhoChallengeElements[i] = proof.libraCommitments[1].x; - rhoChallengeElements[i + 1] = proof.libraCommitments[1].y; - i += 2; - rhoChallengeElements[i] = proof.libraCommitments[2].x; - rhoChallengeElements[i + 1] = proof.libraCommitments[2].y; - i += 2; - rhoChallengeElements[i] = proof.geminiMaskingPoly.x; - rhoChallengeElements[i + 1] = proof.geminiMaskingPoly.y; - - i += 2; - rhoChallengeElements[i] = Fr.unwrap(proof.geminiMaskingEval); - - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(rhoChallengeElements))); - (rho,) = splitChallenge(nextPreviousChallenge); - } - - function generateGeminiRChallenge(Honk.ZKProof memory proof, Fr prevChallenge, uint256 logN) - internal - pure - returns (Fr geminiR, Fr nextPreviousChallenge) + write_term = + wire(p, WIRE.TABLE_1) + + rp.gamma + + (wire(p, WIRE.TABLE_2) * rp.eta) + + (wire(p, WIRE.TABLE_3) * rp.etaTwo) + + (wire(p, WIRE.TABLE_4) * rp.etaThree); + } + + // Calculate the write term { - uint256[] memory gR = new uint256[]((logN - 1) * 2 + 1); - gR[0] = Fr.unwrap(prevChallenge); + Fr derived_entry_1 = wire(p, WIRE.W_L) + rp.gamma + (wire(p, WIRE.Q_R) * wire(p, WIRE.W_L_SHIFT)); + Fr derived_entry_2 = wire(p, WIRE.W_R) + wire(p, WIRE.Q_M) * wire(p, WIRE.W_R_SHIFT); + Fr derived_entry_3 = wire(p, WIRE.W_O) + wire(p, WIRE.Q_C) * wire(p, WIRE.W_O_SHIFT); + + read_term = derived_entry_1 + (derived_entry_2 * rp.eta) + (derived_entry_3 * rp.etaTwo) + (wire(p, WIRE.Q_O) * rp.etaThree); + } + + Fr read_inverse = wire(p, WIRE.LOOKUP_INVERSES) * write_term; + Fr write_inverse = wire(p, WIRE.LOOKUP_INVERSES) * read_term; + + Fr inverse_exists_xor = wire(p, WIRE.LOOKUP_READ_TAGS) + + wire(p, WIRE.Q_LOOKUP) - + (wire(p, WIRE.LOOKUP_READ_TAGS) * wire(p, WIRE.Q_LOOKUP)); + + // Inverse calculated correctly relation + Fr accumulatorNone = read_term * write_term * wire(p, WIRE.LOOKUP_INVERSES) - inverse_exists_xor; + accumulatorNone = accumulatorNone * domainSep; + + // Inverse + Fr accumulatorOne = wire(p, WIRE.Q_LOOKUP) * read_inverse - wire(p, WIRE.LOOKUP_READ_COUNTS) * write_inverse; + + Fr read_tag = wire(p, WIRE.LOOKUP_READ_TAGS); + + Fr read_tag_boolean_relation = read_tag * read_tag - read_tag; - for (uint256 i = 0; i < logN - 1; i++) { - gR[1 + i * 2] = proof.geminiFoldComms[i].x; - gR[2 + i * 2] = proof.geminiFoldComms[i].y; - } + evals[4] = accumulatorNone; + evals[5] = accumulatorOne; + evals[6] = read_tag_boolean_relation * domainSep; + } - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(gR))); + function accumulateDeltaRangeRelation( + Fr[NUMBER_OF_ENTITIES] memory p, + Fr[NUMBER_OF_SUBRELATIONS] memory evals, + Fr domainSep + ) internal pure { + Fr minus_one = ZERO - ONE; + Fr minus_two = ZERO - Fr.wrap(2); + Fr minus_three = ZERO - Fr.wrap(3); - (geminiR,) = splitChallenge(nextPreviousChallenge); + // Compute wire differences + Fr delta_1 = wire(p, WIRE.W_R) - wire(p, WIRE.W_L); + Fr delta_2 = wire(p, WIRE.W_O) - wire(p, WIRE.W_R); + Fr delta_3 = wire(p, WIRE.W_4) - wire(p, WIRE.W_O); + Fr delta_4 = wire(p, WIRE.W_L_SHIFT) - wire(p, WIRE.W_4); + + // Contribution 6 + { + Fr acc = delta_1; + acc = acc * (delta_1 + minus_one); + acc = acc * (delta_1 + minus_two); + acc = acc * (delta_1 + minus_three); + acc = acc * wire(p, WIRE.Q_RANGE); + acc = acc * domainSep; + evals[7] = acc; } - function generateShplonkNuChallenge(Honk.ZKProof memory proof, Fr prevChallenge, uint256 logN) - internal - pure - returns (Fr shplonkNu, Fr nextPreviousChallenge) + // Contribution 7 { - uint256[] memory shplonkNuChallengeElements = new uint256[](logN + 1 + 4); - shplonkNuChallengeElements[0] = Fr.unwrap(prevChallenge); + Fr acc = delta_2; + acc = acc * (delta_2 + minus_one); + acc = acc * (delta_2 + minus_two); + acc = acc * (delta_2 + minus_three); + acc = acc * wire(p, WIRE.Q_RANGE); + acc = acc * domainSep; + evals[8] = acc; + } - for (uint256 i = 1; i <= logN; i++) { - shplonkNuChallengeElements[i] = Fr.unwrap(proof.geminiAEvaluations[i - 1]); - } + // Contribution 8 + { + Fr acc = delta_3; + acc = acc * (delta_3 + minus_one); + acc = acc * (delta_3 + minus_two); + acc = acc * (delta_3 + minus_three); + acc = acc * wire(p, WIRE.Q_RANGE); + acc = acc * domainSep; + evals[9] = acc; + } - uint256 libraIdx = 0; - for (uint256 i = logN + 1; i <= logN + 4; i++) { - shplonkNuChallengeElements[i] = Fr.unwrap(proof.libraPolyEvals[libraIdx]); - libraIdx++; - } + // Contribution 9 + { + Fr acc = delta_4; + acc = acc * (delta_4 + minus_one); + acc = acc * (delta_4 + minus_two); + acc = acc * (delta_4 + minus_three); + acc = acc * wire(p, WIRE.Q_RANGE); + acc = acc * domainSep; + evals[10] = acc; + } + } + + struct EllipticParams { + // Points + Fr x_1; + Fr y_1; + Fr x_2; + Fr y_2; + Fr y_3; + Fr x_3; + // push accumulators into memory + Fr x_double_identity; + } + + function accumulateEllipticRelation( + Fr[NUMBER_OF_ENTITIES] memory p, + Fr[NUMBER_OF_SUBRELATIONS] memory evals, + Fr domainSep + ) internal pure { + EllipticParams memory ep; + ep.x_1 = wire(p, WIRE.W_R); + ep.y_1 = wire(p, WIRE.W_O); + + ep.x_2 = wire(p, WIRE.W_L_SHIFT); + ep.y_2 = wire(p, WIRE.W_4_SHIFT); + ep.y_3 = wire(p, WIRE.W_O_SHIFT); + ep.x_3 = wire(p, WIRE.W_R_SHIFT); + + Fr q_sign = wire(p, WIRE.Q_L); + Fr q_is_double = wire(p, WIRE.Q_M); + + // Contribution 10 point addition, x-coordinate check + // q_elliptic * (x3 + x2 + x1)(x2 - x1)(x2 - x1) - y2^2 - y1^2 + 2(y2y1)*q_sign = 0 + Fr x_diff = (ep.x_2 - ep.x_1); + Fr y1_sqr = (ep.y_1 * ep.y_1); + { + // Move to top + Fr partialEval = domainSep; + + Fr y2_sqr = (ep.y_2 * ep.y_2); + Fr y1y2 = ep.y_1 * ep.y_2 * q_sign; + Fr x_add_identity = (ep.x_3 + ep.x_2 + ep.x_1); + x_add_identity = x_add_identity * x_diff * x_diff; + x_add_identity = x_add_identity - y2_sqr - y1_sqr + y1y2 + y1y2; - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(shplonkNuChallengeElements))); - (shplonkNu,) = splitChallenge(nextPreviousChallenge); + evals[11] = x_add_identity * partialEval * wire(p, WIRE.Q_ELLIPTIC) * (ONE - q_is_double); } - function generateShplonkZChallenge(Honk.ZKProof memory proof, Fr prevChallenge) - internal - pure - returns (Fr shplonkZ, Fr nextPreviousChallenge) + // Contribution 11 point addition, x-coordinate check + // q_elliptic * (q_sign * y1 + y3)(x2 - x1) + (x3 - x1)(y2 - q_sign * y1) = 0 { - uint256[3] memory shplonkZChallengeElements; - shplonkZChallengeElements[0] = Fr.unwrap(prevChallenge); - - shplonkZChallengeElements[1] = proof.shplonkQ.x; - shplonkZChallengeElements[2] = proof.shplonkQ.y; - - nextPreviousChallenge = FrLib.fromBytes32(keccak256(abi.encodePacked(shplonkZChallengeElements))); - (shplonkZ,) = splitChallenge(nextPreviousChallenge); - } - - function loadProof(bytes calldata proof, uint256 logN) internal pure returns (Honk.ZKProof memory p) { - uint256 boundary = 0x0; - - // Pairing point object - for (uint256 i = 0; i < PAIRING_POINTS_SIZE; i++) { - p.pairingPointObject[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); - boundary += FIELD_ELEMENT_SIZE; - } - // Commitments - p.w1 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.w2 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.w3 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - - // Lookup / Permutation Helper Commitments - p.lookupReadCounts = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.lookupReadTags = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.w4 = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.lookupInverses = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.zPerm = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.libraCommitments[0] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - - p.libraSum = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); - boundary += FIELD_ELEMENT_SIZE; - // Sumcheck univariates - for (uint256 i = 0; i < logN; i++) { - for (uint256 j = 0; j < ZK_BATCHED_RELATION_PARTIAL_LENGTH; j++) { - p.sumcheckUnivariates[i][j] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); - boundary += FIELD_ELEMENT_SIZE; - } - } - - // Sumcheck evaluations - for (uint256 i = 0; i < NUMBER_OF_ENTITIES; i++) { - p.sumcheckEvaluations[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); - boundary += FIELD_ELEMENT_SIZE; - } - - p.libraEvaluation = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); - boundary += FIELD_ELEMENT_SIZE; + Fr y1_plus_y3 = ep.y_1 + ep.y_3; + Fr y_diff = ep.y_2 * q_sign - ep.y_1; + Fr y_add_identity = y1_plus_y3 * x_diff + (ep.x_3 - ep.x_1) * y_diff; + evals[12] = y_add_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * (ONE - q_is_double); + } - p.libraCommitments[1] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.libraCommitments[2] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.geminiMaskingPoly = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - p.geminiMaskingEval = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); - boundary += FIELD_ELEMENT_SIZE; + // Contribution 10 point doubling, x-coordinate check + // (x3 + x1 + x1) (4y1*y1) - 9 * x1 * x1 * x1 * x1 = 0 + // N.B. we're using the equivalence x1*x1*x1 === y1*y1 - curve_b to reduce degree by 1 + { + Fr x_pow_4 = (y1_sqr + GRUMPKIN_CURVE_B_PARAMETER_NEGATED) * ep.x_1; + Fr y1_sqr_mul_4 = y1_sqr + y1_sqr; + y1_sqr_mul_4 = y1_sqr_mul_4 + y1_sqr_mul_4; + Fr x1_pow_4_mul_9 = x_pow_4 * Fr.wrap(9); + + // NOTE: pushed into memory (stack >:'( ) + ep.x_double_identity = (ep.x_3 + ep.x_1 + ep.x_1) * y1_sqr_mul_4 - x1_pow_4_mul_9; - // Gemini - // Read gemini fold univariates - for (uint256 i = 0; i < logN - 1; i++) { - p.geminiFoldComms[i] = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - } - - // Read gemini a evaluations - for (uint256 i = 0; i < logN; i++) { - p.geminiAEvaluations[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); - boundary += FIELD_ELEMENT_SIZE; - } - - for (uint256 i = 0; i < 4; i++) { - p.libraPolyEvals[i] = bytesToFr(proof[boundary:boundary + FIELD_ELEMENT_SIZE]); - boundary += FIELD_ELEMENT_SIZE; - } - - // Shplonk - p.shplonkQ = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); - boundary += GROUP_ELEMENT_SIZE; - // KZG - p.kzgQuotient = bytesToG1Point(proof[boundary:boundary + GROUP_ELEMENT_SIZE]); + Fr acc = ep.x_double_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * q_is_double; + evals[11] = evals[11] + acc; } -} -// Field arithmetic libraries + // Contribution 11 point doubling, y-coordinate check + // (y1 + y1) (2y1) - (3 * x1 * x1)(x1 - x3) = 0 + { + Fr x1_sqr_mul_3 = (ep.x_1 + ep.x_1 + ep.x_1) * ep.x_1; + Fr y_double_identity = x1_sqr_mul_3 * (ep.x_1 - ep.x_3) - (ep.y_1 + ep.y_1) * (ep.y_1 + ep.y_3); + evals[12] = evals[12] + y_double_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * q_is_double; + } + } + + // Parameters used within the Memory Relation + // A struct is used to work around stack too deep. This relation has alot of variables + struct MemParams { + Fr memory_record_check; + Fr partial_record_check; + Fr next_gate_access_type; + Fr record_delta; + Fr index_delta; + Fr adjacent_values_match_if_adjacent_indices_match; + Fr adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation; + Fr access_check; + Fr next_gate_access_type_is_boolean; + Fr ROM_consistency_check_identity; + Fr RAM_consistency_check_identity; + Fr timestamp_delta; + Fr RAM_timestamp_check_identity; + Fr memory_identity; + Fr index_is_monotonically_increasing; + } + + function accumulateMemoryRelation( + Fr[NUMBER_OF_ENTITIES] memory p, + Honk.RelationParameters memory rp, + Fr[NUMBER_OF_SUBRELATIONS] memory evals, + Fr domainSep + ) internal pure { + MemParams memory ap; -library RelationsLib { - Fr internal constant GRUMPKIN_CURVE_B_PARAMETER_NEGATED = Fr.wrap(17); // -(-17) - - function accumulateRelationEvaluations( - Fr[NUMBER_OF_ENTITIES] memory purportedEvaluations, - Honk.RelationParameters memory rp, - Fr[NUMBER_OF_ALPHAS] memory alphas, - Fr powPartialEval - ) internal pure returns (Fr accumulator) { - Fr[NUMBER_OF_SUBRELATIONS] memory evaluations; - - // Accumulate all relations in Ultra Honk - each with varying number of subrelations - accumulateArithmeticRelation(purportedEvaluations, evaluations, powPartialEval); - accumulatePermutationRelation(purportedEvaluations, rp, evaluations, powPartialEval); - accumulateLogDerivativeLookupRelation(purportedEvaluations, rp, evaluations, powPartialEval); - accumulateDeltaRangeRelation(purportedEvaluations, evaluations, powPartialEval); - accumulateEllipticRelation(purportedEvaluations, evaluations, powPartialEval); - accumulateMemoryRelation(purportedEvaluations, rp, evaluations, powPartialEval); - accumulateNnfRelation(purportedEvaluations, evaluations, powPartialEval); - accumulatePoseidonExternalRelation(purportedEvaluations, evaluations, powPartialEval); - accumulatePoseidonInternalRelation(purportedEvaluations, evaluations, powPartialEval); - - // batch the subrelations with the alpha challenges to obtain the full honk relation - accumulator = scaleAndBatchSubrelations(evaluations, alphas); - } + /** + * MEMORY + * + * A RAM memory record contains a tuple of the following fields: + * * i: `index` of memory cell being accessed + * * t: `timestamp` of memory cell being accessed (used for RAM, set to 0 for ROM) + * * v: `value` of memory cell being accessed + * * a: `access` type of record. read: 0 = read, 1 = write + * * r: `record` of memory cell. record = access + index * eta + timestamp * eta_two + value * eta_three + * + * A ROM memory record contains a tuple of the following fields: + * * i: `index` of memory cell being accessed + * * v: `value1` of memory cell being accessed (ROM tables can store up to 2 values per index) + * * v2:`value2` of memory cell being accessed (ROM tables can store up to 2 values per index) + * * r: `record` of memory cell. record = index * eta + value2 * eta_two + value1 * eta_three + * + * When performing a read/write access, the values of i, t, v, v2, a, r are stored in the following wires + + * selectors, depending on whether the gate is a RAM read/write or a ROM read + * + * | gate type | i | v2/t | v | a | r | + * | --------- | -- | ----- | -- | -- | -- | + * | ROM | w1 | w2 | w3 | -- | w4 | + * | RAM | w1 | w2 | w3 | qc | w4 | + * + * (for accesses where `index` is a circuit constant, it is assumed the circuit will apply a copy constraint on + * `w2` to fix its value) + * + * + */ /** - * Aesthetic helper function that is used to index by enum into proof.sumcheckEvaluations, it avoids - * the relation checking code being cluttered with uint256 type casting, which is often a different colour in code - * editors, and thus is noisy. + * Memory Record Check + * Partial degree: 1 + * Total degree: 4 + * + * A ROM/ROM access gate can be evaluated with the identity: + * + * qc + w1 \eta + w2 \eta_two + w3 \eta_three - w4 = 0 + * + * For ROM gates, qc = 0 */ - function wire(Fr[NUMBER_OF_ENTITIES] memory p, WIRE _wire) internal pure returns (Fr) { - return p[uint256(_wire)]; - } + ap.memory_record_check = wire(p, WIRE.W_O) * rp.etaThree; + ap.memory_record_check = ap.memory_record_check + (wire(p, WIRE.W_R) * rp.etaTwo); + ap.memory_record_check = ap.memory_record_check + (wire(p, WIRE.W_L) * rp.eta); + ap.memory_record_check = ap.memory_record_check + wire(p, WIRE.Q_C); + ap.partial_record_check = ap.memory_record_check; // used in RAM consistency check; deg 1 or 4 + ap.memory_record_check = ap.memory_record_check - wire(p, WIRE.W_4); - uint256 internal constant NEG_HALF_MODULO_P = 0x183227397098d014dc2822db40c0ac2e9419f4243cdcb848a1f0fac9f8000000; /** - * Ultra Arithmetic Relation + * Contribution 13 & 14 + * ROM Consistency Check + * Partial degree: 1 + * Total degree: 4 + * + * For every ROM read, a set equivalence check is applied between the record witnesses, and a second set of + * records that are sorted. + * + * We apply the following checks for the sorted records: + * + * 1. w1, w2, w3 correctly map to 'index', 'v1, 'v2' for a given record value at w4 + * 2. index values for adjacent records are monotonically increasing + * 3. if, at gate i, index_i == index_{i + 1}, then value1_i == value1_{i + 1} and value2_i == value2_{i + 1} * */ + ap.index_delta = wire(p, WIRE.W_L_SHIFT) - wire(p, WIRE.W_L); + ap.record_delta = wire(p, WIRE.W_4_SHIFT) - wire(p, WIRE.W_4); - function accumulateArithmeticRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - // Relation 0 - Fr q_arith = wire(p, WIRE.Q_ARITH); - { - Fr neg_half = Fr.wrap(NEG_HALF_MODULO_P); - - Fr accum = (q_arith - Fr.wrap(3)) * (wire(p, WIRE.Q_M) * wire(p, WIRE.W_R) * wire(p, WIRE.W_L)) * neg_half; - accum = accum + (wire(p, WIRE.Q_L) * wire(p, WIRE.W_L)) + (wire(p, WIRE.Q_R) * wire(p, WIRE.W_R)) - + (wire(p, WIRE.Q_O) * wire(p, WIRE.W_O)) + (wire(p, WIRE.Q_4) * wire(p, WIRE.W_4)) + wire(p, WIRE.Q_C); - accum = accum + (q_arith - ONE) * wire(p, WIRE.W_4_SHIFT); - accum = accum * q_arith; - accum = accum * domainSep; - evals[0] = accum; - } - - // Relation 1 - { - Fr accum = wire(p, WIRE.W_L) + wire(p, WIRE.W_4) - wire(p, WIRE.W_L_SHIFT) + wire(p, WIRE.Q_M); - accum = accum * (q_arith - Fr.wrap(2)); - accum = accum * (q_arith - ONE); - accum = accum * q_arith; - accum = accum * domainSep; - evals[1] = accum; - } - } - - function accumulatePermutationRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Honk.RelationParameters memory rp, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - Fr grand_product_numerator; - Fr grand_product_denominator; - - { - Fr num = wire(p, WIRE.W_L) + wire(p, WIRE.ID_1) * rp.beta + rp.gamma; - num = num * (wire(p, WIRE.W_R) + wire(p, WIRE.ID_2) * rp.beta + rp.gamma); - num = num * (wire(p, WIRE.W_O) + wire(p, WIRE.ID_3) * rp.beta + rp.gamma); - num = num * (wire(p, WIRE.W_4) + wire(p, WIRE.ID_4) * rp.beta + rp.gamma); - - grand_product_numerator = num; - } - { - Fr den = wire(p, WIRE.W_L) + wire(p, WIRE.SIGMA_1) * rp.beta + rp.gamma; - den = den * (wire(p, WIRE.W_R) + wire(p, WIRE.SIGMA_2) * rp.beta + rp.gamma); - den = den * (wire(p, WIRE.W_O) + wire(p, WIRE.SIGMA_3) * rp.beta + rp.gamma); - den = den * (wire(p, WIRE.W_4) + wire(p, WIRE.SIGMA_4) * rp.beta + rp.gamma); - - grand_product_denominator = den; - } - - // Contribution 2 - { - Fr acc = (wire(p, WIRE.Z_PERM) + wire(p, WIRE.LAGRANGE_FIRST)) * grand_product_numerator; - - acc = acc - - ( - (wire(p, WIRE.Z_PERM_SHIFT) + (wire(p, WIRE.LAGRANGE_LAST) * rp.publicInputsDelta)) - * grand_product_denominator - ); - acc = acc * domainSep; - evals[2] = acc; - } - - // Contribution 3 - { - Fr acc = (wire(p, WIRE.LAGRANGE_LAST) * wire(p, WIRE.Z_PERM_SHIFT)) * domainSep; - evals[3] = acc; - } - } - - function accumulateLogDerivativeLookupRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Honk.RelationParameters memory rp, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - Fr write_term; - Fr read_term; - - // Calculate the write term (the table accumulation) - { - write_term = wire(p, WIRE.TABLE_1) + rp.gamma + (wire(p, WIRE.TABLE_2) * rp.eta) - + (wire(p, WIRE.TABLE_3) * rp.etaTwo) + (wire(p, WIRE.TABLE_4) * rp.etaThree); - } - - // Calculate the write term - { - Fr derived_entry_1 = wire(p, WIRE.W_L) + rp.gamma + (wire(p, WIRE.Q_R) * wire(p, WIRE.W_L_SHIFT)); - Fr derived_entry_2 = wire(p, WIRE.W_R) + wire(p, WIRE.Q_M) * wire(p, WIRE.W_R_SHIFT); - Fr derived_entry_3 = wire(p, WIRE.W_O) + wire(p, WIRE.Q_C) * wire(p, WIRE.W_O_SHIFT); - - read_term = derived_entry_1 + (derived_entry_2 * rp.eta) + (derived_entry_3 * rp.etaTwo) - + (wire(p, WIRE.Q_O) * rp.etaThree); - } - - Fr read_inverse = wire(p, WIRE.LOOKUP_INVERSES) * write_term; - Fr write_inverse = wire(p, WIRE.LOOKUP_INVERSES) * read_term; - - Fr inverse_exists_xor = wire(p, WIRE.LOOKUP_READ_TAGS) + wire(p, WIRE.Q_LOOKUP) - - (wire(p, WIRE.LOOKUP_READ_TAGS) * wire(p, WIRE.Q_LOOKUP)); - - // Inverse calculated correctly relation - Fr accumulatorNone = read_term * write_term * wire(p, WIRE.LOOKUP_INVERSES) - inverse_exists_xor; - accumulatorNone = accumulatorNone * domainSep; - - // Inverse - Fr accumulatorOne = wire(p, WIRE.Q_LOOKUP) * read_inverse - wire(p, WIRE.LOOKUP_READ_COUNTS) * write_inverse; - - Fr read_tag = wire(p, WIRE.LOOKUP_READ_TAGS); - - Fr read_tag_boolean_relation = read_tag * read_tag - read_tag; - - evals[4] = accumulatorNone; - evals[5] = accumulatorOne; - evals[6] = read_tag_boolean_relation * domainSep; - } - - function accumulateDeltaRangeRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - Fr minus_one = ZERO - ONE; - Fr minus_two = ZERO - Fr.wrap(2); - Fr minus_three = ZERO - Fr.wrap(3); - - // Compute wire differences - Fr delta_1 = wire(p, WIRE.W_R) - wire(p, WIRE.W_L); - Fr delta_2 = wire(p, WIRE.W_O) - wire(p, WIRE.W_R); - Fr delta_3 = wire(p, WIRE.W_4) - wire(p, WIRE.W_O); - Fr delta_4 = wire(p, WIRE.W_L_SHIFT) - wire(p, WIRE.W_4); - - // Contribution 6 - { - Fr acc = delta_1; - acc = acc * (delta_1 + minus_one); - acc = acc * (delta_1 + minus_two); - acc = acc * (delta_1 + minus_three); - acc = acc * wire(p, WIRE.Q_RANGE); - acc = acc * domainSep; - evals[7] = acc; - } - - // Contribution 7 - { - Fr acc = delta_2; - acc = acc * (delta_2 + minus_one); - acc = acc * (delta_2 + minus_two); - acc = acc * (delta_2 + minus_three); - acc = acc * wire(p, WIRE.Q_RANGE); - acc = acc * domainSep; - evals[8] = acc; - } - - // Contribution 8 - { - Fr acc = delta_3; - acc = acc * (delta_3 + minus_one); - acc = acc * (delta_3 + minus_two); - acc = acc * (delta_3 + minus_three); - acc = acc * wire(p, WIRE.Q_RANGE); - acc = acc * domainSep; - evals[9] = acc; - } - - // Contribution 9 - { - Fr acc = delta_4; - acc = acc * (delta_4 + minus_one); - acc = acc * (delta_4 + minus_two); - acc = acc * (delta_4 + minus_three); - acc = acc * wire(p, WIRE.Q_RANGE); - acc = acc * domainSep; - evals[10] = acc; - } - } - - struct EllipticParams { - // Points - Fr x_1; - Fr y_1; - Fr x_2; - Fr y_2; - Fr y_3; - Fr x_3; - // push accumulators into memory - Fr x_double_identity; - } - - function accumulateEllipticRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - EllipticParams memory ep; - ep.x_1 = wire(p, WIRE.W_R); - ep.y_1 = wire(p, WIRE.W_O); - - ep.x_2 = wire(p, WIRE.W_L_SHIFT); - ep.y_2 = wire(p, WIRE.W_4_SHIFT); - ep.y_3 = wire(p, WIRE.W_O_SHIFT); - ep.x_3 = wire(p, WIRE.W_R_SHIFT); - - Fr q_sign = wire(p, WIRE.Q_L); - Fr q_is_double = wire(p, WIRE.Q_M); - - // Contribution 10 point addition, x-coordinate check - // q_elliptic * (x3 + x2 + x1)(x2 - x1)(x2 - x1) - y2^2 - y1^2 + 2(y2y1)*q_sign = 0 - Fr x_diff = (ep.x_2 - ep.x_1); - Fr y1_sqr = (ep.y_1 * ep.y_1); - { - // Move to top - Fr partialEval = domainSep; - - Fr y2_sqr = (ep.y_2 * ep.y_2); - Fr y1y2 = ep.y_1 * ep.y_2 * q_sign; - Fr x_add_identity = (ep.x_3 + ep.x_2 + ep.x_1); - x_add_identity = x_add_identity * x_diff * x_diff; - x_add_identity = x_add_identity - y2_sqr - y1_sqr + y1y2 + y1y2; - - evals[11] = x_add_identity * partialEval * wire(p, WIRE.Q_ELLIPTIC) * (ONE - q_is_double); - } - - // Contribution 11 point addition, x-coordinate check - // q_elliptic * (q_sign * y1 + y3)(x2 - x1) + (x3 - x1)(y2 - q_sign * y1) = 0 - { - Fr y1_plus_y3 = ep.y_1 + ep.y_3; - Fr y_diff = ep.y_2 * q_sign - ep.y_1; - Fr y_add_identity = y1_plus_y3 * x_diff + (ep.x_3 - ep.x_1) * y_diff; - evals[12] = y_add_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * (ONE - q_is_double); - } - - // Contribution 10 point doubling, x-coordinate check - // (x3 + x1 + x1) (4y1*y1) - 9 * x1 * x1 * x1 * x1 = 0 - // N.B. we're using the equivalence x1*x1*x1 === y1*y1 - curve_b to reduce degree by 1 - { - Fr x_pow_4 = (y1_sqr + GRUMPKIN_CURVE_B_PARAMETER_NEGATED) * ep.x_1; - Fr y1_sqr_mul_4 = y1_sqr + y1_sqr; - y1_sqr_mul_4 = y1_sqr_mul_4 + y1_sqr_mul_4; - Fr x1_pow_4_mul_9 = x_pow_4 * Fr.wrap(9); - - // NOTE: pushed into memory (stack >:'( ) - ep.x_double_identity = (ep.x_3 + ep.x_1 + ep.x_1) * y1_sqr_mul_4 - x1_pow_4_mul_9; - - Fr acc = ep.x_double_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * q_is_double; - evals[11] = evals[11] + acc; - } - - // Contribution 11 point doubling, y-coordinate check - // (y1 + y1) (2y1) - (3 * x1 * x1)(x1 - x3) = 0 - { - Fr x1_sqr_mul_3 = (ep.x_1 + ep.x_1 + ep.x_1) * ep.x_1; - Fr y_double_identity = x1_sqr_mul_3 * (ep.x_1 - ep.x_3) - (ep.y_1 + ep.y_1) * (ep.y_1 + ep.y_3); - evals[12] = evals[12] + y_double_identity * domainSep * wire(p, WIRE.Q_ELLIPTIC) * q_is_double; - } - } - - // Parameters used within the Memory Relation - // A struct is used to work around stack too deep. This relation has alot of variables - struct MemParams { - Fr memory_record_check; - Fr partial_record_check; - Fr next_gate_access_type; - Fr record_delta; - Fr index_delta; - Fr adjacent_values_match_if_adjacent_indices_match; - Fr adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation; - Fr access_check; - Fr next_gate_access_type_is_boolean; - Fr ROM_consistency_check_identity; - Fr RAM_consistency_check_identity; - Fr timestamp_delta; - Fr RAM_timestamp_check_identity; - Fr memory_identity; - Fr index_is_monotonically_increasing; - } - - function accumulateMemoryRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Honk.RelationParameters memory rp, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - MemParams memory ap; - - /** - * MEMORY - * - * A RAM memory record contains a tuple of the following fields: - * * i: `index` of memory cell being accessed - * * t: `timestamp` of memory cell being accessed (used for RAM, set to 0 for ROM) - * * v: `value` of memory cell being accessed - * * a: `access` type of record. read: 0 = read, 1 = write - * * r: `record` of memory cell. record = access + index * eta + timestamp * eta_two + value * eta_three - * - * A ROM memory record contains a tuple of the following fields: - * * i: `index` of memory cell being accessed - * * v: `value1` of memory cell being accessed (ROM tables can store up to 2 values per index) - * * v2:`value2` of memory cell being accessed (ROM tables can store up to 2 values per index) - * * r: `record` of memory cell. record = index * eta + value2 * eta_two + value1 * eta_three - * - * When performing a read/write access, the values of i, t, v, v2, a, r are stored in the following wires + - * selectors, depending on whether the gate is a RAM read/write or a ROM read - * - * | gate type | i | v2/t | v | a | r | - * | --------- | -- | ----- | -- | -- | -- | - * | ROM | w1 | w2 | w3 | -- | w4 | - * | RAM | w1 | w2 | w3 | qc | w4 | - * - * (for accesses where `index` is a circuit constant, it is assumed the circuit will apply a copy constraint on - * `w2` to fix its value) - * - * - */ - - /** - * Memory Record Check - * Partial degree: 1 - * Total degree: 4 - * - * A ROM/ROM access gate can be evaluated with the identity: - * - * qc + w1 \eta + w2 \eta_two + w3 \eta_three - w4 = 0 - * - * For ROM gates, qc = 0 - */ - ap.memory_record_check = wire(p, WIRE.W_O) * rp.etaThree; - ap.memory_record_check = ap.memory_record_check + (wire(p, WIRE.W_R) * rp.etaTwo); - ap.memory_record_check = ap.memory_record_check + (wire(p, WIRE.W_L) * rp.eta); - ap.memory_record_check = ap.memory_record_check + wire(p, WIRE.Q_C); - ap.partial_record_check = ap.memory_record_check; // used in RAM consistency check; deg 1 or 4 - ap.memory_record_check = ap.memory_record_check - wire(p, WIRE.W_4); - - /** - * Contribution 13 & 14 - * ROM Consistency Check - * Partial degree: 1 - * Total degree: 4 - * - * For every ROM read, a set equivalence check is applied between the record witnesses, and a second set of - * records that are sorted. - * - * We apply the following checks for the sorted records: - * - * 1. w1, w2, w3 correctly map to 'index', 'v1, 'v2' for a given record value at w4 - * 2. index values for adjacent records are monotonically increasing - * 3. if, at gate i, index_i == index_{i + 1}, then value1_i == value1_{i + 1} and value2_i == value2_{i + 1} - * - */ - ap.index_delta = wire(p, WIRE.W_L_SHIFT) - wire(p, WIRE.W_L); - ap.record_delta = wire(p, WIRE.W_4_SHIFT) - wire(p, WIRE.W_4); - - ap.index_is_monotonically_increasing = ap.index_delta * (ap.index_delta - Fr.wrap(1)); // deg 2 - - ap.adjacent_values_match_if_adjacent_indices_match = (ap.index_delta * MINUS_ONE + ONE) * ap.record_delta; // deg 2 - - evals[14] = ap.adjacent_values_match_if_adjacent_indices_match * (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)) - * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 - evals[15] = ap.index_is_monotonically_increasing * (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)) - * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 - - ap.ROM_consistency_check_identity = ap.memory_record_check * (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)); // deg 3 or 7 - - /** - * Contributions 15,16,17 - * RAM Consistency Check - * - * The 'access' type of the record is extracted with the expression `w_4 - ap.partial_record_check` - * (i.e. for an honest Prover `w1 * eta + w2 * eta^2 + w3 * eta^3 - w4 = access`. - * This is validated by requiring `access` to be boolean - * - * For two adjacent entries in the sorted list if _both_ - * A) index values match - * B) adjacent access value is 0 (i.e. next gate is a READ) - * then - * C) both values must match. - * The gate boolean check is - * (A && B) => C === !(A && B) || C === !A || !B || C - * - * N.B. it is the responsibility of the circuit writer to ensure that every RAM cell is initialized - * with a WRITE operation. - */ - Fr access_type = (wire(p, WIRE.W_4) - ap.partial_record_check); // will be 0 or 1 for honest Prover; deg 1 or 4 - ap.access_check = access_type * (access_type - Fr.wrap(1)); // check value is 0 or 1; deg 2 or 8 - - // reverse order we could re-use `ap.partial_record_check` 1 - ((w3' * eta + w2') * eta + w1') * eta - // deg 1 or 4 - ap.next_gate_access_type = wire(p, WIRE.W_O_SHIFT) * rp.etaThree; - ap.next_gate_access_type = ap.next_gate_access_type + (wire(p, WIRE.W_R_SHIFT) * rp.etaTwo); - ap.next_gate_access_type = ap.next_gate_access_type + (wire(p, WIRE.W_L_SHIFT) * rp.eta); - ap.next_gate_access_type = wire(p, WIRE.W_4_SHIFT) - ap.next_gate_access_type; - - Fr value_delta = wire(p, WIRE.W_O_SHIFT) - wire(p, WIRE.W_O); - ap.adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation = - (ap.index_delta * MINUS_ONE + ONE) * value_delta * (ap.next_gate_access_type * MINUS_ONE + ONE); // deg 3 or 6 - - // We can't apply the RAM consistency check identity on the final entry in the sorted list (the wires in the - // next gate would make the identity fail). We need to validate that its 'access type' bool is correct. Can't - // do with an arithmetic gate because of the `eta` factors. We need to check that the *next* gate's access - // type is correct, to cover this edge case - // deg 2 or 4 - ap.next_gate_access_type_is_boolean = - ap.next_gate_access_type * ap.next_gate_access_type - ap.next_gate_access_type; - - // Putting it all together... - evals[16] = ap.adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation - * (wire(p, WIRE.Q_O)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 or 8 - evals[17] = ap.index_is_monotonically_increasing * (wire(p, WIRE.Q_O)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 - evals[18] = ap.next_gate_access_type_is_boolean * (wire(p, WIRE.Q_O)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 or 6 - - ap.RAM_consistency_check_identity = ap.access_check * (wire(p, WIRE.Q_O)); // deg 3 or 9 - - /** - * RAM Timestamp Consistency Check - * - * | w1 | w2 | w3 | w4 | - * | index | timestamp | timestamp_check | -- | - * - * Let delta_index = index_{i + 1} - index_{i} - * - * Iff delta_index == 0, timestamp_check = timestamp_{i + 1} - timestamp_i - * Else timestamp_check = 0 - */ - ap.timestamp_delta = wire(p, WIRE.W_R_SHIFT) - wire(p, WIRE.W_R); - ap.RAM_timestamp_check_identity = (ap.index_delta * MINUS_ONE + ONE) * ap.timestamp_delta - wire(p, WIRE.W_O); // deg 3 - - /** - * Complete Contribution 12 - * The complete RAM/ROM memory identity - * Partial degree: - */ - ap.memory_identity = ap.ROM_consistency_check_identity; // deg 3 or 6 - ap.memory_identity = - ap.memory_identity + ap.RAM_timestamp_check_identity * (wire(p, WIRE.Q_4) * wire(p, WIRE.Q_L)); // deg 4 - ap.memory_identity = ap.memory_identity + ap.memory_record_check * (wire(p, WIRE.Q_M) * wire(p, WIRE.Q_L)); // deg 3 or 6 - ap.memory_identity = ap.memory_identity + ap.RAM_consistency_check_identity; // deg 3 or 9 - - // (deg 3 or 9) + (deg 4) + (deg 3) - ap.memory_identity = ap.memory_identity * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 or 10 - evals[13] = ap.memory_identity; - } - - // Constants for the Non-native Field relation - Fr constant LIMB_SIZE = Fr.wrap(uint256(1) << 68); - Fr constant SUBLIMB_SHIFT = Fr.wrap(uint256(1) << 14); - - // Parameters used within the Non-Native Field Relation - // A struct is used to work around stack too deep. This relation has alot of variables - struct NnfParams { - Fr limb_subproduct; - Fr non_native_field_gate_1; - Fr non_native_field_gate_2; - Fr non_native_field_gate_3; - Fr limb_accumulator_1; - Fr limb_accumulator_2; - Fr nnf_identity; - } - - function accumulateNnfRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - NnfParams memory ap; - - /** - * Contribution 12 - * Non native field arithmetic gate 2 - * deg 4 - * - * _ _ - * / _ _ _ 14 \ - * q_2 . q_4 | (w_1 . w_2) + (w_1 . w_2) + (w_1 . w_4 + w_2 . w_3 - w_3) . 2 - w_3 - w_4 | - * \_ _/ - * - * - */ - ap.limb_subproduct = wire(p, WIRE.W_L) * wire(p, WIRE.W_R_SHIFT) + wire(p, WIRE.W_L_SHIFT) * wire(p, WIRE.W_R); - ap.non_native_field_gate_2 = - (wire(p, WIRE.W_L) * wire(p, WIRE.W_4) + wire(p, WIRE.W_R) * wire(p, WIRE.W_O) - wire(p, WIRE.W_O_SHIFT)); - ap.non_native_field_gate_2 = ap.non_native_field_gate_2 * LIMB_SIZE; - ap.non_native_field_gate_2 = ap.non_native_field_gate_2 - wire(p, WIRE.W_4_SHIFT); - ap.non_native_field_gate_2 = ap.non_native_field_gate_2 + ap.limb_subproduct; - ap.non_native_field_gate_2 = ap.non_native_field_gate_2 * wire(p, WIRE.Q_4); - - ap.limb_subproduct = ap.limb_subproduct * LIMB_SIZE; - ap.limb_subproduct = ap.limb_subproduct + (wire(p, WIRE.W_L_SHIFT) * wire(p, WIRE.W_R_SHIFT)); - ap.non_native_field_gate_1 = ap.limb_subproduct; - ap.non_native_field_gate_1 = ap.non_native_field_gate_1 - (wire(p, WIRE.W_O) + wire(p, WIRE.W_4)); - ap.non_native_field_gate_1 = ap.non_native_field_gate_1 * wire(p, WIRE.Q_O); - - ap.non_native_field_gate_3 = ap.limb_subproduct; - ap.non_native_field_gate_3 = ap.non_native_field_gate_3 + wire(p, WIRE.W_4); - ap.non_native_field_gate_3 = ap.non_native_field_gate_3 - (wire(p, WIRE.W_O_SHIFT) + wire(p, WIRE.W_4_SHIFT)); - ap.non_native_field_gate_3 = ap.non_native_field_gate_3 * wire(p, WIRE.Q_M); - - Fr non_native_field_identity = - ap.non_native_field_gate_1 + ap.non_native_field_gate_2 + ap.non_native_field_gate_3; - non_native_field_identity = non_native_field_identity * wire(p, WIRE.Q_R); - - // ((((w2' * 2^14 + w1') * 2^14 + w3) * 2^14 + w2) * 2^14 + w1 - w4) * qm - // deg 2 - ap.limb_accumulator_1 = wire(p, WIRE.W_R_SHIFT) * SUBLIMB_SHIFT; - ap.limb_accumulator_1 = ap.limb_accumulator_1 + wire(p, WIRE.W_L_SHIFT); - ap.limb_accumulator_1 = ap.limb_accumulator_1 * SUBLIMB_SHIFT; - ap.limb_accumulator_1 = ap.limb_accumulator_1 + wire(p, WIRE.W_O); - ap.limb_accumulator_1 = ap.limb_accumulator_1 * SUBLIMB_SHIFT; - ap.limb_accumulator_1 = ap.limb_accumulator_1 + wire(p, WIRE.W_R); - ap.limb_accumulator_1 = ap.limb_accumulator_1 * SUBLIMB_SHIFT; - ap.limb_accumulator_1 = ap.limb_accumulator_1 + wire(p, WIRE.W_L); - ap.limb_accumulator_1 = ap.limb_accumulator_1 - wire(p, WIRE.W_4); - ap.limb_accumulator_1 = ap.limb_accumulator_1 * wire(p, WIRE.Q_4); - - // ((((w3' * 2^14 + w2') * 2^14 + w1') * 2^14 + w4) * 2^14 + w3 - w4') * qm - // deg 2 - ap.limb_accumulator_2 = wire(p, WIRE.W_O_SHIFT) * SUBLIMB_SHIFT; - ap.limb_accumulator_2 = ap.limb_accumulator_2 + wire(p, WIRE.W_R_SHIFT); - ap.limb_accumulator_2 = ap.limb_accumulator_2 * SUBLIMB_SHIFT; - ap.limb_accumulator_2 = ap.limb_accumulator_2 + wire(p, WIRE.W_L_SHIFT); - ap.limb_accumulator_2 = ap.limb_accumulator_2 * SUBLIMB_SHIFT; - ap.limb_accumulator_2 = ap.limb_accumulator_2 + wire(p, WIRE.W_4); - ap.limb_accumulator_2 = ap.limb_accumulator_2 * SUBLIMB_SHIFT; - ap.limb_accumulator_2 = ap.limb_accumulator_2 + wire(p, WIRE.W_O); - ap.limb_accumulator_2 = ap.limb_accumulator_2 - wire(p, WIRE.W_4_SHIFT); - ap.limb_accumulator_2 = ap.limb_accumulator_2 * wire(p, WIRE.Q_M); - - Fr limb_accumulator_identity = ap.limb_accumulator_1 + ap.limb_accumulator_2; - limb_accumulator_identity = limb_accumulator_identity * wire(p, WIRE.Q_O); // deg 3 - - ap.nnf_identity = non_native_field_identity + limb_accumulator_identity; - ap.nnf_identity = ap.nnf_identity * (wire(p, WIRE.Q_NNF) * domainSep); - evals[19] = ap.nnf_identity; - } - - struct PoseidonExternalParams { - Fr s1; - Fr s2; - Fr s3; - Fr s4; - Fr u1; - Fr u2; - Fr u3; - Fr u4; - Fr t0; - Fr t1; - Fr t2; - Fr t3; - Fr v1; - Fr v2; - Fr v3; - Fr v4; - Fr q_pos_by_scaling; - } - - function accumulatePoseidonExternalRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - PoseidonExternalParams memory ep; - - ep.s1 = wire(p, WIRE.W_L) + wire(p, WIRE.Q_L); - ep.s2 = wire(p, WIRE.W_R) + wire(p, WIRE.Q_R); - ep.s3 = wire(p, WIRE.W_O) + wire(p, WIRE.Q_O); - ep.s4 = wire(p, WIRE.W_4) + wire(p, WIRE.Q_4); - - ep.u1 = ep.s1 * ep.s1 * ep.s1 * ep.s1 * ep.s1; - ep.u2 = ep.s2 * ep.s2 * ep.s2 * ep.s2 * ep.s2; - ep.u3 = ep.s3 * ep.s3 * ep.s3 * ep.s3 * ep.s3; - ep.u4 = ep.s4 * ep.s4 * ep.s4 * ep.s4 * ep.s4; - // matrix mul v = M_E * u with 14 additions - ep.t0 = ep.u1 + ep.u2; // u_1 + u_2 - ep.t1 = ep.u3 + ep.u4; // u_3 + u_4 - ep.t2 = ep.u2 + ep.u2 + ep.t1; // 2u_2 - // ep.t2 += ep.t1; // 2u_2 + u_3 + u_4 - ep.t3 = ep.u4 + ep.u4 + ep.t0; // 2u_4 - // ep.t3 += ep.t0; // u_1 + u_2 + 2u_4 - ep.v4 = ep.t1 + ep.t1; - ep.v4 = ep.v4 + ep.v4 + ep.t3; - // ep.v4 += ep.t3; // u_1 + u_2 + 4u_3 + 6u_4 - ep.v2 = ep.t0 + ep.t0; - ep.v2 = ep.v2 + ep.v2 + ep.t2; - // ep.v2 += ep.t2; // 4u_1 + 6u_2 + u_3 + u_4 - ep.v1 = ep.t3 + ep.v2; // 5u_1 + 7u_2 + u_3 + 3u_4 - ep.v3 = ep.t2 + ep.v4; // u_1 + 3u_2 + 5u_3 + 7u_4 - - ep.q_pos_by_scaling = wire(p, WIRE.Q_POSEIDON2_EXTERNAL) * domainSep; - evals[20] = evals[20] + ep.q_pos_by_scaling * (ep.v1 - wire(p, WIRE.W_L_SHIFT)); - - evals[21] = evals[21] + ep.q_pos_by_scaling * (ep.v2 - wire(p, WIRE.W_R_SHIFT)); - - evals[22] = evals[22] + ep.q_pos_by_scaling * (ep.v3 - wire(p, WIRE.W_O_SHIFT)); - - evals[23] = evals[23] + ep.q_pos_by_scaling * (ep.v4 - wire(p, WIRE.W_4_SHIFT)); - } - - struct PoseidonInternalParams { - Fr u1; - Fr u2; - Fr u3; - Fr u4; - Fr u_sum; - Fr v1; - Fr v2; - Fr v3; - Fr v4; - Fr s1; - Fr q_pos_by_scaling; - } - - function accumulatePoseidonInternalRelation( - Fr[NUMBER_OF_ENTITIES] memory p, - Fr[NUMBER_OF_SUBRELATIONS] memory evals, - Fr domainSep - ) internal pure { - PoseidonInternalParams memory ip; - - Fr[4] memory INTERNAL_MATRIX_DIAGONAL = [ - FrLib.from(0x10dc6e9c006ea38b04b1e03b4bd9490c0d03f98929ca1d7fb56821fd19d3b6e7), - FrLib.from(0x0c28145b6a44df3e0149b3d0a30b3bb599df9756d4dd9b84a86b38cfb45a740b), - FrLib.from(0x00544b8338791518b2c7645a50392798b21f75bb60e3596170067d00141cac15), - FrLib.from(0x222c01175718386f2e2e82eb122789e352e105a3b8fa852613bc534433ee428b) - ]; - - // add round constants - ip.s1 = wire(p, WIRE.W_L) + wire(p, WIRE.Q_L); - - // apply s-box round - ip.u1 = ip.s1 * ip.s1 * ip.s1 * ip.s1 * ip.s1; - ip.u2 = wire(p, WIRE.W_R); - ip.u3 = wire(p, WIRE.W_O); - ip.u4 = wire(p, WIRE.W_4); - - // matrix mul with v = M_I * u 4 muls and 7 additions - ip.u_sum = ip.u1 + ip.u2 + ip.u3 + ip.u4; - - ip.q_pos_by_scaling = wire(p, WIRE.Q_POSEIDON2_INTERNAL) * domainSep; - - ip.v1 = ip.u1 * INTERNAL_MATRIX_DIAGONAL[0] + ip.u_sum; - evals[24] = evals[24] + ip.q_pos_by_scaling * (ip.v1 - wire(p, WIRE.W_L_SHIFT)); - - ip.v2 = ip.u2 * INTERNAL_MATRIX_DIAGONAL[1] + ip.u_sum; - evals[25] = evals[25] + ip.q_pos_by_scaling * (ip.v2 - wire(p, WIRE.W_R_SHIFT)); - - ip.v3 = ip.u3 * INTERNAL_MATRIX_DIAGONAL[2] + ip.u_sum; - evals[26] = evals[26] + ip.q_pos_by_scaling * (ip.v3 - wire(p, WIRE.W_O_SHIFT)); - - ip.v4 = ip.u4 * INTERNAL_MATRIX_DIAGONAL[3] + ip.u_sum; - evals[27] = evals[27] + ip.q_pos_by_scaling * (ip.v4 - wire(p, WIRE.W_4_SHIFT)); - } - - function scaleAndBatchSubrelations( - Fr[NUMBER_OF_SUBRELATIONS] memory evaluations, - Fr[NUMBER_OF_ALPHAS] memory subrelationChallenges - ) internal pure returns (Fr accumulator) { - accumulator = evaluations[0]; - - for (uint256 i = 1; i < NUMBER_OF_SUBRELATIONS; ++i) { - accumulator = accumulator + evaluations[i] * subrelationChallenges[i - 1]; - } - } + ap.index_is_monotonically_increasing = ap.index_delta * (ap.index_delta - Fr.wrap(1)); // deg 2 + + ap.adjacent_values_match_if_adjacent_indices_match = (ap.index_delta * MINUS_ONE + ONE) * ap.record_delta; // deg 2 + + evals[14] = + ap.adjacent_values_match_if_adjacent_indices_match * + (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)) * + (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 + evals[15] = ap.index_is_monotonically_increasing * (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 + + ap.ROM_consistency_check_identity = ap.memory_record_check * (wire(p, WIRE.Q_L) * wire(p, WIRE.Q_R)); // deg 3 or 7 + + /** + * Contributions 15,16,17 + * RAM Consistency Check + * + * The 'access' type of the record is extracted with the expression `w_4 - ap.partial_record_check` + * (i.e. for an honest Prover `w1 * eta + w2 * eta^2 + w3 * eta^3 - w4 = access`. + * This is validated by requiring `access` to be boolean + * + * For two adjacent entries in the sorted list if _both_ + * A) index values match + * B) adjacent access value is 0 (i.e. next gate is a READ) + * then + * C) both values must match. + * The gate boolean check is + * (A && B) => C === !(A && B) || C === !A || !B || C + * + * N.B. it is the responsibility of the circuit writer to ensure that every RAM cell is initialized + * with a WRITE operation. + */ + Fr access_type = (wire(p, WIRE.W_4) - ap.partial_record_check); // will be 0 or 1 for honest Prover; deg 1 or 4 + ap.access_check = access_type * (access_type - Fr.wrap(1)); // check value is 0 or 1; deg 2 or 8 + + // reverse order we could re-use `ap.partial_record_check` 1 - ((w3' * eta + w2') * eta + w1') * eta + // deg 1 or 4 + ap.next_gate_access_type = wire(p, WIRE.W_O_SHIFT) * rp.etaThree; + ap.next_gate_access_type = ap.next_gate_access_type + (wire(p, WIRE.W_R_SHIFT) * rp.etaTwo); + ap.next_gate_access_type = ap.next_gate_access_type + (wire(p, WIRE.W_L_SHIFT) * rp.eta); + ap.next_gate_access_type = wire(p, WIRE.W_4_SHIFT) - ap.next_gate_access_type; + + Fr value_delta = wire(p, WIRE.W_O_SHIFT) - wire(p, WIRE.W_O); + ap.adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation = + (ap.index_delta * MINUS_ONE + ONE) * + value_delta * + (ap.next_gate_access_type * MINUS_ONE + ONE); // deg 3 or 6 + + // We can't apply the RAM consistency check identity on the final entry in the sorted list (the wires in the + // next gate would make the identity fail). We need to validate that its 'access type' bool is correct. Can't + // do with an arithmetic gate because of the `eta` factors. We need to check that the *next* gate's access + // type is correct, to cover this edge case + // deg 2 or 4 + ap.next_gate_access_type_is_boolean = ap.next_gate_access_type * ap.next_gate_access_type - ap.next_gate_access_type; + + // Putting it all together... + evals[16] = + ap.adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation * + (wire(p, WIRE.Q_O)) * + (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 5 or 8 + evals[17] = ap.index_is_monotonically_increasing * (wire(p, WIRE.Q_O)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 + evals[18] = ap.next_gate_access_type_is_boolean * (wire(p, WIRE.Q_O)) * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 or 6 + + ap.RAM_consistency_check_identity = ap.access_check * (wire(p, WIRE.Q_O)); // deg 3 or 9 + + /** + * RAM Timestamp Consistency Check + * + * | w1 | w2 | w3 | w4 | + * | index | timestamp | timestamp_check | -- | + * + * Let delta_index = index_{i + 1} - index_{i} + * + * Iff delta_index == 0, timestamp_check = timestamp_{i + 1} - timestamp_i + * Else timestamp_check = 0 + */ + ap.timestamp_delta = wire(p, WIRE.W_R_SHIFT) - wire(p, WIRE.W_R); + ap.RAM_timestamp_check_identity = (ap.index_delta * MINUS_ONE + ONE) * ap.timestamp_delta - wire(p, WIRE.W_O); // deg 3 + + /** + * Complete Contribution 12 + * The complete RAM/ROM memory identity + * Partial degree: + */ + ap.memory_identity = ap.ROM_consistency_check_identity; // deg 3 or 6 + ap.memory_identity = ap.memory_identity + ap.RAM_timestamp_check_identity * (wire(p, WIRE.Q_4) * wire(p, WIRE.Q_L)); // deg 4 + ap.memory_identity = ap.memory_identity + ap.memory_record_check * (wire(p, WIRE.Q_M) * wire(p, WIRE.Q_L)); // deg 3 or 6 + ap.memory_identity = ap.memory_identity + ap.RAM_consistency_check_identity; // deg 3 or 9 + + // (deg 3 or 9) + (deg 4) + (deg 3) + ap.memory_identity = ap.memory_identity * (wire(p, WIRE.Q_MEMORY) * domainSep); // deg 4 or 10 + evals[13] = ap.memory_identity; + } + + // Constants for the Non-native Field relation + Fr constant LIMB_SIZE = Fr.wrap(uint256(1) << 68); + Fr constant SUBLIMB_SHIFT = Fr.wrap(uint256(1) << 14); + + // Parameters used within the Non-Native Field Relation + // A struct is used to work around stack too deep. This relation has alot of variables + struct NnfParams { + Fr limb_subproduct; + Fr non_native_field_gate_1; + Fr non_native_field_gate_2; + Fr non_native_field_gate_3; + Fr limb_accumulator_1; + Fr limb_accumulator_2; + Fr nnf_identity; + } + + function accumulateNnfRelation(Fr[NUMBER_OF_ENTITIES] memory p, Fr[NUMBER_OF_SUBRELATIONS] memory evals, Fr domainSep) internal pure { + NnfParams memory ap; + + /** + * Contribution 12 + * Non native field arithmetic gate 2 + * deg 4 + * + * _ _ + * / _ _ _ 14 \ + * q_2 . q_4 | (w_1 . w_2) + (w_1 . w_2) + (w_1 . w_4 + w_2 . w_3 - w_3) . 2 - w_3 - w_4 | + * \_ _/ + * + * + */ + ap.limb_subproduct = wire(p, WIRE.W_L) * wire(p, WIRE.W_R_SHIFT) + wire(p, WIRE.W_L_SHIFT) * wire(p, WIRE.W_R); + ap.non_native_field_gate_2 = (wire(p, WIRE.W_L) * wire(p, WIRE.W_4) + wire(p, WIRE.W_R) * wire(p, WIRE.W_O) - wire(p, WIRE.W_O_SHIFT)); + ap.non_native_field_gate_2 = ap.non_native_field_gate_2 * LIMB_SIZE; + ap.non_native_field_gate_2 = ap.non_native_field_gate_2 - wire(p, WIRE.W_4_SHIFT); + ap.non_native_field_gate_2 = ap.non_native_field_gate_2 + ap.limb_subproduct; + ap.non_native_field_gate_2 = ap.non_native_field_gate_2 * wire(p, WIRE.Q_4); + + ap.limb_subproduct = ap.limb_subproduct * LIMB_SIZE; + ap.limb_subproduct = ap.limb_subproduct + (wire(p, WIRE.W_L_SHIFT) * wire(p, WIRE.W_R_SHIFT)); + ap.non_native_field_gate_1 = ap.limb_subproduct; + ap.non_native_field_gate_1 = ap.non_native_field_gate_1 - (wire(p, WIRE.W_O) + wire(p, WIRE.W_4)); + ap.non_native_field_gate_1 = ap.non_native_field_gate_1 * wire(p, WIRE.Q_O); + + ap.non_native_field_gate_3 = ap.limb_subproduct; + ap.non_native_field_gate_3 = ap.non_native_field_gate_3 + wire(p, WIRE.W_4); + ap.non_native_field_gate_3 = ap.non_native_field_gate_3 - (wire(p, WIRE.W_O_SHIFT) + wire(p, WIRE.W_4_SHIFT)); + ap.non_native_field_gate_3 = ap.non_native_field_gate_3 * wire(p, WIRE.Q_M); + + Fr non_native_field_identity = ap.non_native_field_gate_1 + ap.non_native_field_gate_2 + ap.non_native_field_gate_3; + non_native_field_identity = non_native_field_identity * wire(p, WIRE.Q_R); + + // ((((w2' * 2^14 + w1') * 2^14 + w3) * 2^14 + w2) * 2^14 + w1 - w4) * qm + // deg 2 + ap.limb_accumulator_1 = wire(p, WIRE.W_R_SHIFT) * SUBLIMB_SHIFT; + ap.limb_accumulator_1 = ap.limb_accumulator_1 + wire(p, WIRE.W_L_SHIFT); + ap.limb_accumulator_1 = ap.limb_accumulator_1 * SUBLIMB_SHIFT; + ap.limb_accumulator_1 = ap.limb_accumulator_1 + wire(p, WIRE.W_O); + ap.limb_accumulator_1 = ap.limb_accumulator_1 * SUBLIMB_SHIFT; + ap.limb_accumulator_1 = ap.limb_accumulator_1 + wire(p, WIRE.W_R); + ap.limb_accumulator_1 = ap.limb_accumulator_1 * SUBLIMB_SHIFT; + ap.limb_accumulator_1 = ap.limb_accumulator_1 + wire(p, WIRE.W_L); + ap.limb_accumulator_1 = ap.limb_accumulator_1 - wire(p, WIRE.W_4); + ap.limb_accumulator_1 = ap.limb_accumulator_1 * wire(p, WIRE.Q_4); + + // ((((w3' * 2^14 + w2') * 2^14 + w1') * 2^14 + w4) * 2^14 + w3 - w4') * qm + // deg 2 + ap.limb_accumulator_2 = wire(p, WIRE.W_O_SHIFT) * SUBLIMB_SHIFT; + ap.limb_accumulator_2 = ap.limb_accumulator_2 + wire(p, WIRE.W_R_SHIFT); + ap.limb_accumulator_2 = ap.limb_accumulator_2 * SUBLIMB_SHIFT; + ap.limb_accumulator_2 = ap.limb_accumulator_2 + wire(p, WIRE.W_L_SHIFT); + ap.limb_accumulator_2 = ap.limb_accumulator_2 * SUBLIMB_SHIFT; + ap.limb_accumulator_2 = ap.limb_accumulator_2 + wire(p, WIRE.W_4); + ap.limb_accumulator_2 = ap.limb_accumulator_2 * SUBLIMB_SHIFT; + ap.limb_accumulator_2 = ap.limb_accumulator_2 + wire(p, WIRE.W_O); + ap.limb_accumulator_2 = ap.limb_accumulator_2 - wire(p, WIRE.W_4_SHIFT); + ap.limb_accumulator_2 = ap.limb_accumulator_2 * wire(p, WIRE.Q_M); + + Fr limb_accumulator_identity = ap.limb_accumulator_1 + ap.limb_accumulator_2; + limb_accumulator_identity = limb_accumulator_identity * wire(p, WIRE.Q_O); // deg 3 + + ap.nnf_identity = non_native_field_identity + limb_accumulator_identity; + ap.nnf_identity = ap.nnf_identity * (wire(p, WIRE.Q_NNF) * domainSep); + evals[19] = ap.nnf_identity; + } + + struct PoseidonExternalParams { + Fr s1; + Fr s2; + Fr s3; + Fr s4; + Fr u1; + Fr u2; + Fr u3; + Fr u4; + Fr t0; + Fr t1; + Fr t2; + Fr t3; + Fr v1; + Fr v2; + Fr v3; + Fr v4; + Fr q_pos_by_scaling; + } + + function accumulatePoseidonExternalRelation( + Fr[NUMBER_OF_ENTITIES] memory p, + Fr[NUMBER_OF_SUBRELATIONS] memory evals, + Fr domainSep + ) internal pure { + PoseidonExternalParams memory ep; + + ep.s1 = wire(p, WIRE.W_L) + wire(p, WIRE.Q_L); + ep.s2 = wire(p, WIRE.W_R) + wire(p, WIRE.Q_R); + ep.s3 = wire(p, WIRE.W_O) + wire(p, WIRE.Q_O); + ep.s4 = wire(p, WIRE.W_4) + wire(p, WIRE.Q_4); + + ep.u1 = ep.s1 * ep.s1 * ep.s1 * ep.s1 * ep.s1; + ep.u2 = ep.s2 * ep.s2 * ep.s2 * ep.s2 * ep.s2; + ep.u3 = ep.s3 * ep.s3 * ep.s3 * ep.s3 * ep.s3; + ep.u4 = ep.s4 * ep.s4 * ep.s4 * ep.s4 * ep.s4; + // matrix mul v = M_E * u with 14 additions + ep.t0 = ep.u1 + ep.u2; // u_1 + u_2 + ep.t1 = ep.u3 + ep.u4; // u_3 + u_4 + ep.t2 = ep.u2 + ep.u2 + ep.t1; // 2u_2 + // ep.t2 += ep.t1; // 2u_2 + u_3 + u_4 + ep.t3 = ep.u4 + ep.u4 + ep.t0; // 2u_4 + // ep.t3 += ep.t0; // u_1 + u_2 + 2u_4 + ep.v4 = ep.t1 + ep.t1; + ep.v4 = ep.v4 + ep.v4 + ep.t3; + // ep.v4 += ep.t3; // u_1 + u_2 + 4u_3 + 6u_4 + ep.v2 = ep.t0 + ep.t0; + ep.v2 = ep.v2 + ep.v2 + ep.t2; + // ep.v2 += ep.t2; // 4u_1 + 6u_2 + u_3 + u_4 + ep.v1 = ep.t3 + ep.v2; // 5u_1 + 7u_2 + u_3 + 3u_4 + ep.v3 = ep.t2 + ep.v4; // u_1 + 3u_2 + 5u_3 + 7u_4 + + ep.q_pos_by_scaling = wire(p, WIRE.Q_POSEIDON2_EXTERNAL) * domainSep; + evals[20] = evals[20] + ep.q_pos_by_scaling * (ep.v1 - wire(p, WIRE.W_L_SHIFT)); + + evals[21] = evals[21] + ep.q_pos_by_scaling * (ep.v2 - wire(p, WIRE.W_R_SHIFT)); + + evals[22] = evals[22] + ep.q_pos_by_scaling * (ep.v3 - wire(p, WIRE.W_O_SHIFT)); + + evals[23] = evals[23] + ep.q_pos_by_scaling * (ep.v4 - wire(p, WIRE.W_4_SHIFT)); + } + + struct PoseidonInternalParams { + Fr u1; + Fr u2; + Fr u3; + Fr u4; + Fr u_sum; + Fr v1; + Fr v2; + Fr v3; + Fr v4; + Fr s1; + Fr q_pos_by_scaling; + } + + function accumulatePoseidonInternalRelation( + Fr[NUMBER_OF_ENTITIES] memory p, + Fr[NUMBER_OF_SUBRELATIONS] memory evals, + Fr domainSep + ) internal pure { + PoseidonInternalParams memory ip; + + Fr[4] memory INTERNAL_MATRIX_DIAGONAL = [ + FrLib.from(0x10dc6e9c006ea38b04b1e03b4bd9490c0d03f98929ca1d7fb56821fd19d3b6e7), + FrLib.from(0x0c28145b6a44df3e0149b3d0a30b3bb599df9756d4dd9b84a86b38cfb45a740b), + FrLib.from(0x00544b8338791518b2c7645a50392798b21f75bb60e3596170067d00141cac15), + FrLib.from(0x222c01175718386f2e2e82eb122789e352e105a3b8fa852613bc534433ee428b) + ]; + + // add round constants + ip.s1 = wire(p, WIRE.W_L) + wire(p, WIRE.Q_L); + + // apply s-box round + ip.u1 = ip.s1 * ip.s1 * ip.s1 * ip.s1 * ip.s1; + ip.u2 = wire(p, WIRE.W_R); + ip.u3 = wire(p, WIRE.W_O); + ip.u4 = wire(p, WIRE.W_4); + + // matrix mul with v = M_I * u 4 muls and 7 additions + ip.u_sum = ip.u1 + ip.u2 + ip.u3 + ip.u4; + + ip.q_pos_by_scaling = wire(p, WIRE.Q_POSEIDON2_INTERNAL) * domainSep; + + ip.v1 = ip.u1 * INTERNAL_MATRIX_DIAGONAL[0] + ip.u_sum; + evals[24] = evals[24] + ip.q_pos_by_scaling * (ip.v1 - wire(p, WIRE.W_L_SHIFT)); + + ip.v2 = ip.u2 * INTERNAL_MATRIX_DIAGONAL[1] + ip.u_sum; + evals[25] = evals[25] + ip.q_pos_by_scaling * (ip.v2 - wire(p, WIRE.W_R_SHIFT)); + + ip.v3 = ip.u3 * INTERNAL_MATRIX_DIAGONAL[2] + ip.u_sum; + evals[26] = evals[26] + ip.q_pos_by_scaling * (ip.v3 - wire(p, WIRE.W_O_SHIFT)); + + ip.v4 = ip.u4 * INTERNAL_MATRIX_DIAGONAL[3] + ip.u_sum; + evals[27] = evals[27] + ip.q_pos_by_scaling * (ip.v4 - wire(p, WIRE.W_4_SHIFT)); + } + + function scaleAndBatchSubrelations( + Fr[NUMBER_OF_SUBRELATIONS] memory evaluations, + Fr[NUMBER_OF_ALPHAS] memory subrelationChallenges + ) internal pure returns (Fr accumulator) { + accumulator = evaluations[0]; + + for (uint256 i = 1; i < NUMBER_OF_SUBRELATIONS; ++i) { + accumulator = accumulator + evaluations[i] * subrelationChallenges[i - 1]; + } + } } // Field arithmetic libraries - prevent littering the code with modmul / addmul library CommitmentSchemeLib { - using FrLib for Fr; - - // Avoid stack too deep - struct ShpleminiIntermediates { - Fr unshiftedScalar; - Fr shiftedScalar; - Fr unshiftedScalarNeg; - Fr shiftedScalarNeg; - // Scalar to be multiplied by [1]₁ - Fr constantTermAccumulator; - // Accumulator for powers of rho - Fr batchingChallenge; - // Linear combination of multilinear (sumcheck) evaluations and powers of rho - Fr batchedEvaluation; - Fr[4] denominators; - Fr[4] batchingScalars; - // 1/(z - r^{2^i}) for i = 0, ..., logSize, dynamically updated - Fr posInvertedDenominator; - // 1/(z + r^{2^i}) for i = 0, ..., logSize, dynamically updated - Fr negInvertedDenominator; - // ν^{2i} * 1/(z - r^{2^i}) - Fr scalingFactorPos; - // ν^{2i+1} * 1/(z + r^{2^i}) - Fr scalingFactorNeg; - // Fold_i(r^{2^i}) reconstructed by Verifier - Fr[] foldPosEvaluations; - } - - function computeSquares(Fr r, uint256 logN) internal pure returns (Fr[] memory) { - Fr[] memory squares = new Fr[](logN); - squares[0] = r; - for (uint256 i = 1; i < logN; ++i) { - squares[i] = squares[i - 1].sqr(); - } - return squares; - } - // Compute the evaluations Aₗ(r^{2ˡ}) for l = 0, ..., m-1 - - function computeFoldPosEvaluations( - Fr[CONST_PROOF_SIZE_LOG_N] memory sumcheckUChallenges, - Fr batchedEvalAccumulator, - Fr[CONST_PROOF_SIZE_LOG_N] memory geminiEvaluations, - Fr[] memory geminiEvalChallengePowers, - uint256 logSize - ) internal view returns (Fr[] memory) { - Fr[] memory foldPosEvaluations = new Fr[](logSize); - for (uint256 i = logSize; i > 0; --i) { - Fr challengePower = geminiEvalChallengePowers[i - 1]; - Fr u = sumcheckUChallenges[i - 1]; - - Fr batchedEvalRoundAcc = ( - (challengePower * batchedEvalAccumulator * Fr.wrap(2)) - - geminiEvaluations[i - 1] * (challengePower * (ONE - u) - u) - ); - // Divide by the denominator - batchedEvalRoundAcc = batchedEvalRoundAcc * (challengePower * (ONE - u) + u).invert(); - - batchedEvalAccumulator = batchedEvalRoundAcc; - foldPosEvaluations[i - 1] = batchedEvalRoundAcc; - } - return foldPosEvaluations; - } + using FrLib for Fr; + + // Avoid stack too deep + struct ShpleminiIntermediates { + Fr unshiftedScalar; + Fr shiftedScalar; + Fr unshiftedScalarNeg; + Fr shiftedScalarNeg; + // Scalar to be multiplied by [1]₁ + Fr constantTermAccumulator; + // Accumulator for powers of rho + Fr batchingChallenge; + // Linear combination of multilinear (sumcheck) evaluations and powers of rho + Fr batchedEvaluation; + Fr[4] denominators; + Fr[4] batchingScalars; + // 1/(z - r^{2^i}) for i = 0, ..., logSize, dynamically updated + Fr posInvertedDenominator; + // 1/(z + r^{2^i}) for i = 0, ..., logSize, dynamically updated + Fr negInvertedDenominator; + // ν^{2i} * 1/(z - r^{2^i}) + Fr scalingFactorPos; + // ν^{2i+1} * 1/(z + r^{2^i}) + Fr scalingFactorNeg; + // Fold_i(r^{2^i}) reconstructed by Verifier + Fr[] foldPosEvaluations; + } + + function computeSquares(Fr r, uint256 logN) internal pure returns (Fr[] memory) { + Fr[] memory squares = new Fr[](logN); + squares[0] = r; + for (uint256 i = 1; i < logN; ++i) { + squares[i] = squares[i - 1].sqr(); + } + return squares; + } + // Compute the evaluations Aₗ(r^{2ˡ}) for l = 0, ..., m-1 + + function computeFoldPosEvaluations( + Fr[CONST_PROOF_SIZE_LOG_N] memory sumcheckUChallenges, + Fr batchedEvalAccumulator, + Fr[CONST_PROOF_SIZE_LOG_N] memory geminiEvaluations, + Fr[] memory geminiEvalChallengePowers, + uint256 logSize + ) internal view returns (Fr[] memory) { + Fr[] memory foldPosEvaluations = new Fr[](logSize); + for (uint256 i = logSize; i > 0; --i) { + Fr challengePower = geminiEvalChallengePowers[i - 1]; + Fr u = sumcheckUChallenges[i - 1]; + + Fr batchedEvalRoundAcc = ((challengePower * batchedEvalAccumulator * Fr.wrap(2)) - + geminiEvaluations[i - 1] * + (challengePower * (ONE - u) - u)); + // Divide by the denominator + batchedEvalRoundAcc = batchedEvalRoundAcc * (challengePower * (ONE - u) + u).invert(); + + batchedEvalAccumulator = batchedEvalRoundAcc; + foldPosEvaluations[i - 1] = batchedEvalRoundAcc; + } + return foldPosEvaluations; + } } uint256 constant Q = 21888242871839275222246405745257275088696311157297823662689037894645226208583; // EC group order. F_q function bytes32ToString(bytes32 value) pure returns (string memory result) { - bytes memory alphabet = "0123456789abcdef"; - - bytes memory str = new bytes(66); - str[0] = "0"; - str[1] = "x"; - for (uint256 i = 0; i < 32; i++) { - str[2 + i * 2] = alphabet[uint8(value[i] >> 4)]; - str[3 + i * 2] = alphabet[uint8(value[i] & 0x0f)]; - } - result = string(str); + bytes memory alphabet = "0123456789abcdef"; + + bytes memory str = new bytes(66); + str[0] = "0"; + str[1] = "x"; + for (uint256 i = 0; i < 32; i++) { + str[2 + i * 2] = alphabet[uint8(value[i] >> 4)]; + str[3 + i * 2] = alphabet[uint8(value[i] & 0x0f)]; + } + result = string(str); } // Fr utility function bytesToFr(bytes calldata proofSection) pure returns (Fr scalar) { - scalar = FrLib.fromBytes32(bytes32(proofSection)); + scalar = FrLib.fromBytes32(bytes32(proofSection)); } // EC Point utilities function bytesToG1Point(bytes calldata proofSection) pure returns (Honk.G1Point memory point) { - point = Honk.G1Point({ - x: uint256(bytes32(proofSection[0x00:0x20])) % Q, - y: uint256(bytes32(proofSection[0x20:0x40])) % Q - }); + point = Honk.G1Point({ x: uint256(bytes32(proofSection[0x00:0x20])) % Q, y: uint256(bytes32(proofSection[0x20:0x40])) % Q }); } function negateInplace(Honk.G1Point memory point) pure returns (Honk.G1Point memory) { - point.y = (Q - point.y) % Q; - return point; + point.y = (Q - point.y) % Q; + return point; } /** @@ -1648,33 +1641,32 @@ function negateInplace(Honk.G1Point memory point) pure returns (Honk.G1Point mem * @return lhs * @return rhs */ -function convertPairingPointsToG1(Fr[PAIRING_POINTS_SIZE] memory pairingPoints) - pure - returns (Honk.G1Point memory lhs, Honk.G1Point memory rhs) -{ - uint256 lhsX = Fr.unwrap(pairingPoints[0]); - lhsX |= Fr.unwrap(pairingPoints[1]) << 68; - lhsX |= Fr.unwrap(pairingPoints[2]) << 136; - lhsX |= Fr.unwrap(pairingPoints[3]) << 204; - lhs.x = lhsX; - - uint256 lhsY = Fr.unwrap(pairingPoints[4]); - lhsY |= Fr.unwrap(pairingPoints[5]) << 68; - lhsY |= Fr.unwrap(pairingPoints[6]) << 136; - lhsY |= Fr.unwrap(pairingPoints[7]) << 204; - lhs.y = lhsY; - - uint256 rhsX = Fr.unwrap(pairingPoints[8]); - rhsX |= Fr.unwrap(pairingPoints[9]) << 68; - rhsX |= Fr.unwrap(pairingPoints[10]) << 136; - rhsX |= Fr.unwrap(pairingPoints[11]) << 204; - rhs.x = rhsX; - - uint256 rhsY = Fr.unwrap(pairingPoints[12]); - rhsY |= Fr.unwrap(pairingPoints[13]) << 68; - rhsY |= Fr.unwrap(pairingPoints[14]) << 136; - rhsY |= Fr.unwrap(pairingPoints[15]) << 204; - rhs.y = rhsY; +function convertPairingPointsToG1( + Fr[PAIRING_POINTS_SIZE] memory pairingPoints +) pure returns (Honk.G1Point memory lhs, Honk.G1Point memory rhs) { + uint256 lhsX = Fr.unwrap(pairingPoints[0]); + lhsX |= Fr.unwrap(pairingPoints[1]) << 68; + lhsX |= Fr.unwrap(pairingPoints[2]) << 136; + lhsX |= Fr.unwrap(pairingPoints[3]) << 204; + lhs.x = lhsX; + + uint256 lhsY = Fr.unwrap(pairingPoints[4]); + lhsY |= Fr.unwrap(pairingPoints[5]) << 68; + lhsY |= Fr.unwrap(pairingPoints[6]) << 136; + lhsY |= Fr.unwrap(pairingPoints[7]) << 204; + lhs.y = lhsY; + + uint256 rhsX = Fr.unwrap(pairingPoints[8]); + rhsX |= Fr.unwrap(pairingPoints[9]) << 68; + rhsX |= Fr.unwrap(pairingPoints[10]) << 136; + rhsX |= Fr.unwrap(pairingPoints[11]) << 204; + rhs.x = rhsX; + + uint256 rhsY = Fr.unwrap(pairingPoints[12]); + rhsY |= Fr.unwrap(pairingPoints[13]) << 68; + rhsY |= Fr.unwrap(pairingPoints[14]) << 136; + rhsY |= Fr.unwrap(pairingPoints[15]) << 204; + rhs.y = rhsY; } /** @@ -1686,32 +1678,32 @@ function convertPairingPointsToG1(Fr[PAIRING_POINTS_SIZE] memory pairingPoints) * @return recursionSeparator The recursion separator - generated from hashing the above. */ function generateRecursionSeparator( - Fr[PAIRING_POINTS_SIZE] memory proofPairingPoints, - Honk.G1Point memory accLhs, - Honk.G1Point memory accRhs + Fr[PAIRING_POINTS_SIZE] memory proofPairingPoints, + Honk.G1Point memory accLhs, + Honk.G1Point memory accRhs ) pure returns (Fr recursionSeparator) { - // hash the proof aggregated X - // hash the proof aggregated Y - // hash the accum X - // hash the accum Y + // hash the proof aggregated X + // hash the proof aggregated Y + // hash the accum X + // hash the accum Y - (Honk.G1Point memory proofLhs, Honk.G1Point memory proofRhs) = convertPairingPointsToG1(proofPairingPoints); + (Honk.G1Point memory proofLhs, Honk.G1Point memory proofRhs) = convertPairingPointsToG1(proofPairingPoints); - uint256[8] memory recursionSeparatorElements; + uint256[8] memory recursionSeparatorElements; - // Proof points - recursionSeparatorElements[0] = proofLhs.x; - recursionSeparatorElements[1] = proofLhs.y; - recursionSeparatorElements[2] = proofRhs.x; - recursionSeparatorElements[3] = proofRhs.y; + // Proof points + recursionSeparatorElements[0] = proofLhs.x; + recursionSeparatorElements[1] = proofLhs.y; + recursionSeparatorElements[2] = proofRhs.x; + recursionSeparatorElements[3] = proofRhs.y; - // Accumulator points - recursionSeparatorElements[4] = accLhs.x; - recursionSeparatorElements[5] = accLhs.y; - recursionSeparatorElements[6] = accRhs.x; - recursionSeparatorElements[7] = accRhs.y; + // Accumulator points + recursionSeparatorElements[4] = accLhs.x; + recursionSeparatorElements[5] = accLhs.y; + recursionSeparatorElements[6] = accRhs.x; + recursionSeparatorElements[7] = accRhs.y; - recursionSeparator = FrLib.fromBytes32(keccak256(abi.encodePacked(recursionSeparatorElements))); + recursionSeparator = FrLib.fromBytes32(keccak256(abi.encodePacked(recursionSeparatorElements))); } /** @@ -1723,16 +1715,17 @@ function generateRecursionSeparator( * @param recursionSeperator The separator to use for the multiplication. * @return `(recursionSeperator * basePoint) + other`. */ -function mulWithSeperator(Honk.G1Point memory basePoint, Honk.G1Point memory other, Fr recursionSeperator) - view - returns (Honk.G1Point memory) -{ - Honk.G1Point memory result; +function mulWithSeperator( + Honk.G1Point memory basePoint, + Honk.G1Point memory other, + Fr recursionSeperator +) view returns (Honk.G1Point memory) { + Honk.G1Point memory result; - result = ecMul(recursionSeperator, basePoint); - result = ecAdd(result, other); + result = ecMul(recursionSeperator, basePoint); + result = ecAdd(result, other); - return result; + return result; } /** @@ -1744,41 +1737,41 @@ function mulWithSeperator(Honk.G1Point memory basePoint, Honk.G1Point memory oth * @return result The result of the multiplication. */ function ecMul(Fr value, Honk.G1Point memory point) view returns (Honk.G1Point memory) { - Honk.G1Point memory result; - - assembly { - let free := mload(0x40) - // Write the point into memory (two 32 byte words) - // Memory layout: - // Address | value - // free | point.x - // free + 0x20| point.y - mstore(free, mload(point)) - mstore(add(free, 0x20), mload(add(point, 0x20))) - // Write the scalar into memory (one 32 byte word) - // Memory layout: - // Address | value - // free + 0x40| value - mstore(add(free, 0x40), value) - - // Call the ecMul precompile, it takes in the following - // [point.x, point.y, scalar], and returns the result back into the free memory location. - let success := staticcall(gas(), 0x07, free, 0x60, free, 0x40) - if iszero(success) { - revert(0, 0) - } - // Copy the result of the multiplication back into the result memory location. - // Memory layout: - // Address | value - // result | result.x - // result + 0x20| result.y - mstore(result, mload(free)) - mstore(add(result, 0x20), mload(add(free, 0x20))) - - mstore(0x40, add(free, 0x60)) - } - - return result; + Honk.G1Point memory result; + + assembly { + let free := mload(0x40) + // Write the point into memory (two 32 byte words) + // Memory layout: + // Address | value + // free | point.x + // free + 0x20| point.y + mstore(free, mload(point)) + mstore(add(free, 0x20), mload(add(point, 0x20))) + // Write the scalar into memory (one 32 byte word) + // Memory layout: + // Address | value + // free + 0x40| value + mstore(add(free, 0x40), value) + + // Call the ecMul precompile, it takes in the following + // [point.x, point.y, scalar], and returns the result back into the free memory location. + let success := staticcall(gas(), 0x07, free, 0x60, free, 0x40) + if iszero(success) { + revert(0, 0) + } + // Copy the result of the multiplication back into the result memory location. + // Memory layout: + // Address | value + // result | result.x + // result + 0x20| result.y + mstore(result, mload(free)) + mstore(add(result, 0x20), mload(add(free, 0x20))) + + mstore(0x40, add(free, 0x60)) + } + + return result; } /** @@ -1790,649 +1783,637 @@ function ecMul(Fr value, Honk.G1Point memory point) view returns (Honk.G1Point m * @return result The result of the addition. */ function ecAdd(Honk.G1Point memory lhs, Honk.G1Point memory rhs) view returns (Honk.G1Point memory) { - Honk.G1Point memory result; - - assembly { - let free := mload(0x40) - // Write lhs into memory (two 32 byte words) - // Memory layout: - // Address | value - // free | lhs.x - // free + 0x20| lhs.y - mstore(free, mload(lhs)) - mstore(add(free, 0x20), mload(add(lhs, 0x20))) - - // Write rhs into memory (two 32 byte words) - // Memory layout: - // Address | value - // free + 0x40| rhs.x - // free + 0x60| rhs.y - mstore(add(free, 0x40), mload(rhs)) - mstore(add(free, 0x60), mload(add(rhs, 0x20))) - - // Call the ecAdd precompile, it takes in the following - // [lhs.x, lhs.y, rhs.x, rhs.y], and returns their addition back into the free memory location. - let success := staticcall(gas(), 0x06, free, 0x80, free, 0x40) - if iszero(success) { revert(0, 0) } - - // Copy the result of the addition back into the result memory location. - // Memory layout: - // Address | value - // result | result.x - // result + 0x20| result.y - mstore(result, mload(free)) - mstore(add(result, 0x20), mload(add(free, 0x20))) - - mstore(0x40, add(free, 0x80)) - } - - return result; + Honk.G1Point memory result; + + assembly { + let free := mload(0x40) + // Write lhs into memory (two 32 byte words) + // Memory layout: + // Address | value + // free | lhs.x + // free + 0x20| lhs.y + mstore(free, mload(lhs)) + mstore(add(free, 0x20), mload(add(lhs, 0x20))) + + // Write rhs into memory (two 32 byte words) + // Memory layout: + // Address | value + // free + 0x40| rhs.x + // free + 0x60| rhs.y + mstore(add(free, 0x40), mload(rhs)) + mstore(add(free, 0x60), mload(add(rhs, 0x20))) + + // Call the ecAdd precompile, it takes in the following + // [lhs.x, lhs.y, rhs.x, rhs.y], and returns their addition back into the free memory location. + let success := staticcall(gas(), 0x06, free, 0x80, free, 0x40) + if iszero(success) { + revert(0, 0) + } + + // Copy the result of the addition back into the result memory location. + // Memory layout: + // Address | value + // result | result.x + // result + 0x20| result.y + mstore(result, mload(free)) + mstore(add(result, 0x20), mload(add(free, 0x20))) + + mstore(0x40, add(free, 0x80)) + } + + return result; } function validateOnCurve(Honk.G1Point memory point) pure { - uint256 x = point.x; - uint256 y = point.y; + uint256 x = point.x; + uint256 y = point.y; - bool success = false; - assembly { - let xx := mulmod(x, x, Q) - success := eq(mulmod(y, y, Q), addmod(mulmod(x, xx, Q), 3, Q)) - } + bool success = false; + assembly { + let xx := mulmod(x, x, Q) + success := eq(mulmod(y, y, Q), addmod(mulmod(x, xx, Q), 3, Q)) + } - require(success, "point is not on the curve"); + require(success, "point is not on the curve"); } function pairing(Honk.G1Point memory rhs, Honk.G1Point memory lhs) view returns (bool decodedResult) { - bytes memory input = abi.encodePacked( - rhs.x, - rhs.y, - // Fixed G2 point - uint256(0x198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2), - uint256(0x1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed), - uint256(0x090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b), - uint256(0x12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa), - lhs.x, - lhs.y, - // G2 point from VK - uint256(0x260e01b251f6f1c7e7ff4e580791dee8ea51d87a358e038b4efe30fac09383c1), - uint256(0x0118c4d5b837bcc2bc89b5b398b5974e9f5944073b32078b7e231fec938883b0), - uint256(0x04fc6369f7110fe3d25156c1bb9a72859cf2a04641f99ba4ee413c80da6a5fe4), - uint256(0x22febda3c0c0632a56475b4214e5615e11e6dd3f96e6cea2854a87d4dacc5e55) - ); - - (bool success, bytes memory result) = address(0x08).staticcall(input); - decodedResult = success && abi.decode(result, (bool)); + bytes memory input = abi.encodePacked( + rhs.x, + rhs.y, + // Fixed G2 point + uint256(0x198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2), + uint256(0x1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed), + uint256(0x090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b), + uint256(0x12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa), + lhs.x, + lhs.y, + // G2 point from VK + uint256(0x260e01b251f6f1c7e7ff4e580791dee8ea51d87a358e038b4efe30fac09383c1), + uint256(0x0118c4d5b837bcc2bc89b5b398b5974e9f5944073b32078b7e231fec938883b0), + uint256(0x04fc6369f7110fe3d25156c1bb9a72859cf2a04641f99ba4ee413c80da6a5fe4), + uint256(0x22febda3c0c0632a56475b4214e5615e11e6dd3f96e6cea2854a87d4dacc5e55) + ); + + (bool success, bytes memory result) = address(0x08).staticcall(input); + decodedResult = success && abi.decode(result, (bool)); } // Field arithmetic libraries - prevent littering the code with modmul / addmul +abstract contract BaseZKHonkVerifier is IVerifier { + using FrLib for Fr; + + uint256 immutable $N; + uint256 immutable $LOG_N; + uint256 immutable $VK_HASH; + uint256 immutable $NUM_PUBLIC_INPUTS; + + constructor(uint256 _N, uint256 _logN, uint256 _vkHash, uint256 _numPublicInputs) { + $N = _N; + $LOG_N = _logN; + $VK_HASH = _vkHash; + $NUM_PUBLIC_INPUTS = _numPublicInputs; + } + + // Errors + error ProofLengthWrong(); + error ProofLengthWrongWithLogN(uint256 logN, uint256 actualLength, uint256 expectedLength); + error PublicInputsLengthWrong(); + error SumcheckFailed(); + error ShpleminiFailed(); + error GeminiChallengeInSubgroup(); + error ConsistencyCheckFailed(); + + // Constants for proof length calculation (matching UltraKeccakZKFlavor) + uint256 constant NUM_WITNESS_ENTITIES = 8; + uint256 constant NUM_ELEMENTS_COMM = 2; // uint256 elements for curve points + uint256 constant NUM_ELEMENTS_FR = 1; // uint256 elements for field elements + uint256 constant NUM_LIBRA_EVALUATIONS = 4; // libra evaluations + + // Calculate proof size based on log_n (matching UltraKeccakZKFlavor formula) + function calculateProofSize(uint256 logN) internal pure returns (uint256) { + // Witness and Libra commitments + uint256 proofLength = NUM_WITNESS_ENTITIES * NUM_ELEMENTS_COMM; // witness commitments + proofLength += NUM_ELEMENTS_COMM * 4; // Libra concat, grand sum, quotient comms + Gemini masking + // Sumcheck + proofLength += logN * ZK_BATCHED_RELATION_PARTIAL_LENGTH * NUM_ELEMENTS_FR; // sumcheck univariates + proofLength += NUMBER_OF_ENTITIES * NUM_ELEMENTS_FR; // sumcheck evaluations + // Libra and Gemini + proofLength += NUM_ELEMENTS_FR * 3; // Libra sum, claimed eval, Gemini masking eval + proofLength += logN * NUM_ELEMENTS_FR; // Gemini a evaluations + proofLength += NUM_LIBRA_EVALUATIONS * NUM_ELEMENTS_FR; // libra evaluations -abstract contract BaseZKHonkVerifier is IVerifier { - using FrLib for Fr; + // PCS commitments + proofLength += (logN - 1) * NUM_ELEMENTS_COMM; // Gemini Fold commitments + proofLength += NUM_ELEMENTS_COMM * 2; // Shplonk Q and KZG W commitments + + // Pairing points + proofLength += PAIRING_POINTS_SIZE; // pairing inputs carried on public inputs - uint256 immutable $N; - uint256 immutable $LOG_N; - uint256 immutable $VK_HASH; - uint256 immutable $NUM_PUBLIC_INPUTS; + return proofLength; + } - constructor(uint256 _N, uint256 _logN, uint256 _vkHash, uint256 _numPublicInputs) { - $N = _N; - $LOG_N = _logN; - $VK_HASH = _vkHash; - $NUM_PUBLIC_INPUTS = _numPublicInputs; + uint256 constant SHIFTED_COMMITMENTS_START = 30; + + function loadVerificationKey() internal pure virtual returns (Honk.VerificationKey memory); + + function verify(bytes calldata proof, bytes32[] calldata publicInputs) public view override returns (bool verified) { + // Calculate expected proof size based on $LOG_N + uint256 expectedProofSize = calculateProofSize($LOG_N); + + // Check the received proof is the expected size where each field element is 32 bytes + if (proof.length != expectedProofSize * 32) { + revert ProofLengthWrongWithLogN($LOG_N, proof.length, expectedProofSize * 32); } - // Errors - error ProofLengthWrong(); - error ProofLengthWrongWithLogN(uint256 logN, uint256 actualLength, uint256 expectedLength); - error PublicInputsLengthWrong(); - error SumcheckFailed(); - error ShpleminiFailed(); - error GeminiChallengeInSubgroup(); - error ConsistencyCheckFailed(); + Honk.VerificationKey memory vk = loadVerificationKey(); + Honk.ZKProof memory p = ZKTranscriptLib.loadProof(proof, $LOG_N); - // Constants for proof length calculation (matching UltraKeccakZKFlavor) - uint256 constant NUM_WITNESS_ENTITIES = 8; - uint256 constant NUM_ELEMENTS_COMM = 2; // uint256 elements for curve points - uint256 constant NUM_ELEMENTS_FR = 1; // uint256 elements for field elements - uint256 constant NUM_LIBRA_EVALUATIONS = 4; // libra evaluations + if (publicInputs.length != vk.publicInputsSize - PAIRING_POINTS_SIZE) { + revert PublicInputsLengthWrong(); + } - // Calculate proof size based on log_n (matching UltraKeccakZKFlavor formula) - function calculateProofSize(uint256 logN) internal pure returns (uint256) { - // Witness and Libra commitments - uint256 proofLength = NUM_WITNESS_ENTITIES * NUM_ELEMENTS_COMM; // witness commitments - proofLength += NUM_ELEMENTS_COMM * 4; // Libra concat, grand sum, quotient comms + Gemini masking + // Generate the fiat shamir challenges for the whole protocol + ZKTranscript memory t = ZKTranscriptLib.generateTranscript(p, publicInputs, $VK_HASH, $NUM_PUBLIC_INPUTS, $LOG_N); - // Sumcheck - proofLength += logN * ZK_BATCHED_RELATION_PARTIAL_LENGTH * NUM_ELEMENTS_FR; // sumcheck univariates - proofLength += NUMBER_OF_ENTITIES * NUM_ELEMENTS_FR; // sumcheck evaluations + // Derive public input delta + t.relationParameters.publicInputsDelta = computePublicInputDelta( + publicInputs, + p.pairingPointObject, + t.relationParameters.beta, + t.relationParameters.gamma /*pubInputsOffset=*/, + 1 + ); - // Libra and Gemini - proofLength += NUM_ELEMENTS_FR * 3; // Libra sum, claimed eval, Gemini masking eval - proofLength += logN * NUM_ELEMENTS_FR; // Gemini a evaluations - proofLength += NUM_LIBRA_EVALUATIONS * NUM_ELEMENTS_FR; // libra evaluations + // Sumcheck + if (!verifySumcheck(p, t)) revert SumcheckFailed(); - // PCS commitments - proofLength += (logN - 1) * NUM_ELEMENTS_COMM; // Gemini Fold commitments - proofLength += NUM_ELEMENTS_COMM * 2; // Shplonk Q and KZG W commitments + if (!verifyShplemini(p, vk, t)) revert ShpleminiFailed(); - // Pairing points - proofLength += PAIRING_POINTS_SIZE; // pairing inputs carried on public inputs + verified = true; + } - return proofLength; - } + uint256 constant PERMUTATION_ARGUMENT_VALUE_SEPARATOR = 1 << 28; - uint256 constant SHIFTED_COMMITMENTS_START = 30; + function computePublicInputDelta( + bytes32[] memory publicInputs, + Fr[PAIRING_POINTS_SIZE] memory pairingPointObject, + Fr beta, + Fr gamma, + uint256 offset + ) internal view returns (Fr publicInputDelta) { + Fr numerator = Fr.wrap(1); + Fr denominator = Fr.wrap(1); - function loadVerificationKey() internal pure virtual returns (Honk.VerificationKey memory); + Fr numeratorAcc = gamma + (beta * FrLib.from(PERMUTATION_ARGUMENT_VALUE_SEPARATOR + offset)); + Fr denominatorAcc = gamma - (beta * FrLib.from(offset + 1)); - function verify(bytes calldata proof, bytes32[] calldata publicInputs) - public - view - override - returns (bool verified) { - // Calculate expected proof size based on $LOG_N - uint256 expectedProofSize = calculateProofSize($LOG_N); + for (uint256 i = 0; i < $NUM_PUBLIC_INPUTS - PAIRING_POINTS_SIZE; i++) { + Fr pubInput = FrLib.fromBytes32(publicInputs[i]); + + numerator = numerator * (numeratorAcc + pubInput); + denominator = denominator * (denominatorAcc + pubInput); + + numeratorAcc = numeratorAcc + beta; + denominatorAcc = denominatorAcc - beta; + } - // Check the received proof is the expected size where each field element is 32 bytes - if (proof.length != expectedProofSize * 32) { - revert ProofLengthWrongWithLogN($LOG_N, proof.length, expectedProofSize * 32); - } + for (uint256 i = 0; i < PAIRING_POINTS_SIZE; i++) { + Fr pubInput = pairingPointObject[i]; - Honk.VerificationKey memory vk = loadVerificationKey(); - Honk.ZKProof memory p = ZKTranscriptLib.loadProof(proof, $LOG_N); + numerator = numerator * (numeratorAcc + pubInput); + denominator = denominator * (denominatorAcc + pubInput); - if (publicInputs.length != vk.publicInputsSize - PAIRING_POINTS_SIZE) { - revert PublicInputsLengthWrong(); - } + numeratorAcc = numeratorAcc + beta; + denominatorAcc = denominatorAcc - beta; + } + } - // Generate the fiat shamir challenges for the whole protocol - ZKTranscript memory t = - ZKTranscriptLib.generateTranscript(p, publicInputs, $VK_HASH, $NUM_PUBLIC_INPUTS, $LOG_N); + // Fr delta = numerator / denominator; // TOOO: batch invert later? + publicInputDelta = FrLib.div(numerator, denominator); + } - // Derive public input delta - t.relationParameters.publicInputsDelta = computePublicInputDelta( - publicInputs, - p.pairingPointObject, - t.relationParameters.beta, - t.relationParameters.gamma, /*pubInputsOffset=*/ - 1 - ); + function verifySumcheck(Honk.ZKProof memory proof, ZKTranscript memory tp) internal view returns (bool verified) { + Fr roundTargetSum = tp.libraChallenge * proof.libraSum; // default 0 + Fr powPartialEvaluation = Fr.wrap(1); - // Sumcheck - if (!verifySumcheck(p, t)) revert SumcheckFailed(); + // We perform sumcheck reductions over log n rounds ( the multivariate degree ) + for (uint256 round; round < $LOG_N; ++round) { + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory roundUnivariate = proof.sumcheckUnivariates[round]; + Fr totalSum = roundUnivariate[0] + roundUnivariate[1]; + if (totalSum != roundTargetSum) revert SumcheckFailed(); - if (!verifyShplemini(p, vk, t)) revert ShpleminiFailed(); + Fr roundChallenge = tp.sumCheckUChallenges[round]; - verified = true; + // Update the round target for the next rounf + roundTargetSum = computeNextTargetSum(roundUnivariate, roundChallenge); + powPartialEvaluation = powPartialEvaluation * (Fr.wrap(1) + roundChallenge * (tp.gateChallenges[round] - Fr.wrap(1))); } - uint256 constant PERMUTATION_ARGUMENT_VALUE_SEPARATOR = 1 << 28; + // Last round + Fr grandHonkRelationSum = RelationsLib.accumulateRelationEvaluations( + proof.sumcheckEvaluations, + tp.relationParameters, + tp.alphas, + powPartialEvaluation + ); + + Fr evaluation = Fr.wrap(1); + for (uint256 i = 2; i < $LOG_N; i++) { + evaluation = evaluation * tp.sumCheckUChallenges[i]; + } + + grandHonkRelationSum = grandHonkRelationSum * (Fr.wrap(1) - evaluation) + proof.libraEvaluation * tp.libraChallenge; + verified = (grandHonkRelationSum == roundTargetSum); + } + + // Return the new target sum for the next sumcheck round + function computeNextTargetSum( + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory roundUnivariates, + Fr roundChallenge + ) internal view returns (Fr targetSum) { + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory BARYCENTRIC_LAGRANGE_DENOMINATORS = [ + Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000009d80), + Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffec51), + Fr.wrap(0x00000000000000000000000000000000000000000000000000000000000005a0), + Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffd31), + Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000000240), + Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffd31), + Fr.wrap(0x00000000000000000000000000000000000000000000000000000000000005a0), + Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffec51), + Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000009d80) + ]; + + // To compute the next target sum, we evaluate the given univariate at a point u (challenge). + + // Performing Barycentric evaluations + // Compute B(x) + Fr numeratorValue = Fr.wrap(1); + for (uint256 i = 0; i < ZK_BATCHED_RELATION_PARTIAL_LENGTH; ++i) { + numeratorValue = numeratorValue * (roundChallenge - Fr.wrap(i)); + } + + Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory denominatorInverses; + for (uint256 i = 0; i < ZK_BATCHED_RELATION_PARTIAL_LENGTH; ++i) { + denominatorInverses[i] = FrLib.invert(BARYCENTRIC_LAGRANGE_DENOMINATORS[i] * (roundChallenge - Fr.wrap(i))); + } + + for (uint256 i = 0; i < ZK_BATCHED_RELATION_PARTIAL_LENGTH; ++i) { + targetSum = targetSum + roundUnivariates[i] * denominatorInverses[i]; + } + + // Scale the sum by the value of B(x) + targetSum = targetSum * numeratorValue; + } + + uint256 constant LIBRA_COMMITMENTS = 3; + uint256 constant LIBRA_EVALUATIONS = 4; + uint256 constant LIBRA_UNIVARIATES_LENGTH = 9; + + struct PairingInputs { + Honk.G1Point P_0; + Honk.G1Point P_1; + } + + function verifyShplemini( + Honk.ZKProof memory proof, + Honk.VerificationKey memory vk, + ZKTranscript memory tp + ) internal view returns (bool verified) { + CommitmentSchemeLib.ShpleminiIntermediates memory mem; // stack + + // - Compute vector (r, r², ... , r²⁽ⁿ⁻¹⁾), where n = log_circuit_size + Fr[] memory powers_of_evaluation_challenge = CommitmentSchemeLib.computeSquares(tp.geminiR, $LOG_N); + // Arrays hold values that will be linearly combined for the gemini and shplonk batch openings + Fr[] memory scalars = new Fr[](NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3); + Honk.G1Point[] memory commitments = new Honk.G1Point[](NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3); + + mem.posInvertedDenominator = (tp.shplonkZ - powers_of_evaluation_challenge[0]).invert(); + mem.negInvertedDenominator = (tp.shplonkZ + powers_of_evaluation_challenge[0]).invert(); + + mem.unshiftedScalar = mem.posInvertedDenominator + (tp.shplonkNu * mem.negInvertedDenominator); + mem.shiftedScalar = tp.geminiR.invert() * (mem.posInvertedDenominator - (tp.shplonkNu * mem.negInvertedDenominator)); + + scalars[0] = Fr.wrap(1); + commitments[0] = proof.shplonkQ; + + /* Batch multivariate opening claims, shifted and unshifted + * The vector of scalars is populated as follows: + * \f[ + * \left( + * - \left(\frac{1}{z-r} + \nu \times \frac{1}{z+r}\right), + * \ldots, + * - \rho^{i+k-1} \times \left(\frac{1}{z-r} + \nu \times \frac{1}{z+r}\right), + * - \rho^{i+k} \times \frac{1}{r} \times \left(\frac{1}{z-r} - \nu \times \frac{1}{z+r}\right), + * \ldots, + * - \rho^{k+m-1} \times \frac{1}{r} \times \left(\frac{1}{z-r} - \nu \times \frac{1}{z+r}\right) + * \right) + * \f] + * + * The following vector is concatenated to the vector of commitments: + * \f[ + * f_0, \ldots, f_{m-1}, f_{\text{shift}, 0}, \ldots, f_{\text{shift}, k-1} + * \f] + * + * Simultaneously, the evaluation of the multilinear polynomial + * \f[ + * \sum \rho^i \cdot f_i + \sum \rho^{i+k} \cdot f_{\text{shift}, i} + * \f] + * at the challenge point \f$ (u_0,\ldots, u_{n-1}) \f$ is computed. + * + * This approach minimizes the number of iterations over the commitments to multilinear polynomials + * and eliminates the need to store the powers of \f$ \rho \f$. + */ + mem.batchedEvaluation = proof.geminiMaskingEval; + mem.batchingChallenge = tp.rho; + mem.unshiftedScalarNeg = mem.unshiftedScalar.neg(); + mem.shiftedScalarNeg = mem.shiftedScalar.neg(); + + scalars[1] = mem.unshiftedScalarNeg; + for (uint256 i = 0; i < NUMBER_UNSHIFTED; ++i) { + scalars[i + 2] = mem.unshiftedScalarNeg * mem.batchingChallenge; + mem.batchedEvaluation = mem.batchedEvaluation + (proof.sumcheckEvaluations[i] * mem.batchingChallenge); + mem.batchingChallenge = mem.batchingChallenge * tp.rho; + } + // g commitments are accumulated at r + // For each of the to be shifted commitments perform the shift in place by + // adding to the unshifted value. + // We do so, as the values are to be used in batchMul later, and as + // `a * c + b * c = (a + b) * c` this will allow us to reduce memory and compute. + // Applied to w1, w2, w3, w4 and zPerm + for (uint256 i = 0; i < NUMBER_TO_BE_SHIFTED; ++i) { + uint256 scalarOff = i + SHIFTED_COMMITMENTS_START; + uint256 evaluationOff = i + NUMBER_UNSHIFTED; + + scalars[scalarOff] = scalars[scalarOff] + (mem.shiftedScalarNeg * mem.batchingChallenge); + mem.batchedEvaluation = mem.batchedEvaluation + (proof.sumcheckEvaluations[evaluationOff] * mem.batchingChallenge); + mem.batchingChallenge = mem.batchingChallenge * tp.rho; + } + + commitments[1] = proof.geminiMaskingPoly; + + commitments[2] = vk.qm; + commitments[3] = vk.qc; + commitments[4] = vk.ql; + commitments[5] = vk.qr; + commitments[6] = vk.qo; + commitments[7] = vk.q4; + commitments[8] = vk.qLookup; + commitments[9] = vk.qArith; + commitments[10] = vk.qDeltaRange; + commitments[11] = vk.qElliptic; + commitments[12] = vk.qMemory; + commitments[13] = vk.qNnf; + commitments[14] = vk.qPoseidon2External; + commitments[15] = vk.qPoseidon2Internal; + commitments[16] = vk.s1; + commitments[17] = vk.s2; + commitments[18] = vk.s3; + commitments[19] = vk.s4; + commitments[20] = vk.id1; + commitments[21] = vk.id2; + commitments[22] = vk.id3; + commitments[23] = vk.id4; + commitments[24] = vk.t1; + commitments[25] = vk.t2; + commitments[26] = vk.t3; + commitments[27] = vk.t4; + commitments[28] = vk.lagrangeFirst; + commitments[29] = vk.lagrangeLast; + + // Accumulate proof points + commitments[30] = proof.w1; + commitments[31] = proof.w2; + commitments[32] = proof.w3; + commitments[33] = proof.w4; + commitments[34] = proof.zPerm; + commitments[35] = proof.lookupInverses; + commitments[36] = proof.lookupReadCounts; + commitments[37] = proof.lookupReadTags; + + /* Batch gemini claims from the prover + * place the commitments to gemini aᵢ to the vector of commitments, compute the contributions from + * aᵢ(−r²ⁱ) for i=1, … , n−1 to the constant term accumulator, add corresponding scalars + * + * 1. Moves the vector + * \f[ + * \left( \text{com}(A_1), \text{com}(A_2), \ldots, \text{com}(A_{n-1}) \right) + * \f] + * to the 'commitments' vector. + * + * 2. Computes the scalars: + * \f[ + * \frac{\nu^{2}}{z + r^2}, \frac{\nu^3}{z + r^4}, \ldots, \frac{\nu^{n-1}}{z + r^{2^{n-1}}} + * \f] + * and places them into the 'scalars' vector. + * + * 3. Accumulates the summands of the constant term: + * \f[ + * \sum_{i=2}^{n-1} \frac{\nu^{i} \cdot A_i(-r^{2^i})}{z + r^{2^i}} + * \f] + * and adds them to the 'constant_term_accumulator'. + */ + + // Add contributions from A₀(r) and A₀(-r) to constant_term_accumulator: + // Compute the evaluations Aₗ(r^{2ˡ}) for l = 0, ..., $LOG_N - 1 + Fr[] memory foldPosEvaluations = CommitmentSchemeLib.computeFoldPosEvaluations( + tp.sumCheckUChallenges, + mem.batchedEvaluation, + proof.geminiAEvaluations, + powers_of_evaluation_challenge, + $LOG_N + ); - function computePublicInputDelta( - bytes32[] memory publicInputs, - Fr[PAIRING_POINTS_SIZE] memory pairingPointObject, - Fr beta, - Fr gamma, - uint256 offset - ) internal view returns (Fr publicInputDelta) { - Fr numerator = Fr.wrap(1); - Fr denominator = Fr.wrap(1); + mem.constantTermAccumulator = foldPosEvaluations[0] * mem.posInvertedDenominator; + mem.constantTermAccumulator = mem.constantTermAccumulator + (proof.geminiAEvaluations[0] * tp.shplonkNu * mem.negInvertedDenominator); - Fr numeratorAcc = gamma + (beta * FrLib.from(PERMUTATION_ARGUMENT_VALUE_SEPARATOR + offset)); - Fr denominatorAcc = gamma - (beta * FrLib.from(offset + 1)); + mem.batchingChallenge = tp.shplonkNu.sqr(); + uint256 boundary = NUMBER_UNSHIFTED + 2; - { - for (uint256 i = 0; i < $NUM_PUBLIC_INPUTS - PAIRING_POINTS_SIZE; i++) { - Fr pubInput = FrLib.fromBytes32(publicInputs[i]); + // Compute Shplonk constant term contributions from Aₗ(± r^{2ˡ}) for l = 1, ..., m-1; + // Compute scalar multipliers for each fold commitment + for (uint256 i = 0; i < $LOG_N - 1; ++i) { + bool dummy_round = i >= ($LOG_N - 1); - numerator = numerator * (numeratorAcc + pubInput); - denominator = denominator * (denominatorAcc + pubInput); + if (!dummy_round) { + // Update inverted denominators + mem.posInvertedDenominator = (tp.shplonkZ - powers_of_evaluation_challenge[i + 1]).invert(); + mem.negInvertedDenominator = (tp.shplonkZ + powers_of_evaluation_challenge[i + 1]).invert(); + + // Compute the scalar multipliers for Aₗ(± r^{2ˡ}) and [Aₗ] + mem.scalingFactorPos = mem.batchingChallenge * mem.posInvertedDenominator; + mem.scalingFactorNeg = mem.batchingChallenge * tp.shplonkNu * mem.negInvertedDenominator; + scalars[boundary + i] = mem.scalingFactorNeg.neg() + mem.scalingFactorPos.neg(); - numeratorAcc = numeratorAcc + beta; - denominatorAcc = denominatorAcc - beta; - } + // Accumulate the const term contribution given by + // v^{2l} * Aₗ(r^{2ˡ}) /(z-r^{2^l}) + v^{2l+1} * Aₗ(-r^{2ˡ}) /(z+ r^{2^l}) + Fr accumContribution = mem.scalingFactorNeg * proof.geminiAEvaluations[i + 1]; + accumContribution = accumContribution + mem.scalingFactorPos * foldPosEvaluations[i + 1]; + mem.constantTermAccumulator = mem.constantTermAccumulator + accumContribution; + } + // Update the running power of v + mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu * tp.shplonkNu; - for (uint256 i = 0; i < PAIRING_POINTS_SIZE; i++) { - Fr pubInput = pairingPointObject[i]; + commitments[boundary + i] = proof.geminiFoldComms[i]; + } - numerator = numerator * (numeratorAcc + pubInput); - denominator = denominator * (denominatorAcc + pubInput); + boundary += $LOG_N - 1; - numeratorAcc = numeratorAcc + beta; - denominatorAcc = denominatorAcc - beta; - } - } + // Finalize the batch opening claim + mem.denominators[0] = Fr.wrap(1).div(tp.shplonkZ - tp.geminiR); + mem.denominators[1] = Fr.wrap(1).div(tp.shplonkZ - SUBGROUP_GENERATOR * tp.geminiR); + mem.denominators[2] = mem.denominators[0]; + mem.denominators[3] = mem.denominators[0]; - // Fr delta = numerator / denominator; // TOOO: batch invert later? - publicInputDelta = FrLib.div(numerator, denominator); + mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu * tp.shplonkNu; + for (uint256 i = 0; i < LIBRA_EVALUATIONS; i++) { + Fr scalingFactor = mem.denominators[i] * mem.batchingChallenge; + mem.batchingScalars[i] = scalingFactor.neg(); + mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu; + mem.constantTermAccumulator = mem.constantTermAccumulator + scalingFactor * proof.libraPolyEvals[i]; } + scalars[boundary] = mem.batchingScalars[0]; + scalars[boundary + 1] = mem.batchingScalars[1] + mem.batchingScalars[2]; + scalars[boundary + 2] = mem.batchingScalars[3]; - function verifySumcheck(Honk.ZKProof memory proof, ZKTranscript memory tp) internal view returns (bool verified) { - Fr roundTargetSum = tp.libraChallenge * proof.libraSum; // default 0 - Fr powPartialEvaluation = Fr.wrap(1); + for (uint256 i = 0; i < LIBRA_COMMITMENTS; i++) { + commitments[boundary++] = proof.libraCommitments[i]; + } + + commitments[boundary] = Honk.G1Point({ x: 1, y: 2 }); + scalars[boundary++] = mem.constantTermAccumulator; - // We perform sumcheck reductions over log n rounds ( the multivariate degree ) - for (uint256 round; round < $LOG_N; ++round) { - Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory roundUnivariate = proof.sumcheckUnivariates[round]; - Fr totalSum = roundUnivariate[0] + roundUnivariate[1]; - if (totalSum != roundTargetSum) revert SumcheckFailed(); + if (!checkEvalsConsistency(proof.libraPolyEvals, tp.geminiR, tp.sumCheckUChallenges, proof.libraEvaluation)) { + revert ConsistencyCheckFailed(); + } - Fr roundChallenge = tp.sumCheckUChallenges[round]; + Honk.G1Point memory quotient_commitment = proof.kzgQuotient; - // Update the round target for the next rounf - roundTargetSum = computeNextTargetSum(roundUnivariate, roundChallenge); - powPartialEvaluation = - powPartialEvaluation * (Fr.wrap(1) + roundChallenge * (tp.gateChallenges[round] - Fr.wrap(1))); - } + commitments[boundary] = quotient_commitment; + scalars[boundary] = tp.shplonkZ; // evaluation challenge - // Last round - Fr grandHonkRelationSum = RelationsLib.accumulateRelationEvaluations( - proof.sumcheckEvaluations, tp.relationParameters, tp.alphas, powPartialEvaluation - ); + PairingInputs memory pair; + pair.P_0 = batchMul(commitments, scalars); + pair.P_1 = negateInplace(quotient_commitment); - Fr evaluation = Fr.wrap(1); - for (uint256 i = 2; i < $LOG_N; i++) { - evaluation = evaluation * tp.sumCheckUChallenges[i]; - } + // Aggregate pairing points + Fr recursionSeparator = generateRecursionSeparator(proof.pairingPointObject, pair.P_0, pair.P_1); + (Honk.G1Point memory P_0_other, Honk.G1Point memory P_1_other) = convertPairingPointsToG1(proof.pairingPointObject); - grandHonkRelationSum = - grandHonkRelationSum * (Fr.wrap(1) - evaluation) + proof.libraEvaluation * tp.libraChallenge; - verified = (grandHonkRelationSum == roundTargetSum); + // Validate the points from the proof are on the curve + validateOnCurve(P_0_other); + validateOnCurve(P_1_other); + + // accumulate with aggregate points in proof + pair.P_0 = mulWithSeperator(pair.P_0, P_0_other, recursionSeparator); + pair.P_1 = mulWithSeperator(pair.P_1, P_1_other, recursionSeparator); + + return pairing(pair.P_0, pair.P_1); + } + + struct SmallSubgroupIpaIntermediates { + Fr[SUBGROUP_SIZE] challengePolyLagrange; + Fr challengePolyEval; + Fr lagrangeFirst; + Fr lagrangeLast; + Fr rootPower; + Fr[SUBGROUP_SIZE] denominators; // this has to disappear + Fr diff; + } + + function checkEvalsConsistency( + Fr[LIBRA_EVALUATIONS] memory libraPolyEvals, + Fr geminiR, + Fr[CONST_PROOF_SIZE_LOG_N] memory uChallenges, + Fr libraEval + ) internal view returns (bool check) { + Fr one = Fr.wrap(1); + Fr vanishingPolyEval = geminiR.pow(SUBGROUP_SIZE) - one; + if (vanishingPolyEval == Fr.wrap(0)) { + revert GeminiChallengeInSubgroup(); } - // Return the new target sum for the next sumcheck round - function computeNextTargetSum(Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory roundUnivariates, Fr roundChallenge) - internal - view - returns (Fr targetSum) - { - Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory BARYCENTRIC_LAGRANGE_DENOMINATORS = [ - Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000009d80), - Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffec51), - Fr.wrap(0x00000000000000000000000000000000000000000000000000000000000005a0), - Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffd31), - Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000000240), - Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593effffd31), - Fr.wrap(0x00000000000000000000000000000000000000000000000000000000000005a0), - Fr.wrap(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593efffec51), - Fr.wrap(0x0000000000000000000000000000000000000000000000000000000000009d80) - ]; - - // To compute the next target sum, we evaluate the given univariate at a point u (challenge). - - // Performing Barycentric evaluations - // Compute B(x) - Fr numeratorValue = Fr.wrap(1); - for (uint256 i = 0; i < ZK_BATCHED_RELATION_PARTIAL_LENGTH; ++i) { - numeratorValue = numeratorValue * (roundChallenge - Fr.wrap(i)); - } - - Fr[ZK_BATCHED_RELATION_PARTIAL_LENGTH] memory denominatorInverses; - for (uint256 i = 0; i < ZK_BATCHED_RELATION_PARTIAL_LENGTH; ++i) { - denominatorInverses[i] = FrLib.invert(BARYCENTRIC_LAGRANGE_DENOMINATORS[i] * (roundChallenge - Fr.wrap(i))); - } - - for (uint256 i = 0; i < ZK_BATCHED_RELATION_PARTIAL_LENGTH; ++i) { - targetSum = targetSum + roundUnivariates[i] * denominatorInverses[i]; - } - - // Scale the sum by the value of B(x) - targetSum = targetSum * numeratorValue; - } - - uint256 constant LIBRA_COMMITMENTS = 3; - uint256 constant LIBRA_EVALUATIONS = 4; - uint256 constant LIBRA_UNIVARIATES_LENGTH = 9; - - struct PairingInputs { - Honk.G1Point P_0; - Honk.G1Point P_1; - } - - function verifyShplemini(Honk.ZKProof memory proof, Honk.VerificationKey memory vk, ZKTranscript memory tp) - internal - view - returns (bool verified) - { - CommitmentSchemeLib.ShpleminiIntermediates memory mem; // stack - - // - Compute vector (r, r², ... , r²⁽ⁿ⁻¹⁾), where n = log_circuit_size - Fr[] memory powers_of_evaluation_challenge = CommitmentSchemeLib.computeSquares(tp.geminiR, $LOG_N); - // Arrays hold values that will be linearly combined for the gemini and shplonk batch openings - Fr[] memory scalars = new Fr[](NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3); - Honk.G1Point[] memory commitments = new Honk.G1Point[](NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3); - - mem.posInvertedDenominator = (tp.shplonkZ - powers_of_evaluation_challenge[0]).invert(); - mem.negInvertedDenominator = (tp.shplonkZ + powers_of_evaluation_challenge[0]).invert(); - - mem.unshiftedScalar = mem.posInvertedDenominator + (tp.shplonkNu * mem.negInvertedDenominator); - mem.shiftedScalar = - tp.geminiR.invert() * (mem.posInvertedDenominator - (tp.shplonkNu * mem.negInvertedDenominator)); - - scalars[0] = Fr.wrap(1); - commitments[0] = proof.shplonkQ; - - /* Batch multivariate opening claims, shifted and unshifted - * The vector of scalars is populated as follows: - * \f[ - * \left( - * - \left(\frac{1}{z-r} + \nu \times \frac{1}{z+r}\right), - * \ldots, - * - \rho^{i+k-1} \times \left(\frac{1}{z-r} + \nu \times \frac{1}{z+r}\right), - * - \rho^{i+k} \times \frac{1}{r} \times \left(\frac{1}{z-r} - \nu \times \frac{1}{z+r}\right), - * \ldots, - * - \rho^{k+m-1} \times \frac{1}{r} \times \left(\frac{1}{z-r} - \nu \times \frac{1}{z+r}\right) - * \right) - * \f] - * - * The following vector is concatenated to the vector of commitments: - * \f[ - * f_0, \ldots, f_{m-1}, f_{\text{shift}, 0}, \ldots, f_{\text{shift}, k-1} - * \f] - * - * Simultaneously, the evaluation of the multilinear polynomial - * \f[ - * \sum \rho^i \cdot f_i + \sum \rho^{i+k} \cdot f_{\text{shift}, i} - * \f] - * at the challenge point \f$ (u_0,\ldots, u_{n-1}) \f$ is computed. - * - * This approach minimizes the number of iterations over the commitments to multilinear polynomials - * and eliminates the need to store the powers of \f$ \rho \f$. - */ - mem.batchedEvaluation = proof.geminiMaskingEval; - mem.batchingChallenge = tp.rho; - mem.unshiftedScalarNeg = mem.unshiftedScalar.neg(); - mem.shiftedScalarNeg = mem.shiftedScalar.neg(); - - scalars[1] = mem.unshiftedScalarNeg; - for (uint256 i = 0; i < NUMBER_UNSHIFTED; ++i) { - scalars[i + 2] = mem.unshiftedScalarNeg * mem.batchingChallenge; - mem.batchedEvaluation = mem.batchedEvaluation + (proof.sumcheckEvaluations[i] * mem.batchingChallenge); - mem.batchingChallenge = mem.batchingChallenge * tp.rho; - } - // g commitments are accumulated at r - // For each of the to be shifted commitments perform the shift in place by - // adding to the unshifted value. - // We do so, as the values are to be used in batchMul later, and as - // `a * c + b * c = (a + b) * c` this will allow us to reduce memory and compute. - // Applied to w1, w2, w3, w4 and zPerm - for (uint256 i = 0; i < NUMBER_TO_BE_SHIFTED; ++i) { - uint256 scalarOff = i + SHIFTED_COMMITMENTS_START; - uint256 evaluationOff = i + NUMBER_UNSHIFTED; - - scalars[scalarOff] = scalars[scalarOff] + (mem.shiftedScalarNeg * mem.batchingChallenge); - mem.batchedEvaluation = - mem.batchedEvaluation + (proof.sumcheckEvaluations[evaluationOff] * mem.batchingChallenge); - mem.batchingChallenge = mem.batchingChallenge * tp.rho; - } - - commitments[1] = proof.geminiMaskingPoly; - - commitments[2] = vk.qm; - commitments[3] = vk.qc; - commitments[4] = vk.ql; - commitments[5] = vk.qr; - commitments[6] = vk.qo; - commitments[7] = vk.q4; - commitments[8] = vk.qLookup; - commitments[9] = vk.qArith; - commitments[10] = vk.qDeltaRange; - commitments[11] = vk.qElliptic; - commitments[12] = vk.qMemory; - commitments[13] = vk.qNnf; - commitments[14] = vk.qPoseidon2External; - commitments[15] = vk.qPoseidon2Internal; - commitments[16] = vk.s1; - commitments[17] = vk.s2; - commitments[18] = vk.s3; - commitments[19] = vk.s4; - commitments[20] = vk.id1; - commitments[21] = vk.id2; - commitments[22] = vk.id3; - commitments[23] = vk.id4; - commitments[24] = vk.t1; - commitments[25] = vk.t2; - commitments[26] = vk.t3; - commitments[27] = vk.t4; - commitments[28] = vk.lagrangeFirst; - commitments[29] = vk.lagrangeLast; - - // Accumulate proof points - commitments[30] = proof.w1; - commitments[31] = proof.w2; - commitments[32] = proof.w3; - commitments[33] = proof.w4; - commitments[34] = proof.zPerm; - commitments[35] = proof.lookupInverses; - commitments[36] = proof.lookupReadCounts; - commitments[37] = proof.lookupReadTags; - - /* Batch gemini claims from the prover - * place the commitments to gemini aᵢ to the vector of commitments, compute the contributions from - * aᵢ(−r²ⁱ) for i=1, … , n−1 to the constant term accumulator, add corresponding scalars - * - * 1. Moves the vector - * \f[ - * \left( \text{com}(A_1), \text{com}(A_2), \ldots, \text{com}(A_{n-1}) \right) - * \f] - * to the 'commitments' vector. - * - * 2. Computes the scalars: - * \f[ - * \frac{\nu^{2}}{z + r^2}, \frac{\nu^3}{z + r^4}, \ldots, \frac{\nu^{n-1}}{z + r^{2^{n-1}}} - * \f] - * and places them into the 'scalars' vector. - * - * 3. Accumulates the summands of the constant term: - * \f[ - * \sum_{i=2}^{n-1} \frac{\nu^{i} \cdot A_i(-r^{2^i})}{z + r^{2^i}} - * \f] - * and adds them to the 'constant_term_accumulator'. - */ - - // Add contributions from A₀(r) and A₀(-r) to constant_term_accumulator: - // Compute the evaluations Aₗ(r^{2ˡ}) for l = 0, ..., $LOG_N - 1 - Fr[] memory foldPosEvaluations = CommitmentSchemeLib.computeFoldPosEvaluations( - tp.sumCheckUChallenges, - mem.batchedEvaluation, - proof.geminiAEvaluations, - powers_of_evaluation_challenge, - $LOG_N - ); - - mem.constantTermAccumulator = foldPosEvaluations[0] * mem.posInvertedDenominator; - mem.constantTermAccumulator = - mem.constantTermAccumulator + (proof.geminiAEvaluations[0] * tp.shplonkNu * mem.negInvertedDenominator); - - mem.batchingChallenge = tp.shplonkNu.sqr(); - uint256 boundary = NUMBER_UNSHIFTED + 2; - - // Compute Shplonk constant term contributions from Aₗ(± r^{2ˡ}) for l = 1, ..., m-1; - // Compute scalar multipliers for each fold commitment - for (uint256 i = 0; i < $LOG_N - 1; ++i) { - bool dummy_round = i >= ($LOG_N - 1); - - if (!dummy_round) { - // Update inverted denominators - mem.posInvertedDenominator = (tp.shplonkZ - powers_of_evaluation_challenge[i + 1]).invert(); - mem.negInvertedDenominator = (tp.shplonkZ + powers_of_evaluation_challenge[i + 1]).invert(); - - // Compute the scalar multipliers for Aₗ(± r^{2ˡ}) and [Aₗ] - mem.scalingFactorPos = mem.batchingChallenge * mem.posInvertedDenominator; - mem.scalingFactorNeg = mem.batchingChallenge * tp.shplonkNu * mem.negInvertedDenominator; - scalars[boundary + i] = mem.scalingFactorNeg.neg() + mem.scalingFactorPos.neg(); - - // Accumulate the const term contribution given by - // v^{2l} * Aₗ(r^{2ˡ}) /(z-r^{2^l}) + v^{2l+1} * Aₗ(-r^{2ˡ}) /(z+ r^{2^l}) - Fr accumContribution = mem.scalingFactorNeg * proof.geminiAEvaluations[i + 1]; - accumContribution = accumContribution + mem.scalingFactorPos * foldPosEvaluations[i + 1]; - mem.constantTermAccumulator = mem.constantTermAccumulator + accumContribution; - } - // Update the running power of v - mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu * tp.shplonkNu; - - commitments[boundary + i] = proof.geminiFoldComms[i]; - } - - boundary += $LOG_N - 1; - - // Finalize the batch opening claim - mem.denominators[0] = Fr.wrap(1).div(tp.shplonkZ - tp.geminiR); - mem.denominators[1] = Fr.wrap(1).div(tp.shplonkZ - SUBGROUP_GENERATOR * tp.geminiR); - mem.denominators[2] = mem.denominators[0]; - mem.denominators[3] = mem.denominators[0]; - - mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu * tp.shplonkNu; - for (uint256 i = 0; i < LIBRA_EVALUATIONS; i++) { - Fr scalingFactor = mem.denominators[i] * mem.batchingChallenge; - mem.batchingScalars[i] = scalingFactor.neg(); - mem.batchingChallenge = mem.batchingChallenge * tp.shplonkNu; - mem.constantTermAccumulator = mem.constantTermAccumulator + scalingFactor * proof.libraPolyEvals[i]; - } - scalars[boundary] = mem.batchingScalars[0]; - scalars[boundary + 1] = mem.batchingScalars[1] + mem.batchingScalars[2]; - scalars[boundary + 2] = mem.batchingScalars[3]; - - for (uint256 i = 0; i < LIBRA_COMMITMENTS; i++) { - commitments[boundary++] = proof.libraCommitments[i]; - } - - commitments[boundary] = Honk.G1Point({x: 1, y: 2}); - scalars[boundary++] = mem.constantTermAccumulator; - - if (!checkEvalsConsistency(proof.libraPolyEvals, tp.geminiR, tp.sumCheckUChallenges, proof.libraEvaluation)) { - revert ConsistencyCheckFailed(); - } - - Honk.G1Point memory quotient_commitment = proof.kzgQuotient; - - commitments[boundary] = quotient_commitment; - scalars[boundary] = tp.shplonkZ; // evaluation challenge - - PairingInputs memory pair; - pair.P_0 = batchMul(commitments, scalars); - pair.P_1 = negateInplace(quotient_commitment); - - // Aggregate pairing points - Fr recursionSeparator = generateRecursionSeparator(proof.pairingPointObject, pair.P_0, pair.P_1); - (Honk.G1Point memory P_0_other, Honk.G1Point memory P_1_other) = - convertPairingPointsToG1(proof.pairingPointObject); - - // Validate the points from the proof are on the curve - validateOnCurve(P_0_other); - validateOnCurve(P_1_other); - - // accumulate with aggregate points in proof - pair.P_0 = mulWithSeperator(pair.P_0, P_0_other, recursionSeparator); - pair.P_1 = mulWithSeperator(pair.P_1, P_1_other, recursionSeparator); - - return pairing(pair.P_0, pair.P_1); - } - - struct SmallSubgroupIpaIntermediates { - Fr[SUBGROUP_SIZE] challengePolyLagrange; - Fr challengePolyEval; - Fr lagrangeFirst; - Fr lagrangeLast; - Fr rootPower; - Fr[SUBGROUP_SIZE] denominators; // this has to disappear - Fr diff; - } - - function checkEvalsConsistency( - Fr[LIBRA_EVALUATIONS] memory libraPolyEvals, - Fr geminiR, - Fr[CONST_PROOF_SIZE_LOG_N] memory uChallenges, - Fr libraEval - ) internal view returns (bool check) { - Fr one = Fr.wrap(1); - Fr vanishingPolyEval = geminiR.pow(SUBGROUP_SIZE) - one; - if (vanishingPolyEval == Fr.wrap(0)) { - revert GeminiChallengeInSubgroup(); - } - - SmallSubgroupIpaIntermediates memory mem; - mem.challengePolyLagrange[0] = one; - for (uint256 round = 0; round < $LOG_N; round++) { - uint256 currIdx = 1 + LIBRA_UNIVARIATES_LENGTH * round; - mem.challengePolyLagrange[currIdx] = one; - for (uint256 idx = currIdx + 1; idx < currIdx + LIBRA_UNIVARIATES_LENGTH; idx++) { - mem.challengePolyLagrange[idx] = mem.challengePolyLagrange[idx - 1] * uChallenges[round]; - } - } - - mem.rootPower = one; - mem.challengePolyEval = Fr.wrap(0); - for (uint256 idx = 0; idx < SUBGROUP_SIZE; idx++) { - mem.denominators[idx] = mem.rootPower * geminiR - one; - mem.denominators[idx] = mem.denominators[idx].invert(); - mem.challengePolyEval = mem.challengePolyEval + mem.challengePolyLagrange[idx] * mem.denominators[idx]; - mem.rootPower = mem.rootPower * SUBGROUP_GENERATOR_INVERSE; - } - - Fr numerator = vanishingPolyEval * Fr.wrap(SUBGROUP_SIZE).invert(); - mem.challengePolyEval = mem.challengePolyEval * numerator; - mem.lagrangeFirst = mem.denominators[0] * numerator; - mem.lagrangeLast = mem.denominators[SUBGROUP_SIZE - 1] * numerator; - - mem.diff = mem.lagrangeFirst * libraPolyEvals[2]; - - mem.diff = mem.diff - + (geminiR - SUBGROUP_GENERATOR_INVERSE) - * (libraPolyEvals[1] - libraPolyEvals[2] - libraPolyEvals[0] * mem.challengePolyEval); - mem.diff = mem.diff + mem.lagrangeLast * (libraPolyEvals[2] - libraEval) - vanishingPolyEval * libraPolyEvals[3]; - - check = mem.diff == Fr.wrap(0); - } - - // This implementation is the same as above with different constants - function batchMul(Honk.G1Point[] memory base, Fr[] memory scalars) - internal - view - returns (Honk.G1Point memory result) - { - uint256 limit = NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3; + SmallSubgroupIpaIntermediates memory mem; + mem.challengePolyLagrange[0] = one; + for (uint256 round = 0; round < $LOG_N; round++) { + uint256 currIdx = 1 + LIBRA_UNIVARIATES_LENGTH * round; + mem.challengePolyLagrange[currIdx] = one; + for (uint256 idx = currIdx + 1; idx < currIdx + LIBRA_UNIVARIATES_LENGTH; idx++) { + mem.challengePolyLagrange[idx] = mem.challengePolyLagrange[idx - 1] * uChallenges[round]; + } + } + + mem.rootPower = one; + mem.challengePolyEval = Fr.wrap(0); + for (uint256 idx = 0; idx < SUBGROUP_SIZE; idx++) { + mem.denominators[idx] = mem.rootPower * geminiR - one; + mem.denominators[idx] = mem.denominators[idx].invert(); + mem.challengePolyEval = mem.challengePolyEval + mem.challengePolyLagrange[idx] * mem.denominators[idx]; + mem.rootPower = mem.rootPower * SUBGROUP_GENERATOR_INVERSE; + } + + Fr numerator = vanishingPolyEval * Fr.wrap(SUBGROUP_SIZE).invert(); + mem.challengePolyEval = mem.challengePolyEval * numerator; + mem.lagrangeFirst = mem.denominators[0] * numerator; + mem.lagrangeLast = mem.denominators[SUBGROUP_SIZE - 1] * numerator; + + mem.diff = mem.lagrangeFirst * libraPolyEvals[2]; - // Validate all points are on the curve - for (uint256 i = 0; i < limit; ++i) { - validateOnCurve(base[i]); - } + mem.diff = + mem.diff + + (geminiR - SUBGROUP_GENERATOR_INVERSE) * + (libraPolyEvals[1] - libraPolyEvals[2] - libraPolyEvals[0] * mem.challengePolyEval); + mem.diff = mem.diff + mem.lagrangeLast * (libraPolyEvals[2] - libraEval) - vanishingPolyEval * libraPolyEvals[3]; - bool success = true; - assembly { - let free := mload(0x40) + check = mem.diff == Fr.wrap(0); + } - let count := 0x01 - for {} lt(count, add(limit, 1)) { count := add(count, 1) } { - // Get loop offsets - let base_base := add(base, mul(count, 0x20)) - let scalar_base := add(scalars, mul(count, 0x20)) + // This implementation is the same as above with different constants + function batchMul(Honk.G1Point[] memory base, Fr[] memory scalars) internal view returns (Honk.G1Point memory result) { + uint256 limit = NUMBER_UNSHIFTED + $LOG_N + LIBRA_COMMITMENTS + 3; - mstore(add(free, 0x40), mload(mload(base_base))) - mstore(add(free, 0x60), mload(add(0x20, mload(base_base)))) - // Add scalar - mstore(add(free, 0x80), mload(scalar_base)) + // Validate all points are on the curve + for (uint256 i = 0; i < limit; ++i) { + validateOnCurve(base[i]); + } + + bool success = true; + assembly { + let free := mload(0x40) - success := and(success, staticcall(gas(), 7, add(free, 0x40), 0x60, add(free, 0x40), 0x40)) - // accumulator = accumulator + accumulator_2 - success := and(success, staticcall(gas(), 6, free, 0x80, free, 0x40)) - } + let count := 0x01 + for {} lt(count, add(limit, 1)) { + count := add(count, 1) + } { + // Get loop offsets + let base_base := add(base, mul(count, 0x20)) + let scalar_base := add(scalars, mul(count, 0x20)) - // Return the result - mstore(result, mload(free)) - mstore(add(result, 0x20), mload(add(free, 0x20))) - } + mstore(add(free, 0x40), mload(mload(base_base))) + mstore(add(free, 0x60), mload(add(0x20, mload(base_base)))) + // Add scalar + mstore(add(free, 0x80), mload(scalar_base)) - require(success, ShpleminiFailed()); + success := and(success, staticcall(gas(), 7, add(free, 0x40), 0x60, add(free, 0x40), 0x40)) + // accumulator = accumulator + accumulator_2 + success := and(success, staticcall(gas(), 6, free, 0x80, free, 0x40)) + } + + // Return the result + mstore(result, mload(free)) + mstore(add(result, 0x20), mload(add(free, 0x20))) } + + require(success, ShpleminiFailed()); + } } contract HonkVerifier is BaseZKHonkVerifier(N, LOG_N, VK_HASH, NUMBER_OF_PUBLIC_INPUTS) { - function loadVerificationKey() internal pure override returns (Honk.VerificationKey memory) { - return HonkVerificationKey.loadVerificationKey(); - } + function loadVerificationKey() internal pure override returns (Honk.VerificationKey memory) { + return HonkVerificationKey.loadVerificationKey(); + } } diff --git a/examples/CRISP/server/Dockerfile b/examples/CRISP/server/Dockerfile index c2de767e99..3b742fce13 100644 --- a/examples/CRISP/server/Dockerfile +++ b/examples/CRISP/server/Dockerfile @@ -60,7 +60,6 @@ COPY Cargo.toml ./Cargo.toml # find crates/* -name "Cargo.toml" -not -path "*/support/*" -printf "COPY %p %p\n" COPY crates/aggregator/Cargo.toml crates/aggregator/Cargo.toml COPY crates/bfv-client/Cargo.toml crates/bfv-client/Cargo.toml -COPY crates/greco-helpers/Cargo.toml crates/greco-helpers/Cargo.toml COPY crates/ciphernode-builder/Cargo.toml crates/ciphernode-builder/Cargo.toml COPY crates/cli/Cargo.toml crates/cli/Cargo.toml COPY crates/compute-provider/Cargo.toml crates/compute-provider/Cargo.toml diff --git a/packages/enclave-sdk/src/enclave-sdk.ts b/packages/enclave-sdk/src/enclave-sdk.ts index 6378395cfd..6e831f12a2 100644 --- a/packages/enclave-sdk/src/enclave-sdk.ts +++ b/packages/enclave-sdk/src/enclave-sdk.ts @@ -28,6 +28,7 @@ import type { import { bfv_encrypt_number, bfv_encrypt_vector, + generate_public_key, bfv_verifiable_encrypt_number, bfv_verifiable_encrypt_vector, compute_pk_commitment, @@ -119,6 +120,12 @@ export class EnclaveSDK { } } + public async generatePublicKey(): Promise { + await initializeWasm() + const protocolParams = await this.getThresholdBfvParamsSet() + return generate_public_key(protocolParams.degree, protocolParams.plaintextModulus, BigUint64Array.from(protocolParams.moduli)) + } + public async computePublicKeyCommitment(publicKey: Uint8Array): Promise { await initializeWasm() const protocolParams = await this.getThresholdBfvParamsSet() @@ -188,10 +195,9 @@ export class EnclaveSDK { BigUint64Array.from(protocolParams.moduli), ) - const publicInputs = JSON.parse(circuitInputs) return { encryptedData, - publicInputs, + circuitInputs: JSON.parse(circuitInputs), } } @@ -207,7 +213,7 @@ export class EnclaveSDK { publicKey: Uint8Array, circuit: CompiledCircuit, ): Promise { - const { publicInputs, encryptedData } = await this.encryptNumberAndGenInputs(data, publicKey) + const { circuitInputs: publicInputs, encryptedData } = await this.encryptNumberAndGenInputs(data, publicKey) const proof = await generateProof(publicInputs, circuit) return { @@ -234,10 +240,9 @@ export class EnclaveSDK { BigUint64Array.from(protocolParams.moduli), ) - const publicInputs = JSON.parse(circuitInputs) return { encryptedData, - publicInputs, + circuitInputs: JSON.parse(circuitInputs), } } @@ -253,7 +258,7 @@ export class EnclaveSDK { publicKey: Uint8Array, circuit: CompiledCircuit, ): Promise { - const { publicInputs, encryptedData } = await this.encryptVectorAndGenInputs(data, publicKey) + const { circuitInputs: publicInputs, encryptedData } = await this.encryptVectorAndGenInputs(data, publicKey) const proof = await generateProof(publicInputs, circuit) diff --git a/packages/enclave-sdk/src/greco.ts b/packages/enclave-sdk/src/greco.ts index 78824a53c5..92ac57aba5 100644 --- a/packages/enclave-sdk/src/greco.ts +++ b/packages/enclave-sdk/src/greco.ts @@ -29,87 +29,13 @@ export interface CircuitInputs { e0: string[] e1: string[] e0is: string[][] + e0_quotients: string[][] k1: string[] r1is: string[][] r2is: string[][] p1is: string[][] p2is: string[][] -} - -/** - * BfvPkEncryption params for Greco -pub struct Params { - crypto: CryptographicParams, - bounds: BoundParams, -} - */ -export interface BoundParams { - pk_bounds: Field[] - e0_bound: Field - e1_bound: Field - u_bound: Field - r1_low_bounds: Field[] - r1_up_bounds: Field[] - r2_bounds: Field[] - p1_bounds: Field[] - p2_bounds: Field[] - k1_low_bound: Field - k1_up_bound: Field -} - -export interface CryptographicParams { - q_mod_t: Field - qis: Field[] - k0is: Field[] -} - -export interface Params { - bounds: BoundParams - crypto: CryptographicParams -} - -/** - * Default greco params for BFV pk encryption. - */ -export const defaultParams: Params = { - bounds: { - pk_bounds: ['34359701504', '34359615488'], - e0_bound: '20', - e1_bound: '20', - u_bound: '1', - r1_low_bounds: ['261', '258'], - r1_up_bounds: ['260', '258'], - r2_bounds: ['34359701504', '34359615488'], - p1_bounds: ['256', '256'], - p2_bounds: ['34359701504', '34359615488'], - k1_low_bound: '5', - k1_up_bound: '4', - }, - crypto: { - q_mod_t: '3', - qis: ['68719403009', '68719230977'], - k0is: ['61847462708', '20615769293'], - }, -} - -/** - * Convert a string array to a polynomial - * @param stringArray - The string array - * @returns The polynomial - */ -export const convertToPolynomial = (stringArray: string[]): Polynomial => { - return { - coefficients: stringArray, - } -} - -/** - * Convert an array of string arrays to an array of polynomials - * @param stringArrays - The array of string arrays - * @returns The array of polynomials - */ -export const convertToPolynomialArray = (stringArrays: string[][]): Polynomial[] => { - return stringArrays.map(convertToPolynomial) + pk_commitment: string } /** @@ -124,36 +50,7 @@ export const generateProof = async (circuitInputs: CircuitInputs, circuit: Compi const backend = new UltraHonkBackend(circuit.bytecode, { threads: 4 }) - const pk0is_poly = convertToPolynomialArray(circuitInputs.pk0is) - const pk1is_poly = convertToPolynomialArray(circuitInputs.pk1is) - const ct0is_poly = convertToPolynomialArray(circuitInputs.ct0is) - const ct1is_poly = convertToPolynomialArray(circuitInputs.ct1is) - const u_poly = convertToPolynomial(circuitInputs.u) - const e0_poly = convertToPolynomial(circuitInputs.e0) - const e1_poly = convertToPolynomial(circuitInputs.e1) - const e0is_poly = convertToPolynomialArray(circuitInputs.e0is) - const k1_poly = convertToPolynomial(circuitInputs.k1) - const r1is_poly = convertToPolynomialArray(circuitInputs.r1is) - const r2is_poly = convertToPolynomialArray(circuitInputs.r2is) - const p1is_poly = convertToPolynomialArray(circuitInputs.p1is) - const p2is_poly = convertToPolynomialArray(circuitInputs.p2is) - - const { witness } = await noir.execute({ - params: defaultParams as any, - pk0is: pk0is_poly, - pk1is: pk1is_poly, - ct0is: ct0is_poly, - ct1is: ct1is_poly, - u: u_poly, - e0: e0_poly, - e1: e1_poly, - e0is: e0is_poly, - k1: k1_poly, - r1is: r1is_poly, - r2is: r2is_poly, - p1is: p1is_poly, - p2is: p2is_poly, - }) + const { witness } = await noir.execute(circuitInputs as any) return await backend.generateProof(witness, { keccakZK: true }) } diff --git a/packages/enclave-sdk/src/index.ts b/packages/enclave-sdk/src/index.ts index 769445a417..16a779995a 100644 --- a/packages/enclave-sdk/src/index.ts +++ b/packages/enclave-sdk/src/index.ts @@ -65,4 +65,4 @@ export { type ComputeProviderParams, } from './utils' -export { generateProof, type Polynomial, convertToPolynomial, convertToPolynomialArray } from './greco' +export { generateProof, type Polynomial } from './greco' diff --git a/packages/enclave-sdk/src/types.ts b/packages/enclave-sdk/src/types.ts index bd0567875b..3ad921b262 100644 --- a/packages/enclave-sdk/src/types.ts +++ b/packages/enclave-sdk/src/types.ts @@ -302,5 +302,5 @@ export interface EncryptedValueAndPublicInputs { /** * The public inputs for the proof */ - publicInputs: CircuitInputs + circuitInputs: CircuitInputs } diff --git a/packages/enclave-sdk/tests/fixtures/demo_circuit.json b/packages/enclave-sdk/tests/fixtures/demo_circuit.json index 71277e67ac..81f38dd397 100644 --- a/packages/enclave-sdk/tests/fixtures/demo_circuit.json +++ b/packages/enclave-sdk/tests/fixtures/demo_circuit.json @@ -1,241 +1 @@ -{ - "noir_version": "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", - "hash": "461356624656076677", - "abi": { - "parameters": [ - { - "name": "params", - "type": { - "kind": "struct", - "path": "greco::Params", - "fields": [ - { - "name": "crypto", - "type": { - "kind": "struct", - "path": "greco::CryptographicParams", - "fields": [ - { "name": "q_mod_t", "type": { "kind": "field" } }, - { "name": "qis", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } }, - { "name": "k0is", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } } - ] - } - }, - { - "name": "bounds", - "type": { - "kind": "struct", - "path": "greco::BoundParams", - "fields": [ - { "name": "pk_bounds", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } }, - { "name": "e0_bound", "type": { "kind": "field" } }, - { "name": "e1_bound", "type": { "kind": "field" } }, - { "name": "u_bound", "type": { "kind": "field" } }, - { "name": "r1_low_bounds", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } }, - { "name": "r1_up_bounds", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } }, - { "name": "r2_bounds", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } }, - { "name": "p1_bounds", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } }, - { "name": "p2_bounds", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } }, - { "name": "k1_low_bound", "type": { "kind": "field" } }, - { "name": "k1_up_bound", "type": { "kind": "field" } } - ] - } - } - ] - }, - "visibility": "public" - }, - { - "name": "pk0is", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - } - }, - "visibility": "public" - }, - { - "name": "pk1is", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - } - }, - "visibility": "public" - }, - { - "name": "ct0is", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - } - }, - "visibility": "public" - }, - { - "name": "ct1is", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - } - }, - "visibility": "public" - }, - { - "name": "u", - "type": { - "kind": "struct", - "path": "polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - }, - "visibility": "private" - }, - { - "name": "e0", - "type": { - "kind": "struct", - "path": "polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - }, - "visibility": "private" - }, - { - "name": "e1", - "type": { - "kind": "struct", - "path": "polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - }, - "visibility": "private" - }, - { - "name": "e0is", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - } - }, - "visibility": "private" - }, - { - "name": "k1", - "type": { - "kind": "struct", - "path": "polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 512, "type": { "kind": "field" } } }] - }, - "visibility": "private" - }, - { - "name": "r1is", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 1023, "type": { "kind": "field" } } }] - } - }, - "visibility": "private" - }, - { - "name": "r2is", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 511, "type": { "kind": "field" } } }] - } - }, - "visibility": "private" - }, - { - "name": "p1is", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 1023, "type": { "kind": "field" } } }] - } - }, - "visibility": "private" - }, - { - "name": "p2is", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "polynomial::Polynomial", - "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 511, "type": { "kind": "field" } } }] - } - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "11019205087382408538": { "error_kind": "string", "string": "Field failed to decompose into specified 4 limbs" }, - "12469291177396340830": { "error_kind": "string", "string": "call to assert_max_bit_size" } - } - }, - "bytecode": "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", - "debug_symbols": "vN3Rjl1bcp3pd6lrXayYI2LGDL9Ko2HItmwIEGRDtvvG8Ls3D3PNf1AymMUieXzTZ7uStbXjZP6DZO4vq//XX/7TP/yH//lf/v0//vN//q///S//7v/5X3/5D//yj//0T//4X/79P/3X//j3/+Mf/+s/f/lP/9f//ru/3P/nv/8f//IP//DlP/rLNx//8t/6b3//L//wz//jL//un//nP/3T3/3l//v7f/qfX3/Rf/9vf//PX//5P/7+X7589Pm7v/zDP/+nL//88oT/+R//6R/+ePS//87/7ef7/9WQ5v1vhyp4glr/6hnik2dY0r5PsVTj59j/6jnWZ6/iKfEynv7uc+j7z5E7+n2K3Ln8DP3Dz9Dr/rvIzvnVZ9j6qWfoc5/hRH/vGfr7z1B9/03u8BdEnB9+BSeLV9D9MzecTJ5hzveeIZ5fPOLTL6jIxRdU7O9+QcX65a+oT5/ix76kfvgpvv819flT/NAXVexf/IR8+hp+7MvqrzzFD31dzZ/5dfVl4fi6Wnt9d+zil7+uPn2KH/u6+uGn+P7X1edP8UNfV6t+9RMSv/x19Vee4ke+rtb5M7+utA5fV6r67m+Az6//Dvj8+m+Bz6//Hvj88teV8ld/F3x+/bfB55e/rtR/5tdVdfvPd/P81B/Otvy1ub/9lO6fex3f3vJvniN/fTfz13czf30389d3M391N/PXdzN/fTfzT93N/ub3487zU1+b/+o59nefo379C6t+/Qurfv0Lq351OOvXv7Dq17+w6k8dzin/BWJ2/swXVj7Bc+STz889Rx0/x+mf+gL/V7ec796yf/0vQ/vX/zK0f/0vQ/vX/zK0f/UvQ/vX/zK0f/0vQ/vP/MtQRvCdn4z1U+Ob0X6O9cTPPce3r+P7vwn0r3/7qH/9+0f9699A6t/wHaRfHc/+9e8h9a9/E+n8md9Eyi9/K+PrSvlzvwdo/BwZ/XPP8e3r+P7vRSd/+ev706f4sa/vH36K7399f/4UP/T1fX71T52fvoYf+/r+K0/xI1/fE3/m1/eX/8t8XdVPbm/lN8/RP9fIv3od67uvY+qXv74/fYof+/r+4af4/tf350/xQ1/f86u/sX/6Gn7s6/uvPMWPvQmwfvWbzp+9NZXfvDWV339rKp5PSo16Dm9O1TP1/Wf55N/Hl0Pzvk/35fHR95/lkz95fvmaul9fvT/5LvrTn74SUvnyeNXPPsuz/Cyh3/Esa//ks6j5G/yj81ueZT656NPPs765SPn9r5bQr3+eI3/H5/mvPMsPfp7/hmf55PP8+bP86Of5b3iWn/887+RZ8unvv8P4fPZ5rs3n+bM3955f/1pZn/0W/ET5ayXO+sln+dGvuL/yLD/4Ffc3PMsnX3GfP8uPfsX9Dc/y019xuba/4j57T3t+w1fc/PpXnOJ3fMV9/iw/+hX3V57lB7/i/oZn+eQr7vNn+dGvuL/hWX76K67Kz1Lz/Y3T+Q1fLfNbPs/zWz7P81s+z/NbPs/z53+et7+B9uz67jfQ4rO3pH7085z7d3ye/8qz/ODn+W94lk8+z58/y49+nv+GZ/n5z7PfhX36+9+Milq//nku/Y7P8195lh/8PP8Nz/LJ5/nzZ/nRz/Pf8Cw//Xlu/7336f7k8/wbfpffz+/4PP+VZ/nBz/Pf8CyffJ4/f5Yf/Tz/Dc/y05/n4zcHn3m++wZj7N/wPYX9W76nsH/L9xT2b/mewv4t31PY/xe+pzAx/jzv736DNPo3fE+hf8v3FPq3fE+hf8v3FPq3fE+h/y98T2EO3yP846Tvfp7Pb/h+wPktf686v+XvVee3/L3q/Ja/V50//+9VX/76Hv48f/K94NO/4fN8fsvn+fyWz/P5LZ/n81s+z+e3fJ4/fefgJP9268x33xyL+eydwlW8k7K+efdh/9vn+Owr7st/0Ybz+eZPCv/Hs3z2t5BY/rL95q2+1r95jv7sfSEsUp7zyXN8+joOn5xV/f3n+OxvzvPlL7r3SebLb7A/+Swtvgs8X76h9lPPsp6HN/i/PJ7vXrQ+e7fsyx/yFq9l71Pff5ZP/pQwp+5vQXN2/+Q9X7N47wnl91/JZ1+zvXkz9cvjXT/5LF1+lt79O56l908/y/GznPn+s3z27u7iDwm1Zn/3jf/Pfr5q97pfcPtbNftvn+Pza076mvPNd43+j6+Vz55FwTekvzzu83P7ppB9+ZdvX/yOZ/nmxxD33/R+8fDV/+XxJ+Tnsx+42hEPb37nd/+tfPocf/yWc79Svszd95/jk98J58v3ie4eRHzyHJ98xWbu+xyZ31iAmL/l38e+n5r95cvyp/59/KvnWM/P/Tud9L/TrJ/9CnE5NZ/8FNn65Fm6+Lfa1fruNZ/9+NWPfnbX/vXP7qe3eBi7v/n979/+W/3sTzjln1JZ9f2/I6/P3tmKXfPN76HfNPNvn+WzH/zpr39X/Ljmy1/Vvruuf8MrWesn79nmWfvLQd+/55M/E2hBkrTO939A7kefQxHffY6/cs3wZ7bd33/PfWn/hmv2n31N+2eUd9f36dxn7wD98DXzJ1/Tj/vrp75fTq5fv+ZHn+MXrhn+VNIR3/+Zt8/eEfvha+rPvib8P6/wZZy+vwKf/azWD19z/uxrVvDX0C9/jtXPLeO/eZbv//DCZ++F6et3Ed5/J8/3/53Ub/ia//w5Jn7k32v96d3om7+z6ZMV+GvP4i1R/+xnOA/72vX89LPs8zue5Zu/P9aTP/ks9c0q7fjZf7t14nc8Sz+/4Vn68TJ9+bT/5LNs/5DFLzzL8d/b+nzyJ67P3vH50Zp/9Dl+usQvx/D5Oc/3Tcfq59ev+dHn+IVrhn5OfPLV1r/hz7H9Z/859nxj30588kMT/Rv+HNt/9p9jz/L3yo+en6zvy7Okn+WT75p8/izpb1GfrPjZZwn9hmcp/y52aufPPovfofmFZ9kWIWd/8neN8xv+PHv+7D/PnvbfA8/52b8bn979G57l+M8H53z/p0P+2rN8s9Y//yz9TYk9v+Pfy88/yzffHf7y7+i3/Hv5/rN8+j9x53N0/vX/xN3/++X/9ff/8R//5V/9z/L95fnLv/vy0uPr/3f98XbT3/1FH//Ir/9Zff3/7o//qD/+cb7+Z/Px33w+/rOI95/r4z/Wxz/y/U/r/ef++I/74x/n/U/n45/r48Ws99W8L2e9r2d9vKD18YrW+5LW+5rWx4taH69K76vS+6r08ar08ar0viq9r0ofr0ofr0rvq9L7qvLjVeXHq8r3VeX9t/TxqvLjVeX7qvJ9VfnxqvLjVdX7qup9VfXxqurjVdX7qup9VfXxqurjVdX7qup9VfvjVe2PV7XfV7XfV7U/XtV+P3vvq9rvq9ofr2p/vKp+X1W/r6o/XlV/vKp+X1W/r6o/XlV/vKp+X1W/r+p8vKrz8arO+6rO+6rOx6s6H6/qvK/q3K+qj1d1Pl7VvK9q3lc1H69qPl7VvK9q3lc1H69qPl7VvK9q3lcVz/tV/sT7z3U/oPsg34/U+899P9D3wXk/8n7d+wv/fuXfL/37tc8XP1/998v/fv0TwC0g3gTibSBuBHEriDeDeDuIG0LcEuJNId4W4sYQt4bQjfR9pTeIuEXEm0S8TcSNIm4V8WYRbxdxw4hbRrxpxNtG3Dji1hFvHvH2ETeQuIXEm0i8jUQxKPeVvpnE20ncUOKWEm8q8bYSN5a4tcSbS7y9xA0mbjHxJhNvM3GjiVtNvNnE203ccOKWE33H732lN5649cSbT7z9xA0obkHxJhRvQ3EjiltRvBnF21HckOKWFG9K8bYUN6a4NcWbU7w9xTDULPU71W9R6xa1blHrLWq9Ra1b1LpFrbeo9Ra1blHrFrXeotZb1LpFrVvUeotab1HrFrX4PeX+psLvKveV8vvK/Y3l/s7Cby383nJ/c3mLWreodYtab1HrLWrdotYtar1FrbeodYtat6j1FrXeotYtaiW/A76v9C1q3aLWLWq9Ra23qHWLWreo9Ra13qLWLWrdotZb1HqLWreodYtab1HrLWrdotYtar1FrX1/t76v9Ba13qLWW9S6Ra1b1HqLWm9R6xa1blHrLWq9Ra1b1LpFrbeo9Ra1blHrFrXeotZb1LpFrcOfLN5X+ha1blHrFrXeotZb1LpFrVvUeotab1HrFrVuUXqL0luUblG6RektSm9RukXpFqW3KL1FKfhj0P1z0FuU3qJ0i9ItSm9ReovSLUq3KL1F6S1KtyjdovQWpbco3aJ0i9JblO6f1/gDG39i449s7yvlD238qe3+se3+uY0/uN2i9BaltyjdonSL0luU3qJ0i9ItSm9ReovSLUq3KL1F6S1KxR8v7yt9i9JblG5RukXpLUpvUbpF6Raltyi9RekWpVuU3qL0FqVblG5ReovSW5RuUbpFqe8fhd9XeovSLUpvUXqL0i1Ktyi9RektSrco3aL0FqW3KN2idIvSW5TeonSL0i1Kb1F6i9Lwx3b+3P7+wf0tKm9ReYvKt6h8i8pbVN6i8i0q36LyFpW3qHyLyreovEXlLSrfovItKm9ReYvKt6hc9+8Y95XeovItKt+i8haVt6h8i8q3qLxF5S0q36LyLSpvUXmLyreofIvKW1Tyd6H7l6H7tyH+OuS/D72v9P6NiL8S8Xei+5eit6i8ReUtKt+i8i0qb1F5i8q3qHyLyltU3qLyLSrfovIWlbeofIvKff/udl/pLSrfovItKm9ReYvKt6h8i8pbVN6i8i0q36LyFpW3qHyLyreovEXlLSrfovItKm9Refh75vtK36LyFpW3qHyLyreovEXlLSrfovItKm9ReYuqt6h6i6pbVN2i6i2q3qLqFlW3qHqLqreoCv5SfP9W/BZVb1F1i6pbVL1F1VtU3aLqFlVvUfUWVbeoukXVW1S9RdUtqm5R9RZVb1F1i6pbVOn+Bf59pbeoukXVW1S9RdUtqm5R9RZVb1F1i6pbVL1F1VtU3aLqFlVvUXW/z8A3GvhOw/1Ww/1eg7/ZcF/p/XbD/X4D33C4RdVbVL1F1S2qblH1FlVvUXWLqltUvUXVW1TdouoWVW9R9RZVt6i6RVXfb4y8r/QWVbeoeouqt6i6RdUtqt6i6i2qblF1i6q3qHqLqltU3aLqLareouoWVbeoeouqt6gavonDd3Heb+O8Re1b1L5F7beo/Ra1b1H7FrXfovZb1L5F7VvUfovab1H7FrVvUfstar9F7VvUvkXtt6i97nec7iu9Re23qP0WtW9R+xa136L2W9S+Re1b1H6L2m9R+xa1b1H7LWq/Re1b1L5F7beo/Ra1b1E7+e7Y+0rfovYtat+i9lvUfovat6h9i9pvUfstat+i9i1qv0Xtt6h9i9p8D+9+E+9+F49v4/F9vPuNPL6Td18p38u738x7i9q3qH2L2m9R+y1q36L2LWq/Re23qH2L2reo/Ra136L2LWrfovZb1H6L2reoffiu4/tK36L2LWrfovZb1H6L2reofYvab1H7LWrfovYtqt+i+i2qb1F9i+q3qH6L6ltU36L6Larfojr4Fun9HulbVL9F9S2qb1H9FtVvUX2L6ltUv0X1W1TfovoW1W9R/RbVt6i+RfVbVL9F9S2qb1Gt++3c95XeovoW1W9R/RbVt6i+RfVbVL9F9S2qb1H9FtVvUX2L6ltUv0X1W1TfovoW1W9R/RbVxbee7yt9i+q3qL5F9S2q36L6LapvUX2L6reofovqW1Tfovotqu/3x/kGOd8hv98iv98j55vkfJecb5O/r5RvlN+i+i2q36L6FtW3qH6L6reovkX1Larfovotqm9RfYvqt6h+i+pbVN+i+i2q36J6+JY+39N/v6n/FnVuUecWdd6izlvUuUWdW9R5izpvUecWdW5R5y3qvEWdW9S5RZ23qPMWdW5R5xZ13qLOuu8/3Fd6izpvUect6tyizi3qvEWdt6hzizq3qPMWdd6izi3q3KLOW9R5izq3qHOLOm9R5y3q3KJO8l7J+0rfos4t6tyizlvUeYs6t6hzizpvUect6tyizi3qvEWdt6hzizq3qPMWdd6izi3q3KLOW9TZ932d+0pvUect6rxFnVvUuUWdt6jzFnVuUecWdd6izlvUuUUd3nu6bz7dd594+4n3n+4bUPcdKN6C8ntQ7yt9izq3qHOLOm9R5y3q3KLOLeq8RZ23qHOLOreoeYuat6i5Rc0tat6i5i1qblFzi5q3qHmLmuANs/uO2VvUvEXNLWpuUfMWNW9Rc4uaW9S8Rc1b1Nyi5hY1b1HzFjW3qLlFzVvUvEXNLWpuUaP75t77Sm9Rc4uat6h5i5pb1Nyi5i1q3qLmFjW3qHmLmreouUXNLWreouYtam5Rc4uat6h5i5rijcj7St+i5i1qblFzi5q3qHmLmlvU3KLmLWreouYWNbeoeYuat6i5Rc0tat6i5i1qblFzi5q+b5q+r/QWNbeoeYuat6i5Rc0tat6i5i1qblFzi5q3qLnv6/LGLu/s3rd273u7vLnLu7v37d37/q7f4PU7vPctXt7j9Zu8fpeXt3l5n9dv9PqdXt7qve/1PrzZ+/Bu73Pf7n3u+70Pb/g+vOP73Ld8n/ue78Obvg/v+j73bd9n8Q41r553fp/71u9z3/t9ePP34d3f5779+9z3fx/eAH54B/i5bwE/9z3ghzeBH94Ffu7bwM99H/jhjeCHd4Kf+1bwc98Lfngz+Em/w35f/X0/+OEN4Yd3hJ/7lvBz3xN+eFP44V3h574t/Nz3hR/eGH54Z/i5bw0/973hhzeHH94dfu7bw899f/jhDeKHd4if+xbxsxECvHreJX7u28TPfZ/44Y3ih3eKn/tW8XPfK354s/jh3eLnvl383PeLH94wfnjH+LlvGT/3PeOHN40f3jV+7tvGz33f+OGN4+dYONxXf987fnjz+OHd4+e+ffzc948f3kB+eAf5uW8hP/c95Ic3kR+qBWYgM0wzbDPAGegM8wz7DICGhcY3RAOjAdJAaZhp2GkANZAaphpUC9ZAa5hr2GsANhAbJhs2G6AN1IbZht0GcAO5YbphuwHeQG+Yb9hvADgQHCYcNhwgDhSHGYcdB5ADyWHKYcsB5kBzmHPYcwA6EB0mHTYdoA5Uh1mHXQewA9lh2mHbAe5Ad5h32HcAPBAeJh42HiAPlIeZh50H0APpYeph6wH2QHuYe9h7AD4QHyYfNh+gD9SH2YfdB/AD+WH6gf2Iiz/i6o+AfwT+Iy4AiStAAgISGJC4CCSuAgkYSCybwlvtlSABBQksSFwMEleDBBwkloUVxMrGildvZQWzwlkZWllaQa1utdCQwIbExSFxdUjAQwIfEheIxBUiAREJjEhcJBJXiQRMJHAicaFIXCkSUJHAisTFInG1SMBFAi8SF4zEFSMBGQnMSFw0EleNBGwkcCNx4UhcORLQkcCOxMUjcfVIwEcCPxIXkMQVJAEhCQxJXEQSV5EEjCRwJHEhSVxJElCSwJLExSRxNUnASQJPEheUxBUlASkJTElcVBJXlQSsJHAlcWFJXFkS0JLAlsTFJXF1ScBLAl8SF5jEFSYBMQmMSVxkEleZBMwkcCZxoUlcaRJQk8CahLDAt1q4SeBN4oKTuOIkICeBOYmLTuKqk4CdBO4kLjyJK08CehLYk7j4JISQNJG0kTSSvK/eTNJOEiiJlDSVpNoLUeJKlICiBBYlLkaJq1ECjhJ4lLggJa5ICUhKYFLiopS4KiVgKYFLiQtT4sqUgKYENiUuTomrUwKeEviUuEAlrlAJiEpgVOIilbhKJWAqgVOJC1XiSpWAqgRWJS5WiatVAq4SeJW4YCWuWAnISmBW4qKVuGolYCuBW4kLV+LKlYCuBHYlLl6Jq1cCvhL4lbiAJa5gCQhLYFjiIpa4iiVgLIFjiQtZ4kqWgLIEliUuZomrWQLOEniWuKAlEsNPtZiWuKglrmoJWEvgWuLClriyJaAtgW2Ji1vi6paAtwS+JS5wiStcAuISGJe4yCWucgmYS+Bc4kKXuNIloC6RFs4QZ4yzkfM3yvm+epyzobOlM9T5Vgt7CdxLXPgSV74E9CWwL3HxS1z9EvCXwL/EBTBxBUxAYAIDExfBxFUwAYMJHExcCBNXwgQUJrAwcTFMXA0TcJjAw8QFMXFFTEBiAhMTF8XEVTEBiwlcTFwYE1fGBDQmsDFxcUxcHRPwmMDHxAUycYVMQGQCIxMXycRVMgGTCZxMXCgTV8oEVCawMnGxTFwtE3CZwMvEBTNxxUxAZgIzExfNxFUzUf7ZG6q9cCaunAnoTGBn4uKZuHom4DOBn4kLaOIKmoDQBIYmLqKJq2gCRhM4mriQJq6kCShNYGniYpq4mibgNIGniQtq4oqagNQEpiYuqomragJWE7iauLAmip9Q8I8o+GcU+CEFfkrhmx9T4NXzgwr8pIJ/VIFqL7KJq2wCZhM4m7jQJq60CahNYG3iYpu42ibgNoG3iQtu4oqbgNwE5iYuuomrbgJ2E7ibuPAmrrwJ6E1gb+Lim7j6JuA3gb+JC3DiCpyA4AQGJy7CiatwAoYTOJy4ECeuxAkoTmBx4mKcuBon4DiBx4kLcuKKnIDkBCYnLsqJq3IClhO4nLgwJ67MCWhObP/M3K326pyA5wQ+Jy7QiSt0AqITGJ24SCeu0gmYTuB04kKduFInoDqB1YmLdeJqnYDrBF4nLtiJK3YCshOYnbhoJ67aCdhO4Hbiwp24ciegO4HdiYt34uqdgO8Eficu4IkreALCExieuIgnruIJGE9s/4QRP2LEzxj5h4z8U0b8mJF/zohX75804keNbrWQnsD0xEU9cVVPwHoC1xMX9sSVPQHtCWxPXNwTV/cEvCfwPXGBT1zhExCfwPjERT5xlU/AfALnExf6xJU+AfUJrE9c7BNX+wTcJ/A+ccFPXPETkJ/A/MRFP3HVT8B+AvcTF/7ElT8B/QnsT1z8E1f/BPwn8D/R/KzrrRYCFBiguAgorgIKGFDggOJCoLgSKKBAgQWKi4HiaqCAAwUeKC4IiiuCAhIUmKC4KCiuCgpYUOCC4sKguDIooEGBDYqLg+LqoIAHBT4oLhCKK4QCIhQYobhIKK4SCphQ4ITiQqG4UiigQoEViouF4mqhgAsFXiguGIorhgIyFJihuGgomp8Q9I8I+mcE+SFBfkrQPybonxP0DwreV+8fFaTaC4jiCqKAEAWGKC4iiquIAkYUOKK4kCiuJAooUWCJ4mKiuJoo4ESBJ4oLiuKKooAUBaYoLiqKq4oCVhS4oriwKK4sCmhRYIvi4qK4uijgRYEviguM4gqjgBgFxiguMorDz6hTLc4oLjSKK40CahRYo7jYKK42CrhR4I3igqO44iggR4E5iouO4qqjgB0F7iguPIorjwJ6FNijuPgorj4K+FHgj+ICpLgCKSBIgUGKi5DiKqSAIQUOKS5EiiuRAooUWKS4GCmuRgo4UuCR4oKkuCIpIEmBSYqLkuKqpIAlBS4pLkyKK5MCmhTYpLg4Ka5OCnhS4JPiAqW4QikgSnH8E778iC8/4+sf8vVP+fJjvvycr3/Q95uf9L2v/lYLVwq8UlywFFcsBWQpMEtx0VJctRSwpcAtxYVLceVSQJcCuxQXL8XVSwFfCvxSXMAUVzAFhCkwTHERU1zFFDCmwDHFhUxxJVOM/7clqPZipriaKeBMgWeKC5riiqaANAWmKS5qiquaAtYUuKa4sCmubApoU2Cb4uKmuLop4E2Bb4oLnOIKp4A4BcYpLnKKq5wC5hQ4p7jQKa50CqhTYJ3iYqe42ingToF3igue4oqngDwF5ikueoqrngL2FLinuPAprnwK6FNgn+Lip7j6KeBPgX+KC6DiCqiAQAUGKi6CiqugAgYVOKi4ECquhAooVGCh4mKouBoq4FCBh4oLomL4CX3/iL5/Rp8f0uen9P1j+v45fX5Qn5/U/+ZH9d9Xvx5+WJ+f1veP6/vn9fmBfX5i3z+y75/Z54f270/tY6MWNmpdG7WujVrYqIWNWtdGrWujFjZqPf7fhLk/wH9t1MJGLWzUujZqXRu1sFELG7WujVrXRi1s1MJGrWuj1rVRCxu1sFHr2qh1bdTCRi1s1Lo2al0btbBRCxu1ro1a10YtbNTCRq2vNuqP/4Gs9RVHfTz6o9s//v+Yu77qqPfR4qPiUfLR4tHmo82jw0fnPvqj3Y+P/hHv+2jxUfEo+WjxaPPR5hF3bO5o7mjuaO5o7mjuaO5o7mjuaO5o7jjccbjjcMfhjsMdhzsOdxzuONxxuGO4Y7hjuGO4Y7hjuGO4Y7hjuGPuHV/V1NePfmVT76PFR8Wj5KPFo81Hm0eHj947vtqpj49G8GjxUfEo+WjxaPPR5tHho9yxuGNxx+KOxR2LOxZ3LO5Y3LG4Y3GHuEPcIe4Qd4g7xB3iDnGHuEPckdyR3JHckdyR3JHckdyR3EHnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50Hni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3QuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnReebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN50fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnczvXczvXczvXczvXczvXczvXczvXczvXczvXczvXczvXczvXczvXczvXczvXczvXczvXczvXczvXczvXE9yxuGNxx+KOxR2LOxZ3LO5Y3LG4Y3GHuEPcIe4Qd4g7xB3iDnGHuEPckdyR3JHckdyR3JHckdyR3JHckdxR3FHcUdxR3FHcUdxR3FHcUdxR3LG5Y3PH5o7NHZs7Nnds7tjcsbljc0dzR3NHc0dzR3NHc0dzR3NHc0dzx+GOwx2HOw53HO443HG443DH4Y7DHcMdwx3DHcMdwx3DHcMdwx3DHXSOhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eGEhxMeTng44eESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uESD5d4uMTDJR4u8XCJh0s8XOLhEg+XeLjEwyUeLvFwiYdLPFzi4RIPl3i4xMMlHi7xcImHSzxc4uHyq4db++uj5tEfd8zXR/M++urhvn70q4d7Hy0+Kh4lHy0ebT7aPDp8dO6jr51//ejXzj8eLT4qHiUfLR5tPto8OnyUOxZ3LO5Y3LG4Y3HH4o7FHYs7Fncs7hB3iDvEHeIOcYe4Q9wh7hB3iDuSO5I7kjuSO5I7kjuSO5I7kjuSO4o7ijuKO4o7ijuKO4o7ijuKO4o7Nnds7tjcsbljc8fmjs0dmzs2d2zuaO5o7mjuaO5o7mjuaO5o7mjuaO443HG443DH4Y7DHYc7Dncc7jjccbhjuGO4Y7hjuGO4Y7iDzoPOg86DzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7oXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi85F56Jz0bnoXHQuOhedi86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vum86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86fzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86Hzud2Xs/tvJ7beT2383pu5/Xczuu5nddzO6/ndl7P7bye23k9t/N6buf13M7ruZ3Xczuv53Zez+28ntt5PbfzeoI7Fncs7ljcsbhjccfijsUdizsWdyzuEHeIO8Qd4g5xh7hD3CHuEHeIO5I7kjuSO5I7kjuSO5I7kjuSO5I7ijuKO4o7ijuKO4o7ijuKO4o7ijs2d2zu2NyxuWNzx+aOzR2bOzZ3bO5o7mjuaO5o7mjuaO5o7mjuaO5o7jjccbjjcMfhjsMdhzsOdxzuONxxuGO4Y7hjuGO4Y7hjuGO4Y7hjuIPO8XCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4QoPV3i4wsMVHq7wcIWHKzxc4eEKD1d4uMLDFR6u8HCFhys8XOHhCg9XeLjCwxUervBwhYcrPFzh4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4TYebuPhNh5u4+E2Hm7j4fZXD6f6+qh49OX/hs7XR82jw0fnPvqj84+P/tH5+2jxUfEo+WjxaPPR5tHho3Mf/dH5x0f/6Px9tPioeMQdmzs2d2zu2NyxuaO5o7mjuaO5o7mjuaO5o7mjuaO543DH4Y7DHYc7Dncc7jjccbjjcMfhjuGO4Y7hjuGO4Y7hjuGO4Y7hjrl3fPVwXz/61cO9jxYfFY+SjxaPNh9tHh0+eu/46uE+PhrBo8VHxaPko8WjzUebR4ePcsfijsUdizsWdyzuWNyxuGNxx+KOxR3iDnGHuEPcIe4Qd4g7xB3iDnFHckdyR3JHcgedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOF50vOl90vuh80fmi80Xni84XnS86X3S+6HzR+aLzReeLzhedLzpfdL7ofNH5ovNF54vOReeic9G56Fx0LjoXnYvOReeic9G56Fx0LjoXnYvOReeic9G56Fx0LjoXnYvOReeic9G56Fx0LjoXnYvOReeic9G56Fx0LjoXnYvOReeic9G56Fx0LjoXnYvOReeic9G56Fx0LjoXnYvOReeic9G56Fx0LjoXnYvOReeic9G56Fx0LjoXnYvOReeic9G56Fx0LjoXnYvOReeic9G56Fx0LjoXnYvOReeic9G56Fx0LjoXnYvOReeic9G56DzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpPOk86TzpvOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOi86LzovOh80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzpvOm86bzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7ofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofOh86HzofG7n/dzO+7md93M77+d23s/tvJ/beT+3835u5/3czvu5nfdzO+/ndt7P7byf23k/t/N+buf93M77uZ33czvvJ7hjccfijsUdizsWdyzuWNyxuGNxx+IOcYe4Q9wh7hB3iDvEHeIOcYe4I7kjuSO5I7kjuSO5I7kjuSO5I7mjuKO4o7ijuKO4o7ijuKO4o7ijuGNzx+aOzR2bOzZ3bO7Y3LG5Y3PH5o7mjuaO5o7mjuaO5o7mjuaO5o7mjsMdhzsOdxzuONxxuONwx+GOwx2HO4Y7hjuGO4Y7hjuGO4Y7hjuGO+g86DzoPOg86DzoPOg86DzoPOg86DzoPOg86DzoPOg86DzoPOg86DzoPOg86DzoPOg86DzoPOg86DzoPOg86DzoPOg86DzoPOg86DzoPOg86DzoPOg86DzoHA/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EaD9d4uMbDNR6u8XCNh2s8XOPhGg/XeLjGwzUervFwjYdrPFzj4RoP13i4xsM1Hq7xcI2Hazxc4+EOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OEOHu7g4Q4e7uDhDh7u4OHOVw+X++sj8ejL/42cr4+KR5uPNo8OH5330VcP9/WjXz3c+2jxUfEo+WjxaPPR5tHho3Mf/dH5x0f/6Px9tPioeJR8tHi0+Wjz6PBR7ljcsbhjccfijsUdizsWdyzuWNyxuEPcIe4Qd4g7xB3iDnGHuEPcIe5I7kjuSO5I7kjuSO5I7kjuSO5I7ijuKO4o7ijuKO4o7ijuKO4o7iju2NyxuWNzx+aOzR2bOzZ3bO7Y3LG5o7mjuaO5o7mjuaO5o7mjuaO5o7njcMfhjsMdhzsOdxzuONxxuONwx+GO4Y7hDjpfdL7ofNH5ovNF54vOF52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRuehcdC46F52LzkXnonPRedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50nnSedJ50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50XnRedF50fmm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nW8633S+6XzT+abzTeebzjedbzrfdL7pfNP5pvNN55vON51vOt90vul80/mm803nm843nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedN503nTedHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND5ofND54fOD50fOj90fuj80Pmh80Pnh84PnR86P3R+6PzQ+aHzQ+eHzg+dHzo/dH7o/ND50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD50PnQ+dD53M7nuZ3Pczuf53Y+z+18ntv5PLfzeW7n89zO57mdz3M7n+d2Ps/tfJ7b+Ty383lu5/Pczue5nc9zO5/ndj5PcMfijsUdizsWdyzuWNyxuGNxx+KOxR3iDnGHuEPcIe4Qd4g7xB3iDnFHckdyR3JHckdyR3JHckdyR3JHckdxR3FHcUdxR3FHcUdxR3FHcUdxx+aOzR2bOzZ3bO7Y3LG5Y3PH5o7NHc0dzR3NHc0dzR3NHc0dzR3NHc0dhzsOdxzuONxxuONwx+GOwx2HOw53DHcMdwx3DHcMdwx3DHcMdwx30HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedB50HnQedA5Hm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBww0ebvBwg4cbPNzg4QYPN3i4wcMNHm7wcIOHGzzc4OEGDzd4uMHDDR5u8HCDhxs83ODhBg83eLjBw8UDiPvjYfjh8i+QH6Z/Qfnh9i9oPzz+BcPDm/wfD8MPl3+B/DD9C8oPt39B++HxL/Bty7ct37Z82/Jty7ct37Z82/Jty7ct3ybfJt8m3ybfJt8m3ybfJt8m3ybflr4tfVv6tvRt6dvSt6VvS9+Wvi19W/m28m3l28q3lW8r31a+rXxb+bbybdu3bd+2fdv2bdu3bd+2fdv2bdu3bd/Wvq19W/u29m3t29q3tW9r39a+rX3b8W3Htx3fdnzb8W3Htx3fdnzb8W3Ht41vG982vm182/i28W3j28a3jW/zloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/J8pYsb8nylixvyfKWLG/JVwBY9fEw/PDL/7U6Hw/lh+lfUH64/QvaD49/wfDwjy15f8EfW3IfLv8C+WH6F5Qfbv+C9sPjXzA83L5t+7bt27Zv275t+7bt27Zv275t+7b2be3b2re1b2vf1r6tfVv7tvZt7duObzu+7fi249uObzu+7fi249uObzu+bXzb+LbxbePbxreNbxvfNr5tfNtw21c8+PELvurB+3D5F8gP07+g/HD7F7QfHv8CbvvKCN9fEOGHy79Afpj+BeWH27+g/fD4F/i25duWb1u+bfm25duWb1u+bfm25duWb5Nvk2+Tb5Nvk2+Tb5Nvk2+Tb5Nv85bIWyJvibwl8pbIWyJvibwl8pbIWyJvibwl8pbIWyJvibwl8pbIWyJvibwl8pbIWyJvibwl8pbIWyJvibwl8pbIWyJvibwl8pbIWyJvibwl8pbIWyJvibwl8pbIWyJvibwl8pbIWyJvibwl8pbIWyJvibwl8pbIWyJvibwl8pbIWyJvibwl6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9JbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8Jdtbsr0l21uyvSXbW7K9Jdtbsr0l21uyvSXbW7K9Jdtbsr0l21uyvSXbW7K9Jdtbsr0l21uyvSXbW7K9Jdtbsr0l21uyvSXbW7K9Jdtbsr0l21uyvSXbW7K9Jdtbsr0l21uyvSXbW7K9Jdtbsr0l21uyvSXbW7K9Jdtbsr0l21uyvSXbW7K9Jdtbsr0l21uyvSXbW7K9Jdtbsr0l21uyvSXbW7K9Jdtbsr0l21uyvSXbW7K9Jdtbsr0l21uyvSXbW7K9Jdtbsr0l21uyvSXbW7K9Jdtbsr0l21uyvSXbW7K9Jdtbsr0l21uyvSXbW7K9Jdtbsr0l21uyvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2ltyvCXHW3K8Jcdbcrwlx1tyvCXHW3K8Jcdbcrwlx1tyvCXHW3K8Jcdbcrwlx1tyvCXHW3K8Jcdbcrwlx1tyvCXHW3K8Jcdbcrwlx1tyvCXHW3K8Jcdbcrwlx1tyvCXHW3K8Jcdbcrwlx1tyvCXHW3K8Jcdbcrwlx1tyvCXHW3K8Jcdbcrwlx1tyvCXHW3K8Jcdbcrwlx1tyvCXHW3K8Jcdbcrwlx1tyvCXHW3K8Jcdbcrwlx1tyvCXHW3K8Jcdbcrwlx1tyvCXHW3K8Jcdbcrwlx1tyvCXHW3K8Jcdbcrwlx1tyvCXHW3K8Jcdbcrwlx1tyvCXHW3K8JcdbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2TYknjYknjYknjYknjYknjYknjYknjYknjYknjYknjYknjYknjYknjYknjYknjYknjYknjYknjYknjYknjCty3ftnzb8m3Lty3ftnzb8m3Lty3ftnybfJt8m3ybfJt8m3ybfJt8m3ybfFv6tvRt6dvSt6VvS9+Wvi19W/q29G3l28q3lW8r31a+rXxb+bbybeXbyrdt37Z92/Zt27dt37Z92/Zt27dt37Z9W/u29m3t29q3tW9r39a+rX1b+7b2bce3Hd92fNvxbce3Hd92fNvxbce3Hd82vm182/i28W3j28a3jW8b3za+zVsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwly1uyvCXLW7K8Jctbsrwly1uyvCXLW7K8Jctbsrwly1uyvCXLW7K8Jctbsrwly1uyvCXLW7K8Jctbsrwly1uyvCXLW7K8Jctbsrwly1uyvCXLW7K8Jctbsrwly1uyvCXLW7K8JXavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h9xp2r2H3GnavYfcadq9h97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97rsXpfd67J7XXavy+512b0uu9dl97q+utfdHw+Hh39sST8fD8MPl3+B/DD9C8oPt39B++HxL5j78Kt7/fgFX93rfbj8C+SH6V9Qfrj9C9oPj38Bt311r+8viPDD5V8gP0z/gvLD7V/Qfnj8C3zb8m3Lty3ftnzb8m3Lty3ftnzb8m3Lt8m3ybfJt8m3ybfJt8m3ybfJt8m3pW9L35a+LX1b+rb0benb0relb0vfVr6tfFv5tvJt5dvKt5VvK99Wvq182/Zt27dt37Z92/Zt27dt37Z92/Zt27e1b2vf1r6tfVv7tvZt7dvat7Vva992fNvxbce3Hd92fNvxbce3Hd/mLZG3RN4SeUvkLZG3RN4SeUvkLZG3RN4SeUvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLckvSXpLUlvSXpL0luS3pL0lqS3JL0l6S1Jb0l6S9Jbkt6S9JaktyS9JektSW9JekvSW5LekvSWpLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLyltS3pLylpS3pLwl5S0pb0l5S8pbUt6S8paUt6S8JeUtKW9JeUvKW1LekvKWlLekvCXlLSlvSXlLtrdke0u2t2R7S7a3ZHtLtrdke0u2t2R7S7a3ZHtLtrdke0u2t2R7S7a3ZHtLtrdke0u2t2R7S7a3ZHtLtrdke0u2t2R7S7a3ZHtLtrdke0u2t2R7S7a3ZHtLtrdke0u2t2R7S7a3ZHtLtrdke0u2t2R7S7a3ZHtLtrdke0u2t2R7S7a3ZHtLtrdke0u2t2R7S7a3ZHtLtrdke0u2t2R7S7a3ZHtLtrdke0u2t2R7S7a3ZHtLtrdke0u2t2R7S7a3ZHtLtrdke0u2t2R7S7a3ZHtLtrdke0u2t2R7S7a3ZHtLtrdke0u2t2R7S7a3ZHtLtrdke0u2t2R7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t6S9Je0taW9Je0vaW9LekvaWtLekvSXtLWlvSXtL2lvS3pL2lrS3pL0l7S1pb0l7S9pb0t6S9pa0t+R4S4635HhLjrfkeEuOt+R4S4635HhLjrfkeEuOt+R4S4635HhLjrfkeEuOt+R4S4635HhLjrfkeEuOt+R4S4635HhLjrfkeEuOt+R4S4635HhLjrfkeEuOt+R4S4635HhLjrfkeEuOt+R4S4635HhLjrfkeEuOt+R4S4635HhLjrfkeEuOt+R4S4635HhLjrfkeEuOt+R4S4635HhLjrfkeEuOt+R4S4635HhLjrfkeEuOt+R4S4635HhLjrfkeEuOt+R4S4635HhLjrfkeEuOt+R4S4635HhLjrfkeEuOt+R4S4635HhLjrfkeEuOt+R4S4635HhLjrdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvyXhLxlsy3pLxloy3ZLwl4y0Zb8l4S8ZbMt6S8ZaMt2S8JeMtGW/JeEvGWzLekvGWjLdkvCXjLRlvybAletgSPWyJHrZED1uihy3Rw5boYUv0sCV62BI9bIketkQPW6KHLdHDluhhS/SwJXrYEj1siR62RE/4tuXblm9bvm35tuXblm9bvm35tuXblm+Tb5Nvk2+Tb5Nvk2+Tb5Nvk2+Tb0vflr4tfVv6tvRt6dvSt6VvS9+Wvq18W/m28m3l28q3lW8r31a+rXxb+bbt27Zv275t+7bt27Zv275t+7bt27Zva9/Wvq19W/u29m3t29q3tW9r39a+7fi249uObzu+7fi249uObzu+7fi249vGt41vG982vm182/i28W3j28a3eUvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLckvCXhLQlvSXhLwlsS3pLwloS3JLwl4S0Jb0l4S8JbEt6S8JaEtyS8JeEtCW9JeEvCWxLekvCWhLdkeUuWt2R5S5a3ZHlLlrdkeUuWt2R5S5a3ZHlLlrdkeUuWt2R5S5a3ZHlLlrdkeUuWt2R5S5a3ZHlLlrdkeUuWt2R5S5a3ZHlLlrdkeUuWt2R5S5a3ZHlLlrdkeUuWt2R5S5a3ZHlLlrdkeUuWt2R5S5a3ZHlLlrdkeUuWt2R5S5a3ZHlLlrdkeUuWt2R5S5a3ZHlLlrdkeUuWt2R5S5a3ZHlLlrdkeUuWt2R5S5a3ZHlLlrdkeUuWt2R5S5a3ZHlLlrdkeUuWt2R5S5a3ZHlLlrdkeUuWt2R5S5a3xO5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b3K7lV2r7J7ld2r7F5l9yq7V9m9yu5Vdq+ye5Xdq+xeZfcqu1fZvcruVXavsnuV3avsXmX3KrtX2b2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r2r2m3Wvavabda9q9pt1r/v9M2jGSBDmORcErFRgEAdz/YrvdM5MODQLNwr7yhEznXi/3ernXy71e7vVyr5d7vdzr5V4v93q518u9Xu71cq+Xe73c6+VeL/d6udfLvV7u9XKvl3u93OvlXi/3ernXy71e7vVyr5d7vdzr5V4v93q518u9Xu71cq+Xe73c6+VeL/d6udfLvV7u9XKvl3u93OvlXi/3ernXy71e7vVyr5d7vdzr5V4v93q518u9Xu71cq+Xe73c6+VeL/d6udfLvV7u9XKvl3u93OvlXi/3ernXy71e7vVyr5d7vdzr5V4v93q518u9Xu71cq+Xe73c6+VeL/d6udfLvV7u9XKvl3u93OvlXi/3ernXy71e7vVyr5d7vdzr5V4v93q518u9Xu71cq+Xe73c6+VeL/d6udfLvV7u9XKvl3u93OvlXi/3ernXy71e7vVyr5d7vdzr5V4v93q518u9Xu71cq+Xe73c6+VeL/d6udfLvV7u9XKvl3u93OvlXi/3ernXy71e7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7jW51+Rek3tN7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXt+/7rX6P2c4//9rHf85P+f1IJ3Pg3K2B/M7/2nJfx/805L/nceDz3k9SOfzoJztwfzv/Ne9/ufBv+71f+fx4HNeD9L5PChne/Db9q97/e+DCOfx4HNeD9L5PChne2Dbse3Ydmw7th3bjm3HtmPbse3Y9tn22fbZ9tn22fbZ9tn22fbZ9tl2bbu2Xduubde2a9u17dp2bbu2pW1pW9qWtqVtaVvalralbWnbs+3Z9mx7tj3bnm3Ptmfbs+3ZVraVbWVb2Va2lW1lW9lWtpVtWnK15GrJ1ZKrJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JKnJU9LnpY8LXla8rTkacnTkqclT0ueljwteVrytORpydOSpyVPS56WPC15WvK05GnJ05KnJU9LnpY8LXla8rTkacnTkqclT0ueljwteVrytORpydOSpyVPS56WPC15WvK05GnJ05KnJU9LnpY8LXla8rTkacnTkqclT0ueljwteVrytORpydOSpyVPS56WPC15WvK05GnJ05KnJU9LnpY8LXla8rTkacnTkqclT0ueljwteVrytORpydOSpyVPS56WPC15WvK05GnJ05KnJU9LnpY8LSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS2ZX0vq79eS+vu1pP5+Lam/X0vq79eS+vu1pP5+Lam/X0vq79eS+vu1pP5+Lam/X0vq79eS+vu1pP5+Lam/X0vq79eS+vu1pP5+Lam/sO3Ydmw7th3bjm3HtmPbse3Ydmz7bPts+2z7bPts+2z7bPts+2z7bLu2Xduubde2a9u17dp2bbu2XdvStrQtbUvb0ra0LW1L29K2tO3Z9mx7tj3bnm3Ptmfbs+3Z9mwr28q2sq1sK9vKtrKtbCvbyra2rW1r29q2tq1ta9vatratbRvbxraxbWwb28a2sW1sG9u0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0s+Lfm05NOST0u41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rX/da89/znT+f9fm/Ofs5ztwfzOf1ry3wf/tOR/5/Hgc14P0vk8KGd7ML/zn5b898E/LfnfeTz4nLZd265t17Zr27UtbUvb0ra0LW1L29K2tC1tS9uebc+2Z9uz7dn2bHu2Pduebc+2sq1sK9vKtrKtbCvbyrayrWxr29q2tq1ta9vatratbWvb2raxbWwb28a2sW1sG9vGtrFtftv+da//efCve/3feTz4nNeDdD4Pytke/Lb9617/+yDCeTz4nNeDdD4Pytke2HZsO7Yd245tWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWvK05GnJ05KnJU9LnpY8LXla8rTkacnTkqclT0ueljwteVrytORpydOSpyVPS56WPC15WvK05GnJ05KnJU9LnpY8LXla8rTkacnTkqclT0ueljwteVrytORpydOSpyVPS56WPC15WvK05GnJ05KnJU9LnpY8LXla8rTkacnTkqclT0ueljwteVrytORpydOSpyVPS56WPC15WvK05GnJ05KnJU9LnpY8LXla8rTkacnTkqclT0ueljwteVrytORpydOSpyVPS56WPC15WvK05GnJ05KnJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyXza8n8/Voyf7+WzN+vJfP3a8n8/Voyf7+WzN+vJfP3a8n8/Voyf7+WzN+vJfP3a8n8/Voyf7+WzN+vJfP3a8n8/Voyf7+WzN+vJfMXth3bjm3HtmPbse3Ydmw7th3bjm2fbZ9tn22fbZ9tn22fbZ9tn22fbde2a9u17dp2bbu2Xduubde2a1valralbWlb2pa2pW1pW9qWtj3bnm3Ptmfbs+3Z9mx7tj3bnm1lW9lWtpVtZVvZVraVbWVb2da2tW1tW9vWtrVtbVvb1ra1bWPb2Da2jW1j29g2to1tY5uWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacnVkqslV0uullwtuVpyteRqydWSqyVXS66WXC25WnK15GrJ1ZKrJVdLrpZcLblacrXkagn3OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/DvQ73OtzrcK/zc6/n7+de/znDeTz4nNeDdD4PytkezO/8X0v+OcN5PPic14N0Pg/K2R7Ydmw7th3bjm3HtmPbse3Ydmw7tn22fbZ9tn22fbZ9tn22fbZ9tn22Xduubde2a9u17dp2bbu2XduubWlb2pa2pW1pW9qWtqVtaVva9mx7tj3bnm3Ptmfbs+3Z9mx7tpVtZVvZVraVbWVb2Va2lW1lW9vWtrVtbVvb1ra1bW1b29a2jW1j29g2to1tY9vYNraNbVoSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWSqyVXS66WXC25WnK15GrJ1ZKrJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWSqyVXS66WXC25WnK15GrJ1ZKrJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWSqyVXS66WXC25WnK15GrJ1ZKrJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWSqyVXS66WXC25WnK15GrJ1ZKrJVdLrpZcLblaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklrytORpydOSpyVPS56WPC15WvK05GnJ05KnJU9LnpY8LXla8rTkacnTkqclT0ueljwteVrytORpydOSpyVPS56WPC15WvK05GnJ05KnJU9LnpY8LXla8rTkacnTkqclT0ueljwteVrytORpydOSpyVPS56WPC15WvK05GnJ05KnJU9LnpY8LXla8rTkacnTkqclT0ueljwteVrytORpydOSpyVPS56WPC15WvK05GnJ05KnJU9LnpY8LXla8rTkacnTkqclT0ueljwteVrytORpydOSpyWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0loyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMl3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3Gtwr8G9Bvca3OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9Hu71cK+Hez3c6+FeD/d6uNfDvR7u9XCvh3s93OvhXg/3erjXw70e7vVwr4d7Pdzr4V4P93q418O9nn/d6///yPOfu9bd/9zff+5x/9OT/735Jyi/+6w337rvepPrfutNrbvXm3F/f958se6z3nzrvutNrnvt/dbeb+391t679t619669d+29a+9de+/ae9feu/betTfX3lx7c+3NtTfX3lx7c+3NtTfX3lx739r71t639r619629b+19a+9be9/a+9beWntr7a21t9beWntr7a21t9beWntr7e21t9feXnt77e21t9feXnt77e21t9feWXtn7Z21d9beWXtn7Z21d9beWXvH3n8t7X/f/Itpf/dZb7513/Um1/3Wm1p3rzf2/qtq//cmYt1nvfnWfdebXPdbb2rdvd6svatXb/XqrV691au3evVWr97q1Vu9eqtXb/XqrV691au3evVWr97q1Vu9eqtXb/XqrV691au3evVWr97q1Vu9eqtXb/XqrV691au3evVWr97q1Vu9eqtXb/XqrV691au3evVWr97q1Vu9eqtXb/XqrV691au3evVWr97q1Vu9eqtXb/XqrV691au3evVWr97q1Vu9eqtXb/XqrV691au3evVWr97q1Vu9eqtXb/XqrV691au3evVWr97q1Vu9eqtXb/XqrV691au3evVWr97q1Vu9qtWrWr2q1atavarVq1q9qtWrWr2q1atavarVq1q9qtWrWr2q1atavarVq1q9qtWrWr2q1atavarVq1q9qtWrWr2q1atavarVq1q9qtWrWr2q1atavarVq1q9qtWrWr2q1atavarVq1q9qtWrWr2q1atavarVq1q9qtWrWr2q1atavarVq1q9qtWrWr2q1atavarVq1q9qtWrWr2q1atavarVq1q9qtWrWr2q1atavarVq1q9qtWrWr2q1atavarVq1q9qtWrWr2q1atavarVq1q9qtWrWr2q1atavarVq1q9qtWrWr2q1atavarVq1q9qtWrWr2q1ataverVq1696tWrXr3q1ateverVq1696tWrXr3q1ateverVq1696tWrXr3q1ateverVq1696tWrXr3q1ateverVq1696tWrXr3q1ateverVq1696tWrXr3q1ateverVq1696tWrXr3q1ateverVq1696tWrXr3q1ateverVq1696tWrXr3q1ateverVq1696tWrXr3q1ateverVq1696tWrXr3q1ateverVq1696tWrXr3q1ateverVq1696tWrXr3q1ateverVq1696tWrXr3q1ateverVq1696tWrXr3q1ateverVq1696tWrXr3q1ateverVq1696tWrXr2a1atZvZrVq1m9mtWrWb2a1atZvZrVq1m9mtWrWb2a1atZvZrVq1m9mtWrWb2a1atZvZrVq1m9mtWrWb2a1atZvZrVq1m9mtWrWb2a1atZvZrVq1m9mtWrWb2a1atZvZrVq1m9mtWrWb2a1atZvZrVq1m9mtWrWb2a1atZvZrVq1m9mtWrWb2a1atZvZrVq1m9mtWrWb2a1atZvZrVq1m9mtWrWb2a1atZvZrVq1m9mtWrWb2a1atZvZrVq1m9mtWrWb2a1atZvZrVq1m9mtWrWb2a1atZvZrVq1m9mtWrWb2a1atZvZrVq1m9mtWrWb2a1atZvZrVq9Gr70+vvj+9+v706vvTq+9Pr74/vfr+9Or706vvT6++P736/vTq+9Or70+vvj+9+v706vvTq+9Pr74/vfr+9Or7i7X3rL1n7T1r71l7z9p71t6z9p6196y9Z+391t5v7f3W3m/t/dbeb+391t5v7f3W3m/tvWvvXXvv2nvX3rv23rX3rr137b1r7117c+3NtTfX3lx7c+3NtTfX3lx7c+3NtfetvW/tfWvvW3vf2vvW3rf2vrX3rb1v7a21t9beWntr7a21t9beWntr7a21t9beXnt77e21t9feXnt77e21t9feXnt77Z21d9beWXtn7Z21d9beWXtn7Z21d/UqVq9i9SpWr2L1KlavYvUqVq9i9SpWr2L1KlavYvUqVq9i9SpWr2L1KlavYvUqVq9i9SpWr2L1KlavYvUqVq9i9SpWr2L1KlavYvUqVq9i9SpWr2L1KlavYvUqVq9i9SpWr2L1KlavYvUqVq9i9SpWr2L1KlavYvUqVq9i9SpWr2L1KlavYvUqVq9i9SpWr2L1KlavYvUqVq9i9SpWr2L1KlavYvUqVq9i9SpWr2L1KlavYvUqVq9i9SpWr2L1KlavYvUqVq9i9SpWr2L1KlavYvUqVq9i9SpWr2L1KlavYvUqVq9i9SpWr2L1KlavYvUqVq9i9SpWr2L16qxendWrs3p1Vq/O6tVZvTqrV2f16qxendWrs3p1Vq/O6tVZvTqrV2f16qxendWrs3p1Vq/O6tVZvTqrV2f16qxendWrs3p1Vq/O6tVZvTqrV2f16qxendWrs3p1Vq/O6tVZvTqrV2f16qxendWrs3p1Vq/O6tVZvTqrV2f16qxendWrs3p1Vq/O6tVZvTqrV2f16qxendWrs3p1Vq/O6tVZvTqrV2f16qxendWrs3p1Vq/O6tVZvTqrV2f16qxendWrs3p1Vq/O6tVZvTqrV2f16qxendWrs3p1Vq/O6tVZvTqrV2f16qxendWrs3p1Vq/O6tVZvTqrV2f16qxendWrs3p1Vq++1atv9epbvfpWr77Vq2/16lu9+lavvtWrb/XqW736Vq++1atv9epbvfpWr77Vq2/16lu9+lavvtWrb/XqW736Vq++1atv9epbvfpWr77Vq2/16lu9+lavvtWrb/XqW736Vq++1atv9epbvfpWr77Vq2/16lu9+lavvtWrb/XqW736Vq++1atv9epbvfpWr77Vq2/16lu9+lavvtWrb/XqW736Vq++1atv9epbvfpWr77Vq2/16lu9+lavvtWrb/XqW736Vq++1atv9epbvfpWr77Vq2/16lu9+lavvtWrb/XqW736Vq++1atv9epbvfpWr77Vq2/16lu9+lavvtWrb/XqW736Vq++1atv9epbvfpWr+7q1V29uqtXd/Xqrl7d1au7enVXr+7q1V29uqtXd/Xqrl7d1au7enVXr+7q1V29uqtXd/Xqrl7d1au7enVXr+7q1V29uqtXd/Xqrl7d1au7enVXr+7q1V29uqtXd/Xqrl7d1au7enVXr+7q1V29uqtXd/Xqrl7d1au7enVXr+7q1V29uqtXd/Xqrl7d1au7enVXr+7q1V29uqtXd/Xqrl7d1au7enVXr+7q1V29uqtXd/Xqrl7d1au7enVXr+7q1V29uqtXd/Xqrl7d1au7enVXr+7q1V29uqtXd/Xqrl7d1au7enVXr+7q1V29uqtXd/Xqrl7d1au7enVXr+7q1V29uqtXd/UqV69y9SpXr3L1KlevcvUqV69y9SpXr3L1KlevcvUqV69y9SpXr3L1avn2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2b/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/sXq1fPtdvv3/72/dd73Jdb/1ptbd6429y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb7/Ltd/n2u3z7Xb79Lt9+l2+/y7ff5dvv8u13+fa7fPtdvv0u336Xb7/Lt9/l2+/y7Xf59rt8+12+/S7ffpdvv8u33+Xb77++/b7/nOH8/6/e+c/5Oa8H6XwelLM9mN/5T6X+++CfSP3vPB58zutBOp8H5WwP5ne2bW1b29a2tW1tW9vWtrVtbdvYNraNbWPb2Da2jW1j29g2v23/uvX/PPiXrf/vPB58zutBOp8H5WwPftv+1er/fRDhPB58zutBOp8H5WwPbDu2HduObce2Y9ux7dh2bDu2Hds+2z7bPts+2z7bPts+2z7bPts+265t17Zr27Xt2nZtu7Zd265t17a0LW1L29K2tC1tS9vStrQtbdOSpyVPS56WPC15WvK05GnJ05KnJU9LnpY8LXla8rTkacnTkqclT0ueljwteVrytORpydOSpyVPS56WPC15WvK05GnJ05KnJU9LnpY8LXla8rTkaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWvJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJ/FqSf7+W5N+vJfn3a0n+/VqSf7+W5N+vJfn3a0n+/VqSf7+W5N+vJfn3a0n+/VqSf7+W5N+vJfn3a0n+/VqSf7+W5N+vJfn3a0n+hW3HtmPbse3Ydmw7th3bjm3HtmPbZ9tn22fbZ9tn22fbZ9tn22fbZ9u17dp2bbu2Xduubde2a9u17dqWtqVtaVvalralbWlb2pa2pW3Ptmfbs+3Z9mx7tj3bnm3Ptmdb2Va2lW1lW9lWtpVtZVvZVra1bW1b29a2tW1tW9vWtrVtbdvYNraNbWPb2Da2jW1j29imJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaElR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFpyteRqydWSqyVXS66WXC25WnK15GrJ1ZKrJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWSqyVXS66WXC25WnK15GrJ1ZKrJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWSqyVXS66WXC25WnK15GrJ1ZKrJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWSqyVXS66WXC25WnK15GrJ1ZKrJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWSqyWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSXca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m95rca3Kvyb0m9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6uNfHvT7u9XGvj3t93OvjXh/3+rjXx70+7vVxr497fdzr414f9/q418e9Pu71ca+Pe33c6+NeH/f6/nWvmf8553f+05Ls/5zhPB58zutBOp8H5WwP5nf+05L/PvinJf87jwef83qQzudBOW07tn22fbZ9tn22fbZ9tn22fbZ9tn22Xduubde2a9u17dp2bbu2XduubWlb2pa2pW1pW9qWtqVtaVva9mx7tj3bnm3Ptmfbs+3Z9mx7tpVtZVvZVraVbWVb2Va2lW1lW9vWtrVtbVvb1ra1bW1b29a2jW1j29g2to1tY9vYNraNbfPb9q97/c+Df93r/87jwee8HqTzeVDO9uC3rbSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLSktKS0pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLWktaS1pLVktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRktGS0ZLRkfi2pv19L6u/Xkvr7taT+fi2pv19L6u/Xkvr7taT+fi2pv19L6u/Xkvr7taT+fi2pv19L6u/Xkvr7taT+fi2pv19L6u/Xkvr7taT+wrZj27Ht2HZsO7Yd245tx7Zj27Hts+2z7bPts+2z7bPts+2z7bPts+3adm27tl3brm3Xtmvbte3adm1L29K2tC1tS9vStrQtbUvb0rZn27Pt2fZse7Y9255tz7Zn27OtbCvbyrayrWwr28q2sq1sK9vatratbWvb2ra2rW1r29q2tm1sG9vGtrFtbBvbxraxbWzTktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi35tOTTkk9LPi25WnK15GrJ1ZKrJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWSqyVXS66WXC25WnK15GrJ1ZKrJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWSqyVXS66WXC25WnK15GrJ1ZKrJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWSqyVXS66WXC25WnK15GrJ1ZKrJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWSqyVXS66WXC25WnK15GrJ1ZLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUktSS1JLUkqclT0ueljwteVrytORpydMS7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3st7rW41+Jei3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3tt7rW51+Zem3vtf93rq/+c5fz/r9Xff875nf+05L8P/mnJ/87jwee8HqTzeVDO9mB+5z8t+e+Df1ryv/N48DmvB+m0rWwr28q2tq1ta9vatratbWvb2ra2rW0b28a2sW1sG9vGtrFtbBvb5rftX/f6nwf/utf/nceDz3k9SOfzoJztwW/bv+71vw8inMeDz3k9SOfzoJztgW3HtmPbse3Ydmw7th3bjm3HtmPbZ9tn22fbZ9tn22fbZ9tn22fbZ9u17dp2bbu2Xduubde2a9u17dqWtqVtaVvalralbVpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWlJaUlpSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJa0lrSWtJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMloyWjJaMr+WzN+vJfP3a8n8/Voyf7+WzN+vJfP3a8n8/Voyf7+WzN+vJfP3a8n8/Voyf7+WzN+vJfP3a8n8/Voyf7+WzN+vJfP3a8n8/Voyf2Hbse3Ydmw7th3bjm3HtmPbse3Y9tn22fbZ9tn22fbZ9tn22fbZ9tl2bbu2Xduubde2a9u17dp2bbu2pW1pW9qWtqVtaVvalralbWnbs+3Z9mx7tj3bnm3Ptmfbs+3ZVraVbWVb2Va2lW1lW9lWtpVtbVvb1ra1bW1b29a2tW1tW9s2to1tY9vYNraNbWPb2Da2aUloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloSWhJaEloydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLTlacrTkaMnRkqMlR0uOlhwtOVpytORoydGSoyVHS46WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WfFryacmnJZ+WXC25WnK15GrJ1ZKrJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWSqyVXS66WXC25WnK15GrJ1ZKrJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWSqyVXS66WXC25WnK15GrJ1ZKrJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWSqyVXS66WXC25WnK15GrJ1ZKrJVdLrpZcLblacrXkasnVkqslV0uullwtuVpyteRqydWSqyVXS66WXC25WnK15GpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJaklqSWpJasnTkqclT0ueljwteVrytORpydOSpyVPS56WPC15WvK05GnJ05KnJU9LnpY8LXla8rTkacnTkqclT0ueljwteVrytORpydOSpyVPS56WPC15WvK05GnJ05KnJU9LnpY8LXla8rTkacnTkqclT0ueljwteVrytORpCfc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr8O9Dvc63Otwr/Nzr///j/D/WvLPGc7jwee8HqTzeVDO9mB+5/9a8s8ZzuPB57wepPN5UM72wLZj27Ht2HZsO7Yd245tx7Zj27Hts+2z7bPts+2z7bPts+2z7bPts+3adm27tl3brm3Xtmvbte3adm1L29K2tC1tS9vStrQtbUvb0rZn27Pt2fZse7Y9255tz7Zn27OtbCvbyrayrWwr28q2sq1sK9vatratbWvb2ra2rW1r29q2tm1sG9vGtrFtbBvbxraxbWzTktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCS0JLQktCSoyVHS46WHC05WnK05GjJ0ZKjJUdLjpYcLfk/Ju3dCJJkx4KoSoVPAEj9Fdud6TftzgWRZtdA1GHKE0sSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSx5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDksOSw5LDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4soXsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7DbrXoHsNutegew2616B7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke02616R7TbrXpHtNuteke81/u9e9P8/v7/MfSy7+PINn8kHxbD54PIcPlufxwff3+Y8l//vgH0v+eyYfFM/mg8dz+GB5cttw23Lbctty23Lbctty23Lbctty23Lbcdtx23Hbcdtx23Hbcdtx23HbcdvHbR+3fdz2cdvHbR+3fdz2cdvHbd/f2/7tXv988G/3+t8z+aB4Nh88nsMHy/P44O9t/3av//sggmfyQfFsPng8hw+W5/EBtyW3JbcltyW3JbcltyW3JbcltyW3FbcVtxW3FbcVtxW3FbcVtxW3Fbc1tzW3Nbc1tzW3Nbc1tzW3YclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYclhyWHJYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjyYcmHJR+WfFjy/bWkfn8tqd9fS+r315L6/bWkfn8tqd9fS+r315L6/bWkfn8tqd9fS+r315L6/bWkfn8tqd9fS+r315L6/bWkfn8tqd9fS+r315L6BbcltyW3JbcltyW3JbcltyW3JbcltxW3FbcVtxW3FbcVtxW3FbcVtxW3Nbc1tzW3Nbc1tzW3Nbc1tzW3Nbc9bnvc9rjtcdvjtsdtj9setz1ue9w23DbcNtw23DbcNtw23DbcNtw23Lbctty23Lbctty23Lbctty23Lbcdtx23Hbcdtx23Hbcdtx23Hbcdtz2cdvHbR+3fdz2cdvHbR+3fdz2cRuWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYElgSWBJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYkliSWJJYklhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWFJYUlhSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY0ljSWNJY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYclgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWDJYMlgyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliyWLJYsliCd1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Ft1r0b0W3WvRvRbda9G9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O9Nt1r07023WvTvTbda9O99r/d631/nsXz/9e+/PN8PIcPlufxwfff89/u9c8H/3av/z2TD4pn88HjOXywPI8Pvr/Pfyz53wf/WPLfM/mgeDYfPJ7DB8vz+IDbktuS25LbktuS25LbktuS2/6x5L8PuK24rbituK24rbituK24rbituK24rbmtua25rbmtua25rbmtua25rbntcdvjtsdtj9setz1ue9z2uO1x2+O24bbhtuG24bbhtuG24bbhtuG24bbltuW25bbltuW25bbltuW25bbltuO247bjtuO247bjtuO247bjtuO2j9s+bsOSw5LDksOSw5LDksOSw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDkw5IPSz4s+bDk+2vJ+/215P3+WvJ+fy15v7+WvN9fS97vryXv99eS9/tryfv9teT9/lryfn8teb+/lrzfX0ve768l7/fXkvf7a8n7/bXk/f5a8n5/LXm/4LbktuS25LbktuS25LbktuS25LbktuK24rbituK24rbituK24rbituK25rbmtua25rbmtua25rbmtua25rbHbY/bHrc9bnvc9rjtcdvjtsdtj9uG24bbhtuG24bbhtuG24bbhtuG25bbltuW25bbltuW25bbltuW25bbjtuO247bjtuO247bjtuO247bjts+bvu47eO2j9s+bvu47eO2j9s+bsOSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLAksCSwJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksSSxJLEksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSwpLCksKSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpLGksaSxpKHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LHlY8rDkYcnDkoclD0seljwseVjysORhycOShyUPSx6WPCx5WPKw5GHJw5KHJQ9LHpY8LBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLFksWSxZLKF7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d66N7fXSvj+710b0+utdH9/roXh/d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evQvQ7d69C9Dt3r0L0O3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0r0u3evSvS7d69K9Lt3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3evRvR7d69G9Ht3r0b0e3ev9273G7/fn/fSef9715716n775eP8jyn/f/EPK33fqm9K79c3Te/TN6n365vv7/reD/d83/4awf9+pb0rv1jdP79E3q/fpG+79t4j975sIvVPflN6tb57eo29W79M3ujd1b+re1L2pe1P3pu5N3Zu6N3Vv6t7SvaV7S/eW7i3dW7q3dG/p3tK9pXtb97bubd3burd1b+ve1r2te1v3tu59uvfp3qd7n+59uvfp3qd7n+59uvfp3tG9o3tH947uHd07und07+je0b2je1f3ru5d3bu6d3Xv6t7Vvat7V/eu7j3de7r3dO/pXnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVh1ffD6++H159P7z6fnj1/fDq++HV98Or74dX3w+vvh9efT+8+n549f3w6vvh1ffDq++HV98Pr74fXn0/vPp+oXtT96buTd2bujd1b+re1L2pe1P3pu4t3Vu6t3Rv6d7SvaV7S/eW7i3dW7q3dW/r3ta9rXtb97bubd3burd1b+vep3uf7n269+nep3uf7n269+nep3uf7h3dO7p3dO/o3tG9o3tH947uHd07und17+re1b2re1f3ru5d3bu6d3Xv6t7Tvad7T/ee7j3de7r3dO/p3tO9p3s/3fvp3k/3frr3072f7v1076d7P90rr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ6+evHry6smrJ69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfJKffunvv1T3/6pb//Ut3/q2z/17Z/69k99+6e+/VPf/qlv/9S3f+rbP/Xtn/r2T337p779U9/+qW//1Ld/6ts/9e2f+vZPffunvv1T3/6pb//Ut3/q2z/17Z/69k99+6e+/VPf/qlv/9S3f+rbP/Xtn/r2T337p779U9/+qW//1Ld/6ts/9e2f+vZPffunvv1T3/6pb//Ut3/q2z/17Z/69k99+6e+/VPf/qlv/9S3f+rbP/Xtn/r2T337p779U9/+qW//1Ld/6ts/9e2f+vZPffunvv1T3/6pb//Ut3/q2z/17Z/69k99+6e+/VPf/qlv/9S3f+rbP/Xtn/r2T337p779U9/+qW//1Ld/6ts/9e2f+vZPffunvv1T3/6pb//Ut3/q2z/17Z/69k99+6e+/VPf/qlv/9S3f+rbP/Xtn/r2T337p779U9/+0bf//7+Df7365x16p74pvVvfPL1H36zep28+3n+9+ucdeqe+Kb1b3zy9R9+s3qdvdG/q3tS9qXtT96buTd2bujd1b+re1L2le0v3lu4t3Vu6t3Rv6d7SvaV7S/e27m3d27q3dW/r3ta9rXtb97bubd37dO/TvU/3Pt37dO/TvU/3Pt37dO/TvaN7R/eO7h3dO7p3dO/o3tG9o3tH967uXd27und17+re1b2re1f3ru5d3Xu693Tv6d7Tvad7T/ee7j3de7r3dO+nez/d++neT/d+uvfTvZ/u/XTvp3vlVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5dWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1Z++/bs/74/3v1799w69U+/Su/V+eo/eq7d2S7ut3dbuP17lb/68S+/W+/93M+LPe/RevU/vj/c/Xv19h96pd+ndemv3afdp92n3aXe0O9od7Y52R7uj3dHuaHe0O9pd7a52V7ur3dXuane1u9pd7a52T7un3dPuafe0e9o97Z52T7un3U+7n3Y/7f7jVeaf38s/Xv19P71H79X79P7+e8e/ffvfd+idepferffTe/RevU9v7YZ2Q7uh3dBuaDe0G9oN7YZ2Q7up3dRuaje1m9pN7aZ2U7up3dRuabe0W9ot7ZZ2S7ul3dJuabe029pt7bZ2W7ut3dZua7e129pt7T7tPu0+7T7tPu0+7T7tPu0+7T7tjnZHu6Pd0e5od7Q72h3tjnZHu6vd1e5qd7W72l3trnZXu6vd1e5p97R72j3tnnZPu6fd0+5p97T7affT7qfdT7ufdj/tftr9tPtpV16FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1pePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ePXn15NWTV09ejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3ySn17qG8P9e2hvj3Ut4f69lDfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2pvj3Vt6f69lTfnurbU317qm9P9e2Z8kp9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e6pvT/Xtqb491ben+vZU357q21N9e/6vb98/79X79P54//Hqf+9/div+vFPv0rv1fnqP3qv36f3PbvW/73+9+u8deqfepXfr/fQevVfv01u7q93V7mp3tbvaXe2udle7q93V7mn3tHvaPe2edk+7p93T7mn3tPtp99Pup91Pu592P+1+2v20+2n3Y/dP3/7fO/ROvUvv1vvpPXqv3qe3dkO7od3Qbmg3tBvaDe2GdkO7od3Ubmo3tZvaTe2mdlO7qd3Ubmq3tFvaLe2Wdku7pd3Sbmm3tFvabe22dlu7rd3Wbmu3tdvabe22dp92n3afdp92n3afdp92n3afduXVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z65NUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yatPXn3y6pNXn7z68Kp+eFU/vKofXtUPr+qHV/XDq/rhVf3wqn54Vb+fdkO7od3Qbmg3tBvaDe2GdkO7od3Ubmo3tZvaTe2mdlO7qd3Ubmq3tFvaLe2Wdku7pd3Sbmm3tFvabe22dlu7rd3Wbmu3tdvabe22dp92n3afdp92n3afdp92n3afdp92R7uj3dHuaHe0O9od7Y52R7uj3dXuane1u9pd7a52V7ur3dXuave0e9o97Z52T7un3dPuafe0e9r9tPtp99Pup91Pu592P+1+2v20K69CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrk1Z++vfbf9x+v/vcOvVPv0rv1fnqP3qv36a3d0+5p97R72j3tnnZPu6fd0+5p99Pup91Pu592P+1+2v20+2n30+7H7p++/b936J16l96t99N79F69T2/thnZDu6Hd0G5oN7Qb2g3thnZDu6nd1G5qN7Wb2k3tpnZTu6nd1G5pt7Rb2i3tlnZLu6Xd0m5pt7Tb2m3ttnZbu63d1m5rt7Xb2m3tPu0+7T7tPu0+7T7tPu0+7T7tPu2Odke7o93R7mh3tDvaHe2OduVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp59eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj15NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbz607f379/3v1799w69U+/Su/V+eo/eq/fprd1Pu592P+1+2v20+2n30+6n3U+7H7t/+vb/3qF36l16t95P79F79T69tRvaDe2GdkO7od3Qbmg3tBvaDe2mdlO7qd3Ubmo3tZvaTe2mdlO7pd3Sbmm3tFvaLe2Wdku7pd3Sbmu3tdvabe22dlu7rd3Wbmu3tfu0+7T7tPu0+7T7tPu0+7T7tPu0O9od7Y52R7uj3dHuaHe0O9od7a52V7ur3dXuane1u9pd7a525dUnrz559cmrT1598uqTV5+8+uTVJ68+efXJq09effLqk1efvPrk1SevPnn1yasPr/qHV/3Dq/7hVf/wqn941T+86h9e9Q+v+odX/ftpN7Qb2g3thnZDu6Hd0G5oN7Qb2k3tpnZTu6nd1G5qN7Wb2k3tpnZLu6Xd0m5pt7Rb2i3tlnZLu6Xd1m5rt7Xb2m3ttnZbu63d1m5r92n3afdp92n3afdp92n3afdp92l3tDvaHe2Odke7o93R7mh3tDvaXe2udle7q93V7mp3tbvaXe2udk+7p93T7mn3tHvaPe2edk+7p91Pu592P+1+2v20+2n30+6n3U+78irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrk1Z++vevf9x+v/vcOvVPv0rv1fnqP3qv36c3un779v3fonXqX3q3303v0Xr1Pb+2GdkO7od3Qbmg3tBvaDe2GdkO7qd3Ubmo3tZvaTe2mdlO7qd3Ubmm3tFvaLe2Wdku7pd3Sbmm3tNvabe22dlu7rd3Wbmu3tdvabe0+7T7tPu0+7T7tPu0+7T7tPu0+7Y52R7uj3dHuaHe0O9od7Y52R7ur3dXuane1u9pd7a52V7ur3dXuafe0e9o97Z52T7un3dPuaVdetbxqedXyquVVy6uWVy2vWl61vGp59eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj159eTVk1dPXj15NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXI69GXo28Gnk18mrk1cirkVcjr0ZejbwaeTXyauTVyKuRVyOvRl6NvBp5NfJq5NXIq5FXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnm18mrl1cqrlVcrr1ZerbxaebXyauXVyquVVyuvVl6tvFp5tfJq5dXKq5VXK69WXq28Wnl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmrk1cnr05enbw6eXXy6uTVyauTVyevTl6dvDp5dfLq5NXJq5NXJ69OXp28Onl18urk1cmr//Xt88/7f337/96hd+pderfeT+/Re/U+vbUb2g3thnZDu6Hd0G5oN7Qb2g3tpnZTu6nd1G5qN7Wb2k3tpnZTu6Xd0m5pt7Rb2i3tlnZLu6Xd0m5rt7Xb2m3ttnZbu63d1m5rt7X7tPu0+7T7tPu0+7T7tPu0+7T7tDvaHe2Odke7o93R7mh3tDvaHe2udle7q93V7mp3tbvaXe2udle7p93T7mn3tHvaPe2edk+7p93T7qfdT7ufdj/tftr9tPtp99Pup128ej+8ej+8ej+8ej+8ej+8ej+8ej+8ej+8ej+8er+fdkO7od3Qbmg3tBvaDe2GdkO7od3Ubmo3tZvaTe2mdlO7qd3Ubmq3tFvaLe2Wdku7pd3Sbmm3tFvabe22dlu7rd3Wbmu3tdvabe22dp92n3afdp92n3afdp92n3afdp92R7uj3dHuaHe0O9od7Y52R7uj3dXuane1u9pd7a52V7ur3dXuave0e9o97Z52T7un3dPuafe0e9r9tPtp99Pup91Pu592P+1+2v20K69CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irkVcirkFchr0JehbwKeRXyKuRVyKuQVyGvQl6FvAp5FfIq5FXIq5BXIa9CXoW8CnkV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr1JepbxKeZXyKuVVyquUVymvUl6lvEp5lfIq5VXKq5RXKa9SXqW8SnmV8irlVcqrlFcpr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquRVyauSVyWvSl6VvCp5VfKq5FXJq5JXJa9KXpW8KnlV8qrkVcmrklclr0pelbwqeVXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vWl61vGp51fKq5VXLq5ZXLa9aXrW8annV8qrlVcurllctr1petbxqedXyquVVy6uWVy2vnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68urJqyevnrx68ur/mrSbVc2a5DzD56KxBzt+MiPS52KEJLdNQ6MWbclgTJ+7VLWrvveaPYsc3LNrsIiDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXxavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavGK+/bDffvhvv1w3364bz/ctx/u2w/37Yf79sN9++G+/XDffrhvP9y3H+7bD/fth/v2w3374b79cN9+uG8/v+7b3/cOdrKL3ezDvuxhL/t9dtEtukW36Bbdolt0i27RLbpNt+k23abbdJtu0226TbfpHrqH7qF76B66h+6he+geuofupXvpXrqX7qV76V66l+6le+kO3aE7dIfu0B26Q3foDt2hu3SX7tJdukt36S7dpbt0l+6j++g+uo/uo/voPrqP7qP7/ujeX/ftv3awk13sZh/2ZQ972XSDbtANukE36AbdoBt0g27QTbpJN+km3aSbdJNu0k26SbfoFt2iW3SLbtEtukW36Bbdptt0m27TbbpNt+k23abbdA/dQ/fQPXQP3UP30D10D91D99K9dC/dS/fSvXQv3Uv30r10h+7QHbpDd+gO3aE7dIfu0F26S3fpLt2lu3SX7tJdukv30X10H91H99F9dB/dR/fRxavAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8ar7/v20z/3T69+72Anu9jNPuzLHvay6Tbdptt0m27TbbpNt+k23aZ76B66h+6he+geuofuoXvoHrqX7qV76V66l+6le+leupfupTt0h+7QHbpDd+gO3aE7dIfu0l26S3fpLt2lu3SX7tJduo/uo/voPrqP7qP76D66j+77dL/v23/vYCe72M0+7Mse9rLpBt2gG3SDbtANukE36AbdoJt0k27STbpJN+km3aSbdPHq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxauHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1fd9+5mf+9urX/tH93597x/dW9/7R/ee793sH9273/uyh73s99k/vfq9g53sYjeb7qF76B66h+6le+leupfupXvpXrqX7qV76Q7doTt0h+7QHbpDd+gO3aG7dJfu0l26S3fpLt2lu3SX7qP76D66j+6j++g+uo/uo/v+6M73ffvvHexkF7vZh33Zw1423aAbdINu0A26QTfoBt2gG3STbtJNukk36SbdpJt0k27SLbpFt+gW3aJbdItu0S26RbfpNt2m23SbbtNtuk236TbdQ/fQPXQP3UP30D10D91D99C9dC/dS/fSvXQv3Uv30r10L92hO3SH7tAdukN36A7doTt0l+7SXbpLd+ku3aW7dJfu0n10H91H99F9dB/dR/fRfXTxKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8arwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvHq+7594ntf9rCX/T77p1e/d7CTXexm0710L91L99IdukN36A7doTt0h+7QHbpDd+ku3aW7dJfu0l26S3fpLt1H99F9dB/dR/fRfXQf3Uf3fbrf9+2/d7CTXexmH/ZlD3vZdINu0A26QTfoBt2gG3SDbtBNukk36SbdpJt0k27STbpJt+gW3aJbdItu0S26RbfoFt2m23SbbtNtuk236Tbdptt0D91D99A9dA9dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8Wrx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj1fd8+/b0ve9jLfp/97dWvHexkF7vZdIfu0B26Q3fpLt2lu3SX7tJdukt36S7dR/fRfXQf3Uf30X10H91H9/3R3e/79t872MkudrMP+7KHvWy6QTfoBt2gG3SDbtANukE36CbdpJt0k27STbpJN+km3aRbdItu0S26RbfoFt2iW3SLbtNtuk236Tbdptt0m27TbbqH7qF76B66h+6he+geuofuoXvpXrqX7qV76V66l+6le+leukN36A7doTt0h+7QHbpDd+gu3aW7dJfu0l26S3fpLt2l++g+uo/uo/voPrqP7qP76OJV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV49XBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVwyvu25f79uW+fblvX+7bl/v25b59uW9f7tuX+/blvn25b1/u25f79uW+fblvX+7bl/v25b59uW9f7tv31337fO9hL/t99rdXv3awk13sZh823Uf30X1/dN+v+/ZfO9jJLnazD/uyh71sukE36AbdoBt0g27QDbpBN+gm3aSbdJNu0k26STfpJt2kW3SLbtEtukW36Bbdolt0i27TbbpNt+k23abbdJtu0226h+6he+geuofuoXvoHrqH7qF76V66l+6le+leupfupXvpXrpDd+gO3aE7dIfu0B26Q3foLt2lu3SX7tJdukt36S7dpfvoPrqP7qP76D66j+6j++jiVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV49Wv+/b3vX90N773j+7W9/7R3fu93x/7+7799w52sovd7MO+7GEvm27QDbpBN+gG3aAbdINu0A26STfpJt2km3STbtJNukk36Rbdolt0i27RLbpFt+gW3aLbdJtu0226TbfpNt2m23Sb7qF76B66h+6he+geuofuoXvoXrqX7qV76V66l+6le+leupfu0B26Q3foDt2hO3SH7tAdukt36S7dpbt0l+7SXbpLd+k+uo/uo/voPrqP7qP76OLVwauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8Wrx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHV+8Or//rb/odXP3awk13sZh/2ZQ/7Z3e/94/u+/q5f3r1e//odn3vZBe72Yd92cNe9vvsn1793nSTbtJNukk36SbdpJt0i27RLbpFt+gW3aJbdItu0W26TbfpNt2m23SbbtNtuk330D10D91D99A9dA/dQ/fQPXQv3Uv30r10L91L99K9dC/dS3foDt2hO3SH7tAdukN36A7dpbt0l+7SXbpLd+ku3aW7dB/dR/fRfXQf3Uf30X10H9336X7ft//ewU52sZt92Jc97GXTDbp4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41Xh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB6++79v7fu9kF7vZh33Zw172++xvr35tukW36Bbdolt0i27RLbpNt+k23abbdJtu0226TbfpHrqH7qF76B66h+6he+geuofupXvpXrqX7qV76V66l+6le+kO3aE7dIfu0B26Q3foDt2hu3SX7tJdukt36S7dpbt0l+6j++g+uo/uo/voPrqP7qP7Pt3v+/bfO9jJLnazD/uyh71sukE36AbdoBt0g27QDbpBN+gmXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8Wrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePU+XsXXx6v4+ngVXx+v4uvjVXx9vIqvj1fx9fEqvj5exdfHq/j6oht0g27QDbpBN+gG3aAbdINu0k26STfpJt2km3STbtJNukW36Bbdolt0i27RLbpFt+g23abbdJtu0226TbfpNt2me+geuofuoXvoHrqH7qF76B66l+6le+leupfupXvpXrqX7qU7dIfu0B26Q3foDt2hO3SH7tJdukt36S7dpbt0l+7SXbqP7qP76D66j+6j++g+uo8uXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeBV4FXgVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4lXiVeJV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXhVeFV4VXjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeNV41XjVeHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cEr7tuD+/bgvj24bw/u24P79uC+PbhvD+7bg/v24L49uG8P7tuD+/bgvj24bw/u24P79uC+PbhvD+7b49d9+/vexW72YV/2sJf9Pvvbq1872HQP3UP30D10D91D99C9dC/dS/fSvXQv3Uv30r10L92hO3SH7tAdukN36A7doTt0l+7SXbpLd+ku3aW7dJfu0n10H91H99F9dB/dR/fRfXTfp/vrvv3XDnayi93sw77sYS+bbtANukE36AbdoBt0g27QDbpJN+km3aSbdJNu0k26STfpFt2iW3SLbtEtukW36Bbdott0my5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8Wrx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHV+3iVXx+v8uvjVX59vMqvj1f59fEqvz5e5dfHq/z6eJVfH6/y64tu0A26QTfoBt2gG3SDbtANukk36SbdpJt0k27STbpJN+kW3aJbdItu0S26RbfoFt2i23SbbtNtuk236Tbdptt0m+6h+9Or09872cVu9mFf9rCX/T77p1e/N91L99K9dC/dS/fSvXQv3aE7dIfu0B26Q3foDt2hO3SX7tJdukt36S7dpbt0l+7SfXQf3Uf30X10H91H99F9dN+n+33f/nsHO9nFbvZhX/awl0036AbdoBt0g27QDbpBN+gG3aSbdJNu0k26STfpJt2km3SLbtEtukW36Bbdolt0i27RbbpNt+k23abbdJtu0226TffQxavAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxquDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onj1fd9+5nv/6N763j+693zvH9273/uwL3vYy36f/dOr3zvYyS423aE7dIfu0B26S3fpLt2lu3SX7tJdukt36T66j+6j++g+uo/uo/voPrrv0/2+b/+9g53sYjf7sC972MumG3SDbtANukE36AbdoBt0g27STbpJN+km3aSbdJNu0k26RbfoFt2iW3SLbtEtukW36Dbdptt0m27TbbpNt+k23aZ76B66h+6he+geuofuoXvoHrqX7qV76V66eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tXFq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrwavBq8GrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxavFq8WrxauHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl69j1f19fGqvj5e1dfHq/r6eFVfH6/q6+NVfX28qq+PV/X18aq+vugG3aAbdINu0A26QTfoBt2gm3STbtJNukk36SbdpJt0k27RLbpFt+gW3aJbdItu0S26TbfpNt2m23SbbtNtuk236R66h+6he+geuofuoXvoHrqH7qV76V66l+6le+leupfupXvpDt2hO3SH7k+vJr73YV/2sJf9PvunV793sJNdbLpLd+ku3aW7dB/dR/fRfXQf3Uf30X10H9336X7ft//ewU52sZt92Jc97GXTDbpBN+gG3aAbdINu0A26QTfpJt2km3STbtJNukk36Sbdolt0i27RLbpFt+gW3aJbdJtu0226TbfpNt2m23SbbtM9dA/dQ/fQPXQP3UP30D10D91L99K9dC/dS/fSvXQv3Uv30h26Q3foDl28CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq+/79unvfdiXPexlv8/+9urXDnayi0330X10H91H93263/ftv3ewk13sZh/2ZQ972XSDbtANukE36AbdoBt0g27QTbpJN+km3aSbdJNu0k26SbfoFt2iW3SLbtEtukW36Bbdptt0m27TbbpNt+k23abbdA/dQ/fQPXQP3UP30D10D91D99K9dC/dS/fSvXQv3Uv30r10h+7QHbpDd+gO3aE7dIfu0F26S3fpLl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6n286q+PV/318aq/Pl7118er/vp41V8fr/rr41V/fbzqr49X/fVFN+gG3aAbdINu0A26QTfoBt2km3STbtJNukk36SbdpJt0i27RLbpFt+gW3aJbdItu0W26TbfpNt2m23SbbtNtuk330D10D91D99A9dA/dQ/fQPXQv3Uv30r10L91L99K9dC/dS3foDt2hO3SH7tAdukN36A7dpbt0l+7SXbpLd+ku3aW7dB/dR/fRfXQf3Uf30X10H128CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBK+7bm/v25r69uW9v7tub+/bmvr25b2/u25v79ua+vblvb+7bm/v25r69uW9v7tub+/bmvr25b2/u2/vXfft878se9rLfZ3979WsHO9nFbjbdoBt0g27QTbpJN+km3aSbdJNu0k26SbfoFt2iW3SLbtEtukW36Bbdptt0m27TbbpNt+k23abbdA/dQ/fQPXQP3UP30D10D91D99K9dC/dS/fSvXQv3Uv30r10h+7QHbpDd+gO3aE7dIfu0F26S3fpLt2lu3SX7tJdukv30X10H91H99F9dB/dR/fRfZ/ur/v2XzvYyS52sw/7soe9bLp4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eDV4NXg1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV4tXi1eLV49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq4dXD68eXj28enj18Orh1cOrh1cPrx5ePbx6ePXw6uHVw6uHVw+vHl49vHp49fDq4dXDq/fx6nx9vDpfH6/O18er8/Xx6nx9vDpfH6/O18er8/Xx6nx9vDpfX3SDbtANukE36AbdoBt0g27QTbpJN+km3aSbdJNu0k26SbfoFt2iW3SLbtEtukW36Bbdptt0m27TbbpNt+k23abbdA/dQ/fQPXQP3UP30D10D91D99K9dC/dS/fSvXQv3Uv30r10h+7QHbpDd+gO3aE7dIfu0F26S3fpLt2lu3SX7tJdukv30X10H91H99F9dB/dR/fRxavAq8CrwKvAq8CrwKvAq8CrwKvAq8CrwKvAq8CrX/ft73v/6G587x/dre/9o7v3ey/7ffZPr37vYCe72M0+7Mumm3STbtEtukW36Bbdolt0i27RLbpNt+k23abbdJtu0226TbfpHrqH7qF76B66h+6he+geuofupXvpXrqX7qV76V66l+6le+kO3aE7dIfu0B26Q3foDt2hu3SX7tJdukt36S7dpbt0l+6j++g+uo/uo/voPrqP7qP7Pt3v+/bfO9jJLnazD/uyh71sukE36AbdoBt0g27QxavEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8SrxKvEq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrwqvCq8KrxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxqvGq8arxquDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvDp4dfDq4NXBq4NXB68OXh28Onh18Org1cGrg1cHrw5eHbw6eHXw6uDVwauDVwevDl4dvLp4dfHq4tXFq4tXF68uXl28unh18eri1cWri1cXry5eXby6eHXx6uLVxauLVxevLl5dvLp4dfHq4tX3ffvL7/2zu9/7R/f1z/3Tq/f1vX903/37f/uH//tPf/vzP/3zX/70f/7hv/////r8X//xr//y73/+67/++vz3//dvv1/++W9//stf/vy///Hf/vbXf/nT//yPv/3pH//y13/5+fb3//H3/wQ=", - "file_map": { - "18": { - "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n __assert_max_bit_size(self, BIT_SIZE);\n }\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = __to_le_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = __to_be_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_le_radix(self, radix)\n }\n\n fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_be_radix(self, radix)\n }\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n/// This slice will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits(value: Field) -> [u1; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits(value: Field) -> [u1; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime, static_assert};\n use super::{\n field_less_than, modulus_be_bits, modulus_be_bytes, modulus_le_bits, modulus_le_bytes,\n };\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // Updated test to account for Brillig restriction that radix must be greater than 2\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_brillig_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 1;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n unconstrained fn not_enough_limbs_brillig() {\n let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n fn not_enough_limbs() {\n let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n }\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n\n #[test]\n unconstrained fn test_large_field_values_unconstrained() {\n let large_field = 0xffffffffffffffff;\n\n let bits: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\n\n let bytes: [u8; 8] = large_field.to_le_bytes();\n assert_eq(Field::from_le_bytes::<8>(bytes), large_field);\n\n let radix_bytes: [u8; 8] = large_field.to_le_radix(256);\n assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_field);\n }\n\n #[test]\n fn test_large_field_values() {\n let large_val = 0xffffffffffffffff;\n\n let bits: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\n\n let bytes: [u8; 8] = large_val.to_le_bytes();\n assert_eq(Field::from_le_bytes::<8>(bytes), large_val);\n\n let radix_bytes: [u8; 8] = large_val.to_le_radix(256);\n assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_val);\n }\n\n #[test]\n fn test_decomposition_edge_cases() {\n let zero_bits: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\n assert_eq(pow2_bits, expected);\n }\n\n #[test]\n fn test_pow_32() {\n assert_eq(2.pow_32(3), 8);\n assert_eq(3.pow_32(2), 9);\n assert_eq(5.pow_32(0), 1);\n assert_eq(7.pow_32(1), 7);\n\n assert_eq(2.pow_32(10), 1024);\n\n assert_eq(0.pow_32(5), 0);\n assert_eq(0.pow_32(0), 1);\n\n assert_eq(1.pow_32(100), 1);\n }\n\n #[test]\n fn test_sgn0() {\n assert_eq(0.sgn0(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 8 limbs\")]\n fn test_bit_decomposition_overflow() {\n // 8 bits can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; N]) -> Field {\n static_assert(\n N <= modulus_le_bits().len(),\n \"N must be less than or equal to modulus_le_bits().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bits[i] as Field) * v;\n v = v * 2;\n }\n result\n }\n\n /// Convert a big endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_be_bits(bits: [u1; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bits[N - 1 - i] as Field) * v;\n v = v * 2;\n }\n result\n }\n\n #[test]\n fn test_to_from_be_bits_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this bit produces the expected 254 BE bits for (modulus - 1)\n let mut p_minus_1_bits: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\n\n let p_minus_1 = from_be_bits::<254>(p_minus_1_bits);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n let p_minus_1_converted_bits: [u1; 254] = p_minus_1.to_be_bits();\n assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n // checking that incrementing this bit produces 254 BE bits for (modulus + 4)\n let mut p_plus_4_bits: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\n\n let p_plus_4 = from_be_bits::<254>(p_plus_4_bits);\n assert_eq(p_plus_4, 4);\n\n // checking that converting p_plus_4 to 254 BE bits produces the same\n // bit set to 1 as p_plus_4_bits and otherwise zeroes\n let mut p_plus_4_converted_bits: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 254]);\n\n // checking that Field::from_be_bits::<254> on the Field modulus produces 0\n assert_eq(modulus_be_bits().len(), 254);\n let p = from_be_bits::<254>(modulus_be_bits().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 254 BE bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n\n #[test]\n fn test_to_from_le_bits_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this bit produces the expected 254 LE bits for (modulus - 1)\n let mut p_minus_1_bits: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\n\n let p_minus_1 = from_le_bits::<254>(p_minus_1_bits);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n let p_minus_1_converted_bits: [u1; 254] = p_minus_1.to_le_bits();\n assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n // checking that incrementing this bit produces 254 LE bits for (modulus + 4)\n let mut p_plus_4_bits: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\n\n let p_plus_4 = from_le_bits::<254>(p_plus_4_bits);\n assert_eq(p_plus_4, 4);\n\n // checking that converting p_plus_4 to 254 LE bits produces the same\n // bit set to 1 as p_plus_4_bits and otherwise zeroes\n let mut p_plus_4_converted_bits: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 254]);\n\n // checking that Field::from_le_bits::<254> on the Field modulus produces 0\n assert_eq(modulus_le_bits().len(), 254);\n let p = from_le_bits::<254>(modulus_le_bits().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 254 LE bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n", - "path": "std/field/mod.nr" - }, - "19": { - "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u8 as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u16 as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u32 as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u64 as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, - "52": { - "source": "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse greco::{Greco, Params};\nuse polynomial::Polynomial;\n\nmod ciphertext_addition;\nuse ciphertext_addition::CiphertextAddition;\nmod ecdsa;\nuse ecdsa::{address_to_field, derive_address, verify_signature};\nmod merkle_tree;\nuse merkle_tree::get_merkle_root;\nmod utils;\nuse utils::{check_coefficient_values_with_balance, check_coefficient_zero};\n\nfn main(\n params: pub Params<512, 2>,\n pk0is: pub [Polynomial<512>; 2],\n pk1is: pub [Polynomial<512>; 2],\n ct0is: pub [Polynomial<512>; 2],\n ct1is: pub [Polynomial<512>; 2],\n u: Polynomial<512>,\n e0: Polynomial<512>,\n e1: Polynomial<512>,\n e0is: [Polynomial<512>; 2],\n k1: Polynomial<512>,\n r1is: [Polynomial<1023>; 2],\n r2is: [Polynomial<511>; 2],\n p1is: [Polynomial<1023>; 2],\n p2is: [Polynomial<511>; 2],\n) {\n let greco: Greco<512, 2, 36, 36, 2, 6, 6, 4, 10, 36, 10, 36> = Greco::new(\n params,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e1,\n e0is,\n k1,\n r1is,\n r2is,\n p1is,\n p2is,\n );\n\n // Verify the correct ciphertext encryption.\n let is_greco_valid = greco.verify();\n\n assert(is_greco_valid);\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave-2/examples/CRISP/circuits/src/main.nr" - }, - "56": { - "source": "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse polynomial::{flatten, Polynomial};\nuse safe::SafeSponge;\n\n/// Cryptographic parameters for Greco circuit.\n/// Contains the core mathematical constants used in the encryption scheme.\npub struct CryptographicParams {\n /// Plaintext modulus: q mod t\n pub q_mod_t: Field,\n /// CRT moduli for each basis: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Scaling factors for each basis: [k0_0, k0_1, ..., k0_{L-1}]\n pub k0is: [Field; L],\n}\n\nimpl CryptographicParams {\n /// Creates new cryptographic parameters\n pub fn new(q_mod_t: Field, qis: [Field; L], k0is: [Field; L]) -> Self {\n CryptographicParams { q_mod_t, qis, k0is }\n }\n}\n\n/// Bound parameters for range checking.\n/// Contains all the bounds used to validate polynomial coefficients.\npub struct BoundParams {\n /// Bounds for public key polynomials for each CRT basis\n pub pk_bounds: [Field; L],\n /// Bounds for error polynomials (e0)\n pub e0_bound: Field,\n /// Bounds for error polynomials (e1)\n pub e1_bound: Field,\n /// Bound for secret polynomial u (ternary distribution)\n pub u_bound: Field,\n /// Lower bounds for r1 polynomials (modulus switching quotients)\n pub r1_low_bounds: [Field; L],\n /// Upper bounds for r1 polynomials (modulus switching quotients)\n pub r1_up_bounds: [Field; L],\n /// Bounds for r2 polynomials (cyclotomic reduction quotients)\n pub r2_bounds: [Field; L],\n /// Bounds for p1 polynomials (modulus switching quotients)\n pub p1_bounds: [Field; L],\n /// Bounds for p2 polynomials (cyclotomic reduction quotients)\n pub p2_bounds: [Field; L],\n /// Lower bound for k1 polynomial (scaled message)\n pub k1_low_bound: Field,\n /// Upper bound for k1 polynomial (scaled message)\n pub k1_up_bound: Field,\n}\n\nimpl BoundParams {\n /// Creates new bound parameters\n pub fn new(\n pk_bounds: [Field; L],\n e0_bound: Field,\n e1_bound: Field,\n u_bound: Field,\n r1_low_bounds: [Field; L],\n r1_up_bounds: [Field; L],\n r2_bounds: [Field; L],\n p1_bounds: [Field; L],\n p2_bounds: [Field; L],\n k1_low_bound: Field,\n k1_up_bound: Field,\n ) -> Self {\n BoundParams {\n pk_bounds,\n e0_bound,\n e1_bound,\n u_bound,\n r1_low_bounds,\n r1_up_bounds,\n r2_bounds,\n p1_bounds,\n p2_bounds,\n k1_low_bound,\n k1_up_bound,\n }\n }\n}\n\n/// Complete parameters for Greco circuit.\n/// Combines cryptographic parameters, bounds, and circuit-specific parameters.\npub struct Params {\n /// Cryptographic parameters (moduli, scaling factors)\n pub crypto: CryptographicParams,\n /// Bound parameters for range checking\n pub bounds: BoundParams,\n}\n\nimpl Params {\n /// Creates new complete parameters\n pub fn new(\n q_mod_t: Field,\n pk_bounds: [Field; L],\n e0_bound: Field,\n e1_bound: Field,\n u_bound: Field,\n r1_low_bounds: [Field; L],\n r1_up_bounds: [Field; L],\n r2_bounds: [Field; L],\n p1_bounds: [Field; L],\n p2_bounds: [Field; L],\n k1_low_bound: Field,\n k1_up_bound: Field,\n qis: [Field; L],\n k0is: [Field; L],\n ) -> Self {\n let crypto = CryptographicParams::new(q_mod_t, qis, k0is);\n let bounds = BoundParams::new(\n pk_bounds,\n e0_bound,\n e1_bound,\n u_bound,\n r1_low_bounds,\n r1_up_bounds,\n r2_bounds,\n p1_bounds,\n p2_bounds,\n k1_low_bound,\n k1_up_bound,\n );\n\n Params { crypto, bounds }\n }\n\n /// Convenience method to access cryptographic parameters\n pub fn crypto_params(self) -> CryptographicParams {\n self.crypto\n }\n\n /// Convenience method to access bound parameters\n pub fn bound_params(self) -> BoundParams {\n self.bounds\n }\n}\n\n/// Greco\n/// Correct Encryption Circuit under BFV public key\n///\n/// This circuit implements a zero-knowledge proof for the correct formation of a ciphertext\n/// resulting from BFV (Brakerski-Fan-Vercauteren) public key encryption. The circuit verifies\n/// that the ciphertext components (ct0, ct1) are correctly computed from the public key\n/// components (pk0, pk1) and the encryption randomness.\n///\n/// The circuit enforces the following core constraints:\n/// 1. Range checks on all polynomial coefficients to ensure they are within expected bounds\n/// 2. Correct encryption equations:\n/// a. ct0i(gamma) = pk0i(gamma) * u(gamma) + e0(gamma) + k1(gamma) * k0i + r1i(gamma) * qi + r2i(gamma) * cyclo(gamma)\n/// b. ct1i(gamma) = pk1i(gamma) * u(gamma) + e1(gamma) + p1i(gamma) * qi + p2i(gamma) * cyclo(gamma)\n///\n/// DISCLAIMER\n/// The circuit is a porting of the Halo2 circuit from Greco paper author @ PSE.\n/// Halo2 implementation is available at https://github.com/privacy-scaling-explorations/greco\n///\n/// # Generic Parameters\n/// * `N` - The degree of polynomials (ring dimension)\n/// * `L` - The number of CRT (Chinese Remainder Theorem) bases\n/// * `BIT_PK` - Bit-width bound per coefficient for public keys `pk0is`/`pk1is`\n/// * `BIT_CT` - Bit-width bound per coefficient for cipher texts `ct0is`/`ct1is`\n/// * `BIT_U` - Bit-width bound per coefficient for the ternary secret `u`\n/// * `BIT_E0` - Bit-width bound per coefficient for error polynomial `e0`\n/// * `BIT_E1` - Bit-width bound per coefficient for error polynomials `e1`\n/// * `BIT_K` - Bit-width bound per coefficient for the scaled message polynomial `k1`\n/// * `BIT_R1` - Bit-width bound per coefficient for randomness polynomials `r1is`\n/// * `BIT_R2` - Bit-width bound per coefficient for randomness polynomials `r2is`\n/// * `BIT_P1` - Bit-width bound per coefficient for randomness polynomials `p1is`\n/// * `BIT_P2` - Bit-width bound per coefficient for randomness polynomials `p2is`\n///\n/// # Circuit Inputs\n/// * `pk0is`, `pk1is` - Public key polynomials\n/// * `ct0is`, `ct1is` - Ciphertext polynomials\n/// * `u` - Secret polynomial sampled from ternary distribution\n/// * `e0`, `e1` - Error polynomials sampled from discrete Gaussian distribution\n/// * `k1` - Scaled message polynomial\n/// * `r1is`, `r2is` - Randomness polynomials for each i-th CRT basis.\n/// * `p1is`, `p2is` - Randomness polynomials for each i-th CRT basis.\npub struct Greco {\n /// Cryptographic parameters including bounds, moduli, and constants.\n params: Params,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: [Polynomial; L],\n ct1is: [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e1: Polynomial,\n e0is: [Polynomial; L],\n k1: Polynomial,\n r1is: [Polynomial<(2 * N) - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<(2 * N) - 1>; L],\n p2is: [Polynomial; L],\n}\n\nimpl Greco {\n /// Creates a new Greco instance.\n ///\n /// This constructor initializes all the polynomials and parameters needed for\n /// the zero-knowledge proof of correct ciphertext formation.\n ///\n /// # Arguments\n /// * `params` - Cryptographic parameters including bounds and moduli\n /// * `pk0is` - Public key polynomials pk0i = [ai*s + E] for each CRT basis\n /// * `pk1is` - Public key polynomials pk1i = -[ai] for each CRT basis\n /// * `ct0is` - First ciphertext component for each CRT basis\n /// * `ct1is` - Second ciphertext component for each CRT basis\n /// * `u` - Secret polynomial from ternary distribution\n /// * `e0` - Error polynomial sampled from discrete Gaussian distribution\n /// * `e1` - Error polynomial sampled from discrete Gaussian distribution\n /// * `k1` - Scaled message polynomial\n /// * `r1is` - Randomness polynomials for ct0 computation\n /// * `r2is` - Randomness polynomials for ct0 computation\n /// * `p1is` - Randomness polynomials for ct1 computation\n /// * `p2is` - Randomness polynomials for ct1 computation\n ///\n /// # Returns\n /// A new Greco instance ready for constraint checking\n pub fn new(\n params: Params,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: [Polynomial; L],\n ct1is: [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e1: Polynomial,\n e0is: [Polynomial; L],\n k1: Polynomial,\n r1is: [Polynomial<2 * N - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<2 * N - 1>; L],\n p2is: [Polynomial; L],\n ) -> Greco {\n Greco { params, pk0is, pk1is, ct0is, ct1is, u, e0, e1, e0is, k1, r1is, r2is, p1is, p2is }\n }\n\n /// Flattens all polynomials coefficients into a single array for challenge generation.\n ///\n /// This function serializes all polynomial coefficients into a 1D array to enable\n /// the generation of random challenge values using the Fiat-Shamir transform.\n /// The coefficients are arranged in a specific order to ensure deterministic\n /// challenge generation.\n ///\n /// # Returns\n /// An array containing all polynomials coefficients in flattened form\n fn payload(self) -> Vec {\n let mut inputs = Vec::new();\n\n // Flatten public key and ciphertext polynomials first (public inputs)\n inputs = flatten::<_, _, BIT_PK>(inputs, self.pk0is);\n inputs = flatten::<_, _, BIT_PK>(inputs, self.pk1is);\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct0is);\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct1is);\n\n // Flatten common polynomials (used across all CRT bases)\n inputs = flatten::<_, _, BIT_E0>(inputs, [self.e0]);\n inputs = flatten::<_, _, BIT_E1>(inputs, [self.e1]);\n inputs = flatten::<_, _, BIT_U>(inputs, [self.u]);\n inputs = flatten::<_, _, BIT_K>(inputs, [self.k1]);\n\n // Flatten randomness polynomials for each CRT basis\n inputs = flatten::<_, _, BIT_R1>(inputs, self.r1is);\n inputs = flatten::<_, _, BIT_R2>(inputs, self.r2is);\n inputs = flatten::<_, _, BIT_P1>(inputs, self.p1is);\n inputs = flatten::<_, _, BIT_P2>(inputs, self.p2is);\n\n inputs\n }\n\n /// Verifies the correct encryption constraints for the Greco circuit.\n ///\n /// This function implements the core zero-knowledge proof by checking:\n /// 1. Binary constraint on k1 polynomial\n /// 2. Range constraints on all polynomials coefficients\n /// 3. Correct encryption equations\n ///\n /// The proof uses the Schwartz-Zippel lemma: if polynomial equations hold\n /// when evaluated at random points, then the polynomials are identical with\n /// high probability.\n ///\n /// # Encryption Equations\n /// For each CRT basis i:\n /// * ct0i(gamma) = pk0i(gamma) * u(gamma) + e0(gamma) + k1(gamma) * k0i + r1i(gamma) * qi + r2i(gamma) * cyclo\n /// * ct1i(gamma) = pk1i(gamma) * u(gamma) + e1(gamma) + p1i(gamma) * qi + p2i(gamma) * cyclo\n ///\n /// Where:\n /// * cyclo(gamma) = gamma^N + 1 (cyclotomic polynomial)\n /// * qi, k0i are constants from the cryptographic parameters\n /// * r1i, r2i, p1i, p2i are randomness polynomials for each i-th CRT basis.\n ///\n /// # Returns\n /// True if the encryption constraints are satisfied, false otherwise.\n pub fn verify(self) -> bool {\n // Step 1: Perform range checks on all polynomial coefficients\n self.check_range_bounds();\n\n // Step 2: Generate Fiat-Shamir challenges\n let gammas = self.generate_challenge();\n\n // Step 3: Verify encryption constraints using challenges\n self.verify_evaluations(gammas)\n }\n\n /// Performs range checks on all polynomial coefficients\n ///\n /// Checks that all polynomial coefficients are within their expected bounds.\n /// This prevents attacks where coefficients are outside the valid range.\n ///\n /// # Returns\n /// True if the range bounds are satisfied, false otherwise.\n fn check_range_bounds(self) {\n let bound_params = self.params.bound_params();\n\n // Common polynomials (used across all CRT bases)\n self.u.range_check_2bounds::(bound_params.u_bound, bound_params.u_bound);\n self.e0.range_check_2bounds::(bound_params.e0_bound, bound_params.e0_bound);\n self.e1.range_check_2bounds::(bound_params.e1_bound, bound_params.e1_bound);\n self.k1.range_check_2bounds::(bound_params.k1_up_bound, bound_params.k1_low_bound);\n\n // CRT basis-specific polynomials\n for i in 0..L {\n // Public key polynomials must be within bounds for each CRT basis\n self.pk0is[i].range_check_2bounds::(\n bound_params.pk_bounds[i],\n bound_params.pk_bounds[i],\n );\n self.pk1is[i].range_check_2bounds::(\n bound_params.pk_bounds[i],\n bound_params.pk_bounds[i],\n );\n\n // Randomness polynomials for ct0 computation\n self.r1is[i].range_check_2bounds::(\n bound_params.r1_up_bounds[i],\n bound_params.r1_low_bounds[i],\n );\n self.r2is[i].range_check_2bounds::(\n bound_params.r2_bounds[i],\n bound_params.r2_bounds[i],\n );\n\n // Randomness polynomials for ct1 computation\n self.p1is[i].range_check_2bounds::(\n bound_params.p1_bounds[i],\n bound_params.p1_bounds[i],\n );\n self.p2is[i].range_check_2bounds::(\n bound_params.p2_bounds[i],\n bound_params.p2_bounds[i],\n );\n }\n }\n\n /// Generates Fiat-Shamir challenge values using a cryptographic sponge\n ///\n /// The sponge absorbs all witness values and squeezes out deterministic random field elements\n /// that will be used to evaluate polynomials for the Schwartz-Zippel lemma.\n ///\n /// # Returns\n /// Vector of challenge values [gamma_0, gamma_1, ..., gamma_{2L-1}]\n fn generate_challenge(self) -> Vec {\n let inputs = self.payload();\n\n // Domain separator for Greco circuit - \"Greco\" in hex\n let domain_separator = [\n 0x47, 0x72, 0x65, 0x63, 0x6f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n ];\n\n // IO Pattern: ABSORB(input_size), SQUEEZE(2*L)\n let input_size = inputs.len();\n let io_pattern = [0x80000000 | input_size, 0x00000000 | (2 * L)];\n\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(inputs);\n let gammas = sponge.squeeze();\n sponge.finish();\n gammas\n }\n\n /// Verifies encryption constraints using Fiat-Shamir challenges\n ///\n /// For each CRT basis i, proves that LHS(gamma) = RHS(gamma)\n /// This uses the Schwartz-Zippel lemma for polynomial identity testing.\n ///\n /// # Arguments\n /// * `gammas` - Vector of challenge values [gamma_0, gamma_1, ..., gamma_{2L-1}]\n fn verify_evaluations(self, gammas: Vec) -> bool {\n let crypto_params = self.params.crypto_params();\n let gamma = gammas.get(0);\n // Cyclotomic polynomial evaluation: cyclo(x) = x^N + 1\n let cyclo_at_gamma = gamma.pow_32(N as Field) + 1;\n let u_at_gamma = self.u.eval(gamma);\n let e1_at_gamma = self.e1.eval(gamma);\n let k1_at_gamma = self.k1.eval(gamma);\n\n let mut sum = (0, 0);\n for i in 0..L {\n // Check ct0i(gamma) = pk0i(gamma) * u(gamma) + e0(gamma) + k1(gamma) * k0i + r1i(gamma) * qi + r2i(gamma) * cyclo(gamma)\n // Evaluate polynomials at gamma for ct0\n let pk0is_at_gamma = self.pk0is[i].eval(gamma);\n let r1i_at_gamma = self.r1is[i].eval(gamma);\n let r2i_at_gamma = self.r2is[i].eval(gamma);\n let e0is_at_gamma = self.e0is[i].eval(gamma);\n\n // Step 1: pk0_u = pk0i(gamma) * u(gamma) + e0(gamma)\n let pk0_u = (pk0is_at_gamma * u_at_gamma) + e0is_at_gamma;\n\n // Step 2: rhs = pk0_u + k1(gamma) * k0i\n let mut ct0_rhs = pk0_u + (k1_at_gamma * crypto_params.k0is[i]);\n\n // Step 3: rhs = rhs + r1i(gamma) * qi\n ct0_rhs += r1i_at_gamma * crypto_params.qis[i];\n\n // Step 4: rhs = rhs + r2i(gamma) * cyclo(gamma)\n ct0_rhs += r2i_at_gamma * cyclo_at_gamma;\n\n // Left-hand side: ct0i(gamma)\n let ct0_lhs = self.ct0is[i].eval(gamma);\n\n // Checks that ct1i(gamma) = pk1i(gamma) * u(gamma) + e1(gamma) + p1i(gamma) * qi + p2i(gamma) * cyclo(gamma)\n // Evaluate polynomials at gamma for ct1\n let pk1is_at_gamma = self.pk1is[i].eval(gamma);\n let p1is_at_gamma = self.p1is[i].eval(gamma);\n let p2is_at_gamma = self.p2is[i].eval(gamma);\n\n // Step 1: pk1_u = pk1i(gamma) * u(gamma) + e1(gamma)\n let pk1_u = (pk1is_at_gamma * u_at_gamma) + e1_at_gamma;\n\n // Step 2: rhs = pk1_u + p2i(gamma) * cyclo(gamma)\n let mut ct1_rhs = pk1_u + p2is_at_gamma * cyclo_at_gamma;\n\n // Step 3: rhs = rhs + p1i(gamma) * qi\n ct1_rhs += p1is_at_gamma * crypto_params.qis[i];\n\n // Left-hand side: ct1i(gamma)\n let ct1_lhs = self.ct1is[i].eval(gamma);\n\n let gamma_i = if i == 0 { 1 } else { gammas.get(i) };\n\n sum = (\n sum.0 + ct0_lhs * gamma_i + ct1_lhs * gammas.get(i + L),\n sum.1 + ct0_rhs * gamma_i + ct1_rhs * gammas.get(i + L),\n );\n }\n\n sum.0 == sum.1\n }\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave-2/circuits/crates/libs/greco/src/lib.nr" - }, - "57": { - "source": "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\n/// Polynomial structure representing a polynomial of degree N-1.\n///\n/// A polynomial P(X) = a_{N-1} * X^{N-1} + a_{N-2} * X^{N-2} + ... + a_1 * X + a_0\n/// is represented as an array of coefficients where coefficients[0] = a_{N-1} (highest degree)\n/// and coefficients[N-1] = a_0 (constant term).\npub struct Polynomial {\n /// Array of polynomial coefficients in descending degree order\n /// coefficients[0] = coefficient of X^{N-1} (highest degree term)\n /// coefficients[N-1] = constant term (degree 0)\n pub coefficients: [Field; N],\n}\n\nimpl Polynomial {\n /// Creates a new polynomial from an array of coefficients.\n ///\n /// # Arguments\n /// * `coefficients` - Array of N coefficients in descending degree order\n /// coefficients[0] = coefficient of X^{N-1}\n /// coefficients[N-1] = constant term\n ///\n /// # Returns\n /// A new Polynomial instance with the specified coefficients\n pub fn new(coefficients: [Field; N]) -> Self {\n Polynomial { coefficients }\n }\n\n /// Adds two polynomials.\n ///\n /// # Arguments\n /// * `other` - The polynomial to add to the current polynomial.\n ///\n /// # Returns\n /// A new polynomial with the coefficients added.\n pub fn add(self, other: Self) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] + other.coefficients[i];\n }\n\n result\n }\n\n /// Subtracts two polynomials.\n ///\n /// # Arguments\n /// * `other` - The polynomial to subtract from the current polynomial.\n ///\n /// # Returns\n /// A new polynomial with the coefficients subtracted.\n pub fn sub(self, other: Self) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] - other.coefficients[i];\n }\n\n result\n }\n\n /// Multiplies a polynomial by a scalar.\n ///\n /// # Arguments\n /// * `scalar` - The scalar to multiply the polynomial by.\n ///\n /// # Returns\n /// A new polynomial with the coefficients multiplied by the scalar.\n pub fn mul_scalar(self, scalar: Field) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] * scalar;\n }\n\n result\n }\n\n /// Evaluates the polynomial at a given point using Horner's method.\n ///\n /// Horner's method computes P(x) = a_{N-1} * x^{N-1} + ... + a_1 * x + a_0\n /// as ((...((a_{N-1} * x + a_{N-2}) * x + a_{N-3}) * x + ...) * x + a_0)\n /// This approach require n multiplications and n additions to evaluate the polynomial.\n ///\n /// # Arguments\n /// * `x` - The point at which to evaluate the polynomial.\n ///\n /// # Returns\n /// The value of the polynomial at point x: P(x).\n pub fn eval(self, x: Field) -> Field {\n let mut result = self.coefficients[0];\n\n for i in 1..self.coefficients.len() {\n result = result * x + self.coefficients[i];\n }\n\n result\n }\n\n /// Performs range checking on polynomial coefficients using asymmetric bounds\n ///\n /// This function constrains all polynomial coefficients to be in the range [lower_bound, upper_bound].\n /// Similar to range_check_1bound, it uses a shifting technique to avoid negative numbers:\n /// 1. Shifts each coefficient by adding -lower_bound: c' = c - lower_bound\n /// 2. Checks that shifted coefficients are in [0, upper_bound - lower_bound]\n /// 3. This ensures original coefficients are in [lower_bound, upper_bound]\n ///\n /// Set `BIT` to the bit-length of the total range `upper_bound - lower_bound`\n /// (choose `BIT` so `upper_bound - lower_bound < 2^BIT`). Since all checked values lie in\n /// `[0, upper_bound - lower_bound]`, they cannot exceed `BIT + 1` bits, which is\n /// why we use `assert_max_bit_size::()`.\n ///\n /// # Arguments\n /// * `upper_bound` - The upper bound for coefficient range checking\n /// * `lower_bound` - The lower bound for coefficient range checking (must be positive Field value)\n /// Coefficients must satisfy: lower_bound <= c <= upper_bound\n pub fn range_check_2bounds(self, upper_bound: Field, lower_bound: Field) {\n let range_size = lower_bound + upper_bound;\n\n for i in 0..self.coefficients.len() {\n let shifted_coefficient = self.coefficients[i] + lower_bound;\n\n shifted_coefficient.assert_max_bit_size::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\n }\n }\n}\n\n/// Compute hex-aligned packing parameters for a given `BIT`.\n///\n/// # Purpose\n/// Returns `(nibble_bits, group)` for use by packer/flatten so layout stays consistent.\n/// - `nibble_bits`: ceil (`BIT`) to the next multiple of 4 (nibble alignment).\n/// - Examples: `BIT = 7 -> 8`, `BIT = 8 -> 8`, `BIT = 9 -> 12`, `BIT = 10 -> 12`, `BIT = 11 -> 12`,\n/// `BIT=16 -> 16`, `BIT = 17 -> 20`.\n/// - `group`: max number of encoded limbs that fit in one BN254 field element,\n/// when each limb uses an extra 4 bits (see below).\n///\n/// # Rationale\n/// - We align to nibbles so powers of two are hex-friendly and deterministic.\n/// - We reserve one extra nibble (4 bits) per stored value to lift signed\n/// coefficients into the non-negative range (e.g., store `v + 2^nibble_bits`),\n/// which implies a radix of `2^(nibble_bits + 4)`.\n///\n/// # Safety\n/// - Asserts `nibble_bits + 4 <= 254` to avoid mod-p wrap on BN254.\n/// - Ensures at least one limb fits: `group >= 1`.\nfn packing_layout() -> (u32, u32) {\n // Ceil BIT up to the next multiple of 4 (nibble alignment).\n let nibble_bits = ((BIT + 3) / 4) * 4;\n\n // Each stored limb uses an extra nibble because negative coefficients\n // will be shifted to positive, so radix = 2^(nibble_bits+4).\n assert(nibble_bits + 4 <= 254);\n\n // Maximum limbs that fit in one BN254 element without wrap.\n let group = 254 / (nibble_bits + 4);\n assert(group >= 1);\n (nibble_bits, group)\n}\n\n/// Flatten `L` polynomials into a single linear stream of packed `Field` carriers.\n///\n/// ## What this does\n/// - For each CRT limb `j` in `0..L`, it packs the coefficients of `poly[j]`\n/// with `packer::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` and must match what `packer` uses.\n///\n/// ## Determinism & order\n/// - Preserves a stable order: iterate `j = 0..L`, then for each `j` append\n/// carriers in ascending chunk index `i = 0..num_chunks`.\n/// - This ensures transcripts remain deterministic across runs.\n///\n/// ## Generics\n/// - `A`: polynomial degree (number of coefficients per polynomial).\n/// - `L`: number of CRT bases (polynomials).\n/// - `BIT`: per-coefficient bit bound used by the packing layout (compile-time).\n///\n/// ## Returns\n/// - The same `inputs` vector, extended with all carriers in deterministic order.\npub fn flatten(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = packer::(poly[j].coefficients);\n\n // Append carriers in-order to `inputs` to keep a stable transcript layout.\n for i in 0..packed.len() {\n inputs.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\n/// - Encodes each value as a limb `digit = v + 2^nibble_bits` and concatenates\n/// limbs in base `radix = 2^(nibble_bits + 4)` (one extra nibble of headroom).\n/// - Packs up to `group` limbs per carrier (fits within BN254 254-bit capacity).\n/// - Pads the last, partial carrier with `digit = 2^nibble_bits` to keep a stable layout.\n///\n/// ## Determinism & order\n/// - Processes values in increasing index order and emits carriers in chunk order\n/// (`chunk = 0..num_chunks`). Padding is deterministic.\n///\n/// ## Generics\n/// - `A`: number of input values.\n/// - `BIT`: per-value bit bound; rounded up to `nibble_bits` by `packing_layout`.\n///\n/// ## Preconditions / Notes\n/// - Call with the raw coefficients whose magnitudes already satisfy the BIT bound\n/// (as enforced by the upstream range checks); `packer` performs the signed -> unsigned\n/// shift internally via `v + base`.\n/// - `group >= 1` is enforced by `packing_layout::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn packer(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\n\n let base = 2.pow_32(nibble_bits as Field); // 2^nibble_bits\n let radix = 2.pow_32((nibble_bits + 4) as Field); // 2^(nibble_bits + 4)\n\n // Number of chunks to emit: ceil(A / group).\n let num_chunks = (A + group - 1) / group;\n let mut out = Vec::new();\n\n // Process in fixed-size chunks of `group` limbs.\n for chunk in 0..num_chunks {\n // How many real values go into this chunk.\n let remain = A - (chunk * group);\n let take = if remain < group { remain } else { group };\n\n // Build field element accumulator (big-endian concatenation in `radix`).\n let mut acc = 0;\n for i in 0..take {\n let v = values[chunk * group + i];\n acc = acc * radix + (v + base);\n }\n\n // Pad remaining limb slots with the canonical zero-limb `digit = base`.\n for _ in 0..(group - take) {\n acc = acc * radix + base;\n }\n\n out.push(acc);\n }\n out\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert_eq(result, 11);\n}\n\n#[test]\nfn test_polynomial_eval_zero() {\n let coeffs = [1, -2, 1]; // x^2 - 2x + 1 = (x-1)^2\n let poly = Polynomial::new(coeffs);\n\n let x = 1; // evaluate at x = 1, should be 0\n let result = poly.eval(x);\n\n assert_eq(result, 0);\n}\n\n#[test]\nfn test_polynomial_bounds() {\n let coeffs = [-16, 240, 242];\n let poly = Polynomial::new(coeffs);\n\n // Test double bounds check - constrains to [-240, 242]\n poly.range_check_2bounds::<8>(242, 240);\n}\n\n#[test(should_fail_with = \"assert_max_bit_size\")]\nfn test_polynomial_out_of_bounds_coefficients() {\n let coeffs = [-100];\n let poly = Polynomial::new(coeffs);\n\n // Test double bounds check - constrains to [-98, 99]\n // Should fail because -100 is out of bounds.\n poly.range_check_2bounds::<7>(99, 98);\n}\n\n#[test]\nfn test_flatten() {\n // Create test polynomials\n let poly1 = Polynomial::new([1, 2, 3]); // degree 2\n let poly2 = Polynomial::new([4, -16, 6]); // degree 2\n let poly3 = Polynomial::new([-7, 8, 9]); // degree 2\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 4>(inputs, polynomials);\n\n // Verify the flattened coefficients are in the correct positions\n // Every value shifted 1 nibble incase of negative integers\n assert_eq(result.get(0), 0x11121310101010101010101010101010101010101010101010101010101010);\n assert_eq(result.get(1), 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert_eq(result.get(2), 0x09181910101010101010101010101010101010101010101010101010101010); // -7 became 09 at 0x 09 18 19(16 - 7 = 9)\n}\n\n#[test]\nfn test_flatten_big() {\n // Create test polynomials\n let poly1 = Polynomial::new([\n 1791218451968394,\n 21888242871839275222246405745257275088548364400416034343698198265248580087864,\n 21888242871839275222246405745257275088548364400416034343698200542108324633466,\n 5430119342984413,\n 704811298945172,\n 8901715723925099,\n 21888242871839275222246405745257275088548364400416034343698203098124042812559,\n 21888242871839275222246405745257275088548364400416034343698200215091693880034,\n ]);\n let poly2 = Polynomial::new([\n 21888242871839275222246405745257275088548364400416034343698200314078269634250,\n 21888242871839275222246405745257275088548364400416034343698200967285641915872,\n 2909990636858607,\n 7896103832076587,\n 2078397209533893,\n 21888242871839275222246405745257275088548364400416034343698199792421452734531,\n 614400389245817,\n 8290314119277588,\n ]);\n let poly3 = Polynomial::new([\n 21888242871839275222246405745257275088548364400416034343698201373175279892906,\n 21888242871839275222246405745257275088548364400416034343698201087241869723721,\n 6768789983786188,\n 635797784303388,\n 7610153424227556,\n 4633893206538324,\n 2016269760615332,\n 21888242871839275222246405745257275088548364400416034343698201007080554428142,\n ]);\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 54>(inputs, polynomials);\n\n // Verify the flattened coefficients are in the correct positions\n // Every value shifted 1 nibble incase of negative integers\n\n // For the first index of result operation goes like this,\n\n // First four index of poly1\n // 1791218451968394,\n // 21888242871839275222246405745257275088548364400416034343698198265248580087864,\n // 21888242871839275222246405745257275088548364400416034343698200542108324633466,\n // 5430119342984413,\n\n // base + 1791218451968394 = 0x1065d1a8b8b718a\n // base - 5921327228407753 = 0xeaf69591f3b037 (negative coefficient shifted)\n // base - 3644467483862151 = 0xf30d604a3a9b79 (negative coefficient shifted)\n // base + 5430119342984413 = 0x1134aaa2e86ccdd\n assert_eq(result.get(0), 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert_eq(result.get(1), 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert_eq(result.get(2), 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert_eq(result.get(3), 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert_eq(result.get(4), 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert_eq(result.get(5), 0x11b0964eb898ce411076805680b85410729c962da53a40f4b44412d0f6ed);\n}\n\n#[test]\nfn test_flatten_small() {\n // Create test polynomials\n let poly1 = Polynomial::new([712345, 104857, 999999, 500001, 123, 654321, 77]);\n let poly2 = Polynomial::new([1, 524287, 888888, 23456, 34567, 765432, 0]);\n let poly3 = Polynomial::new([444444, 333333, 222222, 111111, 987654, 246810, 13579]);\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert_eq(result.get(0), 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert_eq(result.get(1), 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert_eq(result.get(2), 0x16c81c15161513640e11b2071f120613c41a10350b100000100000100000);\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave-2/circuits/crates/libs/polynomial/src/lib.nr" - }, - "66": { - "source": "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse poseidon::poseidon2_permutation;\nuse sha256::sha256_var;\n\n/// SAFE (Sponge API for Field Elements)\n///\n/// This module provides a complete implementation of the SAFE API in Noir as defined in:\n/// \"SAFE (Sponge API for Field Elements) - A Toolbox for ZK Hash Applications\"\n/// see https://hackmd.io/bHgsH6mMStCVibM_wYvb2w#22-Sponge-state for more details.\n///\n/// SAFE provides a unified interface for cryptographic sponge functions that can be\n/// instantiated with various permutations to create hash functions, MACs, authenticated\n/// encryption schemes, and other cryptographic primitives for ZK proof systems.\n///\n/// This implementation follows the SAFE specification exactly, providing:\n/// - Complete API: START, ABSORB, SQUEEZE, FINISH operations.\n/// - Full security: Domain separation, tag computation, IO pattern validation.\n/// - Poseidon2 integration: Field-friendly permutation for ZK systems.\n/// - Specification compliance: All operations follow SAFE spec 2.4 exactly.\n/// - Natural API design: Variable-length inputs, automatic length detection from IO patterns.\n///\n/// # API Design\n///\n/// The API is designed for natural usage while maintaining type safety:\n/// - `absorb(input: [Field])`: Accepts variable-length arrays, no padding required.\n/// - `squeeze()`: Returns a vector with field element(s).\n/// - IO patterns automatically determine operation lengths for validation.\n\n/// Rate parameter for the sponge construction (number of field elements that can be absorbed per permutation call).\nglobal RATE: u32 = 3;\n\n/// Capacity parameter for the sponge construction (security parameter, typically 1-2 field elements).\nglobal CAPACITY: u32 = 1;\n\n/// Total state size (rate + capacity) in field elements.\nglobal STATE_SIZE: u32 = RATE + CAPACITY;\n\n/// IO Pattern encoding constants (from SAFE spec 2.3).\n///\n/// These constants are used for encoding operation types in the 32-bit word format:\n/// - MSB set to 1 for ABSORB operations\n/// - MSB set to 0 for SQUEEZE operations\n\n/// Flag for ABSORB operations (MSB = 1)\nglobal ABSORB_FLAG: u32 = 0x80000000;\n\n/// Flag for SQUEEZE operations (MSB = 0)\nglobal SQUEEZE_FLAG: u32 = 0x00000000;\n\n/// SAFE Sponge State (following spec 2.2)\n///\n/// The sponge state consists of the permutation state, tag, position counters,\n/// and IO pattern tracking as defined in the SAFE specification.\n///\n/// # Generic Parameters\n/// - `L`: The length of the IO pattern array\n///\n/// # Fields\n/// - `state`: Permutation state V in F^n (rate + capacity elements)\n/// - `tag`: Parameter tag T used for instance differentiation\n/// - `absorb_pos`: Current absorb position (<= n-c)\n/// - `squeeze_pos`: Current squeeze position (<= n-c)\n/// - `io_pattern`: Expected IO pattern for validation (encoded 32-bit words)\n/// - `io_count`: Current operation count for pattern tracking\npub struct SafeSponge {\n /// Permutation state V in F^n (rate + capacity elements).\n state: [Field; STATE_SIZE],\n /// Parameter tag T used for instance differentiation.\n tag: Field,\n /// Current absorb position (<= n-c).\n absorb_pos: u32,\n /// Current squeeze position (<= n-c).\n squeeze_pos: u32,\n /// Expected IO pattern for validation.\n io_pattern: [u32; L],\n /// Current operation count for pattern tracking (spec 2.4: io_count).\n io_count: u32,\n}\n\nimpl SafeSponge {\n /// Initializes a new SAFE sponge instance with the given IO pattern and domain separator (following spec 2.4).\n ///\n /// # Arguments\n /// - `io_pattern`: Array of 32-bit encoded operations defining the expected sequence of ABSORB/SQUEEZE calls.\n /// Each word has MSB=1 for ABSORB operations, MSB=0 for SQUEEZE operations.\n /// - `domain_separator`: 64-byte domain separator for cross-protocol security.\n ///\n /// # Returns\n /// A new `SafeSponge` instance with initialized state\n pub fn start(io_pattern: [u32; L], domain_separator: [u8; 64]) -> SafeSponge {\n // Compute tag from IO pattern and domain separator (spec 2.3).\n let tag = compute_tag(io_pattern, domain_separator);\n\n let mut state = [0; STATE_SIZE];\n // Initialize capacity with tag (spec 2.4).\n // Add T to the first 128 bits of the state.\n state[0] = tag;\n\n SafeSponge { state, tag, absorb_pos: 0, squeeze_pos: 0, io_pattern, io_count: 0 }\n }\n\n /// Absorbs field elements into the sponge state, interleaving permutation calls as needed (following spec 2.4).\n ///\n /// The number of elements to absorb is automatically validated against the IO pattern.\n /// This method accepts variable-length arrays, making it natural to use without padding.\n ///\n /// # Arguments\n /// - `input`: Array of field elements to absorb (variable length, must match IO pattern)\n pub fn absorb(&mut self, input: Vec) {\n let length = input.len() as u32;\n\n // Validate against IO pattern.\n assert(self.io_count < L);\n\n // Parse expected operation from io_pattern (encoded word)\n let expected_encoded_word = self.io_pattern[self.io_count];\n let is_expected_absorb = (expected_encoded_word & ABSORB_FLAG) != 0;\n let expected_length = expected_encoded_word & 0x7FFFFFFF;\n\n // Validate operation type and length\n assert(is_expected_absorb, \"Expected ABSORB operation\");\n assert(expected_length == length, \"Length mismatch\");\n\n // Process each element naturally (no unnecessary iterations).\n for i in 0..length {\n // If absorb_pos == (n-c) then permute and reset (spec 2.4).\n if self.absorb_pos == RATE {\n // n-c = RATE.\n self.state = self.permute();\n self.absorb_pos = 0;\n }\n\n // Add X[i] to state at absorb_pos (spec 2.4).\n // Note: absorb_pos is the rate position, not capacity position.\n self.state[self.absorb_pos + CAPACITY] =\n self.state[self.absorb_pos + CAPACITY] + input.get(i);\n self.absorb_pos += 1;\n }\n\n // Verify that the encoded word matches the expected pattern.\n let encoded_word = ABSORB_FLAG | length;\n assert(encoded_word == expected_encoded_word);\n\n self.io_count += 1;\n\n // Force permute at start of next SQUEEZE (spec 2.4).\n self.squeeze_pos = RATE;\n }\n\n /// Extracts field elements from the sponge state, interleaving permutation calls as needed (following spec 2.4).\n ///\n /// The number of elements to squeeze is automatically determined from the IO pattern.\n pub fn squeeze(&mut self) -> Vec {\n // Parse expected operation from io_pattern (encoded word)\n let expected_encoded_word = self.io_pattern[self.io_count];\n let is_expected_squeeze = (expected_encoded_word & ABSORB_FLAG) == 0;\n let length = expected_encoded_word & 0x7FFFFFFF;\n\n // Validate operation type\n assert(is_expected_squeeze, \"Expected SQUEEZE operation\");\n\n let mut output = Vec::new();\n\n // SQUEEZE implementation following spec 2.4.\n // If length==0, loop won't execute (spec 2.4).\n for _ in 0..length {\n // If squeeze_pos==(n-c) then permute and reset (spec 2.4).\n if self.squeeze_pos == RATE {\n // n-c = RATE.\n self.state = self.permute();\n self.squeeze_pos = 0;\n self.absorb_pos = 0;\n }\n // Set Y[i] to state element at squeeze_pos (spec 2.4).\n output.push(self.state[self.squeeze_pos + CAPACITY]);\n self.squeeze_pos += 1;\n }\n\n // Verify that the encoded word matches the expected pattern.\n let encoded_word = SQUEEZE_FLAG | length;\n assert(encoded_word == expected_encoded_word);\n\n self.io_count += 1;\n output\n }\n\n /// Finalizes the sponge instance, verifying that all expected operations have been performed and clearing the internal state for security (following spec 2.4).\n ///\n /// This function is used to ensure that the sponge instance has been used correctly and to prevent information leakage.\n pub fn finish(&mut self) {\n // Check that io_count equals the length of the IO pattern expected (spec 2.4).\n assert(self.io_count == L, \"IO pattern not completed\");\n\n // Erase the state and its variables (spec 2.4).\n self.state = [0; STATE_SIZE];\n self.absorb_pos = 0;\n self.squeeze_pos = 0;\n self.io_count = 0;\n }\n\n /// Permute the state using Poseidon2 (following spec 2.4).\n ///\n /// Applies the Poseidon2 permutation to the current state.\n /// This is the core cryptographic primitive of the sponge construction.\n ///\n /// # Returns\n /// New state after permutation\n fn permute(self) -> [Field; STATE_SIZE] {\n poseidon2_permutation(self.state, STATE_SIZE)\n }\n}\n\n/// Computes a unique tag for a sponge instance based on its IO pattern and domain separator.\n/// The tag is used to ensure that distinct instances behave like distinct functions.\n///\n/// # Arguments\n/// - `io_pattern`: Array of 32-bit encoded operations defining the sponge's usage pattern.\n/// Each word has MSB=1 for ABSORB operations, MSB=0 for SQUEEZE operations.\n/// - `domain_separator`: 64-byte domain separator for cross-protocol security.\n///\n/// # Returns\n/// A field element representing the 128-bit tag.\npub fn compute_tag(io_pattern: [u32; L], domain_separator: [u8; 64]) -> Field {\n // Step 1: Parse and aggregate consecutive operations of the same type\n let mut encoded_words = [0; L]; // Support up to L operations.\n let mut word_count = 0;\n let mut current_absorb_sum = 0;\n let mut current_squeeze_sum = 0;\n let mut last_was_absorb = false;\n\n for i in 0..L {\n if io_pattern[i] > 0 {\n // Parse operation type from MSB and length from lower 31 bits\n let is_absorb = (io_pattern[i] & ABSORB_FLAG) != 0;\n let length = io_pattern[i] & 0x7FFFFFFF; // Clear MSB to get length\n\n if is_absorb {\n if last_was_absorb {\n // Aggregate consecutive ABSORB operations\n current_absorb_sum += length;\n } else {\n // Start new ABSORB sequence\n if current_squeeze_sum > 0 {\n // Flush previous SQUEEZE sequence\n encoded_words[word_count] = SQUEEZE_FLAG | current_squeeze_sum;\n word_count += 1;\n current_squeeze_sum = 0;\n }\n current_absorb_sum = length;\n }\n last_was_absorb = true;\n } else {\n if !last_was_absorb {\n // Aggregate consecutive SQUEEZE operations\n current_squeeze_sum += length;\n } else {\n // Start new SQUEEZE sequence\n if current_absorb_sum > 0 {\n // Flush previous ABSORB sequence\n encoded_words[word_count] = ABSORB_FLAG | current_absorb_sum;\n word_count += 1;\n current_absorb_sum = 0;\n }\n current_squeeze_sum = length;\n }\n last_was_absorb = false;\n }\n }\n }\n\n // Flush remaining operations\n if current_absorb_sum > 0 {\n encoded_words[word_count] = ABSORB_FLAG | current_absorb_sum;\n word_count += 1;\n }\n if current_squeeze_sum > 0 {\n encoded_words[word_count] = SQUEEZE_FLAG | current_squeeze_sum;\n word_count += 1;\n }\n\n // Step 2: Serialize to byte string and append domain separator (following SAFE spec 2.3).\n // Create a fixed-size array for SHA256 input (max 256 bytes should be enough).\n let mut input_bytes = [0; 256];\n let mut byte_count = 0;\n\n // Serialize encoded words to bytes (big-endian as per SAFE spec).\n for i in 0..word_count {\n if byte_count + 4 <= 256 {\n let word = encoded_words[i];\n input_bytes[byte_count] = (word >> 24) as u8;\n input_bytes[byte_count + 1] = (word >> 16) as u8;\n input_bytes[byte_count + 2] = (word >> 8) as u8;\n input_bytes[byte_count + 3] = word as u8;\n byte_count += 4;\n }\n }\n\n // Append domain separator.\n for i in 0..64 {\n if byte_count + i < 256 {\n input_bytes[byte_count + i] = domain_separator[i];\n }\n }\n byte_count += 64;\n\n // Step 3: Hash with SHA256 and truncate to 128 bits (following SAFE spec 2.3).\n let hash_bytes = sha256_var(input_bytes, byte_count as u64);\n\n // Convert first 128 bits (16 bytes) to field element.\n let mut tag_value: Field = 0;\n for i in 0..16 {\n tag_value = tag_value * 256 + (hash_bytes[i] as Field);\n }\n\n tag_value\n}\n\n#[test]\nfn test_safe_hashing() {\n // Verifies basic hash functionality with a simple ABSORB(3) + SQUEEZE(1) pattern.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = Vec::from_slice(&[1, 2, 3]);\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(elements);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(0) != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(elements);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2.get(0) != 0);\n}\n\n#[test]\nfn test_merkle_node() {\n // Verifies SAFE can be used for Merkle tree node hashing with pattern ABSORB(1) + ABSORB(1) + SQUEEZE(1).\n // Tests the ability to absorb multiple inputs before squeezing output.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let left = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\n\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(left);\n sponge.absorb(right);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(0) != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(left);\n sponge2.absorb(right);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2.get(0) != 0);\n}\n\n#[test]\nfn test_commitment_scheme() {\n // Verifies SAFE can be used for commitment schemes with pattern ABSORB(3) + SQUEEZE(1).\n // Tests the ability to create deterministic commitments from multiple field elements.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let values = Vec::from_slice([10, 20, 30]);\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(values);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(0) != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(values);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2.get(0) != 0);\n}\n\n#[test]\nfn test_domain_separation() {\n // Verifies that different domain separators produce different outputs for the same input.\n // This is crucial for cross-protocol security and preventing collisions between different applications.\n let elements = Vec::from_slice([1, 2, 3]);\n let domain1 = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let domain2 = [\n 0x41, 0x42, 0x43, 0x45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n\n let mut sponge1 = SafeSponge::start(io_pattern, domain1);\n sponge1.absorb(elements);\n let output1 = sponge1.squeeze();\n sponge1.finish();\n\n let mut sponge2 = SafeSponge::start(io_pattern, domain2);\n sponge2.absorb(elements);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output1.len() == 1);\n assert(output2.len() == 1);\n assert(output1.get(0) != output2.get(0)); // Different domain separators should produce different outputs\n}\n\n#[test]\nfn test_multiple_squeeze() {\n // Verifies that multiple field elements can be squeezed in a single operation.\n // Tests pattern ABSORB(3) + SQUEEZE(2) to ensure proper state management.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = Vec::from_slice([1, 2, 3]);\n\n // Pattern: ABSORB(3), SQUEEZE(2)\n let io_pattern = [0x80000003, 0x00000002];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(elements);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 2);\n assert(output.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(1)); // Different squeeze outputs should be different\n}\n\n#[test]\nfn test_zero_length_operations() {\n // Verifies that zero-length ABSORB and SQUEEZE operations are handled correctly.\n // Tests pattern ABSORB(0) + SQUEEZE(1) to ensure proper state transitions.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Pattern: ABSORB(0), SQUEEZE(1)\n let io_pattern = [0x80000000, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(0) != 0);\n}\n\n#[test]\nfn test_tag_computation() {\n // Verifies the tag computation algorithm using the example from the SAFE specification.\n // Pattern: ABSORB(3), ABSORB(3), SQUEEZE(3)\n // Should aggregate to: ABSORB(6), SQUEEZE(3)\n // Encoded as: [0x80000006, 0x00000003]\n // Tests determinism and pattern differentiation.\n\n let io_pattern = [0x80000003, 0x80000003, 0x00000003];\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test determinism\n let tag2 = compute_tag(io_pattern, domain_separator);\n assert(tag == tag2);\n\n // Test that different patterns produce different tags\n let io_pattern2 = [0x80000003, 0x00000003]; // ABSORB(3), SQUEEZE(3) - different pattern\n let tag3 = compute_tag(io_pattern2, domain_separator);\n assert(tag != tag3);\n}\n\n#[test]\nfn test_tag_computation_debug() {\n println(\"=== SAFE Tag Computation Debug Test ===\");\n\n // Test your specific pattern [2, 2, 2] (ABSORB(2), SQUEEZE(2), ABSORB(2))\n let io_pattern = [0x80000002, 0x00000002, 0x80000002];\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n println(f\"Testing pattern: {io_pattern}\");\n println(\n f\"Expected to aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(2)\",\n );\n println(\n f\"Expected encoded words: [0x80000002, 0x00000002, 0x80000002]\",\n );\n println(\"\");\n\n let tag = compute_tag(io_pattern, domain_separator);\n\n println(f\"=== Expected Rust Output ===\");\n println(\"Pattern [2, 2, 2] (ABSORB(2), SQUEEZE(2), ABSORB(2))\");\n println(\"Domain separator: 0x41424344...\");\n println(\"Tag: 0xce3bb9ee4b2d41c42e9cdda38afe8b6a\");\n println(\"\");\n\n println(f\"=== Noir Output ===\");\n println(f\"Tag: {tag}\");\n println(\"\");\n\n println(\"Compare the tag values above with Rust script!\");\n}\n\n#[test]\nfn test_consecutive_absorb_aggregation() {\n // Test that consecutive ABSORB operations are properly aggregated\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1) should aggregate to ABSORB(2), SQUEEZE(1)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), ABSORB(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001];\n\n // This should aggregate to: ABSORB(2), SQUEEZE(1) = [0x80000002, 0x00000001]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag ABSORB(2), SQUEEZE(1)\n let aggregated_pattern = [0x80000002, 0x00000001];\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(tag == aggregated_tag, \"Consecutive ABSORB operations should aggregate to the same tag\");\n\n // Test that a different pattern produces a different tag\n let different_pattern = [0x80000001, 0x00000001, 0x80000001]; // ABSORB(1), SQUEEZE(1), ABSORB(1)\n let different_tag = compute_tag(different_pattern, domain_separator);\n\n // This should be different because it doesn't have consecutive ABSORB operations\n assert(tag != different_tag, \"Different patterns should produce different tags\");\n\n println(\"=== Consecutive ABSORB Aggregation Test ===\");\n println(\n f\"Original pattern: [0x80000001, 0x80000001, 0x00000001] (ABSORB(1), ABSORB(1), SQUEEZE(1))\",\n );\n println(\n f\"Aggregated pattern: [0x80000002, 0x00000001] (ABSORB(2), SQUEEZE(1))\",\n );\n println(f\"Original tag: {tag}\");\n println(f\"Aggregated tag: {aggregated_tag}\");\n println(f\"Original tag: {tag}\");\n println(f\"Aggregated tag: {aggregated_tag}\");\n println(f\"Different pattern tag: {different_tag}\");\n}\n\n#[test]\nfn test_consecutive_squeeze_aggregation() {\n // Test that consecutive SQUEEZE operations are properly aggregated\n // Pattern: ABSORB(1), SQUEEZE(1), SQUEEZE(1) should aggregate to ABSORB(1), SQUEEZE(2)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), SQUEEZE(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x00000001, 0x00000001];\n\n // This should aggregate to: ABSORB(1), SQUEEZE(2) = [0x80000001, 0x00000002]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag ABSORB(1), SQUEEZE(2)\n let aggregated_pattern = [0x80000001, 0x00000002];\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(\n tag == aggregated_tag,\n \"Consecutive SQUEEZE operations should aggregate to the same tag\",\n );\n\n // Test that a different pattern produces a different tag\n let different_pattern = [0x80000001, 0x00000001, 0x80000001]; // ABSORB(1), SQUEEZE(1), ABSORB(1)\n let different_tag = compute_tag(different_pattern, domain_separator);\n\n // This should be different because it doesn't have consecutive SQUEEZE operations\n assert(tag != different_tag, \"Different patterns should produce different tags\");\n\n println(\"=== Consecutive SQUEEZE Aggregation Test ===\");\n println(\n f\"Original pattern: [0x80000001, 0x00000001, 0x00000001] (ABSORB(1), SQUEEZE(1), SQUEEZE(1))\",\n );\n println(\n f\"Aggregated pattern: [0x80000001, 0x00000002] (ABSORB(1), SQUEEZE(2))\",\n );\n println(f\"Original tag: {tag}\");\n println(f\"Aggregated tag: {aggregated_tag}\");\n println(f\"Different pattern tag: {different_tag}\");\n}\n\n#[test]\nfn test_mixed_consecutive_aggregation() {\n // Test that both consecutive ABSORB and SQUEEZE operations are properly aggregated\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1)\n // Should aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(1)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001, 0x00000001, 0x80000001];\n\n // This should aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(1) = [0x80000002, 0x00000002, 0x80000001]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag\n let aggregated_pattern = [0x80000002, 0x00000002, 0x80000001]; // ABSORB(2), SQUEEZE(2), ABSORB(1)\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(tag == aggregated_tag, \"Mixed consecutive operations should aggregate to the same tag\");\n\n println(\"=== Mixed Consecutive Aggregation Test ===\");\n println(\n f\"Original pattern: [0x80000001, 0x80000001, 0x00000001, 0x00000001, 0x80000001]\",\n );\n println(\n f\" (ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1))\",\n );\n println(f\"Aggregated pattern: [0x80000002, 0x00000002, 0x80000001]\");\n println(f\" (ABSORB(2), SQUEEZE(2), ABSORB(1))\");\n println(f\"Original tag: {tag}\");\n println(f\"Aggregated tag: {aggregated_tag}\");\n}\n", - "path": "/Users/omardesogus/Projects/Enclave/enclave-2/circuits/crates/libs/safe/src/lib.nr" - }, - "73": { - "source": "use std::hash::sha256_compression;\nuse std::runtime::is_unconstrained;\n\nuse constants::{\n BLOCK_BYTE_PTR, BLOCK_SIZE, HASH, INITIAL_STATE, INT_BLOCK, INT_BLOCK_SIZE, INT_SIZE,\n INT_SIZE_PTR, MSG_BLOCK, MSG_SIZE_PTR, STATE, TWO_POW_16, TWO_POW_24, TWO_POW_32, TWO_POW_8,\n};\n\npub(crate) mod constants;\nmod tests;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n digest(input)\n}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest(msg: [u8; N]) -> HASH {\n sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var(msg: [u8; N], message_size: u64) -> HASH {\n let message_size = message_size as u32;\n assert(message_size <= N);\n\n if std::runtime::is_unconstrained() {\n // Safety: SHA256 is running as an unconstrained function.\n unsafe {\n __sha256_var(msg, message_size)\n }\n } else {\n let (mut h, mut msg_block, mut msg_byte_ptr) =\n process_full_blocks(msg, message_size, INITIAL_STATE);\n\n finalize_sha256_blocks(msg, message_size, N, h, msg_block, msg_byte_ptr)\n }\n}\n\npub(crate) unconstrained fn __sha_var(\n msg: [u8; N],\n message_size: u32,\n initial_state: STATE,\n) -> HASH {\n let num_full_blocks = message_size / BLOCK_SIZE;\n // Intermediate hash, starting with the canonical initial value\n let mut h: STATE = initial_state;\n // Pointer into msg_block on a 64 byte scale\n for i in 0..num_full_blocks {\n let (msg_block, _) = build_msg_block(msg, message_size, BLOCK_SIZE * i);\n h = sha256_compression(msg_block, h);\n }\n\n // Handle setup of the final msg block.\n // This case is only hit if the msg is less than the block size,\n // or our message cannot be evenly split into blocks.\n\n finalize_last_sha256_block(h, message_size, msg)\n}\n\n// Helper function to finalize the message block with padding and length\npub(crate) unconstrained fn finalize_last_sha256_block(\n mut h: STATE,\n message_size: u32,\n msg: [u8; N],\n) -> HASH {\n let modulo = message_size % BLOCK_SIZE;\n let (mut msg_block, mut msg_byte_ptr): (INT_BLOCK, u32) = if modulo != 0 {\n let num_full_blocks = message_size / BLOCK_SIZE;\n let msg_start = BLOCK_SIZE * num_full_blocks;\n let (new_msg_block, new_msg_byte_ptr) = build_msg_block(msg, message_size, msg_start);\n (new_msg_block, new_msg_byte_ptr)\n } else {\n // If we had modulo == 0 then it means the last block was full,\n // and we can reset the pointer to zero to overwrite it.\n ([0; INT_BLOCK_SIZE], 0)\n };\n\n // Pad the rest such that we have a [u32; 2] block at the end representing the length\n // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n // Here we rely on the fact that everything beyond the available input is set to 0.\n let index = msg_byte_ptr / INT_SIZE;\n msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n // If we don't have room to write the size, compress the block and reset it.\n let (h, mut msg_byte_ptr): (STATE, u32) = if msg_byte_ptr >= MSG_SIZE_PTR {\n // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n (sha256_compression(msg_block, h), 0)\n } else {\n (h, msg_byte_ptr + 1)\n };\n msg_block = attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size);\n\n hash_final_block(msg_block, h)\n}\n\n// Variable size SHA-256 hash\nunconstrained fn __sha256_var(msg: [u8; N], message_size: u32) -> HASH {\n __sha_var(msg, message_size, INITIAL_STATE)\n}\n\npub(crate) fn process_full_blocks(\n msg: [u8; N],\n message_size: u32,\n mut h: STATE,\n) -> (STATE, MSG_BLOCK, u32) {\n let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n let mut msg_byte_ptr = 0;\n let num_blocks = N / BLOCK_SIZE;\n for i in 0..num_blocks {\n let msg_start = BLOCK_SIZE * i;\n let (new_msg_block, new_msg_byte_ptr) =\n // Safety: separate verification function\n unsafe { build_msg_block(msg, message_size, msg_start) };\n\n if msg_start < message_size {\n msg_block = new_msg_block;\n }\n\n // Verify the block we are compressing was appropriately constructed\n let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n if msg_start < message_size {\n msg_byte_ptr = new_msg_byte_ptr;\n }\n\n // If the block is filled, compress it.\n // An un-filled block is handled after this loop.\n if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n h = sha256_compression(msg_block, h);\n }\n }\n (h, msg_block, msg_byte_ptr)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\npub(crate) unconstrained fn build_msg_block(\n msg: [u8; N],\n message_size: u32,\n msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n let block_input = if message_size < msg_start {\n // This function is sometimes called with `msg_start` past the end of the message.\n // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n 0\n } else if message_size < msg_start + BLOCK_SIZE {\n message_size - msg_start\n } else {\n BLOCK_SIZE\n };\n\n // Figure out the number of items in the int array that we have to pack.\n // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n let int_input = (block_input + INT_SIZE - 1) / INT_SIZE;\n\n for i in 0..int_input {\n let mut msg_item: u32 = 0;\n // Always construct the integer as 4 bytes, even if it means going beyond the input.\n for j in 0..INT_SIZE {\n let k = i * INT_SIZE + j;\n let msg_byte = if k < block_input {\n msg[msg_start + k]\n } else {\n 0\n };\n msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n }\n msg_block[i] = msg_item;\n }\n\n // Returning the index as if it was a 64 byte array.\n // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block(\n msg: [u8; N],\n message_size: u32,\n msg_block: MSG_BLOCK,\n msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n let mut msg_byte_ptr = 0;\n let mut msg_end = msg_start + BLOCK_SIZE;\n if msg_end > N {\n msg_end = N;\n }\n // We might have to go beyond the input to pad the fields.\n if msg_end % INT_SIZE != 0 {\n msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n }\n\n // Reconstructed packed item.\n let mut msg_item: u32 = 0;\n\n // Inclusive at the end so that we can compare the last item.\n let mut i: u32 = 0;\n for k in msg_start..=msg_end {\n if k % INT_SIZE == 0 {\n // If we consumed some input we can compare against the block.\n if (msg_start < message_size) & (k > msg_start) {\n assert_eq(msg_block[i], msg_item as u32);\n i = i + 1;\n msg_item = 0;\n }\n }\n // Shift the accumulator\n msg_item = lshift8(msg_item, 1);\n // If we have input to consume, add it at the rightmost position.\n if k < message_size & k < msg_end {\n msg_item = msg_item + msg[k] as u32;\n msg_byte_ptr = msg_byte_ptr + 1;\n }\n }\n\n msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n // Check all the way to the end of the block.\n verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n msg_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n max_int_byte_ptr: u32,\n) {\n // This variable is used to get around the compiler under-constrained check giving a warning.\n // We want to check against a constant zero, but if it does not come from the circuit inputs\n // or return values the compiler check will issue a warning.\n let zero = msg_block[0] - msg_block[0];\n\n // First integer which is supposed to be (partially) zero.\n let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n // Check partial zeros.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n let zeros = INT_SIZE - modulo;\n let mask = if zeros == 3 {\n TWO_POW_24\n } else if zeros == 2 {\n TWO_POW_16\n } else {\n TWO_POW_8\n };\n assert_eq(msg_block[int_byte_ptr] % mask, zero);\n int_byte_ptr = int_byte_ptr + 1;\n }\n\n // Check the rest of the items.\n for i in 0..max_int_byte_ptr {\n if i >= int_byte_ptr {\n assert_eq(msg_block[i], zero);\n }\n }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n msg_block: MSG_BLOCK,\n last_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n // msg_byte_ptr is the position at which they are no longer have to be the same.\n // First integer which is supposed to be (partially) zero contains that pointer.\n let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n // Check partial zeros.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n // Reconstruct the partially zero item from the last block.\n let last_field = last_block[int_byte_ptr];\n let mut msg_item: u32 = 0;\n // Reset to where they are still equal.\n msg_byte_ptr = msg_byte_ptr - modulo;\n for i in 0..INT_SIZE {\n msg_item = lshift8(msg_item, 1);\n if i < modulo {\n msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n msg_byte_ptr = msg_byte_ptr + 1;\n }\n }\n assert_eq(msg_block[int_byte_ptr], msg_item);\n }\n\n for i in 0..INT_SIZE_PTR {\n if i < int_byte_ptr {\n assert_eq(msg_block[i], last_block[i]);\n }\n }\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\n#[inline_always]\nfn set_item_zeros(item: u32, zeros: u32) -> u32 {\n lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n let zeroed_item = set_item_zeros(msg_item, zeros);\n let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n // How many times do we have to shift to the right to get to the position we want?\n let max_shifts = INT_SIZE - 1;\n let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n msg_item = rshift8(msg_item, shifts);\n // At this point the byte we want is in the rightmost position.\n msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\n#[inline_always]\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n let mut msg_item = msg_byte as u32;\n // How many times do we have to shift to the left to get to the position we want?\n let max_shifts = INT_SIZE - 1;\n let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n lshift8(msg_item, shifts)\n}\n\n// Construct a field out of 4 bytes.\n#[inline_always]\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n let mut item = b0 as u32;\n item = lshift8(item, 1) + b1 as u32;\n item = lshift8(item, 1) + b2 as u32;\n item = lshift8(item, 1) + b3 as u32;\n item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\n#[inline_always]\nfn lshift8(item: u32, shifts: u32) -> u32 {\n if is_unconstrained() {\n // Brillig wouldn't shift 0<<4 without overflow.\n if shifts >= 4 {\n 0\n } else {\n item << (8 * shifts)\n }\n } else {\n // We can do a for loop up to INT_SIZE or an if-else.\n if shifts == 0 {\n item\n } else if shifts == 1 {\n item * TWO_POW_8\n } else if shifts == 2 {\n item * TWO_POW_16\n } else if shifts == 3 {\n item * TWO_POW_24\n } else {\n // Doesn't make sense, but it's most likely called on 0 anyway.\n 0\n }\n }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\n#[inline_always]\nfn rshift8(item: u32, shifts: u32) -> u32 {\n if is_unconstrained() {\n if 8 * shifts >= 32 {\n 0\n } else {\n item >> (8 * shifts)\n }\n } else {\n // Division wouldn't work on `Field`.\n if shifts == 0 {\n item\n } else if shifts == 1 {\n item / TWO_POW_8\n } else if shifts == 2 {\n item / TWO_POW_16\n } else if shifts == 3 {\n item / TWO_POW_24\n } else {\n 0\n }\n }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n mut msg_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n message_size: u32,\n) -> MSG_BLOCK {\n // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n // There can be one item which has to be partially zeroed.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n // Index of the block in which we find the item we need to partially zero.\n let i = msg_byte_ptr / INT_SIZE;\n let zeros = INT_SIZE - modulo;\n msg_block[i] = set_item_zeros(msg_block[i], zeros);\n msg_byte_ptr = msg_byte_ptr + zeros;\n }\n\n // The rest can be zeroed without bit shifting anything.\n for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n msg_block[i] = 0;\n }\n\n // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n let len = 8 * message_size;\n let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n msg_block[INT_SIZE_PTR] = (len_bytes[0] as u32) << 24\n | (len_bytes[1] as u32) << 16\n | (len_bytes[2] as u32) << 8\n | (len_bytes[3] as u32);\n\n msg_block[INT_SIZE_PTR + 1] = (len_bytes[4] as u32) << 24\n | (len_bytes[5] as u32) << 16\n | (len_bytes[6] as u32) << 8\n | (len_bytes[7] as u32);\n\n msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n msg_block: MSG_BLOCK,\n last_block: MSG_BLOCK,\n msg_byte_ptr: BLOCK_BYTE_PTR,\n message_size: u32,\n) {\n // Check zeros up to the size pointer.\n verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n // Check that up to the pointer we match the last block.\n verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n // We verify the message length was inserted correctly by reversing the byte decomposition.\n std::static_assert(\n INT_SIZE_PTR + 2 == INT_BLOCK_SIZE,\n \"INT_SIZE_PTR + 2 must equal INT_BLOCK_SIZE\",\n );\n let reconstructed_len_hi = msg_block[INT_SIZE_PTR] as Field;\n let reconstructed_len_lo = msg_block[INT_SIZE_PTR + 1] as Field;\n\n let reconstructed_len: Field =\n reconstructed_len_hi * TWO_POW_32 as Field + reconstructed_len_lo;\n let len = 8 * (message_size as Field);\n assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n // Hash final padded block\n state = sha256_compression(msg_block, state);\n\n // Return final hash as byte array\n for j in 0..8 {\n let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n for k in 0..4 {\n out_h[4 * j + k] = h_bytes[k];\n }\n }\n\n out_h\n}\n\npub(crate) fn finalize_sha256_blocks(\n msg: [u8; N],\n message_size: u32,\n total_len: u32,\n mut h: STATE,\n mut msg_block: MSG_BLOCK,\n mut msg_byte_ptr: u32,\n) -> HASH {\n let modulo = total_len % BLOCK_SIZE;\n // Handle setup of the final msg block.\n // This case is only hit if the msg is less than the block size,\n // or our message cannot be evenly split into blocks.\n if modulo != 0 {\n let num_blocks = total_len / BLOCK_SIZE;\n let msg_start = BLOCK_SIZE * num_blocks;\n let (new_msg_block, new_msg_byte_ptr) =\n // Safety: separate verification function\n unsafe { build_msg_block(msg, message_size, msg_start) };\n\n if msg_start < message_size {\n msg_block = new_msg_block;\n }\n\n let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n if msg_start < message_size {\n msg_byte_ptr = new_msg_byte_ptr;\n verify_msg_block_padding(msg_block, msg_byte_ptr);\n }\n }\n\n // If we had modulo == 0 then it means the last block was full,\n // and we can reset the pointer to zero to overwrite it.\n if msg_byte_ptr == BLOCK_SIZE {\n msg_byte_ptr = 0;\n }\n\n // Pad the rest such that we have a [u32; 2] block at the end representing the length\n // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n // Here we rely on the fact that everything beyond the available input is set to 0.\n let index = msg_byte_ptr / INT_SIZE;\n msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n msg_byte_ptr = msg_byte_ptr + 1;\n let last_block = msg_block;\n\n // If we don't have room to write the size, compress the block and reset it.\n if msg_byte_ptr > MSG_SIZE_PTR {\n h = sha256_compression(msg_block, h);\n\n // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n msg_byte_ptr = 0;\n }\n\n // Safety: separate verification function\n msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n\n hash_final_block(msg_block, h)\n}\n\n/**\n * Given some state of a partially computed sha256 hash and part of the preimage, continue hashing\n * @notice used for complex/ recursive offloading of post-partial hashing\n *\n * @param N - the maximum length of the message to hash\n * @param h - the intermediate hash state\n * @param msg - the preimage to hash\n * @param message_size - the actual length of the preimage to hash\n * @return the intermediate hash state after compressing in msg to h\n */\npub fn partial_sha256_var_interstitial(\n mut h: [u32; 8],\n msg: [u8; N],\n message_size: u32,\n) -> [u32; 8] {\n assert(message_size % BLOCK_SIZE == 0, \"Message size must be a multiple of the block size\");\n if std::runtime::is_unconstrained() {\n // Safety: running as an unconstrained function\n unsafe {\n __sha_partial_var_interstitial(h, msg, message_size)\n }\n } else {\n let (mut h, _, _) = process_full_blocks(msg, message_size, h);\n\n h\n }\n}\n\n/**\n * Given some state of a partially computed sha256 hash and remaining preimage, complete the hash\n * @notice used for traditional partial hashing\n *\n * @param N - the maximum length of the message to hash\n * @param h - the intermediate hash state\n * @param msg - the remaining preimage to hash\n * @param message_size - the size of the current chunk\n * @param real_message_size - the total size of the original preimage\n * @return finalized sha256 hash\n */\npub fn partial_sha256_var_end(\n mut h: [u32; 8],\n msg: [u8; N],\n message_size: u32,\n real_message_size: u32,\n) -> [u8; 32] {\n assert(message_size % BLOCK_SIZE == 0, \"Message size must be a multiple of the block size\");\n if std::runtime::is_unconstrained() {\n // Safety: running as an unconstrained function\n unsafe {\n h = __sha_partial_var_interstitial(h, msg, message_size);\n\n // Handle setup of the final msg block.\n // This case is only hit if the msg is less than the block size,\n // or our message cannot be evenly split into blocks.\n\n finalize_last_sha256_block(h, real_message_size, msg)\n }\n } else {\n let (mut h, mut msg_block, mut msg_byte_ptr) = process_full_blocks(msg, message_size, h);\n finalize_sha256_blocks(msg, real_message_size, N, h, msg_block, msg_byte_ptr)\n }\n}\n\nunconstrained fn __sha_partial_var_interstitial(\n mut h: [u32; 8],\n msg: [u8; N],\n message_size: u32,\n) -> [u32; 8] {\n let num_full_blocks = message_size / BLOCK_SIZE;\n // Intermediate hash, starting with the canonical initial value\n // Pointer into msg_block on a 64 byte scale\n for i in 0..num_full_blocks {\n let (msg_block, _) = build_msg_block(msg, message_size, BLOCK_SIZE * i);\n h = sha256_compression(msg_block, h);\n }\n h\n}\n\nmod equivalence_test {\n\n #[test]\n fn test_implementations_agree(msg: [u8; 100], message_size: u64) {\n let message_size = message_size % 100;\n // Safety: test function\n let unconstrained_sha = unsafe { super::__sha256_var(msg, message_size as u32) };\n let sha = super::sha256_var(msg, message_size);\n assert_eq(sha, unconstrained_sha);\n }\n}\n", - "path": "/Users/omardesogus/nargo/github.com/noir-lang/sha256/v0.2.0/src/sha256.nr" - } - }, - "expression_width": { "Bounded": { "width": 4 } } -} +{"noir_version":"1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663","hash":"12484941825572906809","abi":{"parameters":[{"name":"pk_commitment","type":{"kind":"field"},"visibility":"public"},{"name":"pk0is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"pk1is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"ct0is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"ct1is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"u","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"e0","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"e1","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"e0is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"e0_quotients","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"k1","type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":512,"type":{"kind":"field"}}}]},"visibility":"private"},{"name":"r1is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":1023,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"r2is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":511,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"p1is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":1023,"type":{"kind":"field"}}}]}},"visibility":"private"},{"name":"p2is","type":{"kind":"array","length":2,"type":{"kind":"struct","path":"lib::math::polynomial::Polynomial","fields":[{"name":"coefficients","type":{"kind":"array","length":511,"type":{"kind":"field"}}}]}},"visibility":"private"}],"return_type":null,"error_types":{"12469291177396340830":{"error_kind":"string","string":"call to assert_max_bit_size"}}},"bytecode":"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","debug_symbols":"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","file_map":{"18":{"source":"pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n __assert_max_bit_size(self, BIT_SIZE);\n }\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = __to_le_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = __to_be_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_le_radix(self, radix)\n }\n\n fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_be_radix(self, radix)\n }\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n/// This slice will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits(value: Field) -> [u1; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits(value: Field) -> [u1; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime, static_assert};\n use super::{\n field_less_than, modulus_be_bits, modulus_be_bytes, modulus_le_bits, modulus_le_bytes,\n };\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // Updated test to account for Brillig restriction that radix must be greater than 2\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_brillig_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 1;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n unconstrained fn not_enough_limbs_brillig() {\n let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n fn not_enough_limbs() {\n let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n }\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n\n #[test]\n unconstrained fn test_large_field_values_unconstrained() {\n let large_field = 0xffffffffffffffff;\n\n let bits: [u1; 64] = large_field.to_le_bits();\n assert_eq(bits[0], 1);\n\n let bytes: [u8; 8] = large_field.to_le_bytes();\n assert_eq(Field::from_le_bytes::<8>(bytes), large_field);\n\n let radix_bytes: [u8; 8] = large_field.to_le_radix(256);\n assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_field);\n }\n\n #[test]\n fn test_large_field_values() {\n let large_val = 0xffffffffffffffff;\n\n let bits: [u1; 64] = large_val.to_le_bits();\n assert_eq(bits[0], 1);\n\n let bytes: [u8; 8] = large_val.to_le_bytes();\n assert_eq(Field::from_le_bytes::<8>(bytes), large_val);\n\n let radix_bytes: [u8; 8] = large_val.to_le_radix(256);\n assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_val);\n }\n\n #[test]\n fn test_decomposition_edge_cases() {\n let zero_bits: [u1; 8] = 0.to_le_bits();\n assert_eq(zero_bits, [0; 8]);\n\n let zero_bytes: [u8; 8] = 0.to_le_bytes();\n assert_eq(zero_bytes, [0; 8]);\n\n let one_bits: [u1; 8] = 1.to_le_bits();\n let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n assert_eq(one_bits, expected);\n\n let pow2_bits: [u1; 8] = 4.to_le_bits();\n let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\n assert_eq(pow2_bits, expected);\n }\n\n #[test]\n fn test_pow_32() {\n assert_eq(2.pow_32(3), 8);\n assert_eq(3.pow_32(2), 9);\n assert_eq(5.pow_32(0), 1);\n assert_eq(7.pow_32(1), 7);\n\n assert_eq(2.pow_32(10), 1024);\n\n assert_eq(0.pow_32(5), 0);\n assert_eq(0.pow_32(0), 1);\n\n assert_eq(1.pow_32(100), 1);\n }\n\n #[test]\n fn test_sgn0() {\n assert_eq(0.sgn0(), 0);\n assert_eq(2.sgn0(), 0);\n assert_eq(4.sgn0(), 0);\n assert_eq(100.sgn0(), 0);\n\n assert_eq(1.sgn0(), 1);\n assert_eq(3.sgn0(), 1);\n assert_eq(5.sgn0(), 1);\n assert_eq(101.sgn0(), 1);\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 8 limbs\")]\n fn test_bit_decomposition_overflow() {\n // 8 bits can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u1; 8] = large_val.to_le_bits();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n fn test_byte_decomposition_overflow() {\n // 4 bytes can't represent large field values\n let large_val = 0x1000000000000000;\n let _: [u8; 4] = large_val.to_le_bytes();\n }\n\n #[test]\n fn test_to_from_be_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_minus_1_bytes[32 - 1] > 0);\n p_minus_1_bytes[32 - 1] -= 1;\n\n let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n assert(p_plus_1_bytes[32 - 1] < 255);\n p_plus_1_bytes[32 - 1] += 1;\n\n let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 BE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n p_plus_1_converted_bytes[32 - 1] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_be_bytes().len(), 32);\n let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 BE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_be_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n #[test]\n fn test_to_from_le_bytes_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_minus_1_bytes[0] > 0);\n p_minus_1_bytes[0] -= 1;\n\n let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n assert(p_plus_1_bytes[0] < 255);\n p_plus_1_bytes[0] += 1;\n\n let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n assert_eq(p_plus_1, 1);\n\n // checking that converting p_plus_1 to 32 LE bytes produces the same\n // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n assert_eq(p_plus_1_converted_bytes[0], 1);\n p_plus_1_converted_bytes[0] = 0;\n assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n assert_eq(modulus_le_bytes().len(), 32);\n let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 32 LE bytes produces 32 zeroes\n let p_bytes: [u8; 32] = 0.to_le_bytes();\n assert_eq(p_bytes, [0; 32]);\n }\n }\n\n /// Convert a little endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_le_bits(bits: [u1; N]) -> Field {\n static_assert(\n N <= modulus_le_bits().len(),\n \"N must be less than or equal to modulus_le_bits().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bits[i] as Field) * v;\n v = v * 2;\n }\n result\n }\n\n /// Convert a big endian bit array to a field element.\n /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n fn from_be_bits(bits: [u1; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bits[N - 1 - i] as Field) * v;\n v = v * 2;\n }\n result\n }\n\n #[test]\n fn test_to_from_be_bits_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this bit produces the expected 254 BE bits for (modulus - 1)\n let mut p_minus_1_bits: [u1; 254] = modulus_be_bits().as_array();\n assert(p_minus_1_bits[254 - 1] > 0);\n p_minus_1_bits[254 - 1] -= 1;\n\n let p_minus_1 = from_be_bits::<254>(p_minus_1_bits);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n let p_minus_1_converted_bits: [u1; 254] = p_minus_1.to_be_bits();\n assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n // checking that incrementing this bit produces 254 BE bits for (modulus + 4)\n let mut p_plus_4_bits: [u1; 254] = modulus_be_bits().as_array();\n assert(p_plus_4_bits[254 - 3] < 1);\n p_plus_4_bits[254 - 3] += 1;\n\n let p_plus_4 = from_be_bits::<254>(p_plus_4_bits);\n assert_eq(p_plus_4, 4);\n\n // checking that converting p_plus_4 to 254 BE bits produces the same\n // bit set to 1 as p_plus_4_bits and otherwise zeroes\n let mut p_plus_4_converted_bits: [u1; 254] = p_plus_4.to_be_bits();\n assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n p_plus_4_converted_bits[254 - 3] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 254]);\n\n // checking that Field::from_be_bits::<254> on the Field modulus produces 0\n assert_eq(modulus_be_bits().len(), 254);\n let p = from_be_bits::<254>(modulus_be_bits().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 254 BE bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_be_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n\n #[test]\n fn test_to_from_le_bits_bn254_edge_cases() {\n if crate::compat::is_bn254() {\n // checking that decrementing this bit produces the expected 254 LE bits for (modulus - 1)\n let mut p_minus_1_bits: [u1; 254] = modulus_le_bits().as_array();\n assert(p_minus_1_bits[0] > 0);\n p_minus_1_bits[0] -= 1;\n\n let p_minus_1 = from_le_bits::<254>(p_minus_1_bits);\n assert_eq(p_minus_1 + 1, 0);\n\n // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n let p_minus_1_converted_bits: [u1; 254] = p_minus_1.to_le_bits();\n assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n // checking that incrementing this bit produces 254 LE bits for (modulus + 4)\n let mut p_plus_4_bits: [u1; 254] = modulus_le_bits().as_array();\n assert(p_plus_4_bits[2] < 1);\n p_plus_4_bits[2] += 1;\n\n let p_plus_4 = from_le_bits::<254>(p_plus_4_bits);\n assert_eq(p_plus_4, 4);\n\n // checking that converting p_plus_4 to 254 LE bits produces the same\n // bit set to 1 as p_plus_4_bits and otherwise zeroes\n let mut p_plus_4_converted_bits: [u1; 254] = p_plus_4.to_le_bits();\n assert_eq(p_plus_4_converted_bits[2], 1);\n p_plus_4_converted_bits[2] = 0;\n assert_eq(p_plus_4_converted_bits, [0; 254]);\n\n // checking that Field::from_le_bits::<254> on the Field modulus produces 0\n assert_eq(modulus_le_bits().len(), 254);\n let p = from_le_bits::<254>(modulus_le_bits().as_array());\n assert_eq(p, 0);\n\n // checking that converting 0 to 254 LE bytes produces 254 zeroes\n let p_bits: [u1; 254] = 0.to_le_bits();\n assert_eq(p_bits, [0; 254]);\n }\n }\n}\n","path":"std/field/mod.nr"},"19":{"source":"// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal(input: [Field; N]) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u8 as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u16 as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u32 as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u64 as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n","path":"std/hash/mod.nr"},"50":{"source":"// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse lib::configs::default::threshold::{\n L, N, USER_DATA_ENCRYPTION_BIT_CT, USER_DATA_ENCRYPTION_BIT_E0, USER_DATA_ENCRYPTION_BIT_E1,\n USER_DATA_ENCRYPTION_BIT_K, USER_DATA_ENCRYPTION_BIT_P1, USER_DATA_ENCRYPTION_BIT_P2,\n USER_DATA_ENCRYPTION_BIT_PK, USER_DATA_ENCRYPTION_BIT_R1, USER_DATA_ENCRYPTION_BIT_R2,\n USER_DATA_ENCRYPTION_BIT_U, USER_DATA_ENCRYPTION_CONFIGS,\n};\nuse lib::core::threshold::user_data_encryption::UserDataEncryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n pk_commitment: pub Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: [Polynomial; L],\n ct1is: [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e1: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n k1: Polynomial,\n r1is: [Polynomial<(2 * N) - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<(2 * N) - 1>; L],\n p2is: [Polynomial; L],\n) {\n let user_data_encryption: UserDataEncryption = UserDataEncryption::new(\n USER_DATA_ENCRYPTION_CONFIGS,\n pk_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n k1,\n r1is,\n r2is,\n p1is,\n p2is,\n );\n let is_user_data_encryption_valid = user_data_encryption.execute();\n assert(is_user_data_encryption_valid);\n}\n","path":"/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/threshold/user_data_encryption/src/main.nr"},"72":{"source":"// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse crate::math::commitments::compute_user_data_encryption_challenge_commitment;\nuse crate::math::helpers::flatten;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Greco circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Plaintext modulus: q mod t mod p\n pub q_mod_t_mod_p: Field,\n /// Scaling factors for each basis: [k0_0, k0_1, ..., k0_{L-1}]\n pub k0is: [Field; L],\n /// Bounds for public key polynomials for each CRT basis\n pub pk_bounds: [Field; L],\n /// Bounds for error polynomials (e0)\n pub e0_bound: Field,\n /// Bounds for error polynomials (e1)\n pub e1_bound: Field,\n /// Bound for secret polynomial u (ternary distribution)\n pub u_bound: Field,\n /// Lower bounds for r1 polynomials (modulus switching quotients)\n pub r1_low_bounds: [Field; L],\n /// Upper bounds for r1 polynomials (modulus switching quotients)\n pub r1_up_bounds: [Field; L],\n /// Bounds for r2 polynomials (cyclotomic reduction quotients)\n pub r2_bounds: [Field; L],\n /// Bounds for p1 polynomials (modulus switching quotients)\n pub p1_bounds: [Field; L],\n /// Bounds for p2 polynomials (cyclotomic reduction quotients)\n pub p2_bounds: [Field; L],\n /// Lower bound for k1 polynomial (scaled message)\n pub k1_low_bound: Field,\n /// Upper bound for k1 polynomial (scaled message)\n pub k1_up_bound: Field,\n}\n\nimpl Configs {\n pub fn new(\n q_mod_t_mod_p: Field,\n qis: [Field; L],\n k0is: [Field; L],\n pk_bounds: [Field; L],\n e0_bound: Field,\n e1_bound: Field,\n u_bound: Field,\n r1_low_bounds: [Field; L],\n r1_up_bounds: [Field; L],\n r2_bounds: [Field; L],\n p1_bounds: [Field; L],\n p2_bounds: [Field; L],\n k1_low_bound: Field,\n k1_up_bound: Field,\n ) -> Self {\n Configs {\n qis,\n q_mod_t_mod_p,\n k0is,\n pk_bounds,\n e0_bound,\n e1_bound,\n u_bound,\n r1_low_bounds,\n r1_up_bounds,\n r2_bounds,\n p1_bounds,\n p2_bounds,\n k1_low_bound,\n k1_up_bound,\n }\n }\n}\n\n/// Correct User Data Encryption Circuit under Threshold public key\n///\n/// Verifies:\n/// 1. Range checks on all polynomial coefficients\n/// 2. Correct encryption: ct0i = pk0i * u + e0 + k1 * k0i + r1i * qi + r2i * cyclo\n/// and ct1i = pk1i * u + e1 + p1i * qi + p2i * cyclo\n///\n/// DISCLAIMER: Ported from Halo2 circuit by Greco paper authors @ PSE.\n/// Halo2 implementation: https://github.com/privacy-scaling-explorations/greco\npub struct UserDataEncryption {\n configs: Configs,\n pk_commitment: Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: [Polynomial; L],\n ct1is: [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n e1: Polynomial,\n k1: Polynomial,\n r1is: [Polynomial<(2 * N) - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<(2 * N) - 1>; L],\n p2is: [Polynomial; L],\n}\n\nimpl UserDataEncryption {\n pub fn new(\n configs: Configs,\n pk_commitment: Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: [Polynomial; L],\n ct1is: [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n e1: Polynomial,\n k1: Polynomial,\n r1is: [Polynomial<2 * N - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<2 * N - 1>; L],\n p2is: [Polynomial; L],\n ) -> UserDataEncryption {\n UserDataEncryption {\n configs,\n pk_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n k1,\n r1is,\n r2is,\n p1is,\n p2is,\n }\n }\n\n /// Flattens all polynomials coefficients into a single array for challenge generation.\n ///\n /// This function serializes all polynomial coefficients into a 1D array to enable\n /// the generation of random challenge values using the Fiat-Shamir transform.\n /// The coefficients are arranged in a specific order to ensure deterministic\n /// challenge generation.\n ///\n /// # Returns\n /// An array containing all polynomials coefficients in flattened form\n fn gammas_payload(self) -> Vec {\n let mut inputs = Vec::new();\n\n inputs.push(self.pk_commitment);\n\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct0is);\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct1is);\n\n // Flatten common polynomials (used across all CRT bases)\n inputs = flatten::<_, _, BIT_E0>(inputs, [self.e0]);\n inputs = flatten::<_, _, BIT_E1>(inputs, [self.e1]);\n inputs = flatten::<_, _, BIT_U>(inputs, [self.u]);\n inputs = flatten::<_, _, BIT_K>(inputs, [self.k1]);\n\n // Flatten randomness polynomials for each CRT basis\n inputs = flatten::<_, _, BIT_R1>(inputs, self.r1is);\n inputs = flatten::<_, _, BIT_R2>(inputs, self.r2is);\n inputs = flatten::<_, _, BIT_P1>(inputs, self.p1is);\n inputs = flatten::<_, _, BIT_P2>(inputs, self.p2is);\n\n inputs\n }\n\n /// Performs coefficient-wise CRT consistency check for e0 polynomial.\n ///\n /// Verifies that for each CRT basis i and each coefficient j:\n /// e0.coefficients[j] = e0is[i].coefficients[j] + e0_quotients[i].coefficients[j] * qi\n ///\n /// This ensures that e0 == e0is[i] (mod qi) for all coefficients, which is\n /// much more secure than checking equality at a single evaluation point.\n ///\n /// # Security\n /// Coefficient-wise checking prevents attacks where a malicious prover could\n /// construct different polynomials that happen to evaluate to the same value\n /// at a single challenge point.\n fn check_e0_crt_consistency(self) {\n for i in 0..L {\n // Check each coefficient satisfies the CRT relationship\n for j in 0..N {\n // Verify: e0_coeff = e0i_coeff + quotient_coeff * qi\n assert(\n self.e0.coefficients[j]\n == self.e0is[i].coefficients[j]\n + self.e0_quotients[i].coefficients[j] * self.configs.qis[i],\n );\n }\n }\n }\n\n /// Verifies the correct encryption constraints for the Greco circuit.\n ///\n /// This function implements the core zero-knowledge proof by checking:\n /// 1. Binary constraint on k1 polynomial\n /// 2. Range constraints on all polynomials coefficients\n /// 3. CRT consistency for e0 polynomial\n /// 4. Correct encryption equations\n ///\n /// The proof uses the Schwartz-Zippel lemma: if polynomial equations hold\n /// when evaluated at random points, then the polynomials are identical with\n /// high probability.\n ///\n /// # Encryption Equations\n /// For each CRT basis i:\n /// * ct0i(gamma) = pk0i(gamma) * u(gamma) + e0(gamma) + k1(gamma) * k0i + r1i(gamma) * qi + r2i(gamma) * cyclo\n /// * ct1i(gamma) = pk1i(gamma) * u(gamma) + e1(gamma) + p1i(gamma) * qi + p2i(gamma) * cyclo\n ///\n /// Where:\n /// * cyclo(gamma) = gamma^N + 1 (cyclotomic polynomial)\n /// * qi, k0i are constants from the cryptographic parameters\n /// * r1i, r2i, p1i, p2i are randomness polynomials for each i-th CRT basis.\n ///\n /// # Returns\n /// True if the encryption constraints are satisfied, false otherwise.\n pub fn execute(self) -> bool {\n // Step 1: Perform range checks on all polynomial coefficients\n self.check_range_bounds();\n\n // Step 2: Check CRT consistency for e0 polynomial\n self.check_e0_crt_consistency();\n\n // Step 3: Generate Fiat-Shamir challenges\n let gammas = self.generate_challenge();\n\n // Step 4: Verify encryption constraints using challenges\n self.verify_evaluations(gammas)\n }\n\n /// Performs range checks on all polynomial coefficients.\n ///\n /// Checks that all polynomial coefficients are within their expected bounds\n /// as specified in the `configs`. This prevents attacks where coefficients\n /// are outside the valid range, which could break the security properties\n /// of the encryption scheme.\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// its expected bounds. The bounds are defined per polynomial type in the `configs`.\n fn check_range_bounds(self) {\n self.u.range_check_2bounds::(self.configs.u_bound, self.configs.u_bound);\n self.e0.range_check_2bounds::(self.configs.e0_bound, self.configs.e0_bound);\n self.e1.range_check_2bounds::(self.configs.e1_bound, self.configs.e1_bound);\n self.k1.range_check_2bounds::(self.configs.k1_up_bound, self.configs.k1_low_bound);\n\n for i in 0..L {\n self.pk0is[i].range_check_2bounds::(\n self.configs.pk_bounds[i],\n self.configs.pk_bounds[i],\n );\n self.pk1is[i].range_check_2bounds::(\n self.configs.pk_bounds[i],\n self.configs.pk_bounds[i],\n );\n\n self.r1is[i].range_check_2bounds::(\n self.configs.r1_up_bounds[i],\n self.configs.r1_low_bounds[i],\n );\n self.r2is[i].range_check_2bounds::(\n self.configs.r2_bounds[i],\n self.configs.r2_bounds[i],\n );\n\n self.p1is[i].range_check_2bounds::(\n self.configs.p1_bounds[i],\n self.configs.p1_bounds[i],\n );\n self.p2is[i].range_check_2bounds::(\n self.configs.p2_bounds[i],\n self.configs.p2_bounds[i],\n );\n }\n }\n\n /// Generates Fiat-Shamir challenge values using the SAFE cryptographic sponge.\n ///\n /// This function implements the Fiat-Shamir transform for the Greco circuit:\n /// 1. First, it computes and verifies the public key commitment by absorbing\n /// all public key polynomials and squeezing a single commitment value.\n /// 2. Then, it generates challenge values by absorbing all witness values\n /// (ciphertexts, errors, randomness) and squeezing 2L challenge values.\n ///\n /// The sponge absorbs all witness values and squeezes out deterministic random\n /// field elements that will be used to evaluate polynomials for the Schwartz-Zippel lemma.\n ///\n /// # Returns\n /// Vector of challenge values [gamma_0, gamma_1, ..., gamma_{2L-1}] where:\n /// - gamma_0 is used as the primary evaluation point\n /// - gamma_1, ..., gamma_{L-1} are used for linear combination of ct0 constraints\n /// - gamma_L, ..., gamma_{2L-1} are used for linear combination of ct1 constraints\n fn generate_challenge(self) -> Vec {\n compute_user_data_encryption_challenge_commitment::(\n self.pk0is,\n self.pk1is,\n self.gammas_payload(),\n self.pk_commitment,\n )\n }\n\n /// Verifies encryption constraints using Fiat-Shamir challenges.\n ///\n /// For each CRT basis i, this function verifies that the encryption equations hold\n /// when evaluated at the challenge points. It uses the Schwartz-Zippel lemma:\n /// if polynomial equations hold when evaluated at random points, then the polynomials\n /// are identical with high probability.\n ///\n /// The verification combines all CRT bases using a linear combination with the\n /// challenge values to reduce the number of constraints while maintaining security.\n ///\n /// # Arguments\n /// * `gammas` - Vector of challenge values [gamma_0, gamma_1, ..., gamma_{2L-1}]\n /// generated by `generate_challenge()`\n ///\n /// # Returns\n /// `true` if all encryption constraints are satisfied, `false` otherwise.\n fn verify_evaluations(self, gammas: Vec) -> bool {\n let gamma = gammas.get(0);\n let cyclo_at_gamma = gamma.pow_32(N as Field) + 1;\n let u_at_gamma = self.u.eval(gamma);\n let e1_at_gamma = self.e1.eval(gamma);\n let k1_at_gamma = self.k1.eval(gamma);\n\n let mut sum = (0, 0);\n for i in 0..L {\n let pk0is_at_gamma = self.pk0is[i].eval(gamma);\n let r1i_at_gamma = self.r1is[i].eval(gamma);\n let r2i_at_gamma = self.r2is[i].eval(gamma);\n let e0is_at_gamma = self.e0is[i].eval(gamma);\n\n let pk0_u = (pk0is_at_gamma * u_at_gamma) + e0is_at_gamma;\n let mut ct0_rhs = pk0_u + (k1_at_gamma * self.configs.k0is[i]);\n ct0_rhs += r1i_at_gamma * self.configs.qis[i];\n ct0_rhs += r2i_at_gamma * cyclo_at_gamma;\n let ct0_lhs = self.ct0is[i].eval(gamma);\n let pk1is_at_gamma = self.pk1is[i].eval(gamma);\n let p1is_at_gamma = self.p1is[i].eval(gamma);\n let p2is_at_gamma = self.p2is[i].eval(gamma);\n let pk1_u = (pk1is_at_gamma * u_at_gamma) + e1_at_gamma;\n let mut ct1_rhs = pk1_u + p2is_at_gamma * cyclo_at_gamma;\n ct1_rhs += p1is_at_gamma * self.configs.qis[i];\n let ct1_lhs = self.ct1is[i].eval(gamma);\n let gamma_i = if i == 0 { 1 } else { gammas.get(i) };\n sum = (\n sum.0 + ct0_lhs * gamma_i + ct1_lhs * gammas.get(i + L),\n sum.1 + ct0_rhs * gamma_i + ct1_rhs * gammas.get(i + L),\n );\n }\n\n sum.0 == sum.1\n }\n}\n","path":"/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/threshold/user_data_encryption.nr"},"74":{"source":"// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse crate::math::helpers::{compute_safe, flatten};\nuse crate::math::polynomial::Polynomial;\n\n/// DOMAIN SEPARATORS\n\n// Domain separator - \"PK\"\npub global DS_PK: [u8; 64] = [\n 0x50, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - \"PK_GENERATION\"\npub global DS_PK_GENERATION: [u8; 64] = [\n 0x50, 0x4b, 0x5f, 0x47, 0x45, 0x4e, 0x45, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - \"SHARE_COMPUTATION\"\npub global DS_SHARE_COMPUTATION: [u8; 64] = [\n 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x55, 0x54, 0x41, 0x54, 0x49, 0x4f,\n 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - \"SHARE_ENCRYPTION\"\npub global DS_SHARE_ENCRYPTION: [u8; 64] = [\n 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x45, 0x4e, 0x43, 0x52, 0x59, 0x50, 0x54, 0x49, 0x4f, 0x4e,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - \"PK_AGGREGATION\"\npub global DS_PK_AGGREGATION: [u8; 64] = [\n 0x50, 0x4b, 0x5f, 0x41, 0x47, 0x47, 0x52, 0x45, 0x47, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - \"CIPHERTEXT\"\npub global DS_CIPHERTEXT: [u8; 64] = [\n 0x43, 0x49, 0x50, 0x48, 0x45, 0x52, 0x54, 0x45, 0x58, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - \"AGGREGATED_SHARES\"\npub global DS_AGGREGATED_SHARES: [u8; 64] = [\n 0x41, 0x47, 0x47, 0x52, 0x45, 0x47, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45,\n 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - \"RECURSIVE_AGGREGATION\"\npub global DS_RECURSIVE_AGGREGATION: [u8; 64] = [\n 0x52, 0x45, 0x43, 0x55, 0x52, 0x53, 0x49, 0x56, 0x45, 0x5f, 0x41, 0x47, 0x47, 0x52, 0x45, 0x47,\n 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - \"CLG_PK_GENERATION\"\npub global DS_CLG_PK_GENERATION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x50, 0x4b, 0x5f, 0x47, 0x45, 0x4e, 0x45, 0x52, 0x41, 0x54, 0x49, 0x4f,\n 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - \"CLG_SHARE_ENCRYPTION\"\npub global DS_CLG_SHARE_ENCRYPTION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x45, 0x4e, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - \"CLG_USER_DATA_ENCRYPTION\"\npub global DS_CLG_USER_DATA_ENCRYPTION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x5f, 0x44, 0x41, 0x54, 0x41, 0x5f, 0x45, 0x4e,\n 0x43, 0x52, 0x59, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - \"CLG_SHARE_DECRYPTION\"\npub global DS_CLG_SHARE_DECRYPTION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x44, 0x45, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n\n/// WRAPPERS\n\npub fn compute_commitments(\n payload: Vec,\n domain_separator: [u8; 64],\n io_pattern: [u32; 2],\n) -> Vec {\n compute_safe(domain_separator, payload, io_pattern)\n}\n\npub fn single_polynomial_payload(\n payload: Vec,\n input: Polynomial,\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload(\n payload: Vec,\n inputs: [Polynomial; L],\n) -> Vec {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_threshold_pk_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_GENERATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_share_computation_sk_commitment(\n sk: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), sk);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_computation_e_sm_commitment(\n e_sm: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), e_sm);\n compute_commitments(\n payload,\n DS_SHARE_COMPUTATION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_message(\n message: Polynomial,\n) -> Field {\n let mut payload = single_polynomial_payload::(Vec::new(), message);\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_share_encryption_commitment_from_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n party_idx: u32,\n mod_idx: u32,\n) -> Field {\n let mut payload = Vec::new();\n\n for coeff_idx in 0..N {\n payload.push(y[coeff_idx][mod_idx][party_idx + 1]);\n }\n\n // Include party_idx and mod_idx in the hash\n payload.push(party_idx as Field);\n payload.push(mod_idx as Field);\n\n compute_commitments(\n payload,\n DS_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_aggregated_shares_commitment(\n agg_shares: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), agg_shares);\n compute_commitments(\n payload,\n DS_AGGREGATED_SHARES,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_pk_aggregation_commitment(\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), pk0);\n payload = multiple_polynomial_payload::(payload, pk1);\n\n compute_commitments(payload, DS_PK_AGGREGATION, [0x80000000 | payload.len(), 1]).get(0)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: Vec) -> Field {\n compute_safe(\n DS_RECURSIVE_AGGREGATION,\n payload,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n\npub fn compute_ciphertext_commitment(\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::(Vec::new(), ct0);\n payload = multiple_polynomial_payload::(payload, ct1);\n\n compute_commitments(payload, DS_CIPHERTEXT, [0x80000000 | payload.len(), 1]).get(0)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_PK_GENERATION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_share_encryption_challenge(payload: Vec) -> Vec {\n compute_commitments(\n payload,\n DS_CLG_SHARE_ENCRYPTION,\n [0x80000000 | payload.len(), 2 * L],\n )\n}\n\npub fn compute_user_data_encryption_challenge_commitment(\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n gammas_payload: Vec,\n pk_commitment: Field,\n) -> Vec {\n assert(compute_pk_aggregation_commitment::(pk0is, pk1is) == pk_commitment);\n\n compute_commitments(\n gammas_payload,\n DS_CLG_USER_DATA_ENCRYPTION,\n [0x80000000 | gammas_payload.len(), 2 * L],\n )\n}\n\npub fn compute_threshold_share_decryption_challenge(payload: Vec) -> Field {\n compute_commitments(\n payload,\n DS_CLG_SHARE_DECRYPTION,\n [0x80000000 | payload.len(), 1],\n )\n .get(0)\n}\n","path":"/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/commitments.nr"},"75":{"source":"// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\n//! Helper functions for circuit construction and cryptographic operations.\nuse crate::math::polynomial::Polynomial;\nuse crate::math::safe::SafeSponge;\n\n/// Compute hex-aligned packing parameters for a given `BIT`.\n///\n/// # Purpose\n/// Returns `(nibble_bits, group)` for use by pack/flatten so layout stays consistent.\n/// - `nibble_bits`: ceil (`BIT`) to the next multiple of 4 (nibble alignment).\n/// - Examples: `BIT = 7 -> 8`, `BIT = 8 -> 8`, `BIT = 9 -> 12`, `BIT = 10 -> 12`, `BIT = 11 -> 12`,\n/// `BIT=16 -> 16`, `BIT = 17 -> 20`.\n/// - `group`: max number of encoded limbs that fit in one BN254 field element,\n/// when each limb uses an extra 4 bits (see below).\n///\n/// # Rationale\n/// - We align to nibbles so powers of two are hex-friendly and deterministic.\n/// - We reserve one extra nibble (4 bits) per stored value to lift signed\n/// coefficients into the non-negative range (e.g., store `v + 2^nibble_bits`),\n/// which implies a radix of `2^(nibble_bits + 4)`.\n///\n/// # Safety\n/// - Asserts `nibble_bits + 4 <= 254` to avoid mod-p wrap on BN254.\n/// - Ensures at least one limb fits: `group >= 1`.\nfn packing_layout() -> (u32, u32) {\n // Ceil BIT up to the next multiple of 4 (nibble alignment).\n let nibble_bits = ((BIT + 3) / 4) * 4;\n\n // Each stored limb uses an extra nibble because negative coefficients\n // will be shifted to positive, so radix = 2^(nibble_bits+4).\n assert(nibble_bits + 4 <= 254);\n\n // Maximum limbs that fit in one BN254 element without wrap.\n let group = 254 / (nibble_bits + 4);\n assert(group >= 1);\n (nibble_bits, group)\n}\n\n/// Flatten `L` polynomials into a single linear stream of packed `Field` carriers.\n///\n/// ## What this does\n/// - For each CRT limb `j` in `0..L`, it packs the coefficients of `poly[j]`\n/// with `pack::` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::()` and must match what `pack` uses.\n///\n/// ## Determinism & order\n/// - Preserves a stable order: iterate `j = 0..L`, then for each `j` append\n/// carriers in ascending chunk index `i = 0..num_chunks`.\n/// - This ensures transcripts remain deterministic across runs.\n///\n/// ## Generics\n/// - `A`: polynomial degree (number of coefficients per polynomial).\n/// - `L`: number of CRT bases (polynomials).\n/// - `BIT`: per-coefficient bit bound used by the packing layout (compile-time).\n///\n/// ## Returns\n/// - The same `inputs` vector, extended with all carriers in deterministic order.\npub fn flatten(\n mut inputs: Vec,\n poly: [Polynomial; L],\n) -> Vec {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::(poly[j].coefficients);\n\n // Append carriers in-order to `inputs` to keep a stable transcript layout.\n for i in 0..packed.len() {\n inputs.push(packed.get(i));\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `Vec` of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::()`.\n/// - Encodes each value as a limb `digit = v + 2^nibble_bits` and concatenates\n/// limbs in base `radix = 2^(nibble_bits + 4)` (one extra nibble of headroom).\n/// - Packs up to `group` limbs per carrier (fits within BN254 254-bit capacity).\n/// - Pads the last, partial carrier with `digit = 2^nibble_bits` to keep a stable layout.\n///\n/// ## Determinism & order\n/// - Processes values in increasing index order and emits carriers in chunk order\n/// (`chunk = 0..num_chunks`). Padding is deterministic.\n///\n/// ## Generics\n/// - `A`: number of input values.\n/// - `BIT`: per-value bit bound; rounded up to `nibble_bits` by `packing_layout`.\n///\n/// ## Preconditions / Notes\n/// - Call with the raw coefficients whose magnitudes already satisfy the BIT bound\n/// (as enforced by the upstream range checks); `pack` performs the signed -> unsigned\n/// shift internally via `v + base`.\n/// - `group >= 1` is enforced by `packing_layout::()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `Vec` where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack(values: [Field; A]) -> Vec {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::();\n\n let base = 2.pow_32(nibble_bits as Field); // 2^nibble_bits\n let radix = 2.pow_32((nibble_bits + 4) as Field); // 2^(nibble_bits + 4)\n\n // Number of chunks to emit: ceil(A / group).\n let num_chunks = (A + group - 1) / group;\n let mut out = Vec::new();\n\n // Process in fixed-size chunks of `group` limbs.\n for chunk in 0..num_chunks {\n // How many real values go into this chunk.\n let remain = A - (chunk * group);\n let take = if remain < group { remain } else { group };\n\n // Build field element accumulator (big-endian concatenation in `radix`).\n let mut acc = 0;\n for i in 0..take {\n let v = values[chunk * group + i];\n acc = acc * radix + (v + base);\n }\n\n // Pad remaining limb slots with the canonical zero-limb `digit = base`.\n for _ in 0..(group - take) {\n acc = acc * radix + base;\n }\n\n out.push(acc);\n }\n out\n}\n\n/// Computes a cryptographic hash using the SAFE (Sponge API for Field Elements) protocol.\n///\n/// This is a convenience wrapper around the SAFE sponge API that handles the full\n/// lifecycle: initialization, absorption, squeezing, and finalization. It's designed\n/// for use in Fiat-Shamir challenge generation and commitment schemes within zero-knowledge circuits.\n///\n/// # Arguments\n/// * `domain_separator` - A 64-byte domain separator used to differentiate between\n/// different protocol instances and prevent cross-protocol attacks.\n/// * `inputs` - Vector of field elements to be absorbed into the sponge.\n/// * `io_pattern` - A 2-element array encoding the I/O pattern:\n/// - `io_pattern[0]`: Encoded ABSORB operation (MSB=1, lower 31 bits = length)\n/// - `io_pattern[1]`: Encoded SQUEEZE operation (MSB=0, lower 31 bits = length)\n///\n/// # Returns\n/// A vector of field elements squeezed from the sponge, with length determined by\n/// the SQUEEZE operation in the IO pattern.\npub fn compute_safe(\n domain_separator: [u8; 64],\n inputs: Vec,\n io_pattern: [u32; 2],\n) -> Vec {\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(inputs);\n let digests = sponge.squeeze();\n sponge.finish();\n\n digests\n}\n\n#[test]\nfn test_flatten() {\n // Create test polynomials\n let poly1 = Polynomial::new([1, 2, 3]); // degree 2\n let poly2 = Polynomial::new([4, -16, 6]); // degree 2\n let poly3 = Polynomial::new([-7, 8, 9]); // degree 2\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 4>(inputs, polynomials);\n\n // Verify the flattened coefficients are in the correct positions\n // Every value shifted 1 nibble incase of negative integers\n assert(result.get(0) == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result.get(1) == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result.get(2) == 0x09181910101010101010101010101010101010101010101010101010101010); // -7 became 09 at 0x 09 18 19(16 - 7 = 9)\n}\n\n#[test]\nfn test_flatten_big() {\n // Create test polynomials\n let poly1 = Polynomial::new([\n 1791218451968394,\n 21888242871839275222246405745257275088548364400416034343698198265248580087864,\n 21888242871839275222246405745257275088548364400416034343698200542108324633466,\n 5430119342984413,\n 704811298945172,\n 8901715723925099,\n 21888242871839275222246405745257275088548364400416034343698203098124042812559,\n 21888242871839275222246405745257275088548364400416034343698200215091693880034,\n ]);\n let poly2 = Polynomial::new([\n 21888242871839275222246405745257275088548364400416034343698200314078269634250,\n 21888242871839275222246405745257275088548364400416034343698200967285641915872,\n 2909990636858607,\n 7896103832076587,\n 2078397209533893,\n 21888242871839275222246405745257275088548364400416034343698199792421452734531,\n 614400389245817,\n 8290314119277588,\n ]);\n let poly3 = Polynomial::new([\n 21888242871839275222246405745257275088548364400416034343698201373175279892906,\n 21888242871839275222246405745257275088548364400416034343698201087241869723721,\n 6768789983786188,\n 635797784303388,\n 7610153424227556,\n 4633893206538324,\n 2016269760615332,\n 21888242871839275222246405745257275088548364400416034343698201007080554428142,\n ]);\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 54>(inputs, polynomials);\n\n // Verify the flattened coefficients are in the correct positions\n // Every value shifted 1 nibble incase of negative integers\n\n // For the first index of result operation goes like this,\n\n // First four index of poly1\n // 1791218451968394,\n // 21888242871839275222246405745257275088548364400416034343698198265248580087864,\n // 21888242871839275222246405745257275088548364400416034343698200542108324633466,\n // 5430119342984413,\n\n // base + 1791218451968394 = 0x1065d1a8b8b718a\n // base - 5921327228407753 = 0xeaf69591f3b037 (negative coefficient shifted)\n // base - 3644467483862151 = 0xf30d604a3a9b79 (negative coefficient shifted)\n // base + 5430119342984413 = 0x1134aaa2e86ccdd\n assert(result.get(0) == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result.get(1) == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result.get(2) == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result.get(3) == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result.get(4) == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result.get(5) == 0x11b0964eb898ce411076805680b85410729c962da53a40f4b44412d0f6ed);\n}\n\n#[test]\nfn test_flatten_small() {\n // Create test polynomials\n let poly1 = Polynomial::new([712345, 104857, 999999, 500001, 123, 654321, 77]);\n let poly2 = Polynomial::new([1, 524287, 888888, 23456, 34567, 765432, 0]);\n let poly3 = Polynomial::new([444444, 333333, 222222, 111111, 987654, 246810, 13579]);\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let mut inputs = Vec::new();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result.get(0) == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result.get(1) == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result.get(2) == 0x16c81c15161513640e11b2071f120613c41a10350b100000100000100000);\n}\n\n#[test]\nfn test_safe_hashing_with_safe_helper() {\n // Verifies basic hash functionality with a simple ABSORB(3) + SQUEEZE(1) pattern.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = Vec::from_slice(&[1, 2, 3]);\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let digests1 = compute_safe(domain_separator, elements, io_pattern);\n\n assert(digests1.len() == 1);\n assert(digests1.get(0) != 0);\n\n // Test determinism\n let digests2 = compute_safe(domain_separator, elements, io_pattern);\n\n assert(digests2.len() == 1);\n assert(digests2.get(0) != 0);\n assert(digests2.get(0) == digests1.get(0));\n}\n\n#[test]\nfn test_pack() {\n // Test pack function directly with small values\n let values = [1, 2, 3, 4];\n let packed = pack::<4, 4>(values);\n\n // With BIT=4, nibble_bits=4, group should be floor(254/(4+4)) = 31\n // So all 4 values should fit in one carrier\n assert(packed.len() >= 1);\n\n // Test with negative values\n let values_neg = [-1, 2, -3, 4];\n let packed_neg = pack::<4, 4>(values_neg);\n assert(packed_neg.len() >= 1);\n}\n\n#[test]\nfn test_pack_single_value() {\n // Test packing a single value\n let values = [42];\n let packed = pack::<1, 8>(values);\n assert(packed.len() == 1);\n assert(packed.get(0) != 0);\n}\n\n#[test]\nfn test_pack_determinism() {\n // Test that packing is deterministic\n let values = [10, 20, 30];\n let packed1 = pack::<3, 8>(values);\n let packed2 = pack::<3, 8>(values);\n\n assert(packed1.len() == packed2.len());\n for i in 0..packed1.len() {\n assert(packed1.get(i) == packed2.get(i));\n }\n}\n","path":"/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/helpers.nr"},"80":{"source":"// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse super::modulo::U128::ModU128;\n\n/// Polynomial structure representing a polynomial of degree N-1.\n///\n/// A polynomial P(X) = a_{N-1} * X^{N-1} + a_{N-2} * X^{N-2} + ... + a_1 * X + a_0\n/// is represented as an array of coefficients where coefficients[0] = a_{N-1} (highest degree)\n/// and coefficients[N-1] = a_0 (constant term).\npub struct Polynomial {\n /// Array of polynomial coefficients in descending degree order\n /// coefficients[0] = coefficient of X^{N-1} (highest degree term)\n /// coefficients[N-1] = constant term (degree 0)\n pub coefficients: [Field; N],\n}\n\nimpl Polynomial {\n /// Creates a new polynomial from an array of coefficients.\n ///\n /// # Arguments\n /// * `coefficients` - Array of N coefficients in descending degree order\n /// coefficients[0] = coefficient of X^{N-1}\n /// coefficients[N-1] = constant term\n ///\n /// # Returns\n /// A new Polynomial instance with the specified coefficients\n pub fn new(coefficients: [Field; N]) -> Self {\n Polynomial { coefficients }\n }\n\n /// Adds two polynomials.\n ///\n /// # Arguments\n /// * `other` - The polynomial to add to the current polynomial.\n ///\n /// # Returns\n /// A new polynomial with the coefficients added.\n pub fn add(self, other: Self) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] + other.coefficients[i];\n }\n\n result\n }\n\n /// Subtracts two polynomials.\n ///\n /// # Arguments\n /// * `other` - The polynomial to subtract from the current polynomial.\n ///\n /// # Returns\n /// A new polynomial with the coefficients subtracted.\n pub fn sub(self, other: Self) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] - other.coefficients[i];\n }\n\n result\n }\n\n /// Multiplies a polynomial by a scalar.\n ///\n /// # Arguments\n /// * `scalar` - The scalar to multiply the polynomial by.\n ///\n /// # Returns\n /// A new polynomial with the coefficients multiplied by the scalar.\n pub fn mul_scalar(self, scalar: Field) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] * scalar;\n }\n\n result\n }\n\n /// Evaluates the polynomial at a given point using Horner's method.\n ///\n /// Horner's method computes P(x) = a_{N-1} * x^{N-1} + ... + a_1 * x + a_0\n /// as ((...((a_{N-1} * x + a_{N-2}) * x + a_{N-3}) * x + ...) * x + a_0)\n /// This approach require n multiplications and n additions to evaluate the polynomial.\n ///\n /// # Arguments\n /// * `x` - The point at which to evaluate the polynomial.\n ///\n /// # Returns\n /// The value of the polynomial at point x: P(x).\n pub fn eval(self, x: Field) -> Field {\n let mut result = self.coefficients[0];\n\n for i in 1..self.coefficients.len() {\n result = result * x + self.coefficients[i];\n }\n\n result\n }\n\n /// Evaluates the polynomial at a given point with modular reduction.\n ///\n /// This function computes `P(x) mod q` using Horner's method with intermediate\n /// modular reductions to prevent overflow. The result is guaranteed to be in\n /// the range `[0, q)`.\n ///\n /// The function performs modular reduction after each multiplication and addition\n /// to ensure the accumulator always remains in the range `[0, q)`, preventing\n /// any potential overflow issues.\n ///\n /// # Arguments\n /// * `x` - The point at which to evaluate the polynomial\n /// * `q` - The modular arithmetic context containing the modulus\n ///\n /// # Returns\n /// The value `P(x) mod q` in the range `[0, q)`\n pub fn eval_mod(self, x: Field, q: ModU128) -> Field {\n let mut acc = self.coefficients[0];\n let len = self.coefficients.len();\n\n for i in 1..len {\n acc = q.mul_mod(acc, x);\n acc = q.add(acc, self.coefficients[i]);\n }\n\n acc\n }\n\n /// Performs range checking on polynomial coefficients using asymmetric bounds.\n ///\n /// This function constrains all polynomial coefficients to be in the range [-lower_bound, upper_bound],\n /// where `lower_bound` is a non-negative magnitude.\n /// It uses a shifting technique to handle negative numbers efficiently:\n /// 1. Shifts each coefficient by adding `lower_bound`: c' = c + lower_bound\n /// 2. Checks that shifted coefficients are in [0, upper_bound + lower_bound] using bit-size assertions\n /// 3. This ensures original coefficients are in [-lower_bound, upper_bound]\n ///\n /// The function uses two bit-size checks per coefficient to ensure the value is within bounds:\n /// - `shifted_coefficient.assert_max_bit_size::()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::()` ensures c' <= range_size\n ///\n /// # Arguments\n /// * `upper_bound` - The upper bound for coefficient range checking\n /// * `lower_bound` - Non-negative magnitude of the negative bound\n /// Coefficients must satisfy: -lower_bound <= c <= upper_bound\n ///\n /// # Generic Parameters\n /// * `BIT` - The bit-length of the total range `upper_bound + lower_bound`\n /// (choose `BIT` so `upper_bound + lower_bound < 2^BIT`). Since all checked\n /// values lie in `[0, upper_bound + lower_bound]`, they cannot exceed `BIT + 1` bits.\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// the specified bounds.\n pub fn range_check_2bounds(self, upper_bound: Field, lower_bound: Field) {\n let range_size = lower_bound + upper_bound;\n\n for i in 0..self.coefficients.len() {\n let shifted_coefficient = self.coefficients[i] + lower_bound;\n\n shifted_coefficient.assert_max_bit_size::();\n (range_size - shifted_coefficient).assert_max_bit_size::();\n }\n }\n\n /// Performs range checking on polynomial coefficients for the range [0, upper_bound).\n ///\n /// This function constrains all polynomial coefficients to be non-negative and\n /// strictly less than `upper_bound`. It uses bit-size assertions to verify that\n /// coefficients are in the valid range.\n ///\n /// The function performs two checks per coefficient:\n /// 1. `coeff.assert_max_bit_size::()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::()` ensures `coeff < upper_bound`\n ///\n /// # Arguments\n /// * `upper_bound` - The exclusive upper bound for coefficient range checking.\n /// Coefficients must satisfy: `0 <= c < upper_bound`\n ///\n /// # Generic Parameters\n /// * `BIT` - The bit-length parameter. Must satisfy `upper_bound <= 2^BIT` for\n /// the range check to work correctly.\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// the range `[0, upper_bound)`.\n pub fn range_check_standard(self, upper_bound: Field) {\n for i in 0..self.coefficients.len() {\n let coeff = self.coefficients[i];\n // Check coeff >= 0 and coeff < 2^BIT\n coeff.assert_max_bit_size::();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::();\n }\n }\n\n /// Performs range checking on polynomial coefficients for the range [0, 2^BIT).\n ///\n /// This is a specialized range check for coefficients that must be non-negative\n /// and less than a power of two. It's more efficient than `range_check_standard`\n /// when the upper bound is exactly `2^BIT` because it only needs a single\n /// bit-size assertion per coefficient.\n ///\n /// The function verifies that each coefficient satisfies:\n /// - `coeff >= 0` (implicit from bit-size check)\n /// - `coeff < 2^BIT` (enforced by `assert_max_bit_size::()`)\n ///\n /// # Generic Parameters\n /// * `BIT` - The bit-length parameter. Coefficients must satisfy: `0 <= c < 2^BIT`\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// the range `[0, 2^BIT)`.\n pub fn range_check_power_of_two(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval() {\n let coeffs = [1, 2, 3]; // represents 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n\n let x = 2; // evaluate at x = 2\n let result = poly.eval(x);\n\n // (1 * 2^2) + (2 * 2) + 3 = 4 + 4 + 3 = 11\n assert(result == 11);\n}\n\n#[test]\nfn test_polynomial_eval_zero() {\n let coeffs = [1, -2, 1]; // x^2 - 2x + 1 = (x-1)^2\n let poly = Polynomial::new(coeffs);\n\n let x = 1; // evaluate at x = 1, should be 0\n let result = poly.eval(x);\n\n assert(result == 0);\n}\n\n#[test]\nfn test_polynomial_bounds() {\n let coeffs = [-16, 240, 242];\n let poly = Polynomial::new(coeffs);\n\n // Test double bounds check - constrains to [-240, 242]\n poly.range_check_2bounds::<8>(242, 240);\n}\n\n#[test(should_fail_with = \"assert_max_bit_size\")]\nfn test_polynomial_out_of_bounds_coefficients() {\n let coeffs = [-100];\n let poly = Polynomial::new(coeffs);\n\n // Test double bounds check - constrains to [-98, 99]\n // Should fail because -100 is out of bounds.\n poly.range_check_2bounds::<7>(99, 98);\n}\n\n#[test]\nfn test_polynomial_add() {\n let coeffs1 = [1, 2, 3]; // 1x^2 + 2x + 3\n let coeffs2 = [4, 5, 6]; // 4x^2 + 5x + 6\n let poly1 = Polynomial::new(coeffs1);\n let poly2 = Polynomial::new(coeffs2);\n\n let result = poly1.add(poly2);\n\n // Expected: (1+4)x^2 + (2+5)x + (3+6) = 5x^2 + 7x + 9\n assert(result.coefficients[0] == 5);\n assert(result.coefficients[1] == 7);\n assert(result.coefficients[2] == 9);\n}\n\n#[test]\nfn test_polynomial_sub() {\n let coeffs1 = [5, 7, 9]; // 5x^2 + 7x + 9\n let coeffs2 = [1, 2, 3]; // 1x^2 + 2x + 3\n let poly1 = Polynomial::new(coeffs1);\n let poly2 = Polynomial::new(coeffs2);\n\n let result = poly1.sub(poly2);\n\n // Expected: (5-1)x^2 + (7-2)x + (9-3) = 4x^2 + 5x + 6\n assert(result.coefficients[0] == 4);\n assert(result.coefficients[1] == 5);\n assert(result.coefficients[2] == 6);\n}\n\n#[test]\nfn test_polynomial_mul_scalar() {\n let coeffs = [1, 2, 3]; // 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n let scalar = 5;\n\n let result = poly.mul_scalar(scalar);\n\n // Expected: 5x^2 + 10x + 15\n assert(result.coefficients[0] == 5);\n assert(result.coefficients[1] == 10);\n assert(result.coefficients[2] == 15);\n}\n\n#[test]\nfn test_polynomial_mul_scalar_zero() {\n let coeffs = [1, 2, 3];\n let poly = Polynomial::new(coeffs);\n let scalar = 0;\n\n let result = poly.mul_scalar(scalar);\n\n // Expected: 0x^2 + 0x + 0 = 0\n assert(result.coefficients[0] == 0);\n assert(result.coefficients[1] == 0);\n assert(result.coefficients[2] == 0);\n}\n\n#[test]\nfn test_eval_mod_simple() {\n // Test without initial reduction - simple case\n // p(x) = x + 1 at x=5od 7\n // Expected: (5 + 1) mod 7 = 6\n let q = ModU128::new(7);\n\n let poly1 = Polynomial::new([1, 1]);\n let result1 = poly1.eval_mod(5, q);\n assert(result1 == 6);\n\n // Test: p(x) = 2x + 3 at x=5od 7\n // Expected: (10 + 3) mod 7 = 13 mod 7 = 6\n let poly2 = Polynomial::new([2, 3]);\n let result2 = poly2.eval_mod(5, q);\n assert(result2 == 6);\n}\n\n#[test]\nfn test_eval_mod_degree_2() {\n // p(x) = x^2 + 2x + 3 at x=5od 7\n // Using Horner's method: ((1)*5 + 2)*5 + 3 = (5+2)*5 + 3 = 7*5 + 3 = 35 + 3 = 38\n // 38 mod 7 = 3 (since 38 = 5*7 + 3)\n let q = ModU128::new(7);\n\n let poly = Polynomial::new([1, 2, 3]);\n let result = poly.eval_mod(5, q);\n assert(result == 3);\n}\n\n#[test]\nfn test_eval_mod() {\n // Test 1: Simple polynomial x^2 + 2x + 3 at x=5od 7\n // Expected: (25 + 10 + 3) mod 7 = 38 mod 7 = 3\n let q = ModU128::new(7);\n\n let poly1 = Polynomial::new([1, 2, 3]);\n let result1 = poly1.eval_mod(5, q);\n assert(result1 == 3);\n\n // Test 2: Higher degree polynomialod small prime\n // p(x) = x^3 + x^2 + x + 1 at x=2od 11\n // Expected: (8 + 4 + 2 + 1) mod 11 = 15 mod 11 = 4\n let q = ModU128::new(11);\n\n let poly2 = Polynomial::new([1, 1, 1, 1]);\n let result2 = poly2.eval_mod(2, q);\n assert(result2 == 4);\n\n // Test 3: Polynomial with larger coefficients\n // p(x) = 100x^2 + 50x + 25 at x=10od 73\n // Expected: (10000 + 500 + 25) mod 73 = 10525 mod 73 = 13\n let q = ModU128::new(73);\n\n let poly3 = Polynomial::new([100, 50, 25]);\n let result3 = poly3.eval_mod(10, q);\n assert(result3 == 13);\n\n // Test 4: Result should be less than modulus\n let poly4 = Polynomial::new([5, 3, 7]);\n let q = ModU128::new(17);\n let result4 = poly4.eval_mod(4, q);\n assert(result4 as u128 < q.get_mod_field() as u128);\n\n // Test 5: Compare with regular eval for small values\n let poly5 = Polynomial::new([1, 2, 1]);\n let x = 3;\n let q = ModU128::new(1000);\n let result5 = poly5.eval_mod(x, q);\n let expected5 = poly5.eval(x);\n assert(result5 == expected5);\n\n // Test 6: Zero polynomial\n let poly6 = Polynomial::new([0, 0, 0]);\n let q = ModU128::new(13);\n let result6 = poly6.eval_mod(100, q);\n assert(result6 == 0);\n}\n\n#[test]\nfn test_large_party_ids_scenario() {\n // Simulating party IDs in range [1, 100]\n let party_id_1 = 42;\n let party_id_2 = 73;\n let m = ModU128::new(288230376151711717); // ~58 bits\n\n // Operations that would be used in Lagrange coefficients\n let product = m.mul_mod(party_id_1, party_id_2);\n let diff = m.sub(party_id_2, party_id_1);\n\n assert(product == 3066);\n assert(diff == 31);\n}\n\n#[test]\nfn test_eval_vs_eval_mod() {\n // Compare eval and eval_mod for small values where no reduction should occur\n let poly = Polynomial::new([1, 2, 3]);\n let x = 2;\n let q = ModU128::new(1000); // Large enough that no reduction happens\n\n let result_normal = poly.eval(x);\n let result_mod = poly.eval_mod(x, q);\n\n // They should be equal: (1)*2 + 2)*2 + 3 = (2+2)*2 + 3 = 4*2 + 3 = 11\n assert(result_normal == 11);\n assert(result_mod == 11);\n}\n\n#[test]\nfn test_eval_mod_step_by_step() {\n // p(x) = x + 1 at x=5od 7\n // Step by step: acc = 1, then acc = 1*5 + 1 = 6\n let poly = Polynomial::new([1, 1]);\n\n // Manually compute\n let mut acc = 1; // coefficients[0]\n acc = acc * 5 + 1; // = 6\n assert(acc == 6);\n\n // Now with reduce_mod\n let m = ModU128::new(7);\n let reduced = m.reduce_mod(acc);\n assert(reduced == 6);\n\n // Now test the actual function\n let result = poly.eval_mod(5, m);\n assert(result == 6);\n}\n","path":"/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/polynomial.nr"},"81":{"source":"// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse keccak256::keccak256;\nuse poseidon::poseidon2_permutation;\n\n/// SAFE (Sponge API for Field Elements)\n///\n/// This module provides a complete implementation of the SAFE API in Noir as defined in:\n/// \"SAFE (Sponge API for Field Elements) - A Toolbox for ZK Hash Applications\"\n/// see https://hackmd.io/bHgsH6mMStCVibM_wYvb2w#22-Sponge-state for more details.\n///\n/// SAFE provides a unified interface for cryptographic sponge functions that can be\n/// instantiated with various permutations to create hash functions, MACs, authenticated\n/// encryption schemes, and other cryptographic primitives for ZK proof systems.\n///\n/// This implementation follows the SAFE specification exactly, providing:\n/// - Complete API: START, ABSORB, SQUEEZE, FINISH operations.\n/// - Full security: Domain separation, tag computation, IO pattern validation.\n/// - Poseidon2 integration: Field-friendly permutation for ZK systems.\n/// - Specification compliance: All operations follow SAFE spec 2.4 exactly.\n/// - Natural API design: Variable-length inputs, automatic length detection from IO patterns.\n///\n/// # API Design\n///\n/// The API is designed for natural usage while maintaining type safety:\n/// - `absorb(input: [Field])`: Accepts variable-length arrays, no padding required.\n/// - `squeeze()`: Returns a vector with field element(s).\n/// - IO patterns automatically determine operation lengths for validation.\n\n/// Rate parameter for the sponge construction (number of field elements that can be absorbed per permutation call).\nglobal RATE: u32 = 3;\n\n/// Capacity parameter for the sponge construction (security parameter, typically 1-2 field elements).\nglobal CAPACITY: u32 = 1;\n\n/// Total state size (rate + capacity) in field elements.\nglobal STATE_SIZE: u32 = RATE + CAPACITY;\n\n/// IO Pattern encoding constants (from SAFE spec 2.3).\n///\n/// These constants are used for encoding operation types in the 32-bit word format:\n/// - MSB set to 1 for ABSORB operations\n/// - MSB set to 0 for SQUEEZE operations\n\n/// Flag for ABSORB operations (MSB = 1)\nglobal ABSORB_FLAG: u32 = 0x80000000;\n\n/// Flag for SQUEEZE operations (MSB = 0)\nglobal SQUEEZE_FLAG: u32 = 0x00000000;\n\n/// SAFE Sponge State (following spec 2.2)\n///\n/// The sponge state consists of the permutation state, tag, position counters,\n/// and IO pattern tracking as defined in the SAFE specification.\n///\n/// # Generic Parameters\n/// - `L`: The length of the IO pattern array\n///\n/// # Fields\n/// - `state`: Permutation state V in F^n (rate + capacity elements)\n/// - `tag`: Parameter tag T used for instance differentiation\n/// - `absorb_pos`: Current absorb position (<= n-c)\n/// - `squeeze_pos`: Current squeeze position (<= n-c)\n/// - `io_pattern`: Expected IO pattern for validation (encoded 32-bit words)\n/// - `io_count`: Current operation count for pattern tracking\npub struct SafeSponge {\n /// Permutation state V in F^n (rate + capacity elements).\n state: [Field; STATE_SIZE],\n /// Parameter tag T used for instance differentiation.\n tag: Field,\n /// Current absorb position (<= n-c).\n absorb_pos: u32,\n /// Current squeeze position (<= n-c).\n squeeze_pos: u32,\n /// Expected IO pattern for validation.\n io_pattern: [u32; L],\n /// Current operation count for pattern tracking (spec 2.4: io_count).\n io_count: u32,\n}\n\nimpl SafeSponge {\n /// Initializes a new SAFE sponge instance with the given IO pattern and domain separator (following spec 2.4).\n ///\n /// # Arguments\n /// - `io_pattern`: Array of 32-bit encoded operations defining the expected sequence of ABSORB/SQUEEZE calls.\n /// Each word has MSB=1 for ABSORB operations, MSB=0 for SQUEEZE operations.\n /// - `domain_separator`: 64-byte domain separator for cross-protocol security.\n ///\n /// # Returns\n /// A new `SafeSponge` instance with initialized state\n pub fn start(io_pattern: [u32; L], domain_separator: [u8; 64]) -> SafeSponge {\n // Compute tag from IO pattern and domain separator (spec 2.3).\n let tag = compute_tag(io_pattern, domain_separator);\n\n let mut state = [0; STATE_SIZE];\n // Initialize capacity with tag (spec 2.4).\n // Add T to the first 128 bits of the state.\n state[0] = tag;\n\n SafeSponge { state, tag, absorb_pos: 0, squeeze_pos: 0, io_pattern, io_count: 0 }\n }\n\n /// Absorbs field elements into the sponge state, interleaving permutation calls as needed (following spec 2.4).\n ///\n /// The number of elements to absorb is automatically validated against the IO pattern.\n /// This method accepts variable-length arrays, making it natural to use without padding.\n ///\n /// # Arguments\n /// - `input`: Array of field elements to absorb (variable length, must match IO pattern)\n pub fn absorb(&mut self, input: Vec) {\n let length = input.len() as u32;\n\n // Validate against IO pattern.\n assert(self.io_count < L);\n\n // Parse expected operation from io_pattern (encoded word)\n let expected_encoded_word = self.io_pattern[self.io_count];\n let is_expected_absorb = (expected_encoded_word & ABSORB_FLAG) != 0;\n let expected_length = expected_encoded_word & 0x7FFFFFFF;\n\n // Validate operation type and length\n assert(is_expected_absorb, \"Expected ABSORB operation\");\n assert(expected_length == length, \"Length mismatch\");\n\n // Process each element naturally (no unnecessary iterations).\n for i in 0..length {\n // If absorb_pos == (n-c) then permute and reset (spec 2.4).\n if self.absorb_pos == RATE {\n // n-c = RATE.\n self.state = self.permute();\n self.absorb_pos = 0;\n }\n\n // Add X[i] to state at absorb_pos (spec 2.4).\n // Note: absorb_pos is the rate position, not capacity position.\n self.state[self.absorb_pos + CAPACITY] =\n self.state[self.absorb_pos + CAPACITY] + input.get(i);\n self.absorb_pos += 1;\n }\n\n // Verify that the encoded word matches the expected pattern.\n let encoded_word = ABSORB_FLAG | length;\n assert(encoded_word == expected_encoded_word);\n\n self.io_count += 1;\n\n // Force permute at start of next SQUEEZE (spec 2.4).\n self.squeeze_pos = RATE;\n }\n\n /// Extracts field elements from the sponge state, interleaving permutation calls as needed (following spec 2.4).\n ///\n /// The number of elements to squeeze is automatically determined from the IO pattern.\n pub fn squeeze(&mut self) -> Vec {\n // Validate against IO pattern.\n assert(self.io_count < L);\n\n // Parse expected operation from io_pattern (encoded word)\n let expected_encoded_word = self.io_pattern[self.io_count];\n let is_expected_squeeze = (expected_encoded_word & ABSORB_FLAG) == 0;\n let length = expected_encoded_word & 0x7FFFFFFF;\n\n // Validate operation type\n assert(is_expected_squeeze, \"Expected SQUEEZE operation\");\n\n let mut output = Vec::new();\n\n // SQUEEZE implementation following spec 2.4.\n // If length==0, loop won't execute (spec 2.4).\n for _ in 0..length {\n // If squeeze_pos==(n-c) then permute and reset (spec 2.4).\n if self.squeeze_pos == RATE {\n // n-c = RATE.\n self.state = self.permute();\n self.squeeze_pos = 0;\n self.absorb_pos = 0;\n }\n // Set Y[i] to state element at squeeze_pos (spec 2.4).\n output.push(self.state[self.squeeze_pos + CAPACITY]);\n self.squeeze_pos += 1;\n }\n\n // Verify that the encoded word matches the expected pattern.\n let encoded_word = SQUEEZE_FLAG | length;\n assert(encoded_word == expected_encoded_word);\n\n self.io_count += 1;\n output\n }\n\n /// Finalizes the sponge instance, verifying that all expected operations have been performed and clearing the internal state for security (following spec 2.4).\n ///\n /// This function is used to ensure that the sponge instance has been used correctly and to prevent information leakage.\n pub fn finish(&mut self) {\n // Check that io_count equals the length of the IO pattern expected (spec 2.4).\n assert(self.io_count == L, \"IO pattern not completed\");\n\n // Erase the state and its variables (spec 2.4).\n self.state = [0; STATE_SIZE];\n self.absorb_pos = 0;\n self.squeeze_pos = 0;\n self.io_count = 0;\n }\n\n /// Permute the state using Poseidon2 (following spec 2.4).\n ///\n /// Applies the Poseidon2 permutation to the current state.\n /// This is the core cryptographic primitive of the sponge construction.\n ///\n /// # Returns\n /// New state after permutation\n fn permute(self) -> [Field; STATE_SIZE] {\n poseidon2_permutation(self.state, STATE_SIZE)\n }\n}\n\n/// Computes a unique tag for a sponge instance based on its IO pattern and domain separator.\n/// The tag is used to ensure that distinct instances behave like distinct functions.\n///\n/// # Arguments\n/// - `io_pattern`: Array of 32-bit encoded operations defining the sponge's usage pattern.\n/// Each word has MSB=1 for ABSORB operations, MSB=0 for SQUEEZE operations.\n/// - `domain_separator`: 64-byte domain separator for cross-protocol security.\n///\n/// # Returns\n/// A field element representing the 128-bit tag.\npub fn compute_tag(io_pattern: [u32; L], domain_separator: [u8; 64]) -> Field {\n // Step 1: Parse and aggregate consecutive operations of the same type\n let mut encoded_words = [0; L]; // Support up to L operations.\n let mut word_count = 0;\n let mut current_absorb_sum = 0;\n let mut current_squeeze_sum = 0;\n let mut last_was_absorb = false;\n\n for i in 0..L {\n if io_pattern[i] > 0 {\n // Parse operation type from MSB and length from lower 31 bits\n let is_absorb = (io_pattern[i] & ABSORB_FLAG) != 0;\n let length = io_pattern[i] & 0x7FFFFFFF; // Clear MSB to get length\n\n if is_absorb {\n if last_was_absorb {\n // Aggregate consecutive ABSORB operations\n current_absorb_sum += length;\n } else {\n // Start new ABSORB sequence\n if current_squeeze_sum > 0 {\n // Flush previous SQUEEZE sequence\n encoded_words[word_count] = SQUEEZE_FLAG | current_squeeze_sum;\n word_count += 1;\n current_squeeze_sum = 0;\n }\n current_absorb_sum = length;\n }\n last_was_absorb = true;\n } else {\n if !last_was_absorb {\n // Aggregate consecutive SQUEEZE operations\n current_squeeze_sum += length;\n } else {\n // Start new SQUEEZE sequence\n if current_absorb_sum > 0 {\n // Flush previous ABSORB sequence\n encoded_words[word_count] = ABSORB_FLAG | current_absorb_sum;\n word_count += 1;\n current_absorb_sum = 0;\n }\n current_squeeze_sum = length;\n }\n last_was_absorb = false;\n }\n }\n }\n\n // Flush remaining operations\n if current_absorb_sum > 0 {\n encoded_words[word_count] = ABSORB_FLAG | current_absorb_sum;\n word_count += 1;\n }\n if current_squeeze_sum > 0 {\n encoded_words[word_count] = SQUEEZE_FLAG | current_squeeze_sum;\n word_count += 1;\n }\n\n // Step 2: Serialize to byte string and append domain separator (following SAFE spec 2.3).\n // Buffer is 256 bytes: max 192 bytes for IO pattern (48 words) + 64 bytes for domain separator.\n // Note: We must use a fixed-size array because Noir's keccak256 requires [u8; N], not Vec.\n let max_io_pattern_bytes: u32 = 192; // 256 - 64 (domain separator)\n let io_pattern_bytes = word_count * 4;\n assert(\n io_pattern_bytes <= max_io_pattern_bytes,\n \"IO pattern too large: max 48 aggregated words supported\",\n );\n\n let mut input_bytes = [0u8; 256];\n let mut byte_count: u32 = 0;\n\n // Serialize encoded words to bytes (big-endian as per SAFE spec).\n // Note: Noir requires compile-time loop bounds, so we iterate over L (the array size)\n // instead of word_count (runtime value). The condition `i < word_count` ensures we only\n // process valid encoded words. This is safe because word_count <= L always holds\n // (we can have at most L encoded words from L input operations).\n for i in 0..L {\n if i < word_count {\n let word = encoded_words[i];\n input_bytes[byte_count] = (word >> 24) as u8;\n input_bytes[byte_count + 1] = (word >> 16) as u8;\n input_bytes[byte_count + 2] = (word >> 8) as u8;\n input_bytes[byte_count + 3] = word as u8;\n byte_count += 4;\n }\n }\n\n // Append full 64-byte domain separator.\n for i in 0..64 {\n input_bytes[byte_count] = domain_separator[i];\n byte_count += 1;\n }\n\n // Step 3: Hash with Keccak-256 and truncate to 128 bits.\n // Note: The SAFE spec uses SHA3-256, but we use Keccak-256 for Noir compatibility.\n // Keccak-256 differs from SHA3-256 in padding, but both provide equivalent security.\n let hash_bytes = keccak256(input_bytes, byte_count);\n\n // Convert first 128 bits (16 bytes) to field element.\n let mut tag_value: Field = 0;\n for i in 0..16 {\n tag_value = tag_value * 256 + (hash_bytes[i] as Field);\n }\n\n tag_value\n}\n\n#[test]\nfn test_safe_hashing() {\n // Verifies basic hash functionality with a simple ABSORB(3) + SQUEEZE(1) pattern.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = Vec::from_slice(&[1, 2, 3]);\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(elements);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(0) != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(elements);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2.get(0) != 0);\n}\n\n#[test]\nfn test_merkle_node() {\n // Verifies SAFE can be used for Merkle tree node hashing with pattern ABSORB(1) + ABSORB(1) + SQUEEZE(1).\n // Tests the ability to absorb multiple inputs before squeezing output.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let left = Vec::from_slice([123]);\n let right = Vec::from_slice([456]);\n\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(left);\n sponge.absorb(right);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(0) != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(left);\n sponge2.absorb(right);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2.get(0) != 0);\n}\n\n#[test]\nfn test_commitment_scheme() {\n // Verifies SAFE can be used for commitment schemes with pattern ABSORB(3) + SQUEEZE(1).\n // Tests the ability to create deterministic commitments from multiple field elements.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let values = Vec::from_slice([10, 20, 30]);\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(values);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(0) != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(values);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2.get(0) != 0);\n}\n\n#[test]\nfn test_domain_separation() {\n // Verifies that different domain separators produce different outputs for the same input.\n // This is crucial for cross-protocol security and preventing collisions between different applications.\n let elements = Vec::from_slice([1, 2, 3]);\n let domain1 = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let domain2 = [\n 0x41, 0x42, 0x43, 0x45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n\n let mut sponge1 = SafeSponge::start(io_pattern, domain1);\n sponge1.absorb(elements);\n let output1 = sponge1.squeeze();\n sponge1.finish();\n\n let mut sponge2 = SafeSponge::start(io_pattern, domain2);\n sponge2.absorb(elements);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output1.len() == 1);\n assert(output2.len() == 1);\n assert(output1.get(0) != output2.get(0)); // Different domain separators should produce different outputs\n}\n\n#[test]\nfn test_multiple_squeeze() {\n // Verifies that multiple field elements can be squeezed in a single operation.\n // Tests pattern ABSORB(3) + SQUEEZE(2) to ensure proper state management.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = Vec::from_slice([1, 2, 3]);\n\n // Pattern: ABSORB(3), SQUEEZE(2)\n let io_pattern = [0x80000003, 0x00000002];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(elements);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 2);\n assert(output.get(0) != 0);\n assert(output.get(1) != 0);\n assert(output.get(0) != output.get(1)); // Different squeeze outputs should be different\n}\n\n#[test]\nfn test_zero_length_operations() {\n // Verifies that zero-length ABSORB and SQUEEZE operations are handled correctly.\n // Tests pattern ABSORB(0) + SQUEEZE(1) to ensure proper state transitions.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Pattern: ABSORB(0), SQUEEZE(1)\n let io_pattern = [0x80000000, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(Vec::new());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output.get(0) != 0);\n}\n\n#[test]\nfn test_tag_computation() {\n // Verifies the tag computation algorithm using the example from the SAFE specification.\n // Pattern: ABSORB(3), ABSORB(3), SQUEEZE(3)\n // Should aggregate to: ABSORB(6), SQUEEZE(3)\n // Encoded as: [0x80000006, 0x00000003]\n // Tests determinism and pattern differentiation.\n\n let io_pattern = [0x80000003, 0x80000003, 0x00000003];\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test determinism\n let tag2 = compute_tag(io_pattern, domain_separator);\n assert(tag == tag2);\n\n // Test that different patterns produce different tags\n let io_pattern2 = [0x80000003, 0x00000003]; // ABSORB(3), SQUEEZE(3) - different pattern\n let tag3 = compute_tag(io_pattern2, domain_separator);\n assert(tag != tag3);\n}\n\n#[test]\nfn test_tag_computation_debug() {\n println(\"=== SAFE Tag Computation Debug Test ===\");\n\n // Test your specific pattern [2, 2, 2] (ABSORB(2), SQUEEZE(2), ABSORB(2))\n let io_pattern = [0x80000002, 0x00000002, 0x80000002];\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n println(f\"Testing pattern: {io_pattern}\");\n println(\n f\"Expected to aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(2)\",\n );\n println(\n f\"Expected encoded words: [0x80000002, 0x00000002, 0x80000002]\",\n );\n println(\"\");\n\n let tag = compute_tag(io_pattern, domain_separator);\n\n println(f\"=== Expected Rust Output ===\");\n println(\"Pattern [2, 2, 2] (ABSORB(2), SQUEEZE(2), ABSORB(2))\");\n println(\"Domain separator: 0x41424344...\");\n println(\"Tag: 0xce3bb9ee4b2d41c42e9cdda38afe8b6a\");\n println(\"\");\n\n println(f\"=== Noir Output ===\");\n println(f\"Tag: {tag}\");\n println(\"\");\n\n println(\"Compare the tag values above with Rust script!\");\n}\n\n#[test]\nfn test_consecutive_absorb_aggregation() {\n // Test that consecutive ABSORB operations are properly aggregated\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1) should aggregate to ABSORB(2), SQUEEZE(1)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), ABSORB(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001];\n\n // This should aggregate to: ABSORB(2), SQUEEZE(1) = [0x80000002, 0x00000001]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag ABSORB(2), SQUEEZE(1)\n let aggregated_pattern = [0x80000002, 0x00000001];\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(tag == aggregated_tag, \"Consecutive ABSORB operations should aggregate to the same tag\");\n\n // Test that a different pattern produces a different tag\n let different_pattern = [0x80000001, 0x00000001, 0x80000001]; // ABSORB(1), SQUEEZE(1), ABSORB(1)\n let different_tag = compute_tag(different_pattern, domain_separator);\n\n // This should be different because it doesn't have consecutive ABSORB operations\n assert(tag != different_tag, \"Different patterns should produce different tags\");\n\n println(\"=== Consecutive ABSORB Aggregation Test ===\");\n println(\n f\"Original pattern: [0x80000001, 0x80000001, 0x00000001] (ABSORB(1), ABSORB(1), SQUEEZE(1))\",\n );\n println(\n f\"Aggregated pattern: [0x80000002, 0x00000001] (ABSORB(2), SQUEEZE(1))\",\n );\n println(f\"Original tag: {tag}\");\n println(f\"Aggregated tag: {aggregated_tag}\");\n println(f\"Original tag: {tag}\");\n println(f\"Aggregated tag: {aggregated_tag}\");\n println(f\"Different pattern tag: {different_tag}\");\n}\n\n#[test]\nfn test_consecutive_squeeze_aggregation() {\n // Test that consecutive SQUEEZE operations are properly aggregated\n // Pattern: ABSORB(1), SQUEEZE(1), SQUEEZE(1) should aggregate to ABSORB(1), SQUEEZE(2)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), SQUEEZE(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x00000001, 0x00000001];\n\n // This should aggregate to: ABSORB(1), SQUEEZE(2) = [0x80000001, 0x00000002]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag ABSORB(1), SQUEEZE(2)\n let aggregated_pattern = [0x80000001, 0x00000002];\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(\n tag == aggregated_tag,\n \"Consecutive SQUEEZE operations should aggregate to the same tag\",\n );\n\n // Test that a different pattern produces a different tag\n let different_pattern = [0x80000001, 0x00000001, 0x80000001]; // ABSORB(1), SQUEEZE(1), ABSORB(1)\n let different_tag = compute_tag(different_pattern, domain_separator);\n\n // This should be different because it doesn't have consecutive SQUEEZE operations\n assert(tag != different_tag, \"Different patterns should produce different tags\");\n\n println(\"=== Consecutive SQUEEZE Aggregation Test ===\");\n println(\n f\"Original pattern: [0x80000001, 0x00000001, 0x00000001] (ABSORB(1), SQUEEZE(1), SQUEEZE(1))\",\n );\n println(\n f\"Aggregated pattern: [0x80000001, 0x00000002] (ABSORB(1), SQUEEZE(2))\",\n );\n println(f\"Original tag: {tag}\");\n println(f\"Aggregated tag: {aggregated_tag}\");\n println(f\"Different pattern tag: {different_tag}\");\n}\n\n#[test]\nfn test_mixed_consecutive_aggregation() {\n // Test that both consecutive ABSORB and SQUEEZE operations are properly aggregated\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1)\n // Should aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(1)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001, 0x00000001, 0x80000001];\n\n // This should aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(1) = [0x80000002, 0x00000002, 0x80000001]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag\n let aggregated_pattern = [0x80000002, 0x00000002, 0x80000001]; // ABSORB(2), SQUEEZE(2), ABSORB(1)\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(tag == aggregated_tag, \"Mixed consecutive operations should aggregate to the same tag\");\n\n println(\"=== Mixed Consecutive Aggregation Test ===\");\n println(\n f\"Original pattern: [0x80000001, 0x80000001, 0x00000001, 0x00000001, 0x80000001]\",\n );\n println(\n f\" (ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1))\",\n );\n println(f\"Aggregated pattern: [0x80000002, 0x00000002, 0x80000001]\");\n println(f\" (ABSORB(2), SQUEEZE(2), ABSORB(1))\");\n println(f\"Original tag: {tag}\");\n println(f\"Aggregated tag: {aggregated_tag}\");\n}\n\n#[test]\nfn test_large_io_pattern() {\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Create pattern with 48 alternating ABSORB(1) and SQUEEZE(1) operations\n // This is the maximum supported (48 words * 4 bytes = 192 bytes, leaving 64 for domain separator)\n let mut io_pattern = [0u32; 48];\n for i in 0..48 {\n if i % 2 == 0 {\n io_pattern[i] = ABSORB_FLAG | 1; // ABSORB(1)\n } else {\n io_pattern[i] = SQUEEZE_FLAG | 1; // SQUEEZE(1)\n }\n }\n\n let tag = compute_tag(io_pattern, domain_separator);\n assert(tag != 0);\n}\n\n#[test]\nfn test_domain_separator_not_truncated() {\n // This test verifies that the domain separator is always included in the tag computation,\n // even for large IO patterns. If the domain separator were truncated, different domain\n // separators would produce the same tag for large patterns.\n\n let domain_separator_a = [\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41,\n ]; // All 'A's\n\n let domain_separator_b = [\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42,\n ]; // All 'B's\n\n // Create pattern with 48 alternating operations (max supported: 192 bytes of IO pattern)\n let mut io_pattern = [0u32; 48];\n for i in 0..48 {\n if i % 2 == 0 {\n io_pattern[i] = ABSORB_FLAG | 1;\n } else {\n io_pattern[i] = SQUEEZE_FLAG | 1;\n }\n }\n\n let tag_a = compute_tag(io_pattern, domain_separator_a);\n let tag_b = compute_tag(io_pattern, domain_separator_b);\n\n // Tags MUST be different because domain separators are different.\n // If they were the same, it would mean the domain separator was truncated/ignored.\n assert(tag_a != tag_b, \"Domain separator must affect tag even for large IO patterns\");\n}\n","path":"/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr"}},"expression_width":{"Bounded":{"width":4}}} \ No newline at end of file diff --git a/packages/enclave-sdk/tests/fixtures/pubkey.bin b/packages/enclave-sdk/tests/fixtures/pubkey.bin deleted file mode 100644 index c184df399b..0000000000 Binary files a/packages/enclave-sdk/tests/fixtures/pubkey.bin and /dev/null differ diff --git a/packages/enclave-sdk/tests/sdk.test.ts b/packages/enclave-sdk/tests/sdk.test.ts index 8314b0b3bd..6556c0f8a3 100644 --- a/packages/enclave-sdk/tests/sdk.test.ts +++ b/packages/enclave-sdk/tests/sdk.test.ts @@ -5,8 +5,6 @@ // or FITNESS FOR A PARTICULAR PURPOSE. import { describe, expect, it } from 'vitest' -import fs from 'fs/promises' -import path from 'path' import { CompiledCircuit } from '@noir-lang/noir_js' import { EnclaveSDK } from '../src/enclave-sdk' @@ -29,16 +27,16 @@ describe('encryptNumber', () => { }) it('should encrypt a number without crashing in a node environent', async () => { - const buffer = await fs.readFile(path.resolve(__dirname, './fixtures/pubkey.bin')) - const value = await sdk.encryptNumber(10n, Uint8Array.from(buffer)) + const publicKey = await sdk.generatePublicKey() + const value = await sdk.encryptNumber(10n, publicKey) expect(value).to.be.an.instanceof(Uint8Array) expect(value.length).to.equal(9_242) // TODO: test the encryption is correct }) it('should encrypt a number and generate a proof without crashing in a node environent', async () => { - const buffer = await fs.readFile(path.resolve(__dirname, './fixtures/pubkey.bin')) + const publicKey = await sdk.generatePublicKey() - const value = await sdk.encryptNumberAndGenProof(1n, Uint8Array.from(buffer), demoCircuit as unknown as CompiledCircuit) + const value = await sdk.encryptNumberAndGenProof(1n, publicKey, demoCircuit as unknown as CompiledCircuit) expect(value).to.be.an.instanceof(Object) expect(value.encryptedData).to.be.an.instanceof(Uint8Array) @@ -46,20 +44,16 @@ describe('encryptNumber', () => { }, 9999999) it('should encrypt a vector of numbers without crashing in a node environent', async () => { - const buffer = await fs.readFile(path.resolve(__dirname, './fixtures/pubkey.bin')) - const value = await sdk.encryptVector(new BigUint64Array([1n, 2n]), Uint8Array.from(buffer)) + const publicKey = await sdk.generatePublicKey() + const value = await sdk.encryptVector(new BigUint64Array([1n, 2n]), publicKey) expect(value).to.be.an.instanceof(Uint8Array) expect(value.length).to.equal(9_242) }) it('should encrypt a vector and generate a proof without crashing in a node environent', async () => { - const buffer = await fs.readFile(path.resolve(__dirname, './fixtures/pubkey.bin')) + const publicKey = await sdk.generatePublicKey() - const value = await sdk.encryptVectorAndGenProof( - new BigUint64Array([1n, 2n]), - Uint8Array.from(buffer), - demoCircuit as unknown as CompiledCircuit, - ) + const value = await sdk.encryptVectorAndGenProof(new BigUint64Array([1n, 2n]), publicKey, demoCircuit as unknown as CompiledCircuit) expect(value).to.be.an.instanceof(Object) expect(value.encryptedData).to.be.an.instanceof(Uint8Array) diff --git a/templates/default/Cargo.lock b/templates/default/Cargo.lock index 51225f50f3..fa25d00984 100644 --- a/templates/default/Cargo.lock +++ b/templates/default/Cargo.lock @@ -377,15 +377,6 @@ dependencies = [ "serde", ] -[[package]] -name = "android_system_properties" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" -dependencies = [ - "libc", -] - [[package]] name = "anstream" version = "0.6.21" @@ -743,12 +734,6 @@ dependencies = [ "rand 0.8.5", ] -[[package]] -name = "arrayref" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb" - [[package]] name = "arrayvec" version = "0.7.6" @@ -853,20 +838,6 @@ dependencies = [ "wyz", ] -[[package]] -name = "blake3" -version = "1.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2468ef7d57b3fb7e16b576e8377cdbde2320c60e1491e961d11da40fc4f02a2d" -dependencies = [ - "arrayref", - "arrayvec", - "cc", - "cfg-if", - "constant_time_eq", - "cpufeatures", -] - [[package]] name = "block-buffer" version = "0.10.4" @@ -951,20 +922,6 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" -[[package]] -name = "chrono" -version = "0.4.43" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fac4744fb15ae8337dc853fee7fb3f4e48c0fbaa23d0afe49c447b4fab126118" -dependencies = [ - "iana-time-zone", - "js-sys", - "num-traits", - "serde", - "wasm-bindgen", - "windows-link", -] - [[package]] name = "clap" version = "4.5.41" @@ -1049,12 +1006,6 @@ dependencies = [ "unicode-xid", ] -[[package]] -name = "constant_time_eq" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b" - [[package]] name = "convert_case" version = "0.10.0" @@ -1265,14 +1216,12 @@ version = "0.1.8" dependencies = [ "anyhow", "e3-fhe-params", - "e3-greco-helpers", - "e3-polynomial 0.1.8", + "e3-polynomial", "e3-zk-helpers", "fhe", "fhe-traits", "rand 0.8.5", "thiserror", - "zkfhe-greco", ] [[package]] @@ -1308,16 +1257,6 @@ dependencies = [ "thiserror", ] -[[package]] -name = "e3-greco-helpers" -version = "0.1.8" -dependencies = [ - "e3-zk-helpers", - "fhe", - "fhe-math", - "num-bigint", -] - [[package]] name = "e3-parity-matrix" version = "0.1.8" @@ -1340,17 +1279,6 @@ dependencies = [ "thiserror", ] -[[package]] -name = "e3-polynomial" -version = "0.1.8" -source = "git+https://github.com/gnosisguild/enclave?branch=main#ebf6f386dcefd6ab9c5060d4b8932ed1fa1132b9" -dependencies = [ - "num-bigint", - "num-traits", - "serde", - "thiserror", -] - [[package]] name = "e3-program-server" version = "0.1.8" @@ -1377,18 +1305,6 @@ dependencies = [ "taceo-poseidon2", ] -[[package]] -name = "e3-safe" -version = "0.1.8" -source = "git+https://github.com/gnosisguild/enclave#ebf6f386dcefd6ab9c5060d4b8932ed1fa1132b9" -dependencies = [ - "ark-bn254 0.5.0", - "ark-ff 0.5.0", - "hex", - "sha3", - "taceo-poseidon2", -] - [[package]] name = "e3-support-scripts-dev" version = "0.1.0" @@ -1422,10 +1338,11 @@ dependencies = [ "clap", "e3-fhe-params", "e3-parity-matrix", - "e3-polynomial 0.1.8", - "e3-safe 0.1.8", + "e3-polynomial", + "e3-safe", "fhe", "fhe-math", + "fhe-traits", "itertools 0.14.0", "ndarray", "num-bigint", @@ -2037,30 +1954,6 @@ dependencies = [ "windows-registry", ] -[[package]] -name = "iana-time-zone" -version = "0.1.65" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" -dependencies = [ - "android_system_properties", - "core-foundation-sys", - "iana-time-zone-haiku", - "js-sys", - "log", - "wasm-bindgen", - "windows-core", -] - -[[package]] -name = "iana-time-zone-haiku" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" -dependencies = [ - "cc", -] - [[package]] name = "icu_collections" version = "2.1.1" @@ -4223,41 +4116,6 @@ dependencies = [ "wasm-bindgen", ] -[[package]] -name = "windows-core" -version = "0.62.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" -dependencies = [ - "windows-implement", - "windows-interface", - "windows-link", - "windows-result", - "windows-strings", -] - -[[package]] -name = "windows-implement" -version = "0.60.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.114", -] - -[[package]] -name = "windows-interface" -version = "0.59.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.114", -] - [[package]] name = "windows-link" version = "0.2.1" @@ -4606,54 +4464,6 @@ dependencies = [ "tiny-keccak", ] -[[package]] -name = "zkfhe-greco" -version = "0.1.0" -source = "git+https://github.com/gnosisguild/zkfhe-generator#f93990c3064b636dff0b6efead48a3a4341c90db" -dependencies = [ - "anyhow", - "ark-bn254 0.5.0", - "ark-ff 0.5.0", - "blake3", - "e3-polynomial 0.1.8 (git+https://github.com/gnosisguild/enclave?branch=main)", - "fhe", - "fhe-math", - "fhe-traits", - "itertools 0.14.0", - "num-bigint", - "num-traits", - "rand 0.8.5", - "rayon", - "serde", - "serde_json", - "tempfile", - "toml", - "zkfhe-shared", -] - -[[package]] -name = "zkfhe-shared" -version = "0.1.0" -source = "git+https://github.com/gnosisguild/zkfhe-generator#f93990c3064b636dff0b6efead48a3a4341c90db" -dependencies = [ - "anyhow", - "ark-bn254 0.5.0", - "ark-ff 0.5.0", - "chrono", - "e3-polynomial 0.1.8 (git+https://github.com/gnosisguild/enclave?branch=main)", - "e3-safe 0.1.8 (git+https://github.com/gnosisguild/enclave)", - "fhe", - "fhe-math", - "fhe-traits", - "num-bigint", - "num-traits", - "rand 0.8.5", - "serde", - "serde_json", - "thiserror", - "toml", -] - [[package]] name = "zstd" version = "0.13.3"