diff --git a/crates/events/src/enclave_event/proof.rs b/crates/events/src/enclave_event/proof.rs index bbca7eea58..48cc967cee 100644 --- a/crates/events/src/enclave_event/proof.rs +++ b/crates/events/src/enclave_event/proof.rs @@ -36,22 +36,28 @@ impl Proof { /// Circuit identifiers for ZK proofs. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] pub enum CircuitName { - /// BFV public key proof (T0). + /// BFV public key proof (C0). PkBfv, - /// TrBFV public key share proof (T1a). + /// TrBFV public key share proof (C1). PkGeneration, - /// Sk Share computation proof (T1b). + /// Sk Share computation proof (C2a). SkShareComputation, - /// E_SM share computation proof (T1c). + /// E_SM share computation proof (C2b). ESmShareComputation, - /// Encrypted sk share proof (T1d). + /// Encrypted sk share proof (C3a). SkShareEncryption, - /// Encrypted E_SM share proof (T1e). + /// Encrypted E_SM share proof (C3b). ESmShareEncryption, - /// Decryption share proof (T4/T5). - DecShares, - /// Public key aggregation proof (T6). - PkAgg, + /// Sk share decryption proof (C4a). + DkgSkShareDecryption, + /// E_SM share decryption proof (C4b). + DkgESmShareDecryption, + /// Public key aggregation proof (C5). + PkAggregation, + /// Decryption share proof (C6). + ThresholdShareDecryption, + /// Decrypted shares aggregation proof (C7). + DecryptedSharesAggregation, } impl CircuitName { @@ -63,21 +69,27 @@ impl CircuitName { CircuitName::ESmShareComputation => "e_sm_share_computation", CircuitName::SkShareEncryption => "sk_share_encryption", CircuitName::ESmShareEncryption => "e_sm_share_encryption", - CircuitName::DecShares => "dec_shares", - CircuitName::PkAgg => "pk_agg", + CircuitName::DkgSkShareDecryption => "dkg_sk_share_decryption", + CircuitName::DkgESmShareDecryption => "dkg_e_sm_share_decryption", + CircuitName::PkAggregation => "pk_aggregation", + CircuitName::ThresholdShareDecryption => "threshold_share_decryption", + CircuitName::DecryptedSharesAggregation => "decrypted_shares_aggregation", } } pub fn group(&self) -> &'static str { match self { CircuitName::PkBfv => "dkg", - CircuitName::PkGeneration => "threshold", CircuitName::SkShareComputation => "dkg", CircuitName::ESmShareComputation => "dkg", CircuitName::SkShareEncryption => "dkg", CircuitName::ESmShareEncryption => "dkg", - CircuitName::DecShares => "threshold", - CircuitName::PkAgg => "threshold", + CircuitName::DkgSkShareDecryption => "dkg", + CircuitName::DkgESmShareDecryption => "dkg", + CircuitName::PkGeneration => "threshold", + CircuitName::ThresholdShareDecryption => "threshold", + CircuitName::PkAggregation => "threshold", + CircuitName::DecryptedSharesAggregation => "threshold", } } diff --git a/crates/events/src/enclave_event/signed_proof.rs b/crates/events/src/enclave_event/signed_proof.rs index 659ca6bb5e..554b98e0cd 100644 --- a/crates/events/src/enclave_event/signed_proof.rs +++ b/crates/events/src/enclave_event/signed_proof.rs @@ -47,6 +47,8 @@ pub enum ProofType { T2ESmShareDecryption = 7, /// T5 — Share decryption proof (Proof 6). T5ShareDecryption = 8, + /// T6 — Decrypted shares aggregation proof (Proof 7). + T6DecryptedSharesAggregation = 9, } impl ProofType { @@ -59,10 +61,10 @@ impl ProofType { ProofType::T1ESmShareComputation => CircuitName::ESmShareComputation, ProofType::T1SkShareEncryption => CircuitName::SkShareEncryption, ProofType::T1ESmShareEncryption => CircuitName::ESmShareEncryption, - ProofType::T2SkShareDecryption | ProofType::T2ESmShareDecryption => { - CircuitName::DecShares - } - ProofType::T5ShareDecryption => CircuitName::DecShares, + ProofType::T2SkShareDecryption => CircuitName::DkgSkShareDecryption, + ProofType::T2ESmShareDecryption => CircuitName::DkgESmShareDecryption, + ProofType::T5ShareDecryption => CircuitName::ThresholdShareDecryption, + ProofType::T6DecryptedSharesAggregation => CircuitName::DecryptedSharesAggregation, } } @@ -78,6 +80,7 @@ impl ProofType { | ProofType::T2SkShareDecryption | ProofType::T2ESmShareDecryption => "E3_BAD_DKG_PROOF", ProofType::T5ShareDecryption => "E3_BAD_DECRYPTION_PROOF", + ProofType::T6DecryptedSharesAggregation => "E3_BAD_AGGREGATION_PROOF", } } } @@ -309,7 +312,11 @@ mod tests { ); assert_eq!( ProofType::T2SkShareDecryption.circuit_name(), - CircuitName::DecShares + CircuitName::DkgSkShareDecryption + ); + assert_eq!( + ProofType::T5ShareDecryption.circuit_name(), + CircuitName::ThresholdShareDecryption ); } } diff --git a/crates/zk-helpers/src/circuits/dkg/share_decryption/circuit.rs b/crates/zk-helpers/src/circuits/dkg/share_decryption/circuit.rs index e47ba1fba3..6c72975ce5 100644 --- a/crates/zk-helpers/src/circuits/dkg/share_decryption/circuit.rs +++ b/crates/zk-helpers/src/circuits/dkg/share_decryption/circuit.rs @@ -30,4 +30,6 @@ pub struct ShareDecryptionCircuitData { pub secret_key: SecretKey, /// Ciphertexts from H honest parties: [party_idx][mod_idx] (one ciphertext per party per TRBFV modulus). pub honest_ciphertexts: Vec>, + /// Which input type (SecretKey or SmudgingNoise) to resolve circuit path. + pub dkg_input_type: DkgInputType, } diff --git a/crates/zk-helpers/src/circuits/dkg/share_decryption/sample.rs b/crates/zk-helpers/src/circuits/dkg/share_decryption/sample.rs index 9b5ef24337..e1a954f915 100644 --- a/crates/zk-helpers/src/circuits/dkg/share_decryption/sample.rs +++ b/crates/zk-helpers/src/circuits/dkg/share_decryption/sample.rs @@ -130,6 +130,7 @@ impl ShareDecryptionCircuitData { Ok(ShareDecryptionCircuitData { honest_ciphertexts, secret_key: dkg_secret_key, + dkg_input_type, }) } } diff --git a/crates/zk-prover/src/circuits/dkg/mod.rs b/crates/zk-prover/src/circuits/dkg/mod.rs index 1e5adfe226..0a60030a28 100644 --- a/crates/zk-prover/src/circuits/dkg/mod.rs +++ b/crates/zk-prover/src/circuits/dkg/mod.rs @@ -6,4 +6,5 @@ mod pk; mod share_computation; +mod share_decryption; mod share_encryption; diff --git a/crates/zk-prover/src/circuits/dkg/share_computation.rs b/crates/zk-prover/src/circuits/dkg/share_computation.rs index 9ed1f06568..2ba1c14032 100644 --- a/crates/zk-prover/src/circuits/dkg/share_computation.rs +++ b/crates/zk-prover/src/circuits/dkg/share_computation.rs @@ -11,7 +11,6 @@ use e3_zk_helpers::computation::DkgInputType; use e3_zk_helpers::dkg::share_computation::{ Inputs, ShareComputationCircuit, ShareComputationCircuitData, }; -use noirc_abi::InputMap; impl Provable for ShareComputationCircuit { type Params = BfvPreset; diff --git a/crates/zk-prover/src/circuits/dkg/share_decryption.rs b/crates/zk-prover/src/circuits/dkg/share_decryption.rs new file mode 100644 index 0000000000..3778385085 --- /dev/null +++ b/crates/zk-prover/src/circuits/dkg/share_decryption.rs @@ -0,0 +1,37 @@ +// 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::traits::Provable; +use e3_events::CircuitName; +use e3_fhe_params::BfvPreset; +use e3_zk_helpers::computation::DkgInputType; +use e3_zk_helpers::dkg::share_decryption::{ + Inputs, ShareDecryptionCircuit, ShareDecryptionCircuitData, +}; + +impl Provable for ShareDecryptionCircuit { + type Params = BfvPreset; + type Input = ShareDecryptionCircuitData; + type Inputs = Inputs; + + fn resolve_circuit_name(&self, input: &Self::Input) -> CircuitName { + match input.dkg_input_type { + DkgInputType::SecretKey => CircuitName::DkgSkShareDecryption, + DkgInputType::SmudgingNoise => CircuitName::DkgESmShareDecryption, + } + } + + fn valid_circuits(&self) -> Vec { + vec![ + CircuitName::DkgSkShareDecryption, + CircuitName::DkgESmShareDecryption, + ] + } + + fn circuit(&self) -> CircuitName { + CircuitName::DkgSkShareDecryption + } +} diff --git a/crates/zk-prover/src/circuits/threshold/decrypted_shares_aggregation.rs b/crates/zk-prover/src/circuits/threshold/decrypted_shares_aggregation.rs new file mode 100644 index 0000000000..6cf3e3d2f8 --- /dev/null +++ b/crates/zk-prover/src/circuits/threshold/decrypted_shares_aggregation.rs @@ -0,0 +1,23 @@ +// 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::traits::Provable; +use e3_events::CircuitName; +use e3_fhe_params::BfvPreset; +use e3_zk_helpers::circuits::threshold::decrypted_shares_aggregation::circuit::{ + DecryptedSharesAggregationCircuit, DecryptedSharesAggregationCircuitData, +}; +use e3_zk_helpers::circuits::threshold::decrypted_shares_aggregation::computation::Inputs; + +impl Provable for DecryptedSharesAggregationCircuit { + type Params = BfvPreset; + type Input = DecryptedSharesAggregationCircuitData; + type Inputs = Inputs; + + fn circuit(&self) -> CircuitName { + CircuitName::DecryptedSharesAggregation + } +} diff --git a/crates/zk-prover/src/circuits/threshold/mod.rs b/crates/zk-prover/src/circuits/threshold/mod.rs index c7d6cd3a2b..4500d84095 100644 --- a/crates/zk-prover/src/circuits/threshold/mod.rs +++ b/crates/zk-prover/src/circuits/threshold/mod.rs @@ -4,4 +4,7 @@ // without even the implied warranty of MERCHANTABILITY // or FITNESS FOR A PARTICULAR PURPOSE. +mod decrypted_shares_aggregation; +mod pk_aggregation; mod pk_generation; +mod share_decryption; diff --git a/crates/zk-prover/src/circuits/threshold/pk_aggregation.rs b/crates/zk-prover/src/circuits/threshold/pk_aggregation.rs new file mode 100644 index 0000000000..023cdf4d1b --- /dev/null +++ b/crates/zk-prover/src/circuits/threshold/pk_aggregation.rs @@ -0,0 +1,23 @@ +// 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::traits::Provable; +use e3_events::CircuitName; +use e3_fhe_params::BfvPreset; +use e3_zk_helpers::circuits::threshold::pk_aggregation::circuit::{ + PkAggregationCircuit, PkAggregationCircuitData, +}; +use e3_zk_helpers::circuits::threshold::pk_aggregation::computation::Inputs; + +impl Provable for PkAggregationCircuit { + type Params = BfvPreset; + type Input = PkAggregationCircuitData; + type Inputs = Inputs; + + fn circuit(&self) -> CircuitName { + CircuitName::PkAggregation + } +} diff --git a/crates/zk-prover/src/circuits/threshold/share_decryption.rs b/crates/zk-prover/src/circuits/threshold/share_decryption.rs new file mode 100644 index 0000000000..b396730ce2 --- /dev/null +++ b/crates/zk-prover/src/circuits/threshold/share_decryption.rs @@ -0,0 +1,23 @@ +// 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::traits::Provable; +use e3_events::CircuitName; +use e3_fhe_params::BfvPreset; +use e3_zk_helpers::circuits::threshold::share_decryption::circuit::{ + ShareDecryptionCircuit, ShareDecryptionCircuitData, +}; +use e3_zk_helpers::circuits::threshold::share_decryption::computation::Inputs; + +impl Provable for ShareDecryptionCircuit { + type Params = BfvPreset; + type Input = ShareDecryptionCircuitData; + type Inputs = Inputs; + + fn circuit(&self) -> CircuitName { + CircuitName::ThresholdShareDecryption + } +} diff --git a/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation.json b/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation.json new file mode 100644 index 0000000000..00feae8ecb --- /dev/null +++ b/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation.json @@ -0,0 +1,84 @@ +{ + "noir_version": "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", + "hash": "7372809025462699427", + "abi": { + "parameters": [ + { + "name": "decryption_shares", + "type": { + "kind": "array", + "length": 3, + "type": { + "kind": "array", + "length": 2, + "type": { + "kind": "struct", + "path": "lib::math::polynomial::Polynomial", + "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 80, "type": { "kind": "field" } } }] + } + } + }, + "visibility": "public" + }, + { "name": "party_ids", "type": { "kind": "array", "length": 3, "type": { "kind": "field" } }, "visibility": "public" }, + { + "name": "message", + "type": { + "kind": "struct", + "path": "lib::math::polynomial::Polynomial", + "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 80, "type": { "kind": "field" } } }] + }, + "visibility": "public" + }, + { + "name": "u_global", + "type": { + "kind": "struct", + "path": "lib::math::polynomial::Polynomial", + "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 80, "type": { "kind": "field" } } }] + }, + "visibility": "private" + }, + { + "name": "crt_quotients", + "type": { + "kind": "array", + "length": 2, + "type": { + "kind": "struct", + "path": "lib::math::polynomial::Polynomial", + "fields": [{ "name": "coefficients", "type": { "kind": "array", "length": 80, "type": { "kind": "field" } } }] + } + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "991688543994151927": { "error_kind": "string", "string": "Division verification failed: result * rhs ≠ lhs (mod m)" }, + "6347439466827421235": { "error_kind": "string", "string": "CRT reconstruction verification failed" }, + "15764276373176857197": { "error_kind": "string", "string": "Stack too deep" } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "file_map": { + "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::{MAX_MSG_NON_ZERO_COEFFS, T};\nuse lib::configs::default::threshold::{\n DECRYPTED_SHARES_AGGREGATION_BIT_NOISE, DECRYPTED_SHARES_AGGREGATION_CONFIGS, L,\n};\nuse lib::core::threshold::decrypted_shares_aggregation::DecryptedSharesAggregationModular;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n decryption_shares: pub [[Polynomial; L]; T + 1],\n party_ids: pub [Field; T + 1],\n message: pub Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n) {\n let decrypted_shares_aggregation: DecryptedSharesAggregationModular = DecryptedSharesAggregationModular::new(\n DECRYPTED_SHARES_AGGREGATION_CONFIGS,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n );\n\n decrypted_shares_aggregation.execute();\n}\n", + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/threshold/decrypted_shares_aggregation_mod/src/main.nr" + }, + "67": { + "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::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\nuse dep::bignum::BigNum;\nuse dep::bignum::bignum::to_field;\nuse dep::bignum::SecureThreshold8192;\n\n/// Cryptographic parameters for decryption share aggregation circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Plaintext modulus (typically denoted as `t`)\n pub plaintext_modulus: Field,\n /// Precomputed value: `-Q^(-1) mod t` where Q is the product of all CRT moduli\n pub q_inverse_mod_t: Field,\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L], plaintext_modulus: Field, q_inverse_mod_t: Field) -> Self {\n Configs { qis, plaintext_modulus, q_inverse_mod_t }\n }\n}\n\n/// Decrypted Shares Aggregation Circuit (Circuit 7) using BigNum\n/// for large Q values.\n///\n/// Verifies:\n/// 1. Lagrange interpolation to compute u^{(l)} for each CRT basis\n/// 2. CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n/// 3. Decoding verification: message = -Q^{-1} * (t * u_global)_Q mod t\npub struct DecryptedSharesAggregationBigNum {\n /// Circuit parameters including crypto constants\n configs: Configs,\n\n /// Decryption shares from t+1 parties (public witnesses)\n decryption_shares: [[Polynomial; L]; T + 1],\n\n /// Party IDs (x-coordinates) for interpolation (public witnesses)\n /// Note: Must be in strictly increasing order for correct Lagrange sign computation\n party_ids: [Field; T + 1],\n\n /// Message polynomial m(x) (public witness)\n message: Polynomial,\n\n /// Global u polynomial (secret witness)\n u_global: Polynomial,\n\n /// CRT quotient polynomials (secret witnesses)\n crt_quotients: [Polynomial; L],\n}\n/// Decrypted Shares Aggregation Circuit (Circuit 7) using modular arithmetic\n///\n/// Verifies:\n/// 1. Lagrange interpolation to compute u^{(l)} for each CRT basis\n/// 2. CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n/// 3. Decoding verification: message = -Q^{-1} * (t * u_global)_Q mod t\npub struct DecryptedSharesAggregationModular {\n /// Circuit parameters including crypto constants\n configs: Configs,\n\n /// Decryption shares from t+1 parties (public witnesses)\n decryption_shares: [[Polynomial; L]; T + 1],\n\n /// Party IDs (x-coordinates) for interpolation (public witnesses)\n /// Note: Must be in strictly increasing order for correct Lagrange sign computation\n party_ids: [Field; T + 1],\n\n /// Message polynomial m(x) (public witness)\n message: Polynomial,\n\n /// Global u polynomial (secret witness)\n u_global: Polynomial,\n\n /// CRT quotient polynomials (secret witnesses)\n crt_quotients: [Polynomial; L],\n}\n\nimpl DecryptedSharesAggregationBigNum {\n pub fn new(\n configs: Configs,\n decryption_shares: [[Polynomial; L]; T + 1],\n party_ids: [Field; T + 1],\n message: Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n ) -> Self {\n DecryptedSharesAggregationBigNum {\n configs,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n }\n }\n\n /// Main verification function\n pub fn execute(self) {\n // Step 1: Compute Lagrange coefficients in-circuit\n let lagrange_coeffs = compute_all_lagrange_coeffs::(self.configs.qis, self.party_ids);\n\n // Step 2: Compute u^{(l)} for each CRT basis via Lagrange interpolation\n let u_crts = compute_crt_components::(\n self.configs.qis,\n self.decryption_shares,\n lagrange_coeffs,\n );\n\n // Step 3: Verify CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n verify_crt_reconstruction::(\n self.configs.qis,\n self.u_global,\n self.crt_quotients,\n u_crts,\n );\n\n // Step 4: Verify decoding\n self.verify_decoding();\n }\n\n /// Verifies decoding using BigNum for large Q values\n fn verify_decoding(self) {\n // Compute Q as product of all CRT moduli\n let mut q_modulus = 1 as Field;\n for l in 0..L {\n q_modulus *= self.configs.qis[l];\n }\n\n // For centered arithmetic\n let q_bn = SecureThreshold8192::from(q_modulus);\n\n let q_half_bn = q_bn.udiv(SecureThreshold8192::from(2));\n\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n // Compute (t * u_global) mod Q using BigNum\n let u_bn = SecureThreshold8192::from(self.u_global.coefficients[coeff_idx]);\n let t_bn = SecureThreshold8192::from(self.configs.plaintext_modulus);\n let u_bn_mod_q = u_bn.umod(q_bn);\n let t_bn_mod_q = t_bn.umod(q_bn);\n let t_times_u_bn_q = (t_bn_mod_q * u_bn_mod_q).umod(q_bn);\n\n let m = ModU128::new(self.configs.plaintext_modulus);\n\n // Check if centering is needed\n let needs_centering = t_times_u_bn_q > q_half_bn;\n\n let computed_message = if needs_centering {\n // When (t*u) mod Q >= Q/2: treat as negative in centered form\n // Centered value is conceptually negative: (t_times_u_mod_q - Q)\n // -Q^{-1} * (negative) = positive result\n let centered_positive = q_bn - t_times_u_bn_q;\n let centered_positive_mod_t = centered_positive.umod(t_bn);\n let centered_field = to_field(centered_positive_mod_t);\n m.mul_mod(self.configs.q_inverse_mod_t, centered_field)\n } else {\n // When (t*u) mod Q < Q/2: stays positive in centered form\n // -Q^{-1} * (positive) = negative result = t - result\n let t_times_u_bn_t = t_times_u_bn_q.umod(t_bn);\n let t_times_u_field = to_field(t_times_u_bn_t);\n let product = m.mul_mod(self.configs.q_inverse_mod_t, t_times_u_field);\n if product == 0 {\n 0\n } else {\n self.configs.plaintext_modulus - product\n }\n };\n\n // Verify: only check non-zero coefficients\n if self.message.coefficients[coeff_idx] != 0 {\n assert(computed_message == self.message.coefficients[coeff_idx]);\n }\n }\n }\n}\n\nimpl DecryptedSharesAggregationModular {\n pub fn new(\n configs: Configs,\n decryption_shares: [[Polynomial; L]; T + 1],\n party_ids: [Field; T + 1],\n message: Polynomial,\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n ) -> Self {\n DecryptedSharesAggregationModular {\n configs,\n decryption_shares,\n party_ids,\n message,\n u_global,\n crt_quotients,\n }\n }\n\n /// Alternative verification function using efficient modular arithmetic without BigNum.\n ///\n /// Uses `ModU128` for decoding verification instead of BigNum. More efficient when\n /// Q (the product of all CRT moduli) fits within u128 (e.g., 72 bits for insecure parameter sets).\n pub fn execute(self) {\n // Step 1: Compute Lagrange coefficients in-circuit\n let lagrange_coeffs = compute_all_lagrange_coeffs::(self.configs.qis, self.party_ids);\n\n // Step 2: Compute u^{(l)} for each CRT basis via Lagrange interpolation\n let u_crts = compute_crt_components::(\n self.configs.qis,\n self.decryption_shares,\n lagrange_coeffs,\n );\n\n // Step 3: Verify CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global\n verify_crt_reconstruction::(\n self.configs.qis,\n self.u_global,\n self.crt_quotients,\n u_crts,\n );\n // Step 4: Verify decoding\n self.verify_decoding();\n }\n\n /// Alternative decoding verification using the formula:\n /// message = -Q^{-1} * (t * u_global)_Q mod t\n fn verify_decoding(self) {\n let t: Field = self.configs.plaintext_modulus;\n // Compute Q as product of all CRT moduli\n let mut q_modulus = 1;\n for l in 0..L {\n q_modulus *= self.configs.qis[l];\n }\n\n // For centered arithmetic\n let q_half = q_modulus as u128 / 2;\n\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n // Compute (t * u_global) mod Q using BigNum\n let q_mod = ModU128::new(q_modulus);\n let t_mod = ModU128::new(t);\n\n // Compute (t * u_global) mod Q using modular arithmetic functions\n let t_times_u_mod_q = q_mod.mul_mod(t, self.u_global.coefficients[coeff_idx]);\n let needs_centering = (t_times_u_mod_q as u128) > q_half;\n\n let computed_message = if needs_centering {\n // When (t*u) mod Q >= Q/2: treat as negative in centered form\n // Centered value is conceptually negative: (t_times_u_mod_q - Q)\n // -Q^{-1} * (negative) = positive result\n let centered_positive = q_modulus - t_times_u_mod_q;\n let centered_positive_mod_t = t_mod.reduce_mod(centered_positive);\n\n t_mod.mul_mod(self.configs.q_inverse_mod_t, centered_positive_mod_t)\n } else {\n // When (t*u) mod Q < Q/2: stays positive in centered form\n // -Q^{-1} * (positive) = negative result = t - result\n let t_times_u_mod_t = t_mod.reduce_mod(t_times_u_mod_q);\n let product = t_mod.mul_mod(self.configs.q_inverse_mod_t, t_times_u_mod_t);\n if product == 0 {\n 0\n } else {\n t - product\n }\n };\n\n // Verify: only check non-zero coefficients\n if self.message.coefficients[coeff_idx] != 0 {\n assert(computed_message == self.message.coefficients[coeff_idx]);\n }\n }\n }\n}\n\n/// Computes all Lagrange coefficients using optimized modular arithmetic\npub fn compute_all_lagrange_coeffs(\n qis: [Field; L],\n party_ids: [Field; T + 1],\n) -> [[Field; T + 1]; L] {\n let mut lagrange_coeffs = [[0 as Field; T + 1]; L];\n\n // Step 1: Cache |x_i - x_j| factors for all party pairs\n let mut diffs = [[0 as Field; T + 1]; T + 1];\n for i in 0..(T + 1) {\n for j in (i + 1)..(T + 1) {\n let diff = party_ids[j] - party_ids[i];\n diffs[i][j] = diff;\n diffs[j][i] = diff;\n }\n }\n\n // Step 2: Determine signs (same for all parties within a basis)\n let numerator_sign_negative = (T % 2) == 1;\n\n // Step 3: For each CRT basis, compute Lagrange coefficients\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n let m = ModU128::new(q_l);\n\n // Compute product of all party IDs: PRODUCT(j=0..T) x_j mod q_l\n let mut product_x = 1 as Field;\n for j in 0..(T + 1) {\n product_x = m.mul_mod(product_x, party_ids[j]);\n }\n\n // For each party i, compute L_i(0) mod q_l\n for party_idx in 0..(T + 1) {\n // Numerator (absolute value): PRODUCT(j!=party_idx) x_j\n let numerator_abs = m.div_mod(product_x, party_ids[party_idx]);\n\n // Denominator (absolute value): PRODUCT(j!=party_idx) |x_party_idx - x_j|\n let mut denominator_abs = 1 as Field;\n for j in 0..(T + 1) {\n if j != party_idx {\n denominator_abs = m.mul_mod(denominator_abs, diffs[party_idx][j]);\n }\n }\n\n // Determine denominator sign\n let num_greater = T - party_idx;\n let denom_sign_negative = (num_greater % 2) == 1;\n\n // Compute unsigned result: |numerator| / |denominator| mod q_l\n let result_abs = m.div_mod(numerator_abs, denominator_abs);\n\n // Apply combined sign\n let should_negate = numerator_sign_negative != denom_sign_negative;\n let result = if should_negate {\n m.reduce_mod(q_l - result_abs)\n } else {\n result_abs\n };\n\n lagrange_coeffs[basis_idx][party_idx] = result;\n }\n }\n\n lagrange_coeffs\n}\n\n/// Computes u^{(l)} for each CRT basis via Lagrange interpolation\npub fn compute_crt_components(\n qis: [Field; L],\n decryption_shares: [[Polynomial; L]; T + 1],\n lagrange_coeffs: [[Field; T + 1]; L],\n) -> [Polynomial; L] {\n let mut u_crts: [Polynomial; L] =\n [Polynomial::new([0; MAX_MSG_NON_ZERO_COEFFS]); L];\n\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n let m = ModU128::new(q_l);\n let mut u_coeffs = [0 as Field; MAX_MSG_NON_ZERO_COEFFS];\n\n // For each coefficient position\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n let mut u_coeff = 0 as Field;\n\n // Sum all contributions: u = SUM(i=0..T) [d_i * L_i(0)] mod q_l\n for party_idx in 0..(T + 1) {\n let d_coeff = decryption_shares[party_idx][basis_idx].coefficients[coeff_idx];\n let l_i_0 = lagrange_coeffs[basis_idx][party_idx];\n\n let term = m.mul_mod(d_coeff, l_i_0);\n u_coeff = m.reduce_mod(u_coeff + term);\n }\n\n u_coeffs[coeff_idx] = u_coeff;\n }\n\n u_crts[basis_idx] = Polynomial::new(u_coeffs);\n }\n\n u_crts\n}\n\n/// Verifies CRT reconstruction: u^{(l)} + r^{(l)} * q_l = u_global for all bases l\npub fn verify_crt_reconstruction(\n qis: [Field; L],\n u_global: Polynomial,\n crt_quotients: [Polynomial; L],\n u_crts: [Polynomial; L],\n) {\n for basis_idx in 0..L {\n let q_l = qis[basis_idx];\n\n // Compute r^{(l)} * q_l\n let r_times_q = crt_quotients[basis_idx].mul_scalar(q_l);\n\n // Compute u^{(l)} + r^{(l)} * q_l\n let reconstructed = u_crts[basis_idx].add(r_times_q);\n\n // Verify: u^{(l)} + r^{(l)} * q_l = u_global\n // Must hold for every coefficient\n for coeff_idx in 0..MAX_MSG_NON_ZERO_COEFFS {\n assert(\n reconstructed.coefficients[coeff_idx] == u_global.coefficients[coeff_idx],\n \"CRT reconstruction verification failed\",\n );\n }\n }\n}\n", + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/threshold/decrypted_shares_aggregation.nr" + }, + "77": { + "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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\n // 3 * 4 = 12 = 1 (mod 11), so 3^(-1) = 4 (mod 11)\n assert(result == 4);\n // Verify: 3 * result = 1 (mod 11)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n // 3^(-1) mod 11 = 4 (since 3 * 4 = 12 = 1 mod 11)\n // 7 * 4 = 28 = 6 (mod 11)\n assert(result == 6);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n", + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/U128.nr" + }, + "79": { + "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//! Unconstrained functions for modular u128 arithmetic.\n//!\n//! This module provides unconstrained functions that perform modular arithmetic\n//! computations without generating circuit constraints. These functions are used\n//! internally by the constrained operations in `U128` and should not be called\n//! directly in circuits without proper verification.\n\n/// Computes quotient and remainder for value modulo q (unconstrained).\n///\n/// This function performs integer division and modulo operations to compute\n/// `value = q * quotient + remainder` where `0 <= remainder < q`.\n///\n/// # Arguments\n/// * `value` - The value to reduce\n/// * `q` - The modulus\n///\n/// # Returns\n/// A tuple `(quotient, remainder)` where:\n/// - `quotient = value / q`\n/// - `remainder = value % q`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __compute_mod_reduction(value: Field, q: Field) -> (Field, Field) {\n let value_u128 = value as u128;\n let q_u128 = q as u128;\n\n let quotient_u128 = value_u128 / q_u128;\n let remainder_u128 = value_u128 % q_u128;\n\n (quotient_u128 as Field, remainder_u128 as Field)\n}\n\n/// Computes the negation of a value modulo m (unconstrained).\n///\n/// Returns `(m - val) mod m`, with special handling for zero (returns 0).\n///\n/// # Arguments\n/// * `val` - The value to negate\n/// * `m` - The modulus\n///\n/// # Returns\n/// The additive inverse `(-val) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __neg(val: Field, m: Field) -> Field {\n if val == 0 {\n 0\n } else {\n m - val\n }\n}\n\n/// Subtracts two values with underflow handling (unconstrained).\n///\n/// Computes `(lhs - rhs) mod m`, handling the case where `lhs < rhs` by adding\n/// the modulus. Returns both the result and a flag indicating if underflow occurred.\n///\n/// # Preconditions\n/// Inputs must be reduced modulo `m` such that `lhs, rhs in [0, m)`. This ensures\n/// that the computed difference is bounded and cannot overflow `u128`.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value (minuend), must be in `[0, m)`\n/// * `rhs` - Right-hand side value (subtrahend), must be in `[0, m)`\n/// * `m` - The modulus, must satisfy `m <= u128::MAX`\n///\n/// # Returns\n/// A tuple `(result, underflow)` where:\n/// - `result = (lhs - rhs) mod m`\n/// - `underflow = true` if `lhs < rhs`, `false` otherwise\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\n/// As long as inputs are reduced modulo `m` (and `m <= u128::MAX`), the subtraction-with-underflow\n/// logic is safe and will not overflow `u128`. This function is used by the constrained `sub` method\n/// in `modulo::U128`, which ensures inputs are properly reduced before calling `__sub_with_underflow`.\n/// See the surrounding `modulo/unconstrained_U128` module documentation for details.\npub unconstrained fn __sub_with_underflow(lhs: Field, rhs: Field, m: Field) -> (Field, bool) {\n let lhs_u128 = lhs as u128;\n let rhs_u128 = rhs as u128;\n let m_u128 = m as u128;\n\n let underflow = lhs_u128 < rhs_u128;\n let result = if underflow {\n // Compute (lhs - rhs + m) mod m safely to avoid u128 overflow\n // Since lhs < rhs, we compute: m - (rhs - lhs)\n // This avoids the potential overflow in lhs + m\n let diff = rhs_u128 - lhs_u128; // This is safe since rhs > lhs\n (m_u128 - diff) as Field\n } else {\n (lhs_u128 - rhs_u128) as Field\n };\n (result, underflow)\n}\n\n/// Multiplies two values and returns both quotient and remainder (unconstrained).\n///\n/// Computes `lhs * rhs = m * quotient + remainder` where `0 <= remainder < m`.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value\n/// * `rhs` - Right-hand side value\n/// * `m` - The modulus\n///\n/// # Returns\n/// A tuple `(quotient, remainder)` where `lhs * rhs = m * quotient + remainder`\n///\n/// # Overflow Warning\n/// Field multiplication wraps modulo the field prime (~254 bits). For two u128 values\n/// near 2^128, their product (up to 2^256) exceeds the Field modulus, causing silent\n/// wraparound before the mod reduction. This can produce incorrect results.\n///\n/// # Safe Input Range\n/// To avoid overflow, ensure `lhs * rhs < Field::MODULUS`. For typical use cases:\n/// - Party IDs, polynomial coefficients, and small cryptographic values (< 2^64) are safe\n/// - Arbitrary u128 values may overflow and should be validated by callers\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\n/// Callers must ensure inputs are within the safe range to prevent silent overflow.\npub unconstrained fn __mul_with_quotient(lhs: Field, rhs: Field, m: Field) -> (Field, Field) {\n // WARNING: Field multiplication can overflow for large inputs.\n // For u128 values near 2^128, the product (up to 2^256) exceeds Field modulus (~2^254),\n // causing wraparound. This is safe for typical use cases (party IDs, small coefficients),\n // but callers must validate input ranges for arbitrary u128 values.\n let product = lhs * rhs;\n __compute_mod_reduction(product, m)\n}\n\n/// Computes the modular multiplicative inverse using Fermat's Little Theorem (unconstrained).\n///\n/// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n/// using the identity: val^(-1) = val^(m-2) (mod m) (from Fermat's Little Theorem).\n///\n/// # Arguments\n/// * `val` - The value to invert (must be coprime with the modulus)\n/// * `m` - The modulus (should be prime for this method to work correctly)\n///\n/// # Returns\n/// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __inv_mod(val: Field, m: Field) -> Field {\n // by Fermat's Little Theorem: val^(m-1)= 1 mod m\n __pow_mod(val, m - 2, m)\n}\n\n/// Computes modular division: `lhs * rhs^(-1) mod m` (unconstrained).\n///\n/// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n///\n/// # Arguments\n/// * `lhs` - The numerator\n/// * `rhs` - The denominator (must be coprime with the modulus)\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `(lhs * rhs^(-1)) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __div_mod(lhs: Field, rhs: Field, m: Field) -> Field {\n let rhs_inv = __inv_mod(rhs, m);\n __mul_mod(lhs, rhs_inv, m)\n}\n\n/// Computes modular exponentiation: `base^exp mod m` (unconstrained).\n///\n/// Uses the binary exponentiation method (also known as square-and-multiply)\n/// for efficient computation of large powers.\n///\n/// # Arguments\n/// * `base` - The base value\n/// * `exp` - The exponent\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `base^exp mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __pow_mod(base: Field, exp: Field, m: Field) -> Field {\n let mut result = 1 as Field;\n let (_, base_mod) = __compute_mod_reduction(base, m);\n let mut current_base = base_mod;\n let mut e = exp as u128;\n\n while e > 0 {\n if (e % 2) == 1 {\n result = __mul_mod(result, current_base, m);\n }\n current_base = __mul_mod(current_base, current_base, m);\n e = e / 2;\n }\n\n result\n}\n\n/// Multiplies two values with modular reduction (unconstrained).\n///\n/// Computes `(lhs * rhs) mod m` and returns only the remainder.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value\n/// * `rhs` - Right-hand side value\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `(lhs * rhs) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __mul_mod(lhs: Field, rhs: Field, m: Field) -> Field {\n let (_, r) = __mul_with_quotient(lhs, rhs, m);\n r\n}\n\n// ------------------------------ TESTS ------------------------------\n// Note: All unsafe blocks in the following tests are safe because we are testing\n// unconstrained functions in a controlled test environment. These functions are\n// designed to be called from unsafe blocks or other unconstrained functions.\n// Each unsafe block is used to call an unconstrained function for testing purposes.\n\n#[test]\nfn test_compute_mod_reduction_simple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(42, 10) };\n assert(q == 4); // 42 / 10 = 4\n assert(r == 2); // 42 % 10 = 2\n // Verify: 42 = 10 * 4 + 2\n assert(10 * q + r == 42);\n}\n\n#[test]\nfn test_compute_mod_reduction_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(100, 10) };\n assert(q == 10); // 100 / 10 = 10\n assert(r == 0); // 100 % 10 = 0\n assert(10 * q + r == 100);\n}\n\n#[test]\nfn test_compute_mod_reduction_large_value() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(12345, 100) };\n assert(q == 123); // 12345 / 100 = 123\n assert(r == 45); // 12345 % 100 = 45\n assert(100 * q + r == 12345);\n}\n\n#[test]\nfn test_compute_mod_reduction_smaller_than_modulus() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(7, 10) };\n assert(q == 0); // 7 / 10 = 0\n assert(r == 7); // 7 % 10 = 7\n assert(10 * q + r == 7);\n}\n\n#[test]\nfn test_neg_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(0, 100) };\n assert(result == 0); // Negation of zero is zero\n}\n\n#[test]\nfn test_neg_non_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(30, 100) };\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_large_value() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(12345, 100000) };\n assert(result == 87655); // 100000 - 12345 = 87655\n}\n\n#[test]\nfn test_neg_verification() {\n let val: Field = 42;\n let m: Field = 97;\n // Safety: Test function calling unconstrained helper\n let neg_val = unsafe { __neg(val, m) };\n // Verify: val + neg_val = 0 (mod m)\n let sum = val + neg_val;\n // Safety: Test function calling unconstrained helper\n let (_, remainder) = unsafe { __compute_mod_reduction(sum, m) };\n assert(remainder == 0);\n}\n\n#[test]\nfn test_sub_with_underflow_no_underflow() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(50, 30, 100) };\n assert(underflow == false);\n assert(result == 20); // 50 - 30 = 20\n}\n\n#[test]\nfn test_sub_with_underflow_with_underflow() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(30, 50, 100) };\n assert(underflow == true);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_with_underflow_equal_values() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(42, 42, 100) };\n assert(underflow == false);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\n}\n\n#[test]\nfn test_mul_with_quotient_simple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(6, 7, 10) };\n assert(q == 4); // (6 * 7) / 10 = 42 / 10 = 4\n assert(r == 2); // (6 * 7) % 10 = 42 % 10 = 2\n // Verify: 6 * 7 = 10 * 4 + 2\n assert(6 * 7 == 10 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(12, 15, 100) };\n assert(q == 1); // (12 * 15) / 100 = 180 / 100 = 1\n assert(r == 80); // (12 * 15) % 100 = 180 % 100 = 80\n assert(12 * 15 == 100 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(5, 20, 100) };\n assert(q == 1); // (5 * 20) / 100 = 100 / 100 = 1\n assert(r == 0); // (5 * 20) % 100 = 100 % 100 = 0\n assert(5 * 20 == 100 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_verification() {\n let lhs: Field = 123;\n let rhs: Field = 456;\n let m: Field = 1000;\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(lhs, rhs, m) };\n // Verify: lhs * rhs = m * q + r\n assert(lhs * rhs == m * q + r);\n // Verify remainder is in range [0, m)\n assert((r as u128) < (m as u128));\n}\n\n#[test]\nfn test_mul_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(6, 7, 10) };\n assert(result == 2); // (6 * 7) mod 10 = 42 mod 10 = 2\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(12, 15, 100) };\n assert(result == 80); // (12 * 15) mod 100 = 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(5, 20, 100) };\n assert(result == 0); // (5 * 20) mod 100 = 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(42, 0, 100) };\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_commutative() {\n let a: Field = 7;\n let b: Field = 9;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let mul_a_b = unsafe { __mul_mod(a, b, m) };\n // Safety: Test function calling unconstrained helper\n let mul_b_a = unsafe { __mul_mod(b, a, m) };\n // Verify: a * b = b * a\n assert(mul_a_b == mul_b_a);\n}\n\n#[test]\nfn test_pow_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(2, 3, 10) };\n assert(result == 8); // 2^3 mod 10 = 8 mod 10 = 8\n}\n\n#[test]\nfn test_pow_mod_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(2, 10, 100) };\n assert(result == 24); // 2^10 = 1024, 1024 mod 100 = 24\n}\n\n#[test]\nfn test_pow_mod_exponent_one() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(7, 1, 100) };\n assert(result == 7); // 7^1 mod 100 = 7\n}\n\n#[test]\nfn test_pow_mod_exponent_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(7, 0, 100) };\n assert(result == 1); // 7^0 mod 100 = 1\n}\n\n#[test]\nfn test_pow_mod_base_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(0, 5, 100) };\n assert(result == 0); // 0^5 mod 100 = 0\n}\n\n#[test]\nfn test_pow_mod_large_exponent() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(3, 7, 97) };\n // 3^7 = 2187, 2187 mod 97 = 53\n assert(result == 53);\n}\n\n#[test]\nfn test_pow_mod_fermat_little_theorem() {\n // For prime modulus p and value a, a^(p-1) = 1 (mod p)\n let a: Field = 3;\n let p: Field = 11; // Prime\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(a, p - 1, p) };\n assert(result == 1);\n}\n\n#[test]\nfn test_inv_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(3, 11) };\n // 3 * 4 = 12 = 1 (mod 11), so 3^(-1) = 4 (mod 11)\n assert(result == 4);\n // Verify: 3 * result = 1 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(3, result, 11) } == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(7, 13) };\n // Verify: 7 * result = 1 (mod 13)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(7, result, 13) } == 1);\n}\n\n#[test]\nfn test_inv_mod_another_prime() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(5, 17) };\n // Verify: 5 * result = 1 (mod 17)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(5, result, 17) } == 1);\n}\n\n#[test]\nfn test_inv_mod_inverse_of_inverse() {\n let a: Field = 7;\n let m: Field = 11;\n // Safety: Test function calling unconstrained helper\n let inv_a = unsafe { __inv_mod(a, m) };\n // Safety: Test function calling unconstrained helper\n let inv_inv_a = unsafe { __inv_mod(inv_a, m) };\n // (a^(-1))^(-1) = a\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_div_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(6, 2, 11) };\n assert(result == 3); // 6 / 2 = 3\n // Verify: result * 2 = 6 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 2, 11) } == 6);\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(7, 3, 11) };\n // 3^(-1) mod 11 = 4 (since 3 * 4 = 12 = 1 mod 11)\n // 7 * 4 = 28 = 6 (mod 11)\n assert(result == 6);\n // Verify: result * 3 = 7 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 3, 11) } == 7);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a: Field = 10;\n let b: Field = 3;\n let m: Field = 17;\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(a, b, m) };\n // Verify: result * b = a (mod m)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, b, m) } == a);\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a: Field = 250;\n let b: Field = 7;\n let m: Field = 97;\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(a, b, m) };\n // Verify: result * b = a (mod m)\n // Safety: Test function calling unconstrained helper\n let (_, a_reduced) = unsafe { __compute_mod_reduction(a, m) }; // 250 mod 97 = 56\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, b, m) } == a_reduced);\n}\n\n#[test]\nfn test_div_mod_by_one() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(42, 1, 100) };\n assert(result == 42); // 42 / 1 = 42\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 1, 100) } == 42);\n}\n\n#[test]\nfn test_all_operations_consistency() {\n // Test that all operations work together correctly\n let m: Field = 97; // Prime\n let a: Field = 42;\n let b: Field = 13;\n\n // Test: (a + b) mod m\n let sum = a + b;\n // Safety: Test function calling unconstrained helper\n let (_, sum_reduced) = unsafe { __compute_mod_reduction(sum, m) };\n assert(sum_reduced == 55);\n\n // Test: (a - b) mod m using subtraction\n // Safety: Test function calling unconstrained helper\n let (diff, _) = unsafe { __sub_with_underflow(a, b, m) };\n assert(diff == 29);\n\n // Test: (a * b) mod m\n // Safety: Test function calling unconstrained helper\n let prod = unsafe { __mul_mod(a, b, m) };\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test: b^(-1) mod m\n // Safety: Test function calling unconstrained helper\n let inv = unsafe { __inv_mod(b, m) };\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(b, inv, m) } == 1);\n\n // Test: (a / b) mod m\n // Safety: Test function calling unconstrained helper\n let quot = unsafe { __div_mod(a, b, m) };\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(quot, b, m) } == a);\n\n // Test: (-a) mod m\n // Safety: Test function calling unconstrained helper\n let neg = unsafe { __neg(a, m) };\n let sum_neg = a + neg;\n // Safety: Test function calling unconstrained helper\n let (_, sum_neg_reduced) = unsafe { __compute_mod_reduction(sum_neg, m) };\n assert(sum_neg_reduced == 0);\n}\n", + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr" + } + }, + "expression_width": { "Bounded": { "width": 4 } } +} diff --git a/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation.vk b/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation.vk new file mode 100644 index 0000000000..562dea5f7f Binary files /dev/null and b/crates/zk-prover/tests/fixtures/decrypted_shares_aggregation.vk differ diff --git a/crates/zk-prover/tests/fixtures/dkg_e_sm_share_decryption.json b/crates/zk-prover/tests/fixtures/dkg_e_sm_share_decryption.json new file mode 100644 index 0000000000..0234543f66 --- /dev/null +++ b/crates/zk-prover/tests/fixtures/dkg_e_sm_share_decryption.json @@ -0,0 +1,61 @@ +{ + "noir_version": "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", + "hash": "9828651845942763134", + "abi": { + "parameters": [ + { + "name": "expected_commitments", + "type": { "kind": "array", "length": 5, "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } }, + "visibility": "public" + }, + { + "name": "decrypted_shares", + "type": { + "kind": "array", + "length": 5, + "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" + } + ], + "return_type": { "abi_type": { "kind": "field" }, "visibility": "public" }, + "error_types": { "10481401461242010843": { "error_kind": "string", "string": "Commitment mismatch" } } + }, + "bytecode": "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", + "debug_symbols": "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", + "file_map": { + "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::dkg::{L_THRESHOLD, N, SHARE_DECRYPTION_BIT_MSG};\nuse lib::configs::default::H;\nuse lib::core::dkg::share_decryption::ShareDecryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_commitments: pub [[Field; L_THRESHOLD]; H],\n decrypted_shares: [[Polynomial; L_THRESHOLD]; H],\n) -> pub Field {\n let share_decryption: ShareDecryption =\n ShareDecryption::new(expected_commitments, decrypted_shares);\n\n share_decryption.execute()\n}\n", + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/dkg/share_decryption/src/main.nr" + }, + "64": { + "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::{\n compute_aggregated_shares_commitment, compute_share_encryption_commitment_from_message,\n};\nuse crate::math::polynomial::Polynomial;\n\n/// Share Decryption Commitment Verification (Circuit 4).\n///\n/// Verifies:\n/// 1. Each decrypted share from H honest parties matches its commitment from Circuit 3\n/// 2. Computes sum of all shares\n/// 3. Returns commitment to aggregated shares\npub struct ShareDecryption {\n /// Expected commitments from Circuit 3 for H honest parties: [party_idx][mod_idx]\n /// (public witness)\n expected_commitments: [[Field; L]; H],\n\n /// Decrypted shares from H honest parties: [party_idx][mod_idx]\n /// (secret witnesses)\n decrypted_shares: [[Polynomial; L]; H],\n}\n\nimpl ShareDecryption {\n pub fn new(\n expected_commitments: [[Field; L]; H],\n decrypted_shares: [[Polynomial; L]; H],\n ) -> Self {\n ShareDecryption { expected_commitments, decrypted_shares }\n }\n\n /// Verifies all decrypted shares match their expected commitments\n fn verify_commitments(self) {\n for party_idx in 0..H {\n for mod_idx in 0..L {\n assert(\n compute_share_encryption_commitment_from_message::(\n self.decrypted_shares[party_idx][mod_idx],\n )\n == self.expected_commitments[party_idx][mod_idx],\n \"Commitment mismatch\",\n );\n }\n }\n }\n\n /// Computes sum of all decrypted shares\n fn compute_aggregated_shares(self) -> [Polynomial; L] {\n let mut sum: [Polynomial; L] = [Polynomial::new([0; N]); L];\n\n for mod_idx in 0..L {\n let mut coeffs = [0 as Field; N];\n for coeff_idx in 0..N {\n let mut total = 0 as Field;\n for party_idx in 0..H {\n total =\n total + self.decrypted_shares[party_idx][mod_idx].coefficients[coeff_idx];\n }\n coeffs[coeff_idx] = total;\n }\n sum[mod_idx] = Polynomial::new(coeffs);\n }\n\n sum\n }\n\n /// Main verification function\n /// Returns commitment to aggregated shares\n pub fn execute(self) -> Field {\n // Step 1: Verify all commitments match\n self.verify_commitments();\n\n // Step 2: Compute aggregated shares\n let aggregated = self.compute_aggregated_shares();\n\n // Step 3: Return commitment to aggregated shares\n compute_aggregated_shares_commitment::(aggregated)\n }\n}\n", + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/dkg/share_decryption.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" + }, + "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 } } +} diff --git a/crates/zk-prover/tests/fixtures/dkg_e_sm_share_decryption.vk b/crates/zk-prover/tests/fixtures/dkg_e_sm_share_decryption.vk new file mode 100644 index 0000000000..a9f3fd5ef3 Binary files /dev/null and b/crates/zk-prover/tests/fixtures/dkg_e_sm_share_decryption.vk differ diff --git a/crates/zk-prover/tests/fixtures/dkg_sk_share_decryption.json b/crates/zk-prover/tests/fixtures/dkg_sk_share_decryption.json new file mode 100644 index 0000000000..0234543f66 --- /dev/null +++ b/crates/zk-prover/tests/fixtures/dkg_sk_share_decryption.json @@ -0,0 +1,61 @@ +{ + "noir_version": "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", + "hash": "9828651845942763134", + "abi": { + "parameters": [ + { + "name": "expected_commitments", + "type": { "kind": "array", "length": 5, "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } }, + "visibility": "public" + }, + { + "name": "decrypted_shares", + "type": { + "kind": "array", + "length": 5, + "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" + } + ], + "return_type": { "abi_type": { "kind": "field" }, "visibility": "public" }, + "error_types": { "10481401461242010843": { "error_kind": "string", "string": "Commitment mismatch" } } + }, + "bytecode": "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", + "debug_symbols": "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", + "file_map": { + "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::dkg::{L_THRESHOLD, N, SHARE_DECRYPTION_BIT_MSG};\nuse lib::configs::default::H;\nuse lib::core::dkg::share_decryption::ShareDecryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_commitments: pub [[Field; L_THRESHOLD]; H],\n decrypted_shares: [[Polynomial; L_THRESHOLD]; H],\n) -> pub Field {\n let share_decryption: ShareDecryption =\n ShareDecryption::new(expected_commitments, decrypted_shares);\n\n share_decryption.execute()\n}\n", + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/dkg/share_decryption/src/main.nr" + }, + "64": { + "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::{\n compute_aggregated_shares_commitment, compute_share_encryption_commitment_from_message,\n};\nuse crate::math::polynomial::Polynomial;\n\n/// Share Decryption Commitment Verification (Circuit 4).\n///\n/// Verifies:\n/// 1. Each decrypted share from H honest parties matches its commitment from Circuit 3\n/// 2. Computes sum of all shares\n/// 3. Returns commitment to aggregated shares\npub struct ShareDecryption {\n /// Expected commitments from Circuit 3 for H honest parties: [party_idx][mod_idx]\n /// (public witness)\n expected_commitments: [[Field; L]; H],\n\n /// Decrypted shares from H honest parties: [party_idx][mod_idx]\n /// (secret witnesses)\n decrypted_shares: [[Polynomial; L]; H],\n}\n\nimpl ShareDecryption {\n pub fn new(\n expected_commitments: [[Field; L]; H],\n decrypted_shares: [[Polynomial; L]; H],\n ) -> Self {\n ShareDecryption { expected_commitments, decrypted_shares }\n }\n\n /// Verifies all decrypted shares match their expected commitments\n fn verify_commitments(self) {\n for party_idx in 0..H {\n for mod_idx in 0..L {\n assert(\n compute_share_encryption_commitment_from_message::(\n self.decrypted_shares[party_idx][mod_idx],\n )\n == self.expected_commitments[party_idx][mod_idx],\n \"Commitment mismatch\",\n );\n }\n }\n }\n\n /// Computes sum of all decrypted shares\n fn compute_aggregated_shares(self) -> [Polynomial; L] {\n let mut sum: [Polynomial; L] = [Polynomial::new([0; N]); L];\n\n for mod_idx in 0..L {\n let mut coeffs = [0 as Field; N];\n for coeff_idx in 0..N {\n let mut total = 0 as Field;\n for party_idx in 0..H {\n total =\n total + self.decrypted_shares[party_idx][mod_idx].coefficients[coeff_idx];\n }\n coeffs[coeff_idx] = total;\n }\n sum[mod_idx] = Polynomial::new(coeffs);\n }\n\n sum\n }\n\n /// Main verification function\n /// Returns commitment to aggregated shares\n pub fn execute(self) -> Field {\n // Step 1: Verify all commitments match\n self.verify_commitments();\n\n // Step 2: Compute aggregated shares\n let aggregated = self.compute_aggregated_shares();\n\n // Step 3: Return commitment to aggregated shares\n compute_aggregated_shares_commitment::(aggregated)\n }\n}\n", + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/dkg/share_decryption.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" + }, + "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 } } +} diff --git a/crates/zk-prover/tests/fixtures/dkg_sk_share_decryption.vk b/crates/zk-prover/tests/fixtures/dkg_sk_share_decryption.vk new file mode 100644 index 0000000000..a9f3fd5ef3 Binary files /dev/null and b/crates/zk-prover/tests/fixtures/dkg_sk_share_decryption.vk differ diff --git a/crates/zk-prover/tests/fixtures/e_sm_share_computation.json b/crates/zk-prover/tests/fixtures/e_sm_share_computation.json index a53e673b6d..e5ed627233 100644 --- a/crates/zk-prover/tests/fixtures/e_sm_share_computation.json +++ b/crates/zk-prover/tests/fixtures/e_sm_share_computation.json @@ -1,6 +1,6 @@ { "noir_version": "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", - "hash": "14451764501588190058", + "hash": "12506177918275697276", "abi": { "parameters": [ { "name": "expected_secret_commitment", "type": { "kind": "field" }, "visibility": "public" }, @@ -52,35 +52,35 @@ }, "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::dkg::{\n L_THRESHOLD, N, PARITY_MATRIX, SHARE_COMPUTATION_BIT_SHARE, SHARE_COMPUTATION_E_SM_BIT_SECRET,\n SHARE_COMPUTATION_E_SM_CONFIGS,\n};\nuse lib::configs::default::{N_PARTIES, T};\nuse lib::core::dkg::share_computation::SmudgingNoiseShareComputation;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_secret_commitment: pub Field,\n e_sm_secret: [Polynomial; L_THRESHOLD],\n y: [[[Field; N_PARTIES + 1]; L_THRESHOLD]; N],\n) -> pub [[Field; L_THRESHOLD]; N_PARTIES] {\n let share_computation_e_sm: SmudgingNoiseShareComputation = SmudgingNoiseShareComputation::new(\n SHARE_COMPUTATION_E_SM_CONFIGS,\n expected_secret_commitment,\n e_sm_secret,\n y,\n PARITY_MATRIX,\n );\n\n share_computation_e_sm.execute()\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/bin/dkg/e_sm_share_computation/src/main.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/dkg/e_sm_share_computation/src/main.nr" }, "63": { "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::{\n compute_share_computation_e_sm_commitment, compute_share_computation_sk_commitment,\n compute_share_encryption_commitment_from_shares,\n};\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Threshold secret share verification circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L]) -> Self {\n Configs { qis }\n }\n}\n\n/// Correct Threshold Secret Key Share Computation (Circuit 2a).\n///\n/// Verifies:\n/// 1. secret commitment: verify secret hashes to expected_secret_commitment\n/// 2. secret consistency: y[i][j][0] == sk_secret[i] for all i, j\n/// 3. Range check: shares are in [0, q_j)\n/// 4. Parity check: H[j] * y[i][j]^T == 0 mod q_j for all i, j\n///\n/// For SK: sk_secret is the trinary coefficients\npub struct SecretKeyShareComputation {\n configs: Configs,\n /// Expected commitment to secret (from C1)\n /// (public witness)\n expected_secret_commitment: Field,\n /// Secret key polynomial: Polynomial\n /// trinary coefficients\n /// (secret witness)\n sk_secret: Polynomial,\n /// Shares: y[coeff_idx][mod_idx][0..N_PARTIES+1]\n /// y[i][j][0] = sk_secret[i] = f(0), y[i][j][k] = f(k) for k = 1..N_PARTIES\n /// (secret witnesses)\n y: [[[Field; N_PARTIES + 1]; L]; N],\n /// Parity check matrices: H[mod_idx][row][col]\n /// Size per modulus: (N_PARTIES - T) * (N_PARTIES + 1)\n /// H * y^T = 0 mod q_j\n /// (public constants)\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n}\n\n/// Correct Threshold Smudging Noise Share Computation (Circuit 2b).\n///\n/// Verifies:\n/// 1. secret commitment: verify secret hashes to expected_secret_commitment\n/// 2. secret consistency: y[i][j][0] == e_sm[j][i] for all i, j\n/// 3. Range check: shares are in [0, q_j)\n/// 4. Parity check: H[j] * y[i][j]^T == 0 mod q_j for all i, j\n///\n/// For ESM: e_sm[j] is the RNS representation at modulus j\npub struct SmudgingNoiseShareComputation {\n configs: Configs,\n /// Expected commitment to secret (from C1)\n /// This is computed from all L RNS polynomials (matching\n /// multiple_polynomial_payload's behavior which hashes all L modulus polynomials)\n expected_secret_commitment: Field,\n /// Smudging noise polynomial per modulus: [Polynomial; L]\n /// For ESM: each modulus has its own polynomial (RNS representation)\n e_sm_secret: [Polynomial; L],\n /// Shares: y[coeff_idx][mod_idx][0..N_PARTIES+1]\n /// y[i][j][0] = e_sm[j][i] = f(0), y[i][j][k] = f(k) for k = 1..N_PARTIES\n y: [[[Field; N_PARTIES + 1]; L]; N],\n /// Parity check matrices: H[mod_idx][row][col]\n /// Size per modulus: (N_PARTIES - T) * (N_PARTIES + 1)\n /// H * y^T = 0 mod q_j\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n}\n\nimpl SecretKeyShareComputation {\n pub fn new(\n configs: Configs,\n expected_secret_commitment: Field,\n sk_secret: Polynomial,\n y: [[[Field; N_PARTIES + 1]; L]; N],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n ) -> Self {\n SecretKeyShareComputation { configs, expected_secret_commitment, sk_secret, y, h }\n }\n\n /// Main verification function\n pub fn execute(self) -> [[Field; L]; N_PARTIES] {\n // Step 1: Verify secret commitment matches expected\n self.verify_secret_commitment();\n\n // Step 2: Verify secret consistency\n self.verify_secret_consistency();\n\n // Step 3: Range checks\n check_range_bounds::(self.configs.qis, self.y);\n\n // Step 4: Verify parity check\n verify_parity_check::(self.configs.qis, self.h, self.y);\n\n // Step 5: Commit to shares for each party and modulus\n commit_to_party_shares::(self.y)\n }\n\n /// Verifies that secret hashes to expected_secret_commitment\n fn verify_secret_commitment(self) {\n assert(\n compute_share_computation_sk_commitment::(self.sk_secret)\n == self.expected_secret_commitment,\n \"SK commitment mismatch\",\n );\n }\n\n /// Verifies secret consistency: `y[i][j][0] == sk_secret[i]` for all i, j.\n ///\n /// This function ensures that for each coefficient i and CRT basis j, the share\n /// at party ID 0 equals the corresponding secret coefficient for that modulus.\n /// This is a fundamental property of Shamir secret sharing where the secret is the\n /// evaluation of the sharing polynomial at point 0.\n ///\n /// sk_secret is the trinary coefficients, so y[i][j][0] is the same for all j.\n ///\n /// # Panics\n /// The circuit will fail if secret consistency doesn't hold for any\n /// coefficient or CRT basis.\n fn verify_secret_consistency(self) {\n for coeff_idx in 0..N {\n let secret_coeff = self.sk_secret.coefficients[coeff_idx];\n\n for mod_idx in 0..L {\n assert(self.y[coeff_idx][mod_idx][0] == secret_coeff);\n }\n }\n }\n}\n\nimpl SmudgingNoiseShareComputation {\n pub fn new(\n configs: Configs,\n expected_secret_commitment: Field,\n e_sm_secret: [Polynomial; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n ) -> Self {\n SmudgingNoiseShareComputation { configs, expected_secret_commitment, e_sm_secret, y, h }\n }\n\n /// Main verification function\n pub fn execute(self) -> [[Field; L]; N_PARTIES] {\n // Step 1: Verify secret commitment matches expected\n self.verify_secret_commitment();\n\n // Step 2: Verify secret consistency\n self.verify_secret_consistency();\n\n // Step 3: Range checks\n check_range_bounds::(self.configs.qis, self.y);\n\n // Step 4: Verify parity check\n verify_parity_check::(self.configs.qis, self.h, self.y);\n\n // Step 5: Commit to shares for each party and modulus\n commit_to_party_shares::(self.y)\n }\n\n /// Verifies that secret hashes to expected_secret_commitment\n /// The commitment is computed over all L RNS polynomials (matching\n /// multiple_polynomial_payload's behavior which hashes all L modulus polynomials)\n fn verify_secret_commitment(self) {\n assert(\n compute_share_computation_e_sm_commitment::(self.e_sm_secret)\n == self.expected_secret_commitment,\n \"ESM commitment mismatch\",\n );\n }\n\n /// Verifies secret consistency: `y[i][j][0] == e_sm_secret[j][i]` for all i, j.\n ///\n /// This function ensures that for each coefficient i and CRT basis j, the share\n /// at party ID 0 equals the corresponding secret coefficient for that modulus.\n /// This is a fundamental property of Shamir secret sharing where the secret is the\n /// evaluation of the sharing polynomial at point 0.\n ///\n /// e_sm_secret[j] is the RNS representation at modulus j, so y[i][j][0] varies per modulus.\n ///\n /// # Panics\n /// The circuit will fail if secret consistency doesn't hold for any\n /// coefficient or CRT basis.\n fn verify_secret_consistency(self) {\n for coeff_idx in 0..N {\n for mod_idx in 0..L {\n let secret_coeff = self.e_sm_secret[mod_idx].coefficients[coeff_idx];\n assert(\n self.y[coeff_idx][mod_idx][0] == secret_coeff,\n \"Secret consistency check failed\",\n );\n }\n }\n }\n}\n\n/// Performs range checks on secret key and share values.\n///\n/// This function constrains all values to be within their expected bounds:\n/// - Share values for parties k >= 1 must be in [0, q_j) for each CRT modulus q_j\n///\n/// These bounds are critical for security and correctness of the Threshold scheme.\n///\n/// # Panics\n/// This function will cause the circuit to fail if any value is outside\n/// its expected bounds.\npub fn check_range_bounds(\n qis: [Field; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) {\n // Shares y[i][j][k] for k >= 1 should be in [0, q_j)\n for mod_idx in 0..L {\n let q_j = qis[mod_idx];\n\n for coeff_idx in 0..N {\n for party_idx in 1..(N_PARTIES + 1) {\n // Use range_check_standard from Polynomial by creating a single-coefficient polynomial\n Polynomial::new([y[coeff_idx][mod_idx][party_idx]])\n .range_check_standard::(q_j);\n }\n }\n }\n}\n\n/// Verifies Reed-Solomon parity check: `H[j] * y[i][j]^T == 0 mod q_j` for all i, j.\n///\n/// This function verifies that for each coefficient i and CRT basis j, the share\n/// vector `y[i][j]` forms a valid Reed-Solomon codeword by satisfying the parity\n/// check equation with the parity check matrix `H[j]`.\n///\n/// The parity check matrix H[j] has dimensions `(N_PARTIES - T) * (N_PARTIES + 1)`,\n/// and the share vector `y[i][j]` has length `N_PARTIES + 1`. The parity check\n/// ensures that any T+1 shares can correctly reconstruct the secret key via\n/// Lagrange interpolation.\n///\n/// # Panics\n/// The circuit will fail if the parity check doesn't hold for any coefficient,\n/// CRT basis, or parity check row.\npub fn verify_parity_check(\n qis: [Field; L],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) {\n for coeff_idx in 0..N {\n for mod_idx in 0..L {\n let q_j = qis[mod_idx];\n\n // For each row of H, compute dot product with y and verify == 0\n for row in 0..(N_PARTIES - T) {\n let mut sum: Field = 0;\n\n for col in 0..(N_PARTIES + 1) {\n sum = sum + h[mod_idx][row][col] * y[coeff_idx][mod_idx][col];\n }\n\n // Reduce mod q_j and verify == 0\n let m = ModU128::new(q_j);\n let result = m.reduce_mod(sum);\n assert(result == 0, \"Parity check failed\");\n }\n }\n }\n}\n\n/// Commits to shares for each party and modulus\n/// Returns [[Field; L]; N_PARTIES] where commitments[party_idx][mod_idx]\npub fn commit_to_party_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) -> [[Field; L]; N_PARTIES] {\n let mut commitments: [[Field; L]; N_PARTIES] = [[0; L]; N_PARTIES];\n\n for party_idx in 0..N_PARTIES {\n for mod_idx in 0..L {\n commitments[party_idx][mod_idx] = compute_share_encryption_commitment_from_shares::(\n y,\n party_idx,\n mod_idx,\n );\n }\n }\n\n commitments\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/lib/src/core/dkg/share_computation.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/dkg/share_computation.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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/commitments.nr" + "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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/helpers.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/helpers.nr" }, "77": { "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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\n // 3 * 4 = 12 = 1 (mod 11), so 3^(-1) = 4 (mod 11)\n assert(result == 4);\n // Verify: 3 * result = 1 (mod 11)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n // 3^(-1) mod 11 = 4 (since 3 * 4 = 12 = 1 mod 11)\n // 7 * 4 = 28 = 6 (mod 11)\n assert(result == 6);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/modulo/U128.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/U128.nr" }, "79": { "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//! Unconstrained functions for modular u128 arithmetic.\n//!\n//! This module provides unconstrained functions that perform modular arithmetic\n//! computations without generating circuit constraints. These functions are used\n//! internally by the constrained operations in `U128` and should not be called\n//! directly in circuits without proper verification.\n\n/// Computes quotient and remainder for value modulo q (unconstrained).\n///\n/// This function performs integer division and modulo operations to compute\n/// `value = q * quotient + remainder` where `0 <= remainder < q`.\n///\n/// # Arguments\n/// * `value` - The value to reduce\n/// * `q` - The modulus\n///\n/// # Returns\n/// A tuple `(quotient, remainder)` where:\n/// - `quotient = value / q`\n/// - `remainder = value % q`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __compute_mod_reduction(value: Field, q: Field) -> (Field, Field) {\n let value_u128 = value as u128;\n let q_u128 = q as u128;\n\n let quotient_u128 = value_u128 / q_u128;\n let remainder_u128 = value_u128 % q_u128;\n\n (quotient_u128 as Field, remainder_u128 as Field)\n}\n\n/// Computes the negation of a value modulo m (unconstrained).\n///\n/// Returns `(m - val) mod m`, with special handling for zero (returns 0).\n///\n/// # Arguments\n/// * `val` - The value to negate\n/// * `m` - The modulus\n///\n/// # Returns\n/// The additive inverse `(-val) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __neg(val: Field, m: Field) -> Field {\n if val == 0 {\n 0\n } else {\n m - val\n }\n}\n\n/// Subtracts two values with underflow handling (unconstrained).\n///\n/// Computes `(lhs - rhs) mod m`, handling the case where `lhs < rhs` by adding\n/// the modulus. Returns both the result and a flag indicating if underflow occurred.\n///\n/// # Preconditions\n/// Inputs must be reduced modulo `m` such that `lhs, rhs in [0, m)`. This ensures\n/// that the computed difference is bounded and cannot overflow `u128`.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value (minuend), must be in `[0, m)`\n/// * `rhs` - Right-hand side value (subtrahend), must be in `[0, m)`\n/// * `m` - The modulus, must satisfy `m <= u128::MAX`\n///\n/// # Returns\n/// A tuple `(result, underflow)` where:\n/// - `result = (lhs - rhs) mod m`\n/// - `underflow = true` if `lhs < rhs`, `false` otherwise\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\n/// As long as inputs are reduced modulo `m` (and `m <= u128::MAX`), the subtraction-with-underflow\n/// logic is safe and will not overflow `u128`. This function is used by the constrained `sub` method\n/// in `modulo::U128`, which ensures inputs are properly reduced before calling `__sub_with_underflow`.\n/// See the surrounding `modulo/unconstrained_U128` module documentation for details.\npub unconstrained fn __sub_with_underflow(lhs: Field, rhs: Field, m: Field) -> (Field, bool) {\n let lhs_u128 = lhs as u128;\n let rhs_u128 = rhs as u128;\n let m_u128 = m as u128;\n\n let underflow = lhs_u128 < rhs_u128;\n let result = if underflow {\n // Compute (lhs - rhs + m) mod m safely to avoid u128 overflow\n // Since lhs < rhs, we compute: m - (rhs - lhs)\n // This avoids the potential overflow in lhs + m\n let diff = rhs_u128 - lhs_u128; // This is safe since rhs > lhs\n (m_u128 - diff) as Field\n } else {\n (lhs_u128 - rhs_u128) as Field\n };\n (result, underflow)\n}\n\n/// Multiplies two values and returns both quotient and remainder (unconstrained).\n///\n/// Computes `lhs * rhs = m * quotient + remainder` where `0 <= remainder < m`.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value\n/// * `rhs` - Right-hand side value\n/// * `m` - The modulus\n///\n/// # Returns\n/// A tuple `(quotient, remainder)` where `lhs * rhs = m * quotient + remainder`\n///\n/// # Overflow Warning\n/// Field multiplication wraps modulo the field prime (~254 bits). For two u128 values\n/// near 2^128, their product (up to 2^256) exceeds the Field modulus, causing silent\n/// wraparound before the mod reduction. This can produce incorrect results.\n///\n/// # Safe Input Range\n/// To avoid overflow, ensure `lhs * rhs < Field::MODULUS`. For typical use cases:\n/// - Party IDs, polynomial coefficients, and small cryptographic values (< 2^64) are safe\n/// - Arbitrary u128 values may overflow and should be validated by callers\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\n/// Callers must ensure inputs are within the safe range to prevent silent overflow.\npub unconstrained fn __mul_with_quotient(lhs: Field, rhs: Field, m: Field) -> (Field, Field) {\n // WARNING: Field multiplication can overflow for large inputs.\n // For u128 values near 2^128, the product (up to 2^256) exceeds Field modulus (~2^254),\n // causing wraparound. This is safe for typical use cases (party IDs, small coefficients),\n // but callers must validate input ranges for arbitrary u128 values.\n let product = lhs * rhs;\n __compute_mod_reduction(product, m)\n}\n\n/// Computes the modular multiplicative inverse using Fermat's Little Theorem (unconstrained).\n///\n/// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n/// using the identity: val^(-1) = val^(m-2) (mod m) (from Fermat's Little Theorem).\n///\n/// # Arguments\n/// * `val` - The value to invert (must be coprime with the modulus)\n/// * `m` - The modulus (should be prime for this method to work correctly)\n///\n/// # Returns\n/// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __inv_mod(val: Field, m: Field) -> Field {\n // by Fermat's Little Theorem: val^(m-1)= 1 mod m\n __pow_mod(val, m - 2, m)\n}\n\n/// Computes modular division: `lhs * rhs^(-1) mod m` (unconstrained).\n///\n/// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n///\n/// # Arguments\n/// * `lhs` - The numerator\n/// * `rhs` - The denominator (must be coprime with the modulus)\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `(lhs * rhs^(-1)) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __div_mod(lhs: Field, rhs: Field, m: Field) -> Field {\n let rhs_inv = __inv_mod(rhs, m);\n __mul_mod(lhs, rhs_inv, m)\n}\n\n/// Computes modular exponentiation: `base^exp mod m` (unconstrained).\n///\n/// Uses the binary exponentiation method (also known as square-and-multiply)\n/// for efficient computation of large powers.\n///\n/// # Arguments\n/// * `base` - The base value\n/// * `exp` - The exponent\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `base^exp mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __pow_mod(base: Field, exp: Field, m: Field) -> Field {\n let mut result = 1 as Field;\n let (_, base_mod) = __compute_mod_reduction(base, m);\n let mut current_base = base_mod;\n let mut e = exp as u128;\n\n while e > 0 {\n if (e % 2) == 1 {\n result = __mul_mod(result, current_base, m);\n }\n current_base = __mul_mod(current_base, current_base, m);\n e = e / 2;\n }\n\n result\n}\n\n/// Multiplies two values with modular reduction (unconstrained).\n///\n/// Computes `(lhs * rhs) mod m` and returns only the remainder.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value\n/// * `rhs` - Right-hand side value\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `(lhs * rhs) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __mul_mod(lhs: Field, rhs: Field, m: Field) -> Field {\n let (_, r) = __mul_with_quotient(lhs, rhs, m);\n r\n}\n\n// ------------------------------ TESTS ------------------------------\n// Note: All unsafe blocks in the following tests are safe because we are testing\n// unconstrained functions in a controlled test environment. These functions are\n// designed to be called from unsafe blocks or other unconstrained functions.\n// Each unsafe block is used to call an unconstrained function for testing purposes.\n\n#[test]\nfn test_compute_mod_reduction_simple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(42, 10) };\n assert(q == 4); // 42 / 10 = 4\n assert(r == 2); // 42 % 10 = 2\n // Verify: 42 = 10 * 4 + 2\n assert(10 * q + r == 42);\n}\n\n#[test]\nfn test_compute_mod_reduction_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(100, 10) };\n assert(q == 10); // 100 / 10 = 10\n assert(r == 0); // 100 % 10 = 0\n assert(10 * q + r == 100);\n}\n\n#[test]\nfn test_compute_mod_reduction_large_value() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(12345, 100) };\n assert(q == 123); // 12345 / 100 = 123\n assert(r == 45); // 12345 % 100 = 45\n assert(100 * q + r == 12345);\n}\n\n#[test]\nfn test_compute_mod_reduction_smaller_than_modulus() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(7, 10) };\n assert(q == 0); // 7 / 10 = 0\n assert(r == 7); // 7 % 10 = 7\n assert(10 * q + r == 7);\n}\n\n#[test]\nfn test_neg_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(0, 100) };\n assert(result == 0); // Negation of zero is zero\n}\n\n#[test]\nfn test_neg_non_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(30, 100) };\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_large_value() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(12345, 100000) };\n assert(result == 87655); // 100000 - 12345 = 87655\n}\n\n#[test]\nfn test_neg_verification() {\n let val: Field = 42;\n let m: Field = 97;\n // Safety: Test function calling unconstrained helper\n let neg_val = unsafe { __neg(val, m) };\n // Verify: val + neg_val = 0 (mod m)\n let sum = val + neg_val;\n // Safety: Test function calling unconstrained helper\n let (_, remainder) = unsafe { __compute_mod_reduction(sum, m) };\n assert(remainder == 0);\n}\n\n#[test]\nfn test_sub_with_underflow_no_underflow() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(50, 30, 100) };\n assert(underflow == false);\n assert(result == 20); // 50 - 30 = 20\n}\n\n#[test]\nfn test_sub_with_underflow_with_underflow() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(30, 50, 100) };\n assert(underflow == true);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_with_underflow_equal_values() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(42, 42, 100) };\n assert(underflow == false);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\n}\n\n#[test]\nfn test_mul_with_quotient_simple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(6, 7, 10) };\n assert(q == 4); // (6 * 7) / 10 = 42 / 10 = 4\n assert(r == 2); // (6 * 7) % 10 = 42 % 10 = 2\n // Verify: 6 * 7 = 10 * 4 + 2\n assert(6 * 7 == 10 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(12, 15, 100) };\n assert(q == 1); // (12 * 15) / 100 = 180 / 100 = 1\n assert(r == 80); // (12 * 15) % 100 = 180 % 100 = 80\n assert(12 * 15 == 100 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(5, 20, 100) };\n assert(q == 1); // (5 * 20) / 100 = 100 / 100 = 1\n assert(r == 0); // (5 * 20) % 100 = 100 % 100 = 0\n assert(5 * 20 == 100 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_verification() {\n let lhs: Field = 123;\n let rhs: Field = 456;\n let m: Field = 1000;\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(lhs, rhs, m) };\n // Verify: lhs * rhs = m * q + r\n assert(lhs * rhs == m * q + r);\n // Verify remainder is in range [0, m)\n assert((r as u128) < (m as u128));\n}\n\n#[test]\nfn test_mul_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(6, 7, 10) };\n assert(result == 2); // (6 * 7) mod 10 = 42 mod 10 = 2\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(12, 15, 100) };\n assert(result == 80); // (12 * 15) mod 100 = 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(5, 20, 100) };\n assert(result == 0); // (5 * 20) mod 100 = 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(42, 0, 100) };\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_commutative() {\n let a: Field = 7;\n let b: Field = 9;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let mul_a_b = unsafe { __mul_mod(a, b, m) };\n // Safety: Test function calling unconstrained helper\n let mul_b_a = unsafe { __mul_mod(b, a, m) };\n // Verify: a * b = b * a\n assert(mul_a_b == mul_b_a);\n}\n\n#[test]\nfn test_pow_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(2, 3, 10) };\n assert(result == 8); // 2^3 mod 10 = 8 mod 10 = 8\n}\n\n#[test]\nfn test_pow_mod_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(2, 10, 100) };\n assert(result == 24); // 2^10 = 1024, 1024 mod 100 = 24\n}\n\n#[test]\nfn test_pow_mod_exponent_one() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(7, 1, 100) };\n assert(result == 7); // 7^1 mod 100 = 7\n}\n\n#[test]\nfn test_pow_mod_exponent_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(7, 0, 100) };\n assert(result == 1); // 7^0 mod 100 = 1\n}\n\n#[test]\nfn test_pow_mod_base_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(0, 5, 100) };\n assert(result == 0); // 0^5 mod 100 = 0\n}\n\n#[test]\nfn test_pow_mod_large_exponent() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(3, 7, 97) };\n // 3^7 = 2187, 2187 mod 97 = 53\n assert(result == 53);\n}\n\n#[test]\nfn test_pow_mod_fermat_little_theorem() {\n // For prime modulus p and value a, a^(p-1) = 1 (mod p)\n let a: Field = 3;\n let p: Field = 11; // Prime\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(a, p - 1, p) };\n assert(result == 1);\n}\n\n#[test]\nfn test_inv_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(3, 11) };\n // 3 * 4 = 12 = 1 (mod 11), so 3^(-1) = 4 (mod 11)\n assert(result == 4);\n // Verify: 3 * result = 1 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(3, result, 11) } == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(7, 13) };\n // Verify: 7 * result = 1 (mod 13)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(7, result, 13) } == 1);\n}\n\n#[test]\nfn test_inv_mod_another_prime() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(5, 17) };\n // Verify: 5 * result = 1 (mod 17)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(5, result, 17) } == 1);\n}\n\n#[test]\nfn test_inv_mod_inverse_of_inverse() {\n let a: Field = 7;\n let m: Field = 11;\n // Safety: Test function calling unconstrained helper\n let inv_a = unsafe { __inv_mod(a, m) };\n // Safety: Test function calling unconstrained helper\n let inv_inv_a = unsafe { __inv_mod(inv_a, m) };\n // (a^(-1))^(-1) = a\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_div_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(6, 2, 11) };\n assert(result == 3); // 6 / 2 = 3\n // Verify: result * 2 = 6 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 2, 11) } == 6);\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(7, 3, 11) };\n // 3^(-1) mod 11 = 4 (since 3 * 4 = 12 = 1 mod 11)\n // 7 * 4 = 28 = 6 (mod 11)\n assert(result == 6);\n // Verify: result * 3 = 7 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 3, 11) } == 7);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a: Field = 10;\n let b: Field = 3;\n let m: Field = 17;\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(a, b, m) };\n // Verify: result * b = a (mod m)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, b, m) } == a);\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a: Field = 250;\n let b: Field = 7;\n let m: Field = 97;\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(a, b, m) };\n // Verify: result * b = a (mod m)\n // Safety: Test function calling unconstrained helper\n let (_, a_reduced) = unsafe { __compute_mod_reduction(a, m) }; // 250 mod 97 = 56\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, b, m) } == a_reduced);\n}\n\n#[test]\nfn test_div_mod_by_one() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(42, 1, 100) };\n assert(result == 42); // 42 / 1 = 42\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 1, 100) } == 42);\n}\n\n#[test]\nfn test_all_operations_consistency() {\n // Test that all operations work together correctly\n let m: Field = 97; // Prime\n let a: Field = 42;\n let b: Field = 13;\n\n // Test: (a + b) mod m\n let sum = a + b;\n // Safety: Test function calling unconstrained helper\n let (_, sum_reduced) = unsafe { __compute_mod_reduction(sum, m) };\n assert(sum_reduced == 55);\n\n // Test: (a - b) mod m using subtraction\n // Safety: Test function calling unconstrained helper\n let (diff, _) = unsafe { __sub_with_underflow(a, b, m) };\n assert(diff == 29);\n\n // Test: (a * b) mod m\n // Safety: Test function calling unconstrained helper\n let prod = unsafe { __mul_mod(a, b, m) };\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test: b^(-1) mod m\n // Safety: Test function calling unconstrained helper\n let inv = unsafe { __inv_mod(b, m) };\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(b, inv, m) } == 1);\n\n // Test: (a / b) mod m\n // Safety: Test function calling unconstrained helper\n let quot = unsafe { __div_mod(a, b, m) };\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(quot, b, m) } == a);\n\n // Test: (-a) mod m\n // Safety: Test function calling unconstrained helper\n let neg = unsafe { __neg(a, m) };\n let sum_neg = a + neg;\n // Safety: Test function calling unconstrained helper\n let (_, sum_neg_reduced) = unsafe { __compute_mod_reduction(sum_neg, m) };\n assert(sum_neg_reduced == 0);\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/unconstrained_U128.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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/polynomial.nr" + "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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/safe.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr" } }, "expression_width": { "Bounded": { "width": 4 } } diff --git a/crates/zk-prover/tests/fixtures/e_sm_share_encryption.json b/crates/zk-prover/tests/fixtures/e_sm_share_encryption.json index ed286c2eb6..70af42e495 100644 --- a/crates/zk-prover/tests/fixtures/e_sm_share_encryption.json +++ b/crates/zk-prover/tests/fixtures/e_sm_share_encryption.json @@ -193,35 +193,35 @@ }, "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::dkg::{\n DKG_SHARE_ENCRYPTION_BIT_CT, DKG_SHARE_ENCRYPTION_BIT_E0, DKG_SHARE_ENCRYPTION_BIT_E1,\n DKG_SHARE_ENCRYPTION_BIT_MSG, DKG_SHARE_ENCRYPTION_BIT_P1, DKG_SHARE_ENCRYPTION_BIT_P2,\n DKG_SHARE_ENCRYPTION_BIT_PK, DKG_SHARE_ENCRYPTION_BIT_R1, DKG_SHARE_ENCRYPTION_BIT_R2,\n DKG_SHARE_ENCRYPTION_BIT_U, DKG_SHARE_ENCRYPTION_CONFIGS, L, N,\n};\nuse lib::core::dkg::share_encryption::ShareEncryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_pk_commitment: pub Field,\n expected_message_commitment: pub Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: pub [Polynomial; L],\n ct1is: pub [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n e1: Polynomial,\n message: 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 share_encryption: ShareEncryption = ShareEncryption::new(\n DKG_SHARE_ENCRYPTION_CONFIGS,\n expected_pk_commitment,\n expected_message_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n message,\n r1is,\n r2is,\n p1is,\n p2is,\n );\n share_encryption.execute();\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/bin/dkg/e_sm_share_encryption/src/main.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/dkg/share_encryption/src/main.nr" }, "65": { "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_dkg_pk_commitment;\nuse crate::math::commitments::{\n compute_share_encryption_challenge, compute_share_encryption_commitment_from_message,\n};\nuse crate::math::helpers::flatten;\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for DKG share encryption circuit.\npub struct Configs {\n /// Plaintext modulus t\n pub t: Field,\n /// Q mod t (for scaling message)\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 /// 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 /// Bound for message polynomial (m)\n pub msg_bound: Field,\n}\n\nimpl Configs {\n pub fn new(\n t: Field,\n q_mod_t: 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 msg_bound: Field,\n ) -> Self {\n Configs {\n t,\n q_mod_t,\n qis,\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 msg_bound,\n }\n }\n}\n\n/// DKG Share Encryption Circuit (Circuit 3).\n///\n/// Verifies:\n/// 1. Public key commitment matches expected (from Circuit 0)\n/// 2. Message commitment matches expected (from SK shares circuit)\n/// 3. Correct DKG share encryption: ct0[l] = pk0[l] * u + e0[l] + k1 * k0[l] + r1[l] * q[l] + r2[l] * (X^N + 1)\n/// and ct1[l] = pk1[l] * u + e1 + p2[l] * (X^N + 1) + p1[l] * q[l]\npub struct ShareEncryption {\n /// Circuit parameters\n configs: Configs,\n /// Expected commitment to public key (from Circuit 0)\n /// (public witness)\n expected_pk_commitment: Field,\n /// Expected commitment to message (from SK shares verification circuit)\n /// (public witness)\n expected_message_commitment: Field,\n /// Public key component 0 for each CRT basis (committed witnesses)\n pk0is: [Polynomial; L],\n /// Public key component 1 for each CRT basis (committed witnesses)\n pk1is: [Polynomial; L],\n /// Ciphertext component 0 for each CRT basis (public witnesses)\n ct0is: [Polynomial; L],\n /// Ciphertext component 1 for each CRT basis (public witnesses)\n ct1is: [Polynomial; L],\n /// Random ternary polynomial u (secret witness)\n u: Polynomial,\n /// Error polynomial e0 (secret witness)\n e0: Polynomial,\n /// Per-basis error polynomials e0[l] (secret witnesses)\n e0is: [Polynomial; L],\n /// CRT quotients for e0 (secret witnesses)\n e0_quotients: [Polynomial; L],\n /// Error polynomial e1 (secret witness)\n e1: Polynomial,\n /// Raw message polynomial (secret witness)\n message: Polynomial,\n /// Modulus switching quotient polynomials r1 (secret witnesses, degree 2N-1)\n r1is: [Polynomial<(2 * N) - 1>; L],\n /// Cyclotomic reduction quotient polynomials r2 (secret witnesses, degree N-1)\n r2is: [Polynomial; L],\n /// Modulus switching quotient polynomials p1 (secret witnesses, degree 2N-1)\n p1is: [Polynomial<(2 * N) - 1>; L],\n /// Cyclotomic reduction quotient polynomials p2 (secret witnesses, degree N-1)\n p2is: [Polynomial; L],\n}\n\nimpl ShareEncryption {\n pub fn new(\n configs: Configs,\n expected_pk_commitment: Field,\n expected_message_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 message: Polynomial,\n r1is: [Polynomial<2 * N - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<2 * N - 1>; L],\n p2is: [Polynomial; L],\n ) -> Self {\n ShareEncryption {\n configs,\n expected_pk_commitment,\n expected_message_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n message,\n r1is,\n r2is,\n p1is,\n p2is,\n }\n }\n\n /// Verifies that the public key hashes to the expected commitment\n fn verify_pk_commitment(self) {\n assert(\n compute_dkg_pk_commitment::(self.pk0is, self.pk1is)\n == self.expected_pk_commitment,\n \"Public key commitment mismatch\",\n );\n }\n\n /// Verifies that the message polynomial hashes to the expected commitment\n fn verify_message_commitment(self) {\n assert(\n compute_share_encryption_commitment_from_message::(self.message)\n == self.expected_message_commitment,\n \"Message commitment mismatch\",\n );\n }\n\n /// Computes the scaled message k1 from the raw message in centered form\n /// k1[i] = (q_mod_t * message[i]) mod t, centered to [-t/2, t/2)\n fn compute_scaled_message(self) -> Polynomial {\n let t = self.configs.t;\n let t_mod = ModU128::new(t);\n let q_mod_t: Field = self.configs.q_mod_t;\n let mut k1_coeffs: [Field; N] = [0; N];\n\n // Integer division for t_half\n let t_half: u128 = (t as u128) / 2;\n\n for i in 0..N {\n let msg_i: Field = self.message.coefficients[i];\n let q_times_m_mod_t = t_mod.mul_mod(q_mod_t, msg_i);\n\n // Check if centering is needed (value > t/2 means negative in centered form)\n let needs_centering = (q_times_m_mod_t as u128) > t_half;\n\n k1_coeffs[i] = if needs_centering {\n // Value is in (t/2, t), negative in centered form\n // Represent as P - magnitude (i.e., 0 - magnitude in Field)\n let magnitude = t - q_times_m_mod_t;\n 0 - magnitude\n } else {\n // Value is in [0, t/2], stays positive\n q_times_m_mod_t\n };\n }\n\n Polynomial { coefficients: k1_coeffs }\n }\n\n /// Flattens all polynomial coefficients into a single array for Fiat-Shamir challenge generation\n fn payload(self, k1: Polynomial) -> Vec {\n let mut inputs = Vec::new();\n\n // Use pk commitment instead of full pk polynomials\n inputs.push(self.expected_pk_commitment);\n\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct0is);\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct1is);\n\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\n // Use message commitment instead of full message\n inputs.push(self.expected_message_commitment);\n\n // Include computed k1 in payload\n for i in 0..N {\n inputs.push(k1.coefficients[i]);\n }\n\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 the e0 error polynomial\n fn check_e0_crt_consistency(self) {\n for i in 0..L {\n for j in 0..N {\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 /// Main verification function\n pub fn execute(self) {\n // Step 1: Verify public key commitment matches expected\n self.verify_pk_commitment();\n\n // Step 2: Verify message commitment matches expected\n self.verify_message_commitment();\n\n // Step 3: Perform range checks\n self.check_range_bounds();\n\n // Step 4: Check CRT consistency for e0\n self.check_e0_crt_consistency();\n\n // Step 5: Compute scaled message k1 from message\n let k1 = self.compute_scaled_message();\n\n // Step 6: Generate Fiat-Shamir challenges\n let gammas = self.generate_challenge(k1);\n\n // Step 7: Verify encryption constraints\n self.verify_evaluations(gammas, k1)\n }\n\n /// Performs range checks on all secret witness polynomial coefficients\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\n // Message should be in [0, t)\n self.message.range_check_standard::(self.configs.msg_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 fn generate_challenge(self, k1: Polynomial) -> Vec {\n let inputs = self.payload(k1);\n\n compute_share_encryption_challenge::(inputs)\n }\n\n /// Verifies DKG encryption constraints using Fiat-Shamir challenges and the Schwartz-Zippel lemma\n fn verify_evaluations(self, gammas: Vec, k1: Polynomial) {\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 = 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 // Verify ct0 equation: ct0[i] = pk0[i]*u + e0[i] + k1*k0[i] + r1[i]*q[i] + r2[i]*cyclo\n let mut ct0_rhs = (pk0is_at_gamma * u_at_gamma) + e0is_at_gamma;\n ct0_rhs += 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\n // Verify ct1 equation: ct1[i] = pk1[i]*u + e1 + p2[i]*cyclo + p1[i]*q[i]\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 mut ct1_rhs = (pk1is_at_gamma * u_at_gamma) + e1_at_gamma;\n ct1_rhs += 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\n // Accumulate weighted sums for batch verification\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 assert(sum.0 == sum.1);\n }\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/lib/src/core/dkg/share_encryption.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/dkg/share_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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/commitments.nr" + "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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/helpers.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/helpers.nr" }, "77": { "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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\n // 3 * 4 = 12 = 1 (mod 11), so 3^(-1) = 4 (mod 11)\n assert(result == 4);\n // Verify: 3 * result = 1 (mod 11)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n // 3^(-1) mod 11 = 4 (since 3 * 4 = 12 = 1 mod 11)\n // 7 * 4 = 28 = 6 (mod 11)\n assert(result == 6);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/modulo/U128.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/U128.nr" }, "79": { "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//! Unconstrained functions for modular u128 arithmetic.\n//!\n//! This module provides unconstrained functions that perform modular arithmetic\n//! computations without generating circuit constraints. These functions are used\n//! internally by the constrained operations in `U128` and should not be called\n//! directly in circuits without proper verification.\n\n/// Computes quotient and remainder for value modulo q (unconstrained).\n///\n/// This function performs integer division and modulo operations to compute\n/// `value = q * quotient + remainder` where `0 <= remainder < q`.\n///\n/// # Arguments\n/// * `value` - The value to reduce\n/// * `q` - The modulus\n///\n/// # Returns\n/// A tuple `(quotient, remainder)` where:\n/// - `quotient = value / q`\n/// - `remainder = value % q`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __compute_mod_reduction(value: Field, q: Field) -> (Field, Field) {\n let value_u128 = value as u128;\n let q_u128 = q as u128;\n\n let quotient_u128 = value_u128 / q_u128;\n let remainder_u128 = value_u128 % q_u128;\n\n (quotient_u128 as Field, remainder_u128 as Field)\n}\n\n/// Computes the negation of a value modulo m (unconstrained).\n///\n/// Returns `(m - val) mod m`, with special handling for zero (returns 0).\n///\n/// # Arguments\n/// * `val` - The value to negate\n/// * `m` - The modulus\n///\n/// # Returns\n/// The additive inverse `(-val) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __neg(val: Field, m: Field) -> Field {\n if val == 0 {\n 0\n } else {\n m - val\n }\n}\n\n/// Subtracts two values with underflow handling (unconstrained).\n///\n/// Computes `(lhs - rhs) mod m`, handling the case where `lhs < rhs` by adding\n/// the modulus. Returns both the result and a flag indicating if underflow occurred.\n///\n/// # Preconditions\n/// Inputs must be reduced modulo `m` such that `lhs, rhs in [0, m)`. This ensures\n/// that the computed difference is bounded and cannot overflow `u128`.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value (minuend), must be in `[0, m)`\n/// * `rhs` - Right-hand side value (subtrahend), must be in `[0, m)`\n/// * `m` - The modulus, must satisfy `m <= u128::MAX`\n///\n/// # Returns\n/// A tuple `(result, underflow)` where:\n/// - `result = (lhs - rhs) mod m`\n/// - `underflow = true` if `lhs < rhs`, `false` otherwise\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\n/// As long as inputs are reduced modulo `m` (and `m <= u128::MAX`), the subtraction-with-underflow\n/// logic is safe and will not overflow `u128`. This function is used by the constrained `sub` method\n/// in `modulo::U128`, which ensures inputs are properly reduced before calling `__sub_with_underflow`.\n/// See the surrounding `modulo/unconstrained_U128` module documentation for details.\npub unconstrained fn __sub_with_underflow(lhs: Field, rhs: Field, m: Field) -> (Field, bool) {\n let lhs_u128 = lhs as u128;\n let rhs_u128 = rhs as u128;\n let m_u128 = m as u128;\n\n let underflow = lhs_u128 < rhs_u128;\n let result = if underflow {\n // Compute (lhs - rhs + m) mod m safely to avoid u128 overflow\n // Since lhs < rhs, we compute: m - (rhs - lhs)\n // This avoids the potential overflow in lhs + m\n let diff = rhs_u128 - lhs_u128; // This is safe since rhs > lhs\n (m_u128 - diff) as Field\n } else {\n (lhs_u128 - rhs_u128) as Field\n };\n (result, underflow)\n}\n\n/// Multiplies two values and returns both quotient and remainder (unconstrained).\n///\n/// Computes `lhs * rhs = m * quotient + remainder` where `0 <= remainder < m`.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value\n/// * `rhs` - Right-hand side value\n/// * `m` - The modulus\n///\n/// # Returns\n/// A tuple `(quotient, remainder)` where `lhs * rhs = m * quotient + remainder`\n///\n/// # Overflow Warning\n/// Field multiplication wraps modulo the field prime (~254 bits). For two u128 values\n/// near 2^128, their product (up to 2^256) exceeds the Field modulus, causing silent\n/// wraparound before the mod reduction. This can produce incorrect results.\n///\n/// # Safe Input Range\n/// To avoid overflow, ensure `lhs * rhs < Field::MODULUS`. For typical use cases:\n/// - Party IDs, polynomial coefficients, and small cryptographic values (< 2^64) are safe\n/// - Arbitrary u128 values may overflow and should be validated by callers\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\n/// Callers must ensure inputs are within the safe range to prevent silent overflow.\npub unconstrained fn __mul_with_quotient(lhs: Field, rhs: Field, m: Field) -> (Field, Field) {\n // WARNING: Field multiplication can overflow for large inputs.\n // For u128 values near 2^128, the product (up to 2^256) exceeds Field modulus (~2^254),\n // causing wraparound. This is safe for typical use cases (party IDs, small coefficients),\n // but callers must validate input ranges for arbitrary u128 values.\n let product = lhs * rhs;\n __compute_mod_reduction(product, m)\n}\n\n/// Computes the modular multiplicative inverse using Fermat's Little Theorem (unconstrained).\n///\n/// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n/// using the identity: val^(-1) = val^(m-2) (mod m) (from Fermat's Little Theorem).\n///\n/// # Arguments\n/// * `val` - The value to invert (must be coprime with the modulus)\n/// * `m` - The modulus (should be prime for this method to work correctly)\n///\n/// # Returns\n/// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __inv_mod(val: Field, m: Field) -> Field {\n // by Fermat's Little Theorem: val^(m-1)= 1 mod m\n __pow_mod(val, m - 2, m)\n}\n\n/// Computes modular division: `lhs * rhs^(-1) mod m` (unconstrained).\n///\n/// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n///\n/// # Arguments\n/// * `lhs` - The numerator\n/// * `rhs` - The denominator (must be coprime with the modulus)\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `(lhs * rhs^(-1)) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __div_mod(lhs: Field, rhs: Field, m: Field) -> Field {\n let rhs_inv = __inv_mod(rhs, m);\n __mul_mod(lhs, rhs_inv, m)\n}\n\n/// Computes modular exponentiation: `base^exp mod m` (unconstrained).\n///\n/// Uses the binary exponentiation method (also known as square-and-multiply)\n/// for efficient computation of large powers.\n///\n/// # Arguments\n/// * `base` - The base value\n/// * `exp` - The exponent\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `base^exp mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __pow_mod(base: Field, exp: Field, m: Field) -> Field {\n let mut result = 1 as Field;\n let (_, base_mod) = __compute_mod_reduction(base, m);\n let mut current_base = base_mod;\n let mut e = exp as u128;\n\n while e > 0 {\n if (e % 2) == 1 {\n result = __mul_mod(result, current_base, m);\n }\n current_base = __mul_mod(current_base, current_base, m);\n e = e / 2;\n }\n\n result\n}\n\n/// Multiplies two values with modular reduction (unconstrained).\n///\n/// Computes `(lhs * rhs) mod m` and returns only the remainder.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value\n/// * `rhs` - Right-hand side value\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `(lhs * rhs) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __mul_mod(lhs: Field, rhs: Field, m: Field) -> Field {\n let (_, r) = __mul_with_quotient(lhs, rhs, m);\n r\n}\n\n// ------------------------------ TESTS ------------------------------\n// Note: All unsafe blocks in the following tests are safe because we are testing\n// unconstrained functions in a controlled test environment. These functions are\n// designed to be called from unsafe blocks or other unconstrained functions.\n// Each unsafe block is used to call an unconstrained function for testing purposes.\n\n#[test]\nfn test_compute_mod_reduction_simple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(42, 10) };\n assert(q == 4); // 42 / 10 = 4\n assert(r == 2); // 42 % 10 = 2\n // Verify: 42 = 10 * 4 + 2\n assert(10 * q + r == 42);\n}\n\n#[test]\nfn test_compute_mod_reduction_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(100, 10) };\n assert(q == 10); // 100 / 10 = 10\n assert(r == 0); // 100 % 10 = 0\n assert(10 * q + r == 100);\n}\n\n#[test]\nfn test_compute_mod_reduction_large_value() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(12345, 100) };\n assert(q == 123); // 12345 / 100 = 123\n assert(r == 45); // 12345 % 100 = 45\n assert(100 * q + r == 12345);\n}\n\n#[test]\nfn test_compute_mod_reduction_smaller_than_modulus() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(7, 10) };\n assert(q == 0); // 7 / 10 = 0\n assert(r == 7); // 7 % 10 = 7\n assert(10 * q + r == 7);\n}\n\n#[test]\nfn test_neg_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(0, 100) };\n assert(result == 0); // Negation of zero is zero\n}\n\n#[test]\nfn test_neg_non_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(30, 100) };\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_large_value() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(12345, 100000) };\n assert(result == 87655); // 100000 - 12345 = 87655\n}\n\n#[test]\nfn test_neg_verification() {\n let val: Field = 42;\n let m: Field = 97;\n // Safety: Test function calling unconstrained helper\n let neg_val = unsafe { __neg(val, m) };\n // Verify: val + neg_val = 0 (mod m)\n let sum = val + neg_val;\n // Safety: Test function calling unconstrained helper\n let (_, remainder) = unsafe { __compute_mod_reduction(sum, m) };\n assert(remainder == 0);\n}\n\n#[test]\nfn test_sub_with_underflow_no_underflow() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(50, 30, 100) };\n assert(underflow == false);\n assert(result == 20); // 50 - 30 = 20\n}\n\n#[test]\nfn test_sub_with_underflow_with_underflow() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(30, 50, 100) };\n assert(underflow == true);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_with_underflow_equal_values() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(42, 42, 100) };\n assert(underflow == false);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\n}\n\n#[test]\nfn test_mul_with_quotient_simple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(6, 7, 10) };\n assert(q == 4); // (6 * 7) / 10 = 42 / 10 = 4\n assert(r == 2); // (6 * 7) % 10 = 42 % 10 = 2\n // Verify: 6 * 7 = 10 * 4 + 2\n assert(6 * 7 == 10 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(12, 15, 100) };\n assert(q == 1); // (12 * 15) / 100 = 180 / 100 = 1\n assert(r == 80); // (12 * 15) % 100 = 180 % 100 = 80\n assert(12 * 15 == 100 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(5, 20, 100) };\n assert(q == 1); // (5 * 20) / 100 = 100 / 100 = 1\n assert(r == 0); // (5 * 20) % 100 = 100 % 100 = 0\n assert(5 * 20 == 100 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_verification() {\n let lhs: Field = 123;\n let rhs: Field = 456;\n let m: Field = 1000;\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(lhs, rhs, m) };\n // Verify: lhs * rhs = m * q + r\n assert(lhs * rhs == m * q + r);\n // Verify remainder is in range [0, m)\n assert((r as u128) < (m as u128));\n}\n\n#[test]\nfn test_mul_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(6, 7, 10) };\n assert(result == 2); // (6 * 7) mod 10 = 42 mod 10 = 2\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(12, 15, 100) };\n assert(result == 80); // (12 * 15) mod 100 = 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(5, 20, 100) };\n assert(result == 0); // (5 * 20) mod 100 = 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(42, 0, 100) };\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_commutative() {\n let a: Field = 7;\n let b: Field = 9;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let mul_a_b = unsafe { __mul_mod(a, b, m) };\n // Safety: Test function calling unconstrained helper\n let mul_b_a = unsafe { __mul_mod(b, a, m) };\n // Verify: a * b = b * a\n assert(mul_a_b == mul_b_a);\n}\n\n#[test]\nfn test_pow_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(2, 3, 10) };\n assert(result == 8); // 2^3 mod 10 = 8 mod 10 = 8\n}\n\n#[test]\nfn test_pow_mod_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(2, 10, 100) };\n assert(result == 24); // 2^10 = 1024, 1024 mod 100 = 24\n}\n\n#[test]\nfn test_pow_mod_exponent_one() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(7, 1, 100) };\n assert(result == 7); // 7^1 mod 100 = 7\n}\n\n#[test]\nfn test_pow_mod_exponent_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(7, 0, 100) };\n assert(result == 1); // 7^0 mod 100 = 1\n}\n\n#[test]\nfn test_pow_mod_base_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(0, 5, 100) };\n assert(result == 0); // 0^5 mod 100 = 0\n}\n\n#[test]\nfn test_pow_mod_large_exponent() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(3, 7, 97) };\n // 3^7 = 2187, 2187 mod 97 = 53\n assert(result == 53);\n}\n\n#[test]\nfn test_pow_mod_fermat_little_theorem() {\n // For prime modulus p and value a, a^(p-1) = 1 (mod p)\n let a: Field = 3;\n let p: Field = 11; // Prime\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(a, p - 1, p) };\n assert(result == 1);\n}\n\n#[test]\nfn test_inv_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(3, 11) };\n // 3 * 4 = 12 = 1 (mod 11), so 3^(-1) = 4 (mod 11)\n assert(result == 4);\n // Verify: 3 * result = 1 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(3, result, 11) } == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(7, 13) };\n // Verify: 7 * result = 1 (mod 13)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(7, result, 13) } == 1);\n}\n\n#[test]\nfn test_inv_mod_another_prime() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(5, 17) };\n // Verify: 5 * result = 1 (mod 17)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(5, result, 17) } == 1);\n}\n\n#[test]\nfn test_inv_mod_inverse_of_inverse() {\n let a: Field = 7;\n let m: Field = 11;\n // Safety: Test function calling unconstrained helper\n let inv_a = unsafe { __inv_mod(a, m) };\n // Safety: Test function calling unconstrained helper\n let inv_inv_a = unsafe { __inv_mod(inv_a, m) };\n // (a^(-1))^(-1) = a\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_div_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(6, 2, 11) };\n assert(result == 3); // 6 / 2 = 3\n // Verify: result * 2 = 6 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 2, 11) } == 6);\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(7, 3, 11) };\n // 3^(-1) mod 11 = 4 (since 3 * 4 = 12 = 1 mod 11)\n // 7 * 4 = 28 = 6 (mod 11)\n assert(result == 6);\n // Verify: result * 3 = 7 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 3, 11) } == 7);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a: Field = 10;\n let b: Field = 3;\n let m: Field = 17;\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(a, b, m) };\n // Verify: result * b = a (mod m)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, b, m) } == a);\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a: Field = 250;\n let b: Field = 7;\n let m: Field = 97;\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(a, b, m) };\n // Verify: result * b = a (mod m)\n // Safety: Test function calling unconstrained helper\n let (_, a_reduced) = unsafe { __compute_mod_reduction(a, m) }; // 250 mod 97 = 56\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, b, m) } == a_reduced);\n}\n\n#[test]\nfn test_div_mod_by_one() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(42, 1, 100) };\n assert(result == 42); // 42 / 1 = 42\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 1, 100) } == 42);\n}\n\n#[test]\nfn test_all_operations_consistency() {\n // Test that all operations work together correctly\n let m: Field = 97; // Prime\n let a: Field = 42;\n let b: Field = 13;\n\n // Test: (a + b) mod m\n let sum = a + b;\n // Safety: Test function calling unconstrained helper\n let (_, sum_reduced) = unsafe { __compute_mod_reduction(sum, m) };\n assert(sum_reduced == 55);\n\n // Test: (a - b) mod m using subtraction\n // Safety: Test function calling unconstrained helper\n let (diff, _) = unsafe { __sub_with_underflow(a, b, m) };\n assert(diff == 29);\n\n // Test: (a * b) mod m\n // Safety: Test function calling unconstrained helper\n let prod = unsafe { __mul_mod(a, b, m) };\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test: b^(-1) mod m\n // Safety: Test function calling unconstrained helper\n let inv = unsafe { __inv_mod(b, m) };\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(b, inv, m) } == 1);\n\n // Test: (a / b) mod m\n // Safety: Test function calling unconstrained helper\n let quot = unsafe { __div_mod(a, b, m) };\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(quot, b, m) } == a);\n\n // Test: (-a) mod m\n // Safety: Test function calling unconstrained helper\n let neg = unsafe { __neg(a, m) };\n let sum_neg = a + neg;\n // Safety: Test function calling unconstrained helper\n let (_, sum_neg_reduced) = unsafe { __compute_mod_reduction(sum_neg, m) };\n assert(sum_neg_reduced == 0);\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/unconstrained_U128.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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/polynomial.nr" + "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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/safe.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr" } }, "expression_width": { "Bounded": { "width": 4 } } diff --git a/crates/zk-prover/tests/fixtures/pk.json b/crates/zk-prover/tests/fixtures/pk.json index d5834b1b29..589596a065 100644 --- a/crates/zk-prover/tests/fixtures/pk.json +++ b/crates/zk-prover/tests/fixtures/pk.json @@ -1,6 +1,6 @@ { "noir_version": "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", - "hash": "2071989265523136017", + "hash": "15513232712324041253", "abi": { "parameters": [ { @@ -42,23 +42,23 @@ }, "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::dkg::{L, N};\nuse lib::configs::default::dkg::PK_BIT_PK;\nuse lib::core::dkg::pk::Pk;\nuse lib::math::polynomial::Polynomial;\n\nfn main(pk0is: [Polynomial; L], pk1is: [Polynomial; L]) -> pub Field {\n let pk: Pk = Pk::new(pk0is, pk1is);\n pk.execute()\n}\n", - "path": "enclave/circuits/bin/dkg/pk/src/main.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/dkg/pk/src/main.nr" }, "62": { "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_dkg_pk_commitment;\nuse crate::math::polynomial::Polynomial;\n\n/// Correct DKG Public Key Circuit (Circuit 0).\npub struct Pk {\n /// Correct DKG public key components\n /// pk0[i] is the first component for modulus i\n pk0: [Polynomial; L],\n /// pk1[i] is the second component for modulus i\n pk1: [Polynomial; L],\n}\n\nimpl Pk {\n pub fn new(pk0: [Polynomial; L], pk1: [Polynomial; L]) -> Self {\n Pk { pk0, pk1 }\n }\n\n /// Main verification function\n /// Returns commitment to correct DKG public key\n pub fn execute(self) -> Field {\n compute_dkg_pk_commitment::(self.pk0, self.pk1)\n }\n}\n", - "path": "enclave/circuits/lib/src/core/dkg/pk.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/dkg/pk.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": "enclave/circuits/lib/src/math/commitments.nr" + "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": "enclave/circuits/lib/src/math/helpers.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/helpers.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": "enclave/circuits/lib/src/math/safe.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr" } }, "expression_width": { "Bounded": { "width": 4 } } diff --git a/crates/zk-prover/tests/fixtures/pk_aggregation.json b/crates/zk-prover/tests/fixtures/pk_aggregation.json new file mode 100644 index 0000000000..4ac30f3f3f --- /dev/null +++ b/crates/zk-prover/tests/fixtures/pk_aggregation.json @@ -0,0 +1,116 @@ +{ + "noir_version": "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", + "hash": "16715564098402969150", + "abi": { + "parameters": [ + { + "name": "expected_threshold_pk_commitments", + "type": { "kind": "array", "length": 5, "type": { "kind": "field" } }, + "visibility": "public" + }, + { + "name": "pk0", + "type": { + "kind": "array", + "length": 5, + "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": "pk1", + "type": { + "kind": "array", + "length": 5, + "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": "pk0_agg", + "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": "pk1_agg", + "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" + } + ], + "return_type": { "abi_type": { "kind": "field" }, "visibility": "public" }, + "error_types": { + "15123513130736236245": { "error_kind": "string", "string": "pk aggregation mismatch" }, + "15764276373176857197": { "error_kind": "string", "string": "Stack too deep" }, + "16412438021473037783": { "error_kind": "string", "string": "PK commitment mismatch" } + } + }, + "bytecode": "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", + "debug_symbols": "tP3NjmVdsl0Hvstts3GW/RtfpVAQKIkSCBCUQEnVEfTulXHcbcyUCplIZqLYYGyS99vbLeLYmtN9Dx/8P//tf/yP//3/8T//d//pv/xP/8v/9m///v/1f/7bf/9f/9N//s//6X/+7/7z//I//If//T/9L//lL/+3/+e/ff78b6//7d+/f/dvb37+2O8f9pf/J/vLH+/nD/v5w//t3/tf/oh/+/fxlz/y54/6+eMvd8m//PGXu9T/9X/9u3+75/x3//t//Y//8c9j/urBf/ly/tf/8F//43/53//t3/+X/+M//+d/92//n//wn/+P7//Q//a//of/8v3zf/8P//Uv/6+ff/dv//G//I9/+fMvN/yf/tN//o9/rv6vf6f/+vO3/9P3xn//6/e2uEHvP3wHe3l3MIt/6g75uEN//qk7bN8d/P1TU7gFd4h/7g4x3KHfP3GHqfunmEn++/y//1v23/7vvb1+b+Bdxh3q//4VzN++gyV/j1af+WfuUO/DHez9U19D6GuwvznFe3/7Ftt+H8nt1V9lx//9Fva3b1H97quozv2bt/C/88/xyftA+Kf+6qvI/4ZbhHOL3r95i/zbt8i//K/fW2TO55+6RbHhWeb/3C0+H27x3r98i78+Z/4bbtF9f53Z86/fYv/2IH/v0znvjrudmr/10bJ//dNp//qn0/71T6f9659O+9c/nfavfzrtX/902r/+6bT/f386m7Nz82+enf73Pp3+9j6d/td5/v+4xd/5aPVn7q+zP/s3/1E9/s5X8f6c7z9fxUt9FfP+4Vvk7AVq7l/F4f/zFvV3/jpf3N/Fvo2/eYu/E+sRdedFxOqrePvf8HdR/IvYp/+Zv4v/2y3+Kpb/W/46N/TXGX/7q/h7n4u/tM37XDz/m6dW/J1PZ5ffIF35/tZXEf4v/6NG/Mv/qH93kKHu9V+W9m99FX+3rPEPYjX9r5a1v32Hv1dap694++zfrJx//sL/5i3e3mHxlxbf/9Qt3G4O98i/dYv8OwfnX5aC5vuXvxZ9NPsfv4UTZeb2r98i3j91i/jwbxqv/+Vb2D/7Vdg/cIu/+48acTv2l3/Tf+6j9de3GPvnbmH+D9zi763IsmS+/Te/p6r3L6/I373FP7Yi5f/yivzdW/xjK/IP3+Jvr8jfvcU/tiL/8C3sn/0q/pEV+bv/qP/YivzDt/jbn++/f4t/dUXiw4+x4tXnb97B/+UfGnT8y9+Wdf7L31N1/cvfEP39W/xD3xD9w7f4298Q/d1b/GPfEP3Dt/jb3xD93c/FP/bt+vzr367Pv/699sS//Ln4+7f4hz4X//At/vbn4u/e4h/7XPzDt/hnPxf/0DfK+/mXv1He9y9/o7z2L3+j/Pdu8Q9+o7zxL39Ptfkvf0/19/8u/qFvlP/hW/ztb5T/7l/nP/aN8t/9XPxj3yi/z+df/k75fd6//M/6PvYv/7v+/Vn+zjfL/++//J/+w//wn/7r/89LP//Ld77v5w/7+cN//oifP/Lnj/r5o3/+mJ8/9vc/v9v83uf93uj93un93ur93uv93uz93u393u793s9+72f3df3ez37vZ7/3s9/72e/97Pd+9ns/+72f/97Pf+/nN+jv/fz3fv57P/+9n//ez3/v57/3i9/7xe/94vd+cX9zv/eL3/vF7/3i937xe7/4vV/+3i9/75e/98vf++X9U/zeL3/vl7/3y9/75e/96vd+9Xu/+r1f/d6vfu9X92/7e7/6vV/93q9+79e/9+vf+/Xv/fr3fv17v/69X9+H5fd+/Xu//r3f/N5vfu83v/eb3/vN7/3m937ze7+5T9/v/eb3fvt7v/293/7eb3/vt7/329/77e/99vd+ex9nPs/3gf7cJ/pzH+nPfaY/96H+3Kf6cx/rz32uP/fB/tydtSp3Z5aFbWFd2BcWho1hZW5n3i3NM7bw7nx7825x3m3Ou9V5tzvvlufd9rxbn3f785wFvzvfCr3boXdL9G6L3q3Ruz16t0jvNundKr3g7Lg73za9W6d3+/Ruod5t1LuVerdT75bq3Va95Fi6O99ivdusd6v1brfeLde77Xq3Xu/2692CveLEuzvfjr1bsndb9m7N3u3Zu0V7t2nvVu3drr3mML0737q927d3C/du496t3Lude7d077bu3dq94Zy+O9/mvVu9d7v3bvnebd+79Xu3f+8W8N0GviUCyIALgdtBux2020G7HbTbQbsdtNtBux2020F7xMvd+XbQbgftdtBuB+120G4H7XbQyC2CS8l1dya7CC/Si/givwiw20G7HbTbQXNC8e58O2i3g3Y7aLeDdjtot4N2O2i3g3Y7aEHe3p1vB+120G4H7XbQbgftdtBuB+120G4HLYnyu/PtoN0O2u2g3Q7a7aDdDtrtoN0O2u2gFS3h7nw7aLeDdjtot4N2O2i3g3Y7aLeDdjtoTQG5O98O2u2g3Q7a7aDdDtrtoN0O2u2g3Q7a0G3uzreDdjtot4N2O2i3g3Y7aLeDdjtot4O21CZ60xWn20G/HfTbQb8d9NtBvx3020G/HfTbQX9Usrvz7aDfDvrtoN8O+u2g3w767aDfDvrtoBtt7+58O+i3g3476LeDfjvot4NOi6RG0iNVJO/OVEm6JGWSNkmdvB3020G/HfTbQQ866t35dtBvB/120G8H/XbQbwf9dtBvB/120JP6e3e+HfTbQb8d9NtBvx3020G/HfTbQb8d9KJZ351vB/120G8H/XbQbwf9dtBvB/120G8HvSntd+fbQb8d9NtBvx3020G/HfTbQb8d9NtBH74fuDvfDvrtoN8O+u2g3w767aDfDvrtoN8O+vKtBt9r3Dcbt4NxOxi3g3E7GLeDcTsYt4NxOxi3g/H4NubufDsYt4NxOxi3g3E7GLeDcTsYt4NxOxjGd0h359vBuB2M28G4HYzbwbgdjNvBuB2M28Fwvvm6O98Oxu1g3A7G7WDcDgbf0/FNHd/V8W2dvq+7O/OdHd/a8b0d39zdDsbtYNwOxu1g3A5G8i3j3fl2MP7sYOSfi7mL/b34s4N/gMy4HYzbwbgdjNvBKL4bvTvfDsbtYNwOxu1g3A7G7WDcDsbtYNwORvON7t35djBuB+N2MG4H43YwbgfjdjBuB+N2MIbvoe/Ot4NxOxi3g3E7GLeDcTsYt4NxOxi3g7F8e8735/cN+u1g3g7m7WDeDubtYN4O5u1g3g7m7WA+vvW/O98O5u1g3g7m7WDeDubtYN4O5u1g3g6m8VOFu/PtYN4O5u1g3g7m7WDeDubtYN4O5u1gOj+wuDvfDubtYN4O5u1g3g7m7WDeDubtYN4OZvCzkLvz7WDeDubtYN4OJj9h4Ucs/IyFH7LwUxb9mOXuzA9a+EkLP2q5HMzLwbwdzNvBvB3M28EsfoJzd74dzNvBvB3M28G8HczbwbwdzNvBvB3M5odDd+fbwbwdzNvBvB3M28G8HczbwbwdzNvBHH7udHe+HczbwbwdzNvBvB3M28G8HczbwbwdzOVHWvxM636odTtYt4N1O1i3g3U7WLeDdTtYt4N1O1iPH5fdnW8H63awbgfrdrBuB+t2sG4H63awbgfL+Enc3fl2sG4H63awbgfrdrBuB+t2sG4H63awnB/y3Z1vB+t2sG4H63awbgfrdrBuB+t2sG4HK/j54d35drBuB+t2sG4H63awbgfrdrBuB+t2sJIfTd6dbwfrdrBuB4ufd/IDT37iyY88+ZknP/TUTz3vzvzckx983g7W7WDdDtbtYN0O1u1g3Q5W8wPVu/PtYN0O1u1g3Q7W7WDdDtbtYN0O1u1gDT+rvTvfDtbtYN0O1u1g3Q7W7WDdDtbtYN0O1vJjYH4OfD8Ivh3s28G+Hezbwb4d7NvBvh3s28G+HezHj5jvzreDfTvYt4N9O9i3g3072LeDfTvYt4Nt/PT67nw72LeDfTvYt4N9O9i3g3072LeDfTvYzg/G7863g3072LeDfTvYt4N9O9i3g3072LeDHfzM/e58O9i3g3072LeDfTvYt4N9O9i3g3072MmP8+/Ot4N9O9i3g3072LeDfTvYt4N9O9i3g128Kbg73w727WDz9oHXD7x/4AUEbyB4BcE7CL2EuDvzGuJ2sG8H+3awbwf7drBvB/t2sG8He3i/cXe+Hezbwb4d7NvBvh3s28G+Hezbwb4d7OXVCe9O7uXJ7eDcDs7t4NwOzu3g3A7O7eDcDs7t4Dxey9ydbwfndnBuB+d2cG4H53ZwbgfndnBuB8d443N3vh2c28G5HZzbwbkdnNvBuR2c28G5HRznZdLd+XZwbgfndnBuB+d2cG4H53ZwbgfndnCC91R359vBuR2c28G5HZzbwbkdnNvBuR2c28FJXoHdnW8H53ZwbgfndnBuB+d2cG4H53ZwbgeneLt2d74dnNvBuR2c28G5HZzbwbkdnNvBuR2c5sXd3fl2cHgXyMtA3gbyOpD3gbwQ5I0grwT1TvDufDs4t4NzOzi3g3M7OLeDczs4t4NzOzjL60beN94Lx9vBvR3c28G9Hdzbwb0d3NvBvR3c28F9vMq8O98O7u3g3g7u7eDeDu77/VnBvrmL358VrP3+rGCNt6R359vBvR3c28G9Hdzbwb0d3NvBvR3c28F1XsDenW8H93Zwbwf3dnBvB/d2cG8H93Zwbwc3eLd7d74d3NvBvR3c28G9Hdzbwb0d3NvBvR3c5LXx3fl2cG8H93Zwbwf3dnBvB/d2cG8H93ZwizfSd+fbwb0d3NvBvR3c28G9Hdzbwb0d3NvBbV52351vB/d2cG8H93Zwbwf3dnBvB/d2cG8Hd3iPfnfmzTyv5nk3z8t53s7zep7387yg5w29XtHrHT0v6fWWXq/p9Z5eL+r1pl6v6vWuXi/reVv/eQIBeAYv7D+8sf/wyv7DO/sPL+0/vLX/8Nr+w3v7Dy/uPybagGfw7v7Dy/sPb+8/vL7/8P7+wwv8D2/wP7zC//AO/+NCGngGr/E/vMf/8CL/w5v8D6/yP7zL//Ay/8Pb/A+v8z8hboJn8Eb/wyv9D+/0P7zU//BW/8Nr/Q/v9T+82P/wZv+TgjN4Bi/3P7zd//B6/8P7/Q8v+D+84f/wiv/DO/4PL/k/JQKEZ/Ce/8OL/g9v+j+86v/wrv/Dy/4Pb/s/vO7/8L7/08JMeAav/D+88//w0v/DW/8Pr/0/vPf/8OL/w5v/D6/+PyOWhWfw9v/D6/8P7/8/AAAfCIAPCMAHBuADBPCBAvisgBkRMyAz7LlwHPE4AnJE5AjJEZMjKOevqJy/wnJ4hsAckTlCc8TmCM4RnSM8hz0XoCNCR4iOGB1BOqJ0hOmI0xGoI1JHqI5YHcE6onWE64jXEbAjYkfIjpgdQTuidoTtiNsRuCNyR+iO2B3BO6J3hO+I3xHAI4JHCI8YHkE8oniE8YjjEcgjkkcoj1gewTyieYTziOcR0COiR0iPmB5BPaJ6hPWI6xHYI7JHaI/YHsE9onuE94jvEeAjwkeIjxgfQT6ifIT5iPMR6CPSR6iPWB/BPqJ9hPvA+zyAnwfx80B+HszPA/p5UD8P7OfB/TzAnwf580B/nolVZc+hfx74z4P/eQBADwLogQA9E4cnEO+vSDyeIRZPMJ5oPOF44vEE5LHn4EAPHugBBD2IoAcS9GCCHlDQgwp6YEEPLugBBj3IoAca9GCDHnDQgw564EEPPugBCD0IoQci9GCEHpDQgxJ6YEIPTugBCj1IoQcq9GCFHrDQgxZ64EIPXugBDD2IoQcy9GCGHtDQgxp6YEMPbugBDj3IoQc69GCHHvDQgx564EMPfugBED0IogdC9GCIHhDRgyJ6YEQPjugBEj1IogdK9GCJHjDRgyZ64EQPnugBFD2IogdS9GCKHlDRgyp6YEUPrugBFj3Iogda9GCLHnDRgy564EUPvui5qHT2HMTowRg9IKMHZfTAjB6c0QM0epBGD9TowRo9YKMHbfTAjR680QM4ei7yVuit2Nu/gm95hvBb8bcCcEXgCsFlz4GPHvTRAz968EcPAOlBID0QpAeD9ICQHhTSA0N6cEgPEOlBIj1QpAeL9ICRHjTSA0d68EgPIOlBJD2QpAeT9ICSHlTSA0t6cEkPMOlBJj3QpAeb9ICTHnTSA0968EkPQOl9CaU/P5N5X0Tp92rvan5/UPOglB6Y0oNTeoBKD1LpgSo9WKUHrPSglR640oNXegBLD2LpgSw9mKUHtPSglh7Y0oNbeoBLD3LpgS492KUHvPSglx740oNfegBMD4LpgTA9GKYHxPRCv3/CnsMxPUCmB8n0QJkeLNMDZnrQTA+c6cEzPYCmB9H0QJoeTNMDanpQTQ+s6cE1PcCmB9n0QJsebNMDbnrQTQ+86YVYe8H2ou2F2/8Vb88zRNwLuRdzL+iePQd1erBOD9jpQTs9cKcH7/QAnl6w58GeB3se7DnU0wN7enBPD/DpQT490KcH+/SAnx700wN/evBPDwDqQUA9EKgHA/WAoB4U1AODenBQDxDqQUI9UKgHC/WAoR401AOHevBQDyDqQUQ9kKgHE/WAoh5U1AOLenBRDzDqQUY90KgHG/WAox501AOPevBRD0DqQUg9EKkHI/WApB6U1AOTenBSD1DqQUq91G+asefAUg9a6oFLPXipBzD1IKYeyNSDmXpAUw9q6oFNPbipBzj1IKce6NSDnXrAUw966oFPPfipB0D1IKgeCNWDoXpAVA+K6oFRPTiqB0j1IKkeKNWDpXrAVC/12zX69Rr9fo1+wUa/YfNXv2LDM/RLNvotG/2aDXsOWPUgqx5o1YOtesBVD7rqgVc9+KoHYPUgrB6I1YOxekBWD8rqgVk9OKsHaPUgrR6o1YO1esBWD9rqgVs9eKsHcPUgrh7I1YO5ekBXD+rqgV09uKsHePUgrx7o1YO9esBXD/rqgV89+KsHgPUgsB4I1oPBekBYDwrrgWE9OKwHiPUgsR4o1oPFesBYDxrrgWO90u+UsucQWQ8k68FkPaCsB5X1wLIeXNYDzHqQWQ8068FmPeCsB531wLMefNYD0HoQWg9E68FoPSCtB6X1wLQenNYD1HqQWg9U68FqPWCtB631wLUevNYD2HoQWw9k68FsPaCtB7X1wLYe3NYD3HqQWw9065V+n06/UKffqNOv1Ol36vRLdX/1W3U8Q79Xp1+sY8/BuB4c1wPkepBcD5TrwXI9YK4HzfXAuR481wPoehBdD6TrwXQ9oK4H1fXAuh5c1wPsepBdD7TrwXY94K4H3fXAux581wPwehBeD8TrwXg9IK8H5fXAvB6c1wP0epBeD9TrwXo9YK8H7fXAvR681wP4ehBfD+TrwXy91m+Ps+dgXw/u6wF+PcivB/r1YL8e8NeD/nrgXw/+6wGAPQiwBwL2YMAeENiDAntgYA8O7AGCPUiwBwr2YMEeMNiDBnvgYA8e7AGEPYiwBxL2YMIeUNiDCntgYQ8u7AGGPciwBxr2YMMecNiDDnvgYQ8+7AGIPQixByL2YMQekNiDEntgYg9O7AGKvdZv0OpXaPU7tPolWv0WrX6NVr9H+1e/SMsz9Ku07DnQ2IMae2BjD27sAY49yLEHOvZgxx7w2IMee+BjD37sAZA9CLIHQvZgyB4Q2YMie2BkD47sAZI9SLIHSvZgyR4w2YMme+BkD57sAZQ9iLIHUvZgyh5Q2YMqe2BlD67sAZa9kSeCPYcte8BlD7rsgZc9+LIHYPYgzB6I2YMxe0BmD8rsgZk9OLMHaPYgzR6o2YM1e8Bm70ubfX/G88XNfq/u5z5f4Oz7cx+Iswdy9mDOHtDZgzp7YGcP7uwBnj3Iswd69mDPHvDZgz574GcP/uwBoD0ItAeC9mDQHhDag0J7YGgPDu0Boj1ItAeK9mDRHjDag0Z74GgPHu0BpD2ItAeS9mDSHlDag0p7YGlv9Dvz+qV5/da8fm1evzevX5zXb87rV+f/6nfneQZ7DqL2YNQekNqDUntgag9O7QGqPUi1B6r2YNUesNqDVnvgag9e7QGsPYi1B7L2YNYe0NqDWntgaw9u7QGuPci1B7r2YNce8Npb9nxlhGHPlz2HYHsgbA+G7QGxPSi2B8b24NgeINuDZHugbA+W7QGzPWi2B8724NkeQNuDaHsgbQ+m7QG1Pai2B9b24NoeYNuDbHugbQ+27QG3Pei2B9724NsegNuDcHsgbg/G7QG5PSi3B+b24NweoNuDdHugbg/W7QG7PWi3B+724N0ewNuDeHsgbw/m7QG9Pai3B/b24N4e4NuDfHugbw/27QG/Pei3B/724N8eANyDgHsgcA8G7gHBvZUlQ5oMeTIkypApQ6oMuTIky5At4690Gb/PsI+EGTJmSJkhZ4akGbJmSJshb4bEGZgz4OEMHs7g4QwezuDhDB7O4OEMHs7g4ewj9xMSDXg4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDh7MnQ85fKXJ4hiQ5suRIkyNPjkQ5MuVIlcOeP1ne2HN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiDhzN4OIOHM3g4g4czeDiT/0oCLBmwpMCSA0sSLFmwpMGSB0siLJmwpMKSC0syLNmwpMOSD0tCLBmxpMT6KyeWpFh/ZcXiGfJiSYwlM5bUWHJjSY7FnkuPJT+WBFkyZEmRJUeWJFmyZEmTJU+WRFkyZUmVJVeWZFmyZUmXJV+WhFkyZkmZJWeWpFmyZkmbJW+WxFkyZ0mdJXeW5FmyZ0mfJX+WBFoyaEmhJYeWJFqyaEmjJY+WRFoyaUmlJZeWZFqyaUmnJZ+WhFoyakmpJaeWpFqyakmrJa+WxFoya0mtJbeW5Fqya0mvJb+WBFtfHu7Pz3jsy8P9Xv3+3Me+PNyfn/vYl4fL7//fin/2PP175VwFV8lVcdVcDVd7V3/2/PfqccUzHs94POPPnmd8r4qr5mq42rv6s+e/V3+e0d+rvzyjPt8rv9mMZxhzGHMYcxhzGHM4czhzOHM4czjPcJ7hPMOZw5nDmSOY48+e/14ZV36z/dnzn9n+7PnPbMEzgjmCOYI5kjmSOZI5kjmSOZI5kmckz0iekcxRzFHMUczxZ89/r4KrvNn+7PnPbH/2/Ge24hnFHM0czRzNHM0czRzNHM0czRzNM5pnDM8Y5hjmGOYY5hg+u8Nn98+e/8z2Z89/Zvuz5z+zLc9Y5ljmWOZY5ljmWOZY5ljm2Jvjy8P9Xj2ujKub48vD/V4lV8VVczVc7e9sXx7uO9uXh/vOFux5sOfBnn95uN+r4qq5Gq6Yw5jDmMN4hvEM9vzLw/18pcYcxhzGHHaf3S8P93t1Z8mXh/uZze8sCfY82PNgz7883O8VczhzBHMEcwRzBHMEzwiewZ5/ebifrzSYI5gjmSMfV8bVnSVfHu5ntryzJNjzYM+DPf/ycD9XxRzFHMUcxRzFHMUcxTOKZ7DnXx7u5ytt5mjmaOZoPrvNZ7fvLPnycD+z9Z0lwZ4Hex7s+ZeH+71ijmGOYY5hjmGOYY7hGcMz2PMvD/fzlS5zLHMscyyf3eWzu3eWfHm4n9n2zpJkz5M9T/Y8yfMkz5M8T/I8yfMkz5M8T/I8yfNkz7883Pcr/fJwv1fJVXHVXA1Xd5Z8ebjvbF8e7mc29jzZ82TPkzxP8jzJ8yTPkzxP8jzJ8yTPkzxP9vzLw/18pc4c5HmS50meJ3n+5eF+Zos7S7483M9s7Hmy58meJ3me5HmS50meJ3me5HmS50meJ3me7PmXh/v5SpM5yPMkz5M8T/L8y8P9zFZ3lnx5uJ/Z2PNkz5M9T/I8yfMkz5M8T/I8yfMkz5M8T/I82fMvD/fzlQ5zkOdJnid5nuT5l4f7mW3uLPnycD+zsefJnid7nuR5kudJnid5nuR5kudJnid5nuR5sedfHu77lX55uN8r5yq4Sq6KqztLvjzcd7YvD/edrdjzYs+LPS/yvMjzIs+LPC/yvMjzIs+LPC/yvNjzLw/385Uac5DnRZ4XeV7k+ZeH+5nN7yz58nA/s7HnxZ4Xe17keZHnRZ4XeV7keZHnRZ4XeV7kebHnXx7u5ysN5iDPizwv8rzI8y8P9zNb3lny5eF+ZmPPiz0v9rzI8yLPizwv8rzI8yLPizwv8rzI82LPvzzcz1dazEGeF3le5HmR518e7me2vrPky8P9zMaeF3te7HmR50WeF3le5HmR50WeF3le5HmR58Wef3m4n690mYM8L/K8yPMiz7883M9se2fJl4f7mY09L/a82fMmz5s8b/K8yfMmz5s8b/K8yfMmz5s9//Jw36/0y8P9XjlXwVVyVVzdWfLl4b6zfXm472zNnjd73ux5k+dNnjd53uR5k+dNnjd53uR5k+fNnn95uJ+v1JmDPG/yvMnzJs+/PNzPbHFnyZeH+5mNPW/2vNnzJs+bPG/yvMnzJs+bPG/yvMnzJs+bPf/ycD9faTIHed7keZPnTZ5/ebif2erOki8P9zMbe97sebPnTZ43ed7keZPnTZ43ed7keZPnTZ43e/7l4X6+0mYO8rzJ8ybPmzz/8nA/s82dJV8e7mc29rzZ82bPmzxv8rzJ8ybPmzxv8rzJ8ybPmzxv9vzLw32/0i8P93v1uDKunKvg6s6SLw/3ne3Lw31nG/Z82PNhz4c8H/J8yPMhz4c8H/J8yPMhz4c8H/b8y8P9fKXGHOT5kOdDng95/uXhfmazO0u+PNzPbOz5sOfDng95PuT5kOdDng95PuT5kOdDng95Puz5l4f7+UqDOcjzIc+HPB/y/MvD/cyWd5Z8ebif2djzYc+HPR/yfMjzIc+HPB/yfMjzIc+HPB/yfNjzLw/385UWc5DnXx7u94rPLnn+5eF+Zus7S7483M9s7Pmw58OeD3k+5PmQ50OeD3k+5PmQ50OeD3k+7PmXh/v5Soc5yPMhz4c8H/L8y8P9zLZ3lnx5uJ/Z2PNhz4c9H/J8yfMlz5c8X/J8yfMlz5c8X/J82fMvD/f9Sr883O/V48q4cq6CqztLvjzcd7YvD/edbdnzZc+XPV/yfMnzJc+XPF/yfMnzJc+XPF/yfNnzLw/385U6c5DnS54veb7k+ZeH+5nN7yz58nA/s7Hny54ve77k+ZLnS54veb7k+ZLnS54veb7k+bLnXx7u5ytN5iDPlzxf8nzJ8y8P9zNb3Vny5eF+ZmPPlz1f9nzJ8yXPlzxf8nzJ8yXPlzxf8nzJ82XPvzzcz1fazEGeL3m+5PmS518e7me2ubPky8P9zMaeL3u+7PmS50ueL3m+5PmS50ueL3m+5PmS58uef3m4n690mePy3D+X5/65PPfP5bl/ebg/s/mXh/szm395uD+z+ef23D+35/65PffP5bl/Ls/9c3nun8tz/1ye++fy3D+X5/55POPxjMczHnMYcxhzGHNcnvvn8ty/PNzPbFY3m/XNZjzDmMOZw5nDmcOZw5nDmcOZw5nDeYbzjOAZwRzBHMEcwRyX5/65PPcvD/czW8zNFnuzJc9I5kjmSOZI5kjmSOZI5kjmSOYonlE8o3hGMUcxRzFHMcfluX8uz/3Lw/3M1p+brd/N1jyjmaOZo5mjmaOZo5mjmWOYY5hjeMbwjOEZwxzDHMMcwxzDZ3f57O672dZutvWbbXnGMscyxzLHMsflub/Lc3+X5/4uz/1dnvu7PPd3ee6PPX/3Xs3fvVfzd3nu7/Lc3+W5v8tz//Jw39m+PNx3ti8P953tseePPX/s+XvMYcxhzGHMYcxhzGHMYTzDeAZ7/ow5nDmcOZw5Ls/9XZ77l4f7mc3vLPnycD+zseePPX/s+QvmCOYI5gjmCOYI5gjmCJ4RPIM9f8kcyRzJHMkcl+f+Ls/9y8P9zJZ3lnx5uJ/Z2PPHnj/2/BVzFHMUcxRzFHMUcxRzNM9onsGev2aOZo5mjmaO5rPbfHb7zpIvD/cz29xZ8tjzx54/9vwNcwxzDHMMcwxzLHMscyzPWJ7Bnr9ljmWOZY5lDvLcyPMvD/ed7cvDfWf78nDf2Yw9N/bc2HMjz408N/LcyHMjz408N/LcyHMjz409t3uv5nbv1dzIcyPPjTw38vzLw/3MZneWfHm4n9nYc2PPjT038tzIcyPPjTw38tzIcyPPjTw38tzYc3PmCOYgz408N/LcyPMvD/czW9xZ8uXhfmZjz409N/bcyHMjz408N/LcyHMjz408N/LcyHNjz62Yo5iDPDfy3MhzI8+/PNzPbHVnyZeH+5mNPTf23NhzI8+NPDfy3MhzI8+NPDfy3MhzI8+NPbdhjmEO8tzIcyPPjTz/8nA/s+2dJV8e7mc29tzYc2PPjTw38tzIcyPPjTx38tzJc3g4h4dzeDj3e6/mfu/V3MlzJ8+dPHfy/IeH6+/VnSU/PJx9r3gGe+7suZPnTp47ee7kuZPnTp47eQ4P5/BwDg/nbsxhzEGeO3nu5LmT5z883Hc2v7Pkh4f7zsaeO3vu7LmT506eO3nu5LmT506eO3kOD+fwcA4P5x7MkcxBnjt57uS5k+c/PNx3tryz5IeH+87Gnjt77uy5k+dOnjt57uS5k+dOnjt5Dg/n8HAOD+fezNHMQZ47ee7kuZPnPzzcd7a+s+SHh/vOxp47e+7suZPnTp47ee7kuZPnTp47eQ4P5/BwDg/nvsyxzEGeO3nu5LmT5z883J/Zvjzcd7Y47tXh4TzY82DPgzwP8jzI8yDPgzwP8jzIc3g4h4dzeDiPe6/mce/VPMjzIM+DPA/yPI579Tju1eO4V4eH82DPgz0P8jzI8yDPgzwP8jzI8yDP4eEcHs7h4TycOZw5yPMgz4M8D/I8jnv1OO7V47hXh4fzYM+DPQ/yPMjzIM+DPA/yPMjzIM/h4RwezuHhPJI5ijnI8yDPgzwP8jyOe/U47tXjuFeHh/Ngz4M9D/I8yPMgz4M8D/I8yPMgz+HhHB7O4eE8hjmGOcjzIM+DPA/yPI579Tju1eO4V4eH82DPgz0P8jzI8yDPgzwP8jzI8yDP4eEcHs7h4TzvvZrnvVfzJM+TPE/yPMnzPO7V87hXz+NeHR7Okz1P9jzJ8yTPkzxP8jzJ8yTPkzyHh3N4OIeH8zTmMOYgz5M8T/I8yfM87tXzuFfP414dHs6TPU/2PMnzJM+TPE/yPMnzJM+TPIeHc3g4h4fzDOYI5iDPkzxP8jzJ8zzu1fO4V8/jXh0ezpM9T/Y8yfMkz5M8T/I8yfMkz5M8h4dzeDiHh/Ms5mjmIM+TPE/yPMnzPO7V87hXz+NeHR7Okz1P9jzJ8yTPkzxP8jzJ8yTPkzyHh3N4OIeH81zmWOYgz5M8T/I8yfM87tXzuFfP414dHs6LPS/2vMjzIs+LPC/yvMjzIs+LPIeHc3g4h4fzuvdqXvdezYs8L/K8yPMiz+u4V6/jXr2Oe3V4OC/2vNjzIs+LPC/yvMjzIs+LPC/yHB7O4eEcHs7LmcOZgzwv8rzI8yLP67hXr+NevY57dXg4L/a82PMiz4s8L/K8yPMiz4s8L/IcHs7h4RweziuZI5mDPC/yvMjzIs/ruFev4169jnt1eDgv9rzY8yLPizwv8rzI8yLPizwv8hwezuHhHB7Oq5ljmIM8L/K8yPMiz+u4V6/jXr2Oe3V4OC/2vNjzIs+LPC/yvMjzIs+LPC/yHB7O4eEcHs6b92rNe7Umz5s8b/K8yfM+7tX7uFfv414dHs6bPW/2vMnzJs+bPG/yvMnzJs+bPIeHc3g4h4fz5r1a816tyfMmz5s8b/K8j3v1Pu7V+7hXh4fzZs+bPW/yvMnzJs+bPG/yvMnzJs/h4RwezuHhvHmv1rxXa/K8yfMmz5s87+NevY979T7u1eHhvNnzZs+bPG/yvMnzJs+bPG/yvMlzeDiHh3N4OG/eqzXv1Zo8b/K8yfMmz/u4V+/jXr2Pe3V4OG/2vNnzJs+bPG/yvMnzJs+bPG/yHB7O4eEcHs6b92rNe7Umz5s8b/K8yfM+7tX7uFfv414dHs6bPR/2fMjzIc+HPB/yfMjzIc+HPIeHc3g4h4fz4b3a8F5tyPMhz4c8H/J8jnv1Oe7V57hXh4fzYc+HPR/yfMjzIc+HPB/yfMjzIc/h4RwezuHhfHivNrxXG/J8yPMhz4c8n+NefY579Tnu1eHhfNjzYc+HPB/yfMjzIc+HPB/yfMhzeDiHh3N4OB/eqw3v1YY8H/J8yPMhz+e4V5/jXn2Oe3V4OB/2fNjzIc+HPB/yfMjzIc+HPB/yHB7O4eEcHs6H92rDe7Uhz4c8H/J8yPM57tXnuFef414dHs6HPR/2fMjzIc+HPB/yfMjzIc+HPIeHc3g4h4fz4b3a8l5tyfMlz5c8X/J8j3v1Pe7V97hXh4fzZc+XPV/yfMnzJc+XPF/yfMnzJc/h4RwezuHhfHmvtrxXW/J8yfMlz5c83+NefY979T3u1eHhfNnzZc+XPF/yfMnzJc+XPF/yfMlzeDiHh3N4OF/eqy3v1ZY8X/J8yfMlz/e4V9/jXn2Pe3V4OF/2fNnzJc+XPF/yfMnzJc+XPF/yHB7O4eEcHs6X92rLe7Ulz5c8X/J8yfM97tX3uFff414dHs6XPV/2fMnzJc+XPF/yfMnzJc+XPIeHc3g4h4fz5b3a8l5tyfMlz5c8X/J8j3v1Pe7V97hXh4fzZc+XPd/L8/hcnsfn8jw+l+fxuTyPz+V5fC7PAx4u4OECHi4+914tPvdeLT6X5/G5PI/P5Xl8Ls/jc9xrfI57jc9xrwEPF5/HHMYcxhzGHMYcxhzGHMYcxhzGM4xnOM9w5nDmcOZw5rg8j8/leXyOe43Pca/xOe414OHiE8wRzBHMEcwRzBHMEcwRzBHMkTwjeUbyjGSOZI5kjmSOy/P4XJ7H57jX+Bz3Gp/jXgMeLj7FHMUcxRzFHMUcxRzFHM0czRzNM5pnNM9o5mjmaOZo5mg+u8Nn97jX+Bz3Gp/jXgMeLj7DHMMcwxzDHMMcyxzLHMscyxzLM5ZnLM9Y5ljmuDyPd3ke7/I83uV5vONe4x33Gu+414CHi8eeP/b8XZ7HuzyPd3ke7/I83uV5vMvzeJfnAQ8X8HABDxfvMYcxhzGHMcflebzL83jHvcY77jXeca8BDxePPX/s+XPmcOZw5nDmcOZw5nDmcJ7hPIM9f8EcwRzBHMEcl+fxLs/jHfca77jXeMe9BjxcPPb8secvmSOZI5kjmSOZI5kjmaN4RvEM9vwVcxRzFHMUc1yex7s8j3fca7zjXuMd9xrwcPHY88eev2aOZo5mjmaOZo5hjmGO4RnDM9jzN8wxzDHMMcwxfHaXz+5xr/GOe4133GvAw8Vjzx97/pY5ljnIcyPPjTw38tzIc3i4gIcLeLiwe68Wdu/VwshzI8+NPDfy3I57DTvuNey414CHC2PPjT038tzIcyPPjTw38tzIcyPP4eECHi7g4cKMOZw5yHMjz408N/LcjnsNO+417LjXgIcLY8+NPTfy3MhzI8+NPDfy3MhzI8/h4QIeLuDhwpI5kjnIcyPPjTw38tyOew077jXsuNeAhwtjz409N/LcyHMjz408N/LcyHMjz+HhAh4u4OHCmjmaOchzI8+NPDfy3I57DTvuNey414CHC2PPjT038tzIcyPPjTw38tzIcyPP4eECHi7g4cKWOZY5yHMjz408d/Lcj3sNP+41/LjXgIcL/HCBHy7wwwV+uMAPF/jhAj9c4IcL/HABDxfwcAEPF/jhAj9c4IcL/HDh5LmT537ca/hxr+HHvQY8XOCHC/xwgR8u8MMFfrjADxf44QI/XOCHC3i4gIcLeLjADxf44QI/XOCHCyfPnTz3417Dj3sNP+414OECP1zghwv8cIEfLvDDBX64wA8X+OECP1zAwwU8XMDDBX64wA8X+OECP1w4ee7kuR/3Gn7ca/hxrwEPF/jhAj9c4IcL/HCBHy7wwwV+uMAPF/jhAh4u4OECHi7wwwV+uMAPF/jhwslzJ8/9uNfw417Dj3sNeLjADxf44QI/XOCHC/xwgR8u8MMFfrjADxfwcAEPF/BwgR8u8MMFfrjADxdBngd5Hse9Rhz3GnHca8DDBX64wA8X+OECP1zghwv8cIEfLvDDBX64gIcLeLiAhwv8cIEfLvDDBX64CPI8yPM47jXiuNeI414DHi7wwwV+uMAPF/jhAj9c4IcL/HCBHy7wwwU8XMDDBTxc4IcL/HCBHy7ww0WQ50Gex3GvEce9Rhz3GvBwgR8u8MMFfrjADxf44QI/XOCHC/xwgR8u4OECHi7g4QI/XOCHC/xwgR8ugjwP8jyOe4047jXiuNeAhwv8cIEfLvDDBX64wA8X+OECP1zghwv8cAEPF/BwAQ8X+OECP1zghwv8cBHkeZDncdxr5HGvkce9Bjxc4IcL/HCBHy7wwwV+uMAPF/jhAj9c4IcLeLiAhwt4uMAPF/jhAj9c4IeLJM+TPM/jXiOPe4087jXg4QI/XOCHC/xwgR8u8MMFfrjADxf44QI/XMDDBTxcwMMFfrjADxf44QI/XCR5nuR5Hvcaedxr5HGvAQ8X+OECP1zghwv8cIEfLvDDBX64wA8X+OECHi7g4QIeLvDDBX64wA8X+OEiyfMkz/O418jjXiOPew14uMAPF/jhAj9c4IcL/HCBHy7wwwV+uMAPF/BwAQ8X8HCBHy7wwwV+uMAPF0meJ3mex71GHvcaedxrwMMFfrjADxf44QI/XOCHC/xwgR8u8MMFfriAhwt4uICHC/xwgR8u8MMFfrgo8rzI8zruNeq416jjXgMeLvDDBX64wA8X+OECP1zghwv8cIEfLvDDBTxcwMMFPFzghwv8cIEfLvDDRZHnRZ7Xca9Rx71GHfca8HCBHy7wwwV+uMAPF/jhAj9c4IcL/HCBHy7g4QIeLuDhAj9c4IcL/HCBHy6KPC/yvI57jTruNeq414CHC/xwgR8u8MMFfrjADxf44QI/XOCHC/xwAQ8X8HABDxf44QI/XOCHC/xwUeR5ked13GvUca9Rx70GPFzghwv8cIEfLvDDBX64wA8X+OECP1zghwt4uICHC3i4wA8X+OECP1zgh4siz4s8r+Neo457jTruNeDhAj9c4IcL/HCBHy7wwwV+uMAPF/jhAj9cwMMFPFzAwwV+uMAPF/jhAj9cNHne5Hkf9xp93Gv0ca8BDxf44QI/XOCHC/xwgR8u8MMFfrjADxf44QIeLuDhAh4u8MMFfrjADxf44aLJ8ybP+7jX6ONeo497DXi4wA8X+OECP1zghwv8cIEfLvDDBX64wA8X8HABDxfwcIEfLvDDBX64wA8XTZ43ed7HvUYf9xp93GvAwwV+uMAPF/jhAj9c4IcL/HCBHy7wwwV+uICHC3i4gIcL/HCBHy7wwwV+uGjyvMnzPu41+rjX6ONeAx4u8MMFfrjADxf44QI/XOCHC/xwgR8u8MMFPFzAwwU8XOCHC/xwgR8u8MPFkOdDns9xrzHHvcYc9xrwcIEfLvDDBX64wA8X+OECP1zghwv8cIEfLuDhAh4u4OECP1zghwv8cIEfLoY8H/J8jnuNOe415rjXgIcL/HCBHy7wwwV+uMAPF/jhAj9c4IcL/HABDxfwcAEPF/jhAj9c4IcL/HAx5PmQ53Pca8xxrzHHvQY8XOCHC/xwgR8u8MMFfrjADxf44QI/XOCHC3i4gIcLeLjADxf44QI/XOCHiyHPhzyf415jjnuNOe414OECP1zghwv8cIEfLvDDBX64wA8X+OECP1zAwwU8XMDDBX64wA8X+OECP1wMeT7k+Rz3GnPca8xxrwEPF/jhAj9c4IcL/HCBHy7wwwV+uMAPF/jhAh4u4OECHi7wwwV+uMAPF/jhYsnzJc/3uNfY415jj3sNeLjADxf44QI/XOCHC/xwgR8u8MMFfrjADxfwcAEPF/BwgR8u8MMFfrjADxdLni95vse9xh73Gnvca8DDBX64wA8X+OECP1zghwv8cIEfLvDDBX64gIcLeLiAhwv8cIEfLvDDBX64WPJ8yfM97jX2uNfY414DHi7wwwV+uMAPF/jhAj9c4IcL/HCBHy7wwwU8XMDDBTxc4IcL/HCBHy7ww8WS50ue73Gvsce9xh73GvBwgR8u8MMFfrjADxf44QI/XOCHC/xwgR8u4OECHi7g4QI/XOKHS/xwiR8uP5fn+bk8z89xr/k57jU/x70mPFzih0v8cIkfLvHDJX64xA+X+OESP1zih0t4uISHS3i4xA+X+OESP1zih8vP5Xl+Ls/zc9xrfo57zc9xrwkPl/jhEj9c4odL/HCJHy7xwyV+uMQPl/jhEh4u4eESHi7xwyV+uMQPl/jh8nN5np/L8/wc95qf417zc9xrwsMlfrjED5f44RI/XOKHS/xwiR8u8cMlfriEh0t4uISHS/xwiR8u8cMlfrj8FJ/d5rN73Gt+jnvNz3GvCQ+X+OESP1zih0v8cIkfLvHDJX64xA+X+OESHi7h4RIeLvHDJX64xA+X+OHys3x2l8/uca/5Oe41P8e9Jjxc4odL/HCJHy7xwyV+uMQPl/jhEj9c4odLeLiEh0t4uMQPl/jhEj9c4ofLd3me7/I833Gv+Y57zXfca8LDJX64xA+X+OESP1zih0v8cIkfLvHDJX64hIdLeLiEh0v8cIkfLvHDJX64fJfn+S7P8x33mu+413zHvSY8XOKHS/xwiR8u8cMlfrjED5f44RI/XOKHS3i4hIdLeLjED5f44RI/XOKHy3d5nu/yPN9xr/mOe8133GvCwyV+uMQPl/jhEj9c4odL/HCJHy7xwyV+uISHS3i4hIdL/HCJHy7xwyV+uHzNZ3f47B73mu+413zHvSY8XOKHS/xwiR8u8cMlfrjED5f44RI/XOKHS3i4hIdLeLjED5f44RI/XOKHSyPPjTy3417TjntNO+414eESP1zih0v8cIkfLvHDJX64xA+X+OESP1zCwyU8XMLDJX64xA+X+OESP1waeW7kuR33mnbca9pxrwkPl/jhEj9c4odL/HCJHy7xwyV+uMQPl/jhEh4u4eESHi7xwyV+uMQPl/jh0shzI8/tuNe0417TjntNeLjED5f44RI/XOKHS/xwiR8u8cMlfrjED5fwcAkPl/BwiR8u8cMlfrjED5dGnht5bse9ph33mnbca8LDJX64xA+X+OESP1zih0v8cIkfLvHDJX64hIdLeLiEh0v8cIkfLvHDJX64NPLcyHM77jXtuNe0414THi7xwyV+uMQPl/jhEj9c4odL/HCJHy7xwyU8XMLDJTxc4odL/HCJHy7xw6WT506e+3Gv6ce9ph/3mvBwiR8u8cMlfrjED5f44RI/XOKHS/xwiR8u4eESHi7h4RI/XOKHS/xwiR8unTx38tyPe00/7jX9uNeEh0v8cIkfLvHDJX64xA+X+OESP1zih0v8cAkPl/BwCQ+X+OESP1zih0v8cOnkuZPnftxr+nGv6ce9Jjxc4odL/HCJHy7xwyV+uMQPl/jhEj9c4odLeLiEh0t4uMQPl/jhEj9c4odLJ8+dPPfjXtOPe00/7jXh4RI/XOKHS/xwiR8u8cMlfrjED5f44RI/XMLDJTxcwsMlfrjED5f44RI/XDp5HuR5HPeacdxrxnGvCQ+X+OESP1zih0v8cIkfLvHDJX64xA+X+OESHi7h4RIeLvHDJX64xA+X+OEyyPMgz+O414zjXjOOe014uMQPl/jhEj9c4odL/HCJHy7xwyV+uMQPl/BwCQ+X8HCJHy7xwyV+uMQPl0GeB3kex71mHPeacdxrwsMlfrjED5f44RI/XOKHS/xwiR8u8cMlfriEh0t4uISHS/xwiR8u8cMlfrgM8jzI8zjuNeO414zjXhMeLvHDJX64xA+X+OESP1zih0v8cIkfLvHDJTxcwsMlPFzih0v8cIkfLvHDZZDnQZ7Hca8Zx71mHPea8HCJHy7xwyV+uMQPl/jhEj9c4odL/HCJHy7h4RIeLuHhEj9c4odL/HCJHy6TPE/yPI97zTzuNfO414SHS/xwiR8u8cMlfrjED5f44RI/XOKHS/xwCQ+X8HAJD5f44RI/XOKHS/xwmeR5kud53Gvmca+Zx70mPFzih0v8cIkfLvHDJX64xA+X+OESP1zih0t4uISHS3i4xA+X+OESP1zih8skz5M8z+NeM497zTzuNeHhEj9c4odL/HCJHy7xwyV+uMQPl/jhEj9cwsMlPFzCwyV+uMQPl/jhEj9cJnme5Hke95p53Gvmca8JD5f44RI/XOKHS/xwiR8u8cMlfrjED5f44RIeLuHhEh4u8cMlfrjED5f44TLJ8yTP87jXrONes457TXi4xA+X+OESP1zih0v8cIkfLvHDJX64xA+X8HAJD5fwcIkfLvHDJX64xA+XRZ4XeV7HvWYd95p13GvCwyV+uMQPl/jhEj9c4odL/HCJHy7xwyV+uISHS3i4hIdL/HCJHy7xwyV+uCzyvMjzOu4167jXrONeEx4u8cMlfrjED5f44RI/XOKHS/xwiR8u8cMlPFzCwyU8XOKHS/xwiR8u8cNlkedFntdxr1nHvWYd95rwcIkfLvHDJX64xA+X+OESP1zih0v8cIkfLuHhEh4u4eESP1zih0v8cIkfLos8L/K8jnvNOu4167jXhIdL/HCJHy7xwyV+uMQPl/jhEj9c4odL/HAJD5fwcAkPl/jhEj9c4odL/HDZ5HmT533ca/Zxr9nHvSY8XOKHS/xwiR8u8cMlfrjED5f44RI/XOKHS3i4hIdLeLjED5f44RI/XOKHyybPmzzv416zj3vNPu414eESP1zih0v8cIkfLvHDJX64xA+X+OESP1zCwyU8XMLDJX64xA+X+OESP1w2ed7keR/3mn3ca/ZxrwkPl/jhEj9c4odL/HCJHy7xwyV+uMQPl/jhEh4u4eESHi7xwyV+uMQPl/jhssnzJs/7uNfs416zj3tNeLjED5f44RI/XOKHS/xwiR8u8cMlfrjED5fwcAkPl/BwiR8u8cMlfrjED5dNnjd53se9Zh/3mn3ca8LDJX64xA+X+OESP1zih0v8cIkfLvHDJX64hIdLeLiEh0v8cIkfLvHDJX64HPJ8yPM57jXnuNec414THi7xwyV+uMQPl/jhEj9c4odL/HCJHy7xwyU8XMLDJTxc4odL/HCJHy7xw+WQ50Oez3GvOce95hz3mvBwiR8u8cMlfrjED5f44RI/XOKHS/xwiR8u4eESHi7h4RI/XOKHS/xwiR8uhzwf8nyOe8057jXnuNeEh0v8cIkfLvHDJX64xA+X+OESP1zih0v8cAkPl/BwCQ+X+OESP1zih0v8cDnk+ZDnc9xrznGvOce9Jjxc4odL/HCJHy7xwyV+uMQPl/jhEj9c4odLeLiEh0t4uMQPl/jhEj9c4ofLJc+XPN/jXnOPe8097jXh4RI/XOKHS/xwiR8u8cMlfrjED5f44RI/XMLDJTxcwsMlfrjED5f44RI/XC55vuT5Hveae9xr7nGvCQ+X+OESP1zih0v8cIkfLvHDJX64xA+X+OESHi7h4RIeLvHDJX64xA+X+OFyyfMlz/e419zjXnOPe014uMQPl/jhEj9c4odL/HCJHy7xwyV+uMQPl/BwCQ+X8HCJHy7xwyV+uMQPl0ueL3m+x73mHveae9xrwsMlfrjED5f44RI/XOKHS/xwiR8u8cMlfriEh0t4uISHS/xwiR8u8cMlfrhc8nzJ8z3uNfe419zjXhMeLvHDFX64wg9X+OEKP1zhhyv8cIUfrvDDFTxcwcMVPFzhhyv8cIUfrvDD1efyvD6X5/U57rU+x73W57jXgocr/HCFH67wwxV+uMIPV/jhCj9c4Ycr/HAFD1fwcAUPV/jhCj9c4Ycr/HD1uTyvz+V5fY57rc9xr/U57rXg4Qo/XOGHK/xwhR+u8MMVfrjCD1f44Qo/XMHDFTxcwcMVfrjCD1f44Qo/XH0uz+tzeV6f417rc9xrfY57LXi4wg9X+OEKP1zhhyv8cIUfrvDDFX64wg9X8HAFD1fwcIUfrvDDFX64wg9Xn+GzO3x2j3utz3Gv9TnuteDhCj9c4Ycr/HCFH67wwxV+uMIPV/jhCj9cwcMVPFzBwxV+uMIPV/jhCj9cvcvzepfn9Y57rXfca73jXgservDDFX64wg9X+OEKP1zhhyv8cIUfrvDDFTxcwcMVPFzhhyv8cIUfrvDD1bs8r3d5Xu+413rHvdY77rXg4Qo/XOGHK/xwhR+u8MMVfrjCD1f44Qo/XMHDFTxcwcMVfrjCD1f44Qo/XL3L83qX5/WOe6133Gu9414LHq7wwxV+uMIPV/jhCj9c4Ycr/HCFH67wwxU8XMHDFTxc4Ycr/HCFH67ww9UrPrvNZ/e413rHvdY77rXg4Qo/XOGHK/xwhR+u8MMVfrjCD1f44Qo/XMHDFTxcwcMVfrjCD1f44Qo/XL3ls7t8do97rXfca73jXgservDDFX64wg9X+OEKP1zhhyv8cIUfrvDDFTxcwcMVPFzhhyv8cIUfrvDDlZHnRp7bca9lx72WHfda8HCFH67wwxV+uMIPV/jhCj9c4Ycr/HCFH67g4QoeruDhCj9c4Ycr/HCFH66MPDfy3I57LTvutey414KHK/xwhR+u8MMVfrjCD1f44Qo/XOGHK/xwBQ9X8HAFD1f44Qo/XOGHK/xwZeS5ked23GvZca9lx70WPFzhhyv8cIUfrvDDFX64wg9X+OEKP1zhhyt4uIKHK3i4wg9X+OEKP1zhhysjz408t+Ney457LTvuteDhCj9c4Ycr/HCFH67wwxV+uMIPV/jhCj9cwcMVPFzBwxV+uMIPV/jhCj9cOXnu5Lkf91p+3Gv5ca8FD1f44Qo/XOGHK/xwhR+u8MMVfrjCD1f44QoeruDhCh6u8MMVfrjCD1f44crJcyfP/bjX8uNey497LXi4wg9X+OEKP1zhhyv8cIUfrvDDFX64wg9X8HAFD1fwcIUfrvDDFX64wg9XTp47ee7HvZYf91p+3GvBwxV+uMIPV/jhCj9c4Ycr/HCFH67wwxV+uIKHK3i4gocr/HCFH67wwxV+uHLy3MlzP+61/LjX8uNeCx6u8MMVfrjCD1f44Qo/XOGHK/xwhR+u8MMVPFzBwxU8XOGHK/xwhR+u8MOVk+dOnvtxr+XHvZYf91rwcIUfrvDDFX64wg9X+OEKP1zhhyv8cIUfruDhCh6u4OEKP1zhhyv8cIUfroI8D/I8jnutOO614rjXgocr/HCFH67wwxV+uMIPV/jhCj9c4Ycr/HAFD1fwcAUPV/jhCj9c4Ycr/HAV5HmQ53Hca8VxrxXHvRY8XOGHK/xwhR+u8MMVfrjCD1f44Qo/XOGHK3i4gocreLjCD1f44Qo/XOGHqyDPgzyP414rjnutOO614OEKP1zhhyv8cIUfrvDDFX64wg9X+OEKP1zBwxU8XMHDFX64wg9X+OEKP1wFeR7keRz3WnHca8VxrwUPV/jhCj9c4Ycr/HCFH67wwxV+uMIPV/jhCh6u4OEKHq7wwxV+uMIPV/jhKsjzJM/zuNfK414rj3steLjCD1f44Qo/XOGHK/xwhR+u8MMVfrjCD1fwcAUPV/BwhR+u8MMVfrjCD1dJnid5nse9Vh73Wnnca8HDFX64wg9X+OEKP1zhhyv8cIUfrvDDFX64gocreLiChyv8cIUfrvDDFX64SvI8yfM87rXyuNfK414LHq7wwxV+uMIPV/jhCj9c4Ycr/HCFH67wwxU8XMHDFTxc4Ycr/HCFH67ww1WS50me53Gvlce9Vh73WvBwhR+u8MMVfrjCD1f44Qo/XOGHK/xwhR+u4OEKHq7g4Qo/XOGHK/xwhR+ukjxP8jyPe6087rXyuNeChyv8cH+5Yg7yHD9c4Ycr/HCFH67wwxV+uIKHK3i4gocr/HCFH67wwxV+uCryvMjzOu616rjXquNeCx6u8MMVfrjCD1f44Qo/XOGHK/xwhR+u8MMVPFzBwxU8XOGHK/xwhR+u8MNVkedFntdxr1XHvVYd91rwcIUfrvDDFX64wg9X+OEKP1zhhyv8cIUfruDhCh6u4OEKP1zhhyv8cIUfroo8L/K8jnutOu616rjXgocr/HCFH67wwxV+uMIPV/jhCj9c4Ycr/HAFD1fwcAUPV/jhCj9c4Ycr/HBV5HmR53Xca9Vxr1XHvRY8XOGHK/xwhR+u8MMVfrjCD1f44Qo/XOGHK3i4gocreLjCD1f44Qo/XOGHqyLPizyv416rj3utPu614OEKP1zhhyv8cIUfrvDDFX64wg9X+OEKP1zBwxU8XMHDFX64wg9X+OEKP1w1ed7keR/3Wn3ca/VxrwUPV/jhCj9c4Ycr/HCFH67wwxV+uMIPV/jhCh6u4OEKHq7wwxV+uMIPV/jhqsnzJs/7uNfq416rj3steLjCD1f44Qo/XOGHK/xwhR+u8MMVfrjCD1fwcAUPV/BwhR+u8MMVfrjCD1dNnjd53se9Vh/3Wn3ca8HDFX64wg9X+OEKP1zhhyv8cIUfrvDDFX64gocreLiChyv8cIUfrvDDFX64avK8yfM+7rX6uNfq414LHq7wwxV+uMIPV/jhCj9c4Ycr/HCFH67wwxU8XMHDFTxc4Ycr/HCFH67ww9WQ50Oez3GvNce91hz3WvBwhR+u8MMVfrjCD1f44Qo/XOGHK/xwhR+u4OEKHq7g4Qo/XOGHK/xwhR+uhjwf8nyOe6057rXmuNeChyv8cIUfrvDDFX64wg9X+OEKP1zhhyv8cAUPV/BwBQ9X+OEKP1zhhyv8cDXk+ZDnc9xrzXGvNce9Fjxc4Ycr/HCFH67wwxV+uMIPV/jhCj9c4YcreLiChyt4uMIPV/jhCj9c4YerIc+HPJ/jXmuOe6057rXg4Qo/XOGHK/xwhR+u8MMVfrjCD1f44Qo/XMHDFTxcwcMVfrjCD1f44Qo/XA15PuT5HPdac9xrzXGvBQ9X+OEKP1zhhyv8cIUfrvDDFX64wg9X+OEKHq7g4QoervDDFX64wg9X+OFqyfMlz/e419rjXmuPey14uMIPV/jhCj9c4Ycr/HCFH67wwxV+uMIPV/BwBQ9X8HCFH67wwxV+uMIPV0ueL3m+x73WHvdae9xrwcMVfrjCD1f44Qo/XOGHK/xwhR+u8MMVfriChyt4uIKHK/xwhR+u8MMVfrha8nzJ8z3utfa419rjXgservDDFX64wg9X+OEKP1zhhyv8cIUfrvDDFTxcwcMVPFzhhyv8cIUfrvDD1ZLnS57vca+1x73WHvda8HCFH67wwxV+uMIPV/jhCj9c4Ycr/HCFH67g4QoeruHhGj9c44dr/HCNH64/l+f9uTzvz3Gv/TnutT/HvTY8XOOHa/xwjR+u8cM1frjGD9f44Ro/XOOHa3i4hodreLjGD9f44Ro/XOOH68/leX8uz/tz3Gt/jnvtz3GvDQ/X+OEaP1zjh2v8cI0frvHDNX64xg/X+OEaHq7h4RoervHDNX64xg/X+OH6c3nen8vz/hz32p/jXvtz3GvDwzV+uMYP1/jhGj9c44dr/HCNH67xwzV+uIaHa3i4hodr/HCNH67xwzV+uP40n93ms3vca3+Oe+3Pca8ND9f44Ro/XOOHa/xwjR+u8cM1frjGD9f44RoeruHhGh6u8cM1frjGD9f44fqzfHaXz+5xr/057rU/x702PFzjh2v8cI0frvHDNX64xg/X+OEaP1zjh2t4uIaHa3i4xg/X+OEaP1zjh+t3ed7v8rzfca/9jnvtd9xrw8M1frjGD9f44Ro/XOOHa/xwjR+u8cM1friGh2t4uIaHa/xwjR+u8cM1frh+l+f9Ls/7Hffa77jXfse9Njxc44dr/HCNH67xwzV+uMYP1/jhGj9c44dreLiGh2t4uMYP1/jhGj9c44frd3ne7/K833Gv/Y577Xfca8PDNX64xg/X+OEaP1zjh2v8cI0frvHDNX64hodreLiGh2v8cI0frvHDNX64fsNnd/jsHvfa77jXfse9Njxc44dr/HCNH67xwzV+uMYP1/jhGj9c44dreLiGh2t4uMYP1/jhGj9c44drI8+NPLfjXtuOe2077rXh4Ro/XOOHa/xwjR+u8cM1frjGD9f44Ro/XMPDNTxcw8M1frjGD9f44Ro/XBt5buS5Hffadtxr23GvDQ/X+OEaP1zjh2v8cI0frvHDNX64xg/X+OEaHq7h4RoervHDNX64xg/X+OHayHMjz+2417bjXtuOe214uMYP1/jhGj9c44dr/HCNH67xwzV+uMYP1/BwDQ/X8HCNH67xwzV+uMYP10aeG3lux722Hffadtxrw8M1frjGD9f44Ro/XOOHa/xwjR+u8cM1friGh2t4uIaHa/xwjR+u8cM1frg28tzIczvute2417bjXhservHDNX64xg/X+OEaP1zjh2v8cI0frvHDNTxcw8M1PFzjh2v8cI0frvHDtZPnTp77ca/tx722H/fa8HCNH67xwzV+uMYP1/jhGj9c44dr/HCNH67h4RoeruHhGj9c44dr/HCNH66dPHfy3I97bT/utf2414aHa/xwjR+u8cM1frjGD9f44Ro/XOOHa/xwDQ/X8HAND9f44Ro/XOOHa/xw7eS5k+d+3Gv7ca/tx702PFzjh2v8cI0frvHDNX64xg/X+OEaP1zjh2t4uIaHa3i4xg/X+OEaP1zjh2snz5089+Ne2497bT/uteHhGj9c44dr/HCNH67xwzV+uMYP1/jhGj9cw8M1PFzDwzV+uMYP1/jhGj9cB3ke5Hkc99px3GvHca8ND9f44Ro/XOOHa/xwjR+u8cM1frjGD9f44RoeruHhGh6u8cM1frjGD9f44TrI8yDP47jXjuNeO457bXi4xg/X+OEaP1zjh2v8cI0frvHDNX64xg/X8HAND9fwcI0frvHDNX64xg/XQZ4HeR7HvXYc99px3GvDwzV+uMYP1/jhGj9c44dr/HCNH67xwzV+uIaHa3i4hodr/HCNH67xwzV+uA7yPMjzOO6147jXjuNeGx6u8cM1frjGD9f44Ro/XOOHa/xwjR+u8cM1PFzDwzU8XOOHa/xwjR+u8cN1kOdBnsdxrx3HvXYc99rwcI0frvHDNX64xg/X+OEaP1zjh2v8cI0fruHhGh6u4eEaP1zjh2v8cI0frpM8T/I8j3vtPO6187jXhodr/HCNH67xwzV+uMYP1/jhGj9c44dr/HAND9fwcA0P1/jhGj9c44dr/HCd5HmS53nca+dxr53HvTY8XOOHa/xwjR+u8cM1frjGD9f44Ro/XOOHa3i4hodreLjGD9f44Ro/XOOH6yTPkzzP4147j3vtPO614eEaP1zjh2v8cI0frvHDNX64xg/X+OEaP1zDwzU8XMPDNX64xg/X+OEaP1wneZ7keR732nnca+dxrw0P1/jhGj9c44dr/HCNH67xwzV+uMYP1/jhGh6u4eEaHq7xwzV+uMYP1/jhOsnzIs/ruNeu4167jntteLjGD9f44Ro/XOOHa/xwjR+u8cM1frjGD9fwcA0P1/BwjR+u8cM1frjGD9dFnhd5Xse9dh332nXca8PDNX64xg/X+OEaP1zjh2v8cI0frvHDNX64hodreLiGh2v8cI0frvHDNX64LvK8yPM67rXruNeu414bHq7xwzV+uMYP1/jhGj9c44dr/HCNH67xwzU8XMPDNTxc44dr/HCNH67xw3WR50We13GvXce9dh332vBwjR+u8cM1frjGD9f44Ro/XOOHa/xwjR+u4eEaHq7h4Ro/XOOHa/xwjR+uizwv8ryOe+067rXruNeGh2v8cI0frvHDNX64xg/X+OEaP1zjh2v8cA0P1/BwDQ/X+OEaP1zjh2v8cN3keZPnfdxr93Gv3ce9Njxc44dr/HCNH67xwzV+uMYP1/jhGj9c44dreLiGh2t4uMYP1/jhGj9c44frJs+bPO/jXruPe+0+7rXh4Ro/XOOHa/xwjR+u8cM1frjGD9f44Ro/XMPDNTxcw8M1frjGD9f44Ro/XDd53uR5H/fafdxr93GvDQ/X+OEaP1zjh2v8cI0frvHDNX64xg/X+OEaHq7h4RoervHDNX64xg/X+OG6yfMmz/u41+7jXruPe214uMYP1/jhGj9c44dr/HCNH67xwzV+uMYP1/BwDQ/X8HCNH67xwzV+uMYP102eN3nex732HPfac9xrw8M1frjGD9f44Ro/XOOHa/xwjR+u8cM1friGh2t4uIaHa/xwjR+u8cM1frge8nzI8znutee4157jXhservHDNX64xg/X+OEaP1zjh2v8cI0frvHDNTxcw8M1PFzjh2v8cI0frvHD9ZDnQ57Pca89x732HPfa8HCNH67xwzV+uMYP1/jhGj9c44dr/HCNH67h4RoeruHhGj9c44dr/HCNH66HPB/yfI577Tnutee414aHa/xwjR+u8cM1frjGD9f44Ro/XOOHa/xwDQ/X8HAND9f44Ro/XOOHa/xwPeT5kOdz3GvPca89x702PFzjh2v8cI0frvHDNX64xg/X+OEaP1zjh2t4uIaHa3i4xg/X+OEaP1zjh+slz5c83+Nee4977T3uteHhGj9c44dr/HCNH67xwzV+uMYP1/jhGj9cw8M1PFzDwzV+uMYP1/jhGj9cL3m+5Pke99p73Gvvca8ND9f44Ro/XOOHa/xwjR+u8cM1frjGD9f44RoeruHhGh6u8cM1frjGD9f44XrJ8yXP97jX3uNee497bXi4xg/X+OEaP1zjh2v8cI0frvHDNX64xg/X8HAND9fwcI0frvHDNX64xg/XS54veb7HvfYe99p73GvDwzV+uMYP1/jhGj9c44dr/HCNH67xwzV+uIaHa3i4hodr/HCNH67xwzV+uF7yfMnzPe6197jX3uNeBx5u8MMNfrjBDzf44QY/3OCHG/xwgx9u8MMNPNzAww083OCHG/xwgx9u8MPN5/J8Ppfn8znudT7Hvc7nuNeBhxv8cIMfbvDDDX64wQ83+OEGP9zghxv8cAMPN/BwAw83+OEGP9zghxv8cPO5PJ/P5fl8jnudz3Gv8znudeDhBj/c4Icb/HCDH27www1+uMEPN/jhBj/cwMMNPNzAww1+uMEPN/jhBj/cfC7P53N5Pp/jXudz3Ot8jnsdeLjBDzf44QY/3OCHG/xwgx9u8MMNfrjBDzfwcAMPN/Bwgx9u8MMNfrjBDzef4bM7fHaPe53Pca/zOe514OEGP9zghxv8cIMfbvDDDX64wQ83+OEGP9zAww083MDDDX64wQ83+OEGP9y8y/N5l+fzjnudd9zrvONeBx5u8MMNfrjBDzf44QY/3OCHG/xwgx9u8MMNPNzAww083OCHG/xwgx9u8MPNuzyfd3k+77jXece9zjvudeDhBj/c4Icb/HCDH27www1+uMEPN/jhBj/cwMMNPNzAww1+uMEPN/jhBj/cvMvzeZfn8457nXfc67zjXgcebvDDDX64wQ83+OEGP9zghxv8cIMfbvDDDTzcwMMNPNzghxv8cIMfbvDDzWs+u81n97jXece9zjvudeDhBj/c4Icb/HCDH27www1+uMEPN/jhBj/cwMMNPNzAww1+uMEPN/jhBj/cvOWzu3x2j3udd9zrvONeBx5u8MMNfrjBDzf44QY/3OCHG/xwgx9u8MMNPNzAww083OCHG/xwgx9u8MONkedGnttxr2PHvY4d9zrwcIMfbvDDDX64wQ83+OEGP9zghxv8cIMfbuDhBh5u4OEGP9zghxv8cIMfbow8N/LcjnsdO+517LjXgYcb/HCDH27www1+uMEPN/jhBj/c4Icb/HADDzfwcAMPN/jhBj/c4Icb/HBj5LmR53bc69hxr2PHvQ483OCHG/xwgx9u8MMNfrjBDzf44QY/3OCHG3i4gYcbeLjBDzf44QY/3OCHGyPPjTy3417HjnsdO+514OEGP9zghxv8cIMfbvDDDX64wQ83+OEGP9zAww083MDDDX64wQ83+OEGP9w4ee7kuR/3On7c6/hxrwMPN/jhBj/c4Icb/HCDH27www1+uMEPN/jhBh5u4OEGHm7www1+uMEPN/jhxslzJ8/9uNfx417Hj3sdeLjBDzf44QY/3OCHG/xwgx9u8MMNfrjBDzfwcAMPN/Bwgx9u8MMNfrjBDzdOnjt57se9jh/3On7c68DDDX64wQ83+OEGP9zghxv8cIMfbvDDDX64gYcbeLiBhxv8cIMfbvDDDX64cfLcyXM/7nX8uNfx414HHm7www1+uMEPN/jhBj/c4Icb/HCDH27www083MDDDTzc4Icb/HCDH27ww42T506e+3Gv48e9jh/3OvBwgx9u8MMNfrjBDzf44QY/3OCHG/xwgx9u4OEGHm7g4QY/3OCHG/xwgx9ugjwP8jyOe5047nXiuNeBhxv8cIMfbvDDDX64wQ83+OEGP9zghxv8cAMPN/BwAw83+OEGP9zghxv8cBPkeZDncdzrxHGvE8e9Djzc4Icb/HCDH27www1+uMEPN/jhBj/c4IcbeLiBhxt4uMEPN/jhBj/c4IebIM+DPI/jXieOe5047nXg4QY/3OCHG/xwgx9u8MMNfrjBDzf44QY/3MDDDTzcwMMNfrjBDzf44QY/3AR5HuR5HPc6cdzrxHGvAw83+OEGP9zghxv8cIMfbvDDDX64wQ83+OEGHm7g4QYebvDDDX64wQ83+OEmyfMkz/O418njXiePex14uMEPN/jhBj/c4Icb/HCDH27www1+uMEPN/BwAw838HCDH27www1+uMEPN0meJ3mex71OHvc6edzrwMMNfrjBDzf44QY/3OCHG/xwgx9u8MMNfriBhxt4uIGHG/xwgx9u8MMNfrhJ8jzJ8zzudfK418njXgcebvDDDX64wQ83+OEGP9zghxv8cIMfbvDDDTzcwMMNPNzghxv8cIMfbvDDTZLnSZ7nca+Tx71OHvc68HCDH27www1+uMEPN/jhBj/c4Icb/HCDH27g4QYebuDhBj/c4Icb/HCDH26SPE/yPI97nTzudfK414GHG/xwgx9u8MMNfrjBDzf44QY/3OCHG/xwAw838HADDzf44QY/3OCHG/xwU+R5ked13OvUca9Tx70OPNzghxv8cIMfbvDDDX64wQ83+OEGP9zghxt4uIGHG3i4wQ83+OEGP9zgh5siz4s8r+Nep457nTrudeDhBj/c4Icb/HCDH27www1+uMEPN/jhBj/cwMMNPNzAww1+uMEPN/jhBj/cFHle5Hkd9zp13OvUca8DDzf44QY/3OCHG/xwgx9u8MMNfrjBDzf44QYebuDhBh5u8MMNfrjBDzf44abI8yLP67jXqeNep457HXi4wQ83+OEGP9zghxv8cIMfbvDDDX64wQ838HADDzfwcIMfbvDDDX64wQ83RZ43ed7HvU4f9zp93OvAww1+uMEPN/jhBj/c4Icb/HCDH27www1+uIGHG3i4gYcb/HCDH27www1+uGnyvMnzPu51+rjX6eNeBx5u8MMNfrjBDzf44QY/3OCHG/xwgx9u8MMNPNzAww083OCHG/xwgx9u8MNNk+dNnvdxr9PHvU4f9zrwcIMfbvDDDX64wQ83+OEGP9zghxv8cIMfbuDhBh5u4OEGP9zghxv8cIMfbpo8b/K8j3udPu51+rjXgYcb/HCDH27www1+uMEPN/jhBj/c4Icb/HADDzfwcAMPN/jhBj/c4Icb/HDT5HmT533c6/Rxr9PHvQ483OCHG/xwgx9u8MMNfrjBDzf44QY/3OCHG3i4gYcbeLjBDzf44QY/3OCHmyHPhzyf415njnudOe514OEGP9zghxv8cIMfbvDDDX64wQ83+OEGP9zAww083MDDDX64wQ83+OEGP9wMeT7k+Rz3OnPc68xxrwMPN/jhBj/c4Icb/HCDH27www1+uMEPN/jhBh5u4OEGHm7www1+uMEPN/jhZsjzIc/nuNeZ415njnsdeLjBDzf44QY/3OCHG/xwgx9u8MMNfrjBDzfwcAMPN/Bwgx9u8MMNfrjBDzdDng95Pse9zhz3OnPc68DDDX64wQ83+OEGP9zghxv8cIMfbvDDDX64gYcbeLiBhxv8cIMfbvDDDX64GfJ8yPM57nX2uNfZ414HHm7www1+uMEPN/jhBj/c4Icb/HCDH27www083MDDDTzc4Icb/HCDH27ww82S50ue73Gvs8e9zh73OvBwgx9u8MMNfrjBDzf44QY/3OCHG/xwgx9u4OEGHm7g4QY/3OCHG/xwgx9uljxf8nyPe5097nX2uNeBhxv8cIMfbvDDDX64wQ83+OEGP9zghxv8cAMPN/BwAw83+OEGP9zghxv8cLPk+ZLne9zr7HGvs8e9Djzc4Icb/HCDH27www1+uMEPN/jhBj/c4IcbeLiBhxt4uMEPN/jhBj/c4IebJc+XPN/jXmePe5097nXg4QY/3OCHG/xwgx9u8MMNfrjBDzf44QY/3MLDLTzcwsMtfrjFD7f44RY/3H4uz/dzeb6f4173c9zrfo57XXi4xQ+3+OEWP9zih1v8cIsfbvHDLX64xQ+38HALD7fwcIsfbvHDLX64xQ+3n8vz/Vye7+e41/0c97qf414XHm7xwy1+uMUPt/jhFj/c4odb/HCLH27xwy083MLDLTzc4odb/HCLH27xw+3n8nw/l+f7Oe51P8e97ue414WHW/xwix9u8cMtfrjFD7f44RY/3OKHW/xwCw+38HALD7f44RY/3OKHW/xw+2k+u81n97jX/Rz3up/jXhcebvHDLX64xQ+3+OEWP9zih1v8cIsfbvHDLTzcwsMtPNzih1v8cIsfbvHD7Wf57C6f3eNe93Pc636Oe114uMUPt/jhFj/c4odb/HCLH27xwy1+uMUPt/BwCw+38HCLH27xwy1+uMUPt+/yfN/l+b7jXvcd97rvuNeFh1v8cIsfbvHDLX64xQ+3+OEWP9zih1v8cAsPt/BwCw+3+OEWP9zih1v8cPsuz/ddnu877nXfca/7jntdeLjFD7f44RY/3OKHW/xwix9u8cMtfrjFD7fwcAsPt/Bwix9u8cMtfrjFD7fv8nzf5fm+4173Hfe677jXhYdb/HCLH27xwy1+uMUPt/jhFj/c4odb/HALD7fwcAsPt/jhFj/c4odb/HD7hs/u8Nk97nXfca/7jntdeLjFD7f44RY/3OKHW/xwix9u8cMtfrjFD7fwcAsPt/Bwix9u8cMtfrjFD7dGnht5bse9rh33unbc68LDLX64xQ+3+OEWP9zih1v8cIsfbvHDLX64hYdbeLiFh1v8cIsfbvHDLX64NfLcyHM77nXtuNe1414XHm7xwy1+uMUPt/jhFj/c4odb/HCLH27xwy083MLDLTzc4odb/HCLH27xw62R50ae23Gva8e9rh33uvBwix9u8cMtfrjFD7f44RY/3OKHW/xwix9u4eEWHm7h4RY/3OKHW/xwix9ujTw38tyOe1077nXtuNeFh1v8cIsfbvHDLX64xQ+3+OEWP9zih1v8cAsPt/BwCw+3+OEWP9zih1v8cGvkuZHndtzr2nGva8e9Ljzc4odb/HCLH27xwy1+uMUPt/jhFj/c4odbeLiFh1t4uMUPt/jhFj/c4odbJ8+dPPfjXtePe10/7nXh4RY/3OKHW/xwix9u8cMtfrjFD7f44RY/3MLDLTzcwsMtfrjFD7f44RY/3Dp57uS5H/e6ftzr+nGvCw+3+OEWP9zih1v8cIsfbvHDLX64xQ+3+OEWHm7h4RYebvHDLX64xQ+3+OHWyXMnz/241/XjXtePe114uMUPt/jhFj/c4odb/HCLH27xwy1+uMUPt/BwCw+38HCLH27xwy1+uMUPt06eO3nux72uH/e6ftzrwsMtfrjFD7f44RY/3OKHW/xwix9u8cMtfriFh1t4uIWHW/xwix9u8cMtfrgN8jzI8zjudeO4143jXhcebvHDLX64xQ+3+OEWP9zih1v8cIsfbvHDLTzcwsMtPNzih1v8cIsfbvHDbZDnQZ7Hca8bx71uHPe68HCLH27xwy1+uMUPt/jhFj/c4odb/HCLH27h4RYebuHhFj/c4odb/HCLH26DPA/yPI573TjudeO414WHW/xwix9u8cMtfrjFD7f44RY/3OKHW/xwCw+38HALD7f44RY/3OKHW/xwG+R5kOdx3OvGca8bx70uPNzih1v8cIsfbvHDLX64xQ+3+OEWP9zih1t4uIWHW3i4xQ+3+OEWP9zih9sgz4M8j+NeN4573TjudeHhFj/c4odb/HCLH27xwy1+uMUPt/jhFj/cwsMtPNzCwy1+uMUPt/jhFj/cJnme5Hke97p53Ovmca8LD7f44RY/3OKHW/xwix9u8cMtfrjFD7f44RYebuHhFh5u8cMtfrjFD7f44TbJ8yTP87jXzeNeN497XXi4xQ+3+OEWP9zih1v8cIsfbvHDLX64xQ+38HALD7fwcIsfbvHDLX64xQ+3SZ4neZ7HvW4e97p53OvCwy1+uMUPt/jhFj/c4odb/HCLH27xwy1+uIWHW3i4hYdb/HCLH27xwy1+uE3yPMnzPO5187jXzeNeFx5u8cMtfrjFD7f44RY/3OKHW/xwix9u8cMtPNzCwy083OKHW/xwix9u8cNtkedFntdxr1vHvW4d97rwcIsfbvHDLX64xQ+3+OEWP9zih1v8cIsfbuHhFh5u4eEWP9zih1v8cIsfbos8L/K8jnvdOu5167jXhYdb/HCLH27xwy1+uMUPt/jhFj/c4odb/HALD7fwcAsPt/jhFj/c4odb/HBb5HmR53Xc69Zxr1vHvS483OKHW/xwix9u8cMtfrjFD7f44RY/3OKHW3i4hYdbeLjFD7f44RY/3OKH2yLPizyv4163jnvdOu514eEWP9zih1v8cIsfbvHDLX64xQ+3+OEWP9zCwy083MLDLX64xQ+3+OEWP9wWeV7keR33unXc69ZxrwsPt/jhFj/c4odb/HCLH27xwy1+uMUPt/jhFh5u4eEWHm7xwy1+uMUPt/jhtsnzJs/7uNft4163j3tdeLjFD7f44RY/3OKHW/xwix9u8cMtfrjFD7fwcAsPt/Bwix9u8cMtfrjFD7dNnjd53se9bh/3un3c68LDLX64xQ+3+OEWP9zih1v8cIsfbvHDLX64hYdbeLiFh1v8cIsfbvHDLX64bfK8yfM+7nX7uNft414XHm7xwy1+uMUPt/jhFj/c4odb/HCLH27xwy083MLDLTzc4odb/HCLH27xw22T502e93Gv28e9bh/3uvBwix9u8cMtfrjFD7f44RY/3OKHW/xwix9u4eEWHm7h4RY/3OKHW/xwix9umzwf8nyOe9057nXnuNeFh1v8cIsfbvHDLX64xQ+3+OEWP9zih1v8cAsPt/BwCw+3+OEWP9zih1v8cDvk+ZDnc9zrznGvO8e9Ljzc4odb/HCLH27xwy1+uMUPt/jhFj/c4odbeLiFh1t4uMUPt/jhFj/c4ofbIc+HPJ/jXneOe9057nXh4RY/3OKHW/xwix9u8cMtfrjFD7f44RY/3MLDLTzcwsMtfrjFD7f44RY/3A55PuT5HPe6c9zrznGvCw+3+OEWP9zih1v8cIsfbvHDLX64xQ+3+OEWHm7h4RYebvHDLX64xQ+3+OF2yPMhz+e4153jXneOe114uMUPt/jhFj/c4odb/HCLH27xwy1+uMUPt/BwCw+38HCLH27xwy1+uMUPt0ueL3m+x73uHve6e9zrwsMtfrjFD7f44RY/3OKHW/xwix9u8cMtfriFh1t4uIWHW/xwix9u8cMtfrhd8nzJ8z3udfe4193jXhcebvHDLX64xQ+3+OEWP9zih1v8cIsfbvHDLTzcwsMtPNzih1v8cIsfbvHD7ZLnS57vca+7x73uHve68HCLH27xwy1+uMUPt/jhFj/c4odb/HCLH27h4RYebuHhFj/c4odb/HCLH26XPF/yfI973T3udfe414WHW/xwix9u8cMtfrjFD7f44RY/3OKHW/xwCw+38HALD7f44RY/3OKHW/xwu+T5kud73Ov7fA58/XP5e5r8ufx9zJ9L12XoMnVZumxdji6Xy4v2P5dPl3ra09Oennbv2f5cli5bl6PL5fJC/s/lY+LDYf9cOhObnmaazTSbaTbTbKbZXLO5ZnPN5prN9TTX01xPc83mms01W2i2S/4/l6ZLZ+KDZP9cJhOHnhaaLTRbaLbUbKnZUrOlZkvNlpot9bTU01JPS81Wmq00W2m26wN/LkOXycSHzv65bCYuPa00W2u21myt2VqztWZrzdaarTVb62mtp42eNpptNNtottFsow0YbcDxtH8uh4mPqP3L5eppq9lWs61mW822mm0122q21WzLbEB3fy6fLk2XzIaI7s9l6rJ02bocXXJyvcfJ9R4n19NZ8nSWPJ0lOOn+XJYuW5ejS81mms00m+lppqfpLMFO9+dSs5lmM81mbMDzjy45uZ5zcj3n5Ho6S57OkqezBFPdn0vN5potNFtottBsodlCTws9TWcJzro/l5otNFtqtny6NF1ycr3k5HrJyfV0ljydJU9nCf66v1yWZivNVpqtNFtpttJspaeVnqazBJPdXy5bs7Vma83W2oDWBjQn12tOrtecXE9nydNZ8nSWYLX7c6nZRrONZhvNNpptNNvoaaOn6SzBb/fnUrOtZlvNttqA1QYsJ9dbTq63nFyms8R0lpjOElMvMfUSUy8x9RJTLzH1ElMvMfUSUy8xnSVY7/5chi5Tl6XL1uXokpPLjJPLjJPLdJaYzhLTWWLqJaZeYuolpl5i6iWmXmLqJaZeYuolprMEF96fS82mXmLqJaZeYuolFpxcFpxcFpxcprPEdJaYzhJTLzH1ElMvMfUSUy8x9RJTLzH1ElMvMZ0lGPL+XGo29RJTLzH1ElMvseLksuLksuLkMp0lprPEdJaYeompl5h6iamXmHqJqZeYeompl5h6iekswZv3l8vRbOolpl5i6iWmXmLDyWXDyWXDyWU6S0xnieksMfUSUy8x9RJTLzH1ElMvMfUSUy8x9RLXWYJN78+l6dJ1GbpMXZYuObn8w8nlH04u11niOktcZ4mrl7h6iauXuHqJq5e4eomrl7h6iauXuM4SHHt/LjWbeomrl7h6iauXuHFyuXNyuXNyuc4S11niOktcvcTVS1y9xNVLXL3E1UtcvcTVS1y9xHWWYN77c6nZ1EtcvcTVS1y9xJOTy5OTy5OTy3WWuM4S11ni6iWuXuLqJa5e4uolrl7i6iWuXuLqJa6zBB/fn0vNpl7i6iWuXuLqJd6cXN6cXN6cXK6zxHWWuM4SVy9x9RJXL3H1ElcvcfUSVy9x9RJXL3GdJVj6/nK5mk29xNVLXL3E1Ut8Obl8Obl8OblcZ4nrLAmdJaFeEuoloV4S6iWhXhLqJaFeEuoloV4SOktw9/25NF26LkOXqcvSJSdXPE6ueJxcobMkdJaEzpJQLwn1klAvCfWSUC8J9ZJQLwn1klAvCZ0lGP3+XGo29ZJQLwn1klAvCefkiuDkiuDkCp0lobMkdJaEekmol4R6SaiXhHpJqJeEekmol4R6SegswfP351KzqZeEekmol4R6SRQnVxQnVxQnV+gsCZ0lobMk1EtCvSTUS0K9JNRLQr0k1EtCvSTUS0JnCfa/P5eaTb0k1EtCvSTUS2I4uWI4uWI4uUJnSegsCZ0loV4S6iWhXhLqJaFeEuoloV4S6iWhXhI6S3AC/uXHHp+PLp8uTZeuy9AlJ1d+OLnyw8mVOktSZ0nqLEn1klQvSfWSVC9J9ZJUL0n1klQvSfWS1FmCKfDPpWZTL0n1klQvSfWSNE6uNE6uNE6u1FmSOktSZ0mql6R6SaqXpHpJqpekekmql6R6SaqXpM4S/IF/LjWbekmql6R6SaqXZHByZXJyZXJypc6S1FmSOktSvSTVS1K9JNVLUr0k1UtSvSTVS1K9JHWWYBX8c6nZ1EtSvSTVS1K9JJuTK5uTK5uTK3WWpM6S1FmS6iWpXpLqJalekuolqV6S6iWpXpLqJamzBNfgn0vNpl6S6iWpXpLqJbmcXLmcXLmcXKmzJHWWpM6SVC8p9ZJSLyn1klIvKfWSUi8p9ZJSLymdJRgI/3L5Prp8ujRdui5Dl5xc9Ti56nFylc6S0llSOktKvaTUS0q9pNRLSr2k1EtKvaTUS0q9pHSW4CX8c6nZ1EtKvaTUS0q9pJyTq5yTq5yTq3SWlM6S0llS6iWlXlLqJaVeUuolpV5S6iWlXlLqJaWzBFvhn0vNpl5S6iWlXlLqJZWcXFWcXFWcXKWzpHSWlM6SUi8p9ZJSLyn1klIvKfWSUi8p9ZJSLymdJTgM/1xqNvWSUi8p9ZJSL6nh5Krh5Krh5CqdJaWzpHSWlHpJqZeUekmpl5R6SamXlHpJqZeUeknpLMFs+OdSs6mXtHpJq5e0ekl/OLn6w8nVH06u1lnSOktaZ0mrl7R6SauXtHpJq5e0ekmrl7R6SauXtM6S1jvh1jvhVi9p9ZJWL2n1kjZOrjZOrjZOrtZZ0jpLWmdJq5e0ekmrl7R6SauXtHpJq5e0ekmrl7TOktY74dY74VYvafWSVi9p9ZIOTq4OTq4OTq7WWdI6S1pnSauXtHpJq5e0ekmrl7R6SauXtHpJq5e0zpLWO+HWO+FWL2n1klYvafWSLk6ubk6ubk6u1lnSOktaZ0mrl7R6SauXtHpJq5e0ekmrl7R6SauXtM6S1jvh1jvhVi9p9ZJWL2n1kl5Orl5Orl5OrtZZ0jpLWmdJq5e0ekmrl4x6yaiXjHrJqJeMesmol4zOktE74dE74VEvGfWSUS8Z9ZJ5nFzzOLnmcXKNzpLRWTI6S0a9ZNRLRr1k1EtGvWTUS0a9ZNRLRr1kdJaM3gmP3gmPesmol4x6yaiXjHNyjXNyjXNyjc6S0VkyOktGvWTUS0a9ZNRLRr1k1EtGvWTUS0a9ZHSWjN4Jj94Jj3rJqJeMesmol0xyck1yck1yco3OktFZMjpLRr1k1EtGvWTUS0a9ZNRLRr1k1EtGvWR0lozeCY/eCY96yaiXjHrJqJdMc3LNcHLNcHKNzpLRWTI6S0a9ZNRLRr1k1EtGvWTUS0a9ZNRLRr1kdJaM3gmP3gmPesmol4x6yaqX7IeTaz+cXPvh5FqdJauzZHWWrHrJqpesesmql6x6yaqXrHrJqpesesnqLFm9E169E171klUvWfWSVS9Z4+Ra4+Ra4+RanSWrs2R1lqx6yaqXrHrJqpesesmql6x6yaqXrHrJ6ixZvRNevRNe9ZJVL1n1klUv2eDk2uDk2uDkWp0lq7NkdZasesmql6x6yaqXrHrJqpesesmql6x6yeosWb0TXr0TXvWSVS9Z9ZJVL9ni5Nri5Nri5FqdJauzZHWWrHrJqpesesmql6x6yaqXrHrJqpesesnqLFm9E169E171klUvWfWSVS/Z4eTa5eTa5eRanSWrs2R1lqx6yaqXrHrJqpfggXwPEeSfy6dL06XrMnR5sz10kH8uW5ejy+WSXvI+x7r/ubyT632Odv9zqadxljzEkH8uW5ejS81mms00m2k202ymp5meZnqaaTbTbKbZXLPRS96HXvI+R8D/uQwmPgb+z6We5prNNZtrttBsodlCs4VmC80Wmi30tNDTQk8LzZaaLTVbajZ6yfvQS97nuPg/l8XER8b/udTTUrOVZivNVpqtNFtpttJspdlKs5WeVnpa62mt2VqztWZrzdbagNYGHC3/53KY+Hj598S9PsySfy4122i20Wyj2UazjWYbzTaabfW01dNWT1vNtpptNdtqttUGrDYAhv49GPr3YOifuNf3dJY8nSUYJ/9cli5bl6NLZkM7+efy6VJPe3qazhLck38uS5ety9ElG/DoJe/B0L8HQ/8eDP0T9/qezpKnswQP5Z9LzWaazTWbazbXbK7ZXE9zPU1nCUbKP5eazTVbaDZ6yXv0kvdg6N+DoX8Phv6Je31PZ8nTWYKd8s/fv2ZLzZaaLTVbarbUbKmnpZ6mswRP5Z9/Ys1Wmq00G73kPXrJezD078HQvwdD/8S9vqez5OkswVn551KztWZrzdaarTVba7bW01pP01mCvfLPpWYbzTaabbQBow2AoX8Phv49GPon7vU9nSVPZwkmyz+Xmm0122q21Wyr2dRLxL0+ca9P3OvDafnnMnSZuixdti5Hl5xcBkP/DIb+iXt9prPEdJaYeompl5h6iamXmHqJqZeYeom41yfu9Yl7fZgu/1xqNvUSUy8x9RJTLzEY+mcw9M9g6J+412c6S0xniamXmHqJqZeYeompl5h6iamXiHt94l6fuNeH//LPpWZTLzH1ElMvMfUSg6F/BkP/DIb+iXt9prPEdJaYeompl5h6iamXmHqJqZeYeom41yfu9Yl7fVgx/2SEZlMvMfUSUy8x9RKDoX8GQ/8Mhv6Je32ms8R0lph6iamXmHqJqZeYeompl5h6ibjXJ+71iXt9uDL/XGo29RJTLzH1ElMvMRj6ZzD0z2Don7jX5zpLXGeJq5e4eomrl7h6iauXuHqJq5eIe33iXp+414dB889l6DJ1WbpsXY4uObkchv45DP0T9/pcZ4nrLHH1ElcvcfUSVy9x9RJXL3H1EnGvT9zrE/f68Gr+udRs6iWuXuLqJa5e4jD0z2Hon8PQP3Gvz3WWuM4SVy9x9RJXL3H1ElcvcfUSVy8R9/rEvT5xrw/b5p9LzaZe4uolrl7i6iUOQ/8chv45DP0T9/pcZ4nrLHH1ElcvcfUSVy9x9RJXL3H1EnGvT9zrE/f6cHD+KZmaTb3E1UtcvcTVSxyG/jkM/XMY+ifu9bnOEtdZ4uolrl7i6iWuXuLqJa5e4uol4l6fuNcn7vVh5vxzabp0XYYuU5elS06ugKF/AUP/xL2+0FkSOktCvSTUS0K9JNRLQr0k1EtCvUTc6xP3+sS9Pnydfy41m3pJqJeEekmolwQM/QsY+hcw9E/c6wudJaGzJNRLQr0k1EtCvSTUS0K9JNRLxL0+ca9P3OvD4vnnUrOpl4R6SaiXhHpJwNC/gKF/AUP/xL2+0FkSOktCvSTUS0K9JNRLQr0k1EtCvUTc6xP3+sS9Ptyefy41m3pJqJeEekmolwQM/QsY+hcw9E/c6wudJaGzJNRLQr0k1EtCvSTUS0K9JNRLxL0+ca9P3OvD+Pnnu1TNpl4S6iWhXhLqJQFD/wKG/gUM/RP3+kJnSeosSfWSVC9J9ZJUL0n1klQvSfUSca9P3OsT9/rwgP65NF26LkOXqcvSJSdXwtC/hKF/4l5f6ixJnSWpXpLqJalekuolqV6S6iWpXiLu9Yl7feJeH3bQP5eaTb0k1UtSvSTVSxKG/iUM/UsY+ifu9aXOktRZkuolqV6S6iWpXpLqJalekuol4l6fuNcn7vXhDP1zqdnUS1K9JNVLUr0kYehfwtC/hKF/4l5f6ixJnSWpXpLqJalekuolqV6S6iWpXiLu9Yl7feJeHybRP5eaTb0k1UtSvSTVSxKG/iUM/UsY+ifu9aXOktRZkuolqV6S6iWpXpLqJalekuol4l6fuNcn7vXhF/3zY66PLp8uTZeuy9AlJ1fB0L+CoX/iXl/pLCmdJaVeUuolpV5S6iWlXlLqJaVeIu71iXt94l4f1tE/l5pNvaTUS0q9pNRLCob+FQz9Kxj6J+71lc6S0llS6iWlXlLqJaVeUuolpV5S6iXiXp+41yfu9eEi/XOp2dRLSr2k1EtKvaRg6F/B0L+CoX/iXl/pLCmdJaVeUuolpV5S6iWlXlLqJaVeIu71iXt94l4fhtI/l5pNvaTUS0q9pNRLCob+FQz9Kxj6J+71lc6S0llS6iWlXlLqJaVeUuolpV5S6iXiXp+41yfu9eEt/XOp2dRLSr2k1EtKvaRg6F/B0L+CoX/iXl/pLCmdJaVe0uolrV7S6iWtXtLqJa1eIu71iXt94l5f651w651wq5e0ekmrl7R6ScPQv4ahfw1D/8S9vtZZ0jpLWr2k1UtavaTVS1q9pNVLWr1E3OsT9/rEvb7WO+HWO+FWL2n1klYvafWShqF/DUP/Gob+iXt9rbOkdZa0ekmrl7R6SauXtHpJq5e0eom41yfu9Yl7fa13wq13wq1e0uolrV7S6iUNQ/8ahv41DP0T9/paZ0nrLGn1klYvafWSVi9p9ZJWL2n1EnGvT9zrE/f6Wu+EW++EW72k1UtavaTVSxqG/jUM/WsY+ifu9bXOktZZ0uolrV7S6iWtXtLqJa1e0uol4l6fuNcn7vW13gm33gm3esmol4x6yaiXDAz9Gxj6NzD0T9zrG50lo7Nk1EtGvWTUS0a9ZNRLRr1k1EvEvT5xr0/c6xu9Ex69Ex71klEvGfWSUS8ZGPo3MPRvYOifuNc3OktGZ8mol4x6yaiXjHrJqJeMesmol4h7feJen7jXN3onPHonPOolo14y6iWjXjIw9G9g6N/A0D9xr290lozOklEvGfWSUS8Z9ZJRLxn1klEvEff6xL0+ca9v9E549E541EtGvWTUS0a9ZGDo38DQv4Ghf+Je3+gsGZ0lo14y6iWjXjLqJaNeMuolo14i7vWJe33iXt/onfDonfCol4x6yaiXjHrJwNC/gaF/A0P/xL2+0VkyOktGvWTUS0a9ZNVLVr1k1UtWvUTc6xP3+sS9vtU74dU74VUvWfWSVS9Z9ZKFoX8LQ/8Whv6Je32rs2R1lqx6yaqXrHrJqpesesmql6x6ibjXJ+71iXt9q3fCq3fCq16y6iWrXrLqJQtD/xaG/i0M/RP3+lZnyeosWfWSVS9Z9ZJVL1n1klUvWfUSca9P3OsT9/pW74RX74RXvWTVS1a9ZNVLFob+LQz9Wxj6J+71rc6S1Vmy6iWrXrLqJatesuolq16y6iXiXp+41yfu9a3eCa/eCa96yaqXrHrJqpcsDP1bGPq3MPRP3OtbnSWrs2TVS1a9ZNVLVr1k1UtWvWTVS8S9PnGvT9zrW70TXr0TXvWSVS9Zeol96CX2gaG3Dwy9fWDoTdyryfdq8r2afK8m36vJ92ryvZp8rybfq8n3auJeTdyriXs1+V5NvleT79Xke7UPvcQ+9BL7wNDbB4bePjD0Ju7V5Hs1+V5NvleT79XkezX5Xk2+V5Pv1eR7NXGvJu7VxL2afK8m36vJ92ryvdqHXmIfeol9YOjtA0NvHxh6E/dq8r2afK8m36vJ92ryvZp8rybfq8n3avK9mrhXE/dq4l5NvleT79XkezX5Xu1DL7EPvcQ+MPT2gaG3Dwy9iXs1+V5NvleT79XkezX5Xk2+V5Pv1eR7NfleTdyriXs1ca8m36vJ92ryvZp8r/YZbcBoA2Do7QNDbx8YehP3avK9mnyvJt+ryfdq8r2afK8m36vJ92ryvZq4VxP3auJeTb5Xk+/V5Hs1+V7t0Uvs0UvswdDbg6G3B0Nv4l5NvleT79XkezX5Xk2+V5Pv1eR7NfleTb5XE/dq4l5N3KvJ92ryvZp8rybfqz16iT16iT0Yensw9PZg6E3cq8n3avK9mnyvJt+ryfdq8r2afK8m36vJ92riXk3cq4l7NfleTb5Xk+/V5Hu1Ry+xRy+xB0NvD4beHgy9iXs1+V5NvleT79XkezX5Xk2+V5Pv1eR7NfleTdyriXs1ca8m36vJ92ryvZp8r/ZaG9DaABh6ezD09mDoTdyryfdq8r2afK8m36vJ92ryvZp8rybfq8n3auJeTdyriXs1+V5NvleT79Xke7W32oDVBsDQm8HQm8HQm7hXk+/V5Hs1+V5NvleT79XkezX5Xk2+V5Pv1cS9mrhXE/dq8r2afK8m36vJ92qmXmLqJQZDbwZDbwZDb+JeTb5Xk+/V5Hs1+V5NvleT79XkezX5Xk2+VxP3auJeTdyryfdq8r2afK8m36uZeomplxgMvRkMvRkMvYl7NfleTb5Xk+/V5Hs1+V5NvleT79XkezX5Xk3cq4l7NXGvJt+ryfdq8r2afK9m6iWmXmIw9GYw9GYw9Cbu1eR7NfleTb5Xk+/V5Hs1+V5NvleT79XkezVxrybu1cS9mnyvJt+ryfdq8r2aqZeYeonB0JvB0JvB0Ju4V5Pv1eR7NfleTb5Xk+/V5Hs1+V5NvleT79XEvZq4VxP3avK9mnyvJt+ryfdqrl7i6iUOQ28OQ28OQ2/iXk2+V5Pv1eR7NfleTb5Xk+/V5Hs1+V5NvlcT92riXk3cq8n3avK9mnyvJt+ruXqJq5c4DL05DL05DL2JezX5Xk2+V5Pv1eR7NfleTb5Xk+/V5Hs1+V5N3KuJezVxrybfq8n3avK9mnyv5uolrl7iMPTmMPTmMPQm7tXkezX5Xk2+V5Pv1eR7NfleTb5Xk+/V5Hs1ca8m7tXEvZp8rybfq8n3avK9mquXuHqJw9Cbw9Cbw9CbuFeT79XkezX5Xk2+V5Pv1eR7NfleTb5Xk+/VxL2auFcT92ryvZp8rybfq8n3aq5e4uolDkNvDkNvDkNv4l5NvleT79XkezX5Xk2+V5Pv1eR7NfleTb5XE/dq4l5N3KvJ92ryvZp8rybfq4V6SaiXBAy9BQy9BQy9iXs1+V5NvleT79XkezX5Xk2+V5Pv1eR7NfleTdyriXs1ca8m36vJ92ryvZp8rxbqJaFeEjD0FjD0FjD0Ju7V5Hs1+V5NvleT79XkezX5Xk2+V5Pv1eR7NXGvJu7VxL2afK8m36vJ92ryvVqol4R6ScDQW8DQW8DQm7hXk+/V5Hs1+V5NvleT79XkezX5Xk2+V5Pv1cS9mrhXE/dq8r2afK8m36vJ92qhXhLqJQFDbwFDbwFDb+JeTb5Xk+/V5Hs1+V5NvleT79XkezX5Xk2+VxP3auJeTdyryfdq8r2afK8m36ulekmqlyQMvSUMvSUMvYl7NfleTb5Xk+/V5Hs1+V5NvleT79XkezX5Xk3cq4l7NXGvJt+ryfdq8r2afK+W6iWpXpIw9JYw9JYw9Cbu1eR7NfleTb5Xk+/V5Hs1+V5NvleT79XkezVxrybu1cS9mnyvJt+ryfdq8r1aqpekeknC0FvC0FvC0Ju4V5Pv1eR7NfleTb5Xk+/V5Hs1+V5NvleT79XEvZq4VxP3avK9mnyvJt+ryfdqqV6S6iUJQ28JQ28JQ2/iXk2+V5Pv1eR7NfleTb5Xk+/V5Hs1+V5NvlcT92riXk3cq8n3avK9mnyvJt+rpXpJqpckDL0lDL0lDL2JezX5Xk2+V5Pv1eR7NfleTb5Xk+/V5Hs1+V5N3KuJezVxrybfq8n3avK9mnyvVuolpV5SMPRWMPRWMPQm7tXkezX5Xk2+V5Pv1eR7NfleTb5Xk+/V5Hs1ca8m7tXEvZp8rybfq8n3avK9WqmXlHpJwdBbwdBbwdCbuFeT79XkezX5Xk2+V5Pv1eR7NfleTb5Xk+/VxL2auFcT92ryvZp8rybfq8n3aqVeUuolBUNvBUNvBUNv4l5NvleT79XkezX5Xk2+V5Pv1eR7NfleTb5XE/dq4l5N3KvJ92ryvZp8rybfq5V6SamXFAy9FQy9FQy9iXs1+V5NvleT79XkezX5Xk2+V5Pv1eR7NfleTdyriXs1ca8m36vJ92ryvZp8r9bqJa1e0jD01jD01jD0Ju7V5Hs1+V5NvleT79XkezX5Xk2+V5Pv1eR7NXGvJu7VxL2afK8m36vJ92ryvVqrl7R6ScPQW8PQW8PQm7hXk+/V5Hs1+V5NvleT79XkezX5Xk2+V5Pv1cS9mrhXE/dq8r2afK8m36vJ92qtXtLqJQ1Dbw1Dbw1Db+JeTb5Xk+/V5Hs1+V5NvleT79XkezX5Xk2+VxP3auJeTdyryfdq8r2afK8m36u1ekmrlzQMvTUMvTUMvYl7NfleTb5Xk+/V5Hs1+V5NvleT79XkezX5Xk3cq4l7NXGvJt+ryfdq8r2afK/W6iWtXtIw9NYw9NYw9Cbu1eR7NfleTb5Xk+/V5Hs1+V5NvleT79XkezVxrybu1cS9mnyvJt+ryfdq8r3aqJeMesnA0NvA0NvA0Ju4V5Pv1eR7NfleTb5Xk+/V5Hs1+V5NvleT79XEvZq4VxP3avK9mnyvJt+ryfdqo14y6iUDQ28DQ28DQ2/iXk2+V5Pv1eR7NfleTb5Xk+/V5Hs1+V5NvlcT92riXk3cq8n3avK9mnyvJt+rjXrJqJcMDL0NDL0NDL2JezX5Xk2+V5Pv1eR7NfleTb5Xk+/V5Hs1+V5N3KuJezVxrybfq8n3avK9mnyvNuolo14yMPQ2MPQ2MPQm7tXkezX5Xk2+V5Pv1eR7NfleTb5Xk+/V5Hs1ca8m7tXEvZp8rybfq8n3avK92qqXrHrJwtDbwtDbwtCbuFeT79XkezX5Xk2+V5Pv1eR7NfleTb5Xk+/VxL2auFcT92ryvZp8rybfq8n3aqtesuolC0NvC0NvC0Nv4l5NvleT79XkezX5Xk2+V5Pv1eR7NfleTb5XE/dq4l5N3KvJ92ryvZp8rybfq616yaqXLAy9LQy9LQy9iXs1+V5NvleT79XkezX5Xk2+V5Pv1eR7NfleTdyriXs1ca8m36vJ92ryvZp8r7bqJatesjD0tjD0tjD0Ju7V5Hs1+V5NvleT79XkezX5Xk2+V5Pv1eR7NXGvJu7VxL2afK8m36vJ92ryvdqql6x6ycLQ28LQ28LQm7hXk+/V5Hs1+V5NvleT79Xle3X5Xl2+V5fv1cW9urhXF/fq8r26fK8u36vL9+ofeol/6CX+gaH3Dwy9f2DoXdyry/fq8r26fK8u36vL9+ryvbp8ry7fq8v36uJeXdyri3t1+V5dvleX79Xle/UPvcQ/9BL/wND7B4bePzD0Lu7V5Xt1+V5dvleX79Xle3X5Xl2+V5fv1eV7dXGvLu7Vxb26fK8u36vL9+ryvfqHXuIfeol/YOj9A0PvHxh6F/fq8r26fK8u36vL9+ryvbp8ry7fq8v36vK9urhXF/fq4l5dvleX79Xle3X5Xv3T2oDWBsDQ+weG3j8w9C7u1eV7dfleXb5Xl+/V5Xt1+V5dvleX79Xle3Vxry7u1cW9unyvLt+ry/fq8r36h17ij17iD4beHwy9Pxh6F/fq8r26fK8u36vL9+ryvbp8ry7fq8v36vK9urhXF/fq4l5dvleX79Xle3X5Xv3RS/zRS/zB0PuDofcHQ+/iXl2+V5fv1eV7dfleXb5Xl+/V5Xt1+V5dvlcX9+riXl3cq8v36vK9unyvLt+rP3qJP3qJPxh6fzD0/mDoXdyry/fq8r26fK8u36vL9+ryvbp8ry7fq8v36uJeXdyri3t1+V5dvleX79Xle/VHL/FHL/EHQ+8Pht4fDL2Le3X5Xl2+V5fv1eV7dfleXb5Xl+/V5Xt1+V5d3KuLe3Vxry7fq8v36vK9unyv/kYbMNoAGHp/MPT+YOhd3KvL9+ryvbp8ry7fq8v36vK9unyvLt+ry/fq4l5d3KuLe3X5Xl2+V5fv1eV7dVMvMfUSg6F3g6F3g6F3ca8u36vL9+ryvbp8ry7fq8v36vK9unyvLt+ri3t1ca8u7tXle3X5Xl2+V5fv1U29xNRLDIbeDYbeDYbexb26fK8u36vL9+ryvbp8ry7fq8v36vK9unyvLu7Vxb26uFeX79Xle3X5Xl2+Vzf1ElMvMRh6Nxh6Nxh6F/fq8r26fK8u36vL9+ryvbp8ry7fq8v36vK9urhXF/fq4l5dvleX79Xle3X5Xt3US0y9xGDo3WDo3WDoXdyry/fq8r26fK8u36vL9+ryvbp8ry7fq8v36uJeXdyri3t1+V5dvleX79Xle3VTLzH1EoOhd4ehd4ehd3GvLt+ry/fq8r26fK8u36vL9+ryvbp8ry7fq4t7dXGvLu7V5Xt1+V5dvleX79VdvcTVSxyG3h2G3h2G3sW9unyvLt+ry/fq8r26fK8u36vL9+ryvbp8ry7u1cW9urhXl+/V5Xt1+V5dvld39RJXL3EYencYencYehf36vK9unyvLt+ry/fq8r26fK8u36vL9+ryvbq4Vxf36uJeXb5Xl+/V5Xt1+V7d1UtcvcRh6N1h6N1h6F3cq8v36vK9unyvLt+ry/fq8r26fK8u36vL9+riXl3cq4t7dfleXb5Xl+/V5Xt1Vy9x9RKHoXeHoXeHoXdxry7fq8v36vK9unyvLt+ry/fq8r26fK8u36uLe3Vxry7u1eV7dfleXb5Xl+/VQ70k1EsCht4Dht4Dht7Fvbp8ry7fq8v36vK9unyvLt+ry/fq8r26fK8u7tXFvbq4V5fv1eV7dfleXb5XD/WSUC8JGHoPGHoPGHoX9+ryvbp8ry7fq8v36vK9unyvLt+ry/fq8r26uFcX9+riXl2+V5fv1eV7dflePdRLQr0kYOg9YOg9YOhd3KvL9+ryvbp8ry7fq8v36vK9unyvLt+ry/fq4l5d3KuLe3X5Xl2+V5fv1eV79VAvCfWSgKH3gKH3gKF3ca8u36vL9+ryvbp8ry7fq8v36vK9unyvLt+ri3t1ca8u7tXle3X5Xl2+V5fv1UO9JNRLAobeA4beA4bexb26fK8u36vL9+ryvbp8ry7fq8v36vK9unyvLu7Vxb26uFeX79Xle3X5Xl2+V0/1klQvSRh6Txh6Txh6F/fq8r26fK8u36vL9+ryvbp8ry7fq8v36vK9urhXF/fq4l5dvleX79Xle3X5Xj3VS1K9JGHoPWHoPWHoXdyry/fq8r26fK8u36vL9+ryvbp8ry7fq8v36uJeXdyri3t1+V5dvleX79Xle/VUL0n1koSh94Sh9y/3Wr//A3+2O38uW5ejy+Xy+x7n9/Lp0nTpugxdpi71tNbTWk/7c5ZUfS+/P3v9vXy6NF26LkOXf562P5d/eVr//MP+OUt+Jx49bTTbarbVbKvZVrOtZlvNtpptNdvqacvTvtzrXTLbl3u9S9dl6DJ1Wbrsm/jLvf5M/OVefyb+cq+/T3tPl6ZL12XoMnVZumxdji41m+lppqeZnmaazTSbaTbTbH/OkrscXS4T/zlLfif+c5b8Tux6mms212yu2VyzuWZzzeaaLTRbaLbQ00JPCz0tNFtottBsodmCDfjxvf5ePib+c5b8TvznLPmdOPW01Gyp2VKzpWZLzVaarTRbabbSbKWnlZ6ms+TLvf5+6aXZSrO1ZmttQGsDvmfJz8R/zpLfiZuTq3SWlM6S0lny5V5/L0ezjWYbzTaabTTbaLbR00ZP01ny5V5/v/TVbKvZVrOtNmC1AcvJ9eVefydeTq7SWVI6S1pnyZd7vUvTpesydJm6LF22LkeXeprOki/3+vOlf7nXu3Rdhi5Tl6VLTq4v9/oz8Zd7/Zm4dZa0zpLWWfLlXu9Ss5lmM81mms00m2k219NcT9NZ8uVef79012yu2VyzeetydMnJ9eVefycOTq7WWdI6S1pnyZd7vUvNFpotNFtottRsqdlST0s9TWfJl3v9/dJTs6VmS82WbMCP7/X3kpPry73+TlycXK2zpHWWtM6SVi9p9ZJWL2n1klYvafWSVi9p9ZJWL2mdJV/u9fdLb82mXtLqJa1e0uolX+71d+Lh5Ppyr78T6yxpnSWts6TVS1q9pNVLWr2k1UtavaTVS1q9pNVLWmfJl3v9+dK/3OtdPl2aLl2XoUtOri/3+jPxl3v9mXh0lozOktFZMuolo14y6iWjXjLqJaNeMuolo14y6iWjs+TLvf5+6abZ1EtGvWTUS0a95Mu9/k5snFxf7vV3Yp0lo7NkdJaMesmol4x6yaiXjHrJqJeMesmol4x6yegs+XKvv196aDb1klEvGfWSUS/5cq+/Eycn15d7/Z1YZ8noLBmdJaNeMuolo14y6iWjXjLqJaNeMuolo14yOku+3Ovvl16aTb1k1EtGvWTUS77c6+/Ezcn15V5/J9ZZMjpLRmfJqJeMesmol4x6yaiXjHrJqJeMesmol4zOki/3+vulj2ZTLxn1klEvGfWSL/f6O/Fycn2519+JdZaMzpLRWTLqJatesuolq16y6iWrXrLqJatesuolq7Pky73+fOlf7vUuny5Nl67L0CUn15d7/Zn4y73+TLw6S1ZnyeosWfWSVS9Z9ZJVL1n1klUvWfWSVS9Z9ZLVWfLlXn+/dNds6iWrXrLqJate8uVefyd2Tq4v9/o7sc6S1VmyOktWvWTVS1a9ZNVLVr1k1UtWvWTVS1a9ZHWWfLnX3y89NZt6yaqXrHrJqpd8udffiYuT68u9/k6ss2R1lqzOklUvWfWSVS9Z9ZJVL1n1klUvWfWSVS9ZnSVf7vX3S2/Npl6y6iWrXrLqJV/u9Xfi4eT6cq+/E+ssWZ0lq7Nk1UtWvWTVS1a9ZNVLVr1k1UtWvWTVS1ZnyZd7/f3SV7PRS+JDL4kPvSQ+9JL4cq/fiePLvX4nji/3+p04Ppwl8eEsiQ9nSXzoJfGhl8SHXhIfekl86CXxoZfEh14Sn6enPT3t6WlPs5lmM81mmo1eEh96SXy519+JrZjYmolNTzPN5prNNZtrNtdsrtlcs7lmc83meprraaGnhWYLzRaaLTQbvSQ+9JL4cq+/E8cwcSwTp56Wmi01W2q21Gyp2VKzpWZLzZaarfS00tNKTyvNVpqtNFtpNnpJfOgl8eVefyfuDxP3Y+LW01qztWZrzdaarTVba7bWbKPZRrONnjZ62uhpo9lGs41mG8022oDVBuxj4jUmXmfi1dNWs61mW822mo1eEo9eEo9eEo9eEo9eEo9eEo9eEk9nyZd7/fnSv9zrXTLbo5fEo5fEo5fEl3v9mfjLvf5M/OVefyZ+OkuezpKns+Q9zWaazTSbaTbTbKbZTLOZnmZ6ms6SL/f6+6W7ZnPN5pqNXhKPXhJf7vV3Yufk+nKvvxPrLHk6S57OkheaLTRbaLbQbKHZQrOFZgs9LfQ0nSVf7vX3S0/NlpotNRu9JB69JL7c6+/Eycn15V5/J9ZZ8nSWPJ0lrzRbabbSbKXZSrOVZivN1npa62k6S77c6++X3pqtNVtrttYGtDagObm+3OvvxMPJ9XSWPJ0lT2fJG802mm0022i20Wyr2VazrZ62eprOki/3+vulr2ZbzbaaTb3E1Eu+3OvPxF/u9WfiL/f6M7HpLDGdJaazxNRLTL3E1EtMvcTUS0y9xNRLTL3E1EtMZ8mXe/390t/oUrOpl5h6iamXfLnX34mNk+vLvf5OrLPEdJaYzhJTLzH1ElMvMfUSUy8x9RJTLzH1ElMvMZ0lX+7190sPzaZeYuolpl5i6iVf7vV34uDk+nKvvxPrLDGdJaazxNRLTL3E1EtMvcTUS0y9xNRLTL3E1EtMZ8mXe/390kuzqZeYeompl5h6yZd7/Z24OLm+3OvvxDpLTGeJ6Swx9RJTLzH1ElMvMfUSUy8x9RJTLzH1EtNZYqPZRrOpl5h6iamXmHrJl3v9nXg5ub7c6+/EOktMZ4npLDH1ElMvMfUSUy8x9RJXL3H1ElcvcfUS11nivBMO551wuHqJq5e4eomrl3y515+Jv9zrz8Rf7vVnYtdZ4jpLXGeJq5e4eomrl7h6iauXuHqJq5e4eomrl7jOEjfNZppNvcTVS1y9xNVLvtzr78TOyfXlXn8n1lniOktcZ4mrl7h6iauXuHqJq5e4eomrl7h6iauXuM4SD82Wmk29xNVLXL3E1Uu+3OvvxMnJ9eVefyfWWeI6S1xniauXuHqJq5e4eomrl7h6iauXuHqJq5e4zhJvzdaaTb3E1UtcvcTVS77c6+/Ezcn15V5/J9ZZ4jpLXGeJq5e4eomrl7h6iauXuHqJq5e4eomrl7jOEl/NtppNvcTVS1y9xNVLvtzrz8Rf7vVn4i/3+jNx6CwJnSWhsyTUS0K9JNRLQr0k1EtCvSTUS0K9JNRLQmdJ8E44gnfCEeoloV4S6iWhXvLlXn8nNk6uL/f6O7HOktBZEjpLQr0k1EtCvSTUS0K9JNRLQr0k1EtCvSR0loRrNtds6iWhXhLqJaFe8uVefycOTq4v9/o7sc6S0FkSOktCvSTUS0K9JNRLQr0k1EtCvSTUS0K9JHSWRGq20mzqJaFeEuoloV7y5V5/Jy5Ori/3+juxzpLQWRI6S0K9JNRLQr0k1EtCvSTUS0K9JNRLQr0kdJbEaLbRbOoloV4S6iWhXvLlXn8nHk6uL/f6O7HOktBZEjpLQr0k1EtCvSTUS0K9JNRLQr0k1UtSvSR1liTvhCN5JxypXpLqJalekuolX+71Z+Iv9/oz8Zd7/Zk4dZakzpLUWZLqJalekuolqV6S6iWpXpLqJalekuolqbMkTbOZZlMvSfWSVC9J9ZIv9/o7sXNyfbnX34l1lqTOktRZkuolqV6S6iWpXpLqJalekuolqV6S6iWpsyRDs4VmUy9J9ZJUL0n1ki/3+jtxcnJ9udffiXWWpM6S1FmS6iWpXpLqJalekuolqV6S6iXiXkPca4h7jSzN1ppNvSTVS1K9JNVLfrjXn4mbk+uHe/2ZWGdJ6ixJnSWpXpLqJalekuolqV6S6iWpXiLuNcS9hrjXyNVsq9nUS1K9JNVLUr3kh3v9mXg5uX641+/E4l6jdJaUzpJSLyn1klIvKfWSUi8p9ZJSLxH3GuJeQ9xrFO+Eo3gnHKVeUuolpV5S6iU/3Ot34i/3+jPxD/f6M7HOktJZUjpLSr2k1EtKvaTUS0q9pNRLSr1E3GuIew1xr1Gu2VyzqZeUekmpl5R6yQ/3+jNxcHL9cK8/E+ssKZ0lpbOk1EtKvaTUS0q9pNRLSr2k1EvEvYa41xD3GpWaLTWbekmpl5R6SamX/HCvPxMXJ1fB0Ie41yidJaWzpNRLSr2k1EtKvaTUS0q9pNRLxL2GuNcQ9xrVmm00m3pJqZeUekmplxQMfRQMfRQMfYh7jdJZUjpLSr2k1EtKvaTUS0q9pNRLSr1E3GuIew1xr9F6J9x6J9zqJa1e0uolrV7SMPTRMPTRMPQh7jVaZ0nrLGn1klYvafWSVi9p9ZJWL2n1EnGvIe41xL1G/3+JuJdcOZIki4JbClcz08/+N9ZNJktl5rOXhgIVtxAH4jfh8ptw2SVll5RdUnZJbUN/axv6W9vQX93rLbek3JKyS8ouKbuk7JKyS8ouKbtE93p1r1f3estvwuU34bJLyi4pu6TsktqG/tY29Le2ob+611tuSbklZZeUXVJ2SdklZZeUXVJ2ie716l6v7vWW34TLb8Jll5RdUnZJ2SW1Df2tbehvbUN/da+33JJyS8ouKbuk7JKyS8ouKbuk7BLd69W9Xt3rLb8Jl9+Eyy4pu6TskrJLahv6W9vQ39qG/upeb7kl7Za0XdJ2SdslbZe0XdJ2Sdslutere72619t+E26/Cbdd0nZJ2yVtl/Q29Le3ob+9Df3Vvd52S9otabuk7ZK2S9ouabuk7ZK2S3SvV/d6da+3/SbcfhNuu6TtkrZL2i7pbehvb0N/exv6q3u97Za0W9J2SdslbZe0XdJ2SdslbZfoXq/u9epeb/tNuP0m3HZJ2yVtl7Rd0tvQ396G/vY29Ff3etstabek7ZK2S9ouabuk7ZK2S9ou0b1e3evVvd72m3D7TbjtkrZL2i5pu6S3ob+9Df3tbeiv7vW2W9JuSdslbZe0XdJ2SdslbZe0XaJ7vbrXq3u97Tfh8Zvw2CVjl4xdMnbJbEN/Zxv6O9vQX93rHbdk3JKxS8YuGbtk7JKxS8YuGbtE93p1r1f3esdvwuM34bFLxi4Zu2TsktmG/s429He2ob+61ztuybglY5eMXTJ2ydglY5eMXTJ2ie716l6v7vWO34THb8Jjl4xdMnbJ2CWzDf2dbejvbEN/da933JJxS8YuGbtk7JKxS8YuGbtk7BLd69W9Xt3rHb8Jj9+Exy4Zu2TskrFLZhv6O9vQ39mG/upe77gl45aMXTJ2ydglY5eMXTJ2ydglutere7261zt+Ex6/CY9dMnbJ2CVjl8w29He2ob+zDf3Vvd5xS8Ytmd0l77e75P12l7zf7pL3213yfrtL3m93ydO9Pt3r072+3/4m/H77m/D77S55v90l77e75P12l7zfNvTvtw39+21D/3Sv7/d5W3hbeFt4W3hbeFt4W3hbeFv4a+GvHX/teNvxtuNtx9t2l7zf7pL324b+/bahf79t6J/u9f2ut11vu952ve162/W2623X2663PX/t+WvPX3ve9rztedvztt0l77e75P22oX+/bejfbxv6p3t9v/S29Lb0tvS29Lb0tvS28rbytvLXyl8rf628rbytvK28rfwLaP8CtqF/v23o328b+qd7fb/2tva29rb2tva28bbxtvG28bbx18ZfG39tvG28bXfJ+3aXvG93yft2l7xvG/r3bUP/vm3on+71fW7J55Z8u0vet7vkfbtL3re75H27S963u+R9u0ue7vXpXp/u9X2ft4W3hbeFt+0ued/ukvdtQ/++bejftw39072+zy353JLveNvxtuNtx9uOtx1vO952/LXjr7kl3/W2623X26637S553+6S921D/75t6N+3Df3Tvb7PLfncku952/O2523P2563PW973pb+WvprbsmX3pbelt6W3ra75H27S963Df37tqF/3zb0T/f6Prfkc0u+8rbytvK28rbytva29rb219pfc0u+9rb2tva29rb2L2D8C9iG/n3b0L9vG/qne32fW/K5Jd9423ibXRJ2SdglYZeEXaJ7fbrXp3t9sb8Jv9jfhF/YJWGXhF0SdklsQ/9iG/oX29A/3esLtyTckrBLwi4JuyTskrBLwi4Ju0T3+nSvT/f6IrzteJtdEnZJ2CVhl8Q29C+2oX+xDf3Tvb5wS8ItCbsk7JKwS8IuCbsk7JKwS3SvT/f6dK8vnrc9b7NLwi4JuyTsktiG/sU29C+2oX+61xduSbglYZeEXRJ2SdglYZeEXRJ2ie716V6f7vVFeVt5m10SdknYJWGXxDb0L7ahf7EN/dO9vnBLwi0JuyTskrBLwi4JuyTskrBLdK9P9/p0ry/G28bb7JKwS8IuOXbJ2Yb+nW3o39mG/ule33FLjlty7JJjlxy75Nglxy45dsmxS3SvT/f6dK/v7G/C7+xvwu/YJccuOXbJsUvONvTvbEP/zjb0T/f6jlty3JJjlxy75Nglxy45dsmxS45dont9utene33neNv1Nrvk2CXHLjl2ydmG/p1t6N/Zhv7pXt9xS45bcuySY5ccu+TYJccuOXbJsUt0r0/3+nSv76S3pbfZJccuOXbJsUvONvTvbEP/zjb0T/f6jlty3JJjlxy75Nglxy45dsmxS45dont9utene32nva29zS45dsmxS45dcrahf2cb+ne2oX+613fckuOWHLvk2CXHLjl2ybFLrl1y7RLd69O9Pt3ru/ub8Lv7m/C7dsm1S65dcu2Suw39u9vQv7sN/dO9vuuWXLfk2iXXLrl2ybVLrl1y7ZJrl+hen+716V7fDW8Lb7NLrl1y7ZJrl9xt6N/dhv7dbeif7vVdt+S6JdcuuXbJtUuuXXLtkmuXXLtE9/p0r0/3+u71tudtdsm1S65dcu2Suw39u9vQv7sN/dO9vuuWXLfk2iXXLrl2ybVLrl1y7ZJrl+hen+716V7fLW8rb7NLrl1y7ZJrl9xt6N/dhv7dbeif7vVdt+S6JdcuuXbJtUuuXXLtkmuXXLtE9/p0r0/3+u5423ibXXLtkmuXXLvkbkP/3jb0721D/3Sv77klzy15dsmzS55d8uySZ5c8u+TZJbrXp3t9utf39jfh9/Y34ffskmeXPLvk2SVvG/r3tqF/bxv6p3t9zy15bsmzS55d8uySZ5c8u+TZJc8u0b0+3evTvb53vO14m13y7JJnlzy75G1D/9429O9tQ/90r++5Jc8teXbJs0ueXfLskmeXPLvk2SW616d7fbrX9563pbfZJc8ueXbJs0veNvTvbUP/3jb0T/f6eK+P9/p4r4/3+nivj/f6eK+P9/p4r0/3+nSvT/f6eK+P9/p4r4/3+p5d8uyStw39e9vQv7cN/dO9Pt7r470+3uvjvT7e6+O9Pt7r470+3uvTvT7d69O9Pt7r470+3uvjvb60S9IuyW3oX25D/3Ib+qd7fbzXx3t9vNfHe32818d7fbzXx3t9vNene32616d7fbzXx3t9vNfHe31pl6RdktvQv9yG/uU29E/3+nivj/f6eK+P9/p4r4/3+nivj/f6eK9P9/p0r0/3+nivj/f6eK+P9/rSLkm7JLehf7kN/ctt6J/u9fFeH+/18V4f7/XxXh/v9fFeH+/18V6f7vXpXp/u9fFeH+/18V4f7/WlXZJ2SW5D/3Ib+pfb0D/d6+O9Pt7r470+3uvjvT7e6+O9Pt7r470+3evTvT7d6+O9Pt7r470+3utLuyTtktyG/uU29C+3oX+618d7fbzXx3t9vNfHe32818d7fbzXx3t9utene32618d7fbzXx3t9vNdXdknZJbUN/att6F9tQ/90r4/3+nivj/f6eK+P9/p4r4/3+nivj/f6dK9P9/p0r4/3+nivj/f6eK+v7JKyS2ob+lfb0L/ahv7pXh/v9fFeH+/18V4f7/XxXh/v9fFeH+/16V6f7vXpXh/v9fFeH+/18V5f2SVll9Q29K+2oX+1Df3TvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt7r070+3evTvT7e6+O9Pt7r472+skvKLqlt6F9tQ/9qG/qne32818d7fbzXx3t9vNfHe32818d7fbzXp3t9utene32818d7fbzXx3t9bZe0XdLb0L/ehv71NvRP9/p4r4/3+nivj/f6eK+P9/p4r4/3+nivT/f6dK9P9/p4r4/3+nivj/f62i5pu6S3oX+9Df3rbeif7vXxXh/v9fFeH+/18V4f7/XxXh/v9fFen+716V6f7vXxXh/v9fFeH+/1tV3SdklvQ/96G/rX29A/3evjvT7e6+O9Pt7r470+3uvjvT7e6+O9Pt3r070+3evjvT7e6+O9Pt7ra7uk7ZLehv71NvSvt6F/utfHe32818d7fbzXx3t9vNfHe32818d7fbrXp3t9utfHe32818d7fbzX13ZJ2yW9Df3rbehfb0P/dK+P9/p4r4/3+nivj/f6eK+P9/p4r4/3+nSvT/f6dK+P9/p4r4/3+nivb+ySsUtmG/o329C/2Yb+6V4f7/XxXh/v9fFeH+/18V4f7/XxXh/v9elen+716V4f7/XxXh/v9fFe39glY5fMNvRvtqF/sw39070+3uvjvT7e6+O9Pt7r470+3uvjvT7e69O9Pt3r070+3uvjvT7e6+O9vrFLxi6ZbejfbEP/Zhv6p3t9vNfHe32818d7fbzXx3t9vNfHe32816d7fbrXp3t9vNfHe32818d7fWOXjF0y29C/2Yb+zTb0T/f6eK+P9/p4r4/3+nivj/f6eK+P9/p4r0/3+nSvT/f6eK/Je03ea/Je87e7JH+7S/K3DX3+tqHP3zb0qXtN3mvyXpP3mrzX5L0m7zV5r8l7Td5r6l5T95q61+S9Ju81ea/Je83f7pL87S7J3zb0+duGPn/b0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81f7tL8re7JH/b0OdvG/r8bUOfutfkvSbvNXmvyXtN3mvyXpP3mrzX5L2m7jV1r6l7Td5r8l6T95q81/ylfwHlX8A29Pnbhj5/29Cn7jV5r8l7Td5r8l6T95q81+S9Ju81ea+pe03da+pek/eavNfkvSbvNX/jX8D4F7ANff62oc/fNvSpe03ea/Jek/eavNfkvSbvNXmvyXtN3mvqXlP3mrrX5L0m7zV5r8l7zW93SX67S/Lbhj6/bejz24Y+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5r/ntLslvd0l+29Dntw19ftvQp+41ea/Je03ea/Jek/eavNfkvSbvNXmvqXtN3WvqXpP3mrzX5L0m7zW/3SX57S7Jbxv6/Lahz28b+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L3mV/4FtH8B29Dntw19ftvQp+41ea/Je03ea/Jek/eavNfkvSbvNXmvqXtN3WvqXpP3mrzX5L0m7zXDLgm7JLahz9iGPmMb+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L1m2CVhl8Q29Bnb0GdsQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzXDLsk7JLYhj5jG/qMbehT95q81+S9Ju81ea/Je03ea/Jek/eavNfUvabuNXWvyXtN3mvyXpP3mmGXhF0S29BnbEOfsQ196l6T95q81+S9Ju81ea/Je03ea/Jek/eautfUvabuNXmvyXtN3mvyXjPskrBLYhv6jG3oM7ahT91r8l6T95q81+S9Ju81ea/Je03ea/JeU/eautfUvSbvNXmvyXtN3mseu+TYJWcb+jzb0OfZhj51r8l7Td5r8l6T95q81+S9Ju81ea/Je03da+peU/eavNfkvSbvNXmveeySY5ecbejzbEOfZxv61L0m7zV5r8l7Td5r8l6T95q81+S9Ju81da+pe03da/Jek/eavNfkveaxS45dcrahz7MNfZ5t6FP3mrzX5L0m7zV5r8l7Td5r8l6T95q819S9pu41da/Je03ea/Jek/eaxy45dsnZhj7PNvR5tqFP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03eax675Noldxv6vNvQ592GPnWvyXtN3mvyXpP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea957ZJrl9xt6PNuQ593G/rUvSbvNXmvyXtN3mvyXpP3mrzX5L0m7zV1r6l7Td1r8l6T95q81+S95rVLrl1yt6HPuw193m3oU/eavNfkvSbvNXmvyXtN3mvyXpP3mrzX1L2m7jV1r8l7Td5r8l6T95rXLrl2yd2GPu829Hm3oU/da/Jek/eavNfkvSbvNXmvyXtN3mvyXlP3mrrX1L0m7zV5r8l7Td5rXrvk2iV3G/q829Dn3YY+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5r/nskmeXvG3o821Dn28b+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L3ms0ueXfK2oc+3DX2+behT95q81+S9Ju81ea/Je03ea/Jek/eavNfUvabuNXWvyXtN3mvyXpP3ms8ueXbJ24Y+3zb0+bahT91r8l6T95q81+S9Ju81ea/Je03ea/JeU/eautfUvSbvNXmvyXtN3ms+u+TZJW8b+nzb0Ofbhj51r8l7Td5r8l6T95q81+S9Ju81ea/Je03da+peU/eavNfkvSbvNXmv+eySZ5e8begzt6HP3IY+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5r5l2SdoluQ195jb0mdvQp+41ea/Je03ea/Jek/eavNfkvSbvNXmvqXtN3WvqXpP3mrzX5L0m7zXTLkm7JLehz9yGPnMb+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L1m2iVpl+Q29Jnb0GduQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzXTLsk7ZLchj5zG/rMbehT95q81+S9Ju81ea/Je03ea/Jek/eavNfUvabuNXWvyXtN3mvyXpP3mmWXlF1S29BnbUOftQ196l6T95q81+S9Ju81ea/Je03ea/Jek/eautfUvabuNXmvyXtN3mvyXrPskrJLahv6rG3os7ahT91r8l6T95q81+S9Ju81ea/Je03ea/JeU/eautfUvSbvNXmvyXtN3muWXVJ2SW1Dn7UNfdY29Kl7Td5r8l6T95q81+S9Ju81ea/Je03ea+peU/eautfkvSbvNXmvyXvNskvKLqlt6LO2oc/ahj51r8l7Td5r8l6T95q81+S9Ju81ea/Je03da+peU/eavNfkvSbvNXmvWXZJ2SW1DX3WNvRZ29Cn7jV5r8l7Td5r8l6T95q81+S9Ju81ea+pe03da+pek/eavNfkvSbvNdsuabukt6HP3oY+exv61L0m7zV5r8l7Td5r8l6T95q81+S9Ju81da+pe03da/Jek/eavNfkvWbbJW2X9Db02dvQZ29Dn7rX5L0m7zV5r8l7Td5r8l6T95q81+S9pu41da+pe03ea/Jek/eavNdsu6Ttkt6GPnsb+uxt6FP3mrzX5L0m7zV5r8l7Td5r8l6T95q819S9pu41da/Je03ea/Jek/eabZe0XdLb0GdvQ5+9DX3qXpP3mrzX5L0m7zV5r8l7Td5r8l6T95q619S9pu41ea/Je03ea/Jec+ySsUtmG/qcbehztqFP3WvyXpP3mrzX5L0m7zV5r8l7Td5r8l5T95q619S9Ju81ea/Je03ea45dMnbJbEOfsw19zjb0qXtN3mvyXpP3mrzX5L0m7zV5r8l7Td5r6l5T95q61+S9Ju81ea/Je82xS8YumW3oc7ahz9mGPnWvyXtN3mvyXpP3mrzX5L0m7zV5r8l7Td1r6l5T95q81+S9Ju81ea85dsnYJbMNfc429Dnb0KfuNXmvyXtN3mvyXpP3mrzX5L0m7zV5r6l7Td1r6l6T95q81+S9Ju81xy4Zu2S2oc/Zhj5nG/rUvSbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K91m93Sf12l9RvG/r6bUNfv23oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91q/3SX1211Sv23o67cNff22oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5r/XaX1G93Sf22oa/fNvT124a+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4r/Vr/wLav4Bt6Ou3DX39tqEv3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3ea327S+rbXVLfNvT1bUNf3zb0pXst3mvxXov3WrzX4r0W77V4r8V7Ld5r6V5L91q61+K9Fu+1eK/Fe61vd0l9u0vq24a+vm3o69uGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK/17S6pb3dJfdvQ17cNfX3b0JfutXivxXst3mvxXov3WrzX4r0W77V4r6V7Ld1r6V6L91q81+K9Fu+1vvQvoPwL2Ia+vm3o69uGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK/1jX8B41/ANvT1bUNf3zb0pXst3mvxXov3WrzX4r0W77V4r8V7Ld5r6V5L91q61+K9Fu+1eK/Fe62wS8IuiW3oK7ahr9iGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK8VdknYJbENfcU29BXb0JfutXivxXst3mvxXov3WrzX4r0W77V4r6V7Ld1r6V6L91q81+K9Fu+1wi4JuyS2oa/Yhr5iG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K9VtglYZfENvQV29BXbENfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q81zp2ybFLzjb0dbahr7MNfelei/davNfivRbvtXivxXst3mvxXov3WrrX0r2W7rV4r8V7Ld5r8V7r2CXHLjnb0NfZhr7ONvSley3ea/Fei/davNfivRbvtXivxXst3mvpXkv3WrrX4r0W77V4r8V7rWOXHLvkbENfZxv6OtvQl+61eK/Fey3ea/Fei/davNfivRbvtXivpXst3WvpXov3WrzX4r0W77WOXXLskrMNfZ1t6OtsQ1+61+K9Fu+1eK/Fey3ea/Fei/davNfivZbutXSvpXst3mvxXov3WrzXOnbJsUvONvR1tqGvsw196V6L91q81+K9Fu+1eK/Fey3ea/Fei/dautfSvZbutXivxXst3mvxXuvaJdcuudvQ192Gvu429KV7Ld5r8V6L91q81+K9Fu+1eK/Fey3ea+leS/dautfivRbvtXivxXuta5dcu+RuQ193G/q629CX7rV4r8V7Ld5r8V6L91q81+K9Fu+1eK+ley3da+lei/davNfivRbvta5dcu2Suw193W3o625DX7rX4r0W77V4r8V7Ld5r8V6L91q81+K9lu61dK+ley3ea/Fei/davNe6dsm1S+429HW3oa+7DX3pXov3WrzX4r0W77V4r8V7Ld5r8V6L91q619K9lu61eK/Fey3ea/Fe69olzy5529DX24a+3jb0pXst3mvxXov3WrzX4r0W77V4r8V7Ld5r6V5L91q61+K9Fu+1eK/Fe61nlzy75G1DX28b+nrb0JfutXivxXst3mvxXov3WrzX4r0W77V4r6V7Ld1r6V6L91q81+K9Fu+1nl3y7JK3DX29bejrbUNfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q813p2ybNL3jb09bahr7cNfelei/davNfivRbvtXivxXst3mvxXov3WrrX0r2W7rV4r8V7Ld5r8V7r2SXPLnnb0Nfbhr7eNvSley3ea/Fei/davNfivRbvtXivxXst3mvpXkv3WrrX4r0W77V4r8V7rbRL0i7Jbegrt6Gv3Ia+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4r5V2SdoluQ195Tb0ldvQl+61eK/Fey3ea/Fei/davNfivRbvtXivpXst3WvpXov3WrzX4r0W77XSLkm7JLehr9yGvnIb+tK9Fu+1eK/Fey3ea/Fei/davNfivRbvtXSvpXst3WvxXov3WrzX4r1W2iVpl+Q29JXb0FduQ1+61+K9Fu+1eK/Fey3ea/Fei/davNfivZbutXSvpXst3mvxXov3WrzXSrsk7ZLchr5qG/qqbehL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3WmWXlF1S29BXbUNftQ196V6L91q81+K9Fu+1eK/Fey3ea/Fei/dautfSvZbutXivxXst3mvxXqvskrJLahv6qm3oq7ahL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3muVXVJ2SW1DX7UNfdU29KV7Ld5r8V6L91q81+K9Fu+1eK/Fey3ea+leS/dautfivRbvtXivxXutskvKLqlt6Ku2oa/ahr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXiv1XZJ2yW9DX31NvTV29CX7rV4r8V7Ld5r8V6L91q81+K9Fu+1eK+ley3da+lei/davNfivRbvtdouabukt6Gv3oa+ehv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivVbbJW2X9Db01dvQV29DX7rX4r0W77V4r8V7Ld5r8V6L91q81+K9lu61dK+ley3ea/Fei/davNdqu6Ttkt6Gvnob+upt6Ev3WrzX4r0W77V4r8V7Ld5r8V6L91q819K9lu61dK/Fey3ea/Fei/dabZe0XdLb0FdvQ1+9DX3pXov3WrzX4r0W77V4r8V7Ld5r8V6L91q619K9lu61eK/Fey3ea/Fea+ySsUtmG/qabehrtqEv3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3ea41dMnbJbENfsw19zTb0pXst3mvxXov3WrzX4r0W77V4r8V7Ld5r6V5L91q61+K9Fu+1eK/Fe62xS8YumW3oa7ahr9mGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK81dsnYJbMNfc029DXb0JfutXivxXst3mvxXov3WrzX4r0W77V4r6V7Ld1r616b99q81+a9Nu+1f7tL+re7pH/b0PdvG/r+bUPfutfmvTbvtXmvzXtt3mvzXpv32rzX5r227rV1r617bd5r816b99q81/7tLunf7pL+bUPfv23o+7cNfetem/favNfmvTbvtXmvzXtt3mvzXpv32rrX1r227rV5r817bd5r8177t7ukf7tL+rcNff+2oe/fNvSte23ea/Nem/favNfmvTbvtXmvzXtt3mvrXlv32rrX5r0277V5r8177V/5F1D+BWxD379t6Pu3DX3rXpv32rzX5r0277V5r817bd5r816b99q619a9tu61ea/Ne23ea/Ne+zf+BYx/AdvQ928b+v5tQ9+61+a9Nu+1ea/Ne23ea/Nem/favNfmvbbutXWvrXtt3mvzXpv32rzX/naX9Le7pL9t6Pvbhr6/behb99q81+a9Nu+1ea/Ne23ea/Nem/favNfWvbbutXWvzXtt3mvzXpv32t/ukv52l/S3DX1/29D3tw19616b99q81+a9Nu+1ea/Ne23ea/Nem/fautfWvbbutXmvzXtt3mvzXvvbXdLf7pL+tqHvbxv6/rahb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3mt/7V9A+xewDX1/29D3tw19616b99q81+a9Nu+1ea/Ne23ea/Nem/fautfWvbbutXmvzXtt3mvzXjvskrBLYhv6jm3oO7ahb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3muHXRJ2SWxD37ENfcc29K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvtsEvCLolt6Du2oe/Yhr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmvHXZJ2CWxDX3HNvQd29C37rV5r817bd5r816b99q81+a9Nu+1ea+te23da+tem/favNfmvTbvtcMuCbsktqHv2Ia+Yxv61r0277V5r817bd5r816b99q81+a9Nu+1da+te23da/Nem/favNfmvfaxS45dcrah77MNfZ9t6Fv32rzX5r0277V5r817bd5r816b99q819a9tu61da/Ne23ea/Nem/faxy45dsnZhr7PNvR9tqFv3WvzXpv32rzX5r0277V5r817bd5r815b99q619a9Nu+1ea/Ne23eax+75NglZxv6PtvQ99mGvnWvzXtt3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea997JJjl5xt6PtsQ99nG/rWvTbvtXmvzXtt3mvzXpv32rzX5r0277V1r617bd1r816b99q81+a99rVLrl1yt6Hvuw19323oW/favNfmvTbvtXmvzXtt3mvzXpv32rzX1r227rV1r817bd5r816b99rXLrl2yd2Gvu829H23oW/da/Nem/favNfmvTbvtXmvzXtt3mvzXlv32rrX1r0277V5r817bd5rX7vk2iV3G/q+29D33Ya+da/Ne23ea/Nem/favNfmvTbvtXmvzXtt3WvrXlv32rzX5r0277V5r33tkmuX3G3o+25D33cb+ta9Nu+1ea/Ne23ea/Nem/favNfmvTbvtXWvrXtt3WvzXpv32rzX5r32tUuuXXK3oe+7DX3fbehb99q81+a9Nu+1ea/Ne23ea/Nem/favNfWvbbutXWvzXtt3mvzXpv32s8ueXbJ24a+3zb0/bahb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3ms/u+TZJW8b+n7b0Pfbhr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmv/eySZ5e8bej7bUPfbxv61r0277V5r817bd5r816b99q81+a9Nu+1da+te23da/Nem/favNfmvfazS55d8rah77cNfb9t6Fv32rzX5r0277V5r817bd5r816b99q819a9tu61da/Ne23ea/Nem/fazy5JuyS3oe/chr5zG/rWvTbvtXmvzXtt3mvzXpv32rzX5r0277V1r617bd1r816b99q81+a9dtolaZfkNvSd29B3bkPfutfmvTbvtXmvzXtt3mvzXpv32rzX5r227rV1r617bd5r816b99q81067JO2S3Ia+cxv6zm3oW/favNfmvTbvtXmvzXtt3mvzXpv32rzX1r227rV1r817bd5r816b99ppl6RdktvQd25D37kNfetem/favNfmvTbvtXmvzXtt3mvzXpv32rrX1r227rV5r817bd5r81477ZK0S3Ib+s5t6Du3oW/da/Nem/favNfmvTbvtXmvzXtt3mvzXlv32rrX1r0277V5r817bd5rl11SdkltQ9+1DX3XNvSte23ea/Nem/favNfmvTbvtXmvzXtt3mvrXlv32rrX5r0277V5r8177bJLyi6pbei7tqHv2oa+da/Ne23ea/Nem/favNfmvTbvtXmvzXtt3WvrXlv32rzX5r0277V5r112SdkltQ191zb0XdvQt+61ea/Ne23ea/Nem/favNfmvTbvtXmvrXtt3WvrXpv32rzX5r0277XLLim7pLah79qGvmsb+ta9Nu+1ea/Ne23ea/Nem/favNfmvTbvtXWvrXtt3WvzXpv32rzX5r122SVll9Q29N3b0HdvQ9+61+a9Nu+1ea/Ne23ea/Nem/favNfmvbbutXWvrXtt3mvzXpv32rzXbruk7ZLehr57G/rubehb99q81+a9Nu+1ea/Ne23ea/Nem/favNfWvbbutXWvzXtt3mvzXpv32m2XtF3S29B3b0PfvQ19616b99q81+a9Nu+1ea/Ne23ea/Nem/fautfWvbbutXmvzXtt3mvzXrvtkrZLehv67m3ou7ehb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3mu3XdJ2SW9D370Nffc29K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvtsUvGLplt6Hu2oe/Zhr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmvPXbJ2CWzDX3PNvQ929C37rV5r817bd5r816b99q81+a9Nu+1ea+te23da+tem/favNfmvTbvtccuGbtktqHv2Ya+Zxv61r0277V5r817bd5r816b99q81+a9Nu+1da+te23da/Nem/favNfmvfbYJWOXzDb0PdvQ92xD37rX5r0277V5r817bd5r816b99q81+a9tu61da+te23ea/Nem/favNceu2TsktmGvmcb+p5t6Ef3OrzX4b0O73V4r8N7Hd7r8F6H9zq819G9ju51dK/Dex3e6/Beh/c6v90l89tdMr9t6Oe3Df38tqEf3evwXof3OrzX4b0O73V4r8N7Hd7r8F5H9zq619G9Du91eK/Dex3e6/x2l8xvd8n8tqGf3zb089uGfnSvw3sd3uvwXof3OrzX4b0O73V4r8N7Hd3r6F5H9zq81+G9Du91eK/z210yv90l89uGfn7b0M9vG/rRvQ7vdXivw3sd3uvwXof3OrzX4b0O73V0r6N7Hd3r8F6H9zq81+G9zq/9C2j/Arahn9829PPbhn50r8N7Hd7r8F6H9zq81+G9Du91eK/Dex3d6+heR/c6vNfhvQ7vdXiv8+0umW93yXzb0M+3Df1829CP7nV4r8N7Hd7r8F6H9zq81+G9Du91eK+jex3d6+heh/c6vNfhvQ7vdb7dJfPtLpn/utf/XrwN/Xzb0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du91vt0l8+0umW8b+vm2oZ9vG/rRvQ7vdXivw3sd3uvwXof3OrzX4b0O73V0r6N7Hd3r8F6H9zq81+G9zlf+BZR/AdvQz7cN/Xzb0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du91vvEvYPwL2IZ+vm3o59uGfnSvw3sd3uvwXof3OrzX4b0O73V4r8N7Hd3r6F5H9zq81+G9Du91eK8TdknYJbEN/cQ29BPb0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du91wi4JuyS2oZ/Yhn5iG/rRvQ7vdXivw3sd3uvwXof3OrzX4b0O73V0r6N7Hd3r8F6H9zq81+G9TtglYZfENvQT29BPbEM/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq81wm7JOyS2IZ+Yhv6iW3oR/c6vNfhvQ7vdXivw3sd3uvwXof3OrzX0b2O7nV0r8N7Hd7r8F6H9zrHLjl2ydmGfs429HO2oR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7rHLvk2CVnG/o529DPf93rfy92S3ivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du91jl1y7JKzDf2cbejnbEM/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq81zl2ybFLzjb0c7ahn7MN/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F7n2CXHLjnb0M/Zhn7ONvSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nWuXXLvkbkM/dxv6udvQj+51eK/Dex3e6/Beh/c6vNfhvQ7vdXivo3sd3evoXof3OrzX4b0O73WuXXLtkrsN/dxt6OduQz+61+G9Du91eK/Dex3e6/Beh/c6vNfhvY7udXSvo3sd3uvwXof3OrzXuXbJtUvuNvRzt6Gfuw396F6H9zq81+G9Du91eK/Dex3e6/Beh/c6utfRvY7udXivw3sd3uvwXufaJdcuudvQz92Gfu429KN7Hd7r8F6H9zq81+G9Du91eK/Dex3e6+heR/c6utfhvQ7vdXivw3udZ5c8u+RtQz9vG/p529CP7nV4r8N7Hd7r8F6H9zq81+G9Du91eK+jex3d6+heh/c6vNfhvQ7vdZ5d8uyStw39vG3o521DP7rX4b0O73V4r8N7Hd7r8F6H9zq81+G9ju51dK+jex3e6/Beh/c6vNd5dsmzS9429PO2oZ+3Df3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/Be59klzy5529DP24Z+3jb0o3sd3uvwXof3OrzX4b0O73V4r8N7Hd7r6F5H9zq61+G9Du91eK/De51nlzy75G1DP28b+nnb0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du910i5JuyS3oZ/chn5yG/rRvQ7vdXivw3sd3uvwXof3OrzX4b0O73V0r6N7Hd3r8F6H9zq81+G9TtolaZfkNvST29BPbkM/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq810m7JO2S3IZ+chv6yW3oR/c6vNfhvQ7vdXivw3sd3uvwXof3OrzX0b2O7nV0r8N7Hd7r8F6H9zppl6RdktvQT25DP7kN/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F4n7ZKyS2ob+qlt6Ke2oR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7rlF1SdkltQz+1Df3UNvSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nbJLyi6pbeintqGf2oZ+dK/Dex3e6/Beh/c6vNfhvQ7vdXivw3sd3evoXkf3OrzX4b0O73V4r1N2SdkltQ391Db0U9vQj+51eK/Dex3e6/Beh/c6vNfhvQ7vdXivo3sd3evoXof3OrzX4b0O73XKLim7pLahn9qGfmob+tG9Du91eK/Dex3e6/Beh/c6vNfhvQ7vdXSvo3sd3evwXof3OrzX4b1O2yVtl/Q29NPb0E9vQz+61+G9Du91eK/Dex3e6/Beh/c6vNfhvY7udXSvo3sd3uvwXof3OrzXabuk7ZLehn56G/rpbehH9zq81+G9Du91eK/Dex3e6/Beh/c6vNfRvY7udXSvw3sd3uvwXof3Om2XtF3S29BPb0M/vQ396F6H9zq81+G9Du91eK/Dex3e6/Beh/c6utfRvY7udXivw3sd3uvwXqftkrZLehv66W3op7ehH93r8F6H9zq81+G9Du91eK/Dex3e6/BeR/c6utfRvQ7vdXivw3sd3uu0XdJ2SW9DP7MN/cw29KN7Hd7r8F6H9zq81+G9Du91eK/Dex3e6+heR/c6utfhvQ7vdXivw3udsUvGLplt6Ge2oZ/Zhn50r8N7Hd7r8F6H9zq81+G9Du91eK/Dex3d6+heR/c6vNfhvQ7vdXivM3bJ2CWzDf3MNvQz29CP7nV4r8N7Hd7r8F6H9zq81+G9Du91eK+jex3d6+heh/c6vNfhvQ7vdcYuGbtktqGf2YZ+Zhv60b0O73V4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvc7YJWOXzDb0M9vQz2xDP7rX4b0O73V4r8N7Hd7r8F6H9zq811nvNX7bvf75/HyGz39v+/N5fT6f6bN8ts9/l+v/P//X0P/5/He5/nz6a/+7JX8+r8/nM32Wz/bpbeFt4W3hr4W/Fv5aeFt4W3hbeNv/dsn/f/5vl/z5/PbF/2vo/3yeffHx1463HW873na87Xjb9bbrbdfbrrddf+36a9dfu952ve162/O2/+2SP5/h8+yL/9fQ//l8++Lnrz1ve972vC29Lb0tvS29Lb0tvS39tfTX0l9LbytvK28rbyv/Asq/gP819H8+c1/8v4b+z6e/Vt7W3tbe1t7W3tbe1t7W3tbe1v5a+2vjr423jbeNt423jX8B41/A/xr6P5+9L/5fQx+/zy353JLPLVnv9c/n9fl8ps/y2T73bdu9/vn019yS9V7/fF6fz2f6LJ/tcy/XF3u5vtjL9bkln1vyuSXrvf759LbwtvC28Lbjbcfbjr92/DW3ZL3XP5/edrzteNvZfwHf/fncy/XdvVzf3cv1uSWfW/K5Jeu9/vn0tuttz9uetz1ve972/LXnr7kl673++fS2523pbfn5DJ97ub7cy/XlXq7PLfncks8tWe/1/z/L28rbytvK28rbytvKXyt/zS1Z7/X/P9vb2tva29q/gPYvoPdyfb2X6+u9XJ9b8rkln1uy3uufT28bbxtvG28bbxtvG3/NLgm3ZL3XP5/h8/i8Pp/P9LmXK357ueK3lyvcknBLwi0JuyTskrBLwi4JuyTskrBLwi4JuyTckvVe/3x6m10SdknYJWGXROzlirOXK85ernBLwi0JtyTskrBLwi4JuyTskrBLwi4JuyTsknBL1nv98+ltdknYJWGXhF0Sby9XvL1c8fZyhVsSbkm4JWGXhF0SdknYJWGXhF0SdknYJWGXhFuy3uufT2+zS8IuCbsk7JKovVxRe7mi9nKFWxJuSbglYZeEXRJ2SdglYZeEXRJ2SdglYZeEW7Le6/9/jrfZJWGXhF0SdknMXq6YvVwxe7nCLQm35Lglxy45dsmxS45dcuySY5ccu+TYJccuOW7Jeq9/PsPn8Xl9Pp/pcy/X+fZynW8v13FLjlty3JJjlxy75Nglxy45dsmxS45dcuySY5cct2S91z+f3maXHLvk2CXHLjlnL9e5e7nO3ct13JLjlhy35Nglxy45dsmxS45dcuySY5ccu+TYJcctWe/1z6e32SXHLjl2ybFLTu7lOrmX6+ReruOWHLfkuCXHLjl2ybFLjl1y7JJjlxy75Nglxy45bsl6r38+vc0uOXbJsUuOXXJ6L9fpvVyn93Idt+S4JcctOXbJsUuOXXLskmOXHLvk2CXHLjl2yXFL1nv9/6Xx+/n8fIbP4/P63Mt1f3u57m8v13VLrlty3ZJrl1y75Nol1y65dsm1S65dcu2Sa5dct2S91z+f3maXXLvk2iXXLrmxl+vGXq4be7muW3LdkuuWXLvk2iXXLrl2ybVLrl1y7ZJrl1y75Lol673++fQ2u+TaJdcuuXbJvXu57tvLdd9eruuWXLfkuiXXLrl2ybVLrl1y7ZJrl1y75Nol1y65bsl6r38+vc0uuXbJtUuuXXJrL9etvVy39nJdt+S6JdctuXbJtUuuXXLtkmuXXLvk2iXXLrl2yXVL1nv98+ltdsm1S65dcu2SO3u57uzlurOX67ol1y25bsm1S55d8uySZ5c8u+TZJc8ueXbJs0ueW7Le6/9/fj+fn8/weXxen3u53reX6317uZ5b8tyS55Y8u+TZJc8ueXbJs0ueXfLskmeXPLvkuSXrvf759Da75Nklzy55dsk7e7ne2cv1zl6u55Y8t+S5Jc8ueXbJs0ueXfLskmeXPLvk2SXPLnluyXqvfz69zS55dsmzS55d8t5erpd7uV7u5XpuyXNLnlvy7JJnlzy75Nklzy55dsmzS55d8uyS55as9/rn09vskmeXPLvk2SWv93K93sv1ei/Xc0ueW/LckmeXPLvk2SXPLnl2ybNLnl3y7JJnlzy3ZL3XP5/eZpekXZJ2Sdol+dvLlb+9XPnby5VuSbol6ZakXZJ2SdolaZekXZJ2SdolaZekXZJuyXqv//8Z3maXpF2SdknaJRl7uTL2cmXs5Uq3JN2SdEvSLkm7JO2StEvSLkm7JO2StEvSLkm3ZL3XP5/eZpekXZJ2Sdolefdy5d3LlXcvV7ol6ZakW5J2SdolaZekXZJ2SdolaZekXZJ2Sbol673++fQ2uyTtkrRL0i7J3MuVtZcray9XuiXplqRbknZJ2iVpl6RdknZJ2iVpl6RdknZJuiXrvf759Da7JO2StEvSLsnZy5WzlytnL1e6JemWpFuSdknaJWmXlF1SdknZJWWXlF1Sdkm5JeU34fKbcNklZZeUXVJ2SX17uerby1XfXq5yS8otKbek7JKyS8ouKbuk7JKyS8ouKbuk7JJyS8pvwuU34bJLyi4pu6Tskjp7uers5aqzl6vcknJLyi0pu6TskrJLyi4pu6TskrJLyi4pu6TckvKbcPlNuOySskvKLim7pN5ernp7uert5Sq3pNySckvKLim7pOySskvKLim7pOySskvKLim3pPwmXH4TLruk7JKyS8ouqdrLVb2Xq3ovV7kl5ZaUW1J2SdklZZeUXVJ2SdklZZeUXVJ2Sbkl5Tfh8ptw2SVll5Rd0nZJ//Zy9W8vV//2crVb0m5JuyVtl7Rd0nZJ2yVtl7Rd0nZJ2yVtl7Rb0n4Tbr8Jt13SdknbJW2XdOzl6tjL1bGXq92SdkvaLWm7pO2StkvaLmm7pO2StkvaLmm7pN2S9ptw+0247ZK2S9ouabuk716uvnu5+u7larek3ZJ2S9ouabuk7ZK2S9ouabuk7ZK2S9ouabek/SbcfhNuu6TtkrZL2i7p3MvVuZercy9XuyXtlrRb0nZJ2yVtl7Rd0nZJ2yVtl7Rd0nZJuyXtN+H2m3DbJW2XtF3Sdkn3Xq6evVw9e7naLWm3pN2StkvaLmm7pO2StkvGLhm7ZOySsUvGLRm/CY/fhMcuGbtk7JKxS+bbyzXfXq759nKNWzJuybglY5eMXTJ2ydglY5eMXTJ2ydglY5eMWzJ+Ex6/CY9dMnbJ2CVjl8zZyzVnL9ecvVzjloxbMm7J2CVjl4xdMnbJ2CVjl4xdMnbJ2CXjlozfhMdvwmOXjF0ydsnYJfP2cs3byzVvL9e4JeOWjFsydsnYJWOXjF0ydsnYJWOXjF0ydsm4JeM34fGb8NglY5eMXTJ2ydRerqm9XFN7ucYtGbdk3JKxS8YuGbtk7JKxS8YuGbtk7JKxS8YtGb8Jj9+Exy4Zu2TskrFL5n8NfXy//zX0fz7/d7k+3eu33uufz+vz+Uyf5bN9zn7uLvnWe/3z6a99/trnr+1vwt96r38+y2f7nP3cXfL9/tfQ//mMffH/Gvo/n/5aeFt4W3hbeFt42/G2423H2463HX/t+GvHXzvedrzteNv1tt0l3293yff7X0P/5/Pui//X0P/59Neut11vu972vO152/O2523P2563PX/t+WvPX3velt6W3pbetrvk++0u+X7/a+j/fOa++H8N/Z9Pfy29rbytvK28rbytvK28rbytvK38tfLX2l9rb2tva29rb2v/Atq/gP819H8+e1/8v4b+/z/HXxtvG28bbxtvG28bbxtvG2/bXfLpXj/d66d7/dZ7/fN5fT6f6bN8ts+9XN829N+3Df2ne/0+t+RzS9Z7/fOZPstn+/S28LbwtvDXwl9zS9Z7/fPpbeFt4W27S75vd8n3bUP/fdvQf9829J/u9fvcks8tWe/1z6e3HW+73na97Xrb9bbrr11/zS1Z7/XPp7ddb3vetrvk+3aXfN829N+3Df33bUP/6V6/zy353JL1Xv//M70tvS29Lb0tvS29Lf219NfckvVe//+zvK28rbyt/Aso/wK2of++bei/bxv6T/f6fW7J55as9/rn09va29rb2tva29rb2l9rf80tWe/1z6e3jbeNt41/AeNfwDb037cN/fdtQ//pXr9wS8ItCbsk7JKwS8IuCbsk7JKwS3Svn+71071+673++bw+n8/0WT7b516u2Ib+i23oP93rF25JuCVhl4RdEnZJ2CVhl4RdEnaJ7vXTvX6612+91z+f3maXhF0SdknYJbEN/Rfb0H+xDf2ne/3CLQm3JOySsEvCLgm7JOySsEvCLtG9frrXT/f6rff659Pb7JKwS8IuCbsktqH/Yhv6L7ah/3SvX7gl4ZaEXRJ2SdglYZeEXRJ2SdglutdP9/rpXr/1Xv//s73NLgm7JOySsEtiG/ovtqH/Yhv6T/f6hVsSbknYJWGXhF0SdknYJWGXhF2ie/10r5/u9Vvv9c9n+Dw+r8/nM33u5Trb0H9nG/pP9/odt+S4JccuOXbJsUuOXXLskmOXHLtE9/rpXj/d67fe659Pb7NLjl1y7JJjl5xt6L+zDf13tqH/dK/fcUuOW3LskmOXHLvk2CXHLjl2ybFLdK+f7vXTvX7rvf759Da75Nglxy45dsnZhv4729B/Zxv6T/f6HbfkuCXHLjl2ybFLjl1y7JJjlxy7RPf66V4/3eu33uufT2+zS45dcuySY5ecbei/sw39d7ah/3Sv33FLjlty7JJjlxy75Nglxy45dsmxS3Svn+71071+673+/+d4m11y7JJjlxy75GxD/51t6L+zDf2ne/2OW3LdkmuXXLvk2iXXLrl2ybVLrl2ie/10r5/u9Vvv9c9n+Dw+r8/nM33u5brb0H93G/pP9/pdt+S6JdcuuXbJtUuuXXLtkmuXXLtE9/rpXj/d67fe659Pb7NLrl1y7ZJrl9xt6L+7Df13t6H/dK/fdUuuW3LtkmuXXLvk2iXXLrl2ybVLdK+f7vXTvX7rvf759Da75Nol1y65dsndhv6729B/dxv6T/f6XbfkuiXXLrl2ybVLrl1y7ZJrl1y7RPf66V4/3eu33uufT2+zS65dcu2Sa5fcbei/uw39d7eh/3Sv33VLrlty7ZJrl1y75Nol1y65dsm1S3Svn+71071+673+//952N+Ev2eXPLvk2SXPLnnb0H9vG/rvbUP/6V6/55Y8t+TZJc8ueXbJs0ueXfLskmeX6F4/3eune/3We/3z6W12ybNLnl3y7JK3Df33tqH/3jb0n+71e27Jc0ueXfLskmeXPLvk2SXPLnl2ie71071+utdvvdc/n95mlzy75Nklzy5529B/bxv6721D/+lev+eWPLfk2SXPLnl2ybNLnl3y7JJnl+heP93rp3v91nv98+ltdsmzS55d8uyStw3997ah/9429J/u9XtuyXNLnl3y7JJnlzy75Nklzy55donu9dO9frrXb73XP5/eZpc8u+TZJc8uedvQf28b+u9tQ//pXr/nljy35NklaZekXZJ2SdolaZekXaJ7/XSvn+71W+/1/z/3N+Ev7ZK0S9IuSbskt6H/chv6L7eh/3SvX7ol6ZakXZJ2SdolaZekXZJ2SdolutdP9/rpXr/1Xv98eptdknZJ2iVpl+Q29F9uQ//lNvSf7vVLtyTdkrRL0i5JuyTtkrRL0i5Ju0T3+uleP93rt97rn09vs0vSLkm7JO2S3Ib+y23ov9yG/tO9fumWpFuSdknaJWmXpF2SdknaJWmX6F4/3eune/3We/3z6W12SdolaZekXZLb0H+5Df2X29B/utcv3ZJ0S9IuSbsk7ZK0S9IuSbsk7RLd66d7/XSv33qvfz69zS4pu6TskrJLahv6r7ah/2ob+k/3+pVbUm5J2SVll5RdUnZJ2SVll5Rdonv9dK+f7vUrvwmX34TLLim7pOySsktqG/qvtqH/ahv6T/f6lVtSbknZJWWXlF1SdknZJWWXlF2ie/10r5/u9Su/CZffhMsuKbuk7JKyS2ob+q+2of9qG/pP9/qVW1JuSdklZZeUXVJ2SdklZZeUXaJ7/XSvn+71K78Jl9+Eyy4pu6TskrJLahv6r7ah/2ob+k/3+pVbUm5J2SVll5RdUnZJ2SVll5Rdonv9dK+f7vUrvwmX34TLLim7pOySsktqG/qvtqH/ahv6T/f6lVtSbknZJWWXlF3SdknbJW2XtF2ie/10r5/u9Wu/CbffhNsuabuk7ZK2S3ob+q+3of96G/pP9/q1W9JuSdslbZe0XdJ2SdslbZe0XaJ7/XSvn+71a78Jt9+E2y5pu6TtkrZLehv6r7eh/3ob+k/3+rVb0m5J2yVtl7Rd0nZJ2yVtl7Rdonv9dK+f7vVrvwm334TbLmm7pO2Stkt6G/qvt6H/ehv6T/f6tVvSbknbJW2XtF3SdknbJW2XtF2ie/10r5/u9Wu/CbffhNsuabuk7ZK2S3ob+q+3of96G/pP9/q1W9JuSdslbZe0XdJ2SdslbZe0XaJ7/XSvn+71a78Jt9+E2y5pu6TtkrFLZhv6b7ah/2Yb+k/3+o1bMm7J2CVjl4xdMnbJ2CVjl4xdonv9dK+f7vUbvwmP34THLhm7ZOySsUtmG/pvtqH/Zhv6T/f6jVsybsnYJWOXjF0ydsnYJWOXjF2ie/10r5/u9Ru/CY/fhMcuGbtk7JKxS2Yb+m+2of9mG/pP9/qNWzJuydglY5eMXTJ2ydglY5eMXaJ7/XSvn+71G78Jj9+Exy4Zu2TskrFLZhv6b7ah/2Yb+k/3+o1bMm7J2CVjl4xdMnbJ2CVjl4xdonv9dK+f7vUbvwmP34THLhm7ZOySsUtmG/pvtqH/Zhv6T/f6jVsybsnYJWOXjF0ydgnvNXivwXsN3WvoXkP3GrzX4L0G7zV4r/HbXRK/3SXx24Y+ftvQx28b+tC9Bu81eK/Bew3ea/Beg/cavNfgvQbvNXSvoXsN3WvwXoP3GrzX4L3Gb3dJ/HaXxG8b+vhtQx+/behD9xq81+C9Bu81eK/Bew3ea/Beg/cavNfQvYbuNXSvwXsN3mvwXoP3Gr/dJfHbXRK/bejjtw19/LahD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3mv8yr+A8i9gG/r4bUMfv23oQ/cavNfgvQbvNXivwXsN3mvwXoP3GrzX0L2G7jV0r8F7Dd5r8F6D9xq/8S9g/AvYhj6+bejj24Y+dK/Bew3ea/Beg/cavNfgvQbvNXivwXsN3WvoXkP3GrzX4L0G7zV4r/HtLolvd0l829DHtw19fNvQh+41eK/Bew3ea/Beg/cavNfgvQbvNXivoXsN3WvoXoP3GrzX4L0G7zW+3SXx7S6Jbxv6+Lahj28b+tC9Bu81eK/Bew3ea/Beg/cavNfgvQbvNXSvoXsN3WvwXoP3GrzX4L3Gt7skvt0l8W1DH9829PFtQx+61+C9Bu81eK/Bew3ea/Beg/cavNfgvYbuNXSvoXsN3mvwXoP3GrzX+Nq/gPYvYBv6+Lahj28b+tC9Bu81eK/Bew3ea/Beg/cavNfgvQbvNXSvoXsN3WvwXoP3GrzX4L1G2CVhl8Q29BHb0EdsQx+61+C9Bu81eK/Bew3ea/Beg/cavNfgvYbuNXSvoXsN3mvwXoP3GrzXCLsk7JLYhj5iG/qIbehD9xq81+C9Bu81eK/Bew3ea/Beg/cavNfQvYbuNXSvwXsN3mvwXoP3GmGXhF0S29BHbEMfsQ196F6D9xq81+C9Bu81eK/Bew3ea/Beg/cautfQvYbuNXivwXsN3mvwXiPskrBLYhv6iG3oI7ahD91r8F6D9xq81+C9Bu81eK/Bew3ea/BeQ/cautfQvQbvNXivwXsN3muEXRJ2SWxDH7ENfcQ29KF7Dd5r8F6D9xq81+C9Bu81eK/Bew3ea+heQ/cautfgvQbvNXivwXuNY5ccu+RsQx9nG/o429CH7jV4r8F7Dd5r8F6D9xq81+C9Bu81eK+hew3da+heg/cavNfgvQbvNY5dcuySsw19nG3o42xDH7rX4L0G7zV4r8F7Dd5r8F6D9xq81+C9hu41dK+hew3ea/Beg/cavNc4dsmxS8429HG2oY+zDX3oXoP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq619C9hu41eK/Bew3ea/Be49glxy4529DH2YY+zjb0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be41rl1y75G5DH3cb+rjb0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81rl1y7ZK7DX3cbejjbkMfutfgvQbvNXivwXsN3mvwXoP3GrzX4L2G7jV0r6F7Dd5r8F6D9xq817h2ybVL7jb0cbehj7sNfeheg/cavNfgvQbvNXivwXsN3mvwXoP3GrrX0L2G7jV4r8F7Dd5r8F7j2iXXLrnb0Mfdhj7uNvShew3ea/Beg/cavNfgvQbvNXivwXsN3mvoXkP3GrrX4L0G7zV4r8F7jWuXXLvkbkMfdxv6uNvQh+41eK/Bew3ea/Beg/cavNfgvQbvNXivoXsN3WvoXoP3GrzX4L0G7zWeXfLskrcNfbxt6ONtQx+61+C9Bu81eK/Bew3ea/Beg/cavNfgvYbuNXSvoXsN3mvwXoP3GrzXeHbJs0veNvTxtqGPtw196F6D9xq81+C9Bu81eK/Bew3ea/Beg/cautfQvYbuNXivwXsN3mvwXuPZJc8uedvQx9uGPt429KF7Dd5r8F6D9xq81+C9Bu81eK/Bew3ea+heQ/cautfgvQbvNXivwXuNZ5c8u+RtQx9vG/p429CH7jV4r8F7Dd5r8F6D9xq81+C9Bu81eK+hew3da+heg/cavNfgvQbvNdIuSbskt6GP3IY+chv60L0G7zV4r8F7Dd5r8F6D9xq81+C9Bu81dK+hew3da/Beg/cavNfgvUbaJWmX5Db0kdvQR25DH7rX4L0G7zV4r8F7Dd5r8F6D9xq81+C9hu41dK+hew3ea/Beg/cavNdIuyTtktyGPnIb+sht6EP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq819C9hu41dK/Bew3ea/Beg/caaZekXZLb0EduQx+5DX3oXoP3GrzX4L0G7zV4r8F7Dd5r8F6D9xq619C9hu41eK/Bew3ea/BeI+2StEtyG/rIbegjt6EP3WvwXoP3GrzX4L0G7zV4r8F7Dd5r8F5D9xq619C9Bu81eK/Bew3ea5RdUnZJbUMftQ191Db0oXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd5r6F5D9xq61+C9Bu81eK/Be42yS8ouqW3oo7ahj9qGPnSvwXsN3mvwXoP3GrzX4L0G7zV4r8F7Dd1r6F5D9xq81+C9Bu81eK9RdknZJbUNfdQ29FHb0IfuNXivwXsN3mvwXoP3GrzX4L0G7zV4r6F7Dd1r6F6D9xq81+C9Bu81yi4pu6S2oY/ahj5qG/rQvQbvNXivwXsN3mvwXoP3GrzX4L0G7zV0r6F7Dd1r8F6D9xq81+C9RtslbZf0NvTR29BHb0MfutfgvQbvNXivwXsN3mvwXoP3GrzX4L2G7jV0r6F7Dd5r8F6D9xq812i7pO2S3oY+ehv66G3oQ/cavNfgvQbvNXivwXsN3mvwXoP3GrzX0L2G7jV0r8F7Dd5r8F6D9xptl7Rd0tvQR29DH70Nfeheg/cavNfgvQbvNXivwXsN3mvwXoP3GrrX0L2G7jV4r8F7Dd5r8F6j7ZK2S3ob+uht6KO3oQ/da/Beg/cavNfgvQbvNXivwXsN3mvwXkP3GrrX0L0G7zV4r8F7Dd5rtF3SdklvQx+9DX30NvShew3ea/Beg/cavNfgvQbvNXivwXsN3mvoXkP3GrrX4L0G7zV4r8F7jbFLxi6ZbehjtqGP2YY+dK/Bew3ea/Beg/cavNfgvQbvNXivwXsN3WvoXkP3GrzX4L0G7zV4rzF2ydglsw19zDb0MdvQh+41eK/Bew3ea/Beg/cavNfgvQbvNXivoXsN3WvoXoP3GrzX4L0G7zXGLhm7ZLahj9mGPmYb+tC9Bu81eK/Bew3ea/Beg/cavNfgvQbvNXSvoXsN3WvwXoP3GrzX4L3G2CVjl8w29DHb0MdsQx+61+C9Bu81eK/Bew3ea/Beg/cavNfgvYbuNXSvoXsN3mvwXoP3GrzXmN0l57e75Py2oT+/bejPbxv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7Pb/dJee3u+T8tqE/v23oz28b+qN7PbzXw3s9vNfDez2818N7PbzXw3s9vNejez2616N7PbzXw3s9vNfDez2/3SXnt7vk/LahP79t6M9vG/qjez2818N7PbzXw3s9vNfDez2818N7PbzXo3s9utejez2818N7PbzXw3s9v90l57e75Py2oT+/bejPbxv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7Pb/2L6D9C9iG/vy2oT+/beiP7vXwXg/v9fBeD+/18F4P7/XwXg/v9fBej+716F6P7vXwXg/v9fBeD+/1fLtLzre75Hzb0J9vG/rzbUN/dK+H93p4r4f3enivh/d6eK+H93p4r4f3enSvR/d6dK+H93p4r4f3eniv59tdcr7dJefbhv5829Cfbxv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7Pd/ukvPtLjnfNvTn24b+fNvQH93r4b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7d69G9Ht3r4b0e3uvhvR7e6/nKv4DyL2Ab+vNtQ3++beiP7vXwXg/v9fBeD+/18F4P7/XwXg/v9fBej+716F6P7vXwXg/v9fBeD+/1fONfwPgXsA39iW3oT2xDf3Svh/d6eK+H93p4r4f3+v+f7XPfxns9vNejez2616N7PbzXw3s9vNfDez1hl4RdEtvQn9iG/sQ29Ef3enivh/d6eK+H93p4r4f3enivh/d6eK9H93p0r0f3enivh/d6eK+H93rCLgm7JLahP7EN/Ylt6I/u9fBeD+/18F4P7/XwXg/v9fBeD+/18F6P7vXoXo/u9fBeD+/18F4P7/WEXRJ2SWxDf2Ib+hPb0B/d6+G9Ht7r4b0e3uvhvR7e6+G9Ht7r4b0e3evRvR7d6+G9Ht7r4b0e3usJuyTsktiG/sQ29Ce2oT+618N7PbzXw3s9vNfDez2818N7PbzXw3s9utejez2618N7PbzXw3s9vNdz7JJjl5xt6M/Zhv6cbeiP7vXwXg/v9fBeD+/18F4P7/XwXg/v9fBej+716F6P7vXwXg/v9fBeD+/1HLvk2CVnG/pztqE/Zxv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7PccuOXbJ2Yb+nG3oz9mG/uheD+/18F4P7/XwXg/v9fBeD+/18F4P7/XoXo/u9eheD+/18F4P7/XwXs+xS45dcrahP2cb+nO2oT+618N7PbzXw3s9vNfDez2818N7PbzXw3s9utejez2618N7PbzXw3s9vNdz7JJjl5xt6M/Zhv6cbeiP7vXwXg/v9fBeD+/18F4P7/XwXg/v9fBej+716F6P7vXwXg/v9fBeD+/1XLvk2iV3G/pzt6E/dxv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7PdcuuXbJ3Yb+3G3oz92G/uheD+/18F4P7/XwXg/v9fBeD+/18F4P7/XoXo/u9eheD+/18F4P7/XwXs+1S65dcrehP3cb+nO3oT+618N7PbzXw3s9vNfDez2818N7PbzXw3s9utejez2618N7PbzXw3s9vNdz7ZJrl9xt6M/dhv7cbeiP7vXwXg/v9fBeD+/18F4P7/XwXg/v9fBej+716F6P7vXwXg/v9fBeD+/1PLvk2SVvG/rztqE/bxv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7Pc8ueXbJ24b+vG3oz9uG/uheD+/18F4P7/XwXg/v9fBeD+/18F4P7/XoXo/u9eheD+/18F4P7/XwXs+zS55d8rahP28b+vO2oT+618N7PbzXw3s9vNfDez2818N7PbzXw3s9utejez2618N7PbzXw3s9vNfz7JJnl7xt6M/bhv68beiP7vXwXg/v9fBeD+/18F4P7/XwXg/v9fBej+716F6P7vXwXg/v9fBeD+/1PLvk2SVvG/rztqE/bxv6o3s9vNfDez2818N7PbzXw3s9vNfDez2816N7PbrXo3s9vNfDez2818N7PWmXpF2S29Cf3Ib+5Db0R/d6eK+H93p4r4f3enivh/d6eK+H93p4r0f3enSvR/d6eK+H93p4r4f3etIuSbskt6E/uQ39yW3oj+718F4P7/XwXg/v9fBeD+/18F4P7/XwXo/u9ehej+718F4P7/XwXg/v9aRdknZJbkN/chv6k9vQH93r4b0e3uvhvR7e6+G9Ht7r4b0e3uvhvR7d69G9Ht3r4b0e3uvhvR7e60m7JO2S3Ib+5Db0J7ehP7rXw3s9vNfDez2818N7PbzXw3s9vNfDez2616N7PbrXw3s9vNfDez2811N2SdkltQ39qW3oT21Df3Svh/d6eK+H93p4r4f3enivh/d6eK+H93p0r0f3enSvh/d6eK+H93p4r6fskrJLahv6U9vQn9qG/uheD+/18F4P7/XwXg/v9fBeD+/18F4P7/XoXo/u9eheD+/18F4P7/XwXk/ZJWWX1Db0p7ahP7UN/dG9Ht7r4b0e3uvhvR7e6+G9Ht7r4b0e3uvRvR7d69G9Ht7r4b0e3uvhvZ6yS8ouqW3oT21Df2ob+qN7PbzXw3s9vNfDez2818N7PbzXw3s9vNejez2616N7PbzXw3s9vNfDez1ll5RdUtvQn9qG/tQ29Ef3enivh/d6eK+H93p4r4f3enivh/d6eK9H93p0r0f3enivh/d6eK+H93raLmm7pLehP70N/elt6I/u9fBeD+/18F4P7/XwXg/v9fBeD+/18F6P7vXoXo/u9fBeD+/18F4P7/W0XdJ2SW9Df3ob+tPb0B/d6+G9Ht7r4b0e3uvhvR7e6+G9Ht7r4b0e3evRvR7d6+G9Ht7r4b0e3utpu6Ttkt6G/vQ29Ke3oT+618N7PbzXw3s9vNfDez2818N7PbzXw3s9utejez2618N7PbzXw3s9vNfTdknbJb0N/elt6E9vQ390r4f3enivh/d6eK+H93p4r4f3enivh/d6dK9H93p0r4f3enivh/d6eK9n7JKxS2Yb+jPb0J/Zhv7oXg/v9fBeD+/18F4P7/XwXg/v9fBeD+/16F6P7vXoXg/v9fBeD+/18F7P2CVjl8w29Ge2oT+zDf3RvR7e6+G9Ht7r4b0e3uvhvR7e6+G9Ht7r0b0e3evRvR7e6+G9Ht7r4b2esUvGLplt6M9sQ39mG/qjez2818N7PbzXw3s9vNfDez2818N7PbzXo3s9utejez2818N7PbzXw3s9Y5eMXTLb0J/Zhv7MNvRH93p4r4f3enivh/d6eK+H93p4r4f3enivR/d6dK9H93p4r4f3enivh/d6xi4Zu2S2oT+zDf2ZbeiP7vXwXg/v9fBeD+/18F4v7/XyXi/v9fJer+716l6v7vXyXi/v9fJeL+/1/naX3N/ukvvbhv7+tqG/v23or+718l4v7/XyXi/v9fJeL+/18l4v7/XyXq/u9eper+718l4v7/XyXi/v9f52l9zf7pL724b+/rahv79t6K/u9fJeL+/18l4v7/XyXi/v9fJeL+/18l6v7vXqXq/u9fJeL+/18l4v7/X+dpfc3+6S+9uG/v62ob+/beiv7vXyXi/v9fJeL+/18l4v7/XyXi/v9fJer+716l6v7vXyXi/v9fJeL+/1/sq/gPIvYBv6+9uG/v62ob+618t7vbzXy3u9vNfLe72818t7vbzXy3u9utere72618t7vbzXy3u9vNf7211yv90l99uG/n7b0N9vG/qre72818t7vbzXy3u9vNfLe72818t7vbzXq3u9utere72818t7vbzXy3u93+6S++0uud829Pfbhv5+29Bf3evlvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt3r1b1e3evlvV7e6+W9Xt7r/XaX3G93yf22ob/fNvT324b+6l4v7/XyXi/v9fJeL+/18l4v7/XyXi/v9eper+716l4v7/XyXi/v9fJe77e75H67S+63Df39tqG/3zb0V/d6ea+X93p5r5f3enmvl/d6ea+X93p5r1f3enWvV/d6ea+X93p5r5f3er/2L6D9C9iG/n7b0N9vG/qre72818t7vbzXy3u9vNfLe72818t7vbzXq3u9utere72818t7vbzXy3u9YZeEXRLb0N/Yhv7GNvRX93p5r5f3enmvl/d6ea+X93p5r5f3enmvV/d6da9X93p5r5f3enmvl/d6wy4JuyS2ob+xDf2Nbeiv7vXyXi/v9fJeL+/18l4v7/XyXi/v9fJer+716l6v7vXyXi/v9fJeL+/1hl0SdklsQ39jG/ob29Bf3evlvV7e6+W9Xt7r5b1e3uvlvV7e6+W9Xt3r1b1e3evlvV7e6+W9Xt7rDbsk7JLYhv7GNvQ3tqG/utfLe72818t7vbzXy3u9vNfLe72818t7vbrXq3u9utfLe72818t7vbzXG3ZJ2CWxDf0929Dfsw391b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7e69W9Xt3r1b1e3uvlvV7e6+W93mOXHLvkbEN/zzb092xDf3Wvl/d6ea+X93p5r5f3enmvl/d6ea+X93p1r1f3enWvl/d6ea+X93p5r/fYJccuOdvQ37MN/T3b0F/d6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r5b1e3evVvV7d6+W9Xt7r5b1e3us9dsmxS8429PdsQ3/PNvRX93p5r5f3enmvl/d6ea+X93p5r5f3enmvV/d6da9X93p5r5f3enmvl/d6j11y7JKzDf0929Dfsw391b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7e69W9Xt3r1b1e3uvlvV7e6+W93muXXLvkbkN/7zb0925Df3Wvl/d6ea+X93p5r5f3+v+f7dPb7BLe69W9Xt3r1b1e3uvlvV7e6+W93muXXLvkbkN/7zb0925Df3Wvl/d6ea+X93p5r5f3enmvl/d6ea+X93p1r1f3enWvl/d6ea+X93p5r/faJdcuudvQ37sN/b3b0F/d6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r5b1e3evVvV7d6+W9Xt7r5b1e3uu9dsm1S+429PduQ3/vNvRX93p5r5f3enmvl/d6ea+X93p5r5f3enmvV/d6da9X93p5r5f3enmvl/d6r11y7ZK7Df2929Dfuw391b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7e69W9Xt3r1b1e3uvlvV7e6+W93meXPLvkbUN/3zb0921Df3Wvl/d6ea+X93p5r5f3enmvl/d6ea+X93p1r1f3enWvl/d6ea+X93p5r/fZJc8uedvQ37cN/X3b0F/d6+W9Xt7r5b1e3uvlvV7e6+W9Xt7r5b1e3evVvV7d6+W9Xt7r5b1e3ut9dsmzS9429PdtQ3/fNvRX93p5r5f3enmvl/d6ea+X93p5r5f3enmvV/d6da9X93p5r5f3enmvl/d6n13y7JK3Df1929Dftw391b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7e69W9Xt3r1b1e3uvlvV7e6+W93rRL0i7JbehvbkN/cxv6q3u9vNfLe72818t7vbzXy3u9vNfLe72816t7vbrXq3u9vNfLe72818t7vWmXpF2S29Df3Ib+5jb0V/d6ea+X93p5r5f3enmvl/d6ea+X93p5r1f3enWvV/d6ea+X93p5r5f3etMuSbskt6G/uQ39zW3or+718l4v7/XyXi/v9fJeL+/18l4v7/XyXq/u9eper+718l4v7/XyXi/v9aZdknZJbkN/cxv6m9vQX93r5b1e3uvlvV7e6+W9Xt7r5b1e3uvlvV7d69W9Xt3r5b1e3uvlvV7e6027JO2S3Ib+5jb0N7ehv7rXy3u9vNfLe72818t7vbzXy3u9vNfLe72616t7vbrXy3u9vNfLe72811t2SdkltQ39rW3ob21Df3Wvl/d6ea+X93p5r5f3enmvl/d6ea+X93p1r1f3enWvl/d6ea+X93p5r7fskrJLahv6W9vQ39qG/upeL+/18l4v7/XyXi/v9fJeL+/18l4v7/XqXq/u9epeL+/18l4v7/XyXm/ZJWWX1Db0t7ahv7UN/dW9Xt7r5b1e3uvlvV7e6+W9Xt7r5b1e3uvVvV7d69W9Xt7r5b1e3uvlvd6yS8ouqW3ob21Df2sb+qt7vbzXy3u9vNfLe72818t7vbzXy3u9vNere72616t7vbzXy3u9vNfLe71tl7Rd0tvQ396G/vY29Ff3enmvl/d6ea+X93p5r5f3enmvl/d6ea9X93p1r1f3enmvl/d6ea+X93rbLmm7pLehv70N/f3bvb7/Pv/cknf++/x8hs/j8/p8PtNn+Wyfs5/XX7v+2vXX/tyS99//Fn9uyf8+n8/0WT7b55+/Vn8//96S33+f3774+WvP2563PW973va87Xnb87b0tvS29NfSX0t/Lb0tvS29Lb3tzy359/nnlvzv89sX/70l/734zy359+Ly18rbytvK28rbytva29rb2tva29pfa3+t/bX2tva29rbxtj+35H+f4fPsi//ekv9e/OeW/Hvx+GvjbeNts2/7273+7/PzGT6Pz+vz+Uyf5bN97tv+dq//+/x8hs/j8/p8/3vxf93r77/P+t+L/3av//7a523hbeFt4W3hbeFt4W3hbeFt4a+Fv+aW/O1e//2nH2873na87Tyf6bP2xX93yX8vPnu5xi0Zt2Tckr/d6/8+ve162/W2623X2663PX/t+Wtuyd/u9d9/+vO2523P2175bJ97uf7rXv97ce7lGrdk3JJxS/52r//79Lb0tvS29LbytvK28tfKX3NL/nav//7Ty9vK28rbyr+A9i+g93L9173+9+LeyzVuybgl45b87V7/9+lt7W3jbeNt423jbeOvjb/mlvztXv/9p4+3zf/e9v52r//7/HyGz/9drvdf9/r77/N/l+v99pa8396S99tb8v52r/8+v5/Pz2f4PD6vz+fTX/v8tc9f+7wtvC28Lbwtjs/r8+2LI/fFUfvi8NfC2463HW873na87Xjb8bbjbcfbjr92/LXrr11vu952ve162+6S99td8v52r/9efHtffGdf/Py1523P2563PW973va87Xnb87bnbemvpb+W/lp6W3pbelt62+6S99td8v52r/9eXL99cX374vLXytvK28rbytvK28rbytva29rb2l9rf639tfa29rb2tva29i9g/AuYb188sS+esy8ef228bbxtvG28bXfJ+3aXvG93yft2l7xvd8n7dpe8b3fJ+9ySv93rf//pf7vX/33u277dJe/bXfK+3SXvb/f634v/615//33u5frcks8t+dyS7/O28LbwtvC28LbwtvC28NfCX3NL/nav//7Tj7cdbzvetrvkfbtL3t/u9d+Lz16uv93rvxe7JZ9b8rkl3/W2623X2663XW+73na97fpr119zS/52r//+05+3PW973ra75H27S97f7vXfi99err/d678XuyWfW/K5JV96W3pbelt6W3pbelt6W/lr5a+5JX+713//6eVt5W3lbeVfQPkXUHu5/ute/3tx7+X63JLPLfnckq+9rb2tva29rb1tvG28bfy18dfckr/d67//9PG28bbxNrsk7JK/3et/L/6ve/3997mXK9yScEvCLQm7JOySsEvCLgm7JOySsEvCLgm7JNySv93rv//0r316m10SdknYJX+7138vjr1cf7vXfy92S8ItCbck7JKwS8IuCbsk7JKwS8IuCbsk7JJwS/52r//+06+32SVhl4RdEnbJ3+7134vvXq6/3eu/F7sl4ZaEWxJ2SdglYZeEXRJ2SdglYZeEXRJ2Sbglf7vXf//p6W12SdglYZeEXfK3e/334tzL9bd7/fdityTcknBLwi4JuyTskrBLwi4JuyTskrBLwi4Jt+Rv9/rvP729zS4JuyTskrBL/nav/148e7n+dq//XuyWhFsSbknYJWGXhF0SdknYJccuOXbJsUuOXXLckr/d63//6X+71/99ls/2uf8Cjl3yt3v978X/da+//z73ch235Lglxy05dsmxS45dcuySY5ccu+TYJccuOXbJcUv+dq///tPD2+ySY5ccu+TYJX+7138vPnu5/nav/17slhy35Lglxy45dsmxS45dcuySY5ccu+TYJccuOW7J3+7133/68za75Nglxy45dsnf7vXfi99err/d678XuyXHLTluybFLjl1y7JJjlxy75Nglxy45dsmxS45b8rd7/fefXt5mlxy75Nglxy75273+e3Ht5frbvf57sVty3JLjlhy75Nglxy45dsmxS45dcuySY5ccu+S4JX+713//6eNtdsmxS45dcuySv93rfy/+r3v9/fe5l+u6JdctuW7JtUuuXXLtkmuXXLvk2iXXLrl2ybVLrlvyt3v97z/9b/f6v8/y2T73X8C1S/52r/9eHHu5/nav/17slly35Lol1y65dsm1S65dcu2Sa5dcu+TaJdcuuW7J3+7133/68Ta75Nol1y65dsnf7vXfi+9err/d678XuyXXLbluybVLrl1y7ZJrl1y75Nol1y65dsm1S65b8rd7/fefnt5ml1y75Nol1y75273+e3Hu5frbvf57sVty3ZLrlly75Nol1y65dsm1S65dcu2Sa5dcu+S6JX+713//6e1tdsm1S65dcu2Sv93rvxf3Xq6/3eu/F7sl1y25bsm1S65dcu2Sa5dcu+TaJdcueXbJs0ueW/K3e/3vP/1v9/q/z+czfZbP9rmX67/u9fff516u55Y8t+S5Jc8ueXbJs0ueXfLskmeXPLvk2SXPLnluyd/u9d9/enibXfLskmeXPLvkb/f678VnL9ff7vXfi92S55Y8t+TZJc8ueXbJs0ueXfLskmeXPLvk2SXPLXnX26632SXPLnl2ybNL/nav/1789nL97V7/vdgteW7Jc0ueXfLskmeXPLvk2SXPLnl2ybNLnl3y3JKX3lbeZpc8u+TZJc8u+du9/ntx7eX6273+e7Fb8tyS55Y8u+TZJc8ueXbJs0ueXfLskmeXPLvkuSVvvG28zS55dsmzS55d8rd7/ffi2cv1t3v978XplqRbkm5J2iVpl6RdknZJ2iVpl6RdknZJ2iXpluT+JvxyfxN+aZekXZJ2Sdolf7vX/178X/f6++9zL1e6JemWpFuSdknaJWmXpF2SdknaJWmXpF2Sdkm6JXm87XibXZJ2SdolaZf87V7/vfju5frbvf57sVuSbkm6JWmXpF2SdknaJWmXpF2SdknaJWmXpFuSz9uet9klaZekXZJ2yd/u9d+Lcy/X3+7134vdknRL0i1JuyTtkrRL0i5JuyTtkrRL0i5JuyTdkixva2+zS9IuSbsk7ZK/3eu/F/derr/d678XuyXplqRbknZJ2iVpl6RdknZJ2iVpl6RdknZJuSXlN+Hym3DZJWWXlF1Sdsnf7vW/F//Xvf7++9zLVW5JuSXllpRdUnZJ2SVll5RdUnZJ2SVll5RdUm5J+U24/CZcdknZJWWXlF3yt3v99+Kzl+tv9/rvxW5JuSXllpRdUnZJ2SVll5RdUnZJ2SVll5RdUm5J+U24/CZcdknZJWWXlF3yt3v99+K3l+tv9/rvxW5JuSXllpRdUnZJ2SVll5RdUnZJ2SVll5RdUm5J+U24/CZcdknZJWWXlF3yt3v99+Lay/W3e/33Yrek3JJyS8ouKbuk7JKyS8ouKbuk7JKyS8ouKbek/CZcfhMuu6TskrJLyi75273+e/Hs5frbvf57sVtSbkm7JW2XtF3SdknbJW2XtF3SdknbJW2XtFvSfhNuvwm3XdJ2SdslbZf87V7/e/F/3evvv8+9XO2WtFvSbknbJW2XtF3SdknbJW2XtF2ie32616d7fe034fabcNslbZe0XdJ2yX/d638vvnu5/ute/3uxW9JuSbslbZe0XdJ2SdslbZe0XdJ2ie716V6f7vW134Tbb8Jtl7Rd0nZJ2yX/da//vTj3cv3Xvf73Yrek3ZJ2S9ouabuk7ZK2S9ouabuk7RLd69O9Pt3ra78Jt9+E2y5pu6TtkrZL/ute/3tx7+X6r3v978VuSbsl7Za0XdJ2SdslbZe0XdJ2Sdslutene32619d+Ex6/CY9dMnbJ2CVjl/zXvdZ/n3u5/ute47/P/WvjloxbMnbJ2CVjl4xdMnbJ2CVjl+hen+716V7f+E14/CY8dsnYJWOXjF3yX/f634tjL9dsQ/90r2/cknFLxi4Zu2TskrFLxi4Zu2TsEt3r070+3esbvwmP34THLhm7ZOySsUtmG/o329C/2Yb+6V7fuCXjloxdMnbJ2CVjl4xdMnbJ2CW616d7fbrXN34THr8Jj10ydsnYJWOXzDb0b7ahf7MN/dO9vnFLxi0Zu2TskrFLxi4Zu2TskrFLdK9P9/p0r2/8Jjx+Ex67ZOySsUvGLplt6N9sQ/9mG/qne33jloxbMrtL8re7JH+7S/K3uyR/u0vyt7skf7tLUveautfUveZvfxPO3/4mnL/dJfnbXZK/3SX5212Sv23o87cNff62oU/da/4+bwtvC28LbwtvC28LbwtvC28Lfy38teOvHW873na87Xjb7pL87S7J3zb0+duGPn/b0KfuNX/X2663XW+73na97Xrb9bbrbdfbnr/2/LXnrz1ve972vO152+6S/O0uyd829Pnbhj5/29Cn7jV/6W3pbelt6W3pbelt6W3lbeVt5a+Vv1b+WnlbeVt5W3lb+RfQ/gVsQ5+/bejztw196l7z197W3tbe1t7W3jbeNt423jbeNv7a+Gvjr423jbftLslvd0l+u0vy212S3zb0+W1Dn9829Kl7zc8t+dySb3dJfrtL8ttdkt/ukvx2l+S3uyS/3SWpe03da+pe8/u8LbwtvC28bXdJfrtL8tuGPr9t6PPbhj51r/m5JZ9b8h1vO952vO142/G2423H246/dvw1t+S73na97Xrb9bbdJfntLslvG/r8tqHPbxv61L3m55Z8bsn3vO152/O2523P2563PW9Lfy39NbfkS29Lb0tvS2/bXZLf7pL8tqHPbxv6/LahT91rfm7J55Z85W3lbeVt5W3lbe1t7W3tr7W/5pZ87W3tbe1t7W3tX8D4F7ANfX7b0Oe3DX3qXvNzSz635BtvG2+zS8IuCbsk7JKwS3SvqXtN3WvG/iacsb8JZ9glYZeEXRJ2SWxDn7ENfcY29Kl7zXBLwi0JuyTskrBLwi4JuyTskrBLdK+pe03da0Z42/E2uyTskrBLwi6JbegztqHP2IY+da8Zbkm4JWGXhF0SdknYJWGXhF0SdonuNXWvqXvNeN72vM0uCbsk7JKwS2Ib+oxt6DO2oU/da4ZbEm5J2CVhl4RdEnZJ2CVhl4RdontN3WvqXjPK28rb7JKwS8IuCbsktqHP2IY+Yxv61L1muCXhloRdEnZJ2CVhl4RdEnZJ2CW619S9pu41Y7xtvM0uCbsk7JJjl5xt6PNsQ59nG/rUveZxS45bcuySY5ccu+TYJccuOXbJsUt0r6l7Td1rnv1NOM/+JpzHLjl2ybFLjl1ytqHPsw19nm3oU/eaxy05bsmxS45dcuySY5ccu+TYJccu0b2m7jV1r3mOt11vs0uOXXLskmOXnG3o82xDn2cb+tS95nFLjlty7JJjlxy75Nglxy45dsmxS3SvqXtN3Wue9Lb0Nrvk2CXHLjl2ydmGPs829Hm2oU/dax635Lglxy45dsmxS45dcuySY5ccu0T3mrrX1L3maW9rb7NLjl1y7JJjl5xt6PNsQ59nG/rUveZxS45bcuySY5ccu+TYJccuuXbJtUt0r6l7Td1r3v1NOO/+JpzXLrl2ybVLrl1yt6HPuw193m3oU/ea1y25bsm1S65dcu2Sa5dcu+TaJdcu0b2m7jV1r3nD28Lb7JJrl1y75Noldxv6vNvQ592GPnWved2S65Zcu+TaJdcuuXbJtUuuXXLtEt1r6l5T95r3etvzNrvk2iXXLrl2yd2GPu829Hm3oU/da1635Lol1y65dsm1S65dcu2Sa5dcu0T3mrrX1L3mLW8rb7NLrl1y7ZJrl9xt6PNuQ593G/rUveZ1S65bcu2Sa5dcu+TaJdcuuXbJtUt0r6l7Td1r3vG28Ta75Nol1y65dsndhj7fNvT5tqFP3Ws+t+S5Jc8ueXbJs0ueXfLskmeXPLtE95q619S95tvfhPPtb8L57JJnlzy75Nklbxv6fNvQ59uGPnWv+dyS55Y8u+TZJc8ueXbJs0ueXfLsEt1r6l5T95rveNvxNrvk2SXPLnl2yduGPt829Pm2oU/daz635Lklzy55dsmzS55d8uySZ5c8u0T3mrrX1L3me96W3maXPLvk2SXPLnnb0Ofbhj7fNvSpe83nljy35Nklzy55dsmzS55d8uySZ5foXlP3mrrXfO1t7W12ybNLnl3y7JK3DX2+bejzbUOfutd8bslzS55d8uySZ5c8u+TZJc8ueXaJ7jV1r6l7zdzfhDP3N+FMuyTtkrRL0i7Jbegzt6HP3IY+da+Zbkm6JWmXpF2SdknaJWmXpF2SdonuNXWvqXvNDG8Lb7NL0i5JuyTtktyGPnMb+sxt6FP3mumWpFuSdknaJWmXpF2SdknaJWmX6F5T95q618zrbdfb7JK0S9IuSbskt6HP3IY+cxv61L1muiXplqRdknZJ2iVpl6RdknZJ2iW619S9pu41M72tvM0uSbsk7ZK0S3Ib+sxt6DO3oU/da6Zbkm5J2iVpl6RdknZJ2iVpl6RdontN3WvqXjPH28bb7JK0S9IuSbskt6HP3IY+cxv61L1muSXllpRdUnZJ2SVll5RdUnZJ2SW619S9pu41y2/C5TfhskvKLim7pOyS2oY+axv6rG3oU/ea5ZaUW1J2SdklZZeUXVJ2SdklZZfoXlP3mrrXLL8Jl9+Eyy4pu6TskrJLahv6rG3os7ahT91rlltSbknZJWWXlF1SdknZJWWXlF2ie03da+pes/wmXH4TLruk7JKyS8ouqW3os7ahz9qGPnWvWW5JuSVll5RdUnZJ2SVll5RdUnaJ7jV1r6l7zfKbcPlNuOySskvKLim7pLahz9qGPmsb+tS9Zrkl5ZaUXVJ2SdklZZeUXVJ2SdklutfUvabuNdtvwu034bZL2i5pu6Ttkt6GPnsb+uxt6FP3mu2WtFvSdknbJW2XtF3SdknbJW2X6F5T95q612y/CbffhNsuabuk7ZK2S3ob+uxt6LO3oU/da/Jek/eavNfkvSbvNXmvyXtN3mvyXlP3mrrX1L0m7zV5r8l7Td5rtl3SdklvQ5+9DX32NvSpe03ea/Jek/eavNfkvSbvNXmvyXtN3mvqXlP3mrrX5L0m7zV5r8l7zbZL2i7pbeizt6HP3oY+da/Je03ea/Jek/eavNfkvSbvNXmvyXtN3WvqXlP3mrzX5L0m7zV5r9l2SdslvQ199jb02dvQp+41ea/Je03ea/Jek/eavNfkvSbvNXmvqXtN3WvqXpP3mrzX5L0m7zXHLhm7ZLahz9mGPmcb+tS9Ju81ea/Je03ea/Jek/eavNfkvSbvNXWvqXtN3WvyXpP3mrzX5L3m2CVjl8w29Dnb0OdsQ5+61+S9Ju81ea/Je03ea/Jek/eavNfkvabuNXWvqXtN3mvyXpP3mrzXHLtk7JLZhj5nG/qcbehT95q81+S9Ju81ea/Je03ea/Jek/eavNfUvabuNXWvyXtN3mvyXpP3mmOXjF0y29DnbEOfsw196l6T95q81+S9Ju81ea/Je03ea/Jek/eautfUvabuNXmvxXst3mvxXuu3u6R+u0vqtw19/bahr9829KV7Ld5r8V6L91q81+K9Fu+1eK/Fey3ea+leS/dautfivRbvtXivxXut3+6S+u0uqd829PXbhr5+29CX7rV4r8V7Ld5r8V6L91q81+K9Fu+1eK+ley3da+lei/davNfivRbvtX67S+q3u6R+29DXbxv6+m1DX7rX4r0W77V4r8V7Ld5r8V6L91q81+K9lu61dK+ley3ea/Fei/davNf6pX8B5V/ANvT124a+ftvQl+61eK/Fey3ea/Fei/davNfivRbvtXivpXst3WvpXov3WrzX4r0W77V+41/A+BewDX39tqGv3zb0pXst3mvxXov3WrzX4r0W77V4r8V7Ld5r6V5L91q61+K9Fu+1eK/Fe61vd0l9u0vq24a+vm3o69uGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK/17S6pb3dJfdvQ17cNfX3b0JfutXivxXst3mvxXov3WrzX4r0W77V4r6V7Ld1r6V6L91q81+K9Fu+1vt0l9e0uqW8b+vq2oa9vG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K91lf+BbR/AdvQ17cNfX3b0JfutXivxXst3mvxXov3WrzX4r0W77V4r6V7Ld1r6V6L91q81+K9Fu+1wi4JuyS2oa/Yhr5iG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K9VtglYZfENvQV29BXbENfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q81wq7JOyS2Ia+Yhv6im3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91phl4RdEtvQV2xDX7ENfelei/davNfivRbvtXivxXst3mvxXov3WrrX0r2W7rV4r8V7Ld5r8V4r7JKwS2Ib+opt6Cu2oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rHbvk2CVnG/o629DX2Ya+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4r3XskmOXnG3o62xDX2cb+tK9Fu+1eK/Fey3ea/Fei/davNfivRbvtXSvpXst3WvxXov3WrzX4r3WsUuOXXK2oa+zDX2dbehL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3WscuOXbJ2Ya+zjb0dbahL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3msdu+TaJXcb+rrb0Nfdhr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXivde2Sa5fcbejrbkNfdxv60r0W77V4r8V7Ld5r8V6L91q81+K9Fu+1dK+ley3da/Fei/davNfivda1S65dcrehr7sNfd1t6Ev3WrzX4r0W77V4r8V7Ld5r8V6L91q819K9lu61dK/Fey3ea/Fei/da1y65dsndhr7uNvR1t6Ev3WvxXov3WrzX4r0W77V4r8V7Ld5r8V5L91q619K9Fu+1eK/Fey3ea1275Noldxv6utvQ192GvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK/17JJnl7xt6OttQ19vG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K91rNLnl3ytqGvtw19vW3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91rPLnl2yduGvt429PW2oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rPbvk2SVvG/p629DX24a+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4r/XskmeXvG3oK7ehr9yGvnSvxXst3mvxXov3WrzX4r0W77V4r8V7Ld1r6V5L91q81+K9Fu+1eK+VdknaJbkNfeU29JXb0JfutXivxXst3mvxXov3WrzX4r0W77V4r6V7Ld1r6V6L91q81+K9Fu+10i5JuyS3oa/chr5yG/rSvRbvtXivxXst3mvxXov3WrzX4r0W77V0r6V7Ld1r8V6L91q81+K9VtolaZfkNvSV29BXbkNfutfivRbvtXivxXst3mvxXov3WrzX4r2W7rV0r6V7Ld5r8V6L91q810q7JO2S3Ia+chv6ym3oS/davNfivRbvtXivxXst3mvxXov3WrzX0r2W7rV0r8V7Ld5r8V6L91pll5RdUtvQV21DX7UNfelei/davNfivRbvtXivxXst3mvxXov3WrrX0r2W7rV4r8V7Ld5r8V6r7JKyS2ob+qpt6Ku2oS/da/Fei/davNfivRbvtXivxXst3mvxXkv3WrrX0r0W77V4r8V7Ld5rlV1SdkltQ1+1DX3VNvSley3ea/Fei/davNfivRbvtXivxXst3mvpXkv3WrrX4r0W77V4r8V7rbJLyi6pbeirtqGv2oa+dK/Fey3ea/Fei/davNfivRbvtXivxXst3WvpXkv3WrzX4r0W77V4r1V2SdkltQ191Tb0VdvQl+61eK/Fey3ea/Fei/davNfivRbvtXivpXst3WvpXov3WrzX4r0W77XaLmm7pLehr96Gvnob+tK9Fu+1eK/Fey3ea/Fei/davNfivRbvtXSvpXst3WvxXov3WrzX4r1W2yVtl/Q29NXb0FdvQ1+61+K9Fu+1eK/Fey3ea/Fei/davNfivZbutXSvpXst3mvxXov3WrzXaruk7ZLehr56G/rqbehL91q81+K9Fu+1eK/Fey3ea/Fei/davNfSvZbutXSvxXst3mvxXov3Wm2XtF3S29BXb0NfvQ196V6L91q81+K9Fu+1eK/Fey3ea/Fei/dautfSvZbutXivxXst3mvxXmvskrFLZhv6mm3oa7ahL91r8V6L91q81+K9Fu+1eK/Fey3ea/FeS/dautfSvRbvtXivxXst3muNXTJ2yWxDX7MNfc029KV7Ld5r8V6L91q81+K9Fu+1eK/Fey3ea+leS/dautfivRbvtXivxXutsUvGLplt6Gu2oa/Zhr50r8V7Ld5r8V6L91q81+K9Fu+1eK/Fey3da+leS/davNfivRbvtXivNXbJ2CWzDX3NNvQ129CX7rV4r8V7Ld5r8V6L91q81+K9Fu+1eK+ley3da+lei/davNfivRbvtcYuGbtktqGv2Ya+Zhv60r0W77V5r817bd5r816b99q81+a9Nu+1da+te23da/Nem/favNfmvfZvd0n/dpf0bxv6/m1D379t6Fv32rzX5r0277V5r817bd5r816b99q819a9tu61da/Ne23ea/Nem/fav90l/dtd0r9t6Pu3DX3/tqFv3WvzXpv32rzX5r0277V5r817bd5r815b99q619a9Nu+1ea/Ne23ea/92l/Rvd0n/tqHv3zb0/duGvnWvzXtt3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea/9a/8C2r+Abej7tw19/7ahb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3mt/u0v6213S3zb0/W1D39829K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvtb3dJf7tL+tuGvr9t6Pvbhr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmv/e0u6W93SX/b0Pe3DX1/29C37rV5r817bd5r816b99q81+a9Nu+1ea+te23da+tem/favNfmvTbvtb/0L6D8C9iGvr9t6Pvbhr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmv/Y1/AeNfwDb0/W1D39829K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvtsEvCLolt6Du2oe/Yhr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmvHXZJ2CWxDX3HNvQd29C37rV5r817bd5r816b99q81+a9Nu+1ea+te23da+tem/favNfmvTbvtcMuCbsktqHv2Ia+Yxv61r0277V5r817bd5r816b99q81+a9Nu+1da+te23da/Nem/favNfmvXbYJWGXxDb0HdvQd2xD37rX5r0277V5r817bd5r816b99q81+a9tu61da+te23ea/Nem/favNc+dsmxS8429H22oe+zDX3rXpv32rzX5r0277V5r817bd5r816b99q619a9tu61ea/Ne23ea/Ne+9glxy4529D32Ya+zzb0rXtt3mvzXpv32rzX5r0277V5r817bd5r615b99q61+a9Nu+1ea/Ne+1jlxy75GxD32cb+j7b0LfutXmvzXtt3mvzXpv32rzX5r0277V5r617bd1r616b99q81+a9Nu+1j11y7JKzDX2fbej7bEPfutfmvTbvtXmvzXtt3mvzXpv32rzX5r227rV1r617bd5r816b99q81z52ybFLzjb0fbah77MNfetem/favNfmvTbvtXmvzXtt3mvzXpv32rrX1r227rV5r817bd5r81772iXXLrnb0Pfdhr7vNvSte23ea/Nem/favNfmvTbvtXmvzXtt3mvrXlv32rrX5r0277V5r8177WuXXLvkbkPfdxv6vtvQt+61ea/Ne23ea/Nem/favNfmvTbvtXmvrXtt3WvrXpv32rzX5r0277WvXXLtkrsNfd9t6PtuQ9+61+a9Nu+1ea/Ne23ea/Nem/favNfmvbbutXWvrXtt3mvzXpv32rzXvnbJtUvuNvR9t6Hvuw19616b99q81+a9Nu+1ea/Ne23ea/Nem/fautfWvbbutXmvzXtt3mvzXvvaJc8uedvQ99uGvt829K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvtZ5c8u+RtQ99vG/p+29C37rV5r817bd5r816b99q81+a9Nu+1ea+te23da+tem/favNfmvTbvtZ9d8uyStw19v23o+21D37rX5r0277V5r817bd5r816b99q81+a9tu61da+te23ea/Nem/favNd+dsmzS9429P22oe+3DX3rXpv32rzX5r0277V5r817bd5r816b99q619a9tu61ea/Ne23ea/Ne+9klzy5529D324a+3zb0rXtt3mvzXpv32rzX5r0277V5r817bd5r615b99q61+a9Nu+1ea/Ne+20S9IuyW3oO7eh79yGvnWvzXtt3mvzXpv32rzX5r0277V5r817bd1r615b99q81+a9Nu+1ea+ddknaJbkNfec29J3b0LfutXmvzXtt3mvzXpv32rzX5r0277V5r617bd1r616b99q81+a9Nu+10y5JuyS3oe/chr5zG/rWvTbvtXmvzXtt3mvzXpv32rzX5r0277V1r617bd1r816b99q81+a9dtolaZfkNvSd29B3bkPfutfmvTbvtXmvzXtt3mvzXpv32rzX5r227rV1r617bd5r816b99q81067JO2S3Ia+axv6rm3oW/favNfmvTbvtXmvzXtt3mvzXpv32rzX1r227rV1r817bd5r816b99pll5RdUtvQd21D37UNfetem/favNfmvTbvtXmvzXtt3mvzXpv32rrX1r227rV5r817bd5r81677JKyS2ob+q5t6Lu2oW/da/Nem/favNfmvTbvtXmvzXtt3mvzXlv32rrX1r0277V5r817bd5rl11SdkltQ9+1DX3XNvSte23ea/Nem/favNfmvTbvtXmvzXtt3mvrXlv32rrX5r0277V5r8177bJLyi6pbei7tqHv2oa+da/Ne23ea/Nem/favNfmvTbvtXmvzXtt3WvrXlv32rzX5r0277V5r912SdslvQ199zb03dvQt+61ea/Ne23ea/Nem/favNfmvTbvtXmvrXtt3WvrXpv32rzX5r0277XbLmm7pLeh796Gvnsb+ta9Nu+1ea/Ne23ea/Nem/favNfmvTbvtXWvrXtt3WvzXpv32rzX5r122yVtl/Q29N3b0HdvQ9+61+a9Nu+1ea/Ne23ea/Nem/favNfmvbbutXWvrXtt3mvzXpv32rzXbruk7ZLehr57G/rubehb99q81+a9Nu+1ea/Ne23ea/Nem/favNfWvbbutXWvzXtt3mvzXpv32m2XtF3S29B3b0PfvQ19616b99q81+a9Nu+1ea/Ne23ea/Nem/fautfWvbbutXmvzXtt3mvzXnvskrFLZhv6nm3oe7ahb91r816b99q81+a9Nu+1ea/Ne23ea/NeW/fautfWvTbvtXmvzXtt3muPXTJ2yWxD37MNfc829K17bd5r816b99q81+a9Nu+1ea/Ne23ea+teW/fautfmvTbvtXmvzXvtsUvGLplt6Hu2oe/Zhr51r817bd5r816b99q81+a9Nu+1ea/Ne23da+teW/favNfmvTbvtXmvPXbJ2CWzDX3PNvQ929C37rV5r817bd5r816b99q81+a9Nu+1ea+te23d6+heh/c6vNfhvQ7vdX67S+a3u2R+29DPbxv6+W1DP7rX4b0O73V4r8N7Hd7r8F6H9zq81+G9ju51dK+jex3e6/Beh/c6vNf57S6Z3+6S+W1DP79t6Oe3Df3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/Be57e7ZH67S+a3Df38tqGf3zb0o3sd3uvwXof3OrzX4b0O73V4r8N7Hd7r6F5H9zq61+G9Du91eK/De51f+RdQ/gVsQz+/bejntw396F6H9zq81+G9Du91eK/Dex3e6/Beh/c6utfRvY7udXivw3sd3uvwXuc3/gWMfwHb0M9vG/r5bUM/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq81/l2l8y3u2S+bejn24Z+vm3oR/c6vNfhvQ7vdXivw3sd3uvwXof3OrzX0b2O7nV0r8N7Hd7r8F6H9zrf7pL5dpfMtw39fNvQz7cN/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F7n210y3+6S+bahn28b+vm2oR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7rfO1fQPsXsA39fNvQz7cN/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F4n7JKwS2Ib+olt6Ce2oR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7rhF0SdklsQz+xDf3ENvSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nbBLwi6JbegntqGf2IZ+dK/Dex3e6/Beh/c6vNfhvQ7vdXivw3sd3evoXkf3OrzX4b0O73V4rxN2SdglsQ39xDb0E9vQj+51eK/Dex3e6/Beh/c6vNfhvQ7vdXivo3sd3evoXof3OrzX4b0O73XCLgm7JLahn9iGfmIb+tG9Du91eK/Dex3e6/Beh/c6vNfhvQ7vdXSvo3sd3evwXof3OrzX4b3OsUuOXXK2oZ+zDf2cbehH9zq81+G9Du91eK/Dex3e6/Beh/c6vNfRvY7udXSvw3sd3uvwXof3OscuOXbJ2YZ+zjb0c7ahH93r8F6H9zq81+G9Du91eK/Dex3e6/BeR/c6utfRvQ7vdXivw3sd3uscu+TYJWcb+jnb0M/Zhn50r8N7Hd7r8F6H9zq81+G9Du91eK/Dex3d6+heR/c6vNfhvQ7vdXivc+ySY5ecbejnbEM/Zxv60b0O73V4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvc61S65dcrehn7sN/dxt6Ef3OrzX4b0O73V4r8N7Hd7r8F6H9zq819G9ju51dK/Dex3e6/Beh/c61y65dsndhn7uNvRzt6Ef3evwXof3OrzX4b0O73V4r8N7Hd7r8F5H9zq619G9Du91eK/Dex3e61y75Noldxv6udvQz92GfnSvw3sd3uvwXof3OrzX4b0O73V4r8N7Hd3r6F5H9zq81+G9Du91eK9z7ZJrl9xt6OduQz93G/rRvQ7vdXivw3sd3uvwXof3OrzX4b0O73V0r6N7Hd3r8F6H9zq81+G9zrVLrl1yt6Gfuw393G3oR/c6vNfhvQ7vdXivw3sd3uvwXof3OrzX0b2O7nV0r8N7Hd7r8F6H9zrPLnl2yduGft429PO2oR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX/yPiDnLs2HEoiG6pRFIpcv8b6y5/m2emgYFnDuoigAzE8F5H73X0XkfvdfRe5+KSi0vuOvRz16Gfuw798F5H73X0XkfvdfReR+919F5H73X0XkfvdXivw3sd3uvovY7e6+i9jt7rXFxyccldh37uOvRz16Ef3uvovY7e6+i9jt7r6L2O3uvovY7e6+i9Du91eK/Dex2919F7Hb3X0Xudi0suLrnr0M9dh37uOvTDex2919F7Hb3X0XsdvdfRex2919F7Hb3X4b0O73V4r6P3Onqvo/c6eq9zccmHS7516Odbh36+deiH9zp6r6P3Onqvo/c6eq+j9zp6r6P3Onqvw3sd3uvwXkfvdfReR+919F7nwyUfLvnWoZ9vHfr51qEf3uvovY7e6+i9jt7r6L2O3uvovY7e6+i9Du91eK/Dex2919F7Hb3X0XudD5d8uORbh36+dejnW4d+eK+j9zp6r6P3Onqvo/c6eq+j9zp6r6P3OrzX4b0O73X0XkfvdfReR+91Plzy4ZJvHfr51qGfbx364b2O3uvovY7e6+i9jt7r6L2O3uvovY7e6/Beh/c6vNfRex2919F7Hb3X+XDJh0u+dejnW4d+vnXoh/c6eq+j9zp6r6P3Onqvo/c6eq+j9zp6r8N7Hd7r8F5H73X0XkfvdfRe5+GSh0veOvTz1qGftw798F5H73X0XkfvdfReR+919F5H73X0XkfvdXivw3sd3uvovY7e6+i9jt7rPFzycMlbh37eOvTz1qEf3uvovY7e6+i9jt7r6L2O3uvovY7e6+i9Du91eK/Dex2919F7Hb3X0Xudh0seLnnr0M9bh37eOvTDex2919F7Hb3X0XsdvdfRex2919F7Hb3X4b0O73V4r6P3Onqvo/c6eq/zcMnDJW8d+nnr0M9bh354r6P3Onqvo/c6eq+j9zp6r6P3Onqvo/c6vNfhvQ7vdfReR+919F5H73UeLnm45K1DP70O/fQ69MN7Hb3X0XsdvdfRex2919F7Hb3X0XsdvdfhvQ7vdXivo/c6eq+j9zp6r9O4pHFJr0M/vQ799Dr0w3sdvdfRex2919F7Hb3X0XsdvdfRex291+G9Du91eK+j9zp6r6P3Onqv07ikcUmvQz+9Dv30OvTDex2919F7Hb3X0XsdvdfRex2919F7Hb3X4b0O73V4r6P3Onqvo/c6eq/TuKRxSa9DP70O/fQ69MN7Hb3X0XsdvdfRex2919F7Hb3X0XsdvdfhvQ7vdXivo/c6eq+j9zp6r9O4pHFJr0M/vQ799Dr0w3sdvdfRex2919F7Hb3X0XsdvdfRex291+G9Du91eK+j9zp6r6P3OnqvM7hkcMmsQz+zDv3MOvTDex2919F7Hb3X0XsdvdfRex2919F7Hb3X4b0O73V4r6P3Onqvo/c6eq8zuGRwyaxDP7MO/cw69MN7Hb3X0XsdvdfRex2919F7Hb3X0XsdvdfhvQ7vdXivo/c6eq+j9zp6rzO4ZHDJrEM/sw79zDr0w3sdvdfRex2919F7Hb3X0XsdvdfRex291+G9Du91eK+j9zp6r6P3OnqvM7hkcMmsQz+zDv3MOvTDex2919F7Hb3X0XsdvdfRex2919F7Hb3X4b0O73V4r6P3Onqvo/c6eq8zuGRwyaxDP7MO/cw/h/7/X4T/bcnv83iGZ3qW5/X8PJ9ne84+j187fu34tX/fhH+f5Xk9P8/n2Z5/l+v/z38O/e/z7MXh18Jt4bZwW7gt3BZuC7el29Jt6dfSr6VfS7el29Jt6bZ/XPL/5z8u+X2evfifQ//7zL24/Fq5rdxWbiu3lduu267brtuu265fu37t+rXrtuu267bPbf+45PcZnrkX/3Pof593L/782ue2z22f257bntue257bntue255fe37t+bXntnZbu63d1v4C2l/AP4f+9/ntxf8c+t+nX2u3jdvGbeO2cdu4bdw2bhu3jV+b/bVjS7b3+vsMz/Qsz+v5eb5/F59/Dv3vc5fr2JJjS44t2d7r77M8r+fn+Tzb023h18Kv2ZLtvf4+3RZuC7fF82zPXa6Tu1wnd7mOLTm25NiS7b3+Pt2Wbku3pdvKbeW28mvl12zJ9l5/n24rt5Xbav8Czv3x3OU6d5fr3F2uY0uOLTm2ZHuvv0+3Xbd9bvvc9rntc9vn1z6/Zku29/r7dNvntue25y/g+Qt4u1zn7XKdt8t1bMmxJceWbO/1/892W7ut3dZua7e129qvtV+zJdt7/f9z3DZuG7eNv4DxFzC7XGd2uc7sch1bcmxJ2JLAJYFLApcELglcErgkcEngksAlYUu29/r7DM/0LM/r+XnucsXZ5YqzyxW2JGxJ2JLAJYFLApcELglcErgkcEngksAlYUu29/r7dBsuCVwSuCRwSeQuV9QuV9QuV9iSsCVhSwKXBC4JXBK4JHBJ4JLAJYFLApeELdne6+/TbbgkcEngksAl8e1yxbfLFd8uV9iSsCVhSwKXBC4JXBK4JHBJ4JLAJYFLApeELdne6+/TbbgkcEngksAl0btc0btc0btcYUvCloQtCVwSuCRwSeCSwCWBSwKXBC4JXBK2ZHuv+bO919/n8QzP9CzPXa782eXKn12utCVpS9KWJC5JXJK4JHFJ4pLEJYlLEpckLklbsr3X36fbcEniksQliUsydrkydrkydrnSlqQtSVuSuCRxSeKSxCWJSxKXJC5JXJK4JG3J9l5/n27DJYlLEpckLsna5cq7y5V3lyttSdqStCWJSxKXJC5JXJK4JHFJ4pLEJYlL0pZs7/X36TZckrgkcUnikny7XPl2ufLtcqUtSVuStiRxSeKSxCWJSxKXJC5JXJK4JHFJ2pLtvf4+3YZLEpckLklckrPLlbPLlbPLlbYkbUnaksQlhUsKlxQuKVxSuKRwSeGSwiVlS7b3+v/n+fE8nuGZnuW5y1Vnl6vOLlfZkrIlZUsKlxQuKVxSuKRwSeGSwiWFSwqXlC3Z3uvv0224pHBJ4ZLCJZW7XJW7XJW7XGVLypaULSlcUrikcEnhksIlhUsKlxQuKVxStmR7r79Pt+GSwiWFSwqX1N3lqm+Xq75drrIlZUvKlhQuKVxSuKRwSeGSwiWFSwqXFC4pW7K919+n23BJ4ZLCJYVLqne5qne5qne5ypaULSlbUrikcEnhksIlhUsKlxQuKVxSuKRsyfZef59uwyUXl1xccnHJ/dnluj+7XPdnl+vakmtLri25uOTikotLLi65uOTikotLLi65uOTaku29/v8ZbsMlF5dcXHJxyY1drhu7XDd2ua4tubbk2pKLSy4uubjk4pKLSy4uubjk4pKLS64t2d7r79NtuOTikotLLi65tct1a5fr1i7XtSXXllxbcnHJxSUXl1xccnHJxSUXl1xccnHJtSXbe/19ug2XXFxyccnFJffb5bpvl+u+Xa5rS64tubbk4pKLSy4uubjk4pKLSy4uubjk4pJrS7b3+vt0Gy65uOTikotL7uxy3dnlurPLdW3JtSXXllxccnHJxSUfLvlwyYdLPlzy4ZIPl3y2ZHuvv8/23Ns+XPLhkg+XfGeX6zu7XN/Z5fpsyWdLPlvy4ZIPl3y45MMlHy75cMmHSz5c8uGSz5Zs7/X/z3QbLvlwyYdLPlzy5S7Xl7tcX+5yfbbksyWfLflwyYdLPlzy4ZIPl3y45MMlHy75cMlnS7b3+vt0Gy75cMmHSz5c8t1dru/ucn13l+uzJZ8t+WzJh0s+XPLhkg+XfLjkwyUfLvlwyYdLPluyvdffp9twyYdLPlzy4ZLv7XJ9vcv19S7XZ0s+W/LZkg+XfLjkwyUfLvlwyYdLPlzy4ZIPl3y2ZHuvv0+34ZIPl3y45OGS97PL9X52ud7PLtezJc+WPFvycMnDJQ+XPFzycMnDJQ+XPFzycMmzJc834eeb8MMlD5c8XPJwyYtdrhe7XC92uZ4tebbk2ZKHSx4uebjk4ZKHSx4uebjk4ZKHS54teb4JP9+EHy55uOThkodLXu1yvdrlerXL9WzJsyXPljxc8nDJwyUPlzxc8nDJwyUPlzxc8mzJ8034+Sb8cMnDJQ+XPFzyvl2u9+1yvW+X69mSZ0ueLXm45OGSh0seLnm45OGSh0seLnm45NmS55vw80344ZKHSx4uebjk9S7Xm12uN7tcz5Y8W/JsycMlD5c8XPJwycMljUsalzQuaVzStqR9E27fhBuXNC5pXNK4pM8uV59drj67XG1L2pa0LWlc0rikcUnjksYljUsalzQuaVzStqR9E27fhBuXNC5pXNK4pHOXq3OXq3OXq21J25K2JY1LGpc0Lmlc0rikcUnjksYljUvalrRvwu2bcOOSxiWNSxqX9N3l6rvL1XeXq21J25K2JY1LGpc0Lmlc0rikcUnjksYljUvalrRvwu2bcOOSxiWNSxqX9Nvl6rfL1W+Xq21J25K2JY1LGpc0Lmlc0rikcUnjksYljUvalrRvwu2bcOOSxiWNSxqX9Oxyzc8u1/zsco0tGVsytmRwyeCSwSWDSwaXDC4ZXDK4ZHDJ2JLxTXh8Ex5cMrhkcMngkoldroldroldrrElY0vGlgwuGVwyuGRwyeCSwSWDSwaXDC4ZWzK+CY9vwoNLBpcMLhlcMrXLNbXLNbXLNbZkbMnYksElg0sGlwwuGVwyuGRwyeCSwSVjS8Y34fFNeHDJ4JLBJYNL5tvlmm+Xa75drrElY0vGlgwuGVwyuGRwyeCSwSWDSwaXDC4ZWzK+CY9vwoNLBpcMLhlcMr3LNb3LNb3LNbZkbMnYksElg0sGlwwuGVwyuGR7r///Rrtccnivh/d6tvf6+yzP6/l5Ps/2/Ldc5+efQ//7/Ldch/d6tvf6+yzP6/l5Ps/2dFu4LdwWfi38Wvi1cFu4LdwWblsuOT/LJefnn0P/+4y9+J9D//v0a+m2dFu6Ld2Wbiu3ldvKbeW28mvl18qvldvKbeW267blkvOzXHJ+/jn0v8/ai/859L9Pv3bddt123fa57XPb57bPbZ/bPrd9fu3za59f+9z23Pbc9tz2/AU8fwH/HPrf57cX/3Pof59+7bmt3dZua7e129pt7bZ2W7ut/Vr7tfFr47Zx27ht3Db+AsZfwD+H/vfZe/E69If3eo4tObZke6+/z/K8np/n82zPvY33enivh/d6tvf6+yzP6/l5Ps/23OU669Cfsw794b2eY0uOLdne6+/TbeG2cFu4Ld2Wbku/ln7Nlmzv9ffptnRbum255JzlknPWoT9nHfpz1qE/vNdzbMmxJdt7/X26rdx23Xbddt123Xb92vVrtmR7r79Pt123fW5bLjlnueScdejPWYf+nHXoD+/1HFtybMn2Xv//fG57bntue257bntue37t+TVbsr3X/z/bbe22dlv7C2h/AevQn7MO/Tnr0B/e6zm25NiS7b3+Pt02bhu3jdvGbeO28Wu4hPd6tvf6+wzP9CzP6/l57nLFOvQn1qE/vNcTtiRsSeCSwCWBSwKXBC4JXBK4hPd6eK+H93q29/r7dBsuCVwSuCRwSaxDf2Id+hPr0B/e6wlbErYkcEngksAlgUsClwQuCVzCez2818N7Pdt7/X26DZcELglcErgk1qE/sQ79iXXoD+/1hC0JWxK4JHBJ4JLAJYFLApcELuG9Ht7r4b2e7b3+Pt2GSwKXBC4JXBLr0J9Yh/7EOvSH93rCloQtCVwSuCRwSeCSwCWBSwKX8F4P7/XwXs/2Xv//HLfhksAlgUsCl8Q69CfWoT+xDv3hvZ6wJWlLEpckLklckrgkcUniksQlvNfDez2817O9199neKZneV7Pz3OXK9ehP7kO/eG9nrQlaUsSlyQuSVySuCRxSeKSxCW818N7PbzXs73X36fbcEniksQliUtyHfqT69CfXIf+8F5P2pK0JYlLEpckLklckrgkcUniEt7r4b0e3uvZ3uvv0224JHFJ4pLEJbkO/cl16E+uQ394rydtSdqSxCWJSxKXJC5JXJK4JHEJ7/XwXg/v9Wzv9ffpNlySuCRxSeKSXIf+5Dr0J9ehP7zXk7YkbUniksQliUsSlyQuSVySuIT3enivh/d6tvf6/7/X/SZ8CpcULilcUrik1qE/tQ79qXXoD+/1lC0pW1K4pHBJ4ZLCJYVLCpcULuG9Ht7r4b2e7b3+Pt2GSwqXFC4pXFLr0J9ah/7UOvSH93rKlpQtKVxSuKRwSeGSwiWFSwqX8F4P7/XwXs/2Xn+fbsMlhUsKlxQuqXXoT61Df2od+sN7PWVLypYULilcUrikcEnhksIlhUt4r4f3enivZ3uvv0+34ZLCJYVLCpfUOvSn1qE/tQ794b2esiVlSwqXFC4pXFK4pHBJ4ZLCJbzXw3s9vNezvdffp9twSeGSwiWFS2od+lPr0J9ah/7wXk/ZkrIlhUsuLrm45OKSi0suLrm4hPd6eK+H93q29/r/534TPheXXFxyccnFJXcd+nPXoT93HfrDez3XllxbcnHJxSUXl1xccnHJxSUXl/BeD+/18F7P9l5/n27DJReXXFxyccldh/7cdejPXYf+8F7PtSXXllxccnHJxSUXl1xccnHJxSW818N7PbzXs73X36fbcMnFJReXXFxy16E/dx36c9ehP7zXc23JtSUXl1xccnHJxSUXl1xccnEJ7/XwXg/v9Wzv9ffpNlxyccnFJReX3HXoz12H/tx16A/v9Vxbcm3JxSUXl1xccnHJxSUXl1xcwns9vNfDez3be/19ug2XfLjkwyUfLvnWoT/fOvTnW4f+8F7PZ0s+W/Lhkg+XfLjkwyUfLvlwyYdLeK+H93p4r2d7r/9/httwyYdLPlzy4ZJvHfrzrUN/vnXoD+/1fLbksyUfLvlwyYdLPlzy4ZIPl3y4hPd6eK+H93q29/r7dBsu+XDJh0s+XPKtQ3++dejPtw794b2ez5Z8tuTDJR8u+XDJh0s+XPLhkg+X8F4P7/XwXs/2Xn+fbsMlHy75cMmHS7516M+3Dv351qE/vNfz2ZLPlny45MMlHy75cMmHSz5c8uES3uvhvR7e69ne6+/TbbjkwyUfLvlwybcO/fnWoT/fOvSH93o+W/LZkg+XfLjkwyUPlzxc8nDJwyW818N7PbzX83wTfr4JP1zycMnDJQ+XvHXoz1uH/rx16A/v9Txb8mzJwyUPlzxc8nDJwyUPlzxcwns9vNfDez3PN+Hnm/DDJQ+XPFzycMlbh/68dejPW4f+8F7PsyXPljxc8nDJwyUPlzxc8nDJwyW818N7PbzX83wTfr4JP1zycMnDJQ+XvHXoz1uH/rx16A/v9Txb8mzJwyUPlzxc8nDJwyUPlzxcwns9vNfDez3PN+Hnm/DDJQ+XPFzycMlbh/68dejPW4f+8F7PsyXPljxc8nDJwyUPlzxc8nDJwyW818N7PbzX83wTfr4JP1zycMnDJY1Leh360+vQn16H/vBeT9uStiWNSxqXNC5pXNK4pHFJ4xLe6+G9Ht7rad+E2zfhxiWNSxqXNC7pdehPr0N/eh36w3s9bUvaljQuaVzSuKRxSeOSxiWNS3ivh/d6eK+nfRNu34QblzQuaVzSuKTXoT+9Dv3pdegP7/W0LWlb0rikcUnjksYljUsalzQu4b0e3uvhvZ72Tbh9E25c0rikcUnjkl6H/vQ69KfXoT+819O2pG1J45LGJY1LGpc0Lmlc0riE93p4r4f3eto34fZNuHFJ45LGJY1Leh360+vQn16H/vBeT9uStiWNSxqXNC5pXNK4ZHDJ4BLe6+G9Ht7rGd+ExzfhwSWDSwaXDC6ZdejPrEN/Zh36w3s9Y0vGlgwuGVwyuGRwyeCSwSWDS3ivh/d6eK9nfBMe34QHlwwuGVwyuGTWoT+zDv2ZdegP7/WMLRlbMrhkcMngksElg0sGlwwu4b0e3uvhvZ7xTXh8Ex5cMrhkcMngklmH/sw69GfWoT+81zO2ZGzJ4JLBJYNLBpcMLhlcMriE93p4r4f3esY34fFNeHDJ4JLBJYNLZh36M+vQn1mH/vBez9iSsSWDSwaXDC4ZXDK4ZHDJ4BLe6+G9Ht7rGd+ExzfhwSWDSwaXDC6ZdejjZx36+FmHPnivofcaeq+h9xp6r6H3Gnqvofcaeq+h9xq81+C9Bu819F5D7zX0XkPvNX6WS+JnuSR+1qGPn3Xo42cd+uC9ht5r6L2G3mvovYbea+i9ht5r6L2G3mvwXoP3GrzX0HsNvdfQew291/hZLomf5ZL4WYc+ftahj5916IP3Gnqvofcaeq+h9xp6r6H3Gnqvofcaeq/Bew3ea/BeQ+819F5D7zX0XuNnuSR+lkviZx36+FmHPn7WoQ/ea+i9ht5r6L2G3mvovYbea+i9ht5r6L0G7zV4r8F7Db3X0HsNvdfQe42f9hfQ/gLWoY+fdejjZx364L2G3mvovYbea+i9ht5r6L2G3mvovYbea/Beg/cavNfQew2919B7Db3XOMslcZZL4qxDH2cd+jjr0AfvNfReQ+819F5D7zX0XkPvNfReQ+819F6D9xq81+C9ht5r6L2G3mvovcZZLomzXBJnHfo469DHWYc+eK+h9xp6r6H3Gnqvofcaeq+h9xp6r6H3GrzX4L0G7zX0XkPvNfReQ+81znJJnOWSOOvQx1mHPs469MF7Db3X0HsNvdfQew2919B7Db3X0HsNvdfgvQbvNXivofcaeq+h9xp6r3Gev4DnL2Ad+jjr0MdZhz54r6H3Gnqvofcaeq+h9xp6r6H3GnqvofcavNfgvQbvNfReQ+819F5D7zXO+AsYfwHr0MdZhz7OOvTBew2919B7Db3X0HsNvdfQew2919B7Db3X4L0G7zV4r6H3Gnqvofcaeq8RuCRwSaxDH7EOfcQ69MF7Db3X0HsNvdfQew2919B7Db3X0HsNvdfgvQbvNXivofcaeq+h9xp6rxG4JHBJrEMfsQ59xDr0wXsNvdfQew2919B7Db3X0HsNvdfQew291+C9Bu81eK+h9xp6r6H3GnqvEbgkcEmsQx+xDn3EOvTBew2919B7Db3X0HsNvdfQew2919B7Db3X4L0G7zV4r6H3Gnqvofcaeq8RuCRwSaxDH7EOfcQ69MF7Db3X0HsNvdfQew2919B7Db3X0HsNvdfgvQbvNXivofcaeq+h9xp6r5G4JHFJrkMfuQ595Dr0wXsNvdfQew2919B7Db3X0HsNvdfQew291+C9Bu81eK+h9xp6r6H3GnqvkbgkcUmuQx+5Dn3kOvTBew2919B7Db3X0HsNvdfQew2919B7Db3X4L0G7zV4r6H3Gnqvofcaeq+RuCRxSa5DH7kOfeQ69MF7Db3X0HsNvdfQew2919B7Db3X0HsNvdfgvQbvNXivofcaeq+h9xp6r5G4JHFJrkMfuQ595Dr0wXsNvdfQew2919B7Db3X0HsNvdfQew291+C9Bu81eK+h9xp6r6H3GnqvkbgkcUmuQx+5Dn3kOvTBew2919B7Db3X0HsNvdfQew2919B7Db3X4L0G7zV4r6H3Gnqvofcaeq9RuKRwSa1DH7UOfdQ69MF7Db3X0HsNvdfQew2919B7Db3X0HsNvdfgvQbvNXivofcaeq+h9xp6r1G4pHBJrUMftQ591Dr0wXsNvdfQew2919B7Db3X0HsNvdfQew291+C9Bu81eK+h9xp6r6H3GnqvUbikcEmtQx+1Dn3UOvTBew2919B7Db3X0HsNvdfQew2919B7Db3X4L0G7zV4r6H3Gnqvofcaeq9RuKRwSa1DH7UOfdQ69MF7Db3X0HsNvdfQew2919B7Db3X0HsNvdfgvQbvNXivofcaeq+h9xp6r3FxycUldx36uOvQx12HPnivofcaeq+h9xp6r6H3Gnqvofcaeq+h9xq81+C9Bu819F5D7zX0XkPvNS4uubjkrkMfdx36uOvQB+819F5D7zX0XkPvNfReQ+819F5D7zX0XoP3GrzX4L2G3mvovYbea+i9xsUlF5fcdejjrkMfdx364L2G3mvovYbea+i9ht5r6L2G3mvovYbea/Beg/cavNfQew2919B7Db3XuLjk4pK7Dn3cdejjrkMfvNfQew2919B7Db3X0HsNvdfQew2919B7Dd5r8F6D9xp6r6H3GnqvofcaF5dcXHLXoY+7Dn3cdeiD9xp6r6H3Gnqvofcaeq+h9xp6r6H3GnqvwXsN3mvwXkPvNfReQ+819F7jwyUfLvnWoY9vHfr41qEP3mvovYbea+i9ht5r6L2G3mvovYbea+i9Bu81eK/Bew2919B7Db3X0HuND5d8uORbhz6+dejjW4c+eK+h9xp6r6H3Gnqvofcaeq+h9xp6r6H3GrzX4L0G7zX0XkPvNfReQ+81Plzy4ZJvHfr41qGPbx364L2G3mvovYbea+i9ht5r6L2G3mvovYbea/Beg/cavNfQew2919B7Db3X+HDJh0u+dejjW4c+vnXog/caeq+h9xp6r6H3Gnqvofcaeq+h9xp6r8F7Dd5r8F5D7zX0XkPvNfRe4+GSh0veOvTx1qGPtw598F5D7zX0XkPvNfReQ+819F5D7zX0XkPvNXivwXsN3mvovYbea+i9ht5rPFzycMlbhz7eOvTx1qEP3mvovYbea+i9ht5r6L2G3mvovYbea+i9Bu81eK/Bew2919B7Db3X0HuNh0seLnnr0Mdbhz7eOvTBew2919B7Db3X0HsNvdfQew2919B7Db3X4L0G7zV4r6H3Gnqvofcaeq/xcMnDJW8d+njr0Mdbhz54r6H3Gnqvofcaeq+h9xp6r6H3GnqvofcavNfgvQbvNfReQ+819F5D7zUeLnm45K1DH28d+njr0AfvNfReQ+819F5D7zX0XkPvNfReQ+819F6D9xq81+C9ht5r6L2G3mvovUbjksYlvQ599Dr00evQB+819F5D7zX0XkPvNfReQ+819F5D7zX0XoP3GrzX4L2G3mvovYbea+i9RuOSxiW9Dn30OvTR69AH7zX0XkPvNfReQ+819F5D7zX0XkPvNfReg/cavNfgvYbea+i9ht5r6L1G45LGJb0OffQ69NHr0AfvNfReQ+819F5D7zX0XkPvNfReQ+819F6D9xq81+C9ht5r6L2G3mvovUbjksYlvQ599Dr00evQB+819F5D7zX0XkPvNfReQ+819F5D7zX0XoP3GrzX4L2G3mvovYbea+i9RuOSwSWzDn3MOvQx69AH7zX0XkPvNfReQ+819F5D7zX0XkPvNfReg/cavNfgvYbea+i9ht5r6L3G4JLBJbMOfcw69DHr0AfvNfReQ+819F5D7zX0XkPvNfReQ+819F6D9xq81+C9ht5r6L2G3mvovcbgksElsw59zDr0MevQB+819F5D7zX0XkPvNfReQ+819F5D7zX0XoP3GrzX4L2G3mvovYbea+i9xuCSwSWzDn3MOvQx69AH7zX0XkPvNfReQ+819F5D7zX0XkPvNfReg/cavNfgvYbea+i9ht5r6L3G4JLBJbMOfcw69DHr0AfvNfReQ+819F5D7zX0XkPvNfReU+819V6T95q81+S9pt5r6r2m3mvqvebPckn+LJfkzzr0+bMOff6sQ5+819R7Tb3X1HtNvdfUe02919R7Tb3X1HtN3mvyXpP3mnqvqfeaeq+p95o/yyX5s1ySP+vQ58869PmzDn3yXlPvNfVeU+819V5T7zX1XlPvNfVeU+81ea/Je03ea+q9pt5r6r2m3mv+LJfkz3JJ/qxDnz/r0OfPOvTJe02919R7Tb3X1HtNvdfUe02919R7Tb3X5L0m7zV5r6n3mnqvqfeaeq/58/wFPH8B69Dnzzr0+bMOffJeU+819V5T7zX1XlPvNfVeU+819V5T7zV5r8l7Td5r6r2m3mvqvabea/6Mv4DxF7AOfZ516POsQ5+819R7Tb3X1HtNvdfUe02919R7Tb3X1HtN3mvyXpP3mnqvqfeaeq+p95pnuSTPckmedejzrEOfZx365L2m3mvqvabea+q9pt5r6r2m3mvqvabea/Jek/eavNfUe02919R7Tb3XPMsleZZL8qxDn2cd+jzr0CfvNfVeU+819V5T7zX1XlPvNfVeU+819V6T95q81+S9pt5r6r2m3mvqveZZLsmzXJJnHfo869DnWYc+ea+p95p6r6n3mnqvqfeaeq+p95p6r6n3mrzX5L0m7zX1XlPvNfVeU+81T/sLaH8B69DnWYc+zzr0yXtNvdfUe02919R7Tb3X1HtNvdfUe0291+S9Ju81ea+p95p6r6n3mnqvGbgkcEmsQ5+xDn3GOvTJe02919R7Tb3X1HtNvdfUe02919R7Tb3X5L0m7zV5r6n3mnqvqfeaeq8ZuCRwSaxDn7EOfcY69Ml7Tb3X1HtNvdfUe02919R7Tb3X1HtNvdfkvSbvNXmvqfeaeq+p95p6rxm4JHBJrEOfsQ59xjr0yXtNvdfUe02919R7Tb3X1HtNvdfUe0291+S9Ju81ea+p95p6r6n3mnqvGbgkcEmsQ5+xDn3GOvTJe02919R7Tb3X1HtNvdfUe02919R7Tb3X5L0m7zV5r6n3mnqvqfeaeq8ZuCRwSaxDn7EOfcY69Ml7Tb3X1HtNvdfUe02919R7Tb3X1HtNvdfkvSbvNXmvqfeaeq+p95p6r5m4JHFJrkOfuQ595jr0yXtNvdfUe02919R7Tb3X1HtNvdfUe0291+S9Ju81ea+p95p6r6n3mnqvmbgkcUmuQ5+5Dn3mOvTJe02919R7Tb3X1HtNvdfUe02919R7Tb3X5L0m7zV5r6n3mnqvqfeaeq+ZuCRxSa5Dn7kOfeY69Ml7Tb3X1HtNvdfUe02919R7Tb3X1HtNvdfkvSbvNXmvqfeaeq+p95p6r5m4JHFJrkOfuQ595jr0yXtNvdfUe02919R7Tb3X1HtNvdfUe0291+S9Ju81ea+p95p6r6n3mnqvWbikcEmtQ5+1Dn3WOvTJe02919R7Tb3X1HtNvdfUe02919R7Tb3X5L0m7zV5r6n3mnqvqfeaeq9ZuKRwSa1Dn7UOfdY69Ml7Tb3X1HtNvdfUe02919R7Tb3X1HtNvdfkvSbvNXmvqfeaeq+p95p6r1m4pHBJrUOftQ591jr0yXtNvdfUe02919R7Tb3X1HtNvdfUe0291+S9Ju81ea+p95p6r6n3mnqvWbikcEmtQ5+1Dn3WOvTJe02919R7Tb3X1HtNvdfUe02919R7Tb3X5L0m7zV5r6n3mnqvqfeaeq9ZuKRwSa1Dn7UOfdY69Ml7Tb3X1HtNvdfUe02919R7Tb3X1HtNvdfkvSbvNXmvqfeaeq+p95p6r3lxycUldx36vOvQ512HPnmvqfeaeq+p95p6r6n3mnqvqfeaeq+p95q81+S9Ju819V5T7zX1XlPvNS8uubjkrkOfdx36vOvQJ+819V5T7zX1XlPvNfVeU+819V5T7zX1XpP3mrzX5L2m3mvqvabea+q95sUlF5fcdejzrkOfdx365L2m3mvqvabea+q9pt5r6r2m3mvqvabea/Jek/eavNfUe02919R7Tb3XvLjk4pK7Dn3edejzrkOfvNfUe02919R7Tb3X1HtNvdfUe02919R7Td5r8l6T95p6r6n3mnqvqfeaHy75cMm3Dn1+69Dntw598l5T7zX1XlPvNfVeU+819V5T7zX1XlPvNXmvyXtN3mvqvabea+q9pt5rfrjkwyXfOvT5rUOf3zr0yXtNvdfUe02919R7Tb3X1HtNvdfUe0291+S9Ju81ea+p95p6r6n3mnqv+eGSD5d869Dntw59fuvQJ+819V5T7zX1XlPvNfVeU+819V5T7zX1XpP3mrzX5L2m3mvqvabea+q95odLPlzyrUOf3zr0+a1Dn7zX1HtNvdfUe02919R7Tb3X1HtNvdfUe03ea/Jek/eaeq+p95p6r6n3mh8u+XDJtw59fuvQ57cOffJeU+819V5T7zX1XlPvNfVeU+819V5T7zV5r8l7Td5r6r2m3mvqvabeaz5c8nDJW4c+3zr0+dahT95r6r2m3mvqvabea+q9pt5r6r2m3mvqvSbvNXmvyXtNvdfUe02919R7zYdLHi5569DnW4c+3zr0yXtNvdfUe02919R7Tb3X1HtNvdfUe0291+S9Ju81ea+p95p6r6n3mnqv+XDJwyVvHfp869DnW4c+ea+p95p6r6n3mnqvqfeaeq+p95p6r6n3mrzX5L0m7zX1XlPvNfVeU+81Hy55uOStQ59vHfp869An7zX1XlPvNfVeU+819V5T7zX1XlPvNfVek/eavNfkvabea+q9pt5r6r1m45LGJb0OffY69Nnr0CfvNfVeU+819V5T7zX1XlPvNfVeU+819V6T95q81+S9pt5r6r2m3mvqvWbjksYlvQ599jr02evQJ+819V5T7zX1XlPvNfVeU+819V5T7zX1XpP3mrzX5L2m3mvqvabea+q9ZuOSxiW9Dn32OvTZ69An7zX1XlPvNfVeU+819V5T7zX1XlPvNfVek/eavNfkvabea+q9pt5r6r1m45LGJb0OffY69Nnr0CfvNfVeU+819V5T7zX1XlPvNfVeU+819V6T95q81+S9pt5r6r2m3mvqvWbjksYlvQ599jr02evQJ+819V5T7zX1XlPvNfVeU+819V5T7zX1XpP3mrzX5L2m3mvqvabea+q95uCSwSWzDn3OOvQ569An7zX1XlPvNfVeU+819V5T7zX1XlPvNfVek/eavNfkvabea+q9pt5r6r3m4JLBJbMOfc469Dnr0CfvNfVeU+819V5T7zX1XlPvNfVeU+819V6T95q81+S9pt5r6r2m3mvqvebgksElsw59zjr0OevQJ+819V5T7zX1XlPvNfVeU+819V5T7zX1XpP3mrzX5L2m3mvqvabea+q95uCSwSWzDn3OOvQ569An7zX1XlPvNfVeU+819V5T7zX1XlPvNfVek/eavNfkvabea+q9pt5r6r3mLJfUz3JJ/axDXz/r0NfPOvTFey2919J7Lb3X0nstvdfSey2919J7Lb3X4r0W77V4r6X3Wnqvpfdaeq/1s1xSP8sl9bMOff2sQ18/69AX77X0XkvvtfReS++19F5L77X0XkvvtfRei/davNfivZbea+m9lt5r6b3Wz3JJ/SyX1M869PWzDn39rENfvNfSey2919J7Lb3X0nstvdfSey2919J7Ld5r8V6L91p6r6X3WnqvpfdaP8sl9bNcUj/r0NfPOvT1sw598V5L77X0XkvvtfReS++19F5L77X0XkvvtXivxXst3mvpvZbea+m9lt5r/bS/gPYXsA59/axDXz/r0BfvtfReS++19F5L77X0XkvvtfReS++19F6L91q81+K9lt5r6b2W3mvpvdZZLqmzXFJnHfo669DXWYe+eK+l91p6r6X3Wnqvpfdaeq+l91p6r6X3WrzX4r0W77X0XkvvtfReS++1znJJneWSOuvQ11mHvs469MV7Lb3X0nstvdfSey2919J7Lb3X0nstvdfivRbvtXivpfdaeq+l91p6r3WWS+osl9RZh77OOvR11qEv3mvpvZbea+m9lt5r6b2W3mvpvZbea+m9Fu+1eK/Fey2919J7Lb3X0nut8/wFPH8B69DXWYe+zjr0xXstvdfSey2919J7Lb3X0nstvdfSey291+K9Fu+1eK+l91p6r6X3WnqvdcZfwPgLWIe+Yh36inXoi/daeq+l91p6r6X3Wnqvpfdaeq+l91p6r8V7Ld5r8V5L77X0XkvvtfReK3BJ4JJYh75iHfqKdeiL91p6r6X3Wnqvpfdaeq+l91p6r6X3WnqvxXst3mvxXkvvtfReS++19F4rcEngkliHvmId+op16Iv3Wnqvpfdaeq+l91p6r6X3Wnqvpfdaeq/Fey3ea/FeS++19F5L77X0XitwSeCSWIe+Yh36inXoi/daeq+l91p6r6X3Wnqvpfdaeq+l91p6r8V7Ld5r8V5L77X0XkvvtfReK3BJ4JJYh75iHfqKdeiL91p6r6X3Wnqvpfdaeq+l91p6r6X3WnqvxXst3mvxXkvvtfReS++19F4rcUniklyHvnId+sp16Iv3Wnqvpfdaeq+l91p6r6X3Wnqvpfdaeq/Fey3ea/FeS++19F5L77X0XitxSeKSXIe+ch36ynXoi/daeq+l91p6r6X3Wnqvpfdaeq+l91p6r8V7Ld5r8V5L77X0XkvvtfReK3FJ4pJch75yHfrKdeiL91p6r6X3Wnqvpfdaeq+l91p6r6X3WnqvxXst3mvxXkvvtfReS++19F4rcUniklyHvnId+sp16Iv3Wnqvpfdaeq+l91p6r6X3Wnqvpfdaeq/Fey3ea/FeS++19F5L77X0XitxSeKSXIe+ch36ynXoi/daeq+l91p6r6X3Wnqvpfdaeq+l91p6r8V7Ld5r8V5L77X0XkvvtfReq3BJ4ZJah75qHfqqdeiL91p6r6X3Wnqvpfdaeq+l91p6r6X3WnqvxXst3mvxXkvvtfReS++19F6rcEnhklqHvmod+qp16Iv3Wnqvpfdaeq+l91p6r6X3Wnqvpfdaeq/Fey3ea/FeS++19F5L77X0XqtwSeGSWoe+ah36qnXoi/daeq+l91p6r6X3Wnqvpfdaeq+l91p6r8V7Ld5r8V5L77X0XkvvtfReq3BJ4ZJah75qHfqqdeiL91p6r6X3Wnqvpfdaeq+l91p6r6X3WnqvxXst3mvxXkvvtfReS++19F7r4pKLS+469HXXoa+7Dn3xXkvvtfReS++19F5L77X0XkvvtfReS++1eK/Fey3ea+m9lt5r6b2W3mtdXHJxyV2Hvu469HXXoS/ea+m9lt5r6b2W3mvpvZbea+m9lt5r6b0W77V4r8V7Lb3X0nstvdfSe62LSy4uuevQ112Hvu469MV7Lb3X0nstvdfSey2919J7Lb3X0nstvdfivRbvtXivpfdaeq+l91p6r3VxycUldx36uuvQ112Hvnivpfdaeq+l91p6r6X3Wnqvpfdaeq+l91q81+K9Fu+19F5L77X0XkvvtS4uubjkrkNfdx36uuvQF++19F5L77X0XkvvtfReS++19F5L77X0Xov3WrzX4r2W3mvpvZbea+m91odLPlzyrUNf3zr09a1DX7zX0nstvdfSey2919J7Lb3X0nstvdfSey3ea/Fei/daeq+l91p6r6X3Wh8u+XDJtw59fevQ17cOffFeS++19F5L77X0XkvvtfReS++19F5L77V4r8V7Ld5r6b2W3mvpvZbea3245MMl3zr09a1DX9869MV7Lb3X0nstvdfSey2919J7Lb3X0nstvdfivRbvtXivpfdaeq+l91p6r/Xhkg+XfOvQ17cOfX3r0BfvtfReS++19F5L77X0XkvvtfReS++19F6L91q81+K9lt5r6b2W3mvpvdbDJQ+XvHXo661DX28d+uK9lt5r6b2W3mvpvZbea+m9lt5r6b2W3mvxXov3WrzX0nstvdfSey2913q45OGStw59vXXo661DX7zX0nstvdfSey2919J7Lb3X0nstvdfSey3ea/Fei/daeq+l91p6r6X3Wg+XPFzy1qGvtw59vXXoi/daeq+l91p6r6X3Wnqvpfdaeq+l91p6r8V7Ld5r8V5L77X0XkvvtfRe6+GSh0veOvT11qGvtw598V5L77X0XkvvtfReS++19F5L77X0XkvvtXivxXst3mvpvZbea+m9lt5rPVzycMlbh77eOvT11qEv3mvpvZbea+m9lt5r6b2W3mvpvZbea+m9Fu+1eK/Fey2919J7Lb3X0nutxiWNS3od+up16KvXoS/ea+m9lt5r6b2W3mvpvZbea+m9lt5r6b0W77V4r8V7Lb3X0nstvdfSe63GJY1Leh366nXoq9ehL95r6b2W3mvpvZbea+m9lt5r6b2W3mvpvRbvtXivxXstvdfSey2919J7rcYljUt6Hfrqdeir16Ev3mvpvZbea+m9lt5r6b2W3mvpvZbea+m9Fu+1eK/Fey2919J7Lb3X0nutxiWNS3od+up16KvXoS/ea+m9lt5r6b2W3mvpvZbea+m9lt5r6b0W77V4r8V7Lb3X0nstvdfSe63BJYNLZh36mnXoa9ahL95r6b2W3mvpvZbea+m9lt5r6b2W3mvpvRbvtXivxXstvdfSey2919J7rcElg0tmHfqadehr1qEv3mvpvZbea+m9lt5r6b2W3mvpvZbea+m9Fu+1eK/Fey2919J7Lb3X0nutwSWDS2Yd+pp16GvWoS/ea+m9lt5r6b2W3mvpvZbea+m9lt5r6b0W77V4r8V7Lb3X0nstvdfSe63BJYNLZh36mnXoa9ahL95r6b2W3mvpvZbea+m9lt5r6b2W3mvpvRbvtXivxXstvdfSey2919J7rcElg0tmHfqadehr1qEv3mvpvZbea+m9lt5r6b1evder93r1Xq/e6+W9Xt7r5b1evder93r1Xq/e6/1ZLrk/yyX3Zx36+7MO/f1Zh/7yXq/e69V7vXqvV+/16r1evder93r1Xq/e6+W9Xt7r5b1evder93r1Xq/e6/1ZLrk/yyX3Zx36+7MO/f1Zh/7yXq/e69V7vXqvV+/16r1evder93r1Xq/e6+W9Xt7r5b1evder93r1Xq/e6/1ZLrk/yyX3Zx36+7MO/f1Zh/7yXq/e69V7vXqvV+/16r1evder93r1Xq/e6+W9Xt7r5b1evder93r1Xq/e6/15/gKev4B16O/POvT3Zx36y3u9eq9X7/XqvV6916v3evVer97r1Xu9eq+X93p5r5f3evVer97r1Xu9eq/3Z7nknuWSe9ahv2cd+nvWob+816v3evVer97r1Xu9eq9X7/XqvV6916v3enmvl/d6ea9X7/XqvV6916v3es9yyT3LJfesQ3/POvT3rEN/ea9X7/XqvV6916v3evVer97r1Xu9eq9X7/XyXi/v9fJer97r1Xu9eq9X7/We5ZJ7lkvuWYf+nnXo71mH/vJer97r1Xu9eq9X7/XqvV6916v3evVer97r5b1e3uvlvV6916v3evVer97rPcsl9yyX3LMO/T3r0N+zDv3lvV6916v3evVer97r1Xu9eq9X7/XqvV6918t7vbzXy3u9eq9X7/XqvV6913vaX0D7C1iH/p516O9Zh/7yXq/e69V7vXqvV+/16r1evder93r1Xq/e6+W9Xt7r5b1evder93r1Xq/e6w1cErgk1qG/sQ79jXXoL+/16r1evder93r1Xq/e69V7vXqvV+/16r1e3uvlvV7e69V7vXqvV+/16r3ewCWBS2Id+hvr0N9Yh/7yXq/e69V7vXqvV+/16r1evder93r1Xq/e6+W9Xt7r5b1evder93r1Xq/e6w1cErgk1qG/sQ79jXXoL+/16r1evder93r1Xq/e69V7vXqvV+/16r1e3uvlvV7e69V7vXqvV+/16r3ewCWBS2Id+hvr0N9Yh/7yXq/e69V7vXqvV+/16r1evder93r1Xq/e6+W9Xt7r5b1evder93r1Xq/e6w1cErgk1qG/uQ79zXXoL+/16r1evder93r1Xq/e69V7vXqvV+/16r1e3uvlvV7e69V7vXqvV+/16r3exCWJS3Id+pvr0N9ch/7yXq/e69V7vXqvV+/16r1evder93r1Xq/e6+W9Xt7r5b1evder93r1Xq/e601ckrgk16G/uQ79zXXoL+/16r1evder93r1Xq/e69V7vXqvV+/16r1e3uvlvV7e69V7vXqvV+/16r3exCWJS3Id+pvr0N9ch/7yXq/e69V7vXqvV+/16r1evder93r1Xq/e6+W9Xt7r5b1evder93r1Xq/e601ckrgk16G/uQ79zXXoL+/16r1evder93r1Xq/e69V7vXqvV+/16r1e3uvlvV7e69V7vXqvV+/16r3ewiWFS2od+lvr0N9ah/7yXq/e69V7vXqvV+/16r1evder93r1Xq/e6+W9Xt7r5b1evder93r1Xq/e6y1cUrik1qG/tQ79rXXoL+/16r1evder93r1Xq/e69V7vXqvV+/16r1e3uvlvV7e69V7vXqvV+/16r3ewiWFS2od+lvr0N9ah/7yXq/e69V7vXqvV+/16r1evder93r1Xq/e6+W9Xt7r5b1evder93r1Xq/e6y1cUrik1qG/tQ79rXXoL+/16r1evder93r1Xq/e69V7vXqvV+/16r1e3uvlvV7e69V7vXqvV+/16r3ewiWFS2od+lvr0N9ah/7yXq/e69V7vXqvV+/16r1evder93r1Xq/e6+W9Xt7r5b1evder93r1Xq/e67245OKSuw79vevQ37sO/eW9Xr3Xq/d69V6v3uvVe716r1fv9eq9Xr3Xy3u9vNfLe716r1fv9eq9Xr3Xe3HJxSV3Hfp716G/dx36y3u9eq9X7/XqvV6916v3evVer97r1Xu9eq+X93p5r5f3evVer97r1Xu9eq/34pKLS+469PeuQ3/vOvSX93r1Xq/e69V7vXqvV+/16r1evder93r1Xi/v9fJeL+/16r1evder93r1Xu/FJReX3HXo712H/t516C/v9eq9Xr3Xq/d69V6v3uvVe716r1fv9eq9Xt7r5b1e3uvVe716r1fv9eq93g+XfLjkW4f+fuvQ328d+st7vXqvV+/16r1evder93r1Xq/e69V7vXqvl/d6ea+X93r1Xq/e69V7vXqv98MlHy751qG/3zr091uH/vJer97r1Xu9eq9X7/XqvV6916v3evVer97r5b1e3uvlvV6916v3evVer97r/XDJh0u+dejvtw79/dahv7zXq/d69V6v3uvVe716r1fv9eq9Xr3Xq/d6ea+X93p5r1fv9eq9Xr3Xq/d6P1zy4ZJvHfr7rUN/v3XoL+/16r1evder93r1Xq/e69V7vXqvV+/16r1e3uvlvV7e69V7vXqvV+/16r3eD5d8uORbh/5+69Dfbx36y3u9eq9X7/XqvV6916v3evVer97r1Xu9eq+X93p5r5f3evVer97r1Xu9eq/34ZKHS9469PetQ3/fOvSX93r1Xq/e69V7vXqvV+/16r1evder93r1Xi/v9fJeL+/16r1evder93r1Xu/DJQ+XvHXo71uH/r516C/v9eq9Xr3Xq/d69V6v3uvVe716r1fv9eq9Xt7r5b1e3uvVe716r1fv9eq93odLHi5569Dftw79fevQX97r1Xu9eq9X7/XqvV6916v3evVer97r1Xu9vNfLe72816v3evVer97r1Xu9D5c8XPLWob9vHfr71qG/vNer93r1Xq/e69V7vXqvV+/16r1evder93p5r5f3enmvV+/16r1evder93oblzQu6XXob69Df3sd+st7vXqvV+/16r1evder93r1Xq/e69V7vXqvl/d6ea+X93r1Xq/e69V7vXqvt3FJ45Jeh/72OvS316G/vNer93r1Xq/e69V7vXqvV+/16r1evder93p5r5f3enmvV+/16r1evder93oblzQu6XXob69Df3sd+st7vXqvV+/16r1evder93r1Xq/e69V7vXqvl/d6ea+X93r1Xq/e69V7vXqvt3FJ45Jeh/72OvS316G/vNer93r1Xq/e69V7vXqvV+/16r1evder93p5r5f3enmvV+/16r1evder93oblzQu6XXob69Df3sd+st7vXqvV+/16r1evder93r1Xq/e69V7vXqvl/d6ea+X93r1Xq/e69V7vXqvd3DJ4JJZh/7OOvR31qG/vNer93r1Xq/e69V7vXqvV+/16r1evder93p5r5f3enmvV+/16r1evder93oHlwwumXXo76xDf2cd+st7vXqvV+/16r1evder93r1Xq/e69V7vXqvl/d6ea+X93r1Xq/e69V7vXqvd3DJ4JJZh/7OOvR31qG/vNer93r1Xq/e69V7vXqvV+/16r1evder93p5r5f3enmvV+/16r1evder93oHlwwumXXo76xDf2cd+st7vXqvV+/16r1evder93r1Xq/e69V7vXqvl/d6ea+X93r1Xq/e69V7/fRev5/lku9nueT7WYf++1mH/vtZh/7jvX56r5/e66f3+um9fnqvn97rp/f66b1+eq8f7/XjvX6810/v9dN7/fReP73X72e55PtZLvl+1qH/ftah/37Wof94r5/e66f3+um9fnqvn97rp/f66b1+eq+f3uvHe/14rx/v9dN7/fReP73XT+/1+1ku+X6WS76fdei/n3Xov5916D/e66f3+um9fnqvn97rp/f66b1+eq+f3uun9/rxXj/e68d7/fReP73XT+/103v9fpZLvp/lku9nHfrvZx3672cd+o/3+um9fnqvn97rp/f66b1+eq+f3uun9/rpvX6814/3+vFeP73XT+/103v99F6/n/YXMP4C1qH/ftah//54r9/ff/D7133/e17Pz/N5tuf8e/7xXv89j2d4pmd5Xs/P8/fXvv+e7Tn7/PNN+O/zeIbn76/Nf8///9qL/57338V/vNe/v3aeZ3u6LdwWbgu3hdvCbeG28Gvh18KvhdvSbem2dNvvlvx7lufdi3+35O/Fv1vy9+L0a+m2clu5rdxWbiu3ldvKbeW28mvl165fu267brtuu2773ZJ/z8/z7cW/W/L34t8t+Xvx59c+t31u+9z2ue1z2+e2z22f2z63Pb/2/Nrza89tz23Pbc9tz1/A8xfwuyV/L/7dkr8X/27J34vbr7Xb2m3ttnZbu63d1m4bt43bxq+NX7Mlf7zXv//1cdu4bdw2+xfwX+/17/P8u/iP9/rfxX+81/8uDlsStiRsyR/v9d+zPfe2P97rv+fxDM/09GvHr9mSP97r3//6aU+3hdvieIbnLtcf7/XvxbHLFbYkbEnYkj/e699nui3dlm5Lt6Xb0m3p19Kv2ZI/3uvf/3q5rdxWbqv0LM9drj/e69+La5crbEnYkrAlf7zXf0+3Xbddt123Xbddt12/dv2aLfnjvf79r39u+9z2ue27np/nLtcf7/Xvxd8uV9iSsCVhS/54r/+ebntue257bntue25rv9Z+zZb88V7//tfbbe22dlv7C2h/Ab3L9cd7/Xvx7HKFLQlbErYkcEngksAlgUsClyQuSVySuCRxSdqSP97rf//1P97rv+fzbM/9C0hc8sd7/e/iP97rfxf/8V7/uzhtSdqStCWJSxKXJC5JXJK4JHFJ4pLEJYlL0pb88V7//tfDbbgkcUniksQlf7zXvxfnLtcf7/XvxbYkbUnaksQliUsSlyQuSVySuCRxSeKSxCVpS/54r3//69dtuCRxSeKSxCV/vNe/F99drj/e69+LbUnakrQliUsSlyQuSVySuCRxSeKSxCWJS9KW/PFe//7Xn9twSeKSxCWJS/54r38vfrtcf7zXvxfbkrQlaUsSlyQuSVySuCRxSeKSxCWJSxKXpC35473+/a+P23BJ4pLEJYlL/niv/138x3v97+I/3ut/F5ctKVtStqRwSeGSwiWFSwqXFC4pXFK4pHBJ2ZI/3ut///U/3uu/5/Nsz/0LKFzyx3v9e3Hscv3xXv9ebEvKlpQtKVxSuKRwSeGSwiWFSwqXFC4pXFK25I/3+ve/nm7DJYVLCpcULvnjvf69uHa5/nivfy+2JWVLypYULilcUrikcEnhksIlhUsKlxQuKVvyx3v9+1//3IZLCpcULilc8sd7/Xvxt8v1x3v9e7EtKVtStqRwSeGSwiWFSwqXFC4pXFK4pHBJ2ZI/3uvf/3q7DZcULilcUrjkj/f69+Le5frjvf692JaULSlbUrikcEnhksIlhUsKlxQuubjk4pJrS/54r//91/94r/+e1/PzfJ7tucv1x3v97+I/3ut/F19bcm3JtSUXl1xccnHJxSUXl1xccnHJxSUXl1xb8sd7/ftfD7fhkotLLi65uOSP9/r34tzl+uO9/r3Yllxbcm3JxSUXl1xccnHJxSUXl1xccnHJxSXXlvzxXv/+18ttuOTikotLLi75473+vfjucv3xXv9ebEuuLbm25OKSi0suLrm45OKSi0suLrm45OKSa0v+eK9//+vPbbjk4pKLSy4u+eO9/r347XL98V7/XmxLri25tuTikotLLi65uOTikotLLi65uOTikmtL/nivf//r4zZccnHJxSUXl/zxXv9ePLtcf7zX/y7+bMlnSz5b8uGSD5d8uOTDJR8u+XDJh0s+XPLhks+W/PFe//uv//Fe/z2v5+f5PNtzl+uP9/rfxX+8178X25LPlny25MMlHy75cMmHSz5c8uGSD5d8uOTDJZ8t+eO9/v2vp9twyYdLPlzy4ZI/3uvfi2uX64/3+vdiW/LZks+WfLjkwyUfLvlwyYdLPlzy4ZIPl3y45LMlf7zXv//16zZc8uGSD5d8uOSP9/r34m+X64/3+vdiW/LZks+WfLjkwyUfLvlwyYdLPlzy4ZIPl3y45LMlf7zXv//1dhsu+XDJh0s+XPLHe/17ce9y/fFe/15sSz5b8tmSD5d8uOTDJR8u+XDJh0s+XPLhkg+XPFvyx3v977/+x3v990zP8ryen+cu1x/v9b+L/3iv/138bMmzJc+WPFzycMnDJQ+XPFzycMnDJQ+XPFzybMkf7/Xvfz3chkseLnm45OGSP97r34tzl+uP9/r3YlvybMmzJQ+XPFzycMnDJQ+XPFzycMnDJQ+XPFvyx3v9+18vt+GSh0seLnm45I/3+vfiu8v1x3v9e7Etebbk2ZKHSx4uebjk4ZKHSx4uebjk4ZKHS54t+eO9/v2vf27DJQ+XPFzycMkf7/XvxW+X64/3+vdiW/JsybMlD5c8XPJwycMlD5c8XPJwycMlD5c8W/LHe/37Xx+34ZKHSx4uebjkj/f69+LZ5frjvf692JY8W9K2pHFJ45LGJY1LGpc0Lmlc0rikcUnbkvZNuH0TblzSuKRxSeOSP97rfxf/8V7/u/iP9/rfxW1L2pa0LWlc0rikcUnjksYljUsalzQuaVzStqR9E27fhBuXNC5pXNK45I/3+vfi2uX6473+vdiWtC1pW9K4pHFJ45LGJY1LGpc0Lmlc0rikbUn7Jty+CTcuaVzSuKRxyR/v9e/F3y7XH+/178W2pG1J25LGJY1LGpc0Lmlc0rikcUnjksYlbUvaN+H2TbhxSeOSxiWNS/54r38v7l2uP97r34ttSduStiWNSxqXNC5pXNK4pHFJ45LGJY1L2pa0b8Ljm/DgksElg0sGl/zxXv+7+I/3+t/Ff7zX/y4eWzK2ZGzJ4JLBJYNLBpcMLhlcMrhkcMngkrEl45vw+CY8uGRwyeCSwSV/vNe/F8cu1x/v9e/FtmRsydiSwSWDSwaXDC4ZXDK4ZHDJ4JLBJWNLxjfh8U14cMngksElg0v+eK9/L767XH+8178X25KxJWNLBpcMLhlcMrhkcMngksElg0sGl4wtGd+ExzfhwSWDSwaXDC75473+vfjtcv3xXv9ebEvGlowtGVwyuGRwyeCSwSWDSwaXDC4ZXDK2ZHwTHt+EB5cMLhlcMrjkj/f69+LZ5frjvf692JaMLRlbMssl72e55P0sl7yf5ZL3s1zyfpZL3s9yyftZLnk/yyXvZ7fk/ew34fez34Tfz3LJ+1kueT/LJe9nueT98V7/XPz+eK9/Ln5/vNc/F7+f49eO28Jt4bZwW7gt3BZuC7eF28KvhV9Lv5ZuS7el29JtyyXvZ7nk/fFe/16cvRfn7MXl18pt5bZyW7mt3FZuK7eV28pt169dv3b92nXbddt123Xbcsn7WS55f7zXvxd/P3vxd/biz699bvvc9rntc9vnts9tn9ue257bnl97fu35tee257bntue25y+g/QX02Ys79uLOvbj9Wrut3dZua7e128Zt47Zx27ht/Nr4tfFr47Zx23LJO8sl7yyXvLNc8v7zXue/57/lev95r/Xfc3/t2JJjS85yyTvLJe8sl7yzXPLOcsk7yyXvLJc83uvjvT7e6zvHbeG2cFu4bbnkneWS95/3+t/Fscv1n/f638W25NiSY0tOui3dlm5Lt6Xb0m3ptvRr6ddsySm3ldvKbeW25ZJ3lkvef97rfxfXLtd/3ut/F9uSY0uOLTnXbddt123Xbddt123XbZ9f+/yaLTmf2z63fW773LZc8s5yyfvPe/3v4rfL9Z/3+t/FtuTYkmNLznPbc9tz23Pbc1u7rd3Wfq39mi057bZ2W7ut3db+AsZfwOxy/fFe/168Dv3jvb5jS44tOeO2cRsuCVwSuCRwSeAS3uvjvT7e64v9Jvxivwm/wCWBSwKXBC6JdehfrEP/Yh36x3t9YUvClgQuCVwSuCRwSeCSwCWBS3ivj/f6eK8vwm3pNlwSuCRwSeCSWIf+xTr0L9ahf7zXF7YkbEngksAlgUsClwQuCVwSuIT3+nivj/f64rrtug2XBC4JXBK4JNahf7EO/Yt16B/v9YUtCVsSuCRwSeCSwCWBSwKXBC7hvT7e6+O9vnhue27DJYFLApcELol16F+sQ/9iHfrHe31hS8KWBC4JXBK4JHBJ4JLAJYFLeK+P9/p4ry/GbeM2XBK4JHBJ4pJch/7lOvQv16F/vNeXtiRtSeKSxCWJSxKXJC5JXJK4hPf6eK+P9/pyvwm/3G/CL3FJ4pLEJYlLch36l+vQv1yH/vFeX9qStCWJSxKXJC5JXJK4JHFJ4hLe6+O9Pt7ry3RbuQ2XJC5JXJK4JNehf7kO/ct16B/v9aUtSVuSuCRxSeKSxCWJSxKXJC7hvT7e6+O9vvzc9rkNlyQuSVySuCTXoX+5Dv3Ldegf7/WlLUlbkrgkcUniksQliUsSlyQu4b0+3uvjvb5st7XbcEniksQliUtyHfqX69C/XIf+8V5f2pK0JYlLEpckLklckrikcEnhEt7r470+3uur/Sb8ar8Jv8IlhUsKlxQuqXXoX61D/2od+sd7fWVLypYULilcUrikcEnhksIlhUt4r4/3+nivr8Jt4TZcUrikcEnhklqH/tU69K/WoX+811e2pGxJ4ZLCJYVLCpcULilcUriE9/p4r4/3+qrcdt2GSwqXFC4pXFLr0L9ah/7VOvSP9/rKlpQtKVxSuKRwSeGSwiWFSwqX8F4f7/XxXl89tz234ZLCJYVLCpfUOvSv1qF/tQ79472+siVlSwqXFC4pXFK4pHBJ4ZLCJbzXx3t9vNdX47ZxGy4pXFK4pHBJrUP/7jr0765D/3iv79qSa0suLrm45OKSi0suLrm45OIS3uvjvT7e67v7Tfjd/Sb8Li65uOTikotL7jr0765D/+469I/3+q4tubbk4pKLSy4uubjk4pKLSy4u4b0+3uvjvb6bbku34ZKLSy4uubjkrkP/7jr0765D/3iv79qSa0suLrm45OKSi0suLrm45OIS3uvjvT7e67vXbZ/bcMnFJReXXFxy16F/dx36d9ehf7zXd23JtSUXl1xccnHJxSUXl1xccnEJ7/XxXh/v9d12W7sNl1xccnHJxSV3Hfp316F/dx36x3t915ZcW3JxycUlF5dcXHJxycUlF5fwXh/v9fFe37ffhN+334Tfh0s+XPLhkg+XfOvQv28d+vetQ/94r++zJZ8t+XDJh0s+XPLhkg+XfLjkwyW818d7fbzX94Xbwm245MMlHy75cMm3Dv371qF/3zr0j/f6Plvy2ZIPl3y45MMlHy75cMmHSz5cwnt9vNfHe31fua3chks+XPLhkg+XfOvQv28d+vetQ/94r++zJZ8t+XDJh0s+XPLhkg+XfLjkwyW818d7fbzX931ue27DJR8u+XDJh0u+dejftw79+9ahf7zX99mSz5Z8uOTDJR8u+XDJh0s+XPLhEt7r470+3uv7xm3jNlzy4ZIPl3y45FuH/n3r0L9vHfrHe33Pljxb8nDJwyUPlzxc8nDJwyUPl/BeH+/18V7f8034+Sb8cMnDJQ+XPFzy1qF/bx3699ahf7zX92zJsyUPlzxc8nDJwyUPlzxc8nAJ7/XxXh/v9T3fhJ9vwg+XPFzycMnDJW8d+vfWoX9vHfrHe33Pljxb8nDJwyUPlzxc8nDJwyUPl/BeH+/18V7f8034+Sb8cMnDJQ+XPFzy1qF/bx3699ahf7zX92zJsyUPlzxc8nDJwyUPlzxc8nAJ7/XxXh/v9T3fhJ9vwg+XPFzycMnDJW8d+vfWoX9vHfrHe33Pljxb8nDJwyUPlzxc8nDJwyUPl/BeH+/18V5f+ybcvgk3Lmlc0rikcUmvQ/96HfrX69A/3utrW9K2pHFJ45LGJY1LGpc0Lmlcwnt9vNfHe33tm3D7Jty4pHFJ45LGJb0O/et16F+vQ/94r69tSduSxiWNSxqXNC5pXNK4pHEJ7/XxXh/v9bVvwu2bcOOSxiWNSxqX9Dr0r9ehf70O/eO9vrYlbUsalzQuaVzSuKRxSeOSxiW818d7fbzX174Jt2/CjUsalzQuaVzS69C/Xof+9Tr0j/f62pa0LWlc0rikcUnjksYljUsal/BeH+/18V5f+ybcvgk3Lmlc0rikcUmvQ/96HfrX69A/3utrWzK2ZHDJ4JLBJYNLBpcMLhlcwnt9vNfHe33jm/D4Jjy4ZHDJ4JLBJbMO/Zt16N+sQ/94r29sydiSwSWDSwaXDC4ZXDK4ZHAJ7/XxXh/v9Y1vwuOb8OCSwSWDSwaXzDr0b9ahf7MO/eO9vrElY0sGlwwuGVwyuGRwyeCSwSW818d7fbzXN74Jj2/Cg0sGlwwuGVwy69C/WYf+zTr0j/f6xpaMLRlcMrhkcMngksElg0sGl/BeH+/18V7f+CY8vgkPLhlcMrhkcMmsQ/9mHfo369A/3usbWzK2ZHDJ4JLBJYNLBpcMLhlcwnt9vNfHe32z34T7Z78J989ySf8sl/TPckn/LJf0zzr0/bMOff+sQ9+81/7ZLemf3ZL+WS7pn+WS/lku6Z/lkv5ZLumf5ZL+WS5p3mvzXpv32j/htnBbuC3ctlzSP8sl/bMOff+sQ98/69A377V/0m3ptnRbui3dlm5Lt6Xb0m3l18qvlV8rt5Xbym3ltuWS/lku6Z916PtnHfr+WYe+ea/9c9123Xbddt123Xbddt32ue1z2+fXPr/2+bXPbZ/bPrd9bvv8BTx/AevQ98869P2zDn3zXvvnue257bntue25rd3Wbmu3tdvar7Vfa7/Wbmu3tdvGbeMvYPwFrEPfP+vQ98869M17bb3X1nttvdfWe22919Z7bb3X1nttvdfmvTbvtXmvrffaeq+t99p6r32WS/osl/RZh77POvR91qFv3mvrvbbea+u9tt5r67223mvrvbbea+u9Nu+1ea/Ne22919Z7bb3X1nvts1zSZ7mkzzr0fdah77MOffNeW++19V5b77X1XlvvtfVeW++19V5b77V5r817bd5r67223mvrvbbea5/lkj7LJX3Woe+zDn2fdeib99p6r6332nqvrffaeq+t99p6r6332nqvzXtt3mvzXlvvtfVeW++19V77PH8B7S9gHfo+69D3WYe+ea+t99p6r6332nqvrffaeq+t99p6r6332rzX5r0277X1XlvvtfVeW++1A5cELol16DvWoe9Yh755r6332nqvrffaeq+t99p6r6332nqvrffavNfmvTbvtfVeW++19V5b77UDlwQuiXXoO9ah71iHvnmvrffaeq+t99p6r6332nqvrffaeq+t99q81+a9Nu+19V5b77X1XlvvtQOXBC6Jdeg71qHvWIe+ea+t99p6r6332nqvrffaeq+t99p6r6332rzX5r0277X1XlvvtfVeW++1A5cELol16DvWoe9Yh755r6332nqvrffaeq+t99p6r6332nqvrffavNfmvTbvtfVeW++19V5b77UDlwQuiXXoO9ah71iHvnmvrffaeq+t99p6r6332nqvrffaeq+t99q81+a9Nu+19V5b77X1XlvvtROXJC7Jdeg716HvXIe+ea+t99p6r6332nqvrffaeq+t99p6r6332rzX5r0277X1XlvvtfVeW++1E5ckLsl16DvXoe9ch755r6332nqvrffaeq+t99p6r6332nqvrffavNfmvTbvtfVeW++19V5b77UTlyQuyXXoO9eh71yHvnmvrffaeq+t99p6r6332nqvrffaeq+t99q81+a9Nu+19V5b77X1XlvvtROXJC7Jdeg716HvXIe+ea+t99p6r6332nqvrffaeq+t99p6r6332rzX5r0277X1XlvvtfVeW++1E5cULql16LvWoe9ah755r6332nqvrffaeq+t99p6r6332nqvrffavNfmvTbvtfVeW++19V5b77ULlxQuqXXou9ah71qHvnmvrffaeq+t99p6r6332nqvrffaeq+t99q81+a9Nu+19V5b77X1XlvvtQuXFC6pdei71qHvWoe+ea+t99p6r6332nqvrffaeq+t99p6r6332rzX5r0277X1XlvvtfVeW++1C5cULql16LvWoe9ah755r6332nqvrffaeq+t99p6r6332nqvrffavNfmvTbvtfVeW++19V5b77ULlxQuqXXou9ah71qHvnmvrffaeq+t99p6r6332nqvrffaeq+t99q81+a9Nu+19V5b77X1XlvvtS8uubjkrkPfdx36vuvQN++19V5b77X1XlvvtfVeW++19V5b77X1Xpv32rzX5r223mvrvbbea+u99sUlF5fcdej7rkPfdx365r223mvrvbbea+u9tt5r67223mvrvbbea/Nem/favNfWe22919Z7bb3Xvrjk4pK7Dn3fdej7rkPfvNfWe22919Z7bb3X1nttvdfWe22919Z7bd5r816b99p6r6332nqvrffaF5dcXHLXoe+7Dn3fdeib99p6r6332nqvrffaeq+t99p6r6332nqvzXtt3mvzXlvvtfVeW++19V774pKLS+469P2tQ9/fOvTNe22919Z7bb3X1nttvdfWe22919Z7bb3X5r0277V5r6332nqvrffaeq/94ZIPl3zr0Pe3Dn1/69A377X1XlvvtfVeW++19V5b77X1XlvvtfVem/favNfmvbbea+u9tt5r6732h0s+XPKtQ9/fOvT9rUPfvNfWe22919Z7bb3X1nttvdfWe22919Z7bd5r816b99p6r6332nqvrffaHy75cMm3Dn1/69D3tw59815b77X1XlvvtfVeW++19V5b77X1XlvvtXmvzXtt3mvrvbbea+u9tt5rf7jkwyXfOvT9rUPf3zr0zXttvdfWe22919Z7bb3X1nttvdfWe2291+a9Nu+1ea+t99p6r6332nqv/XDJwyVvHfp+69D3W4e+ea+t99p6r6332nqvrffaeq+t99p6r6332rzX5r0277X1XlvvtfVeW++1Hy55uOStQ99vHfp+69A377X1XlvvtfVeW++19V5b77X1XlvvtfVem/favNfmvbbea+u9tt5r6732wyUPl7x16PutQ99vHfrmvbbea+u9tt5r67223mvrvbbea+u9tt5r816b99q819Z7bb3X1nttvdd+uOThkrcOfb916PutQ9+819Z7bb3X1nttvdfWe22919Z7bb3X1ntt3mvzXpv32nqvrffaeq+t99oPlzxc8tah77cOfb916Jv32nqvrffaeq+t99p6r6332nqvrffaeq/Ne23ea/NeW++19V5b77X1XrtxSeOSXoe+ex367nXom/faeq+t99p6r6332nqvrffaeq+t99p6r817bd5r815b77X1XlvvtfVeu3FJ45Jeh757Hfrudeib99p6r6332nqvrffaeq+t99p6r6332nqvzXtt3mvzXlvvtfVeW++19V67cUnjkl6Hvnsd+u516Jv32nqvrffaeq+t99p6r6332nqvrffaeq/Ne23ea/NeW++19V5b77X1XrtxSeOSXoe+ex367nXom/faeq+t99p6r6332nqvrffaeq+t99p6r817bd5r815b77X1XlvvtfVee3DJ4JJZh75nHfqedeib99p6r6332nqvrffaeq+t99p6r6332nqvzXtt3mvzXlvvtfVeW++19V57cMngklmHvmcd+p516Jv32nqvrffaeq+t99p6r6332nqvrffaeq/Ne23ea/NeW++19V5b77X1XntwyeCSWYe+Zx36nnXom/faeq+t99p6r6332nqvrffaeq+t99p6r817bd5r815b77X1XlvvtfVee3DJ4JJZh75nHfqedeib99p6r6332nqvrffaeq+t99p6r6332nqvzXtt3mvzXlvvtfVeW++19V57cMngklmHvmcd+p516Jv32nqvo/c6eq+j9zp6r6P3Onqvo/c6eq/Dex3e6/BeR+919F5H73X0XudnuWR+lkvmZx36+VmHfn7WoR/e6+i9jt7r6L2O3uvovY7e6+i9jt7r6L0O73V4r8N7Hb3X0XsdvdfRe52f5ZL5WS6Zn3Xo52cd+vlZh354r6P3Onqvo/c6eq+j9zp6r6P3Onqvo/c6vNfhvQ7vdfReR+919F5H73V+lkvmZ7lkftahn5916OdnHfrhvY7e6+i9jt7r6L2O3uvovY7e6+i9jt7r8F6H9zq819F7Hb3X0Xsdvdf5aX8B7S9gHfr5WYd+ftahH97r6L2O3uvovY7e6+i9jt7r6L2O3uvovQ7vdXivw3sdvdfRex2919F7nbNcMme5ZM469HPWoZ+zDv3wXkfvdfReR+919F5H73X0XkfvdfReR+91eK/Dex3e6+i9jt7r6L2O3uuc5ZI5yyVz1qGfsw79nHXoh/c6eq+j9zp6r6P3Onqvo/c6eq+j9zp6r8N7Hd7r8F5H73X0XkfvdfRe5yyXzFkumbMO/Zx16OesQz+819F7Hb3X0XsdvdfRex2919F7Hb3X0Xsd3uvwXof3Onqvo/c6eq+j9zrn8xfw/AWsQz9nHfo569AP73X0XkfvdfReR+919F5H73X0XkfvdfReh/c6vNfhvY7e6+i9jt7r6L3OGX8B4y9gHfo569DPWYd+eK+j9zp6r6P3Onqvo/c6eq+j9zp6r6P3OrzX4b0O73X0XkfvdfReR+91ApcELol16CfWoZ9Yh354r6P3Onqvo/c6eq+j9zp6r6P3Onqvo/c6vNfhvQ7vdfReR+919F5H73UClwQuiXXoJ9ahn1iHfnivo/c6eq+j9zp6r6P3Onqvo/c6eq+j9zq81+G9Du919F5H73X0XkfvdQKXBC6Jdegn1qGfWId+eK+j9zp6r6P3Onqvo/c6eq+j9zp6r6P3OrzX4b0O73X0XkfvdfReR+91ApcELol16CfWoZ9Yh354r6P3Onqvo/c6eq+j9zp6r6P3Onqvo/c6vNfhvQ7vdfReR+919F5H73USlyQuyXXoJ9ehn1yHfnivo/c6eq+j9zp6r6P3Onqvo/c6eq+j9zq81+G9Du919F5H73X0XkfvdRKXJC7Jdegn16GfXId+eK+j9zp6r6P3Onqvo/c6eq+j9zp6r6P3OrzX4b0O73X0XkfvdfReR+91EpckLsl16CfXoZ9ch354r6P3Onqvo/c6eq+j9zp6r6P3Onqvo/c6vNfhvQ7vdfReR+919F5H73USlyQuyXXoJ9ehn1yHfnivo/c6eq+j9zp6r6P3Onqvo/c6eq+j9zq81+G9Du919F5H73X0XkfvdRKXJC7Jdegn16GfXId+eK+j9zp6r6P3Onqvo/c6eq+j9zp6r6P3OrzX4b0O73X0XkfvdfReR+91CpcULql16KfWoZ9ah354r6P3Onqvo/c6eq+j9zp6r6P3Onqvo/c6vNfhvQ7vdfReR+919F5H73UKlxQuqXXop9ahn1qHfnivo/c6eq+j9zp6r6P3Onqvo/c6eq+j9zq81+G9Du919F5H73X0XkfvdQqXFC6pdein1qGfWod+eK+j9zp6r6P3Onqvo/c6eq+j9zp6r6P3OrzX4b0O73X0XkfvdfReR+91CpcULql16KfWoZ9ah354r6P3Onqvo/c6eq+j9zp6r6P3Onqvo/c6vNfhvQ7vdfReR+919F5H73UKl1xcctehn7sO/dx16If3Onqvo/c6eq+j9zp6r6P3Onqvo/c6eq/Dex3e6/BeR+919F5H73X0XufikotL7jr0c9ehn7sO/fBeR+919F5H73X0XkfvdfReR+919F5H73V4r8N7Hd7r6L2O3uvovY7e61xccnHJXYd+7jr0c9ehH97r6L2O3uvovY7e6+i9jt7r6L2O3uvovQ7vdXivw3sdvdfRex2919F7nYtLLi6569DPXYd+7jr0w3sdvdfRex2919F7Hb3X0XsdvdfRex291+G9Du91eK+j9zp6r6P3Onqvc3HJxSV3Hfq569DPXYd+eK+j9zp6r6P3Onqvo/c6eq+j9zp6r6P3OrzX4b0O73X0XkfvdfReR+91Plzy4ZJvHfr51qGfbx364b2O3uvovY7e6+i9jt7r6L2O3uvovY7e6/Beh/c6vNfRex2919F7Hb3X+XDJh0u+dejnW4d+vnXoh/c6eq+j9zp6r6P3Onqvo/c6eq+j9zp6r8N7Hd7r8F5H73X0XkfvdfRe58MlHy751qGfbx36+dahH97r6L2O3uvovY7e6+i9jt7r6L2O3uvovQ7vdXivw3sdvdfRex2919F7nQ+XfLjkW4d+vnXo51uHfnivo/c6eq+j9zp6r6P3Onqvo/c6eq+j9zq81+G9Du919F5H73X0XkfvdT5c8uGSbx36eevQz1uHfnivo/c6eq+j9zp6r6P3Onqvo/c6eq+j9zq81+G9Du919F5H73X0XkfvdR4uebjkrUM/bx36eevQD+919F5H73X0XkfvdfReR+919F5H73X0Xof3OrzX4b2O3uvovY7e6+i9zsMlD5e8dejnrUM/bx364b2O3uvovY7e6+i9jt7r6L2O3uvovY7e6/Beh/c6vNfRex2919F7Hb3Xebjk4ZK3Dv28dejnrUM/vNfRex2919F7Hb3X0XsdvdfRex2919F7Hd7r8F6H9zp6r6P3Onqvo/c6D5c8XPLWoZ+3Dv28deiH9zp6r6P3Onqvo/c6eq+j9zp6r6P3Onqvw3sd3uvwXkfvdfReR+919F6ncUnjkl6Hfnod+ul16If3Onqvo/c6eq+j9zp6r6P3Onqvo/c6eq/Dex3e6/BeR+919F5H73X0XqdxSeOSXod+eh366XXoh/c6eq+j9zp6r6P3Onqvo/c6eq+j9zp6r8N7Hd7r8F5H73X0XkfvdfRep3FJ45Jeh356HfrpdeiH9zp6r6P3Onqvo/c6eq+j9zp6r6P3Onqvw3sd3uvwXkfvdfReR+919F6ncUnjkl6Hfnod+ul16If3Onqvo/c6eq+j9zp6r6P3Onqvo/c6eq/Dex3e6/BeR+919F5H73X0XqdxSeOSXod+eh366XXoh/c6eq+j9zp6r6P3Onqvo/c6eq+j9zp6r8N7Hd7r8F5H73X0XkfvdfReZ3DJ4JJZh35mHfqZdeiH9zp6r6P3Onqvo/c6eq+j9zp6r6P3Onqvw3sd3uvwXkfvdfReR+919F5ncMngklmHfmYd+pl16If3Onqvo/c6eq+j9zp6r6P3Onqvo/c6eq/Dex3e6/BeR+919F5H73X0XmdwyeCSWYd+Zh36mXXoh/c6eq+j9zp6r6P3Onqvo/c6eq+j9zp6r8N7Hd7r8F5H73X0XkfvdfReZ3DJ4JJZh35mHfqZdeiH9zp6r6P3Onqvo/c6eq+j9zp6r6P3Onqvw3ud9V7//xXn35b8Pv/e9vsMz/Qsz+v5ef5drt/n3+X6ff5drv8/j1/7tyW/z/BMz/K8np/n82xPt4VfC78Wfi3cFm4Lt4Xb/nHJ77M9Zy/+59D/Ps9enH4t3ZZuS7el29Jt6bZ0W7mt3FZ+rfxa+bVyW7mt3FZu+8cl/3/+45Lf59mL/zn0v8/ci69fu267brtuu267bvvc9rntc9vnts+vfX7t82uf2z63fW57bnv+Ap6/gH8O/e+z9uJ/Dv3v0689tz23Pbe129pt7bZ2W7ut3dZ+rf1a+7V227ht3DZuG38B4y/gn0P/+/z24n8O/e/Tr9mSY0u29/r7DM/0LM/r+Xk+z/b0a7Zke6+/z/BMz/K8np/nLtc5u1zn7HIdW3JsybEl23v9fbot3BZuC7eF28Jt6dfSr9mS7b3+Pt2Wbku35fNsz12uU7tcp3a5ji05tuTYku29/j7dVm4rt5Xbrtuu265fu37Nlmzv9ffptuu267a7fwHn+/Hc5TrfLtf5drmOLTm25NiS7b3+Pt32ue257bntue257fm159dsyfZef59ue25rt7W/gPYX0Ltcp3e5Tu9yHVtybMmxJdt7/f9z3DZuG7eN28Zt47bxa+PXbMn2Xutne6+/z+MZnulZnrtc8bPLFT+7XGFLwpaELQlcErgkcEngksAlgUsClwQuCVwStmR7r79Pt+GSwCWBSwKXROxyRexyRexyhS0JWxK2JHBJ4JLAJYFLApcELglcErgkcEnYku29/j7dhksClwQuCVwStcsVd5cr7i5X2JKwJWFLApcELglcErgkcEngksAlgUsCl4Qt2d7r79NtuCRwSeCSwCXxdrni7XLF2+UKWxK2JGxJ4JLAJYFLApcELglcErgkcEngkrAl23v9fboNlwQuCVwSuCRmlytmlytmlytsSdiSsCWBSxKXJC5JXJK4JHFJ4pLEJYlL0pZs7/X/z/PjeTzDMz3Lc5crzy5Xnl2utCVpS9KWJC5JXJK4JHFJ4pLEJYlLEpckLklbsr3X36fbcEniksQliUsyd7kyd7kyd7nSlqQtSVuSuCRxSeKSxCWJSxKXJC5JXJK4JG3J9l5/n27DJYlLEpckLsm7y5XfLld+u1xpS9KWpC1JXJK4JHFJ4pLEJYlLEpckLklckrZke6+/T7fhksQliUsSl2TvcmXvcmXvcqUtSVuStiRxSeKSxCWJSxKXJC5JXJK4JHFJ2pLtvf4+3YZLCpcULilcUj+7XPWzy1U/u1xlS8qWlC0pXFK4pHBJ4ZLCJYVLCpcULilcUrZke6//f4bbcEnhksIlhUsqdrkqdrkqdrnKlpQtKVtSuKRwSeGSwiWFSwqXFC4pXFK4pGzJ9l5/n27DJYVLCpcULqna5ara5ara5SpbUrakbEnhksIlhUsKlxQuKVxSuKRwSeGSsiXbe/19ug2XFC4pXFK4pL5drnq7XPV2ucqWlC0pW1K4pHBJ4ZLCJYVLCpcULilcUrikbMn2Xn+fbsMlhUsKlxQuqdnlqtnlqtnlKltStqRsSeGSwiWFSy4uubjk4pKLSy4uubjk2pLtvf4+23Nvu7jk4pKLS+7Z5bpnl+ueXa5rS64tubbk4pKLSy4uubjk4pKLSy4uubjk4pJrS7b3+v9nug2XXFxyccnFJTd3uW7uct3c5bq25NqSa0suLrm45OKSi0suLrm45OKSi0suLrm2ZHuvv0+34ZKLSy4uubjk3l2ue3e57t3lurbk2pJrSy4uubjk4pKLSy4uubjk4pKLSy4uubZke6+/T7fhkotLLi65uOS+Xa7bu1y3d7muLbm25NqSi0suLrm45OKSi0suLrm45OKSi0uuLdne6+/Tbbjk4pKLSz5c8v3scn0/u1zfzy7XZ0s+W/LZkg+XfLjkwyUfLvlwyYdLPlzy4ZIPl3y2ZHuvv8/2dBsu+XDJh0u+2OX6Ypfri12uz5Z8tuSzJR8u+XDJh0s+XPLhkg+XfLjkwyUfLvlsyfZe//8st+GSD5d8uOTDJV/tcn21y/XVLtdnSz5b8tmSD5d8uOTDJR8u+XDJh0s+XPLhkg+XfLZke6+/T7fhkg+XfLjkwyXft8v1fbtc37fL9dmSz5Z8tuTDJR8u+XDJh0s+XPLhkg+XfLjkwyWfLdne6+/TbbjkwyUfLvlwyde7XN/scn2zy/XZks+WfLbkwyUfLvlwyYdLPlzycMnDJQ+XPFzybMnzTfj5JvxwycMlD5c8XPLOLtc7u1zv7HI9W/JsybMlD5c8XPJwycMlD5c8XPJwycMlD5c8W/J8E36+CT9c8nDJwyUPl7zc5Xq5y/Vyl+vZkmdLni15uOThkodLHi55uOThkodLHi55uOTZkueb8PNN+OGSh0seLnm45N1drnd3ud7d5Xq25NmSZ0seLnm45OGSh0seLnm45OGSh0seLnm25Pkm/HwTfrjk4ZKHSx4ueW+X671drvd2uZ4tebbk2ZKHSx4uebjk4ZKHSx4uebjk4ZKHS54teb4JP9+EHy55uOThkodL3uxy9c8uV//scrUtaVvStqRxSeOSxiWNSxqXNC5pXNK4pHFJ25L2Tbh9E25c0rikcUnjko5dro5dro5drrYlbUvaljQuaVzSuKRxSeOSxiWNSxqXNC5pW9K+Cbdvwo1LGpc0Lmlc0rXL1bXL1bXL1bakbUnbksYljUsalzQuaVzSuKRxSeOSxiVtS9o34fZNuHFJ45LGJY1L+tvl6m+Xq79drrYlbUvaljQuaVzSuKRxSeOSxiWNSxqXNC5pW9K+Cbdvwo1LGpc0Lmlc0r3L1b3L1b3L1bakbUnbksYljUsalzQuaVzSuKRxyeCSwSVjS8Y34fFNeHDJ4JLBJYNL5meXa84u15xdrrElY0vGlgwuGVwyuGRwyeCSwSWDSwaXDC4ZWzK+CY9vwoNLBpcMLhlcMrnLNbnLNbnLNbZkbMnYksElg0sGlwwuGVwyuGRwyeCSwSVjS8Y34fFNeHDJ4JLBJYNL5u5yzd3lmrvLNbZkbMnYksElg0sGlwwuGVwyuGRwyeCSwSVjS8Y34fFNeHDJ4JLBJYNL5u1yzdvlmrfLNbZkbMnYksElg0sGlwwuGVwyuGRwyeCSwSVjS8Y34fFNeHDJ4JLBJYNLZna5Zna55p9D///vKrslZ3uvv8/wTM/yvJ6f5/Nsz9nn8WvHrx2/tt+Ez/Zef5/X8/N8nu35b7nOzz+H/vd59uLwa+G2cFu4LdwWbgu3hdvSbem29Gvp19KvpdvSbem2dNtyyflZLjk//xz632fsxf8c+t+nXyu3ldvKbeW2ctt123Xbddt12/Vr169dv3bddt123fa5bbnk/CyXnJ9/Dv3vs/bifw7979OvfW773Pa57bntue257bntue257fm159eeX3tua7e129pt7S+g/QX8c+h/n99e/M+h/336tXbbuG3cNm4bt43bxm3jtnHb+LXlksN7Pdt7/X2GZ3qW5/X8PP8t1znr0J+zDv3hvZ5jS44t2d7r77M8r+fn+Tzb023h18Kv2ZLtvf4+3RZuC7ctl5yzXHLOOvTnrEN/zjr0h/d6ji05tmR7r79Pt6Xb0m3ptnJbua38Wvk1W7K919+n28pt5bblknOWS85Zh/6cdejPWYf+8F7PsSXHlmzv9ffptuu2z22f2z63fW77/Nrn12zJ9l5/n2773Pbc9vwFPH8B69Cfsw79OevQH97rObbk2JLtvf7/2W5rt7Xb2m3ttnZb+7X2a7Zke6//f47bxm3jtvEXMP4C1qE/Zx36c9ahP7zXc2xJ2JLAJYFLApcELglcErgkcAnv9fBeD+/1bO/19xme6Vme1/Pz3OWKdehPrEN/eK8nbEnYksAlgUsClwQuCVwSuCRwCe/18F4P7/Vs7/X36TZcErgkcEngkliH/sQ69CfWoT+81xO2JGxJ4JLAJYFLApcELglcEriE93p4r4f3erb3+vt0Gy4JXBK4JHBJrEN/Yh36E+vQH97rCVsStiRwSeCSwCWBSwKXBC4JXMJ7PbzXw3s923v9fboNlwQuCVwSuCTWoT+xDv2JdegP7/WELQlbErgkcEngksAlgUsClwQu4b0e3uvhvZ7tvdbZ3uvv83iGZ3qW5y5XrkN/ch36w3s9aUvSliQuSVySuCRxSeKSxCWJS3ivh/d6eK9ne6+/T7fhksQliUsSl+Q69CfXoT+5Dv3hvZ60JWlLEpckLklckrgkcUniksQlvNfDez2817O919+n23BJ4pLEJYlLch36k+vQn1yH/vBeT9qStCWJSxKXJC5JXJK4JHFJ4hLe6+G9Ht7r2d7r79NtuCRxSeKSxCW5Dv3JdehPrkN/eK8nbUnaksQliUsSlyQuSVySuCRxCe/18F4P7/Vs7/X36TZckrgkcUniklyH/uQ69CfXoT+815O2JG1J4pLCJYVLCpcULilcUriE93p4r4f3erb3+v/nfhM+hUsKlxQuKVxS69CfWof+1Dr0h/d6ypaULSlcUrikcEnhksIlhUsKl/BeD+/18F7P9l5/n27DJYVLCpcULql16E+tQ39qHfrDez1lS8qWFC4pXFK4pHBJ4ZLCJYVLeK+H93p4r2d7r79Pt+GSwiWFSwqX1Dr0p9ahP7UO/eG9nrIlZUsKlxQuKVxSuKRwSeGSwiW818N7PbzXs73X36fbcEnhksIlhUtqHfpT69CfWof+8F5P2ZKyJYVLCpcULilcUrikcEnhEt7r4b0e3uvZ3uvv02245OKSi0suLrnr0J+7Dv2569Af3uu5tuTakotLLi65uOTikotLLi65uIT3enivh/d6tvf6/2e4DZdcXHJxycUldx36c9ehP3cd+sN7PdeWXFtyccnFJReXXFxyccnFJReX8F4P7/XwXs/2Xn+fbsMlF5dcXHJxyV2H/tx16M9dh/7wXs+1JdeWXFxyccnFJReXXFxyccnFJbzXw3s9vNezvdffp9twycUlF5dcXHLXoT93Hfpz16E/vNdzbcm1JReXXFxyccnFJReXXFxycQnv9fBeD+/1bO/19+k2XHJxycUlF5fcdejPXYf+3HXoD+/1XFtybcnFJReXXFzy4ZIPl3y45MMlvNfDez2817O9199ne+5tHy75cMmHS7516M+3Dv351qE/vNfz2ZLPlny45MMlHy75cMmHSz5c8uES3uvhvR7e69ne6/+f6TZc8uGSD5d8uORbh/5869Cfbx36w3s9ny35bMmHSz5c8uGSD5d8uOTDJR8u4b0e3uvhvZ7tvf4+3YZLPlzy4ZIPl3zr0J9vHfrzrUN/eK/nsyWfLflwyYdLPlzy4ZIPl3y45MMlvNfDez2817O919+n23DJh0s+XPLhkm8d+vOtQ3++degP7/V8tuSzJR8u+XDJh0s+XPLhkg+XfLiE93p4r4f3erb3+vt0Gy75cMmHSx4ueevQn7cO/Xnr0B/e63m25NmSh0seLnm45OGSh0seLnm4hPd6eK+H93qeb8LPN+GHSx4uebjk4ZK3Dv1569Cftw794b2eZ0ueLXm45OGSh0seLnm45OGSh0t4r4f3eniv5/km/HwTfrjk4ZKHSx4ueevQn7cO/Xnr0B/e63m25NmSh0seLnm45OGSh0seLnm4hPd6eK+H93qeb8LPN+GHSx4uebjk4ZK3Dv1569Cftw794b2eZ0ueLXm45OGSh0seLnm45OGSh0t4r4f3eniv5/km/HwTfrjk4ZKHSx4ueevQn7cO/Xnr0B/e63m25NmSh0seLnm45OGSh0salzQu4b0e3uvhvZ72Tbh9E25c0rikcUnjkl6H/vQ69KfXoT+819O2pG1J45LGJY1LGpc0Lmlc0riE93p4r4f3eto34fZNuHFJ45LGJY1Leh360+vQn16H/vBeT9uStiWNSxqXNC5pXNK4pHFJ4xLe6+G9Ht7rad+E2zfhxiWNSxqXNC7pdehPr0N/eh36w3s9bUvaljQuaVzSuKRxSeOSxiWNS3ivh/d6eK+nfRNu34QblzQuaVzSuKTXoT+9Dv3pdegP7/W0LWlb0rikcUnjksYljUsalzQu4b0e3uvhvZ72Tbh9E25c0rikcUnjkl6H/sw69GfWoT+81zO2ZGzJ4JLBJYNLBpcMLhlcMriE93p4r4f3esY34fFNeHDJ4JLBJYNLZh36M+vQn1mH/vBez9iSsSWDSwaXDC4ZXDK4ZHDJ4BLe6+G9Ht7rGd+ExzfhwSWDSwaXDC6ZdejPrEN/Zh36w3s9Y0vGlgwuGVwyuGRwyeCSwSWDS3ivh/d6eK9nfBMe34QHlwwuGVwyuGTWoT+zDv2ZdegP7/WMLRlbMrhkcMngksElg0sGlwwu4b0e3uvhvZ7xTXh8Ex5cMrhkcMngklmH/sw69GfWoT+81zO2ZGzJ4JLBJYNLBpcMLhlcovcavNfgvQbvNfReQ+819F5D7zV+lkviZ7kkftahj5916ONnHfrgvYbea+i9ht5r6L2G3mvovYbea+i9ht5r8F6D9xq819B7Db3X0HsNvdf4WS6Jn+WS+FmHPn7WoY+fdeiD9xp6r6H3Gnqvofcaeq+h9xp6r6H3GnqvwXsN3mvwXkPvNfReQ+819F7jZ7kkfpZL4mcd+vhZhz5+1qEP3mvovYbea+i9ht5r6L2G3mvovYbea+i9Bu81eK/Bew2919B7Db3X0HuNn+cv4PkLWIc+ftahj5916IP3Gnqvofcaeq+h9xp6r6H3Gnqvofcaeq/Bew3ea/BeQ+819F5D7zX0XuNn/AWMv4B16ONnHfr4WYc+eK+h9xp6r6H3Gnqvofcaeq+h9xp6r6H3GrzX4L0G7zX0XkPvNfReQ+81znJJnOWSOOvQx1mHPs469MF7Db3X0HsNvdfQew2919B7Db3X0HsNvdfgvQbvNXivofcaeq+h9xp6r3GWS+Isl8RZhz7OOvRx1qEP3mvovYbea+i9ht5r6L2G3mvovYbea+i9Bu81eK/Bew2919B7Db3X0HuNs1wSZ7kkzjr0cdahj7MOffBeQ+819F5D7zX0XkPvNfReQ+819F5D7zV4r8F7Dd5r6L2G3mvovYbea5z2F9D+Atahj7MOfZx16IP3Gnqvofcaeq+h9xp6r6H3Gnqvofcaeq/Bew3ea/BeQ+819F5D7zX0XiNwSeCSWIc+Yh36iHXog/caeq+h9xp6r6H3Gnqvofcaeq+h9xp6r8F7Dd5r8F5D7zX0XkPvNfReI3BJ4JJYhz5iHfqIdeiD9xp6r6H3Gnqvofcaeq+h9xp6r6H3GnqvwXsN3mvwXkPvNfReQ+819F4jcEngkliHPmId+oh16IP3Gnqvofcaeq+h9xp6r6H3Gnqvofcaeq/Bew3ea/BeQ+819F5D7zX0XiNwSeCSWIc+Yh36iHXog/caeq+h9xp6r6H3Gnqvofcaeq+h9xp6r8F7Dd5r8F5D7zX0XkPvNfReI3BJ4JJYhz5iHfqIdeiD9xp6r6H3Gnqvofcaeq+h9xp6r6H3GnqvwXsN3mvwXkPvNfReQ+819F4jcUniklyHPnId+sh16IP3Gnqvofcaeq+h9xp6r6H3Gnqvofcaeq/Bew3ea/BeQ+819F5D7zX0XiNxSeKSXIc+ch36yHXog/caeq+h9xp6r6H3Gnqvofcaeq+h9xp6r8F7Dd5r8F5D7zX0XkPvNfReI3FJ4pJchz5yHfrIdeiD9xp6r6H3Gnqvofcaeq+h9xp6r6H3GnqvwXsN3mvwXkPvNfReQ+819F4jcUniklyHPnId+sh16IP3Gnqvofcaeq+h9xp6r6H3Gnqvofcaeq/Bew3ea/BeQ+819F5D7zX0XqNwSeGSWoc+ah36qHXog/caeq+h9xp6r6H3Gnqvofcaeq+h9xp6r8F7Dd5r8F5D7zX0XkPvNfReo3BJ4ZJahz5qHfqodeiD9xp6r6H3Gnqvofcaeq+h9xp6r6H3GnqvwXsN3mvwXkPvNfReQ+819F6jcEnhklqHPmod+qh16IP3Gnqvofcaeq+h9xp6r6H3Gnqvofcaeq/Bew3ea/BeQ+819F5D7zX0XqNwSeGSWoc+ah36qHXog/caeq+h9xp6r6H3Gnqvofcaeq+h9xp6r8F7Dd5r8F5D7zX0XkPvNfReo3BJ4ZJahz5qHfqodeiD9xp6r6H3Gnqvofcaeq+h9xp6r6H3GnqvwXsN3mvwXkPvNfReQ+819F7j4pKLS+469HHXoY+7Dn3wXkPvNfReQ+819F5D7zX0XkPvNfReQ+81eK/Bew3ea+i9ht5r6L2G3mtcXHJxyV2HPu469HHXoQ/ea+i9ht5r6L2G3mvovYbea+i9ht5r6L0G7zV4r8F7Db3X0HsNvdfQe42LSy4uuevQx12HPu469MF7Db3X0HsNvdfQew2919B7Db3X0HsNvdfgvQbvNXivofcaeq+h9xp6r3FxycUldx36uOvQx12HPnivofcaeq+h9xp6r6H3Gnqvofcaeq+h9xq81+C9Bu819F5D7zX0XkPvNT5c8uGSbx36+Nahj28d+uC9ht5r6L2G3mvovYbea+i9ht5r6L2G3mvwXoP3GrzX0HsNvdfQew291/hwyYdLvnXo41uHPr516IP3Gnqvofcaeq+h9xp6r6H3Gnqvofcaeq/Bew3ea/BeQ+819F5D7zX0XuPDJR8u+dahj28d+vjWoQ/ea+i9ht5r6L2G3mvovYbea+i9ht5r6L0G7zV4r8F7Db3X0HsNvdfQe40Pl3y45FuHPr516ONbhz54r6H3Gnqvofcaeq+h9xp6r6H3GnqvofcavNfgvQbvNfReQ+819F5D7zU+XPLhkm8d+vjWoY9vHfrgvYbea+i9ht5r6L2G3mvovYbea+i9ht5r8F6D9xq819B7Db3X0HsNvdd4uOThkrcOfbx16OOtQx+819B7Db3X0HsNvdfQew2919B7Db3X0HsN3mvwXoP3Gnqvofcaeq+h9xoPlzxc8tahj7cOfbx16IP3Gnqvofcaeq+h9xp6r6H3Gnqvofcaeq/Bew3ea/BeQ+819F5D7zX0XuPhkodL3jr08dahj7cOffBeQ+819F5D7zX0XkPvNfReQ+819F5D7zV4r8F7Dd5r6L2G3mvovYbeazxc8nDJW4c+3jr08dahD95r6L2G3mvovYbea+i9ht5r6L2G3mvovQbvNXivwXsNvdfQew2919B7jYdLGpf0OvTR69BHr0MfvNfQew2919B7Db3X0HsNvdfQew2919B7Dd5r8F6D9xp6r6H3GnqvofcajUsal/Q69NHr0EevQx+819B7Db3X0HsNvdfQew2919B7Db3X0HsN3mvwXoP3Gnqvofcaeq+h9xqNSxqX9Dr00evQR69DH7zX0HsNvdfQew2919B7Db3X0HsNvdfQew3ea/Beg/caeq+h9xp6r6H3Go1LGpf0OvTR69BHr0MfvNfQew2919B7Db3X0HsNvdfQew2919B7Dd5r8F6D9xp6r6H3GnqvofcajUsal/Q69NHr0EevQx+819B7Db3X0HsNvdfQew2919B7Db3X0HsN3mvwXoP3Gnqvofcaeq+h9xqDSwaXzDr0MevQx6xDH7zX0HsNvdfQew2919B7Db3X0HsNvdfQew3ea/Beg/caeq+h9xp6r6H3GoNLBpfMOvQx69DHrEMfvNfQew2919B7Db3X0HsNvdfQew2919B7Dd5r8F6D9xp6r6H3Gnqvofcag0sGl8w69DHr0MesQx+819B7Db3X0HsNvdfQew2919B7Db3X0HsN3mvwXoP3Gnqvofcaeq+h9xqDSwaXzDr0MevQx6xDH7zX0HsNvdfQew2919B7Db3X0HsNvdfQew3ea/Beg/caeq+h9xp6r6H3GoNLBpfMOvT5sw59/qxDn7zX1HtNvdfUe02919R7Tb3X1HtNvdfUe03ea/Jek/eaeq+p95p6r6n3mj/LJfmzXJI/69Dnzzr0+bMOffJeU+819V5T7zX1XlPvNfVeU+819V5T7zV5r8l7Td5r6r2m3mvqvabea/4sl+TPckn+rEOfP+vQ58869Ml7Tb3X1HtNvdfUe02919R7Tb3X1HtNvdfkvSbvNXmvqfeaeq+p95p6r/mzXJI/yyX5sw59/qxDnz/r0CfvNfVeU+819V5T7zX1XlPvNfVeU+819V6T95q81+S9pt5r6r2m3mvqveZP+wtofwHr0OfPOvT5sw598l5T7zX1XlPvNfVeU+819V5T7zX1XlPvNXmvyXtN3mvqvabea+q9pt5rnuWSPMsledahz7MOfZ516JP3mnqvqfeaeq+p95p6r6n3mnqvqfeaeq/Je03ea/JeU+819V5T7zX1XvMsl+RZLsmzDn2edejzrEOfvNfUe02919R7Tb3X1HtNvdfUe02919R7Td5r8l6T95p6r6n3mnqvqfeaZ7kkz3JJnnXo86xDn2cd+uS9pt5r6r2m3mvqvabea+q9pt5r6r2m3mvyXpP3mrzX1HtNvdfUe0291zzPX8DzF7AOfZ516POsQ5+819R7Tb3X1HtNvdfUe02919R7Tb3X1HtN3mvyXpP3mnqvqfeaeq+p95pn/AWMv4B16POsQ59nHfrkvabea+q9pt5r6r2m3mvqvabea+q9pt5r8l6T95q819R7Tb3X1HtNvdcMXBK4JNahz1iHPmMd+uS9pt5r6r2m3mvqvabea+q9pt5r6r2m3mvyXpP3mrzX1HtNvdfUe0291wxcErgk1qHPWIc+Yx365L2m3mvqvabea+q9pt5r6r2m3mvqvabea/Jek/eavNfUe02919R7Tb3XDFwSuCTWoc9Yhz5jHfrkvabea+q9pt5r6r2m3mvqvabea+q9pt5r8l6T95q819R7Tb3X1HtNvdcMXBK4JNahz1iHPmMd+uS9pt5r6r2m3mvqvabea+q9pt5r6r2m3mvyXpP3mrzX1HtNvdfUe02910xckrgk16HPXIc+cx365L2m3mvqvabea+q9pt5r6r2m3mvqvabea/Jek/eavNfUe02919R7Tb3XTFySuCTXoc9chz5zHfrkvabea+q9pt5r6r2m3mvqvabea+q9pt5r8l6T95q819R7Tb3X1HtNvddMXJK4JNehz1yHPnMd+uS9pt5r6r2m3mvqvabea+q9pt5r6r2m3mvyXpP3mrzX1HtNvdfUe02910xckrgk16HPXIc+cx365L2m3mvqvabea+q9pt5r6r2m3mvqvabea/Jek/eavNfUe02919R7Tb3XTFySuCTXoc9chz5zHfrkvabea+q9pt5r6r2m3mvqvabea+q9pt5r8l6T95q819R7Tb3X1HtNvdcsXFK4pNahz1qHPmsd+uS9pt5r6r2m3mvqvabea+q9pt5r6r2m3mvyXpP3mrzX1HtNvdfUe0291yxcUrik1qHPWoc+ax365L2m3mvqvabea+q9pt5r6r2m3mvqvabea/Jek/eavNfUe02919R7Tb3XLFxSuKTWoc9ahz5rHfrkvabea+q9pt5r6r2m3mvqvabea+q9pt5r8l6T95q819R7Tb3X1HtNvdcsXFK4pNahz1qHPmsd+uS9pt5r6r2m3mvqvabea+q9pt5r6r2m3mvyXpP3mrzX1HtNvdfUe02917y45OKSuw593nXo865Dn7zX1HtNvdfUe02919R7Tb3X1HtNvdfUe03ea/Jek/eaeq+p95p6r6n3mheXXFxy16HPuw593nXok/eaeq+p95p6r6n3mnqvqfeaeq+p95p6r8l7Td5r8l5T7zX1XlPvNfVe8+KSi0vuOvR516HPuw598l5T7zX1XlPvNfVeU+819V5T7zX1XlPvNXmvyXtN3mvqvabea+q9pt5rXlxyccldhz7vOvR516FP3mvqvabea+q9pt5r6r2m3mvqvabea+q9Ju81ea/Je02919R7Tb3X1HvNi0suLrnr0Oddhz7vOvTJe02919R7Tb3X1HtNvdfUe02919R7Tb3X5L0m7zV5r6n3mnqvqfeaeq/54ZIPl3zr0Oe3Dn1+69An7zX1XlPvNfVeU+819V5T7zX1XlPvNfVek/eavNfkvabea+q9pt5r6r3mh0s+XPKtQ5/fOvT5rUOfvNfUe02919R7Tb3X1HtNvdfUe02919R7Td5r8l6T95p6r6n3mnqvqfeaHy75cMm3Dn1+69Dntw598l5T7zX1XlPvNfVeU+819V5T7zX1XlPvNXmvyXtN3mvqvabea+q9pt5rfrjkwyXfOvT5rUOf3zr0yXtNvdfUe02919R7Tb3X1HtNvdfUe0291+S9Ju81ea+p95p6r6n3mnqv+XDJwyVvHfp869DnW4c+ea+p95p6r6n3mnqvqfeaeq+p95p6r6n3mrzX5L0m7zX1XlPvNfVeU+81Hy55uOStQ59vHfp869An7zX1XlPvNfVeU+819V5T7zX1XlPvNfVek/eavNfkvabea+q9pt5r6r3mwyUPl7x16POtQ59vHfrkvabea+q9pt5r6r2m3mvqvabea+q9pt5r8l6T95q819R7Tb3X1HtNvdd8uOThkrcOfb516POtQ5+819R7Tb3X1HtNvdfUe02919R7Tb3X1HtN3mvyXpP3mnqvqfeaeq+p95oPlzxc8tahz7cOfb516JP3mnqvqfeaeq+p95p6r6n3mnqvqfeaeq/Je03ea/JeU+819V5T7zX1XrNxSeOSXoc+ex367HXok/eaeq+p95p6r6n3mnqvqfeaeq+p95p6r8l7Td5r8l5T7zX1XlPvNfVes3FJ45Jehz57HfrsdeiT95p6r6n3mnqvqfeaeq+p95p6r6n3mnqvyXtN3mvyXlPvNfVeU+819V6zcUnjkl6HPnsd+ux16JP3mnqvqfeaeq+p95p6r6n3mnqvqfeaeq/Je03ea/JeU+819V5T7zX1XrNxSeOSXoc+ex367HXok/eaeq+p95p6r6n3mnqvqfeaeq+p95p6r8l7Td5r8l5T7zX1XlPvNfVes3HJ4JJZhz5nHfqcdeiT95p6r6n3mnqvqfeaeq+p95p6r6n3mnqvyXtN3mvyXlPvNfVeU+819V5zcMngklmHPmcd+px16JP3mnqvqfeaeq+p95p6r6n3mnqvqfeaeq/Je03ea/JeU+819V5T7zX1XnNwyeCSWYc+Zx36nHXok/eaeq+p95p6r6n3mnqvqfeaeq+p95p6r8l7Td5r8l5T7zX1XlPvNfVec3DJ4JJZhz5nHfqcdeiT95p6r6n3mnqvqfeaeq+p95p6r6n3mnqvyXtN3mvyXlPvNfVeU+819V5zcMngklmHPmcd+px16JP3mnqvqfeaeq+p95p6r6n3mnqvpfdaeq/Fey3ea/FeS++19F5L77X0XutnuaR+lkvqZx36+lmHvn7WoS/ea+m9lt5r6b2W3mvpvZbea+m9lt5r6b0W77V4r8V7Lb3X0nstvdfSe62f5ZL6WS6pn3Xo62cd+vpZh754r6X3Wnqvpfdaeq+l91p6r6X3WnqvpfdavNfivRbvtfReS++19F5L77V+lkvqZ7mkftahr5916OtnHfrivZbea+m9lt5r6b2W3mvpvZbea+m9lt5r8V6L91q819J7Lb3X0nstvdf6ef4Cnr+AdejrZx36+lmHvnivpfdaeq+l91p6r6X3Wnqvpfdaeq+l91q81+K9Fu+19F5L77X0XkvvtX7GX8D4C1iHvs469HXWoS/ea+m9lt5r6b2W3mvpvZbea+m9lt5r6b0W77V4r8V7Lb3X0nstvdfSe62zXFJnuaTOOvR11qGvsw598V5L77X0XkvvtfReS++19F5L77X0XkvvtXivxXst3mvpvZbea+m9lt5rneWSOsslddahr7MOfZ116Iv3Wnqvpfdaeq+l91p6r6X3Wnqvpfdaeq/Fey3ea/FeS++19F5L77X0Xussl9RZLqmzDn2ddejrrENfvNfSey2919J7Lb3X0nstvdfSey2919J7Ld5r8V6L91p6r6X3Wnqvpfdap/0FtL+AdejrrENfZx364r2W3mvpvZbea+m9lt5r6b2W3mvpvZbea/Fei/davNfSey2919J7Lb3XClwSuCTWoa9Yh75iHfrivZbea+m9lt5r6b2W3mvpvZbea+m9lt5r8V6L91q819J7Lb3X0nstvdcKXBK4JNahr1iHvmId+uK9lt5r6b2W3mvpvZbea+m9lt5r6b2W3mvxXov3WrzX0nstvdfSey291wpcErgk1qGvWIe+Yh364r2W3mvpvZbea+m9lt5r6b2W3mvpvZbea/Fei/davNfSey2919J7Lb3XClwSuCTWoa9Yh75iHfrivZbea+m9lt5r6b2W3mvpvZbea+m9lt5r8V6L91q819J7Lb3X0nstvdcKXBK4JNahr1iHvmId+uK9lt5r6b2W3mvpvZbea+m9lt5r6b2W3mvxXov3WrzX0nstvdfSey2910pckrgk16GvXIe+ch364r2W3mvpvZbea+m9lt5r6b2W3mvpvZbea/Fei/davNfSe63/NXE3K7StW3WG78WyhfnTW+tj5laCiBoTBFE50UAI597jOdH+pLIZi7Xh25XZ6LBfHt7r8F6H9zpfd8nXXfK9hn6+19DP9xr60b0O73V4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvc7XXfJ1l3yvoZ/vNfTzvYZ+dK/Dex3e6/Beh/c6vNfhvQ7vdXivw3sd3evoXkf3OrzX4b0O73V4r/N1l3zdJd9r6Od7Df18r6Ef3evwXof3OrzX4b0O73V4r8N7Hd7r8F5H9zq619G9Du91eK/Dex3e64y7ZNwlcw39zDX0M9fQj+51eK/Dex3e6/Beh/c6vNfhvQ7vdXivo3sd3evoXof3OrzX4b0O73XGXTLukrmGfuYa+plr6Ef3OrzX4b0O73V4r8N7Hd7r8F6H9zq819G9ju51dK/Dex3e6/Beh/c64y4Zd8lcQz9zDf3MNfSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nXGXjLtkrqGfuYZ+5hr60b0O73V4r8N7Hd7r8F6H9zq81+G9Du91dK+jex3d6/Beh/c6vNfhvc64S8ZdMtfQz1xDP3MN/eheh/c6vNfhvQ7vdXivw3sd3uvwXof3OrrX0b2O7nV4r8N7Hd7r8F4n7pK4S3IN/eQa+sk19KN7Hd7r8F6H9zq81+G9Du91eK/Dex3e6+heR/c6utfhvQ7vdXivw3uduEviLsk19JNr6CfX0I/udXivw3sd3uvwXof3OrzX4b0O73V4r6N7Hd3r6F6H9zq81+G9Du914i6JuyTX0E+uoZ9cQz+61+G9Du91eK/Dex3e6/Beh/c6vNfhvY7udXSvo3sd3uvwXof3OrzXibsk7pJcQz+5hn5yDf3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/Bep+6Sukt6Df30GvrpNfSjex3e6/Beh/c6vNfhvQ7vdXivw3sd3uvoXkf3OrrX4b0O73V4r8N7nbpL6i7pNfTTa+in19CP7nV4r8N7Hd7r8F6H9zq81+G9Du91eK+jex3d6+heh/c6vNfhvQ7vdeouqbuk19BPr6GfXkM/utfhvQ7vdXivw3sd3uvwXof3OrzX4b2O7nV0r6N7Hd7r8F6H9zq816m7pO6SXkM/vYZ+eg396F6H9zq81+G9Du91eK/Dex3e6/Beh/c6utfRvY7udXivw3sd3uvwXqfukrpLeg399Br66TX0o3sd3uvwXof3OrzX4b0O73V4r8N7Hd7r6F5H9zq61+G9Du91eK/De511l6y7ZK+hn72GfvYa+tG9Du91eK/Dex3e6/Beh/c6vNfhvQ7vdXSvo3sd3evwXof3OrzX4b3OukvWXbLX0M9eQz97Df3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/BeZ90l6y7Za+hnr6GfvYZ+dK/Dex3e6/Beh/c6vNfhvQ7vdXivw3sd3evoXkf3OrzX4b0O73V4r7PuknWX7DX0s9fQz15DP7rX4b0O73V4r8N7Hd7r8F6H9zq81+G9ju51dK+jex3e6/Beh/c6vNd53CWPu+S5hn6ea+jnuYZ+dK/Dex3e6/Beh/c6vNfhvQ7vdXivw3sd3evoXkf3OrzX4b0O73V4r/O4Sx53yXMN/TzX0M9zDf3oXof3OrzX4b0O73V4r8N7Hd7r8F6H9zq619G9ju51eK/Dex3e6/Be53GXPO6S5xr6ea6hn+ca+tG9Du91eK/Dex3e6/Beh/c6vNfhvQ7vdXSvo3sd3evwXof3OrzX4b3O4y553CXPNfTzXEM/zzX0o3sd3uvwXof3OrzX4b0O73V4r8N7Hd7r6F5H9zq61+G9Du91eK/De53HXfK4S55r6Oe5hn6ea+hH9zq81+G9Du91eK/Dex3e6/Beh/c6vNfRvY7udXSvw3sd3uvwXof3Oj93yc9d8ruGfn7X0M/vGvrRvQ7vdXivw3sd3uvwXof3OrzX4b0O73V0r6N7Hd3r8F6H9zq81+G9zs9d8nOX/K6hn9819PO7hn50r8N7Hd7r8F6H9zq81+G9Du91eK/Dex3d6+heR/c6vNfhvQ7vdXiv83OX/Nwlv2vo53cN/fyuoR/d6/Beh/c6vNfhvQ7vdXivw3sd3uvwXkf3OrrX0b0O73V4r8N7Hd7r/NwlP3fJ7xr6+V1DP79r6Ef3OrzX4b0O73V4r8N7Hd7r8F6H9zq819G9ju51dK/Dex3e6/Beh/c6v7tL8rq7JK9r6PO6hj6va+ijew3vNbzX8F7Dew3vNbzX8F7Dew3vNbrX6F6jew3vNbzX8F7De83r7pK87i7J6xr6vK6hz+sa+uhew3sN7zW81/Bew3sN7zW81/Bew3uN7jW61+hew3sN7zW81/Be87q7JK+7S/K6hj6va+jzuoY+utfwXsN7De81vNfwXsN7De81vNfwXqN7je41utfwXsN7De81vNe87i7J6+6SvK6hz+sa+ryuoY/uNbzX8F7Dew3vNbzX8F7Dew3vNbzX6F6je43uNbzX8F7Dew3vNa/HL+DxC7iGPq9r6PO6hj661/Bew3sN7zW81/Bew3sN7zW81/Beo3uN7jW61/Bew3sN7zW817zvLsn77pK8r6HP+xr6vK+hj+41vNfwXsN7De81vNfwXsN7De81vNfoXqN7je41vNfwXsN7De8177tL8r67JO9r6PO+hj7va+ijew3vNbzX8F7Dew3vNbzX8F7Dew3vNbrX6F6jew3vNbzX8F7De8377pK87y7J+xr6vK+hz/sa+uhew3sN7zW81/Bew3sN7zW81/Bew3uN7jW61+hew3sN7zW81/Be816/gPULuIY+72vo876GPrrX8F7Dew3vNbzX8F7Dew3vNbzX8F6je43uNbrX8F7Dew3vNbzXvH9+AT+/gGvo87mGPp9r6KN7De81vNfwXsN7De81vNfwXsN7De81utfoXqN7De81vNfwXsN7zcdd8nGXfK6hz+ca+nyuoY/uNbzX8F7Dew3vNbzX8F7Dew3vNbzX6F6je43uNbzX8F7Dew3vNR93ycdd8rmGPp9r6PO5hj661/Bew3sN7zW81/Bew3sN7zW81/Beo3uN7jW61/Bew3sN7zW813zcJR93yeca+nyuoc/nGvroXsN7De81vNfwXsN7De81vNfwXsN7je41utfoXsN7De81vNfwXvNxl3zcJZ9r6PO5hj6fa+ijew3vNbzX8F7Dew3vNbzX8F7Dew3vNbrX6F6jew3vNbzX8F7De83XXfJ1l3yvoc/3Gvp8r6GP7jW81/Bew3sN7zW81/Bew3sN7zW81+heo3uN7jW81/Bew3sN7zVfd8nXXfK9hj7fa+jzvYY+utfwXsN7De81vNfwXsN7De81vNfwXqN7je41utfwXsN7De81vNd83SVfd8n3Gvp8r6HP9xr66F7Dew3vNbzX8F7Dew3vNbzX8F7De43uNbrX6F7Dew3vNbzX8F7zdZd83SXfa+jzvYY+32voo3sN7zW81/Bew3sN7zW81/Bew3sN7zW61+heo3sN7zW81/Bew3vN113ydZd8r6HP9xr6fK+hj+41vNfwXsN7De81vNfwXsN7De81vNfoXqN7je41vNfwXsN7De814y4Zd8lcQ5+5hj5zDX10r+G9hvca3mt4r+G9hvca3mt4r+G9Rvca3Wt0r+G9hvca3mt4rxl3ybhL5hr6zDX0mWvoo3sN7zW81/Bew3sN7zW81/Bew3sN7zW61+heo3sN7zW81/Bew3vNuEvGXTLX0Geuoc9cQx/da3iv4b2G9xrea3iv4b2G9xrea3iv0b1G9xrda3iv4b2G9xrea8ZdMu6SuYY+cw195hr66F7Dew3vNbzX8F7Dew3vNbzX8F7De43uNbrX6F7Dew3vNbzX8F4Td0ncJbmGPrmGPrmGPrrX8F7Dew3vNbzX8F7Dew3vNbzX8F6je43uNbrX8F7Dew3vNbzXxF0Sd0muoU+uoU+uoY/uNbzX8F7Dew3vNbzX8F7Dew3vNbzX6F6je43uNbzX8F7Dew3vNXGXxF2Sa+iTa+iTa+ijew3vNbzX8F7Dew3vNbzX8F7Dew3vNbrX6F6jew3vNbzX8F7De03cJXGX5Br65Br65Br66F7Dew3vNbzX8F7Dew3vNbzX8F7De43uNbrX6F7Dew3vNbzX8F4Td0ncJbmGPrmGPrmGPrrX8F7Dew3vNbzX8F7Dew3vNbzX8F6je43uNbrX8F7Dew3vNbzX1F1Sd0mvoU+voU+voY/uNbzX8F7Dew3vNbzX8F7Dew3vNbzX6F6je43uNbzX8F7Dew3vNXWX1F3Sa+jTa+jTa+ijew3vNbzX8F7Dew3vNbzX8F7Dew3vNbrX6F6jew3vNbzX8F7De03dJXWX9Br69Br69Br66F7Dew3vNbzX8F7Dew3vNbzX8F7De43uNbrX6F7Dew3vNbzX8F5Td0ndJb2GPr2GPr2GPrrX8F7Dew3vNbzX8F7Dew3vNbzX8F6je43uNbrX8F7Dew3vNbzXrLtk3SV7DX32GvrsNfTRvYb3Gt5reK/hvYb3Gt5reK/hvYb3Gt1rdK/RvYb3Gt5reK/hvWbdJesu2Wvos9fQZ6+hj+41vNfwXsN7De81vNfwXsN7De81vNfoXqN7je41vNfwXsN7De816y5Zd8leQ5+9hj57DX10r+G9hvca3mt4r+G9hvca3mt4r+G9Rvca3Wt0r+G9hvca3mt4r1l3ybpL9hr67DX02Wvoo3sN7zW81/Bew3sN7zW81/Bew3sN7zW61+heo3sN7zW81/Bew3vNukvWXbLX0Gevoc9eQx/da3iv4b2G9xrea3iv4b2G9xrea3iv0b1G9xrda3iv4b2G9xreax53yeMuea6hz3MNfZ5r6KN7De81vNfwXsN7De81vNfwXsN7De81utfoXqN7De81vNfwXsN7zeMuedwlzzX0ea6hz3MNfXSv4b2G9xrea3iv4b2G9xrea3iv4b1G9xrda3Sv4b2G9xrea3ivedwlj7vkuYY+zzX0ea6hj+41vNfwXsN7De81vNfwXsN7De81vNfoXqN7je41vNfwXsN7De81j7vkcZc819DnuYY+zzX00b2G9xrea3iv4b2G9xrea3iv4b2G9xrda3Sv0b2G9xrea3iv4b3m5y75uUt+19Dndw19ftfQR/ca3mt4r+G9hvca3mt4r+G9hvca3mt0r9G9Rvca3mt4r+G9hvean7vk5y75XUOf3zX0+V1DH91reK/hvYb3Gt5reK/hvYb3Gt5reK/RvUb3Gt1reK/hvYb3Gt5rfu6Sn7vkdw19ftfQ53cNfXSv4b2G9xrea3iv4b2G9xrea3iv4b1G9xrda3Sv4b2G9xrea3iv+blLfu6S3zX0+V1Dn9819NG9hvca3mt4r+G9hvca3mt4r+G9hvca3Wt0r9G9hvca3mt4r+G95ucu+blLftfQ53cNfX7X0Ef3Gt5reK/hvYb3Gt5rea/lvZb3Wt5rda/VvVb3Wt5rea/lvZb32tfdJX3dXdLXNfR9XUPf1zX01b2W91rea3mv5b2W91rea3mv5b2W91rda3Wv1b2W91rea3mv5b32dXdJX3eX9HUNfV/X0Pd1DX11r+W9lvda3mt5r+W9lvda3mt5r+W9Vvda3Wt1r+W9lvda3mt5r33dXdLX3SV9XUPf1zX0fV1DX91rea/lvZb3Wt5rea/lvZb3Wt5rea/VvVb3Wt1rea/lvZb3Wt5rX+sXsH4B19D3dQ19X9fQV/da3mt5r+W9lvda3mt5r+W9lvda3mt1r9W9Vvda3mt5r+W9lvfa190lfd9d0vc19H1fQ9/3NfTVvZb3Wt5rea/lvZb3Wt5rea/lvZb3Wt1rda/VvZb3Wt5rea/lvfZ9d0nfd5f0fQ1939fQ930NfXWv5b2W91rea3mv5b2W91rea3mv5b1W91rda3Wv5b2W91rea3mvfd9d0vfdJX1fQ9/3NfR9X0Nf3Wt5r+W9lvda3mt5r+W9lvda3mt5r9W9Vvda3Wt5r+W9lvda3mvfd5f0fXdJ39fQ930Nfd/X0Ff3Wt5rea/lvZb3Wt5rea/lvZb3Wt5rda/VvVb3Wt5rea/lvZb32vfjF/D4BVxD3/c19H1fQ1/da3mv5b2W91rea3mv5b2W91rea3mv1b1W91rda3mv5b2W91reaz/uko+75HMNfT/X0PdzDX11r+W9lvda3mt5r+W9lvda3mt5r+W9Vvda3Wt1r+W9lvda3mt5r/24Sz7uks819P1cQ9/PNfTVvZb3Wt5rea/lvZb3Wt5rea/lvZb3Wt1rda/VvZb3Wt5rea/lvfbjLvm4Sz7X0PdzDX0/19BX91rea3mv5b2W91rea3mv5b2W91rea3Wv1b1W91rea3mv5b2W99qPu+TjLvlcQ9/PNfT9XENf3Wt5r+W9lvda3mt5r+W9lvda3mt5r9W9Vvda3Wt5r+W9lvda3ms/7pKPu+RzDX2/19D3ew19da/lvZb3Wt5rea/lvZb3Wt5rea/lvVb3Wt1rda/lvZb3Wt5rea/9uku+7pLvNfT9XkPf7zX01b2W91rea3mv5b2W91rea3mv5b2W91rda3Wv1b2W91rea3mv5b326y75uku+19D3ew19v9fQV/da3mt5r+W9lvda3mt5r+W9lvda3mt1r9W9Vvda3mt5r+W9lvfar7vk6y75XkPf7zX0/V5DX91rea/lvZb3Wt5rea/lvZb3Wt5rea/VvVb3Wt1rea/lvZb3Wt5rv+6Sr7vkew19v9fQ93sNfXWv5b2W91rea3mv5b2W91rea3mv5b1W91rda3Wv5b2W91rea3mvHXfJuEvmGvrONfSda+irey3vtbzX8l7Ley3vtbzX8l7Ley3vtbrX6l6rey3vtbzX8l7Le+24S8ZdMtfQd66h71xDX91rea/lvZb3Wt5rea/lvZb3Wt5rea/VvVb3Wt1rea/lvZb3Wt5rx10y7pK5hr5zDX3nGvrqXst7Le+1vNfyXst7Le+1vNfyXst7re61utfqXst7Le+1vNfyXjvuknGXzDX0nWvoO9fQV/da3mt5r+W9lvda3mt5r+W9lvda3mt1r9W9Vvda3mt5r+W9lvfacZeMu2Suoe9cQ9+5hr661/Jey3st77W81/Jey3st77W81/Jeq3ut7rW61/Jey3st77W818ZdEndJrqFvrqFvrqGv7rW81/Jey3st77W81/Jey3st77W81+peq3ut7rW81/Jey3st77Vxl8Rdkmvom2vom2voq3st77W81/Jey3st77W81/Jey3st77W61+peq3st77W81/Jey3tt3CVxl+Qa+uYa+uYa+upey3st77W81/Jey3st77W81/Jey3ut7rW61+pey3st77W81/JeG3dJ3CW5hr65hr65hr661/Jey3st77W81/Jey3st77W81/Jeq3ut7rW61/Jey3st77W819ZdUndJr6Fvr6Fvr6Gv7rW81/Jey3st77W81/Jey3st77W81+peq3ut7rW81/Jey3st77V1l9Rd0mvo22vo22voq3st77W81/Jey3st77W81/Jey3st77W61+peq3st77W81/Jey3tt3SV1l/Qa+vYa+vYa+upey3st77W81/Jey3st77W81/Jey3ut7rW61+pey3st77W81/JeW3dJ3SW9hr69hr69hr661/Jey3st77W81/Jey3st77W81/Jeq3ut7rW61/Jey3st77W819ZdUndJr6Fvr6Fvr6Gv7rW81/Jey3st77W81/Jey3st77W81+peq3ut7rW81/Jey3st77XrLll3yV5D372GvnsNfXWv5b2W91rea3mv5b2W91rea3mv5b1W91rda3Wv5b2W91rea3mvXXfJukv2GvruNfTda+irey3vtbzX8l7Ley3vtbzX8l7Ley3vtbrX6l6rey3vtbzX8l7Le+26S9ZdstfQd6+h715DX91rea/lvZb3Wt5rea/lvZb3Wt5rea/VvVb3Wt1rea/lvZb3Wt5r112y7pK9hr57DX33GvrqXst7Le+1vNfyXst7Le+1vNfyXst7re61utfqXst7Le+1vNfyXvu4Sx53yXMNfZ9r6PtcQ1/da3mv5b2W91rea3mv5b2W91rea3mv1b1W91rda3mv5b2W91reax93yeMuea6h73MNfZ9r6Kt7Le+1vNfyXst7Le+1vNfyXst7Le+1utfqXqt7Le+1vNfyXst77eMuedwlzzX0fa6h73MNfXWv5b2W91rea3mv5b2W91rea3mv5b1W91rda3Wv5b2W91rea3mvfdwlj7vkuYa+zzX0fa6hr+61vNfyXst7Le+1vNfyXst7Le+1vNfqXqt7re61vNfyXst7Le+1j7vkcZc819D3uYa+zzX01b2W91rea3mv5b2W91rea3mv5b2W91rda3Wv1b2W91rea3mv5b325y75uUt+19D3dw19f9fQV/da3mt5r+W9lvda3mt5r+W9lvda3mt1r9W9Vvda3mt5r+W9lvfan7vk5y75XUPf3zX0/V1DX91rea/lvZb3Wt5rea/lvZb3Wt5rea/VvVb3Wt1rea/lvZb3Wt5rf+6Sn7vkdw19f9fQ93cNfXWv5b2W91rea3mv5b2W91rea3mv5b1W91rda3Wv5b2W91rea3mv/blLfu6S3zX0/V1D39819NW9lvda3mt5r+W9lvda3mt5r+W9lvda3Wt1r9W9lvda3mt5r8t73dfdJfu6u2Rf19Dv6xr6fV1Dv7rX5b0u73V5r8t7Xd7r8l6X97q81+W9ru51da+re13e6/Jel/e6vNd93V2yr7tL9nUN/b6uod/XNfSre13e6/Jel/e6vNflvS7vdXmvy3td3uvqXlf3urrX5b0u73V5r8t73dfdJfu6u2Rf19Dv6xr6fV1Dv7rX5b0u73V5r8t7Xd7r8l6X97q81+W9ru51da+re13e6/Jel/e6vNd93V2yr7tL9nUN/b6uod/XNfSre13e6/Jel/e6vNflvS7vdXmvy3td3uvqXlf3urrX5b0u73V5r8t73dfjF/DzC7iGfl/X0O/rGvrVvS7vdXmvy3td3uvyXpf3urzX5b0u73V1r6t7Xd3r8l6X97q81+W97vvukn3fXbLva+j3fQ39vq+hX93r8l6X97q81+W9Lu91ea/Le13e6/JeV/e6utfVvS7vdXmvy3td3uu+7y7Z990l+76Gft/X0O/7GvrVvS7vdXmvy3td3uvyXpf3urzX5b0u73V1r6t7Xd3r8l6X97q81+W97vvukn3fXbLva+j3fQ39vq+hX93r8l6X97q81+W9Lu91ea/Le13e6/JeV/e6utfVvS7vdXmvy3td3uu+1y9g/QKuod/3NfT7voZ+da/Le13e6/Jel/e6vNflvS7vdXmvy3td3evqXlf3urzX5b0u73V5r/t2l3zcJZ9r6PdzDf1+rqFf3evyXpf3urzX5b0u73V5r8t7Xd7r8l5X97q619W9Lu91ea/Le13e637cJR93yeca+v1cQ7+fa+hX97q81+W9Lu91ea/Le13e6/Jel/e6vNfVva7udXWvy3td3uvyXpf3uh93ycdd8rmGfj/X0O/nGvrVvS7vdXmvy3td3uvyXpf3urzX5b0u73V1r6t7Xd3r8l6X97q81+W97sdd8nGXfK6h38819Pu5hn51r8t7Xd7r8l6X97q81+W9Lu91ea/Le13d6+peV/e6vNflvS7vdXmv+3GXfNwln2vo93MN/X6uoV/d6/Jel/e6vNflvS7vdXmvy3td3uvyXlf3urrX1b0u73V5r8t7Xd7rft0lX3fJ9xr6/V5Dv99r6Ff3urzX5b0u73V5r8t7Xd7r8l6X97q819W9ru51da/Le13e6/Jel/e6X3fJ113yvYZ+v9fQ7/ca+tW9Lu91ea/Le13e6/Jel/e6vNflvS7vdXWvq3td3evyXpf3urzX5b3u113ydZd8r6Hf7zX0++fu9fcf/8Lj83eff9qS//x8+/z4/Pocn/FZn16r1+q19dp6bb22XluvrdfWa+u19dp67fHa47XHa4/XHq89Xnu89njt8drjtZ/Xfl77ee3ntZ/Xfl77ee3ntZ/Xfvfan7vX//x8+/z4/Pocn/FZn+vz8em1t9feXnt77e21t9feXnt77e21t9feXvt47eO1j9c+Xvt47eO1j9c+Xvt47eO1r9e+Xvt67eu1r9e+Xvt67eu1r9e+XhuvjdfGa+O18dp4bbw2XhuvjdfitXgtXovX4rV4LV6zJWNLxpaMLRlbMrZkbMnYkrElY0vGlowtGVsytmRsydiSsSVjS8aWjC0ZWzK2ZGzJ2JKxJWNLxpaMLRlbMrZkbMnYkrElY0vGlowtGVsytmRsydiSsSVjS8aWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUltSW1JbUlqwtWVuytmRtydqStSVrS9aWrC1ZW7K2ZG3J2pK1JWtL1pasLVlbsrZkbcnakrUla0vWlqwtWVuytmRtydqStSVrS9aWrC1ZW7K2ZG3J2pK1JWtL1pasLVlbsrZkbcnakrUla0vWlqwtWVuytmRtydqStSVrS9aWrC1ZW7K2ZG3J2pK1JWtL1pasLVlbsrZkbcnakrUla0vWlqwtWVuytmRtydqStSVrS9aWrC1ZW7K2ZG3J2pK1JWtL1pasLVlbsrZkbcnakrUla0vWlqwtWVuytmRtyWNLHlvy2JLHljy25LEljy15bMljSx5b8tiSx5Y8tuTP3eu//2/o//c9/993/vz9x7/8i//1N3/4h7/523/8+//5F//l//z7H//7v/3T3/3rP/zzP/3HH//1f//Lf/7N3/7hH/7xH//hf/z1v/zhn//u7//bv/3h7//6H//57/70d3/x+tM//vSf8l+/r7/85q/++Mc//tUf/y8=", + "file_map": { + "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::H;\nuse lib::configs::default::threshold::{L, N, PK_AGGREGATION_BIT_PK, PK_AGGREGATION_CONFIGS};\nuse lib::core::threshold::pk_aggregation::PkAggregation;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_threshold_pk_commitments: pub [Field; H],\n pk0: [[Polynomial; L]; H],\n pk1: [[Polynomial; L]; H],\n pk0_agg: [Polynomial; L],\n pk1_agg: [Polynomial; L],\n) -> pub Field {\n let pk_aggregation: PkAggregation = PkAggregation::new(\n PK_AGGREGATION_CONFIGS,\n expected_threshold_pk_commitments,\n pk0,\n pk1,\n pk0_agg,\n pk1_agg,\n );\n\n pk_aggregation.execute()\n}\n", + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/threshold/pk_aggregation/src/main.nr" + }, + "69": { + "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_pk_aggregation_commitment;\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Threshold public key aggregation circuit.\npub struct Configs {\n /// CRT moduli for each basis: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L]) -> Self {\n Configs { qis }\n }\n}\n\n/// Public Key Aggregation (Circuit 5).\n///\n/// Verifies that for each CRT basis l and each coefficient i:\n/// - pk0_agg[l][i] = sum_h(pk0[h][l][i]) mod q_l\n/// - pk1_agg[l][i] = sum_h(pk1[h][l][i]) mod q_l\npub struct PkAggregation {\n /// Circuit parameters including CRT moduli\n configs: Configs,\n\n /// Expected commitments to threshold public key (from C1)\n /// We need one commitment from each honest party (H).\n /// (public witness)\n expected_threshold_pk_commitments: [Field; H],\n\n /// Individual public keys from H honest parties\n /// pk0[party_idx][basis_idx] - first component of public key for each party and CRT basis\n /// (committed witnesses)\n pk0: [[Polynomial; L]; H],\n /// pk1[party_idx][basis_idx] - second component of public key for each party and CRT basis\n /// (committed witnesses)\n pk1: [[Polynomial; L]; H],\n\n /// Claimed aggregated public key\n /// pk0_agg[basis_idx] - first component of aggregated public key for each CRT basis\n /// (committed witnesses)\n pk0_agg: [Polynomial; L],\n /// pk1_agg[basis_idx] - second component of aggregated public key for each CRT basis\n /// (committed witnesses)\n pk1_agg: [Polynomial; L],\n}\n\nimpl PkAggregation {\n pub fn new(\n configs: Configs,\n expected_threshold_pk_commitments: [Field; H],\n pk0: [[Polynomial; L]; H],\n pk1: [[Polynomial; L]; H],\n pk0_agg: [Polynomial; L],\n pk1_agg: [Polynomial; L],\n ) -> Self {\n PkAggregation { configs, expected_threshold_pk_commitments, pk0, pk1, pk0_agg, pk1_agg }\n }\n\n /// Verifies that pk hashes to each expected_threshold_pk_commitment\n fn verify_pk_commitments(self) {\n for i in 0..H {\n assert(\n compute_pk_aggregation_commitment::(self.pk0[i], self.pk1[i])\n == self.expected_threshold_pk_commitments[i],\n \"PK commitment mismatch\",\n );\n }\n }\n\n fn verify_pk_for_basis(\n self,\n pk: [[Polynomial; L]; H],\n pk_agg: [Polynomial; L],\n basis_idx: u32,\n ) {\n let q_l = self.configs.qis[basis_idx];\n let mod_q_l = ModU128::new(q_l);\n\n for coeff_idx in 0..N {\n // Sum pk coefficients from all honest parties\n let mut sum_pk: Field = 0;\n for party_idx in 0..H {\n sum_pk = sum_pk + pk[party_idx][basis_idx].coefficients[coeff_idx];\n }\n\n // Reduce mod q_l\n let sum_pk_reduced = mod_q_l.reduce_mod(sum_pk);\n\n // Verify equality\n assert(\n sum_pk_reduced == pk_agg[basis_idx].coefficients[coeff_idx],\n \"pk aggregation mismatch\",\n );\n }\n }\n\n /// Main verification function\n /// Returns commitment to aggregated threshold public key\n pub fn execute(self) -> Field {\n // 0. Verify pk commitments\n self.verify_pk_commitments();\n\n // 1. Verify pk0 & pk1 aggregations for each CRT basis\n for basis_idx in 0..L {\n self.verify_pk_for_basis(self.pk0, self.pk0_agg, basis_idx);\n self.verify_pk_for_basis(self.pk1, self.pk1_agg, basis_idx);\n }\n\n // 2. Commit to aggregated threshold public key\n compute_pk_aggregation_commitment::(self.pk0_agg, self.pk1_agg)\n }\n}\n", + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/threshold/pk_aggregation.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" + }, + "77": { + "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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\n // 3 * 4 = 12 = 1 (mod 11), so 3^(-1) = 4 (mod 11)\n assert(result == 4);\n // Verify: 3 * result = 1 (mod 11)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n // 3^(-1) mod 11 = 4 (since 3 * 4 = 12 = 1 mod 11)\n // 7 * 4 = 28 = 6 (mod 11)\n assert(result == 6);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n", + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/U128.nr" + }, + "79": { + "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//! Unconstrained functions for modular u128 arithmetic.\n//!\n//! This module provides unconstrained functions that perform modular arithmetic\n//! computations without generating circuit constraints. These functions are used\n//! internally by the constrained operations in `U128` and should not be called\n//! directly in circuits without proper verification.\n\n/// Computes quotient and remainder for value modulo q (unconstrained).\n///\n/// This function performs integer division and modulo operations to compute\n/// `value = q * quotient + remainder` where `0 <= remainder < q`.\n///\n/// # Arguments\n/// * `value` - The value to reduce\n/// * `q` - The modulus\n///\n/// # Returns\n/// A tuple `(quotient, remainder)` where:\n/// - `quotient = value / q`\n/// - `remainder = value % q`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __compute_mod_reduction(value: Field, q: Field) -> (Field, Field) {\n let value_u128 = value as u128;\n let q_u128 = q as u128;\n\n let quotient_u128 = value_u128 / q_u128;\n let remainder_u128 = value_u128 % q_u128;\n\n (quotient_u128 as Field, remainder_u128 as Field)\n}\n\n/// Computes the negation of a value modulo m (unconstrained).\n///\n/// Returns `(m - val) mod m`, with special handling for zero (returns 0).\n///\n/// # Arguments\n/// * `val` - The value to negate\n/// * `m` - The modulus\n///\n/// # Returns\n/// The additive inverse `(-val) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __neg(val: Field, m: Field) -> Field {\n if val == 0 {\n 0\n } else {\n m - val\n }\n}\n\n/// Subtracts two values with underflow handling (unconstrained).\n///\n/// Computes `(lhs - rhs) mod m`, handling the case where `lhs < rhs` by adding\n/// the modulus. Returns both the result and a flag indicating if underflow occurred.\n///\n/// # Preconditions\n/// Inputs must be reduced modulo `m` such that `lhs, rhs in [0, m)`. This ensures\n/// that the computed difference is bounded and cannot overflow `u128`.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value (minuend), must be in `[0, m)`\n/// * `rhs` - Right-hand side value (subtrahend), must be in `[0, m)`\n/// * `m` - The modulus, must satisfy `m <= u128::MAX`\n///\n/// # Returns\n/// A tuple `(result, underflow)` where:\n/// - `result = (lhs - rhs) mod m`\n/// - `underflow = true` if `lhs < rhs`, `false` otherwise\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\n/// As long as inputs are reduced modulo `m` (and `m <= u128::MAX`), the subtraction-with-underflow\n/// logic is safe and will not overflow `u128`. This function is used by the constrained `sub` method\n/// in `modulo::U128`, which ensures inputs are properly reduced before calling `__sub_with_underflow`.\n/// See the surrounding `modulo/unconstrained_U128` module documentation for details.\npub unconstrained fn __sub_with_underflow(lhs: Field, rhs: Field, m: Field) -> (Field, bool) {\n let lhs_u128 = lhs as u128;\n let rhs_u128 = rhs as u128;\n let m_u128 = m as u128;\n\n let underflow = lhs_u128 < rhs_u128;\n let result = if underflow {\n // Compute (lhs - rhs + m) mod m safely to avoid u128 overflow\n // Since lhs < rhs, we compute: m - (rhs - lhs)\n // This avoids the potential overflow in lhs + m\n let diff = rhs_u128 - lhs_u128; // This is safe since rhs > lhs\n (m_u128 - diff) as Field\n } else {\n (lhs_u128 - rhs_u128) as Field\n };\n (result, underflow)\n}\n\n/// Multiplies two values and returns both quotient and remainder (unconstrained).\n///\n/// Computes `lhs * rhs = m * quotient + remainder` where `0 <= remainder < m`.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value\n/// * `rhs` - Right-hand side value\n/// * `m` - The modulus\n///\n/// # Returns\n/// A tuple `(quotient, remainder)` where `lhs * rhs = m * quotient + remainder`\n///\n/// # Overflow Warning\n/// Field multiplication wraps modulo the field prime (~254 bits). For two u128 values\n/// near 2^128, their product (up to 2^256) exceeds the Field modulus, causing silent\n/// wraparound before the mod reduction. This can produce incorrect results.\n///\n/// # Safe Input Range\n/// To avoid overflow, ensure `lhs * rhs < Field::MODULUS`. For typical use cases:\n/// - Party IDs, polynomial coefficients, and small cryptographic values (< 2^64) are safe\n/// - Arbitrary u128 values may overflow and should be validated by callers\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\n/// Callers must ensure inputs are within the safe range to prevent silent overflow.\npub unconstrained fn __mul_with_quotient(lhs: Field, rhs: Field, m: Field) -> (Field, Field) {\n // WARNING: Field multiplication can overflow for large inputs.\n // For u128 values near 2^128, the product (up to 2^256) exceeds Field modulus (~2^254),\n // causing wraparound. This is safe for typical use cases (party IDs, small coefficients),\n // but callers must validate input ranges for arbitrary u128 values.\n let product = lhs * rhs;\n __compute_mod_reduction(product, m)\n}\n\n/// Computes the modular multiplicative inverse using Fermat's Little Theorem (unconstrained).\n///\n/// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n/// using the identity: val^(-1) = val^(m-2) (mod m) (from Fermat's Little Theorem).\n///\n/// # Arguments\n/// * `val` - The value to invert (must be coprime with the modulus)\n/// * `m` - The modulus (should be prime for this method to work correctly)\n///\n/// # Returns\n/// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __inv_mod(val: Field, m: Field) -> Field {\n // by Fermat's Little Theorem: val^(m-1)= 1 mod m\n __pow_mod(val, m - 2, m)\n}\n\n/// Computes modular division: `lhs * rhs^(-1) mod m` (unconstrained).\n///\n/// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n///\n/// # Arguments\n/// * `lhs` - The numerator\n/// * `rhs` - The denominator (must be coprime with the modulus)\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `(lhs * rhs^(-1)) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __div_mod(lhs: Field, rhs: Field, m: Field) -> Field {\n let rhs_inv = __inv_mod(rhs, m);\n __mul_mod(lhs, rhs_inv, m)\n}\n\n/// Computes modular exponentiation: `base^exp mod m` (unconstrained).\n///\n/// Uses the binary exponentiation method (also known as square-and-multiply)\n/// for efficient computation of large powers.\n///\n/// # Arguments\n/// * `base` - The base value\n/// * `exp` - The exponent\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `base^exp mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __pow_mod(base: Field, exp: Field, m: Field) -> Field {\n let mut result = 1 as Field;\n let (_, base_mod) = __compute_mod_reduction(base, m);\n let mut current_base = base_mod;\n let mut e = exp as u128;\n\n while e > 0 {\n if (e % 2) == 1 {\n result = __mul_mod(result, current_base, m);\n }\n current_base = __mul_mod(current_base, current_base, m);\n e = e / 2;\n }\n\n result\n}\n\n/// Multiplies two values with modular reduction (unconstrained).\n///\n/// Computes `(lhs * rhs) mod m` and returns only the remainder.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value\n/// * `rhs` - Right-hand side value\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `(lhs * rhs) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __mul_mod(lhs: Field, rhs: Field, m: Field) -> Field {\n let (_, r) = __mul_with_quotient(lhs, rhs, m);\n r\n}\n\n// ------------------------------ TESTS ------------------------------\n// Note: All unsafe blocks in the following tests are safe because we are testing\n// unconstrained functions in a controlled test environment. These functions are\n// designed to be called from unsafe blocks or other unconstrained functions.\n// Each unsafe block is used to call an unconstrained function for testing purposes.\n\n#[test]\nfn test_compute_mod_reduction_simple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(42, 10) };\n assert(q == 4); // 42 / 10 = 4\n assert(r == 2); // 42 % 10 = 2\n // Verify: 42 = 10 * 4 + 2\n assert(10 * q + r == 42);\n}\n\n#[test]\nfn test_compute_mod_reduction_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(100, 10) };\n assert(q == 10); // 100 / 10 = 10\n assert(r == 0); // 100 % 10 = 0\n assert(10 * q + r == 100);\n}\n\n#[test]\nfn test_compute_mod_reduction_large_value() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(12345, 100) };\n assert(q == 123); // 12345 / 100 = 123\n assert(r == 45); // 12345 % 100 = 45\n assert(100 * q + r == 12345);\n}\n\n#[test]\nfn test_compute_mod_reduction_smaller_than_modulus() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(7, 10) };\n assert(q == 0); // 7 / 10 = 0\n assert(r == 7); // 7 % 10 = 7\n assert(10 * q + r == 7);\n}\n\n#[test]\nfn test_neg_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(0, 100) };\n assert(result == 0); // Negation of zero is zero\n}\n\n#[test]\nfn test_neg_non_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(30, 100) };\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_large_value() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(12345, 100000) };\n assert(result == 87655); // 100000 - 12345 = 87655\n}\n\n#[test]\nfn test_neg_verification() {\n let val: Field = 42;\n let m: Field = 97;\n // Safety: Test function calling unconstrained helper\n let neg_val = unsafe { __neg(val, m) };\n // Verify: val + neg_val = 0 (mod m)\n let sum = val + neg_val;\n // Safety: Test function calling unconstrained helper\n let (_, remainder) = unsafe { __compute_mod_reduction(sum, m) };\n assert(remainder == 0);\n}\n\n#[test]\nfn test_sub_with_underflow_no_underflow() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(50, 30, 100) };\n assert(underflow == false);\n assert(result == 20); // 50 - 30 = 20\n}\n\n#[test]\nfn test_sub_with_underflow_with_underflow() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(30, 50, 100) };\n assert(underflow == true);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_with_underflow_equal_values() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(42, 42, 100) };\n assert(underflow == false);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\n}\n\n#[test]\nfn test_mul_with_quotient_simple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(6, 7, 10) };\n assert(q == 4); // (6 * 7) / 10 = 42 / 10 = 4\n assert(r == 2); // (6 * 7) % 10 = 42 % 10 = 2\n // Verify: 6 * 7 = 10 * 4 + 2\n assert(6 * 7 == 10 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(12, 15, 100) };\n assert(q == 1); // (12 * 15) / 100 = 180 / 100 = 1\n assert(r == 80); // (12 * 15) % 100 = 180 % 100 = 80\n assert(12 * 15 == 100 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(5, 20, 100) };\n assert(q == 1); // (5 * 20) / 100 = 100 / 100 = 1\n assert(r == 0); // (5 * 20) % 100 = 100 % 100 = 0\n assert(5 * 20 == 100 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_verification() {\n let lhs: Field = 123;\n let rhs: Field = 456;\n let m: Field = 1000;\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(lhs, rhs, m) };\n // Verify: lhs * rhs = m * q + r\n assert(lhs * rhs == m * q + r);\n // Verify remainder is in range [0, m)\n assert((r as u128) < (m as u128));\n}\n\n#[test]\nfn test_mul_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(6, 7, 10) };\n assert(result == 2); // (6 * 7) mod 10 = 42 mod 10 = 2\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(12, 15, 100) };\n assert(result == 80); // (12 * 15) mod 100 = 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(5, 20, 100) };\n assert(result == 0); // (5 * 20) mod 100 = 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(42, 0, 100) };\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_commutative() {\n let a: Field = 7;\n let b: Field = 9;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let mul_a_b = unsafe { __mul_mod(a, b, m) };\n // Safety: Test function calling unconstrained helper\n let mul_b_a = unsafe { __mul_mod(b, a, m) };\n // Verify: a * b = b * a\n assert(mul_a_b == mul_b_a);\n}\n\n#[test]\nfn test_pow_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(2, 3, 10) };\n assert(result == 8); // 2^3 mod 10 = 8 mod 10 = 8\n}\n\n#[test]\nfn test_pow_mod_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(2, 10, 100) };\n assert(result == 24); // 2^10 = 1024, 1024 mod 100 = 24\n}\n\n#[test]\nfn test_pow_mod_exponent_one() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(7, 1, 100) };\n assert(result == 7); // 7^1 mod 100 = 7\n}\n\n#[test]\nfn test_pow_mod_exponent_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(7, 0, 100) };\n assert(result == 1); // 7^0 mod 100 = 1\n}\n\n#[test]\nfn test_pow_mod_base_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(0, 5, 100) };\n assert(result == 0); // 0^5 mod 100 = 0\n}\n\n#[test]\nfn test_pow_mod_large_exponent() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(3, 7, 97) };\n // 3^7 = 2187, 2187 mod 97 = 53\n assert(result == 53);\n}\n\n#[test]\nfn test_pow_mod_fermat_little_theorem() {\n // For prime modulus p and value a, a^(p-1) = 1 (mod p)\n let a: Field = 3;\n let p: Field = 11; // Prime\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(a, p - 1, p) };\n assert(result == 1);\n}\n\n#[test]\nfn test_inv_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(3, 11) };\n // 3 * 4 = 12 = 1 (mod 11), so 3^(-1) = 4 (mod 11)\n assert(result == 4);\n // Verify: 3 * result = 1 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(3, result, 11) } == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(7, 13) };\n // Verify: 7 * result = 1 (mod 13)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(7, result, 13) } == 1);\n}\n\n#[test]\nfn test_inv_mod_another_prime() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(5, 17) };\n // Verify: 5 * result = 1 (mod 17)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(5, result, 17) } == 1);\n}\n\n#[test]\nfn test_inv_mod_inverse_of_inverse() {\n let a: Field = 7;\n let m: Field = 11;\n // Safety: Test function calling unconstrained helper\n let inv_a = unsafe { __inv_mod(a, m) };\n // Safety: Test function calling unconstrained helper\n let inv_inv_a = unsafe { __inv_mod(inv_a, m) };\n // (a^(-1))^(-1) = a\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_div_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(6, 2, 11) };\n assert(result == 3); // 6 / 2 = 3\n // Verify: result * 2 = 6 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 2, 11) } == 6);\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(7, 3, 11) };\n // 3^(-1) mod 11 = 4 (since 3 * 4 = 12 = 1 mod 11)\n // 7 * 4 = 28 = 6 (mod 11)\n assert(result == 6);\n // Verify: result * 3 = 7 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 3, 11) } == 7);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a: Field = 10;\n let b: Field = 3;\n let m: Field = 17;\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(a, b, m) };\n // Verify: result * b = a (mod m)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, b, m) } == a);\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a: Field = 250;\n let b: Field = 7;\n let m: Field = 97;\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(a, b, m) };\n // Verify: result * b = a (mod m)\n // Safety: Test function calling unconstrained helper\n let (_, a_reduced) = unsafe { __compute_mod_reduction(a, m) }; // 250 mod 97 = 56\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, b, m) } == a_reduced);\n}\n\n#[test]\nfn test_div_mod_by_one() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(42, 1, 100) };\n assert(result == 42); // 42 / 1 = 42\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 1, 100) } == 42);\n}\n\n#[test]\nfn test_all_operations_consistency() {\n // Test that all operations work together correctly\n let m: Field = 97; // Prime\n let a: Field = 42;\n let b: Field = 13;\n\n // Test: (a + b) mod m\n let sum = a + b;\n // Safety: Test function calling unconstrained helper\n let (_, sum_reduced) = unsafe { __compute_mod_reduction(sum, m) };\n assert(sum_reduced == 55);\n\n // Test: (a - b) mod m using subtraction\n // Safety: Test function calling unconstrained helper\n let (diff, _) = unsafe { __sub_with_underflow(a, b, m) };\n assert(diff == 29);\n\n // Test: (a * b) mod m\n // Safety: Test function calling unconstrained helper\n let prod = unsafe { __mul_mod(a, b, m) };\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test: b^(-1) mod m\n // Safety: Test function calling unconstrained helper\n let inv = unsafe { __inv_mod(b, m) };\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(b, inv, m) } == 1);\n\n // Test: (a / b) mod m\n // Safety: Test function calling unconstrained helper\n let quot = unsafe { __div_mod(a, b, m) };\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(quot, b, m) } == a);\n\n // Test: (-a) mod m\n // Safety: Test function calling unconstrained helper\n let neg = unsafe { __neg(a, m) };\n let sum_neg = a + neg;\n // Safety: Test function calling unconstrained helper\n let (_, sum_neg_reduced) = unsafe { __compute_mod_reduction(sum_neg, m) };\n assert(sum_neg_reduced == 0);\n}\n", + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/unconstrained_U128.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 } } +} diff --git a/crates/zk-prover/tests/fixtures/pk_aggregation.vk b/crates/zk-prover/tests/fixtures/pk_aggregation.vk new file mode 100644 index 0000000000..e6e8760477 Binary files /dev/null and b/crates/zk-prover/tests/fixtures/pk_aggregation.vk differ diff --git a/crates/zk-prover/tests/fixtures/pk_generation.json b/crates/zk-prover/tests/fixtures/pk_generation.json index babbab1959..c1ae8868bf 100644 --- a/crates/zk-prover/tests/fixtures/pk_generation.json +++ b/crates/zk-prover/tests/fixtures/pk_generation.json @@ -1,6 +1,6 @@ { "noir_version": "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", - "hash": "12232726796948057982", + "hash": "944264242874897871", "abi": { "parameters": [ { @@ -127,27 +127,27 @@ }, "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, PK_GENERATION_BIT_E_SM, PK_GENERATION_BIT_EEK, PK_GENERATION_BIT_PK, PK_GENERATION_BIT_R1,\n PK_GENERATION_BIT_R2, PK_GENERATION_BIT_SK, PK_GENERATION_CONFIGS,\n};\nuse lib::core::threshold::pk_generation::PkGeneration;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n a: pub [Polynomial; L],\n eek: Polynomial,\n sk: Polynomial,\n e_sm: [Polynomial; L],\n r1is: [Polynomial<(2 * N) - 1>; L],\n r2is: [Polynomial; L],\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n) -> pub (Field, Field, Field) {\n let pk_generation: PkGeneration = PkGeneration::new(\n PK_GENERATION_CONFIGS,\n a,\n eek,\n sk,\n e_sm,\n r1is,\n r2is,\n pk0is,\n pk1is,\n );\n pk_generation.execute()\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/bin/threshold/pk_generation/src/main.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/threshold/pk_generation/src/main.nr" }, "70": { "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::{\n compute_share_computation_e_sm_commitment, compute_share_computation_sk_commitment,\n compute_threshold_pk_challenge, compute_threshold_pk_commitment,\n};\nuse crate::math::helpers::flatten;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for threshold public key generation circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Bound for error polynomial (eek) coefficients\n pub eek_bound: Field,\n /// Bound for secret key polynomial (sk) coefficients\n pub sk_bound: Field,\n /// Bound for smudging noise polynomial (e_sm) coefficients\n pub e_sm_bound: Field,\n /// Bounds for r1 polynomials (modulus switching quotients) for each CRT basis\n pub r1_bounds: [Field; L],\n /// Bounds for r2 polynomials (cyclotomic reduction quotients) for each CRT basis\n pub r2_bounds: [Field; L],\n}\n\nimpl Configs {\n pub fn new(\n qis: [Field; L],\n eek_bound: Field,\n sk_bound: Field,\n e_sm_bound: Field,\n r1_bounds: [Field; L],\n r2_bounds: [Field; L],\n ) -> Self {\n Configs { qis, eek_bound, sk_bound, e_sm_bound, r1_bounds, r2_bounds }\n }\n}\n\n/// Correct Threshold Public Key Generation Circuit (Circuit 1).\n///\n/// Verifies:\n/// 1. Range checks on all secret witnesses (secret key, error, smudging noise, quotients)\n/// 2. Correct public key generation: pk0_i = -a_i * sk + eek + r2_i * (X^N + 1) + r1_i * q_i\n/// and pk1_i = a_i\n///\n/// Outputs:\n/// - commit(threshold_sk)\n/// - commit(threshold_pk)\n/// - commit(e_sm)\npub struct PkGeneration {\n /// Cryptographic parameters including bounds, moduli, and constants.\n configs: Configs,\n\n /// Common Reference String polynomials (public witnesses)\n /// One polynomial per modulus i\n a: [Polynomial; L],\n\n /// Error polynomial (secret witness)\n /// Small coefficients sampled from error distribution\n eek: Polynomial,\n\n /// Secret key polynomial (secret witness)\n /// Small coefficients sampled from CBD (Centered Binomial Distribution)\n sk: Polynomial,\n\n /// Smudging noise polynomial (secret witness)\n /// Used for threshold decryption security\n e_sm: [Polynomial; L],\n\n /// Quotients from polynomial operations (secret witnesses)\n /// r1[i] are quotients from modulus switching for modulus i (can be negative, degree 2*N-1)\n r1: [Polynomial<2 * N - 1>; L],\n /// r2[i] are quotients from cyclotomic reduction for modulus i (typically positive, degree N-1)\n r2: [Polynomial; L],\n\n /// Threshold public key components (committed witnesses)\n /// pk0[i] is the first component of the public key for modulus i\n pk0: [Polynomial; L],\n /// pk1[i] is the second component of the public key for modulus i (should equal a[i])\n pk1: [Polynomial; L],\n}\n\nimpl PkGeneration {\n pub fn new(\n configs: Configs,\n a: [Polynomial; L],\n eek: Polynomial,\n sk: Polynomial,\n e_sm: [Polynomial; L],\n r1: [Polynomial<2 * N - 1>; L],\n r2: [Polynomial; L],\n pk0: [Polynomial; L],\n pk1: [Polynomial; L],\n ) -> Self {\n PkGeneration { configs, a, eek, sk, e_sm, r1, r2, pk0, pk1 }\n }\n\n /// Flattens all witness data into a single array for Fiat-Shamir challenge generation\n fn payload(\n self,\n sk_commitment: Field,\n pk_commitment: Field,\n e_sm_commitment: Field,\n ) -> Vec {\n let mut inputs = Vec::new();\n\n // Flatten CRS polynomials a (L polynomials of degree N)\n inputs = flatten::<_, _, BIT_PK>(inputs, self.a);\n\n // Flatten error polynomial eek (1 polynomial of degree N)\n inputs = flatten::<_, _, BIT_EEK>(inputs, [self.eek]);\n\n // Use commitments instead of full polynomials\n inputs.push(sk_commitment);\n inputs.push(pk_commitment);\n inputs.push(e_sm_commitment);\n\n // Flatten quotient polynomials (L polynomials each)\n inputs = flatten::<_, _, BIT_R1>(inputs, self.r1);\n inputs = flatten::<_, _, BIT_R2>(inputs, self.r2);\n\n inputs\n }\n\n /// Main execution function\n /// Returns (commit(threshold_sk), commit(threshold_pk), commit(e_sm))\n pub fn execute(self) -> (Field, Field, Field) {\n // Step 1: Perform range checks on all secret witness values\n self.perform_range_checks();\n\n // Step 2: Compute commitments\n let sk_commitment = compute_share_computation_sk_commitment::(self.sk);\n let e_sm_commitment =\n compute_share_computation_e_sm_commitment::(self.e_sm);\n let pk_commitment = compute_threshold_pk_commitment::(self.pk0, self.pk1);\n\n // Step 3: Generate Fiat-Shamir challenges using commitments\n let gammas = self.generate_challenge(sk_commitment, pk_commitment, e_sm_commitment);\n\n // Step 4: Verify public key equations for each modulus\n for i in 0..L {\n let gamma = gammas.get(i);\n self.verify_public_key_for_modulus(i, gamma);\n }\n\n // Step 5: Return all commitments\n (sk_commitment, pk_commitment, e_sm_commitment)\n }\n\n /// Generates Fiat-Shamir challenge values using the SAFE cryptographic sponge\n fn generate_challenge(\n self,\n sk_commitment: Field,\n pk_commitment: Field,\n e_sm_commitment: Field,\n ) -> Vec {\n let inputs = self.payload(sk_commitment, pk_commitment, e_sm_commitment);\n\n compute_threshold_pk_challenge::(inputs)\n }\n\n /// Performs range checks on all secret witness values\n fn perform_range_checks(self) {\n // Check that error polynomial has small coefficients\n self.eek.range_check_2bounds::(self.configs.eek_bound, self.configs.eek_bound);\n\n // Check that secret key polynomial has small coefficients\n self.sk.range_check_2bounds::(self.configs.sk_bound, self.configs.sk_bound);\n\n // Check quotient terms are within expected bounds (per modulus)\n for i in 0..L {\n self.e_sm[i].range_check_2bounds::(\n self.configs.e_sm_bound,\n self.configs.e_sm_bound,\n );\n\n self.r1[i].range_check_2bounds::(\n self.configs.r1_bounds[i],\n self.configs.r1_bounds[i],\n );\n\n self.r2[i].range_check_2bounds::(\n self.configs.r2_bounds[i],\n self.configs.r2_bounds[i],\n );\n }\n }\n\n /// Verifies the threshold public key generation equations for a specific CRT basis\n fn verify_public_key_for_modulus(self, i: u32, gamma: Field) {\n // Evaluate all polynomials at the random challenge point gamma\n let a_at_gamma = self.a.map(|a_poly| a_poly.eval(gamma));\n\n let eek_at_gamma = self.eek.eval(gamma);\n let sk_at_gamma = self.sk.eval(gamma);\n\n let r1_at_gamma = self.r1.map(|r1_poly| r1_poly.eval(gamma));\n let r2_at_gamma = self.r2.map(|r2_poly| r2_poly.eval(gamma));\n\n let pk0_at_gamma = self.pk0.map(|pk0_poly| pk0_poly.eval(gamma));\n let pk1_at_gamma = self.pk1.map(|pk1_poly| pk1_poly.eval(gamma));\n\n // Evaluate the cyclotomic polynomial X^N + 1 at gamma\n let cyclo_at_gamma = gamma.pow_32(N as Field) + 1;\n\n // pk0_i = -a_i * sk + eek + r2_i * (X^N + 1) + r1_i * q_i\n let expected_pk0 = -a_at_gamma[i] * sk_at_gamma\n + eek_at_gamma\n + r2_at_gamma[i] * cyclo_at_gamma\n + r1_at_gamma[i] * self.configs.qis[i];\n\n assert(pk0_at_gamma[i] == expected_pk0, \"Public key equation 1 failed\");\n\n // Equation 2: pk1_i = a_i\n assert(pk1_at_gamma[i] == a_at_gamma[i], \"Public key equation 2 failed\");\n }\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/lib/src/core/threshold/pk_generation.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/threshold/pk_generation.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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/commitments.nr" + "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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/helpers.nr" + "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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/polynomial.nr" + "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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/safe.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr" } }, "expression_width": { "Bounded": { "width": 4 } } diff --git a/crates/zk-prover/tests/fixtures/sk_share_computation.json b/crates/zk-prover/tests/fixtures/sk_share_computation.json index ac6b12c70d..f92272b6cf 100644 --- a/crates/zk-prover/tests/fixtures/sk_share_computation.json +++ b/crates/zk-prover/tests/fixtures/sk_share_computation.json @@ -1,6 +1,6 @@ { "noir_version": "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", - "hash": "14473331163517012812", + "hash": "6797148543508543296", "abi": { "parameters": [ { "name": "expected_secret_commitment", "type": { "kind": "field" }, "visibility": "public" }, @@ -47,35 +47,35 @@ }, "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::dkg::{\n L_THRESHOLD, N, PARITY_MATRIX, SHARE_COMPUTATION_BIT_SHARE, SHARE_COMPUTATION_SK_BIT_SECRET,\n SHARE_COMPUTATION_SK_CONFIGS,\n};\nuse lib::configs::default::{N_PARTIES, T};\nuse lib::core::dkg::share_computation::SecretKeyShareComputation;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_secret_commitment: pub Field,\n sk_secret: Polynomial,\n y: [[[Field; N_PARTIES + 1]; L_THRESHOLD]; N],\n) -> pub [[Field; L_THRESHOLD]; N_PARTIES] {\n let sk_share_computation: SecretKeyShareComputation = SecretKeyShareComputation::new(\n SHARE_COMPUTATION_SK_CONFIGS,\n expected_secret_commitment,\n sk_secret,\n y,\n PARITY_MATRIX,\n );\n\n sk_share_computation.execute()\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/bin/dkg/sk_share_computation/src/main.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/dkg/sk_share_computation/src/main.nr" }, "63": { "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::{\n compute_share_computation_e_sm_commitment, compute_share_computation_sk_commitment,\n compute_share_encryption_commitment_from_shares,\n};\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Threshold secret share verification circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L]) -> Self {\n Configs { qis }\n }\n}\n\n/// Correct Threshold Secret Key Share Computation (Circuit 2a).\n///\n/// Verifies:\n/// 1. secret commitment: verify secret hashes to expected_secret_commitment\n/// 2. secret consistency: y[i][j][0] == sk_secret[i] for all i, j\n/// 3. Range check: shares are in [0, q_j)\n/// 4. Parity check: H[j] * y[i][j]^T == 0 mod q_j for all i, j\n///\n/// For SK: sk_secret is the trinary coefficients\npub struct SecretKeyShareComputation {\n configs: Configs,\n /// Expected commitment to secret (from C1)\n /// (public witness)\n expected_secret_commitment: Field,\n /// Secret key polynomial: Polynomial\n /// trinary coefficients\n /// (secret witness)\n sk_secret: Polynomial,\n /// Shares: y[coeff_idx][mod_idx][0..N_PARTIES+1]\n /// y[i][j][0] = sk_secret[i] = f(0), y[i][j][k] = f(k) for k = 1..N_PARTIES\n /// (secret witnesses)\n y: [[[Field; N_PARTIES + 1]; L]; N],\n /// Parity check matrices: H[mod_idx][row][col]\n /// Size per modulus: (N_PARTIES - T) * (N_PARTIES + 1)\n /// H * y^T = 0 mod q_j\n /// (public constants)\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n}\n\n/// Correct Threshold Smudging Noise Share Computation (Circuit 2b).\n///\n/// Verifies:\n/// 1. secret commitment: verify secret hashes to expected_secret_commitment\n/// 2. secret consistency: y[i][j][0] == e_sm[j][i] for all i, j\n/// 3. Range check: shares are in [0, q_j)\n/// 4. Parity check: H[j] * y[i][j]^T == 0 mod q_j for all i, j\n///\n/// For ESM: e_sm[j] is the RNS representation at modulus j\npub struct SmudgingNoiseShareComputation {\n configs: Configs,\n /// Expected commitment to secret (from C1)\n /// This is computed from all L RNS polynomials (matching\n /// multiple_polynomial_payload's behavior which hashes all L modulus polynomials)\n expected_secret_commitment: Field,\n /// Smudging noise polynomial per modulus: [Polynomial; L]\n /// For ESM: each modulus has its own polynomial (RNS representation)\n e_sm_secret: [Polynomial; L],\n /// Shares: y[coeff_idx][mod_idx][0..N_PARTIES+1]\n /// y[i][j][0] = e_sm[j][i] = f(0), y[i][j][k] = f(k) for k = 1..N_PARTIES\n y: [[[Field; N_PARTIES + 1]; L]; N],\n /// Parity check matrices: H[mod_idx][row][col]\n /// Size per modulus: (N_PARTIES - T) * (N_PARTIES + 1)\n /// H * y^T = 0 mod q_j\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n}\n\nimpl SecretKeyShareComputation {\n pub fn new(\n configs: Configs,\n expected_secret_commitment: Field,\n sk_secret: Polynomial,\n y: [[[Field; N_PARTIES + 1]; L]; N],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n ) -> Self {\n SecretKeyShareComputation { configs, expected_secret_commitment, sk_secret, y, h }\n }\n\n /// Main verification function\n pub fn execute(self) -> [[Field; L]; N_PARTIES] {\n // Step 1: Verify secret commitment matches expected\n self.verify_secret_commitment();\n\n // Step 2: Verify secret consistency\n self.verify_secret_consistency();\n\n // Step 3: Range checks\n check_range_bounds::(self.configs.qis, self.y);\n\n // Step 4: Verify parity check\n verify_parity_check::(self.configs.qis, self.h, self.y);\n\n // Step 5: Commit to shares for each party and modulus\n commit_to_party_shares::(self.y)\n }\n\n /// Verifies that secret hashes to expected_secret_commitment\n fn verify_secret_commitment(self) {\n assert(\n compute_share_computation_sk_commitment::(self.sk_secret)\n == self.expected_secret_commitment,\n \"SK commitment mismatch\",\n );\n }\n\n /// Verifies secret consistency: `y[i][j][0] == sk_secret[i]` for all i, j.\n ///\n /// This function ensures that for each coefficient i and CRT basis j, the share\n /// at party ID 0 equals the corresponding secret coefficient for that modulus.\n /// This is a fundamental property of Shamir secret sharing where the secret is the\n /// evaluation of the sharing polynomial at point 0.\n ///\n /// sk_secret is the trinary coefficients, so y[i][j][0] is the same for all j.\n ///\n /// # Panics\n /// The circuit will fail if secret consistency doesn't hold for any\n /// coefficient or CRT basis.\n fn verify_secret_consistency(self) {\n for coeff_idx in 0..N {\n let secret_coeff = self.sk_secret.coefficients[coeff_idx];\n\n for mod_idx in 0..L {\n assert(self.y[coeff_idx][mod_idx][0] == secret_coeff);\n }\n }\n }\n}\n\nimpl SmudgingNoiseShareComputation {\n pub fn new(\n configs: Configs,\n expected_secret_commitment: Field,\n e_sm_secret: [Polynomial; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n ) -> Self {\n SmudgingNoiseShareComputation { configs, expected_secret_commitment, e_sm_secret, y, h }\n }\n\n /// Main verification function\n pub fn execute(self) -> [[Field; L]; N_PARTIES] {\n // Step 1: Verify secret commitment matches expected\n self.verify_secret_commitment();\n\n // Step 2: Verify secret consistency\n self.verify_secret_consistency();\n\n // Step 3: Range checks\n check_range_bounds::(self.configs.qis, self.y);\n\n // Step 4: Verify parity check\n verify_parity_check::(self.configs.qis, self.h, self.y);\n\n // Step 5: Commit to shares for each party and modulus\n commit_to_party_shares::(self.y)\n }\n\n /// Verifies that secret hashes to expected_secret_commitment\n /// The commitment is computed over all L RNS polynomials (matching\n /// multiple_polynomial_payload's behavior which hashes all L modulus polynomials)\n fn verify_secret_commitment(self) {\n assert(\n compute_share_computation_e_sm_commitment::(self.e_sm_secret)\n == self.expected_secret_commitment,\n \"ESM commitment mismatch\",\n );\n }\n\n /// Verifies secret consistency: `y[i][j][0] == e_sm_secret[j][i]` for all i, j.\n ///\n /// This function ensures that for each coefficient i and CRT basis j, the share\n /// at party ID 0 equals the corresponding secret coefficient for that modulus.\n /// This is a fundamental property of Shamir secret sharing where the secret is the\n /// evaluation of the sharing polynomial at point 0.\n ///\n /// e_sm_secret[j] is the RNS representation at modulus j, so y[i][j][0] varies per modulus.\n ///\n /// # Panics\n /// The circuit will fail if secret consistency doesn't hold for any\n /// coefficient or CRT basis.\n fn verify_secret_consistency(self) {\n for coeff_idx in 0..N {\n for mod_idx in 0..L {\n let secret_coeff = self.e_sm_secret[mod_idx].coefficients[coeff_idx];\n assert(\n self.y[coeff_idx][mod_idx][0] == secret_coeff,\n \"Secret consistency check failed\",\n );\n }\n }\n }\n}\n\n/// Performs range checks on secret key and share values.\n///\n/// This function constrains all values to be within their expected bounds:\n/// - Share values for parties k >= 1 must be in [0, q_j) for each CRT modulus q_j\n///\n/// These bounds are critical for security and correctness of the Threshold scheme.\n///\n/// # Panics\n/// This function will cause the circuit to fail if any value is outside\n/// its expected bounds.\npub fn check_range_bounds(\n qis: [Field; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) {\n // Shares y[i][j][k] for k >= 1 should be in [0, q_j)\n for mod_idx in 0..L {\n let q_j = qis[mod_idx];\n\n for coeff_idx in 0..N {\n for party_idx in 1..(N_PARTIES + 1) {\n // Use range_check_standard from Polynomial by creating a single-coefficient polynomial\n Polynomial::new([y[coeff_idx][mod_idx][party_idx]])\n .range_check_standard::(q_j);\n }\n }\n }\n}\n\n/// Verifies Reed-Solomon parity check: `H[j] * y[i][j]^T == 0 mod q_j` for all i, j.\n///\n/// This function verifies that for each coefficient i and CRT basis j, the share\n/// vector `y[i][j]` forms a valid Reed-Solomon codeword by satisfying the parity\n/// check equation with the parity check matrix `H[j]`.\n///\n/// The parity check matrix H[j] has dimensions `(N_PARTIES - T) * (N_PARTIES + 1)`,\n/// and the share vector `y[i][j]` has length `N_PARTIES + 1`. The parity check\n/// ensures that any T+1 shares can correctly reconstruct the secret key via\n/// Lagrange interpolation.\n///\n/// # Panics\n/// The circuit will fail if the parity check doesn't hold for any coefficient,\n/// CRT basis, or parity check row.\npub fn verify_parity_check(\n qis: [Field; L],\n h: [[[Field; N_PARTIES + 1]; N_PARTIES - T]; L],\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) {\n for coeff_idx in 0..N {\n for mod_idx in 0..L {\n let q_j = qis[mod_idx];\n\n // For each row of H, compute dot product with y and verify == 0\n for row in 0..(N_PARTIES - T) {\n let mut sum: Field = 0;\n\n for col in 0..(N_PARTIES + 1) {\n sum = sum + h[mod_idx][row][col] * y[coeff_idx][mod_idx][col];\n }\n\n // Reduce mod q_j and verify == 0\n let m = ModU128::new(q_j);\n let result = m.reduce_mod(sum);\n assert(result == 0, \"Parity check failed\");\n }\n }\n }\n}\n\n/// Commits to shares for each party and modulus\n/// Returns [[Field; L]; N_PARTIES] where commitments[party_idx][mod_idx]\npub fn commit_to_party_shares(\n y: [[[Field; N_PARTIES + 1]; L]; N],\n) -> [[Field; L]; N_PARTIES] {\n let mut commitments: [[Field; L]; N_PARTIES] = [[0; L]; N_PARTIES];\n\n for party_idx in 0..N_PARTIES {\n for mod_idx in 0..L {\n commitments[party_idx][mod_idx] = compute_share_encryption_commitment_from_shares::(\n y,\n party_idx,\n mod_idx,\n );\n }\n }\n\n commitments\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/lib/src/core/dkg/share_computation.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/dkg/share_computation.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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/commitments.nr" + "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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/helpers.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/helpers.nr" }, "77": { "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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\n // 3 * 4 = 12 = 1 (mod 11), so 3^(-1) = 4 (mod 11)\n assert(result == 4);\n // Verify: 3 * result = 1 (mod 11)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n // 3^(-1) mod 11 = 4 (since 3 * 4 = 12 = 1 mod 11)\n // 7 * 4 = 28 = 6 (mod 11)\n assert(result == 6);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/modulo/U128.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/U128.nr" }, "79": { "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//! Unconstrained functions for modular u128 arithmetic.\n//!\n//! This module provides unconstrained functions that perform modular arithmetic\n//! computations without generating circuit constraints. These functions are used\n//! internally by the constrained operations in `U128` and should not be called\n//! directly in circuits without proper verification.\n\n/// Computes quotient and remainder for value modulo q (unconstrained).\n///\n/// This function performs integer division and modulo operations to compute\n/// `value = q * quotient + remainder` where `0 <= remainder < q`.\n///\n/// # Arguments\n/// * `value` - The value to reduce\n/// * `q` - The modulus\n///\n/// # Returns\n/// A tuple `(quotient, remainder)` where:\n/// - `quotient = value / q`\n/// - `remainder = value % q`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __compute_mod_reduction(value: Field, q: Field) -> (Field, Field) {\n let value_u128 = value as u128;\n let q_u128 = q as u128;\n\n let quotient_u128 = value_u128 / q_u128;\n let remainder_u128 = value_u128 % q_u128;\n\n (quotient_u128 as Field, remainder_u128 as Field)\n}\n\n/// Computes the negation of a value modulo m (unconstrained).\n///\n/// Returns `(m - val) mod m`, with special handling for zero (returns 0).\n///\n/// # Arguments\n/// * `val` - The value to negate\n/// * `m` - The modulus\n///\n/// # Returns\n/// The additive inverse `(-val) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __neg(val: Field, m: Field) -> Field {\n if val == 0 {\n 0\n } else {\n m - val\n }\n}\n\n/// Subtracts two values with underflow handling (unconstrained).\n///\n/// Computes `(lhs - rhs) mod m`, handling the case where `lhs < rhs` by adding\n/// the modulus. Returns both the result and a flag indicating if underflow occurred.\n///\n/// # Preconditions\n/// Inputs must be reduced modulo `m` such that `lhs, rhs in [0, m)`. This ensures\n/// that the computed difference is bounded and cannot overflow `u128`.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value (minuend), must be in `[0, m)`\n/// * `rhs` - Right-hand side value (subtrahend), must be in `[0, m)`\n/// * `m` - The modulus, must satisfy `m <= u128::MAX`\n///\n/// # Returns\n/// A tuple `(result, underflow)` where:\n/// - `result = (lhs - rhs) mod m`\n/// - `underflow = true` if `lhs < rhs`, `false` otherwise\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\n/// As long as inputs are reduced modulo `m` (and `m <= u128::MAX`), the subtraction-with-underflow\n/// logic is safe and will not overflow `u128`. This function is used by the constrained `sub` method\n/// in `modulo::U128`, which ensures inputs are properly reduced before calling `__sub_with_underflow`.\n/// See the surrounding `modulo/unconstrained_U128` module documentation for details.\npub unconstrained fn __sub_with_underflow(lhs: Field, rhs: Field, m: Field) -> (Field, bool) {\n let lhs_u128 = lhs as u128;\n let rhs_u128 = rhs as u128;\n let m_u128 = m as u128;\n\n let underflow = lhs_u128 < rhs_u128;\n let result = if underflow {\n // Compute (lhs - rhs + m) mod m safely to avoid u128 overflow\n // Since lhs < rhs, we compute: m - (rhs - lhs)\n // This avoids the potential overflow in lhs + m\n let diff = rhs_u128 - lhs_u128; // This is safe since rhs > lhs\n (m_u128 - diff) as Field\n } else {\n (lhs_u128 - rhs_u128) as Field\n };\n (result, underflow)\n}\n\n/// Multiplies two values and returns both quotient and remainder (unconstrained).\n///\n/// Computes `lhs * rhs = m * quotient + remainder` where `0 <= remainder < m`.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value\n/// * `rhs` - Right-hand side value\n/// * `m` - The modulus\n///\n/// # Returns\n/// A tuple `(quotient, remainder)` where `lhs * rhs = m * quotient + remainder`\n///\n/// # Overflow Warning\n/// Field multiplication wraps modulo the field prime (~254 bits). For two u128 values\n/// near 2^128, their product (up to 2^256) exceeds the Field modulus, causing silent\n/// wraparound before the mod reduction. This can produce incorrect results.\n///\n/// # Safe Input Range\n/// To avoid overflow, ensure `lhs * rhs < Field::MODULUS`. For typical use cases:\n/// - Party IDs, polynomial coefficients, and small cryptographic values (< 2^64) are safe\n/// - Arbitrary u128 values may overflow and should be validated by callers\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\n/// Callers must ensure inputs are within the safe range to prevent silent overflow.\npub unconstrained fn __mul_with_quotient(lhs: Field, rhs: Field, m: Field) -> (Field, Field) {\n // WARNING: Field multiplication can overflow for large inputs.\n // For u128 values near 2^128, the product (up to 2^256) exceeds Field modulus (~2^254),\n // causing wraparound. This is safe for typical use cases (party IDs, small coefficients),\n // but callers must validate input ranges for arbitrary u128 values.\n let product = lhs * rhs;\n __compute_mod_reduction(product, m)\n}\n\n/// Computes the modular multiplicative inverse using Fermat's Little Theorem (unconstrained).\n///\n/// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n/// using the identity: val^(-1) = val^(m-2) (mod m) (from Fermat's Little Theorem).\n///\n/// # Arguments\n/// * `val` - The value to invert (must be coprime with the modulus)\n/// * `m` - The modulus (should be prime for this method to work correctly)\n///\n/// # Returns\n/// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __inv_mod(val: Field, m: Field) -> Field {\n // by Fermat's Little Theorem: val^(m-1)= 1 mod m\n __pow_mod(val, m - 2, m)\n}\n\n/// Computes modular division: `lhs * rhs^(-1) mod m` (unconstrained).\n///\n/// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n///\n/// # Arguments\n/// * `lhs` - The numerator\n/// * `rhs` - The denominator (must be coprime with the modulus)\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `(lhs * rhs^(-1)) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __div_mod(lhs: Field, rhs: Field, m: Field) -> Field {\n let rhs_inv = __inv_mod(rhs, m);\n __mul_mod(lhs, rhs_inv, m)\n}\n\n/// Computes modular exponentiation: `base^exp mod m` (unconstrained).\n///\n/// Uses the binary exponentiation method (also known as square-and-multiply)\n/// for efficient computation of large powers.\n///\n/// # Arguments\n/// * `base` - The base value\n/// * `exp` - The exponent\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `base^exp mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __pow_mod(base: Field, exp: Field, m: Field) -> Field {\n let mut result = 1 as Field;\n let (_, base_mod) = __compute_mod_reduction(base, m);\n let mut current_base = base_mod;\n let mut e = exp as u128;\n\n while e > 0 {\n if (e % 2) == 1 {\n result = __mul_mod(result, current_base, m);\n }\n current_base = __mul_mod(current_base, current_base, m);\n e = e / 2;\n }\n\n result\n}\n\n/// Multiplies two values with modular reduction (unconstrained).\n///\n/// Computes `(lhs * rhs) mod m` and returns only the remainder.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value\n/// * `rhs` - Right-hand side value\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `(lhs * rhs) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __mul_mod(lhs: Field, rhs: Field, m: Field) -> Field {\n let (_, r) = __mul_with_quotient(lhs, rhs, m);\n r\n}\n\n// ------------------------------ TESTS ------------------------------\n// Note: All unsafe blocks in the following tests are safe because we are testing\n// unconstrained functions in a controlled test environment. These functions are\n// designed to be called from unsafe blocks or other unconstrained functions.\n// Each unsafe block is used to call an unconstrained function for testing purposes.\n\n#[test]\nfn test_compute_mod_reduction_simple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(42, 10) };\n assert(q == 4); // 42 / 10 = 4\n assert(r == 2); // 42 % 10 = 2\n // Verify: 42 = 10 * 4 + 2\n assert(10 * q + r == 42);\n}\n\n#[test]\nfn test_compute_mod_reduction_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(100, 10) };\n assert(q == 10); // 100 / 10 = 10\n assert(r == 0); // 100 % 10 = 0\n assert(10 * q + r == 100);\n}\n\n#[test]\nfn test_compute_mod_reduction_large_value() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(12345, 100) };\n assert(q == 123); // 12345 / 100 = 123\n assert(r == 45); // 12345 % 100 = 45\n assert(100 * q + r == 12345);\n}\n\n#[test]\nfn test_compute_mod_reduction_smaller_than_modulus() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(7, 10) };\n assert(q == 0); // 7 / 10 = 0\n assert(r == 7); // 7 % 10 = 7\n assert(10 * q + r == 7);\n}\n\n#[test]\nfn test_neg_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(0, 100) };\n assert(result == 0); // Negation of zero is zero\n}\n\n#[test]\nfn test_neg_non_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(30, 100) };\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_large_value() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(12345, 100000) };\n assert(result == 87655); // 100000 - 12345 = 87655\n}\n\n#[test]\nfn test_neg_verification() {\n let val: Field = 42;\n let m: Field = 97;\n // Safety: Test function calling unconstrained helper\n let neg_val = unsafe { __neg(val, m) };\n // Verify: val + neg_val = 0 (mod m)\n let sum = val + neg_val;\n // Safety: Test function calling unconstrained helper\n let (_, remainder) = unsafe { __compute_mod_reduction(sum, m) };\n assert(remainder == 0);\n}\n\n#[test]\nfn test_sub_with_underflow_no_underflow() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(50, 30, 100) };\n assert(underflow == false);\n assert(result == 20); // 50 - 30 = 20\n}\n\n#[test]\nfn test_sub_with_underflow_with_underflow() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(30, 50, 100) };\n assert(underflow == true);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_with_underflow_equal_values() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(42, 42, 100) };\n assert(underflow == false);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\n}\n\n#[test]\nfn test_mul_with_quotient_simple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(6, 7, 10) };\n assert(q == 4); // (6 * 7) / 10 = 42 / 10 = 4\n assert(r == 2); // (6 * 7) % 10 = 42 % 10 = 2\n // Verify: 6 * 7 = 10 * 4 + 2\n assert(6 * 7 == 10 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(12, 15, 100) };\n assert(q == 1); // (12 * 15) / 100 = 180 / 100 = 1\n assert(r == 80); // (12 * 15) % 100 = 180 % 100 = 80\n assert(12 * 15 == 100 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(5, 20, 100) };\n assert(q == 1); // (5 * 20) / 100 = 100 / 100 = 1\n assert(r == 0); // (5 * 20) % 100 = 100 % 100 = 0\n assert(5 * 20 == 100 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_verification() {\n let lhs: Field = 123;\n let rhs: Field = 456;\n let m: Field = 1000;\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(lhs, rhs, m) };\n // Verify: lhs * rhs = m * q + r\n assert(lhs * rhs == m * q + r);\n // Verify remainder is in range [0, m)\n assert((r as u128) < (m as u128));\n}\n\n#[test]\nfn test_mul_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(6, 7, 10) };\n assert(result == 2); // (6 * 7) mod 10 = 42 mod 10 = 2\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(12, 15, 100) };\n assert(result == 80); // (12 * 15) mod 100 = 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(5, 20, 100) };\n assert(result == 0); // (5 * 20) mod 100 = 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(42, 0, 100) };\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_commutative() {\n let a: Field = 7;\n let b: Field = 9;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let mul_a_b = unsafe { __mul_mod(a, b, m) };\n // Safety: Test function calling unconstrained helper\n let mul_b_a = unsafe { __mul_mod(b, a, m) };\n // Verify: a * b = b * a\n assert(mul_a_b == mul_b_a);\n}\n\n#[test]\nfn test_pow_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(2, 3, 10) };\n assert(result == 8); // 2^3 mod 10 = 8 mod 10 = 8\n}\n\n#[test]\nfn test_pow_mod_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(2, 10, 100) };\n assert(result == 24); // 2^10 = 1024, 1024 mod 100 = 24\n}\n\n#[test]\nfn test_pow_mod_exponent_one() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(7, 1, 100) };\n assert(result == 7); // 7^1 mod 100 = 7\n}\n\n#[test]\nfn test_pow_mod_exponent_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(7, 0, 100) };\n assert(result == 1); // 7^0 mod 100 = 1\n}\n\n#[test]\nfn test_pow_mod_base_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(0, 5, 100) };\n assert(result == 0); // 0^5 mod 100 = 0\n}\n\n#[test]\nfn test_pow_mod_large_exponent() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(3, 7, 97) };\n // 3^7 = 2187, 2187 mod 97 = 53\n assert(result == 53);\n}\n\n#[test]\nfn test_pow_mod_fermat_little_theorem() {\n // For prime modulus p and value a, a^(p-1) = 1 (mod p)\n let a: Field = 3;\n let p: Field = 11; // Prime\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(a, p - 1, p) };\n assert(result == 1);\n}\n\n#[test]\nfn test_inv_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(3, 11) };\n // 3 * 4 = 12 = 1 (mod 11), so 3^(-1) = 4 (mod 11)\n assert(result == 4);\n // Verify: 3 * result = 1 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(3, result, 11) } == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(7, 13) };\n // Verify: 7 * result = 1 (mod 13)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(7, result, 13) } == 1);\n}\n\n#[test]\nfn test_inv_mod_another_prime() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(5, 17) };\n // Verify: 5 * result = 1 (mod 17)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(5, result, 17) } == 1);\n}\n\n#[test]\nfn test_inv_mod_inverse_of_inverse() {\n let a: Field = 7;\n let m: Field = 11;\n // Safety: Test function calling unconstrained helper\n let inv_a = unsafe { __inv_mod(a, m) };\n // Safety: Test function calling unconstrained helper\n let inv_inv_a = unsafe { __inv_mod(inv_a, m) };\n // (a^(-1))^(-1) = a\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_div_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(6, 2, 11) };\n assert(result == 3); // 6 / 2 = 3\n // Verify: result * 2 = 6 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 2, 11) } == 6);\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(7, 3, 11) };\n // 3^(-1) mod 11 = 4 (since 3 * 4 = 12 = 1 mod 11)\n // 7 * 4 = 28 = 6 (mod 11)\n assert(result == 6);\n // Verify: result * 3 = 7 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 3, 11) } == 7);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a: Field = 10;\n let b: Field = 3;\n let m: Field = 17;\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(a, b, m) };\n // Verify: result * b = a (mod m)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, b, m) } == a);\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a: Field = 250;\n let b: Field = 7;\n let m: Field = 97;\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(a, b, m) };\n // Verify: result * b = a (mod m)\n // Safety: Test function calling unconstrained helper\n let (_, a_reduced) = unsafe { __compute_mod_reduction(a, m) }; // 250 mod 97 = 56\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, b, m) } == a_reduced);\n}\n\n#[test]\nfn test_div_mod_by_one() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(42, 1, 100) };\n assert(result == 42); // 42 / 1 = 42\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 1, 100) } == 42);\n}\n\n#[test]\nfn test_all_operations_consistency() {\n // Test that all operations work together correctly\n let m: Field = 97; // Prime\n let a: Field = 42;\n let b: Field = 13;\n\n // Test: (a + b) mod m\n let sum = a + b;\n // Safety: Test function calling unconstrained helper\n let (_, sum_reduced) = unsafe { __compute_mod_reduction(sum, m) };\n assert(sum_reduced == 55);\n\n // Test: (a - b) mod m using subtraction\n // Safety: Test function calling unconstrained helper\n let (diff, _) = unsafe { __sub_with_underflow(a, b, m) };\n assert(diff == 29);\n\n // Test: (a * b) mod m\n // Safety: Test function calling unconstrained helper\n let prod = unsafe { __mul_mod(a, b, m) };\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test: b^(-1) mod m\n // Safety: Test function calling unconstrained helper\n let inv = unsafe { __inv_mod(b, m) };\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(b, inv, m) } == 1);\n\n // Test: (a / b) mod m\n // Safety: Test function calling unconstrained helper\n let quot = unsafe { __div_mod(a, b, m) };\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(quot, b, m) } == a);\n\n // Test: (-a) mod m\n // Safety: Test function calling unconstrained helper\n let neg = unsafe { __neg(a, m) };\n let sum_neg = a + neg;\n // Safety: Test function calling unconstrained helper\n let (_, sum_neg_reduced) = unsafe { __compute_mod_reduction(sum_neg, m) };\n assert(sum_neg_reduced == 0);\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/unconstrained_U128.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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/polynomial.nr" + "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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/safe.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr" } }, "expression_width": { "Bounded": { "width": 4 } } diff --git a/crates/zk-prover/tests/fixtures/sk_share_encryption.json b/crates/zk-prover/tests/fixtures/sk_share_encryption.json index e7db7f5e45..70af42e495 100644 --- a/crates/zk-prover/tests/fixtures/sk_share_encryption.json +++ b/crates/zk-prover/tests/fixtures/sk_share_encryption.json @@ -193,35 +193,35 @@ }, "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::dkg::{\n DKG_SHARE_ENCRYPTION_BIT_CT, DKG_SHARE_ENCRYPTION_BIT_E0, DKG_SHARE_ENCRYPTION_BIT_E1,\n DKG_SHARE_ENCRYPTION_BIT_MSG, DKG_SHARE_ENCRYPTION_BIT_P1, DKG_SHARE_ENCRYPTION_BIT_P2,\n DKG_SHARE_ENCRYPTION_BIT_PK, DKG_SHARE_ENCRYPTION_BIT_R1, DKG_SHARE_ENCRYPTION_BIT_R2,\n DKG_SHARE_ENCRYPTION_BIT_U, DKG_SHARE_ENCRYPTION_CONFIGS, L, N,\n};\nuse lib::core::dkg::share_encryption::ShareEncryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_pk_commitment: pub Field,\n expected_message_commitment: pub Field,\n pk0is: [Polynomial; L],\n pk1is: [Polynomial; L],\n ct0is: pub [Polynomial; L],\n ct1is: pub [Polynomial; L],\n u: Polynomial,\n e0: Polynomial,\n e0is: [Polynomial; L],\n e0_quotients: [Polynomial; L],\n e1: Polynomial,\n message: 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 share_encryption: ShareEncryption = ShareEncryption::new(\n DKG_SHARE_ENCRYPTION_CONFIGS,\n expected_pk_commitment,\n expected_message_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n message,\n r1is,\n r2is,\n p1is,\n p2is,\n );\n share_encryption.execute();\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/bin/dkg/sk_share_encryption/src/main.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/dkg/share_encryption/src/main.nr" }, "65": { "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_dkg_pk_commitment;\nuse crate::math::commitments::{\n compute_share_encryption_challenge, compute_share_encryption_commitment_from_message,\n};\nuse crate::math::helpers::flatten;\nuse crate::math::modulo::U128::ModU128;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for DKG share encryption circuit.\npub struct Configs {\n /// Plaintext modulus t\n pub t: Field,\n /// Q mod t (for scaling message)\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 /// 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 /// Bound for message polynomial (m)\n pub msg_bound: Field,\n}\n\nimpl Configs {\n pub fn new(\n t: Field,\n q_mod_t: 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 msg_bound: Field,\n ) -> Self {\n Configs {\n t,\n q_mod_t,\n qis,\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 msg_bound,\n }\n }\n}\n\n/// DKG Share Encryption Circuit (Circuit 3).\n///\n/// Verifies:\n/// 1. Public key commitment matches expected (from Circuit 0)\n/// 2. Message commitment matches expected (from SK shares circuit)\n/// 3. Correct DKG share encryption: ct0[l] = pk0[l] * u + e0[l] + k1 * k0[l] + r1[l] * q[l] + r2[l] * (X^N + 1)\n/// and ct1[l] = pk1[l] * u + e1 + p2[l] * (X^N + 1) + p1[l] * q[l]\npub struct ShareEncryption {\n /// Circuit parameters\n configs: Configs,\n /// Expected commitment to public key (from Circuit 0)\n /// (public witness)\n expected_pk_commitment: Field,\n /// Expected commitment to message (from SK shares verification circuit)\n /// (public witness)\n expected_message_commitment: Field,\n /// Public key component 0 for each CRT basis (committed witnesses)\n pk0is: [Polynomial; L],\n /// Public key component 1 for each CRT basis (committed witnesses)\n pk1is: [Polynomial; L],\n /// Ciphertext component 0 for each CRT basis (public witnesses)\n ct0is: [Polynomial; L],\n /// Ciphertext component 1 for each CRT basis (public witnesses)\n ct1is: [Polynomial; L],\n /// Random ternary polynomial u (secret witness)\n u: Polynomial,\n /// Error polynomial e0 (secret witness)\n e0: Polynomial,\n /// Per-basis error polynomials e0[l] (secret witnesses)\n e0is: [Polynomial; L],\n /// CRT quotients for e0 (secret witnesses)\n e0_quotients: [Polynomial; L],\n /// Error polynomial e1 (secret witness)\n e1: Polynomial,\n /// Raw message polynomial (secret witness)\n message: Polynomial,\n /// Modulus switching quotient polynomials r1 (secret witnesses, degree 2N-1)\n r1is: [Polynomial<(2 * N) - 1>; L],\n /// Cyclotomic reduction quotient polynomials r2 (secret witnesses, degree N-1)\n r2is: [Polynomial; L],\n /// Modulus switching quotient polynomials p1 (secret witnesses, degree 2N-1)\n p1is: [Polynomial<(2 * N) - 1>; L],\n /// Cyclotomic reduction quotient polynomials p2 (secret witnesses, degree N-1)\n p2is: [Polynomial; L],\n}\n\nimpl ShareEncryption {\n pub fn new(\n configs: Configs,\n expected_pk_commitment: Field,\n expected_message_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 message: Polynomial,\n r1is: [Polynomial<2 * N - 1>; L],\n r2is: [Polynomial; L],\n p1is: [Polynomial<2 * N - 1>; L],\n p2is: [Polynomial; L],\n ) -> Self {\n ShareEncryption {\n configs,\n expected_pk_commitment,\n expected_message_commitment,\n pk0is,\n pk1is,\n ct0is,\n ct1is,\n u,\n e0,\n e0is,\n e0_quotients,\n e1,\n message,\n r1is,\n r2is,\n p1is,\n p2is,\n }\n }\n\n /// Verifies that the public key hashes to the expected commitment\n fn verify_pk_commitment(self) {\n assert(\n compute_dkg_pk_commitment::(self.pk0is, self.pk1is)\n == self.expected_pk_commitment,\n \"Public key commitment mismatch\",\n );\n }\n\n /// Verifies that the message polynomial hashes to the expected commitment\n fn verify_message_commitment(self) {\n assert(\n compute_share_encryption_commitment_from_message::(self.message)\n == self.expected_message_commitment,\n \"Message commitment mismatch\",\n );\n }\n\n /// Computes the scaled message k1 from the raw message in centered form\n /// k1[i] = (q_mod_t * message[i]) mod t, centered to [-t/2, t/2)\n fn compute_scaled_message(self) -> Polynomial {\n let t = self.configs.t;\n let t_mod = ModU128::new(t);\n let q_mod_t: Field = self.configs.q_mod_t;\n let mut k1_coeffs: [Field; N] = [0; N];\n\n // Integer division for t_half\n let t_half: u128 = (t as u128) / 2;\n\n for i in 0..N {\n let msg_i: Field = self.message.coefficients[i];\n let q_times_m_mod_t = t_mod.mul_mod(q_mod_t, msg_i);\n\n // Check if centering is needed (value > t/2 means negative in centered form)\n let needs_centering = (q_times_m_mod_t as u128) > t_half;\n\n k1_coeffs[i] = if needs_centering {\n // Value is in (t/2, t), negative in centered form\n // Represent as P - magnitude (i.e., 0 - magnitude in Field)\n let magnitude = t - q_times_m_mod_t;\n 0 - magnitude\n } else {\n // Value is in [0, t/2], stays positive\n q_times_m_mod_t\n };\n }\n\n Polynomial { coefficients: k1_coeffs }\n }\n\n /// Flattens all polynomial coefficients into a single array for Fiat-Shamir challenge generation\n fn payload(self, k1: Polynomial) -> Vec {\n let mut inputs = Vec::new();\n\n // Use pk commitment instead of full pk polynomials\n inputs.push(self.expected_pk_commitment);\n\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct0is);\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct1is);\n\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\n // Use message commitment instead of full message\n inputs.push(self.expected_message_commitment);\n\n // Include computed k1 in payload\n for i in 0..N {\n inputs.push(k1.coefficients[i]);\n }\n\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 the e0 error polynomial\n fn check_e0_crt_consistency(self) {\n for i in 0..L {\n for j in 0..N {\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 /// Main verification function\n pub fn execute(self) {\n // Step 1: Verify public key commitment matches expected\n self.verify_pk_commitment();\n\n // Step 2: Verify message commitment matches expected\n self.verify_message_commitment();\n\n // Step 3: Perform range checks\n self.check_range_bounds();\n\n // Step 4: Check CRT consistency for e0\n self.check_e0_crt_consistency();\n\n // Step 5: Compute scaled message k1 from message\n let k1 = self.compute_scaled_message();\n\n // Step 6: Generate Fiat-Shamir challenges\n let gammas = self.generate_challenge(k1);\n\n // Step 7: Verify encryption constraints\n self.verify_evaluations(gammas, k1)\n }\n\n /// Performs range checks on all secret witness polynomial coefficients\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\n // Message should be in [0, t)\n self.message.range_check_standard::(self.configs.msg_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 fn generate_challenge(self, k1: Polynomial) -> Vec {\n let inputs = self.payload(k1);\n\n compute_share_encryption_challenge::(inputs)\n }\n\n /// Verifies DKG encryption constraints using Fiat-Shamir challenges and the Schwartz-Zippel lemma\n fn verify_evaluations(self, gammas: Vec, k1: Polynomial) {\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 = 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 // Verify ct0 equation: ct0[i] = pk0[i]*u + e0[i] + k1*k0[i] + r1[i]*q[i] + r2[i]*cyclo\n let mut ct0_rhs = (pk0is_at_gamma * u_at_gamma) + e0is_at_gamma;\n ct0_rhs += 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\n // Verify ct1 equation: ct1[i] = pk1[i]*u + e1 + p2[i]*cyclo + p1[i]*q[i]\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 mut ct1_rhs = (pk1is_at_gamma * u_at_gamma) + e1_at_gamma;\n ct1_rhs += 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\n // Accumulate weighted sums for batch verification\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 assert(sum.0 == sum.1);\n }\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/lib/src/core/dkg/share_encryption.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/dkg/share_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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/commitments.nr" + "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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/helpers.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/helpers.nr" }, "77": { "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//! Constrained modular arithmetic operations for u128 values.\n//!\n//! This module provides a `ModU128` struct that implements modular arithmetic operations\n//! with full constraint generation for zero-knowledge proof circuits. All operations\n//! are verified in-circuit to ensure correctness.\nuse super::unconstrained_U128::{\n __compute_mod_reduction, __div_mod, __inv_mod, __neg, __sub_with_underflow,\n};\n\n/// Modular arithmetic context for u128 values.\n///\n/// This struct holds a modulus and provides methods for performing modular arithmetic\n/// operations with full constraint generation. All operations are verified in-circuit.\n///\n/// # Generic Parameters\n///\n/// The operations work with `Field` values, but are designed for u128-sized integers.\n/// The modulus must be a positive value less than 2^128.\npub struct ModU128 {\n /// The modulus for all operations\n pub m: Field,\n}\n\nimpl ModU128 {\n /// Creates a new modular arithmetic context with the given modulus.\n ///\n /// # Arguments\n /// * `m` - The modulus for all operations. Must be positive.\n ///\n /// # Returns\n /// A new `ModU128` instance configured with the specified modulus.\n pub fn new(m: Field) -> Self {\n ModU128 { m }\n }\n\n /// Returns the modulus as a Field value.\n ///\n /// # Returns\n /// The modulus value used by this context.\n pub fn get_mod_field(self) -> Field {\n self.m\n }\n\n /// Reduces a value modulo the modulus.\n ///\n /// Computes `n mod m` and returns the result in the range [0, m).\n /// This operation is fully constrained and verified in-circuit.\n ///\n /// # Arguments\n /// * `n` - The value to reduce\n ///\n /// # Returns\n /// The value `n mod m` in the range [0, m)\n ///\n /// # Panics\n /// The circuit will fail if the reduction is incorrect.\n pub fn reduce_mod(self, n: Field) -> Field {\n // Safety: __compute_mod_reduction is safe to call here because we assert the properties of the output\n let (q, r) = unsafe { __compute_mod_reduction(n, self.m) };\n\n // Ensure remainder is in [0, m)\n assert(r as u128 < self.m as u128);\n // Verify the reduction is correct\n assert(n == q * self.m + r);\n\n r\n }\n\n /// Adds two values with modular reduction.\n ///\n /// Computes `(lhs + rhs) mod m` and returns the result.\n /// Handles overflow correctly by reducing modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs + rhs) mod m`\n pub fn add(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs + rhs)\n }\n\n /// Subtracts two values with modular reduction.\n ///\n /// Computes `(lhs - rhs) mod m` and returns the result.\n /// Handles underflow correctly by adding the modulus when needed.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value (minuend)\n /// * `rhs` - Right-hand side value (subtrahend)\n ///\n /// # Returns\n /// The result of `(lhs - rhs) mod m`\n pub fn sub(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __sub_with_underflow is safe because we verify the subtraction equation below\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, self.m) };\n\n // Verify the subtraction\n if underflow {\n assert(lhs + self.m == rhs + result, \"Subtraction with underflow verification failed\");\n } else {\n assert(lhs == rhs + result, \"Subtraction verification failed\");\n }\n\n result\n }\n\n /// Multiplies two values with modular reduction.\n ///\n /// Computes `(lhs * rhs) mod m` and returns the result.\n /// The product is computed first, then reduced modulo the modulus.\n ///\n /// # Arguments\n /// * `lhs` - Left-hand side value\n /// * `rhs` - Right-hand side value\n ///\n /// # Returns\n /// The result of `(lhs * rhs) mod m`\n pub fn mul_mod(self, lhs: Field, rhs: Field) -> Field {\n self.reduce_mod(lhs * rhs)\n }\n\n /// Computes modular division: `lhs * rhs^(-1) mod m`.\n ///\n /// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n /// The result satisfies: `(result * rhs) mod m = lhs mod m`.\n ///\n /// # Arguments\n /// * `lhs` - The numerator\n /// * `rhs` - The denominator (must be coprime with the modulus)\n ///\n /// # Returns\n /// The result of `(lhs * rhs^(-1)) mod m`\n ///\n /// # Panics\n /// The circuit will fail if `rhs` is not invertible modulo `m` (i.e., if\n /// `gcd(rhs, m) != 1`). For prime moduli, any non-zero `rhs` is invertible.\n pub fn div_mod(self, lhs: Field, rhs: Field) -> Field {\n // Safety: __div_mod is safe because we verify result * rhs = lhs (mod m) below\n let result = unsafe { __div_mod(lhs, rhs, self.m) };\n\n // Verify: (result * rhs) mod m == lhs mod m\n assert(\n self.mul_mod(result, rhs) == self.reduce_mod(lhs),\n \"Division verification failed: result * rhs ≠ lhs (mod m)\",\n );\n\n result\n }\n\n /// Negates a value modulo m.\n ///\n /// Computes the additive inverse: `(-val) mod m = (m - val) mod m`.\n /// Special case: negation of zero is zero.\n ///\n /// # Arguments\n /// * `val` - The value to negate\n ///\n /// # Returns\n /// The result of `(-val) mod m`, which satisfies `(val + result) mod m = 0`\n pub fn neg(self, val: Field) -> Field {\n // Safety: __neg is safe because we verify val + result = 0 (mod m) below\n let result = unsafe { __neg(val, self.m) };\n\n // Verify: val + result = 0 (mod m)\n // Special case: if val = 0, result should be 0\n if val == 0 {\n assert(result == 0, \"Negation of zero should be zero\");\n } else {\n assert(val + result == self.m, \"Negation verification failed\");\n }\n\n result\n }\n\n /// Computes the modular multiplicative inverse using Fermat's Little Theorem.\n ///\n /// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n /// such that `(val * result) mod m = 1`.\n ///\n /// The implementation uses Fermat's Little Theorem: `val^(m-1) = 1 (mod m)`,\n /// so `val^(-1) = val^(m-2) (mod m)`.\n ///\n /// # Arguments\n /// * `val` - The value to invert (must be coprime with the modulus)\n ///\n /// # Returns\n /// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n ///\n /// # Panics\n /// The circuit will fail if `val` is not invertible modulo `m` (i.e., if\n /// `gcd(val, m) != 1`). For prime moduli, any non-zero `val` is invertible.\n pub fn inv_mod(self, val: Field) -> Field {\n // Safety: __inv_mod is safe because we verify val * result = 1 (mod m) below\n let result = unsafe { __inv_mod(val, self.m) };\n\n // Verify: val * result = 1 (mod m)\n assert(self.mul_mod(val, result) == 1, \"Inverse verification failed\");\n\n result\n }\n}\n\n#[test]\nfn test_reduce_mod_already_reduced() {\n let value = 42;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 42);\n}\n\n#[test]\nfn test_reduce_mod_needs_reduction() {\n let value = 250;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 50);\n}\n\n#[test]\nfn test_reduce_mod_exact_multiple() {\n let value = 300;\n let m = ModU128::new(100);\n let result = m.reduce_mod(value);\n assert(result == 0);\n}\n\n#[test]\nfn test_reduce_mod_large_value() {\n let value = 123456789;\n let m = ModU128::new(1000);\n let result = m.reduce_mod(value);\n assert(result == 789);\n}\n\n#[test]\nfn test_add_no_overflow() {\n let a = 30;\n let b = 40;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 70);\n}\n\n#[test]\nfn test_add_with_overflow() {\n let a = 60;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 10); // (60 + 50) mod 100 = 10\n}\n\n#[test]\nfn test_add_exact_modulus() {\n let a = 50;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_add_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.add(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_sub_no_underflow() {\n let a = 50;\n let b = 30;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 20);\n}\n\n#[test]\nfn test_sub_with_underflow() {\n let a = 30;\n let b = 50;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_equal_values() {\n let a = 42;\n let b = 42;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_subtract_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.sub(a, b);\n assert(result == 42);\n}\n#[test]\nfn test_mul_mod_small_values() {\n let a = 6;\n let b = 7;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 42);\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n let a = 12;\n let b = 15;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 80); // 12 * 15 = 180, 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_result_zero() {\n let a = 5;\n let b = 20;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0); // 5 * 20 = 100, 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n let a = 42;\n let b = 0;\n let m = ModU128::new(100);\n let result = m.mul_mod(a, b);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_large_values() {\n let a = 123;\n let b = 456;\n let m = ModU128::new(1000);\n let result = m.mul_mod(a, b);\n assert(result == 88); // 123 * 456 = 56088, 56088 mod 1000 = 88\n}\n\n#[test]\nfn test_neg_non_zero() {\n let val = 30;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_zero() {\n let val = 0;\n let m = ModU128::new(100);\n let result = m.neg(val);\n assert(result == 0); // Negation of 0 is 0, not m\n}\n\n#[test]\nfn test_neg_large_modulus() {\n let val = 12345;\n let m = ModU128::new(1000000);\n let result = m.neg(val);\n assert(result == 987655); // 1000000 - 12345 = 987655\n}\n\n#[test]\nfn test_inv_mod_simple() {\n let val = 3;\n let m = ModU128::new(11);\n let result = m.inv_mod(val);\n // 3 * 4 = 12 = 1 (mod 11), so 3^(-1) = 4 (mod 11)\n assert(result == 4);\n // Verify: 3 * result = 1 (mod 11)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n let val = 7;\n let m = ModU128::new(13);\n let result = m.inv_mod(val);\n // Verify: 7 * result = 1 (mod 13)\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_inv_mod_with_result_verification() {\n let val = 5;\n let m = ModU128::new(17);\n let result = m.inv_mod(val);\n // Verify the inverse property\n let product = m.mul_mod(val, result);\n assert(product == 1);\n}\n\n#[test]\nfn test_inv_mod_coprime_values() {\n let val = 9;\n let m = ModU128::new(23);\n let result = m.inv_mod(val);\n assert(m.mul_mod(val, result) == 1);\n}\n\n#[test]\nfn test_div_mod_simple() {\n let a = 6;\n let b = 2;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n assert(result == 3); // 6 / 2 = 3\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n let a = 7;\n let b = 3;\n let m = ModU128::new(11);\n let result = m.div_mod(a, b);\n // 3^(-1) mod 11 = 4 (since 3 * 4 = 12 = 1 mod 11)\n // 7 * 4 = 28 = 6 (mod 11)\n assert(result == 6);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == a);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a = 10;\n let b = 3;\n let m = ModU128::new(17);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n assert(m.mul_mod(result, b) == m.reduce_mod(a));\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a = 250;\n let b = 7;\n let m = ModU128::new(97);\n let result = m.div_mod(a, b);\n // Verify: result * b = a (mod m)\n let a_reduced = m.reduce_mod(a); // 250 mod 100 = 50\n assert(m.mul_mod(result, b) == a_reduced);\n}\n\n#[test]\nfn test_reduce_mod_function() {\n let m = ModU128::new(7);\n\n // Test reduce_mod directly first\n assert(m.reduce_mod(38) == 3);\n assert(m.reduce_mod(6) == 6);\n assert(m.reduce_mod(7) == 0);\n assert(m.reduce_mod(14) == 0);\n}\n\n#[test]\nfn test_field_properties_additive_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a + 0 = a\n assert(m.add(a, 0) == a);\n}\n\n#[test]\nfn test_field_properties_multiplicative_identity() {\n let a = 42;\n let m = ModU128::new(100);\n // a * 1 = a\n assert(m.mul_mod(a, 1) == a);\n}\n\n#[test]\nfn test_field_properties_additive_inverse() {\n let a = 42;\n let m = ModU128::new(100);\n let neg_a = m.sub(0, a);\n // a + (-a) = 0\n assert(m.add(a, neg_a) == 0);\n}\n\n#[test]\nfn test_field_properties_commutativity_add() {\n let a = 35;\n let b = 47;\n let m = ModU128::new(100);\n // a + b = b + a\n assert(m.add(a, b) == m.add(b, a));\n}\n\n#[test]\nfn test_field_properties_commutativity_mul() {\n let a = 7;\n let b = 9;\n let m = ModU128::new(100);\n // a * b = b * a\n assert(m.mul_mod(a, b) == m.mul_mod(b, a));\n}\n\n#[test]\nfn test_field_properties_associativity_add() {\n let a = 23;\n let b = 34;\n let c = 45;\n let m = ModU128::new(100);\n // (a + b) + c = a + (b + c)\n let left = m.add(m.add(a, b), c);\n let right = m.add(a, m.add(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_associativity_mul() {\n let a = 3;\n let b = 7;\n let c = 11;\n let m = ModU128::new(100);\n // (a * b) * c = a * (b * c)\n let left = m.mul_mod(m.mul_mod(a, b), c);\n let right = m.mul_mod(a, m.mul_mod(b, c));\n assert(left == right);\n}\n\n#[test]\nfn test_field_properties_distributivity() {\n let a = 5;\n let b = 7;\n let c = 9;\n let m = ModU128::new(100);\n // a * (b + c) = (a * b) + (a * c)\n let left = m.mul_mod(a, m.add(b, c));\n let right = m.add(m.mul_mod(a, b), m.mul_mod(a, c));\n assert(left == right);\n}\n#[test]\nfn test_division_multiplication_inverse() {\n let a = 35;\n let b = 7;\n let m = ModU128::new(97);\n let quotient = m.div_mod(a, b);\n let product = m.mul_mod(quotient, b);\n assert(product == m.reduce_mod(a));\n}\n\n#[test]\nfn test_inverse_of_inverse() {\n let a = 7;\n let m = ModU128::new(11);\n // (a^(-1))^(-1) = a\n let inv_a = m.inv_mod(a);\n let inv_inv_a = m.inv_mod(inv_a);\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_operations_with_prime_modulus() {\n let m = ModU128::new(97); // Prime number\n let a = 42;\n let b = 13;\n\n // Test addition\n let sum = m.add(a, b);\n assert(sum == 55); // 42 + 13 = 55\n\n // Test subtraction\n let diff = m.sub(a, b);\n assert(diff == 29); // 42 - 13 = 29\n\n // Test multiplication\n let prod = m.mul_mod(a, b);\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test inverse: b * b^(-1) = 1 (mod m)\n let inv = m.inv_mod(b);\n assert(m.mul_mod(b, inv) == 1);\n\n // Test division: (a / b) * b = a (mod m)\n let quot = m.div_mod(a, b);\n assert(m.mul_mod(quot, b) == a);\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/modulo/U128.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/U128.nr" }, "79": { "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//! Unconstrained functions for modular u128 arithmetic.\n//!\n//! This module provides unconstrained functions that perform modular arithmetic\n//! computations without generating circuit constraints. These functions are used\n//! internally by the constrained operations in `U128` and should not be called\n//! directly in circuits without proper verification.\n\n/// Computes quotient and remainder for value modulo q (unconstrained).\n///\n/// This function performs integer division and modulo operations to compute\n/// `value = q * quotient + remainder` where `0 <= remainder < q`.\n///\n/// # Arguments\n/// * `value` - The value to reduce\n/// * `q` - The modulus\n///\n/// # Returns\n/// A tuple `(quotient, remainder)` where:\n/// - `quotient = value / q`\n/// - `remainder = value % q`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __compute_mod_reduction(value: Field, q: Field) -> (Field, Field) {\n let value_u128 = value as u128;\n let q_u128 = q as u128;\n\n let quotient_u128 = value_u128 / q_u128;\n let remainder_u128 = value_u128 % q_u128;\n\n (quotient_u128 as Field, remainder_u128 as Field)\n}\n\n/// Computes the negation of a value modulo m (unconstrained).\n///\n/// Returns `(m - val) mod m`, with special handling for zero (returns 0).\n///\n/// # Arguments\n/// * `val` - The value to negate\n/// * `m` - The modulus\n///\n/// # Returns\n/// The additive inverse `(-val) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __neg(val: Field, m: Field) -> Field {\n if val == 0 {\n 0\n } else {\n m - val\n }\n}\n\n/// Subtracts two values with underflow handling (unconstrained).\n///\n/// Computes `(lhs - rhs) mod m`, handling the case where `lhs < rhs` by adding\n/// the modulus. Returns both the result and a flag indicating if underflow occurred.\n///\n/// # Preconditions\n/// Inputs must be reduced modulo `m` such that `lhs, rhs in [0, m)`. This ensures\n/// that the computed difference is bounded and cannot overflow `u128`.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value (minuend), must be in `[0, m)`\n/// * `rhs` - Right-hand side value (subtrahend), must be in `[0, m)`\n/// * `m` - The modulus, must satisfy `m <= u128::MAX`\n///\n/// # Returns\n/// A tuple `(result, underflow)` where:\n/// - `result = (lhs - rhs) mod m`\n/// - `underflow = true` if `lhs < rhs`, `false` otherwise\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\n/// As long as inputs are reduced modulo `m` (and `m <= u128::MAX`), the subtraction-with-underflow\n/// logic is safe and will not overflow `u128`. This function is used by the constrained `sub` method\n/// in `modulo::U128`, which ensures inputs are properly reduced before calling `__sub_with_underflow`.\n/// See the surrounding `modulo/unconstrained_U128` module documentation for details.\npub unconstrained fn __sub_with_underflow(lhs: Field, rhs: Field, m: Field) -> (Field, bool) {\n let lhs_u128 = lhs as u128;\n let rhs_u128 = rhs as u128;\n let m_u128 = m as u128;\n\n let underflow = lhs_u128 < rhs_u128;\n let result = if underflow {\n // Compute (lhs - rhs + m) mod m safely to avoid u128 overflow\n // Since lhs < rhs, we compute: m - (rhs - lhs)\n // This avoids the potential overflow in lhs + m\n let diff = rhs_u128 - lhs_u128; // This is safe since rhs > lhs\n (m_u128 - diff) as Field\n } else {\n (lhs_u128 - rhs_u128) as Field\n };\n (result, underflow)\n}\n\n/// Multiplies two values and returns both quotient and remainder (unconstrained).\n///\n/// Computes `lhs * rhs = m * quotient + remainder` where `0 <= remainder < m`.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value\n/// * `rhs` - Right-hand side value\n/// * `m` - The modulus\n///\n/// # Returns\n/// A tuple `(quotient, remainder)` where `lhs * rhs = m * quotient + remainder`\n///\n/// # Overflow Warning\n/// Field multiplication wraps modulo the field prime (~254 bits). For two u128 values\n/// near 2^128, their product (up to 2^256) exceeds the Field modulus, causing silent\n/// wraparound before the mod reduction. This can produce incorrect results.\n///\n/// # Safe Input Range\n/// To avoid overflow, ensure `lhs * rhs < Field::MODULUS`. For typical use cases:\n/// - Party IDs, polynomial coefficients, and small cryptographic values (< 2^64) are safe\n/// - Arbitrary u128 values may overflow and should be validated by callers\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\n/// Callers must ensure inputs are within the safe range to prevent silent overflow.\npub unconstrained fn __mul_with_quotient(lhs: Field, rhs: Field, m: Field) -> (Field, Field) {\n // WARNING: Field multiplication can overflow for large inputs.\n // For u128 values near 2^128, the product (up to 2^256) exceeds Field modulus (~2^254),\n // causing wraparound. This is safe for typical use cases (party IDs, small coefficients),\n // but callers must validate input ranges for arbitrary u128 values.\n let product = lhs * rhs;\n __compute_mod_reduction(product, m)\n}\n\n/// Computes the modular multiplicative inverse using Fermat's Little Theorem (unconstrained).\n///\n/// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n/// using the identity: val^(-1) = val^(m-2) (mod m) (from Fermat's Little Theorem).\n///\n/// # Arguments\n/// * `val` - The value to invert (must be coprime with the modulus)\n/// * `m` - The modulus (should be prime for this method to work correctly)\n///\n/// # Returns\n/// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __inv_mod(val: Field, m: Field) -> Field {\n // by Fermat's Little Theorem: val^(m-1)= 1 mod m\n __pow_mod(val, m - 2, m)\n}\n\n/// Computes modular division: `lhs * rhs^(-1) mod m` (unconstrained).\n///\n/// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n///\n/// # Arguments\n/// * `lhs` - The numerator\n/// * `rhs` - The denominator (must be coprime with the modulus)\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `(lhs * rhs^(-1)) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __div_mod(lhs: Field, rhs: Field, m: Field) -> Field {\n let rhs_inv = __inv_mod(rhs, m);\n __mul_mod(lhs, rhs_inv, m)\n}\n\n/// Computes modular exponentiation: `base^exp mod m` (unconstrained).\n///\n/// Uses the binary exponentiation method (also known as square-and-multiply)\n/// for efficient computation of large powers.\n///\n/// # Arguments\n/// * `base` - The base value\n/// * `exp` - The exponent\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `base^exp mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __pow_mod(base: Field, exp: Field, m: Field) -> Field {\n let mut result = 1 as Field;\n let (_, base_mod) = __compute_mod_reduction(base, m);\n let mut current_base = base_mod;\n let mut e = exp as u128;\n\n while e > 0 {\n if (e % 2) == 1 {\n result = __mul_mod(result, current_base, m);\n }\n current_base = __mul_mod(current_base, current_base, m);\n e = e / 2;\n }\n\n result\n}\n\n/// Multiplies two values with modular reduction (unconstrained).\n///\n/// Computes `(lhs * rhs) mod m` and returns only the remainder.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value\n/// * `rhs` - Right-hand side value\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `(lhs * rhs) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __mul_mod(lhs: Field, rhs: Field, m: Field) -> Field {\n let (_, r) = __mul_with_quotient(lhs, rhs, m);\n r\n}\n\n// ------------------------------ TESTS ------------------------------\n// Note: All unsafe blocks in the following tests are safe because we are testing\n// unconstrained functions in a controlled test environment. These functions are\n// designed to be called from unsafe blocks or other unconstrained functions.\n// Each unsafe block is used to call an unconstrained function for testing purposes.\n\n#[test]\nfn test_compute_mod_reduction_simple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(42, 10) };\n assert(q == 4); // 42 / 10 = 4\n assert(r == 2); // 42 % 10 = 2\n // Verify: 42 = 10 * 4 + 2\n assert(10 * q + r == 42);\n}\n\n#[test]\nfn test_compute_mod_reduction_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(100, 10) };\n assert(q == 10); // 100 / 10 = 10\n assert(r == 0); // 100 % 10 = 0\n assert(10 * q + r == 100);\n}\n\n#[test]\nfn test_compute_mod_reduction_large_value() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(12345, 100) };\n assert(q == 123); // 12345 / 100 = 123\n assert(r == 45); // 12345 % 100 = 45\n assert(100 * q + r == 12345);\n}\n\n#[test]\nfn test_compute_mod_reduction_smaller_than_modulus() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(7, 10) };\n assert(q == 0); // 7 / 10 = 0\n assert(r == 7); // 7 % 10 = 7\n assert(10 * q + r == 7);\n}\n\n#[test]\nfn test_neg_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(0, 100) };\n assert(result == 0); // Negation of zero is zero\n}\n\n#[test]\nfn test_neg_non_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(30, 100) };\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_large_value() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(12345, 100000) };\n assert(result == 87655); // 100000 - 12345 = 87655\n}\n\n#[test]\nfn test_neg_verification() {\n let val: Field = 42;\n let m: Field = 97;\n // Safety: Test function calling unconstrained helper\n let neg_val = unsafe { __neg(val, m) };\n // Verify: val + neg_val = 0 (mod m)\n let sum = val + neg_val;\n // Safety: Test function calling unconstrained helper\n let (_, remainder) = unsafe { __compute_mod_reduction(sum, m) };\n assert(remainder == 0);\n}\n\n#[test]\nfn test_sub_with_underflow_no_underflow() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(50, 30, 100) };\n assert(underflow == false);\n assert(result == 20); // 50 - 30 = 20\n}\n\n#[test]\nfn test_sub_with_underflow_with_underflow() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(30, 50, 100) };\n assert(underflow == true);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_with_underflow_equal_values() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(42, 42, 100) };\n assert(underflow == false);\n assert(result == 0);\n}\n\n#[test]\nfn test_sub_with_underflow_verification() {\n let lhs: Field = 30;\n let rhs: Field = 50;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(lhs, rhs, m) };\n\n if underflow {\n // Verify: lhs + m = rhs + result\n assert(lhs + m == rhs + result);\n } else {\n // Verify: lhs = rhs + result\n assert(lhs == rhs + result);\n }\n}\n\n#[test]\nfn test_mul_with_quotient_simple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(6, 7, 10) };\n assert(q == 4); // (6 * 7) / 10 = 42 / 10 = 4\n assert(r == 2); // (6 * 7) % 10 = 42 % 10 = 2\n // Verify: 6 * 7 = 10 * 4 + 2\n assert(6 * 7 == 10 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(12, 15, 100) };\n assert(q == 1); // (12 * 15) / 100 = 180 / 100 = 1\n assert(r == 80); // (12 * 15) % 100 = 180 % 100 = 80\n assert(12 * 15 == 100 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(5, 20, 100) };\n assert(q == 1); // (5 * 20) / 100 = 100 / 100 = 1\n assert(r == 0); // (5 * 20) % 100 = 100 % 100 = 0\n assert(5 * 20 == 100 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_verification() {\n let lhs: Field = 123;\n let rhs: Field = 456;\n let m: Field = 1000;\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(lhs, rhs, m) };\n // Verify: lhs * rhs = m * q + r\n assert(lhs * rhs == m * q + r);\n // Verify remainder is in range [0, m)\n assert((r as u128) < (m as u128));\n}\n\n#[test]\nfn test_mul_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(6, 7, 10) };\n assert(result == 2); // (6 * 7) mod 10 = 42 mod 10 = 2\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(12, 15, 100) };\n assert(result == 80); // (12 * 15) mod 100 = 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(5, 20, 100) };\n assert(result == 0); // (5 * 20) mod 100 = 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(42, 0, 100) };\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_commutative() {\n let a: Field = 7;\n let b: Field = 9;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let mul_a_b = unsafe { __mul_mod(a, b, m) };\n // Safety: Test function calling unconstrained helper\n let mul_b_a = unsafe { __mul_mod(b, a, m) };\n // Verify: a * b = b * a\n assert(mul_a_b == mul_b_a);\n}\n\n#[test]\nfn test_pow_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(2, 3, 10) };\n assert(result == 8); // 2^3 mod 10 = 8 mod 10 = 8\n}\n\n#[test]\nfn test_pow_mod_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(2, 10, 100) };\n assert(result == 24); // 2^10 = 1024, 1024 mod 100 = 24\n}\n\n#[test]\nfn test_pow_mod_exponent_one() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(7, 1, 100) };\n assert(result == 7); // 7^1 mod 100 = 7\n}\n\n#[test]\nfn test_pow_mod_exponent_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(7, 0, 100) };\n assert(result == 1); // 7^0 mod 100 = 1\n}\n\n#[test]\nfn test_pow_mod_base_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(0, 5, 100) };\n assert(result == 0); // 0^5 mod 100 = 0\n}\n\n#[test]\nfn test_pow_mod_large_exponent() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(3, 7, 97) };\n // 3^7 = 2187, 2187 mod 97 = 53\n assert(result == 53);\n}\n\n#[test]\nfn test_pow_mod_fermat_little_theorem() {\n // For prime modulus p and value a, a^(p-1) = 1 (mod p)\n let a: Field = 3;\n let p: Field = 11; // Prime\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(a, p - 1, p) };\n assert(result == 1);\n}\n\n#[test]\nfn test_inv_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(3, 11) };\n // 3 * 4 = 12 = 1 (mod 11), so 3^(-1) = 4 (mod 11)\n assert(result == 4);\n // Verify: 3 * result = 1 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(3, result, 11) } == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(7, 13) };\n // Verify: 7 * result = 1 (mod 13)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(7, result, 13) } == 1);\n}\n\n#[test]\nfn test_inv_mod_another_prime() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(5, 17) };\n // Verify: 5 * result = 1 (mod 17)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(5, result, 17) } == 1);\n}\n\n#[test]\nfn test_inv_mod_inverse_of_inverse() {\n let a: Field = 7;\n let m: Field = 11;\n // Safety: Test function calling unconstrained helper\n let inv_a = unsafe { __inv_mod(a, m) };\n // Safety: Test function calling unconstrained helper\n let inv_inv_a = unsafe { __inv_mod(inv_a, m) };\n // (a^(-1))^(-1) = a\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_div_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(6, 2, 11) };\n assert(result == 3); // 6 / 2 = 3\n // Verify: result * 2 = 6 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 2, 11) } == 6);\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(7, 3, 11) };\n // 3^(-1) mod 11 = 4 (since 3 * 4 = 12 = 1 mod 11)\n // 7 * 4 = 28 = 6 (mod 11)\n assert(result == 6);\n // Verify: result * 3 = 7 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 3, 11) } == 7);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a: Field = 10;\n let b: Field = 3;\n let m: Field = 17;\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(a, b, m) };\n // Verify: result * b = a (mod m)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, b, m) } == a);\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a: Field = 250;\n let b: Field = 7;\n let m: Field = 97;\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(a, b, m) };\n // Verify: result * b = a (mod m)\n // Safety: Test function calling unconstrained helper\n let (_, a_reduced) = unsafe { __compute_mod_reduction(a, m) }; // 250 mod 97 = 56\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, b, m) } == a_reduced);\n}\n\n#[test]\nfn test_div_mod_by_one() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(42, 1, 100) };\n assert(result == 42); // 42 / 1 = 42\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 1, 100) } == 42);\n}\n\n#[test]\nfn test_all_operations_consistency() {\n // Test that all operations work together correctly\n let m: Field = 97; // Prime\n let a: Field = 42;\n let b: Field = 13;\n\n // Test: (a + b) mod m\n let sum = a + b;\n // Safety: Test function calling unconstrained helper\n let (_, sum_reduced) = unsafe { __compute_mod_reduction(sum, m) };\n assert(sum_reduced == 55);\n\n // Test: (a - b) mod m using subtraction\n // Safety: Test function calling unconstrained helper\n let (diff, _) = unsafe { __sub_with_underflow(a, b, m) };\n assert(diff == 29);\n\n // Test: (a * b) mod m\n // Safety: Test function calling unconstrained helper\n let prod = unsafe { __mul_mod(a, b, m) };\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test: b^(-1) mod m\n // Safety: Test function calling unconstrained helper\n let inv = unsafe { __inv_mod(b, m) };\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(b, inv, m) } == 1);\n\n // Test: (a / b) mod m\n // Safety: Test function calling unconstrained helper\n let quot = unsafe { __div_mod(a, b, m) };\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(quot, b, m) } == a);\n\n // Test: (-a) mod m\n // Safety: Test function calling unconstrained helper\n let neg = unsafe { __neg(a, m) };\n let sum_neg = a + neg;\n // Safety: Test function calling unconstrained helper\n let (_, sum_neg_reduced) = unsafe { __compute_mod_reduction(sum_neg, m) };\n assert(sum_neg_reduced == 0);\n}\n", - "path": "/Users/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/modulo/unconstrained_U128.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/modulo/unconstrained_U128.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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/polynomial.nr" + "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/ctrlc03/Documents/zk/enclave/circuits/lib/src/math/safe.nr" + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/math/safe.nr" } }, "expression_width": { "Bounded": { "width": 4 } } diff --git a/crates/zk-prover/tests/fixtures/threshold_share_decryption.json b/crates/zk-prover/tests/fixtures/threshold_share_decryption.json new file mode 100644 index 0000000000..70e487d2b9 --- /dev/null +++ b/crates/zk-prover/tests/fixtures/threshold_share_decryption.json @@ -0,0 +1,145 @@ +{ + "noir_version": "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", + "hash": "948548648645930716", + "abi": { + "parameters": [ + { "name": "expected_sk_commitment", "type": { "kind": "field" }, "visibility": "public" }, + { "name": "expected_e_sm_commitment", "type": { "kind": "field" }, "visibility": "public" }, + { + "name": "ct0", + "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": "public" + }, + { + "name": "ct1", + "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": "public" + }, + { + "name": "sk", + "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": "e_sm", + "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": "r1", + "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": "r2", + "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": "d", + "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" + } + ], + "return_type": null, + "error_types": { + "790736725912586495": { "error_kind": "string", "string": "Decryption share computation failed" }, + "7023503018538476324": { "error_kind": "string", "string": "S commitment mismatch" }, + "12469291177396340830": { "error_kind": "string", "string": "call to assert_max_bit_size" }, + "13823868475309396004": { "error_kind": "string", "string": "E commitment mismatch" } + } + }, + "bytecode": "H4sIAAAAAAAA/7z6CbjNdf/3f4fMc0hC1jbPQxIyz/M8z/OcOSQhIQlJkpCQhIQkU0hCQhISkpBMyZQpCfda92/t4+b6/67/9nzt170cx+f6fH/X+d57rx7P/X2f5+k44zzyP38eDd+9O/Tok3bQI4/0HPLI/+NPnPAdCN+FO9cdcKLI3Dxr61dZPWpU8za5i56tPnRdvymVTlyfejn4r9/N8v+b/T//tLsxacGjN1aVyTIoz/mjpXrkuv9fS/h//JwHf/r/80/cRP/rz/lfvyBeov/7Z/o/v+DR/5fZ//ML4sc0e98XJHio2f/5goSJHt773gPeqf5f/5/7/1DvRMA7MfBOAryTAu9kwDs58A4N/v++7///vFMA75TAOxXwTg28HwPeaYB3nMDDe4c+SbJH/n97LfR/h/ZR6L4XvkPfLE74+0bPxQ0+xwv938ETP/DAZ30kUfgO/C//zP/bn7SgWzrQ7XHQLT3o9gTolgHMhjyjZ2NqnCCgvVO0zZOgTUbQJhNokxm0eQp4ZwGzod/z6NmY2iQMRKZNALSJAm2ygjbZQJvswDsHmA3tn+jZmNokCsRuN4b2XuhOEL4Thu/Q942eSxx8ThI8SYMnWeDBD0sb5wSNc4HGuUHjPKBxXtAtH5gNeUbPxtQ4eSAy719+0KYAaFMQtCkE2hQG3kXAbOj3PHo2pjYpApFp8zRoUxS0eQa0KQbaPAu8i4PZ0P6Jno2pTcpA7HZjaO+F7uThO0X4Dn3f6LlUwefUwfNY8KQJPPhhaeMSoHFJ0Pg50LgUaFwadCsDZkOe0bMxNU4biMz7Vxa0KQfalAdtKoA2FYF3JTAb+j2Pno2pTbpAZNpUBm2qgDZVQZtqoE114F2D/HfqwMO3eTwQu90Y2nuhO234The+Q983ei598PmJ4MkQPE8GHvywtHFN0LgWaFwbNK4DGtcF3eqB2ZBn9GxMjTMGIvP+1QdtGoA2DUGbRqBNY+DdhPzdSODh22QKRKZNU9CmGWjTHLRpAdq0BN6twGxo/0TPxtQmcyB2uzG090J3xvCdKXyHvm/03FPB5yyhnxM8UYEHPitu3Bo0bgMatwWN24HG7UG3DuTvvwIP3zhrIDLvX0fQphNo0xm06QLadAXe3cBs6Pc8ejamNtkCkWnTHbTpAdr0BG16gTbPA+/eYDYq8PBtsgditxtDey90Zw3f2cJ36PtGz+UIPucMnlzBkzvwyAN/aOM+oHFf0LgfaNwfNB4Aug0EsyHP6NmYGucJROb9ewG0GQTaDAZthoA2LwLvoWA29HsePRtTm7yByLR5CbQZBtq8DNoMB21GAO+RYDa0f6JnY2qTLxC73Rjae6E7T/jOG75D3zd6Ln/wuUDwFAyeQoEHPyxt/ApoPAo0fhU0Hg0ajwHdxoLZkGf0bEyNCwci8/69BtqMA21eB23GgzZvAO8JYDb0ex49G1ObIoHItJkI2kwCbd4EbSaDNm8B7ylgNrR/omdjavN0IHa7MbT3Qnfh8F0kfIe+b/Rc0eDzM8FTLHieDTz4YWnjt0HjqaDxO6DxNND4XdBtOpgNeUbPxtS4eCAy7997oM0M0GYmaDMLtHkfeM8Gs6Hf8+jZmNqUCESmzQegzRzQZi5oMw+0+RB4zwezof0TPRtTm5KB2O3G0N4L3cXDd4nwHfq+0XPPBZ9LBU/p4CkTePDD0sYfgcYLQOOPQeOFoPEi0G0xmA15Rs/G1LhsIDLv3yegzRLQ5lPQZiloswx4Lwezod/z6NmY2pQLRKbNZ6DNCtDmc9BmJWjzBfBeBWZD+yd6NqY25QOx242hvRe6y4bvcuE79H2j5yoEnysGT6XgqRx48MPSxqtB4zWg8VrQeB1o/CXoth7MhjyjZ2NqXCUQmfdvA2izEbT5CrTZBNp8Dbw3g9nQ73n0bExtqgYi0+Yb0GYLaLMVtNkG2nwLvLeD2dD+iZ6NqU21QOx2Y4XA/9xVwnfV8B36vtFz1YPPNYKnZvDUCjz4YWnj70DjHaDxTtB4F2j8Pei2G8yGPKNnY2pcOxCZ9+8H0GYPaPMjaLMXtNkHvPeD2dDvefRsTG3qBCLT5ifQ5gBo8zNocxC0OQS8D4PZ0P6Jno2pTd1A7HZjaO+F7trhu074Dn3f6Ll6wef6wdMgeBoGHvywtPEvoPER0PhX0PgoaPwb6HYMzIY8o2djatwoEJn37zhocwK0+R20OQna/AG8T4HZ0O959GxMbRoHItPmNGhzBrQ5C9qcA23+BN7nwWxo/0TPxtSmSSB2uzG090J3o/DdOHyHvm/0XNPgc7PgaR48LQIPflja+C/Q+AJofBE0vgQaXwbdroDZkGf0bEyNWwYi8/79DdpcBW2ugTbXQZsbwPsmmA39nkfPxtSmVSAybf4BbW6BNv+CNrdBm/+A9x0wG9o/0bMxtWkdiN1uDO290N0yfLcK36HvGz3XJvjcNnjaBU/7wIMflja+CxrfA40fSfzwjePENHvfF8R9qNn/+YJ4YDbkGT0bU+MOgci8f48mfvg28RM/fJsEoE1C0CYR8E4MZkO/59GzMbXpGIhMmySgTVLQJhlokxy0SQG8U4LZ0P6Jno2pTadA7HZjaO+F7g7hu2P4Dn3f6LnOwecuwdM1eLoFHvywtHEq0Dg1aPwYaJwGNE4LuqUDsyHP6NmYGncPROb9exy0SQ/aPAHaZABtngTeGcFs6Pc8ejamNj0CkWmTCbTJDNo8BdpkAW0CwDsKzIb2T/RsTG16BmK3G0N7L3R3D989wnfo+0bP9Qo+Px88vYOnT+DBD0sbZwWNs4HG2UHjHKBxTtAtF5gNeUbPxtS4byAy719u0CYPaJMXtMkH2uQH3gXAbOj3PHo2pjb9ApFpUxC0KQTaFAZtioA2TwPvomA2tH+iZ2Nq0z8Qu90Y2nuhu2/47he+Q983em5A8Hlg8LwQPIMCD35Y2vgZ0LgYaPwsaFwcNC4BupUEsyHP6NmYGg8OROb9ew60KQXalAZtyoA2ZYF3OTAb+j2Pno2pzZBAZNqUB20qgDYVQZtKoE1l4F0FzIb2T/RsTG1eDMRuN4b2XugeHL6HhO/Q942eGxp8fil4hgXPy4EHPyxtXBU0rgYaVweNa4DGNUG3WmA25Bk9G1Pj4YHIvH+1QZs6oE1d0KYeaFMfeDcAs6Hf8+jZmNqMCESmTUPQphFo0xi0aQLaNAXezcBsaP9Ez8bUZmQgdrsxtPdC9/DwPSJ8h75v9NwrwedRwfNq8IwOPPhhaePmoHEL0LglaNwKNG4NurUBs6MCD994TCAy719b0KYdaNMetOkA2nQE3p3AbOj3PHo2pjZjA5Fp0xm06QLadAVtuoE23YF3DzAb2j/RszG1eS0Qu90Y2nuhe0z4Hhu+Q983em5c8Pn14BkfPG8EHvywtHFP0LgXaPw8aNwbNO4DuvUFsyHP6NmYGk8IROb96wfa9AdtBoA2A0GbF8h/FwOzod/z6NmY2kwMRKbNYNBmCGjzImgzFLR5ifzndDAb2j/RszG1mRSI3W4M7b3QPSF8Twzfoe8bPfdm8Hly8LwVPFMCD35Y2vhl0Hg4aDwCNB4JGr9C/rMgmA15Rs/G1PjtQGTev1dBm9GgzRjQZixo8xrwHgdmQ7/n0bMxtZkaiEyb10Gb8aDNG6DNBNBmIvCeBGZD+yd6NqY27wRitxtDey90vx2+p4bv0PeNnpsWfH43eKYHz3uBBz8sbfwmaDwZNH4LNJ4CGr8Nuk0FsyHP6NmYGs8IROb9ewe0mQbavAvaTAdt3gPeM8Bs6Pc8ejamNjMDkWkzE7SZBdq8D9rMBm0+AN5zwGxo/0TPxtRmViB2uzG090L3jPA9M3yHvm/03PvB59nB80HwzAk8+GFp47mg8TzQ+EPQeD5o/BHotgDMhjyjZ2NqPDcQmffvY9BmIWizCLRZDNp8AryXgNnQ73n0bExt5gUi0+ZT0GYpaLMMtFkO2nwGvFeQPRp4+DYfBmK3G0N7L3TPDd/zwnfo+0bPzQ8+fxQ8C4Ln48CDH5Y2/hw0XgkafwEarwKNV4Nua8BsyDN6NqbGCwORef/WgjbrQJsvQZv1oM0G4L2R/Htc4OHbLApEps1XoM0m0OZr0GYzaPMN8N4CZkP7J3o2pjaLA7HbjaG9F7oXhu9F4Tv0faPnPgk+LwmeT4NnaeDBD0sbbwWNt4HG34LG20Hj70C3HeQ/xwQevvGyQGTev52gzS7Q5nvQZjdo8wPw3gNmQ7/n0bMxtVkeiEybH0GbvaDNPtBmP2jzE/A+AGZD+yd6NqY2nwVitxtDey90Lwvfy8N36PtGz60IPn8ePCuD54vAgx+WNv4ZND4IGh8CjQ+Dxr+AbkfAbMgzejamxqsCkXn/fgVtjoI2v4E2x0Cb48D7BJgN/Z5Hz8bUZnUgMm1+B21OgjZ/gDanQJvTwPsMmA3tn+jZmNqsCcRuN4b2XuheFb5Xh+/Q942eWxt8Xhc8XwbP+sCDH5Y2PgsanwON/wSNz4PGf4FuF8BsyDN6NqbGGwKRef8ugjaXQJvLoM0V0OZv4H0VzIZ+z6NnY2qzMRCZNtdAm+ugzQ3Q5iZo8w/wvgVmQ/snejamNl8FYrcbQ3svdG8I3xvDd+j7Rs9tCj5/HTybg+ebwAOfFTf+FzS+DRr/BxrfAY3vgm73wGzIM3o2psZbAtr7F90v8OCPfuT/+ifJw7eJk+Th/1k3Bx7+n3VrIDK7Ji74Z42X5OF/Dx9N8vC/h/GTPPzvYQLgnRDMht7n6NmY2mwLxG7XhPZI6N4SvreG79D3jZ77Nvi8PXi+C54dgQc/LG2cCDRODBonAY2TgsbJQLfkYDbkGT0bU+Odgci8fylAm5SgTSrQJjVo8xjwTgNmQ7/n0bMxtdkViEybtKBNOtDmcdAmPWjzBPDOAGZD+yd6NqY23wditxtDey907wzfu8J36PtGz+0OPv8QPHuC58fAgx+WNn4SNM4IGmcCjTODxk+BblnAbMgzejamxnsDkXn/AqBNFGiTFbTJBtpkB945wGzo9zx6NqY2+wKRaZMTtMkF2uQGbfKANnmBdz4wG9o/0bMxtdkfiN1uDO290L03fO8L36HvGz33U/D5QPD8HDwHAw9+WNo4P2hcADQuCBoXAo0Lg25FwGzIM3o2psaHApF5/54GbYqCNs+ANsVAm2eBd3EwG/o9j56Nqc3hQGTalABtSoI2z4E2pUCb0sC7DJgN7Z/o2Zja/BKI3W4M7b3QfSh8Hw7foe8bPXck+Pxr8BwNnt8CD35Y2rgsaFwONC4PGlcAjSuCbpXAbMgzejamxscCkXn/KoM2VUCbqqBNNdCmOvCuAWZDv+fRszG1OR6ITJuaoE0t0KY2aFMHtKkLvOuB2dD+iZ6Nqc2JQOx2Y2jvhe5j4ft4+A593+i534PPJ4Pnj+A5FXjkgT+0cX3QuAFo3BA0bgQaNwbdmoDZkGf0bEyNTwci8/41BW2agTbNQZsWoE1L4N0KzIZ+z6NnY2pzJhCZNq1BmzagTVvQph1o0x54dwCzof0TPRtTm7OB2O3G0N4L3afD95nwHfq+0XPngs9/Bs/54Pkr8OCHpY07gsadQOPOoHEX0Lgr6NYNzIY8o2djanwhEJn3rzto0wO06Qna9AJtngfevcFs6Pc8ejamNhcDkWnTB7TpC9r0A236gzYDgPdAMBvaP9GzMbW5FIjdbgztvdB9IXxfDN+h7xs9dzn4fCV4/g6eq4EHPyxt/AJoPAg0HgwaDwGNXwTdhoLZkGf0bEyNrwUi8/69BNoMA21eBm2GgzYjgPdIMBv6PY+ejanN9UBk2rwC2owCbV4FbUaDNmOA91gwG9o/0bMxtbkRiN1uDO290H0tfF8P36HvGz13M/j8T/DcCp5/Aw9+WNr4NdB4HGj8Omg8HjR+A3SbAGZDntGzMTW+HYjM+zcRtJkE2rwJ2kwGbd4C3lPAbOj3PHo2pjb/BSLT5m3QZipo8w5oMw20eRd4Twezof0TPRtTmzuB2O3G0N4L3bfD93/hO/R9o+fuBp/vhX5IVPBfi3rww9LG74HGM0DjmaDxLND4fdBtNpgNeUbPxtQ4blRk3r8PQJs5oM1c0GYeaPMh8J4PZh+Jevg28SLU5iPQZgFo8zFosxC0WQS8F4PZOKDNo6DN/7YbQ3svdIfev9AdL3yHvm/0XPzgc4LgSRg8iaIe/LC08Seg8RLQ+FPQeClovAx0Ww5mE4DGiSP0/n0G2qwAbT4HbVaCNl8A71VgNiFokyRCbVaDNmtAm7WgzTrQ5kvgvR7MJgJtksZyN8YP78LE4TtJ+E56325MFnxOHjwpgidl1IMfljbeABpvBI2/Ao03gcZfg26bwWxy0DhVhN6/b0CbLaDNVtBmG2jzLfDeDmZTgDapI9TmO9BmB2izE7TZBdp8D7x3g9mUoM1jsdyNycK7MFX4Th2+H7tvN6YJPqcNnnTB83jUgx+WNv4BNN4DGv8IGu8FjfeBbvvBbFrQOH2E3r+fQJsDoM3PoM1B0OYQ8D4MZtOBNk9EqM0voM0R0OZX0OYoaPMb8D4GZh8HbTLEcjemCe/C9OH7ifCd4b7d+GTwOWPwZAqezFEPflja+DhofAI0/h00Pgka/wG6nQKzGUHjpyL0/p0Gbc6ANmdBm3OgzZ/A+zyYzQTaZIlQm79AmwugzUXQ5hJoc5n8bzbAbGbQJhDL3fhkeBc+Fb6zhO/AfbsxKvicNXiyBU/2qAc/LG38N2h8FTS+BhpfB41vgG43wWxW0DhHhN6/f0CbW6DNv6DNbdDmP+B9B8xmA21yRqjNXdDmHmjzSNKHbxMn6cO3iZv04b3jgdnsoE2uWO7GqPAuzBG+c4bvXPftxtzB5zzBkzd48kU9+GFp40eTPnzj+EkfvnEC0DghaJwIdEsMZvOAxvkj9P4lAW2SgjbJQJvkoE0K4J0SzOYFbQpEqE0q0CY1aPMYaJMGtEkLvNOB2XygTcFY7sbc4V2YP3wXCN8F79uNhYLPhYOnSPA8HfXgh6WNHweN04PGT4DGGUDjJ0G3jGC2MGhcNELvXybQJjNo8xRokwW0CQDvKDBbBLR5JkJtsoI22UCb7KBNDtAmJ/DOBWafBm2KxXI3FgrvwqLh+5nwXey+3fhs8Ll48JQInpJRD35Y2jg3aJwHNM4LGucDjfODbgXAbHHQ+LkIvX8FQZtCoE1h0KYIaPM08C4KZkuANqUi1OYZ0KYYaPMsaFMctCkBvEuSWdCmdCx347PhXfhc+C4VvkvftxvLBJ/LBk+54Ckf9eCHpY2fA41LgcalQeMyoHFZ0K0cmC0LGleI0PtXHrSpANpUBG0qgTaVgXcV0hG0qRihNlVBm2qgTXXQpgZoUxN41wKz5UGbSrHcjWXCu7BC+K4YvivdtxsrB5+rBE/V4KkW9eCHpY1rg8Z1QOO6oHE90Lg+6NaAvKugcfUIvX8NQZtGoE1j0KYJaNMUeDcDs1VBmxoRatMctGkB2rQEbVqBNq2BdxswWw20qRnL3Vg5vAurh+8a4bvmfbuxVvC5dvDUCZ66UQ9+WNq4LWjcDjRuDxp3AI07gm6dwGxt0LhehN6/zqBNF9CmK2jTDbTpDrx7gNk6oE39CLXpCdr0Am2eB216gzZ9gHdfMFsXtGkQy91YK7wL64Xv+uG7wX27sWHwuVHwNA6eJlEPfljauB9o3B80HgAaDwSNXwDdBoHZRqBx0wi9f4NBmyGgzYugzVDQ5iXgPQzMNgZtmkWozcugzXDQZgRoMxK0eQV4jwKzTUCb5rHcjQ3Du7Bp+G4WvpvftxtbBJ9bBk+r4Gkd9eCHpY1fBY1Hg8ZjQOOxoPFroNs4MNsSNG4ToffvddBmPGjzBmgzAbSZCLwngdlWoE3bCLV5E7SZDNq8BdpMAW3eBt5TwWxr0KZdLHdji/AubBO+24bvdvftxvbB5w7B0zF4OkU9+GFp43dA42mg8bug8XTQ+D3QbQaY7QAad47Q+zcTtJkF2rwP2swGbT4A3nPAbEfQpkuE2swFbeaBNh+CNvNBm4+A9wLy91agTddY7sb24V3YOXx3Cd9d79uN3YLP3YOnR/D0jHrww9LGH4PGC0HjRaDxYtD4E9BtCZjtDhr3itD79ylosxS0WQbaLAdtPgPeK8jfTYI2z0eozeegzUrQ5gvQZhVosxp4rwGzPUGb3rHcjd3Cu7BX+H4+fPe+bzf2CT73DZ5+wdM/6sEPSxuvBY3XgcZfgsbrQeMNoNtG8vfPoPGACL1/X4E2m0Cbr0GbzaDNN8B7C5jtB9oMjFCbraDNNtDmW9BmO2jzHfDeAWb7gzYvxHI39gnvwgHhe2D4fuG+3Tgo+Dw4eIYEz4tRD35Y2ngnaLwLNP4eNN4NGv8Auu0Bs4NB46ERev9+BG32gjb7QJv9oM1PwPsAmB0C2rwUoTY/gzYHQZtDoM1h0OYX4H0EzL4I2gyL5W4cFN6FQ8P3S+F72H278eXg8/DgGRE8I6Me/LC08a+g8VHQ+DfQ+BhofBx0OwFmh4PGr0To/fsdtDkJ2vwB2pwCbU4D7zNgdgRoMypCbc6CNudAmz9Bm/OgzV/A+wKYHQnavBrL3fhyeBe+Er5Hhe9X79uNo4PPY4JnbPC8FvXgh6WNL4LGl0Djy6DxFdD4b9DtKpgdAxqPi9D7dw20uQ7a3ABtboI2/wDvW2B2LGjzeoTa/Ava3AZt/gNt7oA2d4H3PTD7GmgzPpa7cXR4F44L36+H7/H37cY3gs8Tgmdi8EyKevDDRs8EHvxHeOT/+ifZwzeOk+zhzSYAszdjafZG2OjN8D0xfE+6z2xy8Pmt4JkSPG//H2Zxw3fgIT/v/bMxObwV9dCzD/xJ+L/+nP97x7igY7xkD/+uPhpT8/u+IP5D/X78zxckAL9LCZM9fJup4m6k3omAd2LgnQR4JwXeyYB3cuD9ToS8UwDvlMA7FfBODbwfA95pgPe0WO7Ku1n+554a3pHvhO9p9+3Kd4PP04PnveCZEfXgh6X/GSIt6JYOdHscdEsPuj0BumUAs9PBvx/OFN8p2uZJ0CYjaJMJtMkM2jwFvLOA2fdAm1kRahMAbaJAm6ygTTbQJjvwzgFmZ4A278dyN74b3oUzw/es8P3+fbtxdvD5g+CZEzxzox78sLRxTtA4F2icGzTOAxrnBd3ygdkPQON5EXr/8oM2BUCbgqBNIdCmMPAuAmbngDYfRqjN06BNUdDmGdCmGGjzLPAuDmbngjbzY7kbZ4d34bzw/WH4nn/fbvwo+LwgeD4OnoVRD35Y2rgEaFwSNH4ONC4FGpcG3cqA2QWg8aIIvX9lQZtyoE150KYCaFMReFcCsx+DNosj1KYyaFMFtKkK2lQDbaoD7xpgdiFo80ksd+NH4V24KHwvDt+f3LcblwSfPw2epcGzLOrBD0sb1wSNa4HGtUHjOqBxXdCtHpj9FDReHqH3rz5o0wC0aQjaNAJtGgPvJmB2KWjzWYTaNAVtmoE2zUGbFqBNS+DdCswuA21WxHI3LgnvwuXh+7PwveK+3fh58Hll8HwRPKuiHvywtHFr0LgNaNwWNG4HGrcH3TqA2ZWg8eoIvX8dQZtOoE1n0KYLaNMVeHcDs1+ANmsi1KY7aNMDtOkJ2vQCbZ4H3r3B7CrQZm0sd+Pn4V24OnyvCd9r79uN64LPXwbP+uDZEPXgh6WN+4DGfUHjfqBxf9B4AOg2EMx+CRpvjND79wJoMwi0GQzaDAFtXgTeQ8HsetDmqwi1eQm0GQbavAzaDAdtRgDvkWB2A2izKZa7cV14F24M31+F70337cavg8+bg+eb4NkS9eCHpY1fAY1HgcavgsajQeMxoNtYMLsZNN4aoffvNdBmHGjzOmgzHrR5A3hPALPfgDbbItRmImgzCbR5E7SZDNq8BbyngNktoM23sdyNX4d34dbwvS18f3vfbtwefP4ueHYEz86oBz8sbfw2aDwVNH4HNJ4GGr8Luk0Hs9+Bxrsi9P69B9rMAG1mgjazQJv3gfdsMLsDtPk+Qm0+AG3mgDZzQZt5oM2HwHs+mN0J2uyO5W7cHt6Fu8L39+F793278Yfg857g+TF49kY9+GFp449A4wWg8ceg8ULQeBHothjM7gGN90Xo/fsEtFkC2nwK2iwFbZYB7+Vg9kfQZn+E2nwG2qwAbT4HbVaCNl+Qv0MEs3tBm59iuRt/CO/CfeF7f/j+6b7deCD4/HPwHAyeQ1EPfljaeDVovAY0XgsarwONvyR/TwVmfwaND0fo/dsA2mwEbb4CbTaBNl+Tv8MAswdBm18i1OYb0GYLaLMVtNkG2nwLvLeD2UOgzZFY7sYD4V14OHz/Er6P3Lcbfw0+Hw2e34LnWNSDH5Y2/g403gEa7wSNd4HG34Nuu8HsUdD4eITevx9Amz2gzY+gzV7QZh/w3g9mfwNtTkSozU+gzQHQ5mfQ5iBocwh4Hwazx0Cb32O5G38N78Lj4ftE+P79vt14Mvj8R/CcCp7TUQ9+WNr4F9D4CGj8K2h8FDT+jXQDs3+Axmci9P4dB21OgDa/gzYnQZs/gPcpMgvanI1Qm9OgzRnQ5ixocw60+RN4nwezp0Gbc7HcjSfDu/BM+D4bvs/dtxv/DD6fD56/gudC1IMfljb+CzS+ABpfBI0vgcaXQbcr5PcBNL4Yoffvb9DmKmhzDbS5DtrcAN43wexfoM2lCLX5B7S5Bdr8C9rcBm3+A953wOwF0OZyLHfjn+FdeDF8Xwrfl+/bjVeCz38Hz9XguRb14Ielje+CxvdA40eSP3zjODHN3vcFcR9q9n++IB6Y/Rs0vh6h9+/R5A/fJn7yh2+TALRJCNokAt6JwexV0OZGhNokAW2SgjbJQJvkoE0K4J0SzF4DbW7GcjdeCe/C6+H7Rvi+ed9u/Cf4fCt4/g2e21EPfljaOBVonBo0fgw0TgMapwXd0oHZW6DxfxF6/x4HbdKDNk+ANhlAmyeBd0Yw+y9ocydCbTKBNplBm6dAmyygTQB4R4HZ26DN3Vjuxn/Cu/C/8H0nfN+9bzfeCz4/kjX4/x88cbM++GFp46ygcTbQODtonAM0zgm65QKzIc/o2Zgax8samfcvN2iTB7TJC9rkA23yA+8CYDYOaPNohNoUBG0KgTaFQZsioM3TwLsomI0L2sQHbf633XgvvAtD71/ofjR8h75v9FyC4HPC4EkUPIljuRufAY2LgcbPgsbFQeMSoFtJMJsQNE4SoffvOdCmFGhTGrQpA9qUBd7lwGwi0CZphNqUB20qgDYVQZtKoE1l4F2F/N0IaJMslrsxQXgXJgnfScN3svt2Y/Lgc4rgSRk8qWK5G6uCxtVA4+qgcQ3QuCboVgvMpgCNU0fo/asN2tQBbeqCNvVAm/rAuwH5+y/Q5rEItWkI2jQCbRqDNk1Am6bAuxmYTQXapInlbkwe3oWpw/dj4TvNfbsxbfA5XfA8HjzpY7kbm4PGLUDjlqBxK9C4NejWhvzdJGj8RITev7agTTvQpj1o0wG06Qi8O4HZx0GbDBFq0xm06QLadAVtuoE23YF3DzCbHrR5Mpa7MW14Fz4RvjOE7yfv240Zg8+Zgidz8DwVy93YEzTuBRo/Dxr3Bo37gG59wWwm0DhLhN6/fqBNf9BmAGgzELR5AXgPArOZQZtAhNoMBm2GgDYvgjZDQZuXgPcwMPsUaBMVy92YMbwLs4TvQPiOum83Zg0+Zwue7MGTI5a78WXQeDhoPAI0HgkavwK6jQKz2UDjnBF6/14FbUaDNmNAm7GgzWvAexyYzQ7a5IpQm9dBm/GgzRugzQTQZiLwngRmc4A2uWO5G7OGd2HO8J0rfOe+bzfmCT7nDZ58wZM/lrvxTdB4Mmj8Fmg8BTR+G3SbCmbzgsYFIvT+vQPaTANt3gVtpoM27wHvGWA2H2hTMEJtZoI2s0Cb90Gb2aDNB8B7DpjND9oUiuVuzBPehQXCd8HwXei+3Vg4+FwkeJ4OnqKx3I1zQeN5oPGHoPF80Pgj0G0BmC0CGj8ToffvY9BmIWizCLRZDNp8AryXgNmnQZtiEWrzKWizFLRZBtosB20+A94ryP/eB7R5Npa7sXB4Fz4TvouF72fv243Fg88lgqdk8DwXy934OWi8EjT+AjReBRqvBt3WgNkSoHGpCL1/a0GbdaDNl6DNetBmA/DeCGZLgjalI9TmK9BmE2jzNWizGbT5BnhvAbPPgTZlYrkbi4d3YanwXTp8l7lvN5YNPpcLnvLBUyGWu3EraLwNNP4WNN4OGn8Huu0As+VA44oRev92gja7QJvvQZvdoM0PwHsPmC0P2lSKUJsfQZu9oM0+0GY/aPMT8D4AZiuANpVjuRvLhndhxfBdKXxXvm83Vgk+Vw2easFTPZa78WfQ+CBofAg0Pgwa/wK6HQGzVUHjGhF6/34FbY6CNr+BNsdAm+PA+wSYrQba1IxQm99Bm5OgzR+gzSnQ5jTwPgNmq4M2tWK5G6uEd2GN8F0zfNe6bzfWDj7XCZ66wVMvlrvxLGh8DjT+EzQ+Dxr/BbpdALN1QOP6EXr/LoI2l0Cby6DNFdDmb+B9FczWBW0aRKjNNdDmOmhzA7S5Cdr8A7xvgdl6oE3DWO7G2uFdWD98NwjfDe/bjY2Cz42Dp0nwNI3lbvwXNL4NGv8HGt8Bje+CbvfAbGPQuJn4/kX3Czz4ox/5v/5J8fBt4qR4+H/WJuCftXmEdk1c8M8aL8XD/x4+muLhfw/jp3j438MEwDshmG0K2rSI5a5pFN4tzcJ38/Dd4r5d0zL43Cp4WgdPm1jumkSgcWLQOAlonBQ0Tga6JQezrUDjthF6/1KANilBm1SgTWrQ5jHgnQbMtgZt2kWoTVrQJh1o8zhokx60eQJ4ZwCzbUCb9rHcjS3Du7Bt+G4Xvtvftxs7BJ87Bk+n4Okcy934JGicETTOBBpnBo2fAt2ygNmOoHGXCL1/AdAmCrTJCtpkA22yA+8cYLYTaNM1Qm1ygja5QJvcoE0e0CYv8M4HZjuDNt1iuRs7hHdhl/DdNXx3u283dg8+9wiensHTK5a7MT9oXAA0LggaFwKNC4NuRcBsD9D4+Qi9f0+DNkVBm2dAm2KgzbPAuziY7Qna9I5QmxKgTUnQ5jnQphRoUxp4lwGzvUCbPrHcjd3Du/D58N07fPe5bzf2DT73C57+wTMglruxLGhcDjQuDxpXAI0rgm6VwGw/0HhghN6/yqBNFdCmKmhTDbSpDrxrgNn+oM0LEWpTE7SpBdrUBm3qgDZ1gXc9MDsAtBkUy93YN7wLB4bvF8L3oPt24+Dg85DgeTF4hsZyN9YHjRuAxg1B40agcWPyd/hgdgho/FKE3r+moE0z0KY5aNMCtGlJ/n4XzL4I2gyLUJvWoE0b0KYtaNMOtGkPvDuA2aGgzcux3I2Dw7vwpfA9LHy/fN9uHB58HhE8I4PnlVjuxo6gcSfQuDNo3AU07gq6dQOzI0DjURF6/7qDNj1Am56gTS/Q5nng3RvMjgRtXo1Qmz6gTV/Qph9o0x+0GQC8B4LZV0Cb0bHcjcPDu3BU+H41fI++bzeOCT6PDZ7XgmdcLHfjC6DxINB4MGg8BDR+kfx7GpgdCxq/HqH37yXQZhho8zJoMxy0GUH2HZh9DbQZH6E2r4A2o0CbV0Gb0aDNGPIugNlxoM0bsdyNY8K78PXwPT58v3HfbpwQfJ4YPJOC581Y7sbXQONxoPHroPF40PgN0G0CmJ0IGk+O0Ps3EbSZBNq8CdpMBm3eAt5TwOwk0OatCLV5G7SZCtq8A9pMA23eBd7TweyboM2UWO7GCeFdODl8vxW+p9y3G98OPk8NnneCZ1osd+N7oPEM0HgmaDwLNH4fdJsNZqeCxu9G6P37ALSZA9rMBW3mgTYfAu/5YPYd0GZ6hNp8BNosAG0+Bm0WgjaLgPdiMDsNtHkvlrvx7fAufDd8Tw/f7923G2cEn2cGz6zgeT+Wu/ET0HgJaPwpaLwUNF4Gui0HszNB49kRev8+A21WgDafgzYrQZsvgPcqMDsLtPkgQm1WgzZrQJu1oM060OZL4L0ezL4P2syJ5W6cEd6Fs8P3B+F7zn27cW7weV7wfBg882O5GzeAxhtB469A402g8deg22YwOw80/ihC7983oM0W0GYraLMNtPkWeG8Hsx+CNgsi1OY70GYHaLMTtNkF2nwPvHeT//wP2nwcy904N7wLPwrfC8L3x/ftxoXB50XBszh4PonlbvwBNN4DGv8IGu8FjfeBbvvB7CLQeEmE3r+fQJsDoM3PoM1B0OYQ8D5M/jseaPNphNr8AtocAW1+BW2Ogja/Ae9jYPYT0GZpLHfjwvAuXBK+Pw3fS+/bjcuCz8uD57PgWRHL3XgcND4BGv8OGp8Ejf8A3U6R//4NGn8eoffvNGhzBrQ5C9qcA23+BN7nwexnoM3KCLX5C7S5ANpcBG0ugTaXgfcVMLsCtPkilrtxWXgXfh6+V4bvL+7bjauCz6uDZ03wrI3lbvwbNL4KGl8Dja+DxjdAt5tgdjVovC5C798/oM0t0OZf0OY2aPMf8L4DZteANl9GqM1d0OYeaPNIyodvEyflw7eJm/LhveOB2bWgzfpY7sZV4V24Lnx/Gb7X37cbNwSfNwbPV8GzKZa78dGUD984fsqHb5wANE4IGicC3RKD2Y2g8dcRev+SgDZJQZtkoE1y0CYF8E4JZr8CbTZHqE0q0CY1aPMYaJMGtEkLvNOB2U2gzTex3I0bwrvw6/C9OXx/c99u3BJ83ho824Ln21juxsdB4/Sg8ROgcQbQ+EnQLSOY3Qoab4/Q+5cJtMkM2jwF2mQBbQLAOwrMbgNtvotQm6ygTTbQJjtokwO0yQm8c4HZb0GbHbHcjVvCu3B7+P4ufO+4bzfuDD7vCp7vg2d3LHdjbtA4D2icFzTOBxrnB90KgNldoPEPEXr/CoI2hUCbwqBNEdDmaeBdFMx+D9rsiVCbZ0CbYqDNs6BNcdCmBPAuCWZ3gzY/xnI37gzvwh/C957w/eN9u3Fv8Hlf8OwPnp9iuRufA41LgcalQeMyoHFZ0K0cmN0HGh+I0PtXHrSpANpUBG0qgTaVgXcVMLsftPk5Qm2qgjbVQJvqoE0N0KYm8K4FZn8CbQ7GcjfuDe/CA+H75/B98L7deCj4fDh4fgmeI7HcjbVB4zqgcV3QuB5oXB90awBmD4PGv0bo/WsI2jQCbRqDNk1Am6bAuxmY/QW0ORqhNs1BmxagTUvQphVo0xp4twGzR0Cb32K5Gw+Fd+Gv4fto+P7tvt14LPh8PHhOBM/vsdyNbUHjdqBxe9C4A2jcEXTrBGaPg8YnI/T+dQZtuoA2XUGbbqBNd+DdA8yeAG3+iFCbnqBNL9DmedCmN2jTB3j3BbO/gzanYrkbj4V34cnw/Uf4PnXfbjwdfD4TPGeD51wsd2M/0Lg/aDwANB4IGr8Aug0Cs2dA4z8j9P4NBm2GgDYvgjZDQZuXgPcwMHsWtDkfoTYvgzbDQZsRoM1I0OYV4D0KzJ4Dbf6K5W48Hd6Ff4bv8+H7r/t244Xg88XguRQ8l2O5G18FjUeDxmNA47Gg8Wug2zgwexE0vhKh9+910GY8aPMGaDMBtJkIvCeB2Uugzd8RavMmaDMZtHkLtJkC2rwNvKeC2cugzdVY7sYL4V14JXz/Hb6v3rcbrwWfrwfPjeC5Gcvd+A5oPA00fhc0ng4avwe6zQCz10HjfyL0/s0EbWaBNu+DNrNBmw+A9xwwewO0uRWhNnNBm3mgzYegzXzQ5iPgvQDM3gRt/o3lbrwW3oX/hO9b4fvf+3bj7eDzf8FzJ3juxnI3fgwaLwSNF4HGi0HjT0C3JWD2P9D4XoTev09Bm6WgzTLQZjlo8xnwXgFm74A2j2SLTJvPQZuVoM0XoM0q0GY18F4DZu+CNnFAm/9tN94O78J74TvUOk74+0bPxQ0+xwv938ETP9uDH5Y2XgsarwONvwSN14PGG0C3jWA2XraHb5wgQu/fV6DNJtDma9BmM2jzDfDeAmYfBW0SRqjNVtBmG2jzLWizHbT5DnjvALPxQZtEsdyNccO7MEH4Thi+E923GxMHn5MET9LgSRbL3bgTNN4FGn8PGu8GjX8A3faA2SSgcfIIvX8/gjZ7QZt9oM1+0OYn4H0AzCYFbVJEqM3PoM1B0OYQaHMYtPkFeB8Bs8lAm5Sx3I2Jw7swefhOEb5T3rcbUwWfUwfPY8GTJpa78VfQ+Cho/BtofAw0Pk7+tx9gNjVonDZC79/voM1J0OYP0OYUaHOa/O8CwOxjoE26CLU5C9qcA23+BG3OgzZ/Ae8LYDYNaPN4LHdjqvAuTBu+04Xvx+/bjemDz08ET4bgeTKWu/EiaHwJNL4MGl8Bjf8G3a6C2SdA44wRev+ugTbXQZsboM1N0OYf4H0LzGYAbTJFqM2/oM1t0OY/0OYOaHMXeN8Ds0+CNpljuRvTh3dhxvCdKXxnvm83PhV8zhL6OcET9X/sxuiZwIP/CI/8X/+kevjGcVI9vFkWYJY1lmZPhY2yhu9A+I66zyxb8Dl78OQInpz/h1nc8B14yM8b55GHd8ie7aFn/18/U0w/J26ih//8uR7uMyW8d6/f//efNd4j//PPHPq67DF8TvKzY5rN/XCfM+W9u8cf+Jy5H+JzxvAnTjzgmUf0zGPwzAM884qeeQ2ejwLPfKJnPoNnPuCZX/TMb/CMDzwLiJ4FDJ4FgGdB0bOgwTMB8CwkehYyeBYCnoVFz8IGz4TAs4joWcTgWQR4Pi16Pm3wTAQ8i4qeRQ2eRYHnM6LnMwbPxMCzmOhZzOBZDHg+K3o+a/BMAjyLi57FDZ7FgWcJ0bOEwTMp8CwpepY0eJYEns+Jns8ZPJMBz1KiZymDZyngWVr0LG3wTA48y4ieZQyeZYBnWdGzrMEzBfAsJ3qWM3iWA57lRc/yBs+UwLOC6FnB4FkBeFYUPSsaPFMBz0qiZyWDZyXgWVn0rGzwTA08q4ieVQyeVYBnVdGzqsHzMeBZTfSsZvCsBjyri57VDZ5pgGcN0bOGwbMG8KwpetY0eKYFnrVEz1oGz1rAs7boWdvgmQ541hE96xg86wDPuqJnXYPn48CznuhZz+BZD3jWFz3rGzzTA88GomcDg2cD4NlQ9Gxo8HwCeDYSPRsZPBsBz8aiZ2ODZwbg2UT0bGLwbAI8m4qeTQ2eTwLPZqJnM4NnM+DZXPRsbvDMCDxbiJ4tDJ4tgGdL0bOlwTMT8GwlerYyeLYCnq1Fz9YGz8zAs43o2cbg2QZ4thU92xo8nwKe7UTPdgbPdsCzvejZ3uCZBXh2ED07GDw7AM+OomdHg2cAeHYSPTsZPDsBz86iZ2eDZxTw7CJ6djF4dgGeXUXPrgbPrMCzm+jZzeDZDXh2Fz27GzyzAc8eomcPg2cP4NlT9Oxp8MwOPHuJnr0Mnr2A5/Oi5/MGzxzAs7fo2dvg2Rt49hE9+xg8cwLPvqJnX4NnX+DZT/TsZ/DMBTz7i579DZ79gecA0XOAwTM38Bwoeg40eA4Eni+Ini8YPPMAz0Gi5yCD5yDgOVj0HGzwzAs8h4ieQwyeQ4Dni6LniwbPfMBzqOg51OA5FHi+JHq+ZPDMDzyHiZ7DDJ7DgOfLoufLBs8CwHO46Dnc4DkceI4QPUcYPAsCz5Gi50iD50jg+Yro+YrBsxDwHCV6jjJ4jgKer4qerxo8CwPP0aLnaIPnaOA5RvQcY/AsAjzHip5jDZ5jgedroudrBs+ngec40XOcwXMc8Hxd9Hzd4FkUeI4XPccbPMcDzzdEzzcMns8Azwmi5wSD5wTgOVH0nGjwLAY8J4mekwyek4Dnm6LnmwbPZ4HnZNFzssFzMvB8S/R8y+BZHHhOET2nGDynAM+3Rc+3DZ4lgOdU0XOqwXMq8HxH9HzH4FkSeE4TPacZPKcBz3dFz3cNns8Bz+mi53SD53Tg+Z7o+Z7BsxTwnCF6zjB4zgCeM0XPmQbP0sBzlug5y+A5C3i+L3q+b/AsAzxni56zDZ6zgecHoucHBs+ywHOO6DnH4DkHeM4VPecaPMsBz3mi5zyD5zzg+aHo+aHBszzwnC96zjd4zgeeH4meHxk8KwDPBaLnAoPnAuD5sej5scGzIvBcKHouNHguBJ6LRM9FBs9KwHOx6LnY4LkYeH4ien5i8KwMPJeInksMnkuA56ei56cGzyrAc6noudTguRR4LhM9lxk8qwLP5aLncoPncuD5mej5mcGzGvBcIXquMHiuAJ6fi56fGzyrA8+VoudKg+dK4PmF6PmFwbMG8Fwleq4yeK4CnqtFz9UGz5rAc43oucbguQZ4rhU91xo8awHPdaLnOoPnOuD5pej5pcGzNvBcL3quN3iuB54bRM8NBs86wHOj6LnR4LkReH4len5l8KwLPDeJnpsMnpuA59ei59cGz3rAc7PoudnguRl4fiN6fmPwrA88t4ieWwyeW4DnVtFzq8GzAfDcJnpuM3huA57fip7fGjwbAs/toud2g+d24Pmd6PmdwbMR8Nwheu4weO4AnjtFz50Gz8bAc5foucvguQt4fi96fm/wbAI8d4ueuw2eu4HnD6LnDwbPpsBzj+i5x+C5B3j+KHr+aPBsBjz3ip57DZ57gec+0XOfwbM58Nwveu43eO4Hnj+Jnj8ZPFsAzwOi5wGD5wHg+bPo+bPBsyXwPCh6HjR4HgSeh0TPQwbPVsDzsOh52OB5GHj+Inr+YvBsDTyPiJ5HDJ5HgOevouevBs82wPOo6HnU4HkUeP4mev5m8GwLPI+JnscMnseA53HR87jBsx3wPCF6njB4ngCev4uevxs82wPPk6LnSYPnSeD5h+j5h8GzA/A8JXqeMnieAp6nRc/TBs+OwPOM6HnG4HkGeJ4VPc8aPDsBz3Oi5zmD5zng+afo+afBszPwPC96njd4ngeef4mefxk8uwDPC6LnBYPnBeB5UfS8aPDsCjwviZ6XDJ6XgOdl0fOywbMb8Lwiel4xeF4Bnn+Lnn8bPLsDz6ui51WD51XgeU30vGbw7AE8r4ue1w2e14HnDdHzhsGzJ/C8KXreNHjeBJ7/iJ7/GDx7Ac9bouctg+ct4Pmv6PmvwfN54Hlb9Lxt8LwNPP8TPf8zePYGnndEzzsGzzvA867oedfg2Qd43hM97xk87wHP0A8LPBLjn/+HZ+jrYuvZF3jGya55xskee8/7f3ZMs3FFz7gGz37AM57oGc/gGQ94Pip6Pmrw7A8844ue8Q2e8YFnAtEzgcFzAPBMKHomNHgmBJ6JRM9EBs+BwDOx6JnY4JkYeCYRPZMYPF8AnklFz6QGz6TAM5nomczgOQh4Jhc9kxs8kwPPFKJnCoPnYOCZUvRMafBMCTxTiZ6pDJ5DgGdq0TO1wTM18HxM9HzM4Pki8EwjeqYxeKYBnmlFz7QGz6HAM53omc7gmQ54Pi56Pm7wfAl4phc90xs80wPPJ0TPJwyew4BnBtEzg8EzA/B8UvR80uD5MvDMKHpmNHhmBJ6ZRM9MBs/hwDOz6JnZ4JkZeD4lej5l8BwBPLOInlkMnlmAZ0D0DBg8RwLPKNEzyuAZBTyzip5ZDZ6vAM9somc2g2c24Jld9Mxu8BwFPHOInjkMnjmAZ07RM6fB81XgmUv0zGXwzAU8c4ueuQ2eo4FnHtEzj8EzD/DMK3rmNXiOAZ75RM98Bs98wDO/6Jnf4DkWeBYQPQsYPAsAz4KiZ0GD52vAs5DoWcjgWQh4FhY9Cxs8xwHPIqJnEYNnEeD5tOj5tMHzdeBZVPQsavAsCjyfET2fMXiOB57FRM9iBs9iwPNZ0fNZg+cbwLO46Fnc4FkceJYQPUsYPCcAz5KiZ0mDZ0ng+Zzo+ZzBcyLwLCV6ljJ4lgKepUXP0gbPScCzjOhZxuBZBniWFT3LGjzfBJ7lRM9yBs9ywLO86Fne4DkZeFYQPSsYPCsAz4qiZ0WD51vAs5LoWcngWQl4VhY9Kxs8pwDPKqJnFYNnFeBZVfSsavB8G3hWEz2rGTyrAc/qomd1g+dU4FlD9Kxh8KwBPGuKnjUNnu8Az1qiZy2DZy3gWVv0rG3wnAY864iedQyedYBnXdGzrsHzXeBZT/SsZ/CsBzzri571DZ7TgWcD0bOBwbMB8GwoejY0eL4HPBuJno0Mno2AZ2PRs7HBcwbwbCJ6NjF4NgGeTUXPpgbPmcCzmejZzODZDHg2Fz2bGzxnAc8WomcLg2cL4NlS9Gxp8HwfeLYSPVsZPFsBz9aiZ2uD52zg2Ub0bGPwbAM824qebQ2eHwDPdqJnO4NnO+DZXvRsb/CcAzw7iJ4dDJ4dgGdH0bOjwXMu8OwkenYyeHYCnp1Fz84Gz3nAs4vo2cXg2QV4dhU9uxo8PwSe3UTPbgbPbsCzu+jZ3eA5H3j2ED17GDx7AM+eomdPg+dHwLOX6NnL4NkLeD4vej5v8FwAPHuLnr0Nnr2BZx/Rs4/B82Pg2Vf07Gvw7As8+4me/QyeC4Fnf9Gzv8GzP/AcIHoOMHguAp4DRc+BBs+BwPMF0fMFg+di4DlI9Bxk8BwEPAeLnoMNnp8AzyGi5xCD5xDg+aLo+aLBcwnwHCp6DjV4DgWeL4meLxk8PwWew0TPYQbPYcDzZdHzZYPnUuA5XPQcbvAcDjxHiJ4jDJ7LgOdI0XOkwXMk8HxF9HzF4LkceI4SPUcZPEcBz1dFz1cNnp8Bz9Gi52iD52jgOUb0HGPwXAE8x4qeYw2eY4Hna6LnawbPz4HnONFznMFzHPB8XfR83eC5EniOFz3HGzzHA883RM83DJ5fAM8JoucEg+cE4DlR9Jxo8FwFPCeJnpMMnpOA55ui55sGz9XAc7LoOdngORl4viV6vmXwXAM8p4ieUwyeU4Dn26Ln2wbPtcBzqug51eA5FXi+I3q+Y/BcBzyniZ7TDJ7TgOe7oue7Bs8vged00XO6wXM68HxP9HzP4LkeeM4QPWcYPGcAz5mi50yD5wbgOUv0nGXwnAU83xc93zd4bgSes0XP2QbP2cDzA9HzA4PnV8Bzjug5x+A5B3jOFT3nGjw3Ac95ouc8g+c84Pmh6PmhwfNr4Dlf9Jxv8JwPPD8SPT8yeG4GngtEzwUGzwXA82PR82OD5zfAc6HoudDguRB4LhI9Fxk8twDPxaLnYoPnYuD5iej5icFzK/BcInouMXguAZ6fip6fGjy3Ac+loudSg+dS4LlM9Fxm8PwWeC4XPZcbPJcDz89Ez88MntuB5wrRc4XBcwXw/Fz0/Nzg+R3wXCl6rjR4rgSeX4ieXxg8dwDPVaLnKoPnKuC5WvRcbfDcCTzXiJ5rDJ5rgOda0XOtwXMX8Fwneq4zeK4Dnl+Knl8aPL8HnutFz/UGz/XAc4PoucHguRt4bhQ9Nxo8NwLPr0TPrwyePwDPTaLnJoPnJuD5tej5tcFzD/DcLHpuNnhuBp7fiJ7fGDx/BJ5bRM8tBs8twHOr6LnV4LkXeG4TPbcZPLcBz29Fz28NnvuA53bRc7vBczvw/E70/M7guR947hA9dxg8dwDPnaLnToPnT8Bzl+i5y+C5C3h+L3p+b/A8ADx3i567DZ67gecPoucPBs+fgece0XOPwXMP8PxR9PzR4HkQeO4VPfcaPPcCz32i5z6D5yHguV/03G/w3A88fxI9fzJ4HgaeB0TPAwbPA8DzZ9HzZ4PnL8DzoOh50OB5EHgeEj0PGTyPAM/Doudhg+dh4PmL6PmLwfNX4HlE9Dxi8DwCPH8VPX81eB4FnkdFz6MGz6PA8zfR8zeD52/A85joeczgeQx4Hhc9jxs8jwHPE6LnCYPnCeD5u+j5u8HzOPA8KXqeNHieBJ5/iJ5/GDxPAM9Toucpg+cp4Hla9Dxt8PwdeJ4RPc8YPM8Az7Oi51mD50ngeU70PGfwPAc8/xQ9/zR4/gE8z4ue5w2e54HnX6LnXwbPU8Dzguh5weB5AXheFD0vGjxPA89Louclg+cl4HlZ9Lxs8DwDPK+InlcMnleA59+i598Gz7PA86roedXgeRV4XhM9rxk8zwHP66LndYPndeB5Q/S8YfD8E3jeFD1vGjxvAs9/RM9/DJ7ngect0fOWwfMW8PxX9PzX4PkX8Lwtet42eN4Gnv+Jnv8ZPC8Azzui5x2D5x3geVf0vGvwvAg874me9wye94DnIzk0z9DXxdbzEvCMk0PzjJMj9p73/+yYZuOKnnENnpeBZzzRM57BMx7wfFT0fNTgeQV4xhc94xs84wPPBKJnAoPn38AzoeiZ0OCZEHgmEj0TGTyvAs/Eomdig2di4JlE9Exi8LwGPJOKnkkNnkmBZzLRM5nB8zrwTC56Jjd4JgeeKUTPFAbPG8AzpeiZ0uCZEnimEj1TGTxvAs/Uomdqg2dq4PmY6PmYwfMf4JlG9Exj8EwDPNOKnmkNnreAZzrRM53BMx3wfFz0fNzg+S/wTC96pjd4pgeeT4ieTxg8bwPPDKJnBoNnBuD5pOj5pMHzP+CZUfTMaPDMCDwziZ6ZDJ53gGdm0TOzwTMz8HxK9HzK4HkXeGYRPbMYPLMAz4DoGTB43gOeUaJnlMEzCnhmFT2zGjwfSfzwnzOb6JnN4JkNeGYXPbMbPOMAzxyiZw6DZw7gmVP0zGnwjAs8c4meuQyeuYBnbtEzt8EzHvDMI3rmMXjmAZ55Rc+8Bs9HgWc+0TOfwTMf8MwveuY3eMYHngVEzwIGzwLAs6DoWdDgmQB4FhI9Cxk8CwHPwqJnYYNnQuBZRPQsYvAsAjyfFj2fNngmAp5FRc+iBs+iwPMZ0fMZg2di4FlM9Cxm8CwGPJ8VPZ81eCYBnsVFz+IGz+LAs4ToWcLgmRR4lhQ9Sxo8SwLP50TP5wyeyYBnKdGzlMGzFPAsLXqWNngmB55lRM8yBs8ywLOs6FnW4JkCeJYTPcsZPMsBz/KiZ3mDZ0rgWUH0rGDwrAA8K4qeFQ2eqYBnJdGzksGzEvCsLHpWNnimBp5VRM8qBs8qwLOq6FnV4PkY8KwmelYzeFYDntVFz+oGzzTAs4boWcPgWQN41hQ9axo80wLPWqJnLYNnLeBZW/SsbfBMBzzriJ51DJ51gGdd0bOuwfNx4FlP9Kxn8KwHPOuLnvUNnumBZwPRs4HBswHwbCh6NjR4PgE8G4mejQyejYBnY9GzscEzA/BsIno2MXg2AZ5NRc+mBs8ngWcz0bOZwbMZ8GwuejY3eGYEni1EzxYGzxbAs6Xo2dLgmQl4thI9Wxk8WwHP1qJna4NnZuDZRvRsY/BsAzzbip5tDZ5PAc92omc7g2c74Nle9Gxv8MwCPDuInh0Mnh2AZ0fRs6PBMwA8O4menQyenYBnZ9Gzs8EzCnh2ET27GDy7AM+uomdXg2dW4NlN9Oxm8OwGPLuLnt0NntmAZw/Rs4fBswfw7Cl69jR4ZgeevUTPXgbPXsDzedHzeYNnDuDZW/TsbfDsDTz7iJ59DJ45gWdf0bOvwbMv8OwnevYzeOYCnv1Fz/4Gz/7Ac4DoOcDgmRt4DhQ9Bxo8BwLPF0TPFwyeeYDnINFzkMFzEPAcLHoONnjmBZ5DRM8hBs8hwPNF0fNFg2c+4DlU9Bxq8BwKPF8SPV8yeOYHnsNEz2EGz2HA82XR82WDZwHgOVz0HG7wHA48R4ieIwyeBYHnSNFzpMFzJPB8RfR8xeBZCHiOEj1HGTxHAc9XRc9XDZ6Fgedo0XO0wXM08Bwjeo4xeBYBnmNFz7EGz7HA8zXR8zWD59PAc5zoOc7gOQ54vi56vm7wLAo8x4ue4w2e44HnG6LnGwbPZ4DnBNFzgsFzAvCcKHpONHgWA56TRM9JBs9JwPNN0fNNg+ezwHOy6DnZ4DkZeL4ler5l8CwOPKeInlMMnlOA59ui59sGzxLAc6roOdXgORV4viN6vmPwLAk8p4me0wye04Dnu6LnuwbP54DndNFzusFzOvB8T/R8z+BZCnjOED1nGDxnAM+ZoudMg2dp4DlL9Jxl8JwFPN8XPd83eJYBnrNFz9kGz9nA8wPR8wODZ1ngOUf0nGPwnAM854qecw2e5YDnPNFznsFzHvD8UPT80OBZHnjOFz3nGzznA8+PRM+PDJ4VgOcC0XOBwXMB8PxY9PzY4FkReC4UPRcaPBcCz0Wi5yKDZyXguVj0XGzwXAw8PxE9PzF4VgaeS0TPJQbPJcDzU9HzU4NnFeC5VPRcavBcCjyXiZ7LDJ5Vgedy0XO5wXM58PxM9PzM4FkNeK4QPVcYPFcAz89Fz88NntWB50rRc6XBcyXw/EL0/MLgWQN4rhI9Vxk8VwHP1aLnaoNnTeC5RvRcY/BcAzzXip5rDZ61gOc60XOdwXMd8PxS9PzS4FkbeK4XPdcbPNcDzw2i5waDZx3guVH03Gjw3Ag8vxI9vzJ41gWem0TPTQbPTcDza9Hza4NnPeC5WfTcbPDcDDy/ET2/MXjWB55bRM8tBs8twHOr6LnV4NkAeG4TPbcZPLcBz29Fz28Nng2B53bRc7vBczvw/E70/M7g2Qh47hA9dxg8dwDPnaLnToNnY+C5S/TcZfDcBTy/Fz2/N3g2AZ67Rc/dBs/dwPMH0fMHg2dT4LlH9Nxj8NwDPH8UPX80eDYDnntFz70Gz73Ac5/ouc/g2Rx47hc99xs89wPPn0TPnwyeLYDnAdHzgMHzAPD8WfT82eDZEngeFD0PGjwPAs9Douchg2cr4HlY9Dxs8DwMPH8RPX8xeLYGnkdEzyMGzyPA81fR81eDZxvgeVT0PGrwPAo8fxM9fzN4tgWex0TPYwbPY8DzuOh53ODZDnieED1PGDxPAM/fRc/fDZ7tgedJ0fOkwfMk8PxD9PzD4NkBeJ4SPU8ZPE8Bz9Oi52mDZ0fgeUb0PGPwPAM8z4qeZw2enYDnOdHznMHzHPD8U/T80+DZGXieFz3PGzzPA8+/RM+/DJ5dgOcF0fOCwfMC8Lwoel40eHYFnpdEz0sGz0vA87Loedng2Q14XhE9rxg8rwDPv0XPvw2e3YHnVdHzqsHzKvC8JnpeM3j2AJ7XRc/rBs/rwPOG6HnD4NkTeN4UPW8aPG8Cz39Ez38Mnr2A5y3R85bB8xbw/Ff0/Nfg+TzwvC163jZ43gae/4me/xk8ewPPO6LnHYPnHeB5V/S8a/DsAzzviZ73DJ73gOcjOTXP0NfF1rMv8IyTU/OMkzP2nvf/7Jhm44qecQ2e/YBnPNEznsEzHvB8VPR81ODZH3jGFz3jGzzjA88EomcCg+cA4JlQ9Exo8EwIPBOJnokMngOBZ2LRM7HBMzHwTCJ6JjF4vgA8k4qeSQ2eSYFnMtEzmcFzEPBMLnomN3gmB54pRM8UBs/BwDOl6JnS4JkSeKYSPVMZPIcAz9SiZ2qDZ2rg+Zjo+ZjB80XgmUb0TGPwTAM804qeaQ2eQ4FnOtEzncEzHfB8XPR83OD5EvBML3qmN3imB55PiJ5PGDyHAc8MomcGg2cG4Pmk6PmkwfNl4JlR9Mxo8MwIPDOJnpkMnsOBZ2bRM7PBMzPwfEr0fMrgOQJ4ZhE9sxg8swDPgOgZMHiOBJ5RomeUwTMKeGYVPbMaPF8BntlEz2wGz2zAM7vomd3gOQp45hA9cxg8cwDPnKJnToPnq8Azl+iZy+CZC3jmFj1zGzxHA888omceg2ce4JlX9Mxr8BwDPPOJnvkMnvmAZ37RM7/BcyzwLCB6FjB4FgCeBUXPggbP14BnIdGzkMGzEPAsLHoWNniOA55FRM8iBs8iwPNp0fNpg+frwLOo6FnU4FkUeD4jej5j8BwPPIuJnsUMnsWA57Oi57MGzzeAZ3HRs7jBszjwLCF6ljB4TgCeJUXPkgbPksDzOdHzOYPnROBZSvQsZfAsBTxLi56lDZ6TgGcZ0bOMwbMM8CwrepY1eL4JPMuJnuUMnuWAZ3nRs7zBczLwrCB6VjB4VgCeFUXPigbPt4BnJdGzksGzEvCsLHpWNnhOAZ5VRM8qBs8qwLOq6FnV4Pk28KwmelYzeFYDntVFz+oGz6nAs4boWcPgWQN41hQ9axo83wGetUTPWgbPWsCztuhZ2+A5DXjWET3rGDzrAM+6omddg+e7wLOe6FnP4FkPeNYXPesbPKcDzwaiZwODZwPg2VD0bGjwfA94NhI9Gxk8GwHPxqJnY4PnDODZRPRsYvBsAjybip5NDZ4zgWcz0bOZwbMZ8GwuejY3eM4Cni1EzxYGzxbAs6Xo2dLg+T7wbCV6tjJ4tgKerUXP1gbP2cCzjejZxuDZBni2FT3bGjw/AJ7tRM92Bs92wLO96Nne4DkHeHYQPTsYPDsAz46iZ0eD51zg2Un07GTw7AQ8O4uenQ2e84BnF9Gzi8GzC/DsKnp2NXh+CDy7iZ7dDJ7dgGd30bO7wXM+8OwhevYwePYAnj1Fz54Gz4+AZy/Rs5fBsxfwfF70fN7guQB49hY9exs8ewPPPqJnH4Pnx8Czr+jZ1+DZF3j2Ez37GTwXAs/+omd/g2d/4DlA9Bxg8FwEPAeKngMNngOB5wui5wsGz8XAc5DoOcjgOQh4DhY9Bxs8PwGeQ0TPIQbPIcDzRdHzRYPnEuA5VPQcavAcCjxfEj1fMnh+CjyHiZ7DDJ7DgOfLoufLBs+lwHO46Dnc4DkceI4QPUcYPJcBz5Gi50iD50jg+Yro+YrBcznwHCV6jjJ4jgKer4qerxo8PwOeo0XP0QbP0cBzjOg5xuC5AniOFT3HGjzHAs/XRM/XDJ6fA89xouc4g+c44Pm66Pm6wXMl8Bwveo43eI4Hnm+Inm8YPL8AnhNEzwkGzwnAc6LoOdHguQp4ThI9Jxk8JwHPN0XPNw2eq4HnZNFzssFzMvB8S/R8y+C5BnhOET2nGDynAM+3Rc+3DZ5rgedU0XOqwXMq8HxH9HzH4LkOeE4TPacZPKcBz3dFz3cNnl8Cz+mi53SD53Tg+Z7o+Z7Bcz3wnCF6zjB4zgCeM0XPmQbPDcBzlug5y+A5C3i+L3q+b/DcCDxni56zDZ6zgecHoucHBs+vgOcc0XOOwXMO8Jwres41eG4CnvNEz3kGz3nA80PR80OD59fAc77oOd/gOR94fiR6fmTw3Aw8F4ieCwyeC4Dnx6LnxwbPb4DnQtFzocFzIfBcJHouMnhuAZ6LRc/FBs/FwPMT0fMTg+dW4LlE9Fxi8FwCPD8VPT81eG4DnktFz6UGz6XAc5nouczg+S3wXC56Ljd4Lgeen4menxk8twPPFaLnCoPnCuD5uej5ucHzO+C5UvRcafBcCTy/ED2/MHjuAJ6rRM9VBs9VwHO16Lna4LkTeK4RPdcYPNcAz7Wi51qD5y7guU70XGfwXAc8vxQ9vzR4fg8814ue6w2e64HnBtFzg8FzN/DcKHpuNHhuBJ5fiZ5fGTx/AJ6bRM9NBs9NwPNr0fNrg+ce4LlZ9Nxs8NwMPL8RPb8xeP4IPLeInlsMnluA51bRc6vBcy/w3CZ6bjN4bgOe34qe3xo89wHP7aLndoPnduD5nej5ncFzP/DcIXruMHjuAJ47Rc+dBs+fgOcu0XOXwXMX8Pxe9Pze4HkAeO4WPXcbPHcDzx9Ezx8Mnj8Dzz2i5x6D5x7g+aPo+aPB8yDw3Ct67jV47gWe+0TPfQbPQ8Bzv+i53+C5H3j+JHr+ZPA8DDwPiJ4HDJ4HgOfPoufPBs9fgOdB0fOgwfMg8Dwkeh4yeB4BnodFz8MGz8PA8xfR8xeD56/A84joecTgeQR4/ip6/mrwPAo8j4qeRw2eR4Hnb6LnbwbP34DnMdHzmMHzGPA8LnoeN3geA54nRM8TBs8TwPN30fN3g+dx4HlS9Dxp8DwJPP8QPf8weJ4AnqdEz1MGz1PA87Toedrg+TvwPCN6njF4ngGeZ0XPswbPk8DznOh5zuB5Dnj+KXr+afD8A3ieFz3PGzzPA8+/RM+/DJ6ngOcF0fOCwfMC8Lwoel40eJ4GnpdEz0sGz0vA87LoedngeQZ4XhE9rxg8rwDPv0XPvw2eZ4HnVdHzqsHzKvC8JnpeM3ieA57XRc/rBs/rwPOG6HnD4Pkn8Lwpet40eN4Env+Inv8YPM8Dz1ui5y2D5y3g+a/o+a/B8y/geVv0vG3wvA08/xM9/zN4XgCed0TPOwbPO8Dzruh51+B5EXjeEz3vGTzvAc9Hcmmeoa+Lrecl4Bknl+YZJ1fsPe//2THNxhU94xo8LwPPeKJnPINnPOD5qOj5qMHzCvCML3rGN3jGB54JRM8EBs+/gWdC0TOhwTMh8EwkeiYyeF4FnolFz8QGz8TAM4nomcTgeQ14JhU9kxo8kwLPZKJnMoPndeCZXPRMbvBMDjxTiJ4pDJ43gGdK0TOlwTMl8EwleqYyeN4EnqlFz9QGz9TA8zHR8zGD5z/AM43omcbgmQZ4phU90xo8bwHPdKJnOoNnOuD5uOj5uMHzX+CZXvRMb/BMDzyfED2fMHjeBp4ZRM8MBs8MwPNJ0fNJg+d/wDOj6JnR4JkReGYSPTMZPO8Az8yiZ2aDZ2bg+ZTo+ZTB8y7wzCJ6ZjF4ZgGeAdEzYPC8BzyjRM8og2cU8MwqemY1eD6S5OE/ZzbRM5vBMxvwzC56Zjd4xgGeOUTPHAbPHMAzp+iZ0+AZN9nDf85comcug2cu4Jlb9Mxt8IwHPPOInnkMnnmAZ17RM6/B81HgmU/0zGfwzAc884ue+Q2e8YFnAdGzgMGzAPAsKHoWNHgmAJ6FRM9CBs9CwLOw6FnY4JkQeBYRPYsYPIsAz6dFz6cNnomAZ1HRs6jBsyjwfEb0fMbgmRh4FhM9ixk8iwHPZ0XPZw2eSYBncdGzuMGzOPAsIXqWMHgmBZ4lRc+SBs+SwPM50fM5g2cy4FlK9Cxl8CwFPEuLnqUNnsmBZxnRs4zBswzwLCt6ljV4pgCe5UTPcgbPcsCzvOhZ3uCZEnhWED0rGDwrAM+KomdFg2cq4FlJ9Kxk8KwEPCuLnpUNnqmBZxXRs4rBswrwrCp6VjV4PgY8q4me1Qye1YBnddGzusEzDfCsIXrWMHjWAJ41Rc+aBs+0wLOW6FnL4FkLeNYWPWsbPNMBzzqiZx2DZx3gWVf0rGvwfBx41hM96xk86wHP+qJnfYNneuDZQPRsYPBsADwbip4NDZ5PAM9Gomcjg2cj4NlY9Gxs8MwAPJuInk0Mnk2AZ1PRs6nB80ng2Uz0bGbwbAY8m4uezQ2eGYFnC9GzhcGzBfBsKXq2NHhmAp6tRM9WBs9WwLO16Nna4JkZeLYRPdsYPNsAz7aiZ1uD51PAs53o2c7g2Q54thc92xs8swDPDqJnB4NnB+DZUfTsaPAMAM9Oomcng2cn4NlZ9Oxs8IwCnl1Ezy4Gzy7As6vo2dXgmRV4dhM9uxk8uwHP7qJnd4NnNuDZQ/TsYfDsATx7ip49DZ7ZgWcv0bOXwbMX8Hxe9Hze4JkDePYWPXsbPHsDzz6iZx+DZ07g2Vf07Gvw7As8+4me/QyeuYBnf9Gzv8GzP/AcIHoOMHjmBp4DRc+BBs+BwPMF0fMFg2ce4DlI9Bxk8BwEPAeLnoMNnnmB5xDRc4jBcwjwfFH0fNHgmQ94DhU9hxo8hwLPl0TPlwye+YHnMNFzmMFzGPB8WfR82eBZAHgOFz2HGzyHA88RoucIg2dB4DlS9Bxp8BwJPF8RPV8xeBYCnqNEz1EGz1HA81XR81WDZ2HgOVr0HG3wHA08x4ieYwyeRYDnWNFzrMFzLPB8TfR8zeD5NPAcJ3qOM3iOA56vi56vGzyLAs/xoud4g+d44PmG6PmGwfMZ4DlB9Jxg8JwAPCeKnhMNnsWA5yTRc5LBcxLwfFP0fNPg+SzwnCx6TjZ4Tgaeb4mebxk8iwPPKaLnFIPnFOD5tuj5tsGzBPCcKnpONXhOBZ7viJ7vGDxLAs9pouc0g+c04Pmu6PmuwfM54Dld9Jxu8JwOPN8TPd8zeJYCnjNEzxkGzxnAc6boOdPgWRp4zhI9Zxk8ZwHP90XP9w2eZYDnbNFztsFzNvD8QPT8wOBZFnjOET3nGDznAM+5oudcg2c54DlP9Jxn8JwHPD8UPT80eJYHnvNFz/kGz/nA8yPR8yODZwXguUD0XGDwXAA8PxY9PzZ4VgSeC0XPhQbPhcBzkei5yOBZCXguFj0XGzwXA89PRM9PDJ6VgecS0XOJwXMJ8PxU9PzU4FkFeC4VPZcaPJcCz2Wi5zKDZ1XguVz0XG7wXA48PxM9PzN4VgOeK0TPFQbPFcDzc9Hzc4NndeC5UvRcafBcCTy/ED2/MHjWAJ6rRM9VBs9VwHO16Lna4FkTeK4RPdcYPNcAz7Wi51qDZy3guU70XGfwXAc8vxQ9vzR41gae60XP9QbP9cBzg+i5weBZB3huFD03Gjw3As+vRM+vDJ51gecm0XOTwXMT8Pxa9Pza4FkPeG4WPTcbPDcDz29Ez28MnvWB5xbRc4vBcwvw3Cp6bjV4NgCe20TPbQbPbcDzW9HzW4NnQ+C5XfTcbvDcDjy/Ez2/M3g2Ap47RM8dBs8dwHOn6LnT4NkYeO4SPXcZPHcBz+9Fz+8Nnk2A527Rc7fBczfw/EH0/MHg2RR47hE99xg89wDPH0XPHw2ezYDnXtFzr8FzL/DcJ3ruM3g2B577Rc/9Bs/9wPMn0fMng2cL4HlA9Dxg8DwAPH8WPX82eLYEngdFz4MGz4PA85Doecjg2Qp4HhY9Dxs8DwPPX0TPXwyerYHnEdHziMHzCPD8VfT81eDZBngeFT2PGjyPAs/fRM/fDJ5tgecx0fOYwfMY8Dwueh43eLYDnidEzxMGzxPA83fR83eDZ3vgeVL0PGnwPAk8/xA9/zB4dgCep0TPUwbPU8DztOh52uDZEXieET3PGDzPAM+zoudZg2cn4HlO9Dxn8DwHPP8UPf80eHYGnudFz/MGz/PA8y/R8y+DZxfgeUH0vGDwvAA8L4qeFw2eXYHnJdHzksHzEvC8LHpeNnh2A55XRM8rBs8rwPNv0fNvg2d34HlV9Lxq8LwKPK+JntcMnj2A53XR87rB8zrwvCF63jB49gSeN0XPmwbPm8DzH9HzH4NnL+B5S/S8ZfC8BTz/FT3/NXg+Dzxvi563DZ63ged/oud/Bs/ewPOO6HnH4HkHeN4VPe8aPPsAz3ui5z2D5z3g+UhuzTP0dbH17As84+TWPOPkjr3n/T87ptm4omdcg2c/4BlP9Ixn8IwHPB8VPR81ePYHnvFFz/gGz/jAM4HomcDgOQB4JhQ9Exo8EwLPRKJnIoPnQOCZWPRMbPBMDDyTiJ5JDJ4vAM+komdSg2dS4JlM9Exm8BwEPJOLnskNnsmBZwrRM4XBczDwTCl6pjR4pgSeqUTPVAbPIcAzteiZ2uCZGng+Jno+ZvB8EXimET3TGDzTAM+0omdag+dQ4JlO9Exn8EwHPB8XPR83eL4EPNOLnukNnumB5xOi5xMGz2HAM4PomcHgmQF4Pil6PmnwfBl4ZhQ9Mxo8MwLPTKJnJoPncOCZWfTMbPDMDDyfEj2fMniOAJ5ZRM8sBs8swDMgegYMniOBZ5ToGWXwjAKeWUXPrAbPV4BnNtEzm8EzG/DMLnpmN3iOAp45RM8cBs8cwDOn6JnT4Pkq8MwleuYyeOYCnrlFz9wGz9HAM4/omcfgmQd45hU98xo8xwDPfKJnPoNnPuCZX/TMb/AcCzwLiJ4FDJ4FgGdB0bOgwfM14FlI9Cxk8CwEPAuLnoUNnuOAZxHRs4jBswjwfFr0fNrg+TrwLCp6FjV4FgWez4iezxg8xwPPYqJnMYNnMeD5rOj5rMHzDeBZXPQsbvAsDjxLiJ4lDJ4TgGdJ0bOkwbMk8HxO9HzO4DkReJYSPUsZPEsBz9KiZ2mD5yTgWUb0LGPwLAM8y4qeZQ2ebwLPcqJnOYNnOeBZXvQsb/CcDDwriJ4VDJ4VgGdF0bOiwfMt4FlJ9Kxk8KwEPCuLnpUNnlOAZxXRs4rBswrwrCp6VjV4vg08q4me1Qye1YBnddGzusFzKvCsIXrWMHjWAJ41Rc+aBs93gGct0bOWwbMW8KwtetY2eE4DnnVEzzoGzzrAs67oWdfg+S7wrCd61jN41gOe9UXP+gbP6cCzgejZwODZAHg2FD0bGjzfA56NRM9GBs9GwLOx6NnY4DkDeDYRPZsYPJsAz6aiZ1OD50zg2Uz0bGbwbAY8m4uezQ2es4BnC9GzhcGzBfBsKXq2NHi+DzxbiZ6tDJ6tgGdr0bO1wXM28GwjerYxeLYBnm1Fz7YGzw+AZzvRs53Bsx3wbC96tjd4zgGeHUTPDgbPDsCzo+jZ0eA5F3h2Ej07GTw7Ac/Oomdng+c84NlF9Oxi8OwCPLuKnl0Nnh8Cz26iZzeDZzfg2V307G7wnA88e4iePQyePYBnT9Gzp8HzI+DZS/TsZfDsBTyfFz2fN3guAJ69Rc/eBs/ewLOP6NnH4Pkx8OwrevY1ePYFnv1Ez34Gz4XAs7/o2d/g2R94DhA9Bxg8FwHPgaLnQIPnQOD5guj5gsFzMfAcJHoOMngOAp6DRc/BBs9PgOcQ0XOIwXMI8HxR9HzR4LkEeA4VPYcaPIcCz5dEz5cMnp8Cz2Gi5zCD5zDg+bLo+bLBcynwHC56Djd4DgeeI0TPEQbPZcBzpOg50uA5Eni+Inq+YvBcDjxHiZ6jDJ6jgOerouerBs/PgOdo0XO0wXM08Bwjeo4xeK4AnmNFz7EGz7HA8zXR8zWD5+fAc5zoOc7gOQ54vi56vm7wXAk8x4ue4w2e44HnG6LnGwbPL4DnBNFzgsFzAvCcKHpONHiuAp6TRM9JBs9JwPNN0fNNg+dq4DlZ9Jxs8JwMPN8SPd8yeK4BnlNEzykGzynA823R822D51rgOVX0nGrwnAo83xE93zF4rgOe00TPaQbPacDzXdHzXYPnl8Bzuug53eA5HXi+J3q+Z/BcDzxniJ4zDJ4zgOdM0XOmwXMD8Jwles4yeM4Cnu+Lnu8bPDcCz9mi52yD52zg+YHo+YHB8yvgOUf0nGPwnAM854qecw2em4DnPNFznsFzHvD8UPT80OD5NfCcL3rON3jOB54fiZ4fGTw3A88FoucCg+cC4Pmx6PmxwfMb4LlQ9Fxo8FwIPBeJnosMnluA52LRc7HBczHw/ET0/MTguRV4LhE9lxg8lwDPT0XPTw2e24DnUtFzqcFzKfBcJnouM3h+CzyXi57LDZ7LgednoudnBs/twHOF6LnC4LkCeH4uen5u8PwOeK4UPVcaPFcCzy9Ezy8MnjuA5yrRc5XBcxXwXC16rjZ47gSea0TPNQbPNcBzrei51uC5C3iuEz3XGTzXAc8vRc8vDZ7fA8/1oud6g+d64LlB9Nxg8NwNPDeKnhsNnhuB51ei51cGzx+A5ybRc5PBcxPw/Fr0/NrguQd4bhY9Nxs8NwPPb0TPbwyePwLPLaLnFoPnFuC5VfTcavDcCzy3iZ7bDJ7bgOe3oue3Bs99wHO76Lnd4LkdeH4nen5n8NwPPHeInjsMnjuA507Rc6fB8yfguUv03GXw3AU8vxc9vzd4HgCeu0XP3QbP3cDzB9HzB4Pnz8Bzj+i5x+C5B3j+KHr+aPA8CDz3ip57DZ57gec+0XOfwfMQ8Nwveu43eO4Hnj+Jnj8ZPA8DzwOi5wGD5wHg+bPo+bPB8xfgeVD0PGjwPAg8D4mehwyeR4DnYdHzsMHzMPD8RfT8xeD5K/A8InoeMXgeAZ6/ip6/GjyPAs+joudRg+dR4Pmb6PmbwfM34HlM9Dxm8DwGPI+LnscNnseA5wnR84TB8wTw/F30/N3geRx4nhQ9Txo8TwLPP0TPPwyeJ4DnKdHzlMHzFPA8LXqeNnj+DjzPiJ5nDJ5ngOdZ0fOswfMk8Dwnep4zeJ4Dnn+Knn8aPP8AnudFz/MGz/PA8y/R8y+D5yngeUH0vGDwvAA8L4qeFw2ep4HnJdHzksHzEvC8LHpeNnieAZ5XRM8rBs8rwPNv0fNvg+dZ4HlV9Lxq8LwKPK+JntcMnueA53XR87rB8zrwvCF63jB4/gk8b4qeNw2eN4HnP6LnPwbP88Dzluh5y+B5C3j+K3r+a/D8C3jeFj1vGzxvA8//RM//DJ4XgOcd0fOOwfMO8Lwret41eF4EnvdEz3sGz3vA85E8mmfo62LreQl4xsmjecbJE3vP+392TLNxRc+4Bs/LwDOe6BnP4BkPeD4qej5q8LwCPOOLnvENnvGBZwLRM4HB82/gmVD0TGjwTAg8E4meiQyeV4FnYtEzscEzMfBMInomMXheA55JRc+kBs+kwDOZ6JnM4HkdeCYXPZMbPJMDzxSiZwqD5w3gmVL0TGnwTAk8U4meqQyeN4FnatEztcEzNfB8TPR8zOD5D/BMI3qmMXimAZ5pRc+0Bs9bwDOd6JnO4JkOeD4uej5u8PwXeKYXPdMbPNMDzydEzycMnreBZwbRM4PBMwPwfFL0fNLg+R/wzCh6ZjR4ZgSemUTPTAbPO8Azs+iZ2eCZGXg+JXo+ZfC8CzyziJ5ZDJ5ZgGdA9AwYPO8BzyjRM8rgGQU8s4qeWQ2ejyR/+M+ZTfTMZvDMBjyzi57ZDZ5xgGcO0TOHwTMH8MwpeuY0eMYFnrlEz1wGz1zAM7fomdvgGQ945hE98xg88wDPvKJnXoPno8Azn+iZz+CZD3jmFz3zGzzjA88ComcBg2cB4FlQ9Cxo8EwAPAuJnoUMnoWAZ2HRs7DBMyHwLCJ6FjF4FgGeT4ueTxs8EwHPoqJnUYNnUeD5jOj5jMEzMfAsJnoWM3gWA57Pip7PGjyTAM/iomdxg2dx4FlC9Cxh8EwKPEuKniUNniWB53Oi53MGz2TAs5ToWcrgWQp4lhY9Sxs8kwPPMqJnGYNnGeBZVvQsa/BMATzLiZ7lDJ7lgGd50bO8wTMl8KwgelYweFYAnhVFz4oGz1TAs5LoWcngWQl4VhY9Kxs8UwPPKqJnFYNnFeBZVfSsavB8DHhWEz2rGTyrAc/qomd1g2ca4FlD9Kxh8KwBPGuKnjUNnmmBZy3Rs5bBsxbwrC161jZ4pgOedUTPOgbPOsCzruhZ1+D5OPCsJ3rWM3jWA571Rc/6Bs/0wLOB6NnA4NkAeDYUPRsaPJ8Ano1Ez0YGz0bAs7Ho2djgmQF4NhE9mxg8mwDPpqJnU4Pnk8CzmejZzODZDHg2Fz2bGzwzAs8WomcLg2cL4NlS9Gxp8MwEPFuJnq0Mnq2AZ2vRs7XBMzPwbCN6tjF4tgGebUXPtgbPp4BnO9GzncGzHfBsL3q2N3hmAZ4dRM8OBs8OwLOj6NnR4BkAnp1Ez04Gz07As7Po2dngGQU8u4ieXQyeXYBnV9Gzq8EzK/DsJnp2M3h2A57dRc/uBs9swLOH6NnD4NkDePYUPXsaPLMDz16iZy+DZy/g+bzo+bzBMwfw7C169jZ49gaefUTPPgbPnMCzr+jZ1+DZF3j2Ez37GTxzAc/+omd/g2d/4DlA9Bxg8MwNPAeKngMNngOB5wui5wsGzzzAc5DoOcjgOQh4DhY9Bxs88wLPIaLnEIPnEOD5ouj5osEzH/AcKnoONXgOBZ4viZ4vGTzzA89houcwg+cw4Pmy6PmywbMA8Bwueg43eA4HniNEzxEGz4LAc6ToOdLgORJ4viJ6vmLwLAQ8R4meowyeo4Dnq6LnqwbPwsBztOg52uA5GniOET3HGDyLAM+xoudYg+dY4Pma6PmawfNp4DlO9Bxn8BwHPF8XPV83eBYFnuNFz/EGz/HA8w3R8w2D5zPAc4LoOcHgOQF4ThQ9Jxo8iwHPSaLnJIPnJOD5puj5psHzWeA5WfScbPCcDDzfEj3fMngWB55TRM8pBs8pwPNt0fNtg2cJ4DlV9Jxq8JwKPN8RPd8xeJYEntNEz2kGz2nA813R812D53PAc7roOd3gOR14vid6vmfwLAU8Z4ieMwyeM4DnTNFzpsGzNPCcJXrOMnjOAp7vi57vGzzLAM/Zoudsg+ds4PmB6PmBwbMs8Jwjes4xeM4BnnNFz7kGz3LAc57oOc/gOQ94fih6fmjwLA8854ue8w2e84HnR6LnRwbPCsBzgei5wOC5AHh+LHp+bPCsCDwXip4LDZ4Lgeci0XORwbMS8Fwsei42eC4Gnp+Inp8YPCsDzyWi5xKD5xLg+ano+anBswrwXCp6LjV4LgWey0TPZQbPqsBzuei53OC5HHh+Jnp+ZvCsBjxXiJ4rDJ4rgOfnoufnBs/qwHOl6LnS4LkSeH4hen5h8KwBPFeJnqsMnquA52rRc7XBsybwXCN6rjF4rgGea0XPtQbPWsBznei5zuC5Dnh+KXp+afCsDTzXi57rDZ7rgecG0XODwbMO8Nwoem40eG4Enl+Jnl8ZPOsCz02i5yaD5ybg+bXo+bXBsx7w3Cx6bjZ4bgae34ie3xg86wPPLaLnFoPnFuC5VfTcavBsADy3iZ7bDJ7bgOe3oue3Bs+GwHO76Lnd4LkdeH4nen5n8GwEPHeInjsMnjuA507Rc6fBszHw3CV67jJ47gKe34ue3xs8mwDP3aLnboPnbuD5g+j5g8GzKfDcI3ruMXjuAZ4/ip4/GjybAc+9oudeg+de4LlP9Nxn8GwOPPeLnvsNnvuB50+i508GzxbA84DoecDgeQB4/ix6/mzwbAk8D4qeBw2eB4HnIdHzkMGzFfA8LHoeNngeBp6/iJ6/GDxbA88joucRg+cR4Pmr6PmrwbMN8Dwqeh41eB4Fnr+Jnr8ZPNsCz2Oi5zGD5zHgeVz0PG7wbAc8T4ieJwyeJ4Dn76Ln7wbP9sDzpOh50uB5Enj+IXr+YfDsADxPiZ6nDJ6ngOdp0fO0wbMj8Dwjep4xeJ4BnmdFz7MGz07A85zoec7geQ54/il6/mnw7Aw8z4ue5w2e54HnX6LnXwbPLsDzguh5weB5AXheFD0vGjy7As9Louclg+cl4HlZ9Lxs8OwGPK+InlcMnleA59+i598Gz+7A86roedXgeRV4XhM9rxk8ewDP66LndYPndeB5Q/S8YfDsCTxvip43DZ43gec/ouc/Bs9ewPOW6HnL4HkLeP4rev5r8HweeN4WPW8bPG8Dz/9Ez/8Mnr2B5x3R847B8w7wvCt63jV49gGe90TPewbPe8DzkbyaZ+jrYuvZF3jGyat5xskbe8/7f3ZMs3FFz7gGz37AM57oGc/gGQ94Pip6Pmrw7A8844ue8Q2e8YFnAtEzgcFzAPBMKHomNHgmBJ6JRM9EBs+BwDOx6JnY4JkYeCYRPZMYPF8AnklFz6QGz6TAM5nomczgOQh4Jhc9kxs8kwPPFKJnCoPnYOCZUvRMafBMCTxTiZ6pDJ5DgGdq0TO1wTM18HxM9HzM4Pki8EwjeqYxeKYBnmlFz7QGz6HAM53omc7gmQ54Pi56Pm7wfAl4phc90xs80wPPJ0TPJwyew4BnBtEzg8EzA/B8UvR80uD5MvDMKHpmNHhmBJ6ZRM9MBs/hwDOz6JnZ4JkZeD4lej5l8BwBPLOInlkMnlmAZ0D0DBg8RwLPKNEzyuAZBTyzip5ZDZ6vAM9somc2g2c24Jld9Mxu8BwFPHOInjkMnjmAZ07RM6fB81XgmUv0zGXwzAU8c4ueuQ2eo4FnHtEzj8EzD/DMK3rmNXiOAZ75RM98Bs98wDO/6Jnf4DkWeBYQPQsYPAsAz4KiZ0GD52vAs5DoWcjgWQh4FhY9Cxs8xwHPIqJnEYNnEeD5tOj5tMHzdeBZVPQsavAsCjyfET2fMXiOB57FRM9iBs9iwPNZ0fNZg+cbwLO46Fnc4FkceJYQPUsYPCcAz5KiZ0mDZ0ng+Zzo+ZzBcyLwLCV6ljJ4lgKepUXP0gbPScCzjOhZxuBZBniWFT3LGjzfBJ7lRM9yBs9ywLO86Fne4DkZeFYQPSsYPCsAz4qiZ0WD51vAs5LoWcngWQl4VhY9Kxs8pwDPKqJnFYNnFeBZVfSsavB8G3hWEz2rGTyrAc/qomd1g+dU4FlD9Kxh8KwBPGuKnjUNnu8Az1qiZy2DZy3gWVv0rG3wnAY864iedQyedYBnXdGzrsHzXeBZT/SsZ/CsBzzri571DZ7TgWcD0bOBwbMB8GwoejY0eL4HPBuJno0Mno2AZ2PRs7HBcwbwbCJ6NjF4NgGeTUXPpgbPmcCzmejZzODZDHg2Fz2bGzxnAc8WomcLg2cL4NlS9Gxp8HwfeLYSPVsZPFsBz9aiZ2uD52zg2Ub0bGPwbAM824qebQ2eHwDPdqJnO4NnO+DZXvRsb/CcAzw7iJ4dDJ4dgGdH0bOjwXMu8OwkenYyeHYCnp1Fz84Gz3nAs4vo2cXg2QV4dhU9uxo8PwSe3UTPbgbPbsCzu+jZ3eA5H3j2ED17GDx7AM+eomdPg+dHwLOX6NnL4NkLeD4vej5v8FwAPHuLnr0Nnr2BZx/Rs4/B82Pg2Vf07Gvw7As8+4me/QyeC4Fnf9Gzv8GzP/AcIHoOMHguAp4DRc+BBs+BwPMF0fMFg+di4DlI9Bxk8BwEPAeLnoMNnp8AzyGi5xCD5xDg+aLo+aLBcwnwHCp6DjV4DgWeL4meLxk8PwWew0TPYQbPYcDzZdHzZYPnUuA5XPQcbvAcDjxHiJ4jDJ7LgOdI0XOkwXMk8HxF9HzF4LkceI4SPUcZPEcBz1dFz1cNnp8Bz9Gi52iD52jgOUb0HGPwXAE8x4qeYw2eY4Hna6LnawbPz4HnONFznMFzHPB8XfR83eC5EniOFz3HGzzHA883RM83DJ5fAM8JoucEg+cE4DlR9Jxo8FwFPCeJnpMMnpOA55ui55sGz9XAc7LoOdngORl4viV6vmXwXAM8p4ieUwyeU4Dn26Ln2wbPtcBzqug51eA5FXi+I3q+Y/BcBzyniZ7TDJ7TgOe7oue7Bs8vged00XO6wXM68HxP9HzP4LkeeM4QPWcYPGcAz5mi50yD5wbgOUv0nGXwnAU83xc93zd4bgSes0XP2QbP2cDzA9HzA4PnV8Bzjug5x+A5B3jOFT3nGjw3Ac95ouc8g+c84Pmh6PmhwfNr4Dlf9Jxv8JwPPD8SPT8yeG4GngtEzwUGzwXA82PR82OD5zfAc6HoudDguRB4LhI9Fxk8twDPxaLnYoPnYuD5iej5icFzK/BcInouMXguAZ6fip6fGjy3Ac+loudSg+dS4LlM9Fxm8PwWeC4XPZcbPJcDz89Ez88MntuB5wrRc4XBcwXw/Fz0/Nzg+R3wXCl6rjR4rgSeX4ieXxg8dwDPVaLnKoPnKuC5WvRcbfDcCTzXiJ5rDJ5rgOda0XOtwXMX8Fwneq4zeK4Dnl+Knl8aPL8HnutFz/UGz/XAc4PoucHguRt4bhQ9Nxo8NwLPr0TPrwyePwDPTaLnJoPnJuD5tej5tcFzD/DcLHpuNnhuBp7fiJ7fGDx/BJ5bRM8tBs8twHOr6LnV4LkXeG4TPbcZPLcBz29Fz28NnvuA53bRc7vBczvw/E70/M7guR947hA9dxg8dwDPnaLnToPnT8Bzl+i5y+C5C3h+L3p+b/A8ADx3i567DZ67gecPoucPBs+fgece0XOPwXMP8PxR9PzR4HkQeO4VPfcaPPcCz32i5z6D5yHguV/03G/w3A88fxI9fzJ4HgaeB0TPAwbPA8DzZ9HzZ4PnL8DzoOh50OB5EHgeEj0PGTyPAM/Doudhg+dh4PmL6PmLwfNX4HlE9Dxi8DwCPH8VPX81eB4FnkdFz6MGz6PA8zfR8zeD52/A85joeczgeQx4Hhc9jxs8jwHPE6LnCYPnCeD5u+j5u8HzOPA8KXqeNHieBJ5/iJ5/GDxPAM9Toucpg+cp4Hla9Dxt8PwdeJ4RPc8YPM8Az7Oi51mD50ngeU70PGfwPAc8/xQ9/zR4/gE8z4ue5w2e54HnX6LnXwbPU8Dzguh5weB5AXheFD0vGjxPA89Louclg+cl4HlZ9Lxs8DwDPK+InlcMnleA59+i598Gz7PA86roedXgeRV4XhM9rxk8zwHP66LndYPndeB5Q/S8YfD8E3jeFD1vGjxvAs9/RM9/DJ7ngect0fOWwfMW8PxX9PzX4PkX8Lwtet42eN4Gnv+Jnv8ZPC8Azzui5x2D5x3geVf0vGvwvAg874me9wye94DnI/k0z9DXxdbzEvCMk0/zjJMv9p73/+yYZuOKnnENnpeBZzzRM57BMx7wfFT0fNTgeQV4xhc94xs84wPPBKJnAoPn38AzoeiZ0OCZEHgmEj0TGTyvAs/Eomdig2di4JlE9Exi8LwGPJOKnkkNnkmBZzLRM5nB8zrwTC56Jjd4JgeeKUTPFAbPG8AzpeiZ0uCZEnimEj1TGTxvAs/Uomdqg2dq4PmY6PmYwfMf4JlG9Exj8EwDPNOKnmkNnreAZzrRM53BMx3wfFz0fNzg+S/wTC96pjd4pgeeT4ieTxg8bwPPDKJnBoNnBuD5pOj5pMHzP+CZUfTMaPDMCDwziZ6ZDJ53gGdm0TOzwTMz8HxK9HzK4HkXeGYRPbMYPLMAz4DoGTB43gOeUaJnlMEzCnhmFT2zGjwfSfHwnzOb6JnN4JkNeGYXPbMbPOMAzxyiZw6DZw7gmVP0zGnwjJvk4T9nrof1vBt44HPmMnjmAp65H9bzv/IPfM7cBs94wDOP6JnH4JkHeOYVPfMaPB8FnvlEz3wGz3zAM7/omd/gGR94FhA9Cxg8CwDPgqJnQYNnAuBZSPQsZPAsBDwLi56FDZ4JgWcR0bOIwbMI8Hxa9Hza4JkIeBYVPYsaPIsCz2dEz2cMnomBZzHRs5jBsxjwfFb0fNbgmQR4Fhc9ixs8iwPPEqJnCYNnUuBZUvQsafAsCTyfEz2fM3gmA56lRM9SBs9SwLO06Fna4JkceJYRPcsYPMsAz7KiZ1mDZwrgWU70LGfwLAc8y4ue5Q2eKYFnBdGzgsGzAvCsKHpWNHimAp6VRM9KBs9KwLOy6FnZ4JkaeFYRPasYPKsAz6qiZ1WD52PAs5roWc3gWQ14Vhc9qxs80wDPGqJnDYNnDeBZU/SsafBMCzxriZ61DJ61gGdt0bO2wTMd8KwjetYxeNYBnnVFz7oGz8eBZz3Rs57Bsx7wrC961jd4pgeeDUTPBgbPBsCzoejZ0OD5BPBsJHo2Mng2Ap6NRc/GBs8MwLOJ6NnE4NkEeDYVPZsaPJ8Ens1Ez2YGz2bAs7no2dzgmRF4thA9Wxg8WwDPlqJnS4NnJuDZSvRsZfBsBTxbi56tDZ6ZgWcb0bONwbMN8GwrerY1eD4FPNuJnu0Mnu2AZ3vRs73BMwvw7CB6djB4dgCeHUXPjgbPAPDsJHp2Mnh2Ap6dRc/OBs8o4NlF9Oxi8OwCPLuKnl0NnlmBZzfRs5vBsxvw7C56djd4ZgOePUTPHgbPHsCzp+jZ0+CZHXj2Ej17GTx7Ac/nRc/nDZ45gGdv0bO3wbM38OwjevYxeOYEnn1Fz74Gz77As5/o2c/gmQt49hc9+xs8+wPPAaLnAINnbuA5UPQcaPAcCDxfED1fMHjmAZ6DRM9BBs9BwHOw6DnY4JkXeA4RPYcYPIcAzxdFzxcNnvmA51DRc6jBcyjwfEn0fMngmR94DhM9hxk8hwHPl0XPlw2eBYDncNFzuMFzOPAcIXqOMHgWBJ4jRc+RBs+RwPMV0fMVg2ch4DlK9Bxl8BwFPF8VPV81eBYGnqNFz9EGz9HAc4zoOcbgWQR4jhU9xxo8xwLP10TP1wyeTwPPcaLnOIPnOOD5uuj5usGzKPAcL3qON3iOB55viJ5vGDyfAZ4TRM8JBs8JwHOi6DnR4FkMeE4SPScZPCcBzzdFzzcNns8Cz8mi52SD52Tg+Zbo+ZbBszjwnCJ6TjF4TgGeb4uebxs8SwDPqaLnVIPnVOD5juj5jsGzJPCcJnpOM3hOA57vip7vGjyfA57TRc/pBs/pwPM90fM9g2cp4DlD9Jxh8JwBPGeKnjMNnqWB5yzRc5bBcxbwfF/0fN/gWQZ4zhY9Zxs8ZwPPD0TPDwyeZYHnHNFzjsFzDvCcK3rONXiWA57zRM95Bs95wPND0fNDg2d54Dlf9Jxv8JwPPD8SPT8yeFYAngtEzwUGzwXA82PR82ODZ0XguVD0XGjwXAg8F4meiwyelYDnYtFzscFzMfD8RPT8xOBZGXguET2XGDyXAM9PRc9PDZ5VgOdS0XOpwXMp8Fwmei4zeFYFnstFz+UGz+XA8zPR8zODZzXguUL0XGHwXAE8Pxc9Pzd4VgeeK0XPlQbPlcDzC9HzC4NnDeC5SvRcZfBcBTxXi56rDZ41geca0XONwXMN8Fwreq41eNYCnutEz3UGz3XA80vR80uDZ23guV70XG/wXA88N4ieGwyedYDnRtFzo8FzI/D8SvT8yuBZF3huEj03GTw3Ac+vRc+vDZ71gOdm0XOzwXMz8PxG9PzG4FkfeG4RPbcYPLcAz62i51aDZwPguU303Gbw3AY8vxU9vzV4NgSe20XP7QbP7cDzO9HzO4NnI+C5Q/TcYfDcATx3ip47DZ6Ngecu0XOXwXMX8Pxe9Pze4NkEeO4WPXcbPHcDzx9Ezx8Mnk2B5x7Rc4/Bcw/w/FH0/NHg2Qx47hU99xo89wLPfaLnPoNnc+C5X/Tcb/DcDzx/Ej1/Mni2AJ4HRM8DBs8DwPNn0fNng2dL4HlQ9Dxo8DwIPA+JnocMnq2A52HR87DB8zDw/EX0/MXg2Rp4HhE9jxg8jwDPX0XPXw2ebYDnUdHzqMHzKPD8TfT8zeDZFngeEz2PGTyPAc/joudxg2c74HlC9Dxh8DwBPH8XPX83eLYHnidFz5MGz5PA8w/R8w+DZwfgeUr0PGXwPAU8T4uepw2eHYHnGdHzjMHzDPA8K3qeNXh2Ap7nRM9zBs9zwPNP0fNPg2dn4Hle9Dxv8DwPPP8SPf8yeHYBnhdEzwsGzwvA86LoedHg2RV4XhI9Lxk8LwHPy6LnZYNnN+B5RfS8YvC8Ajz/Fj3/Nnh2B55XRc+rBs+rwPOa6HnN4NkDeF4XPa8bPK8Dzxui5w2DZ0/geVP0vGnwvAk8/xE9/zF49gKet0TPWwbPW8DzX9HzX4Pn88Dztuh52+B5G3j+J3r+Z/DsDTzviJ53DJ53gOdd0fOuwbMP8Lwnet4zeN4Dno/k1zxDXxdbz77AM05+zTNO/th73v+zY5qNK3rGNXj2A57xRM94Bs94wPNR0fNRg2d/4Blf9Ixv8IwPPBOIngkMngOAZ0LRM6HBMyHwTCR6JjJ4DgSeiUXPxAbPxMAzieiZxOD5AvBMKnomNXgmBZ7JRM9kBs9BwDO56Jnc4JkceKYQPVMYPAcDz5SiZ0qDZ0rgmUr0TGXwHAI8U4ueqQ2eqYHnY6LnYwbPF4FnGtEzjcEzDfBMK3qmNXgOBZ7pRM90Bs90wPNx0fNxg+dLwDO96Jne4JkeeD4hej5h8BwGPDOInhkMnhmA55Oi55MGz5eBZ0bRM6PBMyPwzCR6ZjJ4DgeemUXPzAbPzMDzKdHzKYPnCOCZRfTMYvDMAjwDomfA4DkSeEaJnlEGzyjgmVX0zGrwfAV4ZhM9sxk8swHP7KJndoPnKOCZQ/TMYfDMATxzip45DZ6vAs9comcug2cu4Jlb9Mxt8BwNPPOInnkMnnmAZ17RM6/BcwzwzCd65jN45gOe+UXP/AbPscCzgOhZwOBZAHgWFD0LGjxfA56FRM9CBs9CwLOw6FnY4DkOeBYRPYsYPIsAz6dFz6cNnq8Dz6KiZ1GDZ1Hg+Yzo+YzBczzwLCZ6FjN4FgOez4qezxo83wCexUXP4gbP4sCzhOhZwuA5AXiWFD1LGjxLAs/nRM/nDJ4TgWcp0bOUwbMU8CwtepY2eE4CnmVEzzIGzzLAs6zoWdbg+SbwLCd6ljN4lgOe5UXP8gbPycCzguhZweBZAXhWFD0rGjzfAp6VRM9KBs9KwLOy6FnZ4DkFeFYRPasYPKsAz6qiZ1WD59vAs5roWc3gWQ14Vhc9qxs8pwLPGqJnDYNnDeBZU/SsafB8B3jWEj1rGTxrAc/aomdtg+c04FlH9Kxj8KwDPOuKnnUNnu8Cz3qiZz2DZz3gWV/0rG/wnA48G4ieDQyeDYBnQ9GzocHzPeDZSPRsZPBsBDwbi56NDZ4zgGcT0bOJwbMJ8GwqejY1eM4Ens1Ez2YGz2bAs7no2dzgOQt4thA9Wxg8WwDPlqJnS4Pn+8CzlejZyuDZCni2Fj1bGzxnA882omcbg2cb4NlW9Gxr8PwAeLYTPdsZPNsBz/aiZ3uD5xzg2UH07GDw7AA8O4qeHQ2ec4FnJ9Gzk8GzE/DsLHp2NnjOA55dRM8uBs8uwLOr6NnV4Pkh8OwmenYzeHYDnt1Fz+4Gz/nAs4fo2cPg2QN49hQ9exo8PwKevUTPXgbPXsDzedHzeYPnAuDZW/TsbfDsDTz7iJ59DJ4fA8++omdfg2df4NlP9Oxn8FwIPPuLnv0Nnv2B5wDRc4DBcxHwHCh6DjR4DgSeL4ieLxg8FwPPQaLnIIPnIOA5WPQcbPD8BHgOET2HGDyHAM8XRc8XDZ5LgOdQ0XOowXMo8HxJ9HzJ4Pkp8Bwmeg4zeA4Dni+Lni8bPJcCz+Gi53CD53DgOUL0HGHwXAY8R4qeIw2eI4HnK6LnKwbP5cBzlOg5yuA5Cni+Knq+avD8DHiOFj1HGzxHA88xoucYg+cK4DlW9Bxr8BwLPF8TPV8zeH4OPMeJnuMMnuOA5+ui5+sGz5XAc7zoOd7gOR54viF6vmHw/AJ4ThA9Jxg8JwDPiaLnRIPnKuA5SfScZPCcBDzfFD3fNHiuBp6TRc/JBs/JwPMt0fMtg+ca4DlF9Jxi8JwCPN8WPd82eK4FnlNFz6kGz6nA8x3R8x2D5zrgOU30nGbwnAY83xU93zV4fgk8p4ue0w2e04Hne6LnewbP9cBzhug5w+A5A3jOFD1nGjw3AM9Zoucsg+cs4Pm+6Pm+wXMj8Jwtes42eM4Gnh+Inh8YPL8CnnNEzzkGzznAc67oOdfguQl4zhM95xk85wHPD0XPDw2eXwPP+aLnfIPnfOD5kej5kcFzM/BcIHouMHguAJ4fi54fGzy/AZ4LRc+FBs+FwHOR6LnI4LkFeC4WPRcbPBcDz09Ez08MnluB5xLRc4nBcwnw/FT0/NTguQ14LhU9lxo8lwLPZaLnMoPnt8Bzuei53OC5HHh+Jnp+ZvDcDjxXiJ4rDJ4rgOfnoufnBs/vgOdK0XOlwXMl8PxC9PzC4LkDeK4SPVcZPFcBz9Wi52qD507guUb0XGPwXAM814qeaw2eu4DnOtFzncFzHfD8UvT80uD5PfBcL3quN3iuB54bRM8NBs/dwHOj6LnR4LkReH4len5l8PwBeG4SPTcZPDcBz69Fz68NnnuA52bRc7PBczPw/Eb0/Mbg+SPw3CJ6bjF4bgGeW0XPrQbPvcBzm+i5zeC5DXh+K3p+a/DcBzy3i57bDZ7bged3oud3Bs/9wHOH6LnD4LkDeO4UPXcaPH8CnrtEz10Gz13A83vR83uD5wHguVv03G3w3A08fxA9fzB4/gw894ieewyee4Dnj6LnjwbPg8Bzr+i51+C5F3juEz33GTwPAc/9oud+g+d+4PmT6PmTwfMw8Dwgeh4weB4Anj+Lnj8bPH8BngdFz4MGz4PA85DoecjgeQR4HhY9Dxs8DwPPX0TPXwyevwLPI6LnEYPnEeD5q+j5q8HzKPA8KnoeNXgeBZ6/iZ6/GTx/A57HRM9jBs9jwPO46Hnc4HkMeJ4QPU8YPE8Az99Fz98NnseB50nR86TB8yTw/EP0/MPgeQJ4nhI9Txk8TwHP06LnaYPn78DzjOh5xuB5BnieFT3PGjxPAs9zouc5g+c54Pmn6PmnwfMP4Hle9Dxv8DwPPP8SPf8yeJ4CnhdEzwsGzwvA86LoedHgeRp4XhI9Lxk8LwHPy6LnZYPnGeB5RfS8YvC8Ajz/Fj3/NnieBZ5XRc+rBs+rwPOa6HnN4HkOeF4XPa8bPK8Dzxui5w2D55/A86boedPgeRN4/iN6/mPwPA88b4metwyet4Dnv6LnvwbPv4DnbdHztsHzNvD8T/T8z+B5AXjeET3vGDzvAM+7ouddg+dF4HlP9Lxn8LwHPB8poHmGvi62npeAZ5wCmmecArH3vP9nxzQbV/SMa/C8DDzjiZ7xDJ7xgOejouejBs8rwDO+6Bnf4BkfeCYQPRMYPP8GnglFz4QGz4TAM5HomcjgeRV4JhY9Exs8EwPPJKJnEoPnNeCZVPRMavBMCjyTiZ7JDJ7XgWdy0TO5wTM58EwheqYweN4AnilFz5QGz5TAM5XomcrgeRN4phY9Uxs8UwPPx0TPxwye/wDPNKJnGoNnGuCZVvRMa/C8BTzTiZ7pDJ7pgOfjoufjBs9/gWd60TO9wTM98HxC9HzC4HkbeGYQPTMYPDMAzydFzycNnv8Bz4yiZ0aDZ0bgmUn0zGTwvAM8M4uemQ2emYHnU6LnUwbPu8Azi+iZxeCZBXgGRM+AwfMe8IwSPaMMnlHAM6vomdXg+UjSh/+c2UTPbAbPbMAzu+iZ3eAZB3jmED1zGDxzAM+comdOg2dc4JlL9Mxl8MwFPHOLnrkNnvGAZx7RM4/BMw/wzCt65jV4Pgo884me+Qye+YBnftEzv8EzPvAsIHoWMHgWAJ4FRc+CBs8EwLOQ6FnI4FkIeBYWPQsbPBMCzyKiZxGDZxHg+bTo+bTBMxHwLCp6FjV4FgWez4iezxg8EwPPYqJnMYNnMeD5rOj5rMEzCfAsLnoWN3gWB54lRM8SBs+kwLOk6FnS4FkSeD4nej5n8EwGPEuJnqUMnqWAZ2nRs7TBMznwLCN6ljF4lgGeZUXPsgbPFMCznOhZzuBZDniWFz3LGzxTAs8KomcFg2cF4FlR9Kxo8EwFPCuJnpUMnpWAZ2XRs7LBMzXwrCJ6VjF4VgGeVUXPqgbPx4BnNdGzmsGzGvCsLnpWN3imAZ41RM8aBs8awLOm6FnT4JkWeNYSPWsZPGsBz9qiZ22DZzrgWUf0rGPwrAM864qedQ2ejwPPeqJnPYNnPeBZX/Ssb/BMDzwbiJ4NDJ4NgGdD0bOhwfMJ4NlI9Gxk8GwEPBuLno0NnhmAZxPRs4nBswnwbCp6NjV4Pgk8m4mezQyezYBnc9GzucEzI/BsIXq2MHi2AJ4tRc+WBs9MwLOV6NnK4NkKeLYWPVsbPDMDzzaiZxuDZxvg2Vb0bGvwfAp4thM92xk82wHP9qJne4NnFuDZQfTsYPDsADw7ip4dDZ4B4NlJ9Oxk8OwEPDuLnp0NnlHAs4vo2cXg2QV4dhU9uxo8swLPbqJnN4NnN+DZXfTsbvDMBjx7iJ49DJ49gGdP0bOnwTM78OwlevYyePYCns+Lns8bPHMAz96iZ2+DZ2/g2Uf07GPwzAk8+4qefQ2efYFnP9Gzn8EzF/DsL3r2N3j2B54DRM8BBs/cwHOg6DnQ4DkQeL4ger5g8MwDPAeJnoMMnoOA52DRc7DBMy/wHCJ6DjF4DgGeL4qeLxo88wHPoaLnUIPnUOD5kuj5ksEzP/AcJnoOM3gOA54vi54vGzwLAM/houdwg+dw4DlC9Bxh8CwIPEeKniMNniOB5yui5ysGz0LAc5ToOcrgOQp4vip6vmrwLAw8R4ueow2eo4HnGNFzjMGzCPAcK3qONXiOBZ6viZ6vGTyfBp7jRM9xBs9xwPN10fN1g2dR4Dle9Bxv8BwPPN8QPd8weD4DPCeInhMMnhOA50TRc6LBsxjwnCR6TjJ4TgKeb4qebxo8nwWek0XPyQbPycDzLdHzLYNnceA5RfScYvCcAjzfFj3fNniWAJ5TRc+pBs+pwPMd0fMdg2dJ4DlN9Jxm8JwGPN8VPd81eD4HPKeLntMNntOB53ui53sGz1LAc4boOcPgOQN4zhQ9Zxo8SwPPWaLnLIPnLOD5vuj5vsGzDPCcLXrONnjOBp4fiJ4fGDzLAs85ouccg+cc4DlX9Jxr8CwHPOeJnvMMnvOA54ei54cGz/LAc77oOd/gOR94fiR6fmTwrAA8F4ieCwyeC4Dnx6LnxwbPisBzoei50OC5EHguEj0XGTwrAc/Foudig+di4PmJ6PmJwbMy8Fwiei4xeC4Bnp+Knp8aPKsAz6Wi51KD51LguUz0XGbwrAo8l4ueyw2ey4HnZ6LnZwbPasBzhei5wuC5Anh+Lnp+bvCsDjxXip4rDZ4rgecXoucXBs8awHOV6LnK4LkKeK4WPVcbPGsCzzWi5xqD5xrguVb0XGvwrAU814me6wye64Dnl6LnlwbP2sBzvei53uC5HnhuED03GDzrAM+NoudGg+dG4PmV6PmVwbMu8Nwkem4yeG4Cnl+Lnl8bPOsBz82i52aD52bg+Y3o+Y3Bsz7w3CJ6bjF4bgGeW0XPrQbPBsBzm+i5zeC5DXh+K3p+a/BsCDy3i57bDZ7bged3oud3Bs9GwHOH6LnD4LkDeO4UPXcaPBsDz12i5y6D5y7g+b3o+b3Bswnw3C167jZ47gaeP4iePxg8mwLPPaLnHoPnHuD5o+j5o8GzGfDcK3ruNXjuBZ77RM99Bs/mwHO/6Lnf4LkfeP4kev5k8GwBPA+IngcMngeA58+i588Gz5bA86DoedDgeRB4HhI9Dxk8WwHPw6LnYYPnYeD5i+j5i8GzNfA8InoeMXgeAZ6/ip6/GjzbAM+joudRg+dR4Pmb6PmbwbMt8Dwmeh4zeB4DnsdFz+MGz3bA84ToecLgeQJ4/i56/m7wbA88T4qeJw2eJ4HnH6LnHwbPDsDzlOh5yuB5CnieFj1PGzw7As8zoucZg+cZ4HlW9Dxr8OwEPM+JnucMnueA55+i558Gz87A87zoed7geR54/iV6/mXw7AI8L4ieFwyeF4DnRdHzosGzK/C8JHpeMnheAp6XRc/LBs9uwPOK6HnF4HkFeP4tev5t8OwOPK+KnlcNnleB5zXR85rBswfwvC56Xjd4XgeeN0TPGwbPnsDzpuh50+B5E3j+I3r+Y/DsBTxviZ63DJ63gOe/oue/Bs/ngedt0fO2wfM28PxP9PzP4NkbeN4RPe8YPO8Az7ui512DZx/geU/0vGfwvAc8HymoeYa+LraefYFnnIKaZ5yCsfe8/2fHNBtX9Ixr8OwHPOOJnvEMnvGA56Oi56MGz/7AM77oGd/gGR94JhA9Exg8BwDPhKJnQoNnQuCZSPRMZPAcCDwTi56JDZ6JgWcS0TOJwfMF4JlU9Exq8EwKPJOJnskMnoOAZ3LRM7nBMznwTCF6pjB4DgaeKUXPlAbPlMAzleiZyuA5BHimFj1TGzxTA8/HRM/HDJ4vAs80omcag2ca4JlW9Exr8BwKPNOJnukMnumA5+Oi5+MGz5eAZ3rRM73BMz3wfEL0fMLgOQx4ZhA9Mxg8MwDPJ0XPJw2eLwPPjKJnRoNnRuCZSfTMZPAcDjwzi56ZDZ6ZgedToudTBs8RwDOL6JnF4JkFeAZEz4DBcyTwjBI9owyeUcAzq+iZ1eD5CvDMJnpmM3hmA57ZRc/sBs9RwDOH6JnD4JkDeOYUPXMaPF8FnrlEz1wGz1zAM7fomdvgORp45hE98xg88wDPvKJnXoPnGOCZT/TMZ/DMBzzzi575DZ5jgWcB0bOAwbMA8CwoehY0eL4GPAuJnoUMnoWAZ2HRs7DBcxzwLCJ6FjF4FgGeT4ueTxs8XweeRUXPogbPosDzGdHzGYPneOBZTPQsZvAsBjyfFT2fNXi+ATyLi57FDZ7FgWcJ0bOEwXMC8CwpepY0eJYEns+Jns8ZPCcCz1KiZymDZyngWVr0LG3wnAQ8y4ieZQyeZYBnWdGzrMHzTeBZTvQsZ/AsBzzLi57lDZ6TgWcF0bOCwbMC8KwoelY0eL4FPCuJnpUMnpWAZ2XRs7LBcwrwrCJ6VjF4VgGeVUXPqgbPt4FnNdGzmsGzGvCsLnpWN3hOBZ41RM8aBs8awLOm6FnT4PkO8KwletYyeNYCnrVFz9oGz2nAs47oWcfgWQd41hU96xo83wWe9UTPegbPesCzvuhZ3+A5HXg2ED0bGDwbAM+GomdDg+d7wLOR6NnI4NkIeDYWPRsbPGcAzyaiZxODZxPg2VT0bGrwnAk8m4mezQyezYBnc9GzucFzFvBsIXq2MHi2AJ4tRc+WBs/3gWcr0bOVwbMV8GwterY2eM4Gnm1EzzYGzzbAs63o2dbg+QHwbCd6tjN4tgOe7UXP9gbPOcCzg+jZweDZAXh2FD07GjznAs9Oomcng2cn4NlZ9Oxs8JwHPLuInl0Mnl2AZ1fRs6vB80Pg2U307Gbw7AY8u4ue3Q2e84FnD9Gzh8GzB/DsKXr2NHh+BDx7iZ69DJ69gOfzoufzBs8FwLO36Nnb4NkbePYRPfsYPD8Gnn1Fz74Gz77As5/o2c/guRB49hc9+xs8+wPPAaLnAIPnIuA5UPQcaPAcCDxfED1fMHguBp6DRM9BBs9BwHOw6DnY4PkJ8Bwieg4xeA4Bni+Kni8aPJcAz6Gi51CD51Dg+ZLo+ZLB81PgOUz0HGbwHAY8XxY9XzZ4LgWew0XP4QbP4cBzhOg5wuC5DHiOFD1HGjxHAs9XRM9XDJ7Lgeco0XOUwXMU8HxV9HzV4PkZ8Bwteo42eI4GnmNEzzEGzxXAc6zoOdbgORZ4viZ6vmbw/Bx4jhM9xxk8xwHP10XP1w2eK4HneNFzvMFzPPB8Q/R8w+D5BfCcIHpOMHhOAJ4TRc+JBs9VwHOS6DnJ4DkJeL4per5p8FwNPCeLnpMNnpOB51ui51sGzzXAc4roOcXgOQV4vi16vm3wXAs8p4qeUw2eU4HnO6LnOwbPdcBzmug5zeA5DXi+K3q+a/D8EnhOFz2nGzynA8/3RM/3DJ7rgecM0XOGwXMG8Jwpes40eG4AnrNEz1kGz1nA833R832D50bgOVv0nG3wnA08PxA9PzB4fgU854iecwyec4DnXNFzrsFzE/CcJ3rOM3jOA54fip4fGjy/Bp7zRc/5Bs/5wPMj0fMjg+dm4LlA9Fxg8FwAPD8WPT82eH4DPBeKngsNnguB5yLRc5HBcwvwXCx6LjZ4Lgaen4ienxg8twLPJaLnEoPnEuD5qej5qcFzG/BcKnouNXguBZ7LRM9lBs9vgedy0XO5wXM58PxM9PzM4LkdeK4QPVcYPFcAz89Fz88Nnt8Bz5Wi50qD50rg+YXo+YXBcwfwXCV6rjJ4rgKeq0XP1QbPncBzjei5xuC5BniuFT3XGjx3Ac91ouc6g+c64Pml6PmlwfN74Lle9Fxv8FwPPDeInhsMnruB50bRc6PBcyPw/Er0/Mrg+QPw3CR6bjJ4bgKeX4ueXxs89wDPzaLnZoPnZuD5jej5jcHzR+C5RfTcYvDcAjy3ip5bDZ57gec20XObwXMb8PxW9PzW4LkPeG4XPbcbPLcDz+9Ez+8MnvuB5w7Rc4fBcwfw3Cl67jR4/gQ8d4meuwyeu4Dn96Ln9wbPA8Bzt+i52+C5G3j+IHr+YPD8GXjuET33GDz3AM8fRc8fDZ4Hgede0XOvwXMv8Nwneu4zeB4CnvtFz/0Gz/3A8yfR8yeD52HgeUD0PGDwPAA8fxY9fzZ4/gI8D4qeBw2eB4HnIdHzkMHzCPA8LHoeNngeBp6/iJ6/GDx/BZ5HRM8jBs8jwPNX0fNXg+dR4HlU9Dxq8DwKPH8TPX8zeP4GPI+JnscMnseA53HR87jB8xjwPCF6njB4ngCev4uevxs8jwPPk6LnSYPnSeD5h+j5h8HzBPA8JXqeMnieAp6nRc/TBs/fgecZ0fOMwfMM8Dwrep41eJ4EnudEz3MGz3PA80/R80+D5x/A87zoed7geR54/iV6/mXwPAU8L4ieFwyeF4DnRdHzosHzNPC8JHpeMnheAp6XRc/LBs8zwPOK6HnF4HkFeP4tev5t8DwLPK+KnlcNnleB5zXR85rB8xzwvC56Xjd4XgeeN0TPGwbPP4HnTdHzpsHzJvD8R/T8x+B5HnjeEj1vGTxvAc9/Rc9/DZ5/Ac/boudtg+dt4Pmf6PmfwfMC8Lwjet4xeN4BnndFz7sGz4vA857oec/geQ94PlJI8wx9XWw9LwHPOIU0zziFYu95/8+OaTau6BnX4HkZeMYTPeMZPOMBz0dFz0cNnleAZ3zRM77BMz7wTCB6JjB4/g08E4qeCQ2eCYFnItEzkcHzKvBMLHomNngmBp5JRM8kBs9rwDOp6JnU4JkUeCYTPZMZPK8Dz+SiZ3KDZ3LgmUL0TGHwvAE8U4qeKQ2eKYFnKtEzlcHzJvBMLXqmNnimBp6PiZ6PGTz/AZ5pRM80Bs80wDOt6JnW4HkLeKYTPdMZPNMBz8dFz8cNnv8Cz/SiZ3qDZ3rg+YTo+YTB8zbwzCB6ZjB4ZgCeT4qeTxo8/wOeGUXPjAbPjMAzk+iZyeB5B3hmFj0zGzwzA8+nRM+nDJ53gWcW0TOLwTML8AyIngGD5z3gGSV6Rhk8o4BnVtEzq8HzkWQP/zmziZ7ZDJ7ZgGd20TO7wTMO8MwheuYweOYAnjlFz5wGz7gpHv5z5hI9cxk8cwHP3KJnboNnPOCZR/TMY/DMAzzzip55DZ6PAs98omc+g2c+4Jlf9Mxv8IwPPAuIngUMngWAZ0HRs6DBMwHwLCR6FjJ4FgKehUXPwgbPhMCziOhZxOBZBHg+LXo+bfBMBDyLip5FDZ5FgeczouczBs/EwLOY6FnM4FkMeD4rej5r8EwCPIuLnsUNnsWBZwnRs4TBMynwLCl6ljR4lgSez4mezxk8kwHPUqJnKYNnKeBZWvQsbfBMDjzLiJ5lDJ5lgGdZ0bOswTMF8CwnepYzeJYDnuVFz/IGz5TAs4LoWcHgWQF4VhQ9Kxo8UwHPSqJnJYNnJeBZWfSsbPBMDTyriJ5VDJ5VgGdV0bOqwfMx4FlN9Kxm8KwGPKuLntUNnmmAZw3Rs4bBswbwrCl61jR4pgWetUTPWgbPWsCztuhZ2+CZDnjWET3rGDzrAM+6omddg+fjwLOe6FnP4FkPeNYXPesbPNMDzwaiZwODZwPg2VD0bGjwfAJ4NhI9Gxk8GwHPxqJnY4NnBuDZRPRsYvBsAjybip5NDZ5PAs9momczg2cz4Nlc9Gxu8MwIPFuIni0Mni2AZ0vRs6XBMxPwbCV6tjJ4tgKerUXP1gbPzMCzjejZxuDZBni2FT3bGjyfAp7tRM92Bs92wLO96Nne4JkFeHYQPTsYPDsAz46iZ0eDZwB4dhI9Oxk8OwHPzqJnZ4NnFPDsInp2MXh2AZ5dRc+uBs+swLOb6NnN4NkNeHYXPbsbPLMBzx6iZw+DZw/g2VP07GnwzA48e4mevQyevYDn86Ln8wbPHMCzt+jZ2+DZG3j2ET37GDxzAs++omdfg2df4NlP9Oxn8MwFPPuLnv0Nnv2B5wDRc4DBMzfwHCh6DjR4DgSeL4ieLxg88wDPQaLnIIPnIOA5WPQcbPDMCzyHiJ5DDJ5DgOeLoueLBs98wHOo6DnU4DkUeL4ker5k8MwPPIeJnsMMnsOA58ui58sGzwLAc7joOdzgORx4jhA9Rxg8CwLPkaLnSIPnSOD5iuj5isGzEPAcJXqOMniOAp6vip6vGjwLA8/Roudog+do4DlG9Bxj8CwCPMeKnmMNnmOB52ui52sGz6eB5zjRc5zBcxzwfF30fN3gWRR4jhc9xxs8xwPPN0TPNwyezwDPCaLnBIPnBOA5UfScaPAsBjwniZ6TDJ6TgOebouebBs9ngedk0XOywXMy8HxL9HzL4FkceE4RPacYPKcAz7dFz7cNniWA51TRc6rBcyrwfEf0fMfgWRJ4ThM9pxk8pwHPd0XPdw2ezwHP6aLndIPndOD5nuj5nsGzFPCcIXrOMHjOAJ4zRc+ZBs/SwHOW6DnL4DkLeL4ver5v8CwDPGeLnrMNnrOB5wei5wcGz7LAc47oOcfgOQd4zhU95xo8ywHPeaLnPIPnPOD5oej5ocGzPPCcL3rON3jOB54fiZ4fGTwrAM8FoucCg+cC4Pmx6PmxwbMi8Fwoei40eC4EnotEz0UGz0rAc7HoudjguRh4fiJ6fmLwrAw8l4ieSwyeS4Dnp6LnpwbPKsBzqei51OC5FHguEz2XGTyrAs/loudyg+dy4PmZ6PmZwbMa8Fwheq4weK4Anp+Lnp8bPKsDz5Wi50qD50rg+YXo+YXBswbwXCV6rjJ4rgKeq0XP1QbPmsBzjei5xuC5BniuFT3XGjxrAc91ouc6g+c64Pml6PmlwbM28Fwveq43eK4HnhtEzw0GzzrAc6PoudHguRF4fiV6fmXwrAs8N4memwyem4Dn16Ln1wbPesBzs+i52eC5GXh+I3p+Y/CsDzy3iJ5bDJ5bgOdW0XOrwbMB8Nwmem4zeG4Dnt+Knt8aPBsCz+2i53aD53bg+Z3o+Z3BsxHw3CF67jB47gCeO0XPnQbPxsBzl+i5y+C5C3h+L3p+b/BsAjx3i567DZ67gecPoucPBs+mwHOP6LnH4LkHeP4oev5o8GwGPPeKnnsNnnuB5z7Rc5/Bsznw3C967jd47geeP4mePxk8WwDPA6LnAYPnAeD5s+j5s8GzJfA8KHoeNHgeBJ6HRM9DBs9WwPOw6HnY4HkYeP4iev5i8GwNPI+InkcMnkeA56+i568GzzbA86joedTgeRR4/iZ6/mbwbAs8j4mexwyex4DncdHzuMGzHfA8IXqeMHieAJ6/i56/GzzbA8+ToudJg+dJ4PmH6PmHwbMD8Dwlep4yeJ4CnqdFz9MGz47A84zoecbgeQZ4nhU9zxo8OwHPc6LnOYPnOeD5p+j5p8GzM/A8L3qeN3ieB55/iZ5/GTy7AM8LoucFg+cF4HlR9Lxo8OwKPC+JnpcMnpeA52XR87LBsxvwvCJ6XjF4XgGef4uefxs8uwPPq6LnVYPnVeB5TfS8ZvDsATyvi57XDZ7XgecN0fOGwbMn8Lwpet40eN4Env+Inv8YPHsBz1ui5y2D5y3g+a/o+a/B83ngeVv0vG3wvA08/xM9/zN49gaed0TPOwbPO8Dzruh51+DZB3jeEz3vGTzvAc9HCmueoa+LrWdf4BmnsOYZp3DsPe//2THNxhU94xo8+wHPeKJnPINnPOD5qOj5qMGzP/CML3rGN3jGB54JRM8EBs8BwDOh6JnQ4JkQeCYSPRMZPAcCz8SiZ2KDZ2LgmUT0TGLwfAF4JhU9kxo8kwLPZKJnMoPnIOCZXPRMbvBMDjxTiJ4pDJ6DgWdK0TOlwTMl8EwleqYyeA4BnqlFz9QGz9TA8zHR8zGD54vAM43omcbgmQZ4phU90xo8hwLPdKJnOoNnOuD5uOj5uMHzJeCZXvRMb/BMDzyfED2fMHgOA54ZRM8MBs8MwPNJ0fNJg+fLwDOj6JnR4JkReGYSPTMZPIcDz8yiZ2aDZ2bg+ZTo+ZTBcwTwzCJ6ZjF4ZgGeAdEzYPAcCTyjRM8og2cU8MwqemY1eL4CPLOJntkMntmAZ3bRM7vBcxTwzCF65jB45gCeOUXPnAbPV4FnLtEzl8EzF/DMLXrmNniOBp55RM88Bs88wDOv6JnX4DkGeOYTPfMZPPMBz/yiZ36D51jgWUD0LGDwLAA8C4qeBQ2erwHPQqJnIYNnIeBZWPQsbPAcBzyLiJ5FDJ5FgOfToufTBs/XgWdR0bOowbMo8HxG9HzG4DkeeBYTPYsZPIsBz2dFz2cNnm8Az+KiZ3GDZ3HgWUL0LGHwnAA8S4qeJQ2eJYHnc6LncwbPicCzlOhZyuBZCniWFj1LGzwnAc8yomcZg2cZ4FlW9Cxr8HwTeJYTPcsZPMsBz/KiZ3mD52TgWUH0rGDwrAA8K4qeFQ2ebwHPSqJnJYNnJeBZWfSsbPCcAjyriJ5VDJ5VgGdV0bOqwfNt4FlN9Kxm8KwGPKuLntUNnlOBZw3Rs4bBswbwrCl61jR4vgM8a4metQyetYBnbdGztsFzGvCsI3rWMXjWAZ51Rc+6Bs93gWc90bOewbMe8KwvetY3eE4Hng1EzwYGzwbAs6Ho2dDg+R7wbCR6NjJ4NgKejUXPxgbPGcCziejZxODZBHg2FT2bGjxnAs9momczg2cz4Nlc9Gxu8JwFPFuIni0Mni2AZ0vRs6XB833g2Ur0bGXwbAU8W4uerQ2es4FnG9GzjcGzDfBsK3q2NXh+ADzbiZ7tDJ7tgGd70bO9wXMO8OwgenYweHYAnh1Fz44Gz7nAs5Po2cng2Ql4dhY9Oxs85wHPLqJnF4NnF+DZVfTsavD8EHh2Ez27GTy7Ac/uomd3g+d84NlD9Oxh8OwBPHuKnj0Nnh8Bz16iZy+DZy/g+bzo+bzBcwHw7C169jZ49gaefUTPPgbPj4FnX9Gzr8GzL/DsJ3r2M3guBJ79Rc/+Bs/+wHOA6DnA4LkIeA4UPQcaPAcCzxdEzxcMnouB5yDRc5DBcxDwHCx6DjZ4fgI8h4ieQwyeQ4Dni6LniwbPJcBzqOg51OA5FHi+JHq+ZPD8FHgOEz2HGTyHAc+XRc+XDZ5Lgedw0XO4wXM48Bwheo4weC4DniNFz5EGz5HA8xXR8xWD53LgOUr0HGXwHAU8XxU9XzV4fgY8R4ueow2eo4HnGNFzjMFzBfAcK3qONXiOBZ6viZ6vGTw/B57jRM9xBs9xwPN10fN1g+dK4Dle9Bxv8BwPPN8QPd8weH4BPCeInhMMnhOA50TRc6LBcxXwnCR6TjJ4TgKeb4qebxo8VwPPyaLnZIPnZOD5luj5lsFzDfCcInpOMXhOAZ5vi55vGzzXAs+poudUg+dU4PmO6PmOwXMd8Jwmek4zeE4Dnu+Knu8aPL8EntNFz+kGz+nA8z3R8z2D53rgOUP0nGHwnAE8Z4qeMw2eG4DnLNFzlsFzFvB8X/R83+C5EXjOFj1nGzxnA88PRM8PDJ5fAc85ouccg+cc4DlX9Jxr8NwEPOeJnvMMnvOA54ei54cGz6+B53zRc77Bcz7w/Ej0/MjguRl4LhA9Fxg8FwDPj0XPjw2e3wDPhaLnQoPnQuC5SPRcZPDcAjwXi56LDZ6LgecnoucnBs+twHOJ6LnE4LkEeH4qen5q8NwGPJeKnksNnkuB5zLRc5nB81vguVz0XG7wXA48PxM9PzN4bgeeK0TPFQbPFcDzc9Hzc4Pnd8Bzpei50uC5Enh+IXp+YfDcATxXiZ6rDJ6rgOdq0XO1wXMn8Fwjeq4xeK4BnmtFz7UGz13Ac53ouc7guQ54fil6fmnw/B54rhc91xs81wPPDaLnBoPnbuC5UfTcaPDcCDy/Ej2/Mnj+ADw3iZ6bDJ6bgOfXoufXBs89wHOz6LnZ4LkZeH4jen5j8PwReG4RPbcYPLcAz62i51aD517guU303Gbw3AY8vxU9vzV47gOe20XP7QbP7cDzO9HzO4PnfuC5Q/TcYfDcATx3ip47DZ4/Ac9doucug+cu4Pm96Pm9wfMA8Nwteu42eO4Gnj+Inj8YPH8GnntEzz0Gzz3A80fR80eD50HguVf03Gvw3As894me+wyeh4DnftFzv8FzP/D8SfT8yeB5GHgeED0PGDwPAM+fRc+fDZ6/AM+DoudBg+dB4HlI9Dxk8DwCPA+LnocNnoeB5y+i5y8Gz1+B5xHR84jB8wjw/FX0/NXgeRR4HhU9jxo8jwLP30TP3wyevwHPY6LnMYPnMeB5XPQ8bvA8BjxPiJ4nDJ4ngOfvoufvBs/jwPOk6HnS4HkSeP4hev5h8DwBPE+JnqcMnqeA52nR87TB83fgeUb0PGPwPAM8z4qeZw2eJ4HnOdHznMHzHPD8U/T80+D5B/A8L3qeN3ieB55/iZ5/GTxPAc8LoucFg+cF4HlR9Lxo8DwNPC+JnpcMnpeA52XR87LB8wzwvCJ6XjF4XgGef4uefxs8zwLPq6LnVYPnVeB5TfS8ZvA8Bzyvi57XDZ7XgecN0fOGwfNP4HlT9Lxp8LwJPP8RPf8xeJ4HnrdEz1sGz1vA81/R81+D51/A87boedvgeRt4/id6/mfwvAA874iedwyed4DnXdHzrsHzIvC8J3reM3jeA56PFNE8Q18XW89LwDNOEc0zTpHYe97/s2OajSt6xjV4Xgae8UTPeAbPeMDzUdHzUYPnFeAZX/SMb/CMDzwTiJ4JDJ5/A8+EomdCg2dC4JlI9Exk8LwKPBOLnokNnomBZxLRM4nB8xrwTCp6JjV4JgWeyUTPZAbP68AzueiZ3OCZHHimED1TGDxvAM+UomdKg2dK4JlK9Exl8LwJPFOLnqkNnqmB52Oi52MGz3+AZxrRM43BMw3wTCt6pjV43gKe6UTPdAbPdMDzcdHzcYPnv8AzveiZ3uCZHng+IXo+YfC8DTwziJ4ZDJ4ZgOeToueTBs//gGdG0TOjwTMj8MwkemYyeN4BnplFz8wGz8zA8ynR8ymD513gmUX0zGLwzAI8A6JnwOB5D3hGiZ5RBs8o4JlV9Mxq8Hwk5cN/zmyiZzaDZzbgmV30zG7wjAM8c4ieOQyeOYBnTtEzp8EzLvDMJXrmMnjmAp65Rc/cBs94wDOP6JnH4JkHeOYVPfMaPB8FnvlEz3wGz3zAM7/omd/gGR94FhA9Cxg8CwDPgqJnQYNnAuBZSPQsZPAsBDwLi56FDZ4JgWcR0bOIwbMI8Hxa9Hza4JkIeBYVPYsaPIsCz2dEz2cMnomBZzHRs5jBsxjwfFb0fNbgmQR4Fhc9ixs8iwPPEqJnCYNnUuBZUvQsafAsCTyfEz2fM3gmA56lRM9SBs9SwLO06Fna4JkceJYRPcsYPMsAz7KiZ1mDZwrgWU70LGfwLAc8y4ue5Q2eKYFnBdGzgsGzAvCsKHpWNHimAp6VRM9KBs9KwLOy6FnZ4JkaeFYRPasYPKsAz6qiZ1WD52PAs5roWc3gWQ14Vhc9qxs80wDPGqJnDYNnDeBZU/SsafBMCzxriZ61DJ61gGdt0bO2wTMd8KwjetYxeNYBnnVFz7oGz8eBZz3Rs57Bsx7wrC961jd4pgeeDUTPBgbPBsCzoejZ0OD5BPBsJHo2Mng2Ap6NRc/GBs8MwLOJ6NnE4NkEeDYVPZsaPJ8Ens1Ez2YGz2bAs7no2dzgmRF4thA9Wxg8WwDPlqJnS4NnJuDZSvRsZfBsBTxbi56tDZ6ZgWcb0bONwbMN8GwrerY1eD4FPNuJnu0Mnu2AZ3vRs73BMwvw7CB6djB4dgCeHUXPjgbPAPDsJHp2Mnh2Ap6dRc/OBs8o4NlF9Oxi8OwCPLuKnl0NnlmBZzfRs5vBsxvw7C56djd4ZgOePUTPHgbPHsCzp+jZ0+CZHXj2Ej17GTx7Ac/nRc/nDZ45gGdv0bO3wbM38OwjevYxeOYEnn1Fz74Gz77As5/o2c/gmQt49hc9+xs8+wPPAaLnAINnbuA5UPQcaPAcCDxfED1fMHjmAZ6DRM9BBs9BwHOw6DnY4JkXeA4RPYcYPIcAzxdFzxcNnvmA51DRc6jBcyjwfEn0fMngmR94DhM9hxk8hwHPl0XPlw2eBYDncNFzuMFzOPAcIXqOMHgWBJ4jRc+RBs+RwPMV0fMVg2ch4DlK9Bxl8BwFPF8VPV81eBYGnqNFz9EGz9HAc4zoOcbgWQR4jhU9xxo8xwLP10TP1wyeTwPPcaLnOIPnOOD5uuj5usGzKPAcL3qON3iOB55viJ5vGDyfAZ4TRM8JBs8JwHOi6DnR4FkMeE4SPScZPCcBzzdFzzcNns8Cz8mi52SD52Tg+Zbo+ZbBszjwnCJ6TjF4TgGeb4uebxs8SwDPqaLnVIPnVOD5juj5jsGzJPCcJnpOM3hOA57vip7vGjyfA57TRc/pBs/pwPM90fM9g2cp4DlD9Jxh8JwBPGeKnjMNnqWB5yzRc5bBcxbwfF/0fN/gWQZ4zhY9Zxs8ZwPPD0TPDwyeZYHnHNFzjsFzDvCcK3rONXiWA57zRM95Bs95wPND0fNDg2d54Dlf9Jxv8JwPPD8SPT8yeFYAngtEzwUGzwXA82PR82ODZ0XguVD0XGjwXAg8F4meiwyelYDnYtFzscFzMfD8RPT8xOBZGXguET2XGDyXAM9PRc9PDZ5VgOdS0XOpwXMp8Fwmei4zeFYFnstFz+UGz+XA8zPR8zODZzXguUL0XGHwXAE8Pxc9Pzd4VgeeK0XPlQbPlcDzC9HzC4NnDeC5SvRcZfBcBTxXi56rDZ41geca0XONwXMN8Fwreq41eNYCnutEz3UGz3XA80vR80uDZ23guV70XG/wXA88N4ieGwyedYDnRtFzo8FzI/D8SvT8yuBZF3huEj03GTw3Ac+vRc+vDZ71gOdm0XOzwXMz8PxG9PzG4FkfeG4RPbcYPLcAz62i51aDZwPguU303Gbw3AY8vxU9vzV4NgSe20XP7QbP7cDzO9HzO4NnI+C5Q/TcYfDcATx3ip47DZ6Ngecu0XOXwXMX8Pxe9Pze4NkEeO4WPXcbPHcDzx9Ezx8Mnk2B5x7Rc4/Bcw/w/FH0/NHg2Qx47hU99xo89wLPfaLnPoNnc+C5X/Tcb/DcDzx/Ej1/Mni2AJ4HRM8DBs8DwPNn0fNng2dL4HlQ9Dxo8DwIPA+JnocMnq2A52HR87DB8zDw/EX0/MXg2Rp4HhE9jxg8jwDPX0XPXw2ebYDnUdHzqMHzKPD8TfT8zeDZFngeEz2PGTyPAc/joudxg2c74HlC9Dxh8DwBPH8XPX83eLYHnidFz5MGz5PA8w/R8w+DZwfgeUr0PGXwPAU8T4uepw2eHYHnGdHzjMHzDPA8K3qeNXh2Ap7nRM9zBs9zwPNP0fNPg2dn4Hle9Dxv8DwPPP8SPf8yeHYBnhdEzwsGzwvA86LoedHg2RV4XhI9Lxk8LwHPy6LnZYNnN+B5RfS8YvC8Ajz/Fj3/Nnh2B55XRc+rBs+rwPOa6HnN4NkDeF4XPa8bPK8Dzxui5w2DZ0/geVP0vGnwvAk8/xE9/zF49gKet0TPWwbPW8DzX9HzX4Pn/4cVugrbsmy7ti3d3d3d3XDS3d3d3d3d3d3dDSIiIiIiIiIiIiAiIiIiItL//8zd39T9ju0ax/Q4lm1f1l6C52vo+drg+VrwfAM93xg8ewueb6HnW4PnW8HzHfR8Z/DsI3i+h57vDZ7vBc8PCjLP//0L1bOv4BmhIPOMUDB0z7Dt8LYRoWdEg2c/wTMS9Ixk8IwkeEaGnpENnv0FzyjQM4rBM4rgGRV6RjV4DhA8o0HPaAbPaIJndOgZ3eA5UPCMAT1jGDxjCJ4xoWdMg+cgwTMW9Ixl8IwleMaGnrENnoMFzzjQM47BM47gGRd6xjV4DhE840HPeAbPeIJnfOgZ3+A5VPBMAD0TGDwTCJ4JoWdCg+cwwTMR9Exk8EwkeCaGnokNnsMFzyTQM4nBM4ngmRR6JjV4jhA8k0HPZAbPZIJncuiZ3OA5UvBMAT1TGDxTCJ4poWdKg+cowTMV9Exl8EwleKaGnqkNnqMFzzTQM43BM43gmRZ6pjV4jhE800HPdAbPdIJneuiZ3uA5VvDMAD0zGDwzCJ4ZoWdGg+c4wTMT9Mxk8MwkeGaGnpkNnuMFzyzQM4vBM4vgmRV6ZjV4ThA8s0HPbAbPbIJnduiZ3eA5UfDMAT1zGDxzCJ45oWdOg+ckwTMX9Mxl8MwleOaGnrkNnpMFzzzQM4/BM4/gmRd65jV4ThE880HPfAbPfIJnfuiZ3+A5VfAsAD0LGDwLCJ4FoWdBg+c0wbMQ9Cxk8CwkeBaGnoUNntMFzyLQs4jBs4jgWRR6FjV4zhA8i0HPYgbPYoJncehZ3OA5U/AsAT1LGDxLCJ4loWdJg+cswbMU9Cxl8CwleJaGnqUNnrMFzzLQs4zBs4zgWRZ6ljV4zhE8y0HPcgbPcoJnAD0Dg+dcwbM89Cxv8CwveFaAnhUMnvMEz4rQs6LBs6LgWQl6VjJ4zhc8K0PPygbPyoJnFehZxeC5QPCsCj2rGjyrCp7VoGc1g+dCwbM69Kxu8KwueNaAnjUMnosEz5rQs6bBs6bgWQt61jJ4LhY8a0PP2gbP2oJnHehZx+C5RPCsCz3rGjzrCp71oGc9g+dSwbM+9Kxv8KwveDaAng0MnssEz4bQs6HBs6Hg2Qh6NjJ4Lhc8G0PPxgbPxoJnE+jZxOC5QvBsCj2bGjybCp7NoGczg+dKwbM59Gxu8GwueLaAni0MnqsEz5bQs6XBs6Xg2Qp6tjJ4rhY8W0PP1gbP1oJnG+jZxuC5RvBsCz3bGjzbCp7toGc7g+dawbM99Gxv8GwveHaAnh0MnusEz47Qs6PBs6Pg2Ql6djJ4rhc8O0PPzgbPzoJnF+jZxeC5QfDsCj27Gjy7Cp7doGc3g+dGwbM79Oxu8OwuePaAnj0MnpsEz57Qs6fBs6fg2Qt69jJ4bhY8e0PP3gbP3oJnH+jZx+C5RfDsCz37Gjz7Cp79oGc/g+dWwbM/9Oxv8OwveA6AngMMntsEz4HQc6DBc6DgOQh6DjJ4bhc8B0PPwQbPwYLnEOg5xOC5Q/AcCj2HGjyHCp7DoOcwg+dOwXM49Bxu8BwueI6AniMMnrsEz5HQc6TBc6TgOQp6jjJ47hY8R0PP0QbP0YLnGOg5xuC5R/AcCz3HGjzHCp7joOc4g+dewXM89Bxv8BwveE6AnhMMnvsEz4nQc6LBc6LgOQl6TjJ47hc8J0PPyQbPyYLnFOg5xeB5QPCcCj2nGjynCp7ToOc0g+dBwXM69Jxu8JwueM6AnjMMnocEz5nQc6bBc6bgOQt6zjJ4HhY8Z0PP2QbP2YLnHOg5x+B5RPCcCz3nGjznCp7zoOc8g+dRwXM+9Jxv8JwveC6AngsMnscEz4XQc6HBc6HguQh6LjJ4Hhc8F0PPxQbPxYLnEui5xOB5QvBcCj2XGjyXCp7LoOcyg+dJwXM59Fxu8FwueK6AnisMnh8Kniuh50qD50rBcxX0XGXwPCV4roaeqw2eqwXPNdBzjcHzI8FzLfRca/BcK3iug57rDJ6nBc/10HO9wXO94LkBem4weH4seG6EnhsNnhsFz03Qc5PB84zguRl6bjZ4bhY8t0DPLQbPTwTPrdBzq8Fzq+C5DXpuM3ieFTy3Q8/tBs/tgucO6LnD4Pmp4LkTeu40eO4UPHdBz10Gz3OC527oudvguVvw3AM99xg8PxM890LPvQbPvYLnPui5z+B5XvDcDz33Gzz3C54HoOcBg+fngudB6HnQ4HlQ8DwEPQ8ZPC8Inoeh52GD52HB8wj0PGLw/ELwPAo9jxo8jwqex6DnMYPnRcHzOPQ8bvA8LniegJ4nDJ5fCp4noedJg+dJwfND6PmhwfOS4HkKep4yeJ4SPD+Cnh8ZPL8SPE9Dz9MGz9OC58fQ82OD52XB8wz0PGPwPCN4fgI9PzF4fi14noWeZw2eZwXPT6HnpwbPK4LnOeh5zuB5TvD8DHp+ZvD8RvA8Dz3PGzzPC56fQ8/PDZ5XBc8L0POCwfOC4PkF9PzC4Pmt4HkRel40eF4UPL+Enl8aPK8Jnpeg5yWD5yXB8yvo+ZXB8zvB8zL0vGzwvCx4fg09vzZ4Xhc8r0DPKwbPK4LnN9DzG4Pn94LnVeh51eB5VfD8Fnp+a/C8IXheg57XDJ7XBM/voOd3Bs8fBM/r0PO6wfO64Pk99Pze4HlT8LwBPW8YPG8Inj9Azx8Mnj8Knjeh502D503B80fo+aPB85bgeQt63jJ43hI8f4KePxk8fxI8b0PP2wbP24LnHeh5x+B5W/C8Cz3vGjzvCp4/Q8+fDZ53BM970POewfOe4PkL9PzF4HlX8LwPPe8bPO8Lnr9Cz18Nnj8Lng+g5wOD5wPB8zfo+ZvB857g+RB6PjR4PhQ8f4eevxs8fxE8H0HPRwbPR4LnH9DzD4PnfcHzMfR8bPB8LHj+CT3/NHj+Kng+gZ5PDJ5PBM+/oOdfBs8HgudT6PnU4PlU8Pwbev5t8PxN8HwGPZ8ZPJ8Jnv9Az38Mng8Fz+fQ87nB87ng+S/0/Nfg+bvg+QJ6vjB4vhA8/4Oe/xk8HwmeL6HnS4PnS8HzFfR8ZfD8Q/B8DT1fGzxfC55voOcbg+djwfMt9Hxr8HwreL6Dnu8Mnn8Knu+h53uD53vB84NCzPN//0L1fCJ4RijEPCMUCt0zbDu8bUToGdHg+ZfgGQl6RjJ4RhI8I0PPyAbPp4JnFOgZxeAZRfCMCj2jGjz/FjyjQc9oBs9ogmd06Bnd4PlM8IwBPWMYPGMInjGhZ0yD5z+CZyzoGcvgGUvwjA09Yxs8nwuecaBnHINnHMEzLvSMa/D8V/CMBz3jGTzjCZ7xoWd8g+cLwTMB9Exg8EwgeCaEngkNnv8JnomgZyKDZyLBMzH0TGzwfCl4JoGeSQyeSQTPpNAzqcHzleCZDHomM3gmEzyTQ8/kBs/XgmcK6JnC4JlC8EwJPVMaPN8InqmgZyqDZyrBMzX0TG3wfCt4poGeaQyeaQTPtNAzrcHzneCZDnqmM3imEzzTQ8/0Bs/3gmcG6JnB4JlB8MwIPTMaPD+I/3+/MxP0zGTwzCR4ZoaemQ2eEQTPLNAzi8Ezi+CZFXpmNXhGFDyz/Z/ujPb+fd/348Pe+b9/ucO5U2mHt83+f7oz3vt3t99HDHtn9v/DneG8CJEEzxzQM4fBM4fgmRN65jR4RhY8c0HPXAbPXIJnbuiZ2+AZRfDMAz3zGDzzCJ55oWdeg2dUwTMf9Mxn8MwneOaHnvkNntEEzwLQs4DBs4DgWRB6FjR4Rhc8C0HPQgbPQoJnYehZ2OAZQ/AsAj2LGDyLCJ5FoWdRg2dMwbMY9Cxm8CwmeBaHnsUNnrEEzxLQs4TBs4TgWRJ6ljR4xhY8S0HPUgbPUoJnaehZ2uAZR/AsAz3LGDzLCJ5loWdZg2dcwbMc9Cxn8CwneAbQMzB4xhM8y0PP8gbP8oJnBehZweAZX/CsCD0rGjwrCp6VoGclg2cCwbMy9Kxs8KwseFaBnlUMngkFz6rQs6rBs6rgWQ16VjN4JhI8q0PP6gbP6oJnDehZw+CZWPCsCT1rGjxrCp61oGctg2cSwbM29Kxt8KwteNaBnnUMnkkFz7rQs67Bs67gWQ961jN4JhM860PP+gbP+oJnA+jZwOCZXPBsCD0bGjwbCp6NoGcjg2cKwbMx9Gxs8GwseDaBnk0MnikFz6bQs6nBs6ng2Qx6NjN4phI8m0PP5gbP5oJnC+jZwuCZWvBsCT1bGjxbCp6toGcrg2cawbM19Gxt8GwteLaBnm0MnmkFz7bQs63Bs63g2Q56tjN4phM820PP9gbP9oJnB+jZweCZXvDsCD07Gjw7Cp6doGcng2cGwbMz9Oxs8OwseHaBnl0MnhkFz67Qs6vBs6vg2Q16djN4ZhI8u0PP7gbP7oJnD+jZw+CZWfDsCT17Gjx7Cp69oGcvg2cWwbM39Oxt8OwtePaBnn0MnlkFz77Qs6/Bs6/g2Q969jN4ZhM8+0PP/gbP/oLnAOg5wOCZXfAcCD0HGjwHCp6DoOcgg2cOwXMw9Bxs8BwseA6BnkMMnjkFz6HQc6jBc6jgOQx6DjN45hI8h0PP4QbP4YLnCOg5wuCZW/AcCT1HGjxHCp6joOcog2cewXM09Bxt8BwteI6BnmMMnnkFz7HQc6zBc6zgOQ56jjN45hM8x0PP8QbP8YLnBOg5weCZX/CcCD0nGjwnCp6ToOckg2cBwXMy9Jxs8JwseE6BnlMMngUFz6nQc6rBc6rgOQ16TjN4FhI8p0PP6QbP6YLnDOg5w+BZWPCcCT1nGjxnCp6zoOcsg2cRwXM29Jxt8JwteM6BnnMMnkUFz7nQc67Bc67gOQ96zjN4FhM850PP+QbP+YLnAui5wOBZXPBcCD0XGjwXCp6LoOcig2cJwXMx9Fxs8FwseC6BnksMniUFz6XQc6nBc6nguQx6LjN4lhI8l0PP5QbP5YLnCui5wuBZWvBcCT1XGjxXCp6roOcqg2cZwXM19Fxt8FwteK6BnmsMnmUFz7XQc63Bc63guQ56rjN4lhM810PP9QbP9YLnBui5weAZCJ4boedGg+dGwXMT9Nxk8CwveG6GnpsNnpsFzy3Qc4vBs4LguRV6bjV4bhU8t0HPbQbPioLndui53eC5XfDcAT13GDwrCZ47oedOg+dOwXMX9Nxl8KwseO6GnrsNnrsFzz3Qc4/Bs4rguRd67jV47hU890HPfQbPqoLnfui53+C5X/A8AD0PGDyrCZ4HoedBg+dBwfMQ9Dxk8KwueB6GnocNnocFzyPQ84jBs4bgeRR6HjV4HhU8j0HPYwbPmoLnceh53OB5XPA8AT1PGDxrCZ4noedJg+dJwfND6PmhwbO24HkKep4yeJ4SPD+Cnh8ZPOsInqeh52mD52nB82Po+bHBs67geQZ6njF4nhE8P4Genxg86wmeZ6HnWYPnWcHzU+j5qcGzvuB5DnqeM3ieEzw/g56fGTwbCJ7noed5g+d5wfNz6Pm5wbOh4HkBel4weF4QPL+Anl8YPBsJnheh50WD50XB80vo+aXBs7HgeQl6XjJ4XhI8v4KeXxk8mwiel6HnZYPnZcHza+j5tcGzqeB5BXpeMXheETy/gZ7fGDybCZ5XoedVg+dVwfNb6PmtwbO54HkNel4zeF4TPL+Dnt8ZPFsInteh53WD53XB83vo+b3Bs6XgeQN63jB43hA8f4CePxg8WwmeN6HnTYPnTcHzR+j5o8GzteB5C3reMnjeEjx/gp4/GTzbCJ63oedtg+dtwfMO9Lxj8GwreN6FnncNnncFz5+h588Gz3aC5z3oec/geU/w/AV6/mLwbC943oee9w2e9wXPX6HnrwbPDoLnA+j5wOD5QPD8DXr+ZvDsKHg+hJ4PDZ4PBc/foefvBs9Ogucj6PnI4PlI8PwDev5h8OwseD6Gno8Nno8Fzz+h558Gzy6C5xPo+cTg+UTw/At6/mXw7Cp4PoWeTw2eTwXPv6Hn3wbPboLnM+j5zOD5TPD8B3r+Y/DsLng+h57PDZ7PBc9/oee/Bs8egucL6PnC4PlC8PwPev5n8OwpeL6Eni8Nni8Fz1fQ85XBs5fg+Rp6vjZ4vhY830DPNwbP3oLnW+j51uD5VvB8Bz3fGTz7CJ7voed7g+d7wfODwszzf/9C9ewreEYozDwjFA7dM2w7vG1E6BnR4NlP8IwEPSMZPCMJnpGhZ2SDZ3/BMwr0jGLwjCJ4RoWeUQ2eAwTPaNAzmsEzmuAZHXpGN3gOFDxjQM8YBs8YgmdM6BnT4DlI8IwFPWMZPGMJnrGhZ2yD52DBMw70jGPwjCN4xoWecQ2eQwTPeNAznsEznuAZH3rGN3gOFTwTQM8EBs8EgmdC6JnQ4DlM8EwEPRMZPBMJnomhZ2KD53DBMwn0TGLwTCJ4JoWeSQ2eIwTPZNAzmcEzmeCZHHomN3iOFDxTQM8UBs8UgmdK6JnS4DlK8EwFPVMZPFMJnqmhZ2qD52jBMw30TGPwTCN4poWeaQ2eYwTPdNAzncEzneCZHnqmN3iOFTwzQM8MBs8MgmdG6JnR4DlO8MwEPTMZPDMJnpmhZ2aD53jBMwv0zGLwzCJ4ZoWeWQ2eEwTPbNAzm8Ezm+CZHXpmN3hOFDxzQM8cBs8cgmdO6JnT4DlJ8MwFPXMZPHMJnrmhZ26D52TBMw/0zGPwzCN45oWeeQ2eUwTPfNAzn8Ezn+CZH3rmN3hOFTwLQM8CBs8CgmdB6FnQ4DlN8CwEPQsZPAsJnoWhZ2GD53TBswj0LGLwLCJ4FoWeRQ2eMwTPYtCzmMGzmOBZHHoWN3jOFDxLQM8SBs8SgmdJ6FnS4DlL8CwFPUsZPEsJnqWhZ2mD52zBswz0LGPwLCN4loWeZQ2ecwTPctCznMGznOAZQM/A4DlX8CwPPcsbPMsLnhWgZwWD5zzBsyL0rGjwrCh4VoKelQye8wXPytCzssGzsuBZBXpWMXguEDyrQs+qBs+qgmc16FnN4LlQ8KwOPasbPKsLnjWgZw2D5yLBsyb0rGnwrCl41oKetQyeiwXP2tCztsGztuBZB3rWMXguETzrQs+6Bs+6gmc96FnP4LlU8KwPPesbPOsLng2gZwOD5zLBsyH0bGjwbCh4NoKejQyeywXPxtCzscGzseDZBHo2MXiuEDybQs+mBs+mgmcz6NnM4LlS8GwOPZsbPJsLni2gZwuD5yrBsyX0bGnwbCl4toKerQyeqwXP1tCztcGzteDZBnq2MXiuETzbQs+2Bs+2gmc76NnO4LlW8GwPPdsbPNsLnh2gZweD5zrBsyP07Gjw7Ch4doKenQye6wXPztCzs8Gzs+DZBXp2MXhuEDy7Qs+uBs+ugmc36NnN4LlR8OwOPbsbPLsLnj2gZw+D5ybBsyf07Gnw7Cl49oKevQyemwXP3tCzt8Gzt+DZB3r2MXhuETz7Qs++Bs++gmc/6NnP4LlV8OwPPfsbPPsLngOg5wCD5zbBcyD0HGjwHCh4DoKegwye2wXPwdBzsMFzsOA5BHoOMXjuEDyHQs+hBs+hgucw6DnM4LlT8BwOPYcbPIcLniOg5wiD5y7BcyT0HGnwHCl4joKeowyeuwXP0dBztMFztOA5BnqOMXjuETzHQs+xBs+xguc46DnO4LlX8BwPPccbPMcLnhOg5wSD5z7BcyL0nGjwnCh4ToKekwye+wXPydBzssFzsuA5BXpOMXgeEDynQs+pBs+pguc06DnN4HlQ8JwOPacbPKcLnjOg5wyD5yHBcyb0nGnwnCl4zoKeswyehwXP2dBztsFztuA5B3rOMXgeETznQs+5Bs+5guc86DnP4HlU8JwPPecbPOcLngug5wKD5zHBcyH0XGjwXCh4LoKeiwyexwXPxdBzscFzseC5BHouMXieEDyXQs+lBs+lgucy6LnM4HlS8FwOPZcbPJcLniug5wqD54eC50roudLguVLwXAU9Vxk8Twmeq6HnaoPnasFzDfRcY/D8SPBcCz3XGjzXCp7roOc6g+dpwXM99Fxv8FwveG6AnhsMnh8Lnhuh50aD50bBcxP03GTwPCN4boaemw2emwXPLdBzi8HzE8FzK/TcavDcKnhug57bDJ5nBc/t0HO7wXO74LkDeu4weH4qeO6EnjsNnjsFz13Qc5fB85zguRt67jZ47hY890DPPQbPzwTPvdBzr8Fzr+C5D3ruM3ieFzz3Q8/9Bs/9gucB6HnA4Pm54HkQeh40eB4UPA9Bz0MGzwuC52HoedjgeVjwPAI9jxg8vxA8j0LPowbPo4LnMeh5zOB5UfA8Dj2PGzyPC54noOcJg+eXgudJ6HnS4HlS8PwQen5o8LwkeJ6CnqcMnqcEz4+g50cGz68Ez9PQ87TB87Tg+TH0/NjgeVnwPAM9zxg8zwien0DPTwyeXwueZ6HnWYPnWcHzU+j5qcHziuB5DnqeM3ieEzw/g56fGTy/ETzPQ8/zBs/zgufn0PNzg+dVwfMC9Lxg8LwgeH4BPb8weH4reF6EnhcNnhcFzy+h55cGz2uC5yXoecngeUnw/Ap6fmXw/E7wvAw9Lxs8LwueX0PPrw2e1wXPK9DzisHziuD5DfT8xuD5veB5FXpeNXheFTy/hZ7fGjxvCJ7XoOc1g+c1wfM76PmdwfMHwfM69Lxu8LwueH4PPb83eN4UPG9AzxsGzxuC5w/Q8weD54+C503oedPgeVPw/BF6/mjwvCV43oKetwyetwTPn6DnTwbPnwTP29DztsHztuB5B3reMXjeFjzvQs+7Bs+7gufP0PNng+cdwfMe9Lxn8LwneP4CPX8xeN4VPO9Dz/sGz/uC56/Q81eD58+C5wPo+cDg+UDw/A16/mbwvCd4PoSeDw2eDwXP36Hn7wbPXwTPR9DzkcHzkeD5B/T8w+B5X/B8DD0fGzwfC55/Qs8/DZ6/Cp5PoOcTg+cTwfMv6PmXwfOB4PkUej41eD4VPP+Gnn8bPH8TPJ9Bz2cGz2eC5z/Q8x+D50PB8zn0fG7wfC54/gs9/zV4/i54voCeLwyeLwTP/6DnfwbPR4LnS+j50uD5UvB8BT1fGTz/EDxfQ8/XBs/Xgucb6PnG4PlY8HwLPd8aPN8Knu+g5zuD55+C53vo+d7g+V7w/KAI8/zfv1A9nwieEYowzwhFQvcM2w5vGxF6RjR4/iV4RoKekQyekQTPyNAzssHzqeAZBXpGMXhGETyjQs+oBs+/Bc9o0DOawTOa4BkdekY3eD4TPGNAzxgGzxiCZ0zoGdPg+Y/gGQt6xjJ4xhI8Y0PP2AbP54JnHOgZx+AZR/CMCz3jGjz/FTzjQc94Bs94gmd86Bnf4PlC8EwAPRMYPBMIngmhZ0KD53+CZyLomcjgmUjwTAw9Exs8XwqeSaBnEoNnEsEzKfRMavB8JXgmg57JDJ7JBM/k0DO5wfO14JkCeqYweKYQPFNCz5QGzzeCZyromcrgmUrwTA09Uxs83wqeaaBnGoNnGsEzLfRMa/B8J3img57pDJ7pBM/00DO9wfO94JkBemYweGYQPDNCz4wGzw8S/N/vzAQ9Mxk8MwmemaFnZoNnBMEzC/TMYvDMInhmhZ5ZDZ4RBc9s0DObwTOb4JkdemY3eEYSPHNAzxwGzxyCZ07omdPgGVnwzAU9cxk8cwmeuaFnboNnFMEzD/TMY/DMI3jmhZ55DZ5RBc980DOfwTOf4JkfeuY3eEYTPAtAzwIGzwKCZ0HoWdDgGV3wLAQ9Cxk8CwmehaFnYYNnDMGzCPQsYvAsIngWhZ5FDZ4xBc9i0LOYwbOY4FkcehY3eMYSPEtAzxIGzxKCZ0noWdLgGVvwLAU9Sxk8SwmepaFnaYNnHMGzDPQsY/AsI3iWhZ5lDZ5xBc9y0LOcwbOc4BlAz8DgGU/wLA89yxs8ywueFaBnBYNnfMGzIvSsaPCsKHhWgp6VDJ4JBM/K0LOywbOy4FkFelYxeCYUPKtCz6oGz6qCZzXoWc3gmUjwrA49qxs8qwueNaBnDYNnYsGzJvSsafCsKXjWgp61DJ5JBM/a0LO2wbO24FkHetYxeCYVPOtCz7oGz7qCZz3oWc/gmUzwrA896xs86wueDaBnA4NncsGzIfRsaPBsKHg2gp6NDJ4pBM/G0LOxwbOx4NkEejYxeKYUPJtCz6YGz6aCZzPo2czgmUrwbA49mxs8mwueLaBnC4NnasGzJfRsafBsKXi2gp6tDJ5pBM/W0LO1wbO14NkGerYxeKYVPNtCz7YGz7aCZzvo2c7gmU7wbA892xs82wueHaBnB4NnesGzI/TsaPDsKHh2gp6dDJ4ZBM/O0LOzwbOz4NkFenYxeGYUPLtCz64Gz66CZzfo2c3gmUnw7A49uxs8uwuePaBnD4NnZsGzJ/TsafDsKXj2gp69DJ5ZBM/e0LO3wbO34NkHevYxeGYVPPtCz74Gz76CZz/o2c/gmU3w7A89+xs8+wueA6DnAINndsFzIPQcaPAcKHgOgp6DDJ45BM/B0HOwwXOw4DkEeg4xeOYUPIdCz6EGz6GC5zDoOczgmUvwHA49hxs8hwueI6DnCINnbsFzJPQcafAcKXiOgp6jDJ55BM/R0HO0wXO04DkGeo4xeOYVPMdCz7EGz7GC5zjoOc7gmU/wHA89xxs8xwueE6DnBINnfsFzIvScaPCcKHhOgp6TDJ4FBM/J0HOywXOy4DkFek4xeBYUPKdCz6kGz6mC5zToOc3gWUjwnA49pxs8pwueM6DnDINnYcFzJvScafCcKXjOgp6zDJ5FBM/Z0HO2wXO24DkHes4xeBYVPOdCz7kGz7mC5zzoOc/gWUzwnA895xs85wueC6DnAoNnccFzIfRcaPBcKHgugp6LDJ4lBM/F0HOxwXOx4LkEei4xeJYUPJdCz6UGz6WC5zLouczgWUrwXA49lxs8lwueK6DnCoNnacFzJfRcafBcKXiugp6rDJ5lBM/V0HO1wXO14LkGeq4xeJYVPNdCz7UGz7WC5zrouc7gWU7wXA891xs81wueG6DnBoNnIHhuhJ4bDZ4bBc9N0HOTwbO84LkZem42eG4WPLdAzy0GzwqC51boudXguVXw3AY9txk8Kwqe26HndoPndsFzB/TcYfCsJHjuhJ47DZ47Bc9d0HOXwbOy4Lkbeu42eO4WPPdAzz0GzyqC517oudfguVfw3Ac99xk8qwqe+6HnfoPnfsHzAPQ8YPCsJngehJ4HDZ4HBc9D0POQwbO64HkYeh42eB4WPI9AzyMGzxqC51HoedTgeVTwPAY9jxk8awqex6HncYPnccHzBPQ8YfCsJXiehJ4nDZ4nBc8PoeeHBs/agucp6HnK4HlK8PwIen5k8KwjeJ6GnqcNnqcFz4+h58cGz7qC5xnoecbgeUbw/AR6fmLwrCd4noWeZw2eZwXPT6HnpwbP+oLnOeh5zuB5TvD8DHp+ZvBsIHieh57nDZ7nBc/PoefnBs+GgucF6HnB4HlB8PwCen5h8GwkeF6EnhcNnhcFzy+h55cGz8aC5yXoecngeUnw/Ap6fmXwbCJ4Xoaelw2elwXPr6Hn1wbPpoLnFeh5xeB5RfD8Bnp+Y/BsJnhehZ5XDZ5XBc9voee3Bs/mguc16HnN4HlN8PwOen5n8GwheF6HntcNntcFz++h5/cGz5aC5w3oecPgeUPw/AF6/mDwbCV43oSeNw2eNwXPH6HnjwbP1oLnLeh5y+B5S/D8CXr+ZPBsI3jehp63DZ63Bc870POOwbOt4HkXet41eN4VPH+Gnj8bPNsJnveg5z2D5z3B8xfo+YvBs73geR963jd43hc8f4Wevxo8OwieD6DnA4PnA8HzN+j5m8Gzo+D5EHo+NHg+FDx/h56/Gzw7CZ6PoOcjg+cjwfMP6PmHwbOz4PkYej42eD4WPP+Enn8aPLsInk+g5xOD5xPB8y/o+ZfBs6vg+RR6PjV4PhU8/4aefxs8uwmez6DnM4PnM8HzH+j5j8Gzu+D5HHo+N3g+Fzz/hZ7/Gjx7CJ4voOcLg+cLwfM/6PmfwbOn4PkSer40eL4UPF9Bz1cGz16C52vo+drg+VrwfAM93xg8ewueb6HnW4PnW8HzHfR8Z/DsI3i+h57vDZ7vBc8PijLP//0L1bOv4BmhKPOMUDR0z7Dt8LYRoWdEg2c/wTMS9Ixk8IwkeEaGnpENnv0FzyjQM4rBM4rgGRV6RjV4DhA8o0HPaAbPaIJndOgZ3eA5UPCMAT1jGDxjCJ4xoWdMg+cgwTMW9Ixl8IwleMaGnrENnoMFzzjQM47BM47gGRd6xjV4DhE840HPeAbPeIJnfOgZ3+A5VPBMAD0TGDwTCJ4JoWdCg+cwwTMR9Exk8EwkeCaGnokNnsMFzyTQM4nBM4ngmRR6JjV4jhA8k0HPZAbPZIJncuiZ3OA5UvBMAT1TGDxTCJ4poWdKg+cowTMV9Exl8EwleKaGnqkNnqMFzzTQM43BM43gmRZ6pjV4jhE800HPdAbPdIJneuiZ3uA5VvDMAD0zGDwzCJ4ZoWdGg+c4wTMT9Mxk8MwkeGaGnpkNnuMFzyzQM4vBM4vgmRV6ZjV4ThA8s0HPbAbPbIJnduiZ3eA5UfDMAT1zGDxzCJ45oWdOg+ckwTMX9Mxl8MwleOaGnrkNnpMFzzzQM4/BM4/gmRd65jV4ThE880HPfAbPfIJnfuiZ3+A5VfAsAD0LGDwLCJ4FoWdBg+c0wbMQ9Cxk8CwkeBaGnoUNntMFzyLQs4jBs4jgWRR6FjV4zhA8i0HPYgbPYoJncehZ3OA5U/AsAT1LGDxLCJ4loWdJg+cswbMU9Cxl8CwleJaGnqUNnrMFzzLQs4zBs4zgWRZ6ljV4zhE8y0HPcgbPcoJnAD0Dg+dcwbM89Cxv8CwveFaAnhUMnvMEz4rQs6LBs6LgWQl6VjJ4zhc8K0PPygbPyoJnFehZxeC5QPCsCj2rGjyrCp7VoGc1g+dCwbM69Kxu8KwueNaAnjUMnosEz5rQs6bBs6bgWQt61jJ4LhY8a0PP2gbP2oJnHehZx+C5RPCsCz3rGjzrCp71oGc9g+dSwbM+9Kxv8KwveDaAng0MnssEz4bQs6HBs6Hg2Qh6NjJ4Lhc8G0PPxgbPxoJnE+jZxOC5QvBsCj2bGjybCp7NoGczg+dKwbM59Gxu8GwueLaAni0MnqsEz5bQs6XBs6Xg2Qp6tjJ4rhY8W0PP1gbP1oJnG+jZxuC5RvBsCz3bGjzbCp7toGc7g+dawbM99Gxv8GwveHaAnh0MnusEz47Qs6PBs6Pg2Ql6djJ4rhc8O0PPzgbPzoJnF+jZxeC5QfDsCj27Gjy7Cp7doGc3g+dGwbM79Oxu8OwuePaAnj0MnpsEz57Qs6fBs6fg2Qt69jJ4bhY8e0PP3gbP3oJnH+jZx+C5RfDsCz37Gjz7Cp79oGc/g+dWwbM/9Oxv8OwveA6AngMMntsEz4HQc6DBc6DgOQh6DjJ4bhc8B0PPwQbPwYLnEOg5xOC5Q/AcCj2HGjyHCp7DoOcwg+dOwXM49Bxu8BwueI6AniMMnrsEz5HQc6TBc6TgOQp6jjJ47hY8R0PP0QbP0YLnGOg5xuC5R/AcCz3HGjzHCp7joOc4g+dewXM89Bxv8BwveE6AnhMMnvsEz4nQc6LBc6LgOQl6TjJ47hc8J0PPyQbPyYLnFOg5xeB5QPCcCj2nGjynCp7ToOc0g+dBwXM69Jxu8JwueM6AnjMMnocEz5nQc6bBc6bgOQt6zjJ4HhY8Z0PP2QbP2YLnHOg5x+B5RPCcCz3nGjznCp7zoOc8g+dRwXM+9Jxv8JwveC6AngsMnscEz4XQc6HBc6HguQh6LjJ4Hhc8F0PPxQbPxYLnEui5xOB5QvBcCj2XGjyXCp7LoOcyg+dJwXM59Fxu8FwueK6AnisMnh8Kniuh50qD50rBcxX0XGXwPCV4roaeqw2eqwXPNdBzjcHzI8FzLfRca/BcK3iug57rDJ6nBc/10HO9wXO94LkBem4weH4seG6EnhsNnhsFz03Qc5PB84zguRl6bjZ4bhY8t0DPLQbPTwTPrdBzq8Fzq+C5DXpuM3ieFTy3Q8/tBs/tgucO6LnD4Pmp4LkTeu40eO4UPHdBz10Gz3OC527oudvguVvw3AM99xg8PxM890LPvQbPvYLnPui5z+B5XvDcDz33Gzz3C54HoOcBg+fngudB6HnQ4HlQ8DwEPQ8ZPC8Inoeh52GD52HB8wj0PGLw/ELwPAo9jxo8jwqex6DnMYPnRcHzOPQ8bvA8LniegJ4nDJ5fCp4noedJg+dJwfND6PmhwfOS4HkKep4yeJ4SPD+Cnh8ZPL8SPE9Dz9MGz9OC58fQ82OD52XB8wz0PGPwPCN4fgI9PzF4fi14noWeZw2eZwXPT6HnpwbPK4LnOeh5zuB5TvD8DHp+ZvD8RvA8Dz3PGzzPC56fQ8/PDZ5XBc8L0POCwfOC4PkF9PzC4Pmt4HkRel40eF4UPL+Enl8aPK8Jnpeg5yWD5yXB8yvo+ZXB8zvB8zL0vGzwvCx4fg09vzZ4Xhc8r0DPKwbPK4LnN9DzG4Pn94LnVeh51eB5VfD8Fnp+a/C8IXheg57XDJ7XBM/voOd3Bs8fBM/r0PO6wfO64Pk99Pze4HlT8LwBPW8YPG8Inj9Azx8Mnj8Knjeh502D503B80fo+aPB85bgeQt63jJ43hI8f4KePxk8fxI8b0PP2wbP24LnHeh5x+B5W/C8Cz3vGjzvCp4/Q8+fDZ53BM970POewfOe4PkL9PzF4HlX8LwPPe8bPO8Lnr9Cz18Nnj8Lng+g5wOD5wPB8zfo+ZvB857g+RB6PjR4PhQ8f4eevxs8fxE8H0HPRwbPR4LnH9DzD4PnfcHzMfR8bPB8LHj+CT3/NHj+Kng+gZ5PDJ5PBM+/oOdfBs8HgudT6PnU4PlU8Pwbev5t8PxN8HwGPZ8ZPJ8Jnv9Az38Mng8Fz+fQ87nB87ng+S/0/Nfg+bvg+QJ6vjB4vhA8/4Oe/xk8HwmeL6HnS4PnS8HzFfR8ZfD8Q/B8DT1fGzxfC55voOcbg+djwfMt9Hxr8HwreL6Dnu8Mnn8Knu+h53uD53vB84NizPN//0L1fCJ4RijGPCMUC90zbDu8bUToGdHg+ZfgGQl6RjJ4RhI8I0PPyAbPp4JnFOgZxeAZRfCMCj2jGjz/FjyjQc9oBs9ogmd06Bnd4PlM8IwBPWMYPGMInjGhZ0yD5z+CZyzoGcvgGUvwjA09Yxs8nwuecaBnHINnHMEzLvSMa/D8V/CMBz3jGTzjCZ7xoWd8g+cLwTMB9Exg8EwgeCaEngkNnv8JnomgZyKDZyLBMzH0TGzwfCl4JoGeSQyeSQTPpNAzqcHzleCZDHomM3gmEzyTQ8/kBs/XgmcK6JnC4JlC8EwJPVMaPN8InqmgZyqDZyrBMzX0TG3wfCt4poGeaQyeaQTPtNAzrcHzneCZDnqmM3imEzzTQ8/0Bs/3gmcG6JnB4JlB8MwIPTMaPD9I+H+/MxP0zGTwzCR4ZoaemQ2eEQTPLNAzi8Ezi+CZFXpmNXhGFDyzQc9sBs9sgmd26Jnd4BlJ8MwBPXMYPHMInjmhZ06DZ2TBMxf0zGXwzCV45oaeuQ2eUQTPPNAzj8Ezj+CZF3rmNXhGFTzzQc98Bs98gmd+6Jnf4BlN8CwAPQsYPAsIngWhZ0GDZ3TBsxD0LGTwLCR4FoaehQ2eMQTPItCziMGziOBZFHoWNXjGFDyLQc9iBs9igmdx6Fnc4BlL8CwBPUsYPEsIniWhZ0mDZ2zBsxT0LGXwLCV4loaepQ2ecQTPMtCzjMGzjOBZFnqWNXjGFTzLQc9yBs9ygmcAPQODZzzBszz0LG/wLC94VoCeFQye8QXPitCzosGzouBZCXpWMngmEDwrQ8/KBs/KgmcV6FnF4JlQ8KwKPasaPKsKntWgZzWDZyLBszr0rG7wrC541oCeNQyeiQXPmtCzpsGzpuBZC3rWMngmETxrQ8/aBs/agmcd6FnH4JlU8KwLPesaPOsKnvWgZz2DZzLBsz70rG/wrC94NoCeDQyeyQXPhtCzocGzoeDZCHo2MnimEDwbQ8/GBs/GgmcT6NnE4JlS8GwKPZsaPJsKns2gZzODZyrBszn0bG7wbC54toCeLQyeqQXPltCzpcGzpeDZCnq2MnimETxbQ8/WBs/Wgmcb6NnG4JlW8GwLPdsaPNsKnu2gZzuDZzrBsz30bG/wbC94doCeHQye6QXPjtCzo8Gzo+DZCXp2MnhmEDw7Q8/OBs/OgmcX6NnF4JlR8OwKPbsaPLsKnt2gZzeDZybBszv07G7w7C549oCePQyemQXPntCzp8Gzp+DZC3r2MnhmETx7Q8/eBs/egmcf6NnH4JlV8OwLPfsaPPsKnv2gZz+DZzbBsz/07G/w7C94DoCeAwye2QXPgdBzoMFzoOA5CHoOMnjmEDwHQ8/BBs/BgucQ6DnE4JlT8BwKPYcaPIcKnsOg5zCDZy7Bczj0HG7wHC54joCeIwyeuQXPkdBzpMFzpOA5CnqOMnjmETxHQ8/RBs/RgucY6DnG4JlX8BwLPccaPMcKnuOg5ziDZz7Bczz0HG/wHC94ToCeEwye+QXPidBzosFzouA5CXpOMngWEDwnQ8/JBs/JgucU6DnF4FlQ8JwKPacaPKcKntOg5zSDZyHBczr0nG7wnC54zoCeMwyehQXPmdBzpsFzpuA5C3rOMngWETxnQ8/ZBs/Zgucc6DnH4FlU8JwLPecaPOcKnvOg5zyDZzHBcz70nG/wnC94LoCeCwyexQXPhdBzocFzoeC5CHouMniWEDwXQ8/FBs/FgucS6LnE4FlS8FwKPZcaPJcKnsug5zKDZynBczn0XG7wXC54roCeKwyepQXPldBzpcFzpeC5CnquMniWETxXQ8/VBs/Vguca6LnG4FlW8FwLPdcaPNcKnuug5zqDZznBcz30XG/wXC94boCeGwyegeC5EXpuNHhuFDw3Qc9NBs/ygudm6LnZ4LlZ8NwCPbcYPCsInluh51aD51bBcxv03GbwrCh4boee2w2e2wXPHdBzh8GzkuC5E3ruNHjuFDx3Qc9dBs/Kgudu6Lnb4Llb8NwDPfcYPKsInnuh516D517Bcx/03GfwrCp47oee+w2e+wXPA9DzgMGzmuB5EHoeNHgeFDwPQc9DBs/qgudh6HnY4HlY8DwCPY8YPGsInkeh51GD51HB8xj0PGbwrCl4Hoeexw2exwXPE9DzhMGzluB5EnqeNHieFDw/hJ4fGjxrC56noOcpg+cpwfMj6PmRwbOO4Hkaep42eJ4WPD+Gnh8bPOsKnmeg5xmD5xnB8xPo+YnBs57geRZ6njV4nhU8P4Wenxo86wue56DnOYPnOcHzM+j5mcGzgeB5HnqeN3ieFzw/h56fGzwbCp4XoOcFg+cFwfML6PmFwbOR4HkRel40eF4UPL+Enl8aPBsLnpeg5yWD5yXB8yvo+ZXBs4ngeRl6XjZ4XhY8v4aeXxs8mwqeV6DnFYPnFcHzG+j5jcGzmeB5FXpeNXheFTy/hZ7fGjybC57XoOc1g+c1wfM76PmdwbOF4Hkdel43eF4XPL+Hnt8bPFsKnjeg5w2D5w3B8wfo+YPBs5XgeRN63jR43hQ8f4SePxo8Wwuet6DnLYPnLcHzJ+j5k8GzjeB5G3reNnjeFjzvQM87Bs+2gudd6HnX4HlX8PwZev5s8GwneN6DnvcMnvcEz1+g5y8Gz/aC533oed/geV/w/BV6/mrw7CB4PoCeDwyeDwTP36DnbwbPjoLnQ+j50OD5UPD8HXr+bvDsJHg+gp6PDJ6PBM8/oOcfBs/Ogudj6PnY4PlY8PwTev5p8OwieD6Bnk8Mnk8Ez7+g518Gz66C51Po+dTg+VTw/Bt6/m3w7CZ4PoOezwyezwTPf6DnPwbP7oLnc+j53OD5XPD8F3r+a/DsIXi+gJ4vDJ4vBM//oOd/Bs+egudL6PnS4PlS8HwFPV8ZPHsJnq+h52uD52vB8w30fGPw7C14voWebw2ebwXPd9DzncGzj+D5Hnq+N3i+Fzw/KM48//cvVM++gmeE4swzQvHQPcO2w9tGhJ4RDZ79BM9I0DOSwTOS4BkZekY2ePYXPKNAzygGzyiCZ1ToGdXgOUDwjAY9oxk8owme0aFndIPnQMEzBvSMYfCMIXjGhJ4xDZ6DBM9Y0DOWwTOW4BkbesY2eA4WPONAzzgGzziCZ1zoGdfgOUTwjAc94xk84wme8aFnfIPnUMEzAfRMYPBMIHgmhJ4JDZ7DBM9E0DORwTOR4JkYeiY2eA4XPJNAzyQGzySCZ1LomdTgOULwTAY9kxk8kwmeyaFncoPnSMEzBfRMYfBMIXimhJ4pDZ6jBM9U0DOVwTOV4JkaeqY2eI4WPNNAzzQGzzSCZ1romdbgOUbwTAc90xk80wme6aFneoPnWMEzA/TMYPDMIHhmhJ4ZDZ7jBM9M0DOTwTOT4JkZemY2eI4XPLNAzywGzyyCZ1bomdXgOUHwzAY9sxk8swme2aFndoPnRMEzB/TMYfDMIXjmhJ45DZ6TBM9c0DOXwTOX4JkbeuY2eE4WPPNAzzwGzzyCZ17omdfgOUXwzAc98xk88wme+aFnfoPnVMGzAPQsYPAsIHgWhJ4FDZ7TBM9C0LOQwbOQ4FkYehY2eE4XPItAzyIGzyKCZ1HoWdTgOUPwLAY9ixk8iwmexaFncYPnTMGzBPQsYfAsIXiWhJ4lDZ6zBM9S0LOUwbOU4FkaepY2eM4WPMtAzzIGzzKCZ1noWdbgOUfwLAc9yxk8ywmeAfQMDJ5zBc/y0LO8wbO84FkBelYweM4TPCtCz4oGz4qCZyXoWcngOV/wrAw9Kxs8KwueVaBnFYPnAsGzKvSsavCsKnhWg57VDJ4LBc/q0LO6wbO64FkDetYweC4SPGtCz5oGz5qCZy3oWcvguVjwrA09axs8awuedaBnHYPnEsGzLvSsa/CsK3jWg571DJ5LBc/60LO+wbO+4NkAejYweC4TPBtCz4YGz4aCZyPo2cjguVzwbAw9Gxs8GwueTaBnE4PnCsGzKfRsavBsKng2g57NDJ4rBc/m0LO5wbO54NkCerYweK4SPFtCz5YGz5aCZyvo2crguVrwbA09Wxs8WwuebaBnG4PnGsGzLfRsa/BsK3i2g57tDJ5rBc/20LO9wbO94NkBenYweK4TPDtCz44Gz46CZyfo2cnguV7w7Aw9Oxs8OwueXaBnF4PnBsGzK/TsavDsKnh2g57dDJ4bBc/u0LO7wbO74NkDevYweG4SPHtCz54Gz56CZy/o2cvguVnw7A09exs8ewuefaBnH4PnFsGzL/Tsa/DsK3j2g579DJ5bBc/+0LO/wbO/4DkAeg4weG4TPAdCz4EGz4GC5yDoOcjguV3wHAw9Bxs8BwueQ6DnEIPnDsFzKPQcavAcKngOg57DDJ47Bc/h0HO4wXO44DkCeo4weO4SPEdCz5EGz5GC5yjoOcrguVvwHA09Rxs8RwueY6DnGIPnHsFzLPQca/AcK3iOg57jDJ57Bc/x0HO8wXO84DkBek4weO4TPCdCz4kGz4mC5yToOcnguV/wnAw9Jxs8JwueU6DnFIPnAcFzKvScavCcKnhOg57TDJ4HBc/p0HO6wXO64DkDes4weB4SPGdCz5kGz5mC5yzoOcvgeVjwnA09Zxs8Zwuec6DnHIPnEcFzLvSca/CcK3jOg57zDJ5HBc/50HO+wXO+4LkAei4weB4TPBdCz4UGz4WC5yLoucjgeVzwXAw9Fxs8FwueS6DnEoPnCcFzKfRcavBcKngug57LDJ4nBc/l0HO5wXO54LkCeq4weH4oeK6EnisNnisFz1XQc5XB85TguRp6rjZ4rhY810DPNQbPjwTPtdBzrcFzreC5DnquM3ieFjzXQ8/1Bs/1gucG6LnB4Pmx4LkRem40eG4UPDdBz00GzzOC52boudnguVnw3AI9txg8PxE8t0LPrQbPrYLnNui5zeB5VvDcDj23Gzy3C547oOcOg+engudO6LnT4LlT8NwFPXcZPM8Jnruh526D527Bcw/03GPw/Ezw3As99xo89wqe+6DnPoPnecFzP/Tcb/DcL3gegJ4HDJ6fC54HoedBg+dBwfMQ9Dxk8LwgeB6GnocNnocFzyPQ84jB8wvB8yj0PGrwPCp4HoOexwyeFwXP49DzuMHzuOB5AnqeMHh+KXiehJ4nDZ4nBc8PoeeHBs9Lgucp6HnK4HlK8PwIen5k8PxK8DwNPU8bPE8Lnh9Dz48NnpcFzzPQ84zB84zg+Qn0/MTg+bXgeRZ6njV4nhU8P4Wenxo8rwie56DnOYPnOcHzM+j5mcHzG8HzPPQ8b/A8L3h+Dj0/N3heFTwvQM8LBs8LgucX0PMLg+e3gudF6HnR4HlR8PwSen5p8LwmeF6CnpcMnpcEz6+g51cGz+8Ez8vQ87LB87Lg+TX0/NrgeV3wvAI9rxg8rwie30DPbwye3wueV6HnVYPnVcHzW+j5rcHzhuB5DXpeM3heEzy/g57fGTx/EDyvQ8/rBs/rguf30PN7g+dNwfMG9Lxh8LwheP4APX8weP4oeN6EnjcNnjcFzx+h548Gz1uC5y3oecvgeUvw/Al6/mTw/EnwvA09bxs8bwued6DnHYPnbcHzLvS8a/C8K3j+DD1/NnjeETzvQc97Bs97gucv0PMXg+ddwfM+9Lxv8LwveP4KPX81eP4seD6Ang8Mng8Ez9+g528Gz3uC50Po+dDg+VDw/B16/m7w/EXwfAQ9Hxk8Hwmef0DPPwye9wXPx9DzscHzseD5J/T80+D5q+D5BHo+MXg+ETz/gp5/GTwfCJ5PoedTg+dTwfNv6Pm3wfM3wfMZ9Hxm8HwmeP4DPf8xeD4UPJ9Dz+cGz+eC57/Q81+D5++C5wvo+cLg+ULw/A96/mfwfCR4voSeLw2eLwXPV9DzlcHzD8HzNfR8bfB8LXi+gZ5vDJ6PBc+30POtwfOt4PkOer4zeP4peL6Hnu8Nnu8Fzw9KMM///QvV84ngGaEE84xQInTPsO3wthGhZ0SD51+CZyToGcngGUnwjAw9Ixs8nwqeUaBnFINnFMEzKvSMavD8W/CMBj2jGTyjCZ7RoWd0g+czwTMG9Ixh8IwheMaEnjENnv8InrGgZyyDZyzBMzb0jG3wfC54xoGecQyecQTPuNAzrsHzX8EzHvSMZ/CMJ3jGh57xDZ4vBM8E0DOBwTOB4JkQeiY0eP4neCaCnokMnokEz8TQM7HB86XgmQR6JjF4JhE8k0LPpAbPV4JnMuiZzOCZTPBMDj2TGzxfC54poGcKg2cKwTMl9Exp8HwjeKaCnqkMnqkEz9TQM7XB863gmQZ6pjF4phE800LPtAbPd4JnOuiZzuCZTvBMDz3TGzzfC54ZoGcGg2cGwTMj9Mxo8Pwg0f/9zkzQM5PBM5PgmRl6ZjZ4RhA8s0DPLAbPLIJnVuiZ1eAZUfDMBj2zGTyzCZ7ZoWd2g2ckwTMH9Mxh8MwheOaEnjkNnpEFz1zQM5fBM5fgmRt65jZ4RhE880DPPAbPPIJnXuiZ1+AZVfDMBz3zGTzzCZ75oWd+g2c0wbMA9Cxg8CwgeBaEngUNntEFz0LQs5DBs5DgWRh6FjZ4xhA8i0DPIgbPIoJnUehZ1OAZU/AsBj2LGTyLCZ7FoWdxg2cswbME9Cxh8CwheJaEniUNnrEFz1LQs5TBs5TgWRp6ljZ4xhE8y0DPMgbPMoJnWehZ1uAZV/AsBz3LGTzLCZ4B9AwMnvEEz/LQs7zBs7zgWQF6VjB4xhc8K0LPigbPioJnJehZyeCZQPCsDD0rGzwrC55VoGcVg2dCwbMq9Kxq8KwqeFaDntUMnokEz+rQs7rBs7rgWQN61jB4JhY8a0LPmgbPmoJnLehZy+CZRPCsDT1rGzxrC551oGcdg2dSwbMu9Kxr8KwreNaDnvUMnskEz/rQs77Bs77g2QB6NjB4Jhc8G0LPhgbPhoJnI+jZyOCZQvBsDD0bGzwbC55NoGcTg2dKwbMp9Gxq8GwqeDaDns0MnqkEz+bQs7nBs7ng2QJ6tjB4phY8W0LPlgbPloJnK+jZyuCZRvBsDT1bGzxbC55toGcbg2dawbMt9Gxr8GwreLaDnu0MnukEz/bQs73Bs73g2QF6djB4phc8O0LPjgbPjoJnJ+jZyeCZQfDsDD07Gzw7C55doGcXg2dGwbMr9Oxq8OwqeHaDnt0MnpkEz+7Qs7vBs7vg2QN69jB4ZhY8e0LPngbPnoJnL+jZy+CZRfDsDT17Gzx7C559oGcfg2dWwbMv9Oxr8OwrePaDnv0MntkEz/7Qs7/Bs7/gOQB6DjB4Zhc8B0LPgQbPgYLnIOg5yOCZQ/AcDD0HGzwHC55DoOcQg2dOwXMo9Bxq8BwqeA6DnsMMnrkEz+HQc7jBc7jgOQJ6jjB45hY8R0LPkQbPkYLnKOg5yuCZR/AcDT1HGzxHC55joOcYg2dewXMs9Bxr8BwreI6DnuMMnvkEz/HQc7zBc7zgOQF6TjB45hc8J0LPiQbPiYLnJOg5yeBZQPCcDD0nGzwnC55ToOcUg2dBwXMq9Jxq8JwqeE6DntMMnoUEz+nQc7rBc7rgOQN6zjB4FhY8Z0LPmQbPmYLnLOg5y+BZRPCcDT1nGzxnC55zoOccg2dRwXMu9Jxr8JwreM6DnvMMnsUEz/nQc77Bc77guQB6LjB4Fhc8F0LPhQbPhYLnIui5yOBZQvBcDD0XGzwXC55LoOcSg2dJwXMp9Fxq8FwqeC6DnssMnqUEz+XQc7nBc7nguQJ6rjB4lhY8V0LPlQbPlYLnKui5yuBZRvBcDT1XGzxXC55roOcag2dZwXMt9Fxr8FwreK6DnusMnuUEz/XQc73Bc73guQF6bjB4BoLnRui50eC5UfDcBD03GTzLC56boedmg+dmwXML9Nxi8KwgeG6FnlsNnlsFz23Qc5vBs6LguR16bjd4bhc8d0DPHQbPSoLnTui50+C5U/DcBT13GTwrC567oedug+duwXMP9Nxj8KwieO6FnnsNnnsFz33Qc5/Bs6rguR967jd47hc8D0DPAwbPaoLnQeh50OB5UPA8BD0PGTyrC56Hoedhg+dhwfMI9Dxi8KwheB6FnkcNnkcFz2PQ85jBs6bgeRx6Hjd4Hhc8T0DPEwbPWoLnSeh50uB5UvD8EHp+aPCsLXiegp6nDJ6nBM+PoOdHBs86gudp6Hna4Hla8PwYen5s8KwreJ6BnmcMnmcEz0+g5ycGz3qC51noedbgeVbw/BR6fmrwrC94noOe5wye5wTPz6DnZwbPBoLneeh53uB5XvD8HHp+bvBsKHhegJ4XDJ4XBM8voOcXBs9GgudF6HnR4HlR8PwSen5p8GwseF6CnpcMnpcEz6+g51cGzyaC52XoedngeVnw/Bp6fm3wbCp4XoGeVwyeVwTPb6DnNwbPZoLnVeh51eB5VfD8Fnp+a/BsLnheg57XDJ7XBM/voOd3Bs8Wgud16Hnd4Hld8Pween5v8GwpeN6AnjcMnjcEzx+g5w8Gz1aC503oedPgeVPw/BF6/mjwbC143oKetwyetwTPn6DnTwbPNoLnbeh52+B5W/C8Az3vGDzbCp53oeddg+ddwfNn6PmzwbOd4HkPet4zeN4TPH+Bnr8YPNsLnveh532D533B81fo+avBs4Pg+QB6PjB4PhA8f4Oevxk8OwqeD6HnQ4PnQ8Hzd+j5u8Gzk+D5CHo+Mng+Ejz/gJ5/GDw7C56Poedjg+djwfNP6PmnwbOL4PkEej4xeD4RPP+Cnn8ZPLsKnk+h51OD51PB82/o+bfBs5vg+Qx6PjN4PhM8/4Ge/xg8uwuez6Hnc4Pnc8HzX+j5r8Gzh+D5Anq+MHi+EDz/g57/GTx7Cp4voedLg+dLwfMV9Hxl8OwleL6Gnq8Nnq8FzzfQ843Bs7fg+RZ6vjV4vhU830HPdwbPPoLne+j53uD5XvD8oCTz/N+/UD37Cp4RSjLPCCVD9wzbDm8bEXpGNHj2EzwjQc9IBs9Igmdk6BnZ4Nlf8IwCPaMYPKMInlGhZ1SD5wDBMxr0jGbwjCZ4Roee0Q2eAwXPGNAzhsEzhuAZE3rGNHgOEjxjQc9YBs9Ygmds6Bnb4DlY8IwDPeMYPOMInnGhZ1yD5xDBMx70jGfwjCd4xoee8Q2eQwXPBNAzgcEzgeCZEHomNHgOEzwTQc9EBs9Egmdi6JnY4Dlc8EwCPZMYPJMInkmhZ1KD5wjBMxn0TGbwTCZ4JoeeyQ2eIwXPFNAzhcEzheCZEnqmNHiOEjxTQc9UBs9Ugmdq6Jna4Dla8EwDPdMYPNMInmmhZ1qD5xjBMx30TGfwTCd4poee6Q2eYwXPDNAzg8Ezg+CZEXpmNHiOEzwzQc9MBs9Mgmdm6JnZ4Dle8MwCPbMYPLMInlmhZ1aD5wTBMxv0zGbwzCZ4Zoee2Q2eEwXPHNAzh8Ezh+CZE3rmNHhOEjxzQc9cBs9cgmdu6Jnb4DlZ8MwDPfMYPPMInnmhZ16D5xTBMx/0zGfwzCd45oee+Q2eUwXPAtCzgMGzgOBZEHoWNHhOEzwLQc9CBs9Cgmdh6FnY4Dld8CwCPYsYPIsInkWhZ1GD5wzBsxj0LGbwLCZ4FoeexQ2eMwXPEtCzhMGzhOBZEnqWNHjOEjxLQc9SBs9Sgmdp6Fna4Dlb8CwDPcsYPMsInmWhZ1mD5xzBsxz0LGfwLCd4BtAzMHjOFTzLQ8/yBs/ygmcF6FnB4DlP8KwIPSsaPCsKnpWgZyWD53zBszL0rGzwrCx4VoGeVQyeCwTPqtCzqsGzquBZDXpWM3guFDyrQ8/qBs/qgmcN6FnD4LlI8KwJPWsaPGsKnrWgZy2D52LBszb0rG3wrC141oGedQyeSwTPutCzrsGzruBZD3rWM3guFTzrQ8/6Bs/6gmcD6NnA4LlM8GwIPRsaPBsKno2gZyOD53LBszH0bGzwbCx4NoGeTQyeKwTPptCzqcGzqeDZDHo2M3iuFDybQ8/mBs/mgmcL6NnC4LlK8GwJPVsaPFsKnq2gZyuD52rBszX0bG3wbC14toGebQyeawTPttCzrcGzreDZDnq2M3iuFTzbQ8/2Bs/2gmcH6NnB4LlO8OwIPTsaPDsKnp2gZyeD53rBszP07Gzw7Cx4doGeXQyeGwTPrtCzq8Gzq+DZDXp2M3huFDy7Q8/uBs/ugmcP6NnD4LlJ8OwJPXsaPHsKnr2gZy+D52bBszf07G3w7C149oGefQyeWwTPvtCzr8Gzr+DZD3r2M3huFTz7Q8/+Bs/+gucA6DnA4LlN8BwIPQcaPAcKnoOg5yCD53bBczD0HGzwHCx4DoGeQwyeOwTPodBzqMFzqOA5DHoOM3juFDyHQ8/hBs/hgucI6DnC4LlL8BwJPUcaPEcKnqOg5yiD527BczT0HG3wHC14joGeYwyeewTPsdBzrMFzrOA5DnqOM3juFTzHQ8/xBs/xgucE6DnB4LlP8JwIPScaPCcKnpOg5ySD537BczL0nGzwnCx4ToGeUwyeBwTPqdBzqsFzquA5DXpOM3geFDynQ8/pBs/pgucM6DnD4HlI8JwJPWcaPGcKnrOg5yyD52HBczb0nG3wnC14zoGecwyeRwTPudBzrsFzruA5D3rOM3geFTznQ8/5Bs/5gucC6LnA4HlM8FwIPRcaPBcKnoug5yKD53HBczH0XGzwXCx4LoGeSwyeJwTPpdBzqcFzqeC5DHouM3ieFDyXQ8/lBs/lgucK6LnC4Pmh4LkSeq40eK4UPFdBz1UGz1OC52roudrguVrwXAM91xg8PxI810LPtQbPtYLnOui5zuB5WvBcDz3XGzzXC54boOcGg+fHgudG6LnR4LlR8NwEPTcZPM8Inpuh52aD52bBcwv03GLw/ETw3Ao9txo8twqe26DnNoPnWcFzO/TcbvDcLnjugJ47DJ6fCp47oedOg+dOwXMX9Nxl8DwneO6GnrsNnrsFzz3Qc4/B8zPBcy/03Gvw3Ct47oOe+wye5wXP/dBzv8Fzv+B5AHoeMHh+LngehJ4HDZ4HBc9D0POQwfOC4HkYeh42eB4WPI9AzyMGzy8Ez6PQ86jB86jgeQx6HjN4XhQ8j0PP4wbP44LnCeh5wuD5peB5EnqeNHieFDw/hJ4fGjwvCZ6noOcpg+cpwfMj6PmRwfMrwfM09Dxt8DwteH4MPT82eF4WPM9AzzMGzzOC5yfQ8xOD59eC51noedbgeVbw/BR6fmrwvCJ4noOe5wye5wTPz6DnZwbPbwTP89DzvMHzvOD5OfT83OB5VfC8AD0vGDwvCJ5fQM8vDJ7fCp4XoedFg+dFwfNL6PmlwfOa4HkJel4yeF4SPL+Cnl8ZPL8TPC9Dz8sGz8uC59fQ82uD53XB8wr0vGLwvCJ4fgM9vzF4fi94XoWeVw2eVwXPb6HntwbPG4LnNeh5zeB5TfD8Dnp+Z/D8QfC8Dj2vGzyvC57fQ8/vDZ43Bc8b0POGwfOG4PkD9PzB4Pmj4HkTet40eN4UPH+Enj8aPG8Jnreg5y2D5y3B8yfo+ZPB8yfB8zb0vG3wvC143oGedwyetwXPu9DzrsHzruD5M/T82eB5R/C8Bz3vGTzvCZ6/QM9fDJ53Bc/70PO+wfO+4Pkr9PzV4Pmz4PkAej4weD4QPH+Dnr8ZPO8Jng+h50OD50PB83fo+bvB8xfB8xH0fGTwfCR4/gE9/zB43hc8H0PPxwbPx4Lnn9DzT4Pnr4LnE+j5xOD5RPD8C3r+ZfB8IHg+hZ5PDZ5PBc+/oeffBs/fBM9n0POZwfOZ4PkP9PzH4PlQ8HwOPZ8bPJ8Lnv9Cz38Nnr8Lni+g5wuD5wvB8z/o+Z/B85Hg+RJ6vjR4vhQ8X0HPVwbPPwTP19DztcHzteD5Bnq+MXg+FjzfQs+3Bs+3guc76PnO4Pmn4Pkeer43eL4XPD8oxTz/9y9UzyeCZ4RSzDNCqdA9w7bD20aEnhENnn8JnpGgZySDZyTBMzL0jGzwfCp4RoGeUQyeUQTPqNAzqsHzb8EzGvSMZvCMJnhGh57RDZ7PBM8Y0DOGwTOG4BkTesY0eP4jeMaCnrEMnrEEz9jQM7bB87ngGQd6xjF4xhE840LPuAbPfwXPeNAznsEznuAZH3rGN3i+EDwTQM8EBs8EgmdC6JnQ4Pmf4JkIeiYyeCYSPBNDz8QGz5eCZxLomcTgmUTwTAo9kxo8XwmeyaBnMoNnMsEzOfRMbvB8LXimgJ4pDJ4pBM+U0DOlwfON4JkKeqYyeKYSPFNDz9QGz7eCZxromcbgmUbwTAs90xo83wme6aBnOoNnOsEzPfRMb/B8L3hmgJ4ZDJ4ZBM+M0DOjwfODxP/3OzNBz0wGz0yCZ2bomdnhmfz/fmeW/9Od/wPt90HYO//3L3M4dyrt8LZZ/293/v+gd/6fO7P+H+4M50WIIHhmg57ZDJ7ZBM/s0DO7wTOi4JkDeuYweOYQPHNCz5wGz0iCZy7omcvgmUvwzA09cxs8IwueeaBnHoNnHsEzL/TMa/CMInjmg575DJ75BM/80DO/wTOq4FkAehYweBYQPAtCz4IGz2iCZyHoWcjgWUjwLAw9Cxs8owueRaBnEYNnEcGzKPQsavCMIXgWg57FDJ7FBM/i0LO4wTOm4FkCepYweJYQPEtCz5IGz1iCZynoWcrgWUrwLA09Sxs8YwueZaBnGYNnGcGzLPQsa/CMI3iWg57lDJ7lBM8AegYGz7iCZ3noWd7gWV7wrAA9Kxg84wmeFaFnRYNnRcGzEvSsZPCML3hWhp6VDZ6VBc8q0LOKwTOB4FkVelY1eFYVPKtBz2oGz4SCZ3XoWd3gWV3wrAE9axg8EwmeNaFnTYNnTcGzFvSsZfBMLHjWhp61DZ61Bc860LOOwTOJ4FkXetY1eNYVPOtBz3oGz6SCZ33oWd/gWV/wbAA9Gxg8kwmeDaFnQ4NnQ8GzEfRsZPBMLng2hp6NDZ6NBc8m0LOJwTOF4NkUejY1eDYVPJtBz2YGz5SCZ3Po2dzg2VzwbAE9Wxg8UwmeLaFnS4NnS8GzFfRsZfBMLXi2hp6tDZ6tBc820LONwTON4NkWerY1eLYVPNtBz3YGz7SCZ3vo2d7g2V7w7AA9Oxg80wmeHaFnR4NnR8GzE/TsZPBML3h2hp6dDZ6dBc8u0LOLwTOD4NkVenY1eHYVPLtBz24Gz4yCZ3fo2d3g2V3w7AE9exg8MwmePaFnT4NnT8GzF/TsZfDMLHj2hp69DZ69Bc8+0LOPwTOL4NkXevY1ePYVPPtBz34Gz6yCZ3/o2d/g2V/wHAA9Bxg8swmeA6HnQIPnQMFzEPQcZPDMLngOhp6DDZ6DBc8h0HOIwTOH4DkUeg41eA4VPIdBz2EGz5yC53DoOdzgOVzwHAE9Rxg8cwmeI6HnSIPnSMFzFPQcZfDMLXiOhp6jDZ6jBc8x0HOMwTOP4DkWeo41eI4VPMdBz3EGz7yC53joOd7gOV7wnAA9Jxg88wmeE6HnRIPnRMFzEvScZPDML3hOhp6TDZ6TBc8p0HOKwbOA4DkVek41eE4VPKdBz2kGz4KC53ToOd3gOV3wnAE9Zxg8CwmeM6HnTIPnTMFzFvScZfAsLHjOhp6zDZ6zBc850HOOwbOI4DkXes41eM4VPOdBz3kGz6KC53zoOd/gOV/wXAA9Fxg8iwmeC6HnQoPnQsFzEfRcZPAsLnguhp6LDZ6LBc8l0HOJwbOE4LkUei41eC4VPJdBz2UGz5KC53LoudzguVzwXAE9Vxg8SwmeK6HnSoPnSsFzFfRcZfAsLXiuhp6rDZ6rBc810HONwbOM4LkWeq41eK4VPNdBz3UGz7KC53roud7guV7w3AA9Nxg8ywmeG6HnRoPnRsFzE/TcZPAMBM/N0HOzwXOz4LkFem4xeJYXPLdCz60Gz62C5zbouc3gWUHw3A49txs8twueO6DnDoNnRcFzJ/TcafDcKXjugp67DJ6VBM/d0HO3wXO34LkHeu4xeFYWPPdCz70Gz72C5z7ouc/gWUXw3A899xs89wueB6DnAYNnVcHzIPQ8aPA8KHgegp6HDJ7VBM/D0POwwfOw4HkEeh4xeFYXPI9Cz6MGz6OC5zHoeczgWUPwPA49jxs8jwueJ6DnCYNnTcHzJPQ8afA8KXh+CD0/NHjWEjxPQc9TBs9TgudH0PMjg2dtwfM09Dxt8DwteH4MPT82eNYRPM9AzzMGzzOC5yfQ8xODZ13B8yz0PGvwPCt4fgo9PzV41hM8z0HPcwbPc4LnZ9DzM4NnfcHzPPQ8b/A8L3h+Dj0/N3g2EDwvQM8LBs8LgucX0PMLg2dDwfMi9Lxo8LwoeH4JPb80eDYSPC9Bz0sGz0uC51fQ8yuDZ2PB8zL0vGzwvCx4fg09vzZ4NhE8r0DPKwbPK4LnN9DzG4NnU8HzKvS8avC8Knh+Cz2/NXg2EzyvQc9rBs9rgud30PM7g2dzwfM69Lxu8LwueH4PPb83eLYQPG9AzxsGzxuC5w/Q8weDZ0vB8yb0vGnwvCl4/gg9fzR4thI8b0HPWwbPW4LnT9DzJ4Nna8HzNvS8bfC8LXjegZ53DJ5tBM+70POuwfOu4Pkz9PzZ4NlW8LwHPe8ZPO8Jnr9Az18Mnu0Ez/vQ877B877g+Sv0/NXg2V7wfAA9Hxg8Hwiev0HP3wyeHQTPh9DzocHzoeD5O/T83eDZUfB8BD0fGTwfCZ5/QM8/DJ6dBM/H0POxwfOx4Pkn9PzT4NlZ8HwCPZ8YPJ8Inn9Bz78Mnl0Ez6fQ86nB86ng+Tf0/Nvg2VXwfAY9nxk8nwme/0DPfwye3QTP59DzucHzueD5L/T81+DZXfB8AT1fGDxfCJ7/Qc//DJ49BM+X0POlwfOl4PkKer4yePYUPF9Dz9cGz9eC5xvo+cbg2UvwfAs93xo83wqe76DnO4Nnb8HzPfR8b/B8L3h+UJp5/u9fqJ59BM8IpZlnhNKhe4Zth7eNCD0jGjz7Cp6RoGckg2ckwTMy9Ixs8OwneEaBnlEMnlEEz6jQM6rBs7/gGQ16RjN4RhM8o0PP6AbPAYJnDOgZw+AZQ/CMCT1jGjwHCp6xoGcsg2cswTM29Ixt8BwkeMaBnnEMnnEEz7jQM67Bc7DgGQ96xjN4xhM840PP+AbPIYJnAuiZwOCZQPBMCD0TGjyHCp6JoGcig2ciwTMx9Exs8BwmeCaBnkkMnkkEz6TQM6nBc7jgmQx6JjN4JhM8k0PP5AbPEYJnCuiZwuCZQvBMCT1TGjxHCp6poGcqg2cqwTM19Ext8BwleKaBnmkMnmkEz7TQM63Bc7TgmQ56pjN4phM800PP9AbPMYJnBuiZweCZQfDMCD0zGjzHCp6ZoGcmg2cmwTMz9Mxs8BwneGaBnlkMnlkEz6zQM6vBc7zgmQ16ZjN4ZhM8s0PP7AbPCYJnDuiZw+CZQ/DMCT1zGjwnCp65oGcug2cuwTM39Mxt8JwkeOaBnnkMnnkEz7zQM6/Bc7LgmQ965jN45hM880PP/AbPKYJnAehZwOBZQPAsCD0LGjynCp6FoGchg2chwbMw9Cxs8JwmeBaBnkUMnkUEz6LQs6jBc7rgWQx6FjN4FhM8i0PP4gbPGYJnCehZwuBZQvAsCT1LGjxnCp6loGcpg2cpwbM09Cxt8JwleJaBnmUMnmUEz7LQs6zBc7bgWQ56ljN4lhM8A+gZGDznCJ7loWd5g2d5wbMC9Kxg8JwreFaEnhUNnhUFz0rQs5LBc57gWRl6VjZ4VhY8q0DPKgbP+YJnVehZ1eBZVfCsBj2rGTwXCJ7VoWd1g2d1wbMG9Kxh8FwoeNaEnjUNnjUFz1rQs5bBc5HgWRt61jZ41hY860DPOgbPxYJnXehZ1+BZV/CsBz3rGTyXCJ71oWd9g2d9wbMB9Gxg8FwqeDaEng0Nng0Fz0bQs5HBc5ng2Rh6NjZ4NhY8m0DPJgbP5YJnU+jZ1ODZVPBsBj2bGTxXCJ7NoWdzg2dzwbMF9Gxh8FwpeLaEni0Nni0Fz1bQs5XBc5Xg2Rp6tjZ4thY820DPNgbP1YJnW+jZ1uDZVvBsBz3bGTzXCJ7toWd7g2d7wbMD9Oxg8FwreHaEnh0Nnh0Fz07Qs5PBc53g2Rl6djZ4dhY8u0DPLgbP9YJnV+jZ1eDZVfDsBj27GTw3CJ7doWd3g2d3wbMH9Oxh8NwoePaEnj0Nnj0Fz17Qs5fBc5Pg2Rt69jZ49hY8+0DPPgbPzYJnX+jZ1+DZV/DsBz37GTy3CJ79oWd/g2d/wXMA9Bxg8NwqeA6EngMNngMFz0HQc5DBc5vgORh6DjZ4DhY8h0DPIQbP7YLnUOg51OA5VPAcBj2HGTx3CJ7Doedwg+dwwXME9Bxh8NwpeI6EniMNniMFz1HQc5TBc5fgORp6jjZ4jhY8x0DPMQbP3YLnWOg51uA5VvAcBz3HGTz3CJ7joed4g+d4wXMC9Jxg8NwreE6EnhMNnhMFz0nQc5LBc5/gORl6TjZ4ThY8p0DPKQbP/YLnVOg51eA5VfCcBj2nGTwPCJ7Toed0g+d0wXMG9Jxh8DwoeM6EnjMNnjMFz1nQc5bB85DgORt6zjZ4zhY850DPOQbPw4LnXOg51+A5V/CcBz3nGTyPCJ7zoed8g+d8wXMB9Fxg8DwqeC6EngsNngsFz0XQc5HB85jguRh6LjZ4LhY8l0DPJQbP44LnUui51OC5VPBcBj2XGTxPCJ7Loedyg+dywXMF9Fxh8DwpeK6EnisNnisFz1XQc5XB80PBczX0XG3wXC14roGeawyepwTPtdBzrcFzreC5DnquM3h+JHiuh57rDZ7rBc8N0HODwfO04LkRem40eG4UPDdBz00Gz48Fz83Qc7PBc7PguQV6bjF4nhE8t0LPrQbPrYLnNui5zeD5ieC5HXpuN3huFzx3QM8dBs+zgudO6LnT4LlT8NwFPXcZPD8VPHdDz90Gz92C5x7oucfgeU7w3As99xo89wqe+6DnPoPnZ4Lnfui53+C5X/A8AD0PGDzPC54HoedBg+dBwfMQ9Dxk8Pxc8DwMPQ8bPA8Lnkeg5xGD5wXB8yj0PGrwPCp4HoOexwyeXwiex6HncYPnccHzBPQ8YfC8KHiehJ4nDZ4nBc8PoeeHBs8vBc9T0POUwfOU4PkR9PzI4HlJ8DwNPU8bPE8Lnh9Dz48Nnl8Jnmeg5xmD5xnB8xPo+YnB87LgeRZ6njV4nhU8P4Wenxo8vxY8z0HPcwbPc4LnZ9DzM4PnFcHzPPQ8b/A8L3h+Dj0/N3h+I3hegJ4XDJ4XBM8voOcXBs+rgudF6HnR4HlR8PwSen5p8PxW8LwEPS8ZPC8Jnl9Bz68MntcEz8vQ87LB87Lg+TX0/Nrg+Z3geQV6XjF4XhE8v4Ge3xg8rwueV6HnVYPnVcHzW+j5rcHze8HzGvS8ZvC8Jnh+Bz2/M3jeEDyvQ8/rBs/rguf30PN7g+cPgucN6HnD4HlD8PwBev5g8LwpeN6EnjcNnjcFzx+h548Gzx8Fz1vQ85bB85bg+RP0/MngeUvwvA09bxs8bwued6DnHYPnT4LnXeh51+B5V/D8GXr+bPC8LXjeg573DJ73BM9foOcvBs87gud96Hnf4Hlf8PwVev5q8LwreD6Ang8Mng8Ez9+g528Gz58Fz4fQ86HB86Hg+Tv0/N3geU/wfAQ9Hxk8Hwmef0DPPwyevwiej6HnY4PnY8HzT+j5p8HzvuD5BHo+MXg+ETz/gp5/GTx/FTyfQs+nBs+nguff0PNvg+cDwfMZ9Hxm8HwmeP4DPf8xeP4meD6Hns8Nns8Fz3+h578Gz4eC5wvo+cLg+ULw/A96/mfw/F3wfAk9Xxo8Xwqer6DnK4PnI8HzNfR8bfB8LXi+gZ5vDJ5/CJ5voedbg+dbwfMd9Hxn8HwseL6Hnu8Nnu8Fzw/KMM///QvV80/BM0IZ5hmhTOieYdvhbSNCz4gGzyeCZyToGcngGUnwjAw9Ixs8/xI8o0DPKAbPKIJnVOgZ1eD5VPCMBj2jGTyjCZ7RoWd0g+ffgmcM6BnD4BlD8IwJPWMaPJ8JnrGgZyyDZyzBMzb0jG3w/EfwjAM94xg84wiecaFnXIPnc8EzHvSMZ/CMJ3jGh57xDZ7/Cp4JoGcCg2cCwTMh9Exo8HwheCaCnokMnokEz8TQM7HB8z/BMwn0TGLwTCJ4JoWeSQ2eLwXPZNAzmcEzmeCZHHomN3i+EjxTQM8UBs8UgmdK6JnS4Pla8EwFPVMZPFMJnqmhZ2qD5xvBMw30TGPwTCN4poWeaQ2ebwXPdNAzncEzneCZHnqmN3i+EzwzQM8MBs8MgmdG6JnR4Ple8MwEPTMZPDMJnpmhZ2aD5wcp/u93ZoGeWQyeWQTPrNAzq8EzguCZDXpmM3hmEzyzQ8/sBs+IgmcO6JnD4JlD8MwJPXMaPCMJnrmgZy6DZy7BMzf0zG3wjCx45oGeeQyeeQTPvNAzr8EziuCZD3rmM3jmEzzzQ8/8Bs+ogmcB6FnA4FlA8CwIPQsaPKMJnoWgZyGDZyHBszD0LGzwjC54FoGeRQyeRQTPotCzqMEzhuBZDHoWM3gWEzyLQ8/iBs+YgmcJ6FnC4FlC8CwJPUsaPGMJnqWgZymDZynBszT0LG3wjC14loGeZQyeZQTPstCzrMEzjuBZDnqWM3iWEzwD6BkYPOMKnuWhZ3mDZ3nBswL0rGDwjCd4VoSeFQ2eFQXPStCzksEzvuBZGXpWNnhWFjyrQM8qBs8EgmdV6FnV4FlV8KwGPasZPBMKntWhZ3WDZ3XBswb0rGHwTCR41oSeNQ2eNQXPWtCzlsEzseBZG3rWNnjWFjzrQM86Bs8kgmdd6FnX4FlX8KwHPesZPJMKnvWhZ32DZ33BswH0bGDwTCZ4NoSeDQ2eDQXPRtCzkcEzueDZGHo2Nng2FjybQM8mBs8UgmdT6NnU4NlU8GwGPZsZPFMKns2hZ3ODZ3PBswX0bGHwTCV4toSeLQ2eLQXPVtCzlcEzteDZGnq2Nni2FjzbQM82Bs80gmdb6NnW4NlW8GwHPdsZPNMKnu2hZ3uDZ3vBswP07GDwTCd4doSeHQ2eHQXPTtCzk8EzveDZGXp2Nnh2Fjy7QM8uBs8MgmdX6NnV4NlV8OwGPbsZPDMKnt2hZ3eDZ3fBswf07GHwzCR49oSePQ2ePQXPXtCzl8Ezs+DZG3r2Nnj2Fjz7QM8+Bs8sgmdf6NnX4NlX8OwHPfsZPLMKnv2hZ3+DZ3/BcwD0HGDwzCZ4DoSeAw2eAwXPQdBzkMEzu+A5GHoONngOFjyHQM8hBs8cgudQ6DnU4DlU8BwGPYcZPHMKnsOh53CD53DBcwT0HGHwzCV4joSeIw2eIwXPUdBzlMEzt+A5GnqONniOFjzHQM8xBs88gudY6DnW4DlW8BwHPccZPPMKnuOh53iD53jBcwL0nGDwzCd4ToSeEw2eEwXPSdBzksEzv+A5GXpONnhOFjynQM8pBs8CgudU6DnV4DlV8JwGPacZPAsKntOh53SD53TBcwb0nGHwLCR4zoSeMw2eMwXPWdBzlsGzsOA5G3rONnjOFjznQM85Bs8igudc6DnX4DlX8JwHPecZPIsKnvOh53yD53zBcwH0XGDwLCZ4LoSeCw2eCwXPRdBzkcGzuOC5GHouNnguFjyXQM8lBs8SgudS6LnU4LlU8FwGPZcZPEsKnsuh53KD53LBcwX0XGHwLCV4roSeKw2eKwXPVdBzlcGztOC5GnquNniuFjzXQM81Bs8yguda6LnW4LlW8FwHPdcZPMsKnuuh53qD53rBcwP03GDwLCd4boSeGw2eGwXPTdBzk8EzEDw3Q8/NBs/NgucW6LnF4Fle8NwKPbcaPLcKntug5zaDZwXBczv03G7w3C547oCeOwyeFQXPndBzp8Fzp+C5C3ruMnhWEjx3Q8/dBs/dguce6LnH4FlZ8NwLPfcaPPcKnvug5z6DZxXBcz/03G/w3C94HoCeBwyeVQXPg9DzoMHzoOB5CHoeMnhWEzwPQ8/DBs/DgucR6HnE4Fld8DwKPY8aPI8Knseg5zGDZw3B8zj0PG7wPC54noCeJwyeNQXPk9DzpMHzpOD5IfT80OBZS/A8BT1PGTxPCZ4fQc+PDJ61Bc/T0PO0wfO04Pkx9PzY4FlH8DwDPc8YPM8Inp9Az08MnnUFz7PQ86zB86zg+Sn0/NTgWU/wPAc9zxk8zwmen0HPzwye9QXP89DzvMHzvOD5OfT83ODZQPC8AD0vGDwvCJ5fQM8vDJ4NBc+L0POiwfOi4Pkl9PzS4NlI8LwEPS8ZPC8Jnl9Bz68Mno0Fz8vQ87LB87Lg+TX0/Nrg2UTwvAI9rxg8rwie30DPbwyeTQXPq9DzqsHzquD5LfT81uDZTPC8Bj2vGTyvCZ7fQc/vDJ7NBc/r0PO6wfO64Pk99Pze4NlC8LwBPW8YPG8Inj9Azx8Mni0Fz5vQ86bB86bg+SP0/NHg2UrwvAU9bxk8bwmeP0HPnwyerQXP29DztsHztuB5B3reMXi2ETzvQs+7Bs+7gufP0PNng2dbwfMe9Lxn8LwneP4CPX8xeLYTPO9Dz/sGz/uC56/Q81eDZ3vB8wH0fGDwfCB4/gY9fzN4dhA8H0LPhwbPh4Ln79Dzd4NnR8HzEfR8ZPB8JHj+AT3/MHh2EjwfQ8/HBs/Hguef0PNPg2dnwfMJ9Hxi8HwieP4FPf8yeHYRPJ9Cz6cGz6eC59/Q82+DZ1fB8xn0fGbwfCZ4/gM9/zF4dhM8n0PP5wbP54Lnv9DzX4Nnd8HzBfR8YfB8IXj+Bz3/M3j2EDxfQs+XBs+Xgucr6PnK4NlT8HwNPV8bPF8Lnm+g5xuDZy/B8y30fGvwfCt4voOe7wyevQXP99DzvcHzveD5QVnm+b9/oXr2ETwjlGWeEcqG7hm2Hd42IvSMaPDsK3hGgp6RDJ6RBM/I0DOywbOf4BkFekYxeEYRPKNCz6gGz/6CZzToGc3gGU3wjA49oxs8BwieMaBnDINnDMEzJvSMafAcKHjGgp6xDJ6xBM/Y0DO2wXOQ4BkHesYxeMYRPONCz7gGz8GCZzzoGc/gGU/wjA894xs8hwieCaBnAoNnAsEzIfRMaPAcKngmgp6JDJ6JBM/E0DOxwXOY4JkEeiYxeCYRPJNCz6QGz+GCZzLomczgmUzwTA49kxs8RwieKaBnCoNnCsEzJfRMafAcKXimgp6pDJ6pBM/U0DO1wXOU4JkGeqYxeKYRPNNCz7QGz9GCZzromc7gmU7wTA890xs8xwieGaBnBoNnBsEzI/TMaPAcK3hmgp6ZDJ6ZBM/M0DOzwXOc4JkFemYxeGYRPLNCz6wGz/GCZzbomc3gmU3wzA49sxs8JwieOaBnDoNnDsEzJ/TMafCcKHjmgp65DJ65BM/c0DO3wXOS4JkHeuYxeOYRPPNCz7wGz8mCZz7omc/gmU/wzA898xs8pwieBaBnAYNnAcGzIPQsaPCcKngWgp6FDJ6FBM/C0LOwwXOa4FkEehYxeBYRPItCz6IGz+mCZzHoWczgWUzwLA49ixs8ZwieJaBnCYNnCcGzJPQsafCcKXiWgp6lDJ6lBM/S0LO0wXOW4FkGepYxeJYRPMtCz7IGz9mCZznoWc7gWU7wDKBnYPCcI3iWh57lDZ7lBc8K0LOCwXOu4FkRelY0eFYUPCtBz0oGz3mCZ2XoWdngWVnwrAI9qxg85wueVaFnVYNnVcGzGvSsZvBcIHhWh57VDZ7VBc8a0LOGwXOh4FkTetY0eNYUPGtBz1oGz0WCZ23oWdvgWVvwrAM96xg8FwuedaFnXYNnXcGzHvSsZ/BcInjWh571DZ71Bc8G0LOBwXOp4NkQejY0eDYUPBtBz0YGz2WCZ2Po2djg2VjwbAI9mxg8lwueTaFnU4NnU8GzGfRsZvBcIXg2h57NDZ7NBc8W0LOFwXOl4NkSerY0eLYUPFtBz1YGz1WCZ2vo2drg2VrwbAM92xg8VwuebaFnW4NnW8GzHfRsZ/BcI3i2h57tDZ7tBc8O0LODwXOt4NkRenY0eHYUPDtBz04Gz3WCZ2fo2dng2Vnw7AI9uxg81wueXaFnV4NnV8GzG/TsZvDcIHh2h57dDZ7dBc8e0LOHwXOj4NkTevY0ePYUPHtBz14Gz02CZ2/o2dvg2Vvw7AM9+xg8NwuefaFnX4NnX8GzH/TsZ/DcInj2h579DZ79Bc8B0HOAwXOr4DkQeg40eA4UPAdBz0EGz22C52DoOdjgOVjwHAI9hxg8twueQ6HnUIPnUMFzGPQcZvDcIXgOh57DDZ7DBc8R0HOEwXOn4DkSeo40eI4UPEdBz1EGz12C52joOdrgOVrwHAM9xxg8dwueY6HnWIPnWMFzHPQcZ/DcI3iOh57jDZ7jBc8J0HOCwXOv4DkRek40eE4UPCdBz0kGz32C52ToOdngOVnwnAI9pxg89wueU6HnVIPnVMFzGvScZvA8IHhOh57TDZ7TBc8Z0HOGwfOg4DkTes40eM4UPGdBz1kGz0OC52zoOdvgOVvwnAM95xg8Dwuec6HnXIPnXMFzHvScZ/A8InjOh57zDZ7zBc8F0HOBwfOo4LkQei40eC4UPBdBz0UGz2OC52LoudjguVjwXAI9lxg8jwueS6HnUoPnUsFzGfRcZvA8IXguh57LDZ7LBc8V0HOFwfOk4LkSeq40eK4UPFdBz1UGzw8Fz9XQc7XBc7XguQZ6rjF4nhI810LPtQbPtYLnOui5zuD5keC5HnquN3iuFzw3QM8NBs/TgudG6LnR4LlR8NwEPTcZPD8WPDdDz80Gz82C5xboucXgeUbw3Ao9txo8twqe26DnNoPnJ4Lndui53eC5XfDcAT13GDzPCp47oedOg+dOwXMX9Nxl8PxU8NwNPXcbPHcLnnug5x6D5znBcy/03Gvw3Ct47oOe+wyenwme+6HnfoPnfsHzAPQ8YPA8L3gehJ4HDZ4HBc9D0POQwfNzwfMw9Dxs8DwseB6BnkcMnhcEz6PQ86jB86jgeQx6HjN4fiF4Hoeexw2exwXPE9DzhMHzouB5EnqeNHieFDw/hJ4fGjy/FDxPQc9TBs9TgudH0PMjg+clwfM09Dxt8DwteH4MPT82eH4leJ6BnmcMnmcEz0+g5ycGz8uC51noedbgeVbw/BR6fmrw/FrwPAc9zxk8zwmen0HPzwyeVwTP89DzvMHzvOD5OfT83OD5jeB5AXpeMHheEDy/gJ5fGDyvCp4XoedFg+dFwfNL6PmlwfNbwfMS9Lxk8LwkeH4FPb8yeF4TPC9Dz8sGz8uC59fQ82uD53eC5xXoecXgeUXw/AZ6fmPwvC54XoWeVw2eVwXPb6HntwbP7wXPa9DzmsHzmuD5HfT8zuB5Q/C8Dj2vGzyvC57fQ8/vDZ4/CJ43oOcNg+cNwfMH6PmDwfOm4HkTet40eN4UPH+Enj8aPH8UPG9Bz1sGz1uC50/Q8yeD5y3B8zb0vG3wvC143oGedwyePwmed6HnXYPnXcHzZ+j5s8HztuB5D3reM3jeEzx/gZ6/GDzvCJ73oed9g+d9wfNX6PmrwfOu4PkAej4weD4QPH+Dnr8ZPH8WPB9Cz4cGz4eC5+/Q83eD5z3B8xH0fGTwfCR4/gE9/zB4/iJ4Poaejw2ejwXPP6HnnwbP+4LnE+j5xOD5RPD8C3r+ZfD8VfB8Cj2fGjyfCp5/Q8+/DZ4PBM9n0POZwfOZ4PkP9PzH4Pmb4Pkcej43eD4XPP+Fnv8aPB8Kni+g5wuD5wvB8z/o+Z/B83fB8yX0fGnwfCl4voKerwyejwTP19DztcHzteD5Bnq+MXj+IXi+hZ5vDZ5vBc930POdwfOx4Pkeer43eL4XPD8oxzz/9y9Uzz8FzwjlmGeEcqF7hm2Ht40IPSMaPJ8InpGgZySDZyTBMzL0jGzw/EvwjAI9oxg8owieUaFnVIPnU8EzGvSMZvCMJnhGh57RDZ5/C54xoGcMg2cMwTMm9Ixp8HwmeMaCnrEMnrEEz9jQM7bB8x/BMw70jGPwjCN4xoWecQ2ezwXPeNAznsEznuAZH3rGN3j+K3gmgJ4JDJ4JBM+E0DOhwfOF4JkIeiYyeCYSPBNDz8QGz/8EzyTQM4nBM4ngmRR6JjV4vhQ8k0HPZAbPZIJncuiZ3OD5SvBMAT1TGDxTCJ4poWdKg+drwTMV9Exl8EwleKaGnqkNnm8EzzTQM43BM43gmRZ6pjV4vhU800HPdAbPdIJneuiZ3uD5TvDMAD0zGDwzCJ4ZoWdGg2eExP/3OzP9n+6M9v5duvfjw975v3+5w7lTaYe3zfx/ujPe+zfl3kcMe2fm/8Od4bwIEQXPLNAzi8Ezi+CZFXpmNXhGEjyzQc9sBs9sgmd26Jnd4BlZ8MwBPXMYPHMInjmhZ06DZxTBMxf0zGXwzCV45oaeuQ2eUQXPPNAzj8Ezj+CZF3rmNXhGEzzzQc98Bs98gmd+6Jnf4Bld8CwAPQsYPAsIngWhZ0GDZwzBsxD0LGTwLCR4FoaehQ2eMQXPItCziMGziOBZFHoWNXjGEjyLQc9iBs9igmdx6Fnc4Blb8CwBPUsYPEsIniWhZ0mDZxzBsxT0LGXwLCV4loaepQ2ecQXPMtCzjMGzjOBZFnqWNXjGEzzLQc9yBs9ygmcAPQODZ3zBszz0LG/wLC94VoCeFQyeCQTPitCzosGzouBZCXpWMngmFDwrQ8/KBs/KgmcV6FnF4JlI8KwKPasaPKsKntWgZzWDZ2LBszr0rG7wrC541oCeNQyeSQTPmtCzpsGzpuBZC3rWMngmFTxrQ8/aBs/agmcd6FnH4JlM8KwLPesaPOsKnvWgZz2DZ3LBsz70rG/wrC94NoCeDQyeKQTPhtCzocGzoeDZCHo2MnimFDwbQ8/GBs/GgmcT6NnE4JlK8GwKPZsaPJsKns2gZzODZ2rBszn0bG7wbC54toCeLQyeaQTPltCzpcGzpeDZCnq2MnimFTxbQ8/WBs/Wgmcb6NnG4JlO8GwLPdsaPNsKnu2gZzuDZ3rBsz30bG/wbC94doCeHQyeGQTPjtCzo8Gzo+DZCXp2MnhmFDw7Q8/OBs/OgmcX6NnF4JlJ8OwKPbsaPLsKnt2gZzeDZ2bBszv07G7w7C549oCePQyeWQTPntCzp8Gzp+DZC3r2MnhmFTx7Q8/eBs/egmcf6NnH4JlN8OwLPfsaPPsKnv2gZz+DZ3bBsz/07G/w7C94DoCeAwyeOQTPgdBzoMFzoOA5CHoOMnjmFDwHQ8/BBs/BgucQ6DnE4JlL8BwKPYcaPIcKnsOg5zCDZ27Bczj0HG7wHC54joCeIwyeeQTPkdBzpMFzpOA5CnqOMnjmFTxHQ8/RBs/RgucY6DnG4JlP8BwLPccaPMcKnuOg5ziDZ37Bczz0HG/wHC94ToCeEwyeBQTPidBzosFzouA5CXpOMngWFDwnQ8/JBs/JgucU6DnF4FlI8JwKPacaPKcKntOg5zSDZ2HBczr0nG7wnC54zoCeMwyeRQTPmdBzpsFzpuA5C3rOMngWFTxnQ8/ZBs/Zgucc6DnH4FlM8JwLPecaPOcKnvOg5zyDZ3HBcz70nG/wnC94LoCeCwyeJQTPhdBzocFzoeC5CHouMniWFDwXQ8/FBs/FgucS6LnE4FlK8FwKPZcaPJcKnsug5zKDZ2nBczn0XG7wXC54roCeKwyeZQTPldBzpcFzpeC5CnquMniWFTxXQ8/VBs/Vguca6LnG4FlO8FwLPdcaPNcKnuug5zqDZyB4roee6w2e6wXPDdBzg8GzvOC5EXpuNHhuFDw3Qc9NBs8Kgudm6LnZ4LlZ8NwCPbcYPCsKnluh51aD51bBcxv03GbwrCR4boee2w2e2wXPHdBzh8GzsuC5E3ruNHjuFDx3Qc9dBs8qgudu6Lnb4Llb8NwDPfcYPKsKnnuh516D517Bcx/03GfwrCZ47oee+w2e+wXPA9DzgMGzuuB5EHoeNHgeFDwPQc9DBs8agudh6HnY4HlY8DwCPY8YPGsKnkeh51GD51HB8xj0PGbwrCV4Hoeexw2exwXPE9DzhMGztuB5EnqeNHieFDw/hJ4fGjzrCJ6noOcpg+cpwfMj6PmRwbOu4Hkaep42eJ4WPD+Gnh8bPOsJnmeg5xmD5xnB8xPo+YnBs77geRZ6njV4nhU8P4Wenxo8Gwie56DnOYPnOcHzM+j5mcGzoeB5HnqeN3ieFzw/h56fGzwbCZ4XoOcFg+cFwfML6PmFwbOx4HkRel40eF4UPL+Enl8aPJsInpeg5yWD5yXB8yvo+ZXBs6ngeRl6XjZ4XhY8v4aeXxs8mwmeV6DnFYPnFcHzG+j5jcGzueB5FXpeNXheFTy/hZ7fGjxbCJ7XoOc1g+c1wfM76PmdwbOl4Hkdel43eF4XPL+Hnt8bPFsJnjeg5w2D5w3B8wfo+YPBs7XgeRN63jR43hQ8f4SePxo82wiet6DnLYPnLcHzJ+j5k8GzreB5G3reNnjeFjzvQM87Bs92gudd6HnX4HlX8PwZev5s8GwveN6DnvcMnvcEz1+g5y8Gzw6C533oed/geV/w/BV6/mrw7Ch4PoCeDwyeDwTP36DnbwbPToLnQ+j50OD5UPD8HXr+bvDsLHg+gp6PDJ6PBM8/oOcfBs8ugudj6PnY4PlY8PwTev5p8OwqeD6Bnk8Mnk8Ez7+g518Gz26C51Po+dTg+VTw/Bt6/m3w7C54PoOezwyezwTPf6DnPwbPHoLnc+j53OD5XPD8F3r+a/DsKXi+gJ4vDJ4vBM//oOd/Bs9egudL6PnS4PlS8HwFPV8ZPHsLnq+h52uD52vB8w30fGPw7CN4voWebw2ebwXPd9DzncGzr+D5Hnq+N3i+Fzw/CJjn//6F6tlP8IwQMM8IQeieYdvhbSMGzDNiELpnf8EzUsA8IwWhe4Zth7eNHDDPyEHongMEzygB84wShO4Zth3eNmrAPKMGoXsOFDyjBcwzWhC6Z9h2eNvoAfOMHoTuOUjwjBEwzxhB6J5h2+FtYwbMM2YQuudgwTNWwDxjBaF7hm2Ht40dMM/YQeieQwTPOAHzjBOE7hm2Hd42bsA84wahew4VPOMFzDNeELpn2HZ42/gB84wfhO45TPBMEDDPBEHonmHb4W0TBswzYRC653DBM1HAPBMFoXuGbYe3TRwwz8RB6J4jBM8kAfNMEoTuGbYd3jZpwDyTBqF7jhQ8kwXMM1kQumfYdnjb5AHzTB6E7jlK8EwRMM8UQeieYdvhbVMGzDNlELrnaMEzVcA8UwWhe4Zth7dNHTDP1EHonmMEzzQB80wThO4Zth3eNm3APNMGoXuOFTzTBcwzXRC6Z9h2eNv0AfNMH4TuOU7wzBAwzwxB6J5h2+FtMwbMM2MQuud4wTNTwDwzBaF7hm2Ht80cMM/MQeieEwTPLAHzzBKE7hm2Hd42a8A8swahe04UPLMFzDNbELpn2HZ42+wB88wehO45SfDMETDPHEHonmHb4W1zBswzZxC652TBM1fAPHMFoXuGbYe3zR0wz9xB6J5TBM88AfPME4TuGbYd3jZvwDzzBqF7ThU88wXMM18QumfYdnjb/AHzzB+E7jlN8CwQMM8CQeieYdvhbQsGzLNgELrndMGzUMA8CwWhe4Zth7ctHDDPwkHonjMEzyIB8ywShO4Zth3etmjAPIsGoXvOFDyLBcyzWBC6Z9h2eNviAfMsHoTuOUvwLBEwzxJB6J5h2+FtSwbMs2QQuudswbNUwDxLBaF7hm2Hty0dMM/SQeiecwTPMgHzLBOE7hm2Hd62bMA8ywahe84VPMsFzLNcELpn2HZ42yBgnkEQuuc8wbN8wDzLB6F7hm2Ht60QMM8KQeie8wXPigHzrBiE7hm2Hd62UsA8KwWhey4QPCsHzLNyELpn2HZ42yoB86wShO65UPCsGjDPqkHonmHb4W2rBcyzWhC65yLBs3rAPKsHoXuGbYe3rREwzxpB6J6LBc+aAfOsGYTuGbYd3rZWwDxrBaF7LhE8awfMs3YQumfYdnjbOgHzrBOE7rlU8KwbMM+6QeieYdvhbesFzLNeELrnMsGzfsA86wehe4Zth7dtEDDPBkHonssFz4YB82wYhO4Zth3etlHAPBsFoXuuEDwbB8yzcRC6Z9h2eNsmAfNsEoTuuVLwbBowz6ZB6J5h2+FtmwXMs1kQuucqwbN5wDybB6F7hm2Ht20RMM8WQeieqwXPlgHzbBmE7hm2Hd62VcA8WwWhe64RPFsHzLN1ELpn2HZ42zYB82wThO65VvBsGzDPtkHonmHb4W3bBcyzXRC65zrBs33APNsHoXuGbYe37RAwzw5B6J7rBc+OAfPsGITuGbYd3rZTwDw7BaF7bhA8OwfMs3MQumfYdnjbLgHz7BKE7rlR8OwaMM+uQeieYdvhbbsFzLNbELrnJsGze8A8uwehe4Zth7ftETDPHkHonpsFz54B8+wZhO4Zth3etlfAPHsFoXtuETx7B8yzdxC6Z9h2eNs+AfPsE4TuuVXw7Bswz75B6J5h2+Ft+wXMs18Quuc2wbN/wDz7B6F7hm2Htx0QMM8BQeie2wXPgQHzHBiE7hm2Hd52UMA8BwWhe+4QPAcHzHNwELpn2HZ42yEB8xwShO65U/AcGjDPoUHonmHb4W2HBcxzWBC65y7Bc3jAPIcHoXuGbYe3HREwzxFB6J67Bc+RAfMcGYTuGbYd3nZUwDxHBaF77hE8RwfMc3QQumfYdnjbMQHzHBOE7rlX8BwbMM+xQeieYdvhbccFzHNcELrnPsFzfMA8xwehe4Zth7edEDDPCUHonvsFz4kB85wYhO4Zth3edlLAPCcFoXseEDwnB8xzchC6Z9h2eNspAfOcEoTueVDwnBowz6lB6J5h2+FtpwXMc1oQuuchwXN6wDynB6F7hm2Ht50RMM8ZQeiehwXPmQHznBmE7hm2Hd52VsA8ZwWhex4RPGcHzHN2ELpn2HZ42zkB85wThO55VPCcGzDPuUHonmHb4W3nBcxzXhC65zHBc37APOcHoXuGbYe3XRAwzwVB6J7HBc+FAfNcGITuGbYd3nZRwDwXBaF7nhA8FwfMc3EQumfYdnjbJQHzXBKE7nlS8FwaMM+lQeieYdvhbZcFzHNZELrnh4Ln8oB5Lg9C9wzbDm+7ImCeK4LQPU8JnisD5rkyCN0zbDu87aqAea4KQvf8SPBcHTDP1UHonmHb4W3XBMxzTRC652nBc23APNcGoXuGbYe3XRcwz3VB6J4fC57rA+a5PgjdM2w7vO2GgHluCEL3PCN4bgyY58YgdM+w7fC2mwLmuSkI3fMTwXNzwDw3B6F7hm2Ht90SMM8tQeieZwXPrQHz3BqE7hm2Hd52W8A8twWhe34qeG4PmOf2IHTPsO3wtjsC5rkjCN3znOC5M2CeO4PQPcO2w9vuCpjnriB0z88Ez90B89wdhO4Zth3edk/APPcEoXueFzz3BsxzbxC6Z9h2eNt9AfPcF4Tu+bnguT9gnvuD0D3DtsPbHgiY54EgdM8LgufBgHkeDEL3DNsOb3soYJ6HgtA9vxA8DwfM83AQumfYdnjbIwHzPBKE7nlR8DwaMM+jQeieYdvhbY8FzPNYELrnl4Ln8YB5Hg9C9wzbDm97ImCeJ4LQPS8JnicD5nkyCN0zbDu87YcB8/wwCN3zK8HzVMA8TwWhe4Zth7f9KGCeHwWhe14WPE8HzPN0ELpn2HZ4248D5vlxELrn14LnmYB5nglC9wzbDm/7ScA8PwlC97wieJ4NmOfZIHTPsO3wtp8GzPPTIHTPbwTPcwHzPBeE7hm2Hd72s4B5fhaE7nlV8DwfMM/zQeieYdvhbT8PmOfnQeie3wqeFwLmeSEI3TNsO7ztFwHz/CII3fOa4HkxYJ4Xg9A9w7bD234ZMM8vg9A9vxM8LwXM81IQumfYdnjbrwLm+VUQuud1wfNywDwvB6F7hm2Ht/06YJ5fB6F7fi94XgmY55UgdM+w7fC23wTM85sgdM8bgufVgHleDUL3DNsOb/ttwDy/DUL3/EHwvBYwz2tB6J5h2+FtvwuY53dB6J43Bc/rAfO8HoTuGbYd3vb7gHl+H4Tu+aPgeSNgnjeC0D3DtsPb/hAwzx+C0D1vCZ43A+Z5MwjdM2w7vO2PAfP8MQjd8yfB81bAPG8FoXuGbYe3/Slgnj8FoXveFjxvB8zzdhC6Z9h2eNs7AfO8E4TueUfwvBswz7tB6J5h2+Ftfw6Y589B6J53Bc97AfO8F4TuGbYd3vaXgHn+EoTu+bPgeT9gnveD0D3DtsPb/howz1+D0D3vCZ4PAub5IAjdM2w7vO1vAfP8LQjd8xfB82HAPB8GoXuGbYe3/T1gnr8HoXveFzwfBczzURC6Z9h2eNs/Aub5RxC656+C5+OAeT4OQvcM2w5v+2fAPP8MQvd8IHg+CZjnkyB0z7Dt8LZ/BczzryB0z98Ez6cB83wahO4Zth3e9u+Aef4dhO75UPB8FjDPZ0HonmHb4W3/CZjnP0Honr8Lns8D5vk8CN0zbDu87b8B8/w3CN3zkeD5ImCeL4LQPcO2w9v+FzDP/4LQPf8QPF8GzPNlELpn2HZ421cB83wVhO75WPB8HTDP10HonmHb4W3fBMzzTRC655+C59uAeb4NQvcM2w5v+y5gnu+C0D2fCJ7vA+b5PgjdM2w7vO0H5Znn//6F6vmX4BmhPPOMUD50z7Dt8LYRoWdEg+dTwTMS9Ixk8IwkeEaGnpENnn8LnlGgZxSDZxTBMyr0jGrwfCZ4RoOe0Qye0QTP6NAzusHzH8EzBvSMYfCMIXjGhJ4xDZ7PBc9Y0DOWwTOW4BkbesY2eP4reMaBnnEMnnEEz7jQM67B84XgGQ96xjN4xhM840PP+AbP/wTPBNAzgcEzgeCZEHomNHi+FDwTQc9EBs9Egmdi6JnY4PlK8EwCPZMYPJMInkmhZ1KD52vBMxn0TGbwTCZ4JoeeyQ2ebwTPFNAzhcEzheCZEnqmNHi+FTxTQc9UBs9Ugmdq6Jna4PlO8EwDPdMYPNMInmmhZ1qD53vBMx30TGfwTCd4poee6Q2eHyT5v9+ZAXpmMHhmEDwzQs+MBs8Igmcm6JnJ4JlJ8MwMPTMbPCMKnlmgZxaDZxbBMyv0zGrwjCR4ZoOe2Qye2QTP7NAzu8EzsuCZA3rmMHjmEDxzQs+cBs8ogmcu6JnL4JlL8MwNPXMbPKMKnnmgZx6DZx7BMy/0zGvwjCZ45oOe+Qye+QTP/NAzv8EzuuBZAHoWMHgWEDwLQs+CBs8Ygmch6FnI4FlI8CwMPQsbPGMKnkWgZxGDZxHBsyj0LGrwjCV4FoOexQyexQTP4tCzuMEztuBZAnqWMHiWEDxLQs+SBs84gmcp6FnK4FlK8CwNPUsbPOMKnmWgZxmDZxnBsyz0LGvwjCd4loOe5Qye5QTPAHoGBs/4gmd56Fne4Fle8KwAPSsYPBMInhWhZ0WDZ0XBsxL0rGTwTCh4VoaelQ2elQXPKtCzisEzkeBZFXpWNXhWFTyrQc9qBs/Egmd16Fnd4Fld8KwBPWsYPJMInjWhZ02DZ03Bsxb0rGXwTCp41oaetQ2etQXPOtCzjsEzmeBZF3rWNXjWFTzrQc96Bs/kgmd96Fnf4Flf8GwAPRsYPFMIng2hZ0ODZ0PBsxH0bGTwTCl4NoaejQ2ejQXPJtCzicEzleDZFHo2NXg2FTybQc9mBs/Ugmdz6Nnc4Nlc8GwBPVsYPNMIni2hZ0uDZ0vBsxX0bGXwTCt4toaerQ2erQXPNtCzjcEzneDZFnq2NXi2FTzbQc92Bs/0gmd76Nne4Nle8OwAPTsYPDMInh2hZ0eDZ0fBsxP07GTwzCh4doaenQ2enQXPLtCzi8Ezk+DZFXp2NXh2FTy7Qc9uBs/Mgmd36Nnd4Nld8OwBPXsYPLMInj2hZ0+DZ0/Bsxf07GXwzCp49oaevQ2evQXPPtCzj8Ezm+DZF3r2NXj2FTz7Qc9+Bs/sgmd/6Nnf4Nlf8BwAPQcYPHMIngOh50CD50DBcxD0HGTwzCl4Doaegw2egwXPIdBziMEzl+A5FHoONXgOFTyHQc9hBs/cgudw6Dnc4Dlc8BwBPUcYPPMIniOh50iD50jBcxT0HGXwzCt4joaeow2eowXPMdBzjMEzn+A5FnqONXiOFTzHQc9xBs/8gud46Dne4Dle8JwAPScYPAsInhOh50SD50TBcxL0nGTwLCh4Toaekw2ekwXPKdBzisGzkOA5FXpONXhOFTynQc9pBs/Cgud06Dnd4Dld8JwBPWcYPIsInjOh50yD50zBcxb0nGXwLCp4zoaesw2eswXPOdBzjsGzmOA5F3rONXjOFTznQc95Bs/igud86Dnf4Dlf8FwAPRcYPEsInguh50KD50LBcxH0XGTwLCl4Loaeiw2eiwXPJdBzicGzlOC5FHouNXguFTyXQc9lBs/Sgudy6Lnc4Llc8FwBPVcYPMsIniuh50qD50rBcxX0XGXwLCt4roaeqw2eqwXPNdBzjcGznOC5FnquNXiuFTzXQc91Bs9A8FwPPdcbPNcLnhug5waDZ3nBcyP03Gjw3Ch4boKemwyeFQTPzdBzs8Fzs+C5BXpuMXhWFDy3Qs+tBs+tguc26LnN4FlJ8NwOPbcbPLcLnjug5w6DZ2XBcyf03Gnw3Cl47oKeuwyeVQTP3dBzt8Fzt+C5B3ruMXhWFTz3Qs+9Bs+9guc+6LnP4FlN8NwPPfcbPPcLngeg5wGDZ3XB8yD0PGjwPCh4HoKehwyeNQTPw9DzsMHzsOB5BHoeMXjWFDyPQs+jBs+jgucx6HnM4FlL8DwOPY8bPI8Lnieg5wmDZ23B8yT0PGnwPCl4fgg9PzR41hE8T0HPUwbPU4LnR9DzI4NnXcHzNPQ8bfA8LXh+DD0/NnjWEzzPQM8zBs8zgucn0PMTg2d9wfMs9Dxr8DwreH4KPT81eDYQPM9Bz3MGz3OC52fQ8zODZ0PB8zz0PG/wPC94fg49Pzd4NhI8L0DPCwbPC4LnF9DzC4NnY8HzIvS8aPC8KHh+CT2/NHg2ETwvQc9LBs9LgudX0PMrg2dTwfMy9Lxs8LwseH4NPb82eDYTPK9AzysGzyuC5zfQ8xuDZ3PB8yr0vGrwvCp4fgs9vzV4thA8r0HPawbPa4Lnd9DzO4NnS8HzOvS8bvC8Lnh+Dz2/N3i2EjxvQM8bBs8bgucP0PMHg2drwfMm9Lxp8LwpeP4IPX80eLYRPG9Bz1sGz1uC50/Q8yeDZ1vB8zb0vG3wvC143oGedwye7QTPu9DzrsHzruD5M/T82eDZXvC8Bz3vGTzvCZ6/QM9fDJ4dBM/70PO+wfO+4Pkr9PzV4NlR8HwAPR8YPB8Inr9Bz98Mnp0Ez4fQ86HB86Hg+Tv0/N3g2VnwfAQ9Hxk8Hwmef0DPPwyeXQTPx9DzscHzseD5J/T80+DZVfB8Aj2fGDyfCJ5/Qc+/DJ7dBM+n0POpwfOp4Pk39Pzb4Nld8HwGPZ8ZPJ8Jnv9Az38Mnj0Ez+fQ87nB87ng+S/0/Nfg2VPwfAE9Xxg8Xwie/0HP/wyevQTPl9DzpcHzpeD5Cnq+Mnj2FjxfQ8/XBs/Xgucb6PnG4NlH8HwLPd8aPN8Knu+g5zuDZ1/B8z30fG/wfC94flCBef7vX6ie/QTPCBWYZ4QKoXuGbYe3jQg9Ixo8+wuekaBnJINnJMEzMvSMbPAcIHhGgZ5RDJ5RBM+o0DOqwXOg4BkNekYzeEYTPKNDz+gGz0GCZwzoGcPgGUPwjAk9Yxo8BwuesaBnLINnLMEzNvSMbfAcInjGgZ5xDJ5xBM+40DOuwXOo4BkPesYzeMYTPONDz/gGz2GCZwLomcDgmUDwTAg9Exo8hwueiaBnIoNnIsEzMfRMbPAcIXgmgZ5JDJ5JBM+k0DOpwXOk4JkMeiYzeCYTPJNDz+QGz1GCZwromcLgmULwTAk9Uxo8RwueqaBnKoNnKsEzNfRMbfAcI3imgZ5pDJ5pBM+00DOtwXOs4JkOeqYzeKYTPNNDz/QGz3GCZwbomcHgmUHwzAg9Mxo8xwuemaBnJoNnJsEzM/TMbPCcIHhmgZ5ZDJ5ZBM+s0DOrwXOi4JkNemYzeGYTPLNDz+wGz0mCZw7omcPgmUPwzAk9cxo8JwueuaBnLoNnLsEzN/TMbfCcInjmgZ55DJ55BM+80DOvwXOq4JkPeuYzeOYTPPNDz/wGz2mCZwHoWcDgWUDwLAg9Cxo8pwuehaBnIYNnIcGzMPQsbPCcIXgWgZ5FDJ5FBM+i0LOowXOm4FkMehYzeBYTPItDz+IGz1mCZwnoWcLgWULwLAk9Sxo8ZwuepaBnKYNnKcGzNPQsbfCcI3iWgZ5lDJ5lBM+y0LOswXOu4FkOepYzeJYTPAPoGRg85wme5aFneYNnecGzAvSsYPCcL3hWhJ4VDZ4VBc9K0LOSwXOB4FkZelY2eFYWPKtAzyoGz4WCZ1XoWdXgWVXwrAY9qxk8Fwme1aFndYNndcGzBvSsYfBcLHjWhJ41DZ41Bc9a0LOWwXOJ4FkbetY2eNYWPOtAzzoGz6WCZ13oWdfgWVfwrAc96xk8lwme9aFnfYNnfcGzAfRsYPBcLng2hJ4NDZ4NBc9G0LORwXOF4NkYejY2eDYWPJtAzyYGz5WCZ1Po2dTg2VTwbAY9mxk8VwmezaFnc4Nnc8GzBfRsYfBcLXi2hJ4tDZ4tBc9W0LOVwXON4NkaerY2eLYWPNtAzzYGz7WCZ1vo2dbg2VbwbAc92xk81wme7aFne4Nne8GzA/TsYPBcL3h2hJ4dDZ4dBc9O0LOTwXOD4NkZenY2eHYWPLtAzy4Gz42CZ1fo2dXg2VXw7AY9uxk8Nwme3aFnd4Nnd8GzB/TsYfDcLHj2hJ49DZ49Bc9e0LOXwXOL4NkbevY2ePYWPPtAzz4Gz62CZ1/o2dfg2Vfw7Ac9+xk8twme/aFnf4Nnf8FzAPQcYPDcLngOhJ4DDZ4DBc9B0HOQwXOH4DkYeg42eA4WPIdAzyEGz52C51DoOdTgOVTwHAY9hxk8dwmew6HncIPncMFzBPQcYfDcLXiOhJ4jDZ4jBc9R0HOUwXOP4Dkaeo42eI4WPMdAzzEGz72C51joOdbgOVbwHAc9xxk89wme46HneIPneMFzAvScYPDcL3hOhJ4TDZ4TBc9J0HOSwfOA4DkZek42eE4WPKdAzykGz4OC51ToOdXgOVXwnAY9pxk8Dwme06HndIPndMFzBvScYfA8LHjOhJ4zDZ4zBc9Z0HOWwfOI4Dkbes42eM4WPOdAzzkGz6OC51zoOdfgOVfwnAc95xk8jwme86HnfIPnfMFzAfRcYPA8LnguhJ4LDZ4LBc9F0HORwfOE4LkYei42eC4WPJdAzyUGz5OC51LoudTguVTwXAY9lxk8PxQ8l0PP5QbP5YLnCui5wuB5SvBcCT1XGjxXCp6roOcqg+dHgudq6Lna4Lla8FwDPdcYPE8Lnmuh51qD51rBcx30XGfw/FjwXA891xs81wueG6DnBoPnGcFzI/TcaPDcKHhugp6bDJ6fCJ6boedmg+dmwXML9Nxi8DwreG6FnlsNnlsFz23Qc5vB81PBczv03G7w3C547oCeOwye5wTPndBzp8Fzp+C5C3ruMnh+Jnjuhp67DZ67Bc890HOPwfO84LkXeu41eO4VPPdBz30Gz88Fz/3Qc7/Bc7/geQB6HjB4XhA8D0LPgwbPg4LnIeh5yOD5heB5GHoeNngeFjyPQM8jBs+LgudR6HnU4HlU8DwGPY8ZPL8UPI9Dz+MGz+OC5wnoecLgeUnwPAk9Txo8TwqeH0LPDw2eXwmep6DnKYPnKcHzI+j5kcHzsuB5GnqeNnieFjw/hp4fGzy/FjzPQM8zBs8zgucn0PMTg+cVwfMs9Dxr8DwreH4KPT81eH4jeJ6DnucMnucEz8+g52cGz6uC53noed7geV7w/Bx6fm7w/FbwvAA9Lxg8LwieX0DPLwye1wTPi9DzosHzouD5JfT80uD5neB5CXpeMnheEjy/gp5fGTyvC56Xoedlg+dlwfNr6Pm1wfN7wfMK9Lxi8LwieH4DPb8xeN4QPK9Cz6sGz6uC57fQ81uD5w+C5zXoec3geU3w/A56fmfwvCl4Xoee1w2e1wXP76Hn9wbPHwXPG9DzhsHzhuD5A/T8weB5S/C8CT1vGjxvCp4/Qs8fDZ4/CZ63oOctg+ctwfMn6PmTwfO24Hkbet42eN4WPO9AzzsGzzuC513oedfgeVfw/Bl6/mzwvCt43oOe9wye9wTPX6DnLwbPnwXP+9DzvsHzvuD5K/T81eB5T/B8AD0fGDwfCJ6/Qc/fDJ6/CJ4PoedDg+dDwfN36Pm7wfO+4PkIej4yeD4SPP+Ann8YPH8VPB9Dz8cGz8eC55/Q80+D5wPB8wn0fGLwfCJ4/gU9/zJ4/iZ4PoWeTw2eTwXPv6Hn3wbPh4LnM+j5zOD5TPD8B3r+Y/D8XfB8Dj2fGzyfC57/Qs9/DZ6PBM8X0POFwfOF4Pkf9PzP4PmH4PkSer40eL4UPF9Bz1cGz8eC52vo+drg+VrwfAM93xg8/xQ830LPtwbPt4LnO+j5zuD5RPB8Dz3fGzzfC54fVGSe//sXqudfgmeEiswzQsXQPcO2w9tGhJ4RDZ5PBc9I0DOSwTOS4BkZekY2eP4teEaBnlEMnlEEz6jQM6rB85ngGQ16RjN4RhM8o0PP6AbPfwTPGNAzhsEzhuAZE3rGNHg+FzxjQc9YBs9Ygmds6Bnb4Pmv4BkHesYxeMYRPONCz7gGzxeCZzzoGc/gGU/wjA894xs8/xM8E0DPBAbPBIJnQuiZ0OD5UvBMBD0TGTwTCZ6JoWdig+crwTMJ9Exi8EwieCaFnkkNnq8Fz2TQM5nBM5ngmRx6Jjd4vhE8U0DPFAbPFIJnSuiZ0uD5VvBMBT1TGTxTCZ6poWdqg+c7wTMN9Exj8EwjeKaFnmkNnu8Fz3TQM53BM53gmR56pjd4fpD0/35nBuiZweCZQfDMCD0zGjwjCJ6ZoGcmg2cmwTMz9Mxs8IwoeGaBnlkMnlkEz6zQM6vBM5LgmQ16ZjN4ZhM8s0PP7AbPyIJnDuiZw+CZQ/DMCT1zGjyjCJ65oGcug2cuwTM39Mxt8IwqeOaBnnkMnnkEz7zQM6/BM5rgmQ965jN45hM880PP/AbP6IJnAehZwOBZQPAsCD0LGjxjCJ6FoGchg2chwbMw9Cxs8IwpeBaBnkUMnkUEz6LQs6jBM5bgWQx6FjN4FhM8i0PP4gbP2IJnCehZwuBZQvAsCT1LGjzjCJ6loGcpg2cpwbM09Cxt8IwreJaBnmUMnmUEz7LQs6zBM57gWQ56ljN4lhM8A+gZGDzjC57loWd5g2d5wbMC9Kxg8EwgeFaEnhUNnhUFz0rQs5LBM6HgWRl6VjZ4VhY8q0DPKgbPRIJnVehZ1eBZVfCsBj2rGTwTC57VoWd1g2d1wbMG9Kxh8EwieNaEnjUNnjUFz1rQs5bBM6ngWRt61jZ41hY860DPOgbPZIJnXehZ1+BZV/CsBz3rGTyTC571oWd9g2d9wbMB9Gxg8EwheDaEng0Nng0Fz0bQs5HBM6Xg2Rh6NjZ4NhY8m0DPJgbPVIJnU+jZ1ODZVPBsBj2bGTxTC57NoWdzg2dzwbMF9Gxh8EwjeLaEni0Nni0Fz1bQs5XBM63g2Rp6tjZ4thY820DPNgbPdIJnW+jZ1uDZVvBsBz3bGTzTC57toWd7g2d7wbMD9Oxg8MwgeHaEnh0Nnh0Fz07Qs5PBM6Pg2Rl6djZ4dhY8u0DPLgbPTIJnV+jZ1eDZVfDsBj27GTwzC57doWd3g2d3wbMH9Oxh8MwiePaEnj0Nnj0Fz17Qs5fBM6vg2Rt69jZ49hY8+0DPPgbPbIJnX+jZ1+DZV/DsBz37GTyzC579oWd/g2d/wXMA9Bxg8MwheA6EngMNngMFz0HQc5DBM6fgORh6DjZ4DhY8h0DPIQbPXILnUOg51OA5VPAcBj2HGTxzC57Doedwg+dwwXME9Bxh8MwjeI6EniMNniMFz1HQc5TBM6/gORp6jjZ4jhY8x0DPMQbPfILnWOg51uA5VvAcBz3HGTzzC57joed4g+d4wXMC9Jxg8CwgeE6EnhMNnhMFz0nQc5LBs6DgORl6TjZ4ThY8p0DPKQbPQoLnVOg51eA5VfCcBj2nGTwLC57Toed0g+d0wXMG9Jxh8CwieM6EnjMNnjMFz1nQc5bBs6jgORt6zjZ4zhY850DPOQbPYoLnXOg51+A5V/CcBz3nGTyLC57zoed8g+d8wXMB9Fxg8CwheC6EngsNngsFz0XQc5HBs6TguRh6LjZ4LhY8l0DPJQbPUoLnUui51OC5VPBcBj2XGTxLC57Loedyg+dywXMF9Fxh8CwjeK6EnisNnisFz1XQc5XBs6zguRp6rjZ4rhY810DPNQbPcoLnWui51uC5VvBcBz3XGTwDwXM99Fxv8FwveG6AnhsMnuUFz43Qc6PBc6PguQl6bjJ4VhA8N0PPzQbPzYLnFui5xeBZUfDcCj23Gjy3Cp7boOc2g2clwXM79Nxu8NwueO6AnjsMnpUFz53Qc6fBc6fguQt67jJ4VhE8d0PP3QbP3YLnHui5x+BZVfDcCz33Gjz3Cp77oOc+g2c1wXM/9Nxv8NwveB6AngcMntUFz4PQ86DB86DgeQh6HjJ41hA8D0PPwwbPw4LnEeh5xOBZU/A8Cj2PGjyPCp7HoOcxg2ctwfM49Dxu8DwueJ6AnicMnrUFz5PQ86TB86Tg+SH0/NDgWUfwPAU9Txk8TwmeH0HPjwyedQXP09DztMHztOD5MfT82OBZT/A8Az3PGDzPCJ6fQM9PDJ71Bc+z0POswfOs4Pkp9PzU4NlA8DwHPc8ZPM8Jnp9Bz88Mng0Fz/PQ87zB87zg+Tn0/Nzg2UjwvAA9Lxg8LwieX0DPLwyejQXPi9DzosHzouD5JfT80uDZRPC8BD0vGTwvCZ5fQc+vDJ5NBc/L0POywfOy4Pk19Pza4NlM8LwCPa8YPK8Int9Az28Mns0Fz6vQ86rB86rg+S30/Nbg2ULwvAY9rxk8rwme30HP7wyeLQXP69DzusHzuuD5PfT83uDZSvC8AT1vGDxvCJ4/QM8fDJ6tBc+b0POmwfOm4Pkj9PzR4NlG8LwFPW8ZPG8Jnj9Bz58Mnm0Fz9vQ87bB87bgeQd63jF4thM870LPuwbPu4Lnz9DzZ4Nne8HzHvS8Z/C8J3j+Aj1/MXh2EDzvQ8/7Bs/7guev0PNXg2dHwfMB9Hxg8HwgeP4GPX8zeHYSPB9Cz4cGz4eC5+/Q83eDZ2fB8xH0fGTwfCR4/gE9/zB4dhE8H0PPxwbPx4Lnn9DzT4NnV8HzCfR8YvB8Inj+BT3/Mnh2EzyfQs+nBs+nguff0PNvg2d3wfMZ9Hxm8HwmeP4DPf8xePYQPJ9Dz+cGz+eC57/Q81+DZ0/B8wX0fGHwfCF4/gc9/zN49hI8X0LPlwbPl4LnK+j5yuDZW/B8DT1fGzxfC55voOcbg2cfwfMt9Hxr8HwreL6Dnu8Mnn0Fz/fQ873B873g+UEl5vm/f6F69hM8I1RinhEqhe4Zth3eNiL0jGjw7C94RoKekQyekQTPyNAzssFzgOAZBXpGMXhGETyjQs+oBs+Bgmc06BnN4BlN8IwOPaMbPAcJnjGgZwyDZwzBMyb0jGnwHCx4xoKesQyesQTP2NAztsFziOAZB3rGMXjGETzjQs+4Bs+hgmc86BnP4BlP8IwPPeMbPIcJngmgZwKDZwLBMyH0TGjwHC54JoKeiQyeiQTPxNAzscFzhOCZBHomMXgmETyTQs+kBs+Rgmcy6JnM4JlM8EwOPZMbPEcJnimgZwqDZwrBMyX0TGnwHC14poKeqQyeqQTP1NAztcFzjOCZBnqmMXimETzTQs+0Bs+xgmc66JnO4JlO8EwPPdMbPMcJnhmgZwaDZwbBMyP0zGjwHC94ZoKemQyemQTPzNAzs8FzguCZBXpmMXhmETyzQs+sBs+Jgmc26JnN4JlN8MwOPbMbPCcJnjmgZw6DZw7BMyf0zGnwnCx45oKeuQyeuQTP3NAzt8FziuCZB3rmMXjmETzzQs+8Bs+pgmc+6JnP4JlP8MwPPfMbPKcJngWgZwGDZwHBsyD0LGjwnC54FoKehQyehQTPwtCzsMFzhuBZBHoWMXgWETyLQs+iBs+Zgmcx6FnM4FlM8CwOPYsbPGcJniWgZwmDZwnBsyT0LGnwnC14loKepQyepQTP0tCztMFzjuBZBnqWMXiWETzLQs+yBs+5gmc56FnO4FlO8AygZ2DwnCd4loee5Q2e5QXPCtCzgsFzvuBZEXpWNHhWFDwrQc9KBs8Fgmdl6FnZ4FlZ8KwCPasYPBcKnlWhZ1WDZ1XBsxr0rGbwXCR4Voee1Q2e1QXPGtCzhsFzseBZE3rWNHjWFDxrQc9aBs8lgmdt6Fnb4Flb8KwDPesYPJcKnnWhZ12DZ13Bsx70rGfwXCZ41oee9Q2e9QXPBtCzgcFzueDZEHo2NHg2FDwbQc9GBs8Vgmdj6NnY4NlY8GwCPZsYPFcKnk2hZ1ODZ1PBsxn0bGbwXCV4NoeezQ2ezQXPFtCzhcFzteDZEnq2NHi2FDxbQc9WBs81gmdr6Nna4Nla8GwDPdsYPNcKnm2hZ1uDZ1vBsx30bGfwXCd4toee7Q2e7QXPDtCzg8FzveDZEXp2NHh2FDw7Qc9OBs8Ngmdn6NnZ4NlZ8OwCPbsYPDcKnl2hZ1eDZ1fBsxv07Gbw3CR4doee3Q2e3QXPHtCzh8Fzs+DZE3r2NHj2FDx7Qc9eBs8tgmdv6Nnb4Nlb8OwDPfsYPLcKnn2hZ1+DZ1/Bsx/07Gfw3CZ49oee/Q2e/QXPAdBzgMFzu+A5EHoONHgOFDwHQc9BBs8dgudg6DnY4DlY8BwCPYcYPHcKnkOh51CD51DBcxj0HGbw3CV4Doeeww2ewwXPEdBzhMFzt+A5EnqONHiOFDxHQc9RBs89gudo6Dna4Dla8BwDPccYPPcKnmOh51iD51jBcxz0HGfw3Cd4joee4w2e4wXPCdBzgsFzv+A5EXpONHhOFDwnQc9JBs8Dgudk6DnZ4DlZ8JwCPacYPA8KnlOh51SD51TBcxr0nGbwPCR4Toee0w2e0wXPGdBzhsHzsOA5E3rONHjOFDxnQc9ZBs8jguds6Dnb4Dlb8JwDPecYPI8KnnOh51yD51zBcx70nGfwPCZ4zoee8w2e8wXPBdBzgcHzuOC5EHouNHguFDwXQc9FBs8Tgudi6LnY4LlY8FwCPZcYPE8Knkuh51KD51LBcxn0XGbw/FDwXA49lxs8lwueK6DnCoPnKcFzJfRcafBcKXiugp6rDJ4fCZ6roedqg+dqwXMN9Fxj8DwteK6FnmsNnmsFz3XQc53B82PBcz30XG/wXC94boCeGwyeZwTPjdBzo8Fzo+C5CXpuMnh+Inhuhp6bDZ6bBc8t0HOLwfOs4LkVem41eG4VPLdBz20Gz08Fz+3Qc7vBc7vguQN67jB4nhM8d0LPnQbPnYLnLui5y+D5meC5G3ruNnjuFjz3QM89Bs/zgude6LnX4LlX8NwHPfcZPD8XPPdDz/0Gz/2C5wHoecDgeUHwPAg9Dxo8Dwqeh6DnIYPnF4LnYeh52OB5WPA8Aj2PGDwvCp5HoedRg+dRwfMY9Dxm8PxS8DwOPY8bPI8Lnieg5wmD5yXB8yT0PGnwPCl4fgg9PzR4fiV4noKepwyepwTPj6DnRwbPy4Lnaeh52uB5WvD8GHp+bPD8WvA8Az3PGDzPCJ6fQM9PDJ5XBM+z0POswfOs4Pkp9PzU4PmN4HkOep4zeJ4TPD+Dnp8ZPK8Knueh53mD53nB83Po+bnB81vB8wL0vGDwvCB4fgE9vzB4XhM8L0LPiwbPi4Lnl9DzS4Pnd4LnJeh5yeB5SfD8Cnp+ZfC8Lnhehp6XDZ6XBc+voefXBs/vBc8r0POKwfOK4PkN9PzG4HlD8LwKPa8aPK8Knt9Cz28Nnj8Integ5zWD5zXB8zvo+Z3B86bgeR16Xjd4Xhc8v4ee3xs8fxQ8b0DPGwbPG4LnD9DzB4PnLcHzJvS8afC8KXj+CD1/NHj+JHjegp63DJ63BM+foOdPBs/bgudt6Hnb4Hlb8LwDPe8YPO8Inneh512D513B82fo+bPB867geQ963jN43hM8f4Gevxg8fxY870PP+wbP+4Lnr9DzV4PnPcHzAfR8YPB8IHj+Bj1/M3j+Ing+hJ4PDZ4PBc/foefvBs/7gucj6PnI4PlI8PwDev5h8PxV8HwMPR8bPB8Lnn9Czz8Nng8EzyfQ84nB84ng+Rf0/Mvg+Zvg+RR6PjV4PhU8/4aefxs8Hwqez6DnM4PnM8HzH+j5j8Hzd8HzOfR8bvB8Lnj+Cz3/NXg+EjxfQM8XBs8Xgud/0PM/g+cfgudL6PnS4PlS8HwFPV8ZPB8Lnq+h52uD52vB8w30fGPw/FPwfAs93xo83wqe76DnO4PnE8HzPfR8b/B8L3h+UJl5/u9fqJ5/CZ4RKjPPCJVD9wzbDm8bEXpGNHg+FTwjQc9IBs9Igmdk6BnZ4Pm34BkFekYxeEYRPKNCz6gGz2eCZzToGc3gGU3wjA49oxs8/xE8Y0DPGAbPGIJnTOgZ0+D5XPCMBT1jGTxjCZ6xoWdsg+e/gmcc6BnH4BlH8IwLPeMaPF8InvGgZzyDZzzBMz70jG/w/E/wTAA9Exg8EwieCaFnQoPnS8EzEfRMZPBMJHgmhp6JDZ6vBM8k0DOJwTOJ4JkUeiY1eL4WPJNBz2QGz2SCZ3Lomdzg+UbwTAE9Uxg8UwieKaFnSoPnW8EzFfRMZfBMJXimhp6pDZ7vBM800DONwTON4JkWeqY1eL4XPNNBz3QGz3SCZ3romd7g+UGy//udGaBnBoNnBsEzI/TMaPCMIHhmgp6ZDJ6ZBM/M0DOzwTOi4JkFemYxeGYRPLNCz6wGz0iCZzbomc3gmU3wzA49sxs8IwueOaBnDoNnDsEzJ/TMafCMInjmgp65DJ65BM/c0DO3wTOq4JkHeuYxeOYRPPNCz7wGz2iCZz7omc/gmU/wzA898xs8owueBaBnAYNnAcGzIPQsaPCMIXgWgp6FDJ6FBM/C0LOwwTOm4FkEehYxeBYRPItCz6IGz1iCZzHoWczgWUzwLA49ixs8YwueJaBnCYNnCcGzJPQsafCMI3iWgp6lDJ6lBM/S0LO0wTOu4FkGepYxeJYRPMtCz7IGz3iCZznoWc7gWU7wDKBnYPCML3iWh57lDZ7lBc8K0LOCwTOB4FkRelY0eFYUPCtBz0oGz4SCZ2XoWdngWVnwrAI9qxg8EwmeVaFnVYNnVcGzGvSsZvBMLHhWh57VDZ7VBc8a0LOGwTOJ4FkTetY0eNYUPGtBz1oGz6SCZ23oWdvgWVvwrAM96xg8kwmedaFnXYNnXcGzHvSsZ/BMLnjWh571DZ71Bc8G0LOBwTOF4NkQejY0eDYUPBtBz0YGz5SCZ2Po2djg2VjwbAI9mxg8UwmeTaFnU4NnU8GzGfRsZvBMLXg2h57NDZ7NBc8W0LOFwTON4NkSerY0eLYUPFtBz1YGz7SCZ2vo2drg2VrwbAM92xg80wmebaFnW4NnW8GzHfRsZ/BML3i2h57tDZ7tBc8O0LODwTOD4NkRenY0eHYUPDtBz04Gz4yCZ2fo2dng2Vnw7AI9uxg8MwmeXaFnV4NnV8GzG/TsZvDMLHh2h57dDZ7dBc8e0LOHwTOL4NkTevY0ePYUPHtBz14Gz6yCZ2/o2dvg2Vvw7AM9+xg8swmefaFnX4NnX8GzH/TsZ/DMLnj2h579DZ79Bc8B0HOAwTOH4DkQeg40eA4UPAdBz0EGz5yC52DoOdjgOVjwHAI9hxg8cwmeQ6HnUIPnUMFzGPQcZvDMLXgOh57DDZ7DBc8R0HOEwTOP4DkSeo40eI4UPEdBz1EGz7yC52joOdrgOVrwHAM9xxg88wmeY6HnWIPnWMFzHPQcZ/DML3iOh57jDZ7jBc8J0HOCwbOA4DkRek40eE4UPCdBz0kGz4KC52ToOdngOVnwnAI9pxg8CwmeU6HnVIPnVMFzGvScZvAsLHhOh57TDZ7TBc8Z0HOGwbOI4DkTes40eM4UPGdBz1kGz6KC52zoOdvgOVvwnAM95xg8iwmec6HnXIPnXMFzHvScZ/AsLnjOh57zDZ7zBc8F0HOBwbOE4LkQei40eC4UPBdBz0UGz5KC52LoudjguVjwXAI9lxg8SwmeS6HnUoPnUsFzGfRcZvAsLXguh57LDZ7LBc8V0HOFwbOM4LkSeq40eK4UPFdBz1UGz7KC52roudrguVrwXAM91xg8ywmea6HnWoPnWsFzHfRcZ/AMBM/10HO9wXO94LkBem4weJYXPDdCz40Gz42C5yboucngWUHw3Aw9Nxs8NwueW6DnFoNnRcFzK/TcavDcKnhug57bDJ6VBM/t0HO7wXO74LkDeu4weFYWPHdCz50Gz52C5y7oucvgWUXw3A09dxs8dwuee6DnHoNnVcFzL/Tca/DcK3jug577DJ7VBM/90HO/wXO/4HkAeh4weFYXPA9Cz4MGz4OC5yHoecjgWUPwPAw9Dxs8DwueR6DnEYNnTcHzKPQ8avA8Kngeg57HDJ61BM/j0PO4wfO44HkCep74/3j3B+hNj7Rh977TnbZt27Zt27Zt27Zt27Zt23Z3+qt8U7PXNc+e2bmPs2pV1qq3rvfd53+S/I7UmUxntgXPUsBzh9BzhwXPHcBzp9BzpwXP0sBzl9BzlwXPXcBzt9BztwXPMsBzj9BzjwXPPcBzr9BzrwXPssBzn9BznwXPfcBzv9BzvwXPcsDzgNDzgAXPA8DzoNDzoAXP8sDzkNDzkAXPQ8DzsNDzsAXPCsDziNDziAXPI8DzqNDzqAXPisDzmNDzmAXPY8DzuNDzuAXPSsDzhNDzhAXPE8DzpNDzpAXPysDzlNDzlAXPU8DztNDztAXPKsDzjNDzjAXPM8DzrNDzrAXPqsDznNDznAXPc8DzvNDzvAXPasDzgtDzggXPC8DzotDzogXP6sDzktDzkgXPS8DzstDzsgXPGsDzitDzigXPK8DzqtDzqgXPmsDzmtDzmgXPa8DzutDzugXPWsDzhtDzhgXPG8DzptDzpgXP2sDzltDzlgXPW8DzttDztgXPOsDzjtDzjgXPO8DzrtDzrgXPusDzntDzngXPe8DzvtDzvgXPesDzgdDzgQXPB8DzodDzoQXP+sDzkdDzkQXPR8DzsdDzsQXPBsDzidDziQXPJ8DzqdDzqQXPhsDzmdDzmQXPZ8DzudDzuQXPRsDzhdDzhQXPF8DzpdDzpQXPxsDzldDzlQXPV8DztdDztQXPJsDzjdDzjQXPN8DzrdDzrQXPpsDzndDznQXPd8DzvdDzvQXPZsDzg9DzgwXPD8Dzo9DzowXP5sDzk9DzkwXPT8Dzs9DzswXPFsDzi9DziwXPL8Dzq9DzqwXPlsDzm9DzmwXPb8Dzu9DzuwXPVsDzh9DzhwXPH8Dzp9DzpwXP1sDzl9DzlwXPX8DzL6HnXxY82wDP30LP3xY8fwNPX2GZ598/Z+rZFnj+UVjm+Udhc0/v7/ufZgMIPQNY8GwHPAMKPQNa8AwIPP8Uev5pwbM98Awk9AxkwTMQ8Aws9AxswbMD8Awi9AxiwTMI8Awq9AxqwbMj8Awm9AxmwTMY8Awu9AxuwbMT8Awh9AxhwTME8Awp9AxpwbMz8Awl9AxlwTMU8Awt9AxtwbML8Awj9AxjwTMM8Awr9AxrwbMr8Awn9AxnwTMc8Awv9AxvwbMb8Iwg9IxgwTMC8Iwo9IxowbM78Iwk9IxkwTMS8Iws9IxswbMH8Iwi9IxiwTMK8Iwq9IxqwbMn8Iwm9IxmwTMa8Iwu9IxuwbMX8Iwh9IxhwTMG8Iwp9IxpwbM38Iwl9IxlwTMW8Iwt9IxtwbMP8Iwj9IxjwTMO8Iwr9IxrwbMv8Iwn9IxnwTMe8Iwv9IxvwbMf8Ewg9ExgwTMB8Ewo9ExowbM/8Ewk9ExkwTMR8Ews9ExswXMA8Ewi9ExiwTMJ8Ewq9ExqwXMg8Ewm9ExmwTMZ8Ewu9ExuwXMQ8Ewh9ExhwTMF8Ewp9ExpwXMw8Ewl9ExlwTMV8Ewt9ExtwXMI8Ewj9ExjwTMN8Ewr9ExrwXMo8Ewn9ExnwTMd8Ewv9ExvwXMY8Mwg9MxgwTMD8Mwo9MxowXM48Mwk9MxkwTMT8Mws9MxswXME8Mwi9MxiwTML8Mwq9MxqwXMk8Mwm9MxmwTMb8Mwu9MxuwXMU8Mwh9MxhwTMH8Mwp9MxpwXM08Mwl9MxlwTMX8Mwt9MxtwXMM8Mwj9MxjwTMP8Mwr9MxrwXMs8Mwn9MxnwTMf8Mwv9MxvwXMc8Cwg9CxgwbMA8Cwo9CxowXM88Cwk9CxkwbMQ8Cws9CxswXMC8Cwi9CxiwbMI8Cwq9CxqwXMi8Cwm9CxmwbMY8Cwu9CxuwXMS8Cwh9CxhwbME8Cwp9CxpwXMy8Cwl9CxlwbMU8Cwt9CxtwXMK8Cwj9CxjwbMM8Cwr9CxrwXMq8Cwn9CxnwbMc8Cwv9CxvwXMa8Kwg9KxgwbMC8Kwo9KxowXM68Kwk9KxkwbMS8Kws9KxswXMG8Kwi9KxiwbMK8Kwq9KxqwXMm8Kwm9KxmwbMa8Kwu9KxuwXMW8Kwh9KxhwbMG8Kwp9KxpwXM28Kwl9KxlwbMW8Kwt9KxtwXMO8Kwj9KxjwbMO8Kwr9KxrwXMu8Kwn9KxnwbMe8Kwv9KxvwXMe8Gwg9GxgwbMB8Gwo9GxowXM+8Gwk9GxkwbMR8Gws9GxswXMB8Gwi9GxiwbMJ8Gwq9GxqwXMh8Gwm9GxmwbMZ8Gwu9GxuwXMR8Gwh9GxhwbMF8Gwp9GxpwXMx8Gwl9GxlwbMV8Gwt9GxtwXMJ8Gwj9GxjwbMN8Gwr9GxrwXMp8Gwn9GxnwbMd8Gwv9GxvwXMZ8Owg9OxgwbMD8Owo9OxowXM58Owk9OxkwbMT8Ows9OxswXMF8Owi9OxiwbML8Owq9OxqwXMl8Owm9OxmwbMb8Owu9OxuwXMV8Owh9OxhwbMH8Owp9OxpwXM18Owl9OxlwbMX8Owt9OxtwXMN8Owj9OxjwbMP8Owr9OxrwXMt8Own9OxnwbMf8Owv9OxvwXMd8Bwg9BxgwXMA8Bwo9BxowXM98Bwk9BxkwXMQ8Bws9BxswXMD8Bwi9BxiwXMI8Bwq9BxqwXMj8Bwm9BxmwXMY8Bwu9BxuwXMT8Bwh9BxhwXME8Bwp9BxpwXMz8Bwl9BxlwXMU8Bwt9BxtwXML8Bwj9BxjwXMM8Bwr9BxrwXMr8Bwn9BxnwXMc8Bwv9BxvwXMb8Jwg9JxgwXMC8Jwo9JxowXM78Jwk9JxkwXMS8Jws9JxswXMH8Jwi9JxiwXMK8Jwq9JxqwXMn8Jwm9JxmwXMa8Jwu9JxuwXMX8Jwh9JxhwXMG8Jwp9JxpwXM38Jwl9JxlwXMW8Jwt9JxtwXMP8Jwj9JxjwXMO8Jwr9JxrwXMv8Jwn9JxnwXMe8Jwv9JxvwXMf8Fwg9FxgwXMB8Fwo9FxowXM/8Fwk9FxkwXMR8Fws9FxswfMA8Fwi9FxiwXMJ8Fwq9FxqwfMg8Fwm9FxmwXMZ8Fwu9FxuwfMQ8Fwh9FxhwXMF8Fwp9FxpwfMw8Fwl9FxlwXMV8Fwt9FxtwfMI8Fwj9FxjwXMN8Fwr9FxrwfMo8Fwn9FxnwXMd8Fwv9FxvwfMY8Nwg9NxgwXMD8Nwo9NxowfM48Nwk9NxkwXMT8Nws9NxswfME8Nwi9NxiwXML8Nwq9NxqwfMk8Nwm9NxmwXMb8Nwu9NxuwfMU8Nwh9NxhwXMH8Nwp9NxpwfM08Nwl9NxlwXMX8Nwt9NxtwfMM8Nwj9NxjwXMP8Nwr9NxrwfMs8Nwn9NxnwXMf8Nwv9NxvwfMc8Dwg9DxgwfMA8Dwo9DxowfM88Dwk9DxkwfMQ8Dws9DxswfMC8Dwi9DxiwfMI8Dwq9DxqwfMi8Dwm9DxmwfMY8Dwu9DxuwfMS8Dwh9DxhwfME8Dwp9DxpwfMy8Dwl9DxlwfMU8Dwt9DxtwfMK8Dwj9DxjwfMM8Dwr9DxrwfMq8Dwn9DxnwfMc8Dwv9DxvwfMa8Lwg9LxgwfMC8Lwo9LxowfM68Lwk9LxkwfMS8Lws9LxswfMG8Lwi9LxiwfMK8Lwq9LxqwfMm8Lwm9LxmwfMa8Lwu9LxuwfMW8Lwh9LxhwfMG8Lwp9LxpwfM28Lwl9LxlwfMW8Lwt9LxtwfMO8Lwj9LxjwfMO8Lwr9LxrwfMu8Lwn9LxnwfMe8Lwv9LxvwfMe8Hwg9HxgwfMB8Hwo9HxowfM+8Hwk9HxkwfMR8Hws9HxswfMB8Hwi9HxiwfMJ8Hwq9HxqwfMh8Hwm9HxmwfMZ8Hwu9HxuwfMR8Hwh9HxhwfMF8Hwp9HxpwfMx8Hwl9HxlwfMV8Hwt9HxtwfMJ8Hwj9HxjwfMN8Hwr9HxrwfMp8Hwn9HxnwfMd8Hwv9HxvwfMZ8Pwg9PxgwfMD8Pwo9PxowfM58Pwk9PxkwfMT8Pws9PxswfMF8Pwi9PxiwfML8Pwq9PxqwfMl8Pwm9PxmwfMb8Pwu9PxuwfMV8Pwh9PxhwfMH8Pwp9PxpwfM18Pwl9PxlwfMX8PxL6PmXBc83wPO30PO3Bc/fwNNXROb598+Zer4Fnn8UkXn+UcTc0/v7/qfZAELPABY83wHPgELPgBY8AwLPP4Wef1rwfA88Awk9A1nwDAQ8Aws9A1vw/AA8gwg9g1jwDAI8gwo9g1rw/Ag8gwk9g1nwDAY8gws9g1vw/AQ8Qwg9Q1jwDAE8Qwo9Q1rw/Aw8Qwk9Q1nwDAU8Qws9Q1vw/AI8wwg9w1jwDAM8wwo9w1rw/Ao8wwk9w1nwDAc8wws9w1vw/AY8Iwg9I1jwjAA8Iwo9I1rw/A48Iwk9I1nwjAQ8Iws9I1vw/AE8owg9o1jwjAI8owo9o1rw/Ak8owk9o1nwjAY8ows9o1vw/AU8Ywg9Y1jwjAE8Ywo9Y1rw/At4xhJ6xrLgGQt4xhZ6xrbg+Rt4xhF6xrHgGQd4xhV6xrXhGc3/P854fv1x/g0a1+f94/z75xL+wx8n+X3/02x8//44FWje//jjjO/HH+c//PaHL7r/f5wJhJ4JLHgmAJ4JhZ4JLXj+ATwTCT0TWfBMBDwTCz0TW/AMADyTCD2TWPBMAjyTCj2TWvAMCDyTCT2TWfBMBjyTCz2TW/D8E3imEHqmsOCZAnimFHqmtOAZCHimEnqmsuCZCnimFnqmtuAZGHimEXqmseCZBnimFXqmteAZBHimE3qms+CZDnimF3qmt+AZFHhmEHpmsOCZAXhmFHpmtOAZDHhmEnpmsuCZCXhmFnpmtuAZHHhmEXpmseCZBXhmFXpmteAZAnhmE3pms+CZDXhmF3pmt+AZEnjmEHrmsOCZA3jmFHrmtOAZCnjmEnrmsuCZC3jmFnrmtuAZGnjmEXrmseCZB3jmFXrmteAZBnjmE3rms+CZD3jmF3rmt+AZFngWEHoWsOBZAHgWFHoWtOAZDngWEnoWsuBZCHgWFnoWtuAZHngWEXoWseBZBHgWFXoWteAZAXgWE3oWs+BZDHgWF3oWt+AZEXiWEHqWsOBZAniWFHqWtOAZCXiWEnqWsuBZCniWFnqWtuAZGXiWEXqWseBZBniWFXqWteAZBXiWE3qWs+BZDniWF3qWt+AZFXhWEHpWsOBZAXhWFHpWtOAZDXhWEnpWsuBZCXhWFnpWtuAZHXhWEXpWseBZBXhWFXpWteAZA3hWE3pWs+BZDXhWF3pWt+AZE3jWEHrWsOBZA3jWFHrWtOAZC3jWEnrWsuBZC3jWFnrWtuAZG3jWEXrWseBZB3jWFXrWteAZB3jWE3rWs+BZD3jWF3rWt+AZF3g2EHo2sODZAHg2FHo2tOAZD3g2Eno2suDZCHg2Fno2tuAZH3g2EXo2seDZBHg2FXo2teCZAHg2E3o2s+DZDHg2F3o2t+CZEHi2EHq2sODZAni2FHq2tOCZCHi2Enq2suDZCni2Fnq2tuCZGHi2EXq2seDZBni2FXq2teCZBHi2E3q2s+DZDni2F3q2t+CZFHh2EHp2sODZAXh2FHp2tOCZDHh2Enp2suDZCXh2Fnp2tuCZHHh2EXp2seDZBXh2FXp2teCZAnh2E3p2s+DZDXh2F3p2t+CZEnj2EHr2sODZA3j2FHr2tOCZCnj2Enr2suDZC3j2Fnr2tuCZGnj2EXr2seDZB3j2FXr2teCZBnj2E3r2s+DZD3j2F3r2t+CZFngOEHoOsOA5AHgOFHoOtOCZDngOEnoOsuA5CHgOFnoOtuCZHngOEXoOseA5BHgOFXoOteCZAXgOE3oOs+A5DHgOF3oOt+CZEXiOEHqOsOA5AniOFHqOtOCZCXiOEnqOsuA5CniOFnqOtuCZGXiOEXqOseA5BniOFXqOteCZBXiOE3qOs+A5DniOF3qOt+CZFXhOEHpOsOA5AXhOFHpOtOCZDXhOEnpOsuA5CXhOFnpOtuCZHXhOEXpOseA5BXhOFXpOteCZA3hOE3pOs+A5DXhOF3pOt+CZE3jOEHrOsOA5A3jOFHrOtOCZC3jOEnrOsuA5C3jOFnrOtuCZG3jOEXrOseA5B3jOFXrOteCZB3jOE3rOs+A5D3jOF3rOt+CZF3guEHousOC5AHguFHoutOCZD3guEnousuC5CHguFnoutuCZH3guEXouseC5BHguFXouteBZAHguE3ous+C5DHguF3out+BZEHiuEHqusOC5AniuFHqutOBZCHiuEnqusuC5CniuFnqutuBZGHiuEXquseC5BniuFXquteBZBHiuE3qus+C5DniuF3qut+BZFHhuEHpusOC5AXhuFHputOBZDHhuEnpusuC5CXhuFnputuBZHHhuEXpuseC5BXhuFXputeBZAnhuE3pus+C5DXhuF3put+BZEnjuEHrusOC5A3juFHrutOBZCnjuEnrusuC5C3juFnrutuBZGnjuEXruseC5B3juFXruteBZBnjuE3rus+C5D3juF3rut+BZFngeEHoesOB5AHgeFHoetOBZDngeEnoesuB5CHgeFnoetuBZHngeEXoeseB5BHgeFXoeteBZAXgeE3oes+B5DHgeF3oet+BZEXieEHqesOB5AnieFHqetOBZCXieEnqesuB5CnieFnqetuBZGXieEXqeseB5BnieFXqeteBZBXieE3qes+B5DnieF3qet+BZFXheEHpesOB5AXheFHpetOBZDXheEnpesuB5CXheFnpetuBZHXheEXpeseB5BXheFXpeteBZA3heE3pes+B5DXheF3pet+BZE3jeEHresOB5A3jeFHretOBZC3jeEnresuB5C3jeFnretuBZG3jeEXreseB5B3jeFXreteBZB3jeE3res+B5D3jeF3ret+BZF3g+EHo+sOD5AHg+FHo+tOBZD3g+Eno+suD5CHg+Fno+tuBZH3g+EXo+seD5BHg+FXo+teDZAHg+E3o+s+D5DHg+F3o+t+DZEHi+EHq+sOD5Ani+FHq+tODZCHi+Enq+suD5Cni+Fnq+tuDZGHi+EXq+seD5Bni+FXq+teDZBHi+E3q+s+D5Dni+F3q+t+DZFHh+EHp+sOD5AXh+FHp+tODZDHh+Enp+suD5CXh+Fnp+tuDZHHh+EXp+seD5BXh+FXp+teDZAnh+E3p+s+D5DXh+F3p+t+DZEnj+EHr+sOD5A3j+FHr+tODZCnj+Enr+suD5C3j+JfT8y4Jna+D5W+j524Lnb+DpKyrz/PvnTD3bAM8/iso8/yhq7un9ff/TbAChZwALnm2BZ0ChZ0ALngGB559Czz8teLYDnoGEnoEseAYCnoGFnoEteLYHnkGEnkEseAYBnkGFnkEteHYAnsGEnsEseAYDnsGFnsEteHYEniGEniEseIYAniGFniEteHYCnqGEnqEseIYCnqGFnqEteHYGnmGEnmEseIYBnmGFnmEteHYBnuGEnuEseIYDnuGFnuEteHYFnhGEnhEseEYAnhGFnhEteHYDnpGEnpEseEYCnpGFnpEteHYHnlGEnlEseEYBnlGFnlEtePYAntGEntEseEYDntGFntEtePYEnjGEnjEseMYAnjGFnjEtePYCnrGEnrEseMYCnrGFnrEtePYGnnGEnnEseMYBnnGFnnEtePYBnvGEnvEseMYDnvGFnvEtePYFngmEngkseCYAngmFngktePYDnomEnokseCYCnomFnoktePYHnkmEnkkseCYBnkmFnkkteA4AnsmEnskseCYDnsmFnskteA4EnimEnikseKYAnimFnikteA4CnqmEnqkseKYCnqmFnqkteA4GnmmEnmkseKYBnmmFnmkteA4BnumEnukseKYDnumFnukteA4FnhmEnhkseGYAnhmFnhkteA4DnpmEnpkseGYCnpmFnpkteA4HnlmEnlkseGYBnlmFnlkteI4AntmEntkseGYDntmFntkteI4EnjmEnjkseOYAnjmFnjkteI4CnrmEnrkseOYCnrmFnrkteI4GnnmEnnkseOYBnnmFnnkteI4BnvmEnvkseOYDnvmFnvkteI4FngWEngUseBYAngWFngUteI4DnoWEnoUseBYCnoWFnoUteI4HnkWEnkUseBYBnkWFnkUteE4AnsWEnsUseBYDnsWFnsUteE4EniWEniUseJYAniWFniUteE4CnqWEnqUseJYCnqWFnqUteE4GnmWEnmUseJYBnmWFnmUteE4BnuWEnuUseJYDnuWFnuUteE4FnhWEnhUseFYAnhWFnhUteE4DnpWEnpUseFYCnpWFnpUteE4HnlWEnlUseFYBnlWFnlUteM4AntWEntUseFYDntWFntUteM4EnjWEnjUseNYAnjWFnjUteM4CnrWEnrUseNYCnrWFnrUteM4GnnWEnnUseNYBnnWFnnUteM4BnvWEnvUseNYDnvWFnvUteM4Fng2Eng0seDYAng2Fng0teM4Dno2Eno0seDYCno2Fno0teM4Hnk2Enk0seDYBnk2Fnk0teC4Ans2Ens0seDYDns2Fns0teC4Eni2Eni0seLYAni2Fni0teC4Cnq2Enq0seLYCnq2Fnq0teC4Gnm2Enm0seLYBnm2Fnm0teC4Bnu2Enu0seLYDnu2Fnu0teC4Fnh2Enh0seHYAnh2Fnh0teC4Dnp2Enp0seHYCnp2Fnp0teC4Hnl2Enl0seHYBnl2Fnl0teK4Ant2Ent0seHYDnt2Fnt0teK4Enj2Enj0sePYAnj2Fnj0teK4Cnr2Enr0sePYCnr2Fnr0teK4Gnn2Enn0sePYBnn2Fnn0teK4Bnv2Env0sePYDnv2Fnv0teK4FngOEngMseA4AngOFngMteK4DnoOEnoMseA4CnoOFnoMteK4HnkOEnkMseA4BnkOFnkMteG4AnsOEnsMseA4DnsOFnsMteG4EniOEniMseI4AniOFniMteG4CnqOEnqMseI4CnqOFnqMteG4GnmOEnmMseI4BnmOFnmMteG4BnuOEnuMseI4DnuOFnuMteG4FnhOEnhMseE4AnhOFnhMteG4DnpOEnpMseE4CnpOFnpMteG4HnlOEnlMseE4BnlOFnlMteO4AntOEntMseE4DntOFntMteO4EnjOEnjMseM4AnjOFnjMteO4CnrOEnrMseM4CnrOFnrMteO4GnnOEnnMseM4BnnOFnnMteO4BnvOEnvMseM4DnvOFnvMteO4FnguEngsseC4AnguFngsteO4DnouEnosseC4CnouFnosteO4HnkuEnksseC4BnkuFnksteB4AnsuEnssseC4DnsuFnssteB4EniuEnisseK4AniuFnisteB4CnquEnqsseK4CnquFnqsteB4GnmuEnmsseK4BnmuFnmsteB4BnuuEnusseK4DnuuFnusteB4FnhuEnhsseG4AnhuFnhsteB4DnpuEnpsseG4CnpuFnpsteB4HnluEnlsseG4BnluFnlsteJ4AntuEntsseG4DntuFntsteJ4EnjuEnjsseO4AnjuFnjsteJ4CnruEnrsseO4CnruFnrsteJ4GnnuEnnsseO4BnnuFnnsteJ4BnvuEnvsseO4DnvuFnvsteJ4FngeEngcseB4AngeFngcteJ4DnoeEnocseB4CnoeFnocteJ4HnkeEnkcseB4BnkeFnkcteF4AnseEnscseB4DnseFnscteF4EnieEnicseJ4AnieFnicteF4CnqeEnqcseJ4CnqeFnqcteF4GnmeEnmcseJ4BnmeFnmcteF4BnueEnucseJ4DnueFnucteF4FnheEnhcseF4AnheFnhcteF4DnpeEnpcseF4CnpeFnpcteF4HnleEnlcseF4BnleFnlcteN4AnteEntcseF4DnteFntcteN4EnjeEnjcseN4AnjeFnjcteN4CnreEnrcseN4CnreFnrcteN4GnneEnncseN4BnneFnncteN4BnveEnvcseN4DnveFnvcteN4Fng+Eng8seD4Ang+Fng8teN4Dno+Eno8seD4Cno+Fno8teN4Hnk+Enk8seD4Bnk+Fnk8teD4Ans+Ens8seD4Dns+Fns8teD4Eni+Eni8seL4Ani+Fni8teD4Cnq+Enq8seL4Cnq+Fnq8teD4Gnm+Enm8seL4Bnm+Fnm8teD4Bnu+Enu8seL4Dnu+Fnu8teD4Fnh+Enh8seH4Anh+Fnh8teD4Dnp+Enp8seH4Cnp+Fnp8teD4Hnl+Enl8seH4Bnl+Fnl8teL4Ant+Ent8seH4Dnt+Fnt8teL4Enj+Enj8seP4Anj+Fnj8teL4Cnr+Enr8seP4Cnn8JPf+y4PkaeP4Wev624PkbePqKyTz//jlTzzfA849iMs8/ipl7en/f/zQbQOgZwILnW+AZUOgZ0IJnQOD5p9DzTwue74BnIKFnIAuegYBnYKFnYAue74FnEKFnEAueQYBnUKFnUAueH4BnMKFnMAuewYBncKFncAueH4FnCKFnCAueIYBnSKFnSAuen4BnKKFnKAueoYBnaKFnaAuen4FnGKFnGAueYYBnWKFnWAueX4BnOKFnOAue4YBneKFneAueX4FnBKFnBAueEYBnRKFnRAue34BnJKFnJAuekYBnZKFnZAue34FnFKFnFAueUYBnVKFnVAueP4BnNKFnNAue0YBndKFndAueP4FnDKFnDAueMYBnTKFnTAuev4BnLKFnLAuesYBnbKFnbAuefwHPOELPOBY84wDPuELPuBY8fwPPeELPeBY84wHP+ELP+BY8fTH8/+NMIPRMYMEzAfBMKPRMaMHzD+CZSOiZyIJnIuCZWOiZ2IJnAOCZROiZxIJnEuCZVOiZ1IJnQOCZTOiZzIJnMuCZXOiZ3ILnn8AzhdAzhQXPFMAzpdAzpQXPQMAzldAzlQXPVMAztdAztQXPwMAzjdAzjQXPNMAzrdAzrQXPIMAzndAznQXPdMAzvdAzvQXPoMAzg9AzgwXPDMAzo9AzowXPYMAzk9AzkwXPTMAzs9AzswXP4MAzi9AziwXPLMAzq9AzqwXPEMAzm9AzmwXPbMAzu9AzuwXPkMAzh9AzhwXPHMAzp9AzpwXPUMAzl9AzlwXPXMAzt9AztwXP0MAzj9AzjwXPPMAzr9AzrwXPMMAzn9AznwXPfMAzv9AzvwXPsMCzgNCzgAXPAsCzoNCzoAXPcMCzkNCzkAXPQsCzsNCzsAXP8MCziNCziAXPIsCzqNCzqAXPCMCzmNCzmAXPYsCzuNCzuAXPiMCzhNCzhAXPEsCzpNCzpAXPSMCzlNCzlAXPUsCztNCztAXPyMCzjNCzjAXPMsCzrNCzrAXPKMCznNCznAXPcsCzvNCzvAXPqMCzgtCzggXPCsCzotCzogXPaMCzktCzkgXPSsCzstCzsgXP6MCzitCzigXPKsCzqtCzqgXPGMCzmtCzmgXPasCzutCzugXPmMCzhtCzhgXPGsCzptCzpgXPWMCzltCzlgXPWsCzttCztgXP2MCzjtCzjgXPOsCzrtCzrgXPOMCzntCzngXPesCzvtCzvgXPuMCzgdCzgQXPBsCzodCzoQXPeMCzkdCzkQXPRsCzsdCzsQXP+MCzidCziQXPJsCzqdCzqQXPBMCzmdCzmQXPZsCzudCzuQXPhMCzhdCzhQXPFsCzpdCzpQXPRMCzldCzlQXPVsCztdCztQXPxMCzjdCzjQXPNsCzrdCzrQXPJMCzndCznQXPdsCzvdCzvQXPpMCzg9CzgwXPDsCzo9CzowXPZMCzk9CzkwXPTsCzs9CzswXP5MCzi9CziwXPLsCzq9CzqwXPFMCzm9CzmwXPbsCzu9CzuwXPlMCzh9CzhwXPHsCzp9CzpwXPVMCzl9CzlwXPXsCzt9CztwXP1MCzj9CzjwXPPsCzr9CzrwXPNMCzn9CznwXPfsCzv9CzvwXPtMBzgNBzgAXPAcBzoNBzoAXPdMBzkNBzkAXPQcBzsNBzsAXP9MBziNBziAXPIcBzqNBzqAXPDMBzmNBzmAXPYcBzuNBzuAXPjMBzhNBzhAXPEcBzpNBzpAXPTMBzlNBzlAXPUcBztNBztAXPzMBzjNBzjAXPMcBzrNBzrAXPLMBznNBznAXPccBzvNBzvAXPrMBzgtBzggXPCcBzotBzogXPbMBzktBzkgXPScBzstBzsgXP7MBzitBzigXPKcBzqtBzqgXPHMBzmtBzmgXPacBzutBzugXPnMBzhtBzhgXPGcBzptBzpgXPXMBzltBzlgXPWcBzttBztgXP3MBzjtBzjgXPOcBzrtBzrgXPPMBzntBzngXPecBzvtBzvgXPvMBzgdBzgQXPBcBzodBzoQXPfMBzkdBzkQXPRcBzsdBzsQXP/MBzidBziQXPJcBzqdBzqQXPAsBzmdBzmQXPZcBzudBzuQXPgsBzhdBzhQXPFcBzpdBzpQXPQsBzldBzlQXPVcBztdBztQXPwsBzjdBzjQXPNcBzrdBzrQXPIsBzndBznQXPdcBzvdBzvQXPosBzg9BzgwXPDcBzo9BzowXPYsBzk9BzkwXPTcBzs9BzswXP4sBzi9BziwXPLcBzq9BzqwXPEsBzm9BzmwXPbcBzu9BzuwXPksBzh9BzhwXPHcBzp9BzpwXPUsBzl9BzlwXPXcBzt9BztwXP0sBzj9BzjwXPPcBzr9BzrwXPMsBzn9BznwXPfcBzv9BzvwXPssDzgNDzgAXPA8DzoNDzoAXPcsDzkNDzkAXPQ8DzsNDzsAXP8sDziNDziAXPI8DzqNDzqAXPCsDzmNDzmAXPY8DzuNDzuAXPisDzhNDzhAXPE8DzpNDzpAXPSsDzlNDzlAXPU8DztNDztAXPysDzjNDzjAXPM8DzrNDzrAXPKsDznNDznAXPc8DzvNDzvAXPqsDzgtDzggXPC8DzotDzogXPasDzktDzkgXPS8DzstDzsgXP6sDzitDzigXPK8DzqtDzqgXPGsDzmtDzmgXPa8DzutDzugXPmsDzhtDzhgXPG8DzptDzpgXPWsDzltDzlgXPW8DzttDztgXP2sDzjtDzjgXPO8DzrtDzrgXPOsDzntDzngXPe8DzvtDzvgXPusDzgdDzgQXPB8DzodDzoQXPesDzkdDzkQXPR8DzsdDzsQXP+sDzidDziQXPJ8DzqdDzqQXPBsDzmdDzmQXPZ8DzudDzuQXPhsDzhdDzhQXPF8DzpdDzpQXPRsDzldDzlQXPV8DztdDztQXPxsDzjdDzjQXPN8DzrdDzrQXPJsDzndDznQXPd8DzvdDzvQXPpsDzg9DzgwXPD8Dzo9DzowXPZsDzk9DzkwXPT8Dzs9DzswXP5sDzi9DziwXPL8Dzq9DzqwXPFsDzm9DzmwXPb8Dzu9DzuwXPlsDzh9DzhwXPH8Dzp9DzpwXPVsDzl9DzlwXPX8DzL6HnXxY8WwPP30LP3xY8fwNPX3GZ598/Z+rZBnj+UVzm+Udxc0/v7/ufZgMIPQNY8GwLPAMKPQNa8AwIPP8Uev5pwbMd8Awk9AxkwTMQ8Aws9AxswbM98Awi9AxiwTMI8Awq9AxqwbMD8Awm9AxmwTMY8Awu9AxuwbMj8Awh9AxhwTME8Awp9AxpwbMT8Awl9AxlwTMU8Awt9AxtwbMz8Awj9AxjwTMM8Awr9AxrwbML8Awn9AxnwTMc8Awv9AxvwbMr8Iwg9IxgwTMC8Iwo9IxowbMb8Iwk9IxkwTMS8Iws9IxswbM78Iwi9IxiwTMK8Iwq9IxqwbMH8Iwm9IxmwTMa8Iwu9IxuwbMn8Iwh9IxhwTMG8Iwp9IxpwbMX8Iwl9IxlwTMW8Iwt9IxtwbM38Iwj9IxjwTMO8Iwr9IxrwbMP8Iwn9IxnwTMe8Iwv9IxvwbMv8Ewg9ExgwTMB8Ewo9ExowbMf8Ewk9ExkwTMR8Ews9ExswbM/8Ewi9ExiwTMJ8Ewq9ExqwXMA8Ewm9ExmwTMZ8Ewu9ExuwXMg8Ewh9ExhwTMF8Ewp9ExpwXMQ8Ewl9ExlwTMV8Ewt9ExtwXMw8Ewj9ExjwTMN8Ewr9ExrwXMI8Ewn9ExnwTMd8Ewv9ExvwXMo8Mwg9MxgwTMD8Mwo9MxowXMY8Mwk9MxkwTMT8Mws9MxswXM48Mwi9MxiwTML8Mwq9MxqwXME8Mwm9MxmwTMb8Mwu9MxuwXMk8Mwh9MxhwTMH8Mwp9MxpwXMU8Mwl9MxlwTMX8Mwt9MxtwXM08Mwj9MxjwTMP8Mwr9MxrwXMM8Mwn9MxnwTMf8Mwv9MxvwXMs8Cwg9CxgwbMA8Cwo9CxowXMc8Cwk9CxkwbMQ8Cws9CxswXM88Cwi9CxiwbMI8Cwq9CxqwXMC8Cwm9CxmwbMY8Cwu9CxuwXMi8Cwh9CxhwbME8Cwp9CxpwXMS8Cwl9CxlwbMU8Cwt9CxtwXMy8Cwj9CxjwbMM8Cwr9CxrwXMK8Cwn9CxnwbMc8Cwv9CxvwXMq8Kwg9KxgwbMC8Kwo9KxowXMa8Kwk9KxkwbMS8Kws9KxswXM68Kwi9KxiwbMK8Kwq9KxqwXMG8Kwm9KxmwbMa8Kwu9KxuwXMm8Kwh9KxhwbMG8Kwp9KxpwXMW8Kwl9KxlwbMW8Kwt9KxtwXM28Kwj9KxjwbMO8Kwr9KxrwXMO8Kwn9KxnwbMe8Kwv9KxvwXMu8Gwg9GxgwbMB8Gwo9GxowXMe8Gwk9GxkwbMR8Gws9GxswXM+8Gwi9GxiwbMJ8Gwq9GxqwXMB8Gwm9GxmwbMZ8Gwu9GxuwXMh8Gwh9GxhwbMF8Gwp9GxpwXMR8Gwl9GxlwbMV8Gwt9GxtwXMx8Gwj9GxjwbMN8Gwr9GxrwXMJ8Gwn9GxnwbMd8Gwv9GxvwXMp8Owg9OxgwbMD8Owo9OxowXMZ8Owk9OxkwbMT8Ows9OxswXM58Owi9OxiwbML8Owq9OxqwXMF8Owm9OxmwbMb8Owu9OxuwXMl8Owh9OxhwbMH8Owp9OxpwXMV8Owl9OxlwbMX8Owt9OxtwXM18Owj9OxjwbMP8Owr9OxrwXMN8Own9OxnwbMf8Owv9OxvwXMt8Bwg9BxgwXMA8Bwo9BxowXMd8Bwk9BxkwXMQ8Bws9BxswXM98Bwi9BxiwXMI8Bwq9BxqwXMD8Bwm9BxmwXMY8Bwu9BxuwXMj8Bwh9BxhwXME8Bwp9BxpwXMT8Bwl9BxlwXMU8Bwt9BxtwXMz8Bwj9BxjwXMM8Bwr9BxrwXML8Bwn9BxnwXMc8Bwv9BxvwXMr8Jwg9JxgwXMC8Jwo9JxowXMb8Jwk9JxkwXMS8Jws9JxswXM78Jwi9JxiwXMK8Jwq9JxqwXMH8Jwm9JxmwXMa8Jwu9JxuwXMn8Jwh9JxhwXMG8Jwp9JxpwXMX8Jwl9JxlwXMW8Jwt9JxtwXM38Jwj9JxjwXMO8Jwr9JxrwXMP8Jwn9JxnwXMe8Jwv9JxvwXMv8Fwg9FxgwXMB8Fwo9FxowXMf8Fwk9FxkwXMR8Fws9FxswXM/8Fwi9FxiwXMJ8Fwq9FxqwfMA8Fwm9FxmwXMZ8Fwu9FxuwfMg8Fwh9FxhwXMF8Fwp9FxpwfMQ8Fwl9FxlwXMV8Fwt9FxtwfMw8Fwj9FxjwXMN8Fwr9FxrwfMI8Fwn9FxnwXMd8Fwv9FxvwfMo8Nwg9NxgwXMD8Nwo9NxowfMY8Nwk9NxkwXMT8Nws9NxswfM48Nwi9NxiwXML8Nwq9NxqwfME8Nwm9NxmwXMb8Nwu9NxuwfMk8Nwh9NxhwXMH8Nwp9NxpwfMU8Nwl9NxlwXMX8Nwt9NxtwfM08Nwj9NxjwXMP8Nwr9NxrwfMM8Nwn9NxnwXMf8Nwv9NxvwfMs8Dwg9DxgwfMA8Dwo9DxowfMc8Dwk9DxkwfMQ8Dws9DxswfM88Dwi9DxiwfMI8Dwq9DxqwfMC8Dwm9DxmwfMY8Dwu9DxuwfMi8Dwh9DxhwfME8Dwp9DxpwfMS8Dwl9DxlwfMU8Dwt9DxtwfMy8Dwj9DxjwfMM8Dwr9DxrwfMK8Dwn9DxnwfMc8Dwv9DxvwfMq8Lwg9LxgwfMC8Lwo9LxowfMa8Lwk9LxkwfMS8Lws9LxswfM68Lwi9LxiwfMK8Lwq9LxqwfMG8Lwm9LxmwfMa8Lwu9LxuwfMm8Lwh9LxhwfMG8Lwp9LxpwfMW8Lwl9LxlwfMW8Lwt9LxtwfM28Lwj9LxjwfMO8Lwr9LxrwfMO8Lwn9LxnwfMe8Lwv9LxvwfMu8Hwg9HxgwfMB8Hwo9HxowfMe8Hwk9HxkwfMR8Hws9HxswfM+8Hwi9HxiwfMJ8Hwq9HxqwfMB8Hwm9HxmwfMZ8Hwu9HxuwfMh8Hwh9HxhwfMF8Hwp9HxpwfMR8Hwl9HxlwfMV8Hwt9HxtwfMx8Hwj9HxjwfMN8Hwr9HxrwfMJ8Hwn9HxnwfMd8Hwv9HxvwfMp8Pwg9PxgwfMD8Pwo9PxowfMZ8Pwk9PxkwfMT8Pws9PxswfM58Pwi9PxiwfML8Pwq9PxqwfMF8Pwm9PxmwfMb8Pwu9PxuwfMl8Pwh9PxhwfMH8Pwp9PxpwfMV8Pwl9PxlwfMX8PxL6PmXBc/XwPO30PO3Bc/fwNNXQub598+Zer4Bnn+UkHn+UcLc0/v7/qfZAELPABY83wLPgELPgBY8AwLPP4Wef1rwfAc8Awk9A1nwDAQ8Aws9A1vwfA88gwg9g1jwDAI8gwo9g1rw/AA8gwk9g1nwDAY8gws9g1vw/Ag8Qwg9Q1jwDAE8Qwo9Q1rw/AQ8Qwk9Q1nwDAU8Qws9Q1vw/Aw8wwg9w1jwDAM8wwo9w1rw/AI8wwk9w1nwDAc8wws9w1vw/Ao8Iwg9I1jwjAA8Iwo9I1rw/AY8Iwk9I1nwjAQ8Iws9I1vw/A48owg9o1jwjAI8owo9o1rw/AE8owk9o1nwjAY8ows9o1vw/Ak8Ywg9Y1jwjAE8Ywo9Y1rw/AU8Ywk9Y1nwjAU8Yws9Y/+XP84/4B9nnP+P3/e6QTc+Bt4cZ2fHEiELdiizfoj3/1uQ//P7+c/f+//7twC+//r7+a8/END3v/+Y/u8P/On7BzvPDwTy+eP8rx8I7Nfsv34giM9/77j/4R32//P/+P//dzbfv/4c//1//7vXH57/+7/P3/+5/56Lp77jq5Pg778+SvznH2xQfcf9zz8F3//6LajP/27BfP53C+7zv1uIf5r1/EBIv2b/9QOhwGx88J4Tgcbe32ib0D7/24Tx+d8mrM//NuF8/rcJ7/PfOwKYTQDaJHbUJqLP/zaRfP63iezzv00Un/9tovr8944GZhOCNkkMd2M8vRsT6TuxvpN4dmNS9Z1MneTqpDDcjdF9/jeO4fO/cUyf/41j/dOs5wdi+zX7rx+IA2aTgcYpHb2/uD7/28Tz+d8mvs//Ngl8/rdJ6PPfOxGYTQ7apHLUJrHP/zZJfP63Serzv00yn/9tkvv8905BZkGb1Ia7ManehSn1nUrfqT27MY36TqtOOnXSG+7GlD7/G6fy+d84tc//xmn+adbzA2n9mv3XD6QDs2lB4wyO3l96n/9tMvj8b5PR53+bTD7/22T2+e+dBcymA20yOmqT1ed/m2w+/9tk9/nfJofP/zY5ff575wKz6UGbTIa7MY3ehRn0nVHfmTy7MbP6zqJOVnWyGe7G3D7/G+fx+d84r8//xvn+adbzA/n9mv3XDxQAs1lA4+yO3l9Bn/9tCvn8b1PY53+bIj7/2xT1+e9dDMxmBW1yOGpT3Od/mxI+/9uU9PnfppTP/zalff57lwGz2UCbnIa7MbPehdn1nUPfOT27MZf6zq1OHnXyGu7Gsj7/G5fz+d+4vM//xhX+adbzAxX9mv3XD1QCs7lB43yO3l9ln/9tqvj8b1PV53+baj7/21T3+e9dA8zmAW3yO2pT0+d/m1o+/9vU9vnfpo7P/zZ1ff571wOzeUGbAoa7MZfehfn0nV/fBTy7saD6LqROYXWKGO7G+j7/Gzfw+d+4oc//xo3+adbzA439mv3XDzQBs4VA46KO3l9Tn/9tmvn8b9Pc53+bFj7/27T0+e/dCswWBm2KOWrT2ud/mzY+/9u09fnfpp3P/zbtff57dwCzRUCb4oa7saDehUX1XUzfxT27sYT6LqlOKXVKG+7Gjj7/G3fy+d+4s8//xl3+adbzA139mv3XD3QDsyVB4zKO3l93n/9tevj8b9PT53+bXj7/2/T2+e/dB8yWAm3KOmrT1+d/m34+/9v09/nfZoDP/zYDff57DwKzpUGbcoa7sYTehWX0XVbf5Ty7sbz6rqBORXUqGe7GwT7/Gw/x+d94qM//xsP+adbzA8P9mv3XD4wAsxVA48qO3t9In/9tRvn8bzPa53+bMT7/24z1+e89DsxWBG2qOGoz3ud/mwk+/9tM9PnfZpLP/zaTff57TwGzlUCbqoa7sbzehZX1XUXfVT27sZr6rq5ODXVqGu7GqT7/G0/z+d94us//xjP+adbzAzP9mv3XD8wCs9VB41qO3t9sn/9t5vj8bzPX53+beT7/28z3+e+9AMzWAG1qO2qz0Od/m0U+/9ss9vnfZonP/zZLff57LwOzNUGbOoa7sZrehbX0XVvfdTy7sa76rqdOfXUaGO7G5T7/G6/w+d94pc//xqv+adbzA6v9mv3XD6wBs/VA44aO3t9an/9t1vn8b7Pe53+bDT7/22z0+e+9CczWB20aOWqz2ed/my0+/9ts9fnfZpvP/zbbff577wCzDUCbxoa7sa7ehQ313UjfjT27sYn6bqpOM3WaG+7GnT7/G+/y+d94t8//xnv+adbzA3v9mv3XD+wDs01B4xaO3t9+n/9tDvj8b3PQ53+bQz7/2xz2+e99BMw2A21aOmpz1Od/m2M+/9sc9/nf5oTP/zYnff57nwKzzUGbVoa7sYnehS303VLfrTy7sbX6bqNOW3XaGe7G0z7/G5/x+d/4rM//xuf+adbzA+f9mv3XD1wAs21A4/aO3t9Fn/9tLvn8b3PZ53+bKz7/21z1+e99Dcy2BW06OGpz3ed/mxs+/9vc9Pnf5pbP/za3ff573wGz7UCbjoa7sbXehe313UHfHT27sZP67qxOF3W6Gu7Guz7/G9/z+d/4vs//xg/+adbzAw/9mv3XDzwCs51B426O3t9jn/9tnvj8b/PU53+bZz7/2zz3+e/9Asx2AW26O2rz0ud/m1c+/9u89vnf5o3P/zZvff57vwOzXUGbHoa7sZPehd303V3fPTy7saf67qVOb3X6GO7G9z7/G3/w+d/4o8//xp/+adbzA5/9mv3XD3wBs71A476O3t9Xn/9tvvn8b/Pd53+bHz7/2/z0+e/9C8z2Bm36OWrzl8//Nr99/rf5+//hf83+3x/44w//2wT4w3/vgGC2D2jT33A39tS7sK++++m7v2c3DlDfA9UZpM5gw9345x/+Nw70h/+NA4PGQUDjoKBbMDA7EDQe4uj9BQdtQoA2IUGbUKBNaOAdBswOAm2GOmoTFrQJB9qEB20igDYRgXckMDsYtBlmuBsH6F04RN9D9T3MsxuHq+8R6oxUZ5ThbowMGkcBjaOCxtFA4+igWwwwOwI0Hu3o/cUEbWKBNrFBmzigTVzgHQ/MjgRtxjhqEx+0SQDaJARtEoE2iYF3EjA7CrQZa7gbh+tdOFrfY/Q91rMbx6nv8epMUGei4W5MChonA42Tg8YpQOOUoFsqMDseNJ7k6P2lBm3SgDZpQZt0oE164J0BzE4AbSY7apMRtMkE2mQGbbKANlmBdzYwOxG0mWK4G8fpXThJ35P1PcWzG6eq72nqTFdnhuFuzA4a5wCNc4LGuUDj3KBbHjA7DTSe6ej95QVt8oE2+UGbAqBNQeBdCMxOB21mOWpTGLQpAtoUBW2KgTbFgXcJMDsDtJltuBun6l04U9+z9D3bsxvnqO+56sxTZ77hbiwJGpcCjUuDxmVA47KgWzkwOxc0XuDo/ZUHbSqANhVBm0qgTWXgXQXMzgNtFjpqUxW0qQbaVAdtaoA2NYF3LTA7H7RZZLgb5+hduEDfC/W9yLMbF6vvJeosVWeZ4W6sDRrXAY3rgsb1QOP6oFsDMLsENF7u6P01BG0agTaNQZsmoE1T4N0MzC4FbVY4atMctGkB2rQEbVqBNq2Bdxswuwy0WWm4GxfrXbhc3yv0vdKzG1ep79XqrFFnreFubAsatwON24PGHUDjjqBbJzC7GjRe5+j9dQZtuoA2XUGbbqBNd+DdA8yuAW3WO2rTE7TpBdr0Bm36gDZ9gXc/MLsWtNlguBtX6V24Tt/r9b3Bsxs3qu9N6mxWZ4vhbuwPGg8AjQeCxoNA48Gg2xAwuwk03uro/Q0FbYaBNsNBmxGgzUjgPQrMbgZttjlqMxq0GQPajAVtxoE244H3BDC7BbTZbrgbN+pduFXf2/S93bMbd6jvnersUme34W6cCBpPAo0ng8ZTQOOpoNs0MLsTNN7j6P1NB21mgDYzQZtZoM1s4D0HzO4CbfY6ajMXtJkH2swHbRaANguB9yIwuxu02We4G3foXbhH33v1vc+zG/er7wPqHFTnkOFuXAwaLwGNl4LGy0Dj5aDbCjB7ADQ+7Oj9rQRtVoE2q0GbNaDNWuC9DsweBG2OOGqzHrTZANpsBG02gTabgfcWMHsItDlquBv36114WN9H9H3UsxuPqe/j6pxQ56ThbtwKGm8DjbeDxjtA452g2y4wexw0PuXo/e0GbfaANntBm32gzX7y9yIwewK0Oe2ozUHQ5hBocxi0OQLaHAXex8DsSdDmjOFuPKZ34Sl9n9b3Gc9uPKu+z6lzXp0LhrvxOGh8AjQ+CRqfAo1Pg25nwOw50Piio/d3FrQ5B9qcB20ugDYXgfclMHsetLnkqM1l0OYKaHMVtLkG2lwH3jfA7AXQ5rLhbjyrd+FFfV/S92XPbryivq+qc02d64a78SZofAs0vg0a3wGN74Ju98DsVdD4hqP3dx+0eQDaPARtHoE2j4H3EzB7DbS56ajNU9DmGWjzHLR5Adq8BN6vwOx10OaW4W68onfhDX3f1Pctz268rb7vqHNXnXuGu/E1aPwGNH4LGr8Djd+Dbh/A7B3Q+L6j9/cRtPkE2nwGbb6ANl+B9zcwexe0eeCozXfQ5gdo8xO0+QXa/AW8f5N//gBtHhruxtt6F97X9wN9P/Tsxkfq+7E6T9R5+n92479n4v7nn4Lvf/4WwP/GfwTw3+wxMHvm6K/nAODPNWAA//96/jOA/389Bwrg/1/PgYF3EDD7BLR57qhNUNAmGGgTHLQJAdqEBN6hwOxT0OaF4a55pHfLM30/1/cLz655qb5fqfNanTeG/xwWGjQOAxqHBY3DgcbhQbcIYPYVaPzW0fuLCNpEAm0igzZRQJuowDsamH0N2rxz1CY6aBMDtIkJ2sQCbWID7zhg9g1o895wN77Uu/Ctvt/p+71nN35Q3x/V+aTOZ8PdGBc0jgcaxweNE4DGCUG3RGD2I2j8xdH7SwzaJAFtkoI2yUCb5MA7BZj9BNp8ddQmJWiTCrRJDdqkAW3SAu90YPYzaPPNcDd+0Lvwi76/6vubZzd+V98/1Pmpzi/D3ZgeNM4AGmcEjTOBxplBtyxg9gdo/Jej95cVtMkG2mQHbXKANjmBdy4w+xO0+e2oTW7QJg9okxe0yQfa5AfeBcDsL9DGV9JsN37Xu/Avff/W99//uf/PnPoOoE7Av//fSv7nHyxtXBA0LgQaFwaNi4DGRUG3YmA2QEn/GwcCjb2/0TbFQZsSoE1J0KYUaFMaeJcBswFBm8CO2pQFbcqBNuVBmwqgTUXgXQnM/gnaBDHcjX/vvb/vQPoOrO8gnt0YVH0HUye4OiEMd2Nl0LgKaFwVNK4GGlcH3WqA2WCgcUhH768maFMLtKkN2tQBbeoC73pgNjhoE8pRm/qgTQPQpiFo0wi0aQy8m4DZEKBNaMPdGFTvwpD6DqXv0J7dGEZ9h1UnnDrhDXdjU9C4GWjcHDRuARq3BN1agdmwoHEER++vNWjTBrRpC9q0A23aA+8OYDYcaBPRUZuOoE0n0KYzaNMFtOkKvLuB2fCgTSTD3RhG78II+o6o70ie3RhZfUdRJ6o60Qx3Y3fQuAdo3BM07gUa9wbd+oDZKKBxdEfvry9o0w+06Q/aDABtBgLvQWA2KmgTw1GbwaDNENBmKGgzDLQZDrxHkP+9AWgT03A3Rta7MLq+Y+g7pmc3xlLfsdWJ8/fvy3A3jgSNR4HGo0HjMaDxWNBtHJiNDRrHc/T+xoM2E0CbiaDNJNBmMvCeQv43JaBNfEdtpoI200Cb6aDNDNBmJvCeBWbjgjYJDHdjLL0L4+k7vr4TeHZjQvWdSJ3E6iQx3I2zQeM5oPFc0HgeaDwfdFtA/vc+oHFSR+9vIWizCLRZDNosAW2WAu9lYDYxaJPMUZvloM0K0GYlaLMKtFkNvNeA2SSgTXLD3ZhQ78Kk+k6m7+Se3ZhCfadUJ5U6qQ1341rQeB1ovB403gAabwTdNoHZlKBxGkfvbzNoswW02QrabANttgPvHWA2FWiT1lGbnaDNLtBmN2izB7TZC7z3gdnUoE06w92YQu/CNPpOq+90nt2YXn1nUCejOpkMd+N+0PgAaHwQND4EGh8G3Y6A2QygcWZH7+8oaHMMtDkO2pwAbU4C71NgNiNok8VRm9OgzRnQ5ixocw60OQ+8L4DZTKBNVsPdmF7vwsz6zqLvrJ7dmE19Z1cnhzo5DXfjRdD4Emh8GTS+AhpfBd2ugdnsoHEuR+/vOmhzA7S5CdrcAm1uA+87YDYHaJPbUZu7oM090OY+aPMAtHkIvB+B2ZygTR7D3ZhN78Jc+s6t7zye3ZhXfedTJ786BQx342PQ+Alo/BQ0fgYaPwfdXoDZfKBxQUfv7yVo8wq0eQ3avAFt3gLvd2A2P2hTyFGb96DNB9DmI2jzCbT5DLy/gNkCoE1hw92YV+/CgvoupO/Cnt1YRH0XVaeYOsUNd+NX0PgbaPwdNP4BGv8E3X6B2aKgcQlH7+8v0OY3aOML6H+bPwL63yZAQP+9A4LZYqBNSUdt/gzof5tAAf1vExi0CQLaBAXewcBscdCmlOFuLKJ3YQl9l9R3Kc9uLK2+y6hTVp1yhrsxOGgcAjQOCRqHAo1Dg25hwGwZ0Li8o/cXFrQJB9qEB20igDYRgXckMFsWtKngqE1k0CYKaBMVtIkG2kQH3jHAbDnQpqLhbiytd2F5fVfQd0XPbqykviurU0Wdqoa7MSZoHAs0jg0axwGN44Ju8cBsZdC4mqP3Fx+0SQDaJARtEoE2iYF3EjBbBbSp7qhNUtAmGWiTHLRJAdqkBN6pwGxV0KaG4W6spHdhNX1X13cNz26sqb5rqVNbnTqGuzE1aJwGNE4LGqcDjdODbhnAbC3QuK6j95cRtMkE2mQGbbKANlmBdzYwWxu0qeeoTXbQJgdokxO0yQXa5AbeecBsHdCmvuFurKl3YV1919N3fc9ubKC+G6rTSJ3GhrsxL2icDzTODxoXAI0Lgm6FwGxD0LiJo/dXGLQpAtoUBW2KgTbFgXcJMNsItGnqqE1J0KYUaFMatCkD2pQl/z0ZzDYGbZoZ7sYGehc20XdTfTfz7Mbm6ruFOi3VaWW4G8uDxhVA44qgcSXQuDL572JgtgVo3NrR+6sK2lQDbaqDNjVAm5rkn9PBbEvQpo2jNrVBmzqgTV3Qph5oUx94NwCzrUCbtoa7sbneha313UbfbT27sZ36bq9OB3U6Gu7GhqBxI9C4MWjcBDRuCro1A7PtQeNOjt5fc9CmBWjTErRpBdq0Bt5twGwH0KazozZtQZt2oE170KYDaNMReHcCsx1Bmy6Gu7Gd3oWd9N1Z3108u7Gr+u6mTnd1ehjuxs6gcRfQuCto3A007g669QCz3UDjno7eX0/Qphdo0xu06QPa9AXe/cBsd9Cml6M2/UGbAaDNQNBmEGgzGHgPIW8MtOltuBu76l3YU9+99N3bsxv7qO++6vRTp7/hbhwKGg8DjYeDxiNA45Gg2ygw2xc0HuDo/Y0GbcaANmNBm3GgzXjgPYHsUdBmoKM2E0GbSaDNZNBmCmgzFXhPA7P9QZtBhruxj96FA/Q9UN+DPLtxsPoeos5QdYYZ7sbpoPEM0HgmaDwLNJ4Nus0hf68EjYc7en9zQZt5oM180GYBaLMQeC8Cs0NBmxGO2iwGbZaANktBm2WgzXLgvQLMDgNtRhruxsF6Fw7X9wh9j/TsxlHqe7Q6Y9QZa7gbV4LGq0Dj1aDxGtB4Lei2DsyOBo3HOXp/60GbDaDNRtBmE2izGXhvAbNjQJvxjtpsBW22gTbbQZsdoM1O4L0LzI4FbSYY7sZReheO0/d4fU/w7MaJ6nuSOpPVmWK4G3eDxntA472g8T7QeD/odgDMTgKNpzp6fwdBm0OgzWHQ5ghocxR4HwOzk0GbaY7aHAdtToA2J0GbU6DNaeB9BsxOAW2mG+7GiXoXTtX3NH1P9+zGGep7pjqz1JltuBvPgsbnQOPzoPEF0Pgi6HYJzM4Ejec4en+XQZsroM1V0OYaaHMdeN8As7NAm7mO2twEbW6BNrdBmzugzV3gfQ/MzgZt5hnuxhl6F87R91x9z/Psxvnqe4E6C9VZZLgb74PGD0Djh6DxI9D4Mej2BMwuAI0XO3p/T0GbZ6DNc9DmBWjzEni/ArMLQZsljtq8Bm3egDZvQZt3oM174P2B/LoxaLPUcDfO17twsb6X6HupZzcuU9/L1VmhzkrD3fgRNP4EGn8Gjb+Axl9Bt29gdjlovMrR+/sO2vwAbX6CNr9Am7+A92/y7wZAm9XCNv9+W3H/83ft+5+//el/mz/+9P/PdSX4c11juGuW6d2ySt+r9b3Gs2vWqu916qxXZ4PhrgkAzAL+6f9fz3/+6f9fz4H+9P+v58CgWxAwuw403uho1wQFbYKBNsFBmxCgTUjgHQrMrgdtNjlqExq0CQPahAVtwoE24YF3BDC7AbTZbLgb1+pduFHfm/S92bMbt6jvrepsU2e74W6MCBpHAo0jg8ZRQOOooFs0MLsVNN7h6P1FB21igDYxQZtYoE1s4B0HzG4DbXY6ahMXtIkH2sQHbRKANgmBdyIwux202WW4G7foXbhD3zv1vcuzG3er7z3q7FVnn+FuTAwaJwGNk4LGyUDj5KBbCjC7BzTe7+j9pQRtUoE2qUGbNKBNWuCdDszuBW0OOGqTHrTJANpkBG0ygTaZgXcWMLsPtDlouBt36124X98H9H3QsxsPqe/D6hxR56jhbswKGmcDjbODxjlA45ygWy4wexg0Pubo/eUGbfKANnlBm3ygTX7gXQDMHgFtjjtqUxC0KQTaFAZtioA2RYF3MTB7FLQ5YbgbD+ldeEzfx/V9wrMbT6rvU+qcVueM4W4sDhqXAI1LgsalQOPSoFsZMHsKND7r6P2VBW3KgTblQZsKoE1F4F0JzJ4Gbc45alMZtKkC2lQFbaqBNtWBdw0wewa0OW+4G0/qXXhW3+f0fd6zGy+o74vqXFLnsuFurAka1wKNa4PGdUDjuqBbPTB7ETS+4uj91QdtGoA2DUGbRqBNY+DdBMxeAm2uOmrTFLRpBto0B21agDYtgXcrMHsZtLlmuBsv6F14Rd9X9X3Nsxuvq+8b6txU55bhbmwNGrcBjduCxu1A4/agWwcwewM0vu3o/XUEbTqBNp1Bmy6gTVfg3Q3M3gRt7jhq0x206QHa9ARteoE2vYF3HzB7C7S5a7gbr+tdeFvfd/R917Mb76nv++o8UOeh4W7sCxr3A437g8YDQOOBoNsgMHsfNH7k6P0NBm2GgDZDQZthoM1w4D0CzD4AbR47ajMStBkF2owGbcaANmOB9zgw+xC0eWK4G+/pXfhI34/1/cSzG5+q72fqPFfnheFuHA8aTwCNJ4LGk0DjyaDbFDD7DDR+6ej9TQVtpoE200GbGaDNTOA9C8w+B21eOWozG7SZA9rMBW3mgTbzgfcCMPsCtHltuBuf6l34Ut+v9P3asxvfqO+36rxT573hblwIGi8CjReDxktA46Wg2zIw+xY0/uDo/S0HbVaANitBm1WgzWrgvQbMvgNtPjpqsxa0WQfarAdtNoA2G4H3JjD7HrT5ZLgb3+hd+EHfH/X9ybMbP6vvL+p8Veeb4W7cDBpvAY23gsbbQOPtoNsOMPsFNP7u6P3tBG12gTa7QZs9oM1e4L0PzH4FbX44arMftDkA2hwEbQ6BNoeB9xEw+w20+Wm4Gz/rXfhd3z/0/dOzG3+p77/U+f33Xiz1n3+wtPFR0PgYaHwcND4BGp8E3U6B2b9A4z9KuXl/p0GbM6DNWdDmHGhzHnhfALO/QZsAjtpcBG0ugTaXQZsroM1V4H0NzPpK+d8mIGjz33bjL70L/35/f98B9P33f+6/5/5U34HUCaxOEMPdeB00vgEa3wSNb4HGt0G3O2A2EGgc1NH7uwva3ANt7oM2D0Cbh8D7EZgNDNoEc9TmMWjzBLR5Cto8A22ek19DBLNBQJvghrvxT70Lg+o7mL6De3ZjCPUdUp1Q6oQ23I0vQeNXoPFr0PgNaPyW/DoVmA0JGodx9P7egzYfQJuPoM0n0OYz+TUMMBsKtAnrqM1X0OYbaPMdtPkB2vwE3r/AbGjQJpzhbgyhd2EYfYfVdzjPbgyvviOoE1GdSIa78S/Q+Ddo7Avkf+M//mnW8wMB/Jr91w8EBLMRQOPIjt7fn4H8bxMokP9tAoM2QUCboMA7GJiNCNpEcdQmOGgTArQJCdqEAm1CA+8wYDYSaBPVcDeG17swsr6j6DuqZzdGU9/R1YmhTkzD3RgWNA4HGocHjSOAxhFJNzAbHTSO5ej9RQZtooA2UUGbaKBNdOAdg8yCNrEdtYkJ2sQCbWKDNnFAm7jAOx6YjQnaxDHcjdH0Loyl79j6juPZjXHVdzx14quTwHA3xgeNE4DGCUHjRKBxYtAtCfnrATRO6Oj9JQVtkoE2yUGbFKBNSuCdCszGB20SOWqTGrRJA9qkBW3SgTbpgXcGMJsAtElsuBvj6l2YUN+J9J3YsxuTqO+k6iRTJ7nhbswIGmcCjTODxllA46ygWzYwmxQ0TuHo/WUHbXKANjlBm1ygTW7gnQfMJgNtUjpqkxe0yQfa5AdtCoA2BYF3ITCbHLRJZbgbk+hdmELfKfWdyrMbU6vvNOqkVSed4W4sDBoXAY2LgsbFQOPioFsJMJsGNE7v6P2VBG1KgTalQZsyoE1Z4F0OzKYFbTI4alMetKkA2lQEbSqBNpWBdxUwmw60yWi4G1PrXZhe3xn0ndGzGzOp78zqZFEnq+FurAoaVwONq4PGNUDjmqBbLTCbGTTO5uj91QZt6oA2dUGbeqBNfeDdAMxmAW2yO2rTELRpBNo0Bm2agDZNgXczMJsVtMlhuBsz6V2YTd/Z9Z3Dsxtzqu9c6uRWJ4/hbmwOGrcAjVuCxq1A49agWxswmws0zuvo/bUFbdqBNu1Bmw6gTUfg3QnM5gZt8jlq0xm06QLadAVtuoE23YF3D/JrI6BNfsPdmFPvwrz6zqfv/J7dWEB9F1SnkDqFDXdjT9C4F2jcGzTuAxr3Bd36gdmCoHERR++vP2gzALQZCNoMAm0GA+8h5Ne/QJuijtoMBW2GgTbDQZsRoM1I4D0KzBYGbYoZ7sYCehcW0XdRfRfz7Mbi6ruEOiXVKWW4G0eDxmNA47Gg8TjQeDzoNoH82iRoXNrR+5sI2kwCbSaDNlNAm6nAexqYLQnalHHUZjpoMwO0mQnazAJtZgPvOWC2FGhT1nA3Fte7sLS+y+i7rGc3llPf5dWpoE5Fw904FzSeBxrPB40XgMYLQbdFYLY8aFzJ0ftbDNosAW2WgjbLQJvlwHsFmK0A2lR21GYlaLMKtFkN2qwBbdYC73VgtiJoU8VwN5bTu7CSvivru4pnN1ZV39XUqa5ODcPduB403gAabwSNN4HGm0G3LWC2Gmhc09H72wrabANttoM2O0CbncB7F5itDtrUctRmN2izB7TZC9rsA232A+8DYLYGaFPbcDdW1buwpr5r6bu2ZzfWUd911amnTn3D3XgQND4EGh8GjY+AxkdBt2Ngti5o3MDR+zsO2pwAbU6CNqdAm9PA+wyYrQfaNHTU5ixocw60OQ/aXABtLgLvS2C2PmjTyHA31tG7sIG+G+q7kWc3NlbfTdRpqk4zw914GTS+AhpfBY2vgcbXQbcbYLYJaNzc0fu7CdrcAm1ugzZ3QJu7wPsemG0K2rRw1OY+aPMAtHkI2jwCbR4D7yfkf+8D2rQ03I2N9S5sru8W+m7p2Y2t1Hdrddqo09ZwNz4FjZ+Bxs9B4xeg8UvQ7RWYbQ0at3P0/l6DNm9Am7egzTvQ5j3w/gBm24A27R21+QjafAJtPoM2X0Cbr8D7G5htC9p0MNyNrfQubKfv9vru4NmNHdV3J3U6q9PFcDd+B41/gMY/QeNfoPFfoNtvMNsJNO4qfH//z///8P/5u/b9z98C+9/mj8D+/7l2Bn+u3RztmgDgzzVgYP//OvwzsP9/HQYK7P9fh4GBdxAw2wW06W64azrq3dJV39303d2za3qo757q9FKnt+GuCQoaBwONg4PGIUDjkKBbKDDbEzTu4+j9hQZtwoA2YUGbcKBNeOAdAcz2Am36OmoTEbSJBNpEBm2igDZRgXc0MNsbtOlnuBt76F3YR9999d3Psxv7q+8B6gxUZ5DhbowOGscAjWOCxrFA49igWxwwOwA0Huzo/cUFbeKBNvFBmwSgTULgnQjMDgRthjhqkxi0SQLaJAVtkoE2yYF3CjA7CLQZargb++tdOFjfQ/Q91LMbh6nv4eqMUGek4W5MCRqnAo1Tg8ZpQOO0oFs6MDscNB7l6P2lB20ygDYZQZtMoE1m4J0FzI4AbUY7apMVtMkG2mQHbXKANjmBdy4wOxK0GWO4G4fpXThK36P1PcazG8eq73HqjFdnguFuzA0a5wGN84LG+UDj/KBbATA7DjSe6Oj9FQRtCoE2hUGbIqBNUeBdDMyOB20mOWpTHLQpAdqUBG1KgTalgXcZMDsBtJlsuBvH6l04Ud+T9D3ZsxunqO+p6kxTZ7rhbiwLGpcDjcuDxhVA44qgWyUwOxU0nuHo/VUGbaqANlVBm2qgTXXgXQPMTgNtZjpqUxO0qQXa1AZt6oA2dYF3PTA7HbSZZbgbp+hdOEPfM/U9y7MbZ6vvOerMVWee4W6sDxo3AI0bgsaNQOPGoFsTMDsHNJ7v6P01BW2agTbNQZsWoE1L4N0KzM4FbRY4atMatGkD2rQFbdqBNu2BdwcwOw+0WWi4G2frXThf3wv0vdCzGxep78XqLFFnqeFu7AgadwKNO4PGXUDjrqBbNzC7GDRe5uj9dQdteoA2PUGbXqBNb+DdB8wuAW2WO2rTF7TpB9r0B20GgDYDyb9fAbNLQZsVhrtxkd6Fy/S9XN8rPLtxpfpepc5qddYY7sbBoPEQ0HgoaDwMNB5Ofg0fzK4Cjdc6en8jQZtRoM1o0GYMaDOW/PoumF0N2qxz1GY8aDMBtJkI2kwCbSYD7ylgdg1os95wN67Uu3Ctvtfpe71nN25Q3xvV2aTOZsPdOBU0ngYaTweNZ4DGM0G3WWB2I2i8xdH7mw3azAFt5oI280Cb+cB7AZjdBNpsddRmIWizCLRZDNosAW2WAu9lYHYzaLPNcDdu0Ltwi7636nubZzduV9871Nmpzi7D3bgcNF4BGq8EjVeBxqvJ39PA7A7QeLej97cWtFkH2qwHbTaANhvJvgOzO0GbPY7abAZttoA2W0GbbaDNdvIWwOwu0Gav4W7crnfhbn3v0fdez27cp773q3NAnYOGu3EnaLwLNN4NGu8BjfeCbvvA7H7Q+JCj97cftDkA2hwEbQ6BNoeB9xEwewC0OeyozVHQ5hhocxy0OQHanATep8DsQdDmiOFu3Kd34SF9H9b3Ec9uPKq+j6lzXJ0ThrvxNGh8BjQ+CxqfA43Pg24XwOwx0Piko/d3EbS5BNpcBm2ugDZXgfc1MHsctDnlqM110OYGaHMTtLkF2twG3nfA7AnQ5rThbjyqd+FJfZ/S92nPbjyjvs+qc06d84a78S5ofA80vg8aPwCNH4Juj8DsWdD4gqP39xi0eQLaPAVtnoE2z4H3CzB7DrS56KjNS9DmFWjzGrR5A9q8Bd7vwOx50OaS4W48o3fhBX1f1Pclz268rL6vqHNVnWuGu/E9aPwBNP4IGn8CjT+Dbl/A7BXQ+Lqj9/cVtPkG2nwHbX6ANj+B9y8wexW0ueGozV+gzW/QxhfE/zZ/BPG/TYAg/nsHBLPXQJubhrvxst6F1/V9Q983Pbvxlvq+rc4dde4a7sY/g/jfOFAQ/xsHBo2DgMZBQbdgYPY2aHzP0fsLDtqEAG1CgjahQJvQwDsMmL0D2tx31CYsaBMOtAkP2kQAbSIC70hg9i5o88BwN97Su/Cevu/r+4FnNz5U34/UeazOE8PdGBk0jgIaRwWNo4HG0UG3GGD2EWj81NH7iwnaxAJtYoM2cUCbuMA7Hph9DNo8c9QmPmiTALRJCNokAm0SA+8kYPYJaPPccDc+1Lvwqb6f6fu5Zze+UN8v1XmlzmvD3ZgUNE4GGicHjVOAxilBt1Rg9iVo/MbR+0sN2qQBbdKCNulAm/TAOwOYfQXavHXUJiNokwm0yQzaZAFtsgLvbGD2NWjzznA3vtC78I2+3+r7nWc3vlffH9T5qM4nw92YHTTOARrnBI1zgca5Qbc8YPYDaPzZ0fvLC9rkA23ygzYFQJuCwLsQmP0I2nxx1KYwaFMEtCkK2hQDbYoD7xJg9hNo89VwN77Xu/Czvr/o+6tnN35T39/V+aHOT8PdWBI0LgUalwaNy4DGZUG3cmD2O2j8y9H7Kw/aVABtKoI2lUCbysC7Cpj9Adr85ahNVdCmGmhTHbSpAdrUBN61wOxP0Oa34W78pnfhL33/pe/fnt3oK63+39QJoE7A0v/5B0sb1waN64DGdUHjeqBxfdCtAZj92/Pfs//U+M/Sbt5fQ9CmEWjTGLRpAto0Bd7NwGwA0CaQozbNQZsWoE1L0KYVaNMaeLch/04btAkM2vy33fj/33u+f72/v+9A+v77P/ffc0HUd1B1gqkT3HA3tgWN24HG7UHjDqBxR9CtE5gNChqHcPT+OoM2XUCbrqBNN9CmO/DuQf73BqBNSEdteoI2vUCb3qBNH9CmL/DuB2aDgzahDHdjEL0LQ+g7pL5DeXZjaPUdRp2w6oQz3I39QeMBoPFA0HgQaDwYdBtC/jcloHF4R+9vKGgzDLQZDtqMAG1GAu9RYDYsaBPBUZvRoM0Y0GYsaDMOtBkPvCeA2XCgTUTD3Rha78Lw+o6g74ie3RhJfUdWJ4o6UQ1340TQeBJoPBk0ngIaTwXdpoHZyKBxNEfvbzpoMwO0mQnazAJtZgPvOWA2CmgT3VGbuaDNPNBmPmizALRZCLwXgdmooE0Mw90YSe/CaPqOru8Ynt0YU33HUie2OnEMd+Ni0HgJaLwUNF4GGi8H3VaA2VigcVxH728laLMKtFkN2qwBbdYC73VgNjZoE89Rm/WgzQbQZiNoswm02Qy8t4DZOKBNfMPdGFPvwrj6jqfv+J7dmEB9J1QnkTqJDXfjVtB4G2i8HTTeARrvBN12gdmEoHESR+9vN2izB7TZC9rsA232A+8DYDYRaJPUUZuDoM0h0OYwaHMEtDkKvI+B2cSgTTLD3ZhA78Ik+k6q72Se3ZhcfadQJ6U6qQx343HQ+ARofBI0PgUanwbdzoDZFKBxakfv7yxocw60OQ/aXABtLgLvS2A2JWiTxlGby6DNFdDmKmhzDbS5DrxvgNlUoE1aw92YXO/C1PpOo++0nt2YTn2nVyeDOhkNd+NN0PgWaHwbNL4DGt8F3e6B2fSgcSZH7+8+aPMAtHkI2jwCbR4D7ydgNgNok9lRm6egzTPQ5jlo8wK0eQm8X4HZjKBNFsPdmE7vwkz6zqzvLJ7dmFV9Z1Mnuzo5DHfja9D4DWj8FjR+Bxq/B90+gNlsoHFOR+/vI2jzCbT5DNp8AW2+Au9vYDY7aJPLUZvvoM0P0OYnaPMLtPkLeP8GszlAm9yGuzGr3oU59Z1L37k9uzGP+s6rTj518v+f3fjvmbj/+afg+5+/BfW/8R9B/TfLC8wKCP96DqLvuP/n9+37H78FCPs//vj/y08EDPv/+ef6Hz/xZ1g/XPRPBArrv2FgMJsPeBf8f3v/z//T+xv1DgK8gwLvYMA7ODAMAWbzA+9CwPu/7YQ8egcU0HdBfRfy7ITC6ruIOkXVKfZ/dgLtFhJ0CwW6hQbdwoAWYcFsEdCtuKN3Eg54hwfeEYB3RGAYCcwWBd4lHHlHBt5RgHdU4B0NGEYHs8WAd0nDvVRY76Hi+i6h75KevVRKfZdWp4w6ZQ33UgzQLSboFgt0iw1axAGzpUG3co7eSVzgHQ94xwfeCYBhQjBbBniXd+SdCHgnBt5JgHdSYJgMzJYF3hUM91IpvYfK6bu8vit49lJF9V1JncrqVDHcS8lBtxSgW0rQLRVokRrMVgLdqjp6J2mAd1rgnQ54pweGGcBsZeBdzZF3RuCdCXhnBt5ZgGFWMFsFeFc33EsV9R6qqu9q+q7u2Us11HdNdWqpU9twL2UD3bKDbjlAt5ygRS4wWxN0q+PoneQG3nmAd17gnQ8Y5geztYB3XUfeBYB3QeBdCHgXBoZFwGxt4F3PcC/V0Huojr7r6rueZy/VV98N1GmoTiPDvVQUdCsGuhUH3UqAFiXBbAPQrbGjd1IKeJcG3mWAd1lgWA7MNgTeTRx5lwfeFYB3ReBdifwzJ5htBLybGu6l+noPNdZ3E3039eylZuq7uTot1GlpuJeqgG5VQbdqoFt10KIGmG0OurVy9E5qAu9awLs28K4DDOuC2RbAu7Uj73rAuz7wbgC8G5JdA2ZbAu82hnupmd5DrfTdWt9tPHuprfpup057dToY7qXGoFsT0K0p6NaM7Bow2w506+jonbQA3i2Bdyvg3RoYtgGz7YF3J0febYF3O+DdHnh3AIYdwWwH4N3ZcC+11Xuoo7476buzZy91Ud9d1emmTnfDvdQJdOsMunUB3bqCFt3AbFfQrYejd9IdePcA3j2Bdy9g2Ju0Ad49HXn3Ad59gXc/4N0fGA4As92Bdy/DvdRF76Ee+u6p716evdRbffdRp686/Qz30kDQbRDoNhh0GwJaDAWzfUC3/o7eyTDgPRx4jwDeI4HhKDDbF3gPcOQ9GniPAd5jgfc4YDgezPYD3gMN91JvvYf663uAvgd69tIg9T1YnSHqDDXcSxNAt4mg2yTQbTJoMQXMDgbdhjl6J1OB9zTgPR14zwCGM8HsEOA93JH3LOA9G3jPAd5zgeE88vdo4D3CcC8N0ntomL6H63uEZy+NVN+j1BmtzhjDvTQfdFsAui0E3RaBFovJ3+tBt7GO3skS4L0UeC8D3suB4QowOxp4j3PkvRJ4rwLeq4H3GmC4FsyOAd7jDffSSL2Hxup7nL7He/bSBPU9UZ1J6kw23EvrQLf1oNsG0G0jaLEJzE4E3aY4eiebgfcW4L0VeG8DhtvB7CTgPdWR9w7gvRN47wLeu4HhHjA7GXhPM9xLE/QemqLvqfqe5tlL09X3DHVmqjPLcC/tBd32gW77QbcDoMVBMDsDdJvt6J0cAt6HgfcR4H0UGB4j/50PeM9x5H0ceJ8A3ieB9ylgeBrMzgLecw330nS9h2bre46+53r20jz1PV+dBeosNNxLZ0C3s6DbOdDtPGhxAczOB90WOXonF4H3JeB9GXhfAYZXwewC4L3Ykfc14H0deN8A3jeB4S0wuxB4LzHcS/P0Hlqk78X6XuLZS0vV9zJ1lquzwnAv3Qbd7oBud0G3e6DFfTC7DHRb6eidPADeD4H3I+D9GBg+AbPLgfcqR95Pgfcz4P0ceL8Ahi/B7ArgvdpwLy3Ve2ilvlfpe7VnL61R32vVWafOesO99Ap0ew26vQHd3oIW78DsWtBtg6N38h54fwDeH4H3J2D4GcyuA94bHXl/Ad5fgfc34P0dGP4As+uB9ybDvbRG76EN+t6o702evbRZfW9RZ6s62wz30k/Q7Rfo9hfo9hu08IXzf3YL6Lbd0Tv5I5z/3gHC+e8dMJz/3n8Cw0Bgdivw3uHIOzDwDgK8gwLvYMAwOJjdBrx3Gu6lzXoPbdf3Dn3v9OylXep7tzp71NlruJdCgG4hQbdQoFto0CIMmN0Nuu1z9E7CAu9wwDs88I4ADCOC2T3Ae78j70jAOzLwjgK8owLDaGB2L/A+YLiXduk9tE/f+/V9wLOXDqrvQ+ocVueI4V6KDrrFAN1igm6xQIvYYPYQ6HbU0TuJA7zjAu94wDs+MEwAZg8D72OOvBMC70TAOzHwTgIMk4LZI8D7uOFeOqj30FF9H9P3cc9eOqG+T6pzSp3ThnspGeiWHHRLAbqlBC1SgdmToNsZR+8kNfBOA7zTAu90wDA9mD0FvM868s4AvDMC70zAOzMwzAJmTwPvc4Z76YTeQ2f0fVbf5zx76bz6vqDORXUuGe6lrKBbNtAtO+iWA7TICWYvgG6XHb2TXMA7N/DOA7zzAsN8YPYi8L7iyDs/8C4AvAsC70LAsDCYvQS8rxrupfN6D13W9xV9X/XspWvq+7o6N9S5abiXioBuRUG3YqBbcdCiBJi9DrrdcvROSgLvUsC7NPAuAwzLgtkbwPu2I+9ywLs88K4AvCsCw0pg9ibwvmO4l67pPXRL37f1fcezl+6q73vq3FfngeFeqgy6VQHdqoJu1UCL6mD2Huj20NE7qQG8awLvWsC7NjCsA2bvA+9HjrzrAu96wLs+8G4ADBuC2QfA+7HhXrqr99BDfT/S92PPXnqivp+q80yd54Z7qRHo1hh0awK6NQUtmoHZp6DbC0fvpDnwbgG8WwLvVsCwNZh9BrxfOvJuA7zbAu92wLs9MOwAZp8D71eGe+mJ3kMv9P1S3688e+m1+n6jzlt13hnupY6gWyfQrTPo1gW06Apm34Bu7x29k27Auzvw7gG8ewLDXmD2LfD+4Mi7N/DuA7z7Au9+wLA/mH0HvD8a7qXXeg+91/cHfX/07KVP6vuzOl/U+Wq4lwaAbgNBt0Gg22DQYgiY/Qy6fXP0ToYC72HAezjwHgEMR4LZL8D7uyPvUcB7NPAeA7zHAsNxYPYr8P5huJc+6T30Td/f9f3Ds5d+qu9f6vylzm/DvTQedJsAuk0E3SaBFpPB7C/QzVfGzTuZArynAu9pwHs6MJwBZv8C3n848p4JvGcB79nAew4wnAtmfwPvAMD7v+2ln3oP/f1O/r7/0Pff/7n/ngv497c6gdQJXOY//2Bpt3mg23zQbQHothC0WARm/yzjf7cgjt7JYuC9BHgvBd7LgOFyMBsIeAd15L0CeK8E3quA92pguAbMBgbewQz3UkC9h4LoO6i+g3n2UnD1HUKdkOqEMtxLa0G3daDbetBtA2ixEcyGAN1CO3onm4D3ZuC9BXhvBYbbwGxI4B3Gkfd24L0DeO8E3ruA4W4wGwp4hzXcS8H1Hgqt7zD6DuvZS+HUd3h1IqgT0XAv7QHd9oJu+0C3/aDFATAbHnSL5OidHATeh4D3YeB9BBgeBbMRgHdkR97HgPdx4H0CeJ8EhqfAbETgHcVwL4XTeyiSviPrO4pnL0VV39HUia5ODMO9dBp0OwO6nQXdzoEW58FsNNAtpqN3cgF4XwTel4D3ZWB4BcxGB96xHHlfBd7XgPd14H0DGN4EszGAd2zDvRRV76GY+o6l79ievRTn79+HOvHUiW+4l26BbrdBtzug213Q4h6YjQu6JXD0Tu4D7wfA+yHwfgQMH4PZeMA7oSPvJ8D7KfB+BryfA8MXYDY+8E5kuJfi6D2UQN8J9Z3Is5cSq+8k6iRVJ5nhXnoJur0C3V6Dbm/I/0YGzCYB3ZI7eifvgPd74P0BeH8Ehp/AbFLgncKR92fg/QV4fwXe34DhdzCbDHinNNxLifUeSq7vFPpO6dlLqdR3anXSqJPWcC/9AN1+gm6/QLe/yL8bBbOpQbd0jt6JL7z/3n+E9987QHj/vQOG99/wTzCbBnind+QdCHgHBt5BgHdQYBgMzKYF3hkM91IqvYfS6Tu9vjN49lJG9Z1JnczqZDHcS8FBtxCgW0jQLRRoERrMZgLdsjp6J2GAd1jgHQ54hweGEcBsZuCdzZF3ROAdCXhHBt5RgGFUMJsFeGc33EsZ9R7Kqu9s+s7u2Us51HdOdXKpk9twL0UD3aKDbjFAt5igRSwwmxN0y+PoncQG3nGAd1zgHQ8YxgezuYB3XkfeCYB3QuCdCHgnBoZJwGxu4J3PcC/l0Hsoj77z6jufZy/lV98F1CmoTiHDvZQUdEsGuiUH3VKAFinBbAHQrbCjd5IKeKcG3mmAd1pgmA7MFgTeRRx5pwfeGYB3RuCdifwzJ5gtBLyLGu6l/HoPFdZ3EX0X9eylYuq7uDol1ClpuJeygG5ZQbdsoFt20CIHmC0OupVy9E5yAu9cwDs38M4DDPOC2RLAu7Qj73zAOz/wLgC8C5JdA2ZLAu8yhnupmN5DpfRdWt9lPHuprPoup055dSoY7qXCoFsR0K0o6FaM7BowWw50q+jonZQA3iWBdyngXRoYlgGz5YF3JUfeZYF3OeBdHnhXAIYVwWwF4F3ZcC+V1Xuoor4r6buyZy9VUd9V1ammTnXDvVQJdKsMulUB3aqCFtXAbFXQrYajd1IdeNcA3jWBdy1gWJu0Ad41HXnXAd51gXc94F0fGDYAs9WBdy3DvVRF76Ea+q6p71qevVRbfddRp6469Qz3UkPQrRHo1hh0awJaNAWzdUC3+o7eSTPg3Rx4twDeLYFhKzBbF3g3cOTdGni3Ad5tgXc7YNgezNYD3g0N91JtvYfq67uBvht69lIj9d1YnSbqNDXcSx1At46gWyfQrTNo0QXMNgbdmjl6J12Bdzfg3R149wCGPcFsE+Dd3JF3L+DdG3j3Ad59gWE/8vdo4N3CcC810nuomb6b67uFZy+1VN+t1GmtThvDvdQfdBsAug0E3QaBFoPJ3+tBt7aO3skQ4D0UeA8D3sOB4Qgw2xp4t3PkPRJ4jwLeo4H3GGA4Fsy2Ad7tDfdSS72H2uq7nb7be/ZSB/XdUZ1O6nQ23EvjQLfxoNsE0G0iaDEJzHYE3bo4eieTgfcU4D0VeE8DhtPBbCfg3dWR9wzgPRN4zwLes4HhHDDbGXh3M9xLHfQe6qLvrvru5tlL3dV3D3V6qtPLcC/NBd3mgW7zQbcFoMVCMNsDdOvt6J0sAt6LgfcS4L0UGC4j/50PePdx5L0ceK8A3iuB9ypguBrM9gLefQ33Une9h3rru4+++3r2Uj/13V+dAeoMNNxLa0C3taDbOtBtPWixAcz2B90GOXonG4H3JuC9GXhvAYZbwewA4D3Ykfc24L0deO8A3juB4S4wOxB4DzHcS/30Hhqk78H6HuLZS0PV9zB1hqszwnAv7Qbd9oBue0G3faDFfjA7DHQb6eidHADeB4H3IeB9GBgeAbPDgfcoR95Hgfcx4H0ceJ8AhifJr/0B79GGe2mo3kMj9T1K36M9e2mM+h6rzjh1xhvupVOg22nQ7Qzodha0OEd+DRF0m+DonZwH3heA90XgfQkYXgaz44D3REfeV4D3VeB9DXhfB4Y3wOx44D3JcC+N0Xtogr4n6nuSZy9NVt9T1JmqzjTDvXQTdLsFut0G3e6AFnfB7BTQbbqjd3IPeN8H3g+A90Ng+AjMTgXeMxx5PwbeT4D3U+D9DBg+B7PTgPdMw700We+h6fqeoe+Znr00S33PVmeOOnMN99IL0O0l6PYKdHsNWrwBs7NBt3mO3slb4P0OeL8H3h+A4Ufy75KA93xH3p+A92fg/QV4fwWG38DsXOC9wHAvzdJ7aJ6+5+t7gWcvLVTfi9RZrM4Sw730HXT7Abr9BN1+gRZ/gdlFoNtSR+/kN/D2RfDf+48I/nsHiOC/YUAwuxh4L3Pk/WcE/70DAe/AwDsIMAwKZpcA7+WGe2mh3kNL9b1M38s9e2mF+l6pzip1VhvupWCgW3DQLQToFhK0CAVmV4Juaxy9k9DAOwzwDgu8wwHD8GB2FfBe68g7AvCOCLwjAe/IwDAKmF0NvNcZ7qUVeg+t0fdafa/z7KX16nuDOhvV2WS4l6KCbtFAt+igWwzQIiaY3QC6bXb0TmIB79jAOw7wjgsM44HZjcB7iyPv+MA7AfBOCLwTAcPEYHYT8N5quJfW6z20Wd9b9L3Vs5e2qe/t6uxQZ6fhXkoCuiUF3ZKBbslBixRgdjvotsvRO0kJvFMB79TAOw0wTAtmdwDv3Y680wHv9MA7A/DOCAwzgdmdwHuP4V7apvfQLn3v1vcez17aq773qbNfnQOGeykz6JYFdMsKumUDLbKD2X2g20FH7yQH8M4JvHMB79zAMA+Y3Q+8Dznyzgu88wHv/MC7ADAsCGYPAO/Dhntpr95DB/V9SN+HPXvpiPo+qs4xdY4b7qVCoFth0K0I6FYUtCgGZo+CbiccvZPiwLsE8C4JvEsBw9Jg9hjwPunIuwzwLgu8ywHv8sCwApg9DrxPGe6lI3oPndD3SX2f8uyl0+r7jDpn1TlnuJcqgm6VQLfKoFsV0KIqmD0Dup139E6qAe/qwLsG8K4JDGuB2bPA+4Ij79rAuw7wrgu86wHD+mD2HPC+aLiXTus9dF7fF/R90bOXLqnvy+pcUeeq4V5qALo1BN0agW6NQYsmYPYy6HbN0TtpCrybAe/mwLsFMGwJZq8A7+uOvFsB79bAuw3wbgsM24HZq8D7huFeuqT30DV9X9f3Dc9euqm+b6lzW507hnupPejWAXTrCLp1Ai06g9lboNtdR++kC/DuCry7Ae/uwLAHmL0NvO858u4JvHsB797Auw8w7Atm7wDv+4Z76abeQ3f1fU/f9z176YH6fqjOI3UeG+6lfqBbf9BtAOg2ELQYBGYfgm5PHL2TwcB7CPAeCryHAcPhYPYR8H7qyHsE8B4JvEcB79HAcAyYfQy8nxnupQd6Dz3R91N9P/Pspefq+4U6L9V5ZbiXxoJu40C38aDbBNBiIph9Abq9dvROJgHvycB7CvCeCgyngdmXwPuNI+/pwHsG8J4JvGcBw9lg9hXwfmu4l57rPfRa32/0/dazl96p7/fqfFDno+FemgO6zQXd5oFu80GLBWD2Pej2ydE7WQi8FwHvxcB7CTBcCmY/AO/PjryXAe/lwHsF8F4JDFeB2Y/A+4vhXnqn99AnfX/W9xfPXvqqvr+p812dH4Z7aTXotgZ0Wwu6rQMt1oPZb6DbT0fvZAPw3gi8NwHvzcBwC5j9Drx/OfLeCry3Ae/twHsHMNwJZn8A778M99JXvYd+6vuXvv/y7KXff++isur/XZ0AZf/zD5Z22wW67Qbd9oBue0GLfWD2b6N/z/5Tt4Bl3byT/cD7APA+CLwPAcPDYPYP4P2nI+8jwPso8D4GvI8DwxNgNgDwDgS8/9te+q330N/v5O/7T33//Z/777nA6juIOkHVCWa4l06CbqdAt9Og2xnyv5EBs0FAt+CO3sk54H0eeF8A3heB4SUwGxR4h3DkfRl4XwHeV4H3NWB4HcwGA94hDfdSYL2Hgus7hL5DevZSKPUdWp0w6oQ13Es3QLeboNst0O02+XejYDY06BbO0Tu5C7zvAe/7wPsB+XeaYDYM8A7vyPsR8H4MvJ8A76fA8BmYDQu8IxjupVB6D4XTd3h9R/DspYjqO5I6kdWJYriXnoNuL0C3l6DbK9DiNZiNBLpFdfRO3gDvt8D7HfB+T34tG8xGBt7RHHl/BN6fgPdn4P0FGH4Fs1GAd3TDvRRR76Go+o6m7+ievRRDfcdUJ5Y6sQ330jfQ7Tvo9gN0+wla/AKzMUG3OMJ3Ekjfcf/P79v3P377C3j/Bt6+iP67xAIucR3tjz8i+u8SIKL/LgEj+v/X4Z/AMBCYjQ284xnujxh6X8TRd1x9x/Psj/jqO4E6CdVJZLg/AoNuQUC3oKBbMNAiOJhNALoldvROQgDvkMA7FPAODQzDgNmEwDuJI++wwDsc8A4PvCMAw4hgNhHwTmq4l+LrPZRY30n0ndSzl5Kp7+TqpFAnpeFeigS6RQbdooBuUUGLaGA2OeiWytE7iQ68YwDvmMA7Fvl7MphNAbxTO/KOA7zjAu94wDs++XspmE0JvNMY7qVkeg+l0ndqfafx7KW06judOunVyWC4lxKCbolAt8SgWxLQIimYTQe6ZXT0TpIB7+TAOwXwTgkMU4HZ9MA7kyPv1MA7DfBOC7zTEUMwmwF4ZzbcS2n1Hsqo70z6zuzZS1nUd1Z1sqmT3XAvZQDdMoJumUC3zKBFFjCbFXTL4eidZAXe2YB3duCdAxjmBLPZgHdOR965gHdu4J0HeOcFhvnAbHbgnctwL2XReyiHvnPqO5dnL+VW33nUyatOPsO9lB90KwC6FQTdCoEWhcFsHtAtv6N3UgR4FwXexYB3cWBYAszmBd4FHHmXBN6lgHdp4F0GGJYlOwx4FzTcS7n1Hsqv7wL6LujZS4XUd2F1iqhT1HAvlQPdyoNuFUC3iqBFJbLDQLdijt5JZeBdBXhXBd7VgGF1MFsEeBd35F0DeNcE3rWAd21gWAfMFgXeJQz3UiG9h4rpu7i+S3j2Ukn1XUqd0uqUMdxLdUG3eqBbfdCtAWjREMyWAt3KOnonjYB3Y+DdBHg3BYbNwGxp4F3OkXdz4N0CeLcE3q2AYWswWwZ4lzfcSyX1Hiqr73L6Lu/ZSxXUd0V1KqlT2XAvtQHd2oJu7UC39qBFBzBbEXSr4uiddATenYB3Z+DdBRh2Jf8sC7yrOvLuBry7A+8ewLsnMOwFZisD72qGe6mC3kNV9F1V39U8e6m6+q6hTk11ahnupd6gWx/QrS/o1g+06A9ma4ButR29kwHAeyDwHgS8BwPDIWC2JvCu48h7KPAeBryHA+8RwHAkmK0FvOsa7qXqeg/V1ncdfdf17KV66ru+Og3UaWi4l0aBbqNBtzGg21jQYhyYrQ+6NXL0TsYD7wnAeyLwngQMJ4PZBsC7sSPvKcB7KvCeBrynA8MZ5Nc0gHcTw71UT++hRvpurO8mnr3UVH03U6e5Oi0M99JM0G0W6DYbdJsDWswlvzYCurV09E7mAe/5wHsB8F4IDBeB2ebAu5Uj78XAewnwXgq8lwHD5WC2BfBubbiXmuo91FLfrfTd2rOX2qjvtuq0U6e94V5aAbqtBN1WgW6rQYs1YLYt6NbB0TtZC7zXAe/1wHsDMNwIZtsB746OvDcB783Aewvw3goMt4HZ9sC7k+FeaqP3UAd9d9R3J89e6qy+u6jTVZ1uhntpO+i2A3TbCbrtAi12g9kuoFt3R+9kD/DeC7z3Ae/9wPAA+TVy4N3DkfdB4H0IeB8G3keA4VEw2w149zTcS531Huqu7x767unZS73Ud291+qjT13AvHQPdjoNuJ0C3k6DFKTDbG3Tr5+idnAbeZ4D3WeB9DhieB7N9gHd/R94XgPdF4H0JeF8GhlfAbF/gPcBwL/XSe6ifvvvre4BnLw1U34PUGazOEMO9dBV0uwa6XQfdboAWN8HsINBtqKN3cgt43wbed4D3XWB4D8wOBt7DHHnfB94PgPdD4P0IGD4m/64UeA833EsD9R4aqu9h+h7u2Usj1PdIdUapM9pwLz0B3Z6Cbs9At+egxQvy71xBtzGO3slL4P0KeL8G3m+A4VswOwp4j3Xk/Q54vwfeH4D3R2D4CcyOBt7jDPfSCL2Hxuh7rL7HefbSePU9QZ2J6kwy3EufQbcvoNtX0O0baPEdzE4A3SY7eic/gPdP4P0LeP8FDH+D2YnAe4ojb18k/73/iOS/d4BI/nsHjOS/4Z9gdhLwnmq4l8brPTRZ31P0PdWzl6ap7+nqzFBnpuFeCgS6BQbdgoBuQUGLYGB2Oug2y9E7CQ68QwDvkMA7FDAMDWZnAO/ZjrzDAO+wwDsc8A4PDCOA2ZnAe47hXpqm99Asfc/W9xzPXpqrvuepM1+dBYZ7KSLoFgl0iwy6RQEtooLZeaDbQkfvJBrwjg68YwDvmMAwFpidD7wXOfKODbzjAO+4wDseMIwPZhcA78WGe2mu3kML9b1I34s9e2mJ+l6qzjJ1lhvupQSgW0LQLRHolhi0SAJml4JuKxy9k6TAOxnwTg68UwDDlGB2GfBe6cg7FfBODbzTAO+0wDAdmF0OvFcZ7qUleg+t0PdKfa/y7KXV6nuNOmvVWWe4l9KDbhlAt4ygWybQIjOYXQO6rXf0TrIA76zAOxvwzg4Mc4DZtcB7gyPvnMA7F/DODbzzAMO8YHYd8N5ouJdW6z20Xt8b9L3Rs5c2qe/N6mxRZ6vhXsoHuuUH3QqAbgVBi0JgdjPots3ROykMvIsA76LAuxgwLA5mtwDv7Y68SwDvksC7FPAuDQzLgNmtwHuH4V7apPfQNn1v1/cOz17aqb53qbNbnT2Ge6ks6FYOdCsPulUALSqC2V2g215H76QS8K4MvKsA76rAsBqY3Q289znyrg68awDvmsC7FjCsDWb3AO/9hntpp95De/W9T9/7PXvpgPo+qM4hdQ4b7qU6oFtd0K0e6FYftGgAZg+CbkccvZOGwLsR8G4MvJsAw6Zg9hDwPurIuxnwbg68WwDvlsCwFZg9DLyPGe6lA3oPHdH3UX0f8+yl4+r7hDon1TlluJdag25tQLe2oFs70KI9mD0Bup129E46AO+OwLsT8O4MDLuA2ZPA+4wj767Auxvw7g68ewDDnmD2FPA+a7iXjus9dFrfZ/R91rOXzqnv8+pcUOei4V7qBbr1Bt36gG59QYt+YPY86HbJ0TvpD7wHAO+BwHsQMBwMZi8A78uOvIcA76HAexjwHg4MR4DZi8D7iuFeOqf30CV9X9b3Fc9euqq+r6lzXZ0bhntpJOg2CnQbDbqNAS3GgtlroNtNR+9kHPAeD7wnAO+JwHASmL0OvG858p4MvKcA76nAexownA5mbwDv24Z76areQzf1fUvftz176Y76vqvOPXXuG+6lGaDbTNBtFug2G7SYA2bvgm4PHL2TucB7HvCeD7wXAMOFYPYe8H7oyHsR8F4MvJcA76XAcBmYvQ+8HxnupTt6Dz3Q90N9P/Lspcfq+4k6T9V5ZriXloNuK0C3laDbKtBiNZh9Aro9d/RO1gDvtcB7HfBeDww3gNmnwPuFI++NwHsT8N4MvLeQf/cPZp8B75eGe+mx3kPP9f1C3y89e+mV+n6tzht13hrupW2g23bQbQfotpP8u38w+xp0e+fonewG3nuA917gvQ8Y7gezb4D3e0feB4D3QeB9CHgfBoZHwOxb4P3BcC+90nvonb7f6/uDZy99VN+f1PmszhfDvXQUdDsGuh0H3U6Qf+cDZj+Bbl8dvZNTwPs08D4DvM8Cw3Ng9jPw/ubI+zzwvgC8LwLvS8DwMpj9Ary/G+6lj3oPfdX3N31/9+ylH+r7pzq/1PnLcC9dAd2ugm7XQLfr5Nf6wOxP0O23o3dyE3jfAt63gfcd8mt0YPYX8PaVc+N9D3jfB94PgPdDYPgIzP4FvP8A3v9tL/3Qe+i3vv/u94f+z/33XAD1HfDv/7s6gcr95x8s7fYYdHsCuj0F3Z6BFs/BbMBy/ncL7OidvADeL4H3K+D9mvx3MzD7J/AO4sj7LfB+B7zfA+8PwPAjmA0EvIMa7qUAeg8F1ncQfQf17KVg6ju4OiHUCWm4lz6Bbp9Bty+g21fQ4huYDQ66hXL0Tr4D7x/A+yfw/kX+ngxmQwDv0I68fwNvX2T/vf+I7L93gMj+GwYEsyGBdxjDvRRM76FQ+g6t7zCevRRWfYdTJ7w6EQz30p+R/e8WCHQLDLoFAS2CgtlwoFtER+8kGPAODrxDAO+QwDAUmA0PvCM58g4NvMMA77DAOxwxBLMRgHdkw70UVu+hiPqOpO/Inr0URX1HVSeaOtEN91IE0C0i6BYJdIsMWkQBs1FBtxiO3klU4B0NeEcH3jGAYUwwGw14x3TkHQt4xwbecYB3XGAYD8xGB96xDPdSFL2HYug7pr5jefZSbPUd5+/fjzrxDPdSfNAtAeiWEHRLBFokBrNxQLf4jt5JEuCdFHgnA97JgWEKMBsXeCdw5J0SeKcC3qmBdxpgmJbsMOCd0HAvxdZ7KL6+E+g7oWcvJVLfidVJok5Sw72UDnRLD7plAN0yghaZyA4D3ZI5eieZgXcW4J0VeGcDhtnBbBLgndyRdw7gnRN45wLeuYFhHjCbFHinMNxLifQeSqbv5PpO4dlLKdV3KnVSq5PGcC/lBd3ygW75QbcCoEVBMJsKdEvr6J0UAt6FgXcR4F0UGBYDs6mBdzpH3sWBdwngXRJ4lwKGpcFsGuCd3nAvpdR7KK2+0+k7vWcvZVDfGdXJpE5mw71UBnQrC7qVA93KgxYVwGxG0C2Lo3dSEXhXAt6VgXcVYFiV/LMs8M7qyLsa8K4OvGsA75rAsBaYzQy8sxnupQx6D2XRd1Z9Z/PspezqO4c6OdXJZbiXaoNudUC3uqBbPdCiPpjNAbrldvROGgDvhsC7EfBuDAybgNmcwDuPI++mwLsZ8G4OvFsAw5ZgNhfwzmu4l7LrPZRb33n0ndezl/Kp7/zqFFCnoOFeagW6tQbd2oBubUGLdmA2P+hWyNE7aQ+8OwDvjsC7EzDsDGYLAO/Cjry7AO+uwLsb8O4ODHuQX9MA3kUM91I+vYcK6buwvot49lJR9V1MneLqlDDcSz1Bt16gW2/QrQ9o0Zf82gjoVtLRO+kHvPsD7wHAeyAwHARmiwPvUo68BwPvIcB7KPAeBgyHg9kSwLu04V4qqvdQSX2X0ndpz14qo77LqlNOnfKGe2kE6DYSdBsFuo0GLcaA2bKgWwVH72Qs8B4HvMcD7wnAcCKYLQe8KzryngS8JwPvKcB7KjCcBmbLA+9KhnupjN5DFfRdUd+VPHupsvquok5VdaoZ7qXpoNsM0G0m6DYLtJgNZquAbtUdvZM5wHsu8J4HvOcDwwXk18iBdw1H3guB9yLgvRh4LwGGS8FsNeBd03AvVdZ7qLq+a+i7pmcv1VLftdWpo05dw720DHRbDrqtAN1WgharwGxt0K2eo3eyGnivAd5rgfc6YLgezNYB3vUdeW8A3huB9ybgvRkYbgGzdYF3A8O9VEvvoXr6rq/vBp691FB9N1KnsTpNDPfSVtBtG+i2HXTbAVrsBLONQLemjt7JLuC9G3jvAd57geE+MNsYeDdz5L0feB8A3geB9yFgeJj8u1Lg3dxwLzXUe6ipvpvpu7lnL7VQ3y3VaaVOa8O9dAR0Owq6HQPdjoMWJ8i/cwXd2jh6JyeB9yngfRp4nwGGZ8FsK+Dd1pH3OeB9HnhfAN4XgeElMNsaeLcz3Est9B5qo++2+m7n2Uvt1XcHdTqq08lwL10G3a6AbldBt2ugxXUw2wF06+zondwA3jeB9y3gfRsY3gGzHYF3F0fed4H3PeB9H3g/AIYPwWwn4N3VcC+113uos7676LurZy91U9/d1emhTk/DvfQIdHsMuj0B3Z6CFs/AbHfQrZejd/IceL8A3i+B9ytg+Jr8b2+Ad29H3m+A91vg/Q54vweGH8BsT+Ddx3AvddN7qJe+e+u7j2cv9VXf/dTpr84Aw730EXT7BLp9Bt2+gBZfwWw/0G2go3fyDXh/B94/gPdPYPgLzPYH3oMcef8FvH8Db18U/73/iOK/YQAwOwB4DzbcS331Hhqo70H6HuzZS0PU91B1hqkz3HAvBYzif7c/o/jfLRDoFhi0CAJmh4JuIxy9k6DAOxjwDg68QwDDkGB2GPAe6cg7FPAODbzDAO+wwDAcmB0OvEcZ7qUheg+N0PdIfY/y7KXR6nuMOmPVGWe4l8KDbhFAt4igWyTQIjKYHQO6jXf0TqIA76jAOxrwjg4MY4DZscB7giPvmMA7FvCODbzjAMO4YHYc8J5ouJdG6z00Xt8T9D3Rs5cmqe/J6kxRZ6rhXooHusUH3RKAbglBi0RgdjLoNs3RO0kMvJMA76TAOxkwTA5mpwDv6Y68UwDvlMA7FfBODQzTgNmpwHuG4V6apPfQNH1P1/cMz16aqb5nqTNbnTmGeykt6JYOdEsPumUALTKC2Vmg21xH7yQT8M4MvLMA76zAMBuYnQ285znyzg68cwDvnMA7FzDMDWbnAO/5hntppt5Dc/U9T9/zPXtpgfpeqM4idRYb7qU8oFte0C0f6JYftCgAZheCbkscvZOCwLsQ8C4MvIsAw6JgdhHwXurIuxjwLg68SwDvksCwFJhdDLyXGe6lBXoPLdH3Un0v8+yl5ep7hTor1VlluJdKg25lQLeyoFs50KI8mF0Buq129E4qAO+KwLsS8K4MDKuA2ZXAe40j76rAuxrwrg68awDDmmB2FfBea7iXlus9tFrfa/S91rOX1qnv9epsUGej4V6qBbrVBt3qgG51QYt6YHY96LbJ0TupD7wbAO+GwLsRMGwMZjcA782OvJsA76bAuxnwbg4MW4DZjcB7i+FeWqf30CZ9b9b3Fs9e2qq+t6mzXZ0dhnupJejWCnRrDbq1AS3agtltoNtOR++kHfBuD7w7AO+OwLATmN0OvHc58u4MvLsA767Auxsw7A5mdwDv3YZ7aaveQzv1vUvfuz17aY/63qvOPnX2G+6lHqBbT9CtF+jWG7ToA2b3gm4HHL2TvsC7H/DuD7wHAMOBYHYf8D7oyHsQ8B4MvIcA76HAcBiY3Q+8DxnupT16Dx3Q90F9H/LspcPq+4g6R9U5ZriXhoNuI0C3kaDbKNBiNJg9Arodd/ROxgDvscB7HPAeDwwngNmjwPuEI++JwHsS8J4MvKeQf/cPZo8B75OGe+mw3kPH9X1C3yc9e+mU+j6tzhl1zhrupWmg23TQbQboNpP8u38wexp0O+foncwG3nOA91zgPQ8YzgezZ4D3eUfeC4D3QuC9CHgvBoZLwOxZ4H3BcC+d0nvonL7P6/uCZy9dVN+X1LmszhXDvbQUdFsGui0H3VaQf+cDZi+BblcdvZNVwHs18F4DvNcCw3Vg9jLwvubIez3w3gC8NwLvTcBwM5i9AryvG+6li3oPXdX3NX1f9+ylG+r7pjq31LltuJe2gG5bQbdtoNt28mt9YPYm6HbH0TvZCbx3Ae/dwHsP+TU6MHsLeN915L0PeO8H3geA90FgeAjM3gbe9wz30g29h+7o+66+73n20n31/UCdh+o8MtxLh0G3I6DbUdDtGGhxHMw+AN0eO3onJ4D3SeB9CnifJv/dDMw+BN5PHHmfBd7ngPd54H0BGF4Es4+A91PDvXRf76HH+n6i76eevfRMfT9X54U6Lw330iXQ7TLodgV0uwpaXAOzz0G3V47eyXXgfQN43wTet8jfk8HsC+D92pH3HeB9F3jfA973yd9LwexL4P3GcC8903volb5f6/uNZy+9Vd/v1HmvzgfDvfQQdHsEuj0G3Z6AFk/B7DvQ7aOjd/IMeD8H3i+A90tg+ArMvgfenxx5vwbeb4D3W+D9jhiC2Q/A+7PhXnqr99BHfX/S92fPXvqivr+q802d74Z76QPo9hF0+wS6fQYtvoDZr6DbD0fv5Cvw/ga8vwPvH8DwJ5j9Brx/Cr0D6Tvu//l9+/7Hb7+A91/A+zdw+Q5cfhnujy96X/zQ9099//Lsj7/U9++/90Z59f+t/H/+wQbVd9z//FPw/c/fov5Xh//6A39E/d9m//cHAkT9B1/PDwT8p1nPD/zp1+y/fiAQmP0NGgco//9q/D//D+9vtE1g0CYIaBMUtAkG2gQH3iHArK+8/20COmoTErQJBdqEBm3CgDZhgXc4MPsHaPMnaPPfduNfehf+/f7+vgPq++//3H/PBVLfgdUJok5Qw90YHjSOABpHBI0jgcaRQbcoYDYwaBzM0fuLCtpEA22igzYxQJuYwDsWmA0C2gR31CY2aBMHtIkL2sQDbeID7wRgNihoE8JwNwbSuzCYvoPrO4RnN4ZU36HUCa1OGMPdmBA0TgQaJwaNk4DGSUG3ZGA2FGgc1tH7Sw7apABtUoI2qUCb1MA7DZgNDdqEc9QmLWiTDrRJD9pkAG0yAu9MYDYMaBPecDeG1LswrL7D6Tu8ZzdGUN8R1YmkTmTD3ZgZNM4CGmcFjbOBxtlBtxxgNiJoHMXR+8sJ2uQCbXKDNnlAm7zAOx+YjQTaRHXUJj9oUwC0KQjaFAJtCgPvImA2MmgTzXA3RtC7MIq+o+o7mmc3RlffMdSJqU4sw91YFDQuBhoXB41LgMYlQbdSYDYGaBzb0fsrDdqUAW3KgjblQJvywLsCmI0J2sRx1KYiaFMJtKkM2lQBbaoC72rk10ZAm7iGuzG63oWx9R1H33E9uzGe+o6vTgJ1EhruxuqgcQ3QuCZoXAs0rg261QGz8UHjRI7eX13Qph5oUx+0aQDaNATejcivf4E2iR21aQzaNAFtmoI2zUCb5sC7BZhNCNokMdyN8fQuTKTvxPpO4tmNSdV3MnWSq5PCcDe2BI1bgcatQeM2oHFb0K0d+bVJ0Dilo/fXHrTpANp0BG06gTadgXcXMJsctEnlqE1X0KYbaNMdtOkB2vQE3r3AbArQJrXhbkyqd2FKfafSd2rPbkyjvtOqk06d9Ia7sTdo3Ac07gsa9wON+4NuA8BsWtA4g6P3NxC0GQTaDAZthoA2Q4H3MDCbDrTJ6KjNcNBmBGgzErQZBdqMBt5jwGx60CaT4W5Mo3dhBn1n1Hcmz27MrL6zqJNVnWyGu3EsaDwONB4PGk8AjSeCbpPAbBbQOLuj9zcZtJkC2kwFbaaBNtOB9wwwmxW0yeGozUzQZhZoMxu0mQPazAXe88BsNtAmp+FuzKx3YXZ959B3Ts9uzKW+c6uTR528hrtxPmi8ADReCBovAo0Xg25LwGxu0Difo/e3FLRZBtosB21WgDYrgfcqMJsHtMnvqM1q0GYNaLMWtFkH2qwH3hvAbF7QpoDhbsyld2E+fefXdwHPbiyovgupU1idIoa7cSNovAk03gwabwGNt4Ju28BsIdC4qKP3tx202QHa7ARtdoE2u4H3HjBbGLQp5qjNXtBmH2izH7Q5ANocBN6HyP/eB7QpbrgbC+pdWFTfxfRd3LMbS6jvkuqUUqe04W48DBofAY2PgsbHQOPjoNsJMFsSNC7j6P2dBG1OgTanQZszoM1Z4H0OzJYCbco6anMetLkA2lwEbS6BNpeB9xUwWxq0KWe4G0voXVhG32X1Xc6zG8ur7wrqVFSnkuFuvAoaXwONr4PGN0Djm6DbLTBbATSu7Oj93QZt7oA2d0Gbe6DNfeD9AMxWBG2qOGrzELR5BNo8Bm2egDZPgfczMFsJtKlquBvL611YWd9V9F3Vsxurqe/q6tRQp6bhbnwOGr8AjV+Cxq9A49eg2xswWx00ruXo/b0Fbd6BNu9Bmw+gzUfg/QnM1gBtajtq8xm0+QLafAVtvoE234H3DzBbE7SpY7gbq+ldWEvftfVdx7Mb66rveurUV6eB4W78CRr/Ao3/Ao1/g8a+aP53+wPM1gONGzp6fwGi+d8mYDT/2/wZzf82gaL53yYw8A4CZuuDNo0ctQkK2gQDbYKDNiFAm5DAOxSYbQDaNDbcjXX1Lmyo70b6buzZjU3Ud1N1mqnT3HA3hgaNw4DGYUHjcKBxeNAtAphtChq3cPT+IoI2kUCbyKBNFNAmKvCOBmabgTYtHbWJDtrEAG1igjaxQJvYwDsOmG0O2rQy3I1N9C5soe+W+m7l2Y2t1Xcbddqq085wN8YFjeOBxvFB4wSgcULQLRGYbQMat3f0/hKDNklAm6SgTTLQJjnwTgFm24I2HRy1SQnapAJtUoM2aUCbtMA7HZhtB9p0NNyNrfUubK/vDvru6NmNndR3Z3W6qNPVcDemB40zgMYZQeNMoHFm0C0LmO0MGndz9P6ygjbZQJvsoE0O0CYn8M4FZruANt0dtckN2uQBbfKCNvlAm/zAuwCY7Qra9DDcjZ30Luym7+767uHZjT3Vdy91eqvTx3A3FgSNC4HGhUHjIqBxUdCtGJjtBRr3dfT+ioM2JUCbkqBNKdCmNPAuA2Z7gzb9HLUpC9qUA23KgzYVQJuKwLsSmO0D2vQ33I099S7sq+9++u7v2Y0D1PdAdQapM9hwN1YGjauAxlVB42qgcXXQrQaYHQgaD3H0/mqCNrVAm9qgTR3Qpi75d19gdhBoM9RRm/qgTQPQpiFo0wi0aQy8m4DZwaDNMMPdOEDvwiH6HqrvYZ7dOFx9j1BnpDqjDHdjU9C4GWjcHDRuARq3BN1agdkRoPFoR++vNWjTBrRpC9q0A23aA+8OYHYkaDPGUZuOoE0n0KYzaNMFtOkKvLuB2VGgzVjD3Thc78LR+h6j77Ge3ThOfY9XZ4I6Ew13Y3fQuAdo3BM07gUa9yb/vA9mx4PGkxy9v76gTT/Qpj9oMwC0GUj+WRDMTgBtJjtqMxi0GQLaDAVthoE2w8k/J4DZiaDNFMPdOE7vwkn6nqzvKZ7dOFV9T1NnujozDHfjSNB4FGg8GjQeAxqPBd3GgdlpoPFMR+9vPGgzAbSZCNpMAm0mA+8pYHY6aDPLUZupoM000GY6aDMDtJkJvGeB2RmgzWzD3ThV78KZ+p6l79me3ThHfc9VZ5468w1342zQeA5oPBc0ngcazwfdFoDZuaDxAkfvbyFoswi0WQzaLAFtlgLvZWB2Hmiz0FGb5aDNCtBmJWizCrRZDbzXgNn5oM0iw904R+/CBfpeqO9Fnt24WH0vUWepOssMd+Na0HgdaLweNN4AGm8E3TaB2SWg8XJH728zaLMFtNkK2mwDbbYD7x1gdilos8JRm52gzS7QZjdoswe02Qu895G/x4E2Kw1342K9C5fre4W+V3p24yr1vVqdNeqsNdyN+0HjA6DxQdD4EGh8GHQ7AmZXg8brHL2/o6DNMdDmOGhzArQ5CbxPkX+OAW3WO2pzGrQ5A9qcBW3OgTbngfcFMLsWtNlguBtX6V24Tt/r9b3Bsxs3qu9N6mxWZ4vhbrwIGl8CjS+DxldA46ug2zXyz5ig8VZH7+86aHMDtLkJ2twCbW4D7ztgdjNos81Rm7ugzT3Q5j5o8wC0eQi8H4HZLaDNdsPduFHvwq363qbv7Z7duEN971Rnlzq7DXfjY9D4CWj8FDR+Bho/B91egNmdoPEeR+/vJWjzCrR5Ddq8AW3eAu93YHYXaLPXUZv3oM0H0OYjaPMJtPkMvL+A2d2gzT7D3bhD78I9+t6r732e3bhffR9Q56A6hwx341fQ+Bto/B00/gEa/wTdfoHZA6DxYeH7C6jvuP/5u/b9r9/+An/8B8Ef/xFH++M3+GvLF93/v7b+iO7/X1sBovv/11bA6P57/wlmD4E2Rw33x369Lw7r+4i+j3r2xzH1fVydE+qcNNwfgaL73zgwaBwENA4KGgcD3YKD2eOg8SlH7y8EaBMStAkF2oQGbcIA77Bg9gRoc9pRm3CgTXjQJgJoExG0iQS8I4PZk6DNGcPdeEzvwlP6Pq3vM57deFZ9n1PnvDoXDHdjFNA4KmgcDTSODhrHAN1igtlzoPFFR+8vFmgTG7SJA9rEBW3iAe/4YPY8aHPJUZsEoE1C0CYRaJMYtEkCvJOC2QugzWXD3XhW78KL+r6k78ue3XhFfV9V55o61w13YzLQODlonAI0TgkapwLdUoPZq6DxDUfvLw1okxa0SQfapAdtMgDvjGD2Gmhz01GbTKBNZtAmC2iTFbTJBryzg9nroM0tw914Re/CG/q+qe9bnt14W33fUeeuOvcMd2MO0DgnaJwLNM4NGucB3fKC2Tug8X1H7y8faJMftCkA2hQEbQoB78Jg9i5o88BRmyKgTVHQphhoUxy0KQG8S4LZe6DNQ8PdeFvvwvv6fqDvh57d+Eh9P1bniTpPDXdjKdC4NGhcBjQuCxqXA93Kg9nHoPEzR++vAmhTEbSpBNpUBm2qAO+qYPYJaPPcUZtqoE110KYGaFMTtKkFvGuD2aegzQvD3fhI78Jn+n6u7xee3fhSfb9S57U6bwx3Yx3QuC5oXA80rg8aNwDdGoLZV6DxW0fvrxFo0xi0aQLaNAVtmgHv5mD2NWjzzlGbFqBNS9CmFWjTGrRpA7zbgtk3oM17w934Uu/Ct/p+p+/3nt34QX1/VOeTOp8Nd2M70Lg9aNwBNO4IGncC3TqD2Y+g8RdH768LaNMVtOkG2nQHbXoA755g9hNo89VRm16gTW/Qpg9o0xe06Qe8+4PZz6DNN8Pd+EHvwi/6/qrvb57d+F19/1Dnpzq/DHfjANB4IGg8CDQeDBoPAd2GgtkfoPFfjt7fMNBmOGgzArQZCdqMAt6jwexP0Oa3ozZjQJuxoM040GY8aDMBeE8Es79AG18Fs934Xe/Cv/T9W99//+f+P3PqO4A6Af/+f6vwn3+wtPEk0HgyaDwFNJ4KGk8D3aaD2QAV/G8cCDT2/kbbzABtZoI2s0Cb2aDNHOA9F8wGBG0CO2ozD7SZD9osAG0WgjaLgPdiMPsnaBPEcDf+vff+vgPpO7C+g3h2Y1D1HUyd4OqEMNyNS0DjpaDxMtB4OWi8AnRbCWaDgcYhHb2/VaDNatBmDWizFrRZB7zXg9ngoE0oR202gDYbQZtNoM1m0GYL8N4KZkOANqENd2NQvQtD6juUvkN7dmMY9R1WnXDqhDfcjdtA4+2g8Q7QeCdovAt02w1mw4LGERy9vz2gzV7QZh9osx+0OQC8D4LZcKBNREdtDoE2h0GbI6DNUdDmGPA+DmbDgzaRDHdjGL0LI+g7or4jeXZjZPUdRZ2o6kQz3I0nQOOToPEp0Pg0aHwGdDsLZqOAxtEdvb9zoM150OYCaHMRtLkEvC+D2aigTQxHba6ANldBm2ugzXXQ5gbwvglmo4E2MQ13Y2S9C6PrO4a+Y3p2Yyz1HVudOH//vgx34y3Q+DZofAc0vgsa3wPd7oPZ2KBxPEfv7wFo8xC0eQTaPAZtngDvp2A2DmgT31GbZ6DNc9DmBWjzErR5Bbxfg9m4oE0Cw90YS+/CePqOr+8Ent2YUH0nUiexOkkMd+Mb0PgtaPwONH4PGn8A3T6C2USgcVJH7+8TaPMZtPkC2nwFbb4B7+9gNjFok8xRmx+gzU/Q5hdo8xdo8xt4+2L4P5sEtEluuBsT6l2YVN/J9J3csxtTqO+U6qRSJ7Xhbvwjhv+NA8Twv3HAGP43/jOG/40DgW6BwWxK0DiNo/cXBLQJCtoEA22CgzYhgHdIMJsKtEnrqE0o0CY0aBMGtAkL2oQD3uHBbGrQJp3hbkyhd2EafafVdzrPbkyvvjOok1GdTIa7MQJoHBE0jgQaRwaNo4BuUcFsBtA4s6P3Fw20iQ7axABtYoI2sYB3bDCbEbTJ4qhNHNAmLmgTD7SJD9okAN4JwWwm0Car4W5Mr3dhZn1n0XdWz27Mpr6zq5NDnZyGuzERaJwYNE4CGicFjZOBbsnBbHbQOJej95cCtEkJ2qQCbVKDNmmAd1owmwO0ye2oTTrQJj1okwG0yQjaZALemcFsTtAmj+FuzKZ3YS5959Z3Hs9uzKu+86mTX50ChrsxC2icFTTOBhpnB41zkG5gNh9oXNDR+8sF2uQGbfKANnlBm3zAOz+ZBW0KOWpTALQpCNoUAm0KgzZFgHdRMFsAtClsuBvz6l1YUN+F9F3YsxuLqO+i6hRTp7jhbiwGGhcHjUuAxiVB41KgW2ny1wNoXMLR+ysD2pQFbcqBNuVBmwrAuyKYLQbalHTUphJoUxm0qQLaVAVtqgHv6mC2OGhTynA3FtG7sIS+S+q7lGc3llbfZdQpq045w91YAzSuCRrXAo1rg8Z1QLe6YLYMaFze0furB9rUB20agDYNQZtGwLsxmC0L2lRw1KYJaNMUtGkG2jQHbVoA75ZgthxoU9FwN5bWu7C8vivou6JnN1ZS35XVqaJOVcPd2Ao0bg0atwGN24LG7UC39mC2MmhczdH76wDadARtOoE2nUGbLsC7K5itAtpUd9SmG2jTHbTpAdr0BG16Ae/eYLYqaFPDcDdW0ruwmr6r67uGZzfWVN+11KmtTh3D3dgHNO4LGvcDjfuDxgNAt4FgthZoXNfR+xsE2gwGbYaANkNBm2HAeziYrQ3a1HPUZgRoMxK0GQXajAZtxgDvsWC2DmhT33A31tS7sK6+6+m7vmc3NlDfDdVppE5jw904DjQeDxpPAI0ngsaTQLfJYLYhaNzE0fubAtpMBW2mgTbTQZsZwHsmmG0E2jR11GYWaDMbtJkD2swFbeYB7/nk10ZAm2aGu7GB3oVN9N1U3808u7G5+m6hTkt1WhnuxgWg8ULQeBFovBg0XgK6LQWzLUDj1o7e3zLQZjloswK0WQnarALeq8mvf4E2bRy1WQParAVt1oE260GbDcB7I5htBdq0NdyNzfUubK3vNvpu69mN7dR3e3U6qNPRcDduAo03g8ZbQOOtoPE20G07+bVJ0LiTo/e3A7TZCdrsAm12gzZ7gPdeMNsBtOnsqM0+0GY/aHMAtDkI2hwC3ofBbEfQpovhbmynd2EnfXfWdxfPbuyqvrup012dHoa78QhofBQ0PgYaHweNT4BuJ8FsN9C4p6P3dwq0OQ3anAFtzoI254D3eTDbHbTp5ajNBdDmImhzCbS5DNpcAd5XwWwP0Ka34W7sqndhT3330ndvz27so777qtNPnf6Gu/EaaHwdNL4BGt8EjW+BbrfBbF/QeICj93cHtLkL2twDbe6DNg+A90Mw2w+0GeiozSPQ5jFo8wS0eQraPAPez8Fsf9BmkOFu7KN34QB9D9T3IM9uHKy+h6gzVJ1hhrvxBWj8EjR+BRq/Bo3fgG5vwewQ0Hi4o/f3DrR5D9p8AG0+gjafgPdnMDsUtBnhqM0X0OYraPMNtPkO2vwA3j/B7DDQZqThbhysd+FwfY/Q90jPbhylvkerM0adsf9nNwbUd9z//FPw/a/ffgGH0cBhnKO/Rv8Cf43+Bn+N+mL6/9foHzF9fv81GiCm/94BwewY0Ga8ozZ/xvS/TaCY/rcJDNoEAW2CAu9gYHYsaDPBcH+M0vtinL7H63uCZ39MVN+T1JmszhTDf7YKDhqHAI1DgsahQOPQoFsYMDsJNJ7q6P2FBW3CgTbhQZsIoE1E4B0JzE4GbaY5ahMZtIkC2kQFbaKBNtGBdwwwOwW0mW64GyfqXThV39P0Pd2zG2eo75nqzFJntuFujAkaxwKNY4PGcUDjuKBbPDA7EzSe4+j9xQdtEoA2CUGbRKBNYuCdBMzOAm3mOmqTFLRJBtokB21SgDYpgXcqMDsbtJlnuBtn6F04R99z9T3Psxvnq+8F6ixUZ5HhbkwNGqcBjdOCxulA4/SgWwYwuwA0Xuzo/WUEbTKBNplBmyygTVbgnQ3MLgRtljhqkx20yQHa5ARtcoE2uYF3HjC7CLRZargb5+tduFjfS/S91LMbl6nv5eqsUGel4W7MCxrnA43zg8YFQOOCoFshMLscNF7l6P0VBm2KgDZFQZtioE1x4F0CzK4AbVY7alMStCkF2pQGbcqANmWBdzkwuxK0WWO4G5fpXbhK36v1vcazG9eq73XqrFdng+FuLA8aVwCNK4LGlUDjyqBbFTC7DjTe6Oj9VQVtqoE21UGbGqBNTeBdC8yuB202OWpTG7SpA9rUBW3qgTb1gXcDMLsBtNlsuBvX6l24Ud+b9L3Zsxu3qO+t6mxTZ7vhbmwIGjcCjRuDxk1A46agWzMwuxU03uHo/TUHbVqANi1Bm1agTWvg3QbMbgNtdjpq0xa0aQfatAdtOoA2HYF3JzC7HbTZZbgbt+hduEPfO/W9y7Mbd6vvPersVWef4W7sDBp3AY27gsbdQOPuoFsPMLsHNN7v6P31BG16gTa9QZs+oE1f4N0PzO4FbQ44atMftBkA2gwEbQaBNoOB9xAwuw+0OWi4G3frXbhf3wf0fdCzGw+p78PqHFHnqOFuHAoaDwONh4PGI0DjkaDbKDB7GDQ+5uj9jQZtxoA2Y0GbcaDNeOA9AcweAW2OO2ozEbSZBNpMBm2mgDZTgfc0MHsUtDlhuBsP6V14TN/H9X3CsxtPqu9T6pxW54zhbpwOGs8AjWeCxrNA49mg2xwwewo0Puvo/c0FbeaBNvNBmwWgzULy7zfB7GnQ5pyjNotBmyWgzVLQZhlos5z8uy8wewa0OW+4G0/qXXhW3+f0fd6zGy+o74vqXFLnsuFuXAkarwKNV4PGa0DjteTfr4DZi6DxFUfvbz1oswG02QjabAJtNgPvLWD2Emhz1VGbraDNNtBmO2izA7TZCbx3gdnLoM01w914Qe/CK/q+qu9rnt14XX3fUOemOrcMd+Nu0HgPaLwXNN4HGu8H3Q6A2Rug8W1H7+8gaHMItDkM2hwBbY4C72Ng9iZoc8dRm+OgzQnQ5iRocwq0OU3+WRDM3gJt7hruxut6F97W9x193/Xsxnvq+746D9R5aLgbz4LG50Dj86DxBdD4IvnnDTB7HzR+5Oj9XQZtroA2V0Gba6DNdfL3IjD7ALR57KjNTdDmFmhzG7S5A9rcBd73wOxD0OaJ4W68p3fhI30/1vcTz258qr6fqfNcnReGu/E+aPwANH4IGj8CjR+Dbk/A7DPQ+KWj9/cUtHkG2jwHbV6ANi+B9ysw+xy0eeWozWvQ5g1o8xa0eQfavAfeH8DsC9DmteFufKp34Ut9v9L3a89ufKO+36rzTp33hrvxI2j8CTT+DBp/AY2/gm7fwOxb0PiDo/f3HbT5Adr8BG1+gTZ/Ae/fYPYdaPPRURtfLP/b/BHL/zYBYvnfJmAs/9v8Gct/70Bg9j1o88lwN77Ru/CDvj/q+5NnN35W31/U+arON8PdGBg0DgIaBwWNg4HGwUG3EGD2C2j83dH7CwnahAJtQoM2YUCbsMA7HJj9Ctr8cNQmPGgTAbSJCNpEAm0iA+8oYPYbaPPTcDd+1rvwu75/6PunZzf+Ut9/qfP7771Y8T//YGnjqKBxNNA4OmgcAzSOCbrFArN/gcZ/VHTz/mKDNnFAm7igTTzQJj7wTgBmf4M2ARy1SQjaJAJtEoM2SUCbpMA7GZj1VfS/TUDQ5r/txl96F/79/v6+A+j77//cf8/9qb4DqRNYnSCGuzE5aJwCNE4JGqcCjVODbmnIf48AjYM6en9pQZt0oE160CYDaJMReGcCs4FBm2CO2mQGbbKANllBm2ygTXbgnQPMBgFtghvuxj/1Lgyq72D6Du7ZjSHUd0h1QqkT2nA35gSNc4HGuUHjPKBxXtAtH5gNCRqHcfT+8oM2BUCbgqBNIdCmMPAuAmZDgTZhHbUpCtoUA22KgzYlQJuSwLsUmA0N2oQz3I0h9C4Mo++w+g7n2Y3h1XcEdSKqE8lwN5YGjcuAxmVB43KgcXnQrQKYjQAaR3b0/iqCNpVAm8qgTRXQpirwrgZmI4I2URy1qQ7a1ABtaoI2tUCb2sC7DpiNBNpENdyN4fUujKzvKPqO6tmN0dR3dHViqBPTcDfWBY3rgcb1QeMGoHFD0K0RmI0OGsdy9P4agzZNQJumoE0z0KY58G4BZmOANrEdtWkJ2rQCbVqDNm1Am7bAux2YjQnaxDHcjdH0Loyl79j6juPZjXHVdzx14quTwHA3tgeNO4DGHUHjTqBxZ9CtC5iNBxondPT+uoI23UCb7qBND9CmJ/DuBWbjgzaJHLXpDdr0AW36gjb9QJv+wHsA+XdqoE1iw90YV+/ChPpOpO/Ent2YRH0nVSeZOskNd+NA0HgQaDwYNB4CGg8F3YaB2aSgcQpH7284aDMCtBkJ2owCbUYD7zHk35uCNikdtRkL2owDbcaDNhNAm4nAexKYTQ7apDLcjUn0Lkyh75T6TuXZjanVdxp10qqTznA3TgaNp4DGU0HjaaDxdNBtBvl32qBxekfvbyZoMwu0mQ3azAFt5gLveWA2LWiTwVGb+aDNAtBmIWizCLRZDLyXgNl0oE1Gw92YWu/C9PrOoO+Mnt2YSX1nVieLOlkNd+NS0HgZaLwcNF4BGq8E3VaB2cygcTZH7281aLMGtFkL2qwDbdYD7w1gNgtok91Rm42gzSbQZjNoswW02Qq8t4HZrKBNDsPdmEnvwmz6zq7vHJ7dmFN951Intzp5DHfjdtB4B2i8EzTeBRrvBt32gNlcoHFeR+9vL2izD7TZD9ocAG0OAu9DYDY3aJPPUZvDoM0R0OYoaHMMtDkOvE+A2TygTX7D3ZhT78K8+s6n7/ye3VhAfRdUp5A6hQ1340nQ+BRofBo0PgManwXdzoHZgqBxEUfv7zxocwG0uQjaXAJtLgPvK2C2EGhT1FGbq6DNNdDmOmhzA7S5CbxvgdnCoE0xw91YQO/CIvouqu9int1YXH2XUKekOqUMd+Nt0PgOaHwXNL4HGt8H3R6A2RKgcWlH7+8haPMItHkM2jwBbZ4C72dgtiRoU8ZRm+egzQvQ5iVo8wq0eQ2834DZUqBNWcPdWFzvwtL6LqPvsp7dWE59l1engjoVDXfjW9D4HWj8HjT+ABp/BN0+gdnyoHElR+/vM2jzBbT5Ctp8A22+A+8fYLYCaFNZ2Ob/+d/H/efv2ve/fvsJ2vwCf64VwZ9rFcNdU07vlkr6rqzvKp5dU1V9V1Onujo1DHfNX8DsN/jr2Rfb/7+e//inWc8PBPBr9l8/EBDMVgONazraNX/G9r9NoNj+twkM2gQBbYIC72BgtjpoU8tRm+CgTQjQJiRoEwq0CQ28w4DZGqBNbcPdWFXvwpr6rqXv2p7dWEd911Wnnjr1DXdjWNA4HGgcHjSOABpHBN0igdm6oHEDR+8vMmgTBbSJCtpEA22iA+8YYLYeaNPQUZuYoE0s0CY2aBMHtIkLvOOB2fqgTSPD3VhH78IG+m6o70ae3dhYfTdRp6k6zQx3Y3zQOAFonBA0TgQaJwbdkoDZJqBxc0fvLylokwy0SQ7apABtUgLvVGC2KWjTwlGb1KBNGtAmLWiTDrRJD7wzgNlmoE1Lw93YWO/C5vpuoe+Wnt3YSn23VqeNOm0Nd2NG0DgTaJwZNM4CGmcF3bKB2dagcTtH7y87aJMDtMkJ2uQCbXID7zxgtg1o095Rm7ygTT7QJj9oUwC0KQi8C4HZtqBNB8Pd2Ervwnb6bq/vDp7d2FF9d1KnszpdDHdjYdC4CGhcFDQuBhoXB91KgNlOoHFXR++vJGhTCrQpDdqUAW3KAu9yYLYzaNPNUZvyoE0F0KYiaFMJtKkMvKuA2S6gTXfD3dhR78Ku+u6m7+6e3dhDffdUp5c6vQ13Y1XQuBpoXB00rgEa1wTdaoHZnqBxH0fvrzZoUwe0qQva1ANt6gPvBmC2F2jT11GbhqBNI9CmMWjTBLRpSv57MpjtDdr0M9yNPfQu7KPvvvru59mN/dX3AHUGqjPIcDc2B41bgMYtQeNWoHFr8t/FwOwA0Hiwo/fXFrRpB9q0B206gDYdyT+ng9mBoM0QR206gzZdQJuuoE030KY78O4BZgeBNkMNd2N/vQsH63uIvod6duMw9T1cnRHqjDTcjT1B416gcW/QuA9o3Bd06wdmh4PGoxy9v/6gzQDQZiBoMwi0GQy8h4DZEaDNaEdthoI2w0Cb4aDNCNBmJPAeBWZHgjZjDHfjML0LR+l7tL7HeHbjWPU9Tp3x6kww3I2jQeMxoPFY0HgcaDwedJsAZseBxhMdvb+JoM0k0GYyaDMFtJkKvKeB2fGgzSRHbaaDNjNAm5mgzSzQZjbwnkPeGGgz2XA3jtW7cKK+J+l7smc3TlHfU9WZps50w904FzSeBxrPB40XgMYLQbdFYHYqaDzD0ftbDNosAW2WgjbLQJvlwHsF2aOgzUxHbVaCNqtAm9WgzRrQZi3wXgdmp4M2swx34xS9C2foe6a+Z3l242z1PUeduerMM9yN60HjDaDxRtB4E2i8GXTbQv5eCRrPd/T+toI220Cb7aDNDtBmJ/DeBWbngjYLHLXZDdrsAW32gjb7QJv9wPsAmJ0H2iw03I2z9S6cr+8F+l7o2Y2L1PdidZaos9RwNx4EjQ+BxodB4yOg8VHQ7RiYXQwaL3P0/o6DNidAm5OgzSnQ5jTwPgNml4A2yx21OQvanANtzoM2F0Cbi8D7EphdCtqsMNyNi/QuXKbv5fpe4dmNK9X3KnVWq7PGcDdeBo2vgMZXQeNroPF10O0GmF0FGq919P5ugja3QJvboM0d0OYu8L4HZleDNusctbkP2jwAbR6CNo9Am8fA+wmYXQParDfcjSv1Llyr73X6Xu/ZjRvU90Z1Nqmz2XA3PgWNn4HGz0HjF6DxS9DtFZjdCBpvcfT+XoM2b0Cbt6DNO9DmPfD+AGY3gTZbHbX5CNp8Am0+gzZfQJuvwPsbmN0M2mwz3I0b9C7cou+t+t7m2Y3b1fcOdXaqs8twN34HjX+Axj9B41+g8V+g228wuwM03u3o/fni+N/mjzj+twkQx/82AeP43+bPOP57BwKzO0GbPY7aBAZtgoA2QUGbYKBNcOAdAszuAm32Gu7G7XoX7tb3Hn3v9ezGfep7vzoH1DlouBtDgsahQOPQoHEY0Dgs6BYOzO4HjQ85en/hQZsIoE1E0CYSaBMZeEcBswdAm8OO2kQFbaKBNtFBmxigTUzgHQvMHgRtjhjuxn16Fx7S92F9H/HsxqPq+5g6x9U5YbgbY4PGcUDjuKBxPNA4PuiWAMweA41POnp/CUGbRKBNYtAmCWiTFHgnA7PHQZtTjtokB21SgDYpQZtUoE1q4J0GzJ4AbU4b7sajehee1PcpfZ/27MYz6vusOufUOW+4G9OCxulA4/SgcQbQOCPolgnMngWNLzh6f5lBmyygTVbQJhtokx145wCz50Cbi47a5ARtcoE2uUGbPKBNXuCdD8yeB20uGe7GM3oXXtD3RX1f8uzGy+r7ijpX1blmuBvzg8YFQOOCoHEh0Lgw6FYEzF4Bja87en9FQZtioE1x0KYEaFMSeJcCs1dBmxuO2pQGbcqANmVBm3KgTXngXQHMXgNtbhruxst6F17X9w193/Tsxlvq+7Y6d9S5a7gbK4LGlUDjyqBxFdC4KuhWDczeBo3vOXp/1UGbGqBNTdCmFmhTG3jXAbN3QJv7jtrUBW3qgTb1QZsGoE1D4N0IzN4FbR4Y7sZbehfe0/d9fT/w7MaH6vuROo/VeWK4GxuDxk1A46agcTPQuDno1gLMPgKNnzp6fy1Bm1agTWvQpg1o0xZ4twOzj0GbZ47atAdtOoA2HUGbTqBNZ+DdBcw+AW2eG+7Gh3oXPtX3M30/9+zGF+r7pTqv1HltuBu7gsbdQOPuoHEP0Lgn6NYLzL4Ejd84en+9QZs+oE1f0KYfaNMfeA8As69Am7eO2gwEbQaBNoNBmyGgzVDgPQzMvgZt3hnuxhd6F77R91t9v/Psxvfq+4M6H9X5ZLgbh4PGI0DjkaDxKNB4NOg2Bsx+AI0/O3p/Y0GbcaDNeNBmAmgzEXhPArMfQZsvjtpMBm2mgDZTQZtpoM104D0DzH4Cbb4a7sb3ehd+1vcXfX/17MZv6vu7Oj/U+Wm4G2eCxrNA49mg8RzQeC7oNg/MfgeNfzl6f/NBmwWgzULQZhFosxh4//94swvgKhZG2/NNCCGEEIIHQiC4u7u7SwghBDpEcXd3d3d3d3d3d3d39zn93rkzd17N1O21vup1qvrs1KnO/vev1959qmApcO5PYJs/om2WAdssB7ZZAWyzEthmFXC/VwPn/gK2+fsfPhu///ss/P3v659/X//+t2ejEfDPf/vncPnniBnw/75YdOM1wMZrgY3XARuvBzbeAOy2ETjXup//de7/tLFrgOb7twnYZjOwzRZgm63ANtuA+70dONcF2CaWaJsdwDY7gW12AdvsBrbZA9zvvcC5MYFt3IBt/r+ejf/ruWf87++f9Rrr31frff/rvNj//Oz+zxHnn8PjP3w27gM23g9sfADY+CCw8SFgt8PAue7AxnFF378jwDZHgW2OAdscB7Y5Adzvk8C5cYBtPEXbnAK2OQ1scwbY5iywzTngfp8HzvUAton3Hz4bY//7LIz776vnv6/x/tuz0eufn+P/c3j/cyT4D5+NF4CNLwIbXwI2vgxsfAXY7Spwbnxg44Si7981YJvrwDY3gG1uAtvcAu73beBcb2CbRKJt7gDb3AW2uQdscx/Y5gFwvx8C5yYAtkn8Hz4bvf59Fib89zXRv6+J/9uzMck/Pyf950j2z+HzHz4bHwEbPwY2fgJs/BTY+Bmw23Pg3KTAxslF378XwDYvgW1eAdu8BrZ5A9zvt8C5yYBtUoi2eQds8x7Y5gOwzUdgm0/I368A5/oA2/j+h8/GJP8+C5P/+5ri31ff//ZsTPnPz37/HKn+OVL/h8/GL8DGX4GNvwEbfwc2/oH8GT5wrh+wsT/5/fuv/fz/32nj/++fX8A2vwFrKsCa5j/8PKf89/Pr/+9rmn9fU/+3z3Paf35O98+R/p8jQ8D/87vWP/6GPVO6f9/j//y9/8mXMcB2g7ou6/0zEteVyeHrst4/E3FdmR2+Luv9MxPXlcXh67LePwtxXVkdvi7r/bMS15XN4euy3j8bcV3ZHb4u6/2zE9eVw+HrcjH+9/PLBfy9mIZ9Q06HDdb15yQMroZ9Qy6BIRdhiGXYN+QWGHITBjfDviGPwJCHMMQ27BvyCgx5CYO7Yd+QT2DIRxjiGPYN+QWG/ITBw7BvKCAwFCAMcQ37hoICQ0HC4GnYNxQSGAoRhniGfUNhgaEwYfAy7BuKCAxFCEN8w76hqMBQlDB4G/YNxQSGYoQhgWHfUFxgKE4YEhr2DSUEhhKEIZFh31BSYChJGBIb9g2lBIZShCGJYd9QWmAoTRiSGvYNZQSGMoQhmWHfUFZgKEsYfAz7hnICQznCkNywbygvMJQnDCkM+4YKAkMFwuBr2DdUFBgqEoaUhn1DJYGhEmHwM+wbKgsMlQlDKsO+oYrAUIUwpDbsG6oKDFUJg79h31BNYKhGGNIY9g3VBYbqhCGtYd9QQ2CoQRjSGfYNNQWGmoQhvWHfUEtgqEUYMhj2DbUFhtqEIaNh31BHYKhDGDIZ9g11BYa6hCGzYd9QT2CoRxiyGPYN9QWG+oQhq2HfECAwBBCGbIZ9QwOBoQFhyG7YNwQKDIGEIYdh39BQYGhIGHIa9g1BAkMQYchl2Dc0EhgaEYbchn1DsMAQTBjyGPYNjQWGxoQhr2HfECIwhBCGfIZ9QxOBoQlhyG/YNzQVGJoShgKGfYMpMJiEoaBh3xAqMIQShkKGfUMzgaEZYShs2DeECQxhhKGIYd8QLjCEE4aihn1DhMAQQRiKGfYNkQJDJGEobtg3RAkMUYShhGHfEC0wRBOGkoZ9Q3OBoTlhKGXYN7QQGFoQhtKGfUNLgaElYShj2De0EhhaEYayhn1Da4GhNWEoZ9g3tBEY2hCG8oZ9Q1uBoS1hqGDYN7QTGNoRhoqGfUN7gaE9Yahk2Dd0EBg6EIbKhn1DR4GhI2GoYtg3dBIYOhGGqoZ9Q2eBoTNhqGbYN3QRGLoQhuqGfUNXgaErYahh2Dd0Exi6EYaahn1Dd4GhO2GoZdg39BAYehCG2oZ9Q0+BoSdhqGPYN/QSGHoRhrqGfUNvgaE3Yahn2Df0ERj6EIb6hn1DX4GhL2EIMOwb+gkM/QhDA8O+ob/A0J8wBBr2DQMEhgGEoaFh3zBQYBhIGIIM+4ZBAsMgwtDIsG8YLDAMJgzBhn3DEIFhCGFobNg3DBUYhhKGEMO+YZjAMIwwNDHsG4YLDMMJQ1PDvmGEwDCCMJiGfcNIgWEkYQg17BtGCQyjCEMzw75htMAwmjCEGfYNYwSGMYQh3LBvGCswjCUMEYZ9wziBYRxhiDTsG8YLDOMJQ5Rh3zBBYJhAGKIN+4aJAsNEwtDcsG+YJDBMIgwtDPuGyQLDZMLQ0rBvmCIwTCEMrQz7hqkCw1TC0Nqwb5gmMEwjDG0M+4bpAsN0wtDWsG+YITDMIAztDPuGmQLDTMLQ3rBvmCUwzCIMHQz7htkCw2zC0NGwb5gjMMwhDJ0M+4a5AsNcwtDZsG+YJzDMIwxdDPuG+QLDfMLQ1bBvWCAwLCAM3Qz7hoUCw0LC0N2wb1gkMCwiDD0M+4bFAsNiwtDTsG9YIjAsIQy9DPuGpQLDUsLQ27BvWCYwLCMMfQz7huUCw3LC0Newb1ghMKwgDP0M+4aVAsNKwtDfsG9YJTCsIgwDDPuG1QLDasIw0LBvWCMwrCEMgwz7hrUCw1rCMNiwb1gnMKwjDEMM+4b1AsN6wjDUsG/YIDBsIAzDDPuGjQLDRsIw3LBv2CQwbCIMIwz7hs0Cw2bCMNKwb9giMGwhDKMM+4atAsNWwjDasG/YJjBsIwxjDPuG7QLDdsIw1rBv2CEw7CAM4wz7hp0Cw07CMN6wb9glMOwiDBMM+4bdAsNuwjDRsG/YIzDsIQyTDPuGvQLDXsIw2bBv2Ccw7CMMUwz7hv0Cw37CMNWwbzggMBwgDNMM+4aDAsNBwjDdsG84JDAcIgwzDPuGwwLDYcIw07BvOCIwHCEMswz7hqMCw1HCMNuwbzgmMBwjDHMM+4bjAsNxwjDXsG84ITCcIAzzDPuGkwLDScIw37BvOCUwnCIMCwz7htMCw2nCsNCwbzgjMJwhDIsM+4azAsNZwrDYsG84JzCcIwxLDPuG8wLDecKw1LBvuCAwXCAMywz7hosCw0XCsNywb7gkMFwiDCsM+4bLAsNlwrDSsG+4IjBcIQyrDPuGqwLDVcKw2rBvuCYwXCMMawz7husCw3XCsNawb7ghMNwgDOsM+4abAsNNwrDesG+4JTDcIgwbDPuG2wLDbcKw0bBvuCMw3CEMmwz7hrsCw13CsNmwb7gnMNwjDFsM+4b7AsN9wrDVsG94IDA8IAzbDPuGhwLDQ8Kw3bBveCQwPCIMOwz7hscCw2PCsNOwb3giMDwhDLsM+4anAsNTwrDbsG94JjA8Iwx7DPuG5wLDc8Kw17BveCEwvCAM+wz7hpcCw0vCsN+wb3glMLwiDAcM+4bXAsNrwnDQsG94IzC8IQyHDPuGtwLDW8Jw2LBveCcwvCMMRwz7hvcCw3vCcNSwb/ggMHwgDMcM+4aPAsNHwnDcsG/4JDB8IgwnDPuGzwLDZ8Jw0rBv+CIwfCEMpwz7hq8Cw1fCcNqwb/gmMHwjDGcM+4bvAsN3wnDWsG/4ITD8IAznDPuGnwLDT8Jw3rBv+CUw/CIMFwz7ht8Cw2/CcNGwb/gjMPwhDJcM+4a/AsNfwnDZsG8wGjhvsBqo4Yph3xBDYIhBGK4a9g0uAoMLYbhm2DfEFBhiEobrhn2Dq8DgShhuGPYNsQSGWIThpmHf4CYwuBGGW4Z9Q2yBITZhuG3YN7gLDO6E4Y5h3xBHYIhDGO4a9g0eAoMHYbhn2DfEFRjiEob7hn2Dp8DgSRgeGPYN8QSGeIThoWHf4CUweBGGR4Z9Q3yBIT5heGzYN3gLDN6E4Ylh35BAYEhAGJ4a9g0JBYaEhOGZYd+QSGBIRBieG/YNiQWGxIThhWHfkERgSEIYXhr2DUkFhqSE4ZVh35BMYEhGGF4b9g0+AoMPYXhj2DckFxiSE4a3hn1DCoEhBWF4Z9g3+AoMvoThvWHfkFJgSEkYPhj2DX4Cgx9h+GjYN6QSGFIRhk+GfUNqgSE1Yfhs2Df4Cwz+hOGLYd+QRmBIQxi+GvYNaQWGtIThm2HfkE5gSEcYvhv2DekFhvSE4Ydh35BBYMhAGH4a9g0ZBYaMhOGXYd+QSWDIRBh+G/YNmQWGzIThj2HfkEVgyEIY/hr2DVkFhqyEwQr917n/kyGbwJCNMMQADNkFhuyEwQUw5BAYchCGmIAhp8CQkzC4AoZcAkMuwhALMOQWGHITBjfAkEdgyEMYYgOGvAJDXsLgDhjyCQz5CEMcwJBfYMhPGDwAQwGBoQBhiAsYCgoMBQmDJ2AoJDAUIgzxAENhgaEwYfACDEUEhiKEIT5gKCowFCUM3oChmMBQjDAkAAzFBYbihCEhYCghMJQgDIkAQ0mBoSRhSAwYSgkMpQhDEsBQWmAoTRiSAoYyAkMZwpAMMJQVGMoSBh/AUE5gKEcYkgOG8gJDecKQAjBUEBgqEAZfwFBRYKhIGFIChkoCQyXC4AcYKgsMlQlDKsBQRWCoQhhSA4aqAkNVwuAPGKoJDNUIQxrAUF1gqE4Y0gKGGgJDDcKQDjDUFBhqEob0gKGWwFCLMGQADLUFhtqEISNgqCMw1CEMmQBDXYGhLmHIDBjqCQz1CEMWwFBfYKhPGLIChgCBIYAwZAMMDQSGBoQhO2AIFBgCCUMOwNBQYGhIGHIChiCBIYgw5AIMjQSGRoQhN2AIFhiCCUMewNBYYGhMGPIChhCBIYQw5AMMTQSGJoQhP2BoKjA0JQwFAIMpMJiEoSBgCBUYQglDIcDQTGBoRhgKA4YwgSGMMBQBDOECQzhhKAoYIgSGCMJQDDBECgyRhKE4YIgSGKIIQwnAEC0wRBOGkoChucDQnDCUAgwtBIYWhKE0YGgpMLQkDGUAQyuBoRVhKAsYWgsMrQlDOcDQRmBoQxjKA4a2AkNbwlABMLQTGNoRhoqAob3A0J4wVAIMHQSGDoShMmDoKDB0JAxVAEMngaETYagKGDoLDJ0JQzXA0EVg6EIYqgOGrgJDV8JQAzB0Exi6EYaagKG7wNCdMNQCDD0Ehh6EoTZg6Ckw9CQMdQBDL4GhF2GoCxh6Cwy9CUM9wNBHYOhDGOoDhr4CQ1/CEAAY+gkM/QhDA8DQX2DoTxgCAcMAgWEAYWgIGAYKDAMJQxBgGCQwDCIMjQDDYIFhMGEIBgxDBIYhhKExYBgqMAwlDCGAYZjAMIwwNAEMwwWG4YShKWAYITCMIAwmYBgpMIwkDKGAYZTAMIowNAMMowWG0YQhDDCMERjGEIZwwDBWYBhLGCIAwziBYRxhiAQM4wWG8YQhCjBMEBgmEIZowDBRYJhIGJoDhkkCwyTC0AIwTBYYJhOGloBhisAwhTC0AgxTBYaphKE1YJgmMEwjDG0Aw3SBYTphaAsYZggMMwhDO8AwU2CYSRjaA4ZZAsMswtABMMwWGGYTho6AYY7AMIcwdAIMcwWGuYShM2CYJzDMIwxdAMN8gWE+YegKGBYIDAsIQzfAsFBgWEgYugOGRQLDIsLQAzAsFhgWE4aegGGJwLCEMPQCDEsFhqWEoTdgWCYwLCMMfQDDcoFhOWHoCxhWCAwrCEM/wLBSYFhJGPoDhlUCwyrCMAAwrBYYVhOGgYBhjcCwhjAMAgxrBYa1hGEwYFgnMKwjDEMAw3qBYT1hGAoYNggMGwjDMMCwUWDYSBiGA4ZNAsMmwjACMGwWGDYThpGAYYvAsIUwjAIMWwWGrYRhNGDYJjBsIwxjAMN2gWE7YRgLGHYIDDsIwzjAsFNg2EkYxgOGXQLDLsIwATDsFhh2E4aJgGGPwLCHMEwCDHsFhr2EYTJg2Ccw7CMMUwDDfoFhP2GYChgOCAwHCMM0wHBQYDhIGKYDhkMCwyHCMAMwHBYYDhOGmYDhiMBwhDDMAgxHBYajhGE2YDgmMBwjDHMAw3GB4ThhmAsYTggMJwjDPMBwUmA4SRjmA4ZTAsMpwrAAMJwWGE4ThoWA4YzAcIYwLAIMZwWGs4RhMWA4JzCcIwxLAMN5geE8YVgKGC4IDBcIwzLAcFFguEgYlgOGSwLDJcKwAjBcFhguE4aVgOGKwHCFMKwCDFcFhquEYTVguCYwXCMMawDDdYHhOmFYCxhuCAw3CMM6wHBTYLhJGNYDhlsCwy3CsAEw3BYYbhOGjYDhjsBwhzBsAgx3BYa7hGEzYLgnMNwjDFsAw32B4T5h2AoYHggMDwjDNsDwUGB4SBi2A4ZHAsMjwrADMDwWGB4Thp2A4YnA8IQw7AIMTwWGp4RhN2B4JjA8Iwx7AMNzgeE5YdgLGF4IDC8Iwz7A8FJgeEkY9gOGVwLDK8JwADC8FhheE4aDgOGNwPCGMBwCDG8FhreE4TBgeCcwvCMMRwDDe4HhPWE4Chg+CAwfCMMxwPBRYPhIGI4Dhk8CwyfCcAIwfBYYPhOGk4Dhi8DwhTCcAgxfBYavhOE0YPgmMHwjDGcAw3eB4TthOAsYfggMPwjDOcDwU2D4SRjOA4ZfAsMvwnABMPwWGH4ThouA4Y/A8IcwXAIMfwWGv4ThMmAwAp03WA3UcAUwxBAYYhCGq4DBRWBwIQzXAENMgSEmYbgOGFwFBlfCcAMwxBIYYhGGm4DBTWBwIwy3AENsgSE2YbgNGNwFBnfCcAcwxBEY4hCGu4DBQ2DwIAz3AENcgSEuYbgPGDwFBk/C8AAwxBMY4hGGh4DBS2DwIgyPAEN8gSE+YXgMGLwFBm/C8AQwJBAYEhCGp4AhocCQkDA8AwyJBIZEhOE5YEgsMCQmDC8AQxKBIQlheAkYkgoMSQnDK8CQTGBIRhheAwYfgcGHMLwBDMkFhuSE4S1gSCEwpCAM7wCDr8DgSxjeA4aUAkNKwvABMPgJDH6E4SNgSCUwpCIMnwBDaoEhNWH4DBj8BQZ/wvAFMKQRGNIQhq+AIa3AkJYwfAMM6QSGdIThO2BILzCkJww/AEMGgSEDYfgJGDIKDBkJwy/AkElgyEQYfgOGzAJDZsLwBzBkERiyEIa/gCGrwJCVMFi/8F/n/k+GbA4bXFz/+f9DAG6I6WrfkF2wQ3ZiB1fAkENgyEEYYgGGnAJDTsLgBhhyCQy5CENswJBbYMhNGNwBQx6BIQ9hiAMY8goMeQmDB2DIJzDkIwxxAUN+gSE/YfAEDAUEhgKEIR5gKCgwFCQMXoChkMBQiDDEBwyFBYbChMEbMBQRGIoQhgSAoajAUJQwJAQMxQSGYoQhEWAoLjAUJwyJAUMJgaEEYUgCGEoKDCUJQ1LAUEpgKEUYkgGG0gJDacLgAxjKCAxlCENywFBWYChLGFIAhnICQznC4AsYygsM5QlDSsBQQWCoQBj8AENFgaEiYUgFGCoJDJUIQ2rAUFlgqEwY/AFDFYGhCmFIAxiqCgxVCUNawFBNYKhGGNIBhuoCQ3XCkB4w1BAYahCGDIChpsBQkzBkBAy1BIZahCETYKgtMNQmDJkBQx2BoQ5hyAIY6goMdQlDVsBQT2CoRxiyAYb6AkN9wpAdMAQIDAGEIQdgaCAwNCAMOQFDoMAQSBhyAYaGAkNDwpAbMAQJDEGEIQ9gaCQwNCIMeQFDsMAQTBjyAYbGAkNjwpAfMIQIDCGEoQBgaCIwNCEMBQFDU4GhKWEoBBhMgcEkDIUBQ6jAEEoYigCGZgJDM8JQFDCECQxhhKEYYAgXGMIJQ3HAECEwRBCGEoAhUmCIJAwlAUOUwBBFGEoBhmiBIZowlAYMzQWG5oShDGBoITC0IAxlAUNLgaElYSgHGFoJDK0IQ3nA0FpgaE0YKgCGNgJDG8JQETC0FRjaEoZKgKGdwNCOMFQGDO0FhvaEoQpg6CAwdCAMVQFDR4GhI2GoBhg6CQydCEN1wNBZYOhMGGoAhi4CQxfCUBMwdBUYuhKGWoChm8DQjTDUBgzdBYbuhKEOYOghMPQgDHUBQ0+BoSdhqAcYegkMvQhDfcDQW2DoTRgCAEMfgaEPYWgAGPoKDH0JQyBg6Ccw9CMMDQFDf4GhP2EIAgwDBIYBhKERYBgoMAwkDMGAYZDAMIgwNAYMgwWGwYQhBDAMERiGEIYmgGGowDCUMDQFDMMEhmGEwQQMwwWG4YQhFDCMEBhGEIZmgGGkwDCSMIQBhlECwyjCEA4YRgsMowlDBGAYIzCMIQyRgGGswDCWMEQBhnECwzjCEA0YxgsM4wlDc8AwQWCYQBhaAIaJAsNEwtASMEwSGCYRhlaAYbLAMJkwtAYMUwSGKYShDWCYKjBMJQxtAcM0gWEaYWgHGKYLDNMJQ3vAMENgmEEYOgCGmQLDTMLQETDMEhhmEYZOgGG2wDCbMHQGDHMEhjmEoQtgmCswzCUMXQHDPIFhHmHoBhjmCwzzCUN3wLBAYFhAGHoAhoUCw0LC0BMwLBIYFhGGXoBhscCwmDD0BgxLBIYlhKEPYFgqMCwlDH0BwzKBYRlh6AcYlgsMywlDf8CwQmBYQRgGAIaVAsNKwjAQMKwSGFYRhkGAYbXAsJowDAYMawSGNYRhCGBYKzCsJQxDAcM6gWEdYRgGGNYLDOsJw3DAsEFg2EAYRgCGjQLDRsIwEjBsEhg2EYZRgGGzwLCZMIwGDFsEhi2EYQxg2CowbCUMYwHDNoFhG2EYBxi2CwzbCcN4wLBDYNhBGCYAhp0Cw07CMBEw7BIYdhGGSYBht8CwmzBMBgx7BIY9hGEKYNgrMOwlDFMBwz6BYR9hmAYY9gsM+wnDdMBwQGA4QBhmAIaDAsNBwjATMBwSGA4RhlmA4bDAcJgwzAYMRwSGI4RhDmA4KjAcJQxzAcMxgeEYYZgHGI4LDMcJw3zAcEJgOEEYFgCGkwLDScKwEDCcEhhOEYZFgOG0wHCaMCwGDGcEhjOEYQlgOCswnCUMSwHDOYHhHGFYBhjOCwznCcNywHBBYLhAGFYAhosCw0XCsBIwXBIYLhGGVYDhssBwmTCsBgxXBIYrhGENYLgqMFwlDGsBwzWB4RphWAcYrgsM1wnDesBwQ2C4QRg2AIabAsNNwrARMNwSGG4Rhk2A4bbAcJswbAYMdwSGO4RhC2C4KzDcJQxbAcM9geEeYdgGGO4LDPcJw3bA8EBgeEAYdgCGhwLDQ8KwEzA8EhgeEYZdgOGxwPCYMOwGDE8EhieEYQ9geCowPCUMewHDM4HhGWHYBxieCwzPCcN+wPBCYHhBGA4AhpcCw0vCcBAwvBIYXhGGQ4DhtcDwmjAcBgxvBIY3hOEIYHgrMLwlDEcBwzuB4R1hOAYY3gsM7wnDccDwQWD4QBhOAIaPAsNHwnASMHwSGD4RhlOA4bPA8JkwnAYMXwSGL4ThDGD4KjB8JQxnAcM3geEbYTgHGL4LDN8Jw3nA8ENg+EEYLgCGnwLDT8JwETD8Ehh+EYZLgOG3wPCbMFwGDH8Ehj+E4Qpg+Csw/CUMVwGD0dB5g9VADdcAQwyBIQZhuA4YXAQGF8JwAzDEFBhiEoabgMFVYHAlDLcAQyyBIRZhuA0Y3AQGN8JwBzDEFhhiE4a7gMFdYHAnDPcAQxyBIQ5huA8YPAQGD8LwADDEFRjiEoaHgMFTYPAkDI8AQzyBIR5heAwYvAQGL8LwBDDEFxjiE4angMFbYPAmDM8AQwKBIQFheA4YEgoMCQnDC8CQSGBIRBheAobEAkNiwvAKMCQRGJIQhteAIanAkJQwvAEMyQSGZIThLWDwERh8CMM7wJBcYEhOGN4DhhQCQwrC8AEw+AoMvoThI2BIKTCkJAyfAIOfwOBHGD4DhlQCQyrC8AUwpBYYUhOGr4DBX2DwJwzfAEMagSENYfgOGNIKDGkJww/AkE5gSEcYfgKG9AJDesLwCzBkEBgyEIbfgCGjwJCRMPwBDJkEhkyE4S9gyCwwZCYMRiz7hiwCQxbCEAMwZBUYshIGF8CQTWDIRhhiAobsAkN2wuAKGHIIDDkIQyzAkFNgyEkY3ABDLoEhF2GIDRhyCwy5CYM7YMgjMOQhDHEAQ16BIS9h8AAM+QSGfIQhLmDILzDkJwyegKGAwFCAMMQDDAUFhoKEwQswFBIYChGG+IChsMBQmDB4A4YiAkMRwpAAMBQVGIoShoSAoZjAUIwwJAIMxQWG4oQhMWAoITCUIAxJAENJgaEkYUgKGEoJDKUIQzLAUFpgKE0YfABDGYGhDGFIDhjKCgxlCUMKwFBOYChHGHwBQ3mBoTxhSAkYKggMFQiDH2CoKDBUJAypAEMlgaESYUgNGCoLDJUJgz9gqCIwVCEMaQBDVYGhKmFICxiqCQzVCEM6wFBdYKhOGNIDhhoCQw3CkAEw1BQYahKGjIChlsBQizBkAgy1BYbahCEzYKgjMNQhDFkAQ12BoS5hyAoY6gkM9QhDNsBQX2CoTxiyA4YAgSGAMOQADA0EhgaEISdgCBQYAglDLsDQUGBoSBhyA4YggSGIMOQBDI0EhkaEIS9gCBYYgglDPsDQWGBoTBjyA4YQgSGEMBQADE0EhiaEoSBgaCowNCUMhQCDKTCYhKEwYAgVGEIJQxHA0ExgaEYYigKGMIEhjDAUAwzhAkM4YSgOGCIEhgjCUAIwRAoMkYShJGCIEhiiCEMpwBAtMEQThtKAobnA0JwwlAEMLQSGFoShLGBoKTC0JAzlAEMrgaEVYSgPGFoLDK0JQwXA0EZgaEMYKgKGtgJDW8JQCTC0ExjaEYbKgKG9wNCeMFQBDB0Ehg6EoSpg6CgwdCQM1QBDJ4GhE2GoDhg6CwydCUMNwNBFYOhCGGoChq4CQ1fCUAswdBMYuhGG2oChu8DQnTDUAQw9BIYehKEuYOgpMPQkDPUAQy+BoRdhqA8YegsMvQlDAGDoIzD0IQwNAENfgaEvYQgEDP0Ehn6EoSFg6C8w9CcMQYBhgMAwgDA0AgwDBYaBhCEYMAwSGAYRhsaAYbDAMJgwhACGIQLDEMLQBDAMFRiGEoamgGGYwDCMMJiAYbjAMJwwhAKGEQLDCMLQDDCMFBhGEoYwwDBKYBhFGMIBw2iBYTRhiAAMYwSGMYQhEjCMFRjGEoYowDBOYBhHGKIBw3iBYTxhaA4YJggMEwhDC8AwUWCYSBhaAoZJAsMkwtAKMEwWGCYThtaAYYrAMIUwtAEMUwWGqYShLWCYJjBMIwztAMN0gWE6YWgPGGYIDDMIQwfAMFNgmEkYOgKGWQLDLMLQCTDMFhhmE4bOgGGOwDCHMHQBDHMFhrmEoStgmCcwzCMM3QDDfIFhPmHoDhgWCAwLCEMPwLBQYFhIGHoChkUCwyLC0AswLBYYFhOG3oBhicCwhDD0AQxLBYalhKEvYFgmMCwjDP0Aw3KBYTlh6A8YVggMKwjDAMCwUmBYSRgGAoZVAsMqwjAIMKwWGFYThsGAYY3AsIYwDAEMawWGtYRhKGBYJzCsIwzDAMN6gWE9YRgOGDYIDBsIwwjAsFFg2EgYRgKGTQLDJsIwCjBsFhg2E4bRgGGLwLCFMIwBDFsFhq2EYSxg2CYwbCMM4wDDdoFhO2EYDxh2CAw7CMMEwLBTYNhJGCYChl0Cwy7CMAkw7BYYdhOGyYBhj8CwhzBMAQx7BYa9hGEqYNgnMOwjDNMAw36BYT9hmA4YDggMBwjDDMBwUGA4SBhmAoZDAsMhwjALMBwWGA4ThtmA4YjAcIQwzAEMRwWGo4RhLmA4JjAcIwzzAMNxgeE4YZgPGE4IDCcIwwLAcFJgOEkYFgKGUwLDKcKwCDCcFhhOE4bFgOGMwHCGMCwBDGcFhrOEYSlgOCcwnCMMywDDeYHhPGFYDhguCAwXCMMKwHBRYLhIGFYChksCwyXCsAowXBYYLhOG1YDhisBwhTCsAQxXBYarhGEtYLgmMFwjDOsAw3WB4TphWA8YbggMNwjDBsBwU2C4SRg2AoZbAsMtwrAJMNwWGG4Ths2A4Y7AcIcwbAEMdwWGu4RhK2C4JzDcIwzbAMN9geE+YdgOGB4IDA8Iww7A8FBgeEgYdgKGRwLDI8KwCzA8FhgeE4bdgOGJwPCEMOwBDE8FhqeEYS9geCYwPCMM+wDDc4HhOWHYDxheCAwvCMMBwPBSYHhJGA4ChlcCwyvCcAgwvBYYXhOGw4DhjcDwhjAcAQxvBYa3hOEoYHgnMLwjDMcAw3uB4T1hOA4YPggMHwjDCcDwUWD4SBhOAoZPAsMnwnAKMHwWGD4ThtOA4YvA8IUwnAEMXwWGr4ThLGD4JjB8IwznAMN3geE7YTgPGH4IDD8IwwXA8FNg+EkYLgKGXwLDL8JwCTD8Fhh+E4bLgOGPwPCHMFwBDH8Fhr+E4SpgMIKcN1gN1HANMMQQGGIQhuuAwUVgcCEMNwBDTIEhJmG4CRhcBQZXwnALMMQSGGIRhtuAwU1gcCMMdwBDbIEhNmG4CxjcBQZ3wnAPMMQRGOIQhvuAwUNg8CAMDwBDXIEhLmF4CBg8BQZPwvAIMMQTGOIRhseAwUtg8CIMTwBDfIEhPmF4Chi8BQZvwvAMMCQQGBIQhueAIaHAkJAwvAAMiQSGRIThJWBILDAkJgyvAEMSgSEJYXgNGJIKDEkJwxvAkExgSEYY3gIGH4HBhzC8AwzJBYbkhOE9YEghMKQgDB8Ag6/A4EsYPgKGlAJDSsLwCTD4CQx+hOEzYEglMKQiDF8AQ2qBITVh+AoY/AUGf8LwDTCkERjSEIbvgCGtwJCWMPwADOkEhnSE4SdgSC8wpCcMvwBDBoEhA2H4DRgyCgwZCcMfwJBJYMhEGP4ChswCQ2bCYLjZN2Rx2ODi/s9zKQA3xHS3b8gq2CErsYMrYMgmMGQjDLEAQ3aBITthcAMMOQSGHIQhNmDIKTDkJAzugCGXwJCLMMQBDLkFhtyEwQMw5BEY8hCGuIAhr8CQlzB4AoZ8AkM+whAPMOQXGPITBi/AUEBgKEAY4gOGggJDQcLgDRgKCQyFCEMCwFBYYChMGBIChiICQxHCkAgwFBUYihKGxIChmMBQjDAkAQzFBYbihCEpYCghMJQgDMkAQ0mBoSRh8AEMpQSGUoQhOWAoLTCUJgwpAEMZgaEMYfAFDGUFhrKEISVgKCcwlCMMfoChvMBQnjCkAgwVBIYKhCE1YKgoMFQkDP6AoZLAUIkwpAEMlQWGyoQhLWCoIjBUIQzpAENVgaEqYUgPGKoJDNUIQwbAUF1gqE4YMgKGGgJDDcKQCTDUFBhqEobMgKGWwFCLMGQBDLUFhtqEIStgqCMw1CEM2QBDXYGhLmHIDhjqCQz1CEMOwFBfYKhPGHIChgCBIYAw5AIMDQSGBoQhN2AIFBgCCUMewNBQYGhIGPIChiCBIYgw5AMMjQSGRoQhP2AIFhiCCUMBwNBYYGhMGAoChhCBIYQwFAIMTQSGJoShMGBoKjA0JQxFAIMpMJiEoShgCBUYQglDMcDQTGBoRhiKA4YwgSGMMJQADOECQzhhKAkYIgSGCMJQCjBECgyRhKE0YIgSGKIIQxnAEC0wRBOGsoChucDQnDCUAwwtBIYWhKE8YGgpMLQkDBUAQyuBoRVhqAgYWgsMrQlDJcDQRmBoQxgqA4a2AkNbwlAFMLQTGNoRhqqAob3A0J4wVAMMHQSGDoShOmDoKDB0JAw1AEMngaETYagJGDoLDJ0JQy3A0EVg6EIYagOGrgJDV8JQBzB0Exi6EYa6gKG7wNCdMNQDDD0Ehh6EoT5g6Ckw9CQMAYChl8DQizA0AAy9BYbehCEQMPQRGPoQhoaAoa/A0JcwBAGGfgJDP8LQCDD0Fxj6E4ZgwDBAYBhAGBoDhoECw0DCEAIYBgkMgwhDE8AwWGAYTBiaAoYhAsMQwmAChqECw1DCEAoYhgkMwwhDM8AwXGAYThjCAMMIgWEEYQgHDCMFhpGEIQIwjBIYRhGGSMAwWmAYTRiiAMMYgWEMYYgGDGMFhrGEoTlgGCcwjCMMLQDDeIFhPGFoCRgmCAwTCEMrwDBRYJhIGFoDhkkCwyTC0AYwTBYYJhOGtoBhisAwhTC0AwxTBYaphKE9YJgmMEwjDB0Aw3SBYTph6AgYZggMMwhDJ8AwU2CYSRg6A4ZZAsMswtAFMMwWGGYThq6AYY7AMIcwdAMMcwWGuYShO2CYJzDMIww9AMN8gWE+YegJGBYIDAsIQy/AsFBgWEgYegOGRQLDIsLQBzAsFhgWE4a+gGGJwLCEMPQDDEsFhqWEoT9gWCYwLCMMAwDDcoFhOWEYCBhWCAwrCMMgwLBSYFhJGAYDhlUCwyrCMAQwrBYYVhOGoYBhjcCwhjAMAwxrBYa1hGE4YFgnMKwjDCMAw3qBYT1hGAkYNggMGwjDKMCwUWDYSBhGA4ZNAsMmwjAGMGwWGDYThrGAYYvAsIUwjAMMWwWGrYRhPGDYJjBsIwwTAMN2gWE7YZgIGHYIDDsIwyTAsFNg2EkYJgOGXQLDLsIwBTDsFhh2E4apgGGPwLCHMEwDDHsFhr2EYTpg2Ccw7CMMMwDDfoFhP2GYCRgOCAwHCMMswHBQYDhIGGYDhkMCwyHCMAcwHBYYDhOGuYDhiMBwhDDMAwxHBYajhGE+YDgmMBwjDAsAw3GB4ThhWAgYTggMJwjDIsBwUmA4SRgWA4ZTAsMpwrAEMJwWGE4ThqWA4YzAcIYwLAMMZwWGs4RhOWA4JzCcIwwrAMN5geE8YVgJGC4IDBcIwyrAcFFguEgYVgOGSwLDJcKwBjBcFhguE4a1gOGKwHCFMKwDDFcFhquEYT1guCYwXCMMGwDDdYHhOmHYCBhuCAw3CMMmwHBTYLhJGDYDhlsCwy3CsAUw3BYYbhOGrYDhjsBwhzBsAwx3BYa7hGE7YLgnMNwjDDsAw32B4T5h2AkYHggMDwjDLsDwUGB4SBh2A4ZHAsMjwrAHMDwWGB4Thr2A4YnA8IQw7AMMTwWGp4RhP2B4JjA8IwwHAMNzgeE5YTgIGF4IDC8IwyHA8FJgeEkYDgOGVwLDK8JwBDC8FhheE4ajgOGNwPCGMBwDDG8FhreE4ThgeCcwvCMMJwDDe4HhPWE4CRg+CAwfCMMpwPBRYPhIGE4Dhk8CwyfCcAYwfBYYPhOGs4Dhi8DwhTCcAwxfBYavhOE8YPgmMHwjDBcAw3eB4TthuAgYfggMPwjDJcDwU2D4SRguA4ZfAsMvwnAFMPwWGH4ThquA4Y/A8IcwXAMMfwWGv4ThOmAwGjlvsBqo4QZgiCEwxCAMNwGDi8DgQhhuAYaYAkNMwnAbMLgKDK6E4Q5giCUwxCIMdwGDm8DgRhjuAYbYAkNswnAfMLgLDO6E4QFgiCMwxCEMDwGDh8DgQRgeAYa4AkNcwvAYMHgKDJ6E4QlgiCcwxCMMTwGDl8DgRRieAYb4AkN8wvAcMHgLDN6E4QVgSCAwJCAMLwFDQoEhIWF4BRgSCQyJCMNrwJBYYEhMGN4AhiQCQxLC8BYwJBUYkhKGd4AhmcCQjDC8Bww+AoMPYfgAGJILDMkJw0fAkEJgSEEYPgEGX4HBlzB8BgwpBYaUhOELYPATGPwIw1fAkEpgSEUYvgGG1AJDasLwHTD4Cwz+hOEHYEgjMKQhDD8BQ1qBIS1h+AUY0gkM6QjDb8CQXmBITxj+AIYMAkMGwvAXMGQUGDISBiOOfUMmgSETYYgBGDILDJkJgwtgyCIwZCEMMQFDVoEhK2FwBQzZBIZshCEWYMguMGQnDG6AIYfAkIMwxAYMOQWGnITBHTDkEhhyEYY4gCG3wJCbMHgAhjwCQx7CEBcw5BUY8hIGT8CQT2DIRxjiAYb8AkN+wuAFGAoIDAUIQ3zAUFBgKEgYvAFDIYGhEGFIABgKCwyFCUNCwFBEYChCGBIBhqICQ1HCkBgwFBMYihGGJIChuMBQnDAkBQwlBIYShCEZYCgpMJQkDD6AoZTAUIowJAcMpQWG0oQhBWAoIzCUIQy+gKGswFCWMKQEDOUEhnKEwQ8wlBcYyhOGVIChgsBQgTCkBgwVBYaKhMEfMFQSGCoRhjSAobLAUJkwpAUMVQSGKoQhHWCoKjBUJQzpAUM1gaEaYcgAGKoLDNUJQ0bAUENgqEEYMgGGmgJDTcKQGTDUEhhqEYYsgKG2wFCbMGQFDHUEhjqEIRtgqCsw1CUM2QFDPYGhHmHIARjqCwz1CUNOwBAgMAQQhlyAoYHA0IAw5AYMgQJDIGHIAxgaCgwNCUNewBAkMAQRhnyAoZHA0Igw5AcMwQJDMGEoABgaCwyNCUNBwBAiMIQQhkKAoYnA0IQwFAYMTQWGpoShCGAwBQaTMBQFDKECQyhhKAYYmgkMzQhDccAQJjCEEYYSgCFcYAgnDCUBQ4TAEEEYSgGGSIEhkjCUBgxRAkMUYSgDGKIFhmjCUBYwNBcYmhOGcoChhcDQgjCUBwwtBYaWhKECYGglMLQiDBUBQ2uBoTVhqAQY2ggMbQhDZcDQVmBoSxiqAIZ2AkM7wlAVMLQXGNoThmqAoYPA0IEwVAcMHQWGjoShBmDoJDB0Igw1AUNngaEzYagFGLoIDF0IQ23A0FVg6EoY6gCGbgJDN8JQFzB0Fxi6E4Z6gKGHwNCDMNQHDD0Fhp6EIQAw9BIYehGGBoCht8DQmzAEAoY+AkMfwtAQMPQVGPoShiDA0E9g6EcYGgGG/gJDf8IQDBgGCAwDCENjwDBQYBhIGEIAwyCBYRBhaAIYBgsMgwlDU8AwRGAYQhhMwDBUYBhKGEIBwzCBYRhhaAYYhgsMwwlDGGAYITCMIAzhgGGkwDCSMEQAhlECwyjCEAkYRgsMowlDFGAYIzCMIQzRgGGswDCWMDQHDOMEhnGEoQVgGC8wjCcMLQHDBIFhAmFoBRgmCgwTCUNrwDBJYJhEGNoAhskCw2TC0BYwTBEYphCGdoBhqsAwlTC0BwzTBIZphKEDYJguMEwnDB0BwwyBYQZh6AQYZgoMMwlDZ8AwS2CYRRi6AIbZAsNswtAVMMwRGOYQhm6AYa7AMJcwdAcM8wSGeYShB2CYLzDMJww9AcMCgWEBYegFGBYKDAsJQ2/AsEhgWEQY+gCGxQLDYsLQFzAsERiWEIZ+gGGpwLCUMPQHDMsEhmWEYQBgWC4wLCcMAwHDCoFhBWEYBBhWCgwrCcNgwLBKYFhFGIYAhtUCw2rCMBQwrBEY1hCGYYBhrcCwljAMBwzrBIZ1hGEEYFgvMKwnDCMBwwaBYQNhGAUYNgoMGwnDaMCwSWDYRBjGAIbNAsNmwjAWMGwRGLYQhnGAYavAsJUwjAcM2wSGbYRhAmDYLjBsJwwTAcMOgWEHYZgEGHYKDDsJw2TAsEtg2EUYpgCG3QLDbsIwFTDsERj2EIZpgGGvwLCXMEwHDPsEhn2EYQZg2C8w7CcMMwHDAYHhAGGYBRgOCgwHCcNswHBIYDhEGOYAhsMCw2HCMBcwHBEYjhCGeYDhqMBwlDDMBwzHBIZjhGEBYDguMBwnDAsBwwmB4QRhWAQYTgoMJwnDYsBwSmA4RRiWAIbTAsNpwrAUMJwRGM4QhmWA4azAcJYwLAcM5wSGc4RhBWA4LzCcJwwrAcMFgeECYVgFGC4KDBcJw2rAcElguEQY1gCGywLDZcKwFjBcERiuEIZ1gOGqwHCVMKwHDNcEhmuEYQNguC4wXCcMGwHDDYHhBmHYBBhuCgw3CcNmwHBLYLhFGLYAhtsCw23CsBUw3BEY7hCGbYDhrsBwlzBsBwz3BIZ7hGEHYLgvMNwnDDsBwwOB4QFh2AUYHgoMDwnDbsDwSGB4RBj2AIbHAsNjwrAXMDwRGJ4Qhn2A4anA8JQw7AcMzwSGZ4ThAGB4LjA8JwwHAcMLgeEFYTgEGF4KDC8Jw2HA8EpgeEUYjgCG1wLDa8JwFDC8ERjeEIZjgOGtwPCWMBwHDO8EhneE4QRgeC8wvCcMJwHDB4HhA2E4BRg+CgwfCcNpwPBJYPhEGM4Ahs8Cw2fCcBYwfBEYvhCGc4Dhq8DwlTCcBwzfBIZvhOECYPguMHwnDBcBww+B4QdhuAQYfgoMPwnDZcDwS2D4RRiuAIbfAsNvwnAVMPwRGP4QhmuA4a/A8JcwXAcMRrDzBquBGm4AhhgCQwzCcBMwuAgMLoThFmCIKTDEJAy3AYOrwOBKGO4AhlgCQyzCcBcwuAkMboThHmCILTDEJgz3AYO7wOBOGB4AhjgCQxzC8BAweAgMHoThEWCIKzDEJQyPAYOnwOBJGJ4AhngCQzzC8BQweAkMXoThGWCILzDEJwzPAYO3wOBNGF4AhgQCQwLC8BIwJBQYEhKGV4AhkcCQiDC8BgyJBYbEhOENYEgiMCQhDG8BQ1KBISlheAcYkgkMyQjDe8DgIzD4EIYPgCG5wJCcMHwEDCkEhhSE4RNg8BUYfAnDZ8CQUmBISRi+AAY/gcGPMHwFDKkEhlSE4RtgSC0wpCYM3wGDv8DgTxh+AIY0AkMawvATMKQVGNIShl+AIZ3AkI4w/AYM6QWG9IThD2DIIDBkIAx/AUNGgSEjYTA87BsyOWxw8fzn+xCAG2J62jdkFuyQmdjBFTBkERiyEIZYgCGrwJCVMLgBhmwCQzbCEBswZBcYshMGd8CQQ2DIQRjiAIacAkNOwuABGHIJDLkIQ1zAkFtgyE0YPAFDHoEhD2GIBxjyCgx5CYMXYMgnMOQjDPEBQ36BIT9h8AYMBQSGAoQhAWAoKDAUJAwJAUMhgaEQYUgEGAoLDIUJQ2LAUERgKEIYkgCGogJDUcKQFDAUExiKEYZkgKG4wFCcMPgAhhICQwnCkBwwlBQYShKGFIChlMBQijD4AobSAkNpwpASMJQRGMoQBj/AUFZgKEsYUgGGcgJDOcKQGjCUFxjKEwZ/wFBBYKhAGNIAhooCQ0XCkBYwVBIYKhGGdIChssBQmTCkBwxVBIYqhCEDYKgqMFQlDBkBQzWBoRphyAQYqgsM1QlDZsBQQ2CoQRiyAIaaAkNNwpAVMNQSGGoRhmyAobbAUJswZAcMdQSGOoQhB2CoKzDUJQw5AUM9gaEeYcgFGOoLDPUJQ27AECAwBBCGPIChgcDQgDDkBQyBAkMgYcgHGBoKDA0JQ37AECQwBBGGAoChkcDQiDAUBAzBAkMwYSgEGBoLDI0JQ2HAECIwhBCGIoChicDQhDAUBQxNBYamhKEYYDAFBpMwFAcMoQJDKGEoARiaCQzNCENJwBAmMIQRhlKAIVxgCCcMpQFDhMAQQRjKAIZIgSGSMJQFDFECQxRhKAcYogWGaMJQHjA0FxiaE4YKgKGFwNCCMFQEDC0FhpaEoRJgaCUwtCIMlQFDa4GhNWGoAhjaCAxtCENVwNBWYGhLGKoBhnYCQzvCUB0wtBcY2hOGGoChg8DQgTDUBAwdBYaOhKEWYOgkMHQiDLUBQ2eBoTNhqAMYuggMXQhDXcDQVWDoShjqAYZuAkM3wlAfMHQXGLoThgDA0ENg6EEYGgCGngJDT8IQCBh6CQy9CENDwNBbYOhNGIIAQx+BoQ9haAQY+goMfQlDMGDoJzD0IwyNAUN/gaE/YQgBDAMEhgGEoQlgGCgwDCQMTQHDIIFhEGEwAcNggWEwYQgFDEMEhiGEoRlgGCowDCUMYYBhmMAwjDCEA4bhAsNwwhABGEYIDCMIQyRgGCkwjCQMUYBhlMAwijBEA4bRAsNowtAcMIwRGMYQhhaAYazAMJYwtAQM4wSGcYShFWAYLzCMJwytAcMEgWECYWgDGCYKDBMJQ1vAMElgmEQY2gGGyQLDZMLQHjBMERimEIYOgGGqwDCVMHQEDNMEhmmEoRNgmC4wTCcMnQHDDIFhBmHoAhhmCgwzCUNXwDBLYJhFGLoBhtkCw2zC0B0wzBEY5hCGHoBhrsAwlzD0BAzzBIZ5hKEXYJgvMMwnDL0BwwKBYQFh6AMYFgoMCwlDX8CwSGBYRBj6AYbFAsNiwtAfMCwRGJYQhgGAYanAsJQwDAQMywSGZYRhEGBYLjAsJwyDAcMKgWEFYRgCGFYKDCsJw1DAsEpgWEUYhgGG1QLDasIwHDCsERjWEIYRgGGtwLCWMIwEDOsEhnWEYRRgWC8wrCcMowHDBoFhA2EYAxg2CgwbCcNYwLBJYNhEGMYBhs0Cw2bCMB4wbBEYthCGCYBhq8CwlTBMBAzbBIZthGESYNguMGwnDJMBww6BYQdhmAIYdgoMOwnDVMCwS2DYRRimAYbdAsNuwjAdMOwRGPYQhhmAYa/AsJcwzAQM+wSGfYRhFmDYLzDsJwyzAcMBgeEAYZgDGA4KDAcJw1zAcEhgOEQY5gGGwwLDYcIwHzAcERiOEIYFgOGowHCUMCwEDMcEhmOEYRFgOC4wHCcMiwHDCYHhBGFYAhhOCgwnCcNSwHBKYDhFGJYBhtMCw2nCsBwwnBEYzhCGFYDhrMBwljCsBAznBIZzhGEVYDgvMJwnDKsBwwWB4QJhWAMYLgoMFwnDWsBwSWC4RBjWAYbLAsNlwrAeMFwRGK4Qhg2A4arAcJUwbAQM1wSGa4RhE2C4LjBcJwybAcMNgeEGYdgCGG4KDDcJw1bAcEtguEUYtgGG2wLDbcKwHTDcERjuEIYdgOGuwHCXMOwEDPcEhnuEYRdguC8w3CcMuwHDA4HhAWHYAxgeCgwPCcNewPBIYHhEGPYBhscCw2PCsB8wPBEYnhCGA4DhqcDwlDAcBAzPBIZnhOEQYHguMDwnDIcBwwuB4QVhOAIYXgoMLwnDUcDwSmB4RRiOAYbXAsNrwnAcMLwRGN4QhhOA4a3A8JYwnAQM7wSGd4ThFGB4LzC8JwynAcMHgeEDYTgDGD4KDB8Jw1nA8Elg+EQYzgGGzwLDZ8JwHjB8ERi+EIYLgOGrwPCVMFwEDN8Ehm+E4RJg+C4wfCcMlwHDD4HhB2G4Ahh+Cgw/CcNVwPBLYPhFGK4Bht8Cw2/CcB0w/BEY/hCGG4Dhr8DwlzDcBAxGY+cNVgM13AIMMQSGGIThNmBwERhcCMMdwBBTYIhJGO4CBleBwZUw3AMMsQSGWIThPmBwExjcCMMDwBBbYIhNGB4CBneBwZ0wPAIMcQSGOIThMWDwEBg8CMMTwBBXYIhLGJ4CBk+BwZMwPAMM8QSGeIThOWDwEhi8CMMLwBBfYIhPGF4CBm+BwZswvAIMCQSGBIThNWBIKDAkJAxvAEMigSERYXgLGBILDIkJwzvAkERgSEIY3gOGpAJDUsLwATAkExiSEYaPgMFHYPAhDJ8AQ3KBITlh+AwYUggMKQjDF8DgKzD4EoavgCGlwJCSMHwDDH4Cgx9h+A4YUgkMqQjDD8CQWmBITRh+AgZ/gcGfMPwCDGkEhjSE4TdgSCswpCUMfwBDOoEhHWH4CxjSCwzpCYMRz74hg8CQgTDEAAwZBYaMhMEFMGQSGDIRhpiAIbPAkJkwuAKGLAJDFsIQCzBkFRiyEgY3wJBNYMhGGGIDhuwCQ3bC4A4YcggMOQhDHMCQU2DISRg8AEMugSEXYYgLGHILDLkJgydgyCMw5CEM8QBDXoEhL2HwAgz5BIZ8hCE+YMgvMOQnDN6AoYDAUIAwJAAMBQWGgoQhIWAoJDAUIgyJAENhgaEwYUgMGIoIDEUIQxLAUFRgKEoYkgKGYgJDMcKQDDAUFxiKEwYfwFBCYChBGJIDhpICQ0nCkAIwlBIYShEGX8BQWmAoTRhSAoYyAkMZwuAHGMoKDGUJQyrAUE5gKEcYUgOG8gJDecLgDxgqCAwVCEMawFBRYKhIGNIChkoCQyXCkA4wVBYYKhOG9IChisBQhTBkAAxVBYaqhCEjYKgmMFQjDJkAQ3WBoTphyAwYaggMNQhDFsBQU2CoSRiyAoZaAkMtwpANMNQWGGoThuyAoY7AUIcw5AAMdQWGuoQhJ2CoJzDUIwy5AEN9gaE+YcgNGAIEhgDCkAcwNBAYGhCGvIAhUGAIJAz5AENDgaEhYcgPGIIEhiDCUAAwNBIYGhGGgoAhWGAIJgyFAENjgaExYSgMGEIEhhDCUAQwNBEYmhCGooChqcDQlDAUAwymwGAShuKAIVRgCCUMJQBDM4GhGWEoCRjCBIYwwlAKMIQLDOGEoTRgiBAYIghDGcAQKTBEEoaygCFKYIgiDOUAQ7TAEE0YygOG5gJDc8JQATC0EBhaEIaKgKGlwNCSMFQCDK0EhlaEoTJgaC0wtCYMVQBDG4GhDWGoChjaCgxtCUM1wNBOYGhHGKoDhvYCQ3vCUAMwdBAYOhCGmoCho8DQkTDUAgydBIZOhKE2YOgsMHQmDHUAQxeBoQthqAsYugoMXQlDPcDQTWDoRhjqA4buAkN3whAAGHoIDD0IQwPA0FNg6EkYAgFDL4GhF2FoCBh6Cwy9CUMQYOgjMPQhDI0AQ1+BoS9hCAYM/QSGfoShMWDoLzD0JwwhgGGAwDCAMDQBDAMFhoGEoSlgGCQwDCIMJmAYLDAMJgyhgGGIwDCEMDQDDEMFhqGEIQwwDBMYhhGGcMAwXGAYThgiAMMIgWEEYYgEDCMFhpGEIQowjBIYRhGGaMAwWmAYTRiaA4YxAsMYwtACMIwVGMYShpaAYZzAMI4wtAIM4wWG8YShNWCYIDBMIAxtAMNEgWEiYWgLGCYJDJMIQzvAMFlgmEwY2gOGKQLDFMLQATBMFRimEoaOgGGawDCNMHQCDNMFhumEoTNgmCEwzCAMXQDDTIFhJmHoChhmCQyzCEM3wDBbYJhNGLoDhjkCwxzC0AMwzBUY5hKGnoBhnsAwjzD0AgzzBYb5hKE3YFggMCwgDH0Aw0KBYSFh6AsYFgkMiwhDP8CwWGBYTBj6A4YlAsMSwjAAMCwVGJYShoGAYZnAsIwwDAIMywWG5YRhMGBYITCsIAxDAMNKgWElYRgKGFYJDKsIwzDAsFpgWE0YhgOGNQLDGsIwAjCsFRjWEoaRgGGdwLCOMIwCDOsFhvWEYTRg2CAwbCAMYwDDRoFhI2EYCxg2CQybCMM4wLBZYNhMGMYDhi0CwxbCMAEwbBUYthKGiYBhm8CwjTBMAgzbBYbthGEyYNghMOwgDFMAw06BYSdhmAoYdgkMuwjDNMCwW2DYTRimA4Y9AsMewjADMOwVGPYShpmAYZ/AsI8wzAIM+wWG/YRhNmA4IDAcIAxzAMNBgeEgYZgLGA4JDIcIwzzAcFhgOEwY5gOGIwLDEcKwADAcFRiOEoaFgOGYwHCMMCwCDMcFhuOEYTFgOCEwnCAMSwDDSYHhJGFYChhOCQynCMMywHBaYDhNGJYDhjMCwxnCsAIwnBUYzhKGlYDhnMBwjjCsAgznBYbzhGE1YLggMFwgDGsAw0WB4SJhWAsYLgkMlwjDOsBwWWC4TBjWA4YrAsMVwrABMFwVGK4Sho2A4ZrAcI0wbAIM1wWG64RhM2C4ITDcIAxbAMNNgeEmYdgKGG4JDLcIwzbAcFtguE0YtgOGOwLDHcKwAzDcFRjuEoadgOGewHCPMOwCDPcFhvuEYTdgeCAwPCAMewDDQ4HhIWHYCxgeCQyPCMM+wPBYYHhMGPYDhicCwxPCcAAwPBUYnhKGg4DhmcDwjDAcAgzPBYbnhOEwYHghMLwgDEcAw0uB4SVhOAoYXgkMrwjDMcDwWmB4TRiOA4Y3AsMbwnACMLwVGN4ShpOA4Z3A8I4wnAIM7wWG94ThNGD4IDB8IAxnAMNHgeEjYTgLGD4JDJ8IwznA8Flg+EwYzgOGLwLDF8JwATB8FRi+EoaLgOGbwPCNMFwCDN8Fhu+E4TJg+CEw/CAMVwDDT4HhJ2G4Chh+CQy/CMM1wPBbYPhNGK4Dhj8Cwx/CcAMw/BUY/hKGm4DBCHHeYDVQwy3AEENgiEEYbgMGF4HBhTDcAQwxBYaYhOEuYHAVGFwJwz3AEEtgiEUY7gMGN4HBjTA8AAyxBYbYhOEhYHAXGNwJwyPAEEdgiEMYHgMGD4HBgzA8AQxxBYa4hOEpYPAUGDwJwzPAEE9giEcYngMGL4HBizC8AAzxBYb4hOElYPAWGLwJwyvAkEBgSEAYXgOGhAJDQsLwBjAkEhgSEYa3gCGxwJCYMLwDDEkEhiSE4T1gSCowJCUMHwBDMoEhGWH4CBh8BAYfwvAJMCQXGJIThs+AIYXAkIIwfAEMvgKDL2H4ChhSCgwpCcM3wOAnMPgRhu+AIZXAkIow/AAMqQWG1IThJ2DwFxj8CcMvwJBGYEhDGH4DhrQCQ1rC8AcwpBMY0hGGv4AhvcCQnjAYXvYNGRw2uHj/s0MAbojpbd+QUbBDRmIHV8CQSWDIRBhiAYbMAkNmwuAGGLIIDFkIQ2zAkFVgyEoY3AFDNoEhG2GIAxiyCwzZCYMHYMghMOQgDHEBQ06BISdh8AQMuQSGXIQhHmDILTDkJgxegCGPwJCHMMQHDHkFhryEwRsw5BMY8hGGBIAhv8CQnzAkBAwFBIYChCERYCgoMBQkDIkBQyGBoRBhSAIYCgsMhQlDUsBQRGAoQhiSAYaiAkNRwuADGIoJDMUIQ3LAUFxgKE4YUgCGEgJDCcLgCxhKCgwlCUNKwFBKYChFGPwAQ2mBoTRhSAUYyggMZQhDasBQVmAoSxj8AUM5gaEcYUgDGMoLDOUJQ1rAUEFgqEAY0gGGigJDRcKQHjBUEhgqEYYMgKGywFCZMGQEDFUEhiqEIRNgqCowVCUMmQFDNYGhGmHIAhiqCwzVCUNWwFBDYKhBGLIBhpoCQ03CkB0w1BIYahGGHIChtsBQmzDkBAx1BIY6hCEXYKgrMNQlDLkBQz2BoR5hyAMY6gsM9QlDXsAQIDAEEIZ8gKGBwNCAMOQHDIECQyBhKAAYGgoMDQlDQcAQJDAEEYZCgKGRwNCIMBQGDMECQzBhKAIYGgsMjQlDUcAQIjCEEIZigKGJwNCEMBQHDE0FhqaEoQRgMAUGkzCUBAyhAkMoYSgFGJoJDM0IQ2nAECYwhBGGMoAhXGAIJwxlAUOEwBBBGMoBhkiBIZIwlAcMUQJDFGGoABiiBYZowlARMDQXGJoThkqAoYXA0IIwVAYMLQWGloShCmBoJTC0IgxVAUNrgaE1YagGGNoIDG0IQ3XA0FZgaEsYagCGdgJDO8JQEzC0FxjaE4ZagKGDwNCBMNQGDB0Fho6EoQ5g6CQwdCIMdQFDZ4GhM2GoBxi6CAxdCEN9wNBVYOhKGAIAQzeBoRthaAAYugsM3QlDIGDoITD0IAwNAUNPgaEnYQgCDL0Ehl6EoRFg6C0w9CYMwYChj8DQhzA0Bgx9BYa+hCEEMPQTGPoRhiaAob/A0J8wNAUMAwSGAYTBBAwDBYaBhCEUMAwSGAYRhmaAYbDAMJgwhAGGIQLDEMIQDhiGCgxDCUMEYBgmMAwjDJGAYbjAMJwwRAGGEQLDCMIQDRhGCgwjCUNzwDBKYBhFGFoAhtECw2jC0BIwjBEYxhCGVoBhrMAwljC0BgzjBIZxhKENYBgvMIwnDG0BwwSBYQJhaAcYJgoMEwlDe8AwSWCYRBg6AIbJAsNkwtARMEwRGKYQhk6AYarAMJUwdAYM0wSGaYShC2CYLjBMJwxdAcMMgWEGYegGGGYKDDMJQ3fAMEtgmEUYegCG2QLDbMLQEzDMERjmEIZegGGuwDCXMPQGDPMEhnmEoQ9gmC8wzCcMfQHDAoFhAWHoBxgWCgwLCUN/wLBIYFhEGAYAhsUCw2LCMBAwLBEYlhCGQYBhqcCwlDAMBgzLBIZlhGEIYFguMCwnDEMBwwqBYQVhGAYYVgoMKwnDcMCwSmBYRRhGAIbVAsNqwjASMKwRGNYQhlGAYa3AsJYwjAYM6wSGdYRhDGBYLzCsJwxjAcMGgWEDYRgHGDYKDBsJw3jAsElg2EQYJgCGzQLDZsIwETBsERi2EIZJgGGrwLCVMEwGDNsEhm2EYQpg2C4wbCcMUwHDDoFhB2GYBhh2Cgw7CcN0wLBLYNhFGGYAht0Cw27CMBMw7BEY9hCGWYBhr8CwlzDMBgz7BIZ9hGEOYNgvMOwnDHMBwwGB4QBhmAcYDgoMBwnDfMBwSGA4RBgWAIbDAsNhwrAQMBwRGI4QhkWA4ajAcJQwLAYMxwSGY4RhCWA4LjAcJwxLAcMJgeEEYVgGGE4KDCcJw3LAcEpgOEUYVgCG0wLDacKwEjCcERjOEIZVgOGswHCWMKwGDOcEhnOEYQ1gOC8wnCcMawHDBYHhAmFYBxguCgwXCcN6wHBJYLhEGDYAhssCw2XCsBEwXBEYrhCGTYDhqsBwlTBsBgzXBIZrhGELYLguMFwnDFsBww2B4QZh2AYYbgoMNwnDdsBwS2C4RRh2AIbbAsNtwrATMNwRGO4Qhl2A4a7AcJcw7AYM9wSGe4RhD2C4LzDcJwx7AcMDgeEBYdgHGB4KDA8Jw37A8EhgeEQYDgCGxwLDY8JwEDA8ERieEIZDgOGpwPCUMBwGDM8EhmeE4QhgeC4wPCcMRwHDC4HhBWE4BhheCgwvCcNxwPBKYHhFGE4AhtcCw2vCcBIwvBEY3hCGU4DhrcDwljCcBgzvBIZ3hOEMYHgvMLwnDGcBwweB4QNhOAcYPgoMHwnDecDwSWD4RBguAIbPAsNnwnARMHwRGL4QhkuA4avA8JUwXAYM3wSGb4ThCmD4LjB8JwxXAcMPgeEHYbgGGH4KDD8Jw3XA8Etg+EUYbgCG3wLDb8JwEzD8ERj+EIZbgOGvwPCXMNwGDEYT5w1WAzXcAQwxBIYYhOEuYHARGFwIwz3AEFNgiEkY7gMGV4HBlTA8AAyxBIZYhOEhYHATGNwIwyPAEFtgiE0YHgMGd4HBnTA8AQxxBIY4hOEpYPAQGDwIwzPAEFdgiEsYngMGT4HBkzC8AAzxBIZ4hOElYPASGLwIwyvAEF9giE8YXgMGb4HBmzC8AQwJBIYEhOEtYEgoMCQkDO8AQyKBIRFheA8YEgsMiQnDB8CQRGBIQhg+AoakAkNSwvAJMCQTGJIRhs+AwUdg8CEMXwBDcoEhOWH4ChhSCAwpCMM3wOArMPgShu+AIaXAkJIw/AAMfgKDH2H4CRhSCQypCMMvwJBaYEhNGH4DBn+BwZ8w/AEMaQSGNIThL2BIKzCkJQxGAvuGdAJDOsIQAzCkFxjSEwYXwJBBYMhAGGIChowCQ0bC4AoYMgkMmQhDLMCQWWDITBjcAEMWgSELYYgNGLIKDFkJgztgyCYwZCMMcQBDdoEhO2HwAAw5BIYchCEuYMgpMOQkDJ6AIZfAkIswxAMMuQWG3ITBCzDkERjyEIb4gCGvwJCXMHgDhnwCQz7CkAAw5BcY8hOGhIChgMBQgDAkAgwFBYaChCExYCgkMBQiDEkAQ2GBoTBhSAoYiggMRQhDMsBQVGAoShh8AEMxgaEYYUgOGIoLDMUJQwrAUEJgKEEYfAFDSYGhJGFICRhKCQylCIMfYCgtMJQmDKkAQxmBoQxhSA0YygoMZQmDP2AoJzCUIwxpAEN5gaE8YUgLGCoIDBUIQzrAUFFgqEgY0gOGSgJDJcKQATBUFhgqE4aMgKGKwFCFMGQCDFUFhqqEITNgqCYwVCMMWQBDdYGhOmHIChhqCAw1CEM2wFBTYKhJGLIDhloCQy3CkAMw1BYYahOGnIChjsBQhzDkAgx1BYa6hCE3YKgnMNQjDHkAQ32BoT5hyAsYAgSGAMKQDzA0EBgaEIb8gCFQYAgkDAUAQ0OBoSFhKAgYggSGIMJQCDA0EhgaEYbCgCFYYAgmDEUAQ2OBoTFhKAoYQgSGEMJQDDA0ERiaEIbigKGpwNCUMJQADKbAYBKGkoAhVGAIJQylAEMzgaEZYSgNGMIEhjDCUAYwhAsM4YShLGCIEBgiCEM5wBApMEQShvKAIUpgiCIMFQBDtMAQTRgqAobmAkNzwlAJMLQQGFoQhsqAoaXA0JIwVAEMrQSGVoShKmBoLTC0JgzVAEMbgaENYagOGNoKDG0JQw3A0E5gaEcYagKG9gJDe8JQCzB0EBg6EIbagKGjwNCRMNQBDJ0Ehk6EoS5g6CwwdCYM9QBDF4GhC2GoDxi6CgxdCUMAYOgmMHQjDA0AQ3eBoTthCAQMPQSGHoShIWDoKTD0JAxBgKGXwNCLMDQCDL0Fht6EIRgw9BEY+hCGxoChr8DQlzCEAIZ+AkM/wtAEMPQXGPoThqaAYYDAMIAwmIBhoMAwkDCEAoZBAsMgwtAMMAwWGAYThjDAMERgGEIYwgHDUIFhKGGIAAzDBIZhhCESMAwXGIYThijAMEJgGEEYogHDSIFhJGFoDhhGCQyjCEMLwDBaYBhNGFoChjECwxjC0AowjBUYxhKG1oBhnMAwjjC0AQzjBYbxhKEtYJggMEwgDO0Aw0SBYSJhaA8YJgkMkwhDB8AwWWCYTBg6AoYpAsMUwtAJMEwVGKYShs6AYZrAMI0wdAEM0wWG6YShK2CYITDMIAzdAMNMgWEmYegOGGYJDLMIQw/AMFtgmE0YegKGOQLDHMLQCzDMFRjmEobegGGewDCPMPQBDPMFhvmEoS9gWCAwLCAM/QDDQoFhIWHoDxgWCQyLCMMAwLBYYFhMGAYChiUCwxLCMAgwLBUYlhKGwYBhmcCwjDAMAQzLBYblhGEoYFghMKwgDMMAw0qBYSVhGA4YVgkMqwjDCMCwWmBYTRhGAoY1AsMawjAKMKwVGNYShtGAYZ3AsI4wjAEM6wWG9YRhLGDYIDBsIAzjAMNGgWEjYRgPGDYJDJsIwwTAsFlg2EwYJgKGLQLDFsIwCTBsFRi2EobJgGGbwLCNMEwBDNsFhu2EYSpg2CEw7CAM0wDDToFhJ2GYDhh2CQy7CMMMwLBbYNhNGGYChj0Cwx7CMAsw7BUY9hKG2YBhn8CwjzDMAQz7BYb9hGEuYDggMBwgDPMAw0GB4SBhmA8YDgkMhwjDAsBwWGA4TBgWAoYjAsMRwrAIMBwVGI4ShsWA4ZjAcIwwLAEMxwWG44RhKWA4ITCcIAzLAMNJgeEkYVgOGE4JDKcIwwrAcFpgOE0YVgKGMwLDGcKwCjCcFRjOEobVgOGcwHCOMKwBDOcFhvOEYS1guCAwXCAM6wDDRYHhImFYDxguCQyXCMMGwHBZYLhMGDYChisCwxXCsAkwXBUYrhKGzYDhmsBwjTBsAQzXBYbrhGErYLghMNwgDNsAw02B4SZh2A4YbgkMtwjDDsBwW2C4TRh2AoY7AsMdwrALMNwVGO4Sht2A4Z7AcI8w7AEM9wWG+4RhL2B4IDA8IAz7AMNDgeEhYdgPGB4JDI8IwwHA8FhgeEwYDgKGJwLDE8JwCDA8FRieEobDgOGZwPCMMBwBDM8FhueE4ShgeCEwvCAMxwDDS4HhJWE4DhheCQyvCMMJwPBaYHhNGE4ChjcCwxvCcAowvBUY3hKG04DhncDwjjCcAQzvBYb3hOEsYPggMHwgDOcAw0eB4SNhOA8YPgkMnwjDBcDwWWD4TBguAoYvAsMXwnAJMHwVGL4ShsuA4ZvA8I0wXAEM3wWG74ThKmD4ITD8IAzXAMNPgeEnYbgOGH4JDL8Iww3A8Ftg+E0YbgKGPwLDH8JwCzD8FRj+EobbgMFo6rzBaqCGO4AhhsAQgzDcBQwuAoMLYbgHGGIKDDEJw33A4CowuBKGB4AhlsAQizA8BAxuAoMbYXgEGGILDLEJw2PA4C4wuBOGJ4AhjsAQhzA8BQweAoMHYXgGGOIKDHEJw3PA4CkweBKGF4AhnsAQjzC8BAxeAoMXYXgFGOILDPEJw2vA4C0weBOGN4AhgcCQgDC8BQwJBYaEhOEdYEgkMCQiDO8BQ2KBITFh+AAYkggMSQjDR8CQVGBIShg+AYZkAkMywvAZMPgIDD6E4QtgSC4wJCcMXwFDCoEhBWH4Bhh8BQZfwvAdMKQUGFIShh+AwU9g8CMMPwFDKoEhFWH4BRhSCwypCcNvwOAvMPgThj+AIY3AkIYw/AUMaQWGtITBSGjfkE5gSEcYYgCG9AJDesLgAhgyCAwZCENMwJBRYMhIGFwBQyaBIRNhiAUYMgsMmQmDG2DIIjBkIQyxAUNWgSErYXAHDNkEhmyEIQ5gyC4wZCcMHoAhh8CQgzDEBQw5BYachMETMOQSGHIRhniAIbfAkJsweAGGPAJDHsIQHzDkFRjyEgZvwJBPYMhHGBIAhvwCQ37CkBAwFBAYChCGRIChoMBQkDAkBgyFBIZChCEJYCgsMBQmDEkBQxGBoQhhSAYYigoMRQmDD2AoJjAUIwzJAUNxgaE4YUgBGEoIDCUIgy9gKCkwlCQMKQFDKYGhFGHwAwylBYbShCEVYCgjMJQhDKkBQ1mBoSxh8AcM5QSGcoQhDWAoLzCUJwxpAUMFgaECYUgHGCoKDBUJQ3rAUElgqEQYMgCGygJDZcKQETBUERiqEIZMgKGqwFCVMGQGDNUEhmqEIQtgqC4wVCcMWQFDDYGhBmHIBhhqCgw1CUN2wFBLYKhFGHIAhtoCQ23CkBMw1BEY6hCGXIChrsBQlzDkBgz1BIZ6hCEPYKgvMNQnDHkBQ4DAEEAY8gGGBgJDA8KQHzAECgyBhKEAYGgoMDQkDAUBQ5DAEEQYCgGGRgJDI8JQGDAECwzBhKEIYGgsMDQmDEUBQ4jAEEIYigGGJgJDE8JQHDA0FRiaEoYSgMEUGEzCUBIwhAoMoYShFGBoJjA0IwylAUOYwBBGGMoAhnCBIZwwlAUMEQJDBGEoBxgiBYZIwlAeMEQJDFGEoQJgiBYYoglDRcDQXGBoThgqAYYWAkMLwlAZMLQUGFoShiqAoZXA0IowVAUMrQWG1oShGmBoIzC0IQzVAUNbgaEtYagBGNoJDO0IQ03A0F5gaE8YagGGDgJDB8JQGzB0FBg6EoY6gKGTwNCJMNQFDJ0Fhs6EoR5g6CIwdCEM9QFDV4GhK2EIAAzdBIZuhKEBYOguMHQnDIGAoYfA0IMwNAQMPQWGnoQhCDD0Ehh6EYZGgKG3wNCbMAQDhj4CQx/C0Bgw9BUY+hKGEMDQT2DoRxiaAIb+AkN/wtAUMAwQGAYQBhMwDBQYBhKGUMAwSGAYRBiaAYbBAsNgwhAGGIYIDEMIQzhgGCowDCUMEYBhmMAwjDBEAobhAsNwwhAFGEYIDCMIQzRgGCkwjCQMzQHDKIFhFGFoARhGCwyjCUNLwDBGYBhDGFoBhrECw1jC0BowjBMYxhGGNoBhvMAwnjC0BQwTBIYJhKEdYJgoMEwkDO0BwySBYRJh6AAYJgsMkwlDR8AwRWCYQhg6AYapAsNUwtAZMEwTGKYRhi6AYbrAMJ0wdAUMMwSGGYShG2CYKTDMJAzdAcMsgWEWYegBGGYLDLMJQ0/AMEdgmEMYegGGuQLDXMLQGzDMExjmEYY+gGG+wDCfMPQFDAsEhgWEoR9gWCgwLCQM/QHDIoFhEWEYABgWCwyLCcNAwLBEYFhCGAYBhqUCw1LCMBgwLBMYlhGGIYBhucCwnDAMBQwrBIYVhGEYYFgpMKwkDMMBwyqBYRVhGAEYVgsMqwnDSMCwRmBYQxhGAYa1AsNawjAaMKwTGNYRhjGAYb3AsJ4wjAUMGwSGDYRhHGDYKDBsJAzjAcMmgWETYZgAGDYLDJsJw0TAsEVg2EIYJgGGrQLDVsIwGTBsExi2EYYpgGG7wLCdMEwFDDsEhh2EYRpg2Ckw7CQM0wHDLoFhF2GYARh2Cwy7CcNMwLBHYNhDGGYBhr0Cw17CMBsw7BMY9hGGOYBhv8CwnzDMBQwHBIYDhGEeYDgoMBwkDPMBwyGB4RBhWAAYDgsMhwnDQsBwRGA4QhgWAYajAsNRwrAYMBwTGI4RhiWA4bjAcJwwLAUMJwSGE4RhGWA4KTCcJAzLAcMpgeEUYVgBGE4LDKcJw0rAcEZgOEMYVgGGswLDWcKwGjCcExjOEYY1gOG8wHCeMKwFDBcEhguEYR1guCgwXCQM6wHDJYHhEmHYABguCwyXCcNGwHBFYLhCGDYBhqsCw1XCsBkwXBMYrhGGLYDhusBwnTBsBQw3BIYbhGEbYLgpMNwkDNsBwy2B4RZh2AEYbgsMtwnDTsBwR2C4Qxh2AYa7AsNdwrAbMNwTGO4Rhj2A4b7AcJ8w7AUMDwSGB4RhH2B4KDA8JAz7AcMjgeERYTgAGB4LDI8Jw0HA8ERgeEIYDgGGpwLDU8JwGDA8ExieEYYjgOG5wPCcMBwFDC8EhheE4RhgeCkwvCQMxwHDK4HhFWE4ARheCwyvCcNJwPBGYHhDGE4BhrcCw1vCcBowvBMY3hGGM4DhvcDwnjCcBQwfBIYPhOEcYPgoMHwkDOcBwyeB4RNhuAAYPgsMnwnDRcDwRWD4QhguAYavAsNXwnAZMHwTGL4RhiuA4bvA8J0wXAUMPwSGH4ThGmD4KTD8JAzXAcMvgeEXYbgBGH4LDL8Jw03A8Edg+EMYbgGGvwLDX8JwGzAYpvMGq4Ea7gCGGKbzBquBGu4CBhfTeYPVQA33AENM03mD1UAN9wGDq+m8wWqghgeAIZbpvMFqoIaHgMHNdN5gNVDDI8AQ23TeYDVQw2PA4G46b7AaqOEJYIhjOm+wGqjhKWDwMJ03WA3U8AwwxDWdN1gN1PAcMHiazhusBmp4ARjimc4brAZqeAkYvEznDVYDNbwCDPFN5w1WAzW8BgzepvMGq4Ea3gCGBKbzBquBGt4ChoSm8wargRreAYZEpvMGq4Ea3gOGxKbzBquBGj4AhiSm8wargRo+AoakpvMGq4EaPgGGZKbzBquBGj4DBh/TeYPVQA1fAENy03mD1UANXwFDCtN5g9VADd8Ag6/pvMFqoIbvgCGl6bzBaqCGH4DBz3TeYDVQw0/AkMp03mA1UMMvwJDadN5gNVDDb8DgbzpvsBqo4Q9gSGM6b7AaqOEvYEhrOm+wGqjBSGTfkM503mA1UEMMwJDedN5gNVCDC2DIYDpvsBqoISZgyGg6b7AaqMEVMGQynTdYDdQQCzBkNp03WA3U4AYYspjOG6wGaogNGLKazhusBmpwBwzZTOcNVgM1xAEM2U3nDVYDNXgAhhym8wargRriAoacpvMGq4EaPAFDLtN5g9VADfEAQ27TeYPVQA1egCGP6bzBaqCG+IAhr+m8wWqgBm/AkM903mA1UEMCwJDfdN5gNVBDQsBQwHTeYDVQQyLAUNB03mA1UENiwFDIdN5gNVBDEsBQ2HTeYDVQQ1LAUMR03mA1UEMywFDUdN5gNVCDD2AoZjpvsBqoITlgKG46b7AaqCEFYChhOm+wGqjBFzCUNJ03WA3UkBIwlDKdN1gN1OAHGEqbzhusBmpIBRjKmM4brAZqSA0YyprOG6wGavAHDOVM5w1WAzWkAQzlTecNVgM1pAUMFUznDVYDNaQDDBVN5w1WAzWkBwyVTOcNVgM1ZAAMlU3nDVYDNWQEDFVM5w1WAzVkAgxVTecNVgM1ZAYM1UznDVYDNWQBDNVN5w1WAzVkBQw1TOcNVgM1ZAMMNU3nDVYDNWQHDLVM5w1WAzXkAAy1TecNVgM15AQMdUznDVYDNeQCDHVN5w1WAzXkBgz1TOcNVgM15AEM9U3nDVYDNeQFDAGm8wargRryAYYGpvMGq4Ea8gOGQNN5g9VADQUAQ0PTeYPVQA0FAUOQ6bzBaqCGQoChkem8wWqghsKAIdh03mA1UEMRwNDYdN5gNVBDUcAQYjpvsBqooRhgaGI6b7AaqKE4YGhqOm+wGqihBGAwTecNVgM1lAQMoabzBquBGkoBhmam8wargRpKA4Yw03mD1UANZQBDuOm8wWqghrKAIcJ03mA1UEM5wBBpOm+wGqihPGCIMp03WA3UUAEwRJvOG6wGaqgIGJqbzhusBmqoBBhamM4brAZqqAwYWprOG6wGaqgCGFqZzhusBmqoChham84brAZqqAYY2pjOG6wGaqgOGNqazhusBmqoARjamc4brAZqqAkY2pvOG6wGaqgFGDqYzhusBmqoDRg6ms4brAZqqAMYOpnOG6wGaqgLGDqbzhusBmqoBxi6mM4brAZqqA8YuprOG6wGaggADN1M5w1WAzU0AAzdTecNVgM1BAKGHqbzBquBGhoChp6m8wargRqCAEMv03mD1UANjQBDb9N5g9VADcGAoY/pvMFqoIbGgKGv6bzBaqCGEMDQz3TeYDVQQxPA0N903mA1UENTwDDAdN5gNVCDCRgGms4brAZqCAUMg0znDVYDNTQDDINN5w1WAzWEAYYhpvMGq4EawgHDUNN5g9VADRGAYZjpvMFqoIZIwDDcdN5gNVBDFGAYYTpvsBqoIRowjDSdN1gN1NAcMIwynTdYDdTQAjCMNp03WA3U0BIwjDGdN1gN1NAKMIw1nTdYDdTQGjCMM503WA3U0AYwjDedN1gN1NAWMEwwnTdYDdTQDjBMNJ03WA3U0B4wTDKdN1gN1NABMEw2nTdYDdTQETBMMZ03WA3U0AkwTDWdN1gN1NAZMEwznTdYDdTQBTBMN503WA3U0BUwzDCdN1gN1NANMMw0nTdYDdTQHTDMMp03WA3U0AMwzDadN1gN1NATMMwxnTdYDdTQCzDMNZ03WA3U0BswzDOdN1gN1NAHMMw3nTdYDdTQFzAsMJ03WA3U0A8wLDSdN1gN1NAfMCwynTdYDdQwADAsNp03WA3UMBAwLDGdN1gN1DAIMCw1nTdYDdQwGDAsM503WA3UMAQwLDedN1gN1DAUMKwwnTdYDdQwDDCsNJ03WA3UMBwwrDKdN1gN1DACMKw2nTdYDdQwEjCsMZ03WA3UMAowrDWdN1gN1DAaMKwznTdYDdQwBjCsN503WA3UMBYwbDCdN1gN1DAOMGw0nTdYDdQwHjBsMp03WA3UMAEwbDadN1gN1DARMGwxnTdYDdQwCTBsNZ03WA3UMBkwbDOdN1gN1DAFMGw3nTdYDdQwFTDsMJ03WA3UMA0w7DSdN1gN1DAdMOwynTdYDdQwAzDsNp03WA3UMBMw7DGdN1gN1DALMOw1nTdYDdQwGzDsM503WA3UMAcw7DedN1gN1DAXMBwwnTdYDdQwDzAcNJ03WA3UMB8wHDKdN1gN1LAAMBw2nTdYDdSwEDAcMZ03WA3UsAgwHDWdN1gN1LAYMBwznTdYDdSwBDAcN503WA3UsBQwnDCdN1gN1LAMMJw0nTdYDdSwHDCcMp03WA3UsAIwnDadN1gN1LASMJwxnTdYDdSwCjCcNZ03WA3UsBownDOdN1gN1LAGMJw3nTdYDdSwFjBcMJ03WA3UsA4wXDSdN1gN1LAeMFwynTdYDdSwATBcNp03WA3UsBEwXDGdN1gN1LAJMFw1nTdYDdSwGTBcM503WA3UsAUwXDedN1gN1LAVMNwwnTdYDdSwDTDcNJ03WA3UsB0w3DKdN1gN1LADMNw2nTdYDdSwEzDcMZ03WA3UsAsw3DWdN1gN1LAbMNwznTdYDdSwBzDcN503WA3UsBcwPDCdN1gN1LAPMDw0nTdYDdSwHzA8Mp03WA3UcAAwPDadN1gN1HAQMDwxnTdYDdRwCDA8NZ03WA3UcBgwPDOdN1gN1HAEMDw3nTdYDdRwFDC8MJ03WA3UcAwwvDSdN1gN1HAcMLwynTdYDdRwAjC8Np03WA3UcBIwvDGdN1gN1HAKMLw1nTdYDdRwGjC8M503WA3UcAYwvDedN1gN1HAWMHwwnTdYDdRwDjB8NJ03WA3UcB4wfDKdN1gN1HABMHw2nTdYDdRwETB8MZ03WA3UcAkwfDWdN1gN1HAZMHwznTdYDdRwBTB8N503WA3UcBUw/DCdN1gN1HANMPw0nTdYDdRwHTD8Mp03WA3UcAMw/DadN1gN1HATMPwxnTdYDdRwCzD8NZ03WA3UcBswGKHOG6wGargDGGIIDDEIw13A4CIwuBCGe4AhpsAQkzDcBwyuAoMrYXgAGGIJDLEIw0PA4CYwuBGGR4AhtsAQmzA8BgzuAoM7YXgCGOIIDHEIw1PA4CEweBCGZ4AhrsAQlzA8BwyeAoMnYXgBGOIJDPEIw0vA4CUweBGGV4AhvsAQnzC8BgzeAoM3YXgDGBIIDAkIw1vAkFBgSEgY3gGGRAJDIsLwHjAkFhgSE4YPgCGJwJCEMHwEDEkFhqSE4RNgSCYwJCMMnwGDj8DgQxi+AIbkAkNywvAVMKQQGFIQhm+AwVdg8CUM3wFDSoEhJWH4ARj8BAY/wvATMKQSGFIRhl+AIbXAkJow/AYM/gKDP2H4AxjSCAxpCMNfwJDWYYPhYxj/6+8gwN+L4WPfkE6wQzpiBxfAkF5gSE8YYgKGDAJDBsLgChgyCgwZCUMswJBJYMhEGNwAQ2aBITNhiA0YsggMWQiDO2DIKjBkJQxxAEM2gSEbYfAADNkFhuyEIS5gyCEw5CAMnoAhp8CQkzDEAwy5BIZchMELMOQWGHIThviAIY/AkIcweAOGvAJDXsKQADDkExjyEYaEgCG/wJCfMCQCDAUEhgKEITFgKCgwFCQMSQBDIYGhEGFIChgKCwyFCUMywFBEYChCGHwAQ1GBoShhSA4YigkMxQhDCsBQXGAoThh8AUMJgaEEYUgJGEoKDCUJgx9gKCUwlCIMqQBDaYGhNGFIDRjKCAxlCIM/YCgrMJQlDGkAQzmBoRxhSAsYygsM5QlDOsBQQWCoQBjSA4aKAkNFwpABMFQSGCoRhoyAobLAUJkwZAIMVQSGKoQhM2CoKjBUJQxZAEM1gaEaYcgKGKoLDNUJQzbAUENgqEEYsgOGmgJDTcKQAzDUEhhqEYacgKG2wFCbMOQCDHUEhjqEITdgqCsw1CUMeQBDPYGhHmHICxjqCwz1CUM+wBAgMAQQhvyAoYHA0IAwFAAMgQJDIGEoCBgaCgwNCUMhwBAkMAQRhsKAoZHA0IgwFAEMwQJDMGEoChgaCwyNCUMxwBAiMIQQhuKAoYnA0IQwlAAMTQWGpoShJGAwBQaTMJQCDKECQyhhKA0YmgkMzQhDGcAQJjCEEYaygCFcYAgnDOUAQ4TAEEEYygOGSIEhkjBUAAxRAkMUYagIGKIFhmjCUAkwNBcYmhOGyoChhcDQgjBUAQwtBYaWhKEqYGglMLQiDNUAQ2uBoTVhqA4Y2ggMbQhDDcDQVmBoSxhqAoZ2AkM7wlALMLQXGNoThtqAoYPA0IEw1AEMHQWGjoShLmDoJDB0Igz1AENngaEzYagPGLoIDF0IQwBg6CowdCUMDQBDN4GhG2EIBAzdBYbuhKEhYOghMPQgDEGAoafA0JMwNAIMvQSGXoQhGDD0Fhh6E4bGgKGPwNCHMIQAhr4CQ1/C0AQw9BMY+hGGpoChv8DQnzCYgGGAwDCAMIQChoECw0DC0AwwDBIYBhGGMMAwWGAYTBjCAcMQgWEIYYgADEMFhqGEIRIwDBMYhhGGKMAwXGAYThiiAcMIgWEEYWgOGEYKDCMJQwvAMEpgGEUYWgKG0QLDaMLQCjCMERjGEIbWgGGswDCWMLQBDOMEhnGEoS1gGC8wjCcM7QDDBIFhAmFoDxgmCgwTCUMHwDBJYJhEGDoChskCw2TC0AkwTBEYphCGzoBhqsAwlTB0AQzTBIZphKErYJguMEwnDN0AwwyBYQZh6A4YZgoMMwlDD8AwS2CYRRh6AobZAsNswtALMMwRGOYQht6AYa7AMJcw9AEM8wSGeYShL2CYLzDMJwz9AMMCgWEBYegPGBYKDAsJwwDAsEhgWEQYBgKGxQLDYsIwCDAsERiWEIbBgGGpwLCUMAwBDMsEhmWEYShgWC4wLCcMwwDDCoFhBWEYDhhWCgwrCcMIwLBKYFhFGEYChtUCw2rCMAowrBEY1hCG0YBhrcCwljCMAQzrBIZ1hGEsYFgvMKwnDOMAwwaBYQNhGA8YNgoMGwnDBMCwSWDYRBgmAobNAsNmwjAJMGwRGLYQhsmAYavAsJUwTAEM2wSGbYRhKmDYLjBsJwzTAMMOgWEHYZgOGHYKDDsJwwzAsEtg2EUYZgKG3QLDbsIwCzDsERj2EIbZgGGvwLCXMMwBDPsEhn2EYS5g2C8w7CcM8wDDAYHhAGGYDxgOCgwHCcMCwHBIYDhEGBYChsMCw2HCsAgwHBEYjhCGxYDhqMBwlDAsAQzHBIZjhGEpYDguMBwnDMsAwwmB4QRhWA4YTgoMJwnDCsBwSmA4RRhWAobTAsNpwrAKMJwRGM4QhtWA4azAcJYwrAEM5wSGc4RhLWA4LzCcJwzrAMMFgeECYVgPGC4KDBcJwwbAcElguEQYNgKGywLDZcKwCTBcERiuEIbNgOGqwHCVMGwBDNcEhmuEYStguC4wXCcM2wDDDYHhBmHYDhhuCgw3CcMOwHBLYLhFGHYChtsCw23CsAsw3BEY7hCG3YDhrsBwlzDsAQz3BIZ7hGEvYLgvMNwnDPsAwwOB4QFh2A8YHgoMDwnDAcDwSGB4RBgOAobHAsNjwnAIMDwRGJ4QhsOA4anA8JQwHAEMzwSGZ4ThKGB4LjA8JwzHAMMLgeEFYTgOGF4KDC8JwwnA8EpgeEUYTgKG1wLDa8JwCjC8ERjeEIbTgOGtwPCWMJwBDO8EhneE4SxgeC8wvCcM5wDDB4HhA2E4Dxg+CgwfCcMFwPBJYPhEGC4Chs8Cw2fCcAkwfBEYvhCGy4Dhq8DwlTBcAQzfBIZvhOEqYPguMHwnDNcAww+B4QdhuA4YfgoMPwnDDcDwS2D4RRhuAobfAsNvwnALMPwRGP4QhtuA4a/A8Jcw3AEMRjPnDVYDNdwFDDEEhhiE4R5gcBEYXAjDfcAQU2CISRgeAAZXgcGVMDwEDLEEhliE4RFgcBMY3AjDY8AQW2CITRieAAZ3gcGdMDwFDHEEhjiE4Rlg8BAYPAjDc8AQV2CISxheAAZPgcGTMLwEDPEEhniE4RVg8BIYvAjDa8AQX2CITxjeAAZvgcGbMLwFDAkEhgSE4R1gSCgwJCQM7wFDIoEhEWH4ABgSCwyJCcNHwJBEYEhCGD4BhqQCQ1LC8BkwJBMYkhGGL4DBR2DwIQxfAUNygSE5YfgGGFIIDCkIw3fA4Csw+BKGH4AhpcCQkjD8BAx+AoMfYfgFGFIJDKkIw2/AkFpgSE0Y/gAGf4HBnzD8BQxpBIY0hMFIbt+QVmBISxhiAIZ0AkM6wuACGNILDOkJQ0zAkEFgyEAYXAFDRoEhI2GIBRgyCQyZCIMbYMgsMGQmDLEBQxaBIQthcAcMWQWGrIQhDmDIJjBkIwwegCG7wJCdMMQFDDkEhhyEwRMw5BQYchKGeIAhl8CQizB4AYbcAkNuwhAfMOQRGPIQBm/AkFdgyEsYEgCGfAJDPsKQEDDkFxjyE4ZEgKGAwFCAMCQGDAUFhoKEIQlgKCQwFCIMSQFDYYGhMGFIBhiKCAxFCIMPYCgqMBQlDMkBQzGBoRhhSAEYigsMxQmDL2AoITCUIAwpAUNJgaEkYfADDKUEhlKEIRVgKC0wlCYMqQFDGYGhDGHwBwxlBYayhCENYCgnMJQjDGkBQ3mBoTxhSAcYKggMFQhDesBQUWCoSBgyAIZKAkMlwpARMFQWGCoThkyAoYrAUIUwZAYMVQWGqoQhC2CoJjBUIwxZAUN1gaE6YcgGGGoIDDUIQ3bAUFNgqEkYcgCGWgJDLcKQEzDUFhhqE4ZcgKGOwFCHMOQGDHUFhrqEIQ9gqCcw1CMMeQFDfYGhPmHIBxgCBIYAwpAfMDQQGBoQhgKAIVBgCCQMBQFDQ4GhIWEoBBiCBIYgwlAYMDQSGBoRhiKAIVhgCCYMRQFDY4GhMWEoBhhCBIYQwlAcMDQRGJoQhhKAoanA0JQwlAQMpsBgEoZSgCFUYAglDKUBQzOBoRlhKAMYwgSGMMJQFjCECwzhhKEcYIgQGCIIQ3nAECkwRBKGCoAhSmCIIgwVAUO0wBBNGCoBhuYCQ3PCUBkwtBAYWhCGKoChpcDQkjBUBQytBIZWhKEaYGgtMLQmDNUBQxuBoQ1hqAEY2goMbQlDTcDQTmBoRxhqAYb2AkN7wlAbMHQQGDoQhjqAoaPA0JEw1AUMnQSGToShHmDoLDB0Jgz1AUMXgaELYQgADF0Fhq6EoQFg6CYwdCMMgYChu8DQnTA0BAw9BIYehCEIMPQUGHoShkaAoZfA0IswBAOG3gJDb8LQGDD0ERj6EIYQwNBXYOhLGJoAhn4CQz/C0BQw9BcY+hMGEzAMEBgGEIZQwDBQYBhIGJoBhkECwyDCEAYYBgsMgwlDOGAYIjAMIQwRgGGowDCUMEQChmECwzDCEAUYhgsMwwlDNGAYITCMIAzNAcNIgWEkYWgBGEYJDKMIQ0vAMFpgGE0YWgGGMQLDGMLQGjCMFRjGEoY2gGGcwDCOMLQFDOMFhvGEoR1gmCAwTCAM7QHDRIFhImHoABgmCQyTCENHwDBZYJhMGDoBhikCwxTC0BkwTBUYphKGLoBhmsAwjTB0BQzTBYbphKEbYJghMMwgDN0Bw0yBYSZh6AEYZgkMswhDT8AwW2CYTRh6AYY5AsMcwtAbMMwVGOYShj6AYZ7AMI8w9AUM8wWG+YShH2BYIDAsIAz9AcNCgWEhYRgAGBYJDIsIw0DAsFhgWEwYBgGGJQLDEsIwGDAsFRiWEoYhgGGZwLCMMAwFDMsFhuWEYRhgWCEwrCAMwwHDSoFhJWEYARhWCQyrCMNIwLBaYFhNGEYBhjUCwxrCMBowrBUY1hKGMYBhncCwjjCMBQzrBYb1hGEcYNggMGwgDOMBw0aBYSNhmAAYNgkMmwjDRMCwWWDYTBgmAYYtAsMWwjAZMGwVGLYShimAYZvAsI0wTAUM2wWG7YRhGmDYITDsIAzTAcNOgWEnYZgBGHYJDLsIw0zAsFtg2E0YZgGGPQLDHsIwGzDsFRj2EoY5gGGfwLCPMMwFDPsFhv2EYR5gOCAwHCAM8wHDQYHhIGFYABgOCQyHCMNCwHBYYDhMGBYBhiMCwxHCsBgwHBUYjhKGJYDhmMBwjDAsBQzHBYbjhGEZYDghMJwgDMsBw0mB4SRhWAEYTgkMpwjDSsBwWmA4TRhWAYYzAsMZwrAaMJwVGM4ShjWA4ZzAcI4wrAUM5wWG84RhHWC4IDBcIAzrAcNFgeEiYdgAGC4JDJcIw0bAcFlguEwYNgGGKwLDFcKwGTBcFRiuEoYtgOGawHCNMGwFDNcFhuuEYRtguCEw3CAM2wHDTYHhJmHYARhuCQy3CMNOwHBbYLhNGHYBhjsCwx3CsBsw3BUY7hKGPYDhnsBwjzDsBQz3BYb7hGEfYHggMDwgDPsBw0OB4SFhOAAYHgkMjwjDQcDwWGB4TBgOAYYnAsMTwnAYMDwVGJ4ShiOA4ZnA8IwwHAUMzwWG54ThGGB4ITC8IAzHAcNLgeElYTgBGF4JDK8Iw0nA8FpgeE0YTgGGNwLDG8JwGjC8FRjeEoYzgOGdwPCOMJwFDO8FhveE4Rxg+CAwfCAM5wHDR4HhI2G4ABg+CQyfCMNFwPBZYPhMGC4Bhi8CwxfCcBkwfBUYvhKGK4Dhm8DwjTBcBQzfBYbvhOEaYPghMPwgDNcBw0+B4SdhuAEYfgkMvwjDTcDwW2D4TRhuAYY/AsMfwnAbMPwVGP4ShjuAwQhz3mA1UMNdwBBDYIhBGO4BBheBwYUw3AcMMQWGmIThAWBwFRhcCcNDwBBLYIhFGB4BBjeBwY0wPAYMsQWG2IThCWBwFxjcCcNTwBBHYIhDGJ4BBg+BwYMwPAcMcQWGuIThBWDwFBg8CcNLwBBPYIhHGF4BBi+BwYswvAYM8QWG+IThDWDwFhi8CcNbwJBAYEhAGN4BhoQCQ0LC8B4wJBIYEhGGD4AhscCQmDB8BAxJBIYkhOETYEgqMCQlDJ8BQzKBIRlh+AIYfAQGH8LwFTAkFxiSE4ZvgCGFwJCCMHwHDL4Cgy9h+AEYUgoMKQnDT8DgJzD4EYZfgCGVwJCKMPwGDKkFhixBuCGGm32Dv8CQKZgweNg3pBEYUhOfpT/AZymtw4Yc/xis4//8vf/putLZv64Y//e/DOAe+f7TCMDv7V9f+4b0gs9HeuLzYaS0b8ggMGQgDDEAQ0aBISNhcAEMmRTPS8IQEzBkFhgyEwZXwJBF8f9ewhALMGQVGLISBjfAkE1gyEYYYgOG7AJDdsLgDhhyCAw5CEMcwJBTYMhJGDwAQy6BIRdhiAsYcgsMuQmDJ2DIIzDkIQzxAENegSEvYfACDPkEhnyEIT5gyC8w5CcM3oChgMBQgDAkAAwFBYaChCEhYCgkMBQiDIkAQ2GBoTBhSAwYiggMRQhDEsBQVGAoShiSAoZiAkMxwpAMMBQXGIoTBh/AUEJgKEEYkgOGkgJDScKQAjCUEhhKEQZfwFBaYChNGFIChjICQxnC4AcYygoMZQlDKsBQTmAoRxhSA4byAkN5wuAPGCoIDBUIQxrAUFFgqEgY0gKGSgJDJcKQDjBUFhgqE4b0gKGKwFCFMGQADFUFhqqEISNgqCYwVCMMmQBDdYGhOmHIDBhqCAw1CEMWwFBTYKhJGLIChloCQy3CkA0w1BYYahOG7IChjsBQhzDkAAx1BYa6hCEnYKgnMNQjDLkAQ32BoT5hyA0YAgSGAMKQBzA0EBgaEIa8gCFQYAgkDPkAQ0OBoSFhyA8YggSGIMJQADA0EhgaEYaCgCFYYAgmDIUAQ2OBoTFhKAwYQgSGEMJQBDA0ERiaEIaigKGpwNCUMBQDDKbAYBKG4oAhVGAIJQwlAEMzgaEZYSgJGMIEhjDCUAowhAsM4YShNGCIEBgiCEMZwBApMEQShrKAIUpgiCIM5QBDtMAQTRjKA4bmAkNzwlABMLQQGFoQhoqAoaXA0JIwVAIMrQSGVoShMmBoLTC0JgxVAEMbgaENYagKGNoKDG0JQzXA0E5gaEcYqgOG9gJDe8JQAzB0EBg6EIaagKGjwNCRMNQCDJ0Ehk6EoTZg6CwwdCYMdQBDF4GhC2GoCxi6CgxdCUM9wNBNYOhGGOoDhu4CQ3fCEAAYeggMPQhDA8DQU2DoSRgCAUMvgaEXYWgIGHoLDL0JQxBg6CMw9CEMjQBDX4GhL2EIBgz9BIZ+hKExYOgvMPQnDCGAYYDAMIAwNAEMAwWGgYShKWAYJDAMIgwmYBgsMAwmDKGAYYjAMIQwNAMMQwWGoYQhDDAMExiGEYZwwDBcYBhOGCIAwwiBYQRhiAQMIwWGkYQhCjCMEhhGEYZowDBaYBhNGJoDhjECwxjC0AIwjBUYxhKGloBhnMAwjjC0AgzjBYbxhKE1YJggMEwgDG0Aw0SBYSJhaAsYJgkMkwhDO8AwWWCYTBjaA4YpAsMUwtABMEwVGKYSho6AYZrAMI0wdAIM0wWG6YShM2CYITDMIAxdAMNMgWEmYegKGGYJDLMIQzfAMFtgmE0YugOGOQLDHMLQAzDMFRjmEoaegGGewDCPMPQCDPMFhvmEoTdgWCAwLCAMfQDDQoFhIWHoCxgWCQyLCEM/wLBYYFhMGPoDhiUCwxLCMAAwLBUYlhKGgYBhmcCwjDAMAgzLBYblhGEwYFghMKwgDEMAw0qBYSVhGAoYVgkMqwjDMMCwWmBYTRiGA4Y1AsMawjACMKwVGNYShpGAYZ3AsI4wjAIM6wWG9YRhNGDYIDBsIAxjAMNGgWEjYRgLGDYJDJsIwzjAsFlg2EwYxgOGLQLDFsIwATBsFRi2EoaJgGGbwLCNMEwCDNsFhu2EYTJg2CEw7CAMUwDDToFhJ2GYChh2CQy7CMM0wLBbYNhNGKYDhj0Cwx7CMAMw7BUY9hKGmYBhn8CwjzDMAgz7BYb9hGE2YDggMBwgDHMAw0GB4SBhmAsYDgkMhwjDPMBwWGA4TBjmA4YjAsMRwrAAMBwVGI4ShoWA4ZjAcIwwLAIMxwWG44RhMWA4ITCcIAxLAMNJgeEkYVgKGE4JDKcIwzLAcFpgOE0YlgOGMwLDGcKwAjCcFRjOEoaVgOGcwHCOMKwCDOcFhvOEYTVguCAwXCAMawDDRYHhImFYCxguCQyXCMM6wHBZYLhMGNYDhisCwxXCsAEwXBUYrhKGjYDhmsBwjTBsAgzXBYbrhGEzYLghMNwgDFsAw02B4SZh2AoYbgkMtwjDNsBwW2C4TRi2A4Y7AsMdwrADMNwVGO4Shp2A4Z7AcI8w7AIM9wWG+4RhN2B4IDA8IAx7AMNDgeEhYdgLGB4JDI8Iwz7A8FhgeEwY9gOGJwLDE8JwADA8FRieEoaDgOGZwPCMMBwCDM8FhueE4TBgeCEwvCAMRwDDS4HhJWE4ChheCQyvCMMxwPBaYHhNGI4DhjcCwxvCcAIwvBUY3hKGk4DhncDwjjCcAgzvBYb3hOE0YPggMHwgDGcAw0eB4SNhOAsYPgkMnwjDOcDwWWD4TBjOA4YvAsMXwnABMHwVGL4ShouA4ZvA8I0wXAIM3wWG74ThMmD4ITD8IAxXAMNPgeEnYbgKGH4JDL8IwzXA8Ftg+E0YrgOGPwLDH8JwAzD8FRj+EoabgMEId95gNVDDLcAQQ2CIQRhuAwYXgcGFMNwBDDEFhpiE4S5gcBUYXAnDPcAQS2CIRRjuAwY3gcGNMDwADLEFhtiE4SFgcBcY3AnDI8AQR2CIQxgeAwYPgcGDMDwBDHEFhriE4Slg8BQYPAnDM8AQT2CIRxieAwYvgcGLMLwADPEFhviE4SVg8BYYvAnDK8CQQGBIQBheA4aEAkNCwvAGMCQSGBIRhreAIbHAkJgwvAMMSQSGJIThPWBIKjAkJQwfAEMygSEZYfgIGHwEBh/C8AkwJBcYkhOGz4AhhcCQgjB8AQy+AoMvYfgKGFIKDCkJwzfA4Ccw+BGG74AhlcCQijD8AAypBYbUhOEnYPAXGPwJwy/AkEZgSEMYfgOGtAJDWsLwBzCkExjSEYa/gCG9wJCeMBh+9g0ZBIYMhCEGYMgoMGQkDC6AIZPAkIkwxAQMmQWGzITBFTBkERiyEIZYgCGrwJCVMLgBhmwCQzbCEBswZBcYshMGd8CQQ2DIQRjiAIacAkNOwuABGHIJDLkIQ1zAkFtgyE0YPAFDHoEhD2GIBxjyCgx5CYMXYMgnMOQjDPEBQ36BIT9h8AYMBQSGAoQhAWAoKDAUJAwJAUMhgaEQYUgEGAoLDIUJQ2LAUERgKEIYkgCGogJDUcKQFDAUExiKEYZkgKG4wFCcMPgAhhICQwnCkBwwlBQYShKGFIChlMBQijD4AobSAkNpwpASMJQRGMoQBj/AUFZgKEsYUgGGcgJDOcKQGjCUFxjKEwZ/wFBBYKhAGNIAhooCQ0XCkBYwVBIYKhGGdIChssBQmTCkBwxVBIYqhCEDYKgqMFQlDBkBQzWBoRphyAQYqgsM1QlDZsBQQ2CoQRiyAIaaAkNNwpAVMNQSGGoRhmyAobbAUJswZAcMdQSGOoQhB2CoKzDUJQw5AUM9gaEeYcgFGOoLDPUJQ27AECAwBBCGPIChgcDQgDDkBQyBAkMgYcgHGBoKDA0JQ37AECQwBBGGAoChkcDQiDAUBAzBAkMwYSgEGBoLDI0JQ2HAECIwhBCGIoChicDQhDAUBQxNBYamhKEYYDAFBpMwFAcMoQJDKGEoARiaCQzNCENJwBAmMIQRhlKAIVxgCCcMpQFDhMAQQRjKAIZIgSGSMJQFDFECQxRhKAcYogWGaMJQHjA0FxiaE4YKgKGFwNCCMFQEDC0FhpaEoRJgaCUwtCIMlQFDa4GhNWGoAhjaCAxtCENVwNBWYGhLGKoBhnYCQzvCUB0wtBcY2hOGGoChg8DQgTDUBAwdBYaOhKEWYOgkMHQiDLUBQ2eBoTNhqAMYuggMXQhDXcDQVWDoShjqAYZuAkM3wlAfMHQXGLoThgDA0ENg6EEYGgCGngJDT8IQCBh6CQy9CENDwNBbYOhNGIIAQx+BoQ9haAQY+goMfQlDMGDoJzD0IwyNAUN/gaE/YQgBDAMEhgGEoQlgGCgwDCQMTQHDIIFhEGEwAcNggWEwYQgFDEMEhiGEoRlgGCowDCUMYYBhmMAwjDCEA4bhAsNwwhABGEYIDCMIQyRgGCkwjCQMUYBhlMAwijBEA4bRAsNowtAcMIwRGMYQhhaAYazAMJYwtAQM4wSGcYShFWAYLzCMJwytAcMEgWECYWgDGCYKDBMJQ1vAMElgmEQY2gGGyQLDZMLQHjBMERimEIYOgGGqwDCVMHQEDNMEhmmEoRNgmC4wTCcMnQHDDIFhBmHoAhhmCgwzCUNXwDBLYJhFGLoBhtkCw2zC0B0wzBEY5hCGHoBhrsAwlzD0BAzzBIZ5hKEXYJgvMMwnDL0BwwKBYQFh6AMYFgoMCwlDX8CwSGBYRBj6AYbFAsNiwtAfMCwRGJYQhgGAYanAsJQwDAQMywSGZYRhEGBYLjAsJwyDAcMKgWEFYRgCGFYKDCsJw1DAsEpgWEUYhgGG1QLDasIwHDCsERjWEIYRgGGtwLCWMIwEDOsEhnWEYRRgWC8wrCcMowHDBoFhA2EYAxg2CgwbCcNYwLBJYNhEGMYBhs0Cw2bCMB4wbBEYthCGCYBhq8CwlTBMBAzbBIZthGESYNguMGwnDJMBww6BYQdhmAIYdgoMOwnDVMCwS2DYRRimAYbdAsNuwjAdMOwRGPYQhhmAYa/AsJcwzAQM+wSGfYRhFmDYLzDsJwyzAcMBgeEAYZgDGA4KDAcJw1zAcEhgOEQY5gGGwwLDYcIwHzAcERiOEIYFgOGowHCUMCwEDMcEhmOEYRFgOC4wHCcMiwHDCYHhBGFYAhhOCgwnCcNSwHBKYDhFGJYBhtMCw2nCsBwwnBEYzhCGFYDhrMBwljCsBAznBIZzhGEVYDgvMJwnDKsBwwWB4QJhWAMYLgoMFwnDWsBwSWC4RBjWAYbLAsNlwrAeMFwRGK4Qhg2A4arAcJUwbAQM1wSGa4RhE2C4LjBcJwybAcMNgeEGYdgCGG4KDDcJw1bAcEtguEUYtgGG2wLDbcKwHTDcERjuEIYdgOGuwHCXMOwEDPcEhnuEYRdguC8w3CcMuwHDA4HhAWHYAxgeCgwPCcNewPBIYHhEGPYBhscCw2PCsB8wPBEYnhCGA4DhqcDwlDAcBAzPBIZnhOEQYHguMDwnDIcBwwuB4QVhOAIYXgoMLwnDUcDwSmB4RRiOAYbXAsNrwnAcMLwRGN4QhhOA4a3A8JYwnAQM7wSGd4ThFGB4LzC8JwynAcMHgeEDYTgDGD4KDB8Jw1nA8Elg+EQYzgGGzwLDZ8JwHjB8ERi+EIYLgOGrwPCVMFwEDN8Ehm+E4RJg+C4wfCcMlwHDD4HhB2G4Ahh+Cgw/CcNVwPBLYPhFGK4Bht8Cw2/CcB0w/BEY/hCGG4Dhr8DwlzDcBAxGhPMGq4EabgGGGAJDDMJwGzC4CAwuhOEOYIgpMMQkDHcBg6vA4EoY7gGGWAJDLMJwHzC4CQxuhOEBYIgtMMQmDA8Bg7vA4E4YHgGGOAJDHMLwGDB4CAwehOEJYIgrMMQlDE8Bg6fA4EkYngGGeAJDPMLwHDB4CQxehOEFYIgvMMQnDC8Bg7fA4E0YXgGGBAJDAsLwGjAkFBgSEoY3gCGRwJCIMLwFDIkFhsSE4R1gSCIwJCEM7wFDUoEhKWH4ABiSCQzJCMNHwOAjMPgQhk+AIbnAkJwwfAYMKQSGFIThC2DwFRh8CcNXwJBSYEhJGL4BBj+BwY8wfAcMqQSGVIThB2BILTCkJgw/AYO/wOBPGH4BhjSgwe3/uJb/6f0tQ7ZA7PwMIbbOH/guhv//Oj9tKHZP/7v5f9w47J/zw+yfn/afc9P9c7iC9ymGC3Cul/37YyS2f29++zn7eXZx+d/7op/nmMC9SSv4TqYlvpOugCGdwJCOMMQCDOkFhvSEwQ0wZBAYMhCG2IAho8CQkTC4A4ZMAkMmwhAHMGQWGDITBg/AkEVgyEIY4gKGrAJDVsLgCRiyCQzZCEM8wJBdYMhOGLwAQw6BIQdhiA8YcgoMOQmDN2DIJTDkIgwJAENugSE3YUgIGPIIDHkIQyLAkFdgyEsYEgOGfAJDPsKQBDDkFxjyE4akgKGAwFCAMCQDDAUFhoKEwQcwFBIYChGG5IChsMBQmDCkAAxFBIYihMEXMBQVGIoShpSAoZjAUIww+AGG4gJDccKQCjCUEBhKEIbUgKGkwFCSMPgDhlICQynCkAYwlBYYShOGtIChjMBQhjCkAwxlBYayhCE9YCgnMJQjDBkAQ3mBoTxhyAgYKggMFQhDJsBQUWCoSBgyA4ZKAkMlwpAFMFQWGCoThqyAoYrAUIUwZAMMVQWGqoQhO2CoJjBUIww5AEN1gaE6YcgJGGoIDDUIQy7AUFNgqEkYcgOGWgJDLcKQBzDUFhhqE4a8gKGOwFCHMOQDDHUFhrqEIT9gqCcw1CMMBQBDfYGhPmEoCBgCBIYAwlAIMDQQGBoQhsKAIVBgCCQMRQBDQ4GhIWEoChiCBIYgwlAMMDQSGBoRhuKAIVhgCCYMJQBDY4GhMWEoCRhCBIYQwlAKMDQRGJoQhtKAoanA0JQwlAEMpsBgEoaygCFUYAglDOUAQzOBoRlhKA8YwgSGMMJQATCECwzhhKEiYIgQGCIIQyXAECkwRBKGyoAhSmCIIgxVAEO0wBBNGKoChuYCQ3PCUA0wtBAYWhCG6oChpcDQkjDUAAytBIZWhKEmYGgtMLQmDLUAQxuBoQ1hqA0Y2goMbQlDHcDQTmBoRxjqAob2AkN7wlAPMHQQGDoQhvqAoaPA0JEwBACGTgJDJ8LQADB0Fhg6E4ZAwNBFYOhCGBoChq4CQ1fCEAQYugkM3QhDI8DQXWDoThiCAUMPgaEHYWgMGHoKDD0JQwhg6CUw9CIMTQBDb4GhN2FoChj6CAx9CIMJGPoKDH0JQyhg6Ccw9CMMzQBDf4GhP2EIAwwDBIYBhCEcMAwUGAYShgjAMEhgGEQYIgHDYIFhMGGIAgxDBIYhhCEaMAwVGIYShuaAYZjAMIwwtAAMwwWG4YShJWAYITCMIAytAMNIgWEkYWgNGEYJDKMIQxvAMFpgGE0Y2gKGMQLDGMLQDjCMFRjGEob2gGGcwDCOMHQADOMFhvGEoSNgmCAwTCAMnQDDRIFhImHoDBgmCQyTCEMXwDBZYJhMGLoChikCwxTC0A0wTBUYphKG7oBhmsAwjTD0AAzTBYbphKEnYJghMMwgDL0Aw0yBYSZh6A0YZgkMswhDH8AwW2CYTRj6AoY5AsMcwtAPMMwVGOYShv6AYZ7AMI8wDAAM8wWG+YRhIGBYIDAsIAyDAMNCgWEhYRgMGBYJDIsIwxDAsFhgWEwYhgKGJQLDEsIwDDAsFRiWEobhgGGZwLCMMIwADMsFhuWEYSRgWCEwrCAMowDDSoFhJWEYDRhWCQyrCMMYwLBaYFhNGMYChjUCwxrCMA4wrBUY1hKG8YBhncCwjjBMAAzrBYb1hGEiYNggMGwgDJMAw0aBYSNhmAwYNgkMmwjDFMCwWWDYTBimAoYtAsMWwjANMGwVGLYShumAYZvAsI0wzAAM2wWG7YRhJmDYITDsIAyzAMNOgWEnYZgNGHYJDLsIwxzAsFtg2E0Y5gKGPQLDHsIwDzDsFRj2Eob5gGGfwLCPMCwADPsFhv2EYSFgOCAwHCAMiwDDQYHhIGFYDBgOCQyHCMMSwHBYYDhMGJYChiMCwxHCsAwwHBUYjhKG5YDhmMBwjDCsAAzHBYbjhGElYDghMJwgDKsAw0mB4SRhWA0YTgkMpwjDGsBwWmA4TRjWAoYzAsMZwrAOMJwVGM4ShvWA4ZzAcI4wbAAM5wWG84RhI2C4IDBcIAybAMNFgeEiYdgMGC4JDJcIwxbAcFlguEwYtgKGKwLDFcKwDTBcFRiuEobtgOGawHCNMOwADNcFhuuEYSdguCEw3CAMuwDDTYHhJmHYDRhuCQy3CMMewHBbYLhNGPYChjsCwx3CsA8w3BUY7hKG/YDhnsBwjzAcAAz3BYb7hOEgYHggMDwgDIcAw0OB4SFhOAwYHgkMjwjDEcDwWGB4TBiOAoYnAsMTwnAMMDwVGJ4ShuOA4ZnA8IwwnAAMzwWG54ThJGB4ITC8IAynAMNLgeElYTgNGF4JDK8IwxnA8FpgeE0YzgKGNwLDG8JwDjC8FRjeEobzgOGdwPCOMFwADO8FhveE4SJg+CAwfCAMlwDDR4HhI2G4DBg+CQyfCMMVwPBZYPhMGK4Chi8CwxfCcA0wfBUYvhKG64Dhm8DwjTDcAAzfBYbvhOEmYPghMPwgDLcAw0+B4SdhuA0YfgkMvwjDHcDwW2D4TRjuAoY/AsMfwnAPMPwVGP4ShvuAwYh03mA1UMMDwBBDYIhBGB4CBheBwYUwPAIMMQWGmIThMWBwFRhcCcMTwBBLYIhFGJ4CBjeBwY0wPAMMsQWG2IThOWBwFxjcCcMLwBBHYIhDGF4CBg+BwYMwvAIMcQWGuIThNWDwFBg8CcMbwBBPYIhHGN4CBi+BwYswvAMM8QWG+IThPWDwFhi8CcMHwJBAYEhAGD4ChoQCQ0LC8AkwJBIYEhGGz4AhscCQmDB8AQxJBIYkhOErYEgqMCQlDN8AQzKBIRlh+A4YfAQGH8LwAzAkFxiSE4afgCGFwJCCMPwCDL4Cgy9h+A0YUgoMKQnDH8DgJzD4EYa/gCGVwJCKMBgx7RtSCwypCUMMwOAvMPgTBhfAkEZgSEMYYgKGtAJDWsLgChjSCQzpCEMswJBeYEhPGNwAQwaBIQNhiA0YMgoMGQmDO2DIJDBkIgxxAENmgSEzYfAADFkEhiyEIS5gyCowZCUMnoAhm8CQjTDEAwzZBYbshMELMOQQGHIQhviAIafAkJMweAOGXAJDLsKQADDkFhhyE4aEgCGPwJCHMCQCDHkFhryEITFgyCcw5CMMSQBDfoEhP2FIChgKCAwFCEMywFBQYChIGHwAQyGBoRBhSA4YCgsMhQlDCsBQRGAoQhh8AUNRgaEoYUgJGIoJDMUIgx9gKC4wFCcMqQBDCYGhBGFIDRhKCgwlCYM/YCglMJQiDGkAQ2mBoTRhSAsYyggMZQhDOsBQVmAoSxjSA4ZyAkM5wpABMJQXGMoThoyAoYLAUIEwZAIMFQWGioQhM2CoJDBUIgxZAENlgaEyYcgKGKoIDFUIQzbAUFVgqEoYsgOGagJDNcKQAzBUFxiqE4acgKGGwFCDMOQCDDUFhpqEITdgqCUw1CIMeQBDbYGhNmHICxjqCAx1CEM+wFBXYKhLGPIDhnoCQz3CUAAw1BcY6hOGgoAhQGAIIAyFAEMDgaEBYSgMGAIFhkDCUAQwNBQYGhKGooAhSGAIIgzFAEMjgaERYSgOGIIFhmDCUAIwNBYYGhOGkoAhRGAIIQylAEMTgaEJYSgNGJoKDE0JQxnAYAoMJmEoCxhCBYZQwlAOMDQTGJoRhvKAIUxgCCMMFQBDuMAQThgqAoYIgSGCMFQCDJECQyRhqAwYogSGKMJQBTBECwzRhKEqYGguMDQnDNUAQwuBoQVhqA4YWgoMLQlDDcDQSmBoRRhqAobWAkNrwlALMLQRGNoQhtqAoa3A0JYw1AEM7QSGdoShLmBoLzC0Jwz1AEMHgaEDYagPGDoKDB0JQwBg6CQwdCIMDQBDZ4GhM2EIBAxdBIYuhKEhYOgqMHQlDEGAoZvA0I0wNAIM3QWG7oQhGDD0EBh6EIbGgKGnwNCTMIQAhl4CQy/C0AQw9BYYehOGpoChj8DQhzCYgKGvwNCXMIQChn4CQz/C0Aww9BcY+hOGMMAwQGAYQBjCAcNAgWEgYYgADIMEhkGEIRIwDBYYBhOGKMAwRGAYQhiiAcNQgWEoYWgOGIYJDMMIQwvAMFxgGE4YWgKGEQLDCMLQCjCMFBhGEobWgGGUwDCKMLQBDKMFhtGEoS1gGCMwjCEM7QDDWIFhLGFoDxjGCQzjCEMHwDBeYBhPGDoChgkCwwTC0AkwTBQYJhKGzoBhksAwiTB0AQyTBYbJhKErYJgiMEwhDN0Aw1SBYSph6A4YpgkM0whDD8AwXWCYThh6AoYZAsMMwtALMMwUGGYSht6AYZbAMIsw9AEMswWG2YShL2CYIzDMIQz9AMNcgWEuYegPGOYJDPMIwwDAMF9gmE8YBgKGBQLDAsIwCDAsFBgWEobBgGGRwLCIMAwBDIsFhsWEYShgWCIwLCEMwwDDUoFhKWEYDhiWCQzLCMMIwLBcYFhOGEYChhUCwwrCMAowrBQYVhKG0YBhlcCwijCMAQyrBYbVhGEsYFgjMKwhDOMAw1qBYS1hGA8Y1gkM6wjDBMCwXmBYTxgmAoYNAsMGwjAJMGwUGDYShsmAYZPAsIkwTAEMmwWGzYRhKmDYIjBsIQzTAMNWgWErYZgOGLYJDNsIwwzAsF1g2E4YZgKGHQLDDsIwCzDsFBh2EobZgGGXwLCLMMwBDLsFht2EYS5g2CMw7CEM8wDDXoFhL2GYDxj2CQz7CMMCwLBfYNhPGBYChgMCwwHCsAgwHBQYDhKGxYDhkMBwiDAsAQyHBYbDhGEpYDgiMBwhDMsAw1GB4ShhWA4YjgkMxwjDCsBwXGA4ThhWAoYTAsMJwrAKMJwUGE4ShtWA4ZTAcIowrAEMpwWG04RhLWA4IzCcIQzrAMNZgeEsYVgPGM4JDOcIwwbAcF5gOE8YNgKGCwLDBcKwCTBcFBguEobNgOGSwHCJMGwBDJcFhsuEYStguCIwXCEM2wDDVYHhKmHYDhiuCQzXCMMOwHBdYLhOGHYChhsCww3CsAsw3BQYbhKG3YDhlsBwizDsAQy3BYbbhGEvYLgjMNwhDPsAw12B4S5h2A8Y7gkM9wjDAcBwX2C4TxgOAoYHAsMDwnAIMDwUGB4ShsOA4ZHA8IgwHAEMjwWGx4ThKGB4IjA8IQzHAMNTgeEpYTgOGJ4JDM8IwwnA8FxgeE4YTgKGFwLDC8JwCjC8FBheEobTgOGVwPCKMJwBDK8FhteE4SxgeCMwvCEM5wDDW4HhLWE4DxjeCQzvCMMFwPBeYHhPGC4Chg8CwwfCcAkwfBQYPhKGy4Dhk8DwiTBcAQyfBYbPhOEqYPgiMHwhDNcAw1eB4SthuA4YvgkM3wjDDcDwXWD4ThhuAoYfAsMPwnALMPwUGH4ShtuA4ZfA8Isw3AEMvwWG34ThLmD4IzD8IQz3AMNfgeEvYbgPGIwo5w1WAzU8AAwxBIYYhOEhYHARGFwIwyPAEFNgiEkYHgMGV4HBlTA8AQyxBIZYhOEpYHATGNwIwzPAEFtgiE0YngMGd4HBnTC8AAxxBIY4hOElYPAQGDwIwyvAEFdgiEsYXgMGT4HBkzC8AQzxBIZ4hOEtYPASGLwIwzvAEF9giE8Y3gMGb4HBmzB8AAwJBIYEhOEjYEgoMCQkDJ8AQyKBIRFh+AwYEgsMiQnDF8CQRGBIQhi+AoakAkNSwvANMCQTGJIRhu+AwUdg8CEMPwBDcoEhOWH4CRhSCAwpCMMvwOArMPgSht+AIaXAkJIw/AEMfgKDH2H4CxhSCQypCIPhat+Q2mGDi5th/K8/NwZ/L6abfYO/YAd/YgdXwJBGYEhDGGIBhrQCQ1rC4AYY0gkM6QhDbMCQXmBITxjcAUMGgSEDYYgDGDIKDBkJgwdgyCQwZCIMcQFDZoEhM2HwBAxZBIYshCEeYMgqMGQlDF6AIZvAkI0wxAcM2QWG7ITBGzDkEBhyEIYEgCGnwJCTMCQEDLkEhlyEIRFgyC0w5CYMiQFDHoEhD2FIAhjyCgx5CUNSwJBPYMhHGJIBhvwCQ37C4AMYCggMBQhDcsBQUGAoSBhSAIZCAkMhwuALGAoLDIUJQ0rAUERgKEIY/ABDUYGhKGFIBRiKCQzFCENqwFBcYChOGPwBQwmBoQRhSAMYSgoMJQlDWsBQSmAoRRjSAYbSAkNpwpAeMJQRGMoQhgyAoazAUJYwZAQM5QSGcoQhE2AoLzCUJwyZAUMFgaECYcgCGCoKDBUJQ1bAUElgqEQYsgGGygJDZcKQHTBUERiqEIYcgKGqwFCVMOQEDNUEhmqEIRdgqC4wVCcMuQFDDYGhBmHIAxhqCgw1CUNewFBLYKhFGPIBhtoCQ23CkB8w1BEY6hCGAoChrsBQlzAUBAz1BIZ6hKEQYKgvMNQnDIUBQ4DAEEAYigCGBgJDA8JQFDAECgyBhKEYYGgoMDQkDMUBQ5DAEEQYSgCGRgJDI8JQEjAECwzBhKEUYGgsMDQmDKUBQ4jAEEIYygCGJgJDE8JQFjA0FRiaEoZygMEUGEzCUB4whAoMoYShAmBoJjA0IwwVAUOYwBBGGCoBhnCBIZwwVAYMEQJDBGGoAhgiBYZIwlAVMEQJDFGEoRpgiBYYoglDdcDQXGBoThhqAIYWAkMLwlATMLQUGFoShlqAoZXA0Iow1AYMrQWG1oShDmBoIzC0IQx1AUNbgaEtYagHGNoJDO0IQ33A0F5gaE8YAgBDB4GhA2FoABg6CgwdCUMgYOgkMHQiDA0BQ2eBoTNhCAIMXQSGLoShEWDoKjB0JQzBgKGbwNCNMDQGDN0Fhu6EIQQw9BAYehCGJoChp8DQkzA0BQy9BIZehMEEDL0Fht6EIRQw9BEY+hCGZoChr8DQlzCEAYZ+AkM/whAOGPoLDP0JQwRgGCAwDCAMkYBhoMAwkDBEAYZBAsMgwhANGAYLDIMJQ3PAMERgGEIYWgCGoQLDUMLQEjAMExiGEYZWgGG4wDCcMLQGDCMEhhGEoQ1gGCkwjCQMbQHDKIFhFGFoBxhGCwyjCUN7wDBGYBhDGDoAhrECw1jC0BEwjBMYxhGGToBhvMAwnjB0BgwTBIYJhKELYJgoMEwkDF0BwySBYRJh6AYYJgsMkwlDd8AwRWCYQhh6AIapAsNUwtATMEwTGKYRhl6AYbrAMJ0w9AYMMwSGGYShD2CYKTDMJAx9AcMsgWEWYegHGGYLDLMJQ3/AMEdgmEMYBgCGuQLDXMIwEDDMExjmEYZBgGG+wDCfMAwGDAsEhgWEYQhgWCgwLCQMQwHDIoFhEWEYBhgWCwyLCcNwwLBEYFhCGEYAhqUCw1LCMBIwLBMYlhGGUYBhucCwnDCMBgwrBIYVhGEMYFgpMKwkDGMBwyqBYRVhGAcYVgsMqwnDeMCwRmBYQxgmAIa1AsNawjARMKwTGNYRhkmAYb3AsJ4wTAYMGwSGDYRhCmDYKDBsJAxTAcMmgWETYZgGGDYLDJsJw3TAsEVg2EIYZgCGrQLDVsIwEzBsExi2EYZZgGG7wLCdMMwGDDsEhh2EYQ5g2Ckw7CQMcwHDLoFhF2GYBxh2Cwy7CcN8wLBHYNhDGBYAhr0Cw17CsBAw7BMY9hGGRYBhv8CwnzAsBgwHBIYDhGEJYDgoMBwkDEsBwyGB4RBhWAYYDgsMhwnDcsBwRGA4QhhWAIajAsNRwrASMBwTGI4RhlWA4bjAcJwwrAYMJwSGE4RhDWA4KTCcJAxrAcMpgeEUYVgHGE4LDKcJw3rAcEZgOEMYNgCGswLDWcKwETCcExjOEYZNgOG8wHCeMGwGDBcEhguEYQtguCgwXCQMWwHDJYHhEmHYBhguCwyXCcN2wHBFYLhCGHYAhqsCw1XCsBMwXBMYrhGGXYDhusBwnTDsBgw3BIYbhGEPYLgpMNwkDHsBwy2B4RZh2AcYbgsMtwnDfsBwR2C4QxgOAIa7AsNdwnAQMNwTGO4RhkOA4b7AcJ8wHAYMDwSGB4ThCGB4KDA8JAxHAcMjgeERYTgGGB4LDI8Jw3HA8ERgeEIYTgCGpwLDU8JwEjA8ExieEYZTgOG5wPCcMJwGDC8EhheE4QxgeCkwvCQMZwHDK4HhFWE4BxheCwyvCcN5wPBGYHhDGC4AhrcCw1vCcBEwvBMY3hGGS4DhvcDwnjBcBgwfBIYPhOEKYPgoMHwkDFcBwyeB4RNhuAYYPgsMnwnDdcDwRWD4QhhuAIavAsNXwnATMHwTGL4RhluA4bvA8J0w3AYMPwSGH4ThDmD4KTD8JAx3AcMvgeEXYbgHGH4LDL8Jw33A8Edg+EMYHgCGvwLDX8LwEDAY0c4brAZqeAQYYggMMQjDY8DgIjC4EIYngCGmwBCTMDwFDK4CgytheAYYYgkMsQjDc8DgJjC4EYYXgCG2wBCbMLwEDO4CgztheAUY4ggMcQjDa8DgITB4EIY3gCGuwBCXMLwFDJ4CgydheAcY4gkM8QjDe8DgJTB4EYYPgCG+wBCfMHwEDN4Cgzdh+AQYEggMCQjDZ8CQUGBISBi+AIZEAkMiwvAVMCQWGBIThm+AIYnAkIQwfAcMSQWGpIThB2BIJjAkIww/AYOPwOBDGH4BhuQCQ3LC8BswpBAYUhCGP4DBV2DwJQx/AUNKgSElYTBi2zf4CQx+hCEGYEglMKQiDC6AIbXAkJowxAQM/gKDP2FwBQxpBIY0hCEWYEgrMKQlDG6AIZ3AkI4wxAYM6QWG9ITBHTBkEBgyEIY4gCGjwJCRMHgAhkwCQybCEBcwZBYYMhMGT8CQRWDIQhjiAYasAkNWwuAFGLIJDNkIQ3zAkF1gyE4YvAFDDoEhB2FIABhyCgw5CUNCwJBLYMhFGBIBhtwCQ27CkBgw5BEY8hCGJIAhr8CQlzAkBQz5BIZ8hCEZYMgvMOQnDD6AoYDAUIAwJAcMBQWGgoQhBWAoJDAUIgy+gKGwwFCYMKQEDEUEhiKEwQ8wFBUYihKGVIChmMBQjDCkBgzFBYbihMEfMJQQGEoQhjSAoaTAUJIwpAUMpQSGUoQhHWAoLTCUJgzpAUMZgaEMYcgAGMoKDGUJQ0bAUE5gKEcYMgGG8gJDecKQGTBUEBgqEIYsgKGiwFCRMGQFDJUEhkqEIRtgqCwwVCYM2QFDFYGhCmHIARiqCgxVCUNOwFBNYKhGGHIBhuoCQ3XCkBsw1BAYahCGPIChpsBQkzDkBQy1BIZahCEfYKgtMNQmDPkBQx2BoQ5hKAAY6goMdQlDQcBQT2CoRxgKAYb6AkN9wlAYMAQIDAGEoQhgaCAwNCAMRQFDoMAQSBiKAYaGAkNDwlAcMAQJDEGEoQRgaCQwNCIMJQFDsMAQTBhKAYbGAkNjwlAaMIQIDCGEoQxgaCIwNCEMZQFDU4GhKWEoBxhMgcEkDOUBQ6jAEEoYKgCGZgJDM8JQETCECQxhhKESYAgXGMIJQ2XAECEwRBCGKoAhUmCIJAxVAUOUwBBFGKoBhmiBIZowVAcMzQWG5oShBmBoITC0IAw1AUNLgaElYagFGFoJDK0IQ23A0FpgaE0Y6gCGNgJDG8JQFzC0FRjaEoZ6gKGdwNCOMNQHDO0FhvaEIQAwdBAYOhCGBoCho8DQkTAEAoZOAkMnwtAQMHQWGDoThiDA0EVg6EIYGgGGrgJDV8IQDBi6CQzdCENjwNBdYOhOGEIAQw+BoQdhaAIYegoMPQlDU8DQS2DoRRhMwNBbYOhNGEIBQx+BoQ9haAYY+goMfQlDGGDoJzD0IwzhgKG/wNCfMEQAhgECwwDCEAkYBgoMAwlDFGAYJDAMIgzRgGGwwDCYMDQHDEMEhiGEoQVgGCowDCUMLQHDMIFhGGFoBRiGCwzDCUNrwDBCYBhBGNoAhpECw0jC0BYwjBIYRhGGdoBhtMAwmjC0BwxjBIYxhKEDYBgrMIwlDB0BwziBYRxh6AQYxgsM4wlDZ8AwQWCYQBi6AIaJAsNEwtAVMEwSGCYRhm6AYbLAMJkwdAcMUwSGKYTh/+Lln4Kea9cuXPf7Xtu2bdu2bdu2bdu2bdu2bftdbfxzZ9XcmaO1qtE2znp2es+do9+58lRSSXoQhqkGw1TB0JMwTDMYpgmGXoRhusEwXTD0JgwzDIYZgqEPYZhpMMwUDH0JwyyDYZZg6EcYZhsMswVDf8Iwx2CYIxgGEIa5BsNcwTCQMMwzGOYJhkGEYb7BMF8wDCYMCwyGBYJhCGFYaDAsFAxDCcMig2GRYBhGGBYbDIsFw3DCsMRgWCIYRhCGpQbDUsEwkjAsMxiWCYZRhGG5wbBcMIwmDCsMhhWCYQxhWGkwrBQMYwnDKoNhlWAYRxhWGwyrBcN4wrDGYFgjGCYQhrUGw1rBMJEwrDMY1gmGSYRhvcGwXjBMJgwbDIYNgmEKYdhoMGwUDFMJwyaDYZNgmEYYNhsMmwXDdMKwxWDYIhhmEIatBsNWwTCTMGwzGLYJhlmEYbvBsF0wzCYMOwyGHYJhDmHYaTDsFAxzCcMug2GXYJhHGHYbDLsFw3zCsMdg2CMYFhCGvQbDXsGwkDDsMxj2CYZFhGG/wbBfMCwmDAcMhgOCYQlhOGgwHBQMSwnDIYPhkGBYRhgOGwyHBcNywnDEYDgiGFYQhqMGw1HBsJIwHDMYjgmGVYThuMFwXDCsJgwnDIYTgmENYThpMJwUDGsJwymD4ZRgWEcYThsMpwXDesJwxmA4Ixg2EIazBsNZwbCRMJwzGM4Jhk2E4bzBcF4wbCYMFwyGC4JhC2G4aDBcFAxbCcMlg+GSYNhGGC4bDJcFw3bCcMVguCIYdhCGqwbDVcGwkzBcMxiuCYZdhOG6wXBdMOwmDDcMhhuCYQ9huGkw3BQMewnDLYPhlmDYRxhuGwy3BcN+wnDHYLgjGA4QhrsGw13BcJAw3DMY7gmGQ4ThvsFwXzAcJgwPDIYHguEIYXhoMDwUDEcJwyOD4ZFgOEYYHhsMjwXDccLwxGB4IhhOEIanBsNTwXCSMDwzGJ4JhlOE4bnB8FwwnCYMLwyGF4LhDGF4aTC8FAxnCcMrg+GVYDhHGF4bDK8Fw3nC8MZgeCMYLhCGtwbDW8FwkTC8MxjeCYZLhOG9wfBeMFwmDB8Mhg+C4Qph+GgwfBQMVwnDJ4Phk2C4Rhg+GwyfBcN1wvDFYPgiGG4Qhq8Gw1fBcJMwfDMYvgmGW4Thu8HwXTDcJgw/DIYfguEOYfhpMPwUDHcJwy+D4ZdguEcYfhsMvwXDfcLwx2D4IxgeEIa/BsNfwfCQMPzT/H9v+M8arOERYfjXYPhXMDwmDAEMhgCC4QlhCGgwBBQMTwlDIIMhkGB4RhgCGwyBBcNzwhDEYAgiGF4QhqAGQ1DB8JIwBDMYggmGV4QhuMEQXDC8JgwhDIYQguENYQhpMIQUDG8JQyiDIZRgeEcYQhsMoQXDe8IQxmAIIxg+EIawBkNYwfCRMIQzGMIJhk+EIbzBEF4wfCYMEQyGCILhC2GIaDBEFAxfCUMkgyGSYPhGGCIbDJEFw3fCEMVgiCIYfhCGqAZDVMHwkzBEMxiiCYZfhCG6wRBdMPwmDDEMhhiC4Q9hiGkwxBQMfwlDLIMhlmD4J9h/b4j9PzYECPHPP//3fiV5XsAQ/70hjmEf4gj7EIgwxDUY4gqGwIQhnsEQTzAEIQzxDYb4giEoYUhgMCQQDMEIQ0KDIaFgCE4YEhkMiQRDCMKQ2GBILBhCEoYkBkMSwRCKMCQ1GJIKhtCEIZnBkEwwhCEMyQ2G5IIhLGFIYTCkEAzhCENKgyGlYAhPGFIZDKkEQwTCkNpgSC0YIhKGNAZDGsEQiTCkNRjSCobIhCGdwZBOMEQhDOkNhvSCISphyGAwZBAM0QhDRoMho2CIThgyGQyZBEMMwpDZYMgsGGIShiwGQxbBEIswZDUYsgqG2IQhm8GQTTDEIQzZDYbsgiEuYchhMOQQDPEIQ06DIadgiE8YchkMuQRDAsKQ22DILRgSEoY8BkMewZCIMOQ1GPIKhsSEIZ/BkE8wJCEM+Q2G/IIhKWEoYDAUEAzJCENBg6GgYEhOGAoZDIUEQwrCUNhgKCwYUhKGIgZDEcGQijAUNRiKCobUhKGYwVBMMKQhDMUNhuKCIS1hKGEwlBAM6QhDSYOhpGBITxhKGQylBEMGwlDaYCgtGDIShjIGQxnBkIkwlDUYygqGzIShnMFQTjBkIQzlDYbygiErYahgMFQQDNkIQ0WDoaJgyE4YKhkMlQRDDsJQ2WCoLBhyEoYqBkMVwZCLMFQ1GKoKhtyEoZrBUE0w5CEM1Q2G6oIhL2GoYTDUEAz5CENNg6GmYMhPGGoZDLUEQwHCUNtgqC0YChKGOgZDHcFQiDDUNRjqCobChKGewVBPMBQhDPUNhvqCoShhaGAwNBAMxQhDQ4OhoWAoThgaGQyNBEMJwtDYYGgsGEoShiYGQxPBUIowNDUYmgqG0oShmcHQTDCUIQzNDYbmgqEsYWhhMLQQDOUIQ0uDoaVgKE8YWhkMrQRDBcLQ2mBoLRgqEoY2BkMbwVCJMLQ1GNoKhsqEoZ3B0E4wVCEM7Q2G9oKhKmHoYDB0EAzVCENHg6GjYKhOGDoZDJ0EQw3C0Nlg6CwYahKGLgZDF8FQizB0NRi6CobahKGbwdBNMNQhDN0Nhu6CoS5h6GEw9BAM9QhDT4Ohp2CoTxh6GQy9BEMDwtDbYOgtGBoShj4GQx/B0Igw9DUY+gqGxoShn8HQTzA0IQz9DYb+gqEpYRhgMAwQDM0Iw0CDYaBgaE4YBhkMgwRDC8Iw2GAYLBhaEoYhBsMQwdCKMAw1GIYKhtaEYZjBMEwwtCEMww2G4YKhLWEYYTCMEAztCMNIg2GkYGhPGEYZDKMEQwfCMNpgGC0YOhKGMQbDGMHQiTCMNRjGCobOhGGcwTBOMHQhDOMNhvGCoSthmGAwTBAM3QjDRINhomDoThgmGQyTBEMPwjDZYJgsGHoShikGwxTB0IswTDUYpgqG3oRhmsEwTTD0IQzTDYbpgqEvYZhhMMwQDP0Iw0yDYaZg6E8YZhkMswTDAMIw22CYLRgGEoY5BsMcwTCIMMw1GOYKhsGEYZ7BME8wDCEM8w2G+YJhKGFYYDAsEAzDCMNCg2GhYBhOGBYZDIsEwwjCsNhgWCwYRhKGJQbDEsEwijAsNRiWCobRhGGZwbBMMIwhDMsNhuWCYSxhWGEwrBAM4wjDSoNhpWAYTxhWGQyrBMMEwrDaYFgtGCYShjUGwxrBMIkwrDUY1gqGyYRhncGwTjBMIQzrDYb1gmEqYdhgMGwQDNMIw0aDYaNgmE4YNhkMmwTDDMKw2WDYLBhmEoYtBsMWwTCLMGw1GLYKhtmEYZvBsE0wzCEM2w2G7YJhLmHYYTDsEAzzCMNOg2GnYJhPGHYZDLsEwwLCsNtg2C0YFhKGPQbDHsGwiDDsNRj2CobFhGGfwbBPMCwhDPsNhv2CYSlhOGAwHBAMywjDQYPhoGBYThgOGQyHBMMKwnDYYDgsGFYShiMGwxHBsIowHDUYjgqG1YThmMFwTDCsIQzHDYbjgmEtYThhMJwQDOsIw0mD4aRgWE8YThkMpwTDBsJw2mA4LRg2EoYzBsMZwbCJMJw1GM4Khs2E4ZzBcE4wbCEM5w2G84JhK2G4YDBcEAzbCMNFg+GiYNhOGC4ZDJcEww7CcNlguCwYdhKGKwbDFcGwizBcNRiuCobdhOGawXBNMOwhDNcNhuuCYS9huGEw3BAM+wjDTYPhpmDYTxhuGQy3BMMBwnDbYLgtGA4ShjsGwx3BcIgw3DUY7gqGw4ThnsFwTzAcIQz3DYb7guEoYXhgMDwQDMcIw0OD4aFgOE4YHhkMjwTDCcLw2GB4LBhOEoYnBsMTwXCKMDw1GJ4KhtOE4ZnB8EwwnCEMzw2G54LhLGF4YTC8EAznCMNLg+GlYDhPGF4ZDK8EwwXC8NpgeC0YLhKGNwbDG8FwiTC8NRjeCobLhOGdwfBOMFwhDO8NhveC4Sph+GAwfBAM1wjDR4Pho2C4Thg+GQyfBMMNwvDZYPgsGG4Shi8GwxfBcIswfDUYvgqG24Thm8HwTTDcIQzfDYbvguEuYfhhMPwQDPcIw0+D4adguE8YfhkMvwTDA8Lw22D4LRgeEoY/BsMfwfCIMPw1GP4KhseE4Z8W/3vDf9ZgDU8Iw78Gw7+C4SlhCGAwBBAMzwhDQIMhoGB4ThgCGQyBBMMLwhDYYAgsGF4ShiAGQxDB8IowBDUYggqG14QhmMEQTDC8IQzBDYbgguEtYQhhMIQQDO8IQ0iDIaRgeE8YQhkMoQTDB8IQ2mAILRg+EoYwBkMYwfCJMIQ1GMIKhs+EIZzBEE4wfCEM4Q2G8ILhK2GIYDBEEAzfCENEgyGiYPhOGCIZDJEEww/CENlgiCwYfhKGKAZDFMHwizBENRiiCobfhCGawRBNMPwhDNENhuiC4S9hiGEwxBAM/4T87w0xDYaYguFfwhDLYIglGAIQhtgGQ2zBEJAwxDEY4giGQIQhrsEQVzAEJgzxDIZ4giEIYYhvMMQXDEEJQwKDIYFgCEYYEhoMCQVDcMKQyGBIJBhCEIbEBkNiwRCSMCQxGJIIhlCEIanBkFQwhCYMyQyGZIIhDGFIbjAkFwxhCUMKgyGFYAhHGFIaDCkFQ3jCkMpgSCUYIhCG1AZDasEQkTCkMRjSCIZIhCGtwZBWMEQmDOkMhnSCIQphSG8wpBcMUQlDBoMhg2CIRhgyGgwZBUN0wpDJYMgkGGIQhswGQ2bBEJMwZDEYsgiGWIQhq8GQVTDEJgzZDIZsgiEOYchuMGQXDHEJQw6DIYdgiEcYchoMOQVDfMKQy2DIJRgSEIbcBkNuwZCQMOQxGPIIhkSEIa/BkFcwJCYM+QyGfIIhCWHIbzDkFwxJCUMBg6GAYEhGGAoaDAUFQ3LCUMhgKCQYUhCGwgZDYcGQkjAUMRiKCIZUhKGowVBUMKQmDMUMhmKCIQ1hKG4wFBcMaQlDCYOhhGBIRxhKGgwlBUN6wlDKYCglGDIQhtIGQ2nBkJEwlDEYygiGTIShrMFQVjBkJgzlDIZygiELYShvMJQXDFkJQwWDoYJgyEYYKhoMFQVDdsJQyWCoJBhyEIbKBkNlwZCTMFQxGKoIhlyEoarBUFUw5CYM1QyGaoIhD2GobjBUFwx5CUMNg6GGYMhHGGoaDDUFQ37CUMtgqCUYChCG2gZDbcFQkDDUMRjqCIZChKGuwVBXMBQmDPUMhnqCoQhhqG8w1BcMRQlDA4OhgWAoRhgaGgwNBUNxwtDIYGgkGEoQhsYGQ2PBUJIwNDEYmgiGUoShqcHQVDCUJgzNDIZmgqEMYWhuMDQXDGUJQwuDoYVgKEcYWhoMLQVDecLQymBoJRgqEIbWBkNrwVCRMLQxGNoIhkqEoa3B0FYwVCYM7QyGdoKhCmFobzC0FwxVCUMHg6GDYKhGGDoaDB0FQ3XC0Mlg6CQYahCGzgZDZ8FQkzB0MRi6CIZahKGrwdBVMNQmDN0Mhm6CoQ5h6G4wdBcMdQlDD4Ohh2CoRxh6Ggw9BUN9wtDLYOglGBoQht4GQ2/B0JAw9DEY+giGRoShr8HQVzA0Jgz9DIZ+gqEJYehvMPQXDE0JwwCDYYBgaEYYBhoMAwVDc8IwyGAYJBhaEIbBBsNgwdCSMAwxGIYIhlaEYajBMFQwtCYMwwyGYYKhDWEYbjAMFwxtCcMIg2GEYGhHGEYaDCMFQ3vCMMpgGCUYOhCG0QbDaMHQkTCMMRjGCIZOhGGswTBWMHQmDOMMhnGCoQthGG8wjBcMXQnDBINhgmDoRhgmGgwTBUN3wjDJYJgkGHoQhskGw2TB0JMwTDEYpgiGXoRhqsEwVTD0JgzTDIZpgqEPYZhuMEwXDH0JwwyDYYZg6EcYZhoMMwVDf8Iwy2CYJRgGEIbZBsNswTCQMMwxGOYIhkGEYa7BMFcwDCYM8wyGeYJhCGGYbzDMFwxDCcMCg2GBYBhGGBYaDAsFw3DCsMhgWCQYRhCGxQbDYsEwkjAsMRiWCIZRhGGpwbBUMIwmDMsMhmWCYQxhWG4wLBcMYwnDCoNhhWAYRxhWGgwrBcN4wrDKYFglGCYQhtUGw2rBMJEwrDEY1giGSYRhrcGwVjBMJgzrDIZ1gmEKYVhvMKwXDFMJwwaDYYNgmEYYNhoMGwXDdMKwyWDYJBhmEIbNBsNmwTCTMGwxGLYIhlmEYavBsFUwzCYM2wyGbYJhDmHYbjBsFwxzCcMOg2GHYJhHGHYaDDsFw3zCsMtg2CUYFhCG3QbDbsGwkDDsMRj2CIZFhGGvwbBXMCwmDPsMhn2CYQlh2G8w7BcMSwnDAYPhgGBYRhgOGgwHBcNywnDIYDgkGFYQhsMGw2HBsJIwHDEYjgiGVYThqMFwVDCsJgzHDIZjgmENYThuMBwXDGsJwwmD4YRgWEcYThoMJwXDesJwymA4JRg2EIbTBsNpwbCRMJwxGM4Ihk2E4azBcFYwbCYM5wyGc4JhC2E4bzCcFwxbCcMFg+GCYNhGGC4aDBcFw3bCcMlguCQYdhCGywbDZcGwkzBcMRiuCIZdhOGqwXBVMOwmDNcMhmuCYQ9huG4wXBcMewnDDYPhhmDYRxhuGgw3BcN+wnDLYLglGA4QhtsGw23BcJAw3DEY7giGQ4ThrsFwVzAcJgz3DIZ7guEIYbhvMNwXDEcJwwOD4YFgOEYYHhoMDwXDccLwyGB4JBhOEIbHBsNjwXCSMDwxGJ4IhlOE4anB8FQwnCYMzwyGZ4LhDGF4bjA8FwxnCcMLg+GFYDhHGF4aDC8Fw3nC8MpgeCUYLhCG1wbDa8FwkTC8MRjeCIZLhOGtwfBWMFwmDO8MhneC4QpheG8wvBcMVwnDB4Phg2C4Rhg+GgwfBcN1wvDJYPgkGG4Qhs8Gw2fBcJMwfDEYvgiGW4Thq8HwVTDcJgzfDIZvguEOYfhuMHwXDHcJww+D4YdguEcYfhoMPwXDfcLwy2D4JRgeEIbfBsNvwfCQMPwxGP4IhkeE4a/B8FcwPCYM/7T83xv+swZreEIY/jUY/hUMTwlDAIMhgGB4RhgCGgwBBcNzwhDIYAgkGF4QhsAGQ2DB8JIwBDEYggiGV4QhqMEQVDC8JgzBDIZgguENYQhuMAQXDG8JQwiDIYRgeEcYQhoMIQXDe8IQymAIJRg+EIbQBkNowfCRMIQxGMIIhk+EIazBEFYwfCYM4QyGcILhC2EIbzCEFwxfCUMEgyGCYPhGGCIaDBEFw3fCEMlgiCQYfhCGyAZDZMHwkzBEMRiiCIZfhCGqwRBVMPwmDNEMhmiC4Q9hiG4wRBcMfwlDDIMhhmD4J9R/b4j5PzYECPPPP//3Phl5XsAw/70hlmEfYgn7EIgwxDYYYguGwIQhjsEQRzAEIQxxDYa4giEoYYhnMMQTDMEIQ3yDIb5gCE4YEhgMCQRDCMKQ0GBIKBhCEoZEBkMiwRCKMCQ2GBILhtCEIYnBkEQwhCEMSQ2GpIIhLGFIZjAkEwzhCENygyG5YAhPGFIYDCkEQwTCkNJgSCkYIhKGVAZDKsEQiTCkNhhSC4bIhCGNwZBGMEQhDGkNhrSCISphSGcwpBMM0QhDeoMhvWCIThgyGAwZBEMMwpDRYMgoGGIShkwGQybBEIswZDYYMguG2IQhi8GQRTDEIQxZDYasgiEuYchmMGQTDPEIQ3aDIbtgiE8YchgMOQRDAsKQ02DIKRgSEoZcBkMuwZCIMOQ2GHILhsSEIY/BkEcwJCEMeQ2GvIIhKWHIZzDkEwzJCEN+gyG/YEhOGAoYDAUEQwrCUNBgKCgYUhKGQgZDIcGQijAUNhgKC4bUhKGIwVBEMKQhDEUNhqKCIS1hKGYwFBMM6QhDcYOhuGBITxhKGAwlBEMGwlDSYCgpGDIShlIGQynBkIkwlDYYSguGzIShjMFQRjBkIQxlDYaygiErYShnMJQTDNkIQ3mDobxgyE4YKhgMFQRDDsJQ0WCoKBhyEoZKBkMlwZCLMFQ2GCoLhtyEoYrBUEUw5CEMVQ2GqoIhL2GoZjBUEwz5CEN1g6G6YMhPGGoYDDUEQwHCUNNgqCkYChKGWgZDLcFQiDDUNhhqC4bChKGOwVBHMBQhDHUNhrqCoShhqGcw1BMMxQhDfYOhvmAoThgaGAwNBEMJwtDQYGgoGEoShkYGQyPBUIowNDYYGguG0oShicHQRDCUIQxNDYamgqEsYWhmMDQTDOUIQ3ODoblgKE8YWhgMLQRDBcLQ0mBoKRgqEoZWBkMrwVCJMLQ2GFoLhsqEoY3B0EYwVCEMbQ2GtoKhKmFoZzC0EwzVCEN7g6G9YKhOGDoYDB0EQw3C0NFg6CgYahKGTgZDJ8FQizB0Nhg6C4bahKGLwdBFMNQhDF0Nhq6CoS5h6GYwdBMM9QhDd4Ohu2CoTxh6GAw9BEMDwtDTYOgpGBoShl4GQy/B0Igw9DYYeguGxoShj8HQRzA0IQx9DYa+gqEpYehnMPQTDM0IQ3+Dob9gaE4YBhgMAwRDC8Iw0GAYKBhaEoZBBsMgwdCKMAw2GAYLhtaEYYjBMEQwtCEMQw2GoYKhLWEYZjAMEwztCMNwg2G4YGhPGEYYDCMEQwfCMNJgGCkYOhKGUQbDKMHQiTCMNhhGC4bOhGGMwTBGMHQhDGMNhrGCoSthGGcwjBMM3QjDeINhvGDoThgmGAwTBEMPwjDRYJgoGHoShkkGwyTB0IswTDYYJguG3oRhisEwRTD0IQxTDYapgqEvYZhmMEwTDP0Iw3SDYbpg6E8YZhgMMwTDAMIw02CYKRgGEoZZBsMswTCIMMw2GGYLhsGEYY7BMEcwDCEMcw2GuYJhKGGYZzDMEwzDCMN8g2G+YBhOGBYYDAsEwwjCsNBgWCgYRhKGRQbDIsEwijAsNhgWC4bRhGGJwbBEMIwhDEsNhqWCYSxhWGYwLBMM4wjDcoNhuWAYTxhWGAwrBMMEwrDSYFgpGCYShlUGwyrBMIkwrDYYVguGyYRhjcGwRjBMIQxrDYa1gmEqYVhnMKwTDNMIw3qDYb1gmE4YNhgMGwTDDMKw0WDYKBhmEoZNBsMmwTCLMGw2GDYLhtmEYYvBsEUwzCEMWw2GrYJhLmHYZjBsEwzzCMN2g2G7YJhPGHYYDDsEwwLCsNNg2CkYFhKGXQbDLsGwiDDsNhh2C4bFhGGPwbBHMCwhDHsNhr2CYSlh2Gcw7BMMywjDfoNhv2BYThgOGAwHBMMKwnDQYDgoGFYShkMGwyHBsIowHDYYDguG1YThiMFwRDCsIQxHDYajgmEtYThmMBwTDOsIw3GD4bhgWE8YThgMJwTDBsJw0mA4KRg2EoZTBsMpwbCJMJw2GE4Lhs2E4YzBcEYwbCEMZw2Gs4JhK2E4ZzCcEwzbCMN5g+G8YNhOGC4YDBcEww7CcNFguCgYdhKGSwbDJcGwizBcNhguC4bdhOGKwXBFMOwhDFcNhquCYS9huGYwXBMM+wjDdYPhumDYTxhuGAw3BMMBwnDTYLgpGA4ShlsGwy3BcIgw3DYYbguGw4ThjsFwRzAcIQx3DYa7guEoYbhnMNwTDMcIw32D4b5gOE4YHhgMDwTDCcLw0GB4KBhOEoZHBsMjwXCKMDw2GB4LhtOE4YnB8EQwnCEMTw2Gp4LhLGF4ZjA8EwznCMNzg+G5YDhPGF4YDC8EwwXC8NJgeCkYLhKGVwbDK8FwiTC8NhheC4bLhOGNwfBGMFwhDG8NhreC4SpheGcwvBMM1wjDe4PhvWC4Thg+GAwfBMMNwvDRYPgoGG4Shk8GwyfBcIswfDYYPguG24Thi8HwRTDcIQxfDYavguEuYfhmMHwTDPcIw3eD4btguE8YfhgMPwTDA8Lw02D4KRgeEoZfBsMvwfCIMPw2GH4LhseE4Y/B8EcwPCEMfw2Gv4LhKWH4p9X/3vCfNVjDM8Lwr8Hwr2B4ThgCGAwBBMMLwhDQYAgoGF4ShkAGQyDB8IowBDYYAguG14QhiMEQRDC8IQxBDYagguEtYQhmMAQTDO8IQ3CDIbhgeE8YQhgMIQTDB8IQ0mAIKRg+EoZQBkMowfCJMIQ2GEILhs+EIYzBEEYwfCEMYQ2GsILhK2EIZzCEEwzfCEN4gyG8YPhOGCIYDBEEww/CENFgiCgYfhKGSAZDJMHwizBENhgiC4bfhCGKwRBFMPwhDFENhqiC4S9hiGYwRBMM/4T97w3RDYboguFfwhDDYIghGAIQhpgGQ0zBEJAwxDIYYgmGQIQhtsEQWzAEJgxxDIY4giEIYYhrMMQVDEEJQzyDIZ5gCEYY4hsM8QVDcMKQwGBIIBhCEIaEBkNCwRCSMCQyGBIJhlCEIbHBkFgwhCYMSQyGJIIhDGFIajAkFQxhCUMygyGZYAhHGJIbDMkFQ3jCkMJgSCEYIhCGlAZDSsEQkTCkMhhSCYZIhCG1wZBaMEQmDGkMhjSCIQphSGswpBUMUQlDOoMhnWCIRhjSGwzpBUN0wpDBYMggGGIQhowGQ0bBEJMwZDIYMgmGWIQhs8GQWTDEJgxZDIYsgiEOYchqMGQVDHEJQzaDIZtgiEcYshsM2QVDfMKQw2DIIRgSEIacBkNOwZCQMOQyGHIJhkSEIbfBkFswJCYMeQyGPIIhCWHIazDkFQxJCUM+gyGfYEhGGPIbDPkFQ3LCUMBgKCAYUhCGggZDQcGQkjAUMhgKCYZUhKGwwVBYMKQmDEUMhiKCIQ1hKGowFBUMaQlDMYOhmGBIRxiKGwzFBUN6wlDCYCghGDIQhpIGQ0nBkJEwlDIYSgmGTIShtMFQWjBkJgxlDIYygiELYShrMJQVDFkJQzmDoZxgyEYYyhsM5QVDdsJQwWCoIBhyEIaKBkNFwZCTMFQyGCoJhlyEobLBUFkw5CYMVQyGKoIhD2GoajBUFQx5CUM1g6GaYMhHGKobDNUFQ37CUMNgqCEYChCGmgZDTcFQkDDUMhhqCYZChKG2wVBbMBQmDHUMhjqCoQhhqGsw1BUMRQlDPYOhnmAoRhjqGwz1BUNxwtDAYGggGEoQhoYGQ0PBUJIwNDIYGgmGUoShscHQWDCUJgxNDIYmgqEMYWhqMDQVDGUJQzODoZlgKEcYmhsMzQVDecLQwmBoIRgqEIaWBkNLwVCRMLQyGFoJhkqEobXB0FowVCYMbQyGNoKhCmFoazC0FQxVCUM7g6GdYKhGGNobDO0FQ3XC0MFg6CAYahCGjgZDR8FQkzB0Mhg6CYZahKGzwdBZMNQmDF0Mhi6CoQ5h6GowdBUMdQlDN4Ohm2CoRxi6GwzdBUN9wtDDYOghGBoQhp4GQ0/B0JAw9DIYegmGRoSht8HQWzA0Jgx9DIY+gqEJYehrMPQVDE0JQz+DoZ9gaEYY+hsM/QVDc8IwwGAYIBhaEIaBBsNAwdCSMAwyGAYJhlaEYbDBMFgwtCYMQwyGIYKhDWEYajAMFQxtCcMwg2GYYGhHGIYbDMMFQ3vCMMJgGCEYOhCGkQbDSMHQkTCMMhhGCYZOhGG0wTBaMHQmDGMMhjGCoQthGGswjBUMXQnDOINhnGDoRhjGGwzjBUN3wjDBYJggGHoQhokGw0TB0JMwTDIYJgmGXoRhssEwWTD0JgxTDIYpgqEPYZhqMEwVDH0JwzSDYZpg6EcYphsM0wVDf8Iww2CYIRgGEIaZBsNMwTCQMMwyGGYJhkGEYbbBMFswDCYMcwyGOYJhCGGYazDMFQxDCcM8g2GeYBhGGOYbDPMFw3DCsMBgWCAYRhCGhQbDQsEwkjAsMhgWCYZRhGGxwbBYMIwmDEsMhiWCYQxhWGowLBUMYwnDMoNhmWAYRxiWGwzLBcN4wrDCYFghGCYQhpUGw0rBMJEwrDIYVgmGSYRhtcGwWjBMJgxrDIY1gmEKYVhrMKwVDFMJwzqDYZ1gmEYY1hsM6wXDdMKwwWDYIBhmEIaNBsNGwTCTMGwyGDYJhlmEYbPBsFkwzCYMWwyGLYJhDmHYajBsFQxzCcM2g2GbYJhHGLYbDNsFw3zCsMNg2CEYFhCGnQbDTsGwkDDsMhh2CYZFhGG3wbBbMCwmDHsMhj2CYQlh2Gsw7BUMSwnDPoNhn2BYRhj2Gwz7BcNywnDAYDggGFYQhoMGw0HBsJIwHDIYDgmGVYThsMFwWDCsJgxHDIYjgmENYThqMBwVDGsJwzGD4ZhgWEcYjhsMxwXDesJwwmA4IRg2EIaTBsNJwbCRMJwyGE4Jhk2E4bTBcFowbCYMZwyGM4JhC2E4azCcFQxbCcM5g+GcYNhGGM4bDOcFw3bCcMFguCAYdhCGiwbDRcGwkzBcMhguCYZdhOGywXBZMOwmDFcMhiuCYQ9huGowXBUMewnDNYPhmmDYRxiuGwzXBcN+wnDDYLghGA4QhpsGw03BcJAw3DIYbgmGQ4ThtsFwWzAcJgx3DIY7guEIYbhrMNwVDEcJwz2D4Z5gOEYY7hsM9wXDccLwwGB4IBhOEIaHBsNDwXCSMDwyGB4JhlOE4bHB8FgwnCYMTwyGJ4LhDGF4ajA8FQxnCcMzg+GZYDhHGJ4bDM8Fw3nC8MJgeCEYLhCGlwbDS8FwkTC8MhheCYZLhOG1wfBaMFwmDG8MhjeC4QpheGswvBUMVwnDO4PhnWC4RhjeGwzvBcN1wvDBYPggGG4Qho8Gw0fBcJMwfDIYPgmGW4Ths8HwWTDcJgxfDIYvguEOYfhqMHwVDHcJwzeD4ZtguEcYvhsM3wXDfcLww2D4IRgeEIafBsNPwfCQMPwyGH4JhkeE4bfB8FswPCYMfwyGP4LhCWH4azD8FQxPCcM/rf/3hv+swRqeEYZ/DYZ/BcNzwhDAYAggGF4QhoAGQ0DB8JIwBDIYAgmGV4QhsMEQWDC8JgxBDIYgguENYQhqMAQVDG8JQzCDIZhgeEcYghsMwQXDe8IQwmAIIRg+EIaQBkNIwfCRMIQyGEIJhk+EIbTBEFowfCYMYQyGMILhC2EIazCEFQxfCUM4gyGcYPhGGMIbDOEFw3fCEMFgiCAYfhCGiAZDRMHwkzBEMhgiCYZfhCGywRBZMPwmDFEMhiiC4Q9hiGowRBUMfwlDNIMhmmD4J9x/b4j+Pzb8G+mff/7v/RnyvACR/ntDDMM+xBD2ISBhiGkwxBQMgQhDLIMhlmAITBhiGwyxBUMQwhDHYIgjGIIShrgGQ1zBEIwwxDMY4gmG4IQhvsEQXzCEIAwJDIYEgiEkYUhoMCQUDKEIQyKDIZFgCE0YEhsMiQVDGMKQxGBIIhjCEoakBkNSwRCOMCQzGJIJhvCEIbnBkFwwRCAMKQyGFIIhImFIaTCkFAyRCEMqgyGVYIhMGFIbDKkFQxTCkMZgSCMYohKGtAZDWsEQjTCkMxjSCYbohCG9wZBeMMQgDBkMhgyCISZhyGgwZBQMsQhDJoMhk2CITRgyGwyZBUMcwpDFYMgiGOIShqwGQ1bBEI8wZDMYsgmG+IQhu8GQXTAkIAw5DIYcgiEhYchpMOQUDIkIQy6DIZdgSEwYchsMuQVDEsKQx2DIIxiSEoa8BkNewZCMMOQzGPIJhuSEIb/BkF8wpCAMBQyGAoIhJWEoaDAUFAypCEMhg6GQYEhNGAobDIUFQxrCUMRgKCIY0hKGogZDUcGQjjAUMxiKCYb0hKG4wVBcMGQgDCUMhhKCISNhKGkwlBQMmQhDKYOhlGDITBhKGwylBUMWwlDGYCgjGLIShrIGQ1nBkI0wlDMYygmG7IShvMFQXjDkIAwVDIYKgiEnYahoMFQUDLkIQyWDoZJgyE0YKhsMlQVDHsJQxWCoIhjyEoaqBkNVwZCPMFQzGKoJhvyEobrBUF0wFCAMNQyGGoKhIGGoaTDUFAyFCEMtg6GWYChMGGobDLUFQxHCUMdgqCMYihKGugZDXcFQjDDUMxjqCYbihKG+wVBfMJQgDA0MhgaCoSRhaGgwNBQMpQhDI4OhkWAoTRgaGwyNBUMZwtDEYGgiGMoShqYGQ1PBUI4wNDMYmgmG8oShucHQXDBUIAwtDIYWgqEiYWhpMLQUDJUIQyuDoZVgqEwYWhsMrQVDFcLQxmBoIxiqEoa2BkNbwVCNMLQzGNoJhuqEob3B0F4w1CAMHQyGDoKhJmHoaDB0FAy1CEMng6GTYKhNGDobDJ0FQx3C0MVg6CIY6hKGrgZDV8FQjzB0Mxi6CYb6hKG7wdBdMDQgDD0Mhh6CoSFh6Gkw9BQMjQhDL4Ohl2BoTBh6Gwy9BUMTwtDHYOgjGJoShr4GQ1/B0Iww9DMY+gmG5oShv8HQXzC0IAwDDIYBgqElYRhoMAwUDK0IwyCDYZBgaE0YBhsMgwVDG8IwxGAYIhjaEoahBsNQwdCOMAwzGIYJhvaEYbjBMFwwdCAMIwyGEYKhI2EYaTCMFAydCMMog2GUYOhMGEYbDKMFQxfCMMZgGCMYuhKGsQbDWMHQjTCMMxjGCYbuhGG8wTBeMPQgDBMMhgmCoSdhmGgwTBQMvQjDJINhkmDoTRgmGwyTBUMfwjDFYJgiGPoShqkGw1TB0I8wTDMYpgmG/oRhusEwXTAMIAwzDIYZgmEgYZhpMMwUDIMIwyyDYZZgGEwYZhsMswXDEMIwx2CYIxiGEoa5BsNcwTCMMMwzGOYJhuGEYb7BMF8wjCAMCwyGBYJhJGFYaDAsFAyjCMMig2GRYBhNGBYbDIsFwxjCsMRgWCIYxhKGpQbDUsEwjjAsMxiWCYbxhGG5wbBcMEwgDCsMhhWCYSJhWGkwrBQMkwjDKoNhlWCYTBhWGwyrBcMUwrDGYFgjGKYShrUGw1rBMI0wrDMY1gmG6YRhvcGwXjDMIAwbDIYNgmEmYdhoMGwUDLMIwyaDYZNgmE0YNhsMmwXDHMKwxWDYIhjmEoatBsNWwTCPMGwzGLYJhvmEYbvBsF0wLCAMOwyGHYJhIWHYaTDsFAyLCMMug2GXYFhMGHYbDLsFwxLCsMdg2CMYlhKGvQbDXsGwjDDsMxj2CYblhGG/wbBfMKwgDAcMhgOCYSVhOGgwHBQMqwjDIYPhkGBYTRgOGwyHBcMawnDEYDgiGNYShqMGw1HBsI4wHDMYjgmG9YThuMFwXDBsIAwnDIYTgmEjYThpMJwUDJsIwymD4ZRg2EwYThsMpwXDFsJwxmA4Ixi2EoazBsNZwbCNMJwzGM4Jhu2E4bzBcF4w7CAMFwyGC4JhJ2G4aDBcFAy7CMMlg+GSYNhNGC4bDJcFwx7CcMVguCIY9hKGqwbDVcGwjzBcMxiuCYb9hOG6wXBdMBwgDDcMhhuC4SBhuGkw3BQMhwjDLYPhlmA4TBhuGwy3BcMRwnDHYLgjGI4ShrsGw13BcIww3DMY7gmG44ThvsFwXzCcIAwPDIYHguEkYXhoMDwUDKcIwyOD4ZFgOE0YHhsMjwXDGcLwxGB4IhjOEoanBsNTwXCOMDwzGJ4JhvOE4bnB8FwwXCAMLwyGF4LhImF4aTC8FAyXCMMrg+GVYLhMGF4bDK8FwxXC8MZgeCMYrhKGtwbDW8FwjTC8MxjeCYbrhOG9wfBeMNwgDB8Mhg+C4SZh+GgwfBQMtwjDJ4Phk2C4TRg+GwyfBcMdwvDFYPgiGO4Shq8Gw1fBcI8wfDMYvgmG+4Thu8HwXTA8IAw/DIYfguEhYfhpMPwUDI8Iwy+D4ZdgeEwYfhsMvwXDE8Lwx2D4IxieEoa/BsNfwfCMMPzT5n9v+M8arOE5YfjXYPhXMLwgDAEMhgCC4SVhCGgwBBQMrwhDIIMhkGB4TRgCGwyBBcMbwhDEYAgiGN4ShqAGQ1DB8I4wBDMYggmG94QhuMEQXDB8IAwhDIYQguEjYQhpMIQUDJ8IQyiDIZRg+EwYQhsMoQXDF8IQxmAIIxi+EoawBkNYwfCNMIQzGMIJhu+EIbzBEF4w/CAMEQyGCILhJ2GIaDBEFAy/CEMkgyGSYPhNGCIbDJEFwx/CEMVgiCIY/hKGqAZDVMHwT+T/3hDNYIgmGP4lDNENhuiCIQBhiGEwxBAMAQlDTIMhpmAIRBhiGQyxBENgwhDbYIgtGIIQhjgGQxzBEJQwxDUY4gqGYIQhnsEQTzAEJwzxDYb4giEEYUhgMCQQDCEJQ0KDIaFgCEUYEhkMiQRDaMKQ2GBILBjCEIYkBkMSwRCWMCQ1GJIKhnCEIZnBkEwwhCcMyQ2G5IIhAmFIYTCkEAwRCUNKgyGlYIhEGFIZDKkEQ2TCkNpgSC0YohCGNAZDGsEQlTCkNRjSCoZohCGdwZBOMEQnDOkNhvSCIQZhyGAwZBAMMQlDRoMho2CIRRgyGQyZBENswpDZYMgsGOIQhiwGQxbBEJcwZDUYsgqGeIQhm8GQTTDEJwzZDYbsgiEBYchhMOQQDAkJQ06DIadgSEQYchkMuQRDYsKQ22DILRiSEIY8BkMewZCUMOQ1GPIKhmSEIZ/BkE8wJCcM+Q2G/IIhBWEoYDAUEAwpCUNBg6GgYEhFGAoZDIUEQ2rCUNhgKCwY0hCGIgZDEcGQljAUNRiKCoZ0hKGYwVBMMKQnDMUNhuKCIQNhKGEwlBAMGQlDSYOhpGDIRBhKGQylBENmwlDaYCgtGLIQhjIGQxnBkJUwlDUYygqGbIShnMFQTjBkJwzlDYbygiEHYahgMFQQDDkJQ0WDoaJgyEUYKhkMlQRDbsJQ2WCoLBjyEIYqBkMVwZCXMFQ1GKoKhnyEoZrBUE0w5CcM1Q2G6oKhAGGoYTDUEAwFCUNNg6GmYChEGGoZDLUEQ2HCUNtgqC0YihCGOgZDHcFQlDDUNRjqCoZihKGewVBPMBQnDPUNhvqCoQRhaGAwNBAMJQlDQ4OhoWAoRRgaGQyNBENpwtDYYGgsGMoQhiYGQxPBUJYwNDUYmgqGcoShmcHQTDCUJwzNDYbmgqECYWhhMLQQDBUJQ0uDoaVgqEQYWhkMrQRDZcLQ2mBoLRiqEIY2BkMbwVCVMLQ1GNoKhmqEoZ3B0E4wVCcM7Q2G9oKhBmHoYDB0EAw1CUNHg6GjYKhFGDoZDJ0EQ23C0Nlg6CwY6hCGLgZDF8FQlzB0NRi6CoZ6hKGbwdBNMNQnDN0Nhu6CoQFh6GEw9BAMDQlDT4Ohp2BoRBh6GQy9BENjwtDbYOgtGJoQhj4GQx/B0JQw9DUY+gqGZoShn8HQTzA0Jwz9DYb+gqEFYRhgMAwQDC0Jw0CDYaBgaEUYBhkMgwRDa8Iw2GAYLBjaEIYhBsMQwdCWMAw1GIYKhnaEYZjBMEwwtCcMww2G4YKhA2EYYTCMEAwdCcNIg2GkYOhEGEYZDKMEQ2fCMNpgGC0YuhCGMQbDGMHQlTCMNRjGCoZuhGGcwTBOMHQnDOMNhvGCoQdhmGAwTBAMPQnDRINhomDoRRgmGQyTBENvwjDZYJgsGPoQhikGwxTB0JcwTDUYpgqGfoRhmsEwTTD0JwzTDYbpgmEAYZhhMMwQDAMJw0yDYaZgGEQYZhkMswTDYMIw22CYLRiGEIY5BsMcwTCUMMw1GOYKhmGEYZ7BME8wDCcM8w2G+YJhBGFYYDAsEAwjCcNCg2GhYBhFGBYZDIsEw2jCsNhgWCwYxhCGJQbDEsEwljAsNRiWCoZxhGGZwbBMMIwnDMsNhuWCYQJhWGEwrBAMEwnDSoNhpWCYRBhWGQyrBMNkwrDaYFgtGKYQhjUGwxrBMJUwrDUY1gqGaYRhncGwTjBMJwzrDYb1gmEGYdhgMGwQDDMJw0aDYaNgmEUYNhkMmwTDbMKw2WDYLBjmEIYtBsMWwTCXMGw1GLYKhnmEYZvBsE0wzCcM2w2G7YJhAWHYYTDsEAwLCcNOg2GnYFhEGHYZDLsEw2LCsNtg2C0YlhCGPQbDHsGwlDDsNRj2CoZlhGGfwbBPMCwnDPsNhv2CYQVhOGAwHBAMKwnDQYPhoGBYRRgOGQyHBMNqwnDYYDgsGNYQhiMGwxHBsJYwHDUYjgqGdYThmMFwTDCsJwzHDYbjgmEDYThhMJwQDBsJw0mD4aRg2EQYThkMpwTDZsJw2mA4LRi2EIYzBsMZwbCVMJw1GM4Khm2E4ZzBcE4wbCcM5w2G84JhB2G4YDBcEAw7CcNFg+GiYNhFGC4ZDJcEw27CcNlguCwY9hCGKwbDFcGwlzBcNRiuCoZ9hOGawXBNMOwnDNcNhuuC4QBhuGEw3BAMBwnDTYPhpmA4RBhuGQy3BMNhwnDbYLgtGI4QhjsGwx3BcJQw3DUY7gqGY4ThnsFwTzAcJwz3DYb7guEEYXhgMDwQDCcJw0OD4aFgOEUYHhkMjwTDacLw2GB4LBjOEIYnBsMTwXCWMDw1GJ4KhnOE4ZnB8EwwnCcMzw2G54LhAmF4YTC8EAwXCcNLg+GlYLhEGF4ZDK8Ew2XC8NpgeC0YrhCGNwbDG8FwlTC8NRjeCoZrhOGdwfBOMFwnDO8NhveC4QZh+GAwfBAMNwnDR4Pho2C4RRg+GQyfBMNtwvDZYPgsGO4Qhi8GwxfBcJcwfDUYvgqGe4Thm8HwTTDcJwzfDYbvguEBYfhhMPwQDA8Jw0+D4adgeEQYfhkMvwTDY8Lw22D4LRieEIY/BsMfwfCUMPw1GP4KhmeE4Z+2/3vDf9ZgDc8Jw78Gw7+C4QVhCGAwBBAMLwlDQIMhoGB4RRgCGQyBBMNrwhDYYAgsGN4QhiAGQxDB8JYwBDUYggqGd4QhmMEQTDC8JwzBDYbgguEDYQhhMIQQDB8JQ0iDIaRg+EQYQhkMoQTDZ8IQ2mAILRi+EIYwBkMYwfCVMIQ1GMIKhm+EIZzBEE4wfCcM4Q2G8ILhB2GIYDBEEAw/CUNEgyGiYPhFGCIZDJEEw2/CENlgiCwY/hCGKAZDFMHwlzBENRiiCoZ/ovz3hmgGQzTB8C9hiG4wRBcMAQhDDIMhhmAISBhiGgwxBUMgwhDLYIglGAIThtgGQ2zBEIQwxDEY4giGoIQhrsEQVzAEIwzxDIZ4giE4YYhvMMQXDCEIQwKDIYFgCEkYEhoMCQVDKMKQyGBIJBhCE4bEBkNiwRCGMCQxGJIIhrCEIanBkFQwhCMMyQyGZIIhPGFIbjAkFwwRCEMKgyGFYIhIGFIaDCkFQyTCkMpgSCUYIhOG1AZDasEQhTCkMRjSCIaohCGtwZBWMEQjDOkMhnSCITphSG8wpBcMMQhDBoMhg2CISRgyGgwZBUMswpDJYMgkGGIThswGQ2bBEIcwZDEYsgiGuIQhq8GQVTDEIwzZDIZsgiE+YchuMGQXDAkIQw6DIYdgSEgYchoMOQVDIsKQy2DIJRgSE4bcBkNuwZCEMOQxGPIIhqSEIa/BkFcwJCMM+QyGfIIhOWHIbzDkFwwpCEMBg6GAYEhJGAoaDAUFQyrCUMhgKCQYUhOGwgZDYcGQhjAUMRiKCIa0hKGowVBUMKQjDMUMhmKCIT1hKG4wFBcMGQhDCYOhhGDISBhKGgwlBUMmwlDKYCglGDIThtIGQ2nBkIUwlDEYygiGrIShrMFQVjBkIwzlDIZygiE7YShvMJQXDDkIQwWDoYJgyEkYKhoMFQVDLsJQyWCoJBhyE4bKBkNlwZCHMFQxGKoIhryEoarBUFUw5CMM1QyGaoIhP2GobjBUFwwFCEMNg6GGYChIGGoaDDUFQyHCUMtgqCUYChOG2gZDbcFQhDDUMRjqCIaihKGuwVBXMBQjDPUMhnqCoThhqG8w1BcMJQhDA4OhgWAoSRgaGgwNBUMpwtDIYGgkGEoThsYGQ2PBUIYwNDEYmgiGsoShqcHQVDCUIwzNDIZmgqE8YWhuMDQXDBUIQwuDoYVgqEgYWhoMLQVDJcLQymBoJRgqE4bWBkNrwVCFMLQxGNoIhqqEoa3B0FYwVCMM7QyGdoKhOmFobzC0Fww1CEMHg6GDYKhJGDoaDB0FQy3C0Mlg6CQYahOGzgZDZ8FQhzB0MRi6CIa6hKGrwdBVMNQjDN0Mhm6CoT5h6G4wdBcMDQhDD4Ohh2BoSBh6Ggw9BUMjwtDLYOglGBoTht4GQ2/B0IQw9DEY+giGpoShr8HQVzA0Iwz9DIZ+gqE5YehvMPQXDC0IwwCDYYBgaEkYBhoMAwVDK8IwyGAYJBhaE4bBBsNgwdCGMAwxGIYIhraEYajBMFQwtCMMwwyGYYKhPWEYbjAMFwwdCMMIg2GEYOhIGEYaDCMFQyfCMMpgGCUYOhOG0QbDaMHQhTCMMRjGCIauhGGswTBWMHQjDOMMhnGCoTthGG8wjBcMPQjDBINhgmDoSRgmGgwTBUMvwjDJYJgkGHoThskGw2TB0IcwTDEYpgiGvoRhqsEwVTD0IwzTDIZpgqE/YZhuMEwXDAMIwwyDYYZgGEgYZhoMMwXDIMIwy2CYJRgGE4bZBsNswTCEMMwxGOYIhqGEYa7BMFcwDCMM8wyGeYJhOGGYbzDMFwwjCMMCg2GBYBhJGBYaDAsFwyjCsMhgWCQYRhOGxQbDYsEwhjAsMRiWCIaxhGGpwbBUMIwjDMsMhmWCYTxhWG4wLBcMEwjDCoNhhWCYSBhWGgwrBcMkwrDKYFglGCYThtUGw2rBMIUwrDEY1giGqYRhrcGwVjBMIwzrDIZ1gmE6YVhvMKwXDDMIwwaDYYNgmEkYNhoMGwXDLMKwyWDYJBhmE4bNBsNmwTCHMGwxGLYIhrmEYavBsFUwzCMM2wyGbYJhPmHYbjBsFwwLCMMOg2GHYFhIGHYaDDsFwyLCsMtg2CUYFhOG3QbDbsGwhDDsMRj2CIalhGGvwbBXMCwjDPsMhn2CYTlh2G8w7BcMKwjDAYPhgGBYSRgOGgwHBcMqwnDIYDgkGFYThsMGw2HBsIYwHDEYjgiGtYThqMFwVDCsIwzHDIZjgmE9YThuMBwXDBsIwwmD4YRg2EgYThoMJwXDJsJwymA4JRg2E4bTBsNpwbCFMJwxGM4Ihq2E4azBcFYwbCMM5wyGc4JhO2E4bzCcFww7CMMFg+GCYNhJGC4aDBcFwy7CcMlguCQYdhOGywbDZcGwhzBcMRiuCIa9hOGqwXBVMOwjDNcMhmuCYT9huG4wXBcMBwjDDYPhhmA4SBhuGgw3BcMhwnDLYLglGA4ThtsGw23BcIQw3DEY7giGo4ThrsFwVzAcIwz3DIZ7guE4YbhvMNwXDCcIwwOD4YFgOEkYHhoMDwXDKcLwyGB4JBhOE4bHBsNjwXCGMDwxGJ4IhrOE4anB8FQwnCMMzwyGZ4LhPGF4bjA8FwwXCMMLg+GFYLhIGF4aDC8FwyXC8MpgeCUYLhOG1wbDa8FwhTC8MRjeCIarhOGtwfBWMFwjDO8MhneC4TpheG8wvBcMNwjDB4Phg2C4SRg+GgwfBcMtwvDJYPgkGG4Ths8Gw2fBcIcwfDEYvgiGu4Thq8HwVTDcIwzfDIZvguE+YfhuMHwXDA8Iww+D4YdgeEgYfhoMPwXDI8Lwy2D4JRgeE4bfBsNvwfCEMPwxGP4IhqeE4a/B8FcwPCMM/7T73xv+swZreE4Y/jUY/hUMLwhDAIMhgGB4SRgCGgwBBcMrwhDIYAgkGF4ThsAGQ2DB8IYwBDEYggiGt4QhqMEQVDC8IwzBDIZgguE9YQhuMAQXDB8IQwiDIYRg+EgYQhoMIQXDJ8IQymAIJRg+E4bQBkNowfCFMIQxGMIIhq+EIazBEFYwfCMM4QyGcILhO2EIbzCEFww/CEMEgyGCYPhJGCIaDBEFwy/CEMlgiCQYfhOGyAZDZMHwhzBEMRiiCIa/hCGqwRBVMPwT9b83RDMYogmGfwlDdIMhumAIQBhiGAwxBENAwhDTYIgpGAIRhlgGQyzBEJgwxDYYYguGIIQhjsEQRzAEJQxxDYa4giEYYYhnMMQTDMEJQ3yDIb5gCEEYEhgMCQRDSMKQ0GBIKBhCEYZEBkMiwRCaMCQ2GBILhjCEIYnBkEQwhCUMSQ2GpIIhHGFIZjAkEwzhCUNygyG5YIhAGFIYDCkEQ0TCkNJgSCkYIhGGVAZDKsEQmTCkNhhSC4YohCGNwZBGMEQlDGkNhrSCIRphSGcwpBMM0QlDeoMhvWCIQRgyGAwZBENMwpDRYMgoGGIRhkwGQybBEJswZDYYMguGOIQhi8GQRTDEJQxZDYasgiEeYchmMGQTDPEJQ3aDIbtgSEAYchgMOQRDQsKQ02DIKRgSEYZcBkMuwZCYMOQ2GHILhiSEIY/BkEcwJCUMeQ2GvIIhGWHIZzDkEwzJCUN+gyG/YEhBGAoYDAUEQ0rCUNBgKCgYUhGGQgZDIcGQmjAUNhgKC4Y0hKGIwVBEMKQlDEUNhqKCIR1hKGYwFBMM6QlDcYOhuGDIQBhKGAwlBENGwlDSYCgpGDIRhlIGQynBkJkwlDYYSguGLIShjMFQRjBkJQxlDYaygiEbYShnMJQTDNkJQ3mDobxgyEEYKhgMFQRDTsJQ0WCoKBhyEYZKBkMlwZCbMFQ2GCoLhjyEoYrBUEUw5CUMVQ2GqoIhH2GoZjBUEwz5CUN1g6G6YChAGGoYDDUEQ0HCUNNgqCkYChGGWgZDLcFQmDDUNhhqC4YihKGOwVBHMBQlDHUNhrqCoRhhqGcw1BMMxQlDfYOhvmAoQRgaGAwNBENJwtDQYGgoGEoRhkYGQyPBUJowNDYYGguGMoShicHQRDCUJQxNDYamgqEcYWhmMDQTDOUJQ3ODoblgqEAYWhgMLQRDRcLQ0mBoKRgqEYZWBkMrwVCZMLQ2GFoLhiqEoY3B0EYwVCUMbQ2GtoKhGmFoZzC0EwzVCUN7g6G9YKhBGDoYDB0EQ03C0NFg6CgYahGGTgZDJ8FQmzB0Nhg6C4Y6hKGLwdBFMNQlDF0Nhq6CoR5h6GYwdBMM9QlDd4Ohu2BoQBh6GAw9BENDwtDTYOgpGBoRhl4GQy/B0Jgw9DYYeguGJoShj8HQRzA0JQx9DYa+gqEZYehnMPQTDM0JQ3+Dob9gaEEYBhgMAwRDS8Iw0GAYKBhaEYZBBsMgwdCaMAw2GAYLhjaEYYjBMEQwtCUMQw2GoYKhHWEYZjAMEwztCcNwg2G4YOhAGEYYDCMEQ0fCMNJgGCkYOhGGUQbDKMHQmTCMNhhGC4YuhGGMwTBGMHQlDGMNhrGCoRthGGcwjBMM3QnDeINhvGDoQRgmGAwTBENPwjDRYJgoGHoRhkkGwyTB0JswTDYYJguGPoRhisEwRTD0JQxTDYapgqEfYZhmMEwTDP0Jw3SDYbpgGEAYZhgMMwTDQMIw02CYKRgGEYZZBsMswTCYMMw2GGYLhiGEYY7BMEcwDCUMcw2GuYJhGGGYZzDMEwzDCcN8g2G+YBhBGBYYDAsEw0jCsNBgWCgYRhGGRQbDIsEwmjAsNhgWC4YxhGGJwbBEMIwlDEsNhqWCYRxhWGYwLBMM4wnDcoNhuWCYQBhWGAwrBMNEwrDSYFgpGCYRhlUGwyrBMJkwrDYYVguGKYRhjcGwRjBMJQxrDYa1gmEaYVhnMKwTDNMJw3qDYb1gmEEYNhgMGwTDTMKw0WDYKBhmEYZNBsMmwTCbMGw2GDYLhjmEYYvBsEUwzCUMWw2GrYJhHmHYZjBsEwzzCcN2g2G7YFhAGHYYDDsEw0LCsNNg2CkYFhGGXQbDLsGwmDDsNhh2C4YlhGGPwbBHMCwlDHsNhr2CYRlh2Gcw7BMMywnDfoNhv2BYQRgOGAwHBMNKwnDQYDgoGFYRhkMGwyHBsJowHDYYDguGNYThiMFwRDCsJQxHDYajgmEdYThmMBwTDOsJw3GD4bhg2EAYThgMJwTDRsJw0mA4KRg2EYZTBsMpwbCZMJw2GE4Lhi2E4YzBcEYwbCUMZw2Gs4JhG2E4ZzCcEwzbCcN5g+G8YNhBGC4YDBcEw07CcNFguCgYdhGGSwbDJcGwmzBcNhguC4Y9hOGKwXBFMOwlDFcNhquCYR9huGYwXBMM+wnDdYPhumA4QBhuGAw3BMNBwnDTYLgpGA4RhlsGwy3BcJgw3DYYbguGI4ThjsFwRzAcJQx3DYa7guEYYbhnMNwTDMcJw32D4b5gOEEYHhgMDwTDScLw0GB4KBhOEYZHBsMjwXCaMDw2GB4LhjOE4YnB8EQwnCUMTw2Gp4LhHGF4ZjA8EwznCcNzg+G5YLhAGF4YDC8Ew0XC8NJgeCkYLhGGVwbDK8FwmTC8NhheC4YrhOGNwfBGMFwlDG8NhreC4RpheGcwvBMM1wnDe4PhvWC4QRg+GAwfBMNNwvDRYPgoGG4Rhk8GwyfBcJswfDYYPguGO4Thi8HwRTDcJQxfDYavguEeYfhmMHwTDPcJw3eD4btgeEAYfhgMPwTDQ8Lw02D4KRgeEYZfBsMvwfCYMPw2GH4LhieE4Y/B8EcwPCUMfw2Gv4LhGWH4p/3/3vCfNVjDc8Lwr8Hwr2B4QRgCGAwBBMNLwhDQYAgoGF4RhkAGQyDB8JowBDYYAguGN4QhiMEQRDC8JQxBDYagguEdYQhmMAQTDO8JQ3CDIbhg+EAYQhgMIQTDR8IQ0mAIKRg+EYZQBkMowfCZMIQ2GEILhi+EIYzBEEYwfCUMYQ2GsILhG2EIZzCEEwzfCUN4gyG8YPhBGCIYDBEEw0/CENFgiCgYfhGGSAZDJMHwmzBENhgiC4Y/hCHK/9jwN/o///zfa2ryvH9i/PeGqIZ9iCrsw7+EIZrBEE0wBCAM0Q2G6IIhIGGIYTDEEAyBCENMgyGmYAhMGGIZDLEEQxDCENtgiC0YghKGOAZDHMEQjDDENRjiCobghCGewRBPMIQgDPENhviCISRhSGAwJBAMoQhDQoMhoWAITRgSGQyJBEMYwpDYYEgsGMIShiQGQxLBEI4wJDUYkgqG8IQhmcGQTDBEIAzJDYbkgiEiYUhhMKQQDJEIQ0qDIaVgiEwYUhkMqQRDFMKQ2mBILRiiEoY0BkMawRCNMKQ1GNIKhuiEIZ3BkE4wxCAM6Q2G9IIhJmHIYDBkEAyxCENGgyGjYIhNGDIZDJkEQxzCkNlgyCwY4hKGLAZDFsEQjzBkNRiyCob4hCGbwZBNMCQgDNkNhuyCISFhyGEw5BAMiQhDToMhp2BITBhyGQy5BEMSwpDbYMgtGJIShjwGQx7BkIww5DUY8gqG5IQhn8GQTzCkIAz5DYb8giElYShgMBQQDKkIQ0GDoaBgSE0YChkMhQRDGsJQ2GAoLBjSEoYiBkMRwZCOMBQ1GIoKhvSEoZjBUEwwZCAMxQ2G4oIhI2EoYTCUEAyZCENJg6GkYMhMGEoZDKUEQxbCUNpgKC0YshKGMgZDGcGQjTCUNRjKCobshKGcwVBOMOQgDOUNhvKCISdhqGAwVBAMuQhDRYOhomDITRgqGQyVBEMewlDZYKgsGPIShioGQxXBkI8wVDUYqgqG/IShmsFQTTAUIAzVDYbqgqEgYahhMNQQDIUIQ02DoaZgKEwYahkMtQRDEcJQ22CoLRiKEoY6BkMdwVCMMNQ1GOoKhuKEoZ7BUE8wlCAM9Q2G+oKhJGFoYDA0EAylCENDg6GhYChNGBoZDI0EQxnC0NhgaCwYyhKGJgZDE8FQjjA0NRiaCobyhKGZwdBMMFQgDM0NhuaCoSJhaGEwtBAMlQhDS4OhpWCoTBhaGQytBEMVwtDaYGgtGKoShjYGQxvBUI0wtDUY2gqG6oShncHQTjDUIAztDYb2gqEmYehgMHQQDLUIQ0eDoaNgqE0YOhkMnQRDHcLQ2WDoLBjqEoYuBkMXwVCPMHQ1GLoKhvqEoZvB0E0wNCAM3Q2G7oKhIWHoYTD0EAyNCENPg6GnYGhMGHoZDL0EQxPC0Ntg6C0YmhKGPgZDH8HQjDD0NRj6CobmhKGfwdBPMLQgDP0Nhv6CoSVhGGAwDBAMrQjDQINhoGBoTRgGGQyDBEMbwjDYYBgsGNoShiEGwxDB0I4wDDUYhgqG9oRhmMEwTDB0IAzDDYbhgqEjYRhhMIwQDJ0Iw0iDYaRg6EwYRhkMowRDF8Iw2mAYLRi6EoYxBsMYwdCNMIw1GMYKhu6EYZzBME4w9CAM4w2G8YKhJ2GYYDBMEAy9CMNEg2GiYOhNGCYZDJMEQx/CMNlgmCwY+hKGKQbDFMHQjzBMNRimCob+hGGawTBNMAwgDNMNhumCYSBhmGEwzBAMgwjDTINhpmAYTBhmGQyzBMMQwjDbYJgtGIYShjkGwxzBMIwwzDUY5gqG4YRhnsEwTzCMIAzzDYb5gmEkYVhgMCwQDKMIw0KDYaFgGE0YFhkMiwTDGMKw2GBYLBjGEoYlBsMSwTCOMCw1GJYKhvGEYZnBsEwwTCAMyw2G5YJhImFYYTCsEAyTCMNKg2GlYJhMGFYZDKsEwxTCsNpgWC0YphKGNQbDGsEwjTCsNRjWCobphGGdwbBOMMwgDOsNhvWCYSZh2GAwbBAMswjDRoNho2CYTRg2GQybBMMcwrDZYNgsGOYShi0GwxbBMI8wbDUYtgqG+YRhm8GwTTAsIAzbDYbtgmEhYdhhMOwQDIsIw06DYadgWEwYdhkMuwTDEsKw22DYLRiWEoY9BsMewbCMMOw1GPYKhuWEYZ/BsE8wrCAM+w2G/YJhJWE4YDAcEAyrCMNBg+GgYFhNGA4ZDIcEwxrCcNhgOCwY1hKGIwbDEcGwjjAcNRiOCob1hOGYwXBMMGwgDMcNhuOCYSNhOGEwnBAMmwjDSYPhpGDYTBhOGQynBMMWwnDaYDgtGLYShjMGwxnBsI0wnDUYzgqG7YThnMFwTjDsIAznDYbzgmEnYbhgMFwQDLsIw0WD4aJg2E0YLhkMlwTDHsJw2WC4LBj2EoYrBsMVwbCPMFw1GK4Khv2E4ZrBcE0wHCAM1w2G64LhIGG4YTDcEAyHCMNNg+GmYDhMGG4ZDLcEwxHCcNtguC0YjhKGOwbDHcFwjDDcNRjuCobjhOGewXBPMJwgDPcNhvuC4SRheGAwPBAMpwjDQ4PhoWA4TRgeGQyPBMMZwvDYYHgsGM4ShicGwxPBcI4wPDUYngqG84ThmcHwTDBcIAzPDYbnguEiYXhhMLwQDJcIw0uD4aVguEwYXhkMrwTDFcLw2mB4LRiuEoY3BsMbwXCNMLw1GN4KhuuE4Z3B8E4w3CAM7w2G94LhJmH4YDB8EAy3CMNHg+GjYLhNGD4ZDJ8Ewx3C8Nlg+CwY7hKGLwbDF8FwjzB8NRi+Cob7hOGbwfBNMDwgDN8Nhu+C4SFh+GEw/BAMjwjDT4Php2B4TBh+GQy/BMMTwvDbYPgtGJ4Shj8Gwx/B8Iww/DUY/gqG54Thnw7/e8N/1mANLwjDvwbDv4LhJWEIYDAEEAyvCENAgyGgYHhNGAIZDIEEwxvCENhgCCwY3hKGIAZDEMHwjjAENRiCCob3hCGYwRBMMHwgDMENhuCC4SNhCGEwhBAMnwhDSIMhpGD4TBhCGQyhBMMXwhDaYAgtGL4ShjAGQxjB8I0whDUYwgqG74QhnMEQTjD8IAzhDYbwguEnYYhgMEQQDL8IQ0SDIaJg+E0YIhkMkQTDH8IQ2WCILBj+EoYoBkMUwfBPzP/eENVgiCoY/iUM0QyGaIIhAGGIbjBEFwwBCUMMgyGGYAhEGGIaDDEFQ2DCEMtgiCUYghCG2AZDbMEQlDDEMRjiCIZghCGuwRBXMAQnDPEMhniCIQRhiG8wxBcMIQlDAoMhgWAIRRgSGgwJBUNowpDIYEgkGMIQhsQGQ2LBEJYwJDEYkgiGcIQhqcGQVDCEJwzJDIZkgiECYUhuMCQXDBEJQwqDIYVgiEQYUhoMKQVDZMKQymBIJRiiEIbUBkNqwRCVMKQxGNIIhmiEIa3BkFYwRCcM6QyGdIIhBmFIbzCkFwwxCUMGgyGDYIhFGDIaDBkFQ2zCkMlgyCQY4hCGzAZDZsEQlzBkMRiyCIZ4hCGrwZBVMMQnDNkMhmyCIQFhyG4wZBcMCQlDDoMhh2BIRBhyGgw5BUNiwpDLYMglGJIQhtwGQ27BkJQw5DEY8giGZIQhr8GQVzAkJwz5DIZ8giEFYchvMOQXDCkJQwGDoYBgSEUYChoMBQVDasJQyGAoJBjSEIbCBkNhwZCWMBQxGIoIhnSEoajBUFQwpCcMxQyGYoIhA2EobjAUFwwZCUMJg6GEYMhEGEoaDCUFQ2bCUMpgKCUYshCG0gZDacGQlTCUMRjKCIZshKGswVBWMGQnDOUMhnKCIQdhKG8wlBcMOQlDBYOhgmDIRRgqGgwVBUNuwlDJYKgkGPIQhsoGQ2XBkJcwVDEYqgiGfIShqsFQVTDkJwzVDIZqgqEAYahuMFQXDAUJQw2DoYZgKEQYahoMNQVDYcJQy2CoJRiKEIbaBkNtwVCUMNQxGOoIhmKEoa7BUFcwFCcM9QyGeoKhBGGobzDUFwwlCUMDg6GBYChFGBoaDA0FQ2nC0MhgaCQYyhCGxgZDY8FQljA0MRiaCIZyhKGpwdBUMJQnDM0MhmaCoQJhaG4wNBcMFQlDC4OhhWCoRBhaGgwtBUNlwtDKYGglGKoQhtYGQ2vBUJUwtDEY2giGaoShrcHQVjBUJwztDIZ2gqEGYWhvMLQXDDUJQweDoYNgqEUYOhoMHQVDbcLQyWDoJBjqEIbOBkNnwVCXMHQxGLoIhnqEoavB0FUw1CcM3QyGboKhAWHobjB0FwwNCUMPg6GHYGhEGHoaDD0FQ2PC0Mtg6CUYmhCG3gZDb8HQlDD0MRj6CIZmhKGvwdBXMDQnDP0Mhn6CoQVh6G8w9BcMLQnDAINhgGBoRRgGGgwDBUNrwjDIYBgkGNoQhsEGw2DB0JYwDDEYhgiGdoRhqMEwVDC0JwzDDIZhgqEDYRhuMAwXDB0JwwiDYYRg6EQYRhoMIwVDZ8IwymAYJRi6EIbRBsNowdCVMIwxGMYIhm6EYazBMFYwdCcM4wyGcYKhB2EYbzCMFww9CcMEg2GCYOhFGCYaDBMFQ2/CMMlgmCQY+hCGyQbDZMHQlzBMMRimCIZ+hGGqwTBVMPQnDNMMhmmCYQBhmG4wTBcMAwnDDINhhmAYRBhmGgwzBcNgwjDLYJglGIYQhtkGw2zBMJQwzDEY5giGYYRhrsEwVzAMJwzzDIZ5gmEEYZhvMMwXDCMJwwKDYYFgGEUYFhoMCwXDaMKwyGBYJBjGEIbFBsNiwTCWMCwxGJYIhnGEYanBsFQwjCcMywyGZYJhAmFYbjAsFwwTCcMKg2GFYJhEGFYaDCsFw2TCsMpgWCUYphCG1QbDasEwlTCsMRjWCIZphGGtwbBWMEwnDOsMhnWCYQZhWG8wrBcMMwnDBoNhg2CYRRg2GgwbBcNswrDJYNgkGOYQhs0Gw2bBMJcwbDEYtgiGeYRhq8GwVTDMJwzbDIZtgmEBYdhuMGwXDAsJww6DYYdgWEQYdhoMOwXDYsKwy2DYJRiWEIbdBsNuwbCUMOwxGPYIhmWEYa/BsFcwLCcM+wyGfYJhBWHYbzDsFwwrCcMBg+GAYFhFGA4aDAcFw2rCcMhgOCQY1hCGwwbDYcGwljAcMRiOCIZ1hOGowXBUMKwnDMcMhmOCYQNhOG4wHBcMGwnDCYPhhGDYRBhOGgwnBcNmwnDKYDglGLYQhtMGw2nBsJUwnDEYzgiGbYThrMFwVjBsJwznDIZzgmEHYThvMJwXDDsJwwWD4YJg2EUYLhoMFwXDbsJwyWC4JBj2EIbLBsNlwbCXMFwxGK4Ihn2E4arBcFUw7CcM1wyGa4LhAGG4bjBcFwwHCcMNg+GGYDhEGG4aDDcFw2HCcMtguCUYjhCG2wbDbcFwlDDcMRjuCIZjhOGuwXBXMBwnDPcMhnuC4QRhuG8w3BcMJwnDA4PhgWA4RRgeGgwPBcNpwvDIYHgkGM4QhscGw2PBcJYwPDEYngiGc4ThqcHwVDCcJwzPDIZnguECYXhuMDwXDBcJwwuD4YVguEQYXhoMLwXDZcLwymB4JRiuEIbXBsNrwXCVMLwxGN4IhmuE4a3B8FYwXCcM7wyGd4LhBmF4bzC8Fww3CcMHg+GDYLhFGD4aDB8Fw23C8Mlg+CQY7hCGzwbDZ8FwlzB8MRi+CIZ7hOGrwfBVMNwnDN8Mhm+C4QFh+G4wfBcMDwnDD4Phh2B4RBh+Ggw/BcNjwvDLYPglGJ4Qht8Gw2/B8JQw/DEY/giGZ4Thr8HwVzA8Jwz/dPzfG/6zBmt4QRj+NRj+FQwvCUMAgyGAYHhFGAIaDAEFw2vCEMhgCCQY3hCGwAZDYMHwljAEMRiCCIZ3hCGowRBUMLwnDMEMhmCC4QNhCG4wBBcMHwlDCIMhhGD4RBhCGgwhBcNnwhDKYAglGL4QhtAGQ2jB8JUwhDEYwgiGb4QhrMEQVjB8JwzhDIZwguEHYQhvMIQXDD8JQwSDIYJg+EUYIhoMsZvzhn+D/feGSAZDzJaCIdR/b4hsMEQUHku/icdSlP+x4U/sf/75v9fU5Hl/Y//3hqiGfYgq7MM/cf57QzSDIZpg+JcwRDcYoguGAIQhhsEQQzAEJAwxHc+tgiEQYYhlMMQSDIEJQ2zH/2nBEIQwxDEY4giGoIQhrsEQVzAEIwzxDIZ4giE4YYhvMMQXDCEIQwKDIYFgCEkYEhoMCQVDKMKQyGBIJBhCE4bEBkNiwRCGMCQxGJIIhrCEIanBkFQwhCMMyQyGZIIhPGFIbjAkFwwRCEMKgyGFYIhIGFIaDCkFQyTCkMpgSCUYIhOG1AZDasEQhTCkMRjSCIaohCGtwZBWMEQjDOkMhnSCITphSG8wpBcMMQhDBoMhg2CISRgyGgwZBUMswpDJYMgkGGIThswGQ2bBEIcwZDEYsgiGuIQhq8GQVTDEIwzZDIZsgiE+YchuMGQXDAkIQw6DIYdgSEgYchoMOQVDIsKQy2DIJRgSE4bcBkNuwZCEMOQxGPIIhqSEIa/BkFcwJCMM+QyGfIIhOWHIbzDkFwwpCEMBg6GAYEhJGAoaDAUFQyrCUMhgKCQYUhOGwgZDYcGQhjAUMRiKCIa0hKGowVBUMKQjDMUMhmKCIT1hKG4wFBcMGQhDCYOhhGDISBhKGgwlBUMmwlDKYCglGDIThtIGQ2nBkIUwlDEYygiGrIShrMFQVjBkIwzlDIZygiE7YShvMJQXDDkIQwWDoYJgyEkYKhoMFQVDLsJQyWCoJBhyE4bKBkNlwZCHMFQxGKoIhryEoarBUFUw5CMM1QyGaoIhP2GobjBUFwwFCEMNg6GGYChIGGoaDDUFQyHCUMtgqCUYChOG2gZDbcFQhDDUMRjqCIaihKGuwVBXMBQjDPUMhnqCoThhqG8w1BcMJQhDA4OhgWAoSRgaGgwNBUMpwtDIYGgkGEoThsYGQ2PBUIYwNDEYmgiGsoShqcHQVDCUIwzNDIZmgqE8YWhuMDQXDBUIQwuDoYVgqEgYWhoMLQVDJcLQymBoJRgqE4bWBkNrwVCFMLQxGNoIhqqEoa3B0FYwVCMM7QyGdoKhOmFobzC0Fww1CEMHg6GDYKhJGDoaDB0FQy3C0Mlg6CQYahOGzgZDZ8FQhzB0MRi6CIa6hKGrwdBVMNQjDN0Mhm6CoT5h6G4wdBcMDQhDD4Ohh2BoSBh6Ggw9BUMjwtDLYOglGBoTht4GQ2/B0IQw9DEY+giGpoShr8HQVzA0Iwz9DIZ+gqE5YehvMPQXDC0IwwCDYYBgaEkYBhoMAwVDK8IwyGAYJBhaE4bBBsNgwdCGMAwxGIYIhraEYajBMFQwtCMMwwyGYYKhPWEYbjAMFwwdCMMIg2GEYOhIGEYaDCMFQyfCMMpgGCUYOhOG0QbDaMHQhTCMMRjGCIauhGGswTBWMHQjDOMMhnGCoTthGG8wjBcMPQjDBINhgmDoSRgmGgwTBUMvwjDJYJgkGHoThskGw2TB0IcwTDEYpgiGvoRhqsEwVTD0IwzTDIZpgqE/YZhuMEwXDAMIwwyDYYZgGEgYZhoMMwXDIMIwy2CYJRgGE4bZBsNswTCEMMwxGOYIhqGEYa7BMFcwDCMM8wyGeYJhOGGYbzDMFwwjCMMCg2GBYBhJGBYaDAsFwyjCsMhgWCQYRhOGxQbDYsEwhjAsMRiWCIaxhGGpwbBUMIwjDMsMhmWCYTxhWG4wLBcMEwjDCoNhhWCYSBhWGgwrBcMkwrDKYFglGCYThtUGw2rBMIUwrDEY1giGqYRhrcGwVjBMIwzrDIZ1gmE6YVhvMKwXDDMIwwaDYYNgmEkYNhoMGwXDLMKwyWDYJBhmE4bNBsNmwTCHMGwxGLYIhrmEYavBsFUwzCMM2wyGbYJhPmHYbjBsFwwLCMMOg2GHYFhIGHYaDDsFwyLCsMtg2CUYFhOG3QbDbsGwhDDsMRj2CIalhGGvwbBXMCwjDPsMhn2CYTlh2G8w7BcMKwjDAYPhgGBYSRgOGgwHBcMqwnDIYDgkGFYThsMGw2HBsIYwHDEYjgiGtYThqMFwVDCsIwzHDIZjgmE9YThuMBwXDBsIwwmD4YRg2EgYThoMJwXDJsJwymA4JRg2E4bTBsNpwbCFMJwxGM4Ihq2E4azBcFYwbCMM5wyGc4JhO2E4bzCcFww7CMMFg+GCYNhJGC4aDBcFwy7CcMlguCQYdhOGywbDZcGwhzBcMRiuCIa9hOGqwXBVMOwjDNcMhmuCYT9huG4wXBcMBwjDDYPhhmA4SBhuGgw3BcMhwnDLYLglGA4ThtsGw23BcIQw3DEY7giGo4ThrsFwVzAcIwz3DIZ7guE4YbhvMNwXDCcIwwOD4YFgOEkYHhoMDwXDKcLwyGB4JBhOE4bHBsNjwXCGMDwxGJ4IhrOE4anB8FQwnCMMzwyGZ4LhPGF4bjA8FwwXCMMLg+GFYLhIGF4aDC8FwyXC8MpgeCUYLhOG1wbDa8FwhTC8MRjeCIarhOGtwfBWMFwjDO8MhneC4TpheG8wvBcMNwjDB4Phg2C4SRg+GgwfBcMtwvDJYPgkGG4Ths8Gw2fBcIcwfDEYvgiGu4Thq8HwVTDcIwzfDIZvguE+YfhuMHwXDA8Iww+D4YdgeEgYfhoMPwXDI8Lwy2D4JRgeE4bfBsNvwfCEMPwxGP4IhqeE4a/B8FcwPCMM/3T63xv+swZreE4Y/jUY/hUMLwhDAIMhgGB4SRgCGgwBBcMrwhDIYAgkGF4ThsAGQ2DB8IYwBDEYggiGt4QhqMEQVDC8IwzBDIZgguE9YQhuMAQXDB8IQwiDIYRg+EgYQhoMIQXDJ8IQymAIJRg+E4bQBkNowfCFMIQxGMIIhq+EIazBEFYwfCMM4QyGcILhO2EIbzCEFww/CEMEgyGCYPhJGCIaDBEFwy/CEMlgiCQYfhOGyAZDZMHwhzBEMRiiCIa/hCGqwRBVMPwT9783RDMYogmGfwlDdIMhumAIQBhiGAwxBENAwhDTYIgpGAIRhlgGQyzBEJgwxDYYYguGIIQhjsEQRzAEJQxxDYa4giEYYYhnMMQTDMEJQ3yDIb5gCEEYEhgMCQRDSMKQ0GBIKBhCEYZEBkMiwRCaMCQ2GBILhjCEIYnBkEQwhCUMSQ2GpIIhHGFIZjAkEwzhCUNygyG5YIhAGFIYDCkEQ0TCkNJgSCkYIhGGVAZDKsEQmTCkNhhSC4YohCGNwZBGMEQlDGkNhrSCIRphSGcwpBMM0QlDeoMhvWCIQRgyGAwZBENMwpDRYMgoGGIRhkwGQybBEJswZDYYMguGOIQhi8GQRTDEJQxZDYasgiEeYchmMGQTDPEJQ3aDIbtgSEAYchgMOQRDQsKQ02DIKRgSEYZcBkMuwZCYMOQ2GHILhiSEIY/BkEcwJCUMeQ2GvIIhGWHIZzDkEwzJCUN+gyG/YEhBGAoYDAUEQ0rCUNBgKCgYUhGGQgZDIcGQmjAUNhgKC4Y0hKGIwVBEMKQlDEUNhqKCIR1hKGYwFBMM6QlDcYOhuGDIQBhKGAwlBENGwlDSYCgpGDIRhlIGQynBkJkwlDYYSguGLIShjMFQRjBkJQxlDYaygiEbYShnMJQTDNkJQ3mDobxgyEEYKhgMFQRDTsJQ0WCoKBhyEYZKBkMlwZCbMFQ2GCoLhjyEoYrBUEUw5CUMVQ2GqoIhH2GoZjBUEwz5CUN1g6G6YChAGGoYDDUEQ0HCUNNgqCkYChGGWgZDLcFQmDDUNhhqC4YihKGOwVBHMBQlDHUNhrqCoRhhqGcw1BMMxQlDfYOhvmAoQRgaGAwNBENJwtDQYGgoGEoRhkYGQyPBUJowNDYYGguGMoShicHQRDCUJQxNDYamgqEcYWhmMDQTDOUJQ3ODoblgqEAYWhgMLQRDRcLQ0mBoKRgqEYZWBkMrwVCZMLQ2GFoLhiqEoY3B0EYwVCUMbQ2GtoKhGmFoZzC0EwzVCUN7g6G9YKhBGDoYDB0EQ03C0NFg6CgYahGGTgZDJ8FQmzB0Nhg6C4Y6hKGLwdBFMNQlDF0Nhq6CoR5h6GYwdBMM9QlDd4Ohu2BoQBh6GAw9BENDwtDTYOgpGBoRhl4GQy/B0Jgw9DYYeguGJoShj8HQRzA0JQx9DYa+gqEZYehnMPQTDM0JQ3+Dob9gaEEYBhgMAwRDS8Iw0GAYKBhaEYZBBsMgwdCaMAw2GAYLhjaEYYjBMEQwtCUMQw2GoYKhHWEYZjAMEwztCcNwg2G4YOhAGEYYDCMEQ0fCMNJgGCkYOhGGUQbDKMHQmTCMNhhGC4YuhGGMwTBGMHQlDGMNhrGCoRthGGcwjBMM3QnDeINhvGDoQRgmGAwTBENPwjDRYJgoGHoRhkkGwyTB0JswTDYYJguGPoRhisEwRTD0JQxTDYapgqEfYZhmMEwTDP0Jw3SDYbpgGEAYZhgMMwTDQMIw02CYKRgGEYZZBsMswTCYMMw2GGYLhiGEYY7BMEcwDCUMcw2GuYJhGGGYZzDMEwzDCcN8g2G+YBhBGBYYDAsEw0jCsNBgWCgYRhGGRQbDIsEwmjAsNhgWC4YxhGGJwbBEMIwlDEsNhqWCYRxhWGYwLBMM4wnDcoNhuWCYQBhWGAwrBMNEwrDSYFgpGCYRhlUGwyrBMJkwrDYYVguGKYRhjcGwRjBMJQxrDYa1gmEaYVhnMKwTDNMJw3qDYb1gmEEYNhgMGwTDTMKw0WDYKBhmEYZNBsMmwTCbMGw2GDYLhjmEYYvBsEUwzCUMWw2GrYJhHmHYZjBsEwzzCcN2g2G7YFhAGHYYDDsEw0LCsNNg2CkYFhGGXQbDLsGwmDDsNhh2C4YlhGGPwbBHMCwlDHsNhr2CYRlh2Gcw7BMMywnDfoNhv2BYQRgOGAwHBMNKwnDQYDgoGFYRhkMGwyHBsJowHDYYDguGNYThiMFwRDCsJQxHDYajgmEdYThmMBwTDOsJw3GD4bhg2EAYThgMJwTDRsJw0mA4KRg2EYZTBsMpwbCZMJw2GE4Lhi2E4YzBcEYwbCUMZw2Gs4JhG2E4ZzCcEwzbCcN5g+G8YNhBGC4YDBcEw07CcNFguCgYdhGGSwbDJcGwmzBcNhguC4Y9hOGKwXBFMOwlDFcNhquCYR9huGYwXBMM+wnDdYPhumA4QBhuGAw3BMNBwnDTYLgpGA4RhlsGwy3BcJgw3DYYbguGI4ThjsFwRzAcJQx3DYa7guEYYbhnMNwTDMcJw32D4b5gOEEYHhgMDwTDScLw0GB4KBhOEYZHBsMjwXCaMDw2GB4LhjOE4YnB8EQwnCUMTw2Gp4LhHGF4ZjA8EwznCcNzg+G5YLhAGF4YDC8Ew0XC8NJgeCkYLhGGVwbDK8FwmTC8NhheC4YrhOGNwfBGMFwlDG8NhreC4RpheGcwvBMM1wnDe4PhvWC4QRg+GAwfBMNNwvDRYPgoGG4Rhk8GwyfBcJswfDYYPguGO4Thi8HwRTDcJQxfDYavguEeYfhmMHwTDPcJw3eD4btgeEAYfhgMPwTDQ8Lw02D4KRgeEYZfBsMvwfCYMPw2GH4LhieE4Y/B8EcwPCUMfw2Gv4LhGWH4p/P/3vCfNVjDc8Lwr8Hwr2B4QRgCGAwBBMNLwhDQYAgoGF4RhkAGQyDB8JowBDYYAguGN4QhiMEQRDC8JQxBDYagguEdYQhmMAQTDO8JQ3CDIbhg+EAYQhgMIQTDR8IQ0mAIKRg+EYZQBkMowfCZMIQ2GEILhi+EIYzBEEYwfCUMYQ2GsILhG2EIZzCEEwzfCUN4gyG8YPhBGCIYDBEEw0/CENFgiCgYfhGGSKQhyP/rvvx/3f5/DHGbcsdHb/1fHT/wXcB9/3d8lPbcNf3/N/9/3p+GuP2OxPXEsZFRIPI6/RuIODbcf399/kb976/N77j//WPhV9T/52+AYHiNiwKhwCgICoqCoeAoBAqJQqHQKAwKi8Kh8CgCiogiocgoCoqKoqHoKAaKiWKh2CgOioviofgoAUqIEqHEKAlKipKh5CgFSolSodQoDUqL0qH0KAPKiDKhzCgLyoqyoewoB8qJcqHcKA/Ki/Kh/KgAKogKocKoCCqKiqHiqAQqiUqh0qgMKovKofKoAqqIKqHKqAqqiqqh6qgGqolqodqoDqqL6qH6qAFqiBqhxqgJaoqaoeaoBWqJWqHWqA1qi9qh9qgD6og6oc6oC+qKuqHuqAfqiXqh3qgP6ov6of5oABqIBqHBaAgaioah4WgEGolGodFoDBqLxqHxaAKaiCahyWgKmoqmoeloBpqJZqHZaA6ai+ah+WgBWogWocVoCVqKlqHlaAVaiVah1WgNWovWofVoA9qINqHNaAvairah7WgH2ol2od1oD9qL9qH96AA6iA6hw+gIOoqOoePoBDqJTqHT6Aw6i86h8+gCuoguocvoCrqKrqHr6Aa6iW6h2+gOuovuofvoAXqIHqHH6Al6ip6h5+gFeoleodfoDXqL3qH36AP6iD6hz+gL+oq+oe/oB/qJfqHf6A/6i/4JjicMFAAFRIFQYBQEBUXBUHAUAoVEoVBoFAaFReFQeBQBRUSRUGQUBUVF0VB0FAPFRLFQbBQHxUXxUHyUACVEiVBilAQlRclQcpQCpUSpUGqUBqVF6VB6lAFlRJlQZpQFZUXZUHaUA+VEuVBulAflRflQflQAFUSFUGFUBBVFxVBxVAKVRKVQaVQGlUXlUHlUAVVElVBlVAVVRdVQdVQD1US1UG1UB9VF9VB91AA1RI1QY9QENUXNUHPUArVErVBr1Aa1Re1Qe9QBdUSdUGfUBXVF3VB31AP1RL1Qb9QH9UX9UH80AA1Eg9BgNAQNRcPQcDQCjUSj0Gg0Bo1F49B4NAFNRJPQZDQFTUXT0HQ0A81Es9BsNAfNRfPQfLQALUSL0GK0BC1Fy9BytAKtRKvQarQGrUXr0Hq0AW1Em9BmtAVtRdvQdrQD7US70G60B+1F+9B+dAAdRIfQYXQEHUXH0HF0Ap1Ep9BpdAadRefQeXQBXUSX0GV0BV1F19B1dAPdRLfQbXQH3UX30H30AD1Ej9Bj9AQ9Rc/Qc/QCvUSv0Gv0Br1F79B79AF9RJ/QZ/QFfUXf0Hf0A/1Ev9Bv9Af9Rf+EwPyjACggCoQCoyAoKAqGgqMQKCQKhUKjMCgsCofCowgoIoqEIqMoKCqKhqKjGCgmioViozgoLoqH4qMEKCFKhBKjJCgpSoaSoxQoJUqFUqM0KC1Kh9KjDCgjyoQyoywoK8qGsqMcKCfKhXKjPCgvyofyowKoICqECqMiqCgqhoqjEqgkKoVKozKoLCqHyqMKqCKqhCqjKqgqqoaqoxqoJqqFaqM6qC6qh+qjBqghaoQaoyaoKWqGmqMWqCVqhVqjNqgtaofaow6oI+qEOqMuqCvqhrqjHqgn6oV6oz6oL+qH+qMBaCAahAajIWgoGoaGoxFoJBqFRqMxaCwah8ajCWgimoQmoyloKpqGpqMZaCaahWajOWgumofmowVoIVqEFqMlaClahpajFWglWoVWozVoLVqH1qMNaCPahDajLWgr2oa2ox1oJ9qFdqM9aC/ah/ajA+ggOoQOoyPoKDqGjqMT6CQ6hU6jM+gsOofOowvoIrqELqMr6Cq6hq6jG+gmuoVuozvoLrqH7qMH6CF6hB6jJ+gpeoaeoxfoJXqFXqM36C16h96jD+gj+oQ+oy/oK/qGvqMf6Cf6hX6jP+gv+ick5h8FQAFRIBQYBUFBUTAUHIVAIVEoFBqFQWFROBQeRUARUSQUGUVBUVE0FB3FQDFRLBQbxUFxUTwUHyVACVEilBglQUlRMpQcpUApUSqUGqVBaVE6lB5lQBlRJpQZZUFZUTaUHeVAOVEulBvlQXlRPpQfFUAFUSFUGBVBRVExVByVQCVRKVQalUFlUTlUHlVAFVElVBlVQVVRNVQd1UA1US1UG9VBdVE9VB81QA1RI9QYNUFNUTPUHLVALVEr1Bq1QW1RO9QedUAdUSfUGXVBXVE31B31QD1RL9Qb9UF9UT/UHw1AA9EgNBgNQUPRMDQcjUAj0Sg0Go1BY9E4NB5NQBPRJDQZTUFT0TQ0Hc1AM9EsNBvNQXPRPDQfLUAL0SK0GC1BS9EytBytQCvRKrQarUFr0Tq0Hm1AG9EmtBltQVvRNrQd7UA70S60G+1Be9E+tB8dQAfRIXQYHUFH0TF0HJ1AJ9EpdBqdQWfROXQeXUAX0SV0GV1BV9E1dB3dQDfRLXQb3UF30T10Hz1AD9Ej9Bg9QU/RM/QcvUAv0Sv0Gr1Bb9E79B59QB/RJ/QZfUFf0Tf0Hf1AP9Ev9Bv9QX/RP6Ew/ygACogCocAoCAqKgqHgKAQKiUKh0CgMCovCofAoAoqIIqHIKAqKiqKh6CgGioliodgoDoqL4qH4KAFKiBKhxCgJSoqSoeQoBUqJUqHUKA1Ki9Kh9CgDyogyocwoC8qKsqHsKAfKiXKh3CgPyovyofyoACqICqHCqAgqioqh4qgEKolKodKoDCqLyqHyqAKqiCqhyqgKqoqqoeqoBqqJaqHaqA6qi+qh+qgBaogaocaoCWqKmqHmqAVqiVqh1qgNaovaofaoA+qIOqHOqAvqirqh7qgH6ol6od6oD+qL+qH+aAAaiAahwWgIGoqGoeFoBBqJRqHRaAwai8ah8WgCmogmocloCpqKpqHpaAaaiWah2WgOmovmofloAVqIFqHFaAlaipah5WgFWolWodVoDVqL1qH1aAPaiDahzWgL2oq2oe1oB9qJdqHdaA/ai/ah/egAOogOocPoCDqKjqHj6AQ6iU6h0+gMOovOofPoArqILqHL6Aq6iq6h6+gGuoluodvoDrqL7qH76AF6iB6hx+gJeoqeoefoBXqJXqHX6A16i96h9+gD+og+oc/oC/qKvqHv6Af6iX6h3+gP+ov+CY35RwFQQBQIBUZBUFAUDAVHIVBIFAqFRmFQWBQOhUcRUEQUCUVGUVBUFA1FRzFQTBQLxUZxUFwUD8VHCVBClAglRklQUpQMJUcpUEqUCqVGaVBalA6lRxlQRpQJZUZZUFaUDWVHOVBOlAvlRnlQXpQP5UcFUEFUCBVGRVBRVAwVRyVQSVQKlUZlUFlUDpVHFVBFVAlVRlVQVVQNVUc1UE1UC9VGdVBdVA/VRw1QQ9QINUZNUFPUDDVHLVBL1Aq1Rm1QW9QOtUcdUEfUCXVGXVBX1A11Rz1QT9QL9UZ9UF/UD/VHA9BANAgNRkPQUDQMDUcj0Eg0Co1GY9BYNA6NRxPQRDQJTUZT0FQ0DU1HM9BMNAvNRnPQXDQPzUcL0EK0CC1GS9BStAwtRyvQSrQKrUZr0Fq0Dq1HG9BGtAltRlvQVrQNbUc70E60C+1Ge9BetA/tRwfQQXQIHUZH0FF0DB1HJ9BJdAqdRmfQWXQOnUcX0EV0CV1GV9BVdA1dRzfQTXQL3UZ30F10D91HD9BD9Ag9Rk/QU/QMPUcv0Ev0Cr1Gb9Bb9A69Rx/QR/QJfUZf0Ff0DX1HP9BP9Av9Rn/QX/RPGMw/CoACokAoMAqCgqJgKDgKgUKiUCg0CoPConAoPIqAIqJIKDKKgqKiaCg6ioFiolgoNoqD4qJ4KD5KgBKiRCgxSoKSomQoOUqBUqJUKDVKg9KidCg9yoAyokwoM8qCsqJsKDvKgXKiXCg3yoPyonwoPyqACqJCqDAqgoqiYqg4KoFKolKoNCqDyqJyqDyqgCqiSqgyqoKqomqoOqqBaqJaqDaqg+qieqg+aoAaokaoMWqCmqJmqDlqgVqiVqg1aoPaonaoPeqAOqJOqDPqgrqibqg76oF6ol6oN+qD+qJ+qD8agAaiQWgwGoKGomFoOBqBRqJRaDQag8aicWg8moAmokloMpqCpqJpaDqagWaiWWg2moPmonloPlqAFqJFaDFagpaiZWg5WoFWolVoNVqD1qJ1aD3agDaiTWgz2oK2om1oO9qBdqJdaDfag/aifWg/OoAOokPoMDqCjqJj6Dg6gU6iU+g0OoPOonPoPLqALqJL6DK6gq6ia+g6uoFuolvoNrqD7qJ76D56gB6iR+gxeoKeomfoOXqBXqJX6DV6g96id+g9+oA+ok/oM/qCvqJv6Dv6gX6iX+g3+oP+on/CYv5RABQQBUKBURAUFAVDwVEIFBKFQqFRGBQWhUPhUQQUEUVCkVEUFBVFQ9FRDBQTxUKxURwUF8VD8VEClBAlQolREpQUJUPJUQqUEqVCqVEalBalQ+lRBpQRZUKZURaUFWVD2VEOlBPlQrlRHpQX5UP5UQFUEBVChVERVBQVQ8VRCVQSlUKlURlUFpVD5VEFVBFVQpVRFVQVVUPVUQ1UE9VCtVEdVBfVQ/VRA9QQNUKNURPUFDVDzVEL1BK1Qq1RG9QWtUPtUQfUEXVCnVEX1BV1Q91RD9QT9UK9UR/UF/VD/dEANBANQoPREDQUDUPD0Qg0Eo1Co9EYNBaNQ+PRBDQRTUKT0RQ0FU1D09EMNBPNQrPRHDQXzUPz0QK0EC1Ci9EStBQtQ8vRCrQSrUKr0Rq0Fq1D69EGtBFtQpvRFrQVbUPb0Q60E+1Cu9EetBftQ/vRAXQQHUKH0RF0FB1Dx9EJdBKdQqfRGXQWnUPn0QV0EV1Cl9EVdBVdQ9fRDXQT3UK30R10F91D99ED9BA9Qo/RE/QUPUPP0Qv0Er1Cr9Eb9Ba9Q+/RB/QRfUKf0Rf0FX1D39EP9BP9Qr/RH/QX/RPu//kcQgAUEAVCgVEQFBQFQ8FRCBQShUKhURgUFoVD4VEEFBFFQpFRFBQVRUPRUQwUE8VCsVEcFPc/n39A8VEClBAlQolREpQUJUPJUQqUEqVCqVEalBalQ+lRBpQRZUKZURaUFWVD2VEOlBPlQrlRHpQX5UP5UQFUEBVChVERVBQVQ8VRCVQSlUKlURlUFpVD5VEFVBFVQpVRFVQVVUPVUQ1UE9VCtVEdVBfVQ/VRA9QQNUKNURPUFDVDzVEL1BK1Qq1RG9QWtUPtUQfUEXVCnVEX1BV1Q91RD9QT9UK9UR/UF/VD/dEANBANQoPREDQUDUPD0Qg0Eo1Co9EYNBaNQ+PRBDQRTUKT0RQ0FU1D09EMNBPNQrPRHDQXzUPz0QK0EC1Ci9EStBQtQ8vRCrQSrUKr0Rq0Fq1D69EGtBFtQpvRFrQVbUPb0Q60E+1Cu9EetBftQ/vRAXQQHUKH0RF0FB1Dx9EJdBKdQqfRGXQWnUPn0QV0EV1Cl9EVdBVdQ9fRDXQT3UK30R10F91D99ED9BA9Qo/RE/QUPUPP0Qv0Er1Cr9Eb9Ba9Q+/RB/QRfUKf0Rf0FX1D39EP9BP9Qr/RH/QX/RMe848CoIAoEAqMgqCgKBgKjkKgkCgUCo3CoLAoHAqPIqCIKBKKjKKgqCgaio5ioJgoFoqN4qC4KB6KjxKghCgRSoySoKQoGUqOUqCUKBVKjdKgtCgdSo8yoIwoE8qMsqCsKBvKjnKgnCgXyo3yoLwoH8qPCqCCqBAqjIqgoqgYKo5KoJKoFCqNyqCyqBwqjyqgiqgSqoyqoKqoGqqOaqCaqBaqjeqguqgeqo8aoIaoEWqMmqCmqBlqjlqglqgVao3aoLaoHWqPOqCOqBPqjLqgrqgb6o56oJ6oF+qN+qC+qB/qjwaggWgQGoyGoKFoGBqORqCRaBQajcagsWgcGo8moIloEpqMpqCpaBqajmagmWgWmo3moLloHpqPFqCFaBFajJagpWgZWo5WoJVoFVqN1qC1aB1ajzagjWgT2oy2oK1oG9qOdqCdaBfajfagvWgf2o8OoIPoEDqMjqCj6Bg6jk6gk+gUOo3OoLPoHDqPLqCL6BK6jK6gq+gauo5uoJvoFrqN7qC76B66jx6gh+gReoyeoKfoGXqOXqCX6BV6jd6gt+gdeo8+oI/oE/qMvqCv6Bv6jn6gn+gX+o3+oL/onwiYfxQABUSBUGAUBAVFwVBwFAKFRKFQaBQGhUXhUHgUAUVEkVBkFAVFRdFQdBQDxUSxUGwUB8VF8VB8lAAlRIlQYpQEJUXJUHKUAqVEqVBqlAalRelQepQBZUSZUGaUBWVF2VB2lAPlRLlQbpQH5UX5UH5UABVEhVBhVAQVRcVQcVQClUSlUGlUBpVF5VB5VAFVRJVQZVQFVUXVUHVUA9VEtVBtVAfVRfVQfdQANUSNUGPUBDVFzVBz1AK1RK1Qa9QGtUXtUHvUAXVEnVBn1AV1Rd1Qd9QD9US9UG/UB/VF/VB/NAANRIPQYDQEDUXD0HA0Ao1Eo9BoNAaNRePQeDQBTUST0GQ0BU1F09B0NAPNRLPQbDQHzUXz0Hy0AC1Ei9BitAQtRcvQcrQCrUSr0Gq0Bq1F69B6tAFtRJvQZrQFbUXb0Ha0A+1Eu9ButAftRfvQfnQAHUSH0GF0BB1Fx9BxdAKdRKfQaXQGnUXn0Hl0AV1El9BldAVdRdfQdXQD3US30G10B91F99B99AA9RI/QY/QEPUXP0HP0Ar1Er9Br9Aa9Re/Qe/QBfUSf0Gf0BX1F39B39AP9RL/Qb/QH/UX/RMT8owAoIAqEAqMgKCgKhoKjECgkCoVCozAoLAqHwqMIKCKKhCKjKCgqioaioxgoJoqFYqM4KC6Kh+KjBCghSoQSoyQoKUqGkqMUKCVKhVKjNCgtSofSowwoI8qEMqMsKCvKhrKjHCgnyoVyozwoL8qH8qMCqCAqhAqjIqgoKoaKoxKoJCqFSqMyqCwqh8qjCqgiqoQqoyqoKqqGqqMaqCaqhWqjOqguqofqowaoIWqEGqMmqClqhpqjFqglaoVaozaoLWqH2qMOqCPqhDqjLqgr6oa6ox6oJ+qFeqM+qC/qh/qjAWggGoQGoyFoKBqGhqMRaCQahUajMWgsGofGowloIpqEJqMpaCqahqajGWgmmoVmozloLpqH5qMFaCFahBajJWgpWoaWoxVoJVqFVqM1aC1ah9ajDWgj2oQ2oy1oK9qGtqMdaCfahXajPWgv2of2owPoIDqEDqMj6Cg6ho6jE+gkOoVOozPoLDqHzqML6CK6hC6jK+gquoauoxvoJrqFbqM76C66h+6jB+gheoQeoyfoKXqGnqMX6CV6hV6jN+gteofeow/oI/qEPqMv6Cv6hr6jH+gn+oV+oz/ob8T/fNEB848CoIAoEAqMgqCgKBgKjkKgkCgUCo3CoLAoHAqPIqCIKBKKjKKgqCgaio5ioJgoFoqN4qC4KB6KjxKghCgRSoySoKQoGUqOUqCUKBVKjdKgtCgdSo8yoIwoE8qMsqCsKBvKjnKgnCgXyo3yoLwoH8qPCqCCqBAqjIqgoqgYKo5KoJKoFCqNyqCyqBwqjyqgiqgSqoyqoKqoGqqOaqCaqBaqjeqguqgeqo8aoIaoEWqMmqCmqBlqjlqglqgVao3aoLaoHWqPOqCOqBPqjLqgrqgb6o56oJ6oF+qN+qC+qB/qjwaggWgQGoyGoKFoGBqORqCRaBQajcagsWgcGo8moIloEpqMpqCpaBqajmagmWgWmo3moLloHpqPFqCFaBFajJagpWgZWo5WoJVoFVqN1qC1aB1ajzagjWgT2oy2oK1oG9qOdqCdaBfajfagvWgf2o8OoIPoEDqMjqCj6Bg6jk6gk+gUOo3OoLPoHDqPLqCL6BK6jK6gq+gauo5uoJvoFrqN7qC76B66jx6gh+gReoyeoKfoGXqOXqCX6BV6jd6gt+gdeo8+oI/oE/qMvqCv6Bv6jn6gn+gX+o3+oL/on8iYfxQABUSBUGAUBAVFwVBwFAKFRKFQaBQGhUXhUHgUAUVEkVBkFAVFRdFQdBQDxUSxUGwUB8VF8VB8lAAlRIlQYpQEJUXJUHKUAqVEqVBqlAalRelQepQBZUSZUGaUBWVF2VB2lAPlRLlQbpQH5UX5UH5UABVEhVBhVAQVRcVQcVQClUSlUGlUBpVF5VB5VAFVRJVQZVQFVUXVUHVUA9VEtVBtVAfVRfVQfdQANUSNUGPUBDVFzVBz1AK1RK1Qa9QGtUXtUHvUAXVEnVBn1AV1Rd1Qd9QD9US9UG/UB/VF/VB/NAANRIPQYDQEDUXD0HA0Ao1Eo9BoNAaNRePQeDQBTUST0GQ0BU1F09B0NAPNRLPQbDQHzUXz0Hy0AC1Ei9BitAQtRcvQcrQCrUSr0Gq0Bq1F69B6tAFtRJvQZrQFbUXb0Ha0A+1Eu9ButAftRfvQfnQAHUSH0GF0BB1Fx9BxdAKdRKfQaXQGnUXn0Hl0AV1El9BldAVdRdfQdXQD3US30G10B91F99B99AA9RI/QY/QEPUXP0HP0Ar1Er9Br9Aa9Re/Qe/QBfUSf0Gf0BX1F39B39AP9RL/Qb/QH/UX/RMH8owAoIAqEAqMgKCgKhoKjECgkCoVCozAoLAqHwqMIKCKKhCKjKCgqioaioxgoJoqFYqM4KC6Kh+KjBCghSoQSoyQoKUqGkqMUKCVKhVKjNCgtSofSowwoI8qEMqMsKCvKhrKjHCgnyoVyozwoL8qH8qMCqCAqhAqjIqgoKoaKoxKoJCqFSqMyqCwqh8qjCqgiqoQqoyqoKqqGqqMaqCaqhWqjOqguqofqowaoIWqEGqMmqClqhpqjFqglaoVaozaoLWqH2qMOqCPqhDqjLqgr6oa6ox6oJ+qFeqM+qC/qh/qjAWggGoQGoyFoKBqGhqMRaCQahUajMWgsGofGowloIpqEJqMpaCqahqajGWgmmoVmozloLpqH5qMFaCFahBajJWgpWoaWoxVoJVqFVqM1aC1ah9ajDWgj2oQ2oy1oK9qGtqMdaCfahXajPWgv2of2owPoIDqEDqMj6Cg6ho6jE+gkOoVOozPoLDqHzqML6CK6hC6jK+gquoauoxvoJrqFbqM76C66h+6jB+gheoQeoyfoKXqGnqMX6CV6hV6jN+gteofeow/oI/qEPqMv6Cv6hr6jH+gn+oV+oz/oL/onKuYfBUABUSAUGAVBQVEwFByFQCFRKBQahUFhUTgUHkVAEVEkFBlFQVFRNBQdxUAxUSwUG8VBcf/znWYUHyVACVEilBglQUlRMpQcpUApUSqUGqVBaVE6lB5lQBlRJpQZZUFZUTaUHeVAOVEulBvlQXlRPpQfFUAFUSFUGBVBRVExVByVQCVRKVQalUFlUTlUHlVAFVElVBlVQVVRNVQd1UA1US1UG9VBdVE9VB81QA1RI9QYNUFNUTPUHLVALVEr1Bq1QW1RO9QedUAdUSfUGXVBXVE31B31QD1RL9Qb9UF9UT/UHw1AA9EgNBgNQUPRMDQcjUAj0Sg0Go1BY9E4NB5NQBPRJDQZTUFT0TQ0Hc1AM9EsNBvNQXPRPDQfLUAL0SK0GC1BS9EytBytQCvRKrQarUFr0Tq0Hm1AG9EmtBltQVvRNrQd7UA70S60G+1Be9E+tB8dQAfRIXQYHUFH0TF0HJ1AJ9EpdBqdQWfROXQeXUAX0SV0GV1BV9E1dB3dQDfRLXQb3UF30T10Hz1AD9Ej9Bg9QU/RM/QcvUAv0Sv0Gr1Bb9E79B59QB/RJ/QZfUFf0Tf0Hf1AP6P+P9/3/43+oP/8psA/0TD/KAAKiAKhwCgICoqCoeAoBAqJQqHQKAwKi8Kh8CgCiogiocgoCoqKoqHoKAaKiWKh2CgOioviofgoAUqIEqHEKAlKipKh5CgFSolSodQoDUqL0qH0KAPKiDKhzCgLyoqyoewoB8qJcqHcKA/Ki/Kh/KgAKogKocKoCCqKiqHiqAQqiUqh0qgMKovKofKoAqqIKqHKqAqqiqqh6qgGqolqodqoDqqL6qH6qAFqiBqhxqgJaoqaoeaoBWqJWqHWqA1qi9qh9qgD6og6oc6oC+qKuqHuqAfqiXqh3qgP6ov6of5oABqIBqHBaAgaioah4WgEGolGodFoDBqLxqHxaAKaiCahyWgKmoqmoeloBpqJZqHZaA6ai+ah+WgBWogWocVoCVqKlqHlaAVaiVah1WgNWovWofVoA9qINqHNaAvairah7WgH2ol2od1oD9qL9qH96AA6iA6hw+gIOoqOoePoBDqJTqHT6Aw6i86h8+gCuoguocvoCrqKrqHr6Aa6iW6h2+gOuovuofvoAXqIHqHH6Al6ip6h5+gFeoleodfoDXqL3qH36AP6iD6hz+gL+oq+oe/oB/qJfqHf6A/6i/6JjvlHAVBAFAgFRkFQUBQMBUchUEgUCoVGYVBYFA6FRxFQRBQJRUZRUFQUDUVHMVBMFAvFRnFQXBQPxUcJUEKUCCVGSVBSlAwlRylQSpQKpUZpUFqUDqVHGVBGlAllRllQVpQNZUc5UE6UC+VGeVBelA/lRwVQQVQIFUZFUFFUDBVHJVBJVAqVRmVQWVQOlUcVUEVUCVVGVVBVVA1VRzVQTVQL1UZ1UF1UD9VHDVBD1Ag1Rk1QU9QMNUctUEvUCrVGbVBb1A61Rx1QR9QJdUZdUFfUDXVHPVBP1Av1Rn1QX9QP9UcD0EA0CA1GQ9BQNAwNRyPQSDQKjUZj0Fg0Do1HE9BENAlNRlPQVDQNTUcz0Ew0C81Gc9BcNA/NRwvQQrQILUZL0FK0DC1HK9BKtAqtRmvQWrQOrUcb0Ea0CW1GW9BWtA1tRzvQTrQL7UZ70F60D+1HB9BBdAgdRkfQUXQMHUcn0El0Cp1GZ9BZdA6dRxfQRXQJXUZX0FV0DV1HN9BNdAvdRnfQXXQP3UcP0EP0CD1GT9BT9Aw9Ry/QS/QKvUZv0Fv0Dr1HH9BH9Al9Rl/QV/QNfUc/0E/0C/1Gf9Bf9E8MzD8KgAKiQCgwCoKComAoOAqBQqJQKDQKg8KicCg8ioAiokgoMoqCoqJoKDqKgWKiWCg2ioPiongoPkqAEqJEKDFKgpKiZCg5SoFSolQoNUqD0qJ0KD3KgDKiTCgzyoKyomwoO8qBcqJcKDfKg/KifCg/KoAKokKoMCqCiqJiqDgqgUqiUqg0KoPKonKoPKqAKqJKqDKqgqqiaqg6qoFqolqoNqqD6qJ6qD5qgBqiRqgxaoKaomaoOWqBWqJWqDVqg9qidqg96oA6ok6oM+qCuqJuqDvqgXqiXqg36oP6on6oPxqABqJBaDAagoaiYWg4GoFGolFoNBqDxqJxaDyagCaiSWgymoKmomloOpqBZqJZaDaag+aieWg+WoAWokVoMVqClqJlaDlagVaiVWg1WoPWonVoPdqANqJNaDPagraibWg72oF2ol1oN9qD9qJ9aD86gA6iQ+gwOoKOomPoODqBTqJT6DQ6g86ic+g8uoAuokvoMrqCrqJr6Dq6gW6iW+g2uoPuonvoPnqAHqJH6DF6gp6iZ+g5eoFeolfoNXqD3qJ36D36gD6iT+gz+oK+om/oO/qBfqJf6Df6g/6if2Ji/lEAFBAFQoFREBQUBUPBUQgUEoVCoVEYFBaFQ+FRBBQRRUKRURQUFUVD0VEMFBPFQrFRHBQXxUPxUQKUECVCiVESlBQlQ8lRCpQSpUKpURqUFqVD6VEGlBFlQplRFpQVZUPZUQ6UE+VCuVEelBflQ/lRAVQQFUKFURFUFBVDxVEJVBKVQqVRGVQWlUPlUQVUEVVClVEVVBVVQ9VRDVQT1UK1UR1UF9VD9VED1BA1Qo1RE9QUNUPNUQvUErVCrVEb1Ba1Q+1RB9QRdUKdURfUFXVD3VEP1BP1Qr1RH9QX9UP90QA0EA1Cg9EQNBQNQ8PRCDQSjUKj0Rg0Fo1D49EENBFNQpPRFDQVTUPT0Qw0E81Cs9EcNBfNQ/PRArQQLUKL0RK0FC1Dy9EKtBKtQqvRGrQWrUPr0Qa0EW1Cm9EWtBVtQ9vRDrQT7UK70R60F+1D+9EBdBAdQofREXQUHUPH0Ql0Ep1Cp9EZdBadQ+fRBXQRXUKX0RV0FV1D19ENdBPdQrfRHXQX3UP30QP0ED1Cj9ET9BQ9Q8/RC/QSvUKv0Rv0Fr1D79EH9BF9Qp/RF/QVfUPf0Q/0E/1Cv9Ef9Bf9EwvzjwKggCgQCoyCoKAoGAqOQqCQKBQKjcKgsCgcCo8ioIgoEoqMoqCoKBqKjmKgmCgWio3ioLgoHoqPEqCEKBFKjJKgpCgZSo5SoJQoFUqN0qC0KB1KjzKgjCgTyoyyoKwoG8qOcqCcKBfKjfKgvCgfyo8KoIKoECqMiqCiqBgqjkqgkqgUKo3KoLKoHCqPKqCKqBKqjKqgqqgaqo5qoJqoFqqN6qC6qB6qjxqghqgRaoyaoKaoGWqOWqCWqBVqjdqgtqgdao86oI6oE+qMuqCuqBvqjnqgnqgX6o36oL6oH+qPBqCBaBAajIagoWgYGo5GoJFoFBqNxqCxaBwajyagiWgSmoymoKloGpqOZqCZaBaajeaguWgemo8WoIVoEVqMlqClaBlajlaglWgVWo3WoLVoHVqPNqCNaBPajLagrWgb2o52oJ1oF9qN9qC9aB/ajw6gg+gQOoyOoKPoGDqOTqCT6BQ6jc6gs+gcOo8uoIvoErqMrqCr6Bq6jm6gm+gWuo3uoLvoHrqPHqCH6BF6jJ6gp+gZeo5eoJfoFXqN3qC36B16jz6gj+gT+oy+oK/oG/qOfqCf6Bf6jf6gv+if2Jh/FAAFRIFQYBQEBUXBUHAUAoVEoVBoFAaFReFQeBQBRUSRUGQUBUVF0VB0FAPFRLFQbBQHxUXxUHyUACVEiVBilAQlRclQcpQCpUSpUGqUBqVF6VB6lAFlRJlQZpQFZUXZUHaUA+VEuVBulAflRflQflQAFUSFUGFUBBVFxVBxVAKVRKVQaVQGlUXlUHlUAVVElVBlVAVVRdVQdVQD1US1UG1UB9VF9VB91AA1RI1QY9QENUXNUHPUArVErVBr1Aa1Re1Qe9QBdUSdUGfUBXVF3VB31AP1RL1Qb9QH9UX9UH80AA1Eg9BgNAQNRcPQcDQCjUSj0Gg0Bo1F49B4NAFNRJPQZDQFTUXT0HQ0A81Es9BsNAfNRfPQfLQALUSL0GK0BC1Fy9BytAKtRKvQarQGrUXr0Hq0AW1Em9BmtAVtRdvQdrQD7US70G60B+1F+9B+dAAdRIfQYXQEHUXH0HF0Ap1Ep9BpdAadRefQeXQBXUSX0GV0BV1F19B1dAPdRLfQbXQH3UX30H30AD1Ej9Bj9AQ9Rc/Qc/QCvUSv0Gv0Br1F79B79AF9RJ/QZ/QFfUXf0Hf0A/1Ev9Bv9Af9Rf/EwfyjACggCoQCoyAoKAqGgqMQKCQKhUKjMCgsCofCowgoIoqEIqMoKCqKhqKjGCgmioViozgoLoqH4qMEKCFKhBKjJCgpSoaSoxQoJUqFUqM0KC1Kh9KjDCgjyoQyoywoK8qGsqMcKCfKhXKjPCgvyofyowKoICqECqMiqCgqhoqjEqgkKoVKozKoLCqHyqMKqCKqhCqjKqgqqoaqoxqoJqqFaqM6qC6qh+qjBqghaoQaoyaoKWqGmqMWqCVqhVqjNqgtaofaow6oI+qEOqMuqCvqhrqjHqgn6oV6oz6oL+qH+qMBaCAahAajIWgoGoaGoxFoJBqFRqMxaCwah8ajCWgimoQmoyloKpqGpqMZaCb6//X1x3F1x//8/5+ZSWZmZmZmJkmSJEmSJEmSZGZmJjMzMzMzM5nJZGZmJjMzkyRJ0jtJkvTuPTOTSZIkSZIkSZIkSX6P+bwvv69/dj2Xy+1yulyuf5/qnPN6Pe8N0c9FjdHPR03RL0TN0S9GLdEvRa3RL0dt0a9E7dGvRh3Re6LO6NeirujXo+7oN6Ke6Dej3ui3or7ot6P+6Heigei90WD0vuhF9LvRy+j3olfR70evoz+IhqI/jN5EfxQNR38cjUR/Eo1GfxqNRX8WjUd/Hk1EfxFNRn8ZTUV/FU1Hfx3NRH8TzUZ/G81FfxfNR38fLUT/EC1G/xgtRf8ULUf/HK1E/xKtRv8arUX/Fq1H/x5tRP8RbUb/GW1F/xVtR/8d7UT/EyV8fLz+o13RB0a7ow+K9kQfHCVGHxIlRR8a7Y0+LNoXfXi0P/qI6ED0kdHB6KOiQ9FHR4ejj4mORB8bHY0+LjoWffzbc8qjT4iSo0+MUqJPilKjT47Sok+J0qNPjTKiT4syo0+PsqLPiLKjz4xyos+KcqPPjvKiz4nyo8+NCqLPiwqjz4+Koi+IiqMvjEqiL4pKoy+OyqIvicqjL40qoi+LKqMvj6qir4hORF8ZnYy+KjoVfXV0Ovqa6Ez0tdHZ6Oui6ujro3PRN0Tno2+MLkTfFF2Mvjm6FH1LdDn61uhK9G3R1ejbo2vRd0TXo++MbkTfFd2Mvjuqib4nuhV9b3Q7+r6oNvr+6E70A1Fd9IPR3eiHonvRD0f3ox+JHkQ/Gj2Mfix6FP14VB/9RPQ4+snoSfRT0dPop6Nn0c9Ez6OfjRqin4sao5+PmqJfiJqjX4xaol+KWqNfjtqiX4nao1+NOqL3RJ3Rr0Vd0a9H3dFvRD3Rb0a90W9FfdFvR/3R70QD0Xujweh90Yvod6OX0e9Fr6Lfj15HfxANRX8YvYn+KBqO/jgaif4kGo3+NBqL/iwaj/48ertp/3YT/u2m+ttN8reb3m83sd9uSr/dZH67afx2E/jtpu7bTdq3m65vN1Hfboq+3eR8u2n5dhPy7abi203Ct5t+bzfx3m7Kvd1ke7tp9nYT7O2m1ttNqrebTm83kd5uCr3d5Hm7afN2E+btpsrbTZK3mx5vNzHebkq83Qd4e97//38wIOH/bVN8YML/2zv4oIT/tw/xwdH7jwhPeP9RoQnvPzIs4f1HhyS8/xbihPffSpTw/kuKE95/aVHC+79iTHj/R40J73/LkfD+Xz3/u1PwCVFy9IlRSvRJUWr0yVFa9ClRevSpUUb0aVFm9OlRVvQZUXb0mVFO9FlRbvTZUV70OVF+9LlRQfR5UWH0+VFR9AVRcfSFUUn0RVFp9MVRWfQlUXn0pVFF9GVRZfTlUVX0FdGJ6Cujk9FXRaeir45OR18TnYm+NjobfV1UHX19dC76huh89I3RheiboovRN0eXom+JLkffGl2Jvi26Gn17dC36juh69J3RjYT/nb1MuBl9d1QTfU90K/re6Hb0fVFt9P3RnegHorroB6O70Q9F96Ifju5HPxI9iH40ehj9WPQo+vGoPvqJ6HH0k9GT6Keip9FPR8+in4meRz8bNUQ/FzVGPx81Rb8QNUe/GLVEvxS1Rr8ctUW/ErVHvxp1RO+JOqNfi7qiX4+6o9+IeqLfjHqj34r6ot+O+qPfiQai90aD0fuiF9HvRi+j34teRb8fvY7+IBqK/jB6E/1RNBz9cTQS/Uk0Gv1pNBb9WTQe/Xk0Ef1FNBn9ZTQV/VU0Hf11NBP9TTQb/W00F/1dNB/9fbQQ/UO0GP1jtBT9U7Qc/XO0Ev1LtBr9a7QW/Vu0Hv17tBH9R7QZ/We0Ff1XtB39d7QT/U/09sX/AdGu6AOj3dEHRXuiD44Sow+JkqIPjfZGHxbtiz482h99RHQg+sjoYPRR0aHoo6PD0cdER6KPjY5GHxcdiz4+Oh59QpQcfWKUEn1SlBp9cpQWfUqUHn1qlBF9WpQZfXqUFX1GlB19ZpQTfVaUG312lBd9TpQffW5UEH1eVBh9flQUfUFUHH1hVBJ9UVQafXFUFn1JVB59aVQRfVlUGX15VBV9RXQi+sroZPRV0anoq6PT0ddEZ6Kvjc5GXxdVR18fnYu+IToffWN0Ifqm6GL0zdGl6Fuiy9G3Rleib4uuRt8eXYu+I7oefWd0I/qu6Gb03VFN9D3Rreh7o9vR90W10fdHd6IfiOqiH4zuRj8U3Yt+OLof/Uj0IPrR6GH0Y9Gj6Mej+ugnosfRT0ZPop+KnkY/HT2LfiZ6Hv1s1BD9XNQY/XzUFP1C1Bz9YtQS/VLUGv1y1Bb9StQe/WrUEb0n6ox+LeqKfj3qjn4j6ol+M+qNfivqi3476o9+JxqI3hsNRu+LXkS/G72Mfi96Ff1+9Dr6g2go+sPoTfRH0XD0x9FI9CfRaPSn0Vj0Z9F49OfRRPQX0WT0l9FU9FfRdPTX0Uz0N9Fs9LfRXPR30Xz099FC9A/RYvSP0VL0T9Fy9M/RSvQv0Wr0r9Fa9G/RevTv0Ub0H9Fm9J/RVvRf0Xb039FO9D/R2z/8HxDtij4w2h19ULQn+uAoMfqQKCn60Ghv9GHRvujDo/3RR0QHoo+MDkYfFR2KPjo6HH1MdCT62Oho9HHRsejjo+PRJ0TJ0SdGKdEnRanRJ0dp0adE6dGnRhnRp0WZ0adHWdFnRNnRZ0Y50WdFudFnR3nR50T50edGBdHnRYXR50dF0RdExdEXRiXRF0Wl0RdHZdGXROXRl0YV0ZdFldGXR1XRV0Qnoq+MTkZfFZ2Kvjo6HX1NdCb62uhs9HVRdfT10bnoG6Lz0TdGF6Jvii5G3xxdir4luhx9a3Ql+rboavTt0bXoO6Lr0XdGN6Lvim5G3x3VRN8T3Yq+N7odfV9UG31/dCf6gagu+sHobvRD0b3oh6P70Y9ED6IfjR5GPxY9in48qo9+Inoc/WT0JPqp6Gn009Gz6Gei59HPRg3Rz0WN0c9HTdEvRM3RL0Yt0S9FrdEvR23Rr0Tt0a9GHdF7os7o16Ku6Nej7ug3op7oN6Pe6Leivui3o/7od6KB6L3RYPS+6EX0u9HL6PeiV9HvR6+jP4iGoj+M3kR/FA1HfxyNRH8SjUZ/Go1FfxaNR38eTUR/EU1GfxlNRX8VTUd/Hc1EfxPNRn8bzUV/F81Hfx8tRP8QLUb/GC1F/xQtR/8crUT/Eq1G/xqtRf8WrUf/Hm1E/xFtRv8ZbUX/FW1H/x3tRP8Tvf2n/wOiXdEHRrujD4r2RB8cJUYfEiVFHxrtjT4s2hd9eLQ/+ojoQPSR0cHoo6JD0UdHh6OPiY5EHxsdjT4uOhZ9fHQ8+oQoOfrEKCX6pCg1+uQoLfqUKD361Cgj+rQoM/r0KCv6jCg7+swoJ/qsKDf67Cgv+pwoP/rcqCD6vKgw+vyoKPqCqDj6wqgk+qKoNPriqCz6kqg8+tKoIvqyqDL68qgq+oroRPSV0cnoq6JT0VdHp6Ovic5EXxudjb4uqo6+PjoXfUN0PvrG6EL0TdHF6JujS9G3RJejb42uRN8WXY2+PboWfUd0PfrO6Eb0XdHN6Lujmuh7olvR90a3o++LaqPvj+5EPxDVRT8Y3Y1+KLoX/XB0P/qR6EH0o9HD6MeiR9GPR/XRT0SPo5+MnkQ/FT2Nfjp6Fv1M9Dz62agh+rmoMfr5qCn6hag5+sWoJfqlqDX65agt+pWoPfrVqCN6T9QZ/VrUFf161B39RtQT/WbUG/1W1Bf9dtQf/U40EL03GozeF72Ifjd6Gf1e9Cr6/eh19AfRUPSH0Zvoj6Lh6I+jkehPotHoT6Ox6M+i8ejPo4noL6LJ6C+jqeivounor6OZ6G+i2ehvo7no76L56O+jhegfosXoH6Ol6J+i5eifo5XoX6LV6F+jtejfovXo36ON6D+izeg/o63ov6Lt6L+jneh/ordv+N9uFu6KPjDaHX1QtCf64Cgx+pAoKfrQaG/0YdG+6MOj/dFHRAeij4wORh8VHYo+OjocfUx0JPrY6Gj0cdGx6OPfbiVGnxAlR58YpUSfFKVGnxylRZ8SpUefGmVEnxZlRp8eZUWfEWVHnxnlRJ8V5UafHeVFnxPlR58bFUSfFxVGnx8VRV8QFUdfGJVEXxSVRl8clUVfEpVHXxpVRF8WVUZfHlVFXxGdiL4yOhl9VXQq+urodPQ10Znoa6Oz0ddF1dHXR+eib4jOR98YXYi+KboYfXN0KfqW6HL0rdGV6Nuiq9G3R9ei74iuR98Z3Yi+K7oZfXdUE31PdCv63uh29H1RbfT90Z3oB6K66Aeju9EPRfeiH47uRz8SPYh+NHoY/Vj0KPrxqD76iehx9JPRk+inoqfRT0fPop+Jnkc/GzVEPxc1Rj8fNUW/EDVHvxi1RL8UtUa/HLVFvxK1R78adUTviTqjX4u6ol+PuqPfiHqi34x6o9+K+qLfjvqj34kGovdGg9H7ohfR70Yvo9+LXkW/H72O/iAaiv4wehP9UTQc/XE0Ev1JNBr9aTQW/Vk0Hv15NBH9RTQZ/WU0Ff1VNB39dTQT/U00G/1tNBf9XTQf/X20EP1DtBj9Y7QU/VO0HP1ztBL9S7Qa/Wu0Fv1btB79e7QR/Ue0Gf1ntBX9V7Qd/Xe0E/1P9PbDvg+IdkUfGO2OPijaE31wlBh9SJQUfWi0N/qwaF/04dH+6COiA9FHRgejj4oORR8dHY4+JjoSfWx0NPq46Fj08dHx6BOi5OgTo5Tok6LU6JOjtOhTovToU6OM6NOizOjTo6zoM6Ls6DOjnOizotzos6O86HOi/Ohzo4Lo86LC6POjougLouLoC6OS6Iui0uiLo7LoS6Ly6EujiujLosroy6Oq6CuiE9FXRiejr4pORV8dnY6+JjoTfW10Nvq6qDr6+uhc9A3R+egbowvRN0UXo2+OLkXfEl2OvjW6En1bdDX69uha9B3R9eg7oxvRd0U3o++OaqLviW5F3xvdjr4vqo2+P7oT/UBUF/1gdDf6oehe9MPR/ehHogfRj0YPox+LHkU/HtVHPxE9jn4yehL9VPQ0+unoWfQz0fPoZ6OG6Oeixujno6boF6Lm6BejluiXotbol6O26Fei9uhXo47oPVFn9GtRV/TrUXf0G1FP9JtRb/RbUV/021F/9DvRQPTeaDB6X/Qi+t3oZfR70avo96PX0R9EQ9EfRm+iP4qGoz+ORqI/iUajP43Goj+LxqM/jyaiv4gmo7+MpqK/iqajv45mor+JZqO/jeaiv4vmo7+PFqJ/iBajf4yWon+KlqN/jlaif4lWo3+N1qJ/i9ajf482ov+INqP/jLai/4q2o/+OdqL/id5+0P8B0a7oA6Pd0QdFe6IPjhKjD4mSog+N9kYfFu2LPjzaH31EdCD6yOhg9FHRoeijo8PRx0RHoo+NjkYfFx2LPj46Hn1ClBx9YpQSfVKUGn1ylBZ9SpQefWqUEX1alBl9epQVfUaUHX1mlBN9VpQbfXaUF31OlB99blQQfV5UGH1+VBR9QVQcfWFUEn1RVBp9cVQWfUlUHn1pVBF9WVQZfXlUFX1FdCL6yuhk9FXRqeiro9PR10Rnoq+NzkZfF1VHXx+di74hOh99Y3Qh+qboYvTN0aXoW6LL0bdGV6Jvi65G3x5di74juh59Z3Qj+q7oZvTdUU30PdGt6Huj29H3RbXR90d3oh+I6qIfjO5GPxTdi344uh/9SPQg+tHoYfRj0aPox6P66Ceix9FPRk+in4qeRj8dPYt+Jnoe/WzUEP1c1Bj9fNQU/ULUHP1i1BL9UtQa/XLUFv1K1B79atQRvSfqjH4t6op+PeqOfiPqiX4z6o1+K+qLfjvqj34nGojeGw1G74teRL8bvYx+L3oV/X70OvqDaCj6w+hN9EfRcPTH0Uj0J9Fo9KfRWPRn0Xj059FE9BfRZPSX0VT0V9F09NfRTPQ30Wz0t9Fc9HfRfPT30UL0D9Fi9I/RUvRP0XL0z9FK9C/RavSv0Vr0b9F69O/RRvQf0Wb0n9FW9F/RdvTf0U70P9HbL/k+INoVfWC0O/qgaE/0wVFi9CFRUvSh0d7ow6J90YdH+6OPiA5EHxkdjD4qOhR9dHQ4+pjoSPSx0dHo46Jj0cdHx6NPiJKjT4xSok+KUqNPjtKiT4nSo0+NMqJPizKjT4+yos+IsqPPjHKiz4pyo8+O8qLPifKjz40Kos+LCqPPj4qiL4iKoy+MSqIvikqjL47Koi+JyqMvjSqiL4sqoy+PqqKviE5EXxmdjL4qOhV9dXQ6+proTPS10dno66Lq6Oujc9E3ROejb4wuRN8UXYy+OboUfUt0OfrW6Er0bdHV6Nuja9F3RNej74xuRN8V3Yy+O6qJvie6FX1vdDv6vqg2+v7oTvQDUV30g9Hd6Ieie9EPR/ejH4keRD8aPYx+LHoU/XhUH/1E9Dj6yehJ9FPR0+ino2fRz0TPo5+NGqKfixqjn4+aol+ImqNfjFqiX4pao1+O2qJfidqjX406ovdEndGvRV3Rr0fd0W9EPdFvRr3Rb0V90W9H/dHvRAPRe6PB6H3Ri+h3o5fR70Wvot+PXkd/EA1Ffxi9if4oGo7+OBqJ/iQajf40Gov+LBqP/jyaiP4imoz+MpqK/iqajv46mon+JpqN/jaai/4umo/+PlqI/iFajP4xWor+KVqO/jlaif4lWo3+NVqL/i1aj/492oj+I9qM/jPaiv4r2o7+O9qJ/id6+wX/B/yfawG2P/n/+/kf3v+c8oszdUO1Nd+Q8H8eb7//+F+r/5H55M+ffN//tdH3W3Xiz7+3eOxD3/N/bQw2DpuATcKmYNOwGdgsbA42D1uALcKWYMuwFdgqbA22DtuAbcK2YNuwHdj/XuzyDtsF2w3bA0uEJcH2wvbB9sMOwA7CDsEOw47AjsKOwY7DkmEpsFRYGiwdlgHLhGXBsmE5sFxYHiwfVgArhBXBimElsFJYGawcVgGrhFXBTsBOwk7BTsPOwM7CqmHnYOdhF2AXYZdgl2FXYFdh12DXYTdgN2E1sFuw27Ba2B1YHewu7B7sPuwB7CHsEawe9hj2BPYU9gz2HNYAa4Q1wZphLbBWWBusHdYB64R1wbphPbBeWB+sHzYAG4S9gL2EvYK9hg3B3sCGYSOwUdgYbBw2AZuETcGmYTOwWdgcbB62AFuELcGWYSuwVdgabB22AduEbcG2YTuw/73R4R22C7YbtgeWCEuC7YXtg+2HHYAdhB2CHYYdgR2FHYMdhyXDUmCpsDRYOiwDlgnLgmXDcmC5sDxYPqwAVggrghXDSmClsDJYOawCVgmrgp2AnYSdgp2GnYGdhVXDzsHOwy7ALsIuwS7DrsCuwq7BrsNuwG7CamC3YLdhtbA7sDrYXdg92H3YA9hD2CNYPewx7AnsKewZ7DmsAdYIa4I1w1pgrbA2WDusA9YJ64J1w3pgvbA+WD9sADYIewF7CXsFew0bgr2BDcNGYKOwMdg4bAI2CZuCTcNmYLOwOdg8bAG2CFuCLcNWYKuwNdg6bAO2CduCbcN2YP97k/s7bBdsN2wPLBGWBNsL2wfbDzsAOwg7BDsMOwI7CjsGOw5LhqXAUmFpsHRYBiwTlgXLhuXAcmF5sHxYAawQVgQrhpXASmFlsHJYBawSVgU7ATsJOwU7DTsDOwurhp2DnYddgF2EXYJdhl2BXYVdg12H3YDdhNXAbsFuw2phd2B1sLuwe7D7sAewh7BHsHrYY9gT2FPYM9hzWAOsEdYEa4a1wFphbbB2WAesE9YF64b1wHphfbB+2ABsEPYC9hL2CvYaNgR7AxuGjcBGYWOwcdgEbBI2BZuGzcBmYXOwedgCbBG2BFuGrcBWYWuwddgGbBO2BduG7cD+94Czd9gu2G7YHlgiLAm2F7YPth92AHYQdgh2GHYEdhR2DHYclgxLgaXC0mDpsAxYJiwLlg3LgeXC8mD5sAJYIawIVgwrgZXCymDlsApYJawKdgJ2EnYKdhp2BnYWVg07BzsPuwC7CLsEuwy7ArsKuwa7DrsBuwmrgd2C3YbVwu7A6mB3Yfdg92EPYA9hj2D1sMewJ7CnsGew57AGWCOsCdYMa4G1wtpg7bAOWCesC9YN64H1wvpg/bAB2CDsBewl7BXsNWwI9gY2DBuBjcLGYOOwCdgkbAo2DZuBzcLmYPOwBdgibAm2DFuBrcLWYOuwDdgmbAu2DduB/e/h1u+wXbDdsD2wRFgSbC9sH2w/7ADsIOwQ7DDsCOwo7BjsOCwZlgJLhaXB0mEZsExYFiwblgPLheXB8mEFsEJYEawYVgIrhZXBymEVsEpYFewE7CTsFOw07AzsLKwadg52HnYBdhF2CXYZdgV2FXYNdh12A3YTVgO7BbsNq4XdgdXB7sLuwe7DHsAewh7B6mGPYU9gT2HPYM9hDbBGWBOsGdYCa4W1wdphHbBOWBesG9YD64X1wfphA7BB2AvYS9gr2GvYEOwNbBg2AhuFjcHGYROwSdgUbBo2A5uFzcHmYQuwRdgSbBm2AluFrcHWYRuwTdgWbBu2A/vfYaN32C7YbtgeWCIsCbYXtg+2H3YAdhB2CHYYdgR2FHYMdhyWDEuBpcLSYOmwDFgmLAuWDcuB5cLyYPmwAlghrAhWDCuBlcLKYOWwClglrAp2AnYSdgp2GnYGdhZWDTsHOw+7ALsIuwS7DLsCuwq7BrsOuwG7CauB3YLdhtXC7sDqYHdh92D3YQ9gD2GPYPWwx7AnsKewZ7DnsAZYI6wJ1gxrgbXC2mDtsA5YJ6wL1g3rgfXC+mD9sAHYIOwF7CXsFew1bAj2BjYMG4GNwsZg47AJ2CRsCjYNm4HNwuZg87AF2CJsCbYMW4GtwtZg67AN2CZsC7YN24ElJL7bdsF2w/bAEmFJsL2wfbD9sAOwg7BDsMOwI7CjsGOw47BkWAosFZYGS4dlwDJhWbBsWA4sF5YHy4cVwAphRbBiWAmsFFYGK4dVwCphVbATsJOwU7DTsDOws7Bq2DnYedgF2EXYJdhl2BXYVdg12HXYDdhNWA3sFuw2rBZ2B1YHuwu7B7sPewB7CHsEq4c9hj2BPYU9gz2HNcAaYU2wZlgLrBXWBmuHdcA6YV2wblgPrBfWB+uHDcAGYS9gL2GvYK9hQ7A3sGHYCGwUNgYbh03AJmFTsGnYDGwWNgebhy3AFmFLsGXYCmwVtgZbh23ANmFbsG3YDizhQ95tu2C7YXtgibAk2F7YPth+2AHYQdgh2GHYEdhR2DHYcVgyLAWWCkuDpcMyYJmwLFg2LAeWC8uD5cMKYIWwIlgxrARWCiuDlcMqYJWwKtgJ2EnYKdhp2BnYWVg17BzsPOwC7CLsEuwy7ArsKuwa7DrsBuwmrAZ2C3YbVgu7A6uD3YXdg92HPYA9hD2C1cMew57AnsKewZ7DGmCNsCZYM6wF1gprg7XDOmCdsC5YN6wH1gvrg/XDBmCDsBewl7BXsNewIdgb2DBsBDYKG4ONwyZgk7Ap2DRsBjYLm4PNwxZgi7Al2DJsBbYKW4OtwzZgm7At2DZsB5aQ9G7bBdsN2wNLhCXB9sL2wfbDDsAOwg7BDsOOwI7CjsGOw5JhKbBUWBosHZYBy4RlwbJhObBcWB4sH1YAK4QVwYphJbBSWBmsHFYBq4RVwU7ATsJOwU7DzsDOwqph52DnYRdgF2GXYJdhV2BXYddg12E3YDdhNbBbsNuwWtgdWB3sLuwe7D7sAewh7BGsHvYY9gT2FPYM9hzWAGuENcGaYS2wVlgbrB3WAeuEdcG6YT2wXlgfrB82ABuEvYC9hL2CvYYNwd7AhmEjsFHYGGwcNgGbhE3BpmEzsFnYHGwetgBbhC3BlmErsFXYGmwdtgHbhG3BtmE7sIQPfbftgu2G7YElwpJge2H7YPthB2AHYYdgh2FHYEdhx2DHYcmwFFgqLA2WDsuAZcKyYNmwHFguLA+WDyuAFcKKYMWwElgprAxWDquAVcKqYCdgJ2GnYKdhZ2BnYdWwc7DzsAuwi7BLsMuwK7CrsGuw67AbsJuwGtgt2G1YLewOrA52F3YPdh/2APYQ9ghWD3sMewJ7CnsGew5rgDXCmmDNsBZYK6wN1g7rgHXCumDdsB5YL6wP1g8bgA3CXsBewl7BXsOGYG9gw7AR2ChsDDYOm4BNwqZg07AZ2CxsDjYPW4AtwpZgy7AV2CpsDbYO24BtwrZg27AdWMLed9su2G7YHlgiLAm2F7YPth92AHYQdgh2GHYEdhR2DHYclgxLgaXC0mDpsAxYJiwLlg3LgeXC8mD5sAJYIawIVgwrgZXCymDlsApYJawKdgJ2EnYKdhp2BnYWVg07BzsPuwC7CLsEuwy7ArsKuwa7DrsBuwmrgd2C3YbVwu7A6mB3Yfdg92EPYA9hj2D1sMewJ7CnsGew57AGWCOsCdYMa4G1wtpg7bAOWCesC9YN64H1wvpg/bAB2CDsBewl7BXsNWwI9gY2DBuBjcLGYOOwCdgkbAo2DZuBzcLmYPOwBdgibAm2DFuBrcLWYOuwDdgmbAu2DduBJXzYu20XbDdsDywRlgTbC9sH2w87ADsIOwQ7DDsCOwo7BjsOS4alwFJhabB0WAYsE5YFy4blwHJhebB8WAGsEFYEK4aVwEphZbByWAWsElYFOwE7CTsFOw07AzsLq4adg52HXYBdhF2CXYZdgV2FXYNdh92A3YTVwG7BbsNqYXdgdbC7sHuw+7AHsIewR7B62GPYE9hT2DPYc1gDrBHWBGuGtcBaYW2wdlgHrBPWBeuG9cB6YX2wftgAbBD2AvYS9gr2GjYEewMbho3ARmFjsHHYBGwSNgWbhs3AZmFzsHnYAmwRtgRbhq3AVmFrsHXYBmwTtgXbhu3AEva923bBdsP2wBJhSbC9sH2w/bADsIOwQ7DDsCOwo7BjsOOwZFgKLBWWBkuHZcAyYVmwbFgOLBeWB8uHFcAKYUWwYlgJrBRWBiuHVcAqYVWwE7CTsFOw07AzsLOwatg52HnYBdhF2CXYZdgV2FXYNdh12A3YTVgN7BbsNqwWdgdWB7sLuwe7D3sAewh7BKuHPYY9gT2FPYM9hzXAGmFNsGZYC6wV1gZrh3XAOmFdsG5YD6wX1gfrhw3ABmEvYC9hr2CvYUOwN7Bh2AhsFDYGG4dNwCZhU7Bp2AxsFjYHm4ctwBZhS7Bl2ApsFbYGW4dtwDZhW7Bt2A4s4cPfbbtgu2F7YImwJNhe2D7YftgB2EHYIdhh2BHYUdgx2HFYMiwFlgpLg6XDMmCZsCxYNiwHlgvLg+XDCmCFsCJYMawEVgorg5XDKmCVsCrYCdhJ2CnYadgZ2FlYNewc7DzsAuwi7BLsMuwK7CrsGuw67AbsJqwGdgt2G1YLuwOrg92F3YPdhz2APYQ9gtXDHsOewJ7CnsGewxpgjbAmWDOsBdYKa4O1wzpgnbAuWDesB9YL64P1wwZgg7AXsJewV7DXsCHYG9gwbAQ2ChuDjcMmYJOwKdg0bAY2C5uDzcMWYIuwJdgybAW2CluDrcM2YJuwLdg2bAeWsP/dtgu2G7YHlghLgu2F7YPthx2AHYQdgh2GHYEdhR2DHYclw1JgqbA0WDosA5YJy4Jlw3JgubA8WD6sAFYIK4IVw0pgpbAyWDmsAlYJq4KdgJ2EnYKdhp2BnYVVw87BzsMuwC7CLsEuw67ArsKuwa7DbsBuwmpgt2C3YbWwO7A62F3YPdh92APYQ9gjWD3sMewJ7CnsGew5rAHWCGuCNcNaYK2wNlg7rAPWCeuCdcN6YL2wPlg/bAA2CHsBewl7BXsNG4K9gQ3DRmCjsDHYOGwCNgmbgk3DZmCzsDnYPGwBtghbgi3DVmCrsDXYOmwDtgnbgm3DdmAJH/Fu2wXbDdsDS4QlwfbC9sH2ww7ADsIOwQ7DjsCOwo7BjsOSYSmwVFgaLB2WAcuEZcGyYTmwXFgeLB9WACuEFcGKYSWwUlgZrBxWAauEVcFOwE7CTsFOw87AzsKqYedg52EXYBdhl2CXYVdgV2HXYNdhN2A3YTWwW7DbsFrYHVgd7C7sHuw+7AHsIewRrB72GPYE9hT2DPYc1gBrhDXBmmEtsFZYG6wd1gHrhHXBumE9sF5YH6wfNgAbhL2AvYS9gr2GDcHewIZhI7BR2BhsHDYBm4RNwaZhM7BZ2BxsHrYAW4QtwZZhK7BV2BpsHbYB24RtwbZhO7CEA++2XbDdsD2wRFgSbC9sH2w/7ADsIOwQ7DDsCOwo7BjsOCwZlgJLhaXB0mEZsExYFiwblgPLheXB8mEFsEJYEawYVgIrhZXBymEVsEpYFewE7CTsFOw07AzsLKwadg52HnYBdhF2CXYZdgV2FXYNdh12A3YTVgO7BbsNq4XdgdXB7sLuwe7DHsAewh7B6mGPYU9gT2HPYM9hDbBGWBOsGdYCa4W1wdphHbBOWBesG9YD64X1wfphA7BB2AvYS9gr2GvYEOwNbBg2AhuFjcHGYROwSdgUbBo2A5uFzcHmYQuwRdgSbBm2AluFrcHWYRuwTdgWbBu2A0v4yHfbLthu2B5YIiwJthe2D7YfdgB2EHYIdhh2BHYUdgx2HJYMS4GlwtJg6bAMWCYsC5YNy4HlwvJg+bACWCGsCFYMK4GVwspg5bAKWCWsCnYCdhJ2CnYadgZ2FlYNOwc7D7sAuwi7BLsMuwK7CrsGuw67AbsJq4Hdgt2G1cLuwOpgd2H3YPdhD2APYY9g9bDHsCewp7BnsOewBlgjrAnWDGuBtcLaYO2wDlgnrAvWDeuB9cL6YP2wAdgg7AXsJewV7DVsCPYGNgwbgY3CxmDjsAnYJGwKNg2bgc3C5mDzsAXYImwJtgxbga3C1mDrsA3YJmwLtg3bgSUcfLftgu2G7YElwpJge2H7YPthB2AHYYdgh2FHYEdhx2DHYcmwFFgqLA2WDsuAZcKyYNmwHFguLA+WDyuAFcKKYMWwElgprAxWDquAVcKqYCdgJ2GnYKdhZ2BnYdWwc7DzsAuwi7BLsMuwK7CrsGuw67AbsJuwGtgt2G1YLewOrA52F3YPdh/2APYQ9ghWD3sMewJ7CnsGew5rgDXCmmDNsBZYK6wN1g7rgHXCumDdsB5YL6wP1g8bgA3CXsBewl7BXsOGYG9gw7AR2ChsDDYOm4BNwqZg07AZ2CxsDjYPW4AtwpZgy7AV2CpsDbYO24BtwrZg27AdWMJHvdt2wXbD9sASYUmwvbB9sP2wA7CDsEOww7AjsKOwY7DjsGRYCiwVlgZLh2XAMmFZsGxYDiwXlgfLhxXACmFFsGJYCawUVgYrh1XAKmFVsBOwk7BTsNOwM7CzsGrYOdh52AXYRdgl2GXYFdhV2DXYddgN2E1YDewW7DasFnYHVge7C7sHuw97AHsIewSrhz2GPYE9hT2DPYc1wBphTbBmWAusFdYGa4d1wDphXbBuWA+sF9YH64cNwAZhL2AvYa9gr2FDsDewYdgIbBQ2BhuHTcAmYVOwadgMbBY2B5uHLcAWYUuwZdgKbBW2BluHbcA2YVuwbdgOLOHQu20XbDdsDywRlgTbC9sH2w87ADsIOwQ7DDsCOwo7BjsOS4alwFJhabB0WAYsE5YFy4blwHJhebB8WAGsEFYEK4aVwEphZbByWAWsElYFOwE7CTsFOw07AzsLq4adg52HXYBdhF2CXYZdgV2FXYNdh92A3YTVwG7BbsNqYXdgdbC7sHuw+7AHsIewR7B62GPYE9hT2DPYc1gDrBHWBGuGtcBaYW2wdlgHrBPWBeuG9cB6YX2wftgAbBD2AvYS9gr2GjYEewMbho3ARmFjsHHYBGwSNgWbhs3AZmFzsHnYAmwRtgRbhq3AVmFrsHXYBmwTtgXbhu3AEj763bYLthu2B5YIS4Lthe2D7YcdgB2EHYIdhh2BHYUdgx2HJcNSYKmwNFg6LAOWCcuCZcNyYLmwPFg+rABWCCuCFcNKYKWwMlg5rAJWCauCnYCdhJ2CnYadgZ2FVcPOwc7DLsAuwi7BLsOuwK7CrsGuw27AbsJqYLdgt2G1sDuwOthd2D3YfdgD2EPYI1g97DHsCewp7BnsOawB1ghrgjXDWmCtsDZYO6wD1gnrgnXDemC9sD5YP2wANgh7AXsJewV7DRuCvYENw0Zgo7Ax2DhsAjYJm4JNw2Zgs7A52DxsAbYIW4Itw1Zgq7A12DpsA7YJ24Jtw3ZgCYffbbtgu2F7YImwJNhe2D7YftgB2EHYIdhh2BHYUdgx2HFYMiwFlgpLg6XDMmCZsCxYNiwHlgvLg+XDCmCFsCJYMawEVgorg5XDKmCVsCrYCdhJ2CnYadgZ2FlYNewc7DzsAuwi7BLsMuwK7CrsGuw67AbsJqwGdgt2G1YLuwOrg92F3YPdhz2APYQ9gtXDHsOewJ7CnsGewxpgjbAmWDOsBdYKa4O1wzpgnbAuWDesB9YL64P1wwZgg7AXsJewV7DXsCHYG9gwbAQ2ChuDjcMmYJOwKdg0bAY2C5uDzcMWYIuwJdgybAW2CluDrcM2YJuwLdg2bAeW8DHvtl2w3bA9sERYEmwvbB9sP+wA7CDsEOww7AjsKOwY7DgsGZYCS4WlwdJhGbBMWBYsG5YDy4XlwfJhBbBCWBGsGFYCK4WVwcphFbBKWBXsBOwk7BTsNOwM7CysGnYOdh52AXYRdgl2GXYFdhV2DXYddgN2E1YDuwW7DauF3YHVwe7C7sHuwx7AHsIewephj2FPYE9hz2DPYQ2wRlgTrBnWAmuFtcHaYR2wTlgXrBvWA+uF9cH6YQOwQdgL2EvYK9hr2BDsDWwYNgIbhY3BxmETsEnYFGwaNgObhc3B5mELsEXYEmwZtgJbha3B1mEbsE3YFmwbtgNLOPJu2wXbDdsDS4QlwfbC9sH2ww7ADsIOwQ7DjsCOwo7BjsOSYSmwVFgaLB2WAcuEZcGyYTmwXFgeLB9WACuEFcGKYSWwUlgZrBxWAauEVcFOwE7CTsFOw87AzsKqYedg52EXYBdhl2CXYVdgV2HXYNdhN2A3YTWwW7DbsFrYHVgd7C7sHuw+7AHsIewRrB72GPYE9hT2DPYc1gBrhDXBmmEtsFZYG6wd1gHrhHXBumE9sF5YH6wfNgAbhL2AvYS9gr2GDcHewIZhI7BR2BhsHDYBm4RNwaZhM7BZ2BxsHrYAW4QtwZZhK7BV2BpsHbYB24RtwbZhO7CEj3237YLthu2BJcKSYHth+2D7YQdgB2GHYIdhR2BHYcdgx2HJsBRYKiwNlg7LgGXCsmDZsBxYLiwPlg8rgBXCimDFsBJYKawMVg6rgFXCqmAnYCdhp2CnYWdgZ2HVsHOw87ALsIuwS7DLsCuwq7BrsOuwG7CbsBrYLdhtWC3sDqwOdhd2D3Yf9gD2EPYIVg97DHsCewp7BnsOa4A1wppgzbAWWCusDdYO64B1wrpg3bAeWC+sD9YPG4ANwl7AXsJewV7DhmBvYMOwEdgobAw2DpuATcKmYNOwGdgsbA42D1uALcKWYMuwFdgqbA22DtuAbcK2YNuwHVjC0XfbLthu2B5YIiwJthe2D7YfdgB2EHYIdhh2BHYUdgx2HJYMS4GlwtJg6bAMWCYsC5YNy4HlwvJg+bACWCGsCFYMK4GVwspg5bAKWCWsCnYCdhJ2CnYadgZ2FlYNOwc7D7sAuwi7BLsMuwK7CrsGuw67AbsJq4Hdgt2G1cLuwOpgd2H3YPdhD2APYY9g9bDHsCewp7BnsOewBlgjrAnWDGuBtcLaYO2wDlgnrAvWDeuB9cL6YP2wAdgg7AXsJewV7DVsCPYGNgwbgY3CxmDjsAnYJGwKNg2bgc3C5mDzsAXYImwJtgxbga3C1mDrsA3YJmwLtg3bgSV83LttF2w3bA8sEZYE2wvbB9sPOwA7CDsEOww7AjsKOwY7DkuGpcBSYWmwdFgGLBOWBcuG5cByYXmwfFgBrBBWBCuGlcBKYWWwclgFrBJWBTsBOwk7BTsNOwM7C6uGnYOdh12AXYRdgl2GXYFdhV2DXYfdgN2E1cBuwW7DamF3YHWwu7B7sPuwB7CHsEewethj2BPYU9gz2HNYA6wR1gRrhrXAWmFtsHZYB6wT1gXrhvXAemF9sH7YAGwQ9gL2EvYK9ho2BHsDG4aNwEZhY7Bx2ARsEjYFm4bNwGZhc7B52AJsEbYEW4atwFZha7B12AZsE7YF24btwBKOvdt2wXbD9sASYUmwvbB9sP2wA7CDsEOww7AjsKOwY7DjsGRYCiwVlgZLh2XAMmFZsGxYDiwXlgfLhxXACmFFsGJYCawUVgYrh1XAKmFVsBOwk7BTsNOwM7CzsGrYOdh52AXYRdgl2GXYFdhV2DXYddgN2E1YDewW7DasFnYHVge7C7sHuw97AHsIewSrhz2GPYE9hT2DPYc1wBphTbBmWAusFdYGa4d1wDphXbBuWA+sF9YH64cNwAZhL2AvYa9gr2FDsDewYdgIbBQ2BhuHTcAmYVOwadgMbBY2B5uHLcAWYUuwZdgKbBW2BluHbcA2YVuwbdgOLOHj3227YLthe2CJsCTYXtg+2H7YAdhB2CHYYdgR2FHYMdhxWDIsBZYKS4OlwzJgmbAsWDYsB5YLy4PlwwpghbAiWDGsBFYKK4OVwypglbAq2AnYSdgp2GnYGdhZWDXsHOw87ALsIuwS7DLsCuwq7BrsOuwG7CasBnYLdhtWC7sDq4Pdhd2D3Yc9gD2EPYLVwx7DnsCewp7BnsMaYI2wJlgzrAXWCmuDtcM6YJ2wLlg3rAfWC+uD9cMGYIOwF7CXsFew17Ah2BvYMGwENgobg43DJmCTsCnYNGwGNgubg83DFmCLsCXYMmwFtgpbg63DNmCbsC3YNmwHlnD83bYLthu2B5YIS4Lthe2D7YcdgB2EHYIdhh2BHYUdgx2HJcNSYKmwNFg6LAOWCcuCZcNyYLmwPFg+rABWCCuCFcNKYKWwMlg5rAJWCauCnYCdhJ2CnYadgZ2FVcPOwc7DLsAuwi7BLsOuwK7CrsGuw27AbsJqYLdgt2G1sDuwOthd2D3YfdgD2EPYI1g97DHsCewp7BnsOawB1ghrgjXDWmCtsDZYO6wD1gnrgnXDemC9sD5YP2wANgh7AXsJewV7DRuCvYENw0Zgo7Ax2DhsAjYJm4JNw2Zgs7A52DxsAbYIW4Itw1Zgq7A12DpsA7YJ24Jtw3ZgCZ/wbtsF2w3bA0uEJcH2wvbB9sMOwA7CDsEOw47AjsKOwY7DkmEpsFRYGiwdlgHLhGXBsmE5sFxYHiwfVgArhBXBimElsFJYGawcVgGrhFXBTsBOwk7BTsPOwM7CqmHnYOdhF2AXYZdgl2FXYFdh12DXYTdgN2E1sFuw27Ba2B1YHewu7B7sPuwB7CHsEawe9hj2BPYU9gz2HNYAa4Q1wZphLbBWWBusHdYB64R1wbphPbBeWB+sHzYAG4S9gL2EvYK9hg3B3sCGYSOwUdgYbBw2AZuETcGmYTOwWdgcbB62AFuELcGWYSuwVdgabB22AduEbcG2YTuwhOR32y7YbtgeWCIsCbYXtg+2H3YAdhB2CHYYdgR2FHYMdhyWDEuBpcLSYOmwDFgmLAuWDcuB5cLyYPmwAlghrAhWDCuBlcLKYOWwClglrAp2AnYSdgp2GnYGdhZWDTsHOw+7ALsIuwS7DLsCuwq7BrsOuwG7CauB3YLdhtXC7sDqYHdh92D3YQ9gD2GPYPWwx7AnsKewZ7DnsAZYI6wJ1gxrgbXC2mDtsA5YJ6wL1g3rgfXC+mD9sAHYIOwF7CXsFew1bAj2BjYMG4GNwsZg47AJ2CRsCjYNm4HNwuZg87AF2CJsCbYMW4GtwtZg67AN2CZsC7YN24ElfOK7bRdsN2wPLBGWBNsL2wfbDzsAOwg7BDsMOwI7CjsGOw5LhqXAUmFpsHRYBiwTlgXLhuXAcmF5sHxYAawQVgQrhpXASmFlsHJYBawSVgU7ATsJOwU7DTsDOwurhp2DnYddgF2EXYJdhl2BXYVdg12H3YDdhNXAbsFuw2phd2B1sLuwe7D7sAewh7BHsHrYY9gT2FPYM9hzWAOsEdYEa4a1wFphbbB2WAesE9YF64b1wHphfbB+2ABsEPYC9hL2CvYaNgR7AxuGjcBGYWOwcdgEbBI2BZuGzcBmYXOwedgCbBG2BFuGrcBWYWuwddgGbBO2BduG7cASUt5tu2C7YXtgibAk2F7YPth+2AHYQdgh2GHYEdhR2DHYcVgyLAWWCkuDpcMyYJmwLFg2LAeWC8uD5cMKYIWwIlgxrARWCiuDlcMqYJWwKtgJ2EnYKdhp2BnYWVg17BzsPOwC7CLsEuwy7ArsKuwa7DrsBuwmrAZ2C3YbVgu7A6uD3YXdg92HPYA9hD2C1cMew57AnsKewZ7DGmCNsCZYM6wF1gprg7XDOmCdsC5YN6wH1gvrg/XDBmCDsBewl7BXsNewIdgb2DBsBDYKG4ONwyZgk7Ap2DRsBjYLm4PNwxZgi7Al2DJsBbYKW4OtwzZgm7At2DZsB5bwSe+2XbDdsD2wRFgSbC9sH2w/7ADsIOwQ7DDsCOwo7BjsOCwZlgJLhaXB0mEZsExYFiwblgPLheXB8mEFsEJYEawYVgIrhZXBymEVsEpYFewE7CTsFOw07AzsLKwadg52HnYBdhF2CXYZdgV2FXYNdh12A3YTVgO7BbsNq4XdgdXB7sLuwe7DHsAewh7B6mGPYU9gT2HPYM9hDbBGWBOsGdYCa4W1wdphHbBOWBesG9YD64X1wfphA7BB2AvYS9gr2GvYEOwNbBg2AhuFjcHGYROwSdgUbBo2A5uFzcHmYQuwRdgSbBm2AluFrcHWYRuwTdgWbBu2A0tIfbftgu2G7YElwpJge2H7YPthB2AHYYdgh2FHYEdhx2DHYcmwFFgqLA2WDsuAZcKyYNmwHFguLA+WDyuAFcKKYMWwElgprAxWDquAVcKqYCdgJ2GnYKdhZ2BnYdWwc7DzsAuwi7BLsMuwK7CrsGuw67AbsJuwGtgt2G1YLewOrA52F3YPdh/2APYQ9ghWD3sMewJ7CnsGew5rgDXCmmDNsBZYK6wN1g7rgHXCumDdsB5YL6wP1g8bgA3CXsBewl7BXsOGYG9gw7AR2ChsDDYOm4BNwqZg07AZ2CxsDjYPW4AtwpZgy7AV2CpsDbYO24BtwrZg27AdWMInv9t2wXbD9sASYUmwvbB9sP2wA7CDsEOww7AjsKOwY7DjsGRYCiwVlgZLh2XAMmFZsGxYDiwXlgfLhxXACmFFsGJYCawUVgYrh1XAKmFVsBOwk7BTsNOwM7CzsGrYOdh52AXYRdgl2GXYFdhV2DXYddgN2E1YDewW7DasFnYHVge7C7sHuw97AHsIewSrhz2GPYE9hT2DPYc1wBphTbBmWAusFdYGa4d1wDphXbBuWA+sF9YH64cNwAZhL2AvYa9gr2FDsDewYdgIbBQ2BhuHTcAmYVOwadgMbBY2B5uHLcAWYUuwZdgKbBW2BluHbcA2YVuwbdgOLCHt3bYLthu2B5YIS4Lthe2D7YcdgB2EHYIdhh2BHYUdgx2HJcNSYKmwNFg6LAOWCcuCZcNyYLmwPFg+rABWCCuCFcNKYKWwMlg5rAJWCauCnYCdhJ2CnYadgZ2FVcPOwc7DLsAuwi7BLsOuwK7CrsGuw27AbsJqYLdgt2G1sDuwOthd2D3YfdgD2EPYI1g97DHsCewp7BnsOawB1ghrgjXDWmCtsDZYO6wD1gnrgnXDemC9sD5YP2wANgh7AXsJewV7DRuCvYENw0Zgo7Ax2DhsAjYJm4JNw2Zgs7A52DxsAbYIW4Itw1Zgq7A12DpsA7YJ24Jtw3ZgCZ/ybtsF2w3bA0uEJcH2wvbB9sMOwA7CDsEOw47AjsKOwY7DkmEpsFRYGiwdlgHLhGXBsmE5sFxYHiwfVgArhBXBimElsFJYGawcVgGrhFXBTsBOwk7BTsPOwM7CqmHnYOdhF2AXYZdgl2FXYFdh12DXYTdgN2E1sFuw27Ba2B1YHewu7B7sPuwB7CHsEawe9hj2BPYU9gz2HNYAa4Q1wZphLbBWWBusHdYB64R1wbphPbBeWB+sHzYAG4S9gL2EvYK9hg3B3sCGYSOwUdgYbBw2AZuETcGmYTOwWdgcbB62AFuELcGWYSuwVdgabB22AduEbcG2YTuwhPR32y7YbtgeWCIsCbYXtg+2H3YAdhB2CHYYdgR2FHYMdhyWDEuBpcLSYOmwDFgmLAuWDcuB5cLyYPmwAlghrAhWDCuBlcLKYOWwClglrAp2AnYSdgp2GnYGdhZWDTsHOw+7ALsIuwS7DLsCuwq7BrsOuwG7CauB3YLdhtXC7sDqYHdh92D3YQ9gD2GPYPWwx7AnsKewZ7DnsAZYI6wJ1gxrgbXC2mDtsA5YJ6wL1g3rgfXC+mD9sAHYIOwF7CXsFew1bAj2BjYMG4GNwsZg47AJ2CRsCjYNm4HNwuZg87AF2CJsCbYMW4GtwtZg67AN2CZsC7YN24ElfOq7bRdsN2wPLBGWBNsL2wfbDzsAOwg7BDsMOwI7CjsGOw5LhqXAUmFpsHRYBiwTlgXLhuXAcmF5sHxYAawQVgQrhpXASmFlsHJYBawSVgU7ATsJOwU7DTsDOwurhp2DnYddgF2EXYJdhl2BXYVdg12H3YDdhNXAbsFuw2phd2B1sLuwe7D7sAewh7BHsHrYY9gT2FPYM9hzWAOsEdYEa4a1wFphbbB2WAesE9YF64b1wHphfbB+2ABsEPYC9hL2CvYaNgR7AxuGjcBGYWOwcdgEbBI2BZuGzcBmYXOwedgCbBG2BFuGrcBWYWuwddgGbBO2BduG7cASMt5tu2C7YXtgibAk2F7YPth+2AHYQdgh2GHYEdhR2DHYcVgyLAWWCkuDpcMyYJmwLFg2LAeWC8uD5cMKYIWwIlgxrARWCiuDlcMqYJWwKtgJ2EnYKdhp2BnYWVg17BzsPOwC7CLsEuwy7ArsKuwa7DrsBuwmrAZ2C3YbVgu7A6uD3YXdg92HPYA9hD2C1cMew57AnsKewZ7DGmCNsCZYM6wF1gprg7XDOmCdsC5YN6wH1gvrg/XDBmCDsBewl7BXsNewIdgb2DBsBDYKG4ONwyZgk7Ap2DRsBjYLm4PNwxZgi7Al2DJsBbYKW4OtwzZgm7At2DZsB5bwae+2XbDdsD2wRFgSbC9sH2w/7ADsIOwQ7DDsCOwo7BjsOCwZlgJLhaXB0mEZsExYFiwblgPLheXB8mEFsEJYEawYVgIrhZXBymEVsEpYFewE7CTsFOw07AzsLKwadg52HnYBdhF2CXYZdgV2FXYNdh12A3YTVgO7BbsNq4XdgdXB7sLuwe7DHsAewh7B6mGPYU9gT2HPYM9hDbBGWBOsGdYCa4W1wdphHbBOWBesG9YD64X1wfphA7BB2AvYS9gr2GvYEOwNbBg2AhuFjcHGYROwSdgUbBo2A5uFzcHmYQuwRdgSbBm2AluFrcHWYRuwTdgWbBu2A0vIfLftgu2G7YElwpJge2H7YPthB2AHYYdgh2FHYEdhx2DHYcmwFFgqLA2WDsuAZcKyYNmwHFguLA+WDyuAFcKKYMWwElgprAxWDquAVcKqYCdgJ2GnYKdhZ2BnYdWwc7DzsAuwi7BLsMuwK7CrsGuw67AbsJuwGtgt2G1YLewOrA52F3YPdh/2APYQ9ghWD3sMewJ7CnsGew5rgDXCmmDNsBZYK6wN1g7rgHXCumDdsB5YL6wP1g8bgA3CXsBewl7BXsOGYG9gw7AR2ChsDDYOm4BNwqZg07AZ2CxsDjYPW4AtwpZgy7AV2CpsDbYO24BtwrZg27AdWMKnv9t2wXbD9sASYUmwvbB9sP2wA7CDsEOww7AjsKOwY7DjsGRYCiwVlgZLh2XAMmFZsGxYDiwXlgfLhxXACmFFsGJYCawUVgYrh1XAKmFVsBOwk7BTsNOwM7CzsGrYOdh52AXYRdgl2GXYFdhV2DXYddgN2E1YDewW7DasFnYHVge7C7sHuw97AHsIewSrhz2GPYE9hT2DPYc1wBphTbBmWAusFdYGa4d1wDphXbBuWA+sF9YH64cNwAZhL2AvYa9gr2FDsDewYdgIbBQ2BhuHTcAmYVOwadgMbBY2B5uHLcAWYUuwZdgKbBW2BluHbcA2YVuwbdgOLCHr3bYLthu2B5YIS4Lthe2D7YcdgB2EHYIdhh2BHYUdgx2HJcNSYKmwNFg6LAOWCcuCZcNyYLmwPFg+rABWCCuCFcNKYKWwMlg5rAJWCauCnYCdhJ2CnYadgZ2FVcPOwc7DLsAuwi7BLsOuwK7CrsGuw27AbsJqYLdgt2G1sDuwOthd2D3YfdgD2EPYI1g97DHsCewp7BnsOawB1ghrgjXDWmCtsDZYO6wD1gnrgnXDemC9sD5YP2wANgh7AXsJewV7DRuCvYENw0Zgo7Ax2DhsAjYJm4JNw2Zgs7A52DxsAbYIW4Itw1Zgq7A12DpsA7YJ24Jtw3ZgCZ/xbtsF2w3bA0uEJcH2wvbB9sMOwA7CDsEOw47AjsKOwY7DkmEpsFRYGiwdlgHLhGXBsmE5sFxYHiwfVgArhBXBimElsFJYGawcVgGrhFXBTsBOwk7BTsPOwM7CqmHnYOdhF2AXYZdgl2FXYFdh12DXYTdgN2E1sFuw27Ba2B1YHewu7B7sPuwB7CHsEawe9hj2BPYU9gz2HNYAa4Q1wZphLbBWWBusHdYB64R1wbphPbBeWB+sHzYAG4S9gL2EvYK9hg3B3sCGYSOwUdgYbBw2AZuETcGmYTOwWdgcbB62AFuELcGWYSuwVdgabB22AduEbcG2YTuwhOx32y7YbtgeWCIsCbYXtg+2H3YAdhB2CHYYdgR2FHYMdhyWDEuBpcLSYOmwDFgmLAuWDcuB5cLyYPmwAlghrAhWDCuBlcLKYOWwClglrAp2AnYSdgp2GnYGdhZWDTsHOw+7ALsIuwS7DLsCuwq7BrsOuwG7CauB3YLdhtXC7sDqYHdh92D3YQ9gD2GPYPWwx7AnsKewZ7DnsAZYI6wJ1gxrgbXC2mDtsA5YJ6wL1g3rgfXC+mD9sAHYIOwF7CXsFew1bAj2BjYMG4GNwsZg47AJ2CRsCjYNm4HNwuZg87AF2CJsCbYMW4GtwtZg67AN2CZsC7YN24ElfOa7bRdsN2wPLBGWBNsL2wfbDzsAOwg7BDsMOwI7CjsGOw5LhqXAUmFpsHRYBiwTlgXLhuXAcmF5sHxYAawQVgQrhpXASmFlsHJYBawSVgU7ATsJOwU7DTsDOwurhp2DnYddgF2EXYJdhl2BXYVdg12H3YDdhNXAbsFuw2phd2B1sLuwe7D7sAewh7BHsHrYY9gT2FPYM9hzWAOsEdYEa4a1wFphbbB2WAesE9YF64b1wHphfbB+2ABsEPYC9hL2CvYaNgR7AxuGjcBGYWOwcdgEbBI2BZuGzcBmYXOwedgCbBG2BFuGrcBWYWuwddgGbBO2BduG7cASct5tu2C7YXtgibAk2F7YPth+2AHYQdgh2GHYEdhR2DHYcVgyLAWWCkuDpcMyYJmwLFg2LAeWC8uD5cMKYIWwIlgxrARWCiuDlcMqYJWwKtgJ2EnYKdhp2BnYWVg17BzsPOwC7CLsEuwy7ArsKuwa7DrsBuwmrAZ2C3YbVgu7A6uD3YXdg92HPYA9hD2C1cMew57AnsKewZ7DGmCNsCZYM6wF1gprg7XDOmCdsC5YN6wH1gvrg/XDBmCDsBewl7BXsNewIdgb2DBsBDYKG4ONwyZgk7Ap2DRsBjYLm4PNwxZgi7Al2DJsBbYKW4OtwzZgm7At2DZsB5bwWe+2XbDdsD2wRFgSbC9sH2w/7ADsIOwQ7DDsCOwo7BjsOCwZlgJLhaXB0mEZsExYFiwblgPLheXB8mEFsEJYEawYVgIrhZXBymEVsEpYFewE7CTsFOw07AzsLKwadg52HnYBdhF2CXYZdgV2FXYNdh12A3YTVgO7BbsNq4XdgdXB7sLuwe7DHsAewh7B6mGPYU9gT2HPYM9hDbBGWBOsGdYCa4W1wdphHbBOWBesG9YD64X1wfphA7BB2AvYS9gr2GvYEOwNbBg2AhuFjcHGYROwSdgUbBo2A5uFzcHmYQuwRdgSbBm2AluFrcHWYRuwTdgWbBu2A0vIfbftgu2G7YElwpJge2H7YPthB2AHYYdgh2FHYEdhx2DHYcmwFFgqLA2WDsuAZcKyYNmwHFguLA+WDyuAFcKKYMWwElgprAxWDquAVcKqYCdgJ2GnYKdhZ2BnYdWwc7DzsAuwi7BLsMuwK7CrsGuw67AbsJuwGtgt2G1YLewOrA52F3YPdh/2APYQ9ghWD3sMewJ7CnsGew5rgDXCmmDNsBZYK6wN1g7rgHXCumDdsB5YL6wP1g8bgA3CXsBewl7BXsOGYG9gw7AR2ChsDDYOm4BNwqZg07AZ2CxsDjYPW4AtwpZgy7AV2CpsDbYO24BtwrZg27AdWMJnv9t2wXbD9sASYUmwvbB9sP2wA7CDsEOww7AjsKOwY7DjsGRYCiwVlgZLh2XAMmFZsGxYDiwXlgfLhxXACmFFsGJYCawUVgYrh1XAKmFVsBOwk7BTsNOwM7CzsGrYOdh52AXYRdgl2GXYFdhV2DXYddgN2E1YDewW7DasFnYHVge7C7sHuw97AHsIewSrhz2GPYE9hT2DPYc1wBphTbBmWAusFdYGa4d1wDphXbBuWA+sF9YH64cNwAZhL2AvYa9gr2FDsDewYdgIbBQ2BhuHTcAmYVOwadgMbBY2B5uHLcAWYUuwZdgKbBW2BluHbcA2YVuwbdgOLCHv3bYLthu2B5YIS4Lthe2D7YcdgB2EHYIdhh2BHYUdgx2HJcNSYKmwNFg6LAOWCcuCZcNyYLmwPFg+rABWCCuCFcNKYKWwMlg5rAJWCauCnYCdhJ2CnYadgZ2FVcPOwc7DLsAuwi7BLsOuwK7CrsGuw27AbsJqYLdgt2G1sDuwOthd2D3YfdgD2EPYI1g97DHsCewp7BnsOawB1ghrgjXDWmCtsDZYO6wD1gnrgnXDemC9sD5YP2wANgh7AXsJewV7DRuCvYENw0Zgo7Ax2DhsAjYJm4JNw2Zgs7A52DxsAbYIW4Itw1Zgq7A12DpsA7YJ24Jtw3ZgCZ/zbtsF2w3bA0uEJcH2wvbB9sMOwA7CDsEOw47AjsKOwY7DkmEpsFRYGiwdlgHLhGXBsmE5sFxYHiwfVgArhBXBimElsFJYGawcVgGrhFXBTsBOwk7BTsPOwM7CqmHnYOdhF2AXYZdgl2FXYFdh12DXYTdgN2E1sFuw27Ba2B1YHewu7B7sPuwB7CHsEawe9hj2BPYU9gz2HNYAa4Q1wZphLbBWWBusHdYB64R1wbphPbBeWB+sHzYAG4S9gL2EvYK9hg3B3sCGYSOwUdgYbBw2AZuETcGmYTOwWdgcbB62AFuELcGWYSuwVdgabB22AduEbcG2YTuwhPx32y7YbtgeWCIsCbYXtg+2H3YAdhB2CHYYdgR2FHYMdhyWDEuBpcLSYOmwDFgmLAuWDcuB5cLyYPmwAlghrAhWDCuBlcLKYOWwClglrAp2AnYSdgp2GnYGdhZWDTsHOw+7ALsIuwS7DLsCuwq7BrsOuwG7CauB3YLdhtXC7sDqYHdh92D3YQ9gD2GPYPWwx7AnsKewZ7DnsAZYI6wJ1gxrgbXC2mDtsA5YJ6wL1g3rgfXC+mD9sAHYIOwF7CXsFew1bAj2BjYMG4GNwsZg47AJ2CRsCjYNm4HNwuZg87AF2CJsCbYMW4GtwtZg67AN2CZsC7YN24ElfO67bRdsN2wPLBGWBNsL2wfbDzsAOwg7BDsMOwI7CjsGOw5LhqXAUmFpsHRYBiwTlgXLhuXAcmF5sHxYAawQVgQrhpXASmFlsHJYBawSVgU7ATsJOwU7DTsDOwurhp2DnYddgF2EXYJdhl2BXYVdg12H3YDdhNXAbsFuw2phd2B1sLuwe7D7sAewh7BHsHrYY9gT2FPYM9hzWAOsEdYEa4a1wFphbbB2WAesE9YF64b1wHphfbB+2ABsEPYC9hL2CvYaNgR7AxuGjcBGYWOwcdgEbBI2BZuGzcBmYXOwedgCbBG2BFuGrcBWYWuwddgGbBO2BduG7cASCt5tu2C7YXtgibAk2F7YPth+2AHYQdgh2GHYEdhR2DHYcVgyLAWWCkuDpcMyYJmwLFg2LAeWC8uD5cMKYIWwIlgxrARWCiuDlcMqYJWwKtgJ2EnYKdhp2BnYWVg17BzsPOwC7CLsEuwy7ArsKuwa7DrsBuwmrAZ2C3YbVgu7A6uD3YXdg92HPYA9hD2C1cMew57AnsKewZ7DGmCNsCZYM6wF1gprg7XDOmCdsC5YN6wH1gvrg/XDBmCDsBewl7BXsNewIdgb2DBsBDYKG4ONwyZgk7Ap2DRsBjYLm4PNwxZgi7Al2DJsBbYKW4OtwzZgm7At2DZsB5bwee+2XbDdsD2wRFgSbC9sH2w/7ADsIOwQ7DDsCOwo7BjsOCwZlgJLhaXB0mEZsExYFiwblgPLheXB8mEFsEJYEawYVgIrhZXBymEVsEpYFewE7CTsFOw07AzsLKwadg52HnYBdhF2CXYZdgV2FXYNdh12A3YTVgO7BbsNq4XdgdXB7sLuwe7DHsAewh7B6mGPYU9gT2HPYM9hDbBGWBOsGdYCa4W1wdphHbBOWBesG9YD64X1wfphA7BB2AvYS9gr2GvYEOwNbBg2AhuFjcHGYROwSdgUbBo2A5uFzcHmYQuwRdgSbBm2AluFrcHWYRuwTdgWbBu2A0sofLftgu2G7YElwpJge2H7YPthB2AHYYdgh2FHYEdhx2DHYcmwFFgqLA2WDsuAZcKyYNmwHFguLA+WDyuAFcKKYMWwElgprAxWDquAVcKqYCdgJ2GnYKdhZ2BnYdWwc7DzsAuwi7BLsMuwK7CrsGuw67AbsJuwGtgt2G1YLewOrA52F3YPdh/2APYQ9ghWD3sMewJ7CnsGew5rgDXCmmDNsBZYK6wN1g7rgHXCumDdsB5YL6wP1g8bgA3CXsBewl7BXsOGYG9gw7AR2ChsDDYOm4BNwqZg07AZ2CxsDjYPW4AtwpZgy7AV2CpsDbYO24BtwrZg27AdWMLnv9t2wXbD9sASYUmwvbB9sP2wA7CDsEOww7AjsKOwY7DjsGRYCiwVlgZLh2XAMmFZsGxYDiwXlgfLhxXACmFFsGJYCawUVgYrh1XAKmFVsBOwk7BTsNOwM7CzsGrYOdh52AXYRdgl2GXYFdhV2DXYddgN2E1YDewW7DasFnYHVge7C7sHuw97AHsIewSrhz2GPYE9hT2DPYc1wBphTbBmWAusFdYGa4d1wDphXbBuWA+sF9YH64cNwAZhL2AvYa9gr2FDsDewYdgIbBQ2BhuHTcAmYVOwadgMbBY2B5uHLcAWYUuwZdgKbBW2BluHbcA2YVuwbdgOLKHo3bYLthu2B5YIS4Lthe2D7YcdgB2EHYIdhh2BHYUdgx2HJcNSYKmwNFg6LAOWCcuCZcNyYLmwPFg+rABWCCuCFcNKYKWwMlg5rAJWCauCnYCdhJ2CnYadgZ2FVcPOwc7DLsAuwi7BLsOuwK7CrsGuw27AbsJqYLdgt2G1sDuwOthd2D3YfdgD2EPYI1g97DHsCewp7BnsOawB1ghrgjXDWmCtsDZYO6wD1gnrgnXDemC9sD5YP2wANgh7AXsJewV7DRuCvYENw0Zgo7Ax2DhsAjYJm4JNw2Zgs7A52DxsAbYIW4Itw1Zgq7A12DpsA7YJ24Jtw3ZgCV/wbtsF2w3bA0uEJcH2wvbB9sMOwA7CDsEOw47AjsKOwY7DkmEpsFRYGiwdlgHLhGXBsmE5sFxYHiwfVgArhBXBimElsFJYGawcVgGrhFXBTsBOwk7BTsPOwM7CqmHnYOdhF2AXYZdgl2FXYFdh12DXYTdgN2E1sFuw27Ba2B1YHewu7B7sPuwB7CHsEawe9hj2BPYU9gz2HNYAa4Q1wZphLbBWWBusHdYB64R1wbphPbBeWB+sHzYAG4S9gL2EvYK9hg3B3sCGYSOwUdgYbBw2AZuETcGmYTOwWdgcbB62AFuELcGWYSuwVdgabB22AduEbcG2YTuwhOJ32y7YbtgeWCIsCbYXtg+2H3YAdhB2CHYYdgR2FHYMdhyWDEuBpcLSYOmwDFgmLAuWDcuB5cLyYPmwAlghrAhWDCuBlcLKYOWwClglrAp2AnYSdgp2GnYGdhZWDTsHOw+7ALsIuwS7DLsCuwq7BrsOuwG7CauB3YLdhtXC7sDqYHdh92D3YQ9gD2GPYPWwx7AnsKewZ7DnsAZYI6wJ1gxrgbXC2mDtsA5YJ6wL1g3rgfXC+mD9sAHYIOwF7CXsFew1bAj2BjYMG4GNwsZg47AJ2CRsCjYNm4HNwuZg87AF2CJsCbYMW4GtwtZg67AN2CZsC7YN24ElfOG7bRdsN2wPLBGWBNsL2wfbDzsAOwg7BDsMOwI7CjsGOw5LhqXAUmFpsHRYBiwTlgXLhuXAcmF5sHxYAawQVgQrhpXASmFlsHJYBawSVgU7ATsJOwU7DTsDOwurhp2DnYddgF2EXYJdhl2BXYVdg12H3YDdhNXAbsFuw2phd2B1sLuwe7D7sAewh7BHsHrYY9gT2FPYM9hzWAOsEdYEa4a1wFphbbB2WAesE9YF64b1wHphfbB+2ABsEPYC9hL2CvYaNgR7AxuGjcBGYWOwcdgEbBI2BZuGzcBmYXOwedgCbBG2BFuGrcBWYWuwddgGbBO2BduG7cASSt5tu2C7YXtgibAk2F7YPth+2AHYQdgh2GHYEdhR2DHYcVgyLAWWCkuDpcMyYJmwLFg2LAeWC8uD5cMKYIWwIlgxrARWCiuDlcMqYJWwKtgJ2EnYKdhp2BnYWVg17BzsPOwC7CLsEuwy7ArsKuwa7DrsBuwmrAZ2C3YbVgu7A6uD3YXdg92HPYA9hD2C1cMew57AnsKewZ7DGmCNsCZYM6wF1gprg7XDOmCdsC5YN6wH1gvrg/XDBmCDsBewl7BXsNewIdgb2DBsBDYKG4ONwyZgk7Ap2DRsBjYLm4PNwxZgi7Al2DJsBbYKW4OtwzZgm7At2DZsB5bwRe+2XbDdsD2wRFgSbC9sH2w/7ADsIOwQ7DDsCOwo7BjsOCwZlgJLhaXB0mEZsExYFiwblgPLheXB8mEFsEJYEawYVgIrhZXBymEVsEpYFewE7CTsFOw07AzsLKwadg52HnYBdhF2CXYZdgV2FXYNdh12A3YTVgO7BbsNq4XdgdXB7sLuwe7DHsAewh7B6mGPYU9gT2HPYM9hDbBGWBOsGdYCa4W1wdphHbBOWBesG9YD64X1wfphA7BB2AvYS9gr2GvYEOwNbBg2AhuFjcHGYROwSdgUbBo2A5uFzcHmYQuwRdgSbBm2AluFrcHWYRuwTdgWbBu2A0sofbftgu2G7YElwpJge2H7YPthB2AHYYdgh2FHYEdhx2DHYcmwFFgqLA2WDsuAZcKyYNmwHFguLA+WDyuAFcKKYMWwElgprAxWDquAVcKqYCdgJ2GnYKdhZ2BnYdWwc7DzsAuwi7BLsMuwK7CrsGuw67AbsJuwGtgt2G1YLewOrA52F3YPdh/2APYQ9ghWD3sMewJ7CnsGew5rgDXCmmDNsBZYK6wN1g7rgHXCumDdsB5YL6wP1g8bgA3CXsBewl7BXsOGYG9gw7AR2ChsDDYOm4BNwqZg07AZ2CxsDjYPW4AtwpZgy7AV2CpsDbYO24BtwrZg27AdWMIXv9t2wXbD9sASYUmwvbB9sP2wA7CDsEOww7AjsKOwY7DjsGRYCiwVlgZLh2XAMmFZsGxYDiwXlgfLhxXACmFFsGJYCawUVgYrh1XAKmFVsBOwk7BTsNOwM7CzsGrYOdh52AXYRdgl2GXYFdhV2DXYddgN2E1YDewW7DasFnYHVge7C7sHuw97AHsIewSrhz2GPYE9hT2DPYc1wBphTbBmWAusFdYGa4d1wDphXbBuWA+sF9YH64cNwAZhL2AvYa9gr2FDsDewYdgIbBQ2BhuHTcAmYVOwadgMbBY2B5uHLcAWYUuwZdgKbBW2BluHbcA2YVuwbdgOLKHs3bYLthu2B5YIS4Lthe2D7YcdgB2EHYIdhh2BHYUdgx2HJcNSYKmwNFg6LAOWCcuCZcNyYLmwPFg+rABWCCuCFcNKYKWwMlg5rAJWCauCnYCdhJ2CnYadgZ2FVcPOwc7DLsAuwi7BLsOuwK7CrsGuw27AbsJqYLdgt2G1sDuwOthd2D3YfdgD2EPYI1g97DHsCewp7BnsOawB1ghrgjXDWmCtsDZYO6wD1gnrgnXDemC9sD5YP2wANgh7AXsJewV7DRuCvYENw0Zgo7Ax2DhsAjYJm4JNw2Zgs7A52DxsAbYIW4Itw1Zgq7A12DpsA7YJ24Jtw3ZgCV/ybtsF2w3bA0uEJcH2wvbB9sMOwA7CDsEOw47AjsKOwY7DkmEpsFRYGiwdlgHLhGXBsmE5sFxYHiwfVgArhBXBimElsFJYGawcVgGrhFXBTsBOwk7BTsPOwM7CqmHnYOdhF2AXYZdgl2FXYFdh12DXYTdgN2E1sFuw27Ba2B1YHewu7B7sPuwB7CHsEawe9hj2BPYU9gz2HNYAa4Q1wZphLbBWWBusHdYB64R1wbphPbBeWB+sHzYAG4S9gL2EvYK9hg3B3sCGYSOwUdgYbBw2AZuETcGmYTOwWdgcbB62AFuELcGWYSuwVdgabB22AduEbcG2YTuwhPJ32y7YbtgeWCIsCbYXtg+2H3YAdhB2CHYYdgR2FHYMdhyWDEuBpcLSYOmwDFgmLAuWDcuB5cLyYPmwAlghrAhWDCuBlcLKYOWwClglrAp2AnYSdgp2GnYGdhZWDTsHOw+7ALsIuwS7DLsCuwq7BrsOuwG7CauB3YLdhtXC7sDqYHdh92D3YQ9gD2GPYPWwx7AnsKewZ7DnsAZYI6wJ1gxrgbXC2mDtsA5YJ6wL1g3rgfXC+mD9sAHYIOwF7CXsFew1bAj2BjYMG4GNwsZg47AJ2CRsCjYNm4HNwuZg87AF2CJsCbYMW4GtwtZg67AN2CZsC7YN24ElfOm7bRdsN2wPLBGWBNsL2wfbDzsAOwg7BDsMOwI7CjsGOw5LhqXAUmFpsHRYBiwTlgXLhuXAcmF5sHxYAawQVgQrhpXASmFlsHJYBawSVgU7ATsJOwU7DTsDOwurhp2DnYddgF2EXYJdhl2BXYVdg12H3YDdhNXAbsFuw2phd2B1sLuwe7D7sAewh7BHsHrYY9gT2FPYM9hzWAOsEdYEa4a1wFphbbB2WAesE9YF64b1wHphfbB+2ABsEPYC9hL2CvYaNgR7AxuGjcBGYWOwcdgEbBI2BZuGzcBmYXOwedgCbBG2BFuGrcBWYWuwddgGbBO2BduG7cASKt5tu2C7YXtgibAk2F7YPth+2AHYQdgh2GHYEdhR2DHYcVgyLAWWCkuDpcMyYJmwLFg2LAeWC8uD5cMKYIWwIlgxrARWCiuDlcMqYJWwKtgJ2EnYKdhp2BnYWVg17BzsPOwC7CLsEuwy7ArsKuwa7DrsBuwmrAZ2C3YbVgu7A6uD3YXdg92HPYA9hD2C1cMew57AnsKewZ7DGmCNsCZYM6wF1gprg7XDOmCdsC5YN6wH1gvrg/XDBmCDsBewl7BXsNewIdgb2DBsBDYKG4ONwyZgk7Ap2DRsBjYLm4PNwxZgi7Al2DJsBbYKW4OtwzZgm7At2DZsB5bwZe+2XbDdsD2wRFgSbC9sH2w/7ADsIOwQ7DDsCOwo7BjsOCwZlgJLhaXB0mEZsExYFiwblgPLheXB8mEFsEJYEawYVgIrhZXBymEVsEpYFewE7CTsFOw07AzsLKwadg52HnYBdhF2CXYZdgV2FXYNdh12A3YTVgO7BbsNq4XdgdXB7sLuwe7DHsAewh7B6mGPYU9gT2HPYM9hDbBGWBOsGdYCa4W1wdphHbBOWBesG9YD64X1wfphA7BB2AvYS9gr2GvYEOwNbBg2AhuFjcHGYROwSdgUbBo2A5uFzcHmYQuwRdgSbBm2AluFrcHWYRuwTdgWbBu2A0uofLftgu2G7YElwpJge2H7YPthB2AHYYdgh2FHYEdhx2DHYcmwFFgqLA2WDsuAZcKyYNmwHFguLA+WDyuAFcKKYMWwElgprAxWDquAVcKqYCdgJ2GnYKdhZ2BnYdWwc7DzsAuwi7BLsMuwK7CrsGuw67AbsJuwGtgt2G1YLewOrA52F3YPdh/2APYQ9ghWD3sMewJ7CnsGew5rgDXCmmDNsBZYK6wN1g7rgHXCumDdsB5YL6wP1g8bgA3CXsBewl7BXsOGYG9gw7AR2ChsDDYOm4BNwqZg07AZ2CxsDjYPW4AtwpZgy7AV2CpsDbYO24BtwrZg27AdWMKXv9t2wXbD9sASYUmwvbB9sP2wA7CDsEOww7AjsKOwY7DjsGRYCiwVlgZLh2XAMmFZsGxYDiwXlgfLhxXACmFFsGJYCawUVgYrh1XAKmFVsBOwk7BTsNOwM7CzsGrYOdh52AXYRdgl2GXYFdhV2DXYddgN2E1YDewW7DasFnYHVge7C7sHuw97AHsIewSrhz2GPYE9hT2DPYc1wBphTbBmWAusFdYGa4d1wDphXbBuWA+sF9YH64cNwAZhL2AvYa9gr2FDsDewYdgIbBQ2BhuHTcAmYVOwadgMbBY2B5uHLcAWYUuwZdgKbBW2BluHbcA2YVuwbdgOLKHq3bYLthu2B5YIS4Lthe2D7YcdgB2EHYIdhh2BHYUdgx2HJcNSYKmwNFg6LAOWCcuCZcNyYLmwPFg+rABWCCuCFcNKYKWwMlg5rAJWCauCnYCdhJ2CnYadgZ2FVcPOwc7DLsAuwi7BLsOuwK7CrsGuw27AbsJqYLdgt2G1sDuwOthd2D3YfdgD2EPYI1g97DHsCewp7BnsOawB1ghrgjXDWmCtsDZYO6wD1gnrgnXDemC9sD5YP2wANgh7AXsJewV7DRuCvYENw0Zgo7Ax2DhsAjYJm4JNw2Zgs7A52DxsAbYIW4Itw1Zgq7A12DpsA7YJ24Jtw3ZgCV/xbtsF2w3bA0uEJcH2wvbB9sMOwA7CDsEOw47AjsKOwY7DkmEpsFRYGiwdlgHLhGXBsmE5sFxYHiwfVgArhBXBimElsFJYGawcVgGrhFXBTsBOwk7BTsPOwM7CqmHnYOdhF2AXYZdgl2FXYFdh12DXYTdgN2E1sFuw27Ba2B1YHewu7B7sPuwB7CHsEawe9hj2BPYU9gz2HNYAa4Q1wZphLbBWWBusHdYB64R1wbphPbBeWB+sHzYAG4R91zf/v+f/SZydmi7+z6T/a9/y3e+2t4//H4I0jdes2UAA", + "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, THRESHOLD_SHARE_DECRYPTION_BIT_CT, THRESHOLD_SHARE_DECRYPTION_BIT_D,\n THRESHOLD_SHARE_DECRYPTION_BIT_E_SM, THRESHOLD_SHARE_DECRYPTION_BIT_R1,\n THRESHOLD_SHARE_DECRYPTION_BIT_R2, THRESHOLD_SHARE_DECRYPTION_BIT_SK,\n THRESHOLD_SHARE_DECRYPTION_CONFIGS,\n};\nuse lib::core::threshold::share_decryption::ShareDecryption;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n expected_sk_commitment: pub Field,\n expected_e_sm_commitment: pub Field,\n ct0: pub [Polynomial; L],\n ct1: pub [Polynomial; L],\n sk: [Polynomial; L],\n e_sm: [Polynomial; L],\n r1: [Polynomial<(2 * N) - 1>; L],\n r2: [Polynomial; L],\n d: [Polynomial; L],\n) {\n let share_decryption: ShareDecryption = ShareDecryption::new(\n THRESHOLD_SHARE_DECRYPTION_CONFIGS,\n expected_sk_commitment,\n expected_e_sm_commitment,\n ct0,\n ct1,\n sk,\n e_sm,\n r1,\n r2,\n d,\n );\n share_decryption.execute()\n}\n", + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/bin/threshold/share_decryption/src/main.nr" + }, + "71": { + "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::{\n compute_aggregated_shares_commitment, compute_threshold_share_decryption_challenge,\n};\nuse crate::math::helpers::flatten;\nuse crate::math::polynomial::Polynomial;\n\n/// Cryptographic parameters for Threshold decryption share circuit.\npub struct Configs {\n /// CRT moduli: [q_0, q_1, ..., q_{L-1}]\n pub qis: [Field; L],\n /// Bounds for r1 polynomials (modulus switching quotients) for each CRT basis\n pub r1_bounds: [Field; L],\n /// Bounds for r2 polynomials (cyclotomic reduction quotients) for each CRT basis\n pub r2_bounds: [Field; L],\n}\n\nimpl Configs {\n pub fn new(qis: [Field; L], r1_bounds: [Field; L], r2_bounds: [Field; L]) -> Self {\n Configs { qis, r1_bounds, r2_bounds }\n }\n}\n\n/// Threshold Share Decryption (Circuit 6).\n///\n/// Verifies:\n/// 1. Commitment to sk matches expected (from DKG decryption circuit)\n/// 2. Commitment to e_sm matches expected (from DKG decryption circuit)\n/// 3. Correct computation: d = c_0 + c_1 * s + e + r_2 * (X^N + 1) + r_1 * q_i\npub struct ShareDecryption {\n /// Circuit parameters including bounds and cryptographic constants\n configs: Configs,\n\n /// Expected commitment to aggregated sk shares (from DKG decryption circuit)\n /// (public witness)\n expected_sk_commitment: Field,\n\n /// Expected commitment to aggregated e_sm shares (from DKG decryption circuit)\n /// (public witness)\n expected_e_sm_commitment: Field,\n\n /// Ciphertext components (public witnesses)\n /// ct0 components for each CRT basis (degree N-1 polynomials with N coefficients)\n ct0: [Polynomial; L],\n /// ct1 components for each CRT basis (degree N-1 polynomials with N coefficients)\n ct1: [Polynomial; L],\n\n /// Aggregated sum of sk shares (secret witness)\n sk: [Polynomial; L],\n\n /// Aggregated sum of e_sm shares (secret witness, direct input)\n /// e_sm[basis] - sum of e_sm shares for each CRT basis (degree N-1 with N coefficients)\n e_sm: [Polynomial; L],\n\n /// Quotient polynomials for lifting to Z (secret witnesses)\n r1: [Polynomial<2 * N - 1>; L],\n r2: [Polynomial; L],\n\n /// Party's computed decryption share\n /// (public witnesses)\n d: [Polynomial; L],\n}\n\nimpl ShareDecryption {\n pub fn new(\n configs: Configs,\n expected_sk_commitment: Field,\n expected_e_sm_commitment: Field,\n ct0: [Polynomial; L],\n ct1: [Polynomial; L],\n sk: [Polynomial; L],\n e_sm: [Polynomial; L],\n r1: [Polynomial<2 * N - 1>; L],\n r2: [Polynomial; L],\n d: [Polynomial; L],\n ) -> Self {\n ShareDecryption {\n configs,\n expected_sk_commitment,\n expected_e_sm_commitment,\n ct0,\n ct1,\n sk,\n e_sm,\n r1,\n r2,\n d,\n }\n }\n\n /// Verifies that aggregated secret shares hash to expected_sk_commitment\n fn verify_agg_sk_commitment(self) {\n assert(\n compute_aggregated_shares_commitment::(self.sk)\n == self.expected_sk_commitment,\n \"S commitment mismatch\",\n );\n }\n\n /// Verifies that aggregated noise shares hash to expected_e_sm_commitment\n fn verify_agg_e_sm_commitment(self) {\n assert(\n compute_aggregated_shares_commitment::(self.e_sm)\n == self.expected_e_sm_commitment,\n \"E commitment mismatch\",\n );\n }\n\n /// Flattens all witness data into a single array for Fiat-Shamir challenge generation.\n ///\n /// This function serializes all polynomial coefficients (both public inputs and\n /// secret witnesses) into a 1D array in a deterministic order. The flattened data\n /// is used to generate the Fiat-Shamir challenge via the SAFE sponge API.\n ///\n /// The order of serialization is:\n /// 1. Commitment to aggregated secret shares `sk` (expected_sk_commitment)\n /// 2. Commitment to aggregated noise shares `e_sm` (expected_e_sm_commitment)\n /// 3. Ciphertext components `c_0` for each CRT basis (serialized coefficients)\n /// 4. Ciphertext components `c_1` for each CRT basis (serialized coefficients)\n /// 5. Quotient polynomials `r_1` for each CRT basis (serialized coefficients)\n /// 6. Quotient polynomials `r_2` for each CRT basis (serialized coefficients)\n /// 7. Decryption shares `d` for each CRT basis (serialized coefficients)\n ///\n /// Note: Aggregated secret shares `s` and noise shares `e` are represented by their\n /// commitments rather than serialized coefficients. This saves constraints while\n /// still binding them to the transcript.\n ///\n /// # Returns\n /// A vector containing commitments and polynomial coefficients in flattened form,\n /// ready for hashing to generate the Fiat-Shamir challenge.\n fn payload(self) -> Vec {\n let mut inputs = Vec::new();\n\n // Use commitments instead of full polynomials (saves constraints)\n inputs.push(self.expected_sk_commitment);\n inputs.push(self.expected_e_sm_commitment);\n\n // Flatten ciphertext components (public inputs)\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct0);\n inputs = flatten::<_, _, BIT_CT>(inputs, self.ct1);\n\n // Flatten quotient polynomials (secret witnesses)\n inputs = flatten::<_, _, BIT_R1>(inputs, self.r1);\n inputs = flatten::<_, _, BIT_R2>(inputs, self.r2);\n\n // Flatten decryption shares (public outputs)\n inputs = flatten::<_, _, BIT_D>(inputs, self.d);\n\n inputs\n }\n\n /// Main verification function\n pub fn execute(self) {\n // Step 1: Verify s commitment matches expected\n self.verify_agg_sk_commitment();\n\n // Step 2: Verify e commitment matches expected\n self.verify_agg_e_sm_commitment();\n\n // Step 3: Perform range checks on all secret witness values\n self.check_range_bounds();\n\n // Step 4: Generate Fiat-Shamir challenge from the transcript\n let gamma = self.generate_challenge();\n\n // Step 5: Verify decryption share computation for each CRT basis\n for i in 0..L {\n self.verify_decryption_share_computation(i, gamma);\n }\n }\n\n /// Performs range checks on all secret witness values.\n ///\n /// This function constrains all secret witnesses to be within their expected bounds\n /// as specified in the `configs`. This is critical for security because it prevents\n /// attacks where malicious provers provide out-of-range values that could break the\n /// security properties of the Threshold scheme.\n ///\n /// The function checks:\n /// - Aggregated secret shares `sk` are within bounds for each CRT basis\n /// - Aggregated noise shares `e_sm` are within bounds for each CRT basis\n /// - Quotient polynomials `r_1` and `r_2` are within bounds for each CRT basis\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 // Check aggregated sums are within bounds\n for basis_idx in 0..L {\n self.sk[basis_idx].range_check_2bounds::(\n self.configs.r2_bounds[basis_idx],\n self.configs.r2_bounds[basis_idx],\n );\n self.e_sm[basis_idx].range_check_2bounds::(\n self.configs.r2_bounds[basis_idx],\n self.configs.r2_bounds[basis_idx],\n );\n }\n\n // Check quotient polynomials are within bounds\n for basis_idx in 0..L {\n // r_1 quotients can be negative (modulus quotients)\n self.r1[basis_idx].range_check_2bounds::(\n self.configs.r1_bounds[basis_idx],\n self.configs.r1_bounds[basis_idx],\n );\n // r_2 quotients (cyclotomic quotients)\n self.r2[basis_idx].range_check_2bounds::(\n self.configs.r2_bounds[basis_idx],\n self.configs.r2_bounds[basis_idx],\n );\n }\n }\n\n /// Generates Fiat-Shamir challenge value using the SAFE cryptographic sponge.\n ///\n /// This function implements the Fiat-Shamir transform for the decryption share circuit:\n /// 1. Flattens all witness data (commitments for s/e, ciphertexts c_0/c_1, quotients r_1/r_2, decryption shares d) into a single array\n /// 2. Absorbs the flattened data into the SAFE sponge\n /// 3. Squeezes a single challenge value\n ///\n /// The challenge is used to evaluate polynomials for the Schwartz-Zippel lemma,\n /// which allows verification of polynomial equations by checking them at a random\n /// point rather than checking all coefficients.\n ///\n /// # Returns\n /// A single challenge value `gamma` used as the evaluation point for verifying\n /// the decryption share computation formula for all CRT bases.\n fn generate_challenge(self) -> Field {\n let inputs = self.payload();\n\n compute_threshold_share_decryption_challenge::(inputs)\n }\n\n /// Verifies the lifted decryption share computation formula for a specific CRT basis using the Schwartz-Zippel lemma.\n ///\n /// This function verifies that the decryption share for basis `i` satisfies:\n /// `d_i(gamma) = c_0i(gamma) + c_1i(gamma) * s(gamma) + e_i(gamma) + r_2_i(gamma) * cyclo(gamma) + r_1_i(gamma) * q_i`\n ///\n /// Where:\n /// - `c_0i`, `c_1i` are ciphertext components for basis i\n /// - `s` is the aggregated secret key shares\n /// - `e_i` is the aggregated noise shares\n /// - `r_1_i`, `r_2_i` are quotient witnesses\n /// - `cyclo(gamma) = gamma^N + 1` is the cyclotomic polynomial evaluated at gamma\n /// - `q_i` is the CRT modulus for basis i\n ///\n /// The Schwartz-Zippel lemma ensures that if this equation holds at a random point\n /// `gamma`, then the polynomials are identical with high probability.\n ///\n /// # Arguments\n /// * `basis_idx` - The index of the CRT basis to verify (0 <= basis_idx < L)\n /// * `gamma` - The Fiat-Shamir challenge value used as the evaluation point\n ///\n /// # Panics\n /// The circuit will fail if the decryption share computation formula doesn't hold for the specified basis.\n fn verify_decryption_share_computation(self, basis_idx: u32, gamma: Field) {\n // Evaluate ciphertext components at gamma\n let c_0_at_gamma = self.ct0[basis_idx].eval(gamma);\n let c_1_at_gamma = self.ct1[basis_idx].eval(gamma);\n\n // Evaluate aggregated sums at gamma\n let sk_at_gamma = self.sk[basis_idx].eval(gamma);\n let e_sm_at_gamma = self.e_sm[basis_idx].eval(gamma);\n\n // Evaluate quotient polynomials at gamma\n let r_1_at_gamma = self.r1[basis_idx].eval(gamma);\n let r_2_at_gamma = self.r2[basis_idx].eval(gamma);\n\n // Evaluate cyclotomic polynomial X^N + 1 at gamma\n let cyclo_at_gamma = gamma.pow_32(N as Field) + 1;\n\n // Compute expected decryption share using the lifted formula:\n // d_i = c_0i + c_1i * sk + e_sm_i + r_2_i * (X^N + 1) + r_1_i * q_i\n let expected_decryption_share = c_0_at_gamma\n + c_1_at_gamma * sk_at_gamma\n + e_sm_at_gamma\n + r_2_at_gamma * cyclo_at_gamma\n + r_1_at_gamma * self.configs.qis[basis_idx];\n\n // Evaluate the party's claimed decryption share at gamma\n let computed_decryption_share = self.d[basis_idx].eval(gamma);\n\n // Enforce equality: computed decryption share must match expected value\n assert(\n computed_decryption_share == expected_decryption_share,\n \"Decryption share computation failed\",\n );\n }\n}\n", + "path": "/Users/omardesogus/Projects/Enclave/enclave/circuits/lib/src/core/threshold/share_decryption.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 } } +} diff --git a/crates/zk-prover/tests/fixtures/threshold_share_decryption.vk b/crates/zk-prover/tests/fixtures/threshold_share_decryption.vk new file mode 100644 index 0000000000..c3cce82305 Binary files /dev/null and b/crates/zk-prover/tests/fixtures/threshold_share_decryption.vk differ diff --git a/crates/zk-prover/tests/local_e2e_tests.rs b/crates/zk-prover/tests/local_e2e_tests.rs index 6c6aaefb40..ecf68e3ecd 100644 --- a/crates/zk-prover/tests/local_e2e_tests.rs +++ b/crates/zk-prover/tests/local_e2e_tests.rs @@ -5,9 +5,11 @@ // or FITNESS FOR A PARTICULAR PURPOSE. //! Local end-to-end tests that require a local bb binary. -//! These tests will be skipped if bb is not found on the system. +//! These tests will be skipped if bb is not found; missing fixtures cause test failure. //! //! To add a new circuit: add setup_*_test() and one line in `e2e_proof_tests!`. +//! Sync fixtures from circuits target: `pnpm sync:fixtures` (copies .json and .vk from +//! circuits/bin/{dkg,threshold}/target into tests/fixtures/). //! Commitment consistency tests are defined separately. mod common; @@ -19,8 +21,19 @@ use e3_zk_helpers::circuits::dkg::pk::circuit::PkCircuitData; use e3_zk_helpers::circuits::{commitments::compute_dkg_pk_commitment, CircuitComputation}; use e3_zk_helpers::computation::DkgInputType; use e3_zk_helpers::dkg::share_computation::{ShareComputationCircuit, ShareComputationCircuitData}; +use e3_zk_helpers::dkg::share_decryption::{ShareDecryptionCircuit, ShareDecryptionCircuitData}; use e3_zk_helpers::dkg::share_encryption::{ShareEncryptionCircuit, ShareEncryptionCircuitData}; use e3_zk_helpers::threshold::pk_generation::{PkGenerationCircuit, PkGenerationCircuitData}; +use e3_zk_helpers::threshold::{ + decrypted_shares_aggregation::{ + DecryptedSharesAggregationCircuit, DecryptedSharesAggregationCircuitData, + }, + pk_aggregation::{PkAggregationCircuit, PkAggregationCircuitData}, + share_decryption::{ + ShareDecryptionCircuit as ThresholdShareDecryptionCircuit, + ShareDecryptionCircuitData as ThresholdShareDecryptionCircuitData, + }, +}; use e3_zk_helpers::CiphernodesCommitteeSize; use e3_zk_helpers::{ compute_share_computation_e_sm_commitment, compute_share_computation_sk_commitment, @@ -89,23 +102,29 @@ async fn setup_test_prover(bb: &PathBuf) -> (ZkBackend, tempfile::TempDir) { } async fn setup_circuit_fixtures(backend: &ZkBackend, circuit_path: &[&str], fixture_name: &str) { + let fixtures = fixtures_dir(); + let json_path = fixtures.join(format!("{fixture_name}.json")); + let vk_path = fixtures.join(format!("{fixture_name}.vk")); + assert!( + json_path.exists(), + "missing circuit fixture: {} (run `pnpm sync:fixtures` to copy from circuits target)", + json_path.display() + ); + assert!( + vk_path.exists(), + "missing verification key fixture: {}", + vk_path.display() + ); let circuit_dir = circuit_path .iter() .fold(backend.circuits_dir.clone(), |p, seg| p.join(seg)); - let fixtures = fixtures_dir(); fs::create_dir_all(&circuit_dir).await.unwrap(); - fs::copy( - fixtures.join(format!("{fixture_name}.json")), - circuit_dir.join(format!("{fixture_name}.json")), - ) - .await - .unwrap(); - fs::copy( - fixtures.join(format!("{fixture_name}.vk")), - circuit_dir.join(format!("{fixture_name}.vk")), - ) - .await - .unwrap(); + fs::copy(json_path, circuit_dir.join(format!("{fixture_name}.json"))) + .await + .unwrap(); + fs::copy(vk_path, circuit_dir.join(format!("{fixture_name}.vk"))) + .await + .unwrap(); } async fn setup_share_encryption_e_sm_test() -> Option<( @@ -305,7 +324,181 @@ async fn setup_pk_generation_test() -> Option<( )) } -async fn setup_pk_bfv_test() -> Option<( +async fn setup_share_decryption_sk_test() -> Option<( + ZkBackend, + tempfile::TempDir, + ZkProver, + ShareDecryptionCircuit, + ShareDecryptionCircuitData, + BfvPreset, + &'static str, +)> { + let committee = CiphernodesCommitteeSize::Small.values(); + let preset = BfvPreset::InsecureThreshold512; + let bb = find_bb().await?; + let (backend, temp) = setup_test_prover(&bb).await; + + setup_circuit_fixtures( + &backend, + &["dkg", "dkg_sk_share_decryption"], + "dkg_sk_share_decryption", + ) + .await; + + let sample = + ShareDecryptionCircuitData::generate_sample(preset, committee, DkgInputType::SecretKey) + .ok()?; + let prover = ZkProver::new(&backend); + + Some(( + backend, + temp, + prover, + ShareDecryptionCircuit, + sample, + preset, + "1", + )) +} + +async fn setup_share_decryption_e_sm_test() -> Option<( + ZkBackend, + tempfile::TempDir, + ZkProver, + ShareDecryptionCircuit, + ShareDecryptionCircuitData, + BfvPreset, + &'static str, +)> { + let committee = CiphernodesCommitteeSize::Small.values(); + let preset = BfvPreset::InsecureThreshold512; + let bb = find_bb().await?; + let (backend, temp) = setup_test_prover(&bb).await; + + setup_circuit_fixtures( + &backend, + &["dkg", "dkg_e_sm_share_decryption"], + "dkg_e_sm_share_decryption", + ) + .await; + + let sample = + ShareDecryptionCircuitData::generate_sample(preset, committee, DkgInputType::SmudgingNoise) + .ok()?; + let prover = ZkProver::new(&backend); + + Some(( + backend, + temp, + prover, + ShareDecryptionCircuit, + sample, + preset, + "1", + )) +} + +async fn setup_pk_aggregation_test() -> Option<( + ZkBackend, + tempfile::TempDir, + ZkProver, + PkAggregationCircuit, + PkAggregationCircuitData, + BfvPreset, + &'static str, +)> { + let committee = CiphernodesCommitteeSize::Small.values(); + let preset = BfvPreset::InsecureThreshold512; + let bb = find_bb().await?; + let (backend, temp) = setup_test_prover(&bb).await; + + setup_circuit_fixtures(&backend, &["threshold", "pk_aggregation"], "pk_aggregation").await; + + let sample = PkAggregationCircuitData::generate_sample(preset, committee).ok()?; + let prover = ZkProver::new(&backend); + + Some(( + backend, + temp, + prover, + PkAggregationCircuit, + sample, + preset, + "1", + )) +} + +async fn setup_threshold_share_decryption_test() -> Option<( + ZkBackend, + tempfile::TempDir, + ZkProver, + ThresholdShareDecryptionCircuit, + ThresholdShareDecryptionCircuitData, + BfvPreset, + &'static str, +)> { + let committee = CiphernodesCommitteeSize::Small.values(); + let preset = BfvPreset::InsecureThreshold512; + let bb = find_bb().await?; + let (backend, temp) = setup_test_prover(&bb).await; + + setup_circuit_fixtures( + &backend, + &["threshold", "threshold_share_decryption"], + "threshold_share_decryption", + ) + .await; + + let sample = ThresholdShareDecryptionCircuitData::generate_sample(preset, committee).ok()?; + let prover = ZkProver::new(&backend); + + Some(( + backend, + temp, + prover, + ThresholdShareDecryptionCircuit, + sample, + preset, + "1", + )) +} + +async fn setup_decrypted_shares_aggregation_test() -> Option<( + ZkBackend, + tempfile::TempDir, + ZkProver, + DecryptedSharesAggregationCircuit, + DecryptedSharesAggregationCircuitData, + BfvPreset, + &'static str, +)> { + let committee = CiphernodesCommitteeSize::Small.values(); + let preset = BfvPreset::InsecureThreshold512; + let bb = find_bb().await?; + let (backend, temp) = setup_test_prover(&bb).await; + + setup_circuit_fixtures( + &backend, + &["threshold", "decrypted_shares_aggregation"], + "decrypted_shares_aggregation", + ) + .await; + + let sample = DecryptedSharesAggregationCircuitData::generate_sample(preset, committee).ok()?; + let prover = ZkProver::new(&backend); + + Some(( + backend, + temp, + prover, + DecryptedSharesAggregationCircuit, + sample, + preset, + "1", + )) +} + +async fn setup_pk_test() -> Option<( ZkBackend, tempfile::TempDir, ZkProver, @@ -363,11 +556,16 @@ macro_rules! e2e_proof_tests { e2e_proof_tests! { (pk_generation, setup_pk_generation_test()), - (pk_bfv, setup_pk_bfv_test()), + (pk, setup_pk_test()), (share_computation_sk, setup_share_computation_sk_test()), (share_computation_e_sm, setup_share_computation_e_sm_test()), (share_encryption_sk, setup_share_encryption_sk_test()), (share_encryption_e_sm, setup_share_encryption_e_sm_test()), + (share_decryption_sk, setup_share_decryption_sk_test()), + (share_decryption_e_sm, setup_share_decryption_e_sm_test()), + (pk_aggregation, setup_pk_aggregation_test()), + (threshold_share_decryption, setup_threshold_share_decryption_test()), + (decrypted_shares_aggregation, setup_decrypted_shares_aggregation_test()), } #[tokio::test] @@ -423,7 +621,7 @@ async fn test_pk_generation_commitment_consistency() { #[tokio::test] async fn test_pk_bfv_commitment_consistency() { - let Some((_backend, _temp, prover, circuit, sample, preset, e3_id)) = setup_pk_bfv_test().await + let Some((_backend, _temp, prover, circuit, sample, preset, e3_id)) = setup_pk_test().await else { println!("skipping: bb not found"); return; @@ -515,3 +713,66 @@ async fn test_share_computation_e_sm_commitment_consistency() { prover.cleanup(e3_id).unwrap(); } + +#[tokio::test] +async fn test_pk_aggregation_commitment_consistency() { + let Some((_backend, _temp, prover, circuit, sample, preset, e3_id)) = + setup_pk_aggregation_test().await + else { + println!("skipping: bb not found"); + return; + }; + + let proof = circuit + .prove(&prover, &preset, &sample, e3_id) + .expect("proof generation should succeed"); + + let computation_output = PkAggregationCircuit::compute(preset, &sample).unwrap(); + + for (i, expected) in computation_output + .inputs + .expected_threshold_pk_commitments + .iter() + .enumerate() + { + let commitment_from_proof = extract_field(&proof.public_signals, i); + assert_eq!( + commitment_from_proof, *expected, + "pk_aggregation commitment {} mismatch", + i + ); + } + + prover.cleanup(e3_id).unwrap(); +} + +#[tokio::test] +async fn test_threshold_share_decryption_commitment_consistency() { + let Some((_backend, _temp, prover, circuit, sample, preset, e3_id)) = + setup_threshold_share_decryption_test().await + else { + println!("skipping: bb not found"); + return; + }; + + let proof = circuit + .prove(&prover, &preset, &sample, e3_id) + .expect("proof generation should succeed"); + + let computation_output = ThresholdShareDecryptionCircuit::compute(preset, &sample) + .expect("computation should succeed"); + + let sk_commitment_from_proof = extract_field(&proof.public_signals, 0); + let e_sm_commitment_from_proof = extract_field(&proof.public_signals, 1); + + assert_eq!( + sk_commitment_from_proof, computation_output.inputs.expected_sk_commitment, + "sk commitment mismatch" + ); + assert_eq!( + e_sm_commitment_from_proof, computation_output.inputs.expected_e_sm_commitment, + "e_sm commitment mismatch" + ); + + prover.cleanup(e3_id).unwrap(); +}