From 1aaf9aebdbffe7b5cc7283f9130656f1c41b3aa1 Mon Sep 17 00:00:00 2001 From: GunaDD Date: Fri, 27 Feb 2026 21:41:28 +0000 Subject: [PATCH 01/78] feat: new keccak (#2303) New Keccak with Xorin and Keccakf chip and opcode - [ ] I have performed a self-review of my own code - [ ] Add negative tests for xorin chip - [ ] Add negative tests for keccakf chip - [x] Add unit test to CI - [x] Add new guest code for E2E test to CI (the keccak example is updated, but I am thinking of adding another one) - [ ] Check with Ayush if I implemented the SizedRecord trait correctly - [ ] Rebase to include Zach's new Plonky3 update and update the keccakf trace gen to not have to transpose any more before giving it into the input - [ ] Maybe add comments to justify the correctness of the constrain_input_read and constraint_output_write function To reviewer: I will still have to complete the above checklist. But you can start reviewing if you would like to. Closes INT-5017, INT-5721, INT-5720, INT-5718, INT-5717, INT-5646, INT-5018 --- Cargo.toml | 6 + examples/keccak/Cargo.toml | 3 + examples/keccak/openvm.toml | 2 +- examples/keccak/src/main.rs | 33 +- extensions/new-keccak256/circuit/Cargo.toml | 56 +++ .../circuit/src/extension/mod.rs | 243 ++++++++++++ .../new-keccak256/circuit/src/keccakf/air.rs | 316 ++++++++++++++++ .../circuit/src/keccakf/columns.rs | 42 +++ .../circuit/src/keccakf/execution.rs | 220 +++++++++++ .../new-keccak256/circuit/src/keccakf/mod.rs | 24 ++ .../circuit/src/keccakf/tests.rs | 149 ++++++++ .../circuit/src/keccakf/trace.rs | 351 ++++++++++++++++++ .../circuit/src/keccakf/utils.rs | 4 + extensions/new-keccak256/circuit/src/lib.rs | 10 + .../new-keccak256/circuit/src/xorin/air.rs | 340 +++++++++++++++++ .../circuit/src/xorin/columns.rs | 55 +++ .../circuit/src/xorin/execution.rs | 220 +++++++++++ .../new-keccak256/circuit/src/xorin/mod.rs | 27 ++ .../new-keccak256/circuit/src/xorin/tests.rs | 251 +++++++++++++ .../new-keccak256/circuit/src/xorin/trace.rs | 341 +++++++++++++++++ .../new-keccak256/circuit/src/xorin/utils.rs | 2 + extensions/new-keccak256/guest/Cargo.toml | 14 + extensions/new-keccak256/guest/src/lib.rs | 86 +++++ .../new-keccak256/transpiler/Cargo.toml | 17 + .../new-keccak256/transpiler/src/lib.rs | 70 ++++ 25 files changed, 2860 insertions(+), 22 deletions(-) create mode 100644 extensions/new-keccak256/circuit/Cargo.toml create mode 100644 extensions/new-keccak256/circuit/src/extension/mod.rs create mode 100644 extensions/new-keccak256/circuit/src/keccakf/air.rs create mode 100644 extensions/new-keccak256/circuit/src/keccakf/columns.rs create mode 100644 extensions/new-keccak256/circuit/src/keccakf/execution.rs create mode 100644 extensions/new-keccak256/circuit/src/keccakf/mod.rs create mode 100644 extensions/new-keccak256/circuit/src/keccakf/tests.rs create mode 100644 extensions/new-keccak256/circuit/src/keccakf/trace.rs create mode 100644 extensions/new-keccak256/circuit/src/keccakf/utils.rs create mode 100644 extensions/new-keccak256/circuit/src/lib.rs create mode 100644 extensions/new-keccak256/circuit/src/xorin/air.rs create mode 100644 extensions/new-keccak256/circuit/src/xorin/columns.rs create mode 100644 extensions/new-keccak256/circuit/src/xorin/execution.rs create mode 100644 extensions/new-keccak256/circuit/src/xorin/mod.rs create mode 100644 extensions/new-keccak256/circuit/src/xorin/tests.rs create mode 100644 extensions/new-keccak256/circuit/src/xorin/trace.rs create mode 100644 extensions/new-keccak256/circuit/src/xorin/utils.rs create mode 100644 extensions/new-keccak256/guest/Cargo.toml create mode 100644 extensions/new-keccak256/guest/src/lib.rs create mode 100644 extensions/new-keccak256/transpiler/Cargo.toml create mode 100644 extensions/new-keccak256/transpiler/src/lib.rs diff --git a/Cargo.toml b/Cargo.toml index 2fea149413..555dbb4a31 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -53,6 +53,9 @@ members = [ "extensions/keccak256/circuit", "extensions/keccak256/transpiler", "extensions/keccak256/guest", + "extensions/new-keccak256/circuit", + "extensions/new-keccak256/guest", + "extensions/new-keccak256/transpiler", "extensions/sha256/circuit", "extensions/sha256/transpiler", "extensions/sha256/guest", @@ -159,6 +162,9 @@ openvm-rv32-adapters = { path = "extensions/rv32-adapters", default-features = f openvm-keccak256-circuit = { path = "extensions/keccak256/circuit", default-features = false } openvm-keccak256-transpiler = { path = "extensions/keccak256/transpiler", default-features = false } openvm-keccak256-guest = { path = "extensions/keccak256/guest", default-features = false } +openvm-new-keccak256-circuit = { path = "extensions/new-keccak256/circuit", default-features = false } +openvm-new-keccak256-guest = { path = "extensions/new-keccak256/guest", default-features = false } +openvm-new-keccak256-transpiler = { path = "extensions/new-keccak256/transpiler", default-features = false } openvm-sha256-circuit = { path = "extensions/sha256/circuit", default-features = false } openvm-sha256-transpiler = { path = "extensions/sha256/transpiler", default-features = false } openvm-sha256-guest = { path = "extensions/sha256/guest", default-features = false } diff --git a/examples/keccak/Cargo.toml b/examples/keccak/Cargo.toml index 74f15e6234..128537ba9d 100644 --- a/examples/keccak/Cargo.toml +++ b/examples/keccak/Cargo.toml @@ -12,6 +12,8 @@ openvm = { git = "https://github.com/openvm-org/openvm.git", features = [ ] } openvm-keccak256 = { git = "https://github.com/openvm-org/openvm.git" } hex = { version = "0.4.3" } +tiny-keccak = { git = "https://github.com/openvm-org/tiny-keccak.git", features = ["keccak"] } +openvm-new-keccak256-guest = { path = "../../extensions/new-keccak256/guest" } [features] default = [] @@ -20,3 +22,4 @@ default = [] [patch."https://github.com/openvm-org/openvm.git"] openvm = { path = "../../crates/toolchain/openvm" } openvm-keccak256 = { path = "../../guest-libs/keccak256" } + diff --git a/examples/keccak/openvm.toml b/examples/keccak/openvm.toml index 90e80fa97f..61b2a0a406 100644 --- a/examples/keccak/openvm.toml +++ b/examples/keccak/openvm.toml @@ -1,4 +1,4 @@ [app_vm_config.rv32i] [app_vm_config.rv32m] [app_vm_config.io] -[app_vm_config.keccak] \ No newline at end of file +[app_vm_config.new_keccak] \ No newline at end of file diff --git a/examples/keccak/src/main.rs b/examples/keccak/src/main.rs index cc12a2e859..b4625c850f 100644 --- a/examples/keccak/src/main.rs +++ b/examples/keccak/src/main.rs @@ -1,30 +1,21 @@ // [!region imports] -use core::hint::black_box; - -use hex::FromHex; use openvm as _; -use openvm_keccak256::keccak256; // [!endregion imports] // [!region main] + +// todo: call the forked tiny keccak library once that is updated instead of directly calling the +// keccak256_guest native functions pub fn main() { - let test_vectors = [ - ( - "", - "C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", - ), - ( - "CC", - "EEAD6DBFC7340A56CAEDC044696A168870549A6A7F6F56961E84A54BD9970B8A", - ), - ]; - for (input, expected_output) in test_vectors.iter() { - let input = Vec::from_hex(input).unwrap(); - let expected_output = Vec::from_hex(expected_output).unwrap(); - let output = keccak256(&black_box(input)); - if output != *expected_output { - panic!(); - } + #[cfg(target_os = "zkvm")] + { + let mut buffer = [1u8; 200]; + let input = [2u8; 136]; + let output = [3u8; 136]; + let len: usize = 136; + openvm_new_keccak256_guest::native_xorin(buffer.as_mut_ptr(), input.as_ptr(), len); + assert_eq!(buffer[..136], output); + openvm_new_keccak256_guest::native_keccakf(buffer.as_mut_ptr()); } } // [!endregion main] diff --git a/extensions/new-keccak256/circuit/Cargo.toml b/extensions/new-keccak256/circuit/Cargo.toml new file mode 100644 index 0000000000..048e7ff9b2 --- /dev/null +++ b/extensions/new-keccak256/circuit/Cargo.toml @@ -0,0 +1,56 @@ +[package] +name = "openvm-new-keccak256-circuit" +description = "OpenVM circuit extension for keccak256" +version.workspace = true +authors.workspace = true +edition.workspace = true +homepage.workspace = true +repository.workspace = true + +[dependencies] +openvm-stark-backend = { workspace = true } +openvm-stark-sdk = { workspace = true } +openvm-circuit-primitives = { workspace = true } +openvm-circuit-primitives-derive = { workspace = true } +openvm-circuit = { workspace = true } +openvm-circuit-derive = { workspace = true } +openvm-instructions = { workspace = true } +openvm-rv32im-circuit = { workspace = true } +openvm-new-keccak256-transpiler = { workspace = true } + +p3-keccak-air = { workspace = true } + +strum.workspace = true +tiny-keccak.workspace = true +itertools.workspace = true +derive-new.workspace = true +derive_more = { workspace = true, features = ["from"] } +rand.workspace = true +serde.workspace = true + +[dev-dependencies] +openvm-stark-sdk = { workspace = true } +openvm-circuit = { workspace = true, features = ["test-utils"] } + +[features] +default = ["parallel", "jemalloc"] +parallel = ["openvm-circuit/parallel"] +test-utils = ["openvm-circuit/test-utils"] +tco = ["openvm-rv32im-circuit/tco"] +aot = ["openvm-circuit/aot", "openvm-rv32im-circuit/aot"] +# performance features: +mimalloc = ["openvm-circuit/mimalloc"] +jemalloc = ["openvm-circuit/jemalloc"] +jemalloc-prof = ["openvm-circuit/jemalloc-prof"] +nightly-features = ["openvm-circuit/nightly-features"] +cuda = [ + "openvm-circuit-primitives/cuda", + "openvm-circuit/cuda", + "openvm-rv32im-circuit/cuda", +] +touchemall = [ + "cuda", + "openvm-circuit/touchemall", + "openvm-circuit-primitives/touchemall", + "openvm-rv32im-circuit/touchemall", +] diff --git a/extensions/new-keccak256/circuit/src/extension/mod.rs b/extensions/new-keccak256/circuit/src/extension/mod.rs new file mode 100644 index 0000000000..f65d242940 --- /dev/null +++ b/extensions/new-keccak256/circuit/src/extension/mod.rs @@ -0,0 +1,243 @@ +use std::{result::Result, sync::Arc}; + +use derive_more::derive::From; +use openvm_circuit::{ + arch::{ + AirInventory, AirInventoryError, ChipInventory, ChipInventoryError, ExecutionBridge, + ExecutorInventoryBuilder, ExecutorInventoryError, InitFileGenerator, MatrixRecordArena, + RowMajorMatrixArena, SystemConfig, VmBuilder, VmChipComplex, VmCircuitExtension, + VmExecutionExtension, VmProverExtension, + }, + system::{ + memory::SharedMemoryHelper, SystemChipInventory, SystemCpuBuilder, SystemExecutor, + SystemPort, + }, +}; +use openvm_circuit_derive::{AnyEnum, Executor, MeteredExecutor, PreflightExecutor, VmConfig}; +use openvm_circuit_primitives::bitwise_op_lookup::{ + BitwiseOperationLookupAir, BitwiseOperationLookupBus, BitwiseOperationLookupChip, + SharedBitwiseOperationLookupChip, +}; +use openvm_instructions::LocalOpcode; +use openvm_new_keccak256_transpiler::{KeccakfOpcode, XorinOpcode}; +use openvm_rv32im_circuit::{ + Rv32I, Rv32IExecutor, Rv32ImCpuProverExt, Rv32Io, Rv32IoExecutor, Rv32M, Rv32MExecutor, +}; +use openvm_stark_backend::{ + config::{StarkGenericConfig, Val}, + p3_field::PrimeField32, + prover::cpu::{CpuBackend, CpuDevice}, +}; +use openvm_stark_sdk::engine::StarkEngine; +use serde::{Deserialize, Serialize}; +use strum::IntoEnumIterator; + +use crate::{ + keccakf::{air::KeccakfVmAir, KeccakfVmChip, KeccakfVmExecutor, KeccakfVmFiller}, + xorin::{air::XorinVmAir, XorinVmChip, XorinVmExecutor, XorinVmFiller}, +}; + +#[derive(Clone, Debug, VmConfig, derive_new::new, Serialize, Deserialize)] +pub struct NewKeccak256Rv32Config { + #[config(executor = "SystemExecutor")] + pub system: SystemConfig, + #[extension] + pub rv32i: Rv32I, + #[extension] + pub rv32m: Rv32M, + #[extension] + pub io: Rv32Io, + #[extension] + pub keccak: NewKeccak256, +} + +impl Default for NewKeccak256Rv32Config { + fn default() -> Self { + Self { + system: SystemConfig::default(), + rv32i: Rv32I, + rv32m: Rv32M::default(), + io: Rv32Io, + keccak: NewKeccak256, + } + } +} + +// Default implementation uses no init file +impl InitFileGenerator for NewKeccak256Rv32Config {} + +#[derive(Clone)] +pub struct NewKeccak256Rv32CpuBuilder; + +impl VmBuilder for NewKeccak256Rv32CpuBuilder +where + SC: StarkGenericConfig, + E: StarkEngine, PD = CpuDevice>, + Val: PrimeField32, +{ + type VmConfig = NewKeccak256Rv32Config; + type SystemChipInventory = SystemChipInventory; + type RecordArena = MatrixRecordArena>; + + fn create_chip_complex( + &self, + config: &NewKeccak256Rv32Config, + circuit: AirInventory, + ) -> Result< + VmChipComplex, + ChipInventoryError, + > { + let mut chip_complex = + VmBuilder::::create_chip_complex(&SystemCpuBuilder, &config.system, circuit)?; + let inventory = &mut chip_complex.inventory; + VmProverExtension::::extend_prover(&Rv32ImCpuProverExt, &config.rv32i, inventory)?; + VmProverExtension::::extend_prover(&Rv32ImCpuProverExt, &config.rv32m, inventory)?; + VmProverExtension::::extend_prover(&Rv32ImCpuProverExt, &config.io, inventory)?; + VmProverExtension::::extend_prover( + &NewKeccak256CpuProverExt, + &config.keccak, + inventory, + )?; + Ok(chip_complex) + } +} + +// =================================== VM Extension Implementation ================================= +#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)] +pub struct NewKeccak256; + +#[derive(Clone, Copy, From, AnyEnum, Executor, MeteredExecutor, PreflightExecutor)] +#[cfg_attr( + feature = "aot", + derive( + openvm_circuit_derive::AotExecutor, + openvm_circuit_derive::AotMeteredExecutor + ) +)] +pub enum NewKeccak256Executor { + Keccakf(KeccakfVmExecutor), + Xorin(XorinVmExecutor), +} + +impl VmExecutionExtension for NewKeccak256 { + type Executor = NewKeccak256Executor; + + fn extend_execution( + &self, + inventory: &mut ExecutorInventoryBuilder, + ) -> Result<(), ExecutorInventoryError> { + let pointer_max_bits = inventory.pointer_max_bits(); + + let xorin_executor = XorinVmExecutor::new(XorinOpcode::CLASS_OFFSET, pointer_max_bits); + inventory.add_executor( + xorin_executor, + XorinOpcode::iter().map(|x| x.global_opcode()), + )?; + + let keccak_executor = KeccakfVmExecutor::new(KeccakfOpcode::CLASS_OFFSET, pointer_max_bits); + inventory.add_executor( + keccak_executor, + KeccakfOpcode::iter().map(|x| x.global_opcode()), + )?; + + Ok(()) + } +} + +impl VmCircuitExtension for NewKeccak256 { + fn extend_circuit(&self, inventory: &mut AirInventory) -> Result<(), AirInventoryError> { + let SystemPort { + execution_bus, + program_bus, + memory_bridge, + } = inventory.system().port(); + + let exec_bridge = ExecutionBridge::new(execution_bus, program_bus); + let pointer_max_bits = inventory.pointer_max_bits(); + + let bitwise_lu = { + let existing_air = inventory.find_air::>().next(); + if let Some(air) = existing_air { + air.bus + } else { + let bus = BitwiseOperationLookupBus::new(inventory.new_bus_idx()); + let air = BitwiseOperationLookupAir::<8>::new(bus); + inventory.add_air(air); + air.bus + } + }; + + let xorin_air = XorinVmAir::new( + exec_bridge, + memory_bridge, + bitwise_lu, + pointer_max_bits, + XorinOpcode::CLASS_OFFSET, + ); + inventory.add_air(xorin_air); + + let keccak_air = KeccakfVmAir::new( + exec_bridge, + memory_bridge, + bitwise_lu, + pointer_max_bits, + KeccakfOpcode::CLASS_OFFSET, + ); + inventory.add_air(keccak_air); + + Ok(()) + } +} + +pub struct NewKeccak256CpuProverExt; +// This implementation is specific to CpuBackend because the lookup chips (VariableRangeChecker, +// BitwiseOperationLookupChip) are specific to CpuBackend. +impl VmProverExtension for NewKeccak256CpuProverExt +where + SC: StarkGenericConfig, + E: StarkEngine, PD = CpuDevice>, + RA: RowMajorMatrixArena>, + Val: PrimeField32, +{ + fn extend_prover( + &self, + _: &NewKeccak256, + inventory: &mut ChipInventory>, + ) -> Result<(), ChipInventoryError> { + let range_checker = inventory.range_checker()?.clone(); + let timestamp_max_bits = inventory.timestamp_max_bits(); + let mem_helper = SharedMemoryHelper::new(range_checker.clone(), timestamp_max_bits); + let pointer_max_bits = inventory.airs().pointer_max_bits(); + + let bitwise_lu = { + let existing_chip = inventory + .find_chip::>() + .next(); + + if let Some(chip) = existing_chip { + chip.clone() + } else { + let air: &BitwiseOperationLookupAir<8> = inventory.next_air()?; + let chip = Arc::new(BitwiseOperationLookupChip::new(air.bus)); + inventory.add_periphery_chip(chip.clone()); + chip + } + }; + + inventory.next_air::()?; + let xorin_chip = XorinVmChip::new( + XorinVmFiller::new(bitwise_lu.clone(), pointer_max_bits), + mem_helper.clone(), + ); + inventory.add_executor_chip(xorin_chip); + + inventory.next_air::()?; + let keccak_chip = KeccakfVmChip::new( + KeccakfVmFiller::new(bitwise_lu, pointer_max_bits), + mem_helper.clone(), + ); + inventory.add_executor_chip(keccak_chip); + + Ok(()) + } +} diff --git a/extensions/new-keccak256/circuit/src/keccakf/air.rs b/extensions/new-keccak256/circuit/src/keccakf/air.rs new file mode 100644 index 0000000000..38e4822c0a --- /dev/null +++ b/extensions/new-keccak256/circuit/src/keccakf/air.rs @@ -0,0 +1,316 @@ +use std::borrow::Borrow; + +use openvm_circuit::{ + arch::{ExecutionBridge, ExecutionState}, + system::memory::{ + offline_checker::{MemoryBridge, MemoryReadAuxCols, MemoryWriteAuxCols}, + MemoryAddress, + }, +}; +use openvm_circuit_primitives::{bitwise_op_lookup::BitwiseOperationLookupBus, utils::not}; +use openvm_instructions::riscv::{ + RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS, +}; +use openvm_new_keccak256_transpiler::KeccakfOpcode; +use openvm_stark_backend::{ + air_builders::sub::SubAirBuilder, + interaction::InteractionBuilder, + p3_air::{Air, AirBuilder, BaseAir}, + p3_field::FieldAlgebra, + p3_matrix::Matrix, + rap::{BaseAirWithPublicValues, PartitionedBaseAir}, +}; +use p3_keccak_air::{KeccakAir, NUM_ROUNDS, U64_LIMBS}; + +use crate::keccakf::columns::{KeccakfVmCols, NUM_KECCAKF_VM_COLS, NUM_KECCAK_PERM_COLS}; + +#[derive(Clone, Copy, Debug, derive_new::new)] +pub struct KeccakfVmAir { + pub execution_bridge: ExecutionBridge, + pub memory_bridge: MemoryBridge, + pub bitwise_lookup_bus: BitwiseOperationLookupBus, + pub ptr_max_bits: usize, + pub(super) offset: usize, +} + +impl BaseAirWithPublicValues for KeccakfVmAir {} +impl PartitionedBaseAir for KeccakfVmAir {} +impl BaseAir for KeccakfVmAir { + fn width(&self) -> usize { + NUM_KECCAKF_VM_COLS + } +} + +impl Air for KeccakfVmAir { + fn eval(&self, builder: &mut AB) { + let main = builder.main(); + + let (local, next) = (main.row_slice(0), main.row_slice(1)); + let local: &KeccakfVmCols<_> = (*local).borrow(); + let next: &KeccakfVmCols<_> = (*next).borrow(); + + let mut timestamp: AB::Expr = local.timestamp.into(); + let mem_oc = &local.mem_oc; + + // only active during the first round in each instruction + self.eval_instruction(builder, local, &mut timestamp, &mem_oc.register_aux_cols); + // only active during the first round in each instruction + self.constrain_input_read( + builder, + local, + &mut timestamp, + &mem_oc.buffer_bytes_read_aux_cols, + ); + + let keccak_f_air = KeccakAir {}; + let mut sub_builder = + SubAirBuilder::::new(builder, 0..NUM_KECCAK_PERM_COLS); + keccak_f_air.eval(&mut sub_builder); + + // only active during the last round in each instruction + self.constrain_output_write( + builder, + local, + &mut timestamp, + &mem_oc.buffer_bytes_write_aux_cols, + ); + + self.constrain_rounds_transition(builder, local, next, timestamp); + } +} + +impl KeccakfVmAir { + #[inline] + pub fn eval_instruction( + &self, + builder: &mut AB, + local: &KeccakfVmCols, + start_timestamp: &mut AB::Expr, + register_aux: &[MemoryReadAuxCols; 1], + ) { + let instruction = local.instruction; + let is_enabled = instruction.is_enabled; + builder.assert_bool(is_enabled); + let is_first_round = local.inner.step_flags[0]; + let is_final_round = local.inner.step_flags[NUM_ROUNDS - 1]; + let is_enabled_is_first_round = is_enabled * is_first_round; + let is_enabled_is_final_round = is_enabled * is_final_round; + builder.assert_eq(is_enabled_is_first_round, is_first_round * is_enabled); + builder.assert_eq(is_enabled_is_final_round, is_final_round * is_enabled); + + let rd_ptr = instruction.rd_ptr; + let buffer_ptr_limbs = instruction.buffer_ptr_limbs.map(Into::into); + // 50 buffer reads and 50 buffer writes and 1 register read + let timestamp_change = + local.is_enabled_is_first_round * AB::F::from_canonical_u32(1 + 50 + 50); + + // safety: it is safe to use timestamp instead of storing a separate + // instruction.start_timestamp because the execution_bridge interaction is only + // enabled in the first row, so timestamp = start_timestamp since there is no more + // timestamp increments + self.execution_bridge + .execute_and_increment_pc( + AB::Expr::from_canonical_usize(KeccakfOpcode::KECCAKF as usize + self.offset), + [ + rd_ptr.into(), + AB::Expr::ZERO, + AB::Expr::ZERO, + AB::Expr::from_canonical_u32(RV32_REGISTER_AS), + AB::Expr::from_canonical_u32(RV32_MEMORY_AS), + ], + ExecutionState::new(instruction.pc, local.timestamp), + timestamp_change, + ) + .eval(builder, local.is_enabled_is_first_round); + + self.memory_bridge + .read( + MemoryAddress::new(AB::Expr::from_canonical_u32(RV32_REGISTER_AS), rd_ptr), + buffer_ptr_limbs, + start_timestamp.clone(), + ®ister_aux[0], + ) + .eval(builder, local.is_enabled_is_first_round); + *start_timestamp += local.is_enabled_is_first_round.into(); + + builder.assert_eq( + instruction.buffer_ptr, + instruction.buffer_ptr_limbs[0] + + instruction.buffer_ptr_limbs[1] * AB::F::from_canonical_u32(1 << 8) + + instruction.buffer_ptr_limbs[2] * AB::F::from_canonical_u32(1 << 16) + + instruction.buffer_ptr_limbs[3] * AB::F::from_canonical_u32(1 << 24), + ); + + let limb_shift = AB::F::from_canonical_usize( + 1 << (RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - self.ptr_max_bits), + ); + let need_range_check = [ + *instruction.buffer_ptr_limbs.last().unwrap(), + *instruction.buffer_ptr_limbs.last().unwrap(), + ]; + for pair in need_range_check.chunks_exact(2) { + self.bitwise_lookup_bus + .send_range(pair[0] * limb_shift, pair[1] * limb_shift) + .eval(builder, local.is_enabled_is_first_round); + } + } + + #[inline] + pub fn constrain_input_read( + &self, + builder: &mut AB, + local: &KeccakfVmCols, + start_timestamp: &mut AB::Expr, + buffer_bytes_read_aux_cols: &[MemoryReadAuxCols; 200 / 4], + ) { + const PREIMAGE_BYTES: usize = 25 * U64_LIMBS * 2; + let local_preimage_bytes: [AB::Expr; PREIMAGE_BYTES] = std::array::from_fn(|byte_idx| { + // `preimage` is represented as 5 * 5 * U64_LIMBS u16 limbs; each u16 limb is split into + // 2 bytes. + let u16_idx = byte_idx / 2; + let is_hi_byte = (byte_idx % 2) == 1; + + let i = u16_idx / U64_LIMBS; + let limb = u16_idx % U64_LIMBS; + + let y = i / 5; + let x = i % 5; + + let state_limb: AB::Expr = local.inner.preimage[y][x][limb].into(); + let hi: AB::Expr = local.preimage_state_hi[i * U64_LIMBS + limb].into(); + let lo: AB::Expr = state_limb.clone() - hi.clone() * AB::F::from_canonical_u64(1 << 8); + + builder.assert_eq( + state_limb, + lo.clone() + hi.clone() * AB::F::from_canonical_u64(1 << 8), + ); + + if is_hi_byte { + hi + } else { + lo + } + }); + + for idx in 0..(PREIMAGE_BYTES / 4) { + let read_chunk: [AB::Expr; 4] = + std::array::from_fn(|j| local_preimage_bytes[4 * idx + j].clone()); + + let ptr = local.instruction.buffer_ptr + AB::Expr::from_canonical_usize(idx * 4); + + self.memory_bridge + .read( + MemoryAddress::new(AB::Expr::from_canonical_u32(RV32_MEMORY_AS), ptr), + read_chunk, + start_timestamp.clone(), + &buffer_bytes_read_aux_cols[idx], + ) + .eval(builder, local.is_enabled_is_first_round); + + *start_timestamp += local.is_enabled_is_first_round.into(); + } + } + + #[inline] + pub fn constrain_output_write( + &self, + builder: &mut AB, + local: &KeccakfVmCols, + start_timestamp: &mut AB::Expr, + buffer_bytes_write_aux_cols: &[MemoryWriteAuxCols; 200 / 4], + ) { + const POSTIMAGE_BYTES: usize = 25 * 4 * 2; + let local_postimage_bytes: [AB::Expr; POSTIMAGE_BYTES] = std::array::from_fn(|byte_idx| { + // `preimage` is represented as 5 * 5 * U64_LIMBS u16 limbs; each u16 limb is split into + // 2 bytes. + let u16_idx = byte_idx / 2; + let is_hi_byte = (byte_idx % 2) == 1; + + let i = u16_idx / U64_LIMBS; + let limb = u16_idx % U64_LIMBS; + let y = i / 5; + let x = i % 5; + + let state_limb: AB::Expr = local.inner.a_prime_prime_prime(y, x, limb).into(); + let hi: AB::Expr = local.postimage_state_hi[i * U64_LIMBS + limb].into(); + let lo: AB::Expr = state_limb.clone() - hi.clone() * AB::F::from_canonical_u64(1 << 8); + + builder.assert_eq( + state_limb, + lo.clone() + hi.clone() * AB::F::from_canonical_u64(1 << 8), + ); + + if is_hi_byte { + hi + } else { + lo + } + }); + + for idx in 0..(200 / 4) { + let write_chunk: [AB::Expr; 4] = + std::array::from_fn(|j| local_postimage_bytes[4 * idx + j].clone()); + + let ptr = local.instruction.buffer_ptr + AB::Expr::from_canonical_usize(idx * 4); + + self.memory_bridge + .write( + MemoryAddress::new(AB::Expr::from_canonical_u32(RV32_MEMORY_AS), ptr), + write_chunk, + start_timestamp.clone(), + &buffer_bytes_write_aux_cols[idx], + ) + .eval(builder, local.is_enabled_is_final_round); + + *start_timestamp += local.is_enabled_is_final_round.into(); + } + } + + // responsible for constraining everything that needs to be constrained between rows in the same + // instruction but different keccakf rounds + #[inline] + pub fn constrain_rounds_transition( + &self, + builder: &mut AB, + local: &KeccakfVmCols, + next: &KeccakfVmCols, + timestamp: AB::Expr, + ) { + let is_final_round = local.inner.step_flags[NUM_ROUNDS - 1]; + let is_enabled = local.instruction.is_enabled; + let need_check = is_enabled * not(is_final_round); + + for idx in 0..100 { + builder + .when(need_check.clone()) + .assert_eq(local.preimage_state_hi[idx], next.preimage_state_hi[idx]); + builder + .when(need_check.clone()) + .assert_eq(local.postimage_state_hi[idx], next.postimage_state_hi[idx]); + } + builder + .when(need_check.clone()) + .assert_eq(local.instruction.pc, next.instruction.pc); + builder + .when(need_check.clone()) + .assert_eq(local.instruction.is_enabled, next.instruction.is_enabled); + builder + .when(need_check.clone()) + .assert_eq(local.instruction.rd_ptr, next.instruction.rd_ptr); + builder + .when(need_check.clone()) + .assert_eq(local.instruction.buffer_ptr, next.instruction.buffer_ptr); + for limb in 0..4 { + builder.when(need_check.clone()).assert_eq( + local.instruction.buffer_ptr_limbs[limb], + next.instruction.buffer_ptr_limbs[limb], + ); + } + // safety: mem_oc does not need to be checked here because in the rows which is not first or + // last it is not used and in the first or last rows, the mem_oc fields which is + // used is already constraiend by the interactions + builder + .when(need_check.clone()) + .assert_eq(timestamp, next.timestamp); + } +} diff --git a/extensions/new-keccak256/circuit/src/keccakf/columns.rs b/extensions/new-keccak256/circuit/src/keccakf/columns.rs new file mode 100644 index 0000000000..8a0e21941c --- /dev/null +++ b/extensions/new-keccak256/circuit/src/keccakf/columns.rs @@ -0,0 +1,42 @@ +use openvm_circuit::system::memory::offline_checker::{MemoryReadAuxCols, MemoryWriteAuxCols}; +use openvm_circuit_primitives_derive::AlignedBorrow; +use openvm_instructions::riscv::RV32_REGISTER_NUM_LIMBS; +use p3_keccak_air::KeccakCols as KeccakPermCols; + +use crate::{keccakf::utils::KECCAK_WIDTH_BYTES, xorin::utils::KECCAK_WORD_SIZE}; + +#[repr(C)] +#[derive(Debug, AlignedBorrow)] +pub struct KeccakfVmCols { + pub inner: KeccakPermCols, + pub preimage_state_hi: [T; KECCAK_WIDTH_BYTES / 2], + pub postimage_state_hi: [T; KECCAK_WIDTH_BYTES / 2], + pub instruction: KeccakfInstructionCols, + pub mem_oc: KeccakfMemoryCols, + pub timestamp: T, + pub is_enabled_is_first_round: T, + pub is_enabled_is_final_round: T, +} + +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, AlignedBorrow, derive_new::new)] +pub struct KeccakfInstructionCols { + pub pc: T, + pub is_enabled: T, + pub rd_ptr: T, + pub buffer_ptr: T, + pub buffer_ptr_limbs: [T; RV32_REGISTER_NUM_LIMBS], +} + +#[repr(C)] +#[derive(Clone, Debug, AlignedBorrow)] +pub struct KeccakfMemoryCols { + pub register_aux_cols: [MemoryReadAuxCols; 1], + pub buffer_bytes_read_aux_cols: [MemoryReadAuxCols; KECCAK_WIDTH_BYTES / KECCAK_WORD_SIZE], + pub buffer_bytes_write_aux_cols: + [MemoryWriteAuxCols; KECCAK_WIDTH_BYTES / KECCAK_WORD_SIZE], +} + +pub const NUM_KECCAKF_VM_COLS: usize = size_of::>(); +pub const NUM_KECCAK_PERM_COLS: usize = size_of::>(); +pub const NUM_ROUNDS: usize = 24; diff --git a/extensions/new-keccak256/circuit/src/keccakf/execution.rs b/extensions/new-keccak256/circuit/src/keccakf/execution.rs new file mode 100644 index 0000000000..16dacc692d --- /dev/null +++ b/extensions/new-keccak256/circuit/src/keccakf/execution.rs @@ -0,0 +1,220 @@ +use std::{ + borrow::{Borrow, BorrowMut}, + convert::TryInto, + mem::size_of, +}; + +use openvm_circuit::{ + arch::{StaticProgramError, *}, + system::memory::online::GuestMemory, +}; +use openvm_circuit_primitives_derive::AlignedBytesBorrow; +use openvm_instructions::{ + instruction::Instruction, + program::DEFAULT_PC_STEP, + riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, +}; +use openvm_stark_backend::p3_field::PrimeField32; +use p3_keccak_air::NUM_ROUNDS; + +use super::KeccakfVmExecutor; +use crate::keccakf::utils::{ + KECCAK_WIDTH_BYTES, KECCAK_WIDTH_U32_LIMBS, KECCAK_WIDTH_U64_LIMBS, KECCAK_WORD_SIZE, +}; + +#[derive(AlignedBytesBorrow, Clone)] +#[repr(C)] +struct KeccakfPreCompute { + a: u8, +} + +impl KeccakfVmExecutor { + fn pre_compute_impl( + &self, + pc: u32, + inst: &Instruction, + data: &mut KeccakfPreCompute, + ) -> Result<(), StaticProgramError> { + let Instruction { + opcode: _, + a, + b: _, + c: _, + d, + e, + .. + } = inst; + + let e_u32 = e.as_canonical_u32(); + if d.as_canonical_u32() != RV32_REGISTER_AS || e_u32 != RV32_MEMORY_AS { + return Err(StaticProgramError::InvalidInstruction(pc)); + } + + *data = KeccakfPreCompute { + a: a.as_canonical_u32() as u8, + }; + + Ok(()) + } +} + +impl InterpreterExecutor for KeccakfVmExecutor { + fn pre_compute_size(&self) -> usize { + size_of::() + } + + #[cfg(not(feature = "tco"))] + fn pre_compute( + &self, + pc: u32, + inst: &Instruction, + data: &mut [u8], + ) -> Result, StaticProgramError> + where + Ctx: ExecutionCtxTrait, + { + let data: &mut KeccakfPreCompute = data.borrow_mut(); + self.pre_compute_impl(pc, inst, data)?; + Ok(execute_e1_impl::<_, _>) + } + + #[cfg(feature = "tco")] + fn handler( + &self, + pc: u32, + inst: &Instruction, + data: &mut [u8], + ) -> Result, StaticProgramError> + where + Ctx: ExecutionCtxTrait, + { + let data: &mut KeccakfPreCompute = data.borrow_mut(); + self.pre_compute_impl(pc, inst, data)?; + Ok(execute_e1_handler) + } +} + +#[cfg(feature = "aot")] +impl AotExecutor for KeccakfVmExecutor {} + +impl InterpreterMeteredExecutor for KeccakfVmExecutor { + fn metered_pre_compute_size(&self) -> usize { + size_of::() + } + + #[cfg(not(feature = "tco"))] + fn metered_pre_compute( + &self, + chip_idx: usize, + pc: u32, + inst: &Instruction, + data: &mut [u8], + ) -> Result, StaticProgramError> + where + Ctx: MeteredExecutionCtxTrait, + { + let data: &mut E2PreCompute = data.borrow_mut(); + data.chip_idx = chip_idx as u32; + self.pre_compute_impl(pc, inst, &mut data.data)?; + Ok(execute_e2_impl::<_, _>) + } + + #[cfg(feature = "tco")] + fn metered_handler( + &self, + chip_idx: usize, + pc: u32, + inst: &Instruction, + data: &mut [u8], + ) -> Result, StaticProgramError> + where + Ctx: MeteredExecutionCtxTrait, + { + let data: &mut E2PreCompute = data.borrow_mut(); + data.chip_idx = chip_idx as u32; + self.pre_compute_impl(pc, inst, &mut data.data)?; + Ok(execute_e2_handler) + } +} + +#[cfg(feature = "aot")] +impl AotMeteredExecutor for KeccakfVmExecutor {} + +#[create_handler] +#[inline(always)] +unsafe fn execute_e1_impl( + pre_compute: *const u8, + exec_state: &mut VmExecState, +) { + let pre_compute: &KeccakfPreCompute = + std::slice::from_raw_parts(pre_compute, size_of::()).borrow(); + execute_e12_impl::(pre_compute, exec_state); +} + +#[inline(always)] +unsafe fn execute_e12_impl( + pre_compute: &KeccakfPreCompute, + exec_state: &mut VmExecState, +) { + use tiny_keccak::keccakf; + + // the variable naming might be misleading + // buf_ptr is the pointer to the register which holds the actual pointer to the buffer + let buf_ptr = pre_compute.a as u32; + let buffer_limbs: [u8; 4] = exec_state.vm_read(RV32_REGISTER_AS, buf_ptr); + let buffer = u32::from_le_bytes(buffer_limbs); + + let message_vec: Option> = if IS_E1 { + None + } else { + Some( + (0..KECCAK_WIDTH_U32_LIMBS) + .flat_map(|i| { + exec_state.vm_read::( + RV32_MEMORY_AS, + buffer + (i * KECCAK_WORD_SIZE) as u32, + ) + }) + .collect(), + ) + }; + + let message: &[u8] = match message_vec.as_deref() { + Some(v) => &v[..KECCAK_WIDTH_BYTES], + None => exec_state.vm_read_slice(RV32_MEMORY_AS, buffer, KECCAK_WIDTH_BYTES), + }; + assert_eq!(message.len(), KECCAK_WIDTH_BYTES); + + let mut message_u64 = [0u64; KECCAK_WIDTH_U64_LIMBS]; + for (i, message_chunk) in message.chunks_exact(8).enumerate() { + let message_chunk_u64 = u64::from_le_bytes(message_chunk.try_into().unwrap()); + message_u64[i] = message_chunk_u64; + } + keccakf(&mut message_u64); + + let mut result: [u8; KECCAK_WIDTH_BYTES] = [0; KECCAK_WIDTH_BYTES]; + for (i, message) in message_u64.into_iter().enumerate() { + let message_bytes = message.to_be_bytes(); + result[8 * i..8 * i + 8].copy_from_slice(&message_bytes); + } + + exec_state.vm_write(RV32_MEMORY_AS, buffer, &result); + + let pc = exec_state.pc(); + exec_state.set_pc(pc.wrapping_add(DEFAULT_PC_STEP)); +} + +#[create_handler] +#[inline(always)] +unsafe fn execute_e2_impl( + pre_compute: *const u8, + exec_state: &mut VmExecState, +) { + let pre_compute: &E2PreCompute = + std::slice::from_raw_parts(pre_compute, size_of::>()) + .borrow(); + exec_state + .ctx + .on_height_change(pre_compute.chip_idx as usize, NUM_ROUNDS as u32); + execute_e12_impl::(&pre_compute.data, exec_state); +} diff --git a/extensions/new-keccak256/circuit/src/keccakf/mod.rs b/extensions/new-keccak256/circuit/src/keccakf/mod.rs new file mode 100644 index 0000000000..a722f429ea --- /dev/null +++ b/extensions/new-keccak256/circuit/src/keccakf/mod.rs @@ -0,0 +1,24 @@ +pub mod air; +pub mod columns; +pub mod execution; +#[cfg(test)] +pub mod tests; +pub mod trace; +pub mod utils; + +use openvm_circuit::arch::VmChipWrapper; +use openvm_circuit_primitives::bitwise_op_lookup::SharedBitwiseOperationLookupChip; + +#[derive(derive_new::new, Clone, Copy)] +pub struct KeccakfVmExecutor { + pub offset: usize, + pub pointer_max_bits: usize, +} + +#[derive(derive_new::new)] +pub struct KeccakfVmFiller { + pub bitwise_lookup_chip: SharedBitwiseOperationLookupChip<8>, + pub pointer_max_bits: usize, +} + +pub type KeccakfVmChip = VmChipWrapper; diff --git a/extensions/new-keccak256/circuit/src/keccakf/tests.rs b/extensions/new-keccak256/circuit/src/keccakf/tests.rs new file mode 100644 index 0000000000..a3b41f91a1 --- /dev/null +++ b/extensions/new-keccak256/circuit/src/keccakf/tests.rs @@ -0,0 +1,149 @@ +use std::sync::Arc; + +use openvm_circuit::{ + arch::{ + testing::{TestBuilder, TestChipHarness, VmChipTestBuilder, BITWISE_OP_LOOKUP_BUS}, + Arena, ExecutionBridge, PreflightExecutor, + }, + system::memory::{offline_checker::MemoryBridge, SharedMemoryHelper}, + utils::get_random_message, +}; +use openvm_circuit_primitives::bitwise_op_lookup::{ + BitwiseOperationLookupAir, BitwiseOperationLookupBus, BitwiseOperationLookupChip, + SharedBitwiseOperationLookupChip, +}; +use openvm_instructions::{instruction::Instruction, riscv::RV32_CELL_BITS, LocalOpcode}; +use openvm_new_keccak256_transpiler::KeccakfOpcode; +use openvm_stark_backend::p3_field::FieldAlgebra; +use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng}; +use rand::rngs::StdRng; + +use super::KeccakfVmFiller; +use crate::keccakf::air::KeccakfVmAir; + +type F = BabyBear; +type Harness = TestChipHarness>; + +use crate::keccakf::{KeccakfVmChip, KeccakfVmExecutor}; + +fn create_harness_fields( + execution_bridge: ExecutionBridge, + memory_bridge: MemoryBridge, + bitwise_chip: Arc>, + memory_helper: SharedMemoryHelper, + address_bits: usize, +) -> (KeccakfVmAir, KeccakfVmExecutor, KeccakfVmChip) { + let air = KeccakfVmAir::new( + execution_bridge, + memory_bridge, + bitwise_chip.bus(), + address_bits, + KeccakfOpcode::CLASS_OFFSET, + ); + + let executor = KeccakfVmExecutor::new(KeccakfOpcode::CLASS_OFFSET, address_bits); + let chip = KeccakfVmChip::new( + KeccakfVmFiller::new(bitwise_chip, address_bits), + memory_helper, + ); + (air, executor, chip) +} + +fn create_test_harness( + tester: &mut VmChipTestBuilder, +) -> ( + Harness, + ( + BitwiseOperationLookupAir, + SharedBitwiseOperationLookupChip, + ), +) { + let bitwise_bus = BitwiseOperationLookupBus::new(BITWISE_OP_LOOKUP_BUS); + let bitwise_chip = Arc::new(BitwiseOperationLookupChip::::new( + bitwise_bus, + )); + + let (air, executor, chip) = create_harness_fields( + tester.execution_bridge(), + tester.memory_bridge(), + bitwise_chip.clone(), + tester.memory_helper(), + tester.address_bits(), + ); + + const MAX_TRACE_ROWS: usize = 4096; + + let harness = Harness::with_capacity(executor, air, chip, MAX_TRACE_ROWS); + + (harness, (bitwise_chip.air, bitwise_chip)) +} + +fn set_and_execute>( + tester: &mut impl TestBuilder, + executor: &mut E, + arena: &mut RA, + rng: &mut StdRng, + opcode: KeccakfOpcode, +) { + const MAX_LEN: usize = 200; + let rand_buffer = get_random_message(rng, MAX_LEN); + let mut rand_buffer_arr = [0u8; MAX_LEN]; + rand_buffer_arr.copy_from_slice(&rand_buffer); + + use openvm_circuit::arch::testing::memory::gen_pointer; + let rd = gen_pointer(rng, 4); + let buffer_ptr = gen_pointer(rng, MAX_LEN); + tester.write(1, rd, buffer_ptr.to_le_bytes().map(F::from_canonical_u8)); + let rand_buffer_arr_f = rand_buffer_arr.map(F::from_canonical_u8); + + for i in 0..(MAX_LEN / 4) { + let buffer_chunk: [F; 4] = rand_buffer_arr_f[4 * i..4 * i + 4] + .try_into() + .expect("slice has length 4"); + tester.write(2, buffer_ptr + 4 * i, buffer_chunk); + } + + // Safety note: If you would like to increase this further, make sure to count if it will + // exceed the MAX_TRACE_ROWS of the test harness configs or not + // currently it does not because 100 * 24 < 4096 + for _ in 0..100 { + tester.execute( + executor, + arena, + &Instruction::from_usize(opcode.global_opcode(), [rd, 0, 0, 1, 2]), + ); + } + + let mut output_buffer = [F::from_canonical_u8(0); MAX_LEN]; + + for i in 0..(MAX_LEN / 4) { + let output_chunk: [F; 4] = tester.read(2, buffer_ptr + 4 * i); + output_buffer[4 * i..4 * i + 4].copy_from_slice(&output_chunk); + } +} + +#[test] +fn keccakf_chip_positive_tests() { + let num_ops: usize = 10; + + for _ in 0..num_ops { + let mut rng = create_seeded_rng(); + let mut tester = VmChipTestBuilder::default(); + let (mut harness, bitwise) = create_test_harness(&mut tester); + + set_and_execute( + &mut tester, + &mut harness.executor, + &mut harness.arena, + &mut rng, + KeccakfOpcode::KECCAKF, + ); + + let tester = tester + .build() + .load(harness) + .load_periphery(bitwise) + .finalize(); + tester.simple_test().expect("Verification failed"); + } +} diff --git a/extensions/new-keccak256/circuit/src/keccakf/trace.rs b/extensions/new-keccak256/circuit/src/keccakf/trace.rs new file mode 100644 index 0000000000..43390ec9d9 --- /dev/null +++ b/extensions/new-keccak256/circuit/src/keccakf/trace.rs @@ -0,0 +1,351 @@ +use core::convert::TryInto; +use std::{borrow::BorrowMut, mem::size_of}; + +use openvm_circuit::{ + arch::*, + system::memory::{ + offline_checker::{MemoryReadAuxRecord, MemoryWriteBytesAuxRecord}, + online::TracingMemory, + MemoryAuxColsFactory, + }, +}; +use openvm_circuit_primitives::AlignedBytesBorrow; +use openvm_instructions::{ + instruction::Instruction, + program::DEFAULT_PC_STEP, + riscv::{RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS}, +}; +use openvm_new_keccak256_transpiler::KeccakfOpcode; +use openvm_rv32im_circuit::adapters::{tracing_read, tracing_write}; +use openvm_stark_backend::{p3_field::PrimeField32, p3_matrix::dense::RowMajorMatrix}; +use p3_keccak_air::generate_trace_rows; + +use crate::keccakf::{ + columns::{KeccakfVmCols, NUM_KECCAKF_VM_COLS, NUM_KECCAK_PERM_COLS, NUM_ROUNDS}, + utils::{KECCAK_WIDTH_BYTES, KECCAK_WIDTH_U32_LIMBS, KECCAK_WIDTH_U64_LIMBS}, + KeccakfVmExecutor, KeccakfVmFiller, +}; + +#[derive(Clone, Copy)] +pub struct KeccakfVmMetadata {} + +impl MultiRowMetadata for KeccakfVmMetadata { + fn get_num_rows(&self) -> usize { + NUM_ROUNDS + } +} + +pub(crate) type KeccakfVmRecordLayout = MultiRowLayout; + +#[repr(C)] +#[derive(AlignedBytesBorrow, Debug, Clone)] +pub struct KeccakfVmRecordHeader { + pub pc: u32, + pub timestamp: u32, + pub buffer: u32, + pub preimage_buffer_bytes: [u8; 200], + pub rd_ptr: u32, + pub register_aux_cols: [MemoryReadAuxRecord; 1], + pub buffer_read_aux_cols: [MemoryReadAuxRecord; 200 / 4], + pub buffer_write_aux_cols: [MemoryWriteBytesAuxRecord<4>; 200 / 4], +} + +pub struct KeccakfVmRecordMut<'a> { + pub inner: &'a mut KeccakfVmRecordHeader, +} + +impl<'a> CustomBorrow<'a, KeccakfVmRecordMut<'a>, KeccakfVmRecordLayout> for [u8] { + fn custom_borrow(&'a mut self, _layout: KeccakfVmRecordLayout) -> KeccakfVmRecordMut<'a> { + let (record_buf, _rest) = + unsafe { self.split_at_mut_unchecked(size_of::()) }; + KeccakfVmRecordMut { + inner: record_buf.borrow_mut(), + } + } + + unsafe fn extract_layout(&self) -> KeccakfVmRecordLayout { + KeccakfVmRecordLayout { + metadata: KeccakfVmMetadata {}, + } + } +} + +// todo: check with Ayush if this is correct +impl SizedRecord for KeccakfVmRecordMut<'_> { + fn size(_layout: &KeccakfVmRecordLayout) -> usize { + size_of::() + } + + fn alignment(_layout: &KeccakfVmRecordLayout) -> usize { + align_of::() + } +} + +impl PreflightExecutor for KeccakfVmExecutor +where + F: PrimeField32, + for<'buf> RA: RecordArena<'buf, KeccakfVmRecordLayout, KeccakfVmRecordMut<'buf>>, +{ + fn get_opcode_name(&self, _: usize) -> String { + format!("{:?}", KeccakfOpcode::KECCAKF) + } + + fn execute( + &self, + state: VmStateMut, + instruction: &Instruction, + ) -> Result<(), ExecutionError> { + let &Instruction { a, .. } = instruction; + + let record = state + .ctx + .alloc(KeccakfVmRecordLayout::new(KeccakfVmMetadata {})); + + record.inner.pc = *state.pc; + record.inner.timestamp = state.memory.timestamp(); + record.inner.rd_ptr = a.as_canonical_u32(); + record.inner.buffer = u32::from_le_bytes(tracing_read( + state.memory, + RV32_REGISTER_AS, + a.as_canonical_u32(), + &mut record.inner.register_aux_cols[0].prev_timestamp, + )); + + for idx in 0..KECCAK_WIDTH_U32_LIMBS { + let read = tracing_read::<4>( + state.memory, + RV32_MEMORY_AS, + record.inner.buffer + (idx * 4) as u32, + &mut record.inner.buffer_read_aux_cols[idx].prev_timestamp, + ); + + record.inner.preimage_buffer_bytes[4 * idx..4 * (idx + 1)].copy_from_slice(&read); + } + + let preimage_buffer_bytes = record.inner.preimage_buffer_bytes; + let mut preimage_buffer_bytes_u64: [u64; KECCAK_WIDTH_U64_LIMBS] = + [0; KECCAK_WIDTH_U64_LIMBS]; + + for idx in 0..KECCAK_WIDTH_U64_LIMBS { + preimage_buffer_bytes_u64[idx] = u64::from_le_bytes( + preimage_buffer_bytes[8 * idx..8 * idx + 8] + .try_into() + .unwrap(), + ); + } + + tiny_keccak::keccakf(&mut preimage_buffer_bytes_u64); + + // result is placed in preimage_buffer_bytes_u64 + // convert back to blocks of u8's + let mut result_u8: [u8; KECCAK_WIDTH_BYTES] = [0; KECCAK_WIDTH_BYTES]; + for idx in 0..KECCAK_WIDTH_U64_LIMBS { + let chunk: [u8; 8] = preimage_buffer_bytes_u64[idx].to_le_bytes(); + result_u8[8 * idx..8 * idx + 8].copy_from_slice(&chunk); + } + + for idx in 0..KECCAK_WIDTH_U32_LIMBS { + let chunk: [u8; 4] = result_u8[4 * idx..4 * idx + 4].try_into().unwrap(); + tracing_write( + state.memory, + RV32_MEMORY_AS, + record.inner.buffer + (idx * 4) as u32, + chunk, + &mut record.inner.buffer_write_aux_cols[idx].prev_timestamp, + &mut record.inner.buffer_write_aux_cols[idx].prev_data, + ); + } + + *state.pc = state.pc.wrapping_add(DEFAULT_PC_STEP); + Ok(()) + } +} + +impl TraceFiller for KeccakfVmFiller { + fn fill_trace( + &self, + mem_helper: &MemoryAuxColsFactory, + trace_matrix: &mut RowMajorMatrix, + rows_used: usize, + ) { + if rows_used == 0 { + return; + } + + let (trace, dummy_trace) = trace_matrix + .values + .split_at_mut(rows_used * NUM_KECCAKF_VM_COLS); + + let p3_dummy_trace: RowMajorMatrix = + generate_trace_rows(vec![[0u64; KECCAK_WIDTH_U64_LIMBS]; 1], 0); + + dummy_trace + // Each Keccak-f round corresponds to exactly one trace row of width + // NUM_KECCAKF_VM_COLS. We already reserved NUM_ROUNDS rows above + // (NUM_ROUNDS * NUM_KECCAKF_VM_COLS elements). + .chunks_exact_mut(NUM_KECCAKF_VM_COLS) + .enumerate() + .for_each(|(row_idx, row_slice)| { + let idx = row_idx % NUM_ROUNDS; + row_slice[..NUM_KECCAK_PERM_COLS].copy_from_slice( + &p3_dummy_trace.values + [idx * NUM_KECCAK_PERM_COLS..(idx + 1) * NUM_KECCAK_PERM_COLS], + ); + // Need to get rid of the accidental garbage data that might overflow + // the F's prime field. Unfortunately, there + // is no good way around this + // SAFETY: + // - row has exactly NUM_KECCAK_VM_COLS elements + // - NUM_KECCAK_PERM_COLS offset is less than NUM_KECCAK_VM_COLS by design + // - We're zeroing the remaining (NUM_KECCAK_VM_COLS - NUM_KECCAK_PERM_COLS) + // elements to clear any garbage data that might overflow the field + unsafe { + std::ptr::write_bytes( + row_slice.as_mut_ptr().add(NUM_KECCAK_PERM_COLS) as *mut u8, + 0, + (NUM_KECCAKF_VM_COLS - NUM_KECCAK_PERM_COLS) * size_of::(), + ); + } + }); + + trace + // Each Keccak-f round corresponds to exactly one trace row of width + // NUM_KECCAKF_VM_COLS. We already reserved NUM_ROUNDS rows above + // (NUM_ROUNDS * NUM_KECCAKF_VM_COLS elements). + .chunks_exact_mut(NUM_KECCAKF_VM_COLS * NUM_ROUNDS) + .for_each(|mut round_slice| { + // each round takes up one row in the trace matrix + // Safety: the initial prefix of the buffer of size NUM_KECCAKF_VM_COLS * NUM_ROUNDS + // holds the record header + let record: KeccakfVmRecordMut = unsafe { + get_record_from_slice( + &mut round_slice, + KeccakfVmRecordLayout { + metadata: KeccakfVmMetadata {}, + }, + ) + }; + let record = record.inner.clone(); + let mut timestamp = record.timestamp; + + // compute u64 preimage and postimage to not have to recompute per row + let preimage_buffer_bytes = record.preimage_buffer_bytes; + let mut preimage_buffer_bytes_u64: [u64; KECCAK_WIDTH_U64_LIMBS] = + [0; KECCAK_WIDTH_U64_LIMBS]; + for idx in 0..KECCAK_WIDTH_U64_LIMBS { + let le_bytes: [u8; 8] = preimage_buffer_bytes[8 * idx..8 * idx + 8] + .try_into() + .unwrap(); + preimage_buffer_bytes_u64[idx] = u64::from_le_bytes(le_bytes); + } + + let mut preimage_buffer_bytes_u64_transpose: [u64; KECCAK_WIDTH_U64_LIMBS] = + [0; KECCAK_WIDTH_U64_LIMBS]; + for y in 0..5 { + for x in 0..5 { + preimage_buffer_bytes_u64_transpose[x + 5 * y] = + preimage_buffer_bytes_u64[y + 5 * x]; + } + } + + let mut postimage_buffer_bytes_u64 = preimage_buffer_bytes_u64; + tiny_keccak::keccakf(&mut postimage_buffer_bytes_u64); + + let mut postimage_buffer_bytes: [u8; KECCAK_WIDTH_BYTES] = + [0u8; KECCAK_WIDTH_BYTES]; + for idx in 0..KECCAK_WIDTH_U64_LIMBS { + let chunk: [u8; 8] = postimage_buffer_bytes_u64[idx].to_le_bytes(); + postimage_buffer_bytes[8 * idx..8 * idx + 8].copy_from_slice(&chunk); + } + + // fills in inner + // the reason we give the transpose instead is inside, plonky3 transpose the + // input so transpose of transpose fixes it + let p3_trace: RowMajorMatrix = + generate_trace_rows(vec![preimage_buffer_bytes_u64_transpose], 0); + + round_slice + .chunks_exact_mut(NUM_KECCAKF_VM_COLS) + .enumerate() + .for_each(|(row_idx, row)| { + row[..NUM_KECCAK_PERM_COLS].copy_from_slice( + &p3_trace.values[row_idx * NUM_KECCAK_PERM_COLS + ..(row_idx + 1) * NUM_KECCAK_PERM_COLS], + ); + + // fills in preimage_state_hi + let cols: &mut KeccakfVmCols = row.borrow_mut(); + for idx in 0..KECCAK_WIDTH_BYTES / 2 { + cols.preimage_state_hi[idx] = + F::from_canonical_u8(preimage_buffer_bytes[2 * idx + 1]); + } + // fills in postimage_state_hi + for idx in 0..KECCAK_WIDTH_BYTES / 2 { + cols.postimage_state_hi[idx] = + F::from_canonical_u8(postimage_buffer_bytes[2 * idx + 1]); + } + // fills in instruction + cols.instruction.pc = F::from_canonical_u32(record.pc); + cols.instruction.is_enabled = F::ONE; + cols.timestamp = F::from_canonical_u32(timestamp); + cols.instruction.rd_ptr = F::from_canonical_u32(record.rd_ptr); + cols.instruction.buffer_ptr = F::from_canonical_u32(record.buffer); + cols.instruction.buffer_ptr_limbs = + record.buffer.to_le_bytes().map(F::from_canonical_u8); + + let is_first_round = cols.inner.step_flags[0]; + let is_final_round = cols.inner.step_flags[NUM_ROUNDS - 1]; + cols.is_enabled_is_first_round = is_first_round; + cols.is_enabled_is_final_round = is_final_round; + + // fills in memory offline checker + if row_idx == 0 { + mem_helper.fill( + record.register_aux_cols[0].prev_timestamp, + timestamp, + cols.mem_oc.register_aux_cols[0].as_mut(), + ); + timestamp += 1; + for t in 0..KECCAK_WIDTH_U32_LIMBS { + mem_helper.fill( + record.buffer_read_aux_cols[t].prev_timestamp, + timestamp, + cols.mem_oc.buffer_bytes_read_aux_cols[t].as_mut(), + ); + timestamp += 1; + } + + // safety: the following approach only works when self.pointer_max_bits + // >= 24 + let limb_shift = 1 + << (RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS + - self.pointer_max_bits); + let buffer_limbs = record.buffer.to_le_bytes(); + let need_range_check = + [buffer_limbs.last().unwrap(), buffer_limbs.last().unwrap()]; + for pair in need_range_check.chunks_exact(2) { + self.bitwise_lookup_chip.request_range( + (pair[0] * limb_shift) as u32, + (pair[1] * limb_shift) as u32, + ); + } + } + + if row_idx == NUM_ROUNDS - 1 { + for t in 0..KECCAK_WIDTH_U32_LIMBS { + mem_helper.fill( + record.buffer_write_aux_cols[t].prev_timestamp, + timestamp, + cols.mem_oc.buffer_bytes_write_aux_cols[t].as_mut(), + ); + cols.mem_oc.buffer_bytes_write_aux_cols[t].prev_data = record + .buffer_write_aux_cols[t] + .prev_data + .map(F::from_canonical_u8); + timestamp += 1; + } + } + }); + }); + } +} diff --git a/extensions/new-keccak256/circuit/src/keccakf/utils.rs b/extensions/new-keccak256/circuit/src/keccakf/utils.rs new file mode 100644 index 0000000000..2011ea926b --- /dev/null +++ b/extensions/new-keccak256/circuit/src/keccakf/utils.rs @@ -0,0 +1,4 @@ +pub const KECCAK_WIDTH_BYTES: usize = 200; +pub const KECCAK_WIDTH_U32_LIMBS: usize = 50; +pub const KECCAK_WIDTH_U64_LIMBS: usize = 25; +pub const KECCAK_WORD_SIZE: usize = 4; diff --git a/extensions/new-keccak256/circuit/src/lib.rs b/extensions/new-keccak256/circuit/src/lib.rs new file mode 100644 index 0000000000..a51f8c4a8d --- /dev/null +++ b/extensions/new-keccak256/circuit/src/lib.rs @@ -0,0 +1,10 @@ +#![cfg_attr(feature = "tco", allow(incomplete_features))] +#![cfg_attr(feature = "tco", feature(explicit_tail_calls))] +#![cfg_attr(feature = "tco", allow(internal_features))] +#![cfg_attr(feature = "tco", feature(core_intrinsics))] + +mod keccakf; +mod xorin; + +mod extension; +pub use extension::*; diff --git a/extensions/new-keccak256/circuit/src/xorin/air.rs b/extensions/new-keccak256/circuit/src/xorin/air.rs new file mode 100644 index 0000000000..382158b9e1 --- /dev/null +++ b/extensions/new-keccak256/circuit/src/xorin/air.rs @@ -0,0 +1,340 @@ +use std::borrow::Borrow; + +use itertools::izip; +use openvm_circuit::{ + arch::{ExecutionBridge, ExecutionState}, + system::memory::{ + offline_checker::{MemoryBridge, MemoryReadAuxCols, MemoryWriteAuxCols}, + MemoryAddress, + }, +}; +use openvm_circuit_primitives::{bitwise_op_lookup::BitwiseOperationLookupBus, utils::not}; +use openvm_instructions::riscv::{ + RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS, +}; +use openvm_new_keccak256_transpiler::XorinOpcode; +use openvm_stark_backend::{ + interaction::InteractionBuilder, + p3_air::{Air, AirBuilder, BaseAir}, + p3_field::FieldAlgebra, + p3_matrix::Matrix, + rap::{BaseAirWithPublicValues, PartitionedBaseAir}, +}; + +use crate::xorin::columns::{XorinVmCols, NUM_XORIN_VM_COLS}; + +#[derive(Clone, Copy, Debug, derive_new::new)] +pub struct XorinVmAir { + pub execution_bridge: ExecutionBridge, + pub memory_bridge: MemoryBridge, + /// Bus to send 8-bit XOR requests to. + pub bitwise_lookup_bus: BitwiseOperationLookupBus, + /// Maximum number of bits allowed for an address pointer + pub ptr_max_bits: usize, + pub(super) offset: usize, +} + +impl BaseAirWithPublicValues for XorinVmAir {} +impl PartitionedBaseAir for XorinVmAir {} +impl BaseAir for XorinVmAir { + fn width(&self) -> usize { + NUM_XORIN_VM_COLS + } +} + +impl Air for XorinVmAir { + // Increases timestamp by 105 + fn eval(&self, builder: &mut AB) { + let main = builder.main(); + + let local = main.row_slice(0); + let local: &XorinVmCols<_> = (*local).borrow(); + + let mem = &local.mem_oc; + + let start_read_timestamp = self.eval_instruction(builder, local, &mem.register_aux_cols); + + let start_write_timestamp = self.constrain_input_read( + builder, + local, + start_read_timestamp, + &mem.input_bytes_read_aux_cols, + &mem.buffer_bytes_read_aux_cols, + ); + + self.constrain_xor(builder, local); + + self.constrain_output_write( + builder, + local, + start_write_timestamp, + &mem.buffer_bytes_write_aux_cols, + ); + } +} + +impl XorinVmAir { + // Increases timestamp by 3 + #[inline] + pub fn eval_instruction( + &self, + builder: &mut AB, + local: &XorinVmCols, + register_aux: &[MemoryReadAuxCols; 3], + ) -> AB::Expr { + // returns start_read_timestamp + let instruction = local.instruction; + let is_enabled = local.instruction.is_enabled; + builder.assert_bool(is_enabled); + + let [buffer_reg_ptr, input_reg_ptr, len_reg_ptr] = [ + instruction.buffer_reg_ptr, + instruction.input_reg_ptr, + instruction.len_reg_ptr, + ]; + + let mut timestamp_change = AB::Expr::from_canonical_u32(3); + let mut not_padding_sum = AB::Expr::ZERO; + + for is_padding in local.sponge.is_padding_bytes { + timestamp_change += AB::Expr::from_canonical_u32(3) * not(is_padding); + not_padding_sum += not(is_padding); + builder.assert_bool(is_padding); + } + + not_padding_sum *= AB::Expr::from_canonical_u32(4); + builder + .when(is_enabled) + .assert_eq(not_padding_sum, instruction.len); + // check that is_padding_bytes is of the form 0...0111...1 + for i in 0..33 { + builder.when(is_enabled).assert_bool( + local.sponge.is_padding_bytes[i + 1] - local.sponge.is_padding_bytes[i], + ); + } + + self.execution_bridge + .execute_and_increment_pc( + AB::Expr::from_canonical_usize(XorinOpcode::XORIN as usize + self.offset), + [ + buffer_reg_ptr.into(), + input_reg_ptr.into(), + len_reg_ptr.into(), + AB::Expr::from_canonical_u32(RV32_REGISTER_AS), + AB::Expr::from_canonical_u32(RV32_MEMORY_AS), + ], + ExecutionState::new(instruction.pc, instruction.start_timestamp), + timestamp_change, + ) + .eval(builder, is_enabled); + + let mut timestamp: AB::Expr = instruction.start_timestamp.into(); + + let buffer_ptr_limbs = instruction.buffer_ptr_limbs.map(Into::into); + let input_ptr_limbs = instruction.input_ptr_limbs.map(Into::into); + let len_limbs = instruction.len_limbs.map(Into::into); + + // Increases timestamp by 3 + for (ptr, value, aux) in izip!( + [buffer_reg_ptr, input_reg_ptr, len_reg_ptr], + [buffer_ptr_limbs, input_ptr_limbs, len_limbs], + register_aux + ) { + self.memory_bridge + .read( + MemoryAddress::new(AB::Expr::from_canonical_u32(RV32_REGISTER_AS), ptr), + value, + timestamp.clone(), + aux, + ) + .eval(builder, is_enabled); + + timestamp += AB::Expr::ONE; + } + + // SAFETY: this approach only works when self.ptr_max_bits >= 24 + // because we are only range checking the last limb + let need_range_check = [ + *instruction.buffer_ptr_limbs.last().unwrap(), + *instruction.input_ptr_limbs.last().unwrap(), + *instruction.len_limbs.last().unwrap(), + *instruction.len_limbs.last().unwrap(), + ]; + + let limb_shift = AB::F::from_canonical_usize( + 1 << (RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - self.ptr_max_bits), + ); + for pair in need_range_check.chunks_exact(2) { + self.bitwise_lookup_bus + .send_range(pair[0] * limb_shift, pair[1] * limb_shift) + .eval(builder, is_enabled); + } + + builder.assert_eq( + instruction.buffer_ptr, + instruction.buffer_ptr_limbs[0] + + instruction.buffer_ptr_limbs[1] * AB::F::from_canonical_u32(1 << 8) + + instruction.buffer_ptr_limbs[2] * AB::F::from_canonical_u32(1 << 16) + + instruction.buffer_ptr_limbs[3] * AB::F::from_canonical_u32(1 << 24), + ); + + builder.assert_eq( + instruction.input_ptr, + instruction.input_ptr_limbs[0] + + instruction.input_ptr_limbs[1] * AB::F::from_canonical_u32(1 << 8) + + instruction.input_ptr_limbs[2] * AB::F::from_canonical_u32(1 << 16) + + instruction.input_ptr_limbs[3] * AB::F::from_canonical_u32(1 << 24), + ); + + builder.assert_eq( + instruction.len, + instruction.len_limbs[0] + + instruction.len_limbs[1] * AB::F::from_canonical_u32(1 << 8) + + instruction.len_limbs[2] * AB::F::from_canonical_u32(1 << 16) + + instruction.len_limbs[3] * AB::F::from_canonical_u32(1 << 24), + ); + + timestamp + } + + // Increases timestamp by <= 2 * 34 = 68 + #[inline] + pub fn constrain_input_read( + &self, + builder: &mut AB, + local: &XorinVmCols, + start_read_timestamp: AB::Expr, + input_bytes_read_aux_cols: &[MemoryReadAuxCols; 34], + buffer_bytes_read_aux_cols: &[MemoryReadAuxCols; 34], + ) -> AB::Expr { + let is_enabled = local.instruction.is_enabled; + let mut timestamp = start_read_timestamp; + + // Constrain read of buffer bytes + // Timestamp increases by <= (136/4) = 34 + for (i, (input, is_padding, mem_aux)) in izip!( + local.sponge.preimage_buffer_bytes.chunks_exact(4), + local.sponge.is_padding_bytes, + buffer_bytes_read_aux_cols + ) + .enumerate() + { + let ptr = local.instruction.buffer_ptr + AB::F::from_canonical_usize(i * 4); + let should_read = is_enabled * not(is_padding); + + self.memory_bridge + .read( + MemoryAddress::new(AB::Expr::from_canonical_u32(RV32_MEMORY_AS), ptr), + [ + input[0].into(), + input[1].into(), + input[2].into(), + input[3].into(), + ], + timestamp.clone(), + mem_aux, + ) + .eval(builder, should_read); + + timestamp += not(is_padding); + } + + // Constrain read of input_bytes + // Timestamp increases by at most (136/4) = 34 + for (i, (input, is_padding, mem_aux)) in izip!( + local.sponge.input_bytes.chunks_exact(4), + local.sponge.is_padding_bytes, + input_bytes_read_aux_cols + ) + .enumerate() + { + let ptr = local.instruction.input_ptr + AB::F::from_canonical_usize(i * 4); + let should_read = is_enabled * not(is_padding); + + self.memory_bridge + .read( + MemoryAddress::new(AB::Expr::from_canonical_u32(RV32_MEMORY_AS), ptr), + [ + input[0].into(), + input[1].into(), + input[2].into(), + input[3].into(), + ], + timestamp.clone(), + mem_aux, + ) + .eval(builder, should_read); + + timestamp += not(is_padding); + } + + timestamp + } + + #[inline] + pub fn constrain_xor( + &self, + builder: &mut AB, + local: &XorinVmCols, + ) { + let buffer_bytes = local.sponge.preimage_buffer_bytes; + let input_bytes = local.sponge.input_bytes; + let result_bytes = local.sponge.postimage_buffer_bytes; + let padding_bytes = local.sponge.is_padding_bytes; + let is_enabled = local.instruction.is_enabled; + + for (x_chunks, y_chunks, x_xor_y_chunks, is_padding) in izip!( + buffer_bytes.chunks_exact(4), + input_bytes.chunks_exact(4), + result_bytes.chunks_exact(4), + padding_bytes + ) { + let should_send = is_enabled * not(is_padding); + for (x, y, x_xor_y) in izip!(x_chunks, y_chunks, x_xor_y_chunks) { + self.bitwise_lookup_bus + .send_xor(*x, *y, *x_xor_y) + .eval(builder, should_send.clone()); + } + } + } + + #[inline] + pub fn constrain_output_write( + &self, + builder: &mut AB, + local: &XorinVmCols, + start_write_timestamp: AB::Expr, + mem_aux: &[MemoryWriteAuxCols; 34], + ) { + let mut timestamp = start_write_timestamp; + let is_enabled = local.instruction.is_enabled; + + // Constrain write of buffer bytes + for (i, (output, is_padding, mem_aux)) in izip!( + local.sponge.postimage_buffer_bytes.chunks_exact(4), + local.sponge.is_padding_bytes, + mem_aux + ) + .enumerate() + { + let should_write = is_enabled * not(is_padding); + let ptr = local.instruction.buffer_ptr + AB::F::from_canonical_usize(i * 4); + + self.memory_bridge + .write( + MemoryAddress::new(AB::Expr::from_canonical_u32(RV32_MEMORY_AS), ptr), + [ + output[0].into(), + output[1].into(), + output[2].into(), + output[3].into(), + ], + timestamp.clone(), + mem_aux, + ) + .eval(builder, should_write); + + timestamp += not(is_padding); + } + } +} diff --git a/extensions/new-keccak256/circuit/src/xorin/columns.rs b/extensions/new-keccak256/circuit/src/xorin/columns.rs new file mode 100644 index 0000000000..3de3fc6f9d --- /dev/null +++ b/extensions/new-keccak256/circuit/src/xorin/columns.rs @@ -0,0 +1,55 @@ +use openvm_circuit::system::memory::offline_checker::{MemoryReadAuxCols, MemoryWriteAuxCols}; +use openvm_circuit_primitives_derive::AlignedBorrow; +use openvm_instructions::riscv::RV32_REGISTER_NUM_LIMBS; + +use crate::xorin::utils::{KECCAK_RATE_BYTES, KECCAK_WORD_SIZE}; + +#[repr(C)] +#[derive(Debug, AlignedBorrow)] +pub struct XorinVmCols { + pub sponge: XorinSpongeCols, + pub instruction: XorinInstructionCols, + pub mem_oc: XorinMemoryCols, +} + +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, AlignedBorrow, derive_new::new)] +#[allow(clippy::too_many_arguments)] +pub struct XorinInstructionCols { + pub pc: T, + pub is_enabled: T, + pub buffer_reg_ptr: T, + pub input_reg_ptr: T, + pub len_reg_ptr: T, + pub buffer_ptr: T, + pub buffer_ptr_limbs: [T; RV32_REGISTER_NUM_LIMBS], + pub input_ptr: T, + pub input_ptr_limbs: [T; RV32_REGISTER_NUM_LIMBS], + pub len: T, + pub len_limbs: [T; RV32_REGISTER_NUM_LIMBS], + pub start_timestamp: T, +} + +#[repr(C)] +#[derive(Copy, Clone, Debug, AlignedBorrow)] +pub struct XorinSpongeCols { + // is_padding_bytes is a boolean where is_padding_bytes[i] = 1 if 4*(i+1) >= len + // and is_padding_bytes[i] = 0 otherwise + // safety: notice that each 4 bytes has to have equal is_padding_bytes value + pub is_padding_bytes: [T; KECCAK_RATE_BYTES / KECCAK_WORD_SIZE], + pub preimage_buffer_bytes: [T; KECCAK_RATE_BYTES], + pub input_bytes: [T; KECCAK_RATE_BYTES], + pub postimage_buffer_bytes: [T; KECCAK_RATE_BYTES], +} + +#[repr(C)] +#[derive(Clone, Debug, AlignedBorrow)] +pub struct XorinMemoryCols { + pub register_aux_cols: [MemoryReadAuxCols; 3], + pub input_bytes_read_aux_cols: [MemoryReadAuxCols; KECCAK_RATE_BYTES / KECCAK_WORD_SIZE], + pub buffer_bytes_read_aux_cols: [MemoryReadAuxCols; KECCAK_RATE_BYTES / KECCAK_WORD_SIZE], + pub buffer_bytes_write_aux_cols: + [MemoryWriteAuxCols; KECCAK_RATE_BYTES / KECCAK_WORD_SIZE], +} + +pub const NUM_XORIN_VM_COLS: usize = size_of::>(); diff --git a/extensions/new-keccak256/circuit/src/xorin/execution.rs b/extensions/new-keccak256/circuit/src/xorin/execution.rs new file mode 100644 index 0000000000..0616969621 --- /dev/null +++ b/extensions/new-keccak256/circuit/src/xorin/execution.rs @@ -0,0 +1,220 @@ +use std::{ + borrow::{Borrow, BorrowMut}, + convert::TryInto, + mem::size_of, +}; + +use openvm_circuit::{ + arch::{StaticProgramError, *}, + system::memory::online::GuestMemory, +}; +use openvm_circuit_primitives_derive::AlignedBytesBorrow; +use openvm_instructions::{ + instruction::Instruction, + program::DEFAULT_PC_STEP, + riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, +}; +use openvm_stark_backend::p3_field::PrimeField32; + +use super::{XorinVmExecutor, KECCAK_WORD_SIZE}; + +#[derive(AlignedBytesBorrow, Clone)] +#[repr(C)] +struct XorinPreCompute { + a: u8, + b: u8, + c: u8, +} + +impl XorinVmExecutor { + fn pre_compute_impl( + &self, + pc: u32, + inst: &Instruction, + data: &mut XorinPreCompute, + ) -> Result<(), StaticProgramError> { + let Instruction { + opcode: _, + a, + b, + c, + d, + e, + .. + } = inst; + + let e_u32 = e.as_canonical_u32(); + if d.as_canonical_u32() != RV32_REGISTER_AS || e_u32 != RV32_MEMORY_AS { + return Err(StaticProgramError::InvalidInstruction(pc)); + } + + *data = XorinPreCompute { + a: a.as_canonical_u32() as u8, + b: b.as_canonical_u32() as u8, + c: c.as_canonical_u32() as u8, + }; + + Ok(()) + } +} + +impl InterpreterExecutor for XorinVmExecutor { + fn pre_compute_size(&self) -> usize { + size_of::() + } + + #[cfg(not(feature = "tco"))] + fn pre_compute( + &self, + pc: u32, + inst: &Instruction, + data: &mut [u8], + ) -> Result, StaticProgramError> + where + Ctx: ExecutionCtxTrait, + { + let data: &mut XorinPreCompute = data.borrow_mut(); + self.pre_compute_impl(pc, inst, data)?; + Ok(execute_e1_impl::<_, _>) + } + + #[cfg(feature = "tco")] + fn handler( + &self, + pc: u32, + inst: &Instruction, + data: &mut [u8], + ) -> Result, StaticProgramError> + where + Ctx: ExecutionCtxTrait, + { + let data: &mut XorinPreCompute = data.borrow_mut(); + self.pre_compute_impl(pc, inst, data)?; + Ok(execute_e1_handler) + } +} + +#[cfg(feature = "aot")] +impl AotExecutor for XorinVmExecutor {} + +impl InterpreterMeteredExecutor for XorinVmExecutor { + fn metered_pre_compute_size(&self) -> usize { + size_of::() + } + + #[cfg(not(feature = "tco"))] + fn metered_pre_compute( + &self, + chip_idx: usize, + pc: u32, + inst: &Instruction, + data: &mut [u8], + ) -> Result, StaticProgramError> + where + Ctx: MeteredExecutionCtxTrait, + { + let data: &mut E2PreCompute = data.borrow_mut(); + data.chip_idx = chip_idx as u32; + self.pre_compute_impl(pc, inst, &mut data.data)?; + Ok(execute_e2_impl::<_, _>) + } + + #[cfg(feature = "tco")] + fn metered_handler( + &self, + chip_idx: usize, + pc: u32, + inst: &Instruction, + data: &mut [u8], + ) -> Result, StaticProgramError> + where + Ctx: MeteredExecutionCtxTrait, + { + let data: &mut E2PreCompute = data.borrow_mut(); + data.chip_idx = chip_idx as u32; + self.pre_compute_impl(pc, inst, &mut data.data)?; + Ok(execute_e2_handler) + } +} + +#[cfg(feature = "aot")] +impl AotMeteredExecutor for XorinVmExecutor {} + +#[create_handler] +#[inline(always)] +unsafe fn execute_e1_impl( + pre_compute: *const u8, + exec_state: &mut VmExecState, +) { + let pre_compute: &XorinPreCompute = + std::slice::from_raw_parts(pre_compute, size_of::()).borrow(); + execute_e12_impl::(pre_compute, exec_state); +} + +#[inline(always)] +unsafe fn execute_e12_impl( + pre_compute: &XorinPreCompute, + exec_state: &mut VmExecState, +) { + let buffer = exec_state.vm_read(RV32_REGISTER_AS, pre_compute.a as u32); + let input = exec_state.vm_read(RV32_REGISTER_AS, pre_compute.b as u32); + let length = exec_state.vm_read(RV32_REGISTER_AS, pre_compute.c as u32); + let buffer_u32 = u32::from_le_bytes(buffer); + let input_u32 = u32::from_le_bytes(input); + let length_u32 = u32::from_le_bytes(length); + + // SAFETY: RV32_MEMORY_AS is memory address space of type u8 + let num_reads = (length_u32 as usize).div_ceil(KECCAK_WORD_SIZE); + let buffer_bytes: Vec<_> = (0..num_reads) + .flat_map(|i| { + exec_state.vm_read::( + RV32_MEMORY_AS, + buffer_u32 + (i * KECCAK_WORD_SIZE) as u32, + ) + }) + .collect(); + + let input_bytes: Vec<_> = (0..num_reads) + .flat_map(|i| { + exec_state.vm_read::( + RV32_MEMORY_AS, + input_u32 + (i * KECCAK_WORD_SIZE) as u32, + ) + }) + .collect(); + + let mut output_bytes = buffer_bytes; + for i in 0..output_bytes.len() { + output_bytes[i] ^= input_bytes[i]; + } + + // Write XOR result back to the buffer memory in KECCAK_WORD_SIZE chunks. + // Note: this means output_bytes has to be multiple of KECCAK_WORD_SIZE + // Todo: recheck the above condition is okay + for (i, chunk) in output_bytes.chunks_exact(KECCAK_WORD_SIZE).enumerate() { + let chunk: [u8; KECCAK_WORD_SIZE] = chunk.try_into().unwrap(); + exec_state.vm_write::( + RV32_MEMORY_AS, + buffer_u32 + (i * KECCAK_WORD_SIZE) as u32, + &chunk, + ); + } + + let pc = exec_state.pc(); + exec_state.set_pc(pc.wrapping_add(DEFAULT_PC_STEP)); +} + +#[create_handler] +#[inline(always)] +unsafe fn execute_e2_impl( + pre_compute: *const u8, + exec_state: &mut VmExecState, +) { + let pre_compute: &E2PreCompute = + std::slice::from_raw_parts(pre_compute, size_of::>()) + .borrow(); + execute_e12_impl::(&pre_compute.data, exec_state); + exec_state + .ctx + .on_height_change(pre_compute.chip_idx as usize, 1); +} diff --git a/extensions/new-keccak256/circuit/src/xorin/mod.rs b/extensions/new-keccak256/circuit/src/xorin/mod.rs new file mode 100644 index 0000000000..ac26faecdb --- /dev/null +++ b/extensions/new-keccak256/circuit/src/xorin/mod.rs @@ -0,0 +1,27 @@ +pub mod air; +pub mod columns; +pub mod execution; +#[cfg(test)] +pub mod tests; +pub mod trace; +pub mod utils; + +use openvm_circuit::arch::VmChipWrapper; +use openvm_circuit_primitives::bitwise_op_lookup::SharedBitwiseOperationLookupChip; + +const KECCAK_WORD_SIZE: usize = 4; + +#[derive(derive_new::new, Clone, Copy)] +pub struct XorinVmExecutor { + pub offset: usize, + pub pointer_max_bits: usize, +} + +#[derive(derive_new::new)] +// number of bits = 8 +pub struct XorinVmFiller { + pub bitwise_lookup_chip: SharedBitwiseOperationLookupChip<8>, + pub pointer_max_bits: usize, +} + +pub type XorinVmChip = VmChipWrapper; diff --git a/extensions/new-keccak256/circuit/src/xorin/tests.rs b/extensions/new-keccak256/circuit/src/xorin/tests.rs new file mode 100644 index 0000000000..30f4907185 --- /dev/null +++ b/extensions/new-keccak256/circuit/src/xorin/tests.rs @@ -0,0 +1,251 @@ +use std::sync::Arc; + +use openvm_circuit::{ + arch::{ + testing::{TestBuilder, TestChipHarness, VmChipTestBuilder, BITWISE_OP_LOOKUP_BUS}, + Arena, ExecutionBridge, PreflightExecutor, + }, + system::memory::{offline_checker::MemoryBridge, SharedMemoryHelper}, + utils::get_random_message, +}; +use openvm_circuit_primitives::bitwise_op_lookup::{ + BitwiseOperationLookupAir, BitwiseOperationLookupBus, BitwiseOperationLookupChip, + SharedBitwiseOperationLookupChip, +}; +use openvm_instructions::{instruction::Instruction, riscv::RV32_CELL_BITS, LocalOpcode}; +use openvm_new_keccak256_transpiler::XorinOpcode; +use openvm_stark_backend::p3_field::FieldAlgebra; +use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng}; +use rand::{rngs::StdRng, Rng}; + +use crate::xorin::{air::XorinVmAir, XorinVmChip, XorinVmExecutor, XorinVmFiller}; + +type F = BabyBear; +type Harness = TestChipHarness>; + +fn create_harness_fields( + execution_bridge: ExecutionBridge, + memory_bridge: MemoryBridge, + bitwise_chip: Arc>, + memory_helper: SharedMemoryHelper, + address_bits: usize, +) -> (XorinVmAir, XorinVmExecutor, XorinVmChip) { + let air = XorinVmAir::new( + execution_bridge, + memory_bridge, + bitwise_chip.bus(), + address_bits, + XorinOpcode::CLASS_OFFSET, + ); + + let executor = XorinVmExecutor::new(XorinOpcode::CLASS_OFFSET, address_bits); + let chip = XorinVmChip::new( + XorinVmFiller::new(bitwise_chip, address_bits), + memory_helper, + ); + (air, executor, chip) +} + +fn create_test_harness( + tester: &mut VmChipTestBuilder, +) -> ( + Harness, + ( + BitwiseOperationLookupAir, + SharedBitwiseOperationLookupChip, + ), +) { + let bitwise_bus = BitwiseOperationLookupBus::new(BITWISE_OP_LOOKUP_BUS); + let bitwise_chip = Arc::new(BitwiseOperationLookupChip::::new( + bitwise_bus, + )); + + let (air, executor, chip) = create_harness_fields( + tester.execution_bridge(), + tester.memory_bridge(), + bitwise_chip.clone(), + tester.memory_helper(), + tester.address_bits(), + ); + + const MAX_TRACE_ROWS: usize = 4096; + + let harness = Harness::with_capacity(executor, air, chip, MAX_TRACE_ROWS); + + (harness, (bitwise_chip.air, bitwise_chip)) +} + +fn set_and_execute>( + tester: &mut impl TestBuilder, + executor: &mut E, + arena: &mut RA, + rng: &mut StdRng, + opcode: XorinOpcode, + buffer_length: Option, +) { + const MAX_LEN: usize = 136; + + let buffer_length = match buffer_length { + Some(length) => length, + None => MAX_LEN, + }; + + assert!(buffer_length.is_multiple_of(4)); + + let rand_buffer = get_random_message(rng, MAX_LEN); + let mut rand_buffer_arr = [0u8; MAX_LEN]; + rand_buffer_arr.copy_from_slice(&rand_buffer); + + let rand_input = get_random_message(rng, MAX_LEN); + let mut rand_input_arr = [0u8; MAX_LEN]; + rand_input_arr.copy_from_slice(&rand_input); + + use openvm_circuit::arch::testing::memory::gen_pointer; + let rd = gen_pointer(rng, 4); + let rs1 = gen_pointer(rng, 4); + let rs2 = gen_pointer(rng, 4); + + let buffer_ptr = gen_pointer(rng, buffer_length); + let input_ptr = gen_pointer(rng, buffer_length); + + let rand_buffer_arr_f = rand_buffer_arr.map(F::from_canonical_u8); + let rand_input_arr_f = rand_input_arr.map(F::from_canonical_u8); + + for i in 0..(buffer_length / 4) { + let buffer_chunk: [F; 4] = rand_buffer_arr_f[4 * i..4 * i + 4] + .try_into() + .expect("slice has length 4"); + tester.write(2, buffer_ptr + 4 * i, buffer_chunk); + + let input_chunk: [F; 4] = rand_input_arr_f[4 * i..4 * i + 4] + .try_into() + .expect("slice has length 4"); + tester.write(2, input_ptr + 4 * i, input_chunk); + } + + tester.write(1, rd, buffer_ptr.to_le_bytes().map(F::from_canonical_u8)); + tester.write(1, rs1, input_ptr.to_le_bytes().map(F::from_canonical_u8)); + tester.write( + 1, + rs2, + buffer_length.to_le_bytes().map(F::from_canonical_u8), + ); + tester.execute( + executor, + arena, + &Instruction::from_usize(opcode.global_opcode(), [rd, rs1, rs2, 1, 2]), + ); + + let mut expected_output = [0u8; MAX_LEN]; + for i in 0..buffer_length { + expected_output[i] = rand_buffer_arr[i] ^ rand_input_arr[i]; + } + + let mut output_buffer = [F::from_canonical_u8(0); MAX_LEN]; + + for i in 0..(buffer_length / 4) { + let output_chunk: [F; 4] = tester.read(2, buffer_ptr + 4 * i); + output_buffer[4 * i..4 * i + 4].copy_from_slice(&output_chunk); + } + + for i in 0..buffer_length { + assert_eq!(F::from_canonical_u8(expected_output[i]), output_buffer[i]); + } +} + +#[test] +fn xorin_chip_positive_tests() { + let num_ops: usize = 100; + + for _ in 0..num_ops { + let mut rng = create_seeded_rng(); + let mut tester = VmChipTestBuilder::default(); + let (mut harness, bitwise) = create_test_harness(&mut tester); + + let buffer_length = Some(rng.gen_range(1..=34) * 4); + + set_and_execute( + &mut tester, + &mut harness.executor, + &mut harness.arena, + &mut rng, + XorinOpcode::XORIN, + buffer_length, + ); + + let tester = tester + .build() + .load(harness) + .load_periphery(bitwise) + .finalize(); + tester.simple_test().expect("Verification failed"); + } +} + +// todo: complete the negative test (currently wip) +/* +#[allow(clippy::too_many_arguments)] +fn run_xorin_chip_negative_tests( + prank_sponge: Option>, + prank_instruction: Option>, + prank_mem_oc: Option>, + interaction_error: bool, +) { + let mut rng = create_seeded_rng(); + let mut tester = VmChipTestBuilder::default(); + let (mut harness, bitwise) = create_test_harness(&mut tester); + + let buffer_length = Some(rng.gen_range(1..=34) * 4_usize); + + set_and_execute( + &mut tester, + &mut harness.executor, + &mut harness.arena, + &mut rng, + XorinOpcode::XORIN, + buffer_length, + ); + + use openvm_stark_backend::p3_matrix::dense::DenseMatrix; + let modify_trace = |trace: &mut DenseMatrix| { + use std::borrow::BorrowMut; + + use openvm_stark_backend::p3_matrix::Matrix; + + use crate::xorin::columns::XorinVmCols; + + let mut values = trace.row_slice(0).to_vec(); + let width = XorinVmCols::::width(); + // split_at_mut() to avoid the compiler saying that it is + // unable to determine the size during compile time + let cols: &mut XorinVmCols = values.split_at_mut(width).0.borrow_mut(); + + if let Some(prank_sponge) = prank_sponge { + cols.sponge = prank_sponge; + } + if let Some(prank_instruction) = prank_instruction { + cols.instruction = prank_instruction; + } + if let Some(prank_mem_oc) = prank_mem_oc.clone() { + cols.mem_oc = prank_mem_oc; + } + *trace = RowMajorMatrix::new(values, trace.width()); + }; + + use openvm_stark_backend::utils::disable_debug_builder; + + disable_debug_builder(); + + let tester = tester + .build() + .load_and_prank_trace(harness, modify_trace) + .load_periphery(bitwise) + .finalize(); + + if interaction_error { + tester.simple_test_with_expected_error(VerificationError::ChallengePhaseError); + } else { + tester.simple_test_with_expected_error(VerificationError::OodEvaluationMismatch); + } +} +*/ diff --git a/extensions/new-keccak256/circuit/src/xorin/trace.rs b/extensions/new-keccak256/circuit/src/xorin/trace.rs new file mode 100644 index 0000000000..80bc6beea4 --- /dev/null +++ b/extensions/new-keccak256/circuit/src/xorin/trace.rs @@ -0,0 +1,341 @@ +use std::{ + borrow::BorrowMut, + mem::{align_of, size_of}, +}; + +use openvm_circuit::{ + arch::*, + system::memory::{ + offline_checker::{MemoryReadAuxRecord, MemoryWriteBytesAuxRecord}, + online::TracingMemory, + MemoryAuxColsFactory, + }, +}; +use openvm_circuit_primitives::AlignedBytesBorrow; +use openvm_instructions::{instruction::Instruction, riscv::RV32_REGISTER_NUM_LIMBS}; +use openvm_new_keccak256_transpiler::XorinOpcode; +use openvm_rv32im_circuit::adapters::{read_rv32_register, tracing_read, tracing_write}; +use openvm_stark_backend::p3_field::PrimeField32; + +use crate::xorin::{ + columns::XorinVmCols, + trace::instructions::{ + program::DEFAULT_PC_STEP, + riscv::{RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS}, + }, + XorinVmExecutor, XorinVmFiller, +}; + +#[derive(Clone, Copy)] +pub struct XorinVmMetadata {} + +impl MultiRowMetadata for XorinVmMetadata { + fn get_num_rows(&self) -> usize { + 1 + } +} + +pub(crate) type XorinVmRecordLayout = MultiRowLayout; + +#[repr(C)] +#[derive(AlignedBytesBorrow, Debug, Clone)] +pub struct XorinVmRecordHeader { + pub from_pc: u32, + pub timestamp: u32, + pub rd_ptr: u32, + pub rs1_ptr: u32, + pub rs2_ptr: u32, + pub buffer: u32, + pub input: u32, + pub len: u32, + pub buffer_limbs: [u8; 136], + pub input_limbs: [u8; 136], + pub register_aux_cols: [MemoryReadAuxRecord; 3], + pub input_read_aux_cols: [MemoryReadAuxRecord; 34], + pub buffer_read_aux_cols: [MemoryReadAuxRecord; 34], + pub buffer_write_aux_cols: [MemoryWriteBytesAuxRecord<4>; 34], +} + +pub struct XorinVmRecordMut<'a> { + pub inner: &'a mut XorinVmRecordHeader, +} + +// Custom borrowing to split the buffer into a fixed `XorinVmRecord` header +impl<'a> CustomBorrow<'a, XorinVmRecordMut<'a>, XorinVmRecordLayout> for [u8] { + fn custom_borrow(&'a mut self, _layout: XorinVmRecordLayout) -> XorinVmRecordMut<'a> { + let (record_buf, _rest) = + unsafe { self.split_at_mut_unchecked(size_of::()) }; + XorinVmRecordMut { + inner: record_buf.borrow_mut(), + } + } + + unsafe fn extract_layout(&self) -> XorinVmRecordLayout { + XorinVmRecordLayout { + metadata: XorinVmMetadata {}, + } + } +} + +impl SizedRecord for XorinVmRecordMut<'_> { + fn size(_layout: &XorinVmRecordLayout) -> usize { + size_of::() + } + + fn alignment(_layout: &XorinVmRecordLayout) -> usize { + align_of::() + } +} + +impl PreflightExecutor for XorinVmExecutor +where + F: PrimeField32, + for<'buf> RA: RecordArena<'buf, XorinVmRecordLayout, XorinVmRecordMut<'buf>>, +{ + fn get_opcode_name(&self, _: usize) -> String { + format!("{:?}", XorinOpcode::XORIN) + } + + fn execute( + &self, + state: VmStateMut, + instruction: &Instruction, + ) -> Result<(), ExecutionError> { + let &Instruction { a, b, c, .. } = instruction; + + // Reading the length first without tracing to allocate a record of correct size + let guest_mem = state.memory.data(); + let len = read_rv32_register(guest_mem, c.as_canonical_u32()) as usize; + // Safety: length has to be multiple of 4 + // This is enforced by how the guest program calls the xorin opcode + // Xorin opcode is only called through the keccak update guest program + debug_assert!(len.is_multiple_of(4)); + let num_reads = len.div_ceil(4); + + // safety: the below alloc uses MultiRowLayout alloc implementation because + // XorinVmRecordLayout is a MultiRowLayout since get_num_rows() = 1, this will + // alloc_buffer of size width where width is the width of the trace matrix + // then it takes a prefix of this allocated buffer through custom borrow + // of length XorinVmRecordLayout size and return it as the below `record` + let record = state + .ctx + .alloc(XorinVmRecordLayout::new(XorinVmMetadata {})); + + record.inner.from_pc = *state.pc; + record.inner.timestamp = state.memory.timestamp(); + record.inner.rd_ptr = a.as_canonical_u32(); + record.inner.rs1_ptr = b.as_canonical_u32(); + record.inner.rs2_ptr = c.as_canonical_u32(); + + record.inner.buffer = u32::from_le_bytes(tracing_read( + state.memory, + RV32_REGISTER_AS, + record.inner.rd_ptr, + &mut record.inner.register_aux_cols[0].prev_timestamp, + )); + + record.inner.input = u32::from_le_bytes(tracing_read( + state.memory, + RV32_REGISTER_AS, + record.inner.rs1_ptr, + &mut record.inner.register_aux_cols[1].prev_timestamp, + )); + + record.inner.len = u32::from_le_bytes(tracing_read( + state.memory, + RV32_REGISTER_AS, + record.inner.rs2_ptr, + &mut record.inner.register_aux_cols[2].prev_timestamp, + )); + + debug_assert!(record.inner.buffer as usize + len <= (1 << self.pointer_max_bits)); + debug_assert!(record.inner.input as usize + len < (1 << self.pointer_max_bits)); + debug_assert!(record.inner.len < (1 << self.pointer_max_bits)); + + // read buffer + for idx in 0..num_reads { + let read = tracing_read::<4>( + state.memory, + RV32_MEMORY_AS, + record.inner.buffer + (idx * 4) as u32, + &mut record.inner.buffer_read_aux_cols[idx].prev_timestamp, + ); + record.inner.buffer_limbs[4 * idx..4 * (idx + 1)].copy_from_slice(&read); + } + + // read input + for idx in 0..num_reads { + let read = tracing_read::<4>( + state.memory, + RV32_MEMORY_AS, + record.inner.input + (idx * 4) as u32, + &mut record.inner.input_read_aux_cols[idx].prev_timestamp, + ); + record.inner.input_limbs[4 * idx..4 * (idx + 1)].copy_from_slice(&read); + } + + let mut result = [0u8; 136]; + + // execute xorin + for ((x_xor_y, &x), &y) in result + .iter_mut() + .zip(record.inner.buffer_limbs.iter()) + .zip(record.inner.input_limbs.iter()) + { + *x_xor_y = x ^ y; + } + + // write result + for idx in 0..num_reads { + let mut word: [u8; 4] = [0u8; 4]; + word.copy_from_slice(&result[4 * idx..4 * (idx + 1)]); + tracing_write( + state.memory, + RV32_MEMORY_AS, + record.inner.buffer + (idx * 4) as u32, + word, + &mut record.inner.buffer_write_aux_cols[idx].prev_timestamp, + &mut record.inner.buffer_write_aux_cols[idx].prev_data, + ); + } + + *state.pc = state.pc.wrapping_add(DEFAULT_PC_STEP); + + Ok(()) + } +} + +impl TraceFiller for XorinVmFiller { + fn fill_trace_row(&self, mem_helper: &MemoryAuxColsFactory, mut row_slice: &mut [F]) { + let record: XorinVmRecordMut = unsafe { + get_record_from_slice( + &mut row_slice, + XorinVmRecordLayout { + metadata: XorinVmMetadata {}, + }, + ) + }; + + // Safety: the clone here is necessary because the XorinVmCols uses the same buffer + let record = record.inner.clone(); + row_slice.fill(F::ZERO); + let trace_row: &mut XorinVmCols = row_slice.borrow_mut(); + + trace_row.instruction.pc = F::from_canonical_u32(record.from_pc); + trace_row.instruction.is_enabled = F::ONE; + trace_row.instruction.buffer_reg_ptr = F::from_canonical_u32(record.rd_ptr); + trace_row.instruction.input_reg_ptr = F::from_canonical_u32(record.rs1_ptr); + trace_row.instruction.len_reg_ptr = F::from_canonical_u32(record.rs2_ptr); + trace_row.instruction.buffer_ptr = F::from_canonical_u32(record.buffer); + let buffer_ptr_u8: [u8; 4] = record.buffer.to_le_bytes(); + let buffer_ptr_limbs: [F; 4] = [ + F::from_canonical_u8(buffer_ptr_u8[0]), + F::from_canonical_u8(buffer_ptr_u8[1]), + F::from_canonical_u8(buffer_ptr_u8[2]), + F::from_canonical_u8(buffer_ptr_u8[3]), + ]; + trace_row.instruction.buffer_ptr_limbs = buffer_ptr_limbs; + trace_row.instruction.input_ptr = F::from_canonical_u32(record.input); + let input_ptr_u8: [u8; 4] = record.input.to_le_bytes(); + let input_ptr_limbs: [F; 4] = [ + F::from_canonical_u8(input_ptr_u8[0]), + F::from_canonical_u8(input_ptr_u8[1]), + F::from_canonical_u8(input_ptr_u8[2]), + F::from_canonical_u8(input_ptr_u8[3]), + ]; + trace_row.instruction.input_ptr_limbs = input_ptr_limbs; + trace_row.instruction.len = F::from_canonical_u32(record.len); + let len_u8: [u8; 4] = record.len.to_le_bytes(); + let len_limbs: [F; 4] = [ + F::from_canonical_u8(len_u8[0]), + F::from_canonical_u8(len_u8[1]), + F::from_canonical_u8(len_u8[2]), + F::from_canonical_u8(len_u8[3]), + ]; + trace_row.instruction.len_limbs = len_limbs; + trace_row.instruction.start_timestamp = F::from_canonical_u32(record.timestamp); + + for i in 0..(record.len / 4) { + trace_row.sponge.is_padding_bytes[i as usize] = F::ZERO; + } + for i in (record.len / 4)..34 { + trace_row.sponge.is_padding_bytes[i as usize] = F::ONE; + } + + let mut timestamp = record.timestamp; + let record_len: usize = record.len as usize; + let num_reads: usize = record_len.div_ceil(4); + + for t in 0..3 { + mem_helper.fill( + record.register_aux_cols[t].prev_timestamp, + timestamp, + trace_row.mem_oc.register_aux_cols[t].as_mut(), + ); + + timestamp += 1; + } + + for t in 0..num_reads { + mem_helper.fill( + record.buffer_read_aux_cols[t].prev_timestamp, + timestamp, + trace_row.mem_oc.buffer_bytes_read_aux_cols[t].as_mut(), + ); + timestamp += 1; + } + + for t in 0..num_reads { + mem_helper.fill( + record.input_read_aux_cols[t].prev_timestamp, + timestamp, + trace_row.mem_oc.input_bytes_read_aux_cols[t].as_mut(), + ); + timestamp += 1; + } + + // safety note: we leave the upper record_len..134 bytes with zeroes + // because they are just padding bytes and unused by the chip + for i in 0..record_len { + trace_row.sponge.preimage_buffer_bytes[i] = + F::from_canonical_u8(record.buffer_limbs[i]); + trace_row.sponge.input_bytes[i] = F::from_canonical_u8(record.input_limbs[i]); + trace_row.sponge.postimage_buffer_bytes[i] = + F::from_canonical_u8(record.buffer_limbs[i] ^ record.input_limbs[i]); + let b_val = record.buffer_limbs[i] as u32; + let c_val = record.input_limbs[i] as u32; + self.bitwise_lookup_chip.request_xor(b_val, c_val); + } + + for t in 0..num_reads { + mem_helper.fill( + record.buffer_write_aux_cols[t].prev_timestamp, + timestamp, + trace_row.mem_oc.buffer_bytes_write_aux_cols[t].as_mut(), + ); + trace_row.mem_oc.buffer_bytes_write_aux_cols[t].prev_data = record + .buffer_write_aux_cols[t] + .prev_data + .map(F::from_canonical_u8); + timestamp += 1; + } + + let buffer_ptr_limbs = record.buffer.to_le_bytes(); + let input_ptr_limbs = record.input.to_le_bytes(); + let len_limbs = record.len.to_le_bytes(); + + let need_range_check = [ + buffer_ptr_limbs.last().unwrap(), + input_ptr_limbs.last().unwrap(), + len_limbs.last().unwrap(), + len_limbs.last().unwrap(), + ]; + + let limb_shift = 1 << (RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - self.pointer_max_bits); + + for pair in need_range_check.chunks_exact(2) { + self.bitwise_lookup_chip + .request_range((pair[0] * limb_shift) as u32, (pair[1] * limb_shift) as u32); + } + } +} diff --git a/extensions/new-keccak256/circuit/src/xorin/utils.rs b/extensions/new-keccak256/circuit/src/xorin/utils.rs new file mode 100644 index 0000000000..b452f97ff5 --- /dev/null +++ b/extensions/new-keccak256/circuit/src/xorin/utils.rs @@ -0,0 +1,2 @@ +pub const KECCAK_RATE_BYTES: usize = 136; +pub const KECCAK_WORD_SIZE: usize = 4; diff --git a/extensions/new-keccak256/guest/Cargo.toml b/extensions/new-keccak256/guest/Cargo.toml new file mode 100644 index 0000000000..9cee7c3d9b --- /dev/null +++ b/extensions/new-keccak256/guest/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "openvm-new-keccak256-guest" +description = "OpenVM guest library for keccak256" +version.workspace = true +authors.workspace = true +edition.workspace = true +homepage.workspace = true +repository.workspace = true + +[dependencies] +openvm-platform = { workspace = true } + +[features] +default = [] diff --git a/extensions/new-keccak256/guest/src/lib.rs b/extensions/new-keccak256/guest/src/lib.rs new file mode 100644 index 0000000000..8f0655dd14 --- /dev/null +++ b/extensions/new-keccak256/guest/src/lib.rs @@ -0,0 +1,86 @@ +#![no_std] + +#[cfg(target_os = "zkvm")] +extern crate alloc; +#[cfg(target_os = "zkvm")] +use openvm_platform::alloc::AlignedBuf; + +pub const OPCODE: u8 = 0x0b; +pub const KECCAKF_FUNCT3: u8 = 0b100; +pub const KECCAKF_FUNCT7: u8 = 0; +pub const XORIN_FUNCT3: u8 = 0b100; +pub const XORIN_FUNCT7: u8 = 1; +pub const KECCAK_WIDTH_BYTES: usize = 200; + +#[cfg(target_os = "zkvm")] +#[inline(always)] +#[no_mangle] +pub extern "C" fn native_xorin(mut buffer: *mut u8, input: *const u8, len: usize) { + const MIN_ALIGN: usize = 4; + unsafe { + if buffer as usize % MIN_ALIGN != 0 { + let aligned_buffer = AlignedBuf::new(buffer, len, MIN_ALIGN); + if input as usize % MIN_ALIGN != 0 { + let aligned_input = AlignedBuf::new(input, len, MIN_ALIGN); + __native_xorin(aligned_buffer.ptr, aligned_input.ptr, len); + core::ptr::copy_nonoverlapping(aligned_buffer.ptr as *const u8, buffer, len); + } else { + __native_xorin(aligned_buffer.ptr, input, len); + core::ptr::copy_nonoverlapping(aligned_buffer.ptr as *const u8, buffer, len); + } + } else { + if input as usize % MIN_ALIGN != 0 { + let aligned_input = AlignedBuf::new(input, len, MIN_ALIGN); + __native_xorin(buffer, aligned_input.ptr, len); + } else { + __native_xorin(buffer, input, len); + } + }; + } +} + +#[cfg(target_os = "zkvm")] +#[inline(always)] +fn __native_xorin(mut buffer: *mut u8, input: *const u8, len: usize) { + openvm_platform::custom_insn_r!( + opcode = OPCODE, + funct3 = XORIN_FUNCT3, + funct7 = XORIN_FUNCT7, + rd = InOut buffer, + rs1 = In input, + rs2 = In len + ); +} + +#[cfg(target_os = "zkvm")] +#[inline(always)] +#[no_mangle] +pub extern "C" fn native_keccakf(mut buffer: *mut u8) { + const MIN_ALIGN: usize = 4; + unsafe { + if buffer as usize % MIN_ALIGN != 0 { + let aligned_buffer = AlignedBuf::new(buffer, KECCAK_WIDTH_BYTES, MIN_ALIGN); + __native_keccakf(aligned_buffer.ptr); + core::ptr::copy_nonoverlapping( + aligned_buffer.ptr as *const u8, + buffer, + KECCAK_WIDTH_BYTES, + ); + } else { + __native_keccakf(buffer); + }; + } +} + +#[cfg(target_os = "zkvm")] +#[inline(always)] +fn __native_keccakf(mut buffer: *mut u8) { + openvm_platform::custom_insn_r!( + opcode = OPCODE, + funct3 = KECCAKF_FUNCT3, + funct7 = KECCAKF_FUNCT7, + rd = InOut buffer, + rs1 = Const "x0", + rs2 = Const "x0", + ); +} diff --git a/extensions/new-keccak256/transpiler/Cargo.toml b/extensions/new-keccak256/transpiler/Cargo.toml new file mode 100644 index 0000000000..6837893c44 --- /dev/null +++ b/extensions/new-keccak256/transpiler/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "openvm-new-keccak256-transpiler" +description = "OpenVM transpiler extension for keccak256" +version.workspace = true +authors.workspace = true +edition.workspace = true +homepage.workspace = true +repository.workspace = true + +[dependencies] +openvm-stark-backend = { workspace = true } +openvm-instructions = { workspace = true } +openvm-transpiler = { workspace = true } +rrs-lib = { workspace = true } +openvm-new-keccak256-guest = { workspace = true } +openvm-instructions-derive = { workspace = true } +strum = { workspace = true } diff --git a/extensions/new-keccak256/transpiler/src/lib.rs b/extensions/new-keccak256/transpiler/src/lib.rs new file mode 100644 index 0000000000..645e82031c --- /dev/null +++ b/extensions/new-keccak256/transpiler/src/lib.rs @@ -0,0 +1,70 @@ +use core::panic; + +use openvm_instructions::{riscv::RV32_MEMORY_AS, LocalOpcode}; +use openvm_instructions_derive::LocalOpcode; +use openvm_new_keccak256_guest::{KECCAKF_FUNCT7, OPCODE, XORIN_FUNCT3, XORIN_FUNCT7}; +use openvm_stark_backend::p3_field::PrimeField32; +use openvm_transpiler::{util::from_r_type, TranspilerExtension, TranspilerOutput}; +use rrs_lib::instruction_formats::RType; +use strum::{EnumCount, EnumIter, FromRepr}; + +#[derive( + Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, EnumCount, EnumIter, FromRepr, LocalOpcode, +)] +#[opcode_offset = 0x310] +#[repr(usize)] +pub enum KeccakfOpcode { + KECCAKF, +} + +#[derive( + Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, EnumCount, EnumIter, FromRepr, LocalOpcode, +)] +#[opcode_offset = 0x311] +#[repr(usize)] +pub enum XorinOpcode { + XORIN, +} + +#[derive(Default)] +pub struct NewKeccakTranspilerExtension; + +impl TranspilerExtension for NewKeccakTranspilerExtension { + fn process_custom(&self, instruction_stream: &[u32]) -> Option> { + if instruction_stream.is_empty() { + return None; + } + let instruction_u32 = instruction_stream[0]; + let opcode = (instruction_u32 & 0x7f) as u8; + let funct3 = ((instruction_u32 >> 12) & 0b111) as u8; + + // Safety note: KECCAKF_FUNCT3 == XORIN_FUNCT3 so it suffices to check once + if (opcode, funct3) != (OPCODE, XORIN_FUNCT3) { + return None; + } + + let dec_insn = RType::new(instruction_u32); + + if dec_insn.funct7 != XORIN_FUNCT7 as u32 && dec_insn.funct7 != KECCAKF_FUNCT7 as u32 { + return None; + } + + let instruction = if dec_insn.funct7 == XORIN_FUNCT7 as u32 { + from_r_type( + XorinOpcode::XORIN.global_opcode().as_usize(), + RV32_MEMORY_AS as usize, + &dec_insn, + true, + ) + } else { + from_r_type( + KeccakfOpcode::KECCAKF.global_opcode().as_usize(), + RV32_MEMORY_AS as usize, + &dec_insn, + true, + ) + }; + + Some(TranspilerOutput::one_to_one(instruction)) + } +} From 4e04ac60c6ca18785ebfb74eb79e4d40d818b651 Mon Sep 17 00:00:00 2001 From: GunaDD Date: Fri, 27 Feb 2026 21:47:40 +0000 Subject: [PATCH 02/78] feat(new-keccak): add xorin cuda tracegen (#2326) Resolves INT-5719 --- .github/workflows/extension-tests.cuda.yml | 4 +- extensions/new-keccak256/circuit/Cargo.toml | 8 + extensions/new-keccak256/circuit/build.rs | 26 +++ .../circuit/cuda/include/xorin/xorin.cuh | 71 +++++++ .../new-keccak256/circuit/cuda/src/xorin.cu | 195 ++++++++++++++++++ .../circuit/src/cuda/cuda_abi.rs | 52 +++++ .../new-keccak256/circuit/src/cuda/mod.rs | 58 ++++++ .../circuit/src/extension/cuda.rs | 84 ++++++++ .../circuit/src/extension/mod.rs | 5 + extensions/new-keccak256/circuit/src/lib.rs | 5 + .../new-keccak256/circuit/src/xorin/tests.rs | 182 +++++++++++++++- 11 files changed, 686 insertions(+), 4 deletions(-) create mode 100644 extensions/new-keccak256/circuit/build.rs create mode 100644 extensions/new-keccak256/circuit/cuda/include/xorin/xorin.cuh create mode 100644 extensions/new-keccak256/circuit/cuda/src/xorin.cu create mode 100644 extensions/new-keccak256/circuit/src/cuda/cuda_abi.rs create mode 100644 extensions/new-keccak256/circuit/src/cuda/mod.rs create mode 100644 extensions/new-keccak256/circuit/src/extension/cuda.rs diff --git a/.github/workflows/extension-tests.cuda.yml b/.github/workflows/extension-tests.cuda.yml index bf90bf1ff6..3993628601 100644 --- a/.github/workflows/extension-tests.cuda.yml +++ b/.github/workflows/extension-tests.cuda.yml @@ -77,7 +77,7 @@ jobs: # Check if any extension in the current matrix group changed ANY_EXT_CHANGED=false for ext in ${{ matrix.extensions }}; do - ext_changed=$(echo $FILTER_OUTPUTS | jq -r .$ext) + ext_changed=$(echo $FILTER_OUTPUTS | jq -r --arg ext "$ext" '.[$ext]') if [[ "$ext_changed" == "true" ]]; then ANY_EXT_CHANGED=true break @@ -112,7 +112,7 @@ jobs: COMMON_CHANGED=$(echo $FILTER_OUTPUTS | jq -r .common) for ext in ${{ matrix.extensions }}; do - ext_changed=$(echo $FILTER_OUTPUTS | jq -r .$ext) + ext_changed=$(echo $FILTER_OUTPUTS | jq -r --arg ext "$ext" '.[$ext]') if [[ "$COMMON_CHANGED" == "true" || "$ext_changed" == "true" ]]; then echo "::group::Running tests for $ext" diff --git a/extensions/new-keccak256/circuit/Cargo.toml b/extensions/new-keccak256/circuit/Cargo.toml index 048e7ff9b2..333fdbd9c3 100644 --- a/extensions/new-keccak256/circuit/Cargo.toml +++ b/extensions/new-keccak256/circuit/Cargo.toml @@ -10,6 +10,8 @@ repository.workspace = true [dependencies] openvm-stark-backend = { workspace = true } openvm-stark-sdk = { workspace = true } +openvm-cuda-backend = { workspace = true, optional = true } +openvm-cuda-common = { workspace = true, optional = true } openvm-circuit-primitives = { workspace = true } openvm-circuit-primitives-derive = { workspace = true } openvm-circuit = { workspace = true } @@ -32,6 +34,9 @@ serde.workspace = true openvm-stark-sdk = { workspace = true } openvm-circuit = { workspace = true, features = ["test-utils"] } +[build-dependencies] +openvm-cuda-builder = { workspace = true, optional = true } + [features] default = ["parallel", "jemalloc"] parallel = ["openvm-circuit/parallel"] @@ -44,6 +49,9 @@ jemalloc = ["openvm-circuit/jemalloc"] jemalloc-prof = ["openvm-circuit/jemalloc-prof"] nightly-features = ["openvm-circuit/nightly-features"] cuda = [ + "dep:openvm-cuda-backend", + "dep:openvm-cuda-common", + "dep:openvm-cuda-builder", "openvm-circuit-primitives/cuda", "openvm-circuit/cuda", "openvm-rv32im-circuit/cuda", diff --git a/extensions/new-keccak256/circuit/build.rs b/extensions/new-keccak256/circuit/build.rs new file mode 100644 index 0000000000..65f583e80b --- /dev/null +++ b/extensions/new-keccak256/circuit/build.rs @@ -0,0 +1,26 @@ +#[cfg(feature = "cuda")] +use openvm_cuda_builder::{cuda_available, CudaBuilder}; + +fn main() { + #[cfg(feature = "cuda")] + { + if !cuda_available() { + return; // Skip CUDA compilation + } + + // Build xorin CUDA library + let xorin_builder = CudaBuilder::new() + .include_from_dep("DEP_CUDA_COMMON_INCLUDE") + .include("../../../crates/circuits/primitives/cuda/include") + .include("../../../crates/vm/cuda/include") + .include("cuda/include") + .watch("cuda") + .watch("../../../crates/circuits/primitives/cuda") + .watch("../../../crates/vm/cuda") + .library_name("tracegen_gpu_xorin") + .file("cuda/src/xorin.cu"); + + xorin_builder.emit_link_directives(); + xorin_builder.build(); + } +} diff --git a/extensions/new-keccak256/circuit/cuda/include/xorin/xorin.cuh b/extensions/new-keccak256/circuit/cuda/include/xorin/xorin.cuh new file mode 100644 index 0000000000..4a10e2c154 --- /dev/null +++ b/extensions/new-keccak256/circuit/cuda/include/xorin/xorin.cuh @@ -0,0 +1,71 @@ +#pragma once + +#include +#include +#include "primitives/constants.h" +#include "system/memory/offline_checker.cuh" + +namespace xorin { + +inline constexpr size_t XORIN_RATE_BYTES = 136; +inline constexpr size_t XORIN_WORD_SIZE = riscv::RV32_REGISTER_NUM_LIMBS; +inline constexpr size_t XORIN_NUM_WORDS = XORIN_RATE_BYTES / XORIN_WORD_SIZE; +inline constexpr size_t XORIN_REGISTER_READS = 3; + +template +struct XorinInstructionCols { + T pc; + T is_enabled; + T buffer_reg_ptr; + T input_reg_ptr; + T len_reg_ptr; + T buffer_ptr; + T buffer_ptr_limbs[XORIN_WORD_SIZE]; + T input_ptr; + T input_ptr_limbs[XORIN_WORD_SIZE]; + T len; + T len_limbs[XORIN_WORD_SIZE]; + T start_timestamp; +}; + +template +struct XorinSpongeCols { + T is_padding_bytes[XORIN_NUM_WORDS]; + T preimage_buffer_bytes[XORIN_RATE_BYTES]; + T input_bytes[XORIN_RATE_BYTES]; + T postimage_buffer_bytes[XORIN_RATE_BYTES]; +}; + +template +struct XorinMemoryCols { + MemoryReadAuxCols register_aux_cols[XORIN_REGISTER_READS]; + MemoryReadAuxCols input_bytes_read_aux_cols[XORIN_NUM_WORDS]; + MemoryReadAuxCols buffer_bytes_read_aux_cols[XORIN_NUM_WORDS]; + MemoryWriteAuxCols buffer_bytes_write_aux_cols[XORIN_NUM_WORDS]; +}; + +template +struct XorinVmCols { + XorinSpongeCols sponge; + XorinInstructionCols instruction; + XorinMemoryCols mem_oc; +}; + +struct XorinVmRecord { + uint32_t from_pc; + uint32_t timestamp; + uint32_t rd_ptr; + uint32_t rs1_ptr; + uint32_t rs2_ptr; + uint32_t buffer; + uint32_t input; + uint32_t len; + uint8_t buffer_limbs[XORIN_RATE_BYTES]; + uint8_t input_limbs[XORIN_RATE_BYTES]; + MemoryReadAuxRecord register_aux_cols[XORIN_REGISTER_READS]; + MemoryReadAuxRecord input_read_aux_cols[XORIN_NUM_WORDS]; + MemoryReadAuxRecord buffer_read_aux_cols[XORIN_NUM_WORDS]; + MemoryWriteBytesAuxRecord buffer_write_aux_cols[XORIN_NUM_WORDS]; +}; + +} // namespace xorin \ No newline at end of file diff --git a/extensions/new-keccak256/circuit/cuda/src/xorin.cu b/extensions/new-keccak256/circuit/cuda/src/xorin.cu new file mode 100644 index 0000000000..3487b93f03 --- /dev/null +++ b/extensions/new-keccak256/circuit/cuda/src/xorin.cu @@ -0,0 +1,195 @@ +#include "launcher.cuh" +#include "primitives/buffer_view.cuh" +#include "primitives/constants.h" +#include "primitives/trace_access.h" +#include "primitives/histogram.cuh" +#include "system/memory/controller.cuh" +#include "xorin/xorin.cuh" + +using namespace xorin; +using namespace riscv; + +#define XORIN_WRITE(FIELD, VALUE) COL_WRITE_VALUE(row, XorinVmCols, FIELD, VALUE) +#define XORIN_WRITE_ARRAY(FIELD, VALUES) COL_WRITE_ARRAY(row, XorinVmCols, FIELD, VALUES) +#define XORIN_FILL_ZERO(FIELD) COL_FILL_ZERO(row, XorinVmCols, FIELD) +#define XORIN_SLICE(FIELD) row.slice_from(COL_INDEX(XorinVmCols, FIELD)) + +__global__ void xorin_tracegen( + Fp *d_trace, + size_t height, + DeviceBufferConstView d_records, + uint32_t *d_range_checker_ptr, + uint32_t range_checker_num_bins, + uint32_t *d_bitwise_lookup_ptr, + size_t bitwise_num_bits, + uint32_t pointer_max_bits, + uint32_t timestamp_max_bits +) { + auto idx = blockIdx.x * blockDim.x + threadIdx.x; + if (idx >= height) { + return; + } + + RowSlice row(d_trace + idx, height); + + if (idx < d_records.len()) { + auto const &rec = d_records[idx]; + + assert((rec.len % XORIN_WORD_SIZE) == 0); + assert(rec.len <= XORIN_RATE_BYTES); + assert((uint64_t)rec.buffer + rec.len <= (1ULL << pointer_max_bits)); + assert((uint64_t)rec.input + rec.len <= (1ULL << pointer_max_bits)); + assert(rec.len < (1U << pointer_max_bits)); + + MemoryAuxColsFactory mem_helper( + VariableRangeChecker(d_range_checker_ptr, range_checker_num_bins), + timestamp_max_bits + ); + BitwiseOperationLookup bitwise_lookup(d_bitwise_lookup_ptr, bitwise_num_bits); + + auto record_len = rec.len; + auto num_reads = (record_len + XORIN_WORD_SIZE - 1) / XORIN_WORD_SIZE; + + // Fill instruction columns + XORIN_WRITE(instruction.pc, rec.from_pc); + XORIN_WRITE(instruction.is_enabled, 1); + XORIN_WRITE(instruction.buffer_reg_ptr, rec.rd_ptr); + XORIN_WRITE(instruction.input_reg_ptr, rec.rs1_ptr); + XORIN_WRITE(instruction.len_reg_ptr, rec.rs2_ptr); + XORIN_WRITE(instruction.buffer_ptr, rec.buffer); + XORIN_WRITE(instruction.input_ptr, rec.input); + XORIN_WRITE(instruction.len, rec.len); + XORIN_WRITE(instruction.start_timestamp, rec.timestamp); + + // Fill buffer/input/len limbs + XORIN_WRITE_ARRAY(instruction.buffer_ptr_limbs, reinterpret_cast(&rec.buffer)); + XORIN_WRITE_ARRAY(instruction.input_ptr_limbs, reinterpret_cast(&rec.input)); + XORIN_WRITE_ARRAY(instruction.len_limbs, reinterpret_cast(&rec.len)); + + // Fill is_padding_bytes + for (auto i = 0u; i < num_reads && i < XORIN_NUM_WORDS; i++) { + XORIN_WRITE(sponge.is_padding_bytes[i], 0); + } + for (auto i = num_reads; i < XORIN_NUM_WORDS; i++) { + XORIN_WRITE(sponge.is_padding_bytes[i], 1); + } + + // Fill sponge columns and request bitwise operations + for (auto i = 0u; i < record_len && i < XORIN_RATE_BYTES; i++) { + XORIN_WRITE(sponge.preimage_buffer_bytes[i], rec.buffer_limbs[i]); + XORIN_WRITE(sponge.input_bytes[i], rec.input_limbs[i]); + XORIN_WRITE(sponge.postimage_buffer_bytes[i], rec.buffer_limbs[i] ^ rec.input_limbs[i]); + bitwise_lookup.add_xor(rec.buffer_limbs[i], rec.input_limbs[i]); + } + + // Zero-fill remaining sponge columns + for (auto i = record_len; i < XORIN_RATE_BYTES; i++) { + XORIN_WRITE(sponge.preimage_buffer_bytes[i], Fp::zero()); + XORIN_WRITE(sponge.input_bytes[i], Fp::zero()); + XORIN_WRITE(sponge.postimage_buffer_bytes[i], Fp::zero()); + } + + // Timestamps follow the order from CPU trace: registers, buffer reads, input reads, buffer writes + auto timestamp = rec.timestamp; + + // Register aux cols (3 register reads) + #pragma unroll + for (auto t = 0u; t < XORIN_REGISTER_READS; t++) { + mem_helper.fill( + XORIN_SLICE(mem_oc.register_aux_cols[t].base), + rec.register_aux_cols[t].prev_timestamp, + timestamp + ); + timestamp++; + } + + // Buffer bytes read aux cols + for (auto t = 0u; t < num_reads && t < XORIN_NUM_WORDS; t++) { + mem_helper.fill( + XORIN_SLICE(mem_oc.buffer_bytes_read_aux_cols[t].base), + rec.buffer_read_aux_cols[t].prev_timestamp, + timestamp + ); + timestamp++; + } + for (auto t = num_reads; t < XORIN_NUM_WORDS; t++) { + mem_helper.fill_zero(XORIN_SLICE(mem_oc.buffer_bytes_read_aux_cols[t].base)); + } + + // Input bytes read aux cols + for (auto t = 0u; t < num_reads && t < XORIN_NUM_WORDS; t++) { + mem_helper.fill( + XORIN_SLICE(mem_oc.input_bytes_read_aux_cols[t].base), + rec.input_read_aux_cols[t].prev_timestamp, + timestamp + ); + timestamp++; + } + for (auto t = num_reads; t < XORIN_NUM_WORDS; t++) { + mem_helper.fill_zero(XORIN_SLICE(mem_oc.input_bytes_read_aux_cols[t].base)); + } + + // Buffer bytes write aux cols + for (auto t = 0u; t < num_reads && t < XORIN_NUM_WORDS; t++) { + mem_helper.fill( + XORIN_SLICE(mem_oc.buffer_bytes_write_aux_cols[t].base), + rec.buffer_write_aux_cols[t].prev_timestamp, + timestamp + ); + XORIN_WRITE_ARRAY(mem_oc.buffer_bytes_write_aux_cols[t].prev_data, rec.buffer_write_aux_cols[t].prev_data); + timestamp++; + } + for (auto t = num_reads; t < XORIN_NUM_WORDS; t++) { + XORIN_FILL_ZERO(mem_oc.buffer_bytes_write_aux_cols[t]); + } + + // Range check for pointer bounds + constexpr uint32_t MSL_RSHIFT = RV32_CELL_BITS * (RV32_REGISTER_NUM_LIMBS - 1); + constexpr uint32_t RV32_TOTAL_BITS = RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS; + bitwise_lookup.add_range( + (rec.buffer >> MSL_RSHIFT) << (RV32_TOTAL_BITS - pointer_max_bits), + (rec.input >> MSL_RSHIFT) << (RV32_TOTAL_BITS - pointer_max_bits) + ); + bitwise_lookup.add_range( + (rec.len >> MSL_RSHIFT) << (RV32_TOTAL_BITS - pointer_max_bits), + (rec.len >> MSL_RSHIFT) << (RV32_TOTAL_BITS - pointer_max_bits) + ); + + } else { + // Zero-fill padding rows + row.fill_zero(0, sizeof(XorinVmCols)); + } +} + +extern "C" int _xorin_tracegen( + Fp *d_trace, + size_t height, + size_t width, + DeviceBufferConstView d_records, + uint32_t *d_range_checker_ptr, + uint32_t range_checker_num_bins, + uint32_t *d_bitwise_lookup_ptr, + size_t bitwise_num_bits, + uint32_t pointer_max_bits, + uint32_t timestamp_max_bits +) { + assert((height & (height - 1)) == 0); + assert(height >= d_records.len()); + assert(width == sizeof(XorinVmCols)); + + auto [grid, block] = kernel_launch_params(height); + + xorin_tracegen<<>>( + d_trace, + height, + d_records, + d_range_checker_ptr, + range_checker_num_bins, + d_bitwise_lookup_ptr, + bitwise_num_bits, + pointer_max_bits, + timestamp_max_bits + ); + + return CHECK_KERNEL(); +} diff --git a/extensions/new-keccak256/circuit/src/cuda/cuda_abi.rs b/extensions/new-keccak256/circuit/src/cuda/cuda_abi.rs new file mode 100644 index 0000000000..62e4289ca9 --- /dev/null +++ b/extensions/new-keccak256/circuit/src/cuda/cuda_abi.rs @@ -0,0 +1,52 @@ +use openvm_cuda_backend::prelude::F; +use openvm_cuda_common::{ + d_buffer::{DeviceBuffer, DeviceBufferView}, + error::CudaError, +}; + +pub mod xorin { + use super::*; + + extern "C" { + fn _xorin_tracegen( + d_trace: *mut F, + height: usize, + width: usize, + d_records: DeviceBufferView, + d_range_checker: *mut u32, + range_checker_num_bins: u32, + d_bitwise_lookup: *const u32, + bitwise_num_bits: usize, + pointer_max_bits: u32, + timestamp_max_bits: u32, + ) -> i32; + } + + /// # Safety + /// All device buffers must be valid and properly allocated. + #[allow(clippy::too_many_arguments)] + pub unsafe fn tracegen( + d_trace: &DeviceBuffer, + height: usize, + d_records: &DeviceBuffer, + d_range_checker: &DeviceBuffer, + d_bitwise_lookup: &DeviceBuffer, + bitwise_num_bits: usize, + pointer_max_bits: u32, + timestamp_max_bits: u32, + ) -> Result<(), CudaError> { + assert!(height.is_power_of_two() || height == 0); + CudaError::from_result(_xorin_tracegen( + d_trace.as_mut_ptr(), + height, + d_trace.len() / height, + d_records.view(), + d_range_checker.as_mut_ptr() as *mut u32, + d_range_checker.len() as u32, + d_bitwise_lookup.as_mut_ptr() as *mut u32, + bitwise_num_bits, + pointer_max_bits, + timestamp_max_bits, + )) + } +} diff --git a/extensions/new-keccak256/circuit/src/cuda/mod.rs b/extensions/new-keccak256/circuit/src/cuda/mod.rs new file mode 100644 index 0000000000..c23b046996 --- /dev/null +++ b/extensions/new-keccak256/circuit/src/cuda/mod.rs @@ -0,0 +1,58 @@ +use std::{mem::size_of, sync::Arc}; + +use derive_new::new; +use openvm_circuit::{arch::DenseRecordArena, utils::next_power_of_two_or_zero}; +use openvm_circuit_primitives::{ + bitwise_op_lookup::BitwiseOperationLookupChipGPU, var_range::VariableRangeCheckerChipGPU, +}; +use openvm_cuda_backend::{ + base::DeviceMatrix, chip::get_empty_air_proving_ctx, prelude::F, prover_backend::GpuBackend, +}; +use openvm_cuda_common::copy::MemCopyH2D; +use openvm_instructions::riscv::RV32_CELL_BITS; +use openvm_stark_backend::{prover::types::AirProvingContext, Chip}; + +use crate::xorin::{columns::NUM_XORIN_VM_COLS, trace::XorinVmRecordHeader}; + +mod cuda_abi; + +#[derive(new)] +pub struct XorinVmChipGpu { + pub range_checker: Arc, + pub bitwise_lookup: Arc>, + pub pointer_max_bits: usize, + pub timestamp_max_bits: u32, +} + +impl Chip for XorinVmChipGpu { + fn generate_proving_ctx(&self, arena: DenseRecordArena) -> AirProvingContext { + const RECORD_SIZE: usize = size_of::(); + let records = arena.allocated(); + if records.is_empty() { + return get_empty_air_proving_ctx::(); + } + debug_assert_eq!(records.len() % RECORD_SIZE, 0); + + let trace_width = NUM_XORIN_VM_COLS; + let trace_height = next_power_of_two_or_zero(records.len() / RECORD_SIZE); + + let d_records = records.to_device().unwrap(); + let d_trace = DeviceMatrix::::with_capacity(trace_height, trace_width); + + unsafe { + cuda_abi::xorin::tracegen( + d_trace.buffer(), + trace_height, + &d_records, + &self.range_checker.count, + &self.bitwise_lookup.count, + RV32_CELL_BITS, + self.pointer_max_bits as u32, + self.timestamp_max_bits, + ) + .unwrap(); + } + + AirProvingContext::simple_no_pis(d_trace) + } +} diff --git a/extensions/new-keccak256/circuit/src/extension/cuda.rs b/extensions/new-keccak256/circuit/src/extension/cuda.rs new file mode 100644 index 0000000000..4b57ef4172 --- /dev/null +++ b/extensions/new-keccak256/circuit/src/extension/cuda.rs @@ -0,0 +1,84 @@ +use openvm_circuit::{ + arch::DenseRecordArena, + system::cuda::{ + extensions::{ + get_inventory_range_checker, get_or_create_bitwise_op_lookup, SystemGpuBuilder, + }, + SystemChipInventoryGPU, + }, +}; +use openvm_cuda_backend::{engine::GpuBabyBearPoseidon2Engine, prover_backend::GpuBackend}; +use openvm_rv32im_circuit::Rv32ImGpuProverExt; +use openvm_stark_sdk::config::baby_bear_poseidon2::BabyBearPoseidon2Config; + +use super::*; +use crate::cuda::XorinVmChipGpu; + +pub struct NewKeccak256GpuProverExt; + +impl VmProverExtension + for NewKeccak256GpuProverExt +{ + fn extend_prover( + &self, + _extension: &NewKeccak256, + inventory: &mut ChipInventory, + ) -> Result<(), ChipInventoryError> { + let pointer_max_bits = inventory.airs().pointer_max_bits(); + let timestamp_max_bits = inventory.timestamp_max_bits(); + + let range_checker = get_inventory_range_checker(inventory); + let bitwise_lu = get_or_create_bitwise_op_lookup(inventory)?; + + inventory.next_air::()?; + let xorin_chip = XorinVmChipGpu::new( + range_checker.clone(), + bitwise_lu.clone(), + pointer_max_bits, + timestamp_max_bits as u32, + ); + inventory.add_executor_chip(xorin_chip); + + inventory.next_air::()?; + + Ok(()) + } +} + +#[derive(Clone)] +pub struct NewKeccak256Rv32GpuBuilder; + +type E = GpuBabyBearPoseidon2Engine; + +impl VmBuilder for NewKeccak256Rv32GpuBuilder { + type VmConfig = NewKeccak256Rv32Config; + type SystemChipInventory = SystemChipInventoryGPU; + type RecordArena = DenseRecordArena; + + fn create_chip_complex( + &self, + config: &NewKeccak256Rv32Config, + circuit: AirInventory<::SC>, + ) -> Result< + VmChipComplex< + ::SC, + Self::RecordArena, + ::PB, + Self::SystemChipInventory, + >, + ChipInventoryError, + > { + let mut chip_complex = + VmBuilder::::create_chip_complex(&SystemGpuBuilder, &config.system, circuit)?; + let inventory = &mut chip_complex.inventory; + VmProverExtension::::extend_prover(&Rv32ImGpuProverExt, &config.rv32i, inventory)?; + VmProverExtension::::extend_prover(&Rv32ImGpuProverExt, &config.rv32m, inventory)?; + VmProverExtension::::extend_prover(&Rv32ImGpuProverExt, &config.io, inventory)?; + VmProverExtension::::extend_prover( + &NewKeccak256GpuProverExt, + &config.keccak, + inventory, + )?; + Ok(chip_complex) + } +} diff --git a/extensions/new-keccak256/circuit/src/extension/mod.rs b/extensions/new-keccak256/circuit/src/extension/mod.rs index f65d242940..82c0093a00 100644 --- a/extensions/new-keccak256/circuit/src/extension/mod.rs +++ b/extensions/new-keccak256/circuit/src/extension/mod.rs @@ -37,6 +37,11 @@ use crate::{ xorin::{air::XorinVmAir, XorinVmChip, XorinVmExecutor, XorinVmFiller}, }; +#[cfg(feature = "cuda")] +mod cuda; +#[cfg(feature = "cuda")] +pub use cuda::*; + #[derive(Clone, Debug, VmConfig, derive_new::new, Serialize, Deserialize)] pub struct NewKeccak256Rv32Config { #[config(executor = "SystemExecutor")] diff --git a/extensions/new-keccak256/circuit/src/lib.rs b/extensions/new-keccak256/circuit/src/lib.rs index a51f8c4a8d..6ef84d65bc 100644 --- a/extensions/new-keccak256/circuit/src/lib.rs +++ b/extensions/new-keccak256/circuit/src/lib.rs @@ -6,5 +6,10 @@ mod keccakf; mod xorin; +#[cfg(feature = "cuda")] +mod cuda; +#[cfg(feature = "cuda")] +pub use cuda::*; + mod extension; pub use extension::*; diff --git a/extensions/new-keccak256/circuit/src/xorin/tests.rs b/extensions/new-keccak256/circuit/src/xorin/tests.rs index 30f4907185..6f11450434 100644 --- a/extensions/new-keccak256/circuit/src/xorin/tests.rs +++ b/extensions/new-keccak256/circuit/src/xorin/tests.rs @@ -22,6 +22,7 @@ use crate::xorin::{air::XorinVmAir, XorinVmChip, XorinVmExecutor, XorinVmFiller} type F = BabyBear; type Harness = TestChipHarness>; +const MAX_TRACE_ROWS: usize = 4096; fn create_harness_fields( execution_bridge: ExecutionBridge, @@ -68,8 +69,6 @@ fn create_test_harness( tester.address_bits(), ); - const MAX_TRACE_ROWS: usize = 4096; - let harness = Harness::with_capacity(executor, air, chip, MAX_TRACE_ROWS); (harness, (bitwise_chip.air, bitwise_chip)) @@ -249,3 +248,182 @@ fn run_xorin_chip_negative_tests( } } */ + +// //////////////////////////////////////////////////////////////////////////////////// +// CUDA TESTS +// //////////////////////////////////////////////////////////////////////////////////// +#[cfg(feature = "cuda")] +use openvm_circuit::arch::{ + testing::{default_bitwise_lookup_bus, GpuChipTestBuilder, GpuTestChipHarness}, + DenseRecordArena, +}; + +#[cfg(feature = "cuda")] +use crate::{cuda::XorinVmChipGpu, xorin::trace::XorinVmRecordMut}; + +#[cfg(feature = "cuda")] +type GpuHarness = + GpuTestChipHarness>; + +#[cfg(feature = "cuda")] +fn create_cuda_harness(tester: &GpuChipTestBuilder) -> GpuHarness { + let bitwise_bus = default_bitwise_lookup_bus(); + let dummy_bitwise_chip = Arc::new(BitwiseOperationLookupChip::::new( + bitwise_bus, + )); + + let (air, executor, cpu_chip) = create_harness_fields( + tester.execution_bridge(), + tester.memory_bridge(), + dummy_bitwise_chip, + tester.dummy_memory_helper(), + tester.address_bits(), + ); + + let gpu_chip = XorinVmChipGpu::new( + tester.range_checker(), + tester.bitwise_op_lookup(), + tester.address_bits(), + tester.timestamp_max_bits() as u32, + ); + + GpuTestChipHarness::with_capacity(executor, air, gpu_chip, cpu_chip, MAX_TRACE_ROWS) +} + +#[cfg(feature = "cuda")] +fn cuda_set_and_execute( + tester: &mut GpuChipTestBuilder, + executor: &mut XorinVmExecutor, + arena: &mut DenseRecordArena, + rng: &mut StdRng, + len: Option, +) { + use openvm_circuit::arch::testing::memory::gen_pointer; + + let len = len.unwrap_or_else(|| rng.gen_range(4..=136)); + let len = (len / 4) * 4; + if len == 0 { + return; + } + + let buffer_reg = gen_pointer(rng, 4); + let input_reg = gen_pointer(rng, 4); + let len_reg = gen_pointer(rng, 4); + + let buffer_ptr = gen_pointer(rng, len); + let input_ptr = gen_pointer(rng, len); + + tester.write( + 1, + buffer_reg, + buffer_ptr.to_le_bytes().map(F::from_canonical_u8), + ); + tester.write( + 1, + input_reg, + input_ptr.to_le_bytes().map(F::from_canonical_u8), + ); + tester.write( + 1, + len_reg, + (len as u32).to_le_bytes().map(F::from_canonical_u8), + ); + + let buffer_data: Vec = (0..len).map(|_| rng.gen()).collect(); + for (i, chunk) in buffer_data.chunks(4).enumerate() { + let mut word = [F::ZERO; 4]; + for (j, &byte) in chunk.iter().enumerate() { + word[j] = F::from_canonical_u8(byte); + } + tester.write(2, buffer_ptr + i * 4, word); + } + + let input_data: Vec = (0..len).map(|_| rng.gen()).collect(); + for (i, chunk) in input_data.chunks(4).enumerate() { + let mut word = [F::ZERO; 4]; + for (j, &byte) in chunk.iter().enumerate() { + word[j] = F::from_canonical_u8(byte); + } + tester.write(2, input_ptr + i * 4, word); + } + + let instruction = Instruction::from_usize( + XorinOpcode::XORIN.global_opcode(), + [buffer_reg, input_reg, len_reg, 1, 2], + ); + + tester.execute(executor, arena, &instruction); +} + +#[cfg(feature = "cuda")] +#[test] +fn test_xorin_cuda_tracegen() { + let mut rng = create_seeded_rng(); + let mut tester = + GpuChipTestBuilder::default().with_bitwise_op_lookup(default_bitwise_lookup_bus()); + + let mut harness = create_cuda_harness(&tester); + + let num_ops: usize = 5; + for _ in 0..num_ops { + cuda_set_and_execute( + &mut tester, + &mut harness.executor, + &mut harness.dense_arena, + &mut rng, + None, + ); + } + + for len in [4, 8, 16, 32, 64, 128, 136] { + cuda_set_and_execute( + &mut tester, + &mut harness.executor, + &mut harness.dense_arena, + &mut rng, + Some(len), + ); + } + + harness + .dense_arena + .get_record_seeker::() + .transfer_to_matrix_arena(&mut harness.matrix_arena); + + tester + .build() + .load_gpu_harness(harness) + .finalize() + .simple_test() + .unwrap(); +} + +#[cfg(feature = "cuda")] +#[test] +fn test_xorin_cuda_tracegen_single() { + let mut rng = create_seeded_rng(); + let mut tester = + GpuChipTestBuilder::default().with_bitwise_op_lookup(default_bitwise_lookup_bus()); + + let mut harness = create_cuda_harness(&tester); + + cuda_set_and_execute( + &mut tester, + &mut harness.executor, + &mut harness.dense_arena, + &mut rng, + Some(16), + ); + + harness + .dense_arena + .get_record_seeker::() + .transfer_to_matrix_arena(&mut harness.matrix_arena); + + tester + .build() + .load_gpu_harness(harness) + .finalize() + .simple_test() + .unwrap(); +} From 4755ec9d33e910e9927f4d21419b9b3d262ecfce Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Fri, 19 Dec 2025 21:15:07 +0100 Subject: [PATCH 03/78] feat(new-keccak): add keccakf cuda tracegen (#2327) Resolves INT-5722 --- extensions/new-keccak256/circuit/build.rs | 15 + .../circuit/cuda/include/keccakf/keccakf.cuh | 75 +++++ .../cuda/include/keccakf/p3_generation.cuh | 92 ++++++ .../new-keccak256/circuit/cuda/src/keccakf.cu | 290 ++++++++++++++++++ .../circuit/src/cuda/cuda_abi.rs | 45 +++ .../new-keccak256/circuit/src/cuda/mod.rs | 50 ++- .../circuit/src/extension/cuda.rs | 9 +- .../circuit/src/keccakf/tests.rs | 194 +++++++++++- .../circuit/src/keccakf/trace.rs | 6 +- 9 files changed, 770 insertions(+), 6 deletions(-) create mode 100644 extensions/new-keccak256/circuit/cuda/include/keccakf/keccakf.cuh create mode 100644 extensions/new-keccak256/circuit/cuda/include/keccakf/p3_generation.cuh create mode 100644 extensions/new-keccak256/circuit/cuda/src/keccakf.cu diff --git a/extensions/new-keccak256/circuit/build.rs b/extensions/new-keccak256/circuit/build.rs index 65f583e80b..3e8372a5fd 100644 --- a/extensions/new-keccak256/circuit/build.rs +++ b/extensions/new-keccak256/circuit/build.rs @@ -22,5 +22,20 @@ fn main() { xorin_builder.emit_link_directives(); xorin_builder.build(); + + // Build keccakf CUDA library + let keccakf_builder = CudaBuilder::new() + .include_from_dep("DEP_CUDA_COMMON_INCLUDE") + .include("../../../crates/circuits/primitives/cuda/include") + .include("../../../crates/vm/cuda/include") + .include("cuda/include") + .watch("cuda") + .watch("../../../crates/circuits/primitives/cuda") + .watch("../../../crates/vm/cuda") + .library_name("tracegen_gpu_keccakf") + .file("cuda/src/keccakf.cu"); + + keccakf_builder.emit_link_directives(); + keccakf_builder.build(); } } diff --git a/extensions/new-keccak256/circuit/cuda/include/keccakf/keccakf.cuh b/extensions/new-keccak256/circuit/cuda/include/keccakf/keccakf.cuh new file mode 100644 index 0000000000..558103032f --- /dev/null +++ b/extensions/new-keccak256/circuit/cuda/include/keccakf/keccakf.cuh @@ -0,0 +1,75 @@ +#pragma once + +#include +#include +#include "primitives/constants.h" +#include "system/memory/offline_checker.cuh" + +namespace keccakf { + +inline constexpr size_t NUM_ROUNDS = 24; +inline constexpr size_t KECCAK_STATE_BYTES = 200; +inline constexpr size_t KECCAK_STATE_U64 = 25; +inline constexpr size_t KECCAK_STATE_U16 = 100; +inline constexpr size_t NUM_BUFFER_WORDS = KECCAK_STATE_BYTES / riscv::RV32_REGISTER_NUM_LIMBS; +inline constexpr size_t U64_LIMBS = 4; + +// KeccakPermCols from p3_keccak_air - must match exactly +template +struct KeccakPermCols { + T step_flags[NUM_ROUNDS]; + T _export; + T preimage[5][5][U64_LIMBS]; + T a[5][5][U64_LIMBS]; + T c[5][64]; + T c_prime[5][64]; + T a_prime[5][5][64]; + T a_prime_prime[5][5][U64_LIMBS]; + T a_prime_prime_0_0_bits[64]; + T a_prime_prime_prime_0_0_limbs[U64_LIMBS]; +}; + +template +struct KeccakfInstructionCols { + T pc; + T is_enabled; + T rd_ptr; + T buffer_ptr; + T buffer_ptr_limbs[riscv::RV32_REGISTER_NUM_LIMBS]; +}; + +template +struct KeccakfMemoryCols { + MemoryReadAuxCols register_aux_cols[1]; + MemoryReadAuxCols buffer_bytes_read_aux_cols[NUM_BUFFER_WORDS]; + MemoryWriteAuxCols buffer_bytes_write_aux_cols[NUM_BUFFER_WORDS]; +}; + +template +struct KeccakfVmCols { + KeccakPermCols inner; + T preimage_state_hi[KECCAK_STATE_U16]; + T postimage_state_hi[KECCAK_STATE_U16]; + KeccakfInstructionCols instruction; + KeccakfMemoryCols mem_oc; + T timestamp; + T is_enabled_is_first_round; + T is_enabled_is_final_round; +}; + +// Record structure matching Rust's KeccakfVmRecordHeader +struct KeccakfVmRecord { + uint32_t pc; + uint32_t timestamp; + uint32_t buffer; + uint8_t preimage_buffer_bytes[KECCAK_STATE_BYTES]; + uint32_t rd_ptr; + MemoryReadAuxRecord register_aux_cols[1]; + MemoryReadAuxRecord buffer_read_aux_cols[NUM_BUFFER_WORDS]; + MemoryWriteBytesAuxRecord buffer_write_aux_cols[NUM_BUFFER_WORDS]; +}; + +inline constexpr size_t NUM_KECCAKF_VM_COLS = sizeof(KeccakfVmCols); +inline constexpr size_t NUM_KECCAK_PERM_COLS = sizeof(KeccakPermCols); + +} // namespace keccakf diff --git a/extensions/new-keccak256/circuit/cuda/include/keccakf/p3_generation.cuh b/extensions/new-keccak256/circuit/cuda/include/keccakf/p3_generation.cuh new file mode 100644 index 0000000000..b736c1262b --- /dev/null +++ b/extensions/new-keccak256/circuit/cuda/include/keccakf/p3_generation.cuh @@ -0,0 +1,92 @@ +#pragma once + +#include "keccakf.cuh" +#include "primitives/trace_access.h" +#include "primitives/utils.cuh" + +using namespace keccakf; + +__device__ __constant__ uint8_t R[5][5] = { + {0, 36, 3, 41, 18}, + {1, 44, 10, 45, 2}, + {62, 6, 43, 15, 61}, + {28, 55, 25, 21, 56}, + {27, 20, 39, 8, 14}, +}; + +__device__ __constant__ uint64_t RC[NUM_ROUNDS] = { + 0x0000000000000001ULL, 0x0000000000008082ULL, 0x800000000000808AULL, 0x8000000080008000ULL, + 0x000000000000808BULL, 0x0000000080000001ULL, 0x8000000080008081ULL, 0x8000000000008009ULL, + 0x000000000000008AULL, 0x0000000000000088ULL, 0x0000000080008009ULL, 0x000000008000000AULL, + 0x000000008000808BULL, 0x800000000000008BULL, 0x8000000000008089ULL, 0x8000000000008003ULL, + 0x8000000000008002ULL, 0x8000000000000080ULL, 0x000000000000800AULL, 0x800000008000000AULL, + 0x8000000080008081ULL, 0x8000000000008080ULL, 0x0000000080000001ULL, 0x8000000080008008ULL +}; + +__device__ void generate_trace_row_for_round( + RowSlice row, + uint32_t round, + uint64_t current_state[5][5] +) { + COL_FILL_ZERO(row, KeccakfVmCols, inner.step_flags); + COL_WRITE_VALUE(row, KeccakfVmCols, inner.step_flags[round], 1); + + // Populate C[x] = xor(A[x, 0], A[x, 1], A[x, 2], A[x, 3], A[x, 4]). + uint64_t state_c[5]; +#pragma unroll 5 + for (auto x = 0; x < 5; x++) { + state_c[x] = current_state[0][x] ^ current_state[1][x] ^ current_state[2][x] ^ + current_state[3][x] ^ current_state[4][x]; + COL_WRITE_BITS(row, KeccakfVmCols, inner.c[x], state_c[x]); + } + + // Populate C'[x, z] = xor(C[x, z], C[x - 1, z], ROTL1(C[x + 1, z - 1])). + uint64_t state_c_prime[5]; +#pragma unroll 5 + for (auto x = 0; x < 5; x++) { + state_c_prime[x] = state_c[x] ^ state_c[(x + 4) % 5] ^ ROTL64(state_c[(x + 1) % 5], 1); + COL_WRITE_BITS(row, KeccakfVmCols, inner.c_prime[x], state_c_prime[x]); + } + + // Populate A'. To avoid shifting indices, we rewrite + // A'[x, y, z] = xor(A[x, y, z], C[x - 1, z], C[x + 1, z - 1]) + // as + // A'[x, y, z] = xor(A[x, y, z], C[x, z], C'[x, z]). + for (int x = 0; x < 5; x++) { +#pragma unroll 5 + for (int y = 0; y < 5; y++) { + current_state[y][x] ^= state_c[x] ^ state_c_prime[x]; + COL_WRITE_BITS(row, KeccakfVmCols, inner.a_prime[y][x], current_state[y][x]); + } + } + + // Rotate the current state to get the B array. + uint64_t state_b[5][5]; + for (auto i = 0; i < 5; i++) { +#pragma unroll 5 + for (auto j = 0; j < 5; j++) { + auto new_i = (i + 3 * j) % 5; + auto new_j = i; + state_b[j][i] = ROTL64(current_state[new_j][new_i], R[new_i][new_j]); + } + } + + // Populate A'' as A''[x, y] = xor(B[x, y], andn(B[x + 1, y], B[x + 2, y])). + for (int i = 0; i < 5; i++) { +#pragma unroll 5 + for (int j = 0; j < 5; j++) { + current_state[i][j] = + state_b[i][j] ^ ((~state_b[i][(j + 1) % 5]) & state_b[i][(j + 2) % 5]); + } + } + uint16_t *state_limbs = reinterpret_cast(¤t_state[0][0]); + COL_WRITE_ARRAY(row, KeccakfVmCols, inner.a_prime_prime, state_limbs); + + COL_WRITE_BITS(row, KeccakfVmCols, inner.a_prime_prime_0_0_bits, current_state[0][0]); + + // A''[0, 0] is additionally xor'd with RC. + current_state[0][0] ^= RC[round]; + + state_limbs = reinterpret_cast(¤t_state[0][0]); + COL_WRITE_ARRAY(row, KeccakfVmCols, inner.a_prime_prime_prime_0_0_limbs, state_limbs); +} diff --git a/extensions/new-keccak256/circuit/cuda/src/keccakf.cu b/extensions/new-keccak256/circuit/cuda/src/keccakf.cu new file mode 100644 index 0000000000..9e1b315eee --- /dev/null +++ b/extensions/new-keccak256/circuit/cuda/src/keccakf.cu @@ -0,0 +1,290 @@ +#include "keccakf/keccakf.cuh" +#include "keccakf/p3_generation.cuh" +#include "launcher.cuh" +#include "primitives/buffer_view.cuh" +#include "primitives/constants.h" +#include "primitives/histogram.cuh" +#include "primitives/trace_access.h" +#include "primitives/utils.cuh" +#include "system/memory/controller.cuh" + +using namespace keccakf; +using namespace riscv; + +#define KECCAKF_WRITE(FIELD, VALUE) COL_WRITE_VALUE(row, KeccakfVmCols, FIELD, VALUE) +#define KECCAKF_WRITE_ARRAY(FIELD, VALUES) COL_WRITE_ARRAY(row, KeccakfVmCols, FIELD, VALUES) +#define KECCAKF_FILL_ZERO(FIELD) COL_FILL_ZERO(row, KeccakfVmCols, FIELD) +#define KECCAKF_SLICE(FIELD) row.slice_from(COL_INDEX(KeccakfVmCols, FIELD)) + +// Single kernel that processes one block (24 rows) per thread +__global__ void keccakf_tracegen( + Fp *d_trace, + size_t height, + uint32_t num_records, + uint32_t blocks_to_fill, + DeviceBufferConstView d_records, + uint32_t *d_range_checker_ptr, + uint32_t range_checker_num_bins, + uint32_t *d_bitwise_lookup_ptr, + size_t bitwise_num_bits, + uint32_t pointer_max_bits, + uint32_t timestamp_max_bits +) { + auto block_idx = blockIdx.x * blockDim.x + threadIdx.x; + if (block_idx >= blocks_to_fill) { + return; + } + + __align__(16) uint64_t current_state[5][5] = {0}; + __align__(16) uint64_t initial_state[5][5] = {0}; + uint64_t postimage_u64[25] = {0}; + + if (block_idx < num_records) { + auto const &rec = d_records[block_idx]; + + // Convert preimage bytes to u64 state and transpose for p3 compatibility +#pragma unroll 5 + for (auto x = 0; x < 5; x++) { +#pragma unroll 5 + for (auto y = 0; y < 5; y++) { + uint64_t val = 0; +#pragma unroll 8 + for (auto j = 0; j < 8; j++) { + val |= static_cast(rec.preimage_buffer_bytes[(y + 5 * x) * 8 + j]) << (j * 8); + } + current_state[x][y] = val; // Store transposed (x-major for p3) + initial_state[x][y] = val; + } + } + + // Compute postimage - load preimage into postimage_u64 +#pragma unroll 5 + for (auto i = 0; i < 25; i++) { + uint64_t val = 0; +#pragma unroll 8 + for (auto j = 0; j < 8; j++) { + val |= static_cast(rec.preimage_buffer_bytes[i * 8 + j]) << (j * 8); + } + postimage_u64[i] = val; + } + + // Keccakf permutation +#pragma unroll 1 + for (auto round = 0; round < NUM_ROUNDS; round++) { + // Theta + uint64_t c[5]; +#pragma unroll 5 + for (auto x = 0; x < 5; x++) { + c[x] = postimage_u64[x] ^ postimage_u64[x + 5] ^ postimage_u64[x + 10] ^ + postimage_u64[x + 15] ^ postimage_u64[x + 20]; + } +#pragma unroll 5 + for (auto x = 0; x < 5; x++) { + auto d = c[(x + 4) % 5] ^ ROTL64(c[(x + 1) % 5], 1); + postimage_u64[x] ^= d; + postimage_u64[x + 5] ^= d; + postimage_u64[x + 10] ^= d; + postimage_u64[x + 15] ^= d; + postimage_u64[x + 20] ^= d; + } + + // Rho and Pi + uint64_t temp[25]; +#pragma unroll 5 + for (auto y = 0; y < 5; y++) { +#pragma unroll 5 + for (auto x = 0; x < 5; x++) { + temp[y + 5 * ((2 * x + 3 * y) % 5)] = ROTL64(postimage_u64[x + 5 * y], R[x][y]); + } + } + + // Chi +#pragma unroll 5 + for (auto y = 0; y < 5; y++) { +#pragma unroll 5 + for (auto x = 0; x < 5; x++) { + postimage_u64[x + 5 * y] = temp[x + 5 * y] ^ ((~temp[(x + 1) % 5 + 5 * y]) & temp[(x + 2) % 5 + 5 * y]); + } + } + + // Iota + postimage_u64[0] ^= RC[round]; + } + } + + auto last_rounds = height - (blocks_to_fill - 1) * NUM_ROUNDS; + uint16_t *initial_state_limbs = reinterpret_cast(initial_state); + RowSlice prev_round_row(d_trace + block_idx * NUM_ROUNDS, height); + + // Process all 24 rounds for this block + for (uint32_t round_idx = 0; round_idx < NUM_ROUNDS; round_idx++) { + if ((block_idx == (blocks_to_fill - 1)) && (round_idx >= last_rounds)) { + break; + } + + RowSlice row(d_trace + block_idx * NUM_ROUNDS + round_idx, height); + + // Fill p3 permutation columns + if (round_idx == 0) { + COL_WRITE_ARRAY(row, KeccakfVmCols, inner.a, initial_state_limbs); + COL_WRITE_ARRAY(row, KeccakfVmCols, inner.preimage, initial_state_limbs); + } else { + COL_WRITE_ARRAY(row, KeccakfVmCols, inner.preimage, initial_state_limbs); + // Copy previous row's output to this row's input (a) + for (auto y = 0; y < 5; y++) { +#pragma unroll 5 + for (auto x = 0; x < 5; x++) { +#pragma unroll 4 + for (auto limb = 0; limb < U64_LIMBS; limb++) { + COL_WRITE_VALUE(row, KeccakfVmCols, inner.a[y][x][limb], + ((x == 0) && (y == 0)) + ? prev_round_row[COL_INDEX(KeccakfVmCols, inner.a_prime_prime_prime_0_0_limbs[limb])] + : prev_round_row[COL_INDEX(KeccakfVmCols, inner.a_prime_prime[y][x][limb])]); + } + } + } + } + generate_trace_row_for_round(row, round_idx, current_state); + + if (block_idx < num_records) { + auto const &rec = d_records[block_idx]; + + MemoryAuxColsFactory mem_helper( + VariableRangeChecker(d_range_checker_ptr, range_checker_num_bins), + timestamp_max_bits + ); + BitwiseOperationLookup bitwise_lookup(d_bitwise_lookup_ptr, bitwise_num_bits); + + // Fill the state hi columns - extract hi byte directly from u64 + // preimage_state_hi[i] = high byte of i-th u16 = byte at position 2*i+1 +#pragma unroll 8 + for (auto i = 0; i < KECCAK_STATE_U16; i++) { + KECCAKF_WRITE(preimage_state_hi[i], + static_cast(rec.preimage_buffer_bytes[2 * i + 1])); + } + // postimage_state_hi[i] = high byte of i-th u16 from postimage_u64 + // i-th u16 is in postimage_u64[i/4], at limb position (i%4), hi byte offset is 8 +#pragma unroll 8 + for (auto i = 0; i < KECCAK_STATE_U16; i++) { + KECCAKF_WRITE(postimage_state_hi[i], + static_cast((postimage_u64[i / 4] >> ((i % 4) * 16 + 8)) & 0xFF)); + } + + // Fill the instruction columns + KECCAKF_WRITE(instruction.pc, rec.pc); + KECCAKF_WRITE(instruction.is_enabled, 1); + KECCAKF_WRITE(instruction.rd_ptr, rec.rd_ptr); + KECCAKF_WRITE(instruction.buffer_ptr, rec.buffer); + KECCAKF_WRITE_ARRAY(instruction.buffer_ptr_limbs, reinterpret_cast(&rec.buffer)); + + // Fill timestamp + KECCAKF_WRITE(timestamp, round_idx > 0 ? rec.timestamp + 1 + NUM_BUFFER_WORDS : rec.timestamp); + + KECCAKF_WRITE(is_enabled_is_first_round, round_idx == 0); + KECCAKF_WRITE(is_enabled_is_final_round, round_idx == NUM_ROUNDS - 1); + KECCAKF_WRITE(inner._export, Fp::zero()); + + // Fill the register reads + if (round_idx == 0) { + auto ts = rec.timestamp; + mem_helper.fill( + KECCAKF_SLICE(mem_oc.register_aux_cols[0].base), + rec.register_aux_cols[0].prev_timestamp, + ts + ); + ts++; + + // Buffer reads (50 words of 4 bytes each) + for (auto t = 0u; t < NUM_BUFFER_WORDS; t++) { + mem_helper.fill( + KECCAKF_SLICE(mem_oc.buffer_bytes_read_aux_cols[t].base), + rec.buffer_read_aux_cols[t].prev_timestamp, + ts + ); + ts++; + } + + // Range check for buffer pointer + constexpr uint32_t MSL_RSHIFT = RV32_CELL_BITS * (RV32_REGISTER_NUM_LIMBS - 1); + constexpr uint32_t RV32_TOTAL_BITS = RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS; + bitwise_lookup.add_range( + (rec.buffer >> MSL_RSHIFT) << (RV32_TOTAL_BITS - pointer_max_bits), + (rec.buffer >> MSL_RSHIFT) << (RV32_TOTAL_BITS - pointer_max_bits) + ); + } else { + mem_helper.fill_zero(KECCAKF_SLICE(mem_oc.register_aux_cols[0].base)); + for (auto t = 0u; t < NUM_BUFFER_WORDS; t++) { + mem_helper.fill_zero(KECCAKF_SLICE(mem_oc.buffer_bytes_read_aux_cols[t].base)); + } + } + + // Fill the buffer writes + if (round_idx == NUM_ROUNDS - 1) { + auto write_ts = rec.timestamp + 1 + NUM_BUFFER_WORDS; + for (auto t = 0u; t < NUM_BUFFER_WORDS; t++) { + mem_helper.fill( + KECCAKF_SLICE(mem_oc.buffer_bytes_write_aux_cols[t].base), + rec.buffer_write_aux_cols[t].prev_timestamp, + write_ts + ); + KECCAKF_WRITE_ARRAY(mem_oc.buffer_bytes_write_aux_cols[t].prev_data, + rec.buffer_write_aux_cols[t].prev_data); + write_ts++; + } + } else { + for (auto t = 0u; t < NUM_BUFFER_WORDS; t++) { + KECCAKF_FILL_ZERO(mem_oc.buffer_bytes_write_aux_cols[t]); + } + } + } else { + // inner rows are filled above. Ensure export flag is 0 + KECCAKF_WRITE(inner._export, Fp::zero()); + row.fill_zero( + COL_INDEX(KeccakfVmCols, preimage_state_hi), + sizeof(KeccakfVmCols) - COL_INDEX(KeccakfVmCols, preimage_state_hi) + ); + } + + prev_round_row = row; + } +} + +#undef KECCAKF_WRITE +#undef KECCAKF_WRITE_ARRAY +#undef KECCAKF_FILL_ZERO +#undef KECCAKF_SLICE + +extern "C" int _keccakf_tracegen( + Fp *d_trace, + size_t height, + size_t width, + DeviceBufferConstView d_records, + uint32_t *d_range_checker_ptr, + uint32_t range_checker_num_bins, + uint32_t *d_bitwise_lookup_ptr, + size_t bitwise_num_bits, + uint32_t pointer_max_bits, + uint32_t timestamp_max_bits +) { + assert((height & (height - 1)) == 0); + assert(width == sizeof(KeccakfVmCols)); + + uint32_t num_records = d_records.len(); + uint32_t blocks_to_fill = div_ceil(height, uint32_t(NUM_ROUNDS)); + + auto [grid, block] = kernel_launch_params(blocks_to_fill, 256); + keccakf_tracegen<<>>( + d_trace, + height, + num_records, + blocks_to_fill, + d_records, + d_range_checker_ptr, + range_checker_num_bins, + d_bitwise_lookup_ptr, + bitwise_num_bits, + pointer_max_bits, + timestamp_max_bits + ); + return CHECK_KERNEL(); +} diff --git a/extensions/new-keccak256/circuit/src/cuda/cuda_abi.rs b/extensions/new-keccak256/circuit/src/cuda/cuda_abi.rs index 62e4289ca9..6592c96b10 100644 --- a/extensions/new-keccak256/circuit/src/cuda/cuda_abi.rs +++ b/extensions/new-keccak256/circuit/src/cuda/cuda_abi.rs @@ -50,3 +50,48 @@ pub mod xorin { )) } } + +pub mod keccakf { + use super::*; + + extern "C" { + fn _keccakf_tracegen( + d_trace: *mut F, + height: usize, + width: usize, + d_records: DeviceBufferView, + d_range_checker: *mut u32, + range_checker_num_bins: u32, + d_bitwise_lookup: *const u32, + bitwise_num_bits: usize, + pointer_max_bits: u32, + timestamp_max_bits: u32, + ) -> i32; + } + + #[allow(clippy::too_many_arguments)] + pub unsafe fn tracegen( + d_trace: &DeviceBuffer, + height: usize, + d_records: &DeviceBuffer, + d_range_checker: &DeviceBuffer, + d_bitwise_lookup: &DeviceBuffer, + bitwise_num_bits: usize, + pointer_max_bits: u32, + timestamp_max_bits: u32, + ) -> Result<(), CudaError> { + assert!(height.is_power_of_two() || height == 0); + CudaError::from_result(_keccakf_tracegen( + d_trace.as_mut_ptr(), + height, + d_trace.len() / height, + d_records.view(), + d_range_checker.as_mut_ptr() as *mut u32, + d_range_checker.len() as u32, + d_bitwise_lookup.as_mut_ptr() as *mut u32, + bitwise_num_bits, + pointer_max_bits, + timestamp_max_bits, + )) + } +} diff --git a/extensions/new-keccak256/circuit/src/cuda/mod.rs b/extensions/new-keccak256/circuit/src/cuda/mod.rs index c23b046996..8b4eff2ea7 100644 --- a/extensions/new-keccak256/circuit/src/cuda/mod.rs +++ b/extensions/new-keccak256/circuit/src/cuda/mod.rs @@ -12,7 +12,13 @@ use openvm_cuda_common::copy::MemCopyH2D; use openvm_instructions::riscv::RV32_CELL_BITS; use openvm_stark_backend::{prover::types::AirProvingContext, Chip}; -use crate::xorin::{columns::NUM_XORIN_VM_COLS, trace::XorinVmRecordHeader}; +use crate::{ + keccakf::{ + columns::{NUM_KECCAKF_VM_COLS, NUM_ROUNDS}, + trace::KeccakfVmRecordHeader, + }, + xorin::{columns::NUM_XORIN_VM_COLS, trace::XorinVmRecordHeader}, +}; mod cuda_abi; @@ -56,3 +62,45 @@ impl Chip for XorinVmChipGpu { AirProvingContext::simple_no_pis(d_trace) } } + +#[derive(new)] +pub struct KeccakfVmChipGpu { + pub range_checker: Arc, + pub bitwise_lookup: Arc>, + pub pointer_max_bits: usize, + pub timestamp_max_bits: u32, +} + +impl Chip for KeccakfVmChipGpu { + fn generate_proving_ctx(&self, arena: DenseRecordArena) -> AirProvingContext { + const RECORD_SIZE: usize = size_of::(); + let records = arena.allocated(); + if records.is_empty() { + return get_empty_air_proving_ctx::(); + } + debug_assert_eq!(records.len() % RECORD_SIZE, 0); + + let num_records = records.len() / RECORD_SIZE; + let trace_width = NUM_KECCAKF_VM_COLS; + let trace_height = next_power_of_two_or_zero(num_records * NUM_ROUNDS); + + let d_records = records.to_device().unwrap(); + let d_trace = DeviceMatrix::::with_capacity(trace_height, trace_width); + + unsafe { + cuda_abi::keccakf::tracegen( + d_trace.buffer(), + trace_height, + &d_records, + &self.range_checker.count, + &self.bitwise_lookup.count, + RV32_CELL_BITS, + self.pointer_max_bits as u32, + self.timestamp_max_bits, + ) + .unwrap(); + } + + AirProvingContext::simple_no_pis(d_trace) + } +} diff --git a/extensions/new-keccak256/circuit/src/extension/cuda.rs b/extensions/new-keccak256/circuit/src/extension/cuda.rs index 4b57ef4172..90339da719 100644 --- a/extensions/new-keccak256/circuit/src/extension/cuda.rs +++ b/extensions/new-keccak256/circuit/src/extension/cuda.rs @@ -12,7 +12,7 @@ use openvm_rv32im_circuit::Rv32ImGpuProverExt; use openvm_stark_sdk::config::baby_bear_poseidon2::BabyBearPoseidon2Config; use super::*; -use crate::cuda::XorinVmChipGpu; +use crate::cuda::{KeccakfVmChipGpu, XorinVmChipGpu}; pub struct NewKeccak256GpuProverExt; @@ -40,6 +40,13 @@ impl VmProverExtension()?; + let keccakf_chip = KeccakfVmChipGpu::new( + range_checker, + bitwise_lu, + pointer_max_bits, + timestamp_max_bits as u32, + ); + inventory.add_executor_chip(keccakf_chip); Ok(()) } diff --git a/extensions/new-keccak256/circuit/src/keccakf/tests.rs b/extensions/new-keccak256/circuit/src/keccakf/tests.rs index a3b41f91a1..489ba6fa55 100644 --- a/extensions/new-keccak256/circuit/src/keccakf/tests.rs +++ b/extensions/new-keccak256/circuit/src/keccakf/tests.rs @@ -17,12 +17,15 @@ use openvm_new_keccak256_transpiler::KeccakfOpcode; use openvm_stark_backend::p3_field::FieldAlgebra; use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng}; use rand::rngs::StdRng; +#[cfg(feature = "cuda")] +use rand::Rng; use super::KeccakfVmFiller; use crate::keccakf::air::KeccakfVmAir; type F = BabyBear; type Harness = TestChipHarness>; +const MAX_TRACE_ROWS: usize = 4096; use crate::keccakf::{KeccakfVmChip, KeccakfVmExecutor}; @@ -71,8 +74,6 @@ fn create_test_harness( tester.address_bits(), ); - const MAX_TRACE_ROWS: usize = 4096; - let harness = Harness::with_capacity(executor, air, chip, MAX_TRACE_ROWS); (harness, (bitwise_chip.air, bitwise_chip)) @@ -147,3 +148,192 @@ fn keccakf_chip_positive_tests() { tester.simple_test().expect("Verification failed"); } } + +// //////////////////////////////////////////////////////////////////////////////////// +// CUDA TESTS +// //////////////////////////////////////////////////////////////////////////////////// +#[cfg(feature = "cuda")] +use openvm_circuit::arch::{ + testing::{default_bitwise_lookup_bus, GpuChipTestBuilder, GpuTestChipHarness}, + DenseRecordArena, +}; + +#[cfg(feature = "cuda")] +use crate::{cuda::KeccakfVmChipGpu, keccakf::trace::KeccakfVmRecordMut}; + +#[cfg(feature = "cuda")] +type GpuHarness = + GpuTestChipHarness>; + +#[cfg(feature = "cuda")] +fn create_cuda_harness(tester: &GpuChipTestBuilder) -> GpuHarness { + let bitwise_bus = default_bitwise_lookup_bus(); + let dummy_bitwise_chip = Arc::new(BitwiseOperationLookupChip::::new( + bitwise_bus, + )); + + let (air, executor, cpu_chip) = create_harness_fields( + tester.execution_bridge(), + tester.memory_bridge(), + dummy_bitwise_chip, + tester.dummy_memory_helper(), + tester.address_bits(), + ); + + let gpu_chip = KeccakfVmChipGpu::new( + tester.range_checker(), + tester.bitwise_op_lookup(), + tester.address_bits(), + tester.timestamp_max_bits() as u32, + ); + + GpuTestChipHarness::with_capacity(executor, air, gpu_chip, cpu_chip, MAX_TRACE_ROWS) +} + +#[cfg(feature = "cuda")] +fn cuda_set_and_execute( + tester: &mut GpuChipTestBuilder, + executor: &mut KeccakfVmExecutor, + arena: &mut DenseRecordArena, + rng: &mut StdRng, +) { + use openvm_circuit::arch::testing::memory::gen_pointer; + + const KECCAK_STATE_BYTES: usize = 200; + + let buffer_reg = gen_pointer(rng, 4); + let buffer_ptr = gen_pointer(rng, KECCAK_STATE_BYTES); + + tester.write( + 1, + buffer_reg, + buffer_ptr.to_le_bytes().map(F::from_canonical_u8), + ); + + let state_data: Vec = (0..KECCAK_STATE_BYTES).map(|_| rng.gen()).collect(); + for (i, chunk) in state_data.chunks(4).enumerate() { + let mut word = [F::ZERO; 4]; + for (j, &byte) in chunk.iter().enumerate() { + word[j] = F::from_canonical_u8(byte); + } + tester.write(2, buffer_ptr + i * 4, word); + } + + let instruction = Instruction::from_usize( + KeccakfOpcode::KECCAKF.global_opcode(), + [buffer_reg, 0, 0, 1, 2], + ); + + tester.execute(executor, arena, &instruction); +} + +#[cfg(feature = "cuda")] +#[test] +fn test_keccakf_cuda_tracegen() { + let mut rng = create_seeded_rng(); + let mut tester = + GpuChipTestBuilder::default().with_bitwise_op_lookup(default_bitwise_lookup_bus()); + + let mut harness = create_cuda_harness(&tester); + + let num_ops: usize = 3; + for _ in 0..num_ops { + cuda_set_and_execute( + &mut tester, + &mut harness.executor, + &mut harness.dense_arena, + &mut rng, + ); + } + + harness + .dense_arena + .get_record_seeker::() + .transfer_to_matrix_arena(&mut harness.matrix_arena); + + tester + .build() + .load_gpu_harness(harness) + .finalize() + .simple_test() + .unwrap(); +} + +#[cfg(feature = "cuda")] +#[test] +fn test_keccakf_cuda_tracegen_single() { + let mut rng = create_seeded_rng(); + let mut tester = + GpuChipTestBuilder::default().with_bitwise_op_lookup(default_bitwise_lookup_bus()); + + let mut harness = create_cuda_harness(&tester); + + cuda_set_and_execute( + &mut tester, + &mut harness.executor, + &mut harness.dense_arena, + &mut rng, + ); + + harness + .dense_arena + .get_record_seeker::() + .transfer_to_matrix_arena(&mut harness.matrix_arena); + + tester + .build() + .load_gpu_harness(harness) + .finalize() + .simple_test() + .unwrap(); +} + +#[cfg(feature = "cuda")] +#[test] +fn test_keccakf_cuda_tracegen_zero_state() { + let mut rng = create_seeded_rng(); + let mut tester = + GpuChipTestBuilder::default().with_bitwise_op_lookup(default_bitwise_lookup_bus()); + + let mut harness = create_cuda_harness(&tester); + + use openvm_circuit::arch::testing::memory::gen_pointer; + + const KECCAK_STATE_BYTES: usize = 200; + + let buffer_reg = gen_pointer(&mut rng, 4); + let buffer_ptr = gen_pointer(&mut rng, KECCAK_STATE_BYTES); + + tester.write( + 1, + buffer_reg, + buffer_ptr.to_le_bytes().map(F::from_canonical_u8), + ); + + for i in 0..(KECCAK_STATE_BYTES / 4) { + tester.write(2, buffer_ptr + i * 4, [F::ZERO; 4]); + } + + let instruction = Instruction::from_usize( + KeccakfOpcode::KECCAKF.global_opcode(), + [buffer_reg, 0, 0, 1, 2], + ); + + tester.execute( + &mut harness.executor, + &mut harness.dense_arena, + &instruction, + ); + + harness + .dense_arena + .get_record_seeker::() + .transfer_to_matrix_arena(&mut harness.matrix_arena); + + tester + .build() + .load_gpu_harness(harness) + .finalize() + .simple_test() + .unwrap(); +} diff --git a/extensions/new-keccak256/circuit/src/keccakf/trace.rs b/extensions/new-keccak256/circuit/src/keccakf/trace.rs index 43390ec9d9..17ad059e13 100644 --- a/extensions/new-keccak256/circuit/src/keccakf/trace.rs +++ b/extensions/new-keccak256/circuit/src/keccakf/trace.rs @@ -1,5 +1,8 @@ use core::convert::TryInto; -use std::{borrow::BorrowMut, mem::size_of}; +use std::{ + borrow::BorrowMut, + mem::{align_of, size_of}, +}; use openvm_circuit::{ arch::*, @@ -70,7 +73,6 @@ impl<'a> CustomBorrow<'a, KeccakfVmRecordMut<'a>, KeccakfVmRecordLayout> for [u8 } } -// todo: check with Ayush if this is correct impl SizedRecord for KeccakfVmRecordMut<'_> { fn size(_layout: &KeccakfVmRecordLayout) -> usize { size_of::() From c9de2da0268fb0386975f5f20e9439ba52bae586 Mon Sep 17 00:00:00 2001 From: GunaDD Date: Fri, 27 Feb 2026 21:48:07 +0000 Subject: [PATCH 04/78] perf: new keccak run reth (#2328) Closes INT-5779 --------- Co-authored-by: Ayush Shukla --- Cargo.toml | 1 + crates/toolchain/transpiler/src/extension.rs | 1 + examples/new-keccak/Cargo.toml | 23 ++ examples/new-keccak/openvm.toml | 4 + examples/new-keccak/src/main.rs | 171 ++++++++++++++ .../cuda/include/keccakf/p3_generation.cuh | 3 + .../new-keccak256/circuit/cuda/src/keccakf.cu | 1 + .../circuit/src/keccakf/execution.rs | 16 +- extensions/new-keccak256/guest/src/lib.rs | 220 +++++++++++++++--- guest-libs/new_keccak256/Cargo.toml | 16 ++ guest-libs/new_keccak256/src/lib.rs | 41 ++++ 11 files changed, 457 insertions(+), 40 deletions(-) create mode 100644 examples/new-keccak/Cargo.toml create mode 100644 examples/new-keccak/openvm.toml create mode 100644 examples/new-keccak/src/main.rs create mode 100644 guest-libs/new_keccak256/Cargo.toml create mode 100644 guest-libs/new_keccak256/src/lib.rs diff --git a/Cargo.toml b/Cargo.toml index 555dbb4a31..3987b783c4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -70,6 +70,7 @@ members = [ "guest-libs/k256/", "guest-libs/p256/", "guest-libs/keccak256/", + "guest-libs/new_keccak256/", "guest-libs/pairing/", "guest-libs/ruint/", "guest-libs/sha2/", diff --git a/crates/toolchain/transpiler/src/extension.rs b/crates/toolchain/transpiler/src/extension.rs index cb413185bf..fd4a220f4d 100644 --- a/crates/toolchain/transpiler/src/extension.rs +++ b/crates/toolchain/transpiler/src/extension.rs @@ -21,6 +21,7 @@ pub trait TranspilerExtension { } } +#[derive(Debug)] pub struct TranspilerOutput { pub instructions: Vec>>, pub used_u32s: usize, diff --git a/examples/new-keccak/Cargo.toml b/examples/new-keccak/Cargo.toml new file mode 100644 index 0000000000..a42de61ace --- /dev/null +++ b/examples/new-keccak/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "new-keccak-example" +version = "0.0.0" +edition = "2021" + +[workspace] +members = [] + +[dependencies] +openvm = { git = "https://github.com/openvm-org/openvm.git", features = [ + "std", +] } +openvm-new-keccak256-guest = { path = "../../extensions/new-keccak256/guest" } +hex-literal = "1.1.0" + +[features] +default = [] + +# remove this if copying example outside of monorepo +[patch."https://github.com/openvm-org/openvm.git"] +openvm = { path = "../../crates/toolchain/openvm" } +openvm-keccak256 = { path = "../../guest-libs/keccak256" } + diff --git a/examples/new-keccak/openvm.toml b/examples/new-keccak/openvm.toml new file mode 100644 index 0000000000..61b2a0a406 --- /dev/null +++ b/examples/new-keccak/openvm.toml @@ -0,0 +1,4 @@ +[app_vm_config.rv32i] +[app_vm_config.rv32m] +[app_vm_config.io] +[app_vm_config.new_keccak] \ No newline at end of file diff --git a/examples/new-keccak/src/main.rs b/examples/new-keccak/src/main.rs new file mode 100644 index 0000000000..fc8ad8c1a0 --- /dev/null +++ b/examples/new-keccak/src/main.rs @@ -0,0 +1,171 @@ +// [!region imports] +// [!endregion imports] + +// [!region main] +#[cfg(target_os = "zkvm")] +use hex_literal::hex; +use openvm as _; + +/// Vector of test cases for Keccak-256 hash function. +/// Each test case consists of (input_bytes, expected_hash_result). +#[cfg(target_os = "zkvm")] +const KECCAK_TEST_CASES: &[(&[u8], [u8; 32])] = &[ + ( + b"", + hex!("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"), + ), + ( + b"hello world", + hex!("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad"), + ), + ( + &hex!("91376f5774419e518ced240cfb7ce0fbb835d80c609f7db3736a8474381c23cb7dde504e009f8d9656351a22ff18172046cbd80e074ee99ac7cc95f0daf32c35d4a0b41932d6efee42790e0298fa3d8f0d362f79008e9bd9989b355470e714aebd0d5936bbbfcc11d4"), + hex!("bcd603061b992b3c881b2418a691c4a77606f4e9ff4fb1e57bd64118430f9e64"), + ), + ( + &hex!("2e8b467f65bb7a367e17b0f1ea54e20cfcd5f581bb7a9e937b1d48e289cb8477a4aa081031666529e3659782945bdadc3524e069b1e50da71caa04e681e986869325ba36e2fd"), + hex!("f5856263b398ac1b9682363fd87f3f47d96c213d9a27ca84f42ccdc69c04b600"), + ), + ( + &hex!("8c7e1ae8d32e176dbb4c25dfbfa4edf2c642"), + hex!("1d673221b76ffb970ef7abec781e7e8678ef7535b95ffc9dd7e7b9ebb472e155"), + ), + ( + &hex!("1f483a587db0a0152083be135d4418a3387a9d223a3329b8044ac6b97dfb754718cec558ab6cf6fb0f46b344442326b7d639ec7b81e0eac95340bb3e96860368961a82d98f35eb893dd848da52e7a7cc3d970657592071da1ea70ce99c995d2bdf4f9f764f2ca277705843f0800e7a97"), + hex!("b83494263c50b8444ae444d436ed9a30065ce869342d9c3a5fe319ed323b3ac6"), + ), + ( + &hex!("a2d386e126c7"), + hex!("d94338cbf5a5505c6079f381bc9c5f895a93911ea906d84ccf1c876ae24f31f9"), + ), + ( + &hex!("590307764a0f2294f82301735054adc163cd1ee5c582fc3d173f54ba7c5f6dbe72aa30ce8007657d7bafb9d083e80574b3d3a69469ed43cf61cdd8bb2d2762a0861affae378c052dad637707f420cfbc1dbbf7"), + hex!("03c2229015d2693d8448b1761c04ae80cee6e11e046ae2d3ebeb4291531abf8d"), + ), + ( + &hex!("8b0d83e9b5d1770faa1f17195a9c8fa74bd5109e50ba74f752d1a40189b0f2d7dd8abe3b0c9648f67f413f584ccea0f69fa2346460dd97a28acb1d0ba8618398817c76be800cebce0d701595ac0b5f422775c504"), + hex!("3390695701398af69128d9d8fc4a8a1c43c340e65b673a896dd40360c4c816f9"), + ), + ( + &hex!("2f80c45d979eb3f7"), + hex!("12292d148143f86721726f656ae496b95d113dd669f78e202ac2cca9bca8304c"), + ), + ( + &hex!("d43a4df4bf208321971cabff80d9ae2bf619bfac98004b729e6415a481bf70089a39ad5019f21d4bec3dd8f2598cf9fccc6a5fcd5ac79d516d1fdbb123b4bda96021130b44fde0633c50ae85c376db29b551edb16d5fac451b0cbea06356f80661b011f3904e3c62ea9f8ad3773da5"), + hex!("1cf0c4b5afb89f146d9b09d878d4afc00aa8a56037ff8602071ce989f3e58695"), + ), + ( + &hex!("72ba3368324d809df9a9d97e251e00a6dfb3e70fca2892e63ee3df6d5b08e01e63c9db23296586bf9a3ee78a68"), + hex!("7d79f8ed4fb4cd728d9ca383536f81f025d8e246504f5e9d53cbfa05006abad1"), + ), + ( + &hex!("6b0bd4f931c1d8861f5ccea87642791dfa74fe8544175fb63451ee0adcfcc13f3040ab8f7525892fcd7da15ce23da3b2f21a6e55dca0765daeb2407acff87c03b7d1a13d3acd77390d6055fde3eeeeef381c04cd41d5c83bd3ef7e494a8391de3a6d8f1f1941e9fb217bd8"), + hex!("9550d5094b85b0d1f01209b71c338114a09aad20cb33b7d444c31c1e1473716b"), + ), + ( + &hex!("494c7a2642a3d6b3943605cbc30140aaf622f3a34338fdff183e5ef6bc41389d6f095056760dd144f0a14a2b21ca5b487cab0a3ea23a86"), + hex!("a03c900c3ebf6c4037f8351b1a144720a04a105e067707c5cbac79aade25fb56"), + ), + ( + &hex!("4d91a527e6bd5ea378c5ba9516b8b34cc99dd7c52ed03b54623f1ce4ca6d886b37c95dde605fb7ab8274f21488229bd9169e760703747ae9d23699f77db579f1ad31ef8dbdb57cce0de326db8bbc6550a5cc5fe09c8486ef24ef023b4f2f8aa32e390ede54eb3d6123fbc08a8e591d6cad80c3fe52821da10136cce9"), + hex!("5b47a38b57bfe74950e59da3c1918d94293d4250b8991a3324ec42160b3d402c"), + ), + ( + &hex!("9e60df2407f3057680e332f32cafb32e195aa13c275c1571c4877da2f26b00ed139f808310e9e4a800fd950ddbb3dc"), + hex!("52474f4d926fa0599845e38ab4a9529737bd42f0d46784d5f584c7ab063c18f7"), + ), + ( + &hex!("712b9a6afe96f461e31092ffe38d74288cb1424e876a3592bca03dbc9c3a57"), + hex!("3b0a1d9106e06e1a3de754fc90583862e82ec92f81edf261e5a12108d46a69bf"), + ), + ( + &hex!("9feff865dad6dc06e095d330f363178b71e56fd1b86fcac2249aed2a84a82fa4d596d6f4142b71ec034f543d69bdbc47404b8146203b215ce3bce1a8c4"), + hex!("63fe4b8bd1e0d823b5d7b6ab722c5b5dfcfe472da792e8974a38cc81fdd53777"), + ), + ( + &hex!("0213643f8bbb0aa1e9528f7f117c050cbd9d8709cc3672850363c0ddef5be2001c"), + hex!("4bf5a88bb8954c539620033214e1b1e34306639417c7b7683a4aa825f5c004bb"), + ), + ( + &hex!("a79eca9f55b0f13c533ca91e71495f65f642ab91224bbe664ff59b1b3362ba51"), + hex!("a710b4cbdc60423e7ab1773d6731ceb3ea0157cff6df39a1b8c1410acf8c0075"), + ), + ( + &hex!("4cc8abc63b48a1a653c3a52801394db7ae608249d67006329fd259ec203a1ed836f384ed88b6dff310948c9f29f7c240fc49d705299e8aec3239e35c998c2befbd8997e59c8581"), + hex!("ba972e77578147700ba7539b89e53fc40bdd9893b3cccef0bcf1a2f7ef65c4bc"), + ), + ( + &hex!("f66cd0cd9a55d6c2046dd7df0cf6496a876d165d0de8f639140cafa2155abc2426cc55258e0db47938d262472558f4eb63e98cfd3725296dc1de7c57d9d148194c2ac3b9d0c267814578bfc66c46da093bc59f132b41076865659d548ed3"), + hex!("54ea328ab976e794e653b82d5cfbc0f20305e6e33a97bf4e8764d06bbed2753c"), + ), + ( + &hex!("fe7eee2bcc4071ab2bcd801d805cc082bc0d7781713941e06e4819e09748a5692c945f3b3b0b632b50bce1"), + hex!("57a655827352ff95ce21082515add7f6fb0f51b457e338a1cfd7a5912a2c30a0"), + ), + ( + &hex!("2cf005de4865b6321e8995f38825353e64e34f7ecaedd9b5f39ee41067e9e63f38618985d015b1fb89be1140e249ac92d0b8f273"), + hex!("0ba80a1c481facdec27552c2d8382467fb97f864a6c915e2882045a995dd452a"), + ), + ( + &hex!("edee326b959740e515dd8a0ed9ced665d782b50bda2af634189def905b59d3a9ac635e1d96c670eaf28675b0071db0d86131088fad00a0b80da10dd1259692d17dc9af43a5e3f40185e88776be68bdf2a3ddeb7c9726e5bde8e4d14bcf6e991d142047"), + hex!("295d1a5a86a4ea5cc3d7c5860c3fa6069374a610e5f9cda1e643b4f01e957752"), + ), + ( + &hex!("8703f576434a9ec235904e106991aa447b1d4e715fd1fe2e5aa2e3aa950291d624d97420dc9eec10d76cdf23ae189c995760f339c20bbb5e"), + hex!("7ebb76c5e9669e9bceb867560682a653e600e116af83777ed6e71fb4b28f1b48"), + ), + ( + &hex!("e8dffb080d61e60561a5f2e44db8e65c4ab134f3283411b374da96cc6a94408871de72d5b8e39aae83c81fa7b31027a8da64915010eb688a72f5f605aab2b77d67baa1f90056281e92fa3031108e2061a1b110f4d0d62ff91f956f977cc504a68337d7b01d2ff6caadc57e"), + hex!("e85f50155c3abf4d0cabe2a62d9af075c163600fb0c12e1bc3d004ce4d25bd13"), + ), + ( + &hex!("5de9ef34a6f71cbe1780ff29816f7b26f574f0ea5d6adeaff6d9c78e08440ce9c3a5597e31693e0d2a89b1b84bf3b8c8cda9c13b7abb3bf8b2cf0cb3410d9df1e6fd4765546ce8f4e1d821aa7253fdf044437a65eca5d7393716"), + hex!("3de18f83084b4ced8b0a261f80225b52cf9c27950dff768bb2e0ab1a8f015fe2"), + ), + ( + &hex!("8278f74015c08ea408c53446d4e9364eddc6c37cf2a03b54df9a9122095eef5f3812d03afa4f7c52ba937f73968e3074ed5ddd7a6439916b8c4a6bb821896852bbe1430be00f9da2244d980834696f949232facdc0e214f52f308267"), + hex!("1f60d8c4bfd1cf910fd7e5a5ecd3e2996aee20d7c40c1f6d43225d832b937b0a"), + ), + ( + &hex!("65063a451690b64af8901e2cc0414abbe0e92c6789c721577bf975b4cd58771086ad8f6e2899bf45e7f23e76a299accae8782dd1f47fa449d7cc7f06ced46bd7bde7ce5f61e594485a6489edd5dc96ad79c5425960297b028f9669fb827a"), + hex!("30d3360dbb001c115a287da3eac988b1a925b2ab607ba1e1f909a64eef1c90e4"), + ), + ( + &hex!("41c7813c97"), + hex!("be714f64489c82a8fc1008db96c096bd72b74ca142f8682c19aa5d7b8d575d31"), + ), + ( + &hex!("7a9fa65269a9af8e994849b91c58c9ad2b4da115a96514a02200d931c359e4a26ff54c3937ed061a1e58e7cf2c1b1dd72c42049081fe28dd59caaf09447c403c167265d5e121e367d41fc87c3c1c9a81c582ee826cfe"), + hex!("41ca49571619a8b82cd7bff0e317493eb70d8dfaee994702c3c1ad80b794c863"), + ), + ( + &hex!("d8b70735a52277d4e361a68b884abf5118756c5685dd0af29e8274b94ab37bc126dbb8e97735cf"), + hex!("a43a2a0321aac66ed239bc40518f9947ae4480bc70d4b1c23bbe5d1a367e1cd1"), + ), + ( + &hex!("190dcb4311e6c20f303e939bea29a0f42856735821743d92579d1d2e41b0925304e08be11e978aa760993083bf546a31d8e1877b405f14f3bdcae789ed5d639e51ac846ab2390ae9552e733a7233"), + hex!("f5392ee04880a0bd1336f30ee79b5c014a90728bf29f422dabb4ae6bc972f30b"), + ), +]; +// todo: call the forked tiny keccak library once that is updated instead of directly calling the +// keccak256_guest native functions +pub fn main() { + #[cfg(target_os = "zkvm")] + { + for &(input, expected) in KECCAK_TEST_CASES { + let mut input = input.to_vec(); + let mut output = [0u8; 32]; + openvm_new_keccak256_guest::native_keccak256( + input.as_ptr(), + input.len(), + output.as_mut_ptr(), + ); + assert_eq!(output, expected); + } + + // let mut expected_output = [0u8; 32]; + // openvm_keccak256::keccak256(&buffer); + // assert_eq!(output, expected_output); + } +} +// [!endregion main] diff --git a/extensions/new-keccak256/circuit/cuda/include/keccakf/p3_generation.cuh b/extensions/new-keccak256/circuit/cuda/include/keccakf/p3_generation.cuh index b736c1262b..7f8c4a4f20 100644 --- a/extensions/new-keccak256/circuit/cuda/include/keccakf/p3_generation.cuh +++ b/extensions/new-keccak256/circuit/cuda/include/keccakf/p3_generation.cuh @@ -4,6 +4,7 @@ #include "primitives/trace_access.h" #include "primitives/utils.cuh" +namespace new_keccak { using namespace keccakf; __device__ __constant__ uint8_t R[5][5] = { @@ -90,3 +91,5 @@ __device__ void generate_trace_row_for_round( state_limbs = reinterpret_cast(¤t_state[0][0]); COL_WRITE_ARRAY(row, KeccakfVmCols, inner.a_prime_prime_prime_0_0_limbs, state_limbs); } + +} // namespace new_keccak diff --git a/extensions/new-keccak256/circuit/cuda/src/keccakf.cu b/extensions/new-keccak256/circuit/cuda/src/keccakf.cu index 9e1b315eee..3da45839e0 100644 --- a/extensions/new-keccak256/circuit/cuda/src/keccakf.cu +++ b/extensions/new-keccak256/circuit/cuda/src/keccakf.cu @@ -10,6 +10,7 @@ using namespace keccakf; using namespace riscv; +using namespace new_keccak; #define KECCAKF_WRITE(FIELD, VALUE) COL_WRITE_VALUE(row, KeccakfVmCols, FIELD, VALUE) #define KECCAKF_WRITE_ARRAY(FIELD, VALUES) COL_WRITE_ARRAY(row, KeccakfVmCols, FIELD, VALUES) diff --git a/extensions/new-keccak256/circuit/src/keccakf/execution.rs b/extensions/new-keccak256/circuit/src/keccakf/execution.rs index 16dacc692d..3098c91c20 100644 --- a/extensions/new-keccak256/circuit/src/keccakf/execution.rs +++ b/extensions/new-keccak256/circuit/src/keccakf/execution.rs @@ -194,11 +194,23 @@ unsafe fn execute_e12_impl( + RV32_MEMORY_AS, + buffer + (i * KECCAK_WORD_SIZE) as u32, + &write_chunk, + ); + } + } let pc = exec_state.pc(); exec_state.set_pc(pc.wrapping_add(DEFAULT_PC_STEP)); diff --git a/extensions/new-keccak256/guest/src/lib.rs b/extensions/new-keccak256/guest/src/lib.rs index 8f0655dd14..55a22cab59 100644 --- a/extensions/new-keccak256/guest/src/lib.rs +++ b/extensions/new-keccak256/guest/src/lib.rs @@ -9,56 +9,57 @@ pub const OPCODE: u8 = 0x0b; pub const KECCAKF_FUNCT3: u8 = 0b100; pub const KECCAKF_FUNCT7: u8 = 0; pub const XORIN_FUNCT3: u8 = 0b100; -pub const XORIN_FUNCT7: u8 = 1; +pub const XORIN_FUNCT7: u8 = 2; pub const KECCAK_WIDTH_BYTES: usize = 200; +pub const KECCAK_RATE: usize = 136; +pub const KECCAK_OUTPUT_SIZE: usize = 32; +pub const MIN_ALIGN: usize = 4; + +#[cfg(target_os = "zkvm")] +#[repr(align(4))] +struct AlignedStackBuf { + data: [u8; N], +} #[cfg(target_os = "zkvm")] -#[inline(always)] #[no_mangle] -pub extern "C" fn native_xorin(mut buffer: *mut u8, input: *const u8, len: usize) { - const MIN_ALIGN: usize = 4; +pub extern "C" fn native_xorin(buffer: *mut u8, input: *const u8, len: usize) { + if len == 0 { + return; + } unsafe { - if buffer as usize % MIN_ALIGN != 0 { - let aligned_buffer = AlignedBuf::new(buffer, len, MIN_ALIGN); - if input as usize % MIN_ALIGN != 0 { - let aligned_input = AlignedBuf::new(input, len, MIN_ALIGN); - __native_xorin(aligned_buffer.ptr, aligned_input.ptr, len); - core::ptr::copy_nonoverlapping(aligned_buffer.ptr as *const u8, buffer, len); - } else { - __native_xorin(aligned_buffer.ptr, input, len); - core::ptr::copy_nonoverlapping(aligned_buffer.ptr as *const u8, buffer, len); - } + let aligned_buffer; + let aligned_input; + + let actual_buffer = if buffer as usize % MIN_ALIGN == 0 { + buffer } else { - if input as usize % MIN_ALIGN != 0 { - let aligned_input = AlignedBuf::new(input, len, MIN_ALIGN); - __native_xorin(buffer, aligned_input.ptr, len); - } else { - __native_xorin(buffer, input, len); - } + aligned_buffer = AlignedBuf::new(buffer, len, MIN_ALIGN); + aligned_buffer.ptr }; - } -} -#[cfg(target_os = "zkvm")] -#[inline(always)] -fn __native_xorin(mut buffer: *mut u8, input: *const u8, len: usize) { - openvm_platform::custom_insn_r!( - opcode = OPCODE, - funct3 = XORIN_FUNCT3, - funct7 = XORIN_FUNCT7, - rd = InOut buffer, - rs1 = In input, - rs2 = In len - ); + let actual_input = if input as usize % MIN_ALIGN == 0 { + input + } else { + aligned_input = AlignedBuf::new(input, len, MIN_ALIGN); + aligned_input.ptr + }; + + __native_xorin(actual_buffer, actual_input, len); + + if buffer as usize % MIN_ALIGN != 0 { + core::ptr::copy_nonoverlapping(actual_buffer as *const u8, buffer, len); + } + } } #[cfg(target_os = "zkvm")] -#[inline(always)] #[no_mangle] -pub extern "C" fn native_keccakf(mut buffer: *mut u8) { - const MIN_ALIGN: usize = 4; +pub extern "C" fn native_keccakf(buffer: *mut u8) { unsafe { - if buffer as usize % MIN_ALIGN != 0 { + if buffer as usize % MIN_ALIGN == 0 { + __native_keccakf(buffer); + } else { let aligned_buffer = AlignedBuf::new(buffer, KECCAK_WIDTH_BYTES, MIN_ALIGN); __native_keccakf(aligned_buffer.ptr); core::ptr::copy_nonoverlapping( @@ -66,12 +67,155 @@ pub extern "C" fn native_keccakf(mut buffer: *mut u8) { buffer, KECCAK_WIDTH_BYTES, ); + } + } +} + +/// Native hook for keccak256 for use with `alloy-primitives` "native-keccak" feature. +/// +/// # Safety +/// +/// The VM accepts the preimage by pointer and length, and writes the +/// 32-byte hash. +/// - `bytes` must point to an input buffer at least `len` long. +/// - `output` must point to a buffer that is at least 32-bytes long. +/// +/// [`keccak256`]: https://en.wikipedia.org/wiki/SHA-3 +/// [`sha3`]: https://docs.rs/sha3/latest/sha3/ +/// [`tiny_keccak`]: https://docs.rs/tiny-keccak/latest/tiny_keccak/ +#[cfg(target_os = "zkvm")] +#[no_mangle] +pub extern "C" fn native_keccak256(bytes: *const u8, len: usize, output: *mut u8) { + // SAFETY: assuming safety assumptions of the inputs, we handle all cases where `bytes` or + // `output` are not aligned to 4 bytes. + unsafe { + let aligned_bytes; + let aligned_output; + + let actual_bytes = if len == 0 || bytes as usize % MIN_ALIGN == 0 { + bytes } else { - __native_keccakf(buffer); + aligned_bytes = AlignedBuf::new(bytes, len, MIN_ALIGN); + aligned_bytes.ptr }; + + let actual_output = if output as usize % MIN_ALIGN == 0 { + output + } else { + aligned_output = AlignedBuf::uninit(KECCAK_OUTPUT_SIZE, MIN_ALIGN); + aligned_output.ptr + }; + + keccak256_impl(actual_bytes, len, actual_output); + + if output as usize % MIN_ALIGN != 0 { + core::ptr::copy_nonoverlapping(actual_output as *const u8, output, KECCAK_OUTPUT_SIZE); + } + } +} + +#[cfg(target_os = "zkvm")] +#[inline(always)] +fn keccak_update( + buffer: &mut AlignedStackBuf, + input: *const u8, + len: usize, +) -> usize { + let buffer_ptr = buffer.data.as_mut_ptr(); + let mut offset = 0; + let mut remaining = len; + let input_aligned = input as usize % MIN_ALIGN == 0; + + // Absorb full blocks + while remaining >= KECCAK_RATE { + if input_aligned { + __native_xorin(buffer_ptr, unsafe { input.add(offset) }, KECCAK_RATE); + } else { + let mut block = AlignedStackBuf:: { + data: [0u8; KECCAK_RATE], + }; + unsafe { + core::ptr::copy_nonoverlapping( + input.add(offset), + block.data.as_mut_ptr(), + KECCAK_RATE, + ); + __native_xorin(buffer_ptr, block.data.as_ptr(), KECCAK_RATE); + } + } + unsafe { + __native_keccakf(buffer_ptr); + } + offset += KECCAK_RATE; + remaining -= KECCAK_RATE; + } + + // Handle remaining bytes + if remaining > 0 { + unsafe { + if input_aligned && remaining % MIN_ALIGN == 0 { + __native_xorin(buffer_ptr, input.add(offset), remaining); + } else { + let adjusted_len = remaining.next_multiple_of(MIN_ALIGN); + let mut padded_input = AlignedStackBuf:: { + data: [0u8; KECCAK_RATE], + }; + core::ptr::copy_nonoverlapping( + input.add(offset), + padded_input.data.as_mut_ptr(), + remaining, + ); + __native_xorin(buffer_ptr, padded_input.data.as_ptr(), adjusted_len); + } + } + } + + remaining +} + +#[cfg(target_os = "zkvm")] +#[inline(always)] +fn keccak_finalize( + buffer: &mut AlignedStackBuf, + remaining_len: usize, + output: *mut u8, +) { + // Apply Keccak padding (pad10*1) + buffer.data[remaining_len] ^= 0x01; + buffer.data[KECCAK_RATE - 1] ^= 0x80; + + // Final permutation + unsafe { + __native_keccakf(buffer.data.as_mut_ptr()); + + // Extract output + core::ptr::copy_nonoverlapping(buffer.data.as_ptr(), output, KECCAK_OUTPUT_SIZE); } } +#[cfg(target_os = "zkvm")] +#[inline(always)] +fn keccak256_impl(input: *const u8, len: usize, output: *mut u8) { + let mut buffer = AlignedStackBuf:: { + data: [0u8; KECCAK_WIDTH_BYTES], + }; + let remaining_len = keccak_update(&mut buffer, input, len); + keccak_finalize(&mut buffer, remaining_len, output); +} + +#[cfg(target_os = "zkvm")] +#[inline(always)] +fn __native_xorin(mut buffer: *mut u8, input: *const u8, len: usize) { + openvm_platform::custom_insn_r!( + opcode = OPCODE, + funct3 = XORIN_FUNCT3, + funct7 = XORIN_FUNCT7, + rd = InOut buffer, + rs1 = In input, + rs2 = In len + ); +} + #[cfg(target_os = "zkvm")] #[inline(always)] fn __native_keccakf(mut buffer: *mut u8) { diff --git a/guest-libs/new_keccak256/Cargo.toml b/guest-libs/new_keccak256/Cargo.toml new file mode 100644 index 0000000000..8bec1ea5a7 --- /dev/null +++ b/guest-libs/new_keccak256/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "openvm-new-keccak256" +description = "OpenVM library for keccak256" +version.workspace = true +edition.workspace = true +rust-version.workspace = true +authors.workspace = true +homepage.workspace = true +repository.workspace = true +license.workspace = true + +[dependencies] +openvm-new-keccak256-guest = { workspace = true } + +[target.'cfg(not(target_os = "zkvm"))'.dependencies] +tiny-keccak = { workspace = true } diff --git a/guest-libs/new_keccak256/src/lib.rs b/guest-libs/new_keccak256/src/lib.rs new file mode 100644 index 0000000000..f0ed185199 --- /dev/null +++ b/guest-libs/new_keccak256/src/lib.rs @@ -0,0 +1,41 @@ +#![no_std] + +#[cfg(target_os = "zkvm")] +use core::mem::MaybeUninit; + +#[inline(always)] +pub fn keccak256(input: &[u8]) -> [u8; 32] { + #[cfg(not(target_os = "zkvm"))] + { + let mut output = [0u8; 32]; + set_keccak256(input, &mut output); + output + } + #[cfg(target_os = "zkvm")] + { + let mut output = MaybeUninit::<[u8; 32]>::uninit(); + openvm_new_keccak256_guest::native_keccak256( + input.as_ptr(), + input.len(), + output.as_mut_ptr() as *mut u8, + ); + unsafe { output.assume_init() } + } +} + +/// Sets `output` to the keccak256 hash of `input`. +pub fn set_keccak256(input: &[u8], output: &mut [u8; 32]) { + #[cfg(not(target_os = "zkvm"))] + { + use tiny_keccak::Hasher; + let mut hasher = tiny_keccak::Keccak::v256(); + hasher.update(input); + hasher.finalize(output); + } + #[cfg(target_os = "zkvm")] + openvm_new_keccak256_guest::native_keccak256( + input.as_ptr(), + input.len(), + output.as_mut_ptr() as *mut u8, + ); +} From 328524809182221c0f588b7a5e05027b742c3dc0 Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Tue, 30 Dec 2025 14:02:27 +0000 Subject: [PATCH 05/78] fix: use tiny-keccak fork in new keccak example --- examples/new-keccak/Cargo.toml | 9 +- examples/new-keccak/src/main.rs | 37 +++-- extensions/new-keccak256/guest/src/lib.rs | 162 ++++++++++------------ 3 files changed, 97 insertions(+), 111 deletions(-) diff --git a/examples/new-keccak/Cargo.toml b/examples/new-keccak/Cargo.toml index a42de61ace..09cd7f5de5 100644 --- a/examples/new-keccak/Cargo.toml +++ b/examples/new-keccak/Cargo.toml @@ -7,11 +7,13 @@ edition = "2021" members = [] [dependencies] +tiny-keccak = { git = "https://github.com/openvm-org/tiny-keccak", branch = "perf/custom-xorin-keccak", features = ["keccak"] } +hex-literal = "1.1.0" + +[target.'cfg(target_os = "zkvm")'.dependencies] openvm = { git = "https://github.com/openvm-org/openvm.git", features = [ "std", ] } -openvm-new-keccak256-guest = { path = "../../extensions/new-keccak256/guest" } -hex-literal = "1.1.0" [features] default = [] @@ -19,5 +21,4 @@ default = [] # remove this if copying example outside of monorepo [patch."https://github.com/openvm-org/openvm.git"] openvm = { path = "../../crates/toolchain/openvm" } -openvm-keccak256 = { path = "../../guest-libs/keccak256" } - +openvm-new-keccak256-guest = { path = "../../extensions/new-keccak256/guest" } diff --git a/examples/new-keccak/src/main.rs b/examples/new-keccak/src/main.rs index fc8ad8c1a0..a9a494c650 100644 --- a/examples/new-keccak/src/main.rs +++ b/examples/new-keccak/src/main.rs @@ -1,14 +1,15 @@ // [!region imports] -// [!endregion imports] +use hex_literal::hex; +use tiny_keccak::{Hasher, Keccak}; -// [!region main] #[cfg(target_os = "zkvm")] -use hex_literal::hex; use openvm as _; +// [!endregion imports] + +// [!region main] /// Vector of test cases for Keccak-256 hash function. /// Each test case consists of (input_bytes, expected_hash_result). -#[cfg(target_os = "zkvm")] const KECCAK_TEST_CASES: &[(&[u8], [u8; 32])] = &[ ( b"", @@ -147,25 +148,19 @@ const KECCAK_TEST_CASES: &[(&[u8], [u8; 32])] = &[ hex!("f5392ee04880a0bd1336f30ee79b5c014a90728bf29f422dabb4ae6bc972f30b"), ), ]; -// todo: call the forked tiny keccak library once that is updated instead of directly calling the -// keccak256_guest native functions pub fn main() { - #[cfg(target_os = "zkvm")] - { - for &(input, expected) in KECCAK_TEST_CASES { - let mut input = input.to_vec(); - let mut output = [0u8; 32]; - openvm_new_keccak256_guest::native_keccak256( - input.as_ptr(), - input.len(), - output.as_mut_ptr(), - ); - assert_eq!(output, expected); - } + // Run the keccak tests for all targets + for &(input, expected) in KECCAK_TEST_CASES { + let mut output = [0u8; 32]; - // let mut expected_output = [0u8; 32]; - // openvm_keccak256::keccak256(&buffer); - // assert_eq!(output, expected_output); + // Using tiny-keccak API + let mut hasher = Keccak::v256(); + hasher.update(input); + hasher.finalize(&mut output); + + assert_eq!(output, expected); } + + println!("All {} keccak256 test cases passed!", KECCAK_TEST_CASES.len()); } // [!endregion main] diff --git a/extensions/new-keccak256/guest/src/lib.rs b/extensions/new-keccak256/guest/src/lib.rs index 55a22cab59..99334e79ba 100644 --- a/extensions/new-keccak256/guest/src/lib.rs +++ b/extensions/new-keccak256/guest/src/lib.rs @@ -21,6 +21,15 @@ struct AlignedStackBuf { data: [u8; N], } +/// SAFETY: Caller must ensure: +/// - buffer and input are aligned to MIN_ALIGN +/// - len is a multiple of MIN_ALIGN +#[cfg(target_os = "zkvm")] +#[inline(always)] +unsafe fn native_xorin_unchecked(buffer: *mut u8, input: *const u8, len: usize) { + __native_xorin(buffer, input, len); +} + #[cfg(target_os = "zkvm")] #[no_mangle] pub extern "C" fn native_xorin(buffer: *mut u8, input: *const u8, len: usize) { @@ -28,31 +37,48 @@ pub extern "C" fn native_xorin(buffer: *mut u8, input: *const u8, len: usize) { return; } unsafe { - let aligned_buffer; - let aligned_input; + let buffer_aligned = buffer as usize % MIN_ALIGN == 0; + let input_aligned = input as usize % MIN_ALIGN == 0; + let len_aligned = len % MIN_ALIGN == 0; + let all_aligned = buffer_aligned && input_aligned && len_aligned; - let actual_buffer = if buffer as usize % MIN_ALIGN == 0 { - buffer + if all_aligned { + __native_xorin(buffer, input, len); } else { - aligned_buffer = AlignedBuf::new(buffer, len, MIN_ALIGN); - aligned_buffer.ptr - }; + let adjusted_len = len.next_multiple_of(MIN_ALIGN); + let aligned_buffer; + let aligned_input; - let actual_input = if input as usize % MIN_ALIGN == 0 { - input - } else { - aligned_input = AlignedBuf::new(input, len, MIN_ALIGN); - aligned_input.ptr - }; + let actual_buffer = if buffer_aligned && len_aligned { + buffer + } else { + aligned_buffer = AlignedBuf::new(buffer, adjusted_len, MIN_ALIGN); + aligned_buffer.ptr + }; + + let actual_input = if input_aligned && len_aligned { + input + } else { + aligned_input = AlignedBuf::new(input, adjusted_len, MIN_ALIGN); + aligned_input.ptr + }; - __native_xorin(actual_buffer, actual_input, len); + __native_xorin(actual_buffer, actual_input, adjusted_len); - if buffer as usize % MIN_ALIGN != 0 { - core::ptr::copy_nonoverlapping(actual_buffer as *const u8, buffer, len); + if !buffer_aligned || !len_aligned { + core::ptr::copy_nonoverlapping(actual_buffer as *const u8, buffer, len); + } } } } +/// SAFETY: Caller must ensure buffer is aligned to MIN_ALIGN +#[cfg(target_os = "zkvm")] +#[inline(always)] +unsafe fn native_keccakf_unchecked(buffer: *mut u8) { + __native_keccakf(buffer); +} + #[cfg(target_os = "zkvm")] #[no_mangle] pub extern "C" fn native_keccakf(buffer: *mut u8) { @@ -86,20 +112,21 @@ pub extern "C" fn native_keccakf(buffer: *mut u8) { #[cfg(target_os = "zkvm")] #[no_mangle] pub extern "C" fn native_keccak256(bytes: *const u8, len: usize, output: *mut u8) { - // SAFETY: assuming safety assumptions of the inputs, we handle all cases where `bytes` or - // `output` are not aligned to 4 bytes. unsafe { + let bytes_aligned = bytes as usize % MIN_ALIGN == 0; + let output_aligned = output as usize % MIN_ALIGN == 0; + let aligned_bytes; let aligned_output; - let actual_bytes = if len == 0 || bytes as usize % MIN_ALIGN == 0 { + let actual_bytes = if len == 0 || bytes_aligned { bytes } else { aligned_bytes = AlignedBuf::new(bytes, len, MIN_ALIGN); aligned_bytes.ptr }; - let actual_output = if output as usize % MIN_ALIGN == 0 { + let actual_output = if output_aligned { output } else { aligned_output = AlignedBuf::uninit(KECCAK_OUTPUT_SIZE, MIN_ALIGN); @@ -108,99 +135,62 @@ pub extern "C" fn native_keccak256(bytes: *const u8, len: usize, output: *mut u8 keccak256_impl(actual_bytes, len, actual_output); - if output as usize % MIN_ALIGN != 0 { + if !output_aligned { core::ptr::copy_nonoverlapping(actual_output as *const u8, output, KECCAK_OUTPUT_SIZE); } } } +/// SAFETY: This function is only called from native_keccak256 which ensures: +/// - input is aligned to MIN_ALIGN +/// - output is aligned to MIN_ALIGN +/// - All internal buffers are aligned by AlignedStackBuf #[cfg(target_os = "zkvm")] #[inline(always)] -fn keccak_update( - buffer: &mut AlignedStackBuf, - input: *const u8, - len: usize, -) -> usize { +unsafe fn keccak256_impl(input: *const u8, len: usize, output: *mut u8) { + let mut buffer = AlignedStackBuf:: { + data: [0u8; KECCAK_WIDTH_BYTES], + }; let buffer_ptr = buffer.data.as_mut_ptr(); + let mut offset = 0; let mut remaining = len; - let input_aligned = input as usize % MIN_ALIGN == 0; // Absorb full blocks while remaining >= KECCAK_RATE { - if input_aligned { - __native_xorin(buffer_ptr, unsafe { input.add(offset) }, KECCAK_RATE); - } else { - let mut block = AlignedStackBuf:: { - data: [0u8; KECCAK_RATE], - }; - unsafe { - core::ptr::copy_nonoverlapping( - input.add(offset), - block.data.as_mut_ptr(), - KECCAK_RATE, - ); - __native_xorin(buffer_ptr, block.data.as_ptr(), KECCAK_RATE); - } - } - unsafe { - __native_keccakf(buffer_ptr); - } + native_xorin_unchecked(buffer_ptr, input.add(offset), KECCAK_RATE); + native_keccakf_unchecked(buffer_ptr); offset += KECCAK_RATE; remaining -= KECCAK_RATE; } // Handle remaining bytes if remaining > 0 { - unsafe { - if input_aligned && remaining % MIN_ALIGN == 0 { - __native_xorin(buffer_ptr, input.add(offset), remaining); - } else { - let adjusted_len = remaining.next_multiple_of(MIN_ALIGN); - let mut padded_input = AlignedStackBuf:: { - data: [0u8; KECCAK_RATE], - }; - core::ptr::copy_nonoverlapping( - input.add(offset), - padded_input.data.as_mut_ptr(), - remaining, - ); - __native_xorin(buffer_ptr, padded_input.data.as_ptr(), adjusted_len); - } + if remaining % MIN_ALIGN == 0 { + native_xorin_unchecked(buffer_ptr, input.add(offset), remaining); + } else { + let adjusted_len = remaining.next_multiple_of(MIN_ALIGN); + let mut padded_input = AlignedStackBuf:: { + data: [0u8; KECCAK_RATE], + }; + core::ptr::copy_nonoverlapping( + input.add(offset), + padded_input.data.as_mut_ptr(), + remaining, + ); + native_xorin_unchecked(buffer_ptr, padded_input.data.as_ptr(), adjusted_len); } } - remaining -} - -#[cfg(target_os = "zkvm")] -#[inline(always)] -fn keccak_finalize( - buffer: &mut AlignedStackBuf, - remaining_len: usize, - output: *mut u8, -) { // Apply Keccak padding (pad10*1) - buffer.data[remaining_len] ^= 0x01; + buffer.data[remaining] ^= 0x01; buffer.data[KECCAK_RATE - 1] ^= 0x80; // Final permutation - unsafe { - __native_keccakf(buffer.data.as_mut_ptr()); - - // Extract output - core::ptr::copy_nonoverlapping(buffer.data.as_ptr(), output, KECCAK_OUTPUT_SIZE); - } -} + native_keccakf_unchecked(buffer_ptr); -#[cfg(target_os = "zkvm")] -#[inline(always)] -fn keccak256_impl(input: *const u8, len: usize, output: *mut u8) { - let mut buffer = AlignedStackBuf:: { - data: [0u8; KECCAK_WIDTH_BYTES], - }; - let remaining_len = keccak_update(&mut buffer, input, len); - keccak_finalize(&mut buffer, remaining_len, output); + // Extract output + core::ptr::copy_nonoverlapping(buffer.data.as_ptr(), output, KECCAK_OUTPUT_SIZE); } #[cfg(target_os = "zkvm")] From 6d12b88c726749ae4e82b6b67fdec67891c7747d Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Tue, 30 Dec 2025 14:53:23 +0000 Subject: [PATCH 06/78] chore: revert old keccak example --- crates/toolchain/transpiler/src/extension.rs | 1 - examples/keccak/Cargo.toml | 3 -- examples/keccak/openvm.toml | 2 +- examples/keccak/src/main.rs | 33 +++++++++++++------- examples/new-keccak/src/main.rs | 8 +++-- 5 files changed, 27 insertions(+), 20 deletions(-) diff --git a/crates/toolchain/transpiler/src/extension.rs b/crates/toolchain/transpiler/src/extension.rs index fd4a220f4d..cb413185bf 100644 --- a/crates/toolchain/transpiler/src/extension.rs +++ b/crates/toolchain/transpiler/src/extension.rs @@ -21,7 +21,6 @@ pub trait TranspilerExtension { } } -#[derive(Debug)] pub struct TranspilerOutput { pub instructions: Vec>>, pub used_u32s: usize, diff --git a/examples/keccak/Cargo.toml b/examples/keccak/Cargo.toml index 128537ba9d..74f15e6234 100644 --- a/examples/keccak/Cargo.toml +++ b/examples/keccak/Cargo.toml @@ -12,8 +12,6 @@ openvm = { git = "https://github.com/openvm-org/openvm.git", features = [ ] } openvm-keccak256 = { git = "https://github.com/openvm-org/openvm.git" } hex = { version = "0.4.3" } -tiny-keccak = { git = "https://github.com/openvm-org/tiny-keccak.git", features = ["keccak"] } -openvm-new-keccak256-guest = { path = "../../extensions/new-keccak256/guest" } [features] default = [] @@ -22,4 +20,3 @@ default = [] [patch."https://github.com/openvm-org/openvm.git"] openvm = { path = "../../crates/toolchain/openvm" } openvm-keccak256 = { path = "../../guest-libs/keccak256" } - diff --git a/examples/keccak/openvm.toml b/examples/keccak/openvm.toml index 61b2a0a406..93998f52a3 100644 --- a/examples/keccak/openvm.toml +++ b/examples/keccak/openvm.toml @@ -1,4 +1,4 @@ [app_vm_config.rv32i] [app_vm_config.rv32m] [app_vm_config.io] -[app_vm_config.new_keccak] \ No newline at end of file +[app_vm_config.keccak] diff --git a/examples/keccak/src/main.rs b/examples/keccak/src/main.rs index b4625c850f..cc12a2e859 100644 --- a/examples/keccak/src/main.rs +++ b/examples/keccak/src/main.rs @@ -1,21 +1,30 @@ // [!region imports] +use core::hint::black_box; + +use hex::FromHex; use openvm as _; +use openvm_keccak256::keccak256; // [!endregion imports] // [!region main] - -// todo: call the forked tiny keccak library once that is updated instead of directly calling the -// keccak256_guest native functions pub fn main() { - #[cfg(target_os = "zkvm")] - { - let mut buffer = [1u8; 200]; - let input = [2u8; 136]; - let output = [3u8; 136]; - let len: usize = 136; - openvm_new_keccak256_guest::native_xorin(buffer.as_mut_ptr(), input.as_ptr(), len); - assert_eq!(buffer[..136], output); - openvm_new_keccak256_guest::native_keccakf(buffer.as_mut_ptr()); + let test_vectors = [ + ( + "", + "C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", + ), + ( + "CC", + "EEAD6DBFC7340A56CAEDC044696A168870549A6A7F6F56961E84A54BD9970B8A", + ), + ]; + for (input, expected_output) in test_vectors.iter() { + let input = Vec::from_hex(input).unwrap(); + let expected_output = Vec::from_hex(expected_output).unwrap(); + let output = keccak256(&black_box(input)); + if output != *expected_output { + panic!(); + } } } // [!endregion main] diff --git a/examples/new-keccak/src/main.rs b/examples/new-keccak/src/main.rs index a9a494c650..ff3b586daf 100644 --- a/examples/new-keccak/src/main.rs +++ b/examples/new-keccak/src/main.rs @@ -1,9 +1,8 @@ // [!region imports] use hex_literal::hex; -use tiny_keccak::{Hasher, Keccak}; - #[cfg(target_os = "zkvm")] use openvm as _; +use tiny_keccak::{Hasher, Keccak}; // [!endregion imports] // [!region main] @@ -161,6 +160,9 @@ pub fn main() { assert_eq!(output, expected); } - println!("All {} keccak256 test cases passed!", KECCAK_TEST_CASES.len()); + println!( + "All {} keccak256 test cases passed!", + KECCAK_TEST_CASES.len() + ); } // [!endregion main] From b9ebe335950347108f325ef3f3efb27619a04610 Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Mon, 5 Jan 2026 18:37:38 +0000 Subject: [PATCH 07/78] fix: avoid xorin funct7 clash with sha512 --- extensions/new-keccak256/guest/src/lib.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/extensions/new-keccak256/guest/src/lib.rs b/extensions/new-keccak256/guest/src/lib.rs index 99334e79ba..4140bf24ef 100644 --- a/extensions/new-keccak256/guest/src/lib.rs +++ b/extensions/new-keccak256/guest/src/lib.rs @@ -9,7 +9,8 @@ pub const OPCODE: u8 = 0x0b; pub const KECCAKF_FUNCT3: u8 = 0b100; pub const KECCAKF_FUNCT7: u8 = 0; pub const XORIN_FUNCT3: u8 = 0b100; -pub const XORIN_FUNCT7: u8 = 2; +pub const XORIN_FUNCT7: u8 = 3; + pub const KECCAK_WIDTH_BYTES: usize = 200; pub const KECCAK_RATE: usize = 136; pub const KECCAK_OUTPUT_SIZE: usize = 32; From 39ebfaec58b3f0d349f7b880193efdbe66d6aca3 Mon Sep 17 00:00:00 2001 From: Jonathan Wang <31040440+jonathanpwang@users.noreply.github.com> Date: Sat, 28 Feb 2026 00:58:25 +0000 Subject: [PATCH 08/78] feat(new-keccak): split keccakf into two AIRs (#2353) Note that I removed the `cells_used` metric since with the introduction of periphery chips (both here and the new SHA-2) it is very hard to make it accurate. There are better ways to get that data, and we should add tooling for it in a separate feature. --- Cargo.lock | 16 +- Cargo.toml | 8 +- .../elf/openvm-keccak256-program.elf | Bin 67140 -> 61004 bytes .../elf/openvm-keccak256-iter-program.elf | Bin 60024 -> 60092 bytes crates/vm/src/arch/vm.rs | 78 --- crates/vm/src/system/cuda/mod.rs | 35 - crates/vm/src/system/cuda/poseidon2.rs | 4 - crates/vm/src/system/mod.rs | 46 -- examples/keccak/Cargo.toml | 8 +- examples/keccak/openvm.toml | 2 +- examples/keccak/src/main.rs | 180 ++++- examples/new-keccak/Cargo.toml | 24 - examples/new-keccak/openvm.toml | 4 - examples/new-keccak/src/main.rs | 168 ----- extensions/keccak256/circuit/Cargo.toml | 5 - extensions/keccak256/circuit/README.md | 36 - extensions/keccak256/circuit/build.rs | 7 +- .../cuda/include/keccak256/columns.cuh | 140 ---- .../cuda/include/keccak256/keccakvm.cuh | 46 -- .../cuda/include/keccak256/p3_generation.cuh | 92 --- .../circuit/cuda/include/keccakf_op.cuh | 83 +++ .../circuit/cuda/include/keccakf_perm.cuh | 19 + .../circuit/cuda/include/p3_keccakf.cuh} | 78 ++- .../circuit/cuda/include}/xorin.cuh | 0 .../keccak256/circuit/cuda/src/keccak256.cu | 344 ---------- .../keccak256/circuit/cuda/src/keccakf.cu | 254 ------- .../keccak256/circuit/cuda/src/keccakf_op.cu | 156 +++++ .../circuit/cuda/src/keccakf_perm.cu | 193 ++++++ .../circuit/cuda/src/xorin.cu | 30 +- extensions/keccak256/circuit/src/air.rs | 638 ------------------ extensions/keccak256/circuit/src/columns.rs | 153 ----- extensions/keccak256/circuit/src/constants.rs | 28 + .../keccak256/circuit/src/cuda/cuda_abi.rs | 169 ++--- extensions/keccak256/circuit/src/cuda/mod.rs | 202 ++++-- extensions/keccak256/circuit/src/execution.rs | 203 ------ .../keccak256/circuit/src/extension/cuda.rs | 47 +- .../keccak256/circuit/src/extension/mod.rs | 97 ++- .../keccak256/circuit/src/keccakf_op/air.rs | 194 ++++++ .../circuit/src/keccakf_op/columns.rs | 38 ++ .../circuit/src/keccakf_op}/execution.rs | 89 +-- .../keccak256/circuit/src/keccakf_op/mod.rs | 77 +++ .../circuit/src/keccakf_op}/tests.rs | 236 ++++--- .../keccak256/circuit/src/keccakf_op/trace.rs | 257 +++++++ .../keccak256/circuit/src/keccakf_perm/air.rs | 116 ++++ .../keccak256/circuit/src/keccakf_perm/mod.rs | 5 + .../circuit/src/keccakf_perm/trace.rs | 74 ++ extensions/keccak256/circuit/src/lib.rs | 68 +- extensions/keccak256/circuit/src/tests.rs | 501 -------------- extensions/keccak256/circuit/src/trace.rs | 578 ---------------- extensions/keccak256/circuit/src/utils.rs | 26 - .../circuit/src/xorin/air.rs | 54 +- .../circuit/src/xorin/columns.rs | 2 +- .../circuit/src/xorin/execution.rs | 3 +- .../circuit/src/xorin/mod.rs | 3 - .../circuit/src/xorin/tests.rs | 34 +- .../circuit/src/xorin/trace.rs | 62 +- extensions/keccak256/guest/Cargo.toml | 3 + extensions/keccak256/guest/src/lib.rs | 232 ++++++- extensions/keccak256/transpiler/src/lib.rs | 49 +- extensions/new-keccak256/circuit/Cargo.toml | 64 -- extensions/new-keccak256/circuit/build.rs | 41 -- .../circuit/cuda/include/keccakf/keccakf.cuh | 75 -- .../new-keccak256/circuit/cuda/src/keccakf.cu | 291 -------- .../circuit/src/cuda/cuda_abi.rs | 97 --- .../new-keccak256/circuit/src/cuda/mod.rs | 106 --- .../circuit/src/extension/cuda.rs | 91 --- .../circuit/src/extension/mod.rs | 248 ------- .../new-keccak256/circuit/src/keccakf/air.rs | 316 --------- .../circuit/src/keccakf/columns.rs | 42 -- .../new-keccak256/circuit/src/keccakf/mod.rs | 24 - .../circuit/src/keccakf/trace.rs | 353 ---------- .../circuit/src/keccakf/utils.rs | 4 - extensions/new-keccak256/circuit/src/lib.rs | 15 - .../new-keccak256/circuit/src/xorin/utils.rs | 2 - extensions/new-keccak256/guest/Cargo.toml | 14 - extensions/new-keccak256/guest/src/lib.rs | 221 ------ .../new-keccak256/transpiler/Cargo.toml | 17 - .../new-keccak256/transpiler/src/lib.rs | 70 -- guest-libs/keccak256/src/lib.rs | 1 - guest-libs/keccak256/tests/lib.rs | 8 +- guest-libs/new_keccak256/Cargo.toml | 16 - guest-libs/new_keccak256/src/lib.rs | 41 -- 82 files changed, 2338 insertions(+), 6113 deletions(-) delete mode 100644 examples/new-keccak/Cargo.toml delete mode 100644 examples/new-keccak/openvm.toml delete mode 100644 examples/new-keccak/src/main.rs delete mode 100644 extensions/keccak256/circuit/README.md delete mode 100644 extensions/keccak256/circuit/cuda/include/keccak256/columns.cuh delete mode 100644 extensions/keccak256/circuit/cuda/include/keccak256/keccakvm.cuh delete mode 100644 extensions/keccak256/circuit/cuda/include/keccak256/p3_generation.cuh create mode 100644 extensions/keccak256/circuit/cuda/include/keccakf_op.cuh create mode 100644 extensions/keccak256/circuit/cuda/include/keccakf_perm.cuh rename extensions/{new-keccak256/circuit/cuda/include/keccakf/p3_generation.cuh => keccak256/circuit/cuda/include/p3_keccakf.cuh} (54%) rename extensions/{new-keccak256/circuit/cuda/include/xorin => keccak256/circuit/cuda/include}/xorin.cuh (100%) delete mode 100644 extensions/keccak256/circuit/cuda/src/keccak256.cu delete mode 100644 extensions/keccak256/circuit/cuda/src/keccakf.cu create mode 100644 extensions/keccak256/circuit/cuda/src/keccakf_op.cu create mode 100644 extensions/keccak256/circuit/cuda/src/keccakf_perm.cu rename extensions/{new-keccak256 => keccak256}/circuit/cuda/src/xorin.cu (91%) delete mode 100644 extensions/keccak256/circuit/src/air.rs delete mode 100644 extensions/keccak256/circuit/src/columns.rs create mode 100644 extensions/keccak256/circuit/src/constants.rs delete mode 100644 extensions/keccak256/circuit/src/execution.rs create mode 100644 extensions/keccak256/circuit/src/keccakf_op/air.rs create mode 100644 extensions/keccak256/circuit/src/keccakf_op/columns.rs rename extensions/{new-keccak256/circuit/src/keccakf => keccak256/circuit/src/keccakf_op}/execution.rs (66%) create mode 100644 extensions/keccak256/circuit/src/keccakf_op/mod.rs rename extensions/{new-keccak256/circuit/src/keccakf => keccak256/circuit/src/keccakf_op}/tests.rs (51%) create mode 100644 extensions/keccak256/circuit/src/keccakf_op/trace.rs create mode 100644 extensions/keccak256/circuit/src/keccakf_perm/air.rs create mode 100644 extensions/keccak256/circuit/src/keccakf_perm/mod.rs create mode 100644 extensions/keccak256/circuit/src/keccakf_perm/trace.rs delete mode 100644 extensions/keccak256/circuit/src/tests.rs delete mode 100644 extensions/keccak256/circuit/src/trace.rs delete mode 100644 extensions/keccak256/circuit/src/utils.rs rename extensions/{new-keccak256 => keccak256}/circuit/src/xorin/air.rs (85%) rename extensions/{new-keccak256 => keccak256}/circuit/src/xorin/columns.rs (96%) rename extensions/{new-keccak256 => keccak256}/circuit/src/xorin/execution.rs (99%) rename extensions/{new-keccak256 => keccak256}/circuit/src/xorin/mod.rs (91%) rename extensions/{new-keccak256 => keccak256}/circuit/src/xorin/tests.rs (91%) rename extensions/{new-keccak256 => keccak256}/circuit/src/xorin/trace.rs (85%) delete mode 100644 extensions/new-keccak256/circuit/Cargo.toml delete mode 100644 extensions/new-keccak256/circuit/build.rs delete mode 100644 extensions/new-keccak256/circuit/cuda/include/keccakf/keccakf.cuh delete mode 100644 extensions/new-keccak256/circuit/cuda/src/keccakf.cu delete mode 100644 extensions/new-keccak256/circuit/src/cuda/cuda_abi.rs delete mode 100644 extensions/new-keccak256/circuit/src/cuda/mod.rs delete mode 100644 extensions/new-keccak256/circuit/src/extension/cuda.rs delete mode 100644 extensions/new-keccak256/circuit/src/extension/mod.rs delete mode 100644 extensions/new-keccak256/circuit/src/keccakf/air.rs delete mode 100644 extensions/new-keccak256/circuit/src/keccakf/columns.rs delete mode 100644 extensions/new-keccak256/circuit/src/keccakf/mod.rs delete mode 100644 extensions/new-keccak256/circuit/src/keccakf/trace.rs delete mode 100644 extensions/new-keccak256/circuit/src/keccakf/utils.rs delete mode 100644 extensions/new-keccak256/circuit/src/lib.rs delete mode 100644 extensions/new-keccak256/circuit/src/xorin/utils.rs delete mode 100644 extensions/new-keccak256/guest/Cargo.toml delete mode 100644 extensions/new-keccak256/guest/src/lib.rs delete mode 100644 extensions/new-keccak256/transpiler/Cargo.toml delete mode 100644 extensions/new-keccak256/transpiler/src/lib.rs delete mode 100644 guest-libs/new_keccak256/Cargo.toml delete mode 100644 guest-libs/new_keccak256/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index daa4cb76b9..2291a67031 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6624,10 +6624,8 @@ dependencies = [ name = "openvm-keccak256-circuit" version = "2.0.0-alpha" dependencies = [ - "cfg-if", "derive-new 0.6.0", "derive_more 1.0.0", - "hex", "itertools 0.14.0", "openvm-circuit", "openvm-circuit-derive", @@ -6647,7 +6645,6 @@ dependencies = [ "serde", "strum 0.26.3", "tiny-keccak", - "tokio", ] [[package]] @@ -6655,6 +6652,7 @@ name = "openvm-keccak256-guest" version = "2.0.0-alpha" dependencies = [ "openvm-platform", + "spin 0.10.0", ] [[package]] @@ -9845,16 +9843,6 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" -[[package]] -name = "signal-hook-registry" -version = "1.4.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b" -dependencies = [ - "errno", - "libc", -] - [[package]] name = "signature" version = "1.6.4" @@ -10784,9 +10772,7 @@ dependencies = [ "bytes", "libc", "mio", - "parking_lot", "pin-project-lite", - "signal-hook-registry", "socket2", "tokio-macros", "windows-sys 0.61.2", diff --git a/Cargo.toml b/Cargo.toml index 3987b783c4..3fe04ffb68 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -53,9 +53,6 @@ members = [ "extensions/keccak256/circuit", "extensions/keccak256/transpiler", "extensions/keccak256/guest", - "extensions/new-keccak256/circuit", - "extensions/new-keccak256/guest", - "extensions/new-keccak256/transpiler", "extensions/sha256/circuit", "extensions/sha256/transpiler", "extensions/sha256/guest", @@ -70,7 +67,6 @@ members = [ "guest-libs/k256/", "guest-libs/p256/", "guest-libs/keccak256/", - "guest-libs/new_keccak256/", "guest-libs/pairing/", "guest-libs/ruint/", "guest-libs/sha2/", @@ -163,9 +159,6 @@ openvm-rv32-adapters = { path = "extensions/rv32-adapters", default-features = f openvm-keccak256-circuit = { path = "extensions/keccak256/circuit", default-features = false } openvm-keccak256-transpiler = { path = "extensions/keccak256/transpiler", default-features = false } openvm-keccak256-guest = { path = "extensions/keccak256/guest", default-features = false } -openvm-new-keccak256-circuit = { path = "extensions/new-keccak256/circuit", default-features = false } -openvm-new-keccak256-guest = { path = "extensions/new-keccak256/guest", default-features = false } -openvm-new-keccak256-transpiler = { path = "extensions/new-keccak256/transpiler", default-features = false } openvm-sha256-circuit = { path = "extensions/sha256/circuit", default-features = false } openvm-sha256-transpiler = { path = "extensions/sha256/transpiler", default-features = false } openvm-sha256-guest = { path = "extensions/sha256/guest", default-features = false } @@ -264,6 +257,7 @@ serde = { version = "1.0.201", default-features = false, features = ["derive"] } hex-literal = { version = "1.0.0", default-features = false } bytemuck = { version = "1.20.0", default-features = false } once_cell = { version = "1.20", default-features = false } +spin = { version = "0.10.0", default-features = false } # cryptography, default-features = false for no_std tiny-keccak = { version = "2.0.2", features = ["keccak"] } diff --git a/benchmarks/guest/keccak256/elf/openvm-keccak256-program.elf b/benchmarks/guest/keccak256/elf/openvm-keccak256-program.elf index 6e0fc26837f576f23321c0c25fc233a6aa6a7cfc..f5dbe33b5078774c043b610e1145904db9e6d86b 100755 GIT binary patch literal 61004 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 literal 63984 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≫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 diff --git a/benchmarks/guest/keccak256/elf/openvm-keccak256-program.elf b/benchmarks/guest/keccak256/elf/openvm-keccak256-program.elf index f5dbe33b5078774c043b610e1145904db9e6d86b..5f6a6674702a41b5d0a4e532d59c1f708906ba29 100755 GIT binary patch literal 61940 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 Zz6N@a_+G18Od7#urz$-?SH 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 e{`0@HvuEiS-V;5_pN{VPz~m^vqZavLtl) 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 z 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 F{{Y3GOdS9K literal 60092 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 R= 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 delta 163650 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

fyvrfQ>VTAH)w2WWjsvGYt3Z* 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 z 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 z�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

w=2Ct`OcA${}XwzWS|X8{S?6*6j6Ox$c46 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 z

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%0Da@QuFe?a~(g*(aq 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

vEnj)<&ypEC8} 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�f=`s8% zS?ZRZ*dxR}xOLNV_>;e$Hm|_rx^*A0f_pKq4I{kZXcC>{8;fA0m(FIiYaw*FxcJ;#vn>7Yb+HOnmFT0e%ngdjK690H+1?*w*$y z%OB$XomA?I?zIONFz5EA9hf_2ly_kyB9Yd-wM=I62wWJF@E+-*k^>nF(vpxXR;-5d2U7M6cBd8+-#rT=v}wk_zxrKWX# zJ#xUlQKS9n(GiS~`V;jt{n$uX_>fSSC;!N~Ac6;E6 z5nkS=Z4ZMr*x0b(QDW$0Gitq-?@DwOcqze?T|+;z?#@pRxDDT?Z;``B{me)Meq$3q zP&n&)^1o<5X)Rn_CVf(Jqr@Jw3(#d_$fY&9Wb~t>{zc!jywu z4SMXZVjrp6tEnq?O3(;4yfGYH_dtNPz(HrBr_u@a9q%-cW_|Y-^1HyhH;-Z6E^)vOjl%X4V7W4YK=$7)0w^uOm=nwWjOo`S%vVDBT0J`dwv4xdaaMSo5cUjXNbkMn z>XVw$m9%-Ky=ozQHZevo+ty`XzPHQ1{6LpE?r4`iuCmL#_K`08+NZkg$l5OR>akt+ zRg=2RYo>MCSI_D?HCL0m1s;a@b^G!lW&3s6qX%`FSB&hk&R)cN+zdAd4r_hfoayp| zgRH-}L)ces>ol+4+i6D*bedz2cCrVAVV%W#3-URsKhDR`x(t5lxSLBuuYGoNs(g8V zBF~e~8BoEP)On$%?jm-cT#D2BvHn%pgFHF!lmCfa2zni~8jC++<4+BBd9_eu4jFP2 zV|Uy$oxs zJ6`A3gtMCFk(W&KsFK9qyX<-5?k}r0VyA5TvanZOiTsY?8Ga$RebJU7fpEb`rxYujwpVtz)gZx_z(xK>!{A> zrn9?VKZEY{>cd=%+2h45E=_PH3 z)x;jI*e>{1$Yq}xYmU9COLge?e$xn-wZVxW%!v8-_O`e9(4m>=&>VCqd8fuQ?_8E? zn3v}u+j-nCQ>-j0G{U7*jFqKDj9v7D(TbjEM^E5W*-}9HLds8}d=cdfC|^kVDU|2> zGRl`x-ln|GXAk8)ls74F>hf{QFQI%51DiMjE_^i zYV1kwq|%TL&clugVaEiqV}kbJXb?Llh#eC!!F=|RXuv#Q1nl!0{b0ouZP#d?z#+DS zx_*2bE+tMuUT<9&|!g+`a-J;`@~A)a;ljB$3kGV=L+|JL58=*P zbr*aZcN(5$2VI|Fj(s}rJPV8qrj3eNO3LtV+-VM>-D*NE*0gJ`bg`z3IpKCR=4|*e z9N)qo)!lfLb?rfCzQ&trC-A16T>u{jzB`|}Y(S}=%Y2p}yxHTgC-A16otwm)$4|qX zR^N%>nnD+6Ch#UaT^#vw@h15nh&xEgMkEkR?=dLWA6#$(YZfH2WGz#HXB!Gt;IBYY8!} z35*%}e2lr_>HoJe=4kQX!Bg7z?+JWal*E@Wo{BHubTQMv z3tN7__7m8$q}Iij{akE0RbyKhTgGc#Y#Gj)z*u+~y`goOiz}!6^SBZWT6^WEa3y&q z$TI`3>~RXNeD4%oxvxR<3!lQ1PJAQri4EwQb<8`=C!d8U@7Xr#Z{bP3ZrH_>nT6a3 zE^z7f=#Kxwe+8Egj?}iEnFEd-2#y>GjvSI>*!Fksn0PC?K z#x<3l_EnE`+E+gX{#)Dm**J1+r#Ws?r#*UFr#X67=jY={{N7guxo1D_JqR2*5*#@a z44Eo)zFK+b56Jz$4Bz9&CvhaUl)JW9=L+(Gt?&HHo%Z_^a%1?gALcSKe)z>A6};SMj}stu}9-b7t_u2fFnKN$N)Gp zK&(nH9Z$m^8&f^<1u&$+c?5?|xq6OmeZh^X_%5z+aiko*n`eO|H%%Ana&Y9v4}~1} zC-5ZkE@LgBM!#jqEgPvPb=|Uw_zC9R5eL{05*&HiXzV($6gX1v7p6voH!tUY;7F-) zB(|r0d9GoO8{v*kZF@S7>E;Jaf*@H!jSCK>)NpPI6rxKxYr3Ab~pL* zGLklI8|}$+xlcES#Qu!Rjvdsa-qjD?_)+?IoX`{O9b>5bz5{2mkh2#*1- z*btG$yHAwwF6WFN0cV%MkIwZDyaTpRMKAW^13wnj(r4K7*x@c0*jft)1V2vS{jz?B zQw)9_1Aa7iyZF&U{!hh@66~0;)A-%Rj$2P(v%EErbr3%AS0>{j2mF->cJzTAGex+x z5bQXGdpCg{o57B)V8?cHHxz)E3&C$wz;8vA=kr+R%FCuu9;{VHdGKS{rabsD?4i7e z@+Rd?T|Q3vC6uqBd>!TaJa!4?8T*&lfgLFiehkMc4}J`LDetAckMcfUzKQb9ly9Xx zpEY(I+f4aZ%D00ZDGz=OS5Ur!@_x$uDIcJGK$rJ{A2Y#^IpD`U!TWym=KIK!I zjFl;rPi-|;rt0!>$}gdO4dv@7&*!mAC|^VQIuTw#`300;Ncn}7Pirz(rcu5}tFf|& zF5g7?X3DoxzMb-X9@|X$R?4@FFnOa^R#ScvA6WI3|9UJ9n zTRw0DvbCFj9>ZLwZF)T?f^V{1K5aG}$*RAJeFtmodqq@Z-^9EEHvT_}dzZU>>|NmA zBlu3pMFHPB0KPTr9Qf6*!LLT)SFeL#y%~P>-T=RoQ|X~VIBSK@q2zP@dc--IIX+?M zTTLE{dvH5?2 z&3}&%=Vo}mMsGMMyx}2#(Q(FLHn>Cb4#4>d-Db;vsCmDVo?tQ`{8N83rxbp+5gk%0 z?A%6t#5{XoRL5nQ@P6hec|TbJx7Ps2m&dujp1H4{cyNxUc2|#RdsJRg3)l59`5DnE zQ|jP#SMaXH;snY4M=W?4&fDdF2ZFz|&%x&ccg6Mjez-7ySEuHX8XgCK&rhv(g3S58 zKAIc*K+pTKf|%Xb~{PPZmgTjnPkS{ z7@H0Gy*hZzKO0T~v2|%dbeT_B^RfTiGle`>gMTsP)p%OE*tjl(|d{yIjR;rI6{ zeUG9#c*D9Ru6zCju5X+ez@2<6WP$_Wj3`?erbmNtYXkj5iSz-PBu{ zTe8t9!_g_5(W$$z$@h_m=P-GA<{IXvhYfqvlkhHU;9ahOcbP!WiCf7lH^abgg;QBz zSabTb&gIoE`4KUA)!U=?cCTT-+?#wp+2o|d7nJ>LzW+HsyQtxO{Ba;`%n@?lH6rY} zpZz(ON39fikMwcG+x}YT4JFQ}hS+|;n|o5v>w2A?j$78b19e_ZMP62o$JEsE?)KeliX>JHfDy92PpZTHB%4vK+=wf&M>Y&1*8%Mfgv=$U)g}(q!HB>@VU=vqGhC z1U<12LWbjGEtp&94QctUp*tGtZhJnzWBMfx9oN?6PfWkAVW#i#`~&vcmak~46E8eq z`E&n2^4>kZit1eap4qc+xf3P{ND)IO2_eJ?j1b#`-CNjPY^zd5ZS6%25w$&9T2W7X z+GaECB!D+M0@j{d<0hcgOVcsLUe0N@vH>sErX`^DcaDuQptfF6qSm(XexI408=$r4 z({s-Id*46yXZFl`)|xeIJ?mM|^Q`AmXE$vQI!JkyOB|4>{>Z9SPuWKy0o%B81&nJBFD+$!{mXQ#hOXE&&4NVb3_$- zcdy&WgnRxE?OLE><8-(#zb7-$!K6LFb?!8i2H8;Oy=5nTGHVvjFo9E-sj&OzSYL(c4GV!WoY zZF`rz()`CJ*$%&<*`HYj&Rhh4i+=mMH2m04RcFNj>!@7fKDqIO-MF^>KT*s-93*y3 zn*Fo~+tQOXJy6U!@Sn8dIcPkr$JTQHRqU(UW=sE>C+t+jkHH;}+j+*BY2%1Gkwf}Y z;<+qEUbqn5vgGjIpQRf4%LlnRfE&Rfa!enmi7$dKDOfs)~OlEv& zZ_Hr(-*xRqj`1C{%D~qu@U|)*vZjE?Q^4m+@R}Iq>_K7u>$Av-6jAE(l~Tv5kLae( zx!+sl1pYd7H;FEF(vkYh(^{P)=YjK@fYoxyDem1{Yi*5lUG6>KGGrR!W_SJ;+HhaJ z_?A`IY0RM;`>}<5gDr~wY%@Nf{D|Rbf05sB6XcCxtTkdie*0?TI9{#l&$X!Lcdj9h z<29;&33TD`a?UcA^SqfHy;qV?<4T@0kAJ$7IpP0vO{#I||xB~oXAvPxS@qOCIPr{9Px&ry_ zBfR_i6`3=wKTx0dynVTMPImcolsCC?t=*Wqmp?&H$_CjBJ$lyPK+L5_ROh9akne5> z52rwz>d^vu z`hX5S#h(3?7jJLZSobWA7;Bq<{f3-1-$z?7!()~hNbUU%SUw|8DRlXYJ_-A-(L7&^>2@hfj-oZ6MT{@*+b zU(1*tc-n5dd?9guPZ_4)t&08Ja_olU#DdNV>hF1U+bCU$-UxnUT@0PYmx)0YaQBtX zW8Cq21747vO1VnkZ8=B0eu@2K1X_Nf+7~_%E$^BvaKp5`>nDbSzht>eTvL8kDs(+A z@iXaXV=zPSe{5&rzk7B(U#swF60$XXF}l|&i`l=?t5!Yco^={!DePI^z}~expFJs` z_+I&pL!o`)D)@_y(C>|k^9S&=_+!wB4(Rw|)lgU;{%EM)_c(UZ#n9~cM$+H!>9KVl z%|6gZ-=YOJ{m*>=@98V=8%3`-={?Zv9_Yh9=r!@e^^2g_zLmvEU#iH^+KZA}YmvSb zdaX<@PAaWMhT2<{RJ)7ZwrNk!;lU^JEUm=0Wz_qgwYeYSYrTE_PQlp|=Az;px(Z4C_i3A=09^Bswqo(}_%=&!L<+iLLl&x93>ZG58pfiJ(pJ^7W0|F9zQgk%`1+nfUrH z-!HZSb;v`V*fw@z6Kvm@OI+6gvSusz6KXNAht#nfkaedA-hLfk%BSB{a=t;#7se91 zdicSL0PPJN6+33^{m#?S*VngfKTk{F0bjlyzWisZcJJe=wgtbG2hUct2k~cl;BoXH zJlpd-Vllr$?8^7x+c~G+{SDRHvW~ni=o;_MR<-SCtJ^)qaqr{_ZNE6EjJAZ6%wXHXER{xY@-JP#$51ixWqmj6Zo7o%t>Rn#mttT>1 zbu034w_i(V^Ue6OUA_X{PBq{2u_0N&NC^I|m8mb(Wd7dQ>rbZons z^AzG_j-VmPTEs>^BylgZu+Pc1*JUF=$5rF*i`Z{9=@)VX{b|^SEJ|KYVr?>S*y3Q5 zWh}_-SQ;!{!j@`R+?M9{V4*z@Ly3ZWApFIr!uJF%%e9s7(J7f2o z$k_d2tAig5ymJ;MCR`B+L^1V%+!G5#xbpMJ5ku$ky1&;WO8<%MO$(eV1ph;f|g3 z*(RxUzg#C3=7t zt+FWm^XC;Ufc$oL0J@MX=XO4qMrUOCA^ZKznA@M3<<*J7Q&hwQ;GQ4c^J`Po0Js-0 z!=G2|mPd}--~9}_^D6w0J|A(y6IuW5^q=oH_ET$NoPqF8Av*-2_OZ*V>s;X+0 zH)1QEQth|j4(Xv3G=Q~HwgTAe(I;<>AkVXJJ%g_I8F2AQ=|hk)1^-p#hGDQ&ZWxs^({8 z?BjAfx@SR^3)Z{xa&FMqxdocO#$P@yu`!I^$Fr%gh^=RB!(#<}@F>0?1=HdBM(m=Q zNBB?|hIkw6MOWzMoK(Io^4rL^(BZrXtWWl3fffGGgN=OC4#4{avWD93yDj)0_N(x9 zir>pi34eslZYbzoN};Fa=vm66taJDwRaG z%`-}u&4YeNDUVVfWq*sZzeRPwI$vL@;@cs7Q7Yf4YDZTP5W6;PfzV&x)5Ll7F0~Hc zOS_LV|9ciFTCz#e9@vHa7kI-K84Ov={x$UXbIq##xto#KZdUEjTI8Fzh}+LTK^%Yb zZs9XZ{MdbA)@)&c;VYbLlpe}U`VP%CwA38^LXC6lWx0lb*&L&KMo!W{W3Ca9=lS4i zD$fX}<{Fhta+1L%bB&NZ40djj7N_;NsJzHOzV4bvQCzbX&+=mUd75MJFq}DyxDC^Bj272cj zH5;;%p$)t*nv=|m&b77&HS695ns$GaX5F_-v+n22=)MI$ZF>`XlJ2mzWf!{R!t7*D z;T+~PCz-d5HdbaO3s%l$t<2f{d(n3*i->EkTmy+Qswd~^JvY&>RzFw1nJYQa=#O0a zHo2~2PFl%}wN7{);MRz~I>?pplq=;`?v?S8^0m?)&*4`qxh|#sTK6jTgZi^Ks(KG? zm$ruWoI_LL+vm7^VSrdbW8@s6>#&`3sLp+s$bse$K99Vm2M*1U=Wfh-7gl*wzbF@8 zIX)Nq;ZOQn=V-A*Gpv|8Q(I6tll&tyjqsAW`ZMqgQ&Rq9_|P1Ce;)jM`&^4Seo3Wp zuAv^9V?hU#a$PuMrnM+Kle}v)$yGAb(0b?S7g5(p1(MpzIfkD(FyeuvpZ|g0IoiUN zGp%{?nc6uUW?JX8&eTqe24&v#=l#gW8|GN2sljCM5IEU8S34~pOv?4#_LBY z%DMI>d`E8UTn&4mWNv(}k+*WLg?&&`uAiJ?YM+Xl+NYP8)~A=5q9+~HkxFig!5ndd zm+o0;|GTb!)LOXGv=+rp>#Pl?Hm}w6^4#USws)d0wQoaLD!DWc_PKU=COJ=?tMA}! zwB6*JOuotFn@l$j*GuT6pT+j^j%@ebTF$2j^HPrN!^n1>t1jVu`(Ln?ydPeRK1rU; z7hWf(+8wM-?Bn`(&|ltt;3@i$O^((t55a*?6Io9aS##J4bx$;^dM6sy>dEkQ6QO-4 z8~Gc+5ta4WI>#uOF*jK-dBmFND(TA)T>3uv_{96*JixwXOSB7yw-_$&$-yUge;N>L? zyE z@L&YaNd8(kZnNM4vB14KI;?8*JRESAe@wL&XYfFD?0we^!8_N`eg@~x%z0 z`D)CUE^zbJ7*%Q&^Hycl@T=ul+ByjteUee$JBdAMlBaJ;uQRH;C&7bE0`3&%_Y|WP z*fM_Q{3_L|zTChfXx>EVOVzYs$9QdOG_P+`kiC!c5$zAPcWiydtv_k7e&3j2gnbr% zIaSd2O52&owxd<13iMgTd?5ycoi2t4MTQ<2An)<$e!;u?Tt0R}$9P@xEM1o79^KUr z_WoegR^E}Z$7?)K{`XDV8nLFSd0P4jWS-}c^Zvm3%b$_s)+6_PAKC6l$aX(Rw)>>2 zJ<8lY`eo$0Z<4Pwhde(YA-B&oauI*r-S38IfSi$JaLYV!P_Z6+g506caSrnb&SCz1 zLfjJEaWdy0f?MVl&-32(ocnwqS?fp0T0i&fqL0BX$@gQvHjG5p6s>6=_9Po+NB8B?k6*J9DBvIlFiB~z)-b=g$vb6q)= z`ds5upX&yx&$U(Rb8VOUKHe|&xpqr^pZ3Y#sn#bCO=a&a&{tI`#IP$es@vhITG_KV zpu30@%W8=RpQynvBJ*z$KcHOT!}t&jFP|mn!mNp~_ZAvQJynZu!xOk4l5VEF3bDVcJqmzr~%K3^#4lud5s^YoMOXD~z zSM!~BzAJimFJIWfH;IQ8&v(9NgFEn%l2ht3&gG0$zWJ6dHsh|2TyRLMRSTT2-zm0I zu5LkM(p$ChJoCt%iktYneDtRy2 zi~2?W=j`V4M_CWQCC}AsoCy(+XT>SlRzwS|GGq)RnoVD_;OS4+Dx#A6d^Xp7qfD;w ztL1Wyqhpe*O0IPGc|LO@&(TA=&*8aSXL~yBU<B!iQ>;C4P zRjE_8%IH+ad#YBInyO6!k1N34%6Jw1trGqnebgKJ`S1qkx2Wc~?~yYL@@uirJkOcM z(QR(-D*Lld3i+^9=Nnt`YiQzZBFQ*h$9YSOYm4Tr*h9`->c9H{^x-AWOlaqaw8K8& zymT0TA6oF%z4$ZCQ|-OXrT9-=iGA98ce``zyp@Enc$7ApWNuvF3i5LC{s%dS`Jv(* z-YRD!?%w6RaF(k7Ea8s%?t-3i^^_WD|5$<{#mO`gb$8Ve)x!26TYE=^*xKFYQ$A8{R1}557XKwoj@0 z`S3L4M>XIblghF=hPrZ2Qe84f&H(MtgeY%z$58(w`Y&>;%J|vOhxlHeKTF?#$6597 z7{|{ysrKiCs{RGO^*`wQuaOUsdy>8-a|~_SoTTuc`;iggHIx1n@=o{MWB^|A;sm^9 z?_7_s+%P8@f~UQRx?y;laCEK#51GvBo?~A~-R$_>WcCL5$kw?@@SFAA8uvJ8DF)q{r&PtJ=Zpb=H|zQF0wjcPl~oip?loJF|v7@5TUiaf>n4D&ej zylWzD)yVVVxo!N2p{$$%zR!S;X~?S6d9RjquPM#&$-OG_7uTrY(A;u=(!HkqhTknm zZgR^5M!+o(B;9K&U z%>&=1UP02mMnz8IKCUL+YYJU}3+GF6?IeZ}F$vZ|4}C^{`*aJPSJJ(ve4LeYuWCuI zoIBSrF4GyyiPHidC4BD;>deq8<1?(v)C{5F(Bawe7qgApZlUYcjZUY0I_1+1_5kFQ z*+x0#m2UYdl%GQRDU@@r);gW~)2Tn5`t(9jGOHl}Ov zwDtKRnfnjw*BP{X2JN0fyJwuBUuV$f8MJu@ZJy!zg#=1zvr2Hl!x??n)G7h*Q zS%kO?JJ5H&GeT}?6IsFY<56zT$P!zGpUwF8tUso`vBb0Z?dWG+V>rJiH)B8<=Nvl9 z$%@3sBfd)^dYd?BFB|Z+LxkPGz|UG&tQdR#K!8}t64x_E|L80I>ui&DJAN#93qOYZc5GQ2 zWnLZ8?e)y?D50!#iFa#w$tVouJX>QkE7RX z&5XxV#^X{&;td>Z1b_XUU--c_^uN4E<2@Sh(ZC@M9P)uf60^oH@6=-8+A6+hEWX9= zH}tsulr{$26TLC#y{rpp`lX@=S0a651DuyEMh}ed#niNXbJ(lj?~cJx-ARGBy|z{| zCTro@IS*&74fMwbwvEsurH=O!YvX}r&IWJ*n=Q^Muwz8mm}0%id*iD2-o`WfN&;_M z6^tEpc6i(q?mGn^D1XE2N1$ECd$1q2U(Q8Nd7bb6P-FbRJigWcOXFMi-!;BsXRDV~ zDxJj5B6gQ<2KRvrL1l#!=x{`D2;y zU3lu?_saRs@b|J_2EW(sYyYX<_$-{}eQy_QZIJdwrg?jATWtmgK10StzOC`J(eICC z-d{ZU{xkI8uif!}-}fh6x_U#V?K-b*p{qmhH@x>3e>4Mgng=6e(>P_+*m!gDgf}N$ zlScJz6dr`k!Eup2V|ZLf;DI|XZKn6m&`jo`bkw`t@{Y{>DdR`I>$rKC@^L-b^}*xd z&BMnt--E#+-HcV?@%@j%Fa2KX=N?}+ zYX;w(t=${*_SG%2cRa>=Vvex`$?TawlC>fGg}Z+QSgUddz9~?o#kP3+!D=CSL9dzHISDVj?oPD~39 z!sDIy!L-1AM{N3NyqnIPq!f=YX#5jYbefH42R_I`FX8-KwoKE&onV(c9&Q8|_ z$lUJyVkhvnRl#?&pPpzhwKI6Y`wv?c^M`n`!TlB9?oImtfpP1E?%Tny;`fX#!I*u1 zvDMbvvN*qmXY%;9?SgyoDeoJ1k9P#&6WzG=)^_S|q5k&AGxcNJT-*i!4l3E$34*t7 zjCJ^uzttw=uB9{l&qQp0;X~|%$Nxw>F7H5_eG}k+m=jla^?Z3QCcmMarBC$gjNo|$ zer(`fd>HVH^1I_Kd4=V?MRb-K+pzKCW8(CqCwhCJz}{3z9GhK?(+uoaThUv>*Oo!U z%892Yaa4sTMmAZYglMmnH54Il#8=s`y2v|m9@hxhQn|+_=sYRsI$iF=@ay=QN4QRx zwTB(Vr2@}2BKJW(aF@VyZ4~$b<#LZ-x))O(IDz-;0ijR$$_DO|d#+=|e;wTF5_qu_ z$klrioIiI6f6O{cySjg90e$|xd>61Yw9cMV#xW4pgHg4!WHP)!(~s-6!T*Iq7ulid zO5HvD54T)whfBo{3tkvLur`HlZ8v?0q9az}i3>HO1{|+FByRF@&xDns*fQr-!k(f7x%&o`PLa(64P{GT>>nDIvxn?b^{E zWKNALY!0i-#m?}Ab`|FAO~hCY{zYQ(48{eMTqo}bPk%pDj6Qg9@=?+!crQ!(wJm|o zS{nU0-&VCivC6QqfG4w12xd%*_s&80I_n8lo;f$~SKZi3JB}#MdY*SY=RP-gfNwXVTb=a_-nG?@+3w}C zkNl@m%J`O*V^458>uEkR#|6;L<(xlU%lX3^6`K|xW9iedIkd1bLrywjY(Hdev31c_ zKsUJlO_|kB%x4V?ZHDJfB*6Jw*&kWkBV|^%toST%Z)*MoJQ4W&;}J4z*DYTC^dL;c zgSi!YF(|V(-t_-QnN{Rem+u$ap9}uux97==k3$pS=gS89j}bI{P<~a!Ht%oCuVOc@ zRj?l%zn>hp*AB_O!cTk{xpz$9T~Gc*?selpb}dIfdiz7ky<-E1{~>a(``*YG*n?jC zK)H89;E%`AFn26n8ukb9^?l`Dcb+QY2~Idq@QMF7&65|?Wo{sYo z_Vi&1;?XxK^=F}v+PGAy-xVMaIlPr$g|}0o8F#_^+@)l4lr=b^dn0D^7RumbGI|i( zji;#)a}>Tu>IM$s=Oz1pmufd%7toh7*NyNb_!o)|xY)$^Bltb&!#K28 zyYYo9&@Yrje{O~rRW#8Ce!Qy^N6i3o4ZgWzFN=M|(faTf%ICY~;=?nzx6-a_+bA^O zqr>kqiz4l;h-j5CX05%W-Y%hwj$*92o zVixunG3+mvVt>(~YCBh9gOMOV`$oy-u4<2WsMh0YRePdGwVvo#wI>HM=i0l~x^rg# zdZhil8?!>rxH&_Wm=khlE%sIVN!V9mYe8%|{KW8Ay#srk`mb|N%314cuc=PoVsbZ@ ztLBUARp-U4uWwU-(JRR9%~rQxcqizr-2uSaL4DMNGf7?DzZv zcSUpqI;TWbGq5(&xoy#dc5|m@nv7REfd4T1)<-HB!&P$b&KWYcW@2YgOg8ht(|pHE zO8t9RlKX&P==Zc0^4e;?GSd0d13$A{u6W8c$6*UI%k{ytC9b6ShhI^EU)-adg0NrtSkeCwqP{_3cIZ&>%&@0O|Cj2zlrSR6>ers0)e70OyiG3%}6H=f1jZ&X$ zo7CspA@%**&a@Al@_|!6YuA9(@mr4vH0!Zq&DvR^@gD5hyD5ud*U|0MezjDyo^0Ux zD*Qa8odi5Q&mZ5YX^*w>yaRq-;M3TC$h8MPpX;ysH7h;9_qG!=U@Lrbif`N+aebj? z74yHt`;R_-vzt$`@e?-ZEE+c6^|vOb>KpNMD#qWb1pLj|lL`LX|LWNYYEz;6a^~~F=1c>>>pnptJc4_oLE2nLT^OuyFL7O znwLlFz<)h_#Z%5t#9k&I6rWP9DizF(O-RN@GonGWp~1}`WL~*nsej`Oesjkc+_j)1 z%W9R;ka=LYXV>*&8}Y7R#-HP57gwE^cPaIkZt+8p-Fx;EzuEMKh+cO9zmL)N`mTHV zFXpV5z3&C*rEcG~TX?o*_*r5tdGuzfX7EYI26;g6Wf(tBmUB2+TlJF?0i$XOaW|qN zi`eBFajDGy`(&ILqqyrgBsNDH@d2!9s?X`i-iXUy?WNQgX_t+5YS<&4?p$Zh2Or@e=YigHt(KzA!ftI5${&U4B~y?ZSbtQ3bbM=@=gre+rYVt z%6g{He49}%*Elpqu2JM4xvJ0=)^^!O)?FKGa~11wBWt~bby>k$h8~p83ZO3%eb3+R z!-jo-zS#E*e<|lM$eSAHdzx0cR=D(7?y;CaHr!%a(ci~$eb_yFKw z7BmNbVe~grj_*78B0li=0vOosajwqyrd*#H+6qcrp6sg($Udbn9Z)m$@l_W`^8*uT zN9Lck85h5rj2;DD3;IHrHiHwCyK8}RWM;;Di7CME`A;yCJOhPf=O=B~K zPskT7eDohx>{H-(o?Wfzzgw-EZ#{~=7<>6!kC5APwQGkbHsRP+DbCTy;CIdimc7BY z6z3{zw%*z;{`J_fJ&j%1nX3LJ?5?Ej;Pt$N=ih;^sQ->)erLD%-FtR@*Blgof9Te3 zVkI=G=2es*LGQP@Np-&dgcoP63BGCe@7OEeQ|pgBi%x_eJb{kii_53OXL6nBG(8*X zglDpEhG+W4KIl0(^d)qR-%jISwFi4J=3V?FzYm{sun&8;-KzPA%h)s4sZIyKz>g#P z10K)hB-TZTc&2|Jz;B;EzO#!MH&5fIpK$FI1&`bq059cWH{ZuThCZf_AN!a+$S;MS zh<5hDFIn|ZIp+1mrFc|)@m-!%?CG5TrO>q=)%?nMzU`ajK>a3hX_cs66^7S2!2a;I z;(Vn;ssBo@W(IPj!poSivOm0bANI2MW%h?I@(_MAqMz~7(UEofZpi(sIV%_bkG+t+ zLF)CrecxZqj{Ao9hFSOX|Nal+AAYW1hdvg01Dhg${e&I(b!V{#7BjwU+29va^svcd4~vHf`d;nB|`@1W~ULzn!=x3|)duE{^5y+geJ1NHt!=`!*NtHHmM z?n6`9t1>xn`8M_>e&zfsRpM~Fbf5j9brfxd?nA$NN6}U2zWDE+fbK_r@cwka@%y9c ze&Zb@=)O{adpdY5-8b%GzPCR#H0P9K7s6gv$zE2;UUnDdcT>IvoY=Zo=K4M6`hCwj z;0weaCMZ0BeE;!tp&|>b=+X!0w(A+--#2cLzIh+nG zZu80llPQxi%#!z4d1YHNWiy7$CI&0LvWGHd(c!X5!E&!`XQph)aM_r_vb~wIWy57- zgJoX57c*rmhs%nBrC!#JC1F43~`$PV~x(GG(p9WfOuEyt494 zS^IF=#Nc?Z?DR}oYPf7tu*55ypDF7eE*mpgc0s1Bcere9u*j>oJX3aPxU48R)+@U< zQwGf#oQIO&7_V$irmS$dYL1TvinH>%qgCS1$a6%v0PiIYI2;(jz*y zl`hV`K|UW@mqGCIHYxK(XV@(SR(Q4%@MI3h&-&t;@R+wz$m~B#?n}DrqF)Y zbryc~^fjJEna>uzCi%eJeF5EOrj09*zp|hwS@mNB#6eS`K^ufNdGSEp{ZCm6JwtvV zjs&up*Ip{TdAiW3i15T&*!^KAk%AXTeyE5_j(YXjJ{hI#_hsbsDJM>F<-JN>u|mHS zjK#f-1vZ^;eCc(m@6qt4d7l1KVu5tcU_4wsrA<5`ZCi|ULGm9Z&@pz>MoZw+c60Mz z(3LO-oE4I{LPuw-lS^asS7n?UWe<@vs6oGLw=KOTNZz*L_Uz!Lj8n+1>z!Xj&iXL* zI{6N}DRBKz-Ai4&4(&vBNA*9ZDxJ-$^uNV!4qf#D{eSI5Z5`YH&NjCnJ4g2;^5+jz z*A7Nb8LH==p)}4srrsgsuY98%KbW!&`G&-`sU;RmO_Uf+#A2yhhTqIed}!jtX4yb& zmR4f3wC5OQt>jC5<7izhYfI;>A5N{?bduhA-B-1`-*Lv59oNLp+g(>V6|3#_fs^&X zfxGP+7o1KG;%4jt)|tQ9?lW)Vm)@v4fu))`i(jmboHq$%@}D(1l2e=<-I5dB2{&lw zW9Vn<`2VZ@&bg|&crAHzHmYXRQqAe$mu^$d z1x>X3c$0bEh2)8#ekb)hX)i$=XI#fS`1vl^h@T8Rx~1JA>Y%IH1^i>^haOK$4!!C+ z&MAcs2rdhs*~w3R({)7 zbGG~lJn}q6JIzw8(;j8d*XY}1bP(t^OAFBzqDm?+L@q`)u7aNhul0x+O~5f<_h^hiSu%g`0TGlHeG`5qBnrd9kA{` zN7a%yt5%YjEHx=|BvH2%T>)|Cv~8SsZ)>9NF5(IVX}b{p!4hInEJMezGDyq;Vi2G= z+q#P~(45W=A$3Whu-F)AIr0pfxgH ziZ&t_+Pg+=A-beE^Syz2pUnKvAQo?wSiDO@G8WdB*o|(Cj&=Sb@=g-dXg+%a{J4yX zm#_F%ZTlLZwS6b}3SL*wQ0)Xh&;jgG+;Zg++C#s#1bY?eMI!Mfsh{z+>*GIj4gDON z>&939$LG35VrUVEWz<|NFSt1aM$U8TmJgWc#{W2Go(~oQL{5`_&_3sz!VB^%Ps0OkWDH6brQUxNy<6vpXFPTdbhZC|Yanv}e{BsUGHW2x z>8*h;^|*6t9pP7E`e#%1`>nD7gBpbHy0;YF3TtiiX~&vMyMbK!Mz;f3IJ zW)O!iN*uZ+Ih`);OMCH&TKtvovwouQyMEmD75UoWx*5q!biz;Qp~Si5T|L*@mRJH! zT%w1Y&etlN&bO)-vZr$1Wb9TfgLAOjg{oEC%wD>i^NN+=5qo%fcR+Xm;i2I_*t^rj zqhk+t_0#YaHSGVj%ZNoCBd<-uwO{l21@`_L+Nezhv?+@?Yir?Mdw3Tyd`i2a`K{>G zg$HOy=d%c1IOkkddnjARp5Dq?M7x|tWNB?pOObz;8k~t4)x8qijlF+KQ0)9HczSIc z{n_UB2U#PAP5!Yb#_LA?gYmj+{@`2;;`jd;o$}_ycp;LeSkaO}OXidPI zllP@Hk@r4$P8z2T&cz96%|+0fi=Z{1h1Pr)T5}1s=92$QXw4U(HDCDeqcuv=C|cv; z(^-S~{XdM?!#t?lkFJmYeRv(2bqrpANLmvZQ8R0OeUpD8e0+GA zHZ)dX<0f$}+5byjeW38H_}CIJca2(qc}Izv_#W~5cZ$!?5hr^)cCy4Ji%q~Ewpz6o zVE3|+Sg#9-d%B3Yr;FYr$IUuLn|Fs|%>(wFpSgYxBjf)J=0_M6kBQh9)`GKX=X11k z743XO;;RhhO%fZE!FmqyRwO^F zJ|xGC(Hf=xvJU(tBD90PqKscTZC1|kWWWGC`Hx*WVzpJ8dS6>|XsBmD9$e$;FOh>c zyL)5fLgZHR9QajNuPN=hGGpVb$U*OBc(?iTe&p8h=C8W(zF(!izlnF+)C}I0WGNC~ zSI=6!QD61Z5i-JPyfd>Zum>$UVrOOf>MwtGNN4b&@h(4WA~qiIH}G8WIPgI5W1mrj*P1X*uPUKXq}^_JfnTfg&?8m3$nJ{r?9iMZR;0q~DAvQl&lVheaI{<(OpeC|WzpU45CLznltI2btv9DLcu!NIa2JXF$@9gBxP z4-dO`4&ott7S>c;>D*U}oVj3s-DdIaXZ9M%I-=mNB)OK4E!4}C>}!`g@O z&mR+b^B>};;J&x3uWx+dkCxcbRm4x|Q%LzM@9(Do?y2fC=;11jns_C8xJsjH@)T(7 z6r(&k1wGspN=8AE|YN+ zQ%KIs$zjCa8BxvIoTrojudnEYzFAYinJM7R6mVt=d~_vzbR~RrCA!T@Yg(#8;~T7+ zXoYsFT7hn}oNuoZ{#xE?RH`M~Q+&tHrHZzz0bB4@*fJ*+>(PzaM7I&s4%@`X(u(zD zk82xlJu<*ILvx=l#`e1cyYE@pe8*I5Z;7ARplXksLM4llNmoK7hS!(9Lrs_DuGj*h-82H#V~p!;`gHV)iFx4VPepsyctHQL(Z1 zY1kTzow4=kEZ1(a!kc@L5l-@=08GH|Cnyqff|oV|$8SuK7|);S2ikG5e>N7|S$$#)f%UzYn{5pTsJ4 zZQhANDRI~(KAW3A=d~|l(*^%feW-|>F4!+^mH8>+n>D^!vvyZ#@qU}L~G0J~}!w)7a-+U|V%3v2?|Hefr3VQX6RkLfS4J;0`c z?FV*X7`Eyd*h*=)I7ol7rLPFm-{6Sx9o=r3z%B(g25bYctA=4qk7>8IJD2_fn*g>A z*p6Y?n%3N7`U`9iuxViXfgKozC1&I(*h*=)I7EL#^fyF*i5s86v+`qL%LH~QurXj8 zfL%2VTY3y^Z8x^J8-Yy#+XigMFl6j={sP+rY#P{pU6_kqQ9eI#eXKf6xbNB4ZyA%hQ;@NRJ+)j(_df{z_tO~F$_!om{G9g z#-qQ$rh)ATc3>D5S$PyJF$m~y9{tUuzj;=AR-W|Nxhn1LvBbc1UWN~;h?kgG7ITf3 zn6GT%s+KsH!*5iOFK0@;*j%xVIHupiZ|cv;>B#CYSj27qcgmy1PW^)dUkvY9WWLrW zZ53G+(IUtFukt^oo3Fdib)M^v`=8Wn<*Bjea(P#LEWFlO=SBCuV}UO;|KP$G0$=F3 z|5g5{#yEd;pO4}B7>UQpd-ZZtdiS+% zx#W=vy5+*ZRB&cn5%uoN!UiC&Jf=a__#LnEG;u?B%`YEB+dcG8#T+uBU6kwN>d+!FZ+m5-un@3PCjB( z#U~(ROn}##fbGu&%8C6x<7A_J*~!=jos9k1$wqaY*zfHp8?~*(;Ej(lh$F6nS4Np! z)k33OuBkCbrCj5M@QzYmXjHr9_6Rmr_6*VI_*bB*iNmvV9{ zxaCFEmvWu@QeH&;GRljn&s8PQn_N>x)aM!}|C?J*E;zTmg!)omOnoUQUtDWB^~oLA zT5bp8&N@NAqmB~_A%@iWua3Cp=NwuhaZqi~MAQJWecXO*YMY31s8>$K>2 z?X>uKt2Q-Wt5r|3jOa<45kHA{oy0qftTGiJlqlmW^UOGx%6z6K@Lri$=0L7d=ApGj zADD%WA7|^?N~yE<-Vr*|S*jE0plrfls57qqz$~rvr<`f8UEDl*{*_Gi};zZY5Mb8E>rht0xzS;XGGSv6LpyZw)R@{VuBZ{%jh zu<)ZGCrQ#;rP`NZo3sXb_2QeAvmIU9Dts0FDKK-}rlw@Oq zDIf49;{%#?TB?L`V_eccatG+~N2W_70}db)ijB%GaZfk9YlY|u(9QZcU+U(2vytat<@|B1QO>$9 zBcE>RWY+17LZe33{}O1yvO?$xG$LL|c_C{6I?!IgIk8{Q2@vBbpjhauta}sam3XJb zRKGW%T0e@Be=R|7wX|y874TX2#mLW+@M-s_ecFQo&3Z7VX%8eg<81d?50L+KDfx60 z2kzJKE4Hw6BcBdu)4N~j{46CGThx$q*}!hnMq+ zDQ0?`?1A}ptInK;{^L|9wu3Qf&+j~#b(J01-QuLVFXR51U%Ul;%8cE^IJM???)&{E zb(P=NI|sUV-N1^8L{qqjU*5`=Zz- zEWze59^kBiGv`)0Zw^DF0v0}f#K`gKOVLRMm1oFn=F{+3GsD}67muB9QxILI*zCTc z^nGQ2gKnXJEMKJby?6LBJyd}0WQ)>w!_iB%se8Eo>5JBBVYTnwqo22?E#ms;&)G`8 zqSdyjeb*hi7<&e_@9j4))GEThz8eNEuqqZ|m)0KcdwbwB^qalE#n*Ru;5@Bj4>p#q z;l8g8oCB=ZckRHZz(xAIh&kc;R|n44Dq1wk7f~M@hgNJI3PaSBd}YDDZw$;QJ_Pm@ z-C_HtzhaBrPF#r+<_dd<@)_jYQnQ`rI&{{{s1wb00u8G8<~q&bROzxH^eo#9UJiVr zUlV>OT&$S0?or6=1s=rxR;8NbG&L!DP6*#<_@lrIe9!u^XFVXk(m7TY{8|YAd?UsG zc!7fk*mSM{zgM8YI+K|4*#FhQmuUY-)vD)luJ*6kh%l~O=F^9T=z2auoP&=lX7(SU zWoIj97CNod@JX4vm_A%cOoUIM$NIS96#Rv?cP=rF=BU=*A{Odqb}y&ArIXDa$_ zGl^OBBzXe1B6d=?Y6gRBYoNpMpU$VrPm@)tGH!WJB(0c%St`%-%w0TR z!`dd+zw^k?S)WVtotvLiogLp+ou<8vWw-E~`R1aZfxo~6Us0Wh7pPA7BNjDebKYAdi+ z?qeM+%Qy4>DtktjlXC-k)xV`UGk>N!>n~wUrRP+nj@A+klZz=>_ehjhKFZ%m+9Op9)kxMvA+3jJLAmS+Yku)!ui)tURycc${4 z{2tXzoS~Yx98jHE&ogelc}}Q9+5&c!Vz#`;^NU#@YM$d`k11Wkx5mNq2Gwa{tUGR} zox(g*qpWIKwi!F%&2jqQ(Q5~Y^B+*1uUrJZ+>oa)K%>ng>(=|0t*b-rrm-49%Afl=9;?}QeD6Uc)d2bteP z`DXKvz@1)f@|WbBYgY3va3pb;;>@~0al(9iZDF3{zg@;H$BhL>>@jz|s+NGGamFR7 zII&aV)!>~r6_ZbQ7wxV@j|6YkGr;%An5VL3FLPpbLvZFn;A(r(FJ$1Z>R>z$W0QXa zdD}8=2@E(k2xGeWDR%;M*-$&qOY*)#^eSFElE;@Z4ci-M$+z%)7Pv0)$%r#>Zwx*z zkiqL1^U<2^3B~#7b+j{E zwH_=`oVE15^Lx+?;>+FgSJmwNC3RmH8kple(NDjazx53sy?b&8@!;@%M#gqN^)tSC zyNq|PbJj2Uo~KpkR|Mmd`^5pwv-!XTr;d`FO{~=!B6ug5iFMI>**17R3l-fJ@l#`81}k~XqNfdgNptIOSQ+W#drEHc%aq- z7Y@0|xzte2dDwuU8^EVT(dC^&`>w2j=1k6V-zoI3-eLTsxlSStp3G)lHVLf~5D>^K`9E7w`T*|5+?f&KCb*gjyZTjAZHy)kG}RdvP9X5X zsBOuqo$O)g#b zm&)EebHO!3Fy=^@YiJMtnf3}?Ucc-R?Xi9b+q--}-_)Hy)TVa^l~2F2%yd#QcU?9N zOAMGHxG$#_4SB|@j{D)k{8o+X*G^4o!e@iSK|3#?;HUQ#^4Iaa{0H#tdO-O5)?7Ux z{C(>X-#?Ns2RB`weTa|G@ae+8yF7h{&ljG4karhc1&7&7I-t){{;Sy{>oDip=7Q^> z!Ex~LLZP{Nmhhsx4?<&^hblG4S@^D^Ri$#wMdOLp105-g=Qw+aRrSdCgf~^pd0$o> z)}(n3K1j7{zH`p=@R{*E^V}E70hJQ}{{rXS!>UGJS*x7+-nj;UuBECOi@_7cHD?#O zuE-Z)E|9B=uNJwhh~a52lxs?L_S`PdedZ#$#`B#=zAN_y<~*BgG~antuBm+UoIB;- zXP)~*u5q99l-#F$=KR~Zs+#k(Jda9zf>FNf#yv0M>ki*{pIS&=hO)a#hrN(GA z@iA6Sbc}YYI>tIRRe;Q_yEdk-|G=&vB2NpRgf^GDb|C-m`4#NCQ=WUzlz+=S`+)~5 z`8Nc%@#mT6|2hndFM-$Y_cQHgV7ng9Jimkdx+248+KzN)o`27SSF^mfyE-z@Zy$zj zd?@p5vpmxiJ|)vXC-Z!h`#g}JdEVHbdA`wuC;zD1Z{^3C=eK#!3kKmI$UL{bcChvE z;P1~o|E~9Z2>wTz=Nr6su<`NWw`ZQ;>OCLo&pnL&UZb|K+NgRghRy+Pz|nD(}EfP6ZbKvgScsxvqcKV!SUb{lK26aSQesUBvBBC+S%$ z$H=?Izby0qO|;{eXRdwBU4k3RMm?}nd_3fN#>S|zj{J5!yHu&at|Q+L{91E*+K6Rb zEU^PQ8>zrQM)aJ4r1;QiQ|W(JT>SO&@rA)ZZqO&K>pR3!4%^bN>edOy#CC~~o-eVZ z^&oxvswV!s`{dhfw{BxzCYH^5?^!fVpRlVEIOVWWrXoZ0Bfg8CD3USr%H8j1Y%v=B z5>sL?Yi$~9Z5nHB8f$GDYpt63tZ~;8{ni8NyS#Z1-fiPI;^9Kq^%57_C~ci6cGCD? zEf;?b?6&H?SR$bYJMd%rtxn9qze1bu8=q3EU_L%fjLI?YTK@R|XJb@)e&jMI?-!%e z9YehZ{a#xFz9%zokzmk`?YWb4*BH-&cPVw)rZF!|>R(BN*SE43B0;kWed&d}hzqoj zxPmg(%t{n{)!Xn&?B6nmp?8kj z#8h??{m=>4v(%CM=7SM4)X!L8|A?)Z9tbP8&;obv8Xq3{9$7=Y6PrSGlQkRgXPZoX zv>E6vqnfo99qjIehW(j}e|}I85=-=J?}lxSI{a*(BK|+=U z%suFM7NRHEvk#sCS?-f65OP(qL`AI~J9b&)@mIfwzVzwjZRcD0W^>X}#kuncIT9aL&DVazx$kM@UA2jig?(6a z$YJxh z<$4lw+e^0-6LhL-&8NSM(UC1~Q?#=?M%k20+)w+51+HzFS&vQm)!!zU=kvtwJWTsB z+ULFJHqibmbb*`!VYenZsHL8>{CmhcA0uxu{Mxy!*~P`QUjcs28fsHwr8?IfCKl?; z=;qPM-y8F}c5B4VG8^YWHjS;r|w0L@{&Bn4WRI&(Ziv%rWr9{AEycZV77U_2A7ac>EntY37=zG-u5h zea=t#AwKD&r-@#jKk^Egk;{V%=u>Za_W_ujBCyOX{f_w8Eeww>z_A|r+B zI_XPjVUr!AFP-BQ@4k7h4V{;J=}W!O@Ar5#c!Raj`$RC~FW(ptduErHlK%Sq(29sp z_cIn=|6RM*q5C50Q)ZMh*JTN0%nq@IW<28}AHV~_=c!%{k`FsZePRE5=%VRB0--M_^Gchs5I)Krla*&bSm|C zf-jW82NJJ}|HQD_9C7_ypVQjrb5H%IUE+(3Jf8xV@4_ZV$5ve@7ln7O9qB>-C9YM# zhs>cEca=kzw#YY+^5>xMn(PSzV-Y8D_+62`X7d4e&v8P(j+ocKgFd{|SAT0L+YEL3 zz|}^ld4Ht-rGsJ49>apK);92d6X%fpx0@Gkw8MNiaa`(OdqW37ECzn6Mn zmS1EI7YA;2`P!$AyZp$_r>n-6HSA~L&^>Dehmh;BiAR2C-Kg;AvUa?@fAAp3e`Di= zG8dlAk+^3#<`Uz}8j&&?8~3WJzejE(M}3@J^&2KJhNm!wrx@kYQ?QvQXZ*JB-R)ved$fW$*|QWY&3?G&0%CA4$KL!}MccIo+j4XR zPq7xBen_!)@5H8lFZSmz5~KSt`P}DYPksUR=F71qzm`2#BX&4vGZV4J{sB70ALOg{ zt+%M=E9|Sp6E~OtfHG_;PUfEc%jU~J#*TarvBO`*w)+S%&39tMz8Bkd^di4H?B>q4 z$5@KkkjuX8`h)eI#~%J~s`bbk;BEtMi)+8_ynH70A97nG<)&Tcn$x$_!&*;nr- zb|v}jA1R`r<fzT#!2?%o-_`0Tu)`^yg!8`}E}!Gb%8eQ1MO6SbGrrN8=P7=LY=jw~U z!2j{i?u%SMJ~!s)<o(n^2gcp2H|@Vi4_%S6n{U{wuP-}j z)GpI>%_c5R{UvtrKNEV(q<8G_(Ixikqp$1!7oSm{Dq_ErvwiHr zx`~s7y-;~Ov69-c6I;f4{jwtZRb1EnpLcd%|M;Z3@Nb$suV{J^Jw%Qjh!gKvEwY1Z zP!CsjfWn+V_MO0e2g4Tg3MQo<4#9 z&O@5`&bWRs&?1p7%olIOE^(%6Uin$-`1yt+>XZ{Z|8&j%KJ@4ZH$kVq<@($>FaE1y z-;wRoG3S-fs8(5Ale25*g-4)ApI7Q~p+~v7ZwQSNzgeL<4*s$B#1>-EAB1K$ljmTE zo2OoAkaO@qp;HCK1U`jz{wcoypO9IgKlPVOz5!tAU;i{>_1>X4UvDP9aSJqv>*4>0 zyEl)oqC6Y^XU?1@8(|r?vWCpbA%qaX0b~2LeRF^SYHN#>rS5QKu~n>4koIxOVMy4u zI3m{8O4zk(i=#yC)0P7Su&uR#0c`7nk;Pg!Fo+1`_r2~p2?4R%w?2Qozdz1r&TRMG z%eCLvGAB)gb~e)>i4T(bP&FeYmZ*LNyg*r5eUopQDetGb-{0-^cC%{%7*Yf#A`Nedx0Y}^r$1^t3 zXNBf}vYk)7NAAOx?^SFhuO#!VXV9NB`O}N5@%`N(zQ6dM?v%Xf$_JYMM(8gzj{7n0 z7p6KxXF78~i}%?BOv*l^;6e-E;GNyLuY9n%@8@riazBRea3Sp%?Zg%gO${ZfHJhZqxGV_ z_HJ-L^jZu0vAiOOZi<ia6LOr(lR3ud>KtcuO2rFFT${w@iEJdXfPy#P!3=1{6Phz_KW*r( zobkO{IhV&s_Jb=`Kbzg^WE{ORr}zUE8m-8}Rjmnugg~r5(37)C|9RcWI})Yin-J$}K${d7x(f zw8`Z7c)|?t@yK~~kr~(H4FNXcpUaejWofMe2 z@`AuQzo_i-w7F2;G1-FxKGv7I9Gct>e{AbW@x9#F)?{I{ak|+)pNub z+{%q-*Z0UerrzNhzaN|Ws(y3}{TNv5ZDz*1@Gdd;vhO6YSnAKrNUF z8s4`0H+`|z=-JsomhOJ(K|WN>75#A6zUf^h4Bk&jzD`% zXwOh+PY-C%9nhY4BM(^7>Jo6H#41dcfCnX|Yo<-Miuacwqn0qo1L^ZXp$TftGF}-g z<22{Zd4lHxZe+KIPh7y9zxyKQ&~P(edC8*gsae(IHVb;_h8vGC|G-?sh0s)JJansM z12TVGnfG2+;rq<{{ygT4b**Myce1Xjd^LwMf6Sdhtd5mmT?jmtw3sVul_jZ3b_=!1 zWKMcz`*WccJH35uZ24i$$dVi-N-rumGDHgP)1R7HUt?93K zbNa`-IniV{qX=5FID=Xo$fxW67qPFOSfbmB@2T1!BFEa3XHnAwJpmcrzT+-@W?rF<`AW8>ju){QeB*<; z)HoZa+drPK@(9R#-s{uxImJG3`Yzpj=d|v=N}swcM8+Pe+b7WZ??dK3>aZVjlza4# zd)~p}#E4WPSKp1U@hzUK^lbxj??5>+dM9A|{jfdd5HjKZpgnmqG!XxcNwv&DHStgP zhztl_0&kf z7WnM`j5I#s|9vh#A+JXF=kXqLsvMD53+0$ZuT#gf@Xg6jNlw2!M{-D($T1F|9+eLq zlH+YuzKm7IDPxrJS?Ay(^LZ8y${1yQGPd-%TH*qFWv_@Dlgj6t9#4MrcuqJ4K2A8j z^#M*SK7f9d7*?vp03QtS!KCgCwP%0|#o-n`FxRwK_NcSlpm-dp+h89Bm=Jt_Mf1L2Xv z_kbInoQ)jwI7azNjWlwta}Aw}>yoQf;4Q|lkYAA=Z0^&20Zsn9bA~K4k6wTtN}O7* zmghN%GSfEM13ubl&zOO~-e~^!IGH#&F;ME+{2yAyvqrXOYW}&iz%{VVbKVrAW;%gj z&2HHPN-RuN1d7bjz|ZKAqI2#wtjD!s=o0?^v1G`73Ap%67`jr0k8C__es>YEY}gX6 zT*SWjO4+LjxmQ;bueMotuL=>b2HhH8Nxa%b*~18%f3GAqYcqSRA!62!;5S*RSIda_kt(j3-o&-{^`^?TD9;9{Z0nmztQhS!0oH_dl4}IBK=;xSpx=w=6C7$;@9z! zrQgITm{-v6C7a0~jy~}UF>rS=mcJ7NcUL=N_2v=Fwu|^UJp_&t%QjInM@Mw4VtT+O zKF*27ja3!90y5WDQjYQPD*qS~{Iuo-j8$_kH!NqOVH75fRZhS#_sM*%B&O|k!>W9O zn6`Tivrgvc31Zsr30U)v5Ysl@a2whY)3!OVYW@&n+AbibEuWaSBY{;5R}#}U$5^#! zvtccMJ+NwVJHuKsk(jn!#I)@Sth#F@F>QSJ?&$&ZsSem}R%(g)#AB*_MwP_0ZA$+y zw?!Vb@}7i`duC`TPx9ov3hYOoPa4t9|Dq346)6@!eTbW|*0RzXMxYS$a+)hq|_*QLRMwUH+QN!*(;{>XPUd!u~W0J$`Ap23vj2 zBLnxBUi$5)YrdaMx}jtjGb?2>H}KLde6y6kX+v9(8%4%%x~5%_Xp@;^R%TKUV^g;M z)HuC9H+1Zi`pHkORI)dJX7ou06m)5npoNu*tE2D>?v*;WT z5M#$N^!+Q52RZ*+C3H9}K1arIY!AZ=G-Cw&KqJb@&o_qre3S6Wn5h{5Sb#WIgzT$}hxTh&}0Xcnh?# z{vpklTC(h4dWRy|AP>SDYN?&MO4VAk-|B=tw2rmU)XcjwL+Io9y^Lz-loP8kya#

urIW# zZ_TjNqib%ss=o9ePj{{Paj(Zq|JE^3bLnMwmM*?{an0i2j4nN87uMYV%#Ui`+dtHu z+y0mCf-nEV%(~)wcj1r!iX1^~XWX>%26nLWm$t9T)ZTN0U9-)FS6<>~{oOVfU6tWx zFPUpD?w;u`9`Ic&I-!FV8$~>J9J}1o_U_y-!K0SKvz8M3oFwk~mafVVMSNDsMI`%V z%{6+l|2EC1>^(Kl=d|aLcN>{Uav;jQ9^9qo)1I`>pU=rJu*XFHq=Wc6VB@i(sX{BZ zztAe&S!fki7s5B72NSx2^U#BMSEEl#Vi$G3pS~)*rd8*lj_>SCe;<2R99?LU9m}Z72p5Quu0Jd`p5WQ z-LOe@`&64$v^r+RQsf%jj}Eqz++!QiJ14}fy!Vj_b!1(}r)UB)$6rL}-qe<{n}WN( z4Ue+M1oAJyE&6m=8~B&T6xu7t&(bZGjNu-6dN(HmXE9ryjjs(ki92#m9>|3 z_t*T~y&6(v)~k!HlJ|=lbAR;e{z|Ww zakj)I(W^`L`+9Y8TCXlj>(zy6y}B^v>(weRJ$iMt+SjX*Tdm@@;I|HbW24N+b{WNH z>D$$@T?*Yjd)`?4Vqm6ep0H~(FZs+#ROVw;b{Zcpbb2TI8NE~efQb@ldP!QRE;bmS z6Vv-S1@V4{mF(+S`1h9R#ZF1Q*yx`ua{8x=jHuq%T@utBe12UG+PEOCTT7kF>@0NL z-agIE%0{k&PM~9ZxAj&!w(0BGz|<`QQ`jSR4ovIV{eh|eR$&sm#nKXQMl7vk7eZGq z@^x&{QxA>sb?iI)LUYh#?<`Pz+bU1ol;ygKj_v&rA))?yWJ=_+W*r;3PwCht=hd<8 zA4c&HxR-Ye&!c0PH0#)+uh>)X*Srs6X&u{Y*0Gf?bMQXCi(b-*Pusf>@mzt@vDLi; z%jmz-v4cv-X3y0A-emUsYO#IKfeu&uy0zk~XK?9U+%$?)=)~C6`k*J|4}?y}(Pfun zuTHY(n(U%DEQn=n$j8G4QRpt?V6iHJ7x)&VLqOQ6m_AyKodWf|KCV zEtyU+dU)~DOh@$jk`0+@_>r70=irf!e!Rb(A$oL)9Kr3p{q2D<_L1dyHl8`6*F;CP zcSL`V$uTAUZM1BzQCs+5m52OyI;>_{X=-!aZOZ9#YLditrFQ3JKjLNj~u`@-NvRB(QrizeLkW@I~^wzN}#Y^a0v0CLfw{AEYG50k z+I?}JCbe3wN$J!+3@M#@YFej09`)f}bn2gBQ@Z&!_CS5u^*$iZ zvHpkX%IE6T0-vH&TS^8}`4wM>SEEyVAJ85(yU*6CecbY4{(L%hEUiD9<`O0SNk^=kI^y(YaH`Ocd}tQqp1JsF*&C`FC#1He>uQ2Cv$#P4ij0C^Ulz-*0r z%9`?jwgeu~Z!OV_(>k#$y0GZLzW$3%Up+$}0HrsFo7-!l3%eg)fR05pUD%x$2$qU2Tzqt4 zqAF16jwAkhH2UpmVy~~kPxqQE^x=i*fmN)3Sa+$jYxF}0ylM&hE_?o0EI|*Rh&~w) znO9b#2Tx~RLg>Nhc}fpf`eev_sS;go2zqP?J@|EUoQNL089g`^YSx3V5WNoFah&ME z)6s+Vv>uEes`TI^xpPwT!D(evqRv+jEVF|T^WRJt#^xAb*UJ~X#U_titqy6-sp zx@5>1-M3FXV!pBzzRAehx^Fu}bYJGmz+NCaZ_w9yQxRY1y@y;b z0mE`GN9Wapt3ILgqTg1w)OqKi^R`3xpLmYWi>|A5UUc6tQ0E0t!qB_0(>sn|KKkzp z_DolfWgl%D`)X_1S3AbO+CkBKZ6k_a8%3|}gI?Pwb%9Zoyuc}nUtsjb&fhmR&_F+R zisJ)~e)>SCUuuA<>x0g#_qGwecazQiUsxq=ud|Ai*TF}xvkH4nuwnxzSkd?dD}U4k zD{sOCc<;5`zn1&gf|u7q1FwbdPAv5vdBillM{Ij?z`SM#zRueX+uLT~t8Cbjdd+r@ zQ40>g@JK}W3}P)a*n68l8lUdzTB36(V0J)P=r|4E=Cx(Sh!7tU4xiauE|5KAVsocz z*v!&7?v?ZYiG|^y$|Y4? zi63l^R`YjkX^X!>J*C_5qpi?fiYnTXb!9?3><V@tSgkHn)1uP$f{5qxA z^ekmxx~9YShEn#WYdYRtTgtw4&7sHxrR+=7hbP?1I*+~Si`biHUwY>dE0!99em;b6 z4k=}C$PIP6&8+(H2z%4)d&<6a^$@Fs=kij+to#kbR6jz=A$&Wq{M!;QR<<5{M=sZk z<(k@CRM$7HO|((h#kM`X#q(>}tIgqgvE`3EbA8h);3$jh7jXTOGuO*j(mwW=zALoUiNd^4{-gfT>s9Q z>zf{+eYyU1u8%!)z3iv7FK`qwu(=sl+;A-2NW1EiC z@Bu9S)xK~IK7ggsUyi5|AHXG{a1Akzr3=uPeuOVw7QS@ft9qmK`O_`O`U*tNv zq;<$5C!bmAV!NqkE~a6-k@Ht7d7t||Kjb~m8%NPT?S1er&$V&qif`f4HpI2Q2V8Oe zyL&it{?kYKej77XG@JK1e}FwvInN%-`k5#E>k5#E>k8N3hw`H1&2BWC4-F!q7oX1K!eX@&Mr zYsG>rYvnWK8Nf$s^~2_xH$(WO$iW%gzuvR>mYmghrS}Dg=D{HkJ^;~PM9OJpni`>t(9#Qvmtw+`U z*4E=3*@|(jxMh?iEvF=98U6LB(?1@CCq$iSDr#1BQ8|3f%#RwGiyZn)e_zV6*1nlz zt^X*;dL*-z_2`#cS&x4=$69ei8*Al{+VK6h*4mfaTI=6zYd!K&TkFvUZ5T@%t0dLM zY}JaoW7s;wnU6T-txg!_-A@1qxyI0bC!8T)J7Em}<_Tx`)hCS0ZaU!%z5RqSV#x_- z#Dgb{Z#{Ox_{MKf7$cuQ;f#FwgmdZJynE_|amhD7b}qU4W8>1BK6buw`^RoigT1Xe z_+8?IF23k(TI+6)#kzTKHhLkl{+HNO5&8b@e#qxN@I@yc>&;(cPkjDk=dzbSHio_Z zv2*FEk7ci`$@f#_dZqJ9U6P5Tv0?s@IJG4_`ykIg_A&kXSn{Te52&;)exkgq@&vIb zhK|6#^t8J)`}&{h#-*)zr#tWTqrYGKSbRMt?#%w)70MUg``*uKBRlPj{@>(Y(OXNK zE&V<1fBOEO=rWqy27L$LEZM8G5B)~@ecFfL#aHWP{6aq<|0;Wh@8WC!?rXYt{Vc{i zhCRGV__Du(Jr=!w(v`Y_9n(9qUAK?!(7hQP@7Tc}aq0>yw(|g)uCnqcTxCR4W8A&gAKCy<#Em6Q zqkp`;(;pwWpOl1vx%R#*to7@;qz`LtDHz zH{kn)-fLty`Fb1iMF&S(dpqQqY%TtuPJX<#@LPGl@_BO9C7&m;_8Y|Sh`fO6p5y|Rd)V-*i=io!3zTCLn-ly$_Wn?-aQ{$b z#-X%>&z#5vy`b4kkqMAPLdh%Okwy5u48bPb#psRCc;0@FDRPp^QO8$Yj`6luY=0MD zhAGR1e_r7frmk=+@SzInS31#+y}g zftaovz>yKHc&|I-=ywX6lJW~NF8SIi*?(90|9Q{;$0fS=y$?0x(k0B*gD1gBg}3(P zwb-9Ff^&Zc_Zr!Yc%J!u`J^95G6lSSNBMGlhqhy%I4X39J^UU%4VacqKBkl@u_WF* zGZl@oZw7}CgL_lOcY6@Fj!W>b799RiY;Brd&v>V&|4+My|HssI?{)qk1f;-qc=f_x|~o(Eq|2U)zmkFOFhBKYd#Dfmh}Y7@T7 z9+5ryn5s#Ez5#xfO-Rf+4!$1$m-uQZd?k0{XX0zwRp8wJ622})hEIa86UxuQ*Doo2 zE!^K(;cJl`b?AZ|uK=yH28WNeC^Q!UmL;KM)0)}d~G}rz7k*7w&xdsuZ`eqBly|~zBYaazBYodJo{K< z3w&+-9Qew6-5E!}#uoV6_$m0xTs?UDU*IeA`SR)iSMb$sfqRC+*SpTaSK+f~{WMXkGdcG)nC)VL-wezW?%Xy_N;Gb&-yXV82VfGtKWwIoMNB)o4W8~XV}%caq&&M zbMfuiy5WmG;71R^2fNJ2*DC-|aNvu7Mn*K)hxrHB=fW!;&HXtvcp83S3E~MSE`|r( zNX~-ib?{7gE_oZd^Ax`P^Zl41;aTuli5s%tfG-{<7IMTA9X#XN$I|lXk9p^}%D=3M zzbTx%m-mRBw8^n%-yr<774LPYzx~L~Dg2aNQp3Kccy-fz-WxxKhkmFzmo8y09u!&i z)A%Cu^)h+Z<{_8edS1SWEPN)ea^f|N^ZUdgkuTwT?yqN zb!`2TKcXZFzucLP?23FWN8zJ#j9-aeC;O9pRb*r7lP?=5a)%n;*N5t9oNGfL+8gWx z8-3udJxUDWt)909*>)(rH7yhWTzG4R;;rXPbH;vJEPg}?sf-{Y_KUBXin zbLJBdH6J_K0c7C@Fc|NcLQryav3Ul^WhVRXXxW?e4O&{A z>-0-qX%y*KIYsfSoMLQD*b$9B*q8dSmc=@@D}H%8-{KeLe~e!tzao7Ib|}e_==F1H=tHe&iWueiP%EF~ z+6eVJMrg)5{Lt5J$7fzIXO2QfVZ5CA;+QOF?l`8(E&O)4KitaG*%ONoXMW}WaOPU> z4`*IOrL(hg&5X{s@l2+~$&y#=2+u{-zGMdbF~$6sy_^j8WQzEIe0G+ZG5-m^87b|& zy}``b=keVL9qJr0*LlzZ;@I}f z9#D?aThDQN6T@7Xr0zpJ+sW6n4J(!9SjjA-Bu#CtxsK$9 zrVaY5_FI(ivb5PT1Z_-G159s~zTe7_+|=UR?B8dP)!zqF`^IImZ@lThT=F!k_>&?% zhqcIIZE{$vT-KJ{`21uqr%?T(tWT6@qC6AjnHbN+cm{t~Jtli~YCjGdUCKT*>%hA4 zzx?XmZmYVB)Y=5=UMiiLmFosO+*W!3SjcWTB0iO7X2XTD2W@86PDIbZ|EsOQe{0?c zACln11n@T{^cdQ_|7v_(uI8Dmtr$8@;e@O3SwqL#iN3Y}D*Rinp1~kHWtz$rzR0n{mof#wo`XwRz>3Y{feqvv z3P1nqlCyB^I)!8X6pnQcKr-3yyVubBp!Xv5&TN|KZO1LIh!Xk=3Mc0C0EW9=!3a6?Y1|#b9Q-F z$tZFqRI|PtSl<-uyE7{5#u{G4_<@K0to8dbmz=n)cW-lkmWJ)NcQd}hpMi%c^B(1X z6nKa-XI-756m`w?eBg#yP<|zPeq!z;+Rd+hi`b2LS3loWExzp$&CMb2rmAUQQDDx` z!A~ob=U!M#d*oPAzvg%;+6>cXvrib`&fpp}fL|WJe11`WF+Gnp#nvzMAdW9%b&xq{ zzetWLd>!Se2N*lYc!0H#`}kF=`}kQ_2XB7wq2Dz5vp5C#H?9n^_q&F@1di+Zt-vSX zFAwc*dIo=&VAFq8NCUwVFc^Ixw0&MN}NuwkX0h_ z&T(QOM;YLg_-Bi+wjpu$?1`(IQ0AV8+1tE!Lf`aLV5P6>_TnfgEIiCC}JD$VqlWGqx<$oGlNKlZ+YIrSN~^K z7u?v9#do@}U&{NNi}>DG{MgBSfwg>RJ8>2XmFLSl6u{T7I$#yOk1x`G z;smQN7R_9uouJRE0^y*D_VOG$c8$4-dW(M6*j+V%|QBN$yUiin#K>fn(f4JG?4SDaO z<5u1v`ZSFF+d;aMmkJudm=lc$jXrwN>60>yqND*$G>pEw;q;}i#YxHE84`c47V!G0 z@+I=&bsP6jS|x4qkxDYwrQm8W;1hU_#_=%*Uh^j4dwdHxodlnW&o8Vd_ILyKt&pa2 zm;l4%Gu8yhti08lMII00sydMyirjPTXQDA!bt9r&jB*|?Pr zjrL67=Sv;5#E*-Zo7bcb{9FDaeqZgRCZV$i_-|34&^$I6AJ?)^^)jj{!Q8EZOVW6uX2DU=7ie0_|m%g(wd8+tbH}>xar{+?f+fY&isN!&^f z{!SkeKgS%(+&{_OuhxJI1Gq4N3-;rIgFe7PQ8EBr1b~YGaG?VixS%22J=sP;__)$7e@G&!#2Q1Jp1yh?= zNG{dHKena&^%VW`a~!I?gxi4|e4k~{kGg2NiF*#_xZymlK5NfO>d|tIch$84TD>OM z2A{b$3)qR2Y4vjtp7?j**4b80&ciXjpGBvLikb4>IHJX=ITpU-pm-sn;Q40T}tWD1kT=>(?@4b42wWlvynHdU_hre9s zKliVFKarC~e)6F1)`2Tso(&r@U1#sLjYCc<6x=;u5oAYcrzJhwdYKoheSb}tnfF<&v$c$0i zi0x+%;E}|*xXU`~=AL8Bb&@(N+>35N=1aj-Xs1XIh))jmQ^n+SP05&vj7UIY5>$S5 z0~iYMpY?M?vd&5JHEm){$btE38iKqjJXiECX!P0dhIHT*U-}4e8h~eNT84u>YQ$2X ze4g*{4W3W(d>+0<>UrW-bj9Oaw(q9<1@8{feul&|2%Vz+z}fw#@8Kl$BuT$`M#j~n zlzK?NBd_LNjcz1E>Xf2e5bOG@%kVoptef+RrQlwDp!I3|r^yjq#(TU^K1*Oblm9{Q zAiC{A{JV^8dSWp?NDBkpr~lG^*xxgpMU3vE)!&Zt?+`#Pu?+Ik~43?LQP=H~}qj_;qMP1~o?lGFRw6BD-*YzfBFNsf^`9ax{-;PPmo}ADj=5 z$e66T9yUT}y5_c%H5|=zHvamPWZ$ikc63*sCAUnXBGOxO5u4#E?m3Ol;}O<(1mBsb zB~BmA!Dqiv;@c%I$GnSgx5mdss|ee_xskeSFB;xguF}0{-ZbpRZy4T_Zy45!Z;`9| zPTjqmoE(dIX2ExLFY~{s-}Y6WyFvH9vQYQtV#^5P<2Uy^y7%Q_x}6#IuYCo-p@qX( zm%FHS(vx^L)+EZB{Lf2zI{aV8L65V*D zwI=m3?W~J+`^!bt_JgKn->%nJ{j$M+=9falKX8MGoIt!FTxHm)}H={2{XITz^d2Jd4dOYkxKDY`&Gnce454>X*8`_-C58_z~S3gdZ7x#om&i z5;O6j?mfx=cVA@cykVM`&An%!(~Af2TcX#8|EIzG^8ctYdG8EjjJdD7xox!iz~0yG z*3^fJQcJIYYx;#h)?DHbfBymf`UrlBf9d~O0G)pb`qW>qpWpfwv-RCteYoeV?%m)+ z3H{_gZ%ek8Sb%_s`cX+l<=HI1$6>Ht7-t8DX319qcVqqj?(g%3L zUxEDyupa^TGk|^aF%rXCl0vrx_Vf3LxexzNg}G0Dn|Q>%wTIAN@QY^(cYZ@uhA5_ZGJ7WGJny$PUIlmPAw2{PI3;r$BtohJedAI zazm6psQ%S8<tZ(W2Cf0 z8u*M{gL?%WC&VQ13?`51@&ypA6&q|h-+!<;6%LZSD=ACGe=LH5+%`*C#=aX8^ zV3DuNx0AzOtJ#QNQC0Pf@FsXL->XJOXyT_E@V$@2Tj_t{et2)S(oxg-#h;ZvFaNc~ zE|mqG7-KCc*AwK8H44hre5B>}U#a?7mDCe>O~pAqN?$&;9?<8i1*E=N@$CO^YXNPN zd8!!A`egvu8NjvV%4)7*lei=-|IeQTf8B8GD3J_jT@^Ge(neyO&aIOna*xyzN?cz9 z%$H${geQlOQ_tc>&86n07v5JUJlZ?9Pt~{Z!dtb(J5_B;GqgPR0JOyMaNE*-gMfv7 z3#pOO4j$D}rNw~Sj#!jOksr=`KK3e}yjSclJ z?HAz7Cu)bte9D?A8r-py`o6gUx%c`yP3niJ@swpUo-e8KxbqG)CjQBIx<%AIC6}KW z&vF@$qLFGW(9`Czi;Oz2Hw>N?hfV@8eO z3*$s5Zx3C=F46QXHIF%OX!Jtwm3i3z?2Xuy1y-pEV^=K;h)u+v-%ysAx+CLEO&GD? zVFM3u`}Oj_D0uymQGiTWc@P^Wd@v8*SQ&w53cRL7=h0ox(=}n%3YqyJyKE zCUYpVh?NiSn@W81!-_!ywDVlDZvQR_0YM zdy`|KV?@O!Q?qHAduyrU(eBgm z$H;M?FMr5B#k@nD*MK930?mB+WJLG*@^NCC*?Up8gH31hB?x~ig+HnM3FJ!<{=~WB zPdSlbA`lL`=(MHit7b;V3(gMYf+NVl`$kery|eBGh=JO{KIUfhbLw1)?7ZskPK{QD zkPKXF?HmG;*JY1Q^ z_oUIpAN{<`6)PO}A&g5>hS<>(_dfz(0Iuc?6I)#;@;wsMy_7z_r>AR}eixhsuk?U1 zHjccC4R73pfYV#xb1i%bxu^1gW^P2MU(RnH^UnBWzsa6;44ZWwzgqU5z_B=^RypWN|$PO9>L7(r0wgM0A z(NX8qh4-g*0E2#Fhe)zNay|P#@t{{ZDK7P}v4zndZ5AS<7wyEKcatG)InX8}HWz#Y z$J95uFZDclrnxV9%ujxlHiAk&@V^^}*TR#PtzSFt^hx5Anx5199!A%LUQr*wi0RZV zBrn7Ynd2yQHf|iM2ou*iOmq6oMdqgu=wc@0X<8?_56wGEhDA4v7~~2=H;bT~MSulW zmr<=(<-N!U1B~=~eccVkSp#H-O8S?l{2a)we9l-`4l=B{QECUTCRX;zu))5s>ThrQ z+dIxa?^fb%$;rNUHF3I6hN(3irq*y6efJpOKFh{wf};+4nG+kXcurzIcIV0vy69S2 zBl@B>)f67YIW-27S{i@9&37YwH)56-_lwSvr9=w4((J&UL^__T~0B4#4Y>f0j?y z?C?R_sw)#dBs!krJ!%f+y=_{es!sTvs^L zUdV{Gg8EJDZJb%licXxfmh5*ZK3`^=!4I&xXKErdBVPjx8tV_-FFW0rqx6NiI4HU3orj0fr@fj+rOrnCSKu-tpmuK4wXK_45ZeDtKM7`doO;Jg2>aPrz#z zY}|}f!E4cZ;58q3jc&-YVk!0lc4o=EoF67D0%u?{-U22yvD4%*e>u!w4)d48{AEK6 zvYEqHGKcI1po_BZk-cT^-YM`Pk;RXps{(JGu}xP&e^%D9=eIqOn9qJy8n%d+B{m-z z1h$lqgb!aQ_}=;9D<<$+iSEgogy3=DHN(Qrnz_`%+zNe$=2iwH>U-GT67%T~dWguo*2>iav*`cG zW6?Nx0Nm@kE^{sQgT+pl$Pgd2a^`^N^UvT`TF(6KzmjQa>nt0D@NA(k4z?#*N5Mb8 zozNyT{1a$I*ynF+g@#wbueLF_%yFPvTNR*hV=mO(Syk}dx-!LU#}3B#WTs{hUIDG~ zX>gkNe?Q&7RA~(|dSv@1AE(vc12w#r{p3#B<1>bjf*x;FH4ar>?)yUUUY-5FHPq=2 zWr)5iyGldkbA1;5JvQ}$!Q??jum zL4!Fp3Tner??vf4L-?QLzwfN({p0shZ&c|j*xG^$o|mgOv{?ppw7z5Lq@Uk6bPqVv zl7DQc|6S?7ki22KHn1v^)UMdQauPksL9S!Oj&vHZMO)};d`JSK4x9o9M+p(Y$c{-%Ye`;bca|(3eE)I+)sTDg|?cs|2tZKz# zgOa+gQiIbDt%Lq_Mn?{1`}I;s{OkIu?Lt}Vd$G_`e730xIe_tP`>E)oE_>mJw6Hd# zjkZbon5?Bw_l1?O2(~Qx#C*bM&4vs4ewkJi(efmJkvW+CU+~zTd4T@ZA(Jl0C#oU* zdF(x`RnUxt^cu-=M19-(Kojw|w{0=b-}p_vZmP`-D9Peu@7N`{&RRnJ3_^%0T{4 zT!T%lS!W9WUipA1UR_b4Yy-e(A}iC+2_>~W@5|I`UgG@)7n2j}%d7)yaE|YqmwBOX zSN72p69<2)@0!#JWgb6YP0u-*-ArT#RZGU_KldQ_)A+L3WDiT)P4u`}Hyger zwgzNX>{Kd`ce#!J=fmSU@bAuqrZOKjVPGu0vCJh0xX^yDp;ogip@~&vf%&>X4gPuT z5mfQ4u?YV>|GaX6&^|dAol#^~|9h2#Wb86mE;^E54|U^0sm-HkLEd2YK+4fO@WWF5 ztNbs2uVN6_qPp@~2nElKv5m<3+8q|PhJmYQn+fzOfXtvHGw8ri+J3^k$=nESMc-Ah z@t(@%{WqCYqfeauwpZW!beP<91}2+z)ijLx>vRR*QZlTwo^_%oyUU(`Vl#Q}kR6ac zlsufcHzRmRLpN@TLjh>$J>!GUno8=pS8B#8Xs7IbH_XQt^|Zh@-)8@=#XIJ_2-nVT z$A3SBPfZ4V=j?k;eQPPJP(z(Pd;0i?3?tDcBkZiB&n^0TsDju4zIi^mz!iU*&YdF$ z{dEfGD}FBZ+f~1h)9*^^OsIbQ{WxD6YK~fbujQD|_q^b`v0CW#nOffNOyOsr0;h8; znY*>85|f|&oN%f!cRvg?!(~=5ct$pruWYRFS!)G)GBT948W>$W z7eC>s$gt;~H=qB8;bQ`WKL{*Wuv4M(-21p+{)f+yrOwhtkr_Uhzm4qkI~KB(H5|Xt zD%~jDrW@nJ0f8CwK~r-t!at%L$M9Fx8hWSq!2@2_$sebA3(()@vEMoGBYd_Rm~VyC zx^sCf;LRJyK2J?h;Rzus#V*mB`-rBAcA86*E-QL6}ljkNF2`#~4{ zwemTSwl%C6N3ofRKM-*$R_uNDnE5YxMsxIF;&9zpEwN`7rJx_TptDYZCyipCvYH&5 zz42j+v~gQ$%CFMEmTDA~-nyFja-(%mKB)GV!1TctgvS^7+UmA;Jr zj56H0TN@KuvCPC`&rD=JYnlyjG$z6g?Yz+MbZ3#sP6M>WrtEgkpYU_L@&2~PwgUWE zq0K5@HssgJyM80JiGsR2CRU&8$8M(J-@kL*Q%a{4BHddXfB?Hlg0 zVKPQ!^*HV? zSNfN`j5Q5D`5F4xy{8$AuYchS)TDoT!PTGRy<`xZPSA+yzWx=8EBy<8@#1C%=zah=MZ0hHHU$m;J=cqH+?uVg2BU^57U6Z}f?CpI&m+u+MMWx#eOGU&x=o8)u; znuW9AMffE2Vg1GTBdSO6m5F1 zngo}0-KVt`jm+n>KK-ovv*?Jv?y`y4l2oXL%^tazxvfg?1xVaTNp;%41bbR^1Gywq z)EM50&)0r@wzx+f!L;1PUO+s&{3l8;{803pG|s$mHVl7aALVn!ScnX&4@+zJ)vXRG{Vk1O$ zlJm5zrJEt-J9wq_=o)15%zVY8qSfeHy^u3?Su^ZLOGsN$lwbY&R6nVNr;IOXzK)jFFKoi=?J?vDg!*=MW_!qT@*3INwOSSr7 z_DSFmUsT4Mfn3D9-hU59*6Mjm+DqiXmoCkwjjr?y+X8!Lz~sk?#aRL3HWXd<{<~bB zKVd4{7kslxh7&ng^?TFTjXo)P@3_pbbB=5;eRI?D{rTisZ^2;UbEgvrU;3PKg2>nx z>&WbT#xR`)?3co;mIE3mBO1{Zqe!?U*KEL~g1;>)u;OP>NJ zLX|Jn%oN#r%`q!F3|zr(UHBxp!vEqR{#Jv)*I?MmgYJAr+y%0qin&m*cV4}-tXc0o z|1%=1V9Pk8lO4luf!|k>db~@C#p;Dm@4!rp*h}_2GOfG`Qsa+(nk4%)OWCKXju4}P zeY`s8>|niL=%5+T!N;B(OiW3+@`ZP{Od=L$CVNK6zkgV!Ie%EA8Gn3AGyYVoIos=q znK_^tFEkLV6Vi?6JLt~y1-i3oubZ6^K$qPf=MyBM1A>Tgrz@pXE zonsyHtHaKYO5J#F8F4^shzEK~;(Jux6BVyR-2wNZEOIvDhd1d~6*K0&bq9I-uh6`I zd_>$(E%7>ay7Sxt-KcF)zS|P(BlS}x&cc0=_=ulW==MM7kzbKoC^z3kt+ZbgBLpAX z(t(=e1p(*z!2#uSP0mKi6Qy!zP-g^QPOa?w$@4ZB|IIH^A8n6jY%8aB`50=HPYO6Y zW(FkJn$-E0ypJk3Vtc+PwY*<@U9)c*OfH_Inq5!Mo7zh1oG%L)Th|1f=bj3vT#lVG zBp;6&ulM>kVvpDtWIx=ftqU024)C3ZfaI=IbN0pp)}xjfD&)eBVZZ*t6zmFzw()!i z!`K$04tW7J#Rp3ra^j)TRp=MB8IVQ3%KVJsUb*2sKglp^XR4eZ-kU#VZ+l=w=1BTa zd@4F=bq zM}EU^JN=jn?yRRDTln5ad~v_VuRFOw$5J=oYR%k&FI)X&&D=eiHW@qr-LWI+`*s!g zXYRe67`-RJ1#oU8dila!-rJ*l!^h*Jg+Fe_tGb=BPjmN7BnEILKJu@SUwoYI=CCG3 zDZ{(#54v|3>oW9K{J6<8dD+oMZ`xknymkuTpuaaB(#>&CGluahSE#wqCVwKi*bf`J zXK+9Cux4-H%-C+_{{hY1o1j0d{QhJdXKg(cE1o<2cH9Mk|=K!^3sARhC9RQ+~i^ zXf3eGcU)lSE!JkvMEu%sz@Og)PIu{ccuRV1CbBmEH|+X}ntS<7# zWY#hOPW1sdZ$jOeb#q5IX0&AtK)wSdyv4+J;0{K@!WNq^=S0h zWb++v4G@FmM>UKc4k){Jfm3hn+E7`O@1XYJe+r{6%k} z7f)r)!IMMv{#qC}tF=(;ZOri3;+=EWVpmu4!~uVAT}k_+Y2PE}mGz#p7612kntgYp zX1DIi+H^&?$d-N+$CV7*i@&FNS~tzEV%-=05?C0c+atl>k+T(@GxvR;wz&RJa?p*0 zcFcz_oU=yWjeCe|Tmvjj^6A{z^jIhFV2=>m0Bn1e<+_;-%x!xMTE|=}+Bk_hSp&@M z(Ci)HRO{BdxdWW3kANG@@p5qPaD+M==`}yl050{1=f4XssdZ)E>!8m%u(lCct_0RP zV26di*D;6pfkOv?n{D9xoL!nbTFP2g&%~V$9sX}8@wKc=pJ6wWjvbNh)WJz_dLBcudUDT=qJ>8MgwXQ+yf)jMm&W z=L&bxFMet+Yy}V85R#Y$JBJvCz*Sn!E8o1zTzpwOi+svn&M$OtF>--(BehG;z_okL z4EpHO{%+{hX6{WS?;v=26ZDf99`6nl*b({&y}x5O^f5iA8|!uNcst$P0&hIZ{2ZPN z{ANOP=kuEl3_S<`9BA0#Sf&)DJf z256+ff;S&Nx{vky1?%^AE;3{?=!IW|hE##`lQsJ|IJB9yoX&cHPgc={kQe$5Ff~(G zG;<%{h9`Lk!@yBxn&-l^@rAOF-$x$d*_u0q^*S=Pnb(k`1Uw)vyaE|=zD7F@+)LBM z*Akj{oHg9S9?uNqO2%!DzMrwp=KE8jFCW17gB)+gM%M{CTnc>b<+)DG%VEvCbqDJ@ z4nB>a(v0J0@dKlODr86A1-*tpQ~7=aFuVhLe7uc{PqbS-PE644{E**(8@u5M>p4j?Ynhj$D}DM7 z|B+gy4*pMe)mG$(sx&N+A*a(YQVgA znE4Iw(YzTOkp&X)2KGN@oXs21cMNaIv&a#*Lkpn8Rj)R~iMjiJ>eaB-AxyfT^R*8+cgsDC^@4R7OtDdKsd3A z$+Y&s%@6qYU!c9qS$q0^i1pr;hQrs#@@$Rf9ox=0XnWf!zOnZ#I^@lH9r`m-$u0I9 z@U6;c`Begk(1d23yHSk=o)os{3C!FIkLtwyHPOco%;o0S+?P0?(3zwCV)~6Q04E-u;Yj zx4v6<$Wh=`{?#9E;7wqQ`bm9KL2rI0?akM{ik~27UPtaz{0k=kiMqZnJZT0r${~;a zb(;C7_ZscnkRuWf@{k8?Kfv!cMfdEJ_2f$ZyKa61dU49p&A&4~cNMVaP+!V~4jxtO z?&ZEp4X4MMf8YVyXSZHO4XT^r^WfM&x#sNFyjeXpb7&*DH3>L?4lP-o#)p@IA!5I( zX6aroI?G*m(0@H-JI}$lXXth=`b+K|)GULxzV#d3eIA;3%A*cdx-YMpigvl9(>Rj2 z9e8o54bFNlYfy7(&pQB5n?m2=9|t^gdmqxx7r^s750W3fo_wb8jGKS2yMKgV{P(TY zb58S%o7MrBvzXJ@b#reM4jcpyE&%U$f%mV&zku^O0oI=OJFa8xIX~8pG0tM`fJqme z78#iRc6TUiI^#Cr8yK%*o#&m#@3g7ij=^7Oz0tS9jOO*r_=X)=sPmd z=+d<8HU(J{d_=Ah{%q1`@1}b2(#K7A8}NUS@ooz%JT=GN$l5;hSn{EyjKE%30 zbKKqcf%~&${P@%M04_$R;T~GztkvB;3G(%>(!3jAA$BtpeX|#_h7T)PaM2sRgTTr* zXi6*K0$%3InD1Fnd&nS{cZUw1f(~A-m7acSnwit%S*Ha4R{1*x|91UU%^tdi|IpRl zV_5&ESa13z>x1lV3Z1-e8ZoK43jfS4)F4L|w}*P1^RBZ7x}QLPq<_GPJ9<1k;A!aj zZ0y6xvZBL)@9qxfbgHR)I}URWoQ)q0f2f0=LkG}hOn8TqK@Y5A{~;dqBGi|Fzp3?^ z2p!yf543L_<73Zp7thL?z74(DHIKEPr|6#@{-eTmMMGYfcXn|;mN{7K%K{U}(%%|n zNBY|dnsacw=C%5bqUG)g`ZwjM=56o9cbPBfV-qZTZyUhnI=(Z7?;xW`^?*I^4aGxE z#wEN`^h1%~%_e#{1wC{=uqm>&@WeyMq2o#5PI%#Mx;qj&hn(W=;NJXh(89gQ;r={| z9PaL34-8CI@ZnWKtB^(fxfsp3fYmC-wJQeP9Auq=UwBN@ymvkc%k1bnDFP1Ha9;3O&`PaGl7d`!2cNN@Oq!mqc3=q zJnRRuzT8*qE8{s140ix8R>IqXAHn5GtAMSMX_y9PT0H{nF45262xACipV)mNZ1)z77ZM$(Yb>y&X>j6VR8tsHL!P8gutJeAzAF9#>M-;z&a%kXgy{2vL7 ziX991^7#WWGyZAdb3F91Gc=$v4PTwihBy>?QW; zql^JsD00)Gqe@@(c{1Ojwm{96u6LV@w>2>~Y|-5&B-a^B@*IwdRxagcOX-BX3VpY|3zQg=gS51&4c^MCjf75l8pmnq1gw(J=O#phSZcX>)I(A zDY}(?JOdg^ACSvM|Ft7cum+5W8Z>+MQ(T{l&VtM{eGGHY{4t;QB<6l}6YZNKw&Re< zZ@wNAfv5Hc)_^l$**1VZ_@BVL=%My(=1_R#@$Tr)okeC3G|AcC;vCU?>DON7VLUj& zdK{JZrqCX6jt$4F_!9iD0-3N4u=XhQ3ti^*lfYGH=KZ)&d*M+EHo^>pkdzJ4n9IAoo$7lLM|btrRpA>TQy+A(*}^!euj z@M!+i$W_d=n{NG;1Rjgd}R{PGk22Q$(u85vL9n_K_7#< zJGquUAbi=I&`4WPCfw1CSH*HOz=#}d_%7x9nc2wQc(7y=<2?^rfBj3IJCt#?(2;M< zh|yYcF1QlASHb)1Y1a&0(XVgNrRW$h_WYV$1{kB_z}+9U@hS1yC5Fz(LdLN>iy7-K zbj-KqvX{4gFoQ9J`M&JATCVb?+&KP|2F^+Bo%SbWYbyH}bwX#EE9!);CNF3k^{nqP zfp@GVRzyDWJ4|92`w;!w?8~R%+|~);o1^f}p6mHTcE?{~`xohMY8{wJKU3dfE}0x= z^>qAzSc;wY3ABT5cVqKrWAlhxo#9X7-~WcWgn#l(VvL9XK&}%1HTYM}JwzP(+V{k& z_cE7t5B%MOdvhhc7ua5uY^fS)?u98(} z3%-kk@3Lz%G2z3yxskb|I~#}z*Xs76QOsxF!#knf_tnI{-m~q`s)bg_MLo}Z7MhRX zd0^m(TKLC3;F^7JGg#7$Z#f?O^fbODx;LefwX7C_0}?A`fqkPCuBez{(u=xz39<2^ z_26PXb`Q)TKV^H1Uwj#Mf?3cAN@)l1MTXOuj$Owp=0&PSac<_H-`4;_$ZF? z)zy3vew1DF67T;AtQT1v#`AdQbo`^ARU+pNVB|24r*rRgbuE!{#beIw58pyB*xO7` zk@#NXa`!xJ7CwW@B}FG=YexGvvjN}j8!)C=w+A7&gVr-owi}x~4h%#l#ddGK84R9> zjC|etF83O6fILvVAAX_aTFJxO>!)b0@tJ1IT*IE-$h|LTyLa>MH^G2mx;qH0S4sA*=oYiy-E(9&8xu$Y(W!!7Jqj}rjl{DVXJQ6vyFT<__Sv$c;P)?^4a7+ z1oL=yitb83$YUzoO-@hdot@z?U`z3t#_+B;E5N0Cct2Eg+ckN)rs>Q}pImO(!6#K5 z;l9MXg6O^2k`ITs>Wugw_S(2k+(~^R^6%$LRi3WZ)=$FExP>|12N=UGB5yJ;6tF{^ z6lS^S4doZUy~H@K8QN<1MSk44p(}qPZ5wktS^P~xhn^)iz$OuU+ha4>7kmZ08x8N_ zT{~=G2<+P0GNxu~&VHxabE>&^3-h(m5qn?`!uF2Y1^-(3&iR+3{N0TnUx5#W&gP=C z*WO9rtD#Rd^pSD=x9?xxtn|(ey$kQK^XqvJ^H9QT$*DO)2W*AhBXdK<1|fGwiS7=> zMy?$qF$CD=T?qZ8uuVPEH6qkJ~zHNbE1(T^AHfxH8s z&0NbkqTt~Wo*{b3eJc0R3EWG&0GUD#MQ&3M9u=oKL+a3N_&JJk$2Tfon_H%1|EH_C z-oEErY}G=pfyIMH@w*q_626byk4*YFGG;&XEMGH+11@0m6pzdm*bv6_=0Iq&mcDa5 zWB~7KWM4a>@qc4W@VkP4f-jSpZ+uhbJx$4h?;(beIY&Py?Z!=Tn^IwX{oxo9y!xG3H*F@i z?4&zajU^`A!F-w6^27W;64`zMn{WtQb_n^&CFVS&?2nrfCs#R6{0*>Wt;~Ds?!9~Q z$+1i8!L6n#;O&Rd$H$u8;4kxpacU(bw`gbVA-)=`*_SpEV_~mHqNkDrV2(-lo%e8A zutaeEM_}qU#)FMWTY+4xXY61LYdE=sCUL$QygP_J^5jD7QM`ottQqiNAY&hh&ZnVA zZQ>o3!)oI*(4JiL2KbjizDDrAXVv_>Jp&o6*~&aV?_ds6Y=~XCnR7e9j}5e4Nngj% zhi^C@2EMEYUk)f8w?iAL1JMIkK6M}kE2(83PW=QmBPCn4cz&`Sa@a0T4VKZDwX6Cj z)9?|}@RQSwlk~LsNy$`$daO9#&KoD|sqvGOA?m`?)i+$a{vP#Q1y;XU0rgr1ooR+v7g3{~5y}4QO4{dHr5x9s z%eQWovX4SWWOT15X#Y9S&xou}-Ny4Di~ITAGMf8k&HdXgz6p<1U&%KFlUToFSz09P?|d&b;6yBQqCUb7reisaJ&H9Vi=3m8}ZM4nHZ zKc3FLuk!qqNLH^idDp8vpBmb2mzcrYE#Qcow}E%c&}kvhl)oUfJhJ&gJ~=DnBoh`&@%og}p{_01aZ&oy4fwhbAt znZZt)nfEmKTgM)?Lv{1Y1=Kn6tiokIoOe#roVo2;Pxe#%^Y^KxJDXaV+K z$6nS?O5I$Z{c&I2{rDH`$A^zOey1LPHAwv>xcFL;ZoD=C-(oMAt>+tsv3z&ay_&u5 zN|}SokC*cQw^!=!VREmVuv>#K*4=L()7+OI;~tAO5l`3cOLt;tZeeUU<=XdtK`q?} zdB&y+J-%ruwU(mM_)Ec*_^UqhFmhZ+cUml0qv@3S1av$8yoBRo+R1*sCK2&u90^2v}@*j z7iqVjbvuq}*RM-=`ee{2!`N8F_c6)t#>N2#7;^OUN~GOT+Ep0wjiXpo{f*x7jgx5i zM(?BE8}8DZ{u#!mYTDKs#w&H~83zrhdv&kN(~V7y)NWFjxuKc&QJ0yA-Iu!5Pd?Y( zQ5|*cL@u?V_%m~Kr`PXv`^G;L)7_4|#=5)Bf2E!g8ul;GQ@Q8nam;tJ4(Rwg+T4W< ze~{-kzX0CTrl`D!_`>o2dJng`5x-#xb(w#n9s4{NT+Op+SE$pLSW+mGh+LvpesoDhAXv#K+7Ln`yLgjkV=}hyALVP@I^Qdb2$p1qv z{IWgX_0naTl0USY&!d)!eBg(V;pcVdI(0kEwW6b$W+Ur^l81H{Fy|!a!rUW!Vp0oe zH*Y{*ALpJPyz`)Uy-@D?G5_P2Nc#f*Uoe~Z*CX=_$({V3_ES0EB~SJtK;JVB_8anQ z`H;({ONnFgZH7*UZpmJD^V5uXSy!Vd=C_$dtus0LCTTT$ddZPcsM3|*kwr_pix|&9WO4=vIl*`+SYnjyo7x`iH+hV zvCMcud8W4yy`C9oNX%34?O)O~`X;*y<{EutragGDZj_dr_JyzL_NzBAzw@?kZ@gD< zuBW|`?>7pQz3q*^qK-P*&Ax;h>@dH?MOJuO4)W632=X0UISti2FF zCE3Hy*w0-4IL*l=AKLts=tHhK^acJO>HXhN{$GNwi%#-BY14064_Swp_hvgI!0`iSU2PS2@N>dN1c^XUVgBN-S#?ew7nHNzZlOlyk_AoGbk*$12c!GJh%U zvfY=aaPIORPKrVQuI}Lsu{od2mK+QB<4eYJ%prXHQk=|j*N@@7JhM2KXIOfkJ#a7l zFVE-y9`4$`)HB^FaaO*&cCBvo*L&I-PmwRW6PtW0u@|v(#_P~8nP+Fbs5$r!Hg(HZ ziTpo`IO{cXbL0Z<{fzaOQ>ho7s=HOgm|N^l+=$%|^^kAAdb$@dZ(kJaZm)d|+91pA ziEq+g;97ZSyBazN@f}W%b#ptqx-*QL&~DT-joV6I_$-d!C0>-{9FD=q>*V-H9B(7P zFUPmBZ!dNtD#s^r{!?Ocj#JY3e=66&{L#YC5-^^;@0=7b*4wa0cQ4@kih&b|jdzjH zd{W}6d{s+5e3V9=vx;TOC9qEVQ2d}f$q6k$PKgQkY$U!tSu>Y@j(ys}G4s<8oXxiy zZ*xozRK6+r_-)-N#Lk}_%XTlBOTP7e-M)3MX1{WY?xf&jjeJ64R&*(r=ZqxBvtb)D zeHOBRb$5H#d@1a()5=zYOx#WUYi>ISpJuzN zjdDhG*G=toP?cW*rteftQT_Cb!h^&IYL zLdQPHbnjtp;FHkh+2k^Y-k>?zPcYXY82T5@$-xKx=vj^*qOZ5%?@@Cw=Ns~C`>7ZE zi)L@!50>_)kK_Z!BfpK?`L5?2_KKF{aeQ|}KX#IuCDESTham`7mgd^DQ#Djboc*Y7wsIcuQw!`laTo<5M~Q z8*`b`W&&#xIn=<(F<_k2q?w)ITU74(Eo;8thpcXc5BcQG{?7Qj^pM=5(LdQqy+3q- ze3Hxi2ZPTKlJ|k8)DT(t$mWQrsarOfKl(i~0NxG()7Il7gg?l1ww+45Y}z45v)l8{ zcanVx%X_=ix02f+e|Gm6#!LPoy#`udkB{*<{@QBlV6jWttcAX-f&M;-UwkWhBk~JY zthbt%9YlTEl<&aUmE?8v>Hpu=zDDM@zpRU>B~;&gF7DVrx%mh3=0z2o27H2Jd>g)$LuW3C5oiIot7H_&4}bUwolEJIHa( zp9eqpA#dQo0}tsUZ|2+NwI29TlQ_kB`y~7fFyZ5~cwZy=m2CKm{0~AVHk<+tPlvv- zPBQ<%{4ab)-%8QRq3C4&YItyYFK5dm&<{-6`d`T9L9q!r&hVc=Uyciq(R6H1J8XVI zc`lgN-Ax$^-X(LTZor-+IYFKCu^c;qFUsDIHs2B39pA#QxQ<-hW5~1k82G}Ah>dpR zlQcene{~D`rhJ^<vem-=*uW-7fSIzK4I*&w10uLN%`x*r_&4Uzv+;Z0$M+B)=yukh{2e+b z=lc;eiI4mgF=R)u@D9z%e3)G0I^DVAWagPZ*PQl2^!;IIb%1#P}PW1EI@o_#folfC3THZD)*9PH`!|L2}!Vffeqq`=@ z{lUjQ&?ST1B>!*wjb<)+5?svX_<8W>SKv<`#}6aBcknG>9=;j+NAA~MH&}P~L9=z| z>*m`hY375UVn<4K^PP7!^P#i&zU(61eD?-?LumBrjk^0<56%4^d-qR%U;Bg7Aw};> zuwebo$i^P*j^5i2%-7uW2J2?KAat!&^)XiXgI?y4m5K+{DpK2mtoL7*Z4NsVU!+fW zyMg>+elpXpJP7Zu!B)hO+hmT^)bQI==x?`wR{YTJhWI9m_T|u6XfOV$-pS_MdONg^ zeC8sss-8UV7HY71Lg#<@bVjeS>7Gr7KHUzfdJ<>&InaE&PxITLGh?K7&iNVoYofm& z4$+*93~&vblM4^T9&g9SEZw7ULB3gY2f;tSzp^*1)u|WY8IQuN53&8keC80TP371@ zjwf)>9jo#)v*p&5yIEO6{U)|lV=R7f>v*jGvb7*)Beqd(S=8a6qR9vEhrw_GhR$?V1hP@H3d_ z?G5ez>C^6P>c`Mu!CvM#ovzqI`3CD}1E3>1Aaoou2^uc&eH!#QSM+!z{znn9d^5h+ z4($2Kx|8?0!dZ7t13q20!fCf*1moL`E!@NN@pCS~u9Pn8!8bSPa|1dxfOg1HIEh@H zExL<7ZxEk8le%f}?)P9E?Y8`pkOfpP1(tTDtmU25I`h7Ct&xAfDT zCHR9Emhq%A2fQ9zAU0tNe#${;nhEXpL9efgB~OQTZ_&TK9A_avV9K~d97EGw zXu3y^Cz4kqULJp#<3i}j+*rE+JUOhHS3&R01@w8RZeCG@pM<_3Q}|{Xd|#vHPgMOf zv6(w?JGysRvoFDao*tr>U93l77i|vn zdnvw?*ahsXyB_@v2EZj~Z0_^@%G04MG**6gcVrL0YR@L}lxLFHdz<;gebDX}Y|aCo zK3*|NbGk3!JLv~B=gPji+2do)y^ggiehz(mK;KU;Z zsxWa2&*8V1ThqXvIHSd9WG`^=vO^7X@PA-ViQ1xJ#1!3Xk#}e{tWM=#?Q7rScmWtV z2^!#66_>-SZtyvW`u;{_Kbz})!LE5{)ZH~{RZeNbCgLe1=Uu*{Rz}m^sXac`$ zCvy$F%>{2i+s^S>9KTCWLXNXJK0v-gj=_!GE!0)YF?dU^&E3WENboifyxl`wa~03Z zTM7612EE*yK5t>3Zz=X?EVSOkeE1WZd+9nId(w-! zapInrIR_?6ehwVN7wt+Pz>4jhOJ<_?8R|Qp87b6zO(0Gzhqii-M_cd_+R7Yfoc*++ zZRChgDsqxeYv@2R3||LcK>1>@~h>6d!rSkD=W==(8N( ziX1@IL-DLBLN2yAfPC&ZqeIDZPc?=Lj_+5pG!aeggwC&zVs?~X2g+>T@T z_~0aRIV_HY-L$D+axco_JBvx+3jFxR$*ieF9`uIWb@P|x)_Y@fKATJa=r_94865rm zkGfli4F9$_-=lpDUDiO;Vc2kyU1HU>_aG0aOKls^n@ybgw4%8)694YyH^KKG(-wcK z|K(ksH_wHpU-foh;{VdiySnF% zN{6QC=*%;O)*V}71T}xDAv<#yVbAd+v%kkz0=tLdM|OLU`hfM|IC{JITkOpSj?aYl z$mEAF(dKr|G|Bfy*K*ts+J6S^Io^UkFF~JoZR8uLzSwfc4{iufxa+}X(c8)`)Jx(| zImBky457B;d2*NdQxc1Aewf_v9XyL1203lPcy}XqNMh~!r+6kY$x>nxo@wqNCYgUK zKJrdtg+W}#>F#a(zH%#k!k#ot#+IL!=e!FJte?U;{8GtLZJ zbTOT6-~w@kMSjX|xP};J6*dFEt3>Y}mmC=~9529*r7?z-ZO}K_i)+a2Hth9i=A^+v zneT59TORAE>Lf$;V9GG?7+byQYtIjr?_w6e32hHD|D1#T9`xh!A3?)yK5kA$cNgQ^ z+{t)vX1v5hGTy67urnX|u{iP2gCDB#O5KZ{iXICVH;iR`O~}R)==uof#2?hVnL`-Q zC8Ochk33tBPiSuWFOjVry8&AsPIfhijRDVA!n^g@y97S+aN-2|IUM;gr=Vx#nTquu z?#u-5c%C@%8+=gO4KD)2n&E@k(ngL4pi6Q*iZQ{vPxjItA7RRVYz@C_r-;9kW0aI< zOPvRF1S3jccftO$+{eia#+Ef1r@q4_xj3oyzl=SN@oJop*>Y(eYn`dAY zMW$DC?Aw|>FK`U@W`n(>9}Bb2pP)QCFgVF#ZLw+=HfeF+N9Zsi7N(ufe(ls&-+-d9pYT|HufJou6&y7(9_41Kj^N5-V-0t z+;90^cRG1O;+-pVb+gwYe4C$OH_m~++p+6&pf7aq4c%{inD6VLd(U^kd}QL&C-@&M z$XS9ctm3#oe$^iQ)u*7_7UZQFf8j9oTQi~Q?a+6FoQJkG#8Y6vPuCMWLCcHjGx-ke zN2bcl6@JjwC{A`z_lw-sEEHe8H|MgXX2vK5_gKrp?XVEKk?$yunQ~sfE3iAR(Culf z$%SO0TfL|w$99Zb4K1-93*YnOLSmS1|McU+v%MH*_ebc;jo4>=45?2W`B$*+m%g9* zJLLLyMQ`JjWUk$5yyk9-YVKX%>-O65nsZelzROPEcfrry-$orR*TQAR) z`b?Eq?U<0cfL@$4y>nxzxgr-)6zjnENYG;~w3|#lC%&Swg4|7S@-_cdb7@ZF+0f>F zKR3}6oxz90#ws5!NAw4Ls;HB9qu0n`Hu|n|p~ztla;S2l$f1gFUyyj5*nARL4xRXR z-d&4aj4VbDcjM!Tf43DHMSL2KLI3dECB7YuuHC}<+xUI?7O;SEmpqf@mQ7+V=LxXt zYUY3N=^C>6PWvusc1ZFWj5%q#GnjW0+@AriR^^~iOp6uAx~czXj3D2*if4V5YgaTN zb0S0K9jGk^Hy_3RodHI6Mkc=W#=YfKu=j6j+|IUc$rd}{Y-2q1(b*Oy9|Nt_z0eAs^>X+}bk;Z})>FR!buWz*uk0nydoS2l zg4}>VN^Z7kPLChq>!E8uABzlu;h+2hA8$Hqm`&B~+xdNUwr=#(Wlk(xzArMsTl{}~ zfY%sjQq8T(yco5I)Vys`awco6xDCW5N(YD0*RG5c`>*wxEN%;Sl>rBBwKpuz!zWvoFtdD@5n8LD+EYip0nG ze2v_Lepas*dFd)PMr?#j&deEl9r*m1;4{a6M&8g9C2tR)pSR%WJu7mJjEw?kqndr^ z%j9*(ksBml&;88T)Ax|KpZM~2BUlGL=(BtNM_}FWH1`&M!8(y?+dzjax1;A-#3uW_ zagQ8;o;T9}W!at|2OS>x2EXQGa=XysLFf?vDp&a8<#rD+ud|)+&CVsxOSZR-&Ddqp zxrJUHjGVc-85+<}cNRJrsL|plmv=!9yGq`H_>??wwr-rHb1v3J{V(4?rH;lQx)vHN z_w(U@Lg%i49>~Rr`MPONRKA&E5%-B-eaS7*V;wQ)o#1LIGWUrubMN4z{n+(hkVoce*=~-%a4o70{sjex;Ajl>?ABXuv$DvbyQ-xz)?HY2q*g`kBn!Lj^*{;;kvQCWCc!OpxMVwH>Ulw{fgBa>YWQp8>!guUi&M$pg!mj0l z*XX~|zr4HpR)6Cp)@+UZ$4qZ?M3_>_?QPD6^-CyCVW)>4SdXmkE&nI^vj`N{QCW3ZClSDY3)}m zUA~v|uxufIrtonRyc__%ne->(JK8N8b?DAE{aOgU%G0H0+pZBT3F9|{9i4W8 z3HTb>Py2j?4&AQu=bM*;k#~{X{zz!u%bhU-{?X?&JinqHvfhH-BKN~Q z?Dk~s0pttp9xdNj^k1Pl8;Is$C@Hvz4)FQTkeBq3w^ki-&!^bRNAJ0JUMIW1wm|+1v+azD^%bDZ) z2t0+43Rm}#hk;&8eVo{_86AKw!pFCu7jp0Q>jZLt&qg1=MDFn$i<4=`$$cl0`|n?c%fec;5uhT-8V)k?(&) z?mb*>%g6GxwtTb|AFGe!V_RG`mw=(l4(ZTq4?YTc=)?Po8^sPKA-0Nv0mbdy#w5$6d$q(d>pkirf!JAMuGj zyw|~d@DN-TpICe?<>!dp@7Vf zZTM(U7!TeHACddaW?$AD(MRN7@o^M<#LrRo@dxn!C_d_`$KicI@cvq`;Rk&AT=C`c zbEp|~?}dkokLx@>j`Z-Mho|=7anxQ} z_+R|uf5rPIdnliEM#eE%Q67?c75O$wd@y?kIvHF+-$v25TEA~~^lhl$H*8TZvafvB zBr*mM&P!;r4uM<$-_)QG-{%qEe|Qzxx(z%dzE^lQ7M~S=U3}JcYl+Dg(?5P&ebyJj z3cd|&^;z{cyj;lK7;$%;K9Qp_vmfCypyoIQ#-8$12+7;oH3!hg$>jC+5|@pkKPzQz7cXbG7>xL6D)V$;#F8m$ zZl9QznsD@bV+uBCEA*(Xe8sv*#k*|hq z)`u{l`yMc2vKH?b%W~)Zl2|?#khRC8hC|l&bZcht7vlIMZ1h;LVHNTMKTY^aZ03wu z?9C;b@D!iIU5l(t;P|B>^g9gA=vUL7K*4CzRo|-xK%TaZp=WQnMhwfB=h#u^xeFA-ir}I|QuLS)VP9AcRuGT%82S4{t zVV+N9y@&d@8{wnZytB1dL@w@43 z-@DerzalS(C~`0Iw4;$ZW$?n0ehE)ULEpVf{w1$^to+CG%d_1oa?zCy#4ok*sW;em zP}RTSkLhuX?~P^c3hK3GO&vS57hTBacpJI^emJYp1^Na*%^mb@DQ)*5kE1u^*N4@- zwUfKcm-Q{k^*-iQk^QD|#NngyeZFCC9r@q0l{yyQKji>9s`Zjz&r@@t$i488wLZ8P zd>;sH8kn~_rQG`tTKXkxJcQtN%`oiJhhX_N^y?AwZeYifpV6;*^b6eBdowlQP2@(y zKF$1o?byOQ3~DO;e({~ZJN_X5)30&cbbBiA-B-i=1I&LXGnIWFv>tjjkeB~0^FrnM z?mBo&-|RuVW&I1ojl)an8{d=Lsd4_0qv}VY2{x0uduL=FcrXCQB`xK z^bdd4v(w1XhD>aAgxadRxIV`7EhIm;6CZ9ZeVD+rH}Va+73=B7hj_fYWGJ%TO}7Vg z{{`qQeZzNQ|0-&oFC$2#DlgK`Hy}llr?WPutXKq|Y zpW>X`FW@cL^M28tOZXPVVor_xpo@*PFU@9t0ACFZ zb2p+V^?bv{I+1zO&eqeRJv0;3GD3KC-{B06WEXY7WDRll1l-H_<8QUgwZ9KW~tMJ*LrfvfMU62cQ zeFKIb;J(eQ?Ny5o!23aqsNpQ{7PoY+p?B-i|C(J2Tcke4u3kZ`G>V)seH&2+Er(*O z7O*xp{7J9iJ3{)Xa%RQK_i&uuYP}+JJNHVzorq`SSyxQfIJakyQEQl~^~H#h#Rrmp z$XtwFIYn|}dA8Anj<4W=voWYg z*`M5OtS6qR(EYX<<}h%H_GT#L-;>m=RC)fX^8A3=Si~HBGrH7zPbYQHmLvB$HEr*G zLwi)+U&gu@)7blXuoi!ueRCdvnSC(ZY4+;J*+;eq>yI^PW(|9=XQpb;a98m-SO_6JFJ`u2*~Z>!Thf&<_42xsUyz)c(}ksqVA~HM{N#{Ikc|WAXt_ z_LPd=ev&TxM6uuax8{L;ogDTKi?UV-G-OO=DMn?0^>!=1jsCqpp!N{#u!3*P=QB@U zsLOs}@RR-VVkz)51%9^fmkK{+9#n^ShVYI(%bD-3U|d11sVc}`UO{blRZ#8GMH{u> zsp4Cq&$j?{Rr^E!3%&*5n`-xez&CXdd<)9+{}1`rdM|ua_m@GZeCQnWX3o<1U90e_rZiinAuHFJ?KpQA&a1V_15Z8! z$Y)_S@`)@wHVvCtR380xbwKug=U7*A7HW~Rs&;l@Ch|2+$q=;Qo01rH2FL?@3qy|- zk%yMO*VO*u!FKRM_AS$piK@Bs4)$RC&a7$O&wYP4`^&>)G^4!Dxv#x*YtKD$u6nO` zE`CnD0vre-%VUvc_#B;9uX%Ea3?hfdqsU>JaY*El=L)}$;}h#@fG437jJ>{f?5f|M zetq|^#tqKNJB}awO!T>B{F)m79Zq#SMQ8RY{Pu_XWkFBY)S*WDYIHpWkAq-{@aPDJ z7%SRoE*N4)df@+W1vkKu`Kizz+N83s)R^Je!)7o9nNS$g3_rJkXM!OQsl6c7{?gv~ zKC@?*>h=KU>=b?g-U>e+V*kMZ5q=ycA3`VW0c!!3lRMB`Y4)%1BdVbbtr(K;>ta=; zMGr+Mefx0~k0WoL4&A2BH7cgDKjEq9G}x27AV=+8S5)mp$6~LL4$r`I-dyFE{pDgwn52nY90@%~#?Cl&3#47^q0r=%%t7M%Py*n6i z6i%-R#Vgm*p8ae?w7V~qmY|>3A6Cz?o@$uWa(~m^!SDS&0kuVCvNvVfB~I{sa6G9k z$`{!y%P}gF$Rm35S#5}Y!P#rEE+qF$e`IWe$s#M#ANCQX#xFo^$vSG=_|*a_Y9Gcn zI^QDmYV7@kbF6+rS?^}9g$%aEhL(2t7p#APj@F`|(}D+&*ohtA$TQ?#2kc#>bfxT9 zMg{mbDNAb#1$U1Ba_K>D99kOBV@;zjDMlFn@vL}l1#+L%BfC#U_NRA9@Xe_+ef^Ez z-oP8kOQGilm3*69!x$T|Z*Q>^9Byaz8_T&`ovr-Nd-G<*l;N(pM#W zUF&2&c7+cu=lwAl-WaOp|KJ#8e^MDkK4V}HKaW2$2EEM~);t`&5S!O#99HT5jJFTI z>uI{NvXZ@vQ`6!rYqV%pYUjw-(}^XfAGL3|nTiiEgE3v3(9E`VLIlPi$H{Y+y}liyszKHnj%7 zg8fjVxdHLdgXT17wHTk1y^_^&Mj%D-(<-P&KI%DNWwgHkU(lo}JMg_#P^az@KDEeb z-1l)>Y<&y=kgucSmS`w7!^Izoe)y*hXFC06Eb%boS&$7c7vRIo*gBWVv!m><$uU@v zkTHPOU~?w2#{RG^ZSCsa{LlK0!7s~He7Jf+ipjX5okQ$hv>-+HQ@3aAFN==dkQQCS z`;^V7O7ZtV?y#ur3$SX<&&0;M)w{qsbSD3q6tg-NoLfeFY(gl8j|hDg?rN_S_i52y zVyD196%QyKZjA*Pv-11pT}QvC?57^am+MELUvr^RSq+|^%J{Y%Wv|WDYH;@%ojyQw zbU94_z*(#G4dml=WVoiI&~pN}OO2H=moi>(+3)9JWwSdA4p&{?#{cc)`@i@2_U5pehHfBZ z9^H~HyvT3_%klHgRPbCqXU#7dM=PGU#X(Et8vkG77UykZlmqq9PGXiddUPRiWK@NAGKw;z(^Dv68dPkCm{MkE&;DsgA@+i$k=j zZ;g3qm(ddMs8~m}-=$f)>W|?NBbkeu`L5NAk!asZwcqN+NOF%eofxV0z608$+-pyp z292Q+@-A}MHs)#ZX`ydQiywgh06$~!75Ve+jl>$F`{MH)iL>gDjy2St;$`-KCe~Q9 z`j}YbJNgx%Ujghs7?Mm$G~y>!*Wc*rYNhFf^5H>wii3@?Sj!N(qTNkFi+qt)@&@Di zfN^~VrlDJDF~Jhnplgxa;C}SWFp)dohqyLgp&O!S(W>f@9HTE>2jfPsR=!sB?t1Y7 zg3vPv{X#;&=;%K|XY^}+E%95q(W+l_j?%BA?m0@g!g@gI7Hc|!a{;R$8L$fVKpWjM ze4Xf-D4PA}Nac#*iD92cBV%6Of)AW9Lp9x;nuZiJb?X)@zZp8F|7WaUq9cdCcJ!g`=zaL;XKYGTNV?vZgR*_gDylN$fn73dpS81Um({8z)m zCr&43#h+C%E3zi{NPMDX#%lPNvF!hQdR%tj|F6d<(&IG;{>OU!lQ;Hqx>oommDi2l9SWJ!ck%fG z8f%=K!I~nY=~Jb|-(FsH+5)hlT5DPyLQk+8;$x+b&Wx)VA5_ zKW9x9$&C%xo3gL_r$a zF8GYEC;d}=7CNXtu6f-JJP7^Zap8Q$=YN~W*zKcfs$FjIPGa(ZD~Bci82s&^a#`>f zUqf>qJcI9SuF%bD$sK$AmAT7S{zC6~U*Ye7^61q1Bm51*-|BWguc|JPHuxt-D^Iy@ z3QuWchFW;4RXV};>UoN%MIt-Aw>F@j-*ipIKaC>c=>YP#Ej(TGoI7(cv=-Zcrrxyh zidLTf5Z#W=YdK1vJi8&jgW&n1uH<6wPI**lVpNb1$`1Ou(Xt97JPoW5K#%kB-^f`R z*j#cCo?pIZl;;~i121BX4S!E^Q%TIt`|;2F7^;sdmt6L(Q9D!RC8C;_+lXp)At#tm zOjwtu`rZ&^y=lf@RXdM0#?w3>pdy!?4*myu@90#>3Uj z{nhiGe2^Sp1+m;SvL-No9r>^D2Y&8rS&B!Ode+D$#tP{vzW=rX|4a4V2q(E0f2x4{ z*)z8#PO=KuL7M>mN0*RYkw@~Kvs>a3@flVB@&k;Id}1N-0`e~H%wWX=XVL&@U8W^M zT0Y;{l{t0fSCJ`qf4!QUbZUkjj*f1mf8;W%D{5$K%pQ$50lYwGE#@c{Hm?AqS5%NYs@CEw z>osFlP$yr>d?sy(ajkwIAbVel>={DeR$c_aN#p>2=srK5mYhhOn6qVEe0$3?cuqf_ zlMj6h*75GQTI~(}Gg`*&`I5+v^u6mAS=V3r5eEI1cuxFI$)ifX(kRB}7T2(*LIbsF zA>9a9G9SS^3h8T@zLx0NZ*rvIjmn35Im24PMV_nTAY&!ZlCc+6@ce50+x6sYLdu5~ z-Hg{(&jvRX#=zSJ(gzhs?nfq4k%?4fB6Ve%IUox^~wCsUj2P zw_0QZ-IV{2$V9c~<)IR@B!BJGqfd(*2whId_trTF;eS;t|6A^Fp{I<`3^Fe9)mz65 zJ<;j5V}>qD*Oe@+Kvw8ybj~hvR-pj$7I3f+4(G^U>CxO!ipWlUC4cb5D6Uq|i&sw9 z3~CFke0V_K)9*`x%4;aRSd$em^4f~6h&OP&et{MNFVJ7VeXy`i`>ri=0KOng_iORx z^i9bgxm4tBcNO|wgdP>4MQ_4&D8ZN@_l?{(2C*Y-}wfd z^TbmUL#gi*nu(!DQDZO)Tag3Sqf;Ww;)_XNe(*i1PrP8J4u8da&#+A1bDQ^`3%hat z3-umiFp0a4dr!95BGm6Mp1plP;QDhXIS96vvvKpxqJgP4eJwMTP+8v3VOYaX@ zC4GWc__Ux^SRQoRr81XB-YwnpyM=bxNOa{HbOrqYpFLZ!CTSA?Df`r;E+8_8?A#xH zDVS@9D(*+ez_cuQPU!iOj?-pzNIXkUY{rI@Swj|F{{US73Y(zg zN1cj%=>b^}#tc!5FiGZEb!-J=!d9BtSF5Cp0d~=!WD2+&6q}i-KUFX}BzTYjJIOuQ zMH0|8bx?_u>OIp;<2h~ZNcatSB+ujhrM$l%7)ac124i4(Ol*?hs@6h@_ zk@M&r|o`EEl!b6O}MzH*|SmM?Q2&Vn8u4j0KX7> z6uMB^$>_MZ`S$DWGS!b+vknWbo93q$> zUS?MpmD`~(e$^|``*De-4tTVLFT_XQyS2e0J79VlcDl^7@ylENmbUU@u-9Ll{Vt)k zlA9*2-Iu=H{aDHHzsxxY&r&&OP07J0p6?zyTg?ZaD(BWLIC2ghQRkSSBR@~Q)K4Ub z>*v)S-rwpIA(P5ybtGSSR4!iS3c*E{kS`CPoB%bIPB?U48`?7yPoibsv4_Nc@b zJv?kd4(8ED`9BHxhD`m`3^Dej<~4NuHC>BLwxQjM10F`EUhD*K0;^-l9=!LkkXCXK)SPd2mo{JCa`_)9I;Ax(#@2bqk&f^YE>*zZ-y@O&l$gti$5H$Q1^)rcx~e& zdF~-kr-BzLor3Njf0sdP?7i~ob)RO{7n#KAiz7@gpkhpFWde}emo$(g_OZO0)e=+l7bi@XvG@ZkV?c zpWNsBCDHku58a2p!SjM7aw$5?Ur5V0v03si54+2zTZQ-MTj4%^h?nw-(esVI#BYV? z(;gZ57$0fo%np%P@W;|;g%Zy(hFP;NH`{|3VZFc!mRqLyV*S|zO7>POc&323lJha1 zwXDGE$KGrG`>^j?c@g6%vsF3oJuT*SCh4Pc9!`vIqljN%IM{|cd9 z5i~5e3ZP%%{b76)j`c!lX%SNtSpDB9p#Memr4PQLwOdP-oJybQ=;i1&@6D+T@ZJJw zoEp9MFKIIO6RoPHZbt8ePUJ@qu26Xn)raDGFep}}uuMHCR;0%8NiBXD_k~nVNr?e( zS2Wo{gy$WX9}(SWEh%+J-$>kzZ)xB^rg(pS55HsX1){3 zCU@L8KY9r`g^j^>%r_dUsSy)h^>f0=mg>9Ug|vU9UbCjvay?(2k8q!r7Mw3_L_tr=9`UVnLZF?@!BR?Z?QO73} z_kDbRB9}yRIc*qg^%cKp&gpi$89Mm2(!V(e&oFCVx`yL`8H)e6 z#3W|TW|zDOws8B8z-0d4{z5f;{^Pn;coR9ATXoj+;`ry-{XQI*lA}3|;~(?wbUE=G>m2suuRnkJ>G%u$74jG6 zuOz)?{OozK4Bd>Sd;G8YiycZbhai2`@Ka(Let%7AcYK>Q7t*Gy-=^D%+f-fPUpM4> z!lPYJk1kq=1ab$S8+N-ld|GSg`Rz|YM=i(a$GJ{GZ{PAAi%(@!9A!dHOl6#ngf4mYNRKkM`;K2p(-~xDX0X(?C z?C@nLr$a2w?D*wjiPg*w-ye>4_(LaiQiqT;^e5Cq1P_}-2WYZSuwDHJY6|hwzyp1kGf{_^#7FelwAO!B?N8);U_2Wi-bwD`%iF9kpL_mq4Aewuz(q7D5Qm5FYb zO=_hbG;nAmH1gWZ%ObhO7`%If}FBEMR?W+#` z@N?H#PJ8lSU*>&f24tS@Z>4_QV&Nrvah0c&S}w;!+V)xW((7AQ9@lO_{)TwtSi^pe zU){yNkp|~(@Xl3@@z3>ixaL$ZpeBK9UjO#_?>qtT%hIv$VmJOx-e2Fsd*tEYM$bmEaABUr}p6F!mZy$2l|Kf-ou-4Xz2q6a{ zdR&2GGvef)aUmw)(j@ceOd;M2ILj}z#k zV2QFH@Bi?#HA8*Z^W}~&{WiV~C|;iH$w3wKaq53N(MEoc$ikXK{&jqH#b?{+{~-UF zC*ZO6+5gi#HUmd^?6!l)>9K&>-q-cOzQfVyMvE*8}i40FOiP zI0TQW?RkUz@AG(^g}jl+ZL8}(eJ?tm z$5k)>@Uz$KJRy(U!P9mRj8{1YWrMXHJ|Cke=5yKK{r49~vc&(WP8Hnt?f1L>y|?*o zdbW{|_x$#G(q3vxeSF#GpI7$Hzb|^^zOuLd>nF*53Eqj_H$B@$-$M&+U%sFA+YM~f z?xZ&DZu9NYlYYBjv}rfcYuAEH+7o`83CFi-`_3x%KUOrD-KO1yqcON_MO&Wu{r`pc zK5|b1^3{J=w%+yMImTt2g6T59)n)^A6bRRI^uZX!LbX&E)&6(swGYey?B) zpTibDenDixOxFnx-)h#ZU+IKCYBZ-$1-m}MKE8u}db z?_B89;Ax?g;F>SHh8=40b;@4g{JDNRSK1xlM*Aym2KsFhCvLOm&;IpC<$B_TSf%~R zZ}XQnZ5|b#`0t!;t9~ilJj-vZFxlsyFE1^AW7#5~cbB@n)8k#swWeW4+Cxa3-ec!-a^|Q zGL{q5wrW)y+BQkM<7r#Aq77|#pSX>-+^5B6xqf2WmM!tyeA=eX<~FqT{99rseDR6A zv&Cmuez1oLYZm&?FytAu5uefbIm#BB;zM~j;OkL~uT<4?pT{eY_lBoy#8K*USE|%Tuw<&goR-TTZEA1sm;I+}FMzX$1PfU9Gtw{EeGZMQhFNsX) zl9uT9NIbIY;Zcd4&aWg=mYyA1J7HF0$c|?s{eQPMamm;)dsz1+XY@9?>#LobEsG+j zfFGSM{i)sQ17u{!A*06DyG5RvItsH-<`rye6W6&7WO!Vb3pD#h;+l))_Hhp1I#&lfSk&-3bAp{Y z&XgF~48~FyDY}%6j3V|AEV@WH!n0YU z=vCb)rrxUfBF!k7O%1`Te1FxRNyCe}#I4y~jQ+27iT7{c**N8*&hb-bcQy)N?VOkx zTaQ;K>eF;qx7=@ar9{lJ`4AhF*KBRr-0l)$gC_R{xIet^D2{ z6Sb#(U=?0I(F$KZ(JHxVA~FA@NabbEQV%h~>i@w6EB~uWRzYlHVstEKPS1SInfuNv zXU+{tr~U13nSr9+&NRNINFV(RXV#W#tMm@`W`Fpw)&F^Fnm#A)N`hQS5UBsPJV;Vv&GUIRW}+&*43x4jX5y?s2~QE1wg{7F}f{V}MUU=QYtJ8-=N z*E?{%Be7>D`Ql8Aby1i{<$8N^nHL$*&VY8zg&jS1uBUK4h3hF?C;oU6Iy?^@UQf63 z-|xV6lj|neO|F|fADTP^O_I>$jfq@m&xnhw&n5v?YP(UJ;AuM8Fx10WjAD4!yL!&j$CIBb#_Otiyj>-=e++S^lUbI_G*X! z%(&O2A2;sOC$WpqV;5h?F1}Ar;Fxh2urEU4^Vr1K!40|IK9zo@(yvtdl}f*Fgf2Hi zmm8tWja(0Low<_PA+CqOkL#i9_0aW3=qlGcalI4QJ8`|!3Fwx=^$f0Oa6QB7cN6$` zKlt~I;NPTU=?G>{vclz)tdje|huB2${02YHX%DVV@Nli{A4XB^hImo(1|zKB7!Q}z zSH{(karI|h`R}K2{YI|e$o1cF{WtUr8~!{t{B>-&T)!Coos0gyj{bH8OOGA*#neR2 zJPmdcn`;Nnp9`K_V{OEPu zxC@u{f}g$MXD|54^^3vlx#0Ed;B`mi1mnh5&c#-~j;-v-Jj!w7?#8&fF|KZmtJ?|2 zoz3-ZuCwp^tJ(jVahJV!f^qj^+`Sk#HM4Kzo?zU$j60Wc=Q8eGKUSYmlxmp$F`xz60yu{s~?%yrpIz6;m8K+9uvK89{2(G9&b*E|1P zIjgR%=dLOPAaJ}FJbijtQS4ddL#+RSK#>cvFy$jc|@#X&^8?XK4 z*l`=hjI$VDrsVYw@sf@m6StmyO5~lMn-haW2O={&mM4}k=p9+!v@&t-z`lt!WoJeX zGtZOj&-0kf^Grz3NPL+3ATr-(ZtRV4q;}kBtMG#`^`&8}L}xCxOL3y&mZ{FHclLo- zsb+c)<~PbyotYosZsnhrYPP!tU#(BjoH6YlE38vHG!Y*z7IN3lxBZ zh2UZMeX#I#{OVTUk=PO6(bJD-Parp!Avc#HHCV!V_Ra_o+P$M#|J7u$_FyjWgclRIe??_hggL%ovqe%u?kOCwUVME#4G5` zT$zKt6d(A8BR+7|V)}6@@41xsT*iAYz8r;a;{%aKabJli?LyIv0<-c z!#Z~2`muDt_Rq!kzmDzih>bgr4){Dtd>*|$&ljKQSUTV5gTE)BLt9_Lm*c9by!U8d z;5hyr<4YXRzoYT7a9KZS)elmF8Q!@=I>e3xBp?DKxO3-@Y9?U_!E;BD1VSz|G+Sm~UhYH;t%V(Acta}bcT7-51Au5I#MF9r^$2vl6lq{=2;G%xMSCIf9%3& zD1)20WiwY$>!C|I@x{p7@mtfq*fZDRo5;_OPsb+7&l<=>WSMLyPdQGWa)vymVJ5th zWh%=|#xBXsgB_n?<1#9xy&x?j@cZ?lFY{;JFm#9yOIk2>EIKb-GbKmMhnCvT#* z!a7fie+Q2fV{$3%B!!)%uoIrEig^{ex8c``KU&1}>rv7(fK~JgKL-Y{Sx@s4gb2iud5~lU0l}%eF^j>m(E`iN1U}eG4Cka z)JPZimHp~6c)JYVu7I~Ipv!)B1w2>*59pV0=t~*bQpS~LTx1cX#T#Fc2C*$hWy}o22^o7tD zL0?qHm%P*RD&zY{TFT)55V$`C?t8&qE;if??t8&~FSrGLF}N0ks|#FRWpH;w?}WY> z`rRaCV@yS|x z@wTw;`!GEo-@^9Yd78$#2J9DQF4@Ce@-TDB=g3oK8x?!TdYFULBO85=8rqf6^?`pY zgM9_qSAcyL*jJUoz6$KCz`hFXtH7>-O#_<-Ht!tyWG#E3wp2i;KlWQ?=Ey#3rak0N zhc$4OshRqigZD58Kg=BbIcla?0=FXOv$Bn^0{1F#uL1X(GPu`(dkwhPfO`$T_G9>8 z&RL~Ltl)qDx8|*r$hogvCzh{x8?g-uOr#-qU)k#86OYwiZyH1ku#Q$3SLTSz~@y&GS{K@|JQx|(b zbunsH)T^W%R1bH4K##V5K#vbn>oPx3oU@Vpm{%jO_ZM&v_>q@8?@3^DN!BV-XX?qx z8lk&lKQ`G&PS;3I*GNt$=;Un7p~u$)ytv8Pj+3*UsUvS9XY=6Z`jVW_8z;`6^GSZh zo8yn?J;ga*VXpe72bU+um-r&_m+Regyb!p;9fFyC|K&ToS|P|QiDPvj(-pEI^;jBOfYn}$rL>mHtO4?t%P<_z_j z2A<>g)!5KlD`IL^!Ys+Ll&^tl1+rX0Y+FfeTd8|=!CVe~IrJ6K$!|Qmkb$0oZa_D< zUe3{YuDup|272bw{ouGR$az}kPvD8$4wAVZd|{6sv^U}lH$r#YK{&S&U$_xpxDj6n z-CV}lmNB;FjBR-t>}lv}=*ys!BYCi|gT4;>dg$xRU^k!}(APmfV~IoJz$4!zQb~pa%(5nC=c>nx6e-I?ql5dG4A^r_x;e_K0BPdpK;&M zxT%*p^mmx&uC<7d6=LMT-Hc0)yZ1A0YJoOA?V|#hoNGPExF2NP4>E4(b;JVKTH$|! zUb+TT4V^k#ajj6YU#_RVy0sa4Gd1^SuddZKL2rWI1YN2_U&frGAg_aEaMLe^4Fzp_ zhexj}gZnCQ(JKW#A?S6)0@qrhjGGu*vR3HDjbAHSTlV;u^Q|pkF7AQdWpLAP1g@Y> zztQNHGPt*ZoBku{iP0^AIv?w9Qf}<=*-~ySW0&)D8M~aHUuup?A3t%yJ*RTyKCr$F z{w?6&0{(5_-&O|yHt=r)|2FVLm)4j)*rlEVFLrl+?#1rT&o32wS=`E!GPt*admFfS zfO|(7+&jR%1Kc~ny#s!V{CX3yd+Uk)PJP3`7c0bO=0NAxA*DRgvkoce*O!`aO)kGK z*#0eGb^GdfKfiY8Tb_JR%C{z)Ul(-$YENu^_w#Ffxogc)@|ovbbHwLKw)8f6rkGb0 z)=&!a&UkQp^Jh7qlJ!{5uciFhlV7{?Vf1Y(xTk6pYm74P^Q*FwMc67$`+iA5tn;JNPH$}?}1 zax?F|t%q^-Fs==ZYeN~_>!GiQ-UGd-4DRcpUl08T=r@$XeI4}cpkELD`YVGw^I{p? zl0A8F%l5Q~aqVGTdl}c>GPrj`-wk~a^gU&8|32jX7vOg1+Ma$Vk3LBKPUb#v?E}{} z;JOBRO=X@xRgW@{kNBftZ|jS7 zo#ul7E!MOOKKKh-WII0YIC=gV^85z+D4tdrTS?E;c6{Vf z|1Z85{$KnR{{JS?TW~Wxx)~nrhe!MMaDG4iBm3z~>7y@&y_`-wppIvVH8%d5VvUX3 z-c3`G|3Tz%!#O!PIq1NjXi3ATMe3<%ZlhNJD7E@;i(0+pPwL52w~?nlO0E9eqTki! zPb_Ljm%L_hdAj75hl3%*dWKsb@aYhIIs~6?hflXdpMh=6z&2)J8)Cipc68}>bm?|< z33@#>`)%09qtxubEo$~M{tD>S>>s6O|7~jaZv2zLV7Vqr-J+!b$HP;z3VM|` z-v1-#=n{{m8aTcFPW`X6Ci?zDO-A`c#xDC7sc+TeTcmu)QxBHngePB>;{>&flKQ_l zFLBrZ6Aw&h-D5iI9@AO(n2CP5cuAg)&UVaX-GknX<1;4Wgj4%OZjOJNUc`R{{O(wh zB%e!BQwrL5pc8jMcgKow?hbU~4s_xUbOO33j!O7FaahLho~L+aKL!3wLH5+7oZd)x zT#;q(UiT@9lMa6B;YI)K_ygr04?Yk7CH_eK2LBz5?+(UyC*!+Q4?W#Pp3p>|&_tfl z1pNchKLGs>=2 zhyTZ^`JI8k4WcF}`Lpft|2X_VGX**|LCK#*%v%}Xt>C*2e7E5*CHpWBLO%%oR_M20 zdTc#cTN>Bhy5js~9=w%vJYpd|i>Wijz#kH;Ji6&aHa=v-{$huIh_M}FZ0})g?WJl~dsi+irz;bOM^yCAl^3B`(taQ*7J250o;WPUoO(G9yZof5w&>A&xwa^+yGnL& zQ8B0BbAAPOcg*qDhTQq=h1Xss?Ay;DZ@o2Px6R8n;VThu3;EZNJ=l}EJBT-T=t27~ z;>}&q-PpsqyNEY;5pV7y-Uzx}ACj@3fBjYN*^uS#>Djnaav%6k8SHm~{VuTI4feas zV80vecZ2I`VrSr+jXtQ%RD*1K19p|__+i4xr6w*gSyOl)0huU$4}6Eh#ySh2ZKMX=6XpVe#to@ z|52?+8*23Uyc(`=;Q9uxZ{Yeyut~fz_k(Re*!sZ6+~}A1iT_}|z9FCo=S|mQ<}Fst zzD0|x`>nXaT*@6E`91TS|DczZu?6Rmd%5~A%IBU1Tll31d*bP8uvLSt8f>-D-L??I zM~2xm89h@=45%d!XAh@RuZ2~5BF~*^`4{}V9vXcv>;ZPpxy=06fU3^5en0zp-xTL= zu`i(_TSpG|$PJu7%KqKBcrTAx#Tbk4`%}Ke89T_%`JP_N@$Uzo;rn{djuXG<-819g zD^F)1^>H49n2RXvd8i*h)ARHEo_-AH_w*>8`~Bzm?HqBAPv9uOb>=RaFYwM-`q$_^ zJ4Nr=spoj79_wjO(rb2_UbEBBDc0k@X6>^*&DLiRH*3#4*K9rGYtp{h(`0?|aFh1L zb4}@wu;=&H{@c@^F7EmL+~+IwFZ@M?{tSCuAA8N`?D>8C7Zv&wzpKzs)oJ?aIa+bg z@2z^Y?^ZqDPfldtR^0P@P*3F#vgh|UJ!IbM?D?&l^;F>atEaOK@3XVD_rH{_iM$?o zm_5I~LpKDDvFA70d#4`fysXsFoq90WuZQw?Is1OYt^MpRQT3>af1xH2H~Mwnd8{Wo z`^9-$MPDM$6gueml7dctTsygyHL*wNS$mP5HO8CFxqISHZe>mF5qjQUr01=Ud@8pJ zUYGR5(bIO4p0-o;w4I`-P2vaq=Kl1woua4h6g_Q^!>=dc7thmAzg7V~06hRb0A1`6 zf=@&6$%ap(w?dx^eJb>+(6LqUpTll~Eq8$bAJBvRJ~Vo(F8CmL;Nb7<_uzK)VB}sI zxAr7Bp9JS=aGtL7r9ZlQ;V^rI(pxIu9A=MD`l*ZFBjoC>EAA0mLoJ4WI(03zn6+Y$ zP@wL$U+ba1D$aFde@d@EQ2YPTt049Yu}3J*UZJXEpU{JOU!a;jLQ&Q4>=BBNRRzQz zp)hAGRetizV6My_WuH)L)R(Q|+_*6Ng+9(+p-{6wps`md+2_mt0egiKy@kC(?3H)+ z3MGfgn>*nn^Os;RI@H(CJ&C(x{frU4$={_Xo6)B+bZL}WMLY@_bO*-XlEkMV?nD*2vts%gL>b_Yr)_i};c{u?8dME~b0F@wv~x1wY<`A8)}A1%9~a z8;?VO0{SWFr(ffJK_1(3^V4HnH)ve1>8C!A-+4rH_DV@S)<3sW)4$NJ>Ce1h(;s^T zy%1~94tCDlb>_-i!B-A!1piy$dkcJTfsegq;495vPHsI5{Vepe&=v4Y`HNFm%qZ({!g7df0rie;9>EXx_8w1 zORgaPsy^X|_#N|P@z-Ro?9jPBe>Ze-J$@;NZ=L8>M!!T~Ho3K}>G&&6)Vt&2ugPAP zoa48MfrWh9(MhEp+A1qzuYzZ*;n`|<5b-s{*w%n;4cOL#ZEYFstD&!kz6Sc5GT3Dw zCu4W}xGRP|vrNWL3|EQaDluFohF4f2bB?Ct4|M!N3V*>zTWHL)_~6Ut!>9T1DF~l} z@BzPK;#X|^27BVe`5^HyNIYyMX1Ahmb1gnv+?Z?efsfd=E%Kn%=;>+=pM$O83;Nkl zkY_)Ex|*0tE<;WdAH7XakmJeNlYQha|-a!#VpPV)1qcYAr5g~ z!bx8PxkLlGL<6}*gU64a^wmSJhh7i89=(_I)*9$F&}*QJJjG+b=b|jlRim@MP5u!eCiSM z;;kAw?TX(QpA%>P5bRetCssZ?XQ> zmk*X;zmy!fFkd6rcIShdHwSJ5a~qi3z}ybzb}+YtxgE@l$Q>7vJ1!>gU(CJmA0}sT z*qpIpC&0WI%!|R?1?Da=C%~Kla{|oJJ(%I+#pJ+~!93C-V+KbG94T-t0>>ig?m282 zoKbMbp(jQckpp*Goc#~ZiW82_53D2y_LHmm$<_SiYW_00pbxqax(~Wf_vXOUp-+cC z9lF?GDCdIHpihH74La*4A{Q*>gIv44Kn`4x|2%YlvN>=S)nv4>Xj)EytVl=D_IkdE<>HddjK2hR&*cYz{1+Bjt_#RmA=(Vt+NYi{c!tME@jx_RhbZ zIheaP?C9XguaSkz?_!VdZf!VX)`D$fAGtSP*FdiUdo9>&^~bM34qULmpMm|#<-mpf z<5yQe7nXo`33$7~+wHMw`P>)TCNEzXrj*fzcRL4O3ihR7PlG*O275R3Zs<#)FZKAN z%f`;TMZ9((`=m+bz~ep%-{sVUg-^N|e}vy+PCoQOD=FsWVs37fs{?nH_@i&3gYFpW zwJCQUN}5NO(P6n3>YmeIF&!Luy^I{(=MQ;v;1%QtrRNX*9_qkX#20^0#$F}|?$UJf zAKmUEAM7R{>?R-VCLip^Z_DQ$;YUpTh`oe-aETtyFC!o1yd!lv`QUQ&aEZl-d~gZ* z;F5x^v6lVJi>#;p!mn|*6uy>P;YV5H{sn8?bwUrx59B&<3HA%-z)~&H@xud;g4>k` z$!pkF$m|ApH@LgOod$Or+-Y#9!R_`@5fdL`;zMkFguN8p)VIf|Z&SxkG_MBtQgAN? z_fl{#ErYxJ9mnm&3grPAH&|q!i9#wjK6G!-U>YgJ)}$i(X&qN z&Hu;^Cf2Dv{`OL9zmB{!PnE%)!53!qpuLVcz&hwM?seGsIz0|O0bM?)(VH(V0QUlL z2f-aIgPZ%8^m=%4qmL!M9*8dkr$+&VV}u?u`EUFX%P+9lZvu>z|%; z7Tg(dXTY5Sccu*PweJpYWvz^xu}Jk@x8FlgUG-dKd};PA>#1b#-g&{fo{2)gNMSzR z#kl3X*wvc^UGA4~&l@k*J}-IPW#%)5{5!_j`3xPpsHi$NlM{wgb?o zLHE`YE-16N!>+WH!QKP*i8Fz`*f)Z`^h}^IV+%932xE(s!LCEsp@*S|%V3`Yojqvk zOz1PqV5fK9o(`QoYKFI-aM{>1)iQQ`jJ$@v0UxsgAF}};vk4!w2_LfwAF~PHx(+_A z)6bnBWNx(BFOHAdh>zK*hx0x7)*gK827K!Ve9T6C%tn07Mtsc10-s(K{b8#9*e^7V zedPEUZ26<~g#Ch^FnX>&hYozBL6Y46RUdfr+7TKs z2hpbo(Wj50PdrERuMzVB=np`D5c-2<^i{TXd7k68^-K0sW&P_9k(caWH==(N=L&iK z>s8ok$+<$NY^UxA604t&n*&xUUBH)!^<0cQ3em!QER%zB|Fa6Wlw&y%RrA zy!svSidc1e4(GF|JHfpZ+&jU&6aA6>{MGM{pC5P_U6uX39J6FU@9sbL+PUm6-FAK@ zbk*@OBM-{DivC?{ef<*c^a|9+3;ywgj9rdXcVRp9($hyT_I*kEh>qNik2$yR3%RYp zhpfPdti*?`EZELpl=h7;hrS&83g|2J$H_%X`^F4kTJ^?v_J`SZTwgd}|4OV4 z6mpBtl)=6S?0dkz5A33+-erqm-v{=6dK`KJx_rK-H_u8l_KEW~z1SO}H-c>nyb=9v z?zv+`I{)j6Vb6S0#*Uvki=R1*pE--4QLK=;7eBKXKeHDfLpB~Qd!N2aozwX7q?#0jS!_Vx)&+Nm`>?`A6_m=Um@ZvS{ z?bpb+e@7pbtn=^3m%*=7_%nRjMfF7$>~*~?*D^kKH`sTBeK*+mf_*R8_kvxVF@%pS zJ@?Yw1NJ>&-vjnN^na5VkC7LX6Nj2V2KGH*-vjnNVBf>__v=y4`i$ET=!yIT8s`(? zWA7uE=8RCT4XFkXzC?@gPRt1J#*C^DpmRJ6dvx#f_$c&`LcbsS z{km6YWqX%(RYY z!fVdza_H{!aJ}{>+3O{b-Mc@<;rqZ`+1{|BYZ?2sjQx7Xe!Z-d=*jhr{d&gEd0WsU zW(v8akjp~kvapQYI-qwzPeD(Wk(>J*6EAl6`m@L0E-1IR!!G*%`AaE%V2-^*Pjc%M)du=u$S?(H{ok;!q?oSrPNz2 zKKPnj@HMxfBiF;H>*3Rl@aabQaI?h+Uvo3Q=4L&dzY#xsBYyTK{OnEmnw#-8H{)w= z#@F0j#?RjL?)llwFJ-xw@v|71c>~yQ0Q*f~zX|L&fnA*8CHvVM!G0syZv^{|W&G@o zV80RUH-h~}u9yAn4ey?x9r&R(c|R-LyX;9K zMd!tS0PLk_(Jf+Zix^ucW9uw~eIfLP&=)~pR0jKO=(C~Efj*}U_F2$pL7xqM_Lajv za7xBr#?SWQYx?jtefXM#_?mju3yOY3%Py~*DsRoQJ3mL zWpZ(^pLNDQaHnijNVn;kys= z9cPPkE{5~nz`gvRGawYs5ivLim~%v&@0AZ1&k?y(&eAhMu&^|U zbuAyr9{u>2$(5DtL*IFp_p>U2hVL%R9{cXA0snmFqKxh6Tffp%wi2j1OHW;1$v*l& z@N4EAJ=#A!rUuCp0D{GYQJ;<+X*!ubjbzE2MF9cL`0#CNs|zozn=3a**T^907m0!C#w z&#L6R5{wyfCVqnNk^8vbD%<(LGj8;@aQ@9>4v+3D>Mg%LH~t@?v)x*l-Y4`-Yg4fV~N(TF0tC_1w-eoq|v2yke77Wivy~<^gRQL!r#9}XIG( zv#W(p27G+{s!}{3+Xx)<3H{{!9eBLo(a#Lybo4X*3hx*e`uPz0`6T*z8vR_xJBI(7 zcMSh4`WYy`V|YIL`LWu@fdA!R2P$W%*`w%W)rZgO;rt@{#)>`sxkc%pRed^e^r25= zEAKrLc<7(f*@vd`KB%!p=nwlDM%m9`FHWDj<50HJ`f}i*?>;Ne1POfnA70hNDmEqd zG~^efbBl*JqW@J3?&tl%zY0{oxiow98=UdP^(lKXa$2H?@=L(f0zVfOWHho2OhONX zCGrrznalU}6W@(2=DS5%_`|g=Ckpb}FZjjp78T#YbqqaF0{2W;4l4f2Y>g?-@NOxb z(*q9&9Nj%wxK9md_l$oxaDeZ^&V35{9S`^qi~BN8rKRYv5&^%$cTLKj$^d^AMGt-j zJ$*t!A6BCetI>zm=)-FCVO2m?*PKt@I={{ODiwTCQSRpW_^u1o*3@Uu$-cH^oXWL~ z=}O5zjQqp8^FHoe_-*7LM*i&S9*rXZ=-bFYhWy#r&HnDhX!LF5A4UFAe=7eM*CEq!Ka_cr-yt_-Sy@~3L&_<>TXat51$jQf zcj7r=NADax$gFpMSI|YJs81`4_AZ`NU-(X0QBJ%foEX~v3f7XF{-|BPGlP55L5AEj1j z`CXt=E%Gtrvv}vV#yhXAh*^VQtg+&1HF;mP6*H@~m|Z;_s;fxv?piv${@+%n8^8A9 z;lG;}N&nU1^}}a}qr=zTvpIbq=TH5B^QZoA&Yx;{;QQG>xckci?YrGstLqbi#!rZM z3(wL+{VjU9uSJjcwhZsOby2`d9n5O~cr@^dDgT)LL=Ac{I!jORyClC$^|how+nMJ( z_6gaG^dx(RQuvw;JHMs}n>(qU@=i~DOf<(5Y@~)j)svj1mTw`K13$k@jkRbowbP0j zom$-NwBmLr&++LY-lrb6eb}Fm@v&ZF)G@v~##hJnthtY|-p-nRs@c!=wOn7z^|f5j z{d4dVJ|^L33cd#O?9qaUVR#vZrx)bO$lviy7f%=y>-ap^vf9^w<`LqC%q=ab-*kiFBj#*ziAG7Yg`~d^vmMI64hqI86@^P1B>fY3b+N zHf8-Y?++aP-@nRM{&s2Lp>Hxj&rib_(nrScQbW^*Pv(0AM?-V6l^=xu!I^=^JBS^^ zme7^(D7s{~q-RvuWRK2&f53loO7_S-*!$1LIV$MVP>Y_-VN0VeV8+)8UZ^c6GLEm9 z#dr7$;UCoc6Z@U-{zZ!zL3}_^i`qepe%r3wo>!jz*`F(2KRc-$oaV1ZzVsj)t;o04 zirTFO`pZh!ZC@31&OxL%IbwvMhoFZfy3h}LSqys4OdYx|(UG^uUk&qJT$0yU3o+LD zZFND017Fb|M)-Af&Ujf;A}Q?s-75}s>fRc;%$2W#nr!NyJTA(!pt{N*9u zJDRHn2k$Dk>xYm0!=I%;{H^)JRo{6ief!a$5~D=!T$`;lwZP%MuViaZd?D~~?A}22 zA1_0AZS@MtaPG=eY8HBopNw;OpTdHztH)ov)r ztWIFI5+*rRuXv~GIL-=mi*waDM=lDkcqi|sF)JL~cW@2-pE9_rc}6wQsOA~yuLoB( zxHtzB{}~#EFPDc)i^1=BzLxQn#Wjwph==%m4ih>DCgyR-iunqdc(+19P6ODh>00Ya z|Lyx049E87)8C(Y-|(`hcMcy|kVt=a=HHF;*V4r}`kiqM|LfK+;?B(MLnr2-6Q3ha z9oNIn%&pMR_!vCTH>SV${`Y1dTKAs=)j#=u_TxW!B2cv{&RCEozYD6(#E&K|#=Bu- zc8wM%-oy>&XZZXmK0l5wBu4T5d3^sE=cKAN%r$EYdRvfT5pU%<-s1f7c5qdqf0bHP zt+Jw=(G||2|3kzuo`rto17zw)I*3gorD5 zDoQzdy6)rEQ+XWt1Kx?IMezr`6OD1!Gfv)%!8j75^;)C>JJ^mL9C!Q&c2LhadABV( z9U5&E<0;M;#8`bN{@$sNyhqFzbj68#0WE9>EPR&MrUr<6Q?&%|mP!~?wRUx?)owRy z_%ADIG;1Adv(;fY1yprfasKc+ah*6}wvhX@=)u-mVypUHaF3!(%oyQ~5iDCF^Wnc#L)avua)-o}) z8eb>QXT@%F)oISGM6a+-K4CuWD|N+G|MSGuoMYR>)PgOer}#h40OFGpzgMe;o&-eR z?BpZ^e=l;9z!9IImFST2KMq!lx{t`8$8&7)P8zN+%o{}wqZ&GMig8&gTlqh_$lUx# zBF1Kz!-(hcoyb3&JUz25d)Oyp-!$>NiEA^P_^yfX$d}Y<#hiXK--$ThRC4`Q#ds)i zR2Ot;fH?}eQ}79Vq)*H3(lghI{|2}wz9bCdb zL=L5g^HcTc7`ciXAV&xsZ1mrpzK6Nh%gn9*D7b34@`3NCueo*6@RObS^i?~*HhjBj z2I{6im3`#p(}DU!cJ|Q^y%cDOy`DXGq9Rax`wiKLzb|r!I-NNJe!osn^pQ98k~bK{ z&`$D(oQR)deq4JZ=*)X=Pf!2Vf#D7DC(|D~Gc>$(`VZ0{{*T~r?7EJ0%g3nQ-PV{r za@%XvXMT`9`ep+;D7h@S;^edma@y%Xzz$2F*H5m}R~PWrDSEVze)p<>4jkRICtLZ= zF9rNx{UW>}&*dILoBVr-eA_*?^h5vfXT#()>FV!1G+fAO#8{^l^BRA);hI+h$H;4{ z)kw(A|4ETsTbp1#vA!Tnpky zLQbwA#~>$XFJKv+!TsbI2Cv{#9DX@Des5jiFu4x0$ky>U{sMN1NATUr_guO< zE`QF2?knc7@FR4NAEJ*$mbIKexMeNn58!q0DU|b9`HWjBSLOM#Zn%5^bV)Y`r(>hj zE$1BIe$JQgogO%jPK5CtCH%yfPO}mQI@8NJ@0~NPu!-Ib@_rptW5iqP zt3$EzH7o6;pM6CeRL*}Xd&c~E=CUDtMF^X9&b2JgWkbX%>I|w*oYKWyHt^`wr?Sjt z0}nHot$XmL?8B+ovz4D=E;h=1mO9*FF^{G8CibGmsl_Es>ThOP7do8ki|9_RxHnd2 z9vecR!svBP;5hTxh7(`N9%CL`BYb^pjh^bP(St*E_{=&dCsLfc(mZsGT7*q4f|^5= znnR45LyY}yaW%|5h3C3u&9$6Ao=3i8#C?_6*v#2BK8-wuGvp6z<)ZM^j%;~4KmjPXV4V$P->4{OHD+Nk8;LsKIC8*xZ{1QmfoHAAL@+-{N^}ja$PV+!5AN^5w?t-igP`SHl3NGT@a_lb7_tOW^87RISKQ=5c4`` zoXGp!S-b{wZ^oNK-a(Z*YA&paxwlh0W&C2?#W7?1(%KB<+bZN6gjbG?3wgcr5uO+1c|o4n%JW*e-+ab9pYhITyz`+`d$U`ihoFb_ z@DR2%i2j(^63_RZ9qisW@5MKt`_1Qm3%K6`dHelkBUPkXtsm@!q08&j>g*=&W(W=*%7Ek0UGZMOJm3yo%rkDhF9)l+@gAO0;ghK|~-!wY%a z!sc4hi&j0^3m^LNBYFI%ip@wm93H|)a(#T1xH6{ej*k&Kcn-5zrngL|QGCi-R<)>Nc?2Y%F9eBehN_hv2y zz7+U^wyuZry2ja8dbk(N{b0`HXH+nQDFvqBD86&74CX#C<9p&`#D(UIz?@miI9-^* zF)3eBhR^fSE#|zewK_ElWg*XW`3v~Gz>3)m;BydO1iiA9bJsjMFmv0WI-NKp&gBC) zyqSnItb63)6?`bhnKI)NK1k%bA|GHrgbzv@Vy%l9llN)D4+Zm;RtJ9Q+}uz3FO1#g zhZwsn7eGgvG#%a7?ItaS&htS>rlKQL8K-Mb!oAoFX*Q!H%@!ZVOb$H8oJO4qu9=Lb z+2VtaG{YC@9v#6hE~F!7*zF5s9qA*#IGWK7ADW2#_&ojmR)QJbh+SFA% zQ=W&ip2oaBZnK`|%=hGZDC=v`sZTMdZsGb%^qbO{C7miWW}!b~y`ZSq1MK-czi#MZ z&ofwe8=~IDm=mMazw)fHjZt4!=OF(%y5sYPO7jd?FDyDi{}sL=HHP0Hf98D%R@7v@ z*KR>?W}!E%0b?8Ia_(k)2L2<8Z8$!HYrL|M{G#$}aJl4<&b#~~<2)}8uBX45ak0i| z(Z`Ek&$eR5Y{oa6STGBlnWgFWENo^LHZu#GnT5^F!e$u1Cl*kL#tzOK3uHdy8(gu# zqkj_Sk)JYV7iOO6!U$cC+sF=C2JP9%VRo7Mq&pw+&L_cCB5V2VQkNV@#eBhicBxml zTt4x9a>oBr6Egf(7~dBi^l2UVzId)s7b^6BY%jx)*^GBKx;q=)on3|>v*E{V_%RoL z%!Mx3N#s07uCvH_628*LSK?En_)=YySh>WDalE{@NCBBsmlxP1z`=-9VCv43IGyc_r@?&-EK>7MwYpcS)& z)J~KfyZpSLmgAj&<#qe9&F_1M4dE z;y@2Wk2-X>p2nY`9!ig2@;Qa;StF42)LEB-9)=!$NwI>Q2_5EaXlglHo7!fz*>Npl z#;t@A*V@&%)o#Z$>N-}^h-n>a%<8bC0aZ^LxW58U~8KBHfIPL z-P9Ah^>`n>&HeN?oAfph(%YQtcJ+*oh;^xv2gN!HYd@@2iFGiiALIeC7L?_?;{WgG z|4H$GXN_t^tOJo-N%L^l6y5JG45@xi$4}|xYbo1rrBt7`(C}FcO&>UYa_<;Ej9Mc# z$D~cIk=}{Dw~AgR`Y5P7hE;krnwy<>7sh+TdZI6^C;RC&v?I>D3!NN0PrMvsZrm9W z?=JN8h85pkn62gAg^#>)1b$FI8>EhAQcvq|gI{g%jq|e&>S>*AU>0j|qE9A%;z!OJ z-h*01Wu9c31Dn484Nd2DPQbh4&K%p@*P{p+})d*c%!#7IOcEJb$6gGw3Pk>>*_@Y1HOC?i_QE zLHJ_Amwx6`Irs^W!;C#TN`1GF8bWVrKipz4Q^!@q1qQ?2fugoAfhIr zv$xDlLQnEMnFlI#6*_C{HnkWqmFNxkSD>>tZz|9guD^U96yoWpxu?tn=CMQg9GiT7 z6rbwh0Xhmj2|eY|Wx2U}^0;1>8$EjT?1kysqvsmB1||(m8kj`9mw8qJy#jg#bP-eN z(V({}Y+^V4&HUfRL*!2HQ!jHAqghXNHX|d^2f0|RFBjwCBRq2v_gut17jaK)F-N^` zD9V_kj429T?)jsR2|Wot<>+df4m$a|i#Ib)EMH^mc%`1I!&@9@q6`QP=P1nX;V4yI-jn z*sLFjz7CI^>Gy!1gr0KfF~$^QOfkkJYVoq1qR^wzqtHcvvr8`ApE`s=9l|WsA-tHW zdl|LRYq_3!^<*)R{3o92!mP!>7&E%GIQAU3yQ~m(6P@~rZq#cjYNvd(g?59*hv(DJ zGSsMtZECpmwM0~Et17is!>OI>@jU%R^b{qjG1EIl46nENX!OZ&Z~A3&*a@;vq93Vz zM2i^Iqw(({e0w;LZK>!D{xdO(4;{rXkFnk%WA39zJckb+!v{ADKQ7BTjBdx#?V_AV zS{bKH_rM&nVnzha5ylk(b0e4=!Q2SuDPW!g<|$yN|0$OQa}vx+FekYeb60f=n5U4p z&_k6^f;kCh^h~^`!fXU{BbXbxH+^kFk8Kg>u)RF{QVjY9d(qW?{Bj<@tkRQ+??{Zo zmr?jKCj7QLRt5XuQ4SuB!J}q))OUf{H6Zr8$gwL0jubdj;7CE2V;Aoufu4k(8cks@ z^h2mgCkObF)33xlLHJq~Uu)oNO?uYw$uV06t7^qn6+Wt(Zm1R?_^7}~1wJb9QPJa! z+lk}gOpW0K4B@N6WedMbyvl>C7uolV-ZSE-T1NIm$bJ;rqZ?6l=)3UcCAr$bPZ+byujx`efG+1PavmYaY}uE~F9AG_J#O%K4t71-~Nu<_j8Q-_vzcw5nJT* zU3x0tRrKxXML#)wo*Z5!KSqxy=i4P+ANdNHWnGtjyR7Rj-_G^aXN~Ea=tYUz)63*7 z)OU?((5FGC=ADyuUG@*MuFE<7WOY4X1~au}YI{G z(kqdp)=7;oObsw9YJe*FwMu?%kY5|**LiA#W7Mcs_6Rr6!PX1=!03@DcF`-3?YeU{ za_(OIa{oJ+t0@mL&I{Qy>wGHfeB{L`vkuI4V6Fo*y^cBRnXJ!-ZR(SvuBnn=tK`=P z`L#iBWS({1G4?&H?0aq&>!$3TGHdZ~^t9Vz@05(0ockTb{P#{x=EE0(c`lgef_W~O z=Yg4b3ER9&*q#UG`C#V#xHk1mu_mojFI1@)8uP%+Uhh181!L3=)dgT)0Oq-1o(pE) zB@Caun5o6R)0hWtzX;6p!8{+#^TE6T%)Cq3=3T<}0x-)tIXw{S0x%bP9K3lM?-Dk7 zm$1$HIDB$!-!Apryo`pTN-uyx9TmMe z*9(At#L23j!@H6d?y?o$rwDFdAh+o-DI9_Hx%^0qz>uieFk}-N#19R zyiJbxtT7m~pwEIntKc(+O6y%M&{<{2dAiL!Jtx=T8X0pVbo#<<=H$@bH8|EM4Av*iInd{n z;n{5HoQ-61_L0q6T28Jzx_HPOMy|b%*Wkhh%*t*sFXEo1H8?r1lWTCUybjq<)IOZr zzCw+KTF2z-a>NsS2fhWI#1m>Sr8REH{}}ime2aK@y;t_k*_pQ&YvyI<>_Ya1dW|Fd zfpv^olC8W>BioX^PQ%*CJRXUd;5!81&SctjQ5iCXG46+`)}mi-9p_ zEY{-YVq(@}E2IXAhe7;!5I^3EA8*Bvx8lcJSzBWd-dEUz_Z)i{UaI6?tk0>f#DrFI zfL7Ml*su9(_HX;DSX-ly&t!ehWPQ#Ka&LMVa&q3o`rpgCOP6Dc~R>EJ=#f+ zsIfo~^^#}xku&zsgFbJ3Em04vK0V4O&L_bqsj{BSC&<6W`v8(EI>;xeR`dUAeh%-(mWxqj_o{qt3d(usF9OnP=bC zD030wY^c9ptWE04R%*Yh*iSJPo=|s*ydJ3f;|lgz-N2avM|5Y8KXX~EGu6I$Qnb*?`}y%lge`*0N{P4^k1R8oo9AP@4U`%NQ%Ino*Tn?L|$ z@Qt-`K0$OO#7FeNvsVDDtep=jR=Z!(k{gu3Z)Ph8eSY?5g3)hkC;tAd$Zy3tQX2o~ z-K|PxQQyDP^>Vu!m^)X=-t%v2_W9qa&rbhu&b~UaKl3Mw|4puG7WbIAMj7He=N``9 z0mp7ezQ}jy_2Hv$gCae&aK5@V#@-3ELa^ycM(;Xkp?6HiPXg z!1m^A3F1P+n2+tvx7zJ_8uk-V)nL))zKP8()syB@Y;Gwwm&WGOde}%~b7^djb$!}yz@VNqgV>|4aPHnX0}p8d!R z*cba4Q|x0*v5!%IVcfo$ORD$-J_&Wc%f711+E*3!h0QnPW7)5ZePth-c|QBXC-mYI z_mk{wqsxIV(%k5=+rTFXP?>7)S`W1OQWoD+U!m0pPDY%7xQ_Q z+=KCkRL(Jryq-OJ!m%&T<-oqg+BIv`@ln>QbBS^L8pgf?)xQY5R?lEzV@=@;N+{3Xi=RVH)f9Lpm zBIwjQo-95OUv}D|{eJ#blx;0@d zs=BObU;iEZ%IHZmgMDSNF9Z8B^sr%IUk3JNU|(yYuZ6x=kLT8+8*8)J8orCY${X0L ze1yHq&-=8~N7$?EXRq?}e(kdx{9W&NED8C9iyxERlKaO8N zLu}~hy`25nMel0X?63{as0+2yli0sX4|8plYvZFU^hACId|sue23PAz_DKZ?*YI!l zGUnHo+4H*s`&)(m1p@Wgyux`EUm(6#ID39M!z6HA>;ubjmW#@nF7#oC%;`F7b%BRD zSLg_5niOga|4ozMU*YZRUWv`F)S~JtD{64gUQXK2%e%KCTk(&N;3s)EnCD%kyh|an zl{L^uSOa~rzzc^Dt*fne@}C5}addiXin-6CPtpzj7<q3DvynrCZsvEJ}-89vQM7Nvc| zGM{E6%Za{W{DyUMJAC5YlT(i0aO)9%13G*CFmTUTd~gFiaBN{b0y zL?_>dXXE^0F1NM}pNP$aQ>-vNN)1v2GCAi)=u*D8COSfG-lI!%!9wknS_fySLYH|Y z^-g>IiJM1}34fxqN3`HmJoqmDoZ2KoB3pdifT5DITVm;#>4b%YLGk z_3|wh(9vT<_$lT+b?h;&QG^a?39z9D0;e7~@I`$WgKq^sMD%2fIMaaa8<0EoPLsZ- zd}Fcy^;)p4z(1_OKdiLGJCMBn>au?gf{mI9bp-Z#XeVnpS70-HijT3U_ysSvlQr~x zZl>?^7=52FRAg&vu#3yWGPj6@o;9#U2kWyw>>_T~Yv^&Hp^7j^GF9Aj z4!oQLFR2e2ti7Szu2^GIN42S=s&k-=eKm4CnFW0o^x4o^uaxzKnsdqd{DEVFmz}Gv z4i&$L4G29!Kdhv%fkBUsXholTF6Ok0nA5k`5_`@g5$^j7F0t`C*rNf3GvdMkAH z7lhArI=YbiBq@zE9KuoU`I=xONG1faWfBPaIj z=x0$*!k;ZI`hYr3?6XLkwN{&mXPwlb@NJwiQ?&m&#w+`^IQNf(hnoIq9J*}(%*mk# znLmd_@3)EE>{jG)M1b+iv6cZTvpL{pcb0@FNaA4!sRJ zz55sBM`;d3&D5lZ1s~#r;tZ&|qW%6mIAr@R)(60uaB#Zin#|GLPW>Rr+EPfYEt#w@ z*fGWxXI%6vdd3}vPT#K@gC2AHc83oaBUf=w`Kl9Na_Um|@Jv~DNo1EqcC33jW0GaZ zIvDgI{hT4u?`d9=AHB>mvyS7$R%(hSHN{T)P~bghb`*F&^5Zf%=trgRG|o5^&NyWp z^rJ!#+N{rs-gr~?eXv9=-dptV0h;c5053Ex!rp3;alkcb>vxvJgMu8^F6@9`5sy3szrNxzKl#|p1Wl#k45q$Z{wR2 zjy)9kHz4y*^Twl;rkg2Cw^Le*byYsZqea9c_F3eX!0RROdI`Kv9ZKH zn`C|o@o0%2RH?}}r?r^MdpFdD#G{48Bk02K*`@J_zUm9bBbonw7axxtACT#mF@xg* z@kn~66pzaAdC7P@Dfpd{_wvjo=+P4Ns2e?Ee_3uZyju+K=$~`+up4?e^rg_LYeP># z55n7!!&_NT<(POOJ(V%CHf(qCyd^wuNg2JT&%$Q^lG+8GGu5$+^T*H>n4LOI(brxN z<`nlxaS!wXd3*CO^u7(9A;AzLfWSN-@OU*ItF)zqLb>uaE%m8;S^ zZ0aw$s-pk71x#|@bEWl2@KKyKIG$_GF2hF`F6bBHql-^v{H)-^jEQGv0$!YMeb8d$ z<}rJv7FSmhgG6o6#Rp;*F=>pLq%uc(+xZQ9CY*Tg(_+jO!g-$_HJKj|GB?ioi~jE_ z55Ch+`LH1$Hsr&Ge9+x`_89cXp+5orltXv>=+jRrT+e&BsFgnRD)wc%ee`3{ABX+~ z^i!{jebR;&HVun48?8+>tTsENCCrSKFfv-Znz7pLwHoU;R?=9jb*O8t4tq^NRo992 zAC0}DR)lw@e92iquDkP%TYd-ab9$wzYcmG^g8Hu5?!n()r<8c)_vA$r#3T|V~phm z#!}-R%M3A=8pg7ju^eM8FSy4tLyV<{v2126#~8~C?y=0MWGpp|Wiw+r##ml(k7b6l z4po0=Q&T!n!+OhMe|6w+jp#j8v(EYpy(ph@*7yFH@BCTOn^O4y3I4ws9Go-E`&R~> z^~JC8T}{^cUiF`N%$eW(*NNY;e&+mcg!BK^hT`wk!tWGuZSj6Qqj0}x`Hpo)@x5C7 z-GI2Z@H;VqoWp(-eMR_^t8`|DRR-?exO4Ghad$((eX7 z&+k|Zb)MZ^_}$3Ud?)ZVIQ6jo&N+o`2U}RP^Q-h5s8c4s&%_VT74#VdLq9;PmXP1jV_D#d+EW z*f${4&Bgd`gV_MHp+)fxQQN>ygL;CxYtp9vDr(B=I_T@5uYXQ0AHpevQj3~2JCmX`q6!SKnnX0qUWJebbWLaeJh*1nETLe^gB6*ZZ~f@uWma&KSQ43 z*6lKwbujB-*1;SGa~RBFFjH&KT?OW=zUAnp|gGqp#fP*V@)w}5#InDHmgTfxj( zaHbAs9nAEDGEe25bztrSa~GI(FjIT!Uj$}qEh_I~!XJi4;mas|8C%aY@pFUtITJtE zzd?`p!6SS`5+8|w1oI|**d}}!JnGzp59`E-8Thab#rP%m0WcRcn2RwdE4({t3plob zV+%O8Kqogcn7@)E70%z-hHh_ToZIj*+qh>N_uPDfT!-^qTKRtm|8M0PZN-?ofqPJ& zRH;uI)E~__*yC1=Ix2NuE3U?^kQ&!?BMx8V@HGZsWAHTwUt@Z(dA%O$6PSquW9uwY zzjXW{J}_w$2lC+TMHl+fg*<*wEu#zgxCH(!ISQY~EV~#Lp z))!3H7i`uSY}OTW$c@@q@ts%PD+>N7_@j)Ub%i{#9z)hDvTp8zAFMB!tS{KCFW6$g zJ#u#Gzu1fZPV0Y*j2RsAo-N?RXLiS3O@0Ro3EWYa~>O+|C zHuGI)L1zZu;<;PUu`OEE+=7m60sk)UyNmno;=a3}Z-%}Z`ex{x8P`tuyA%HIL`Qc* zr#@m(AE8cCICn;lDb#!nYLnC`3unGac7x57#8usEH@%Fv#BQ8DEWO;bmwWbd&tAsl zilvNc7xZ1wcR}9;CfR3igT4*=Ht5@+?*#KsJq)I(gJ~=DtqzEYuL=IRjr|;4841evzxVcnD_ftam-W0^icfdpy*u!Q6}7jH0ig z#;abpTc z{l$C1(2pME(F3)&jDM8kpvOPTIo`OOHy1I#&Ny9i2J``{7xNshszW_WZVIgfk~%q}@|PdO&+v?9noirk}&FPL-1 z1g_r*eIxXZ&^H!vxO961^bOEAKqqeHWZk}0e;{E7Z;5}nFy;(31P|s_+=G5Rn|{I3 zRnTS3^nnenK{ji!*EP_u0@GDsx(ZBJmBG9T`X=a`pof5SboYXiGBv1=Q<7Iy3M<7i0jutUjuy&^fg>B`|{P$S3_S7onD)qWaA!RegPXF_$kkH**N!`g)Vx8 zCn@{P%ZzzaHjeBk=EF{HCG#ZrqzIzLaR^TgF z;47EoE0^Odm*Xp!>%r#TdZnO7>hY=YewW;>w-N==-JmcL}q{zrQ`^!rbl@ zV|M$pI5pw~HR2>S;*_WnOFRie4?zz@k2>@oY_JC#?7;@9l`sZ(zP29vdg$w+i@Dik z{re;_D<{feW?$yl*_ZhOYv-?4mcd*J=1MSEg1J)ocj4QeJrw&L|9%_aP1G@+?=rW_ zXK{LXb5eRIhKDyk)r$16zI9l&qR**ZFZn;NkMt)@}H*ZN%1X(B*h9>ysSsd&%E>$=~sX{bIi1(l2rx z{AcfO@^|vU&fUmqJHGB}^7r0?-Dg(t%EtYb{;7}Gk&v<~_X=sTeA zfWAWyGN%bKcMhZP(a|0ud+uqRxJ%6S6`kM9b}VC%=WVVrbA1KRtKfMRJdZt_vfNel z!ay%f^uksd@8#P>q5gjx&y; zz&uI059|Z8EO&V>Cd-|<7`3dheHC&SwXDhJ^Oaz#1XCrL*q7&#vmd%2x*xh9%yLdA z=ksz-Hy-0Q7j=CTW0vLY;-e#MlFitFiPa_a%V$5zIe=P}1iH8an+x&Xt~gK<|ihZyo+2D zYoit9u@!n0-}Vf9au#k@F7z(V;lEm-U)~%dQ{(qu^zpUHcegpK1z!BcRnGk;$F#cVyV9V^u z&3=Je0s8^UNZ^Jmm8hAMbZvG~5C_&&HjSwDLb z7aFR#=TAQVSM*hlsXRl0_o82E#)-QencmI+k%O5+9xcUpw*J_P*cE|4yiLje;Su&_ zpJe_xB>cTue(Z~ZF#8~D%KQ{OnNMa+t>ny1A5HzE(8lZT)`jLBEH z@5ukuPO`@*l-sABJT7tu{%%*{!yd7J5I*qtjKUcCdtBrU{N2v=4qf!f?9n1GaQ1!f zS}k(S&-MJ>?B{y?WevR`;xD;hLi{~OPlEWn*~j&Q4*&RDc>d1f^ZDyMe@F58{B@qs zU+4M!b)GNiiq@fudo09m{5m~d*bdL=U8uF2JhM;qcunmS&)%^9Hm zomv8_$dAmp9s$czXY#}eA*{?B={qEqkH)>O%HcY*Q4+w3_s!~e1RW{ z{InuJLe{B?5c@y_E6uuMsGiSV{9eTG zAJ0=6Qu-FHL*KxG*g0u^<2{^ptbbiU((u7kztXW-nx~N>i5#tpB(lUm1fs~X3ppao zAhHap_!$3DkwhoNIkY1~+G}a|CD8*_|9-51zAK$l`{*g#V;_qyY&K85|4P|zK03#_ zL+z8td3HYZaK`UcB+ul&=ulM2h`mg@&f(tYaBpPLhn>g1#x-B#nlrhEn3?tf?dUmu zJBRO6xCXoIVjlQ_p7k?dXRw|P;m1hyOh?bu`^(TX_6i8aMyBJDzi__{di9*x8Afmu z_>|C$YUb?KJ`V{2=u3MIbz9*CsMdvu{MRvyo)|1yP^~>S2(zctQ=hA z?BF8jq7*K7r*XMEjmzC>T<%Wea(5b+yVJPboyO(vG%lx}j}AG{=j=QmopYYg*?B%^ z=lPtS=c{(jQhUhw!QnJ6%gG9t8>U#y4J7_Z;j((?O?A%@T(%rsUZ0K2rP9IWNvwTU zxXjwu6fUDD%4Yi0I-4YG8utT()7ZQzjm^wiGZZ#g za?b&5t{euND?bLCD~pE5=1TfB95z?39Uhx2zC1iOR}}I4$Mf|gu$gtllS;tmVneMV zPGNJJr_DC@|Jks)JB`iVX>9IJV{>;Jo4eE4+?~ee?vKFcO@9wIW1EMuc|g|`HV@Xd zA=u2?Vfew?;WRcEgU!Wh|9?C8`v+ok^Ue%xK10>fv^rUt!e-(vm%?YgsK~A7TuEWAVKI zp;+8`J~6oSe9q4EiM5^Qb9SE3*?B%^=lQCgJ)acjH-TR<;_npROTWVV80%<=OR9;F zYS$BA_S9KUEL5*zp~0~?Yqz7$+HFU_eEsMdIHuNcJM&^9ONdwg7suQw-Y7qq=81~e z4)eq)AHomTf5Q*ff2VQ1&VGiS*y2d)_@1?_hp*Zf@S*v7WoZ zPxgx-)>c@apThEZPHS$s75rWZetW_1%i3PmJ!d~>1iGl{+`MT#J{jbmDb0FBPvJ#_iAncM7+g zAC=wgx1;i`?p0~rK0S@w`DxsKJdN9{(ztzk8n^TRhj80@K6vdspR@CPaM^i2XXp8x zo#%6Qp0C;m;Wjmr)V>N+EC;vOr*S(5Mxi_4wj91@LjGQtCsjON+s_`HV3e<)^}!8k z9opsl-;dk)Ewx58cTXsv{pxGs+vfbqZexlY^|j1fOKaeLKA;P&Ysf!q0M z+)nY-a&Q|QSM`HIeEo=+oHfg=SFT-;j=|IN0iHI0DF1(f+t}b?+*UkMxII|chQ#FL zs_=s~rrrLfo2`*h<~MrR6O4Wt3_!(|F4$XFpT=m#V2>;_Qj|*J1j5 zmE7&t8go6`UU%Mmy4%lwpcnsTZ*kr`x_gw`8}!fNZPQq<)pmjMI~#Vrfxl|LI{n+% z^;R!y<<)PItJ1%nf8;vtTj}4<(>*!q>vnyUe#e-Xxy{dJE$tfiA{D*!%OfoLj>i8H4%!4U5C?FV0Vl zVej29viI)Tb-VRKH|s9TmgpVtz7@}VZ-&0=kxS$GE4S#YpSR-$FU*XudEuAvLhbkC zj(ZBVlpG=#D*mY7&?Ck#SYMTrj~Y+PG5qU~F{+!;vnKWqZpfjZ>?2&CN1u-|%A??a zl>LR-7oxWA7$Y!=8p0&j8mK)5*82><@EHLP-ZgK8gfIN;H2in#YNML(wH!WCZm=hG z<7khj+H}upH^&z)gzwE-V%wo(Oz*Zxytj-on0F7^@9x&j)^0wJp4oU=uPf1O^7*tj z-5Zgsr;pZB-&;F$?+8tOFVNWIRcjWBvo)^sJZgJ-weWM(s1igA<+4U61TVHB5e4IV^v36VC8DhMcSnwkuVC!VS6>)k z@tu2&+WP#st7!vM6u-+SA@$2aZ`!mN~Cv_Tr^?hxKxZIog*{F*6 zit4?Q7{OA>{?Uv92pM0wZwWO(V$DT|jPic!yKS9@ua6qT z^{qy25?y*Nj6BiRva1X=epeWqp4bi!b#$CXPEy3UUwYlG_5xUE#LMPr`sfx->9XnB zjeW&VKqiGL8*BC}yfH$t@_5HMZD6cWXRNUCJ9lZ<_|AwJp}IWeX!1X`zIgnGOPuwU zelUKTmAQ|@0(5AB5lk*HLVXKpH)%IzdS3-OIY}MAVUY|8a-ZlTtBRQ4S9gP~iK%gd z8?2BZ52(LE`lE&95R0wqDEYwp8!WZwPH6pN$$P_$>VEdkX__oqmuUFkJ>yE?3VM)Qh^RrFu7FK%J9?=qYDW1kb9WXFl{Sf}Y9L;mc%I3>=wMX4NFY zk)AT1Mc>r8n;<`9+$}XzjGn1>OhJ*3(Tg;nt-Ap>ie5A&ab_AH(iQq%vEM!QBkSkbUZ@k;T@fJcfyiZ_Zc ziYHdJ;>r5S4o@a4o;1|Rkm5civ zhc%1CaC8fM2tsS9f1zal9k_#?G(mqqb|Rp^2m1SOglQ2M5oY~0D3ZnX6UU&=02`3hc{_?e>Bazb`7Day6bD) z<7?dGEbeg@?U_9Bcb!F_&Z1B3AE4SlEiPo^ozjg{(Tx^#1Kk-yGdebS{^e(;xw$8s zrg%>5Y-2O_e>dZu_b}dhuQMK+A#17f^XmR%u?3Z{b55#!eHwP1gFSL)ED61)oiQbK zrhXQ5+SQnnYG=N$)6Se7Gy>|J zRP*sT3pFof26%HWcw^!R&P@3=Ey1GkeeUVEDj?ZYgBFiAC5JV z4(QIbtA9S$oM%;_2j~e{az1>>#u{`fi7ufh0rcau*qsx1X*Xue8rgjv{rS4#OI`@p zTsVX${;mtbnhU|23&9%NKO@#Sx-lEwK!?;`*4Z?x@tDDTS$}4lcYQOPCVb~Nct;U_ zWh;7yud97#7{5Y$IqiPh15W#wkj0mf1#_pPU#8z#u~+P0X#W@5Sq1AZB16x_Dvi%d#7J zcYg_a5p!-FCg$uW=Ikcs+(^v15g$B+?oa1iWI9flyc@=-?GMSJv3iDom7gM3Phs?~ z+3@9`YWKv-3GGX0UrIam z$V{J#oZw^DetLfTox#Vfz3{5D_&8LLGx=DNnTP+s$H(SB!N&|f!Iv9`(ces756!=w zI>?5IlYhU$J+pme7GH+=$Si%y%)P?snwis&58l)qMvqKS7rwan$mihhBcDUhqCc6r zS(@+okdO2w%h1u` zmeIb9_T{uMH?n=MTlrjkW;b@ek$h~UlaFQcG0RS~?G9PiXY2T3yS?*owSY`NpN)4z{aLm?PD57HkQHmyqtpKmeKh(1ks9VF$2R}N`nc=8 zVf67*bpBGqmz)De&l$pFf7cwaa1K6U4nAQHzKPn;kQgpgABXy#EIwxX{ZG%wVe#~z zXx9;iZ5g_Vjm;efFSGQKdcvUj+uY+*=6geYTQnCRVrkB* z#_QBSRNZ?TxIsO9@ILYm-cc)5HQp}HNmcje?9_PK-zT;Ryd!3bndw;iX=qx6jxWMS z7Gooex#wlv^D^{n9{M$p_QkX>ru_!miQ&5D(dT*ec^>*T4?dosja6Kel?P{H5zol< z`9twClP_6#DgWVoiR{d#8#=ETMqe^{H`Kpg3BN~gnCke~Z^8d-_%%`Z zCr$J1Etr>B0kPSX(egEbBrfmG;l#cB>mFHe#aZt~^ z#tMig>X}VeWweQUW)tzFuIibXVX8p z{z?9kRCye8Df*W>bCav<;ZqZQ>L+&-@QFMv&1v6-yAD|5^@r7MH-*9!El0zE?y@g+^h(0C4A zO`@ylVF3Lb(4~Pq!gqP>aO_cjEq{rY_w^`=C9!xkq+fkxA#! zxFkc?{J$DqsYX|7(3P6QdhxgCnv?neWd2{x|CvM3WP)3!;cJ*qt%~<0cYSOuk3CNZ z^QpB?V*IshI=D2DOPcBN>l5f>W;~hYi)hb?NsX+UG`{MFVSH5C3F|uYN1c;uFB8tfh3r*3 zb3>hW=7&1%YCi}y&d5A8b&fJGSDjRgN5&c1Y`W;X8E?7iDG^NkNQyK$LjUwWoyzjB?{_+6Jv zm&`lk(2F^%qlC}A>s#%ypu68ZWK~7;n4dOUeYW3PsWmoVC+#g4XzF*{bw^{-9km7q@Hnil0UG;t`tJ`H-;9Wtu6k<~Ob}9}@ak zbmz0V_fqJ*NYhPSi*FgJ#aFyV|M|^zo@VZF3EO&9;P;EondfP`%+;*gXmMlP9wCir zv1!iN?E7_LFPH^?Ybyp%1a{l$}v%U z*-Fh^DWmpVD>QTFLz?Z~6EVFHMeIZTKA(B|ZQiJ5BnxeMJ^gryIXt4sZhHh;9udfL zF0z~}r-;ieU-UBMco{OhjB74Oo|hZdeJ2~W2TnG8T@mKjMa;Rc3;VUvnyuve8a%st zzh=G$ALsT`OJg6|Ktsd`HZeCV8EqWNe(yQR)QfC6^jyw-kE=7XMs{W9yU4eAp)h-Y z1fOn;n7yxvID1|+erF`IZDzh~^C5HLCe5ly7MZ=>nb)+8M6MjIBO|8uO4RJ^PRZ4C z2XdXufBqNCwH>)GLVoQsYQDchvyV;7RU%iVlh<>!pA#YOEkxd$z2!3WUlf_S^E5N} zJjTinL=0!2=C1S}hy9-;4*VQ39{VzhQ)ET#O89f73?#3#0^%xJDXy|AqgN4oUu6Yj z-?GYM-;zf1TNVfU_AQG;PKkcY;vn{3h@2O2uYvhXSAsE&6D66ylXT`U$&jk=lb5JD zaaF1|Fsa7!$EXdEiwv3DlsT_Jk|!Ddt{SUG)e3rQtm-7Sg7r0WvZ@s{WX@@F;_S$` zp(i6pL9estG+p)o-khcse-v*VzEn4myOF;gp3~Gt?neFw?ZeZ(YXx+FrreGHPs6qj z*CCB8KTmr`oiQcn!Q+AGN(DNC4uKa}@&By)iqf+rdWH@K(4DkS7>8-j&R0K%W+%67 zo==}LXeJgpWtjR$hCUcs^^Z?KUa0hYFx^AymRWRXkC$c3`qR>_&B>-49iMMiCg*4@H9r=Ky;=@*(*?^g9k4db>~h;iRytjr~hjUz?lggf!M$?`-m z^K)BUzmZ-aF;RZpyxbAadWI|I?mYZ-dTy>~s@CZ0b;ms;v_?03>^%L|-NY{{W*Cjk z#fA~8z7+ZWKtCGYcdBc44SM!P*F62yj)DIW4;iWdX!|q&Q}WY6|GD^@r`J6g-mrXH z;_|!iN}Rf=H}OE@X^9CdN)u}*+#UYj2OZ%bwOk$k%H6kx&%7cKKD6R134PzT#0$Uq zQ2K?is@$wcK2^%<7HRn&meioxEACYG3upQ@-B0`3|EzS)iA+zh{K{3*wyz-_diw-yUzj z?L)nA{FU)__wnAA>;3Vz(FQdUYGnP#8oqkwdUj1WoH3;X+5 zf8hEVhCdmm=E9!b4ZJtDj``rFll6{V{81_M6U1aapU*x*9$#Ngyrq~Lb{}zUe~sbq ztB$Yr61(^1R?jNYpSC??z0kA(-6VET?nwXHO`X79C>d7Zc$4A6Y;&-m= zIx)PGx%`Wm%b&|!{&{V$qF)2` z>1(M`yS|ipGOSxXFp~a_Oyy0@-N-Ssu3Fu7B6@HleVqj@?A1IZcbo-=&oY9vhg5qu zE+{?WeZD^Sd@WadK@Y)|6Z!v%{QpG$ekqz~ z*fygoyl8qwB1d$GU%0C-ao(IiC0sww3GWFkPFT-(g_j+?*s68s$SJ4hSW{YZtg44| z;647le<8d^Z|WA(?xo#JyI1-jW?p39{6y`_YV=@!xa4KlUmRGNcxv=jMtN*O;y244 zG^!`1=YliOM6H)Ck1;p3=LRFt#kg++^LOi+hoWp^{qeGjx@YaA6D+lc+qeEit4i5L z-AVEMiqYtpM_=1}4?a-FJ&!z%Zn3ApcP~Yr#F6`Ww{5>$U-i7QOOIYKkN0Occ;aj4 z@!r24PkhD5KK}2Gd+npqA-CRs%9BR5@WgYMQ6DVz#5-#>;*}g-KJ^D9(BReEmj41> z^~P8J_z`pq8VANw(Q%byJ2^CZ9gL#qYCNM9Js0SCAJ3~t&kxK%Pt$td7aq_@D>aAx zBrxM7S*>(2b`mlhs6{K?8zI$u5B*)GMqquZRZTt@Twf|DV-ul<(sVAk96iePUqkgQ z!v}J|Og*cNf&D}B?<`##GFKs6*QR9Z+AiiuIQiuD^iSoJoRcb_TnzmxpXBW1lboG= zlCzUfs&#<67+FTI}Om+G}X9kw@MYdo}iTwc(?^+-X;PJY8q8ClSBTm!T;6bd;Diwt#09 z@NCYa&Q6$)Rh){QIx<(|Ddhe5 zLT{{uXO_q+a`amE3h{w0fPK~^`Ze? zX0Bc8y`&lSC}_+W*FZm&zgBBb%oL_X-h_5=P{}vO{&0?*!E7Zj<|n7*tk%>kIlAGM zlA~Hzui8CnIjeo{R6F|;Iqhm6JS9i=u25&@Tc_mAdSLaP`PL~p^FB~V&W@avjFf!1 zUaiIXNExN%6Fb(*d>?AIZq(6Uhi)8erQQvir5g&PoLUPQrOpbYx~4&c^4-&rGj%nv zAxLd46jODz0U4XfSmiA21A}~n>r0GKLrKb(BcJ2{pH;q7==T)*J(Ye>Regjn_~gU# zol5&u+Usa%UEC1)o}49Lwf;@jpVWFQ_Xa1fYkoqiJ>Y{$_JJ1>Ss5jl7E!A*7O~WO z$b!j;ed)8Bx%cPPbzalVtH+9ry3V&V>pD7XP<84$PTo(>uj)DR5>?OnK!oGI6Lr~` zY`pbSE$-BA&e6hh=?l7?|BR~Nq-s3BNY!{+ULnVSg}Ozm9%HV2g&NK;BIdfEMQzvR z5nWP~u^L&E6s4x|67`t*T>G4=YZP%Ub9{a-Y`L7+^jyuHb*^TWQ&ZXUGtF*4Dry!# zB+SJh2>amsBJqVY?l;Y=oqOqDov6jF%P+7mr@iqSEuI+T)O2+D_91)G+tgzY@{H#J zY-%|s--{m==KaOot5`^CG-mNj(Z)7vUiKcrnm3VXjKzq(T5X$a+s})rKA3Gki`cHK zBkCS@&fAejcP{kiYUZI2gr586A#;IO*l)Rn`F4&lz1K$U@J8mku};prF=DsA8?gr0 zbBKA^n}>SNZszaBqR236)v}NJlqm1jihT~*p@YKNL)@s2%`j^F!}zh8MtT2C`?6<+ zx$j+JUNcshm;X^S|A>4qds(wzf1P?x!%XyjrV(tKX@ru;HGbQBxSpdIAzxLm8>s2z zD;Y;d>q^G&?HAz<$T;V6Wc)fhKz;7|=d^GRGR|4_j6LIdYE(~0%*1md?qXkwmiL6c z-(Pp;7Mfw`K*rSYsNd}u=D~fAjO{IFa_yN~{7GtbE0m1Um%UdHm2u8N?)CG- zGB%4BQ(HsEA4p+Qud}U(qK)2*sJr|uCF4tx@rqxx+FRbD7Pmiw43P1o5xc$7k+CV$ zGIr%^_M(00%Im^}Pv)Y%!p=P-VsF_@9qayx*}56|o*j`j$wITJTbR@Toi$TRzGXtK z@inT&afb8m(|X>0+IPI+??0Y6oT1Ks+=#K?_HvD zsq}o)lhKWjUW@5q!>-i>`QD)Wo9X+rA7d)V9CZJNLH9rIZ@7P}3?$1f`Z4ev?n(T= zo0y`P`gCh9IK|#nDxXw2=&lvI5MGP9pprG?mOr{oR*7X+RdT5eF|HAcE|rtTQfqQ@ ziL8z-v8tm>WQ|y2)g;xL@#Sibe0m-Fh2gVREz~Vna0!Q_Gl4bUy71 z+u$>NO{^(T8qRwx{e6>+KtJoz4@@#bF`s&mrM`CDUGbt9H^=j?OzJH+J);*??2E6y z*`*g=c0qj2bFGFy=7$dzMzE&>U8^9TuP|z372LPdC~v5Q-U)F}%!lsz(_;nSkrlBC zRz-4x42Yw_=%Wq4nrF$J-5~M}^%0}Sj;8%++9%RJ5t_*FX!j8pm-o5gnS^H&o=JG7 zVv-D+X=jh$(|M=sDi`f4u7-Yi5=>6u{u8)=c5DPMc#ozp2`|(;C1W9;AL99wdH&=f zH2S-I+|S4TeB96X$uvh=xn~B=vJx6Ap)m-JL1<);H10{<4~-$#PqQC{QQc2GdVp9| ztrsix=xuJ+k0rs_!8){yy>#+D(CdL-5A>=SE1Mte)pI)Uz+L60UBzhG{HTK7D(DSC zZ;1bA^CL)mkoGFtt3DGyoVi62Vzx|v&?jO>_K9ZiW$1U)o~;9{p`+bLOjzFMh2|V+ z%7LaFXj0=@*))4;=e@wIytJ#hGMnaqo(?!PYjcO8nK-wH7#EsC&@_~0)*aIBBVQ`- zQ`nJkEr|W)rZ8uh$#3d?-?`2^ zi5(njK9=9qHQa9in<91eCtEKvd0Y|8(u*NHE=6xj(VLOzjjEAl>(vO_N6=nMd+BG_ zD-FLkM6bXn-VGW|`r)yE7#{oKu^%1>;BkQVY`vID`&8PGrCp7=W?@6uRPH~O`%mTm zQ)$>F&|C%0;7J2KKsSO1z|+!6&|GEI#;Txs zvQgeJ8JY)tNHAUBdPio-8JaWj6q?yjKQ>iXdVmAW1)F0H1mAkm&^M=p;?XP zkFhwQc?>joa4kPr`yf^306biavc>%*Xzd*grTC03U|ZJeqbjb_G6Q|3hg$iuR*upFsPBVQ3yt z`*_-qqMaJ`XQesvn_+0q#_{a<2^DwH*iG#=3J+(3NJiqO5)k0_Jlw0 zeJ{~g6b)~>`RK%^y_>=_PpL{g8aXcU7Vpc^d0);cyf0@W@5@=1U#xqceJ4&$L-)SE zB;I!YA;XXV41j4td}*j_LYTeW;+~bAdfTGbxOab8Upe+Fe0AE-CdqeuCMLSCzD#dh zu_f-^W9uvT%#7!}^h?8kV4@M|pU7CxL~2$O!|VkYZ=1M;efQpCue2Gu_mNADYW`o_ zGtuyYKjnQsMJIHn?Bh+fcik?oPuoWud%mS&?&az0QdsL;7rBw&9IQnb($_UFK^ECI zldV75Hj}MCpVD^^!I*6Q$;QX1hr@?cN#*c7WWIfXcLDsjWtc09X3PU)}ZpB>Ns|TK2J@@(yMr8_P9uP zjFml>lo4ZbKNXt?r9VoZKA z&LpeEbgL>kO@?CAtWb2CoGhkUlar>T=44ezO<5yMt0sA@F2oE~&*J=3BT&k_>|@OL zTK_r2H|Z3kwk~Q^N25llK57ITqQtCG+M~2b^}HPRgrr_|_&rz6)MNxT8R{?9oNGCJ z)G5k^t8vcH**nt9o{)Lt^?WfR&Jli)JqZg|UzXq;U%h&sUZ|-#o8%|LWw)-8CVL7( zAM*&bybX@6G=Cw!W&*Xb^)lY#F4Xh>r1miOHhS|$=$@D>-l{Oh*^@GtcLC-&YtvKT z`;n7NUs%R|l%BtE{~YIYvFAhnS90Wk&8m)2qT1NIay<8NaLRcnSnBzz&MBX)&?~fNaoSTZ~hkRfK|U!|4sEY^X{_5KK9Mz-DSF`bqjko+Pt@HChsl#rQv%9d9g={pS?-~cWU9&z)}zI zENgrJt+zut#wrc3`=g{HLp~Ig;hd+l7M`egHi4bE*lSLFAj-bO4 z_z=;BIK`>OG6#ug&)v}MVDISkUVoRTzn7)IUz)Dj&WU^86sfl6GVZaTS}n0_Y&5ml z(ME967;uZYjo7WcevIL37-Q5nk-NsqXfHE@U1j*{vN-#OvRAeyyFJuoPdmIGT5e)~ z#->xL$+Azu=7%-wcDIywoGPt5TBN-9VQJm#cFFrrby@edxa3_AyAIc6ze7#7(5cB5 zgKNcxFF68S8<$&N5;8%BUn%r8mm>6&b*5$G=^Pb@V;lS-YM z?CNoM>4nr}i{>QbYnD92yBqcy{x0Th-AwI}y%xQfU0_g4MP98&pbuHCXHN3K2L2V8n?kiEtP^D>wl zQ{AP;`Wep^oDWc^>QC31v<2v6u~m^QmH|;hOjIH(VhM#4=Rdqk_k>j~O<^q(L79@5v_o})c zemB7HCitB!b>?CD`xuAqXB_r`;&-u{la-u0nT zU5c%jT?rO~OWoY3N9}P*44GulOXfuJ9wWog93g61JY$5xJ7wTA@y|^Ig>}bEMisEYRjj)c>#^fZSq{T*_P~u5rtMhmH?77L+>TDw_PebbbjsJ0BWuv9@~)gz z|C(pgzkGO}56=tWxtjly$+L=B0qq5}7t&rxKQejFJRaKfXwRpey@;}S$~++2b7{|` z9XnJ!1)G9klcMWW^E9Gr02w@$l`+=9^z(kFq%Z>NEEro+=O`Gd&aq4^Dv!CqjS*IP zk}(%`7VxHiq*We;H|iYAlSVSnGDN_!PR8w&mxoKn$Hoq8kF- zi56PCA46itR;4I_?*;HMR~pFPNHTt#DRWtiu5idH(R_=;*!&`MmLF%%@&n9SzFUn6 zqEpBqfDAZ{+r|sy_IzR7`JrZP{2k-_g7fkq6J`}$W%OFkj8v2!qubc078FxS6GVWpA z@!l6zEiY3Jx6yt(?RV0?@kN*AqweI7jj@PLWEJ(Ls^n-HijB5H(b00U7;R0a7Dt?7 zRY%KYjZl03j?#q~n~v}I8iCRYhCfE#Z#}i4VxjJl_+Lryz z?#yOqBj zz{cjsp*PcJv#^f#5!T>w$&CIrP_qVG2E`DW{hKrnITX;pBGtb%9=CGOj5r7VDzMnM zTLuL<87<_V8F7z!*`utV+r*r!7g$r5;9#EJT=w)=YwEIM-o~-yE#!03h%)aeQlH6B z)!)H-;`A?%{*6h`McfcBd+XA~X~9k5>!0XJ%qV*?yy&mKMCJK4;jzpAsC(wJzy91` z@y@sx<8ANZx6s2{^wEdjmUoQ~m%WI8A1uFyadA)1Z}qk>oE7&z`eWVGdmpqRfArhY zbN)Ace+J|!CAAZyI_9!!kZWxZ?;T32x&wN=UeyZRY3#jMX2lus6kn6X=ZFG$s{GAJ zX(UHlhS2fZx>Xx1l~a6Xp=Gem3!~c64f3Zh;fjklb2$mafBVa{8uHIB@6IqOi>x>U6$m4jM|V_R{Tvo>{9 zBA54E@V*N@m-kY%FMg)6Gl#XmA82MV^D)hrw0Nh~8b`e0yw5y7zwMB1Ge>Z6o13+} zv)<6mlV1`xb3)Y`Uc2O_NaDGsdA9qFXn1*SgDn?D^iJlRwmr95&pGC<_^gS{XM9;R zcQPMx76gPntyyl z*l#=|^pkl%`ws5gdGL^Zkl%{;Fu(F@%~pMBxs>~##oXH~E-;tx6}nZz9L%#c)BZMd zTY1L1cX(cjrpprMP(B(lb3cffZEr>GoR^q$dr2hBdp{Dq|HIsIJ98GdFlX_0=4i%U zx@GLMt=&=Eb2jrLnUBi6T-$Xfu|o>448JaofJ7(v5SQ;|tyQd0RwfJ4lOps4ym^~= z{2}H*+2H({Zj0OldjmVc&2n(FdJh<}7kuCz<=o3}gZmGWC%uh+GpCa^X#5x4xI@*U zCP-o>%O9N}s|4>EX3Q=WJIV@0kCKzcQP$+-cv&4AZ&gRf%NoWnYm(!1A&ySRTCWyi3)QPuhyFR(DRGvrD z!5-E|hmf_839B|wlT&7E)|3v`uRo@RZ;Wk7r04pDi=4U=ctL#NOM=CHqtkUIVul06 z48#bb(z0}2i5f`*HIgRQQzQ%0b)`Hb(4R-F3)a=;sk&0UVEkS2HL9+}T)%>)&*()J z`}7v(`l)&nbMKDSlN!LT9{f2N5o%H~+-RegKKNpc%VU@2UBks?qrjqEuxNDL8}m3d zB~@$bAU4Zqoz*H;ORA@i6b0w&)c)$;)EGfO=ZMxU{eOJQv=A1)f}8X z!Z+Hpa(r-jP~62kz@=3&TgpI(v;vQ*8bM|ar6SKoyNh=8_c51>KaBDQ^3OD%{Hz%p z;8k`WR*i3~j*UV8&~vU=JoI&`cjT!!Lh(%H?}}%{H}EGECB}hA)pgvn&LjO%>}FsN z*sc??pHWt2a+E~=*iRX}JIotNtoNy6JAab8XcM~BK>S%hYS`GWx?cG#;`b(WumRuR zM;t?*iw{Qss2xliqjwO0W$4Rb-_cL57|X6F5a;#~=O(F7_Kl)FyBRGcwF7K;jF6Ci7_pp~>9Xvv3lr8x)bx+Y| zIl4g`w8@Y_x1x$Z#$Z$QrR*ef2YoH&S*1K{B+nWt{YiA>PVP&s{>Z-LnX#>p_QCs( z53Q$V$|9>CNPjbA@psr7SOSi~10ytPSo*D&X4GGw(exe z23kKhZsq@3*wqg{kh}T>^@>uR|7YYR+4x}i`!oFYFmlMU^XA)lW`><(xBU=4$Hr$@8yK24K%wrcXO-I{fmN65Pw zkGrpx_kZjb@wUJ|J!gX}ZjHH1FMeTjyq#K8&Yo6XUYRuKt<%ike@`?2Fh$tk`noXx zu!h*aK$usy3%&iOXBtNqxZO+Rr0bo}LzeZz^u&O1riKe>x%goRmj zt1yrMvM@jVlCalojy7sbrTyTKguUvUQQLh>#9X~5YIlUAjid6NJ#`XS6929KRjd8r z2}7@O=fkgj`t!JEzxl9c-}oPz`RB(p+kI`+-u|i}H;9_+UX9x8PKHj_i~Z#H{6@aA zW*zeKxR9O8x~J7;{rhegvX$0dr%7Z&q{vQv4Q%Gby#RQ{&cpE>(TIXRm)+FbCs z7XBVNTizAP#$vy)XLYbX@9C(y^#?-FbF;6|4&>VGvJbv2!fw{1xfeWR&w7UZXwWq+ zJA}D?hp->073OL-6YJO!wO9WjYOc8mS$9P2;tN=7_aDOCdbO~RUnXqV4XjW5nlRmK z$fL^nABXvYFy$#xd(}nA`|_V9Reg*g}4zr9Gx6h0=Hh<4$Z=J^d=SOV$0kQ~2?at?suRA5*Imox= znO1u%x|@BC+pWbp%*EuzA8@??lxDv7q-M&0C8uRAn#Ycqa&OdbUC5qOU=60DJ6jSH-Cfi*6$#s$_0utv>+ z5MYe}Yt+0I_uq;&dOmYhR4pTbZ*u0U@R@rV%vEVD_7)C|={xrA(ME=O_n@BFafMm1 z(PgflE7I>G{H8NcB@`1n?;nhpwWxPzMoiD$jH$c5)Bp-MJng*Gbb?xo##|NrR!nPb zo09|9YQ$vhopLuhZ44b`&Pv4D-{hAn{*tU&i~&#G8|l1^J1RiNBs)rUCuFT$8oTt1wOzW`g?1x_z1* zKE%4m_jw-pzUee!uY6B4w{qVS)>&?&hOyFeo?-Yr+@p+pJBG+81%ZRw4bn zg>@%>p?kNmS6r;wJKv&4!oB7DT*unlogC{}OX}GQUj2aoflG;ph28oZ_uj@mJ}<0_ zHr56|BJ8#way{3se4qZG4IK-i=UM6t??UH3>}wynxL24D@6*i3*vD>82iWnDG`GLy zV3C6%Tel6lW^eODhs^B{f%9(G0D?CY^L&kKSVw&PGOh9Z^mXgATH^#aa%~po0~c$1 z+xH!`r@hbmWUgPum`jzH{QvWs^tWl2{}HWmbiTWB#Y|~#n<*Mc{?KJU05&|{shR&m z|9|&Q(fDnJ=@FMXBPjN|et6J4p5F(zx1clVP2+g)SmlH58?pBfvG+q@`Z93oxEF-p zs56%<54!gY^TGY#O=HwF8^N0WQ8V|2sCn`#@aU3=-44!tK>ca{qu7s{hX(0~o%@4`e#$87 zd+gCSPZzp5QH$R{R*ScPaL7D351f7qy*@~d?3>iQz}owNCQ>!8T>8I16%pKd%mwgetZCk{iK2OuXa148@&4YfOJ@%ky<>uV%&>Sbtz>S9#XJ$ooDnMo#!O~D zp%5;Gi^_(q0Jm>1nbqc&PzzB{7^z+a$ z&b{o88N&2pgEMc1_FuA&p67bM%jeIhe$V|b@7VDWM_`$PJ3<7i=S`>Kem z`JB*cA9oh>AhF&2vxp|-y|%x#UDx%^^k+g|kZX?3@p<|JT{0 z;A~C*;xWWOXGcu$lM(wmXk597*l0g{Fpd`bqh-|Se-lx*Z(hFNv3;G5Z1tS?57`U( z?PKge9rwIz1WK7>5~E(bo;f3v*e8p3hF3?a)z(w9ZJ>7B#Q0P!k9M_J4*TXXk7tvY zc&y(oH+>$T)$fv<+Q5~5<}E#fFY9x~!Fss~8&!V)N7(4yyNLlj!ny-I0Y4bmV$JMs z;_Du-Rl&W2J(^X)y~=y2yK}E{^}D)Pj~m<|UO=D9TX|NOTN=BWqv6Frce!N6=keA2 zhF|6El@*V0&n~z9+U3X#c`SKBvzOxM=i)=(-=o=odVyHVbGrRLzb$@AGkdp4+ha>} zhAnMtg|v69kY=$Z?UOBOuG=Ebt@lf_BO&bvI99hy`zP(vY+otWUI_N|Ua*(@Zks3Z z4d|C2`@%L?T~7NQ>;6n4P^ z{2sB7zfYRI_iFZP_C;Oy6n$-yjcu#pyO8GeR-REJ%=SCr-=)&@HcER|BmDXt@d<}# zqh`+7tvU4MpThV1pzAg6OHOg}Dbg-@4h$f#D|t$@J1>=X=d&u`frk5-|6GAR+(`S` z;M2Qc7YEmwGl&N*ayEA>{lR8-ybLX1W3LT1(9c=-a=)GM1b^B}-=^_DFL8#qO|u_Z z$Ti^GG~%xOi{Ur@U;G^Q1K)aQBKNQ~cZBK3ewVqEV?cIt8UCACY#sOR<#~#Z9s6A7 zS|!`1DcN=s8%^H|kDo&y`#ko8$Z*|qVV9796(NJ^Pk^H($g>1oIUwy;#)sHv&uqOL zo_2Zdf~D*|dn`I=qJtcruej_T93^{Q=FGh=d(E+G{M2jiyv1cQ*Tw$v2KskI_wd&_ zX4`qv@ej)Xbf6nQ=DUYJ&qC(blVH;=#FOOX2Y;>EOVIg}*ZJ+&!dwddGvMvQm*L+J zgxR)BvkSZV&qDY{e75G-!fsxUzS-#Exw5h49_YUZ89l-O0>sxmd;21nz4J|C-uuys zPW%FMcPd4Wz49-_DLFz;iRKVP5$kL~?>3-o-N=P|w<4c)j4h&XMyM&r+_4%T@D#rl z!>li|TO_Fw#;?A(YcqgF>+JyFVQ1ny^{mzCVC^u13C|)chEbFL)nf8 zy(yOPWPPBW7S;+yy_rtTr{2x7YqZ^$E(Z4&f zW9r|57;ErL$>oH{z6t&>z-Hfc_Q`bH*YUjwK29&fcJC#2iAX2+qJBi)Nxmx>58$1MMrefHBu%13Qr; zJiPyY>~S6TxDHzZYi%&MleV4Tl6DI?x}9SHUvh~<+P);sHLrpz-$(YpC062l+J4O< zu-Ez)|2;~xKSb{j?$OM`HuN@{!#>vJAMktnf8ry4jlSW-Tkj-3LoV*`Yqqu-{kRLg zCx2U8hTJvU6<)3t<}8jvbO9T%fBXgd^i$$=e3uub|HLN+#Eo8be$^N0djWjn=y;sIbDszB zIUedrYb;@(w1j*1(zjnApSgUWi%&S8n3HS0KcPO^hHUA#bt!cI7P@%;gLf#u;4yRa ziDN3@Q?IH)c+L6GDnF59-T;3U&u;{4x1H$VtPReZ>;3>9{Q(>UO9yOM`N_@`@wK(| z7r!t|`3i7KLc_XO!ENl*+KVqh=gj%=X`idH1)sWu{!Is$<$TR9IFIKbi`7@5qr|fL zyq`H3%`s03Auq7l^)j^K15e_>ciHUqZLj_h%|7WtVXnO$9XuIc;}0H~iQfOwW!oIh z`(1YD$x>o(<_>fVA3UIc_9~ve4WH~rUOUji;zz){76&)LrRR{neF zB}eCMH!(76ZPfnn_WWOx!#<4NJ)_wtvKM@m9OPE zexTzL;)yed%d6od z`^_0q?8$Q3?Zid$kTjM4TL%xvrPTkJ3)D&bJZ$Cn#23i1_ciE4ra3%Y#Wo2rZ{>dW z_lmkzTs)xHN(NR?5HG0THj|ewOkw{6=#|$i%-7yWPSBeFd11bOnox5Ek*V8U^t{Re z7=KQ>O!iwd*gr>B$2`PE=%MFQBh)}_PQ9*{y4`^9`2fG8V)1u>g)e-DK0c2PzJMQi z!NCjD;=9{IALbxeuwwxG@h@gOcG`-4sW@BFvjf|01t0J?w!9vBqf2i1bAp@xKB?&| zi@{jrYj=Yc*MlwGvlrd-{?28azjK+`xxItKbG$TX9uMCBk$HhpVy^_agkO39|1|LY z)ek{))MH!3hlOD5wrX?kH6Z#Ed6yBU3_ zzVD`9wS&06^;vA@_vrfB#5rfbdzSEZnzRCF01NbB2VzY!8U(rZg@ek-5KCgv1(!{>iy9DS%qkBI-jf31u z>eEE(m(K+mTH8Gim9`^2mNAzju zN@(0ftoI`EJ~mfy6S@Qzz!&=g{_|(-@1%FZ2J!^_kG=A3=(`x*0Xu)X2%f(|Y(p$o z@B+I2q_X!Mdlq)napR51?B(eGIap6jSNs^U_#Mc>O`Qy$^_)=u8#>Z5A)b>a6y;TYiT#`7w z(GB*Vtne4TvEZ9$G`bu>!gG9#-F^(dKB?jbp?rc`>(&_$b;`-ePatXo%=a*sihEW*>68f-9+R#b%2AsN)YB-J^*Wq48RD37b=R&b%zI>JxPxuf6a*;rIh}Zz`!_Cg+i&1$62G{DSYZXeui0fO|G07@e(@s4_o6xG zEMhS96+fTyYsGx;q-{zR8DH#j^30vhF4KJ~*S+H8&(zwSJ~;l(0-I;Ogq+~n3}{q% z2yM27yxQnnE@nXiv=axC(z3kUl;h4CpL z2Nu0cu2-2vHu#D5H=yAS{0_B;6?|7Q%dux;tIE&8Tl%8nW3zo0-|q#3&;!-C9kcLr zXCq^HnD%pa2{PFUmg47>k8|d~lIN>&Dzldu%S$c6q^6+i69%>CUO?=#bm#oIe zZ3izpIwj*fM{ornXIskmQ8S)F4b_XTQwJOHZ+8B}U=6sk^(`^r+w64&DOJcs`8E~* z_hPqizl=}8w|VZSw)-FC{Nz0O*xssBuq*8ALGY(_2matjt^+G1zG@rKdT@vGHSm8i zvN_)IYvy+4*DCNQ>!9;Au$QA3dvW|4de(++tvE}?ti*q>)8|?+YzyDXGmpiu6)V5S z@4aAA2{pcH9Ll$E$G7K$lhg54Dpzlz9b2?pen^}%oBq557T|yKzKBo#EoW*NdE_M} zHvP_nKOE~$rWOx29B+fy;E#o0-->_DZKsZOJ9ZYN1_jn1dx$YE>gKIBwTFe!iyyPz zhQ_C$i9B+r#5T`IhOarbDs0lL><9mlV=gCF0<%qY%JFAg(VGtRX!{$CZ^v@XRoK7- zi@>pER@XK6Xh419L67u7`Td7k{Ay1wSZvtTYt zih1lc=aQr0dwTzsID_YHITt%Zmu~{UsEgVw?}5*+GN0sW{PPCk*x|IBscroqbmkoV z2){Ltgzw}mTRF6e8qfFGt2(8fa|Lq!5BLmUPr!bhJPVnsdlsR$C;U5DxQHu zS-z2T52LqyhV^rN34VB(>(5xSDwZ!~JNz&pWE}e~9(XT$n(o<$j9UmCJu>c=Jp52m z{PpaEXi?}8UTVoVY!R=AxjjN32bs@KWcV@O0q=6QbB&Md2tNO~(^@YfQ&u9|R_@{X z4ZH^&oPsJi4r{Kh@iX5_Mcf(l%br+1HVr;DVo~tt&c!dc0l)9< z_!+98gMHXHh1fT@Gxm@(;=nGO)GbH8-;8gUy|zkt=(cA3ar@ZIcUiGA^ySbe{Z#5| zYVOvz(AM{!W*2cD?33lVe38s<*7prLa#u6F2%o@RE^Ca5=d0wdR-T{yW9FgfnPD#W z?cc(tev5bgPBABaLDr}9+4ehpf%~P%P%-9dY)A-!$5&s@G+Qnvx)K5%d0vDE## z05U(Gy≠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�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 z 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

9GOs|}$_5Anm#ls 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

q4#%dB7{d{&PYu54p*!!S>l9FU0nIt_nH% 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

v6PU+_RKB2@Y-#iNH1T`~BtmI6gk}v~I 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 diff --git a/benchmarks/guest/revm_snailtracer/Cargo.toml b/benchmarks/guest/revm_snailtracer/Cargo.toml index 6f0a5176b5..3b3d965d6b 100644 --- a/benchmarks/guest/revm_snailtracer/Cargo.toml +++ b/benchmarks/guest/revm_snailtracer/Cargo.toml @@ -5,6 +5,8 @@ edition.workspace = true [dependencies] openvm = { workspace = true, features = ["std"] } +openvm-algebra-guest.workspace = true +openvm-ecc-guest.workspace = true revm = { version = "18.0.0", default-features = false } # revm does not re-export this feature so we enable it here derive_more = { version = "1.0.0", default-features = false, features = [ diff --git a/benchmarks/guest/revm_snailtracer/elf/openvm-revm-snailtracer.elf b/benchmarks/guest/revm_snailtracer/elf/openvm-revm-snailtracer.elf index 26e1d4c515e34f21cec7717d7e9bfd4051b69160..1b437754cfd8fcdd68d67b0fd97dd9afbbe1fff1 100755 GIT binary patch literal 1949776 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 diff --git a/benchmarks/guest/keccak256_iter/elf/openvm-keccak256-iter-program.elf b/benchmarks/guest/keccak256_iter/elf/openvm-keccak256-iter-program.elf index 5a5f8cbb966e54aa6f910055b8b86b11c51fbe67..f3f9a8808e17106850e14a6e19163a72c9f1aa27 100755 GIT binary patch literal 60092 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 diff --git a/crates/vm/src/arch/vm.rs b/crates/vm/src/arch/vm.rs index 4df65ae2a7..46feb53399 100644 --- a/crates/vm/src/arch/vm.rs +++ b/crates/vm/src/arch/vm.rs @@ -722,9 +722,6 @@ where system_records: SystemRecords>, record_arenas: Vec, ) -> Result, GenerationError> { - #[cfg(all(feature = "metrics", not(feature = "cuda")))] - let mut current_trace_heights = - self.get_trace_heights_from_arenas(&system_records, &record_arenas); // main tracegen call: let ctx = self .chip_complex @@ -782,8 +779,6 @@ where }); } } - #[cfg(all(feature = "metrics", not(feature = "cuda")))] - self.finalize_metrics(&mut current_trace_heights); #[cfg(feature = "stark-debug")] self.debug_proving_ctx(&ctx); @@ -1379,76 +1374,3 @@ where let global_airs = air_inv.into_airs().collect_vec(); vm.engine.debug(&global_airs, ctx); } - -#[cfg(all(feature = "metrics", not(feature = "cuda")))] -mod vm_metrics { - use std::iter::zip; - - use metrics::counter; - - use super::*; - use crate::arch::Arena; - - impl VirtualMachine - where - E: StarkEngine, - VB: VmBuilder, - { - /// Assumed that `record_arenas` has length equal to number of AIRs. - /// - /// Best effort calculation of the used trace heights per chip without padding to powers of - /// two. This is best effort because some periphery chips may not have record arenas to - /// instrument. This function includes the constant trace heights, and the used height of - /// the program trace. It does not include the memory access adapter trace heights, - /// which is included in `SystemChipComplex::finalize_trace_heights`. - pub(crate) fn get_trace_heights_from_arenas( - &self, - system_records: &SystemRecords>, - record_arenas: &[VB::RecordArena], - ) -> Vec { - let num_airs = self.num_airs(); - assert_eq!(num_airs, record_arenas.len()); - let mut heights: Vec = record_arenas - .iter() - .map(|arena| arena.current_trace_height()) - .collect(); - // If there are any constant trace heights, set them - for (pk, height) in zip(&self.pk.per_air, &mut heights) { - if let Some(constant_height) = pk.preprocessed_data.as_ref().map(|pd| pd.height()) { - *height = constant_height; - } - } - // Program chip used height - heights[PROGRAM_AIR_ID] = system_records.filtered_exec_frequencies.len(); - - heights - } - - /// Update used trace heights after tracegen is done (primarily updating memory-related - /// metrics) and then emit the final metrics. - pub(crate) fn finalize_metrics(&self, heights: &mut [usize]) { - self.chip_complex.system.finalize_trace_heights(heights); - let mut main_cells_used = 0usize; - let mut total_cells_used = 0usize; - for (pk, height) in zip(&self.pk.per_air, heights.iter()) { - let width = &pk.vk.params.width; - main_cells_used += width.main_width() * *height; - total_cells_used += width.total_width( - <::EF as BasedVectorSpace>>::DIMENSION, - ) * *height; - } - tracing::debug!(?heights); - tracing::info!(main_cells_used, total_cells_used); - counter!("main_cells_used").absolute(main_cells_used as u64); - counter!("total_cells_used").absolute(total_cells_used as u64); - - #[cfg(feature = "perf-metrics")] - { - for (name, value) in zip(self.air_names(), heights) { - let labels = [("air_name", name.to_string())]; - counter!("rows_used", &labels).absolute(*value as u64); - } - } - } - } -} diff --git a/crates/vm/src/system/cuda/mod.rs b/crates/vm/src/system/cuda/mod.rs index ce1736d158..65b3c5c4a7 100644 --- a/crates/vm/src/system/cuda/mod.rs +++ b/crates/vm/src/system/cuda/mod.rs @@ -127,39 +127,4 @@ impl SystemChipComplex for SystemChipInventoryGPU (!top_tree.is_empty()).then_some(top_tree.as_slice()) }) } - - #[cfg(feature = "metrics")] - fn finalize_trace_heights(&self, heights: &mut [usize]) { - use crate::{arch::BOUNDARY_AIR_ID, system::cuda::boundary::BoundaryFields}; - - let boundary_idx = BOUNDARY_AIR_ID; - let mut access_adapter_offset = boundary_idx + 1; - match self.memory_inventory.boundary.fields { - BoundaryFields::Volatile(_) => { - let boundary_height = self.memory_inventory.boundary.num_records.unwrap_or(0); - heights[boundary_idx] = boundary_height; - } - BoundaryFields::Persistent(ref boundary) => { - let boundary_height = 2 * self.memory_inventory.boundary.num_records.unwrap_or(0); - heights[boundary_idx] = boundary_height; - heights[boundary_idx + 1] = self.memory_inventory.unpadded_merkle_height; - access_adapter_offset += 1; - - // Poseidon2Periphery height also varies based on memory, so set it now even though - // it's not a system chip: - let poseidon_height = boundary - .poseidon2_buffer - .current_trace_height - .load(std::sync::atomic::Ordering::Relaxed); - // We know the chip insertion index, which starts from *the end* of the the AIR - // ordering - const POSEIDON2_INSERTION_IDX: usize = 1; - let poseidon_idx = heights.len() - 1 - POSEIDON2_INSERTION_IDX; - heights[poseidon_idx] = poseidon_height; - } - } - let access_heights = &self.memory_inventory.access_adapters.unpadded_heights; - heights[access_adapter_offset..access_adapter_offset + access_heights.len()] - .copy_from_slice(access_heights); - } } diff --git a/crates/vm/src/system/cuda/poseidon2.rs b/crates/vm/src/system/cuda/poseidon2.rs index dbd873e788..3e943acaf2 100644 --- a/crates/vm/src/system/cuda/poseidon2.rs +++ b/crates/vm/src/system/cuda/poseidon2.rs @@ -19,8 +19,6 @@ use crate::cuda_abi::poseidon2; pub struct SharedBuffer { pub buffer: Arc>, pub idx: Arc>, - #[cfg(feature = "metrics")] - pub(crate) current_trace_height: Arc, } pub struct Poseidon2ChipGPU { @@ -46,8 +44,6 @@ impl Poseidon2ChipGPU { SharedBuffer { buffer: self.records.clone(), idx: self.idx.clone(), - #[cfg(feature = "metrics")] - current_trace_height: self.current_trace_height.clone(), } } diff --git a/crates/vm/src/system/mod.rs b/crates/vm/src/system/mod.rs index b4f89b9b61..df96ff42ee 100644 --- a/crates/vm/src/system/mod.rs +++ b/crates/vm/src/system/mod.rs @@ -93,18 +93,6 @@ pub trait SystemChipComplex { /// [`generate_proving_ctx`](Self::generate_proving_ctx) and may return `None` if called before /// that. fn memory_top_tree(&self) -> Option<&[[PB::Val; CHUNK]]>; - - /// This function is only used for metric collection purposes and custom implementations are - /// free to ignore it. - /// - /// Since system chips (primarily memory) will only have all information needed to compute the - /// true used trace heights after `generate_proving_ctx` is called, this method will be called - /// after `generate_proving_ctx` on the trace `heights` of all AIRs (including non-system AIRs) - /// in the AIR ID order. - /// - /// The default implementation does nothing. - #[cfg(feature = "metrics")] - fn finalize_trace_heights(&self, _heights: &mut [usize]) {} } /// Trait meant to be implemented on a SystemChipComplex. @@ -428,40 +416,6 @@ where MemoryInterface::Volatile { .. } => None, } } - - #[cfg(feature = "metrics")] - fn finalize_trace_heights(&self, heights: &mut [usize]) { - use crate::{arch::BOUNDARY_AIR_ID, system::memory::interface::MemoryInterface}; - - let boundary_idx = BOUNDARY_AIR_ID; - let mut access_adapter_offset = boundary_idx + 1; - match &self.memory_controller.interface_chip { - MemoryInterface::Volatile { boundary_chip } => { - let boundary_height = boundary_chip - .final_memory - .as_ref() - .map(|m| m.len()) - .unwrap_or(0); - heights[boundary_idx] = boundary_height; - } - MemoryInterface::Persistent { - boundary_chip, - merkle_chip, - .. - } => { - let boundary_height = 2 * boundary_chip.touched_labels.len(); - heights[boundary_idx] = boundary_height; - heights[boundary_idx + 1] = merkle_chip.current_height; - access_adapter_offset += 1; - } - } - let access_heights = &self - .memory_controller - .access_adapter_inventory - .trace_heights; - heights[access_adapter_offset..access_adapter_offset + access_heights.len()] - .copy_from_slice(access_heights); - } } #[derive(Clone)] diff --git a/examples/keccak/Cargo.toml b/examples/keccak/Cargo.toml index 74f15e6234..88a3e144a3 100644 --- a/examples/keccak/Cargo.toml +++ b/examples/keccak/Cargo.toml @@ -7,11 +7,13 @@ edition = "2021" members = [] [dependencies] +tiny-keccak = { git = "https://github.com/openvm-org/tiny-keccak", branch = "perf/custom-xorin-keccak", features = ["keccak"] } +hex-literal = "1.1.0" + +[target.'cfg(target_os = "zkvm")'.dependencies] openvm = { git = "https://github.com/openvm-org/openvm.git", features = [ "std", ] } -openvm-keccak256 = { git = "https://github.com/openvm-org/openvm.git" } -hex = { version = "0.4.3" } [features] default = [] @@ -19,4 +21,4 @@ default = [] # remove this if copying example outside of monorepo [patch."https://github.com/openvm-org/openvm.git"] openvm = { path = "../../crates/toolchain/openvm" } -openvm-keccak256 = { path = "../../guest-libs/keccak256" } +openvm-keccak256-guest = { path = "../../extensions/keccak256/guest" } diff --git a/examples/keccak/openvm.toml b/examples/keccak/openvm.toml index 93998f52a3..90e80fa97f 100644 --- a/examples/keccak/openvm.toml +++ b/examples/keccak/openvm.toml @@ -1,4 +1,4 @@ [app_vm_config.rv32i] [app_vm_config.rv32m] [app_vm_config.io] -[app_vm_config.keccak] +[app_vm_config.keccak] \ No newline at end of file diff --git a/examples/keccak/src/main.rs b/examples/keccak/src/main.rs index cc12a2e859..ff3b586daf 100644 --- a/examples/keccak/src/main.rs +++ b/examples/keccak/src/main.rs @@ -1,30 +1,168 @@ // [!region imports] -use core::hint::black_box; - -use hex::FromHex; +use hex_literal::hex; +#[cfg(target_os = "zkvm")] use openvm as _; -use openvm_keccak256::keccak256; +use tiny_keccak::{Hasher, Keccak}; // [!endregion imports] // [!region main] + +/// Vector of test cases for Keccak-256 hash function. +/// Each test case consists of (input_bytes, expected_hash_result). +const KECCAK_TEST_CASES: &[(&[u8], [u8; 32])] = &[ + ( + b"", + hex!("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"), + ), + ( + b"hello world", + hex!("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad"), + ), + ( + &hex!("91376f5774419e518ced240cfb7ce0fbb835d80c609f7db3736a8474381c23cb7dde504e009f8d9656351a22ff18172046cbd80e074ee99ac7cc95f0daf32c35d4a0b41932d6efee42790e0298fa3d8f0d362f79008e9bd9989b355470e714aebd0d5936bbbfcc11d4"), + hex!("bcd603061b992b3c881b2418a691c4a77606f4e9ff4fb1e57bd64118430f9e64"), + ), + ( + &hex!("2e8b467f65bb7a367e17b0f1ea54e20cfcd5f581bb7a9e937b1d48e289cb8477a4aa081031666529e3659782945bdadc3524e069b1e50da71caa04e681e986869325ba36e2fd"), + hex!("f5856263b398ac1b9682363fd87f3f47d96c213d9a27ca84f42ccdc69c04b600"), + ), + ( + &hex!("8c7e1ae8d32e176dbb4c25dfbfa4edf2c642"), + hex!("1d673221b76ffb970ef7abec781e7e8678ef7535b95ffc9dd7e7b9ebb472e155"), + ), + ( + &hex!("1f483a587db0a0152083be135d4418a3387a9d223a3329b8044ac6b97dfb754718cec558ab6cf6fb0f46b344442326b7d639ec7b81e0eac95340bb3e96860368961a82d98f35eb893dd848da52e7a7cc3d970657592071da1ea70ce99c995d2bdf4f9f764f2ca277705843f0800e7a97"), + hex!("b83494263c50b8444ae444d436ed9a30065ce869342d9c3a5fe319ed323b3ac6"), + ), + ( + &hex!("a2d386e126c7"), + hex!("d94338cbf5a5505c6079f381bc9c5f895a93911ea906d84ccf1c876ae24f31f9"), + ), + ( + &hex!("590307764a0f2294f82301735054adc163cd1ee5c582fc3d173f54ba7c5f6dbe72aa30ce8007657d7bafb9d083e80574b3d3a69469ed43cf61cdd8bb2d2762a0861affae378c052dad637707f420cfbc1dbbf7"), + hex!("03c2229015d2693d8448b1761c04ae80cee6e11e046ae2d3ebeb4291531abf8d"), + ), + ( + &hex!("8b0d83e9b5d1770faa1f17195a9c8fa74bd5109e50ba74f752d1a40189b0f2d7dd8abe3b0c9648f67f413f584ccea0f69fa2346460dd97a28acb1d0ba8618398817c76be800cebce0d701595ac0b5f422775c504"), + hex!("3390695701398af69128d9d8fc4a8a1c43c340e65b673a896dd40360c4c816f9"), + ), + ( + &hex!("2f80c45d979eb3f7"), + hex!("12292d148143f86721726f656ae496b95d113dd669f78e202ac2cca9bca8304c"), + ), + ( + &hex!("d43a4df4bf208321971cabff80d9ae2bf619bfac98004b729e6415a481bf70089a39ad5019f21d4bec3dd8f2598cf9fccc6a5fcd5ac79d516d1fdbb123b4bda96021130b44fde0633c50ae85c376db29b551edb16d5fac451b0cbea06356f80661b011f3904e3c62ea9f8ad3773da5"), + hex!("1cf0c4b5afb89f146d9b09d878d4afc00aa8a56037ff8602071ce989f3e58695"), + ), + ( + &hex!("72ba3368324d809df9a9d97e251e00a6dfb3e70fca2892e63ee3df6d5b08e01e63c9db23296586bf9a3ee78a68"), + hex!("7d79f8ed4fb4cd728d9ca383536f81f025d8e246504f5e9d53cbfa05006abad1"), + ), + ( + &hex!("6b0bd4f931c1d8861f5ccea87642791dfa74fe8544175fb63451ee0adcfcc13f3040ab8f7525892fcd7da15ce23da3b2f21a6e55dca0765daeb2407acff87c03b7d1a13d3acd77390d6055fde3eeeeef381c04cd41d5c83bd3ef7e494a8391de3a6d8f1f1941e9fb217bd8"), + hex!("9550d5094b85b0d1f01209b71c338114a09aad20cb33b7d444c31c1e1473716b"), + ), + ( + &hex!("494c7a2642a3d6b3943605cbc30140aaf622f3a34338fdff183e5ef6bc41389d6f095056760dd144f0a14a2b21ca5b487cab0a3ea23a86"), + hex!("a03c900c3ebf6c4037f8351b1a144720a04a105e067707c5cbac79aade25fb56"), + ), + ( + &hex!("4d91a527e6bd5ea378c5ba9516b8b34cc99dd7c52ed03b54623f1ce4ca6d886b37c95dde605fb7ab8274f21488229bd9169e760703747ae9d23699f77db579f1ad31ef8dbdb57cce0de326db8bbc6550a5cc5fe09c8486ef24ef023b4f2f8aa32e390ede54eb3d6123fbc08a8e591d6cad80c3fe52821da10136cce9"), + hex!("5b47a38b57bfe74950e59da3c1918d94293d4250b8991a3324ec42160b3d402c"), + ), + ( + &hex!("9e60df2407f3057680e332f32cafb32e195aa13c275c1571c4877da2f26b00ed139f808310e9e4a800fd950ddbb3dc"), + hex!("52474f4d926fa0599845e38ab4a9529737bd42f0d46784d5f584c7ab063c18f7"), + ), + ( + &hex!("712b9a6afe96f461e31092ffe38d74288cb1424e876a3592bca03dbc9c3a57"), + hex!("3b0a1d9106e06e1a3de754fc90583862e82ec92f81edf261e5a12108d46a69bf"), + ), + ( + &hex!("9feff865dad6dc06e095d330f363178b71e56fd1b86fcac2249aed2a84a82fa4d596d6f4142b71ec034f543d69bdbc47404b8146203b215ce3bce1a8c4"), + hex!("63fe4b8bd1e0d823b5d7b6ab722c5b5dfcfe472da792e8974a38cc81fdd53777"), + ), + ( + &hex!("0213643f8bbb0aa1e9528f7f117c050cbd9d8709cc3672850363c0ddef5be2001c"), + hex!("4bf5a88bb8954c539620033214e1b1e34306639417c7b7683a4aa825f5c004bb"), + ), + ( + &hex!("a79eca9f55b0f13c533ca91e71495f65f642ab91224bbe664ff59b1b3362ba51"), + hex!("a710b4cbdc60423e7ab1773d6731ceb3ea0157cff6df39a1b8c1410acf8c0075"), + ), + ( + &hex!("4cc8abc63b48a1a653c3a52801394db7ae608249d67006329fd259ec203a1ed836f384ed88b6dff310948c9f29f7c240fc49d705299e8aec3239e35c998c2befbd8997e59c8581"), + hex!("ba972e77578147700ba7539b89e53fc40bdd9893b3cccef0bcf1a2f7ef65c4bc"), + ), + ( + &hex!("f66cd0cd9a55d6c2046dd7df0cf6496a876d165d0de8f639140cafa2155abc2426cc55258e0db47938d262472558f4eb63e98cfd3725296dc1de7c57d9d148194c2ac3b9d0c267814578bfc66c46da093bc59f132b41076865659d548ed3"), + hex!("54ea328ab976e794e653b82d5cfbc0f20305e6e33a97bf4e8764d06bbed2753c"), + ), + ( + &hex!("fe7eee2bcc4071ab2bcd801d805cc082bc0d7781713941e06e4819e09748a5692c945f3b3b0b632b50bce1"), + hex!("57a655827352ff95ce21082515add7f6fb0f51b457e338a1cfd7a5912a2c30a0"), + ), + ( + &hex!("2cf005de4865b6321e8995f38825353e64e34f7ecaedd9b5f39ee41067e9e63f38618985d015b1fb89be1140e249ac92d0b8f273"), + hex!("0ba80a1c481facdec27552c2d8382467fb97f864a6c915e2882045a995dd452a"), + ), + ( + &hex!("edee326b959740e515dd8a0ed9ced665d782b50bda2af634189def905b59d3a9ac635e1d96c670eaf28675b0071db0d86131088fad00a0b80da10dd1259692d17dc9af43a5e3f40185e88776be68bdf2a3ddeb7c9726e5bde8e4d14bcf6e991d142047"), + hex!("295d1a5a86a4ea5cc3d7c5860c3fa6069374a610e5f9cda1e643b4f01e957752"), + ), + ( + &hex!("8703f576434a9ec235904e106991aa447b1d4e715fd1fe2e5aa2e3aa950291d624d97420dc9eec10d76cdf23ae189c995760f339c20bbb5e"), + hex!("7ebb76c5e9669e9bceb867560682a653e600e116af83777ed6e71fb4b28f1b48"), + ), + ( + &hex!("e8dffb080d61e60561a5f2e44db8e65c4ab134f3283411b374da96cc6a94408871de72d5b8e39aae83c81fa7b31027a8da64915010eb688a72f5f605aab2b77d67baa1f90056281e92fa3031108e2061a1b110f4d0d62ff91f956f977cc504a68337d7b01d2ff6caadc57e"), + hex!("e85f50155c3abf4d0cabe2a62d9af075c163600fb0c12e1bc3d004ce4d25bd13"), + ), + ( + &hex!("5de9ef34a6f71cbe1780ff29816f7b26f574f0ea5d6adeaff6d9c78e08440ce9c3a5597e31693e0d2a89b1b84bf3b8c8cda9c13b7abb3bf8b2cf0cb3410d9df1e6fd4765546ce8f4e1d821aa7253fdf044437a65eca5d7393716"), + hex!("3de18f83084b4ced8b0a261f80225b52cf9c27950dff768bb2e0ab1a8f015fe2"), + ), + ( + &hex!("8278f74015c08ea408c53446d4e9364eddc6c37cf2a03b54df9a9122095eef5f3812d03afa4f7c52ba937f73968e3074ed5ddd7a6439916b8c4a6bb821896852bbe1430be00f9da2244d980834696f949232facdc0e214f52f308267"), + hex!("1f60d8c4bfd1cf910fd7e5a5ecd3e2996aee20d7c40c1f6d43225d832b937b0a"), + ), + ( + &hex!("65063a451690b64af8901e2cc0414abbe0e92c6789c721577bf975b4cd58771086ad8f6e2899bf45e7f23e76a299accae8782dd1f47fa449d7cc7f06ced46bd7bde7ce5f61e594485a6489edd5dc96ad79c5425960297b028f9669fb827a"), + hex!("30d3360dbb001c115a287da3eac988b1a925b2ab607ba1e1f909a64eef1c90e4"), + ), + ( + &hex!("41c7813c97"), + hex!("be714f64489c82a8fc1008db96c096bd72b74ca142f8682c19aa5d7b8d575d31"), + ), + ( + &hex!("7a9fa65269a9af8e994849b91c58c9ad2b4da115a96514a02200d931c359e4a26ff54c3937ed061a1e58e7cf2c1b1dd72c42049081fe28dd59caaf09447c403c167265d5e121e367d41fc87c3c1c9a81c582ee826cfe"), + hex!("41ca49571619a8b82cd7bff0e317493eb70d8dfaee994702c3c1ad80b794c863"), + ), + ( + &hex!("d8b70735a52277d4e361a68b884abf5118756c5685dd0af29e8274b94ab37bc126dbb8e97735cf"), + hex!("a43a2a0321aac66ed239bc40518f9947ae4480bc70d4b1c23bbe5d1a367e1cd1"), + ), + ( + &hex!("190dcb4311e6c20f303e939bea29a0f42856735821743d92579d1d2e41b0925304e08be11e978aa760993083bf546a31d8e1877b405f14f3bdcae789ed5d639e51ac846ab2390ae9552e733a7233"), + hex!("f5392ee04880a0bd1336f30ee79b5c014a90728bf29f422dabb4ae6bc972f30b"), + ), +]; pub fn main() { - let test_vectors = [ - ( - "", - "C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", - ), - ( - "CC", - "EEAD6DBFC7340A56CAEDC044696A168870549A6A7F6F56961E84A54BD9970B8A", - ), - ]; - for (input, expected_output) in test_vectors.iter() { - let input = Vec::from_hex(input).unwrap(); - let expected_output = Vec::from_hex(expected_output).unwrap(); - let output = keccak256(&black_box(input)); - if output != *expected_output { - panic!(); - } + // Run the keccak tests for all targets + for &(input, expected) in KECCAK_TEST_CASES { + let mut output = [0u8; 32]; + + // Using tiny-keccak API + let mut hasher = Keccak::v256(); + hasher.update(input); + hasher.finalize(&mut output); + + assert_eq!(output, expected); } + + println!( + "All {} keccak256 test cases passed!", + KECCAK_TEST_CASES.len() + ); } // [!endregion main] diff --git a/examples/new-keccak/Cargo.toml b/examples/new-keccak/Cargo.toml deleted file mode 100644 index 09cd7f5de5..0000000000 --- a/examples/new-keccak/Cargo.toml +++ /dev/null @@ -1,24 +0,0 @@ -[package] -name = "new-keccak-example" -version = "0.0.0" -edition = "2021" - -[workspace] -members = [] - -[dependencies] -tiny-keccak = { git = "https://github.com/openvm-org/tiny-keccak", branch = "perf/custom-xorin-keccak", features = ["keccak"] } -hex-literal = "1.1.0" - -[target.'cfg(target_os = "zkvm")'.dependencies] -openvm = { git = "https://github.com/openvm-org/openvm.git", features = [ - "std", -] } - -[features] -default = [] - -# remove this if copying example outside of monorepo -[patch."https://github.com/openvm-org/openvm.git"] -openvm = { path = "../../crates/toolchain/openvm" } -openvm-new-keccak256-guest = { path = "../../extensions/new-keccak256/guest" } diff --git a/examples/new-keccak/openvm.toml b/examples/new-keccak/openvm.toml deleted file mode 100644 index 61b2a0a406..0000000000 --- a/examples/new-keccak/openvm.toml +++ /dev/null @@ -1,4 +0,0 @@ -[app_vm_config.rv32i] -[app_vm_config.rv32m] -[app_vm_config.io] -[app_vm_config.new_keccak] \ No newline at end of file diff --git a/examples/new-keccak/src/main.rs b/examples/new-keccak/src/main.rs deleted file mode 100644 index ff3b586daf..0000000000 --- a/examples/new-keccak/src/main.rs +++ /dev/null @@ -1,168 +0,0 @@ -// [!region imports] -use hex_literal::hex; -#[cfg(target_os = "zkvm")] -use openvm as _; -use tiny_keccak::{Hasher, Keccak}; -// [!endregion imports] - -// [!region main] - -/// Vector of test cases for Keccak-256 hash function. -/// Each test case consists of (input_bytes, expected_hash_result). -const KECCAK_TEST_CASES: &[(&[u8], [u8; 32])] = &[ - ( - b"", - hex!("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"), - ), - ( - b"hello world", - hex!("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad"), - ), - ( - &hex!("91376f5774419e518ced240cfb7ce0fbb835d80c609f7db3736a8474381c23cb7dde504e009f8d9656351a22ff18172046cbd80e074ee99ac7cc95f0daf32c35d4a0b41932d6efee42790e0298fa3d8f0d362f79008e9bd9989b355470e714aebd0d5936bbbfcc11d4"), - hex!("bcd603061b992b3c881b2418a691c4a77606f4e9ff4fb1e57bd64118430f9e64"), - ), - ( - &hex!("2e8b467f65bb7a367e17b0f1ea54e20cfcd5f581bb7a9e937b1d48e289cb8477a4aa081031666529e3659782945bdadc3524e069b1e50da71caa04e681e986869325ba36e2fd"), - hex!("f5856263b398ac1b9682363fd87f3f47d96c213d9a27ca84f42ccdc69c04b600"), - ), - ( - &hex!("8c7e1ae8d32e176dbb4c25dfbfa4edf2c642"), - hex!("1d673221b76ffb970ef7abec781e7e8678ef7535b95ffc9dd7e7b9ebb472e155"), - ), - ( - &hex!("1f483a587db0a0152083be135d4418a3387a9d223a3329b8044ac6b97dfb754718cec558ab6cf6fb0f46b344442326b7d639ec7b81e0eac95340bb3e96860368961a82d98f35eb893dd848da52e7a7cc3d970657592071da1ea70ce99c995d2bdf4f9f764f2ca277705843f0800e7a97"), - hex!("b83494263c50b8444ae444d436ed9a30065ce869342d9c3a5fe319ed323b3ac6"), - ), - ( - &hex!("a2d386e126c7"), - hex!("d94338cbf5a5505c6079f381bc9c5f895a93911ea906d84ccf1c876ae24f31f9"), - ), - ( - &hex!("590307764a0f2294f82301735054adc163cd1ee5c582fc3d173f54ba7c5f6dbe72aa30ce8007657d7bafb9d083e80574b3d3a69469ed43cf61cdd8bb2d2762a0861affae378c052dad637707f420cfbc1dbbf7"), - hex!("03c2229015d2693d8448b1761c04ae80cee6e11e046ae2d3ebeb4291531abf8d"), - ), - ( - &hex!("8b0d83e9b5d1770faa1f17195a9c8fa74bd5109e50ba74f752d1a40189b0f2d7dd8abe3b0c9648f67f413f584ccea0f69fa2346460dd97a28acb1d0ba8618398817c76be800cebce0d701595ac0b5f422775c504"), - hex!("3390695701398af69128d9d8fc4a8a1c43c340e65b673a896dd40360c4c816f9"), - ), - ( - &hex!("2f80c45d979eb3f7"), - hex!("12292d148143f86721726f656ae496b95d113dd669f78e202ac2cca9bca8304c"), - ), - ( - &hex!("d43a4df4bf208321971cabff80d9ae2bf619bfac98004b729e6415a481bf70089a39ad5019f21d4bec3dd8f2598cf9fccc6a5fcd5ac79d516d1fdbb123b4bda96021130b44fde0633c50ae85c376db29b551edb16d5fac451b0cbea06356f80661b011f3904e3c62ea9f8ad3773da5"), - hex!("1cf0c4b5afb89f146d9b09d878d4afc00aa8a56037ff8602071ce989f3e58695"), - ), - ( - &hex!("72ba3368324d809df9a9d97e251e00a6dfb3e70fca2892e63ee3df6d5b08e01e63c9db23296586bf9a3ee78a68"), - hex!("7d79f8ed4fb4cd728d9ca383536f81f025d8e246504f5e9d53cbfa05006abad1"), - ), - ( - &hex!("6b0bd4f931c1d8861f5ccea87642791dfa74fe8544175fb63451ee0adcfcc13f3040ab8f7525892fcd7da15ce23da3b2f21a6e55dca0765daeb2407acff87c03b7d1a13d3acd77390d6055fde3eeeeef381c04cd41d5c83bd3ef7e494a8391de3a6d8f1f1941e9fb217bd8"), - hex!("9550d5094b85b0d1f01209b71c338114a09aad20cb33b7d444c31c1e1473716b"), - ), - ( - &hex!("494c7a2642a3d6b3943605cbc30140aaf622f3a34338fdff183e5ef6bc41389d6f095056760dd144f0a14a2b21ca5b487cab0a3ea23a86"), - hex!("a03c900c3ebf6c4037f8351b1a144720a04a105e067707c5cbac79aade25fb56"), - ), - ( - &hex!("4d91a527e6bd5ea378c5ba9516b8b34cc99dd7c52ed03b54623f1ce4ca6d886b37c95dde605fb7ab8274f21488229bd9169e760703747ae9d23699f77db579f1ad31ef8dbdb57cce0de326db8bbc6550a5cc5fe09c8486ef24ef023b4f2f8aa32e390ede54eb3d6123fbc08a8e591d6cad80c3fe52821da10136cce9"), - hex!("5b47a38b57bfe74950e59da3c1918d94293d4250b8991a3324ec42160b3d402c"), - ), - ( - &hex!("9e60df2407f3057680e332f32cafb32e195aa13c275c1571c4877da2f26b00ed139f808310e9e4a800fd950ddbb3dc"), - hex!("52474f4d926fa0599845e38ab4a9529737bd42f0d46784d5f584c7ab063c18f7"), - ), - ( - &hex!("712b9a6afe96f461e31092ffe38d74288cb1424e876a3592bca03dbc9c3a57"), - hex!("3b0a1d9106e06e1a3de754fc90583862e82ec92f81edf261e5a12108d46a69bf"), - ), - ( - &hex!("9feff865dad6dc06e095d330f363178b71e56fd1b86fcac2249aed2a84a82fa4d596d6f4142b71ec034f543d69bdbc47404b8146203b215ce3bce1a8c4"), - hex!("63fe4b8bd1e0d823b5d7b6ab722c5b5dfcfe472da792e8974a38cc81fdd53777"), - ), - ( - &hex!("0213643f8bbb0aa1e9528f7f117c050cbd9d8709cc3672850363c0ddef5be2001c"), - hex!("4bf5a88bb8954c539620033214e1b1e34306639417c7b7683a4aa825f5c004bb"), - ), - ( - &hex!("a79eca9f55b0f13c533ca91e71495f65f642ab91224bbe664ff59b1b3362ba51"), - hex!("a710b4cbdc60423e7ab1773d6731ceb3ea0157cff6df39a1b8c1410acf8c0075"), - ), - ( - &hex!("4cc8abc63b48a1a653c3a52801394db7ae608249d67006329fd259ec203a1ed836f384ed88b6dff310948c9f29f7c240fc49d705299e8aec3239e35c998c2befbd8997e59c8581"), - hex!("ba972e77578147700ba7539b89e53fc40bdd9893b3cccef0bcf1a2f7ef65c4bc"), - ), - ( - &hex!("f66cd0cd9a55d6c2046dd7df0cf6496a876d165d0de8f639140cafa2155abc2426cc55258e0db47938d262472558f4eb63e98cfd3725296dc1de7c57d9d148194c2ac3b9d0c267814578bfc66c46da093bc59f132b41076865659d548ed3"), - hex!("54ea328ab976e794e653b82d5cfbc0f20305e6e33a97bf4e8764d06bbed2753c"), - ), - ( - &hex!("fe7eee2bcc4071ab2bcd801d805cc082bc0d7781713941e06e4819e09748a5692c945f3b3b0b632b50bce1"), - hex!("57a655827352ff95ce21082515add7f6fb0f51b457e338a1cfd7a5912a2c30a0"), - ), - ( - &hex!("2cf005de4865b6321e8995f38825353e64e34f7ecaedd9b5f39ee41067e9e63f38618985d015b1fb89be1140e249ac92d0b8f273"), - hex!("0ba80a1c481facdec27552c2d8382467fb97f864a6c915e2882045a995dd452a"), - ), - ( - &hex!("edee326b959740e515dd8a0ed9ced665d782b50bda2af634189def905b59d3a9ac635e1d96c670eaf28675b0071db0d86131088fad00a0b80da10dd1259692d17dc9af43a5e3f40185e88776be68bdf2a3ddeb7c9726e5bde8e4d14bcf6e991d142047"), - hex!("295d1a5a86a4ea5cc3d7c5860c3fa6069374a610e5f9cda1e643b4f01e957752"), - ), - ( - &hex!("8703f576434a9ec235904e106991aa447b1d4e715fd1fe2e5aa2e3aa950291d624d97420dc9eec10d76cdf23ae189c995760f339c20bbb5e"), - hex!("7ebb76c5e9669e9bceb867560682a653e600e116af83777ed6e71fb4b28f1b48"), - ), - ( - &hex!("e8dffb080d61e60561a5f2e44db8e65c4ab134f3283411b374da96cc6a94408871de72d5b8e39aae83c81fa7b31027a8da64915010eb688a72f5f605aab2b77d67baa1f90056281e92fa3031108e2061a1b110f4d0d62ff91f956f977cc504a68337d7b01d2ff6caadc57e"), - hex!("e85f50155c3abf4d0cabe2a62d9af075c163600fb0c12e1bc3d004ce4d25bd13"), - ), - ( - &hex!("5de9ef34a6f71cbe1780ff29816f7b26f574f0ea5d6adeaff6d9c78e08440ce9c3a5597e31693e0d2a89b1b84bf3b8c8cda9c13b7abb3bf8b2cf0cb3410d9df1e6fd4765546ce8f4e1d821aa7253fdf044437a65eca5d7393716"), - hex!("3de18f83084b4ced8b0a261f80225b52cf9c27950dff768bb2e0ab1a8f015fe2"), - ), - ( - &hex!("8278f74015c08ea408c53446d4e9364eddc6c37cf2a03b54df9a9122095eef5f3812d03afa4f7c52ba937f73968e3074ed5ddd7a6439916b8c4a6bb821896852bbe1430be00f9da2244d980834696f949232facdc0e214f52f308267"), - hex!("1f60d8c4bfd1cf910fd7e5a5ecd3e2996aee20d7c40c1f6d43225d832b937b0a"), - ), - ( - &hex!("65063a451690b64af8901e2cc0414abbe0e92c6789c721577bf975b4cd58771086ad8f6e2899bf45e7f23e76a299accae8782dd1f47fa449d7cc7f06ced46bd7bde7ce5f61e594485a6489edd5dc96ad79c5425960297b028f9669fb827a"), - hex!("30d3360dbb001c115a287da3eac988b1a925b2ab607ba1e1f909a64eef1c90e4"), - ), - ( - &hex!("41c7813c97"), - hex!("be714f64489c82a8fc1008db96c096bd72b74ca142f8682c19aa5d7b8d575d31"), - ), - ( - &hex!("7a9fa65269a9af8e994849b91c58c9ad2b4da115a96514a02200d931c359e4a26ff54c3937ed061a1e58e7cf2c1b1dd72c42049081fe28dd59caaf09447c403c167265d5e121e367d41fc87c3c1c9a81c582ee826cfe"), - hex!("41ca49571619a8b82cd7bff0e317493eb70d8dfaee994702c3c1ad80b794c863"), - ), - ( - &hex!("d8b70735a52277d4e361a68b884abf5118756c5685dd0af29e8274b94ab37bc126dbb8e97735cf"), - hex!("a43a2a0321aac66ed239bc40518f9947ae4480bc70d4b1c23bbe5d1a367e1cd1"), - ), - ( - &hex!("190dcb4311e6c20f303e939bea29a0f42856735821743d92579d1d2e41b0925304e08be11e978aa760993083bf546a31d8e1877b405f14f3bdcae789ed5d639e51ac846ab2390ae9552e733a7233"), - hex!("f5392ee04880a0bd1336f30ee79b5c014a90728bf29f422dabb4ae6bc972f30b"), - ), -]; -pub fn main() { - // Run the keccak tests for all targets - for &(input, expected) in KECCAK_TEST_CASES { - let mut output = [0u8; 32]; - - // Using tiny-keccak API - let mut hasher = Keccak::v256(); - hasher.update(input); - hasher.finalize(&mut output); - - assert_eq!(output, expected); - } - - println!( - "All {} keccak256 test cases passed!", - KECCAK_TEST_CASES.len() - ); -} -// [!endregion main] diff --git a/extensions/keccak256/circuit/Cargo.toml b/extensions/keccak256/circuit/Cargo.toml index 5255d7138f..c5725d7a1c 100644 --- a/extensions/keccak256/circuit/Cargo.toml +++ b/extensions/keccak256/circuit/Cargo.toml @@ -30,13 +30,10 @@ derive-new.workspace = true derive_more = { workspace = true, features = ["from"] } rand.workspace = true serde.workspace = true -cfg-if.workspace = true [dev-dependencies] openvm-stark-sdk = { workspace = true, features = ["cpu-backend"] } openvm-circuit = { workspace = true, features = ["test-utils"] } -hex.workspace = true -tokio = { workspace = true, features = ["full"] } [build-dependencies] openvm-cuda-builder = { workspace = true, optional = true } @@ -63,7 +60,5 @@ touchemall = [ "cuda", "openvm-circuit/touchemall", "openvm-circuit-primitives/touchemall", - "openvm-cuda-backend/touchemall", - "openvm-cuda-common/touchemall", "openvm-rv32im-circuit/touchemall", ] diff --git a/extensions/keccak256/circuit/README.md b/extensions/keccak256/circuit/README.md deleted file mode 100644 index ade42bb08a..0000000000 --- a/extensions/keccak256/circuit/README.md +++ /dev/null @@ -1,36 +0,0 @@ -# Spec - -## Review of `keccak-f` AIR - -The `keccak-air` from Plonky3 is an AIR that does one `keccak-f[1600]` permutation every `NUM_ROUNDS = 24` rows (henceforth we call this the `keccak-f` AIR to avoid confusion). All rows in the round have the same `preimage`, which is the starting state prior to the permutation, represented as `5 * 5 * 4` `u16` limbs (the state in the spec is `5 * 5` `u64`s, but since the AIR uses a 31-bit field, the `u64` is broken into `u16`s). - -The `keccak-f` permutation copies `preimage` to `A` and mutates `A` over rounds. The mutations are materialized in the `keccak-f` AIR in `A'` and `A''` arrays. While the bits of `A'` are materialized, the bits of `preimage` and `A` are never materialized (there is an implicit bit composition in the constraints). - -## Review of `keccak256` sponge - -The `keccak256` hash function on variable length byte arrays works by two main steps: - -1. Padding the input to a multiple of `RATE_IN_BYTES = 136` bytes. The padding can be described as appending a `1` bit, then multiple `0`s, and another `1` to get the length to a multiple of `RATE_IN_BYTES`. In bytes this means appending `0x01`, then multiples `0x00` and a final `0x80` because the keccak-f state conversion uses [little-endian](https://keccak.team/keccak_bits_and_bytes.html). -2. Absorb the padded input `RATE_IN_BYTES` bytes at a time into the state, and then applying the `keccak-f` permutation. Here absorb means to XOR the input with the state. - -The output is "squeezed" by reading the first `32` bytes of the state. The combination of absorb and squeeze is what makes the `keccak256` hash function a sponge construction. - -## VM AIR - -In our VM's `keccak256` hasher AIR, the AIR will add columns and constraints to the `keccak-f` AIR to make it stateful, meaning that the transition of `preimage` between different `keccak-f` permutations will be constrained based on the instructions received. - -We add `KECCAK_RATE_U16S = 136 / 2` columns for the input to be absorbed. -It seems to handle padding in a single AIR row there is no alternate to having `136` columns with bits to represent whether it is padding byte or not. - -The absorb step must correctly constrain that the input bytes are XORed with the end-state in the last round and equals the next permutation's `preimage`. The end-state is accessed via `a_prime_prime_prime()`. Note that both `preimage` and `a_prime_prime_prime()` are represented as `u16`s. However we can only XOR at most 8-bit limbs. Without changing the `keccak-f` AIR itself, we can use a trick: -if we already have a 16-bit limb `x` and we also provide a 8-bit limb `hi = x >> 8`, assuming `x` and `hi` have been range checked, we can use the expression `lo = x - hi * 256` for the low byte. If `lo` is range checked to `8`-bits, this constrains a valid byte decomposition of `x` into `hi, lo`. This means in terms of trace cells, it is equivalent to provide `x, hi` versus `hi, lo`. - -The constraints are in [air.rs](./src/air.rs). Notably we use an XOR lookup table for byte XORs in the absorb step. - -## Future Improvement - -Currently most of the columns in `KeccakOpcodeCols` and `KeccakSpongeCols` only change every `NUM_ROUNDS = 24` rows for a `keccak-f` block. It will likely save more cells if this part is split out into a separate AIR which communicates with the `keccak-f` AIR via interactions. However this requires some care in matching up rows via timestamps, so it is not currently implemented. - -# References - -- Official Keccak [spec summary](https://keccak.team/keccak_specs_summary.html) diff --git a/extensions/keccak256/circuit/build.rs b/extensions/keccak256/circuit/build.rs index d8d021c8b9..7832536924 100644 --- a/extensions/keccak256/circuit/build.rs +++ b/extensions/keccak256/circuit/build.rs @@ -8,12 +8,15 @@ fn main() { return; // Skip CUDA compilation } - let builder: CudaBuilder = CudaBuilder::new() + let builder = CudaBuilder::new() .include_from_dep("DEP_CUDA_COMMON_INCLUDE") .include("../../../crates/circuits/primitives/cuda/include") .include("../../../crates/vm/cuda/include") .include("cuda/include") - .library_name("tracegen_gpu_keccak") + .watch("cuda") + .watch("../../../crates/circuits/primitives/cuda") + .watch("../../../crates/vm/cuda") + .library_name("tracegen_gpu_keccak256") .files_from_glob("cuda/src/*.cu"); builder.emit_link_directives(); diff --git a/extensions/keccak256/circuit/cuda/include/keccak256/columns.cuh b/extensions/keccak256/circuit/cuda/include/keccak256/columns.cuh deleted file mode 100644 index b744a16210..0000000000 --- a/extensions/keccak256/circuit/cuda/include/keccak256/columns.cuh +++ /dev/null @@ -1,140 +0,0 @@ -#pragma once - -#include "primitives/constants.h" -#include "system/memory/offline_checker.cuh" - -using namespace riscv; -using namespace keccak256; -using namespace p3_keccak_air; - -template struct KeccakPermCols { - /// The `i`th value is set to 1 if we are in the `i`th round, otherwise 0. - T step_flags[NUM_ROUNDS]; - - /// A register which indicates if a row should be exported, i.e. included in a multiset equality - /// argument. Should be 1 only for certain rows which are final steps, i.e. with - /// `step_flags[23] = 1`. - T _export; - - /// Permutation inputs, stored in y-major order. - T preimage[5][5][U64_LIMBS]; - - T a[5][5][U64_LIMBS]; - - /// ```ignore - /// C[x] = xor(A[x, 0], A[x, 1], A[x, 2], A[x, 3], A[x, 4]) - /// ``` - T c[5][64]; - - /// ```ignore - /// C'[x, z] = xor(C[x, z], C[x - 1, z], C[x + 1, z - 1]) - /// ``` - T c_prime[5][64]; - - // Note: D is inlined, not stored in the witness. - /// ```ignore - /// A'[x, y] = xor(A[x, y], D[x]) - /// = xor(A[x, y], C[x - 1], ROT(C[x + 1], 1)) - /// ``` - T a_prime[5][5][64]; - - /// ```ignore - /// A''[x, y] = xor(B[x, y], andn(B[x + 1, y], B[x + 2, y])). - /// ``` - T a_prime_prime[5][5][U64_LIMBS]; - - /// The bits of `A''[0, 0]`. - T a_prime_prime_0_0_bits[64]; - - /// ```ignore - /// A'''[0, 0, z] = A''[0, 0, z] ^ RC[k, z] - /// ``` - T a_prime_prime_prime_0_0_limbs[U64_LIMBS]; -}; - -template struct KeccakSpongeCols { - /// Only used on first row of a round to determine whether the state - /// prior to absorb should be reset to all 0s. - /// Constrained to be zero if not first round. - T is_new_start; - - /// Whether the current byte is a padding byte. - /// If this row represents a full input block, this should contain all 0s. - T is_padding_byte[KECCAK_RATE_BYTES]; - - /// The block being absorbed, which may contain input bytes and padding bytes. - T block_bytes[KECCAK_RATE_BYTES]; - - /// For each of the first [KECCAK_RATE_U16S] `u16` limbs in the state, - /// the most significant byte of the limb. - /// Here `state` is the postimage state if last round and the preimage - /// state if first round. It can be junk if not first or last round. - T state_hi[KECCAK_RATE_U16S]; -}; - -template struct KeccakInstructionCols { - /// Program counter - T pc; - /// True for all rows that are part of opcode execution. - /// False on dummy rows only used to pad the height. - T is_enabled; - /// Is enabled and first round of block. Used to lower constraint degree. - /// is_enabled * inner.step_flags\[0\] - T is_enabled_first_round; - /// The starting timestamp to use for memory access in this row. - /// A single row will do multiple memory accesses. - T start_timestamp; - /// Pointer to address space 1 `dst` register - T dst_ptr; - /// Pointer to address space 1 `src` register - T src_ptr; - /// Pointer to address space 1 `len` register - T len_ptr; - // Register values - /// dst <- \[dst_ptr:4\]_1 - T dst[RV32_REGISTER_NUM_LIMBS]; - /// src <- \[src_ptr:4\]_1 - /// We store src_limbs\[i\] = \[src_ptr + i + 1\]_1 and src = u32(\[src_ptr:4\]_1) from which - /// \[src_ptr\]_1 can be recovered by linear combination. - /// We do this because `src` needs to be incremented between keccak-f permutations. - T src_limbs[RV32_REGISTER_NUM_LIMBS - 1]; - T src; - /// len <- \[len_ptr:4\]_1 - /// We store len_limbs\[i\] = \[len_ptr + i + 1\]_1 and remaining_len = u32(\[len_ptr:4\]_1) - /// from which \[len_ptr\]_1 can be recovered by linear combination. - /// We do this because `remaining_len` needs to be decremented between keccak-f permutations. - T len_limbs[RV32_REGISTER_NUM_LIMBS - 1]; - /// The remaining length of the unpadded input, in bytes. - /// If `is_new_start` is true and `is_enabled` is true, this must be equal to `u32(len)`. - T remaining_len; -}; - -template struct KeccakMemoryCols { - MemoryReadAuxCols register_aux[KECCAK_REGISTER_READS]; - MemoryReadAuxCols absorb_reads[KECCAK_ABSORB_READS]; - MemoryWriteAuxCols digest_writes[KECCAK_DIGEST_WRITES]; - /// The input bytes are batch read in blocks of private constant KECCAK_WORD_SIZE bytes. - /// However if the input length is not a multiple of KECCAK_WORD_SIZE, we read into - /// `partial_block` more bytes than we need. On the other hand `block_bytes` expects - /// only the partial block of bytes and then the correctly padded bytes. - /// We will select between `partial_block` and `block_bytes` for what to read from memory. - /// We never read a full padding block, so the first byte is always ok. - T partial_block[KECCAK_WORD_SIZE - 1]; -}; - -template struct KeccakVmCols { - /// Columns for keccak-f permutation - KeccakPermCols inner; - /// Columns for sponge and padding - KeccakSpongeCols sponge; - /// Columns for instruction interface and register access - KeccakInstructionCols instruction; - /// Auxiliary columns for offline memory checking - KeccakMemoryCols mem_oc; -}; - -constexpr size_t NUM_KECCAK_VM_COLS = sizeof(KeccakVmCols); -constexpr size_t NUM_KECCAK_PERM_COLS = sizeof(KeccakPermCols); -constexpr size_t NUM_KECCAK_SPONGE_COLS = sizeof(KeccakSpongeCols); -constexpr size_t NUM_KECCAK_INSTRUCTION_COLS = sizeof(KeccakInstructionCols); -constexpr size_t NUM_KECCAK_MEMORY_COLS = sizeof(KeccakMemoryCols); diff --git a/extensions/keccak256/circuit/cuda/include/keccak256/keccakvm.cuh b/extensions/keccak256/circuit/cuda/include/keccak256/keccakvm.cuh deleted file mode 100644 index 3149424bbf..0000000000 --- a/extensions/keccak256/circuit/cuda/include/keccak256/keccakvm.cuh +++ /dev/null @@ -1,46 +0,0 @@ -#pragma once - -#include "primitives/constants.h" -#include "primitives/utils.cuh" -#include "system/memory/offline_checker.cuh" - -using namespace keccak256; - -__device__ __forceinline__ size_t num_keccak_f(size_t byte_len) { - return (byte_len / KECCAK_RATE_BYTES) + 1; -} - -struct KeccakVmRecordHeader { - uint32_t from_pc; - uint32_t timestamp; - uint32_t rd_ptr; - uint32_t rs1_ptr; - uint32_t rs2_ptr; - uint32_t dst; - uint32_t src; - uint32_t len; - - MemoryReadAuxRecord register_reads_aux[KECCAK_REGISTER_READS]; - MemoryWriteBytesAuxRecord write_aux[KECCAK_DIGEST_WRITES]; -}; - -struct KeccakVmRecordMut { - KeccakVmRecordHeader header; - uint8_t *input_ptr; - MemoryReadAuxRecord *read_aux_ptr; - - __device__ __host__ __forceinline__ KeccakVmRecordMut(uint8_t *record_buf) { - header = *reinterpret_cast(record_buf); - input_ptr = record_buf + sizeof(KeccakVmRecordHeader); - auto read_aux_offset = next_multiple_of(read_len(), alignof(MemoryReadAuxRecord)); - read_aux_ptr = reinterpret_cast(input_ptr + read_aux_offset); - } - - __device__ __host__ __forceinline__ size_t num_reads() const { - return d_div_ceil(size_t(header.len), KECCAK_WORD_SIZE); - } - - __device__ __host__ __forceinline__ size_t read_len() const { - return num_reads() * KECCAK_WORD_SIZE; - } -}; diff --git a/extensions/keccak256/circuit/cuda/include/keccak256/p3_generation.cuh b/extensions/keccak256/circuit/cuda/include/keccak256/p3_generation.cuh deleted file mode 100644 index b5764af979..0000000000 --- a/extensions/keccak256/circuit/cuda/include/keccak256/p3_generation.cuh +++ /dev/null @@ -1,92 +0,0 @@ -#pragma once - -#include "columns.cuh" -#include "primitives/trace_access.h" -#include "primitives/utils.cuh" - -using namespace keccak256; - -__device__ __constant__ uint8_t R[5][5] = { - {0, 36, 3, 41, 18}, - {1, 44, 10, 45, 2}, - {62, 6, 43, 15, 61}, - {28, 55, 25, 21, 56}, - {27, 20, 39, 8, 14}, -}; - -__device__ __constant__ uint64_t RC[NUM_ROUNDS] = { - 0x0000000000000001ULL, 0x0000000000008082ULL, 0x800000000000808AULL, 0x8000000080008000ULL, - 0x000000000000808BULL, 0x0000000080000001ULL, 0x8000000080008081ULL, 0x8000000000008009ULL, - 0x000000000000008AULL, 0x0000000000000088ULL, 0x0000000080008009ULL, 0x000000008000000AULL, - 0x000000008000808BULL, 0x800000000000008BULL, 0x8000000000008089ULL, 0x8000000000008003ULL, - 0x8000000000008002ULL, 0x8000000000000080ULL, 0x000000000000800AULL, 0x800000008000000AULL, - 0x8000000080008081ULL, 0x8000000000008080ULL, 0x0000000080000001ULL, 0x8000000080008008ULL -}; - -__device__ __noinline__ void generate_trace_row_for_round( - RowSlice row, - uint32_t round, - uint64_t current_state[5][5] -) { - COL_FILL_ZERO(row, KeccakPermCols, step_flags); - COL_WRITE_VALUE(row, KeccakPermCols, step_flags[round], 1); - - // Populate C[x] = xor(A[x, 0], A[x, 1], A[x, 2], A[x, 3], A[x, 4]). - uint64_t state_c[5]; -#pragma unroll 5 - for (auto x = 0; x < 5; x++) { - state_c[x] = current_state[0][x] ^ current_state[1][x] ^ current_state[2][x] ^ - current_state[3][x] ^ current_state[4][x]; - COL_WRITE_BITS(row, KeccakPermCols, c[x], state_c[x]); - } - - // Populate C'[x, z] = xor(C[x, z], C[x - 1, z], ROTL1(C[x + 1, z - 1])). - uint64_t state_c_prime[5]; -#pragma unroll 5 - for (auto x = 0; x < 5; x++) { - state_c_prime[x] = state_c[x] ^ state_c[(x + 4) % 5] ^ ROTL64(state_c[(x + 1) % 5], 1); - COL_WRITE_BITS(row, KeccakPermCols, c_prime[x], state_c_prime[x]); - } - - // Populate A'. To avoid shifting indices, we rewrite - // A'[x, y, z] = xor(A[x, y, z], C[x - 1, z], C[x + 1, z - 1]) - // as - // A'[x, y, z] = xor(A[x, y, z], C[x, z], C'[x, z]). - for (int x = 0; x < 5; x++) { -#pragma unroll 5 - for (int y = 0; y < 5; y++) { - current_state[y][x] ^= state_c[x] ^ state_c_prime[x]; - COL_WRITE_BITS(row, KeccakPermCols, a_prime[y][x], current_state[y][x]); - } - } - - // Rotate the current state to get the B array. - uint64_t state_b[5][5]; - for (auto i = 0; i < 5; i++) { -#pragma unroll 5 - for (auto j = 0; j < 5; j++) { - auto new_i = (i + 3 * j) % 5; - auto new_j = i; - state_b[j][i] = ROTL64(current_state[new_j][new_i], R[new_i][new_j]); - } - } - - // Populate A'' as A''[x, y] = xor(B[x, y], andn(B[x + 1, y], B[x + 2, y])). - for (int i = 0; i < 5; i++) { -#pragma unroll 5 - for (int j = 0; j < 5; j++) { - current_state[i][j] = - state_b[i][j] ^ ((~state_b[i][(j + 1) % 5]) & state_b[i][(j + 2) % 5]); - } - } - uint16_t *state_limbs = reinterpret_cast(¤t_state[0][0]); - COL_WRITE_ARRAY(row, KeccakPermCols, a_prime_prime, state_limbs); - - COL_WRITE_BITS(row, KeccakPermCols, a_prime_prime_0_0_bits, current_state[0][0]); - - // A''[0, 0] is additionally xor'd with RC. - current_state[0][0] ^= RC[round]; - - state_limbs = reinterpret_cast(¤t_state[0][0]); - COL_WRITE_ARRAY(row, KeccakPermCols, a_prime_prime_prime_0_0_limbs, state_limbs); -} \ No newline at end of file diff --git a/extensions/keccak256/circuit/cuda/include/keccakf_op.cuh b/extensions/keccak256/circuit/cuda/include/keccakf_op.cuh new file mode 100644 index 0000000000..cfeebfc2a9 --- /dev/null +++ b/extensions/keccak256/circuit/cuda/include/keccakf_op.cuh @@ -0,0 +1,83 @@ +#pragma once + +#include "p3_keccakf.cuh" +#include "primitives/constants.h" +#include "system/memory/offline_checker.cuh" + +#include +#include + +namespace keccakf_op { +using namespace riscv; +using namespace keccak256; + +inline constexpr size_t KECCAK_WIDTH_WORDS = KECCAK_WIDTH_BYTES / RV32_REGISTER_NUM_LIMBS; +inline constexpr size_t NUM_OP_ROWS_PER_INS = 1; // 1 row per instruction + +// Record structure matching Rust KeccakfRecord (from trace.rs) +// Must match exact layout with #[repr(C)] +struct KeccakfOpRecord { + uint32_t pc; + uint32_t timestamp; + uint32_t rd_ptr; + uint32_t buffer_ptr; + MemoryReadAuxRecord rd_aux; + MemoryReadAuxRecord buffer_word_aux[KECCAK_WIDTH_WORDS]; + uint8_t preimage_buffer_bytes[KECCAK_WIDTH_BYTES]; +}; + +// Column structure matching Rust KeccakfOpCols (from columns.rs) +template struct KeccakfOpCols { + T pc; + T is_valid; + T timestamp; + T rd_ptr; + T buffer_ptr_limbs[RV32_REGISTER_NUM_LIMBS]; // 4 limbs + T preimage[KECCAK_WIDTH_BYTES]; // 200 bytes + T postimage[KECCAK_WIDTH_BYTES]; // 200 bytes + MemoryReadAuxCols rd_aux; + MemoryBaseAuxCols buffer_word_aux[KECCAK_WIDTH_WORDS]; // 50 words +}; + +inline constexpr size_t NUM_KECCAKF_OP_COLS = sizeof(KeccakfOpCols); + +// Helper to rotate left a 64-bit value +__device__ __forceinline__ uint64_t rotl64(uint64_t x, int n) { return (x << n) | (x >> (64 - n)); } + +// Compute keccak-f permutation on a 200-byte state +__device__ __forceinline__ void keccakf_permutation(uint64_t state[25]) { + for (int round = 0; round < 24; round++) { + // Theta + uint64_t c[5]; + for (int x = 0; x < 5; x++) { + c[x] = state[x] ^ state[x + 5] ^ state[x + 10] ^ state[x + 15] ^ state[x + 20]; + } + for (int x = 0; x < 5; x++) { + uint64_t d = c[(x + 4) % 5] ^ rotl64(c[(x + 1) % 5], 1); + for (int y = 0; y < 5; y++) { + state[x + 5 * y] ^= d; + } + } + + // Rho and Pi + uint64_t temp[25]; + for (int y = 0; y < 5; y++) { + for (int x = 0; x < 5; x++) { + temp[y + 5 * ((2 * x + 3 * y) % 5)] = rotl64(state[x + 5 * y], R[x][y]); + } + } + + // Chi + for (int y = 0; y < 5; y++) { + for (int x = 0; x < 5; x++) { + state[x + 5 * y] = + temp[x + 5 * y] ^ ((~temp[(x + 1) % 5 + 5 * y]) & temp[(x + 2) % 5 + 5 * y]); + } + } + + // Iota + state[0] ^= RC[round]; + } +} + +} // namespace keccakf_op diff --git a/extensions/keccak256/circuit/cuda/include/keccakf_perm.cuh b/extensions/keccak256/circuit/cuda/include/keccakf_perm.cuh new file mode 100644 index 0000000000..bca675214b --- /dev/null +++ b/extensions/keccak256/circuit/cuda/include/keccakf_perm.cuh @@ -0,0 +1,19 @@ +#pragma once + +#include "p3_keccakf.cuh" + +#include +#include + +namespace keccakf_perm { + +// KeccakfPermCols = KeccakCols + timestamp +// Matches Rust KeccakfPermCols (from keccakf_perm/air.rs) +template struct KeccakfPermCols { + p3_keccak_air::KeccakCols inner; + T timestamp; +}; + +inline constexpr size_t NUM_KECCAKF_PERM_COLS = sizeof(KeccakfPermCols); + +} // namespace keccakf_perm diff --git a/extensions/new-keccak256/circuit/cuda/include/keccakf/p3_generation.cuh b/extensions/keccak256/circuit/cuda/include/p3_keccakf.cuh similarity index 54% rename from extensions/new-keccak256/circuit/cuda/include/keccakf/p3_generation.cuh rename to extensions/keccak256/circuit/cuda/include/p3_keccakf.cuh index 7f8c4a4f20..8df6b2ca4f 100644 --- a/extensions/new-keccak256/circuit/cuda/include/keccakf/p3_generation.cuh +++ b/extensions/keccak256/circuit/cuda/include/p3_keccakf.cuh @@ -1,13 +1,15 @@ #pragma once -#include "keccakf.cuh" +#include "primitives/constants.h" #include "primitives/trace_access.h" #include "primitives/utils.cuh" +#include +#include -namespace new_keccak { -using namespace keccakf; +namespace keccak256 { +using p3_keccak_air::NUM_ROUNDS; -__device__ __constant__ uint8_t R[5][5] = { +__device__ __constant__ inline uint8_t R[5][5] = { {0, 36, 3, 41, 18}, {1, 44, 10, 45, 2}, {62, 6, 43, 15, 61}, @@ -15,7 +17,7 @@ __device__ __constant__ uint8_t R[5][5] = { {27, 20, 39, 8, 14}, }; -__device__ __constant__ uint64_t RC[NUM_ROUNDS] = { +__device__ __constant__ inline uint64_t RC[NUM_ROUNDS] = { 0x0000000000000001ULL, 0x0000000000008082ULL, 0x800000000000808AULL, 0x8000000080008000ULL, 0x000000000000808BULL, 0x0000000080000001ULL, 0x8000000080008081ULL, 0x8000000000008009ULL, 0x000000000000008AULL, 0x0000000000000088ULL, 0x0000000080008009ULL, 0x000000008000000AULL, @@ -23,14 +25,59 @@ __device__ __constant__ uint64_t RC[NUM_ROUNDS] = { 0x8000000000008002ULL, 0x8000000000000080ULL, 0x000000000000800AULL, 0x800000008000000AULL, 0x8000000080008081ULL, 0x8000000000008080ULL, 0x0000000080000001ULL, 0x8000000080008008ULL }; +} // namespace keccak256 -__device__ void generate_trace_row_for_round( +namespace p3_keccak_air { +using keccak256::R; +using keccak256::RC; + +// Plonky3 KeccakCols structure (from p3_keccak_air) +// Must match exactly for trace compatibility +template struct KeccakCols { + // The `i`th value is set to 1 if we are in the `i`th round, otherwise 0. + T step_flags[NUM_ROUNDS]; + + // A register which indicates if a row should be exported, i.e. included in a multiset equality + // argument. Should be 1 only for certain rows which are final steps, i.e. with + // `step_flags[23] = 1`. + T _export; + + // Permutation inputs, stored in y-major order. + T preimage[5][5][U64_LIMBS]; + + T a[5][5][U64_LIMBS]; + + // C[x] = xor(A[x, 0], A[x, 1], A[x, 2], A[x, 3], A[x, 4]) + T c[5][64]; + + // C'[x, z] = xor(C[x, z], C[x - 1, z], C[x + 1, z - 1]) + T c_prime[5][64]; + + // A'[x, y] = xor(A[x, y], D[x]) + // = xor(A[x, y], C[x - 1], ROT(C[x + 1], 1)) + T a_prime[5][5][64]; + + // A''[x, y] = xor(B[x, y], andn(B[x + 1, y], B[x + 2, y])). + T a_prime_prime[5][5][U64_LIMBS]; + + // The bits of `A''[0, 0]`. + T a_prime_prime_0_0_bits[64]; + + // A'''[0, 0, z] = A''[0, 0, z] ^ RC[k, z] + T a_prime_prime_prime_0_0_limbs[U64_LIMBS]; +}; + +inline constexpr size_t NUM_KECCAK_COLS = sizeof(KeccakCols); + +// tracegen matching plonky3 +// `row` must have first NUM_KECCAK_COLS columns matching KeccakCols +__device__ inline void generate_trace_row_for_round( RowSlice row, uint32_t round, uint64_t current_state[5][5] ) { - COL_FILL_ZERO(row, KeccakfVmCols, inner.step_flags); - COL_WRITE_VALUE(row, KeccakfVmCols, inner.step_flags[round], 1); + COL_FILL_ZERO(row, KeccakCols, step_flags); + COL_WRITE_VALUE(row, KeccakCols, step_flags[round], 1); // Populate C[x] = xor(A[x, 0], A[x, 1], A[x, 2], A[x, 3], A[x, 4]). uint64_t state_c[5]; @@ -38,7 +85,7 @@ __device__ void generate_trace_row_for_round( for (auto x = 0; x < 5; x++) { state_c[x] = current_state[0][x] ^ current_state[1][x] ^ current_state[2][x] ^ current_state[3][x] ^ current_state[4][x]; - COL_WRITE_BITS(row, KeccakfVmCols, inner.c[x], state_c[x]); + COL_WRITE_BITS(row, KeccakCols, c[x], state_c[x]); } // Populate C'[x, z] = xor(C[x, z], C[x - 1, z], ROTL1(C[x + 1, z - 1])). @@ -46,7 +93,7 @@ __device__ void generate_trace_row_for_round( #pragma unroll 5 for (auto x = 0; x < 5; x++) { state_c_prime[x] = state_c[x] ^ state_c[(x + 4) % 5] ^ ROTL64(state_c[(x + 1) % 5], 1); - COL_WRITE_BITS(row, KeccakfVmCols, inner.c_prime[x], state_c_prime[x]); + COL_WRITE_BITS(row, KeccakCols, c_prime[x], state_c_prime[x]); } // Populate A'. To avoid shifting indices, we rewrite @@ -57,7 +104,7 @@ __device__ void generate_trace_row_for_round( #pragma unroll 5 for (int y = 0; y < 5; y++) { current_state[y][x] ^= state_c[x] ^ state_c_prime[x]; - COL_WRITE_BITS(row, KeccakfVmCols, inner.a_prime[y][x], current_state[y][x]); + COL_WRITE_BITS(row, KeccakCols, a_prime[y][x], current_state[y][x]); } } @@ -81,15 +128,14 @@ __device__ void generate_trace_row_for_round( } } uint16_t *state_limbs = reinterpret_cast(¤t_state[0][0]); - COL_WRITE_ARRAY(row, KeccakfVmCols, inner.a_prime_prime, state_limbs); + COL_WRITE_ARRAY(row, KeccakCols, a_prime_prime, state_limbs); - COL_WRITE_BITS(row, KeccakfVmCols, inner.a_prime_prime_0_0_bits, current_state[0][0]); + COL_WRITE_BITS(row, KeccakCols, a_prime_prime_0_0_bits, current_state[0][0]); // A''[0, 0] is additionally xor'd with RC. current_state[0][0] ^= RC[round]; state_limbs = reinterpret_cast(¤t_state[0][0]); - COL_WRITE_ARRAY(row, KeccakfVmCols, inner.a_prime_prime_prime_0_0_limbs, state_limbs); + COL_WRITE_ARRAY(row, KeccakCols, a_prime_prime_prime_0_0_limbs, state_limbs); } - -} // namespace new_keccak +} // namespace p3_keccak_air diff --git a/extensions/new-keccak256/circuit/cuda/include/xorin/xorin.cuh b/extensions/keccak256/circuit/cuda/include/xorin.cuh similarity index 100% rename from extensions/new-keccak256/circuit/cuda/include/xorin/xorin.cuh rename to extensions/keccak256/circuit/cuda/include/xorin.cuh diff --git a/extensions/keccak256/circuit/cuda/src/keccak256.cu b/extensions/keccak256/circuit/cuda/src/keccak256.cu deleted file mode 100644 index cfa884a5df..0000000000 --- a/extensions/keccak256/circuit/cuda/src/keccak256.cu +++ /dev/null @@ -1,344 +0,0 @@ -#include "keccak256/columns.cuh" -#include "keccak256/keccakvm.cuh" -#include "keccak256/p3_generation.cuh" -#include "launcher.cuh" -#include "primitives/histogram.cuh" -#include "primitives/trace_access.h" -#include "primitives/utils.cuh" -#include "system/memory/controller.cuh" - -using namespace keccak256; - -__global__ void p3_inner_tracegen( - Fp *trace, - size_t height, - uint32_t total_num_blocks, // actual number of blocks (rows_used / ROUNDS) - uint32_t blocks_to_fill, // includes dummy rows (1 + (height / ROUNDS)) - uint64_t *states -) { - auto block_idx = blockIdx.x * blockDim.x + threadIdx.x; // [0 .. blocks_to_fill) - if (block_idx >= blocks_to_fill) { - return; - } - RowSlice row(trace + block_idx * NUM_ROUNDS, height); - __align__(16) uint64_t current_state[5][5] = {0}; - __align__(16) uint64_t initial_state[5][5] = {0}; - - if (block_idx < total_num_blocks) { -#pragma unroll 5 - for (auto x = 0; x < 5; x++) { -#pragma unroll 5 - for (auto y = 0; y < 5; y++) { - current_state[y][x] = states[block_idx * KECCAK_STATE_SIZE + x + 5 * y]; - initial_state[y][x] = current_state[y][x]; - } - } - } - uint16_t *initial_state_limbs = reinterpret_cast(initial_state); - - COL_WRITE_ARRAY(row, KeccakPermCols, a, initial_state_limbs); - COL_WRITE_ARRAY(row, KeccakPermCols, preimage, initial_state_limbs); - generate_trace_row_for_round(row, 0, current_state); - - auto last_rounds = height - (blocks_to_fill - 1) * NUM_ROUNDS; - RowSlice prev_round_row = row; -#pragma unroll 1 - for (auto round = 1; round < NUM_ROUNDS; round++) { - if ((block_idx == (blocks_to_fill - 1)) && (round >= last_rounds)) { - break; - } - RowSlice round_row(prev_round_row.ptr + 1, height); - COL_WRITE_ARRAY(round_row, KeccakPermCols, preimage, initial_state_limbs); - for (auto y = 0; y < 5; y++) { -#pragma unroll 5 - for (auto x = 0; x < 5; x++) { -#pragma unroll 4 - for (auto limb = 0; limb < U64_LIMBS; limb++) { - // Copy previous row's output to next row's input. - COL_WRITE_VALUE( - round_row, - KeccakPermCols, - a[y][x][limb], - ((x == 0) && (y == 0)) - ? prev_round_row - [COL_INDEX(KeccakPermCols, a_prime_prime_prime_0_0_limbs[limb])] - : prev_round_row[COL_INDEX(KeccakPermCols, a_prime_prime[y][x][limb])] - ); - } - } - } - generate_trace_row_for_round(round_row, round, current_state); - prev_round_row = round_row; - } -} - -#define KECCAK_WRITE(FIELD, VALUE) COL_WRITE_VALUE(row, KeccakVmCols, FIELD, VALUE) -#define KECCAK_WRITE_ARRAY(FIELD, VALUES) COL_WRITE_ARRAY(row, KeccakVmCols, FIELD, VALUES) -#define KECCAK_FILL_ZERO(FIELD) COL_FILL_ZERO(row, KeccakVmCols, FIELD) -#define KECCAK_SLICE(FIELD) row.slice_from(COL_INDEX(KeccakVmCols, FIELD)) - -__global__ void keccak256_tracegen( - Fp *trace, - size_t height, - uint8_t *records, - size_t num_records, - size_t *record_offsets, - uint32_t *block_offsets, - uint32_t *block_to_record_idx, - uint32_t total_num_blocks, - uint64_t *states, - size_t rows_used, - uint32_t ptr_max_bits, - uint32_t *range_checker_ptr, - uint32_t range_checker_num_bins, - uint32_t *bitwise_lookup_ptr, - uint32_t bitwise_num_bits, - uint32_t timestamp_max_bits -) { - auto row_idx = blockIdx.x * blockDim.x + threadIdx.x; - auto round_idx = row_idx % NUM_ROUNDS; - - RowSlice row(trace + row_idx, height); - if (row_idx < rows_used) { - MemoryAuxColsFactory mem_helper( - VariableRangeChecker(range_checker_ptr, range_checker_num_bins), timestamp_max_bits - ); - auto bitwise_lookup = BitwiseOperationLookup(bitwise_lookup_ptr, bitwise_num_bits); - - uint32_t global_block_idx = row_idx / NUM_ROUNDS; - uint32_t record_idx = block_to_record_idx[global_block_idx]; - - auto record_mut = KeccakVmRecordMut(records + record_offsets[record_idx]); - KeccakVmRecordHeader vm_record = record_mut.header; - auto len = vm_record.len; - auto num_blocks = num_keccak_f(len); - auto state = states + global_block_idx * KECCAK_STATE_SIZE; - - auto input = record_mut.input_ptr; - - auto block_idx = global_block_idx - block_offsets[record_idx]; - auto input_offset = block_idx * KECCAK_RATE_BYTES; - auto start_timestamp = - vm_record.timestamp + (block_idx * (KECCAK_REGISTER_READS + KECCAK_ABSORB_READS)); - auto rem_len = len - input_offset; - KECCAK_WRITE(inner._export, Fp::zero()); - { // Fill the sponge columns - KECCAK_WRITE(sponge.is_new_start, (block_idx == 0) && (round_idx == 0)); -#pragma unroll 8 - for (auto i = 0; i < KECCAK_RATE_BYTES; i++) { - KECCAK_WRITE(sponge.is_padding_byte[i], i >= rem_len); - } - - if (block_idx == num_blocks - 1) { - auto this_block_len = len - ((num_blocks - 1) * KECCAK_RATE_BYTES); - for (auto i = 0; i < this_block_len; i++) { - KECCAK_WRITE(sponge.block_bytes[i], input[input_offset + i]); - } - // Add Keccak spec padding - if (this_block_len == KECCAK_RATE_BYTES - 1) { - KECCAK_WRITE(sponge.block_bytes[this_block_len], 0x81); - } else { - KECCAK_WRITE(sponge.block_bytes[this_block_len], 0x01); - for (auto i = this_block_len + 1; i < KECCAK_RATE_BYTES - 1; i++) { - KECCAK_WRITE(sponge.block_bytes[i], 0); - } - KECCAK_WRITE(sponge.block_bytes[KECCAK_RATE_BYTES - 1], 0x80); - } - } else { - KECCAK_WRITE_ARRAY(sponge.block_bytes, input + input_offset); - } - if (round_idx == 0) { -#pragma unroll 8 - for (auto i = 0; i < KECCAK_RATE_U16S; i++) { - KECCAK_WRITE( - sponge.state_hi[i], - static_cast(state[i / U64_LIMBS] >> ((i % U64_LIMBS) * 16 + 8)) - ); - } - } else if (round_idx == NUM_ROUNDS - 1) { - auto next_state = state + total_num_blocks * KECCAK_STATE_SIZE; -#pragma unroll 8 - for (auto i = 0; i < KECCAK_RATE_U16S; i++) { - KECCAK_WRITE( - sponge.state_hi[i], - static_cast( - next_state[i / U64_LIMBS] >> ((i % U64_LIMBS) * 16 + 8) - ) - ); - } - if (block_idx == num_blocks - 1) { - KECCAK_WRITE(inner._export, Fp::one()); - auto next_state_bytes = reinterpret_cast(next_state); -#pragma unroll 8 - for (auto i = 0; i < NUM_ABSORB_ROUNDS * sizeof(uint64_t); i++) { - bitwise_lookup.add_xor(0, next_state_bytes[i]); - } - } - } else { - KECCAK_FILL_ZERO(sponge.state_hi); - } - } - { // Fill the instruction columns - KECCAK_WRITE(instruction.pc, vm_record.from_pc); - KECCAK_WRITE(instruction.is_enabled, 1); - KECCAK_WRITE(instruction.is_enabled_first_round, round_idx == 0); - KECCAK_WRITE(instruction.start_timestamp, start_timestamp); - KECCAK_WRITE(instruction.dst_ptr, vm_record.rd_ptr); - KECCAK_WRITE(instruction.src_ptr, vm_record.rs1_ptr); - KECCAK_WRITE(instruction.len_ptr, vm_record.rs2_ptr); - auto vm_record_dst_limbs = reinterpret_cast(&vm_record.dst); - KECCAK_WRITE_ARRAY(instruction.dst, vm_record_dst_limbs); - uint32_t src = vm_record.src + (block_idx * KECCAK_RATE_BYTES); - KECCAK_WRITE(instruction.src, src); - auto src_limbs = reinterpret_cast(&src); - KECCAK_WRITE_ARRAY(instruction.src_limbs, src_limbs + 1); - auto rem_len_limbs = reinterpret_cast(&rem_len); - KECCAK_WRITE_ARRAY(instruction.len_limbs, rem_len_limbs + 1); - KECCAK_WRITE(instruction.remaining_len, rem_len); - } - { // Fill the register reads - if (round_idx == 0 && block_idx == 0) { - for (auto i = 0; i < KECCAK_REGISTER_READS; i++) { - mem_helper.fill( - KECCAK_SLICE(mem_oc.register_aux[i].base), - vm_record.register_reads_aux[i].prev_timestamp, - start_timestamp + i - ); - } - - auto msl_rshift = RV32_CELL_BITS * (RV32_REGISTER_NUM_LIMBS - 1); - auto msl_lshift = RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - ptr_max_bits; - - bitwise_lookup.add_range( - (vm_record.dst >> msl_rshift) << msl_lshift, - (vm_record.src >> msl_rshift) << msl_lshift - ); - bitwise_lookup.add_range( - (vm_record.len >> msl_rshift) << msl_lshift, - (vm_record.len >> msl_rshift) << msl_lshift - ); - } else { - KECCAK_FILL_ZERO(mem_oc.register_aux); - } - } - { // Fill the absorb reads - if (round_idx == 0) { - auto reads_offs = block_idx * KECCAK_ABSORB_READS; - auto num_reads = - min(d_div_ceil(size_t(rem_len), KECCAK_WORD_SIZE), KECCAK_ABSORB_READS); - start_timestamp += KECCAK_REGISTER_READS; - for (auto i = 0; i < num_reads; i++) { - mem_helper.fill( - KECCAK_SLICE(mem_oc.absorb_reads[i].base), - record_mut.read_aux_ptr[i + reads_offs].prev_timestamp, - start_timestamp + i - ); - } - for (auto i = num_reads; i < KECCAK_ABSORB_READS; i++) { - // Zero the whole MemoryReadAuxCols struct (prev_timestamp + lt_decomp) - KECCAK_FILL_ZERO(mem_oc.absorb_reads[i]); - } - } else { - KECCAK_FILL_ZERO(mem_oc.absorb_reads); - } - } - { // Fill the digest writes - if (block_idx == num_blocks - 1 && round_idx == NUM_ROUNDS - 1) { - auto timestamp = start_timestamp + (KECCAK_ABSORB_READS + KECCAK_REGISTER_READS); - for (auto i = 0; i < KECCAK_DIGEST_WRITES; i++) { - KECCAK_WRITE_ARRAY( - mem_oc.digest_writes[i].prev_data, vm_record.write_aux[i].prev_data - ); - mem_helper.fill( - KECCAK_SLICE(mem_oc.digest_writes[i].base), - vm_record.write_aux[i].prev_timestamp, - timestamp + i - ); - } - } else { - KECCAK_FILL_ZERO(mem_oc.digest_writes); - } - } - { // Fill the partial block - auto read_len = record_mut.read_len(); - if ((block_idx == num_blocks - 1) && (read_len != len)) { - KECCAK_WRITE_ARRAY(mem_oc.partial_block, input + read_len - KECCAK_WORD_SIZE + 1); - } else { - KECCAK_FILL_ZERO(mem_oc.partial_block); - } - } - } else { // height > idx >= rows_used - // inner rows are filled in p3_tracegen kernel. Ensure export flag is 0 - KECCAK_WRITE(inner._export, Fp::zero()); - // leave other permutation columns untouched - row.fill_zero( - COL_INDEX(KeccakVmCols, sponge), - NUM_KECCAK_SPONGE_COLS + NUM_KECCAK_INSTRUCTION_COLS + NUM_KECCAK_MEMORY_COLS - ); - KECCAK_WRITE(sponge.is_new_start, round_idx == 0); - KECCAK_WRITE(sponge.block_bytes[0], Fp::one()); - KECCAK_WRITE(sponge.block_bytes[KECCAK_RATE_BYTES - 1], Fp(0x80)); - for (auto i = 0; i < KECCAK_RATE_BYTES; i++) { - KECCAK_WRITE(sponge.is_padding_byte[i], Fp::one()); - } - } -} - -#undef KECCAK_WRITE -#undef KECCAK_WRITE_ARRAY -#undef KECCAK_FILL_ZERO -#undef KECCAK_SLICE - -extern "C" int _keccak256_p3_tracegen( - Fp *trace, - size_t height, - uint32_t total_num_blocks, - uint64_t *states -) { - auto threads = div_ceil(height, NUM_ROUNDS); - auto [grid, block] = kernel_launch_params(threads, 256); - p3_inner_tracegen<<>>(trace, height, total_num_blocks, threads, states); - return CHECK_KERNEL(); -} - -extern "C" int _keccak256_tracegen( - Fp *trace, - size_t height, - uint8_t *records, - size_t num_records, - size_t *offsets, - uint32_t *block_offsets, - uint32_t *block_to_record_idx, - uint32_t total_num_blocks, - uint64_t *states, - size_t rows_used, - uint32_t ptr_max_bits, - uint32_t *range_checker_ptr, - uint32_t range_checker_num_bins, - uint32_t *bitwise_lookup_ptr, - uint32_t bitwise_num_bits, - uint32_t timestamp_max_bits -) { - assert((height & (height - 1)) == 0); - assert(height > total_num_blocks * NUM_ROUNDS); - auto [grid, block] = kernel_launch_params(height, 256); - keccak256_tracegen<<>>( - trace, - height, - records, - num_records, - offsets, - block_offsets, - block_to_record_idx, - total_num_blocks, - states, - rows_used, - ptr_max_bits, - range_checker_ptr, - range_checker_num_bins, - bitwise_lookup_ptr, - bitwise_num_bits, - timestamp_max_bits - ); - return CHECK_KERNEL(); -} diff --git a/extensions/keccak256/circuit/cuda/src/keccakf.cu b/extensions/keccak256/circuit/cuda/src/keccakf.cu deleted file mode 100644 index d6b47b0bda..0000000000 --- a/extensions/keccak256/circuit/cuda/src/keccakf.cu +++ /dev/null @@ -1,254 +0,0 @@ -#include "keccak256/keccakvm.cuh" -#include "launcher.cuh" -#include "primitives/constants.h" -#include "primitives/histogram.cuh" -#include "primitives/utils.cuh" - -using namespace keccak256; - -// FROM https://github.com/mochimodev/cuda-hashing-algos/blob/master/keccak.cu - -__device__ __constant__ uint64_t CUDA_KECCAK_CONSTS[KECCAK_ROUND] = { - 0x0000000000000001, 0x0000000000008082, 0x800000000000808a, 0x8000000080008000, - 0x000000000000808b, 0x0000000080000001, 0x8000000080008081, 0x8000000000008009, - 0x000000000000008a, 0x0000000000000088, 0x0000000080008009, 0x000000008000000a, - 0x000000008000808b, 0x800000000000008b, 0x8000000000008089, 0x8000000000008003, - 0x8000000000008002, 0x8000000000000080, 0x000000000000800a, 0x800000008000000a, - 0x8000000080008081, 0x8000000000008080, 0x0000000080000001, 0x8000000080008008 -}; - -__device__ __forceinline__ uint64_t cuda_keccak_ROTL64(uint64_t a, uint64_t b) { - return ROTL64(a, b); -} - -__device__ void cuda_keccak_permutations(uint64_t *state) { - int64_t *A = reinterpret_cast(state); - - int64_t *a00 = A, *a01 = A + 1, *a02 = A + 2, *a03 = A + 3, *a04 = A + 4; - int64_t *a05 = A + 5, *a06 = A + 6, *a07 = A + 7, *a08 = A + 8, *a09 = A + 9; - int64_t *a10 = A + 10, *a11 = A + 11, *a12 = A + 12, *a13 = A + 13, *a14 = A + 14; - int64_t *a15 = A + 15, *a16 = A + 16, *a17 = A + 17, *a18 = A + 18, *a19 = A + 19; - int64_t *a20 = A + 20, *a21 = A + 21, *a22 = A + 22, *a23 = A + 23, *a24 = A + 24; - - for (int i = 0; i < KECCAK_ROUND; i++) { - - /* Theta */ - int64_t c0 = *a00 ^ *a05 ^ *a10 ^ *a15 ^ *a20; - int64_t c1 = *a01 ^ *a06 ^ *a11 ^ *a16 ^ *a21; - int64_t c2 = *a02 ^ *a07 ^ *a12 ^ *a17 ^ *a22; - int64_t c3 = *a03 ^ *a08 ^ *a13 ^ *a18 ^ *a23; - int64_t c4 = *a04 ^ *a09 ^ *a14 ^ *a19 ^ *a24; - - int64_t d1 = cuda_keccak_ROTL64(c1, 1) ^ c4; - int64_t d2 = cuda_keccak_ROTL64(c2, 1) ^ c0; - int64_t d3 = cuda_keccak_ROTL64(c3, 1) ^ c1; - int64_t d4 = cuda_keccak_ROTL64(c4, 1) ^ c2; - int64_t d0 = cuda_keccak_ROTL64(c0, 1) ^ c3; - - *a00 ^= d1; - *a05 ^= d1; - *a10 ^= d1; - *a15 ^= d1; - *a20 ^= d1; - *a01 ^= d2; - *a06 ^= d2; - *a11 ^= d2; - *a16 ^= d2; - *a21 ^= d2; - *a02 ^= d3; - *a07 ^= d3; - *a12 ^= d3; - *a17 ^= d3; - *a22 ^= d3; - *a03 ^= d4; - *a08 ^= d4; - *a13 ^= d4; - *a18 ^= d4; - *a23 ^= d4; - *a04 ^= d0; - *a09 ^= d0; - *a14 ^= d0; - *a19 ^= d0; - *a24 ^= d0; - - /* Rho pi */ - c1 = cuda_keccak_ROTL64(*a01, 1); - *a01 = cuda_keccak_ROTL64(*a06, 44); - *a06 = cuda_keccak_ROTL64(*a09, 20); - *a09 = cuda_keccak_ROTL64(*a22, 61); - *a22 = cuda_keccak_ROTL64(*a14, 39); - *a14 = cuda_keccak_ROTL64(*a20, 18); - *a20 = cuda_keccak_ROTL64(*a02, 62); - *a02 = cuda_keccak_ROTL64(*a12, 43); - *a12 = cuda_keccak_ROTL64(*a13, 25); - *a13 = cuda_keccak_ROTL64(*a19, 8); - *a19 = cuda_keccak_ROTL64(*a23, 56); - *a23 = cuda_keccak_ROTL64(*a15, 41); - *a15 = cuda_keccak_ROTL64(*a04, 27); - *a04 = cuda_keccak_ROTL64(*a24, 14); - *a24 = cuda_keccak_ROTL64(*a21, 2); - *a21 = cuda_keccak_ROTL64(*a08, 55); - *a08 = cuda_keccak_ROTL64(*a16, 45); - *a16 = cuda_keccak_ROTL64(*a05, 36); - *a05 = cuda_keccak_ROTL64(*a03, 28); - *a03 = cuda_keccak_ROTL64(*a18, 21); - *a18 = cuda_keccak_ROTL64(*a17, 15); - *a17 = cuda_keccak_ROTL64(*a11, 10); - *a11 = cuda_keccak_ROTL64(*a07, 6); - *a07 = cuda_keccak_ROTL64(*a10, 3); - *a10 = c1; - - /* Chi */ - c0 = *a00 ^ (~*a01 & *a02); - c1 = *a01 ^ (~*a02 & *a03); - *a02 ^= ~*a03 & *a04; - *a03 ^= ~*a04 & *a00; - *a04 ^= ~*a00 & *a01; - *a00 = c0; - *a01 = c1; - - c0 = *a05 ^ (~*a06 & *a07); - c1 = *a06 ^ (~*a07 & *a08); - *a07 ^= ~*a08 & *a09; - *a08 ^= ~*a09 & *a05; - *a09 ^= ~*a05 & *a06; - *a05 = c0; - *a06 = c1; - - c0 = *a10 ^ (~*a11 & *a12); - c1 = *a11 ^ (~*a12 & *a13); - *a12 ^= ~*a13 & *a14; - *a13 ^= ~*a14 & *a10; - *a14 ^= ~*a10 & *a11; - *a10 = c0; - *a11 = c1; - - c0 = *a15 ^ (~*a16 & *a17); - c1 = *a16 ^ (~*a17 & *a18); - *a17 ^= ~*a18 & *a19; - *a18 ^= ~*a19 & *a15; - *a19 ^= ~*a15 & *a16; - *a15 = c0; - *a16 = c1; - - c0 = *a20 ^ (~*a21 & *a22); - c1 = *a21 ^ (~*a22 & *a23); - *a22 ^= ~*a23 & *a24; - *a23 ^= ~*a24 & *a20; - *a24 ^= ~*a20 & *a21; - *a20 = c0; - *a21 = c1; - - /* Iota */ - *a00 ^= CUDA_KECCAK_CONSTS[i]; - } -} - -// END OF FROM https://github.com/mochimodev/cuda-hashing-algos/blob/master/keccak.cu - -__global__ void keccakf_kernel( - uint8_t *records, - size_t num_records, - size_t *record_offsets, - uint32_t *block_offsets, - uint32_t total_num_blocks, - uint64_t *states, - uint32_t *bitwise_lookup_ptr, - uint32_t bitwise_num_bits -) { - auto record_idx = blockIdx.x * blockDim.x + threadIdx.x; - if (record_idx >= num_records) { - return; - } - auto bitwise_lookup = BitwiseOperationLookup(bitwise_lookup_ptr, bitwise_num_bits); - - auto record_mut = KeccakVmRecordMut(records + record_offsets[record_idx]); - auto input = record_mut.input_ptr; - auto record_len = record_mut.header.len; - auto num_blocks = num_keccak_f(record_len); - auto block_offset = block_offsets[record_idx]; - auto this_rec_states = reinterpret_cast( - states + block_offset * KECCAK_STATE_SIZE - ); - auto next_rec_states = reinterpret_cast( - states + (block_offset + total_num_blocks) * KECCAK_STATE_SIZE - ); - uint64_t state[KECCAK_STATE_SIZE] = {0}; - - auto last_block_len = record_len - (num_blocks - 1) * KECCAK_RATE_BYTES; - for (size_t blk = 0; blk < num_blocks; blk++) { - uint8_t *chunk = input + blk * KECCAK_RATE_BYTES; - bool is_last_block = (blk == num_blocks - 1); - for (int round = 0; round < NUM_ABSORB_ROUNDS; round++) { - uint8_t i_bytes[8] = {}; - int round_base = round * sizeof(uint64_t); - // For the last block, zero-initialize and only copy available bytes - if (is_last_block && round_base < last_block_len) { - size_t bytes_to_copy = min(sizeof(uint64_t), last_block_len - round_base); - memcpy(i_bytes, chunk + round_base, bytes_to_copy); - } else if (!is_last_block) { - memcpy(i_bytes, chunk + round_base, sizeof(uint64_t)); - } - - // Handle Keccak spec padding - if (is_last_block) { - int round_base = round * 8; -#pragma unroll 8 - for (int i = 0; i < 8; i++) { - int global_idx = round_base + i; - if (global_idx >= last_block_len) { - i_bytes[i] = 0; - if (global_idx == last_block_len) - i_bytes[i] = 0x01; - // WARNING: it is possible for i_bytes[i] = 0x81=0b10000001 in the case all padding happens in a single byte - if (global_idx == KECCAK_RATE_BYTES - 1) - i_bytes[i] ^= 0x80; - } - } - } - -#pragma unroll 8 - for (int i = 0; i < 8; i++) { - uint8_t byte = i_bytes[i]; - uint8_t s_byte = (state[round] >> (i * 8)) & 0xff; - if (blk != 0) { - bitwise_lookup.add_xor(byte, s_byte); - } - state[round] ^= (static_cast(byte) << (i * 8)); - } - } -#pragma unroll 8 - for (int i = 0; i < KECCAK_STATE_SIZE; i++) { - this_rec_states[blk][i] = state[i]; - } - cuda_keccak_permutations(state); -#pragma unroll 8 - for (int i = 0; i < KECCAK_STATE_SIZE; i++) { - next_rec_states[blk][i] = state[i]; - } - } -} - -extern "C" int _keccakf_kernel( - uint8_t *records, - size_t num_records, - size_t *record_offsets, - uint32_t *block_offsets, - uint32_t total_num_blocks, - uint64_t *states, - uint32_t *bitwise_lookup_ptr, - uint32_t bitwise_num_bits -) { - auto [grid, block] = kernel_launch_params(num_records, 256); - keccakf_kernel<<>>( - records, - num_records, - record_offsets, - block_offsets, - total_num_blocks, - states, - bitwise_lookup_ptr, - bitwise_num_bits - ); - return CHECK_KERNEL(); -} diff --git a/extensions/keccak256/circuit/cuda/src/keccakf_op.cu b/extensions/keccak256/circuit/cuda/src/keccakf_op.cu new file mode 100644 index 0000000000..47410333b4 --- /dev/null +++ b/extensions/keccak256/circuit/cuda/src/keccakf_op.cu @@ -0,0 +1,156 @@ +#include "fp.h" +#include "keccakf_op.cuh" +#include "launcher.cuh" +#include "primitives/buffer_view.cuh" +#include "primitives/constants.h" +#include "primitives/histogram.cuh" +#include "primitives/trace_access.h" +#include "system/memory/controller.cuh" + +#include +#include +#include +#include + +using namespace keccakf_op; +using namespace riscv; + +#define KECCAKF_OP_WRITE(FIELD, VALUE) COL_WRITE_VALUE(row, KeccakfOpCols, FIELD, VALUE) +#define KECCAKF_OP_WRITE_ARRAY(FIELD, VALUES) COL_WRITE_ARRAY(row, KeccakfOpCols, FIELD, VALUES) +#define KECCAKF_OP_FILL_ZERO(FIELD) COL_FILL_ZERO(row, KeccakfOpCols, FIELD) +#define KECCAKF_OP_SLICE(FIELD) row.slice_from(COL_INDEX(KeccakfOpCols, FIELD)) + +// Main kernel for KeccakfOpChip trace generation +// Each thread processes one record (1 rows) +__global__ void keccakf_op_tracegen( + Fp *d_trace, + size_t height, + uint32_t num_records, + DeviceBufferConstView d_records, + uint32_t *d_range_checker_ptr, + uint32_t range_checker_num_bins, + uint32_t *d_bitwise_lookup_ptr, + size_t bitwise_num_bits, + uint32_t pointer_max_bits, + uint32_t timestamp_max_bits +) { + uint32_t record_idx = blockIdx.x * blockDim.x + threadIdx.x; + uint32_t records_to_fill = height / NUM_OP_ROWS_PER_INS; + + if (record_idx >= records_to_fill) { + return; + } + + // Each record produces 1 row + size_t row0_idx = record_idx * NUM_OP_ROWS_PER_INS; + + RowSlice row0(d_trace + row0_idx, height); + + // Initialize both rows to zero + row0.fill_zero(0, sizeof(KeccakfOpCols)); + + if (record_idx < num_records) { + auto const &rec = d_records[record_idx]; + + MemoryAuxColsFactory mem_helper( + VariableRangeChecker(d_range_checker_ptr, range_checker_num_bins), timestamp_max_bits + ); + BitwiseOperationLookup bitwise_lookup(d_bitwise_lookup_ptr, bitwise_num_bits); + + // CUDA is little-endian, so the u64 word and byte representations below are the same memory layout. + union KeccakState { + uint64_t u64[25]; + uint8_t bytes[KECCAK_WIDTH_BYTES]; + }; + // Compute postimage + KeccakState state; + memcpy(state.u64, rec.preimage_buffer_bytes, KECCAK_WIDTH_BYTES); + keccakf_permutation(state.u64); + + // =========== Row 0: is_valid = 1, preimage buffer =========== + { + RowSlice row = row0; + KECCAKF_OP_WRITE(pc, rec.pc); + KECCAKF_OP_WRITE(is_valid, 1); + KECCAKF_OP_WRITE(timestamp, rec.timestamp); + KECCAKF_OP_WRITE(rd_ptr, rec.rd_ptr); + + // Write buffer_ptr_limbs + uint8_t buffer_ptr_limbs[RV32_REGISTER_NUM_LIMBS]; + buffer_ptr_limbs[0] = rec.buffer_ptr & 0xFF; + buffer_ptr_limbs[1] = (rec.buffer_ptr >> 8) & 0xFF; + buffer_ptr_limbs[2] = (rec.buffer_ptr >> 16) & 0xFF; + buffer_ptr_limbs[3] = (rec.buffer_ptr >> 24) & 0xFF; + KECCAKF_OP_WRITE_ARRAY(buffer_ptr_limbs, buffer_ptr_limbs); + + // Write preimage buffer + KECCAKF_OP_WRITE_ARRAY(preimage, rec.preimage_buffer_bytes); + // Write postimage buffer + KECCAKF_OP_WRITE_ARRAY(postimage, state.bytes); + + // Fill rd_aux - memory read for rd_ptr + uint32_t ts = rec.timestamp; + mem_helper.fill(KECCAKF_OP_SLICE(rd_aux.base), rec.rd_aux.prev_timestamp, ts); + ts++; + + // Fill buffer_word_aux - memory writes for 50 words + for (uint32_t w = 0; w < KECCAK_WIDTH_WORDS; w++) { + mem_helper.fill( + KECCAKF_OP_SLICE(buffer_word_aux[w]), rec.buffer_word_aux[w].prev_timestamp, ts + ); + ts++; + } + + // Range check for buffer pointer (scaled MSB limb) + constexpr uint32_t RV32_TOTAL_BITS = RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS; + uint32_t scaled_limb = (buffer_ptr_limbs[RV32_REGISTER_NUM_LIMBS - 1]) + << (RV32_TOTAL_BITS - pointer_max_bits); + bitwise_lookup.add_range(scaled_limb, scaled_limb); + + // Range check for postimage bytes (pairs) + for (size_t i = 0; i < KECCAK_WIDTH_BYTES; i += 2) { + bitwise_lookup.add_range(state.bytes[i], state.bytes[i + 1]); + } + } + } + // Dummy rows are already zeroed +} + +#undef KECCAKF_OP_WRITE +#undef KECCAKF_OP_WRITE_ARRAY +#undef KECCAKF_OP_FILL_ZERO +#undef KECCAKF_OP_SLICE + +extern "C" int _keccakf_op_tracegen( + Fp *d_trace, + size_t height, + size_t width, + DeviceBufferConstView d_records, + uint32_t *d_range_checker_ptr, + uint32_t range_checker_num_bins, + uint32_t *d_bitwise_lookup_ptr, + size_t bitwise_num_bits, + uint32_t pointer_max_bits, + uint32_t timestamp_max_bits +) { + assert((height & (height - 1)) == 0); + assert(width == sizeof(KeccakfOpCols)); + + uint32_t num_records = d_records.len(); + uint32_t records_to_fill = height / NUM_OP_ROWS_PER_INS; + + auto [grid, block] = kernel_launch_params(records_to_fill, 256); + keccakf_op_tracegen<<>>( + d_trace, + height, + num_records, + d_records, + d_range_checker_ptr, + range_checker_num_bins, + d_bitwise_lookup_ptr, + bitwise_num_bits, + pointer_max_bits, + timestamp_max_bits + ); + return CHECK_KERNEL(); +} diff --git a/extensions/keccak256/circuit/cuda/src/keccakf_perm.cu b/extensions/keccak256/circuit/cuda/src/keccakf_perm.cu new file mode 100644 index 0000000000..4c7dc58ff9 --- /dev/null +++ b/extensions/keccak256/circuit/cuda/src/keccakf_perm.cu @@ -0,0 +1,193 @@ +#include "fp.h" +#include "keccakf_op.cuh" // For KeccakfOpRecord +#include "keccakf_perm.cuh" +#include "launcher.cuh" +#include "p3_keccakf.cuh" +#include "primitives/buffer_view.cuh" +#include "primitives/constants.h" +#include "primitives/trace_access.h" + +#include +#include +#include + +using namespace keccakf_perm; +using namespace keccakf_op; +using p3_keccak_air::NUM_ROUNDS; +using p3_keccak_air::U64_LIMBS; + +#define KECCAKF_PERM_WRITE(FIELD, VALUE) COL_WRITE_VALUE(row, KeccakfPermCols, FIELD, VALUE) +#define KECCAKF_PERM_WRITE_ARRAY(FIELD, VALUES) COL_WRITE_ARRAY(row, KeccakfPermCols, FIELD, VALUES) + +// Main kernel for KeccakfPermChip trace generation +// Each thread processes one permutation (24 rows) +__global__ void keccakf_perm_tracegen( + Fp *d_trace, + size_t height, + uint32_t num_records, + uint32_t blocks_to_fill, // = ceil(height / 24) + DeviceBufferConstView d_records +) { + uint32_t block_idx = blockIdx.x * blockDim.x + threadIdx.x; + + if (block_idx >= blocks_to_fill) { + return; + } + + // Initialize state - will be transformed by generate_trace_row_for_round + __align__(16) uint64_t current_state[5][5] = {0}; + __align__(16) uint64_t initial_state[5][5] = {0}; + + uint32_t timestamp = 0; + + if (block_idx < num_records) { + auto const &rec = d_records[block_idx]; + timestamp = rec.timestamp; + + // Convert preimage bytes to u64 state with coordinate transposition + // generate_trace_row_for_round expects current_state[y][x] = A[x][y] (keccak notation) + // In keccak buffer: A[x][y] is stored at offset (x + 5*y) + // So current_state[y][x] should get keccak_buffer[x + 5*y] + for (int x = 0; x < 5; x++) { + for (int y = 0; y < 5; y++) { + // keccak spec: A[x][y] is at byte offset (x + 5*y) * 8 + int keccak_offset = x + 5 * y; + uint64_t val = 0; + for (int j = 0; j < 8; j++) { + val |= static_cast(rec.preimage_buffer_bytes[keccak_offset * 8 + j]) + << (j * 8); + } + // Store as current_state[y][x] = A[x][y] for generate_trace_row_for_round + current_state[y][x] = val; + initial_state[y][x] = val; + } + } + } + + // Convert initial state to u16 limbs for preimage columns + uint16_t *initial_state_limbs = reinterpret_cast(initial_state); + + // Calculate how many rows to fill for this block + size_t rows_for_this_block = NUM_ROUNDS; + if (block_idx == blocks_to_fill - 1) { + // Last block might have fewer rows + size_t remaining = height - block_idx * NUM_ROUNDS; + if (remaining < NUM_ROUNDS) { + rows_for_this_block = remaining; + } + } + + // Generate 24 round rows + for (uint32_t round_idx = 0; round_idx < rows_for_this_block; round_idx++) { + size_t row_idx = block_idx * NUM_ROUNDS + round_idx; + RowSlice row(d_trace + row_idx, height); + + // Fill zero first for safety + row.fill_zero(0, sizeof(KeccakfPermCols)); + + if (block_idx < num_records) { + // Valid record: fill preimage and compute keccak-f trace + + // Fill preimage columns (same for all rounds within a permutation) + COL_WRITE_ARRAY(row, KeccakfPermCols, inner.preimage, initial_state_limbs); + + // Fill 'a' input state - on first round, same as preimage + // On subsequent rounds, copy from previous row's output + if (round_idx == 0) { + COL_WRITE_ARRAY(row, KeccakfPermCols, inner.a, initial_state_limbs); + } else { + // Copy previous round's output to this round's input + // a[y][x] gets a_prime_prime_prime[0][0] for (x,y)=(0,0), else a_prime_prime[y][x] + RowSlice prev_row(d_trace + row_idx - 1, height); + for (int y = 0; y < 5; y++) { + for (int x = 0; x < 5; x++) { + for (int limb = 0; limb < U64_LIMBS; limb++) { + Fp val; + if (x == 0 && y == 0) { + val = prev_row[COL_INDEX( + KeccakfPermCols, inner.a_prime_prime_prime_0_0_limbs[limb] + )]; + } else { + val = prev_row[COL_INDEX( + KeccakfPermCols, inner.a_prime_prime[y][x][limb] + )]; + } + KECCAKF_PERM_WRITE(inner.a[y][x][limb], val); + } + } + } + } + + // Generate trace row for this round (updates current_state in-place) + p3_keccak_air::generate_trace_row_for_round(row, round_idx, current_state); + + // Set export flag and timestamp on last round + if (round_idx == NUM_ROUNDS - 1) { + KECCAKF_PERM_WRITE(inner._export, 1); + KECCAKF_PERM_WRITE(timestamp, timestamp); + } else { + KECCAKF_PERM_WRITE(inner._export, 0); + KECCAKF_PERM_WRITE(timestamp, 0); + } + } else { + // Dummy block: generate valid keccak-f trace with zero state, export=0 + // The KeccakAir constraints require all intermediate columns (C, C', A', A'', etc.) + // to be properly computed, so we can't just zero them out. + + // Fill preimage with zeros (already zeroed) + // Fill 'a' input state + if (round_idx == 0) { + // a = preimage = zeros (already zeroed) + } else { + // Copy previous round's output to this round's input + RowSlice prev_row(d_trace + row_idx - 1, height); + for (int y = 0; y < 5; y++) { + for (int x = 0; x < 5; x++) { + for (int limb = 0; limb < U64_LIMBS; limb++) { + Fp val; + if (x == 0 && y == 0) { + val = prev_row[COL_INDEX( + KeccakfPermCols, inner.a_prime_prime_prime_0_0_limbs[limb] + )]; + } else { + val = prev_row[COL_INDEX( + KeccakfPermCols, inner.a_prime_prime[y][x][limb] + )]; + } + KECCAKF_PERM_WRITE(inner.a[y][x][limb], val); + } + } + } + } + + // Generate trace row for this round (using current_state which is zero for dummy blocks) + p3_keccak_air::generate_trace_row_for_round(row, round_idx, current_state); + + // Dummy rows: export must be 0, timestamp = 0 + KECCAKF_PERM_WRITE(inner._export, 0); + KECCAKF_PERM_WRITE(timestamp, 0); + } + } +} + +#undef KECCAKF_PERM_WRITE +#undef KECCAKF_PERM_WRITE_ARRAY + +extern "C" int _keccakf_perm_tracegen( + Fp *d_trace, + size_t height, + size_t width, + DeviceBufferConstView d_records, + size_t num_records +) { + assert((height & (height - 1)) == 0); + assert(width == sizeof(KeccakfPermCols)); + + uint32_t blocks_to_fill = div_ceil(height, uint32_t(NUM_ROUNDS)); + + auto [grid, block] = kernel_launch_params(blocks_to_fill, 256); + keccakf_perm_tracegen<<>>( + d_trace, height, static_cast(num_records), blocks_to_fill, d_records + ); + return CHECK_KERNEL(); +} diff --git a/extensions/new-keccak256/circuit/cuda/src/xorin.cu b/extensions/keccak256/circuit/cuda/src/xorin.cu similarity index 91% rename from extensions/new-keccak256/circuit/cuda/src/xorin.cu rename to extensions/keccak256/circuit/cuda/src/xorin.cu index 3487b93f03..b169102e76 100644 --- a/extensions/new-keccak256/circuit/cuda/src/xorin.cu +++ b/extensions/keccak256/circuit/cuda/src/xorin.cu @@ -1,10 +1,14 @@ +#include "fp.h" #include "launcher.cuh" #include "primitives/buffer_view.cuh" #include "primitives/constants.h" -#include "primitives/trace_access.h" #include "primitives/histogram.cuh" +#include "primitives/trace_access.h" #include "system/memory/controller.cuh" -#include "xorin/xorin.cuh" +#include "xorin.cuh" +#include +#include +#include using namespace xorin; using namespace riscv; @@ -42,8 +46,7 @@ __global__ void xorin_tracegen( assert(rec.len < (1U << pointer_max_bits)); MemoryAuxColsFactory mem_helper( - VariableRangeChecker(d_range_checker_ptr, range_checker_num_bins), - timestamp_max_bits + VariableRangeChecker(d_range_checker_ptr, range_checker_num_bins), timestamp_max_bits ); BitwiseOperationLookup bitwise_lookup(d_bitwise_lookup_ptr, bitwise_num_bits); @@ -62,9 +65,13 @@ __global__ void xorin_tracegen( XORIN_WRITE(instruction.start_timestamp, rec.timestamp); // Fill buffer/input/len limbs - XORIN_WRITE_ARRAY(instruction.buffer_ptr_limbs, reinterpret_cast(&rec.buffer)); - XORIN_WRITE_ARRAY(instruction.input_ptr_limbs, reinterpret_cast(&rec.input)); - XORIN_WRITE_ARRAY(instruction.len_limbs, reinterpret_cast(&rec.len)); + XORIN_WRITE_ARRAY( + instruction.buffer_ptr_limbs, reinterpret_cast(&rec.buffer) + ); + XORIN_WRITE_ARRAY( + instruction.input_ptr_limbs, reinterpret_cast(&rec.input) + ); + XORIN_WRITE_ARRAY(instruction.len_limbs, reinterpret_cast(&rec.len)); // Fill is_padding_bytes for (auto i = 0u; i < num_reads && i < XORIN_NUM_WORDS; i++) { @@ -92,8 +99,8 @@ __global__ void xorin_tracegen( // Timestamps follow the order from CPU trace: registers, buffer reads, input reads, buffer writes auto timestamp = rec.timestamp; - // Register aux cols (3 register reads) - #pragma unroll +// Register aux cols (3 register reads) +#pragma unroll for (auto t = 0u; t < XORIN_REGISTER_READS; t++) { mem_helper.fill( XORIN_SLICE(mem_oc.register_aux_cols[t].base), @@ -136,7 +143,10 @@ __global__ void xorin_tracegen( rec.buffer_write_aux_cols[t].prev_timestamp, timestamp ); - XORIN_WRITE_ARRAY(mem_oc.buffer_bytes_write_aux_cols[t].prev_data, rec.buffer_write_aux_cols[t].prev_data); + XORIN_WRITE_ARRAY( + mem_oc.buffer_bytes_write_aux_cols[t].prev_data, + rec.buffer_write_aux_cols[t].prev_data + ); timestamp++; } for (auto t = num_reads; t < XORIN_NUM_WORDS; t++) { diff --git a/extensions/keccak256/circuit/src/air.rs b/extensions/keccak256/circuit/src/air.rs deleted file mode 100644 index 112444006f..0000000000 --- a/extensions/keccak256/circuit/src/air.rs +++ /dev/null @@ -1,638 +0,0 @@ -use std::{array::from_fn, borrow::Borrow, iter::zip}; - -use itertools::{izip, Itertools}; -use openvm_circuit::{ - arch::{ExecutionBridge, ExecutionState}, - system::memory::{ - offline_checker::{MemoryBridge, MemoryReadAuxCols, MemoryWriteAuxCols}, - MemoryAddress, - }, -}; -use openvm_circuit_primitives::{ - bitwise_op_lookup::BitwiseOperationLookupBus, - utils::{assert_array_eq, not, select}, -}; -use openvm_instructions::riscv::{RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_NUM_LIMBS}; -use openvm_keccak256_transpiler::Rv32KeccakOpcode; -use openvm_rv32im_circuit::adapters::abstract_compose; -use openvm_stark_backend::{ - air_builders::sub::SubAirBuilder, - interaction::InteractionBuilder, - p3_air::{Air, AirBuilder, BaseAir}, - p3_field::PrimeCharacteristicRing, - p3_matrix::Matrix, - BaseAirWithPublicValues, PartitionedBaseAir, -}; -use p3_keccak_air::{KeccakAir, NUM_KECCAK_COLS as NUM_KECCAK_PERM_COLS, U64_LIMBS}; - -use super::{ - columns::{KeccakVmCols, NUM_KECCAK_VM_COLS}, - KECCAK_ABSORB_READS, KECCAK_DIGEST_BYTES, KECCAK_DIGEST_WRITES, KECCAK_RATE_BYTES, - KECCAK_RATE_U16S, KECCAK_REGISTER_READS, KECCAK_WIDTH_U16S, KECCAK_WORD_SIZE, - NUM_ABSORB_ROUNDS, -}; - -#[derive(Clone, Copy, Debug, derive_new::new)] -pub struct KeccakVmAir { - pub execution_bridge: ExecutionBridge, - pub memory_bridge: MemoryBridge, - /// Bus to send 8-bit XOR requests to. - pub bitwise_lookup_bus: BitwiseOperationLookupBus, - /// Maximum number of bits allowed for an address pointer - pub ptr_max_bits: usize, - pub(super) offset: usize, -} - -impl BaseAirWithPublicValues for KeccakVmAir {} -impl PartitionedBaseAir for KeccakVmAir {} -impl BaseAir for KeccakVmAir { - fn width(&self) -> usize { - NUM_KECCAK_VM_COLS - } -} - -impl Air for KeccakVmAir { - fn eval(&self, builder: &mut AB) { - let main = builder.main(); - let (local, next) = ( - main.row_slice(0).expect("window should have two elements"), - main.row_slice(1).expect("window should have two elements"), - ); - let local: &KeccakVmCols = (*local).borrow(); - let next: &KeccakVmCols = (*next).borrow(); - - builder.assert_bool(local.sponge.is_new_start); - builder.assert_eq( - local.sponge.is_new_start, - local.sponge.is_new_start * local.is_first_round(), - ); - builder.assert_eq( - local.instruction.is_enabled_first_round, - local.instruction.is_enabled * local.is_first_round(), - ); - // Not strictly necessary: - builder - .when_first_row() - .assert_one(local.sponge.is_new_start); - - self.eval_keccak_f(builder); - self.constrain_padding(builder, local, next); - self.constrain_consistency_across_rounds(builder, local, next); - - let mem = &local.mem_oc; - // Interactions: - self.constrain_absorb(builder, local, next); - let start_read_timestamp = self.eval_instruction(builder, local, &mem.register_aux); - let start_write_timestamp = - self.constrain_input_read(builder, local, start_read_timestamp, &mem.absorb_reads); - self.constrain_output_write( - builder, - local, - start_write_timestamp.clone(), - &mem.digest_writes, - ); - - self.constrain_block_transition(builder, local, next, start_write_timestamp); - } -} - -impl KeccakVmAir { - /// Evaluate the keccak-f permutation constraints. - /// - /// WARNING: The keccak-f AIR columns **must** be the first columns in the main AIR. - #[inline] - pub fn eval_keccak_f(&self, builder: &mut AB) { - let keccak_f_air = KeccakAir {}; - let mut sub_builder = - SubAirBuilder::::new(builder, 0..NUM_KECCAK_PERM_COLS); - keccak_f_air.eval(&mut sub_builder); - } - - /// Many columns are expected to be the same between rounds and only change per-block. - pub fn constrain_consistency_across_rounds>( - &self, - builder: &mut AB, - local: &KeccakVmCols, - next: &KeccakVmCols, - ) { - let mut transition_builder = builder.when_transition(); - let mut round_builder = transition_builder.when(not(local.is_last_round())); - // Instruction columns - local - .instruction - .assert_eq(&mut round_builder, next.instruction); - } - - pub fn constrain_block_transition>( - &self, - builder: &mut AB, - local: &KeccakVmCols, - next: &KeccakVmCols, - start_write_timestamp: AB::Expr, - ) { - // When we transition between blocks, if the next block isn't a new block - // (this means it's not receiving a new opcode or starting a dummy block) - // then we want _parts_ of opcode instruction to stay the same - // between blocks. - let mut block_transition = builder.when(local.is_last_round() * not(next.is_new_start())); - block_transition.assert_eq(local.instruction.pc, next.instruction.pc); - block_transition.assert_eq(local.instruction.is_enabled, next.instruction.is_enabled); - // dst is only going to be used for writes in the last input block - assert_array_eq( - &mut block_transition, - local.instruction.dst, - next.instruction.dst, - ); - // these are not used and hence not necessary, but putting for safety until performance - // becomes an issue: - block_transition.assert_eq(local.instruction.dst_ptr, next.instruction.dst_ptr); - block_transition.assert_eq(local.instruction.src_ptr, next.instruction.src_ptr); - block_transition.assert_eq(local.instruction.len_ptr, next.instruction.len_ptr); - // no constraint on `instruction.len` because we use `remaining_len` instead - - // Move the src pointer over based on the number of bytes read. - // This should always be RATE_BYTES since it's a non-final block. - block_transition.assert_eq( - next.instruction.src, - local.instruction.src + AB::F::from_usize(KECCAK_RATE_BYTES), - ); - // Advance timestamp by the number of memory accesses from reading - // `dst, src, len` and block input bytes. - block_transition.assert_eq(next.instruction.start_timestamp, start_write_timestamp); - block_transition.assert_eq( - next.instruction.remaining_len, - local.instruction.remaining_len - AB::F::from_usize(KECCAK_RATE_BYTES), - ); - // Padding transition is constrained in `constrain_padding`. - } - - /// Keccak follows the 10*1 padding rule. - /// See Section 5.1 of - /// Note this is the ONLY difference between Keccak and SHA-3 - /// - /// Constrains padding constraints and length between rounds and - /// between blocks. Padding logic is tied to constraints on `is_new_start`. - pub fn constrain_padding( - &self, - builder: &mut AB, - local: &KeccakVmCols, - next: &KeccakVmCols, - ) where - AB::Var: Copy, - { - let is_padding_byte = local.sponge.is_padding_byte; - let block_bytes = &local.sponge.block_bytes; - let remaining_len = local.remaining_len(); - - // is_padding_byte should all be boolean - for &is_padding_byte in is_padding_byte.iter() { - builder.assert_bool(is_padding_byte); - } - // is_padding_byte should transition from 0 to 1 only once and then stay 1 - for i in 1..KECCAK_RATE_BYTES { - builder - .when(is_padding_byte[i - 1]) - .assert_one(is_padding_byte[i]); - } - // is_padding_byte must stay the same on all rounds in a block - // we use next instead of local.step_flags.last() because the last row of the trace overall - // may not end on a last round - let is_last_round = next.inner.step_flags[0]; - let is_not_last_round = not(is_last_round); - for i in 0..KECCAK_RATE_BYTES { - builder.when(is_not_last_round.clone()).assert_eq( - local.sponge.is_padding_byte[i], - next.sponge.is_padding_byte[i], - ); - } - - let num_padding_bytes = local - .sponge - .is_padding_byte - .iter() - .fold(AB::Expr::ZERO, |a, &b| a + b); - - // If final rate block of input, then last byte must be padding - let is_final_block = is_padding_byte[KECCAK_RATE_BYTES - 1]; - - // is_padding_byte must be consistent with remaining_len - builder.when(is_final_block).assert_eq( - remaining_len, - AB::Expr::from_usize(KECCAK_RATE_BYTES) - num_padding_bytes, - ); - // If this block is not final, when transitioning to next block, remaining len - // must decrease by `KECCAK_RATE_BYTES`. - builder - .when(is_last_round) - .when(not(is_final_block)) - .assert_eq( - remaining_len - AB::F::from_usize(KECCAK_RATE_BYTES), - next.remaining_len(), - ); - // To enforce that is_padding_byte must be set appropriately for an input, we require - // the block before a new start to have padding - builder - .when(is_last_round) - .when(next.is_new_start()) - .assert_one(is_final_block); - // Make sure there are not repeated padding blocks - builder - .when(is_last_round) - .when(is_final_block) - .assert_one(next.is_new_start()); - // The chain above enforces that for an input, the remaining length must decrease by RATE - // block-by-block until it reaches a final block with padding. - - // ====== Constrain the block_bytes are padded according to is_padding_byte ===== - - // If the first padding byte is at the end of the block, then the block has a - // single padding byte - let has_single_padding_byte: AB::Expr = - is_padding_byte[KECCAK_RATE_BYTES - 1] - is_padding_byte[KECCAK_RATE_BYTES - 2]; - - // If the row has a single padding byte, then it must be the last byte with - // value 0b10000001 - builder.when(has_single_padding_byte.clone()).assert_eq( - block_bytes[KECCAK_RATE_BYTES - 1], - AB::F::from_u8(0b10000001), - ); - - let has_multiple_padding_bytes: AB::Expr = not(has_single_padding_byte.clone()); - for i in 0..KECCAK_RATE_BYTES - 1 { - let is_first_padding_byte: AB::Expr = { - if i > 0 { - is_padding_byte[i] - is_padding_byte[i - 1] - } else { - is_padding_byte[i].into() - } - }; - // If the row has multiple padding bytes, the first padding byte must be 0x01 - // because the padding 1*0 is *little-endian* - builder - .when(has_multiple_padding_bytes.clone()) - .when(is_first_padding_byte.clone()) - .assert_eq(block_bytes[i], AB::F::from_u8(0x01)); - // If the row has multiple padding bytes, the other padding bytes - // except the last one must be 0 - builder - .when(is_padding_byte[i]) - .when(not::(is_first_padding_byte)) // hence never when single padding byte - .assert_zero(block_bytes[i]); - } - - // If the row has multiple padding bytes, then the last byte must be 0x80 - // because the padding *01 is *little-endian* - builder - .when(is_final_block) - .when(has_multiple_padding_bytes) - .assert_eq(block_bytes[KECCAK_RATE_BYTES - 1], AB::F::from_u8(0x80)); - } - - /// Constrain state transition between keccak-f permutations is valid absorb of input bytes. - /// The end-state in last round is given by `a_prime_prime_prime()` in `u16` limbs. - /// The pre-state is given by `preimage` also in `u16` limbs. - /// The input `block_bytes` will be given as **bytes**. - /// - /// We will XOR `block_bytes` with `a_prime_prime_prime()` and constrain to be `next.preimage`. - /// This will be done using 8-bit XOR lookup in a separate AIR via interactions. - /// This will require decomposing `u16` into bytes. - /// Note that the XOR lookup automatically range checks its inputs to be bytes. - /// - /// We use the following trick to keep `u16` limbs and avoid changing - /// the `keccak-f` AIR itself: - /// if we already have a 16-bit limb `x` and we also provide a 8-bit limb - /// `hi = x >> 8`, assuming `x` and `hi` have been range checked, - /// we can use the expression `lo = x - hi * 256` for the low byte. - /// If `lo` is range checked to `8`-bits, this constrains a valid byte - /// decomposition of `x` into `hi, lo`. - /// This means in terms of trace cells, it is equivalent to provide - /// `x, hi` versus `hi, lo`. - pub fn constrain_absorb( - &self, - builder: &mut AB, - local: &KeccakVmCols, - next: &KeccakVmCols, - ) { - let updated_state_bytes = (0..NUM_ABSORB_ROUNDS).flat_map(|i| { - let y = i / 5; - let x = i % 5; - (0..U64_LIMBS).flat_map(move |limb| { - let state_limb = local.postimage(y, x, limb); - let hi = local.sponge.state_hi[i * U64_LIMBS + limb]; - let lo = state_limb - hi * AB::F::from_u64(1 << 8); - // Conversion from bytes to u64 is little-endian - [lo, hi.into()] - }) - }); - - let post_absorb_state_bytes = (0..NUM_ABSORB_ROUNDS).flat_map(|i| { - let y = i / 5; - let x = i % 5; - (0..U64_LIMBS).flat_map(move |limb| { - let state_limb = next.inner.preimage[y][x][limb]; - let hi = next.sponge.state_hi[i * U64_LIMBS + limb]; - let lo = state_limb - hi * AB::F::from_u64(1 << 8); - [lo, hi.into()] - }) - }); - - // We xor on last round of each block, even if it is a final block, - // because we use xor to range check the output bytes (= updated_state_bytes) - let is_final_block = *local.sponge.is_padding_byte.last().unwrap(); - for (input, prev, post) in izip!( - next.sponge.block_bytes, - updated_state_bytes, - post_absorb_state_bytes - ) { - // Add new send interaction to lookup (x, y, x ^ y) where x, y, z - // will all be range checked to be 8-bits (assuming the bus is - // received by an 8-bit xor chip). - - // When absorb, input ^ prev = post - // Otherwise, 0 ^ prev = prev - // The interaction fields are degree 2, leading to degree 3 constraint - self.bitwise_lookup_bus - .send_xor( - input * not(is_final_block), - prev.clone(), - select(is_final_block, prev, post), - ) - .eval( - builder, - local.is_last_round() * local.instruction.is_enabled, - ); - } - - // We separately constrain that when(local.is_new_start), the preimage (u16s) equals the - // block bytes - let local_preimage_bytes = (0..NUM_ABSORB_ROUNDS).flat_map(|i| { - let y = i / 5; - let x = i % 5; - (0..U64_LIMBS).flat_map(move |limb| { - let state_limb = local.inner.preimage[y][x][limb]; - let hi = local.sponge.state_hi[i * U64_LIMBS + limb]; - let lo = state_limb - hi * AB::F::from_u64(1 << 8); - [lo, hi.into()] - }) - }); - let mut when_is_new_start = - builder.when(local.is_new_start() * local.instruction.is_enabled); - for (preimage_byte, block_byte) in zip(local_preimage_bytes, local.sponge.block_bytes) { - when_is_new_start.assert_eq(preimage_byte, block_byte); - } - - // constrain transition on the state outside rate - let mut reset_builder = builder.when(local.is_new_start()); - for i in KECCAK_RATE_U16S..KECCAK_WIDTH_U16S { - let y = i / U64_LIMBS / 5; - let x = (i / U64_LIMBS) % 5; - let limb = i % U64_LIMBS; - reset_builder.assert_zero(local.inner.preimage[y][x][limb]); - } - let mut absorb_builder = builder.when(local.is_last_round() * not(next.is_new_start())); - for i in KECCAK_RATE_U16S..KECCAK_WIDTH_U16S { - let y = i / U64_LIMBS / 5; - let x = (i / U64_LIMBS) % 5; - let limb = i % U64_LIMBS; - absorb_builder.assert_eq(local.postimage(y, x, limb), next.inner.preimage[y][x][limb]); - } - } - - /// Receive the instruction itself on program bus. Send+receive on execution bus. - /// Then does memory read in addr space 1 to get `dst, src, len` from memory. - /// - /// Adds range check interactions for the most significant limbs of the register values - /// using BitwiseOperationLookupBus. - /// - /// Returns `start_read_timestamp` which is only relevant when `local.instruction.is_enabled`. - /// Note that `start_read_timestamp` is a linear expression. - pub fn eval_instruction( - &self, - builder: &mut AB, - local: &KeccakVmCols, - register_aux: &[MemoryReadAuxCols; KECCAK_REGISTER_READS], - ) -> AB::Expr { - let instruction = local.instruction; - // Only receive opcode if: - // - enabled row (not dummy row) - // - first round of block - // - is_new_start - // Note this is degree 3, which results in quotient degree 2 if used - // as `count` in interaction - let should_receive = local.instruction.is_enabled * local.sponge.is_new_start; - - let [dst_ptr, src_ptr, len_ptr] = [ - instruction.dst_ptr, - instruction.src_ptr, - instruction.len_ptr, - ]; - let reg_addr_sp = AB::F::ONE; - let timestamp_change: AB::Expr = Self::timestamp_change(instruction.remaining_len); - self.execution_bridge - .execute_and_increment_pc( - AB::Expr::from_usize(Rv32KeccakOpcode::KECCAK256 as usize + self.offset), - [ - dst_ptr.into(), - src_ptr.into(), - len_ptr.into(), - reg_addr_sp.into(), - AB::Expr::from_u32(RV32_MEMORY_AS), - ], - ExecutionState::new(instruction.pc, instruction.start_timestamp), - timestamp_change, - ) - .eval(builder, should_receive.clone()); - - let mut timestamp: AB::Expr = instruction.start_timestamp.into(); - let recover_limbs = |limbs: [AB::Var; RV32_REGISTER_NUM_LIMBS - 1], - val: AB::Var| - -> [AB::Expr; RV32_REGISTER_NUM_LIMBS] { - from_fn(|i| { - if i == 0 { - limbs - .into_iter() - .enumerate() - .fold(val.into(), |acc, (j, limb)| { - acc - limb * AB::Expr::from_usize(1 << ((j + 1) * RV32_CELL_BITS)) - }) - } else { - limbs[i - 1].into() - } - }) - }; - // Only when it is an input do we want to do memory read for - // dst <- word[a]_d, src <- word[b]_d - let dst_data = instruction.dst.map(Into::into); - let src_data = recover_limbs(instruction.src_limbs, instruction.src); - let len_data = recover_limbs(instruction.len_limbs, instruction.remaining_len); - for (ptr, value, aux) in izip!( - [dst_ptr, src_ptr, len_ptr], - [dst_data, src_data, len_data], - register_aux, - ) { - self.memory_bridge - .read( - MemoryAddress::new(reg_addr_sp, ptr), - value, - timestamp.clone(), - aux, - ) - .eval(builder, should_receive.clone()); - - timestamp += AB::Expr::ONE; - } - // See Rv32VecHeapAdapterAir - // repeat len for even number - // We range check `len` to `max_ptr_bits` to ensure `remaining_len` doesn't overflow. - // We could range check it to some other size, but `max_ptr_bits` is convenient. - let need_range_check = [ - *instruction.dst.last().unwrap(), - *instruction.src_limbs.last().unwrap(), - *instruction.len_limbs.last().unwrap(), - *instruction.len_limbs.last().unwrap(), - ]; - let limb_shift = - AB::F::from_usize(1 << (RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - self.ptr_max_bits)); - for pair in need_range_check.chunks_exact(2) { - self.bitwise_lookup_bus - .send_range(pair[0] * limb_shift, pair[1] * limb_shift) - .eval(builder, should_receive.clone()); - } - - timestamp - } - - /// Constrain reading the input as `block_bytes` from memory. - /// Reads input based on `is_padding_byte`. - /// Constrains timestamp transitions between blocks if input crosses blocks. - /// - /// Expects `start_read_timestamp` to be a linear expression. - /// Returns the `start_write_timestamp` which is the timestamp to start from - /// for writing digest to memory. - pub fn constrain_input_read( - &self, - builder: &mut AB, - local: &KeccakVmCols, - start_read_timestamp: AB::Expr, - mem_aux: &[MemoryReadAuxCols; KECCAK_ABSORB_READS], - ) -> AB::Expr { - let partial_block = &local.mem_oc.partial_block; - // Only read input from memory when it is an opcode-related row - // and only on the first round of block - let is_input = local.instruction.is_enabled_first_round; - - let mut timestamp = start_read_timestamp; - // read `state` into `word[src + ...]_e` - // iterator of state as u16: - for (i, (input, is_padding, mem_aux)) in izip!( - local.sponge.block_bytes.chunks_exact(KECCAK_WORD_SIZE), - local.sponge.is_padding_byte.chunks_exact(KECCAK_WORD_SIZE), - mem_aux - ) - .enumerate() - { - let ptr = local.instruction.src + AB::F::from_usize(i * KECCAK_WORD_SIZE); - // Only read block i if it is not entirely padding bytes - // count is degree 2 - let count = is_input * not(is_padding[0]); - // The memory block read is partial if first byte is not padding but the last byte is - // padding. Since `count` is only 1 when first byte isn't padding, use check just if - // last byte is padding. - let is_partial_read = *is_padding.last().unwrap(); - // word is degree 2 - let word: [_; KECCAK_WORD_SIZE] = from_fn(|i| { - if i == 0 { - // first byte is always ok - input[0].into() - } else { - // use `partial_block` if this is a partial read, otherwise use the normal input - // block - select(is_partial_read, partial_block[i - 1], input[i]) - } - }); - for i in 1..KECCAK_WORD_SIZE { - let not_padding: AB::Expr = not(is_padding[i]); - // When not a padding byte, the word byte and input byte must be equal - // This is constraint degree 3 - builder.assert_eq( - not_padding.clone() * word[i].clone(), - not_padding.clone() * input[i], - ); - } - - self.memory_bridge - .read( - MemoryAddress::new(AB::Expr::from_u32(RV32_MEMORY_AS), ptr), - word, // degree 2 - timestamp.clone(), - mem_aux, - ) - .eval(builder, count); - - timestamp += AB::Expr::ONE; - } - timestamp - } - - pub fn constrain_output_write( - &self, - builder: &mut AB, - local: &KeccakVmCols, - start_write_timestamp: AB::Expr, - mem_aux: &[MemoryWriteAuxCols; KECCAK_DIGEST_WRITES], - ) { - let instruction = local.instruction; - - let is_final_block = *local.sponge.is_padding_byte.last().unwrap(); - // since keccak-f AIR has this column, we might as well use it - builder.assert_eq( - local.inner.export, - instruction.is_enabled * is_final_block * local.is_last_round(), - ); - // See `constrain_absorb` on how we derive the postimage bytes from u16 limbs - // **SAFETY:** we always XOR the final state with 0 in `constrain_absorb`, - // so the output bytes **are** range checked. - let updated_state_bytes = (0..NUM_ABSORB_ROUNDS).flat_map(|i| { - let y = i / 5; - let x = i % 5; - (0..U64_LIMBS).flat_map(move |limb| { - let state_limb = local.postimage(y, x, limb); - let hi = local.sponge.state_hi[i * U64_LIMBS + limb]; - let lo = state_limb - hi * AB::F::from_u64(1 << 8); - // Conversion from bytes to u64 is little-endian - [lo, hi.into()] - }) - }); - let dst = abstract_compose::(instruction.dst); - for (i, digest_bytes) in updated_state_bytes - .take(KECCAK_DIGEST_BYTES) - .chunks(KECCAK_WORD_SIZE) - .into_iter() - .enumerate() - { - let digest_bytes = digest_bytes.collect_vec(); - let timestamp = start_write_timestamp.clone() + AB::Expr::from_usize(i); - self.memory_bridge - .write( - MemoryAddress::new( - AB::Expr::from_u32(RV32_MEMORY_AS), - dst.clone() + AB::F::from_usize(i * KECCAK_WORD_SIZE), - ), - digest_bytes.try_into().unwrap(), - timestamp, - &mem_aux[i], - ) - .eval(builder, local.inner.export) - } - } - - /// Amount to advance timestamp by after execution of one opcode instruction. - /// This is an upper bound dependent on the length `len` operand, which is unbounded. - pub fn timestamp_change(len: impl Into) -> T { - // actual number is ceil(len / 136) * (3 + 17) + KECCAK_DIGEST_WRITES - // digest writes only done on last row of multi-block - // add another KECCAK_ABSORB_READS to round up so we don't deal with padding - len.into() - + T::from_usize(KECCAK_REGISTER_READS + KECCAK_ABSORB_READS + KECCAK_DIGEST_WRITES) - } -} diff --git a/extensions/keccak256/circuit/src/columns.rs b/extensions/keccak256/circuit/src/columns.rs deleted file mode 100644 index a14ba4dcea..0000000000 --- a/extensions/keccak256/circuit/src/columns.rs +++ /dev/null @@ -1,153 +0,0 @@ -use core::mem::size_of; - -use openvm_circuit::system::memory::offline_checker::{MemoryReadAuxCols, MemoryWriteAuxCols}; -use openvm_circuit_primitives::utils::assert_array_eq; -use openvm_circuit_primitives_derive::AlignedBorrow; -use openvm_instructions::riscv::RV32_REGISTER_NUM_LIMBS; -use openvm_stark_backend::p3_air::AirBuilder; -use p3_keccak_air::KeccakCols as KeccakPermCols; - -use super::{ - KECCAK_ABSORB_READS, KECCAK_DIGEST_WRITES, KECCAK_RATE_BYTES, KECCAK_RATE_U16S, - KECCAK_REGISTER_READS, KECCAK_WORD_SIZE, -}; - -#[repr(C)] -#[derive(Debug, AlignedBorrow)] -pub struct KeccakVmCols { - /// Columns for keccak-f permutation - pub inner: KeccakPermCols, - /// Columns for sponge and padding - pub sponge: KeccakSpongeCols, - /// Columns for instruction interface and register access - pub instruction: KeccakInstructionCols, - /// Auxiliary columns for offline memory checking - pub mem_oc: KeccakMemoryCols, -} - -/// Columns for KECCAK256_RV32 instruction parsing. -/// Includes columns for instruction execution and register reads. -#[allow(clippy::too_many_arguments)] -#[repr(C)] -#[derive(Copy, Clone, Debug, Default, AlignedBorrow, derive_new::new)] -pub struct KeccakInstructionCols { - /// Program counter - pub pc: T, - /// True for all rows that are part of opcode execution. - /// False on dummy rows only used to pad the height. - pub is_enabled: T, - /// Is enabled and first round of block. Used to lower constraint degree. - /// is_enabled * inner.step_flags\[0\] - pub is_enabled_first_round: T, - /// The starting timestamp to use for memory access in this row. - /// A single row will do multiple memory accesses. - pub start_timestamp: T, - /// Pointer to address space 1 `dst` register - pub dst_ptr: T, - /// Pointer to address space 1 `src` register - pub src_ptr: T, - /// Pointer to address space 1 `len` register - pub len_ptr: T, - // Register values - /// dst <- \[dst_ptr:4\]_1 - pub dst: [T; RV32_REGISTER_NUM_LIMBS], - /// src <- \[src_ptr:4\]_1 - /// We store src_limbs\[i\] = \[src_ptr + i + 1\]_1 and src = u32(\[src_ptr:4\]_1) from which - /// \[src_ptr\]_1 can be recovered by linear combination. - /// We do this because `src` needs to be incremented between keccak-f permutations. - pub src_limbs: [T; RV32_REGISTER_NUM_LIMBS - 1], - pub src: T, - /// len <- \[len_ptr:4\]_1 - /// We store len_limbs\[i\] = \[len_ptr + i + 1\]_1 and remaining_len = u32(\[len_ptr:4\]_1) - /// from which \[len_ptr\]_1 can be recovered by linear combination. - /// We do this because `remaining_len` needs to be decremented between keccak-f permutations. - pub len_limbs: [T; RV32_REGISTER_NUM_LIMBS - 1], - /// The remaining length of the unpadded input, in bytes. - /// If `is_new_start` is true and `is_enabled` is true, this must be equal to `u32(len)`. - pub remaining_len: T, -} - -#[repr(C)] -#[derive(Clone, Copy, Debug, AlignedBorrow)] -pub struct KeccakSpongeCols { - /// Only used on first row of a round to determine whether the state - /// prior to absorb should be reset to all 0s. - /// Constrained to be zero if not first round. - pub is_new_start: T, - - /// Whether the current byte is a padding byte. - /// - /// If this row represents a full input block, this should contain all 0s. - pub is_padding_byte: [T; KECCAK_RATE_BYTES], - - /// The block being absorbed, which may contain input bytes and padding - /// bytes. - pub block_bytes: [T; KECCAK_RATE_BYTES], - - /// For each of the first [KECCAK_RATE_U16S] `u16` limbs in the state, - /// the most significant byte of the limb. - /// Here `state` is the postimage state if last round and the preimage - /// state if first round. It can be junk if not first or last round. - pub state_hi: [T; KECCAK_RATE_U16S], -} - -#[repr(C)] -#[derive(Clone, Debug, AlignedBorrow)] -pub struct KeccakMemoryCols { - pub register_aux: [MemoryReadAuxCols; KECCAK_REGISTER_READS], - pub absorb_reads: [MemoryReadAuxCols; KECCAK_ABSORB_READS], - pub digest_writes: [MemoryWriteAuxCols; KECCAK_DIGEST_WRITES], - /// The input bytes are batch read in blocks of private constant KECCAK_WORD_SIZE bytes. - /// However if the input length is not a multiple of KECCAK_WORD_SIZE, we read into - /// `partial_block` more bytes than we need. On the other hand `block_bytes` expects - /// only the partial block of bytes and then the correctly padded bytes. - /// We will select between `partial_block` and `block_bytes` for what to read from memory. - /// We never read a full padding block, so the first byte is always ok. - pub partial_block: [T; KECCAK_WORD_SIZE - 1], -} - -impl KeccakVmCols { - pub const fn remaining_len(&self) -> T { - self.instruction.remaining_len - } - - pub const fn is_new_start(&self) -> T { - self.sponge.is_new_start - } - - pub fn postimage(&self, y: usize, x: usize, limb: usize) -> T { - self.inner.a_prime_prime_prime(y, x, limb) - } - - pub fn is_first_round(&self) -> T { - *self.inner.step_flags.first().unwrap() - } - - pub fn is_last_round(&self) -> T { - *self.inner.step_flags.last().unwrap() - } -} - -impl KeccakInstructionCols { - pub fn assert_eq(&self, builder: &mut AB, other: Self) - where - T: Into, - { - builder.assert_eq(self.pc, other.pc); - builder.assert_eq(self.is_enabled, other.is_enabled); - builder.assert_eq(self.start_timestamp, other.start_timestamp); - builder.assert_eq(self.dst_ptr, other.dst_ptr); - builder.assert_eq(self.src_ptr, other.src_ptr); - builder.assert_eq(self.len_ptr, other.len_ptr); - assert_array_eq(builder, self.dst, other.dst); - assert_array_eq(builder, self.src_limbs, other.src_limbs); - builder.assert_eq(self.src, other.src); - assert_array_eq(builder, self.len_limbs, other.len_limbs); - builder.assert_eq(self.remaining_len, other.remaining_len); - } -} - -pub const NUM_KECCAK_VM_COLS: usize = size_of::>(); -pub const NUM_KECCAK_INSTRUCTION_COLS: usize = size_of::>(); -pub const NUM_KECCAK_SPONGE_COLS: usize = size_of::>(); -pub const NUM_KECCAK_MEMORY_COLS: usize = size_of::>(); diff --git a/extensions/keccak256/circuit/src/constants.rs b/extensions/keccak256/circuit/src/constants.rs new file mode 100644 index 0000000000..05de87ea90 --- /dev/null +++ b/extensions/keccak256/circuit/src/constants.rs @@ -0,0 +1,28 @@ +// ==== VM-specific constants ==== +/// Number of cells to read/write in a single memory access +pub const KECCAK_WORD_SIZE: usize = 4; +/// The number of memory blocks needed to access the entire keccakf state. +pub const KECCAK_WIDTH_WORDS: usize = KECCAK_WIDTH_BYTES / KECCAK_WORD_SIZE; + +// ==== Do not change these constants! ==== +/// Total number of sponge bytes: number of rate bytes + number of capacity +/// bytes. +pub const KECCAK_WIDTH_BYTES: usize = 200; +/// Total number of 16-bit limbs in the sponge. +pub const KECCAK_WIDTH_U16S: usize = KECCAK_WIDTH_BYTES / 2; +/// Total number of 64-bit limbs in the sponge. +pub const KECCAK_WIDTH_U64S: usize = KECCAK_WIDTH_BYTES / 8; +/// Number of rate bytes. +pub const KECCAK_RATE_BYTES: usize = 136; +/// Number of 16-bit rate limbs. +pub const KECCAK_RATE_U16S: usize = KECCAK_RATE_BYTES / 2; +/// Number of absorb rounds, equal to rate in u64s. +pub const NUM_ABSORB_ROUNDS: usize = KECCAK_RATE_BYTES / 8; +/// Number of capacity bytes. +pub const KECCAK_CAPACITY_BYTES: usize = 64; +/// Number of 16-bit capacity limbs. +pub const KECCAK_CAPACITY_U16S: usize = KECCAK_CAPACITY_BYTES / 2; +/// Number of output digest bytes used during the squeezing phase. +pub const KECCAK_DIGEST_BYTES: usize = 32; +/// Number of 64-bit digest limbs. +pub const KECCAK_DIGEST_U64S: usize = KECCAK_DIGEST_BYTES / 8; diff --git a/extensions/keccak256/circuit/src/cuda/cuda_abi.rs b/extensions/keccak256/circuit/src/cuda/cuda_abi.rs index adc8efd22c..cb6869e014 100644 --- a/extensions/keccak256/circuit/src/cuda/cuda_abi.rs +++ b/extensions/keccak256/circuit/src/cuda/cuda_abi.rs @@ -1,122 +1,133 @@ -#![allow(clippy::missing_safety_doc)] - use openvm_cuda_backend::prelude::F; -use openvm_cuda_common::{d_buffer::DeviceBuffer, error::CudaError}; +use openvm_cuda_common::{ + d_buffer::{DeviceBuffer, DeviceBufferView}, + error::CudaError, +}; -pub mod keccak256 { +pub mod xorin { use super::*; extern "C" { - fn _keccakf_kernel( - d_records: *const u8, - num_records: usize, - d_record_offsets: *const usize, - d_block_offsets: *const u32, - total_num_blocks: u32, - d_states: *mut u64, - d_bitwise_lookup: *mut u32, - bitwise_num_bits: u32, - ) -> i32; - - fn _keccak256_p3_tracegen( - d_trace: *mut F, - height: usize, - total_num_blocks: u32, - d_states: *mut u64, - ) -> i32; - - fn _keccak256_tracegen( + fn _xorin_tracegen( d_trace: *mut F, height: usize, - d_records: *const u8, - num_records: usize, - d_record_offsets: *const usize, - d_block_offsets: *const u32, - d_block_to_record_idx: *const u32, - total_num_blocks: u32, - d_states: *const u64, - rows_used: usize, - ptr_max_bits: u32, + width: usize, + d_records: DeviceBufferView, d_range_checker: *mut u32, range_checker_num_bins: u32, - d_bitwise_lookup: *mut u32, - bitwise_num_bits: u32, + d_bitwise_lookup: *const u32, + bitwise_num_bits: usize, + pointer_max_bits: u32, timestamp_max_bits: u32, ) -> i32; } + /// # Safety + /// All device buffers must be valid and properly allocated. #[allow(clippy::too_many_arguments)] - pub unsafe fn keccakf( + pub unsafe fn tracegen( + d_trace: &DeviceBuffer, + height: usize, d_records: &DeviceBuffer, - records_num: usize, - d_record_offsets: &DeviceBuffer, - d_block_offsets: &DeviceBuffer, - total_num_blocks: u32, - d_states: &DeviceBuffer, + d_range_checker: &DeviceBuffer, d_bitwise_lookup: &DeviceBuffer, bitwise_num_bits: usize, + pointer_max_bits: u32, + timestamp_max_bits: u32, ) -> Result<(), CudaError> { - CudaError::from_result(_keccakf_kernel( - d_records.as_ptr(), - records_num, - d_record_offsets.as_ptr(), - d_block_offsets.as_ptr(), - total_num_blocks, - d_states.as_mut_ptr(), + assert!(height.is_power_of_two() || height == 0); + CudaError::from_result(_xorin_tracegen( + d_trace.as_mut_ptr(), + height, + d_trace.len() / height, + d_records.view(), + d_range_checker.as_mut_ptr() as *mut u32, + d_range_checker.len() as u32, d_bitwise_lookup.as_mut_ptr() as *mut u32, - bitwise_num_bits as u32, + bitwise_num_bits, + pointer_max_bits, + timestamp_max_bits, )) } +} - pub unsafe fn p3_tracegen( - d_trace: &DeviceBuffer, - height: usize, - total_num_blocks: u32, - d_states: &DeviceBuffer, - ) -> Result<(), CudaError> { - CudaError::from_result(_keccak256_p3_tracegen( - d_trace.as_mut_ptr(), - height, - total_num_blocks, - d_states.as_mut_ptr(), - )) +/// FFI bindings for the new KeccakfOpChip GPU kernel +pub mod keccakf_op { + use super::*; + + extern "C" { + fn _keccakf_op_tracegen( + d_trace: *mut F, + height: usize, + width: usize, + d_records: DeviceBufferView, + d_range_checker: *mut u32, + range_checker_num_bins: u32, + d_bitwise_lookup: *const u32, + bitwise_num_bits: usize, + pointer_max_bits: u32, + timestamp_max_bits: u32, + ) -> i32; } + /// # Safety + /// All device buffers must be valid and properly allocated. #[allow(clippy::too_many_arguments)] pub unsafe fn tracegen( d_trace: &DeviceBuffer, height: usize, d_records: &DeviceBuffer, - records_num: usize, - d_record_offsets: &DeviceBuffer, - d_block_offsets: &DeviceBuffer, - d_block_to_record_idx: &DeviceBuffer, - total_num_blocks: u32, - d_states: &DeviceBuffer, - rows_used: usize, - ptr_max_bits: u32, d_range_checker: &DeviceBuffer, d_bitwise_lookup: &DeviceBuffer, bitwise_num_bits: usize, + pointer_max_bits: u32, timestamp_max_bits: u32, ) -> Result<(), CudaError> { - CudaError::from_result(_keccak256_tracegen( + assert!(height.is_power_of_two() || height == 0); + CudaError::from_result(_keccakf_op_tracegen( d_trace.as_mut_ptr(), height, - d_records.as_ptr(), - records_num, - d_record_offsets.as_ptr(), - d_block_offsets.as_ptr(), - d_block_to_record_idx.as_ptr(), - total_num_blocks, - d_states.as_ptr(), - rows_used, - ptr_max_bits, + d_trace.len() / height, + d_records.view(), d_range_checker.as_mut_ptr() as *mut u32, d_range_checker.len() as u32, d_bitwise_lookup.as_mut_ptr() as *mut u32, - bitwise_num_bits as u32, + bitwise_num_bits, + pointer_max_bits, timestamp_max_bits, )) } } + +/// FFI bindings for the new KeccakfPermChip GPU kernel +pub mod keccakf_perm { + use super::*; + + extern "C" { + fn _keccakf_perm_tracegen( + d_trace: *mut F, + height: usize, + width: usize, + d_records: DeviceBufferView, + num_records: usize, + ) -> i32; + } + + /// # Safety + /// All device buffers must be valid and properly allocated. + pub unsafe fn tracegen( + d_trace: &DeviceBuffer, + height: usize, + d_records: &DeviceBuffer, + num_records: usize, + ) -> Result<(), CudaError> { + assert!(height.is_power_of_two() || height == 0); + CudaError::from_result(_keccakf_perm_tracegen( + d_trace.as_mut_ptr(), + height, + d_trace.len() / height, + d_records.view(), + num_records, + )) + } +} diff --git a/extensions/keccak256/circuit/src/cuda/mod.rs b/extensions/keccak256/circuit/src/cuda/mod.rs index 635610c856..1575d77b4c 100644 --- a/extensions/keccak256/circuit/src/cuda/mod.rs +++ b/extensions/keccak256/circuit/src/cuda/mod.rs @@ -1,114 +1,182 @@ -use std::{iter::repeat_n, sync::Arc}; +use std::{ + mem::size_of, + sync::{Arc, Mutex}, +}; use derive_new::new; -use openvm_circuit::arch::{DenseRecordArena, MultiRowLayout, RecordSeeker}; +use openvm_circuit::{arch::DenseRecordArena, utils::next_power_of_two_or_zero}; use openvm_circuit_primitives::{ - bitwise_op_lookup::BitwiseOperationLookupChipGPU, utils::next_power_of_two_or_zero, - var_range::VariableRangeCheckerChipGPU, Chip, + bitwise_op_lookup::BitwiseOperationLookupChipGPU, var_range::VariableRangeCheckerChipGPU, +}; +use openvm_cuda_backend::{ + base::DeviceMatrix, chip::get_empty_air_proving_ctx, prelude::F, prover_backend::GpuBackend, + GpuBackend, }; -use openvm_cuda_backend::{base::DeviceMatrix, prelude::F, GpuBackend}; use openvm_cuda_common::{copy::MemCopyH2D, d_buffer::DeviceBuffer}; use openvm_instructions::riscv::RV32_CELL_BITS; use openvm_stark_backend::prover::AirProvingContext; use p3_keccak_air::NUM_ROUNDS; use crate::{ - columns::NUM_KECCAK_VM_COLS, - trace::{KeccakVmMetadata, KeccakVmRecordMut}, - utils::num_keccak_f, + keccakf_op::{columns::NUM_KECCAKF_OP_COLS, trace::KeccakfRecord, NUM_OP_ROWS_PER_INS}, + keccakf_perm::NUM_KECCAKF_PERM_COLS, + xorin::{columns::NUM_XORIN_VM_COLS, trace::XorinVmRecordHeader}, }; mod cuda_abi; -use cuda_abi::keccak256::*; + +// ========================== XorinVmChipGpu ========================== #[derive(new)] -pub struct Keccak256ChipGpu { +pub struct XorinVmChipGpu { pub range_checker: Arc, pub bitwise_lookup: Arc>, - pub ptr_max_bits: u32, + pub pointer_max_bits: usize, pub timestamp_max_bits: u32, } -impl Chip for Keccak256ChipGpu { - fn generate_proving_ctx(&self, mut arena: DenseRecordArena) -> AirProvingContext { - let records = arena.allocated_mut(); +impl Chip for XorinVmChipGpu { + fn generate_proving_ctx(&self, arena: DenseRecordArena) -> AirProvingContext { + const RECORD_SIZE: usize = size_of::(); + let records = arena.allocated(); if records.is_empty() { return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); } + debug_assert_eq!(records.len() % RECORD_SIZE, 0); - let mut record_offsets = Vec::::new(); - let mut block_to_record_idx = Vec::::new(); - let mut block_offsets = Vec::::new(); - let mut offset_so_far = 0; - let mut num_blocks_so_far = 0; - while offset_so_far < records.len() { - record_offsets.push(offset_so_far); - block_offsets.push(num_blocks_so_far); - - let record = RecordSeeker::< - DenseRecordArena, - KeccakVmRecordMut, - MultiRowLayout, - >::get_record_at(&mut offset_so_far, records); - - let num_blocks = num_keccak_f(record.inner.len as usize); - let record_idx = record_offsets.len() - 1; - block_to_record_idx.extend(repeat_n(record_idx as u32, num_blocks)); - num_blocks_so_far += num_blocks as u32; - } - assert_eq!(num_blocks_so_far as usize, block_to_record_idx.len()); - assert_eq!(offset_so_far, records.len()); - assert_eq!(block_offsets.len(), record_offsets.len()); + let trace_width = NUM_XORIN_VM_COLS; + let trace_height = next_power_of_two_or_zero(records.len() / RECORD_SIZE); - let records_num = record_offsets.len(); let d_records = records.to_device().unwrap(); - let d_record_offsets = record_offsets.to_device().unwrap(); - let d_block_offsets = block_offsets.to_device().unwrap(); - let d_block_to_record_idx = block_to_record_idx.to_device().unwrap(); - - let rows_used = num_blocks_so_far as usize * NUM_ROUNDS; - let trace_height = next_power_of_two_or_zero(rows_used); - let trace = DeviceMatrix::::with_capacity(trace_height, NUM_KECCAK_VM_COLS); - - // We store state + keccakf(state) for each block - let states_num = 2 * num_blocks_so_far as usize; - let d_states = DeviceBuffer::::with_capacity(states_num * 25); + let d_trace = DeviceMatrix::::with_capacity(trace_height, trace_width); unsafe { - keccakf( + cuda_abi::xorin::tracegen( + d_trace.buffer(), + trace_height, &d_records, - records_num, - &d_record_offsets, - &d_block_offsets, - num_blocks_so_far, - &d_states, + &self.range_checker.count, &self.bitwise_lookup.count, RV32_CELL_BITS, + self.pointer_max_bits as u32, + self.timestamp_max_bits, ) .unwrap(); + } + + AirProvingContext::simple_no_pis(d_trace) + } +} + +// ========================== Shared state for KeccakfOp <-> KeccakfPerm ========================== + +/// Shared state to pass records from KeccakfOpChipGpu to KeccakfPermChipGpu +/// The OpChip generates first and stores the device buffer, then PermChip takes it. +#[derive(Default)] +pub struct SharedKeccakfRecords { + /// Device buffer containing records (set by OpChip, consumed by PermChip) + pub d_records: Option>, + /// Number of records + pub num_records: usize, +} + +pub type SharedKeccakfRecordsGpu = Arc>; + +// ========================== KeccakfOpChipGpu ========================== + +#[derive(new)] +pub struct KeccakfOpChipGpu { + pub range_checker: Arc, + pub bitwise_lookup: Arc>, + pub pointer_max_bits: usize, + pub timestamp_max_bits: u32, + pub shared_records: SharedKeccakfRecordsGpu, +} + +impl Chip for KeccakfOpChipGpu { + fn generate_proving_ctx(&self, arena: DenseRecordArena) -> AirProvingContext { + const RECORD_SIZE: usize = size_of::(); + let records = arena.allocated(); + if records.is_empty() { + // Store empty state for PermChip + let mut shared = self.shared_records.lock().unwrap(); + shared.d_records = None; + shared.num_records = 0; + return get_empty_air_proving_ctx::(); + } + debug_assert_eq!(records.len() % RECORD_SIZE, 0); + + let num_records = records.len() / RECORD_SIZE; + let trace_width = NUM_KECCAKF_OP_COLS; + let trace_height = next_power_of_two_or_zero(num_records * NUM_OP_ROWS_PER_INS); - p3_tracegen(trace.buffer(), trace_height, num_blocks_so_far, &d_states).unwrap(); + // Transfer records to GPU + let d_records = records.to_device().unwrap(); + let d_trace = DeviceMatrix::::with_capacity(trace_height, trace_width); - tracegen( - trace.buffer(), + unsafe { + cuda_abi::keccakf_op::tracegen( + d_trace.buffer(), trace_height, &d_records, - records_num, - &d_record_offsets, - &d_block_offsets, - &d_block_to_record_idx, - num_blocks_so_far, - &d_states, - rows_used, - self.ptr_max_bits, &self.range_checker.count, &self.bitwise_lookup.count, RV32_CELL_BITS, + self.pointer_max_bits as u32, self.timestamp_max_bits, ) .unwrap(); } - AirProvingContext::simple_no_pis(trace) + // Store records in shared state for PermChip + { + let mut shared = self.shared_records.lock().unwrap(); + shared.d_records = Some(d_records); + shared.num_records = num_records; + } + + AirProvingContext::simple_no_pis(d_trace) + } +} + +// ========================== KeccakfPermChipGpu ========================== + +#[derive(new)] +pub struct KeccakfPermChipGpu { + pub shared_records: SharedKeccakfRecordsGpu, +} + +impl Chip for KeccakfPermChipGpu { + fn generate_proving_ctx(&self, _arena: DenseRecordArena) -> AirProvingContext { + // Take records from shared state (set by OpChip) + let (d_records, num_records) = { + let mut shared = self.shared_records.lock().unwrap(); + (shared.d_records.take(), shared.num_records) + }; + + let Some(d_records) = d_records else { + return get_empty_air_proving_ctx::(); + }; + + if num_records == 0 { + return get_empty_air_proving_ctx::(); + } + + let trace_width = NUM_KECCAKF_PERM_COLS; + let trace_height = next_power_of_two_or_zero(num_records * NUM_ROUNDS); + + let d_trace = DeviceMatrix::::with_capacity(trace_height, trace_width); + + unsafe { + cuda_abi::keccakf_perm::tracegen( + d_trace.buffer(), + trace_height, + &d_records, + num_records, + ) + .unwrap(); + } + + AirProvingContext::simple_no_pis(d_trace) } } diff --git a/extensions/keccak256/circuit/src/execution.rs b/extensions/keccak256/circuit/src/execution.rs deleted file mode 100644 index 025786c685..0000000000 --- a/extensions/keccak256/circuit/src/execution.rs +++ /dev/null @@ -1,203 +0,0 @@ -use std::{ - borrow::{Borrow, BorrowMut}, - mem::size_of, -}; - -use openvm_circuit::{arch::*, system::memory::online::GuestMemory}; -use openvm_circuit_primitives_derive::AlignedBytesBorrow; -use openvm_instructions::{ - instruction::Instruction, - program::DEFAULT_PC_STEP, - riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, - LocalOpcode, -}; -use openvm_keccak256_transpiler::Rv32KeccakOpcode; -use openvm_stark_backend::p3_field::PrimeField32; -use p3_keccak_air::NUM_ROUNDS; - -use super::{KeccakVmExecutor, KECCAK_WORD_SIZE}; -use crate::utils::{keccak256, num_keccak_f}; - -#[derive(AlignedBytesBorrow, Clone)] -#[repr(C)] -struct KeccakPreCompute { - a: u8, - b: u8, - c: u8, -} - -impl KeccakVmExecutor { - fn pre_compute_impl( - &self, - pc: u32, - inst: &Instruction, - data: &mut KeccakPreCompute, - ) -> Result<(), StaticProgramError> { - let Instruction { - opcode, - a, - b, - c, - d, - e, - .. - } = inst; - let e_u32 = e.as_canonical_u32(); - if d.as_canonical_u32() != RV32_REGISTER_AS || e_u32 != RV32_MEMORY_AS { - return Err(StaticProgramError::InvalidInstruction(pc)); - } - *data = KeccakPreCompute { - a: a.as_canonical_u32() as u8, - b: b.as_canonical_u32() as u8, - c: c.as_canonical_u32() as u8, - }; - assert_eq!(&Rv32KeccakOpcode::KECCAK256.global_opcode(), opcode); - Ok(()) - } -} - -impl InterpreterExecutor for KeccakVmExecutor { - fn pre_compute_size(&self) -> usize { - size_of::() - } - - #[cfg(not(feature = "tco"))] - fn pre_compute( - &self, - pc: u32, - inst: &Instruction, - data: &mut [u8], - ) -> Result, StaticProgramError> - where - Ctx: ExecutionCtxTrait, - { - let data: &mut KeccakPreCompute = data.borrow_mut(); - self.pre_compute_impl(pc, inst, data)?; - Ok(execute_e1_impl::<_, _>) - } - - #[cfg(feature = "tco")] - fn handler( - &self, - pc: u32, - inst: &Instruction, - data: &mut [u8], - ) -> Result, StaticProgramError> - where - Ctx: ExecutionCtxTrait, - { - let data: &mut KeccakPreCompute = data.borrow_mut(); - self.pre_compute_impl(pc, inst, data)?; - Ok(execute_e1_handler) - } -} - -#[cfg(feature = "aot")] -impl AotExecutor for KeccakVmExecutor {} - -impl InterpreterMeteredExecutor for KeccakVmExecutor { - fn metered_pre_compute_size(&self) -> usize { - size_of::>() - } - - #[cfg(not(feature = "tco"))] - fn metered_pre_compute( - &self, - chip_idx: usize, - pc: u32, - inst: &Instruction, - data: &mut [u8], - ) -> Result, StaticProgramError> - where - Ctx: MeteredExecutionCtxTrait, - { - let data: &mut E2PreCompute = data.borrow_mut(); - data.chip_idx = chip_idx as u32; - self.pre_compute_impl(pc, inst, &mut data.data)?; - Ok(execute_e2_impl::<_, _>) - } - - #[cfg(feature = "tco")] - fn metered_handler( - &self, - chip_idx: usize, - pc: u32, - inst: &Instruction, - data: &mut [u8], - ) -> Result, StaticProgramError> - where - Ctx: MeteredExecutionCtxTrait, - { - let data: &mut E2PreCompute = data.borrow_mut(); - data.chip_idx = chip_idx as u32; - self.pre_compute_impl(pc, inst, &mut data.data)?; - Ok(execute_e2_handler::<_, _>) - } -} -#[cfg(feature = "aot")] -impl AotMeteredExecutor for KeccakVmExecutor {} - -#[inline(always)] -unsafe fn execute_e12_impl( - pre_compute: &KeccakPreCompute, - exec_state: &mut VmExecState, -) -> u32 { - let dst = exec_state.vm_read(RV32_REGISTER_AS, pre_compute.a as u32); - let src = exec_state.vm_read(RV32_REGISTER_AS, pre_compute.b as u32); - let len = exec_state.vm_read(RV32_REGISTER_AS, pre_compute.c as u32); - let dst_u32 = u32::from_le_bytes(dst); - let src_u32 = u32::from_le_bytes(src); - let len_u32 = u32::from_le_bytes(len); - - let (output, height) = if IS_E1 { - // SAFETY: RV32_MEMORY_AS is memory address space of type u8 - let message = exec_state.vm_read_slice(RV32_MEMORY_AS, src_u32, len_u32 as usize); - let output = keccak256(message); - (output, 0) - } else { - let num_reads = (len_u32 as usize).div_ceil(KECCAK_WORD_SIZE); - let message: Vec<_> = (0..num_reads) - .flat_map(|i| { - exec_state.vm_read::( - RV32_MEMORY_AS, - src_u32 + (i * KECCAK_WORD_SIZE) as u32, - ) - }) - .collect(); - let output = keccak256(&message[..len_u32 as usize]); - let height = (num_keccak_f(len_u32 as usize) * NUM_ROUNDS) as u32; - (output, height) - }; - exec_state.vm_write(RV32_MEMORY_AS, dst_u32, &output); - - let pc = exec_state.pc(); - exec_state.set_pc(pc.wrapping_add(DEFAULT_PC_STEP)); - - height -} - -#[create_handler] -#[inline(always)] -unsafe fn execute_e1_impl( - pre_compute: *const u8, - exec_state: &mut VmExecState, -) { - let pre_compute: &KeccakPreCompute = - std::slice::from_raw_parts(pre_compute, size_of::()).borrow(); - execute_e12_impl::(pre_compute, exec_state); -} - -#[create_handler] -#[inline(always)] -unsafe fn execute_e2_impl( - pre_compute: *const u8, - exec_state: &mut VmExecState, -) { - let pre_compute: &E2PreCompute = - std::slice::from_raw_parts(pre_compute, size_of::>()) - .borrow(); - let height = execute_e12_impl::(&pre_compute.data, exec_state); - exec_state - .ctx - .on_height_change(pre_compute.chip_idx as usize, height); -} diff --git a/extensions/keccak256/circuit/src/extension/cuda.rs b/extensions/keccak256/circuit/src/extension/cuda.rs index 17bacbb659..d3c679b2e9 100644 --- a/extensions/keccak256/circuit/src/extension/cuda.rs +++ b/extensions/keccak256/circuit/src/extension/cuda.rs @@ -1,3 +1,5 @@ +use std::sync::{Arc, Mutex}; + use openvm_circuit::{ arch::DenseRecordArena, system::cuda::{ @@ -12,18 +14,19 @@ use openvm_rv32im_circuit::Rv32ImGpuProverExt; use openvm_stark_sdk::config::baby_bear_poseidon2::BabyBearPoseidon2Config; use super::*; -use crate::{air::KeccakVmAir, cuda::Keccak256ChipGpu}; +use crate::{ + cuda::{KeccakfOpChipGpu, KeccakfPermChipGpu, SharedKeccakfRecords, XorinVmChipGpu}, + keccakf_perm::KeccakfPermAir, +}; pub struct Keccak256GpuProverExt; -// This implementation is specific to GpuBackend because the lookup chips -// (VariableRangeCheckerChipGPU, BitwiseOperationLookupChipGPU) are specific to GpuBackend. impl VmProverExtension for Keccak256GpuProverExt { fn extend_prover( &self, - _: &Keccak256, + _extension: &Keccak256, inventory: &mut ChipInventory, ) -> Result<(), ChipInventoryError> { let pointer_max_bits = inventory.airs().pointer_max_bits(); @@ -32,21 +35,45 @@ impl VmProverExtension let range_checker = get_inventory_range_checker(inventory); let bitwise_lu = get_or_create_bitwise_op_lookup(inventory)?; - // These calls to next_air are not strictly necessary to construct the chips, but provide a - // safeguard to ensure that chip construction matches the circuit definition - inventory.next_air::()?; - let keccak = Keccak256ChipGpu::new( + // XorinVmChip + inventory.next_air::()?; + let xorin_chip = XorinVmChipGpu::new( range_checker.clone(), bitwise_lu.clone(), - pointer_max_bits as u32, + pointer_max_bits, + timestamp_max_bits as u32, + ); + inventory.add_executor_chip(xorin_chip); + + // Create shared state for passing records between Op and Perm chips + let shared_records = Arc::new(Mutex::new(SharedKeccakfRecords::default())); + + // NOTE: AIRs are added in extend_circuit in this order: XorinVmAir, KeccakfPermAir, + // KeccakfOpAir The prover extension must consume AIRs in the same order. + + // Register KeccakfPermChip (periphery chip - added BEFORE OpChip to ensure OpChip tracegen + // runs first) + inventory.next_air::()?; + let perm_chip = KeccakfPermChipGpu::new(shared_records.clone()); + inventory.add_periphery_chip(perm_chip); + + // Register KeccakfOpChip (executor chip - generates first due to executor vs periphery + // ordering) + inventory.next_air::()?; + let op_chip = KeccakfOpChipGpu::new( + range_checker, + bitwise_lu, + pointer_max_bits, timestamp_max_bits as u32, + shared_records, ); - inventory.add_executor_chip(keccak); + inventory.add_executor_chip(op_chip); Ok(()) } } +#[derive(Clone)] pub struct Keccak256Rv32GpuBuilder; type E = GpuBabyBearPoseidon2Engine; diff --git a/extensions/keccak256/circuit/src/extension/mod.rs b/extensions/keccak256/circuit/src/extension/mod.rs index b583ab18a7..64a802f242 100644 --- a/extensions/keccak256/circuit/src/extension/mod.rs +++ b/extensions/keccak256/circuit/src/extension/mod.rs @@ -1,4 +1,7 @@ -use std::{result::Result, sync::Arc}; +use std::{ + result::Result, + sync::{Arc, Mutex}, +}; use derive_more::derive::From; use openvm_circuit::{ @@ -20,7 +23,7 @@ use openvm_circuit_primitives::bitwise_op_lookup::{ }; use openvm_cpu_backend::{CpuBackend, CpuDevice}; use openvm_instructions::*; -use openvm_keccak256_transpiler::Rv32KeccakOpcode; +use openvm_keccak256_transpiler::{KeccakfOpcode, Rv32KeccakOpcode, XorinOpcode}; use openvm_rv32im_circuit::{ Rv32I, Rv32IExecutor, Rv32ImCpuProverExt, Rv32Io, Rv32IoExecutor, Rv32M, Rv32MExecutor, }; @@ -28,23 +31,16 @@ use openvm_stark_backend::{p3_field::PrimeField32, StarkEngine, StarkProtocolCon use serde::{Deserialize, Serialize}; use strum::IntoEnumIterator; -use crate::{KeccakVmAir, KeccakVmChip, KeccakVmExecutor, KeccakVmFiller}; +use crate::{ + keccakf_op::{KeccakfExecutor, KeccakfOpAir, KeccakfOpChip}, + keccakf_perm::{KeccakfPermAir, KeccakfPermChip}, + xorin::{air::XorinVmAir, XorinVmChip, XorinVmExecutor, XorinVmFiller}, +}; -cfg_if::cfg_if! { - if #[cfg(feature = "cuda")] { - mod cuda; - pub use cuda::*; - pub use cuda::{ - Keccak256GpuProverExt as Keccak256ProverExt, - Keccak256Rv32GpuBuilder as Keccak256Rv32Builder, - }; - } else { - pub use self::{ - Keccak256CpuProverExt as Keccak256ProverExt, - Keccak256Rv32CpuBuilder as Keccak256Rv32Builder, - }; - } -} +#[cfg(feature = "cuda")] +mod cuda; +#[cfg(feature = "cuda")] +pub use cuda::*; #[derive(Clone, Debug, VmConfig, derive_new::new, Serialize, Deserialize)] pub struct Keccak256Rv32Config { @@ -125,7 +121,8 @@ pub struct Keccak256; ) )] pub enum Keccak256Executor { - Keccak256(KeccakVmExecutor), + Keccakf(KeccakfExecutor), + Xorin(XorinVmExecutor), } impl VmExecutionExtension for Keccak256 { @@ -136,10 +133,17 @@ impl VmExecutionExtension for Keccak256 { inventory: &mut ExecutorInventoryBuilder, ) -> Result<(), ExecutorInventoryError> { let pointer_max_bits = inventory.pointer_max_bits(); - let keccak_step = KeccakVmExecutor::new(Rv32KeccakOpcode::CLASS_OFFSET, pointer_max_bits); + + let xorin_executor = XorinVmExecutor::new(XorinOpcode::CLASS_OFFSET, pointer_max_bits); + inventory.add_executor( + xorin_executor, + XorinOpcode::iter().map(|x| x.global_opcode()), + )?; + + let keccak_executor = KeccakfExecutor::new(KeccakfOpcode::CLASS_OFFSET, pointer_max_bits); inventory.add_executor( - keccak_step, - Rv32KeccakOpcode::iter().map(|x| x.global_opcode()), + keccak_executor, + KeccakfOpcode::iter().map(|x| x.global_opcode()), )?; Ok(()) @@ -169,14 +173,28 @@ impl VmCircuitExtension for Keccak256 { } }; - let keccak = KeccakVmAir::new( + let xorin_air = XorinVmAir::new( exec_bridge, memory_bridge, bitwise_lu, pointer_max_bits, - Rv32KeccakOpcode::CLASS_OFFSET, + XorinOpcode::CLASS_OFFSET, ); - inventory.add_air(keccak); + inventory.add_air(xorin_air); + + let keccakf_state_bus = PermutationCheckBus::new(inventory.new_bus_idx()); + let periphery_air = KeccakfPermAir::new(keccakf_state_bus); + inventory.add_air(periphery_air); + + let op_air = KeccakfOpAir::new( + exec_bridge, + memory_bridge, + bitwise_lu, + keccakf_state_bus, + pointer_max_bits, + KeccakfOpcode::CLASS_OFFSET, + ); + inventory.add_air(op_air); Ok(()) } @@ -207,6 +225,7 @@ where let existing_chip = inventory .find_chip::>() .next(); + if let Some(chip) = existing_chip { chip.clone() } else { @@ -217,12 +236,30 @@ where } }; - inventory.next_air::()?; - let keccak = KeccakVmChip::new( - KeccakVmFiller::new(bitwise_lu, pointer_max_bits), - mem_helper, + inventory.next_air::()?; + let xorin_chip = XorinVmChip::new( + XorinVmFiller::new(bitwise_lu.clone(), pointer_max_bits), + mem_helper.clone(), + ); + inventory.add_executor_chip(xorin_chip); + + inventory.next_air::()?; + let shared_records = Arc::new(Mutex::new(Vec::new())); + let periphery_chip = KeccakfPermChip::new(shared_records.clone()); + // Clone the Arc Mutex and pass to the OpChip. + // WARNING: the OpChip must be added _after_ the periphery chip so that its tracegen is done + // _first_. After OpChip tracegen, the shared_record is set to the execution records, + // effectively passing the records to the periphery chip. + inventory.add_periphery_chip(periphery_chip); + + inventory.next_air::()?; + let op_chip = KeccakfOpChip::new( + bitwise_lu, + pointer_max_bits, + mem_helper.clone(), + shared_records, ); - inventory.add_executor_chip(keccak); + inventory.add_executor_chip(op_chip); Ok(()) } diff --git a/extensions/keccak256/circuit/src/keccakf_op/air.rs b/extensions/keccak256/circuit/src/keccakf_op/air.rs new file mode 100644 index 0000000000..a43e352fb1 --- /dev/null +++ b/extensions/keccak256/circuit/src/keccakf_op/air.rs @@ -0,0 +1,194 @@ +use std::{borrow::Borrow, iter}; + +use itertools::izip; +use openvm_circuit::{ + arch::{ExecutionBridge, ExecutionState}, + system::memory::{ + offline_checker::{MemoryBridge, MemoryWriteAuxCols}, + MemoryAddress, + }, +}; +use openvm_circuit_primitives::bitwise_op_lookup::BitwiseOperationLookupBus; +use openvm_instructions::riscv::{ + RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS, +}; +use openvm_keccak256_transpiler::KeccakfOpcode; +use openvm_rv32im_circuit::adapters::abstract_compose; +use openvm_stark_backend::{ + interaction::{InteractionBuilder, PermutationCheckBus}, + p3_air::{Air, BaseAir}, + p3_field::PrimeCharacteristicRing, + p3_matrix::Matrix, + BaseAirWithPublicValues, PartitionedBaseAir, +}; + +use crate::{ + keccakf_op::columns::{KeccakfOpCols, NUM_KECCAKF_OP_COLS}, + KECCAK_WORD_SIZE, +}; + +#[derive(Clone, Copy, Debug, derive_new::new)] +pub struct KeccakfOpAir { + pub execution_bridge: ExecutionBridge, + pub memory_bridge: MemoryBridge, + pub bitwise_lookup_bus: BitwiseOperationLookupBus, + /// Direct bus with keccakf pre- or post-state. Bus message is + /// ```text + /// is_post || timestamp || state_u16_limbs + /// ``` + pub keccakf_state_bus: PermutationCheckBus, + pub ptr_max_bits: usize, + pub(super) offset: usize, +} + +impl BaseAirWithPublicValues for KeccakfOpAir {} +impl PartitionedBaseAir for KeccakfOpAir {} +impl BaseAir for KeccakfOpAir { + fn width(&self) -> usize { + NUM_KECCAKF_OP_COLS + } +} + +impl Air for KeccakfOpAir { + fn eval(&self, builder: &mut AB) { + let main = builder.main(); + + let local = main.row_slice(0).unwrap(); + let local: &KeccakfOpCols<_> = (*local).borrow(); + + let is_valid = local.is_valid; + builder.assert_bool(is_valid); + + let start_timestamp = local.timestamp; + let mut timestamp_delta = 0usize; + let mut timestamp_pp = || { + timestamp_delta += 1; + start_timestamp + AB::F::from_usize(timestamp_delta - 1) + }; + // ======== Read `rd` ========= + let rd_ptr = local.rd_ptr; + let buffer_ptr_limbs = local.buffer_ptr_limbs; + self.memory_bridge + .read( + MemoryAddress::new(AB::F::from_u32(RV32_REGISTER_AS), rd_ptr), + buffer_ptr_limbs, + timestamp_pp(), + &local.rd_aux, + ) + .eval(builder, is_valid); + // Range check that buffer_ptr_limbs fits in [0, 2^ptr_max_bits) as u32 + { + assert!(self.ptr_max_bits >= RV32_CELL_BITS * (RV32_REGISTER_NUM_LIMBS - 1)); + let limb_shift = AB::F::from_usize( + 1 << (RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - self.ptr_max_bits), + ); + let need_range_check = [ + buffer_ptr_limbs[RV32_REGISTER_NUM_LIMBS - 1], + buffer_ptr_limbs[RV32_REGISTER_NUM_LIMBS - 1], + ]; + for pair in need_range_check.chunks_exact(2) { + self.bitwise_lookup_bus + .send_range(pair[0] * limb_shift, pair[1] * limb_shift) + .eval(builder, is_valid); + } + } + // Now it is safe to cast buffer_ptr to F + let buffer_ptr: AB::Expr = abstract_compose(local.buffer_ptr_limbs); + + // ======== Constrain that post-state consists of bytes ========= + // We know that the pre-state buffer consists of bytes due to the invariant of Address Space + // 2 in memory. The keccakf_state_bus guarantees that the post-state consists of + // u16, but we still need to constrain that each pair actually consists of bytes. + // NOTE[jpw]: this can be removed if AS2 cells are changed to u16s + for pair in local.postimage.chunks_exact(2) { + self.bitwise_lookup_bus + .send_range(pair[0], pair[1]) + .eval(builder, is_valid); + } + + // ======== Constrain new writes of `buffer` to memory ========= + // NOTE: we use the _next_ row's `buffer` as the pre-state + for (word_idx, (prev_word, post_word, base_aux)) in izip!( + local.preimage.chunks_exact(KECCAK_WORD_SIZE), + local.postimage.chunks_exact(KECCAK_WORD_SIZE), + local.buffer_word_aux + ) + .enumerate() + { + // Safety: + // - we range checked that buffer_ptr < 2^ptr_max_bits but not that buffer_ptr + + // KECCAK_WIDTH_BYTES is in range. + // - the previous range check implies `buffer_ptr + KECCAK_WIDTH_BYTES` does not + // overflow the field `F` hence it is safe to consider `ptr` as a field element. + // - the memory_bridge.write at `ptr` consists of a receive on memory bus at a previous + // timestamp. The only way this bus interaction could balance is if there was already + // a previous valid write at `ptr`. Assuming the invariant that all previous memory + // accesses are valid and timestamp always moves forward, the new write to `ptr` must + // be valid as well. + let ptr = buffer_ptr.clone() + AB::F::from_usize(word_idx * KECCAK_WORD_SIZE); + let prev_data: &[_; KECCAK_WORD_SIZE] = prev_word.try_into().unwrap(); + // post_word consists of bytes due to range checks above + let data: &[_; KECCAK_WORD_SIZE] = post_word.try_into().unwrap(); + let write_aux = MemoryWriteAuxCols { + base: base_aux, + prev_data: *prev_data, + }; + self.memory_bridge + .write( + MemoryAddress::new(AB::F::from_u32(RV32_MEMORY_AS), ptr), + *data, + timestamp_pp(), + &write_aux, + ) + .eval(builder, is_valid); + } + + // ======== Execution bus ========= + self.execution_bridge + .execute_and_increment_pc( + AB::Expr::from_usize(KeccakfOpcode::KECCAKF as usize + self.offset), + [ + rd_ptr.into(), + AB::Expr::ZERO, + AB::Expr::ZERO, + AB::Expr::from_u32(RV32_REGISTER_AS), + AB::Expr::from_u32(RV32_MEMORY_AS), + ], + ExecutionState::new(local.pc, local.timestamp), + AB::F::from_usize(timestamp_delta), + ) + .eval(builder, is_valid); + + // ======== KeccakF State Interaction ======= + // Now we actually constrain that the pre- and post- buffer values are valid, but doing a + // permutation check with the KeccakFPeripheryAir. We compose two u8 into a u16 + // since the keccakf periphery air uses u16 limbs + // + // We use two interactions bound with the same timestamp to avoid having a really large + // message length. + self.keccakf_state_bus.send( + builder, + iter::empty() + .chain([AB::Expr::ZERO, local.timestamp.into()]) + .chain( + local + .preimage + .chunks(2) + .map(|pair| pair[0] + pair[1] * AB::F::from_u32(256)), + ), + is_valid, + ); + self.keccakf_state_bus.send( + builder, + iter::empty() + .chain([AB::Expr::ONE, local.timestamp.into()]) + .chain( + local + .postimage + .chunks(2) + .map(|pair| pair[0] + pair[1] * AB::F::from_u32(256)), + ), + is_valid, + ); + } +} diff --git a/extensions/keccak256/circuit/src/keccakf_op/columns.rs b/extensions/keccak256/circuit/src/keccakf_op/columns.rs new file mode 100644 index 0000000000..5fb2f65b39 --- /dev/null +++ b/extensions/keccak256/circuit/src/keccakf_op/columns.rs @@ -0,0 +1,38 @@ +use openvm_circuit::system::memory::offline_checker::{MemoryBaseAuxCols, MemoryReadAuxCols}; +use openvm_circuit_primitives_derive::AlignedBorrow; +use openvm_instructions::riscv::RV32_REGISTER_NUM_LIMBS; + +use crate::{KECCAK_WIDTH_BYTES, KECCAK_WIDTH_WORDS}; + +#[repr(C)] +#[derive(Copy, Clone, Debug, AlignedBorrow)] +pub struct KeccakfOpCols { + /// Program counter + pub pc: T, + /// True on the row handling execution for an instruction. + pub is_valid: T, + /// The starting timestamp for execution in this row. + /// A single row will do multiple memory accesses. + pub timestamp: T, + /// Pointer to address space 1 `rd` register. + /// The `rd` register holds the value of `buffer_ptr`. + pub rd_ptr: T, + /// `buffer_ptr <- [rd_ptr:4]_1`. + /// Limbs of the pointer to address space 2 `buffer`. + pub buffer_ptr_limbs: [T; RV32_REGISTER_NUM_LIMBS], + /// The preimage state, to be permuted in the `keccakf` operation. + pub preimage: [T; KECCAK_WIDTH_BYTES], + /// The postimage state after `keccakf` permute of `preimage`. + /// + /// Note: there is 2 row per instruction design where these columns can be shared with + /// `preimage`. However due to the interactions necessary for range checks, currently we + /// determined it is better to minimum number of rows while using more main columns. + pub postimage: [T; KECCAK_WIDTH_BYTES], + /// Auxiliary columns for timestamp checking for the read of `[rd_ptr:4]_1`. + pub rd_aux: MemoryReadAuxCols, + /// Auxiliary columns for timestamp checking of the writes to `buffer`. The writes are done one + /// word at a time, and each write requires a separate previous timestamp. + pub buffer_word_aux: [MemoryBaseAuxCols; KECCAK_WIDTH_WORDS], +} + +pub const NUM_KECCAKF_OP_COLS: usize = size_of::>(); diff --git a/extensions/new-keccak256/circuit/src/keccakf/execution.rs b/extensions/keccak256/circuit/src/keccakf_op/execution.rs similarity index 66% rename from extensions/new-keccak256/circuit/src/keccakf/execution.rs rename to extensions/keccak256/circuit/src/keccakf_op/execution.rs index 3098c91c20..6a2ef10cbd 100644 --- a/extensions/new-keccak256/circuit/src/keccakf/execution.rs +++ b/extensions/keccak256/circuit/src/keccakf_op/execution.rs @@ -17,10 +17,8 @@ use openvm_instructions::{ use openvm_stark_backend::p3_field::PrimeField32; use p3_keccak_air::NUM_ROUNDS; -use super::KeccakfVmExecutor; -use crate::keccakf::utils::{ - KECCAK_WIDTH_BYTES, KECCAK_WIDTH_U32_LIMBS, KECCAK_WIDTH_U64_LIMBS, KECCAK_WORD_SIZE, -}; +use super::{KeccakfExecutor, NUM_OP_ROWS_PER_INS}; +use crate::{keccakf_op::keccakf_postimage_bytes, KECCAK_WIDTH_BYTES, KECCAK_WORD_SIZE}; #[derive(AlignedBytesBorrow, Clone)] #[repr(C)] @@ -28,7 +26,7 @@ struct KeccakfPreCompute { a: u8, } -impl KeccakfVmExecutor { +impl KeccakfExecutor { fn pre_compute_impl( &self, pc: u32, @@ -58,7 +56,7 @@ impl KeccakfVmExecutor { } } -impl InterpreterExecutor for KeccakfVmExecutor { +impl InterpreterExecutor for KeccakfExecutor { fn pre_compute_size(&self) -> usize { size_of::() } @@ -95,9 +93,9 @@ impl InterpreterExecutor for KeccakfVmExecutor { } #[cfg(feature = "aot")] -impl AotExecutor for KeccakfVmExecutor {} +impl AotExecutor for KeccakfExecutor {} -impl InterpreterMeteredExecutor for KeccakfVmExecutor { +impl InterpreterMeteredExecutor for KeccakfExecutor { fn metered_pre_compute_size(&self) -> usize { size_of::() } @@ -138,7 +136,7 @@ impl InterpreterMeteredExecutor for KeccakfVmExecutor { } #[cfg(feature = "aot")] -impl AotMeteredExecutor for KeccakfVmExecutor {} +impl AotMeteredExecutor for KeccakfExecutor {} #[create_handler] #[inline(always)] @@ -156,58 +154,22 @@ unsafe fn execute_e12_impl, ) { - use tiny_keccak::keccakf; - - // the variable naming might be misleading - // buf_ptr is the pointer to the register which holds the actual pointer to the buffer - let buf_ptr = pre_compute.a as u32; - let buffer_limbs: [u8; 4] = exec_state.vm_read(RV32_REGISTER_AS, buf_ptr); - let buffer = u32::from_le_bytes(buffer_limbs); + let rd_ptr = pre_compute.a as u32; + let buffer_ptr_limbs: [u8; 4] = exec_state.vm_read(RV32_REGISTER_AS, rd_ptr); + let buffer_ptr = u32::from_le_bytes(buffer_ptr_limbs); - let message_vec: Option> = if IS_E1 { - None - } else { - Some( - (0..KECCAK_WIDTH_U32_LIMBS) - .flat_map(|i| { - exec_state.vm_read::( - RV32_MEMORY_AS, - buffer + (i * KECCAK_WORD_SIZE) as u32, - ) - }) - .collect(), - ) - }; - - let message: &[u8] = match message_vec.as_deref() { - Some(v) => &v[..KECCAK_WIDTH_BYTES], - None => exec_state.vm_read_slice(RV32_MEMORY_AS, buffer, KECCAK_WIDTH_BYTES), - }; - assert_eq!(message.len(), KECCAK_WIDTH_BYTES); - - let mut message_u64 = [0u64; KECCAK_WIDTH_U64_LIMBS]; - for (i, message_chunk) in message.chunks_exact(8).enumerate() { - let message_chunk_u64 = u64::from_le_bytes(message_chunk.try_into().unwrap()); - message_u64[i] = message_chunk_u64; - } - keccakf(&mut message_u64); - - let mut result: [u8; KECCAK_WIDTH_BYTES] = [0; KECCAK_WIDTH_BYTES]; - for (i, message) in message_u64.into_iter().enumerate() { - let message_bytes = message.to_le_bytes(); - result[8 * i..8 * i + 8].copy_from_slice(&message_bytes); - } + let preimage: &[u8] = + exec_state.host_read_slice(RV32_MEMORY_AS, buffer_ptr, KECCAK_WIDTH_BYTES); + let postimage = keccakf_postimage_bytes(preimage.try_into().unwrap()); if IS_E1 { - exec_state.vm_write(RV32_MEMORY_AS, buffer, &result); + exec_state.vm_write(RV32_MEMORY_AS, buffer_ptr, &postimage); } else { - for i in 0..KECCAK_WIDTH_U32_LIMBS { - let mut write_chunk: [u8; 4] = [0; 4]; - write_chunk.copy_from_slice(&result[4 * i..4 * i + 4]); + for (word_idx, word) in postimage.chunks_exact(KECCAK_WORD_SIZE).enumerate() { exec_state.vm_write::( RV32_MEMORY_AS, - buffer + (i * KECCAK_WORD_SIZE) as u32, - &write_chunk, + buffer_ptr + (word_idx * KECCAK_WORD_SIZE) as u32, + word.try_into().unwrap(), ); } } @@ -225,8 +187,23 @@ unsafe fn execute_e2_impl( let pre_compute: &E2PreCompute = std::slice::from_raw_parts(pre_compute, size_of::>()) .borrow(); + + let op_air_idx = pre_compute.chip_idx as usize; + + // Update KeccakfOpChip height (2 rows per instruction) + exec_state + .ctx + .on_height_change(op_air_idx, NUM_OP_ROWS_PER_INS as u32); + + // HACK: KeccakfPermAir is added right before KeccakfOpAir in extend_circuit, + // and due to reverse ordering of AIR indices, perm_air_idx = op_air_idx + 1. + // See extension/mod.rs extend_circuit for the ordering. + let perm_air_idx = op_air_idx + 1; + + // Update KeccakfPermChip height (24 rows per keccakf permutation) exec_state .ctx - .on_height_change(pre_compute.chip_idx as usize, NUM_ROUNDS as u32); + .on_height_change(perm_air_idx, NUM_ROUNDS as u32); + execute_e12_impl::(&pre_compute.data, exec_state); } diff --git a/extensions/keccak256/circuit/src/keccakf_op/mod.rs b/extensions/keccak256/circuit/src/keccakf_op/mod.rs new file mode 100644 index 0000000000..61cd5fb135 --- /dev/null +++ b/extensions/keccak256/circuit/src/keccakf_op/mod.rs @@ -0,0 +1,77 @@ +mod air; +pub mod columns; +mod execution; +#[cfg(test)] +pub mod tests; +/// Preflight and CPU trace generation +pub mod trace; + +use std::mem::MaybeUninit; + +pub use air::*; +pub use columns::*; +pub use trace::*; + +use crate::{KECCAK_WIDTH_BYTES, KECCAK_WIDTH_U64S}; + +pub const NUM_OP_ROWS_PER_INS: usize = 1; + +#[derive(derive_new::new, Clone, Copy)] +pub struct KeccakfExecutor { + pub offset: usize, + pub pointer_max_bits: usize, +} + +#[cfg(target_endian = "little")] +fn copy_bytes_to_u64(src: &[u8; KECCAK_WIDTH_BYTES]) -> [u64; KECCAK_WIDTH_U64S] { + // 1. Create uninitialized memory for the destination. This avoids the performance cost of + // writing zeros first. + let mut dst = MaybeUninit::<[u64; KECCAK_WIDTH_U64S]>::uninit(); + + unsafe { + // 2. Perform a raw memory copy. We cast the destination pointer to *mut u8 to copy + // byte-by-byte. This is crucial: copying as u8s ignores the alignment of 'src'. + std::ptr::copy_nonoverlapping( + src.as_ptr(), // Source pointer (*const u8) + dst.as_mut_ptr() as *mut u8, // Destination pointer (cast to *mut u8) + KECCAK_WIDTH_BYTES, // Number of BYTES to copy + ); + // 3. Assume initialization is complete. We know we filled all 200 bytes (25 * 8), so this + // is safe. + dst.assume_init() + } +} + +#[cfg(not(target_endian = "little"))] +fn copy_bytes_to_u64(src: &[u8; KECCAK_WIDTH_BYTES]) -> [u64; KECCAK_WIDTH_U64S] { + let mut dst = [0u64; KECCAK_WIDTH_U64S]; + for (u64_word, chunk) in dst.iter_mut().zip(src.chunks_exact(8)) { + *u64_word = u64::from_le_bytes(chunk.try_into().unwrap()); + } + dst +} + +#[cfg(target_endian = "little")] +fn transmute_u64_to_bytes(src: [u64; KECCAK_WIDTH_U64S]) -> [u8; KECCAK_WIDTH_BYTES] { + // SAFETY: + // - The size of both is the same, and `src` is plain old data (so we do not even need the fact + // that src has alignment > alignment of dst). + unsafe { std::mem::transmute::<[u64; KECCAK_WIDTH_U64S], [u8; KECCAK_WIDTH_BYTES]>(src) } +} + +#[cfg(not(target_endian = "little"))] +fn transmute_u64_to_bytes(src: [u64; KECCAK_WIDTH_U64S]) -> [u8; KECCAK_WIDTH_BYTES] { + let mut dst = [0u8; KECCAK_WIDTH_BYTES]; + for (chunk, u64_word) in dst.chunks_exact_mut(8).zip(src.iter()) { + chunk.copy_from_slice(&u64_word.to_le_bytes()); + } + dst +} + +fn keccakf_postimage_bytes( + preimage_buffer_bytes: &[u8; KECCAK_WIDTH_BYTES], +) -> [u8; KECCAK_WIDTH_BYTES] { + let mut state = copy_bytes_to_u64(preimage_buffer_bytes); + tiny_keccak::keccakf(&mut state); + transmute_u64_to_bytes(state) +} diff --git a/extensions/new-keccak256/circuit/src/keccakf/tests.rs b/extensions/keccak256/circuit/src/keccakf_op/tests.rs similarity index 51% rename from extensions/new-keccak256/circuit/src/keccakf/tests.rs rename to extensions/keccak256/circuit/src/keccakf_op/tests.rs index 489ba6fa55..903c36ea29 100644 --- a/extensions/new-keccak256/circuit/src/keccakf/tests.rs +++ b/extensions/keccak256/circuit/src/keccakf_op/tests.rs @@ -1,8 +1,15 @@ -use std::sync::Arc; +use std::{ + array::from_fn, + sync::{Arc, Mutex}, +}; +use itertools::Itertools; use openvm_circuit::{ arch::{ - testing::{TestBuilder, TestChipHarness, VmChipTestBuilder, BITWISE_OP_LOOKUP_BUS}, + testing::{ + memory::gen_pointer, TestBuilder, TestChipHarness, VmChipTestBuilder, + BITWISE_OP_LOOKUP_BUS, + }, Arena, ExecutionBridge, PreflightExecutor, }, system::memory::{offline_checker::MemoryBridge, SharedMemoryHelper}, @@ -13,21 +20,28 @@ use openvm_circuit_primitives::bitwise_op_lookup::{ SharedBitwiseOperationLookupChip, }; use openvm_instructions::{instruction::Instruction, riscv::RV32_CELL_BITS, LocalOpcode}; -use openvm_new_keccak256_transpiler::KeccakfOpcode; -use openvm_stark_backend::p3_field::FieldAlgebra; +use openvm_keccak256_transpiler::KeccakfOpcode; +use openvm_stark_backend::{ + interaction::{BusIndex, PermutationCheckBus}, + p3_field::{PrimeCharacteristicRing, PrimeField32}, +}; use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng}; use rand::rngs::StdRng; #[cfg(feature = "cuda")] use rand::Rng; +use tiny_keccak::keccakf; -use super::KeccakfVmFiller; -use crate::keccakf::air::KeccakfVmAir; +use crate::{ + keccakf_op::{KeccakfExecutor, KeccakfOpAir, KeccakfOpChip}, + keccakf_perm::{KeccakfPermAir, KeccakfPermChip}, + KECCAK_WIDTH_BYTES, +}; type F = BabyBear; -type Harness = TestChipHarness>; +/// Harness without KeccakfPeriphery* +type Harness = TestChipHarness, RA>; const MAX_TRACE_ROWS: usize = 4096; - -use crate::keccakf::{KeccakfVmChip, KeccakfVmExecutor}; +const KECCAKF_STATE_BUS: BusIndex = 13; fn create_harness_fields( execution_bridge: ExecutionBridge, @@ -35,67 +49,73 @@ fn create_harness_fields( bitwise_chip: Arc>, memory_helper: SharedMemoryHelper, address_bits: usize, -) -> (KeccakfVmAir, KeccakfVmExecutor, KeccakfVmChip) { - let air = KeccakfVmAir::new( +) -> (KeccakfOpAir, KeccakfExecutor, KeccakfOpChip) { + let executor = KeccakfExecutor::new(KeccakfOpcode::CLASS_OFFSET, address_bits); + let empty_records = Arc::new(Mutex::new(Vec::new())); + let op_air = KeccakfOpAir::new( execution_bridge, memory_bridge, bitwise_chip.bus(), + PermutationCheckBus::new(KECCAKF_STATE_BUS), address_bits, KeccakfOpcode::CLASS_OFFSET, ); - - let executor = KeccakfVmExecutor::new(KeccakfOpcode::CLASS_OFFSET, address_bits); - let chip = KeccakfVmChip::new( - KeccakfVmFiller::new(bitwise_chip, address_bits), - memory_helper, - ); - (air, executor, chip) + let op_chip = KeccakfOpChip::new(bitwise_chip, address_bits, memory_helper, empty_records); + (op_air, executor, op_chip) } -fn create_test_harness( - tester: &mut VmChipTestBuilder, -) -> ( - Harness, - ( +struct TestHarness { + harness: Harness, + bitwise: ( BitwiseOperationLookupAir, SharedBitwiseOperationLookupChip, ), -) { + perm: (KeccakfPermAir, KeccakfPermChip), +} + +fn create_test_harness(tester: &mut VmChipTestBuilder) -> TestHarness { let bitwise_bus = BitwiseOperationLookupBus::new(BITWISE_OP_LOOKUP_BUS); let bitwise_chip = Arc::new(BitwiseOperationLookupChip::::new( bitwise_bus, )); - let (air, executor, chip) = create_harness_fields( + let (op_air, executor, op_chip) = create_harness_fields( tester.execution_bridge(), tester.memory_bridge(), bitwise_chip.clone(), tester.memory_helper(), tester.address_bits(), ); + let shared_records = op_chip.shared_records.clone(); - let harness = Harness::with_capacity(executor, air, chip, MAX_TRACE_ROWS); + let harness = Harness::with_capacity(executor, op_air, op_chip, MAX_TRACE_ROWS); - (harness, (bitwise_chip.air, bitwise_chip)) + let perm_air = KeccakfPermAir::new(op_air.keccakf_state_bus); + let perm_chip = KeccakfPermChip::new(shared_records); + + TestHarness { + harness, + bitwise: (bitwise_chip.air, bitwise_chip), + perm: (perm_air, perm_chip), + } } -fn set_and_execute>( +fn set_and_execute_single_perm>( tester: &mut impl TestBuilder, executor: &mut E, arena: &mut RA, rng: &mut StdRng, opcode: KeccakfOpcode, ) { - const MAX_LEN: usize = 200; + const MAX_LEN: usize = KECCAK_WIDTH_BYTES; let rand_buffer = get_random_message(rng, MAX_LEN); let mut rand_buffer_arr = [0u8; MAX_LEN]; rand_buffer_arr.copy_from_slice(&rand_buffer); - use openvm_circuit::arch::testing::memory::gen_pointer; let rd = gen_pointer(rng, 4); let buffer_ptr = gen_pointer(rng, MAX_LEN); - tester.write(1, rd, buffer_ptr.to_le_bytes().map(F::from_canonical_u8)); - let rand_buffer_arr_f = rand_buffer_arr.map(F::from_canonical_u8); + tester.write(1, rd, buffer_ptr.to_le_bytes().map(F::from_u8)); + let rand_buffer_arr_f = rand_buffer_arr.map(F::from_u8); for i in 0..(MAX_LEN / 4) { let buffer_chunk: [F; 4] = rand_buffer_arr_f[4 * i..4 * i + 4] @@ -104,49 +124,60 @@ fn set_and_execute>( tester.write(2, buffer_ptr + 4 * i, buffer_chunk); } - // Safety note: If you would like to increase this further, make sure to count if it will - // exceed the MAX_TRACE_ROWS of the test harness configs or not - // currently it does not because 100 * 24 < 4096 - for _ in 0..100 { - tester.execute( - executor, - arena, - &Instruction::from_usize(opcode.global_opcode(), [rd, 0, 0, 1, 2]), - ); - } + tester.execute( + executor, + arena, + &Instruction::from_usize(opcode.global_opcode(), [rd, 0, 0, 1, 2]), + ); - let mut output_buffer = [F::from_canonical_u8(0); MAX_LEN]; + let mut output_buffer = [0u8; MAX_LEN]; for i in 0..(MAX_LEN / 4) { let output_chunk: [F; 4] = tester.read(2, buffer_ptr + 4 * i); + let output_chunk = output_chunk.map(|x| x.as_canonical_u32() as u8); output_buffer[4 * i..4 * i + 4].copy_from_slice(&output_chunk); } + let mut state: [u64; 25] = + from_fn(|i| u64::from_le_bytes(rand_buffer[8 * i..8 * i + 8].try_into().unwrap())); + keccakf(&mut state); + let expected_out = state.iter().flat_map(|w| w.to_le_bytes()).collect_vec(); + assert_eq!(&output_buffer[..], &expected_out[..]); } +/////////////////////////////////////////////////////////////////////////////////////// +/// POSITIVE TESTS +/// +/// Randomly generate computations and execute, ensuring that the generated trace +/// passes all constraints. +/////////////////////////////////////////////////////////////////////////////////////// #[test] -fn keccakf_chip_positive_tests() { - let num_ops: usize = 10; - +fn rand_keccakf_positive_tests() { + let mut rng = create_seeded_rng(); + let mut tester = VmChipTestBuilder::default(); + let TestHarness { + mut harness, + bitwise, + perm, + } = create_test_harness(&mut tester); + + let num_ops: usize = 100; for _ in 0..num_ops { - let mut rng = create_seeded_rng(); - let mut tester = VmChipTestBuilder::default(); - let (mut harness, bitwise) = create_test_harness(&mut tester); - - set_and_execute( + set_and_execute_single_perm( &mut tester, &mut harness.executor, &mut harness.arena, &mut rng, KeccakfOpcode::KECCAKF, ); - - let tester = tester - .build() - .load(harness) - .load_periphery(bitwise) - .finalize(); - tester.simple_test().expect("Verification failed"); } + + let tester = tester + .build() + .load(harness) + .load_periphery(perm) + .load_periphery(bitwise) + .finalize(); + tester.simple_test().expect("Verification failed"); } // //////////////////////////////////////////////////////////////////////////////////// @@ -159,14 +190,24 @@ use openvm_circuit::arch::{ }; #[cfg(feature = "cuda")] -use crate::{cuda::KeccakfVmChipGpu, keccakf::trace::KeccakfVmRecordMut}; +use crate::{ + cuda::{KeccakfOpChipGpu, KeccakfPermChipGpu, SharedKeccakfRecords, SharedKeccakfRecordsGpu}, + keccakf_op::trace::KeccakfRecordMut, +}; #[cfg(feature = "cuda")] type GpuHarness = - GpuTestChipHarness>; + GpuTestChipHarness>; + +#[cfg(feature = "cuda")] +struct CudaTestHarness { + op_harness: GpuHarness, + perm_air: KeccakfPermAir, + perm_chip: KeccakfPermChipGpu, +} #[cfg(feature = "cuda")] -fn create_cuda_harness(tester: &GpuChipTestBuilder) -> GpuHarness { +fn create_cuda_harness(tester: &GpuChipTestBuilder) -> CudaTestHarness { let bitwise_bus = default_bitwise_lookup_bus(); let dummy_bitwise_chip = Arc::new(BitwiseOperationLookupChip::::new( bitwise_bus, @@ -180,20 +221,36 @@ fn create_cuda_harness(tester: &GpuChipTestBuilder) -> GpuHarness { tester.address_bits(), ); - let gpu_chip = KeccakfVmChipGpu::new( + // Create shared state for passing records between GPU Op and Perm chips + let shared_records: SharedKeccakfRecordsGpu = + Arc::new(Mutex::new(SharedKeccakfRecords::default())); + + let gpu_chip = KeccakfOpChipGpu::new( tester.range_checker(), tester.bitwise_op_lookup(), tester.address_bits(), tester.timestamp_max_bits() as u32, + shared_records.clone(), ); - GpuTestChipHarness::with_capacity(executor, air, gpu_chip, cpu_chip, MAX_TRACE_ROWS) + let op_harness = + GpuTestChipHarness::with_capacity(executor, air, gpu_chip, cpu_chip, MAX_TRACE_ROWS); + + // Create GPU Perm chip with shared records + let perm_air = KeccakfPermAir::new(air.keccakf_state_bus); + let perm_chip = KeccakfPermChipGpu::new(shared_records); + + CudaTestHarness { + op_harness, + perm_air, + perm_chip, + } } #[cfg(feature = "cuda")] fn cuda_set_and_execute( tester: &mut GpuChipTestBuilder, - executor: &mut KeccakfVmExecutor, + executor: &mut KeccakfExecutor, arena: &mut DenseRecordArena, rng: &mut StdRng, ) { @@ -207,14 +264,14 @@ fn cuda_set_and_execute( tester.write( 1, buffer_reg, - buffer_ptr.to_le_bytes().map(F::from_canonical_u8), + buffer_ptr.to_le_bytes().map(F::from_u8), ); let state_data: Vec = (0..KECCAK_STATE_BYTES).map(|_| rng.gen()).collect(); for (i, chunk) in state_data.chunks(4).enumerate() { let mut word = [F::ZERO; 4]; for (j, &byte) in chunk.iter().enumerate() { - word[j] = F::from_canonical_u8(byte); + word[j] = F::from_u8(byte); } tester.write(2, buffer_ptr + i * 4, word); } @@ -240,20 +297,25 @@ fn test_keccakf_cuda_tracegen() { for _ in 0..num_ops { cuda_set_and_execute( &mut tester, - &mut harness.executor, - &mut harness.dense_arena, + &mut harness.op_harness.executor, + &mut harness.op_harness.dense_arena, &mut rng, ); } harness + .op_harness .dense_arena - .get_record_seeker::() - .transfer_to_matrix_arena(&mut harness.matrix_arena); + .get_record_seeker::() + .transfer_to_matrix_arena(&mut harness.op_harness.matrix_arena); + + // Create empty arena for Perm chip (it uses shared records, not arena) + let perm_arena = DenseRecordArena::with_capacity(0, 1); tester .build() - .load_gpu_harness(harness) + .load_gpu_harness(harness.op_harness) + .load(harness.perm_air, harness.perm_chip, perm_arena) .finalize() .simple_test() .unwrap(); @@ -270,19 +332,24 @@ fn test_keccakf_cuda_tracegen_single() { cuda_set_and_execute( &mut tester, - &mut harness.executor, - &mut harness.dense_arena, + &mut harness.op_harness.executor, + &mut harness.op_harness.dense_arena, &mut rng, ); harness + .op_harness .dense_arena - .get_record_seeker::() - .transfer_to_matrix_arena(&mut harness.matrix_arena); + .get_record_seeker::() + .transfer_to_matrix_arena(&mut harness.op_harness.matrix_arena); + + // Create empty arena for Perm chip (it uses shared records, not arena) + let perm_arena = DenseRecordArena::with_capacity(0, 1); tester .build() - .load_gpu_harness(harness) + .load_gpu_harness(harness.op_harness) + .load(harness.perm_air, harness.perm_chip, perm_arena) .finalize() .simple_test() .unwrap(); @@ -307,7 +374,7 @@ fn test_keccakf_cuda_tracegen_zero_state() { tester.write( 1, buffer_reg, - buffer_ptr.to_le_bytes().map(F::from_canonical_u8), + buffer_ptr.to_le_bytes().map(F::from_u8), ); for i in 0..(KECCAK_STATE_BYTES / 4) { @@ -320,19 +387,24 @@ fn test_keccakf_cuda_tracegen_zero_state() { ); tester.execute( - &mut harness.executor, - &mut harness.dense_arena, + &mut harness.op_harness.executor, + &mut harness.op_harness.dense_arena, &instruction, ); harness + .op_harness .dense_arena - .get_record_seeker::() - .transfer_to_matrix_arena(&mut harness.matrix_arena); + .get_record_seeker::() + .transfer_to_matrix_arena(&mut harness.op_harness.matrix_arena); + + // Create empty arena for Perm chip (it uses shared records, not arena) + let perm_arena = DenseRecordArena::with_capacity(0, 1); tester .build() - .load_gpu_harness(harness) + .load_gpu_harness(harness.op_harness) + .load(harness.perm_air, harness.perm_chip, perm_arena) .finalize() .simple_test() .unwrap(); diff --git a/extensions/keccak256/circuit/src/keccakf_op/trace.rs b/extensions/keccak256/circuit/src/keccakf_op/trace.rs new file mode 100644 index 0000000000..ee86dbdeab --- /dev/null +++ b/extensions/keccak256/circuit/src/keccakf_op/trace.rs @@ -0,0 +1,257 @@ +use core::convert::TryInto; +use std::{ + borrow::BorrowMut, + mem::{align_of, size_of}, + sync::{Arc, Mutex}, +}; + +use openvm_circuit::{ + arch::*, + system::memory::{ + offline_checker::MemoryReadAuxRecord, online::TracingMemory, MemoryAuxColsFactory, + SharedMemoryHelper, + }, +}; +use openvm_circuit_primitives::{ + bitwise_op_lookup::SharedBitwiseOperationLookupChip, AlignedBytesBorrow, +}; +use openvm_instructions::{ + instruction::Instruction, + program::DEFAULT_PC_STEP, + riscv::{RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS}, +}; +use openvm_keccak256_transpiler::KeccakfOpcode; +use openvm_rv32im_circuit::adapters::{timed_write, tracing_read}; +use openvm_circuit_primitives::Chip; +use openvm_stark_backend::{ + p3_field::PrimeField32, + p3_matrix::{dense::RowMajorMatrix, Matrix}, + p3_maybe_rayon::prelude::*, + prover::{AirProvingContext, ColMajorMatrix, CpuBackend}, + StarkProtocolConfig, Val, +}; + +use super::{KeccakfExecutor, NUM_OP_ROWS_PER_INS}; +use crate::{ + keccakf_op::{columns::KeccakfOpCols, keccakf_postimage_bytes}, + KECCAK_WIDTH_BYTES, KECCAK_WIDTH_WORDS, KECCAK_WORD_SIZE, +}; + +#[derive(derive_new::new)] +pub struct KeccakfOpChip { + pub bitwise_lookup_chip: SharedBitwiseOperationLookupChip<8>, + pub pointer_max_bits: usize, + pub mem_helper: SharedMemoryHelper, + // NOTE[jpw]: this is an awkward way to pass data from this execution chip to the + // KeccakfPeriphery chip. This can be improved with a redesign of how record arenas are shared + // with chips. + pub shared_records: Arc>>, +} + +impl Chip> for KeccakfOpChip> +where + SC: StarkProtocolConfig, + Val: PrimeField32, + RA: RowMajorMatrixArena>, +{ + fn generate_proving_ctx(&self, arena: RA) -> AirProvingContext> { + let rows_used = arena.trace_offset() / arena.width(); + let mut trace = arena.into_matrix(); + let mem_helper = self.mem_helper.as_borrowed(); + self.fill_trace(&mem_helper, &mut trace, rows_used); + AirProvingContext::simple_no_pis(ColMajorMatrix::from_row_major(&trace)) + } +} + +#[derive(Clone, Copy, Default)] +pub struct KeccakfMetadata; + +impl MultiRowMetadata for KeccakfMetadata { + fn get_num_rows(&self) -> usize { + NUM_OP_ROWS_PER_INS + } +} + +pub(crate) type KeccakfRecordLayout = MultiRowLayout; + +#[repr(C)] +#[derive(AlignedBytesBorrow, Debug, Clone)] +pub struct KeccakfRecord { + pub pc: u32, + pub timestamp: u32, + pub rd_ptr: u32, + pub buffer_ptr: u32, + pub rd_aux: MemoryReadAuxRecord, + pub buffer_word_aux: [MemoryReadAuxRecord; KECCAK_WIDTH_WORDS], + pub preimage_buffer_bytes: [u8; KECCAK_WIDTH_BYTES], +} + +/// Mutable reference wrapper for KeccakfRecord, used for record seeking in CUDA tests +pub struct KeccakfRecordMut<'a> { + pub inner: &'a mut KeccakfRecord, +} + +impl<'a> CustomBorrow<'a, KeccakfRecordMut<'a>, KeccakfRecordLayout> for [u8] { + fn custom_borrow(&'a mut self, _layout: KeccakfRecordLayout) -> KeccakfRecordMut<'a> { + let (record_buf, _rest) = + unsafe { self.split_at_mut_unchecked(size_of::()) }; + KeccakfRecordMut { + inner: record_buf.borrow_mut(), + } + } + + unsafe fn extract_layout(&self) -> KeccakfRecordLayout { + KeccakfRecordLayout::new(KeccakfMetadata) + } +} + +impl SizedRecord for KeccakfRecordMut<'_> { + fn size(_layout: &KeccakfRecordLayout) -> usize { + size_of::() + } + + fn alignment(_layout: &KeccakfRecordLayout) -> usize { + align_of::() + } +} + +impl PreflightExecutor for KeccakfExecutor +where + F: PrimeField32, + for<'buf> RA: RecordArena<'buf, KeccakfRecordLayout, &'buf mut KeccakfRecord>, +{ + fn get_opcode_name(&self, _: usize) -> String { + format!("{:?}", KeccakfOpcode::KECCAKF) + } + + fn execute( + &self, + state: VmStateMut, + instruction: &Instruction, + ) -> Result<(), ExecutionError> { + let &Instruction { a, .. } = instruction; + let rd_ptr = a.as_canonical_u32(); + + let record = state.ctx.alloc(KeccakfRecordLayout::new(KeccakfMetadata)); + + record.pc = *state.pc; + record.timestamp = state.memory.timestamp(); + record.rd_ptr = rd_ptr; + let buffer_ptr = u32::from_le_bytes(tracing_read( + state.memory, + RV32_REGISTER_AS, + rd_ptr, + &mut record.rd_aux.prev_timestamp, + )); + record.buffer_ptr = buffer_ptr; + + let guest_mem = state.memory.data(); + // SAFETY: + // - RV32_MEMORY_AS (2) consists of `u8` + // - get_slice will panic (if protected mode) if out of bounds + let prestate = + unsafe { guest_mem.get_slice(RV32_MEMORY_AS, record.buffer_ptr, KECCAK_WIDTH_BYTES) }; + record.preimage_buffer_bytes.copy_from_slice(prestate); + let poststate = keccakf_postimage_bytes(&record.preimage_buffer_bytes); + for (word_idx, (word, aux)) in poststate + .chunks_exact(KECCAK_WORD_SIZE) + .zip(&mut record.buffer_word_aux) + .enumerate() + { + // We don't need prev_data since we read it earlier + let (t_prev, _) = timed_write::( + state.memory, + RV32_MEMORY_AS, + buffer_ptr + (word_idx * KECCAK_WORD_SIZE) as u32, + word.try_into().unwrap(), + ); + aux.prev_timestamp = t_prev; + } + + *state.pc = state.pc.wrapping_add(DEFAULT_PC_STEP); + Ok(()) + } +} + +impl TraceFiller for KeccakfOpChip { + fn fill_trace( + &self, + mem_helper: &MemoryAuxColsFactory, + trace_matrix: &mut RowMajorMatrix, + rows_used: usize, + ) { + if rows_used == 0 { + return; + } + assert!(rows_used.is_multiple_of(NUM_OP_ROWS_PER_INS)); + + let width = trace_matrix.width(); + let (trace, dummy_trace) = trace_matrix.values.split_at_mut(rows_used * width); + // For clarity we just clone the records into a separate vector to avoid dealing with unsafe + // overwriting + let records = trace + .par_chunks_exact_mut(width * NUM_OP_ROWS_PER_INS) + .map(|mut row| { + let record: &mut KeccakfRecord = unsafe { + get_record_from_slice(&mut row, KeccakfRecordLayout::new(KeccakfMetadata)) + }; + record.clone() + }) + .collect::>(); + dummy_trace.fill(F::ZERO); + + trace + .par_chunks_exact_mut(width * NUM_OP_ROWS_PER_INS) + .zip(records.par_iter()) + .for_each(|(row, record)| { + row.fill(F::ZERO); + + let postimage_buffer_bytes = keccakf_postimage_bytes(&record.preimage_buffer_bytes); + let buffer_ptr_limbs = record.buffer_ptr.to_le_bytes(); + + let local: &mut KeccakfOpCols = row.borrow_mut(); + + local.pc = F::from_u32(record.pc); + local.is_valid = F::ONE; + local.timestamp = F::from_u32(record.timestamp); + local.rd_ptr = F::from_u32(record.rd_ptr); + local.buffer_ptr_limbs = buffer_ptr_limbs.map(F::from_u8); + + for (dst, &byte) in local.preimage.iter_mut().zip(&record.preimage_buffer_bytes) { + *dst = F::from_u8(byte); + } + for (dst, &byte) in local.postimage.iter_mut().zip(&postimage_buffer_bytes) { + *dst = F::from_u8(byte); + } + + let mut timestamp = record.timestamp; + mem_helper.fill( + record.rd_aux.prev_timestamp, + record.timestamp, + local.rd_aux.as_mut(), + ); + timestamp += 1; + for (aux, record_aux) in local + .buffer_word_aux + .iter_mut() + .zip(&record.buffer_word_aux) + { + mem_helper.fill(record_aux.prev_timestamp, timestamp, aux); + timestamp += 1; + } + + let limb_shift = 1u32 + << (RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - self.pointer_max_bits) as u32; + let scaled_limb = + (buffer_ptr_limbs[RV32_REGISTER_NUM_LIMBS - 1] as u32) * limb_shift; + self.bitwise_lookup_chip + .request_range(scaled_limb, scaled_limb); + + for pair in postimage_buffer_bytes.chunks_exact(2) { + self.bitwise_lookup_chip + .request_range(pair[0] as u32, pair[1] as u32); + } + }); + *self.shared_records.lock().unwrap() = records; + } +} diff --git a/extensions/keccak256/circuit/src/keccakf_perm/air.rs b/extensions/keccak256/circuit/src/keccakf_perm/air.rs new file mode 100644 index 0000000000..7da97ba9e2 --- /dev/null +++ b/extensions/keccak256/circuit/src/keccakf_perm/air.rs @@ -0,0 +1,116 @@ +use std::{borrow::Borrow, iter}; + +use openvm_circuit_primitives_derive::AlignedBorrow; +use openvm_stark_backend::{ + air_builders::sub::SubAirBuilder, + interaction::{InteractionBuilder, PermutationCheckBus}, + p3_air::{Air, AirBuilder, BaseAir}, + p3_field::PrimeCharacteristicRing, + p3_matrix::Matrix, + BaseAirWithPublicValues, PartitionedBaseAir, +}; +use p3_keccak_air::{KeccakAir, KeccakCols, NUM_KECCAK_COLS, U64_LIMBS}; + +use crate::KECCAK_WIDTH_U64S; + +#[repr(C)] +#[derive(Debug, AlignedBorrow)] +pub struct KeccakfPermCols { + pub inner: KeccakCols, + + /// The AIR **assumes** but does not constrain that the timestamp should be unique for each + /// distinct preimage state. + pub timestamp: T, +} + +/// A periphery AIR that wraps the Plonky3 AIR with a direct interaction on a [PermutationCheckBus]. +/// The AIR assumes but does not constrain that the timestamp in the bus should be unique for each +/// distinct preimage state. +#[derive(Clone, Copy, Debug, derive_new::new)] +pub struct KeccakfPermAir { + /// Direct bus with keccakf pre- or post-state. Bus message is `prestate_u16_limbs || + /// poststate_u16_limbs` + pub keccakf_state_bus: PermutationCheckBus, +} + +impl KeccakfPermCols { + pub fn postimage(&self, y: usize, x: usize, limb: usize) -> T { + self.inner.a_prime_prime_prime(y, x, limb) + } + + pub fn is_first_round(&self) -> T { + *self.inner.step_flags.first().unwrap() + } + + pub fn is_last_round(&self) -> T { + *self.inner.step_flags.last().unwrap() + } +} + +pub const NUM_KECCAKF_PERM_COLS: usize = size_of::>(); + +impl BaseAirWithPublicValues for KeccakfPermAir {} +impl PartitionedBaseAir for KeccakfPermAir {} +impl BaseAir for KeccakfPermAir { + fn width(&self) -> usize { + NUM_KECCAKF_PERM_COLS + } +} + +impl Air for KeccakfPermAir { + fn eval(&self, builder: &mut AB) { + self.eval_keccak_f(builder); + + let main = builder.main(); + let local = main.row_slice(0).unwrap(); + let local: &KeccakfPermCols<_> = (*local).borrow(); + + // Only allowed to export on the last round of permutation + builder + .when(local.inner.export) + .assert_one(local.is_last_round()); + + // ==== Receive preimage and postimage on direct bus ==== + // reminder: keccakf-air constrains that `preimage` stays the same across steps within 24 rows of the same permutation + + // preimage + self.keccakf_state_bus.receive( + builder, + iter::empty() + .chain([AB::Expr::ZERO, local.timestamp.into()]) + .chain((0..KECCAK_WIDTH_U64S).flat_map(|i| { + // state[x + 5 * y] is y-major as in https://keccak.team/keccak_specs_summary.html + let y = i / 5; + let x = i % 5; + (0..U64_LIMBS).map(move |limb| local.inner.preimage[y][x][limb].into()) + })), + local.inner.export, + ); + // postimage + self.keccakf_state_bus.receive( + builder, + iter::empty() + .chain([AB::Expr::ONE, local.timestamp.into()]) + .chain((0..KECCAK_WIDTH_U64S).flat_map(|i| { + // state[x + 5 * y] is y-major as in https://keccak.team/keccak_specs_summary.html + let y = i / 5; + let x = i % 5; + (0..U64_LIMBS).map(move |limb| local.postimage(y, x, limb).into()) + })), + local.inner.export, + ); + } +} + +impl KeccakfPermAir { + /// Evaluate the keccak-f permutation constraints. + /// + /// WARNING: The keccak-f AIR columns **must** be the first columns in the main AIR. + #[inline] + pub fn eval_keccak_f(&self, builder: &mut AB) { + let keccakf_air = KeccakAir {}; + let mut sub_builder = + SubAirBuilder::::new(builder, 0..NUM_KECCAK_COLS); + keccakf_air.eval(&mut sub_builder); + } +} diff --git a/extensions/keccak256/circuit/src/keccakf_perm/mod.rs b/extensions/keccak256/circuit/src/keccakf_perm/mod.rs new file mode 100644 index 0000000000..26ed4a40d4 --- /dev/null +++ b/extensions/keccak256/circuit/src/keccakf_perm/mod.rs @@ -0,0 +1,5 @@ +mod air; +mod trace; + +pub use air::*; +pub use trace::*; diff --git a/extensions/keccak256/circuit/src/keccakf_perm/trace.rs b/extensions/keccak256/circuit/src/keccakf_perm/trace.rs new file mode 100644 index 0000000000..ada5e73063 --- /dev/null +++ b/extensions/keccak256/circuit/src/keccakf_perm/trace.rs @@ -0,0 +1,74 @@ +use std::{ + array::from_fn, + borrow::BorrowMut, + sync::{Arc, Mutex}, +}; + +use openvm_circuit_primitives::Chip; +use openvm_stark_backend::{ + p3_field::{PrimeCharacteristicRing, PrimeField32}, + p3_matrix::{dense::RowMajorMatrix, Matrix}, + p3_maybe_rayon::prelude::*, + prover::{AirProvingContext, ColMajorMatrix, CpuBackend}, + StarkProtocolConfig, Val, +}; +use p3_keccak_air::{generate_trace_rows, NUM_KECCAK_COLS, NUM_ROUNDS}; + +use crate::{ + keccakf_op::KeccakfRecord, + keccakf_perm::{KeccakfPermCols, NUM_KECCAKF_PERM_COLS}, +}; + +#[derive(Clone, derive_new::new)] +pub struct KeccakfPermChip { + /// See comments in [KeccakfOpChip](crate::keccakf_op::KeccakfOpChip). + pub(crate) shared_records: Arc>>, +} + +impl Chip> for KeccakfPermChip +where + SC: StarkProtocolConfig, + Val: PrimeField32, +{ + /// Generates trace and clears internal records state. + fn generate_proving_ctx(&self, _: RA) -> AirProvingContext> { + let records: Vec<_> = std::mem::take(&mut self.shared_records.lock().unwrap()); + let states = records + .iter() + .map(|record| { + // p3-keccak-air now uses standard Keccak indexing: + // input[x + 5*y] = state[x][y], matching the byte buffer layout. + // The previous transposition workaround (plonky3 issue #672) is no longer needed. + from_fn(|i| { + u64::from_le_bytes( + record.preimage_buffer_bytes[i * 8..i * 8 + 8] + .try_into() + .unwrap(), + ) + }) + }) + .collect::>(); + + let p3_trace = generate_trace_rows::>(states, 0); + // Row-major: we need to add more columns + let mut values = Val::::zero_vec(NUM_KECCAKF_PERM_COLS * p3_trace.height()); + values + .par_chunks_exact_mut(NUM_KECCAKF_PERM_COLS) + .zip(p3_trace.values.par_chunks_exact(NUM_KECCAK_COLS)) + .enumerate() + .for_each(|(row_idx, (row, p3_row))| { + row[..NUM_KECCAK_COLS].copy_from_slice(p3_row); + + if row_idx % NUM_ROUNDS == (NUM_ROUNDS - 1) { + let record_idx = row_idx / NUM_ROUNDS; + if let Some(record) = records.get(record_idx) { + let local: &mut KeccakfPermCols<_> = row.borrow_mut(); + local.inner.export = Val::::ONE; + local.timestamp = Val::::from_u32(record.timestamp); + } + } + }); + let matrix = RowMajorMatrix::new(values, NUM_KECCAKF_PERM_COLS); + AirProvingContext::simple_no_pis(ColMajorMatrix::from_row_major(&matrix)) + } +} diff --git a/extensions/keccak256/circuit/src/lib.rs b/extensions/keccak256/circuit/src/lib.rs index 00e57033e5..bbcf29b643 100644 --- a/extensions/keccak256/circuit/src/lib.rs +++ b/extensions/keccak256/circuit/src/lib.rs @@ -2,70 +2,22 @@ #![cfg_attr(feature = "tco", feature(explicit_tail_calls))] #![cfg_attr(feature = "tco", allow(internal_features))] #![cfg_attr(feature = "tco", feature(core_intrinsics))] -//! Stateful keccak256 hasher. Handles full keccak sponge (padding, absorb, keccak-f) on -//! variable length inputs read from VM memory. -use openvm_circuit_primitives::bitwise_op_lookup::SharedBitwiseOperationLookupChip; - -pub mod air; -pub mod columns; -pub mod execution; -pub mod trace; -pub mod utils; +/// The AIR that handles interactions with the VM ExecutionBus and MemoryBus for handling of the +/// keccakf opcode. +pub mod keccakf_op; +/// Wrapper around the Plonky3 keccakf permutation AIR with a direct lookup bus for interaction with +/// `KeccakfOpAir`. +mod keccakf_perm; +/// AIR that handles the `xorin` opcode. +pub mod xorin; #[cfg(feature = "cuda")] mod cuda; #[cfg(feature = "cuda")] pub use cuda::*; +mod constants; mod extension; -#[cfg(test)] -mod tests; -pub use air::KeccakVmAir; +pub use constants::*; pub use extension::*; -use openvm_circuit::arch::*; - -// ==== Constants for register/memory adapter ==== -/// Register reads to get dst, src, len -const KECCAK_REGISTER_READS: usize = 3; -/// Number of cells to read/write in a single memory access -const KECCAK_WORD_SIZE: usize = 4; -/// Memory reads for absorb per row -const KECCAK_ABSORB_READS: usize = KECCAK_RATE_BYTES / KECCAK_WORD_SIZE; -/// Memory writes for digest per row -const KECCAK_DIGEST_WRITES: usize = KECCAK_DIGEST_BYTES / KECCAK_WORD_SIZE; - -// ==== Do not change these constants! ==== -/// Total number of sponge bytes: number of rate bytes + number of capacity -/// bytes. -pub const KECCAK_WIDTH_BYTES: usize = 200; -/// Total number of 16-bit limbs in the sponge. -pub const KECCAK_WIDTH_U16S: usize = KECCAK_WIDTH_BYTES / 2; -/// Number of rate bytes. -pub const KECCAK_RATE_BYTES: usize = 136; -/// Number of 16-bit rate limbs. -pub const KECCAK_RATE_U16S: usize = KECCAK_RATE_BYTES / 2; -/// Number of absorb rounds, equal to rate in u64s. -pub const NUM_ABSORB_ROUNDS: usize = KECCAK_RATE_BYTES / 8; -/// Number of capacity bytes. -pub const KECCAK_CAPACITY_BYTES: usize = 64; -/// Number of 16-bit capacity limbs. -pub const KECCAK_CAPACITY_U16S: usize = KECCAK_CAPACITY_BYTES / 2; -/// Number of output digest bytes used during the squeezing phase. -pub const KECCAK_DIGEST_BYTES: usize = 32; -/// Number of 64-bit digest limbs. -pub const KECCAK_DIGEST_U64S: usize = KECCAK_DIGEST_BYTES / 8; - -pub type KeccakVmChip = VmChipWrapper; - -#[derive(derive_new::new, Clone, Copy)] -pub struct KeccakVmExecutor { - pub offset: usize, - pub pointer_max_bits: usize, -} - -#[derive(derive_new::new)] -pub struct KeccakVmFiller { - pub bitwise_lookup_chip: SharedBitwiseOperationLookupChip<8>, - pub pointer_max_bits: usize, -} diff --git a/extensions/keccak256/circuit/src/tests.rs b/extensions/keccak256/circuit/src/tests.rs deleted file mode 100644 index 32eb17e65f..0000000000 --- a/extensions/keccak256/circuit/src/tests.rs +++ /dev/null @@ -1,501 +0,0 @@ -use std::{array, borrow::BorrowMut, sync::Arc}; - -use hex::FromHex; -use openvm_circuit::{ - arch::{ - testing::{ - memory::gen_pointer, TestBuilder, TestChipHarness, VmChipTestBuilder, - BITWISE_OP_LOOKUP_BUS, - }, - Arena, ExecutionBridge, PreflightExecutor, - }, - system::memory::{offline_checker::MemoryBridge, SharedMemoryHelper}, - utils::get_random_message, -}; -use openvm_circuit_primitives::bitwise_op_lookup::{ - BitwiseOperationLookupAir, BitwiseOperationLookupBus, BitwiseOperationLookupChip, - SharedBitwiseOperationLookupChip, -}; -use openvm_instructions::{ - instruction::Instruction, - riscv::{RV32_CELL_BITS, RV32_MEMORY_AS}, - LocalOpcode, -}; -use openvm_keccak256_transpiler::Rv32KeccakOpcode::{self, *}; -use openvm_stark_backend::{ - p3_field::PrimeCharacteristicRing, - p3_matrix::{ - dense::{DenseMatrix, RowMajorMatrix}, - Matrix, - }, - utils::disable_debug_builder, -}; -use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng}; -use rand::{rngs::StdRng, Rng}; -use tiny_keccak::Hasher; -#[cfg(feature = "cuda")] -use { - crate::{trace::KeccakVmRecordMut, Keccak256ChipGpu}, - openvm_circuit::arch::testing::{ - default_bitwise_lookup_bus, GpuChipTestBuilder, GpuTestChipHarness, - }, -}; - -use super::{columns::KeccakVmCols, KeccakVmChip}; -use crate::{utils::keccak256, KeccakVmAir, KeccakVmExecutor, KeccakVmFiller}; - -type F = BabyBear; -const MAX_INS_CAPACITY: usize = 4096; -type Harness = TestChipHarness, RA>; - -fn create_harness_fields( - execution_bridge: ExecutionBridge, - memory_bridge: MemoryBridge, - bitwise_chip: Arc>, - memory_helper: SharedMemoryHelper, - address_bits: usize, -) -> (KeccakVmAir, KeccakVmExecutor, KeccakVmChip) { - let air = KeccakVmAir::new( - execution_bridge, - memory_bridge, - bitwise_chip.bus(), - address_bits, - Rv32KeccakOpcode::CLASS_OFFSET, - ); - let executor = KeccakVmExecutor::new(Rv32KeccakOpcode::CLASS_OFFSET, address_bits); - let chip = KeccakVmChip::new( - KeccakVmFiller::new(bitwise_chip, address_bits), - memory_helper, - ); - (air, executor, chip) -} - -fn create_test_harness( - tester: &mut VmChipTestBuilder, -) -> ( - Harness, - ( - BitwiseOperationLookupAir, - SharedBitwiseOperationLookupChip, - ), -) { - let bitwise_bus = BitwiseOperationLookupBus::new(BITWISE_OP_LOOKUP_BUS); - let bitwise_chip = Arc::new(BitwiseOperationLookupChip::::new( - bitwise_bus, - )); - - let (air, executor, chip) = create_harness_fields( - tester.execution_bridge(), - tester.memory_bridge(), - bitwise_chip.clone(), - tester.memory_helper(), - tester.address_bits(), - ); - - let harness = Harness::::with_capacity(executor, air, chip, MAX_INS_CAPACITY); - - (harness, (bitwise_chip.air, bitwise_chip)) -} - -#[allow(clippy::too_many_arguments)] -fn set_and_execute>( - tester: &mut impl TestBuilder, - executor: &mut E, - arena: &mut RA, - rng: &mut StdRng, - opcode: Rv32KeccakOpcode, - message: Option<&[u8]>, - len: Option, - expected_output: Option<[u8; 32]>, -) { - let len = len.unwrap_or(rng.random_range(1..3000)); - let tmp = get_random_message(rng, len); - let message: &[u8] = message.unwrap_or(&tmp); - let len = message.len(); - - let rd = gen_pointer(rng, 4); - let rs1 = gen_pointer(rng, 4); - let rs2 = gen_pointer(rng, 4); - - let dst_ptr = gen_pointer(rng, 4); - let src_ptr = gen_pointer(rng, 4); - tester.write(1, rd, dst_ptr.to_le_bytes().map(F::from_u8)); - tester.write(1, rs1, src_ptr.to_le_bytes().map(F::from_u8)); - tester.write(1, rs2, len.to_le_bytes().map(F::from_u8)); - - message.chunks(4).enumerate().for_each(|(i, chunk)| { - let rng = rng.random(); - let chunk: [&u8; 4] = array::from_fn(|i| chunk.get(i).unwrap_or(&rng)); - tester.write( - RV32_MEMORY_AS as usize, - src_ptr + i * 4, - chunk.map(|&x| F::from_u8(x)), - ); - }); - - tester.execute( - executor, - arena, - &Instruction::from_usize(opcode.global_opcode(), [rd, rs1, rs2, 1, 2]), - ); - - let expected_output = expected_output.unwrap_or(keccak256(message)); - println!("expected_output: {expected_output:?}"); - println!("keccak256(message): {:?}", keccak256(message)); - assert_eq!( - expected_output.map(F::from_u8), - tester.read(RV32_MEMORY_AS as usize, dst_ptr) - ); -} - -/////////////////////////////////////////////////////////////////////////////////////// -/// POSITIVE TESTS -/// -/// Randomly generate computations and execute, ensuring that the generated trace -/// passes all constraints. -/////////////////////////////////////////////////////////////////////////////////////// -#[test] -fn rand_keccak256_test() { - let mut rng = create_seeded_rng(); - let mut tester = VmChipTestBuilder::default(); - let (mut harness, bitwise) = create_test_harness(&mut tester); - - let num_ops: usize = 10; - for _ in 0..num_ops { - set_and_execute( - &mut tester, - &mut harness.executor, - &mut harness.arena, - &mut rng, - KECCAK256, - None, - None, - None, - ); - } - - let tester = tester - .build() - .load(harness) - .load_periphery(bitwise) - .finalize(); - tester.simple_test().expect("Verification failed"); -} - -#[test] -fn keccak256_length_tests() { - let mut rng = create_seeded_rng(); - let mut tester = VmChipTestBuilder::default(); - let (mut harness, bitwise) = create_test_harness(&mut tester); - - // Test special length edge cases: - for len in [0, 135, 136, 137, 2000, 10000] { - println!("Testing length: {len}"); - set_and_execute( - &mut tester, - &mut harness.executor, - &mut harness.arena, - &mut rng, - KECCAK256, - None, - Some(len), - None, - ); - } - - let tester = tester - .build() - .load(harness) - .load_periphery(bitwise) - .finalize(); - tester.simple_test().expect("Verification failed"); -} - -// Keccak Known Answer Test (KAT) vectors from https://keccak.team/obsolete/KeccakKAT-3.zip. -// Only selecting a small subset for now (add more later) -// KAT includes inputs at the bit level; we only include the ones that are bytes -#[test] -fn test_keccak256_positive_kat_vectors() { - // input, output, Len in bits - let test_vectors = vec![ - ("", "C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470"), // ShortMsgKAT_256 Len = 0 - ("CC", "EEAD6DBFC7340A56CAEDC044696A168870549A6A7F6F56961E84A54BD9970B8A"), // ShortMsgKAT_256 Len = 8 - ("B55C10EAE0EC684C16D13463F29291BF26C82E2FA0422A99C71DB4AF14DD9C7F33EDA52FD73D017CC0F2DBE734D831F0D820D06D5F89DACC485739144F8CFD4799223B1AFF9031A105CB6A029BA71E6E5867D85A554991C38DF3C9EF8C1E1E9A7630BE61CAABCA69280C399C1FB7A12D12AEFC", "0347901965D3635005E75A1095695CCA050BC9ED2D440C0372A31B348514A889"), // ShortMsgKAT_256 Len = 920 - ("2EDC282FFB90B97118DD03AAA03B145F363905E3CBD2D50ECD692B37BF000185C651D3E9726C690D3773EC1E48510E42B17742B0B0377E7DE6B8F55E00A8A4DB4740CEE6DB0830529DD19617501DC1E9359AA3BCF147E0A76B3AB70C4984C13E339E6806BB35E683AF8527093670859F3D8A0FC7D493BCBA6BB12B5F65E71E705CA5D6C948D66ED3D730B26DB395B3447737C26FAD089AA0AD0E306CB28BF0ACF106F89AF3745F0EC72D534968CCA543CD2CA50C94B1456743254E358C1317C07A07BF2B0ECA438A709367FAFC89A57239028FC5FECFD53B8EF958EF10EE0608B7F5CB9923AD97058EC067700CC746C127A61EE3", "DD1D2A92B3F3F3902F064365838E1F5F3468730C343E2974E7A9ECFCD84AA6DB"), // ShortMsgKAT_256 Len = 1952, - ("724627916C50338643E6996F07877EAFD96BDF01DA7E991D4155B9BE1295EA7D21C9391F4C4A41C75F77E5D27389253393725F1427F57914B273AB862B9E31DABCE506E558720520D33352D119F699E784F9E548FF91BC35CA147042128709820D69A8287EA3257857615EB0321270E94B84F446942765CE882B191FAEE7E1C87E0F0BD4E0CD8A927703524B559B769CA4ECE1F6DBF313FDCF67C572EC4185C1A88E86EC11B6454B371980020F19633B6B95BD280E4FBCB0161E1A82470320CEC6ECFA25AC73D09F1536F286D3F9DACAFB2CD1D0CE72D64D197F5C7520B3CCB2FD74EB72664BA93853EF41EABF52F015DD591500D018DD162815CC993595B195", "EA0E416C0F7B4F11E3F00479FDDF954F2539E5E557753BD546F69EE375A5DE29"), // LongMsgKAT_256 Len = 2048 - ("6E1CADFB2A14C5FFB1DD69919C0124ED1B9A414B2BEA1E5E422D53B022BDD13A9C88E162972EBB9852330006B13C5B2F2AFBE754AB7BACF12479D4558D19DDBB1A6289387B3AC084981DF335330D1570850B97203DBA5F20CF7FF21775367A8401B6EBE5B822ED16C39383232003ABC412B0CE0DD7C7DA064E4BB73E8C58F222A1512D5FE6D947316E02F8AA87E7AA7A3AA1C299D92E6414AE3B927DB8FF708AC86A09B24E1884743BC34067BB0412453B4A6A6509504B550F53D518E4BCC3D9C1EFDB33DA2EACCB84C9F1CAEC81057A8508F423B25DB5500E5FC86AB3B5EB10D6D0BF033A716DDE55B09FD53451BBEA644217AE1EF91FAD2B5DCC6515249C96EE7EABFD12F1EF65256BD1CFF2087DABF2F69AD1FFB9CF3BC8CA437C7F18B6095BC08D65DF99CC7F657C418D8EB109FDC91A13DC20A438941726EF24F9738B6552751A320C4EA9C8D7E8E8592A3B69D30A419C55FB6CB0850989C029AAAE66305E2C14530B39EAA86EA3BA2A7DECF4B2848B01FAA8AA91F2440B7CC4334F63061CE78AA1589BEFA38B194711697AE3AADCB15C9FBF06743315E2F97F1A8B52236ACB444069550C2345F4ED12E5B8E881CDD472E803E5DCE63AE485C2713F81BC307F25AC74D39BAF7E3BC5E7617465C2B9C309CB0AC0A570A7E46C6116B2242E1C54F456F6589E20B1C0925BF1CD5F9344E01F63B5BA9D4671ABBF920C7ED32937A074C33836F0E019DFB6B35D865312C6058DFDAFF844C8D58B75071523E79DFBAB2EA37479DF12C474584F4FF40F00F92C6BADA025CE4DF8FAF0AFB2CE75C07773907CA288167D6B011599C3DE0FFF16C1161D31DF1C1DDE217CB574ED5A33751759F8ED2B1E6979C5088B940926B9155C9D250B479948C20ACB5578DC02C97593F646CC5C558A6A0F3D8D273258887CCFF259197CB1A7380622E371FD2EB5376225EC04F9ED1D1F2F08FA2376DB5B790E73086F581064ED1C5F47E989E955D77716B50FB64B853388FBA01DAC2CEAE99642341F2DA64C56BEFC4789C051E5EB79B063F2F084DB4491C3C5AA7B4BCF7DD7A1D7CED1554FA67DCA1F9515746A237547A4A1D22ACF649FA1ED3B9BB52BDE0C6996620F8CFDB293F8BACAD02BCE428363D0BB3D391469461D212769048219220A7ED39D1F9157DFEA3B4394CA8F5F612D9AC162BF0B961BFBC157E5F863CE659EB235CF98E8444BC8C7880BDDCD0B3B389AAA89D5E05F84D0649EEBACAB4F1C75352E89F0E9D91E4ACA264493A50D2F4AED66BD13650D1F18E7199E931C78AEB763E903807499F1CD99AF81276B615BE8EC709B039584B2B57445B014F6162577F3548329FD288B0800F936FC5EA1A412E3142E609FC8E39988CA53DF4D8FB5B5FB5F42C0A01648946AC6864CFB0E92856345B08E5DF0D235261E44CFE776456B40AEF0AC1A0DFA2FE639486666C05EA196B0C1A9D346435E03965E6139B1CE10129F8A53745F80100A94AE04D996C13AC14CF2713E39DFBB19A936CF3861318BD749B1FB82F40D73D714E406CBEB3D920EA037B7DE566455CCA51980F0F53A762D5BF8A4DBB55AAC0EDDB4B1F2AED2AA3D01449D34A57FDE4329E7FF3F6BECE4456207A4225218EE9F174C2DE0FF51CEAF2A07CF84F03D1DF316331E3E725C5421356C40ED25D5ABF9D24C4570FED618CA41000455DBD759E32E2BF0B6C5E61297C20F752C3042394CE840C70943C451DD5598EB0E4953CE26E833E5AF64FC1007C04456D19F87E45636F456B7DC9D31E757622E2739573342DE75497AE181AAE7A5425756C8E2A7EEF918E5C6A968AEFE92E8B261BBFE936B19F9E69A3C90094096DAE896450E1505ED5828EE2A7F0EA3A28E6EC47C0AF711823E7689166EA07ECA00FFC493131D65F93A4E1D03E0354AFC2115CFB8D23DAE8C6F96891031B23226B8BC82F1A73DAA5BB740FC8CC36C0975BEFA0C7895A9BBC261EDB7FD384103968F7A18353D5FE56274E4515768E4353046C785267DE01E816A2873F97AAD3AB4D7234EBFD9832716F43BE8245CF0B4408BA0F0F764CE9D24947AB6ABDD9879F24FCFF10078F5894B0D64F6A8D3EA3DD92A0C38609D3C14FDC0A44064D501926BE84BF8034F1D7A8C5F382E6989BFFA2109D4FBC56D1F091E8B6FABFF04D21BB19656929D19DECB8E8291E6AE5537A169874E0FE9890DFF11FFD159AD23D749FB9E8B676E2C31313C16D1EFA06F4D7BC191280A4EE63049FCEF23042B20303AECDD412A526D7A53F760A089FBDF13F361586F0DCA76BB928EDB41931D11F679619F948A6A9E8DBA919327769006303C6EF841438A7255C806242E2E7FF4621BB0F8AFA0B4A248EAD1A1E946F3E826FBFBBF8013CE5CC814E20FEF21FA5DB19EC7FF0B06C592247B27E500EB4705E6C37D41D09E83CB0A618008CA1AAAE8A215171D817659063C2FA385CFA3C1078D5C2B28CE7312876A276773821BE145785DFF24BBB24D590678158A61EA49F2BE56FDAC8CE7F94B05D62F15ADD351E5930FD4F31B3E7401D5C0FF7FC845B165FB6ABAFD4788A8B0615FEC91092B34B710A68DA518631622BA2AAE5D19010D307E565A161E64A4319A6B261FB2F6A90533997B1AEC32EF89CF1F232696E213DAFE4DBEB1CF1D5BBD12E5FF2EBB2809184E37CD9A0E58A4E0AF099493E6D8CC98B05A2F040A7E39515038F6EE21FC25F8D459A327B83EC1A28A234237ACD52465506942646AC248EC96EBBA6E1B092475F7ADAE4D35E009FD338613C7D4C12E381847310A10E6F02C02392FC32084FBE939689BC6518BE27AF7842DEEA8043828E3DFFE3BBAC4794CA0CC78699722709F2E4B0EAE7287DEB06A27B462423EC3F0DF227ACF589043292685F2C0E73203E8588B62554FF19D6260C7FE48DF301509D33BE0D8B31D3F658C921EF7F55449FF3887D91BFB894116DF57206098E8C5835B", "3C79A3BD824542C20AF71F21D6C28DF2213A041F77DD79A328A0078123954E7B"), // LongMsgKAT_256 Len = 16664 - ("7ADC0B6693E61C269F278E6944A5A2D8300981E40022F839AC644387BFAC9086650085C2CDC585FEA47B9D2E52D65A2B29A7DC370401EF5D60DD0D21F9E2B90FAE919319B14B8C5565B0423CEFB827D5F1203302A9D01523498A4DB10374", "4CC2AFF141987F4C2E683FA2DE30042BACDCD06087D7A7B014996E9CFEAA58CE"), // ShortMsgKAT_256 Len = 752 - ]; - - let mut rng = create_seeded_rng(); - let mut tester = VmChipTestBuilder::default(); - let (mut harness, bitwise) = create_test_harness(&mut tester); - - for (input, output) in test_vectors { - let input = Vec::from_hex(input).unwrap(); - let output = Vec::from_hex(output).unwrap().try_into().unwrap(); - set_and_execute( - &mut tester, - &mut harness.executor, - &mut harness.arena, - &mut rng, - KECCAK256, - Some(&input), - None, - Some(output), - ); - } - let tester = tester - .build() - .load(harness) - .load_periphery(bitwise) - .finalize(); - tester.simple_test().expect("Verification failed"); -} - -////////////////////////////////////////////////////////////////////////////////////// -// NEGATIVE TESTS -// -// Given a fake trace of a single operation, setup a chip and run the test. We replace -// part of the trace and check that the chip throws the expected error. -////////////////////////////////////////////////////////////////////////////////////// -fn run_negative_keccak256_test(input: &[u8], prank_output: [u8; 32]) { - let mut rng = create_seeded_rng(); - let mut tester = VmChipTestBuilder::default(); - let (mut harness, bitwise) = create_test_harness(&mut tester); - - set_and_execute( - &mut tester, - &mut harness.executor, - &mut harness.arena, - &mut rng, - KECCAK256, - Some(input), - None, - None, - ); - - let modify_trace = |trace: &mut DenseMatrix| { - let mut trace_row = trace - .row_slice(16) - .expect("trace row should be present") - .to_vec(); - let digest_row: &mut KeccakVmCols<_> = trace_row.as_mut_slice().borrow_mut(); - for i in 0..16 { - let out_limb = - F::from_u16(prank_output[2 * i] as u16 + ((prank_output[2 * i + 1] as u16) << 8)); - let x = i / 4; - let y = 0; - let limb = i % 4; - if x == 0 && y == 0 { - digest_row.inner.a_prime_prime_prime_0_0_limbs[limb] = out_limb; - } else { - digest_row.inner.a_prime_prime[y][x][limb] = out_limb; - } - } - *trace = RowMajorMatrix::new(trace_row, trace.width()); - }; - - disable_debug_builder(); - let tester = tester - .build() - .load_and_prank_trace(harness, modify_trace) - .load_periphery(bitwise) - .finalize(); - tester - .simple_test() - .expect_err("Expected verification to fail, but it passed"); -} - -#[test] -fn test_keccak256_negative() { - let mut rng = create_seeded_rng(); - let mut hasher = tiny_keccak::Keccak::v256(); - let input: Vec<_> = vec![0; 137]; - hasher.update(&input); - let mut out = [0u8; 32]; - hasher.finalize(&mut out); - out[0] = rng.random(); - run_negative_keccak256_test(&input, out); -} - -// //////////////////////////////////////////////////////////////////////////////////// -// CUDA TESTS -// -// Ensure GPU tracegen is equivalent to CPU tracegen -// //////////////////////////////////////////////////////////////////////////////////// -#[cfg(feature = "cuda")] -type GpuHarness = - GpuTestChipHarness>; - -#[cfg(feature = "cuda")] -fn create_cuda_harness(tester: &GpuChipTestBuilder) -> GpuHarness { - // getting bus from tester since `gpu_chip` and `air` must use the same bus - let bitwise_bus = default_bitwise_lookup_bus(); - // creating a dummy chip for Cpu so we only count `add_count`s from GPU - let dummy_bitwise_chip = Arc::new(BitwiseOperationLookupChip::::new( - bitwise_bus, - )); - - let (air, executor, cpu_chip) = create_harness_fields( - tester.execution_bridge(), - tester.memory_bridge(), - dummy_bitwise_chip, - tester.dummy_memory_helper(), - tester.address_bits(), - ); - - let gpu_chip = Keccak256ChipGpu::new( - tester.range_checker(), - tester.bitwise_op_lookup(), - tester.address_bits() as u32, - tester.timestamp_max_bits() as u32, - ); - - GpuTestChipHarness::with_capacity(executor, air, gpu_chip, cpu_chip, MAX_INS_CAPACITY) -} - -#[cfg(feature = "cuda")] -#[test] -fn test_keccak256_cuda_tracegen() { - let mut rng = create_seeded_rng(); - let mut tester = - GpuChipTestBuilder::default().with_bitwise_op_lookup(default_bitwise_lookup_bus()); - - let mut harness = create_cuda_harness(&tester); - - let num_ops: usize = 10; - for _ in 0..num_ops { - set_and_execute( - &mut tester, - &mut harness.executor, - &mut harness.dense_arena, - &mut rng, - KECCAK256, - None, - None, - None, - ); - } - - // Test special length edge cases: - for len in [0, 135, 136, 137, 2000] { - println!("Testing length: {len}"); - set_and_execute( - &mut tester, - &mut harness.executor, - &mut harness.dense_arena, - &mut rng, - KECCAK256, - None, - Some(len), - None, - ); - } - - harness - .dense_arena - .get_record_seeker::() - .transfer_to_matrix_arena(&mut harness.matrix_arena); - - tester - .build() - .load_gpu_harness(harness) - .finalize() - .simple_test() - .unwrap(); -} - -#[cfg(feature = "cuda")] -#[test] -fn test_keccak256_cuda_tracegen_multi() { - let num_threads: usize = std::env::var("NUM_THREADS") - .ok() - .and_then(|s| s.parse().ok()) - .unwrap_or(2); - - let num_tasks: usize = std::env::var("NUM_TASKS") - .ok() - .and_then(|s| s.parse().ok()) - .unwrap_or(num_threads * 4); - - let runtime = tokio::runtime::Builder::new_multi_thread() - .max_blocking_threads(num_threads) - .enable_all() - .build() - .unwrap(); - - runtime.block_on(async { - let tasks_per_thread = num_tasks.div_ceil(num_threads); - let mut worker_handles = Vec::new(); - - for worker_idx in 0..num_threads { - let start_task = worker_idx * tasks_per_thread; - let end_task = std::cmp::min(start_task + tasks_per_thread, num_tasks); - - let worker_handle = tokio::task::spawn(async move { - for task_id in start_task..end_task { - tokio::task::spawn_blocking(move || { - println!("[worker {worker_idx}, task {task_id}] Starting test"); - - let mut rng = create_seeded_rng(); - let mut tester = GpuChipTestBuilder::default() - .with_bitwise_op_lookup(default_bitwise_lookup_bus()); - - let mut harness = create_cuda_harness(&tester); - - let num_ops: usize = 10; - for _ in 0..num_ops { - set_and_execute( - &mut tester, - &mut harness.executor, - &mut harness.dense_arena, - &mut rng, - KECCAK256, - None, - None, - None, - ); - } - - for len in [0, 135, 136, 137, 2000] { - set_and_execute( - &mut tester, - &mut harness.executor, - &mut harness.dense_arena, - &mut rng, - KECCAK256, - None, - Some(len), - None, - ); - } - - harness - .dense_arena - .get_record_seeker::() - .transfer_to_matrix_arena(&mut harness.matrix_arena); - - tester - .build() - .load_gpu_harness(harness) - .finalize() - .simple_test() - .unwrap(); - - println!("[worker {worker_idx}, task {task_id}] Test completed ✅"); - }) - .await - .expect("task failed"); - } - }); - worker_handles.push(worker_handle); - } - - for handle in worker_handles { - handle.await.expect("worker failed"); - } - - println!("\nAll {num_tasks} tasks completed on {num_threads} workers."); - }); -} diff --git a/extensions/keccak256/circuit/src/trace.rs b/extensions/keccak256/circuit/src/trace.rs deleted file mode 100644 index 04b7cea4e6..0000000000 --- a/extensions/keccak256/circuit/src/trace.rs +++ /dev/null @@ -1,578 +0,0 @@ -use std::{ - array::{self, from_fn}, - borrow::{Borrow, BorrowMut}, - cmp::min, -}; - -use openvm_circuit::{ - arch::*, - system::memory::{ - offline_checker::{MemoryReadAuxRecord, MemoryWriteBytesAuxRecord}, - online::TracingMemory, - MemoryAuxColsFactory, - }, -}; -use openvm_circuit_primitives::AlignedBytesBorrow; -use openvm_instructions::{ - instruction::Instruction, - program::DEFAULT_PC_STEP, - riscv::{RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS}, - LocalOpcode, -}; -use openvm_keccak256_transpiler::Rv32KeccakOpcode; -use openvm_rv32im_circuit::adapters::{read_rv32_register, tracing_read, tracing_write}; -use openvm_stark_backend::{ - p3_field::PrimeField32, - p3_matrix::{dense::RowMajorMatrix, Matrix}, - p3_maybe_rayon::prelude::*, -}; -use p3_keccak_air::{ - generate_trace_rows, NUM_KECCAK_COLS as NUM_KECCAK_PERM_COLS, NUM_ROUNDS, U64_LIMBS, -}; -use tiny_keccak::keccakf; - -use super::{ - columns::KeccakVmCols, KECCAK_ABSORB_READS, KECCAK_DIGEST_WRITES, KECCAK_RATE_BYTES, - KECCAK_REGISTER_READS, NUM_ABSORB_ROUNDS, -}; -use crate::{ - columns::NUM_KECCAK_VM_COLS, - utils::{keccak256, keccak_f, num_keccak_f}, - KeccakVmExecutor, KeccakVmFiller, KECCAK_DIGEST_BYTES, KECCAK_RATE_U16S, KECCAK_WORD_SIZE, -}; - -#[derive(Clone, Copy)] -pub struct KeccakVmMetadata { - pub len: usize, -} - -impl MultiRowMetadata for KeccakVmMetadata { - #[inline(always)] - fn get_num_rows(&self) -> usize { - num_keccak_f(self.len) * NUM_ROUNDS - } -} - -pub(crate) type KeccakVmRecordLayout = MultiRowLayout; - -#[repr(C)] -#[derive(AlignedBytesBorrow, Debug, Clone)] -pub struct KeccakVmRecordHeader { - pub from_pc: u32, - pub timestamp: u32, - pub rd_ptr: u32, - pub rs1_ptr: u32, - pub rs2_ptr: u32, - pub dst: u32, - pub src: u32, - pub len: u32, - - pub register_reads_aux: [MemoryReadAuxRecord; KECCAK_REGISTER_READS], - pub write_aux: [MemoryWriteBytesAuxRecord; KECCAK_DIGEST_WRITES], -} - -pub struct KeccakVmRecordMut<'a> { - pub inner: &'a mut KeccakVmRecordHeader, - // Having a continuous slice of the input is useful for fast hashing in `execute` - pub input: &'a mut [u8], - pub read_aux: &'a mut [MemoryReadAuxRecord], -} - -/// Custom borrowing that splits the buffer into a fixed `KeccakVmRecord` header -/// followed by a slice of `u8`'s of length `num_reads * KECCAK_WORD_SIZE` where `num_reads` is -/// provided at runtime, followed by a slice of `MemoryReadAuxRecord`'s of length `num_reads`. -/// Uses `align_to_mut()` to make sure the slice is properly aligned to `MemoryReadAuxRecord`. -/// Has debug assertions that check the size and alignment of the slices. -impl<'a> CustomBorrow<'a, KeccakVmRecordMut<'a>, KeccakVmRecordLayout> for [u8] { - fn custom_borrow(&'a mut self, layout: KeccakVmRecordLayout) -> KeccakVmRecordMut<'a> { - // SAFETY: - // - Caller guarantees through the layout that self has sufficient length for all splits and - // constants are guaranteed <= self.len() by layout precondition - let (record_buf, rest) = - unsafe { self.split_at_mut_unchecked(size_of::()) }; - - let num_reads = layout.metadata.len.div_ceil(KECCAK_WORD_SIZE); - // Note: each read is `KECCAK_WORD_SIZE` bytes - // SAFETY: - // - layout guarantees rest has sufficient length for input data - // - num_reads is calculated from layout.metadata.len - // - total buffer size was validated to contain header + input + aligned aux records - let (input, rest) = unsafe { rest.split_at_mut_unchecked(num_reads * KECCAK_WORD_SIZE) }; - let (_, read_aux_buf, _) = unsafe { rest.align_to_mut::() }; - KeccakVmRecordMut { - inner: record_buf.borrow_mut(), - input, - read_aux: &mut read_aux_buf[..num_reads], - } - } - - unsafe fn extract_layout(&self) -> KeccakVmRecordLayout { - let header: &KeccakVmRecordHeader = self.borrow(); - KeccakVmRecordLayout { - metadata: KeccakVmMetadata { - len: header.len as usize, - }, - } - } -} - -impl SizedRecord for KeccakVmRecordMut<'_> { - fn size(layout: &KeccakVmRecordLayout) -> usize { - let num_reads = layout.metadata.len.div_ceil(KECCAK_WORD_SIZE); - let mut total_len = size_of::(); - total_len += num_reads * KECCAK_WORD_SIZE; - // Align the pointer to the alignment of `MemoryReadAuxRecord` - total_len = total_len.next_multiple_of(align_of::()); - total_len += num_reads * size_of::(); - total_len - } - - fn alignment(_layout: &KeccakVmRecordLayout) -> usize { - align_of::() - } -} - -impl PreflightExecutor for KeccakVmExecutor -where - F: PrimeField32, - for<'buf> RA: RecordArena<'buf, KeccakVmRecordLayout, KeccakVmRecordMut<'buf>>, -{ - fn get_opcode_name(&self, _: usize) -> String { - format!("{:?}", Rv32KeccakOpcode::KECCAK256) - } - - fn execute( - &self, - state: VmStateMut, - instruction: &Instruction, - ) -> Result<(), ExecutionError> { - let &Instruction { - opcode, - a, - b, - c, - d, - e, - .. - } = instruction; - debug_assert_eq!(opcode, Rv32KeccakOpcode::KECCAK256.global_opcode()); - debug_assert_eq!(d.as_canonical_u32(), RV32_REGISTER_AS); - debug_assert_eq!(e.as_canonical_u32(), RV32_MEMORY_AS); - - // Reading the length first without tracing to allocate a record of correct size - let len = read_rv32_register(state.memory.data(), c.as_canonical_u32()) as usize; - - let num_reads = len.div_ceil(KECCAK_WORD_SIZE); - let num_blocks = num_keccak_f(len); - let record = state - .ctx - .alloc(KeccakVmRecordLayout::new(KeccakVmMetadata { len })); - - record.inner.from_pc = *state.pc; - record.inner.timestamp = state.memory.timestamp(); - record.inner.rd_ptr = a.as_canonical_u32(); - record.inner.rs1_ptr = b.as_canonical_u32(); - record.inner.rs2_ptr = c.as_canonical_u32(); - - record.inner.dst = u32::from_le_bytes(tracing_read( - state.memory, - RV32_REGISTER_AS, - record.inner.rd_ptr, - &mut record.inner.register_reads_aux[0].prev_timestamp, - )); - record.inner.src = u32::from_le_bytes(tracing_read( - state.memory, - RV32_REGISTER_AS, - record.inner.rs1_ptr, - &mut record.inner.register_reads_aux[1].prev_timestamp, - )); - record.inner.len = u32::from_le_bytes(tracing_read( - state.memory, - RV32_REGISTER_AS, - record.inner.rs2_ptr, - &mut record.inner.register_reads_aux[2].prev_timestamp, - )); - - debug_assert!(record.inner.src as usize + len <= (1 << self.pointer_max_bits)); - debug_assert!( - record.inner.dst as usize + KECCAK_DIGEST_BYTES <= (1 << self.pointer_max_bits) - ); - // We don't support messages longer than 2^[pointer_max_bits] bytes - debug_assert!(record.inner.len < (1 << self.pointer_max_bits)); - - for idx in 0..num_reads { - if idx % KECCAK_ABSORB_READS == 0 && idx != 0 { - // Need to increment the timestamp according at the start of each block due to the - // AIR constraints - state - .memory - .increment_timestamp_by(KECCAK_REGISTER_READS as u32); - } - let read = tracing_read::( - state.memory, - RV32_MEMORY_AS, - record.inner.src + (idx * KECCAK_WORD_SIZE) as u32, - &mut record.read_aux[idx].prev_timestamp, - ); - record.input[idx * KECCAK_WORD_SIZE..(idx + 1) * KECCAK_WORD_SIZE] - .copy_from_slice(&read); - } - - // Due to the AIR constraints, need to set the timestamp to the following: - state.memory.timestamp = record.inner.timestamp - + (num_blocks * (KECCAK_ABSORB_READS + KECCAK_REGISTER_READS)) as u32; - - let digest = keccak256(&record.input[..len]); - for (i, word) in digest.chunks_exact(KECCAK_WORD_SIZE).enumerate() { - tracing_write::( - state.memory, - RV32_MEMORY_AS, - record.inner.dst + (i * KECCAK_WORD_SIZE) as u32, - word.try_into().unwrap(), - &mut record.inner.write_aux[i].prev_timestamp, - &mut record.inner.write_aux[i].prev_data, - ); - } - - // Due to the AIR constraints, the final memory timestamp should be the following: - state.memory.timestamp = record.inner.timestamp - + (len + KECCAK_REGISTER_READS + KECCAK_ABSORB_READS + KECCAK_DIGEST_WRITES) as u32; - *state.pc = state.pc.wrapping_add(DEFAULT_PC_STEP); - Ok(()) - } -} - -impl TraceFiller for KeccakVmFiller { - fn fill_trace( - &self, - mem_helper: &MemoryAuxColsFactory, - trace_matrix: &mut RowMajorMatrix, - rows_used: usize, - ) { - if rows_used == 0 { - return; - } - - let mut chunks = Vec::with_capacity(trace_matrix.height() / NUM_ROUNDS); - let mut sizes = Vec::with_capacity(trace_matrix.height() / NUM_ROUNDS); - let mut trace = &mut trace_matrix.values[..]; - let mut num_blocks_so_far = 0; - - // First pass over the trace to get the number of blocks for each instruction - // and divide the matrix into chunks of needed sizes - loop { - if num_blocks_so_far * NUM_ROUNDS >= rows_used { - // Push all the dummy rows as a single chunk and break - chunks.push(trace); - sizes.push((0, 0)); - break; - } else { - // SAFETY: - // - caller ensures `trace` contains a valid record representation that was - // previously written by the executor - // - header is the first element of the record - let record: &KeccakVmRecordHeader = - unsafe { get_record_from_slice(&mut trace, ()) }; - let num_blocks = num_keccak_f(record.len as usize); - let (chunk, rest) = - trace.split_at_mut(NUM_KECCAK_VM_COLS * NUM_ROUNDS * num_blocks); - chunks.push(chunk); - sizes.push((num_blocks, record.len as usize)); - num_blocks_so_far += num_blocks; - trace = rest; - } - } - - // First, parallelize over instruction chunks, every instruction can have multiple blocks - // Then, compute some additional values for each block and parallelize over blocks within an - // instruction Finally, compute some additional values for each row and parallelize - // over rows within a block - chunks - .par_iter_mut() - .zip(sizes.par_iter()) - .for_each(|(slice, (num_blocks, len))| { - if *num_blocks == 0 { - // Fill in the dummy rows in parallel - // Note: a 'block' of dummy rows is generated by `generate_trace_rows` from the - // zero state dummy rows are repeated every - // `NUM_ROUNDS` rows - let p3_trace: RowMajorMatrix = generate_trace_rows(vec![[0u64; 25]; 1], 0); - - slice - .par_chunks_exact_mut(NUM_KECCAK_VM_COLS) - .enumerate() - .for_each(|(row_idx, row)| { - let idx = row_idx % NUM_ROUNDS; - row[..NUM_KECCAK_PERM_COLS].copy_from_slice( - &p3_trace.values - [idx * NUM_KECCAK_PERM_COLS..(idx + 1) * NUM_KECCAK_PERM_COLS], - ); - - // Need to get rid of the accidental garbage data that might overflow - // the F's prime field. Unfortunately, there - // is no good way around this - // SAFETY: - // - row has exactly NUM_KECCAK_VM_COLS elements - // - NUM_KECCAK_PERM_COLS offset is less than NUM_KECCAK_VM_COLS by - // design - // - We're zeroing the remaining (NUM_KECCAK_VM_COLS - - // NUM_KECCAK_PERM_COLS) elements to clear any garbage data that might - // overflow the field - unsafe { - std::ptr::write_bytes( - row.as_mut_ptr().add(NUM_KECCAK_PERM_COLS) as *mut u8, - 0, - (NUM_KECCAK_VM_COLS - NUM_KECCAK_PERM_COLS) * size_of::(), - ); - } - let cols: &mut KeccakVmCols = row.borrow_mut(); - // The first row of a `dummy` block should have `is_new_start = F::ONE` - cols.sponge.is_new_start = F::from_bool(idx == 0); - cols.sponge.block_bytes[0] = F::ONE; - cols.sponge.block_bytes[KECCAK_RATE_BYTES - 1] = F::from_u32(0x80); - cols.sponge.is_padding_byte = [F::ONE; KECCAK_RATE_BYTES]; - }); - return; - } - - let num_reads = len.div_ceil(KECCAK_WORD_SIZE); - let read_len = num_reads * KECCAK_WORD_SIZE; - - // SAFETY: - // - caller ensures `trace` contains a valid record representation that was - // previously written by the executor - // - slice contains a valid KeccakVmRecord with the exact layout specified - // - get_record_from_slice will correctly split the buffer into header, input, and - // aux components based on this layout - let record: KeccakVmRecordMut = unsafe { - get_record_from_slice( - slice, - KeccakVmRecordLayout::new(KeccakVmMetadata { len: *len }), - ) - }; - - // Copy the read aux records and inner record to another place - // to safely fill in the trace matrix without overwriting the record - let mut read_aux_records = Vec::with_capacity(num_reads); - read_aux_records.extend_from_slice(record.read_aux); - let vm_record = record.inner.clone(); - let partial_block = if read_len != *len { - record.input[read_len - KECCAK_WORD_SIZE + 1..] - .try_into() - .unwrap() - } else { - [0u8; KECCAK_WORD_SIZE - 1] - } - .map(F::from_u8); - let mut input = Vec::with_capacity(*num_blocks * KECCAK_RATE_BYTES); - input.extend_from_slice(&record.input[..*len]); - // Pad the input according to the Keccak spec - input.push(0x01); - input.resize(input.capacity(), 0); - *input.last_mut().unwrap() += 0x80; - - let mut states = Vec::with_capacity(*num_blocks); - let mut state = [0u64; 25]; - - input - .chunks_exact(KECCAK_RATE_BYTES) - .enumerate() - .for_each(|(idx, chunk)| { - // absorb - for (bytes, s) in chunk.chunks_exact(8).zip(state.iter_mut()) { - // u64 <-> bytes conversion is little-endian - for (i, &byte) in bytes.iter().enumerate() { - let s_byte = (*s >> (i * 8)) as u8; - // Update bitwise lookup (i.e. xor) chip state: order matters! - if idx != 0 { - self.bitwise_lookup_chip - .request_xor(byte as u32, s_byte as u32); - } - *s ^= (byte as u64) << (i * 8); - } - } - states.push(state); - keccakf(&mut state); - }); - - slice - .par_chunks_exact_mut(NUM_ROUNDS * NUM_KECCAK_VM_COLS) - .enumerate() - .for_each(|(block_idx, block_slice)| { - let state = states[block_idx]; - - // Note: we can call `generate_trace_rows` for each block separately because - // its trace only depends on the current `state` - // `generate_trace_rows` will generate additional dummy rows to make the - // height into power of 2, but we can safely discard them - let p3_trace: RowMajorMatrix = generate_trace_rows(vec![state], 0); - let input_offset = block_idx * KECCAK_RATE_BYTES; - let start_timestamp = vm_record.timestamp - + (block_idx * (KECCAK_REGISTER_READS + KECCAK_ABSORB_READS)) as u32; - let rem_len = *len - input_offset; - - block_slice - .par_chunks_exact_mut(NUM_KECCAK_VM_COLS) - .enumerate() - .zip(p3_trace.values.par_chunks(NUM_KECCAK_PERM_COLS)) - .for_each(|((row_idx, row), p3_row)| { - // Fill the inner columns - // Safety: `KeccakPermCols` **must** be the first field in - // `KeccakVmCols` - row[..NUM_KECCAK_PERM_COLS].copy_from_slice(p3_row); - - let cols: &mut KeccakVmCols = row.borrow_mut(); - // Fill the sponge columns - cols.sponge.is_new_start = - F::from_bool(block_idx == 0 && row_idx == 0); - if rem_len < KECCAK_RATE_BYTES { - cols.sponge.is_padding_byte[..rem_len].fill(F::ZERO); - cols.sponge.is_padding_byte[rem_len..].fill(F::ONE); - } else { - cols.sponge.is_padding_byte = [F::ZERO; KECCAK_RATE_BYTES]; - } - cols.sponge.block_bytes = - array::from_fn(|i| F::from_u8(input[input_offset + i])); - if row_idx == 0 { - cols.sponge.state_hi = from_fn(|i| { - F::from_u8( - (states[block_idx][i / U64_LIMBS] - >> ((i % U64_LIMBS) * 16 + 8)) - as u8, - ) - }); - } else if row_idx == NUM_ROUNDS - 1 { - let state = keccak_f(states[block_idx]); - cols.sponge.state_hi = from_fn(|i| { - F::from_u8( - (state[i / U64_LIMBS] >> ((i % U64_LIMBS) * 16 + 8)) - as u8, - ) - }); - if block_idx == num_blocks - 1 { - cols.inner.export = F::ONE; - for s in state.into_iter().take(NUM_ABSORB_ROUNDS) { - for s_byte in s.to_le_bytes() { - self.bitwise_lookup_chip - .request_xor(0, s_byte as u32); - } - } - } - } else { - cols.sponge.state_hi = [F::ZERO; KECCAK_RATE_U16S]; - } - - // Fill the instruction columns - cols.instruction.pc = F::from_u32(vm_record.from_pc); - cols.instruction.is_enabled = F::ONE; - cols.instruction.is_enabled_first_round = - F::from_bool(row_idx == 0); - cols.instruction.start_timestamp = F::from_u32(start_timestamp); - cols.instruction.dst_ptr = F::from_u32(vm_record.rd_ptr); - cols.instruction.src_ptr = F::from_u32(vm_record.rs1_ptr); - cols.instruction.len_ptr = F::from_u32(vm_record.rs2_ptr); - cols.instruction.dst = vm_record.dst.to_le_bytes().map(F::from_u8); - - let src = vm_record.src + (block_idx * KECCAK_RATE_BYTES) as u32; - cols.instruction.src = F::from_u32(src); - cols.instruction - .src_limbs - .copy_from_slice(&src.to_le_bytes().map(F::from_u8)[1..]); - cols.instruction.len_limbs.copy_from_slice( - &(rem_len as u32).to_le_bytes().map(F::from_u8)[1..], - ); - cols.instruction.remaining_len = F::from_u32(rem_len as u32); - - // Fill the register reads - if row_idx == 0 && block_idx == 0 { - for ((i, cols), vm_record) in cols - .mem_oc - .register_aux - .iter_mut() - .enumerate() - .zip(vm_record.register_reads_aux.iter()) - { - mem_helper.fill( - vm_record.prev_timestamp, - start_timestamp + i as u32, - cols.as_mut(), - ); - } - - let msl_rshift = RV32_CELL_BITS * (RV32_REGISTER_NUM_LIMBS - 1); - let msl_lshift = RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - - self.pointer_max_bits; - // Update the bitwise lookup chip - self.bitwise_lookup_chip.request_range( - (vm_record.dst >> msl_rshift) << msl_lshift, - (vm_record.src >> msl_rshift) << msl_lshift, - ); - self.bitwise_lookup_chip.request_range( - (vm_record.len >> msl_rshift) << msl_lshift, - (vm_record.len >> msl_rshift) << msl_lshift, - ); - } else { - cols.mem_oc.register_aux.par_iter_mut().for_each(|aux| { - mem_helper.fill_zero(aux.as_mut()); - }); - } - - // Fill the absorb reads - if row_idx == 0 { - let reads_offs = block_idx * KECCAK_ABSORB_READS; - let num_reads = min( - rem_len.div_ceil(KECCAK_WORD_SIZE), - KECCAK_ABSORB_READS, - ); - let start_timestamp = - start_timestamp + KECCAK_REGISTER_READS as u32; - for i in 0..num_reads { - mem_helper.fill( - read_aux_records[i + reads_offs].prev_timestamp, - start_timestamp + i as u32, - cols.mem_oc.absorb_reads[i].as_mut(), - ); - } - for i in num_reads..KECCAK_ABSORB_READS { - mem_helper.fill_zero(cols.mem_oc.absorb_reads[i].as_mut()); - } - } else { - cols.mem_oc.absorb_reads.par_iter_mut().for_each(|aux| { - mem_helper.fill_zero(aux.as_mut()); - }); - } - - if block_idx == num_blocks - 1 && row_idx == NUM_ROUNDS - 1 { - let timestamp = start_timestamp - + (KECCAK_ABSORB_READS + KECCAK_REGISTER_READS) as u32; - cols.mem_oc - .digest_writes - .par_iter_mut() - .enumerate() - .zip(vm_record.write_aux.par_iter()) - .for_each(|((i, cols), vm_record)| { - cols.set_prev_data(vm_record.prev_data.map(F::from_u8)); - mem_helper.fill( - vm_record.prev_timestamp, - timestamp + i as u32, - cols.as_mut(), - ); - }); - } else { - cols.mem_oc.digest_writes.par_iter_mut().for_each(|aux| { - aux.set_prev_data([F::ZERO; KECCAK_WORD_SIZE]); - mem_helper.fill_zero(aux.as_mut()); - }); - } - - // Set the partial block only for the last block - if block_idx == num_blocks - 1 { - cols.mem_oc.partial_block = partial_block; - } else { - cols.mem_oc.partial_block = [F::ZERO; KECCAK_WORD_SIZE - 1]; - } - }); - }); - }); - } -} diff --git a/extensions/keccak256/circuit/src/utils.rs b/extensions/keccak256/circuit/src/utils.rs deleted file mode 100644 index 64417c8a8a..0000000000 --- a/extensions/keccak256/circuit/src/utils.rs +++ /dev/null @@ -1,26 +0,0 @@ -use tiny_keccak::{keccakf, Hasher, Keccak}; - -use super::KECCAK_RATE_BYTES; - -/// Wrapper function for tiny-keccak's keccak-f permutation. -/// Returns the new state after permutation. -pub fn keccak_f(mut state: [u64; 25]) -> [u64; 25] { - keccakf(&mut state); - state -} - -pub fn keccak256(input: &[u8]) -> [u8; 32] { - let mut hasher = Keccak::v256(); - hasher.update(input); - let mut output = [0u8; 32]; - hasher.finalize(&mut output); - output -} - -/// Number of keccak-f permutations required for keccak256 on -/// input of `byte_len` bytes. -pub fn num_keccak_f(byte_len: usize) -> usize { - // always need at least 1 extra byte for padding - // ceil((byte_len + 1) / rate) = byte_len // rate + 1 - byte_len / KECCAK_RATE_BYTES + 1 -} diff --git a/extensions/new-keccak256/circuit/src/xorin/air.rs b/extensions/keccak256/circuit/src/xorin/air.rs similarity index 85% rename from extensions/new-keccak256/circuit/src/xorin/air.rs rename to extensions/keccak256/circuit/src/xorin/air.rs index 382158b9e1..95151b69fe 100644 --- a/extensions/new-keccak256/circuit/src/xorin/air.rs +++ b/extensions/keccak256/circuit/src/xorin/air.rs @@ -12,13 +12,13 @@ use openvm_circuit_primitives::{bitwise_op_lookup::BitwiseOperationLookupBus, ut use openvm_instructions::riscv::{ RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS, }; -use openvm_new_keccak256_transpiler::XorinOpcode; +use openvm_keccak256_transpiler::XorinOpcode; use openvm_stark_backend::{ interaction::InteractionBuilder, p3_air::{Air, AirBuilder, BaseAir}, - p3_field::FieldAlgebra, + p3_field::PrimeCharacteristicRing, p3_matrix::Matrix, - rap::{BaseAirWithPublicValues, PartitionedBaseAir}, + BaseAirWithPublicValues, PartitionedBaseAir, }; use crate::xorin::columns::{XorinVmCols, NUM_XORIN_VM_COLS}; @@ -47,7 +47,7 @@ impl Air for XorinVmAir { fn eval(&self, builder: &mut AB) { let main = builder.main(); - let local = main.row_slice(0); + let local = main.row_slice(0).unwrap(); let local: &XorinVmCols<_> = (*local).borrow(); let mem = &local.mem_oc; @@ -93,16 +93,16 @@ impl XorinVmAir { instruction.len_reg_ptr, ]; - let mut timestamp_change = AB::Expr::from_canonical_u32(3); + let mut timestamp_change = AB::Expr::from_u32(3); let mut not_padding_sum = AB::Expr::ZERO; for is_padding in local.sponge.is_padding_bytes { - timestamp_change += AB::Expr::from_canonical_u32(3) * not(is_padding); + timestamp_change += AB::Expr::from_u32(3) * not(is_padding); not_padding_sum += not(is_padding); builder.assert_bool(is_padding); } - not_padding_sum *= AB::Expr::from_canonical_u32(4); + not_padding_sum *= AB::Expr::from_u32(4); builder .when(is_enabled) .assert_eq(not_padding_sum, instruction.len); @@ -115,13 +115,13 @@ impl XorinVmAir { self.execution_bridge .execute_and_increment_pc( - AB::Expr::from_canonical_usize(XorinOpcode::XORIN as usize + self.offset), + AB::Expr::from_usize(XorinOpcode::XORIN as usize + self.offset), [ buffer_reg_ptr.into(), input_reg_ptr.into(), len_reg_ptr.into(), - AB::Expr::from_canonical_u32(RV32_REGISTER_AS), - AB::Expr::from_canonical_u32(RV32_MEMORY_AS), + AB::Expr::from_u32(RV32_REGISTER_AS), + AB::Expr::from_u32(RV32_MEMORY_AS), ], ExecutionState::new(instruction.pc, instruction.start_timestamp), timestamp_change, @@ -142,7 +142,7 @@ impl XorinVmAir { ) { self.memory_bridge .read( - MemoryAddress::new(AB::Expr::from_canonical_u32(RV32_REGISTER_AS), ptr), + MemoryAddress::new(AB::Expr::from_u32(RV32_REGISTER_AS), ptr), value, timestamp.clone(), aux, @@ -161,7 +161,7 @@ impl XorinVmAir { *instruction.len_limbs.last().unwrap(), ]; - let limb_shift = AB::F::from_canonical_usize( + let limb_shift = AB::F::from_usize( 1 << (RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - self.ptr_max_bits), ); for pair in need_range_check.chunks_exact(2) { @@ -173,25 +173,25 @@ impl XorinVmAir { builder.assert_eq( instruction.buffer_ptr, instruction.buffer_ptr_limbs[0] - + instruction.buffer_ptr_limbs[1] * AB::F::from_canonical_u32(1 << 8) - + instruction.buffer_ptr_limbs[2] * AB::F::from_canonical_u32(1 << 16) - + instruction.buffer_ptr_limbs[3] * AB::F::from_canonical_u32(1 << 24), + + instruction.buffer_ptr_limbs[1] * AB::F::from_u32(1 << 8) + + instruction.buffer_ptr_limbs[2] * AB::F::from_u32(1 << 16) + + instruction.buffer_ptr_limbs[3] * AB::F::from_u32(1 << 24), ); builder.assert_eq( instruction.input_ptr, instruction.input_ptr_limbs[0] - + instruction.input_ptr_limbs[1] * AB::F::from_canonical_u32(1 << 8) - + instruction.input_ptr_limbs[2] * AB::F::from_canonical_u32(1 << 16) - + instruction.input_ptr_limbs[3] * AB::F::from_canonical_u32(1 << 24), + + instruction.input_ptr_limbs[1] * AB::F::from_u32(1 << 8) + + instruction.input_ptr_limbs[2] * AB::F::from_u32(1 << 16) + + instruction.input_ptr_limbs[3] * AB::F::from_u32(1 << 24), ); builder.assert_eq( instruction.len, instruction.len_limbs[0] - + instruction.len_limbs[1] * AB::F::from_canonical_u32(1 << 8) - + instruction.len_limbs[2] * AB::F::from_canonical_u32(1 << 16) - + instruction.len_limbs[3] * AB::F::from_canonical_u32(1 << 24), + + instruction.len_limbs[1] * AB::F::from_u32(1 << 8) + + instruction.len_limbs[2] * AB::F::from_u32(1 << 16) + + instruction.len_limbs[3] * AB::F::from_u32(1 << 24), ); timestamp @@ -219,12 +219,12 @@ impl XorinVmAir { ) .enumerate() { - let ptr = local.instruction.buffer_ptr + AB::F::from_canonical_usize(i * 4); + let ptr = local.instruction.buffer_ptr + AB::F::from_usize(i * 4); let should_read = is_enabled * not(is_padding); self.memory_bridge .read( - MemoryAddress::new(AB::Expr::from_canonical_u32(RV32_MEMORY_AS), ptr), + MemoryAddress::new(AB::Expr::from_u32(RV32_MEMORY_AS), ptr), [ input[0].into(), input[1].into(), @@ -248,12 +248,12 @@ impl XorinVmAir { ) .enumerate() { - let ptr = local.instruction.input_ptr + AB::F::from_canonical_usize(i * 4); + let ptr = local.instruction.input_ptr + AB::F::from_usize(i * 4); let should_read = is_enabled * not(is_padding); self.memory_bridge .read( - MemoryAddress::new(AB::Expr::from_canonical_u32(RV32_MEMORY_AS), ptr), + MemoryAddress::new(AB::Expr::from_u32(RV32_MEMORY_AS), ptr), [ input[0].into(), input[1].into(), @@ -318,11 +318,11 @@ impl XorinVmAir { .enumerate() { let should_write = is_enabled * not(is_padding); - let ptr = local.instruction.buffer_ptr + AB::F::from_canonical_usize(i * 4); + let ptr = local.instruction.buffer_ptr + AB::F::from_usize(i * 4); self.memory_bridge .write( - MemoryAddress::new(AB::Expr::from_canonical_u32(RV32_MEMORY_AS), ptr), + MemoryAddress::new(AB::Expr::from_u32(RV32_MEMORY_AS), ptr), [ output[0].into(), output[1].into(), diff --git a/extensions/new-keccak256/circuit/src/xorin/columns.rs b/extensions/keccak256/circuit/src/xorin/columns.rs similarity index 96% rename from extensions/new-keccak256/circuit/src/xorin/columns.rs rename to extensions/keccak256/circuit/src/xorin/columns.rs index 3de3fc6f9d..9e40abd22e 100644 --- a/extensions/new-keccak256/circuit/src/xorin/columns.rs +++ b/extensions/keccak256/circuit/src/xorin/columns.rs @@ -2,7 +2,7 @@ use openvm_circuit::system::memory::offline_checker::{MemoryReadAuxCols, MemoryW use openvm_circuit_primitives_derive::AlignedBorrow; use openvm_instructions::riscv::RV32_REGISTER_NUM_LIMBS; -use crate::xorin::utils::{KECCAK_RATE_BYTES, KECCAK_WORD_SIZE}; +use crate::{KECCAK_RATE_BYTES, KECCAK_WORD_SIZE}; #[repr(C)] #[derive(Debug, AlignedBorrow)] diff --git a/extensions/new-keccak256/circuit/src/xorin/execution.rs b/extensions/keccak256/circuit/src/xorin/execution.rs similarity index 99% rename from extensions/new-keccak256/circuit/src/xorin/execution.rs rename to extensions/keccak256/circuit/src/xorin/execution.rs index 0616969621..e07dd8f515 100644 --- a/extensions/new-keccak256/circuit/src/xorin/execution.rs +++ b/extensions/keccak256/circuit/src/xorin/execution.rs @@ -16,7 +16,8 @@ use openvm_instructions::{ }; use openvm_stark_backend::p3_field::PrimeField32; -use super::{XorinVmExecutor, KECCAK_WORD_SIZE}; +use super::XorinVmExecutor; +use crate::KECCAK_WORD_SIZE; #[derive(AlignedBytesBorrow, Clone)] #[repr(C)] diff --git a/extensions/new-keccak256/circuit/src/xorin/mod.rs b/extensions/keccak256/circuit/src/xorin/mod.rs similarity index 91% rename from extensions/new-keccak256/circuit/src/xorin/mod.rs rename to extensions/keccak256/circuit/src/xorin/mod.rs index ac26faecdb..5a452d0a62 100644 --- a/extensions/new-keccak256/circuit/src/xorin/mod.rs +++ b/extensions/keccak256/circuit/src/xorin/mod.rs @@ -4,13 +4,10 @@ pub mod execution; #[cfg(test)] pub mod tests; pub mod trace; -pub mod utils; use openvm_circuit::arch::VmChipWrapper; use openvm_circuit_primitives::bitwise_op_lookup::SharedBitwiseOperationLookupChip; -const KECCAK_WORD_SIZE: usize = 4; - #[derive(derive_new::new, Clone, Copy)] pub struct XorinVmExecutor { pub offset: usize, diff --git a/extensions/new-keccak256/circuit/src/xorin/tests.rs b/extensions/keccak256/circuit/src/xorin/tests.rs similarity index 91% rename from extensions/new-keccak256/circuit/src/xorin/tests.rs rename to extensions/keccak256/circuit/src/xorin/tests.rs index 6f11450434..6d602d2ce6 100644 --- a/extensions/new-keccak256/circuit/src/xorin/tests.rs +++ b/extensions/keccak256/circuit/src/xorin/tests.rs @@ -13,8 +13,8 @@ use openvm_circuit_primitives::bitwise_op_lookup::{ SharedBitwiseOperationLookupChip, }; use openvm_instructions::{instruction::Instruction, riscv::RV32_CELL_BITS, LocalOpcode}; -use openvm_new_keccak256_transpiler::XorinOpcode; -use openvm_stark_backend::p3_field::FieldAlgebra; +use openvm_keccak256_transpiler::XorinOpcode; +use openvm_stark_backend::p3_field::PrimeCharacteristicRing; use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng}; use rand::{rngs::StdRng, Rng}; @@ -107,8 +107,8 @@ fn set_and_execute>( let buffer_ptr = gen_pointer(rng, buffer_length); let input_ptr = gen_pointer(rng, buffer_length); - let rand_buffer_arr_f = rand_buffer_arr.map(F::from_canonical_u8); - let rand_input_arr_f = rand_input_arr.map(F::from_canonical_u8); + let rand_buffer_arr_f = rand_buffer_arr.map(F::from_u8); + let rand_input_arr_f = rand_input_arr.map(F::from_u8); for i in 0..(buffer_length / 4) { let buffer_chunk: [F; 4] = rand_buffer_arr_f[4 * i..4 * i + 4] @@ -122,12 +122,12 @@ fn set_and_execute>( tester.write(2, input_ptr + 4 * i, input_chunk); } - tester.write(1, rd, buffer_ptr.to_le_bytes().map(F::from_canonical_u8)); - tester.write(1, rs1, input_ptr.to_le_bytes().map(F::from_canonical_u8)); + tester.write(1, rd, buffer_ptr.to_le_bytes().map(F::from_u8)); + tester.write(1, rs1, input_ptr.to_le_bytes().map(F::from_u8)); tester.write( 1, rs2, - buffer_length.to_le_bytes().map(F::from_canonical_u8), + buffer_length.to_le_bytes().map(F::from_u8), ); tester.execute( executor, @@ -140,7 +140,7 @@ fn set_and_execute>( expected_output[i] = rand_buffer_arr[i] ^ rand_input_arr[i]; } - let mut output_buffer = [F::from_canonical_u8(0); MAX_LEN]; + let mut output_buffer = [F::from_u8(0); MAX_LEN]; for i in 0..(buffer_length / 4) { let output_chunk: [F; 4] = tester.read(2, buffer_ptr + 4 * i); @@ -148,7 +148,7 @@ fn set_and_execute>( } for i in 0..buffer_length { - assert_eq!(F::from_canonical_u8(expected_output[i]), output_buffer[i]); + assert_eq!(F::from_u8(expected_output[i]), output_buffer[i]); } } @@ -161,7 +161,7 @@ fn xorin_chip_positive_tests() { let mut tester = VmChipTestBuilder::default(); let (mut harness, bitwise) = create_test_harness(&mut tester); - let buffer_length = Some(rng.gen_range(1..=34) * 4); + let buffer_length = Some(rng.random_range(1..=34) * 4); set_and_execute( &mut tester, @@ -194,7 +194,7 @@ fn run_xorin_chip_negative_tests( let mut tester = VmChipTestBuilder::default(); let (mut harness, bitwise) = create_test_harness(&mut tester); - let buffer_length = Some(rng.gen_range(1..=34) * 4_usize); + let buffer_length = Some(rng.random_range(1..=34) * 4_usize); set_and_execute( &mut tester, @@ -300,7 +300,7 @@ fn cuda_set_and_execute( ) { use openvm_circuit::arch::testing::memory::gen_pointer; - let len = len.unwrap_or_else(|| rng.gen_range(4..=136)); + let len = len.unwrap_or_else(|| rng.random_range(4..=136)); let len = (len / 4) * 4; if len == 0 { return; @@ -316,24 +316,24 @@ fn cuda_set_and_execute( tester.write( 1, buffer_reg, - buffer_ptr.to_le_bytes().map(F::from_canonical_u8), + buffer_ptr.to_le_bytes().map(F::from_u8), ); tester.write( 1, input_reg, - input_ptr.to_le_bytes().map(F::from_canonical_u8), + input_ptr.to_le_bytes().map(F::from_u8), ); tester.write( 1, len_reg, - (len as u32).to_le_bytes().map(F::from_canonical_u8), + (len as u32).to_le_bytes().map(F::from_u8), ); let buffer_data: Vec = (0..len).map(|_| rng.gen()).collect(); for (i, chunk) in buffer_data.chunks(4).enumerate() { let mut word = [F::ZERO; 4]; for (j, &byte) in chunk.iter().enumerate() { - word[j] = F::from_canonical_u8(byte); + word[j] = F::from_u8(byte); } tester.write(2, buffer_ptr + i * 4, word); } @@ -342,7 +342,7 @@ fn cuda_set_and_execute( for (i, chunk) in input_data.chunks(4).enumerate() { let mut word = [F::ZERO; 4]; for (j, &byte) in chunk.iter().enumerate() { - word[j] = F::from_canonical_u8(byte); + word[j] = F::from_u8(byte); } tester.write(2, input_ptr + i * 4, word); } diff --git a/extensions/new-keccak256/circuit/src/xorin/trace.rs b/extensions/keccak256/circuit/src/xorin/trace.rs similarity index 85% rename from extensions/new-keccak256/circuit/src/xorin/trace.rs rename to extensions/keccak256/circuit/src/xorin/trace.rs index 80bc6beea4..07b920d039 100644 --- a/extensions/new-keccak256/circuit/src/xorin/trace.rs +++ b/extensions/keccak256/circuit/src/xorin/trace.rs @@ -13,19 +13,17 @@ use openvm_circuit::{ }; use openvm_circuit_primitives::AlignedBytesBorrow; use openvm_instructions::{instruction::Instruction, riscv::RV32_REGISTER_NUM_LIMBS}; -use openvm_new_keccak256_transpiler::XorinOpcode; +use openvm_keccak256_transpiler::XorinOpcode; use openvm_rv32im_circuit::adapters::{read_rv32_register, tracing_read, tracing_write}; use openvm_stark_backend::p3_field::PrimeField32; -use crate::xorin::{ - columns::XorinVmCols, - trace::instructions::{ - program::DEFAULT_PC_STEP, - riscv::{RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS}, - }, - XorinVmExecutor, XorinVmFiller, +use openvm_instructions::{ + program::DEFAULT_PC_STEP, + riscv::{RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS}, }; +use crate::xorin::{columns::XorinVmCols, XorinVmExecutor, XorinVmFiller}; + #[derive(Clone, Copy)] pub struct XorinVmMetadata {} @@ -221,39 +219,39 @@ impl TraceFiller for XorinVmFiller { row_slice.fill(F::ZERO); let trace_row: &mut XorinVmCols = row_slice.borrow_mut(); - trace_row.instruction.pc = F::from_canonical_u32(record.from_pc); + trace_row.instruction.pc = F::from_u32(record.from_pc); trace_row.instruction.is_enabled = F::ONE; - trace_row.instruction.buffer_reg_ptr = F::from_canonical_u32(record.rd_ptr); - trace_row.instruction.input_reg_ptr = F::from_canonical_u32(record.rs1_ptr); - trace_row.instruction.len_reg_ptr = F::from_canonical_u32(record.rs2_ptr); - trace_row.instruction.buffer_ptr = F::from_canonical_u32(record.buffer); + trace_row.instruction.buffer_reg_ptr = F::from_u32(record.rd_ptr); + trace_row.instruction.input_reg_ptr = F::from_u32(record.rs1_ptr); + trace_row.instruction.len_reg_ptr = F::from_u32(record.rs2_ptr); + trace_row.instruction.buffer_ptr = F::from_u32(record.buffer); let buffer_ptr_u8: [u8; 4] = record.buffer.to_le_bytes(); let buffer_ptr_limbs: [F; 4] = [ - F::from_canonical_u8(buffer_ptr_u8[0]), - F::from_canonical_u8(buffer_ptr_u8[1]), - F::from_canonical_u8(buffer_ptr_u8[2]), - F::from_canonical_u8(buffer_ptr_u8[3]), + F::from_u8(buffer_ptr_u8[0]), + F::from_u8(buffer_ptr_u8[1]), + F::from_u8(buffer_ptr_u8[2]), + F::from_u8(buffer_ptr_u8[3]), ]; trace_row.instruction.buffer_ptr_limbs = buffer_ptr_limbs; - trace_row.instruction.input_ptr = F::from_canonical_u32(record.input); + trace_row.instruction.input_ptr = F::from_u32(record.input); let input_ptr_u8: [u8; 4] = record.input.to_le_bytes(); let input_ptr_limbs: [F; 4] = [ - F::from_canonical_u8(input_ptr_u8[0]), - F::from_canonical_u8(input_ptr_u8[1]), - F::from_canonical_u8(input_ptr_u8[2]), - F::from_canonical_u8(input_ptr_u8[3]), + F::from_u8(input_ptr_u8[0]), + F::from_u8(input_ptr_u8[1]), + F::from_u8(input_ptr_u8[2]), + F::from_u8(input_ptr_u8[3]), ]; trace_row.instruction.input_ptr_limbs = input_ptr_limbs; - trace_row.instruction.len = F::from_canonical_u32(record.len); + trace_row.instruction.len = F::from_u32(record.len); let len_u8: [u8; 4] = record.len.to_le_bytes(); let len_limbs: [F; 4] = [ - F::from_canonical_u8(len_u8[0]), - F::from_canonical_u8(len_u8[1]), - F::from_canonical_u8(len_u8[2]), - F::from_canonical_u8(len_u8[3]), + F::from_u8(len_u8[0]), + F::from_u8(len_u8[1]), + F::from_u8(len_u8[2]), + F::from_u8(len_u8[3]), ]; trace_row.instruction.len_limbs = len_limbs; - trace_row.instruction.start_timestamp = F::from_canonical_u32(record.timestamp); + trace_row.instruction.start_timestamp = F::from_u32(record.timestamp); for i in 0..(record.len / 4) { trace_row.sponge.is_padding_bytes[i as usize] = F::ZERO; @@ -298,10 +296,10 @@ impl TraceFiller for XorinVmFiller { // because they are just padding bytes and unused by the chip for i in 0..record_len { trace_row.sponge.preimage_buffer_bytes[i] = - F::from_canonical_u8(record.buffer_limbs[i]); - trace_row.sponge.input_bytes[i] = F::from_canonical_u8(record.input_limbs[i]); + F::from_u8(record.buffer_limbs[i]); + trace_row.sponge.input_bytes[i] = F::from_u8(record.input_limbs[i]); trace_row.sponge.postimage_buffer_bytes[i] = - F::from_canonical_u8(record.buffer_limbs[i] ^ record.input_limbs[i]); + F::from_u8(record.buffer_limbs[i] ^ record.input_limbs[i]); let b_val = record.buffer_limbs[i] as u32; let c_val = record.input_limbs[i] as u32; self.bitwise_lookup_chip.request_xor(b_val, c_val); @@ -316,7 +314,7 @@ impl TraceFiller for XorinVmFiller { trace_row.mem_oc.buffer_bytes_write_aux_cols[t].prev_data = record .buffer_write_aux_cols[t] .prev_data - .map(F::from_canonical_u8); + .map(F::from_u8); timestamp += 1; } diff --git a/extensions/keccak256/guest/Cargo.toml b/extensions/keccak256/guest/Cargo.toml index f2e86a53fe..8a6939ca7c 100644 --- a/extensions/keccak256/guest/Cargo.toml +++ b/extensions/keccak256/guest/Cargo.toml @@ -10,5 +10,8 @@ repository.workspace = true [dependencies] openvm-platform = { workspace = true } +[target.'cfg(target_os = "zkvm")'.dependencies] +spin = { workspace = true, features = ["mutex", "spin_mutex"] } + [features] default = [] diff --git a/extensions/keccak256/guest/src/lib.rs b/extensions/keccak256/guest/src/lib.rs index acfeea785b..1930b25d41 100644 --- a/extensions/keccak256/guest/src/lib.rs +++ b/extensions/keccak256/guest/src/lib.rs @@ -4,11 +4,109 @@ extern crate alloc; #[cfg(target_os = "zkvm")] use openvm_platform::alloc::AlignedBuf; +#[cfg(target_os = "zkvm")] +use spin::Mutex; -/// This is custom-0 defined in RISC-V spec document pub const OPCODE: u8 = 0x0b; -pub const KECCAK256_FUNCT3: u8 = 0b100; -pub const KECCAK256_FUNCT7: u8 = 0; +pub const KECCAKF_FUNCT3: u8 = 0b100; +pub const KECCAKF_FUNCT7: u8 = 0; +pub const XORIN_FUNCT3: u8 = 0b100; +pub const XORIN_FUNCT7: u8 = 3; + +pub const KECCAK_WIDTH_BYTES: usize = 200; +pub const KECCAK_RATE: usize = 136; +pub const KECCAK_OUTPUT_SIZE: usize = 32; +pub const MIN_ALIGN: usize = 4; + +#[cfg(target_os = "zkvm")] +#[repr(align(4))] +struct AlignedStackBuf { + data: [u8; N], +} + +/// Calls to [keccak256_impl] require use of a buffer for the state. Allocation of such a buffer can +/// increase the size of the stack frame. Instead, we can reuse a static buffer. Spin mutex is +/// acceptable since the zkVM is single-threaded so there is no contention. +#[cfg(target_os = "zkvm")] +static KECCAK_BUFFER: Mutex> = Mutex::new(AlignedStackBuf { + data: [0u8; KECCAK_WIDTH_BYTES], +}); + +/// SAFETY: Caller must ensure: +/// - buffer and input are aligned to MIN_ALIGN +/// - len is a multiple of MIN_ALIGN +#[cfg(target_os = "zkvm")] +#[inline(always)] +unsafe fn native_xorin_unchecked(buffer: *mut u8, input: *const u8, len: usize) { + __native_xorin(buffer, input, len); +} + +#[cfg(target_os = "zkvm")] +#[no_mangle] +pub extern "C" fn native_xorin(buffer: *mut u8, input: *const u8, len: usize) { + if len == 0 { + return; + } + unsafe { + let buffer_aligned = buffer as usize % MIN_ALIGN == 0; + let input_aligned = input as usize % MIN_ALIGN == 0; + let len_aligned = len % MIN_ALIGN == 0; + let all_aligned = buffer_aligned && input_aligned && len_aligned; + + if all_aligned { + __native_xorin(buffer, input, len); + } else { + let adjusted_len = len.next_multiple_of(MIN_ALIGN); + let aligned_buffer; + let aligned_input; + + let actual_buffer = if buffer_aligned && len_aligned { + buffer + } else { + aligned_buffer = AlignedBuf::new(buffer, adjusted_len, MIN_ALIGN); + aligned_buffer.ptr + }; + + let actual_input = if input_aligned && len_aligned { + input + } else { + aligned_input = AlignedBuf::new(input, adjusted_len, MIN_ALIGN); + aligned_input.ptr + }; + + __native_xorin(actual_buffer, actual_input, adjusted_len); + + if !buffer_aligned || !len_aligned { + core::ptr::copy_nonoverlapping(actual_buffer as *const u8, buffer, len); + } + } + } +} + +/// SAFETY: Caller must ensure buffer is aligned to MIN_ALIGN +#[cfg(target_os = "zkvm")] +#[inline(always)] +unsafe fn native_keccakf_unchecked(buffer: *mut u8) { + __native_keccakf(buffer); +} + +#[cfg(target_os = "zkvm")] +#[no_mangle] +pub extern "C" fn native_keccakf(buffer: *mut u8) { + unsafe { + if buffer as usize % MIN_ALIGN == 0 { + __native_keccakf(buffer); + } else { + let aligned_buffer = AlignedBuf::new(buffer, KECCAK_WIDTH_BYTES, MIN_ALIGN); + __native_keccakf(aligned_buffer.ptr); + core::ptr::copy_nonoverlapping( + aligned_buffer.ptr as *const u8, + buffer, + KECCAK_WIDTH_BYTES, + ); + } + } +} /// Native hook for keccak256 for use with `alloy-primitives` "native-keccak" feature. /// @@ -23,52 +121,112 @@ pub const KECCAK256_FUNCT7: u8 = 0; /// [`sha3`]: https://docs.rs/sha3/latest/sha3/ /// [`tiny_keccak`]: https://docs.rs/tiny-keccak/latest/tiny_keccak/ #[cfg(target_os = "zkvm")] -#[inline(always)] #[no_mangle] pub extern "C" fn native_keccak256(bytes: *const u8, len: usize, output: *mut u8) { - // SAFETY: assuming safety assumptions of the inputs, we handle all cases where `bytes` or - // `output` are not aligned to 4 bytes. - const MIN_ALIGN: usize = 4; unsafe { - if bytes as usize % MIN_ALIGN != 0 { - let aligned_buff = AlignedBuf::new(bytes, len, MIN_ALIGN); - if output as usize % MIN_ALIGN != 0 { - let aligned_out = AlignedBuf::uninit(32, MIN_ALIGN); - __native_keccak256(aligned_buff.ptr, len, aligned_out.ptr); - core::ptr::copy_nonoverlapping(aligned_out.ptr as *const u8, output, 32); - } else { - __native_keccak256(aligned_buff.ptr, len, output); - } + let bytes_aligned = bytes as usize % MIN_ALIGN == 0; + let output_aligned = output as usize % MIN_ALIGN == 0; + + let aligned_bytes; + let aligned_output; + + let actual_bytes = if len == 0 || bytes_aligned { + bytes } else { - if output as usize % MIN_ALIGN != 0 { - let aligned_out = AlignedBuf::uninit(32, MIN_ALIGN); - __native_keccak256(bytes, len, aligned_out.ptr); - core::ptr::copy_nonoverlapping(aligned_out.ptr as *const u8, output, 32); - } else { - __native_keccak256(bytes, len, output); - } + aligned_bytes = AlignedBuf::new(bytes, len, MIN_ALIGN); + aligned_bytes.ptr }; + + let actual_output = if output_aligned { + output + } else { + aligned_output = AlignedBuf::uninit(KECCAK_OUTPUT_SIZE, MIN_ALIGN); + aligned_output.ptr + }; + + keccak256_impl(actual_bytes, len, actual_output); + + if !output_aligned { + core::ptr::copy_nonoverlapping(actual_output as *const u8, output, KECCAK_OUTPUT_SIZE); + } } } -/// keccak256 intrinsic binding -/// -/// # Safety -/// -/// The VM accepts the preimage by pointer and length, and writes the -/// 32-byte hash. -/// - `bytes` must point to an input buffer at least `len` long. -/// - `output` must point to a buffer that is at least 32-bytes long. -/// - `bytes` and `output` must be 4-byte aligned. +/// SAFETY: This function is only called from native_keccak256 which ensures: +/// - input is aligned to MIN_ALIGN +/// - output is aligned to MIN_ALIGN +/// - All internal buffers are aligned by AlignedStackBuf #[cfg(target_os = "zkvm")] #[inline(always)] -fn __native_keccak256(bytes: *const u8, len: usize, output: *mut u8) { +unsafe fn keccak256_impl(input: *const u8, len: usize, output: *mut u8) { + let mut buffer = KECCAK_BUFFER.lock(); + let buffer_ptr = buffer.data.as_mut_ptr(); + + // Zero the buffer (memset equivalent) + core::ptr::write_bytes(buffer_ptr, 0, KECCAK_WIDTH_BYTES); + + let mut offset = 0; + let mut remaining = len; + + // Absorb full blocks + while remaining >= KECCAK_RATE { + native_xorin_unchecked(buffer_ptr, input.add(offset), KECCAK_RATE); + native_keccakf_unchecked(buffer_ptr); + offset += KECCAK_RATE; + remaining -= KECCAK_RATE; + } + + // Handle remaining bytes + if remaining > 0 { + if remaining % MIN_ALIGN == 0 { + native_xorin_unchecked(buffer_ptr, input.add(offset), remaining); + } else { + let adjusted_len = remaining.next_multiple_of(MIN_ALIGN); + let mut padded_input = AlignedStackBuf:: { + data: [0u8; KECCAK_RATE], + }; + core::ptr::copy_nonoverlapping( + input.add(offset), + padded_input.data.as_mut_ptr(), + remaining, + ); + native_xorin_unchecked(buffer_ptr, padded_input.data.as_ptr(), adjusted_len); + } + } + + // Apply Keccak padding (pad10*1) + buffer.data[remaining] ^= 0x01; + buffer.data[KECCAK_RATE - 1] ^= 0x80; + + // Final permutation + native_keccakf_unchecked(buffer_ptr); + + // Extract output + core::ptr::copy_nonoverlapping(buffer.data.as_ptr(), output, KECCAK_OUTPUT_SIZE); +} + +#[cfg(target_os = "zkvm")] +#[inline(always)] +fn __native_xorin(mut buffer: *mut u8, input: *const u8, len: usize) { openvm_platform::custom_insn_r!( opcode = OPCODE, - funct3 = KECCAK256_FUNCT3, - funct7 = KECCAK256_FUNCT7, - rd = In output, - rs1 = In bytes, + funct3 = XORIN_FUNCT3, + funct7 = XORIN_FUNCT7, + rd = InOut buffer, + rs1 = In input, rs2 = In len ); } + +#[cfg(target_os = "zkvm")] +#[inline(always)] +fn __native_keccakf(mut buffer: *mut u8) { + openvm_platform::custom_insn_r!( + opcode = OPCODE, + funct3 = KECCAKF_FUNCT3, + funct7 = KECCAKF_FUNCT7, + rd = InOut buffer, + rs1 = Const "x0", + rs2 = Const "x0", + ); +} diff --git a/extensions/keccak256/transpiler/src/lib.rs b/extensions/keccak256/transpiler/src/lib.rs index b2fccdc009..6247794ad0 100644 --- a/extensions/keccak256/transpiler/src/lib.rs +++ b/extensions/keccak256/transpiler/src/lib.rs @@ -1,6 +1,8 @@ -use openvm_instructions::LocalOpcode; +use core::panic; + +use openvm_instructions::{riscv::RV32_MEMORY_AS, LocalOpcode}; use openvm_instructions_derive::LocalOpcode; -use openvm_keccak256_guest::{KECCAK256_FUNCT3, KECCAK256_FUNCT7, OPCODE}; +use openvm_keccak256_guest::{KECCAKF_FUNCT7, OPCODE, XORIN_FUNCT3, XORIN_FUNCT7}; use openvm_stark_backend::p3_field::PrimeField32; use openvm_transpiler::{util::from_r_type, TranspilerExtension, TranspilerOutput}; use rrs_lib::instruction_formats::RType; @@ -11,8 +13,17 @@ use strum::{EnumCount, EnumIter, FromRepr}; )] #[opcode_offset = 0x310] #[repr(usize)] -pub enum Rv32KeccakOpcode { - KECCAK256, +pub enum KeccakfOpcode { + KECCAKF, +} + +#[derive( + Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, EnumCount, EnumIter, FromRepr, LocalOpcode, +)] +#[opcode_offset = 0x311] +#[repr(usize)] +pub enum XorinOpcode { + XORIN, } #[derive(Default)] @@ -27,19 +38,33 @@ impl TranspilerExtension for Keccak256TranspilerExtension { let opcode = (instruction_u32 & 0x7f) as u8; let funct3 = ((instruction_u32 >> 12) & 0b111) as u8; - if (opcode, funct3) != (OPCODE, KECCAK256_FUNCT3) { + // Safety note: KECCAKF_FUNCT3 == XORIN_FUNCT3 so it suffices to check once + if (opcode, funct3) != (OPCODE, XORIN_FUNCT3) { return None; } + let dec_insn = RType::new(instruction_u32); - if dec_insn.funct7 != KECCAK256_FUNCT7 as u32 { + + if dec_insn.funct7 != XORIN_FUNCT7 as u32 && dec_insn.funct7 != KECCAKF_FUNCT7 as u32 { return None; } - let instruction = from_r_type( - Rv32KeccakOpcode::KECCAK256.global_opcode().as_usize(), - 2, - &dec_insn, - true, - ); + + let instruction = if dec_insn.funct7 == XORIN_FUNCT7 as u32 { + from_r_type( + XorinOpcode::XORIN.global_opcode().as_usize(), + RV32_MEMORY_AS as usize, + &dec_insn, + true, + ) + } else { + from_r_type( + KeccakfOpcode::KECCAKF.global_opcode().as_usize(), + RV32_MEMORY_AS as usize, + &dec_insn, + true, + ) + }; + Some(TranspilerOutput::one_to_one(instruction)) } } diff --git a/extensions/new-keccak256/circuit/Cargo.toml b/extensions/new-keccak256/circuit/Cargo.toml deleted file mode 100644 index 333fdbd9c3..0000000000 --- a/extensions/new-keccak256/circuit/Cargo.toml +++ /dev/null @@ -1,64 +0,0 @@ -[package] -name = "openvm-new-keccak256-circuit" -description = "OpenVM circuit extension for keccak256" -version.workspace = true -authors.workspace = true -edition.workspace = true -homepage.workspace = true -repository.workspace = true - -[dependencies] -openvm-stark-backend = { workspace = true } -openvm-stark-sdk = { workspace = true } -openvm-cuda-backend = { workspace = true, optional = true } -openvm-cuda-common = { workspace = true, optional = true } -openvm-circuit-primitives = { workspace = true } -openvm-circuit-primitives-derive = { workspace = true } -openvm-circuit = { workspace = true } -openvm-circuit-derive = { workspace = true } -openvm-instructions = { workspace = true } -openvm-rv32im-circuit = { workspace = true } -openvm-new-keccak256-transpiler = { workspace = true } - -p3-keccak-air = { workspace = true } - -strum.workspace = true -tiny-keccak.workspace = true -itertools.workspace = true -derive-new.workspace = true -derive_more = { workspace = true, features = ["from"] } -rand.workspace = true -serde.workspace = true - -[dev-dependencies] -openvm-stark-sdk = { workspace = true } -openvm-circuit = { workspace = true, features = ["test-utils"] } - -[build-dependencies] -openvm-cuda-builder = { workspace = true, optional = true } - -[features] -default = ["parallel", "jemalloc"] -parallel = ["openvm-circuit/parallel"] -test-utils = ["openvm-circuit/test-utils"] -tco = ["openvm-rv32im-circuit/tco"] -aot = ["openvm-circuit/aot", "openvm-rv32im-circuit/aot"] -# performance features: -mimalloc = ["openvm-circuit/mimalloc"] -jemalloc = ["openvm-circuit/jemalloc"] -jemalloc-prof = ["openvm-circuit/jemalloc-prof"] -nightly-features = ["openvm-circuit/nightly-features"] -cuda = [ - "dep:openvm-cuda-backend", - "dep:openvm-cuda-common", - "dep:openvm-cuda-builder", - "openvm-circuit-primitives/cuda", - "openvm-circuit/cuda", - "openvm-rv32im-circuit/cuda", -] -touchemall = [ - "cuda", - "openvm-circuit/touchemall", - "openvm-circuit-primitives/touchemall", - "openvm-rv32im-circuit/touchemall", -] diff --git a/extensions/new-keccak256/circuit/build.rs b/extensions/new-keccak256/circuit/build.rs deleted file mode 100644 index 3e8372a5fd..0000000000 --- a/extensions/new-keccak256/circuit/build.rs +++ /dev/null @@ -1,41 +0,0 @@ -#[cfg(feature = "cuda")] -use openvm_cuda_builder::{cuda_available, CudaBuilder}; - -fn main() { - #[cfg(feature = "cuda")] - { - if !cuda_available() { - return; // Skip CUDA compilation - } - - // Build xorin CUDA library - let xorin_builder = CudaBuilder::new() - .include_from_dep("DEP_CUDA_COMMON_INCLUDE") - .include("../../../crates/circuits/primitives/cuda/include") - .include("../../../crates/vm/cuda/include") - .include("cuda/include") - .watch("cuda") - .watch("../../../crates/circuits/primitives/cuda") - .watch("../../../crates/vm/cuda") - .library_name("tracegen_gpu_xorin") - .file("cuda/src/xorin.cu"); - - xorin_builder.emit_link_directives(); - xorin_builder.build(); - - // Build keccakf CUDA library - let keccakf_builder = CudaBuilder::new() - .include_from_dep("DEP_CUDA_COMMON_INCLUDE") - .include("../../../crates/circuits/primitives/cuda/include") - .include("../../../crates/vm/cuda/include") - .include("cuda/include") - .watch("cuda") - .watch("../../../crates/circuits/primitives/cuda") - .watch("../../../crates/vm/cuda") - .library_name("tracegen_gpu_keccakf") - .file("cuda/src/keccakf.cu"); - - keccakf_builder.emit_link_directives(); - keccakf_builder.build(); - } -} diff --git a/extensions/new-keccak256/circuit/cuda/include/keccakf/keccakf.cuh b/extensions/new-keccak256/circuit/cuda/include/keccakf/keccakf.cuh deleted file mode 100644 index 558103032f..0000000000 --- a/extensions/new-keccak256/circuit/cuda/include/keccakf/keccakf.cuh +++ /dev/null @@ -1,75 +0,0 @@ -#pragma once - -#include -#include -#include "primitives/constants.h" -#include "system/memory/offline_checker.cuh" - -namespace keccakf { - -inline constexpr size_t NUM_ROUNDS = 24; -inline constexpr size_t KECCAK_STATE_BYTES = 200; -inline constexpr size_t KECCAK_STATE_U64 = 25; -inline constexpr size_t KECCAK_STATE_U16 = 100; -inline constexpr size_t NUM_BUFFER_WORDS = KECCAK_STATE_BYTES / riscv::RV32_REGISTER_NUM_LIMBS; -inline constexpr size_t U64_LIMBS = 4; - -// KeccakPermCols from p3_keccak_air - must match exactly -template -struct KeccakPermCols { - T step_flags[NUM_ROUNDS]; - T _export; - T preimage[5][5][U64_LIMBS]; - T a[5][5][U64_LIMBS]; - T c[5][64]; - T c_prime[5][64]; - T a_prime[5][5][64]; - T a_prime_prime[5][5][U64_LIMBS]; - T a_prime_prime_0_0_bits[64]; - T a_prime_prime_prime_0_0_limbs[U64_LIMBS]; -}; - -template -struct KeccakfInstructionCols { - T pc; - T is_enabled; - T rd_ptr; - T buffer_ptr; - T buffer_ptr_limbs[riscv::RV32_REGISTER_NUM_LIMBS]; -}; - -template -struct KeccakfMemoryCols { - MemoryReadAuxCols register_aux_cols[1]; - MemoryReadAuxCols buffer_bytes_read_aux_cols[NUM_BUFFER_WORDS]; - MemoryWriteAuxCols buffer_bytes_write_aux_cols[NUM_BUFFER_WORDS]; -}; - -template -struct KeccakfVmCols { - KeccakPermCols inner; - T preimage_state_hi[KECCAK_STATE_U16]; - T postimage_state_hi[KECCAK_STATE_U16]; - KeccakfInstructionCols instruction; - KeccakfMemoryCols mem_oc; - T timestamp; - T is_enabled_is_first_round; - T is_enabled_is_final_round; -}; - -// Record structure matching Rust's KeccakfVmRecordHeader -struct KeccakfVmRecord { - uint32_t pc; - uint32_t timestamp; - uint32_t buffer; - uint8_t preimage_buffer_bytes[KECCAK_STATE_BYTES]; - uint32_t rd_ptr; - MemoryReadAuxRecord register_aux_cols[1]; - MemoryReadAuxRecord buffer_read_aux_cols[NUM_BUFFER_WORDS]; - MemoryWriteBytesAuxRecord buffer_write_aux_cols[NUM_BUFFER_WORDS]; -}; - -inline constexpr size_t NUM_KECCAKF_VM_COLS = sizeof(KeccakfVmCols); -inline constexpr size_t NUM_KECCAK_PERM_COLS = sizeof(KeccakPermCols); - -} // namespace keccakf diff --git a/extensions/new-keccak256/circuit/cuda/src/keccakf.cu b/extensions/new-keccak256/circuit/cuda/src/keccakf.cu deleted file mode 100644 index 3da45839e0..0000000000 --- a/extensions/new-keccak256/circuit/cuda/src/keccakf.cu +++ /dev/null @@ -1,291 +0,0 @@ -#include "keccakf/keccakf.cuh" -#include "keccakf/p3_generation.cuh" -#include "launcher.cuh" -#include "primitives/buffer_view.cuh" -#include "primitives/constants.h" -#include "primitives/histogram.cuh" -#include "primitives/trace_access.h" -#include "primitives/utils.cuh" -#include "system/memory/controller.cuh" - -using namespace keccakf; -using namespace riscv; -using namespace new_keccak; - -#define KECCAKF_WRITE(FIELD, VALUE) COL_WRITE_VALUE(row, KeccakfVmCols, FIELD, VALUE) -#define KECCAKF_WRITE_ARRAY(FIELD, VALUES) COL_WRITE_ARRAY(row, KeccakfVmCols, FIELD, VALUES) -#define KECCAKF_FILL_ZERO(FIELD) COL_FILL_ZERO(row, KeccakfVmCols, FIELD) -#define KECCAKF_SLICE(FIELD) row.slice_from(COL_INDEX(KeccakfVmCols, FIELD)) - -// Single kernel that processes one block (24 rows) per thread -__global__ void keccakf_tracegen( - Fp *d_trace, - size_t height, - uint32_t num_records, - uint32_t blocks_to_fill, - DeviceBufferConstView d_records, - uint32_t *d_range_checker_ptr, - uint32_t range_checker_num_bins, - uint32_t *d_bitwise_lookup_ptr, - size_t bitwise_num_bits, - uint32_t pointer_max_bits, - uint32_t timestamp_max_bits -) { - auto block_idx = blockIdx.x * blockDim.x + threadIdx.x; - if (block_idx >= blocks_to_fill) { - return; - } - - __align__(16) uint64_t current_state[5][5] = {0}; - __align__(16) uint64_t initial_state[5][5] = {0}; - uint64_t postimage_u64[25] = {0}; - - if (block_idx < num_records) { - auto const &rec = d_records[block_idx]; - - // Convert preimage bytes to u64 state and transpose for p3 compatibility -#pragma unroll 5 - for (auto x = 0; x < 5; x++) { -#pragma unroll 5 - for (auto y = 0; y < 5; y++) { - uint64_t val = 0; -#pragma unroll 8 - for (auto j = 0; j < 8; j++) { - val |= static_cast(rec.preimage_buffer_bytes[(y + 5 * x) * 8 + j]) << (j * 8); - } - current_state[x][y] = val; // Store transposed (x-major for p3) - initial_state[x][y] = val; - } - } - - // Compute postimage - load preimage into postimage_u64 -#pragma unroll 5 - for (auto i = 0; i < 25; i++) { - uint64_t val = 0; -#pragma unroll 8 - for (auto j = 0; j < 8; j++) { - val |= static_cast(rec.preimage_buffer_bytes[i * 8 + j]) << (j * 8); - } - postimage_u64[i] = val; - } - - // Keccakf permutation -#pragma unroll 1 - for (auto round = 0; round < NUM_ROUNDS; round++) { - // Theta - uint64_t c[5]; -#pragma unroll 5 - for (auto x = 0; x < 5; x++) { - c[x] = postimage_u64[x] ^ postimage_u64[x + 5] ^ postimage_u64[x + 10] ^ - postimage_u64[x + 15] ^ postimage_u64[x + 20]; - } -#pragma unroll 5 - for (auto x = 0; x < 5; x++) { - auto d = c[(x + 4) % 5] ^ ROTL64(c[(x + 1) % 5], 1); - postimage_u64[x] ^= d; - postimage_u64[x + 5] ^= d; - postimage_u64[x + 10] ^= d; - postimage_u64[x + 15] ^= d; - postimage_u64[x + 20] ^= d; - } - - // Rho and Pi - uint64_t temp[25]; -#pragma unroll 5 - for (auto y = 0; y < 5; y++) { -#pragma unroll 5 - for (auto x = 0; x < 5; x++) { - temp[y + 5 * ((2 * x + 3 * y) % 5)] = ROTL64(postimage_u64[x + 5 * y], R[x][y]); - } - } - - // Chi -#pragma unroll 5 - for (auto y = 0; y < 5; y++) { -#pragma unroll 5 - for (auto x = 0; x < 5; x++) { - postimage_u64[x + 5 * y] = temp[x + 5 * y] ^ ((~temp[(x + 1) % 5 + 5 * y]) & temp[(x + 2) % 5 + 5 * y]); - } - } - - // Iota - postimage_u64[0] ^= RC[round]; - } - } - - auto last_rounds = height - (blocks_to_fill - 1) * NUM_ROUNDS; - uint16_t *initial_state_limbs = reinterpret_cast(initial_state); - RowSlice prev_round_row(d_trace + block_idx * NUM_ROUNDS, height); - - // Process all 24 rounds for this block - for (uint32_t round_idx = 0; round_idx < NUM_ROUNDS; round_idx++) { - if ((block_idx == (blocks_to_fill - 1)) && (round_idx >= last_rounds)) { - break; - } - - RowSlice row(d_trace + block_idx * NUM_ROUNDS + round_idx, height); - - // Fill p3 permutation columns - if (round_idx == 0) { - COL_WRITE_ARRAY(row, KeccakfVmCols, inner.a, initial_state_limbs); - COL_WRITE_ARRAY(row, KeccakfVmCols, inner.preimage, initial_state_limbs); - } else { - COL_WRITE_ARRAY(row, KeccakfVmCols, inner.preimage, initial_state_limbs); - // Copy previous row's output to this row's input (a) - for (auto y = 0; y < 5; y++) { -#pragma unroll 5 - for (auto x = 0; x < 5; x++) { -#pragma unroll 4 - for (auto limb = 0; limb < U64_LIMBS; limb++) { - COL_WRITE_VALUE(row, KeccakfVmCols, inner.a[y][x][limb], - ((x == 0) && (y == 0)) - ? prev_round_row[COL_INDEX(KeccakfVmCols, inner.a_prime_prime_prime_0_0_limbs[limb])] - : prev_round_row[COL_INDEX(KeccakfVmCols, inner.a_prime_prime[y][x][limb])]); - } - } - } - } - generate_trace_row_for_round(row, round_idx, current_state); - - if (block_idx < num_records) { - auto const &rec = d_records[block_idx]; - - MemoryAuxColsFactory mem_helper( - VariableRangeChecker(d_range_checker_ptr, range_checker_num_bins), - timestamp_max_bits - ); - BitwiseOperationLookup bitwise_lookup(d_bitwise_lookup_ptr, bitwise_num_bits); - - // Fill the state hi columns - extract hi byte directly from u64 - // preimage_state_hi[i] = high byte of i-th u16 = byte at position 2*i+1 -#pragma unroll 8 - for (auto i = 0; i < KECCAK_STATE_U16; i++) { - KECCAKF_WRITE(preimage_state_hi[i], - static_cast(rec.preimage_buffer_bytes[2 * i + 1])); - } - // postimage_state_hi[i] = high byte of i-th u16 from postimage_u64 - // i-th u16 is in postimage_u64[i/4], at limb position (i%4), hi byte offset is 8 -#pragma unroll 8 - for (auto i = 0; i < KECCAK_STATE_U16; i++) { - KECCAKF_WRITE(postimage_state_hi[i], - static_cast((postimage_u64[i / 4] >> ((i % 4) * 16 + 8)) & 0xFF)); - } - - // Fill the instruction columns - KECCAKF_WRITE(instruction.pc, rec.pc); - KECCAKF_WRITE(instruction.is_enabled, 1); - KECCAKF_WRITE(instruction.rd_ptr, rec.rd_ptr); - KECCAKF_WRITE(instruction.buffer_ptr, rec.buffer); - KECCAKF_WRITE_ARRAY(instruction.buffer_ptr_limbs, reinterpret_cast(&rec.buffer)); - - // Fill timestamp - KECCAKF_WRITE(timestamp, round_idx > 0 ? rec.timestamp + 1 + NUM_BUFFER_WORDS : rec.timestamp); - - KECCAKF_WRITE(is_enabled_is_first_round, round_idx == 0); - KECCAKF_WRITE(is_enabled_is_final_round, round_idx == NUM_ROUNDS - 1); - KECCAKF_WRITE(inner._export, Fp::zero()); - - // Fill the register reads - if (round_idx == 0) { - auto ts = rec.timestamp; - mem_helper.fill( - KECCAKF_SLICE(mem_oc.register_aux_cols[0].base), - rec.register_aux_cols[0].prev_timestamp, - ts - ); - ts++; - - // Buffer reads (50 words of 4 bytes each) - for (auto t = 0u; t < NUM_BUFFER_WORDS; t++) { - mem_helper.fill( - KECCAKF_SLICE(mem_oc.buffer_bytes_read_aux_cols[t].base), - rec.buffer_read_aux_cols[t].prev_timestamp, - ts - ); - ts++; - } - - // Range check for buffer pointer - constexpr uint32_t MSL_RSHIFT = RV32_CELL_BITS * (RV32_REGISTER_NUM_LIMBS - 1); - constexpr uint32_t RV32_TOTAL_BITS = RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS; - bitwise_lookup.add_range( - (rec.buffer >> MSL_RSHIFT) << (RV32_TOTAL_BITS - pointer_max_bits), - (rec.buffer >> MSL_RSHIFT) << (RV32_TOTAL_BITS - pointer_max_bits) - ); - } else { - mem_helper.fill_zero(KECCAKF_SLICE(mem_oc.register_aux_cols[0].base)); - for (auto t = 0u; t < NUM_BUFFER_WORDS; t++) { - mem_helper.fill_zero(KECCAKF_SLICE(mem_oc.buffer_bytes_read_aux_cols[t].base)); - } - } - - // Fill the buffer writes - if (round_idx == NUM_ROUNDS - 1) { - auto write_ts = rec.timestamp + 1 + NUM_BUFFER_WORDS; - for (auto t = 0u; t < NUM_BUFFER_WORDS; t++) { - mem_helper.fill( - KECCAKF_SLICE(mem_oc.buffer_bytes_write_aux_cols[t].base), - rec.buffer_write_aux_cols[t].prev_timestamp, - write_ts - ); - KECCAKF_WRITE_ARRAY(mem_oc.buffer_bytes_write_aux_cols[t].prev_data, - rec.buffer_write_aux_cols[t].prev_data); - write_ts++; - } - } else { - for (auto t = 0u; t < NUM_BUFFER_WORDS; t++) { - KECCAKF_FILL_ZERO(mem_oc.buffer_bytes_write_aux_cols[t]); - } - } - } else { - // inner rows are filled above. Ensure export flag is 0 - KECCAKF_WRITE(inner._export, Fp::zero()); - row.fill_zero( - COL_INDEX(KeccakfVmCols, preimage_state_hi), - sizeof(KeccakfVmCols) - COL_INDEX(KeccakfVmCols, preimage_state_hi) - ); - } - - prev_round_row = row; - } -} - -#undef KECCAKF_WRITE -#undef KECCAKF_WRITE_ARRAY -#undef KECCAKF_FILL_ZERO -#undef KECCAKF_SLICE - -extern "C" int _keccakf_tracegen( - Fp *d_trace, - size_t height, - size_t width, - DeviceBufferConstView d_records, - uint32_t *d_range_checker_ptr, - uint32_t range_checker_num_bins, - uint32_t *d_bitwise_lookup_ptr, - size_t bitwise_num_bits, - uint32_t pointer_max_bits, - uint32_t timestamp_max_bits -) { - assert((height & (height - 1)) == 0); - assert(width == sizeof(KeccakfVmCols)); - - uint32_t num_records = d_records.len(); - uint32_t blocks_to_fill = div_ceil(height, uint32_t(NUM_ROUNDS)); - - auto [grid, block] = kernel_launch_params(blocks_to_fill, 256); - keccakf_tracegen<<>>( - d_trace, - height, - num_records, - blocks_to_fill, - d_records, - d_range_checker_ptr, - range_checker_num_bins, - d_bitwise_lookup_ptr, - bitwise_num_bits, - pointer_max_bits, - timestamp_max_bits - ); - return CHECK_KERNEL(); -} diff --git a/extensions/new-keccak256/circuit/src/cuda/cuda_abi.rs b/extensions/new-keccak256/circuit/src/cuda/cuda_abi.rs deleted file mode 100644 index 6592c96b10..0000000000 --- a/extensions/new-keccak256/circuit/src/cuda/cuda_abi.rs +++ /dev/null @@ -1,97 +0,0 @@ -use openvm_cuda_backend::prelude::F; -use openvm_cuda_common::{ - d_buffer::{DeviceBuffer, DeviceBufferView}, - error::CudaError, -}; - -pub mod xorin { - use super::*; - - extern "C" { - fn _xorin_tracegen( - d_trace: *mut F, - height: usize, - width: usize, - d_records: DeviceBufferView, - d_range_checker: *mut u32, - range_checker_num_bins: u32, - d_bitwise_lookup: *const u32, - bitwise_num_bits: usize, - pointer_max_bits: u32, - timestamp_max_bits: u32, - ) -> i32; - } - - /// # Safety - /// All device buffers must be valid and properly allocated. - #[allow(clippy::too_many_arguments)] - pub unsafe fn tracegen( - d_trace: &DeviceBuffer, - height: usize, - d_records: &DeviceBuffer, - d_range_checker: &DeviceBuffer, - d_bitwise_lookup: &DeviceBuffer, - bitwise_num_bits: usize, - pointer_max_bits: u32, - timestamp_max_bits: u32, - ) -> Result<(), CudaError> { - assert!(height.is_power_of_two() || height == 0); - CudaError::from_result(_xorin_tracegen( - d_trace.as_mut_ptr(), - height, - d_trace.len() / height, - d_records.view(), - d_range_checker.as_mut_ptr() as *mut u32, - d_range_checker.len() as u32, - d_bitwise_lookup.as_mut_ptr() as *mut u32, - bitwise_num_bits, - pointer_max_bits, - timestamp_max_bits, - )) - } -} - -pub mod keccakf { - use super::*; - - extern "C" { - fn _keccakf_tracegen( - d_trace: *mut F, - height: usize, - width: usize, - d_records: DeviceBufferView, - d_range_checker: *mut u32, - range_checker_num_bins: u32, - d_bitwise_lookup: *const u32, - bitwise_num_bits: usize, - pointer_max_bits: u32, - timestamp_max_bits: u32, - ) -> i32; - } - - #[allow(clippy::too_many_arguments)] - pub unsafe fn tracegen( - d_trace: &DeviceBuffer, - height: usize, - d_records: &DeviceBuffer, - d_range_checker: &DeviceBuffer, - d_bitwise_lookup: &DeviceBuffer, - bitwise_num_bits: usize, - pointer_max_bits: u32, - timestamp_max_bits: u32, - ) -> Result<(), CudaError> { - assert!(height.is_power_of_two() || height == 0); - CudaError::from_result(_keccakf_tracegen( - d_trace.as_mut_ptr(), - height, - d_trace.len() / height, - d_records.view(), - d_range_checker.as_mut_ptr() as *mut u32, - d_range_checker.len() as u32, - d_bitwise_lookup.as_mut_ptr() as *mut u32, - bitwise_num_bits, - pointer_max_bits, - timestamp_max_bits, - )) - } -} diff --git a/extensions/new-keccak256/circuit/src/cuda/mod.rs b/extensions/new-keccak256/circuit/src/cuda/mod.rs deleted file mode 100644 index 8b4eff2ea7..0000000000 --- a/extensions/new-keccak256/circuit/src/cuda/mod.rs +++ /dev/null @@ -1,106 +0,0 @@ -use std::{mem::size_of, sync::Arc}; - -use derive_new::new; -use openvm_circuit::{arch::DenseRecordArena, utils::next_power_of_two_or_zero}; -use openvm_circuit_primitives::{ - bitwise_op_lookup::BitwiseOperationLookupChipGPU, var_range::VariableRangeCheckerChipGPU, -}; -use openvm_cuda_backend::{ - base::DeviceMatrix, chip::get_empty_air_proving_ctx, prelude::F, prover_backend::GpuBackend, -}; -use openvm_cuda_common::copy::MemCopyH2D; -use openvm_instructions::riscv::RV32_CELL_BITS; -use openvm_stark_backend::{prover::types::AirProvingContext, Chip}; - -use crate::{ - keccakf::{ - columns::{NUM_KECCAKF_VM_COLS, NUM_ROUNDS}, - trace::KeccakfVmRecordHeader, - }, - xorin::{columns::NUM_XORIN_VM_COLS, trace::XorinVmRecordHeader}, -}; - -mod cuda_abi; - -#[derive(new)] -pub struct XorinVmChipGpu { - pub range_checker: Arc, - pub bitwise_lookup: Arc>, - pub pointer_max_bits: usize, - pub timestamp_max_bits: u32, -} - -impl Chip for XorinVmChipGpu { - fn generate_proving_ctx(&self, arena: DenseRecordArena) -> AirProvingContext { - const RECORD_SIZE: usize = size_of::(); - let records = arena.allocated(); - if records.is_empty() { - return get_empty_air_proving_ctx::(); - } - debug_assert_eq!(records.len() % RECORD_SIZE, 0); - - let trace_width = NUM_XORIN_VM_COLS; - let trace_height = next_power_of_two_or_zero(records.len() / RECORD_SIZE); - - let d_records = records.to_device().unwrap(); - let d_trace = DeviceMatrix::::with_capacity(trace_height, trace_width); - - unsafe { - cuda_abi::xorin::tracegen( - d_trace.buffer(), - trace_height, - &d_records, - &self.range_checker.count, - &self.bitwise_lookup.count, - RV32_CELL_BITS, - self.pointer_max_bits as u32, - self.timestamp_max_bits, - ) - .unwrap(); - } - - AirProvingContext::simple_no_pis(d_trace) - } -} - -#[derive(new)] -pub struct KeccakfVmChipGpu { - pub range_checker: Arc, - pub bitwise_lookup: Arc>, - pub pointer_max_bits: usize, - pub timestamp_max_bits: u32, -} - -impl Chip for KeccakfVmChipGpu { - fn generate_proving_ctx(&self, arena: DenseRecordArena) -> AirProvingContext { - const RECORD_SIZE: usize = size_of::(); - let records = arena.allocated(); - if records.is_empty() { - return get_empty_air_proving_ctx::(); - } - debug_assert_eq!(records.len() % RECORD_SIZE, 0); - - let num_records = records.len() / RECORD_SIZE; - let trace_width = NUM_KECCAKF_VM_COLS; - let trace_height = next_power_of_two_or_zero(num_records * NUM_ROUNDS); - - let d_records = records.to_device().unwrap(); - let d_trace = DeviceMatrix::::with_capacity(trace_height, trace_width); - - unsafe { - cuda_abi::keccakf::tracegen( - d_trace.buffer(), - trace_height, - &d_records, - &self.range_checker.count, - &self.bitwise_lookup.count, - RV32_CELL_BITS, - self.pointer_max_bits as u32, - self.timestamp_max_bits, - ) - .unwrap(); - } - - AirProvingContext::simple_no_pis(d_trace) - } -} diff --git a/extensions/new-keccak256/circuit/src/extension/cuda.rs b/extensions/new-keccak256/circuit/src/extension/cuda.rs deleted file mode 100644 index 90339da719..0000000000 --- a/extensions/new-keccak256/circuit/src/extension/cuda.rs +++ /dev/null @@ -1,91 +0,0 @@ -use openvm_circuit::{ - arch::DenseRecordArena, - system::cuda::{ - extensions::{ - get_inventory_range_checker, get_or_create_bitwise_op_lookup, SystemGpuBuilder, - }, - SystemChipInventoryGPU, - }, -}; -use openvm_cuda_backend::{engine::GpuBabyBearPoseidon2Engine, prover_backend::GpuBackend}; -use openvm_rv32im_circuit::Rv32ImGpuProverExt; -use openvm_stark_sdk::config::baby_bear_poseidon2::BabyBearPoseidon2Config; - -use super::*; -use crate::cuda::{KeccakfVmChipGpu, XorinVmChipGpu}; - -pub struct NewKeccak256GpuProverExt; - -impl VmProverExtension - for NewKeccak256GpuProverExt -{ - fn extend_prover( - &self, - _extension: &NewKeccak256, - inventory: &mut ChipInventory, - ) -> Result<(), ChipInventoryError> { - let pointer_max_bits = inventory.airs().pointer_max_bits(); - let timestamp_max_bits = inventory.timestamp_max_bits(); - - let range_checker = get_inventory_range_checker(inventory); - let bitwise_lu = get_or_create_bitwise_op_lookup(inventory)?; - - inventory.next_air::()?; - let xorin_chip = XorinVmChipGpu::new( - range_checker.clone(), - bitwise_lu.clone(), - pointer_max_bits, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(xorin_chip); - - inventory.next_air::()?; - let keccakf_chip = KeccakfVmChipGpu::new( - range_checker, - bitwise_lu, - pointer_max_bits, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(keccakf_chip); - - Ok(()) - } -} - -#[derive(Clone)] -pub struct NewKeccak256Rv32GpuBuilder; - -type E = GpuBabyBearPoseidon2Engine; - -impl VmBuilder for NewKeccak256Rv32GpuBuilder { - type VmConfig = NewKeccak256Rv32Config; - type SystemChipInventory = SystemChipInventoryGPU; - type RecordArena = DenseRecordArena; - - fn create_chip_complex( - &self, - config: &NewKeccak256Rv32Config, - circuit: AirInventory<::SC>, - ) -> Result< - VmChipComplex< - ::SC, - Self::RecordArena, - ::PB, - Self::SystemChipInventory, - >, - ChipInventoryError, - > { - let mut chip_complex = - VmBuilder::::create_chip_complex(&SystemGpuBuilder, &config.system, circuit)?; - let inventory = &mut chip_complex.inventory; - VmProverExtension::::extend_prover(&Rv32ImGpuProverExt, &config.rv32i, inventory)?; - VmProverExtension::::extend_prover(&Rv32ImGpuProverExt, &config.rv32m, inventory)?; - VmProverExtension::::extend_prover(&Rv32ImGpuProverExt, &config.io, inventory)?; - VmProverExtension::::extend_prover( - &NewKeccak256GpuProverExt, - &config.keccak, - inventory, - )?; - Ok(chip_complex) - } -} diff --git a/extensions/new-keccak256/circuit/src/extension/mod.rs b/extensions/new-keccak256/circuit/src/extension/mod.rs deleted file mode 100644 index 82c0093a00..0000000000 --- a/extensions/new-keccak256/circuit/src/extension/mod.rs +++ /dev/null @@ -1,248 +0,0 @@ -use std::{result::Result, sync::Arc}; - -use derive_more::derive::From; -use openvm_circuit::{ - arch::{ - AirInventory, AirInventoryError, ChipInventory, ChipInventoryError, ExecutionBridge, - ExecutorInventoryBuilder, ExecutorInventoryError, InitFileGenerator, MatrixRecordArena, - RowMajorMatrixArena, SystemConfig, VmBuilder, VmChipComplex, VmCircuitExtension, - VmExecutionExtension, VmProverExtension, - }, - system::{ - memory::SharedMemoryHelper, SystemChipInventory, SystemCpuBuilder, SystemExecutor, - SystemPort, - }, -}; -use openvm_circuit_derive::{AnyEnum, Executor, MeteredExecutor, PreflightExecutor, VmConfig}; -use openvm_circuit_primitives::bitwise_op_lookup::{ - BitwiseOperationLookupAir, BitwiseOperationLookupBus, BitwiseOperationLookupChip, - SharedBitwiseOperationLookupChip, -}; -use openvm_instructions::LocalOpcode; -use openvm_new_keccak256_transpiler::{KeccakfOpcode, XorinOpcode}; -use openvm_rv32im_circuit::{ - Rv32I, Rv32IExecutor, Rv32ImCpuProverExt, Rv32Io, Rv32IoExecutor, Rv32M, Rv32MExecutor, -}; -use openvm_stark_backend::{ - config::{StarkGenericConfig, Val}, - p3_field::PrimeField32, - prover::cpu::{CpuBackend, CpuDevice}, -}; -use openvm_stark_sdk::engine::StarkEngine; -use serde::{Deserialize, Serialize}; -use strum::IntoEnumIterator; - -use crate::{ - keccakf::{air::KeccakfVmAir, KeccakfVmChip, KeccakfVmExecutor, KeccakfVmFiller}, - xorin::{air::XorinVmAir, XorinVmChip, XorinVmExecutor, XorinVmFiller}, -}; - -#[cfg(feature = "cuda")] -mod cuda; -#[cfg(feature = "cuda")] -pub use cuda::*; - -#[derive(Clone, Debug, VmConfig, derive_new::new, Serialize, Deserialize)] -pub struct NewKeccak256Rv32Config { - #[config(executor = "SystemExecutor")] - pub system: SystemConfig, - #[extension] - pub rv32i: Rv32I, - #[extension] - pub rv32m: Rv32M, - #[extension] - pub io: Rv32Io, - #[extension] - pub keccak: NewKeccak256, -} - -impl Default for NewKeccak256Rv32Config { - fn default() -> Self { - Self { - system: SystemConfig::default(), - rv32i: Rv32I, - rv32m: Rv32M::default(), - io: Rv32Io, - keccak: NewKeccak256, - } - } -} - -// Default implementation uses no init file -impl InitFileGenerator for NewKeccak256Rv32Config {} - -#[derive(Clone)] -pub struct NewKeccak256Rv32CpuBuilder; - -impl VmBuilder for NewKeccak256Rv32CpuBuilder -where - SC: StarkGenericConfig, - E: StarkEngine, PD = CpuDevice>, - Val: PrimeField32, -{ - type VmConfig = NewKeccak256Rv32Config; - type SystemChipInventory = SystemChipInventory; - type RecordArena = MatrixRecordArena>; - - fn create_chip_complex( - &self, - config: &NewKeccak256Rv32Config, - circuit: AirInventory, - ) -> Result< - VmChipComplex, - ChipInventoryError, - > { - let mut chip_complex = - VmBuilder::::create_chip_complex(&SystemCpuBuilder, &config.system, circuit)?; - let inventory = &mut chip_complex.inventory; - VmProverExtension::::extend_prover(&Rv32ImCpuProverExt, &config.rv32i, inventory)?; - VmProverExtension::::extend_prover(&Rv32ImCpuProverExt, &config.rv32m, inventory)?; - VmProverExtension::::extend_prover(&Rv32ImCpuProverExt, &config.io, inventory)?; - VmProverExtension::::extend_prover( - &NewKeccak256CpuProverExt, - &config.keccak, - inventory, - )?; - Ok(chip_complex) - } -} - -// =================================== VM Extension Implementation ================================= -#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)] -pub struct NewKeccak256; - -#[derive(Clone, Copy, From, AnyEnum, Executor, MeteredExecutor, PreflightExecutor)] -#[cfg_attr( - feature = "aot", - derive( - openvm_circuit_derive::AotExecutor, - openvm_circuit_derive::AotMeteredExecutor - ) -)] -pub enum NewKeccak256Executor { - Keccakf(KeccakfVmExecutor), - Xorin(XorinVmExecutor), -} - -impl VmExecutionExtension for NewKeccak256 { - type Executor = NewKeccak256Executor; - - fn extend_execution( - &self, - inventory: &mut ExecutorInventoryBuilder, - ) -> Result<(), ExecutorInventoryError> { - let pointer_max_bits = inventory.pointer_max_bits(); - - let xorin_executor = XorinVmExecutor::new(XorinOpcode::CLASS_OFFSET, pointer_max_bits); - inventory.add_executor( - xorin_executor, - XorinOpcode::iter().map(|x| x.global_opcode()), - )?; - - let keccak_executor = KeccakfVmExecutor::new(KeccakfOpcode::CLASS_OFFSET, pointer_max_bits); - inventory.add_executor( - keccak_executor, - KeccakfOpcode::iter().map(|x| x.global_opcode()), - )?; - - Ok(()) - } -} - -impl VmCircuitExtension for NewKeccak256 { - fn extend_circuit(&self, inventory: &mut AirInventory) -> Result<(), AirInventoryError> { - let SystemPort { - execution_bus, - program_bus, - memory_bridge, - } = inventory.system().port(); - - let exec_bridge = ExecutionBridge::new(execution_bus, program_bus); - let pointer_max_bits = inventory.pointer_max_bits(); - - let bitwise_lu = { - let existing_air = inventory.find_air::>().next(); - if let Some(air) = existing_air { - air.bus - } else { - let bus = BitwiseOperationLookupBus::new(inventory.new_bus_idx()); - let air = BitwiseOperationLookupAir::<8>::new(bus); - inventory.add_air(air); - air.bus - } - }; - - let xorin_air = XorinVmAir::new( - exec_bridge, - memory_bridge, - bitwise_lu, - pointer_max_bits, - XorinOpcode::CLASS_OFFSET, - ); - inventory.add_air(xorin_air); - - let keccak_air = KeccakfVmAir::new( - exec_bridge, - memory_bridge, - bitwise_lu, - pointer_max_bits, - KeccakfOpcode::CLASS_OFFSET, - ); - inventory.add_air(keccak_air); - - Ok(()) - } -} - -pub struct NewKeccak256CpuProverExt; -// This implementation is specific to CpuBackend because the lookup chips (VariableRangeChecker, -// BitwiseOperationLookupChip) are specific to CpuBackend. -impl VmProverExtension for NewKeccak256CpuProverExt -where - SC: StarkGenericConfig, - E: StarkEngine, PD = CpuDevice>, - RA: RowMajorMatrixArena>, - Val: PrimeField32, -{ - fn extend_prover( - &self, - _: &NewKeccak256, - inventory: &mut ChipInventory>, - ) -> Result<(), ChipInventoryError> { - let range_checker = inventory.range_checker()?.clone(); - let timestamp_max_bits = inventory.timestamp_max_bits(); - let mem_helper = SharedMemoryHelper::new(range_checker.clone(), timestamp_max_bits); - let pointer_max_bits = inventory.airs().pointer_max_bits(); - - let bitwise_lu = { - let existing_chip = inventory - .find_chip::>() - .next(); - - if let Some(chip) = existing_chip { - chip.clone() - } else { - let air: &BitwiseOperationLookupAir<8> = inventory.next_air()?; - let chip = Arc::new(BitwiseOperationLookupChip::new(air.bus)); - inventory.add_periphery_chip(chip.clone()); - chip - } - }; - - inventory.next_air::()?; - let xorin_chip = XorinVmChip::new( - XorinVmFiller::new(bitwise_lu.clone(), pointer_max_bits), - mem_helper.clone(), - ); - inventory.add_executor_chip(xorin_chip); - - inventory.next_air::()?; - let keccak_chip = KeccakfVmChip::new( - KeccakfVmFiller::new(bitwise_lu, pointer_max_bits), - mem_helper.clone(), - ); - inventory.add_executor_chip(keccak_chip); - - Ok(()) - } -} diff --git a/extensions/new-keccak256/circuit/src/keccakf/air.rs b/extensions/new-keccak256/circuit/src/keccakf/air.rs deleted file mode 100644 index 38e4822c0a..0000000000 --- a/extensions/new-keccak256/circuit/src/keccakf/air.rs +++ /dev/null @@ -1,316 +0,0 @@ -use std::borrow::Borrow; - -use openvm_circuit::{ - arch::{ExecutionBridge, ExecutionState}, - system::memory::{ - offline_checker::{MemoryBridge, MemoryReadAuxCols, MemoryWriteAuxCols}, - MemoryAddress, - }, -}; -use openvm_circuit_primitives::{bitwise_op_lookup::BitwiseOperationLookupBus, utils::not}; -use openvm_instructions::riscv::{ - RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS, -}; -use openvm_new_keccak256_transpiler::KeccakfOpcode; -use openvm_stark_backend::{ - air_builders::sub::SubAirBuilder, - interaction::InteractionBuilder, - p3_air::{Air, AirBuilder, BaseAir}, - p3_field::FieldAlgebra, - p3_matrix::Matrix, - rap::{BaseAirWithPublicValues, PartitionedBaseAir}, -}; -use p3_keccak_air::{KeccakAir, NUM_ROUNDS, U64_LIMBS}; - -use crate::keccakf::columns::{KeccakfVmCols, NUM_KECCAKF_VM_COLS, NUM_KECCAK_PERM_COLS}; - -#[derive(Clone, Copy, Debug, derive_new::new)] -pub struct KeccakfVmAir { - pub execution_bridge: ExecutionBridge, - pub memory_bridge: MemoryBridge, - pub bitwise_lookup_bus: BitwiseOperationLookupBus, - pub ptr_max_bits: usize, - pub(super) offset: usize, -} - -impl BaseAirWithPublicValues for KeccakfVmAir {} -impl PartitionedBaseAir for KeccakfVmAir {} -impl BaseAir for KeccakfVmAir { - fn width(&self) -> usize { - NUM_KECCAKF_VM_COLS - } -} - -impl Air for KeccakfVmAir { - fn eval(&self, builder: &mut AB) { - let main = builder.main(); - - let (local, next) = (main.row_slice(0), main.row_slice(1)); - let local: &KeccakfVmCols<_> = (*local).borrow(); - let next: &KeccakfVmCols<_> = (*next).borrow(); - - let mut timestamp: AB::Expr = local.timestamp.into(); - let mem_oc = &local.mem_oc; - - // only active during the first round in each instruction - self.eval_instruction(builder, local, &mut timestamp, &mem_oc.register_aux_cols); - // only active during the first round in each instruction - self.constrain_input_read( - builder, - local, - &mut timestamp, - &mem_oc.buffer_bytes_read_aux_cols, - ); - - let keccak_f_air = KeccakAir {}; - let mut sub_builder = - SubAirBuilder::::new(builder, 0..NUM_KECCAK_PERM_COLS); - keccak_f_air.eval(&mut sub_builder); - - // only active during the last round in each instruction - self.constrain_output_write( - builder, - local, - &mut timestamp, - &mem_oc.buffer_bytes_write_aux_cols, - ); - - self.constrain_rounds_transition(builder, local, next, timestamp); - } -} - -impl KeccakfVmAir { - #[inline] - pub fn eval_instruction( - &self, - builder: &mut AB, - local: &KeccakfVmCols, - start_timestamp: &mut AB::Expr, - register_aux: &[MemoryReadAuxCols; 1], - ) { - let instruction = local.instruction; - let is_enabled = instruction.is_enabled; - builder.assert_bool(is_enabled); - let is_first_round = local.inner.step_flags[0]; - let is_final_round = local.inner.step_flags[NUM_ROUNDS - 1]; - let is_enabled_is_first_round = is_enabled * is_first_round; - let is_enabled_is_final_round = is_enabled * is_final_round; - builder.assert_eq(is_enabled_is_first_round, is_first_round * is_enabled); - builder.assert_eq(is_enabled_is_final_round, is_final_round * is_enabled); - - let rd_ptr = instruction.rd_ptr; - let buffer_ptr_limbs = instruction.buffer_ptr_limbs.map(Into::into); - // 50 buffer reads and 50 buffer writes and 1 register read - let timestamp_change = - local.is_enabled_is_first_round * AB::F::from_canonical_u32(1 + 50 + 50); - - // safety: it is safe to use timestamp instead of storing a separate - // instruction.start_timestamp because the execution_bridge interaction is only - // enabled in the first row, so timestamp = start_timestamp since there is no more - // timestamp increments - self.execution_bridge - .execute_and_increment_pc( - AB::Expr::from_canonical_usize(KeccakfOpcode::KECCAKF as usize + self.offset), - [ - rd_ptr.into(), - AB::Expr::ZERO, - AB::Expr::ZERO, - AB::Expr::from_canonical_u32(RV32_REGISTER_AS), - AB::Expr::from_canonical_u32(RV32_MEMORY_AS), - ], - ExecutionState::new(instruction.pc, local.timestamp), - timestamp_change, - ) - .eval(builder, local.is_enabled_is_first_round); - - self.memory_bridge - .read( - MemoryAddress::new(AB::Expr::from_canonical_u32(RV32_REGISTER_AS), rd_ptr), - buffer_ptr_limbs, - start_timestamp.clone(), - ®ister_aux[0], - ) - .eval(builder, local.is_enabled_is_first_round); - *start_timestamp += local.is_enabled_is_first_round.into(); - - builder.assert_eq( - instruction.buffer_ptr, - instruction.buffer_ptr_limbs[0] - + instruction.buffer_ptr_limbs[1] * AB::F::from_canonical_u32(1 << 8) - + instruction.buffer_ptr_limbs[2] * AB::F::from_canonical_u32(1 << 16) - + instruction.buffer_ptr_limbs[3] * AB::F::from_canonical_u32(1 << 24), - ); - - let limb_shift = AB::F::from_canonical_usize( - 1 << (RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - self.ptr_max_bits), - ); - let need_range_check = [ - *instruction.buffer_ptr_limbs.last().unwrap(), - *instruction.buffer_ptr_limbs.last().unwrap(), - ]; - for pair in need_range_check.chunks_exact(2) { - self.bitwise_lookup_bus - .send_range(pair[0] * limb_shift, pair[1] * limb_shift) - .eval(builder, local.is_enabled_is_first_round); - } - } - - #[inline] - pub fn constrain_input_read( - &self, - builder: &mut AB, - local: &KeccakfVmCols, - start_timestamp: &mut AB::Expr, - buffer_bytes_read_aux_cols: &[MemoryReadAuxCols; 200 / 4], - ) { - const PREIMAGE_BYTES: usize = 25 * U64_LIMBS * 2; - let local_preimage_bytes: [AB::Expr; PREIMAGE_BYTES] = std::array::from_fn(|byte_idx| { - // `preimage` is represented as 5 * 5 * U64_LIMBS u16 limbs; each u16 limb is split into - // 2 bytes. - let u16_idx = byte_idx / 2; - let is_hi_byte = (byte_idx % 2) == 1; - - let i = u16_idx / U64_LIMBS; - let limb = u16_idx % U64_LIMBS; - - let y = i / 5; - let x = i % 5; - - let state_limb: AB::Expr = local.inner.preimage[y][x][limb].into(); - let hi: AB::Expr = local.preimage_state_hi[i * U64_LIMBS + limb].into(); - let lo: AB::Expr = state_limb.clone() - hi.clone() * AB::F::from_canonical_u64(1 << 8); - - builder.assert_eq( - state_limb, - lo.clone() + hi.clone() * AB::F::from_canonical_u64(1 << 8), - ); - - if is_hi_byte { - hi - } else { - lo - } - }); - - for idx in 0..(PREIMAGE_BYTES / 4) { - let read_chunk: [AB::Expr; 4] = - std::array::from_fn(|j| local_preimage_bytes[4 * idx + j].clone()); - - let ptr = local.instruction.buffer_ptr + AB::Expr::from_canonical_usize(idx * 4); - - self.memory_bridge - .read( - MemoryAddress::new(AB::Expr::from_canonical_u32(RV32_MEMORY_AS), ptr), - read_chunk, - start_timestamp.clone(), - &buffer_bytes_read_aux_cols[idx], - ) - .eval(builder, local.is_enabled_is_first_round); - - *start_timestamp += local.is_enabled_is_first_round.into(); - } - } - - #[inline] - pub fn constrain_output_write( - &self, - builder: &mut AB, - local: &KeccakfVmCols, - start_timestamp: &mut AB::Expr, - buffer_bytes_write_aux_cols: &[MemoryWriteAuxCols; 200 / 4], - ) { - const POSTIMAGE_BYTES: usize = 25 * 4 * 2; - let local_postimage_bytes: [AB::Expr; POSTIMAGE_BYTES] = std::array::from_fn(|byte_idx| { - // `preimage` is represented as 5 * 5 * U64_LIMBS u16 limbs; each u16 limb is split into - // 2 bytes. - let u16_idx = byte_idx / 2; - let is_hi_byte = (byte_idx % 2) == 1; - - let i = u16_idx / U64_LIMBS; - let limb = u16_idx % U64_LIMBS; - let y = i / 5; - let x = i % 5; - - let state_limb: AB::Expr = local.inner.a_prime_prime_prime(y, x, limb).into(); - let hi: AB::Expr = local.postimage_state_hi[i * U64_LIMBS + limb].into(); - let lo: AB::Expr = state_limb.clone() - hi.clone() * AB::F::from_canonical_u64(1 << 8); - - builder.assert_eq( - state_limb, - lo.clone() + hi.clone() * AB::F::from_canonical_u64(1 << 8), - ); - - if is_hi_byte { - hi - } else { - lo - } - }); - - for idx in 0..(200 / 4) { - let write_chunk: [AB::Expr; 4] = - std::array::from_fn(|j| local_postimage_bytes[4 * idx + j].clone()); - - let ptr = local.instruction.buffer_ptr + AB::Expr::from_canonical_usize(idx * 4); - - self.memory_bridge - .write( - MemoryAddress::new(AB::Expr::from_canonical_u32(RV32_MEMORY_AS), ptr), - write_chunk, - start_timestamp.clone(), - &buffer_bytes_write_aux_cols[idx], - ) - .eval(builder, local.is_enabled_is_final_round); - - *start_timestamp += local.is_enabled_is_final_round.into(); - } - } - - // responsible for constraining everything that needs to be constrained between rows in the same - // instruction but different keccakf rounds - #[inline] - pub fn constrain_rounds_transition( - &self, - builder: &mut AB, - local: &KeccakfVmCols, - next: &KeccakfVmCols, - timestamp: AB::Expr, - ) { - let is_final_round = local.inner.step_flags[NUM_ROUNDS - 1]; - let is_enabled = local.instruction.is_enabled; - let need_check = is_enabled * not(is_final_round); - - for idx in 0..100 { - builder - .when(need_check.clone()) - .assert_eq(local.preimage_state_hi[idx], next.preimage_state_hi[idx]); - builder - .when(need_check.clone()) - .assert_eq(local.postimage_state_hi[idx], next.postimage_state_hi[idx]); - } - builder - .when(need_check.clone()) - .assert_eq(local.instruction.pc, next.instruction.pc); - builder - .when(need_check.clone()) - .assert_eq(local.instruction.is_enabled, next.instruction.is_enabled); - builder - .when(need_check.clone()) - .assert_eq(local.instruction.rd_ptr, next.instruction.rd_ptr); - builder - .when(need_check.clone()) - .assert_eq(local.instruction.buffer_ptr, next.instruction.buffer_ptr); - for limb in 0..4 { - builder.when(need_check.clone()).assert_eq( - local.instruction.buffer_ptr_limbs[limb], - next.instruction.buffer_ptr_limbs[limb], - ); - } - // safety: mem_oc does not need to be checked here because in the rows which is not first or - // last it is not used and in the first or last rows, the mem_oc fields which is - // used is already constraiend by the interactions - builder - .when(need_check.clone()) - .assert_eq(timestamp, next.timestamp); - } -} diff --git a/extensions/new-keccak256/circuit/src/keccakf/columns.rs b/extensions/new-keccak256/circuit/src/keccakf/columns.rs deleted file mode 100644 index 8a0e21941c..0000000000 --- a/extensions/new-keccak256/circuit/src/keccakf/columns.rs +++ /dev/null @@ -1,42 +0,0 @@ -use openvm_circuit::system::memory::offline_checker::{MemoryReadAuxCols, MemoryWriteAuxCols}; -use openvm_circuit_primitives_derive::AlignedBorrow; -use openvm_instructions::riscv::RV32_REGISTER_NUM_LIMBS; -use p3_keccak_air::KeccakCols as KeccakPermCols; - -use crate::{keccakf::utils::KECCAK_WIDTH_BYTES, xorin::utils::KECCAK_WORD_SIZE}; - -#[repr(C)] -#[derive(Debug, AlignedBorrow)] -pub struct KeccakfVmCols { - pub inner: KeccakPermCols, - pub preimage_state_hi: [T; KECCAK_WIDTH_BYTES / 2], - pub postimage_state_hi: [T; KECCAK_WIDTH_BYTES / 2], - pub instruction: KeccakfInstructionCols, - pub mem_oc: KeccakfMemoryCols, - pub timestamp: T, - pub is_enabled_is_first_round: T, - pub is_enabled_is_final_round: T, -} - -#[repr(C)] -#[derive(Copy, Clone, Debug, Default, AlignedBorrow, derive_new::new)] -pub struct KeccakfInstructionCols { - pub pc: T, - pub is_enabled: T, - pub rd_ptr: T, - pub buffer_ptr: T, - pub buffer_ptr_limbs: [T; RV32_REGISTER_NUM_LIMBS], -} - -#[repr(C)] -#[derive(Clone, Debug, AlignedBorrow)] -pub struct KeccakfMemoryCols { - pub register_aux_cols: [MemoryReadAuxCols; 1], - pub buffer_bytes_read_aux_cols: [MemoryReadAuxCols; KECCAK_WIDTH_BYTES / KECCAK_WORD_SIZE], - pub buffer_bytes_write_aux_cols: - [MemoryWriteAuxCols; KECCAK_WIDTH_BYTES / KECCAK_WORD_SIZE], -} - -pub const NUM_KECCAKF_VM_COLS: usize = size_of::>(); -pub const NUM_KECCAK_PERM_COLS: usize = size_of::>(); -pub const NUM_ROUNDS: usize = 24; diff --git a/extensions/new-keccak256/circuit/src/keccakf/mod.rs b/extensions/new-keccak256/circuit/src/keccakf/mod.rs deleted file mode 100644 index a722f429ea..0000000000 --- a/extensions/new-keccak256/circuit/src/keccakf/mod.rs +++ /dev/null @@ -1,24 +0,0 @@ -pub mod air; -pub mod columns; -pub mod execution; -#[cfg(test)] -pub mod tests; -pub mod trace; -pub mod utils; - -use openvm_circuit::arch::VmChipWrapper; -use openvm_circuit_primitives::bitwise_op_lookup::SharedBitwiseOperationLookupChip; - -#[derive(derive_new::new, Clone, Copy)] -pub struct KeccakfVmExecutor { - pub offset: usize, - pub pointer_max_bits: usize, -} - -#[derive(derive_new::new)] -pub struct KeccakfVmFiller { - pub bitwise_lookup_chip: SharedBitwiseOperationLookupChip<8>, - pub pointer_max_bits: usize, -} - -pub type KeccakfVmChip = VmChipWrapper; diff --git a/extensions/new-keccak256/circuit/src/keccakf/trace.rs b/extensions/new-keccak256/circuit/src/keccakf/trace.rs deleted file mode 100644 index 17ad059e13..0000000000 --- a/extensions/new-keccak256/circuit/src/keccakf/trace.rs +++ /dev/null @@ -1,353 +0,0 @@ -use core::convert::TryInto; -use std::{ - borrow::BorrowMut, - mem::{align_of, size_of}, -}; - -use openvm_circuit::{ - arch::*, - system::memory::{ - offline_checker::{MemoryReadAuxRecord, MemoryWriteBytesAuxRecord}, - online::TracingMemory, - MemoryAuxColsFactory, - }, -}; -use openvm_circuit_primitives::AlignedBytesBorrow; -use openvm_instructions::{ - instruction::Instruction, - program::DEFAULT_PC_STEP, - riscv::{RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS}, -}; -use openvm_new_keccak256_transpiler::KeccakfOpcode; -use openvm_rv32im_circuit::adapters::{tracing_read, tracing_write}; -use openvm_stark_backend::{p3_field::PrimeField32, p3_matrix::dense::RowMajorMatrix}; -use p3_keccak_air::generate_trace_rows; - -use crate::keccakf::{ - columns::{KeccakfVmCols, NUM_KECCAKF_VM_COLS, NUM_KECCAK_PERM_COLS, NUM_ROUNDS}, - utils::{KECCAK_WIDTH_BYTES, KECCAK_WIDTH_U32_LIMBS, KECCAK_WIDTH_U64_LIMBS}, - KeccakfVmExecutor, KeccakfVmFiller, -}; - -#[derive(Clone, Copy)] -pub struct KeccakfVmMetadata {} - -impl MultiRowMetadata for KeccakfVmMetadata { - fn get_num_rows(&self) -> usize { - NUM_ROUNDS - } -} - -pub(crate) type KeccakfVmRecordLayout = MultiRowLayout; - -#[repr(C)] -#[derive(AlignedBytesBorrow, Debug, Clone)] -pub struct KeccakfVmRecordHeader { - pub pc: u32, - pub timestamp: u32, - pub buffer: u32, - pub preimage_buffer_bytes: [u8; 200], - pub rd_ptr: u32, - pub register_aux_cols: [MemoryReadAuxRecord; 1], - pub buffer_read_aux_cols: [MemoryReadAuxRecord; 200 / 4], - pub buffer_write_aux_cols: [MemoryWriteBytesAuxRecord<4>; 200 / 4], -} - -pub struct KeccakfVmRecordMut<'a> { - pub inner: &'a mut KeccakfVmRecordHeader, -} - -impl<'a> CustomBorrow<'a, KeccakfVmRecordMut<'a>, KeccakfVmRecordLayout> for [u8] { - fn custom_borrow(&'a mut self, _layout: KeccakfVmRecordLayout) -> KeccakfVmRecordMut<'a> { - let (record_buf, _rest) = - unsafe { self.split_at_mut_unchecked(size_of::()) }; - KeccakfVmRecordMut { - inner: record_buf.borrow_mut(), - } - } - - unsafe fn extract_layout(&self) -> KeccakfVmRecordLayout { - KeccakfVmRecordLayout { - metadata: KeccakfVmMetadata {}, - } - } -} - -impl SizedRecord for KeccakfVmRecordMut<'_> { - fn size(_layout: &KeccakfVmRecordLayout) -> usize { - size_of::() - } - - fn alignment(_layout: &KeccakfVmRecordLayout) -> usize { - align_of::() - } -} - -impl PreflightExecutor for KeccakfVmExecutor -where - F: PrimeField32, - for<'buf> RA: RecordArena<'buf, KeccakfVmRecordLayout, KeccakfVmRecordMut<'buf>>, -{ - fn get_opcode_name(&self, _: usize) -> String { - format!("{:?}", KeccakfOpcode::KECCAKF) - } - - fn execute( - &self, - state: VmStateMut, - instruction: &Instruction, - ) -> Result<(), ExecutionError> { - let &Instruction { a, .. } = instruction; - - let record = state - .ctx - .alloc(KeccakfVmRecordLayout::new(KeccakfVmMetadata {})); - - record.inner.pc = *state.pc; - record.inner.timestamp = state.memory.timestamp(); - record.inner.rd_ptr = a.as_canonical_u32(); - record.inner.buffer = u32::from_le_bytes(tracing_read( - state.memory, - RV32_REGISTER_AS, - a.as_canonical_u32(), - &mut record.inner.register_aux_cols[0].prev_timestamp, - )); - - for idx in 0..KECCAK_WIDTH_U32_LIMBS { - let read = tracing_read::<4>( - state.memory, - RV32_MEMORY_AS, - record.inner.buffer + (idx * 4) as u32, - &mut record.inner.buffer_read_aux_cols[idx].prev_timestamp, - ); - - record.inner.preimage_buffer_bytes[4 * idx..4 * (idx + 1)].copy_from_slice(&read); - } - - let preimage_buffer_bytes = record.inner.preimage_buffer_bytes; - let mut preimage_buffer_bytes_u64: [u64; KECCAK_WIDTH_U64_LIMBS] = - [0; KECCAK_WIDTH_U64_LIMBS]; - - for idx in 0..KECCAK_WIDTH_U64_LIMBS { - preimage_buffer_bytes_u64[idx] = u64::from_le_bytes( - preimage_buffer_bytes[8 * idx..8 * idx + 8] - .try_into() - .unwrap(), - ); - } - - tiny_keccak::keccakf(&mut preimage_buffer_bytes_u64); - - // result is placed in preimage_buffer_bytes_u64 - // convert back to blocks of u8's - let mut result_u8: [u8; KECCAK_WIDTH_BYTES] = [0; KECCAK_WIDTH_BYTES]; - for idx in 0..KECCAK_WIDTH_U64_LIMBS { - let chunk: [u8; 8] = preimage_buffer_bytes_u64[idx].to_le_bytes(); - result_u8[8 * idx..8 * idx + 8].copy_from_slice(&chunk); - } - - for idx in 0..KECCAK_WIDTH_U32_LIMBS { - let chunk: [u8; 4] = result_u8[4 * idx..4 * idx + 4].try_into().unwrap(); - tracing_write( - state.memory, - RV32_MEMORY_AS, - record.inner.buffer + (idx * 4) as u32, - chunk, - &mut record.inner.buffer_write_aux_cols[idx].prev_timestamp, - &mut record.inner.buffer_write_aux_cols[idx].prev_data, - ); - } - - *state.pc = state.pc.wrapping_add(DEFAULT_PC_STEP); - Ok(()) - } -} - -impl TraceFiller for KeccakfVmFiller { - fn fill_trace( - &self, - mem_helper: &MemoryAuxColsFactory, - trace_matrix: &mut RowMajorMatrix, - rows_used: usize, - ) { - if rows_used == 0 { - return; - } - - let (trace, dummy_trace) = trace_matrix - .values - .split_at_mut(rows_used * NUM_KECCAKF_VM_COLS); - - let p3_dummy_trace: RowMajorMatrix = - generate_trace_rows(vec![[0u64; KECCAK_WIDTH_U64_LIMBS]; 1], 0); - - dummy_trace - // Each Keccak-f round corresponds to exactly one trace row of width - // NUM_KECCAKF_VM_COLS. We already reserved NUM_ROUNDS rows above - // (NUM_ROUNDS * NUM_KECCAKF_VM_COLS elements). - .chunks_exact_mut(NUM_KECCAKF_VM_COLS) - .enumerate() - .for_each(|(row_idx, row_slice)| { - let idx = row_idx % NUM_ROUNDS; - row_slice[..NUM_KECCAK_PERM_COLS].copy_from_slice( - &p3_dummy_trace.values - [idx * NUM_KECCAK_PERM_COLS..(idx + 1) * NUM_KECCAK_PERM_COLS], - ); - // Need to get rid of the accidental garbage data that might overflow - // the F's prime field. Unfortunately, there - // is no good way around this - // SAFETY: - // - row has exactly NUM_KECCAK_VM_COLS elements - // - NUM_KECCAK_PERM_COLS offset is less than NUM_KECCAK_VM_COLS by design - // - We're zeroing the remaining (NUM_KECCAK_VM_COLS - NUM_KECCAK_PERM_COLS) - // elements to clear any garbage data that might overflow the field - unsafe { - std::ptr::write_bytes( - row_slice.as_mut_ptr().add(NUM_KECCAK_PERM_COLS) as *mut u8, - 0, - (NUM_KECCAKF_VM_COLS - NUM_KECCAK_PERM_COLS) * size_of::(), - ); - } - }); - - trace - // Each Keccak-f round corresponds to exactly one trace row of width - // NUM_KECCAKF_VM_COLS. We already reserved NUM_ROUNDS rows above - // (NUM_ROUNDS * NUM_KECCAKF_VM_COLS elements). - .chunks_exact_mut(NUM_KECCAKF_VM_COLS * NUM_ROUNDS) - .for_each(|mut round_slice| { - // each round takes up one row in the trace matrix - // Safety: the initial prefix of the buffer of size NUM_KECCAKF_VM_COLS * NUM_ROUNDS - // holds the record header - let record: KeccakfVmRecordMut = unsafe { - get_record_from_slice( - &mut round_slice, - KeccakfVmRecordLayout { - metadata: KeccakfVmMetadata {}, - }, - ) - }; - let record = record.inner.clone(); - let mut timestamp = record.timestamp; - - // compute u64 preimage and postimage to not have to recompute per row - let preimage_buffer_bytes = record.preimage_buffer_bytes; - let mut preimage_buffer_bytes_u64: [u64; KECCAK_WIDTH_U64_LIMBS] = - [0; KECCAK_WIDTH_U64_LIMBS]; - for idx in 0..KECCAK_WIDTH_U64_LIMBS { - let le_bytes: [u8; 8] = preimage_buffer_bytes[8 * idx..8 * idx + 8] - .try_into() - .unwrap(); - preimage_buffer_bytes_u64[idx] = u64::from_le_bytes(le_bytes); - } - - let mut preimage_buffer_bytes_u64_transpose: [u64; KECCAK_WIDTH_U64_LIMBS] = - [0; KECCAK_WIDTH_U64_LIMBS]; - for y in 0..5 { - for x in 0..5 { - preimage_buffer_bytes_u64_transpose[x + 5 * y] = - preimage_buffer_bytes_u64[y + 5 * x]; - } - } - - let mut postimage_buffer_bytes_u64 = preimage_buffer_bytes_u64; - tiny_keccak::keccakf(&mut postimage_buffer_bytes_u64); - - let mut postimage_buffer_bytes: [u8; KECCAK_WIDTH_BYTES] = - [0u8; KECCAK_WIDTH_BYTES]; - for idx in 0..KECCAK_WIDTH_U64_LIMBS { - let chunk: [u8; 8] = postimage_buffer_bytes_u64[idx].to_le_bytes(); - postimage_buffer_bytes[8 * idx..8 * idx + 8].copy_from_slice(&chunk); - } - - // fills in inner - // the reason we give the transpose instead is inside, plonky3 transpose the - // input so transpose of transpose fixes it - let p3_trace: RowMajorMatrix = - generate_trace_rows(vec![preimage_buffer_bytes_u64_transpose], 0); - - round_slice - .chunks_exact_mut(NUM_KECCAKF_VM_COLS) - .enumerate() - .for_each(|(row_idx, row)| { - row[..NUM_KECCAK_PERM_COLS].copy_from_slice( - &p3_trace.values[row_idx * NUM_KECCAK_PERM_COLS - ..(row_idx + 1) * NUM_KECCAK_PERM_COLS], - ); - - // fills in preimage_state_hi - let cols: &mut KeccakfVmCols = row.borrow_mut(); - for idx in 0..KECCAK_WIDTH_BYTES / 2 { - cols.preimage_state_hi[idx] = - F::from_canonical_u8(preimage_buffer_bytes[2 * idx + 1]); - } - // fills in postimage_state_hi - for idx in 0..KECCAK_WIDTH_BYTES / 2 { - cols.postimage_state_hi[idx] = - F::from_canonical_u8(postimage_buffer_bytes[2 * idx + 1]); - } - // fills in instruction - cols.instruction.pc = F::from_canonical_u32(record.pc); - cols.instruction.is_enabled = F::ONE; - cols.timestamp = F::from_canonical_u32(timestamp); - cols.instruction.rd_ptr = F::from_canonical_u32(record.rd_ptr); - cols.instruction.buffer_ptr = F::from_canonical_u32(record.buffer); - cols.instruction.buffer_ptr_limbs = - record.buffer.to_le_bytes().map(F::from_canonical_u8); - - let is_first_round = cols.inner.step_flags[0]; - let is_final_round = cols.inner.step_flags[NUM_ROUNDS - 1]; - cols.is_enabled_is_first_round = is_first_round; - cols.is_enabled_is_final_round = is_final_round; - - // fills in memory offline checker - if row_idx == 0 { - mem_helper.fill( - record.register_aux_cols[0].prev_timestamp, - timestamp, - cols.mem_oc.register_aux_cols[0].as_mut(), - ); - timestamp += 1; - for t in 0..KECCAK_WIDTH_U32_LIMBS { - mem_helper.fill( - record.buffer_read_aux_cols[t].prev_timestamp, - timestamp, - cols.mem_oc.buffer_bytes_read_aux_cols[t].as_mut(), - ); - timestamp += 1; - } - - // safety: the following approach only works when self.pointer_max_bits - // >= 24 - let limb_shift = 1 - << (RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - - self.pointer_max_bits); - let buffer_limbs = record.buffer.to_le_bytes(); - let need_range_check = - [buffer_limbs.last().unwrap(), buffer_limbs.last().unwrap()]; - for pair in need_range_check.chunks_exact(2) { - self.bitwise_lookup_chip.request_range( - (pair[0] * limb_shift) as u32, - (pair[1] * limb_shift) as u32, - ); - } - } - - if row_idx == NUM_ROUNDS - 1 { - for t in 0..KECCAK_WIDTH_U32_LIMBS { - mem_helper.fill( - record.buffer_write_aux_cols[t].prev_timestamp, - timestamp, - cols.mem_oc.buffer_bytes_write_aux_cols[t].as_mut(), - ); - cols.mem_oc.buffer_bytes_write_aux_cols[t].prev_data = record - .buffer_write_aux_cols[t] - .prev_data - .map(F::from_canonical_u8); - timestamp += 1; - } - } - }); - }); - } -} diff --git a/extensions/new-keccak256/circuit/src/keccakf/utils.rs b/extensions/new-keccak256/circuit/src/keccakf/utils.rs deleted file mode 100644 index 2011ea926b..0000000000 --- a/extensions/new-keccak256/circuit/src/keccakf/utils.rs +++ /dev/null @@ -1,4 +0,0 @@ -pub const KECCAK_WIDTH_BYTES: usize = 200; -pub const KECCAK_WIDTH_U32_LIMBS: usize = 50; -pub const KECCAK_WIDTH_U64_LIMBS: usize = 25; -pub const KECCAK_WORD_SIZE: usize = 4; diff --git a/extensions/new-keccak256/circuit/src/lib.rs b/extensions/new-keccak256/circuit/src/lib.rs deleted file mode 100644 index 6ef84d65bc..0000000000 --- a/extensions/new-keccak256/circuit/src/lib.rs +++ /dev/null @@ -1,15 +0,0 @@ -#![cfg_attr(feature = "tco", allow(incomplete_features))] -#![cfg_attr(feature = "tco", feature(explicit_tail_calls))] -#![cfg_attr(feature = "tco", allow(internal_features))] -#![cfg_attr(feature = "tco", feature(core_intrinsics))] - -mod keccakf; -mod xorin; - -#[cfg(feature = "cuda")] -mod cuda; -#[cfg(feature = "cuda")] -pub use cuda::*; - -mod extension; -pub use extension::*; diff --git a/extensions/new-keccak256/circuit/src/xorin/utils.rs b/extensions/new-keccak256/circuit/src/xorin/utils.rs deleted file mode 100644 index b452f97ff5..0000000000 --- a/extensions/new-keccak256/circuit/src/xorin/utils.rs +++ /dev/null @@ -1,2 +0,0 @@ -pub const KECCAK_RATE_BYTES: usize = 136; -pub const KECCAK_WORD_SIZE: usize = 4; diff --git a/extensions/new-keccak256/guest/Cargo.toml b/extensions/new-keccak256/guest/Cargo.toml deleted file mode 100644 index 9cee7c3d9b..0000000000 --- a/extensions/new-keccak256/guest/Cargo.toml +++ /dev/null @@ -1,14 +0,0 @@ -[package] -name = "openvm-new-keccak256-guest" -description = "OpenVM guest library for keccak256" -version.workspace = true -authors.workspace = true -edition.workspace = true -homepage.workspace = true -repository.workspace = true - -[dependencies] -openvm-platform = { workspace = true } - -[features] -default = [] diff --git a/extensions/new-keccak256/guest/src/lib.rs b/extensions/new-keccak256/guest/src/lib.rs deleted file mode 100644 index 4140bf24ef..0000000000 --- a/extensions/new-keccak256/guest/src/lib.rs +++ /dev/null @@ -1,221 +0,0 @@ -#![no_std] - -#[cfg(target_os = "zkvm")] -extern crate alloc; -#[cfg(target_os = "zkvm")] -use openvm_platform::alloc::AlignedBuf; - -pub const OPCODE: u8 = 0x0b; -pub const KECCAKF_FUNCT3: u8 = 0b100; -pub const KECCAKF_FUNCT7: u8 = 0; -pub const XORIN_FUNCT3: u8 = 0b100; -pub const XORIN_FUNCT7: u8 = 3; - -pub const KECCAK_WIDTH_BYTES: usize = 200; -pub const KECCAK_RATE: usize = 136; -pub const KECCAK_OUTPUT_SIZE: usize = 32; -pub const MIN_ALIGN: usize = 4; - -#[cfg(target_os = "zkvm")] -#[repr(align(4))] -struct AlignedStackBuf { - data: [u8; N], -} - -/// SAFETY: Caller must ensure: -/// - buffer and input are aligned to MIN_ALIGN -/// - len is a multiple of MIN_ALIGN -#[cfg(target_os = "zkvm")] -#[inline(always)] -unsafe fn native_xorin_unchecked(buffer: *mut u8, input: *const u8, len: usize) { - __native_xorin(buffer, input, len); -} - -#[cfg(target_os = "zkvm")] -#[no_mangle] -pub extern "C" fn native_xorin(buffer: *mut u8, input: *const u8, len: usize) { - if len == 0 { - return; - } - unsafe { - let buffer_aligned = buffer as usize % MIN_ALIGN == 0; - let input_aligned = input as usize % MIN_ALIGN == 0; - let len_aligned = len % MIN_ALIGN == 0; - let all_aligned = buffer_aligned && input_aligned && len_aligned; - - if all_aligned { - __native_xorin(buffer, input, len); - } else { - let adjusted_len = len.next_multiple_of(MIN_ALIGN); - let aligned_buffer; - let aligned_input; - - let actual_buffer = if buffer_aligned && len_aligned { - buffer - } else { - aligned_buffer = AlignedBuf::new(buffer, adjusted_len, MIN_ALIGN); - aligned_buffer.ptr - }; - - let actual_input = if input_aligned && len_aligned { - input - } else { - aligned_input = AlignedBuf::new(input, adjusted_len, MIN_ALIGN); - aligned_input.ptr - }; - - __native_xorin(actual_buffer, actual_input, adjusted_len); - - if !buffer_aligned || !len_aligned { - core::ptr::copy_nonoverlapping(actual_buffer as *const u8, buffer, len); - } - } - } -} - -/// SAFETY: Caller must ensure buffer is aligned to MIN_ALIGN -#[cfg(target_os = "zkvm")] -#[inline(always)] -unsafe fn native_keccakf_unchecked(buffer: *mut u8) { - __native_keccakf(buffer); -} - -#[cfg(target_os = "zkvm")] -#[no_mangle] -pub extern "C" fn native_keccakf(buffer: *mut u8) { - unsafe { - if buffer as usize % MIN_ALIGN == 0 { - __native_keccakf(buffer); - } else { - let aligned_buffer = AlignedBuf::new(buffer, KECCAK_WIDTH_BYTES, MIN_ALIGN); - __native_keccakf(aligned_buffer.ptr); - core::ptr::copy_nonoverlapping( - aligned_buffer.ptr as *const u8, - buffer, - KECCAK_WIDTH_BYTES, - ); - } - } -} - -/// Native hook for keccak256 for use with `alloy-primitives` "native-keccak" feature. -/// -/// # Safety -/// -/// The VM accepts the preimage by pointer and length, and writes the -/// 32-byte hash. -/// - `bytes` must point to an input buffer at least `len` long. -/// - `output` must point to a buffer that is at least 32-bytes long. -/// -/// [`keccak256`]: https://en.wikipedia.org/wiki/SHA-3 -/// [`sha3`]: https://docs.rs/sha3/latest/sha3/ -/// [`tiny_keccak`]: https://docs.rs/tiny-keccak/latest/tiny_keccak/ -#[cfg(target_os = "zkvm")] -#[no_mangle] -pub extern "C" fn native_keccak256(bytes: *const u8, len: usize, output: *mut u8) { - unsafe { - let bytes_aligned = bytes as usize % MIN_ALIGN == 0; - let output_aligned = output as usize % MIN_ALIGN == 0; - - let aligned_bytes; - let aligned_output; - - let actual_bytes = if len == 0 || bytes_aligned { - bytes - } else { - aligned_bytes = AlignedBuf::new(bytes, len, MIN_ALIGN); - aligned_bytes.ptr - }; - - let actual_output = if output_aligned { - output - } else { - aligned_output = AlignedBuf::uninit(KECCAK_OUTPUT_SIZE, MIN_ALIGN); - aligned_output.ptr - }; - - keccak256_impl(actual_bytes, len, actual_output); - - if !output_aligned { - core::ptr::copy_nonoverlapping(actual_output as *const u8, output, KECCAK_OUTPUT_SIZE); - } - } -} - -/// SAFETY: This function is only called from native_keccak256 which ensures: -/// - input is aligned to MIN_ALIGN -/// - output is aligned to MIN_ALIGN -/// - All internal buffers are aligned by AlignedStackBuf -#[cfg(target_os = "zkvm")] -#[inline(always)] -unsafe fn keccak256_impl(input: *const u8, len: usize, output: *mut u8) { - let mut buffer = AlignedStackBuf:: { - data: [0u8; KECCAK_WIDTH_BYTES], - }; - let buffer_ptr = buffer.data.as_mut_ptr(); - - let mut offset = 0; - let mut remaining = len; - - // Absorb full blocks - while remaining >= KECCAK_RATE { - native_xorin_unchecked(buffer_ptr, input.add(offset), KECCAK_RATE); - native_keccakf_unchecked(buffer_ptr); - offset += KECCAK_RATE; - remaining -= KECCAK_RATE; - } - - // Handle remaining bytes - if remaining > 0 { - if remaining % MIN_ALIGN == 0 { - native_xorin_unchecked(buffer_ptr, input.add(offset), remaining); - } else { - let adjusted_len = remaining.next_multiple_of(MIN_ALIGN); - let mut padded_input = AlignedStackBuf:: { - data: [0u8; KECCAK_RATE], - }; - core::ptr::copy_nonoverlapping( - input.add(offset), - padded_input.data.as_mut_ptr(), - remaining, - ); - native_xorin_unchecked(buffer_ptr, padded_input.data.as_ptr(), adjusted_len); - } - } - - // Apply Keccak padding (pad10*1) - buffer.data[remaining] ^= 0x01; - buffer.data[KECCAK_RATE - 1] ^= 0x80; - - // Final permutation - native_keccakf_unchecked(buffer_ptr); - - // Extract output - core::ptr::copy_nonoverlapping(buffer.data.as_ptr(), output, KECCAK_OUTPUT_SIZE); -} - -#[cfg(target_os = "zkvm")] -#[inline(always)] -fn __native_xorin(mut buffer: *mut u8, input: *const u8, len: usize) { - openvm_platform::custom_insn_r!( - opcode = OPCODE, - funct3 = XORIN_FUNCT3, - funct7 = XORIN_FUNCT7, - rd = InOut buffer, - rs1 = In input, - rs2 = In len - ); -} - -#[cfg(target_os = "zkvm")] -#[inline(always)] -fn __native_keccakf(mut buffer: *mut u8) { - openvm_platform::custom_insn_r!( - opcode = OPCODE, - funct3 = KECCAKF_FUNCT3, - funct7 = KECCAKF_FUNCT7, - rd = InOut buffer, - rs1 = Const "x0", - rs2 = Const "x0", - ); -} diff --git a/extensions/new-keccak256/transpiler/Cargo.toml b/extensions/new-keccak256/transpiler/Cargo.toml deleted file mode 100644 index 6837893c44..0000000000 --- a/extensions/new-keccak256/transpiler/Cargo.toml +++ /dev/null @@ -1,17 +0,0 @@ -[package] -name = "openvm-new-keccak256-transpiler" -description = "OpenVM transpiler extension for keccak256" -version.workspace = true -authors.workspace = true -edition.workspace = true -homepage.workspace = true -repository.workspace = true - -[dependencies] -openvm-stark-backend = { workspace = true } -openvm-instructions = { workspace = true } -openvm-transpiler = { workspace = true } -rrs-lib = { workspace = true } -openvm-new-keccak256-guest = { workspace = true } -openvm-instructions-derive = { workspace = true } -strum = { workspace = true } diff --git a/extensions/new-keccak256/transpiler/src/lib.rs b/extensions/new-keccak256/transpiler/src/lib.rs deleted file mode 100644 index 645e82031c..0000000000 --- a/extensions/new-keccak256/transpiler/src/lib.rs +++ /dev/null @@ -1,70 +0,0 @@ -use core::panic; - -use openvm_instructions::{riscv::RV32_MEMORY_AS, LocalOpcode}; -use openvm_instructions_derive::LocalOpcode; -use openvm_new_keccak256_guest::{KECCAKF_FUNCT7, OPCODE, XORIN_FUNCT3, XORIN_FUNCT7}; -use openvm_stark_backend::p3_field::PrimeField32; -use openvm_transpiler::{util::from_r_type, TranspilerExtension, TranspilerOutput}; -use rrs_lib::instruction_formats::RType; -use strum::{EnumCount, EnumIter, FromRepr}; - -#[derive( - Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, EnumCount, EnumIter, FromRepr, LocalOpcode, -)] -#[opcode_offset = 0x310] -#[repr(usize)] -pub enum KeccakfOpcode { - KECCAKF, -} - -#[derive( - Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, EnumCount, EnumIter, FromRepr, LocalOpcode, -)] -#[opcode_offset = 0x311] -#[repr(usize)] -pub enum XorinOpcode { - XORIN, -} - -#[derive(Default)] -pub struct NewKeccakTranspilerExtension; - -impl TranspilerExtension for NewKeccakTranspilerExtension { - fn process_custom(&self, instruction_stream: &[u32]) -> Option> { - if instruction_stream.is_empty() { - return None; - } - let instruction_u32 = instruction_stream[0]; - let opcode = (instruction_u32 & 0x7f) as u8; - let funct3 = ((instruction_u32 >> 12) & 0b111) as u8; - - // Safety note: KECCAKF_FUNCT3 == XORIN_FUNCT3 so it suffices to check once - if (opcode, funct3) != (OPCODE, XORIN_FUNCT3) { - return None; - } - - let dec_insn = RType::new(instruction_u32); - - if dec_insn.funct7 != XORIN_FUNCT7 as u32 && dec_insn.funct7 != KECCAKF_FUNCT7 as u32 { - return None; - } - - let instruction = if dec_insn.funct7 == XORIN_FUNCT7 as u32 { - from_r_type( - XorinOpcode::XORIN.global_opcode().as_usize(), - RV32_MEMORY_AS as usize, - &dec_insn, - true, - ) - } else { - from_r_type( - KeccakfOpcode::KECCAKF.global_opcode().as_usize(), - RV32_MEMORY_AS as usize, - &dec_insn, - true, - ) - }; - - Some(TranspilerOutput::one_to_one(instruction)) - } -} diff --git a/guest-libs/keccak256/src/lib.rs b/guest-libs/keccak256/src/lib.rs index 963bee9d53..29614ea9ae 100644 --- a/guest-libs/keccak256/src/lib.rs +++ b/guest-libs/keccak256/src/lib.rs @@ -3,7 +3,6 @@ #[cfg(target_os = "zkvm")] use core::mem::MaybeUninit; -/// The keccak256 cryptographic hash function. #[inline(always)] pub fn keccak256(input: &[u8]) -> [u8; 32] { #[cfg(not(target_os = "zkvm"))] diff --git a/guest-libs/keccak256/tests/lib.rs b/guest-libs/keccak256/tests/lib.rs index fbab4ef8c8..59c48e740c 100644 --- a/guest-libs/keccak256/tests/lib.rs +++ b/guest-libs/keccak256/tests/lib.rs @@ -3,7 +3,11 @@ mod tests { use eyre::Result; use openvm_circuit::utils::air_test; use openvm_instructions::exe::VmExe; - use openvm_keccak256_circuit::{Keccak256Rv32Builder, Keccak256Rv32Config}; + use openvm_keccak256_circuit::Keccak256Rv32Config; + #[cfg(not(feature = "cuda"))] + use openvm_keccak256_circuit::Keccak256Rv32CpuBuilder as TestBuilder; + #[cfg(feature = "cuda")] + use openvm_keccak256_circuit::Keccak256Rv32GpuBuilder as TestBuilder; use openvm_keccak256_transpiler::Keccak256TranspilerExtension; use openvm_rv32im_transpiler::{ Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension, @@ -27,7 +31,7 @@ mod tests { .with_extension(Rv32MTranspilerExtension) .with_extension(Rv32IoTranspilerExtension), )?; - air_test(Keccak256Rv32Builder, config, openvm_exe); + air_test(TestBuilder, config, openvm_exe); Ok(()) } } diff --git a/guest-libs/new_keccak256/Cargo.toml b/guest-libs/new_keccak256/Cargo.toml deleted file mode 100644 index 8bec1ea5a7..0000000000 --- a/guest-libs/new_keccak256/Cargo.toml +++ /dev/null @@ -1,16 +0,0 @@ -[package] -name = "openvm-new-keccak256" -description = "OpenVM library for keccak256" -version.workspace = true -edition.workspace = true -rust-version.workspace = true -authors.workspace = true -homepage.workspace = true -repository.workspace = true -license.workspace = true - -[dependencies] -openvm-new-keccak256-guest = { workspace = true } - -[target.'cfg(not(target_os = "zkvm"))'.dependencies] -tiny-keccak = { workspace = true } diff --git a/guest-libs/new_keccak256/src/lib.rs b/guest-libs/new_keccak256/src/lib.rs deleted file mode 100644 index f0ed185199..0000000000 --- a/guest-libs/new_keccak256/src/lib.rs +++ /dev/null @@ -1,41 +0,0 @@ -#![no_std] - -#[cfg(target_os = "zkvm")] -use core::mem::MaybeUninit; - -#[inline(always)] -pub fn keccak256(input: &[u8]) -> [u8; 32] { - #[cfg(not(target_os = "zkvm"))] - { - let mut output = [0u8; 32]; - set_keccak256(input, &mut output); - output - } - #[cfg(target_os = "zkvm")] - { - let mut output = MaybeUninit::<[u8; 32]>::uninit(); - openvm_new_keccak256_guest::native_keccak256( - input.as_ptr(), - input.len(), - output.as_mut_ptr() as *mut u8, - ); - unsafe { output.assume_init() } - } -} - -/// Sets `output` to the keccak256 hash of `input`. -pub fn set_keccak256(input: &[u8], output: &mut [u8; 32]) { - #[cfg(not(target_os = "zkvm"))] - { - use tiny_keccak::Hasher; - let mut hasher = tiny_keccak::Keccak::v256(); - hasher.update(input); - hasher.finalize(output); - } - #[cfg(target_os = "zkvm")] - openvm_new_keccak256_guest::native_keccak256( - input.as_ptr(), - input.len(), - output.as_mut_ptr() as *mut u8, - ); -} From 0ab82a2d44a9d35526cc51ad915162e636373001 Mon Sep 17 00:00:00 2001 From: Jonathan Wang <31040440+jonathanpwang@users.noreply.github.com> Date: Fri, 16 Jan 2026 14:49:59 -0800 Subject: [PATCH 09/78] feat(new-keccak): optimize guest to skip first xorin (#2360) closes INT-5935 --- extensions/keccak256/guest/src/lib.rs | 28 +++++++++++++++++++++++---- 1 file changed, 24 insertions(+), 4 deletions(-) diff --git a/extensions/keccak256/guest/src/lib.rs b/extensions/keccak256/guest/src/lib.rs index 1930b25d41..048977484c 100644 --- a/extensions/keccak256/guest/src/lib.rs +++ b/extensions/keccak256/guest/src/lib.rs @@ -162,11 +162,31 @@ unsafe fn keccak256_impl(input: *const u8, len: usize, output: *mut u8) { let mut buffer = KECCAK_BUFFER.lock(); let buffer_ptr = buffer.data.as_mut_ptr(); - // Zero the buffer (memset equivalent) - core::ptr::write_bytes(buffer_ptr, 0, KECCAK_WIDTH_BYTES); + // State starts as [0u8; KECCAK_WIDTH_BYTES]. To save the first xorin, we memcpy directly into + // state. + let first_xorin_len = core::cmp::min(len, KECCAK_RATE); + core::ptr::copy_nonoverlapping(input, buffer_ptr, first_xorin_len); + core::ptr::write_bytes( + buffer_ptr.add(first_xorin_len), + 0u8, + KECCAK_WIDTH_BYTES - first_xorin_len, + ); + if first_xorin_len >= KECCAK_RATE { + native_keccakf_unchecked(buffer_ptr); + } else { + // We pad, do a single keccakf, and early return + + // 1*01 padding + buffer.data[first_xorin_len] ^= 0x01; + buffer.data[KECCAK_RATE - 1] ^= 0x80; + native_keccakf_unchecked(buffer_ptr); + + core::ptr::copy_nonoverlapping(buffer_ptr, output, KECCAK_OUTPUT_SIZE); + return; + } - let mut offset = 0; - let mut remaining = len; + let mut offset = KECCAK_RATE; + let mut remaining = len - KECCAK_RATE; // Absorb full blocks while remaining >= KECCAK_RATE { From e30c951fd1bccb4d624550611067773b31c3b872 Mon Sep 17 00:00:00 2001 From: Jonathan Wang <31040440+jonathanpwang@users.noreply.github.com> Date: Tue, 20 Jan 2026 11:01:59 -0800 Subject: [PATCH 10/78] chore: update openvm `tiny-keccak` patch (#2362) --- examples/keccak/Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/keccak/Cargo.toml b/examples/keccak/Cargo.toml index 88a3e144a3..5dca565717 100644 --- a/examples/keccak/Cargo.toml +++ b/examples/keccak/Cargo.toml @@ -7,7 +7,7 @@ edition = "2021" members = [] [dependencies] -tiny-keccak = { git = "https://github.com/openvm-org/tiny-keccak", branch = "perf/custom-xorin-keccak", features = ["keccak"] } +tiny-keccak = { git = "https://github.com/openvm-org/tiny-keccak", features = ["keccak"] } hex-literal = "1.1.0" [target.'cfg(target_os = "zkvm")'.dependencies] From b136f5beb947d38be4e589f3675ffad30d57957d Mon Sep 17 00:00:00 2001 From: Avaneesh-axiom Date: Sat, 28 Feb 2026 02:17:28 +0000 Subject: [PATCH 11/78] feat: SHA-2 incremental hasher design (#2182) Implemented a new design for constraining the SHA-2 family of hash functions (specifically SHA-256, SHA-512, SHA-384). The new design adds incremental hasher functionality, which means we can compute the hash of a stream of bytes. More specifically, the new `Sha256`, `Sha512`, and `Sha384` structs provided in the SHA-2 guest library provide the `update(&[u8])` and `finalize() -> [u8; HASH_SIZE]` methods. We can instantiate a hasher object, `let hasher = Sha256::new()` and then call `hasher.update(data)` as many times as we want on it. The `data` parameter can be a slice of any size. When we would like to retrieve the hash, we can call `hasher.finalize()`. The `Sha256` struct in the SHA-2 guest library maintains an array of bytes that serves as the internal state of the SHA-2 hashing algorithm. This array is updated using a new opcode: `SHA256_UPDATE dst src input` which takes in one block of input and pointers to the src/dst hasher states (the guest library sets `src == dst` for updating the state in-place). The `Sha256` struct will buffer up to one block of input, and it will call `SHA2_UPDATE` when necessary to absorb the input into the state. The `Sha512` and `Sha384` structs are implemented similarly. The `Sha256`, `Sha512`, `Sha384` structs implement the `sha2::Digest` trait, allowing them to be used as a drop-in replacement for the popular `sha2` crate's `sha2::{Sha256, Sha512, Sha384}` hasher objects. The OpenVM book, specs, and the crate docs have been updated. Additionally, a brief justification of soundness for the main constraints has been added. All the SHA-2 guest library integration tests and the SHA-2 circuit unit tests pass on CI. Both CPU and GPU trace generation is tested among these tests. closes INT-4972 INT-5023 INT-5024 INT-5025 INT-5026 --- .github/workflows/extension-tests.cuda.yml | 6 +- .github/workflows/extension-tests.yml | 4 +- .github/workflows/guest-lib-tests.cuda.yml | 2 +- .github/workflows/primitives.yml | 9 +- Cargo.lock | 512 +++++--- Cargo.toml | 16 +- benchmarks/execute/Cargo.toml | 10 +- benchmarks/execute/benches/execute.rs | 16 +- benchmarks/guest/kitchen-sink/openvm.toml | 2 +- benchmarks/guest/sha256/openvm.toml | 2 +- benchmarks/guest/sha256/src/main.rs | 8 +- benchmarks/guest/sha256_iter/openvm.toml | 2 +- benchmarks/guest/sha256_iter/src/main.rs | 8 +- crates/circuits/primitives/derive/Cargo.toml | 11 +- .../primitives/derive/src/cols_ref/README.md | 113 ++ .../primitives/derive/src/cols_ref/mod.rs | 703 +++++++++++ .../primitives/derive/src/cols_ref/utils.rs | 102 ++ crates/circuits/primitives/derive/src/lib.rs | 25 + .../primitives/derive/tests/example.rs | 87 ++ .../primitives/derive/tests/test_cols_ref.rs | 299 +++++ crates/circuits/sha2-air/Cargo.toml | 19 + crates/circuits/sha2-air/SOUNDNESS.md | 209 ++++ crates/circuits/sha2-air/src/air.rs | 617 ++++++++++ crates/circuits/sha2-air/src/columns.rs | 170 +++ crates/circuits/sha2-air/src/config.rs | 323 +++++ crates/circuits/sha2-air/src/lib.rs | 11 + crates/circuits/sha2-air/src/trace.rs | 663 ++++++++++ crates/circuits/sha2-air/src/utils.rs | 313 +++++ crates/circuits/sha256-air/Cargo.toml | 20 - .../cuda/include/sha256-air/columns.cuh | 131 -- .../cuda/include/sha256-air/tracegen.cuh | 632 ---------- .../cuda/include/sha256-air/utils.cuh | 177 --- crates/circuits/sha256-air/src/air.rs | 612 ---------- crates/circuits/sha256-air/src/columns.rs | 140 --- crates/circuits/sha256-air/src/lib.rs | 15 - crates/circuits/sha256-air/src/tests.rs | 163 --- crates/circuits/sha256-air/src/trace.rs | 551 --------- crates/circuits/sha256-air/src/utils.rs | 271 ----- crates/sdk-config/Cargo.toml | 10 +- crates/sdk-config/src/lib.rs | 16 +- crates/sdk-config/v1.5/openvm_standard.toml | 2 +- crates/vm/src/arch/testing/cpu.rs | 47 +- .../overview.mdx | 5 +- .../acceleration-using-extensions/sha-2.mdx | 45 + .../acceleration-using-extensions/sha-256.mdx | 35 - .../docs/pages/book/advanced-usage/sdk.mdx | 2 +- .../book/getting-started/introduction.mdx | 3 +- .../docs/pages/book/guest-libraries/sha2.mdx | 33 +- .../architecture/circuit-architecture.mdx | 2 +- docs/vocs/docs/pages/specs/openvm/isa.mdx | 9 +- .../specs/reference/instruction-reference.mdx | 9 +- .../specs/reference/riscv-custom-code.mdx | 11 +- .../docs/pages/specs/reference/transpiler.mdx | 9 +- examples/{sha256 => sha2}/Cargo.toml | 10 +- examples/{sha256 => sha2}/openvm.toml | 2 +- examples/sha2/src/main.rs | 41 + examples/sha256/src/main.rs | 24 - .../{sha256 => sha2}/circuit/Cargo.toml | 18 +- extensions/sha2/circuit/README.md | 93 ++ extensions/{sha256 => sha2}/circuit/build.rs | 8 +- .../cuda/include/block_hasher/columns.cuh | 110 ++ .../cuda/include/block_hasher/record.cuh | 68 ++ .../cuda/include/block_hasher/variant.cuh | 297 +++++ .../circuit/cuda/include/main/columns.cuh | 116 ++ .../sha2/circuit/cuda/include/main/record.cuh | 70 ++ .../sha2/circuit/cuda/include/variant.cuh | 6 + .../sha2/circuit/cuda/src/sha2_hasher.cu | 1066 +++++++++++++++++ extensions/sha2/circuit/cuda/src/sha2_main.cu | 219 ++++ extensions/sha2/circuit/src/cuda/cuda_abi.rs | 326 +++++ extensions/sha2/circuit/src/cuda/mod.rs | 289 +++++ extensions/sha2/circuit/src/extension/cuda.rs | 117 ++ extensions/sha2/circuit/src/extension/mod.rs | 281 +++++ extensions/sha2/circuit/src/lib.rs | 15 + .../src/sha2_chips/block_hasher_chip/air.rs | 156 +++ .../sha2_chips/block_hasher_chip/columns.rs | 59 + .../sha2_chips/block_hasher_chip/config.rs | 52 + .../src/sha2_chips/block_hasher_chip/mod.rs | 55 + .../src/sha2_chips/block_hasher_chip/trace.rs | 271 +++++ .../sha2/circuit/src/sha2_chips/config.rs | 97 ++ .../circuit/src/sha2_chips}/execution.rs | 157 +-- .../circuit/src/sha2_chips/main_chip/air.rs | 326 +++++ .../src/sha2_chips/main_chip/columns.rs | 74 ++ .../src/sha2_chips/main_chip/config.rs | 42 + .../circuit/src/sha2_chips/main_chip/mod.rs | 58 + .../circuit/src/sha2_chips/main_chip/trace.rs | 222 ++++ extensions/sha2/circuit/src/sha2_chips/mod.rs | 33 + .../sha2/circuit/src/sha2_chips/test_utils.rs | 77 ++ .../sha2/circuit/src/sha2_chips/tests.rs | 867 ++++++++++++++ .../sha2/circuit/src/sha2_chips/trace.rs | 320 +++++ extensions/{sha256 => sha2}/guest/Cargo.toml | 4 +- extensions/sha2/guest/src/lib.rs | 155 +++ .../{sha256 => sha2}/transpiler/Cargo.toml | 6 +- extensions/sha2/transpiler/src/lib.rs | 58 + extensions/sha256/circuit/README.md | 93 -- extensions/sha256/circuit/cuda/src/sha256.cu | 447 ------- extensions/sha256/circuit/src/cuda_abi.rs | 124 -- .../sha256/circuit/src/extension/cuda.rs | 39 - .../sha256/circuit/src/extension/mod.rs | 142 --- extensions/sha256/circuit/src/lib.rs | 156 --- .../sha256/circuit/src/sha256_chip/air.rs | 621 ---------- .../sha256/circuit/src/sha256_chip/columns.rs | 70 -- .../sha256/circuit/src/sha256_chip/cuda.rs | 127 -- .../sha256/circuit/src/sha256_chip/mod.rs | 78 -- .../sha256/circuit/src/sha256_chip/tests.rs | 376 ------ .../sha256/circuit/src/sha256_chip/trace.rs | 623 ---------- extensions/sha256/guest/src/lib.rs | 69 -- extensions/sha256/transpiler/src/lib.rs | 46 - guest-libs/k256/Cargo.toml | 8 +- guest-libs/k256/src/ecdsa.rs | 2 +- guest-libs/k256/tests/lib.rs | 18 +- .../k256/tests/programs/examples/ecdsa.rs | 10 +- guest-libs/p256/Cargo.toml | 8 +- guest-libs/p256/tests/lib.rs | 18 +- guest-libs/sha2/Cargo.toml | 13 +- guest-libs/sha2/src/host_impl.rs | 3 + guest-libs/sha2/src/lib.rs | 35 +- guest-libs/sha2/src/zkvm_impl.rs | 292 +++++ guest-libs/sha2/tests/lib.rs | 14 +- guest-libs/sha2/tests/programs/Cargo.toml | 8 +- .../sha2/tests/programs/examples/sha.rs | 29 - .../sha2/tests/programs/examples/sha2.rs | 95 ++ rust-toolchain.toml | 2 +- 122 files changed, 10785 insertions(+), 6258 deletions(-) create mode 100644 crates/circuits/primitives/derive/src/cols_ref/README.md create mode 100644 crates/circuits/primitives/derive/src/cols_ref/mod.rs create mode 100644 crates/circuits/primitives/derive/src/cols_ref/utils.rs create mode 100644 crates/circuits/primitives/derive/tests/example.rs create mode 100644 crates/circuits/primitives/derive/tests/test_cols_ref.rs create mode 100644 crates/circuits/sha2-air/Cargo.toml create mode 100644 crates/circuits/sha2-air/SOUNDNESS.md create mode 100644 crates/circuits/sha2-air/src/air.rs create mode 100644 crates/circuits/sha2-air/src/columns.rs create mode 100644 crates/circuits/sha2-air/src/config.rs create mode 100644 crates/circuits/sha2-air/src/lib.rs create mode 100644 crates/circuits/sha2-air/src/trace.rs create mode 100644 crates/circuits/sha2-air/src/utils.rs delete mode 100644 crates/circuits/sha256-air/Cargo.toml delete mode 100644 crates/circuits/sha256-air/cuda/include/sha256-air/columns.cuh delete mode 100644 crates/circuits/sha256-air/cuda/include/sha256-air/tracegen.cuh delete mode 100644 crates/circuits/sha256-air/cuda/include/sha256-air/utils.cuh delete mode 100644 crates/circuits/sha256-air/src/air.rs delete mode 100644 crates/circuits/sha256-air/src/columns.rs delete mode 100644 crates/circuits/sha256-air/src/lib.rs delete mode 100644 crates/circuits/sha256-air/src/tests.rs delete mode 100644 crates/circuits/sha256-air/src/trace.rs delete mode 100644 crates/circuits/sha256-air/src/utils.rs create mode 100644 docs/vocs/docs/pages/book/acceleration-using-extensions/sha-2.mdx delete mode 100644 docs/vocs/docs/pages/book/acceleration-using-extensions/sha-256.mdx rename examples/{sha256 => sha2}/Cargo.toml (63%) rename examples/{sha256 => sha2}/openvm.toml (73%) create mode 100644 examples/sha2/src/main.rs delete mode 100644 examples/sha256/src/main.rs rename extensions/{sha256 => sha2}/circuit/Cargo.toml (81%) create mode 100644 extensions/sha2/circuit/README.md rename extensions/{sha256 => sha2}/circuit/build.rs (74%) create mode 100644 extensions/sha2/circuit/cuda/include/block_hasher/columns.cuh create mode 100644 extensions/sha2/circuit/cuda/include/block_hasher/record.cuh create mode 100644 extensions/sha2/circuit/cuda/include/block_hasher/variant.cuh create mode 100644 extensions/sha2/circuit/cuda/include/main/columns.cuh create mode 100644 extensions/sha2/circuit/cuda/include/main/record.cuh create mode 100644 extensions/sha2/circuit/cuda/include/variant.cuh create mode 100644 extensions/sha2/circuit/cuda/src/sha2_hasher.cu create mode 100644 extensions/sha2/circuit/cuda/src/sha2_main.cu create mode 100644 extensions/sha2/circuit/src/cuda/cuda_abi.rs create mode 100644 extensions/sha2/circuit/src/cuda/mod.rs create mode 100644 extensions/sha2/circuit/src/extension/cuda.rs create mode 100644 extensions/sha2/circuit/src/extension/mod.rs create mode 100644 extensions/sha2/circuit/src/lib.rs create mode 100644 extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/air.rs create mode 100644 extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/columns.rs create mode 100644 extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/config.rs create mode 100644 extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/mod.rs create mode 100644 extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/trace.rs create mode 100644 extensions/sha2/circuit/src/sha2_chips/config.rs rename extensions/{sha256/circuit/src/sha256_chip => sha2/circuit/src/sha2_chips}/execution.rs (53%) create mode 100644 extensions/sha2/circuit/src/sha2_chips/main_chip/air.rs create mode 100644 extensions/sha2/circuit/src/sha2_chips/main_chip/columns.rs create mode 100644 extensions/sha2/circuit/src/sha2_chips/main_chip/config.rs create mode 100644 extensions/sha2/circuit/src/sha2_chips/main_chip/mod.rs create mode 100644 extensions/sha2/circuit/src/sha2_chips/main_chip/trace.rs create mode 100644 extensions/sha2/circuit/src/sha2_chips/mod.rs create mode 100644 extensions/sha2/circuit/src/sha2_chips/test_utils.rs create mode 100644 extensions/sha2/circuit/src/sha2_chips/tests.rs create mode 100644 extensions/sha2/circuit/src/sha2_chips/trace.rs rename extensions/{sha256 => sha2}/guest/Cargo.toml (69%) create mode 100644 extensions/sha2/guest/src/lib.rs rename extensions/{sha256 => sha2}/transpiler/Cargo.toml (73%) create mode 100644 extensions/sha2/transpiler/src/lib.rs delete mode 100644 extensions/sha256/circuit/README.md delete mode 100644 extensions/sha256/circuit/cuda/src/sha256.cu delete mode 100644 extensions/sha256/circuit/src/cuda_abi.rs delete mode 100644 extensions/sha256/circuit/src/extension/cuda.rs delete mode 100644 extensions/sha256/circuit/src/extension/mod.rs delete mode 100644 extensions/sha256/circuit/src/lib.rs delete mode 100644 extensions/sha256/circuit/src/sha256_chip/air.rs delete mode 100644 extensions/sha256/circuit/src/sha256_chip/columns.rs delete mode 100644 extensions/sha256/circuit/src/sha256_chip/cuda.rs delete mode 100644 extensions/sha256/circuit/src/sha256_chip/mod.rs delete mode 100644 extensions/sha256/circuit/src/sha256_chip/tests.rs delete mode 100644 extensions/sha256/circuit/src/sha256_chip/trace.rs delete mode 100644 extensions/sha256/guest/src/lib.rs delete mode 100644 extensions/sha256/transpiler/src/lib.rs create mode 100644 guest-libs/sha2/src/host_impl.rs create mode 100644 guest-libs/sha2/src/zkvm_impl.rs delete mode 100644 guest-libs/sha2/tests/programs/examples/sha.rs create mode 100644 guest-libs/sha2/tests/programs/examples/sha2.rs diff --git a/.github/workflows/extension-tests.cuda.yml b/.github/workflows/extension-tests.cuda.yml index 3993628601..49234ddf2a 100644 --- a/.github/workflows/extension-tests.cuda.yml +++ b/.github/workflows/extension-tests.cuda.yml @@ -34,7 +34,7 @@ jobs: matrix: extensions: # group extensions on the same runner based on test time - "rv32im" - - "keccak256 sha256 bigint algebra ecc pairing deferral" + - "keccak256 sha2 bigint algebra ecc pairing deferral" runs-on: - runs-on=${{ github.run_id }}-extension-tests-cuda-${{ github.run_attempt }}-${{ strategy.job-index }}/runner=${{ github.event_name == 'workflow_dispatch' && github.event.inputs.machine_type || 'test-gpu-nvidia/family=g6.*+g6e' }} @@ -54,8 +54,8 @@ jobs: - "extensions/rv32im/**" keccak256: - "extensions/keccak256/**" - sha256: - - "extensions/sha256/**" + sha2: + - "extensions/sha2/**" bigint: - "extensions/bigint/**" algebra: diff --git a/.github/workflows/extension-tests.yml b/.github/workflows/extension-tests.yml index 601bc9ced8..dff981ccfe 100644 --- a/.github/workflows/extension-tests.yml +++ b/.github/workflows/extension-tests.yml @@ -29,7 +29,7 @@ jobs: extension: - { name: "rv32im", path: "rv32im", aot: false } - { name: "keccak256", path: "keccak256", aot: false } - - { name: "sha256", path: "sha256", aot: false } + - { name: "sha2", path: "sha2", aot: false } - { name: "bigint", path: "bigint", aot: false } - { name: "algebra", path: "algebra", aot: false } - { name: "ecc", path: "ecc", aot: false } @@ -37,7 +37,7 @@ jobs: - { name: "deferral", path: "deferral", aot: false } - { name: "rv32im", path: "rv32im", aot: true } - { name: "keccak256", path: "keccak256", aot: true } - - { name: "sha256", path: "sha256", aot: true } + - { name: "sha2", path: "sha2", aot: true } - { name: "bigint", path: "bigint", aot: true } - { name: "algebra", path: "algebra", aot: true } - { name: "ecc", path: "ecc", aot: true } diff --git a/.github/workflows/guest-lib-tests.cuda.yml b/.github/workflows/guest-lib-tests.cuda.yml index dd084ed0e5..f3e5cfdf8c 100644 --- a/.github/workflows/guest-lib-tests.cuda.yml +++ b/.github/workflows/guest-lib-tests.cuda.yml @@ -51,7 +51,7 @@ jobs: - ".github/workflows/guest-lib-tests.cuda.yml" - "crates/sdk/guest/fib/**" sha2: - - "extensions/sha256/**" + - "extensions/sha2/**" - "guest-libs/sha2/**" keccak256: - "extensions/keccak256/**" diff --git a/.github/workflows/primitives.yml b/.github/workflows/primitives.yml index 434cf8357c..1ee2f6efcb 100644 --- a/.github/workflows/primitives.yml +++ b/.github/workflows/primitives.yml @@ -9,7 +9,7 @@ on: paths: - "crates/circuits/primitives/**" - "crates/circuits/poseidon2-air/**" - - "crates/circuits/sha256-air/**" + - "crates/circuits/sha2-air/**" - "crates/circuits/mod-builder/**" - "Cargo.toml" - ".github/workflows/primitives.yml" @@ -64,13 +64,6 @@ jobs: run: | cargo nextest run ${{ env.NEXTEST_ARGS }} - # No gpu tests in these crates - - name: Run tests for sha256-air - if: ${{ !contains(matrix.platform.runner, 'gpu') }} - working-directory: crates/circuits/sha256-air - run: | - cargo nextest run ${{ env.NEXTEST_ARGS }} - - name: Run tests for mod-builder if: ${{ !contains(matrix.platform.runner, 'gpu') }} working-directory: crates/circuits/mod-builder diff --git a/Cargo.lock b/Cargo.lock index 2291a67031..3fb0266b49 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -106,9 +106,9 @@ checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" [[package]] name = "alloy-chains" -version = "0.2.32" +version = "0.2.33" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9247f0a399ef71aeb68f497b2b8fb348014f742b50d3b83b1e00dfe1b7d64b3d" +checksum = "f4e9e31d834fe25fe991b8884e4b9f0e59db4a97d86e05d1464d6899c013cd62" dependencies = [ "alloy-primitives", "num_enum", @@ -118,9 +118,9 @@ dependencies = [ [[package]] name = "alloy-consensus" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b0c0dc44157867da82c469c13186015b86abef209bf0e41625e4b68bac61d728" +checksum = "1e56cae3909bcb2347f77c0f318ef5eb7e131ea6d0a94d31f8bfb6e4c5e3c7c7" dependencies = [ "alloy-eips", "alloy-primitives", @@ -145,9 +145,9 @@ dependencies = [ [[package]] name = "alloy-consensus-any" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba4cdb42df3871cd6b346d6a938ec2ba69a9a0f49d1f82714bc5c48349268434" +checksum = "f4394690a8a64757316c57c57f2c663bf8395febb4c4baa049a058ebd122b668" dependencies = [ "alloy-consensus", "alloy-eips", @@ -229,9 +229,9 @@ dependencies = [ [[package]] name = "alloy-eips" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b9f7ef09f21bd1e9cb8a686f168cb4a206646804567f0889eadb8dcc4c9288c8" +checksum = "7b97433ffdb356d11b6c89b08c69a787b9f55d787cdeee733c12fdf85d465ef1" dependencies = [ "alloy-eip2124", "alloy-eip2930", @@ -250,7 +250,6 @@ dependencies = [ "serde", "serde_with", "sha2 0.10.9", - "thiserror 2.0.18", ] [[package]] @@ -301,9 +300,9 @@ dependencies = [ [[package]] name = "alloy-json-rpc" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff42cd777eea61f370c0b10f2648a1c81e0b783066cd7269228aa993afd487f7" +checksum = "ae95062f48461967424eecb1e1ab703e493b6a7aca7f9c327cc1c06758eb6ec2" dependencies = [ "alloy-primitives", "alloy-sol-types", @@ -316,9 +315,9 @@ dependencies = [ [[package]] name = "alloy-network" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8cbca04f9b410fdc51aaaf88433cbac761213905a65fe832058bcf6690585762" +checksum = "464d9c2c5bca3ff3f020f2ab502629043486a1b3645c5c11613c1dade4eb6f5e" dependencies = [ "alloy-consensus", "alloy-consensus-any", @@ -342,9 +341,9 @@ dependencies = [ [[package]] name = "alloy-network-primitives" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42d6d15e069a8b11f56bef2eccbad2a873c6dd4d4c81d04dda29710f5ea52f04" +checksum = "2158d382ef9743ae7185c9fcd33cd9a99967419fdcd5eebc83ff7c0e79cad2bc" dependencies = [ "alloy-consensus", "alloy-eips", @@ -385,9 +384,9 @@ dependencies = [ [[package]] name = "alloy-provider" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d181c8cc7cf4805d7e589bf4074d56d55064fa1a979f005a45a62b047616d870" +checksum = "09b08405e82effb4985f7cbe83d5067730e79893c8699793c1e113043ffeac9d" dependencies = [ "alloy-chains", "alloy-consensus", @@ -421,9 +420,9 @@ dependencies = [ [[package]] name = "alloy-pubsub" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8bd82953194dec221aa4cbbbb0b1e2df46066fe9d0333ac25b43a311e122d13" +checksum = "9f39b713fb8fd7abb6ee7601d467f71d2c2541b7799dd02d3a8f9f650d1d3f6d" dependencies = [ "alloy-json-rpc", "alloy-primitives", @@ -465,9 +464,9 @@ dependencies = [ [[package]] name = "alloy-rpc-client" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f2792758a93ae32a32e9047c843d536e1448044f78422d71bf7d7c05149e103f" +checksum = "96846729dd095dd5a87bf5bd8efea2345ca41ceab6dda212c49f5c8ca6e2a536" dependencies = [ "alloy-json-rpc", "alloy-primitives", @@ -485,9 +484,9 @@ dependencies = [ [[package]] name = "alloy-rpc-types" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7bdcbf9dfd5eea8bfeb078b1d906da8cd3a39c4d4dbe7a628025648e323611f6" +checksum = "4f20059ff046049aae59f6e19d96462214ad3290cf9920394309dd7ffc284390" dependencies = [ "alloy-primitives", "alloy-rpc-types-engine", @@ -498,9 +497,9 @@ dependencies = [ [[package]] name = "alloy-rpc-types-any" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd720b63f82b457610f2eaaf1f32edf44efffe03ae25d537632e7d23e7929e1a" +checksum = "89b71da7e5cdd0d5ffebc459f5987888fd3380969c2f94f8cb652ad91ae51bba" dependencies = [ "alloy-consensus-any", "alloy-rpc-types-eth", @@ -509,9 +508,9 @@ dependencies = [ [[package]] name = "alloy-rpc-types-engine" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e4ac61f03f1edabccde1c687b5b25fff28f183afee64eaa2e767def3929e4457" +checksum = "f083328dbf7aa5abfe5c0a7758ec9acc86a45bfbcfb45c54186c6caa78036f2a" dependencies = [ "alloy-consensus", "alloy-eips", @@ -529,9 +528,9 @@ dependencies = [ [[package]] name = "alloy-rpc-types-eth" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b2dc411f13092f237d2bf6918caf80977fc2f51485f9b90cb2a2f956912c8c9" +checksum = "1641df7ef4d15cd43843d399252c90a95abf465a67e2a2b2fd76f4e93cc60e15" dependencies = [ "alloy-consensus", "alloy-consensus-any", @@ -541,7 +540,7 @@ dependencies = [ "alloy-rlp", "alloy-serde", "alloy-sol-types", - "itertools 0.13.0", + "itertools 0.14.0", "serde", "serde_json", "serde_with", @@ -550,9 +549,9 @@ dependencies = [ [[package]] name = "alloy-serde" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2ce1e0dbf7720eee747700e300c99aac01b1a95bb93f493a01e78ee28bb1a37" +checksum = "8f1c2c0b5f024814f1c04ae76ff71862d06c836e7d67102daf8a557e5056be68" dependencies = [ "alloy-primitives", "serde", @@ -561,9 +560,9 @@ dependencies = [ [[package]] name = "alloy-signer" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2425c6f314522c78e8198979c8cbf6769362be4da381d4152ea8eefce383535d" +checksum = "e0f59de30d9d3b13ce6a1b90e85270dc086e4e4733aaa12b250fb30e1eb35849" dependencies = [ "alloy-primitives", "async-trait", @@ -646,9 +645,9 @@ dependencies = [ [[package]] name = "alloy-transport" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fa186e560d523d196580c48bf00f1bf62e63041f28ecf276acc22f8b27bb9f53" +checksum = "ec9c680a7ee0879aa27ea2e347f14e3a973a262e4325964fa1ab062b8a796064" dependencies = [ "alloy-json-rpc", "auto_impl", @@ -669,14 +668,14 @@ dependencies = [ [[package]] name = "alloy-transport-http" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa501ad58dd20acddbfebc65b52e60f05ebf97c52fa40d1b35e91f5e2da0ad0e" +checksum = "ae9abaedb9123ebe4b1527bc88a0409d65b2727c3de89a289284ba91ad70ae99" dependencies = [ "alloy-json-rpc", "alloy-transport", - "itertools 0.13.0", - "reqwest 0.12.28", + "itertools 0.14.0", + "reqwest 0.13.2", "serde_json", "tower", "tracing", @@ -685,9 +684,9 @@ dependencies = [ [[package]] name = "alloy-transport-ipc" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2ef85688e5ac2da72afc804e0a1f153a1f309f05a864b1998bbbed7804dbaab" +checksum = "1c74911eda4fd7ef12f446b1661f11787f9fb31bde4ab4a0a68efcac9b98cfdf" dependencies = [ "alloy-json-rpc", "alloy-pubsub", @@ -705,18 +704,20 @@ dependencies = [ [[package]] name = "alloy-transport-ws" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b9f00445db69d63298e2b00a0ea1d859f00e6424a3144ffc5eba9c31da995e16" +checksum = "130762ef3e6c0fb7dc1b855d4f359eb8ea6f2df2f800f40aa52d27737bf640f1" dependencies = [ "alloy-pubsub", "alloy-transport", "futures", "http 1.4.0", + "rustls", "serde_json", "tokio", "tokio-tungstenite", "tracing", + "url", "ws_stream_wasm", ] @@ -738,11 +739,11 @@ dependencies = [ [[package]] name = "alloy-tx-macros" -version = "1.7.3" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6fa0c53e8c1e1ef4d01066b01c737fb62fc9397ab52c6e7bb5669f97d281b9bc" +checksum = "1a3684226a2220bb6e84a5ab74877e66628882336ecfba97482c9d473aa2b1cc" dependencies = [ - "darling 0.21.3", + "darling 0.23.0", "proc-macro2", "quote", "syn 2.0.117", @@ -1369,8 +1370,8 @@ dependencies = [ "aws-runtime", "aws-sdk-sts", "aws-smithy-async", - "aws-smithy-http", - "aws-smithy-json", + "aws-smithy-http 0.62.6", + "aws-smithy-json 0.61.9", "aws-smithy-runtime", "aws-smithy-runtime-api", "aws-smithy-types", @@ -1386,9 +1387,9 @@ dependencies = [ [[package]] name = "aws-credential-types" -version = "1.2.11" +version = "1.2.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3cd362783681b15d136480ad555a099e82ecd8e2d10a841e14dfd0078d67fee3" +checksum = "8f20799b373a1be121fe3005fba0c2090af9411573878f224df44b42727fcaf7" dependencies = [ "aws-smithy-async", "aws-smithy-runtime-api", @@ -1420,23 +1421,26 @@ dependencies = [ [[package]] name = "aws-runtime" -version = "1.5.17" +version = "1.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d81b5b2898f6798ad58f484856768bca817e3cd9de0974c24ae0f1113fe88f1b" +checksum = "5fc0651c57e384202e47153c1260b84a9936e19803d747615edf199dc3b98d17" dependencies = [ "aws-credential-types", "aws-sigv4", "aws-smithy-async", "aws-smithy-eventstream", - "aws-smithy-http", + "aws-smithy-http 0.63.6", "aws-smithy-runtime", "aws-smithy-runtime-api", "aws-smithy-types", "aws-types", "bytes", + "bytes-utils", "fastrand", "http 0.2.12", + "http 1.4.0", "http-body 0.4.6", + "http-body 1.0.1", "percent-encoding", "pin-project-lite", "tracing", @@ -1455,8 +1459,8 @@ dependencies = [ "aws-smithy-async", "aws-smithy-checksums", "aws-smithy-eventstream", - "aws-smithy-http", - "aws-smithy-json", + "aws-smithy-http 0.62.6", + "aws-smithy-json 0.61.9", "aws-smithy-runtime", "aws-smithy-runtime-api", "aws-smithy-types", @@ -1479,15 +1483,16 @@ dependencies = [ [[package]] name = "aws-sdk-sts" -version = "1.95.0" +version = "1.101.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "55542378e419558e6b1f398ca70adb0b2088077e79ad9f14eb09441f2f7b2164" +checksum = "ab41ad64e4051ecabeea802d6a17845a91e83287e1dd249e6963ea1ba78c428a" dependencies = [ "aws-credential-types", "aws-runtime", "aws-smithy-async", - "aws-smithy-http", - "aws-smithy-json", + "aws-smithy-http 0.63.6", + "aws-smithy-json 0.62.5", + "aws-smithy-observability", "aws-smithy-query", "aws-smithy-runtime", "aws-smithy-runtime-api", @@ -1496,19 +1501,20 @@ dependencies = [ "aws-types", "fastrand", "http 0.2.12", + "http 1.4.0", "regex-lite", "tracing", ] [[package]] name = "aws-sigv4" -version = "1.3.7" +version = "1.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "69e523e1c4e8e7e8ff219d732988e22bfeae8a1cafdbe6d9eca1546fa080be7c" +checksum = "b0b660013a6683ab23797778e21f1f854744fdf05f68204b4cca4c8c04b5d1f4" dependencies = [ "aws-credential-types", "aws-smithy-eventstream", - "aws-smithy-http", + "aws-smithy-http 0.63.6", "aws-smithy-runtime-api", "aws-smithy-types", "bytes", @@ -1530,9 +1536,9 @@ dependencies = [ [[package]] name = "aws-smithy-async" -version = "1.2.7" +version = "1.2.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ee19095c7c4dda59f1697d028ce704c24b2d33c6718790c7f1d5a3015b4107c" +checksum = "2ffcaf626bdda484571968400c326a244598634dc75fd451325a54ad1a59acfc" dependencies = [ "futures-util", "pin-project-lite", @@ -1541,11 +1547,11 @@ dependencies = [ [[package]] name = "aws-smithy-checksums" -version = "0.63.12" +version = "0.63.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87294a084b43d649d967efe58aa1f9e0adc260e13a6938eb904c0ae9b45824ae" +checksum = "23374b9170cbbcc6f5df8dc5ebb9b6c5c28a3c8f599f0e8b8b10eb6f4a5c6e74" dependencies = [ - "aws-smithy-http", + "aws-smithy-http 0.62.6", "aws-smithy-types", "bytes", "crc-fast", @@ -1561,9 +1567,9 @@ dependencies = [ [[package]] name = "aws-smithy-eventstream" -version = "0.60.14" +version = "0.60.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc12f8b310e38cad85cf3bef45ad236f470717393c613266ce0a89512286b650" +checksum = "faf09d74e5e32f76b8762da505a3cd59303e367a664ca67295387baa8c1d7548" dependencies = [ "aws-smithy-types", "bytes", @@ -1592,11 +1598,32 @@ dependencies = [ "tracing", ] +[[package]] +name = "aws-smithy-http" +version = "0.63.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba1ab2dc1c2c3749ead27180d333c42f11be8b0e934058fb4b2258ee8dbe5231" +dependencies = [ + "aws-smithy-runtime-api", + "aws-smithy-types", + "bytes", + "bytes-utils", + "futures-core", + "futures-util", + "http 1.4.0", + "http-body 1.0.1", + "http-body-util", + "percent-encoding", + "pin-project-lite", + "pin-utils", + "tracing", +] + [[package]] name = "aws-smithy-http-client" -version = "1.1.5" +version = "1.1.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59e62db736db19c488966c8d787f52e6270be565727236fd5579eaa301e7bc4a" +checksum = "6a2f165a7feee6f263028b899d0a181987f4fa7179a6411a32a439fba7c5f769" dependencies = [ "aws-smithy-async", "aws-smithy-runtime-api", @@ -1625,20 +1652,29 @@ dependencies = [ "aws-smithy-types", ] +[[package]] +name = "aws-smithy-json" +version = "0.62.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9648b0bb82a2eedd844052c6ad2a1a822d1f8e3adee5fbf668366717e428856a" +dependencies = [ + "aws-smithy-types", +] + [[package]] name = "aws-smithy-observability" -version = "0.1.5" +version = "0.2.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "17f616c3f2260612fe44cede278bafa18e73e6479c4e393e2c4518cf2a9a228a" +checksum = "a06c2315d173edbf1920da8ba3a7189695827002e4c0fc961973ab1c54abca9c" dependencies = [ "aws-smithy-runtime-api", ] [[package]] name = "aws-smithy-query" -version = "0.60.9" +version = "0.60.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae5d689cf437eae90460e944a58b5668530d433b4ff85789e69d2f2a556e057d" +checksum = "1a56d79744fb3edb5d722ef79d86081e121d3b9422cb209eb03aea6aa4f21ebd" dependencies = [ "aws-smithy-types", "urlencoding", @@ -1646,12 +1682,12 @@ dependencies = [ [[package]] name = "aws-smithy-runtime" -version = "1.9.5" +version = "1.10.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a392db6c583ea4a912538afb86b7be7c5d8887d91604f50eb55c262ee1b4a5f5" +checksum = "028999056d2d2fd58a697232f9eec4a643cf73a71cf327690a7edad1d2af2110" dependencies = [ "aws-smithy-async", - "aws-smithy-http", + "aws-smithy-http 0.63.6", "aws-smithy-http-client", "aws-smithy-observability", "aws-smithy-runtime-api", @@ -1662,6 +1698,7 @@ dependencies = [ "http 1.4.0", "http-body 0.4.6", "http-body 1.0.1", + "http-body-util", "pin-project-lite", "pin-utils", "tokio", @@ -1670,9 +1707,9 @@ dependencies = [ [[package]] name = "aws-smithy-runtime-api" -version = "1.9.3" +version = "1.11.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab0d43d899f9e508300e587bf582ba54c27a452dd0a9ea294690669138ae14a2" +checksum = "876ab3c9c29791ba4ba02b780a3049e21ec63dabda09268b175272c3733a79e6" dependencies = [ "aws-smithy-async", "aws-smithy-types", @@ -1687,9 +1724,9 @@ dependencies = [ [[package]] name = "aws-smithy-types" -version = "1.3.5" +version = "1.4.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "905cb13a9895626d49cf2ced759b062d913834c7482c38e49557eac4e6193f01" +checksum = "9d73dbfbaa8e4bc57b9045137680b958d274823509a360abfd8e1d514d40c95c" dependencies = [ "base64-simd", "bytes", @@ -1713,18 +1750,18 @@ dependencies = [ [[package]] name = "aws-smithy-xml" -version = "0.60.13" +version = "0.60.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "11b2f670422ff42bf7065031e72b45bc52a3508bd089f743ea90731ca2b6ea57" +checksum = "0ce02add1aa3677d022f8adf81dcbe3046a95f17a1b1e8979c145cd21d3d22b3" dependencies = [ "xmlparser", ] [[package]] name = "aws-types" -version = "1.3.11" +version = "1.3.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d980627d2dd7bfc32a3c025685a033eeab8d365cc840c631ef59d1b8f428164" +checksum = "47c8323699dd9b3c8d5b3c13051ae9cdef58fd179957c882f8374dd8725962d9" dependencies = [ "aws-credential-types", "aws-smithy-async", @@ -1995,19 +2032,20 @@ dependencies = [ [[package]] name = "borsh" -version = "1.6.0" +version = "1.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d1da5ab77c1437701eeff7c88d968729e7766172279eab0676857b3d63af7a6f" +checksum = "cfd1e3f8955a5d7de9fab72fc8373fade9fb8a703968cb200ae3dc6cf08e185a" dependencies = [ "borsh-derive", + "bytes", "cfg_aliases", ] [[package]] name = "borsh-derive" -version = "1.6.0" +version = "1.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0686c856aa6aac0c4498f936d7d6a02df690f614c03e4d906d1018062b5c5e2c" +checksum = "bfcfdc083699101d5a7965e49925975f2f55060f94f9a05e7187be95d530ca59" dependencies = [ "once_cell", "proc-macro-crate 3.5.0", @@ -2278,9 +2316,9 @@ checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9" [[package]] name = "cmake" -version = "0.1.57" +version = "0.1.58" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75443c44cd6b379beb8c5b45d85d0773baf31cce901fe7bb252f4eff3008ef7d" +checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678" dependencies = [ "cc", ] @@ -2365,7 +2403,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c" dependencies = [ "lazy_static", - "windows-sys 0.52.0", + "windows-sys 0.59.0", ] [[package]] @@ -2539,15 +2577,14 @@ checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5" [[package]] name = "crc-fast" -version = "1.6.0" +version = "1.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ddc2d09feefeee8bd78101665bd8645637828fa9317f9f292496dbbd8c65ff3" +checksum = "2fd92aca2c6001b1bf5ba0ff84ee74ec8501b52bbef0cac80bf25a6c1d87a83d" dependencies = [ "crc", "digest 0.10.7", - "rand 0.9.2", - "regex", "rustversion", + "spin 0.10.0", ] [[package]] @@ -2808,7 +2845,6 @@ dependencies = [ "ident_case", "proc-macro2", "quote", - "serde", "strsim", "syn 2.0.117", ] @@ -2822,6 +2858,7 @@ dependencies = [ "ident_case", "proc-macro2", "quote", + "serde", "strsim", "syn 2.0.117", ] @@ -3346,20 +3383,20 @@ dependencies = [ [[package]] name = "env_filter" -version = "1.0.0" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a1c3cc8e57274ec99de65301228b537f1e4eedc1b8e0f9411c6caac8ae7308f" +checksum = "32e90c2accc4b07a8456ea0debdc2e7587bdd890680d71173a15d4ae604f6eef" dependencies = [ "log", ] [[package]] name = "env_logger" -version = "0.11.9" +version = "0.11.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2daee4ea451f429a58296525ddf28b45a3b64f1acf6587e2067437bb11e218d" +checksum = "0621c04f2196ac3f488dd583365b9c09be011a4ab8b9f37248ffcc8f6198b56a" dependencies = [ - "anstream 0.6.21", + "anstream 1.0.0", "anstyle", "env_filter", "log", @@ -3389,7 +3426,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" dependencies = [ "libc", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -3735,7 +3772,7 @@ dependencies = [ "dyn-clone", "foundry-compilers-artifacts", "foundry-compilers-core", - "itertools 0.13.0", + "itertools 0.14.0", "path-slash", "rayon", "semver 1.0.27", @@ -3998,9 +4035,9 @@ dependencies = [ [[package]] name = "generic-array" -version = "0.14.7" +version = "0.14.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2" dependencies = [ "typenum", "version_check", @@ -4871,7 +4908,7 @@ checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46" dependencies = [ "hermit-abi", "libc", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -4918,9 +4955,9 @@ dependencies = [ [[package]] name = "itoa" -version = "1.0.17" +version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" [[package]] name = "jiff" @@ -5062,8 +5099,8 @@ dependencies = [ "openvm-ecc-sw-macros", "openvm-ecc-transpiler", "openvm-rv32im-transpiler", - "openvm-sha256-circuit", - "openvm-sha256-transpiler", + "openvm-sha2-circuit", + "openvm-sha2-transpiler", "openvm-stark-backend", "openvm-stark-sdk", "openvm-toolchain-tests", @@ -5177,9 +5214,9 @@ dependencies = [ [[package]] name = "libredox" -version = "0.1.14" +version = "0.1.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1744e39d1d6a9948f4f388969627434e31128196de472883b39f148769bfe30a" +checksum = "7ddbf48fd451246b1f8c2610bd3b4ac0cc6e149d89832867093ab69a17194f08" dependencies = [ "libc", ] @@ -5334,6 +5371,16 @@ dependencies = [ "regex-automata", ] +[[package]] +name = "matrixmultiply" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06de3016e9fae57a36fd14dba131fccf49f74b40b7fbdb472f96e361ec71a08" +dependencies = [ + "autocfg", + "rawpointer", +] + [[package]] name = "maybe-rayon" version = "0.1.1" @@ -5487,6 +5534,21 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "ndarray" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "882ed72dce9365842bf196bdeedf5055305f11fc8c03dee7bb0194a6cad34841" +dependencies = [ + "matrixmultiply", + "num-complex", + "num-integer", + "num-traits", + "portable-atomic", + "portable-atomic-util", + "rawpointer", +] + [[package]] name = "nibble_vec" version = "0.1.0" @@ -5571,9 +5633,9 @@ dependencies = [ [[package]] name = "num-conv" -version = "0.2.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050" +checksum = "c6673768db2d862beb9b39a78fdcb1a69439615d5794a1be50caa9bc92c81967" [[package]] name = "num-format" @@ -6040,6 +6102,7 @@ dependencies = [ "openvm-bigint-circuit", "openvm-bigint-transpiler", "openvm-circuit", + "openvm-continuations", "openvm-ecc-circuit", "openvm-ecc-transpiler", "openvm-keccak256-circuit", @@ -6049,8 +6112,9 @@ dependencies = [ "openvm-pairing-transpiler", "openvm-rv32im-circuit", "openvm-rv32im-transpiler", - "openvm-sha256-circuit", - "openvm-sha256-transpiler", + "openvm-sdk", + "openvm-sha2-circuit", + "openvm-sha2-transpiler", "openvm-stark-sdk", "openvm-transpiler", "rand 0.9.2", @@ -6238,6 +6302,8 @@ name = "openvm-circuit-primitives-derive" version = "2.0.0-alpha" dependencies = [ "itertools 0.14.0", + "ndarray", + "proc-macro2", "quote", "syn 2.0.117", ] @@ -7052,8 +7118,8 @@ dependencies = [ "openvm-pairing-transpiler", "openvm-rv32im-circuit", "openvm-rv32im-transpiler", - "openvm-sha256-circuit", - "openvm-sha256-transpiler", + "openvm-sha2-circuit", + "openvm-sha2-transpiler", "openvm-stark-backend", "openvm-stark-sdk", "openvm-transpiler", @@ -7066,12 +7132,13 @@ name = "openvm-sha2" version = "2.0.0-alpha" dependencies = [ "eyre", + "openvm", "openvm-circuit", "openvm-instructions", "openvm-rv32im-transpiler", - "openvm-sha256-circuit", - "openvm-sha256-guest", - "openvm-sha256-transpiler", + "openvm-sha2-circuit", + "openvm-sha2-guest", + "openvm-sha2-transpiler", "openvm-stark-sdk", "openvm-toolchain-tests", "openvm-transpiler", @@ -7079,59 +7146,61 @@ dependencies = [ ] [[package]] -name = "openvm-sha256-air" +name = "openvm-sha2-air" version = "2.0.0-alpha" dependencies = [ - "openvm-circuit", + "ndarray", + "num_enum", "openvm-circuit-primitives", - "openvm-cpu-backend", + "openvm-circuit-primitives-derive", "openvm-stark-backend", - "openvm-stark-sdk", "rand 0.9.2", "sha2 0.10.9", ] [[package]] -name = "openvm-sha256-circuit" +name = "openvm-sha2-circuit" version = "2.0.0-alpha" dependencies = [ "cfg-if", "derive-new 0.6.0", "derive_more 1.0.0", "hex", + "itertools 0.14.0", + "ndarray", "openvm-circuit", "openvm-circuit-derive", "openvm-circuit-primitives", + "openvm-circuit-primitives-derive", "openvm-cpu-backend", "openvm-cuda-backend", "openvm-cuda-builder", "openvm-cuda-common", "openvm-instructions", "openvm-rv32im-circuit", - "openvm-sha256-air", - "openvm-sha256-transpiler", + "openvm-sha2-air", + "openvm-sha2-transpiler", "openvm-stark-backend", "openvm-stark-sdk", "rand 0.9.2", "serde", "sha2 0.10.9", - "strum 0.26.3", ] [[package]] -name = "openvm-sha256-guest" +name = "openvm-sha2-guest" version = "2.0.0-alpha" dependencies = [ "openvm-platform", ] [[package]] -name = "openvm-sha256-transpiler" +name = "openvm-sha2-transpiler" version = "2.0.0-alpha" dependencies = [ "openvm-instructions", "openvm-instructions-derive", - "openvm-sha256-guest", + "openvm-sha2-guest", "openvm-stark-backend", "openvm-transpiler", "rrs-lib", @@ -7380,8 +7449,8 @@ dependencies = [ "openvm-ecc-sw-macros", "openvm-ecc-transpiler", "openvm-rv32im-transpiler", - "openvm-sha256-circuit", - "openvm-sha256-transpiler", + "openvm-sha2-circuit", + "openvm-sha2-transpiler", "openvm-stark-backend", "openvm-stark-sdk", "openvm-toolchain-tests", @@ -8139,7 +8208,7 @@ version = "3.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f" dependencies = [ - "toml_edit 0.25.4+spec-1.1.0", + "toml_edit 0.25.8+spec-1.1.0", ] [[package]] @@ -8188,9 +8257,9 @@ dependencies = [ [[package]] name = "proptest" -version = "1.10.0" +version = "1.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37566cb3fdacef14c0737f9546df7cfeadbfbc9fef10991038bf5015d0c80532" +checksum = "4b45fcc2344c680f5025fe57779faef368840d0bd1f42f216291f0dc4ace4744" dependencies = [ "bit-set", "bit-vec", @@ -8342,7 +8411,7 @@ dependencies = [ "once_cell", "socket2", "tracing", - "windows-sys 0.52.0", + "windows-sys 0.60.2", ] [[package]] @@ -8497,6 +8566,12 @@ dependencies = [ "bitflags", ] +[[package]] +name = "rawpointer" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3" + [[package]] name = "rayon" version = "1.11.0" @@ -9325,7 +9400,7 @@ dependencies = [ "errno", "libc", "linux-raw-sys", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -9383,7 +9458,7 @@ dependencies = [ "security-framework", "security-framework-sys", "webpki-root-certs", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -9843,6 +9918,16 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" +[[package]] +name = "signal-hook-registry" +version = "1.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b" +dependencies = [ + "errno", + "libc", +] + [[package]] name = "signature" version = "1.6.4" @@ -10045,7 +10130,7 @@ dependencies = [ "derive_more 2.1.1", "dunce", "inturn", - "itertools 0.11.0", + "itertools 0.14.0", "itoa", "normalize-path", "once_map", @@ -10081,7 +10166,7 @@ dependencies = [ "alloy-primitives", "bitflags", "bumpalo", - "itertools 0.11.0", + "itertools 0.14.0", "memchr", "num-bigint 0.4.6", "num-rational", @@ -10540,7 +10625,7 @@ dependencies = [ "getrandom 0.4.2", "once_cell", "rustix", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -10773,6 +10858,7 @@ dependencies = [ "libc", "mio", "pin-project-lite", + "signal-hook-registry", "socket2", "tokio-macros", "windows-sys 0.61.2", @@ -10839,9 +10925,9 @@ dependencies = [ [[package]] name = "tokio-tungstenite" -version = "0.26.2" +version = "0.28.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a9daff607c6d2bf6c16fd681ccb7eecc83e4e2cdc1ca067ffaadfca5de7f084" +checksum = "d25a406cddcc431a75d3d9afc6a7c0f7428d4891dd973e4d54c56b46127bf857" dependencies = [ "futures-util", "log", @@ -10913,9 +10999,9 @@ dependencies = [ [[package]] name = "toml_datetime" -version = "1.0.0+spec-1.1.0" +version = "1.1.0+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32c2555c699578a4f59f0cc68e5116c8d7cabbd45e1409b989d4be085b53f13e" +checksum = "97251a7c317e03ad83774a8752a7e81fb6067740609f75ea2b585b569a59198f" dependencies = [ "serde_core", ] @@ -10962,23 +11048,23 @@ dependencies = [ [[package]] name = "toml_edit" -version = "0.25.4+spec-1.1.0" +version = "0.25.8+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7193cbd0ce53dc966037f54351dbbcf0d5a642c7f0038c382ef9e677ce8c13f2" +checksum = "16bff38f1d86c47f9ff0647e6838d7bb362522bdf44006c7068c2b1e606f1f3c" dependencies = [ "indexmap 2.13.0", - "toml_datetime 1.0.0+spec-1.1.0", + "toml_datetime 1.1.0+spec-1.1.0", "toml_parser", - "winnow 0.7.15", + "winnow 1.0.0", ] [[package]] name = "toml_parser" -version = "1.0.9+spec-1.1.0" +version = "1.1.0+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "702d4415e08923e7e1ef96cd5727c0dfed80b4d2fa25db9647fe5eb6f7c5a4c4" +checksum = "2334f11ee363607eb04df9b8fc8a13ca1715a72ba8662a26ac285c98aabb4011" dependencies = [ - "winnow 0.7.15", + "winnow 1.0.0", ] [[package]] @@ -11155,9 +11241,9 @@ checksum = "e78122066b0cb818b8afd08f7ed22f7fdbc3e90815035726f0840d0d26c0747a" [[package]] name = "tungstenite" -version = "0.26.2" +version = "0.28.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4793cb5e56680ecbb1d843515b23b6de9a75eb04b66643e256a396d43be33c13" +checksum = "8628dcc84e5a09eb3d8423d6cb682965dea9133204e8fb3efee74c2a0c259442" dependencies = [ "bytes", "data-encoding", @@ -11264,9 +11350,9 @@ checksum = "7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d" [[package]] name = "unicode-segmentation" -version = "1.12.0" +version = "1.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493" +checksum = "9629274872b2bfaf8d66f5f15725007f635594914870f65218920345aa11aa8c" [[package]] name = "unicode-width" @@ -11707,7 +11793,7 @@ version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" dependencies = [ - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -11804,6 +11890,24 @@ dependencies = [ "windows-targets 0.52.6", ] +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" +dependencies = [ + "windows-targets 0.53.5", +] + [[package]] name = "windows-sys" version = "0.61.2" @@ -11837,13 +11941,30 @@ dependencies = [ "windows_aarch64_gnullvm 0.52.6", "windows_aarch64_msvc 0.52.6", "windows_i686_gnu 0.52.6", - "windows_i686_gnullvm", + "windows_i686_gnullvm 0.52.6", "windows_i686_msvc 0.52.6", "windows_x86_64_gnu 0.52.6", "windows_x86_64_gnullvm 0.52.6", "windows_x86_64_msvc 0.52.6", ] +[[package]] +name = "windows-targets" +version = "0.53.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3" +dependencies = [ + "windows-link", + "windows_aarch64_gnullvm 0.53.1", + "windows_aarch64_msvc 0.53.1", + "windows_i686_gnu 0.53.1", + "windows_i686_gnullvm 0.53.1", + "windows_i686_msvc 0.53.1", + "windows_x86_64_gnu 0.53.1", + "windows_x86_64_gnullvm 0.53.1", + "windows_x86_64_msvc 0.53.1", +] + [[package]] name = "windows_aarch64_gnullvm" version = "0.42.2" @@ -11856,6 +11977,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53" + [[package]] name = "windows_aarch64_msvc" version = "0.42.2" @@ -11868,6 +11995,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" +[[package]] +name = "windows_aarch64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006" + [[package]] name = "windows_i686_gnu" version = "0.42.2" @@ -11880,12 +12013,24 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" +[[package]] +name = "windows_i686_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3" + [[package]] name = "windows_i686_gnullvm" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" +[[package]] +name = "windows_i686_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c" + [[package]] name = "windows_i686_msvc" version = "0.42.2" @@ -11898,6 +12043,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" +[[package]] +name = "windows_i686_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2" + [[package]] name = "windows_x86_64_gnu" version = "0.42.2" @@ -11910,6 +12061,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" +[[package]] +name = "windows_x86_64_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499" + [[package]] name = "windows_x86_64_gnullvm" version = "0.42.2" @@ -11922,6 +12079,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1" + [[package]] name = "windows_x86_64_msvc" version = "0.42.2" @@ -11934,6 +12097,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" +[[package]] +name = "windows_x86_64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" + [[package]] name = "winnow" version = "0.5.40" @@ -11952,6 +12121,15 @@ dependencies = [ "memchr", ] +[[package]] +name = "winnow" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a90e88e4667264a994d34e6d1ab2d26d398dcdca8b7f52bec8668957517fc7d8" +dependencies = [ + "memchr", +] + [[package]] name = "wit-bindgen" version = "0.51.0" @@ -12120,18 +12298,18 @@ dependencies = [ [[package]] name = "zerocopy" -version = "0.8.42" +version = "0.8.47" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f2578b716f8a7a858b7f02d5bd870c14bf4ddbbcf3a4c05414ba6503640505e3" +checksum = "efbb2a062be311f2ba113ce66f697a4dc589f85e78a4aea276200804cea0ed87" dependencies = [ "zerocopy-derive", ] [[package]] name = "zerocopy-derive" -version = "0.8.42" +version = "0.8.47" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7e6cc098ea4d3bd6246687de65af3f920c430e236bee1e3bf2e441463f08a02f" +checksum = "0e8bc7269b54418e7aeeef514aa68f8690b8c0489a06b0136e5f57c4c5ccab89" dependencies = [ "proc-macro2", "quote", diff --git a/Cargo.toml b/Cargo.toml index 3fe04ffb68..172c64e0c5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -53,9 +53,9 @@ members = [ "extensions/keccak256/circuit", "extensions/keccak256/transpiler", "extensions/keccak256/guest", - "extensions/sha256/circuit", - "extensions/sha256/transpiler", - "extensions/sha256/guest", + "extensions/sha2/circuit", + "extensions/sha2/transpiler", + "extensions/sha2/guest", "extensions/ecc/circuit", "extensions/ecc/transpiler", "extensions/ecc/guest", @@ -128,7 +128,7 @@ openvm-cuda-common = { git = "https://github.com/openvm-org/stark-backend.git", # OpenVM openvm-mod-circuit-builder = { path = "crates/circuits/mod-builder", default-features = false } openvm-poseidon2-air = { path = "crates/circuits/poseidon2-air", default-features = false } -openvm-sha256-air = { path = "crates/circuits/sha256-air", default-features = false } +openvm-sha2-air = { path = "crates/circuits/sha2-air", default-features = false } openvm-circuit-primitives = { path = "crates/circuits/primitives", default-features = false } openvm-circuit-primitives-derive = { path = "crates/circuits/primitives/derive", default-features = false } openvm = { path = "crates/toolchain/openvm", default-features = false } @@ -159,9 +159,9 @@ openvm-rv32-adapters = { path = "extensions/rv32-adapters", default-features = f openvm-keccak256-circuit = { path = "extensions/keccak256/circuit", default-features = false } openvm-keccak256-transpiler = { path = "extensions/keccak256/transpiler", default-features = false } openvm-keccak256-guest = { path = "extensions/keccak256/guest", default-features = false } -openvm-sha256-circuit = { path = "extensions/sha256/circuit", default-features = false } -openvm-sha256-transpiler = { path = "extensions/sha256/transpiler", default-features = false } -openvm-sha256-guest = { path = "extensions/sha256/guest", default-features = false } +openvm-sha2-circuit = { path = "extensions/sha2/circuit", default-features = false } +openvm-sha2-transpiler = { path = "extensions/sha2/transpiler", default-features = false } +openvm-sha2-guest = { path = "extensions/sha2/guest", default-features = false } openvm-bigint-circuit = { path = "extensions/bigint/circuit", default-features = false } openvm-bigint-transpiler = { path = "extensions/bigint/transpiler", default-features = false } openvm-bigint-guest = { path = "extensions/bigint/guest", default-features = false } @@ -249,6 +249,8 @@ abi_stable = "0.11.3" bytesize = "2.0" zstd = { version = "0.13", default-features = false } inferno = { version = "0.12", default-features = false } +ndarray = { version = "0.16.1", default-features = false } +num_enum = { version = "0.7.4", default-features = false } # default-features = false for no_std for use in guest programs itertools = { version = "0.14.0", default-features = false } diff --git a/benchmarks/execute/Cargo.toml b/benchmarks/execute/Cargo.toml index 9db471fc16..a5a812c34e 100644 --- a/benchmarks/execute/Cargo.toml +++ b/benchmarks/execute/Cargo.toml @@ -25,8 +25,10 @@ openvm-keccak256-circuit.workspace = true openvm-keccak256-transpiler.workspace = true openvm-rv32im-circuit.workspace = true openvm-rv32im-transpiler.workspace = true -openvm-sha256-circuit.workspace = true -openvm-sha256-transpiler.workspace = true +openvm-sha2-circuit.workspace = true +openvm-sha2-transpiler.workspace = true +openvm-continuations = { workspace = true } +openvm-sdk = { workspace = true } clap.workspace = true eyre.workspace = true @@ -51,7 +53,7 @@ tco = [ "openvm-keccak256-circuit/tco", "openvm-pairing-circuit/tco", "openvm-rv32im-circuit/tco", - "openvm-sha256-circuit/tco", + "openvm-sha2-circuit/tco", ] aot = [ "openvm-circuit/aot", @@ -61,7 +63,7 @@ aot = [ "openvm-keccak256-circuit/aot", "openvm-pairing-circuit/aot", "openvm-rv32im-circuit/aot", - "openvm-sha256-circuit/aot", + "openvm-sha2-circuit/aot", ] mimalloc = ["openvm-circuit/mimalloc"] jemalloc = ["openvm-circuit/jemalloc"] diff --git a/benchmarks/execute/benches/execute.rs b/benchmarks/execute/benches/execute.rs index 6b52cbb99f..a43060e174 100644 --- a/benchmarks/execute/benches/execute.rs +++ b/benchmarks/execute/benches/execute.rs @@ -39,8 +39,12 @@ use openvm_rv32im_circuit::{ use openvm_rv32im_transpiler::{ Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension, }; -use openvm_sha256_circuit::{Sha256, Sha256Executor, Sha2CpuProverExt}; -use openvm_sha256_transpiler::Sha256TranspilerExtension; +use openvm_sdk::{ + commit::VmCommittedExe, + config::{AggregationConfig, DEFAULT_NUM_CHILDREN_INTERNAL, DEFAULT_NUM_CHILDREN_LEAF}, +}; +use openvm_sha2_circuit::{Sha2, Sha2CpuProverExt, Sha2Executor}; +use openvm_sha2_transpiler::Sha2TranspilerExtension; use openvm_stark_sdk::{ config::baby_bear_poseidon2::BabyBearPoseidon2CpuEngine, openvm_cpu_backend::{CpuBackend, CpuDevice}, @@ -127,7 +131,7 @@ pub struct ExecuteConfig { #[extension] pub keccak: Keccak256, #[extension] - pub sha256: Sha256, + pub sha2: Sha2, #[extension] pub modular: ModularExtension, #[extension] @@ -148,7 +152,7 @@ impl Default for ExecuteConfig { io: Rv32Io, bigint: Int256::default(), keccak: Keccak256, - sha256: Sha256, + sha2: Sha2, modular: ModularExtension::new(vec![ bn_config.modulus.clone(), bn_config.scalar.clone(), @@ -209,7 +213,7 @@ where &config.keccak, inventory, )?; - VmProverExtension::::extend_prover(&Sha2CpuProverExt, &config.sha256, inventory)?; + VmProverExtension::::extend_prover(&Sha2CpuProverExt, &config.sha2, inventory)?; VmProverExtension::::extend_prover( &AlgebraCpuProverExt, &config.modular, @@ -237,7 +241,7 @@ fn create_default_transpiler() -> Transpiler { .with_extension(Rv32MTranspilerExtension) .with_extension(Int256TranspilerExtension) .with_extension(Keccak256TranspilerExtension) - .with_extension(Sha256TranspilerExtension) + .with_extension(Sha2TranspilerExtension) .with_extension(ModularTranspilerExtension) .with_extension(Fp2TranspilerExtension) .with_extension(EccTranspilerExtension) diff --git a/benchmarks/guest/kitchen-sink/openvm.toml b/benchmarks/guest/kitchen-sink/openvm.toml index 7f70a95cea..cf257e95af 100644 --- a/benchmarks/guest/kitchen-sink/openvm.toml +++ b/benchmarks/guest/kitchen-sink/openvm.toml @@ -2,7 +2,7 @@ [app_vm_config.rv32m] [app_vm_config.io] [app_vm_config.keccak] -[app_vm_config.sha256] +[app_vm_config.sha2] [app_vm_config.bigint] [app_vm_config.modular] diff --git a/benchmarks/guest/sha256/openvm.toml b/benchmarks/guest/sha256/openvm.toml index 656bf52414..35f92b7195 100644 --- a/benchmarks/guest/sha256/openvm.toml +++ b/benchmarks/guest/sha256/openvm.toml @@ -1,4 +1,4 @@ [app_vm_config.rv32i] [app_vm_config.rv32m] [app_vm_config.io] -[app_vm_config.sha256] +[app_vm_config.sha2] diff --git a/benchmarks/guest/sha256/src/main.rs b/benchmarks/guest/sha256/src/main.rs index fc0b3fab78..7f7067fd79 100644 --- a/benchmarks/guest/sha256/src/main.rs +++ b/benchmarks/guest/sha256/src/main.rs @@ -1,7 +1,7 @@ use core::hint::black_box; -use openvm as _; -use openvm_sha2::sha256; +use openvm as _; +use openvm_sha2::Sha256; const INPUT_LENGTH_BYTES: usize = 384 * 1024; @@ -16,5 +16,7 @@ pub fn main() { } // Prevent optimizer from optimizing away the computation - black_box(sha256(&black_box(input))); + let sha256 = Sha256::new(); + sha256.update(black_box(&input)); + black_box(sha256.finalize()); } diff --git a/benchmarks/guest/sha256_iter/openvm.toml b/benchmarks/guest/sha256_iter/openvm.toml index 656bf52414..35f92b7195 100644 --- a/benchmarks/guest/sha256_iter/openvm.toml +++ b/benchmarks/guest/sha256_iter/openvm.toml @@ -1,4 +1,4 @@ [app_vm_config.rv32i] [app_vm_config.rv32m] [app_vm_config.io] -[app_vm_config.sha256] +[app_vm_config.sha2] diff --git a/benchmarks/guest/sha256_iter/src/main.rs b/benchmarks/guest/sha256_iter/src/main.rs index aea8b723e9..7c71085de2 100644 --- a/benchmarks/guest/sha256_iter/src/main.rs +++ b/benchmarks/guest/sha256_iter/src/main.rs @@ -5,13 +5,19 @@ use openvm_sha2::sha256; const ITERATIONS: usize = 150_000; +fn sha256(input: &[u8]) -> [u8; 32] { + let mut sha256 = Sha256::new(); + sha256.update(black_box(input)); + sha256.finalize() +} + pub fn main() { // Initialize with hash of an empty vector let mut hash = black_box(sha256(&[])); // Iteratively apply sha256 for _ in 0..ITERATIONS { - hash = sha256(&hash); + hash = black_box(sha256(&hash)); } // Prevent optimizer from optimizing away the computation diff --git a/crates/circuits/primitives/derive/Cargo.toml b/crates/circuits/primitives/derive/Cargo.toml index 06d4c00aed..23ec5d559d 100644 --- a/crates/circuits/primitives/derive/Cargo.toml +++ b/crates/circuits/primitives/derive/Cargo.toml @@ -12,6 +12,13 @@ license.workspace = true proc-macro = true [dependencies] -syn = { version = "2.0", features = ["parsing"] } +syn = { version = "2.0", features = ["full", "parsing", "extra-traits"] } quote = "1.0" -itertools = { workspace = true } +itertools = { workspace = true, default-features = true } +proc-macro2 = "1.0" + +[dev-dependencies] +ndarray.workspace = true + +[package.metadata.cargo-shear] +ignored = ["ndarray"] diff --git a/crates/circuits/primitives/derive/src/cols_ref/README.md b/crates/circuits/primitives/derive/src/cols_ref/README.md new file mode 100644 index 0000000000..82812f7b90 --- /dev/null +++ b/crates/circuits/primitives/derive/src/cols_ref/README.md @@ -0,0 +1,113 @@ +# ColsRef macro + +The `ColsRef` procedural macro is used in constraint generation to create column structs that have dynamic sizes. + +Note: this macro was originally created for use in the SHA-2 VM extension, where we reuse the same constraint generation code for three different circuits (SHA-256, SHA-512, and SHA-384). +See the [SHA-2 VM extension](../../../../../../extensions/sha2/circuit/src/sha2_chip/air.rs) for an example of how to use the `ColsRef` macro to reuse constraint generation code over multiple circuits. + +## Overview + +As an illustrative example, consider the following columns struct: +```rust +struct ExampleCols { + arr: [T; N], + sum: T, +} +``` +Let's say we want to constrain `sum` to be the sum of the elements of `arr`, and `N` can be either 5 or 10. +We can define a trait that stores the config parameters. +```rust +pub trait ExampleConfig { + const N: usize; +} +``` +and then implement it for the two different configs. +```rust +pub struct ExampleConfigImplA; +impl ExampleConfig for ExampleConfigImplA { + const N: usize = 5; +} +pub struct ExampleConfigImplB; +impl ExampleConfig for ExampleConfigImplB { + const N: usize = 10; +} +``` +Then we can use the `ColsRef` macro like this +```rust +#[derive(ColsRef)] +#[config(ExampleConfig)] +struct ExampleCols { + arr: [T; N], + sum: T, +} +``` +which will generate a columns struct that uses references to the fields. +```rust +struct ExampleColsRef<'a, T, const N: usize> { + arr: ndarray::ArrayView1<'a, T>, // an n-dimensional view into the input slice (ArrayView2 for 2D arrays, etc.) + sum: &'a T, +} +``` +The `ColsRef` macro will also generate a `from` method that takes a slice of the correct length and returns an instance of the columns struct. +The `from` method is parameterized by a struct that implements the `ExampleConfig` trait, and it uses the associated constants to determine how to split the input slice into the fields of the columns struct. + +So, the constraint generation code can be written as +```rust +impl Air for ExampleAir { + fn eval(&self, builder: &mut AB) { + let main = builder.main(); + let (local, _) = (main.row_slice(0), main.row_slice(1)); + let local_cols = ExampleColsRef::::from::(&local[..C::N + 1]); + let sum = local_cols.arr.iter().sum(); + builder.assert_eq(local_cols.sum, sum); + } +} +``` +Notes: +- the `arr` and `sum` fields of `ExampleColsRef` are references to the elements of the `local` slice. +- the name, `N`, of the const generic parameter must match the name of the associated constant `N` in the `ExampleConfig` trait. + +The `ColsRef` macro also generates a `ExampleColsRefMut` struct that stores mutable references to the fields, for use in trace generation. + +The `ColsRef` macro supports more than just variable-length array fields. +The field types can also be: +- any type that derives `AlignedBorrow` via `#[derive(AlignedBorrow)]` +- any type that derives `ColsRef` via `#[derive(ColsRef)]` +- (possibly nested) arrays of `T` or (possibly nested) arrays of a type that derives `AlignedBorrow` + +Note that we currently do not support arrays of types that derive `ColsRef`. + +## Specification + +Annotating a struct named `ExampleCols` with `#[derive(ColsRef)]` and `#[config(ExampleConfig)]` produces two structs, `ExampleColsRef` and `ExampleColsRefMut`. +- we assume `ExampleCols` has exactly one generic type parameter, typically named `T`, and any number of const generic parameters. Each const generic parameter must have a name that matches an associated constant in the `ExampleConfig` trait + +The fields of `ExampleColsRef` have the same names as the fields of `ExampleCols`, but their types are transformed as follows: +- type `T` becomes `&T` +- type `[T; LEN]` becomes `&ArrayView1` (see [ndarray](https://docs.rs/ndarray/latest/ndarray/index.html)) where `LEN` is an associated constant in `ExampleConfig` + - the `ExampleColsRef::from` method will correctly infer the length of the array from the config +- fields with names that end in `Cols` are assumed to be a columns struct that derives `ColsRef` and are transformed into the appropriate `ColsRef` type recursively + - one restriction is that any nested `ColsRef` type must have the same config as the outer `ColsRef` type +- fields that are annotated with `#[aligned_borrow]` are assumed to derive `AlignedBorrow` and are borrowed from the input slice. The new type is a reference to the `AlignedBorrow` type + - if a field whose name ends in `Cols` is annotated with `#[aligned_borrow]`, then the aligned borrow takes precedence, and the field is not transformed into an `ArrayView` +- nested arrays of `U` become `&ArrayViewX` where `X` is the number of dimensions in the nested array type + - `U` can be either the generic type `T` or a type that derives `AlignedBorrow`. In the latter case, the field must be annotated with `#[aligned_borrow]` + - the `ArrayViewX` type provides a `X`-dimensional view into the row slice + +The fields of `ExampleColsRefMut` are almost the same as the fields of `ExampleColsRef`, but they are mutable references. +- the `ArrayViewMutX` type is used instead of `ArrayViewX` for the array fields. +- fields that derive `ColsRef` are transformed into the appropriate `ColsRefMut` type recursively. + +Each of the `ExampleColsRef` and `ExampleColsRefMut` types has the following methods implemented: +```rust +// Takes a slice of the correct length and returns an instance of the columns struct. +pub const fn from(slice: &[T]) -> Self; +// Returns the number of cells in the struct +pub const fn width() -> usize; +``` +Note that the `width` method on both structs returns the same value. + +Additionally, the `ExampleColsRef` struct has a `from_mut` method that takes a `ExampleColsRefMut` and returns a `ExampleColsRef`. +This may be useful in trace generation to pass a `ExampleColsRefMut` to a function that expects a `ExampleColsRef`. + +See the [tests](../../tests/test_cols_ref.rs) for concrete examples of how the `ColsRef` macro handles each of the supported field types. \ No newline at end of file diff --git a/crates/circuits/primitives/derive/src/cols_ref/mod.rs b/crates/circuits/primitives/derive/src/cols_ref/mod.rs new file mode 100644 index 0000000000..2d3fad11ed --- /dev/null +++ b/crates/circuits/primitives/derive/src/cols_ref/mod.rs @@ -0,0 +1,703 @@ +/* + * The `ColsRef` procedural macro is used in constraint generation to create column structs that + * have dynamic sizes. + * + * Note: this macro was originally created for use in the SHA-2 VM extension, where we reuse the + * same constraint generation code for three different circuits (SHA-256, SHA-512, and SHA-384). + * See the [SHA-2 VM extension](openvm/extensions/sha2/circuit/src/sha2_chip/air.rs) for an + * example of how to use the `ColsRef` macro to reuse constraint generation code over multiple + * circuits. + * + * This macro can also be used in other situations where we want to derive Borrow for &[u8], + * for some complicated struct T. + */ +mod utils; + +use utils::*; + +extern crate proc_macro; + +use itertools::Itertools; +use quote::{format_ident, quote}; +use syn::{parse_quote, DeriveInput}; + +pub fn cols_ref_impl( + derive_input: DeriveInput, + config: proc_macro2::Ident, +) -> proc_macro2::TokenStream { + let DeriveInput { + ident, + generics, + data, + vis, + .. + } = derive_input; + + let generic_types = generics + .params + .iter() + .filter_map(|p| { + if let syn::GenericParam::Type(type_param) = p { + Some(type_param) + } else { + None + } + }) + .collect::>(); + + if generic_types.len() != 1 { + panic!("Struct must have exactly one generic type parameter"); + } + + let generic_type = generic_types[0]; + + let const_generics = generics.const_params().map(|p| &p.ident).collect_vec(); + + match data { + syn::Data::Struct(data_struct) => { + // Process the fields of the struct, transforming the types for use in ColsRef struct + let const_field_infos: Vec = data_struct + .fields + .iter() + .map(|f| get_const_cols_ref_fields(f, generic_type, &const_generics)) + .collect_vec(); + + // The ColsRef struct is named by appending `Ref` to the struct name + let const_cols_ref_name = syn::Ident::new(&format!("{ident}Ref"), ident.span()); + + // the args to the `from` method will be different for the ColsRef and ColsRefMut + // structs + let from_args = quote! { slice: &'a [#generic_type] }; + + // Package all the necessary information to generate the ColsRef struct + let struct_info = StructInfo { + name: const_cols_ref_name, + vis: vis.clone(), + generic_type: generic_type.clone(), + field_infos: const_field_infos, + fields: data_struct.fields.clone(), + from_args, + derive_clone: true, + }; + + // Generate the ColsRef struct + let const_cols_ref_struct = make_struct(struct_info.clone(), &config); + + // Generate the `from_mut` method for the ColsRef struct + let from_mut_impl = make_from_mut(struct_info, &config); + + // Process the fields of the struct, transforming the types for use in ColsRefMut struct + let mut_field_infos: Vec = data_struct + .fields + .iter() + .map(|f| get_mut_cols_ref_fields(f, generic_type, &const_generics)) + .collect_vec(); + + // The ColsRefMut struct is named by appending `RefMut` to the struct name + let mut_cols_ref_name = syn::Ident::new(&format!("{ident}RefMut"), ident.span()); + + // the args to the `from` method will be different for the ColsRef and ColsRefMut + // structs + let from_args = quote! { slice: &'a mut [#generic_type] }; + + // Package all the necessary information to generate the ColsRefMut struct + let struct_info = StructInfo { + name: mut_cols_ref_name, + vis, + generic_type: generic_type.clone(), + field_infos: mut_field_infos, + fields: data_struct.fields, + from_args, + derive_clone: false, + }; + + // Generate the ColsRefMut struct + let mut_cols_ref_struct = make_struct(struct_info, &config); + + quote! { + #const_cols_ref_struct + #from_mut_impl + #mut_cols_ref_struct + } + } + _ => panic!("ColsRef can only be derived for structs"), + } +} + +#[derive(Debug, Clone)] +struct StructInfo { + name: syn::Ident, + vis: syn::Visibility, + generic_type: syn::TypeParam, + field_infos: Vec, + fields: syn::Fields, + from_args: proc_macro2::TokenStream, + derive_clone: bool, +} + +// Generate the ColsRef and ColsRefMut structs, depending on the value of `struct_info` +// This function is meant to reduce code duplication between the code needed to generate the two +// structs Notable differences between the two structs are: +// - the types of the fields +// - ColsRef derives Clone, but ColsRefMut cannot (since it stores mutable references) +// - the `from` method parameter is a reference to a slice for ColsRef and a mutable reference to +// a slice for ColsRefMut +fn make_struct(struct_info: StructInfo, config: &proc_macro2::Ident) -> proc_macro2::TokenStream { + let StructInfo { + name, + vis, + generic_type, + field_infos, + fields, + from_args, + derive_clone, + } = struct_info; + + let field_types = field_infos.iter().map(|f| &f.ty).collect_vec(); + let length_exprs = field_infos.iter().map(|f| &f.length_expr).collect_vec(); + let prepare_subslices = field_infos + .iter() + .map(|f| &f.prepare_subslice) + .collect_vec(); + let initializers = field_infos.iter().map(|f| &f.initializer).collect_vec(); + + let idents = fields.iter().map(|f| &f.ident).collect_vec(); + + let clone_impl = if derive_clone { + quote! { + #[derive(Clone)] + } + } else { + quote! {} + }; + + quote! { + #clone_impl + #[derive(Debug)] + #vis struct #name <'a, #generic_type> { + #( pub #idents: #field_types ),* + } + + impl<'a, #generic_type> #name<'a, #generic_type> { + pub fn from(#from_args) -> Self { + #( #prepare_subslices )* + Self { + #( #idents: #initializers ),* + } + } + + // Returns number of cells in the struct (where each cell has type T). + // This method should only be called if the struct has no primitive types (i.e. for columns structs). + pub const fn width() -> usize { + 0 #( + #length_exprs )* + } + } + } +} + +// Generate the `from_mut` method for the ColsRef struct +fn make_from_mut(struct_info: StructInfo, config: &proc_macro2::Ident) -> proc_macro2::TokenStream { + let StructInfo { + name, + vis: _, + generic_type, + field_infos: _, + fields, + from_args: _, + derive_clone: _, + } = struct_info; + + let from_mut_impl = fields + .iter() + .map(|f| { + let ident = f.ident.clone().unwrap(); + + let derives_aligned_borrow = f + .attrs + .iter() + .any(|attr| attr.path().is_ident("aligned_borrow")); + + let is_array = matches!(f.ty, syn::Type::Array(_)); + + if is_array { + // calling view() on ArrayViewMut returns an ArrayView + quote! { + other.#ident.view() + } + } else if derives_aligned_borrow { + // implicitly converts a mutable reference to an immutable reference, so leave the + // field value unchanged + quote! { + other.#ident + } + } else if is_columns_struct(&f.ty) { + // lifetime 'b is used in from_mut to allow more flexible lifetime of return value + let cols_ref_type = + get_const_cols_ref_type(&f.ty, &generic_type, parse_quote! { 'b }); + // Recursively call `from_mut` on the ColsRef field + quote! { + <#cols_ref_type>::from_mut::(&other.#ident) + } + } else if is_generic_type(&f.ty, &generic_type) { + // implicitly converts a mutable reference to an immutable reference, so leave the + // field value unchanged + quote! { + &other.#ident + } + } else { + panic!("Unsupported field type (in make_from_mut): {:?}", f.ty); + } + }) + .collect_vec(); + + let field_idents = fields + .iter() + .map(|f| f.ident.clone().unwrap()) + .collect_vec(); + + let mut_struct_ident = format_ident!("{}Mut", name.to_string()); + let mut_struct_type: syn::Type = parse_quote! { + #mut_struct_ident<'a, #generic_type> + }; + + parse_quote! { + // lifetime 'b is used in from_mut to allow more flexible lifetime of return value + impl<'b, #generic_type> #name<'b, #generic_type> { + pub fn from_mut<'a, C: #config>(other: &'b #mut_struct_type) -> Self + { + Self { + #( #field_idents: #from_mut_impl ),* + } + } + } + } +} + +// Information about a field that is used to generate the ColsRef and ColsRefMut structs +// See the `make_struct` function to see how this information is used +#[derive(Debug, Clone)] +struct FieldInfo { + // type for struct definition + ty: syn::Type, + // an expr calculating the length of the field + length_expr: proc_macro2::TokenStream, + // prepare a subslice of the slice to be used in the 'from' method + prepare_subslice: proc_macro2::TokenStream, + // an expr used in the Self initializer in the 'from' method + // may refer to the subslice declared in prepare_subslice + initializer: proc_macro2::TokenStream, +} + +// Prepare the fields for the const ColsRef struct +fn get_const_cols_ref_fields( + f: &syn::Field, + generic_type: &syn::TypeParam, + const_generics: &[&syn::Ident], +) -> FieldInfo { + let length_var = format_ident!("{}_length", f.ident.clone().unwrap()); + let slice_var = format_ident!("{}_slice", f.ident.clone().unwrap()); + + let derives_aligned_borrow = f + .attrs + .iter() + .any(|attr| attr.path().is_ident("aligned_borrow")); + + let is_array = matches!(f.ty, syn::Type::Array(_)); + + if is_array { + let ArrayInfo { dims, elem_type } = get_array_info(&f.ty, const_generics); + debug_assert!( + !dims.is_empty(), + "Array field must have at least one dimension" + ); + + let ndarray_ident: syn::Ident = format_ident!("ArrayView{}", dims.len()); + let ndarray_type: syn::Type = parse_quote! { + ndarray::#ndarray_ident<'a, #elem_type> + }; + + // dimensions of the array in terms of number of cells + let dim_exprs = dims + .iter() + .map(|d| match d { + // need to prepend C:: for const generic array dimensions + Dimension::ConstGeneric(expr) => quote! { C::#expr }, + Dimension::Other(expr) => quote! { #expr }, + }) + .collect_vec(); + + if derives_aligned_borrow { + let length_expr = quote! { + <#elem_type>::width() #(* #dim_exprs)* + }; + + FieldInfo { + ty: parse_quote! { + #ndarray_type + }, + length_expr: length_expr.clone(), + prepare_subslice: quote! { + let (#slice_var, slice) = slice.split_at(#length_expr); + let #slice_var: &[#elem_type] = unsafe { &*(#slice_var as *const [T] as *const [#elem_type]) }; + let #slice_var = ndarray::#ndarray_ident::from_shape( ( #(#dim_exprs),* ) , #slice_var).unwrap(); + }, + initializer: quote! { + #slice_var + }, + } + } else if is_columns_struct(&elem_type) { + panic!("Arrays of columns structs are currently not supported"); + } else if is_generic_type(&elem_type, generic_type) { + let length_expr = quote! { + 1 #(* #dim_exprs)* + }; + FieldInfo { + ty: parse_quote! { + #ndarray_type + }, + length_expr: length_expr.clone(), + prepare_subslice: quote! { + let (#slice_var, slice) = slice.split_at(#length_expr); + let #slice_var = ndarray::#ndarray_ident::from_shape( ( #(#dim_exprs),* ) , #slice_var).unwrap(); + }, + initializer: quote! { + #slice_var + }, + } + } else if is_primitive_type(&elem_type) { + FieldInfo { + ty: parse_quote! { + &'a #elem_type + }, + // Columns structs won't ever have primitive types, but this macro can be used on + // other structs as well, to make it easy to borrow a struct from &[u8]. + // We just set length = 0 knowing that calling the width() method is undefined if + // the struct has a primitive type. + length_expr: quote! { + 0 + }, + prepare_subslice: quote! { + let (#slice_var, slice) = slice.split_at(std::mem::size_of::<#elem_type>() #(* #dim_exprs)*); + let #slice_var = ndarray::#ndarray_ident::from_shape( ( #(#dim_exprs),* ) , #slice_var).unwrap(); + }, + initializer: quote! { + #slice_var + }, + } + } else { + panic!( + "Unsupported field type (in get_const_cols_ref_fields): {:?}", + f.ty + ); + } + } else if derives_aligned_borrow { + // treat the field as a struct that derives AlignedBorrow (and doesn't depend on the config) + let f_ty = &f.ty; + FieldInfo { + ty: parse_quote! { + &'a #f_ty + }, + length_expr: quote! { + <#f_ty>::width() + }, + prepare_subslice: quote! { + let #length_var = <#f_ty>::width(); + let (#slice_var, slice) = slice.split_at(#length_var); + }, + initializer: quote! { + { + use core::borrow::Borrow; + #slice_var.borrow() + } + }, + } + } else if is_columns_struct(&f.ty) { + let const_cols_ref_type = get_const_cols_ref_type(&f.ty, generic_type, parse_quote! { 'a }); + FieldInfo { + ty: parse_quote! { + #const_cols_ref_type + }, + length_expr: quote! { + <#const_cols_ref_type>::width::() + }, + prepare_subslice: quote! { + let #length_var = <#const_cols_ref_type>::width::(); + let (#slice_var, slice) = slice.split_at(#length_var); + let #slice_var = <#const_cols_ref_type>::from::(#slice_var); + }, + initializer: quote! { + #slice_var + }, + } + } else if is_generic_type(&f.ty, generic_type) { + FieldInfo { + ty: parse_quote! { + &'a #generic_type + }, + length_expr: quote! { + 1 + }, + prepare_subslice: quote! { + let #length_var = 1; + let (#slice_var, slice) = slice.split_at(#length_var); + }, + initializer: quote! { + &#slice_var[0] + }, + } + } else { + panic!( + "Unsupported field type (in get_mut_cols_ref_fields): {:?}", + f.ty + ); + } +} + +// Prepare the fields for the mut ColsRef struct +fn get_mut_cols_ref_fields( + f: &syn::Field, + generic_type: &syn::TypeParam, + const_generics: &[&syn::Ident], +) -> FieldInfo { + let length_var = format_ident!("{}_length", f.ident.clone().unwrap()); + let slice_var = format_ident!("{}_slice", f.ident.clone().unwrap()); + + let derives_aligned_borrow = f + .attrs + .iter() + .any(|attr| attr.path().is_ident("aligned_borrow")); + + let is_array = matches!(f.ty, syn::Type::Array(_)); + + if is_array { + let ArrayInfo { dims, elem_type } = get_array_info(&f.ty, const_generics); + debug_assert!( + !dims.is_empty(), + "Array field must have at least one dimension" + ); + + let ndarray_ident: syn::Ident = format_ident!("ArrayViewMut{}", dims.len()); + let ndarray_type: syn::Type = parse_quote! { + ndarray::#ndarray_ident<'a, #elem_type> + }; + + // dimensions of the array in terms of number of cells + let dim_exprs = dims + .iter() + .map(|d| match d { + // need to prepend C:: for const generic array dimensions + Dimension::ConstGeneric(expr) => quote! { C::#expr }, + Dimension::Other(expr) => quote! { #expr }, + }) + .collect_vec(); + + if derives_aligned_borrow { + let length_expr = quote! { + <#elem_type>::width() #(* #dim_exprs)* + }; + + FieldInfo { + ty: parse_quote! { + #ndarray_type + }, + length_expr: length_expr.clone(), + prepare_subslice: quote! { + let (#slice_var, slice) = slice.split_at_mut (#length_expr); + let #slice_var: &mut [#elem_type] = unsafe { &mut *(#slice_var as *mut [T] as *mut [#elem_type]) }; + let #slice_var = ndarray::#ndarray_ident::from_shape( ( #(#dim_exprs),* ) , #slice_var).unwrap(); + }, + initializer: quote! { + #slice_var + }, + } + } else if is_columns_struct(&elem_type) { + panic!("Arrays of columns structs are currently not supported"); + } else if is_generic_type(&elem_type, generic_type) { + let length_expr = quote! { + 1 #(* #dim_exprs)* + }; + FieldInfo { + ty: parse_quote! { + #ndarray_type + }, + length_expr: length_expr.clone(), + prepare_subslice: quote! { + let (#slice_var, slice) = slice.split_at_mut(#length_expr); + let #slice_var = ndarray::#ndarray_ident::from_shape( ( #(#dim_exprs),* ) , #slice_var).unwrap(); + }, + initializer: quote! { + #slice_var + }, + } + } else if is_primitive_type(&elem_type) { + FieldInfo { + ty: parse_quote! { + &'a mut #elem_type + }, + // Columns structs won't ever have primitive types, but this macro can be used on + // other structs as well, to make it easy to borrow a struct from &[u8]. + // We just set length = 0 knowing that calling the width() method is undefined if + // the struct has a primitive type. + length_expr: quote! { + 0 + }, + prepare_subslice: quote! { + let (#slice_var, slice) = slice.split_at_mut(std::mem::size_of::<#elem_type>() #(* #dim_exprs)*); + let #slice_var = ndarray::#ndarray_ident::from_shape( ( #(#dim_exprs),* ) , #slice_var).unwrap(); + }, + initializer: quote! { + #slice_var + }, + } + } else { + panic!( + "Unsupported field type (in get_mut_cols_ref_fields): {:?}", + f.ty + ); + } + } else if derives_aligned_borrow { + // treat the field as a struct that derives AlignedBorrow (and doesn't depend on the config) + let f_ty = &f.ty; + FieldInfo { + ty: parse_quote! { + &'a mut #f_ty + }, + length_expr: quote! { + <#f_ty>::width() + }, + prepare_subslice: quote! { + let #length_var = <#f_ty>::width(); + let (#slice_var, slice) = slice.split_at_mut(#length_var); + }, + initializer: quote! { + { + use core::borrow::BorrowMut; + #slice_var.borrow_mut() + } + }, + } + } else if is_columns_struct(&f.ty) { + let mut_cols_ref_type = get_mut_cols_ref_type(&f.ty, generic_type); + FieldInfo { + ty: parse_quote! { + #mut_cols_ref_type + }, + length_expr: quote! { + <#mut_cols_ref_type>::width::() + }, + prepare_subslice: quote! { + let #length_var = <#mut_cols_ref_type>::width::(); + let (#slice_var, slice) = slice.split_at_mut(#length_var); + let #slice_var = <#mut_cols_ref_type>::from::(#slice_var); + }, + initializer: quote! { + #slice_var + }, + } + } else if is_generic_type(&f.ty, generic_type) { + FieldInfo { + ty: parse_quote! { + &'a mut #generic_type + }, + length_expr: quote! { + 1 + }, + prepare_subslice: quote! { + let #length_var = 1; + let (#slice_var, slice) = slice.split_at_mut(#length_var); + }, + initializer: quote! { + &mut #slice_var[0] + }, + } + } else { + panic!( + "Unsupported field type (in get_mut_cols_ref_fields): {:?}", + f.ty + ); + } +} + +// Helper functions + +fn is_columns_struct(ty: &syn::Type) -> bool { + if let syn::Type::Path(type_path) = ty { + type_path + .path + .segments + .iter() + .next_back() + .map(|s| s.ident.to_string().ends_with("Cols")) + .unwrap_or(false) + } else { + false + } +} + +// If 'ty' is a struct that derives ColsRef, return the ColsRef struct type +// Otherwise, return None +fn get_const_cols_ref_type( + ty: &syn::Type, + generic_type: &syn::TypeParam, + lifetime: syn::Lifetime, +) -> syn::TypePath { + if !is_columns_struct(ty) { + panic!("Expected a columns struct, got {ty:?}"); + } + + if let syn::Type::Path(type_path) = ty { + let s = type_path.path.segments.iter().next_back().unwrap(); + if s.ident.to_string().ends_with("Cols") { + let const_cols_ref_ident = format_ident!("{}Ref", s.ident); + let const_cols_ref_type = parse_quote! { + #const_cols_ref_ident<#lifetime, #generic_type> + }; + const_cols_ref_type + } else { + panic!("is_columns_struct returned true for type {ty:?} but the last segment is not a columns struct"); + } + } else { + panic!("is_columns_struct returned true but the type {ty:?} is not a path",); + } +} + +// If 'ty' is a struct that derives ColsRef, return the ColsRefMut struct type +// Otherwise, return None +fn get_mut_cols_ref_type(ty: &syn::Type, generic_type: &syn::TypeParam) -> syn::TypePath { + if !is_columns_struct(ty) { + panic!("Expected a columns struct, got {ty:?}"); + } + + if let syn::Type::Path(type_path) = ty { + let s = type_path.path.segments.iter().next_back().unwrap(); + if s.ident.to_string().ends_with("Cols") { + let mut_cols_ref_ident = format_ident!("{}RefMut", s.ident); + let mut_cols_ref_type = parse_quote! { + #mut_cols_ref_ident<'a, #generic_type> + }; + mut_cols_ref_type + } else { + panic!("is_columns_struct returned true for type {ty:?} but the last segment is not a columns struct"); + } + } else { + panic!("is_columns_struct returned true but the type {ty:?} is not a path",); + } +} + +fn is_generic_type(ty: &syn::Type, generic_type: &syn::TypeParam) -> bool { + if let syn::Type::Path(type_path) = ty { + if type_path.path.segments.len() == 1 { + type_path + .path + .segments + .iter() + .next_back() + .map(|s| s.ident == generic_type.ident) + .unwrap_or(false) + } else { + false + } + } else { + false + } +} diff --git a/crates/circuits/primitives/derive/src/cols_ref/utils.rs b/crates/circuits/primitives/derive/src/cols_ref/utils.rs new file mode 100644 index 0000000000..56e7dcd918 --- /dev/null +++ b/crates/circuits/primitives/derive/src/cols_ref/utils.rs @@ -0,0 +1,102 @@ +use syn::{Expr, ExprPath, Ident, Stmt, Type, TypePath}; + +pub fn is_primitive_type(ty: &Type) -> bool { + match ty { + Type::Path(TypePath { path, .. }) if path.segments.len() == 1 => { + matches!( + path.segments[0].ident.to_string().as_str(), + "u8" | "u16" + | "u32" + | "u64" + | "u128" + | "usize" + | "i8" + | "i16" + | "i32" + | "i64" + | "i128" + | "isize" + | "f32" + | "f64" + | "bool" + | "char" + ) + } + _ => false, + } +} + +// Type of array dimension +pub enum Dimension { + ConstGeneric(Expr), + Other(Expr), +} + +// Describes a nested array +pub struct ArrayInfo { + pub dims: Vec, + pub elem_type: Type, +} + +pub fn get_array_info(ty: &Type, const_generics: &[&Ident]) -> ArrayInfo { + let dims = get_dims(ty, const_generics); + let elem_type = get_elem_type(ty); + ArrayInfo { dims, elem_type } +} + +fn get_elem_type(ty: &Type) -> Type { + match ty { + Type::Array(array) => get_elem_type(array.elem.as_ref()), + Type::Path(_) => ty.clone(), + _ => panic!("Unsupported type: {ty:?}"), + } +} + +// Get a vector of the dimensions of the array +// Each dimension is either a constant generic or a literal integer value +fn get_dims(ty: &Type, const_generics: &[&Ident]) -> Vec { + get_dims_impl(ty, const_generics) + .into_iter() + .rev() + .collect() +} + +fn get_dims_impl(ty: &Type, const_generics: &[&Ident]) -> Vec { + match ty { + Type::Array(array) => { + let mut dims = get_dims_impl(array.elem.as_ref(), const_generics); + match &array.len { + Expr::Block(syn::ExprBlock { block, .. }) => { + if block.stmts.len() != 1 { + panic!( + "Expected exactly one statement in block, got: {:?}", + block.stmts.len() + ); + } + if let Stmt::Expr(Expr::Path(expr_path), ..) = &block.stmts[0] { + if let Some(len_ident) = expr_path.path.get_ident() { + if const_generics.contains(&len_ident) { + dims.push(Dimension::ConstGeneric(expr_path.clone().into())); + } else { + dims.push(Dimension::Other(expr_path.clone().into())); + } + } + } + } + Expr::Path(ExprPath { path, .. }) => { + let len_ident = path.get_ident(); + if len_ident.is_some() && const_generics.contains(&len_ident.unwrap()) { + dims.push(Dimension::ConstGeneric(array.len.clone())); + } else { + dims.push(Dimension::Other(array.len.clone())); + } + } + Expr::Lit(expr_lit) => dims.push(Dimension::Other(expr_lit.clone().into())), + _ => panic!("Unsupported array length type: {:?}", array.len), + } + dims + } + Type::Path(_) => Vec::new(), + _ => panic!("Unsupported field type (in get_dims_impl)"), + } +} diff --git a/crates/circuits/primitives/derive/src/lib.rs b/crates/circuits/primitives/derive/src/lib.rs index f656f86a8b..b5011b665d 100644 --- a/crates/circuits/primitives/derive/src/lib.rs +++ b/crates/circuits/primitives/derive/src/lib.rs @@ -7,6 +7,9 @@ use proc_macro::TokenStream; use quote::quote; use syn::{parse_macro_input, Data, DeriveInput, Fields, GenericParam, LitStr, Meta}; +mod cols_ref; +use cols_ref::cols_ref_impl; + #[proc_macro_derive(AlignedBorrow)] pub fn aligned_borrow_derive(input: TokenStream) -> TokenStream { let ast = parse_macro_input!(input as DeriveInput); @@ -331,3 +334,25 @@ pub fn bytes_stateful_derive(input: TokenStream) -> TokenStream { _ => unimplemented!(), } } + +#[proc_macro_derive(ColsRef, attributes(aligned_borrow, config))] +pub fn cols_ref_derive(input: TokenStream) -> TokenStream { + let derive_input: DeriveInput = parse_macro_input!(input as DeriveInput); + + let config = derive_input + .attrs + .iter() + .find(|attr| attr.path().is_ident("config")); + if config.is_none() { + return syn::Error::new(derive_input.ident.span(), "Config attribute is required") + .to_compile_error() + .into(); + } + let config: proc_macro2::Ident = config + .unwrap() + .parse_args() + .expect("Failed to parse config"); + + let res = cols_ref_impl(derive_input, config); + res.into() +} diff --git a/crates/circuits/primitives/derive/tests/example.rs b/crates/circuits/primitives/derive/tests/example.rs new file mode 100644 index 0000000000..58bac9e26c --- /dev/null +++ b/crates/circuits/primitives/derive/tests/example.rs @@ -0,0 +1,87 @@ +use openvm_circuit_primitives_derive::ColsRef; + +pub trait ExampleConfig { + const N: usize; +} +pub struct ExampleConfigImplA; +impl ExampleConfig for ExampleConfigImplA { + const N: usize = 5; +} +pub struct ExampleConfigImplB; +impl ExampleConfig for ExampleConfigImplB { + const N: usize = 10; +} + +#[allow(dead_code)] +#[derive(ColsRef)] +#[config(ExampleConfig)] +struct ExampleCols { + arr: [T; N], + sum: T, +} + +#[test] +fn example() { + let input = [1, 2, 3, 4, 5, 15]; + let test: ExampleColsRef = ExampleColsRef::from::(&input); + println!("{}, {}", test.arr, test.sum); +} + +/* + * For reference, this is what the ColsRef macro expands to. + * The `cargo expand` tool is helpful for understanding how the ColsRef macro works. + * See https://github.com/dtolnay/cargo-expand + +#[derive(Debug, Clone)] +struct ExampleColsRef<'a, T> { + pub arr: ndarray::ArrayView1<'a, T>, + pub sum: &'a T, +} + +impl<'a, T> ExampleColsRef<'a, T> { + pub fn from(slice: &'a [T]) -> Self { + let (arr_slice, slice) = slice.split_at(1 * C::N); + let arr_slice = ndarray::ArrayView1::from_shape((C::N), arr_slice).unwrap(); + let sum_length = 1; + let (sum_slice, slice) = slice.split_at(sum_length); + Self { + arr: arr_slice, + sum: &sum_slice[0], + } + } + pub const fn width() -> usize { + 0 + 1 * C::N + 1 + } +} + +impl<'b, T> ExampleColsRef<'b, T> { + pub fn from_mut<'a, C: ExampleConfig>(other: &'b ExampleColsRefMut<'a, T>) -> Self { + Self { + arr: other.arr.view(), + sum: &other.sum, + } + } +} + +#[derive(Debug)] +struct ExampleColsRefMut<'a, T> { + pub arr: ndarray::ArrayViewMut1<'a, T>, + pub sum: &'a mut T, +} + +impl<'a, T> ExampleColsRefMut<'a, T> { + pub fn from(slice: &'a mut [T]) -> Self { + let (arr_slice, slice) = slice.split_at_mut(1 * C::N); + let arr_slice = ndarray::ArrayViewMut1::from_shape((C::N), arr_slice).unwrap(); + let sum_length = 1; + let (sum_slice, slice) = slice.split_at_mut(sum_length); + Self { + arr: arr_slice, + sum: &mut sum_slice[0], + } + } + pub const fn width() -> usize { + 0 + 1 * C::N + 1 + } +} +*/ diff --git a/crates/circuits/primitives/derive/tests/test_cols_ref.rs b/crates/circuits/primitives/derive/tests/test_cols_ref.rs new file mode 100644 index 0000000000..caaa3bcec9 --- /dev/null +++ b/crates/circuits/primitives/derive/tests/test_cols_ref.rs @@ -0,0 +1,299 @@ +use openvm_circuit_primitives_derive::{AlignedBorrow, ColsRef}; + +pub trait TestConfig { + const N: usize; + const M: usize; +} +pub struct TestConfigImpl; +impl TestConfig for TestConfigImpl { + const N: usize = 5; + const M: usize = 2; +} + +#[allow(dead_code)] // TestCols isn't actually used in the code. silence clippy warning +#[derive(ColsRef)] +#[config(TestConfig)] +struct TestCols { + single_field_element: T, + array_of_t: [T; N], + nested_array_of_t: [[T; N]; N], + cols_struct: TestSubCols, + #[aligned_borrow] + array_of_aligned_borrow: [TestAlignedBorrow; N], + #[aligned_borrow] + nested_array_of_aligned_borrow: [[TestAlignedBorrow; N]; N], +} + +#[allow(dead_code)] // TestSubCols isn't actually used in the code. silence clippy warning +#[derive(ColsRef, Debug)] +#[config(TestConfig)] +struct TestSubCols { + // TestSubCols can have fields of any type that TestCols can have + a: T, + b: [T; M], + #[aligned_borrow] + c: TestAlignedBorrow, +} + +#[derive(AlignedBorrow, Debug)] +struct TestAlignedBorrow { + a: T, + b: [T; 5], +} + +#[test] +fn test_cols_ref() { + assert_eq!( + TestColsRef::::width::(), + TestColsRefMut::::width::() + ); + const WIDTH: usize = TestColsRef::::width::(); + let mut input = vec![0; WIDTH]; + let mut cols: TestColsRefMut = TestColsRefMut::from::(&mut input); + + *cols.single_field_element = 1; + cols.array_of_t[0] = 2; + cols.nested_array_of_t[[0, 0]] = 3; + *cols.cols_struct.a = 4; + cols.cols_struct.b[0] = 5; + cols.cols_struct.c.a = 6; + cols.cols_struct.c.b[0] = 7; + cols.array_of_aligned_borrow[0].a = 8; + cols.array_of_aligned_borrow[0].b[0] = 9; + cols.nested_array_of_aligned_borrow[[0, 0]].a = 10; + cols.nested_array_of_aligned_borrow[[0, 0]].b[0] = 11; + + let cols: TestColsRef = TestColsRef::from::(&input); + println!("{cols:?}"); + assert_eq!(*cols.single_field_element, 1); + assert_eq!(cols.array_of_t[0], 2); + assert_eq!(cols.nested_array_of_t[[0, 0]], 3); + assert_eq!(*cols.cols_struct.a, 4); + assert_eq!(cols.cols_struct.b[0], 5); + assert_eq!(cols.cols_struct.c.a, 6); + assert_eq!(cols.cols_struct.c.b[0], 7); + assert_eq!(cols.array_of_aligned_borrow[0].a, 8); + assert_eq!(cols.array_of_aligned_borrow[0].b[0], 9); + assert_eq!(cols.nested_array_of_aligned_borrow[[0, 0]].a, 10); + assert_eq!(cols.nested_array_of_aligned_borrow[[0, 0]].b[0], 11); +} + +/* + * For reference, this is what the ColsRef macro expands to. + * The `cargo expand` tool is helpful for understanding how the ColsRef macro works. + * See https://github.com/dtolnay/cargo-expand + +#[derive(Debug, Clone)] +struct TestColsRef<'a, T> { + pub single_field_element: &'a T, + pub array_of_t: ndarray::ArrayView1<'a, T>, + pub nested_array_of_t: ndarray::ArrayView2<'a, T>, + pub cols_struct: TestSubColsRef<'a, T>, + pub array_of_aligned_borrow: ndarray::ArrayView1<'a, TestAlignedBorrow>, + pub nested_array_of_aligned_borrow: ndarray::ArrayView2<'a, TestAlignedBorrow>, +} + +impl<'a, T> TestColsRef<'a, T> { + pub fn from(slice: &'a [T]) -> Self { + let single_field_element_length = 1; + let (single_field_element_slice, slice) = slice + .split_at(single_field_element_length); + let (array_of_t_slice, slice) = slice.split_at(1 * C::N); + let array_of_t_slice = ndarray::ArrayView1::from_shape((C::N), array_of_t_slice) + .unwrap(); + let (nested_array_of_t_slice, slice) = slice.split_at(1 * C::N * C::N); + let nested_array_of_t_slice = ndarray::ArrayView2::from_shape( + (C::N, C::N), + nested_array_of_t_slice, + ) + .unwrap(); + let cols_struct_length = >::width::(); + let (cols_struct_slice, slice) = slice.split_at(cols_struct_length); + let cols_struct_slice = >::from::(cols_struct_slice); + let (array_of_aligned_borrow_slice, slice) = slice + .split_at(>::width() * C::N); + let array_of_aligned_borrow_slice: &[TestAlignedBorrow] = unsafe { + &*(array_of_aligned_borrow_slice as *const [T] + as *const [TestAlignedBorrow]) + }; + let array_of_aligned_borrow_slice = ndarray::ArrayView1::from_shape( + (C::N), + array_of_aligned_borrow_slice, + ) + .unwrap(); + let (nested_array_of_aligned_borrow_slice, slice) = slice + .split_at(>::width() * C::N * C::N); + let nested_array_of_aligned_borrow_slice: &[TestAlignedBorrow] = unsafe { + &*(nested_array_of_aligned_borrow_slice as *const [T] + as *const [TestAlignedBorrow]) + }; + let nested_array_of_aligned_borrow_slice = ndarray::ArrayView2::from_shape( + (C::N, C::N), + nested_array_of_aligned_borrow_slice, + ) + .unwrap(); + Self { + single_field_element: &single_field_element_slice[0], + array_of_t: array_of_t_slice, + nested_array_of_t: nested_array_of_t_slice, + cols_struct: cols_struct_slice, + array_of_aligned_borrow: array_of_aligned_borrow_slice, + nested_array_of_aligned_borrow: nested_array_of_aligned_borrow_slice, + } + } + pub const fn width() -> usize { + 0 + 1 + 1 * C::N + 1 * C::N * C::N + >::width::() + + >::width() * C::N + + >::width() * C::N * C::N + } +} + +impl<'b, T> TestColsRef<'b, T> { + pub fn from_mut<'a, C: TestConfig>(other: &'b TestColsRefMut<'a, T>) -> Self { + Self { + single_field_element: &other.single_field_element, + array_of_t: other.array_of_t.view(), + nested_array_of_t: other.nested_array_of_t.view(), + cols_struct: >::from_mut::(&other.cols_struct), + array_of_aligned_borrow: other.array_of_aligned_borrow.view(), + nested_array_of_aligned_borrow: other.nested_array_of_aligned_borrow.view(), + } + } +} + +#[derive(Debug)] +struct TestColsRefMut<'a, T> { + pub single_field_element: &'a mut T, + pub array_of_t: ndarray::ArrayViewMut1<'a, T>, + pub nested_array_of_t: ndarray::ArrayViewMut2<'a, T>, + pub cols_struct: TestSubColsRefMut<'a, T>, + pub array_of_aligned_borrow: ndarray::ArrayViewMut1<'a, TestAlignedBorrow>, + pub nested_array_of_aligned_borrow: ndarray::ArrayViewMut2<'a, TestAlignedBorrow>, +} + +impl<'a, T> TestColsRefMut<'a, T> { + pub fn from(slice: &'a mut [T]) -> Self { + let single_field_element_length = 1; + let (single_field_element_slice, slice) = slice + .split_at_mut(single_field_element_length); + let (array_of_t_slice, slice) = slice.split_at_mut(1 * C::N); + let array_of_t_slice = ndarray::ArrayViewMut1::from_shape( + (C::N), + array_of_t_slice, + ) + .unwrap(); + let (nested_array_of_t_slice, slice) = slice.split_at_mut(1 * C::N * C::N); + let nested_array_of_t_slice = ndarray::ArrayViewMut2::from_shape( + (C::N, C::N), + nested_array_of_t_slice, + ) + .unwrap(); + let cols_struct_length = >::width::(); + let (cols_struct_slice, slice) = slice.split_at_mut(cols_struct_length); + let cols_struct_slice = >::from::(cols_struct_slice); + let (array_of_aligned_borrow_slice, slice) = slice + .split_at_mut(>::width() * C::N); + let array_of_aligned_borrow_slice: &mut [TestAlignedBorrow] = unsafe { + &mut *(array_of_aligned_borrow_slice as *mut [T] + as *mut [TestAlignedBorrow]) + }; + let array_of_aligned_borrow_slice = ndarray::ArrayViewMut1::from_shape( + (C::N), + array_of_aligned_borrow_slice, + ) + .unwrap(); + let (nested_array_of_aligned_borrow_slice, slice) = slice + .split_at_mut(>::width() * C::N * C::N); + let nested_array_of_aligned_borrow_slice: &mut [TestAlignedBorrow] = unsafe { + &mut *(nested_array_of_aligned_borrow_slice as *mut [T] + as *mut [TestAlignedBorrow]) + }; + let nested_array_of_aligned_borrow_slice = ndarray::ArrayViewMut2::from_shape( + (C::N, C::N), + nested_array_of_aligned_borrow_slice, + ) + .unwrap(); + Self { + single_field_element: &mut single_field_element_slice[0], + array_of_t: array_of_t_slice, + nested_array_of_t: nested_array_of_t_slice, + cols_struct: cols_struct_slice, + array_of_aligned_borrow: array_of_aligned_borrow_slice, + nested_array_of_aligned_borrow: nested_array_of_aligned_borrow_slice, + } + } + pub const fn width() -> usize { + 0 + 1 + 1 * C::N + 1 * C::N * C::N + >::width::() + + >::width() * C::N + + >::width() * C::N * C::N + } +} + +#[derive(Debug, Clone)] +struct TestSubColsRef<'a, T> { + pub a: &'a T, + pub b: ndarray::ArrayView1<'a, T>, + pub c: &'a TestAlignedBorrow, +} + +impl<'a, T> TestSubColsRef<'a, T> { + pub fn from(slice: &'a [T]) -> Self { + let a_length = 1; + let (a_slice, slice) = slice.split_at(a_length); + let (b_slice, slice) = slice.split_at(1 * C::M); + let b_slice = ndarray::ArrayView1::from_shape((C::M), b_slice).unwrap(); + let c_length = >::width(); + let (c_slice, slice) = slice.split_at(c_length); + Self { + a: &a_slice[0], + b: b_slice, + c: { + use core::borrow::Borrow; + c_slice.borrow() + }, + } + } + pub const fn width() -> usize { + 0 + 1 + 1 * C::M + >::width() + } +} + +impl<'b, T> TestSubColsRef<'b, T> { + pub fn from_mut<'a, C: TestConfig>(other: &'b TestSubColsRefMut<'a, T>) -> Self { + Self { + a: &other.a, + b: other.b.view(), + c: other.c, + } + } +} + +#[derive(Debug)] +struct TestSubColsRefMut<'a, T> { + pub a: &'a mut T, + pub b: ndarray::ArrayViewMut1<'a, T>, + pub c: &'a mut TestAlignedBorrow, +} + +impl<'a, T> TestSubColsRefMut<'a, T> { + pub fn from(slice: &'a mut [T]) -> Self { + let a_length = 1; + let (a_slice, slice) = slice.split_at_mut(a_length); + let (b_slice, slice) = slice.split_at_mut(1 * C::M); + let b_slice = ndarray::ArrayViewMut1::from_shape((C::M), b_slice).unwrap(); + let c_length = >::width(); + let (c_slice, slice) = slice.split_at_mut(c_length); + Self { + a: &mut a_slice[0], + b: b_slice, + c: { + use core::borrow::BorrowMut; + c_slice.borrow_mut() + }, + } + } + pub const fn width() -> usize { + 0 + 1 + 1 * C::M + >::width() + } +} +*/ diff --git a/crates/circuits/sha2-air/Cargo.toml b/crates/circuits/sha2-air/Cargo.toml new file mode 100644 index 0000000000..668611ecf5 --- /dev/null +++ b/crates/circuits/sha2-air/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "openvm-sha2-air" +version.workspace = true +authors.workspace = true +edition.workspace = true + +[dependencies] +openvm-circuit-primitives = { workspace = true } +openvm-stark-backend = { workspace = true } +openvm-circuit-primitives-derive = { workspace = true } + +sha2 = { workspace = true, features = ["compress"] } +rand.workspace = true +ndarray.workspace = true +num_enum = { workspace = true } + +[features] +default = ["parallel"] +parallel = ["openvm-stark-backend/parallel"] diff --git a/crates/circuits/sha2-air/SOUNDNESS.md b/crates/circuits/sha2-air/SOUNDNESS.md new file mode 100644 index 0000000000..d2bb318c1d --- /dev/null +++ b/crates/circuits/sha2-air/SOUNDNESS.md @@ -0,0 +1,209 @@ +# Justification of Soundness + +The soundness of `Sha2BlockHasherSubAir`'s constraints is not obvious. +This document aims to make it clearer. + +## Summary of Constraints + +The main constraints are summarized below. + +### Constraint 1: Digest Row Hash Computation + +In `eval_digest_row()` on lines 148-185, we constrain: + +``` +next.prev_hash + local.work_vars = next.final_hash +``` + +when `next` is a digest row. + +### Constraint 2: Dummy Row Consistency + +In `eval_transitions()` on lines 293-304, we constrain: + +``` +local.work_vars.a == next.work_vars.a +local.work_vars.e == next.work_vars.e +``` + +when `next` is a dummy row. + +This ensures that all dummy rows have the same values in `work_vars.a` and `work_vars.e`, and moreover that these values match the last digest row's `hash` field. (Since the `hash` field on digest rows is the same as `work_vars` on round rows.) + +### Constraint 3: Block Chaining + +In `eval_prev_hash()`, we constrain, via an interaction on digest rows, that: + +``` +curr_block.digest_row.hash == next_block.digest_row.prev_hash +``` + +That is, the next block's digest row's `prev_hash` field is equal to the current block's digest row's `hash` field. + +On the last block, this constraint wraps around, and constrains that: + +``` +last_block.digest_row.hash == first_block.digest_row.prev_hash +``` + +### Constraint 4: Work Variables Update + +In `eval_work_vars()`, we constrain: + +``` +constraint_word_addition(local, next) +``` + +on **all** rows. + +We constrain this on all rows because the constraint degree is already too high to narrow down the rows on which to enforce this constraint. On round rows, this constraint ensures the work vars are updated correctly. + +However, on other rows, even though the constraint doesn't constrain anything meaningful, we still need to ensure that the constraint passes. In order to do this, we fill in certain fields on certain rows with values that satisfy the constraint. + +In particular: +- When `next` is a digest row, we fill in `next.work_vars.carry_a` and `next.work_vars.carry_e` with slack values. +- When `next` is a dummy row, we also fill in `next.work_vars.carry_a` and `next.work_vars.carry_e` with slack values. However, in this case, all these values will be the same on all the dummy rows (due to constraint 2), so we compute them once (on the first dummy row) and copy them into all the other dummy rows. + + +## Soundness + +We will show that the four constraints above imply that the hash of each block is computed correctly. + +We will walk through the justification with an example trace consisting of three blocks and three dummy rows. The argument generalizes readily to traces with more blocks or dummy rows. + +### Example Trace + +Suppose our trace looks like this: + +``` +Block 1: + Round rows (64 rounds): + first round row: work_vars + ... + last round row: work_vars + + Digest row: + hash: [3a] + final_hash: (computed from prev_hash + work_vars) + prev_hash: [3c] + carry_a/e: (slack values) + +Block 2: + Round rows (64 rounds): + first round row: work_vars + ... + last round row: work_vars + Digest row: + hash: [3b] + final_hash: (computed from prev_hash + work_vars) + prev_hash: [3a] + carry_a/e: (slack values) + +Block 3: + Round rows (64 rounds): + first round row: work_vars + ... + last round row: work_vars + + Digest row: + hash: [3c][2a] + final_hash: (computed from prev_hash + work_vars) + prev_hash: [3b] + carry_a/e: (slack values) + +Dummy rows: + Dummy row 1: + work_vars: [2a][2b] + carry_a/e: (slack values) + + Dummy row 2: + work_vars: [2b][2c] + carry_a/e: (slack values) + + Dummy row 3: + work_vars: [2c] + carry_a/e: (slack values) +``` + +**Legend:** +- Square brackets `[X]` indicate fields affected by constraint X (e.g., `[3a]` = affected by constraint 3a) +- Multiple annotations on a field (e.g., `[3c][2a]`) indicate it's affected by multiple constraints + +### Constraint Applications + +**Constraint 1** gives: + +``` +block1.digest_row.prev_hash + block1.last_round_row.work_vars == block1.digest_row.final_hash +block2.digest_row.prev_hash + block2.last_round_row.work_vars == block2.digest_row.final_hash +block3.digest_row.prev_hash + block3.last_round_row.work_vars == block3.digest_row.final_hash +``` + +**Constraint 2** gives: + +``` +[2a] block3.digest_row.hash == dummy_row_1.work_vars +[2b] dummy_row_1.work_vars == dummy_row_2.work_vars +[2c] dummy_row_2.work_vars == dummy_row_3.work_vars +``` + +**Constraint 3** gives: + +``` +[3a] block1.digest_row.hash == block2.digest_row.prev_hash +[3b] block2.digest_row.hash == block3.digest_row.prev_hash +[3c] block3.digest_row.hash == block1.digest_row.prev_hash +``` + +### Constraining Rounds + +First, we claim that all 64 rounds for each block are constrained correctly. That is, we claim that the `work_vars` in each of these rounds are updated correctly. + +**Constraint 4** gives that rounds 5 to 64 inclusive of each block are constrained correctly, since these rounds occur when `local` and `next` are in the same block. + +For the first four rounds of each block, we must examine the case when `next` is the first row of a block. There are two subcases: either `local` is a digest row, or a dummy row. + +#### Case 1: `local` is a digest row + +If `local` is a digest row, for example when `local` is the digest row of block 1 (and so `next` is the first row of block 2), then by constraint 3b, we have: + +``` +local.hash == block3.digest_row.prev_hash +``` + +So, the `constraint_word_addition(local, next)` constrains that `next.work_vars` is updated from `local.work_vars` (i.e. `local.hash`) by consuming the first 4 words of input. Since `local.work_vars` stores the `prev_hash` of block 3, this constraint ensures that the first 4 rounds are constrained correctly. + +A similar argument works for when `local` is the digest row of block2. + +#### Case 2: `local` is a dummy row + +If `local` is a dummy row, then it is the last dummy row, and `next` is the first row of block 1. In this case, constraint 2 gives us that: + +``` +local.work_vars == dummy_row_3.work_vars + == dummy_row_2.work_vars + == dummy_row_1.work_vars + == block3.digest_row.hash +``` + +Then constraint 3c gives: + +``` +block3.digest_row.hash == block1.digest_row.prev_hash +``` + +which overall gives: + +``` +local.work_vars == block1.digest_row.prev_hash +``` + +So, the first 4 rounds of block 1 are constrained correctly. + +**Conclusion:** All rounds are constrained correctly. + +### Final Hash + +Now, we can show that each block's `final_hash` is correct. + +We already argued that, on each block, `last_round_row.work_vars` is correctly computed from the `prev_hash`. Now, **constraint 1** gives that each block's `final_hash` is constructed by adding the `last_round_row.work_vars` to the `prev_state`. This is exactly correct, by the SHA-2 specification. diff --git a/crates/circuits/sha2-air/src/air.rs b/crates/circuits/sha2-air/src/air.rs new file mode 100644 index 0000000000..803df2c688 --- /dev/null +++ b/crates/circuits/sha2-air/src/air.rs @@ -0,0 +1,617 @@ +use std::{iter::once, marker::PhantomData}; + +use ndarray::s; +use openvm_circuit_primitives::{ + bitwise_op_lookup::BitwiseOperationLookupBus, encoder::Encoder, utils::select, SubAir, +}; +use openvm_stark_backend::{ + interaction::{BusIndex, InteractionBuilder, PermutationCheckBus}, + p3_air::{AirBuilder, BaseAir}, + p3_field::{Field, PrimeCharacteristicRing}, + p3_matrix::Matrix, +}; + +use super::{ + big_sig0_field, big_sig1_field, ch_field, compose, maj_field, small_sig0_field, + small_sig1_field, +}; +use crate::{ + constraint_word_addition, word_into_u16_limbs, Sha2BlockHasherSubairConfig, Sha2DigestColsRef, + Sha2RoundColsRef, +}; + +/// Expects the message to be padded to a multiple of C::BLOCK_WORDS * C::WORD_BITS bits +#[derive(Clone, Debug)] +pub struct Sha2BlockHasherSubAir { + pub bitwise_lookup_bus: BitwiseOperationLookupBus, + pub row_idx_encoder: Encoder, + /// Internal bus for self-interactions in this AIR. + pub private_bus: PermutationCheckBus, + _phantom: PhantomData, +} + +impl Sha2BlockHasherSubAir { + pub fn new(bitwise_lookup_bus: BitwiseOperationLookupBus, private_bus_idx: BusIndex) -> Self { + Self { + bitwise_lookup_bus, + row_idx_encoder: Encoder::new(C::ROWS_PER_BLOCK + 1, 2, false), /* + 1 for dummy + * (padding) rows */ + private_bus: PermutationCheckBus::new(private_bus_idx), + _phantom: PhantomData, + } + } +} + +impl BaseAir for Sha2BlockHasherSubAir { + fn width(&self) -> usize { + C::SUBAIR_WIDTH + } +} + +impl SubAir + for Sha2BlockHasherSubAir +{ + /// The start column for the sub-air to use + type AirContext<'a> + = usize + where + Self: 'a, + AB: 'a, + ::Var: 'a, + ::Expr: 'a; + + fn eval<'a>(&'a self, builder: &'a mut AB, start_col: Self::AirContext<'a>) + where + AB::Var: 'a, + AB::Expr: 'a, + { + self.eval_row(builder, start_col); + self.eval_transitions(builder, start_col); + } +} + +impl Sha2BlockHasherSubAir { + /// Implements the single row constraints (i.e. imposes constraints only on local) + /// Implements some sanity constraints on the row index, flags, and work variables + fn eval_row(&self, builder: &mut AB, start_col: usize) { + let main = builder.main(); + let local = main.row_slice(0).unwrap(); + + // Doesn't matter which column struct we use here as we are only interested in the common + // columns + let local_cols: Sha2DigestColsRef = + Sha2DigestColsRef::from::(&local[start_col..start_col + C::SUBAIR_DIGEST_WIDTH]); + let flags = &local_cols.flags; + builder.assert_bool(*flags.is_round_row); + builder.assert_bool(*flags.is_first_4_rows); + builder.assert_bool(*flags.is_digest_row); + builder.assert_bool(*flags.is_round_row + *flags.is_digest_row); + + self.row_idx_encoder + .eval(builder, local_cols.flags.row_idx.to_slice().unwrap()); + // assert all row indices are in [0, C::ROWS_PER_BLOCK] + builder.assert_one(self.row_idx_encoder.contains_flag_range::( + local_cols.flags.row_idx.to_slice().unwrap(), + 0..=C::ROWS_PER_BLOCK, + )); + // assert that the row indices are [0, 3] for the first 4 rows + builder.assert_eq( + self.row_idx_encoder + .contains_flag_range::(local_cols.flags.row_idx.to_slice().unwrap(), 0..=3), + *flags.is_first_4_rows, + ); + // round row indices are in [0, C::ROUND_ROWS - 1] + builder.assert_eq( + self.row_idx_encoder.contains_flag_range::( + local_cols.flags.row_idx.to_slice().unwrap(), + 0..=C::ROUND_ROWS - 1, + ), + *flags.is_round_row, + ); + // digest row always has row index C::ROUND_ROWS + builder.assert_eq( + self.row_idx_encoder.contains_flag::( + local_cols.flags.row_idx.to_slice().unwrap(), + &[C::ROUND_ROWS], + ), + *flags.is_digest_row, + ); + // If padding row we want the row_idx to be C::ROWS_PER_BLOCK + builder.assert_eq( + self.row_idx_encoder.contains_flag::( + local_cols.flags.row_idx.to_slice().unwrap(), + &[C::ROWS_PER_BLOCK], + ), + flags.is_padding_row(), + ); + + // Constrain a, e, being composed of bits: we make sure a and e are always in the same place + // in the trace matrix Note: this has to be true for every row, even padding rows + for i in 0..C::ROUNDS_PER_ROW { + for j in 0..C::WORD_BITS { + builder.assert_bool(local_cols.hash.a[[i, j]]); + builder.assert_bool(local_cols.hash.e[[i, j]]); + } + } + } + + /// Evaluates the final hash for this block + fn eval_digest_row( + &self, + builder: &mut AB, + local: Sha2RoundColsRef, + next: Sha2DigestColsRef, + ) { + // Assert that the previous hash + work vars == final hash. + // That is, `next.prev_hash[i] + local.work_vars[i] == next.final_hash[i]` + // where addition is done modulo 2^32 + for i in 0..C::HASH_WORDS { + let mut carry = AB::Expr::ZERO; + for j in 0..C::WORD_U16S { + let work_var_limb = if i < C::ROUNDS_PER_ROW { + compose::( + local + .work_vars + .a + .slice(s![C::ROUNDS_PER_ROW - 1 - i, j * 16..(j + 1) * 16]) + .as_slice() + .unwrap(), + 1, + ) + } else { + compose::( + local + .work_vars + .e + .slice(s![C::ROUNDS_PER_ROW + 3 - i, j * 16..(j + 1) * 16]) + .as_slice() + .unwrap(), + 1, + ) + }; + let final_hash_limb = compose::( + next.final_hash + .slice(s![i, j * 2..(j + 1) * 2]) + .as_slice() + .unwrap(), + 8, + ); + + carry = AB::Expr::from(AB::F::from_u32(1 << 16).inverse()) + * (next.prev_hash[[i, j]] + work_var_limb + carry - final_hash_limb); + builder + .when(*next.flags.is_digest_row) + .assert_bool(carry.clone()); + } + // constrain the final hash limbs two at a time since we can do two checks per + // interaction + for chunk in next.final_hash.row(i).as_slice().unwrap().chunks(2) { + self.bitwise_lookup_bus + .send_range(chunk[0], chunk[1]) + .eval(builder, *next.flags.is_digest_row); + } + } + } + + fn eval_transitions(&self, builder: &mut AB, start_col: usize) { + let main = builder.main(); + let local = main.row_slice(0).unwrap(); + let next = main.row_slice(1).unwrap(); + + // Doesn't matter what column structs we use here + let local_cols: Sha2RoundColsRef = + Sha2RoundColsRef::from::(&local[start_col..start_col + C::SUBAIR_ROUND_WIDTH]); + let next_cols: Sha2RoundColsRef = + Sha2RoundColsRef::from::(&next[start_col..start_col + C::SUBAIR_ROUND_WIDTH]); + + let local_is_padding_row = local_cols.flags.is_padding_row(); + // Note that there will always be a padding row in the trace since the unpadded height is a + // multiple of 17 (SHA-256) or 21 (SHA-512, SHA-384). So the next row is padding iff the + // current block is the last block in the trace. + let next_is_padding_row = next_cols.flags.is_padding_row(); + + // If we are in a round row, the next row cannot be a padding row + builder + .when(*local_cols.flags.is_round_row) + .assert_zero(next_is_padding_row.clone()); + // The first row must be a round row + builder + .when_first_row() + .assert_one(*local_cols.flags.is_round_row); + // If we are in a padding row, the next row must also be a padding row + builder + .when_transition() + .when(local_is_padding_row.clone()) + .assert_one(next_is_padding_row.clone()); + // If we are in a digest row, the next row cannot be a digest row + builder + .when(*local_cols.flags.is_digest_row) + .assert_zero(*next_cols.flags.is_digest_row); + // Constrain how much the row index changes by + // round->round: 1 + // round->digest: 1 + // digest->round: -C::ROUND_ROWS + // digest->padding: 1 + // padding->padding: 0 + // Other transitions are not allowed by the above constraints + let delta = *local_cols.flags.is_round_row * AB::Expr::ONE + + *local_cols.flags.is_digest_row + * *next_cols.flags.is_round_row + * AB::Expr::from_usize(C::ROUND_ROWS) + * AB::Expr::NEG_ONE + + *local_cols.flags.is_digest_row * next_is_padding_row.clone() * AB::Expr::ONE; + + let local_row_idx = self.row_idx_encoder.flag_with_val::( + local_cols.flags.row_idx.to_slice().unwrap(), + &(0..=C::ROWS_PER_BLOCK).map(|i| (i, i)).collect::>(), + ); + let next_row_idx = self.row_idx_encoder.flag_with_val::( + next_cols.flags.row_idx.to_slice().unwrap(), + &(0..=C::ROWS_PER_BLOCK).map(|i| (i, i)).collect::>(), + ); + + builder + .when_transition() + .assert_eq(local_row_idx.clone() + delta, next_row_idx.clone()); + builder.when_first_row().assert_zero(local_row_idx); + + // Constrain the global block index starting with 1 so it is not the same as the padding + // rows. + // We set the global block index to 0 for padding rows + + // Global block index is 1 on first row + builder + .when_first_row() + .assert_one(*local_cols.flags.global_block_idx); + + // Global block index is constant on all rows in a block + builder.when(*local_cols.flags.is_round_row).assert_eq( + *local_cols.flags.global_block_idx, + *next_cols.flags.global_block_idx, + ); + // Global block index increases by 1 between blocks + builder + .when_transition() + .when(*local_cols.flags.is_digest_row) + .when(*next_cols.flags.is_round_row) + .assert_eq( + *local_cols.flags.global_block_idx + AB::Expr::ONE, + *next_cols.flags.global_block_idx, + ); + // Global block index is 0 on padding rows + builder + .when(local_is_padding_row.clone()) + .assert_zero(*local_cols.flags.global_block_idx); + + // Constrain that all the padding rows have the same work vars as the last block's digest + // row. We constrain elsewhere that the last block's digest row is equal to the first + // block's prev_hash. Together, this ensures that all the padding rows have the same + // work vars as the first block's prev_hash. As a result, the + // constraint_word_addition constraints in eval_work_vars() on the first row of the first + // block (i.e. when next = first_row) will correctly constrain the first 4 rounds of + // the first block. + for i in 0..C::ROUNDS_PER_ROW { + for j in 0..C::WORD_BITS { + builder.when(next_cols.flags.is_padding_row()).assert_eq( + local_cols.work_vars.a[[i, j]], + next_cols.work_vars.a[[i, j]], + ); + builder.when(next_cols.flags.is_padding_row()).assert_eq( + local_cols.work_vars.e[[i, j]], + next_cols.work_vars.e[[i, j]], + ); + } + } + + self.eval_message_schedule(builder, local_cols.clone(), next_cols.clone()); + self.eval_work_vars(builder, local_cols.clone(), next_cols); + let next: Sha2DigestColsRef = + Sha2DigestColsRef::from::(&next[start_col..start_col + C::SUBAIR_DIGEST_WIDTH]); + self.eval_digest_row(builder, local_cols, next); + let local_cols: Sha2DigestColsRef = + Sha2DigestColsRef::from::(&local[start_col..start_col + C::SUBAIR_DIGEST_WIDTH]); + self.eval_prev_hash(builder, local_cols, next_is_padding_row); + } + + /// Constrains that the next block's `prev_hash` is equal to the current block's `hash` + /// Note: the constraining is done by interactions with the chip itself on every digest row + fn eval_prev_hash( + &self, + builder: &mut AB, + local: Sha2DigestColsRef, + is_last_block_of_trace: AB::Expr, /* note this indicates the last block of the trace, + * not the last block of the message */ + ) { + // Constrain that next block's `prev_hash` is equal to the current block's `hash` + let composed_hash = (0..C::HASH_WORDS) + .map(|i| { + let hash_bits = if i < C::ROUNDS_PER_ROW { + local + .hash + .a + .row(C::ROUNDS_PER_ROW - 1 - i) + .mapv(|x| x.into()) + .to_vec() + } else { + local + .hash + .e + .row(C::ROUNDS_PER_ROW + 3 - i) + .mapv(|x| x.into()) + .to_vec() + }; + (0..C::WORD_U16S) + .map(|j| compose::(&hash_bits[j * 16..(j + 1) * 16], 1)) + .collect::>() + }) + .collect::>(); + // Need to handle the case if this is the very last block of the trace matrix + let next_global_block_idx = select( + is_last_block_of_trace, + AB::Expr::ONE, + *local.flags.global_block_idx + AB::Expr::ONE, + ); + // The following interactions constrain certain values from block to block + self.private_bus.send( + builder, + composed_hash + .into_iter() + .flatten() + .chain(once(next_global_block_idx)), + *local.flags.is_digest_row, + ); + + self.private_bus.receive( + builder, + local + .prev_hash + .flatten() + .mapv(|x| x.into()) + .into_iter() + .chain(once((*local.flags.global_block_idx).into())), + *local.flags.is_digest_row, + ); + } + + /// Constrain the message schedule additions for `next` row + /// Note: For every addition we need to constrain the following for each of [WORD_U16S] limbs + /// sig_1(w_{t-2})[i] + w_{t-7}[i] + sig_0(w_{t-15})[i] + w_{t-16}[i] + carry_w[t][i-1] - + /// carry_w[t][i] * 2^16 - w_t[i] == 0 Refer to [https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf] + fn eval_message_schedule<'a, AB: InteractionBuilder>( + &self, + builder: &mut AB, + local: Sha2RoundColsRef<'a, AB::Var>, + next: Sha2RoundColsRef<'a, AB::Var>, + ) { + // This `w` array contains 8 message schedule words - w_{idx}, ..., w_{idx+7} for some idx + let w = ndarray::concatenate( + ndarray::Axis(0), + &[local.message_schedule.w, next.message_schedule.w], + ) + .unwrap(); + + // Constrain `w_3` for `next` row + for i in 0..C::ROUNDS_PER_ROW - 1 { + // here we constrain the w_3 of the i_th word of the next row + // w_3 of next is w[i+4-3] = w[i+1] + let w_3 = w.row(i + 1).mapv(|x| x.into()).to_vec(); + let expected_w_3 = next.schedule_helper.w_3.row(i); + for j in 0..C::WORD_U16S { + let w_3_limb = compose::(&w_3[j * 16..(j + 1) * 16], 1); + builder + .when(*local.flags.is_round_row) + .assert_eq(w_3_limb, expected_w_3[j].into()); + } + } + + // Constrain intermed for `next` row + // We will only constrain intermed_12 for rows [3, C::ROUND_ROWS - 2], and let it + // unconstrained for other rows Other rows should put the needed value in + // intermed_12 to make the below summation constraint hold + let is_row_intermed_12 = self.row_idx_encoder.contains_flag_range::( + next.flags.row_idx.to_slice().unwrap(), + 3..=C::ROUND_ROWS - 2, + ); + // We will only constrain intermed_8 for rows [2, C::ROUND_ROWS - 3], and let it + // unconstrained for other rows + let is_row_intermed_8 = self.row_idx_encoder.contains_flag_range::( + next.flags.row_idx.to_slice().unwrap(), + 2..=C::ROUND_ROWS - 3, + ); + for i in 0..C::ROUNDS_PER_ROW { + // w_idx + let w_idx = w.row(i).mapv(|x| x.into()).to_vec(); + // sig_0(w_{idx+1}) + let sig_w = small_sig0_field::(w.row(i + 1).as_slice().unwrap()); + for j in 0..C::WORD_U16S { + let w_idx_limb = compose::(&w_idx[j * 16..(j + 1) * 16], 1); + let sig_w_limb = compose::(&sig_w[j * 16..(j + 1) * 16], 1); + + // We would like to constrain this only on round rows, but we can't do a conditional + // check because the degree is already 3. So we must fill in `intermed_4` with dummy + // values on the first round row and the digest row (rows 0 and 16 for SHA-256) to + // ensure the constraint holds on these rows. + builder.when_transition().assert_eq( + next.schedule_helper.intermed_4[[i, j]], + w_idx_limb + sig_w_limb, + ); + + builder.when(is_row_intermed_8.clone()).assert_eq( + next.schedule_helper.intermed_8[[i, j]], + local.schedule_helper.intermed_4[[i, j]], + ); + + builder.when(is_row_intermed_12.clone()).assert_eq( + next.schedule_helper.intermed_12[[i, j]], + local.schedule_helper.intermed_8[[i, j]], + ); + } + } + + // Constrain the message schedule additions for `next` row + for i in 0..C::ROUNDS_PER_ROW { + // Note, here by w_{t} we mean the i_th word of the `next` row + // w_{t-7} + let w_7 = if i < 3 { + local.schedule_helper.w_3.row(i).mapv(|x| x.into()).to_vec() + } else { + let w_3 = w.row(i - 3).mapv(|x| x.into()).to_vec(); + (0..C::WORD_U16S) + .map(|j| compose::(&w_3[j * 16..(j + 1) * 16], 1)) + .collect::>() + }; + // sig_0(w_{t-15}) + w_{t-16} + let intermed_16 = local.schedule_helper.intermed_12.row(i).mapv(|x| x.into()); + + let carries = (0..C::WORD_U16S) + .map(|j| { + next.message_schedule.carry_or_buffer[[i, j * 2]] + + AB::Expr::TWO * next.message_schedule.carry_or_buffer[[i, j * 2 + 1]] + }) + .collect::>(); + + // Constrain `W_{idx} = sig_1(W_{idx-2}) + W_{idx-7} + sig_0(W_{idx-15}) + W_{idx-16}` + // We would like to constrain this only on rows 4..C::ROUND_ROWS, but we can't do a + // conditional check because the degree of sum is already 3 So we must fill + // in `intermed_12` with dummy values on rows 0..3 and C::ROUND_ROWS-1 and C::ROUND_ROWS + // to ensure the constraint holds on rows 0..4 and C::ROUND_ROWS. Note that + // the dummy value goes in the previous row to make the current row's constraint hold. + constraint_word_addition::<_, C>( + // Note: here we can't do a conditional check because the degree of sum is already + // 3 + &mut builder.when_transition(), + &[&small_sig1_field::( + w.row(i + 2).as_slice().unwrap(), + )], + &[&w_7, intermed_16.as_slice().unwrap()], + w.row(i + 4).as_slice().unwrap(), + &carries, + ); + + for j in 0..C::WORD_U16S { + // When on rows 4..C::ROUND_ROWS message schedule carries should be 0 or 1 + let is_row_4_or_more = *next.flags.is_round_row - *next.flags.is_first_4_rows; + builder + .when(is_row_4_or_more.clone()) + .assert_bool(next.message_schedule.carry_or_buffer[[i, j * 2]]); + builder + .when(is_row_4_or_more) + .assert_bool(next.message_schedule.carry_or_buffer[[i, j * 2 + 1]]); + } + // Constrain w being composed of bits + for j in 0..C::WORD_BITS { + builder + .when(*next.flags.is_round_row) + .assert_bool(next.message_schedule.w[[i, j]]); + } + } + } + + /// Constrain the work vars on `next` row according to the sha documentation + /// Refer to [https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf] + fn eval_work_vars<'a, AB: InteractionBuilder>( + &self, + builder: &mut AB, + local: Sha2RoundColsRef<'a, AB::Var>, + next: Sha2RoundColsRef<'a, AB::Var>, + ) { + let a = + ndarray::concatenate(ndarray::Axis(0), &[local.work_vars.a, next.work_vars.a]).unwrap(); + let e = + ndarray::concatenate(ndarray::Axis(0), &[local.work_vars.e, next.work_vars.e]).unwrap(); + + for i in 0..C::ROUNDS_PER_ROW { + for j in 0..C::WORD_U16S { + // Although we need carry_a <= 6 and carry_e <= 5, constraining carry_a, carry_e in + // [0, 2^8) is enough to prevent overflow and ensure the soundness + // of the addition we want to check + self.bitwise_lookup_bus + .send_range( + local.work_vars.carry_a[[i, j]], + local.work_vars.carry_e[[i, j]], + ) + .eval(builder, *local.flags.is_round_row); + } + + let w_limbs = (0..C::WORD_U16S) + .map(|j| { + compose::( + next.message_schedule + .w + .slice(s![i, j * 16..(j + 1) * 16]) + .as_slice() + .unwrap(), + 1, + ) * *next.flags.is_round_row + }) + .collect::>(); + + let k_limbs = (0..C::WORD_U16S) + .map(|j| { + self.row_idx_encoder.flag_with_val::( + next.flags.row_idx.to_slice().unwrap(), + &(0..C::ROUND_ROWS) + .map(|rw_idx| { + ( + rw_idx, + word_into_u16_limbs::( + C::get_k()[rw_idx * C::ROUNDS_PER_ROW + i], + )[j] as usize, + ) + }) + .collect::>(), + ) + }) + .collect::>(); + + // Constrain `a = h + sig_1(e) + ch(e, f, g) + K + W + sig_0(a) + Maj(a, b, c)` + // We have to enforce this constraint on all rows since the degree of the constraint is + // already 3. So, we must fill in `carry_a` with dummy values on digest rows + // to ensure the constraint holds. + constraint_word_addition::<_, C>( + builder, + &[ + e.row(i).mapv(|x| x.into()).as_slice().unwrap(), // previous `h` + &big_sig1_field::(e.row(i + 3).as_slice().unwrap()), /* sig_1 of + previous `e` */ + &ch_field::( + e.row(i + 3).as_slice().unwrap(), + e.row(i + 2).as_slice().unwrap(), + e.row(i + 1).as_slice().unwrap(), + ), /* Ch of previous `e`, `f`, `g` */ + &big_sig0_field::(a.row(i + 3).as_slice().unwrap()), /* sig_0 of `a` */ + &maj_field::( + a.row(i + 3).as_slice().unwrap(), + a.row(i + 2).as_slice().unwrap(), + a.row(i + 1).as_slice().unwrap(), + ), /* Maj of previous a, b, c */ + ], + &[&w_limbs, &k_limbs], // K and W + a.row(i + 4).as_slice().unwrap(), // new `a` + next.work_vars.carry_a.row(i).as_slice().unwrap(), // carries of addition + ); + + // Constrain `e = d + h + sig_1(e) + ch(e, f, g) + K + W` + // We have to enforce this constraint on all rows since the degree of the constraint is + // already 3. So, we must fill in `carry_e` with dummy values on digest rows + // to ensure the constraint holds. + constraint_word_addition::<_, C>( + builder, + &[ + a.row(i).mapv(|x| x.into()).as_slice().unwrap(), // previous `d` + e.row(i).mapv(|x| x.into()).as_slice().unwrap(), // previous `h` + &big_sig1_field::(e.row(i + 3).as_slice().unwrap()), /* sig_1 of + previous `e` */ + &ch_field::( + e.row(i + 3).as_slice().unwrap(), + e.row(i + 2).as_slice().unwrap(), + e.row(i + 1).as_slice().unwrap(), + ), /* Ch of previous `e`, `f`, `g` */ + ], + &[&w_limbs, &k_limbs], // K and W + e.row(i + 4).as_slice().unwrap(), // new `e` + next.work_vars.carry_e.row(i).as_slice().unwrap(), // carries of addition + ); + } + } +} diff --git a/crates/circuits/sha2-air/src/columns.rs b/crates/circuits/sha2-air/src/columns.rs new file mode 100644 index 0000000000..01088cbc54 --- /dev/null +++ b/crates/circuits/sha2-air/src/columns.rs @@ -0,0 +1,170 @@ +//! WARNING: the order of fields in the structs is important, do not change it + +use core::ops::Add; + +use openvm_circuit_primitives::utils::not; +use openvm_circuit_primitives_derive::ColsRef; +use openvm_stark_backend::p3_field::PrimeCharacteristicRing; + +use crate::Sha2BlockHasherSubairConfig; + +/// In each SHA block: +/// - First C::ROUND_ROWS rows use Sha2RoundCols +/// - Final row uses Sha2DigestCols +/// +/// Note that for soundness, we require that there is always a padding row after the last digest row +/// in the trace. Right now, this is true because the unpadded height is a multiple of 17 (SHA-256) +/// or 21 (SHA-512), and thus not a power of 2. +/// +/// Sha2RoundCols and Sha2DigestCols share the same first 3 fields: +/// - flags +/// - work_vars/hash (same type, different name) +/// - schedule_helper +/// +/// This design allows for: +/// 1. Common constraints to work on either struct type by accessing these shared fields +/// 2. Specific constraints to use the appropriate struct, with flags helping to do conditional +/// constraints +/// +/// Note that the `Sha2WorkVarsCols` field is used for different purposes in the two structs. +#[repr(C)] +#[derive(Clone, Copy, Debug, ColsRef)] +#[config(Sha2BlockHasherSubairConfig)] +pub struct Sha2RoundCols< + T, + const WORD_BITS: usize, + const WORD_U8S: usize, + const WORD_U16S: usize, + const ROUNDS_PER_ROW: usize, + const ROUNDS_PER_ROW_MINUS_ONE: usize, + const ROW_VAR_CNT: usize, +> { + pub flags: Sha2FlagsCols, + pub work_vars: Sha2WorkVarsCols, + pub schedule_helper: + Sha2MessageHelperCols, + pub message_schedule: Sha2MessageScheduleCols, +} + +#[repr(C)] +#[derive(Clone, Copy, Debug, ColsRef)] +#[config(Sha2BlockHasherSubairConfig)] +pub struct Sha2DigestCols< + T, + const WORD_BITS: usize, + const WORD_U8S: usize, + const WORD_U16S: usize, + const HASH_WORDS: usize, + const ROUNDS_PER_ROW: usize, + const ROUNDS_PER_ROW_MINUS_ONE: usize, + const ROW_VAR_CNT: usize, +> { + pub flags: Sha2FlagsCols, + /// Will serve as previous hash values for the next block + pub hash: Sha2WorkVarsCols, + pub schedule_helper: + Sha2MessageHelperCols, + /// The actual final hash values of the given block + /// Note: the above `hash` will be equal to `final_hash` unless we are on the last block + pub final_hash: [[T; WORD_U8S]; HASH_WORDS], + /// The final hash of the previous block + /// Note: will be constrained using interactions with the chip itself + pub prev_hash: [[T; WORD_U16S]; HASH_WORDS], +} + +#[repr(C)] +#[derive(Clone, Copy, Debug, ColsRef)] +#[config(Sha2BlockHasherSubairConfig)] +pub struct Sha2MessageScheduleCols< + T, + const WORD_BITS: usize, + const ROUNDS_PER_ROW: usize, + const WORD_U8S: usize, +> { + /// The message schedule words as bits + /// The first 16 words will be the message data + pub w: [[T; WORD_BITS]; ROUNDS_PER_ROW], + /// Will be message schedule carries for rows 4..C::ROUND_ROWS and a buffer for rows 0..4 to be + /// used freely by wrapper chips Note: carries are 2 bit numbers represented using 2 cells + /// as individual bits + /// Note: carry_or_buffer is left unconstrained on rounds 0..3 + pub carry_or_buffer: [[T; WORD_U8S]; ROUNDS_PER_ROW], +} + +#[repr(C)] +#[derive(Clone, Copy, Debug, ColsRef)] +#[config(Sha2BlockHasherSubairConfig)] +pub struct Sha2WorkVarsCols< + T, + const WORD_BITS: usize, + const ROUNDS_PER_ROW: usize, + const WORD_U16S: usize, +> { + /// `a` and `e` after each iteration as 32-bits + pub a: [[T; WORD_BITS]; ROUNDS_PER_ROW], + pub e: [[T; WORD_BITS]; ROUNDS_PER_ROW], + /// The carry's used for addition during each iteration when computing `a` and `e` + pub carry_a: [[T; WORD_U16S]; ROUNDS_PER_ROW], + pub carry_e: [[T; WORD_U16S]; ROUNDS_PER_ROW], +} + +/// These are the columns that are used to help with the message schedule additions +/// Note: these need to be correctly assigned for every row even on padding rows +#[repr(C)] +#[derive(Clone, Copy, Debug, ColsRef)] +#[config(Sha2BlockHasherSubairConfig)] +pub struct Sha2MessageHelperCols< + T, + const WORD_U16S: usize, + const ROUNDS_PER_ROW: usize, + const ROUNDS_PER_ROW_MINUS_ONE: usize, +> { + /// The following are used to move data forward to constrain the message schedule additions + /// The value of `w` from 3 rounds ago + pub w_3: [[T; WORD_U16S]; ROUNDS_PER_ROW_MINUS_ONE], + /// Here intermediate(i) = w_i + sig_0(w_{i+1}) + /// Intermed_t represents the intermediate t rounds ago + /// This is needed to constrain the message schedule, since we can only constrain on two rows + /// at a time + pub intermed_4: [[T; WORD_U16S]; ROUNDS_PER_ROW], + pub intermed_8: [[T; WORD_U16S]; ROUNDS_PER_ROW], + pub intermed_12: [[T; WORD_U16S]; ROUNDS_PER_ROW], +} + +#[repr(C)] +#[derive(Clone, Copy, Debug, ColsRef)] +#[config(Sha2BlockHasherSubairConfig)] +pub struct Sha2FlagsCols { + pub is_round_row: T, + /// A flag that indicates if the current row is among the first 4 rows of a block (the message + /// rows) + pub is_first_4_rows: T, + pub is_digest_row: T, + /// We will encode the row index [0..C::ROWS_PER_BLOCK] using ROW_VAR_CNT cells + pub row_idx: [T; ROW_VAR_CNT], + /// The global index of the current block, starts at 1 for the first block + /// and increments by 1 for each block. Set to 0 for padding rows. + pub global_block_idx: T, +} + +impl Sha2FlagsColsRef<'_, T> +where + T: Add + Copy, +{ + // This refers to the padding rows that are added to the air to make the trace length a power of + // 2. Not to be confused with the padding added to messages as part of the SHA hash + // function. + pub fn is_not_padding_row(&self) -> O { + *self.is_round_row + *self.is_digest_row + } + + // This refers to the padding rows that are added to the air to make the trace length a power of + // 2. Not to be confused with the padding added to messages as part of the SHA hash + // function. + pub fn is_padding_row(&self) -> O + where + O: PrimeCharacteristicRing, + { + not(self.is_not_padding_row()) + } +} diff --git a/crates/circuits/sha2-air/src/config.rs b/crates/circuits/sha2-air/src/config.rs new file mode 100644 index 0000000000..74f087a2b7 --- /dev/null +++ b/crates/circuits/sha2-air/src/config.rs @@ -0,0 +1,323 @@ +use std::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr}; + +use crate::{Sha2DigestColsRef, Sha2RoundColsRef}; + +#[repr(u32)] +#[derive(num_enum::TryFromPrimitive, num_enum::IntoPrimitive, Copy, Clone, Debug)] +pub enum Sha2Variant { + Sha256, + Sha512, + Sha384, +} + +pub trait Sha2BlockHasherSubairConfig: Send + Sync + Clone { + // --- Required --- + + type Word: 'static + + Shr + + Shl + + BitAnd + + Not + + BitXor + + BitOr + + RotateRight + + WrappingAdd + + PartialEq + + From + + TryInto + + Copy + + Send + + Sync; + // Differentiate between the SHA-2 variants + const VARIANT: Sha2Variant; + /// Number of bits in a SHA word + const WORD_BITS: usize; + /// Number of words in a SHA block + const BLOCK_WORDS: usize; + /// Number of rows per block + const ROWS_PER_BLOCK: usize; + /// Number of rounds per row. Must divide Self::ROUNDS_PER_BLOCK + const ROUNDS_PER_ROW: usize; + /// Number of rounds per block. Must be a multiple of Self::ROUNDS_PER_ROW + const ROUNDS_PER_BLOCK: usize; + /// Number of words in a SHA hash + const HASH_WORDS: usize; + /// Number of vars needed to encode the row index with [Encoder] + const ROW_VAR_CNT: usize; + + /// We also store the SHA constants K and H + fn get_k() -> &'static [Self::Word]; + fn get_h() -> &'static [Self::Word]; + + // --- Provided --- + + /// Number of 16-bit limbs in a SHA word + const WORD_U16S: usize = Self::WORD_BITS / 16; + /// Number of 8-bit limbs in a SHA word + const WORD_U8S: usize = Self::WORD_BITS / 8; + /// Number of cells in a SHA block + const BLOCK_U8S: usize = Self::BLOCK_WORDS * Self::WORD_U8S; + /// Number of bits in a SHA block + const BLOCK_BITS: usize = Self::BLOCK_WORDS * Self::WORD_BITS; + /// Number of rows used for the sha rounds + const ROUND_ROWS: usize = Self::ROUNDS_PER_BLOCK / Self::ROUNDS_PER_ROW; + /// Number of rows used for the message + const MESSAGE_ROWS: usize = Self::BLOCK_WORDS / Self::ROUNDS_PER_ROW; + /// Number of rounds per row minus one (needed for one of the column structs) + const ROUNDS_PER_ROW_MINUS_ONE: usize = Self::ROUNDS_PER_ROW - 1; + /// Width of the Sha2RoundCols + const SUBAIR_ROUND_WIDTH: usize = Sha2RoundColsRef::::width::(); + /// Width of the Sha2DigestCols + const SUBAIR_DIGEST_WIDTH: usize = Sha2DigestColsRef::::width::(); + /// Width of the Sha2BlockHasherCols + const SUBAIR_WIDTH: usize = if Self::SUBAIR_ROUND_WIDTH > Self::SUBAIR_DIGEST_WIDTH { + Self::SUBAIR_ROUND_WIDTH + } else { + Self::SUBAIR_DIGEST_WIDTH + }; +} + +#[derive(Clone)] +pub struct Sha256Config; + +#[derive(Clone)] +pub struct Sha512Config; + +#[derive(Clone)] +pub struct Sha384Config; + +impl Sha2BlockHasherSubairConfig for Sha256Config { + // ==== Do not change these constants! ==== + const VARIANT: Sha2Variant = Sha2Variant::Sha256; + type Word = u32; + /// Number of bits in a SHA256 word + const WORD_BITS: usize = 32; + /// Number of words in a SHA256 block + const BLOCK_WORDS: usize = 16; + /// Number of rows per block + const ROWS_PER_BLOCK: usize = 17; + /// Number of rounds per row + const ROUNDS_PER_ROW: usize = 4; + /// Number of rounds per block + const ROUNDS_PER_BLOCK: usize = 64; + /// Number of words in a SHA256 hash + const HASH_WORDS: usize = 8; + /// Number of vars needed to encode the row index with [Encoder] + const ROW_VAR_CNT: usize = 5; + + fn get_k() -> &'static [u32] { + &SHA256_K + } + fn get_h() -> &'static [u32] { + &SHA256_H + } +} + +/// SHA256 constant K's +pub const SHA256_K: [u32; 64] = [ + 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, + 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, + 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, + 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, + 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, + 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, + 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, + 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2, +]; +/// SHA256 initial hash values +pub const SHA256_H: [u32; 8] = [ + 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19, +]; + +impl Sha2BlockHasherSubairConfig for Sha512Config { + // ==== Do not change these constants! ==== + const VARIANT: Sha2Variant = Sha2Variant::Sha512; + type Word = u64; + /// Number of bits in a SHA512 word + const WORD_BITS: usize = 64; + /// Number of words in a SHA512 block + const BLOCK_WORDS: usize = 16; + /// Number of rows per block + const ROWS_PER_BLOCK: usize = 21; + /// Number of rounds per row + const ROUNDS_PER_ROW: usize = 4; + /// Number of rounds per block + const ROUNDS_PER_BLOCK: usize = 80; + /// Number of words in a SHA512 hash + const HASH_WORDS: usize = 8; + /// Number of vars needed to encode the row index with [Encoder] + const ROW_VAR_CNT: usize = 6; + + fn get_k() -> &'static [u64] { + &SHA512_K + } + fn get_h() -> &'static [u64] { + &SHA512_H + } +} + +/// SHA512 constant K's +pub const SHA512_K: [u64; 80] = [ + 0x428a2f98d728ae22, + 0x7137449123ef65cd, + 0xb5c0fbcfec4d3b2f, + 0xe9b5dba58189dbbc, + 0x3956c25bf348b538, + 0x59f111f1b605d019, + 0x923f82a4af194f9b, + 0xab1c5ed5da6d8118, + 0xd807aa98a3030242, + 0x12835b0145706fbe, + 0x243185be4ee4b28c, + 0x550c7dc3d5ffb4e2, + 0x72be5d74f27b896f, + 0x80deb1fe3b1696b1, + 0x9bdc06a725c71235, + 0xc19bf174cf692694, + 0xe49b69c19ef14ad2, + 0xefbe4786384f25e3, + 0x0fc19dc68b8cd5b5, + 0x240ca1cc77ac9c65, + 0x2de92c6f592b0275, + 0x4a7484aa6ea6e483, + 0x5cb0a9dcbd41fbd4, + 0x76f988da831153b5, + 0x983e5152ee66dfab, + 0xa831c66d2db43210, + 0xb00327c898fb213f, + 0xbf597fc7beef0ee4, + 0xc6e00bf33da88fc2, + 0xd5a79147930aa725, + 0x06ca6351e003826f, + 0x142929670a0e6e70, + 0x27b70a8546d22ffc, + 0x2e1b21385c26c926, + 0x4d2c6dfc5ac42aed, + 0x53380d139d95b3df, + 0x650a73548baf63de, + 0x766a0abb3c77b2a8, + 0x81c2c92e47edaee6, + 0x92722c851482353b, + 0xa2bfe8a14cf10364, + 0xa81a664bbc423001, + 0xc24b8b70d0f89791, + 0xc76c51a30654be30, + 0xd192e819d6ef5218, + 0xd69906245565a910, + 0xf40e35855771202a, + 0x106aa07032bbd1b8, + 0x19a4c116b8d2d0c8, + 0x1e376c085141ab53, + 0x2748774cdf8eeb99, + 0x34b0bcb5e19b48a8, + 0x391c0cb3c5c95a63, + 0x4ed8aa4ae3418acb, + 0x5b9cca4f7763e373, + 0x682e6ff3d6b2b8a3, + 0x748f82ee5defb2fc, + 0x78a5636f43172f60, + 0x84c87814a1f0ab72, + 0x8cc702081a6439ec, + 0x90befffa23631e28, + 0xa4506cebde82bde9, + 0xbef9a3f7b2c67915, + 0xc67178f2e372532b, + 0xca273eceea26619c, + 0xd186b8c721c0c207, + 0xeada7dd6cde0eb1e, + 0xf57d4f7fee6ed178, + 0x06f067aa72176fba, + 0x0a637dc5a2c898a6, + 0x113f9804bef90dae, + 0x1b710b35131c471b, + 0x28db77f523047d84, + 0x32caab7b40c72493, + 0x3c9ebe0a15c9bebc, + 0x431d67c49c100d4c, + 0x4cc5d4becb3e42b6, + 0x597f299cfc657e2a, + 0x5fcb6fab3ad6faec, + 0x6c44198c4a475817, +]; +/// SHA512 initial hash values +pub const SHA512_H: [u64; 8] = [ + 0x6a09e667f3bcc908, + 0xbb67ae8584caa73b, + 0x3c6ef372fe94f82b, + 0xa54ff53a5f1d36f1, + 0x510e527fade682d1, + 0x9b05688c2b3e6c1f, + 0x1f83d9abfb41bd6b, + 0x5be0cd19137e2179, +]; + +impl Sha2BlockHasherSubairConfig for Sha384Config { + // ==== Do not change these constants! ==== + const VARIANT: Sha2Variant = Sha2Variant::Sha384; + type Word = ::Word; + /// Number of bits in a SHA384 word + const WORD_BITS: usize = ::WORD_BITS; + /// Number of words in a SHA384 block + const BLOCK_WORDS: usize = ::BLOCK_WORDS; + /// Number of rows per block + const ROWS_PER_BLOCK: usize = ::ROWS_PER_BLOCK; + /// Number of rounds per row + const ROUNDS_PER_ROW: usize = ::ROUNDS_PER_ROW; + /// Number of rounds per block + const ROUNDS_PER_BLOCK: usize = ::ROUNDS_PER_BLOCK; + /// Number of words in a SHA384 hash + const HASH_WORDS: usize = ::HASH_WORDS; + /// Number of vars needed to encode the row index with [Encoder] + const ROW_VAR_CNT: usize = ::ROW_VAR_CNT; + + fn get_k() -> &'static [u64] { + &SHA384_K + } + fn get_h() -> &'static [u64] { + &SHA384_H + } +} + +/// SHA384 constant K's +pub const SHA384_K: [u64; 80] = SHA512_K; + +/// SHA384 initial hash values +pub const SHA384_H: [u64; 8] = [ + 0xcbbb9d5dc1059ed8, + 0x629a292a367cd507, + 0x9159015a3070dd17, + 0x152fecd8f70e5939, + 0x67332667ffc00b31, + 0x8eb44a8768581511, + 0xdb0c2e0d64f98fa7, + 0x47b5481dbefa4fa4, +]; + +// Needed to avoid compile errors in utils.rs +// not sure why this doesn't inf loop +pub trait RotateRight { + fn rotate_right(self, n: u32) -> Self; +} +impl RotateRight for u32 { + fn rotate_right(self, n: u32) -> Self { + self.rotate_right(n) + } +} +impl RotateRight for u64 { + fn rotate_right(self, n: u32) -> Self { + self.rotate_right(n) + } +} +pub trait WrappingAdd { + fn wrapping_add(self, n: Self) -> Self; +} +impl WrappingAdd for u32 { + fn wrapping_add(self, n: u32) -> Self { + self.wrapping_add(n) + } +} +impl WrappingAdd for u64 { + fn wrapping_add(self, n: u64) -> Self { + self.wrapping_add(n) + } +} diff --git a/crates/circuits/sha2-air/src/lib.rs b/crates/circuits/sha2-air/src/lib.rs new file mode 100644 index 0000000000..8c86ae4f27 --- /dev/null +++ b/crates/circuits/sha2-air/src/lib.rs @@ -0,0 +1,11 @@ +mod air; +mod columns; +mod config; +mod trace; +mod utils; + +pub use air::*; +pub use columns::*; +pub use config::*; +pub use trace::*; +pub use utils::*; diff --git a/crates/circuits/sha2-air/src/trace.rs b/crates/circuits/sha2-air/src/trace.rs new file mode 100644 index 0000000000..243f463687 --- /dev/null +++ b/crates/circuits/sha2-air/src/trace.rs @@ -0,0 +1,663 @@ +use std::{marker::PhantomData, ops::Range}; + +use openvm_circuit_primitives::{ + bitwise_op_lookup::SharedBitwiseOperationLookupChip, encoder::Encoder, utils::compose, +}; +use openvm_stark_backend::p3_field::PrimeField32; +use sha2::{compress256, compress512, digest::generic_array::GenericArray}; + +use crate::{ + big_sig0, big_sig0_field, big_sig1, big_sig1_field, ch, ch_field, get_flag_pt_array, + le_limbs_into_word, maj, maj_field, set_arrayview_from_u32_slice, small_sig0, small_sig0_field, + small_sig1, small_sig1_field, word_into_bits, word_into_u16_limbs, word_into_u8_limbs, + Sha2BlockHasherSubairConfig, Sha2DigestColsRefMut, Sha2RoundColsRef, Sha2RoundColsRefMut, + Sha2Variant, WrappingAdd, +}; + +/// A helper struct for the SHA-2 trace generation. +/// Also, separates the inner AIR from the trace generation. +pub struct Sha2BlockHasherFillerHelper { + pub row_idx_encoder: Encoder, + _phantom: PhantomData, +} + +impl Default for Sha2BlockHasherFillerHelper { + fn default() -> Self { + Self::new() + } +} + +/// The trace generation of SHA-2 should be done in two passes. +/// The first pass should do `get_block_trace` for every block and generate the invalid rows through +/// `get_default_row` The second pass should go through all the blocks and call +/// `generate_missing_cells` +impl Sha2BlockHasherFillerHelper { + pub fn new() -> Self { + Self { + row_idx_encoder: Encoder::new(C::ROWS_PER_BLOCK + 1, 2, false), + _phantom: PhantomData, + } + } + + /// This function takes the input_message (padding not handled), the previous hash, + /// and returns the new hash after processing the block input + pub fn get_block_hash(prev_hash: &[C::Word], input: Vec) -> Vec { + debug_assert!(prev_hash.len() == C::HASH_WORDS); + debug_assert!(input.len() == C::BLOCK_U8S); + let mut new_hash: [C::Word; 8] = prev_hash.try_into().unwrap(); + match C::VARIANT { + Sha2Variant::Sha256 => { + let input_array = [*GenericArray::::from_slice( + &input, + )]; + let hash_ptr: &mut [u32; 8] = unsafe { std::mem::transmute(&mut new_hash) }; + compress256(hash_ptr, &input_array); + } + Sha2Variant::Sha512 | Sha2Variant::Sha384 => { + let hash_ptr: &mut [u64; 8] = unsafe { std::mem::transmute(&mut new_hash) }; + let input_array = [*GenericArray::::from_slice( + &input, + )]; + compress512(hash_ptr, &input_array); + } + } + new_hash.to_vec() + } + + /// This function takes a C::BLOCK_BITS-bit chunk of the input message (padding not handled), + /// the previous hash, a flag indicating if it's the last block, the global block index, the + /// local block index, and the buffer values that will be put in rows 0..4. + /// Will populate the given `trace` with the trace of the block, where the width of the trace is + /// `trace_width` and the starting column for the `Sha2Air` is `trace_start_col`. + /// **Note**: this function only generates some of the required trace. Another pass is required, + /// refer to [`Self::generate_missing_cells`] for details. + #[allow(clippy::too_many_arguments)] + pub fn generate_block_trace( + &self, + trace: &mut [F], + trace_width: usize, + trace_start_col: usize, + input: &[C::Word], + bitwise_lookup_chip: SharedBitwiseOperationLookupChip<8>, + prev_hash: &[C::Word], + next_block_prev_hash: &[C::Word], + global_block_idx: u32, + ) { + #[cfg(debug_assertions)] + { + assert!(input.len() == C::BLOCK_WORDS); + assert!(prev_hash.len() == C::HASH_WORDS); + assert!(next_block_prev_hash.len() == C::HASH_WORDS); + assert!(trace_start_col + C::SUBAIR_WIDTH == trace_width); + assert!(trace.len() == trace_width * C::ROWS_PER_BLOCK); + } + + let get_range = |start: usize, len: usize| -> Range { start..start + len }; + let mut message_schedule = vec![C::Word::from(0); C::ROUNDS_PER_BLOCK]; + message_schedule[..input.len()].copy_from_slice(input); + let mut work_vars = prev_hash.to_vec(); + for (i, row) in trace.chunks_exact_mut(trace_width).enumerate() { + // do the rounds + if i < C::ROUND_ROWS { + let mut cols: Sha2RoundColsRefMut = Sha2RoundColsRefMut::from::( + &mut row[get_range(trace_start_col, C::SUBAIR_ROUND_WIDTH)], + ); + *cols.flags.is_round_row = F::ONE; + *cols.flags.is_first_4_rows = if i < C::MESSAGE_ROWS { F::ONE } else { F::ZERO }; + *cols.flags.is_digest_row = F::ZERO; + set_arrayview_from_u32_slice( + &mut cols.flags.row_idx, + get_flag_pt_array(&self.row_idx_encoder, i), + ); + *cols.flags.global_block_idx = F::from_u32(global_block_idx); + + // W_idx = M_idx + if i < C::MESSAGE_ROWS { + for j in 0..C::ROUNDS_PER_ROW { + set_arrayview_from_u32_slice( + &mut cols.message_schedule.w.row_mut(j), + word_into_bits::(input[i * C::ROUNDS_PER_ROW + j]), + ); + } + } + // W_idx = SIG1(W_{idx-2}) + W_{idx-7} + SIG0(W_{idx-15}) + W_{idx-16} + else { + for j in 0..C::ROUNDS_PER_ROW { + let idx = i * C::ROUNDS_PER_ROW + j; + let nums: [C::Word; 4] = [ + small_sig1::(message_schedule[idx - 2]), + message_schedule[idx - 7], + small_sig0::(message_schedule[idx - 15]), + message_schedule[idx - 16], + ]; + let w: C::Word = nums + .iter() + .fold(C::Word::from(0), |acc, &num| acc.wrapping_add(num)); + set_arrayview_from_u32_slice( + &mut cols.message_schedule.w.row_mut(j), + word_into_bits::(w), + ); + let nums_limbs = nums + .iter() + .map(|x| word_into_u16_limbs::(*x)) + .collect::>(); + let w_limbs = word_into_u16_limbs::(w); + + // fill in the carrys + for k in 0..C::WORD_U16S { + let mut sum = nums_limbs.iter().fold(0, |acc, num| acc + num[k]); + if k > 0 { + sum += (cols.message_schedule.carry_or_buffer[[j, k * 2 - 2]] + + F::TWO + * cols.message_schedule.carry_or_buffer[[j, k * 2 - 1]]) + .as_canonical_u32(); + } + let carry = (sum - w_limbs[k]) >> 16; + cols.message_schedule.carry_or_buffer[[j, k * 2]] = + F::from_u32(carry & 1); + cols.message_schedule.carry_or_buffer[[j, k * 2 + 1]] = + F::from_u32(carry >> 1); + } + // update the message schedule + message_schedule[idx] = w; + } + } + // fill in the work variables + for j in 0..C::ROUNDS_PER_ROW { + // t1 = h + SIG1(e) + ch(e, f, g) + K_idx + W_idx + let t1 = [ + work_vars[7], + big_sig1::(work_vars[4]), + ch::(work_vars[4], work_vars[5], work_vars[6]), + C::get_k()[i * C::ROUNDS_PER_ROW + j], + le_limbs_into_word::( + cols.message_schedule + .w + .row(j) + .map(|f| f.as_canonical_u32()) + .as_slice() + .unwrap(), + ), + ]; + let t1_sum: C::Word = t1 + .iter() + .fold(C::Word::from(0), |acc, &num| acc.wrapping_add(num)); + + // t2 = SIG0(a) + maj(a, b, c) + let t2 = [ + big_sig0::(work_vars[0]), + maj::(work_vars[0], work_vars[1], work_vars[2]), + ]; + + let t2_sum: C::Word = t2 + .iter() + .fold(C::Word::from(0), |acc, &num| acc.wrapping_add(num)); + + // e = d + t1 + let e = work_vars[3].wrapping_add(t1_sum); + set_arrayview_from_u32_slice( + &mut cols.work_vars.e.row_mut(j), + word_into_bits::(e), + ); + let e_limbs = word_into_u16_limbs::(e); + // a = t1 + t2 + let a = t1_sum.wrapping_add(t2_sum); + set_arrayview_from_u32_slice( + &mut cols.work_vars.a.row_mut(j), + word_into_bits::(a), + ); + let a_limbs = word_into_u16_limbs::(a); + // fill in the carrys + for k in 0..C::WORD_U16S { + let t1_limb = t1 + .iter() + .fold(0, |acc, &num| acc + word_into_u16_limbs::(num)[k]); + let t2_limb = t2 + .iter() + .fold(0, |acc, &num| acc + word_into_u16_limbs::(num)[k]); + + let mut e_limb = t1_limb + word_into_u16_limbs::(work_vars[3])[k]; + let mut a_limb = t1_limb + t2_limb; + if k > 0 { + a_limb += cols.work_vars.carry_a[[j, k - 1]].as_canonical_u32(); + e_limb += cols.work_vars.carry_e[[j, k - 1]].as_canonical_u32(); + } + let carry_a = (a_limb - a_limbs[k]) >> 16; + let carry_e = (e_limb - e_limbs[k]) >> 16; + cols.work_vars.carry_a[[j, k]] = F::from_u32(carry_a); + cols.work_vars.carry_e[[j, k]] = F::from_u32(carry_e); + bitwise_lookup_chip.request_range(carry_a, carry_e); + } + + // update working variables + work_vars[7] = work_vars[6]; + work_vars[6] = work_vars[5]; + work_vars[5] = work_vars[4]; + work_vars[4] = e; + work_vars[3] = work_vars[2]; + work_vars[2] = work_vars[1]; + work_vars[1] = work_vars[0]; + work_vars[0] = a; + } + + // filling w_3 and intermed_4 here and the rest later + if i > 0 { + for j in 0..C::ROUNDS_PER_ROW { + let idx = i * C::ROUNDS_PER_ROW + j; + let w_4 = word_into_u16_limbs::(message_schedule[idx - 4]); + let sig_0_w_3 = + word_into_u16_limbs::(small_sig0::(message_schedule[idx - 3])); + set_arrayview_from_u32_slice( + &mut cols.schedule_helper.intermed_4.row_mut(j), + (0..C::WORD_U16S) + .map(|k| w_4[k] + sig_0_w_3[k]) + .collect::>(), + ); + if j < C::ROUNDS_PER_ROW - 1 { + let w_3 = message_schedule[idx - 3]; + set_arrayview_from_u32_slice( + &mut cols.schedule_helper.w_3.row_mut(j), + word_into_u16_limbs::(w_3), + ); + } + } + } + } + // generate the digest row + else { + let mut cols: Sha2DigestColsRefMut = Sha2DigestColsRefMut::from::( + &mut row[get_range(trace_start_col, C::SUBAIR_DIGEST_WIDTH)], + ); + for j in 0..C::ROUNDS_PER_ROW - 1 { + let w_3 = message_schedule[i * C::ROUNDS_PER_ROW + j - 3]; + set_arrayview_from_u32_slice( + &mut cols.schedule_helper.w_3.row_mut(j), + word_into_u16_limbs::(w_3), + ); + } + *cols.flags.is_round_row = F::ZERO; + *cols.flags.is_first_4_rows = F::ZERO; + *cols.flags.is_digest_row = F::ONE; + set_arrayview_from_u32_slice( + &mut cols.flags.row_idx, + get_flag_pt_array(&self.row_idx_encoder, C::ROUND_ROWS), + ); + *cols.flags.global_block_idx = F::from_u32(global_block_idx); + + let final_hash: Vec = (0..C::HASH_WORDS) + .map(|i| work_vars[i].wrapping_add(prev_hash[i])) + .collect(); + let final_hash_limbs: Vec> = final_hash + .iter() + .map(|word| word_into_u8_limbs::(*word)) + .collect(); + // need to ensure final hash limbs are bytes, in order for + // prev_hash[i] + work_vars[i] == final_hash[i] + // to be constrained correctly + for word in final_hash_limbs.iter() { + for chunk in word.chunks(2) { + bitwise_lookup_chip.request_range(chunk[0], chunk[1]); + } + } + set_arrayview_from_u32_slice( + &mut cols.final_hash, + final_hash + .iter() + .flat_map(|word| word_into_u8_limbs::(*word)), + ); + set_arrayview_from_u32_slice( + &mut cols.prev_hash, + prev_hash + .iter() + .flat_map(|word| word_into_u16_limbs::(*word)), + ); + let next_block_prev_hash_bits = next_block_prev_hash + .iter() + .map(|x| word_into_bits::(*x)) + .collect::>(); + + for i in 0..C::ROUNDS_PER_ROW { + set_arrayview_from_u32_slice( + &mut cols.hash.a.row_mut(i), + next_block_prev_hash_bits[C::ROUNDS_PER_ROW - i - 1].clone(), + ); + set_arrayview_from_u32_slice( + &mut cols.hash.e.row_mut(i), + next_block_prev_hash_bits[C::ROUNDS_PER_ROW - i + 3].clone(), + ); + } + } + } + + for i in 0..C::ROWS_PER_BLOCK - 1 { + let rows = &mut trace[i * trace_width..(i + 2) * trace_width]; + let (local, next) = rows.split_at_mut(trace_width); + let mut local_cols: Sha2RoundColsRefMut = Sha2RoundColsRefMut::from::( + &mut local[get_range(trace_start_col, C::SUBAIR_ROUND_WIDTH)], + ); + let mut next_cols: Sha2RoundColsRefMut = Sha2RoundColsRefMut::from::( + &mut next[get_range(trace_start_col, C::SUBAIR_ROUND_WIDTH)], + ); + if i > 0 { + for j in 0..C::ROUNDS_PER_ROW { + next_cols + .schedule_helper + .intermed_8 + .row_mut(j) + .assign(&local_cols.schedule_helper.intermed_4.row(j)); + if (2..C::ROWS_PER_BLOCK - 3).contains(&i) { + next_cols + .schedule_helper + .intermed_12 + .row_mut(j) + .assign(&local_cols.schedule_helper.intermed_8.row(j)); + } + } + } + if i == C::ROWS_PER_BLOCK - 2 { + // `next` is a digest row. + // Fill in `carry_a` and `carry_e` with dummy values so the constraints on `a` and + // `e` hold. + let const_local_cols = Sha2RoundColsRef::::from_mut::(&local_cols); + Self::generate_carry_ae(const_local_cols.clone(), &mut next_cols); + + // Fill in row 16's `intermed_4` with dummy values so the message schedule + // constraints holds on that row + Self::generate_intermed_4(const_local_cols, &mut next_cols); + } + if i < C::MESSAGE_ROWS - 1 { + // i is in 0..3. + // Fill in `local.intermed_12` with dummy values so the message schedule constraints + // hold on rows 1..4. + Self::generate_intermed_12( + &mut local_cols, + Sha2RoundColsRef::::from_mut::(&next_cols), + ); + } + } + } + + /// This function will fill in the cells that we couldn't do during the first pass. + /// This function should be called only after `generate_block_trace` was called for all blocks + /// And [`Self::generate_default_row`] is called for all invalid rows + /// Will populate the missing values of `trace`, where the width of the trace is `trace_width` + /// Note: `trace` needs to be the rows 1..C::ROWS_PER_BLOCK of a block and the first row of the + /// next block + pub fn generate_missing_cells( + &self, + trace: &mut [F], + trace_width: usize, + trace_start_col: usize, + ) { + let rows = &mut trace[(C::ROUND_ROWS - 2) * trace_width..(C::ROUND_ROWS + 1) * trace_width]; + let (last_round_row, rows) = rows.split_at_mut(trace_width); + let (digest_row, next_block_first_row) = rows.split_at_mut(trace_width); + let mut cols_last_round_row: Sha2RoundColsRefMut = Sha2RoundColsRefMut::from::( + &mut last_round_row[trace_start_col..trace_start_col + C::SUBAIR_ROUND_WIDTH], + ); + let mut cols_digest_row: Sha2RoundColsRefMut = Sha2RoundColsRefMut::from::( + &mut digest_row[trace_start_col..trace_start_col + C::SUBAIR_ROUND_WIDTH], + ); + let mut cols_next_block_first_row: Sha2RoundColsRefMut = Sha2RoundColsRefMut::from::( + &mut next_block_first_row[trace_start_col..trace_start_col + C::SUBAIR_ROUND_WIDTH], + ); + // Fill in the last round row's `intermed_12` with dummy values so the message schedule + // constraints holds on the last round row + Self::generate_intermed_12( + &mut cols_last_round_row, + Sha2RoundColsRef::from_mut::(&cols_digest_row), + ); + // Fill in the digest row's `intermed_12` with dummy values so the message schedule + // constraints holds on the next block's row 0 + Self::generate_intermed_12( + &mut cols_digest_row, + Sha2RoundColsRef::from_mut::(&cols_next_block_first_row), + ); + // Fill in the next block's first row's `intermed_4` with dummy values so the message + // schedule constraints holds on that row + Self::generate_intermed_4( + Sha2RoundColsRef::from_mut::(&cols_digest_row), + &mut cols_next_block_first_row, + ); + } + + /// Fills the `cols` as a padding row + /// Note: we still need to correctly fill in the hash values, carries and intermeds + pub fn generate_default_row( + &self, + cols: &mut Sha2RoundColsRefMut, + first_block_prev_hash: &[C::Word], + carry_a: Option<&[F]>, + carry_e: Option<&[F]>, + ) { + debug_assert!(first_block_prev_hash.len() == C::HASH_WORDS); + debug_assert!(carry_a.is_some() == carry_e.is_some()); + debug_assert!( + carry_a.is_none() || carry_a.unwrap().len() == C::ROUNDS_PER_ROW * C::WORD_U16S + ); + debug_assert!( + carry_e.is_none() || carry_e.unwrap().len() == C::ROUNDS_PER_ROW * C::WORD_U16S + ); + + set_arrayview_from_u32_slice( + &mut cols.flags.row_idx, + get_flag_pt_array(&self.row_idx_encoder, C::ROWS_PER_BLOCK), + ); + + for i in 0..C::ROUNDS_PER_ROW { + // The padding rows need to have the first block's prev_hash here, to satisfy the air + // constraints + set_arrayview_from_u32_slice( + &mut cols.work_vars.a.row_mut(i), + word_into_bits::(first_block_prev_hash[C::ROUNDS_PER_ROW - i - 1]).into_iter(), + ); + set_arrayview_from_u32_slice( + &mut cols.work_vars.e.row_mut(i), + word_into_bits::(first_block_prev_hash[C::ROUNDS_PER_ROW - i + 3]).into_iter(), + ); + + // The invalid carries are not constants anymore, so we need to fill them in here + if let Some(carry_a) = carry_a { + cols.work_vars + .carry_a + .iter_mut() + .zip(carry_a.iter()) + .for_each(|(x, y)| *x = *y); + } + if let Some(carry_e) = carry_e { + cols.work_vars + .carry_e + .iter_mut() + .zip(carry_e.iter()) + .for_each(|(x, y)| *x = *y); + } + } + } + + /// The following functions do the calculations in native field since they will be called on + /// padding rows which can overflow and we need to make sure it matches the AIR constraints + /// Puts the correct carries in the `next_row`, the resulting carries can be out of bounds. + /// Assumes next.w and next.k are zero, which is the case when constraint_word_addition is + /// constrained on digest rows or padding rows. + /// It only looks at local.a, next.a, local.e, next.e. + pub fn generate_carry_ae( + local_cols: Sha2RoundColsRef, + next_cols: &mut Sha2RoundColsRefMut, + ) { + let a = [ + local_cols + .work_vars + .a + .rows() + .into_iter() + .collect::>(), + next_cols.work_vars.a.rows().into_iter().collect::>(), + ] + .concat(); + let e = [ + local_cols + .work_vars + .e + .rows() + .into_iter() + .collect::>(), + next_cols.work_vars.e.rows().into_iter().collect::>(), + ] + .concat(); + for i in 0..C::ROUNDS_PER_ROW { + let cur_a = a[i + 4]; + let sig_a = big_sig0_field::(a[i + 3].as_slice().unwrap()); + let maj_abc = maj_field::( + a[i + 3].as_slice().unwrap(), + a[i + 2].as_slice().unwrap(), + a[i + 1].as_slice().unwrap(), + ); + let d = a[i]; + let cur_e = e[i + 4]; + let sig_e = big_sig1_field::(e[i + 3].as_slice().unwrap()); + let ch_efg = ch_field::( + e[i + 3].as_slice().unwrap(), + e[i + 2].as_slice().unwrap(), + e[i + 1].as_slice().unwrap(), + ); + let h = e[i]; + + let t1 = [h.to_vec(), sig_e, ch_efg.to_vec()]; + let t2 = [sig_a, maj_abc]; + for j in 0..C::WORD_U16S { + let t1_limb_sum = t1.iter().fold(F::ZERO, |acc, x| { + acc + compose::(&x[j * 16..(j + 1) * 16], 1) + }); + let t2_limb_sum = t2.iter().fold(F::ZERO, |acc, x| { + acc + compose::(&x[j * 16..(j + 1) * 16], 1) + }); + let d_limb = compose::(&d.as_slice().unwrap()[j * 16..(j + 1) * 16], 1); + let cur_a_limb = compose::(&cur_a.as_slice().unwrap()[j * 16..(j + 1) * 16], 1); + let cur_e_limb = compose::(&cur_e.as_slice().unwrap()[j * 16..(j + 1) * 16], 1); + let sum = d_limb + + t1_limb_sum + + if j == 0 { + F::ZERO + } else { + next_cols.work_vars.carry_e[[i, j - 1]] + } + - cur_e_limb; + let carry_e = sum * (F::from_u32(1 << 16).inverse()); + + let sum = t1_limb_sum + + t2_limb_sum + + if j == 0 { + F::ZERO + } else { + next_cols.work_vars.carry_a[[i, j - 1]] + } + - cur_a_limb; + let carry_a = sum * (F::from_u32(1 << 16).inverse()); + next_cols.work_vars.carry_e[[i, j]] = carry_e; + next_cols.work_vars.carry_a[[i, j]] = carry_a; + } + } + } + + /// Puts the correct intermed_4 in the `next_row` + pub fn generate_intermed_4( + local_cols: Sha2RoundColsRef, + next_cols: &mut Sha2RoundColsRefMut, + ) { + let w = [ + local_cols + .message_schedule + .w + .rows() + .into_iter() + .collect::>(), + next_cols + .message_schedule + .w + .rows() + .into_iter() + .collect::>(), + ] + .concat(); + let w_limbs: Vec> = w + .iter() + .map(|x| { + (0..C::WORD_U16S) + .map(|i| compose::(&x.as_slice().unwrap()[i * 16..(i + 1) * 16], 1)) + .collect::>() + }) + .collect(); + for i in 0..C::ROUNDS_PER_ROW { + let sig_w = small_sig0_field::(w[i + 1].as_slice().unwrap()); + let sig_w_limbs: Vec = (0..C::WORD_U16S) + .map(|j| compose::(&sig_w[j * 16..(j + 1) * 16], 1)) + .collect(); + for (j, sig_w_limb) in sig_w_limbs.iter().enumerate() { + next_cols.schedule_helper.intermed_4[[i, j]] = w_limbs[i][j] + *sig_w_limb; + } + } + } + + /// Puts the needed intermed_12 in the `local_row` + pub fn generate_intermed_12( + local_cols: &mut Sha2RoundColsRefMut, + next_cols: Sha2RoundColsRef, + ) { + let w = [ + local_cols + .message_schedule + .w + .rows() + .into_iter() + .collect::>(), + next_cols + .message_schedule + .w + .rows() + .into_iter() + .collect::>(), + ] + .concat(); + let w_limbs: Vec> = w + .iter() + .map(|x| { + (0..C::WORD_U16S) + .map(|i| compose::(&x.as_slice().unwrap()[i * 16..(i + 1) * 16], 1)) + .collect::>() + }) + .collect(); + for i in 0..C::ROUNDS_PER_ROW { + // sig_1(w_{t-2}) + let sig_w_2: Vec = (0..C::WORD_U16S) + .map(|j| { + compose::( + &small_sig1_field::(w[i + 2].as_slice().unwrap()) + [j * 16..(j + 1) * 16], + 1, + ) + }) + .collect(); + // w_{t-7} + let w_7 = if i < 3 { + local_cols.schedule_helper.w_3.row(i).to_slice().unwrap() + } else { + w_limbs[i - 3].as_slice() + }; + // w_t + let w_cur = w_limbs[i + 4].as_slice(); + for j in 0..C::WORD_U16S { + let carry = next_cols.message_schedule.carry_or_buffer[[i, j * 2]] + + F::TWO * next_cols.message_schedule.carry_or_buffer[[i, j * 2 + 1]]; + let sum = sig_w_2[j] + w_7[j] - carry * F::from_u32(1 << 16) - w_cur[j] + + if j > 0 { + next_cols.message_schedule.carry_or_buffer[[i, j * 2 - 2]] + + F::from_u32(2) + * next_cols.message_schedule.carry_or_buffer[[i, j * 2 - 1]] + } else { + F::ZERO + }; + local_cols.schedule_helper.intermed_12[[i, j]] = -sum; + } + } + } +} diff --git a/crates/circuits/sha2-air/src/utils.rs b/crates/circuits/sha2-air/src/utils.rs new file mode 100644 index 0000000000..1e956b82d0 --- /dev/null +++ b/crates/circuits/sha2-air/src/utils.rs @@ -0,0 +1,313 @@ +use ndarray::ArrayViewMut; +pub use openvm_circuit_primitives::utils::compose; +use openvm_circuit_primitives::{ + encoder::Encoder, + utils::{not, select}, +}; +use openvm_stark_backend::{ + p3_air::AirBuilder, + p3_field::{PrimeCharacteristicRing, PrimeField32}, +}; +use rand::{rngs::StdRng, Rng}; + +use crate::{RotateRight, Sha2BlockHasherSubairConfig}; + +/// Convert a word into a list of 8-bit limbs in little endian +pub fn word_into_u8_limbs(num: impl Into) -> Vec { + word_into_limbs::(num.into(), C::WORD_U8S) +} + +/// Convert a word into a list of 16-bit limbs in little endian +pub fn word_into_u16_limbs(num: impl Into) -> Vec { + word_into_limbs::(num.into(), C::WORD_U16S) +} + +/// Convert a word into a list of 1-bit limbs in little endian +pub fn word_into_bits(num: impl Into) -> Vec { + word_into_limbs::(num.into(), C::WORD_BITS) +} + +/// Convert a word into a list of limbs in little endian +pub fn word_into_limbs(num: C::Word, num_limbs: usize) -> Vec { + let limb_bits = std::mem::size_of::() * 8 / num_limbs; + (0..num_limbs) + .map(|i| { + let shifted = num >> (limb_bits * i); + let mask: C::Word = ((1u32 << limb_bits) - 1).into(); + let masked = shifted & mask; + masked.try_into().unwrap() + }) + .collect() +} + +/// Convert a u32 into a list of 1-bit limbs in little endian +pub fn u32_into_bits(num: u32) -> Vec { + let limb_bits = 32 / C::WORD_BITS; + (0..C::WORD_BITS) + .map(|i| (num >> (limb_bits * i)) & ((1 << limb_bits) - 1)) + .collect() +} + +/// Convert a list of limbs in little endian into a Word +pub fn le_limbs_into_word(limbs: &[u32]) -> C::Word { + let mut limbs = limbs.to_vec(); + limbs.reverse(); + be_limbs_into_word::(&limbs) +} + +/// Convert a list of limbs in big endian into a Word +pub fn be_limbs_into_word(limbs: &[u32]) -> C::Word { + let limb_bits = C::WORD_BITS / limbs.len(); + limbs.iter().fold(C::Word::from(0), |acc, &limb| { + (acc << limb_bits) | limb.into() + }) +} + +/// Convert a list of limbs in little endian into a u32 +pub fn limbs_into_u32(limbs: &[u32]) -> u32 { + let limb_bits = 32 / limbs.len(); + limbs + .iter() + .rev() + .fold(0, |acc, &limb| (acc << limb_bits) | limb) +} + +/// Rotates `bits` right by `n` bits, assumes `bits` is in little-endian +#[inline] +pub(crate) fn rotr(bits: &[impl Into + Clone], n: usize) -> Vec { + (0..bits.len()) + .map(|i| bits[(i + n) % bits.len()].clone().into()) + .collect() +} + +/// Shifts `bits` right by `n` bits, assumes `bits` is in little-endian +#[inline] +pub(crate) fn shr(bits: &[impl Into + Clone], n: usize) -> Vec { + (0..bits.len()) + .map(|i| { + if i + n < bits.len() { + bits[i + n].clone().into() + } else { + F::ZERO + } + }) + .collect() +} + +/// Computes x ^ y ^ z, where x, y, z are assumed to be boolean +#[inline] +pub(crate) fn xor_bit( + x: impl Into, + y: impl Into, + z: impl Into, +) -> F { + let (x, y, z) = (x.into(), y.into(), z.into()); + (x.clone() * y.clone() * z.clone()) + + (x.clone() * not::(y.clone()) * not::(z.clone())) + + (not::(x.clone()) * y.clone() * not::(z.clone())) + + (not::(x) * not::(y) * z) +} + +/// Computes x ^ y ^ z, where x, y, z are [C::WORD_BITS] bit numbers +#[inline] +pub(crate) fn xor( + x: &[impl Into + Clone], + y: &[impl Into + Clone], + z: &[impl Into + Clone], +) -> Vec { + (0..x.len()) + .map(|i| xor_bit(x[i].clone(), y[i].clone(), z[i].clone())) + .collect() +} + +/// Choose function from the SHA spec +#[inline] +pub fn ch(x: C::Word, y: C::Word, z: C::Word) -> C::Word { + (x & y) ^ ((!x) & z) +} + +/// Computes Ch(x,y,z), where x, y, z are [C::WORD_BITS] bit numbers +#[inline] +pub(crate) fn ch_field( + x: &[impl Into + Clone], + y: &[impl Into + Clone], + z: &[impl Into + Clone], +) -> Vec { + (0..x.len()) + .map(|i| select(x[i].clone(), y[i].clone(), z[i].clone())) + .collect() +} + +/// Majority function from the SHA spec +pub fn maj(x: C::Word, y: C::Word, z: C::Word) -> C::Word { + (x & y) ^ (x & z) ^ (y & z) +} + +/// Computes Maj(x,y,z), where x, y, z are [C::WORD_BITS] bit numbers +#[inline] +pub(crate) fn maj_field( + x: &[impl Into + Clone], + y: &[impl Into + Clone], + z: &[impl Into + Clone], +) -> Vec { + (0..x.len()) + .map(|i| { + let (x, y, z) = ( + x[i].clone().into(), + y[i].clone().into(), + z[i].clone().into(), + ); + x.clone() * y.clone() + x.clone() * z.clone() + y.clone() * z.clone() + - F::TWO * x * y * z + }) + .collect() +} + +/// Big sigma_0 function from the SHA spec +pub fn big_sig0(x: C::Word) -> C::Word { + if C::WORD_BITS == 32 { + x.rotate_right(2) ^ x.rotate_right(13) ^ x.rotate_right(22) + } else { + x.rotate_right(28) ^ x.rotate_right(34) ^ x.rotate_right(39) + } +} + +/// Computes BigSigma0(x), where x is a [C::WORD_BITS] bit number in little-endian +#[inline] +pub(crate) fn big_sig0_field( + x: &[impl Into + Clone], +) -> Vec { + if C::WORD_BITS == 32 { + xor(&rotr::(x, 2), &rotr::(x, 13), &rotr::(x, 22)) + } else { + xor(&rotr::(x, 28), &rotr::(x, 34), &rotr::(x, 39)) + } +} + +/// Big sigma_1 function from the SHA spec +pub fn big_sig1(x: C::Word) -> C::Word { + if C::WORD_BITS == 32 { + x.rotate_right(6) ^ x.rotate_right(11) ^ x.rotate_right(25) + } else { + x.rotate_right(14) ^ x.rotate_right(18) ^ x.rotate_right(41) + } +} + +/// Computes BigSigma1(x), where x is a [C::WORD_BITS] bit number in little-endian +#[inline] +pub(crate) fn big_sig1_field( + x: &[impl Into + Clone], +) -> Vec { + if C::WORD_BITS == 32 { + xor(&rotr::(x, 6), &rotr::(x, 11), &rotr::(x, 25)) + } else { + xor(&rotr::(x, 14), &rotr::(x, 18), &rotr::(x, 41)) + } +} + +/// Small sigma_0 function from the SHA spec +pub fn small_sig0(x: C::Word) -> C::Word { + if C::WORD_BITS == 32 { + x.rotate_right(7) ^ x.rotate_right(18) ^ (x >> 3) + } else { + x.rotate_right(1) ^ x.rotate_right(8) ^ (x >> 7) + } +} + +/// Computes SmallSigma0(x), where x is a [C::WORD_BITS] bit number in little-endian +#[inline] +pub(crate) fn small_sig0_field( + x: &[impl Into + Clone], +) -> Vec { + if C::WORD_BITS == 32 { + xor(&rotr::(x, 7), &rotr::(x, 18), &shr::(x, 3)) + } else { + xor(&rotr::(x, 1), &rotr::(x, 8), &shr::(x, 7)) + } +} + +/// Small sigma_1 function from the SHA spec +pub fn small_sig1(x: C::Word) -> C::Word { + if C::WORD_BITS == 32 { + x.rotate_right(17) ^ x.rotate_right(19) ^ (x >> 10) + } else { + x.rotate_right(19) ^ x.rotate_right(61) ^ (x >> 6) + } +} + +/// Computes SmallSigma1(x), where x is a [C::WORD_BITS] bit number in little-endian +#[inline] +pub(crate) fn small_sig1_field( + x: &[impl Into + Clone], +) -> Vec { + if C::WORD_BITS == 32 { + xor(&rotr::(x, 17), &rotr::(x, 19), &shr::(x, 10)) + } else { + xor(&rotr::(x, 19), &rotr::(x, 61), &shr::(x, 6)) + } +} + +/// Generate a random message of a given length +pub fn get_random_message(rng: &mut StdRng, len: usize) -> Vec { + let mut random_message: Vec = vec![0u8; len]; + rng.fill(&mut random_message[..]); + random_message +} + +/// Wrapper of `get_flag_pt` to get the flag pointer as an array +pub fn get_flag_pt_array(encoder: &Encoder, flag_idx: usize) -> Vec { + encoder.get_flag_pt(flag_idx) +} + +/// Constrain the addition of [C::WORD_BITS] bit words in 16-bit limbs +/// It takes in the terms some in bits some in 16-bit limbs, +/// the expected sum in bits and the carries +pub fn constraint_word_addition( + builder: &mut AB, + terms_bits: &[&[impl Into + Clone]], + terms_limb: &[&[impl Into + Clone]], + expected_sum: &[impl Into + Clone], + carries: &[impl Into + Clone], +) { + debug_assert!(terms_bits.iter().all(|x| x.len() == C::WORD_BITS)); + debug_assert!(terms_limb.iter().all(|x| x.len() == C::WORD_U16S)); + assert_eq!(expected_sum.len(), C::WORD_BITS); + assert_eq!(carries.len(), C::WORD_U16S); + + for i in 0..C::WORD_U16S { + let mut limb_sum = if i == 0 { + AB::Expr::ZERO + } else { + carries[i - 1].clone().into() + }; + for term in terms_bits { + limb_sum += compose::(&term[i * 16..(i + 1) * 16], 1); + } + for term in terms_limb { + limb_sum += term[i].clone().into(); + } + let expected_sum_limb = compose::(&expected_sum[i * 16..(i + 1) * 16], 1) + + carries[i].clone().into() * AB::Expr::from_u32(1 << 16); + builder.assert_eq(limb_sum, expected_sum_limb); + } +} + +pub fn set_arrayview_from_u32_slice( + arrayview: &mut ArrayViewMut, + data: impl IntoIterator, +) { + arrayview + .iter_mut() + .zip(data.into_iter().map(|x| F::from_u32(x))) + .for_each(|(x, y)| *x = y); +} + +pub fn set_arrayview_from_u8_slice( + arrayview: &mut ArrayViewMut, + data: impl IntoIterator, +) { + arrayview + .iter_mut() + .zip(data.into_iter().map(|x| F::from_u8(x))) + .for_each(|(x, y)| *x = y); +} diff --git a/crates/circuits/sha256-air/Cargo.toml b/crates/circuits/sha256-air/Cargo.toml deleted file mode 100644 index bad3d3eac9..0000000000 --- a/crates/circuits/sha256-air/Cargo.toml +++ /dev/null @@ -1,20 +0,0 @@ -[package] -name = "openvm-sha256-air" -version.workspace = true -authors.workspace = true -edition.workspace = true - -[dependencies] -openvm-circuit-primitives = { workspace = true } -openvm-stark-backend = { workspace = true } -sha2 = { version = "0.10", features = ["compress"] } -rand.workspace = true - -[dev-dependencies] -openvm-cpu-backend = { workspace = true } -openvm-stark-sdk = { workspace = true, features = ["cpu-backend"] } -openvm-circuit = { workspace = true, features = ["test-utils"] } - -[features] -default = ["parallel"] -parallel = ["openvm-stark-backend/parallel", "openvm-circuit-primitives/parallel"] diff --git a/crates/circuits/sha256-air/cuda/include/sha256-air/columns.cuh b/crates/circuits/sha256-air/cuda/include/sha256-air/columns.cuh deleted file mode 100644 index 64c6a276eb..0000000000 --- a/crates/circuits/sha256-air/cuda/include/sha256-air/columns.cuh +++ /dev/null @@ -1,131 +0,0 @@ -#pragma once - -#include "primitives/constants.h" -#include "primitives/execution.h" -#include "system/memory/offline_checker.cuh" - -using namespace riscv; -using namespace sha256; - -template struct Sha256FlagsCols { - T is_round_row; - T is_first_4_rows; - T is_digest_row; - T is_last_block; - T row_idx[SHA256_ROW_VAR_CNT]; - T global_block_idx; - T local_block_idx; -}; - -template struct Sha256MessageHelperCols { - T w_3[SHA256_ROUNDS_PER_ROW - 1][SHA256_WORD_U16S]; - T intermed_4[SHA256_ROUNDS_PER_ROW][SHA256_WORD_U16S]; - T intermed_8[SHA256_ROUNDS_PER_ROW][SHA256_WORD_U16S]; - T intermed_12[SHA256_ROUNDS_PER_ROW][SHA256_WORD_U16S]; -}; - -template struct Sha256MessageScheduleCols { - T w[SHA256_ROUNDS_PER_ROW][SHA256_WORD_BITS]; - T carry_or_buffer[SHA256_ROUNDS_PER_ROW][SHA256_WORD_U8S]; -}; - -template struct Sha256WorkVarsCols { - T a[SHA256_ROUNDS_PER_ROW][SHA256_WORD_BITS]; - T e[SHA256_ROUNDS_PER_ROW][SHA256_WORD_BITS]; - T carry_a[SHA256_ROUNDS_PER_ROW][SHA256_WORD_U16S]; - T carry_e[SHA256_ROUNDS_PER_ROW][SHA256_WORD_U16S]; -}; - -template struct Sha256RoundCols { - Sha256FlagsCols flags; - Sha256WorkVarsCols work_vars; - Sha256MessageHelperCols schedule_helper; - Sha256MessageScheduleCols message_schedule; -}; - -template struct Sha256DigestCols { - Sha256FlagsCols flags; - Sha256WorkVarsCols hash; - Sha256MessageHelperCols schedule_helper; - T final_hash[SHA256_HASH_WORDS][SHA256_WORD_U8S]; - T prev_hash[SHA256_HASH_WORDS][SHA256_WORD_U16S]; -}; - -template struct Sha256VmControlCols { - T len; - T cur_timestamp; - T read_ptr; - T pad_flags[6]; - T padding_occurred; -}; - -template struct Sha256VmRoundCols { - Sha256VmControlCols control; - Sha256RoundCols inner; - MemoryReadAuxCols read_aux; -}; - -template struct Sha256VmDigestCols { - Sha256VmControlCols control; - Sha256DigestCols inner; - ExecutionState from_state; - T rd_ptr; - T rs1_ptr; - T rs2_ptr; - T dst_ptr[RV32_REGISTER_NUM_LIMBS]; - T src_ptr[RV32_REGISTER_NUM_LIMBS]; - T len_data[RV32_REGISTER_NUM_LIMBS]; - MemoryReadAuxCols register_reads_aux[SHA256_REGISTER_READS]; - MemoryWriteAuxCols writes_aux; -}; - -struct Sha256InnerBlockRecord { - uint32_t global_block_idx; - uint32_t local_block_idx; - uint32_t is_last_block; - uint32_t prev_hash[SHA256_HASH_WORDS]; - uint32_t input_words[SHA256_BLOCK_WORDS]; -}; - -__global__ void sha256_fill_invalid_rows( - Fp *d_trace, - size_t trace_height, - size_t trace_width, - uint32_t rows_used -); - -// ===== MACROS AND CONSTANTS ===== -static constexpr size_t SHA256VM_CONTROL_WIDTH = sizeof(Sha256VmControlCols); -static constexpr size_t SHA256_ROUND_WIDTH = sizeof(Sha256RoundCols); -static constexpr size_t SHA256_DIGEST_WIDTH = sizeof(Sha256DigestCols); -static constexpr size_t SHA256VM_ROUND_WIDTH = sizeof(Sha256VmRoundCols); -static constexpr size_t SHA256VM_DIGEST_WIDTH = sizeof(Sha256VmDigestCols); - -static constexpr size_t SHA256_WIDTH = - (SHA256_ROUND_WIDTH > SHA256_DIGEST_WIDTH) ? SHA256_ROUND_WIDTH : SHA256_DIGEST_WIDTH; -static constexpr size_t SHA256VM_WIDTH = - (SHA256VM_ROUND_WIDTH > SHA256VM_DIGEST_WIDTH) ? SHA256VM_ROUND_WIDTH : SHA256VM_DIGEST_WIDTH; -static constexpr size_t SHA256_INNER_COLUMN_OFFSET = sizeof(Sha256VmControlCols); - -#define SHA256_WRITE_ROUND(row, FIELD, VALUE) COL_WRITE_VALUE(row, Sha256VmRoundCols, FIELD, VALUE) -#define SHA256_WRITE_DIGEST(row, FIELD, VALUE) \ - COL_WRITE_VALUE(row, Sha256VmDigestCols, FIELD, VALUE) -#define SHA256_WRITE_ARRAY_ROUND(row, FIELD, VALUES) \ - COL_WRITE_ARRAY(row, Sha256VmRoundCols, FIELD, VALUES) -#define SHA256_WRITE_ARRAY_DIGEST(row, FIELD, VALUES) \ - COL_WRITE_ARRAY(row, Sha256VmDigestCols, FIELD, VALUES) -#define SHA256_FILL_ZERO_ROUND(row, FIELD) COL_FILL_ZERO(row, Sha256VmRoundCols, FIELD) -#define SHA256_FILL_ZERO_DIGEST(row, FIELD) COL_FILL_ZERO(row, Sha256VmDigestCols, FIELD) -#define SHA256_SLICE_ROUND(row, FIELD) row.slice_from(COL_INDEX(Sha256VmRoundCols, FIELD)) -#define SHA256_SLICE_DIGEST(row, FIELD) row.slice_from(COL_INDEX(Sha256VmDigestCols, FIELD)) - -#define SHA256INNER_WRITE_ROUND(row, FIELD, VALUE) \ - COL_WRITE_VALUE(row, Sha256RoundCols, FIELD, VALUE) -#define SHA256INNER_WRITE_DIGEST(row, FIELD, VALUE) \ - COL_WRITE_VALUE(row, Sha256DigestCols, FIELD, VALUE) -#define SHA256INNER_WRITE_ARRAY_ROUND(row, FIELD, VALUES) \ - COL_WRITE_ARRAY(row, Sha256RoundCols, FIELD, VALUES) -#define SHA256INNER_WRITE_ARRAY_DIGEST(row, FIELD, VALUES) \ - COL_WRITE_ARRAY(row, Sha256DigestCols, FIELD, VALUES) -#define SHA256INNER_FILL_ZERO_ROUND(row, FIELD) COL_FILL_ZERO(row, Sha256RoundCols, FIELD) -#define SHA256INNER_FILL_ZERO_DIGEST(row, FIELD) COL_FILL_ZERO(row, Sha256DigestCols, FIELD) \ No newline at end of file diff --git a/crates/circuits/sha256-air/cuda/include/sha256-air/tracegen.cuh b/crates/circuits/sha256-air/cuda/include/sha256-air/tracegen.cuh deleted file mode 100644 index 7af23a98e2..0000000000 --- a/crates/circuits/sha256-air/cuda/include/sha256-air/tracegen.cuh +++ /dev/null @@ -1,632 +0,0 @@ -#pragma once - -#include "columns.cuh" -#include "primitives/constants.h" -#include "primitives/encoder.cuh" -#include "primitives/histogram.cuh" -#include "primitives/trace_access.h" -#include "utils.cuh" - -using namespace riscv; -using namespace sha256; - -// Helper to get a_bit from either local_row or next_row based on index -__device__ __forceinline__ Fp get_a_bit(RowSlice local_row, RowSlice next_row, int round_idx, int bit) { - if (round_idx < SHA256_ROUNDS_PER_ROW) { - return local_row[COL_INDEX(Sha256RoundCols, work_vars.a[round_idx][bit])]; - } else { - return next_row[COL_INDEX(Sha256RoundCols, work_vars.a[round_idx - SHA256_ROUNDS_PER_ROW][bit])]; - } -} - -// Helper to get e_bit from either local_row or next_row based on index -__device__ __forceinline__ Fp get_e_bit(RowSlice local_row, RowSlice next_row, int round_idx, int bit) { - if (round_idx < SHA256_ROUNDS_PER_ROW) { - return local_row[COL_INDEX(Sha256RoundCols, work_vars.e[round_idx][bit])]; - } else { - return next_row[COL_INDEX(Sha256RoundCols, work_vars.e[round_idx - SHA256_ROUNDS_PER_ROW][bit])]; - } -} - -__device__ void generate_carry_ae(RowSlice local_row, RowSlice next_row) { - // Process one round at a time instead of loading all 8 rounds upfront - // This reduces stack from ~2KB to ~512 bytes - - for (int i = 0; i < SHA256_ROUNDS_PER_ROW; i++) { - Fp sig_a_bits[SHA256_WORD_BITS]; - for (int bit = 0; bit < SHA256_WORD_BITS; bit++) { - Fp a3_b2 = get_a_bit(local_row, next_row, i + 3, (bit + 2) & 31); - Fp a3_b13 = get_a_bit(local_row, next_row, i + 3, (bit + 13) & 31); - Fp a3_b22 = get_a_bit(local_row, next_row, i + 3, (bit + 22) & 31); - Fp xor_2_13 = a3_b2 + a3_b13 - Fp(2) * a3_b2 * a3_b13; - sig_a_bits[bit] = xor_2_13 + a3_b22 - Fp(2) * xor_2_13 * a3_b22; - } - - Fp sig_e_bits[SHA256_WORD_BITS]; - for (int bit = 0; bit < SHA256_WORD_BITS; bit++) { - Fp e3_b6 = get_e_bit(local_row, next_row, i + 3, (bit + 6) & 31); - Fp e3_b11 = get_e_bit(local_row, next_row, i + 3, (bit + 11) & 31); - Fp e3_b25 = get_e_bit(local_row, next_row, i + 3, (bit + 25) & 31); - Fp xor_6_11 = e3_b6 + e3_b11 - Fp(2) * e3_b6 * e3_b11; - sig_e_bits[bit] = xor_6_11 + e3_b25 - Fp(2) * xor_6_11 * e3_b25; - } - - Fp maj_abc_bits[SHA256_WORD_BITS]; - for (int bit = 0; bit < SHA256_WORD_BITS; bit++) { - Fp a3 = get_a_bit(local_row, next_row, i + 3, bit); - Fp a2 = get_a_bit(local_row, next_row, i + 2, bit); - Fp a1 = get_a_bit(local_row, next_row, i + 1, bit); - maj_abc_bits[bit] = a3 * a2 + a3 * a1 + a2 * a1 - Fp(2) * a3 * a2 * a1; - } - - Fp ch_efg_bits[SHA256_WORD_BITS]; - for (int bit = 0; bit < SHA256_WORD_BITS; bit++) { - Fp e3 = get_e_bit(local_row, next_row, i + 3, bit); - Fp e2 = get_e_bit(local_row, next_row, i + 2, bit); - Fp e1 = get_e_bit(local_row, next_row, i + 1, bit); - ch_efg_bits[bit] = e3 * e2 + e1 - e3 * e1; - } - - for (int j = 0; j < SHA256_WORD_U16S; j++) { - Fp t1_limb_sum = Fp::zero(); -#pragma unroll 1 - for (int bit = 0; bit < 16; bit++) { - Fp e_i = get_e_bit(local_row, next_row, i, j * 16 + bit); - t1_limb_sum += (e_i + sig_e_bits[j * 16 + bit] + ch_efg_bits[j * 16 + bit]) * Fp(1 << bit); - } - Fp t2_limb_sum = Fp::zero(); -#pragma unroll 1 - for (int bit = 0; bit < 16; bit++) { - t2_limb_sum += (sig_a_bits[j * 16 + bit] + maj_abc_bits[j * 16 + bit]) * Fp(1 << bit); - } - - Fp d_limb = Fp::zero(); - Fp cur_a_limb = Fp::zero(); - Fp cur_e_limb = Fp::zero(); -#pragma unroll 1 - for (int bit = 0; bit < 16; bit++) { - d_limb += get_a_bit(local_row, next_row, i, j * 16 + bit) * Fp(1 << bit); - cur_a_limb += get_a_bit(local_row, next_row, i + 4, j * 16 + bit) * Fp(1 << bit); - cur_e_limb += get_e_bit(local_row, next_row, i + 4, j * 16 + bit) * Fp(1 << bit); - } - Fp prev_carry_e = - (j == 0) ? Fp::zero() - : next_row[COL_INDEX(Sha256RoundCols, work_vars.carry_e[i][j - 1])]; - Fp carry_e_numerator = d_limb + t1_limb_sum + prev_carry_e - cur_e_limb; - Fp carry_e = carry_e_numerator.mul_2exp_neg_n(16); - - Fp prev_carry_a = - (j == 0) ? Fp::zero() - : next_row[COL_INDEX(Sha256RoundCols, work_vars.carry_a[i][j - 1])]; - - Fp carry_a_numerator = t1_limb_sum + t2_limb_sum + prev_carry_a - cur_a_limb; - Fp carry_a = carry_a_numerator.mul_2exp_neg_n(16); - SHA256INNER_WRITE_ROUND(next_row, work_vars.carry_e[i][j], carry_e); - SHA256INNER_WRITE_ROUND(next_row, work_vars.carry_a[i][j], carry_a); - } - } -} - -// Helper to get w_bit from either local_row or next_row based on index -__device__ __forceinline__ Fp get_w_bit(RowSlice local_row, RowSlice next_row, int round_idx, int bit) { - if (round_idx < SHA256_ROUNDS_PER_ROW) { - return local_row[COL_INDEX(Sha256RoundCols, message_schedule.w[round_idx][bit])]; - } else { - return next_row[COL_INDEX(Sha256RoundCols, message_schedule.w[round_idx - SHA256_ROUNDS_PER_ROW][bit])]; - } -} - -__device__ void generate_intermed_4(RowSlice local_row, RowSlice next_row) { - // Process one round at a time instead of loading all 8 rounds upfront - // This reduces stack from ~1.2KB to ~256 bytes - - for (int i = 0; i < SHA256_ROUNDS_PER_ROW; i++) { - // Compute w_limbs[i] on the fly - Fp w_limbs_i[SHA256_WORD_U16S]; - for (int j = 0; j < SHA256_WORD_U16S; j++) { - w_limbs_i[j] = Fp::zero(); - for (int bit = 0; bit < 16; bit++) { - w_limbs_i[j] = w_limbs_i[j] + get_w_bit(local_row, next_row, i, j * 16 + bit) * Fp(1 << bit); - } - } - - Fp sig_w_bits[SHA256_WORD_BITS]; - for (int bit = 0; bit < SHA256_WORD_BITS; bit++) { - Fp w1_b7 = get_w_bit(local_row, next_row, i + 1, (bit + 7) & 31); - Fp w1_b18 = get_w_bit(local_row, next_row, i + 1, (bit + 18) & 31); - Fp w1_b3 = (bit + 3 < 32) ? get_w_bit(local_row, next_row, i + 1, bit + 3) : Fp::zero(); - Fp xor_7_18 = w1_b7 + w1_b18 - Fp(2) * w1_b7 * w1_b18; - sig_w_bits[bit] = xor_7_18 + w1_b3 - Fp(2) * xor_7_18 * w1_b3; - } - - Fp sig_w_limbs[SHA256_WORD_U16S]; - for (int j = 0; j < SHA256_WORD_U16S; j++) { - sig_w_limbs[j] = Fp::zero(); - for (int bit = 0; bit < 16; bit++) { - sig_w_limbs[j] = sig_w_limbs[j] + sig_w_bits[j * 16 + bit] * Fp(1 << bit); - } - } - - for (int j = 0; j < SHA256_WORD_U16S; j++) { - SHA256INNER_WRITE_ROUND( - next_row, schedule_helper.intermed_4[i][j], w_limbs_i[j] + sig_w_limbs[j] - ); - } - } -} - -__device__ void generate_intermed_12(RowSlice local_row, RowSlice next_row) { - // Use compute-on-the-fly to avoid storing bit arrays - for (int i = 0; i < SHA256_ROUNDS_PER_ROW; i++) { - // Compute sig_bits on the fly using get_w_bit helper (reusing for i+2) - Fp sig_w_2_limbs[SHA256_WORD_U16S]; - for (int j = 0; j < SHA256_WORD_U16S; j++) { - sig_w_2_limbs[j] = Fp::zero(); - for (int bit_offset = 0; bit_offset < 16; bit_offset++) { - int bit = j * 16 + bit_offset; - // Get w[i+2] bits on the fly - Fp w2_b17 = get_w_bit(local_row, next_row, i + 2, (bit + 17) & 31); - Fp w2_b19 = get_w_bit(local_row, next_row, i + 2, (bit + 19) & 31); - Fp w2_b10 = (bit + 10 < 32) ? get_w_bit(local_row, next_row, i + 2, bit + 10) : Fp::zero(); - Fp xor_17_19 = w2_b17 + w2_b19 - Fp(2) * w2_b17 * w2_b19; - Fp sig_bit = xor_17_19 + w2_b10 - Fp(2) * xor_17_19 * w2_b10; - sig_w_2_limbs[j] += sig_bit * Fp(1 << bit_offset); - } - } - - Fp w_7_limbs[SHA256_WORD_U16S]; - if (i < 3) { - w_7_limbs[0] = local_row[COL_INDEX(Sha256RoundCols, schedule_helper.w_3[i][0])]; - w_7_limbs[1] = local_row[COL_INDEX(Sha256RoundCols, schedule_helper.w_3[i][1])]; - } else { - // Compute w[i-3] limbs on the fly - for (int j = 0; j < SHA256_WORD_U16S; j++) { - w_7_limbs[j] = Fp::zero(); - for (int bit = 0; bit < 16; bit++) { - w_7_limbs[j] += local_row[COL_INDEX(Sha256RoundCols, message_schedule.w[i - 3][j * 16 + bit])] * Fp(1 << bit); - } - } - } - - // Compute w_cur_limbs on the fly - Fp w_cur_limbs[SHA256_WORD_U16S]; - for (int j = 0; j < SHA256_WORD_U16S; j++) { - w_cur_limbs[j] = Fp::zero(); - for (int bit = 0; bit < 16; bit++) { - w_cur_limbs[j] += next_row[COL_INDEX(Sha256RoundCols, message_schedule.w[i][j * 16 + bit])] * Fp(1 << bit); - } - } - - for (int j = 0; j < SHA256_WORD_U16S; j++) { - Fp carry = - next_row[COL_INDEX(Sha256RoundCols, message_schedule.carry_or_buffer[i][j * 2])] + - Fp(2) * next_row[COL_INDEX( - Sha256RoundCols, message_schedule.carry_or_buffer[i][j * 2 + 1] - )]; - - Fp prev_carry = Fp::zero(); - if (j > 0) { - prev_carry = - next_row[COL_INDEX( - Sha256RoundCols, message_schedule.carry_or_buffer[i][j * 2 - 2] - )] + - Fp(2) * next_row[COL_INDEX( - Sha256RoundCols, message_schedule.carry_or_buffer[i][j * 2 - 1] - )]; - } - - Fp sum = - sig_w_2_limbs[j] + w_7_limbs[j] - carry * Fp(1 << 16) - w_cur_limbs[j] + prev_carry; - SHA256INNER_WRITE_ROUND(local_row, schedule_helper.intermed_12[i][j], -sum); - } - } -} - -__device__ void get_block_hash( - uint32_t hash[SHA256_HASH_WORDS], - const uint8_t input[SHA256_BLOCK_U8S] -) { - uint32_t work_vars[SHA256_HASH_WORDS]; - memcpy(work_vars, hash, SHA256_HASH_WORDS * sizeof(uint32_t)); - - uint32_t w[64]; - for (int i = 0; i < 16; i++) { - w[i] = u32_from_bytes_be(input + i * 4); - } - for (int i = 16; i < 64; i++) { - w[i] = small_sig1(w[i - 2]) + w[i - 7] + small_sig0(w[i - 15]) + w[i - 16]; - } - - for (int i = 0; i < 64; i++) { - uint32_t t1 = work_vars[7] + big_sig1(work_vars[4]) + - ch(work_vars[4], work_vars[5], work_vars[6]) + SHA256_K[i] + w[i]; - uint32_t t2 = big_sig0(work_vars[0]) + maj(work_vars[0], work_vars[1], work_vars[2]); - - uint32_t a = work_vars[0]; - uint32_t b = work_vars[1]; - uint32_t c = work_vars[2]; - uint32_t d = work_vars[3]; - uint32_t e = work_vars[4]; - uint32_t f = work_vars[5]; - uint32_t g = work_vars[6]; - uint32_t h = work_vars[7]; - - h = g; - g = f; - f = e; - e = d + t1; - d = c; - c = b; - b = a; - a = t1 + t2; - - work_vars[0] = a; - work_vars[1] = b; - work_vars[2] = c; - work_vars[3] = d; - work_vars[4] = e; - work_vars[5] = f; - work_vars[6] = g; - work_vars[7] = h; - } - - for (int i = 0; i < SHA256_HASH_WORDS; i++) { - hash[i] += work_vars[i]; - } -} - -__device__ __noinline__ void generate_block_trace( - Fp *trace, - size_t trace_height, - const uint32_t input[SHA256_BLOCK_WORDS], - uint32_t *bitwise_lookup_ptr, - uint32_t bitwise_num_bits, - const uint32_t prev_hash[SHA256_HASH_WORDS], - bool is_last_block, - uint32_t global_block_idx, - uint32_t local_block_idx -) { - BitwiseOperationLookup bitwise_lookup(bitwise_lookup_ptr, bitwise_num_bits); - Encoder row_idx_encoder(18, 2, false); - - uint32_t message_schedule[64]; - uint32_t work_vars[SHA256_HASH_WORDS]; - - memcpy(message_schedule, input, SHA256_BLOCK_WORDS * sizeof(uint32_t)); - memcpy(work_vars, prev_hash, SHA256_HASH_WORDS * sizeof(uint32_t)); - - for (int i = 0; i < SHA256_ROWS_PER_BLOCK; i++) { - RowSlice row_slice(trace + i, trace_height); - - if (i < 16) { - SHA256INNER_WRITE_ROUND(row_slice, flags.is_round_row, Fp::one()); - SHA256INNER_WRITE_ROUND( - row_slice, flags.is_first_4_rows, (i < 4) ? Fp::one() : Fp::zero() - ); - SHA256INNER_WRITE_ROUND(row_slice, flags.is_digest_row, Fp::zero()); - SHA256INNER_WRITE_ROUND( - row_slice, flags.is_last_block, is_last_block ? Fp::one() : Fp::zero() - ); - - RowSlice row_idx_flags = - row_slice.slice_from(COL_INDEX(Sha256RoundCols, flags.row_idx)); - row_idx_encoder.write_flag_pt(row_idx_flags, i); - - SHA256INNER_WRITE_ROUND(row_slice, flags.global_block_idx, global_block_idx); - SHA256INNER_WRITE_ROUND(row_slice, flags.local_block_idx, local_block_idx); - - if (i < 4) { - for (int j = 0; j < SHA256_ROUNDS_PER_ROW; j++) { - COL_WRITE_BITS( - row_slice, - Sha256RoundCols, - message_schedule.w[j], - input[i * SHA256_ROUNDS_PER_ROW + j] - ); - } - } else { - for (int j = 0; j < SHA256_ROUNDS_PER_ROW; j++) { - int idx = i * SHA256_ROUNDS_PER_ROW + j; - - uint32_t w = small_sig1(message_schedule[idx - 2]) + message_schedule[idx - 7] + - small_sig0(message_schedule[idx - 15]) + - message_schedule[idx - 16]; - - COL_WRITE_BITS(row_slice, Sha256RoundCols, message_schedule.w[j], w); - - for (int k = 0; k < SHA256_WORD_U16S; k++) { - uint32_t sum = u32_to_u16_limb(small_sig1(message_schedule[idx - 2]), k) + - u32_to_u16_limb(message_schedule[idx - 7], k) + - u32_to_u16_limb(small_sig0(message_schedule[idx - 15]), k) + - u32_to_u16_limb(message_schedule[idx - 16], k); - - if (k > 0) { - sum += row_slice[COL_INDEX( - Sha256RoundCols, - message_schedule.carry_or_buffer[j][k * 2 - 2] - )] - .asUInt32() + - 2 * row_slice[COL_INDEX( - Sha256RoundCols, - message_schedule.carry_or_buffer[j][k * 2 - 1] - )] - .asUInt32(); - } - - uint32_t carry = (sum - u32_to_u16_limb(w, k)) >> 16; - SHA256INNER_WRITE_ROUND( - row_slice, message_schedule.carry_or_buffer[j][k * 2], Fp(carry & 1) - ); - SHA256INNER_WRITE_ROUND( - row_slice, - message_schedule.carry_or_buffer[j][k * 2 + 1], - Fp(carry >> 1) - ); - } - message_schedule[idx] = w; - } - } - - for (int j = 0; j < SHA256_ROUNDS_PER_ROW; j++) { - int idx = i * SHA256_ROUNDS_PER_ROW + j; - - uint32_t t1 = work_vars[7] + big_sig1(work_vars[4]) + - ch(work_vars[4], work_vars[5], work_vars[6]) + SHA256_K[idx] + - message_schedule[idx]; - uint32_t t2 = - big_sig0(work_vars[0]) + maj(work_vars[0], work_vars[1], work_vars[2]); - uint32_t e = work_vars[3] + t1; - uint32_t a = t1 + t2; - - COL_WRITE_BITS(row_slice, Sha256RoundCols, work_vars.a[j], a); - COL_WRITE_BITS(row_slice, Sha256RoundCols, work_vars.e[j], e); - - uint32_t carry_a_values[SHA256_WORD_U16S] = {0}; - uint32_t carry_e_values[SHA256_WORD_U16S] = {0}; - - for (int k = 0; k < SHA256_WORD_U16S; k++) { - uint32_t t1_limb = - u32_to_u16_limb(work_vars[7], k) + - u32_to_u16_limb(big_sig1(work_vars[4]), k) + - u32_to_u16_limb(ch(work_vars[4], work_vars[5], work_vars[6]), k) + - u32_to_u16_limb(SHA256_K[idx], k) + - u32_to_u16_limb(message_schedule[idx], k); - - uint32_t t2_limb = - u32_to_u16_limb(big_sig0(work_vars[0]), k) + - u32_to_u16_limb(maj(work_vars[0], work_vars[1], work_vars[2]), k); - - uint32_t e_limb = t1_limb + u32_to_u16_limb(work_vars[3], k); - uint32_t a_limb = t1_limb + t2_limb; - - if (k > 0) { - a_limb += carry_a_values[k - 1]; - e_limb += carry_e_values[k - 1]; - } - - carry_a_values[k] = (a_limb - u32_to_u16_limb(a, k)) >> 16; - carry_e_values[k] = (e_limb - u32_to_u16_limb(e, k)) >> 16; - - SHA256INNER_WRITE_ROUND(row_slice, work_vars.carry_a[j][k], carry_a_values[k]); - SHA256INNER_WRITE_ROUND(row_slice, work_vars.carry_e[j][k], carry_e_values[k]); - - bitwise_lookup.add_range(carry_a_values[k], carry_e_values[k]); - } - - work_vars[7] = work_vars[6]; - work_vars[6] = work_vars[5]; - work_vars[5] = work_vars[4]; - work_vars[4] = e; - work_vars[3] = work_vars[2]; - work_vars[2] = work_vars[1]; - work_vars[1] = work_vars[0]; - work_vars[0] = a; - } - - if (i == 0) { - for (int j = 0; j < SHA256_ROUNDS_PER_ROW - 1; j++) { - for (int k = 0; k < SHA256_WORD_U16S; k++) { - SHA256INNER_WRITE_ROUND(row_slice, schedule_helper.w_3[j][k], Fp::zero()); - } - } - - for (int j = 0; j < SHA256_ROUNDS_PER_ROW; j++) { - for (int k = 0; k < SHA256_WORD_U16S; k++) { - SHA256INNER_WRITE_ROUND( - row_slice, schedule_helper.intermed_4[j][k], Fp::zero() - ); - SHA256INNER_WRITE_ROUND( - row_slice, schedule_helper.intermed_8[j][k], Fp::zero() - ); - SHA256INNER_WRITE_ROUND( - row_slice, schedule_helper.intermed_12[j][k], Fp::zero() - ); - } - } - } else if (i > 0) { - for (int j = 0; j < SHA256_ROUNDS_PER_ROW; j++) { - uint32_t idx = i * SHA256_ROUNDS_PER_ROW + j; - - uint32_t w_4 = message_schedule[idx - 4]; - uint32_t sig_0_w_3 = small_sig0(message_schedule[idx - 3]); - - SHA256INNER_WRITE_ROUND( - row_slice, - schedule_helper.intermed_4[j][0], - Fp(u32_to_u16_limb(w_4, 0) + u32_to_u16_limb(sig_0_w_3, 0)) - ); - SHA256INNER_WRITE_ROUND( - row_slice, - schedule_helper.intermed_4[j][1], - Fp(u32_to_u16_limb(w_4, 1) + u32_to_u16_limb(sig_0_w_3, 1)) - ); - - if (j < SHA256_ROUNDS_PER_ROW - 1) { - uint32_t w_3 = message_schedule[idx - 3]; - SHA256INNER_WRITE_ROUND( - row_slice, schedule_helper.w_3[j][0], u32_to_u16_limb(w_3, 0) - ); - SHA256INNER_WRITE_ROUND( - row_slice, schedule_helper.w_3[j][1], u32_to_u16_limb(w_3, 1) - ); - } - } - } - } else { - for (int j = 0; j < SHA256_ROUNDS_PER_ROW - 1; j++) { - uint32_t w_3 = message_schedule[i * SHA256_ROUNDS_PER_ROW + j - 3]; - SHA256INNER_WRITE_DIGEST( - row_slice, schedule_helper.w_3[j][0], u32_to_u16_limb(w_3, 0) - ); - SHA256INNER_WRITE_DIGEST( - row_slice, schedule_helper.w_3[j][1], u32_to_u16_limb(w_3, 1) - ); - } - - SHA256INNER_WRITE_DIGEST(row_slice, flags.is_round_row, Fp::zero()); - SHA256INNER_WRITE_DIGEST(row_slice, flags.is_first_4_rows, Fp::zero()); - SHA256INNER_WRITE_DIGEST(row_slice, flags.is_digest_row, Fp::one()); - SHA256INNER_WRITE_DIGEST( - row_slice, flags.is_last_block, is_last_block ? Fp::one() : Fp::zero() - ); - - RowSlice row_idx_flags = - row_slice.slice_from(COL_INDEX(Sha256DigestCols, flags.row_idx)); - row_idx_encoder.write_flag_pt(row_idx_flags, 16); - - SHA256INNER_WRITE_DIGEST(row_slice, flags.global_block_idx, global_block_idx); - SHA256INNER_WRITE_DIGEST(row_slice, flags.local_block_idx, local_block_idx); - - uint32_t final_hash[SHA256_HASH_WORDS]; - for (int j = 0; j < SHA256_HASH_WORDS; j++) { - final_hash[j] = work_vars[j] + prev_hash[j]; - } - - for (int j = 0; j < SHA256_HASH_WORDS; j++) { - uint8_t *hash_bytes = (uint8_t *)&final_hash[j]; - SHA256INNER_WRITE_ARRAY_DIGEST(row_slice, final_hash[j], hash_bytes); - -#pragma unroll - for (int chunk = 0; chunk < SHA256_WORD_U8S; chunk += 2) { - bitwise_lookup.add_range( - (uint32_t)hash_bytes[chunk], (uint32_t)hash_bytes[chunk + 1] - ); - } - } - - for (int j = 0; j < SHA256_HASH_WORDS; j++) { - SHA256INNER_WRITE_DIGEST( - row_slice, prev_hash[j][0], u32_to_u16_limb(prev_hash[j], 0) - ); - SHA256INNER_WRITE_DIGEST( - row_slice, prev_hash[j][1], u32_to_u16_limb(prev_hash[j], 1) - ); - } - - uint32_t hash[SHA256_HASH_WORDS]; - if (is_last_block) { - for (int j = 0; j < SHA256_HASH_WORDS; j++) { - hash[j] = SHA256_H[j]; - } - } else { - for (int j = 0; j < SHA256_HASH_WORDS; j++) { - hash[j] = final_hash[j]; - } - } - - for (int j = 0; j < SHA256_ROUNDS_PER_ROW; j++) { - COL_WRITE_BITS( - row_slice, Sha256DigestCols, hash.a[j], hash[SHA256_ROUNDS_PER_ROW - j - 1] - ); - COL_WRITE_BITS( - row_slice, Sha256DigestCols, hash.e[j], hash[SHA256_ROUNDS_PER_ROW - j + 3] - ); - } - } - } - for (int i = 0; i < SHA256_ROWS_PER_BLOCK - 1; i++) { - RowSlice local_row(trace + i, trace_height); - RowSlice next_row(trace + i + 1, trace_height); - - for (int j = 0; j < SHA256_ROUNDS_PER_ROW; j++) { - for (int k = 0; k < SHA256_WORD_U16S; k++) { - Fp intermed_4_val = - local_row[COL_INDEX(Sha256RoundCols, schedule_helper.intermed_4[j][k])]; - SHA256INNER_WRITE_ROUND(next_row, schedule_helper.intermed_8[j][k], intermed_4_val); - } - } - - if (i >= 2 && i <= 13) { - for (int j = 0; j < SHA256_ROUNDS_PER_ROW; j++) { - for (int k = 0; k < SHA256_WORD_U16S; k++) { - Fp intermed_8_val = - local_row[COL_INDEX(Sha256RoundCols, schedule_helper.intermed_8[j][k])]; - SHA256INNER_WRITE_ROUND( - next_row, schedule_helper.intermed_12[j][k], intermed_8_val - ); - } - } - } - - if (i == SHA256_ROWS_PER_BLOCK - 2) { - - generate_carry_ae(local_row, next_row); - generate_intermed_4(local_row, next_row); - } - - if (i <= 2) { - generate_intermed_12(local_row, next_row); - } - } -} - -__device__ void generate_default_row(RowSlice row_slice) { - Encoder row_idx_encoder(18, 2, false); - RowSlice row_idx_flags = row_slice.slice_from(COL_INDEX(Sha256RoundCols, flags.row_idx)); - row_idx_encoder.write_flag_pt(row_idx_flags, 17); - - for (int i = 0; i < SHA256_ROUNDS_PER_ROW; i++) { - uint32_t a_word = SHA256_H[3 - i]; - uint32_t e_word = SHA256_H[7 - i]; - - for (int bit = 0; bit < SHA256_WORD_BITS; bit++) { - SHA256INNER_WRITE_ROUND(row_slice, work_vars.a[i][bit], Fp((a_word >> bit) & 1)); - SHA256INNER_WRITE_ROUND(row_slice, work_vars.e[i][bit], Fp((e_word >> bit) & 1)); - } - -#pragma unroll - for (int j = 0; j < SHA256_WORD_U16S; j++) { - SHA256INNER_WRITE_ROUND( - row_slice, work_vars.carry_a[i][j], SHA256_INVALID_CARRY_A[i][j] - ); - SHA256INNER_WRITE_ROUND( - row_slice, work_vars.carry_e[i][j], SHA256_INVALID_CARRY_E[i][j] - ); - } - } -} - -__device__ __noinline__ void generate_missing_cells(Fp *trace_chunk, size_t trace_height) { - RowSlice row15(trace_chunk + 15, trace_height); - RowSlice row16(trace_chunk + 16, trace_height); - RowSlice row17(trace_chunk + 17, trace_height); - - generate_intermed_12(row15, row16); - generate_intermed_12(row16, row17); - generate_intermed_4(row16, row17); -} - -__global__ void sha256_second_pass_dependencies( - Fp *inner_trace_start, - size_t trace_height, - size_t total_sha256_blocks -) { - uint32_t sha256_block_idx = blockIdx.x * blockDim.x + threadIdx.x; - - if (sha256_block_idx >= total_sha256_blocks) { - return; - } - - Fp *block_start = inner_trace_start + (sha256_block_idx * SHA256_ROWS_PER_BLOCK); - generate_missing_cells(block_start, trace_height); -} diff --git a/crates/circuits/sha256-air/cuda/include/sha256-air/utils.cuh b/crates/circuits/sha256-air/cuda/include/sha256-air/utils.cuh deleted file mode 100644 index d93f75a1d0..0000000000 --- a/crates/circuits/sha256-air/cuda/include/sha256-air/utils.cuh +++ /dev/null @@ -1,177 +0,0 @@ -#pragma once - -#include "primitives/constants.h" -#include "primitives/utils.cuh" -#include "system/memory/offline_checker.cuh" - -using namespace riscv; -using namespace sha256; - -__device__ __host__ inline uint32_t get_sha256_num_blocks(uint32_t len) { - uint32_t bit_len = len * 8; - uint32_t padded_bit_len = bit_len + 1 + 64; - return (padded_bit_len + 511) >> 9; -} - -struct Sha256VmRecordHeader { - uint32_t from_pc; - uint32_t timestamp; - uint32_t rd_ptr; - uint32_t rs1_ptr; - uint32_t rs2_ptr; - uint32_t dst_ptr; - uint32_t src_ptr; - uint32_t len; - MemoryReadAuxRecord register_reads_aux[SHA256_REGISTER_READS]; - MemoryWriteBytesAuxRecord write_aux; -}; - -struct Sha256VmRecordMut { - Sha256VmRecordHeader *header; - uint8_t *input; - MemoryReadAuxRecord *read_aux; - - __device__ __host__ __forceinline__ static uint32_t next_multiple_of( - uint32_t value, - uint32_t alignment - ) { - return ((value + alignment - 1) / alignment) * alignment; - } - - __device__ __host__ __forceinline__ Sha256VmRecordMut(uint8_t *record_buf) { - // Use memcpy for safe unaligned access instead of reinterpret_cast - header = reinterpret_cast(record_buf); - - uint32_t offset = sizeof(Sha256VmRecordHeader); - - input = record_buf + offset; - uint32_t num_blocks = get_sha256_num_blocks(header->len); - uint32_t input_size = num_blocks * SHA256_BLOCK_U8S; - - offset += input_size; - offset = next_multiple_of(offset, alignof(MemoryReadAuxRecord)); - - read_aux = reinterpret_cast(record_buf + offset); - } -}; - -__device__ static constexpr uint32_t SHA256_K[64] = { - 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, - 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, - 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, - 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, - 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, - 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, - 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, - 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2, -}; - -__device__ static constexpr uint32_t SHA256_H[8] = { - 0x6a09e667, - 0xbb67ae85, - 0x3c6ef372, - 0xa54ff53a, - 0x510e527f, - 0x9b05688c, - 0x1f83d9ab, - 0x5be0cd19, -}; - -__device__ static constexpr uint32_t SHA256_INVALID_CARRY_A[SHA256_ROUNDS_PER_ROW] - [SHA256_WORD_U16S] = { - {1230919683, 1162494304}, - {266373122, 1282901987}, - {1519718403, 1008990871}, - {923381762, 330807052}, -}; - -__device__ static constexpr uint32_t SHA256_INVALID_CARRY_E[SHA256_ROUNDS_PER_ROW] - [SHA256_WORD_U16S] = { - {204933122, 1994683449}, - {443873282, 1544639095}, - {719953922, 1888246508}, - {194580482, 1075725211}, -}; - -__device__ inline uint32_t ch(uint32_t x, uint32_t y, uint32_t z) { return (x & y) ^ ((~x) & z); } - -__device__ inline uint32_t maj(uint32_t x, uint32_t y, uint32_t z) { - return (x & y) ^ (x & z) ^ (y & z); -} - -__device__ inline uint32_t big_sig0(uint32_t x) { return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22); } - -__device__ inline uint32_t big_sig1(uint32_t x) { return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25); } - -__device__ inline uint32_t small_sig0(uint32_t x) { return rotr(x, 7) ^ rotr(x, 18) ^ (x >> 3); } - -__device__ inline uint32_t small_sig1(uint32_t x) { return rotr(x, 17) ^ rotr(x, 19) ^ (x >> 10); } - -enum class PaddingFlags : uint32_t { - NotConsidered = 0, - NotPadding = 1, - FirstPadding0 = 2, - FirstPadding1 = 3, - FirstPadding2 = 4, - FirstPadding3 = 5, - FirstPadding4 = 6, - FirstPadding5 = 7, - FirstPadding6 = 8, - FirstPadding7 = 9, - FirstPadding8 = 10, - FirstPadding9 = 11, - FirstPadding10 = 12, - FirstPadding11 = 13, - FirstPadding12 = 14, - FirstPadding13 = 15, - FirstPadding14 = 16, - FirstPadding15 = 17, - FirstPadding0_LastRow = 18, - FirstPadding1_LastRow = 19, - FirstPadding2_LastRow = 20, - FirstPadding3_LastRow = 21, - FirstPadding4_LastRow = 22, - FirstPadding5_LastRow = 23, - FirstPadding6_LastRow = 24, - FirstPadding7_LastRow = 25, - EntirePaddingLastRow = 26, - EntirePadding = 27, - COUNT = 28, -}; - -__device__ inline MemoryReadAuxRecord *get_read_aux_record( - const Sha256VmRecordMut *record, - uint32_t block_idx, - uint32_t read_row_idx -) { - return &record->read_aux[block_idx * SHA256_NUM_READ_ROWS + read_row_idx]; -} - -__device__ inline uint16_t u32_to_u16_limb(uint32_t value, uint32_t limb_idx) { - return ((uint16_t *)&value)[limb_idx]; -} - -__device__ inline void sha256_pad_input( - const uint8_t *input, - uint32_t len, - uint8_t *padded_output, - uint32_t num_blocks -) { -#pragma unroll - for (uint32_t i = 0; i < len; i++) { - padded_output[i] = input[i]; - } - - padded_output[len] = 0x80; - - uint32_t total_len = num_blocks * SHA256_BLOCK_U8S; - for (uint32_t i = len + 1; i < total_len - 8; i++) { - padded_output[i] = 0; - } - - uint64_t bit_len = static_cast(len) * 8; -#pragma unroll - for (int i = 0; i < 8; i++) { - padded_output[total_len - 8 + i] = static_cast(bit_len >> (8 * (7 - i))); - } -} \ No newline at end of file diff --git a/crates/circuits/sha256-air/src/air.rs b/crates/circuits/sha256-air/src/air.rs deleted file mode 100644 index 304074113c..0000000000 --- a/crates/circuits/sha256-air/src/air.rs +++ /dev/null @@ -1,612 +0,0 @@ -use std::{array, borrow::Borrow, cmp::max, iter::once}; - -use openvm_circuit_primitives::{ - bitwise_op_lookup::BitwiseOperationLookupBus, - encoder::Encoder, - utils::{not, select}, - SubAir, -}; -use openvm_stark_backend::{ - interaction::{BusIndex, InteractionBuilder, PermutationCheckBus}, - p3_air::{AirBuilder, BaseAir}, - p3_field::{Field, PrimeCharacteristicRing}, - p3_matrix::Matrix, -}; - -use super::{ - big_sig0_field, big_sig1_field, ch_field, compose, maj_field, small_sig0_field, - small_sig1_field, Sha256DigestCols, Sha256RoundCols, SHA256_DIGEST_WIDTH, SHA256_H, - SHA256_HASH_WORDS, SHA256_K, SHA256_ROUNDS_PER_ROW, SHA256_ROUND_WIDTH, SHA256_WORD_BITS, - SHA256_WORD_U16S, SHA256_WORD_U8S, -}; -use crate::{constraint_word_addition, u32_into_u16s}; - -/// Expects the message to be padded to a multiple of 512 bits -#[derive(Clone, Debug)] -pub struct Sha256Air { - pub bitwise_lookup_bus: BitwiseOperationLookupBus, - pub row_idx_encoder: Encoder, - /// Internal bus for self-interactions in this AIR. - bus: PermutationCheckBus, -} - -impl Sha256Air { - pub fn new(bitwise_lookup_bus: BitwiseOperationLookupBus, self_bus_idx: BusIndex) -> Self { - Self { - bitwise_lookup_bus, - row_idx_encoder: Encoder::new(18, 2, false), - bus: PermutationCheckBus::new(self_bus_idx), - } - } -} - -impl BaseAir for Sha256Air { - fn width(&self) -> usize { - max( - Sha256RoundCols::::width(), - Sha256DigestCols::::width(), - ) - } -} - -impl SubAir for Sha256Air { - /// The start column for the sub-air to use - type AirContext<'a> - = usize - where - Self: 'a, - AB: 'a, - ::Var: 'a, - ::Expr: 'a; - - fn eval<'a>(&'a self, builder: &'a mut AB, start_col: Self::AirContext<'a>) - where - ::Var: 'a, - ::Expr: 'a, - { - self.eval_row(builder, start_col); - self.eval_transitions(builder, start_col); - } -} - -impl Sha256Air { - /// Implements the single row constraints (i.e. imposes constraints only on local) - /// Implements some sanity constraints on the row index, flags, and work variables - fn eval_row(&self, builder: &mut AB, start_col: usize) { - let main = builder.main(); - let local = main.row_slice(0).expect("window should have two elements"); - - // Doesn't matter which column struct we use here as we are only interested in the common - // columns - let local_cols: &Sha256DigestCols = - local[start_col..start_col + SHA256_DIGEST_WIDTH].borrow(); - let flags = &local_cols.flags; - builder.assert_bool(flags.is_round_row); - builder.assert_bool(flags.is_first_4_rows); - builder.assert_bool(flags.is_digest_row); - builder.assert_bool(flags.is_round_row + flags.is_digest_row); - builder.assert_bool(flags.is_last_block); - - self.row_idx_encoder - .eval(builder, &local_cols.flags.row_idx); - builder.assert_one( - self.row_idx_encoder - .contains_flag_range::(&local_cols.flags.row_idx, 0..=17), - ); - builder.assert_eq( - self.row_idx_encoder - .contains_flag_range::(&local_cols.flags.row_idx, 0..=3), - flags.is_first_4_rows, - ); - builder.assert_eq( - self.row_idx_encoder - .contains_flag_range::(&local_cols.flags.row_idx, 0..=15), - flags.is_round_row, - ); - builder.assert_eq( - self.row_idx_encoder - .contains_flag::(&local_cols.flags.row_idx, &[16]), - flags.is_digest_row, - ); - // If padding row we want the row_idx to be 17 - builder.assert_eq( - self.row_idx_encoder - .contains_flag::(&local_cols.flags.row_idx, &[17]), - flags.is_padding_row(), - ); - - // Constrain a, e, being composed of bits: we make sure a and e are always in the same place - // in the trace matrix Note: this has to be true for every row, even padding rows - for i in 0..SHA256_ROUNDS_PER_ROW { - for j in 0..SHA256_WORD_BITS { - builder.assert_bool(local_cols.hash.a[i][j]); - builder.assert_bool(local_cols.hash.e[i][j]); - } - } - } - - /// Implements constraints for a digest row that ensure proper state transitions between blocks - /// This validates that: - /// The work variables are correctly initialized for the next message block - /// For the last message block, the initial state matches SHA256_H constants - fn eval_digest_row( - &self, - builder: &mut AB, - local: &Sha256RoundCols, - next: &Sha256DigestCols, - ) { - // Check that if this is the last row of a message or an inpadding row, the hash should be - // the [SHA256_H] - for i in 0..SHA256_ROUNDS_PER_ROW { - let a = next.hash.a[i].map(|x| x.into()); - let e = next.hash.e[i].map(|x| x.into()); - for j in 0..SHA256_WORD_U16S { - let a_limb = compose::(&a[j * 16..(j + 1) * 16], 1); - let e_limb = compose::(&e[j * 16..(j + 1) * 16], 1); - - // If it is a padding row or the last row of a message, the `hash` should be the - // [SHA256_H] - builder - .when( - next.flags.is_padding_row() - + next.flags.is_last_block * next.flags.is_digest_row, - ) - .assert_eq( - a_limb, - AB::Expr::from_u32( - u32_into_u16s(SHA256_H[SHA256_ROUNDS_PER_ROW - i - 1])[j], - ), - ); - - builder - .when( - next.flags.is_padding_row() - + next.flags.is_last_block * next.flags.is_digest_row, - ) - .assert_eq( - e_limb, - AB::Expr::from_u32( - u32_into_u16s(SHA256_H[SHA256_ROUNDS_PER_ROW - i + 3])[j], - ), - ); - } - } - - // Check if last row of a non-last block, the `hash` should be equal to the final hash of - // the current block - for i in 0..SHA256_ROUNDS_PER_ROW { - let prev_a = next.hash.a[i].map(|x| x.into()); - let prev_e = next.hash.e[i].map(|x| x.into()); - let cur_a = next.final_hash[SHA256_ROUNDS_PER_ROW - i - 1].map(|x| x.into()); - - let cur_e = next.final_hash[SHA256_ROUNDS_PER_ROW - i + 3].map(|x| x.into()); - for j in 0..SHA256_WORD_U8S { - let prev_a_limb = compose::(&prev_a[j * 8..(j + 1) * 8], 1); - let prev_e_limb = compose::(&prev_e[j * 8..(j + 1) * 8], 1); - - builder - .when(not(next.flags.is_last_block) * next.flags.is_digest_row) - .assert_eq(prev_a_limb, cur_a[j].clone()); - - builder - .when(not(next.flags.is_last_block) * next.flags.is_digest_row) - .assert_eq(prev_e_limb, cur_e[j].clone()); - } - } - - // Assert that the previous hash + work vars == final hash. - // That is, `next.prev_hash[i] + local.work_vars[i] == next.final_hash[i]` - // where addition is done modulo 2^32 - for i in 0..SHA256_HASH_WORDS { - let mut carry = AB::Expr::ZERO; - for j in 0..SHA256_WORD_U16S { - let work_var_limb = if i < SHA256_ROUNDS_PER_ROW { - compose::( - &local.work_vars.a[SHA256_ROUNDS_PER_ROW - 1 - i][j * 16..(j + 1) * 16], - 1, - ) - } else { - compose::( - &local.work_vars.e[SHA256_ROUNDS_PER_ROW + 3 - i][j * 16..(j + 1) * 16], - 1, - ) - }; - let final_hash_limb = - compose::(&next.final_hash[i][j * 2..(j + 1) * 2], 8); - - carry = AB::Expr::from(AB::F::from_u32(1 << 16).inverse()) - * (next.prev_hash[i][j] + work_var_limb + carry - final_hash_limb); - builder - .when(next.flags.is_digest_row) - .assert_bool(carry.clone()); - } - // constrain the final hash limbs two at a time since we can do two checks per - // interaction - for chunk in next.final_hash[i].chunks(2) { - self.bitwise_lookup_bus - .send_range(chunk[0], chunk[1]) - .eval(builder, next.flags.is_digest_row); - } - } - } - - fn eval_transitions(&self, builder: &mut AB, start_col: usize) { - let main = builder.main(); - let local = main.row_slice(0).expect("window should have two elements"); - let next = main.row_slice(1).expect("window should have two elements"); - - // Doesn't matter what column structs we use here - let local_cols: &Sha256RoundCols = - local[start_col..start_col + SHA256_ROUND_WIDTH].borrow(); - let next_cols: &Sha256RoundCols = - next[start_col..start_col + SHA256_ROUND_WIDTH].borrow(); - - let local_is_padding_row = local_cols.flags.is_padding_row(); - // Note that there will always be a padding row in the trace since the unpadded height is a - // multiple of 17. So the next row is padding iff the current block is the last - // block in the trace. - let next_is_padding_row = next_cols.flags.is_padding_row(); - - // We check that the very last block has `is_last_block` set to true, which guarantees that - // there is at least one complete message. If other digest rows have `is_last_block` set to - // true, then the trace will be interpreted as containing multiple messages. - builder - .when(next_is_padding_row.clone()) - .when(local_cols.flags.is_digest_row) - .assert_one(local_cols.flags.is_last_block); - // If we are in a round row, the next row cannot be a padding row - builder - .when(local_cols.flags.is_round_row) - .assert_zero(next_is_padding_row.clone()); - // The first row must be a round row - builder - .when_first_row() - .assert_one(local_cols.flags.is_round_row); - // If we are in a padding row, the next row must also be a padding row - builder - .when_transition() - .when(local_is_padding_row.clone()) - .assert_one(next_is_padding_row.clone()); - // If we are in a digest row, the next row cannot be a digest row - builder - .when(local_cols.flags.is_digest_row) - .assert_zero(next_cols.flags.is_digest_row); - // Constrain how much the row index changes by - // round->round: 1 - // round->digest: 1 - // digest->round: -16 - // digest->padding: 1 - // padding->padding: 0 - // Other transitions are not allowed by the above constraints - let delta = local_cols.flags.is_round_row * AB::Expr::ONE - + local_cols.flags.is_digest_row - * next_cols.flags.is_round_row - * AB::Expr::from_u32(16) - * AB::Expr::NEG_ONE - + local_cols.flags.is_digest_row * next_is_padding_row.clone() * AB::Expr::ONE; - - let local_row_idx = self.row_idx_encoder.flag_with_val::( - &local_cols.flags.row_idx, - &(0..18).map(|i| (i, i)).collect::>(), - ); - let next_row_idx = self.row_idx_encoder.flag_with_val::( - &next_cols.flags.row_idx, - &(0..18).map(|i| (i, i)).collect::>(), - ); - - builder - .when_transition() - .assert_eq(local_row_idx.clone() + delta, next_row_idx.clone()); - builder.when_first_row().assert_zero(local_row_idx); - - // Constrain the global block index - // We set the global block index to 0 for padding rows - // Starting with 1 so it is not the same as the padding rows - - // Global block index is 1 on first row - builder - .when_first_row() - .assert_one(local_cols.flags.global_block_idx); - - // Global block index is constant on all rows in a block - builder.when(local_cols.flags.is_round_row).assert_eq( - local_cols.flags.global_block_idx, - next_cols.flags.global_block_idx, - ); - // Global block index increases by 1 between blocks - builder - .when_transition() - .when(local_cols.flags.is_digest_row) - .when(next_cols.flags.is_round_row) - .assert_eq( - local_cols.flags.global_block_idx + AB::Expr::ONE, - next_cols.flags.global_block_idx, - ); - // Global block index is 0 on padding rows - builder - .when(local_is_padding_row.clone()) - .assert_zero(local_cols.flags.global_block_idx); - - // Constrain the local block index - // We set the local block index to 0 for padding rows - - // Local block index is constant on all rows in a block - // and its value on padding rows is equal to its value on the first block - builder.when(not(local_cols.flags.is_digest_row)).assert_eq( - local_cols.flags.local_block_idx, - next_cols.flags.local_block_idx, - ); - // Local block index increases by 1 between blocks in the same message - builder - .when(local_cols.flags.is_digest_row) - .when(not(local_cols.flags.is_last_block)) - .assert_eq( - local_cols.flags.local_block_idx + AB::Expr::ONE, - next_cols.flags.local_block_idx, - ); - // Local block index is 0 on padding rows - // Combined with the above, this means that the local block index is 0 in the first block - builder - .when(local_cols.flags.is_digest_row) - .when(local_cols.flags.is_last_block) - .assert_zero(next_cols.flags.local_block_idx); - - self.eval_message_schedule::(builder, local_cols, next_cols); - self.eval_work_vars::(builder, local_cols, next_cols); - let next_cols: &Sha256DigestCols = - next[start_col..start_col + SHA256_DIGEST_WIDTH].borrow(); - self.eval_digest_row(builder, local_cols, next_cols); - let local_cols: &Sha256DigestCols = - local[start_col..start_col + SHA256_DIGEST_WIDTH].borrow(); - self.eval_prev_hash::(builder, local_cols, next_is_padding_row); - } - - /// Constrains that the next block's `prev_hash` is equal to the current block's `hash` - /// Note: the constraining is done by interactions with the chip itself on every digest row - fn eval_prev_hash( - &self, - builder: &mut AB, - local: &Sha256DigestCols, - is_last_block_of_trace: AB::Expr, /* note this indicates the last block of the trace, - * not the last block of the message */ - ) { - // Constrain that next block's `prev_hash` is equal to the current block's `hash` - let composed_hash: [[::Expr; SHA256_WORD_U16S]; SHA256_HASH_WORDS] = - array::from_fn(|i| { - let hash_bits = if i < SHA256_ROUNDS_PER_ROW { - local.hash.a[SHA256_ROUNDS_PER_ROW - 1 - i].map(|x| x.into()) - } else { - local.hash.e[SHA256_ROUNDS_PER_ROW + 3 - i].map(|x| x.into()) - }; - array::from_fn(|j| compose::(&hash_bits[j * 16..(j + 1) * 16], 1)) - }); - // Need to handle the case if this is the very last block of the trace matrix - let next_global_block_idx = select( - is_last_block_of_trace, - AB::Expr::ONE, - local.flags.global_block_idx + AB::Expr::ONE, - ); - // The following interactions constrain certain values from block to block - self.bus.send( - builder, - composed_hash - .into_iter() - .flatten() - .chain(once(next_global_block_idx)), - local.flags.is_digest_row, - ); - - self.bus.receive( - builder, - local - .prev_hash - .into_iter() - .flatten() - .map(|x| x.into()) - .chain(once(local.flags.global_block_idx.into())), - local.flags.is_digest_row, - ); - } - - /// Constrain the message schedule additions for `next` row - /// Note: For every addition we need to constrain the following for each of [SHA256_WORD_U16S] - /// limbs sig_1(w_{t-2})[i] + w_{t-7}[i] + sig_0(w_{t-15})[i] + w_{t-16}[i] + - /// carry_w[t][i-1] - carry_w[t][i] * 2^16 - w_t[i] == 0 Refer to [https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf] - fn eval_message_schedule( - &self, - builder: &mut AB, - local: &Sha256RoundCols, - next: &Sha256RoundCols, - ) { - // This `w` array contains 8 message schedule words - w_{idx}, ..., w_{idx+7} for some idx - let w = [local.message_schedule.w, next.message_schedule.w].concat(); - - // Constrain `w_3` for `next` row - for i in 0..SHA256_ROUNDS_PER_ROW - 1 { - // here we constrain the w_3 of the i_th word of the next row - // w_3 of next is w[i+4-3] = w[i+1] - let w_3 = w[i + 1].map(|x| x.into()); - let expected_w_3 = next.schedule_helper.w_3[i]; - for j in 0..SHA256_WORD_U16S { - let w_3_limb = compose::(&w_3[j * 16..(j + 1) * 16], 1); - builder - .when(local.flags.is_round_row) - .assert_eq(w_3_limb, expected_w_3[j].into()); - } - } - - // Constrain intermed for `next` row - // We will only constrain intermed_12 for rows [3, 14], and let it be unconstrained for - // other rows Other rows should put the needed value in intermed_12 to make the - // below summation constraint hold - let is_row_3_14 = self - .row_idx_encoder - .contains_flag_range::(&next.flags.row_idx, 3..=14); - // We will only constrain intermed_8 for rows [2, 13], and let it unconstrained for other - // rows - let is_row_2_13 = self - .row_idx_encoder - .contains_flag_range::(&next.flags.row_idx, 2..=13); - for i in 0..SHA256_ROUNDS_PER_ROW { - // w_idx - let w_idx = w[i].map(|x| x.into()); - // sig_0(w_{idx+1}) - let sig_w = small_sig0_field::(&w[i + 1]); - for j in 0..SHA256_WORD_U16S { - let w_idx_limb = compose::(&w_idx[j * 16..(j + 1) * 16], 1); - let sig_w_limb = compose::(&sig_w[j * 16..(j + 1) * 16], 1); - - // We would like to constrain this only on rows 0..16, but we can't do a conditional - // check because the degree is already 3. So we must fill in - // `intermed_4` with dummy values on rows 0 and 16 to ensure the constraint holds on - // these rows. - builder.when_transition().assert_eq( - next.schedule_helper.intermed_4[i][j], - w_idx_limb + sig_w_limb, - ); - - builder.when(is_row_2_13.clone()).assert_eq( - next.schedule_helper.intermed_8[i][j], - local.schedule_helper.intermed_4[i][j], - ); - - builder.when(is_row_3_14.clone()).assert_eq( - next.schedule_helper.intermed_12[i][j], - local.schedule_helper.intermed_8[i][j], - ); - } - } - - // Constrain the message schedule additions for `next` row - for i in 0..SHA256_ROUNDS_PER_ROW { - // Note, here by w_{t} we mean the i_th word of the `next` row - // w_{t-7} - let w_7 = if i < 3 { - local.schedule_helper.w_3[i].map(|x| x.into()) - } else { - let w_3 = w[i - 3].map(|x| x.into()); - array::from_fn(|j| compose::(&w_3[j * 16..(j + 1) * 16], 1)) - }; - // sig_0(w_{t-15}) + w_{t-16} - let intermed_16 = local.schedule_helper.intermed_12[i].map(|x| x.into()); - - let carries = array::from_fn(|j| { - next.message_schedule.carry_or_buffer[i][j * 2] - + AB::Expr::TWO * next.message_schedule.carry_or_buffer[i][j * 2 + 1] - }); - - // Constrain `W_{idx} = sig_1(W_{idx-2}) + W_{idx-7} + sig_0(W_{idx-15}) + W_{idx-16}` - // We would like to constrain this only on rows 4..16, but we can't do a conditional - // check because the degree of sum is already 3 So we must fill in - // `intermed_12` with dummy values on rows 0..3 and 15 and 16 to ensure the constraint - // holds on rows 0..4 and 16. Note that the dummy value goes in the previous - // row to make the current row's constraint hold. - constraint_word_addition( - // Note: here we can't do a conditional check because the degree of sum is already - // 3 - &mut builder.when_transition(), - &[&small_sig1_field::(&w[i + 2])], - &[&w_7, &intermed_16], - &w[i + 4], - &carries, - ); - - for j in 0..SHA256_WORD_U16S { - // When on rows 4..16 message schedule carries should be 0 or 1 - let is_row_4_15 = next.flags.is_round_row - next.flags.is_first_4_rows; - builder - .when(is_row_4_15.clone()) - .assert_bool(next.message_schedule.carry_or_buffer[i][j * 2]); - builder - .when(is_row_4_15) - .assert_bool(next.message_schedule.carry_or_buffer[i][j * 2 + 1]); - } - // Constrain w being composed of bits - for j in 0..SHA256_WORD_BITS { - builder - .when(next.flags.is_round_row) - .assert_bool(next.message_schedule.w[i][j]); - } - } - } - - /// Constrain the work vars on `next` row according to the sha256 documentation - /// Refer to [https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf] - fn eval_work_vars( - &self, - builder: &mut AB, - local: &Sha256RoundCols, - next: &Sha256RoundCols, - ) { - let a = [local.work_vars.a, next.work_vars.a].concat(); - let e = [local.work_vars.e, next.work_vars.e].concat(); - for i in 0..SHA256_ROUNDS_PER_ROW { - for j in 0..SHA256_WORD_U16S { - // Although we need carry_a <= 6 and carry_e <= 5, constraining carry_a, carry_e in - // [0, 2^8) is enough to prevent overflow and ensure the soundness - // of the addition we want to check - self.bitwise_lookup_bus - .send_range(local.work_vars.carry_a[i][j], local.work_vars.carry_e[i][j]) - .eval(builder, local.flags.is_round_row); - } - - let w_limbs = array::from_fn(|j| { - compose::(&next.message_schedule.w[i][j * 16..(j + 1) * 16], 1) - * next.flags.is_round_row - }); - let k_limbs = array::from_fn(|j| { - self.row_idx_encoder.flag_with_val::( - &next.flags.row_idx, - &(0..16) - .map(|rw_idx| { - ( - rw_idx, - u32_into_u16s(SHA256_K[rw_idx * SHA256_ROUNDS_PER_ROW + i])[j] - as usize, - ) - }) - .collect::>(), - ) - }); - - // Constrain `a = h + sig_1(e) + ch(e, f, g) + K + W + sig_0(a) + Maj(a, b, c)` - // We have to enforce this constraint on all rows since the degree of the constraint is - // already 3. So, we must fill in `carry_a` with dummy values on digest rows - // to ensure the constraint holds. - constraint_word_addition( - builder, - &[ - &e[i].map(|x| x.into()), // previous `h` - &big_sig1_field::(&e[i + 3]), // sig_1 of previous `e` - &ch_field::(&e[i + 3], &e[i + 2], &e[i + 1]), /* Ch of previous - * `e`, `f`, `g` */ - &big_sig0_field::(&a[i + 3]), // sig_0 of previous `a` - &maj_field::(&a[i + 3], &a[i + 2], &a[i + 1]), /* Maj of previous - * a, b, c */ - ], - &[&w_limbs, &k_limbs], // K and W - &a[i + 4], // new `a` - &next.work_vars.carry_a[i], // carries of addition - ); - - // Constrain `e = d + h + sig_1(e) + ch(e, f, g) + K + W` - // We have to enforce this constraint on all rows since the degree of the constraint is - // already 3. So, we must fill in `carry_e` with dummy values on digest rows - // to ensure the constraint holds. - constraint_word_addition( - builder, - &[ - &a[i].map(|x| x.into()), // previous `d` - &e[i].map(|x| x.into()), // previous `h` - &big_sig1_field::(&e[i + 3]), /* sig_1 of previous - * `e` */ - &ch_field::(&e[i + 3], &e[i + 2], &e[i + 1]), /* Ch of previous - * `e`, `f`, `g` */ - ], - &[&w_limbs, &k_limbs], // K and W - &e[i + 4], // new `e` - &next.work_vars.carry_e[i], // carries of addition - ); - } - } -} diff --git a/crates/circuits/sha256-air/src/columns.rs b/crates/circuits/sha256-air/src/columns.rs deleted file mode 100644 index f7f22fff6a..0000000000 --- a/crates/circuits/sha256-air/src/columns.rs +++ /dev/null @@ -1,140 +0,0 @@ -//! WARNING: the order of fields in the structs is important, do not change it - -use openvm_circuit_primitives::{utils::not, AlignedBorrow}; -use openvm_stark_backend::p3_field::PrimeCharacteristicRing; - -use super::{ - SHA256_HASH_WORDS, SHA256_ROUNDS_PER_ROW, SHA256_ROW_VAR_CNT, SHA256_WORD_BITS, - SHA256_WORD_U16S, SHA256_WORD_U8S, -}; - -/// In each SHA256 block: -/// - First 16 rows use Sha256RoundCols -/// - Final row uses Sha256DigestCols -/// -/// Note that for soundness, we require that there is always a padding row after the last digest row -/// in the trace. Right now, this is true because the unpadded height is a multiple of 17, and thus -/// not a power of 2. -/// -/// Sha256RoundCols and Sha256DigestCols share the same first 3 fields: -/// - flags -/// - work_vars/hash (same type, different name) -/// - schedule_helper -/// -/// This design allows for: -/// 1. Common constraints to work on either struct type by accessing these shared fields -/// 2. Specific constraints to use the appropriate struct, with flags helping to do conditional -/// constraints -/// -/// Note that the `Sha256WorkVarsCols` field it is used for different purposes in the two structs. -#[repr(C)] -#[derive(Clone, Copy, Debug, AlignedBorrow)] -pub struct Sha256RoundCols { - pub flags: Sha256FlagsCols, - /// Stores the current state of the working variables - pub work_vars: Sha256WorkVarsCols, - pub schedule_helper: Sha256MessageHelperCols, - pub message_schedule: Sha256MessageScheduleCols, -} - -#[repr(C)] -#[derive(Clone, Copy, Debug, AlignedBorrow)] -pub struct Sha256DigestCols { - pub flags: Sha256FlagsCols, - /// Will serve as previous hash values for the next block. - /// - on non-last blocks, this is the final hash of the current block - /// - on last blocks, this is the initial state constants, SHA256_H. - /// The work variables constraints are applied on all rows, so `carry_a` and `carry_e` - /// must be filled in with dummy values to ensure these constraints hold. - pub hash: Sha256WorkVarsCols, - pub schedule_helper: Sha256MessageHelperCols, - /// The actual final hash values of the given block - /// Note: the above `hash` will be equal to `final_hash` unless we are on the last block - pub final_hash: [[T; SHA256_WORD_U8S]; SHA256_HASH_WORDS], - /// The final hash of the previous block - /// Note: will be constrained using interactions with the chip itself - pub prev_hash: [[T; SHA256_WORD_U16S]; SHA256_HASH_WORDS], -} - -#[repr(C)] -#[derive(Clone, Copy, Debug, AlignedBorrow)] -pub struct Sha256MessageScheduleCols { - /// The message schedule words as 32-bit integers - /// The first 16 words will be the message data - pub w: [[T; SHA256_WORD_BITS]; SHA256_ROUNDS_PER_ROW], - /// Will be message schedule carries for rows 4..16 and a buffer for rows 0..4 to be used - /// freely by wrapper chips Note: carries are 2 bit numbers represented using 2 cells as - /// individual bits - pub carry_or_buffer: [[T; SHA256_WORD_U8S]; SHA256_ROUNDS_PER_ROW], -} - -#[repr(C)] -#[derive(Clone, Copy, Debug, AlignedBorrow)] -pub struct Sha256WorkVarsCols { - /// `a` and `e` after each iteration as 32-bits - pub a: [[T; SHA256_WORD_BITS]; SHA256_ROUNDS_PER_ROW], - pub e: [[T; SHA256_WORD_BITS]; SHA256_ROUNDS_PER_ROW], - /// The carry's used for addition during each iteration when computing `a` and `e` - pub carry_a: [[T; SHA256_WORD_U16S]; SHA256_ROUNDS_PER_ROW], - pub carry_e: [[T; SHA256_WORD_U16S]; SHA256_ROUNDS_PER_ROW], -} - -/// These are the columns that are used to help with the message schedule additions -/// Note: these need to be correctly assigned for every row even on padding rows -#[repr(C)] -#[derive(Clone, Copy, Debug, AlignedBorrow)] -pub struct Sha256MessageHelperCols { - /// The following are used to move data forward to constrain the message schedule additions - /// The value of `w` (message schedule word) from 3 rounds ago - /// In general, `w_i` means `w` from `i` rounds ago - pub w_3: [[T; SHA256_WORD_U16S]; SHA256_ROUNDS_PER_ROW - 1], - /// Here intermediate(i) = w_i + sig_0(w_{i+1}) - /// Intermed_t represents the intermediate t rounds ago - /// This is needed to constrain the message schedule, since we can only constrain on two rows - /// at a time - pub intermed_4: [[T; SHA256_WORD_U16S]; SHA256_ROUNDS_PER_ROW], - pub intermed_8: [[T; SHA256_WORD_U16S]; SHA256_ROUNDS_PER_ROW], - pub intermed_12: [[T; SHA256_WORD_U16S]; SHA256_ROUNDS_PER_ROW], -} - -#[repr(C)] -#[derive(Clone, Copy, Debug, AlignedBorrow)] -pub struct Sha256FlagsCols { - /// A flag that indicates if the current row is among the first 16 rows of a block. - pub is_round_row: T, - /// A flag that indicates if the current row is among the first 4 rows of a block. - pub is_first_4_rows: T, - /// A flag that indicates if the current row is the last (17th) row of a block. - pub is_digest_row: T, - // A flag that indicates if the current row is the last block of the message. - // This flag is only used in digest rows. - pub is_last_block: T, - /// We will encode the row index [0..17) using 5 cells - pub row_idx: [T; SHA256_ROW_VAR_CNT], - /// The index of the current block in the trace starting at 1. - /// Set to 0 on padding rows. - pub global_block_idx: T, - /// The index of the current block in the current message starting at 0. - /// Resets after every message. - /// Set to 0 on padding rows. - pub local_block_idx: T, -} - -impl> Sha256FlagsCols { - // This refers to the padding rows that are added to the air to make the trace length a power of - // 2. Not to be confused with the padding added to messages as part of the SHA hash - // function. - pub fn is_not_padding_row(&self) -> O { - self.is_round_row + self.is_digest_row - } - - // This refers to the padding rows that are added to the air to make the trace length a power of - // 2. Not to be confused with the padding added to messages as part of the SHA hash - // function. - pub fn is_padding_row(&self) -> O - where - O: PrimeCharacteristicRing, - { - not(self.is_not_padding_row()) - } -} diff --git a/crates/circuits/sha256-air/src/lib.rs b/crates/circuits/sha256-air/src/lib.rs deleted file mode 100644 index 48bdaee5f9..0000000000 --- a/crates/circuits/sha256-air/src/lib.rs +++ /dev/null @@ -1,15 +0,0 @@ -//! Implementation of the SHA256 compression function without padding -//! This this AIR doesn't constrain any of the message padding - -mod air; -mod columns; -mod trace; -mod utils; - -pub use air::*; -pub use columns::*; -pub use trace::*; -pub use utils::*; - -#[cfg(test)] -mod tests; diff --git a/crates/circuits/sha256-air/src/tests.rs b/crates/circuits/sha256-air/src/tests.rs deleted file mode 100644 index e4b490acaa..0000000000 --- a/crates/circuits/sha256-air/src/tests.rs +++ /dev/null @@ -1,163 +0,0 @@ -use std::{array, borrow::BorrowMut, sync::Arc}; - -use openvm_circuit::arch::{ - instructions::riscv::RV32_CELL_BITS, - testing::{VmChipTestBuilder, BITWISE_OP_LOOKUP_BUS}, -}; -use openvm_circuit_primitives::{ - bitwise_op_lookup::{ - BitwiseOperationLookupAir, BitwiseOperationLookupBus, BitwiseOperationLookupChip, - SharedBitwiseOperationLookupChip, - }, - Chip, SubAir, -}; -use openvm_cpu_backend::CpuBackend; -use openvm_stark_backend::{ - interaction::{BusIndex, InteractionBuilder}, - p3_air::{Air, BaseAir}, - p3_field::{Field, PrimeCharacteristicRing, PrimeField32}, - p3_matrix::{dense::RowMajorMatrix, Matrix}, - prover::AirProvingContext, - utils::disable_debug_builder, - AirRef, BaseAirWithPublicValues, PartitionedBaseAir, StarkProtocolConfig, StarkTestError, Val, -}; -use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng}; -use rand::Rng; - -use crate::{ - Sha256Air, Sha256DigestCols, Sha256FillerHelper, SHA256_BLOCK_U8S, SHA256_DIGEST_WIDTH, - SHA256_HASH_WORDS, SHA256_WIDTH, SHA256_WORD_U8S, -}; - -// A wrapper AIR purely for testing purposes -#[derive(Clone, Debug)] -pub struct Sha256TestAir { - pub sub_air: Sha256Air, -} - -impl BaseAirWithPublicValues for Sha256TestAir {} -impl PartitionedBaseAir for Sha256TestAir {} -impl BaseAir for Sha256TestAir { - fn width(&self) -> usize { - >::width(&self.sub_air) - } -} - -impl Air for Sha256TestAir { - fn eval(&self, builder: &mut AB) { - self.sub_air.eval(builder, 0); - } -} - -const SELF_BUS_IDX: BusIndex = 28; -type F = BabyBear; -type RecordType = Vec<([u8; SHA256_BLOCK_U8S], bool)>; - -// A wrapper Chip purely for testing purposes -pub struct Sha256TestChip { - pub step: Sha256FillerHelper, - pub bitwise_lookup_chip: SharedBitwiseOperationLookupChip<8>, -} - -impl Chip> for Sha256TestChip -where - Val: PrimeField32, -{ - fn generate_proving_ctx(&self, records: RecordType) -> AirProvingContext> { - let trace = crate::generate_trace::>( - &self.step, - self.bitwise_lookup_chip.as_ref(), - SHA256_WIDTH, - records, - ); - AirProvingContext::simple_no_pis(trace) - } -} - -#[allow(clippy::type_complexity)] -fn create_air_with_air_ctx() -> ( - (AirRef, AirProvingContext>), - ( - BitwiseOperationLookupAir, - SharedBitwiseOperationLookupChip, - ), -) -where - Val: PrimeField32, -{ - let mut rng = create_seeded_rng(); - let bitwise_bus = BitwiseOperationLookupBus::new(BITWISE_OP_LOOKUP_BUS); - let bitwise_chip = Arc::new(BitwiseOperationLookupChip::::new( - bitwise_bus, - )); - let len = rng.random_range(1..100); - let random_records: Vec<_> = (0..len) - .map(|i| { - ( - array::from_fn(|_| rng.random::()), - rng.random::() || i == len - 1, - ) - }) - .collect(); - - let air = Sha256TestAir { - sub_air: Sha256Air::new(bitwise_bus, SELF_BUS_IDX), - }; - let chip = Sha256TestChip { - step: Sha256FillerHelper::new(), - bitwise_lookup_chip: bitwise_chip.clone(), - }; - let air_ctx = chip.generate_proving_ctx(random_records); - - ((Arc::new(air), air_ctx), (bitwise_chip.air, bitwise_chip)) -} - -#[test] -fn rand_sha256_test() { - let tester = VmChipTestBuilder::default(); - let (air_ctx, bitwise) = create_air_with_air_ctx(); - let tester = tester - .build() - .load_air_proving_ctx(air_ctx) - .load_periphery(bitwise) - .finalize(); - tester.simple_test().expect("Verification failed"); -} - -#[test] -fn negative_sha256_test_bad_final_hash() { - use openvm_stark_backend::SystemParams; - - let tester = VmChipTestBuilder::default(); - let ((air, mut air_ctx), bitwise) = create_air_with_air_ctx(); - - // Set the final_hash to all zeros - let modify_trace = |trace: &mut RowMajorMatrix| { - trace.row_chunks_exact_mut(1).for_each(|row| { - let mut row_slice = row.row_slice(0).expect("row exists").to_vec(); - let cols: &mut Sha256DigestCols = row_slice[..SHA256_DIGEST_WIDTH].borrow_mut(); - if cols.flags.is_last_block.is_one() && cols.flags.is_digest_row.is_one() { - for i in 0..SHA256_HASH_WORDS { - for j in 0..SHA256_WORD_U8S { - cols.final_hash[i][j] = F::ZERO; - } - } - row.values.copy_from_slice(&row_slice); - } - }); - }; - - // Modify the air_ctx common_main trace directly - modify_trace(&mut air_ctx.common_main); - - disable_debug_builder(); - let mut params = SystemParams::new_for_testing(20); - params.max_constraint_degree = 4; - let tester = tester - .build() - .load_air_proving_ctx((air, air_ctx)) - .load_periphery(bitwise) - .finalize(); - let result = tester.simple_test_with_params(params); - assert!(matches!(result, Err(StarkTestError::Prover(_)))); -} diff --git a/crates/circuits/sha256-air/src/trace.rs b/crates/circuits/sha256-air/src/trace.rs deleted file mode 100644 index 45607413d5..0000000000 --- a/crates/circuits/sha256-air/src/trace.rs +++ /dev/null @@ -1,551 +0,0 @@ -use std::{array, borrow::BorrowMut, ops::Range}; - -use openvm_circuit_primitives::{ - bitwise_op_lookup::BitwiseOperationLookupChip, encoder::Encoder, - utils::next_power_of_two_or_zero, -}; -use openvm_stark_backend::{ - p3_field::PrimeField32, p3_matrix::dense::RowMajorMatrix, p3_maybe_rayon::prelude::*, -}; -use sha2::{compress256, digest::generic_array::GenericArray}; - -use super::{ - big_sig0_field, big_sig1_field, ch_field, columns::Sha256RoundCols, compose, get_flag_pt_array, - maj_field, small_sig0_field, small_sig1_field, SHA256_BLOCK_WORDS, SHA256_DIGEST_WIDTH, - SHA256_HASH_WORDS, SHA256_ROUND_WIDTH, -}; -use crate::{ - big_sig0, big_sig1, ch, columns::Sha256DigestCols, limbs_into_u32, maj, small_sig0, small_sig1, - u32_into_bits_field, u32_into_u16s, SHA256_BLOCK_U8S, SHA256_H, SHA256_INVALID_CARRY_A, - SHA256_INVALID_CARRY_E, SHA256_K, SHA256_ROUNDS_PER_ROW, SHA256_ROWS_PER_BLOCK, - SHA256_WORD_U16S, SHA256_WORD_U8S, -}; - -/// A helper struct for the SHA256 trace generation. -/// Also, separates the inner AIR from the trace generation. -pub struct Sha256FillerHelper { - pub row_idx_encoder: Encoder, -} - -impl Default for Sha256FillerHelper { - fn default() -> Self { - Self::new() - } -} - -/// The trace generation of SHA256 should be done in two passes. -/// The first pass should do `get_block_trace` for every block and generate the invalid rows through -/// `get_default_row` The second pass should go through all the blocks and call -/// `generate_missing_cells` -impl Sha256FillerHelper { - pub fn new() -> Self { - Self { - row_idx_encoder: Encoder::new(18, 2, false), - } - } - /// This function takes the input_message (padding not handled), the previous hash, - /// and returns the new hash after processing the block input - pub fn get_block_hash( - prev_hash: &[u32; SHA256_HASH_WORDS], - input: [u8; SHA256_BLOCK_U8S], - ) -> [u32; SHA256_HASH_WORDS] { - let mut new_hash = *prev_hash; - let input_array = [GenericArray::from(input)]; - compress256(&mut new_hash, &input_array); - new_hash - } - - /// This function takes a 512-bit chunk of the input message (padding not handled), the previous - /// hash, a flag indicating if it's the last block, the global block index, the local block - /// index, and the buffer values that will be put in rows 0..4. - /// Will populate the given `trace` with the trace of the block, where the width of the trace is - /// `trace_width` and the starting column for the `Sha256Air` is `trace_start_col`. - /// **Note**: this function only generates some of the required trace. Another pass is required, - /// refer to [`Self::generate_missing_cells`] for details. - #[allow(clippy::too_many_arguments)] - pub fn generate_block_trace( - &self, - trace: &mut [F], - trace_width: usize, - trace_start_col: usize, - input: &[u32; SHA256_BLOCK_WORDS], - bitwise_lookup_chip: &BitwiseOperationLookupChip<8>, - prev_hash: &[u32; SHA256_HASH_WORDS], - is_last_block: bool, - global_block_idx: u32, - local_block_idx: u32, - ) { - #[cfg(debug_assertions)] - { - assert!(trace.len() == trace_width * SHA256_ROWS_PER_BLOCK); - assert!(trace_start_col + super::SHA256_WIDTH <= trace_width); - if local_block_idx == 0 { - assert!(*prev_hash == SHA256_H); - } - } - let get_range = |start: usize, len: usize| -> Range { start..start + len }; - let mut message_schedule = [0u32; 64]; - message_schedule[..input.len()].copy_from_slice(input); - let mut work_vars = *prev_hash; - for (i, row) in trace.chunks_exact_mut(trace_width).enumerate() { - // doing the 64 rounds in 16 rows - if i < 16 { - let cols: &mut Sha256RoundCols = - row[get_range(trace_start_col, SHA256_ROUND_WIDTH)].borrow_mut(); - cols.flags.is_round_row = F::ONE; - cols.flags.is_first_4_rows = if i < 4 { F::ONE } else { F::ZERO }; - cols.flags.is_digest_row = F::ZERO; - cols.flags.is_last_block = F::from_bool(is_last_block); - cols.flags.row_idx = get_flag_pt_array(&self.row_idx_encoder, i).map(F::from_u32); - cols.flags.global_block_idx = F::from_u32(global_block_idx); - cols.flags.local_block_idx = F::from_u32(local_block_idx); - - // W_idx = M_idx - if i < 4 { - for j in 0..SHA256_ROUNDS_PER_ROW { - cols.message_schedule.w[j] = - u32_into_bits_field::(input[i * SHA256_ROUNDS_PER_ROW + j]); - } - } - // W_idx = SIG1(W_{idx-2}) + W_{idx-7} + SIG0(W_{idx-15}) + W_{idx-16} - else { - for j in 0..SHA256_ROUNDS_PER_ROW { - let idx = i * SHA256_ROUNDS_PER_ROW + j; - let nums: [u32; 4] = [ - small_sig1(message_schedule[idx - 2]), - message_schedule[idx - 7], - small_sig0(message_schedule[idx - 15]), - message_schedule[idx - 16], - ]; - let w: u32 = nums.iter().fold(0, |acc, &num| acc.wrapping_add(num)); - cols.message_schedule.w[j] = u32_into_bits_field::(w); - - let nums_limbs = nums.map(u32_into_u16s); - let w_limbs = u32_into_u16s(w); - - // fill in the carrys - for k in 0..SHA256_WORD_U16S { - let mut sum = nums_limbs.iter().fold(0, |acc, num| acc + num[k]); - if k > 0 { - sum += (cols.message_schedule.carry_or_buffer[j][k * 2 - 2] - + F::TWO * cols.message_schedule.carry_or_buffer[j][k * 2 - 1]) - .as_canonical_u32(); - } - let carry = (sum - w_limbs[k]) >> 16; - cols.message_schedule.carry_or_buffer[j][k * 2] = - F::from_u32(carry & 1); - cols.message_schedule.carry_or_buffer[j][k * 2 + 1] = - F::from_u32(carry >> 1); - } - // update the message schedule - message_schedule[idx] = w; - } - } - // fill in the work variables - for j in 0..SHA256_ROUNDS_PER_ROW { - // t1 = h + SIG1(e) + ch(e, f, g) + K_idx + W_idx - let t1 = [ - work_vars[7], - big_sig1(work_vars[4]), - ch(work_vars[4], work_vars[5], work_vars[6]), - SHA256_K[i * SHA256_ROUNDS_PER_ROW + j], - limbs_into_u32(cols.message_schedule.w[j].map(|f| f.as_canonical_u32())), - ]; - let t1_sum: u32 = t1.iter().fold(0, |acc, &num| acc.wrapping_add(num)); - - // t2 = SIG0(a) + maj(a, b, c) - let t2 = [ - big_sig0(work_vars[0]), - maj(work_vars[0], work_vars[1], work_vars[2]), - ]; - - let t2_sum: u32 = t2.iter().fold(0, |acc, &num| acc.wrapping_add(num)); - - // e = d + t1 - let e = work_vars[3].wrapping_add(t1_sum); - cols.work_vars.e[j] = u32_into_bits_field::(e); - let e_limbs = u32_into_u16s(e); - // a = t1 + t2 - let a = t1_sum.wrapping_add(t2_sum); - cols.work_vars.a[j] = u32_into_bits_field::(a); - let a_limbs = u32_into_u16s(a); - // fill in the carrys - for k in 0..SHA256_WORD_U16S { - let t1_limb = t1.iter().fold(0, |acc, &num| acc + u32_into_u16s(num)[k]); - let t2_limb = t2.iter().fold(0, |acc, &num| acc + u32_into_u16s(num)[k]); - - let mut e_limb = t1_limb + u32_into_u16s(work_vars[3])[k]; - let mut a_limb = t1_limb + t2_limb; - if k > 0 { - a_limb += cols.work_vars.carry_a[j][k - 1].as_canonical_u32(); - e_limb += cols.work_vars.carry_e[j][k - 1].as_canonical_u32(); - } - let carry_a = (a_limb - a_limbs[k]) >> 16; - let carry_e = (e_limb - e_limbs[k]) >> 16; - cols.work_vars.carry_a[j][k] = F::from_u32(carry_a); - cols.work_vars.carry_e[j][k] = F::from_u32(carry_e); - bitwise_lookup_chip.request_range(carry_a, carry_e); - } - - // update working variables - work_vars[7] = work_vars[6]; - work_vars[6] = work_vars[5]; - work_vars[5] = work_vars[4]; - work_vars[4] = e; - work_vars[3] = work_vars[2]; - work_vars[2] = work_vars[1]; - work_vars[1] = work_vars[0]; - work_vars[0] = a; - } - - // filling w_3 and intermed_4 here and the rest later - if i > 0 { - for j in 0..SHA256_ROUNDS_PER_ROW { - let idx = i * SHA256_ROUNDS_PER_ROW + j; - let w_4 = u32_into_u16s(message_schedule[idx - 4]); - let sig_0_w_3 = u32_into_u16s(small_sig0(message_schedule[idx - 3])); - cols.schedule_helper.intermed_4[j] = - array::from_fn(|k| F::from_u32(w_4[k] + sig_0_w_3[k])); - if j < SHA256_ROUNDS_PER_ROW - 1 { - let w_3 = message_schedule[idx - 3]; - cols.schedule_helper.w_3[j] = u32_into_u16s(w_3).map(F::from_u32); - } - } - } - } - // generate the digest row - else { - let cols: &mut Sha256DigestCols = - row[get_range(trace_start_col, SHA256_DIGEST_WIDTH)].borrow_mut(); - for j in 0..SHA256_ROUNDS_PER_ROW - 1 { - let w_3 = message_schedule[i * SHA256_ROUNDS_PER_ROW + j - 3]; - cols.schedule_helper.w_3[j] = u32_into_u16s(w_3).map(F::from_u32); - } - cols.flags.is_round_row = F::ZERO; - cols.flags.is_first_4_rows = F::ZERO; - cols.flags.is_digest_row = F::ONE; - cols.flags.is_last_block = F::from_bool(is_last_block); - cols.flags.row_idx = get_flag_pt_array(&self.row_idx_encoder, 16).map(F::from_u32); - cols.flags.global_block_idx = F::from_u32(global_block_idx); - - cols.flags.local_block_idx = F::from_u32(local_block_idx); - let final_hash: [u32; SHA256_HASH_WORDS] = - array::from_fn(|i| work_vars[i].wrapping_add(prev_hash[i])); - let final_hash_limbs: [[u8; SHA256_WORD_U8S]; SHA256_HASH_WORDS] = - array::from_fn(|i| final_hash[i].to_le_bytes()); - // need to ensure final hash limbs are bytes, in order for - // prev_hash[i] + work_vars[i] == final_hash[i] - // to be constrained correctly - for word in final_hash_limbs.iter() { - for chunk in word.chunks(2) { - bitwise_lookup_chip.request_range(chunk[0] as u32, chunk[1] as u32); - } - } - cols.final_hash = - array::from_fn(|i| array::from_fn(|j| F::from_u8(final_hash_limbs[i][j]))); - cols.prev_hash = prev_hash.map(|f| u32_into_u16s(f).map(F::from_u32)); - let hash = if is_last_block { - SHA256_H.map(u32_into_bits_field::) - } else { - cols.final_hash - .map(|f| u32::from_le_bytes(f.map(|x| x.as_canonical_u32() as u8))) - .map(u32_into_bits_field::) - }; - - for i in 0..SHA256_ROUNDS_PER_ROW { - cols.hash.a[i] = hash[SHA256_ROUNDS_PER_ROW - i - 1]; - cols.hash.e[i] = hash[SHA256_ROUNDS_PER_ROW - i + 3]; - } - } - } - - for i in 0..SHA256_ROWS_PER_BLOCK - 1 { - let rows = &mut trace[i * trace_width..(i + 2) * trace_width]; - let (local, next) = rows.split_at_mut(trace_width); - let local_cols: &mut Sha256RoundCols = - local[get_range(trace_start_col, SHA256_ROUND_WIDTH)].borrow_mut(); - let next_cols: &mut Sha256RoundCols = - next[get_range(trace_start_col, SHA256_ROUND_WIDTH)].borrow_mut(); - if i > 0 { - for j in 0..SHA256_ROUNDS_PER_ROW { - next_cols.schedule_helper.intermed_8[j] = - local_cols.schedule_helper.intermed_4[j]; - if (2..SHA256_ROWS_PER_BLOCK - 3).contains(&i) { - next_cols.schedule_helper.intermed_12[j] = - local_cols.schedule_helper.intermed_8[j]; - } - } - } - if i == SHA256_ROWS_PER_BLOCK - 2 { - // `next` is a digest row. - // Fill in `carry_a` and `carry_e` with dummy values so the constraints on `a` and - // `e` hold. - Self::generate_carry_ae(local_cols, next_cols); - // Fill in row 16's `intermed_4` with dummy values so the message schedule - // constraints holds on that row - Self::generate_intermed_4(local_cols, next_cols); - } - if i <= 2 { - // i is in 0..3. - // Fill in `local.intermed_12` with dummy values so the message schedule constraints - // hold on rows 1..4. - Self::generate_intermed_12(local_cols, next_cols); - } - } - } - - /// This function will fill in the cells that we couldn't do during the first pass. - /// This function should be called only after `generate_block_trace` was called for all blocks - /// And [`Self::generate_default_row`] is called for all invalid rows - /// Will populate the missing values of `trace`, where the width of the trace is `trace_width` - /// and the starting column for the `Sha256Air` is `trace_start_col`. - /// Note: `trace` needs to be the rows 1..17 of a block and the first row of the next block - pub fn generate_missing_cells( - &self, - trace: &mut [F], - trace_width: usize, - trace_start_col: usize, - ) { - // Here row_17 = next blocks row 0 - let rows_15_17 = &mut trace[14 * trace_width..17 * trace_width]; - let (row_15, row_16_17) = rows_15_17.split_at_mut(trace_width); - let (row_16, row_17) = row_16_17.split_at_mut(trace_width); - let cols_15: &mut Sha256RoundCols = - row_15[trace_start_col..trace_start_col + SHA256_ROUND_WIDTH].borrow_mut(); - let cols_16: &mut Sha256RoundCols = - row_16[trace_start_col..trace_start_col + SHA256_ROUND_WIDTH].borrow_mut(); - let cols_17: &mut Sha256RoundCols = - row_17[trace_start_col..trace_start_col + SHA256_ROUND_WIDTH].borrow_mut(); - // Fill in row 15's `intermed_12` with dummy values so the message schedule constraints - // holds on row 16 - Self::generate_intermed_12(cols_15, cols_16); - // Fill in row 16's `intermed_12` with dummy values so the message schedule constraints - // holds on the next block's row 0 - Self::generate_intermed_12(cols_16, cols_17); - // Fill in row 0's `intermed_4` with dummy values so the message schedule constraints holds - // on that row - Self::generate_intermed_4(cols_16, cols_17); - } - - /// Fills the `cols` as a padding row - /// Note: we still need to correctly fill in the hash values, carries and intermeds - pub fn generate_default_row( - self: &Sha256FillerHelper, - cols: &mut Sha256RoundCols, - ) { - cols.flags.row_idx = get_flag_pt_array(&self.row_idx_encoder, 17).map(F::from_u32); - - let hash = SHA256_H.map(u32_into_bits_field::); - - for i in 0..SHA256_ROUNDS_PER_ROW { - cols.work_vars.a[i] = hash[SHA256_ROUNDS_PER_ROW - i - 1]; - cols.work_vars.e[i] = hash[SHA256_ROUNDS_PER_ROW - i + 3]; - } - - cols.work_vars.carry_a = - array::from_fn(|i| array::from_fn(|j| F::from_u32(SHA256_INVALID_CARRY_A[i][j]))); - cols.work_vars.carry_e = - array::from_fn(|i| array::from_fn(|j| F::from_u32(SHA256_INVALID_CARRY_E[i][j]))); - } - - /// The following functions do the calculations in native field since they will be called on - /// padding rows which can overflow and we need to make sure it matches the AIR constraints - /// Puts the correct carrys in the `next_row`, the resulting carrys can be out of bound - fn generate_carry_ae( - local_cols: &Sha256RoundCols, - next_cols: &mut Sha256RoundCols, - ) { - let a = [local_cols.work_vars.a, next_cols.work_vars.a].concat(); - let e = [local_cols.work_vars.e, next_cols.work_vars.e].concat(); - for i in 0..SHA256_ROUNDS_PER_ROW { - let cur_a = a[i + 4]; - let sig_a = big_sig0_field::(&a[i + 3]); - let maj_abc = maj_field::(&a[i + 3], &a[i + 2], &a[i + 1]); - let d = a[i]; - let cur_e = e[i + 4]; - let sig_e = big_sig1_field::(&e[i + 3]); - let ch_efg = ch_field::(&e[i + 3], &e[i + 2], &e[i + 1]); - let h = e[i]; - - let t1 = [h, sig_e, ch_efg]; - let t2 = [sig_a, maj_abc]; - for j in 0..SHA256_WORD_U16S { - let t1_limb_sum = t1.iter().fold(F::ZERO, |acc, x| { - acc + compose::(&x[j * 16..(j + 1) * 16], 1) - }); - let t2_limb_sum = t2.iter().fold(F::ZERO, |acc, x| { - acc + compose::(&x[j * 16..(j + 1) * 16], 1) - }); - let d_limb = compose::(&d[j * 16..(j + 1) * 16], 1); - let cur_a_limb = compose::(&cur_a[j * 16..(j + 1) * 16], 1); - let cur_e_limb = compose::(&cur_e[j * 16..(j + 1) * 16], 1); - let sum = d_limb - + t1_limb_sum - + if j == 0 { - F::ZERO - } else { - next_cols.work_vars.carry_e[i][j - 1] - } - - cur_e_limb; - let carry_e = sum * (F::from_u32(1 << 16).inverse()); - - let sum = t1_limb_sum - + t2_limb_sum - + if j == 0 { - F::ZERO - } else { - next_cols.work_vars.carry_a[i][j - 1] - } - - cur_a_limb; - let carry_a = sum * (F::from_u32(1 << 16).inverse()); - next_cols.work_vars.carry_e[i][j] = carry_e; - next_cols.work_vars.carry_a[i][j] = carry_a; - } - } - } - - /// Puts the correct intermed_4 in the `next_row` - fn generate_intermed_4( - local_cols: &Sha256RoundCols, - next_cols: &mut Sha256RoundCols, - ) { - let w = [local_cols.message_schedule.w, next_cols.message_schedule.w].concat(); - let w_limbs: Vec<[F; SHA256_WORD_U16S]> = w - .iter() - .map(|x| array::from_fn(|i| compose::(&x[i * 16..(i + 1) * 16], 1))) - .collect(); - for i in 0..SHA256_ROUNDS_PER_ROW { - let sig_w = small_sig0_field::(&w[i + 1]); - let sig_w_limbs: [F; SHA256_WORD_U16S] = - array::from_fn(|j| compose::(&sig_w[j * 16..(j + 1) * 16], 1)); - for (j, sig_w_limb) in sig_w_limbs.iter().enumerate() { - next_cols.schedule_helper.intermed_4[i][j] = w_limbs[i][j] + *sig_w_limb; - } - } - } - - /// Puts the needed intermed_12 in the `local_row` - fn generate_intermed_12( - local_cols: &mut Sha256RoundCols, - next_cols: &Sha256RoundCols, - ) { - let w = [local_cols.message_schedule.w, next_cols.message_schedule.w].concat(); - let w_limbs: Vec<[F; SHA256_WORD_U16S]> = w - .iter() - .map(|x| array::from_fn(|i| compose::(&x[i * 16..(i + 1) * 16], 1))) - .collect(); - for i in 0..SHA256_ROUNDS_PER_ROW { - // sig_1(w_{t-2}) - let sig_w_2: [F; SHA256_WORD_U16S] = array::from_fn(|j| { - compose::(&small_sig1_field::(&w[i + 2])[j * 16..(j + 1) * 16], 1) - }); - // w_{t-7} - let w_7 = if i < 3 { - local_cols.schedule_helper.w_3[i] - } else { - w_limbs[i - 3] - }; - // w_t - let w_cur = w_limbs[i + 4]; - for j in 0..SHA256_WORD_U16S { - let carry = next_cols.message_schedule.carry_or_buffer[i][j * 2] - + F::TWO * next_cols.message_schedule.carry_or_buffer[i][j * 2 + 1]; - let sum = sig_w_2[j] + w_7[j] - carry * F::from_u32(1 << 16) - w_cur[j] - + if j > 0 { - next_cols.message_schedule.carry_or_buffer[i][j * 2 - 2] - + F::from_u32(2) - * next_cols.message_schedule.carry_or_buffer[i][j * 2 - 1] - } else { - F::ZERO - }; - local_cols.schedule_helper.intermed_12[i][j] = -sum; - } - } - } -} - -/// Generates a trace for a standalone SHA256 computation (currently only used for testing) -/// `records` consists of pairs of `(input_block, is_last_block)`. -pub fn generate_trace( - step: &Sha256FillerHelper, - bitwise_lookup_chip: &BitwiseOperationLookupChip<8>, - width: usize, - records: Vec<([u8; SHA256_BLOCK_U8S], bool)>, -) -> RowMajorMatrix { - let non_padded_height = records.len() * SHA256_ROWS_PER_BLOCK; - let height = next_power_of_two_or_zero(non_padded_height); - let mut values = F::zero_vec(height * width); - - struct BlockContext { - prev_hash: [u32; 8], - local_block_idx: u32, - global_block_idx: u32, - input: [u8; SHA256_BLOCK_U8S], - is_last_block: bool, - } - let mut block_ctx: Vec = Vec::with_capacity(records.len()); - let mut prev_hash = SHA256_H; - let mut local_block_idx = 0; - let mut global_block_idx = 1; - for (input, is_last_block) in records { - block_ctx.push(BlockContext { - prev_hash, - local_block_idx, - global_block_idx, - input, - is_last_block, - }); - global_block_idx += 1; - if is_last_block { - local_block_idx = 0; - prev_hash = SHA256_H; - } else { - local_block_idx += 1; - prev_hash = Sha256FillerHelper::get_block_hash(&prev_hash, input); - } - } - // first pass - values - .par_chunks_exact_mut(width * SHA256_ROWS_PER_BLOCK) - .zip(block_ctx) - .for_each(|(block, ctx)| { - let BlockContext { - prev_hash, - local_block_idx, - global_block_idx, - input, - is_last_block, - } = ctx; - let input_words = array::from_fn(|i| { - limbs_into_u32::(array::from_fn(|j| { - input[(i + 1) * SHA256_WORD_U8S - j - 1] as u32 - })) - }); - step.generate_block_trace( - block, - width, - 0, - &input_words, - bitwise_lookup_chip, - &prev_hash, - is_last_block, - global_block_idx, - local_block_idx, - ); - }); - // second pass: padding rows - values[width * non_padded_height..] - .par_chunks_mut(width) - .for_each(|row| { - let cols: &mut Sha256RoundCols = row.borrow_mut(); - step.generate_default_row(cols); - }); - // second pass: non-padding rows - values[width..] - .par_chunks_mut(width * SHA256_ROWS_PER_BLOCK) - .take(non_padded_height / SHA256_ROWS_PER_BLOCK) - .for_each(|chunk| { - step.generate_missing_cells(chunk, width, 0); - }); - RowMajorMatrix::new(values, width) -} diff --git a/crates/circuits/sha256-air/src/utils.rs b/crates/circuits/sha256-air/src/utils.rs deleted file mode 100644 index 8e15fcee18..0000000000 --- a/crates/circuits/sha256-air/src/utils.rs +++ /dev/null @@ -1,271 +0,0 @@ -use std::array; - -pub use openvm_circuit_primitives::utils::compose; -use openvm_circuit_primitives::{ - encoder::Encoder, - utils::{not, select}, -}; -use openvm_stark_backend::{p3_air::AirBuilder, p3_field::PrimeCharacteristicRing}; - -use super::{Sha256DigestCols, Sha256RoundCols}; - -// ==== Do not change these constants! ==== -/// Number of bits in a SHA256 word -pub const SHA256_WORD_BITS: usize = 32; -/// Number of 16-bit limbs in a SHA256 word -pub const SHA256_WORD_U16S: usize = SHA256_WORD_BITS / 16; -/// Number of 8-bit limbs in a SHA256 word -pub const SHA256_WORD_U8S: usize = SHA256_WORD_BITS / 8; -/// Number of words in a SHA256 block -pub const SHA256_BLOCK_WORDS: usize = 16; -/// Number of cells in a SHA256 block -pub const SHA256_BLOCK_U8S: usize = SHA256_BLOCK_WORDS * SHA256_WORD_U8S; -/// Number of bits in a SHA256 block -pub const SHA256_BLOCK_BITS: usize = SHA256_BLOCK_WORDS * SHA256_WORD_BITS; -/// Number of rows per block -pub const SHA256_ROWS_PER_BLOCK: usize = 17; -/// Number of rounds per row -pub const SHA256_ROUNDS_PER_ROW: usize = 4; -/// Number of words in a SHA256 hash -pub const SHA256_HASH_WORDS: usize = 8; -/// Number of vars needed to encode the row index with [Encoder] -pub const SHA256_ROW_VAR_CNT: usize = 5; -/// Width of the Sha256RoundCols -pub const SHA256_ROUND_WIDTH: usize = Sha256RoundCols::::width(); -/// Width of the Sha256DigestCols -pub const SHA256_DIGEST_WIDTH: usize = Sha256DigestCols::::width(); -/// Size of the buffer of the first 4 rows of a block (each row's size) -pub const SHA256_BUFFER_SIZE: usize = SHA256_ROUNDS_PER_ROW * SHA256_WORD_U16S * 2; -/// Width of the Sha256Cols -pub const SHA256_WIDTH: usize = if SHA256_ROUND_WIDTH > SHA256_DIGEST_WIDTH { - SHA256_ROUND_WIDTH -} else { - SHA256_DIGEST_WIDTH -}; -/// We can notice that `carry_a`'s and `carry_e`'s are always the same on invalid rows -/// To optimize the trace generation of invalid rows, we have those values precomputed here -pub(crate) const SHA256_INVALID_CARRY_A: [[u32; SHA256_WORD_U16S]; SHA256_ROUNDS_PER_ROW] = [ - [1230919683, 1162494304], - [266373122, 1282901987], - [1519718403, 1008990871], - [923381762, 330807052], -]; -pub(crate) const SHA256_INVALID_CARRY_E: [[u32; SHA256_WORD_U16S]; SHA256_ROUNDS_PER_ROW] = [ - [204933122, 1994683449], - [443873282, 1544639095], - [719953922, 1888246508], - [194580482, 1075725211], -]; -/// SHA256 constant K's -pub const SHA256_K: [u32; 64] = [ - 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, - 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, - 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, - 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, - 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, - 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, - 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, - 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2, -]; - -/// SHA256 initial hash values -pub const SHA256_H: [u32; 8] = [ - 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19, -]; - -/// Returns the number of blocks required to hash a message of length `len` -pub fn get_sha256_num_blocks(len: u32) -> u32 { - // need to pad with one 1 bit, 64 bits for the message length and then pad until the length - // is divisible by [SHA256_BLOCK_BITS] - ((len << 3) as usize + 1 + 64).div_ceil(SHA256_BLOCK_BITS) as u32 -} - -/// Convert a u32 into a list of bits in little endian then convert each bit into a field element -pub fn u32_into_bits_field(num: u32) -> [F; SHA256_WORD_BITS] { - array::from_fn(|i| F::from_bool((num >> i) & 1 == 1)) -} - -/// Convert a u32 into a an array of 2 16-bit limbs in little endian -pub fn u32_into_u16s(num: u32) -> [u32; 2] { - [num & 0xffff, num >> 16] -} - -/// Convert a list of limbs in little endian into a u32 -pub fn limbs_into_u32(limbs: [u32; NUM_LIMBS]) -> u32 { - let limb_bits = 32 / NUM_LIMBS; - limbs - .iter() - .rev() - .fold(0, |acc, &limb| (acc << limb_bits) | limb) -} - -/// Rotates `bits` right by `n` bits, assumes `bits` is in little-endian -#[inline] -pub(crate) fn rotr( - bits: &[impl Into + Clone; SHA256_WORD_BITS], - n: usize, -) -> [F; SHA256_WORD_BITS] { - array::from_fn(|i| bits[(i + n) % SHA256_WORD_BITS].clone().into()) -} - -/// Shifts `bits` right by `n` bits, assumes `bits` is in little-endian -#[inline] -pub(crate) fn shr( - bits: &[impl Into + Clone; SHA256_WORD_BITS], - n: usize, -) -> [F; SHA256_WORD_BITS] { - array::from_fn(|i| { - if i + n < SHA256_WORD_BITS { - bits[i + n].clone().into() - } else { - F::ZERO - } - }) -} - -/// Computes x ^ y ^ z, where x, y, z are assumed to be boolean -#[inline] -pub(crate) fn xor_bit( - x: impl Into, - y: impl Into, - z: impl Into, -) -> F { - let (x, y, z) = (x.into(), y.into(), z.into()); - (x.clone() * y.clone() * z.clone()) - + (x.clone() * not::(y.clone()) * not::(z.clone())) - + (not::(x.clone()) * y.clone() * not::(z.clone())) - + (not::(x) * not::(y) * z) -} - -/// Computes x ^ y ^ z, where x, y, z are [SHA256_WORD_BITS] bit numbers -#[inline] -pub(crate) fn xor( - x: &[impl Into + Clone; SHA256_WORD_BITS], - y: &[impl Into + Clone; SHA256_WORD_BITS], - z: &[impl Into + Clone; SHA256_WORD_BITS], -) -> [F; SHA256_WORD_BITS] { - array::from_fn(|i| xor_bit(x[i].clone(), y[i].clone(), z[i].clone())) -} - -/// Choose function from SHA256 -#[inline] -pub fn ch(x: u32, y: u32, z: u32) -> u32 { - (x & y) ^ ((!x) & z) -} - -/// Computes Ch(x,y,z), where x, y, z are [SHA256_WORD_BITS] bit numbers -#[inline] -pub(crate) fn ch_field( - x: &[impl Into + Clone; SHA256_WORD_BITS], - y: &[impl Into + Clone; SHA256_WORD_BITS], - z: &[impl Into + Clone; SHA256_WORD_BITS], -) -> [F; SHA256_WORD_BITS] { - array::from_fn(|i| select(x[i].clone(), y[i].clone(), z[i].clone())) -} - -/// Majority function from SHA256 -pub fn maj(x: u32, y: u32, z: u32) -> u32 { - (x & y) ^ (x & z) ^ (y & z) -} - -/// Computes Maj(x,y,z), where x, y, z are [SHA256_WORD_BITS] bit numbers -#[inline] -pub(crate) fn maj_field( - x: &[impl Into + Clone; SHA256_WORD_BITS], - y: &[impl Into + Clone; SHA256_WORD_BITS], - z: &[impl Into + Clone; SHA256_WORD_BITS], -) -> [F; SHA256_WORD_BITS] { - array::from_fn(|i| { - let (x, y, z) = ( - x[i].clone().into(), - y[i].clone().into(), - z[i].clone().into(), - ); - x.clone() * y.clone() + x.clone() * z.clone() + y.clone() * z.clone() - F::TWO * x * y * z - }) -} - -/// Big sigma_0 function from SHA256 -pub fn big_sig0(x: u32) -> u32 { - x.rotate_right(2) ^ x.rotate_right(13) ^ x.rotate_right(22) -} - -/// Computes BigSigma0(x), where x is a [SHA256_WORD_BITS] bit number in little-endian -#[inline] -pub(crate) fn big_sig0_field( - x: &[impl Into + Clone; SHA256_WORD_BITS], -) -> [F; SHA256_WORD_BITS] { - xor(&rotr::(x, 2), &rotr::(x, 13), &rotr::(x, 22)) -} - -/// Big sigma_1 function from SHA256 -pub fn big_sig1(x: u32) -> u32 { - x.rotate_right(6) ^ x.rotate_right(11) ^ x.rotate_right(25) -} - -/// Computes BigSigma1(x), where x is a [SHA256_WORD_BITS] bit number in little-endian -#[inline] -pub(crate) fn big_sig1_field( - x: &[impl Into + Clone; SHA256_WORD_BITS], -) -> [F; SHA256_WORD_BITS] { - xor(&rotr::(x, 6), &rotr::(x, 11), &rotr::(x, 25)) -} - -/// Small sigma_0 function from SHA256 -pub fn small_sig0(x: u32) -> u32 { - x.rotate_right(7) ^ x.rotate_right(18) ^ (x >> 3) -} - -/// Computes SmallSigma0(x), where x is a [SHA256_WORD_BITS] bit number in little-endian -#[inline] -pub(crate) fn small_sig0_field( - x: &[impl Into + Clone; SHA256_WORD_BITS], -) -> [F; SHA256_WORD_BITS] { - xor(&rotr::(x, 7), &rotr::(x, 18), &shr::(x, 3)) -} - -/// Small sigma_1 function from SHA256 -pub fn small_sig1(x: u32) -> u32 { - x.rotate_right(17) ^ x.rotate_right(19) ^ (x >> 10) -} - -/// Computes SmallSigma1(x), where x is a [SHA256_WORD_BITS] bit number in little-endian -#[inline] -pub(crate) fn small_sig1_field( - x: &[impl Into + Clone; SHA256_WORD_BITS], -) -> [F; SHA256_WORD_BITS] { - xor(&rotr::(x, 17), &rotr::(x, 19), &shr::(x, 10)) -} - -/// Wrapper of `get_flag_pt` to get the flag pointer as an array -pub fn get_flag_pt_array(encoder: &Encoder, flag_idx: usize) -> [u32; N] { - encoder.get_flag_pt(flag_idx).try_into().unwrap() -} - -/// Constrain the addition of [SHA256_WORD_BITS] bit words in 16-bit limbs -/// It takes in the terms some in bits some in 16-bit limbs, -/// the expected sum in bits and the carries -pub fn constraint_word_addition( - builder: &mut AB, - terms_bits: &[&[impl Into + Clone; SHA256_WORD_BITS]], - terms_limb: &[&[impl Into + Clone; SHA256_WORD_U16S]], - expected_sum: &[impl Into + Clone; SHA256_WORD_BITS], - carries: &[impl Into + Clone; SHA256_WORD_U16S], -) { - for i in 0..SHA256_WORD_U16S { - let mut limb_sum = if i == 0 { - AB::Expr::ZERO - } else { - carries[i - 1].clone().into() - }; - for term in terms_bits { - limb_sum += compose::(&term[i * 16..(i + 1) * 16], 1); - } - for term in terms_limb { - limb_sum += term[i].clone().into(); - } - let expected_sum_limb = compose::(&expected_sum[i * 16..(i + 1) * 16], 1) - + carries[i].clone().into() * AB::Expr::from_u32(1 << 16); - builder.assert_eq(limb_sum, expected_sum_limb); - } -} diff --git a/crates/sdk-config/Cargo.toml b/crates/sdk-config/Cargo.toml index 9945ef72a3..272a3c67a5 100644 --- a/crates/sdk-config/Cargo.toml +++ b/crates/sdk-config/Cargo.toml @@ -20,8 +20,8 @@ openvm-deferral-circuit = { workspace = true } openvm-deferral-transpiler = { workspace = true } openvm-keccak256-circuit = { workspace = true } openvm-keccak256-transpiler = { workspace = true } -openvm-sha256-circuit = { workspace = true } -openvm-sha256-transpiler = { workspace = true } +openvm-sha2-circuit = { workspace = true } +openvm-sha2-transpiler = { workspace = true } openvm-pairing-circuit = { workspace = true } openvm-pairing-transpiler = { workspace = true } openvm-rv32im-circuit = { workspace = true } @@ -45,7 +45,7 @@ cuda = [ "openvm-deferral-circuit/cuda", "openvm-ecc-circuit/cuda", "openvm-keccak256-circuit/cuda", - "openvm-sha256-circuit/cuda", + "openvm-sha2-circuit/cuda", "openvm-pairing-circuit/cuda", "openvm-rv32im-circuit/cuda", ] @@ -55,7 +55,7 @@ metrics = [ tco = [ "openvm-circuit/tco", "openvm-rv32im-circuit/tco", - "openvm-sha256-circuit/tco", + "openvm-sha2-circuit/tco", "openvm-keccak256-circuit/tco", "openvm-bigint-circuit/tco", "openvm-algebra-circuit/tco", @@ -66,7 +66,7 @@ tco = [ aot = [ "openvm-circuit/aot", "openvm-rv32im-circuit/aot", - "openvm-sha256-circuit/aot", + "openvm-sha2-circuit/aot", "openvm-keccak256-circuit/aot", "openvm-bigint-circuit/aot", "openvm-algebra-circuit/aot", diff --git a/crates/sdk-config/src/lib.rs b/crates/sdk-config/src/lib.rs index 244019c1e6..2026ba23a1 100644 --- a/crates/sdk-config/src/lib.rs +++ b/crates/sdk-config/src/lib.rs @@ -36,7 +36,7 @@ cfg_if::cfg_if! { use openvm_ecc_circuit::EccProverExt; use openvm_keccak256_circuit::Keccak256GpuProverExt; use openvm_rv32im_circuit::Rv32ImGpuProverExt; - use openvm_sha256_circuit::Sha256GpuProverExt; + use openvm_sha2_circuit::Sha2GpuProverExt; pub use SdkVmGpuBuilder as SdkVmBuilder; } else { pub use SdkVmCpuBuilder as SdkVmBuilder; @@ -177,7 +177,7 @@ impl TranspilerConfig for SdkVmConfig { transpiler = transpiler.with_extension(Keccak256TranspilerExtension); } if self.sha256.is_some() { - transpiler = transpiler.with_extension(Sha256TranspilerExtension); + transpiler = transpiler.with_extension(Sha2TranspilerExtension); } if self.rv32m.is_some() { transpiler = transpiler.with_extension(Rv32MTranspilerExtension); @@ -242,7 +242,7 @@ impl SdkVmConfig { let rv32i = config.rv32i.map(|_| Rv32I); let io = config.io.map(|_| Rv32Io); let keccak = config.keccak.map(|_| Keccak256); - let sha256 = config.sha256.map(|_| Sha256); + let sha256 = config.sha256.map(|_| Sha2); let rv32m = config.rv32m; let bigint = config.bigint; let modular = config.modular.clone(); @@ -286,8 +286,8 @@ pub struct SdkVmConfigInner { pub io: Option, #[extension(executor = "Keccak256Executor")] pub keccak: Option, - #[extension(executor = "Sha256Executor")] - pub sha256: Option, + #[extension(executor = "Sha2Executor")] + pub sha256: Option, #[extension(executor = "Rv32MExecutor")] pub rv32m: Option, @@ -428,7 +428,7 @@ impl VmBuilder for SdkVmGpuBuilder { VmProverExtension::::extend_prover(&Keccak256GpuProverExt, keccak, inventory)?; } if let Some(sha256) = &config.sha256 { - VmProverExtension::::extend_prover(&Sha256GpuProverExt, sha256, inventory)?; + VmProverExtension::::extend_prover(&Sha2GpuProverExt, sha256, inventory)?; } if let Some(rv32m) = &config.rv32m { VmProverExtension::::extend_prover(&Rv32ImGpuProverExt, rv32m, inventory)?; @@ -534,8 +534,8 @@ impl From for UnitStruct { } } -impl From for UnitStruct { - fn from(_: Sha256) -> Self { +impl From for UnitStruct { + fn from(_: Sha2) -> Self { UnitStruct {} } } diff --git a/crates/sdk-config/v1.5/openvm_standard.toml b/crates/sdk-config/v1.5/openvm_standard.toml index f1f9267191..eac2c0a81b 100644 --- a/crates/sdk-config/v1.5/openvm_standard.toml +++ b/crates/sdk-config/v1.5/openvm_standard.toml @@ -3,7 +3,7 @@ [app_vm_config.io] [app_vm_config.keccak] -[app_vm_config.sha256] +[app_vm_config.sha2] [app_vm_config.bigint] [app_vm_config.modular] diff --git a/crates/vm/src/arch/testing/cpu.rs b/crates/vm/src/arch/testing/cpu.rs index 015b20b352..44e4f6a7c4 100644 --- a/crates/vm/src/arch/testing/cpu.rs +++ b/crates/vm/src/arch/testing/cpu.rs @@ -519,20 +519,39 @@ where self } - // TODO[jpw]: put back once we can make it generic in SC - // /// Given a function to produce an engine from the max trace height, - // /// runs a simple test on that engine - // pub fn test E>( - // self, // do no take ownership so it's easier to prank - // engine_provider: P, - // ) -> Result, VerificationError> - // where - // E: StarkEngine, PD = CpuDevice>, - // { - // assert!(self.memory.is_none(), "Memory must be finalized"); - // let (airs, ctxs): (Vec<_>, Vec<_>) = self.air_ctxs.into_iter().unzip(); - // engine_provider().run_test_impl(airs, ctxs) - // } + pub fn load_periphery_and_prank_trace( + mut self, + (air, chip): (A, C), + modify_trace: P, + ) -> Self + where + A: AnyAir + 'static, + C: Chip<(), CpuBackend>, + P: Fn(&mut RowMajorMatrix>), + { + let mut ctx = chip.generate_proving_ctx(()); + let mut trace = + StridedColMajorMatrixView::from(ctx.common_main.as_view()).to_row_major_matrix(); + modify_trace(&mut trace); + ctx.common_main = ColMajorMatrix::from_row_major(&trace); + self.air_ctxs.push((Arc::new(air), ctx)); + self + } + + /// Given a function to produce an engine from the max trace height, + /// runs a simple test on that engine + pub fn test E>( + self, // do no take ownership so it's easier to prank + engine_provider: P, + ) -> Result, VerifierError> + where + E: StarkEngine, PD = CpuDevice>, + SC::EF: Ord, + { + assert!(self.memory.is_none(), "Memory must be finalized"); + let (airs, ctxs): (Vec<_>, Vec<_>) = self.air_ctxs.into_iter().unzip(); + engine_provider().run_test(airs, ctxs) + } } /// Concrete `StarkTestError` type alias for BabyBear Poseidon2 CPU tests. diff --git a/docs/vocs/docs/pages/book/acceleration-using-extensions/overview.mdx b/docs/vocs/docs/pages/book/acceleration-using-extensions/overview.mdx index e636d02279..97a2478d0a 100644 --- a/docs/vocs/docs/pages/book/acceleration-using-extensions/overview.mdx +++ b/docs/vocs/docs/pages/book/acceleration-using-extensions/overview.mdx @@ -3,7 +3,7 @@ OpenVM ships with a set of pre-built extensions maintained by the OpenVM team. Below, we highlight six of these extensions designed to accelerate common arithmetic and cryptographic operations that are notoriously expensive to execute. Some of these extensions have corresponding guest libraries which provide convenient, high-level interfaces for your guest program to interact with the extension. - [`openvm-keccak-guest`](/book/acceleration-using-extensions/keccak) - Keccak256 hash function. See the [Keccak256 guest library](/book/guest-libraries/keccak256) for usage details. -- [`openvm-sha256-guest`](/book/acceleration-using-extensions/sha-256) - SHA-256 hash function. See the [SHA2 guest library](/book/guest-libraries/sha2) for usage details. +- [`openvm-sha2-guest`](/book/acceleration-using-extensions/sha-2) - SHA-2 family of hash functions. See the [SHA-2 guest library](/book/guest-libraries/sha2) for usage details. - [`openvm-bigint-guest`](/book/acceleration-using-extensions/big-integer) - Big integer arithmetic for 256-bit signed and unsigned integers. See the [Ruint guest library](/book/guest-libraries/ruint) for using accelerated 256-bit integer ops in rust. - [`openvm-algebra-guest`](/book/acceleration-using-extensions/algebra) - Modular arithmetic and complex field extensions. - [`openvm-ecc-guest`](/book/acceleration-using-extensions/elliptic-curve-cryptography) - Elliptic curve cryptography. See the [K256](/book/guest-libraries/k256) and [P256](/book/guest-libraries/p256) guest libraries for using this extension over the respective curves. @@ -44,7 +44,8 @@ range_tuple_checker_sizes = [256, 8192] [app_vm_config.keccak] -[app_vm_config.sha256] +[app_vm_config.sha2] +[app_vm_config.native] [app_vm_config.bigint] range_tuple_checker_sizes = [256, 8192] diff --git a/docs/vocs/docs/pages/book/acceleration-using-extensions/sha-2.mdx b/docs/vocs/docs/pages/book/acceleration-using-extensions/sha-2.mdx new file mode 100644 index 0000000000..30daa44f6a --- /dev/null +++ b/docs/vocs/docs/pages/book/acceleration-using-extensions/sha-2.mdx @@ -0,0 +1,45 @@ +# SHA-2 + +The SHA-2 extension guest provides functions that are meant to be linked to other external libraries. The external libraries can use these functions as a hook for SHA-2 intrinsics. This is enabled only when the target is `zkvm`. We support the SHA-256 and SHA-512 hash functions. + +We provide the following functions to compute the SHA-2 compression function. +- `zkvm_shaXXX_impl(state: *const u8, input: *const u8, output: *mut u8)` where `XXX` is `256` or `512`. These functions have `C` ABI. They take in a pointer to the current hasher state (`state`), a pointer to the next block of the message (`input`), and a pointer where the new hasher state will be written (`output`). `state` is expected to be a pointer to 8 little-endian words, even though its type is `*const u8`. For Sha256 that means it is a pointer to `[u32; 8]`, and for Sha512 it's `[u64; 8]`. + +In the external library, you can do something like the following: + +```rust +extern "C" { + fn zkvm_sha256_impl(input: *const u8, len: usize, output: *mut u8); +} + +fn sha256(input: &[u8]) -> [u8; 32] { + #[cfg(target_os = "zkvm")] + { + let mut state = [0u32; 8]; + let padded_input = add_padding(input); + padded_input + .chunks_exact(32) + .for_each(|input_block| { + unsafe { + zkvm_sha256_impl(state.as_ptr() as *const u8, input_block.as_ptr(), output.as_mut_ptr() as *mut u8); + } + }) + state + .map(|word| word.to_be_bytes()) + .collect::>() + .try_into() + .unwrap() + } + #[cfg(not(target_os = "zkvm"))] { + // Regular SHA-256 implementation + } +} +``` + +### Config parameters + +For the guest program to build successfully add the following to your `.toml` file: + +```toml +[app_vm_config.sha2] +``` diff --git a/docs/vocs/docs/pages/book/acceleration-using-extensions/sha-256.mdx b/docs/vocs/docs/pages/book/acceleration-using-extensions/sha-256.mdx deleted file mode 100644 index a4a7f46261..0000000000 --- a/docs/vocs/docs/pages/book/acceleration-using-extensions/sha-256.mdx +++ /dev/null @@ -1,35 +0,0 @@ -# SHA-256 - -The SHA-256 extension guest provides a function that is meant to be linked to other external libraries. The external libraries can use this function as a hook for the SHA-256 intrinsic. This is enabled only when the target is `zkvm`. - -- `zkvm_sha256_impl(input: *const u8, len: usize, output: *mut u8)`: This function has `C` ABI. It takes in a pointer to the input, the length of the input, and a pointer to the output buffer. - -In the external library, you can do the following: - -```rust -extern "C" { - fn zkvm_sha256_impl(input: *const u8, len: usize, output: *mut u8); -} - -fn sha256(input: &[u8]) -> [u8; 32] { - #[cfg(target_os = "zkvm")] - { - let mut output = [0u8; 32]; - unsafe { - zkvm_sha256_impl(input.as_ptr(), input.len(), output.as_mut_ptr() as *mut u8); - } - output - } - #[cfg(not(target_os = "zkvm"))] { - // Regular SHA-256 implementation - } -} -``` - -### Config parameters - -For the guest program to build successfully add the following to your `.toml` file: - -```toml -[app_vm_config.sha256] -``` diff --git a/docs/vocs/docs/pages/book/advanced-usage/sdk.mdx b/docs/vocs/docs/pages/book/advanced-usage/sdk.mdx index 8a69d4231b..4a9fbc7842 100644 --- a/docs/vocs/docs/pages/book/advanced-usage/sdk.mdx +++ b/docs/vocs/docs/pages/book/advanced-usage/sdk.mdx @@ -38,7 +38,7 @@ Note that to use `Sdk::riscv32()` or `Sdk::standard()` the `app_vm_config` field ``` -Observe that this standard `openvm.toml` also enables normal Rust and `openvm::io` functions (via the `rv32i`, `rv32m`, and `io` extensions). `keccak` and `sha256` enable intrinsic instructions for the [Keccak](/book/acceleration-using-extensions/keccak) and [SHA-256](/book/acceleration-using-extensions/sha-256) hashes respectively, and `bigint` supports [Big Integer](/book/acceleration-using-extensions/big-integer) operations. +Observe that this standard `openvm.toml` also enables normal Rust and `openvm::io` functions (via the `rv32i`, `rv32m`, and `io` extensions). `keccak` and `sha2` enable intrinsic instructions for the [Keccak](/book/acceleration-using-extensions/keccak) and [SHA-2](/book/acceleration-using-extensions/sha-2) hashes respectively, and `bigint` supports [Big Integer](/book/acceleration-using-extensions/big-integer) operations. [Modular](/book/acceleration-using-extensions/algebra) operations for the BN254, Secp256k1 (i.e. K256), Secp256r1 (i.e. P256), and BLS12-381 curves' scalar and coordinate field moduli are also supported, as well as [Complex Field Extension](/book/acceleration-using-extensions/algebra#complex-field-extension) operations over the BN254 and BLS12-381 coordinate fields. [Elliptic Curve Cryptography](/book/acceleration-using-extensions/elliptic-curve-cryptography) operations are also supported for the BN254, Secp256k1, Secp256r1, and BLS12-381 curves, and [Elliptic Curve Pairing](/book/acceleration-using-extensions/elliptic-curve-pairing) checks are supported for the BN254 and BLS12-381 curves. diff --git a/docs/vocs/docs/pages/book/getting-started/introduction.mdx b/docs/vocs/docs/pages/book/getting-started/introduction.mdx index dcbd750e74..4507e95e21 100644 --- a/docs/vocs/docs/pages/book/getting-started/introduction.mdx +++ b/docs/vocs/docs/pages/book/getting-started/introduction.mdx @@ -11,7 +11,8 @@ OpenVM is an open-source zero-knowledge virtual machine (zkVM) framework focused - **Extensible Instruction Set**: The instruction set architecture (ISA) is designed to be extended with new custom instructions that integrate directly with the virtual machine. Current extensions available for OpenVM include: - RISC-V support via RV32IM - - The Keccak-256 and SHA2-256 hash functions + - A native field arithmetic extension for proof recursion and aggregation + - The Keccak-256, SHA-256 and SHA-512 hash functions - Int256 arithmetic - Modular arithmetic over arbitrary fields - Elliptic curve operations, including multi-scalar multiplication and ECDSA signature verification, including for the secp256k1 and secp256r1 curves diff --git a/docs/vocs/docs/pages/book/guest-libraries/sha2.mdx b/docs/vocs/docs/pages/book/guest-libraries/sha2.mdx index 53127ca4ab..095203c21b 100644 --- a/docs/vocs/docs/pages/book/guest-libraries/sha2.mdx +++ b/docs/vocs/docs/pages/book/guest-libraries/sha2.mdx @@ -3,30 +3,33 @@ The OpenVM SHA-2 guest library provides access to a set of accelerated SHA-2 family hash functions. Currently, it supports the following: - SHA-256 +- SHA-512 +- SHA-384 -## SHA-256 - -Refer [here](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf) for more details on SHA-256. - -For SHA-256, the SHA2 guest library provides two functions for use in your guest code: - -- `sha256(input: &[u8]) -> [u8; 32]`: Computes the SHA-256 hash of the input data and returns it as an array of 32 bytes. -- `set_sha256(input: &[u8], output: &mut [u8; 32])`: Sets the output to the SHA-256 hash of the input data into the provided output buffer. - -See the full example [here](https://github.com/openvm-org/openvm/blob/main/examples/sha256/src/main.rs). +Refer to [the FIPS publication](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf) for more details on the SHA-2 family of hash functions. +The SHA-2 guest library provides the `Sha256`, `Sha512`, and `Sha384` structs for use in your guest code. +These structs mimic the identically-named structs found in the `sha2` crate, in that they implement the [`sha2::Digest` trait](https://docs.rs/sha2/latest/sha2/trait.Digest.html). +Importantly, the `sha2::Digest` trait has the following methods, which can be used to incrementally hash a stream of bytes. +```Rust +fn update(&mut self, data: impl AsRef<[u8]>); +fn finalize(self) -> GenericArray; +``` ### Example +The following example can be run as guest code or host code (i.e. run in the zkvm or natively). +To run with guest code, use `cargo openvm run`, and for host code use `cargo run`. +The implementations for `Sha256`, `Sha512`, and `Sha384` fall back to using `sha2` when running as host code. ```rust -// [!include ~/snippets/examples/sha256/src/main.rs:imports] -// [!include ~/snippets/examples/sha256/src/main.rs:main] +[!include ~/snippets/examples/sha2/src/main.rs:imports] +[!include ~/snippets/examples/sha2/src/main.rs:main] ``` -To be able to import the `sha256` function, add the following to your `Cargo.toml` file: +To be able to import the `shaXXX` functions and run the example, add the following to your `Cargo.toml` file: ```toml +openvm = { git = "https://github.com/openvm-org/openvm.git", tag = "v1.5.0" } openvm-sha2 = { git = "https://github.com/openvm-org/openvm.git", tag = "v1.5.0" } -hex = { version = "0.4.3" } ``` ### Config parameters @@ -34,4 +37,4 @@ hex = { version = "0.4.3" } For the guest program to build successfully add the following to your `.toml` file: ```toml -[app_vm_config.sha256] +[app_vm_config.sha2] diff --git a/docs/vocs/docs/pages/specs/architecture/circuit-architecture.mdx b/docs/vocs/docs/pages/specs/architecture/circuit-architecture.mdx index fc68943813..f5cbde1e55 100644 --- a/docs/vocs/docs/pages/specs/architecture/circuit-architecture.mdx +++ b/docs/vocs/docs/pages/specs/architecture/circuit-architecture.mdx @@ -105,7 +105,7 @@ The chips that fall into these categories are: | PhantomChip | 1 | 3 | Case 2. No memory accesses, 3 interactions from program bus and execution bus. | | KeccakVmChip | - | - | Case 2. Special timestamp jump. | | Rv32HintStoreChip | – | – | Case 1. | -| Sha256VmChip | – | – | Case 1. | +| Sha2VmChip | – | – | Case 1. | | DeferralOutputChip | – | – | Case 1. | The PhantomChip satisfies the condition because `1 < 3`. diff --git a/docs/vocs/docs/pages/specs/openvm/isa.mdx b/docs/vocs/docs/pages/specs/openvm/isa.mdx index 3398f7a7f2..e6189e8ead 100644 --- a/docs/vocs/docs/pages/specs/openvm/isa.mdx +++ b/docs/vocs/docs/pages/specs/openvm/isa.mdx @@ -5,7 +5,7 @@ This specification describes the overall architecture and default VM extensions - [RV32IM](#rv32im-extension): An extension supporting the 32-bit RISC-V ISA with multiplication. - [Keccak-256](#keccak-extension): An extension implementing the Keccak-256 hash function compatibly with RISC-V memory. -- [SHA2-256](#sha2-256-extension): An extension implementing the SHA2-256 hash function compatibly with RISC-V memory. +- [SHA2](#sha-2-extension): An extension implementing the SHA-256 and SHA-512 hash functions compatibly with RISC-V memory. - [BigInt](#bigint-extension): An extension supporting 256-bit signed and unsigned integer arithmetic, including multiplication. This extension respects the RISC-V memory format. - [Algebra](#algebra-extension): An extension supporting modular arithmetic over arbitrary fields and their complex @@ -456,14 +456,15 @@ all memory cells are constrained to be bytes. | -------------- | ----------- | ----------------------------------------------------------------------------------------------------------------- | | KECCAK256_RV32 | `a,b,c,1,2` | `[r32{0}(a):32]_2 = keccak256([r32{0}(b)..r32{0}(b)+r32{0}(c)]_2)`. Performs memory accesses with block size `4`. | -### SHA2-256 Extension +### SHA-2 Extension -The SHA2-256 extension supports the SHA2-256 hash function. The extension operates on address spaces `1` and `2`, +The SHA-2 extension supports the SHA-256 and SHA-512 hash functions. The extension operates on address spaces `1` and `2`, meaning all memory cells are constrained to be bytes. | Name | Operands | Description | | ----------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -| SHA256_RV32 | `a,b,c,1,2` | `[r32{0}(a):32]_2 = sha256([r32{0}(b)..r32{0}(b)+r32{0}(c)]_2)`. Does the necessary padding. Performs memory reads with block size `16` and writes with block size `32`. | +| SHA256_UPDATE_RV32 | `a,b,c,1,2` | `[r32{0}(a):32]_2 = compress256([r32{0}(b):32]_2, [r32{0}(c):64]_2)`. where `compress256(state, input)` is the SHA-256 block compression function which returns the updated state. This instruction performs memory reads and writes with block size `4`. | +| SHA512_UPDATE_RV32 | `a,b,c,1,2` | `[r32{0}(a):64]_2 = compress512([r32{0}(b):64]_2, [r32{0}(c):128]_2)`. where `compress512(state, input)` is the SHA-512 block compression function which returns the updated state. This instruction performs memory reads and writes with block size `4`. | ### BigInt Extension diff --git a/docs/vocs/docs/pages/specs/reference/instruction-reference.mdx b/docs/vocs/docs/pages/specs/reference/instruction-reference.mdx index 76d8cad739..1f069d827c 100644 --- a/docs/vocs/docs/pages/specs/reference/instruction-reference.mdx +++ b/docs/vocs/docs/pages/specs/reference/instruction-reference.mdx @@ -97,13 +97,14 @@ In the tables below, we provide the mapping between the `LocalOpcode` and `Phant | ------------- | ---------- | ------------- | | Keccak | `Rv32KeccakOpcode::KECCAK256` | KECCAK256_RV32 | -## SHA2-256 Extension +## SHA-2 Extension #### Instructions -| VM Extension | `LocalOpcode` | ISA Instruction | -| ------------- | ---------- | ------------- | -| SHA2-256 | `Rv32Sha256Opcode::SHA256` | SHA256_RV32 | +| VM Extension | `LocalOpcode` | ISA Instruction | +| ------------- | ------------------------ | ------------------------ | +| SHA-2 | `Rv32Sha2Opcode::SHA256` | SHA256_UPDATE_RV32 | +| SHA-2 | `Rv32Sha2Opcode::SHA512` | SHA512_UPDATE_RV32 | ## BigInt Extension diff --git a/docs/vocs/docs/pages/specs/reference/riscv-custom-code.mdx b/docs/vocs/docs/pages/specs/reference/riscv-custom-code.mdx index dc5dcd8d9a..362adadd07 100644 --- a/docs/vocs/docs/pages/specs/reference/riscv-custom-code.mdx +++ b/docs/vocs/docs/pages/specs/reference/riscv-custom-code.mdx @@ -5,7 +5,7 @@ The default VM extensions that support transpilation are: - [RV32IM](#rv32im-extension): An extension supporting the 32-bit RISC-V ISA with multiplication. - [Keccak-256](#keccak-extension): An extension implementing the Keccak-256 hash function compatibly with RISC-V memory. -- [SHA2-256](#sha2-256-extension): An extension implementing the SHA2-256 hash function compatibly with RISC-V memory. +- [SHA2](#sha-2-extension): An extension implementing the SHA-256 and SHA-512 hash functions compatibly with RISC-V memory. - [BigInt](#bigint-extension): An extension supporting 256-bit signed and unsigned integer arithmetic, including multiplication. This extension respects the RISC-V memory format. - [Algebra](#algebra-extension): An extension supporting modular arithmetic over arbitrary fields and their complex field extensions. This extension respects the RISC-V memory format. - [Elliptic curve](#elliptic-curve-extension): An extension for elliptic curve operations over Weierstrass curves, including addition and doubling. This can be used to implement multi-scalar multiplication and ECDSA scalar multiplication. This extension respects the RISC-V memory format. @@ -87,11 +87,12 @@ Deferral instructions use the _custom-1_ opcode prefix (`0101011`) and `funct3 = | ----------- | --- | ----------- | ------ | ------ | ------------------------------------------- | | keccak256 | R | 0001011 | 100 | 0x0 | `[rd:32]_2 = keccak256([rs1..rs1 + rs2]_2)` | -## SHA2-256 Extension +## SHA-2 Extension -| RISC-V Inst | FMT | opcode[6:0] | funct3 | funct7 | RISC-V description and notes | -| ----------- | --- | ----------- | ------ | ------ | ---------------------------------------- | -| sha256 | R | 0001011 | 100 | 0x1 | `[rd:32]_2 = sha256([rs1..rs1 + rs2]_2)` | +| RISC-V Inst | FMT | opcode[6:0] | funct3 | funct7 | RISC-V description and notes | +| ------------- | --- | ----------- | ------ | ------ | -------------------------------------------------- | +| sha256_update | R | 0001011 | 100 | 0x1 | `[rd:32]_2 = compress256([rs1:32]_2, [rs2:64]_2)` | +| sha512_update | R | 0001011 | 100 | 0x2 | `[rd:64]_2 = compress512([rs1:64]_2, [rs2:128]_2)` | ## BigInt Extension diff --git a/docs/vocs/docs/pages/specs/reference/transpiler.mdx b/docs/vocs/docs/pages/specs/reference/transpiler.mdx index ebb31770b5..6fc1c6b479 100644 --- a/docs/vocs/docs/pages/specs/reference/transpiler.mdx +++ b/docs/vocs/docs/pages/specs/reference/transpiler.mdx @@ -151,11 +151,12 @@ Each VM extension's behavior is specified below. | ----------- | -------------------------------------------------- | | keccak256 | KECCAK256_RV32 `ind(rd), ind(rs1), ind(rs2), 1, 2` | -### SHA2-256 Extension +### SHA-2 Extension -| RISC-V Inst | OpenVM Instruction | -| ----------- | ----------------------------------------------- | -| sha256 | SHA256_RV32 `ind(rd), ind(rs1), ind(rs2), 1, 2` | +| RISC-V Inst | OpenVM Instruction | +| ------------- | ------------------------------------------------------ | +| sha256_update | SHA256_UPDATE_RV32 `ind(rd), ind(rs1), ind(rs2), 1, 2` | +| sha512_update | SHA512_UPDATE_RV32 `ind(rd), ind(rs1), ind(rs2), 1, 2` | ### BigInt Extension diff --git a/examples/sha256/Cargo.toml b/examples/sha2/Cargo.toml similarity index 63% rename from examples/sha256/Cargo.toml rename to examples/sha2/Cargo.toml index 0b5a44bc3e..b093a850ae 100644 --- a/examples/sha256/Cargo.toml +++ b/examples/sha2/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "sha256-example" +name = "sha2-example" version = "0.0.0" edition = "2021" @@ -7,16 +7,14 @@ edition = "2021" members = [] [dependencies] -openvm = { git = "https://github.com/openvm-org/openvm.git", features = [ - "std", -] } +openvm = { git = "https://github.com/openvm-org/openvm.git" } openvm-sha2 = { git = "https://github.com/openvm-org/openvm.git" } -hex = { version = "0.4.3" } [features] default = [] +std = ["openvm/std"] # remove this if copying example outside of monorepo [patch."https://github.com/openvm-org/openvm.git"] openvm = { path = "../../crates/toolchain/openvm" } -openvm-sha2 = { path = "../../guest-libs/sha2" } +openvm-sha2 = { path = "../../guest-libs/sha2" } \ No newline at end of file diff --git a/examples/sha256/openvm.toml b/examples/sha2/openvm.toml similarity index 73% rename from examples/sha256/openvm.toml rename to examples/sha2/openvm.toml index 656bf52414..fb0cbe8cd4 100644 --- a/examples/sha256/openvm.toml +++ b/examples/sha2/openvm.toml @@ -1,4 +1,4 @@ [app_vm_config.rv32i] [app_vm_config.rv32m] [app_vm_config.io] -[app_vm_config.sha256] +[app_vm_config.sha2] \ No newline at end of file diff --git a/examples/sha2/src/main.rs b/examples/sha2/src/main.rs new file mode 100644 index 0000000000..c11221d33d --- /dev/null +++ b/examples/sha2/src/main.rs @@ -0,0 +1,41 @@ +// [!region imports] +#![cfg_attr(all(target_os = "zkvm", not(feature = "std")), no_main)] +#![cfg_attr(all(target_os = "zkvm", not(feature = "std")), no_std)] + +extern crate alloc; + +use alloc::{format, string::String}; + +use openvm_sha2::{Digest, Sha256, Sha384, Sha512}; + +openvm::entry!(main); +// [!endregion imports] + +// [!region main] +fn println(s: String) { + #[cfg(target_os = "zkvm")] + openvm::io::println(s); + #[cfg(not(target_os = "zkvm"))] + println!("{}", s); +} +pub fn main() { + let mut sha256 = Sha256::new(); + sha256.update(b"Hello, world!"); + sha256.update(b"some other input"); + let output = sha256.finalize(); + println(format!("SHA-256: {:?}", output)); + + let mut sha512 = Sha512::new(); + sha512.update(b"Hello, world!"); + sha512.update(b"some other input"); + let output = sha512.finalize(); + println(format!("SHA-512: {:?}", output)); + + let mut sha384 = Sha384::new(); + sha384.update(b"Hello, world!"); + sha384.update(b"some other input"); + let output = sha384.finalize(); + println(format!("SHA-384: {:?}", output)); +} + +// [!endregion main] diff --git a/examples/sha256/src/main.rs b/examples/sha256/src/main.rs deleted file mode 100644 index 670ac5c011..0000000000 --- a/examples/sha256/src/main.rs +++ /dev/null @@ -1,24 +0,0 @@ -// [!region imports] -use core::hint::black_box; - -use hex::FromHex; -use openvm as _; -use openvm_sha2::sha256; -// [!endregion imports] - -// [!region main] -pub fn main() { - let test_vectors = [( - "", - "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", - )]; - for (input, expected_output) in test_vectors.iter() { - let input = Vec::from_hex(input).unwrap(); - let expected_output = Vec::from_hex(expected_output).unwrap(); - let output = sha256(&black_box(input)); - if output != *expected_output { - panic!(); - } - } -} -// [!endregion main] diff --git a/extensions/sha256/circuit/Cargo.toml b/extensions/sha2/circuit/Cargo.toml similarity index 81% rename from extensions/sha256/circuit/Cargo.toml rename to extensions/sha2/circuit/Cargo.toml index 3ee68540e5..6fd9998524 100644 --- a/extensions/sha256/circuit/Cargo.toml +++ b/extensions/sha2/circuit/Cargo.toml @@ -1,9 +1,9 @@ [package] -name = "openvm-sha256-circuit" +name = "openvm-sha2-circuit" version.workspace = true authors.workspace = true edition.workspace = true -description = "OpenVM circuit extension for sha256" +description = "OpenVM circuit extension for SHA-2" [dependencies] openvm-stark-backend = { workspace = true } @@ -12,20 +12,23 @@ openvm-stark-sdk = { workspace = true, features = ["cpu-backend"] } openvm-cuda-backend = { workspace = true, optional = true } openvm-cuda-common = { workspace = true, optional = true } openvm-circuit-primitives = { workspace = true } +openvm-circuit-primitives-derive = { workspace = true } openvm-circuit-derive = { workspace = true } openvm-circuit = { workspace = true } openvm-instructions = { workspace = true } -openvm-sha256-transpiler = { workspace = true } +openvm-sha2-transpiler = { workspace = true } openvm-rv32im-circuit = { workspace = true } -openvm-sha256-air = { workspace = true } + +openvm-sha2-air = { workspace = true } derive-new.workspace = true derive_more = { workspace = true, features = ["from"] } rand.workspace = true serde.workspace = true -sha2 = { version = "0.10", default-features = false } -strum = { workspace = true } +sha2 = { version = "0.10", features = ["compress"] } +ndarray = { workspace = true, default-features = false } cfg-if.workspace = true +itertools = { workspace = true } [dev-dependencies] hex = { workspace = true } @@ -62,3 +65,6 @@ touchemall = [ "openvm-cuda-common/touchemall", "openvm-rv32im-circuit/touchemall", ] + +[package.metadata.cargo-shear] +ignored = ["ndarray"] \ No newline at end of file diff --git a/extensions/sha2/circuit/README.md b/extensions/sha2/circuit/README.md new file mode 100644 index 0000000000..d98d9d6a4c --- /dev/null +++ b/extensions/sha2/circuit/README.md @@ -0,0 +1,93 @@ +# SHA-2 VM Extension + +This crate contains circuits for the SHA-2 family of hash functions. +We support constraining the block compression functions for SHA-256 and SHA-512. +It is also possible to use this crate to constrain the SHA-384 algorithm, as described in the next section. + +## SHA-2 Algorithms Summary + +The SHA-256, SHA-512, and SHA-384 algorithms are similar in structure. +We will first describe the SHA-256 algorithm, and then describe the differences between the three algorithms. + +See the [FIPS standard](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf) for reference. In particular, sections 6.2, 6.4, and 6.5. + +In short the SHA-256 algorithm works as follows. +1. Pad the message to 512 bits and split it into 512-bit 'blocks'. +2. Initialize a hash state consisting of eight 32-bit words to a specific constant value. +3. For each block, + 1. split the message into 16 32-bit words and produce 48 more words based on them. The 16 message words together with the 48 additional words are called the 'message schedule'. + 2. apply a scrambling function 64 times to the hash state to update it based on the message schedule. We call each update a 'round'. + 3. add the previous block's final hash state to the current hash state (modulo $2^{32}$). +4. The output is the final hash state + +The differences with the SHA-512 algorithm are that: +- SHA-512 uses 64-bit words, 1024-bit blocks, performs 80 rounds, and produces a 512-bit output. +- all the arithmetic is done modulo $2^{64}$. +- the initial hash state is different. + +The SHA-384 algorithm is a truncation of the SHA-512 output to 384 bits, and the only difference is that the initial hash state is different. +In particular, SHA-384 shares its compression function with SHA-512, so users may write guest code that supports SHA-384 by using this crate's SHA-512 compression function. + +## Design Overview + +We support the `SHA256_UPDATE` and `SHA512_UPDATE` intrinsic instructions, each of which takes three operands, `dst`, `state`, and `input`. +- `input` is a pointer to exactly one block of message bytes (the size of a block varies for each SHA-2 variant.) +- `state` is a pointer to the current hasher state (8 words in big endian). Word size varies by SHA-2 variant. +- `dst` is a pointer where the updated state should be stored. `dst` may be equal to `state`. + +The `SHA256_UPDATE` and `SHA512_UPDATE` instructions write the value of the updated hasher state after consuming the input to `dst`. +Note that these instructions do not pad the input. + +### Chips + +The SHA-2 extension consists of 2 chips: `Sha2MainChip` and `Sha2BlockHasherChip`. + +The main chip constraints reading `state` and `input` from memory and writing the new state into `dst`. +The main chip sends the operands to the the block hasher chip via interactions. +The trace of the main chip consists of one row per instruction. + +The block hasher chip constraints the SHA-2 compression algorithm for one block at a time. +More specifically, the trace of the block hasher chip consists of groups of 17 consecutive rows (21 for SHA-512) which together constrain the 64 (resp. 80) rounds of the SHA-2 compression algorithm for one block of input +Each block receives the previous hasher state and the input bytes from the main chip and sends the updated state to the main chip via interactions. +Note that the block hasher chip consists of a SubAir, which constrains all the SHA-2 logic, while the block hasher chip itself only constrains its interactions with the main chip. + + +### Air Design + +We reuse the same AIR code to produce circuits for SHA-256 and SHA-512. +To achieve this, we parameterize the AIR by constants (such as the word size, number of rounds, and block size) that are specific to each algorithm. + +The block hasher AIR consists of $R+1$ rows for each instruction, and no more rows +(for SHA-256, $R = 16$ and for SHA-512 and SHA-384, $R = 20$). +The first $R$ rows of each block are called 'round rows', and each of them constrains four rounds of the hash algorithm. +Each row constrains updates to the working variables on each round, and also constrains the message schedule words based on previous rounds. +The final row of each block is called a 'digest row' and it produces a final hash for the block, computed as the sum of the working variables and the previous block's final hash. + +### Storing working variables + +One optimization is that we only keep track of the `a` and `e` working variables. +It turns out that if we have their values over four consecutive rounds, we can reconstruct all eight variables at the end of the four rounds. +This is because there is overlap between the values of the working variables in adjacent rounds. +If the state is visualized as an array, `s_0 = [a, b, c, d, e, f, g, h]`, then the new state, `s_1`, after one round is produced by a right-shift and an addition. +More formally, +``` +s_1 = (s_0 >> 1) + [T_1 + T_2, 0, 0, 0, T_1, 0, 0, 0] + = [0, a, b, c, d, e, f, g] + [T_1 + T_2, 0, 0, 0, T_1, 0, 0, 0] + = [T_1 + T_2, a, b, c, d + T_1, e, f, g] +``` +where `T_1` and `T_2` are certain functions of the working variables and message data (see the FIPS spec). +So if `a_i` and `e_i` denote the values of `a` and `e` after the `i`th round, for `0 <= i < 4`, then the state `s_3` after the fourth round can be written as `s_3 = [a_3, a_2, a_1, a_0, e_3, e_2, e_1, e_0]`. + +### Message schedule constraints + +The algorithm for computing the message schedule involves message schedule words from 16 rounds ago. +Since we can only constrain two rows at a time, we cannot access data from more than four rounds ago for the first round in each row. +So, we maintain intermediate values that we call `intermed_4`, `intermed_8` and `intermed_12`, where `intermed_i = w_i + sig_0(w_{i+1})` where `w_i` is the value of `w` from `i` rounds ago and `sig_0` denotes the `sigma_0` function from the FIPS spec. +Since we can reliably constrain values from four rounds ago, we can build up `intermed_16` from these values, which is needed for computing the message schedule. + + +### Dummy values + +Some constraints have degree three, and so we cannot restrict them to particular rows due to the limitation of the maximum constraint degree. +We must enforce them on all rows, and in order to ensure they hold on the remaining rows we must fill in some cells with appropriate dummy values. +We use this trick in several places in this chip. diff --git a/extensions/sha256/circuit/build.rs b/extensions/sha2/circuit/build.rs similarity index 74% rename from extensions/sha256/circuit/build.rs rename to extensions/sha2/circuit/build.rs index bcb991c8b9..ea99d52b66 100644 --- a/extensions/sha256/circuit/build.rs +++ b/extensions/sha2/circuit/build.rs @@ -7,18 +7,16 @@ fn main() { if !cuda_available() { return; // Skip CUDA compilation } - let builder: CudaBuilder = CudaBuilder::new() .include_from_dep("DEP_CUDA_COMMON_INCLUDE") + .include("cuda/include") .include("../../../crates/circuits/primitives/cuda/include") - .include("../../../crates/circuits/sha256-air/cuda/include") .include("../../../crates/vm/cuda/include") .watch("cuda") .watch("../../../crates/circuits/primitives/cuda") - .watch("../../../crates/circuits/sha256-air/cuda") .watch("../../../crates/vm/cuda") - .library_name("tracegen_gpu_sha256") - .file("cuda/src/sha256.cu"); + .library_name("tracegen_gpu_sha2") + .files_from_glob("cuda/src/*.cu"); builder.emit_link_directives(); builder.build(); diff --git a/extensions/sha2/circuit/cuda/include/block_hasher/columns.cuh b/extensions/sha2/circuit/cuda/include/block_hasher/columns.cuh new file mode 100644 index 0000000000..622ffe6cff --- /dev/null +++ b/extensions/sha2/circuit/cuda/include/block_hasher/columns.cuh @@ -0,0 +1,110 @@ +#pragma once + +#include +#include + +// Column structs matching the new block-hasher AIR (request_id + inner round/digest columns). +template struct Sha2FlagsCols { + T is_round_row; + T is_first_4_rows; + T is_digest_row; + T row_idx[V::ROW_VAR_CNT]; + T global_block_idx; +}; + +template struct Sha2MessageHelperCols { + T w_3[V::ROUNDS_PER_ROW_MINUS_ONE][V::WORD_U16S]; + T intermed_4[V::ROUNDS_PER_ROW][V::WORD_U16S]; + T intermed_8[V::ROUNDS_PER_ROW][V::WORD_U16S]; + T intermed_12[V::ROUNDS_PER_ROW][V::WORD_U16S]; +}; + +template struct Sha2MessageScheduleCols { + T w[V::ROUNDS_PER_ROW][V::WORD_BITS]; + T carry_or_buffer[V::ROUNDS_PER_ROW][V::WORD_U8S]; +}; + +template struct Sha2WorkVarsCols { + T a[V::ROUNDS_PER_ROW][V::WORD_BITS]; + T e[V::ROUNDS_PER_ROW][V::WORD_BITS]; + T carry_a[V::ROUNDS_PER_ROW][V::WORD_U16S]; + T carry_e[V::ROUNDS_PER_ROW][V::WORD_U16S]; +}; + +template struct Sha2RoundCols { + Sha2FlagsCols flags; + Sha2WorkVarsCols work_vars; + Sha2MessageHelperCols schedule_helper; + Sha2MessageScheduleCols message_schedule; +}; + +template struct Sha2DigestCols { + Sha2FlagsCols flags; + Sha2WorkVarsCols hash; + Sha2MessageHelperCols schedule_helper; + T final_hash[V::HASH_WORDS][V::WORD_U8S]; + T prev_hash[V::HASH_WORDS][V::WORD_U16S]; +}; + +template struct Sha2BlockHasherRoundCols { + T request_id; + Sha2RoundCols inner; +}; + +template struct Sha2BlockHasherDigestCols { + T request_id; + Sha2DigestCols inner; +}; + +template struct Sha2Layout { + static constexpr size_t ROUND_WIDTH = sizeof(Sha2BlockHasherRoundCols); + static constexpr size_t DIGEST_WIDTH = sizeof(Sha2BlockHasherDigestCols); + static constexpr size_t WIDTH = (ROUND_WIDTH > DIGEST_WIDTH) ? ROUND_WIDTH : DIGEST_WIDTH; + static constexpr size_t INNER_OFFSET = sizeof(uint8_t); // request_id + static constexpr size_t INNER_COLUMN_OFFSET = sizeof(uint8_t); +}; + +#define SHA2_COL_INDEX(V, STRUCT, FIELD) \ + (reinterpret_cast(&(reinterpret_cast *>(0)->FIELD))) +#define SHA2_COL_ARRAY_LEN(V, STRUCT, FIELD) \ + (sizeof((reinterpret_cast *>(0)->FIELD))) +#define SHA2_WRITE_VALUE(V, ROW, STRUCT, FIELD, VALUE) \ + (ROW).write(SHA2_COL_INDEX(V, STRUCT, FIELD), VALUE) +#define SHA2_WRITE_ARRAY(V, ROW, STRUCT, FIELD, VALUES) \ + (ROW).write_array( \ + SHA2_COL_INDEX(V, STRUCT, FIELD), SHA2_COL_ARRAY_LEN(V, STRUCT, FIELD), VALUES \ + ) +#define SHA2_WRITE_BITS(V, ROW, STRUCT, FIELD, VALUE) \ + (ROW).write_bits(SHA2_COL_INDEX(V, STRUCT, FIELD), VALUE) +#define SHA2_FILL_ZERO(V, ROW, STRUCT, FIELD) \ + (ROW).fill_zero(SHA2_COL_INDEX(V, STRUCT, FIELD), SHA2_COL_ARRAY_LEN(V, STRUCT, FIELD)) +#define SHA2_SLICE_FROM(V, ROW, STRUCT, FIELD) (ROW).slice_from(SHA2_COL_INDEX(V, STRUCT, FIELD)) + +#define SHA2_WRITE_ROUND(V, row, FIELD, VALUE) \ + SHA2_WRITE_VALUE(V, row, Sha2BlockHasherRoundCols, FIELD, VALUE) +#define SHA2_WRITE_DIGEST(V, row, FIELD, VALUE) \ + SHA2_WRITE_VALUE(V, row, Sha2BlockHasherDigestCols, FIELD, VALUE) +#define SHA2_WRITE_ARRAY_ROUND(V, row, FIELD, VALUES) \ + SHA2_WRITE_ARRAY(V, row, Sha2BlockHasherRoundCols, FIELD, VALUES) +#define SHA2_WRITE_ARRAY_DIGEST(V, row, FIELD, VALUES) \ + SHA2_WRITE_ARRAY(V, row, Sha2BlockHasherDigestCols, FIELD, VALUES) +#define SHA2_FILL_ZERO_ROUND(V, row, FIELD) SHA2_FILL_ZERO(V, row, Sha2BlockHasherRoundCols, FIELD) +#define SHA2_FILL_ZERO_DIGEST(V, row, FIELD) \ + SHA2_FILL_ZERO(V, row, Sha2BlockHasherDigestCols, FIELD) +#define SHA2_SLICE_ROUND(V, row, FIELD) SHA2_SLICE_FROM(V, row, Sha2BlockHasherRoundCols, FIELD) +#define SHA2_SLICE_DIGEST(V, row, FIELD) SHA2_SLICE_FROM(V, row, Sha2BlockHasherDigestCols, FIELD) + +#define SHA2INNER_WRITE_ROUND(V, row, FIELD, VALUE) \ + SHA2_WRITE_VALUE(V, row, Sha2RoundCols, FIELD, VALUE) +#define SHA2INNER_WRITE_DIGEST(V, row, FIELD, VALUE) \ + SHA2_WRITE_VALUE(V, row, Sha2DigestCols, FIELD, VALUE) +#define SHA2INNER_WRITE_ARRAY_ROUND(V, row, FIELD, VALUES) \ + SHA2_WRITE_ARRAY(V, row, Sha2RoundCols, FIELD, VALUES) +#define SHA2INNER_WRITE_ARRAY_DIGEST(V, row, FIELD, VALUES) \ + SHA2_WRITE_ARRAY(V, row, Sha2DigestCols, FIELD, VALUES) +#define SHA2INNER_FILL_ZERO_ROUND(V, row, FIELD) SHA2_FILL_ZERO(V, row, Sha2RoundCols, FIELD) +#define SHA2INNER_FILL_ZERO_DIGEST(V, row, FIELD) SHA2_FILL_ZERO(V, row, Sha2DigestCols, FIELD) +#define SHA2INNER_WRITE_BITS_ROUND(V, row, FIELD, VALUE) \ + SHA2_WRITE_BITS(V, row, Sha2RoundCols, FIELD, VALUE) +#define SHA2INNER_WRITE_BITS_DIGEST(V, row, FIELD, VALUE) \ + SHA2_WRITE_BITS(V, row, Sha2DigestCols, FIELD, VALUE) diff --git a/extensions/sha2/circuit/cuda/include/block_hasher/record.cuh b/extensions/sha2/circuit/cuda/include/block_hasher/record.cuh new file mode 100644 index 0000000000..4ee1bc4d0f --- /dev/null +++ b/extensions/sha2/circuit/cuda/include/block_hasher/record.cuh @@ -0,0 +1,68 @@ +#pragma once + +#include "system/memory/offline_checker.cuh" +#include "variant.cuh" +#include + +namespace sha2 { + +// GPU view of the per-block record produced by the executor (matches Sha2RecordMut in Rust). +template struct Sha2BlockRecordHeader { + uint32_t variant; + uint32_t from_pc; + uint32_t timestamp; + uint32_t dst_reg_ptr; + uint32_t state_reg_ptr; + uint32_t input_reg_ptr; + uint32_t dst_ptr; + uint32_t state_ptr; + uint32_t input_ptr; + MemoryReadAuxRecord register_reads_aux[sha2::SHA2_REGISTER_READS]; +}; + +template struct Sha2BlockRecordMut { + Sha2BlockRecordHeader *header; + uint8_t *message_bytes; + uint8_t *prev_state; + uint8_t *new_state; + MemoryReadAuxRecord *input_reads_aux; + MemoryReadAuxRecord *state_reads_aux; + MemoryWriteBytesAuxRecord *write_aux; + + __device__ __host__ __forceinline__ static uint32_t next_multiple_of( + uint32_t value, + uint32_t alignment + ) { + return ((value + alignment - 1) / alignment) * alignment; + } + + __device__ __host__ __forceinline__ Sha2BlockRecordMut(uint8_t *record_buf) { + header = reinterpret_cast *>(record_buf); + uint32_t offset = sizeof(Sha2BlockRecordHeader); + + message_bytes = record_buf + offset; + offset += V::BLOCK_U8S; + + prev_state = record_buf + offset; + offset += V::STATE_BYTES; + + new_state = record_buf + offset; + offset += V::STATE_BYTES; + + offset = next_multiple_of(offset, alignof(MemoryReadAuxRecord)); + input_reads_aux = reinterpret_cast(record_buf + offset); + offset += V::BLOCK_READS * sizeof(MemoryReadAuxRecord); + + offset = next_multiple_of(offset, alignof(MemoryReadAuxRecord)); + state_reads_aux = reinterpret_cast(record_buf + offset); + offset += V::STATE_READS * sizeof(MemoryReadAuxRecord); + + offset = + next_multiple_of(offset, alignof(MemoryWriteBytesAuxRecord)); + write_aux = reinterpret_cast *>( + record_buf + offset + ); + } +}; + +} // namespace sha2 diff --git a/extensions/sha2/circuit/cuda/include/block_hasher/variant.cuh b/extensions/sha2/circuit/cuda/include/block_hasher/variant.cuh new file mode 100644 index 0000000000..ec36a9dd1c --- /dev/null +++ b/extensions/sha2/circuit/cuda/include/block_hasher/variant.cuh @@ -0,0 +1,297 @@ +#pragma once + +#include +#include + +namespace sha2 { + +// Common VM constants across SHA-2 variants. +inline constexpr size_t SHA2_REGISTER_READS = 3; +inline constexpr size_t SHA2_READ_SIZE = 4; +inline constexpr size_t SHA2_WRITE_SIZE = 4; +inline constexpr size_t SHA2_MAIN_READ_SIZE = 4; + +template < + typename WordT, + size_t WORD_BITS_, + size_t BLOCK_WORDS_, + size_t ROUNDS_PER_ROW_, + size_t ROUNDS_PER_BLOCK_, + size_t HASH_WORDS_, + size_t ROW_VAR_CNT_, + size_t MESSAGE_LENGTH_BITS_> +struct Sha2VariantBase { + using Word = WordT; + + static constexpr size_t WORD_BITS = WORD_BITS_; + static constexpr size_t BLOCK_WORDS = BLOCK_WORDS_; + static constexpr size_t ROUNDS_PER_ROW = ROUNDS_PER_ROW_; + static constexpr size_t ROUNDS_PER_BLOCK = ROUNDS_PER_BLOCK_; + static constexpr size_t HASH_WORDS = HASH_WORDS_; + static constexpr size_t ROW_VAR_CNT = ROW_VAR_CNT_; + static constexpr size_t MESSAGE_LENGTH_BITS = MESSAGE_LENGTH_BITS_; + + static constexpr size_t WORD_U16S = WORD_BITS / 16; + static constexpr size_t WORD_U8S = WORD_BITS / 8; + static constexpr size_t WORD_BYTES = WORD_U8S; + static constexpr size_t BLOCK_U8S = BLOCK_WORDS * WORD_U8S; + static constexpr size_t BLOCK_BYTES = BLOCK_U8S; + static constexpr size_t BLOCK_BITS = BLOCK_WORDS * WORD_BITS; + static constexpr size_t ROUND_ROWS = ROUNDS_PER_BLOCK / ROUNDS_PER_ROW; + static constexpr size_t MESSAGE_ROWS = BLOCK_WORDS / ROUNDS_PER_ROW; + static constexpr size_t ROUNDS_PER_ROW_MINUS_ONE = ROUNDS_PER_ROW - 1; + + static constexpr size_t NUM_READ_ROWS = BLOCK_U8S / SHA2_READ_SIZE; + static constexpr size_t STATE_BYTES = HASH_WORDS * WORD_U8S; + static constexpr size_t BLOCK_READS = BLOCK_U8S / SHA2_MAIN_READ_SIZE; + static constexpr size_t STATE_READS = STATE_BYTES / SHA2_MAIN_READ_SIZE; + static constexpr size_t STATE_WRITES = STATE_BYTES / SHA2_WRITE_SIZE; + static constexpr size_t TIMESTAMP_DELTA = + BLOCK_READS + STATE_READS + STATE_WRITES + SHA2_REGISTER_READS; +}; + +// SHA-256 constants +static constexpr uint32_t SHA256_K_HOST[64] = { + 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, + 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, + 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, + 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, + 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, + 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, + 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, + 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2, +}; + +static constexpr uint32_t SHA256_H_HOST[8] = { + 0x6a09e667, + 0xbb67ae85, + 0x3c6ef372, + 0xa54ff53a, + 0x510e527f, + 0x9b05688c, + 0x1f83d9ab, + 0x5be0cd19, +}; + +// SHA-512 constants +static constexpr uint64_t SHA512_K_HOST[80] = { + 0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc, + 0x3956c25bf348b538, 0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, + 0xd807aa98a3030242, 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2, + 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235, 0xc19bf174cf692694, + 0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, + 0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5, + 0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4, + 0xc6e00bf33da88fc2, 0xd5a79147930aa725, 0x06ca6351e003826f, 0x142929670a0e6e70, + 0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df, + 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b, + 0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30, + 0xd192e819d6ef5218, 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8, + 0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8, + 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, + 0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec, + 0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b, + 0xca273eceea26619c, 0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, + 0x06f067aa72176fba, 0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b, + 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c, + 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817, +}; + +static constexpr uint64_t SHA512_H_HOST[8] = { + 0x6a09e667f3bcc908, + 0xbb67ae8584caa73b, + 0x3c6ef372fe94f82b, + 0xa54ff53a5f1d36f1, + 0x510e527fade682d1, + 0x9b05688c2b3e6c1f, + 0x1f83d9abfb41bd6b, + 0x5be0cd19137e2179, +}; + +// Device copies of the constants +// These are only defined when SHA2_DEFINE_DEVICE_CONSTANTS is set (in sha2_hasher.cu) +#ifdef SHA2_DEFINE_DEVICE_CONSTANTS +__device__ __constant__ uint32_t SHA256_K_DEV[64] = { + 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, + 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, + 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, + 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, + 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, + 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, + 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, + 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2, +}; +__device__ __constant__ uint32_t SHA256_H_DEV[8] = { + 0x6a09e667, + 0xbb67ae85, + 0x3c6ef372, + 0xa54ff53a, + 0x510e527f, + 0x9b05688c, + 0x1f83d9ab, + 0x5be0cd19, +}; +__device__ __constant__ uint64_t SHA512_K_DEV[80] = { + 0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc, + 0x3956c25bf348b538, 0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, + 0xd807aa98a3030242, 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2, + 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235, 0xc19bf174cf692694, + 0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, + 0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5, + 0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4, + 0xc6e00bf33da88fc2, 0xd5a79147930aa725, 0x06ca6351e003826f, 0x142929670a0e6e70, + 0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df, + 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b, + 0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30, + 0xd192e819d6ef5218, 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8, + 0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8, + 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, + 0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec, + 0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b, + 0xca273eceea26619c, 0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, + 0x06f067aa72176fba, 0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b, + 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c, + 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817, +}; +__device__ __constant__ uint64_t SHA512_H_DEV[8] = { + 0x6a09e667f3bcc908, + 0xbb67ae8584caa73b, + 0x3c6ef372fe94f82b, + 0xa54ff53a5f1d36f1, + 0x510e527fade682d1, + 0x9b05688c2b3e6c1f, + 0x1f83d9abfb41bd6b, + 0x5be0cd19137e2179, +}; +#else +extern __device__ __constant__ uint32_t SHA256_K_DEV[64]; +extern __device__ __constant__ uint32_t SHA256_H_DEV[8]; +extern __device__ __constant__ uint64_t SHA512_K_DEV[80]; +extern __device__ __constant__ uint64_t SHA512_H_DEV[8]; +#endif + +struct Sha256Variant : Sha2VariantBase { + static constexpr size_t ROWS_PER_BLOCK = 17; + static constexpr int SIGMA_A0 = 2; + static constexpr int SIGMA_A1 = 13; + static constexpr int SIGMA_A2 = 22; + static constexpr int SIGMA_E0 = 6; + static constexpr int SIGMA_E1 = 11; + static constexpr int SIGMA_E2 = 25; + static constexpr int SIGMA0_ROT1 = 7; + static constexpr int SIGMA0_ROT2 = 18; + static constexpr int SIGMA0_SHR = 3; + static constexpr int SIGMA1_ROT1 = 17; + static constexpr int SIGMA1_ROT2 = 19; + static constexpr int SIGMA1_SHR = 10; + + __device__ __host__ static inline Word K(size_t i) { +#ifdef __CUDA_ARCH__ + return SHA256_K_DEV[i]; +#else + return SHA256_K_HOST[i]; +#endif + } + __device__ __host__ static inline Word H(size_t i) { +#ifdef __CUDA_ARCH__ + return SHA256_H_DEV[i]; +#else + return SHA256_H_HOST[i]; +#endif + } +}; + +struct Sha512Variant : Sha2VariantBase { + static constexpr size_t ROWS_PER_BLOCK = 21; + static constexpr int SIGMA_A0 = 28; + static constexpr int SIGMA_A1 = 34; + static constexpr int SIGMA_A2 = 39; + static constexpr int SIGMA_E0 = 14; + static constexpr int SIGMA_E1 = 18; + static constexpr int SIGMA_E2 = 41; + static constexpr int SIGMA0_ROT1 = 1; + static constexpr int SIGMA0_ROT2 = 8; + static constexpr int SIGMA0_SHR = 7; + static constexpr int SIGMA1_ROT1 = 19; + static constexpr int SIGMA1_ROT2 = 61; + static constexpr int SIGMA1_SHR = 6; + + __device__ __host__ static inline Word K(size_t i) { +#ifdef __CUDA_ARCH__ + return SHA512_K_DEV[i]; +#else + return SHA512_K_HOST[i]; +#endif + } + __device__ __host__ static inline Word H(size_t i) { +#ifdef __CUDA_ARCH__ + return SHA512_H_DEV[i]; +#else + return SHA512_H_HOST[i]; +#endif + } +}; + +template +__device__ __host__ __forceinline__ WordT rotr_generic(WordT value, int n); + +template <> inline __device__ __host__ uint32_t rotr_generic(uint32_t value, int n) { + return (value >> n) | (value << (32 - n)); +} + +template <> inline __device__ __host__ uint64_t rotr_generic(uint64_t value, int n) { + return (value >> n) | (value << (64 - n)); +} + +template +__device__ __host__ __forceinline__ typename V::Word big_sig0(typename V::Word x) { + return rotr_generic(x, V::SIGMA_A0) ^ + rotr_generic(x, V::SIGMA_A1) ^ + rotr_generic(x, V::SIGMA_A2); +} + +template +__device__ __host__ __forceinline__ typename V::Word big_sig1(typename V::Word x) { + return rotr_generic(x, V::SIGMA_E0) ^ + rotr_generic(x, V::SIGMA_E1) ^ + rotr_generic(x, V::SIGMA_E2); +} + +template +__device__ __host__ __forceinline__ typename V::Word small_sig0(typename V::Word x) { + return rotr_generic(x, V::SIGMA0_ROT1) ^ + rotr_generic(x, V::SIGMA0_ROT2) ^ (x >> V::SIGMA0_SHR); +} + +template +__device__ __host__ __forceinline__ typename V::Word small_sig1(typename V::Word x) { + return rotr_generic(x, V::SIGMA1_ROT1) ^ + rotr_generic(x, V::SIGMA1_ROT2) ^ (x >> V::SIGMA1_SHR); +} + +template +__device__ __host__ __forceinline__ typename V::Word ch( + typename V::Word x, + typename V::Word y, + typename V::Word z +) { + return (x & y) ^ ((~x) & z); +} + +template +__device__ __host__ __forceinline__ typename V::Word maj( + typename V::Word x, + typename V::Word y, + typename V::Word z +) { + return (x & y) ^ (x & z) ^ (y & z); +} + +template __device__ __host__ __forceinline__ uint32_t get_num_blocks(uint32_t len) { + constexpr uint32_t length_bits = static_cast(V::MESSAGE_LENGTH_BITS); + uint64_t bit_len = static_cast(len) * 8; + uint64_t padded_bit_len = bit_len + 1 + length_bits; + return static_cast((padded_bit_len + (V::BLOCK_BITS - 1)) / V::BLOCK_BITS); +} + +} // namespace sha2 diff --git a/extensions/sha2/circuit/cuda/include/main/columns.cuh b/extensions/sha2/circuit/cuda/include/main/columns.cuh new file mode 100644 index 0000000000..88e054d4e3 --- /dev/null +++ b/extensions/sha2/circuit/cuda/include/main/columns.cuh @@ -0,0 +1,116 @@ +#pragma once + +#include "block_hasher/variant.cuh" +#include "primitives/constants.h" +#include "primitives/execution.h" +#include "system/memory/offline_checker.cuh" +#include +#include + +using namespace riscv; + +namespace sha2 { + +template struct Sha2MainBlockCols { + T request_id; + T message_bytes[V::BLOCK_U8S]; + T prev_state[V::STATE_BYTES]; + T new_state[V::STATE_BYTES]; +}; + +template struct Sha2MainInstructionCols { + T is_enabled; + ExecutionState from_state; + T dst_reg_ptr; + T state_reg_ptr; + T input_reg_ptr; + T dst_ptr_limbs[RV32_REGISTER_NUM_LIMBS]; + T state_ptr_limbs[RV32_REGISTER_NUM_LIMBS]; + T input_ptr_limbs[RV32_REGISTER_NUM_LIMBS]; +}; + +template struct Sha2MainMemoryCols { + MemoryReadAuxCols register_aux[sha2::SHA2_REGISTER_READS]; + MemoryReadAuxCols input_reads[V::BLOCK_READS]; + MemoryReadAuxCols state_reads[V::STATE_READS]; + MemoryWriteAuxCols write_aux[V::STATE_WRITES]; +}; + +template struct Sha2MainCols { + Sha2MainBlockCols block; + Sha2MainInstructionCols instruction; + Sha2MainMemoryCols mem; +}; + +template struct Sha2MainLayout { + static constexpr size_t WIDTH = sizeof(Sha2MainCols); +}; + +#define SHA2_MAIN_COL_INDEX_V(V, STRUCT, FIELD) \ + (reinterpret_cast(&(reinterpret_cast *>(0)->FIELD))) +#define SHA2_MAIN_COL_INDEX_PLAIN(STRUCT, FIELD) \ + (reinterpret_cast(&(reinterpret_cast *>(0)->FIELD))) + +#define SHA2_MAIN_COL_ARRAY_LEN_V(V, STRUCT, FIELD) \ + (sizeof((reinterpret_cast *>(0)->FIELD))) +#define SHA2_MAIN_COL_ARRAY_LEN_PLAIN(STRUCT, FIELD) \ + (sizeof((reinterpret_cast *>(0)->FIELD))) + +#define SHA2_MAIN_WRITE_VALUE_V(V, ROW, STRUCT, FIELD, VALUE) \ + (ROW).write(SHA2_MAIN_COL_INDEX_V(V, STRUCT, FIELD), VALUE) +#define SHA2_MAIN_WRITE_VALUE_PLAIN(ROW, STRUCT, FIELD, VALUE) \ + (ROW).write(SHA2_MAIN_COL_INDEX_PLAIN(STRUCT, FIELD), VALUE) + +#define SHA2_MAIN_WRITE_ARRAY_V(V, ROW, STRUCT, FIELD, VALUES) \ + (ROW).write_array( \ + SHA2_MAIN_COL_INDEX_V(V, STRUCT, FIELD), \ + SHA2_MAIN_COL_ARRAY_LEN_V(V, STRUCT, FIELD), \ + VALUES \ + ) +#define SHA2_MAIN_WRITE_ARRAY_PLAIN(ROW, STRUCT, FIELD, VALUES) \ + (ROW).write_array( \ + SHA2_MAIN_COL_INDEX_PLAIN(STRUCT, FIELD), \ + SHA2_MAIN_COL_ARRAY_LEN_PLAIN(STRUCT, FIELD), \ + VALUES \ + ) + +#define SHA2_MAIN_FILL_ZERO_V(V, ROW, STRUCT, FIELD) \ + (ROW).fill_zero(SHA2_MAIN_COL_INDEX_V(V, STRUCT, FIELD), SHA2_MAIN_COL_ARRAY_LEN_V(V, STRUCT, FIELD)) +#define SHA2_MAIN_SLICE_FROM_V(V, ROW, STRUCT, FIELD) \ + (ROW).slice_from(SHA2_MAIN_COL_INDEX_V(V, STRUCT, FIELD)) + +// Compute offset of nested struct field: offsetof(Sha2MainCols, block) + offsetof(Sha2MainBlockCols, FIELD) +#define SHA2_MAIN_COL_INDEX_BLOCK_V(V, FIELD) \ + (SHA2_MAIN_COL_INDEX_V(V, Sha2MainCols, block) + \ + SHA2_MAIN_COL_INDEX_V(V, Sha2MainBlockCols, FIELD)) +// Compute offset of nested struct field: offsetof(Sha2MainCols, instruction) + offsetof(Sha2MainInstructionCols, FIELD) +#define SHA2_MAIN_COL_INDEX_INSTR(V, FIELD) \ + (SHA2_MAIN_COL_INDEX_V(V, Sha2MainCols, instruction) + \ + SHA2_MAIN_COL_INDEX_PLAIN(Sha2MainInstructionCols, FIELD)) +// Compute offset of nested struct field: offsetof(Sha2MainCols, mem) + offsetof(Sha2MainMemoryCols, FIELD) +#define SHA2_MAIN_COL_INDEX_MEM_V(V, FIELD) \ + (SHA2_MAIN_COL_INDEX_V(V, Sha2MainCols, mem) + \ + SHA2_MAIN_COL_INDEX_V(V, Sha2MainMemoryCols, FIELD)) + +#define SHA2_MAIN_WRITE_BLOCK(V, ROW, FIELD, VALUE) \ + (ROW).write(SHA2_MAIN_COL_INDEX_BLOCK_V(V, FIELD), VALUE) +#define SHA2_MAIN_WRITE_ARRAY_BLOCK(V, ROW, FIELD, VALUES) \ + (ROW).write_array( \ + SHA2_MAIN_COL_INDEX_BLOCK_V(V, FIELD), \ + SHA2_MAIN_COL_ARRAY_LEN_V(V, Sha2MainBlockCols, FIELD), \ + VALUES \ + ) + +#define SHA2_MAIN_WRITE_INSTR(V, ROW, FIELD, VALUE) \ + (ROW).write(SHA2_MAIN_COL_INDEX_INSTR(V, FIELD), VALUE) +#define SHA2_MAIN_WRITE_ARRAY_INSTR(V, ROW, FIELD, VALUES) \ + (ROW).write_array( \ + SHA2_MAIN_COL_INDEX_INSTR(V, FIELD), \ + SHA2_MAIN_COL_ARRAY_LEN_PLAIN(Sha2MainInstructionCols, FIELD), \ + VALUES \ + ) + +#define SHA2_MAIN_SLICE_MEM(V, ROW, FIELD) \ + (ROW).slice_from(SHA2_MAIN_COL_INDEX_MEM_V(V, FIELD)) + +} // namespace sha2 diff --git a/extensions/sha2/circuit/cuda/include/main/record.cuh b/extensions/sha2/circuit/cuda/include/main/record.cuh new file mode 100644 index 0000000000..570946d8b5 --- /dev/null +++ b/extensions/sha2/circuit/cuda/include/main/record.cuh @@ -0,0 +1,70 @@ +#pragma once + +#include "block_hasher/variant.cuh" +#include "system/memory/offline_checker.cuh" +#include + +namespace sha2 { + +template struct Sha2RecordHeader { + uint32_t variant; + uint32_t from_pc; + uint32_t timestamp; + uint32_t dst_reg_ptr; + uint32_t state_reg_ptr; + uint32_t input_reg_ptr; + uint32_t dst_ptr; + uint32_t state_ptr; + uint32_t input_ptr; + MemoryReadAuxRecord register_reads_aux[sha2::SHA2_REGISTER_READS]; +}; + +template struct Sha2RecordMut { + Sha2RecordHeader *header; + uint8_t *message_bytes; + uint8_t *prev_state; + uint8_t *new_state; + MemoryReadAuxRecord *input_reads_aux; + MemoryReadAuxRecord *state_reads_aux; + MemoryWriteBytesAuxRecord *write_aux; + + __device__ __host__ __forceinline__ static uint32_t next_multiple_of( + uint32_t value, + uint32_t alignment + ) { + return ((value + alignment - 1) / alignment) * alignment; + } + + __device__ __host__ __forceinline__ Sha2RecordMut(uint8_t *record_buf) { + header = reinterpret_cast *>(record_buf); + uint32_t offset = sizeof(Sha2RecordHeader); + + message_bytes = record_buf + offset; + offset += V::BLOCK_U8S; + + prev_state = record_buf + offset; + offset += V::STATE_BYTES; + + new_state = record_buf + offset; + offset += V::STATE_BYTES; + + offset = next_multiple_of(offset, alignof(MemoryReadAuxRecord)); + + input_reads_aux = reinterpret_cast(record_buf + offset); + offset += V::BLOCK_READS * sizeof(MemoryReadAuxRecord); + + offset = next_multiple_of(offset, alignof(MemoryReadAuxRecord)); + + state_reads_aux = reinterpret_cast(record_buf + offset); + offset += V::STATE_READS * sizeof(MemoryReadAuxRecord); + + offset = next_multiple_of( + offset, alignof(MemoryWriteBytesAuxRecord) + ); + write_aux = reinterpret_cast *>( + record_buf + offset + ); + } +}; + +} // namespace sha2 diff --git a/extensions/sha2/circuit/cuda/include/variant.cuh b/extensions/sha2/circuit/cuda/include/variant.cuh new file mode 100644 index 0000000000..7f46878412 --- /dev/null +++ b/extensions/sha2/circuit/cuda/include/variant.cuh @@ -0,0 +1,6 @@ +#pragma once + +// Expose the shared SHA-2 variant definitions at the top-level include dir so both +// main/ and block_hasher/ headers can include "variant.cuh". +#include "block_hasher/variant.cuh" + diff --git a/extensions/sha2/circuit/cuda/src/sha2_hasher.cu b/extensions/sha2/circuit/cuda/src/sha2_hasher.cu new file mode 100644 index 0000000000..fb37585362 --- /dev/null +++ b/extensions/sha2/circuit/cuda/src/sha2_hasher.cu @@ -0,0 +1,1066 @@ +#define SHA2_DEFINE_DEVICE_CONSTANTS + +#include "block_hasher/columns.cuh" +#include "block_hasher/record.cuh" +#include "block_hasher/variant.cuh" +#include "fp.h" +#include "launcher.cuh" +#include "primitives/encoder.cuh" +#include "primitives/histogram.cuh" +#include "primitives/trace_access.h" +#include +#include +#include + +using namespace riscv; +using namespace sha2; + +// === Utility helpers for SHA-2 block hasher === +template +__device__ __forceinline__ typename V::Word word_from_bytes_be(const uint8_t *bytes) { + typename V::Word acc = 0; +#pragma unroll + for (int i = 0; i < static_cast(V::WORD_U8S); i++) { + acc = (acc << 8) | static_cast(bytes[i]); + } + return acc; +} + +template +__device__ __forceinline__ typename V::Word word_from_bytes_le(const uint8_t *bytes) { + typename V::Word acc = 0; +#pragma unroll + for (int i = static_cast(V::WORD_U8S) - 1; i >= 0; i--) { + acc = (acc << 8) | static_cast(bytes[i]); + } + return acc; +} + +template +__device__ __forceinline__ uint32_t word_to_u16_limb(typename V::Word w, int limb) { + return static_cast((w >> (16 * limb)) & static_cast(0xFFFF)); +} + +template +__device__ __forceinline__ uint32_t word_to_u8_limb(typename V::Word w, int limb) { + return static_cast((w >> (8 * limb)) & static_cast(0xFF)); +} + +// === Shared helpers mirroring the CPU tracegen structure === +template struct Sha2TraceHelper { + Encoder row_idx_encoder; + + __device__ Sha2TraceHelper() + : row_idx_encoder(static_cast(V::ROWS_PER_BLOCK + 1), 2, false) {} + + __device__ __forceinline__ size_t base_a(uint32_t row_idx) const { + return SHA2_COL_INDEX(V, Sha2RoundCols, work_vars.a[row_idx]); + } + + __device__ __forceinline__ size_t base_e(uint32_t row_idx) const { + return SHA2_COL_INDEX(V, Sha2RoundCols, work_vars.e[row_idx]); + } + + __device__ __forceinline__ size_t base_carry_a(uint32_t row_idx) const { + return SHA2_COL_INDEX(V, Sha2RoundCols, work_vars.carry_a[row_idx]); + } + + __device__ __forceinline__ size_t base_carry_e(uint32_t row_idx) const { + return SHA2_COL_INDEX(V, Sha2RoundCols, work_vars.carry_e[row_idx]); + } + + __device__ __forceinline__ void read_w(RowSlice inner, uint32_t j, Fp *w_limbs) const { + size_t base = SHA2_COL_INDEX(V, Sha2RoundCols, message_schedule.w[j]); + for (int limb = 0; limb < V::WORD_U16S; limb++) { + w_limbs[limb] = Fp::zero(); + for (int bit = 0; bit < 16; bit++) { + w_limbs[limb] += inner[base + bit] * Fp(1 << bit); + } + base += 16; + } + } + + __device__ __forceinline__ Fp read_carry_fp(RowSlice inner, uint32_t i, uint32_t limb) const { + size_t base = SHA2_COL_INDEX(V, Sha2RoundCols, message_schedule.carry_or_buffer[i]); + Fp low = inner[base + limb * 2]; + Fp high = inner[base + limb * 2 + 1]; + return low + high + high; // low + 2 * high + } + + __device__ __forceinline__ void read_word_bits( + RowSlice inner, + size_t base, + Fp *dst_bits + ) const { +#pragma unroll + for (uint32_t bit = 0; bit < V::WORD_BITS; bit++) { + dst_bits[bit] = inner[base + bit]; + } + } + + __device__ __forceinline__ void read_w_bits(RowSlice inner, uint32_t j, Fp *dst_bits) const { + read_word_bits(inner, SHA2_COL_INDEX(V, Sha2RoundCols, message_schedule.w[j]), dst_bits); + } + + __device__ __forceinline__ Fp xor_fp(Fp a, Fp b) const { return a + b - Fp(2) * a * b; } + + __device__ __forceinline__ Fp xor_fp(Fp a, Fp b, Fp c) const { return xor_fp(xor_fp(a, b), c); } + + __device__ __forceinline__ Fp ch_fp(Fp x, Fp y, Fp z) const { return x * y + z - x * z; } + + __device__ __forceinline__ Fp maj_fp(Fp x, Fp y, Fp z) const { + return x * y + x * z + y * z - Fp(2) * x * y * z; + } + + __device__ __forceinline__ void rotr_bits(const Fp *src, uint32_t rot, Fp *dst) const { +#pragma unroll + for (uint32_t bit = 0; bit < V::WORD_BITS; bit++) { + dst[bit] = src[(bit + rot) % V::WORD_BITS]; + } + } + + __device__ __forceinline__ void shr_bits(const Fp *src, uint32_t shift, Fp *dst) const { +#pragma unroll + for (uint32_t bit = 0; bit < V::WORD_BITS; bit++) { + dst[bit] = (bit + shift < V::WORD_BITS) ? src[bit + shift] : Fp::zero(); + } + } + + __device__ __forceinline__ void big_sig0_bits(const Fp *src, Fp *dst) const { + if (V::WORD_BITS == 32) { + Fp r2[V::WORD_BITS], r13[V::WORD_BITS], r22[V::WORD_BITS]; + rotr_bits(src, 2, r2); + rotr_bits(src, 13, r13); + rotr_bits(src, 22, r22); +#pragma unroll + for (uint32_t bit = 0; bit < V::WORD_BITS; bit++) { + dst[bit] = xor_fp(r2[bit], r13[bit], r22[bit]); + } + } else { + Fp r28[V::WORD_BITS], r34[V::WORD_BITS], r39[V::WORD_BITS]; + rotr_bits(src, 28, r28); + rotr_bits(src, 34, r34); + rotr_bits(src, 39, r39); +#pragma unroll + for (uint32_t bit = 0; bit < V::WORD_BITS; bit++) { + dst[bit] = xor_fp(r28[bit], r34[bit], r39[bit]); + } + } + } + + __device__ __forceinline__ void big_sig1_bits(const Fp *src, Fp *dst) const { + if (V::WORD_BITS == 32) { + Fp r6[V::WORD_BITS], r11[V::WORD_BITS], r25[V::WORD_BITS]; + rotr_bits(src, 6, r6); + rotr_bits(src, 11, r11); + rotr_bits(src, 25, r25); +#pragma unroll + for (uint32_t bit = 0; bit < V::WORD_BITS; bit++) { + dst[bit] = xor_fp(r6[bit], r11[bit], r25[bit]); + } + } else { + Fp r14[V::WORD_BITS], r18[V::WORD_BITS], r41[V::WORD_BITS]; + rotr_bits(src, 14, r14); + rotr_bits(src, 18, r18); + rotr_bits(src, 41, r41); +#pragma unroll + for (uint32_t bit = 0; bit < V::WORD_BITS; bit++) { + dst[bit] = xor_fp(r14[bit], r18[bit], r41[bit]); + } + } + } + + __device__ __forceinline__ void small_sig0_bits(const Fp *src, Fp *dst) const { + if (V::WORD_BITS == 32) { + Fp r7[V::WORD_BITS], r18[V::WORD_BITS], s3[V::WORD_BITS]; + rotr_bits(src, 7, r7); + rotr_bits(src, 18, r18); + shr_bits(src, 3, s3); +#pragma unroll + for (uint32_t bit = 0; bit < V::WORD_BITS; bit++) { + dst[bit] = xor_fp(r7[bit], r18[bit], s3[bit]); + } + } else { + Fp r1[V::WORD_BITS], r8[V::WORD_BITS], s7[V::WORD_BITS]; + rotr_bits(src, 1, r1); + rotr_bits(src, 8, r8); + shr_bits(src, 7, s7); +#pragma unroll + for (uint32_t bit = 0; bit < V::WORD_BITS; bit++) { + dst[bit] = xor_fp(r1[bit], r8[bit], s7[bit]); + } + } + } + + __device__ __forceinline__ void small_sig1_bits(const Fp *src, Fp *dst) const { + if (V::WORD_BITS == 32) { + Fp r17[V::WORD_BITS], r19[V::WORD_BITS], s10[V::WORD_BITS]; + rotr_bits(src, 17, r17); + rotr_bits(src, 19, r19); + shr_bits(src, 10, s10); +#pragma unroll + for (uint32_t bit = 0; bit < V::WORD_BITS; bit++) { + dst[bit] = xor_fp(r17[bit], r19[bit], s10[bit]); + } + } else { + Fp r19[V::WORD_BITS], r61[V::WORD_BITS], s6[V::WORD_BITS]; + rotr_bits(src, 19, r19); + rotr_bits(src, 61, r61); + shr_bits(src, 6, s6); +#pragma unroll + for (uint32_t bit = 0; bit < V::WORD_BITS; bit++) { + dst[bit] = xor_fp(r19[bit], r61[bit], s6[bit]); + } + } + } + + __device__ __forceinline__ Fp compose_u16_limb(const Fp *bits, uint32_t limb) const { + Fp acc = Fp::zero(); +#pragma unroll + for (uint32_t bit = 0; bit < 16; bit++) { + acc += bits[limb * 16 + bit] * Fp(1u << bit); + } + return acc; + } + + __device__ void write_flags_round( + RowSlice inner_row, + uint32_t row_idx, + uint32_t global_block_idx + ) const { + SHA2INNER_WRITE_ROUND(V, inner_row, flags.is_round_row, Fp::one()); + SHA2INNER_WRITE_ROUND( + V, + inner_row, + flags.is_first_4_rows, + (row_idx < static_cast(V::MESSAGE_ROWS)) ? Fp::one() : Fp::zero() + ); + SHA2INNER_WRITE_ROUND(V, inner_row, flags.is_digest_row, Fp::zero()); + RowSlice row_idx_flags = + inner_row.slice_from(SHA2_COL_INDEX(V, Sha2RoundCols, flags.row_idx)); + row_idx_encoder.write_flag_pt(row_idx_flags, row_idx); + SHA2INNER_WRITE_ROUND(V, inner_row, flags.global_block_idx, Fp(global_block_idx)); + } + + __device__ void write_flags_digest( + RowSlice inner_row, + uint32_t row_idx, + uint32_t global_block_idx + ) const { + SHA2INNER_WRITE_DIGEST(V, inner_row, flags.is_round_row, Fp::zero()); + SHA2INNER_WRITE_DIGEST(V, inner_row, flags.is_first_4_rows, Fp::zero()); + SHA2INNER_WRITE_DIGEST(V, inner_row, flags.is_digest_row, Fp::one()); + RowSlice row_idx_flags = + inner_row.slice_from(SHA2_COL_INDEX(V, Sha2DigestCols, flags.row_idx)); + row_idx_encoder.write_flag_pt(row_idx_flags, row_idx); + SHA2INNER_WRITE_DIGEST(V, inner_row, flags.global_block_idx, Fp(global_block_idx)); + } + + __device__ void generate_carry_ae(RowSlice local_inner, RowSlice next_inner) const { + Fp a_bits[2 * V::ROUNDS_PER_ROW][V::WORD_BITS]; + Fp e_bits[2 * V::ROUNDS_PER_ROW][V::WORD_BITS]; +#pragma unroll + for (uint32_t i = 0; i < V::ROUNDS_PER_ROW; i++) { + read_word_bits(local_inner, base_a(i), a_bits[i]); + read_word_bits(next_inner, base_a(i), a_bits[i + V::ROUNDS_PER_ROW]); + read_word_bits(local_inner, base_e(i), e_bits[i]); + read_word_bits(next_inner, base_e(i), e_bits[i + V::ROUNDS_PER_ROW]); + } + + const Fp pow16_inv = inv(Fp(1u << 16)); + + for (uint32_t i = 0; i < V::ROUNDS_PER_ROW; i++) { + Fp sig_a[V::WORD_BITS]; + Fp sig_e[V::WORD_BITS]; + Fp maj_abc[V::WORD_BITS]; + Fp ch_efg[V::WORD_BITS]; + + big_sig0_bits(a_bits[i + 3], sig_a); + big_sig1_bits(e_bits[i + 3], sig_e); + for (uint32_t bit = 0; bit < V::WORD_BITS; bit++) { + maj_abc[bit] = maj_fp(a_bits[i + 3][bit], a_bits[i + 2][bit], a_bits[i + 1][bit]); + ch_efg[bit] = ch_fp(e_bits[i + 3][bit], e_bits[i + 2][bit], e_bits[i + 1][bit]); + } + + Fp prev_carry_a = Fp::zero(); + Fp prev_carry_e = Fp::zero(); + for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { + Fp t1_sum = compose_u16_limb(e_bits[i], limb) + compose_u16_limb(sig_e, limb) + + compose_u16_limb(ch_efg, limb); + Fp t2_sum = compose_u16_limb(sig_a, limb) + compose_u16_limb(maj_abc, limb); + Fp d_limb = compose_u16_limb(a_bits[i], limb); + Fp cur_a_limb = compose_u16_limb(a_bits[i + 4], limb); + Fp cur_e_limb = compose_u16_limb(e_bits[i + 4], limb); + + Fp e_sum = d_limb + t1_sum + + (limb == 0 ? Fp::zero() : next_inner[base_carry_e(i) + limb - 1]); + Fp a_sum = t1_sum + t2_sum + + (limb == 0 ? Fp::zero() : next_inner[base_carry_a(i) + limb - 1]); + Fp carry_e = (e_sum - cur_e_limb) * pow16_inv; + Fp carry_a = (a_sum - cur_a_limb) * pow16_inv; + + SHA2INNER_WRITE_ROUND(V, next_inner, work_vars.carry_e[i][limb], Fp(carry_e)); + SHA2INNER_WRITE_ROUND(V, next_inner, work_vars.carry_a[i][limb], Fp(carry_a)); + + prev_carry_e = carry_e; + prev_carry_a = carry_a; + } + } + } + + __device__ void generate_intermed_4(RowSlice local_inner, RowSlice next_inner) const { + Fp w_bits[2 * V::ROUNDS_PER_ROW][V::WORD_BITS]; + Fp w_limbs[2 * V::ROUNDS_PER_ROW][V::WORD_U16S]; +#pragma unroll + for (uint32_t j = 0; j < V::ROUNDS_PER_ROW; j++) { + read_w_bits(local_inner, j, w_bits[j]); + read_w_bits(next_inner, j, w_bits[j + V::ROUNDS_PER_ROW]); + for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { + w_limbs[j][limb] = compose_u16_limb(w_bits[j], limb); + w_limbs[j + V::ROUNDS_PER_ROW][limb] = + compose_u16_limb(w_bits[j + V::ROUNDS_PER_ROW], limb); + } + } + + for (uint32_t i = 0; i < V::ROUNDS_PER_ROW; i++) { + Fp sig_bits[V::WORD_BITS]; + Fp sig_limbs[V::WORD_U16S]; + + small_sig0_bits(w_bits[i + 1], sig_bits); + for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { + sig_limbs[limb] = compose_u16_limb(sig_bits, limb); + } +#pragma unroll + for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { + Fp val = w_limbs[i][limb] + sig_limbs[limb]; + SHA2INNER_WRITE_ROUND(V, next_inner, schedule_helper.intermed_4[i][limb], val); + } + } + } + + __device__ void generate_intermed_12(RowSlice local_inner, RowSlice next_inner) const { + Fp w_bits[2 * V::ROUNDS_PER_ROW][V::WORD_BITS]; + Fp w_limbs[2 * V::ROUNDS_PER_ROW][V::WORD_U16S]; +#pragma unroll + for (uint32_t j = 0; j < V::ROUNDS_PER_ROW; j++) { + read_w_bits(local_inner, j, w_bits[j]); + read_w_bits(next_inner, j, w_bits[j + V::ROUNDS_PER_ROW]); + for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { + w_limbs[j][limb] = compose_u16_limb(w_bits[j], limb); + w_limbs[j + V::ROUNDS_PER_ROW][limb] = + compose_u16_limb(w_bits[j + V::ROUNDS_PER_ROW], limb); + } + } + + for (uint32_t i = 0; i < V::ROUNDS_PER_ROW; i++) { + Fp sig_bits[V::WORD_BITS]; + Fp sig_limbs[V::WORD_U16S]; + + small_sig1_bits(w_bits[i + 2], sig_bits); + for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { + sig_limbs[limb] = compose_u16_limb(sig_bits, limb); + } + for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { + Fp carry = read_carry_fp(next_inner, i, limb); + Fp prev_carry = (limb > 0) ? read_carry_fp(next_inner, i, limb - 1) : Fp::zero(); + Fp w7_limb = (i < 3) + ? local_inner[SHA2_COL_INDEX( + V, Sha2RoundCols, schedule_helper.w_3[i][limb] + )] + : w_limbs[i - 3][limb]; + Fp w_cur = w_limbs[i + 4][limb]; + Fp sum = sig_limbs[limb] + w7_limb - carry * Fp(1u << 16) - w_cur + prev_carry; + Fp intermed = -sum; + SHA2INNER_WRITE_ROUND( + V, local_inner, schedule_helper.intermed_12[i][limb], intermed + ); + } + } + } + + __device__ void generate_default_row( + RowSlice inner_row, + const typename V::Word *first_block_prev_hash, + Fp *carry_a, + Fp *carry_e, + size_t trace_height + ) const { + RowSlice row_idx_flags = + inner_row.slice_from(SHA2_COL_INDEX(V, Sha2RoundCols, flags.row_idx)); + row_idx_encoder.write_flag_pt(row_idx_flags, V::ROWS_PER_BLOCK); + + for (uint32_t i = 0; i < V::ROUNDS_PER_ROW; i++) { + uint32_t a_idx = V::ROUNDS_PER_ROW - i - 1; + uint32_t e_idx = V::ROUNDS_PER_ROW - i + 3; + SHA2INNER_WRITE_BITS_ROUND(V, inner_row, work_vars.a[i], first_block_prev_hash[a_idx]); + SHA2INNER_WRITE_BITS_ROUND(V, inner_row, work_vars.e[i], first_block_prev_hash[e_idx]); + } + + if (carry_a && carry_e) { + for (uint32_t i = 0; i < V::ROUNDS_PER_ROW; i++) { + for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { + SHA2INNER_WRITE_ROUND( + V, + inner_row, + work_vars.carry_a[i][limb], + carry_a[(i * V::WORD_U16S + limb) * trace_height] + ); + SHA2INNER_WRITE_ROUND( + V, + inner_row, + work_vars.carry_e[i][limb], + carry_e[(i * V::WORD_U16S + limb) * trace_height] + ); + } + } + } + } + + __device__ void generate_missing_cells( + Fp *trace, + size_t trace_height, + uint32_t block_idx + ) const { + trace += 1; // skip the first row of the trace + uint32_t block_row_base = block_idx * V::ROWS_PER_BLOCK; + uint32_t last_round_row = block_row_base + (V::ROUND_ROWS - 2); + uint32_t digest_row = block_row_base + (V::ROUND_ROWS - 1); + uint32_t next_block_row_base = block_row_base + V::ROUND_ROWS; + + if (last_round_row >= trace_height || digest_row >= trace_height || + next_block_row_base >= trace_height) { + return; + } + + RowSlice last_round_row_slice(trace + last_round_row, trace_height); + RowSlice last_round_inner = + last_round_row_slice.slice_from(Sha2Layout::INNER_COLUMN_OFFSET); + RowSlice digest_row_slice(trace + digest_row, trace_height); + RowSlice digest_inner = digest_row_slice.slice_from(Sha2Layout::INNER_COLUMN_OFFSET); + RowSlice next_row_slice(trace + next_block_row_base, trace_height); + RowSlice next_inner = next_row_slice.slice_from(Sha2Layout::INNER_COLUMN_OFFSET); + + generate_intermed_12(last_round_inner, digest_inner); + generate_intermed_12(digest_inner, next_inner); + generate_intermed_4(digest_inner, next_inner); + } +}; + +// ===== BLOCK HASHER KERNELS ===== +template +__global__ void sha2_hash_computation( + uint8_t *records, + size_t num_records, + size_t *record_offsets, + typename V::Word *prev_hashes, + uint32_t total_num_blocks +) { + uint32_t block_idx = blockIdx.x * blockDim.x + threadIdx.x; + if (block_idx >= total_num_blocks) { + return; + } + + if (block_idx >= num_records) { + return; + } + + uint32_t offset = record_offsets[block_idx]; + Sha2BlockRecordMut record(records + offset); +#pragma unroll + for (int i = 0; i < static_cast(V::HASH_WORDS); i++) { + const uint8_t *ptr = record.prev_state + i * V::WORD_U8S; + prev_hashes[block_idx * V::HASH_WORDS + i] = word_from_bytes_le(ptr); + } +} + +template +__global__ void sha2_first_pass_tracegen( + Fp *trace, + size_t trace_height, + uint8_t *records, + size_t num_records, + size_t *record_offsets, + uint32_t total_num_blocks, + typename V::Word *prev_hashes, + uint32_t /*ptr_max_bits*/, + uint32_t * /*range_checker_ptr*/, + uint32_t /*range_checker_num_bins*/, + uint32_t *bitwise_lookup_ptr, + uint32_t bitwise_num_bits, + uint32_t /*timestamp_max_bits*/ +) { + uint32_t global_block_idx = blockIdx.x * blockDim.x + threadIdx.x; + if (global_block_idx >= total_num_blocks) { + return; + } + + uint32_t record_idx = global_block_idx; + if (record_idx >= num_records) { + return; + } + + uint32_t trace_start_row = global_block_idx * V::ROWS_PER_BLOCK; + if (trace_start_row + V::ROWS_PER_BLOCK > trace_height) { + return; + } + + Sha2TraceHelper helper; + Sha2BlockRecordMut record(records + record_offsets[record_idx]); + const typename V::Word *prev_hash = prev_hashes + global_block_idx * V::HASH_WORDS; + const typename V::Word *next_block_prev_hash = + prev_hashes + ((global_block_idx + 1) % total_num_blocks) * V::HASH_WORDS; + + BitwiseOperationLookup bitwise_lookup(bitwise_lookup_ptr, bitwise_num_bits); + + typename V::Word w_schedule[V::ROUNDS_PER_BLOCK] = {}; +#pragma unroll + for (int i = 0; i < static_cast(V::BLOCK_WORDS); i++) { + w_schedule[i] = word_from_bytes_be(record.message_bytes + i * V::WORD_U8S); + } + + typename V::Word a = prev_hash[0]; + typename V::Word b = prev_hash[1]; + typename V::Word c = prev_hash[2]; + typename V::Word d = prev_hash[3]; + typename V::Word e = prev_hash[4]; + typename V::Word f = prev_hash[5]; + typename V::Word g = prev_hash[6]; + typename V::Word h = prev_hash[7]; + + for (uint32_t row_in_block = 0; row_in_block < V::ROWS_PER_BLOCK; row_in_block++) { + uint32_t absolute_row = trace_start_row + row_in_block; + if (absolute_row >= trace_height) { + return; + } + + RowSlice row(trace + absolute_row, trace_height); + row.fill_zero(0, Sha2Layout::WIDTH); + + if (row_in_block < V::ROUND_ROWS) { + SHA2_WRITE_ROUND(V, row, request_id, Fp(record_idx)); + RowSlice inner_row = row.slice_from(Sha2Layout::INNER_COLUMN_OFFSET); + helper.write_flags_round(inner_row, row_in_block, global_block_idx + 1); + + for (uint32_t j = 0; j < V::ROUNDS_PER_ROW; j++) { + uint32_t t = row_in_block * V::ROUNDS_PER_ROW + j; + typename V::Word w_val; + if (t < V::BLOCK_WORDS) { + w_val = w_schedule[t]; + } else { + typename V::Word nums[4] = { + sha2::small_sig1(w_schedule[t - 2]), + w_schedule[t - 7], + sha2::small_sig0(w_schedule[t - 15]), + w_schedule[t - 16], + }; + w_val = nums[0] + nums[1] + nums[2] + nums[3]; + w_schedule[t] = w_val; + +#pragma unroll + for (int limb = 0; limb < static_cast(V::WORD_U16S); limb++) { + uint32_t sum = 0; +#pragma unroll + for (auto num : nums) { + sum += word_to_u16_limb(num, limb); + } + if (limb > 0) { + size_t carry_base = SHA2_COL_INDEX( + V, Sha2RoundCols, message_schedule.carry_or_buffer[j] + ); + sum += inner_row[carry_base + limb * 2 - 2].asUInt32() + + (inner_row[carry_base + limb * 2 - 1].asUInt32() << 1); + } + uint32_t carry = (sum - word_to_u16_limb(w_val, limb)) >> 16; + SHA2INNER_WRITE_ROUND( + V, + inner_row, + message_schedule.carry_or_buffer[j][limb * 2], + Fp(carry & 1) + ); + SHA2INNER_WRITE_ROUND( + V, + inner_row, + message_schedule.carry_or_buffer[j][limb * 2 + 1], + Fp((carry >> 1) & 1) + ); + } + } + + SHA2_WRITE_BITS(V, inner_row, Sha2RoundCols, message_schedule.w[j], w_val); + + typename V::Word t1 = + h + sha2::big_sig1(e) + sha2::ch(e, f, g) + V::K(t) + w_val; + typename V::Word t2 = sha2::big_sig0(a) + sha2::maj(a, b, c); + + typename V::Word new_e = d + t1; + typename V::Word new_a = t1 + t2; + + SHA2_WRITE_BITS(V, inner_row, Sha2RoundCols, work_vars.e[j], new_e); + SHA2_WRITE_BITS(V, inner_row, Sha2RoundCols, work_vars.a[j], new_a); + +#pragma unroll + for (int limb = 0; limb < static_cast(V::WORD_U16S); limb++) { + uint32_t t1_limb = word_to_u16_limb(h, limb) + + word_to_u16_limb(sha2::big_sig1(e), limb) + + word_to_u16_limb(sha2::ch(e, f, g), limb) + + word_to_u16_limb(V::K(t), limb) + + word_to_u16_limb(w_val, limb); + uint32_t t2_limb = word_to_u16_limb(sha2::big_sig0(a), limb) + + word_to_u16_limb(sha2::maj(a, b, c), limb); + + uint32_t prev_carry_e = + (limb > 0) ? inner_row[SHA2_COL_INDEX( + V, Sha2RoundCols, work_vars.carry_e[j][limb - 1] + )] + .asUInt32() + : 0; + uint32_t prev_carry_a = + (limb > 0) ? inner_row[SHA2_COL_INDEX( + V, Sha2RoundCols, work_vars.carry_a[j][limb - 1] + )] + .asUInt32() + : 0; + uint32_t e_sum = t1_limb + word_to_u16_limb(d, limb) + prev_carry_e; + uint32_t a_sum = t1_limb + t2_limb + prev_carry_a; + uint32_t c_e = (e_sum - word_to_u16_limb(new_e, limb)) >> 16; + uint32_t c_a = (a_sum - word_to_u16_limb(new_a, limb)) >> 16; + SHA2INNER_WRITE_ROUND(V, inner_row, work_vars.carry_e[j][limb], Fp(c_e)); + SHA2INNER_WRITE_ROUND(V, inner_row, work_vars.carry_a[j][limb], Fp(c_a)); + bitwise_lookup.add_range(c_a, c_e); + } + + if (row_in_block > 0) { + typename V::Word w_4 = w_schedule[t - 4]; + typename V::Word sig0_w3 = sha2::small_sig0(w_schedule[t - 3]); +#pragma unroll + for (int limb = 0; limb < static_cast(V::WORD_U16S); limb++) { + uint32_t val = + word_to_u16_limb(w_4, limb) + word_to_u16_limb(sig0_w3, limb); + SHA2INNER_WRITE_ROUND( + V, inner_row, schedule_helper.intermed_4[j][limb], Fp(val) + ); + } + if (j < V::ROUNDS_PER_ROW - 1) { + typename V::Word w3 = w_schedule[t - 3]; +#pragma unroll + for (int limb = 0; limb < static_cast(V::WORD_U16S); limb++) { + SHA2INNER_WRITE_ROUND( + V, + inner_row, + schedule_helper.w_3[j][limb], + Fp(word_to_u16_limb(w3, limb)) + ); + } + } + } + + h = g; + g = f; + f = e; + e = new_e; + d = c; + c = b; + b = a; + a = new_a; + } + } else { + uint32_t digest_row_idx = V::ROUND_ROWS; + SHA2_WRITE_DIGEST(V, row, request_id, Fp(record_idx)); + + RowSlice inner_row = row.slice_from(Sha2Layout::INNER_COLUMN_OFFSET); + helper.write_flags_digest(inner_row, digest_row_idx, global_block_idx + 1); + + for (uint32_t j = 0; j < V::ROUNDS_PER_ROW - 1; j++) { + typename V::Word val = w_schedule[row_in_block * V::ROUNDS_PER_ROW + j - 3]; + for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { + SHA2INNER_WRITE_DIGEST( + V, + inner_row, + schedule_helper.w_3[j][limb], + Fp(word_to_u16_limb(val, limb)) + ); + } + } + + typename V::Word final_hash[V::HASH_WORDS]; + for (int i = 0; i < static_cast(V::HASH_WORDS); i++) { + typename V::Word work_val = + (i == 0) + ? a + : (i == 1 + ? b + : (i == 2 + ? c + : (i == 3 ? d + : (i == 4 ? e : (i == 5 ? f : (i == 6 ? g : h)))))); + final_hash[i] = prev_hash[i] + work_val; + for (uint32_t limb = 0; limb < V::WORD_U8S; limb++) { + SHA2INNER_WRITE_DIGEST( + V, + inner_row, + final_hash[i][limb], + Fp(word_to_u8_limb(final_hash[i], limb)) + ); + } + for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { + SHA2INNER_WRITE_DIGEST( + V, + inner_row, + prev_hash[i][limb], + Fp(word_to_u16_limb(prev_hash[i], limb)) + ); + } + + for (uint32_t limb = 0; limb < V::WORD_U8S; limb += 2) { + uint32_t b0 = word_to_u8_limb(final_hash[i], limb); + uint32_t b1 = word_to_u8_limb(final_hash[i], limb + 1); + bitwise_lookup.add_range(b0, b1); + } + } + + for (uint32_t i = 0; i < V::ROUNDS_PER_ROW; i++) { + uint32_t a_idx = V::ROUNDS_PER_ROW - i - 1; + uint32_t e_idx = V::ROUNDS_PER_ROW - i + 3; + SHA2_WRITE_BITS( + V, inner_row, Sha2DigestCols, hash.a[i], next_block_prev_hash[a_idx] + ); + SHA2_WRITE_BITS( + V, inner_row, Sha2DigestCols, hash.e[i], next_block_prev_hash[e_idx] + ); + } + } + } + + for (uint32_t row_in_block = 0; row_in_block < V::ROWS_PER_BLOCK - 1; row_in_block++) { + uint32_t absolute_row = trace_start_row + row_in_block; + RowSlice local_row(trace + absolute_row, trace_height); + RowSlice next_row(trace + absolute_row + 1, trace_height); + RowSlice local_inner = local_row.slice_from(Sha2Layout::INNER_COLUMN_OFFSET); + RowSlice next_inner = next_row.slice_from(Sha2Layout::INNER_COLUMN_OFFSET); + + if (row_in_block > 0) { + for (uint32_t j = 0; j < V::ROUNDS_PER_ROW; j++) { + for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { + Fp intermed_4_val = local_inner[SHA2_COL_INDEX( + V, Sha2RoundCols, schedule_helper.intermed_4[j][limb] + )]; + if (row_in_block + 1 == V::ROWS_PER_BLOCK - 1) { + SHA2INNER_WRITE_DIGEST( + V, next_inner, schedule_helper.intermed_8[j][limb], intermed_4_val + ); + } else { + SHA2INNER_WRITE_ROUND( + V, next_inner, schedule_helper.intermed_8[j][limb], intermed_4_val + ); + } + + if (row_in_block >= 2 && row_in_block < V::ROWS_PER_BLOCK - 3) { + Fp intermed_8_val = local_inner[SHA2_COL_INDEX( + V, Sha2RoundCols, schedule_helper.intermed_8[j][limb] + )]; + SHA2INNER_WRITE_ROUND( + V, next_inner, schedule_helper.intermed_12[j][limb], intermed_8_val + ); + } + } + } + } + + if (row_in_block == V::ROWS_PER_BLOCK - 2) { + helper.generate_carry_ae(local_inner, next_inner); + helper.generate_intermed_4(local_inner, next_inner); + } + + if (row_in_block < V::MESSAGE_ROWS - 1) { + helper.generate_intermed_12(local_inner, next_inner); + } + } +} + +template +__global__ void sha2_fill_first_dummy_row(Fp *trace, size_t trace_height, size_t rows_used) { + uint32_t row_idx = rows_used; + + uint32_t digest_row = V::ROUND_ROWS; + if (digest_row >= trace_height) { + return; + } + + RowSlice digest(trace + digest_row, trace_height); + RowSlice digest_inner = digest.slice_from(Sha2Layout::INNER_COLUMN_OFFSET); + + typename V::Word prev_hash[V::HASH_WORDS]; + for (uint32_t i = 0; i < V::HASH_WORDS; i++) { + typename V::Word acc = 0; + for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { + size_t base = SHA2_COL_INDEX(V, Sha2DigestCols, prev_hash[i][limb]); + uint32_t limb_val = digest_inner[base].asUInt32(); + acc |= static_cast(limb_val) << (16 * limb); + } + prev_hash[i] = acc; + } + + RowSlice row(trace + row_idx, trace_height); + uint32_t intermed_4_offset = + SHA2_COL_INDEX(V, Sha2BlockHasherRoundCols, inner.schedule_helper.intermed_4); + uint32_t intermed_8_offset = + SHA2_COL_INDEX(V, Sha2BlockHasherRoundCols, inner.schedule_helper.intermed_8); + row.fill_zero(0, intermed_4_offset); + row.fill_zero(intermed_8_offset, Sha2Layout::WIDTH - intermed_8_offset); + SHA2_WRITE_ROUND(V, row, request_id, Fp::zero()); + RowSlice inner_row = row.slice_from(Sha2Layout::INNER_COLUMN_OFFSET); + + Sha2TraceHelper helper; + helper.generate_default_row(inner_row, prev_hash, nullptr, nullptr, trace_height); + + helper.generate_carry_ae(inner_row, inner_row); +} + +template +__global__ void sha2_second_pass_dependencies(Fp *trace, size_t trace_height, size_t total_blocks) { + uint32_t block_idx = blockIdx.x * blockDim.x + threadIdx.x; + if (block_idx >= total_blocks) { + return; + } + + Sha2TraceHelper helper; + helper.generate_missing_cells(trace, trace_height, block_idx); +} + +template +__global__ void sha2_fill_invalid_rows( + Fp *d_trace, + size_t trace_height, + size_t rows_used, + typename V::Word *d_prev_hashes +) { + uint32_t thread_idx = blockIdx.x * blockDim.x + threadIdx.x; + uint32_t first_dummy_row_idx = rows_used; + // skip the first dummy row, since it is already filled + uint32_t row_idx = first_dummy_row_idx + thread_idx + 1; + if (row_idx >= trace_height) { + return; + } + + RowSlice first_dummy_row(d_trace + first_dummy_row_idx, trace_height); + RowSlice first_dummy_row_inner = first_dummy_row.slice_from(Sha2Layout::INNER_COLUMN_OFFSET); + + Fp *first_dummy_row_carry_a = + &first_dummy_row_inner[SHA2_COL_INDEX(V, Sha2RoundCols, work_vars.carry_a)]; + Fp *first_dummy_row_carry_e = + &first_dummy_row_inner[SHA2_COL_INDEX(V, Sha2RoundCols, work_vars.carry_e)]; + + RowSlice dst(d_trace + row_idx, trace_height); + dst.fill_zero(0, Sha2Layout::WIDTH); + RowSlice dst_inner = dst.slice_from(Sha2Layout::INNER_COLUMN_OFFSET); + + Sha2TraceHelper helper; + helper.generate_default_row( + dst_inner, &d_prev_hashes[0], first_dummy_row_carry_a, first_dummy_row_carry_e, trace_height + ); +} + +// ===== HOST LAUNCHER FUNCTIONS ===== + +template +int launch_sha2_hash_computation( + uint8_t *d_records, + size_t num_records, + size_t *d_record_offsets, + typename V::Word *d_prev_hashes, + uint32_t total_num_blocks +) { + auto [grid_size, block_size] = kernel_launch_params(num_records, 256); + + sha2_hash_computation<<>>( + d_records, num_records, d_record_offsets, d_prev_hashes, total_num_blocks + ); + + return CHECK_KERNEL(); +} + +template +int launch_sha2_first_pass_tracegen( + Fp *d_trace, + size_t trace_height, + uint8_t *d_records, + size_t num_records, + size_t *d_record_offsets, + uint32_t total_num_blocks, + typename V::Word *d_prev_hashes, + uint32_t ptr_max_bits, + uint32_t *d_range_checker, + uint32_t range_checker_num_bins, + uint32_t *d_bitwise_lookup, + uint32_t bitwise_num_bits, + uint32_t timestamp_max_bits +) { + auto [grid_size, block_size] = kernel_launch_params(total_num_blocks, 256); + + sha2_first_pass_tracegen<<>>( + d_trace, + trace_height, + d_records, + num_records, + d_record_offsets, + total_num_blocks, + d_prev_hashes, + ptr_max_bits, + d_range_checker, + range_checker_num_bins, + d_bitwise_lookup, + bitwise_num_bits, + timestamp_max_bits + ); + + return CHECK_KERNEL(); +} + +template +int launch_sha2_second_pass_dependencies(Fp *d_trace, size_t trace_height, size_t rows_used) { + size_t total_blocks = rows_used / V::ROWS_PER_BLOCK; + auto [grid_size, block_size] = kernel_launch_params(total_blocks, 256); + sha2_second_pass_dependencies + <<>>(d_trace, trace_height, total_blocks); + return CHECK_KERNEL(); +} + +template +int launch_sha2_fill_invalid_rows( + Fp *d_trace, + size_t trace_height, + size_t rows_used, + typename V::Word *d_prev_hashes +) { + sha2_fill_first_dummy_row<<<1, 1>>>(d_trace, trace_height, rows_used); + if (CHECK_KERNEL() != 0) { + return -1; + } + + auto [grid_size, block_size] = kernel_launch_params(trace_height - rows_used, 256); + sha2_fill_invalid_rows + <<>>(d_trace, trace_height, rows_used, d_prev_hashes); + return CHECK_KERNEL(); +} + +// Explicit instantiations for SHA-256 and SHA-512 +extern "C" { +int launch_sha256_hash_computation( + uint8_t *d_records, + size_t num_records, + size_t *d_record_offsets, + uint32_t *d_prev_hashes, + uint32_t total_num_blocks +) { + return launch_sha2_hash_computation( + d_records, + num_records, + d_record_offsets, + reinterpret_cast(d_prev_hashes), + total_num_blocks + ); +} + +int launch_sha512_hash_computation( + uint8_t *d_records, + size_t num_records, + size_t *d_record_offsets, + uint64_t *d_prev_hashes, + uint32_t total_num_blocks +) { + return launch_sha2_hash_computation( + d_records, num_records, d_record_offsets, d_prev_hashes, total_num_blocks + ); +} + +int launch_sha256_first_pass_tracegen( + Fp *d_trace, + size_t trace_height, + uint8_t *d_records, + size_t num_records, + size_t *d_record_offsets, + uint32_t total_num_blocks, + uint32_t *d_prev_hashes, + uint32_t ptr_max_bits, + uint32_t *d_range_checker, + uint32_t range_checker_num_bins, + uint32_t *d_bitwise_lookup, + uint32_t bitwise_num_bits, + uint32_t timestamp_max_bits +) { + return launch_sha2_first_pass_tracegen( + d_trace, + trace_height, + d_records, + num_records, + d_record_offsets, + total_num_blocks, + d_prev_hashes, + ptr_max_bits, + d_range_checker, + range_checker_num_bins, + d_bitwise_lookup, + bitwise_num_bits, + timestamp_max_bits + ); +} + +int launch_sha512_first_pass_tracegen( + Fp *d_trace, + size_t trace_height, + uint8_t *d_records, + size_t num_records, + size_t *d_record_offsets, + uint32_t total_num_blocks, + uint64_t *d_prev_hashes, + uint32_t ptr_max_bits, + uint32_t *d_range_checker, + uint32_t range_checker_num_bins, + uint32_t *d_bitwise_lookup, + uint32_t bitwise_num_bits, + uint32_t timestamp_max_bits +) { + return launch_sha2_first_pass_tracegen( + d_trace, + trace_height, + d_records, + num_records, + d_record_offsets, + total_num_blocks, + d_prev_hashes, + ptr_max_bits, + d_range_checker, + range_checker_num_bins, + d_bitwise_lookup, + bitwise_num_bits, + timestamp_max_bits + ); +} + +int launch_sha256_second_pass_dependencies(Fp *d_trace, size_t trace_height, size_t rows_used) { + return launch_sha2_second_pass_dependencies(d_trace, trace_height, rows_used); +} +int launch_sha512_second_pass_dependencies(Fp *d_trace, size_t trace_height, size_t rows_used) { + return launch_sha2_second_pass_dependencies(d_trace, trace_height, rows_used); +} +int launch_sha256_fill_invalid_rows( + Fp *d_trace, + size_t trace_height, + size_t rows_used, + uint32_t *d_prev_hashes +) { + return launch_sha2_fill_invalid_rows( + d_trace, trace_height, rows_used, d_prev_hashes + ); +} +int launch_sha512_fill_invalid_rows( + Fp *d_trace, + size_t trace_height, + size_t rows_used, + uint64_t *d_prev_hashes +) { + return launch_sha2_fill_invalid_rows( + d_trace, trace_height, rows_used, d_prev_hashes + ); +} +} diff --git a/extensions/sha2/circuit/cuda/src/sha2_main.cu b/extensions/sha2/circuit/cuda/src/sha2_main.cu new file mode 100644 index 0000000000..dde74c5826 --- /dev/null +++ b/extensions/sha2/circuit/cuda/src/sha2_main.cu @@ -0,0 +1,219 @@ +#include "block_hasher/variant.cuh" +#include "fp.h" +#include "launcher.cuh" +#include "main/columns.cuh" +#include "main/record.cuh" +#include "primitives/constants.h" +#include "primitives/histogram.cuh" +#include "primitives/trace_access.h" +#include "system/memory/controller.cuh" +#include "system/memory/offline_checker.cuh" +#include +#include +#include + +using namespace riscv; +using namespace sha2; + +// ===== MAIN CHIP KERNEL ===== +template +__global__ void sha2_main_tracegen( + Fp *trace, + size_t trace_height, + uint8_t *records, + size_t num_records, + size_t *record_offsets, + uint32_t ptr_max_bits, + uint32_t *range_checker_ptr, + uint32_t range_checker_num_bins, + uint32_t *bitwise_lookup_ptr, + uint32_t bitwise_num_bits, + uint32_t timestamp_max_bits +) { + uint32_t row_idx = blockIdx.x * blockDim.x + threadIdx.x; + if (row_idx >= trace_height) { + return; + } + + RowSlice row(trace + row_idx, trace_height); + row.fill_zero(0, sha2::Sha2MainLayout::WIDTH); + + if (row_idx >= num_records) { + return; + } + + Sha2RecordMut record(records + record_offsets[row_idx]); + Sha2RecordHeader *header = record.header; + + BitwiseOperationLookup bitwise_lookup(bitwise_lookup_ptr, bitwise_num_bits); + MemoryAuxColsFactory mem_helper( + VariableRangeChecker(range_checker_ptr, range_checker_num_bins), timestamp_max_bits + ); + + // Block cols + SHA2_MAIN_WRITE_BLOCK(V, row, request_id, Fp(row_idx)); + SHA2_MAIN_WRITE_ARRAY_BLOCK(V, row, message_bytes, record.message_bytes); + SHA2_MAIN_WRITE_ARRAY_BLOCK(V, row, prev_state, record.prev_state); + SHA2_MAIN_WRITE_ARRAY_BLOCK(V, row, new_state, record.new_state); + + // Instruction cols + SHA2_MAIN_WRITE_INSTR(V, row, is_enabled, Fp::one()); + SHA2_MAIN_WRITE_INSTR(V, row, from_state.timestamp, header->timestamp); + SHA2_MAIN_WRITE_INSTR(V, row, from_state.pc, header->from_pc); + SHA2_MAIN_WRITE_INSTR(V, row, dst_reg_ptr, header->dst_reg_ptr); + SHA2_MAIN_WRITE_INSTR(V, row, state_reg_ptr, header->state_reg_ptr); + SHA2_MAIN_WRITE_INSTR(V, row, input_reg_ptr, header->input_reg_ptr); + + uint8_t dst_ptr_bytes[RV32_REGISTER_NUM_LIMBS]; + uint8_t state_ptr_bytes[RV32_REGISTER_NUM_LIMBS]; + uint8_t input_ptr_bytes[RV32_REGISTER_NUM_LIMBS]; + memcpy(dst_ptr_bytes, &header->dst_ptr, sizeof(uint32_t)); + memcpy(state_ptr_bytes, &header->state_ptr, sizeof(uint32_t)); + memcpy(input_ptr_bytes, &header->input_ptr, sizeof(uint32_t)); + + SHA2_MAIN_WRITE_ARRAY_INSTR(V, row, dst_ptr_limbs, dst_ptr_bytes); + SHA2_MAIN_WRITE_ARRAY_INSTR(V, row, state_ptr_limbs, state_ptr_bytes); + SHA2_MAIN_WRITE_ARRAY_INSTR(V, row, input_ptr_limbs, input_ptr_bytes); + + // Range checks on top limbs + uint8_t needs_range_check[4] = { + dst_ptr_bytes[RV32_REGISTER_NUM_LIMBS - 1], + state_ptr_bytes[RV32_REGISTER_NUM_LIMBS - 1], + input_ptr_bytes[RV32_REGISTER_NUM_LIMBS - 1], + input_ptr_bytes[RV32_REGISTER_NUM_LIMBS - 1], + }; + uint32_t shift = 1u << (RV32_REGISTER_NUM_LIMBS * RV32_CELL_BITS - ptr_max_bits); + for (int i = 0; i < 4; i += 2) { + bitwise_lookup.add_range( + static_cast(needs_range_check[i]) * shift, + static_cast(needs_range_check[i + 1]) * shift + ); + } + + // Memory aux + uint32_t timestamp = header->timestamp; + for (int i = 0; i < static_cast(sha2::SHA2_REGISTER_READS); i++) { + RowSlice reg_aux = SHA2_MAIN_SLICE_MEM(V, row, register_aux[i]); + RowSlice base_slice = reg_aux.slice_from(COL_INDEX(MemoryReadAuxCols, base)); + mem_helper.fill(base_slice, header->register_reads_aux[i].prev_timestamp, timestamp); + timestamp += 1; + } + + for (int i = 0; i < static_cast(V::BLOCK_READS); i++) { + RowSlice input_aux = SHA2_MAIN_SLICE_MEM(V, row, input_reads[i]); + RowSlice base_slice = input_aux.slice_from(COL_INDEX(MemoryReadAuxCols, base)); + mem_helper.fill(base_slice, record.input_reads_aux[i].prev_timestamp, timestamp); + timestamp += 1; + } + + for (int i = 0; i < static_cast(V::STATE_READS); i++) { + RowSlice state_aux = SHA2_MAIN_SLICE_MEM(V, row, state_reads[i]); + RowSlice base_slice = state_aux.slice_from(COL_INDEX(MemoryReadAuxCols, base)); + mem_helper.fill(base_slice, record.state_reads_aux[i].prev_timestamp, timestamp); + timestamp += 1; + } + + for (int i = 0; i < static_cast(V::STATE_WRITES); i++) { + RowSlice write_aux = SHA2_MAIN_SLICE_MEM(V, row, write_aux[i]); + write_aux.write_array( + COL_INDEX(MemoryWriteAuxCols, prev_data), + sha2::SHA2_WRITE_SIZE, + record.write_aux[i].prev_data + ); + RowSlice base_slice = write_aux.slice_from(COL_INDEX(MemoryWriteAuxCols, base)); + mem_helper.fill(base_slice, record.write_aux[i].prev_timestamp, timestamp); + timestamp += 1; + } +} + +// ===== HOST LAUNCHER FUNCTIONS ===== + +template +int launch_sha2_main_tracegen( + Fp *d_trace, + size_t trace_height, + uint8_t *d_records, + size_t num_records, + size_t *d_record_offsets, + uint32_t ptr_max_bits, + uint32_t *d_range_checker, + uint32_t range_checker_num_bins, + uint32_t *d_bitwise_lookup, + uint32_t bitwise_num_bits, + uint32_t timestamp_max_bits +) { + auto [grid_size, block_size] = kernel_launch_params(trace_height, 256); + sha2_main_tracegen<<>>( + d_trace, + trace_height, + d_records, + num_records, + d_record_offsets, + ptr_max_bits, + d_range_checker, + range_checker_num_bins, + d_bitwise_lookup, + bitwise_num_bits, + timestamp_max_bits + ); + return CHECK_KERNEL(); +} + +// Explicit instantiations for SHA-256 and SHA-512 +extern "C" { +int launch_sha256_main_tracegen( + Fp *d_trace, + size_t trace_height, + uint8_t *d_records, + size_t num_records, + size_t *d_record_offsets, + uint32_t ptr_max_bits, + uint32_t *d_range_checker, + uint32_t range_checker_num_bins, + uint32_t *d_bitwise_lookup, + uint32_t bitwise_num_bits, + uint32_t timestamp_max_bits +) { + return launch_sha2_main_tracegen( + d_trace, + trace_height, + d_records, + num_records, + d_record_offsets, + ptr_max_bits, + d_range_checker, + range_checker_num_bins, + d_bitwise_lookup, + bitwise_num_bits, + timestamp_max_bits + ); +} + +int launch_sha512_main_tracegen( + Fp *d_trace, + size_t trace_height, + uint8_t *d_records, + size_t num_records, + size_t *d_record_offsets, + uint32_t ptr_max_bits, + uint32_t *d_range_checker, + uint32_t range_checker_num_bins, + uint32_t *d_bitwise_lookup, + uint32_t bitwise_num_bits, + uint32_t timestamp_max_bits +) { + return launch_sha2_main_tracegen( + d_trace, + trace_height, + d_records, + num_records, + d_record_offsets, + ptr_max_bits, + d_range_checker, + range_checker_num_bins, + d_bitwise_lookup, + bitwise_num_bits, + timestamp_max_bits + ); +} +} diff --git a/extensions/sha2/circuit/src/cuda/cuda_abi.rs b/extensions/sha2/circuit/src/cuda/cuda_abi.rs new file mode 100644 index 0000000000..a7ba91bc5e --- /dev/null +++ b/extensions/sha2/circuit/src/cuda/cuda_abi.rs @@ -0,0 +1,326 @@ +#![allow(clippy::missing_safety_doc)] + +use openvm_cuda_backend::prelude::F; +use openvm_cuda_common::{d_buffer::DeviceBuffer, error::CudaError}; + +pub mod sha256 { + use super::*; + + extern "C" { + fn launch_sha256_main_tracegen( + d_trace: *mut F, + trace_height: usize, + d_records: *const u8, + num_records: usize, + d_record_offsets: *const usize, + ptr_max_bits: u32, + d_range_checker: *mut u32, + range_checker_num_bins: u32, + d_bitwise_lookup: *mut u32, + bitwise_num_bits: u32, + timestamp_max_bits: u32, + ) -> i32; + + fn launch_sha256_hash_computation( + d_records: *const u8, + num_records: usize, + d_record_offsets: *const usize, + d_prev_hashes: *mut u32, + total_num_blocks: u32, + ) -> i32; + + fn launch_sha256_first_pass_tracegen( + d_trace: *mut F, + trace_height: usize, + d_records: *const u8, + num_records: usize, + d_record_offsets: *const usize, + total_num_blocks: u32, + d_prev_hashes: *const u32, + ptr_max_bits: u32, + d_range_checker: *mut u32, + range_checker_num_bins: u32, + d_bitwise_lookup: *mut u32, + bitwise_num_bits: u32, + timestamp_max_bits: u32, + ) -> i32; + + fn launch_sha256_second_pass_dependencies( + d_trace: *mut F, + trace_height: usize, + rows_used: usize, + ) -> i32; + + fn launch_sha256_fill_invalid_rows( + d_trace: *mut F, + trace_height: usize, + rows_used: usize, + d_prev_hashes: *const u32, + ) -> i32; + } + + #[allow(clippy::too_many_arguments)] + pub unsafe fn sha256_main_tracegen( + d_trace: &DeviceBuffer, + height: usize, + d_records: &DeviceBuffer, + num_records: usize, + d_record_offsets: &DeviceBuffer, + ptr_max_bits: u32, + d_range_checker: &DeviceBuffer, + d_bitwise_lookup: &DeviceBuffer, + bitwise_num_bits: u32, + timestamp_max_bits: u32, + ) -> Result<(), CudaError> { + let result = launch_sha256_main_tracegen( + d_trace.as_mut_ptr(), + height, + d_records.as_ptr(), + num_records, + d_record_offsets.as_ptr(), + ptr_max_bits, + d_range_checker.as_mut_ptr() as *mut u32, + d_range_checker.len() as u32, + d_bitwise_lookup.as_mut_ptr() as *mut u32, + bitwise_num_bits, + timestamp_max_bits, + ); + CudaError::from_result(result) + } + + pub unsafe fn sha256_hash_computation( + d_records: &DeviceBuffer, + num_records: usize, + d_record_offsets: &DeviceBuffer, + d_prev_hashes: &DeviceBuffer, + num_blocks: u32, + ) -> Result<(), CudaError> { + let result = launch_sha256_hash_computation( + d_records.as_ptr(), + num_records, + d_record_offsets.as_ptr(), + d_prev_hashes.as_mut_ptr(), + num_blocks, + ); + CudaError::from_result(result) + } + + #[allow(clippy::too_many_arguments)] + pub unsafe fn sha256_first_pass_tracegen( + d_trace: &DeviceBuffer, + height: usize, + d_records: &DeviceBuffer, + num_records: usize, + d_record_offsets: &DeviceBuffer, + total_num_blocks: u32, + d_prev_hashes: &DeviceBuffer, + ptr_max_bits: u32, + d_range_checker: &DeviceBuffer, + d_bitwise_lookup: &DeviceBuffer, + bitwise_num_bits: u32, + timestamp_max_bits: u32, + ) -> Result<(), CudaError> { + let result = launch_sha256_first_pass_tracegen( + d_trace.as_mut_ptr(), + height, + d_records.as_ptr(), + num_records, + d_record_offsets.as_ptr(), + total_num_blocks, + d_prev_hashes.as_ptr(), + ptr_max_bits, + d_range_checker.as_mut_ptr() as *mut u32, + d_range_checker.len() as u32, + d_bitwise_lookup.as_mut_ptr() as *mut u32, + bitwise_num_bits, + timestamp_max_bits, + ); + CudaError::from_result(result) + } + + pub unsafe fn sha256_second_pass_dependencies( + d_trace: &DeviceBuffer, + height: usize, + rows_used: usize, + ) -> Result<(), CudaError> { + let result = + launch_sha256_second_pass_dependencies(d_trace.as_mut_ptr(), height, rows_used); + CudaError::from_result(result) + } + + pub unsafe fn sha256_fill_invalid_rows( + d_trace: &DeviceBuffer, + height: usize, + rows_used: usize, + d_prev_hashes: &DeviceBuffer, + ) -> Result<(), CudaError> { + let result = launch_sha256_fill_invalid_rows( + d_trace.as_mut_ptr(), + height, + rows_used, + d_prev_hashes.as_ptr(), + ); + CudaError::from_result(result) + } +} + +pub mod sha512 { + use super::*; + + extern "C" { + fn launch_sha512_main_tracegen( + d_trace: *mut F, + trace_height: usize, + d_records: *const u8, + num_records: usize, + d_record_offsets: *const usize, + ptr_max_bits: u32, + d_range_checker: *mut u32, + range_checker_num_bins: u32, + d_bitwise_lookup: *mut u32, + bitwise_num_bits: u32, + timestamp_max_bits: u32, + ) -> i32; + + fn launch_sha512_hash_computation( + d_records: *const u8, + num_records: usize, + d_record_offsets: *const usize, + d_prev_hashes: *mut u64, + total_num_blocks: u32, + ) -> i32; + + fn launch_sha512_first_pass_tracegen( + d_trace: *mut F, + trace_height: usize, + d_records: *const u8, + num_records: usize, + d_record_offsets: *const usize, + total_num_blocks: u32, + d_prev_hashes: *const u64, + ptr_max_bits: u32, + d_range_checker: *mut u32, + range_checker_num_bins: u32, + d_bitwise_lookup: *mut u32, + bitwise_num_bits: u32, + timestamp_max_bits: u32, + ) -> i32; + + fn launch_sha512_second_pass_dependencies( + d_trace: *mut F, + trace_height: usize, + rows_used: usize, + ) -> i32; + + fn launch_sha512_fill_invalid_rows( + d_trace: *mut F, + trace_height: usize, + rows_used: usize, + d_prev_hashes: *const u64, + ) -> i32; + } + + #[allow(clippy::too_many_arguments)] + pub unsafe fn sha512_main_tracegen( + d_trace: &DeviceBuffer, + height: usize, + d_records: &DeviceBuffer, + num_records: usize, + d_record_offsets: &DeviceBuffer, + ptr_max_bits: u32, + d_range_checker: &DeviceBuffer, + d_bitwise_lookup: &DeviceBuffer, + bitwise_num_bits: u32, + timestamp_max_bits: u32, + ) -> Result<(), CudaError> { + let result = launch_sha512_main_tracegen( + d_trace.as_mut_ptr(), + height, + d_records.as_ptr(), + num_records, + d_record_offsets.as_ptr(), + ptr_max_bits, + d_range_checker.as_mut_ptr() as *mut u32, + d_range_checker.len() as u32, + d_bitwise_lookup.as_mut_ptr() as *mut u32, + bitwise_num_bits, + timestamp_max_bits, + ); + CudaError::from_result(result) + } + + pub unsafe fn sha512_hash_computation( + d_records: &DeviceBuffer, + num_records: usize, + d_record_offsets: &DeviceBuffer, + d_prev_hashes: &DeviceBuffer, + num_blocks: u32, + ) -> Result<(), CudaError> { + let result = launch_sha512_hash_computation( + d_records.as_ptr(), + num_records, + d_record_offsets.as_ptr(), + d_prev_hashes.as_mut_ptr(), + num_blocks, + ); + CudaError::from_result(result) + } + + #[allow(clippy::too_many_arguments)] + pub unsafe fn sha512_first_pass_tracegen( + d_trace: &DeviceBuffer, + height: usize, + d_records: &DeviceBuffer, + num_records: usize, + d_record_offsets: &DeviceBuffer, + total_num_blocks: u32, + d_prev_hashes: &DeviceBuffer, + ptr_max_bits: u32, + d_range_checker: &DeviceBuffer, + d_bitwise_lookup: &DeviceBuffer, + bitwise_num_bits: u32, + timestamp_max_bits: u32, + ) -> Result<(), CudaError> { + let result = launch_sha512_first_pass_tracegen( + d_trace.as_mut_ptr(), + height, + d_records.as_ptr(), + num_records, + d_record_offsets.as_ptr(), + total_num_blocks, + d_prev_hashes.as_ptr(), + ptr_max_bits, + d_range_checker.as_mut_ptr() as *mut u32, + d_range_checker.len() as u32, + d_bitwise_lookup.as_mut_ptr() as *mut u32, + bitwise_num_bits, + timestamp_max_bits, + ); + CudaError::from_result(result) + } + + pub unsafe fn sha512_second_pass_dependencies( + d_trace: &DeviceBuffer, + height: usize, + rows_used: usize, + ) -> Result<(), CudaError> { + let result = + launch_sha512_second_pass_dependencies(d_trace.as_mut_ptr(), height, rows_used); + CudaError::from_result(result) + } + + pub unsafe fn sha512_fill_invalid_rows( + d_trace: &DeviceBuffer, + height: usize, + rows_used: usize, + d_prev_hashes: &DeviceBuffer, + ) -> Result<(), CudaError> { + let result = launch_sha512_fill_invalid_rows( + d_trace.as_mut_ptr(), + height, + rows_used, + d_prev_hashes.as_ptr(), + ); + CudaError::from_result(result) + } +} diff --git a/extensions/sha2/circuit/src/cuda/mod.rs b/extensions/sha2/circuit/src/cuda/mod.rs new file mode 100644 index 0000000000..a8f5705ef2 --- /dev/null +++ b/extensions/sha2/circuit/src/cuda/mod.rs @@ -0,0 +1,289 @@ +use std::{ + marker::PhantomData, + sync::{Arc, Mutex}, +}; + +use openvm_circuit::{ + arch::{DenseRecordArena, RecordSeeker}, + utils::next_power_of_two_or_zero, +}; +use openvm_circuit_primitives::{ + bitwise_op_lookup::BitwiseOperationLookupChipGPU, var_range::VariableRangeCheckerChipGPU, +}; +use openvm_cuda_backend::{base::DeviceMatrix, prelude::F, GpuBackend}; +use openvm_cuda_common::{copy::MemCopyH2D, d_buffer::DeviceBuffer}; +use openvm_sha2_air::{Sha256Config, Sha2Variant, Sha512Config}; +use openvm_stark_backend::prover::AirProvingContext; + +use openvm_circuit_primitives::Chip; + +use crate::{Sha2Config, Sha2RecordLayout, Sha2RecordMut}; + +mod cuda_abi; + +pub struct Sha2SharedRecordsGpu { + d_records: DeviceBuffer, + d_record_offsets: DeviceBuffer, + num_records: usize, +} + +pub struct Sha2MainChipGpu { + records: Arc>>, + range_checker: Arc, + bitwise_lookup: Arc>, + pointer_max_bits: u32, + timestamp_max_bits: u32, + _marker: PhantomData, +} + +impl Sha2MainChipGpu { + pub fn new( + records: Arc>>, + range_checker: Arc, + bitwise_lookup: Arc>, + pointer_max_bits: u32, + timestamp_max_bits: u32, + ) -> Self { + Self { + records, + range_checker, + bitwise_lookup, + pointer_max_bits, + timestamp_max_bits, + _marker: PhantomData, + } + } +} + +impl Chip for Sha2MainChipGpu +where + C: Sha2Config, +{ + fn generate_proving_ctx(&self, mut arena: DenseRecordArena) -> AirProvingContext { + let records = arena.allocated_mut(); + if records.is_empty() { + return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); + } + + let mut record_offsets = Vec::::new(); + let mut offset = 0usize; + while offset < records.len() { + record_offsets.push(offset); + let _record = + RecordSeeker::::get_record_at( + &mut offset, + records, + ); + } + + let num_records = record_offsets.len(); + let trace_height = next_power_of_two_or_zero(num_records); + let trace = DeviceMatrix::::with_capacity(trace_height, C::MAIN_CHIP_WIDTH); + + let d_records = records.to_device().unwrap(); + let d_record_offsets = record_offsets.to_device().unwrap(); + + unsafe { + match C::VARIANT { + Sha2Variant::Sha256 => { + cuda_abi::sha256::sha256_main_tracegen( + trace.buffer(), + trace_height, + &d_records, + num_records, + &d_record_offsets, + self.pointer_max_bits, + &self.range_checker.count, + &self.bitwise_lookup.count, + 8, + self.timestamp_max_bits, + ) + .unwrap(); + } + Sha2Variant::Sha512 | Sha2Variant::Sha384 => { + cuda_abi::sha512::sha512_main_tracegen( + trace.buffer(), + trace_height, + &d_records, + num_records, + &d_record_offsets, + self.pointer_max_bits, + &self.range_checker.count, + &self.bitwise_lookup.count, + 8, + self.timestamp_max_bits, + ) + .unwrap(); + } + } + } + + // Pass the records to Sha2BlockHasherChip + *self.records.lock().unwrap() = Some(Sha2SharedRecordsGpu { + d_records, + d_record_offsets, + num_records, + }); + + AirProvingContext::simple_no_pis(trace) + } +} + +/// Generic hybrid GPU wrapper that reuses CPU block-hasher tracegen. +pub struct Sha2BlockHasherChipGpu { + records: Arc>>, + range_checker: Arc, + bitwise_lookup: Arc>, + pointer_max_bits: u32, + timestamp_max_bits: u32, + _marker: PhantomData, +} + +impl Chip for Sha2BlockHasherChipGpu +where + C: Sha2Config, +{ + /// We don't use the record arena associated with this chip. Instead, we will use the record + /// arena provided by the main chip, which will be passed to this chip after the main chip's + /// tracegen is done. + fn generate_proving_ctx(&self, _: R) -> AirProvingContext { + let mut records = self.records.lock().unwrap(); + if records.is_none() { + return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); + } + + let Sha2SharedRecordsGpu { + d_records, + d_record_offsets, + num_records, + } = records.take().unwrap(); + + if num_records == 0 { + return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); + } + + let rows_used = num_records * C::ROWS_PER_BLOCK; + let trace_height = next_power_of_two_or_zero(rows_used); + let trace = DeviceMatrix::::with_capacity(trace_height, C::BLOCK_HASHER_WIDTH); + + // one record per block, right now + let num_blocks: u32 = num_records as u32; + + // prev_hashes + unsafe { + match C::VARIANT { + Sha2Variant::Sha256 => { + let d_prev_hashes = + DeviceBuffer::::with_capacity(num_blocks as usize * C::HASH_WORDS); + cuda_abi::sha256::sha256_hash_computation( + &d_records, + num_records, + &d_record_offsets, + &d_prev_hashes, + num_blocks, + ) + .unwrap(); + + cuda_abi::sha256::sha256_first_pass_tracegen( + trace.buffer(), + trace_height, + &d_records, + num_records, + &d_record_offsets, + num_blocks, + &d_prev_hashes, + self.pointer_max_bits, + &self.range_checker.count, + &self.bitwise_lookup.count, + 8, + self.timestamp_max_bits, + ) + .unwrap(); + + cuda_abi::sha256::sha256_fill_invalid_rows( + trace.buffer(), + trace_height, + rows_used, + &d_prev_hashes, + ) + .unwrap(); + cuda_abi::sha256::sha256_second_pass_dependencies( + trace.buffer(), + trace_height, + rows_used, + ) + .unwrap(); + } + Sha2Variant::Sha512 | Sha2Variant::Sha384 => { + let d_prev_hashes = + DeviceBuffer::::with_capacity(num_blocks as usize * C::HASH_WORDS); + cuda_abi::sha512::sha512_hash_computation( + &d_records, + num_records, + &d_record_offsets, + &d_prev_hashes, + num_blocks, + ) + .unwrap(); + + cuda_abi::sha512::sha512_first_pass_tracegen( + trace.buffer(), + trace_height, + &d_records, + num_records, + &d_record_offsets, + num_blocks, + &d_prev_hashes, + self.pointer_max_bits, + &self.range_checker.count, + &self.bitwise_lookup.count, + 8, + self.timestamp_max_bits, + ) + .unwrap(); + + cuda_abi::sha512::sha512_fill_invalid_rows( + trace.buffer(), + trace_height, + rows_used, + &d_prev_hashes, + ) + .unwrap(); + cuda_abi::sha512::sha512_second_pass_dependencies( + trace.buffer(), + trace_height, + rows_used, + ) + .unwrap(); + } + } + } + + AirProvingContext::simple_no_pis(trace) + } +} + +impl Sha2BlockHasherChipGpu { + pub fn new( + records: Arc>>, + range_checker: Arc, + bitwise_lookup: Arc>, + pointer_max_bits: u32, + timestamp_max_bits: u32, + ) -> Self { + Self { + records, + range_checker, + bitwise_lookup, + pointer_max_bits, + timestamp_max_bits, + _marker: PhantomData, + } + } +} + +// Convenience aliases for the common SHA-2 variants. +pub type Sha256VmChipGpu = Sha2MainChipGpu; +pub type Sha256BlockHasherChipGpu = Sha2BlockHasherChipGpu; +pub type Sha512VmChipGpu = Sha2MainChipGpu; +pub type Sha512BlockHasherChipGpu = Sha2BlockHasherChipGpu; diff --git a/extensions/sha2/circuit/src/extension/cuda.rs b/extensions/sha2/circuit/src/extension/cuda.rs new file mode 100644 index 0000000000..1caaf22a13 --- /dev/null +++ b/extensions/sha2/circuit/src/extension/cuda.rs @@ -0,0 +1,117 @@ +use openvm_circuit::{ + arch::{ + AirInventory, ChipInventory, ChipInventoryError, DenseRecordArena, VmBuilder, + VmChipComplex, VmProverExtension, + }, + system::cuda::{ + extensions::{ + get_inventory_range_checker, get_or_create_bitwise_op_lookup, SystemGpuBuilder, + }, + SystemChipInventoryGPU, + }, +}; +use openvm_cuda_backend::{BabyBearPoseidon2GpuEngine as GpuBabyBearPoseidon2Engine, GpuBackend}; +use openvm_rv32im_circuit::Rv32ImGpuProverExt; +use openvm_sha2_air::{Sha256Config, Sha512Config}; +use openvm_stark_sdk::config::baby_bear_poseidon2::BabyBearPoseidon2Config; + +use super::*; +use crate::{ + cuda::{Sha2BlockHasherChipGpu, Sha2MainChipGpu}, + Sha2BlockHasherVmAir, Sha2MainAir, +}; + +pub struct Sha2GpuProverExt; + +impl VmProverExtension for Sha2GpuProverExt { + fn extend_prover( + &self, + _: &Sha2, + inventory: &mut ChipInventory, + ) -> Result<(), ChipInventoryError> { + let pointer_max_bits = inventory.airs().pointer_max_bits(); + let timestamp_max_bits = inventory.timestamp_max_bits(); + + let range_checker_gpu = get_inventory_range_checker(inventory); + let bitwise_gpu = get_or_create_bitwise_op_lookup(inventory)?; + + // SHA-256 + inventory.next_air::>()?; + let sha256_shared_records = Arc::new(Mutex::new(None)); + let sha256_block_gpu = Sha2BlockHasherChipGpu::::new( + sha256_shared_records.clone(), + range_checker_gpu.clone(), + bitwise_gpu.clone(), + pointer_max_bits as u32, + timestamp_max_bits as u32, + ); + inventory.add_periphery_chip(sha256_block_gpu); + + inventory.next_air::>()?; + let sha256_main_gpu = Sha2MainChipGpu::::new( + sha256_shared_records, + range_checker_gpu.clone(), + bitwise_gpu.clone(), + pointer_max_bits as u32, + timestamp_max_bits as u32, + ); + inventory.add_executor_chip(sha256_main_gpu); + + // SHA-512 (also covers SHA-384 constraints) + inventory.next_air::>()?; + let sha512_shared_records = Arc::new(Mutex::new(None)); + let sha512_block_gpu = Sha2BlockHasherChipGpu::::new( + sha512_shared_records.clone(), + range_checker_gpu.clone(), + bitwise_gpu.clone(), + pointer_max_bits as u32, + timestamp_max_bits as u32, + ); + inventory.add_periphery_chip(sha512_block_gpu); + + inventory.next_air::>()?; + let sha512_main_gpu = Sha2MainChipGpu::::new( + sha512_shared_records, + range_checker_gpu, + bitwise_gpu, + pointer_max_bits as u32, + timestamp_max_bits as u32, + ); + inventory.add_executor_chip(sha512_main_gpu); + + Ok(()) + } +} + +pub struct Sha2Rv32GpuBuilder; + +type E = GpuBabyBearPoseidon2Engine; + +impl VmBuilder for Sha2Rv32GpuBuilder { + type VmConfig = Sha2Rv32Config; + type SystemChipInventory = SystemChipInventoryGPU; + type RecordArena = DenseRecordArena; + + fn create_chip_complex( + &self, + config: &Sha2Rv32Config, + circuit: AirInventory<::SC>, + ) -> Result< + VmChipComplex< + ::SC, + Self::RecordArena, + ::PB, + Self::SystemChipInventory, + >, + ChipInventoryError, + > { + let mut chip_complex = + VmBuilder::::create_chip_complex(&SystemGpuBuilder, &config.system, circuit)?; + let inventory = &mut chip_complex.inventory; + VmProverExtension::::extend_prover(&Rv32ImGpuProverExt, &config.rv32i, inventory)?; + VmProverExtension::::extend_prover(&Rv32ImGpuProverExt, &config.rv32m, inventory)?; + VmProverExtension::::extend_prover(&Rv32ImGpuProverExt, &config.io, inventory)?; + VmProverExtension::::extend_prover(&Sha2GpuProverExt, &config.sha2, inventory)?; + Ok(chip_complex) + } +} diff --git a/extensions/sha2/circuit/src/extension/mod.rs b/extensions/sha2/circuit/src/extension/mod.rs new file mode 100644 index 0000000000..abab4cd3a8 --- /dev/null +++ b/extensions/sha2/circuit/src/extension/mod.rs @@ -0,0 +1,281 @@ +use std::{ + result::Result, + sync::{Arc, Mutex}, +}; + +use derive_more::derive::From; +use openvm_circuit::{ + arch::{ + AirInventory, AirInventoryError, ChipInventory, ChipInventoryError, + ExecutorInventoryBuilder, ExecutorInventoryError, InitFileGenerator, MatrixRecordArena, + RowMajorMatrixArena, SystemConfig, VmBuilder, VmChipComplex, VmCircuitExtension, + VmExecutionExtension, VmField, VmProverExtension, + }, + system::{memory::SharedMemoryHelper, SystemChipInventory, SystemCpuBuilder, SystemExecutor}, +}; +use openvm_circuit_derive::{AnyEnum, Executor, MeteredExecutor, PreflightExecutor, VmConfig}; +use openvm_circuit_primitives::bitwise_op_lookup::{ + BitwiseOperationLookupAir, BitwiseOperationLookupBus, BitwiseOperationLookupChip, + SharedBitwiseOperationLookupChip, +}; +use openvm_instructions::LocalOpcode; +use openvm_rv32im_circuit::{ + Rv32I, Rv32IExecutor, Rv32ImCpuProverExt, Rv32Io, Rv32IoExecutor, Rv32M, Rv32MExecutor, +}; +use openvm_sha2_air::{Sha256Config, Sha512Config}; +use openvm_sha2_transpiler::Rv32Sha2Opcode; +use openvm_stark_backend::{ + prover::{CpuBackend, CpuDevice}, + StarkEngine, StarkProtocolConfig, Val, +}; +use serde::{Deserialize, Serialize}; + +use crate::{Sha2BlockHasherChip, Sha2BlockHasherVmAir, Sha2MainAir, Sha2MainChip, Sha2VmExecutor}; + +cfg_if::cfg_if! { + if #[cfg(feature = "cuda")] { + mod cuda; + pub use self::cuda::*; + pub use self::cuda::Sha2GpuProverExt as Sha2ProverExt; + pub use self::cuda::Sha2Rv32GpuBuilder as Sha2Rv32Builder; + } else { + pub use self::Sha2CpuProverExt as Sha2ProverExt; + pub use self::Sha2Rv32CpuBuilder as Sha2Rv32Builder; + } +} + +#[derive(Clone, Debug, VmConfig, derive_new::new, Serialize, Deserialize)] +pub struct Sha2Rv32Config { + #[config(executor = "SystemExecutor")] + pub system: SystemConfig, + #[extension] + pub rv32i: Rv32I, + #[extension] + pub rv32m: Rv32M, + #[extension] + pub io: Rv32Io, + #[extension] + pub sha2: Sha2, +} + +impl Default for Sha2Rv32Config { + fn default() -> Self { + Self { + system: SystemConfig::default(), + rv32i: Rv32I, + rv32m: Rv32M::default(), + io: Rv32Io, + sha2: Sha2, + } + } +} + +// Default implementation uses no init file +impl InitFileGenerator for Sha2Rv32Config {} + +#[derive(Clone)] +pub struct Sha2Rv32CpuBuilder; + +impl VmBuilder for Sha2Rv32CpuBuilder +where + SC: StarkProtocolConfig, + E: StarkEngine, PD = CpuDevice>, + Val: VmField, + SC::EF: Ord, +{ + type VmConfig = Sha2Rv32Config; + type SystemChipInventory = SystemChipInventory; + type RecordArena = MatrixRecordArena>; + + fn create_chip_complex( + &self, + config: &Sha2Rv32Config, + circuit: AirInventory, + ) -> Result< + VmChipComplex, + ChipInventoryError, + > { + let mut chip_complex = + VmBuilder::::create_chip_complex(&SystemCpuBuilder, &config.system, circuit)?; + let inventory = &mut chip_complex.inventory; + VmProverExtension::::extend_prover(&Rv32ImCpuProverExt, &config.rv32i, inventory)?; + VmProverExtension::::extend_prover(&Rv32ImCpuProverExt, &config.rv32m, inventory)?; + VmProverExtension::::extend_prover(&Rv32ImCpuProverExt, &config.io, inventory)?; + VmProverExtension::::extend_prover(&Sha2CpuProverExt, &config.sha2, inventory)?; + Ok(chip_complex) + } +} + +// =================================== VM Extension Implementation ================================= +#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)] +pub struct Sha2; + +#[derive(Clone, From, AnyEnum, Executor, MeteredExecutor, PreflightExecutor)] +#[cfg_attr( + feature = "aot", + derive( + openvm_circuit_derive::AotExecutor, + openvm_circuit_derive::AotMeteredExecutor + ) +)] +pub enum Sha2Executor { + Sha256(Sha2VmExecutor), + Sha512(Sha2VmExecutor), +} + +impl VmExecutionExtension for Sha2 { + type Executor = Sha2Executor; + + fn extend_execution( + &self, + inventory: &mut ExecutorInventoryBuilder, + ) -> Result<(), ExecutorInventoryError> { + let pointer_max_bits = inventory.pointer_max_bits(); + + let sha256_executor = + Sha2VmExecutor::::new(Rv32Sha2Opcode::CLASS_OFFSET, pointer_max_bits); + inventory.add_executor(sha256_executor, [Rv32Sha2Opcode::SHA256.global_opcode()])?; + + let sha512_executor = + Sha2VmExecutor::::new(Rv32Sha2Opcode::CLASS_OFFSET, pointer_max_bits); + inventory.add_executor(sha512_executor, [Rv32Sha2Opcode::SHA512.global_opcode()])?; + + Ok(()) + } +} + +impl VmCircuitExtension for Sha2 { + fn extend_circuit(&self, inventory: &mut AirInventory) -> Result<(), AirInventoryError> { + let bitwise_lu = { + let existing_air = inventory.find_air::>().next(); + if let Some(air) = existing_air { + air.bus + } else { + let bus = BitwiseOperationLookupBus::new(inventory.new_bus_idx()); + let air = BitwiseOperationLookupAir::<8>::new(bus); + inventory.add_air(air); + air.bus + } + }; + + // this bus will be used for communication between the block hasher chip and the main chip + let sha2_bus_index = inventory.new_bus_idx(); + // the sha2 subair needs its own bus for self-interactions + let subair_bus_index = inventory.new_bus_idx(); + + // SHA-256 + let sha256_block_hasher_air = + Sha2BlockHasherVmAir::::new(bitwise_lu, subair_bus_index, sha2_bus_index); + inventory.add_air(sha256_block_hasher_air); + + let sha256_main_air = Sha2MainAir::::new( + inventory.system().port(), + bitwise_lu, + inventory.pointer_max_bits(), + sha2_bus_index, + Rv32Sha2Opcode::CLASS_OFFSET, + ); + inventory.add_air(sha256_main_air); + + // SHA-512 + let sha512_block_hasher_air = + Sha2BlockHasherVmAir::::new(bitwise_lu, subair_bus_index, sha2_bus_index); + inventory.add_air(sha512_block_hasher_air); + + let sha512_main_air = Sha2MainAir::::new( + inventory.system().port(), + bitwise_lu, + inventory.pointer_max_bits(), + sha2_bus_index, + Rv32Sha2Opcode::CLASS_OFFSET, + ); + inventory.add_air(sha512_main_air); + + Ok(()) + } +} + +pub struct Sha2CpuProverExt; +// This implementation is specific to CpuBackend because the lookup chips (VariableRangeChecker, +// BitwiseOperationLookupChip) are specific to CpuBackend. +impl VmProverExtension for Sha2CpuProverExt +where + SC: StarkProtocolConfig, + E: StarkEngine, PD = CpuDevice>, + RA: RowMajorMatrixArena> + Send + Sync + 'static, + Val: VmField, + SC::EF: Ord, +{ + fn extend_prover( + &self, + _: &Sha2, + inventory: &mut ChipInventory>, + ) -> Result<(), ChipInventoryError> { + let range_checker = inventory.range_checker()?.clone(); + let timestamp_max_bits = inventory.timestamp_max_bits(); + let mem_helper = SharedMemoryHelper::new(range_checker.clone(), timestamp_max_bits); + let pointer_max_bits = inventory.airs().pointer_max_bits(); + + let bitwise_lu = { + let existing_chip = inventory + .find_chip::>() + .next(); + if let Some(chip) = existing_chip { + chip.clone() + } else { + let air: &BitwiseOperationLookupAir<8> = inventory.next_air()?; + let chip = Arc::new(BitwiseOperationLookupChip::new(air.bus)); + inventory.add_periphery_chip(chip.clone()); + chip + } + }; + + // We must add each block hasher chip before the main chip to ensure that main chip does its + // tracegen first, because the main chip will pass the records to the block hasher chip + // after its tracegen is done. + + // SHA-256 + inventory.next_air::>()?; + // shared records between the main chip and the block hasher chip + let records = Arc::new(Mutex::new(None)); + let sha256_block_hasher_chip = Sha2BlockHasherChip::, Sha256Config>::new( + bitwise_lu.clone(), + pointer_max_bits, + mem_helper.clone(), + records.clone(), + ); + inventory.add_periphery_chip(sha256_block_hasher_chip); + + inventory.next_air::>()?; + let sha256_main_chip = Sha2MainChip::, Sha256Config>::new( + records, + bitwise_lu.clone(), + pointer_max_bits, + mem_helper.clone(), + ); + inventory.add_executor_chip(sha256_main_chip); + + // SHA-512 + inventory.next_air::>()?; + // shared records between the main chip and the block hasher chip + let records = Arc::new(Mutex::new(None)); + let sha512_block_hasher_chip = Sha2BlockHasherChip::, Sha512Config>::new( + bitwise_lu.clone(), + pointer_max_bits, + mem_helper.clone(), + records.clone(), + ); + inventory.add_periphery_chip(sha512_block_hasher_chip); + + inventory.next_air::>()?; + let sha512_main_chip = Sha2MainChip::, Sha512Config>::new( + records, + bitwise_lu.clone(), + pointer_max_bits, + mem_helper.clone(), + ); + inventory.add_executor_chip(sha512_main_chip); + + Ok(()) + } +} diff --git a/extensions/sha2/circuit/src/lib.rs b/extensions/sha2/circuit/src/lib.rs new file mode 100644 index 0000000000..226cde11e7 --- /dev/null +++ b/extensions/sha2/circuit/src/lib.rs @@ -0,0 +1,15 @@ +#![cfg_attr(feature = "tco", allow(incomplete_features))] +#![cfg_attr(feature = "tco", feature(explicit_tail_calls))] +#![cfg_attr(feature = "tco", allow(internal_features))] +#![cfg_attr(feature = "tco", feature(core_intrinsics))] + +mod sha2_chips; +pub use sha2_chips::*; + +mod extension; +pub use extension::*; + +#[cfg(feature = "cuda")] +mod cuda; +#[cfg(feature = "cuda")] +pub use cuda::*; diff --git a/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/air.rs b/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/air.rs new file mode 100644 index 0000000000..e8e339bcb0 --- /dev/null +++ b/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/air.rs @@ -0,0 +1,156 @@ +use openvm_circuit_primitives::{bitwise_op_lookup::BitwiseOperationLookupBus, SubAir}; +use openvm_sha2_air::{compose, Sha2BlockHasherSubAir}; +use openvm_stark_backend::{ + interaction::{BusIndex, InteractionBuilder, PermutationCheckBus}, + p3_air::{Air, AirBuilder, BaseAir}, + p3_field::{Field, PrimeCharacteristicRing}, + p3_matrix::Matrix, + BaseAirWithPublicValues, PartitionedBaseAir, +}; + +use crate::{ + MessageType, Sha2BlockHasherDigestColsRef, Sha2BlockHasherRoundColsRef, + Sha2BlockHasherVmConfig, INNER_OFFSET, +}; + +pub struct Sha2BlockHasherVmAir { + pub inner: Sha2BlockHasherSubAir, + pub sha2_bus: PermutationCheckBus, +} + +impl Sha2BlockHasherVmAir { + pub fn new( + bitwise_lookup_bus: BitwiseOperationLookupBus, + inner_bus_idx: BusIndex, + sha2_bus_idx: BusIndex, + ) -> Self { + Self { + inner: Sha2BlockHasherSubAir::new(bitwise_lookup_bus, inner_bus_idx), + sha2_bus: PermutationCheckBus::new(sha2_bus_idx), + } + } +} + +impl BaseAirWithPublicValues for Sha2BlockHasherVmAir {} +impl PartitionedBaseAir for Sha2BlockHasherVmAir {} +impl BaseAir for Sha2BlockHasherVmAir { + fn width(&self) -> usize { + C::BLOCK_HASHER_WIDTH + } +} + +impl Air for Sha2BlockHasherVmAir { + fn eval(&self, builder: &mut AB) { + self.inner.eval(builder, INNER_OFFSET); + self.eval_interactions(builder); + self.eval_request_id(builder); + } +} + +impl Sha2BlockHasherVmAir { + fn eval_interactions(&self, builder: &mut AB) { + let main = builder.main(); + let local_slice = main.row_slice(0).unwrap(); + let next_slice = main.row_slice(1).unwrap(); + + let local = Sha2BlockHasherDigestColsRef::::from::( + &local_slice[..C::BLOCK_HASHER_DIGEST_WIDTH], + ); + + // Receive (STATE, request_id, prev_state_as_u16s, new_state) on the sha2 bus + self.sha2_bus.receive( + builder, + [ + AB::Expr::from_u8(MessageType::State as u8), + (*local.request_id).into(), + ] + .into_iter() + .chain(local.inner.prev_hash.flatten().map(|x| (*x).into())) + .chain(local.inner.final_hash.flatten().map(|x| (*x).into())), + *local.inner.flags.is_digest_row, + ); + + let local = Sha2BlockHasherRoundColsRef::::from::( + &local_slice[..C::BLOCK_HASHER_ROUND_WIDTH], + ); + let next = Sha2BlockHasherRoundColsRef::::from::( + &next_slice[..C::BLOCK_HASHER_ROUND_WIDTH], + ); + + let is_local_first_row = self + .inner + .row_idx_encoder + .contains_flag::(local.inner.flags.row_idx.to_slice().unwrap(), &[0]); + + // Taken from old Sha256VmChip: + // https://github.com/openvm-org/openvm/blob/c2e376e6059c8bbf206736cf01d04cda43dfc42d/extensions/sha256/circuit/src/sha256_chip/air.rs#L310C1-L318C1 + let get_ith_byte = |i: usize, cols: &Sha2BlockHasherRoundColsRef| { + debug_assert!(i < C::WORD_U8S * C::ROUNDS_PER_ROW); + let row_idx = i / C::WORD_U8S; + let word: Vec = cols + .inner + .message_schedule + .w + .row(row_idx) + .into_iter() + .copied() + .collect::>(); + // Need to reverse the byte order to match the endianness of the memory + let byte_idx = C::WORD_U8S - i % C::WORD_U8S - 1; + compose::(&word[byte_idx * 8..(byte_idx + 1) * 8], 1) + }; + + let local_message = (0..C::WORD_U8S * C::ROUNDS_PER_ROW).map(|i| get_ith_byte(i, &local)); + let next_message = (0..C::WORD_U8S * C::ROUNDS_PER_ROW).map(|i| get_ith_byte(i, &next)); + + // Receive (MESSAGE_1, request_id, first_half_of_message) on the sha2 bus + self.sha2_bus.receive( + builder, + [ + AB::Expr::from_u8(MessageType::Message1 as u8), + (*local.request_id).into(), + ] + .into_iter() + .chain(local_message.clone()) + .chain(next_message.clone()), + is_local_first_row * local.inner.flags.is_not_padding_row(), + ); + + let is_local_third_row = self + .inner + .row_idx_encoder + .contains_flag::(local.inner.flags.row_idx.to_slice().unwrap(), &[2]); + + // Send (MESSAGE_2, request_id, second_half_of_message) to the sha2 bus + self.sha2_bus.receive( + builder, + [ + AB::Expr::from_u8(MessageType::Message2 as u8), + (*local.request_id).into(), + ] + .into_iter() + .chain(local_message) + .chain(next_message), + is_local_third_row * local.inner.flags.is_not_padding_row(), + ); + } + + fn eval_request_id(&self, builder: &mut AB) { + let main = builder.main(); + let local = main.row_slice(0).unwrap(); + let next = main.row_slice(1).unwrap(); + + // doesn't matter if we use round or digest cols here, since we only access + // request_id and inner.flags.is_last block, which are common to both + // field + let local = + Sha2BlockHasherRoundColsRef::::from::(&local[..C::BLOCK_HASHER_WIDTH]); + let next = + Sha2BlockHasherRoundColsRef::::from::(&next[..C::BLOCK_HASHER_WIDTH]); + + builder + .when_transition() + .when(*local.inner.flags.is_round_row) + .assert_eq(*next.request_id, *local.request_id); + } +} diff --git a/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/columns.rs b/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/columns.rs new file mode 100644 index 0000000000..13f7a70a76 --- /dev/null +++ b/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/columns.rs @@ -0,0 +1,59 @@ +use openvm_circuit_primitives_derive::ColsRef; +use openvm_sha2_air::{ + Sha2BlockHasherSubairConfig, Sha2DigestCols, Sha2DigestColsRef, Sha2DigestColsRefMut, + Sha2RoundCols, Sha2RoundColsRef, Sha2RoundColsRefMut, +}; + +// offset in the columns struct where the inner column start +pub const INNER_OFFSET: usize = 1; + +// Just adding request_id to both columns structs +#[repr(C)] +#[derive(Clone, Copy, Debug, ColsRef)] +#[config(Sha2BlockHasherSubairConfig)] +pub struct Sha2BlockHasherRoundCols< + T, + const WORD_BITS: usize, + const WORD_U8S: usize, + const WORD_U16S: usize, + const ROUNDS_PER_ROW: usize, + const ROUNDS_PER_ROW_MINUS_ONE: usize, + const ROW_VAR_CNT: usize, +> { + pub request_id: T, + pub inner: Sha2RoundCols< + T, + WORD_BITS, + WORD_U8S, + WORD_U16S, + ROUNDS_PER_ROW, + ROUNDS_PER_ROW_MINUS_ONE, + ROW_VAR_CNT, + >, +} + +#[repr(C)] +#[derive(Clone, Copy, Debug, ColsRef)] +#[config(Sha2BlockHasherSubairConfig)] +pub struct Sha2BlockHasherDigestCols< + T, + const WORD_BITS: usize, + const WORD_U8S: usize, + const WORD_U16S: usize, + const HASH_WORDS: usize, + const ROUNDS_PER_ROW: usize, + const ROUNDS_PER_ROW_MINUS_ONE: usize, + const ROW_VAR_CNT: usize, +> { + pub request_id: T, + pub inner: Sha2DigestCols< + T, + WORD_BITS, + WORD_U8S, + WORD_U16S, + HASH_WORDS, + ROUNDS_PER_ROW, + ROUNDS_PER_ROW_MINUS_ONE, + ROW_VAR_CNT, + >, +} diff --git a/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/config.rs b/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/config.rs new file mode 100644 index 0000000000..14523a06f4 --- /dev/null +++ b/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/config.rs @@ -0,0 +1,52 @@ +use openvm_sha2_air::{Sha256Config, Sha2BlockHasherSubairConfig, Sha384Config, Sha512Config}; + +use crate::{Sha2BlockHasherDigestColsRef, Sha2BlockHasherRoundColsRef}; + +pub trait Sha2BlockHasherVmConfig: Sha2BlockHasherSubairConfig { + /// Width of the Sha2VmRoundCols + const BLOCK_HASHER_ROUND_WIDTH: usize; + /// Width of the Sha2DigestCols + const BLOCK_HASHER_DIGEST_WIDTH: usize; + /// Width of the Sha2BlockHasherCols + const BLOCK_HASHER_WIDTH: usize; +} + +impl Sha2BlockHasherVmConfig for Sha256Config { + const BLOCK_HASHER_ROUND_WIDTH: usize = + Sha2BlockHasherRoundColsRef::::width::(); + const BLOCK_HASHER_DIGEST_WIDTH: usize = + Sha2BlockHasherDigestColsRef::::width::(); + const BLOCK_HASHER_WIDTH: usize = + if Self::BLOCK_HASHER_ROUND_WIDTH > Self::BLOCK_HASHER_DIGEST_WIDTH { + Self::BLOCK_HASHER_ROUND_WIDTH + } else { + Self::BLOCK_HASHER_DIGEST_WIDTH + }; +} + +impl Sha2BlockHasherVmConfig for Sha512Config { + const BLOCK_HASHER_ROUND_WIDTH: usize = + Sha2BlockHasherRoundColsRef::::width::(); + const BLOCK_HASHER_DIGEST_WIDTH: usize = + Sha2BlockHasherDigestColsRef::::width::(); + const BLOCK_HASHER_WIDTH: usize = if ::BLOCK_HASHER_ROUND_WIDTH + > Self::BLOCK_HASHER_DIGEST_WIDTH + { + Self::BLOCK_HASHER_ROUND_WIDTH + } else { + Self::BLOCK_HASHER_DIGEST_WIDTH + }; +} + +impl Sha2BlockHasherVmConfig for Sha384Config { + const BLOCK_HASHER_ROUND_WIDTH: usize = + Sha2BlockHasherRoundColsRef::::width::(); + const BLOCK_HASHER_DIGEST_WIDTH: usize = + Sha2BlockHasherDigestColsRef::::width::(); + const BLOCK_HASHER_WIDTH: usize = + if Self::BLOCK_HASHER_ROUND_WIDTH > Self::BLOCK_HASHER_DIGEST_WIDTH { + Self::BLOCK_HASHER_ROUND_WIDTH + } else { + Self::BLOCK_HASHER_DIGEST_WIDTH + }; +} diff --git a/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/mod.rs b/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/mod.rs new file mode 100644 index 0000000000..0465a2fdac --- /dev/null +++ b/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/mod.rs @@ -0,0 +1,55 @@ +mod air; +mod columns; + +mod config; +mod trace; + +use std::{ + marker::PhantomData, + sync::{Arc, Mutex}, +}; + +pub use air::*; +pub use columns::*; +pub use config::*; +use openvm_circuit::system::memory::SharedMemoryHelper; +use openvm_circuit_primitives::bitwise_op_lookup::SharedBitwiseOperationLookupChip; +use openvm_instructions::riscv::RV32_CELL_BITS; +use openvm_sha2_air::{Sha2BlockHasherFillerHelper, Sha2BlockHasherSubairConfig}; + +pub use super::{config::*, Sha2SharedRecords}; + +pub struct Sha2BlockHasherChip { + pub inner: Sha2BlockHasherFillerHelper, + pub bitwise_lookup_chip: SharedBitwiseOperationLookupChip, + pub pointer_max_bits: usize, + pub mem_helper: SharedMemoryHelper, + // This Arc>> is shared with the main chip (Sha2MainChip). + // When the main chip's tracegen is done, it will set the value of the mutex to Some(records) + // and then the block hasher chip can see the records and use it to generate its trace. + // The arc mutex is not strictly necessary (we could just use a Cell) because tracegen is done + // sequentially over the list of chips (although it is parallelized within each chip), but the + // overhead of using a thread-safe type is negligible since we only access the 'records' field + // twice (once to set the value and once to get the value). + // So, we will just use an arc mutex to avoid overcomplicating things. + pub records: Arc>>>, + _phantom: PhantomData, +} + +impl Sha2BlockHasherChip { + pub fn new( + bitwise_lookup_chip: SharedBitwiseOperationLookupChip, + pointer_max_bits: usize, + mem_helper: SharedMemoryHelper, + records: Arc>>>, + ) -> Self { + Self { + inner: Sha2BlockHasherFillerHelper::new(), + bitwise_lookup_chip, + pointer_max_bits, + mem_helper, + records, + _phantom: PhantomData, + } + } +} diff --git a/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/trace.rs b/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/trace.rs new file mode 100644 index 0000000000..6feaac8066 --- /dev/null +++ b/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/trace.rs @@ -0,0 +1,271 @@ +use std::slice; + +use openvm_circuit::arch::get_record_from_slice; +use openvm_circuit_primitives::utils::next_power_of_two_or_zero; +use openvm_sha2_air::{ + be_limbs_into_word, le_limbs_into_word, Sha2BlockHasherFillerHelper, Sha2RoundColsRef, + Sha2RoundColsRefMut, +}; +use openvm_circuit_primitives::Chip; +use openvm_stark_backend::{ + p3_field::{PrimeCharacteristicRing, PrimeField32}, + p3_matrix::dense::RowMajorMatrix, + p3_maybe_rayon::prelude::*, + prover::{AirProvingContext, ColMajorMatrix, CpuBackend}, + StarkProtocolConfig, Val, +}; + +use crate::{ + Sha2BlockHasherChip, Sha2BlockHasherRoundColsRefMut, Sha2BlockHasherVmConfig, Sha2Config, + Sha2Metadata, Sha2RecordLayout, Sha2RecordMut, Sha2SharedRecords, INNER_OFFSET, +}; + +// We don't use the record arena associated with this chip. Instead, we will use the record arena +// provided by the main chip, which will be passed to this chip after the main chip's tracegen is +// done. +impl Chip> for Sha2BlockHasherChip, C> +where + Val: PrimeField32, + SC: StarkProtocolConfig, +{ + fn generate_proving_ctx(&self, _: R) -> AirProvingContext> { + // SAFETY: the tracegen for Sha2MainChip must be done before this chip's tracegen + let mut records = self.records.lock().unwrap(); + let mut records = records.take().unwrap(); + let rows_used = records.num_records * C::ROWS_PER_BLOCK; + + let height = next_power_of_two_or_zero(rows_used); + let trace = Val::::zero_vec(height * C::BLOCK_HASHER_WIDTH); + let mut trace_matrix = RowMajorMatrix::new(trace, C::BLOCK_HASHER_WIDTH); + + self.fill_trace(&mut trace_matrix, &mut records, rows_used); + + AirProvingContext::simple_no_pis(ColMajorMatrix::from_row_major(&trace_matrix)) + } +} + +impl Sha2BlockHasherChip +where + F: PrimeField32, + C: Sha2BlockHasherVmConfig, +{ + fn fill_trace( + &self, + trace_matrix: &mut RowMajorMatrix, + records: &mut Sha2SharedRecords, + rows_used: usize, + ) { + if rows_used == 0 { + return; + } + + let trace = &mut trace_matrix.values[..]; + + // grab all the records + // we need to do this first, so we can pass (this_block.prev_hash, next_block.prev_hash) to + // each block (in the call to fill_block_trace) + let (records, prev_hashes): (Vec<_>, Vec<_>) = records + .matrix + .par_rows_mut() + .take(records.num_records) + .map(|mut record| { + // SAFETY: + // - caller ensures `records` contains a valid record representation that was + // previously written by the executor + // - records contains a valid Sha2RecordMut with the exact layout specified + // - get_record_from_slice will correctly split the buffer into header, input, and + // aux components based on this layout + let record: Sha2RecordMut = unsafe { + get_record_from_slice( + &mut record, + Sha2RecordLayout { + metadata: Sha2Metadata { + variant: C::VARIANT, + }, + }, + ) + }; + + let prev_hash = (0..C::HASH_WORDS) + .map(|i| { + le_limbs_into_word::( + &record.prev_state[i * C::WORD_U8S..(i + 1) * C::WORD_U8S] + .iter() + .map(|x| *x as u32) + .collect::>(), + ) + }) + .collect::>(); + + (record, prev_hash) + }) + .unzip(); + + // zip the prev_hashes with the next block's prev_hash + let prev_hashes_and_next_block_prev_hashes = prev_hashes.par_iter().zip( + prev_hashes[1..] + .par_iter() + .chain(prev_hashes[..1].par_iter()), + ); + + // fill in used rows + trace[..rows_used * C::BLOCK_HASHER_WIDTH] + .par_chunks_exact_mut(C::BLOCK_HASHER_WIDTH * C::ROWS_PER_BLOCK) + .zip( + records + .par_iter() + .zip(prev_hashes_and_next_block_prev_hashes), + ) + .enumerate() + .for_each( + |(block_idx, (block_slice, (record, (prev_hash, next_block_prev_hash))))| { + self.fill_block_trace( + block_slice, + record.message_bytes, + block_idx + 1, // 1-indexed + prev_hash, + next_block_prev_hash, + block_idx, + ); + }, + ); + + // fill in the first dummy row. + // we need to do this first, so we can compute the carries that make the + // constraint_word_addition constraints hold on dummy rows (or more precisely, on rows such + // that the next row is a dummy row). + let first_dummy_row_cols_const = self.fill_first_dummy_row( + &mut trace[rows_used * C::BLOCK_HASHER_WIDTH..(rows_used + 1) * C::BLOCK_HASHER_WIDTH], + &prev_hashes[0], + ); + + // fill in the rest of the dummy rows + trace[(rows_used + 1) * C::BLOCK_HASHER_WIDTH..] + .par_chunks_exact_mut(C::BLOCK_HASHER_WIDTH) + .for_each(|row| { + // copy the carries from the first dummy row into the current dummy row + self.inner.generate_default_row( + &mut Sha2RoundColsRefMut::from::( + &mut row[INNER_OFFSET..INNER_OFFSET + C::SUBAIR_ROUND_WIDTH], + ), + &prev_hashes[0], + Some( + first_dummy_row_cols_const + .work_vars + .carry_a + .as_slice() + .unwrap(), + ), + Some( + first_dummy_row_cols_const + .work_vars + .carry_e + .as_slice() + .unwrap(), + ), + ); + }); + + // Do a second pass over the trace to fill in the missing values + // Note, we need to skip the very first row + trace[C::BLOCK_HASHER_WIDTH..] + .par_chunks_mut(C::BLOCK_HASHER_WIDTH * C::ROWS_PER_BLOCK) + .take(rows_used / C::ROWS_PER_BLOCK) + .for_each(|chunk| { + self.inner + .generate_missing_cells(chunk, C::BLOCK_HASHER_WIDTH, INNER_OFFSET); + }); + } + + fn fill_first_dummy_row( + &self, + first_dummy_row_mut: &mut [F], + first_block_prev_hash: &[C::Word], + ) -> Sha2RoundColsRef<'_, F> { + let first_dummy_row_const = + unsafe { slice::from_raw_parts(first_dummy_row_mut.as_ptr(), C::BLOCK_HASHER_WIDTH) }; + let first_dummy_row_cols_const = Sha2RoundColsRef::from::( + &first_dummy_row_const[INNER_OFFSET..INNER_OFFSET + C::SUBAIR_ROUND_WIDTH], + ); + + let first_dummy_row_mut = unsafe { + slice::from_raw_parts_mut(first_dummy_row_mut.as_mut_ptr(), C::BLOCK_HASHER_WIDTH) + }; + let mut first_dummy_row_cols_mut: Sha2RoundColsRefMut = Sha2RoundColsRefMut::from::( + &mut first_dummy_row_mut[INNER_OFFSET..INNER_OFFSET + C::SUBAIR_ROUND_WIDTH], + ); + + // first, fill in everything but the carries into the first dummy row (i.e. fill in the + // work vars and row_idx) + self.inner.generate_default_row( + &mut first_dummy_row_cols_mut, + first_block_prev_hash, + None, + None, + ); + + // Now, this will fill in the first dummy row with the correct carries. + // This works because we already filled in the work vars into the first dummy row, and + // generate_carry_ae only looks at the work vars. + // Note that these carries will work for any pair of dummy rows, since all dummy rows + // have the same work vars (the first block's prev_hash). + Sha2BlockHasherFillerHelper::::generate_carry_ae( + first_dummy_row_cols_const.clone(), + &mut first_dummy_row_cols_mut, + ); + + first_dummy_row_cols_const + } +} + +impl Sha2BlockHasherChip { + #[allow(clippy::too_many_arguments)] + fn fill_block_trace( + &self, + block_slice: &mut [F], + input: &[u8], + global_block_idx: usize, // 1-indexed + prev_hash: &[C::Word], + next_block_prev_hash: &[C::Word], + request_id: usize, + ) where + F: PrimeField32, + { + debug_assert_eq!(input.len(), C::BLOCK_U8S); + debug_assert_eq!(prev_hash.len(), C::HASH_WORDS); + + // Set request_id + block_slice + .par_chunks_exact_mut(C::BLOCK_HASHER_WIDTH) + .for_each(|row_slice| { + // Set request_id + let cols = Sha2BlockHasherRoundColsRefMut::::from::( + &mut row_slice[..C::BLOCK_HASHER_WIDTH], + ); + *cols.request_id = F::from_usize(request_id); + }); + + let input_words = (0..C::BLOCK_WORDS) + .map(|i| { + be_limbs_into_word::( + &input[i * C::WORD_U8S..(i + 1) * C::WORD_U8S] + .iter() + .map(|x| *x as u32) + .collect::>(), + ) + }) + .collect::>(); + + // Fill in the inner trace + self.inner.generate_block_trace( + block_slice, + C::BLOCK_HASHER_WIDTH, + INNER_OFFSET, + &input_words, + self.bitwise_lookup_chip.clone(), + prev_hash, + next_block_prev_hash, + global_block_idx as u32, + ); + } +} diff --git a/extensions/sha2/circuit/src/sha2_chips/config.rs b/extensions/sha2/circuit/src/sha2_chips/config.rs new file mode 100644 index 0000000000..437852315e --- /dev/null +++ b/extensions/sha2/circuit/src/sha2_chips/config.rs @@ -0,0 +1,97 @@ +use openvm_sha2_air::{Sha256Config, Sha384Config, Sha512Config}; +use sha2::{ + compress256, compress512, digest::generic_array::GenericArray, Digest, Sha256, Sha384, Sha512, +}; + +use crate::{Sha2BlockHasherVmConfig, Sha2MainChipConfig}; + +pub const SHA2_REGISTER_READS: usize = 3; +pub const SHA2_READ_SIZE: usize = 4; +pub const SHA2_WRITE_SIZE: usize = 4; + +pub trait Sha2Config: Sha2MainChipConfig + Sha2BlockHasherVmConfig { + /// Number of bits used to store the message length (part of the message padding) + const MESSAGE_LENGTH_BITS: usize; + + /// Number of bytes in the digest + const DIGEST_BYTES: usize; + + // Preconditions: + // - state.len() >= Self::STATE_BYTES + // - input.len() == Self::BLOCK_BYTES + fn compress(state: &mut [u8], input: &[u8]); + + // returns the digest as big-endian words + fn hash(message: &[u8]) -> Vec; +} + +impl Sha2Config for Sha256Config { + const MESSAGE_LENGTH_BITS: usize = 64; + + // the digest is the whole state + const DIGEST_BYTES: usize = Sha256Config::STATE_BYTES; + + fn compress(state: &mut [u8], input: &[u8]) { + debug_assert!(state.len() >= Sha256Config::STATE_BYTES); + debug_assert!(input.len() == Sha256Config::BLOCK_BYTES); + + // SAFETY: + // This is safe because state points to a [u32; 8]. + // The only reason we have a &[u8] instead is that we read it from a record, where + // we store the state as bytes since we don't know the word size at compile time (u32 for + // Sha256, u64 for Sha512) + let state_u32s: &mut [u32; 8] = unsafe { &mut *(state.as_mut_ptr() as *mut [u32; 8]) }; + + let input_array = GenericArray::from_slice(input); + + compress256(state_u32s, &[*input_array]); + } + + // returns the digest as big-endian words + fn hash(message: &[u8]) -> Vec { + Sha256::digest(message).to_vec() + } +} + +impl Sha2Config for Sha512Config { + const MESSAGE_LENGTH_BITS: usize = 128; + + // the digest is the whole state + const DIGEST_BYTES: usize = Sha512Config::STATE_BYTES; + + fn compress(state: &mut [u8], input: &[u8]) { + debug_assert!(state.len() >= Sha512Config::STATE_BYTES); + debug_assert!(input.len() == Sha512Config::BLOCK_BYTES); + + // SAFETY: + // This is safe because state points to a [u64; 8]. + // The only reason we have a &[u8] instead is that we read it from a record, where + // we store the state as bytes since we don't know the word size at compile time (u32 for + // Sha256, u64 for Sha512) + let state_u64s: &mut [u64; 8] = unsafe { &mut *(state.as_mut_ptr() as *mut [u64; 8]) }; + + let input_array = GenericArray::from_slice(input); + + compress512(state_u64s, &[*input_array]); + } + + // returns the digest as big-endian words + fn hash(message: &[u8]) -> Vec { + Sha512::digest(message).to_vec() + } +} + +impl Sha2Config for Sha384Config { + const MESSAGE_LENGTH_BITS: usize = Sha512Config::MESSAGE_LENGTH_BITS; + + // SHA-384 truncates the output to 48 bytes + const DIGEST_BYTES: usize = 48; + + fn compress(state: &mut [u8], input: &[u8]) { + Sha512Config::compress(state, input); + } + + fn hash(message: &[u8]) -> Vec { + Sha384::digest(message).to_vec() + } +} diff --git a/extensions/sha256/circuit/src/sha256_chip/execution.rs b/extensions/sha2/circuit/src/sha2_chips/execution.rs similarity index 53% rename from extensions/sha256/circuit/src/sha256_chip/execution.rs rename to extensions/sha2/circuit/src/sha2_chips/execution.rs index 8fdc91f9d0..d0428ab33f 100644 --- a/extensions/sha256/circuit/src/sha256_chip/execution.rs +++ b/extensions/sha2/circuit/src/sha2_chips/execution.rs @@ -8,62 +8,58 @@ use openvm_instructions::{ riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, LocalOpcode, }; -use openvm_sha256_air::{get_sha256_num_blocks, SHA256_ROWS_PER_BLOCK}; -use openvm_sha256_transpiler::Rv32Sha256Opcode; use openvm_stark_backend::p3_field::PrimeField32; -use super::{sha256_solve, Sha256VmExecutor, SHA256_NUM_READ_ROWS, SHA256_READ_SIZE}; +use super::{Sha2Config, Sha2VmExecutor, SHA2_READ_SIZE}; +use crate::SHA2_WRITE_SIZE; #[derive(AlignedBytesBorrow, Clone)] #[repr(C)] -struct ShaPreCompute { +struct Sha2PreCompute { a: u8, b: u8, c: u8, } -impl InterpreterExecutor for Sha256VmExecutor { - #[cfg(feature = "tco")] - fn handler( +impl InterpreterExecutor for Sha2VmExecutor { + fn pre_compute_size(&self) -> usize { + size_of::() + } + + #[cfg(not(feature = "tco"))] + fn pre_compute( &self, pc: u32, inst: &Instruction, data: &mut [u8], - ) -> Result, StaticProgramError> + ) -> Result, StaticProgramError> where Ctx: ExecutionCtxTrait, { - let data: &mut ShaPreCompute = data.borrow_mut(); + let data: &mut Sha2PreCompute = data.borrow_mut(); self.pre_compute_impl(pc, inst, data)?; - Ok(execute_e1_handler::<_, _>) - } - - fn pre_compute_size(&self) -> usize { - size_of::() + Ok(execute_e1_impl::<_, _, C>) } - #[cfg(not(feature = "tco"))] - fn pre_compute( + #[cfg(feature = "tco")] + fn handler( &self, pc: u32, inst: &Instruction, data: &mut [u8], - ) -> Result, StaticProgramError> + ) -> Result, StaticProgramError> where Ctx: ExecutionCtxTrait, { - let data: &mut ShaPreCompute = data.borrow_mut(); + let data: &mut Sha2PreCompute = data.borrow_mut(); self.pre_compute_impl(pc, inst, data)?; - Ok(execute_e1_impl::<_, _>) + Ok(execute_e1_handler::<_, _, C>) } } -#[cfg(feature = "aot")] -impl AotExecutor for Sha256VmExecutor {} - -impl InterpreterMeteredExecutor for Sha256VmExecutor { +impl InterpreterMeteredExecutor for Sha2VmExecutor { fn metered_pre_compute_size(&self) -> usize { - size_of::>() + size_of::>() } #[cfg(not(feature = "tco"))] @@ -77,10 +73,10 @@ impl InterpreterMeteredExecutor for Sha256VmExecutor { where Ctx: MeteredExecutionCtxTrait, { - let data: &mut E2PreCompute = data.borrow_mut(); + let data: &mut E2PreCompute = data.borrow_mut(); data.chip_idx = chip_idx as u32; self.pre_compute_impl(pc, inst, &mut data.data)?; - Ok(execute_e2_impl::<_, _>) + Ok(execute_e2_impl::<_, _, C>) } #[cfg(feature = "tco")] @@ -94,90 +90,101 @@ impl InterpreterMeteredExecutor for Sha256VmExecutor { where Ctx: MeteredExecutionCtxTrait, { - let data: &mut E2PreCompute = data.borrow_mut(); + let data: &mut E2PreCompute = data.borrow_mut(); data.chip_idx = chip_idx as u32; self.pre_compute_impl(pc, inst, &mut data.data)?; - Ok(execute_e2_handler::<_, _>) + Ok(execute_e2_handler::<_, _, C>) } } -#[cfg(feature = "aot")] -impl AotMeteredExecutor for Sha256VmExecutor {} - #[inline(always)] -unsafe fn execute_e12_impl( - pre_compute: &ShaPreCompute, +unsafe fn execute_e12_impl< + F: PrimeField32, + C: Sha2Config, + CTX: ExecutionCtxTrait, + const IS_E1: bool, +>( + pre_compute: &Sha2PreCompute, exec_state: &mut VmExecState, ) -> u32 { let dst = exec_state.vm_read(RV32_REGISTER_AS, pre_compute.a as u32); - let src = exec_state.vm_read(RV32_REGISTER_AS, pre_compute.b as u32); - let len = exec_state.vm_read(RV32_REGISTER_AS, pre_compute.c as u32); + let state = exec_state.vm_read(RV32_REGISTER_AS, pre_compute.b as u32); + let input = exec_state.vm_read(RV32_REGISTER_AS, pre_compute.c as u32); let dst_u32 = u32::from_le_bytes(dst); - let src_u32 = u32::from_le_bytes(src); - let len_u32 = u32::from_le_bytes(len); - - let (output, height) = if IS_E1 { - // SAFETY: RV32_MEMORY_AS is memory address space of type u8 - let message = exec_state.vm_read_slice(RV32_MEMORY_AS, src_u32, len_u32 as usize); - let output = sha256_solve(message); - (output, 0) - } else { - let num_blocks = get_sha256_num_blocks(len_u32); - let mut message = Vec::with_capacity(len_u32 as usize); - for block_idx in 0..num_blocks as usize { - // Reads happen on the first 4 rows of each block - for row in 0..SHA256_NUM_READ_ROWS { - let read_idx = block_idx * SHA256_NUM_READ_ROWS + row; - let row_input: [u8; SHA256_READ_SIZE] = exec_state.vm_read( - RV32_MEMORY_AS, - src_u32 + (read_idx * SHA256_READ_SIZE) as u32, - ); - message.extend_from_slice(&row_input); - } - } - let output = sha256_solve(&message[..len_u32 as usize]); - let height = num_blocks * SHA256_ROWS_PER_BLOCK as u32; - (output, height) - }; - exec_state.vm_write(RV32_MEMORY_AS, dst_u32, &output); + let state_u32 = u32::from_le_bytes(state); + let input_u32 = u32::from_le_bytes(input); + + // state is in 4-byte little-endian words + let mut state_data = Vec::with_capacity(C::STATE_BYTES); + for i in 0..C::STATE_READS { + state_data.extend_from_slice(&exec_state.vm_read::( + RV32_MEMORY_AS, + state_u32 + (i * SHA2_READ_SIZE) as u32, + )); + } + let mut input_block = Vec::with_capacity(C::BLOCK_BYTES); + for i in 0..C::BLOCK_READS { + input_block.extend_from_slice(&exec_state.vm_read::( + RV32_MEMORY_AS, + input_u32 + (i * SHA2_READ_SIZE) as u32, + )); + } + + C::compress(&mut state_data, &input_block); + + for i in 0..C::STATE_WRITES { + exec_state.vm_write::( + RV32_MEMORY_AS, + dst_u32 + (i * SHA2_WRITE_SIZE) as u32, + &state_data[i * SHA2_WRITE_SIZE..(i + 1) * SHA2_WRITE_SIZE] + .try_into() + .unwrap(), + ); + } let pc = exec_state.pc(); exec_state.set_pc(pc.wrapping_add(DEFAULT_PC_STEP)); - height + 1 // height delta } #[create_handler] #[inline(always)] -unsafe fn execute_e1_impl( +unsafe fn execute_e1_impl( pre_compute: *const u8, exec_state: &mut VmExecState, ) { - let pre_compute: &ShaPreCompute = - std::slice::from_raw_parts(pre_compute, size_of::()).borrow(); - execute_e12_impl::(pre_compute, exec_state); + let pre_compute: &Sha2PreCompute = + std::slice::from_raw_parts(pre_compute, size_of::()).borrow(); + execute_e12_impl::(pre_compute, exec_state); } #[create_handler] #[inline(always)] -unsafe fn execute_e2_impl( +unsafe fn execute_e2_impl( pre_compute: *const u8, exec_state: &mut VmExecState, ) { - let pre_compute: &E2PreCompute = - std::slice::from_raw_parts(pre_compute, size_of::>()).borrow(); - let height = execute_e12_impl::(&pre_compute.data, exec_state); + let pre_compute: &E2PreCompute = + std::slice::from_raw_parts(pre_compute, size_of::>()).borrow(); + let height = execute_e12_impl::(&pre_compute.data, exec_state); exec_state .ctx .on_height_change(pre_compute.chip_idx as usize, height); } -impl Sha256VmExecutor { +#[cfg(feature = "aot")] +impl AotExecutor for Sha2VmExecutor {} + +#[cfg(feature = "aot")] +impl AotMeteredExecutor for Sha2VmExecutor {} + +impl Sha2VmExecutor { fn pre_compute_impl( &self, pc: u32, inst: &Instruction, - data: &mut ShaPreCompute, + data: &mut Sha2PreCompute, ) -> Result<(), StaticProgramError> { let Instruction { opcode, @@ -192,12 +199,12 @@ impl Sha256VmExecutor { if d.as_canonical_u32() != RV32_REGISTER_AS || e_u32 != RV32_MEMORY_AS { return Err(StaticProgramError::InvalidInstruction(pc)); } - *data = ShaPreCompute { + *data = Sha2PreCompute { a: a.as_canonical_u32() as u8, b: b.as_canonical_u32() as u8, c: c.as_canonical_u32() as u8, }; - assert_eq!(&Rv32Sha256Opcode::SHA256.global_opcode(), opcode); + assert_eq!(&C::OPCODE.global_opcode(), opcode); Ok(()) } } diff --git a/extensions/sha2/circuit/src/sha2_chips/main_chip/air.rs b/extensions/sha2/circuit/src/sha2_chips/main_chip/air.rs new file mode 100644 index 0000000000..c5aeb50fce --- /dev/null +++ b/extensions/sha2/circuit/src/sha2_chips/main_chip/air.rs @@ -0,0 +1,326 @@ +use std::marker::PhantomData; + +use itertools::izip; +use ndarray::s; +use openvm_circuit::{ + arch::ExecutionBridge, + system::{ + memory::{offline_checker::MemoryBridge, MemoryAddress}, + SystemPort, + }, +}; +use openvm_circuit_primitives::{bitwise_op_lookup::BitwiseOperationLookupBus, utils::compose}; +use openvm_instructions::riscv::{ + RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS, +}; +use openvm_sha2_air::Sha2BlockHasherSubairConfig; +use openvm_stark_backend::{ + interaction::{BusIndex, InteractionBuilder, PermutationCheckBus}, + p3_air::{Air, AirBuilder, BaseAir}, + p3_field::PrimeCharacteristicRing, + p3_matrix::Matrix, + BaseAirWithPublicValues, PartitionedBaseAir, +}; + +use super::config::Sha2MainChipConfig; +use crate::{MessageType, Sha2ColsRef, SHA2_READ_SIZE, SHA2_WRITE_SIZE}; + +#[derive(Clone, Debug)] +pub struct Sha2MainAir { + pub execution_bridge: ExecutionBridge, + pub memory_bridge: MemoryBridge, + pub bitwise_lookup_bus: BitwiseOperationLookupBus, + pub sha2_bus: PermutationCheckBus, + /// Maximum number of bits allowed for an address pointer + /// Must be at least 24 + pub ptr_max_bits: usize, + pub offset: usize, + _phantom: PhantomData, +} + +impl Sha2MainAir { + pub fn new( + SystemPort { + execution_bus, + program_bus, + memory_bridge, + }: SystemPort, + bitwise_lookup_bus: BitwiseOperationLookupBus, + ptr_max_bits: usize, + self_bus_idx: BusIndex, + offset: usize, + ) -> Self { + Self { + execution_bridge: ExecutionBridge::new(execution_bus, program_bus), + memory_bridge, + bitwise_lookup_bus, + sha2_bus: PermutationCheckBus::new(self_bus_idx), + ptr_max_bits, + offset, + _phantom: PhantomData, + } + } +} + +impl BaseAirWithPublicValues for Sha2MainAir {} +impl PartitionedBaseAir for Sha2MainAir {} +impl BaseAir for Sha2MainAir { + fn width(&self) -> usize { + C::MAIN_CHIP_WIDTH + } +} + +impl Air + for Sha2MainAir +{ + fn eval(&self, builder: &mut AB) { + let main = builder.main(); + let (local, next) = (main.row_slice(0).unwrap(), main.row_slice(1).unwrap()); + + let local: Sha2ColsRef = Sha2ColsRef::from::(&local[..C::MAIN_CHIP_WIDTH]); + let next: Sha2ColsRef = Sha2ColsRef::from::(&next[..C::MAIN_CHIP_WIDTH]); + + let mut timestamp_delta = 0; + let mut timestamp_pp = || { + timestamp_delta += 1; + local.instruction.from_state.timestamp + + AB::F::from_usize(timestamp_delta - 1) + }; + + self.eval_block(builder, &local, &next); + self.eval_instruction(builder, &local, &mut timestamp_pp); + self.eval_reads(builder, &local, &mut timestamp_pp); + self.eval_writes(builder, &local, &mut timestamp_pp); + } +} + +impl Sha2MainAir { + pub fn eval_block( + &self, + builder: &mut AB, + local: &Sha2ColsRef, + next: &Sha2ColsRef, + ) { + builder + .when_first_row() + .when(*local.instruction.is_enabled) + .assert_zero(*local.block.request_id); + + builder + .when_transition() + .when(*next.instruction.is_enabled) + .assert_eq( + *next.block.request_id, + *local.block.request_id + AB::Expr::ONE, + ); + + let prev_state_as_u16s: Vec = local + .block + .prev_state + .exact_chunks(C::WORD_U8S) + .into_iter() + .flat_map(|word| { + word.as_slice() + .unwrap() + .chunks_exact(2) + .map(|x| x[1] * AB::F::from_u64(1 << 8) + x[0]) + .collect::>() + }) + .collect(); + + // Send (STATE, request_id, prev_state_as_u16s, new_state) to the sha2 bus + self.sha2_bus.send( + builder, + [ + AB::Expr::from_u8(MessageType::State as u8), + (*local.block.request_id).into(), + ] + .into_iter() + .chain(prev_state_as_u16s) + .chain(local.block.new_state.into_iter().copied().map(|x| x.into())), + *local.instruction.is_enabled, + ); + + // Send (MESSAGE_1, request_id, first_half_of_message) to the sha2 bus + self.sha2_bus.send( + builder, + [ + AB::Expr::from_u8(MessageType::Message1 as u8), + (*local.block.request_id).into(), + ] + .into_iter() + .chain( + local + .block + .message_bytes + .iter() + .take(C::BLOCK_BYTES / 2) + .map(|x| (*x).into()), + ), + *local.instruction.is_enabled, + ); + + // Send (MESSAGE_2, request_id, second_half_of_message) to the sha2 bus + self.sha2_bus.send( + builder, + [ + AB::Expr::from_u8(MessageType::Message2 as u8), + (*local.block.request_id).into(), + ] + .into_iter() + .chain( + local + .block + .message_bytes + .iter() + .skip(C::BLOCK_BYTES / 2) + .map(|x| (*x).into()), + ), + *local.instruction.is_enabled, + ); + } + + pub fn eval_instruction( + &self, + builder: &mut AB, + local: &Sha2ColsRef, + timestamp_pp: &mut impl FnMut() -> AB::Expr, + ) { + for (&ptr, val, aux) in izip!( + [ + local.instruction.dst_reg_ptr, + local.instruction.state_reg_ptr, + local.instruction.input_reg_ptr + ], + [ + local.instruction.dst_ptr_limbs, + local.instruction.state_ptr_limbs, + local.instruction.input_ptr_limbs + ], + &local.mem.register_aux, + ) { + self.memory_bridge + .read::<_, _, SHA2_READ_SIZE>( + MemoryAddress::new(AB::Expr::from_u32(RV32_REGISTER_AS), ptr), + val.to_vec().try_into().unwrap_or_else(|_| panic!()), // can't unwrap because AB::Var doesn't impl Debug + timestamp_pp(), + aux, + ) + .eval(builder, *local.instruction.is_enabled); + } + + // range check the memory pointers + let shift = AB::Expr::from_usize( + 1 << (RV32_REGISTER_NUM_LIMBS * RV32_CELL_BITS - self.ptr_max_bits), + ); + let needs_range_check = [ + local.instruction.dst_ptr_limbs[RV32_REGISTER_NUM_LIMBS - 1], + local.instruction.state_ptr_limbs[RV32_REGISTER_NUM_LIMBS - 1], + local.instruction.input_ptr_limbs[RV32_REGISTER_NUM_LIMBS - 1], + local.instruction.input_ptr_limbs[RV32_REGISTER_NUM_LIMBS - 1], + ]; + for pair in needs_range_check.chunks_exact(2) { + self.bitwise_lookup_bus + .send_range(pair[0] * shift.clone(), pair[1] * shift.clone()) + .eval(builder, *local.instruction.is_enabled); + } + + self.execution_bridge + .execute_and_increment_pc( + AB::Expr::from_usize(C::OPCODE as usize + self.offset), + [ + (*local.instruction.dst_reg_ptr).into(), + (*local.instruction.state_reg_ptr).into(), + (*local.instruction.input_reg_ptr).into(), + AB::Expr::from_u32(RV32_REGISTER_AS), + AB::Expr::from_u32(RV32_MEMORY_AS), + ], + *local.instruction.from_state, + AB::F::from_usize(C::TIMESTAMP_DELTA), + ) + .eval(builder, *local.instruction.is_enabled); + } + + pub fn eval_reads( + &self, + builder: &mut AB, + local: &Sha2ColsRef, + timestamp_pp: &mut impl FnMut() -> AB::Expr, + ) { + let input_ptr_val = compose(&local.instruction.input_ptr_limbs.to_vec(), RV32_CELL_BITS); + for i in 0..C::BLOCK_READS { + self.memory_bridge + .read::<_, _, SHA2_READ_SIZE>( + MemoryAddress::new( + AB::Expr::from_u32(RV32_MEMORY_AS), + input_ptr_val.clone() + AB::F::from_usize(i * SHA2_READ_SIZE), + ), + local + .block + .message_bytes + .slice(s![i * SHA2_READ_SIZE..(i + 1) * SHA2_READ_SIZE]) + .to_vec() + .try_into() + .unwrap_or_else(|_| { + panic!("message bytes is not the correct size"); + }), + timestamp_pp(), + &local.mem.input_reads[i], + ) + .eval(builder, *local.instruction.is_enabled); + } + + let state_ptr_val = compose(&local.instruction.state_ptr_limbs.to_vec(), RV32_CELL_BITS); + for i in 0..C::STATE_READS { + self.memory_bridge + .read::<_, _, SHA2_READ_SIZE>( + MemoryAddress::new( + AB::Expr::from_u32(RV32_MEMORY_AS), + state_ptr_val.clone() + AB::F::from_usize(i * SHA2_READ_SIZE), + ), + local + .block + .prev_state + .slice(s![i * SHA2_READ_SIZE..(i + 1) * SHA2_READ_SIZE]) + .to_vec() + .try_into() + .unwrap_or_else(|_| { + panic!("prev state is not the correct size"); + }), + timestamp_pp(), + &local.mem.state_reads[i], + ) + .eval(builder, *local.instruction.is_enabled); + } + } + + pub fn eval_writes( + &self, + builder: &mut AB, + local: &Sha2ColsRef, + timestamp_pp: &mut impl FnMut() -> AB::Expr, + ) { + let dst_ptr_val = compose(&local.instruction.dst_ptr_limbs.to_vec(), RV32_CELL_BITS); + for i in 0..C::STATE_READS { + self.memory_bridge + .write::<_, _, SHA2_WRITE_SIZE>( + MemoryAddress::new( + AB::Expr::from_u32(RV32_MEMORY_AS), + dst_ptr_val.clone() + AB::F::from_usize(i * SHA2_READ_SIZE), + ), + local + .block + .new_state + .slice(s![i * SHA2_READ_SIZE..(i + 1) * SHA2_READ_SIZE]) + .to_vec() + .try_into() + .unwrap_or_else(|_| { + panic!("new state is not the correct size"); + }), + timestamp_pp(), + &local.mem.write_aux[i], + ) + .eval(builder, *local.instruction.is_enabled); + } + } +} diff --git a/extensions/sha2/circuit/src/sha2_chips/main_chip/columns.rs b/extensions/sha2/circuit/src/sha2_chips/main_chip/columns.rs new file mode 100644 index 0000000000..9c2151580f --- /dev/null +++ b/extensions/sha2/circuit/src/sha2_chips/main_chip/columns.rs @@ -0,0 +1,74 @@ +use openvm_circuit::{ + arch::ExecutionState, + system::memory::offline_checker::{MemoryReadAuxCols, MemoryWriteAuxCols}, +}; +use openvm_circuit_primitives::ColsRef; +use openvm_instructions::riscv::RV32_REGISTER_NUM_LIMBS; + +use crate::{Sha2MainChipConfig, SHA2_REGISTER_READS, SHA2_WRITE_SIZE}; + +#[repr(C)] +#[derive(Clone, Copy, Debug, ColsRef)] +#[config(Sha2MainChipConfig)] +pub struct Sha2Cols { + pub block: Sha2BlockCols, + pub instruction: Sha2InstructionCols, + pub mem: Sha2MemoryCols, +} + +#[repr(C)] +#[derive(Clone, Copy, Debug, ColsRef)] +#[config(Sha2MainChipConfig)] +pub struct Sha2BlockCols { + /// Identifier of this row in the interactions between the two chips + pub request_id: T, + /// Input bytes for this block + pub message_bytes: [T; BLOCK_BYTES], + /// Previous state of the SHA-2 hasher object, as little-endian words + pub prev_state: [T; STATE_BYTES], + /// New state of the SHA-2 hasher object after processing this block, as little-endian words + pub new_state: [T; STATE_BYTES], +} + +#[repr(C)] +#[derive(Clone, Copy, Debug, ColsRef)] +#[config(Sha2MainChipConfig)] +pub struct Sha2InstructionCols { + /// True for all rows that are part of opcode execution. + /// False on dummy rows only used to pad the height. + pub is_enabled: T, + #[aligned_borrow] + pub from_state: ExecutionState, + /// Pointer to address space 1 `dst` register + pub dst_reg_ptr: T, + /// Pointer to address space 1 `state` register + pub state_reg_ptr: T, + /// Pointer to address space 1 `input` register + pub input_reg_ptr: T, + // Register values + /// dst_ptr_limbs <- \[dst_reg_ptr:4\]_1 + pub dst_ptr_limbs: [T; RV32_REGISTER_NUM_LIMBS], + /// state_ptr_limbs <- \[state_reg_ptr:4\]_1 + pub state_ptr_limbs: [T; RV32_REGISTER_NUM_LIMBS], + /// input_ptr_limbs <- \[input_reg_ptr:4\]_1 + pub input_ptr_limbs: [T; RV32_REGISTER_NUM_LIMBS], +} + +#[repr(C)] +#[derive(Clone, Copy, Debug, ColsRef)] +#[config(Sha2MainChipConfig)] +pub struct Sha2MemoryCols< + T, + const BLOCK_READS: usize, + const STATE_READS: usize, + const STATE_WRITES: usize, +> { + #[aligned_borrow] + pub register_aux: [MemoryReadAuxCols; SHA2_REGISTER_READS], + #[aligned_borrow] + pub input_reads: [MemoryReadAuxCols; BLOCK_READS], + #[aligned_borrow] + pub state_reads: [MemoryReadAuxCols; STATE_READS], + #[aligned_borrow] + pub write_aux: [MemoryWriteAuxCols; STATE_WRITES], +} diff --git a/extensions/sha2/circuit/src/sha2_chips/main_chip/config.rs b/extensions/sha2/circuit/src/sha2_chips/main_chip/config.rs new file mode 100644 index 0000000000..5aec638971 --- /dev/null +++ b/extensions/sha2/circuit/src/sha2_chips/main_chip/config.rs @@ -0,0 +1,42 @@ +use openvm_sha2_air::{Sha256Config, Sha384Config, Sha512Config}; +use openvm_sha2_transpiler::Rv32Sha2Opcode; + +use crate::{Sha2ColsRef, SHA2_READ_SIZE, SHA2_REGISTER_READS, SHA2_WRITE_SIZE}; + +pub trait Sha2MainChipConfig: Send + Sync + Clone { + // --- Required --- + /// Number of bytes in a SHA block (sometimes referred to as message bytes in the code) + const BLOCK_BYTES: usize; + /// Number of bytes in a SHA state + const STATE_BYTES: usize; + /// OpenVM Opcode for the instruction + const OPCODE: Rv32Sha2Opcode; + + // --- Provided --- + const BLOCK_READS: usize = Self::BLOCK_BYTES / SHA2_READ_SIZE; + const STATE_READS: usize = Self::STATE_BYTES / SHA2_READ_SIZE; + const STATE_WRITES: usize = Self::STATE_BYTES / SHA2_WRITE_SIZE; + + const TIMESTAMP_DELTA: usize = + Self::BLOCK_READS + Self::STATE_READS + Self::STATE_WRITES + SHA2_REGISTER_READS; + + const MAIN_CHIP_WIDTH: usize = Sha2ColsRef::::width::(); +} + +impl Sha2MainChipConfig for Sha256Config { + const BLOCK_BYTES: usize = 64; + const STATE_BYTES: usize = 32; + const OPCODE: Rv32Sha2Opcode = Rv32Sha2Opcode::SHA256; +} + +impl Sha2MainChipConfig for Sha512Config { + const BLOCK_BYTES: usize = 128; + const STATE_BYTES: usize = 64; + const OPCODE: Rv32Sha2Opcode = Rv32Sha2Opcode::SHA512; +} + +impl Sha2MainChipConfig for Sha384Config { + const BLOCK_BYTES: usize = Sha512Config::BLOCK_BYTES; + const STATE_BYTES: usize = Sha512Config::STATE_BYTES; + const OPCODE: Rv32Sha2Opcode = Sha512Config::OPCODE; +} diff --git a/extensions/sha2/circuit/src/sha2_chips/main_chip/mod.rs b/extensions/sha2/circuit/src/sha2_chips/main_chip/mod.rs new file mode 100644 index 0000000000..c72b48fe3e --- /dev/null +++ b/extensions/sha2/circuit/src/sha2_chips/main_chip/mod.rs @@ -0,0 +1,58 @@ +mod air; +mod columns; +mod config; +mod trace; + +use std::{ + marker::PhantomData, + sync::{Arc, Mutex}, +}; + +pub use air::*; +pub use columns::*; +pub use config::*; +use openvm_circuit::system::memory::SharedMemoryHelper; +use openvm_circuit_primitives::bitwise_op_lookup::SharedBitwiseOperationLookupChip; +use openvm_stark_backend::p3_matrix::dense::RowMajorMatrix; + +use crate::Sha2Config; + +// Record struct for sharing between the main chip and the block hasher chip +pub struct Sha2SharedRecords { + // note that we can't just do matrix.height() because the height is padded to the next power of + // two by MatrixRecordArena::into_matrix() + pub num_records: usize, + pub matrix: RowMajorMatrix, +} +pub struct Sha2MainChip { + // This Arc>> is shared with the block hasher chip (Sha2BlockHasherChip). + // When the main chip's tracegen is done, it will set the value of the mutex to Some(records) + // and then the block hasher chip can see the records and use them to generate its trace. + // The arc mutex is not strictly necessary (we could just use a Cell) because tracegen is done + // sequentially over the list of chips (although it is parallelized within each chip), but the + // overhead of using a thread-safe type is negligible since we only access the 'records' field + // twice (once to set the value and once to get the value). + // So, we will just use an arc mutex to avoid overcomplicating things. + pub records: Arc>>>, + pub bitwise_lookup_chip: SharedBitwiseOperationLookupChip<8>, + pub pointer_max_bits: usize, + pub mem_helper: SharedMemoryHelper, + _phantom: PhantomData, +} + +impl Sha2MainChip { + pub fn new( + records: Arc>>>, + bitwise_lookup_chip: SharedBitwiseOperationLookupChip<8>, + pointer_max_bits: usize, + mem_helper: SharedMemoryHelper, + ) -> Self { + Self { + records, + bitwise_lookup_chip, + pointer_max_bits, + mem_helper, + _phantom: PhantomData, + } + } +} diff --git a/extensions/sha2/circuit/src/sha2_chips/main_chip/trace.rs b/extensions/sha2/circuit/src/sha2_chips/main_chip/trace.rs new file mode 100644 index 0000000000..e374c7927a --- /dev/null +++ b/extensions/sha2/circuit/src/sha2_chips/main_chip/trace.rs @@ -0,0 +1,222 @@ +use openvm_circuit::{ + arch::*, + system::memory::{ + offline_checker::{MemoryReadAuxRecord, MemoryWriteBytesAuxRecord}, + MemoryAuxColsFactory, + }, + utils::next_power_of_two_or_zero, +}; +use openvm_instructions::riscv::{RV32_CELL_BITS, RV32_REGISTER_NUM_LIMBS}; +use openvm_sha2_air::set_arrayview_from_u8_slice; +use openvm_circuit_primitives::Chip; +use openvm_stark_backend::{ + p3_field::{PrimeCharacteristicRing, PrimeField32}, + p3_matrix::{dense::RowMajorMatrix, Matrix}, + p3_maybe_rayon::prelude::*, + prover::{AirProvingContext, ColMajorMatrix, CpuBackend}, + StarkProtocolConfig, Val, +}; + +use crate::{ + Sha2ColsRefMut, Sha2Config, Sha2MainChip, Sha2Metadata, Sha2RecordLayout, Sha2RecordMut, + Sha2SharedRecords, SHA2_WRITE_SIZE, +}; + +// We will allocate a new trace matrix instead of using the record arena directly, +// because we want to pass the record arena to Sha2BlockHasherChip when we are done. +impl Chip> + for Sha2MainChip, C> +where + Val: PrimeField32, + SC: StarkProtocolConfig, + RA: RowMajorMatrixArena> + Send + Sync, +{ + fn generate_proving_ctx(&self, arena: RA) -> AirProvingContext> { + // Since Sha2Metadata::get_num_rows() = 1, the number of rows used is equal to the number of + // SHA-2 instructions executed. + let rows_used = arena.trace_offset() / arena.width(); + + // We will fill the trace into a separate buffer, because we want to pass the arena to the + // Sha2BlockHasherChip when we are done. + // Sha2MainChip uses 1 row per instruction, we allocate rows_used * arena.width() space for + // the trace. + let height = next_power_of_two_or_zero(rows_used); + let trace = Val::::zero_vec(height * arena.width()); + let mut trace_matrix = RowMajorMatrix::new(trace, arena.width()); + let mem_helper = self.mem_helper.as_borrowed(); + + let mut records = arena.into_matrix(); + + self.fill_trace(&mem_helper, &mut trace_matrix, rows_used, &mut records); + + // Pass the records to Sha2BlockHasherChip + *self.records.lock().unwrap() = Some(Sha2SharedRecords { + num_records: rows_used, + matrix: records, + }); + + AirProvingContext::simple_no_pis(ColMajorMatrix::from_row_major(&trace_matrix)) + } +} + +// Note: we would like to just impl TraceFiller here, but we can't because we need to pass the +// records and row_idx to the tracegen functions. +impl Sha2MainChip { + // Preconditions: + // - trace should be a matrix with width = Sha2MainAir::width() and height = rows_used + // - trace should be filled with all zeros + // - records should be a matrix with height = rows_used, where each row stores a record + pub fn fill_trace( + &self, + mem_helper: &MemoryAuxColsFactory, + trace: &mut RowMajorMatrix, + rows_used: usize, + records: &mut RowMajorMatrix, + ) { + let width = trace.width(); + trace.values[..rows_used * width] + .par_chunks_exact_mut(width) + .zip(records.par_rows_mut()) + .enumerate() + .for_each(|(row_idx, (row_slice, record))| { + self.fill_trace_row_with_row_idx(mem_helper, row_slice, row_idx, record); + }); + } + + // Same as TraceFiller::fill_trace_row, except we also take the row index as a parameter. + // + // Note: the only reason the record parameter is mutable is that get_record_from_slice + // requires a &mut &mut [F] slice. This parameter type is useful in other places where + // get_record_from_slice is used, to circumvent the borrow checker. Here, we don't actually need + // this workaround (we could duplicate get_record_from_slice and modify it to take a &mut + // [F] slice), but we just use the existing function for simplicity. + fn fill_trace_row_with_row_idx( + &self, + mem_helper: &MemoryAuxColsFactory, + row_slice: &mut [F], + row_idx: usize, + mut record: &mut [F], + ) where + F: Clone, + { + // SAFETY: + // - caller ensures `record` contains a valid record representation that was previously + // written by the executor + // - record contains a valid Sha2RecordMut with the exact layout specified + // - get_record_from_slice will correctly split the buffer into header and other components + // based on this layout. + let record: Sha2RecordMut = unsafe { + get_record_from_slice( + &mut record, + Sha2RecordLayout::new(Sha2Metadata { + variant: C::VARIANT, + }), + ) + }; + + // save all the components of the record on the stack so that we don't overwrite them when + // filling in the trace matrix. + let vm_record = record.inner.clone(); + + let mut message_bytes = Vec::with_capacity(C::BLOCK_BYTES); + message_bytes.extend_from_slice(record.message_bytes); + + let mut prev_state = Vec::with_capacity(C::STATE_BYTES); + prev_state.extend_from_slice(record.prev_state); + + let mut new_state = Vec::with_capacity(C::STATE_BYTES); + new_state.extend_from_slice(record.new_state); + + let mut input_reads_aux = + Vec::with_capacity(C::BLOCK_READS * size_of::()); + input_reads_aux.extend_from_slice(record.input_reads_aux); + + let mut state_reads_aux = + Vec::with_capacity(C::STATE_READS * size_of::()); + state_reads_aux.extend_from_slice(record.state_reads_aux); + + let mut write_aux = Vec::with_capacity( + C::STATE_WRITES * size_of::>(), + ); + write_aux.extend_from_slice(record.write_aux); + + let mut cols = Sha2ColsRefMut::from::(row_slice); + + *cols.block.request_id = F::from_usize(row_idx); + set_arrayview_from_u8_slice(&mut cols.block.message_bytes, message_bytes); + set_arrayview_from_u8_slice(&mut cols.block.prev_state, prev_state); + set_arrayview_from_u8_slice(&mut cols.block.new_state, new_state); + + *cols.instruction.is_enabled = F::ONE; + cols.instruction.from_state.timestamp = F::from_u32(vm_record.timestamp); + cols.instruction.from_state.pc = F::from_u32(vm_record.from_pc); + *cols.instruction.dst_reg_ptr = F::from_u32(vm_record.dst_reg_ptr); + *cols.instruction.state_reg_ptr = F::from_u32(vm_record.state_reg_ptr); + *cols.instruction.input_reg_ptr = F::from_u32(vm_record.input_reg_ptr); + + let dst_ptr_limbs = vm_record.dst_ptr.to_le_bytes(); + let state_ptr_limbs = vm_record.state_ptr.to_le_bytes(); + let input_ptr_limbs = vm_record.input_ptr.to_le_bytes(); + set_arrayview_from_u8_slice(&mut cols.instruction.dst_ptr_limbs, dst_ptr_limbs); + set_arrayview_from_u8_slice(&mut cols.instruction.state_ptr_limbs, state_ptr_limbs); + set_arrayview_from_u8_slice(&mut cols.instruction.input_ptr_limbs, input_ptr_limbs); + let needs_range_check = [ + dst_ptr_limbs[RV32_REGISTER_NUM_LIMBS - 1], + state_ptr_limbs[RV32_REGISTER_NUM_LIMBS - 1], + input_ptr_limbs[RV32_REGISTER_NUM_LIMBS - 1], + input_ptr_limbs[RV32_REGISTER_NUM_LIMBS - 1], + ]; + let shift: u32 = 1 << (RV32_REGISTER_NUM_LIMBS * RV32_CELL_BITS - self.pointer_max_bits); + for pair in needs_range_check.chunks_exact(2) { + self.bitwise_lookup_chip + .request_range(pair[0] as u32 * shift, pair[1] as u32 * shift); + } + + // fill in the register reads aux + let mut timestamp = vm_record.timestamp; + for (cols, vm_record) in cols + .mem + .register_aux + .iter_mut() + .zip(vm_record.register_reads_aux.iter()) + { + mem_helper.fill(vm_record.prev_timestamp, timestamp, cols.as_mut()); + timestamp += 1; + } + + input_reads_aux.iter().zip(cols.mem.input_reads).for_each( + |(read_aux_record, read_aux_cols)| { + mem_helper.fill( + read_aux_record.prev_timestamp, + timestamp, + read_aux_cols.as_mut(), + ); + timestamp += 1; + }, + ); + + state_reads_aux.iter().zip(cols.mem.state_reads).for_each( + |(state_aux_record, state_aux_cols)| { + mem_helper.fill( + state_aux_record.prev_timestamp, + timestamp, + state_aux_cols.as_mut(), + ); + timestamp += 1; + }, + ); + + write_aux + .iter() + .zip(cols.mem.write_aux) + .for_each(|(write_aux_record, write_aux_cols)| { + write_aux_cols.set_prev_data(write_aux_record.prev_data.map(F::from_u8)); + mem_helper.fill( + write_aux_record.prev_timestamp, + timestamp, + write_aux_cols.as_mut(), + ); + timestamp += 1; + }); + } +} diff --git a/extensions/sha2/circuit/src/sha2_chips/mod.rs b/extensions/sha2/circuit/src/sha2_chips/mod.rs new file mode 100644 index 0000000000..f1a6a9211d --- /dev/null +++ b/extensions/sha2/circuit/src/sha2_chips/mod.rs @@ -0,0 +1,33 @@ +mod block_hasher_chip; +mod config; +mod execution; +mod main_chip; +mod trace; + +use std::marker::PhantomData; + +pub use block_hasher_chip::*; +pub use main_chip::*; +pub use trace::*; + +#[cfg(test)] +mod test_utils; +#[cfg(test)] +mod tests; +#[cfg(test)] +pub use test_utils::*; + +#[derive(derive_new::new, Clone)] +pub struct Sha2VmExecutor { + pub offset: usize, + pub pointer_max_bits: usize, + _phantom: PhantomData, +} + +// Indicates the message type of the interactions on the sha bus +#[repr(u8)] +pub enum MessageType { + State, + Message1, + Message2, +} diff --git a/extensions/sha2/circuit/src/sha2_chips/test_utils.rs b/extensions/sha2/circuit/src/sha2_chips/test_utils.rs new file mode 100644 index 0000000000..0e0ab04f00 --- /dev/null +++ b/extensions/sha2/circuit/src/sha2_chips/test_utils.rs @@ -0,0 +1,77 @@ +use itertools::Itertools; +use openvm_circuit::arch::testing::TestBuilder; +use openvm_instructions::riscv::RV32_MEMORY_AS; +use openvm_sha2_air::Sha2Variant; +use openvm_stark_backend::p3_field::PrimeField32; + +use crate::{Sha2Config, SHA2_READ_SIZE, SHA2_WRITE_SIZE}; + +// See https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf for the padding algorithm +pub fn add_padding_to_message(mut message: Vec) -> Vec { + // Length of the message in bits + let message_len = message.len() * 8; + + // For SHA-256, + // l + 1 + k = 448 mod 512 + // <=> l + 1 + k + 8 = 0 mod 512 + // <=> k = -(l + 1 + 8) mod 512 + // <=> k = (512 - (l + 1 + 8)) mod 512 + // The other variants are similar. + let padding_len_bits = (C::BLOCK_BITS + - ((message_len + 1 + C::MESSAGE_LENGTH_BITS) % C::BLOCK_BITS)) + % C::BLOCK_BITS; + message.push(0x80); + + let padding_len_bytes = padding_len_bits / 8; + message.extend(std::iter::repeat_n(0x00, padding_len_bytes)); + + match C::VARIANT { + Sha2Variant::Sha256 => { + message.extend_from_slice(&((message_len as u64).to_be_bytes())); + } + Sha2Variant::Sha512 => { + message.extend_from_slice(&((message_len as u128).to_be_bytes())); + } + Sha2Variant::Sha384 => { + message.extend_from_slice(&((message_len as u128).to_be_bytes())); + } + }; + + assert_eq!(message.len() % C::BLOCK_BYTES, 0); + + message +} + +pub fn write_slice_to_memory( + tester: &mut impl TestBuilder, + data: &[u8], + ptr: usize, +) { + data.chunks_exact(4).enumerate().for_each(|(i, chunk)| { + tester.write::( + RV32_MEMORY_AS as usize, + ptr + i * 4, + chunk + .iter() + .cloned() + .map(F::from_u8) + .collect_vec() + .try_into() + .unwrap(), + ); + }); +} + +pub fn read_slice_from_memory( + tester: &mut impl TestBuilder, + ptr: usize, + len: usize, +) -> Vec { + let mut data = Vec::new(); + for i in 0..(len / SHA2_READ_SIZE) { + data.extend_from_slice( + &tester.read::(RV32_MEMORY_AS as usize, ptr + i * SHA2_READ_SIZE), + ); + } + data +} diff --git a/extensions/sha2/circuit/src/sha2_chips/tests.rs b/extensions/sha2/circuit/src/sha2_chips/tests.rs new file mode 100644 index 0000000000..67d3707c6d --- /dev/null +++ b/extensions/sha2/circuit/src/sha2_chips/tests.rs @@ -0,0 +1,867 @@ +use std::sync::{Arc, Mutex}; + +use hex::FromHex; +use itertools::Itertools; +use openvm_circuit::{ + arch::{ + testing::{ + memory::gen_pointer, TestBuilder, TestChipHarness, VmChipTestBuilder, + BITWISE_OP_LOOKUP_BUS, + }, + Arena, MatrixRecordArena, PreflightExecutor, + }, + system::{memory::SharedMemoryHelper, SystemPort}, + utils::get_random_message, +}; +use openvm_circuit_primitives::bitwise_op_lookup::{ + BitwiseOperationLookupAir, BitwiseOperationLookupBus, BitwiseOperationLookupChip, + SharedBitwiseOperationLookupChip, +}; +use openvm_instructions::{instruction::Instruction, riscv::RV32_CELL_BITS, LocalOpcode}; +use openvm_sha2_air::{word_into_u8_limbs, Sha256Config, Sha384Config, Sha512Config}; +use openvm_sha2_transpiler::Rv32Sha2Opcode; +use openvm_stark_backend::{ + interaction::BusIndex, + p3_field::{Field, PrimeCharacteristicRing, PrimeField32}, + p3_matrix::{dense::RowMajorMatrix, Matrix}, + utils::disable_debug_builder, +}; +use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng}; +use rand::{rngs::StdRng, Rng}; +#[cfg(feature = "cuda")] +use { + crate::{Sha2BlockHasherChipGpu, Sha2MainChipGpu, Sha2RecordMut}, + openvm_circuit::arch::testing::{ + default_bitwise_lookup_bus, GpuChipTestBuilder, GpuTestChipHarness, + }, + openvm_circuit_primitives::bitwise_op_lookup::BitwiseOperationLookupChipGPU, +}; + +use crate::{ + add_padding_to_message, read_slice_from_memory, write_slice_to_memory, Sha2BlockHasherChip, + Sha2BlockHasherDigestColsRefMut, Sha2BlockHasherVmAir, Sha2Config, Sha2MainAir, Sha2MainChip, + Sha2VmExecutor, +}; + +const SHA2_BUS_IDX: BusIndex = 28; +const SUBAIR_BUS_IDX: BusIndex = 29; +type F = BabyBear; +const MAX_INS_CAPACITY: usize = 4096; +type Harness = TestChipHarness, Sha2MainAir, Sha2MainChip, RA>; + +fn create_harness_fields( + system_port: SystemPort, + bitwise_chip: SharedBitwiseOperationLookupChip, + memory_helper: SharedMemoryHelper, + pointer_max_bits: usize, +) -> (Sha2MainAir, Sha2VmExecutor, Sha2MainChip) { + let executor = Sha2VmExecutor::::new(Rv32Sha2Opcode::CLASS_OFFSET, pointer_max_bits); + let empty_records = Arc::new(Mutex::new(None)); + let main_chip = Sha2MainChip::new( + empty_records.clone(), + bitwise_chip.clone(), + pointer_max_bits, + memory_helper, + ); + let main_air = Sha2MainAir::new( + system_port, + bitwise_chip.bus(), + pointer_max_bits, + SHA2_BUS_IDX, + Rv32Sha2Opcode::CLASS_OFFSET, + ); + (main_air, executor, main_chip) +} + +struct TestHarness { + harness: Harness, + bitwise: ( + BitwiseOperationLookupAir, + SharedBitwiseOperationLookupChip, + ), + block_hasher: (Sha2BlockHasherVmAir, Sha2BlockHasherChip), +} + +fn create_test_harness( + tester: &mut VmChipTestBuilder, +) -> TestHarness { + let bitwise_bus = BitwiseOperationLookupBus::new(BITWISE_OP_LOOKUP_BUS); + let bitwise_chip = Arc::new(BitwiseOperationLookupChip::::new( + bitwise_bus, + )); + + let (air, executor, main_chip) = create_harness_fields( + tester.system_port(), + bitwise_chip.clone(), + tester.memory_helper(), + tester.address_bits(), + ); + + let shared_records = main_chip.records.clone(); + + let harness = Harness::::with_capacity(executor, air, main_chip, MAX_INS_CAPACITY); + + let block_hasher_air = + Sha2BlockHasherVmAir::new(bitwise_chip.bus(), SUBAIR_BUS_IDX, SHA2_BUS_IDX); + let block_hasher_chip = Sha2BlockHasherChip::new( + bitwise_chip.clone(), + tester.address_bits(), + tester.memory_helper(), + shared_records, + ); + + TestHarness { + harness, + bitwise: (bitwise_chip.air, bitwise_chip), + block_hasher: (block_hasher_air, block_hasher_chip), + } +} + +// execute one SHA2_UPDATE instruction +#[allow(clippy::too_many_arguments)] +fn set_and_execute_single_block>( + tester: &mut impl TestBuilder, + executor: &mut E, + arena: &mut RA, + rng: &mut StdRng, + opcode: Rv32Sha2Opcode, + message: Option<&[u8]>, + prev_state: Option<&[u8]>, +) { + let rd = gen_pointer(rng, 4); + let rs1 = gen_pointer(rng, 4); + let rs2 = gen_pointer(rng, 4); + + let dst_ptr = gen_pointer(rng, 4); + let state_ptr = gen_pointer(rng, 4); + let input_ptr = gen_pointer(rng, 4); + tester.write(1, rd, dst_ptr.to_le_bytes().map(F::from_u8)); + tester.write(1, rs1, state_ptr.to_le_bytes().map(F::from_u8)); + tester.write(1, rs2, input_ptr.to_le_bytes().map(F::from_u8)); + + let default_message = get_random_message(rng, C::BLOCK_U8S); + let message = message.unwrap_or(&default_message); + assert!(message.len() == C::BLOCK_U8S); + write_slice_to_memory(tester, message, input_ptr); + + let default_prev_state = get_random_message(rng, C::STATE_BYTES); + let prev_state = prev_state.unwrap_or(&default_prev_state); + assert!(prev_state.len() == C::STATE_BYTES); + write_slice_to_memory(tester, prev_state, state_ptr); + + tester.execute( + executor, + arena, + &Instruction::from_usize(opcode.global_opcode(), [rd, rs1, rs2, 1, 2]), + ); + + let mut state = prev_state.to_vec(); + C::compress(&mut state, message); + let expected_output = state + .iter() + .cloned() + .map(F::from_u8) + .collect_vec(); + + assert_eq!( + expected_output, + read_slice_from_memory(tester, dst_ptr, C::STATE_BYTES) + ); +} + +/////////////////////////////////////////////////////////////////////////////////////// +/// POSITIVE TESTS - Single Block Hash +/// +/// Randomly generate computations and execute, ensuring that the generated trace +/// passes all constraints. +/////////////////////////////////////////////////////////////////////////////////////// +// Test a single block hash +fn rand_sha2_single_block_test() { + let mut rng = create_seeded_rng(); + let mut tester = VmChipTestBuilder::default(); + let TestHarness { + mut harness, + bitwise, + block_hasher, + } = create_test_harness::, C>(&mut tester); + + let num_ops: usize = 10; + for _ in 0..num_ops { + set_and_execute_single_block::<_, C, _>( + &mut tester, + &mut harness.executor, + &mut harness.arena, + &mut rng, + C::OPCODE, + None, + None, + ); + } + + let tester = tester + .build() + .load(harness) + .load_periphery(block_hasher) + .load_periphery(bitwise) + .finalize(); + tester.simple_test().expect("Verification failed"); +} + +#[test] +fn rand_sha256_single_block_test() { + rand_sha2_single_block_test::(); +} + +#[test] +fn rand_sha512_single_block_test() { + rand_sha2_single_block_test::(); +} + +#[test] +fn rand_sha384_single_block_test() { + rand_sha2_single_block_test::(); +} + +/////////////////////////////////////////////////////////////////////////////////////// +/// POSITIVE TESTS - Multi Block Hash +/// +/// Execute multiple SHA2_UPDATE instructions to hash an entire message +/////////////////////////////////////////////////////////////////////////////////////// +#[allow(clippy::too_many_arguments)] +fn set_and_execute_full_message>( + tester: &mut impl TestBuilder, + executor: &mut E, + arena: &mut RA, + rng: &mut StdRng, + opcode: Rv32Sha2Opcode, + message: Option<&[u8]>, + len: Option, +) { + let rd = gen_pointer(rng, 4); + let rs1 = gen_pointer(rng, 4); + let rs2 = gen_pointer(rng, 4); + + let state_ptr = gen_pointer(rng, 4); + let dst_ptr = state_ptr; + let input_ptr = gen_pointer(rng, 4); + tester.write(1, rd, dst_ptr.to_le_bytes().map(F::from_u8)); + tester.write(1, rs1, state_ptr.to_le_bytes().map(F::from_u8)); + tester.write(1, rs2, input_ptr.to_le_bytes().map(F::from_u8)); + + // initial state as little-endian words + let initial_state: Vec = C::get_h() + .iter() + .cloned() + .flat_map(|x| word_into_u8_limbs::(x).into_iter()) + .map(|x| x.try_into().unwrap()) + .collect_vec(); + + assert!(initial_state.len() == C::STATE_BYTES); + write_slice_to_memory(tester, &initial_state, state_ptr); + + let len = len.unwrap_or(rng.random_range(1..3000)); + let default_message = get_random_message(rng, len); + let message = message.map(|x| x.to_vec()).unwrap_or(default_message); + + // C::hash() returns big-endian words. + // We want little-endian words so we can compare to our final state (which is in little-endian + // words) + let expected_output = C::hash(&message) + .chunks_exact(C::WORD_U8S) + .flat_map(|word| word.iter().rev().copied()) + .collect_vec(); + + let padded_message = add_padding_to_message::(message); + + // run SHA2_UPDATE as many times as needed to hash the entire message + padded_message + .chunks_exact(C::BLOCK_BYTES) + .for_each(|block| { + write_slice_to_memory(tester, block, input_ptr); + + tester.execute( + executor, + arena, + &Instruction::from_usize(opcode.global_opcode(), [rd, rs1, rs2, 1, 2]), + ); + }); + + let output = read_slice_from_memory(tester, dst_ptr, C::DIGEST_BYTES) + .into_iter() + .map(|x| x.as_canonical_u32() as u8) + .collect_vec(); + + assert_eq!(expected_output, output); +} + +// Test a single block hash +fn rand_sha2_multi_block_test() { + let mut rng = create_seeded_rng(); + let mut tester = VmChipTestBuilder::default(); + let TestHarness { + mut harness, + bitwise, + block_hasher, + } = create_test_harness::<_, C>(&mut tester); + + let num_ops: usize = 10; + for _ in 0..num_ops { + set_and_execute_full_message::<_, C, _>( + &mut tester, + &mut harness.executor, + &mut harness.arena, + &mut rng, + C::OPCODE, + None, + None, + ); + } + + let tester = tester + .build() + .load(harness) + .load_periphery(block_hasher) + .load_periphery(bitwise) + .finalize(); + tester.simple_test().expect("Verification failed"); +} + +#[test] +fn rand_sha256_multi_block_test() { + rand_sha2_multi_block_test::(); +} + +#[test] +fn rand_sha512_multi_block_test() { + rand_sha2_multi_block_test::(); +} + +// Note that this test is distinct from rand_sha512_multi_block_test() because this one uses the +// initial hash state for SHA384 instead of SHA512. +#[test] +fn rand_sha384_multi_block_test() { + rand_sha2_multi_block_test::(); +} + +/////////////////////////////////////////////////////////////////////////////////////// +/// EDGE TESTS - Edge Case Input Lengths +/// +/// Test the hash function with various input lengths. +/////////////////////////////////////////////////////////////////////////////////////// +fn sha2_edge_test_lengths() { + let mut rng = create_seeded_rng(); + let mut tester = VmChipTestBuilder::default(); + let TestHarness { + mut harness, + bitwise, + block_hasher, + } = create_test_harness::<_, C>(&mut tester); + + // inputs of various number of blocks + const TEST_VECTORS: [&str; 4] = [ + "", + "98c1c0bdb7d5fea9a88859f06c6c439f", + "5b58f4163e248467cc1cd3eecafe749e8e2baaf82c0f63af06df0526347d7a11327463c115210a46b6740244eddf370be89c", + "9ad198539e3160194f38ac076a782bd5210a007560d1fce9ef78f8a4a5e4d78c6b96c250cff3520009036e9c6087d5dab587394edda862862013de49a12072485a6c01165ec0f28ffddf1873fbd53e47fcd02fb6a5ccc9622d5588a92429c663ce298cb71b50022fc2ec4ba9f5bbd250974e1a607b165fee16e8f3f2be20d7348b91a2f518ce928491900d56d9f86970611580350cee08daea7717fe28a73b8dcfdea22a65ed9f5a09198de38e4e4f2cc05b0ba3dd787a5363ab6c9f39dcb66c1a29209b1d6b1152769395df8150b4316658ea6ab19af94903d643fcb0ae4d598035ebe73c8b1b687df1ab16504f633c929569c6d0e5fae6eea43838fbc8ce2c2b43161d0addc8ccf945a9c4e06294e56a67df0000f561f61b630b1983ba403e775aaeefa8d339f669d1e09ead7eae979383eda983321e1743e5404b4b328da656de79ff52d179833a6bd5129f49432d74d001996c37c68d9ab49fcff8061d193576f396c20e1f0d9ee83a51290ba60efa9c3cb2e15b756321a7ca668cdbf63f95ec33b1c450aa100101be059dc00077245b25a6a66698dee81953ed4a606944076e2858b1420de0095a7f60b08194d6d9a997009d345c71f63a7034b976e409af8a9a040ac7113664609a7adedb76b2fadf04b0348392a1650526eb2a4d6ed5e4bbcda8aabc8488b38f4f5d9a398103536bb8250ed82a9b9825f7703c263f9e", + ]; + + for input in TEST_VECTORS.iter() { + let input = Vec::from_hex(input).unwrap(); + + set_and_execute_full_message::<_, C, _>( + &mut tester, + &mut harness.executor, + &mut harness.arena, + &mut rng, + C::OPCODE, + Some(&input), + None, + ); + } + + // check every possible input length modulo block size + for i in (C::BLOCK_BYTES + 1)..=(2 * C::BLOCK_BYTES) { + set_and_execute_full_message::<_, C, _>( + &mut tester, + &mut harness.executor, + &mut harness.arena, + &mut rng, + C::OPCODE, + None, + Some(i), + ); + } + + let tester = tester + .build() + .load(harness) + .load_periphery(block_hasher) + .load_periphery(bitwise) + .finalize(); + tester.simple_test().expect("Verification failed"); +} + +#[test] +fn sha256_edge_test_lengths() { + sha2_edge_test_lengths::(); +} + +#[test] +fn sha512_edge_test_lengths() { + sha2_edge_test_lengths::(); +} + +#[test] +fn sha384_edge_test_lengths() { + sha2_edge_test_lengths::(); +} + +/////////////////////////////////////////////////////////////////////////////////////// +/// SANITY TESTS +/// +/// Ensure that solve functions produce the correct results. +/////////////////////////////////////////////////////////////////////////////////////// +fn execute_roundtrip_sanity_test() { + let mut rng = create_seeded_rng(); + let mut tester = VmChipTestBuilder::default(); + let TestHarness { mut harness, .. } = + create_test_harness::, C>(&mut tester); + + // let num_tests: usize = 10; + let num_tests: usize = 1; + for _ in 0..num_tests { + set_and_execute_full_message::<_, C, _>( + &mut tester, + &mut harness.executor, + &mut harness.arena, + &mut rng, + C::OPCODE, + None, + // None, + Some(0), + ); + } +} + +#[test] +fn execute_roundtrip_sanity_test_sha256() { + execute_roundtrip_sanity_test::(); +} + +#[test] +fn execute_roundtrip_sanity_test_sha512() { + execute_roundtrip_sanity_test::(); +} +#[test] +fn execute_roundtrip_sanity_test_sha384() { + execute_roundtrip_sanity_test::(); +} + +#[test] +fn sha256_solve_sanity_check() { + let input = b"Axiom is the best! Axiom is the best! Axiom is the best! Axiom is the best!"; + let output = Sha256Config::hash(input); + let expected: [u8; 32] = [ + 99, 196, 61, 185, 226, 212, 131, 80, 154, 248, 97, 108, 157, 55, 200, 226, 160, 73, 207, + 46, 245, 169, 94, 255, 42, 136, 193, 15, 40, 133, 173, 22, + ]; + assert_eq!(output, expected); +} + +#[test] +fn sha512_solve_sanity_check() { + let input = b"Axiom is the best! Axiom is the best! Axiom is the best! Axiom is the best!"; + let output = Sha512Config::hash(input); + let expected: [u8; 64] = [ + 0, 8, 195, 142, 70, 71, 97, 208, 132, 132, 243, 53, 179, 186, 8, 162, 71, 75, 126, 21, 130, + 203, 245, 126, 207, 65, 119, 60, 64, 79, 200, 2, 194, 17, 189, 137, 164, 213, 107, 197, + 152, 11, 242, 165, 146, 80, 96, 105, 249, 27, 139, 14, 244, 21, 118, 31, 94, 87, 32, 145, + 149, 98, 235, 75, + ]; + assert_eq!(output, expected); +} + +#[test] +fn sha384_solve_sanity_check() { + let input = b"Axiom is the best! Axiom is the best! Axiom is the best! Axiom is the best!"; + let output = Sha384Config::hash(input); + let expected: [u8; 48] = [ + 134, 227, 167, 229, 35, 110, 115, 174, 10, 27, 197, 116, 56, 144, 150, 36, 152, 190, 212, + 120, 26, 243, 125, 4, 2, 60, 164, 195, 218, 219, 255, 143, 240, 75, 158, 126, 102, 105, 8, + 202, 142, 240, 230, 161, 162, 152, 111, 71, + ]; + assert_eq!(output, expected); +} + +/////////////////////////////////////////////////////////////////////////////////////// +/// NEGATIVE TESTS +/// +/// This tests a soundness bug that was found at one point in our implementation. +/////////////////////////////////////////////////////////////////////////////////////// +fn negative_sha2_test_bad_final_hash() { + let mut rng = create_seeded_rng(); + let mut tester = VmChipTestBuilder::default(); + let TestHarness { + mut harness, + bitwise, + block_hasher, + } = create_test_harness::, C>(&mut tester); + + let num_ops: usize = 1; + for _ in 0..num_ops { + set_and_execute_single_block::<_, C, _>( + &mut tester, + &mut harness.executor, + &mut harness.arena, + &mut rng, + C::OPCODE, + None, + None, + ); + } + + // Set the final_hash to all zeros + let modify_trace = |trace: &mut RowMajorMatrix| { + trace.row_chunks_exact_mut(1).for_each(|row| { + let mut row_slice = row.row_slice(0).unwrap().to_vec(); + let mut cols = Sha2BlockHasherDigestColsRefMut::from::( + &mut row_slice[..C::BLOCK_HASHER_DIGEST_WIDTH], + ); + if cols.inner.flags.is_digest_row.is_one() { + for i in 0..C::HASH_WORDS { + for j in 0..C::WORD_U8S { + cols.inner.final_hash[[i, j]] = F::ZERO; + } + } + row.values.copy_from_slice(&row_slice); + } + }); + }; + + disable_debug_builder(); + let tester = tester + .build() + .load(harness) + .load_periphery_and_prank_trace(block_hasher, modify_trace) + .load_periphery(bitwise) + .finalize(); + let result = tester.simple_test(); + assert!(result.is_err(), "Expected verification to fail"); +} + +#[test] +#[should_panic] +fn negative_sha256_test_bad_final_hash() { + negative_sha2_test_bad_final_hash::(); +} + +#[test] +#[should_panic] +fn negative_sha512_test_bad_final_hash() { + negative_sha2_test_bad_final_hash::(); +} + +#[test] +#[should_panic] +fn negative_sha384_test_bad_final_hash() { + negative_sha2_test_bad_final_hash::(); +} + +// //////////////////////////////////////////////////////////////////////////////////// +// CUDA TESTS +// +// Ensure GPU tracegen is equivalent to CPU tracegen +// //////////////////////////////////////////////////////////////////////////////////// + +#[cfg(feature = "cuda")] +type Sha2GpuTestChip = GpuTestChipHarness< + F, + Sha2VmExecutor, + Sha2MainAir, + Sha2MainChipGpu, + Sha2MainChip, +>; + +#[cfg(feature = "cuda")] +struct GpuHarness { + pub main: Sha2GpuTestChip, + block_air: Sha2BlockHasherVmAir, + block_gpu: Sha2BlockHasherChipGpu, + block_cpu: Sha2BlockHasherChip, + bitwise_air: BitwiseOperationLookupAir, + bitwise_gpu: Arc>, +} + +#[cfg(feature = "cuda")] +fn create_cuda_harness(tester: &GpuChipTestBuilder) -> GpuHarness { + const GPU_MAX_INS_CAPACITY: usize = 8192; + let bitwise_bus = default_bitwise_lookup_bus(); + let dummy_bitwise_chip = Arc::new(BitwiseOperationLookupChip::::new( + bitwise_bus, + )); + + let (main_air, main_executor, main_chip) = create_harness_fields( + tester.system_port(), + dummy_bitwise_chip.clone(), + tester.dummy_memory_helper(), + tester.address_bits(), + ); + + let block_hasher_air = Sha2BlockHasherVmAir::new(bitwise_bus, SUBAIR_BUS_IDX, SHA2_BUS_IDX); + let block_hasher_chip = Sha2BlockHasherChip::new( + dummy_bitwise_chip.clone(), + tester.address_bits(), + tester.dummy_memory_helper(), + main_chip.records.clone(), + ); + + let shared_records_gpu = Arc::new(Mutex::new(None)); + let main_gpu_chip = Sha2MainChipGpu::new( + shared_records_gpu.clone(), + tester.range_checker(), + tester.bitwise_op_lookup(), + tester.address_bits() as u32, + tester.timestamp_max_bits() as u32, + ); + + let block_gpu_chip = Sha2BlockHasherChipGpu::new( + shared_records_gpu.clone(), + tester.range_checker(), + tester.bitwise_op_lookup(), + tester.address_bits() as u32, + tester.timestamp_max_bits() as u32, + ); + + let bitwise_gpu = tester.bitwise_op_lookup(); + let bitwise_air = BitwiseOperationLookupAir::new(bitwise_bus); + + GpuHarness { + main: GpuTestChipHarness::with_capacity( + main_executor, + main_air, + main_gpu_chip, + main_chip, + GPU_MAX_INS_CAPACITY, + ), + block_air: block_hasher_air, + block_gpu: block_gpu_chip, + block_cpu: block_hasher_chip, + bitwise_air, + bitwise_gpu, + } +} + +#[cfg(feature = "cuda")] +fn test_cuda_rand_sha2_multi_block() { + let mut rng = create_seeded_rng(); + let mut tester = + GpuChipTestBuilder::default().with_bitwise_op_lookup(default_bitwise_lookup_bus()); + + let mut harness = create_cuda_harness::(&tester); + + let num_ops = 70; + for _ in 1..=num_ops { + set_and_execute_full_message::<_, C, _>( + &mut tester, + &mut harness.main.executor, + &mut harness.main.dense_arena, + &mut rng, + C::OPCODE, + None, + None, + ); + } + + harness + .main + .dense_arena + .get_record_seeker::() + .transfer_to_matrix_arena(&mut harness.main.matrix_arena); + + let mut tester = tester.build(); + tester = tester.load_gpu_harness(harness.main); + tester = tester.load_and_compare( + harness.block_air, + harness.block_gpu, + (), + harness.block_cpu, + (), + ); + tester = tester.load_periphery(harness.bitwise_air, harness.bitwise_gpu); + tester.finalize().simple_test().unwrap(); +} + +#[cfg(feature = "cuda")] +#[test] +fn test_cuda_rand_sha256_multi_block() { + test_cuda_rand_sha2_multi_block::(); +} + +#[cfg(feature = "cuda")] +#[test] +fn test_cuda_rand_sha512_multi_block() { + test_cuda_rand_sha2_multi_block::(); +} + +#[cfg(feature = "cuda")] +#[test] +fn test_cuda_rand_sha384_multi_block() { + test_cuda_rand_sha2_multi_block::(); +} + +#[cfg(feature = "cuda")] +fn test_cuda_sha2_known_vectors(test_vectors: &[(&str, &str)]) { + let mut rng = create_seeded_rng(); + let mut tester = + GpuChipTestBuilder::default().with_bitwise_op_lookup(default_bitwise_lookup_bus()); + + let mut harness = create_cuda_harness::(&tester); + + for (input, expected_hex) in test_vectors.iter() { + let input = Vec::from_hex(input).unwrap(); + let expected = Vec::from_hex(expected_hex).unwrap(); + // Sanity-check the expected digest matches the config’s hash. + assert_eq!(C::hash(&input).as_slice(), expected.as_slice()); + set_and_execute_full_message::<_, C, _>( + &mut tester, + &mut harness.main.executor, + &mut harness.main.dense_arena, + &mut rng, + C::OPCODE, + Some(&input), + Some(input.len()), + ); + } + // No block-hasher arena needed; GPU block chip ignores the arena input. + harness + .main + .dense_arena + .get_record_seeker::() + .transfer_to_matrix_arena(&mut harness.main.matrix_arena); + + let mut tester = tester.build(); + tester = tester.load_gpu_harness(harness.main); + tester = tester.load_and_compare( + harness.block_air, + harness.block_gpu, + (), + harness.block_cpu, + (), + ); + tester = tester.load_periphery(harness.bitwise_air, harness.bitwise_gpu); + tester.finalize().simple_test().unwrap(); +} + +#[cfg(feature = "cuda")] +#[test] +fn test_cuda_sha256_known_vectors() { + let test_vectors = [ + ("", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"), + ( + "98c1c0bdb7d5fea9a88859f06c6c439f", + "b6b2c9c9b6f30e5c66c977f1bd7ad97071bee739524aecf793384890619f2b05", + ), + ("5b58f4163e248467cc1cd3eecafe749e8e2baaf82c0f63af06df0526347d7a11327463c115210a46b6740244eddf370be89c", "ac0e25049870b91d78ef6807bb87fce4603c81abd3c097fba2403fd18b6ce0b7"), + ("9ad198539e3160194f38ac076a782bd5210a007560d1fce9ef78f8a4a5e4d78c6b96c250cff3520009036e9c6087d5dab587394edda862862013de49a12072485a6c01165ec0f28ffddf1873fbd53e47fcd02fb6a5ccc9622d5588a92429c663ce298cb71b50022fc2ec4ba9f5bbd250974e1a607b165fee16e8f3f2be20d7348b91a2f518ce928491900d56d9f86970611580350cee08daea7717fe28a73b8dcfdea22a65ed9f5a09198de38e4e4f2cc05b0ba3dd787a5363ab6c9f39dcb66c1a29209b1d6b1152769395df8150b4316658ea6ab19af94903d643fcb0ae4d598035ebe73c8b1b687df1ab16504f633c929569c6d0e5fae6eea43838fbc8ce2c2b43161d0addc8ccf945a9c4e06294e56a67df0000f561f61b630b1983ba403e775aaeefa8d339f669d1e09ead7eae979383eda983321e1743e5404b4b328da656de79ff52d179833a6bd5129f49432d74d001996c37c68d9ab49fcff8061d193576f396c20e1f0d9ee83a51290ba60efa9c3cb2e15b756321a7ca668cdbf63f95ec33b1c450aa100101be059dc00077245b25a6a66698dee81953ed4a606944076e2858b1420de0095a7f60b08194d6d9a997009d345c71f63a7034b976e409af8a9a040ac7113664609a7adedb76b2fadf04b0348392a1650526eb2a4d6ed5e4bbcda8aabc8488b38f4f5d9a398103536bb8250ed82a9b9825f7703c263f9e", "080ad71239852124fc26758982090611b9b19abf22d22db3a57f67a06e984a23") + ]; + test_cuda_sha2_known_vectors::(&test_vectors); +} + +#[cfg(feature = "cuda")] +#[test] +fn test_cuda_sha512_known_vectors() { + let test_vectors = [ + ( + "", + "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e", + ), + ( + "98c1c0bdb7d5fea9a88859f06c6c439f", + "eb576959c531f116842c0cc915a29c8f71d7a285c894c349b83469002ef093d51f9f14ce4248488bff143025e47ed27c12badb9cd43779cb147408eea062d583" + ), + ( + "9ad198539e3160194f38ac076a782bd5210a007560d1fce9ef78f8a4a5e4d78c6b96c250cff3520009036e9c6087d5dab587394edda862862013de49a12072485a6c01165ec0f28ffddf1873fbd53e47fcd02fb6a5ccc9622d5588a92429c663ce298cb71b50022fc2ec4ba9f5bbd250974e1a607b165fee16e8f3f2be20d7348b91a2f518ce928491900d56d9f86970611580350cee08daea7717fe28a73b8dcfdea22a65ed9f5a09198de38e4e4f2cc05b0ba3dd787a5363ab6c9f39dcb66c1a29209b1d6b1152769395df8150b4316658ea6ab19af94903d643fcb0ae4d598035ebe73c8b1b687df1ab16504f633c929569c6d0e5fae6eea43838fbc8ce2c2b43161d0addc8ccf945a9c4e06294e56a67df0000f561f61b630b1983ba403e775aaeefa8d339f669d1e09ead7eae979383eda983321e1743e5404b4b328da656de79ff52d179833a6bd5129f49432d74d001996c37c68d9ab49fcff8061d193576f396c20e1f0d9ee83a51290ba60efa9c3cb2e15b756321a7ca668cdbf63f95ec33b1c450aa100101be059dc00077245b25a6a66698dee81953ed4a606944076e2858b1420de0095a7f60b08194d6d9a997009d345c71f63a7034b976e409af8a9a040ac7113664609a7adedb76b2fadf04b0348392a1650526eb2a4d6ed5e4bbcda8aabc8488b38f4f5d9a398103536bb8250ed82a9b9825f7703c263f9e", + "8d215ee6dc26757c210db0dd00c1c6ed16cc34dbd4bb0fa10c1edb6b62d5ab16aea88c881001b173d270676daf2d6381b5eab8711fa2f5589c477c1d4b84774f" + ), + ]; + test_cuda_sha2_known_vectors::(&test_vectors); +} + +#[cfg(feature = "cuda")] +#[test] +fn test_cuda_sha384_known_vectors() { + let test_vectors = [ + ( + "", + "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b", + ), + ( + "98c1c0bdb7d5fea9a88859f06c6c439f", + "63e3061aab01f335ea3a4e617b9d14af9b63a5240229164ee962f6d5335ff25f0f0bf8e46723e83c41b9d17413b6a3c7", + ), + ( + "9ad198539e3160194f38ac076a782bd5210a007560d1fce9ef78f8a4a5e4d78c6b96c250cff3520009036e9c6087d5dab587394edda862862013de49a12072485a6c01165ec0f28ffddf1873fbd53e47fcd02fb6a5ccc9622d5588a92429c663ce298cb71b50022fc2ec4ba9f5bbd250974e1a607b165fee16e8f3f2be20d7348b91a2f518ce928491900d56d9f86970611580350cee08daea7717fe28a73b8dcfdea22a65ed9f5a09198de38e4e4f2cc05b0ba3dd787a5363ab6c9f39dcb66c1a29209b1d6b1152769395df8150b4316658ea6ab19af94903d643fcb0ae4d598035ebe73c8b1b687df1ab16504f633c929569c6d0e5fae6eea43838fbc8ce2c2b43161d0addc8ccf945a9c4e06294e56a67df0000f561f61b630b1983ba403e775aaeefa8d339f669d1e09ead7eae979383eda983321e1743e5404b4b328da656de79ff52d179833a6bd5129f49432d74d001996c37c68d9ab49fcff8061d193576f396c20e1f0d9ee83a51290ba60efa9c3cb2e15b756321a7ca668cdbf63f95ec33b1c450aa100101be059dc00077245b25a6a66698dee81953ed4a606944076e2858b1420de0095a7f60b08194d6d9a997009d345c71f63a7034b976e409af8a9a040ac7113664609a7adedb76b2fadf04b0348392a1650526eb2a4d6ed5e4bbcda8aabc8488b38f4f5d9a398103536bb8250ed82a9b9825f7703c263f9e", + "904a90010d772a904a35572fdd4bdf1dd253742e47872c8a18e2255f66fa889e44781e65487a043f435daa53c496a53e", + ), + ]; + test_cuda_sha2_known_vectors::(&test_vectors); +} + +// GPU edge-case length tests mirroring the CPU suite. +#[cfg(feature = "cuda")] +fn cuda_sha2_edge_test_lengths() { + let mut rng = create_seeded_rng(); + let mut tester = + GpuChipTestBuilder::default().with_bitwise_op_lookup(default_bitwise_lookup_bus()); + + let mut harness = create_cuda_harness::(&tester); + + // check every possible input length modulo block size + for i in (C::BLOCK_BYTES + 1)..=(2 * C::BLOCK_BYTES) { + set_and_execute_full_message::<_, C, _>( + &mut tester, + &mut harness.main.executor, + &mut harness.main.dense_arena, + &mut rng, + C::OPCODE, + None, + Some(i), + ); + } + + harness + .main + .dense_arena + .get_record_seeker::() + .transfer_to_matrix_arena(&mut harness.main.matrix_arena); + + let mut tester = tester.build(); + tester = tester.load_gpu_harness(harness.main); + tester = tester.load_and_compare( + harness.block_air, + harness.block_gpu, + (), + harness.block_cpu, + (), + ); + tester = tester.load_periphery(harness.bitwise_air, harness.bitwise_gpu); + tester.finalize().simple_test().unwrap(); +} + +#[cfg(feature = "cuda")] +#[test] +fn test_cuda_sha256_edge_test_lengths() { + cuda_sha2_edge_test_lengths::(); +} + +#[cfg(feature = "cuda")] +#[test] +fn test_cuda_sha512_edge_test_lengths() { + cuda_sha2_edge_test_lengths::(); +} + +#[cfg(feature = "cuda")] +#[test] +fn test_cuda_sha384_edge_test_lengths() { + cuda_sha2_edge_test_lengths::(); +} diff --git a/extensions/sha2/circuit/src/sha2_chips/trace.rs b/extensions/sha2/circuit/src/sha2_chips/trace.rs new file mode 100644 index 0000000000..4749a839ef --- /dev/null +++ b/extensions/sha2/circuit/src/sha2_chips/trace.rs @@ -0,0 +1,320 @@ +use std::{ + borrow::BorrowMut, + mem::transmute, + slice::{from_raw_parts, from_raw_parts_mut}, +}; + +use openvm_circuit::{ + arch::{ + CustomBorrow, ExecutionError, MultiRowLayout, MultiRowMetadata, PreflightExecutor, + RecordArena, SizedRecord, VmStateMut, + }, + system::memory::{ + offline_checker::{MemoryReadAuxRecord, MemoryWriteBytesAuxRecord}, + online::TracingMemory, + }, +}; +use openvm_circuit_primitives::AlignedBytesBorrow; +use openvm_instructions::{ + instruction::Instruction, + program::DEFAULT_PC_STEP, + riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, + LocalOpcode, +}; +use openvm_rv32im_circuit::adapters::{tracing_read, tracing_write}; +use openvm_sha2_air::{Sha256Config, Sha2Variant, Sha384Config, Sha512Config}; +use openvm_stark_backend::p3_field::PrimeField32; + +use crate::{ + Sha2Config, Sha2MainChipConfig, Sha2VmExecutor, SHA2_READ_SIZE, SHA2_REGISTER_READS, + SHA2_WRITE_SIZE, +}; + +#[derive(Clone, Copy)] +pub struct Sha2Metadata { + pub variant: Sha2Variant, +} + +impl MultiRowMetadata for Sha2Metadata { + #[inline(always)] + fn get_num_rows(&self) -> usize { + // The size of the record arena will be height * Sha2MainAir::width() * num_rows. + // We will not use the record arena's buffer for either chip's trace, so we just + // need to ensure that the record arena is large enough to store all the records. + // The size of Sha2RecordMut (in bytes) is less than Sha2MainAir::width() * size_of::(), + // for all SHA-2 variants. Therefore, we can set num_rows = 1. + 1 + } +} + +pub(crate) type Sha2RecordLayout = MultiRowLayout; + +#[repr(C)] +#[derive(AlignedBytesBorrow, Debug, Clone)] +pub struct Sha2RecordHeader { + pub variant: Sha2Variant, + pub from_pc: u32, + pub timestamp: u32, + pub dst_reg_ptr: u32, + pub state_reg_ptr: u32, + pub input_reg_ptr: u32, + pub dst_ptr: u32, + pub state_ptr: u32, + pub input_ptr: u32, + + pub register_reads_aux: [MemoryReadAuxRecord; SHA2_REGISTER_READS], +} + +pub struct Sha2RecordMut<'a> { + pub inner: &'a mut Sha2RecordHeader, + + pub message_bytes: &'a mut [u8], + pub prev_state: &'a mut [u8], // little-endian words + pub new_state: &'a mut [u8], // little-endian words + + pub input_reads_aux: &'a mut [MemoryReadAuxRecord], + pub state_reads_aux: &'a mut [MemoryReadAuxRecord], + pub write_aux: &'a mut [MemoryWriteBytesAuxRecord], +} + +impl<'a> CustomBorrow<'a, Sha2RecordMut<'a>, Sha2RecordLayout> for [u8] { + fn custom_borrow(&'a mut self, layout: Sha2RecordLayout) -> Sha2RecordMut<'a> { + // SAFETY: + // - Caller guarantees through the layout that self has sufficient length for all splits and + // constants are guaranteed <= self.len() by layout precondition + + let (header_slice, rest) = + unsafe { self.split_at_mut_unchecked(size_of::()) }; + let record_header: &mut Sha2RecordHeader = header_slice.borrow_mut(); + + let dims = Sha2PreComputeDims::new(layout.metadata.variant); + + let (message_bytes, rest) = unsafe { rest.split_at_mut_unchecked(dims.input_size) }; + let (prev_state, rest) = unsafe { rest.split_at_mut_unchecked(dims.state_size) }; + let (new_state, rest) = unsafe { rest.split_at_mut_unchecked(dims.state_size) }; + + let (input_reads_aux, rest) = unsafe { align_to_mut_at(rest, dims.input_reads) }; + let (state_reads_aux, rest) = unsafe { align_to_mut_at(rest, dims.state_reads) }; + let (write_aux, _) = unsafe { align_to_mut_at(rest, dims.state_writes) }; + + Sha2RecordMut { + inner: record_header, + message_bytes, + prev_state, + new_state, + input_reads_aux, + state_reads_aux, + write_aux, + } + } + + unsafe fn extract_layout(&self) -> Sha2RecordLayout { + let (variant, _) = unsafe { align_to_at(self, 1) }; + let variant = variant[0]; + Sha2RecordLayout { + metadata: Sha2Metadata { variant }, + } + } +} + +unsafe fn align_to_mut_at(slice: &mut [u8], offset: usize) -> (&mut [T], &mut [u8]) { + let (_, items, rest) = unsafe { slice.align_to_mut::() }; + let (items, items_rest) = unsafe { items.split_at_mut_unchecked(offset) }; + let rest = unsafe { + let items_rest: &mut [u8] = transmute(items_rest); + from_raw_parts_mut( + items_rest.as_mut_ptr(), + items_rest.len() * size_of::() + rest.len(), + ) + }; + (items, rest) +} + +unsafe fn align_to_at(slice: &[u8], offset: usize) -> (&[T], &[u8]) { + let (_, items, rest) = unsafe { slice.align_to::() }; + let (items, items_rest) = unsafe { items.split_at_unchecked(offset) }; + let rest = unsafe { + let items_rest: &[u8] = transmute(items_rest); + from_raw_parts( + items_rest.as_ptr(), + items_rest.len() * size_of::() + rest.len(), + ) + }; + (items, rest) +} + +impl SizedRecord for Sha2RecordMut<'_> { + fn size(layout: &Sha2RecordLayout) -> usize { + let header_size = size_of::(); + let dims = Sha2PreComputeDims::new(layout.metadata.variant); + let mut total_len = header_size + + dims.input_size // input + + dims.state_size // prev_state + + dims.state_size; // new_state + + total_len = total_len.next_multiple_of(align_of::()); + total_len += dims.input_reads * size_of::(); + + total_len = total_len.next_multiple_of(align_of::()); + total_len += dims.state_reads * size_of::(); + + total_len = + total_len.next_multiple_of(align_of::>()); + total_len += dims.state_writes * size_of::>(); + + total_len + } + + fn alignment(_layout: &Sha2RecordLayout) -> usize { + align_of::() // 4-byte alignment + } +} + +// This is needed in CustomBorrow trait to convert the Sha2Variant that we read from the buffer +// into appropriate dimensions for the record. +struct Sha2PreComputeDims { + state_size: usize, + input_size: usize, + input_reads: usize, + state_reads: usize, + state_writes: usize, +} + +impl Sha2PreComputeDims { + fn new(variant: Sha2Variant) -> Self { + match variant { + Sha2Variant::Sha256 => Self { + state_size: Sha256Config::STATE_BYTES, + input_size: Sha256Config::BLOCK_BYTES, + input_reads: Sha256Config::BLOCK_READS, + state_reads: Sha256Config::STATE_READS, + state_writes: Sha256Config::STATE_WRITES, + }, + Sha2Variant::Sha512 => Self { + state_size: Sha512Config::STATE_BYTES, + input_size: Sha512Config::BLOCK_BYTES, + input_reads: Sha512Config::BLOCK_READS, + state_reads: Sha512Config::STATE_READS, + state_writes: Sha512Config::STATE_WRITES, + }, + Sha2Variant::Sha384 => Self { + state_size: Sha384Config::STATE_BYTES, + input_size: Sha384Config::BLOCK_BYTES, + input_reads: Sha384Config::BLOCK_READS, + state_reads: Sha384Config::STATE_READS, + state_writes: Sha384Config::STATE_WRITES, + }, + } + } +} + +impl PreflightExecutor for Sha2VmExecutor +where + F: PrimeField32, + // for<'buf> RA: RecordArena<'buf, Sha2RecordLayout, Sha2RecordMut<'buf>>, + for<'buf> RA: RecordArena<'buf, Sha2RecordLayout, Sha2RecordMut<'buf>>, +{ + fn get_opcode_name(&self, _: usize) -> String { + format!("{:?}", C::OPCODE) + } + + fn execute( + &self, + state: VmStateMut, + instruction: &Instruction, + ) -> Result<(), ExecutionError> { + let &Instruction { + opcode, + a, + b, + c, + d, + e, + .. + } = instruction; + debug_assert_eq!(opcode, C::OPCODE.global_opcode()); + debug_assert_eq!(d.as_canonical_u32(), RV32_REGISTER_AS); + debug_assert_eq!(e.as_canonical_u32(), RV32_MEMORY_AS); + + let record = state.ctx.alloc(Sha2RecordLayout::new(Sha2Metadata { + variant: C::VARIANT, + })); + + record.inner.variant = C::VARIANT; + record.inner.from_pc = *state.pc; + record.inner.timestamp = state.memory.timestamp(); + record.inner.dst_reg_ptr = a.as_canonical_u32(); + record.inner.state_reg_ptr = b.as_canonical_u32(); + record.inner.input_reg_ptr = c.as_canonical_u32(); + + record.inner.dst_ptr = u32::from_le_bytes(tracing_read::( + state.memory, + RV32_REGISTER_AS, + record.inner.dst_reg_ptr, + &mut record.inner.register_reads_aux[0].prev_timestamp, + )); + record.inner.state_ptr = u32::from_le_bytes(tracing_read::( + state.memory, + RV32_REGISTER_AS, + record.inner.state_reg_ptr, + &mut record.inner.register_reads_aux[1].prev_timestamp, + )); + record.inner.input_ptr = u32::from_le_bytes(tracing_read::( + state.memory, + RV32_REGISTER_AS, + record.inner.input_reg_ptr, + &mut record.inner.register_reads_aux[2].prev_timestamp, + )); + + debug_assert!( + record.inner.dst_ptr as usize + C::STATE_BYTES <= (1 << self.pointer_max_bits) + ); + debug_assert!( + record.inner.state_ptr as usize + C::STATE_BYTES <= (1 << self.pointer_max_bits) + ); + debug_assert!( + record.inner.input_ptr as usize + C::BLOCK_BYTES <= (1 << self.pointer_max_bits) + ); + + for idx in 0..C::BLOCK_READS { + let read = tracing_read::( + state.memory, + RV32_MEMORY_AS, + record.inner.input_ptr + (idx * SHA2_READ_SIZE) as u32, + &mut record.input_reads_aux[idx].prev_timestamp, + ); + record.message_bytes[idx * SHA2_READ_SIZE..(idx + 1) * SHA2_READ_SIZE] + .copy_from_slice(&read); + } + + for idx in 0..C::STATE_READS { + let read = tracing_read::( + state.memory, + RV32_MEMORY_AS, + record.inner.state_ptr + (idx * SHA2_READ_SIZE) as u32, + &mut record.state_reads_aux[idx].prev_timestamp, + ); + record.prev_state[idx * SHA2_READ_SIZE..(idx + 1) * SHA2_READ_SIZE] + .copy_from_slice(&read); + } + + record.new_state.copy_from_slice(record.prev_state); + C::compress(record.new_state, record.message_bytes); + + for idx in 0..C::STATE_WRITES { + tracing_write::( + state.memory, + RV32_MEMORY_AS, + record.inner.dst_ptr + (idx * SHA2_WRITE_SIZE) as u32, + record.new_state[idx * SHA2_WRITE_SIZE..(idx + 1) * SHA2_WRITE_SIZE] + .try_into() + .unwrap(), + &mut record.write_aux[idx].prev_timestamp, + &mut record.write_aux[idx].prev_data, + ); + } + + *state.pc = state.pc.wrapping_add(DEFAULT_PC_STEP); + Ok(()) + } +} diff --git a/extensions/sha256/guest/Cargo.toml b/extensions/sha2/guest/Cargo.toml similarity index 69% rename from extensions/sha256/guest/Cargo.toml rename to extensions/sha2/guest/Cargo.toml index e9d28292b8..1c6503002e 100644 --- a/extensions/sha256/guest/Cargo.toml +++ b/extensions/sha2/guest/Cargo.toml @@ -1,9 +1,9 @@ [package] -name = "openvm-sha256-guest" +name = "openvm-sha2-guest" version.workspace = true authors.workspace = true edition.workspace = true -description = "Guest extension for Sha256" +description = "Guest extension for SHA-2" [dependencies] openvm-platform = { workspace = true } diff --git a/extensions/sha2/guest/src/lib.rs b/extensions/sha2/guest/src/lib.rs new file mode 100644 index 0000000000..d2b9c1f585 --- /dev/null +++ b/extensions/sha2/guest/src/lib.rs @@ -0,0 +1,155 @@ +#![no_std] + +#[cfg(target_os = "zkvm")] +use openvm_platform::alloc::AlignedBuf; + +/// This is custom-0 defined in RISC-V spec document +pub const OPCODE: u8 = 0x0b; +pub const SHA2_FUNCT3: u8 = 0b100; + +// There is no Sha384 enum variant because the SHA-384 compression function is +// the same as the SHA-512 compression function. +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +#[repr(u8)] +pub enum Sha2BaseFunct7 { + Sha256 = 0x1, + Sha512 = 0x2, +} + +/// zkvm native implementation of sha256 compression function +/// # Safety +/// +/// The VM accepts the previous hash state and the next block of input, and writes the +/// new hash state. +/// - `state` must point to a buffer of at least 32 bytes, storing the previous hash state as 8 +/// 32-bit words in little-endian order +/// - `input` must point to a buffer of at least 64 bytes +/// - `output` must point to a buffer of at least 32 bytes. It will be filled with the new hash +/// state as 8 32-bit words in little-endian order +/// +/// [`sha2-256`]: https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf +#[cfg(target_os = "zkvm")] +#[inline(always)] +#[no_mangle] +pub extern "C" fn zkvm_sha256_impl(state: *const u8, input: *const u8, output: *mut u8) { + // SAFETY: we handle all cases where `prev_state`, `input`, or `output` are not aligned to 4 + // bytes. + + // The minimum alignment required for the buffers + const MIN_ALIGN: usize = 4; + unsafe { + let state_is_aligned = state as usize % MIN_ALIGN == 0; + let input_is_aligned = input as usize % MIN_ALIGN == 0; + let output_is_aligned = output as usize % MIN_ALIGN == 0; + + let state_ptr = if state_is_aligned { + state + } else { + AlignedBuf::new(state, 32, MIN_ALIGN).ptr + }; + + let input_ptr = if input_is_aligned { + input + } else { + AlignedBuf::new(input, 64, MIN_ALIGN).ptr + }; + + let output_ptr = if output_is_aligned { + output + } else { + AlignedBuf::uninit(32, MIN_ALIGN).ptr + }; + + __native_sha256_compress(state_ptr, input_ptr, output_ptr); + + if !output_is_aligned { + core::ptr::copy_nonoverlapping(output_ptr, output, 32); + } + } +} + +/// zkvm native implementation of sha512 compression function +/// # Safety +/// +/// The VM accepts the previous hash state and the next block of input, and writes the +/// new hash state. +/// - `state` must point to a buffer of at least 64 bytes, storing the previous hash state as 8 +/// 64-bit words in little-endian order +/// - `input` must point to a buffer of at least 128 bytes +/// - `output` must point to a buffer of at least 64 bytes. It will be filled with the new hash +/// state as 8 64-bit words in little-endian order +/// +/// [`sha2-512`]: https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf +#[cfg(target_os = "zkvm")] +#[inline(always)] +#[no_mangle] +pub extern "C" fn zkvm_sha512_impl(state: *const u8, input: *const u8, output: *mut u8) { + // SAFETY: we handle all cases where `prev_state`, `input`, or `output` are not aligned to 4 + // bytes. + + // The minimum alignment required for the buffers + const MIN_ALIGN: usize = 4; + unsafe { + let state_is_aligned = state as usize % MIN_ALIGN == 0; + let input_is_aligned = input as usize % MIN_ALIGN == 0; + let output_is_aligned = output as usize % MIN_ALIGN == 0; + + let state_ptr = if state_is_aligned { + state + } else { + AlignedBuf::new(state, 64, MIN_ALIGN).ptr + }; + + let input_ptr = if input_is_aligned { + input + } else { + AlignedBuf::new(input, 128, MIN_ALIGN).ptr + }; + + let output_ptr = if output_is_aligned { + output + } else { + AlignedBuf::uninit(64, MIN_ALIGN).ptr + }; + + __native_sha512_compress(state_ptr, input_ptr, output_ptr); + + if !output_is_aligned { + core::ptr::copy_nonoverlapping(output_ptr, output, 64); + } + } +} + +/// sha256 compression function intrinsic binding +/// +/// # Safety +/// +/// The VM accepts the previous hash state and the next block of input, and writes the +/// 32-byte hash. +/// - `prev_state` must point to a buffer of at least 32 bytes, storing the previous hash state as 8 +/// 32-bit words in little-endian order +/// - `input` must point to a buffer of at least 64 bytes +/// - `output` must point to a buffer of at least 32 bytes. It will be filled with the new hash +/// state as 8 32-bit words in little-endian order +#[cfg(target_os = "zkvm")] +#[inline(always)] +fn __native_sha256_compress(prev_state: *const u8, input: *const u8, output: *mut u8) { + openvm_platform::custom_insn_r!(opcode = OPCODE, funct3 = SHA2_FUNCT3, funct7 = Sha2BaseFunct7::Sha256 as u8, rd = In output, rs1 = In prev_state, rs2 = In input); +} + +/// sha512 intrinsic binding +/// +/// # Safety +/// +/// The VM accepts the previous hash state and the next block of input, and writes the +/// 64-byte hash. +/// - `prev_state` must point to a buffer of at least 32 bytes, storing the previous hash state as 8 +/// 64-bit words in little-endian order +/// - `input` must point to a buffer of at least 128 bytes +/// - `output` must point to a buffer of at least 64 bytes. It will be filled with the new hash +/// state as 8 64-bit words in little-endian order +#[cfg(target_os = "zkvm")] +#[inline(always)] +fn __native_sha512_compress(prev_state: *const u8, input: *const u8, output: *mut u8) { + openvm_platform::custom_insn_r!(opcode = OPCODE, funct3 = SHA2_FUNCT3, funct7 = Sha2BaseFunct7::Sha512 as u8, rd = In output, rs1 = In prev_state, rs2 = In input); +} diff --git a/extensions/sha256/transpiler/Cargo.toml b/extensions/sha2/transpiler/Cargo.toml similarity index 73% rename from extensions/sha256/transpiler/Cargo.toml rename to extensions/sha2/transpiler/Cargo.toml index 933859f3a8..9eff76a3db 100644 --- a/extensions/sha256/transpiler/Cargo.toml +++ b/extensions/sha2/transpiler/Cargo.toml @@ -1,15 +1,15 @@ [package] -name = "openvm-sha256-transpiler" +name = "openvm-sha2-transpiler" version.workspace = true authors.workspace = true edition.workspace = true -description = "Transpiler extension for sha256" +description = "Transpiler extension for SHA-2" [dependencies] openvm-stark-backend = { workspace = true } openvm-instructions = { workspace = true } openvm-transpiler = { workspace = true } rrs-lib = { workspace = true } -openvm-sha256-guest = { workspace = true } +openvm-sha2-guest = { workspace = true } openvm-instructions-derive = { workspace = true } strum = { workspace = true } diff --git a/extensions/sha2/transpiler/src/lib.rs b/extensions/sha2/transpiler/src/lib.rs new file mode 100644 index 0000000000..0110d869c3 --- /dev/null +++ b/extensions/sha2/transpiler/src/lib.rs @@ -0,0 +1,58 @@ +use openvm_instructions::{riscv::RV32_MEMORY_AS, LocalOpcode}; +use openvm_instructions_derive::LocalOpcode; +use openvm_sha2_guest::{Sha2BaseFunct7, OPCODE, SHA2_FUNCT3}; +use openvm_stark_backend::p3_field::PrimeField32; +use openvm_transpiler::{util::from_r_type, TranspilerExtension, TranspilerOutput}; +use rrs_lib::instruction_formats::RType; +use strum::{EnumCount, EnumIter, FromRepr}; + +// There is no SHA384 opcode because the SHA-384 compression function is +// the same as the SHA-512 compression function. +#[derive( + Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, EnumCount, EnumIter, FromRepr, LocalOpcode, +)] +#[opcode_offset = 0x320] +#[repr(usize)] +pub enum Rv32Sha2Opcode { + SHA256, + SHA512, +} + +#[derive(Default)] +pub struct Sha2TranspilerExtension; + +impl TranspilerExtension for Sha2TranspilerExtension { + fn process_custom(&self, instruction_stream: &[u32]) -> Option> { + if instruction_stream.is_empty() { + return None; + } + let instruction_u32 = instruction_stream[0]; + let opcode = (instruction_u32 & 0x7f) as u8; + let funct3 = ((instruction_u32 >> 12) & 0b111) as u8; + + if (opcode, funct3) != (OPCODE, SHA2_FUNCT3) { + return None; + } + let dec_insn = RType::new(instruction_u32); + + if dec_insn.funct7 == Sha2BaseFunct7::Sha256 as u32 { + let instruction = from_r_type( + Rv32Sha2Opcode::SHA256.global_opcode().as_usize(), + RV32_MEMORY_AS as usize, + &dec_insn, + true, + ); + Some(TranspilerOutput::one_to_one(instruction)) + } else if dec_insn.funct7 == Sha2BaseFunct7::Sha512 as u32 { + let instruction = from_r_type( + Rv32Sha2Opcode::SHA512.global_opcode().as_usize(), + RV32_MEMORY_AS as usize, + &dec_insn, + true, + ); + Some(TranspilerOutput::one_to_one(instruction)) + } else { + None + } + } +} diff --git a/extensions/sha256/circuit/README.md b/extensions/sha256/circuit/README.md deleted file mode 100644 index 1e794cd35c..0000000000 --- a/extensions/sha256/circuit/README.md +++ /dev/null @@ -1,93 +0,0 @@ -# SHA256 VM Extension - -This crate contains the circuit for the SHA256 VM extension. - -## SHA-256 Algorithm Summary - -See the [FIPS standard](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf), in particular, section 6.2 for reference. - -In short the SHA-256 algorithm works as follows. -1. Pad the message to 512 bits and split it into 512-bit 'blocks'. -2. Initialize a hash state consisting of eight 32-bit words. -3. For each block, - 1. split the message into 16 32-bit words and produce 48 more 'message schedule' words based on them. - 2. apply 64 'rounds' to update the hash state based on the message schedule. - 3. add the previous block's final hash state to the current hash state (modulo `2^32`). -4. The output is the final hash state - -## Design Overview - -This chip produces an AIR that consists of 17 rows for each block (512 bits) in the message, and no more rows. -The first 16 rows of each block are called 'round rows', and each of them represents four rounds of the SHA-256 algorithm. -Each row constrains updates to the working variables on each round, and it also constrains the message schedule words based on previous rounds. -The final row is called a 'digest row' and it produces a final hash for the block, computed as the sum of the working variables and the previous block's final hash. - -Note that this chip only supports messages of length less than `2^29` bytes. - -### Storing working variables - -One optimization is that we only keep track of the `a` and `e` working variables. -It turns out that if we have their values over four consecutive rounds, we can reconstruct all eight variables at the end of the four rounds. -This is because there is overlap between the values of the working variables in adjacent rounds. -If the state is visualized as an array, `s_0 = [a, b, c, d, e, f, g, h]`, then the new state, `s_1`, after one round is produced by a right-shift and an addition. -More formally, -``` -s_1 = (s_0 >> 1) + [T_1 + T_2, 0, 0, 0, T_1, 0, 0, 0] - = [0, a, b, c, d, e, f, g] + [T_1 + T_2, 0, 0, 0, T_1, 0, 0, 0] - = [T_1 + T_2, a, b, c, d + T_1, e, f, g] -``` -where `T_1` and `T_2` are certain functions of the working variables and message data (see the FIPS spec). -So if `a_i` and `e_i` denote the values of `a` and `e` after the `i`th round, for `0 <= i < 4`, then the state `s_3` after the fourth round can be written as `s_3 = [a_3, a_2, a_1, a_0, e_3, e_2, e_1, e_0]`. - -### Message schedule constraints - -The algorithm for computing the message schedule involves message schedule words from 16 rounds ago. -Since we can only constrain two rows at a time, we cannot access data from more than four rounds ago for the first round in each row. -So, we maintain intermediate values that we call `intermed_4`, `intermed_8` and `intermed_12`, where `intermed_i = w_i + sig_0(w_{i+1})` where `w_i` is the value of `w` from `i` rounds ago and `sig_0` denotes the `sigma_0` function from the FIPS spec. -Since we can reliably constrain values from four rounds ago, we can build up `intermed_16` from these values, which is needed for computing the message schedule. - -### Note about `is_last_block` - -The last block of every message should have the `is_last_block` flag set to `1`. -Note that `is_last_block` is not constrained to be true for the last block of every message, instead it *defines* what the last block of a message is. -For instance, if we produce an air with 10 blocks and only the last block has `is_last_block = 1` then the constraints will interpret it as a single message of length 10 blocks. -If, however, we set `is_last_block` to true for the 6th block, the trace will be interpreted as hashing two messages, each of length 5 blocks. - -Note that we do constrain, however, that the very last block of the trace has `is_last_block = 1`. - -### Dummy values - -Some constraints have degree three, and so we cannot restrict them to particular rows due to the limitation of the maximum constraint degree. -We must enforce them on all rows, and in order to ensure they hold on the remaining rows we must fill in some cells with appropriate dummy values. -We use this trick in several places in this chip. - -### Block index counter variables - -There are two "block index" counter variables in each row of the air named `global_block_idx` and `local_block_idx`. -Both of these variables take on the same value on all 17 rows in a block. - -The `global_block_idx` is the index of the block in the entire trace. -The very first 17 rows in the trace will have `global_block_idx = 1` and the counter will increment by 1 between blocks. -The padding rows will all have `global_block_idx = 0`. -The `global_block_idx` is used in interaction constraints to constrain the value of `hash` between blocks. - -The `local_block_idx` is the index of the block in the current message. -It starts at 0 for the first block of each message and increments by 1 for each block. -The `local_block_idx` is reset to 0 after each message. -The padding rows will all have `local_block_idx = 0`. -The `local_block_idx` is used to calculate the length of the message processed so far when the first padding row is encountered. - -### VM air vs SubAir - -The SHA-256 VM extension chip uses the `Sha256Air` SubAir to help constrain the SHA-256 hash. -The VM extension air constrains the correctness of the SHA message padding, while the SubAir adds all other constraints related to the hash algorithm. -The VM extension air also constrains memory reads and writes. - -### A gotcha about padding rows - -There are two senses of the word padding used in the context of this chip and this can be confusing. -First, we use padding to refer to the extra bits added to the message that is input to the SHA-256 algorithm in order to make the input's length a multiple of 512 bits. -So, we may use the term 'padding rows' to refer to round rows that correspond to the padded bits of a message (as in `Sha256VmAir::eval_padding_row`). -Second, the dummy rows that are added to the trace to make the trace height a power of 2 are also called padding rows (see the `is_padding_row` flag). -In the SubAir, padding row probably means dummy row. -In the VM air, it probably refers to SHA-256 padding. \ No newline at end of file diff --git a/extensions/sha256/circuit/cuda/src/sha256.cu b/extensions/sha256/circuit/cuda/src/sha256.cu deleted file mode 100644 index d1939a8c9a..0000000000 --- a/extensions/sha256/circuit/cuda/src/sha256.cu +++ /dev/null @@ -1,447 +0,0 @@ -#include "launcher.cuh" -#include "primitives/constants.h" -#include "primitives/trace_access.h" -#include "sha256-air/columns.cuh" -#include "sha256-air/tracegen.cuh" -#include "sha256-air/utils.cuh" -#include "system/memory/controller.cuh" -#include "system/memory/offline_checker.cuh" -#include - -using namespace riscv; -using namespace sha256; - -__device__ inline void write_round_padding_flags_encoder( - RowSlice row, - const Encoder &padding_encoder, - uint32_t flag_idx -) { - RowSlice pad_flags = row.slice_from(COL_INDEX(Sha256VmRoundCols, control.pad_flags)); - padding_encoder.write_flag_pt(pad_flags, flag_idx); -} - -__device__ inline void write_digest_padding_flags_encoder( - RowSlice row, - const Encoder &padding_encoder, - uint32_t flag_idx -) { - RowSlice pad_flags = row.slice_from(COL_INDEX(Sha256VmDigestCols, control.pad_flags)); - padding_encoder.write_flag_pt(pad_flags, flag_idx); -} - -// ===== MAIN KERNEL FUNCTIONS ===== -__global__ void sha256_hash_computation( - uint8_t *records, - size_t num_records, - size_t *record_offsets, - uint32_t *block_offsets, - uint32_t *prev_hashes, - uint32_t total_num_blocks -) { - uint32_t record_idx = blockIdx.x * blockDim.x + threadIdx.x; - - if (record_idx >= num_records) { - return; - } - - uint32_t offset = record_offsets[record_idx]; - Sha256VmRecordMut record(records + offset); - - uint32_t len = record.header->len; - uint8_t *input = record.input; - - uint32_t start_block = block_offsets[record_idx]; - uint32_t num_blocks = get_sha256_num_blocks(len); - - uint32_t current_hash[SHA256_HASH_WORDS] = { - 0x6a09e667, - 0xbb67ae85, - 0x3c6ef372, - 0xa54ff53a, - 0x510e527f, - 0x9b05688c, - 0x1f83d9ab, - 0x5be0cd19 - }; - - uint8_t block_input[SHA256_BLOCK_U8S]; - for (uint32_t local_block = 0; local_block < num_blocks; local_block++) { - { - uint32_t offset = SHA256_HASH_WORDS * (start_block + local_block); - memcpy(prev_hashes + offset, current_hash, SHA256_HASH_WORDS * sizeof(uint32_t)); - } - if (local_block < num_blocks - 1) { - // Since local_block < num_blocks - 1, we know that block_offset < len by the definition of num_blocks - uint32_t block_offset = local_block * SHA256_BLOCK_U8S; - if (block_offset + SHA256_BLOCK_U8S > len) { - uint32_t remaining_bytes = len - block_offset; - memcpy(block_input, input + block_offset, remaining_bytes); - block_input[remaining_bytes] = 0x80; - memset( - block_input + remaining_bytes + 1, 0, SHA256_BLOCK_U8S - remaining_bytes - 1 - ); - } else { - memcpy(block_input, input + block_offset, SHA256_BLOCK_U8S); - } - - get_block_hash(current_hash, block_input); - } - } -} - -__global__ __noinline__ void sha256_first_pass_tracegen( - Fp *trace, - size_t trace_height, - uint8_t *records, - size_t num_records, - size_t *record_offsets, - uint32_t *block_offsets, - uint32_t *block_to_record_idx, - uint32_t total_num_blocks, - uint32_t *prev_hashes, - uint32_t ptr_max_bits, - uint32_t *range_checker_ptr, - uint32_t range_checker_num_bins, - uint32_t *bitwise_lookup_ptr, - uint32_t bitwise_num_bits, - uint32_t timestamp_max_bits -) { - uint32_t global_block_idx = blockIdx.x * blockDim.x + threadIdx.x; - - if (global_block_idx >= total_num_blocks) { - return; - } - - uint32_t record_idx = block_to_record_idx[global_block_idx]; - if (record_idx >= num_records) { - return; - } - - uint32_t offset = record_offsets[record_idx]; - Sha256VmRecordMut record(records + offset); - Sha256VmRecordHeader &vm_record = *record.header; - - auto len = vm_record.len; - auto input = record.input; - - auto local_block_idx = global_block_idx - block_offsets[record_idx]; - auto prev_hash = &prev_hashes[global_block_idx * SHA256_HASH_WORDS]; - auto block_offset = local_block_idx * SHA256_BLOCK_U8S; - - uint32_t num_blocks_for_record = get_sha256_num_blocks(len); - bool is_last_block = (local_block_idx == num_blocks_for_record - 1); - - uint32_t input_words[SHA256_BLOCK_WORDS]; - { - uint8_t padded_input[SHA256_BLOCK_U8S]; - if (block_offset <= len) { - if (block_offset + SHA256_BLOCK_U8S > len) { - uint32_t remaining_bytes = len - block_offset; - memcpy(padded_input, input + block_offset, remaining_bytes); - padded_input[remaining_bytes] = 0x80; - memset( - padded_input + remaining_bytes + 1, 0, SHA256_BLOCK_U8S - remaining_bytes - 1 - ); - } else { - memcpy(padded_input, input + block_offset, SHA256_BLOCK_U8S); - } - } else { - memset(padded_input, 0, SHA256_BLOCK_U8S); - } - - for (uint32_t i = 0; i < SHA256_BLOCK_WORDS; i++) { - input_words[i] = u32_from_bytes_be(padded_input + i * 4); - } - - if (is_last_block) { - input_words[SHA256_BLOCK_WORDS - 1] = len << 3; - } - } - - uint32_t trace_start_row = global_block_idx * SHA256_ROWS_PER_BLOCK; - - uint32_t read_cells = (SHA256_BLOCK_U8S * local_block_idx); - uint32_t block_start_read_ptr = vm_record.src_ptr + read_cells; - uint32_t message_left = len - read_cells; - - MemoryAuxColsFactory mem_helper( - VariableRangeChecker(range_checker_ptr, range_checker_num_bins), timestamp_max_bits - ); - - BitwiseOperationLookup bitwise_lookup(bitwise_lookup_ptr, bitwise_num_bits); - - Encoder padding_encoder(static_cast(PaddingFlags::COUNT), 2, false); - - int32_t first_padding_row; - if (len < read_cells) { - first_padding_row = -1; - } else if (message_left < SHA256_BLOCK_U8S) { - first_padding_row = message_left / SHA256_READ_SIZE; - } else { - first_padding_row = 18; - } - - auto start_timestamp = - vm_record.timestamp + (SHA256_REGISTER_READS + SHA256_NUM_READ_ROWS * local_block_idx); - - for (uint32_t row_in_block = 0; row_in_block < SHA256_ROWS_PER_BLOCK; row_in_block++) { - uint32_t absolute_row = trace_start_row + row_in_block; - - if (absolute_row >= trace_height) { - return; - } - - RowSlice row(trace + absolute_row, trace_height); - - if (row_in_block == SHA256_ROWS_PER_BLOCK - 1) { - SHA256_WRITE_DIGEST(row, from_state.timestamp, vm_record.timestamp); - SHA256_WRITE_DIGEST(row, from_state.pc, vm_record.from_pc); - SHA256_WRITE_DIGEST(row, rd_ptr, vm_record.rd_ptr); - SHA256_WRITE_DIGEST(row, rs1_ptr, vm_record.rs1_ptr); - SHA256_WRITE_DIGEST(row, rs2_ptr, vm_record.rs2_ptr); - - { - uint8_t *dst_bytes = reinterpret_cast(&vm_record.dst_ptr); - uint8_t *src_bytes = reinterpret_cast(&vm_record.src_ptr); - uint8_t *len_bytes = reinterpret_cast(&len); - - SHA256_WRITE_ARRAY_DIGEST(row, dst_ptr, dst_bytes); - SHA256_WRITE_ARRAY_DIGEST(row, src_ptr, src_bytes); - SHA256_WRITE_ARRAY_DIGEST(row, len_data, len_bytes); - } - - if (is_last_block) { - for (int i = 0; i < SHA256_REGISTER_READS; i++) { - mem_helper.fill( - SHA256_SLICE_DIGEST(row, register_reads_aux[i]), - vm_record.register_reads_aux[i].prev_timestamp, - vm_record.timestamp + i - ); - } - - SHA256_WRITE_ARRAY_DIGEST(row, writes_aux.prev_data, vm_record.write_aux.prev_data); - - mem_helper.fill( - SHA256_SLICE_DIGEST(row, writes_aux), - vm_record.write_aux.prev_timestamp, - start_timestamp + SHA256_NUM_READ_ROWS - ); - - uint32_t msl_rshift = ((RV32_REGISTER_NUM_LIMBS - 1) * RV32_CELL_BITS); - uint32_t msl_lshift = (RV32_REGISTER_NUM_LIMBS * RV32_CELL_BITS - ptr_max_bits); - bitwise_lookup.add_range( - (vm_record.dst_ptr >> msl_rshift) << msl_lshift, - (vm_record.src_ptr >> msl_rshift) << msl_lshift - ); - } else { - for (int i = 0; i < SHA256_REGISTER_READS; i++) { - mem_helper.fill_zero(SHA256_SLICE_DIGEST(row, register_reads_aux[i])); - } - - row.fill_zero( - COL_INDEX(Sha256VmDigestCols, writes_aux.prev_data), SHA256_WRITE_SIZE - ); - mem_helper.fill_zero(SHA256_SLICE_DIGEST(row, writes_aux)); - } - SHA256_WRITE_DIGEST(row, inner.flags.is_last_block, is_last_block); - SHA256_WRITE_DIGEST(row, inner.flags.is_digest_row, Fp::one()); - row.fill_zero(SHA256VM_DIGEST_WIDTH, SHA256VM_WIDTH - SHA256VM_DIGEST_WIDTH); - } else { - if (row_in_block < SHA256_NUM_READ_ROWS) { - - uint32_t data_offset = block_offset + row_in_block * SHA256_READ_SIZE; - SHA256_WRITE_ARRAY_ROUND( - row, inner.message_schedule.carry_or_buffer, input + data_offset - ); - - MemoryReadAuxRecord *read_aux_record = - get_read_aux_record(&record, local_block_idx, row_in_block); - mem_helper.fill( - SHA256_SLICE_ROUND(row, read_aux), - read_aux_record->prev_timestamp, - start_timestamp + row_in_block - ); - } else { - mem_helper.fill_zero(SHA256_SLICE_ROUND(row, read_aux)); - } - } - - SHA256_WRITE_ROUND(row, control.len, len); - - { - uint32_t control_timestamp = - start_timestamp + min(row_in_block, (uint32_t)SHA256_NUM_READ_ROWS); - uint32_t control_read_ptr = - block_start_read_ptr + - (SHA256_READ_SIZE * min(row_in_block, (uint32_t)SHA256_NUM_READ_ROWS)); - - SHA256_WRITE_ROUND(row, control.cur_timestamp, control_timestamp); - SHA256_WRITE_ROUND(row, control.read_ptr, control_read_ptr); - } - - if (row_in_block < SHA256_NUM_READ_ROWS) { - if ((int32_t)row_in_block < first_padding_row) { - write_round_padding_flags_encoder( - row, padding_encoder, static_cast(PaddingFlags::NotPadding) - ); - } else if ((int32_t)row_in_block == first_padding_row) { - { - uint32_t len = message_left - row_in_block * SHA256_READ_SIZE; - uint32_t flag_idx; - if (row_in_block == 3 && is_last_block) { - flag_idx = static_cast(PaddingFlags::FirstPadding0_LastRow) + len; - if (flag_idx >= static_cast(PaddingFlags::COUNT)) { - flag_idx = static_cast(PaddingFlags::EntirePaddingLastRow); - } - } else { - flag_idx = static_cast(PaddingFlags::FirstPadding0) + len; - if (flag_idx >= static_cast(PaddingFlags::COUNT)) { - flag_idx = static_cast(PaddingFlags::EntirePadding); - } - } - write_round_padding_flags_encoder(row, padding_encoder, flag_idx); - } - } else { - { - uint32_t flag_idx; - if (row_in_block == 3 && is_last_block) { - flag_idx = static_cast(PaddingFlags::EntirePaddingLastRow); - } else { - flag_idx = static_cast(PaddingFlags::EntirePadding); - } - write_round_padding_flags_encoder(row, padding_encoder, flag_idx); - } - } - } else { - write_round_padding_flags_encoder( - row, padding_encoder, static_cast(PaddingFlags::NotConsidered) - ); - } - - if (is_last_block && row_in_block == SHA256_ROWS_PER_BLOCK - 1) { - SHA256_WRITE_ROUND(row, control.padding_occurred, Fp::zero()); - } else { - SHA256_WRITE_ROUND( - row, control.padding_occurred, (int32_t)row_in_block >= first_padding_row - ); - } - } - - Fp *inner_trace_start = trace + (SHA256_INNER_COLUMN_OFFSET * trace_height) + trace_start_row; - generate_block_trace( - inner_trace_start, - trace_height, - input_words, - bitwise_lookup_ptr, - bitwise_num_bits, - prev_hash, - is_last_block, - global_block_idx + 1, - local_block_idx - ); -} - -__global__ void sha256_fill_invalid_rows(Fp *d_trace, size_t trace_height, size_t rows_used) { - uint32_t thread_idx = blockIdx.x * blockDim.x + threadIdx.x; - uint32_t row_idx = rows_used + thread_idx; - if (row_idx >= trace_height) { - return; - } - - RowSlice row(d_trace + row_idx, trace_height); - row.fill_zero(0, SHA256VM_WIDTH); - - RowSlice inner_row = row.slice_from(SHA256_INNER_COLUMN_OFFSET); - generate_default_row(inner_row); -} - -// ===== HOST LAUNCHER FUNCTIONS ===== -extern "C" int launch_sha256_hash_computation( - uint8_t *d_records, - size_t num_records, - size_t *d_record_offsets, - uint32_t *d_block_offsets, - uint32_t *d_prev_hashes, - uint32_t total_num_blocks -) { - auto [grid_size, block_size] = kernel_launch_params(num_records, 256); - - sha256_hash_computation<<>>( - d_records, num_records, d_record_offsets, d_block_offsets, d_prev_hashes, total_num_blocks - ); - - return CHECK_KERNEL(); -} - -extern "C" int launch_sha256_first_pass_tracegen( - Fp *d_trace, - size_t trace_height, - uint8_t *d_records, - size_t num_records, - size_t *d_record_offsets, - uint32_t *d_block_offsets, - uint32_t *d_block_to_record_idx, - uint32_t total_num_blocks, - uint32_t *d_prev_hashes, - uint32_t ptr_max_bits, - uint32_t *d_range_checker, - uint32_t range_checker_num_bins, - uint32_t *d_bitwise_lookup, - uint32_t bitwise_num_bits, - uint32_t timestamp_max_bits -) { - // Validate that trace_height is a power of two - assert((trace_height & (trace_height - 1)) == 0); - assert(trace_height >= total_num_blocks * SHA256_ROWS_PER_BLOCK); - - auto [grid_size, block_size] = kernel_launch_params(total_num_blocks, 256); - - sha256_first_pass_tracegen<<>>( - d_trace, - trace_height, - d_records, - num_records, - d_record_offsets, - d_block_offsets, - d_block_to_record_idx, - total_num_blocks, - d_prev_hashes, - ptr_max_bits, - d_range_checker, - range_checker_num_bins, - d_bitwise_lookup, - bitwise_num_bits, - timestamp_max_bits - ); - - return CHECK_KERNEL(); -} - -extern "C" int launch_sha256_second_pass_dependencies( - Fp *d_trace, - size_t trace_height, - size_t rows_used -) { - Fp *inner_trace_start = d_trace + (SHA256_INNER_COLUMN_OFFSET * trace_height); - uint32_t total_sha256_blocks = rows_used / SHA256_ROWS_PER_BLOCK; - - auto [grid_size, block_size] = kernel_launch_params(total_sha256_blocks, 256); - - sha256_second_pass_dependencies<<>>( - inner_trace_start, trace_height, total_sha256_blocks - ); - - return CHECK_KERNEL(); -} - -extern "C" int launch_sha256_fill_invalid_rows( - Fp *d_trace, - size_t trace_height, - size_t rows_used -) { - uint32_t invalid_rows = trace_height - rows_used; - auto [grid_size, block_size] = kernel_launch_params(invalid_rows, 256); - sha256_fill_invalid_rows<<>>(d_trace, trace_height, rows_used); - - return CHECK_KERNEL(); -} \ No newline at end of file diff --git a/extensions/sha256/circuit/src/cuda_abi.rs b/extensions/sha256/circuit/src/cuda_abi.rs deleted file mode 100644 index 77df3a782e..0000000000 --- a/extensions/sha256/circuit/src/cuda_abi.rs +++ /dev/null @@ -1,124 +0,0 @@ -#![allow(clippy::missing_safety_doc)] - -use openvm_cuda_backend::prelude::F; -use openvm_cuda_common::{d_buffer::DeviceBuffer, error::CudaError}; - -pub mod sha256 { - use super::*; - - extern "C" { - fn launch_sha256_hash_computation( - d_records: *const u8, - num_records: usize, - d_record_offsets: *const usize, - d_block_offsets: *const u32, - d_prev_hashes: *mut u32, - total_num_blocks: u32, - ) -> i32; - - fn launch_sha256_first_pass_tracegen( - d_trace: *mut F, - trace_height: usize, - d_records: *const u8, - num_records: usize, - d_record_offsets: *const usize, - d_block_offsets: *const u32, - d_block_to_record_idx: *const u32, - total_num_blocks: u32, - d_prev_hashes: *const u32, - ptr_max_bits: u32, - d_range_checker: *mut u32, - range_checker_num_bins: u32, - d_bitwise_lookup: *mut u32, - bitwise_num_bits: u32, - timestamp_max_bits: u32, - ) -> i32; - - fn launch_sha256_second_pass_dependencies( - d_trace: *mut F, - trace_height: usize, - rows_used: usize, - ) -> i32; - - fn launch_sha256_fill_invalid_rows( - d_trace: *mut F, - trace_height: usize, - rows_used: usize, - ) -> i32; - } - - pub unsafe fn sha256_hash_computation( - d_records: &DeviceBuffer, - num_records: usize, - d_record_offsets: &DeviceBuffer, - d_block_offsets: &DeviceBuffer, - d_prev_hashes: &DeviceBuffer, - num_blocks: u32, - ) -> Result<(), CudaError> { - let result = launch_sha256_hash_computation( - d_records.as_ptr(), - num_records, - d_record_offsets.as_ptr(), - d_block_offsets.as_ptr(), - d_prev_hashes.as_mut_ptr(), - num_blocks, - ); - CudaError::from_result(result) - } - - #[allow(clippy::too_many_arguments)] - pub unsafe fn sha256_first_pass_tracegen( - d_trace: &DeviceBuffer, - height: usize, - d_records: &DeviceBuffer, - num_records: usize, - d_record_offsets: &DeviceBuffer, - d_block_offsets: &DeviceBuffer, - d_block_to_record_idx: &DeviceBuffer, - total_num_blocks: u32, - d_prev_hashes: &DeviceBuffer, - ptr_max_bits: u32, - d_range_checker: &DeviceBuffer, - d_bitwise_lookup: &DeviceBuffer, - bitwise_num_bits: u32, - timestamp_max_bits: u32, - ) -> Result<(), CudaError> { - let result = launch_sha256_first_pass_tracegen( - d_trace.as_mut_ptr(), - height, - d_records.as_ptr(), - num_records, - d_record_offsets.as_ptr(), - d_block_offsets.as_ptr(), - d_block_to_record_idx.as_ptr(), - total_num_blocks, - d_prev_hashes.as_ptr(), - ptr_max_bits, - d_range_checker.as_mut_ptr() as *mut u32, - d_range_checker.len() as u32, - d_bitwise_lookup.as_mut_ptr() as *mut u32, - bitwise_num_bits, - timestamp_max_bits, - ); - CudaError::from_result(result) - } - - pub unsafe fn sha256_second_pass_dependencies( - d_trace: &DeviceBuffer, - height: usize, - rows_used: usize, - ) -> Result<(), CudaError> { - let result = - launch_sha256_second_pass_dependencies(d_trace.as_mut_ptr(), height, rows_used); - CudaError::from_result(result) - } - - pub unsafe fn sha256_fill_invalid_rows( - d_trace: &DeviceBuffer, - height: usize, - rows_used: usize, - ) -> Result<(), CudaError> { - let result = launch_sha256_fill_invalid_rows(d_trace.as_mut_ptr(), height, rows_used); - CudaError::from_result(result) - } -} diff --git a/extensions/sha256/circuit/src/extension/cuda.rs b/extensions/sha256/circuit/src/extension/cuda.rs deleted file mode 100644 index 6b18624dbc..0000000000 --- a/extensions/sha256/circuit/src/extension/cuda.rs +++ /dev/null @@ -1,39 +0,0 @@ -use openvm_circuit::{ - arch::DenseRecordArena, - system::cuda::extensions::{get_inventory_range_checker, get_or_create_bitwise_op_lookup}, -}; -use openvm_cuda_backend::{BabyBearPoseidon2GpuEngine as GpuBabyBearPoseidon2Engine, GpuBackend}; -use openvm_stark_sdk::config::baby_bear_poseidon2::BabyBearPoseidon2Config; - -use super::*; - -pub struct Sha256GpuProverExt; - -impl VmProverExtension - for Sha256GpuProverExt -{ - fn extend_prover( - &self, - _: &Sha256, - inventory: &mut ChipInventory, - ) -> Result<(), ChipInventoryError> { - let pointer_max_bits = inventory.airs().pointer_max_bits(); - let timestamp_max_bits = inventory.timestamp_max_bits(); - - let range_checker = get_inventory_range_checker(inventory); - let bitwise_lu = get_or_create_bitwise_op_lookup(inventory)?; - - // These calls to next_air are not strictly necessary to construct the chips, but provide a - // safeguard to ensure that chip construction matches the circuit definition - inventory.next_air::()?; - let sha256 = Sha256VmChipGpu::new( - range_checker.clone(), - bitwise_lu, - pointer_max_bits as u32, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(sha256); - - Ok(()) - } -} diff --git a/extensions/sha256/circuit/src/extension/mod.rs b/extensions/sha256/circuit/src/extension/mod.rs deleted file mode 100644 index 169130ddc8..0000000000 --- a/extensions/sha256/circuit/src/extension/mod.rs +++ /dev/null @@ -1,142 +0,0 @@ -use std::{result::Result, sync::Arc}; - -use derive_more::derive::From; -use openvm_circuit::{ - arch::{ - AirInventory, AirInventoryError, ChipInventory, ChipInventoryError, - ExecutorInventoryBuilder, ExecutorInventoryError, RowMajorMatrixArena, VmCircuitExtension, - VmExecutionExtension, VmProverExtension, - }, - system::memory::SharedMemoryHelper, -}; -use openvm_circuit_derive::{AnyEnum, Executor, MeteredExecutor, PreflightExecutor}; -use openvm_circuit_primitives::bitwise_op_lookup::{ - BitwiseOperationLookupAir, BitwiseOperationLookupBus, BitwiseOperationLookupChip, - SharedBitwiseOperationLookupChip, -}; -use openvm_cpu_backend::{CpuBackend, CpuDevice}; -use openvm_instructions::*; -use openvm_sha256_transpiler::Rv32Sha256Opcode; -use openvm_stark_backend::{p3_field::PrimeField32, StarkEngine, StarkProtocolConfig, Val}; -use serde::{Deserialize, Serialize}; -use strum::IntoEnumIterator; - -use crate::*; - -cfg_if::cfg_if! { - if #[cfg(feature = "cuda")] { - mod cuda; - pub use self::cuda::*; - pub use self::cuda::Sha256GpuProverExt as Sha256ProverExt; - } else { - pub use self::Sha2CpuProverExt as Sha256ProverExt; - } -} - -// =================================== VM Extension Implementation ================================= -#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)] -pub struct Sha256; - -#[derive(Clone, From, AnyEnum, Executor, MeteredExecutor, PreflightExecutor)] -#[cfg_attr( - feature = "aot", - derive( - openvm_circuit_derive::AotExecutor, - openvm_circuit_derive::AotMeteredExecutor - ) -)] -pub enum Sha256Executor { - Sha256(Sha256VmExecutor), -} - -impl VmExecutionExtension for Sha256 { - type Executor = Sha256Executor; - - fn extend_execution( - &self, - inventory: &mut ExecutorInventoryBuilder, - ) -> Result<(), ExecutorInventoryError> { - let pointer_max_bits = inventory.pointer_max_bits(); - let sha256_step = Sha256VmExecutor::new(Rv32Sha256Opcode::CLASS_OFFSET, pointer_max_bits); - inventory.add_executor( - sha256_step, - Rv32Sha256Opcode::iter().map(|x| x.global_opcode()), - )?; - - Ok(()) - } -} - -impl VmCircuitExtension for Sha256 { - fn extend_circuit(&self, inventory: &mut AirInventory) -> Result<(), AirInventoryError> { - let pointer_max_bits = inventory.pointer_max_bits(); - - let bitwise_lu = { - let existing_air = inventory.find_air::>().next(); - if let Some(air) = existing_air { - air.bus - } else { - let bus = BitwiseOperationLookupBus::new(inventory.new_bus_idx()); - let air = BitwiseOperationLookupAir::<8>::new(bus); - inventory.add_air(air); - air.bus - } - }; - - let sha256 = Sha256VmAir::new( - inventory.system().port(), - bitwise_lu, - pointer_max_bits, - inventory.new_bus_idx(), - ); - inventory.add_air(sha256); - - Ok(()) - } -} - -pub struct Sha2CpuProverExt; -// This implementation is specific to CpuBackend because the lookup chips (VariableRangeChecker, -// BitwiseOperationLookupChip) are specific to CpuBackend. -impl VmProverExtension for Sha2CpuProverExt -where - SC: StarkProtocolConfig, - E: StarkEngine, PD = CpuDevice>, - RA: RowMajorMatrixArena>, - Val: PrimeField32, - SC::EF: Ord, -{ - fn extend_prover( - &self, - _: &Sha256, - inventory: &mut ChipInventory>, - ) -> Result<(), ChipInventoryError> { - let range_checker = inventory.range_checker()?.clone(); - let timestamp_max_bits = inventory.timestamp_max_bits(); - let mem_helper = SharedMemoryHelper::new(range_checker.clone(), timestamp_max_bits); - let pointer_max_bits = inventory.airs().pointer_max_bits(); - - let bitwise_lu = { - let existing_chip = inventory - .find_chip::>() - .next(); - if let Some(chip) = existing_chip { - chip.clone() - } else { - let air: &BitwiseOperationLookupAir<8> = inventory.next_air()?; - let chip = Arc::new(BitwiseOperationLookupChip::new(air.bus)); - inventory.add_periphery_chip(chip.clone()); - chip - } - }; - - inventory.next_air::()?; - let sha256 = Sha256VmChip::new( - Sha256VmFiller::new(bitwise_lu, pointer_max_bits), - mem_helper, - ); - inventory.add_executor_chip(sha256); - - Ok(()) - } -} diff --git a/extensions/sha256/circuit/src/lib.rs b/extensions/sha256/circuit/src/lib.rs deleted file mode 100644 index 29f9537727..0000000000 --- a/extensions/sha256/circuit/src/lib.rs +++ /dev/null @@ -1,156 +0,0 @@ -#![cfg_attr(feature = "tco", allow(incomplete_features))] -#![cfg_attr(feature = "tco", feature(explicit_tail_calls))] -#![cfg_attr(feature = "tco", allow(internal_features))] -#![cfg_attr(feature = "tco", feature(core_intrinsics))] - -use std::result::Result; - -use openvm_circuit::{ - arch::{ - AirInventory, ChipInventoryError, InitFileGenerator, MatrixRecordArena, SystemConfig, - VmBuilder, VmChipComplex, VmField, VmProverExtension, - }, - system::{SystemChipInventory, SystemCpuBuilder, SystemExecutor}, -}; -use openvm_circuit_derive::VmConfig; -use openvm_cpu_backend::{CpuBackend, CpuDevice}; -use openvm_rv32im_circuit::{ - Rv32I, Rv32IExecutor, Rv32ImCpuProverExt, Rv32Io, Rv32IoExecutor, Rv32M, Rv32MExecutor, -}; -use openvm_stark_backend::{StarkEngine, StarkProtocolConfig, Val}; -use serde::{Deserialize, Serialize}; - -mod sha256_chip; -pub use sha256_chip::*; - -mod extension; -pub use extension::*; - -cfg_if::cfg_if! { - if #[cfg(feature = "cuda")] { - use openvm_cuda_backend::{GpuBackend as GpuBackend, BabyBearPoseidon2GpuEngine as GpuBabyBearPoseidon2Engine}; - use openvm_circuit::arch::DenseRecordArena; - use openvm_circuit::system::cuda::{extensions::SystemGpuBuilder, SystemChipInventoryGPU}; - use openvm_stark_sdk::config::baby_bear_poseidon2::BabyBearPoseidon2Config; - use openvm_rv32im_circuit::Rv32ImGpuProverExt; - pub(crate) mod cuda_abi; - pub use Sha256Rv32GpuBuilder as Sha256Rv32Builder; - } else { - pub use Sha256Rv32CpuBuilder as Sha256Rv32Builder; - } -} - -#[derive(Clone, Debug, VmConfig, derive_new::new, Serialize, Deserialize)] -pub struct Sha256Rv32Config { - #[config(executor = "SystemExecutor")] - pub system: SystemConfig, - #[extension] - pub rv32i: Rv32I, - #[extension] - pub rv32m: Rv32M, - #[extension] - pub io: Rv32Io, - #[extension] - pub sha256: Sha256, -} - -impl Default for Sha256Rv32Config { - fn default() -> Self { - Self { - system: SystemConfig::default(), - rv32i: Rv32I, - rv32m: Rv32M::default(), - io: Rv32Io, - sha256: Sha256, - } - } -} - -// Default implementation uses no init file -impl InitFileGenerator for Sha256Rv32Config {} - -#[derive(Clone)] -pub struct Sha256Rv32CpuBuilder; - -impl VmBuilder for Sha256Rv32CpuBuilder -where - SC: StarkProtocolConfig, - E: StarkEngine, PD = CpuDevice>, - Val: VmField, - SC::EF: Ord, -{ - type VmConfig = Sha256Rv32Config; - type SystemChipInventory = SystemChipInventory; - type RecordArena = MatrixRecordArena>; - - fn create_chip_complex( - &self, - config: &Sha256Rv32Config, - circuit: AirInventory, - ) -> Result< - VmChipComplex, - ChipInventoryError, - > { - let mut chip_complex = - VmBuilder::::create_chip_complex(&SystemCpuBuilder, &config.system, circuit)?; - let inventory = &mut chip_complex.inventory; - VmProverExtension::::extend_prover(&Rv32ImCpuProverExt, &config.rv32i, inventory)?; - VmProverExtension::::extend_prover(&Rv32ImCpuProverExt, &config.rv32m, inventory)?; - VmProverExtension::::extend_prover(&Rv32ImCpuProverExt, &config.io, inventory)?; - VmProverExtension::::extend_prover(&Sha2CpuProverExt, &config.sha256, inventory)?; - Ok(chip_complex) - } -} - -#[cfg(feature = "cuda")] -#[derive(Clone)] -pub struct Sha256Rv32GpuBuilder; - -#[cfg(feature = "cuda")] -impl VmBuilder for Sha256Rv32GpuBuilder { - type VmConfig = Sha256Rv32Config; - type SystemChipInventory = SystemChipInventoryGPU; - type RecordArena = DenseRecordArena; - - fn create_chip_complex( - &self, - config: &Sha256Rv32Config, - circuit: AirInventory, - ) -> Result< - VmChipComplex< - BabyBearPoseidon2Config, - Self::RecordArena, - GpuBackend, - Self::SystemChipInventory, - >, - ChipInventoryError, - > { - let mut chip_complex = VmBuilder::::create_chip_complex( - &SystemGpuBuilder, - &config.system, - circuit, - )?; - let inventory = &mut chip_complex.inventory; - VmProverExtension::::extend_prover( - &Rv32ImGpuProverExt, - &config.rv32i, - inventory, - )?; - VmProverExtension::::extend_prover( - &Rv32ImGpuProverExt, - &config.rv32m, - inventory, - )?; - VmProverExtension::::extend_prover( - &Rv32ImGpuProverExt, - &config.io, - inventory, - )?; - VmProverExtension::::extend_prover( - &Sha256GpuProverExt, - &config.sha256, - inventory, - )?; - Ok(chip_complex) - } -} diff --git a/extensions/sha256/circuit/src/sha256_chip/air.rs b/extensions/sha256/circuit/src/sha256_chip/air.rs deleted file mode 100644 index 59d1b902a7..0000000000 --- a/extensions/sha256/circuit/src/sha256_chip/air.rs +++ /dev/null @@ -1,621 +0,0 @@ -use std::{array, borrow::Borrow, cmp::min}; - -use openvm_circuit::{ - arch::ExecutionBridge, - system::{ - memory::{offline_checker::MemoryBridge, MemoryAddress}, - SystemPort, - }, -}; -use openvm_circuit_primitives::{ - bitwise_op_lookup::BitwiseOperationLookupBus, encoder::Encoder, utils::not, SubAir, -}; -use openvm_instructions::{ - riscv::{RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS}, - LocalOpcode, -}; -use openvm_sha256_air::{ - compose, Sha256Air, SHA256_BLOCK_U8S, SHA256_HASH_WORDS, SHA256_ROUNDS_PER_ROW, - SHA256_WORD_U16S, SHA256_WORD_U8S, -}; -use openvm_sha256_transpiler::Rv32Sha256Opcode; -use openvm_stark_backend::{ - interaction::{BusIndex, InteractionBuilder}, - p3_air::{Air, AirBuilder, BaseAir}, - p3_field::{Field, PrimeCharacteristicRing}, - p3_matrix::Matrix, - BaseAirWithPublicValues, PartitionedBaseAir, -}; - -use super::{ - Sha256VmDigestCols, Sha256VmRoundCols, SHA256VM_CONTROL_WIDTH, SHA256VM_DIGEST_WIDTH, - SHA256VM_ROUND_WIDTH, SHA256VM_WIDTH, SHA256_READ_SIZE, -}; - -/// Sha256VmAir does all constraints related to message padding and -/// the Sha256Air subair constrains the actual hash -#[derive(Clone, Debug)] -pub struct Sha256VmAir { - pub execution_bridge: ExecutionBridge, - pub memory_bridge: MemoryBridge, - /// Bus to send byte checks to - pub bitwise_lookup_bus: BitwiseOperationLookupBus, - /// Maximum number of bits allowed for an address pointer - /// Must be at least 24 - pub ptr_max_bits: usize, - pub(super) sha256_subair: Sha256Air, - pub(super) padding_encoder: Encoder, -} - -impl Sha256VmAir { - pub fn new( - SystemPort { - execution_bus, - program_bus, - memory_bridge, - }: SystemPort, - bitwise_lookup_bus: BitwiseOperationLookupBus, - ptr_max_bits: usize, - self_bus_idx: BusIndex, - ) -> Self { - Self { - execution_bridge: ExecutionBridge::new(execution_bus, program_bus), - memory_bridge, - bitwise_lookup_bus, - ptr_max_bits, - sha256_subair: Sha256Air::new(bitwise_lookup_bus, self_bus_idx), - padding_encoder: Encoder::new(PaddingFlags::COUNT, 2, false), - } - } -} - -impl BaseAirWithPublicValues for Sha256VmAir {} -impl PartitionedBaseAir for Sha256VmAir {} -impl BaseAir for Sha256VmAir { - fn width(&self) -> usize { - SHA256VM_WIDTH - } -} - -impl Air for Sha256VmAir { - fn eval(&self, builder: &mut AB) { - self.eval_padding(builder); - self.eval_transitions(builder); - self.eval_reads(builder); - self.eval_last_row(builder); - - self.sha256_subair.eval(builder, SHA256VM_CONTROL_WIDTH); - } -} - -#[allow(dead_code, non_camel_case_types)] -pub(super) enum PaddingFlags { - /// Not considered for padding - W's are not constrained - NotConsidered, - /// Not padding - W's should be equal to the message - NotPadding, - /// FIRST_PADDING_i: it is the first row with padding and there are i cells of non-padding - FirstPadding0, - FirstPadding1, - FirstPadding2, - FirstPadding3, - FirstPadding4, - FirstPadding5, - FirstPadding6, - FirstPadding7, - FirstPadding8, - FirstPadding9, - FirstPadding10, - FirstPadding11, - FirstPadding12, - FirstPadding13, - FirstPadding14, - FirstPadding15, - /// FIRST_PADDING_i_LastRow: it is the first row with padding and there are i cells of - /// non-padding AND it is the last reading row of the message - /// NOTE: if the Last row has padding it has to be at least 9 cells since the last 8 cells are - /// padded with the message length - FirstPadding0_LastRow, - FirstPadding1_LastRow, - FirstPadding2_LastRow, - FirstPadding3_LastRow, - FirstPadding4_LastRow, - FirstPadding5_LastRow, - FirstPadding6_LastRow, - FirstPadding7_LastRow, - /// The entire row is padding AND it is not the first row with padding - /// AND it is the 4th row of the last block of the message - EntirePaddingLastRow, - /// The entire row is padding AND it is not the first row with padding - EntirePadding, -} - -impl PaddingFlags { - /// The number of padding flags (including NotConsidered) - pub const COUNT: usize = EntirePadding as usize + 1; -} - -use PaddingFlags::*; -impl Sha256VmAir { - /// Implement all necessary constraints for the padding - fn eval_padding(&self, builder: &mut AB) { - let main = builder.main(); - let (local, next) = ( - main.row_slice(0).expect("window should have two elements"), - main.row_slice(1).expect("window should have two elements"), - ); - let local_cols: &Sha256VmRoundCols = local[..SHA256VM_ROUND_WIDTH].borrow(); - let next_cols: &Sha256VmRoundCols = next[..SHA256VM_ROUND_WIDTH].borrow(); - - // Constrain the sanity of the padding flags - self.padding_encoder - .eval(builder, &local_cols.control.pad_flags); - - builder.assert_one(self.padding_encoder.contains_flag_range::( - &local_cols.control.pad_flags, - NotConsidered as usize..=EntirePadding as usize, - )); - - Self::eval_padding_transitions(self, builder, local_cols, next_cols); - Self::eval_padding_row(self, builder, local_cols); - } - - fn eval_padding_transitions( - &self, - builder: &mut AB, - local: &Sha256VmRoundCols, - next: &Sha256VmRoundCols, - ) { - let next_is_last_row = next.inner.flags.is_digest_row * next.inner.flags.is_last_block; - - // Constrain that `padding_occured` is 1 on a suffix of rows in each message, excluding the - // last digest row, and 0 everywhere else. Furthermore, the suffix starts in the - // first 4 rows of some block. - - builder.assert_bool(local.control.padding_occurred); - // Last round row in the last block has padding_occurred = 1 - // This is the end of the suffix - builder - .when(next_is_last_row.clone()) - .assert_one(local.control.padding_occurred); - - // Digest row in the last block has padding_occurred = 0 - builder - .when(next_is_last_row.clone()) - .assert_zero(next.control.padding_occurred); - - // If padding_occurred = 1 in the current row, then padding_occurred = 1 in the next row, - // unless next is the last digest row - builder - .when(local.control.padding_occurred - next_is_last_row.clone()) - .assert_one(next.control.padding_occurred); - - // If next row is not first 4 rows of a block, then next.padding_occurred = - // local.padding_occurred. So padding_occurred only changes in the first 4 rows of a - // block. - builder - .when_transition() - .when(not(next.inner.flags.is_first_4_rows) - next_is_last_row) - .assert_eq( - next.control.padding_occurred, - local.control.padding_occurred, - ); - - // Constrain the that the start of the padding is correct - let next_is_first_padding_row = - next.control.padding_occurred - local.control.padding_occurred; - // Row index if its between 0..4, else 0 - let next_row_idx = self.sha256_subair.row_idx_encoder.flag_with_val::( - &next.inner.flags.row_idx, - &(0..4).map(|x| (x, x)).collect::>(), - ); - // How many non-padding cells there are in the next row. - // Will be 0 on non-padding rows. - let next_padding_offset = self.padding_encoder.flag_with_val::( - &next.control.pad_flags, - &(0..16) - .map(|i| (FirstPadding0 as usize + i, i)) - .collect::>(), - ) + self.padding_encoder.flag_with_val::( - &next.control.pad_flags, - &(0..8) - .map(|i| (FirstPadding0_LastRow as usize + i, i)) - .collect::>(), - ); - - // Will be 0 on last digest row since: - // - padding_occurred = 0 is constrained above - // - next_row_idx = 0 since row_idx is not in 0..4 - // - and next_padding_offset = 0 since `pad_flags = NotConsidered` - let expected_len = next.inner.flags.local_block_idx - * next.control.padding_occurred - * AB::Expr::from_usize(SHA256_BLOCK_U8S) - + next_row_idx * AB::Expr::from_usize(SHA256_READ_SIZE) - + next_padding_offset; - - // Note: `next_is_first_padding_row` is either -1,0,1 - // If 1, then this constrains the length of message - // If -1, then `next` must be the last digest row and so this constraint will be 0 == 0 - builder.when(next_is_first_padding_row).assert_eq( - expected_len, - next.control.len * next.control.padding_occurred, - ); - - // Constrain the padding flags are of correct type (eg is not padding or first padding) - let is_next_first_padding = self.padding_encoder.contains_flag_range::( - &next.control.pad_flags, - FirstPadding0 as usize..=FirstPadding7_LastRow as usize, - ); - - let is_next_last_padding = self.padding_encoder.contains_flag_range::( - &next.control.pad_flags, - FirstPadding0_LastRow as usize..=EntirePaddingLastRow as usize, - ); - - let is_next_entire_padding = self.padding_encoder.contains_flag_range::( - &next.control.pad_flags, - EntirePaddingLastRow as usize..=EntirePadding as usize, - ); - - let is_next_not_considered = self - .padding_encoder - .contains_flag::(&next.control.pad_flags, &[NotConsidered as usize]); - - let is_next_not_padding = self - .padding_encoder - .contains_flag::(&next.control.pad_flags, &[NotPadding as usize]); - - let is_next_4th_row = self - .sha256_subair - .row_idx_encoder - .contains_flag::(&next.inner.flags.row_idx, &[3]); - - // `pad_flags` is `NotConsidered` on all rows except the first 4 rows of a block - builder.assert_eq( - not(next.inner.flags.is_first_4_rows), - is_next_not_considered, - ); - - // `pad_flags` is `EntirePadding` if the previous row is padding - builder.when(next.inner.flags.is_first_4_rows).assert_eq( - local.control.padding_occurred * next.control.padding_occurred, - is_next_entire_padding, - ); - - // `pad_flags` is `FirstPadding*` if current row is padding and the previous row is not - // padding - builder.when(next.inner.flags.is_first_4_rows).assert_eq( - not(local.control.padding_occurred) * next.control.padding_occurred, - is_next_first_padding, - ); - - // `pad_flags` is `NotPadding` if current row is not padding - builder - .when(next.inner.flags.is_first_4_rows) - .assert_eq(not(next.control.padding_occurred), is_next_not_padding); - - // `pad_flags` is `*LastRow` on the row that contains the last four words of the message - builder - .when(next.inner.flags.is_last_block) - .assert_eq(is_next_4th_row, is_next_last_padding); - } - - fn eval_padding_row( - &self, - builder: &mut AB, - local: &Sha256VmRoundCols, - ) { - let message: [AB::Var; SHA256_READ_SIZE] = array::from_fn(|i| { - local.inner.message_schedule.carry_or_buffer[i / (SHA256_WORD_U8S)] - [i % (SHA256_WORD_U8S)] - }); - - let get_ith_byte = |i: usize| { - let word_idx = i / SHA256_ROUNDS_PER_ROW; - let word = local.inner.message_schedule.w[word_idx].map(|x| x.into()); - // Need to reverse the byte order to match the endianness of the memory - let byte_idx = 4 - i % 4 - 1; - compose::(&word[byte_idx * 8..(byte_idx + 1) * 8], 1) - }; - - let is_not_padding = self - .padding_encoder - .contains_flag::(&local.control.pad_flags, &[NotPadding as usize]); - - // Check the `w`s on case by case basis - for (i, message_byte) in message.iter().enumerate() { - let w = get_ith_byte(i); - let should_be_message = is_not_padding.clone() - + if i < 15 { - self.padding_encoder.contains_flag_range::( - &local.control.pad_flags, - FirstPadding0 as usize + i + 1..=FirstPadding15 as usize, - ) - } else { - AB::Expr::ZERO - } - + if i < 7 { - self.padding_encoder.contains_flag_range::( - &local.control.pad_flags, - FirstPadding0_LastRow as usize + i + 1..=FirstPadding7_LastRow as usize, - ) - } else { - AB::Expr::ZERO - }; - builder - .when(should_be_message) - .assert_eq(w.clone(), *message_byte); - - let should_be_zero = self - .padding_encoder - .contains_flag::(&local.control.pad_flags, &[EntirePadding as usize]) - + if i < 12 { - self.padding_encoder.contains_flag::( - &local.control.pad_flags, - &[EntirePaddingLastRow as usize], - ) + if i > 0 { - self.padding_encoder.contains_flag_range::( - &local.control.pad_flags, - FirstPadding0_LastRow as usize - ..=min( - FirstPadding0_LastRow as usize + i - 1, - FirstPadding7_LastRow as usize, - ), - ) - } else { - AB::Expr::ZERO - } - } else { - AB::Expr::ZERO - } - + if i > 0 { - self.padding_encoder.contains_flag_range::( - &local.control.pad_flags, - FirstPadding0 as usize..=FirstPadding0 as usize + i - 1, - ) - } else { - AB::Expr::ZERO - }; - builder.when(should_be_zero).assert_zero(w.clone()); - - // Assumes bit-length of message is a multiple of 8 (message is bytes) - // This is true because the message is given as &[u8] - let should_be_128 = self - .padding_encoder - .contains_flag::(&local.control.pad_flags, &[FirstPadding0 as usize + i]) - + if i < 8 { - self.padding_encoder.contains_flag::( - &local.control.pad_flags, - &[FirstPadding0_LastRow as usize + i], - ) - } else { - AB::Expr::ZERO - }; - - builder - .when(should_be_128) - .assert_eq(AB::Expr::from_u32(1 << 7), w); - - // should be len is handled outside of the loop - } - let appended_len = compose::( - &[ - get_ith_byte(15), - get_ith_byte(14), - get_ith_byte(13), - get_ith_byte(12), - ], - RV32_CELL_BITS, - ); - - let actual_len = local.control.len; - - let is_last_padding_row = self.padding_encoder.contains_flag_range::( - &local.control.pad_flags, - FirstPadding0_LastRow as usize..=EntirePaddingLastRow as usize, - ); - - builder.when(is_last_padding_row.clone()).assert_eq( - appended_len * AB::F::from_usize(RV32_CELL_BITS).inverse(), // bit to byte conversion - actual_len, - ); - - // We constrain that the appended length is in bytes - builder.when(is_last_padding_row.clone()).assert_zero( - local.inner.message_schedule.w[3][0] - + local.inner.message_schedule.w[3][1] - + local.inner.message_schedule.w[3][2], - ); - - // We can't support messages longer than 2^30 bytes because the length has to fit in a field - // element. So, constrain that the first 4 bytes of the length are 0. - // Thus, the bit-length is < 2^32 so the message is < 2^29 bytes. - for i in 8..12 { - builder - .when(is_last_padding_row.clone()) - .assert_zero(get_ith_byte(i)); - } - } - /// Implement constraints on `len`, `read_ptr` and `cur_timestamp` - fn eval_transitions(&self, builder: &mut AB) { - let main = builder.main(); - let (local, next) = ( - main.row_slice(0).expect("window should have two elements"), - main.row_slice(1).expect("window should have two elements"), - ); - let local_cols: &Sha256VmRoundCols = local[..SHA256VM_ROUND_WIDTH].borrow(); - let next_cols: &Sha256VmRoundCols = next[..SHA256VM_ROUND_WIDTH].borrow(); - - let is_last_row = - local_cols.inner.flags.is_last_block * local_cols.inner.flags.is_digest_row; - - // Len should be the same for the entire message - builder - .when_transition() - .when(not::(is_last_row.clone())) - .assert_eq(next_cols.control.len, local_cols.control.len); - - // Read ptr should increment by [SHA256_READ_SIZE] for the first 4 rows and stay the same - // otherwise - let read_ptr_delta = - local_cols.inner.flags.is_first_4_rows * AB::Expr::from_usize(SHA256_READ_SIZE); - builder - .when_transition() - .when(not::(is_last_row.clone())) - .assert_eq( - next_cols.control.read_ptr, - local_cols.control.read_ptr + read_ptr_delta, - ); - - // Timestamp should increment by 1 for the first 4 rows and stay the same otherwise - let timestamp_delta = local_cols.inner.flags.is_first_4_rows * AB::Expr::ONE; - builder - .when_transition() - .when(not::(is_last_row.clone())) - .assert_eq( - next_cols.control.cur_timestamp, - local_cols.control.cur_timestamp + timestamp_delta, - ); - } - - /// Implement the reads for the first 4 rows of a block - fn eval_reads(&self, builder: &mut AB) { - let main = builder.main(); - let local = main.row_slice(0).expect("window should have two elements"); - let local_cols: &Sha256VmRoundCols = local[..SHA256VM_ROUND_WIDTH].borrow(); - - let message: [AB::Var; SHA256_READ_SIZE] = array::from_fn(|i| { - local_cols.inner.message_schedule.carry_or_buffer[i / (SHA256_WORD_U16S * 2)] - [i % (SHA256_WORD_U16S * 2)] - }); - - self.memory_bridge - .read( - MemoryAddress::new( - AB::Expr::from_u32(RV32_MEMORY_AS), - local_cols.control.read_ptr, - ), - message, - local_cols.control.cur_timestamp, - &local_cols.read_aux, - ) - .eval(builder, local_cols.inner.flags.is_first_4_rows); - } - /// Implement the constraints for the last row of a message - fn eval_last_row(&self, builder: &mut AB) { - let main = builder.main(); - let local = main.row_slice(0).expect("window should have two elements"); - let local_cols: &Sha256VmDigestCols = local[..SHA256VM_DIGEST_WIDTH].borrow(); - - let timestamp: AB::Var = local_cols.from_state.timestamp; - let mut timestamp_delta: usize = 0; - let mut timestamp_pp = || { - timestamp_delta += 1; - timestamp + AB::Expr::from_usize(timestamp_delta - 1) - }; - - let is_last_row = - local_cols.inner.flags.is_last_block * local_cols.inner.flags.is_digest_row; - - self.memory_bridge - .read( - MemoryAddress::new(AB::Expr::from_u32(RV32_REGISTER_AS), local_cols.rd_ptr), - local_cols.dst_ptr, - timestamp_pp(), - &local_cols.register_reads_aux[0], - ) - .eval(builder, is_last_row.clone()); - - self.memory_bridge - .read( - MemoryAddress::new(AB::Expr::from_u32(RV32_REGISTER_AS), local_cols.rs1_ptr), - local_cols.src_ptr, - timestamp_pp(), - &local_cols.register_reads_aux[1], - ) - .eval(builder, is_last_row.clone()); - - self.memory_bridge - .read( - MemoryAddress::new(AB::Expr::from_u32(RV32_REGISTER_AS), local_cols.rs2_ptr), - local_cols.len_data, - timestamp_pp(), - &local_cols.register_reads_aux[2], - ) - .eval(builder, is_last_row.clone()); - - // range check that the memory pointers don't overflow - // Note: no need to range check the length since we read from memory step by step and - // the memory bus will catch any memory accesses beyond ptr_max_bits - let shift = AB::Expr::from_usize( - 1 << (RV32_REGISTER_NUM_LIMBS * RV32_CELL_BITS - self.ptr_max_bits), - ); - // This only works if self.ptr_max_bits >= 24 which is typically the case - self.bitwise_lookup_bus - .send_range( - // It is fine to shift like this since we already know that dst_ptr and src_ptr - // have [RV32_CELL_BITS] bits - local_cols.dst_ptr[RV32_REGISTER_NUM_LIMBS - 1] * shift.clone(), - local_cols.src_ptr[RV32_REGISTER_NUM_LIMBS - 1] * shift.clone(), - ) - .eval(builder, is_last_row.clone()); - - // the number of reads that happened to read the entire message: we do 4 reads per block - let time_delta = - (local_cols.inner.flags.local_block_idx + AB::Expr::ONE) * AB::Expr::from_usize(4); - // Every time we read the message we increment the read pointer by SHA256_READ_SIZE - let read_ptr_delta = time_delta.clone() * AB::Expr::from_usize(SHA256_READ_SIZE); - - let result: [AB::Var; SHA256_WORD_U8S * SHA256_HASH_WORDS] = array::from_fn(|i| { - // The limbs are written in big endian order to the memory so need to be reversed - local_cols.inner.final_hash[i / SHA256_WORD_U8S] - [SHA256_WORD_U8S - i % SHA256_WORD_U8S - 1] - }); - - let dst_ptr_val = - compose::(&local_cols.dst_ptr.map(|x| x.into()), RV32_CELL_BITS); - - // Note: revisit in the future to do 2 block writes of 16 cells instead of 1 block write of - // 32 cells This could be beneficial as the output is often an input for - // another hash - self.memory_bridge - .write( - MemoryAddress::new(AB::Expr::from_u32(RV32_MEMORY_AS), dst_ptr_val), - result, - timestamp_pp() + time_delta.clone(), - &local_cols.writes_aux, - ) - .eval(builder, is_last_row.clone()); - - self.execution_bridge - .execute_and_increment_pc( - AB::Expr::from_usize(Rv32Sha256Opcode::SHA256.global_opcode().as_usize()), - [ - local_cols.rd_ptr.into(), - local_cols.rs1_ptr.into(), - local_cols.rs2_ptr.into(), - AB::Expr::from_u32(RV32_REGISTER_AS), - AB::Expr::from_u32(RV32_MEMORY_AS), - ], - local_cols.from_state, - AB::Expr::from_usize(timestamp_delta) + time_delta.clone(), - ) - .eval(builder, is_last_row.clone()); - - // Assert that we read the correct length of the message - let len_val = compose::(&local_cols.len_data.map(|x| x.into()), RV32_CELL_BITS); - builder - .when(is_last_row.clone()) - .assert_eq(local_cols.control.len, len_val); - // Assert that we started reading from the correct pointer initially - let src_val = compose::(&local_cols.src_ptr.map(|x| x.into()), RV32_CELL_BITS); - builder - .when(is_last_row.clone()) - .assert_eq(local_cols.control.read_ptr, src_val + read_ptr_delta); - // Assert that we started reading from the correct timestamp - builder.when(is_last_row.clone()).assert_eq( - local_cols.control.cur_timestamp, - local_cols.from_state.timestamp + AB::Expr::from_u32(3) + time_delta, - ); - } -} diff --git a/extensions/sha256/circuit/src/sha256_chip/columns.rs b/extensions/sha256/circuit/src/sha256_chip/columns.rs deleted file mode 100644 index 38c13a0f73..0000000000 --- a/extensions/sha256/circuit/src/sha256_chip/columns.rs +++ /dev/null @@ -1,70 +0,0 @@ -//! WARNING: the order of fields in the structs is important, do not change it - -use openvm_circuit::{ - arch::ExecutionState, - system::memory::offline_checker::{MemoryReadAuxCols, MemoryWriteAuxCols}, -}; -use openvm_circuit_primitives::AlignedBorrow; -use openvm_instructions::riscv::RV32_REGISTER_NUM_LIMBS; -use openvm_sha256_air::{Sha256DigestCols, Sha256RoundCols}; - -use super::{SHA256_REGISTER_READS, SHA256_WRITE_SIZE}; - -/// the first 16 rows of every SHA256 block will be of type Sha256VmRoundCols and the last row will -/// be of type Sha256VmDigestCols -#[repr(C)] -#[derive(Clone, Copy, Debug, AlignedBorrow)] -pub struct Sha256VmRoundCols { - pub control: Sha256VmControlCols, - pub inner: Sha256RoundCols, - pub read_aux: MemoryReadAuxCols, -} - -#[repr(C)] -#[derive(Clone, Copy, Debug, AlignedBorrow)] -pub struct Sha256VmDigestCols { - pub control: Sha256VmControlCols, - pub inner: Sha256DigestCols, - - pub from_state: ExecutionState, - /// It is counter intuitive, but we will constrain the register reads on the very last row of - /// every message - pub rd_ptr: T, - pub rs1_ptr: T, - pub rs2_ptr: T, - pub dst_ptr: [T; RV32_REGISTER_NUM_LIMBS], - pub src_ptr: [T; RV32_REGISTER_NUM_LIMBS], - pub len_data: [T; RV32_REGISTER_NUM_LIMBS], - pub register_reads_aux: [MemoryReadAuxCols; SHA256_REGISTER_READS], - pub writes_aux: MemoryWriteAuxCols, -} - -/// These are the columns that are used on both round and digest rows -#[repr(C)] -#[derive(Clone, Copy, Debug, AlignedBorrow)] -pub struct Sha256VmControlCols { - /// Note: We will use the buffer in `inner.message_schedule` as the message data - /// This is the length of the entire message in bytes - pub len: T, - /// Need to keep timestamp and read_ptr since block reads don't have the necessary information - pub cur_timestamp: T, - pub read_ptr: T, - /// Padding flags which will be used to encode the the number of non-padding cells in the - /// current row - pub pad_flags: [T; 6], - /// A boolean flag that indicates whether a padding already occurred - pub padding_occurred: T, -} - -/// Width of the Sha256VmControlCols -pub const SHA256VM_CONTROL_WIDTH: usize = Sha256VmControlCols::::width(); -/// Width of the Sha256VmRoundCols -pub const SHA256VM_ROUND_WIDTH: usize = Sha256VmRoundCols::::width(); -/// Width of the Sha256VmDigestCols -pub const SHA256VM_DIGEST_WIDTH: usize = Sha256VmDigestCols::::width(); -/// Width of the Sha256Cols -pub const SHA256VM_WIDTH: usize = if SHA256VM_ROUND_WIDTH > SHA256VM_DIGEST_WIDTH { - SHA256VM_ROUND_WIDTH -} else { - SHA256VM_DIGEST_WIDTH -}; diff --git a/extensions/sha256/circuit/src/sha256_chip/cuda.rs b/extensions/sha256/circuit/src/sha256_chip/cuda.rs deleted file mode 100644 index 14a2809fdf..0000000000 --- a/extensions/sha256/circuit/src/sha256_chip/cuda.rs +++ /dev/null @@ -1,127 +0,0 @@ -// crates/tracegen/src/extensions/sha256/mod.rs - -use std::{iter::repeat_n, sync::Arc}; - -use derive_new::new; -use openvm_circuit::{ - arch::{DenseRecordArena, MultiRowLayout, RecordSeeker}, - utils::next_power_of_two_or_zero, -}; -use openvm_circuit_primitives::{ - bitwise_op_lookup::BitwiseOperationLookupChipGPU, var_range::VariableRangeCheckerChipGPU, Chip, -}; -use openvm_cuda_backend::{base::DeviceMatrix, prelude::F, GpuBackend}; -use openvm_cuda_common::{copy::MemCopyH2D, d_buffer::DeviceBuffer}; -use openvm_instructions::riscv::RV32_CELL_BITS; -use openvm_sha256_air::{get_sha256_num_blocks, SHA256_HASH_WORDS, SHA256_ROWS_PER_BLOCK}; -use openvm_stark_backend::prover::AirProvingContext; - -use crate::{ - cuda_abi::sha256::{ - sha256_fill_invalid_rows, sha256_first_pass_tracegen, sha256_hash_computation, - sha256_second_pass_dependencies, - }, - Sha256VmMetadata, Sha256VmRecordMut, SHA256VM_WIDTH, -}; - -// ===== SHA256 GPU CHIP IMPLEMENTATION ===== -#[derive(new)] -pub struct Sha256VmChipGpu { - pub range_checker: Arc, - pub bitwise_lookup: Arc>, - pub ptr_max_bits: u32, - pub timestamp_max_bits: u32, -} - -impl Chip for Sha256VmChipGpu { - fn generate_proving_ctx(&self, mut arena: DenseRecordArena) -> AirProvingContext { - let records = arena.allocated_mut(); - if records.is_empty() { - return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); - } - - let mut record_offsets = Vec::::new(); - let mut block_to_record_idx = Vec::::new(); - let mut block_offsets = Vec::::new(); - let mut offset_so_far = 0; - let mut num_blocks_so_far: u32 = 0; - - while offset_so_far < records.len() { - record_offsets.push(offset_so_far); - block_offsets.push(num_blocks_so_far); - - let record = RecordSeeker::< - DenseRecordArena, - Sha256VmRecordMut, - MultiRowLayout, - >::get_record_at(&mut offset_so_far, records); - - let num_blocks = get_sha256_num_blocks(record.inner.len); - let record_idx = record_offsets.len() - 1; - - block_to_record_idx.extend(repeat_n(record_idx as u32, num_blocks as usize)); - num_blocks_so_far += num_blocks; - } - - assert_eq!(num_blocks_so_far as usize, block_to_record_idx.len()); - assert_eq!(offset_so_far, records.len()); - assert_eq!(block_offsets.len(), record_offsets.len()); - - let d_records = records.to_device().unwrap(); - let d_record_offsets = record_offsets.to_device().unwrap(); - let d_block_offsets = block_offsets.to_device().unwrap(); - let d_block_to_record_idx = block_to_record_idx.to_device().unwrap(); - - let d_prev_hashes = DeviceBuffer::::with_capacity( - num_blocks_so_far as usize * SHA256_HASH_WORDS, // 8 words per SHA256 hash block - ); - - unsafe { - sha256_hash_computation( - &d_records, - record_offsets.len(), - &d_record_offsets, - &d_block_offsets, - &d_prev_hashes, - num_blocks_so_far, - ) - .expect("Hash computation kernel failed"); - } - - let rows_used = num_blocks_so_far as usize * SHA256_ROWS_PER_BLOCK; - let trace_height = next_power_of_two_or_zero(rows_used); - let d_trace = DeviceMatrix::::with_capacity(trace_height, SHA256VM_WIDTH); - - unsafe { - sha256_first_pass_tracegen( - d_trace.buffer(), - trace_height, - &d_records, - record_offsets.len(), - &d_record_offsets, - &d_block_offsets, - &d_block_to_record_idx, - num_blocks_so_far, - &d_prev_hashes, - self.ptr_max_bits, - &self.range_checker.count, - &self.bitwise_lookup.count, - RV32_CELL_BITS as u32, - self.timestamp_max_bits, - ) - .expect("First pass trace generation failed"); - } - - unsafe { - sha256_fill_invalid_rows(d_trace.buffer(), trace_height, rows_used) - .expect("Invalid rows filling failed"); - } - - unsafe { - sha256_second_pass_dependencies(d_trace.buffer(), trace_height, rows_used) - .expect("Second pass trace generation failed"); - } - - AirProvingContext::simple_no_pis(d_trace) - } -} diff --git a/extensions/sha256/circuit/src/sha256_chip/mod.rs b/extensions/sha256/circuit/src/sha256_chip/mod.rs deleted file mode 100644 index eb027bd6d1..0000000000 --- a/extensions/sha256/circuit/src/sha256_chip/mod.rs +++ /dev/null @@ -1,78 +0,0 @@ -//! Sha256 hasher. Handles full sha256 hashing with padding. -//! variable length inputs read from VM memory. - -use openvm_circuit::arch::*; -use openvm_circuit_primitives::{ - bitwise_op_lookup::SharedBitwiseOperationLookupChip, encoder::Encoder, -}; -use openvm_instructions::riscv::RV32_CELL_BITS; -use openvm_sha256_air::{Sha256FillerHelper, SHA256_BLOCK_BITS}; -use sha2::{Digest, Sha256}; - -mod air; -mod columns; -mod execution; -mod trace; - -pub use air::*; -pub use columns::*; -pub use trace::*; - -#[cfg(feature = "cuda")] -mod cuda; -#[cfg(feature = "cuda")] -pub use cuda::*; - -#[cfg(test)] -mod tests; - -// ==== Constants for register/memory adapter ==== -/// Register reads to get dst, src, len -const SHA256_REGISTER_READS: usize = 3; -/// Number of cells to read in a single memory access -const SHA256_READ_SIZE: usize = 16; -/// Number of cells to write in a single memory access -const SHA256_WRITE_SIZE: usize = 32; -/// Number of rv32 cells read in a SHA256 block -pub const SHA256_BLOCK_CELLS: usize = SHA256_BLOCK_BITS / RV32_CELL_BITS; -/// Number of rows we will do a read on for each SHA256 block -pub const SHA256_NUM_READ_ROWS: usize = SHA256_BLOCK_CELLS / SHA256_READ_SIZE; -/// Maximum message length that this chip supports in bytes -pub const SHA256_MAX_MESSAGE_LEN: usize = 1 << 29; - -pub type Sha256VmChip = VmChipWrapper; - -#[derive(derive_new::new, Clone)] -pub struct Sha256VmExecutor { - pub offset: usize, - pub pointer_max_bits: usize, -} - -pub struct Sha256VmFiller { - pub inner: Sha256FillerHelper, - pub padding_encoder: Encoder, - pub bitwise_lookup_chip: SharedBitwiseOperationLookupChip, - pub pointer_max_bits: usize, -} - -impl Sha256VmFiller { - pub fn new( - bitwise_lookup_chip: SharedBitwiseOperationLookupChip, - pointer_max_bits: usize, - ) -> Self { - Self { - inner: Sha256FillerHelper::new(), - padding_encoder: Encoder::new(PaddingFlags::COUNT, 2, false), - bitwise_lookup_chip, - pointer_max_bits, - } - } -} - -pub fn sha256_solve(input_message: &[u8]) -> [u8; SHA256_WRITE_SIZE] { - let mut hasher = Sha256::new(); - hasher.update(input_message); - let mut output = [0u8; SHA256_WRITE_SIZE]; - output.copy_from_slice(hasher.finalize().as_ref()); - output -} diff --git a/extensions/sha256/circuit/src/sha256_chip/tests.rs b/extensions/sha256/circuit/src/sha256_chip/tests.rs deleted file mode 100644 index 8f3b0243d6..0000000000 --- a/extensions/sha256/circuit/src/sha256_chip/tests.rs +++ /dev/null @@ -1,376 +0,0 @@ -use std::{array, sync::Arc}; - -use hex::FromHex; -use openvm_circuit::{ - arch::{ - testing::{ - memory::gen_pointer, TestBuilder, TestChipHarness, VmChipTestBuilder, - BITWISE_OP_LOOKUP_BUS, - }, - Arena, MatrixRecordArena, PreflightExecutor, - }, - system::{memory::SharedMemoryHelper, SystemPort}, - utils::get_random_message, -}; -use openvm_circuit_primitives::bitwise_op_lookup::{ - BitwiseOperationLookupAir, BitwiseOperationLookupBus, BitwiseOperationLookupChip, - SharedBitwiseOperationLookupChip, -}; -use openvm_instructions::{ - instruction::Instruction, - riscv::{RV32_CELL_BITS, RV32_MEMORY_AS}, - LocalOpcode, -}; -use openvm_sha256_air::{get_sha256_num_blocks, SHA256_BLOCK_U8S}; -use openvm_sha256_transpiler::Rv32Sha256Opcode::{self, *}; -use openvm_stark_backend::{interaction::BusIndex, p3_field::PrimeCharacteristicRing}; -use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng}; -use rand::{rngs::StdRng, Rng}; -#[cfg(feature = "cuda")] -use { - crate::{Sha256VmChipGpu, Sha256VmRecordMut}, - openvm_circuit::arch::testing::{ - default_bitwise_lookup_bus, GpuChipTestBuilder, GpuTestChipHarness, - }, -}; - -use super::{Sha256VmAir, Sha256VmChip, Sha256VmExecutor}; -use crate::{sha256_solve, Sha256VmDigestCols, Sha256VmFiller, Sha256VmRoundCols}; - -type F = BabyBear; -const SELF_BUS_IDX: BusIndex = 28; -const MAX_INS_CAPACITY: usize = 4096; -type Harness = TestChipHarness, RA>; - -fn create_harness_fields( - system_port: SystemPort, - bitwise_chip: Arc>, - memory_helper: SharedMemoryHelper, - address_bits: usize, -) -> (Sha256VmAir, Sha256VmExecutor, Sha256VmChip) { - let air = Sha256VmAir::new(system_port, bitwise_chip.bus(), address_bits, SELF_BUS_IDX); - let executor = Sha256VmExecutor::new(Rv32Sha256Opcode::CLASS_OFFSET, address_bits); - let chip = Sha256VmChip::new( - Sha256VmFiller::new(bitwise_chip, address_bits), - memory_helper, - ); - (air, executor, chip) -} - -fn create_harness( - tester: &mut VmChipTestBuilder, -) -> ( - Harness, - ( - BitwiseOperationLookupAir, - SharedBitwiseOperationLookupChip, - ), -) { - let bitwise_bus = BitwiseOperationLookupBus::new(BITWISE_OP_LOOKUP_BUS); - let bitwise_chip = Arc::new(BitwiseOperationLookupChip::::new( - bitwise_bus, - )); - let (air, executor, chip) = create_harness_fields( - tester.system_port(), - bitwise_chip.clone(), - tester.memory_helper(), - tester.address_bits(), - ); - let harness = Harness::::with_capacity(executor, air, chip, MAX_INS_CAPACITY); - (harness, (bitwise_chip.air, bitwise_chip)) -} - -fn set_and_execute>( - tester: &mut impl TestBuilder, - executor: &mut E, - arena: &mut RA, - rng: &mut StdRng, - opcode: Rv32Sha256Opcode, - message: Option<&[u8]>, - len: Option, -) { - let len = len.unwrap_or(rng.random_range(1..3000)); - let tmp = get_random_message(rng, len); - let message: &[u8] = message.unwrap_or(&tmp); - let len = message.len(); - - let rd = gen_pointer(rng, 4); - let rs1 = gen_pointer(rng, 4); - let rs2 = gen_pointer(rng, 4); - - let dst_ptr = gen_pointer(rng, 4); - let src_ptr = gen_pointer(rng, 4); - tester.write(1, rd, dst_ptr.to_le_bytes().map(F::from_u8)); - tester.write(1, rs1, src_ptr.to_le_bytes().map(F::from_u8)); - tester.write(1, rs2, len.to_le_bytes().map(F::from_u8)); - - // Adding random memory after the message - let num_blocks = get_sha256_num_blocks(len as u32) as usize; - for offset in (0..num_blocks * SHA256_BLOCK_U8S).step_by(4) { - let chunk: [F; 4] = array::from_fn(|i| { - if offset + i < message.len() { - F::from_u8(message[offset + i]) - } else { - F::from_u8(rng.random()) - } - }); - - tester.write(RV32_MEMORY_AS as usize, src_ptr + offset, chunk); - } - - tester.execute( - executor, - arena, - &Instruction::from_usize(opcode.global_opcode(), [rd, rs1, rs2, 1, 2]), - ); - - let output = sha256_solve(message); - assert_eq!( - output.map(F::from_u8), - tester.read::<32>(RV32_MEMORY_AS as usize, dst_ptr) - ); -} - -/////////////////////////////////////////////////////////////////////////////////////// -/// POSITIVE TESTS -/// -/// Randomly generate computations and execute, ensuring that the generated trace -/// passes all constraints. -/////////////////////////////////////////////////////////////////////////////////////// -#[test] -fn rand_sha256_test() { - let mut rng = create_seeded_rng(); - let mut tester = VmChipTestBuilder::default(); - let (mut harness, bitwise) = create_harness(&mut tester); - - let num_ops: usize = 10; - for _ in 0..num_ops { - set_and_execute( - &mut tester, - &mut harness.executor, - &mut harness.arena, - &mut rng, - SHA256, - None, - None, - ); - } - - let tester = tester - .build() - .load(harness) - .load_periphery(bitwise) - .finalize(); - tester.simple_test().expect("Verification failed"); -} - -#[test] -fn sha256_edge_test_lengths() { - let mut rng = create_seeded_rng(); - let mut tester = VmChipTestBuilder::default(); - let (mut harness, bitwise) = create_harness(&mut tester); - - let test_vectors = [ - ("", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"), - ( - "98c1c0bdb7d5fea9a88859f06c6c439f", - "b6b2c9c9b6f30e5c66c977f1bd7ad97071bee739524aecf793384890619f2b05", - ), - ("5b58f4163e248467cc1cd3eecafe749e8e2baaf82c0f63af06df0526347d7a11327463c115210a46b6740244eddf370be89c", "ac0e25049870b91d78ef6807bb87fce4603c81abd3c097fba2403fd18b6ce0b7"), - ("9ad198539e3160194f38ac076a782bd5210a007560d1fce9ef78f8a4a5e4d78c6b96c250cff3520009036e9c6087d5dab587394edda862862013de49a12072485a6c01165ec0f28ffddf1873fbd53e47fcd02fb6a5ccc9622d5588a92429c663ce298cb71b50022fc2ec4ba9f5bbd250974e1a607b165fee16e8f3f2be20d7348b91a2f518ce928491900d56d9f86970611580350cee08daea7717fe28a73b8dcfdea22a65ed9f5a09198de38e4e4f2cc05b0ba3dd787a5363ab6c9f39dcb66c1a29209b1d6b1152769395df8150b4316658ea6ab19af94903d643fcb0ae4d598035ebe73c8b1b687df1ab16504f633c929569c6d0e5fae6eea43838fbc8ce2c2b43161d0addc8ccf945a9c4e06294e56a67df0000f561f61b630b1983ba403e775aaeefa8d339f669d1e09ead7eae979383eda983321e1743e5404b4b328da656de79ff52d179833a6bd5129f49432d74d001996c37c68d9ab49fcff8061d193576f396c20e1f0d9ee83a51290ba60efa9c3cb2e15b756321a7ca668cdbf63f95ec33b1c450aa100101be059dc00077245b25a6a66698dee81953ed4a606944076e2858b1420de0095a7f60b08194d6d9a997009d345c71f63a7034b976e409af8a9a040ac7113664609a7adedb76b2fadf04b0348392a1650526eb2a4d6ed5e4bbcda8aabc8488b38f4f5d9a398103536bb8250ed82a9b9825f7703c263f9e", "080ad71239852124fc26758982090611b9b19abf22d22db3a57f67a06e984a23") - ]; - - for (input, _) in test_vectors.iter() { - let input = Vec::from_hex(input).unwrap(); - - set_and_execute( - &mut tester, - &mut harness.executor, - &mut harness.arena, - &mut rng, - SHA256, - Some(&input), - None, - ); - } - - // check every possible input length modulo 64 - for i in 65..=128 { - set_and_execute( - &mut tester, - &mut harness.executor, - &mut harness.arena, - &mut rng, - SHA256, - None, - Some(i), - ); - } - - let tester = tester - .build() - .load(harness) - .load_periphery(bitwise) - .finalize(); - tester.simple_test().expect("Verification failed"); -} - -/////////////////////////////////////////////////////////////////////////////////////// -/// SANITY TESTS -/// -/// Ensure that solve functions produce the correct results. -/////////////////////////////////////////////////////////////////////////////////////// -#[test] -fn execute_roundtrip_sanity_test() { - let mut rng = create_seeded_rng(); - let mut tester = VmChipTestBuilder::default(); - let (mut harness, _) = create_harness::>(&mut tester); - - println!( - "Sha256VmDigestCols::width(): {}", - Sha256VmDigestCols::::width() - ); - println!( - "Sha256VmRoundCols::width(): {}", - Sha256VmRoundCols::::width() - ); - let num_tests: usize = 1; - for _ in 0..num_tests { - set_and_execute( - &mut tester, - &mut harness.executor, - &mut harness.arena, - &mut rng, - SHA256, - None, - None, - ); - } -} - -#[test] -fn sha256_solve_sanity_check() { - let input = b"Axiom is the best! Axiom is the best! Axiom is the best! Axiom is the best!"; - let output = sha256_solve(input); - let expected: [u8; 32] = [ - 99, 196, 61, 185, 226, 212, 131, 80, 154, 248, 97, 108, 157, 55, 200, 226, 160, 73, 207, - 46, 245, 169, 94, 255, 42, 136, 193, 15, 40, 133, 173, 22, - ]; - assert_eq!(output, expected); -} - -// //////////////////////////////////////////////////////////////////////////////////// -// CUDA TESTS -// -// Ensure GPU tracegen is equivalent to CPU tracegen -// //////////////////////////////////////////////////////////////////////////////////// - -#[cfg(feature = "cuda")] -type GpuHarness = - GpuTestChipHarness>; - -#[cfg(feature = "cuda")] -fn create_cuda_harness(tester: &GpuChipTestBuilder) -> GpuHarness { - const GPU_MAX_INS_CAPACITY: usize = 8192; - - let bitwise_bus = default_bitwise_lookup_bus(); - let dummy_bitwise_chip = Arc::new(BitwiseOperationLookupChip::::new( - bitwise_bus, - )); - - let (air, executor, cpu_chip) = create_harness_fields( - tester.system_port(), - dummy_bitwise_chip, - tester.dummy_memory_helper(), - tester.address_bits(), - ); - let gpu_chip = Sha256VmChipGpu::new( - tester.range_checker(), - tester.bitwise_op_lookup(), - tester.address_bits() as u32, - tester.timestamp_max_bits() as u32, - ); - - GpuTestChipHarness::with_capacity(executor, air, gpu_chip, cpu_chip, GPU_MAX_INS_CAPACITY) -} - -#[cfg(feature = "cuda")] -#[test] -fn test_cuda_sha256_tracegen() { - let mut rng = create_seeded_rng(); - let mut tester = - GpuChipTestBuilder::default().with_bitwise_op_lookup(default_bitwise_lookup_bus()); - - let mut harness = create_cuda_harness(&tester); - - let num_ops = 70; - for i in 1..=num_ops { - set_and_execute( - &mut tester, - &mut harness.executor, - &mut harness.dense_arena, - &mut rng, - SHA256, - None, - Some(i), - ); - } - - harness - .dense_arena - .get_record_seeker::() - .transfer_to_matrix_arena(&mut harness.matrix_arena); - - tester - .build() - .load_gpu_harness(harness) - .finalize() - .simple_test() - .unwrap(); -} - -#[cfg(feature = "cuda")] -#[test] -fn test_cuda_sha256_known_vectors() { - let mut rng = create_seeded_rng(); - let mut tester = - GpuChipTestBuilder::default().with_bitwise_op_lookup(default_bitwise_lookup_bus()); - - let mut harness = create_cuda_harness(&tester); - - let test_vectors = [ - ("", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"), - ( - "98c1c0bdb7d5fea9a88859f06c6c439f", - "b6b2c9c9b6f30e5c66c977f1bd7ad97071bee739524aecf793384890619f2b05", - ), - ("5b58f4163e248467cc1cd3eecafe749e8e2baaf82c0f63af06df0526347d7a11327463c115210a46b6740244eddf370be89c", "ac0e25049870b91d78ef6807bb87fce4603c81abd3c097fba2403fd18b6ce0b7"), - ("9ad198539e3160194f38ac076a782bd5210a007560d1fce9ef78f8a4a5e4d78c6b96c250cff3520009036e9c6087d5dab587394edda862862013de49a12072485a6c01165ec0f28ffddf1873fbd53e47fcd02fb6a5ccc9622d5588a92429c663ce298cb71b50022fc2ec4ba9f5bbd250974e1a607b165fee16e8f3f2be20d7348b91a2f518ce928491900d56d9f86970611580350cee08daea7717fe28a73b8dcfdea22a65ed9f5a09198de38e4e4f2cc05b0ba3dd787a5363ab6c9f39dcb66c1a29209b1d6b1152769395df8150b4316658ea6ab19af94903d643fcb0ae4d598035ebe73c8b1b687df1ab16504f633c929569c6d0e5fae6eea43838fbc8ce2c2b43161d0addc8ccf945a9c4e06294e56a67df0000f561f61b630b1983ba403e775aaeefa8d339f669d1e09ead7eae979383eda983321e1743e5404b4b328da656de79ff52d179833a6bd5129f49432d74d001996c37c68d9ab49fcff8061d193576f396c20e1f0d9ee83a51290ba60efa9c3cb2e15b756321a7ca668cdbf63f95ec33b1c450aa100101be059dc00077245b25a6a66698dee81953ed4a606944076e2858b1420de0095a7f60b08194d6d9a997009d345c71f63a7034b976e409af8a9a040ac7113664609a7adedb76b2fadf04b0348392a1650526eb2a4d6ed5e4bbcda8aabc8488b38f4f5d9a398103536bb8250ed82a9b9825f7703c263f9e", "080ad71239852124fc26758982090611b9b19abf22d22db3a57f67a06e984a23") - ]; - - for (input, _) in test_vectors.iter() { - let input = Vec::from_hex(input).unwrap(); - - set_and_execute( - &mut tester, - &mut harness.executor, - &mut harness.dense_arena, - &mut rng, - SHA256, - Some(&input), - None, - ); - } - - harness - .dense_arena - .get_record_seeker::() - .transfer_to_matrix_arena(&mut harness.matrix_arena); - - tester - .build() - .load_gpu_harness(harness) - .finalize() - .simple_test() - .unwrap(); -} diff --git a/extensions/sha256/circuit/src/sha256_chip/trace.rs b/extensions/sha256/circuit/src/sha256_chip/trace.rs deleted file mode 100644 index 0b3d317e0b..0000000000 --- a/extensions/sha256/circuit/src/sha256_chip/trace.rs +++ /dev/null @@ -1,623 +0,0 @@ -use std::{ - array, - borrow::{Borrow, BorrowMut}, - cmp::min, -}; - -use openvm_circuit::{ - arch::*, - system::memory::{ - offline_checker::{MemoryReadAuxRecord, MemoryWriteBytesAuxRecord}, - online::TracingMemory, - MemoryAuxColsFactory, - }, -}; -use openvm_circuit_primitives::AlignedBytesBorrow; -use openvm_instructions::{ - instruction::Instruction, - program::DEFAULT_PC_STEP, - riscv::{RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS}, - LocalOpcode, -}; -use openvm_rv32im_circuit::adapters::{read_rv32_register, tracing_read, tracing_write}; -use openvm_sha256_air::{ - get_flag_pt_array, get_sha256_num_blocks, Sha256FillerHelper, SHA256_BLOCK_BITS, SHA256_H, - SHA256_ROWS_PER_BLOCK, -}; -use openvm_sha256_transpiler::Rv32Sha256Opcode; -use openvm_stark_backend::{ - p3_field::PrimeField32, - p3_matrix::{dense::RowMajorMatrix, Matrix}, - p3_maybe_rayon::prelude::*, -}; - -use super::{ - Sha256VmDigestCols, Sha256VmExecutor, Sha256VmRoundCols, SHA256VM_CONTROL_WIDTH, - SHA256VM_DIGEST_WIDTH, -}; -use crate::{ - sha256_chip::{PaddingFlags, SHA256_READ_SIZE, SHA256_REGISTER_READS, SHA256_WRITE_SIZE}, - sha256_solve, Sha256VmControlCols, Sha256VmFiller, SHA256VM_ROUND_WIDTH, SHA256VM_WIDTH, - SHA256_BLOCK_CELLS, SHA256_MAX_MESSAGE_LEN, SHA256_NUM_READ_ROWS, -}; - -#[derive(Clone, Copy)] -pub struct Sha256VmMetadata { - pub num_blocks: u32, -} - -impl MultiRowMetadata for Sha256VmMetadata { - #[inline(always)] - fn get_num_rows(&self) -> usize { - self.num_blocks as usize * SHA256_ROWS_PER_BLOCK - } -} - -pub(crate) type Sha256VmRecordLayout = MultiRowLayout; - -#[repr(C)] -#[derive(AlignedBytesBorrow, Debug, Clone)] -pub struct Sha256VmRecordHeader { - pub from_pc: u32, - pub timestamp: u32, - pub rd_ptr: u32, - pub rs1_ptr: u32, - pub rs2_ptr: u32, - pub dst_ptr: u32, - pub src_ptr: u32, - pub len: u32, - - pub register_reads_aux: [MemoryReadAuxRecord; SHA256_REGISTER_READS], - pub write_aux: MemoryWriteBytesAuxRecord, -} - -pub struct Sha256VmRecordMut<'a> { - pub inner: &'a mut Sha256VmRecordHeader, - // Having a continuous slice of the input is useful for fast hashing in `execute` - pub input: &'a mut [u8], - pub read_aux: &'a mut [MemoryReadAuxRecord], -} - -/// Custom borrowing that splits the buffer into a fixed `Sha256VmRecord` header -/// followed by a slice of `u8`'s of length `SHA256_BLOCK_CELLS * num_blocks` where `num_blocks` is -/// provided at runtime, followed by a slice of `MemoryReadAuxRecord`'s of length -/// `SHA256_NUM_READ_ROWS * num_blocks`. Uses `align_to_mut()` to make sure the slice is properly -/// aligned to `MemoryReadAuxRecord`. Has debug assertions that check the size and alignment of the -/// slices. -impl<'a> CustomBorrow<'a, Sha256VmRecordMut<'a>, Sha256VmRecordLayout> for [u8] { - fn custom_borrow(&'a mut self, layout: Sha256VmRecordLayout) -> Sha256VmRecordMut<'a> { - // SAFETY: - // - Caller guarantees through the layout that self has sufficient length for all splits and - // constants are guaranteed <= self.len() by layout precondition - let (header_buf, rest) = - unsafe { self.split_at_mut_unchecked(size_of::()) }; - - // SAFETY: - // - layout guarantees rest has sufficient length for input data - // - The layout size calculation includes num_blocks * SHA256_BLOCK_CELLS bytes after header - // - num_blocks is derived from the message length ensuring correct sizing - // - SHA256_BLOCK_CELLS is a compile-time constant (64 bytes per block) - let (input, rest) = unsafe { - rest.split_at_mut_unchecked((layout.metadata.num_blocks as usize) * SHA256_BLOCK_CELLS) - }; - - // SAFETY: - // - rest is a valid mutable slice from the previous split - // - align_to_mut guarantees the middle slice is properly aligned for MemoryReadAuxRecord - // - The subslice operation [..num_blocks * SHA256_NUM_READ_ROWS] validates sufficient - // capacity - // - Layout calculation ensures space for alignment padding plus required aux records - let (_, read_aux_buf, _) = unsafe { rest.align_to_mut::() }; - Sha256VmRecordMut { - inner: header_buf.borrow_mut(), - input, - read_aux: &mut read_aux_buf - [..(layout.metadata.num_blocks as usize) * SHA256_NUM_READ_ROWS], - } - } - - unsafe fn extract_layout(&self) -> Sha256VmRecordLayout { - let header: &Sha256VmRecordHeader = self.borrow(); - Sha256VmRecordLayout { - metadata: Sha256VmMetadata { - num_blocks: get_sha256_num_blocks(header.len), - }, - } - } -} - -impl SizedRecord for Sha256VmRecordMut<'_> { - fn size(layout: &Sha256VmRecordLayout) -> usize { - let mut total_len = size_of::(); - total_len += layout.metadata.num_blocks as usize * SHA256_BLOCK_CELLS; - // Align the pointer to the alignment of `MemoryReadAuxRecord` - total_len = total_len.next_multiple_of(align_of::()); - total_len += layout.metadata.num_blocks as usize - * SHA256_NUM_READ_ROWS - * size_of::(); - total_len - } - - fn alignment(_layout: &Sha256VmRecordLayout) -> usize { - align_of::() - } -} - -impl PreflightExecutor for Sha256VmExecutor -where - F: PrimeField32, - for<'buf> RA: RecordArena<'buf, Sha256VmRecordLayout, Sha256VmRecordMut<'buf>>, -{ - fn get_opcode_name(&self, _: usize) -> String { - format!("{:?}", Rv32Sha256Opcode::SHA256) - } - - fn execute( - &self, - state: VmStateMut, - instruction: &Instruction, - ) -> Result<(), ExecutionError> { - let Instruction { - opcode, - a, - b, - c, - d, - e, - .. - } = instruction; - debug_assert_eq!(*opcode, Rv32Sha256Opcode::SHA256.global_opcode()); - debug_assert_eq!(d.as_canonical_u32(), RV32_REGISTER_AS); - debug_assert_eq!(e.as_canonical_u32(), RV32_MEMORY_AS); - - // Reading the length first to allocate a record of correct size - let len = read_rv32_register(state.memory.data(), c.as_canonical_u32()); - - let num_blocks = get_sha256_num_blocks(len); - let record = state.ctx.alloc(MultiRowLayout { - metadata: Sha256VmMetadata { num_blocks }, - }); - - record.inner.from_pc = *state.pc; - record.inner.timestamp = state.memory.timestamp(); - record.inner.rd_ptr = a.as_canonical_u32(); - record.inner.rs1_ptr = b.as_canonical_u32(); - record.inner.rs2_ptr = c.as_canonical_u32(); - - record.inner.dst_ptr = u32::from_le_bytes(tracing_read( - state.memory, - RV32_REGISTER_AS, - record.inner.rd_ptr, - &mut record.inner.register_reads_aux[0].prev_timestamp, - )); - record.inner.src_ptr = u32::from_le_bytes(tracing_read( - state.memory, - RV32_REGISTER_AS, - record.inner.rs1_ptr, - &mut record.inner.register_reads_aux[1].prev_timestamp, - )); - record.inner.len = u32::from_le_bytes(tracing_read( - state.memory, - RV32_REGISTER_AS, - record.inner.rs2_ptr, - &mut record.inner.register_reads_aux[2].prev_timestamp, - )); - - // we will read [num_blocks] * [SHA256_BLOCK_CELLS] cells but only [len] cells will be used - debug_assert!( - record.inner.src_ptr as usize + num_blocks as usize * SHA256_BLOCK_CELLS - <= (1 << self.pointer_max_bits) - ); - debug_assert!( - record.inner.dst_ptr as usize + SHA256_WRITE_SIZE <= (1 << self.pointer_max_bits) - ); - // We don't support messages longer than 2^29 bytes - debug_assert!(record.inner.len < SHA256_MAX_MESSAGE_LEN as u32); - - for block_idx in 0..num_blocks as usize { - // Reads happen on the first 4 rows of each block - for row in 0..SHA256_NUM_READ_ROWS { - let read_idx = block_idx * SHA256_NUM_READ_ROWS + row; - let row_input: [u8; SHA256_READ_SIZE] = tracing_read( - state.memory, - RV32_MEMORY_AS, - record.inner.src_ptr + (read_idx * SHA256_READ_SIZE) as u32, - &mut record.read_aux[read_idx].prev_timestamp, - ); - record.input[read_idx * SHA256_READ_SIZE..(read_idx + 1) * SHA256_READ_SIZE] - .copy_from_slice(&row_input); - } - } - - let output = sha256_solve(&record.input[..len as usize]); - tracing_write( - state.memory, - RV32_MEMORY_AS, - record.inner.dst_ptr, - output, - &mut record.inner.write_aux.prev_timestamp, - &mut record.inner.write_aux.prev_data, - ); - - *state.pc = state.pc.wrapping_add(DEFAULT_PC_STEP); - - Ok(()) - } -} - -impl TraceFiller for Sha256VmFiller { - fn fill_trace( - &self, - mem_helper: &MemoryAuxColsFactory, - trace_matrix: &mut RowMajorMatrix, - rows_used: usize, - ) { - if rows_used == 0 { - return; - } - - let mut chunks = Vec::with_capacity(trace_matrix.height() / SHA256_ROWS_PER_BLOCK); - let mut sizes = Vec::with_capacity(trace_matrix.height() / SHA256_ROWS_PER_BLOCK); - let mut trace = &mut trace_matrix.values[..]; - let mut num_blocks_so_far = 0; - - // First pass over the trace to get the number of blocks for each instruction - // and divide the matrix into chunks of needed sizes - loop { - if num_blocks_so_far * SHA256_ROWS_PER_BLOCK >= rows_used { - // Push all the padding rows as a single chunk and break - chunks.push(trace); - sizes.push((0, num_blocks_so_far)); - break; - } else { - // SAFETY: - // - caller ensures `trace` contains a valid record representation that was - // previously written by the executor - // - header is the first element of the record - let record: &Sha256VmRecordHeader = - unsafe { get_record_from_slice(&mut trace, ()) }; - let num_blocks = ((record.len << 3) as usize + 1 + 64).div_ceil(SHA256_BLOCK_BITS); - let (chunk, rest) = - trace.split_at_mut(SHA256VM_WIDTH * SHA256_ROWS_PER_BLOCK * num_blocks); - chunks.push(chunk); - sizes.push((num_blocks, num_blocks_so_far)); - num_blocks_so_far += num_blocks; - trace = rest; - } - } - - // During the first pass we will fill out most of the matrix - // But there are some cells that can't be generated by the first pass so we will do a second - // pass over the matrix later - chunks.par_iter_mut().zip(sizes.par_iter()).for_each( - |(slice, (num_blocks, global_block_offset))| { - if global_block_offset * SHA256_ROWS_PER_BLOCK >= rows_used { - // Fill in the invalid rows - slice.par_chunks_mut(SHA256VM_WIDTH).for_each(|row| { - // Need to get rid of the accidental garbage data that might overflow the - // F's prime field. Unfortunately, there is no good way around this - // SAFETY: - // - row has exactly SHA256VM_WIDTH elements - // - We're zeroing all SHA256VM_WIDTH elements to clear any garbage data - // that might overflow the field - // - Casting F* to u8* preserves validity for write_bytes operation - // - SHA256VM_WIDTH * size_of::() correctly calculates total bytes to - // zero - unsafe { - std::ptr::write_bytes( - row.as_mut_ptr() as *mut u8, - 0, - SHA256VM_WIDTH * size_of::(), - ); - } - let cols: &mut Sha256VmRoundCols = - row[..SHA256VM_ROUND_WIDTH].borrow_mut(); - self.inner.generate_default_row(&mut cols.inner); - }); - return; - } - - // SAFETY: - // - caller ensures `trace` contains a valid record representation that was - // previously written by the executor - // - slice contains a valid Sha256VmRecord with the exact layout specified - // - get_record_from_slice will correctly split the buffer into header, input, and - // aux components based on this layout - let record: Sha256VmRecordMut = unsafe { - get_record_from_slice( - slice, - Sha256VmRecordLayout { - metadata: Sha256VmMetadata { - num_blocks: *num_blocks as u32, - }, - }, - ) - }; - - let mut input: Vec = Vec::with_capacity(SHA256_BLOCK_CELLS * num_blocks); - input.extend_from_slice(record.input); - let mut padded_input = input.clone(); - let len = record.inner.len as usize; - let padded_input_len = padded_input.len(); - padded_input[len] = 1 << (RV32_CELL_BITS - 1); - padded_input[len + 1..padded_input_len - 4].fill(0); - padded_input[padded_input_len - 4..] - .copy_from_slice(&((len as u32) << 3).to_be_bytes()); - - let mut prev_hashes = Vec::with_capacity(*num_blocks); - prev_hashes.push(SHA256_H); - for i in 0..*num_blocks - 1 { - prev_hashes.push(Sha256FillerHelper::get_block_hash( - &prev_hashes[i], - padded_input[i * SHA256_BLOCK_CELLS..(i + 1) * SHA256_BLOCK_CELLS] - .try_into() - .unwrap(), - )); - } - // Copy the read aux records and input to another place to safely fill in the trace - // matrix without overwriting the record - let mut read_aux_records = Vec::with_capacity(SHA256_NUM_READ_ROWS * num_blocks); - read_aux_records.extend_from_slice(record.read_aux); - let vm_record = record.inner.clone(); - - slice - .par_chunks_exact_mut(SHA256VM_WIDTH * SHA256_ROWS_PER_BLOCK) - .enumerate() - .for_each(|(block_idx, block_slice)| { - // Need to get rid of the accidental garbage data that might overflow the - // F's prime field. Unfortunately, there is no good way around this - // SAFETY: - // - block_slice comes from par_chunks_exact_mut with exact size guarantee - // - Length is SHA256_ROWS_PER_BLOCK * SHA256VM_WIDTH * size_of::() bytes - // - Zeroing entire blocks prevents using garbage data - // - The subsequent trace filling will overwrite with valid values - unsafe { - std::ptr::write_bytes( - block_slice.as_mut_ptr() as *mut u8, - 0, - SHA256_ROWS_PER_BLOCK * SHA256VM_WIDTH * size_of::(), - ); - } - self.fill_block_trace::( - block_slice, - &vm_record, - &read_aux_records[block_idx * SHA256_NUM_READ_ROWS - ..(block_idx + 1) * SHA256_NUM_READ_ROWS], - &input[block_idx * SHA256_BLOCK_CELLS - ..(block_idx + 1) * SHA256_BLOCK_CELLS], - &padded_input[block_idx * SHA256_BLOCK_CELLS - ..(block_idx + 1) * SHA256_BLOCK_CELLS], - block_idx == *num_blocks - 1, - *global_block_offset + block_idx, - block_idx, - prev_hashes[block_idx], - mem_helper, - ); - }); - }, - ); - - // Do a second pass over the trace to fill in the missing values - // Note, we need to skip the very first row - trace_matrix.values[SHA256VM_WIDTH..] - .par_chunks_mut(SHA256VM_WIDTH * SHA256_ROWS_PER_BLOCK) - .take(rows_used / SHA256_ROWS_PER_BLOCK) - .for_each(|chunk| { - self.inner - .generate_missing_cells(chunk, SHA256VM_WIDTH, SHA256VM_CONTROL_WIDTH); - }); - } -} - -impl Sha256VmFiller { - #[allow(clippy::too_many_arguments)] - fn fill_block_trace( - &self, - block_slice: &mut [F], - record: &Sha256VmRecordHeader, - read_aux_records: &[MemoryReadAuxRecord], - input: &[u8], - padded_input: &[u8], - is_last_block: bool, - global_block_idx: usize, - local_block_idx: usize, - prev_hash: [u32; 8], - mem_helper: &MemoryAuxColsFactory, - ) { - debug_assert_eq!(input.len(), SHA256_BLOCK_CELLS); - debug_assert_eq!(padded_input.len(), SHA256_BLOCK_CELLS); - debug_assert_eq!(read_aux_records.len(), SHA256_NUM_READ_ROWS); - - let padded_input = array::from_fn(|i| { - u32::from_be_bytes(padded_input[i * 4..(i + 1) * 4].try_into().unwrap()) - }); - - let block_start_timestamp = record.timestamp - + (SHA256_REGISTER_READS + SHA256_NUM_READ_ROWS * local_block_idx) as u32; - - let read_cells = (SHA256_BLOCK_CELLS * local_block_idx) as u32; - let block_start_read_ptr = record.src_ptr + read_cells; - - let message_left = if record.len <= read_cells { - 0 - } else { - (record.len - read_cells) as usize - }; - - // -1 means that padding occurred before the start of the block - // 18 means that no padding occurred on this block - let first_padding_row = if record.len < read_cells { - -1 - } else if message_left < SHA256_BLOCK_CELLS { - (message_left / SHA256_READ_SIZE) as i32 - } else { - 18 - }; - - // Fill in the VM columns first because the inner `carry_or_buffer` needs to be filled in - block_slice - .par_chunks_exact_mut(SHA256VM_WIDTH) - .enumerate() - .for_each(|(row_idx, row_slice)| { - // Handle round rows and digest row separately - if row_idx == SHA256_ROWS_PER_BLOCK - 1 { - // This is a digest row - let digest_cols: &mut Sha256VmDigestCols = - row_slice[..SHA256VM_DIGEST_WIDTH].borrow_mut(); - digest_cols.from_state.timestamp = F::from_u32(record.timestamp); - digest_cols.from_state.pc = F::from_u32(record.from_pc); - digest_cols.rd_ptr = F::from_u32(record.rd_ptr); - digest_cols.rs1_ptr = F::from_u32(record.rs1_ptr); - digest_cols.rs2_ptr = F::from_u32(record.rs2_ptr); - digest_cols.dst_ptr = record.dst_ptr.to_le_bytes().map(F::from_u8); - digest_cols.src_ptr = record.src_ptr.to_le_bytes().map(F::from_u8); - digest_cols.len_data = record.len.to_le_bytes().map(F::from_u8); - if is_last_block { - digest_cols - .register_reads_aux - .iter_mut() - .zip(record.register_reads_aux.iter()) - .enumerate() - .for_each(|(idx, (cols_read, record_read))| { - mem_helper.fill( - record_read.prev_timestamp, - record.timestamp + idx as u32, - cols_read.as_mut(), - ); - }); - digest_cols - .writes_aux - .set_prev_data(record.write_aux.prev_data.map(F::from_u8)); - // In the last block we do `SHA256_NUM_READ_ROWS` reads and then write the - // result thus the timestamp of the write is - // `block_start_timestamp + SHA256_NUM_READ_ROWS` - mem_helper.fill( - record.write_aux.prev_timestamp, - block_start_timestamp + SHA256_NUM_READ_ROWS as u32, - digest_cols.writes_aux.as_mut(), - ); - // Need to range check the destination and source pointers - let msl_rshift: u32 = - ((RV32_REGISTER_NUM_LIMBS - 1) * RV32_CELL_BITS) as u32; - let msl_lshift: u32 = (RV32_REGISTER_NUM_LIMBS * RV32_CELL_BITS - - self.pointer_max_bits) - as u32; - self.bitwise_lookup_chip.request_range( - (record.dst_ptr >> msl_rshift) << msl_lshift, - (record.src_ptr >> msl_rshift) << msl_lshift, - ); - } else { - // Filling in zeros to make sure the accidental garbage data doesn't - // overflow the prime - digest_cols.register_reads_aux.iter_mut().for_each(|aux| { - mem_helper.fill_zero(aux.as_mut()); - }); - digest_cols - .writes_aux - .set_prev_data([F::ZERO; SHA256_WRITE_SIZE]); - mem_helper.fill_zero(digest_cols.writes_aux.as_mut()); - } - digest_cols.inner.flags.is_last_block = F::from_bool(is_last_block); - digest_cols.inner.flags.is_digest_row = F::from_bool(true); - } else { - // This is a round row - let round_cols: &mut Sha256VmRoundCols = - row_slice[..SHA256VM_ROUND_WIDTH].borrow_mut(); - // Take care of the first 4 round rows (aka read rows) - if row_idx < SHA256_NUM_READ_ROWS { - round_cols - .inner - .message_schedule - .carry_or_buffer - .as_flattened_mut() - .iter_mut() - .zip( - input[row_idx * SHA256_READ_SIZE..(row_idx + 1) * SHA256_READ_SIZE] - .iter(), - ) - .for_each(|(cell, data)| { - *cell = F::from_u8(*data); - }); - mem_helper.fill( - read_aux_records[row_idx].prev_timestamp, - block_start_timestamp + row_idx as u32, - round_cols.read_aux.as_mut(), - ); - } else { - mem_helper.fill_zero(round_cols.read_aux.as_mut()); - } - } - // Fill in the control cols, doesn't matter if it is a round or digest row - let control_cols: &mut Sha256VmControlCols = - row_slice[..SHA256VM_CONTROL_WIDTH].borrow_mut(); - control_cols.len = F::from_u32(record.len); - // Only the first `SHA256_NUM_READ_ROWS` rows increment the timestamp and read ptr - control_cols.cur_timestamp = - F::from_u32(block_start_timestamp + min(row_idx, SHA256_NUM_READ_ROWS) as u32); - control_cols.read_ptr = F::from_u32( - block_start_read_ptr - + (SHA256_READ_SIZE * min(row_idx, SHA256_NUM_READ_ROWS)) as u32, - ); - - // Fill in the padding flags - if row_idx < SHA256_NUM_READ_ROWS { - #[allow(clippy::comparison_chain)] - if (row_idx as i32) < first_padding_row { - control_cols.pad_flags = get_flag_pt_array( - &self.padding_encoder, - PaddingFlags::NotPadding as usize, - ) - .map(F::from_u32); - } else if row_idx as i32 == first_padding_row { - let len = message_left - row_idx * SHA256_READ_SIZE; - control_cols.pad_flags = get_flag_pt_array( - &self.padding_encoder, - if row_idx == 3 && is_last_block { - PaddingFlags::FirstPadding0_LastRow - } else { - PaddingFlags::FirstPadding0 - } as usize - + len, - ) - .map(F::from_u32); - } else { - control_cols.pad_flags = get_flag_pt_array( - &self.padding_encoder, - if row_idx == 3 && is_last_block { - PaddingFlags::EntirePaddingLastRow - } else { - PaddingFlags::EntirePadding - } as usize, - ) - .map(F::from_u32); - } - } else { - control_cols.pad_flags = get_flag_pt_array( - &self.padding_encoder, - PaddingFlags::NotConsidered as usize, - ) - .map(F::from_u32); - } - if is_last_block && row_idx == SHA256_ROWS_PER_BLOCK - 1 { - // If last digest row, then we set padding_occurred = 0 - control_cols.padding_occurred = F::ZERO; - } else { - control_cols.padding_occurred = - F::from_bool((row_idx as i32) >= first_padding_row); - } - }); - - // Fill in the inner trace when the `buffer_or_carry` is filled in - self.inner.generate_block_trace::( - block_slice, - SHA256VM_WIDTH, - SHA256VM_CONTROL_WIDTH, - &padded_input, - self.bitwise_lookup_chip.as_ref(), - &prev_hash, - is_last_block, - global_block_idx as u32 + 1, // global block index is 1-indexed - local_block_idx as u32, - ); - } -} diff --git a/extensions/sha256/guest/src/lib.rs b/extensions/sha256/guest/src/lib.rs deleted file mode 100644 index 8f7c072f4a..0000000000 --- a/extensions/sha256/guest/src/lib.rs +++ /dev/null @@ -1,69 +0,0 @@ -#![no_std] - -#[cfg(target_os = "zkvm")] -use openvm_platform::alloc::AlignedBuf; - -/// This is custom-0 defined in RISC-V spec document -pub const OPCODE: u8 = 0x0b; -pub const SHA256_FUNCT3: u8 = 0b100; -pub const SHA256_FUNCT7: u8 = 0x1; - -/// Native hook for sha256 -/// -/// # Safety -/// -/// The VM accepts the preimage by pointer and length, and writes the -/// 32-byte hash. -/// - `bytes` must point to an input buffer at least `len` long. -/// - `output` must point to a buffer that is at least 32-bytes long. -/// -/// [`sha2`]: https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf -#[cfg(target_os = "zkvm")] -#[inline(always)] -#[no_mangle] -pub extern "C" fn zkvm_sha256_impl(bytes: *const u8, len: usize, output: *mut u8) { - // SAFETY: assuming safety assumptions of the inputs, we handle all cases where `bytes` or - // `output` are not aligned to 4 bytes. - // The minimum alignment required for the input and output buffers - const MIN_ALIGN: usize = 4; - // The preferred alignment for the input buffer, since the input is read in chunks of 16 bytes - const INPUT_ALIGN: usize = 16; - // The preferred alignment for the output buffer, since the output is written in chunks of 32 - // bytes - const OUTPUT_ALIGN: usize = 32; - unsafe { - if bytes as usize % MIN_ALIGN != 0 { - let aligned_buff = AlignedBuf::new(bytes, len, INPUT_ALIGN); - if output as usize % MIN_ALIGN != 0 { - let aligned_out = AlignedBuf::uninit(32, OUTPUT_ALIGN); - __native_sha256(aligned_buff.ptr, len, aligned_out.ptr); - core::ptr::copy_nonoverlapping(aligned_out.ptr as *const u8, output, 32); - } else { - __native_sha256(aligned_buff.ptr, len, output); - } - } else { - if output as usize % MIN_ALIGN != 0 { - let aligned_out = AlignedBuf::uninit(32, OUTPUT_ALIGN); - __native_sha256(bytes, len, aligned_out.ptr); - core::ptr::copy_nonoverlapping(aligned_out.ptr as *const u8, output, 32); - } else { - __native_sha256(bytes, len, output); - } - }; - } -} - -/// sha256 intrinsic binding -/// -/// # Safety -/// -/// The VM accepts the preimage by pointer and length, and writes the -/// 32-byte hash. -/// - `bytes` must point to an input buffer at least `len` long. -/// - `output` must point to a buffer that is at least 32-bytes long. -/// - `bytes` and `output` must be 4-byte aligned. -#[cfg(target_os = "zkvm")] -#[inline(always)] -fn __native_sha256(bytes: *const u8, len: usize, output: *mut u8) { - openvm_platform::custom_insn_r!(opcode = OPCODE, funct3 = SHA256_FUNCT3, funct7 = SHA256_FUNCT7, rd = In output, rs1 = In bytes, rs2 = In len); -} diff --git a/extensions/sha256/transpiler/src/lib.rs b/extensions/sha256/transpiler/src/lib.rs deleted file mode 100644 index 6b13efe055..0000000000 --- a/extensions/sha256/transpiler/src/lib.rs +++ /dev/null @@ -1,46 +0,0 @@ -use openvm_instructions::{riscv::RV32_MEMORY_AS, LocalOpcode}; -use openvm_instructions_derive::LocalOpcode; -use openvm_sha256_guest::{OPCODE, SHA256_FUNCT3, SHA256_FUNCT7}; -use openvm_stark_backend::p3_field::PrimeField32; -use openvm_transpiler::{util::from_r_type, TranspilerExtension, TranspilerOutput}; -use rrs_lib::instruction_formats::RType; -use strum::{EnumCount, EnumIter, FromRepr}; - -#[derive( - Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, EnumCount, EnumIter, FromRepr, LocalOpcode, -)] -#[opcode_offset = 0x320] -#[repr(usize)] -pub enum Rv32Sha256Opcode { - SHA256, -} - -#[derive(Default)] -pub struct Sha256TranspilerExtension; - -impl TranspilerExtension for Sha256TranspilerExtension { - fn process_custom(&self, instruction_stream: &[u32]) -> Option> { - if instruction_stream.is_empty() { - return None; - } - let instruction_u32 = instruction_stream[0]; - let opcode = (instruction_u32 & 0x7f) as u8; - let funct3 = ((instruction_u32 >> 12) & 0b111) as u8; - - if (opcode, funct3) != (OPCODE, SHA256_FUNCT3) { - return None; - } - let dec_insn = RType::new(instruction_u32); - - if dec_insn.funct7 != SHA256_FUNCT7 as u32 { - return None; - } - let instruction = from_r_type( - Rv32Sha256Opcode::SHA256.global_opcode().as_usize(), - RV32_MEMORY_AS as usize, - &dec_insn, - true, - ); - Some(TranspilerOutput::one_to_one(instruction)) - } -} diff --git a/guest-libs/k256/Cargo.toml b/guest-libs/k256/Cargo.toml index 73b412380e..d1147075c3 100644 --- a/guest-libs/k256/Cargo.toml +++ b/guest-libs/k256/Cargo.toml @@ -35,8 +35,8 @@ openvm-transpiler.workspace = true openvm-algebra-transpiler.workspace = true openvm-ecc-transpiler.workspace = true openvm-ecc-circuit.workspace = true -openvm-sha256-circuit.workspace = true -openvm-sha256-transpiler.workspace = true +openvm-sha2-circuit.workspace = true +openvm-sha2-transpiler.workspace = true openvm-rv32im-transpiler.workspace = true openvm-toolchain-tests.workspace = true @@ -72,14 +72,14 @@ pkcs8 = ["ecdsa-core/pkcs8", "elliptic-curve/pkcs8"] precomputed-tables = ["arithmetic", "once_cell"] schnorr = ["arithmetic", "signature"] serde = ["ecdsa-core/serde", "elliptic-curve/serde"] -sha256 = [] +sha2 = [] test-vectors = [] # Internal feature for testing only. cuda = [ "openvm-circuit/cuda", "openvm-ecc-circuit/cuda", - "openvm-sha256-circuit/cuda", + "openvm-sha2-circuit/cuda", ] tco = ["openvm-circuit/tco"] aot = ["openvm-circuit/aot"] diff --git a/guest-libs/k256/src/ecdsa.rs b/guest-libs/k256/src/ecdsa.rs index 69128c0384..29b10f882a 100644 --- a/guest-libs/k256/src/ecdsa.rs +++ b/guest-libs/k256/src/ecdsa.rs @@ -3,7 +3,7 @@ // Use these types instead of unpatched k256::ecdsa::{Signature, VerifyingKey} // because those are type aliases that use non-zkvm implementations -#[cfg(any(feature = "ecdsa", feature = "sha256"))] +#[cfg(any(feature = "ecdsa", feature = "sha2"))] pub use ecdsa_core::hazmat; pub use ecdsa_core::{ signature::{self, Error}, diff --git a/guest-libs/k256/tests/lib.rs b/guest-libs/k256/tests/lib.rs index e80d4a9431..f65a799d8d 100644 --- a/guest-libs/k256/tests/lib.rs +++ b/guest-libs/k256/tests/lib.rs @@ -13,7 +13,7 @@ mod guest_tests { use openvm_rv32im_transpiler::{ Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension, }; - use openvm_sha256_transpiler::Sha256TranspilerExtension; + use openvm_sha2_transpiler::Sha2TranspilerExtension; use openvm_stark_sdk::p3_baby_bear::BabyBear; use openvm_toolchain_tests::{build_example_program_at_path, get_programs_dir}; use openvm_transpiler::{transpiler::Transpiler, FromElf}; @@ -99,7 +99,7 @@ mod guest_tests { CurveConfig, Rv32WeierstrassBuilder, Rv32WeierstrassConfig, Rv32WeierstrassConfigExecutor, }; - use openvm_sha256_circuit::{Sha256, Sha256Executor, Sha256ProverExt}; + use openvm_sha2_circuit::{Sha2, Sha2Executor, Sha2ProverExt}; use serde::{Deserialize, Serialize}; #[cfg(feature = "cuda")] use { @@ -125,14 +125,14 @@ mod guest_tests { #[config(generics = true)] pub weierstrass: Rv32WeierstrassConfig, #[extension] - pub sha256: Sha256, + pub sha2: Sha2, } impl EcdsaConfig { pub fn new(curves: Vec) -> Self { Self { weierstrass: Rv32WeierstrassConfig::new(curves), - sha256: Default::default(), + sha2: Default::default(), } } } @@ -177,8 +177,8 @@ mod guest_tests { )?; let inventory = &mut chip_complex.inventory; VmProverExtension::::extend_prover( - &Sha256ProverExt, - &config.sha256, + &Sha2ProverExt, + &config.sha2, inventory, )?; Ok(chip_complex) @@ -212,8 +212,8 @@ mod guest_tests { )?; let inventory = &mut chip_complex.inventory; VmProverExtension::::extend_prover( - &Sha256ProverExt, - &config.sha256, + &Sha2ProverExt, + &config.sha2, inventory, )?; Ok(chip_complex) @@ -235,7 +235,7 @@ mod guest_tests { .with_extension(Rv32IoTranspilerExtension) .with_extension(EccTranspilerExtension) .with_extension(ModularTranspilerExtension) - .with_extension(Sha256TranspilerExtension), + .with_extension(Sha2TranspilerExtension), )?; air_test(EcdsaBuilder, config, openvm_exe); Ok(()) diff --git a/guest-libs/k256/tests/programs/examples/ecdsa.rs b/guest-libs/k256/tests/programs/examples/ecdsa.rs index d886e80ed0..f66fdf7622 100644 --- a/guest-libs/k256/tests/programs/examples/ecdsa.rs +++ b/guest-libs/k256/tests/programs/examples/ecdsa.rs @@ -3,13 +3,15 @@ extern crate alloc; +use core::hint::black_box; + use ecdsa::RecoveryId; use hex_literal::hex; use openvm_k256::ecdsa::{Signature, VerifyingKey}; // clippy thinks this is unused, but it's used in the init! macro #[allow(unused)] use openvm_k256::Secp256k1Point; -use openvm_sha2::sha256; +use openvm_sha2::{Digest, Sha256}; openvm::init!("openvm_init_ecdsa.rs"); @@ -49,10 +51,12 @@ const RECOVERY_TEST_VECTORS: &[RecoveryTestVector] = &[ // Test public key recovery fn main() { for vector in RECOVERY_TEST_VECTORS { - let digest = sha256(vector.msg); + let mut hasher = Sha256::new(); + hasher.update(black_box(&vector.msg)); + let digest = hasher.finalize(); let sig = Signature::try_from(vector.sig.as_slice()).unwrap(); let recid = vector.recid; - let pk = VerifyingKey::recover_from_prehash(digest.as_slice(), &sig, recid).unwrap(); + let pk = VerifyingKey::recover_from_prehash(&digest, &sig, recid).unwrap(); assert_eq!(&vector.pk[..], &pk.to_sec1_bytes(true)); } } diff --git a/guest-libs/p256/Cargo.toml b/guest-libs/p256/Cargo.toml index b358ea195a..ccbf6270c7 100644 --- a/guest-libs/p256/Cargo.toml +++ b/guest-libs/p256/Cargo.toml @@ -32,8 +32,8 @@ openvm-transpiler.workspace = true openvm-algebra-transpiler.workspace = true openvm-ecc-transpiler.workspace = true openvm-ecc-circuit.workspace = true -openvm-sha256-circuit.workspace = true -openvm-sha256-transpiler.workspace = true +openvm-sha2-circuit.workspace = true +openvm-sha2-transpiler.workspace = true openvm-rv32im-transpiler.workspace = true openvm-toolchain-tests.workspace = true @@ -61,7 +61,7 @@ jwk = ["elliptic-curve/jwk"] pem = ["elliptic-curve/pem", "ecdsa-core/pem", "pkcs8"] pkcs8 = ["ecdsa-core?/pkcs8", "elliptic-curve/pkcs8"] serde = ["ecdsa-core?/serde", "elliptic-curve/serde"] -sha256 = [] +sha2 = [] test-vectors = [] voprf = ["elliptic-curve/voprf"] @@ -69,7 +69,7 @@ voprf = ["elliptic-curve/voprf"] cuda = [ "openvm-circuit/cuda", "openvm-ecc-circuit/cuda", - "openvm-sha256-circuit/cuda", + "openvm-sha2-circuit/cuda", ] tco = ["openvm-circuit/tco"] aot = ["openvm-circuit/aot"] diff --git a/guest-libs/p256/tests/lib.rs b/guest-libs/p256/tests/lib.rs index ad288a1404..131d6a82b7 100644 --- a/guest-libs/p256/tests/lib.rs +++ b/guest-libs/p256/tests/lib.rs @@ -13,7 +13,7 @@ mod guest_tests { use openvm_rv32im_transpiler::{ Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension, }; - use openvm_sha256_transpiler::Sha256TranspilerExtension; + use openvm_sha2_transpiler::Sha2TranspilerExtension; use openvm_stark_sdk::p3_baby_bear::BabyBear; use openvm_toolchain_tests::{build_example_program_at_path, get_programs_dir}; use openvm_transpiler::{transpiler::Transpiler, FromElf}; @@ -99,7 +99,7 @@ mod guest_tests { CurveConfig, Rv32WeierstrassBuilder, Rv32WeierstrassConfig, Rv32WeierstrassConfigExecutor, }; - use openvm_sha256_circuit::{Sha256, Sha256Executor, Sha256ProverExt}; + use openvm_sha2_circuit::{Sha2, Sha2Executor, Sha2ProverExt}; use serde::{Deserialize, Serialize}; #[cfg(feature = "cuda")] use { @@ -125,14 +125,14 @@ mod guest_tests { #[config(generics = true)] pub weierstrass: Rv32WeierstrassConfig, #[extension] - pub sha256: Sha256, + pub sha2: Sha2, } impl EcdsaConfig { pub fn new(curves: Vec) -> Self { Self { weierstrass: Rv32WeierstrassConfig::new(curves), - sha256: Default::default(), + sha2: Default::default(), } } } @@ -177,8 +177,8 @@ mod guest_tests { )?; let inventory = &mut chip_complex.inventory; VmProverExtension::::extend_prover( - &Sha256ProverExt, - &config.sha256, + &Sha2ProverExt, + &config.sha2, inventory, )?; Ok(chip_complex) @@ -212,8 +212,8 @@ mod guest_tests { )?; let inventory = &mut chip_complex.inventory; VmProverExtension::::extend_prover( - &Sha256ProverExt, - &config.sha256, + &Sha2ProverExt, + &config.sha2, inventory, )?; Ok(chip_complex) @@ -235,7 +235,7 @@ mod guest_tests { .with_extension(Rv32IoTranspilerExtension) .with_extension(EccTranspilerExtension) .with_extension(ModularTranspilerExtension) - .with_extension(Sha256TranspilerExtension), + .with_extension(Sha2TranspilerExtension), )?; air_test(EcdsaBuilder, config, openvm_exe); Ok(()) diff --git a/guest-libs/sha2/Cargo.toml b/guest-libs/sha2/Cargo.toml index 573930affb..0ae715d364 100644 --- a/guest-libs/sha2/Cargo.toml +++ b/guest-libs/sha2/Cargo.toml @@ -10,22 +10,21 @@ repository.workspace = true license.workspace = true [dependencies] -openvm-sha256-guest = { workspace = true } +openvm = { workspace = true } +openvm-sha2-guest = { workspace = true } +sha2 = { workspace = true, default-features = false } [dev-dependencies] openvm-instructions = { workspace = true } openvm-stark-sdk = { workspace = true } openvm-circuit = { workspace = true, features = ["test-utils", "parallel"] } openvm-transpiler = { workspace = true } -openvm-sha256-transpiler = { workspace = true } -openvm-sha256-circuit = { workspace = true } +openvm-sha2-transpiler = { workspace = true } +openvm-sha2-circuit = { workspace = true } openvm-rv32im-transpiler = { workspace = true } openvm-toolchain-tests = { workspace = true } eyre = { workspace = true } -[target.'cfg(not(target_os = "zkvm"))'.dependencies] -sha2 = { workspace = true } - [features] # Internal feature for testing only. -cuda = ["openvm-sha256-circuit/cuda"] \ No newline at end of file +cuda = ["openvm-sha2-circuit/cuda"] \ No newline at end of file diff --git a/guest-libs/sha2/src/host_impl.rs b/guest-libs/sha2/src/host_impl.rs new file mode 100644 index 0000000000..da74208f91 --- /dev/null +++ b/guest-libs/sha2/src/host_impl.rs @@ -0,0 +1,3 @@ +// On a host execution environment, the zkvm impl's input buffering is not necessary, and we can +// use the sha2 crate directly. +pub use sha2::{Sha256, Sha384, Sha512}; diff --git a/guest-libs/sha2/src/lib.rs b/guest-libs/sha2/src/lib.rs index 43d90ba822..2aaeabbfe0 100644 --- a/guest-libs/sha2/src/lib.rs +++ b/guest-libs/sha2/src/lib.rs @@ -1,28 +1,13 @@ #![no_std] -/// The sha256 cryptographic hash function. -#[inline(always)] -pub fn sha256(input: &[u8]) -> [u8; 32] { - let mut output = [0u8; 32]; - set_sha256(input, &mut output); - output -} +pub use sha2::Digest; -/// Sets `output` to the sha256 hash of `input`. -pub fn set_sha256(input: &[u8], output: &mut [u8; 32]) { - #[cfg(not(target_os = "zkvm"))] - { - use sha2::{Digest, Sha256}; - let mut hasher = Sha256::new(); - hasher.update(input); - output.copy_from_slice(hasher.finalize().as_ref()); - } - #[cfg(target_os = "zkvm")] - { - openvm_sha256_guest::zkvm_sha256_impl( - input.as_ptr(), - input.len(), - output.as_mut_ptr() as *mut u8, - ); - } -} +#[cfg(not(target_os = "zkvm"))] +mod host_impl; +#[cfg(target_os = "zkvm")] +mod zkvm_impl; + +#[cfg(not(target_os = "zkvm"))] +pub use host_impl::*; +#[cfg(target_os = "zkvm")] +pub use zkvm_impl::*; diff --git a/guest-libs/sha2/src/zkvm_impl.rs b/guest-libs/sha2/src/zkvm_impl.rs new file mode 100644 index 0000000000..1f32ba0a70 --- /dev/null +++ b/guest-libs/sha2/src/zkvm_impl.rs @@ -0,0 +1,292 @@ +use core::cmp::min; + +use sha2::digest::{ + consts::{U32, U64}, + FixedOutput, HashMarker, Output, OutputSizeUser, Update, +}; + +// We store static padding bytes here so that we don't need to allocate a vector when padding in +// finalize(). +// Padding always consists of a single 0x80 byte, followed by zeros, (and then the length of the +// message in bits but we don't include that here because it's not static). +// Length of this array is chosen to be the maximum block size between SHA-256 and SHA-512, since +// padding can be at most BLOCK_BYTES bytes. +const PADDING_BYTES: [u8; SHA512_BLOCK_BYTES] = { + let mut padding_bytes = [0u8; SHA512_BLOCK_BYTES]; + padding_bytes[0] = 0x80; + padding_bytes +}; + +const SHA256_STATE_WORDS: usize = 8; +const SHA256_BLOCK_BYTES: usize = 64; +const SHA256_DIGEST_BYTES: usize = 32; + +// Initial state for SHA-256 in 32-bit words +const SHA256_H: [u32; 8] = [ + 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19, +]; + +#[derive(Debug, Clone, Copy)] +pub struct Sha256 { + // the current hasher state, in 32-bit words + state: [u32; SHA256_STATE_WORDS], + // the next block of input + buffer: [u8; SHA256_BLOCK_BYTES], + // idx of next byte to write to buffer (equal to len mod SHA256_BLOCK_BYTES) + idx: usize, + // accumulated length of the input data, in bytes + len: usize, +} + +impl Default for Sha256 { + fn default() -> Self { + Self::new() + } +} + +impl Sha256 { + pub fn new() -> Self { + Self { + state: SHA256_H, + buffer: [0; SHA256_BLOCK_BYTES], + idx: 0, + len: 0, + } + } + + fn update(&mut self, mut input: &[u8]) { + self.len += input.len(); + while !input.is_empty() { + let to_copy = min(input.len(), SHA256_BLOCK_BYTES - self.idx); + self.buffer[self.idx..self.idx + to_copy].copy_from_slice(&input[..to_copy]); + self.idx += to_copy; + if self.idx == SHA256_BLOCK_BYTES { + self.idx = 0; + self.compress(); + } + input = &input[to_copy..]; + } + } + + fn finalize(mut self) -> [u8; SHA256_DIGEST_BYTES] { + // pad until length in bytes is 56 mod 64 (leave 8 bytes for the message length) + let num_bytes_of_padding = SHA256_BLOCK_BYTES - 8 - self.idx; + // ensure num_bytes_of_padding is positive + let num_bytes_of_padding = (num_bytes_of_padding + SHA256_BLOCK_BYTES) % SHA256_BLOCK_BYTES; + let message_len_in_bits = self.len * 8; + self.update(&PADDING_BYTES[..num_bytes_of_padding]); + self.update(&(message_len_in_bits as u64).to_be_bytes()); + let mut output = [0u8; SHA256_DIGEST_BYTES]; + output + .chunks_exact_mut(4) + .zip(self.state.iter()) + .for_each(|(chunk, x)| { + chunk.copy_from_slice(&x.to_be_bytes()); + }); + output + } + + fn compress(&mut self) { + openvm_sha2_guest::zkvm_sha256_impl( + self.state.as_ptr() as *const u8, + self.buffer.as_ptr(), + self.state.as_mut_ptr() as *mut u8, + ); + } +} + +// We will implement FixedOutput, Default, Update, and HashMarker for Sha256 so that +// the blanket implementation of sha2::Digest is available. +// See: https://docs.rs/sha2/latest/sha2/trait.Digest.html#impl-Digest-for-D +impl Update for Sha256 { + fn update(&mut self, input: &[u8]) { + self.update(input); + } +} + +// OutputSizeUser is required for FixedOutput +// See: https://docs.rs/digest/0.10.7/digest/trait.FixedOutput.html +impl OutputSizeUser for Sha256 { + type OutputSize = U32; +} + +impl FixedOutput for Sha256 { + fn finalize_into(self, out: &mut Output) { + out.copy_from_slice(&self.finalize()); + } +} + +impl HashMarker for Sha256 {} + +const SHA512_STATE_WORDS: usize = 8; +const SHA512_BLOCK_BYTES: usize = 128; +const SHA512_DIGEST_BYTES: usize = 64; + +// Initial state for SHA-512 in 64-bit words +pub const SHA512_H: [u64; 8] = [ + 0x6a09e667f3bcc908, + 0xbb67ae8584caa73b, + 0x3c6ef372fe94f82b, + 0xa54ff53a5f1d36f1, + 0x510e527fade682d1, + 0x9b05688c2b3e6c1f, + 0x1f83d9abfb41bd6b, + 0x5be0cd19137e2179, +]; + +#[derive(Debug, Clone, Copy)] +pub struct Sha512 { + // the current hasher state + state: [u64; SHA512_STATE_WORDS], + // the next block of input + buffer: [u8; SHA512_BLOCK_BYTES], + // idx of next byte to write to buffer + idx: usize, + // accumulated length of the input data, in bytes + len: usize, +} + +impl Default for Sha512 { + fn default() -> Self { + Self::new() + } +} + +impl Sha512 { + pub fn new() -> Self { + Self { + state: SHA512_H, + buffer: [0; SHA512_BLOCK_BYTES], + idx: 0, + len: 0, + } + } + + fn update(&mut self, mut input: &[u8]) { + self.len += input.len(); + while !input.is_empty() { + let to_copy = min(input.len(), SHA512_BLOCK_BYTES - self.idx); + self.buffer[self.idx..self.idx + to_copy].copy_from_slice(&input[..to_copy]); + self.idx += to_copy; + if self.idx == SHA512_BLOCK_BYTES { + self.idx = 0; + self.compress(); + } + input = &input[to_copy..]; + } + } + + fn finalize(mut self) -> [u8; SHA512_DIGEST_BYTES] { + // pad until length in bytes is 112 mod 128 (leave 16 bytes for the message length) + let num_bytes_of_padding = SHA512_BLOCK_BYTES - 16 - self.idx; + // ensure num_bytes_of_padding is positive + let num_bytes_of_padding = (num_bytes_of_padding + SHA512_BLOCK_BYTES) % SHA512_BLOCK_BYTES; + let message_len_in_bits = self.len * 8; + self.update(&PADDING_BYTES[..num_bytes_of_padding]); + self.update(&(message_len_in_bits as u128).to_be_bytes()); + let mut output = [0u8; SHA512_DIGEST_BYTES]; + output + .chunks_exact_mut(8) + .zip(self.state.iter()) + .for_each(|(chunk, x)| { + chunk.copy_from_slice(&x.to_be_bytes()); + }); + output + } + + fn compress(&mut self) { + openvm_sha2_guest::zkvm_sha512_impl( + self.state.as_ptr() as *const u8, + self.buffer.as_ptr(), + self.state.as_mut_ptr() as *mut u8, + ); + } +} + +// We will implement FixedOutput, Default, Update, and HashMarker for Sha512 so that +// the blanket implementation of sha2::Digest is available. +// See: https://docs.rs/sha2/latest/sha2/trait.Digest.html#impl-Digest-for-D +impl Update for Sha512 { + fn update(&mut self, input: &[u8]) { + self.update(input); + } +} + +// OutputSizeUser is required for FixedOutput +// See: https://docs.rs/digest/0.10.7/digest/trait.FixedOutput.html +impl OutputSizeUser for Sha512 { + type OutputSize = U64; +} + +impl FixedOutput for Sha512 { + fn finalize_into(self, out: &mut Output) { + out.copy_from_slice(&self.finalize()); + } +} + +impl HashMarker for Sha512 {} + +const SHA384_DIGEST_BYTES: usize = 48; + +// Initial state for SHA-384 in 64-bit words +pub const SHA384_H: [u64; 8] = [ + 0xcbbb9d5dc1059ed8, + 0x629a292a367cd507, + 0x9159015a3070dd17, + 0x152fecd8f70e5939, + 0x67332667ffc00b31, + 0x8eb44a8768581511, + 0xdb0c2e0d64f98fa7, + 0x47b5481dbefa4fa4, +]; + +#[derive(Debug, Clone, Copy)] +pub struct Sha384 { + inner: Sha512, +} + +impl Default for Sha384 { + fn default() -> Self { + Self::new() + } +} + +impl Sha384 { + pub fn new() -> Self { + let mut inner = Sha512::new(); + inner.state = SHA384_H; + Self { inner } + } + + pub fn update(&mut self, input: &[u8]) { + self.inner.update(input); + } + + pub fn finalize(self) -> [u8; SHA384_DIGEST_BYTES] { + let digest = self.inner.finalize(); + digest[..SHA384_DIGEST_BYTES].try_into().unwrap() + } +} + +// We will implement FixedOutput, Default, Update, and HashMarker for Sha384 so that +// the blanket implementation of sha2::Digest is available. +// See: https://docs.rs/sha2/latest/sha2/trait.Digest.html#impl-Digest-for-D +impl Update for Sha384 { + fn update(&mut self, input: &[u8]) { + self.update(input); + } +} + +// OutputSizeUser is required for FixedOutput +// See: https://docs.rs/digest/0.10.7/digest/trait.FixedOutput.html +impl OutputSizeUser for Sha384 { + type OutputSize = U64; +} + +impl FixedOutput for Sha384 { + fn finalize_into(self, out: &mut Output) { + out.copy_from_slice(&self.finalize()); + } +} + +impl HashMarker for Sha384 {} diff --git a/guest-libs/sha2/tests/lib.rs b/guest-libs/sha2/tests/lib.rs index adfae8e764..26319f7e4d 100644 --- a/guest-libs/sha2/tests/lib.rs +++ b/guest-libs/sha2/tests/lib.rs @@ -6,8 +6,8 @@ mod tests { use openvm_rv32im_transpiler::{ Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension, }; - use openvm_sha256_circuit::{Sha256Rv32Builder, Sha256Rv32Config}; - use openvm_sha256_transpiler::Sha256TranspilerExtension; + use openvm_sha2_circuit::{Sha2Rv32Builder, Sha2Rv32Config}; + use openvm_sha2_transpiler::Sha2TranspilerExtension; use openvm_stark_sdk::p3_baby_bear::BabyBear; use openvm_toolchain_tests::{build_example_program_at_path, get_programs_dir}; use openvm_transpiler::{transpiler::Transpiler, FromElf}; @@ -15,19 +15,19 @@ mod tests { type F = BabyBear; #[test] - fn test_sha256() -> Result<()> { - let config = Sha256Rv32Config::default(); + fn test_sha2() -> Result<()> { + let config = Sha2Rv32Config::default(); let elf = - build_example_program_at_path(get_programs_dir!("tests/programs"), "sha", &config)?; + build_example_program_at_path(get_programs_dir!("tests/programs"), "sha2", &config)?; let openvm_exe = VmExe::from_elf( elf, Transpiler::::default() .with_extension(Rv32ITranspilerExtension) .with_extension(Rv32MTranspilerExtension) .with_extension(Rv32IoTranspilerExtension) - .with_extension(Sha256TranspilerExtension), + .with_extension(Sha2TranspilerExtension), )?; - air_test(Sha256Rv32Builder, config, openvm_exe); + air_test(Sha2Rv32Builder, config, openvm_exe); Ok(()) } } diff --git a/guest-libs/sha2/tests/programs/Cargo.toml b/guest-libs/sha2/tests/programs/Cargo.toml index df13f8dfc7..60618893c9 100644 --- a/guest-libs/sha2/tests/programs/Cargo.toml +++ b/guest-libs/sha2/tests/programs/Cargo.toml @@ -6,18 +6,12 @@ edition = "2021" [dependencies] openvm = { path = "../../../../crates/toolchain/openvm" } -openvm-platform = { path = "../../../../crates/toolchain/platform" } openvm-sha2 = { path = "../../" } - hex = { version = "0.4.3", default-features = false, features = ["alloc"] } -serde = { version = "1.0", default-features = false, features = [ - "alloc", - "derive", -] } [features] default = [] -std = ["serde/std", "openvm/std"] +std = ["openvm/std"] [profile.release] panic = "abort" diff --git a/guest-libs/sha2/tests/programs/examples/sha.rs b/guest-libs/sha2/tests/programs/examples/sha.rs deleted file mode 100644 index ebfd50cbee..0000000000 --- a/guest-libs/sha2/tests/programs/examples/sha.rs +++ /dev/null @@ -1,29 +0,0 @@ -#![cfg_attr(not(feature = "std"), no_main)] -#![cfg_attr(not(feature = "std"), no_std)] - -extern crate alloc; - -use alloc::vec::Vec; -use core::hint::black_box; - -use hex::FromHex; -use openvm_sha2::sha256; - -openvm::entry!(main); - -pub fn main() { - let test_vectors = [ - ("", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"), - ("98c1c0bdb7d5fea9a88859f06c6c439f", "b6b2c9c9b6f30e5c66c977f1bd7ad97071bee739524aecf793384890619f2b05"), - ("5b58f4163e248467cc1cd3eecafe749e8e2baaf82c0f63af06df0526347d7a11327463c115210a46b6740244eddf370be89c", "ac0e25049870b91d78ef6807bb87fce4603c81abd3c097fba2403fd18b6ce0b7"), - ("9ad198539e3160194f38ac076a782bd5210a007560d1fce9ef78f8a4a5e4d78c6b96c250cff3520009036e9c6087d5dab587394edda862862013de49a12072485a6c01165ec0f28ffddf1873fbd53e47fcd02fb6a5ccc9622d5588a92429c663ce298cb71b50022fc2ec4ba9f5bbd250974e1a607b165fee16e8f3f2be20d7348b91a2f518ce928491900d56d9f86970611580350cee08daea7717fe28a73b8dcfdea22a65ed9f5a09198de38e4e4f2cc05b0ba3dd787a5363ab6c9f39dcb66c1a29209b1d6b1152769395df8150b4316658ea6ab19af94903d643fcb0ae4d598035ebe73c8b1b687df1ab16504f633c929569c6d0e5fae6eea43838fbc8ce2c2b43161d0addc8ccf945a9c4e06294e56a67df0000f561f61b630b1983ba403e775aaeefa8d339f669d1e09ead7eae979383eda983321e1743e5404b4b328da656de79ff52d179833a6bd5129f49432d74d001996c37c68d9ab49fcff8061d193576f396c20e1f0d9ee83a51290ba60efa9c3cb2e15b756321a7ca668cdbf63f95ec33b1c450aa100101be059dc00077245b25a6a66698dee81953ed4a606944076e2858b1420de0095a7f60b08194d6d9a997009d345c71f63a7034b976e409af8a9a040ac7113664609a7adedb76b2fadf04b0348392a1650526eb2a4d6ed5e4bbcda8aabc8488b38f4f5d9a398103536bb8250ed82a9b9825f7703c263f9e", "080ad71239852124fc26758982090611b9b19abf22d22db3a57f67a06e984a23") - ]; - for (input, expected_output) in test_vectors.iter() { - let input = Vec::from_hex(input).unwrap(); - let expected_output = Vec::from_hex(expected_output).unwrap(); - let output = sha256(&black_box(input)); - if output != *expected_output { - panic!(); - } - } -} diff --git a/guest-libs/sha2/tests/programs/examples/sha2.rs b/guest-libs/sha2/tests/programs/examples/sha2.rs new file mode 100644 index 0000000000..49c0dafeb4 --- /dev/null +++ b/guest-libs/sha2/tests/programs/examples/sha2.rs @@ -0,0 +1,95 @@ +#![cfg_attr(not(feature = "std"), no_main)] +#![cfg_attr(not(feature = "std"), no_std)] + +extern crate alloc; + +use alloc::vec::Vec; +use core::hint::black_box; + +use hex::FromHex; +use openvm_sha2::{Digest, Sha256, Sha384, Sha512}; + +openvm::entry!(main); + +struct ShaTestVector { + input: &'static str, + expected_output_sha256: &'static str, + expected_output_sha512: &'static str, + expected_output_sha384: &'static str, +} + +pub fn main() { + let test_vectors = [ + ShaTestVector { + input: "", + expected_output_sha256: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + expected_output_sha512: "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e", + expected_output_sha384: "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b", + }, + ShaTestVector { + input: "98c1c0bdb7d5fea9a88859f06c6c439f", + expected_output_sha256: "b6b2c9c9b6f30e5c66c977f1bd7ad97071bee739524aecf793384890619f2b05", + expected_output_sha512: "eb576959c531f116842c0cc915a29c8f71d7a285c894c349b83469002ef093d51f9f14ce4248488bff143025e47ed27c12badb9cd43779cb147408eea062d583", + expected_output_sha384: "63e3061aab01f335ea3a4e617b9d14af9b63a5240229164ee962f6d5335ff25f0f0bf8e46723e83c41b9d17413b6a3c7", + }, + ShaTestVector { + input: "5b58f4163e248467cc1cd3eecafe749e8e2baaf82c0f63af06df0526347d7a11327463c115210a46b6740244eddf370be89c", + expected_output_sha256: "ac0e25049870b91d78ef6807bb87fce4603c81abd3c097fba2403fd18b6ce0b7", + expected_output_sha512: "a20d5fb14814d045a7d2861e80d2b688f1cd1daaba69e6bb1cc5233f514141ea4623b3373af702e78e3ec5dc8c1b716a37a9a2f5fbc9493b9df7043f5e99a8da", + expected_output_sha384: "eac4b72b0540486bc088834860873338e31e9e4062532bf509191ef63b9298c67db5654a28fe6f07e4cc6ff466d1be24", + }, + ShaTestVector { + input: "9ad198539e3160194f38ac076a782bd5210a007560d1fce9ef78f8a4a5e4d78c6b96c250cff3520009036e9c6087d5dab587394edda862862013de49a12072485a6c01165ec0f28ffddf1873fbd53e47fcd02fb6a5ccc9622d5588a92429c663ce298cb71b50022fc2ec4ba9f5bbd250974e1a607b165fee16e8f3f2be20d7348b91a2f518ce928491900d56d9f86970611580350cee08daea7717fe28a73b8dcfdea22a65ed9f5a09198de38e4e4f2cc05b0ba3dd787a5363ab6c9f39dcb66c1a29209b1d6b1152769395df8150b4316658ea6ab19af94903d643fcb0ae4d598035ebe73c8b1b687df1ab16504f633c929569c6d0e5fae6eea43838fbc8ce2c2b43161d0addc8ccf945a9c4e06294e56a67df0000f561f61b630b1983ba403e775aaeefa8d339f669d1e09ead7eae979383eda983321e1743e5404b4b328da656de79ff52d179833a6bd5129f49432d74d001996c37c68d9ab49fcff8061d193576f396c20e1f0d9ee83a51290ba60efa9c3cb2e15b756321a7ca668cdbf63f95ec33b1c450aa100101be059dc00077245b25a6a66698dee81953ed4a606944076e2858b1420de0095a7f60b08194d6d9a997009d345c71f63a7034b976e409af8a9a040ac7113664609a7adedb76b2fadf04b0348392a1650526eb2a4d6ed5e4bbcda8aabc8488b38f4f5d9a398103536bb8250ed82a9b9825f7703c263f9e", + expected_output_sha256: "080ad71239852124fc26758982090611b9b19abf22d22db3a57f67a06e984a23", + expected_output_sha512: "8d215ee6dc26757c210db0dd00c1c6ed16cc34dbd4bb0fa10c1edb6b62d5ab16aea88c881001b173d270676daf2d6381b5eab8711fa2f5589c477c1d4b84774f", + expected_output_sha384: "904a90010d772a904a35572fdd4bdf1dd253742e47872c8a18e2255f66fa889e44781e65487a043f435daa53c496a53e", + } + ]; + + for ( + i, + ShaTestVector { + input, + expected_output_sha256, + expected_output_sha512, + expected_output_sha384, + }, + ) in test_vectors.iter().enumerate() + { + let input = Vec::from_hex(input).unwrap(); + let expected_output_sha256 = Vec::from_hex(expected_output_sha256).unwrap(); + let mut hasher = Sha256::new(); + hasher.update(black_box(&input)); + let output = hasher.finalize(); + if output.as_slice() != expected_output_sha256.as_slice() { + panic!( + "sha256 test {i} failed on input: {:?}.\nexpected: {:?},\ngot: {:?}", + input, + expected_output_sha256, + output.as_slice() + ); + } + let expected_output_sha512 = Vec::from_hex(expected_output_sha512).unwrap(); + let mut hasher = Sha512::new(); + hasher.update(black_box(&input)); + let output = hasher.finalize(); + if output.as_slice() != expected_output_sha512.as_slice() { + panic!( + "sha512 test {i} failed on input: {:?}.\nexpected: {:?},\ngot: {:?}", + input, + expected_output_sha512, + output.as_slice() + ); + } + let expected_output_sha384 = Vec::from_hex(expected_output_sha384).unwrap(); + let mut hasher = Sha384::new(); + hasher.update(black_box(&input)); + let output = hasher.finalize(); + if output.as_slice() != expected_output_sha384.as_slice() { + panic!( + "sha384 test {i} failed on input: {:?}.\nexpected: {:?},\ngot: {:?}", + input, expected_output_sha384, output + ); + } + } +} diff --git a/rust-toolchain.toml b/rust-toolchain.toml index 25c9b640da..a6a8cdcacb 100644 --- a/rust-toolchain.toml +++ b/rust-toolchain.toml @@ -2,4 +2,4 @@ channel = "1.90.0" # To use the "tco" feature, switch to Rust nightly: # channel = "nightly-2025-08-19" -components = ["clippy", "rustfmt"] +components = ["clippy", "rustfmt", "rust-analyzer"] From 357b842115001bc84825db1126acf0d9afafa1da Mon Sep 17 00:00:00 2001 From: Euicheon Hong <78904698+gdmlcjs@users.noreply.github.com> Date: Thu, 29 Jan 2026 01:38:27 +0900 Subject: [PATCH 12/78] fix: sha2 guest library implementation (#2374) - change padding size to positive instead of non-negative - change output size of sha384 to 48 bytes instead of 64 --- guest-libs/sha2/src/zkvm_impl.rs | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/guest-libs/sha2/src/zkvm_impl.rs b/guest-libs/sha2/src/zkvm_impl.rs index 1f32ba0a70..77c66b9f03 100644 --- a/guest-libs/sha2/src/zkvm_impl.rs +++ b/guest-libs/sha2/src/zkvm_impl.rs @@ -1,7 +1,7 @@ use core::cmp::min; use sha2::digest::{ - consts::{U32, U64}, + consts::{U32, U48, U64}, FixedOutput, HashMarker, Output, OutputSizeUser, Update, }; @@ -69,10 +69,9 @@ impl Sha256 { } fn finalize(mut self) -> [u8; SHA256_DIGEST_BYTES] { - // pad until length in bytes is 56 mod 64 (leave 8 bytes for the message length) - let num_bytes_of_padding = SHA256_BLOCK_BYTES - 8 - self.idx; - // ensure num_bytes_of_padding is positive - let num_bytes_of_padding = (num_bytes_of_padding + SHA256_BLOCK_BYTES) % SHA256_BLOCK_BYTES; + // pad positive amount so that length is multiple of SHA256_BLOCK_BYTES + // (extra 8 bytes are for message length) + let num_bytes_of_padding = SHA256_BLOCK_BYTES - (self.idx + 8) % SHA256_BLOCK_BYTES; let message_len_in_bits = self.len * 8; self.update(&PADDING_BYTES[..num_bytes_of_padding]); self.update(&(message_len_in_bits as u64).to_be_bytes()); @@ -177,10 +176,9 @@ impl Sha512 { } fn finalize(mut self) -> [u8; SHA512_DIGEST_BYTES] { - // pad until length in bytes is 112 mod 128 (leave 16 bytes for the message length) - let num_bytes_of_padding = SHA512_BLOCK_BYTES - 16 - self.idx; - // ensure num_bytes_of_padding is positive - let num_bytes_of_padding = (num_bytes_of_padding + SHA512_BLOCK_BYTES) % SHA512_BLOCK_BYTES; + // pad positive amount so that length is multiple of SHA512_BLOCK_BYTES + // (extra 16 bytes are for message length) + let num_bytes_of_padding = SHA512_BLOCK_BYTES - (self.idx + 16) % SHA512_BLOCK_BYTES; let message_len_in_bits = self.len * 8; self.update(&PADDING_BYTES[..num_bytes_of_padding]); self.update(&(message_len_in_bits as u128).to_be_bytes()); @@ -280,7 +278,7 @@ impl Update for Sha384 { // OutputSizeUser is required for FixedOutput // See: https://docs.rs/digest/0.10.7/digest/trait.FixedOutput.html impl OutputSizeUser for Sha384 { - type OutputSize = U64; + type OutputSize = U48; } impl FixedOutput for Sha384 { From 7159f4e9f7b92eff5c1b432d30a035dd488f52ff Mon Sep 17 00:00:00 2001 From: Jonathan Wang <31040440+jonathanpwang@users.noreply.github.com> Date: Sat, 28 Feb 2026 02:19:53 +0000 Subject: [PATCH 13/78] test: add test suite for sha2 guest (#2368) Adds execution tests and proving (only for GPU) tests for the Sha2 guest library. Test vectors are from https://csrc.nist.gov/projects/cryptographic-algorithm-validation-program/secure-hashing closes INT-5932 --- .github/workflows/guest-lib-tests.cuda.yml | 37 +- .github/workflows/guest-lib-tests.yml | 21 +- guest-libs/sha2/Cargo.toml | 10 +- guest-libs/sha2/tests/lib.rs | 148 ++++- .../sha2/tests/programs/examples/sha2.rs | 94 +--- .../sha2/tests/test_vectors/SHA256LongMsg.rsp | 263 +++++++++ .../tests/test_vectors/SHA256ShortMsg.rsp | 267 +++++++++ .../sha2/tests/test_vectors/SHA384LongMsg.rsp | 519 +++++++++++++++++ .../tests/test_vectors/SHA384ShortMsg.rsp | 523 ++++++++++++++++++ .../sha2/tests/test_vectors/SHA512LongMsg.rsp | 519 +++++++++++++++++ .../tests/test_vectors/SHA512ShortMsg.rsp | 523 ++++++++++++++++++ 11 files changed, 2829 insertions(+), 95 deletions(-) create mode 100644 guest-libs/sha2/tests/test_vectors/SHA256LongMsg.rsp create mode 100644 guest-libs/sha2/tests/test_vectors/SHA256ShortMsg.rsp create mode 100644 guest-libs/sha2/tests/test_vectors/SHA384LongMsg.rsp create mode 100644 guest-libs/sha2/tests/test_vectors/SHA384ShortMsg.rsp create mode 100644 guest-libs/sha2/tests/test_vectors/SHA512LongMsg.rsp create mode 100644 guest-libs/sha2/tests/test_vectors/SHA512ShortMsg.rsp diff --git a/.github/workflows/guest-lib-tests.cuda.yml b/.github/workflows/guest-lib-tests.cuda.yml index f3e5cfdf8c..addfc2962b 100644 --- a/.github/workflows/guest-lib-tests.cuda.yml +++ b/.github/workflows/guest-lib-tests.cuda.yml @@ -29,7 +29,10 @@ jobs: strategy: matrix: crates: # group crates on the same runner based on test time - - { names: "sha2 keccak256 verify-stark" } + - { names: "sha2_256", path: "sha2", filter: "sha256" } + - { names: "sha2_384", path: "sha2", filter: "sha384" } + - { names: "sha2_512", path: "sha2", filter: "sha512" } + - { names: "keccak256 verify-stark" } - { names: "ruint k256 p256" } - { names: "ff_derive pairing" } runs-on: @@ -50,7 +53,13 @@ jobs: - "extensions/rv32-adapters/**" - ".github/workflows/guest-lib-tests.cuda.yml" - "crates/sdk/guest/fib/**" - sha2: + sha2_256: + - "extensions/sha2/**" + - "guest-libs/sha2/**" + sha2_384: + - "extensions/sha2/**" + - "guest-libs/sha2/**" + sha2_512: - "extensions/sha2/**" - "guest-libs/sha2/**" keccak256: @@ -129,9 +138,15 @@ jobs: if [[ "$COMMON_CHANGED" == "true" || "$crate_changed" == "true" ]]; then echo "::group::Running tests for $crate" + # Determine the actual directory path + CRATE_PATH="${{ matrix.crates.path }}" + if [[ -z "$CRATE_PATH" ]]; then + CRATE_PATH="$crate" + fi + # Run guest library tests - if [ -d "guest-libs/$crate" ]; then - TEST_DIR="guest-libs/$crate" + if [ -d "guest-libs/$CRATE_PATH" ]; then + TEST_DIR="guest-libs/$CRATE_PATH" if [[ "$crate" == "verify-stark" ]]; then TEST_DIR="guest-libs/$crate/circuit" fi @@ -144,9 +159,21 @@ jobs: elif [[ "$crate" == "ruint" ]]; then # only run integration tests because other tests are not OpenVM related SPECIAL_ARGS="test_matrix_power" + elif [[ "$crate" == sha2_* ]]; then + # only run proving tests + SPECIAL_ARGS="--run-ignored=ignored-only" + if [[ ${{ github.event_name }} == "push" && ${{ github.ref }} == "refs/heads/main" ]]; then + SPECIAL_ARGS="$SPECIAL_ARGS --features=long_proving_tests" + fi fi - ${{ env.NEXTEST_ENV }} cargo nextest run --cargo-profile=fast ${{ env.FEATURE_ARGS }} $SPECIAL_ARGS --no-tests=pass --test-threads=1 + # Build the command + CMD="${{ env.NEXTEST_ENV }} cargo nextest run --cargo-profile=fast ${{ env.FEATURE_ARGS }} $SPECIAL_ARGS --no-tests=pass --test-threads=1" + # Apply test filter if specified + if [[ -n "${{ matrix.crates.filter }}" ]]; then + CMD="$CMD -E 'test(/${{ matrix.crates.filter }}/)'" + fi + eval $CMD popd fi echo "::endgroup::" diff --git a/.github/workflows/guest-lib-tests.yml b/.github/workflows/guest-lib-tests.yml index dde8cb0559..736a23b3e3 100644 --- a/.github/workflows/guest-lib-tests.yml +++ b/.github/workflows/guest-lib-tests.yml @@ -29,7 +29,9 @@ jobs: strategy: matrix: crate: - - { name: "sha2", path: "sha2" } + - { name: "sha2_256", path: "sha2", filter: "sha256" } + - { name: "sha2_384", path: "sha2", filter: "sha384" } + - { name: "sha2_512", path: "sha2", filter: "sha512" } - { name: "keccak256", path: "keccak256" } - { name: "ff_derive", path: "ff_derive" } - { name: "k256", path: "k256" } @@ -74,8 +76,17 @@ jobs: working-directory: guest-libs/${{ matrix.crate.path }} run: | rustup component add rust-src --toolchain nightly-2025-08-02 - PAIRING_FEATURE_ARGS="" - if [[ "${{ matrix.crate.name }}" == "pairing" ]]; then - PAIRING_FEATURE_ARGS="--features=bn254,bls12_381,aot" + FEATURE_ARGS="" + if [[ "${{ matrix.crate.name }}" == sha2_* ]]; then + FEATURE_ARGS="--features=aot" + elif [[ "${{ matrix.crate.name }}" == "pairing" ]]; then + FEATURE_ARGS="--features=bn254,bls12_381,aot" fi - cargo nextest run --cargo-profile=fast $PAIRING_FEATURE_ARGS --no-tests=pass --test-threads=1 + + # Build the command + CMD="cargo nextest run --cargo-profile=fast $FEATURE_ARGS --no-tests=pass --test-threads=1" + # Apply test filter if specified + if [[ -n "${{ matrix.crate.filter }}" ]]; then + CMD="$CMD -E 'test(/${{ matrix.crate.filter }}/)'" + fi + eval $CMD diff --git a/guest-libs/sha2/Cargo.toml b/guest-libs/sha2/Cargo.toml index 0ae715d364..ffd68f551d 100644 --- a/guest-libs/sha2/Cargo.toml +++ b/guest-libs/sha2/Cargo.toml @@ -15,8 +15,10 @@ openvm-sha2-guest = { workspace = true } sha2 = { workspace = true, default-features = false } [dev-dependencies] +hex = { workspace = true } openvm-instructions = { workspace = true } -openvm-stark-sdk = { workspace = true } +openvm-sdk = { workspace = true } +openvm-stark-sdk = { workspace = true } openvm-circuit = { workspace = true, features = ["test-utils", "parallel"] } openvm-transpiler = { workspace = true } openvm-sha2-transpiler = { workspace = true } @@ -26,5 +28,9 @@ openvm-toolchain-tests = { workspace = true } eyre = { workspace = true } [features] +default = [] +aot = ["openvm-sdk/aot"] # Internal feature for testing only. -cuda = ["openvm-sha2-circuit/cuda"] \ No newline at end of file +cuda = ["openvm-sha2-circuit/cuda"] +# Enables rust integration tests that take a long time. +long_proving_tests = [] diff --git a/guest-libs/sha2/tests/lib.rs b/guest-libs/sha2/tests/lib.rs index 26319f7e4d..3536e1bd28 100644 --- a/guest-libs/sha2/tests/lib.rs +++ b/guest-libs/sha2/tests/lib.rs @@ -1,11 +1,15 @@ #[cfg(test)] mod tests { + use std::fs; + use eyre::Result; - use openvm_circuit::utils::air_test; + use hex::FromHex; + use openvm_circuit::{arch::VmExecutor, utils::air_test_with_min_segments}; use openvm_instructions::exe::VmExe; use openvm_rv32im_transpiler::{ Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension, }; + use openvm_sdk::StdIn; use openvm_sha2_circuit::{Sha2Rv32Builder, Sha2Rv32Config}; use openvm_sha2_transpiler::Sha2TranspilerExtension; use openvm_stark_sdk::p3_baby_bear::BabyBear; @@ -14,8 +18,55 @@ mod tests { type F = BabyBear; - #[test] - fn test_sha2() -> Result<()> { + enum Sha2Type { + Sha256, + Sha384, + Sha512, + } + + struct TestVector { + input: Vec, + expected_output: Vec, + } + + // test vectors are from https://csrc.nist.gov/projects/cryptographic-algorithm-validation-program/secure-hashing + fn parse_test_vectors(file_name: &str) -> Vec { + let mut test_vectors = Vec::new(); + + let get_attribute_from_line = |line: &str, attribute: &str| -> Option { + line.trim() + .strip_prefix(&(attribute.to_string() + " = ")) + .map(|s| s.to_string()) + }; + + let file_content = + fs::read_to_string("tests/test_vectors/".to_string() + file_name).unwrap(); + let mut lines = file_content.lines(); + while let Some(line) = lines.next() { + let Some(len_str) = get_attribute_from_line(line, "Len") else { + continue; + }; + let msg_str = get_attribute_from_line(lines.next().unwrap(), "Msg").unwrap(); + let md_str = get_attribute_from_line(lines.next().unwrap(), "MD").unwrap(); + + let len: usize = len_str.parse().unwrap(); + let msg = if len == 0 { + Vec::new() + } else { + Vec::from_hex(&msg_str).unwrap() + }; + let md = Vec::from_hex(&md_str).unwrap(); + + test_vectors.push(TestVector { + input: msg, + expected_output: md, + }); + } + + test_vectors + } + + fn test_sha2_base(test_vector_file_name: &str, sha2_type: Sha2Type, prove: bool) -> Result<()> { let config = Sha2Rv32Config::default(); let elf = build_example_program_at_path(get_programs_dir!("tests/programs"), "sha2", &config)?; @@ -27,7 +78,96 @@ mod tests { .with_extension(Rv32IoTranspilerExtension) .with_extension(Sha2TranspilerExtension), )?; - air_test(Sha2Rv32Builder, config, openvm_exe); + + for test_vector in parse_test_vectors(test_vector_file_name) { + let mut stdin = StdIn::default(); + stdin.write(&match sha2_type { + Sha2Type::Sha256 => 256u32, + Sha2Type::Sha384 => 384u32, + Sha2Type::Sha512 => 512u32, + }); + stdin.write(&test_vector.input); + stdin.write(&test_vector.expected_output); + + if prove { + air_test_with_min_segments( + Sha2Rv32Builder, + config.clone(), + openvm_exe.clone(), + stdin, + 1, + ); + } else { + let executor = VmExecutor::new(config.clone())?; + let interpreter = executor.instance(&openvm_exe)?; + #[allow(unused_variables)] + let state = interpreter.execute(stdin.clone(), None)?; + + #[cfg(feature = "aot")] + { + use openvm_circuit::{arch::VmState, system::memory::online::GuestMemory}; + let naive_interpreter = executor.interpreter_instance(&openvm_exe)?; + let naive_state = naive_interpreter.execute(stdin, None)?; + let assert_vm_state_eq = + |lhs: &VmState, + rhs: &VmState| { + assert_eq!(lhs.pc(), rhs.pc()); + for r in 0..32 { + let a = unsafe { lhs.memory.read::(1, r as u32) }; + let b = unsafe { rhs.memory.read::(1, r as u32) }; + assert_eq!(a, b); + } + }; + assert_vm_state_eq(&state, &naive_state); + } + } + } + + Ok(()) + } + + #[test] + fn test_sha256_run() -> Result<()> { + test_sha2_base("SHA256ShortMsg.rsp", Sha2Type::Sha256, false)?; + test_sha2_base("SHA256LongMsg.rsp", Sha2Type::Sha256, false) + } + + #[test] + fn test_sha384_run() -> Result<()> { + test_sha2_base("SHA384ShortMsg.rsp", Sha2Type::Sha384, false)?; + test_sha2_base("SHA384LongMsg.rsp", Sha2Type::Sha384, false) + } + + #[test] + fn test_sha512_run() -> Result<()> { + test_sha2_base("SHA512ShortMsg.rsp", Sha2Type::Sha512, false)?; + test_sha2_base("SHA512LongMsg.rsp", Sha2Type::Sha512, false) + } + + #[test] + #[ignore = "proving on CPU is slow"] + fn test_sha256_prove() -> Result<()> { + test_sha2_base("SHA256ShortMsg.rsp", Sha2Type::Sha256, true)?; + #[cfg(feature = "long_proving_tests")] + test_sha2_base("SHA256LongMsg.rsp", Sha2Type::Sha256, true)?; + Ok(()) + } + + #[test] + #[ignore = "proving on CPU is slow"] + fn test_sha384_prove() -> Result<()> { + test_sha2_base("SHA384ShortMsg.rsp", Sha2Type::Sha384, true)?; + #[cfg(feature = "long_proving_tests")] + test_sha2_base("SHA384LongMsg.rsp", Sha2Type::Sha384, true)?; + Ok(()) + } + + #[test] + #[ignore = "proving on CPU is slow"] + fn test_sha512_prove() -> Result<()> { + test_sha2_base("SHA512ShortMsg.rsp", Sha2Type::Sha512, true)?; + #[cfg(feature = "long_proving_tests")] + test_sha2_base("SHA512LongMsg.rsp", Sha2Type::Sha512, true)?; Ok(()) } } diff --git a/guest-libs/sha2/tests/programs/examples/sha2.rs b/guest-libs/sha2/tests/programs/examples/sha2.rs index 49c0dafeb4..de22f4d9d8 100644 --- a/guest-libs/sha2/tests/programs/examples/sha2.rs +++ b/guest-libs/sha2/tests/programs/examples/sha2.rs @@ -6,90 +6,26 @@ extern crate alloc; use alloc::vec::Vec; use core::hint::black_box; -use hex::FromHex; +use openvm::io::read; use openvm_sha2::{Digest, Sha256, Sha384, Sha512}; openvm::entry!(main); -struct ShaTestVector { - input: &'static str, - expected_output_sha256: &'static str, - expected_output_sha512: &'static str, - expected_output_sha384: &'static str, -} - pub fn main() { - let test_vectors = [ - ShaTestVector { - input: "", - expected_output_sha256: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", - expected_output_sha512: "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e", - expected_output_sha384: "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b", - }, - ShaTestVector { - input: "98c1c0bdb7d5fea9a88859f06c6c439f", - expected_output_sha256: "b6b2c9c9b6f30e5c66c977f1bd7ad97071bee739524aecf793384890619f2b05", - expected_output_sha512: "eb576959c531f116842c0cc915a29c8f71d7a285c894c349b83469002ef093d51f9f14ce4248488bff143025e47ed27c12badb9cd43779cb147408eea062d583", - expected_output_sha384: "63e3061aab01f335ea3a4e617b9d14af9b63a5240229164ee962f6d5335ff25f0f0bf8e46723e83c41b9d17413b6a3c7", - }, - ShaTestVector { - input: "5b58f4163e248467cc1cd3eecafe749e8e2baaf82c0f63af06df0526347d7a11327463c115210a46b6740244eddf370be89c", - expected_output_sha256: "ac0e25049870b91d78ef6807bb87fce4603c81abd3c097fba2403fd18b6ce0b7", - expected_output_sha512: "a20d5fb14814d045a7d2861e80d2b688f1cd1daaba69e6bb1cc5233f514141ea4623b3373af702e78e3ec5dc8c1b716a37a9a2f5fbc9493b9df7043f5e99a8da", - expected_output_sha384: "eac4b72b0540486bc088834860873338e31e9e4062532bf509191ef63b9298c67db5654a28fe6f07e4cc6ff466d1be24", - }, - ShaTestVector { - input: "9ad198539e3160194f38ac076a782bd5210a007560d1fce9ef78f8a4a5e4d78c6b96c250cff3520009036e9c6087d5dab587394edda862862013de49a12072485a6c01165ec0f28ffddf1873fbd53e47fcd02fb6a5ccc9622d5588a92429c663ce298cb71b50022fc2ec4ba9f5bbd250974e1a607b165fee16e8f3f2be20d7348b91a2f518ce928491900d56d9f86970611580350cee08daea7717fe28a73b8dcfdea22a65ed9f5a09198de38e4e4f2cc05b0ba3dd787a5363ab6c9f39dcb66c1a29209b1d6b1152769395df8150b4316658ea6ab19af94903d643fcb0ae4d598035ebe73c8b1b687df1ab16504f633c929569c6d0e5fae6eea43838fbc8ce2c2b43161d0addc8ccf945a9c4e06294e56a67df0000f561f61b630b1983ba403e775aaeefa8d339f669d1e09ead7eae979383eda983321e1743e5404b4b328da656de79ff52d179833a6bd5129f49432d74d001996c37c68d9ab49fcff8061d193576f396c20e1f0d9ee83a51290ba60efa9c3cb2e15b756321a7ca668cdbf63f95ec33b1c450aa100101be059dc00077245b25a6a66698dee81953ed4a606944076e2858b1420de0095a7f60b08194d6d9a997009d345c71f63a7034b976e409af8a9a040ac7113664609a7adedb76b2fadf04b0348392a1650526eb2a4d6ed5e4bbcda8aabc8488b38f4f5d9a398103536bb8250ed82a9b9825f7703c263f9e", - expected_output_sha256: "080ad71239852124fc26758982090611b9b19abf22d22db3a57f67a06e984a23", - expected_output_sha512: "8d215ee6dc26757c210db0dd00c1c6ed16cc34dbd4bb0fa10c1edb6b62d5ab16aea88c881001b173d270676daf2d6381b5eab8711fa2f5589c477c1d4b84774f", - expected_output_sha384: "904a90010d772a904a35572fdd4bdf1dd253742e47872c8a18e2255f66fa889e44781e65487a043f435daa53c496a53e", - } - ]; + let sha2_type: u32 = read(); + let input: Vec = read(); + let expected_output: Vec = read(); - for ( - i, - ShaTestVector { - input, - expected_output_sha256, - expected_output_sha512, - expected_output_sha384, - }, - ) in test_vectors.iter().enumerate() - { - let input = Vec::from_hex(input).unwrap(); - let expected_output_sha256 = Vec::from_hex(expected_output_sha256).unwrap(); - let mut hasher = Sha256::new(); - hasher.update(black_box(&input)); - let output = hasher.finalize(); - if output.as_slice() != expected_output_sha256.as_slice() { - panic!( - "sha256 test {i} failed on input: {:?}.\nexpected: {:?},\ngot: {:?}", - input, - expected_output_sha256, - output.as_slice() - ); - } - let expected_output_sha512 = Vec::from_hex(expected_output_sha512).unwrap(); - let mut hasher = Sha512::new(); - hasher.update(black_box(&input)); - let output = hasher.finalize(); - if output.as_slice() != expected_output_sha512.as_slice() { - panic!( - "sha512 test {i} failed on input: {:?}.\nexpected: {:?},\ngot: {:?}", - input, - expected_output_sha512, - output.as_slice() - ); - } - let expected_output_sha384 = Vec::from_hex(expected_output_sha384).unwrap(); - let mut hasher = Sha384::new(); - hasher.update(black_box(&input)); - let output = hasher.finalize(); - if output.as_slice() != expected_output_sha384.as_slice() { - panic!( - "sha384 test {i} failed on input: {:?}.\nexpected: {:?},\ngot: {:?}", - input, expected_output_sha384, output - ); - } + let output = match sha2_type { + 256 => Sha256::digest(black_box(&input)).to_vec(), + 384 => Sha384::digest(black_box(&input)).to_vec(), + 512 => Sha512::digest(black_box(&input)).to_vec(), + _ => panic!(), + }; + if output != expected_output { + panic!( + "input: {:?}, expected_output: {:?}, output: {:?}", + input, expected_output, output + ); } } diff --git a/guest-libs/sha2/tests/test_vectors/SHA256LongMsg.rsp b/guest-libs/sha2/tests/test_vectors/SHA256LongMsg.rsp new file mode 100644 index 0000000000..967db2e473 --- /dev/null +++ b/guest-libs/sha2/tests/test_vectors/SHA256LongMsg.rsp @@ -0,0 +1,263 @@ +# CAVS 11.0 +# "SHA-256 LongMsg" information +# SHA-256 tests are configured for BYTE oriented implementations +# Generated on Tue Mar 15 08:23:38 2011 + +[L = 32] + +Len = 1304 +Msg = 451101250ec6f26652249d59dc974b7361d571a8101cdfd36aba3b5854d3ae086b5fdd4597721b66e3c0dc5d8c606d9657d0e323283a5217d1f53f2f284f57b85c8a61ac8924711f895c5ed90ef17745ed2d728abd22a5f7a13479a462d71b56c19a74a40b655c58edfe0a188ad2cf46cbf30524f65d423c837dd1ff2bf462ac4198007345bb44dbb7b1c861298cdf61982a833afc728fae1eda2f87aa2c9480858bec +MD = 3c593aa539fdcdae516cdf2f15000f6634185c88f505b39775fb9ab137a10aa2 + +Len = 2096 +Msg = 6b918fb1a5ad1f9c5e5dbdf10a93a9c8f6bca89f37e79c9fe12a57227941b173ac79d8d440cde8c64c4ebc84a4c803d198a296f3de060900cc427f58ca6ec373084f95dd6c7c427ecfbf781f68be572a88dbcbb188581ab200bfb99a3a816407e7dd6dd21003554d4f7a99c93ebfce5c302ff0e11f26f83fe669acefb0c1bbb8b1e909bd14aa48ba3445c88b0e1190eef765ad898ab8ca2fe507015f1578f10dce3c11a55fb9434ee6e9ad6cc0fdc4684447a9b3b156b908646360f24fec2d8fa69e2c93db78708fcd2eef743dcb9353819b8d667c48ed54cd436fb1476598c4a1d7028e6f2ff50751db36ab6bc32435152a00abd3d58d9a8770d9a3e52d5a3628ae3c9e0325 +MD = 46500b6ae1ab40bde097ef168b0f3199049b55545a1588792d39d594f493dca7 + +Len = 2888 +Msg = 82829690aa3733c62b90d3297886952fc1dc473d67bb7d6bb299e088c65fc95ed3ca0f368d111d9fdcc9476cd4065efce7c481be598537f3f53bbbb6ff67973a69837454499e31398b463288e3aafb8b0600fdba1a25af806b83e1425f384e9eac7570f0c823981ba2cd3d868fba94648759623991e30f997c3bfb33d019150f0467a914f1eb79cd8727106dbf7d5310d0975943a6067cc79029b09239511417d922c7c7ac3dfdd8a41c52455b3c5e164b8289e141d820910f17a9668129743d936f7312e1604bc35f73ab164a3fddfe5fe19b1a4a9f237f61cb8eb792e95d099a1455fb789d8d1622f6c5e976cef951737e36f7a9a4ad19ee0d068e53d9f60457d9148d5a3ce85a546b45c5c631d995f11f037e472fe4e81fa7b9f2ac4068b5308858cd6d8586165c9bd6b322afa755408da9b90a87f3735a5f50eb8568daa58ee7cbc59abf8fd2a44e1eba72928816c890d1b0dbf6004208ff7381c697755adac0137cca342b1693 +MD = 5f4e16a72d6c9857da0ba009ccacd4f26d7f6bf6c1b78a2ed35e68fcb15b8e40 + +Len = 3680 +Msg = 5f664be0c0f3d2fc9a1a7ed6b515ef9c52ad1c7fb3acf2c2de943e109f91cc12ccadd041cc4386f95ab616cf8762ba25fed322fc8c351809e00c600a8f26e25a5bcd0bc3b44170947f65b4f417b8ac769187c2ee4561978289cced04c036c37f942ec10f7fd4d7f6908e22ed6cfd0fb89330c2fde417b956643aaca53baab8a8ff38bdcd35e60547159b26618e1b29128a35ebd2733fc4adf6bf6796076b09fd2554c6a4df5e40ae97f389f986f843ad00000515f9c001aec9c4e47e2c60fea78de8a33c8423d1539dfe125c5b7ea4b17cf8d86e7f84b88264afec06b370dfcebf5e1d3e2c1f005faf248b321593964587852b830c7231504fe947d6a385f399441cfc52df3914fa55cdba25bd215f91a80fc8ffa872b34113dbbd9504868331a38c081fa659574b186169db590f48be67fe75885b6c877d37ec16ebde5ad7be6414084e88670f7b7f485efcf44599f44cbbfbc62e48f62b438319823aeb3767101ec6868e4c85b113ea623193ab9a5ae0ac226328ee4674bf0a90ff1f20eb542e110870bfee01165ab03c2240299319aa3ab1045247bf7f34e8410d96e13aae465597b42336cad2de00b67602a7cb5832cd7253b239ab752a85f452a6166e9de0523bf9c20c2a0c274396d5 +MD = 044d823532092c22a4b48181cfb2c796e1f5b98bcd713a21f70b5afcceef1d73 + +Len = 4472 +Msg = 9d64d891d99bb8aba23a29a8f69b32482714e031d31dde3317b046d000f6b7fc421fa8212d91fb66dc46d531b06faeeafd5ea40302a215351f746c0c42523ba5a3e98bb7b13870d04bf3e0e13425c4fdc11a505ed57c90a90fbc447242b3ee03268a29594dd73c705808efc16a059e08dd118b4a34f178175151760de963f89d34c92b12e9b58ace694fadd73a576193b80bfed0074bf5074cfba9e21da980fb366f39e76d1b8073e88ebf2d8d623827bad051f736d02e02688185fbc7ccaea69244fae2c15146e63b8ed0cb496f494b4b272bc8aac94c8f0dadb45fd015ab25b210170acd9f05afcc1786b758c6bc87d3d93449497d7637a345db161ecc9f00fc9b37677a4de55701f189fba0afba63baaf1584fc36d5819212a5299b39b2c0daad0302aea20d6544e3829f0b726b68686e7681ac3a91f543dcb79f2da30aecb30d23e252e7a661fcb619a98056f61d46e1fe473fd3d11b1c6bbc80be54d20cee843e0f4f65d7d49032f523e6a4830abacf56de9f46bd7c86865ad4359230a9f5dafc928b61c9456a1fbf1427a53cb82dff264eb2de7f9feaf739a47aa64c4a2fd70772f026a33cf1451e852a9e47ae083a159f62e23c0cae8402f775d84f77044204b765fb8e418d6cbb7dd7dacc74b148cbda95991f4c3cf65dd60e6f61b8dce59e6ad127b2dda65b3d0416a0f49392f1f107354c4de6fa14f1482db5a9961f867b921ef33697a4db4d22cf37e69211fd2f2c2944f16252a86755baf0509835ee433733a743f8f0b493e0eae8cb +MD = db593a375cb27df689cd78b5154949e5bc30094a05d704c0295d547385176662 + +Len = 5264 +Msg = 7dd546397a9a0129861fb6815d419a307f90d259d55f3503961754126cd1b776d3236aa2c239b93f8e2837220b80057cf42050518d4f1c2c860840102394b2b19a5f05e4bd043055d8aa9178dd9332c2bef24a181bfd07881d448a37a241349a9a3020e9b021f0d12e4bcd6a1aa3a968a5adc795c7927e7f23743a6d30fec3989a3fc298e6b8811d56b3f2df0cd7f3d871fad0b0d83609795f3f569c16f3e9136433f3d9a6f2699f188b08c1f9589778ea806c51981031de9a4ee8ab9d4a2d73beb5bb9437f632c13e7b18f72a4d1db2d8e8a3604d497d169c48f7820a281721716d23b1e2ed63ea8e2a2869e7df0eed02d97dc5400876892dd68c09a8b7308345023219efff8581d24143ff7836f09031fc0368b976a29f15a0ae28be1fff02011df1b2a6531ff0d0676ea124794e052df93c32ffbb8bc11b4d65c793880d076f6566654e12b99e5145b33734d1adb3be7731095cfeb9550985b9ce7019e0f855839b1b3163dcf31c8319a9f0659702ac1ee8d71667b3c5a5f2b3259dfa023e7c1e98ba956f0e57fbc8a8dfa05e935abe976b8276200177b83a5ab46254fb42acdf632bc35eda32b4bc69c18ce32a23bd8ac2f3c44e2bd50905b764074f516bac6d06570357c5ec10086338fc1de2c5729ef313481cb94562fcd01bd3128e20467289259d8259edd7549f2a373346a8a27c08c94ab0343189c6afc20fc639cb4093f27cd8081d9ed1472381864edb3518cc08fc11322400470c5c420492dbd3637a4b46fd119965c58af92331962bd29b35fc96e6cb0f1a6476dd81f79ffba077cf9c6a54c456ab7dc529fa8032bde8f25feb7e11a27fe7a8ab3c693314219a4439ebd0254adbd9bf9fb9ecba4b19e0e6f3dd9cdae1fbcfdb5481e1ff1ad62991614260b8cbb05554c0b3e32908c8203f99 +MD = 0599f88c429a3d4fcbb0206fa57e344121afdf8e56f78e3f5e61ba3bcf134ec6 + +Len = 6056 +Msg = 42172d5fdae447c4cfdd13836bb8b833c0cb85f7327f92983501a4d7583a5201830266c37c908640b0351461314b526cfb68cad97bd7ed615248fa5756c6213bd9eae98d2f4ecfdf6a452f2e68c9687210b53c74d83575e08a7ace9b49b21056cf377c64f80669c884742e93181c426d871ca2715081733e68ffe94a39e6677aea51e8f0e1a09d258629d7374a2b2884e903c577eba32fa2713f130d2e496eceb4a0f4daf105b31bf9cef4c306de62dfbcd46e2fb283f1352fa3138c31c56d7bb48d6aca301bf3d464ca4bde521d37a78bf66340ac09011e2991b36e4941aba8727e1067a7cba4784f85a53138d0f104dbd16d54e21ea686e772b95c7fa6717e77dcb05a5dfe102e4267c963bfdfd61d36cd53105aa82a95f2afeefddada07254a10104a5a9a7d1fc6d8811def322f1b2352df1e1e90d372d1ae1afa62c6b5c47380f9e0a788347362409307d1b243252bc8d72636bfea460cd905fa1f52c3847b9632c44bb17d519f07c8c86c455c64d49704cfa81cb6382c9776a61a67788ce9b9859d4efc9fe10495e809c9d4c000a9272ec27e8e8171b84f37a65aeb1d054550b814b950e44d1952bb71ee48b8202fe11ca7c0ff9119386b0ea1e7c8fa1618c594d0939792ba66a708a9e5878cecf02b9825745630573452c43fcae457e8e87fe17ae4b8f25274fa9958b67b848d736e68e4a47ba453356c21290a297ca240e667b9b59b4c3dcab43427670ae82b4013558d57553536c221ec07af7db06da562ed360d28e8a3f03ea2be021effede08027c896ce2d2864d9ef80c2ca3d71a15b3d98f4470dab6ffeabc48e9e12fcda1fa63c68cdd250a2fcf03d49f769d5bb391d8872e0057dce5e16e214726980b6579a92d53b6ed704f2b8e64fec7dc27c6456ae90db164295c5adbf9b824ca0fd8fca71e5fe47e412230f22d991c05f6a45b0b1552089224d9b36042bb603843631ff82a1ffa5a055f8bc99f1ce7cd50f42f23aca97a6447d477a58ccf6d555e9a4016d1026d23354d789f49e8bf74bf3c4e6f0f529b4d1ad334164872a0c3b9e5098d93a +MD = 6c83f9b69754facc3155da93261ed99c38e4225e748e8ebcd04ed62719fa56db + +Len = 6848 +Msg = 9c4bdc3b1af6ab9dc7bd2dd90e2e429a07d5dd5c48bb7016fe2ca51d3cbd4f45928ea049e2cd9c6d6f7bcd613773396983a891bbbcaeab28807c32fff5709d2f5d935dabeb1f5b13d53ea190ab155700e701f253c520a834551427ecce03868425e27c2adef4d0d7238d102e131c86a65c6868eb0c1a4f82a47ceaac6e80f48e1104638e6354e3007ef182021691ada40a665b4d38a3885a963de5077feece934a807c9f21487cd810f15fd55d7bb4421882333ff2c43b0353de7fc5a656fcdcf8de2e25c1d783a50115106f8fe282c8ae45588ae28450c602e71fad8dbf65b141a7e0e7ea0ae0b079e5fb9855ce017ef63633f6afebafebcbe02f89dc31f3595062fcae45e87b419fea8918574818ac15dd2a4a020141bad752161f3bb58d1e4b97e9427a793c9f9bab22b63c57af9936c2a65082cfec7a4ec53c3750511b465bcf0f6b30c50c1496b02f3bad04af8e7f6e10ced85c997558bf099bc60f861aa790d6f10fd5d1e6b88216705156fed31868ce8dabb031f11bcae51243f7b4e25865a69bc1b0755e28a8411ad15585b02a384a55a4d49a37c26d38636f108ee695d3e732eb5edec40faa1604d4092c6ddd67eaed6bcfbe8f73316a57f462fc6d8764017f38e8f6609411fff5037bdc51587c181fa7a98340569ce3b677f5e7c1559f5c474d55a379e06463b406b27ba5c4ff3bb1006bd39495380b48a3d23528280c6055d5adcf591a2baa0a84b6f2b14878ba6c201c95d1558d4bd41d00d0eb2834767076f861466bef3bbf25902abd0d70ff18acc4b140c121092490879e527c9e045fd83f4189fb36809b92470a113b6f717d4f6b0e29fe7faefea27089a44dd274eba48a576af18be06673e379f5f9fb7862af1a96d4372ca32bfbc2782bc2592cdc82df8b307573c3e76f6d61b06f9e7c9174d9308892b14f734485522d04ba96fa1948c525b17891e72feca98bc6dfe5d047aec48f3797199d25c101f33a7d180c12cced8fca21b32e5b6839ce26461ce8d0a33b2f4f666b73457f6cc58d2b1cdc1473ebb7ebf68f849ae9f9c1b65c87a1b6bf7bb102a4acbb4dc77bea254b0930c846a7e53a808eb19478d1ab9fa88fc2a10a6d5d77db433ee49f16ac296547d1d64c0961df46187cf21ca9d608b39c153b8df97ad7929ac4b3112551c2023e87e58efa7203d196ae5cde69881a031760294f0852 +MD = f574ac85532bc0c6c4e7614a2e084dbc49fbc474cda593144af28c5cc5f293f8 + +Len = 7640 +Msg = bb64be5c71918756c611cd6e001dbab53e6bf9be164875537ce76367e5f9824cad7da126b6da63a0532b3fdd64dacab2c2703912ddab21c9a3d2826da44504927458803e5161c29d06108ef50fffe0dbfe8a78a81ee19627555b03904f0e50bad89c628c8a4f2fb5a969c29c4bb5859abc62bf6820115cd35a2dedb72d7bef2aa1f250f8a9cc2f5002dde4bc5e244056c2a0153a2d64f9377aee48ca87b5684c9701516af5ff4cd6db15fa3c91739978d9eb83068b02f7b97d471cb0a5e3438782726dcab7110daffab80f042ccb1866c9eb10b48312dec32adf7253cf2e094229ecac00382afa43276f28fc775346895a49c42c5dbd34bc4a5f519a4dbe41e7551817f4bd709cfa2ce24f0cba34aa4954ada756612a830ca56ec26d66ba73ddce9db58f910e7a3dd0b88b1c3c95cd0f7ebec21ad782521a03b5ccb4644a288c5c258fb7fb2a1d72da9ae514469f3541a1251c6106ec2a502cdb77578d98e65cc755ab5542ed0b03132f63dc20796c49858abd1137919215e789cb3f2ac938b5d6d71352af7ece564320105c124dfa8df293ae14b29812d1fe67d1528208a3ff5353cf948a05eed53214f17d64406577b0ebf650bf2a32ed371c9079df7bb1a20470e5051bacf1e6a7b410255d7c376d86389dafa66f7bcf5b51109d874ae906b1d75f8ca99961f36ba8743d4629f7d93e23ac18ae8e74e032ad5aa4c39ed393243044107ef4c563479725ae676e2e229e532a7220b0a68883d97578db9ff8b224229d7be0e6a69e00292c5e087463b06f711fa744fc9730187c69ff1774dfc9785571b418978b0c6107903771631eeb7824949e629bd13eb73f3f23bf461142e972c8a36d2efc1531d95920ea62e83b83158f3fc2b4dc1c29cafeca1a3c14833f21ab3029d3812137468f00ba99470856eb1b72ac703e3035c4aede717f72f64209204392b0a3983cf73bc12a31c5babb4f3d1f67f781e4a5d658460c36b201b9d332c4f2eae9e20894654a8252eab977e9ff2e3c702c9f40a703ea338a5d0e6e26e69b8facdc6763c413830a233d6d556068877303c8c8cde0b7b22ea3fa8427ab46b0b21c028f152f4f5409cd463f1c5d801354dadcc915287c8644a811cbad0a59eba262e6c3e57e20a5c9778d95938750b8261af009e0285b4ebfc12b4bc8ea2735a9a70d699d598f5e904a9bd88487df5f33ee8df0f5875bf2e518cf6b3ff3b9740d1301eb0367a267a76ef771b50436f1c17c3ae61eee855affd28596dcce169217cd49afe05163a8560a29c6eea75b5419ec7f532105df6f541ad531652346750ffe6d1ffbbeda0ae447ba41f91858728367e49fc77374 +MD = 19636dfc80fef6d47c7ab8fa620909ccc387126cec56415c9a898f64be728515 + +Len = 8432 +Msg = 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 +MD = 3380c8dae5c0b68bb264b757e2451c21cbe2b899fe7a871ab1bae6041f48e7ad + +Len = 9224 +Msg = 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 +MD = c31bc10bed1384826cc30369b2d0b5880422e1a34d0eea0b67f29f40de17ba46 + +Len = 10016 +Msg = 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 +MD = c3cd7be2de832774c614ccf60d030d75dfacf3cc7e49a37af349a4c3c196b106 + +Len = 10808 +Msg = 9020918aad4ebe24bfbad9f9109325d09ef520bd79ba08986d949fade1592cb5ff9dc2061586c4063bdca9e53760fd8c9d5fa8d03b8673ecb3f8c82e6a9eb9f0a1be45cae2d0d6069e8d0d541448c2bf748147e045b8ed52047fca660ed3b917c0aca140dcd3fb0c2ef48eae70f47d536c84845560f77fb2a6502cbc94a03112a28f61ceca383b00353ab35c130b362fcb90e89854eb30f4e295769ac6ac2bc98f8e0ade76a69ecaf98605c4c536f33bd9ccfa0fe93d0800007331676aa0ae24d1d126d7a6c62d53c3010b4f4e1dbe5fe0614223e6950fbe4814e48a4923c30baf813c212340ef81dad24d6575679e832677483c159a4e1702a0176d2bde716670c6d524b5bbed3d8823536f03bd9c8ff43495c33cf5ccf1753e5277d878c01d5dc7784723df2d701319a6d3c1c6be6b92c3b01e244e9136ea171e10179ab818beadadf53755b900c4decdfb742b0e00484a21b7954ba6cca95302a0b1ec623fdb9ffd93b7c599d7e39a504de79394345ef271f55797129dfa19878f6f15c57bfbc6ee8a6cd6d3dbb874b833e1a757f01be2273f31d8dd8f2591334617bee9b2674a0a421e3171f68a958b14290f5f1dc943cbffecb7108c71e5912b718ed7cd6852d923957e7a0fa32554588872b4a1ae3ce59c50dbb27b283a26a7472e96b54406e2969864f70d494b9866c6785f6612f6fe7e25edcb4390bb7c235f452e50438fad01f18befdac52fe1a8abca67523f989d0d339464cef18d1a05827ca888af15c2cd669c6a5d5ffab685fe10d44f7c4b4bb14279830395db88b6787b0b44cebfaa63c03f717e5ed4a06589f1ae4410378fd2194333cac3cb4f9f09e95f6ceab6ec29c61b0a250ce426b01216fe184483f1d8819b790bc285f627fd6fade74922108942d9403aaf53d0cf6227ccb56058f92b42295faedb3205b51bb4fc9f332a9eeafa2018a59048262841cb1e02acdd30332494ec9c56fa04b32c61547bf2f61fb4b8999c4ef7ecb12477aafee76f3b1d58ef8528bb7b047c88f81dbd63cdaf1b4e42ecd31e2b67f82bcb6d734cf39949036aa31cf49179f59c4791403f0b7d182260c0c5fb76e083a606bc85197e203a9a5e97cf30e280f557e164e4f7f587a097dcbd7bce1e7fdbfbf03e3d3659f77a8793084955b44206218e3fb274d3f63a157d8cfc806c6e8794519ca28ccc489130d19f934c50e7af6215cab09cedf16f040ad550f7a8d20fd7f17ebd011e3805ffe004b4fefe9679823face8588aa1c5cd4c3f801d1ad6fc2e988a947e99f1605a87deb4520677eae9d48e6291f32ec6d60b7393d90a9fd5000d6b32ec839b29ab8fd59c2fafb38cff9c17252d71bffa880e199112bf5822b519c79c31255de959c192737f4272e72d5ef039164a7ce84b1fd883b282276cb58447dc37c76027cce3bd412907db81d9e4c0a632c68e1888045870a09b3439671692f8e4b1cc6b6cbdfe0f154617e46df430746b2f1d12a5864260c452a814359651fb222ac83ea119fbe42b474d984f57e8aca7cb505f0c6d3e5b06eeab8286ce2bead87b7c26d3bd5fc85351a623e9d58f56d0e450862381f36a4eb9640dc384c9cfeeed11ad6a72d0c375ae4a0fa135cd78cdc0450f548a0a9484f9fc3c5281d2b14bc6af5bce00f6de79a460e4e1414c1c86a75683064f2ae290f79b979c8def99d94e7db7672f7b20477c112810bfb149e3e3ab68a099fc5a5afb67a7096fc88e7fcfa4499ec70492c77e84659578a708ccbb6d498c302807cb4d8bf302f10498258f4c99d98f3c3ae2f1e222da34d4602976c4ab31dc55eec9342d04edd94bbfb3d79b308150c8227e1f52e846bae059e25dd718f7652b193dfa766033f0470c12efbc95ffd25352844efd3e41d474fbdfb8cf174692548f +MD = 888e223d5a497fc679c3ecfe98bf7dc531a4adf3ccf0e6d586c8912ebf781af1 + +Len = 11600 +Msg = 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 +MD = e65812200409ad7e1684a2df8e15685dfab7079449c52d032870d80acceab3f6 + +Len = 12392 +Msg = 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 +MD = 2916d4595a3ede77f4165357977cf3529c672dcf4c39e76ec3aa848dba6ff4f6 + +Len = 13184 +Msg = 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 +MD = df5f9f0898e0fa1bd9c3d3196fa8f7e6b01331d11eb214f7e5629bb7a1b7eb20 + +Len = 13976 +Msg = 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 +MD = 46d6071814544b8de5db52d4b4d22023ba2e630146ef4e47b9b280341985f189 + +Len = 14768 +Msg = 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 +MD = 0a147f33ab036e8ae148061028c6a557e2eeb1a6ea71b3760548734942743557 + +Len = 15560 +Msg = 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 +MD = 07ddd5dafcf04956cc36c1ff290f07c1c0e5832cc8dd9aea502da677ea04fe64 + +Len = 16352 +Msg = 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 +MD = 2ace8ba5195f54a7c501234431e99232dbb1d1365edbb593a3dd3b5810326570 + +Len = 17144 +Msg = 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 +MD = 4c7118050c64cb293f54c5cc199e99aa87c0a7aaeb7256af498e82d535b994c7 + +Len = 17936 +Msg = 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 +MD = 906c5b84ec1e480195860d89f859fc7d3c5f67f585ef8b738ffec08a3c07a98b + +Len = 18728 +Msg = 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 +MD = 09247dc00c0060232407a4e69050b5112c9f72a65d7b0ff077f6be180c482cdb + +Len = 19520 +Msg = 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 +MD = 7b2e8b28951a825924aed1b26e9c197ec080558a97120f34d6e22e341a90c978 + +Len = 20312 +Msg = 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 +MD = a5e93544e86eb9960dcfcebb6bcc461d82f119cae1947e340c7cea1c7f351c0b + +Len = 21104 +Msg = 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 +MD = c525eef8b2ca56547565c947bb7e964e2ecae7c9c82c29228b6c932d2ace181c + +Len = 21896 +Msg = 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 +MD = 31600a05842b12ea927796eafa30e6b1634a97f9bb41a2f75abbb2aa921c17c3 + +Len = 22688 +Msg = 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 +MD = 7ce7f53dc2287da4cf28c9fe64d5515e484c9cc57fd81ec76e66fa38b760565e + +Len = 23480 +Msg = 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 +MD = e026d0e1228ef882d093fe4dbb2ec5134dd122877ac2b380d399bff447fc9fa1 + +Len = 24272 +Msg = 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 +MD = cd26132e2c223d19d3a75ae0664f7475b478695d7824dad856c19417ea0b3794 + +Len = 25064 +Msg = df753c3c6eb6f4e34dde6ee5388b5b818196c4e7a951439e2d0d7223a2e0a4d304a5d30a4c43da8d4033e4258f3c258d1d81c88e9cbe28695ccf427564726b09c14d3e9c1e33d92b95a349dcc59142e02569139d9752da0d41b0f46198ecb8ebbd77653a0d0c5887f436835001131a4240578f5cc493c15283b8712f67d7f53fa12a302c4158c16703f57bc96c48157b16522313490b45ffcaef9f27f8b989ce146f87b9e19e7b946de719912eba9c525062b7094e42cfdec05e6791741ddc60bf4d522b1567eed6d81446ef6ef11590968f3487fcbfc5b50b0cb1b4028856bd4acc79c8073a82f4ed85e82a5474eafd8fe280d57a0a914d530166d9cb845fac5cf4e4d9dc9f9fb85341e88b0acb8161e462843bf1ab996e41466c48f6985ff69dce7ca5bf1eade8b2502f5ab57e44843d182801892a47df7ce2ad49ac4dbe63b7612776d640144db4bba4df8015992e400a556e6910026aaddd10241529e4bb4fb5ce92498c3cafff892e619119ea269842f1cbbae531d57c407c2058b639c610d35a42418b8ed63bc2b72a10129e35ebc8e560a32f3ee99012db869e7c264c9fc2b1cee6c37089116f268026861d23e2a21a754d78906e925b149e0e021114a78abd7e5fbe4b92289763acfbffcfb824da7752e0478f2c29230fb0d1d063e7ce34649ad50488b72a4255f5b6041cbb5a78e33f8325a3ebfe73b4040e6e858dbcc790696f1b8dc1bc78e6a57f1e6cf62b8248835e993472b952ebe2ee65ddce1a4b2834568dc4778842fd0380d3272f40028d679a2baa8a01c99c91993bd57290c91443b1e293a336a78256deaeb52f40ff9a335f636dfb7edfaf5a367bd440c5473cdea9a0640b6eb05ee7c4347ebed482572fd4cae58dd99c0c85edaa410162d0884d66519e78d76477fe58efeba3a492aca222e77b07ba089b5ae852867d0e69e0d70f7ca9b319cbb6e2c26662a8573781d670429533c82c45204cfa0a7c721c2cc6ccaaed81dded03dd2b214c939579be11e7649dd7ac0ff021442b35c636f05460c762d2adcbd34735bba9122d08614b9cafd4f9bc0eb985a3f56c6f2201ee40ee252cc0fd8a84683399851a3e56f610bfef1a13aa9433edef8a45205a7b1cd8b711901f3bc308501fee3dce8e2741f5c1d0bf5169e9840e4d293eb0344d840505b117572d1d68e541e15a95e42448e3ec794a1dc0b3b4d204fbe088791f2ead1e2d48d09c41ab11e09b63d60af415c0861243de789bcc205e27b20ef19820b94baeacf24fd6d9bb4643e0fbc640b076d8c533fb5948d3dfa1d53dab63616412d45cc9261085fbcbb902596be1b01feb2ab8a1de2b63d1f9162f07c79822029e015e2ad2a5f617288200578e23eb6c09c41315eeb693cf55055a9acb598200471add5460d7d038bce96461cc539a9fb6edff1793c281d3dbb6817e1d6c2968f46600d1366ebb636e3557008d3b64bedceea4303516d4e87370ca392799c0428d2ef027be3261a226b000bb39a1f2d3620f29e73c7b3513057d5d5550aaef94f9bad4e15eeb67fccca0881a384eebe53098b6c511b94c5e7923635aff655d682252d5848060787a494e16a5f20af8fd2ed175511a98c0d0b7ab04ce9e94b3c5ef3e1b9a8b5a3a228302d3e5d09cc12244028c13c0e03a71a85d673b94fd98b448c5cdabe7a155fe6304e66138ceed5c5a7223936b58614a3280b5284969b53b1531133dfbfd7216d19b78a1936625b3586a635a84c9de623e5e151e259fb2653ec816da31363970b610b12e4a2d1030263273ef71fb58c2b53db0a490693637acd3fe09f0135116f8abb88fc3eb57daac127cda9cb678707d66ae42f28de9bb4599f353a15d631081b4b64c6868a1bad352a6a46bc2e67680213680b3d474f8f2641c3eaadc16643773d2eea06b97d6813918d448e649dca4b570e73b067ff69c7aa1547458131c043035fcd2bee1389f10fbf29aeb49a8d36c85fef2ebb1be2924ab1d67990140cf3206fe682726e8161f7686c99a8fe4f48c9d4d414ab35783aa6220eb6689d680c26e7dc96f0eecccaeb2193db9c397ef5edf5d8eed2cc99054ede5698953e8fe2895005d5e434eab05d7325d108dcaac2a74b5429ac51d3a6a74f447c8067d33aca20f8cbb6a169a6c0c5a93699384123884dec61a265a673321d6efec4a9e0696be32be502e4a802a7918478a80cd0bcf365e8135f68801f81a12c7bdc9525f2d10f25be334f4478847f4df3cfaad7f38b2bfdab2deb0ef018730390228a126bac1d6cb3d271bd6ce9e76c447a92d54bc21883b5b85d8199691b8ac8512934385f8677626adc81544a5275e73375473a1ab420bf6940b67ff6033880c2d319fd6de2bc5656e02ec31858e1588492bc42f7774b14cb24ec1831b293460218220f59bac1ec414d143df6534524d8ab82fb0aea6972588ab0f6cea201a49978eaf295672ea09443d02946e9f7b8b9f059d6a77612449bd293900f6a2a18e375e35bc370392fda84f1199c859fa0a331af4a6fb2bc07ffad02788673631f9a8f998f467e97c68e80e58369aea3592ecfd1eac618fd390e7a9c24b656532509367c21a0eac1212ac83c0b20cd896eb72b801c4d212c5452bbbf09317b50c5c9fb1997553d2bbc29bb42f5748ad83dc6e538736763eff646f0f9aa6a5b028e575de074f5fe5de425dab8e6b73f0662f88d49749749ae7b55aaba9cd38deecb3bcf6f3ee5a6de5589b70c637b82aa6aa67451847f5aee60295990350f8c6c18d1d02449b6bf037cdfd09bd033de2ab16b4adf47620036511c7e192770cf0103c4009e49ebaf83c682a805d172aa0dd3a1615121f1e20caab99893c8a9ce43f89cc13ba3f700c5cf3cbdd8dbaa8eda4e036845a89168d7e98b39bebd0d22bb8396a29aec6b5b5ff3487263435df4f68cebb02b4fe31d3eaa0bc1e8692d44ce117c151a87ab0798df507653cd0f65091cd4e9808c49779758b5d1bf518cacf24ea7a9590a58ae36efcf2a18cd3157887a5974c3e246f0786203d9920aadd3de8793cfd4e8d6a780a11f1e30c86664eb21e3d283e66e106872805a0ef90341c948db090cb7a79c2cafeac32a4310e5a7b00e934f0d217fddf6c5c394a11f9f792ee7d56edb6df48148aca963c1b3824481242773db03674f6b1eb6a1977515349644c579d88c392517cf417bc8d0a35821df1f90b4769f334c2593d440866ba21b7c59cc4374d29ea9dd1be0ccfac1492e99dc244e0d60301664fbab30d60b382ae8f2c480ca79445b50a9215294749de3eefdbcec3a52bc56475e84ecd67c7d413530f134ff65bcc8c469bbde3035dd0e48f4b9338fff4e88572cffe92a17c7facb84e0b486507e6e92ee2ed4407d7cfa2241a79870ce5d291ef77a9a2395deb4267f01a3e191ffa95696e8e957c3f424256506af7f386eb5093e9384655ef819c07fd277b3d2b7259a048861f891e938acff64dd1dd5f9c89072c94c61ebca784417e1945f7b3b5fb7b76bf2757fa29433414095ef1f94b06f248a36abb4bc6c0bd7adae56f402b43a1021ff80e5e6c3530b088e358db628dfd464f7a5424471922f951a3cf593cfbbbf390d9d5cfc42769d4b1ab398d47e7d02d7f3d13d09057190366c63c8750e97052f911d4d799e287876cfdbd9864dc12051bfc1ed60b4249a10198e051cfd7692641e934fd532f33d2a1200b831f336bd60aff9dbe1fa15bda0a5fe33f218b4e7752a91dc95ad415bb385d4dd6e2b685a9368eb911333ef6b769646dd9aecdc64e1399b6c41799d44d1afca81a142b058586f19955b1dfc33e07efa4a8df6779b26c002875f048188d2d4546d61c5b9673e26f6715004d6979ca47b3331a1f10ab45289a654ea78b855a7f4f92640ede7a325248d6885091709bb6c002c8bf33418657351a9a80d33c8af4ebd6530b85a25ee06622b1afe32a6382f49e520d897d18d6211e3a9998baa3ea402b511c34f34f62e980e33406af08f4768e1ed2bb66e1ed85f998ba83088eaa7918c6079376eb1ff97986a5a30774546f5a96d57004cae389311aad3b2d347cbc261a9549321b61bc9402cb613b8dea068b21e05160bb0257502a3969317ca731dbb68eff2fc86e5d59bf6ee9513dfd64a826b906819d9014de2f25b51d4d7502c200ba5c76d89002502656e2546ad7b0390f29367056d6eb61913ac6f8912c546061e1090e350cd4029d4af549febe13c743f88933d01c0263b74045ca2f15523f42caadffc52dfaf68d14ca3ae0fbb5d92aeea9d4f1aa816b0bffd99b0f7821e6093ef152723a9cb45f7a082ef8d6bdf72cd33b5aa3c79102f43e2b74199decdd20057d0e227ae4c57945582e2e9653a9b16eeacecdbc5aaedac7e35c35cbd9adede7f83bbf36f8b0453d61416a85a17821885b3757d203fa2560a85c4b4c10 +MD = 176b0c71e213031a29f56009aac7ebec591ba24a8b162d80506b2df8f59e11a2 + +Len = 25856 +Msg = 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 +MD = 36423179904261f57bf7405853a319058065857e67a510128baf09a68c30b987 + +Len = 26648 +Msg = 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 +MD = 54290349fbb1e8327a65b871f3fc2c6d3975775e48dd1d7b2c368142bcfc8c27 + +Len = 27440 +Msg = 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 +MD = 683712362407cefd2968ce6373cbd86c1a6170493c84025be740129120d327bc + +Len = 28232 +Msg = 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 +MD = 76e3a0221b6d29a43a0c2929baaf46ab00b85571d59ef2b3f0facb315621f4ec + +Len = 29024 +Msg = 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 +MD = a7c4cff2f73c911d7e3f2f82b20adb9cf2caafc9254cf5997215a11046846d0e + +Len = 29816 +Msg = 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 +MD = 977495dc59e74389b65ee1a7a33295014abdcf7916f9e0d1ca39a7cd395e6c41 + +Len = 30608 +Msg = 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 +MD = 6a5f09b3e0a8ae5d795f2dbed00ee521aed5b0875d2e487a82b2c687b527c278 + +Len = 31400 +Msg = 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 +MD = 5ba431851b1e2be373d818c3c6884e53d82273219c3f1c36c9aae099fa6690e1 + +Len = 32192 +Msg = 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 +MD = d305c4ce0161386004c267eaa17180eb2433280716c894ed4094c2597a582da1 + +Len = 32984 +Msg = 0f5452e6b51540cf219998590995cd7f8785fa40b4f217fc79f07322a2ec5e0834a4261a0177463779dfd958c33c55730dd3759f20167778372688c511967d584572c336d67f99f807c57c71704be39152222d8928a4d8307efef3a606ecd637e9c410825bb6a1da72526aec384ae1a2ff7a0948f425a2eef7829c0daa77d26dc8a4f545b9a3c6a5638e891142c2b66ebbe3f123ad213c784ab96c4125bed9c18b195ac917cf71208182c227b73bcabd2f66cd617b1e10961eab498c9e4954fcda2b27549ec008147535fe78be3b8557020a854b85a685121b611c343da1a9e65ce3442f7500f549e6af234a804c4f04ddd80229f44003b3eae2ce822c4d4247ba489aa2c6179e877df91ae625f5908b68d62a43ef75f240333645be90d585e79c630ff4b68b6d96e21acc94d4bfb0b54a0ee6e09fcbbb829d666b3094c2dc8ea83a8c6f6fe6c83dbc1a209cb530174a2c881f492cccc441d17927205d9bae0389d8fa5919af1945b302fd45f1d22d12b54bbbc7bd007644777760d516e8630fe5423ffbdb6fc77770d94dd8b02d5bd48e5fa4a07aee395536690098e532637a6582459ddead3a999ba7f79d19c7075a5eccc01c8c1e763ab656eeb1f2ff150cb09ef2874af1da73dc75e3dc552a9b6ace9af9851b1893bca046126866dae38c6fa1300046c40fcfd94af9dd8bde7dcd86d235214e65faa39c415404694834c44990e651faac41733d2e21e7e469174b2d7c5e3a4e8c11b751509ccf22d3717ae775fcc38f33d828ae2943448855cfab6b9e5b16431542c0687ad20fba020077f057599c2de13cb6d444473a9e2a0fb7ea4214fd5489f48588c8de0d595d4a830d3fe724fb3dd5e5598615124f6e3e354f6f7139a96e8ecf5a40a811256db765e6348da522cf0c7de2f89514c2abc3ee452e5a116b4f7a6686ed196349b9b0e7223e3365ca1f47451aa0b087206808aa7286b7ccc2b11f12b3d4174aebca9bcf6965c1ad19b6ef06a6884cb5902e74307e7f70b3d51ee59b89ff8b103426e1e665b220c53a1b6d8831b852e43b846f4a12216d0ecd1d34c8b2755efb4b57ebf4bc2c36f553d627936136ab5d48f261bed6759725d1377462d33e765458e520c116dcec858d7087efde0c3d68e000b2557182d43f0af20d319763bd628556e7141cc82bbc0f70f4635142f24c2b37cbd78c500da5a0d968fda3eb1a6ff834aab775fad9e4025ed6b962deb153501e120ccee82ba0ba71eb8ea2de74c1d906d070ca7adf438dc394b7b8ea61c3783ef0bce05114768044ffac3a44b5a15155c108c34e2621d9259826fc6dece5ca1dceae6993b26f1bd90d1e1326c45788a8e447078095c80d0f49cdd57039016f4512ab12b7ebd5b3b87badd68b892ba587a3f43f18137f52060f76ecfa305f8e3e267b83c4a9ee6f6ab2212b7cec65d07a65d9121c8a8dd09452e7e813b946508e70e663c2d30478761b42b900d54c330a93bc2996e13bae407ae973c3bc00ddbf5ab45aba515df6641dd7291f2c29f3be93662b8d00d11592ef44321321d35c594aac12b30b4110bd1faa22e1d9443b1fce9fc10acf972c131ac0cf0ad008f5e2aa9730b5e8faee078b814d4fc4e531b4ac2e931435d41c4a6125f2b1b2e6d2e4e13d5fc8d3cfb9cdc8255270d654fd0596dd48b31dd20cc02d3a420eadb718e6576645f5b10799943e5ed84df5d8c89af27289ef6cd725fbe7c8682caac1f27174da8a436bebb5e655f387ec0abbbafc29b6fdd10b2c8e85f5970b10924e860ca060d7bbe9c3364a75ae0957fe43fab2a4714d60e21970e6c16fd4c44ba4fc3f43c2d46313d7434906550396b7b9b144ca6b20a5d9e5f3a4b1186b4fbf0b7d92c5c62845d16e056a70b120af1f65063b026b1fa6d9da3e492f5977b9d4cd318e8e357b690cd1a4351b8a05ac1d8e221db63bf26dc83e7a5da2fca10a74313fba06d677d5aa49473270a85d94987d2c754da14002905ace6672c7904b867ecf9e9673c293951c16ead5d2ce707a7b4dc82f66b16b177663ee0683ec84f2fd0bc3a4d204abb3923ae4b3d20047aaceada0c352eeb247da617cc8f85fbba0f619b09abce623eef5dba8736e9d2110be7384732c9fdf06cdef991fed8ffa78b021eddef90f052d8b20bf7b6f4a079495c8fda7be6cf83e9835cb732b244861754c03da512959589e32b0359cb1ff1e99d392c5cefb07d6845c9d2d7bc7ae468bc179f48cd9255674390307bf7a149614bdcb3625f713b6d78c94b3a320320c3ba9d79671c97311555c415b9e4d4be44cad30628b0625c6d9ec3a6e6bd6df9ccd2ca627caa14a708bc3f19803d0aef08acc4ab1c7d044eed4a516c69d92bade89716d0f5d08b35b5d979b26b4ae44a21541a08ca3fe78160edeb024fffbcdbab7a1b4b5f3a7b4ba1200c76d798d15e33735ba59e538c926d0c091ee5bba1f199ee3048353265875f325fed51c162a9936d02181562540066273408e7776b8e18760e3e0472ca475482fc7c663f08aae5b395c6dbe6ee49e0c1e456a1bd8a1fcba40dc349561a2a05945aba818c33d08ee99f384e5bbbed616ea29ec1187e1507faa74e8066f59df6d9031e301394c9137176f2d92b3d497c7fe737a202c80c71ec6356262fbd11bcd38e1dfe7f8be2f7ddc57d28ffe30c76983ab7e0f6f8748debda60b71b0133ac264430491a89bcc0a1033daa245da5042a05a5fa7f7fdba09b74f4bfa332626923ce0bbc9f2ec4f24d98cad9430d8189b7e0785b06dea07e5dbb98bc72f12c585e93f6a557eb8a01462e8b32c663409bb443a58f2785616bb526b319e4ae001e593e87bfef307a722d1d2543490f60aec1b7b4034c14acfd244eda7482c97c0f86164548cf9e14c954fcff872552402742b53a540f0cd1a74d8c8538d7e3fec087c3a5fc73a4f77b7036907b05ec8db9c9b49efdcace8dfe736839f34e8e16c5b0cf202775b5810ce1627e9b452e97cac94e686d19da2067487a6f207118328393815a7630705ff23af910646da90cdec3db0d2e66c037763f3bab3cca23008ec282ab554e45d2cfef730c6309ec4b6a3bf313ce5c1131bfca1464c4c42edf4bb05b994129a687fa6168b9239458d1f1b41f12a9443dbd887bad2244f9ac4d4edf74aab65d22ee165332bd02878f3f09aec7705bd9b62974b65e6a39d52bc90cb2566641534b838817696eac6deff1169e74b362671b04191cb0b31fd11dd109db89426e9670d6e43085646db20b86ad05bf523986ccebca113c836387f303dabd75d5aaa143569f311f34e2fe527e41670fd36da34c3f2c366a61a1645bcfd3cab486620e23913d9b8f36889d65265854decd6b67297c93fec2c455f0b8a39995cddb3137a20523d26e0feb29a43d6631b4a6af2ce532b5ccce220db78a0da0b11a4a94b83f2106683417773da0220f9019d5c57effeff632f5011523508c6d8f226b08fa6b7349df69f3b923e95298f286f13ad7ea02d9c3cff818beacae74828ea31a98b78a62aa781b2d76d06db6db847f7bc22429c4f1c76d94f3eec23a5db78925fd93d4e55bf6f440c105d1ddad8ae704b84ea36c4f63d7f66d978643532593d7a380c146666f159f7cea0d620b02be6244ba3e243f3dddd9864759142561498c252efe0a4c390596250d9f0856946c10d207288133bdd59ad87ec92126f310dfecced9a58ffd3ac133e0f52522b8769cfab61117df5c55d6ce9e44feda43903f8510e2aca4143bad23f4be4ce1d774732937763c94a1e509e3365af1d1db3e276875b7842b266eb69fb948e43689dc1fd81bc673f616e9a0b0c789de90327114116db6c087ac7a89e1bf238f7338140fa1c3905266340a37b1d23fe987e1dfa21a797ef63c0eb573b476dca33a7ac2def0df526c87719d2b60e70bb73b51e04dde295e79dac5c6206260e2c3feca5eea5fbf8b06bc68391838667bcc2d1b1973f6edf3efc68a12fc861dc476329f4ede48f4b8d58770548ac2d0fe9cdf95f1b0df47ddac9194228489fdf01e78722907371f5a3d7b3285df7ac702adb56aff8101b75a54beac7b350892043122db6411c48fedc2fa272392dab926835102997108cd185cc01b93aa6c7a6f62e433867a5bc6f1eaa6b6d4416d17e89244e555ed5ee99649286a02413007a0081f33169d7774f538e37a1e679c73b77ee38bcb626ead329e6a202d95fdca24b546328b17a1ea662242d95881f35d118dbf7e508cc2889bc107c69c1520528bdeebba5a6565c7d33b476d190d1c1495635b358ba904fc205583e5c44b4201340992430b032d6dbae8639dd685516aa1842939e36380787eb060d64ca4cd86cbb9bc65237d837c8bbe19f427673dafc454cc03ee28cfadf59611408bbe3d23a153dc892a30e254c420fd08724f5b647c79962c02856ced234b278d07f41b98538c752795d9d48702b56f334d9a151948571a0ad6f5c2b68654164447e2e33560b818e8ecb4d4a3b5eff30d1fc4154ea671ea28c1e67baaad456feed2072e8b476b2a25956e5d0b6c351b0e7f79b665255e791e59f3f229f69396e52ced482a761a4b662662f85e743969bfd317830d33713954159ac0c4f0d31ddfbee1ea637b49df33264f10ed8c414199c129f5975f5ebd526b47620c3a6887371ea16fe6d57e68050b6f416912f15504b02da8a4078b77a1f186405021d84573b2885325033c78644c60043186ddf6b9269ef6b3da6bfabb1ed4064145b6eb2e11232eae82e872d97fbdd3d7765ba90f9afa7a373684a91669bd0e402478eabec0ee7cd3e31709cd0bc52adb6fef0e8093ccadbeba7a153c58add2ed3c82b6be3866a835925c8fc7773283bdb22c89a497920baab490d1b56232ee98fc88e194ee184b542f0d8741487278ef0b889ce42cc70e9bd37d40ea2cc8dbe3f2e00deb687fd0bff7ce82d3060174ffca77cae7a9e840f285a3e5630eec055eae2c7e2a1e09d2c9aaf404f5266c02508d9e95f7b5822d5f599951b88f2905598cb2b4c9a542cc11a7327010301eab91b35180ccd6013e32bdb1f84333ec56751d37644264b717188afe76bca995cb33da350dbf6201fe0d20a26bab83c27321ee1eef4cf2d35e5eb4bc6b62f96dfba760bdaf480fe0d75f30df0e59f537d5f06dedd821c6240c44b2e0d0aba603b76cf55fe80f364a74995ccc52b71ea919512b0891695525ab7b142038ef45f38904f6a04a7d5b9b305c02fefb7b56b297d49403bd9c3654b66236ef26b64fb9db0ff303490b065fa507c1eb5aff33d0ebeb3763af22d04da78ac9a20c8939d347de590d6640bd044d3d2815e3cb4c80801583ad08a5c95d19651aed6ce07abc3a00b72314a6f625935c94033857e74dfee417543c9d682f6671c935ca54a8f13c079bf8e6b6383001f6a437cb3dca95a2c750ddcd625311294142ffa74e4afec86365d35ef6f9b0339bc7281ed53cf4264fcece3dad00cecc4416bf8635b75169a4a366efd1b12282ac7b6895c6d4e5f3ddff8a0fc60794ea0ac309d9c394858a3bd3181bdf050389b93f5dd27b18e7960251b5a655ce2fecf5c643344058f7b4a9735b55875bdfa332919c678a7f85874d63c5b3c4caec5fa59f0008648b44836e12c54f633c1389b90088a74d8f2c322fb43e9aab9456bc9acbd4d88891e840fa3fda4beb0c5b87ad0ac7145cbe584129a174dd72a0fb8e35cb261725035fa7fe390eed9762f4379f2ebc513083a61ebbea2cfea277474f171b6866d2661712cabcd796f0d69a140fcafcc05185723566ccbb60c38dc669af4b302a1910ab0be029c8fa7fbd99a76f9dfd04482a692faae7a +MD = f98918c63e3a9238e78dbd5bebe4e47eaeec0ae1627387dcd2a5ae4725f7e47c + +Len = 33776 +Msg = 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 +MD = cf17b0770212e87516c080aad008d50cb5481044626a325be730d54a66f66662 + +Len = 34568 +Msg = f60c89481488d65c26a6ba364c5d602134ed1afad5c2b037609bf82873eba67d907f6609cf6228c5cffebb18f2839e55ca8d1386ce0174685237cab6b65f9caadd1d05c2e07709c004f129f4eaf635bd067a624e52de9dae44141e02fd033f0fc32d8ffbb18f2253adc82c539b7ece61d0fe30daca22d0111e781a95b1a038b32bf62b3ca9721b89b3ccebbb6de31147115fa5b39c95b79ac8ace6f63bfe2e9ffec1020e30e79b67fc428fb7c8eca579afe6e86032fffa502af8abad01e5cad922d63cf8aeb74af771753fcc146333ff94db2269f328413c2da391436d1db46b817d00838baad240faac2484b90e62dfa6867a5746d83364b7f7bf3fe66d935c02fe76353088d84a802e66661fb5db23cf2e19b095d678d2b13a5e29d39f10b58ca0c7990319071ee9442cfaaf2246d3f61d26ff47ebb98e04b5958a9e79d27d09ad1b346d2504c31f369ec9cf1c4af50399cac9c4df9e9e96b08de9aec482bc606b9990d7737a41084ce65ae86a8f93ddeb2d98737ace0c51736dce6b47c77b79236a34a7cc0fa18ece293563d5beb46e5b76f3be83f2e01c455ec13dcc4ac13c1cb5a847f86bea980392e3a6257f619d30ce630cc4b120de70884b8c19b29691a0a3751dbf37240d3446eb1b2279a152b45c6fc603b4d6813a12f3c0f8a80260f55c2293e91b57d7a970d52993557c752d499f5209a209ecec2542412ed40e916407370f3dbe8cddaa362a3742bafaefe4bc7b199e24c207cde8bf7886ddc10c35cd3cfb84c9cb077fc071aff55124a621de8c8389e208ba2784f2cbc76c24b9b0d5babe86e31a3d6f3732f875c201832cd659f99483e3ed402063a3b8283d801d4839c00bb58367c3c3f67a8ab4996e4ccd6ae185b05b8862e59b6923ba164ac34d3f69dbe70d6dc48b439dfbcff550caeb48a425107973d3fb2183cec9b7fdeb0d5621bd20c037b7b8a4c992bc1c0fee577aab3c4c4497db897d5b81fe2683ddaf05507b08a5aee7719e6615231695003a885d920bc5dac4b7385706016dc2e15cd55edb48c3b89bdfbbdc4dabecc848bbfb21eef60225d4afd9e1247994a43f3c4cb3a688233e1a2a829302fda5920e035a611ab405615596e860a20ea1103e76f4b7a36fcb29ad797bf4fcc149da99392d84dceed6748d97ed3c49699eed273355d39ca6c55f9cf42f65029ee1883286fdf2fd4c7b48c5d771dce1329225429af56d57d519ca2fc5254fde3c7483211250124575fec34481fcaa3210869fd7d45eef9ea3cd51ae11e51b56440ab5ae04b14e7b1266cf54bb140d03ac81432e0818bf37b8ebdb6003f82f335eab052185a50d69cabc533bad436d1dae8bf98f5fa947eabd7a528ec0e5f53c31605bc1bcb6b8d54607364281103349bdaca941019bed815a839d807334d33b66309fd7d26bb5882e4f62b15c03c54d81ed3b8d15761bc2360da47e426e33f6a424b9abee4c6d4a299dbed068a58cf1a45597bbc3c03877fa204fd0551a7c379443928539e248e2dff832e6cd7df0ffcbeda6133503ac664dc486bdd5c016c4de9510addbb4af1af968a63db3145a3da0bc4edc90c6de58d802318eeae9696529221c6afb4b08b81ff5021b41f03075cbca7860ff92381443e1388cbb1cdde41df39f06c12dbc85f8a82ec99f9bdb6df41f0de5a8ee2164356a83fc71e1da08630f7fc756e434492d88138ff69dc4eec2c4f3b4b362010e56a4fa2933c0c898a37ea6f6e2f8d7cc659d97b46e7c52bfddc01415497641db4f97865a2a420f5d8449fada8cef0cd549f0a3822ec2ecaaee1b564f92b34793c84b0dd67eee171faf7765bd7d533d2e8188203f5ff6fc759ddda3acb5a07cfe68c978e6564c48a5cc10cee5ddabd19db46ef43428a1e9e9910fe272dac648e3d818b0d2dae50bb9821d1c9bd38030eb8aa809a9b24a1bce73b9fbea2bab140cc0409ce23440c62179a439278759c2e0ad4045e62479faeceae1d55ccdd9463fc64a235e89e6e3a65ab00cd122beee43c23d9232a7b7ee0a9f915a10ebd84845953d2f8d045dc810cd467de1cc371fde74a8d7d7638a5ff239d0714dab2e80e6d321a7b8ca2fdf277970749eac4dba776888fc1b7f7db56a61a7025d356558e929fe722706e38eb30735d952eb8728d749e5e8472415583bbf1cf686b20536183edd7a22de023f7b1e9e9443b06ed1c6bdc885a279dcb02dfa3a33114a948439bbc5a6f17a13594867b18eb924881d0b6c38ba76a7592607bb06a246249ca91547bfdedb039e44e28a78adfe6f607570003d6f09d5142093a98a2b6c69a40d748bd20a29a12c67112efbda59b87b3fbb1edf8ca52c9607976dcdb7cc4035181e2e0613247b442c9dfb41fe112763e4b57027fa90d46644dcaed72cafd2d632dad963df11ba6efa4d9b52ff6fe69fcd269e1c9f12f40c3d2a15b1745b470fc37134f2573b85323aeab336c7bb1ab761d650c66475b4115c484a627519c66833ace6ba63e90519523ceef53c3dee33078c2d2e31ff3dfc0800f4f21930776aea5198c3ec6262aaab0bf198483c889c2912dd5beffab755a818bb6a46ea839c5128f116d8efc36ead1f6727d202107a2e2e095584ac4aa5a65949d1e68d1286cefb9aba11d850ebc040f6a8c1d5af537ea95925da5e1c72698b432fe0624bb1ca903ab77d6533ab4d354625fffe8cb1814a74d2d85758475976548c1cb157a4aeb07a1606de9136bac700a573c4d11b9fdb036465e124a9dee122f182c25ee7e02302de938a951271becc310571a31a4022ade46b42a82260965565fadc8703cab179170bb264c9d8e251d09d4c2c35cce91b59d1c30e39475b96f16c48fa7fd22288ca589e29e359fa388a239c94f4abf6f4cb7fac7b77fbf98d9cc04fe0e3623dd6fe61960ae65bd028677faa03df4511e1435c451962e438e16ede3761b8e1cb0cbb0ee22f5c462aca709abea07f02048ac752d510846bdf3a6fae48a485b794d10947c9c1cc81d1c6ac5a1f935b4b96966248a68865f6b842a819ccd2d24b60cef1f494e8bf768dc324a81705fb868eae1927fea88bef899e200509122807f7aa7afd8ccbbc8c2569de6dec1ee81db579f6d5269880bc1bf9df5c488d0d52210ead4af6934b2b6362e48fe705a976d3a0003b6681ccc736f9ee04d16a0c94a5a290c41d67f4bb0d533ef850e3c6fbb0ca3f41058bf576a14654e7ecd2aa364c0d2e51487040a4ece7f28e6fdfc81213a0bcd04ddd8533268919ebe1ed719edef88cdabed6b64fc8c40a3b8b223625c5c97ece84a004658b6a46faf7e2e835230ab448c8c0df2269928de5eed3989b8fee8d25f3fbf8739990e2fb78da9763e2ecad81ae56418696fa8476de1b77dc37b7f2bbe217ebc718a4f5d5aafc0791e5457f6fb8c266e419a3f6d5a422595085cbb47a991b64c8d04d8872d671bf25f2be33f92e29d6a2b837ebea880fc95f43d3db485f30ecde8934a1b943604789d2ffcf0657b6172a3c5b6c9dd10a4c713776700f7e7e0a710a014b923bf228234daf5e807c8eb3e26cb97fd6c93d6cee2a5d7ab63c2c46e91c5b8be5044fe95d2a76e54ee5dc323412f92f7db6ceb03ee5300125e26328af87ea6b9ae79e129e33fe6e58dac61a87f4c3817ae1e5a0c92d960e44b74a39291357f29a2c082c4d2eec0086a374f542dcbd7fb592abc5f7cd37a7fb050a00c0874a28cb1bb4bed4e4eba4c0870f4acf909230171147a6318bbcd73212ca05dcad6a1616fcca509a1da161eecfbfa295d8e89c86a5e2ccdd31cda3d128b3d1e64b60c36316746a07a0b63ff8c4ab84fc7e68cceb97a4bd65851115c08dedeb442ad3389bb2d8958337d346c6abfc786c48b9c72f2fb4032f503134e7899fdb60126c7ba4181e5876a8a07f40cfd9064d00839538b53b26a559d4082e66f12aa1cbd39668906f3c48bcc4f14f776bb7076c703ff07160ac2d6aa39a7e6a0c5f6e1caf90ce62f3c8613be8a4d9eada12025526cc3eab4c1f314946f1bddf180231cea972bdd5d1842aedb3a1c7714da0a7824d4409aa260618bf6415d50b3c9c51a968431f3232f8099aceef0254ece75cbd8eb03bb717ea4a94a50fac37a1b43675950bdbc13dad6709e09671dbe0718acc9117bb1a47522f90b3e62caa6fd248fad7d3d9ca1b2aad03929ffb4e51c69a78fd81711bddc62f7b33a23caecd7eef00d7a20195f3f741508c118af4666cf2897af6450202ceb21cd04cc389e341934e3c803b6aee9d8db875f4051648edfcc7b27f1f16ddf3203c30ebab84daa29cadaf756f9034a3f703f55153fc1fd11ffa4a23e7a097bce1a3fb87dbe7da2a72e5d88a8550ec91e9f8b62f5eee129ec2e9edeb85e857b25d19da293bfa0a5f7dbe5ec665f23ef0ca605d960d3449de4f5d41dde136465bfc6674d7b30593cb2500ea32f7be53460203958e4815ed182d1eee04e4d28c422751739b2b4f9df6d37223d424fb531ef9a90420f7da26d5c4f49d65740350ec44a47c7d8b214f67edddb2b6d2f366fd161a525303cc1b9c7ca7f60a7a13bae3bd253a84bbc3d1a6dd093ee0eaecb26dc31d28305230f5f5bdfea0fadf48f3aef89d52b8a37d4c3b09be7058552f62f5687c2ebdcd51db68efc2443d89eb23d55fd36f212c97e8afdbc4f028f9049c1e6bfd0b045c76f67e7abb89dc624371e0589137c83c58cc88b9e26558c0b2886e3569670de8e66ebec6b118de519a06584d9d52b4bc0921510de277ee9183506f2e87ecde57ea6ab13b6c984b3d360ac5a5c069ed95f20e8f3e8acff453bd19a9be21408193ca12dd42b3b22b1060a4adc8c2247cad5bbcccb4a31571f0a90ea34efd0bfe82ce8fcc41500e87b160fc9a1e6b2a68ee8c528fd7f4f16e4f8f54e544e5f65b0e3e0906a2095366087e3b130f8324b93fccf9610f4709f258b716f70a9ea8a21e61a711cba729d1fd0289a103d1b9788765d9c9c4620805f3687a6206f3cadb9980927726f23acf78330dca621e92acb09d194f5e0e94af08eca8ada2ab040c69e3f2c019b12b68615bf0199432565da1bde27b451355f97f89c960458dfd3f75d2ee720eaea7a4a0c0591301d5ae93420c5bd6e139f5ea4088050356635e7ba595ae176caf548c1daa714211cf42577bd4ade79b48198b3431831f3ff3cec9e1735b369b7dda27c163602d2de7b9b0345bff36d9076be241cb6c3b6706f63011b61d5803e0e27e72324d5cbbe7bca755eb7a4c043f93fa50a0e7e036637eb81da41b040c9f1497195e60582595f243c6ca45b085b839d84af61d9514d40d69ed867ec21e84177c9f30c3a8d1b9048c6f408aeac23a0486151636e2691f4b4c6aa36d1aa1559435eaf09bd4291d998a39976e83258d9c0b9b48594f9d0de2687a451195fddb32c8e4e6136593885a460a151b021578aa6fc2d3ae65186677c506b292ba9ade9a3f745950e279c1eec7cc04b9effac5d6ba74015eab43f2b56cf7331712e02673a181937dd34291ff1565aa6fd33b3ac7f5981891aa847841643310c824387a66f7f5dac0c056c03239bf50663542a0262816616ee844c2c6b5a491ce7808a31b48b77741321d16313ac03dc69d76be9a59d6241eefec96ea6831fe5196b96a399cafb229b1ff5ba42052bbb6933f5ecc92bfa9c947e2bd5584c19e7807b49569fcc5d2a0c3645632f45c105ea0054663dabb37957690ffb0113eba6c5260ec526ee121cdf2b4d084bdc585e74b303f083ab217ad065c23a3188f9a55ff24399dfdebe5d9c5579142837762791d281163b88a92377fb0f3d59f9c865a966a42f1aecb67ecc4b561134e59ef3b9d56841b5f2cee5c67f335efb14dc6a3a099d0f78b69ef2c7836089f27537456532060d934807343488db298538aa159a518ab569badc4c468434d8f154d38f2c7ef6c44416e6b15a9e632798f3b61a42b519bb7e68030da1d42f98b212f8435822c71058ddf1cf913667d3a6c484cabbcab68c275c879971d9dd43a52e1a04a0b3d37c320b9cf180d755a82f399ab97df8ed91e4f6fe822f2baa645b04cd457ea8c862703e6cd991f7b92f92a16c58f1d62b8747c5bc5a42303375343566885a87f26d93d4c +MD = 10e88348b55c5c0683f4d4d3ef56c485be9888bf00806040de25204d25df4ea6 + +Len = 35360 +Msg = 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 +MD = d46ef45eb47aa54032fc8ea47150d10334b208dc6b7ac5e09e8718231e87cd1c + +Len = 36152 +Msg = 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 +MD = 982c20c2493fc9ae405b74b65a022662c014a38ef3d707217e56e57afac05994 + +Len = 36944 +Msg = 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 +MD = 8e28867538bc2c6c94d3428f05b1458f428d3f950430b09238209efe6bb267d9 + +Len = 37736 +Msg = 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 +MD = 022aa46f368252ce0a7b2431d55ac4767455865dfe65d2e372f4e82691a14cb2 + +Len = 38528 +Msg = 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 +MD = 5d1f1f7c14e34f79468bb5de195a60f3b422c4e48757facf1df01d1b022e6764 + +Len = 39320 +Msg = 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 +MD = 6025dc79681355ec9f3886a74b39dc4d1d2e6c77180080e9d296e5ca7742d04e + +Len = 40112 +Msg = 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 +MD = f52b3c537f28d89f0df1efee21c70f74df186f3928296d19582d5c51286e98bc + +Len = 40904 +Msg = 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 +MD = 1ca0be9286023fb0b947f07cad056e59cff9d2d16c7cefdbedc33950a9312685 + +Len = 41696 +Msg = d9db535f11ed31c906af44c6b10a631fc6b004c289a4b066e3fcb472b5e61a1b6ce9d7cdd66d46cd347ed51c90cdff9e50f77a7b0c0ab1c69d46745d7620ee10388dd805807ced5a03a49e0dde810619279920e2c80438d38d2b9f467bd0a3a4644fbecdb8230eba9eab0561432e62d8721e60be66992dd7dc359df66cfd202018b7f2ee266991332b1b74df69ddfa235a0ca1d68dd27818b1ecd735f0b04dcc7e4eda3071565e0ed37a5250f596b64207ed4af3e6b501df35d7b3caaff012efbb9bdf5a41f25e93bd52077c925f7e7ca048c5dd184db1738f7e9a7f52c557d2fa26693640467709122afb2be6423a1b4ea6795ccc9f6e1ee869f51a813704be6178e18a145992baf98b96259946d265388ece38aab5212668212a64e34f01f91818ad1f653398ec9bfc403154732ea387882c385996b3d4362da325211436cb488e37bddcdd6fe81f056119bfd2371c621cfb26824a0a707b15c625e28f8c7e1963e62b205e01f6ae2e61a3816ad31af2d3a3c8ccda10425e62fd2bcfc6e959b21e2133dabe345d7000a8984244ebe35e348ce6e04dab91089baf0190c337a33c47529bb206f2678c029ebfac6668c0cfc81f4a65abc5a7a148436dcc8e5ca5de67e02c4f3d225a2bbdabe265da30f96d15c2bb04fc45ca50f123382b2d42a7c10533ae5a6bac7f74b738c715a82dd65fa5de00654913433d1fb62a57aacff00ca9b3e97a98771e907aab3765d6459fce00dce22f99175a9159640af50cedcae8dbc8a558cd6d7fa68e6efafc6e629be1ac22290bf53956742895a2b05c837b7d24daa99c1275e9df79e7d884776b13c1331a9da06461810d13b1b82da1784cf20b51beed6d77a663c58099a2fa484f951d2b0597ee772185a2201517e3b685701995acf3e85cfc59f9a00400fee19786f0bc2b979b637f035d4b81142b246e1ed40e3b578a0a34e99eaee3468b1e33bc3637d549740de3b0cd98c3cc80aa4f25c62432c15b6a953d3b14fc1ca9e76a5e7603cc54805d94b47970a5e9ea306fac77405bd86464697a58391728612486953988d862c83cdc36e93ced10719e17dc6ec87c45ace1f6cb7e85fe15babdcd88062ec0185290015ea66264eb1edc8fdd33265eb03bc7865633607889bd9a8860655d4e2028434c55374cd222f8d31fd64ec0c9bf1a005f4302324c2c71a3fe44de7d4822523b05432460ff5d07690fef4800851d5072c9bb706343a8dec1795dfaf677c5d6627450f608b2435487a652a74d5970e5070ee6075b25a20cda3fd24030a3b2be9ee1a234abb57ce6162d24f60e0e61e2a575eb4e83bac504d799cc3994949112d9936466b0ceb1c6fcec90baad6c974e3645f2cd41c9b6cda1cf736b881109d8fad3bc1581c68afa232bbb7d913bbb31a1c7250dfe1c206f1e29ee6075e4c21ae9e9d2c88564ae8c7132d0c622437494ce43aa952379a9f338ef66a0c4d365df8e1dcf072472c683d048f51ec84c6b7ea500a9ed16a9f960d66802b1dba79a30d1b6db5ac6b679e827b7520ceb1d47f70e484b9e4174b9bee0ddeb1d242708149afe1d4ad3fa70c25dc51118f37fb107f161b72f0ba191153d96486c051d5893d13bbe5eb30452195cbb57ca483a51b736941628dbfa286ed7db4224e84f31b55eb6e51fcf9cc8f60be14fab5216ce0ec52990121b4527d095f401cf34873c8329b7bb138d8c7a60527e1e427adbd11486684c74324b35445f28acf4518b21041a8668c4569b0f5f19dbef17265001d2629973d688d4fbd11dc16c1ca72387401a6a13ba939030fb4841e8b3bf3e074f3f032cc085a8217fb70568ce9e1916400fade57baa34843dc8f6319dae6d8a9407efa0bb918e4e56163dc9929e34770be3950591054fb42c7f42f35d5aa533a7a0a5f74e144f2a5f20b0b6f00f3b52a97c6b9b840aa967d0566f567c2aaeaa92f46d580276b35ea1bea8587159f74e23c476d1da2309463235c48181884f965de98feb5e1f829224d96bd69ce4301480a100cd1db738f85905889df4db529f0e6952daea77846df1574259fa18ad4cc8fd4fb7d42dff264dac04d15e8a7d6eaf5b004a2ee781980f227509115e389d04bfacb888ef24781714804646ff99ab47a6df65b3d540bb86204c0d6c1c97af3bcf5ff8c0646f95be23432334a16dfedf34385300aa8a7d5f3b0f8e90bb932b7515b09e04f4aa264ac39791b0d8c30d7eec523c9dcf2786a15905b307a4f4b9ba78e7d2dc079bd2c4dbc2b8430c61832cb6774713aadf7f546477a5583e820013e34bbed1050c4233530dbf74a51006f17aed9ce9a57a108143ad8b0bf005a9873b25876a57c31e9f13c0cfcc0b983ed620fd64a727bfe02fdeef8ea824445b1f69bd583063880d1102230fd2a7c1d5e291efc7d6977798661d85d6b84108bfe2555b57aa9225b78f0a7ea80edf53701eb30becfd5f6adf2ee8b68ac3af197dd8e747ac604c60c5241218c1081c15ba906f99fca4e6605e9027ccd34fd53f3c0908c880dafa03dfd5033a8349c7d05842aee01e539421bd93c20dd8e61d42a47e9e28fba102d4acacc32c1658464cf53c56297b93d174a340a1c2c20feee95e3e92ad443cce9cd5b03b36a1bd0351378450bc3aeb0523b89dad32b853b0fd1251cda08433c42201e953a04c0164a7c62485e185e498f4a5b5cca7e338cc4767c03649e20f4e30d960f4b141abd3154b24dce08104f3b0128de7676a48a88c0692b4ef8756d38c051c04b2a543b7656e8a3c0058d67c1fa62fe7bb760bad9797cf31db9a93bbff2c256ceba351785dd6608f8a32df9c080aa2b2eb2f08432fc17f9456444b6d51f68415a4605e7ec62caebcc636a9bb34e6ee323fbcc7d31b2cabc5a6ad08534a0d40e62507f13067177aabfc8dbb426ce11c4dff46d0c324815bab13fc51d4b21661c6b5be93f80a40ce44745e9d9776a332ed72f4ac7d12689530e75aaf5850bcf09f9eadcb3d754eb16f75d2d8241ad53bf9e1efe267ad88633b68eea947eda4f45826fe216871ea2c144911f350221f3c59945efaebbc8accb5e0e1c70a517975d996d61ddfc6bc451b3642768254283ff5d36a7c700915d984955a910744e17c0a3660480b3c6b066c858ee9247a994bb5e63bf15e5ad29091d08290a78e840fd34dc129549ba077ef7e1cd59d5a19698114f8e11c7869fbc4d8804b52f60c391c25244923aa029f8d6815c255bd51a041a7cad2142b812205f77d4a71461effcd04af2ede323a862c8da036b46ae8f8dde5d84ead3ac20b3d73a1166a44656bce338a62effbef34b533e6bb222b87793d174bdc4f6fd6c052951336a7b9868407fade6dbccdcab211a30ed807c6d62c49844a05629062492ea5fc328e6c2c5260a0d3d5af70730726254116cb047c18ea76fe4f4e6611acb7eb83938927fddec26f90242eab913bde00a7fbd6ad224506338e447cb988f3d7aed1e0ffb0a12f13ad3ee1a348cc57207e671190896fbc8604236c5251722675380da158d0c14d3da30495750dce61d3e5aae0625f0c845331e54e39f5754b79cf605ffb4f054126990bc70cc33c64e17e97efb2f9a0a55302fb729a6f396ccabcf2a052f51412b8d67affd032c165319157c6e91dd42870bf8e60db8567905247eaefc48a97c8d9a47ac62921036eab6611ed7094501491afc5a16600a7c0f8b771d1b9d5356c734933a27f59aa863744eeedad26bb719e1bc9bca1a7a003a456aed0999f97056d0ecc1e3aa35fb6bd75164c0a9abe487e4bc139f644fb613e6aca73cdb0649baf3b6ebfc2c5ca05253fb095eeba00a01b87d6a1cc9d5fe2af3cec42bbd045372118400f7f87927b57ebe44dc14c2a815c17307a8a7c758fdd143dc6ccc7e2dfabed6b95dab35f203cc0dcfeea19e3f32942f64f9aa7e56fb13ae586685ce29e350116d9390fdbfdba08bd2fd3e9d4ff6a5251a563e6568a13f50b0bf859ee79a79d6a640565ac19ba09b269e384a4ac078d68064d0371e9ec8ed7dbe284ad7ae9098fbda77b7a7c250de03382b1fc03e93c64f9c0c4dd93224d728090a5c8a8e38dac6c8519ee2fe15a7215183a840af6a66c0724f342909f7a04826886e60b7e71e9fa0909af39d8388e970de5e3cb1715a9b6e1564ae9495db467d4eeb0aca0fc6fee9a1266a2f0f15d42ca7bc24e35cf42915fb69ba50a3eabb93ba4cd92327766d09ffbbb7313cc069db5c3c899361d601d07daddccc96411ff0571e6c51d2af629828d55b32810b13137879eb604472be43f8cb9676e180dc2991da34e475d457faa90dd6a17068884b98debad8595ca6d7092d67de0a2c7896170ab349a587e5d7fccfaa0c8f6b020a19e5884a34f664003b5de16094a68dcc432a77ffd62c7486908555e2227548d58828d4544bc26e65ebd763ad05818432a2a3e3857c548cad00e96ab0fe39a51470131f8522533e6eb7248f21d13fe47fb21196692c72b6a1ca464907770aaf6d5e3eca3b4d2b4c8119cfc45d8c4436fa0dfe01195b195b1b59367144017ad0469ef6850520bd21537023a3ceab30e447f2c3a4148cbb02504a2483f5320cb016dee4a061418b554c76da9de3928884d01d0cfff935ca4506f9baf1998d32b7748a93dcee240840d28a5f133ae6bd9128e9248525eae99ba5f4443abf778f6ed62e5e7afa4cd68c8c272bb4331c3281b8f3b4d439107b6e93d67adfc595653ec236df0b14205880efd9caf17ab7a9df16a9385d914b023676fca9514a4b66bfbf30801dca4310d6641ea74b602d6621b8962991ccff109bc5f36a1fcc2e066a23a7dc239b3981e59f625b32820209c2152703014ab11906e73727cbb991c6b696095dacf5584e46e84151376eb9f768c2f85f3ca8e5adf071548cc5913b2a2d9cd18f2a6733b862d53823da74d9d16e287688a4562121f0fac7e3adf17e93479e9ceb1c7f6062d1ecb34d8c32d60a4aec2e29c8d0d82770ca0dd6d548c0b49d11d7ec039c42d01ca55f28dd37231497547bbd1ab79f21088582d0ec05c5e086acff2c604c7f829b8578604dd06582cc180bbd3a68ca9110a3e36c42c6e2b9acb69f06c31e5afce703bb6e4ecd01d7719d4a9478630f1a31bb9bf389faab9277c51415ac70899177b674bd505b8c84f06ab4fd8544c10ee4231921121f852d606f1ad37ce17ff2d60450d8132a6a0de0f6e732c17c74f19070e75f8ba403ccff0affbab4ffa2937a73bc38d7a82ee4cbc83deebd78bf64df2b93195736ac03bc2f5f56050995f5ed9b337a4e634fac1955358be9c7f4db18c988e8f535e2642052a61fbdcdce9ca7d142f6c7ca50c642346a94d6f8b9c6e5c14538f6205b60b40b50827f8ab0ea21bc6748d46bb6c5dedc5983f57972aabea964a3ca945b8bffb00b28aaeee180f3b31ceb04c5f62d57b36ee3c5d8b4091bf84393f2f077385bf7226cc058d4d3866bd047d957a35f4560273ee884f26486247e93ffd34308612732e960670f64623d2e09b29f22ee10592effae0cc24f75b4822e519b237e97f6b9090b77f5a60fbd828b310b195c5104d2a0b6de882c633eeabd98d6bd0d78bc2156122a3c3af7537a56c529db2c7009aebc7388c87de71a04ec261454378c0e185b14fc2775a19571f6ff8a0cc105ce3fcd648a17c679dc8d1489b2ad7f3a52ea82a44c5bf8a6fa05e630aa12cc7ac8f23e1a50da98840cdfd144501d571c21246720b95e367007b29f18e871b157906299058ba566ae1179ace66b28519a0f62631ac182b18534e49c18e3cdf2249afd68a688ecb35080e701e07242f14c64011102d38dfc6f082877a11a7c015a7f4f178dd734f103d1a46aa2f411b89bc5acfb698dc46986080a9c420b00816183c4401c0502c2309a3e61de6f091a10baa28cdf4eca9b72aaf7749c23ffd4f26f095ce180ca897f311161d3419d8843a9ae4fa4a4f504ad676bbaeff3ce9e55876ad86ed910c9484cc9f5222a43959d190cae7a1ef837aed3f3b9edf8f1203363754d247c6a041423c4966b77afc4859f6a33c01b38a6ff671c0bf6b21c1cf499b515a2f93abc7b7c9dbfefc81697b593337a07383ac50797312b9aad83d71180b6ec5ace0774e6bdc1fc5f7a2c71759af4ebcfd473345feaff935a59dd0122ced71bcc7954afde5dbdb60b2c66047e1d2b038aae765780e8c3ddb6259c0da0baa23e6879b6dfcad30d87a35d37a317a0424bb7f4c8b0e3072a552ebf256f03fab4cecf4d828744b41deb986b35efdabad74ed865cec32edc9fb434852da7d5057b4751635c28d4778b5c5af4c54d4fd356678c600d20accfa05557f5f94a8c415222af69a856e2a3c2447b888a3def704c301472183be556b8c319a03cb9a254f60b29bf0b7407cf4f4e7a74d95422182523312a548771085577ea024c97afa6c34b70d1da12ac30aed4c868570290318ddb32e76695d86b030e59aacd471ccd467de550b8b5589e5d71f5c177dba262c2a2ca37a2e973e55dd0e8f8235a722eec1d17aa0bce855ed7a0732eb041e112803447a9bdf4ec0da27a0878e34438424093884c67e0cb08a9ead0fe94d7c4c722ea3babfc3a995a9d6448bb8186e7add09ba7c6417e921240ab8fbf99ffd607473f26bd023d14428b2a1a1e82b4f8d8287006962d0a6302387d1ff0344c9d4949cd995b547ed55c18260d406b30f44794cb253a7f16c65efdda021ef8207303c6fff4156772651db102829faf9d5282b2077421dc26249f0d4cc6ba5a2dffdd3b60d779bfba4bfdd22a2aaac45cac000caf73fab8bb1638f33fee50deb7ac1c137aa3d6c1a8e273181755e05df15946114db513993803b32c4dd9610a700076dbb7f9db11e0c113ef54a4deb0ee02cb4c4cb81b023f85a434d1286941c99544109349e524d48066c46c980471b501162a36ed6f6834147289744bd82946b32a4eb704837f0678d233b99fe024e8fcad4796d58f4fb828a4b6a1c44c355a128fe27dba4494e942fcb9d63cf02efc5df710e6f0f92d3e3ac128e42223da761bfb8861eb96eb1f573cc34cefc314619d8a0291d04b9528d34e7ca5d5fdad4d37d38d0e1908f5fb2e18fc8838c769bb43ecb941f3e4fc1a8aa31e71504812321ede7cdcb2f95a1f4017a212987b835be9959151cc53d685b9757ae14171adb70942d4485a066bfe35cf60669f6e15d5e6fb275bda26c8fcf82c3e4ffa38c45ebfc73ffb7ebec01a6796c41ebe0d85bbc4a3e7ba9dcc37e2cf3dc5481adc1a9b7ac1fc408160daf66e04298564d857701b164f1887b297c99720ac5403fa04fff2c9b5c202bb3104a1ae2d45345d0f9552d8f9d048888d33e88b5fee460117ee9054d8fa831c56d7baeb2bd89d1a128df452449 +MD = d8101ed4097b4bde7abbc16cd854e4c122460dbbabf08a9f56f4f2b882f59b00 + +Len = 42488 +Msg = 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 +MD = 9570f18459f97be85bfc8fca837e0891ef248ba6295119679280a136d60e57f2 + +Len = 43280 +Msg = 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 +MD = 8ff4c479d1230d8dc53493395e89ca712533b80e1b97cb5af448e0e78fab0f7a + +Len = 44072 +Msg = 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 +MD = c4558c7ec68df61d6bb65238397d49cc320a8c213f7bffdd4a397552d83ec20e + +Len = 44864 +Msg = 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 +MD = 7ebc665ab5e5a1babbbae9e86bd00a09bfe68c4ca91b9f0da092c853c7732c3f + +Len = 45656 +Msg = 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 +MD = cecddb12b508e6cddcf3e96635abec8bc6031d588b21a4a4859cbdd79aaee47a + +Len = 46448 +Msg = 5ab7074f7be12272f9f47fd8900dd823ef716b676974502eed9a0bc038fb5ea149ec615a15dbd47c7d7bb3e37d220b38a66f0db9ce2f603d0681bc72cc39b56a8283d4561fc9ec9125d6abe0d33b70f89bf15c40d641acd9b7e146dc7d6091e2edc38aca007115b6d94c9057f921ae6bb6428383e971db0ae800d083b4379c1273f6ab3e209bf5f581268ad0599c6e99e0a9a80b708896d8812883f1d7877b01fa625e3ae711345505adc0d45a73588bff6df45ed14f844c6a9f87ad5018d9b76b51cc47bd9a7bdf4d265bea64701348fcd78e06768b4e6d8bad033f85b25c3daf091dec0afd729941dc829bdf5948d8c02f9e8bc5079b44cc9c1f30e01dac9aacd378b23603c08dca165e6e33f79e4432bd4e73288a14d716b20506c72072d64cf60520a9740dc3ce1b17ebc912be9339c8c44806db61304f39da4ca48556fa76bceebecb1803413634d49a07724fcdbf9a2891c7c329576177c987de12ff0d126b581405b64811eba9bd0456defafbab79a3d7d20a145232b5f741dd901617074c6dabbd18843bd4c2fcb01f1f6723e5ae5da19178cc2bac3a8f0109c642213fa7550a5c0460c5d8c7b626c8fd3d5054807d776bd4f6eab650b750ca7e2c31a1c438b94b4383b9e1ff16efbb402587e2392be1c8e83d95373d97b5887e7c5215ea3d41f19d971ed6b341925eb0c6d276209168107a4636194a59b8ab8fd98983628c29b5d941fd9e2b62971b15c938f87cd493ac53bcd443bf22e19b79ebe0d3754ef901c12b5d23af9f875936d5c251961feb023b45789de41db9c0045b5eed68ab3a3c1bfd464c8720e97fdc937667b698f77bfa89290f006fc783f8d10bba86ca73cdb05ec101fa0e45f7cfaa5e2323673f7f5732ef815d43934a1cf4f02016d42c1e48f7d42a51912428d7c3826d27b54b771be5d2db41bfa67e396d14085ff0ed96ab708ab0d5d00c7abc86e82e08aaa4c90e4cdb05f50b878817e3805baa473f9da070e879cbf48855459a9a4c0f6dd1dff80f11e7c150bece7eff3aff3f01a99bf09ff86e7e241d213ca8a0b184275a20a1d67d6aecb6d4ba36694cde6645b4f863a7c1773589554667570043afffc8f3d1482574c06450b306c8bddf673be61dc12d4b7d374bb72c8e50c4ecd71ea1c24f0d13ee8383ba20b8c596e9890cca70d2dc9f66cd91cb3c7b3bf49346ab70f4e4ce4fc17e3a9b6b1207dee616e0e55a5e59c41c3f831adcf5bf962042cfbaf15833dfd3f9b27afbdd379dbd54dec1442c4fc285d54b2b75c384b47a14b2092073e3cd0e3c12df38e0fcdc568c2fe5940564a28bd70e8670ae33558b047be4ebfc8721598e83528ae5ffa29905fad9b4b1406b158cf7b4337e74823a5953d4b9bdc6e19b392d5c59b2e7f76e0968260af88c250a3d2b3c28fbee426f5d6160f37c4917be8337840d115de3bddea15300a2f0d85432d5a6b6ec4a9d1256ce10ff02b7caa9b5ca530ec7096f6ecdcce8fc76138ddab31b7b441b2f9b0c8dc16c4617b90344160d50c59f92a2691e126d683d9e4c840825423c4e4645434a63fd3082f7c977f029039860a18596199a6babbf381b3a781c83054e37a2a0d5db4a260d18242a8945f4f0d1dd1edd068d6a2dc48a04e44c28c707e3a9ba0b7552db8e7ec51c452b8aac36bcef77272c12f056143c0e6acd7094aad444966d73f039d19ea5bab01c20b2d0e77e985ad452878e76f541b4401d7556ebb13dac17dceb5835610554a42e8e281a3387604674b63db45da6abf056ef73ee98b7b2a93f798a0ba006170ddcc9a41fb64e1fcaa106cb941d443524448c69a6a00d6571406ccee70bc3e29d54eaaebdaef581a801fda0dfdd243b230fd3a0db7246afb7084b8e9349469e9ebb79adbbc3826d27bb25245c444ca636de4c8155b66a77c2be9e31d5039731563cfe09e29effca90f806c0d5fbc65ca5d98072db1382a5db8bee1f76e1bc850efc0229fae773822bdf26da10aa9a47b82af6dc373195204a97c1bf3e8abf800d260d77cb45e77c40990fdcd7f8ce4eb7f636282fb9abd25709a27bf4a7a70c9de0a55a1c6162a0174d492cf08d6c58e968c9bc8c53cca24a0a16ba62df7d100452543ab6e3ecd6f8245a3423127b4f97a5360215a601786ac1a7e54edb48738ba6a18062728d062a46cc5a3a2f041a09d80560945b513c0057dc628143101f7a011492e6b64e18f6da2708fb8b0ea18727bf40cf19c5d654f33d9ac3bedefb198d36d90a5936f4a408f1a530cfa1cc59baeb099089642faebe53f5dbf4b9efaf728ebd98004e837cfab4999fa2c583c6ba11239d53362d56e0a5dc938ea9e386d8a5a756559dabc5d5f74b11ad83ae174fbaf6be1e43b99380bcb5b134b6bfe4e601fd0e002b55c9c443254d98e23595a06deabd9294bcafc61ee9fe8de96b12c42c2886a9006aceed1f8e1d0aeb0085d6b2676158301cf0db55e1424249d0589bae9187f725d01d7813ee47aba5f7321811d571181fc39fe7e90445faded4fd930d9fd892a171fe8ea7ae94241803e38f139cb6796a97031160b9ce5eb1604bd3d3b943237c33b8576434cc1d4c0adf633f24f82418826682446aa716c95d888487498e52be0095fad1e9b73d4af56fbb1dd5fec1316b0e621c7e96c92fb1fdcdb2b682c670bfdb9f77351c2d19addbbf361892f7be3944d8715d641fe946f2d7db68e7289a58d370dc81c595c1196b9911537a6ec5d6500cca6fd9c20102afc98ac7851f42b2c5928a33781b4b20676e37f07fcf51297a27af1bbc577ecf7bcc483b235472b7f93009b5fe6abeac16692e5569c2671a0a51a8ccd7896994a0089b2c8b6e314eb670df6d1f2822a4c1af80ec00ee119147b13ee7f0fdc93964a40e028316885f467a96c5a2fe7fefb06bb41b0cfc56767b70f8d5d05ea6a510c92625d4f47dd3ef77b6235193de772bc3534c54933fb1ecb55ffe3f5209c2eb9e6dfd46af1b90fa8fc5f1f29046237adfe4e6a15cd22be2a9f9ca0481f9773f4c6af3a0f0677fafe94d964e9cc0dbe4e8ef51bbff19caa77451a2e9957eac52faa56dac5e6b8855aed57a2d605387b206fdf46a231c77823dececb433a0496ed1a7d430a22e943505e605578307102d6095397670e21bba2c54112e056837d9f9f791f563b8899817079f93aee45c9a1f3f87a690739c986b107a1fb3dd5cdb991d0ac34a1251c40cc0b0aa89f354446a8347c328d7e4641fa88e4fe507a1bed9a2a961ff43d2020b99a065bb3be0726aeadf95e316d96673a4b48542efeec8e20dd5992953f6993c1bd78aedc4e96b47fbb8e4663965e58d8d568b729c2c43dce6f531704ba3d3c8cdbee1c6975578283f3a785c486f2b95ebdb271e164175efb673f27e32c3f6d737bb34efbb0ee1353ccd196b49de7eb444ab22ee6617a74103b6a4f8103d4b90e237490f38faee987cda8e3b469c2711222e4389939520fd58260f89edf91a1c559be9cf1703e77687c7a07546906dd60ccc5498a5a22a493a2bfad7d2dfaba3184ddcd75f1013fae3fe17c152a29a288bed1bc2a5280b4d332d2f8ac6d7454cb4b7eace1808bb491ae5bbc671baf53126f962b09a0e0c33ca94744bd2c9313fb03fdb5d4bd5278eb4e6532dabc0c5196558ef098c3c752088c892c2fd9db8a5944f762bff5e9fef3768a99d089c5308d0728a7684998e3ef33151964f3b20a6e94e84e13c8b6b942dd383bf9137e725f0affd9f880f9eb59538786fd08bb16936a4cd260a44d2a61d8eaa3b4d77c8984c780f2ba385efadf643d1f78976b51703b819a372711d4d9003e6b84545408a6c3387c3dae4c74d9cbc22d381e272d7d9f430ff7bfa95b00d99fede7f8a9523d94a2e0e37126fbd110934aec0b931d23ebfdae32ec77ff81cb8bc57052c108a1a23ccb5c1f82f26dd94cf2e4fe13a2fbd81def791c1264c45c8e6c8df15f9e8b728295f807e4eb086c3bafb3544d517dba305e2afced1d5113145dc132b986439bf0cb57d8d16829600bfbe7ac84ab2228b174d8dd7c7bb075ca139ab58342727523e5ebf0bcdc595b2a41f2757e02719a2dcdf35c55125b0afc287ae821758094888034ee2bca0094032c543d8e19f48501b41ae7eb73b92936f6f259387206809b04c33f82b3c7c143159d632934138fe9e1a00ec4127377172981772cda7cafd7ee0753762c075956982e94f3f3670122b1334f6370e27af91ac8c073114ba8cbc681c85a8557d2ba2e982162ca578f68bd45083e01be8b795508d3afa8fbd1e308b31cc47231b3ea336ac6fa4b7d91086045f7d857304ef452e20f372425d1ba3f2bbf38551d73635106c42ed941acae34b66cb6e4103c16bee501adf5321ebde45c2e2ab08397c201fcc775063c38b6c536f55e3ab6b94cd3822978aea91f6a62b4f81006fca762c0cd3f7154d5dbae7c181032cd9c6cf35b2a052bb3036a4c64c68b8ceaf118d207f89a884796fc11d40a5bd90f49bdc6907d134ba4c975e0451186f5bef9629c61ff773e50f8107d676e26b5824732231ddbd23ce673d8a2ae2648ef158e2b3e49524407f391bf4d90b40f5cd90d50957dd6d0840a9ae92fea656fdd6127c91438819f89b1dc6f0f0a8c743346149f9a1aee8cc583974dc4946f5a45244ec2daba1dc8181e30963e1f5803dd8be575ad9f836555e4017d2d269496baf16bbeee48877c579b46db5759972cc00d08894c565608d9ae51dda63b85b3b33b1703bb5e4f1abcbb8794e743da5d6f3bf630f2e9b6d5b5451105ec2db32fa283d937ee75e531abe16b597a6882244fab27134db4265a6d3ab77c5b879d692d4e1ad1e429da4fc9bf7a9f6d323f0ff5dd1386996035158601cdb770d3a50e980c645838e4aec38aa82ded4c2b517ee644542172586385843ccc3dc89c8a7e97314e315930c34b633e0db9a3ce7a0f8573617a75172228ec4e2b75cf4c8e379f7f20f3c198c835e7e3828ae096192077dcb3d7fe26f17e22b873f5f15e50d8052885260e771e118d3b34e7af1caf5021f2d3e09a027203cbfe2e44db5c52ce8cdff33e9c66456cc7979d464bccad2d08584a2ac533f4484c91c2d8e9c104898b07f3b3f7e0deb62b9b142d6310b305bf7f7efcfc2628ca2915ca38a926f6a78432ff0cad713a7c2db8321371932178abdaeafdcb636fe7e5fcbcca95f899870ce38dcf2991f93d42718f7ef3cea8f451ed2693af763a5017b913354ca08dc6898c287208bd8b581e4984f6662d9a174638ba6514d9286112cd55df19d913e48eaf478ba76e717af5c2bae0353a75400d500ed89806bab97bcbfd4ea9ecfc5f80cf6372a22f3c147d5f79e30d6fdb1cfb95ac64a57951b7c71781fa59667796046f14cd657a5b9329827a655b583beca5ac0b9fc9bb9dea69428c68c4c046269e00d4028dda50956ede14fd8b6e085d9ff5b4f07147efdff6cf651058a4c89f9217199867b9ab99d1b4d1f22a2bc0ee5ef530fd38a8d7f6e430b497a16e7f5f95246e25afb2ccfee6c95a09b40c15fd473cf82c8c58d6cda5f8f3652b97eae52bbb3a00b2304553026de5aab5a958290d3f72e4f8c27cc2d09a99ef53bb9bdeaa4e15d01bcca524d9253d4bbb6e07fff57f49dcea903a84e89810bcb643f29ab55f7a0a48d26cf2cf81996311e4b5c0b47ee57afe2c807252740043cfcb9fa7c151ef25c60bed3b5a05b2877577d239bea0ce258001ef29a2b0e12b0cace39442e7eda91fb3d66d0d13f13f32c1fdc968977c833cbaf7095dc12bb8f9727edede63ee0ab27499065d5edde0f64d98de66c5791a60a2089fe84758a412b6b1e5e86878c12ac8a5a5cf28e1132c6524072dbd3c31b871c45bd695e042e4e43d47f5580672e52aacb9d714a34c31c33fc221e13e8f90849adbad3f6b3bec85718389d52f868e14eec119a48d02c2c23cade7c4087a8564fc8de0c651e5a604ef171a424c7262020c39eb4b16cd4bfcbb18e3f82299039d79f0f5bd2cd68e0d16812b41f5dd1d8c85b2d09ac91239cd3b91aad00551978893836076549520e878403136a41d2d1eeb9a7df62c6818de2ea6a0fe393abdd0c9d3c5948197eb2194d2c092ffb8fd339e7f27ffb935658a04d67ac526bae2e09d60799a0c556962ecb76e0931472a651ecf8319e800ac6b7e9f7ce76668a3427e9810f98d640816f07c7dec013e211dfd09f3c7316059fccc603bb770ba7b70fe0910255d3a63a8308094dde8047de8b9bd1eaa3dcb0ab8aed74bc7ce36d7f68c21ebc0244ef8a14d6227314e408d3fc567581565b71b196653019ad754553db981283c5b18339c77afc998bc68fb9db09734ab319b17b9b36211a334995fc106954a0c6a3ca0f46fb7d066bae4357cfbab38de3a0d9cf3f692e0736e7c643ae3dcc5b2ea22cd439618f04db248c7781731c920e784f762a053e27ddd841ee5e1d62fb2534114f47b519d903b1d2df983b98a05a277d3805123bc351a36dc5c70ffecad2e3e14919fe02ce0cdc7d58bd1b0f00f237c9dc78990c23bad0b192921e880e5e36048a5744342b1e2ef5aa981967fbfc309d2c2aa0998f3fe7771b664fe810f1b5e2daa88f9638602ea39dd04089d7a19860eec432ca4f08712629ecac0618b1e9e301b4e8103dfb64edf90e955ddc08f97aebed5487aa3ef62584cb3cca6dc95970c624568a8117583c85f922cb545ada53eb4e10b8ea09fcdef4ac071d595f8eeff2a0e2ec4dda93f90a3aeebc85bec453b68f6d4555900db8413716e5229c0eca4dcf931ee96f9c8a50780116b85d3ee21357741634fcb01b3213700c11a763679f5a71099dfcfb591f5c64c3365ed068cb4e2b13ce746e6f91e91d786ea91430b0e88493b1aa39cc3f8e1ea944ea024da61d9c256d21cd1d2460261381c9aa8b4822d5a56ca0dd4d77b537b22d295df96c6ccf32572b578bb42192c39130ace22eb06b2817076f439179b8c5374268d4e5e2ca23d5b9942208d36972e805a29c2b394e02fa0677165384a8c9ac5eab47d92897e12ff30b4aea1fb407cc7115210765871d5dc67e2d867b0fa8d2a4afb80fe63e53ad02446c20ad7a6a869c8cd98ade1d5f886e0bf2f209f549f23dfb9050c3c560970ec7ee7324c3835ead8f2c7b4918b2c227a7cc5ed4639453501838646736f2343e1d3aab2d973a9bcca682a45181fd5519d923938460713f068c16137b98f0cdbbcdb6906fff7787235a43cb9c5f28876b29605ac2f5c8fc87e19425a7f441aaad5fcce993022268d732d7b9d2ba1aa1461fe979362981d3fa9e19619251cf133b5be38040a9238713b7a6369c9abdead14427b88704840c874c0c90e5b781508d4a621b1ffb622cfd6f190aa208f8ac351f82e15d8eb9ef5872d77a472f3fa8ccb4b383d700c79fbde496fc8b0bb32d993963ba62d009c49298e1e761bff165201f3d8011c03b277c9e86d5ffacd6b72618300d3cd15ad26047929fdb727fcdb01568da7544a40d6224525da8f24a90034653a093999662e80552695c4dd229a51d9c58aa93ec9a96fd605c2be5f5005a4b323b1031a3bc525d890f8c5ad0c026c041c359b5f91341b41a9a338dc05150ad37a85aa06b28c7d49f5714a062dc5c84bfe329b3b5c38acee7de66f393c90ff6c8ae1aeed4ee6ff4fc0a9c2771c36ff47f80c39406f19ad52ef26c1e57b2bfad4f14f824c855714409f0cbf8e3be8695e762ce60d6e49851599cee16f252875b33a39b492ea6f54c2cd04a1aa215c9f16050f31f0ce5adc8cfa594e44ef29087dc23ac65ed2a2595ce73c0959410618f5314dada903c01c4f8d5058f52d902b9b25cd281ef2627a658a2d672a3f776f726742a994a31bbcc3cf3ea1fe551047a1d15b6a31be52307302334b8b6112fb243398c62220c046903c9ea9df1a0be50851800d659ae4241c0be816fb4a7b547102ba73f00140321b51dae105d0f59c6522b571f91c8abdb6f3d669f8701303ef7112437cc92e17fbab8dd8011e6fd61ec176388ab7c885da4668a511667c7205eb4aa526ecec5087a6220f5f46dd1abbba3cd189012fe50c903968d4921a273afdde299ce10d8465ee21f78f0ecfe2b28993dd726d2373b45da31590876eac251527313d4a041c0cc028110ecaaab6999bf5ace56035ba680b404bf3bb0c792acdc07c969c529fe2d88efc6d1f001ee77dfcd0409ef9119e258b6c6ca15606d2842 +MD = 03deb53fbacc9e3701311efbff2ee0566c27355b6f30a22848a5b8618f6c0d63 + +Len = 47240 +Msg = 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 +MD = 0b6180f72608560023802ef42e0d80f862759a2a6b107667d7819e07bef00b08 + +Len = 48032 +Msg = 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 +MD = 71b950c0085388ddf90444c0918d72aa700319e789441fcd2da539c12a32ee19 + +Len = 48824 +Msg = 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 +MD = d5ebd0d3d544e46023979d06b666f35758b69628d95abb808fa65f51f03b81bf + +Len = 49616 +Msg = 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 +MD = 740e25c81e510d27735af90e3f8091596092c8136edb60f4df910f7204c289d5 + +Len = 50408 +Msg = 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 +MD = 90df9cc3a3b904415331eba9cd52750c2c5cb73cb91b42caca7eee3788fc2b30 + +Len = 51200 +Msg = 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 +MD = 33b6229592ca719e4e46f35b287617fedadd3b7c38be3c8c1c9f446d2d9085b3 + diff --git a/guest-libs/sha2/tests/test_vectors/SHA256ShortMsg.rsp b/guest-libs/sha2/tests/test_vectors/SHA256ShortMsg.rsp new file mode 100644 index 0000000000..ddcfefbd04 --- /dev/null +++ b/guest-libs/sha2/tests/test_vectors/SHA256ShortMsg.rsp @@ -0,0 +1,267 @@ +# CAVS 11.0 +# "SHA-256 ShortMsg" information +# SHA-256 tests are configured for BYTE oriented implementations +# Generated on Tue Mar 15 08:23:38 2011 + +[L = 32] + +Len = 0 +Msg = 00 +MD = e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 + +Len = 8 +Msg = d3 +MD = 28969cdfa74a12c82f3bad960b0b000aca2ac329deea5c2328ebc6f2ba9802c1 + +Len = 16 +Msg = 11af +MD = 5ca7133fa735326081558ac312c620eeca9970d1e70a4b95533d956f072d1f98 + +Len = 24 +Msg = b4190e +MD = dff2e73091f6c05e528896c4c831b9448653dc2ff043528f6769437bc7b975c2 + +Len = 32 +Msg = 74ba2521 +MD = b16aa56be3880d18cd41e68384cf1ec8c17680c45a02b1575dc1518923ae8b0e + +Len = 40 +Msg = c299209682 +MD = f0887fe961c9cd3beab957e8222494abb969b1ce4c6557976df8b0f6d20e9166 + +Len = 48 +Msg = e1dc724d5621 +MD = eca0a060b489636225b4fa64d267dabbe44273067ac679f20820bddc6b6a90ac + +Len = 56 +Msg = 06e076f5a442d5 +MD = 3fd877e27450e6bbd5d74bb82f9870c64c66e109418baa8e6bbcff355e287926 + +Len = 64 +Msg = 5738c929c4f4ccb6 +MD = 963bb88f27f512777aab6c8b1a02c70ec0ad651d428f870036e1917120fb48bf + +Len = 72 +Msg = 3334c58075d3f4139e +MD = 078da3d77ed43bd3037a433fd0341855023793f9afd08b4b08ea1e5597ceef20 + +Len = 80 +Msg = 74cb9381d89f5aa73368 +MD = 73d6fad1caaa75b43b21733561fd3958bdc555194a037c2addec19dc2d7a52bd + +Len = 88 +Msg = 76ed24a0f40a41221ebfcf +MD = 044cef802901932e46dc46b2545e6c99c0fc323a0ed99b081bda4216857f38ac + +Len = 96 +Msg = 9baf69cba317f422fe26a9a0 +MD = fe56287cd657e4afc50dba7a3a54c2a6324b886becdcd1fae473b769e551a09b + +Len = 104 +Msg = 68511cdb2dbbf3530d7fb61cbc +MD = af53430466715e99a602fc9f5945719b04dd24267e6a98471f7a7869bd3b4313 + +Len = 112 +Msg = af397a8b8dd73ab702ce8e53aa9f +MD = d189498a3463b18e846b8ab1b41583b0b7efc789dad8a7fb885bbf8fb5b45c5c + +Len = 120 +Msg = 294af4802e5e925eb1c6cc9c724f09 +MD = dcbaf335360de853b9cddfdafb90fa75567d0d3d58af8db9d764113aef570125 + +Len = 128 +Msg = 0a27847cdc98bd6f62220b046edd762b +MD = 80c25ec1600587e7f28b18b1b18e3cdc89928e39cab3bc25e4d4a4c139bcedc4 + +Len = 136 +Msg = 1b503fb9a73b16ada3fcf1042623ae7610 +MD = d5c30315f72ed05fe519a1bf75ab5fd0ffec5ac1acb0daf66b6b769598594509 + +Len = 144 +Msg = 59eb45bbbeb054b0b97334d53580ce03f699 +MD = 32c38c54189f2357e96bd77eb00c2b9c341ebebacc2945f97804f59a93238288 + +Len = 152 +Msg = 58e5a3259cb0b6d12c83f723379e35fd298b60 +MD = 9b5b37816de8fcdf3ec10b745428708df8f391c550ea6746b2cafe019c2b6ace + +Len = 160 +Msg = c1ef39cee58e78f6fcdc12e058b7f902acd1a93b +MD = 6dd52b0d8b48cc8146cebd0216fbf5f6ef7eeafc0ff2ff9d1422d6345555a142 + +Len = 168 +Msg = 9cab7d7dcaec98cb3ac6c64dd5d4470d0b103a810c +MD = 44d34809fc60d1fcafa7f37b794d1d3a765dd0d23194ebbe340f013f0c39b613 + +Len = 176 +Msg = ea157c02ebaf1b22de221b53f2353936d2359d1e1c97 +MD = 9df5c16a3f580406f07d96149303d8c408869b32053b726cf3defd241e484957 + +Len = 184 +Msg = da999bc1f9c7acff32828a73e672d0a492f6ee895c6867 +MD = 672b54e43f41ee77584bdf8bf854d97b6252c918f7ea2d26bc4097ea53a88f10 + +Len = 192 +Msg = 47991301156d1d977c0338efbcad41004133aefbca6bcf7e +MD = feeb4b2b59fec8fdb1e55194a493d8c871757b5723675e93d3ac034b380b7fc9 + +Len = 200 +Msg = 2e7ea84da4bc4d7cfb463e3f2c8647057afff3fbececa1d200 +MD = 76e3acbc718836f2df8ad2d0d2d76f0cfa5fea0986be918f10bcee730df441b9 + +Len = 208 +Msg = 47c770eb4549b6eff6381d62e9beb464cd98d341cc1c09981a7a +MD = 6733809c73e53666c735b3bd3daf87ebc77c72756150a616a194108d71231272 + +Len = 216 +Msg = ac4c26d8b43b8579d8f61c9807026e83e9b586e1159bd43b851937 +MD = 0e6e3c143c3a5f7f38505ed6adc9b48c18edf6dedf11635f6e8f9ac73c39fe9e + +Len = 224 +Msg = 0777fc1e1ca47304c2e265692838109e26aab9e5c4ae4e8600df4b1f +MD = ffb4fc03e054f8ecbc31470fc023bedcd4a406b9dd56c71da1b660dcc4842c65 + +Len = 232 +Msg = 1a57251c431d4e6c2e06d65246a296915071a531425ecf255989422a66 +MD = c644612cd326b38b1c6813b1daded34448805aef317c35f548dfb4a0d74b8106 + +Len = 240 +Msg = 9b245fdad9baeb890d9c0d0eff816efb4ca138610bc7d78cb1a801ed3273 +MD = c0e29eeeb0d3a7707947e623cdc7d1899adc70dd7861205ea5e5813954fb7957 + +Len = 248 +Msg = 95a765809caf30ada90ad6d61c2b4b30250df0a7ce23b7753c9187f4319ce2 +MD = a4139b74b102cf1e2fce229a6cd84c87501f50afa4c80feacf7d8cf5ed94f042 + +Len = 256 +Msg = 09fc1accc230a205e4a208e64a8f204291f581a12756392da4b8c0cf5ef02b95 +MD = 4f44c1c7fbebb6f9601829f3897bfd650c56fa07844be76489076356ac1886a4 + +Len = 264 +Msg = 0546f7b8682b5b95fd32385faf25854cb3f7b40cc8fa229fbd52b16934aab388a7 +MD = b31ad3cd02b10db282b3576c059b746fb24ca6f09fef69402dc90ece7421cbb7 + +Len = 272 +Msg = b12db4a1025529b3b7b1e45c6dbc7baa8897a0576e66f64bf3f8236113a6276ee77d +MD = 1c38bf6bbfd32292d67d1d651fd9d5b623b6ec1e854406223f51d0df46968712 + +Len = 280 +Msg = e68cb6d8c1866c0a71e7313f83dc11a5809cf5cfbeed1a587ce9c2c92e022abc1644bb +MD = c2684c0dbb85c232b6da4fb5147dd0624429ec7e657991edd95eda37a587269e + +Len = 288 +Msg = 4e3d8ac36d61d9e51480831155b253b37969fe7ef49db3b39926f3a00b69a36774366000 +MD = bf9d5e5b5393053f055b380baed7e792ae85ad37c0ada5fd4519542ccc461cf3 + +Len = 296 +Msg = 03b264be51e4b941864f9b70b4c958f5355aac294b4b87cb037f11f85f07eb57b3f0b89550 +MD = d1f8bd684001ac5a4b67bbf79f87de524d2da99ac014dec3e4187728f4557471 + +Len = 304 +Msg = d0fefd96787c65ffa7f910d6d0ada63d64d5c4679960e7f06aeb8c70dfef954f8e39efdb629b +MD = 49ba38db85c2796f85ffd57dd5ec337007414528ae33935b102d16a6b91ba6c1 + +Len = 312 +Msg = b7c79d7e5f1eeccdfedf0e7bf43e730d447e607d8d1489823d09e11201a0b1258039e7bd4875b1 +MD = 725e6f8d888ebaf908b7692259ab8839c3248edd22ca115bb13e025808654700 + +Len = 320 +Msg = 64cd363ecce05fdfda2486d011a3db95b5206a19d3054046819dd0d36783955d7e5bf8ba18bf738a +MD = 32caef024f84e97c30b4a7b9d04b678b3d8a6eb2259dff5b7f7c011f090845f8 + +Len = 328 +Msg = 6ac6c63d618eaf00d91c5e2807e83c093912b8e202f78e139703498a79c6067f54497c6127a23910a6 +MD = 4bb33e7c6916e08a9b3ed6bcef790aaaee0dcf2e7a01afb056182dea2dad7d63 + +Len = 336 +Msg = d26826db9baeaa892691b68900b96163208e806a1da077429e454fa011840951a031327e605ab82ecce2 +MD = 3ac7ac6bed82fdc8cd15b746f0ee7489158192c238f371c1883c9fe90b3e2831 + +Len = 344 +Msg = 3f7a059b65d6cb0249204aac10b9f1a4ac9e5868adebbe935a9eb5b9019e1c938bfc4e5c5378997a3947f2 +MD = bfce809534eefe871273964d32f091fe756c71a7f512ef5f2300bcd57f699e74 + +Len = 352 +Msg = 60ffcb23d6b88e485b920af81d1083f6291d06ac8ca3a965b85914bc2add40544a027fca936bbde8f359051c +MD = 1d26f3e04f89b4eaa9dbed9231bb051eef2e8311ad26fe53d0bf0b821eaf7567 + +Len = 360 +Msg = 9ecd07b684bb9e0e6692e320cec4510ca79fcdb3a2212c26d90df65db33e692d073cc174840db797504e482eef +MD = 0ffeb644a49e787ccc6970fe29705a4f4c2bfcfe7d19741c158333ff6982cc9c + +Len = 368 +Msg = 9d64de7161895884e7fa3d6e9eb996e7ebe511b01fe19cd4a6b3322e80aaf52bf6447ed1854e71001f4d54f8931d +MD = d048ee1524014adf9a56e60a388277de194c694cc787fc5a1b554ea9f07abfdf + +Len = 376 +Msg = c4ad3c5e78d917ecb0cbbcd1c481fc2aaf232f7e289779f40e504cc309662ee96fecbd20647ef00e46199fbc482f46 +MD = 50dbf40066f8d270484ee2ef6632282dfa300a85a8530eceeb0e04275e1c1efd + +Len = 384 +Msg = 4eef5107459bddf8f24fc7656fd4896da8711db50400c0164847f692b886ce8d7f4d67395090b3534efd7b0d298da34b +MD = 7c5d14ed83dab875ac25ce7feed6ef837d58e79dc601fb3c1fca48d4464e8b83 + +Len = 392 +Msg = 047d2758e7c2c9623f9bdb93b6597c5e84a0cd34e610014bcb25b49ed05c7e356e98c7a672c3dddcaeb84317ef614d342f +MD = 7d53eccd03da37bf58c1962a8f0f708a5c5c447f6a7e9e26137c169d5bdd82e4 + +Len = 400 +Msg = 3d83df37172c81afd0de115139fbf4390c22e098c5af4c5ab4852406510bc0e6cf741769f44430c5270fdae0cb849d71cbab +MD = 99dc772e91ea02d9e421d552d61901016b9fd4ad2df4a8212c1ec5ba13893ab2 + +Len = 408 +Msg = 33fd9bc17e2b271fa04c6b93c0bdeae98654a7682d31d9b4dab7e6f32cd58f2f148a68fbe7a88c5ab1d88edccddeb30ab21e5e +MD = cefdae1a3d75e792e8698d5e71f177cc761314e9ad5df9602c6e60ae65c4c267 + +Len = 416 +Msg = 77a879cfa11d7fcac7a8282cc38a43dcf37643cc909837213bd6fd95d956b219a1406cbe73c52cd56c600e55b75bc37ea69641bc +MD = c99d64fa4dadd4bc8a389531c68b4590c6df0b9099c4d583bc00889fb7b98008 + +Len = 424 +Msg = 45a3e6b86527f20b4537f5af96cfc5ad8777a2dde6cf7511886c5590ece24fc61b226739d207dabfe32ba6efd9ff4cd5db1bd5ead3 +MD = 4d12a849047c6acd4b2eee6be35fa9051b02d21d50d419543008c1d82c427072 + +Len = 432 +Msg = 25362a4b9d74bde6128c4fdc672305900947bc3ada9d9d316ebcf1667ad4363189937251f149c72e064a48608d940b7574b17fefc0df +MD = f8e4ccab6c979229f6066cc0cb0cfa81bb21447c16c68773be7e558e9f9d798d + +Len = 440 +Msg = 3ebfb06db8c38d5ba037f1363e118550aad94606e26835a01af05078533cc25f2f39573c04b632f62f68c294ab31f2a3e2a1a0d8c2be51 +MD = 6595a2ef537a69ba8583dfbf7f5bec0ab1f93ce4c8ee1916eff44a93af5749c4 + +Len = 448 +Msg = 2d52447d1244d2ebc28650e7b05654bad35b3a68eedc7f8515306b496d75f3e73385dd1b002625024b81a02f2fd6dffb6e6d561cb7d0bd7a +MD = cfb88d6faf2de3a69d36195acec2e255e2af2b7d933997f348e09f6ce5758360 + +Len = 456 +Msg = 4cace422e4a015a75492b3b3bbfbdf3758eaff4fe504b46a26c90dacc119fa9050f603d2b58b398cad6d6d9fa922a154d9e0bc4389968274b0 +MD = 4d54b2d284a6794581224e08f675541c8feab6eefa3ac1cfe5da4e03e62f72e4 + +Len = 464 +Msg = 8620b86fbcaace4ff3c2921b8466ddd7bacae07eefef693cf17762dcabb89a84010fc9a0fb76ce1c26593ad637a61253f224d1b14a05addccabe +MD = dba490256c9720c54c612a5bd1ef573cd51dc12b3e7bd8c6db2eabe0aacb846b + +Len = 472 +Msg = d1be3f13febafefc14414d9fb7f693db16dc1ae270c5b647d80da8583587c1ad8cb8cb01824324411ca5ace3ca22e179a4ff4986f3f21190f3d7f3 +MD = 02804978eba6e1de65afdbc6a6091ed6b1ecee51e8bff40646a251de6678b7ef + +Len = 480 +Msg = f499cc3f6e3cf7c312ffdfba61b1260c37129c1afb391047193367b7b2edeb579253e51d62ba6d911e7b818ccae1553f6146ea780f78e2219f629309 +MD = 0b66c8b4fefebc8dc7da0bbedc1114f228aa63c37d5c30e91ab500f3eadfcec5 + +Len = 488 +Msg = 6dd6efd6f6caa63b729aa8186e308bc1bda06307c05a2c0ae5a3684e6e460811748690dc2b58775967cfcc645fd82064b1279fdca771803db9dca0ff53 +MD = c464a7bf6d180de4f744bb2fe5dc27a3f681334ffd54a9814650e60260a478e3 + +Len = 496 +Msg = 6511a2242ddb273178e19a82c57c85cb05a6887ff2014cf1a31cb9ba5df1695aadb25c22b3c5ed51c10d047d256b8e3442842ae4e6c525f8d7a5a944af2a +MD = d6859c0b5a0b66376a24f56b2ab104286ed0078634ba19112ace0d6d60a9c1ae + +Len = 504 +Msg = e2f76e97606a872e317439f1a03fcd92e632e5bd4e7cbc4e97f1afc19a16fde92d77cbe546416b51640cddb92af996534dfd81edb17c4424cf1ac4d75aceeb +MD = 18041bd4665083001fba8c5411d2d748e8abbfdcdfd9218cb02b68a78e7d4c23 + +Len = 512 +Msg = 5a86b737eaea8ee976a0a24da63e7ed7eefad18a101c1211e2b3650c5187c2a8a650547208251f6d4237e661c7bf4c77f335390394c37fa1a9f9be836ac28509 +MD = 42e61e174fbb3897d6dd6cef3dd2802fe67b331953b06114a65c772859dfc1aa + diff --git a/guest-libs/sha2/tests/test_vectors/SHA384LongMsg.rsp b/guest-libs/sha2/tests/test_vectors/SHA384LongMsg.rsp new file mode 100644 index 0000000000..4d8404bcd0 --- /dev/null +++ b/guest-libs/sha2/tests/test_vectors/SHA384LongMsg.rsp @@ -0,0 +1,519 @@ +# CAVS 11.0 +# "SHA-384 LongMsg" information +# SHA-384 tests are configured for BYTE oriented implementations +# Generated on Tue Mar 15 08:23:40 2011 + +[L = 48] + +Len = 1816 +Msg = 62c6a169b9be02b3d7b471a964fc0bcc72b480d26aecb2ed460b7f50016ddaf04c51218783f3aadfdff5a04ded030d7b3fb7376b61ba30b90e2da921a4470740d63fb99fa16cc8ed81abaf8ce4016e50df81da832070372c24a80890aa3a26fa675710b8fb718266249d496f313c55d0bada101f8f56eeccee4345a8f98f60a36662cfda794900d12f9414fcbdfdeb85388a814996b47e24d5c8086e7a8edcc53d299d0d033e6bb60c58b83d6e8b57f6c258d6081dd10eb942fdf8ec157ec3e75371235a8196eb9d22b1de3a2d30c2abbe0db7650cf6c7159bacbe29b3a93c92100508 +MD = 0730e184e7795575569f87030260bb8e54498e0e5d096b18285e988d245b6f3486d1f2447d5f85bcbe59d5689fc49425 + +Len = 2608 +Msg = ffd67890ff77f344ad4f067df2f4ff1db8f541c7a2bd9ae9fabad0faebbf7d00f0a71d568c3c66ac3c57d84faa4894ab2377710e4b4c4dae0f4da1eedc8658dd0e2ee2ffac8784515206f2876eb41f98afd4547cbbc68034212bcf0c8e4a7d1d43b3ed15c621f53bd8a57cada80148ec4652119b5af3da84169d81dc69d394c8767d662044d36272b77ca04abff7b6b0cf3bd1f3919a04a5d8ebdfe7d6e844e78fd576a68d6373ffd5d384e51b5e12ec32d5bb0ac685a59f4d5d12b43b533580750345310999cfe91cf2500624fe03a65769f86a627a667b5f3b42cb01da109e124ffa48203f1f3873202d35429f32e8263eaf9bce42ef40f5cc96b591467d464d00bd743a1b0af4c1a743fbdd0846b9879e092371a5e7f6f65937f9515e23820e60b83bbff73926f0cdb9df5d02e82262cf2e8cb26af6a64c2a4d1fabecab593db510281799 +MD = 1396fea95ce0c1c1c224b50a07dd7197f1d62b993c7fe9e1cc1a56101920d4b0fecef587fbcd56b854c8c9da95132f02 + +Len = 3400 +Msg = be105a6c585a766aa1f290b632219ff864ea6674b5e3f9846d447d46813e2f92b78ea82f0b515f46511a6f161d429aeae07f8e4853b8686c191877f5a06242dd4884ccaec76e16f3cc24e6ede212c78897a1518dde07aa19b3634d4efd090a48b81a4e535359a55b57397da44a3b2dbbd37636ac1f77c875824c88bb62dc90bc517ab78579b913643d81bda11d62d469da29c50bdbb1c967d0fcafa29582db1f59c98fabff3669f8c4232d4d2332c57bf6e08613dd5db5d6e39b4a6d5fa4f35b19325c2fae79aefe36485610235007da6cc3022cec2295ac0550e18388eae156d9dba8784e2aea5ed917be53e767a26c87fcc0bfcfa870d07b43fd4cd8fbacfae1ecfaeea7f12600f6b9ef7c351d9f1b8eb048324f984e2a909d253017805c2d788edbf9807469ccd45571f5d61a05cec80a23ef349a37a28b86e2970c20fad9e7e8d201a35ebbaabd14ca249207dc6d7e2fd85c46553420b325bbe980848de57724676ed6552482f71e8473308c2ddff94aefe34c724c8c52a3388e3b541d396d6722a8e201ad3ccb9a26497a50ff0e7e81f1eb109888ceae27e1ef0537b3bd14dc8c178f0c5dc081 +MD = 39cf9206d78cfb437000b100661753181b5f262b539c208b442e7a022cd3234c58751621ff0ee9e9d3607174e36aaa88 + +Len = 4192 +Msg = b41ef4a2b31d3a47a5e8386925fb90fbe980ca2cf6ba34e814a3eca280d43b51e2a624b87e973debaeefbe0f90a3d861fc79487ab96d2bd1f0531481e0bf5c4cd422b9e05235125a969b92093fc2fc74470a3e9e382948889dce1ef8b7842c7972d9dba397c0619c4335dddf981fa33cb27ad420ddb533170559338f6eec55dfa515b088b601d1ba9f04c61a058476c2261334890fdb93850e3f7bcf6bbf7c86531c631715bd0bbb91527641ecb71c0d891b8361356110dba2c61d3f17c54c7765381ad81dbfb7a7006515dcb7813e25c5dbec2eb9105320a8384268dac56ab9c4aefd5436ce7c87d687ca73cdaa8413c09b957a02b0045c08db11d01d89815456c93612c9b10262fafdbd8f96fa95de64a3a6cc7809cb98aaf8b30146d7375105d0ea9a3c31f240541217b77a391a8e973a48ad83e24edb76d64f83bf7834b7b80a4475f916f429cc0d0074e12eba2c43a9a2a48b05382d54bf0edcee34218e57c0692a6628af264a359f4d33a21ebf4f39de39f8382f962cf918963dd2a6dfc93b8441ed2ecc3eb6d41dcad85dee4fa32f21f43244db1fe6cd9438131c6ab1f8c0bb43f5f2f27af830a1733927d1e527d6965ea1f1e6cf6a83aa4bd7d8160ccb9a36b7e53acae0f89154d1bcc86f87c37562feae06f5afa0638456f3cf51f82a0f1e2527cffc7b9f415e6bca0771405f53b05cbf4db3c570b547e1cec9c47efd699b1522792f50d387e6c9 +MD = 0f8ff0eee8ffdefb8b3151b7664ce9dcaaaf3f7af0b1e290ee49ba211b67863f63fa71202a534c0c42444a52bebf6c62 + +Len = 4984 +Msg = 52a6741b9ea02569dabf96ec0b3e2462866eea4a635bd7a42fad04f8e1cc45990f48ff2b627739634860f50ee8d7c0555bea883f197cae77b1305c50be891906164f9a474434dbf139b76f1e3e49155e2dae8b43e1a7a723ebcea31986c1b94dce82ef752c1e359c158dad22f4da4a0564849c5ea323ea2f434e825b23bd4df69eaba6bf027e6ceb44aa5625f2d387d2683263994739a023237aa01f7cc5fe8af090672dae9cab672ed6132c207cf64ea28087fbb531f188f218a66c7920f3902bfbd9c619c018963bd98c41661cbc007838b18dd65304e418f13b4b02185690b6b2a4922932db02d47a686bacfc04705320885690e602c2fdcd08c3fff34c12fb7d7199c7391d335f8250b3da65f4279c02b55ecc3412a70974b4dc58faff9f6126e8e4dc1f06b046baeb1fd89db4acb9a4dfad73835d1da4ade89ef67597be5073b07a4e2abd01efe7e2ba8eec6d8714ceaf4c6b1c0bab36414c12bfac3bf8302e726307a36baec4d4dc89e49c4741134acc429e4743da27f9873f9ce614d46a1dd5a8edd2373f2b488296c3f4696120dfe097f24c2d30df9b422e756d4ada64098250eafe4a3d8e0a7ce8113bfc6fa25490535172f237c6ef24e53387049287b92063e570cb3054e37187b8ba27f40172867fa202ba7744bfd66ebc7d6a853bf758eac571e39ee59b097c9eb91377a4016a23cd44ac77c2d1ffd1fa97a63ae989d2eb7447ba11a9faedcead7fe780f5c9e345b980f1bfa6ee4814d41cdd39f7383571d93a771008c8c585cb56cc975b919aef50feb0d75ade594131563a0bcfcc2981dc9443246acc38aae284ea453e233728790512484469d95ffb8be237d70d5825659b45d337cfef43d95268 +MD = 45d0bc363c4e0d5c1993570d7366847aae64ead4138d93acd843f28d3f719b02871736ba4905532e27f4bc8b5c2ced85 + +Len = 5776 +Msg = cc990092fb16b6311fe4d66dd5c472215e807f82e71d34f60e58b32aa351eb5eab81bd04abf15d8a23aefc745878a4ad56ba631f36bfab819d22f9708586b5c240885917b9f2d6b0fe313485fb0a78918888ca71a739d72d069a7556cccf855192971ef2ae80e84db857c5c847e3b775fcd3fe9fc2f480a353a76e01ff9325b3a99752be12025a065a07f966c36b2900b98145d20f586e8b8c332e9ca6395b918d6e3ea26be2f585ea291687f80a95dbc77be83217ce688cb725fb4d492bf09347062ac74387817273a465526c29c4ae2eaa2ee661bc384ede651e3c71d0ac60dd455e542159c674fa622ef0a92e7f20f6f56117758ba47a08dadf93a59056a15a1521728ec08b34894ab98937838cd92843c7ecdca475b83e6e85776ed3b8fdc35dbd4911249a5a27444d449c8eb382cc7eaa8e1d6d72af87085a125301981d2205780032edb98ddd38334962b9bec3e88d5024c0506508eb90a48cdc82bfa87ef49bc07983b175b20eb4c1106b7343865802d74eb4146a72efac0d91bff547e0146db06f4f49bbaeae16d42f0b9cabadc707cf4e01497e250bbabcfb1e01a24f4c38f99bb74b07d901a1a94603ffa266c2a933489ecaec0bcd15c1a108ad60d38442c285247d003ced9f69ddba65d1b8312e2bc4f55f5b2c1d07450be6bf2a74a4d534b6ffa94fde5b563b7d9895dfabfcdfe14b6dd27391e4d670c21e00a73b953777b5ae959cc7340f48ac055975470b047a646eeadd4108cb694d1a38802f3db0b20a9b0a8e005e12b7f569773b9546e52198606e4144732e5934402f5c59858a0d3e2ccfcd90c3a7b1dd2cb8d89c96c9fc6eac2746a30b476700faace4bf550bb1d8cbae027f4a165eeeb6e4f564e1fa336eb8dd9565ba5dbc38af79c06b967dc660df6dd5d6daa6e5af70c339f611beef20ed57d69267ba7f64c65c97652e26735fd0d5ed9c5da16fa8c01c4d590c5e580db35fb033faa4d90da91e11b3074fe15c05aef3d9ba4d23620fb9d895bc +MD = 2d24f6afeef2af38849f29ebeae7012717d50f5a31561ebb9e5760b83766030d1d2394c8eb71e030226ecf0159efda87 + +Len = 6568 +Msg = 546a582d46de5b45d3f71166ef69aa0704848c0a3963b194f4674a1d9de4a9c3a6195de4c8669feb8fb9ed6a184af46a1a88b3ff2352de1f246b80b33028e5ef816cb7dfbcd667437539ce9df64d15883ca4d24b43df73ae8421e00dbbc45caaed4bac47aa987cf59060fe2710dbd40a75c0301921703aec1a71b250c61fd69df39e86441a13a6a8e514c42fee5dfa98cac4168f466ff97ef0443da7daa11b709a4d8bfd95afac047e3e67dd19394fd94598ccd53942790f0e80ca387eb2f2caeb41049ba2d458b362c7305a18d99b76ed249a14825382457a0fa12b3aba2453ec603845caea705a999567ce73a3a616ca51c874aa08dcc83ed70aa996217ab4a79371249459bda42c925461b3013862e5059d1c38cb4e4162c24dda1b4fb99524c3f560888a073622a43e395f5a180245296235b403a158ecb7b1e550adac9d6ad60e202ee316bb83b56f81ff150f9df2a660e6a7179db4e69d7ff2bda11a7581b6018c0fcdb1d957ac2d5f1c9ce5dbf562dc5898710afe575e002beb94cac5714919ceb2b1a238a771c1fb3d566266554721b20f78b0dd48e179b661ef853442799d0b9ff5af817aec737eeaab4de31a3c761d949457fac00e35bba718136afd2cd46e5f03a15cd9058a10ab0370fd4d2822c1b02dc6fcc7cd7b6346793c10aa4c071c79413f70cba450d809c6915af5f56ec5eaabc68c650692d5c578c8ce4fc07f407519536658b10bff8b5c79a21a8aa252cb771f52a3a1c33aac7f7e4bf6708100dcf2a3e5881404acba2ef07ec4cf068fdaf799f5888656ba84f52730a64458843533f99664b583081ca2be96fcace1a59f94fb1e1d9e937cd4428b2468244bf508461b21f37ccf3b3b21aa91c9097dbba2b60f7469cfc1a924cd72d043f8a17bde92d12d3e52326c9f147d1734ce20fa6cc69ba074022a68fd00a4db3fa8a33d3d7fe5624b1df2c4cee1ffd244e3138a842a6849462014e2e542e8ee641c9964b0751d6a24c7586a52f2f86701309e92724c3e18e80fc83f66fc08b1bb3dcb17bcdc43ead136ac86b3ad3081739e083abf93e5b561b98ea60894cacb4bf1807feb1c1d8d58543642777c6fc6a3139bacf26624c7b904ad3f5273f7e51c2101c4c49d74f8c3073dc428c67cde98789d0d93 +MD = 8103d79f14895bd39e568b4c8cec9a26f03966763c3b2a65174a5d2829ecae097a7c6971dfe182fd2a7a9ea6e329b6fa + +Len = 7360 +Msg = b8727e619a77b72152a46d80efe1c1ad34f131b83e8f614967bd1b926b599482c9f1f13b6cd809c78b796d06ceeca6ebb2c7bde82e3701a7974f04fbc19fe7166709d7fcccd0d838a3f2c1cd2cb8886fa18bc0f3d00960050958c6193abafca45962398b0287abdb62b673bc536cf2a0c8e443c06c2e08c986816ad220d25b9268a51ed056240a1a8f6e8bba8a3169e6f17b4d374acd815dd672f710b90e8d495c7a8fb310cf7d5cf4c10fb1182f77a9e2f7e640b10f5127c1d275ba4f971932fd88931c77b28d0a57580988468da351640216c3eb1c02910f49edb8289587b4127832f3d4f2c18a81da80275c7475463f41e6a83e1b1c01878166f28c2f603665f174206fbaa2453af07d76a20b76f13b5e5dd7f33425e1f21fe84fc58d2a22bc9c628b9030b7a34942075c5f7b2db8200184395191a79818ce7bba1ad870dfe021031d7f7c880d787726c4ddeb2304b5d161b4a257298ec1342818d238b7d5992760bc83c79de98d38e2936284de3ec377ff312cb1342bb5f9f65236d4896cae567f51e6397fa0512c44b2376de8cc129a639939c54fd7bbc6ee508ed56d0ce9586ac5eef9b59b8cfc5309a4cfc9186ae397d20fbb02fa9d4316fa2262ec1d10d229fee430c741064f1880f0d2078893faa2c6f6bcd5fc2117783839a48d07ec6fc2e610053ef986ce9900659d2c8654868c5b38f0514510ea1cf31cc3d83245d43f64b9a1a02dd621e06f4959c07977305d7b1c7efd3d3166081114e65507e3aca75f282b7844bceff5b7e52d49c9c29f1e0de98e614d4e31467c67358dec8d9d03c1a6cc4ba601e0debe814251ddfe7bd7f9e84a06db2df3de1a5dd9074a0d4f5a7179aca3ba6d9da56e65c05f1ff36e8e2761d873519755d6d540fa4b8a296cb457e9f207eac7ce52add8cefcf6681e4d7f9b60301554fe389456bfe212aa991a5b40c7009ed91beb652394aeca26331be8e00bc6912c980c3fe951534c57809265c452153c692a7a7d8f3b0004f656014d7600bc2be7c858bd3fd8269efac9275dbfbcce2d40a606dd62eb770a9e2f0593a6689a4d4c3826f8a07be472591cde2b772cb3d92635986de4cb9d45e66532a3b86be95e25907dd75662142f3e1fc1b735cb4da8e27f37155f04f91d98a18d65f43030c638776642a8b63e3d6f7dd7e940c023033e2debbd19bd13fb7a8a20c1a2e0f7ec4e96e721dd9fea04b4dc28aae234bd5000e7bc4d5b1f744556c9f2a009a2c73a2e950b5c3e44a1ecd7e5bde0614fa4f8f154b3ad6d52a365f2050be8729f2617 +MD = 2ac3ab5299ffbac1c27300859a92a69a80f510a1f28b7054f131b43af74a0df5e298a9eab77e49ca81a578c309f5aec4 + +Len = 8152 +Msg = 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 +MD = 70a597d1f470d69d7b7d495531c3182704dd60db5c73429fd7108c8ee22d86ed5822adfe6352f28f93023f46cc8d60bb + +Len = 8944 +Msg = 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 +MD = 81a031db32d465202a2aba19ae6072148f3fcf6fe33fc8a843c0691cf845f9cb7bbeaaaa04ce2f1476bece682632e20f + +Len = 9736 +Msg = 98afae971df98e02fc3f503d0b12176c2ed77f4e7962de7194c7caa2646cdba8e763b13260f7390db5852d9a158eda80dd09269ebdfed1441750fba2a7dbe78069befe30b7fa17c1b23df576e4f8117624b79ac5b9b2bb73c29f1c14d5cbab70e6699c7b6a2aae87bd0eb1b8c17945b8c989e4adb5a723685e5c34df3466b0de250c93f9c1ae89c59ca06848f439fdad94260b3cf804918ab22f4ced0dd47d33ef4eec9404af2de4189c220ec55fc1bd4f37175cccf28d4188be6b25a73d9ad80cd7ae327a54244df9aae7f17c131950c06311f47799a0f5a6b4996f4cc890334450e1bd6cc6f5670771c0dc607f8eceb15300ec4220510ed5b7deb3429de6ae5f618e1c222c28990a9ab4b4bac8a7a0e8afec2c75b029f4dd6f43d9d2e524b024b1bc37e4af454dc9cccc62d219ed2c2d1ede9b5870af108686cfca44c8d3a05ce973f6fa77d5ea0db00fcef098e7db4a48dc2333896bc898a18b6ce06d7ae8cfb0bb41abab60d89eee85e05c6d1d1505d6f1ab4d22e585da6b7da8eefda1ef45af9d0041746c7e442d36815dc117432870221cef64a6b01589af67b59fd01d868e201b02f98346c7152b973dbc5ecb79bd795c617735af11a6298f7e7c90da59f44d7a37632c97ee4f6b0b42857917c166fd54eb821aec9668f10991bb688e88892a0627d9f0d98283fec6b545f08dc712b6ecd5addecd6c7711be3686e1a1d9f6c2a51c8455754c58edafde234c97556aad0d662208bc5a7c9195b502817c15e31a405c8be5d111773fad0448139c3116e99de70620202a1f77755559d38504f73cc0301728569c88fcaa70dbd00424bd7285a084ae61a207cd485fb35c256ddb2f0be050a56cb4322c8d6b050836f60751aed9c13be78bdd9bf51b37a6c41937fb0bb45de47c201dd83e3bee459c6f9e8dffdae84e19ac48e764d10e38cbd1b2a9a6f4676deca9f208a428bd0e9d57272e5fea1f7061cff1bb7dc95f9aa05bf43fc6e795c9261759c2a97c9beca1754d3db8538e2826ba7f1e284a5355ad7fa6c852d6107f9032f910347daf661092b5c1f15b5ffed1369b194d9e12f0590770493209ff1794c17bf92e75220453760ac2f24bb77ac80bedb2d40bc3f30bb9f9cc4ec88b19998e86867daa1b4ed0e9f249a36bc12574011cf3a5da8fe62d5fea588e5bdc0e075fc3bd0a65c3cdf0b3155cec02a2863de0d1e4a8539d5226bfeaf6da09197e45fddaa8bded41081b9b1d06b55a85268c6fb38cc6bd16bf5ea2a2ad1a1c6befbd30724f7e8cbe87ba6baf4ce6b9908bc7776bf3e56221b33dcfb98536daf9ebd6bf33b8368862d333e976386768eb3f58c0a021ee88e7b82b10d886168cecf9f874c7edcb2a5473f0de17d120afbfcaa512fb1fca788f55902ba7b9a2796ba28b15d3f627babdef57113d1ff9d534b2183524f45f7a4213d4e9cd25c3eb9f6cf76b02d93080c4d0d24c8e2bdb24718117f0c2a897d528785f12f3d25f28afe1a53ef9a0d0c3929dc855b2fcace29fbe0c0d7d4459d3680e996ec0c95f79c489fb566353eecd4edea1f5529a5658e5f25e52ffce8cba2b5debc4dd11ac2606eb627ae6f872e4211cc4f4160ebfce6ca47588ed511ad398ecbbdef1b22c779c8f43742a99435133dd9b1aa55fd18b5b5cb977f2d2ea66d8437282a5b5c9b4affd040ad83d4b5cabac8d2fa89572d9dba392e6b45be4bb12ea7979 +MD = b31950d784b30bb1743918b99fbd6693b30fde41b0b9c2e154425f048827a161dbd4f3b163b5ea8b8d91bcdacf22e84f + +Len = 10528 +Msg = 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 +MD = e35b64497f34c095a1135e65b6d417d69e8587fcb53cd700d10cb8a1c0ffdd97144b6cd1221b25169ad42d1826d10bac + +Len = 11320 +Msg = 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 +MD = 5a39dfdea913fcbcc5549e23b310c7ad76f392fdbea1ac188d529062b9961a2e32cef378f951c4d29eac03b3fed8e662 + +Len = 12112 +Msg = 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 +MD = c4d5e18acd6e425d4a1f03c23d7a48ccf313c4f987b9a1f4b4e3688c5ee4d7a97a3dd31fca20e8cf159e1feeb0df4e65 + +Len = 12904 +Msg = 8c9eabe871c6e9511194b48ebf9e9b031d8df7b9e1cecbb2d88bef792bda6efce1342c9ea528cc89c950d0418c85027f984f133ccf9f830c47c1c0ad938c92e045dcb677b042cab0f3f969c1331c96b427175e75da5cb92aac57b2c29aa3c7d1c07e939b1c7aaa6e9576c5363ccd1f4bd1cd1e8d896b36b30e340be0c887d5775b020931713a366db9af2cc730ff64eb9f599cac6435c2507642132ea4a0847c1d50616235e93452668ce89c95192e3d97a320f8f42224a9eb6814d5b6579c850f50e355f2ee6dc8a5f540def68545e9c494f29cc09b2665758e54fd8612e43d37ebd6332fb3a9757dd27bb5d8aa71962b1259be51068e2c1c9c1ccc9d3a25499f078423759faf01f60be248c5f07aecd6069f872dcc25a8e97bb46d823827544f8d334e4b1a49151888bdc044bf2795cc590a1ede56b37fe3116406bd72b2044d662cdb398c3d59ec325444de7f413615f1e3abec0b0059134774c0d7528e01a378b7f3c75d547479efeefd1998907abab87158dd52d3df7f062bc2573f82f459ad1bbe7ef6560fc7a8d4138073dc06c295fe4b3b95f6b83134d335c5a1588575eca263e5bd0bd1df464fad9876ed85356fd0ac8d3b2f8d31bab240aadfd65b011c920b851b3b63c8afa5f3eb0a8b9d1b3030a45cac47068581100c8c63c51f042734dde479ad6c8acd1e0e00987df67dbf665b2f4f06ca377037c0f694ec7887f4d0028c3d2a952e8604265f868c396204baf88e8e33824f6e6e856dda150f916baea105d17a86bbc49d62913d800ed3e774a301d098d5d365fc837b9d068b2a7415e3d59b65e6396e33eb1d26211cd750db86117efb6ccd3c2ae1a74588965af74ff08605b35db16c0ce98ba8360c762738c645fe25ee44db40c8793a63d52adca2efa0752b952aa67083642a8985b854d38e26b9de04412a865f7ae55ff2a10b5708a9559633ac03a9e12e16e030a6bff4043b17ed56cb1043cf31ac4495c86db5652b0cbce23f6efe2c74d304b54751e3500c811c8bea78c13f27f8d965a5e8062bad026548ecccb68cbbc9bdbba4f0e79b215d314ca64746d8e232e70b43659085b89f590dba061a288d60d2eac3854a0d0314f54008661bc1ecc0362ea7cd9d99d34b5fdab204722971000decaef952cd390f301017bd8823cd0c8e77db06738f866e4157daae06b6f01134666d3248044bb5aa63dc34d4260b7cb78ee6fa5a905970c52b3cec1df891fb1003061a74d9c26d2ae25db449f1307a781ad08f9cc4d5b9b4fee0a70017dc26696883981d7524a17a35a4232dadc46d9bc4a1af805281b1d57accc5f83a59fb0740eb938cfffcb86003b96bc9814dbde63362414d62e5c1f2450a304b8991e0b13147f50aa0cf1aa5f4a272659655d1220f1b2d4c1e8a4fd107a2ce412d0b3e31e39ea5dd80272e11b16922491463131702d25bc5acf7c53b699a89244e4f7e4d00f88b4dc68b5e6be21661bc2200ea8cb291b3ff34b489f812fc483a13e606ce2d5e8fa49b84127d2faf1907e8b2be4ac75f1c44df4a05d0acd0f3cda557407b14d699282699b00d3e3e31738f04f81aea4581dad4409f8bdc1c71232c2a921e5d6b91239052a1e4baca91463f7bfec2c349c70a3c1ec1f04ceaac84cfe8667db0225fdb00374dca495c21c81fa1390af976d71c3f6dd2c9a4418b3ab6182362b305eb999fd11c8693fbc94358fd11bc35d1995804b43adc8b2af68c0a423193111b1da494a777e241af71fd1117ef9e1e64f506b47b60f2aaabd5c1f3eef8d8706cde460841c4a4fb80013f7378397a5d36d46d764baed2a9cf102298a5e0fb790114c523286c9568776151a6a75916994f1cd673aa8b462f9b90f722ee51c2d3e1a96a0ce3d87d319b797bd12cb53a7bb8b789d3235f14e4193b88b852b3f72614837decfa6f24fef531051d90b7b0aa788bcebd3b93057250fa1c83586e601ca38c46eaf69851768b7236b15ac53fcf9782ed597c8de17e48b6fcab88eac65b95aa0c2f5ebdce41672258b61249ae921e832dd06db670b30a5571576a8ff08bf2c719e3ba456108912bb15341aac69a1475d84a967679b69dc1c1af87c6a855c3cab32c9398d3730f738ab16e504f90814234ee8036c63209e034dc66f5b4610f9b23356f1eeb29ebe42af721a3111b6dd18ae5b25c1dcd579c14068f86dd56de22b124d93f73d32d65db4ee20bd3e4e10a2157b452472f8edba7548bdfebdc3847a42256633118dbdde3de3af05f93e4d5436b0f7e0c01b68737efe1 +MD = fbaea1239fb68417d5fc143c0a2386ea75d5ef93affb80108e6faeda4eaab7b30ad620538ab0589a91af34b78f06dcdd + +Len = 13696 +Msg = 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 +MD = 916864ec799cc0ccac4b6a806a8c02ac72fa2c3c9abce6231ae7a240d9f2f26b819a711de5480aa334638cae55cbe6f5 + +Len = 14488 +Msg = 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 +MD = 5077b3d65d16446eeb06f10c73ee1128e29060ab1ca255c6cfec53af04edc2a665bc5dafa937164bed9d01d0316f0ffa + +Len = 15280 +Msg = 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 +MD = 8f4d27faba49fe0bffa92f430faccd1990f9b745442d455a5c64eb39edbe7c9d95749a644ca8eeab63ad183cbc739c12 + +Len = 16072 +Msg = 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 +MD = cb7a6f63e6186009b6857157690ead10a5323917ef6035d41bc71c224b5bdb0ddacbdc2a59e6ad2b3731678b1848ae66 + +Len = 16864 +Msg = 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 +MD = 082f8540fbf6774f3858ec103c57091ce84b1479a791f87495c44b3e85518993267eb2ac0cb44e089567c562aba69709 + +Len = 17656 +Msg = 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 +MD = 34136970bcf300d0b2553a049fb7d598acf9febaf3b79ff79264bf9a4b0b27474b6fc7c27c5b19f7242b7b8f594da916 + +Len = 18448 +Msg = 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 +MD = a6f88871b9f52e19ce23dd00fe0162dd6a6bb39d66cdaf2ff84b55aa9ba5aec9d2d352b374097cb35f0e1b71867a3f6e + +Len = 19240 +Msg = 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 +MD = 240602789ea8f91535fed9ce15b79d6d3e6cb54cdd4cb55326ab03ea76e0f89d42202ef229a55351b13a1ec143c29711 + +Len = 20032 +Msg = 82b6d4fcee076404ec0e88251df98b0fc80488007c8f2d7ff774be4d47975d992fbf8873cca4e383784938fbef8bbccab1fa9413a7e997dd08c1560c7e9b5990850dacdc14439b998052b99c9dca2716268a120b5fd97e06f8b2420a355e54cb4c49471e0f0e12afcad413f26fdd545cf05c0cd2ed8769628fee8c31b40bd6b44c1a6223022bd22b20754fe4acedcb02d717894f991ce059951e3c6742c865b24c2904d238c2637748dd74599e211572a364926aaac06b53d1e9589628bd8b2d161d3513f8fc4bf90ab58a3b8ba2b9121cea2e0b6a9a93b80cf8eaa5af14cf8d709ffdce8900141b30a59a71bc973f4c0a52651a1fd3dff00ef2f97c1cf2b93b235765eb34f745448054aae37929308734433f7f1292d8639f808e03ba81d29df7ec7453410967dbc46bc5790a80122a6366c5228b000479874ab022d0e9a11cb30733ecf85d014ac291f01bb6c3709f5f63feecd145ed9b8df767c1a552af21214fa89fa01c9bf8436f35b1c61bcf4df0e1f3c32e881b2f7b2fbbc882e38212076ddd55836dbe4d0ead9b2382afb99cde88aa91e8f1159f179cb51fafc4a4582e08daf4e779f0b1edf22a5932a8b5f4f0012d3c48aa63512ae45cae741e9d5c5ec9a5651568bc8ca6e6eb3b1e2d4cbdeff484ad96d88daf7bafb95e1919f3855e5748915561a7460232e5b28e67045fa408b5cd1aa61b1fd4a6d215e5dc303af85ccb5fef8c3b47c97e21a4c97d6842d4e6ca831c3a960bfb70b1bc2190dbe5f27d34b62a12fff8c371a5fb1898fdcf4a36cab6e3bc86dab9b65e3c165c7ded15648d804f1b7bbfb7b47b9dc3e04d6ccd9fbe50b85571f4d620df7b09699dba29b9dea4a6ce38056fefab74127cdf8224c9ad38e32ce1c11a553e6345dec3b4f6232d0a7754bd33b1c93b664c953b7a185d9f56ac6b5da94dfe83db11e47843434b849a0ad592af46ea355dbb52eaba71039d925a376e1436c2b4cab4a342cfdad9ea3ca67840e3f6fba040a5dc73acf762add437bb9a6a9e4adb1a7742acc0817468d895654e3588a485f7535a5eb77123da04891c6c134d3effb2a2ea3b7e01c404561dc5440fc68ceb690df53442a9ed290a998569770b45297a7dc279712272c89e87c0abd8765cda801bd57bb76569a4ceaf1c1bfea007605a4ff3ed01ab26bc981b7d0af861bb5b23c421be7d6e3f523913090911d32dac3a62a41f976687e72d2025e9d74f52743a510282fc8c163b310c75bb166d5f1502fcfe9899193e5143e0dfd0dd08c92fae0a9f519c8696689fe388ba773744a49a6629df718df302c3a1d4487253c794653721b2c52668e06ce1698d9af68560eae84c7c858a4d0396ac2bd8fef9f4aa4820af2edf3234ab7e4b41bce975c952dbc98ff83fd8f45ba2490d09e9c3f9793f0d724c5273a1d2bf6c37d0ca7bb98053531bda063e9112d1bfa2629b767e093345919486b1585c168b7450a7cffdf43bcc18aa4185cc310a58116b7cdd2a630a11358ee4b401516aef1fc4e73a3cb67c7daef15a754cbe345a83acf5bfa68eaeb986c3d24343baa5e161b4f2841eccfcae0335b8d6bac4390e1fae6ce399920585abbab928c69eaea962a930754d40a5a74201c370bd4800bc0ef84a12ac78f9bccdfb022933056d8f492b09d46e1a5eaf91dae30bfe5471ac7712f814874771a8130f130f32f7cadb3fc0e56b2c600e0f184a806e24ef74258385dcb1d107548fa67d56a16a7dadd46bf22c002c1c9f1001d80262d822f1715ad860b133c08cbaadcd31a9849efec3f648465c1955f8f8710dd1afc2f4d0d62393ebdb547b007151880eed2763a5f0074a9b479914010f926f551d896df99d073fe4f8dd4098fcba355437fcd28aa3c78193895460a29f8c88f773d695550d2d63b5d075153ca20f5c6b4dabf696245d7497e9f441c3ee87e01d7b5075ca70bd87c52bc504d4ac7985bbf7dbd4afbaf2ac0d301ebf4c45aafd31fba014410ce1337cd1741448621f39acff3476beafaeaf5f267ce325ec1d6999bc6d7aa32bbff0428a2b4d800c2affa62c60e3ac49b807f393b6b4372b09acbf8660b0d6137f457f1d92b865f2c160114504235fd1393b333f743a684a964c092121bdc40c4abb9b53505cdd5c0de35513cb3fc18e58d486f25d7ea190ebd3e15457a9536048d9fef40e42d1913510da5e5a3eb9ca3e5953731987cb4731c9aee8aa7d6d55a02711c873702ada626f08ed5c282ecb1252048b515eccb58fb4d7a6c440f9357b2d3a9628f0ce7fbc89488a77050adbfd480002ad098e222e1ec6534afadf460074e228d4caa7c86ae500fb53de344027c2afa0d492f7d8358ee2bae7b307d15883724420049cfc950b9a0999ba9442b748792c6f00f11ecd8d93a24174591daae250b3b4a8946564847c7cf1a2122bd662c670255c633b1ea241d20044bd741f1ae63c37bd794900d7101c029d9641ab99fe329fad34784f555413cd2c1b1cdfb29ba9524c32f1908cbcb175b308ce5f74893b84fb4e1d892e342d50335b5e1132d6c1ac5ca7a53d2cea02f1ec5018197ccf537d4f9872f3b64ae830616582dd22014beef5c0ad2f3e01d81f5156680237394132b0fabeb674fc0c15be21d06c0b8310bf1f65508d4a69fba7e90305422f2dcf4a265c4bf9f0b360a9537790e675c4d8c8e37ed77fd8893330bd3d3900ec14c36eb9a65fe5b3d8ad9127500973e62c6ab048f38a2f71cb4862d3ed4a64f457e64572c043a244d1bb7842928439e823902057acb1c29c9601e735fc8197d15c007858933f572b085204ad274963021110c017919463e2532764eb5026c10b8dd9ae73059a2cf1e33add6ff5a017bd5eb337908b7b38ca688284fbd3810928513890ccff9e4a1dcc3aac90e6d17d9f72412eca80ad69dc3edaec6f6bd998b20fe7c56a6a91d9372a1c1919e123bf32b5824cce5a731fa03df7474e0278963131acf6562cbc00c865a6cb11cde002fe903e3aa3ff15829fcda13ba17fa42a2b1e50cb962f67e857e5a16b80944e718a693c9f5159dbb960579f706fcaa67c2a3e9beb3459dab96c11d4a06f1db5315ea94524e14e0ced6b41ba90c0cbc6b5b5f954ff37945c9a8f530913e4505f6d02b921715ac8f24549f5ba409d6a4bfd55b745aea8c736b34912066cea15934bffff982dc4aed3ea81d9672a0c8f7f7b90e034a18edab12d21b79452865498f3dbe5710027e8f8039b5788f61822a858f1dcea80f1b41330a0a87b6dc2f5b78e21d276948c5da9b920d6e74cc60b0fbbfd132ff2da3fa4e34c4e8366a5e03844562e6d8efaf72e3497be4ad22032fccd3eeeca9f4f62ae6fb01174e537fe633c04601f997a9dce9b88767a332d7fb6b63bd385305b0577fc515a159181357f9fb2d2545b1337d2167b683f15f5db879d7c2b264d031048b1b98f2f138a6ed694e9ebd47ccdae82cff9fb6021812cb5aa8a5f769d516c69b66f1a8a125b92ae44301366a5b0e826eb8997a7fed85c8907ecd53dc94cff2234fb61ee37fa8750d70fb2 +MD = 8e2dff705dffa8faab0e5e06375d8a188602a9084843866e4c991a450de4c4503ecbd3667ebe432b353df3181f9d9726 + +Len = 20824 +Msg = 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 +MD = fa6f2bce66e628ee4638b8658e0cd36ca630c71c7e1d6da2189b4e8965a73573fdd137d23481ed07a8405c04b1c9e48b + +Len = 21616 +Msg = 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 +MD = 88a7ebe36ed445be23583ee13431e6291a08ce9a42b7ec012cad0fe205bfa04d84303e571f0df0803c76d7fca5a7d8e6 + +Len = 22408 +Msg = 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 +MD = 4e7fae296c6d80c6508379f94e01d80cf3bf9e057f579ee91df6d0f7c1fb85e4fac45194b91d0b1a9bcb756bff848a30 + +Len = 23200 +Msg = 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 +MD = b77fd3d5f25b7a3c0e42c707a9bdf225a8e842582308a73526ef4768f497f47776c4ea0ac5c6d1933946b14907e58dee + +Len = 23992 +Msg = 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 +MD = 1c471b3e2b5d06a6382569b12bd43c6ba3c1c7e47ff0aafd51d896fab41a58e00b14250aa556a842161df9f649327f64 + +Len = 24784 +Msg = 2b23382c218197e4c48025da42212e39effa3e73452f40d5299de360705842d4a258c30dfe6f3f92be7e646c9ce9583494489f70ec603f20725122930510bb7f5618ed51f05d28c27682d5ab2c4bf41ab95503a52c0522fe3cbe76c8d457cba9cfcc7da10033989a75f23e40fc304912e78932b90d063299114ca6a7e713b87a93da3ca434d9d842423868d2147ea045a54cf355974bb41978637cd7452ecb192cacf203963830e365ba1b0a7a1f41db7b061021d3bcf3a6fa6bbe01f68e4caf22a866652e36e7a567e21e9038f974fbf11f4fc4c84236661ecc35cc031d8363fb38627302bc47afcf173b0b56f681cd90ff79e77ec3c4846ceea9e173c1b75e41c3acd51db3962a25c03823dafdaf7adf0f5631fe28e6266c3ae2e74e6432c77bb10d3284011d3df247de81cef5482a67b5ad4b4f5ae475a716a7879ced3ac732694d3241902411bc13f5cd39c89204ae5a47dc79400698a4ebc16966441886ed55347e5a46f3cd0e8c45ae245dd6313e67ed8d85c194b7eb22f934b451142b34dc8abeda0dd19a6d1a95cd969c5bd99f4265067ac7d5fc052115908cfc75df8f661699c6cc08a06325afd2976d6b22575577ee6039128d7952dd27f82d85c9875ba1b8286bde06771559642fb84c37f007edee40fe9392cf1c1b9effcc8a12a324f3c307d19cf532525c2b6765473ef2bf8ead2100a03490e695a0a9c1cde16c27d4616ce889941a4480d1465ca460e3e721d40b26819a431a14d3fff4965f69cd0c3a5e97ef0cb9548cfbd586abc44de66f0a06587dee701f60df084d2db3227e62f7e5c6148497e84a531bc9a493b72440f81b7edd559f5d416dcdb5d9071fa3a040095d41253a6a8081200ed6f4aa095b455181eaf9593c7f255412e380e9a28cbcd345be172c40f72dec3e8a10adfd8a9ab147e9022524e1aea74e934807e5ef144a64d381f5d477fe883f080e4868939f41b925988c7d31b1ce4f318701d290f077a3c88b1b8cc89cfbfb981703b23ffb0bbfe5e115af35d5cfff056460d339f660eae45f28d2b1b04d58825367435657174270084822b6c3b4445708aa4fb0d10f227122a40dfbe286400de9fb83a05a6b280f33ad3e7b2285086e9b6aaebe278c31b5ff15a46ed9af9a820247dbe5ad115b0a8bcd6c4e9b4832934425572ba1dd01f91c0501d23ed04e29c5d4b1ecf711c1a9372f12f5d607aa0e2b65b4bfe60c7984a1fb8befb8ef434a5b296e7ee17144345f5b9a397ac9582779b12c429f2180a0b780aa8df016632debcf7b63133bcbf22dda6ae22f9724265692277b73220093861bc6738d4c951a9e4c3e6334773d2cc733ecb89f78f652e98f0d330b19e0a63554476a389ac1589c2a2145ec2b842a55ee86837074b6f45b3047320e0d0821ecb3963a9906cf300cf08bd3e56187340094a20a4a934c54d3fd3b4025075f4cd5c119ab579ba8ea1627e4d3c4202e92efaca716d6dea0ba7a7f5225f80ecf6e150539841b5e32cee456930e3471618b4cbefd6fbb5c9a6e783df4a82e2a40d1d7075e8f8c5956239b05024cdb5a08683c520cdda21523b7f4bf8a936f6398bb4150f1925393fd3366bd985561e60b72e9f13b28331221df168e7aac65c2c0757b67585617140d446b04bdf06f1a52ee7b22f417155a7e2c08312ebcb64ea047aed4fda381e5709fd265d9e7ad00c6271a6e9f73f1f520e7ef300c8a0a10207802204641390d0c8cc4655400c29f4d64ec5ca2046eecf157f6147ee00a0e29529ed29df7e694cb52698e970457ffd0ec1c7466923546d7c64264eb845d52a11bab72698e3083933be86708ba13293808d03e53e5ed0bbc7afea8bb3face4721c508912cfc1e14e8d697810ec9f246b003143d2c43f4487bc506955d99fca829db69e007f3eb6e391164a1860a2f8531c660a49f9d3f820d4602d231add0ebbe604399a69520a3a8f156486dfc5aed7a4971b214a502f6f0a577f8cca0fb8033e63e24a54a3e63bcf8e4ec331b04ddedfeeffc3805ff15ba65de4f8b0dcce44effb227807d951ce98aa91381e0add5216903d9563a747ceef99e6cf95ed5a653ff3808a4b9d54db3490b44c6e7b671a91a85d01bad138b02e340c7a41e9634e777485e9e897f64ae96a3f66e8adf11e985ce86e4f84cde7ac56de5f7c79f2e7dea5b7fda66e3f03005dbbf05645864673d46544e8690d5cae25e5e70e450e18beafa12e4dca37eec093af517eee2b7a69395cea4e2700f77fcca87abef4bfc95db9c8e5a455e7f47334a3f1284eeaa2c3b355ca4967aea16671b081552f0de205ecb68874b456fb5f671f381e0dcaa6ca69d94ba0d12040aa3d83629c9d014bfc70f28185928cecce55ac8e27d4d46ec3846fd51d0c5dbd9457ab8758e7a2ec8a6c04369f9592b00626d15b0a4b0ee2f92ba0d086c16d016ce7b05654b4f9adf90875118a656f2d50011707901982ebb387f3a4a49759f37a17183957ad0c778f6ecb780dab2b4df30e05fa81e6386f38c0f0ba3f37287a050d6d97287ae53096c391d5f20fcff73977239ca55c3657d1fd1f781f48e28057f136d890c28cc254324c8fff3862136861f956c321868cc66609470b7390ecb6ecfc63572d071312e0860efdcfec88c9f6108ea5dd30f55f253590cc6038a66b2646a24565600d17f8c6bab37b7640a45eefad11393a79e45f2bb92ab6e595bdc69cfc210f9f97ada095fbebe5062241c11e1cd0dcae029c3f742ced1e9ca3f6f486d9b5d6ca981a007a396bb5a716e7462642aa709377d0ea974fdd3f67b75dda8da1c75febfaa742fddcfc925e04df158e86669af2bfc88b1c8cc2c24db9399d38bd205509a49c8ba64c662435d47257de52ce04d2c4cc488c4a634e5792d3681093885e2d7e4106fef17114336ee5349f0da8563b6d24496ef0898c8b2873619c8cc7225e70ddd88c34e50a60bb83d3581ebd3736a217b74ae8fc23f36460b06410a44ba462ba2cd87b89adc5a1935d91efd550c94beebaa99984bc972ee47ef088e87e073c1e286b2f26a669095cf9d2e7b849ff51f279116be9ff7d6f45f3c95a5b6590e652f4ccb9849c55dc27d0a46e2dc9dd9a681d0dc6f293af0dcc3676f0c5a846489eb9837f6b388f003c0a8eecfd786d0f9bcd2212692135f2c1707fb1eeef324b499f19eba322215fe3ce19c9f000b698d2b2dab7145015046cc86d049ee15ad59dcd1564f30112e06444cb6ece06c01e54f4bc1dbbc9592d1467c6539c26c8cfe06cff51257e6b6a06952f415f3594876aba50ad2834095403741505b16784225ba3601cff4033e713e9caab6b3239bd5c2c1fcd22382b617f18df82a54c94b4569bbf2c4af0723ed1672615b9a8b7a67274b0e6707dc93bd17bae31407c026f197ba4e9cd3531578938cae5123d172cf4b78b61dbaceacc41c4097c49a0d63aeb6c97bb52b8771a82833e853e996036292039a42b6d97fb161c79ca8a5f16fc1696210a9f204c6f06710b5b05659aab5ad441192867d7b09aaa8584c962cc9fe020c93e7e16b83e5b2ab8d12f49cd75cffe2b279943b2d31397b510cf50ff0a923318bfb442c46fcad5cd4d83ec027bd0c4803548a8304dca0a91d764d2b82573f695f60c4b77ea9b9bd239caf741a5a54ec7adfb3f5a04072ca2414f90fed8cd92c8494ddada9716a350fccc1190db95c588f67bb037e112246fb75a31d90be62e39213e96f35e8316cffe51e3f905e9514c7890a2cfcc321b809f4b5e51a608f371e7a928cc28291bd5a72115830bea19999b01bd2baeb0395e62ebbe6f917909f70154376ddb51dbec5f034e36d5dd46fac798aa526dd4a5906902fa3ab5819753d9076cdc61437d9b8ec1361b4c0dfff4641b114cf3e6889e1b58b9bbf86ac50ed58c6f23a0472a6b9c21763956c16d11da539922262e0911dfb4a4f8437abdaf5faae74a82a50ae2f1ecb699dc40b8d89108ebdbf0f451701fe062fb7ffba4bede287c57eea4448af5e99d41c7d307d1f202af7f387f874342a29ccc9233a5c3bacfd754cb8d01eb11e2d43bfdc2828563088c17e618d413b0c3fa71666be5475a67a04803a8688bab9d038f6855537b4de42aaae1076066d00b23f4e1ea8fd228b87e3c7d3da2f42de4d143efd49f3b195c3240139452c70c41c05cedfac9ea8b891a372194d6aefd7de6617986914e2d394ce16307d3bbcb2f78b271e1bb19eba31c41d7f52d3f8530ebf0f0b44e3bf3421f96b9a70acc769bf4fd54e88fe6b1cf2b6287a7cf312bc788f93ba6018ad1415466fdbd2081734edc4580576ad943d3efa319f3e30c5908648342a4d0c431fc925a17913c622b10d793dc76767b0a77120b7521915676bd2896edf6e3707a +MD = 4d241b96609427aff41b2d90417050e2201b9ff5d7cb32852ba2f51178f7d4f6091c89a004c1a11a90f65d24324e1772 + +Len = 25576 +Msg = 79cb0302813f43ae79a950e0167832923a97743075e4cca8cde4fec1bab5fdad754453e172c0c4242b4e2ee620feb4d41cfd1ba9b90d74472633fc0628af404c5f31855ecb4a66758f21bf15f467ca9ab08d88146934635475e51147e402bb83c0fc5f2093c773c92a8bcb12999dbc0c7fad82188b41dff83f62052cf494b67b1f0caad0d21e314786f519881786d25410c6d05d291b315b0e11a05c624f795b04c92d159137e9182ac5721d770c5497eb413b8c4aaca1a4695ca980361a4b4cf79bb298d7fae2639e659e79c016890099848b4df7db76fcd9aaea3f76dc767681eaff00ac4f66516b3b6545fa8bbab4a1f988473790fa8ae56429422c7f4000291edef6181ebb0a18b18f292d552fde8b07f92312b3737715f02f305feaf213789f1422244f2ab52d2de3cc625b30a4e015a888902d2aeaf1b7c4b21805d3d6f5d66c2bd7cafb7b32192ad7a185052e278d5b1fbae4670c0221af705eb82d722829adba3a777683b0dc2cf1f0bbf5a5e8d6db9097c17204cf97ba1139eb460e99019e76533ee3f62fdeb1c359e54931ac58f0822fac92fbe07fab3eb18668d3d1c709082c0889fb358781f5e3eb4af9f97b619d8b8e1019be424b9ecf71d9e957e1b417cdbbb1bb4c3f632e96b53d265aa7f88ab24d3485f04962da9a95e177b3b9674c3c41a35dfb6e21167b2c6ddf54447bf1acd34668fefbb8991bd8caa56eb5ec4f8380a70acb7c81569936214d71bab37982068ee971bf14845823da9d0f3f0ac7aa6205ea42d14c96f9bca098387168cb3bd05431d0ff40425b5f5b841ebe885cb7ce0424ead5497da1a733e731d2628fdf18df67a322027c2c729385239a2fb7b4abede14bf142b49bdd2262e543686c77c678b4739023dad146cbc5a73ac780a8e30848eb8bfde3ef48b533db2d440a0ac16740c6b06b0354c14a6f3208185e9c5d9d82540d44b1a3cf347f9bf9bc12a0f3f43227eca1a0bccd5aa94a6be9fa9701f4b60eddddc6c159e671ae0d992c414367b31bab8f581251419b79cb03fca1b7550d9f6590cb50d0142e9bd3a2fff69907ea2c56fbd45d34486f46912f0bc26707af910b2768591b06e1eab1a134c6dd1d00e153aebca560b74a392333cf03f953c36c396844e32204b024115c72baf7f11cc20b70b7f3bcd656dbead7f26b558171b6561d08f6cd56c3d05a9d62d9d0cb6758e6086d4e30ecbbb34ee5190364d9e3f9ca0c5b9a04434376f42aac2b4ef3092a4d4087bea443a14ab823eed20ca23ebcfcfee6d8af14589f47cbf7b85ab029c1a6dead4b00212f268e5b19e03626ad8856ba51b7b61229d2bb4aeb89dd4cefa35aab86fe2ccf8dd139534235cbab56e43f0a43400182df97b86e31a5bd0d845ad26fbbde1195e4d322d410dab17a61581fb4647a78afa176a6fe7114e43c106e75f2f3f395ba5cb2b0a52bd6d2dbf76c5f815d6d04e098f8edc352df3820ba65aafbd746a1881cf84a903c31141540a96539d6218b5ceca4f5857d0da303abc9db540fde1e454d2c5a5bebf3617263969aa4769ff66cc402260b9aa60c2b0b216fc342c4f23a16d747cfdf25a03888bc6689e6ee2e58489be91f50b35ae101f6ce1118fe07afa08079b4c1cfb9b0d9a132b2ce161a68a2f6a487473a776db5cf60063b9643ec12af58d238f793227bcf64e5d420a1e4f79cc10c28464a1750348c695093903895ed4cf0eda718d699ce66eba313ad137213a6769bdcbb27faadbd0402fed5dd51c0bdd887e62f1359249e8ce1f7253e38e5bd8d4706b2e4dac3589df6defa216db31350afbdc023e35b768f37d4f0ad74996c19d5cb179819fdc6fdd73be64d124bb6210d32b44c60fb54be4cb3f8a84cb81de1ec34d289dee46fec4b1e83a867120e134850f1d7f88aa2dfc99b2477e8c937ae3547ccff52febb31fa8eb87c958f84ed091c600cd292c7bb55955c6171542248580eeb449dd613968e936d0fc34a7e79f7a0e932179a2b1a99a888af0fe24577fc91189fe6f1dde1ac358aab1acc657dbbe37592ee2b36c43cdc91aae9fa0a03c9d73c5755d982dbfe7df896c29ca2c2fcedea7580cc5080e7395d972824d8b369e83db514156b4c2c729d18e2429b1063c73221f505e11742c8d5c1f3e8185081cc0501482dfffcde1c627ba247ba2e987833df745e5152f490e16f73cf30a2bc8b7a831ca9a5b2bb842f052b3266e64208d7f6256008f7a6996ae8d0608971bf2e8682b612c7386bb1ed00a58b06fe098004b031926fceffec567531248b8535bd10483ef0cc5497ab82b238db043f97e7a453c07ceca1a8908f5ebea19ea6c43eff1bddc91ccfe77bd8640aa8c77191459e28f9a7e836488dfbeba1612b9b14bb3d44ba271f700228d65d467db75ca2a2da77059acc5688ec8464ffec982dce3bb10aff913d0191ba63e712df3cc7700740880cddfec910b4111003c84f249ac743b7d190de483b3a69489658be7ca37bb8a235f9e85787ed8938d27fb6481f66db925aab6a0fa9afcfc9fc6fa541e4072a0ea875f0c896a0d62497993760062061e2c26a491c82217db269ad59dfdbb27e158ed980e3e4d4df1c789c3936f6fdbdf03155e3376f995a4b0798421e2f849cfd0faeff711a918c689d1224909806d804cef5a02a181d50dbfebac9c588856c0e527bd53adfdfc54f2f825f3794429865c1d1e9bc24b846ac769b549e90bed79280c86906dcc7721a567554f391bae65d337124b43c6f250496c14d6fec36c3cfc01e259db8507b1239726a8b3774ab324c5ebbdb074cd32c86b61a0147f51a0e3b0370c71c83c87c010109c9307acd2d331f14f92e56396c6f02251c4704c2971802b24bb06642a3d5aa997321d43696113c99d658953f0b792bd487946aa5b280a054f21b04cfcedef68252b588ccb50d3eb0392e12ce53cbbb910cd72fa9a79b67bc8406625844446c2d2e92a079d150acc3eb57d4cc8a8e3ac371b85cb8bd90de53c9188ac64e2e9500cf60232334010e39b57ce323f9e92ed17fdef8b93e888d8188fa83ff34c4f764fcc81ab42449ed7a5d4548b9e8052125fef20b9370aafdaf8b5355ed3e301cc27f718c13ea50cfeeab590a789f099a26b69b9e309c1fb54398cc0977b4978c801e058128ce3d3ffd69613146651e223c6f82b777090e3da7780da584dd24cd08a22902db1738c20f5d04c60d846c40cff04f615001a01e41f3bd34fe02fc69c0d28715140f6be28c50ebd0b4421a7c4702a9a1a3cafddf7bd084bbcc6b4ae81278c7c5bbfcfc26dc0bbe5723e8515e0d6d388158ad4c08bcd90c44d66034d0655a9117b82713166753246442bd386f87f9a50858f2b6226bd4fad60429e2ab20428b15f3d8d93b95f3c5fdf90bf8361e6d983e89e162b4f28af97a3e0d7d00adf660c65557751ccfb14a2d3018b83b3a93b82cd4c27846b8c3af376c552d58733eb632c4eb10427b575bf9cf2ea1074431aed921dc22602546c415764a193adae4366229ddd23303ab9f6bbe93db21a210214e5978868ba1dde11c44316a2e4aae875d6d75e279cd76bf8ae58f8d11bef8ba9162decc4e944eae55be5547bc2b66512b76fb699c437f625e2c6cdf60ffb121ac26561d326662d2c7cdfdd96de5d23ed52eb78e22cb9031f07c70fa95cc02fda68c28a1be7fe1f67a577048c8e0bbf4627cf17a95cf6fd447bbe506388fb4f7887b9b7f7a4893c17745f7bb5685e81bda47f0547cb6e5f26bd3112ad2af8fb659ddf8e0ee2740dcc580da5a9d3a235c4679fd4560e8ba3365aa3d8fea945be3219987eba385afee6cef614e2768325fadf96075c8cdb6413c2ab05d08a6e025e99790c920cba9a07579d4bf7c78decb17af610b3ccda1c1f83ab4bbb44de625b8bf5ba1ed5ff69ae7087ad422d0ef488c8348304450425ea2c18fd177f1348a96f9309c93ab5e83ca839cb6a3da2d80155d5c0b69be62be41a98ac8d8fa93fd8b2d56e29915a90327d1828d87fd6018b925e6c5327fc989ddd9edc860d0cb26a043169a87079ec405dc748054a04fbb81c32e8528fb3f687f3900f895dba4acdc23b8ece6e8066b6c8bbab7942dc30f731f7c74d19a8c022db10b810183e63848b584013c20a9a364c69b5bce0b84bc9a2218bab8c57701f129558b2c315871eae2c10114174f12f67560948ba25a6bfbb2497e62e2ca0ad389273d9d4bc300cc90b914f334c06029815289525a0dc4a0b859e8595b4bc8dab9c9bfdc3bef8cf6a8b26063e1c33606d0b663ab9b646e901d8e212496c3e00ea1833a7167a4be6e13f510eb86223c934bd7491ecd2812d3c731514bfdf9fd772a9dd6e539aa3e3eb7ca4a1489a319dadafc643458215772a0899f56f6b7c51e3a5ebabe17c8b36e7e783664530f75e3666cdc74a417e6748fe034ceebc3e00aba0f0f876bc8c5044f49fe654c2dfab4d570d86719d266e17b7c383b43e6f74393f8fcc59c701d0a1183c79fdcc74e5711508093201980c14ea6d22366e8b2d2 +MD = 1405434caf2b81a133c800119e1016be5f57ea1baf92d681cccef9d27e1a954a2df60748a19243ade40d0b99554dbd81 + +Len = 26368 +Msg = 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 +MD = 399a7a212c1e8e51e644df1339d2e02006c1dd8e51a0c854217532c69692bec120dff30d21869fe26a4f4a0d86ebae3f + +Len = 27160 +Msg = e881e908d46879ce673e7e64f8d90cdf5497953a9ee75df95a0b2f0dc41c4ff8664eaf31e97565ca2cc85d5093e54bf3a216e4e6cad34e098288d5c69a98df38cca12293950214c0439aa3474ed32772ebdf95b0df42f537919116ed647980894302aaf57e156df7d43db911d1aa87a65a7b0e5d863d3acbafae5a4cc9c71931f3faaf214cb958b908370576c37252d51471b9b866ca050c036809a9728b9179031099dda8f3bd4c0612f13ecc3472484449fd8828f43e43b6468bcd06cdd2a99ccdd0f23acd84f9f755e43095f7ce47108c419473c0cdb8efd148802e93c309e5b8bc28a94e960803894615c6c34e19a0c1efa5f0389ab3d78fa98992e74ce10759c6469d7ed9c151357eb507a0da081d706e8346638e7c960a14b2d9d0557829385416c066366c0ae1f6d8fe975a5aaf2226f61e498f5a53caf2c1ac57c61774ded05eb70d95505516154656afb6587d5d7fc620f386973755ac7fb282870610d2a0e72d7cdfb65b5a43c6b5f1d64ab0ace1baf3685c796935a8b4945b818d249c2e79c8b9fae64438e822c463a3786f94b49c40b0f74911f25028f9ea9af4d8c5e0dc30ced02837356c202a0f0329e39f6032aed4414e59120ba28a36bb8255d420d70ec248c45cdb38898ffddfa734544d45e6db21d2671f40ecef47cd80c35155330a9e4901dcb1b2249d342038893be39c8fcd7e1b63a159cccf25b6364ac4e6b8cb69bd29df3f43bbfabcac250add8b0152b34272761ebd0bd2d960ec10b63d2efa2b8b828c0e53144e9d6db6e1c1ab3ad794541fc820d471a16ab1ea40afc15d3eed9b550ca54bf942df4a323370ad10c5789c6a802e06c5e4e093770035da0d40b6d5e9878c91307d8b2ae32b70f74bc567029bc6d1bbd14243eddd78d2f005a88e2188244c8f81a8a9f70fee4bf3b37e6a6ef9c48f5b5b649ca662d20d6b0e1d7d67780b6cacb66b3f98ffa788070f9988c8cd9ff34e2cf2f2a84f336eb4f0478c8f0265744f956d57f5fb7cb09d29bdcaf85f8282fc0c934edaecc57e3173cfc2816e5aede2e857f8f64a954a1cc79336e6f793c6cec2efb72480b0c44b5e5d282504115ecc75d02b83361bdeecb2c2d77bddfa462a18af356e551cc96a7b98c4630cb34f750581f7840536f575b2f3b29d58e08a79d47bd0a0b13013f79029a024cd6748455f1264e1000d161e8fced135b26d1b24bffa91a3dd142c5866b7c44e9056d2a44d2a7a826fc9c95110fa3b2c31c88091a1d57f5d21f19cf7c5eb36cb9da774fa9571424f9a919676fe20f8681e1a412a42b4a3b7c4efe93b756d00813c83b7af0091c331c88e06f321e711d3c18ae756693d039910359d8b3de42a5ab512222b562f050e43e8a03141f88d546141f97ce01ba9ec4bec3f51e6f9ba3d4f7b3dd65ff611d051c6ec9826fa74d24766ff066df49d96be3b58f43953ba1153e79019e28bee5d3b5073919796ce37bc22815bd971e581b14b6fdcfb9b31c0097da45aa999a49f49b0bc825e74a46a069d08e3eb398b936b430c71f7782831b96600027ac63c7cc20b50d4413bfd536dfe1b066df597b6364cb81af493a64cabc92c7a1ebabddef08cb5f00994e2da3b6e432c254c0fd1588ef942b993b3f927cfb1295d1e2fac1958753c7e265ae7b61407bddde7fdcc1a305a4e0f21572074a01676fe9a9bce869a1822679a6d622819ef215b6d688fc45b60a7bee59ba9db63e3cbcbd5082b7f7824098d972333d7a483c0688759019e3695b58e86867ca441a18f8a787ead4b1a2359b9c685420cde4c03cbddd70cf0ea80e047ad21821761d729042a053b34a99c79b1ce9a770eeed1504e16ea97019ea991b00173a17bec0d030194a6bd804d18d33d596bbb27fd9a10b7da9a8b1a7b992e922b84c21a09cb84495e681c782d1ece270cfef49d3330accfd3f0ce83a9d721b5d25cce3ae19a14a32f543e647236d236915d0cb9b71a8a5ea7f349844febd0e19f04ab249b011bd8af700c8c43e847319090e9c3b2e0142cfeace465955ea5de39834320608901b187c66e37c9bd96e1b09d75034b0bb1008121886da4b706734ae17c7558b82ff35f5e4daf2c3c250e9a8e96c0ab22c8a3d75c1be5a47e5d6a7726406daa190b69de3e8f3a93ee5d7ff66b3644f9adc3dea9658615bd3c11896a5b764e7f31fedaad701e212659a6fe6b3a3cd55e3509779f42b24515778a99cb880661fe8a710d74fce0ac0f076951a10590bc0241023660fd86bdd7ba306141b3d7ee50abcacbdae8bf2273800c4141d31a410c5916e5959ee9c4298a6bab75e6d33d9c1c73dc873ea2cd7d4af996f3adc2aba505ad4ae52bc5a43371a33d0f28e1950b66d208240670f352ef96185e9a7044f4ce2f2ff9ae01a31ef640e0b682e940c5105117594613dd1df74d8f2ba20c52223b045a782e850a12a2aa5c12fad484f1a256d0cd0872d304e885c201cd7e1e56d594930bb4392136fb4979cc9b88aab7a44bfc2953751c2f4ca57a8924aef0b92248a45a47052fb38b86ff8c6aeef9409f976314300402c7aa177f6bae841073ac86540cefd17eb1dac7b5f971eebbb41ba2cd37a507cbf48b42994e73e9c5abfbb76acab48554576e7564bcb771363b9ed40239bd66c0dd768e90da7cc358899544af3b9f09facdd1f9d47d445db4fbb295c9c47d0929abf3632bb8d0fc11360493eb08b745b83c8bb9cde3219c7b1fde4dec7defd94e858a293390777a38dad00ee5d80521d5cc221f17965514d3cdab64310e1abc7694c44871097a27159c7f1c67548f869ba42092793fe8af062d9f42611f069beb002828aacce0e9f0a59b2437245f5a50ed0d79bd86e3535b69444f4457bc5ff3f03f32a981b1aa101dac901eef7d873dce6f3ea9124dea19a622f4a15f43eed78c8fcc35cff651be2b38c7e45deff3aa70d048068c2e5b890fbf9741dea332dffea25f155eb6c642f7c9315117bf88defab7ff9b9b8e8ef3c9a5a2ed7de512526b005412d7f9f1e4aae6362dc5f52c2395adcb32e8766b9fff5c7b6be410757afe2f11f4e2c7baec6c183e3f0f97c9bf693914911aeddad4d76a8c83ba2c459ddcb90083262909a164e5b1509baf46fb9de34281dafcc3db79593bffa8426904302688864c26c64cbbd8f72814448b1f5a33bdcad0aa0efc0eb1f2a65558c9f720fc10c7fbc7d9359876788f205f8073c7b2ee34a3ffa37fbef8183f6a794dbdd4c5020cdc132aa424499d4d67070d3f0de73b87fc036aacb0b814938eaadda07508c51e9712a1e187d8cc2992441aca535a0d8a82bf4ccb0d78506a6af561e62b4ec1c5d3cc2733e8ab6eed491e8f5dc294cd06de3a2f23fcc1338ba561c1d81d1e5ec8384aa2e46f4bec5f339e5440821ce1c4b77cfdfda61a25c0e8f6e5be740004f16f93fc3a463fac48f9cb51bbba7ab389b68e9ca1330b8ecfdbbdb5e0577c1b0620af1b7e920f186f43ae6f169237a9208377f657ca1cd78125bd1a85ef1b0bd0f3a7e9f77e44979eb84d949833da2d50c53ff16793d6669e6ffffaf764643c178e824cef2f65909b00b2a98ac5eba6e024ef7718b7c0a4ee60893f7cdde017a39c482eacd0fa6d2fc4e597346ff37c994a8e6fb45e63f938a165cf5d8215023bc3017677878b9522acec44de5a791643dc24c081af45ce46d99b94e27c8d66a9abb60c987ca1703c5fd19ad0ae05dea685ba54c8d3f089deb1317452f3d0acb3fd6fd857d9c36645869c8051921f3b89eb5612d0f2ec94c9d13159f70e643a226132c1fcc37adf04c853ddab2e5095b5b603e2e332bf55cfe0a22a17f6d37abd7e09b2ce644d4342ce009b24ab1f55f38fc6ac47bef336b7878dcffbd3a5d24efdfb9016e4c4fac73faaa1053115e1091ea95845bc109d4b6df92febcc60ac9b8510441d6b676c5bc45ad796e7b8a2bf0ab3cf25559cf4513bee342e098e6f6ebf51b62820bf02c60517251ef69300dffbecf72fb021a2929875c50eb3b6838d53c5ce822b5322cfa9e973e7862b642f9b5db9abf6260fd62d94cad1f26150c0e8757572b5ab354059d8a937be0a34798f0dfee04e34a3e5a1552cc0ed163ed12667913fe650a4dfbcedaf57c6b7da838204ac17e1d2c6869dc0d123cd5db586b7a50b32e5c9d6757b2f6d8fc7babc161a4bac98d688e083c9dca242b9be1da94037cc93db9e32c93da7cc26e99c44f9ffe9e7ab56de59a2ccb18764dac2de006c23bbaaef5822a5ab5bb26653e4d8f6dae64498895d99ac4f4769d358f06054e073bfbe4a7e0ccf6c5508952e1ae2d3534baaa6968c0868f9a72ed55ad10b6c472fc21813985a10299db7fca1c6c959111f031ea6f30fa073d8c0b308eb4812475dab01732f73308a39a6e3d571f550bd6a3648e01b141a64e205b58bc97d0c880762bf92cabff73633bc91f1a2ce80fe352b6c6d8b819f75cee7220bf01423b334ce9a97f1a62dd693e3501ee2bcb07d87cad274cbbcf74ea34d44afea731f70edd9dcaa2c9099115f026684b827aae268fbc21e642fea96691e61a03d04c866396acbf504e50490a1001c4aac7734d4e0a68393dd4040f52844c206742de63e206ab19d000d36fb60c7ba99461417fbf8b35efabe59c015e9a6af08145840a0aabfd4cda971f7f9a53e88980f661b00b70a9b7b90e1349bb32c6fcea7ec9f32e0527dab85770f32774dce708ed6078b26938240da4062328fbe4c81b551cb9fc90bf35f1e88454fdedcd3484bcaa5434b375a6e24dd128084448c49c4ee8c8d6dd28012fc0d62f8e2d3e049cfab +MD = 4f20b8ac2926e6feadb98e36c9eaa74b368ffdb545a83323dc0cb862378175e2adf6df26ae3bb1c23cafab91b6f9c198 + +Len = 27952 +Msg = 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 +MD = 3dd340c35dd5a88967b66a5602dccb8ec44478d76662a1e328ad5a93ba16639ef7da57b175c9bf6fa2b11e006dfa6ac1 + +Len = 28744 +Msg = 9216bfda38412a0f70511159dc73bb6bae1f8eaa0ef08d99bcb31f94f6be12c29c83df45926430b366c99fca3270c15fc4056398fdf3135b7779e3066a006961d1ac0ad1c83179ce39e87a96b722ec23aabc065badf3e188347a360772ca6a447abac7e6a44f0d4632d52926332e44a0a86bff5ce699fd063bdda3ffd4c41b53ded49fecec67f40599b934e16e3fd1bc063ad7026f8d71bfd4cbaf56599586774723194b692036f1b6bb242e2ffb9c600b5215b412764599476ce475c9e5b396fbcebd6be323dcf4d0048077400aac7500db41dc95fc7f7edbe7c9c2ec5ea89943fe13b42217eef530bbd023671509e12dfce4e1c1c82955d965e6a68aa66f6967dba48feda572db1f099d9a6dc4bc8edade852b5e824a06890dc48a6a6510ecaf8cf7620d757290e3166d431abecc624fa9ac2234d2eb783308ead45544910c633a94964b2ef5fbc409cb8835ac4147d384e12e0a5e13951f7de0ee13eafcb0ca0c04946d7804040c0a3cd088352424b097adb7aad1ca4495952f3e6c0158c02d2bcec33bfda69301434a84d9027ce02c0b9725dad1186ddc785e2e282eae23d4be7a8a7f62e390edd97c0af1ba5165900828e0630606f83d4df5240e1b05c307ee9153ff52c3e316f75acb9806ab9a24b5e6500d1a9bce003c7d8ae77065870ee39a8584734f75c5c36d2f958e93672f3b5bdd9fb2e0d56d6f7dc77bd4d75730c41d87d66d8e2c41653c9fb2f910b4fbc20ff0e379dbf6cb0b7d4392f0611bb7b9a2c3bde989f1d4065081b5f02b69ce7189ef9f14961a643b0566f46c0ebbe9ecb2a0018f46adc4ce2f3e671aeb6ff17051449c2e19277e259e9868efe3200f82d4866906cf465ae4633f902058acace8ef55a26d6a0762f1cf41b821ea3070a691ddbff72ca6de7174ebf8a97a094601eb8c797993a058c821c9aaac2ad4567e700ec90963b3989ce8a9665e5a6e09e2ce50e8fb9cdca7d21b980735abf50732f97f50e57e57cf8e49e3a4e6ffc43bb42008b89b8ba19936451696677679ccebb4991b328478cd6e1e0078eb71f1259e671eb1006ad9741d27ac21e7924aedd12ac4f4997e00d865f068ab12b9df0fc92df99bd3406b81ae4ac06e60074eb20be269a1c273d6399b46820505de74405cf9013ebb163f081235bc4778de6f63c264eeeb546be23837a8b84d6ce89a0280549e6261f33d5170700672d71e93471d39bd9af86f0c1c629e714deee0389b5dc538ce6cdf4da3f18408b726cfa4a745e83c7655853c2f43b116cb34cd36541ad4374b85e35748bdf828e00df989cb61f9d54614b85ab703680d90e6b77b75e00903a154054386fb54d0b333a52afb9af5efd4dc0d4efdc94cbf64aba6f146d6ed0498804ff9a6d32167fa41db6f7f1863f1e6568e0049bee4940e2ba37f0f2507a3f7b2c961ef6ee5557bdea1409e02cb4545294259e309b8f5580fb50d17f4df4688917a64abf42b01ffb30185a280b552b9fe313f12d4504808ffe584a76cfe5711c66ae8208d78d54d680226d1bcaa800a7d649b1f4435f6e7a23aca07b5eb3c5bf8a1d6985f56382fa4ac0b74db3137ff4de2565283ee68bda1bcc87ff62e5f2ed0281759954c926b0f081dd208d3df6117b356f3b9030552a373665757502652f60691ab55e34cca521d42356917e0f882e0854a0dfc346d51688dd601d8fb8e11432ed8c7a1cc1415f463e32685a38c3770ca9fa8625fd853a223451c4e45abc9e8d52715117b11ff93692568a58ee5dd6b0c39b2bded59502911eccf3b6b72c8fb6edf64b8c188b9043a4357000aca1dda3561529346b9f10640134326d7a8b387e049df200743eb4fc0851a1d80059fc42c5fb06ed2bfdd409702a097f018359115adabd0b3083c7ae133da84565c0a31d97bf5d5f835bcdffd000d161e89f423f453f3502fa0548f8794bebef698072924fd495123e138ec5c57b22cc9c298446582dd29e1d3dc9599f1ef52c6813db5f52cd369b88df76d9b4db860598ccafd508391e233687c95ff9294c830de55dc3451bca520ffa16da22b473b36af32559d9f38038c29db96a1bfd6a99a79f6a7c9b42b8dc300dff159398644c9f37754351bfa1453dca2a067c0dd7c6e18c91c9c9d49aa09575903a8be9e0378204102fe42fe9ef24a78bb39dcd0c91384754696543e835bceb6aa7704b700acfd3a68e15b6d29d03b06f0ff5dd719f185a32a9d2031a01f2b9eefae51f7c4ce53088dc6ad6e3b5577f446a1891cf270e2fbd29a4b4a8abf37bbd835ee89d644ea537996812a5ee9c5e9c607a9c4dff8652445761bb3c8a1bab270f42393be788ac435371fc919f4ee8d771904fa65f1d4c78b17d991e22f7c2ebcd3373e05d0fb02c893cf72f4debb8961c0e4e40ec3f88bad67cc0f61cf44d5c6bb74b132b604b63a91d94d780ff1858ce28faa61d69919b24d3e52ccebdb4f95922015cd916f88941884832cf05b2801684e75e6937f18a2b07585abea0a45314284915ec9021fdd121a3c99e7c01bc73b696d26607131857abace8734975fa3b1e84e6ec686241d66e19f455de706e64128b9a8a6380c64925555e6314a44f2c9937384efc23e5cfc22d5babb998f6764d382f4ce9c5046e08e435349ed9d2670cf2929ae8016a3bc240580679e61518bb1ef933e65a6344cadc053e446114890e298e46a8654f98e31581dcbbe22ac9e0b290c605bb535bef9f3706a1f495e1015e73d8c9d9f675a8ff61b4dc17b80842957e79b4626511ebb0531433eec73d8b03fbc7a8d9ff408870602576e13d62753a2ad56eda090543c1e1ed76ba38cd0fbc7ea9d1efda88061b158508e93b56ed132e5fb19ccfb48c164c08e7016b3e03ea84e5d18618baa651ea7a0e9a22641ea2e17f1925199e395029ed114eceff0c00971234272a66edb7676ae47e93088e8becca020d9730bff1e41061ece49e8ca13d95565d900b50ae04ee4700fdb2b110c8a708b098fa946e12f975763c7b0a4ed105d493ea1653b85b6a92bbd2f13ae3ddcc99a8bf7a6b372f2ea8754743096c19ea1b6479268b68c3665429b3526067c47131707b3e88ef9126976485551e8b4098b749fdaa4c31e56817b50f44d63ef55b6c824c9591fa0157aebe874f9e1f0db814aec8103aa639f639f8574710bbe8d1a758b43e0ad8d8587afdcd811ca9d9bed02d7906cb282987476e1be78471277a7e8e4286482e8e9f78bcb8982ebe2d23662070ec624a4ca1cc70dd94c5f139cc6e8d681cfe4daca32445d90328ce807c4332503fb48f0bbc45cb0cdd39be883dd3c0955081c8bafa0a53bf40bf5d7c2ff3cd878f2668ff5d2fb73a3f743bab556ad26acf7712220a9750dbdf46ed68c4f47c97393c6a800b06dfe629e9eb0b89703d58f842dc7a5b57b7af3d43e0deb1c1a9fffc6b06462c479f812b2f5f3160a06bd049796a4c72c802b9f95aea569ce7f0321736beba578e90abc1a90aa56157d871618f6de0d764cc8c91e06c68ecd3b9de3824064503384db67beb7fe012232dacaef93a000fba7f877578e97e18119144cdb77f7ec5c11141b86b2179e98eb5f2a04b61026235963b3288d41ea53e011646758ce005d595ce05ac81cb5df71be3d3fa6560a5729b284794deb31a9573b340c2a0e149d245cbf224335cf5f8c9e0b89ad9b31fde18df33214be3fec483bc3b337e2b18439bbbfc6698c737f03a79dc81107257f479b063b2be29b8579b81a45c5705e7a6222e92e834629aaa082fae61bc16d432485c77cda7ecddab25b3fa81de0a3e765394343d88e794529d72ac913f291b33ff23ede68bb5e55bdcc3cc6875b08330ba7d8ebb28aecb9674d365b41c11935628b72471fc0d55d61b219854a0916c61c15ad0f5762096e228d2582ec578e3353f86ba045b6ba5965b5dccfb0115409602acc98103f58cc223fff285edb7814dbe031d223c496b3927e8f8bff9b4a629f8f3c6c2549623c2e0acd34dd765d40c2eccdc40113efd2b0b539a180d1813aa0eb0575dea7ae241096968eb250c71fd0c3465d27ca501e8702e3f87bd980fa2ce730998382c5ed8e8c621e25903d19cd0da487dc123effde0b947a38dbcf080b2bc3c25b012d00719439cc7d5f48968074ef29691343dd7e7b540efe00f7ce055ec9d7af4d70c38055248004e46ffeb29e302a16f4e62030f82b9c176f7fb2e12847c0c78d15a085782a2200483ab92b336f742bdeb030ba2a220dc951ef1e69334765ebeaa5fe46a4549abab2312fb3dcb2eef0f82776e4bb40475dced0796324d0ae638ca7458d82a9d07a4bddc812410380ad6bd55878508e331b0da92b98a6eb83769aa3dc20ba31ac883ac5ed0f096912a95e423f3c9412b94a37029cd05f9fcc6e3c222dc7f3f4172ba8710474dced8c2dfaf494fa2cd6c233736334d3f7f471919cab9f4cd5fbf7acbd6a77076495d6816675bd78c3e2341fea555b6817f25a28dfc69a760a4d3653a037ac91466bd9edcb4d247fff3cf954c45f795967a26f7a30fb860c37f2ba687a600dd92d777bb951022fd688eef71b280af66c8e0b99d1b5d3ccd707f36d33726e00a9bfc0a52c1f1e4847070018bb3edd3a6a3535be7396d5d29f1f5735fcb1e8efc7a44e408f5e29d6982478427e2f60ad1a0329c7a9fc8a012b2a26fc0a5f5641fc8529322a35a9419286605faa231bb746a1ee9dbb0f78c145ce68a9a6a3405e100a5a6545cd28f0fdd6bf56884197c1b4b68c26f1f6297bb3b3262418a52faecbdae8bf284e2d4da1bb9e0f60b25b312deb0c4c93da25953e826855a88eab99f59edb2a1bdf41bf45de04727a9eef7179e875f6e8e2f279aee334249e863a8755fd3b8d65a8ebaeb3e6f9671d2cdce76054cf0c39371a8dcb7d947941b466e0b4a011cf4fd2b382b17c86d69284a9fdaad72375ce00253b5df98f3cda41b60cda2e64da218521a40848b1a722cfde1a1e1a781bef6699ea2bfe2d55b154b2738f503d9523e8be7a80f184c2123504a586c5d6e5e4910001fe3577ac0e16e37d9baea3e89c24116de020070faddda208a88045bbf4a8e1ea9e46742939 +MD = 478f747486422a451f200e63775b2fa32b2af6f88524bdf14a3b6bc8d3ce5c610efac145f76391e7fd55c44c09b883f9 + +Len = 29536 +Msg = 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 +MD = 6c3a8559da6994c513896859d491b019b3ea9dd74b8c39dc983a8a0c0a277c6b9a68b00a82772f48c873934690fabb3b + +Len = 30328 +Msg = 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 +MD = be2da5a9473cf79f41f123520e48c0b37d0b78af0e640f6f85892fac68489e29b9992eb38215cec107a29f95cca5223c + +Len = 31120 +Msg = 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 +MD = b236f326dcfab7c5ca01b0f0e172e77c53ff4e9c3f0686b0e60b91d7ffe134810dca596fa2ddc11827883c1613f74960 + +Len = 31912 +Msg = 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 +MD = cb16838296482187bce81d180666b720ea763b9dd3bead81134f8deec96c98bab0e938651e6c11e6fbd76fa241cec784 + +Len = 32704 +Msg = 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 +MD = 00d3b9396a09d37e126ecceb86f5db9e8ed94065646f4d3d6bba15e8318ca9f6d07e363d60dd863ec28ac2378ccdb515 + +Len = 33496 +Msg = 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 +MD = 4732bfd9941893d6597ebd157588b7438daf1df027172664f8452d019cf90bc36ec890c143016d38c2b8f763dda58f39 + +Len = 34288 +Msg = 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 +MD = ab4cced009cd42ca0a92339d0513667901babdc49182fa1d414cc91a48827429ad8cb733b93acd82e0edcd30d0ec568d + +Len = 35080 +Msg = 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 +MD = e1a1e25e96b2ef7504b76ae5adefda0114c7d4a7a6c6796745ba9c9d204864156b3429fb9b9aa1908038f7928d48267e + +Len = 35872 +Msg = 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 +MD = 6f07c911878a86e57375528b8cd2adda91e11217b8c944b20fb1a4fdd6ae52bfeca5d4f929872196a6f17aa1af942034 + +Len = 36664 +Msg = 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 +MD = ae3d50c6b6dffc7062dcfb7788c60029a467c40b75e37f0320f001c4588e83024fe4be1cace1ebd8b1da1744a920546f + +Len = 37456 +Msg = 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 +MD = b59b1626d9b8d6ff9a35bb5cd69d29702dca9471a3140e7c2106b295eea3193a850ca00d15469f6d355bb60f48a284e3 + +Len = 38248 +Msg = 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 +MD = 757a852bcd6479d42065467ece8db9489f081568b54fa7d505ace1365ce78bab67351c10aa65fe0b8ce42291ec9d2132 + +Len = 39040 +Msg = 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 +MD = 46f2afc4632e2121e7ab844474534f44c4ad9a13a0b59eb86918aea1e16bb13f8e753dffbef875bc7818244a84e4e33f + +Len = 39832 +Msg = 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 +MD = 9a7e7f53e213c84fee6961a65064a3c426c68ce6432266158c60f7a3f87975386301ed4c89d222eb55ef6efd7dd23ec9 + +Len = 40624 +Msg = 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 +MD = be87bf6e103f66527b12a010e50eb157524c76f0fa7118ef8f0659f3a8734008f973bdadfcff5d84cfeef0914245f47a + +Len = 41416 +Msg = 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 +MD = 0310e51ec82c5fbb0d8a3a3e520a7a0f77504e0d4744f36b4d87e9cd9222056f45b591ff4f0b752cf642cf5859ce2682 + +Len = 42208 +Msg = 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 +MD = f2df4b7af9ca9da652b5027a6a68ed91022eda553d72f61e2abd9ab46038be92141d3b3dac6c0e2f87db9350019d9f1a + +Len = 43000 +Msg = 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 +MD = 2b73f1ea458d69bd87d55e2c055936222a83d927d4c4b1b059259633ab0b14d0ac62ddc4d04d6a6d2c878b0fa1b53fbf + +Len = 43792 +Msg = 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 +MD = 50e223e4f32f90fb64ffbfa33f0ea65841d75dfad19d0eefbc67664b546e60f5564bde3351b3d49df2ac3613c15e43db + +Len = 44584 +Msg = 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 +MD = 0a53523921e16516ac76648367b4a285bfce6b711b99e4775c00ec9d15abd092d5db3ddfa3560f3dcf47f44031e91155 + +Len = 45376 +Msg = 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 +MD = 9d7af269d49bab3b400d2b66254fcabe81cee8bd8d0d2b44c3393bebcd776402746773318ad6509fac19c1a538491094 + +Len = 46168 +Msg = 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 +MD = a4d92c826cfae13d7a80653023254365415825a6fa9810dba593ec73f6560e0bc87fa9e5eef2e23076ad5214605be3d9 + +Len = 46960 +Msg = 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 +MD = 7fcf34ae19d002775dc86151d66094e11a187478577687c4ae76ce6e2c8666036d095c3a93c1b4332f6967a65f699f0a + +Len = 47752 +Msg = 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 +MD = e796373a85f5a0372d9d6ec70acde59b60174d4298718ef9b3eeb0222fc6c182f04706a2014f8608592493c3e7ecca4f + +Len = 48544 +Msg = 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 +MD = 1a93eac31a9802d78492522fa021b98711d9334434ff3c45d8f3b441e1805e08dfc62237b1152c4b392ebf85ac39a04a + +Len = 49336 +Msg = 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 +MD = 55851677287615c9f5cdd01c36321a3e4ee0adc7aa8db055a7014b1eb8fe19b09d643ddbbbef874f8c80c6d1e30ab22e + +Len = 50128 +Msg = 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 +MD = 3565d79d701a8b0dc31fb0d7eb545dd3f968a7e23b8a5bf09695abee2f1c8370e6d4098b234189c38bb0f3ba2869397f + +Len = 50920 +Msg = 146629e70b37d8b83ee828e2b001cf55630e7c131a50bb8963b3181fd500870e9754037122d176a04793d9b973e59c7f32b54868f24663f10a259435fa5e07bef4ef139b9c7d1ab20d46b1581c57011fe0ff6def72837659f113db27c9fd04383521a08b03a58e9998eaf9e833bec8dd76d335d2226fbb682266361ecb46462362d1f469deb098fbf065fa904182b760fb18e6368a73fcc7a404ed42869f942881e7555eb60601811ea1f979cd0a975177b8c94533f5ff1d7fd748ba8471b7ef9c4a0c92120f90d2298441ca5fc02f57f29a2627a45f8d13bbc68eaf4d25781fbae4612c7a320f9719f819ac7f0b491b75a6450465176e5161b8094867219d60e49c9b5476da4477f6e4c847b653ab4407c46d03ff876a7e7997ffae5ccfee5c215a04348f6cf91bc92f97c28b011e7bb1dce84cf9154942094ab908b49635b87906e2f14c51f42a9ac3ce46877b6a687ad6fc08db2bd2471bb97f7ff5dd381ff4897eb636f1fe4d6f87b5fa302a57b26a9af25f2e30ce32b6cc993ba90ec0379bc920a9d3b4de2c526393071176ad0289111278788c06aee36b4e63579095a875af10f2ae035e6e4a3fb294afc833ffe021a37c44a63f61a97ee72088cb7f1b8a2395ba4c4444bb5f0358ca9486b25276b3ef9217e844f310edac99c3274638e30ef82937e159bd9a98ced1471af3a253b03ce37bb9dc0d20a0e5f7900cb1a687568266f640651902e45cd050eabb9880fed397f781ce57e27fda6177e28a0e7ee5789a11cb307aa0d049ef3860d5dc0487fcd514a9e3785d73d30001119717d1a125ec10e881867a44df5885e20815e731fec55897e319996217fbb501a16a8774d0857c0121e59b296430c2da1beb32e623904db496e19f36ef7b1c1a6faea845c08cdd7dd940086521a274afd708ec8db15e7b68c37976d5a3a8bcc5cb8c3dfb3e2ab9c46f3fcae25ed325c904111d0ef156691c348826297ba920687bac4d8092879a3eab89ea8663ee5c906ab1cd512ba19f36afb7b818bea7cd6d48b5e0bb04ca075357c7703b7719a26cd08e053da766a520fdae338cb6c94d3afa50fe94dc1c896b39a062e8e37c7ec5ff50ccbcacce0440e6149f6ca93826395924b0f361a4a7ee1bbdca75f0417803c0a02bb683014300319105a0e01be3d02cdafdc0dc8be944c3c5afc9e38d188ed92629117526eac7a8cf6c0fa39b09693d19eee395f8d7d5f9611ace078be7ce1289ceb6c86681fc1173dca33ae0226b528a8a45d414fa098739126ba3606c2c3571228dc4e8910935285d43ec11b63e34d4d9cce106d94934f49f88fe372f0e08882e7eb3d5a155dc94f8d702574b4aaba0e36103f7fcfbc73bc90e6136b9dd5573f972db543a48cd5fb448c4d96bf67f96b1ed840fec8909b599e314859102e2dd8b4f868ee34ad2329a7c7ac09dac775d4a56aa753059c20b16f05f4d3fe3776cedfffaaa24c3b1b5b05c6c336ad45c9eb686be5250d5b9e4491d8ab64ceadec826687fd1851b338f00d0e25b58d4f600fe6307cdd563b8e93853dce73f7ede9a3e745f2b8fba206892c1235ff1150d2c29d7cf0f466d85c2ed789e09a0063e8a3e0ae0dfc90940ea6c157868bdff69c93fc95c402b5ae91670751943f8ecc73f2d114c16bc6e5bbb98b6299e43fbd1804920f8860d92ac8dc73392bece9741621373e9f7ee5238831e8a7e280b6f0ff94dc6e90c727d96d0fc9954a1aa6f749af91700abe91ea0eb047bbe2f9dc4e9db56a277f8e5836f87178ea61514dc2790e6e5d85935385b9a547033da826328cf699cec73eb0cfe5a1efccf42954624ece2c5bb2a580a313a1650235241b2947c909c8ea40e800cef1bca184fb4153155f59fef46dcfaea705005d7be621bf48bd28aa7b4d54761f115e0c965fab11773285bbdd449724de60c7697476d0511a3384e7dcac8c9c50615262aabee839def82e16dfc25d92344518bab15ebd8b46dc8d1580f706e00d62284824a18f18d710b1947e8fa973431282c5a4f64fba3908cf982ab549fd90a44e21b690064aea0ccec93bd4f1448569741ed1e5ed8a7b58caf42c5fdc21a4a83283b312f45c725cc4098a6adb7275ba9b2aca963d68784cfdcdf85f141893de83e2bca2cfaa1a714ff9fc99bea98e76367df19fa5d0da45d66a214ba82ef8c7a0c335b7fed04cfaa0ff04ea11565a2cf49ce95acd5ffbe3e37d39ae0ef13df427a9a0cb184b745985ad35e479e5436f43ec146ffa626797b35ba3ee9eebfdc4671aa07492984b0e6c6902116ee2e48da2fff537d394a7e1a4a9e295fe9b92e90d7a971cf4331b99a3d6ebe956dba838a05d1e5aef43374265dc983c947ca7b2896e075cb3a8707bea6b65d4d83c28c0ba67f241940a804a4558173b070ba6c14949738c6754e4359e8b128c4990c0e65fc5137468672d69e1c0f219bcc51a85ebb16e5485e4e1474eda445841562afa1ee8e47bd2c59911b99bbb612c357d80ef1a4a2d75c4e23169cdadc15618a17c663807b079c25de24b4cc5a9dbd93a32a208a97fdd7181747dd9a16fde34cefdc456dfcab3c9e64c0558c34c522ceb2bc2f11ee413772990f982b1ac60572dfec7b9ef131768cccf764416d115ad0accb067ecc2be5255177b5d611f72ec28efced5b8322b1b6bdd1c9342c0acd613a608d1c5b4447f9e6861de32319c506a51783ecda0454e5e0576cad9a36e3490482ac32c313c6b50145b69a77b33404cb4225981d62c9e1dd9036f3df1f054fb1394b072c21cb2349ba6942364de285a987bba875c177725b850d50224d993de98d52e4bdf4bc0967ef1f2587703750e7ed2d6409abc660023cdb0a8b4709d95687a9119e16023002ecbe8993a29b2f2c7c631402a71e727bbf866a4495bbec9e2e38d6f80f0660c3b72fb7826e76e8203d4500873ee7716e16f7b872bf193d698be87bf3652f60515a5bf77b5930446c37bc70c1f689268247173c404d899660a49f47b6a2e4fa56dd2991a6ed310bb873aeabd75a6c56605ccd3ed4c875bd2a8346836a4d8ff4774680cc2cb1e205abf705faf2eff9ccb05c000556b8447b7030c67836ef97175e9f4af1352da9f9eecda7a53a3f964f19509adaefa35e98dab1056b430f642bb3f06e48e8eaefb129fd7ef4d6d1aca6433f8205c6132bdc0f10eda7b8355ef81d3fd4196e6f1df3038d702eef2da49ad731a0ce058f130fb8556573beeaed45459664acef4499882487679dacdce4f37d2fdc7cd1a07ef87c8654167db479dcd3fc064892f2cd3835f24a873665d679dc3f1e5955ccd46004ada4d91c1e6a836e7aa2377f001fcaded70135b450e1f39d6c4eabb69e7d0ff8d13c04c4ad2803be1620bfdff6f908c63d73ef4f266c2b67bb54bb1f9be1cdfffb04df9ceb1b246cda6829da5dc2b8962c8afd2f6de1e7e33618d1b64d6862c132e4b1cd5fabad20ce62bd97bce2a3f5ad2da67bb0a7f0b9e48335a33b7b95e77ec4c47e91416881f9f7c23f9bc1918cc644335c74260e90cd7b2e0fed802f19e78c5ed80a431b38630d82f982c74a0381b8ecf943c60810fae90522ece1f9fe7624c803511b8fed148d43eefa5c9501e66f197ba4efa8e272b60303bf04b83f32744a26ee2f8c4715604e458ae83b2efc5202092009b4ae3dc86ddbee53378324652b696ae9daee6d6ceb27bbd30533cb49efcc3e7cf51b64098ed102343d7352ddb5f54cb0408b249b61bc1485b8b85b3d27eb86b033d2ee60ad0e821191b7c6c52ef21ceb87c643d4fa2b1d661f64b514f38f800e367be3b411b9f651fcf68806df8863047746d0fefc9d5edf01e0e0b89be0b5fcc5bd4cef03fbe65c46d89e8610dda762d8b4d603b039605625d3e40f6705ace3aa4030f8cbfcdb9a3707122f091c736d72b75aca5e28aa3454e6ca039e27ed2cabad97b7b1e35d739628ece8116b4c8d0df8663b4e91c4e256c1997b8a6d013d91ac8914fdd9f24f2de6329871f2bc2a701e013ec79d37c6f30b595e71006f8023e40ff7f6052496c2e6ee2972db4aac64d234bb13748a4af36d12969c07bf5b2bfe3048e5907ab01ed327825a4b7f7bb1bc069a783d45d51d8ecd0a53ab7a386fa1f5ef12a17c050953e68b716ce1ff1f837fc33f21f1ce3a1792a2de14277eb97664d4c561b3fd4b0e322c0166faa175d0a71faf47159f12af674684694e95cf2588e046f7a601abae134d506152c77d4a879412d739af6dff56de8ed377e5795566f9dc8cde77f2d891d6a7846fdbfd9a260baefbe56613ae665244792bd681ae0808d148e1c9e836b5af4ef7db43be678c6dcdd9a22ccc659f8aee84f1d0aeda75f66b52395d557086c18de31e69885ac2a0b599f7695fcc0a6fd41b523bc77eb5a9f3d36d9d012e0cf2ac70beb3231bcf8eae646d85958aaee73e67d57f9545d10bb0f206f0b417502bf2c5458b5651bb1d02628be8364894db738f0204e0d4d003ecd88bbd35d35955a90b3b58eaa48f37f7bad9fb0aadc234bcbc61326fd6ba78edac846e4d0b305617692681a8be52c3d795df24d86242d861167b720cf19754fd977a6ac467db188408907055440ca9e81a26cc6a0e1cb1aac4d72a7dcd707e62c1f419628e64813a0f008cbce1c5d17372355c865a56a6deeffdc48b134cde64517ae3ee29d27b80a7ff3da43b8623bfc4943af5eefa9e47be76a6fe6b345c4d70943032df2eed9df814ebd4fa56871639ccd07e710f832b5ac93a9e7c2fe06345cb68f4597fbeda29c7fe15c73ee5bef96485eb8c9e3cd3ea7ee633ef4552f0f9a6f3fd3ecdd87f63a0de2f4a4525002be4c003e6aeb187971e14846b7e9a3ab3ae3915372122d4cd28f4ea2a732f24f7d4eb8d2847ca8f89302b5a99e3a08a9c69a303ec82842090e6a60e0fd0eb7286bd6d52f9716f32e73c937d217b4d27dc61979104f8e6add3625d62a36541320027ae1a023588b9d9cab3b5aa4f875b9a1e7e85288b30c1bf2582af8b391aab8d9816acea9afd6c8963f5cadc65376cfe26c1a8ff444aa57cb67bbd72545c26539a0dd25aa9b6931c8ec08361c746a33103c6c2322a1da1319db254febff1eb7db4fb52fa699b76bdd47da9de7d9a485b3df79b68458ffc06638d3cd781bf42316f48f571e2955d92bc9204fe8d1da3a35abbfa4a9e8900248f763ca6a2b07397515c83681c8a8fc3ce685c6601b5fb32e479a97f3cf4f3b3a9d41e132babc5d9e49fc48620645579926779c1e04c9a30639b6eb028b61eda3a0fa8c52397821cb07a8074f509f7dc91f723b533c9c6c45d88128568b9c9c2c98fa365925ef08b3c537ed9a363bd13528121ea0114c8165ca85da506e33c93debbd69a81e7574b1093875e3358ee475d6b3c0a5215e84fe76316b9091ebe7401fd0b0df61a0187b4a363abacd2d49f3b1f3cba2fb46d97872107687a51988dbbbc0866fcdf3565b1e9da6716b8b5447303e9a49ed9a115c24af65b606413079361964c981e3a0d8dcfb33a79f2da5d8d810a70aa6ccaf22346ac3ac33e750a12527d67d4bf59a8d3bcb8cede678b13120069c6585531552f7df1acacc906bdbef88560b7aada5e0818afc84c01108e89e8cc4cb27c1e6770588c5921ec104922bb76df49c80556b64a61d3cca7b0f57aa0fcadbfc9d8506d3d47ea2d8fd9d6c304178b93ff21b964bc96956541b4706d92c18f8725a937ae95e807d59aaa8b2b39310d9c3878ae9bd516b61fb86429eb25e29b1376d744bcc9385723f6cb90e1c48c0c6d5c505ee2fda8df02f208457bc129786aa6aba11e3fff831e89840e6d0bf0310c51f2f1c19c16b817d8e8efa6ce5cce949b6d735c610532ce3c1d2d587825248301a68ec01a26e865524c4df3b444479a3f65e5ff96110d3cf8dd142871f28cda52b45d68e0a118f4497b87eadca9898378db1c8e45edbc6fa30eec68602112172e638740544eefcda3bec613ac533c5730164391d85fe66f26f6dc9dac785d447cfc34d1dff716f74a5d32f78d09091f4e5f8090b63033456add0d51bdc0166824c78ba1ea62347a24a0f21de89598e2bafefb1447284df8560da60bfbc0e48c0d0cb53adb58f25f1bce2f0d23bd90a85c3bdea4f30ed990d1cdd054ce4270b72113da241ba1f8ad16311050a84a99791c5d4ec922ac8216c564b3b39e0c61f1472320e51305ed6cfc0fbe6ddd035d5ee2ae750a3cc8ed91191b76b0d3e860426786b2072a4c79a5b7b160ec2cb2815e96747befa92bc509b53a42d3d59c15b36a82b612c73d455f2e5f1f56fc1db08220f88800d19db08781093ea50cf0274b3660558c54a2f9a249612332b40d90d16882c2c61de5561165cf93ade1ae3f13b468b6ff38413d76f0fe9308be4ac953565a54c8f3cd61b249d66873ba9c0411cce102f2dbe2b7e40b7f9761819c0410d3c7648ebc1b766f1564e68000841f4f671560eea54f12f3822c59c365cbe911c5121ba1e1983f52b1c2345b1c2c37d56b4af97afe4ff4ac3d4dfeb9d29e1f5d1684a088c80c646205387c8c745cf5a9c2c9f41e4ea90615252ab1c830df4ffcac631ccbdb3f8da7f90de39c72de01d552da7a62fd26ef39200b987ae75420f771f7b6f381f8612a768b93127d79026105c4b3cf738e571d1737db565fc63b554b8a9787210188f262f8b476fcf4a053c1d1c6ec18a9e8cbf3f7a3e401fc471e2462e60f2520ab07a79d6d51591884b57047dc41553e484a9a9318ad33c0ed5ae3c8cc14f41e72722bc2e72afbad568ef96f1c5790171fa2f65361385ed8d5127004711df6c2843ad8af4a894a7bbde74491afb532fa16dcee7ea70deb0da64eb35efcb293d68a6794abbdf6ae4962c739f5bce4a4b0d4fe695e11b540270814941e955b33202b0249ff68fa8fe0ed36c0e26c6a4d0102135139c8b7c7eea56efb8b66a13e6a1012def4741c5509053dc1a2e7d194b448208d58f39be72a2263d0ee940b1c7ae09f3bd009e5688a52e2247b54a0e3934d2f0503bbea07a22afbfb8f4a22351844b248db4edc312b7e2fd1b6db60a164ba47a182482b911f633f64b6ae6cf20ee451ed5f6c8916b62e2cb09aa69835f03671491cc1e6ec697536f3abe873b923678712a28b7480f10ce0aa71dad009ff6ab4e51a4ea4804809e991b521bff31e76599fedd126d8a6c053a581a2918459fe185dc419ebb584c75e241e81d609c8b8d17c886926849bf28d8a1424610ec599a599624746f3e4569f952c2f4261e9d6f691bb79fcee994997427088cb0f0ce364813c033aa2315fb4cd28548b654977d0c6ce2a317c676d78b4ddf754eff6865cfe9a73512a3389a3b35a17377caf44680408a34c98cf0738c7a59986174b2795f6c3bf12f3b27d762e09a1d00de4e4c531b30dd5a997bfe0650f95e8edd37118530010056576e235287e19de82b100ef37158f5417883c7675621302da5609ecfb998eb3e94661e68802a8e742dc40effc765252496a2705dee73d5d479b9a19d8d660a3e5eca29336db7675b52d4bcc6a207d57a90527928ae639809a6bcaa8d0feaf5dc32e4c431951aa0f436eca8e685a39e99e20e52760a62ff33d8e41a0cd5ba26ae9d507ff1bae6d3e5465643edd6bae92908508cb4871483f96cca809b6336251c1a97dce2338e68850dbc2e3b39c03d9e7fa39872a8dabeb0feda7ec73cf169ab17153b81a393e789f998c85d13561460c482062ee43827f0eb8e550eb77e7ce23f734c5e6f79c93a964692c1f7eef62653764647ddbf284fdf60b3d0873fd747e01c6fe70bb2963d70701e185bed6b45b8eae95bd9d2581436fc0bbb10a7f142a58b16aa0cc0c6f8f48fdabeb3f3dc55717a5fe97d143fe48ebadd3ce8595378fc49e115f746e3f3af1059339474d1bbf98f2a6f3be738374327a8c482c6964150c35fc93f9775c41c8c0a0571f2d40fcda3c95baadde992f0bceef0547202324fa1d3225a44e4d0a96d7da2d0f07bc77a52cd4d2e6acc7e1405102ee1ee5fc2454ffbbfebd1c9aff22f149a45e001597c06a6a25b10496f297accfebf9de787de382a0048c08cc8736b7f6a25642d5c3f59d5f9a560e8dcad9875ee51f331e976f4fe821583b6a0998d1e8103df583650a6dbc181cf434d1ce89b5c2d90d76dac00d9b3c6bddfcef11e627d75c40a8e4c88488894ddb13703d5bde6c6f9409af9d65c23d0b150aa0699ebcddfb4ccba8f787cbd42fedb30defa5e1c929ef5e7ccfff640b810b1d8468a3ae0c624174195f218de10b529b12ad0ec4c34e47feaa1f82899015e8bc03d69a054bd8462c9fc7f8d798283253e53d3e914128c36fa2529739b30ed470857a2eca81a68379a2f9b4b0e1d0b464f067de502afd8c3bcb33e57d5cb6f6c0721d0504981521e68abbfe21a449005599f596076816c9e98c89155c735377343287c7bb776b48f8bfd67e31c9dc3fae4aad0dc0e2bba3024f1bcedfe12e7e542d801df706f01f39a912dbe838d199f86a59ec828034420d7bb2b90d8c8f34a9ccd0afc12deecf30b036bd4ed97035b961bfda562ac8cd9278167dee5dbdc1ba753e2420d4ab7f653d0cce6c94003c7c96a88042c8c06c1aad0fc38a3c024c0f9194241de3705861b65ab34952cbd5c673db85514264492c846533ea12a4fd31899859bf428582ab85e917edf91729215f22938880fc895064df7415c5ecfda7c313680eda3224cb1081a061732d6014c2434ff16bd0570eb5472f133f2274f9a9ccfc1291bf674ac1e9f6aca655a12805076393e928d9efe0630bed668e8ab0a28dbbd4507372afffebc2d67cd714e38e367776e34b377a4bfcb1aa24786553151c4d5b00986e82314dace8dcfae2d0c69832a342829a385fd9c8526027306a6c425baf8774824cc1d85be9ad07337415f43d21ec152aaf84c4f9ee02e4117e0ec78dd9cf4fd793165478e1d9462e59e4143ff8cb4c0e692383ec84f1f7301663738ae0be7394e29889aad947fffc0699bee131c66e6fee +MD = ee6f7213ad92981ac82d431bea13e18259545c89b38dcd3a20906801e1abbcd324ba466f78385f84ba81daef5c967896 + +Len = 51712 +Msg = 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 +MD = c966b502473611899aa80eebef4c206fb2e22af4386145cc1e272e2d3ecdebf1be7c21c03a47710957e82cfbeb290a9d + +Len = 52504 +Msg = 17450948986cda4399d2aa0cd697295fabf4bfd9cb1fd703356f7e8c64c12cd6c61ae1b5708e747310602817236a81e668bf562b94902634474cb09d3f0bbdd1cc2d41cd833ea227371d584f255eb6166fec076cccf3dd6e7dfda6a0835b80760fc64f1a3a460c69f653603e443a71f4a8c3fc26da11a4b9bfc9891d97771dcf782d3323fb6d59403548686ce9c8598afb8c5ae028b2211ef5fa819ce5273be4efa916702f7a32b5dc4699607ace17df518e4c231d9dffa407d6b5a6d43582bb5d83208a3f363eced3931aa2611552fb9012f876219ce454dda64ec2cc679c5ea80478f891692695027714ba0465b3e7a26086619c75793460b1737935872ed5ba7147428fda9112523caf31cd86e2aa6dc01f6cf6f1654f76414d52785be3267915b4f1a053284ca928128d233f864cdb7aeb2098d850aa089c04d5fbac605bcf37e88c2b9a934bf18566596d5947d6d3d51104e8f2e44fff0bbf8a2741507ca31e0a9b9a7979171099d21a159dcf4f3c1ab9a14f07c64541d6a6fa64e4598fdc1343a654b582b9f0ad7f5a82d0c3bf00920d7d36dea194b845e2ac1b5b239e645ebb36c1195738770895a01cbdce2e0682322203401b454aa09b28b26f57b0224799d2496ca09c8ff43b754b2b96a53635531820f5dc5ee12ef8f793e89dcefe160603547504ed1fb7996077e1c32b78f296e5f3c58dea643822a0248e9cffe01229504afd2c340e9ad8e908a8fec9b4002313e678d6eebb0641abcf29fd4bb0842b4193ccc07946e520986648ef86d2a8232a5fd55e74cee07ca1fb8067ba56b4335e97aa67c2aee098f6f9893d6aba32beb0c8a5ce83850efb090f5c8355bbea6a30bf5fc9192ed3698a2a33907d55e61b2f88b0cd24c8d7e76b7585f923c56ef73e71b28f85ae05badc5f0d92c8890b632e07be045e7f85684f94c3702c5d870310166d610f16bfb47501e0e9523febbd36ad971b39925ea53ed4de91796c7fb62f1756e6bd4e497fdc79743d2360cc52cee202b9bde9abc7c09d9d0311d89c3722da36c7993feb42992e913744d2f74a7e0ec986f36cb3f55b57c96efd8b27af71c9d4acabcfed263587ff7ebc7fb4ccce99b22ce204c058996a2a7c436b6745a54bfa3bfae7965237ee85bb934d4b0047eb865092971818013f88d3ed62a62245c76e1f8e702fee27caed96d226030f706c0c9d0c0e045c1b3cab1b02572a6dd9a7f9fe6f5000248e82fdb680f12521d1850eb85752cc4c70ca5bfd8b313d4fea526381a671511af3807ec4a596f95df39c524c7b4ab81187525f208fda25f0ff30744f39b96af8de2b37674afcc7ec5d1ba2ff81dd10d3e83a802e16392a77a0a9f411331292e7d7ebf248750dd7f69768c47970f51bb91ceb86cc2936960d5525aa6e9963130f6728750f31b070a22aed8063507922ecaace39a4ceb9afd9a70c5f0f75943397154a896383cddc189d10a0652a506d941a4a605e0faabf041dc6db9bce8c3ba76ab9f6ec754d6181783bea26056444d7f5c6c5a2f4f10cb540bbe6bbad357369edde84530e16480544d5284fe99cefe0c2ac2e168477df159654481719762203261ffb405611d9cb88462087dee0b5d509636465c7227f4ca9f7c8561a37919d9de5225a56265bfcccf59b77ed18e0df53532f35c5db3681010d3020b8600960db99c24a153e18bf994c60c71d2cb62526e4562f878b4adc24ff461ffcdad07367a1a3b79b3f563d75b2391e770580d00d7ea3fa141804869c33d3f8ed8b2effc9678d4af1135e9deb8fec24018985078d89dc3e746caca7f1139e56945c6d2c8a5148ab1ea07808804c4282c5a10ff3306dcaa5b06d8a66a90671dff735d42131c99b812ad0eba6be4f03e0cb3664bb7d9235d5cf05e5ec4e73123b20ffaa07463650751e89019e2c01f7e5192ecd89fc61e576d91b076167c44a1317a0380551002d2e01b5001952cae53ab97392823640a131d79636ec7d60e10fe202c644db8efb55db3b313eb9139787b3ebfbd0b29832aed060bbb517af9fd68b0b9bec6b4a8191b503dc36e842d3730d80509bf8d26194cc60dee5bd194c111aa501248a9b898b96f5492867c162a6d119d80a9154f48bd37ee6a4f806af6795b73e14bfe9d9ea86f9bf3dbff60cc9079ddc460488b33deea21d194ede918106299be5929d3b578df7889d774b9884b5f6a477d9d5684f24b4c96d4909ba0674e360bf8b1d747ab4d7ea6f1726d07ee50b78c399a2d96c7e9c33c771eff29fe8ccd5c933d24ffa02812edc28f17a609ec4a055cb59cf3a0242a3504df901f469ce422c1124938080dd9b0b31135fd1e9096353f7611261ba8f6030658daeacffd0ee0fae7c07b334d47b24baf4477acdc20be6a6226a8aae69b48e4115c270b2bb229b9040753c284c14514bfcfa0252d7de355e049f5de5bae5926af706e78b7526f841daa3c2642eb0b86d933f1380302569aa6f788167683c66679d3fba91e7424d49b059eeee639581a721df5260b627a90fcbbf9f3c5c012fc06d3890cdf9bec22e2c6168d0d20bd5820ea369f94f2e1e17803a5e6d7f7c18fed1b8124594e1817ab482d712625cdc85c2500053e480ef49f6b26700b8f546a83086e8039ef4afb4b283e3bafdcebd38a6b1be775e66452d95ee6100eeb3e446f16bb90f013f77658d2d35d28aaba123208d4c6ca328484cc6b8f5720bff18607e2f2d6fa30aff14ad487561f039afcf99ab513a9d0e1f2defd6cb60f6210a7f3e9aed2d6e9d6f497a9c4b7019c110c37ad476ea3260f3597a118ad19761e42a9973a151483ff08d5cf05d06ec8aeb8729d063834c65eb56cd31daced606cbeaf784f1e11b3aaa66bb0d562b51de69a41067bf0dd26630ae52fe655e9b5ae946c09383e7ced4c45fffbcdce73003b2a195613391acabe9e86f40d089cea366c65c69026a495666fd90c397437142ed0622856615c27c3f8d8ebec657572a6af234ce14737408bacad6ea3146fde3425c1e9c01a4fc215a241641edd11e371c53ae8a61093731e54d3afb4ff9ba2eda29f16eab4342e161356f91edfe0c12a470336492347a1a120e22bc9c62916bddf802c30dfc7c067d4900766fe707022bd12c254ffc250c6796f7f7bd8b6ae1734ebb63ced692d6d5e733b81b92f850d9ffff953f6a204d0c6c22725d7c2ed9c2b5831697da6c9a92976f1e9809c845d581167c0b8553252a1809f6223cc39bf5b4c2a3100ef299dbe11d718f545d2748dfd7a25b56a6dee923164ab4d2136f32d4e1d3e07c0d1dd94ea379a779a13e59a2accfd5e302bf7014b038bc49059da19b466eb02ca36cb3656afe89827bd43151fcca24364d0fe8733e86e2a6806c6c935a3c27249dcf92aedac8dc76d22ff7742e5cee57711778c92afdcdf36e26b8448504ee6ee48e9eb25b9e495e9098d494ac4ddc4c541f499cdb652638b611b0353090ac125ff1fef8564a78419c57f038dd65951fe06e8377b986947b407579eec1a60a16f540db0931921027deb472e8296bc2d8fb4e4ddf2c27c0c6f49c3ef7a20fb08490c25c6b563fba193ef7822cf8290a7d8f05cf5e9c125120bacd25d93993456317c0aaa82b191d1da4674a8db265161883dc327b710df0927a4f561bf0f972bc7182ec481ae7e23ef84def92bfe88db0bf1b9ebf13e145221c6bfa452e0bde9688504bd18a73b08122f19cc4887a184e2b0a3ab0eb56f7da886939df5a8f31f94372efcde38330f00a9b77a973e25ff9aff12fd85f33afc2a6913a72de4e15ee8a2fffc38ce009929993a8cbe9ea09b93317a4bfd84214e15f2a26852110307b45d1a43cef52e46fb52058b25358bf969fc5c2ebbf49cf3f997e24a18b9c2aab5c9e05bf73a06990478cafe417f52899db43b1e67a1187e43dd35d4d84bcac83b8df4bd480943ffc381dd4eb9f89edc9cfd998387362e5d93472f91174365e0d3fdb9d037ef40fbb6e1cf04f51dcb52f64cf9f671003912564a31f75c3d3e750dadc24d5d58980d6d3d12a9697b529d1806cf0fdbbbe32d0b7aef702d95bf054722807d1ee1b3b544e83ab4ad8def0b90cf9b082db5970e314daaa3f1f962022ed086f802f72e73dc67b9af27b1db3eff1be0a7cd79df565627060b5fb4c20c135c4846801552d9a25022017ea3b1a79150324751952665e8bb840ead644973930a46d13cd8db572525e65408c00cc61621026f408406ed676fa736819472e93c8f05309f9e326cd35d790f5c93372afbf2c39820c2eb3d60b7e21b72a1d8dd6e4ef5dd0ef1c29b3b6b7cabf099eb36913a185a68de6dd65328b705d738e5b0a6beab4f21503652dbd443a24b407389948b531e8f32e958cd36b8be45a62403747297ff7d55f834232c809ae3237a94645b165d0a7cf8352d66498d44960e6665ff4e76596f72afbfd895ee5ecf6ad79f2dd4be70f914ebf23bfc0b3a751f29f9b9314c6bf94035e06d06250480bec39378008b4943b9edba3c42a0bdcfd0fe8e34d2da1bafeb57636e43c77af400f8efce3c7bf9e971daf3cbaff63502ce34b1f6c5b7feefde948730f15e28a5bbe80294fae91966b7142d7eb66446ba616cf3736c5e7c35947dea697151a3f25a018a60ae5b1e280429c5d9d88359532517c13f49461a1d9763fb8c563a638665e5d5b5c95a7ec9e39c6b4198cbe369a3c5b9cedef75f0471f738fe1280edbe69f58318fe6fc1b8cfdc7c6a79b67b6a47e73b86bffac1869e98315338bdb926c0c0f0eeaff37d61437a7798eddb97d19bfcd50b4eb8d81077d763002b594c4c24d8cdcb409e087fc8f6fb718793bf3c0a96f4d11dca194eb8254ca98cec1d8ae09d781362b80950dac26678b98768063e26395cafa6eb7dca125ca3bfdea38f9e8f6e7b88e9e680f37d4713061f08dc812b112276c7e53a182f218346a984b6b94f3f48159c268cad781bc4ffd3380b8e25faa705b59d103ccc29ccb3e5279cbb2d592dbb574fd063536323093c7c3fbf97747ecee8597ca289e3e47a1a12ae3eda5a80cca3d8f8af9fbba1a4c32bc590100d0e44e8c0fbe3d8de6f2ba0cc679ea6a1d5dbfa4861fcad63c5750fed59a9f032da0a2f6a0a6b4977c12b21bb556542cdb16bd324a8d50d1a12dc6b275857d8746681349b14c34c4e8f0b0566042d1f4c97feb6d439c34f3cfe5d6d703e443940384c90fac76661d12d4dd462d0409c9cfe072dfd9131e44afc6aaf4e97d99324c3bebcff8edf1a9e20561728566a6b3d580791075bcb5cd291a67918e18256a09d7a212fd797f7141cd6362d12e4dbac3a829877d5da295262738375a7f9243229e155f23e1b57b15720b9f7725a8e781a0aacc5bbf8da48c37436cb57986c67fd96d3ed2ef3dd1483d82b0e1135f41f8b0236775aa1c034590b0bb07cda9fa08cfd1377269bf7bc076f01d75c01ad00e20bce135e6fab9377aa8a9b844a5e7a6ca6ad36b18e27f67657d6f9df3809dac379fc0023acdce4c3f53c030a61f953f105f9925c44fe723524f2dc07639afbb3ef18f436f3e4b6a26d887d8bbc20dbcead9120935aebbde8491df450fee0f217dddd3624df4377b765f86164a335606a000c47d32a6017f44690e968747c3c83c8816c69c989a66781246531d1d78037afb39ea85dfc3eedaff411aa5ebd596c31ddfd724d17d1374174ef8fa267c9dc0f3f9b9f40208138e7c003933834c7559c2b7fdad48e76ab196266baaf669bbb90f8a5048b7d9d6a708d35bf7b6314c489f25a0fea4e05379b85716f5364745ae78761948a53d1f6fca43e8bb2d8b02d6deb128e08e70b612a46860a28e1e22e755457abe753cd62cebd748458f62814ca4e3fd1baea07bc583e1b07ba5f73caccf7ddd70cedee3279218e45d85bfb0f21c448777ab778ada7d4b704624d97a450ea8a928592c2ea8e88c22cdb7a9770f6b5b2fbc2efdcb99b92d07ccb2cdc4f9394d46acbe2d9ff715bd6b5ccc28beecbcb05bb1de3b274a600fddd5f8da021279f51cc4a4e91f5b403328d16d446dd235cc741f6438843499795a299e081cd6f527933ab369941e9274bff541066d07fe36e3ce67fdcca08df4e68f4b5ffb8ed66b13d594b4e886320a9a90f175a4d340760f869090e5d66407e9d0a7e885814349045cefd201dc487d1f6a2499fb8023155f0f87fbb91e453bcbb45baaa3f9654ace986bccc967fe53b84a837b5a55ce9a3d30f3462ec05817f4030fad3e3c63f5d951b1a926717a16ccf9b522aa996a8d10b37c772e03c723cc856afa3c9366d38d4e69710240e44dc2406396d1951e773f5ecb98a031b7e7bc0215988746966a53593a2d441d658104e535e0b99113df34fa88b06b9052ec2a41b88f059d1a459138cce4d4502539f9b0d20748d4704d564e5bc87969c0b97f0bfae8a0e01be9b0b4c89e9a214bfd096be31368a85e490d24eae7b10329d6242883aa3e56c0e01995d6637dd8ff559cdc0f0d0053055cc142e015fba8b4cc7f60fcddc94832b133a39d3c68bc6bca1acdfffcf81e8c0dda71e35a3f9e8922fa7b0d8a28fe98e465a6c6304016b4e3ec045be838511ce5c0799bbf652ed160fc405db843c01b011965f848ee2e05297849cadaa734dc6bdc22b24b56a0b40fec78956f02d6e391b6a9dc8b5a4c84232766f4d82f0ff5279434cd07f83c59b634eb5cb74d87171ca43a1a016cb85959612182edb7298ea1517697f9344ae9dd3b615b990c1de0284ae059b20db9ad538f441c1e28cbd0627cb1b52bf3118b0c69a23a1c27de653f126341a72399a89a17956975683de3f17badd2a51bda68cc2675a0498613cfe8638a7be7979e71b563dd12f960c7eed6b832946d95eda7a4daa43526120345aca51eaf7a5211312cd9e3beb2f8b1199a9908a38d4a92721dedf5a2beb1f8f01141e884693b3a0f88e37116a919428ec488f6a80d2111eebdc8318f164c38f7a19dada3bb3960344fe84dc2e5a9c372dcecc64bf301b1450fd120a338cc0c83e42238b47836ccc70c5040696e917cf06a2d3e3349d4bb9f987189872b17bcbc6138505ea819c7f1448212b34dbab52df7b3270917817723e21035e3f71790c9a048bc4954ca97da81e88b4a890bb6540ae5487463f02dfa7417ed5ea5b2d0d329b8451e843084a94ae973d32a6bc68b2c2d6b1d3709254bd6ec77a03bd2c30185f2b3853e35d88728ed91f939c42ffae4f256ab9ab4a63f91f99b52c45eb27c3b5cce258cc0d99ba25cae61bdfd37cbba9dd2c795d9fafe2ca5231c453ee56bd3605da775bad10e409f92b6befe27233694a7192e6067af2f57d5a5c85aa4f7d5652ab2020906078a1c059e45af472de1409d486f31367b22797b96549a3748cad3fbef3996c1af093ccfc158f8de0e42097cfd6034af898e72db96f2e6e5853a1199062449492d4467b7c902c136f1e2580bdf08521902fbaabe4ea926f8d7ab89cc9ecb0ae8aac306875b48f295fc479313976f71be0def89eb658142b665a7a25b5f34c2e44e0f7f052234734457fb245ccc9d7ae4d3f4772c8482226858b5c410f369578640af3cfac3cd2c8b2b8671ae279b56d47b91dc4753b5ae55d75e57b1ff72b316a92ba32de91b05b1a06ee4d15070ebd62e4f20057921cfc70b28c3072e55bcdcb00c1e683a27e700dd3de38cee24233114b4ab2e9fce6b041b9d71da251c5c1f7ed914715ef8b8be0b7ad8a9a9c0e52f544ae58a6cc56b553045c7f28fcf7a293a1aed11fe96623451ae2aee2b4a1816179937e0890db80272a72e161274fe400d581010c20acbaad860412419cda62f842807fa9dae3853084b0f105615cfad1f19e736515bdd67c71885131e4e76c2c47fbe9e51b1d5901bb9d0a604b9d7b897e8d94b54917eb5475f5e82e0d77017fe26c5954d1d7600d27adba1c469fda89e4a4e1672b598da80bb343a076f7c755ba682a738fa03ec561596c83d2c29c75bc9ae6054ce121f99b76f043c1f822603855f9bbb51639cce126be5180a435bf7ec62f1a1e4d4ccbbd877a627ee6a701d4ec33b7d29805863fac1befc0b34ad993bd0910200c6290da8b4e86fe41c9cd186164d278a41683d53ff1d9238e2056a3f61081f28d07eb8ae8f94bc0981f149b7bf9a607c8e1383a88fc8829836ab927f7d1d9f67da12e3726e70b8667fb9aa6828ead1084fa35e7ed887733318e638848d9a2bc2cc2eb77dba460902ff3a1f22b80521356c5ef55f42240e1271ff84d4f7456a438e1a5c56dcdc57e5eabecd6cd7b2f90cce8d71d23565fa3c273e9ff925e605f1081ef9853afa4b18268bdfceedbb01935b77f9601914dfb924ebb17b7d47a3d42382b6933e6a8ca29de97bd062e6e0d4fc66b68f56f767924e4ee1e0692fedf5c58dbc074ff3c38b3522cafb9ffc3fd79aa0cfea54d738ce8faf58b250658a5bd7883369d45c98dcd87df3d60ac4c5a21b6e6df67c7bfa75ce553e789ab2230e42bb4342376eb29c6d411eea0c081b3f6918b83d34ad5690f389babbaede6017ec6e1218dff1bad3dcb775bd0e8ee8b66ae6d746e533f326e593f402f6b1e87dbfe9cb7634ad57890d271dd9761fd50d0820f399f8d67b3f8ebb15d5d9f36448a27394e19e6932c7e7d841c6ad838a4e290d33bfd35e93e3d54945bcbf6b7b817c5695e385eff3945414070a1c82ae81b7f6c03fe093e51ba284ab4010e2d62f37d8f803510541f93c21972f2ae4e9ac9923c1a1863d19eeddb570e835201d5aba42e2ca6a74c4fd85481abd3e70e5d9b7dc5f6e2c23d7656f24bb3d94edf70aeddc7dbe390325a818d1b83ac2ef470ff969c22d3c0ec6873e19b5c696110c48b8edf169247c0c02dd0498301d2aba57471111661dc68e5c33dc860ba353051b03bf665394a52014bc29e326b7e6e4b8891e75a13713d8ec36b45594247c8a8cb6980302f2480ae59e87c0a5f8ee6d3aa7d61567f2bd4c4030eb4aea7f5442a2b9c1f000a42b727d696758344809fee589821a3fb68b915f07c78f941ea3d665f48256d51417fee50711d35b0ffe3fc21869abb2eb465051a591491a6731eddd50225d07a8d359245ecd58a2b596d7d83ad5f147f9b6301ff090a305c4c63013b3eb2c20ca29294258e30f92a2996f2fd80c138648a3dad0d20ec3db9c29470e0723eca8e1df1748dc9a21b23ecfaed0db573af740d5f56c3251d1275723d9d63213c42555beca3dd13cb68af2ff3dc229fe8e234a132afcf7a2f66e5c7c8e741e03dd218d8eeb29210ff5a324f3c30dac493691cc2721860b4959 +MD = b2a7c12abd0703108eb404f4d038e82f1223f0aa15db525884b7d239e3bef60a5248a66f515dd61f8387e475b4a0ec42 + +Len = 53296 +Msg = 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 +MD = 4184e0941a1fb27a613f91b6ffa7dd74ec65852fe63e108b94c8ceac88193620a2100d638bac1667072c40d05602c0fa + +Len = 54088 +Msg = 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 +MD = 3a8838e486476a517a6a3f4bf10a0144296e631bcb1347f812f35f46f796977984dc7c1936c254f9ecd9469078a72ee5 + +Len = 54880 +Msg = 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 +MD = 7dedb138a250a3ff4325116aba68c7b45f21b6f83e1f381ad1df4e5b4606e5ad365728f3cc83a2badc8cd25bd45a4289 + +Len = 55672 +Msg = b7bd0f9a64f3f398ae90ee77e2ba58bcc82ecf1f838f3785b8fd002ef2eaa730452980243248b21fcb2083e417aad657b815f135cb158403107de7444b10a4efea943520e7290f0ef0d9df3dc67013f5e38e9cf25ffaf25d143959fb016064a5ec26b7f84b3d104d65e389ebb5b4177c8fc257be06e78a7b0c5addbbdb81ef3894068d12262dc0c472650957ad1debd605d8aa01878453454007fceca21c4d922a5d3fd840a0245c5f87e8e8755396e98df91d23ab7855a4f7693df61ed88799f65256b0613f46fb7373ad05d7ff209f6e4d398c3a6c987e7ba82842175ea3373f0e590450b22d8af74ee01899c992def2fb85a5fc0725bd12eb45365555ac534fb9d03bd6a0e1f2334309888458f3905f2c8ad4b8f20347055a1d3b9f66a7d46c7a43bdbbb26b196f77b1bd60554b9cfe07ce8238d43a069c1f37babf399ea4df793bf2c78fd2e9f3155f1ff567a2ea17b5db184256d3e01e5f1b197b7598aaf0df4042c1df1e4906439c160a370162f25d39fc9f20d5bfd54552c29cc29ecee6d4d815734c5720f229ef0a696c6fecd6286e9817d9488a07f6631beacab7f80b7f8dd3a37c8658fdf1e063d8aff5700d3e045371293429fd9dd68e2c32eb10a509e6e41a17b3d870c0f78920a89ad6ddc6839477baa283ff6034812ca542fefd996bb0a0c6e48893c1bde409fe66068fe871c5ef3199825467045eb0c9c5aa5b58a5a0fd312350ad19b9dc5a5a61e86ace584da239220d46dbce8c81467bfd066e1b1af8ff771808f374dadd639465b89dbf945878440c1be41b7367c56ddd480255875ad8e9c8ea75744458c20663bf802f02d89607681ca9717b29eea133673cdc50eb667f489cc74384941ebfcbc99d2fffec3c730791535b0c916821e8ac4537db734e4380661269005920c8861c1c47f35a1291d2c2095e8e65dcf5e25f45ee92ba3b3d598f7e6c226e70287b0026ff46ebbf68b1f6f404696ef1230bc8638adc87d374b96132d6519db5e791bfe3e06067ec008d773cd4057450b54a2fc89220a4bef08a22572ef4ac970eb2a07a71a99640624c8b0856cb3fa0b286db9c8ec8d7a5b9b21b14fd7564c0a4c5ea133a8a406495d87b801321968a23a91506073be930d81b9492ca3b8dd5b1b1e6d8c4692cffa1178fce927042b60f9a252e84e1a20654abd4f81daeef813e60dcef96af23ba8ff30e175b210ccb7e41533d8d22c9d0354c256f7e36516a51b9138039c5ed3d66534286f79ab9727986e75baa66283583e5cd1f763b7d38f5a4d5b43311522f2e1e7140ed451452065128af641585de475d152f8c2539942f0968b20efd1a38f03ee470c589e414308a5f624297a972899e45c8495c4e2609d015a351f00c01b39ae33c08cdf05ffc19d49bcd545c9a4f8fa511344884958ae224af8552f1327f1ab5cc3d7b01dc74e6cf838bb565fea3187d33d552a289ba25ddfd318a91735ca6a449ecfadf329fda984206208e458c211455b4e072aca28288b6dd02b46a5326f6db9eb2520a85db76ffc6fe9d181392b3a05a5cbaa349e16c01122122c26b82f4a9d90b220c2fd2b3e351b85b1e3e53a23c4e2c4319b82bd207564fa221ada2e6dc286d16dfa4a8951531b49000174d295018bad5b4f54602f034f4fe301f6f149b1040f82cec4365bdee5c0465a6669004416c381c0a1c44e33178fc96cbcfc50f1bec8e9a108d6a050e177ef6f2871e8150ac33fafe94e008d74465fbb9ab4360d0d9a1d2176dee131b4cc85b03991cefcde18ff6da951d88adbe0009f0ecd4b5b76ff87b09ca370f9d65a83be182d276407214b7a509458b3b4f97667878c13659175d3eef8e8e221ac9e73e952c883c32c98ae667d79e380a5ff0ba5939520d3d3796c3d0a03b741ce04d0d267d866c2b4db92a29e771b8a157d5ae9b16ce5fec396cb1b4e8862c2a12a1509c5f132cb166692cf2210533889d0ce947f67f57ec83a7b1a34eb772cdc7adaeffb979a44e7c6194ca6da4d0489b5d1465c3ab1ac77f0f6aa6ba15708b6737d05872fefe89f76a09b9b394b768b892d7fb649bd304936b85c414e94bef5a085eae74eb5fea404c33c8db1e11705b71d913c197a82c2985a906447b2e7e08e8ff0aa688f1fabdcfbbfecd8a06e9eec4c3b4c2e6c1c6a8237f7232133fc2da9e5b73f01cdc40d7ba49647120bd5ad8513ce74fd2475a780eae13c7f9a64236f41bf13af14845f6d78400af285f4b81e1edb350a16271010edfeee9748c8685b0e78c6c4d5c8f83ec15dc70e91344513b7e20ad9c3992aaebba0d81ce1917309b664d6f7940a8e4c2a3009aac02ceb02996364e0bf545dd6ce677784d747c9d7d413b29bd1d188321d77217b953700671ddfe1b36bd12025a0c34b43ac63d361e205f83601b65c7d1593ccd582fb3bbdcfd7ffd64ba827f7dd34d1fdd36e36245a9bf65ac61191799d066a6d1be1e37329bc1dadf141cbd9de4c9a07dedf588bc8765b8e718bbdd42e5f6896b2739e23b62cd9cedf2682482e6b01e6312fb12496059625a67d480953ff65d6f938c25bef7aa29d77cef1df3820a83d8ce7d67b5dda14d4d77eb6857876d0c2529a0668505606be5dc380eba60e0b6224904efc7a5475f076f88fd5364647dd512fc0e5632f8485e37cc609d27399f89aa171249615382d27834a6507fe298c7752886fa2679aa8cb8317c65801e26571a3f3801b8cb9df4ba75ce157fef45437bad35398aeb78b584f1c8da129633d2c003c9b953b998b65cd6da6b0d936c904c1282da06579a22c694aec386a9ae44c5eb2d37d9245b6087dc331ad1d7f5f70fdfd7a741c4f71ba4a095e9835f7ff3507fcc44f315cd3a621141ea72c2c8c0ed9d9b66e43a79e7469fe515b2c18e288a480fa74993d88c16fc6ca3995dce330dd335e096c107d0d518050dbad6c32a9acd5c2a82a6639dca251d0cedafed9798090fdd0062891c79945f9945a70743a9961c93465657b6a715baee17c00e36b5c79025ca24e814599a5a83f83a40b9df2cb8ab3fac9a1fd553ad11be981a568d96207f9b100a009eb25e927d9958d56316963a13af15207b675c3d8b40f74047fd27b41b2cd8286f64d38d7ccc35df5edc20086a68b001c1da313a25bf8f3c0c850d8df3823ad3f539223d9cd9c11ff707bddceddd5409d03392cf361dc89104b43bcfcb1a194b58b8b16a86cae2dc571ed47f4318e781d0fae9c663628c89561517454afa5bd6bf6ae9dbe2a78260a5a9cfba152152b1e9b89de55697c26a2b2d0ab6192ceabd52d5325a577688f10a3115530bfe7ee141f316f5b7c4527daa867de9e0b8ac483b83f5ad8d41dcd8ae3d0e12ccb952590336bcbd2def230afca7d6a746a48bbe9ffc989d2d0f665db85522c1015ab5605506f70761221f5948187fb8f3fa6e69a9c685f2dfe90ec75101b92651e791405fed2f99fb642db1b762dee490c23c8f7e6b22744ad6bc60a0ca3b0b656acd3f4a72cc3ca2be355c710c5df3c502df794973d9eb17de586ece371036e4ea51a63e1e36b8fe3620a09d9e62ac39c43e6f3064111eed09ca3a02d1a06f777005bd6277d5d5b8d7d4c663a057d8950f41b85bc831d67560fa0c651e5480c603d1cbdf07125b78a63a15ec9ba33f80ecd09ef326a3db57ead02c1fa8923078ab9d1add565311e5ad3ad76017aea9a361d3672007cef53aaf35e157f7c346367051f083ea01c0a8f3bd52e79ae0dea579325c09f21aecc6b80f743591508ba75bd596f94d85306980a9d0a7aea1a53039d5c5d76fef87a40c482de2009fc77473115468074529cf5de897cbda59c8e9aba5eab106b58f7cb3c65486cc1ac144c1ed71f89eab73829160ef79a7700d7ad68812c040d4cdf5b67331487b2843c04b5237d09c1ed52b24fb22d99b4e3d8bc267872ca4b406b81c350c51973013901b26ec19890519721f9f7715405b20c3782b8f1cbbbe056dedf62cc9a89cfa5b3953d9faebca05fe893635521e007dcbffba73b80b5891bb329ddad734d3c0c9abbf469c4cd462786aa7a5bbbba31d4a5ffe7b2a1eeb714af2125ea3c53d2d837b547a26338bf787cada0f75a1aec9e9a1deee977ce06ec3353d0056e2420931b1f8bfc129578ed4b2b7bbab58874750cc41162aab9d50ce03060818144a1b7b53955b95b5a0ed062926f08366985f26e8113908358cdf126555bd10e1bd2c076b1297c95fceddc6380ff7255547db14fe35a05ca214e23862126867d40304800057bb86af4926bce65a18baadfe82c11495934c789c23e70325514472846b8c1b4c0ff32e7a908f3bef9b6af4241bd635195900418e68c84f76c0d045a929d3c3d9db3963c7e3e83fb6c85cb4206ffa66a93ca184517a834eedfd33d4d805fe00e6667fd699e66efb98e7b9745c46d6b12d8257ca4d21bf08734f94a77ac9b5da5bf9ee105962ca767b3fa8bd3f67111d8d74499aea242486ee001b47f83b9f5a20dcae986d20a3b849195216319c54b2b15aa07c904d5bcf4856f23bb82465871d57e6f63fe5a2cae8bddf079aab4779817c83f8a7620ceb679a3e0b244baf6a3bb2beb3357c6fb342737618e35d9179e6211b97972cdfe335132a40a37a240960345f56b9acb17b3d833fd2727adbbbc69390e0c8737abe980bdb619c776c6e7526f167323c102bc33463bcb0cacc450b18095ca3ff88847ac87cf6790b30a163d09b6f08f536cabbd00a5f05140d219bf9ae918e97af3dc2933387a1fe18a8107a86f5a29fc8600c9d5b41da224557607ea809f20597f258b4289d7c18cb8d666cda816a0271f6a0e47fec95ba1ded40ee1f4c380fe9ab247385bf7221f2584cedbe9bc7e5d7925eec9ee8a0a53ded25933ae0c67e4d6e0d186f76ebe0340fa9475acc2111a23f2effdebb61ab4c5ef6b3224f06196a45feea10494f1e3abc67c0d79be14f7b02f8636aef4293f3499b97ff215eaae937dc3290c006a3ab666da15d916d650ae5a461680ca927d9b5fb87f8dc38f7714c9039176378373016a33213342e1bf6ef1b410198002da7aa00ca350afbcaab8d0244ccbb0ea271d3f1ba220f8c3be728434b5c1dae6e043191aadf320fe93f011a9ed74f2eab15a53f83b2a7f08b879905c7a2221bb29950966d1edddc1cd4b1c18e61a7411cc59475d3ea86c0d57b494afcfa30afc10d11f85c1992ca2d12a3dd5b924cb0bb28a97bf3f23366df6e40f8338dced262097c9dbff9d941e2a3e1574e91c5e251e7eb392bf33648720687f8b48284ec5f35986edee53aa9052c7318af879a3ea5a96398c21518d055eb2533c702da657e386d5300063e6a5c585f07c69b542e8117177e027f606452c62290b43559a588bb03356f846cecb0ccaf0bdaf67a18abd811d4315a966e2f3f87f6c2428814446563fa71864d97c8336b0e34bf9466ec95598398cd4255b5fd5b4f3a52ef1b7cdf948c4f3467d46e3399f71d1f2b7f0cf6f5727f01ed81aca9a682648c1720f6d09ed151b74509687443aedb3ec6cbd3a2ef882d1d1e5adcea71778819878d7be18ab3be376ca07f9f701ab643edb209424fafec4a5e480c69c316ee20c7c8d3ba5f19e0db66ff7b5c2925f856289c757d1bce02b034b306cea447deca603bc60225eafdccb990245275b6e7a100f1e0fc5dccb876280390c01cf29f3fd94c1c61e4105e32f0b9422a5cb6cd49fc1912671c9356c5c2a073e734ff7aa6ba659c81a5724b3490e49c8ce60bf079a57dd365610a24c48bf277ecf356b7278ced10076ff80bfa2378fb1e1c9e99578183eb9e33196a9c0a62637762df9eecd64c3e9e4b8ae8ad31dd278b05570f0b1a9421bb9aa86f74c756012f8783761a20e9eeec40102875407ae879a91e9cbef8193e649e9f7c754b3717bd6c2889dcf32eea9956721479dab9069111dc8698a1780b4048e6d9c61d6e6ec819b71d58d582f94e9598f4e28601487a447716c09f1b4df89f66ce91c661cef994197bb6514de2b3066b10d7cdbb77dc4ad9945f7a68cf33ab05a3fbcc7afef8e734eb1fecf86e6fb0d1af81354d5b612ce8489cb8c9589a75ac9f2eb920c86c1af2b4bb30e9652b9cb31b084820bcaff18e79a0e3a5afd504440b5214baf2fe333a20b1a4898f8ed0fa9a938e9c626ea1b2719282639d8b61b32f8e66b245553cf3752ad040b341568c754a8e291547453c769b1e6dea6492e3530b366f891a3c07fc4d3d779beb3653f456d0309ce1e413d1e33e2a5e0aa1babff10c5986f43c5dfd4372940d3576365edfdc17c0e68621ca916a02c0229522ba6770d8038c43ddc033f701d2c6201cfd0c3b4849fb334da8ce2b5dda5777028e95eb54ca89596f8c465524b2483bef17067429ffcaf47fb5c107a3724e4e4181a40435a19486fbaba313677460d096f5f50f24a9fbd09f3793883c51b222c9dcbc44e35155d3696374b931e2b8e6f9df0094a01136d096776b36913f29fc81e70432c7a27347a1fdded0e9c2f885001c4f8c05fd22fb4abd729808045be351e9a556475b97eb8cc00bdff9ddc8b593f60b7fba366759a451cf360a67f2df212cc738cc4668c510f6236ec8fbce7f9ab35cf32984aef28c7aab98003193f8d9f69061bf298fe016e54d05bee4b5eafd9c6972b9ae9fcfeb812e47502ae83762902b5886cdb34187d7b22d435f23ffa4f95b83d27ee1f7a7ae7fca641a99a3a242bea58bfa7df249127a6dbf35c1c5771259afdcba1d72aa49c7a9a2c94e44825372d1347794fa46dfcc4e9a2e36445f2e8c7c3f2bfa49da9a2d6d74ffae23ea0d6e63eb0ea2616485d0573c122a8442971c746499218321e9da9d41836147c3b6dbe317854c2f8d4eb0100ea9478e0a93301fb1cc3928667df6c1701e10b9f397e0d91fa53c6da880910176bb32699d6bf0048f8beb41919fa8616b98637f64f8a6ce6d361a239d649eb3dd0f961de56785ab679fdfd48997180699b901a3fc21544a68008d575442fcadac6e19b3c8ce179c9fd1bcec38ad6f376248932ca55913d378ca3e13b462d67749a0633230eacd60a1e72a8e8529d57d2e0fc02346e90bf3055ed55ea70b529a1e6d1da20401d07ed3a9d3c45852715f65d4318fc71963317782f9411586989d919def0b2c5c487e9fe15c9599716c656f608d780f31441537ff52c2e41cd1080cf780768f435ce96c55700a30ceed17b57b7de70879d528ab9d89ecfd122564f64479ea17fd3445a1ceb52906b11dfe9deca9e299393ff13c2346c448b3bb37b74c8170abd4f91da814d3fc016224a1907db874aab8a9f9525b3054ad46bc0cb7d7410f330ed3f6e8ef738b0a282988f7f453a2243f3cc6560bf0a315124f685dad61cf98f4e95ac9273ddc0a4d543c381a2176ed161fe2aefc2eb966609dd5139588b8c0ce64d0b383d8fae717ce44bdb7cbf7ee857bd5c4f6919f8a78ceda41595ed394e46be10ecdedea8bcfbf28ec93f82d0fd47825ffc1c15c67a209004dbf8d27fc7d271342cb23b5dcbc4f712f755121394a3d5cc62467f8e72676cda090babce1e3c0f1b7462364c428a4a6ed277dda5230f30183e82b7cf14b3ecba2938f9b295c5d00d60594ff2a59e94f8d6f256043cec19d9dd5b4ef6c5b8982bb92b4cbbe3126ca05d21f8cf59844f57916f1bcf56cd0b77cb3ab59429c7e795453d15486aa44d6ad736c150f2ddd1f18e488f54f5248d7884ab7c25a574638d3a08d3f6b0edfac37b122a15f60dd55d2a0931338c85086296281339cd30847a23f909354a71ed50954e939cd796c1f0f14b91f9a15104ac7c2b0b3f05aed2f27f8835828bb2ad88d246be441bfb1063706a3205c82b1aeca33ed4b3e321d77cc950e97d1932b3d2ae94daaa37bd591b23ff91e66575b379a7de0026ea4bfa7f8dcd8573677488d476a3a93dbf6ff49e9876222a0dc356f9f6830e068f8fc4712978aa03faea94f4e70d8a8d27558b442a58632f25868dd41bc86ed1476fbe0848ccb7ad482770ba6c3cff06e43085c26630e5944151b09e94089325b66e5f9b58444eedd39da49b72bc87398a736c9fe87a29c7e59777cfdbde2b6230fe11b0d469d03421cf992e9706b3a39e80b8130dae905886da4bde7fb388156ba18cdf49c7dc2eb73fd6da4595f4c374fae0e26248c9b4a99c9540dc2349cdaafb197d24c8c31c1860d6350af4db27c2447f8462d3266ac240fcad9da7e0e9936d5010f1f735baa9c52fb553adc72eeaf00c5fabc846f97589da6b10abddf7997ac9413ddda458ffff4bd1bc2b5967737ffffa99b2abdf17b9c70ff1b991864195dd7474e68f959f51a310b0f7f25fe066c2dba90cb58a4d633b12ad6bcc0410511531139c67eeec7ece08be8e3286a6270d897640f4996b18bef9a00cbdff8a3ef8eda689cdc38bd9351041789a6a5943387a7dfa097b154cbb5b764717e703b20120ba1911b1e1e370cdf6218a796e3dcc252c8234adb061c88e9c954a39315cb670aad4d448734ff9a829239342599931200e9436bfe10a6f298f61c59487919134154795f5d451482576f93533afd82fd1908a60101ba907a2cb472a577ae32a0165dbd72879a9e4cc4c0cf0fbd56ce0d05eef414cc4c03a90dcbfe9108fd3d96f392c087ed7bc481334f946d96eda2ca2d63d6ad470e2605a3036724e4ae627b3fb92ba5772faea80be28b77ae0a24bbf72ef3d25a48221857245566f109cbd9629ba5d50d008549b4425b34ebf47c68cc19f58eed411e6a8ff5726018559d37c400d71e973471ec9637adac36f5d35915ea81e6e8424381b43f631942dc031ecdb06888fd14991a198829e878535117386a42e43393b8e72fcad39955e42315e572011b27e8265aa5ff76ef97571d299f61dd8fb67ca624665e68e93bb625a4740f4ae0fdf83f35a2623dc97d496017b097fdef5a4535bec3c3ca10da9a3253e250eade688b0d32787a257f1071416ad5d3480d05358c3fadc0a2161cd772ab97fa8a1d4eebb8d98f0fd7183a16e9a975df66f0a095d42f8c1f9804e7b70c33fbd8d1a6995e67b24fe9fa9ce1827f5cf78100a014ad3414c7a653e12580287376b168802f2d424621cf3714effb2c0bc582be2647c5d578c81e7cb5bd7bf0f4714cf6b3faa0721c6b8a36874bca183f46a947892325dfe2f64eba8997f08a3d52722448e0fe1fbc96e39efddd376a7fe2c044d18f1579dbb900b6649b271ed783eb9a46cb9170af0b9f187e8d894b54018d5c0772dccbea79fa184eb167d5486a7fffb5a29f8e7c31894b13430ae2450bda3832b6c3fe979e05874fc1fad61a71f6fc9e4d71a1ab6f68e0c3e70058da686d7f5a42123a6a90e9ab70b3264ad4ff173808b34fd0c52f037e9761b4d49b810eda87fe11a6ecb86e2db86f3459ff7bab5cfbbe804351d823ce95996e7f11bc87f1c2d2076ba47c5cb530dd6c2a224f7a0f7f554e23d7d29077c7787680c3829f6b12a63eb01a457aeadee615e6c5e24cfa9d60ff98df84122235e41300393c1df18062fc9ed77c9175cc7078b4719ce9c45cc8dcc9f2587177e6c68e27fc50ca2a13ee8a5d628769fd0264debdace51916c5732ddf97b5741de2072f1c93286ebfd332301443d0ca2b86ab8d290125a398de4a3a015703e5bd318d3e08862ad157c81735ec03bd7ca7622bce1ff5c450f1b1354a58b9ab8afedc4203125ec0ba9bfb83e30c29b846189ecee8c7122ae8ca461da70c45132b89e90dc663a251f232735f809c3d28f227407b254adfc033caa3e8974483a4920563d5ce22da4442c6389455c6c875467b521acbd0e4ecf89ad2806328fcc6861b4f8464788f0370fc5309aab051060bbddb +MD = 0b7356b6057490b828893565407e4dadd6e45d8e75399499f74ab90bc917d5b48b0b125ea3fc87f45ffa12e05aaa10e4 + +Len = 56464 +Msg = 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 +MD = b19abfc62aace1d49392cee8f69fc6477422a647223742cc7d65da06cdd8b86cb8198c3af9069dd4e8c3a4a6e404d9b7 + +Len = 57256 +Msg = 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 +MD = a14ab54acad289474c703cd30f01ab844b8955e1e4a8764884b994c18c3f4812c0cfc6a2b762bd77b4e44f940ff4b245 + +Len = 58048 +Msg = 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 +MD = 511ee3ba7cca58960e5e3865e895995f988981d8cdf2a0fab5acbfbbaa0b2b5d92b3fd5c920f2529a5739fe85a8d94bc + +Len = 58840 +Msg = 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 +MD = be458f1d393877c0c12100466a1215955faf462b0de86618d8417af9a278316f9bdf2ebd1ea1d1169232f43d67d36942 + +Len = 59632 +Msg = dfbbe12e39b516635f3500a9bdc68b8ebc0080059209fc0a5e5c218474c90b6ff5bd063aa4c4fe6ef44c379166ac3e4a11651fc682a7d859c7170e69c7cfff88d5a6b8e084b287d4bc0cb4e40dd36cd14474fe023c284a27f7be751ced9ae210a4fe5ee681889bdbdefce06a5d44fe6d7bb58684689439ba16d9c0668f329e508d4b6215444d21cd83a523eafb06dd63deb11f13adf48f5c4bf0560f55a01990b6172b35750901f0d28de62e9221effe97ef3276b34f3352be8c9fdfe6eb3d1847e9210ebcc5238df43e8ffcc89e1e85cbf7257623ad0de79834039eeb1bf02f694aac67bf886feb1040881d4584513fa55262dba51605620171ea130b391c1e43c1340a295acd544f193759b2db70754a874f6de093030a20cabc07ef4ca82effd621bda043250ed9530677b7ac6270e51e56f37d2bef291ec7e1423f5c7ca4c211db49cc4c5f62d5755c41fbfe11759ca0de3723e7b10522f0c28ca27280cbb7fbca76577c63986b08a07d27d964cf97944eff7bcd31e655cec5adc0949cea031b570be6dc19f8c5933cf4e24543c4ff8210142de85816dfe8536c42cdb848d1f9e8d2247269ca089e976ed54b969efcf28b3ee03d0cdce7c6d592d022bc2e471ee791b6483c555fb219b3a8f245a3b56d27443cd6367f95f1b1e7119d90e48d11ba11476678e2f0562a8a0243391c537a4cf0ebbabf4812f05133ae451cb2cc5acb1a7dd207b9e31232bc8b445850fda2620892f18d7f864b1b3e4e2249e02c8280740096cf22616e9912ecff8b89dc6cd155dc848a6c198b79d09a3dfdb5d41043e679baba6592f3c751cd7cbb0d1860029f6e7a9c56f137d2b03a9d217aed8c7b399044afc99d282544d5c2ce26d8065baef3dbad8739d78da7d54a9e789e7f8f35ec3e9597aa9519b2add9ae1944e7454911afa44517f4147d134d5af41070e9a236af5618e3c30c62fdc94131868a293a70ff69d9b315cefa9ead3f396ae7f04815a0d9916e39671d6c9a71b5c3776d47b9d2e48b36c223e51b72348ed56c0cef3218064d737f90aba25524ec26377b399431fda2c8837b0835a5203a7988a55e341fc5931b1ef1d44802441fd451b9d7a8239c6890e13e29924ded867dc2235ec4bdfeaa8d9df06006a7b897f84d91eb9eb0a923b763d411da7282ba0aa3efb78afb99dbf284f716834e6899b8b46a3b1de00c1c6492a688b61cc71e47b26f312de07e6e725c6dbf68fe3c703c0dab91cebcad9bc0f41a56ce54a4f95d770c93567596ab34acba235cc01c63ade0beb3594b74e7f3139942c9210195737a2ea7acc1c7d961fc450a089bf0b933b60a6965964a4a24778c154f8cc638b2443e33d8ccfa4220d5783c1397a0bbf515f77d9aa3150a7ca659970a9cdb2b425ca200819e182c9abdba8026bc14b11c88edb5a27cbf70222a6a909f5928b64a4ac4d6504007e0f73e74a0e91335e3cf9454db22292ec43e8b25c8b9cb9620f2970b7dedb9b1a65ee00c6203a3e99837c394b5c5b04c4efa4ff407fefb0bb364cadebcff11fcc5f72aeb8f1d7419197c9c150c301bff557c003e1416f070b5c56ba75c2e50d287eba479efde8faeafc5a740a70e723123ec256ab8aab2ae6f4002cd26247f1a3262d61e49effb8ea03a6d7b5005bbc9fe7347e2bb624aab29fa18b8df86a6bc0f83494366f7c0a33405752fcdbd00af2f39ed0de5e5bf512b1e34cf52ffcb9f6677844e0f9fe7d3b54b47c5e7e048cbfe659f53fddc1987bcd2df7c4635f8ad7f660fa90a8f770869376ca366139c05b21fe61ccdee6134253ea02782d034cda17773ba1f6e78299aee6b3312000345959148d01bc49e42af8cff36cf7988e716d237eb18e5f31e8e9bccdcb34f8573ede04fd7b005d8989fe18412f5d8fae424a0e3a3bc9beecf8d64180510a82a770337839a545a171e4068b823bc9495aa14090049d2397424e171d618f2b1fb391fbc6b7fce6b64bcd94622d1ec555e222e34154723668a05d1eb8e7c2115ffa189978fefe8dfc65ab1a64b854cc55f34b94aaa0477cb3a5aa4fac999657a3e9888f17753685f46e011aeb9a5a58a9fc9ff7247e8950f8b0ba3c50dd78689c10465f2ac111792eb364186f69bbf4c26c746d5755b47db86001675e59e4be98fcf69c1b593bd21bd4589578acd62b4fd18d79abbc553d731214531d6567d42b0dfd9871a3f22b3c4f33149fba556692ba2faeaa28e82aa965777226a67e43e2d1e006b647f0df109298083d3896214b84ff6edb11e9cfdbd88f570283948830d7225961aba488293d0bf2e99e3505dad0515ca70de6977ac9d0842983471b958c58f2fc45799106ace3771d61ae6eb11ae9daa6734b1c16d7ff6c043c1278917fe875feac0c940970d2d751196ed67ec31d7b41f893b8208140714b046319b5105554e155ca0bc2173ec61d2bf2c7846760b111f46d06383468563672d58960ec24123cc93e52c10eabb5ea2fd6dc7286581e8efd1380ce8fcb6d8f1dc6422561d930798cd62376d59e19407b876fc99e6806218943b243f1ee498d5bd1de832fe92210072dd863fa7a72a8b5810bea2e151a721f5a0548e9355ce9b364a90a94d879a8cea1fc18ebe5549b64503b54a3e3dde925e3143df4551a0ccb1b5c2c4f2ba99c49ef08f628533180fe7178a99e58a30f436b499391b2236ef9524258ad5734731f41798c4e488c01ea714e597be80c4cde5f200a5fd0fb98c4a606103defacb5a555e85bbc39e686bebc16d4db269c3a8d3b31e29d35f512c38311f37f6964ec72a8bfe500abb397f1ce7cbc2a78b540a68bf9bd0855b2556c75e072f0391f801d967aa8aa1285be1a34ea7fe8630a07d0cdd209ffc4b5e925fb1c0f2ee31f08fccba3271712df519e6bea70a389ece8827d755a01e77236868f0f388a0bf5ff9694c3d0d60112fb04fff76eda41d07b42173e1dad4269d614ae447fa00826cc81ae47467571e322d45d8baafb1f77387627a6d5507a1f4046d55654ff5c44083464c7f863f9a26182f131c594972398b52b3a01a9d314fd9390bf48f69cb02b2544a0572fece33fa777643f253d8824859e82330801cd66917cd9dc243e1dbdeaea7ae347e027f5984cad882b66f7545e0df9d9f96aab33b6d6408f16b4cf38ebb2a24d3a57e35c0bed682125c803b0a4d61b770c9250bd8a499dc24c854714ae39d0c575d897bb48d64eaa82c52fb1f0a3619aaffd309c62532c16144437e9a8ec611c98d6c79bf593ab74f0e2fde0d7d266a5522fed28f57f761b2c65f4107246fd9301d7059688a21920cea5d0c5b10f9527a19ec91baa1b2611e37f2e3180d5e0c94f4da403788e123e9a825ac912a767b1fcce56cd06d296cad7d428b56b25c53fdfcf558b5bc4211ed31cfe63732678a4f23338b582225286881986247793056741c08c9698c0c05206ba3e4d692922a0f061d17da276e3d562b3b9075cba4bc003c5abbdc6106a68b3fe9cbf5b1bf01695dea38dfe6cc548064753c68117e2daa44345594a4fa9d3595e8c61df7b8b76410e315eec60715ec128c8ea6b18753791ddebf1bbbae912756e9fad5cc44f5080750d78f2fe627a41ec9afb91587d375ada022f910ea2b67683492a5982a635e2b79a54a893333b07174c729a34658a6ddc2a6b4097813ffb511b415c333a86d62a5a8a83db4e016f2d5fd7cc58b8815968b72d6101ff0f624c889aeb5276c3e951d0830b132d7e088337a3ce21f0bc9be45afe78ca66a559ca038f7d7ce59d7ad2aec6b4e74bf161dd866f061cb8aca3e36846de5d62a2307e2e9798fef154290127cdf7c4441be980ae821ac55ad21ffa61af28277d8684cd7c6ba46544887281de216a46805e2e01228562a851bd5e8df98fdcd511c2d53c4f44465c39bac5b9543982ca9b289df384f1743257deee02827172d2b9c7904f49e9f5205b5bb13c0caeb7ecff0bc7cc385ed5ffb7a75d1c8efc60ace035447aeea5177e240bb37e89c9900a269829ffdf15ee6d1bb71a2081795cd03f7c6043900e43b21e1b5af53e42a1ceac2e3302cbcf4406de7ea3b30c809dc9020d823de09e0058c42b06349c824396ea6e718990d37d697a7e8848829aca03d28918ce52dcb3fe90bb43b147011bef7bb973d8c0dae0e19a3746557630581d4b4fa2796932f5001e4ca1ffb0578154da9fa884ce4e151ba8295c6e79d9ce81b6f19dd386493a09c73f8f745afe2a5381918e123b9580841ed548f7e00fa3bdcfef89415c78097826348ab3b95d6d680b3fa3157b49c99778bb7a865b4a6e3dd0c9f3573e57d9d7a5ac22325e0dc10ec1ea75e31ff346e2405c9f9e4e02849e73f14a99be6121a4d006d474bb77cbb45032752f9bfa8ed10028f6a42ac09d4c13f61d6d5f1c776c3ff5100f4433f3f530983f3f71f8180022b13e4c941d0eb35b58ea6692e2519a4fc763469acac05ded9c22b7345468ec3285c4dbfc705f80949a1009ec6b36bb8a2e5ccf3194c73ae1aece1b4597f7f1ca0728f6d65316206a2a4cbbde1f9d5c796a5b1d8b2a5f28a750afd0384b4bad23b5e901b44db91f4699ef10ea680bd9883bec960a141eb3c922366a8ed6ea9b0a2273a118c8bed9b459859d93ecf8cf40f39fed50ba8c48a183f06ebbe34b37d7dd5739664c9dec2df99eb66d16faba3e21d377d1b60e73db066c4131c8f4000737125f3f41ecc33dea98ffc86e6806da5725ca2f6f3ba1d01a1886a3106b8022d01377165111fb4ebd02de585be751a0040548ac7e9a7f1b4f73a362521844b53909156df2b3f0eae17ad67f77ef1719a90097db4c814837071c3c020680aa38c231bea89f29409ce85f7cb04af5c3b1c6962c5e51a6b99de1609504964b3d280c4bd778cf0876cf423f459d3d81d402dd447a9836613fca5eef52ec89ce79fd87a5f4310ad7e01c7f88a588d819e4876d8a070b63574746e016fa1c6980fd43c4ee9973cb0e28ef00ca2125933461b9f7d5563a50ef6c8e15860f26be19137534643bb38811cdc166725cd60747d804fcb4fca797901c2a5faae6adefed791c66d55f72da892b3e212f9d2c9cfab412ecb74ed59fefd2863ef434f487747a93cc8089343adaedafc140869bdc93824e584ad136e2652c3c24005e9d0d54b495e6142d6a119d71b0b7538d964ec8df21cfee385e078685b6bf4de829f9f4a37d43fec0a7074743cb73d736ce5bf10727a42fc8cd67da8b80513b560dc5dac3c456aef75d744ef06aa75a06869ca2a6ea857e26e78bb78a139a671ccb098d8205aeb315fff13af418925a716179643ac4e457b73efbc41dfafb3fc0e43d638abbac99c120f681cb5ff5370be18aac4f61315b1e563086c3b0e453d6ebca233a50d0c17d530cc9e29b209e2a8938e13129fce6a0afb255f7aff611c34438131d5fdbd89ef8ac69d674a4ee71bb1cb9ac89b78902ce09d8467291181a702fd9a0430e2dca944de8135702b66619ae8c0e2af1c0a913af842c9355c54101e9dd7fa4e86f74b879cb25ccca648c0756dec2682c1c08130bc0067ca4b7db7c2e94e7f00aec21d7a8999a405ca73816ae3885ebd6f9a46ea73280a91e4e5e4146a685bee642566462c9cd4c39cd0eba3d1fb50072e802791a4217a313172df3ca78d55bfaf0870120d24b6b026474845bfadc509075a6b4dd8537f533a0def632926371b98538107b59a10726fc1de7b3506846b01105b459626e19f069f5eb17699c7ac25eee24dab64abb17f24f76bbc6e57d4258a3fa2660267bc9d0e724d1850ce1760c1db0b77ec4f165f5ad93ddb4d04ec7ab15f8bd04fdb530744746097b1130751b5b369a298c3481649cc1a1b0b545c086b02295d75030b4c27ab1179266022ffb0b490b3d2d1f0acdb1a2a03100fccd7a171a494dca78d75a1618948167b10729b24a832013fb62af609941bc4fde3f03cf523feec91818a99dcef8be92d7ab25f4cd8a88cd6419784e381eb90e54a5a22d4ce210e888d91f6666ccb063e08c8e274499cdd5e3afb6cee18fcda91a91d3d56ce87a8535c94a245288fd77661bb0ee423965b9f485e967382d50bc7a74273c54bb824bb949a84c14a5fc39d2e93cae38d1e6e6114c9eab9e6fe8c50eccfae676c3be888deac8424fbc3327a1658fdbaafbd7e6b4643500a6d00c4f421cfd5865a975e82e1d18ab462448cd6c21391b2b2faf38685d5b0ac3e621a7aee47d0683d57ec7046117ebba8693a79d9cc6d11be5e367a7986f2e883acf8acfa4187553c00fc1cb474487ff4bba22b0489791ffa70ad0fcb5efe066167c550eec4e2977f1cf54cd403d1496fc12db4eb549d268fb8c10c2365bc4e021ae82f71d9c9752f323fc94ec5ff60400343db3534c16ca5beda3b28a415088e4dcb112c87243674cb425bc9c3bb0e91094d698b32cd3a620b61628322ef7b2c88d5bec6d6db23756e65c9ed03ee99875cb1279454a9d8f126bc4adce734f005546efde8ced6845ba313dd638f7e4a4c83d9daf9a43e8e789755bbd9fccaaf4138fe973a78fda14df3b15dd36f556908062b4d612a72a420e7937d25689b0007bded5563db39c174e4a812e4a9593ee26e114775ed2e61109ddd5766338d2b7f69a4fd0cff702df80060c43f4774100341f28fddf55b0f71419d1245668a77d3c78957dced8b2e00cf413b8c508d29930a36ee404adff46a5b3a766908792e285c052d7cac730ab4d8b43e72cd8bcfb94e442c46f5a45824741c4b7b214196a9b2814593440e093da31f9799c5584b9d97861198fd9085c613ab5922baccf77b506368cabe4675c3b8eb0caa40dbe5686c6364de6a8dc279c14f6807d9019bc9be145ec92102946da081664d47fce4425643efbf4482566505703fd189c8c9b985fdef37752ab064e2476c29e0a39252dc8e78e494568ab16776a729cf09c8732c85e3bdc3a50fd006a7e8e716b835c186adc8f562f3a6866fc968b7b5ace1203b130102125df9d89408a02eee2316b6dc06a799b440f20ba6d14a22429a5ce83a1112af6a39b8a415d25ea772cc7d5a6702dd789425b56993f615137eb981f2b2e6de6bd321935d116ce8faa99cb1d5ae09313b098a39c7bfa1903172f297672bfa2ddf56fdd12b0e4006ce9b79fc4e39846c8a1b57c44eb0388425252ee86e2bb5c7b2fab5bb3596b582cb514ca4ed91d9560cd3749f25f025b9969f53ba303c7f748dc83299a43033239ad2fef2dc3d72b76a38ca127607cef72de94a56d5e5c0fb18c65ab39f6522b0e326752e40c5b5574c533f64667b9d06920afc0484afe025fafe16504fbbebf24d569ba044b20cfe582abcdf1fd6f8ad6c0a500c652047badc784fb9dcbcf4b1816957900d8bde7339c82ac9c99f49b563f22db5a1c25d82653beb376df0a6b427679045c6d8937f95326f6b8b5ff7e720c97d48601d8b443e4fd4102ade69c5e6593008952293ea1572750d8e9d6a094b97270dc9b737ca0ebcf08c3c0ea6aa66461e21a2ef457c608e22f7fae10ae38c65134c051acbda7e8a29f5cb08c32c503642d816ca13fc1f916070f6b43f3f893a294d3bcead3d36c26591fe552a134c31847419386434f98016c1aa9c71e3ed1e5157945947bbdd6c8eaafe7c41270140cc3fd2c3a1ea97652c333f2308985e1973b43845ff1b1b8e8b86f3057230186a027f6af230e7a047890cddd16c26843477aa4e1a3f279a32446d047924f538b80e7d094d7af3bd2f1794ab2d055509764582ff5e6ea5ff5fa1a9595ebe3f0a30d881d55de7d59624bd15d2bf3ced92e8c584729bf35ef51e8a811b3faad636dd49d3f9a9e057d22e63d57a0f77b5ca90e0f7d058381a2276e73c72a14f8263c447ba9bbacb3f1955f11dc9a61f7656787c25401ea4a02e6fa023850e150b39efbb80e416115615a25035ea0b9df8e1a88254eb749fbac2119d7e7d0d643862658e6bfb471b646c1c666503c657031126dbcdf8e2912e8665c7958127a4d2832ea6c408d55031c6cc1cf53d60b75f8efc6dd890f0e2c5217204afbae23da14753edd235461784ccb85b2cbf6024d3013222bcdb27fb473c403d1550c9986d53db4adfa824da2725ea0954b24e062912cee1c3000e427c7ed85b106a611bfe52cea43189f600e07a6a0fb33db3c42768da9133282e202c904144e630342f1cea34e5110145f178733e56918915c896ac5d1c557a0dfe1e1983e2dfcbc93d8ec316f4c7389814b7b770c538bdff793d856069711f35421bc2a71b4563a8ab1d867bb99b5577d364ef0843ef02f63fe69cea60cf3e2e56eb33b4d95e1f5ae291db6c1cd5806a9549c20cbafd808482579803e9b6007ea05613b2037428664bb269f005bce3fac32cd98611ab5e30aa5923b3ec708daf8a240aaa81cda6544d47d90f5c99a3aec3d6db7d3041c5821fb4e20351430c497a1cc2a33bb1c0ad4f1ad2d109b4eb0ffe0f71faff07dc034a307ffa0078a5d2da07e0a5186a9ef7bbf1fd3ff455e1a4dc9e43046544cc3a9195a2a1e25682d411ad0fb8033f69bdf895026006c4adf5c64df8a34d42bcb05daaf2fedd27c8d687d6f5e5e17749846ece883d2548788a22e239df9c47d5eb1738181cda31a261a44a3a339b5b65d6856337dc3a2b6aec5926adc13b9c3e752507bb00c2be36fcd0d087ab1933e63aa51eb9472eb3aaa2d4e1fd50128920d6f1df84b47b14ac2f733284534347f33936c5b386e7296134fadbd0950955a394e1881b3fef7b2d82f536d83501deb55aa021d09f4fd5b62b32dbcf96094aee395fc927a9043de17ebea52b593c4154254bfab59c4dfed20de6aba25df8ae2a4dd26c51faa4a1efaa364627c5dab9f722a0180d84c8eddc657d11f0f2c0ca7e56a237403bb6ee7f8ec6e37283c58cc6da05427e60aaebfdb85fd6615b47e613de36f39c74226dbbb3d442b49be302ead4e342b037da3e5d90f3c29ea2774a116cf8680fabd066c9a0ca2c96131e658b98a3de4d11402e2374a39c4fcf363d9f894f5d3feaa820d1dd0e69bff55dfbd0afabdffaf7c40578edd72e1ce86e08e5bba39bd43891e5fcf30ac1d949880ee2a0650c61ef4e098382f53eabf706f40c8d5deb779e76fb716924fc891586e4e9f3372f2a04c6846dbb6695a703e6473c84e313d0223cab59c7c6e1796341c50c318b0efd3b14bc5d2092fbb615f6499c2a9edb86cfcc3ddc96573a513aa0fb73e1c873809e20fa7c3ae13780341e445506f60d42aa0ef9215d3fcdb8a38bcd478b56245e34d285f190bc13ae68467e8ea0546fabbdea2751a4e56357a4ea82b0b79de93d0513a7e5aa8955e8b9564070811ecb6a0f490e93f4b3c3d648a563d5ee058cc61ac9a68011b1c6d53036d22330bee726a811f710d310b7dc94a5b8dfb7f6d3a07adecbe94c9d2e1ed4ce7cce359a8b88912c2af0cc64051192d0c9f59bd888732d385e49e3b4556bae06869a191c8137d180ef5a6418761f490fdd40211371e93cc1a7c75f5d0263c4c737ae63aa90dc70f78e762592d2abc14b3de8d10f57a8ae5fed8c4702ffae20f7d9339bae7f1f77784e6d963be160036a3214333401588bfc7ac0230a12f5ca80b2504a8f17a7edea79673f7b6ae3165602ecd0eb39a2dc7f94897cdd04e0c8480b2ef7b5201dda37558ba9bb37df02f5f5992f9ac52ea8d08412d8e39c1624392bf42a88622846462b025b610efad0315543d8ab6ea3f7d79281c284a440e63a5ccb6b70a4713aff42f4ddd7b8dc87f068115484fca9d17c05ffbf28e2051432e4db43d5b0a0bd4ae488b883fd2e2f1c782c2a8f37ea3fa727b35937200eb80b0c4b391f4c5cd80f57e673cfa498d19ccbbce232e70b48403ec617192402d9ac1c44d6b6414d9236e437962277c17358a9e805d7d3b7f52f935f8136b68a80fd5ceda002561cf3a7d3a3aae33c5220385cd81ae5c4944d5c6ea720f6a04eb4e6136f216c5571034b6c51367cbcf2dd242bb5a9c4824a58af16c67bc2a9f57d4f8bf1e15a04f3cb08f76ac254bf4ab4045da73adbd5821e11d5e31b009828e3200a9c67352d4b52c7bb15d6d30d02acc03bd5569485e4a868f126861a368eef41d9973b669621a071017bfb616dc1cd400d6884565917fd9eb3b846764bd0a89a400be553081cbeec11c3b866a82f206d1b874d8a1ac4259963c1e37e9f9517148620ed664ae4b3223316964a86f5ac2dac5b3896909229434968e398f9864295f5fddc06262287f9af9c1c75cfbb7a69090ccde3832a1082add6d02e224a3306d3cb3a9a627e435bcc7cd2504b28900a7bc194d9bb33e240d63331a7e38af25069b18d8cc79fee2fd3df4041c2e5f8f648a216e0ff56a7640da68f6b02ee8559ffd85f431d2e905d0cecefb1fb9aba17b8d8da61193b68d69a5771e2471df60bdd6837272cd232ccbfcc6609bfeedc53158b68c2cf892d7ec56f5f747cc04d4d4a889ea0bb34da6634a62dafd6896894a5e2496deae8fc44d616e189677e900690601b1694fb9312b3a3cd0d081465c1b20604c83202df1014738089d200c9 +MD = 033a5e38a60f821bfc35c8ef32c48453e4dc3fd7988bebd807f1d579df4360d488d097eac9b086ff1099a447a2ded1c2 + +Len = 60424 +Msg = 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 +MD = e9bdfb8b069dddf2bb86059553f9b337e869aa0162ee8885cbe999dafe2185bb411aa8c06cc524e4f3b08dad667c6904 + +Len = 61216 +Msg = 8246bf7b81b287411777df7ecb53a1795e54b150ff3dd584be2bc7b8437889b6c0e0f9b324e2a5d49269e0f111ac169885535c55dedb4b308f3b0f7841c8bbbfc956df2658a05ddbf2ea78df22e42e0debd2c85801eaaf543afd81f83f5a64a287f09b5b86b2575c2140cfd266c392df7a181ce1d232a8f6a6b946c0a3f72d65e1f552da14e13a6206b30c514511ea16186f8178b87adf20bdb78558d767be12beaf2f2c6cf5aef2898d58e52795ddbbaf1d1fa61b8cfcd9663e67494172beb0086457d8f4b65d169214da14741814d4266b1df2632ea62a899814194be0d648a65df56616ececd50992bb699462376c65a1a4e5f92985190f0bb3535c78ade180e22f5f395e0638d64d2269ef3bed885407db05434442b1dee06d7cdb03ec837e3a2d4ac4d55145e28e389eed6bde32dbe5ebddaa4985f7df5f691e324a3a3688af18af21197506139c248ff7b9b371e282fbf297fef5f5facfd0c0c812400386871816b7f21b8352c10fc473ee144e512734ce702d3bb2187ac9eb0526a5f1600b5408ee28ebc3884321c6cbd2a8cf101cbef89e9cff361fa67d26514d1209fe83f50c2e828cce9b6b811c652d18ff07a9c0f88a14e88af99c13f9144e2f52483722abdfc9a7ac7581584eabc70be31f1662579b5c9eb58ca4b4ecb6f2a3d4276e046c69c5e366fccdcde503682a853eaace9c383ecabfc20588889f0117978172c3d7353ee9021a960968d7d71dec4dae294fcb8014b18109b654384332a440898674a9fc608bb626345f8edd8b20356a9ef8bbeb2392b3f667d9e77f9d024afc75cc2ec6f106b7c3755290421d2adc2652207047a06a3f15c29d157fffb98913ba662d66447d07b6f4ca45ce7a112c2a704e525c32410daef02a2b0901d2e3157aca0ca200f78d47da4f15484add0cbd1e0bc9f18220050918088fe64b54424ce0813543cd7d31bd4f67687a3796632984de3dd0370e0f6d63bdabde84478dfe11120e115516db627a9ca62ae7451bb4cc4f16bffa141324f9d3e6b854b3ac74380501d33dca737c8475372102f21ba71be6bc877339f97401d2a73e65a186f67be3745330a1e154947a832731a34b4a9c2c97f04985a9a6a34058365c1805cb0233d157d4a40d32d334f3041c6293e474a80fc125000b0109a76069e421103df67d7fa8d1dae05d692aed7f6a36dbbfcee38dc4aeb308cf588e279fa3c38f927f4ae60ed04c401f7de4da61c3280b21d06377bf8da58656bb7e159f41066b13c4206e50790016be37eb2372d13e0b53a2b2377b69de6ee058fe923367f28a08ee8a7f3873004b83c0c62e7a3982c39d6d5833c0eb67a9b357960621bd90d5b9240d818c6754c5b640fd6541a6fc1c4659dbd555bb471e17e1ced932eae7346d8f33dc15fc026e9fde192f8ebeb3fc988dc584048086b4561e2f732e97ff906e5783f89bdb142d86c3a1f32b29af4dd9329da793e22d55b735403cdd6be1cf02a3853ee6ab91e9b2171d1bde90f8f5526feca8cb8b43e8814e899d070f94db729bc214bd15828c6c01160e709b97de4b6d39ee7420d054fd9393fc732a209a0669c1e3e9c1eefdfca91334a9f193ee0b530ce1564cdd83732ae5c2ea658ef605320a143356dd24aa389cf5503bf40fdc4aede938b5705c2a3b08583468e5d6b921260d607d58e9bed639b92f20c228047a656ee40394c76cef822419da2d21685b9c383bdd65347faa73e80c490620cc0afbd820df4eac7f6ddd9061636fc15b0bf4fc8b1f0fed36ddd1eab05dc8e17c23388fb5f1a8f3acdea003d3acb29dda57b7c017ea5bfc2b96dc27e3050e525ceca3fb6be0a9853b6a54e5385dfe9d2c676ceea8e75349a6fe1a086ce9e25bb48ec485095459487438809d581e5ba99b649bed06bdfebdef3d15f315b04be4cb30239359f7c1259f71ac95fb95d2a96d76cd25f915643e4d7a5551a40352d5eafb498f216ee804033c6134e96d6a85ebc488fe49978eb50ade608be289fd165917bddf2a64d7cee9c225e2e94c2c255d7757e0bdea830b6c90c00797eb569060ab07ed3c7f9469992b8307c5db1e720bb6bf331fb74b26bcb8fd2f8bd0652947dfb01f1f6729bf5b9e000b43c14a523caa4a5f35a5eff041809d6a85e131ca55dc3fdf9ac59db7774326572ca6b8ae3a7b7fccc85d7650450e2a1f4fc6c25cd3ca3c947641f93834437c5147346f6f4b50e6e29f86e82d0e8a2cb8af2620c509d12fa57b82442cdcc68a625e11777bb851080a84c94e71e51d299c6ea954ef3f17a17c7131867ab5f3d9f237e5d8bcc9a86caa3dceaf0312efab3354f865c0bdc71a8020f5c80a08f3f06a9c599a19c57a9b2c933c13cbdd2739e528bb5b22ca072019507711c41cee57305314c679f6f21bf64ebc82b18eed5c1ab4993efcb0ff3dafc85f69903b0b97ae24bf64c6a235767236f5059d6c6b9a3abe3b1735b5d9f8aa5154d856ab72374bd9027ae7126e33061290a377c0c67ead0f49edb722bad973b3fe67feb54cbf6e388412c48ec3db1cac346527d2298ddb6f6ac9693fcc6970b6061d70a1c1b8810bee33455d5cf51bca8a5195eaba512da546b23353372f0a21140394b7f8a9eb18e7e652c962096b353972aa50a151097b86b0fda823b4a9becf1f523f1a1a14281832d318fda074b5eacd4c4b0715d8b7d2cbaf84b77eb653e07b93804e936402291fb09354419d12456c642514260322d10c32301b1797a9ee1f3dc3bd9d4370c1b5d18290745013f156db24ef0bf0842c7a6cf47807b688a2113a508ebf193888fd1e2dd8c1f58197939791c14c09a58b1e4617f6d47ab8a45b706fea824e2328fe80db55b1f224de2c82b4b172b54c94fea8e3bc084a009b05c968f96d4af946c0ddd62fcbb0c46f2883d4e8045b43f2247b9ef32a902930152c82e20875828d4c1f648d979729f18f813a8d8a65504b98a591c2c3b3fc0a958006cedb3885a2a92cce979e101a0d69662fc98c3a3c48601004525a1b3ed28caf3ce46ff9cc30dfee5c776781616bbf19f9c49342ce9086a23eca7730ba2f03a06c4d4b211dddf74b55527b53c4b29882e0a526e5d0cc12458953a35937ca013bde30f7194151f82d035360ef0c8bfd892e95ce8b08a30ae02b1564017c4a8e68dab6fc480035ea7bac9fa0bb019df51629bb129c40be785b6d37458d5258b20fa707e1152131d61d9961c3216a9188111b407a803ec4639e97e2cb66819c76188e4a2eea6eecc3fa12bf4f88100ebe624a4b8e9fcb5ed490f13d80f4d1bde16bd7a86c2ead0fb9fc5ee1ce58bcbda0f1ff05d762ae34d21bc371eb9f0a64fcf1ca482248a741c00ac7f0c7f8344535a68195dc2fb1ed652654a594d0f338ce90ae53d8a2242be10c9314c3d24050866a1a24256f9a31959aed0204ed55e25f31cdf016a3ec7523eb0b74494daa83992310da3b8b32aa6b5dd6b0c260f809b7bd6d4865b3c6c68f8d7739e1d1398878bbacdea5e941feee5857d6568fa456df1ad7824c3a7bc62bdb1f8a13c6b4072b183659ebf38fd52773b89c49e42170de3253c754a0d41e01bd4a906895e4a7b824f6729610e3d81c97402b22c53601bceb283f034e9676191c427367a4911129c533522da706aed7aa38ab699cadae812fa011e4aa8c7579de4d5a995c82ed86e537203822c1006095e844a7d04c2136e501667c1d7dc42bedb46d842581e2d56b480540e8da76bd41981c62c9dc02e3f594655510300b372fbfd6b2685498203faf29cc6119b7f895905e25ef24f88e46a137f6e96ef1a38eb5baab8bc4b86e49b4b364f5486c1978173075aaeeac41c27003e712ff1e79f1e044f5f899eac8719ecc900c2d3c26d477badc6200c6035048f2b1f1ab3bc13f86991a159bd5359fb79bd90e92d02990f625e17f23edddd8732cdbf03af08162f0e4a24c9222bdbb4549c6633dcf2994dd990d691fc9d54337d8ed7573e4c341664b1304457868ad91fde073f6e22fc8743de688bc03f677dd1e6fea1fc08ec42ff6f7a47d803f5de3e0ada787b14214023af645c243455dac27eab6062bebd3950ed59602e249b3831ab765b7e36a60d1b8c506f830ccddee1be641f0cee056debb36419c458e98b8d286164d21af9427ded934277392e0e922e9f3a55078355324a10d135117f2cb30a02312121a984dd4bc3817b49f4ce7627d34ec5bb8583c729e622eafebab045d8ff2ce5fb2548bc3f678909afc0b2e06296c8f94aaa8e1ccb5a8b60712a9ab81dbed48af80b028d30d5e5acdb0030634760354a5550b895b6f47740095d608c30a7b4aab8a956e2b8b513cf6c31eb914ea610436c16a7e4753a72d437b18634ca6039afbdae9a3f4f8b800bd3e428ed00fee67eef7ae06b7ea31ac78cc59034437ef014678961055dafd6cc92859cc8d6d134476febd6ad3ba4bb846918031d243a647346a82fd77bb8749c3894abc768a366475de81f2c54d5e1855d175351e5490346eba97b18122be5e5269fda6b0f0c19094a0e1e5b22bd3954e94205751f115909c70bb769c980a751fd15ad266271a8e7b4bc48dc5da10f7d9e269df93a39d226692d892f0a4d354d1c84987beb5ab26d1e7143023e47f069dc438140bf090b3722ad54ea4ce81c41157b20ee024da223f7db817f7d187894341753fe263560b6b3f9af2e19e7c8d87857daff5fc11496c13988a67278f4a726208a83f8157f2f7da0fc6ce9d2d77da5a92b225c3b76201b49cd09b70010fd32ed9974bd4fc30be021c129452fa4ab3ded95f97033336a565ac33bc3344a10eadd0542ee3ab8c69bfa91d5a454ccdb91a3bfe7443ef8d0130b0f9f2f9c0c8cae7d6260f36cdd0a0199e3049ff8cc995159ed6e30c522ebc1c906b6449dd4bafe5d1571656cbc20a19e39389072007eed7ec300de5c4e37f3134d13bab03f466aeab2d6dca0b2b50c6608e41e5724c6d690b541a56ad72f27884739ea79a89974a4af1391af7d21a29fe699922e863bad2e58a31e776a4bcf86998b6c60ad3eac298eaa5cff6810f48a36bba45ec137c1a601a7a21854186bac98aab8fbb9a051d7b62d6706ffed72d38ddccd6e5235b4a664b1e8b4311f7c48e8fa48b16a69363dd9ff785cc121be0a607f65e3b5c0169de6745ae18dbb8209ef0c94081be3a9ca5ea2e9674858367d33161645586137fafb416106d6970d6e3f5433865aca2d1bb8ba32ccf1fb6cca9a335709d693c95c37bba3ba881c8ec43e53afb2b36740a07ca80ce45a85d170fa4990a7acc22b1010359b733ec686ca80ad50f3925584d70efea053ee71f4eec7eb5bb54786dde5196190a7472f75df9aa3dfef940f5a4e1410b5822a5a57b2a77b20a9436c6219b7a25bed5da1ec81e0e9a50d151f4163f090b4f59aa96a5b0d8b880a0ccd584c7f8a35bbcee84b4fe7e138b2b1efcab739012724bbe9bd566e9eea3e102410ebe58bc679374d2298341d0396e71b66c651b474a61a95c1234f17dfebfa2b2c766e2976cc135af3094a1fae10210ca60fdf5d25e01328064023a8d16a372d2b8a8de5df1aef9c4cf19e4b90c4fc3df902465dc369423b0d3b80a4575f33c46e86d93357fc288b810fb533441bd549d02c0b28d5b834293683eaacda219c6b95f9b4a489d65a934fb20369408b489aec0ba250c543558d22a7c624e257bd9d1261b4bbdd3ff26e09771d500e99c2cb7d2fb0682a9112c14225b79f087833c3644d6debda9f8c563ecd677a16ddd03633e6a9d16e381880256c139da4f97b991c1b34b70a8b84f660238669f1bdfd7570eee31f189eb3243d097e8350521168aa699d9fd57a78b90e27de8217c0a6f3e4a710b3a23b9f38098c6cf2831881cc8fa72d18d3e2e438a938f464f16c795bef8da741a3a529361b43536dc5c3493f4c5257b47e6b33dfb1d54c852747c0f7f2211b2b9551eda8d2ecb64780d8d43b5109a1f54d6a0428c89b6b5521b93a62acffd0d3efc8590ad0e72a325cdfbf3b4e2b905db965b1ae5de9c5776957222670888cfd1b7ef7c685a11390b23e66d99436a7505af4e8dad24edf4e768834bddd4993e9c0fc467671c8f6f5197b6770b3b95b6faa8df638c6393d5cd1f2ce9353b19a4c48b6c19525bd68d20b1d3dab2d32211e10978632ca475424f3fd7c31745ee4774b4505ad020cddb9ffaa55e3712f9cee25b805732ee7b829552eba229fb0170d210d6f289725ca1f7f995ca4201023527255f05494a8ddfc8e0d04e16643a66062967a826596b264f3609e87aa6268dd5ef7c3517bf939f106fed8f8488817339876c454fdde2b3d03a6a7e880b4b20174241b14455750b9489ac2d1c70bfdd93b04b92ab07a990a18c215513385a3413a4154079141b6b7db574ef8523daed3b2e6e54e3dea905ecb59435c4333c12f1a060a95e056e07f27cae9e67a9bceb5a893b569e6ac85ad63b2de54306d702dabb8bb59a2f54261c64c0026c0b4b1f17471c5f85b4efd689a8532f37b9154bf67ffc2cd69bb61223f713e33a5071d09bf2783640c307c22d836dd94952dd376c731cd6b94f7d112ebd0f09798015480d11b6a476a0f666e955e5ac20db160c651f537aec558f6c653d1c3cd2a41fcd962d4071cf51a60ae6a52270655baa13080c0ae216b5d66bf1ffa343ecc376a85ecd7d65f5e0fdf64cfb8cedbfdb80947ec1a7d4e0753955fa8b0ae771e504218c79d5478d54e57142df8bead76280d7eec69419f19f9f74a76abbf00612b07f49bab0e142b645c5f0da873154f8922381a43779f33af20e21231c265553620cbc1676f9b90d04387f73e888dfa59ec25ee2fabb8b4f196c903e975006af020e0e178f589d610c13173316b820728cfaaf0844a963e5fcd61b439338c12f79ce664564c694bb449edfa17a89be664414999f7c0923048393eabb78a42ddaad94ed275b0b4622942000457ac2628aaf57462e0ca473b496ed262ead5df2b887a8ca45ddee5d9ee4e3a2a77f2db3e4b30dde3d5b42f9fe1d2af7229c2bb9d1ef51262753387e371c2deb50f2905a7f397c8854d1ab60e900938421acd52a2eced8295623b153f6254706c739b4fe602aee6dfcd6a64e7e2770f6b24525ecd60a85fa59b72184e2e5791994be6148916ca9b5bcd2fc6cc47a09745ecfe1a8d18da0c2b87550b903450a4d40e75edf19e9f6871d2d7561c3e2a527abb2d205283d71a8fcc70699622d44c9521e756d00871c0ba64fd9d583458e372357c0ace20440d5ac140acc06866db652ca6c974e30656bdfa1f0720d8d0acb4e24734407c9547150c325fbf836ce3bc8520c070ccb17cc508982dd68a0620bb382b276a074f6a3703e1fce3e27af813d201d6542407b59827056c19c68de20dada46eab3ec6e9395ecc0ece23f58af399b6758f677d937fcbf35c4b2cbc5324b92f8474b1b046a4635cffeeb6810ee422bb1893257799146dce78eb1b361688f148e356de800500c8116ab62892066e238c5a0fdcaa28de93134c8a107f8eb2dc6d05e233ba96c6e385b9c4e8ad03ea02a694460b89d536c24e41a8aafd3e3ad12886774fc48e7f4c26778b752689f046a661d6107b30c571fbe2b75923a77985f7cfb691325e8268802e8a6cb30b0975e84d40ba029e033898ba4699a74cf741475c0086988988df0f39421dc709ae06f8a11636b4af686ca132c6faecb14cc9b3b5e5be4b91fb0630423336d6f846805427b73505d77db4a1e6c8eb6856e255b967e6a6dffa4174afb3ee1677697b58972bb4238a98ab770740cce9beb0409bc4ec83beda44f4b0ba18c35b0cdfa5161e379d8097758a4a6dcb3374345ffff262ae3d94aee49d310beb63631bcd6c4f75d5c3ead0f0929542009d297db869001f478496e26ba37bf1a63ecd28b5394b2a80c7b0ab9c4cfe006b8a67ff4c242b5722e943f93ca00827c3c607c81984bf98b32970abdb11cb35765bbe4dadba0aa6daec3a77f9fb5c0aee89915e7ce7036cf769b9462f99a35daba1aacd3f82f49ac9fde8d3064dee076109f86051c8cd03c7f8e8ff2c4d1ce595fcac1284179f8f9aaebd8ef3f044c9d5c7bb823ab262f9af678e5b33948e79afcd30921df05201a77f4720458ae6beb73349289a3c6bbb182617dee8187e667383e6e05fa5b2ad8ad0042b7d864a527fed2fb7f2bf5dc49cc523feac3163586bb12d71eb9047cfbf4183050e7ae621ba45edd4c6b39fa297b5213f1287e3abf2e572bb24587804bf6432416ac150a8d0edf1f398c1d7d1a386ae149d8465fdc3916540ac66c9d905889065250200546e45da98eb626cde4aba1913bfaf60ba38356396e633c3a91c5f2be4dfa58bc0ecde1639310de524f7bff0b0fb716a5deb51fc225447ec117e387354cd34395ac7171358fc3cc7423518c370d362f97537679d77992ba99ea5a4f519a036bf9ea791807ccf6789c27d451fe7da0c848cb6f6d60b075782ad2d352fb7eb158518e8ddbc190d26b3024ad5546a61c6a200d480245131441dc97f6991c3f0690036154c44b247f2c9ae283a0f9d1d39c87e3a8416eea989c17006a2b9a26299d792b77da8dd024434029ff3bfd46ece6e5133730c47d281243d6d8115f7b420719b49d256fdbea398cc1c92d3c4d90d0a2669eda2d13ed2ac8e1e75151867b544dc36faeda8ff895e471887e9c2ee7e326a4854492f60f6c0ee940f55a8efa0e7c22957cb43277dfb202e437073018a6da959378dc6cb5607eb68a0461dde7bc0d97b697e70d8ea05d3d875f649c4ca22400717df1be078f7e0f6e874db96be76aeb7a085968665e4de716fe9bbaaa5d6dafc75bbb342e8077be9485086bae16fae68bd6f48b26a4eacb3c1d93d25b611e683c1a211552bbd289a306793ad7d1254f8e099ebdf7f79cb09fc2362c86369df478c30aab9ac9f539441388700ea153f02eaa414701e1cb5de7f86b105462541b245e603c2f314a961eb21d547d0cec8f11c0c4716be9df9bbdc41ac5ed6fa9a4e8f10a11397b3767daee202d499c58f5df530f835e984032c9302b9478e506596b86f072df3026761fcc79449dd900ea416c0ac5017456eab24387c51d4ad2005624faa649d77e89965611e19f4a4a35de119d7f7d078a8b200514a00628756250d410f7a0f8a769e693ce4b77779fa0604db0f8f9d942dcbd7fbb6c58065747029d1aab0c1b09deb88b99cc4ee868f16c252b799e70e7a62eb865733e6de0771387000bb4c90cafb4475baa4c260bf1ada3f64a9356e2b11eb8f8fbdee478b92c9aaa5fc18918a681cefa2e98b8f268c8cef9b3011399c533885e4d60f387d6f5df00ef5ae49589c82860a05b26831e68ae1dfc102d76aa152f7db1ed227597155deb02a861eb21305e7348bcf928da334c486ce72ee0276db53f6eadfaaac1351c51e2d388823662771d6de4b84866d1af634caf9e3f06e3238acec7028e1ffc251cd502e1c290057b4459faeb4a88ebdf57e48f03fa0d1e80481763c28978137f32245df514f6c273d252271a980929e50a7cb0e77b05c7d46092abc3049321327d170d4bde314166aea193ce99b032c8665c3ad129b58528ba87c58c6539cf47e3f53a6b890a295cc08e658eb547af9052cc544a6ce701833e3ed9a61632c5c54e080bde7e46235df060c6e354944746b51326d9ac61e3edd4fe10977d46aab4a596a92b24b0d6722661dd54de61a3f1797ad90651ecd26e641191e9043d271dd0e83cdae20feba24ad7d369bb746a9985499559c350760fd6bd852312dee307b646eb74222a09f6440bcfaa54954546c1c8815b6b5578d7124b14ce0ef2877a41f7de804bcad974fc45faa00f8edc01153ec693afc380cf000365716241ba7e58453e86c5b702265bcd7bd25526d6d169f58b89f86135fd892ca1947593251ce376330ef7b92d1447ea7bc88f24dcbfa533f9c6aff8406b930fefc0afb06f5bcbd3e4a14b980245a9e5220b235195d2b14138d13a50482107f5787b78604144f6a47ac6281b28c16a0697227b75aa1275676f320331f625ce246450386a43dd4d311c06f60c489070950395fd58c287daecc7727063f281cee5dac457971c30b8c1f3e81e3109bba5da8ded13c1863ac61a6718ebade33df17f02613daf7545209e27f406521448f01d5eb124799d32223777acdbd9725f1e3c05ae537af5226b0edfb21739104238a59d699749b177d78c21b7a8ad46f13d620b33ffbf45d1835a43abb9ada6ae67bb739ed6f76712cc618bc0b9f208fa353a3b79aa480c5a4eca7c6655757e9664a708d6484b690ae8fedd4f786f5f83f00cbe07bddbf3c3b6a5b26b515a3f0117b1839c550f5f6715aa40ec4ceef4935520bc659e41a216a2350c43172492f868210d756509f0323aaedc209d356e324cbd5c1cb742c05bf9c0b3750d9b1e823f3ecdebe002c5723e52d872d40e7668bd2cc6b36fa5f598a58fcf899d868ca78451ec852fc3862f0bde5c6b573fb43e90b623b22d34ebd78dea87082eaf836f1fa291ccb811da71889a92918f90cfbbada19ba25bb5471f9918037927dcace3f879e546e4b769419dcea06fe4cb70e8fd35550a60f1b479b1636c64f2d6af0af81e107d1b7bdca632c1ae8abfb63ecb66bc7a72a4b0d8ebbd11ea51f66533ed05d839f9c627dba92fbce56c861be26fd17c31628fb95b80a56ba4c99b50e09208f188404b810d517c076c9ca3c003d927bea36389d6e63d51b9c35349615f03eaaf26dc14521ba602ea6ca27c6d4a134ecaf7fcfacd212caa436e78685e5848915b3b558761acb0a7ad0d077bec5e2430e856b64a67b3549650cebf +MD = 4d7909d8e5613249cae1a82481093c7b3260abe835294e5f72c6683a65bb0cc5142e6b8a21beeae531e7c3fc8238349d + +Len = 62008 +Msg = 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 +MD = 7ac9b2b81f25cb0c96971b4647943822bd86d0006fa26049cb9943a09dff78d287afc49831f5c5e8b225a25e0dadff44 + +Len = 62800 +Msg = 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 +MD = 4a86527c19095982e491c56f5fad57593d827683ae08f0ce40b607a49ce25222abb4b96762596e4809574222307e2e47 + +Len = 63592 +Msg = 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 +MD = c55c7d5fedf6c5f93126dd90b6f19720f56f791590d42903c78a778063b93ed5174502c6b76b0d2b75658ce813e867c3 + +Len = 64384 +Msg = 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 +MD = 13189ce20ec85fa2c86f0c51fa9de0d0678e6ab13aba4ef0856b37b2daff99b5530b258901b6297c68d542513082c115 + +Len = 65176 +Msg = 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 +MD = 43e98dd681cedf885992d37e500247fef6beadebc6d90eb05c3cae3d808daee1a483087606b5b9774903ed672ee9645b + +Len = 65968 +Msg = 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 +MD = 4cc9b319af23213a45f5b8ec966905e20aa06248500cc2bc736b171c9fdcad3d67493f930753912d82125e8bc188e72b + +Len = 66760 +Msg = 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 +MD = 63c337417fa6fe40cb3c6ae8b9d9092f4f3e7f4dde7e583d94f540383eebb0c5a80daf3b4690861c5b0e5b0d29fc448d + +Len = 67552 +Msg = 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 +MD = 025dc380479269ae1739ed9631f7606fd2927f71893ad74ae864d6af7d14323be5fda67b2c456fff98387239b8eb3a13 + +Len = 68344 +Msg = 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 +MD = 810231a63c06bce7f411f1b8ef106c364564a4b90fb9b9b275c0749ad3c83983afe2044d1844d8ef76c03a1acef7c6b3 + +Len = 69136 +Msg = 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 +MD = b3b87315402171643f4f2826ccbfa633607fa9eecdeb224395b69ddac04d01b1159034fbcde1e0a7fb3c38155ecb6062 + +Len = 69928 +Msg = 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 +MD = 3d71f08e52812bd83b34694c14eefa3ae29bf4084e608c7832d23edd52d33972ec3164f40477f4c45ae52d147268ec8c + +Len = 70720 +Msg = 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 +MD = 6a76b88ce50bab0682ee7cb670821ea8f608e7d70801e7785d26f9823455767914c5c87f0054a576bdd69938a6e6d9ec + +Len = 71512 +Msg = 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 +MD = 5377572306ef61982330034f0a28fdde93da57c53cd1365126cd496847bc05694fba3d508b55c97db476a75876ff6474 + +Len = 72304 +Msg = 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 +MD = d3e8ef0c120279753ba4211888c2b079f5913a1d9828500cfc68f29c9b182a8d38608cc7dae41448198ab428231c24bd + +Len = 73096 +Msg = 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 +MD = 6486d90890cc9b399c800127f495bf67f692511b6f26c08c53aac308d3d3583e7184bec5ca9d17905d5b9717d43fa0dc + +Len = 73888 +Msg = 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 +MD = b0181daadc927c25b4a8b4f634aea80911d31181a379d3d4689f164e073fff0f268f518ad3e131122439edf25c53bcd9 + +Len = 74680 +Msg = d91a18cec8f9bb63d2bd0501bfe310b08556a4635e38f3d71ee087bec41f781d4fc8e2f3d36f961bcb701073b134aa3eccaf0fc74a2df1488e4fff09cb5011ccd28da669284591b65c9defa997e75cc1752367a113c643ff6abbbfbcdba877540a724c79f00313fb2c4b8aeb9a84900027bb9539e48c4fc4592dae1f1bae137da17ebd6b533283b3e482c981e294adc48b7e81d7e3067e6103abb67ab4ea4b0f3cbadf8778594ba62b4a94b2969f1bd5497413c338bc389c1140be14cde488d1862c9b158800d29caaacd3c8df2b41fb08a534440c36e63f2bf1af368f25338c24deda5caaaf805d09af6e09e4c289fe701acaa487fdee10f8c86f282234b208c1d882a507efbdb0ef5c4dbeceeb5aa52adabe29d098bad821cce732ad996f0d03207c38c647f15f04b9592ec42f1cb9deedf91c108fb05e4d05ff9c58ddd06392c0b15d11408430f1d178a3ef143803335c62c56e6b3a6c257ca0ad4d873fd117c0085c0d60dfec5ea9936376241448d22ee06b13b2bfc85138b0aeb11f23213a26687ce432685bf24b93b782e71953636b5d5726efa73b784118e7af2de419a2fcbb06be3b884456be5ee73be4afeb8d1bc0d2d0a7598d42a0c1a06c3aea82f84ae842c205a770320ade3bc8a33fd7f847f12239643f86595c922113cd9c23e316d77819172ea82d38f9fb52ac2fe04df7d78f88adc0ee627d72b1ca6f64c60c6a70f0eaf983b2ef4e996e0088e9ce34315c63e60b448c080c4b9ab9a7a9311a4d9bf15e3410562157a5ddfbbed36954ff67e47a053329f01004220afdd42db6c840c59d4f3c5e6b5805906ad657785668e15c6d23f68dc5918592e2f94b8288e147b2ced26e90745ba1cf7658dcc5e175b011e6edf3802d98b6326c2477f837a298011a4510b6e56761e247cdca169e2cbd4c0eec93cad02b7f49cd05c0576c131bfaa831899665852d1004bd88343597f0540ca73e325855c82130258f66ce3bb9e4a11e41f99dbceda3d6ae80e74dbe317309a65d826a1b7900bb0a4aee062258092c92a0a6341489e1e42a19f68ea769ef2d725680b1877a2f963e5bb7bbd0e1af72170e67d395e91357b8bb2ba25c7e119f9293f5d2a0b3f6ea492889964e3d1f9a34f3022248f58056e1ce4c2ee55a21888e7aa8786e0c9cdfb11b2c3fa352a1cd72b740c83496720a2bba22dd48e3670fef756349fa6e6b9c009a675dd70a7c3357c2e96e61b22f9a20e875548f032a5d3cebeced4bbfa94abd0f0498f34cfaf36d7cc5bbd832002f48be0d3ec2a1b499fd440c0d69e99f1071e1c99afdff61363c4e9b58a0ff2df12aa5b141e7a54becbbe78b515dd29517a3787f08000dfa234b9e35ecc1fffe074e062b0508f6387efc3e31602e64d286db3cee8d015d0de322d55920441cbb9a3c4741332c7ec3764bb0c6e3e485a086a295ddcf0ad7e29d495cd09c303dabd17dd2bc735c2433fd2da51181881f453f7eeb15762263c07a499962078d4a17d5980d636c9fd0d23a2c85dbe321190ad8faa65f2b52e9f1a2a8f6d60a642a47cd156200c7fd6ae656cfb9ecb0b75b377a9b2e8196a151bb3cf1daf64cbcc783e27d38592b7edbb8789ea70c9153cd144cebeb435e17836770a9ad88769d08133c56f638412b0990c922b8032efb57e97771466f2bbc683c685ad6552f0fd53e022b0663b10bddb671e254982ebae1fd22b5a5cba799e684498bbf25201b164e5d81cfa222263f719767e4953a9553997640712178b5e6853ec5cfc0f0c8b38974e2b9bf3d85180a6337cec0f99695059b991337461851896c8f6eed481f953870d52c80a92f4ec9fedc7ce114c48f89b848f1d5bacb0dd6fe710476d026a2a278e390af0e2ccbf690de54c232272a6df5d675c57bd504b41af3f9212fe7c311b5924d12168575d940c3c02afcc84cf87bca06ce323e1c6de99eb6b70e6ae1cb4e6dcb72674136ba371527e019aede7372ac0bb7870f3f4892f9a1ff14b5e2196cf97396a968f5e09d5bf1ad32e1c9260205ee49214f548c3d8d23c3ead2b04337c0ab4885039a94991e8559ef6af359515b164ca906438214e0a5c937c93191d649dc4ea2190c1e53e54dacf75046548a39eb88c63cf4723c7c8ddaa4a04f4b721c6f71aab235c6f438b06ef39ba95ed324d5c421fa4ea3e0e944bed961f0b832c2ca7942d6fcd4a49f16668a5403c154a63cca62473b5f26ad333d7d14fe213fc2572e148e498f8aa3e75d65823ec337468860302ca3ec3652c11f38bf60cec0a47d58c8e10440cfcb8c1b2c2d41ada18d214f33b06c933960552bb46cfe07def1a3be06d8162f9aa06b68865df4c7bc01705e14db7f9c575d592a9622c014c1303329757a65a414a9ed0c1b1b3f58b02cdb577bb5c44fb7d334e589ea8e3c90e99461bdcfdae7656e7ace946e0aaaa596cb000f4723f482494e2133cb50c974a42e2e87df5d3fb4777b77995f3d03c2c5a923799885d2df480fa93ccdee0194ea69587bb3d7f6294d56cfd1f5c0ac2f43db8661b0d032f757df444df8502d1942ada640522e52ee77759ee5387bed1598cbf26d98ee5cf2fe26b90e555f942a3562e17fc44c9c287d3eac7c30570d9c4adf2e4857c598f7c54cd126eb0180f04af0d1df12171b02e81bc13fe63a56ebe3810498f53f2e2e35b9543ec21f379209bf3e09437919a23e73a4d6610e0e2beb183a067b4365c0d5d50afde3a20239fa37f0a45f59dc300aae1ee8a9b97e83e80c9939f0b887d52d09ba0c5570290da6c1ae596f9eadd5d133f71dc725ee1c64c4e9da5c88da94c6bb2e122073f43594c342d07932d4b81d6cf71fc238a51de6aaf290c89aa72627552cb84d91abda4ca772b088fc990375c0e593a2dcedaff7257b043bd635b3d83d7da6e3b4952357d307a1a1e444db62978b2470f80cfa1e9d4eddbd24ce6262dde983eac3fb393cb1c94dced21c6a6b5aaf7833734b25e37a31c4566cb85b4c9b37f76ba6254383a77f5916ae6ad8186f1a37f337f259ce25ed610f963cc71ee131ac6c455b6ab51ff3708260764df13f940ab82b49bd68044a5bef8aa2ce61169d47f888e5d65980eb3818d188f07f32e5998b37987a38800f5bfe3132979ca1447314570aaef7323059e2e7e8e949b1d48b734326b7c60206084571344b57eceed6ca9a141b179d8a7ce88bde61d7222a8879373c9d9bf0f50bcb33ef111b5e6218213949444229c04931a6b180b2eeaf3aa4fb22543eb3a50b9960ac126e5f6ae2221cf252ff3e9c67c51eaa6d617e2b46fc78200337b4deb1b5deb375db57ccdcd32b566cd744e47facdd11516c39665789947ed20f5a67a529974c63e7ae51ad3e4fbfbb51a36138eec92e535c862713543883ea4d0c0a8efd71bf041ccdc1fd6b6e7366f5c3db3b94cc489cb8cf3822644d787379348d143756537f011ae4766071bb964b0c1a2fa6cda853087b5f2dc1b9a5941c39b9e0e12d51fd1efe82be2741df73dce7e5bd2ab397a1d5f265dc74665276bd83569a02de01a5fce2627dc8c427242fba058d2a685baea59b12d6843ac741e47a2ceaa350aba0222c4d5c49e4dbd2ccee4346add33ca103e02dc4f91f4b1c19860276cb6d971518460b02b48842a43cec6590bcdc84a27428804ddcfc282fe50fa2e9821c0d2d679664191098a5c3061b33155e6b79db82dcd11a34b8a4a3cf7dd2e9d04554109686204666fb4c56b2e2777a9b686571b462e9d2093d08a060385b1ebed0b5e52d7c0633bd9b7f86c9abf76a7bbb8e8f9223901e63729c4d1ea8053253a678d4b5e2df881d5f867bd2dd7c8b074d3d5ba5878da64b3fa7d3933597ca98ade507b51f73ec8f2fa85c55dfce854604b9fd74f7aa11c88c735a4748db9193ce43a3b59b8a0819f32f51da1bb50141c94c9e88d9ad08e3414609c147972c4ef2dcd33dbeec84c6936184eaf8f9a7fe853c6667965f32a3476908899c9446d1fff6bdd6f060079bf8871a0cde611e871ed27c9b9788381084248027ad9a8522dfda890799b039a208e83ec935b70fe47e5609ac43f0c132e1be9923e471914b78d0605921a2c4e2acce16a866c1211b8b103420015e761246817a06a8e01354b41f6a53f0ff4d63cd7fca31d748fd362f4726813b9cfeb79cb34c5860b0b3437911ce7d6e8e7f2e514483ecf1134a3c5045065658700329c99d369f76a91822b1ecb55f0419ff4a226569621cecb136d850fd28c0a32a71b78761655193ebf843f94682186678bf262aa31ac199da2baeb1337edafd1d964cb8f4315936d3ce1780aa6d143f909647db5a9c46e36c23bab0cfe0104584a0727a188cf65a79ab15c908a85e6aefd66bbfb57115921027e494fad6c94506981013f5fd90c68497251b89bc60af3e877c1fdd20946e6d3d14a7dbe96ec34c850eccb20c8f439d9b2fc0553080d825b16143f9312d3e2c70322f9ba06588fe6f53ed78415b996cbd1bfe938c28ab4b5d0273322d47ccf4c526756184175cc35ec9be6e255c909807d11e6b59bff2599347f7b09b49de6e46d8c1561cec06435b5787bd3ffbefca813967061dad73f65918169a039d3d41fa315ba1f04d50276de58f8c179e80a9323c238c6359f7cbb95d1a18edaab116e9178a6c88a000179d5c1f0436af09de22c09825b02d4580bafe4954e2d802951c7397dc6d4edfbaf2a27f4d2394531059ae10f78e9027bc64e3ec73698ff7659a2eca1b26c0b5b974a0f78e66b726e8e0efd12d84ea6327c0f54aa00b37592f6b2e6b513b5d4abb2b3ecfef887e4a0ebe6923ed1ba4c26ad51aad014f38f09a985dc2a5348c656920654e9910538629fb06505fd9240c2dac3b5bbebdfb844f28a217409ab7d06b5afbbdb4869da3e1a0ad9fad49d309174b419d00dde6ddf523e4b14af5455168e1e9646773c36ae0b34657fcf01980d1bc12bbef3862c235920dd9eacb9eb109be188bdb5e2fa0cb3fb8c177585f3b030798fdb255d8fdb77c04d748a62ab7f5f86f7a38cf48104d49ed2543080b005432b9ab72bcae5422e9b1f38d0d502dd497d578a54e76810cdbcccb8b8887986c475f0c56f64e901fe1fc75e1897bd950a434cf4a6421bab0fc3dfa756139cbf44d7169878a1e79556dcda46ba110850f2573c55098b184e2b528fb291a8b60944dd70a2c0088d66d940cc954dd78f7b9257aa3df738ea74a0d7517d03be421f34e79376ee1f2710e5fa12cc3c51bf8f7a931b11e7c21eb8f0c0d93924cabd4ba583f3875b4c610e1d47415e1e2614f71bb8036363bd01859bad6ba96d64a429073115468016b7c8dfe6eccd6bbb3c6ce624f7c4f3804f55220b9d3056128331ea8d7d56f51497dbbe27598c9d87723b6a786c98ffc264b20459e250673ad6f0cfe7901b42ac8da138a72c3e2c2172fd3900d66210e9ce26b316ef9c29641bd017edf215c17505d3cfd4e934b00f9b2ca28cc9b2bf6d082dced0f9761514ce6a52ff17c929d49ccdf43ef51291a87744674abafd63d28f31a806b470a2c36b3a119985c7c461bf0a3653f44a799273ced7e93ec496a0efccef26951e5b067e99d44ba0742992e91316a25b6ea0443d3674d6a98ad05e967a04cf0fc1b64485340b940c60d1eeb77305a88ed1de342025de91afc299621fa3795ea92d4d13fb8337f13e1055eb869493d523266bf8c8f775b8960e6a61e7e3cd53e59377db5df1e9e19a051e0fe30241c6acded1e89425caaa10b0bbc47ba5614d49a6df21391a71f3c4b1a2c269468feb806db8ba1e5b5de4847c16106782e5b949c9db8bf967909632987cb965dbeec2425588b3c3e2900685a301cc27e6cb166a9f05523b63a647683c144b853cded96718ba8c2176116e88d7f75e495b71f32078e53a5b993385ca1ef1ff33e3e09f6339d699b36042bb028d7f4d285b7ace0ff9e3aaf662b8effcb3ae5aee5b8482cb4b6562f63bb44a8735f22f516156058d94990a886ab6d4649ca1d5311e4b32039fcf8e6682e6bb8b64086b510794382ddb6dff8e1bade1962c64f498a6951bb0d9ad6290c04a7c838a1a97b3a8a5e46530eae063f01e860605604f818f12be377b6795e16e601c042ab11ad5df1b88d8278863c6827930389a4c2c883214781be7967ef4f7b7f881c8548b54156593db31dee0123d5e7eb26d5142192a3af7e2b0a2a427f6c2c080e59d6f9ae5f4a402e246ebd3ab3edfe7e147f6b0f1f6bc006914ac16e600d29604c41e36cb7927c3bb68ed97368ac25db878d0ec03c813197384dd2e3002cd1598813d9420439db22fbd7bb979d2c498356c5726da3fbb82525bddfa7f490e94235d345faef48442a1ad0cc6ef97650bfaaafffe0fce03cfa80214f83e3415a637a0a8e5a1fc69e9c3c0274bf259124d7abd41ee0ee39a75c72028a3c75480a04803f1c2b3dbbd3c088f31c54c885ab1380bb3534210de09423e7f89d53ace36d6ffa5734f030cade272d2af38b5bcfbb52edaea53e64cfe9ba58016d2575cce66ec4a73fe12b6b3e40380865161a761648f0effbed475ca55fdd0d7392abacb6a5237412b7b79e28fc9a1c7110ca8a6d8b4e62fed5bc6f0e3cff847843576d263da126771bd94be383ddd0e12274f208428e6d759fcef06e7645ce44e081f67e5ec62533b59b5ab8fc888b7cf31f962f96397a2af282c70b3838539f102f2f062f19d9112c04b3ef8f24b4092cd35e2aafd6f0e377e2dc2ea85e7b517b6b0005d922abd8291c3fd06638b55174983240b4ed3769d6f5171eee42af21ca3c51c58369014f53ece4a2a64cf51c7477fabbcd07b784b6c36125336955d9a5ab0a8c56774440537b8baf7ae9dc31d3779ee124abd7fbbf55a0899f5dd73fb3be13a37ad3dd71d0d21d3d0896d25a3aa106fbde6102989ab2be9359a59b1c9d7f5452160532aa73f7809578db3f5d51fb1b5026b19d21efe2a18b8ac90b370af6b6e05396adb5e4f49efff3408b03bf90c32a2224115f65ee33b959518d5aa32a1f97580db559cad15dc2a14e1e142d65e7cffa41c61aa5dd5a64efc68b4b102378bd4ef2b15dcd94a728a98c615842847088d790241a57b700d673b06cd3f8e9aa9b5cce0b8a964763773382ba97a7f4449de19a942622850c550e9598ba04859c79ab272aa8cdf179f869b9929803bd4d563fe67c08ae4e662ae8ff77c8dbfe359f6288767f1a9bd0f371b85224ffe871fb1afd4586a41af69d287571c5255c5f54aa7657d6234c52b073076003437b9ad399655869acf1a4f5f780ee788ca701e1ab7b3576930ce676982f26fd7681af27e5a81b786ddc587c7ca756aab6e8028e8c1e782810e3748f07b70ad940ff983f254df87d90e2fa78e07211234b274ca376e888b242dae541e92776614bff3d6382dd563ebc0c72324a6987abf46ac668905fcedcd3f81fd56608d15b3c8886db24df9d859a61a8f2e315200a59bb5825030db07068460b93a5e18390bea35bee32db3418d2e98400d2fd45072121ea21f67a9734acca91c2cf3af4c87757a4e6d45a85bf0bacefa340a95c6cf4a564a5922cecf2448e9aab0b9b8ccb0fac490934e3f744edb3cf2455a2cfff7c4daef9fead1570db9a0c97828db3602faa32a077fef26e22050ecb386f04895e23b16563857c7717f4d1cc5c97d1517f5a47f2c833de044faa92e0129865d1452f5331e93a87cea0a6cf93c0424e64a6c371494d0b24cf1fab45ab0aa658a1d7787da4b756a03f1fb8f033d61592624ded96eb2e0d2a97370f0d74492047bfbc061807f6612e903c301af6c79805121be19f2194c2592342ded482f78e99f49de10aa2cde1998a9e183722bb530f3eb9a67533a7b0193de620811e3b78b60822123dbd656048f5ee772e00d9cf19acce44fe698e61d3abcbdefc903d6706c3f2a097a0e665a599d356e7d84a93892503c4240b725ded369a202d2026e3f1edb69302937779173df6bc4af23627c971002dce607a2ad1a6fbecfc161e72df4d15f365dd402306abfeb13f95c4143f586c87e4b1cf52e5c3954c51b94c9e38acb8c9a7c76aebdaa9943eae0a1ce155a2efdb4d46985d935511471452d9ee64d2461cb2991d59fc0060697f9a671672163230f367fed1422316e52d29eceacb8768f56d9b80f6d278093c9a8acd3cfd7edd8ebd5c293859f64d2f8486ae1bd593c65bc014bc49c5d838bfe72575da60a098fd936c401942965e2c01b14708ebbd0756934ef8da3eea94f94fb28878024409865de16bfd64cbf0e58df1de3a73ced4eece8f5d32a374c6f2b8782d9e4b34db300301d46b275dab600e909b37d78fd42c5a2013d85d3f75b20cc08dd5a337b4046e15a0ebf31339a76ed4a7897dc5b0171d494154d5134a4231d2cfa472143d088464fa0530b63fc293062ab7cf3b0fb80051102f72b7eda911f61d9420941d462e380842460e68b7676d4b4a33b89a15eb82a7f09bf505ef92749c2c157ffcc655d7f2299ee35990d05333c91303f938c7222f1fba933a1d9e9376f4ba9d848fdf8ae1439efdbd55b8fe0abcd6e5d3297a7acf45365a36391c9dd37475b55ba8b699fd16af243a0c06b7f7ace426d0eeeed2b0e977129e4ef3d8da35af91291cc04c6d2c3a1f78bfa2c62220a58e99910972f993e5831d610d8db4bed1f797f0e7eb5a0da5b720757373b4a081e4d61ab5a1d3cbe874597c5103889741b04c2e11bdeb3f59b4da376306d5b4e0f22e8fd9a8661ae8affaa6a7847f496984f1de280b494cbfde4d0c59c6ace52a7e4afa5dcfd9074dfaa9e8f756c15bb03a2e06131d9bbc3efc22fc3efd62bac751d262285e541b7f1e0e4929c275557d9caab0ba3b0a153dd8010ff8f11ebc1f336dd0249d01dce6e3d0d12610c4c03a700ee305adbee12638904e70ea09719aecc34b38d406d4ea109788d488d5224e7f01a8dcbadea760e57ac08e324b63a1437ddb4c4a8b8bf46f0d771c72d10621912c0627ac92f053a7656d3b100b1a9a0143884948b9886ac6d8a5e615dff11b6e3705cec904436745fa5e5dcb711defeebc5b1516b753b6dea01a1bba286da4ddc9adb95a59280489e09addaca7f406d2915b99fcae743e7f0edfa1a9d30124a78a07d1a6bc279239bf29a4fbd22749756a91bd42c6736c70c9fb622a09360394241afcf753c9791e411499001d3e1e9fed036a2f26d9a77b7a764585f292a96c3cee2393469521000c62a302aec2ef17c5bb860cf72e5666c9593101b59f7ef77d8c2fc3be14f3a7c81bac4bad3b23a698c1fa2160f8e3fa5dab10e77be5ebfd8cfb06cfe3cc55da1e489b21432f22140f1bafb68ac1b5ffdf74c97f6beb5645144392ffdc47b063b5f058cd98285429d1d38c139d10343df6bc4411ae392898bb6db99bd20d6d08371bca96d3ad21ac87f17880c06ec87c4b8c69e56b57cabe298065eaeca4f29249d1dbc61c47f167d87b5d441b62d98386eb2043cbcea27f07847d355396a9c8951b72a49d7c2c206d7b22a8d774cf1b4ee25172f6241aa3fd82e9c42e6bf874c30077777bd73aa0edf8aff41c2c120c4b78e4bb13e499f1b28091dfa6a9495c7b89d388e1dd83af01fbec7011130a1e26b5c1664a938632cf895dcee3da034964bd6c1ff5187014518bc163dfb0201887a1d0bbc5bb4b2efba235d80c858e0426a42b83df0f679984b01617ad8bbac41545fa01a9e34faddfd50147493352526a46f8fec84ad1044272d3d2a42d42e879a825822194fa772329a961c46bb7fed8acbcd6d852171e35dae0ddec1d1e4d5bd23a845255b4536ea7156fa2b525ce17dd5d5436ae9faf03ef2580ace3b8bb61cc225067aee50b68552db80e99048cd0e1c5c00be6d37f54ba8a020d0876fa369dc32e8627f565ba3dda862ea0bcfeaac1da627e831a55d141f8ad3613c2d1804d0765d8494d2a0c67021f2a51b5ed4e848681b80cdbfb218e55c74f8c0309e8e5d53f849b532205d98ecc2b3557206332b067e0098037eda98b9982fca06a156c1402b2a670144e9d67d559d20b6192d4405a1f0270d2dd98806bf5ea03bcb0eaaef78cf00cc98fbb7382dbb3377683701da39d80139498651e85d0de93c760688a663703900a6f399c1bda5d4528dd11318a810ad144c7184b2e3c60b853ceec9097de67629d9621c9e77d5a9b3f48bc6356f42912ac11b7f1af61f9da27a181a8d1a7a2ec4aad7be22fed30a3836e7b9b511d643e921f4cf7506630610c822cba5eba3e95db5c4dce3b516ac3bcf455c1c12543bdbf98de4559738eb6ca19f7ae8440c3c4164aa17753d28d65b18553beef334ef7fb2576c312b29a3f290de96c8c61b7e3c5207ec4bf9823f02bc77b7823700e550d6e1b59c349dc65f1070addbe44a459ae85ed9dc6cab4ccf262d7d8a5030a3dbf1ad5efb360dc90e9ae63e76112118e9a22f4eab290c660ceff6fc6bc15ca18d7d2ac6d2b202329daabfb73bff287ea509f9e93c913e3168746492bb1ced74f1e3da9bb73b038968ca5db6a1e0d8dd59aa3f081547b9255e4de6fedcc55b8485c04d3c1d339a341c74509b2c78babb73ed6f49a9af05c86ae70e9f655d3f56d59ce336893e3ed9053338f35029369f805e1b1c7e599c70fada3bd2c946f1725dc44cf96fad59dedf71675d9164d5000b76c2ff17b9e5d59a920f579d152a5d7af0eb13451383bbf7c96c1884de2e7371c1e77fea528a6cc6a8e99c453a327ed98d3e12be0334f6eab5c7d29ed7ab606fba090d8ab5f29d0b796aff5638b26ce603b6561efef62624a10b0a43f3c46d31e998265d56a6ece5ae041f3493229e2cff047c0c694fb02215a63e18b511e074bb2568f6b71fd2c191356a84dbfb891ac978f2fad49a3b8fae09dc719e1c70b4b93133cb49e5f54bdd7f7fbb75b5b43c1db4395eb36e1ec9b4d66403013c746e6e3c156f9171bac0ed62bd4ce2d9b60d4616ddcc9843d04cd47c634190fa81fe34b69c48204b99ed3b5fa1bdb5eff50aed414eb8f5b3f695876c6891dfef1000c72116e978ec191d61f6cb82615107b17da41aa85e2708304846d2882082b502701c43c80ddbcedddba8a94f77b544ad61bfb01f24257ba9916c4f99054dd76fd9f871684183219b12e5b9596b85523b5414ad820a27d77ded7d1e4910b8fdc56f564e4ed67a97f1a24e7a44af39b6f7af13617552b68209c6c9ed2cb54cae9faaa628e01f3ab86df4437aa5d54ac97eed5c8a6da05a21f9b8033a987581405b06789fc09e4bf96ca35528d15041201d995076df757b3daa3b996530d3ef89841d4e2174c626e17a1a04037bb2b551703d9fc55f34921bb7cbfd1b6a52ffb0a769874c514943e712d2c0a8e96f0fb403348ad4418057628ed3becbc9753a7c4155c48efa7a2b90d3682b77cf07c8ee3338a2423acb0398bc0d5ed4c2ad1832ce6c7647e4eb5675184494fe80ff7966ac94869dbf875f34bbb34de4da8d217abb382d25851f5cfa6de2adbb93c88993cbe2a8252447a2bd0a701c6a9577decaa42349a67f88979750dcd62d9bf5721c1d9d77972d8e769824be3ae4780fb898f5c86c2918b99ed24dad9ec2fe08db561e4f85622fbe536c971839d0f6a7376c3c92054c0514fb41d0af782a3e752de84a5341f49f69c180ddf889be95f0e3caf51a957db93d155c668ce2a1d1bcd2292e634ded1113399b65e9bb1bda5f462babccad4ca99475889bb07ee85c6270cf36d9f9aa194d2412cb664e573854c704bd12ad275abda46cdca49d6c32e87210f021e5ca1c7a397d7af8a41f3473eefcc597259c411b1a5f95e3de9c09b16eb4f6f592bb9f2cb232011b6cd2533f466a41d49729f12f600773f8a2f6257fcf1197bf70fd15c756d6da38f90f291935d3be25823eef8cedcae35d9b092a960bbd6eda110d14ec7fe272ebe9240a8465cf9734676990963c30608d27539d86ad2ef8efe37a110e95db77aeadbf9c133ec4697bc73888edd3ce77f1c853d2d44bdca26b78b2aea0412834fbc74032482948a156221a3ce64d0b96460e888f01304d17d7314522440a6f575dc6448195cdd2db6df88d3131e05e47d45a7006902306b5adbdb0205c4a074b3f1b3aee8e94e9742dcb0fea33666d09374c98fdf36c8ff8696e723d6b98867d3a3691fd8506f308100a20dc7d278e66d94561c9cda54f7ca4d419be046e7389b9c8f8232bac8613af465e9c71bc58cd54e578ee6145cbaeca8ef546894434ed4812dbe3f4ee290375f0178eb38d42b914ad3cf060c69b0b44efb34b9cb271146fd49bd443544273eea7fa47b512d2c6a2fd2c644ec0241ece86c251a1218e9b8b6ed668c96768c183de654be9059f528a65c5be7d9b0d55a1d4b0ed291a03ef35420a15e9a01298dff3e70fd1bdff093567a7639fdfad4c8969fd62a714678c080eb5601686c6464d88fdf801a478472e833ff808068a6fcfb70676ada92ffe5e2546dbe2a3fa76772e28b8fb61a188f0390de058a82b3bef3c7a8daf30d3c2a2166cfdd0503595c723e5b7216de16b05097fc1041d164d826ab81c1e53e9559e52662a6233fe10c83ac3770641ee59e76523fe8d0dc1f103d24da69d7ae7338d89e0f60ac7ba93f4b3307d3c55fed211ec990d75d2b4d30e03a9b18f2e33f91a0d5bf55c83f18bc72dbb3e1632b9600f003d823114757feb6f6ad175e675f2ae5d358cb9d14964da1ac24e3660948059308fd1513b7a343685ff6ae42c23dcb50a1c30b56818bb880af4020f6826bf6b0e0e9f58c039bc69d7d5f24c67a3f3e8846e95d190f5fc6b6ebf0e2391d679cee94820ba3b4a651fe59d0c31419cf4a36cab1080e447b3fec681d6f5a62a4bff62ab29e81512baa33fa32d1512754b6023602565fab45ebc92fad117fd98b276fad5ff84d62949ae3696b97a82a364b9391c68d31c92692f6478a0dd10b829b0222735f307048e9b6ac655d3facdcd192e3e4f6af2887fb1ab89aae777ff2e55793d51c5202af5f56cd066b3e34b010a63444d9fe4fceefde8bc73b99bd44cb15076d77daa031c468d33808ce4b19cf788dce7e49c66536eac7f7fb614ede16e58723b7f0d236df97c7e27d17777fd8b0f56a2cb616b298e5741437f5b92a8e6e1adf26be21267988b0ec1340434af1f575002d6dc61fdd779b05387d868efa59c8890a6914695ae6963d0f7134e3e3ef1478c7975e12cc4943b243223e74234d9909ac1c3467 +MD = cca52ac605ab74649fd6c6bc13da780e913bf742ca25fdf24b0092170ec4909514027d8dc1e3036105219fd5a2f260b8 + +Len = 75472 +Msg = 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 +MD = 4da010129dd22d2daf6da3a9c760e3ba8a68ccbed9b59c8525b84ad72ec04be130042794b8c03a573ec41804c9de3eca + +Len = 76264 +Msg = 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 +MD = 3e82f9f2941e2e8edbd0942f8db71b923cfd2c62cc80f50e7064385616c954eb05bb71a0e52d5bc73154d24ee01458a2 + +Len = 77056 +Msg = 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 +MD = 66e646adbcf608c86139c62ce5c1cb76112fc0aa7c3f83ac24d3e6f7c5c7e1a1b6db310df87f8f9a0f84c4e5658c6fd3 + +Len = 77848 +Msg = 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 +MD = 1a8b75dd663038289a4fbd07a51bd53c4b6073a3f0a9b9f91350ebdf095b89281398fe773f755df77956b1a57379507d + +Len = 78640 +Msg = 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 +MD = 8ca103dd16385714893331aae8b98012b40a1c359b4b25958843093a1ed2cd36a58aa0054a6b9e0a18b08836ba6be834 + +Len = 79432 +Msg = 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 +MD = 45a19bfa408943f7a44e3f8bde24b08eced95632b92fb30f87c04a8dc18c8fb242797dca783c34799b6e99907239b589 + +Len = 80224 +Msg = f407e8ad17daf71e1feb8765a879acd211706be625857b09fb814c7f1add4999e1905b282725ae371e10b7fa7d427601defbf8b164e021f5a24da831b8ec6378bf87c5fe681aa5d0df2d40c2f66082a97f4881cbf9794b9470e4e18b9e64838456932e1623e2644f2ce92ba75afb5833bdfe0d1b2c79814e2cefff74146c32256e5d9f589fa4731ecbec7f90f33a810560c5a58945084b8ba0150bd6612cf6c3ce8c1fac26895ba384df446407468489304750fd8b4d32b392ff0c98cecd5ac63fc9b7fafeb9a348216a830ddf47e926f529165f4771bd2ecb550aa2a377e39689bc6e2a705bd37468344372c36439437616ff97c29b756513be0edc28511b9b740c4c24c498738e23e68c7bfac5fb4a7cb4148e41f4e0be31e21e2ea484893dc86259d042970c0018276610ce93b7a2cfab5c2a0fa488a2ef6a45806137b5e54c659e173281253110a0da1985f6f5b337a4df5473d2f57a13fe88baa59328f9c9be22dfdb7d4789d2f9ef7e68153ee57c47a6f5b4a7adac6645f1c4b9c069e30714ed1286b4f97028d9ae27bf1919a0653bb8f31b4a3aa2b0e88786e5e50009ce1008967b4dc34ed8e81dfdd2290f4cbb291e38f0e324c2b98e52e8702b76d5e65a7a5502712d8babcf47e6e86ea75146b8deaa7b9cf17648e05bd3a4b952ad16994b356348c08f693631cb4b106917ce910233039b2b252786a92dc7b81cfb27758420e5f903c3dac4e5954136dd071b5b91bad20859361c2744e0224f5d26e2982cfdd1ad7f8dc5226a2a13088c87f4bf94262e0c0413f06b35d2fda79b960ca74bb46f8bba56f4f8c87409affd002365126160cfb3236bfc83eda0e761b3704dea2c07bc3e872ded075a6a53b8db6ef41352af78eece547f3617523834e5d5300f4fe167938639a930c3801b467e9e15a0e1652f3e7c759f573a5cc29e9402f8c50445b53fbde0d54b9991302e537b6fbff6c91e29959402ed3d06ac2628c04e11337acecc92e9195ec3e6baf8c0ccab7b79226a39817a500008981f5509d7dafdc4c9d9c26f1e1c7329c7e02d2f5b70d952b93ef6a9ef3299835a42b19f0f4390a07afea7bb458791b37bca5407ee67e36ad6c0e773ba4fbe96943ec4533031d2add56705de2701c1494ca1f5b04e37a0a7c0189448a5517a298d3a168b014eccd4213963408c330ad3808d9892438918f2c16f859176ddd2248e5f2db04b3f85fea89f4a493cc4743960b5c615940554341fed43b4f69ed06fdfd4932bd6af0511b0bf4161fe5d0763344206a10b525b5323b9551bed397bf2c8c2d0626a4455f782c1d0f09ba6cc39445be19e6e19353915fc432c2359db9691516abfcfa67c9666ce7f5edc46caa4d729de748601ebcc3ddd96515fa4f94181a8eba9cc7e82d8a30ed71386e6098a37d4858b1bb384f6e285d5f16bc2dcdce1f0db882b7470a383a85f77642d92d5aa835e4bf5d6089d4e1b88730d5c8c50f950c0c3b22f4de14cc49ff23dc46c6b795ef21ddb1380abc7c837410e1a128311f124c42a582179478c20edd8529f36ec8ec8679612f30796b46bc235a3755f71fb8ef25a96f553bc2669cefe80341c4a3b6892ef7a69990306ab5e4ca0bdcb619587b50c92d057f3ba03ff77f63207dd8c5b07abf4ea4955e7807d19b8f3ae28e7967506f4ba6d337174e60b5ba1deebaa282d95277fffd67e718766941ef20f1a439a1163bb7dc67246ed82588a89bdbd576b74bc2fa3ccf406e4f9db467e5e56168cf587dc6ff2e6007ba394f4ef9bec712b0f5a031d8070c7fd9a36733a5dc298b47a09242b00f52bf737b8e7facc5ffdd42faa01553a1b3d38134dae0e5387507868919c9938c64ecb066b6b919a3f83ce9c533334421ceffe2bc7fee28accc64186c64aa2e182f15ed856899c4bb48b801efea1a0df9c65b8a94d6c9e48ba83789d51382c44509d187520480428e59e547d5352825ac328cc5686ff2ad6790e8375d96e20aa59d861a572b1af79fb43b180f94ec3fbb8bfa4fa1bbf6e7c30efccd607f26759c52da12ff4ca86861d03fff1999d490aa4b2a65db3b4538108afb98883cee79abb2140dc4d9d71967465a796da48fecfae8a3c46f7e7bf2f28d5b452f40a8ab4633ea674263259f328f10f376555c992ffcecd7e8e5f9bccb8e924fe03ac37f1e60b3cbf268f24e3602fa09ee1cf919abe06c0ce2224d0a1e274715257bed6976c106884f6bebcaf44a8c292f7bb403014bb7ffc583f45f6ccfd021799474eef1cd6938d3dc7079ffde3deda4f23bd9c297371d0dab7e1139e0c4114705089411fe426a0a4b0effab3685a3f900ef02624b9fe1450948e3f8129951385e06ed59dc28786d3835b0a8dc0a0896385c1162e128e8e61df33c39ddd66da7fffe5f2bdf9200771483215b47216806f8f18b36e088907b69fb7e719af1d3307b5d6e1a71058ea26055e64500626eb5d34dd460d225848f7dc04f31d2820e4c50b29eb848f96f99cc4c63f88053794d47cf81732e96116cb9e012fd3ced8b56008c6567cff44fa788c52ed84f6b0417d70516e06e30d3cdaee96e3612cad7081b5966ab6e7c9b66566eab86d61fbbb0017d193b19ac480cdd3ab56efc708dbcf187f715bcf8df5095876e66bce7fca047a5ecd5a96efac4c5628d1a6294fc0f33c6ab1923ff87e0c6ddec0a5c6a435319fe166295df486fe7ef59cadd9ece59426407384c0721b17aa0a8e44d0d2c6309043a447793dd78c53fbff2d5f45125be0e7ff58d96392d219e3986f757143a9556ad0dc7230669ddd20424e44c411ef71499d371333ace4c14f254f3ce97543f440310fce37fdda254dac370fcfa9fae14d9549f54a31f6aa377f0cada324a777ac110917b962eb326b861148d0a12138da2eb50710e9afdd84eccd5005187de595b6f2d41e5e770c601803772ec20e7fdab2a4d1ee9cb8611cb5baae78186c47e569f18ecdb926bc16aa362551d469be34673ddc4a11b83ee922fc4e65ee1ca483722ecc303ba2497384d2d9a19fd9fbd096a9af8d11587dd27abbb8326036045719d216aeac90bb61eefe1c86ea074096860fd220644025be071e754937627049a605f4afd39b1bc72fe275687f9b946e8198ce69d2173e970f4e0c103a47ee4160eeef9b7969708c90a76caf243c0040cd6c2ad22385d144db7305f1338e892791b68edb66a2c29a597589c3a2928af4b3b26ec21e34e4adb3b4e952e8de46e37f845ad562ef19d8d273550cc0463d727b9323a18cc982bade393f9d23e02f5d7281daf235f87e2e42ca57f348001ea26d36d0d635efb053a62b8f39aa3c4b7eb4d5969aa664f884f3a117de0067376cd1c4fdcbe14c786051b2628e4599a22c8ca716367fdb90c22b211e36b2248fb9ee6432e75888e1c928f53e04be9f3d50411fe32c86074dd13372f36424df2e6f0d3ff892614cf376731dae03dcf723d31c6784e6848d379753bb1fce1f3f1d78767cd634c640b74f7a5137f366495c9b65a481ca401856fdd22528de6aec63ba714455354d0b343d84ba633c253cf19264016342844eb3ebfad798fbcf8f081f46bffbfebf557326db7fb946e179e99f60a4b0b516d7554a11f9f68c14d0158e3c1453f5e3c87af4c5cac17a61a84ca9a3b5f38bbf5c440060b5cbfb025691ee9c6ce283830a538d8bc0043e6f70239a735db12b478589f72f319eaf61ca8429aeee321065c306db758b09fbd179755919c374ff76f92b15c695f710f9d3f626bac3ca05529c99c4ca53581a506c4acedd11c36e146132446c0a5e86911af0cd081232c8123c1632d43f7a01b4f1aae1066c27e0e864a76b6ab85c79f3467906e004f3c36d4d840cd978f61ac5af9e7adefe27bdbbab917208c67851e5009ab989c1945d2b74ec3a222654cc4b4f2d81abef4b6e55ddf8408e5c3b7630f05ace4c709dfd135b55a3f76f1d7e0d7860deb6671b597ea3e4bf44a42c519cbdc12d7139960defaac7319f7ed89ad4d33e79478d20e7fea55ed672c3d348f010d7bf404508f485094bcb64790d876808cf3aa589e1809c8a6d6d5fe4b8c4f690a56a00bc7b1a9d1ee7598c8945ad91be1b0a1a84e68d21fb1a6d542d642e74e63217fbc675e70194a5c460d50674179d2bcfeca6b874569f6cbc99c65eec33b986af778980c378118df22886db44c14f06736416de9f001f6b4376d82e68fbb2aa18bd302316c93da6cc2cc349855879b4dccafde074ea221fea338b5d089379a53c15e1e748bdc2f83ab3b5da9fa5c63ef46682475ddb51919a17067236c5b57f01c6c452c11c458b25078315fa6ddbaba17fce9ac19a54c8396b72f559570e41511a03eee9ae7168736e5682fe7b6303cd5f086108f0d2ccb077f66ed8122ef21357c343293aeb960e3156aa1496044e5f4c592599a573a6e883bb661dbeba9a2fc62fd7e78a5e1ddc98aa14a28566953f8fe96cde81e05dc8d7e9658f235d418caf6c358c647006c7ea7b48121132e05570dfc13e4cc1f937bba7f19608bdf0145aa5e28191c958b671f0cfca021035893663a921cdbd831f761d949a3782afae0e00672dd9121b907332303420a79ec32b9faeefcd7d02675174d5037655844215a54df703f3573f3968f3b632a022eb95b8571114a97ef794d43c3a8ede79b9b5bd1c49d91315aa0bbba1ba02a2c9e9bdd92ced6ae8ffb7876452a547c495f937705a8a211b5db93053c1a756569ca5eb28b6ec97e28e8f714d9ead68afe0ebe3e59121a4b23554f257dbe5f764a20767cd7c76624032679cb6a9babb496377004548782a81a76397f078dcad73e4f878f107f494aaf4274ec8f93506372586d8b708f67b30bace68451ff43f2b685e67bcddccf5c7dab7d0ab188412242efeb16458035e66767dad7f5895773638237d5588684d40efff6a868e11a7b687c9d474c0079ccbe459aec5ab271b395c2dffe5902e64bc38e76381e1438c9537cd890ec86afd080b48b240a112f4dfda6638937b8802e4bf5805c69b818b6a46f4175af99549c5f4330317c1becacdbcb46f88d3ddee608b38967a43356addbd24c881daee48a9a503e773939365ae0a01ebeb1f95f1d7a4715fc862c6f295a347e2abf4dec25d289ea77ca0fa8c28ca34f5e5e818d3f213e9a8d67f9ceb3b0044aeffcdce7e8985ee8b596f5909e30635d59eb5cd5c58df8ab9cc221f1d76dd0374a6ef2445d4c2dada338919a288c5ecd33d0e1e53b1103ad9d3d4b750ef416c7cc8e24adfe6e949de3174a320bf104137eb7b7282a7afe351131bcc4b4e34670d8b2ca614680125dd7cba5e4a2fee1c48cf8532afe0c26c6ab382c6d73abedc701a57a2ac021355203be2b1ea8167654f12b3c4a30454bd69db8e0dbc5be8b3ee9beba46e5b26c1ef977506c65d830494db8e9126bc6abe99b5c909c25ab9d4cd376e16231c425192b8fac4a8694be15f539d0100b00e574166ba22b0df3a2755156a5f93ec6fed50c5f9525650c6e4f8a1687df8874770a819e9c150917195d05e66e78674b67d72e7fb1a98b8fcf6a6ef776bd7e91ef117f4df4c681968048439eb16c45c1ee940458783384af6fdb3625334658099c2d61f232dc11e275dbacf8054144bb019020825f5fcadbbe2652483416af1c3cb2dc33dca2349b489ba47ad0940e973f500575dd8ae89538e055d8ff9aee7a1f56408b68d5642196fcccafa9d0edf6f66825bb8951488c7e8da3400c3f8083d26c21515dd21b05ef63880f07847d5ac52cf3bbd92f7501ed72ed25c0912fc9e479013e2214d3c890845901602b37233a33020f5381e896045475f2e32c26ccc411729a6c3a28da48c3d23f4a4195f0b3fed32e6ef53dc96196e02fba6d100d0fa9c80e72ae84cb669666013c442443c104e981a205cf0c73bebe34dcc075fb15c6a3f30bee720c8890970faccf7c7cffc9a7b1931026ffb92062bab0e2b32774ec88f06e767b2e1d36d7a3122fe93cbed1b02698c0dfe3a0807029ed307202ab7fd98f30d2fa9092fdca741301f4e38ca1756949745478d84358fad8461d2d38152817e9808ae48859c1fb15c24a11e7bd79e22bc72f2fbefdafb608702ef7a930f7330f0ba69a7bdf6090910d33386e7a30399625ba78d2f3c6d3f45b22025d57c958f7d0d812dc0328dd2b3f6ad77f8c3ad83f0c90d4a2da30ed326380dde2fe01025a8c99fe37498d593ad53b6fa957ec367d084cc3ad15906a3935e5dac89850b7ad7b56acfc27006d465b3f716a61d6ece69548d6504a57c37f2eab998cbb1af14739a8bfb92014b1e45dd17d314e8d53f2301f8d4acce9818aca5c8a8ddad247de540a96fcd94caf7b49bbf39c52721426652b48eb21d84cd2a5733e6a7c1913d946f6d325971abea1ab39751a222795f9a106a9bffda65ded3c8a15a12341edae7ef7e4b20e0177ce0ee46229321061f2703c1047a4d66d40ebfbb0b0450f5de488786c5092936376c1475b4816bef0976f362d00abdac3645062901665b3bd11e012aa5fb932fa227edcb1052495da6eda8f4079974628cdf639244219e1b39d02314f5e0672b457940f13df003787cf5e920b20eb8ae5f449f9edd1b61bba0c8b6ecbd9fee51a9cbd78e4341e16715f7808ed750d2b835db82f6d33eec438d6d815903206dca5583784b2b2f2a53f95933e581490aa9990ed3422e7186dc89274e04d14b2fbdd10becd0fca12863ae85cbcdb5e0a7a910445c29f69b78ae1b5ee3952e087b53a6c9fbc4be7e21c0bee110f07dfdf3df24e6e35434a60be0cb7a09b3233f98b35b276cd07ab05e91b1d7c9f3e08834745c5a316bf079849a21e38806b6d8cf07788b099b371e27ff0dcdc081e76ab39040090e1530fc2e06a6022837f1bb6874865f98cefdb0c4325c2dbb409889b859595b41fafe175049e13db1eedcd0ab240c0ae210d44e7c51255e83d8fdce8afa2eb994c361b2318e5afdead27e00df3f92f4af0ac5e09885f1c8e0f21e2173994889cd1862b51afb9aab9c8cdf314eeca085c763d74e60f547d39936016bb95f2d34b5a0070853b828ad8fc4074c3e54bf25f1c413801ccaafe7784bb092a573672314045a9424ee8c6d8b21ff3af89f763cf7d57f5f142bb16c43da33807ffd7ebdb2ec633fd5c54f51584bcee1c4f44e329f3d26d19041d6cac38a901b8f27f86956fe29f2ad64f8c3bdeb7c2be97bce6fb2a50dbfd733a569c004d14d1c175f91cae5b496f5f40f2a84a912ffb15e7e5bf7b43e12322aa7b202effefd70f53a9cd4470c11f69c1dee732c974462c2e65f3813c0b0e94e620b50f41d13d1ea12f23dcd3a4df585a976531d13e445d18fe13b699b8344c660dd73bb3876881e6efbcc1e45303dd63b2ceb238ec6a2b3004bc95fd7728abb299134eb5610ddb8d61e4be335a415b85b7705e711d2c190c103aa9d7d640554438d592c80c817e0d2c680c31290c45392bf6710a3f0e98f5b73a6ca9543fbba383baa28bd8680c0eb583567e5db93ce676dda474d0864d85501858e25f6b5149002f18415325e7da83d3076b66fca5263e726341602789437170e9337657b8bd149f4eb90b5fa4292dd3a998b33b1060c96137e06c66eeb8a1c0a7ed2789547857a7c0337f59c352fa01a786e0f8f13ede269ce253d8e04d47842faff174a6f33fc517411db8c7e0aef9aba66ebaea08b34efcb7c4d1f08a0927badc52ae32c64373be7264f1146a83080077baf54d670f26e1e12df6b1e73d4803f2c99a8a59f9302047f3a74b593cd9509b644cadd2386af6eefdcb86fd7a518593c4ce1036c786d722382fef2522ca1651e9058dc2c5677641c2a4f23536d0aa3fe2bd66d534e46da1a11f4266db76cc6bc7c45fb14cc91a8a0b3786170951fc4791fcf0cdd7d53e36dcda1786cd4bdd296f0db64614ec4e1835d7a51b4831f65b50e1307916d5d3623a04c11d8ed5d31b7d5603c9e46d7b7ce129f1ca9a0d22dbbe2eb87f8862b7a44713c183969158c24111dae501b93d488b92dead754ffc592819fb498318758d927bab615b0ab8be68e5adf0135c0ddb93a6de2c50870d442d577b5fcd43778e9ac0e13f62ae7d506325ffa38fc267d697da72dfb22eb03d4c4bab3a9d904817ce78056633f93138ce773257ed88c5aa16923f2010c39fa4f38b2d529a6b61c9ac058a8e55775ec7e94df885a31bb1c68e8285a602c2260bb18a54402a515f04c1fdd3003da5709e621ec4d546f7c6cc7e2ff8d9fec6ddd214cdc27bf3ce8a699ec58174530ff11cb75df99f4fa95f2c53df1b246b3e41b88bb9fa7e5d5f9e58a0f118433c135ad367a0397c33ace556ae244f2dde84dbff84f36ecfed70e56267150a056f5c3852e179f6c4898f13dbeb94074edf5717479efe81d92aaf0a075f85d9235357040bb34fa430b7ac454caaa2f61fd4118e01483fe6327b6676c7f8d7f8358e70387e5ba5d429549113f959e57e0963409abd0f4c0e547623b624d19009b48754501b58f10916d6e9ea9277b021a3f360e7eb62876cc79183329e68226018c45fe57329c5b591b4f3338892b763680afed01cc08683f4640186a52b23adeacc1f53065c986c228569a94c294fb5de1076fdb1c7cde673440b2cc9a8f8359314ff43554ffd8f31bea9a66daa0dbb7eba65cb4ae6d1f6bcd81c9f8c5034b9ba259c10e09249a157c72fa56da365c6b25f57c3688c17474996b2595dbf5d8cc874625628c21154fd458830bc93dc8a2185a9707b46225aa1f678d4ce54c7412697ee8d9e3df8ecaaa03fd2eaf9f65834a3e74cf3a367a34e7dbcbc5e9f26598ce69d21c184550ad86db306695437c37450adc372027ba3b7930a5a7f2cef384416fabd3333aa221f048e35c821154e5912497e6701c2fe65ecfe49b05c868ff47f83aa63aa8cb4e71b2e0b87ef137b6b4f66d8632fc1f5e1d1e50482cc80a306a6c483b3776145b9081ed2191cb6bd238e626bc6cb1d3ca3e87b0576eb6234031339d3d318cc571d61dd33fc4873960a55e8932282293534971cd6fd47af95624b5015231d226b7caef59bb1e0de98881c55f906d37a721c744703964fdd49bcc5a3c223e307e56f45d493da745c3745683707d44d8565b40675f5c2825fe37b08b1556608e1775dcd06a6c68180f49ab0084a2b3ede92a3a44638128dbbe5159ae56969fd4373d0bb183f1686c143209a363a7c55ea8b53f4243506b085b114d2dc58904ea27d608665d73b02b1b55f7d6d4337f13db25d6c9c970f9921ea0166e2bd896b82f675b59c09b463b6cdafd01a1eeebf5caa18841bb8ada634f263cdb4f2b5e2696188df0731134864feaa38a908210eabd52db12e245176136ca45dafb28621da6132595407c82f20cad72da6a94f6dbfb5f59a5064ab6761ab5bbd5f57aac83a57dabafed853669ea4af159f6cfa6b1cdf18a60ef40c289450f253306c74442dc81a7a643d35ad232e9a96ffed827527b30f5ac64d04081fdff0c5cf6b830409344a2e10a0ff5142db42085485a81a84d4322f22ea23a488badf7b88df47a6712f124ca0ae0101920d1e0019efbbd9a8a539998155db7c537426eaf93242a9da0aeb3c80aefb2c85668714dc663e20f7c87e308e1aac0e048e6f9a9cfef46cc86a3d943d4e3e30916a259cf883bf8f1690887a85a305c8108c0210e0afed8db0dfa1da32e65abc4a7a622f1ae2b08279afd0de248989390bdf96d460cf8e7b27ad80751e11d13e1529d531afeda1899578ffe1d72896df5b0b866b99d867c39186720b3b5b222495faf75b142f1332fe8e6e0c0a1acf398292692cf85509e582ecfef3271cde1e216030f2040175ed194293e359da92c626f6b7bf18bfd55f70338fd37df155695bec2a9cec1f5a367a4819de32e272139ccaea9857935a9fee0c9d028c5338b4ba113cc238c3309d9601587321cced8078617a3f515a2a3550daaf26eecce88ea051ffe876b78980f100e838a2e475bb2e6d0f1a728ea4ae4d204eb721c8f535b330eca62246c59f1fc931a532d3ab22334fe1b0579b5a79477ff419b1c1df6877307b51c80b853686ccdd2f5e24ee343b8cca975d2acc04b43c27e50b62279550d32491d47048f5aa7e336d8122cf8f9ba602461f9769ff27f7629fbb043e2ac48b80dce41f713b1f6fecb65887cf82c81e21430b7bc4c727442cb03d32a3b766dc18995353ae953a1461b020be5ecc6567bff4ad426cdb1674febd0e77f8c9ac47446dbed75192af0e2ad18620fdbae81526f17185b2c99a3c411cab4e9db0095facb092f4fa91c2afb091056a3cdcc4a91ebff4b0471116fcac65901113290287ba085c470a31399b8b850af49cb08f85dfc6a34c8a200128990e5989f9832c41e4eb974810ef68342414235a8db4ad5e128c09c50c950d528fad63f3a16ceb30b5c0b062af3ad31c02c4daf69087a2742fa694b44ede800d08994bf8ab24c3b6b52e54412591feb5b02d8e733578037abf7cd094b17b0dba8c787e0387694a566b9aef4e24836f93b494da3afd2444d42a9549e0d4e90add93b1769ec6a8e392318cedf41c9d9a2878c13ac8580afb12f9767d1339a70c08a6dad244d95233ecbf7adcdd8e2f02f685092ca5c69a7aa9b496c6b6503385ae4e6afd704ff39fe85deb3864f9d64e8051f32c4dc961581ae48cd354a92d0c40f2d874bb9b0b9bf7a5648d14d021b1587805b64ae0ee27f8f1bf0f48b4e204632ca9b4813b18ccad1e6d4777a18fefe15fc75707ad9f4e9674a3f73cf40112775465596ba099867b317bf417fe7f5ebd81ae8b1e700350a5d5e2079bf6e89b101281cfc57c0c7dd487071f40477e923f7621cef9e8a8c299adefdcd03e2712afef8574392df0076b779525bb0d1c0ef9b5c7af2477fe08d45523d3842a4b2db943f7033126c2a7829bacb3d2cfc6497ec91688189e81b7f8742488224ba320ce983ce9480722f2cc5bc42611f00bb6311884f660ccc244788378673532edb05284fd92e83f6f6dab406209032e6af9a33c998677933e32d6fb95fd27408940d7728f9c9c40267ca1d20ce920db5278679dda94d78254079654e3b69324e446dfe98962cea9d6a432993b22f57750a6d0c4becdfb0ab2372918082fe320ad56ee72618209ed0e78f00e6362fb92e4298139bc7e7cacc74611cd69c5a1f432e56575be76d88a2c6f4c9a1c159dae9b64fb756a42b6d911b8e2dd8f1459f02376d78bd6bdb4f1befbbad4dba7663ae4eda2003ea7542000041ed0fe9875a4ed8fd72d60d319c434b2bd3718b4efb83f280752a018bf1240cc28302ede7fa2ff94c6d2e33391623c08e63959ba94b728a8adf53513521022558183a632e24ad82a3904b47b966c2372a8741524ffa82fe408507423d7aa4344dd43db52482d15b4a03b7af7a3328994965fe1808b1bb36ea90cd3c6aa61122e7de954991bca26d89effad544265ecc312553559b18261bd0272ea7834a51d56f5fc9893d7a289ea87c9a1fdfe76bba2af0c971d1d6ca933a73b1eb51116d372c7e62dcf0636cd7eed121f7121d57497eeee7d47294b0876f9bde709ca06c2f6864e7a9711f7501a51717c4a6702b63734635e746f9dee0b8c83d9e2ba256a46938e05a89574c02137502ed648aeeef53213b1014ae5e845d2257dec8bd33807923d65600b3f7c480146cdc1110a8d564a682b8a65a385da6d0b39639990caade4d50059eda802d361bdcf878ad61fdeffe9148c2a67252dafbd93047dfe80ae0ddd6cf2a75ee277cb3dba96007224f3b50f026313a164a43ca5212ba37d088c9fcf01c6e2b4a999904f05790c6f2b392c528bcbabd2b2f2766a5a65a48cb0cdfd1275430a59b6ad635a36ad193da113a85c07127d8bae8cff65a52efbbe17e6c8502df398ae9847b6f7c4aeb16e1517cb740ac3f32ca5d83a3fa8040371ac6b63f0a2551833dced0d90460a6f60f5ba08330d7c97463768b950c9716657fcc0628c58f3f389e301c9cc212cadb6c17ee1219598e458d1b2ef318ff39ed1779a368bd83cd501492a9df3ec91e6f016dae8c839a564e5134b5e5a61f7176ebb3d7267a6ac174a7dcbdcb01ee6b57d5462719f402e836b6a968953f6186a80163e88a82ade44b60f6a18892e7793ef088a2dff6f90ea6c5628f286a2c3f2d63721fbd5fb2fe7e46c99d3d791e10ca5b1d670910e78e46854772c9b0e965aa19c6c4e799e3d7b4613bf8123ff9f8a31debbebdcb3431bdfe41599e98fec0ca29491f2fb6a73696ba35fc306be2f8723edcef23ad48bfb438368bcfaad418329de177be4065e5cb58a0efbf8540dadfc7d74165408b00d23c1051856ed3358d7c7816bcbf87aafc44621ae6167b6491bfc3fea80c66bcc011b5f3e86d63df81cff54250b9744ed18465c5cea5fb5f312e8a6c17983fba25bf0fb91f2eedddb69d4044a2b89499f1228f389fba2792661d13d3d76c7fc3aa4f04ea5339d7f8d6ee4164db434f520525caba80dd69c7d992467d13108f9ff7c87ed0ab178bf886cbe0e923e30d43b496fd94999728c432980bb1f10dd516b33264b1504f6fa5703a051da11e3632a77c100f136fcd5218344ab699e9bbef86959ed66969edc63c4698467e7f32e886dfea7116eebe393370ebd5342fa8f41afa13871fee6c2592f481ade18b692df8c87502c99a64412c53d656ea6404eb1468ad0c9a655488184ea89af3cc44c8a53d980c55fe2732abe5f481e212369d1fe853ac01560cb8795bf554dcc9298336493bd5e29f70d3572f2b9d45c0a8d2e181edb07c49fe7d5b235125c30a812453f146a69707a5edd93864f43af7c152023b646035c7919e67afa253d018b574a33fa2c79cbd3048d80988ccea3ee9e42b1e9e0451572de54406d2272d7a2b3bcf3a35801a4977acfda87d6e7d1d8852043384e4fb823a189a30c7e9ffb84d417eeae8193934e4e1f01f2d221a1c06623481fe4859cf200013366be1715b824d5958a4d92004ddae58767e30e9c4ccdd6410f57793c64865551fa457a8ea3129088b4f0af844ccdddeb35adf139c408a3be94fbad2ef180f08f35c92cfedc49b328bd2f2e879183429e0a878c02dcb336213f6593ed3f9c5d5bb7adb0ceca26c7f6116d9192d297ce204504317fdd69e8096d09cfef95451647ee67a8770336499140209b2e7677cb02839884196c7943e7bc7ca3be98f795c4488b76a00df4a25ac7dc9dc303afe3c534d8f668007dd44c9c22d1c2c1406651548d9da250ee8ce327160bf8f0ac82d8d739fac41ff413988a80bca4949bf29fa0e2a0166280439adc517828c3fa42cde93023e631688c5c163ad6cc8986e4dfac2f0074b9567112561364eaf4158e14f96fe426eb379917bda5b2b3268d97c1e4c74145cbdd9fca32d054a8178acf3e762dce1e840de45bef55d2f0e20c95c6d94fe4e220921a22d11cb9f894d6a0bafe0e4425b247d89929cfa9fe42a0695ef82d6e024df09adcef5d2744f2658d0adf85d8e4ec71e0300b77ba33ded58d0acff43f0eaa857c28bc160f25c6c40ebeb9391ec4a918b5e0f2e28659fd187b5adf18ea7fdcdd48b6e5dbe403788e8037197c685d6ea8b40c8e9490a953e5aebf942002ce4b448b07eb1348868e018c145ee45807a3ae55231d126bda49c9b1b98d8dfa827c77bd9c3a509ef78de9acd717e5606bee9623b55cc07a4565310ec939d73424f6d34ad4622879feee935cefd31403f2b5fcaa339c333e732cb8207f1770623e30d3dd40e0ef4c05268b06cefed4d524804e534e79ff3afc06db813ba50de726b115cf7235399792dc5d450519cc3689d417a9466468f24899f7cb9f60f445870e05abe8ed7bef3066769222a25eba8b37c536bbea24f6d14ca94a1ae9c80fd79e2fed05684ab5665b6378983700d3b111e3662f89a7ab3e957c972eadfda880e7f12d68340a7c9d21a052e636571484090ec201a155a1d91ace3d4b0c09a21b71f5c771ef5fb74d6fb9cb9d2ec5ef8c6393d4e2ffd35d49333aa710a2707f2fd2aa65c2e8af080f8c1c5d1d9ed1e732d80f0943c3954ff7753e6eefffc6a206708b62cbbe7cc15c1d4461e7e50f7e0fccfcf994bb1ffc7c6735ef697270bd67e215490cef4d75ab89de74acbfd3267bc8da006634d7e5407fddb2fdb90323ac8de4a306d995b78658272fac8dc1632f4212c828df5 +MD = c16f349a856d4f9146bd281fd2b1502087f75ef0e2260015e6e3201f22eedbadb0dc40ed3c9e99de9ec5f761478492ae + +Len = 81016 +Msg = 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 +MD = 4b10df4fbdbcd0ab46f3132c2285a26e1d9c74b1b7565526f02de3799383ee3e183c6d11b9a500beda827873039c4523 + +Len = 81808 +Msg = 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 +MD = f22ba6107688aeb25c2f2465d8fac70a67acc7c104b2ec614c281869db51aada00df0eb51ba6a25ad7efb72744d35cdf + +Len = 82600 +Msg = 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 +MD = fc98a8a7b37b9798aec687fe4e80e30d616598d0a6ac2c4826058a98db089df3d65fc9f58c3c1c518cb46c3b164a203c + +Len = 83392 +Msg = 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 +MD = b927381128f052bf16953a327e8bdb5fea57b3715142ea1e0eded78b5c2061dc68cad2956fd5ec7e51dc22ebcecca4a3 + +Len = 84184 +Msg = 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 +MD = 1b1979f92d62c71c5756924a1778ef10514450677754acd36cd0a9d71d9ae400f556e03f5dd8337a24e8e6d129c7c919 + +Len = 84976 +Msg = 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 +MD = 9dbd0cc2c35ddf97c3940ed706ff7a2cee1169ff64661db7d1a805619422eff4bcd7b3df0703cb8fd3fd060822dff322 + +Len = 85768 +Msg = 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 +MD = 87703bdb80194b39bcd2c71c2347bf71962fef9d9b77f637f798115dad973d0642c50ab15ad7bcd9e5452c4990376ff8 + +Len = 86560 +Msg = 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 +MD = da81f8b846337c2dbf86c1818305516dcf50b6bd9e7b4b91312bcd32ee8e0736e869ec791043a7c67bb853a70f4a9f84 + +Len = 87352 +Msg = e3c137117f3738282f808dd94aec5699fa4938483507f46eee9a3fc48c20cef69b44b0a7c162e0b5f4ec1bbfeb0cefe5d28a15cf42f100f170edb60da5f8dff9ee351ba2149c9951ce58e62d366d02027a9eb940d48e3047bc25bfe15c35fe10445e230b5f2f8b83258d962a1359b876584dcda2d227adf7380a0149992155c405856ee98a61ddd36254d4bf6a1639cbd65ff9fe23049f894e63254c4402099c9973a4447c7bb8c9eb7348f323edac885b9be45bb16d2d8565fad2f34521452168f06e241fc443ee29b299ce262639364eca37c163aa7f74e495b14584c62fd9dbc474925a86a7c984db6f585b090a5c19b499392102bede35fd694ae939ef4e58b65d9515070be365b4749aabde44822321b3c9d3bf1249bffaa30a5dc1ae08488fd136389198c232074e9bfcec1231d4d92d7c6127a23fea54078ec6a7948e14177a7cac6a75f0559aa563387c9aef94a3ae57b48397471ed23cdd0e34c8672216fd6f57daccf5343522fb45d60447cb49de64b21a18eac33debff1bad731edc540517222bc25739a26c6a0d4279bee19166aa44364eae415dbbfdd75dbc38a998387df5a381a0caa82cb8760821de3e44ee31531d611e01fa55de288bcc3ff0ac3ea8b98c3157510e0aee6a6f232e4b2a1d02c51878bf69dc60aaf87ecabb1b56c0a0542cf905359dad13d0c0a7366e0a9c24846fbb1be2ca85692e7fdf32915f666eb0cc0231de1dbe2f8f44d77f10ad129f766a53b9d58e6c24b2d6332eba8fd719b4b37463b456e44b9140d9909adc287c85516821a8eebce36ccbed36feadbca9472b76241f0fc86dbdffd5f1725d86c2986b21dcc5b31eac44a636d3c583bc27537a30fa871212a0fbc8f42b02f8d3799601a77192a5398922ae358b77d7809abfe9cb70542569e933e25dc5b177b8a9695b2268798bb681ee2c13e97c72af0a73c06f0bee1175524d963a47e6a0dc5bf8c1b94ae02e3c9c9068f7723c1cf27f56474355bd9ddfe2322cb03a0b3de8972b7b949d315774e3f0aa0ab0209cf10252c670d52a934fa1c8ece92587148363ead0dcecd3cc055df63a732a8ebc539a4e841d139bb96c98f81d0d90c2ee56c91d0ab9bc2e5699138b5f5b68ef42c15033ca739879d9dfceab094303249208d0ac6f5297aabcd50b9563eaf3acf7e22be7e09aeb2db94f4bc7f6b40715ca42807f48d004afc8634ffd8c47522ba35f33530eb9941d226518352d8823fd5cace27fdc5a8ca540ebe7ac239b0dd60edf705f9cf91cb3dbc93cdef6e6e04411edfd927519b5f4ed14d9896f0dad14ff0bebf4d1810a56ae22bfa998f6c552b1aedaa159350a0497872f7bbac6b94c408babf8f67ae66d6119aa7d5de25a8f04967f95d1d5103e05ecf16c4aeeb9e89706b855530b3962bd5504448bcf2764d14ef6542521510801ea254369ac354fcd241bf1305d899c8a7fd5e56be7b537e27d47c89d4254cb5129d5e85d28b6e9aa8edbb6d5976183903e264845528b71fdcc78d78160a1f0be5208426e8bc31ef5ec008a89e2467f963bfe556138317bebe3936b18a2c1dd100dc73be6fde55678e593579666c2f8661d65f406c030bb74699f6bab313bfc0f0119ba0ba5a3f9f9229a04424a5c56c68d630d7e120f9b5f07a5bf823597b483d706a827ac856f414b2079d6b79d017f3301880f5756827664ac4fe5d55e6c333696eb8039132018072a9e99d40b6259b6464d02b78ed87f29bc031c39178ee8c7d26c5e75d67545fec25bd5ca30df1bbf3b449f593e0443fdddc36e8a4a816a32c1130b8855d492d9ef98d0c094e18ff5e6562d66ee708a89187725f07fad811e6bc9ce9918a6c540ba3dd4dfbdd17b015169f60526831c74740787923f7af533d974eed0a854a7da2932274e3515a88a8466405f6fa5c067fa5bdd9911508d1a12fdb4568c440050475f11368417de398536549c503e400ab15b6e2c7e97127b1e4d68534ce0984919acdcbf303de4b65ebf7ae352b66204a1f084740db74dfd064b52ee718f366ea902ce10c3f184a817ebf95cfb76effed200659946180349d1deb95082b8a467fe473152c59a84b7b6a11b30d6e4ae9f4d745ac2b122ff0787f0e7a107c5a8db20654bacbc9fad8c45c92687686969901935ab17d73e08de31682208891d0b7318426547326ac7cfcb4a63883b6ee6783e2aa0c13fd2e576d62db3ad8f2894d6edc8c64bae629a28510e1a5cd659ee00c53a81e871485f787e29e2b9a14e0daca7ddb8dfb9efed3ddefc932ac19349d0b54f95b3f6063e8c3143f65447f73c9f4f6b812bda798ab97afc151b8585bf8f1650254b55764a59f86339a50a8beb55eb596a58996837422df6e957a99618e5f02479d816fe4a88da71f1d57172e076868fbb8e7e25bd8000d25805b52d1b7c4cb5d981c20808c0e056670b0514e4ab25f5bcf41216e41dfa78a84e31b492f931ea8d6ee0fb4aaa11f8e3704cdabe9cd273b5b3dca473be24d12159a6924307a8abdcc8f83fd9ee7540ac2cd02a38f094f1edf26437340d84c30d4f9c2ff64cb8e010b7923c7d3314160c66196d184f7457adda3338edb22537b25799f3757069716f62375afd21f7634947ad0c2763788d3d93d00d67550c165a9a2746871cc34742f26e012361250dacf6166d2dd1aa7be544c3206a9d43464b3fcd90f3f8cf48d08ec099b59ba6fe7d9bdcfaf244120aed1695d8be32d1b1cd6f143982ab945d635fb48a7c76831c0460851a3d62b7209c30cd9c2abdbe3d2a5282a9fcde1a6f418dd23c409bc351896b9b34d7d3a1a63bbaf3d677e612d4a80fa14829386a64b33fa217c9b26e8453e4a6b28940d88512de90ed6d54d65d91cff97fd0628b26019dad84de628d9dabf42cfb195165a369c22b49d4b012c02bb910b4bb03859b73d07ae949532683d9c3b7774fad4fea888e4c5274a1cce5bff67050b0c461ad510091afd02e44202578ce8ef5fd9e41b66b7b7015d00eb494ada1bc784d2643e2547b3f3c9bec5bd63bfaa8d1e85a8f3d81410b7ee4df15f407295fdb45dc446ff5bfff5441281c3636c12dad178cbe63f7258b788648f0252c92a0a0548c9a400be559e2c9ff4b8b8eae854f313cb571f5b058cb5e4f2d704364e991233d2c9dbd76b4acda7ad11e6e46187fdf705caea568da3f13ffb41d7425a1745af7e2ce33f9787c1d9f9437fc134f07c9329b642dd7799b4e5d6d74e95f2f12a1c2a41a96f60c183a787d1e609c90ae96895ad9b5859ea9b67340bdc799fd339ea75acb0ef5da48d80d741ac369443bef7e815766f9af2ff448163f395c729efcadec27c27f49d69f6462744d03d4777b17f82467bb16f6afe4d543652ff61d61dd4277db1bc18839872d7525f1a62ae35ea788e15339c690506711739af176763d45028052aa284b7ebf6274bb241bce5b77cdfc4a82673f93b2f18c25cb72e2d8db12daab6d7c804ffe8661eab514e5154e39df2658a063b5a02bd859edd94db3eded11ae704d7d04d4281505c0dbd0941616b372223aa4bf18067ebdbd7361d864dc4ce31c62eda5288fb794af3a36e0b5aa9fb34afeacb801cba6daa408c34e2627b3d3d9857638e104701fe9f6bf02153ecc7337b120a845c37a360b5f1e1d1d166f05107cc0c7e9cf682fd6da14011c196239511eab97cb331f5b5841184e2ff1a801271074592738c64bdeaddde5b485888e000cf38e7b66c0d1f57659e746ff855088093af78387b3fc6936c1b6c4c866f9ac42a0943da3831e48c68af349892f79992fb9a8e50356c9df3e697d332b2502bd895bb2f93190ccbbf9537720d7ce04c44a9a7435f5d83aa88d7d42ebf6ed319ba9ccef97591063b4d65b7db331897a702184635ba560d72ceba40bd371e50fae6a9a53ff632b699d264b0ceadf8862047d207e405b1729d42086e2d3e436235f946de61a970868ddb1ca2dad28f444ea2616ccca5f24b706f3ccced39607f514eeefb1ce3cd0e7dc3f81e7e456f5a889e40d55e2f8b0092b2e1ed8bbd0810e3641c6bb049caa6f0298184277afb217497fae227170e3a8ac97230673daccf52e559a0ca5fdbf87b78336464e7c541992bea03a5d0de41beff78462e4fc0f3263f214ad97a837b763ca83fc51040234cc6a8ba69018dcea5e15e9f4f47e734e3ce0dba5c4e539876e33a96b6991e5f25f4b196cf0d8f29e60bbf8c38ca71fd023e698fc12fced8040874d9b7c6925dab429f09667974fbe5caf5cd795c03b407fcef3bb6b347c29418d1a9573d5e97431ccb82bdc9b1ad2bcbabb38f511f127b75e93e9b6d60e0ada0fb560371d59493ffc1a34362e7c63e7a4beef96e2670c355f218edb2acaac71d3c904af899ee04780bdb85f969df845350c025e7bc577609844b3c178d99670a3fc8ac261e0c1af214bbf3e1ba4193e354e7c372334f0a0d3a55e520863503d45f6f95aec4675e0a76952bb07ba4e3a6b2b620824dc005dd6ec9a75218f63428160595e73f98343dac177bea00620a1a04cbeb9c4e42eff6ac06c120d8556e521e2b3b53e21733f81fb382f30b116db9c5897314c7403ee57c9de12126eb190eb230e4995e4ce3b66bf9df6fde2b95027f8f65a04b6069365b0f75b7972fdaaa9cc7201c06d1ba14fb3adfc50c28f6909d4e21b33d0bf545c1dbfd68ab8c19b2184e7c506e2e2d8058270277079228c0993635c22eab69a03b73f6b8c6985ca1cf4767db16cac4850d2ee60a72efa22f1dd81051a2d74ce23277e03c9acd2a161c426110732ff59f74c30903b099d94875c45ff61c080568414848487aa2e87ba9b006a515d6673c4973d9d7533954894b5b6303fcc629cee275ad80f8a24e4ed210a6ed61466fe7d5b1d719dd46aa8df93dd81fe79a306290807e5a9753921c3ff4e06e0808962eb42d9f2fb13a21b329cc0dae5eecafefc5e93959c93f7a404ddd41bb5c85607d6f2780ad619c708537869243b545feb31d207ce320be5d67862a2939e165556061302a0780e60d90bd0e04549d2ea358e0b6a7ab1068b1fe637c258e38f0fb5424e809b2719f6f5224c2b275791f443dcb2c48062ab72e818043c50cc5d0b8d534bf9e52c6210c4609354b0acb9047fe26e1ec88d232197d4701665a1a8d14702b17565cf1236ae8d4e63ca9271a3506ae87f3a7a952096e3235a7ea997ea491528fc035751f11b70245e5c4fe1581e3ac7efbe702af84b0dc610822d53ddfd545a97a70e46c773d2be4f4e2c32ab521cb4763cb90a302019013e5b750432ca89ec4d393a1a421e7bc33d88718c2452d5571d9c9b5c507bd17beef0c9d072177a8927a124f4ea8433dc31f166164c873057ebc65f49e1c6fbdd272971e2244ef0d72bc714fd460ec2b1327353f9aa59f45de9a24cf86a6860cef2eeb460d0d6b37e6394515dde22efe948f57f5cc731e8101d19ac9173c9c8f75627dc73ff178b27d7ee253b3a2a832d7b6033682975d6199111c53e8451fbff5bbc2f423779407a8ebfd6bfe38c4724d49ab7455a8f841f4d73e1252668c0900995f6f60364991e90edad1360b200775a8c531ae2e5bacb5728466ee076e04f699b78b6e84060bce561f25c390279cd161e4f0f47e142c5b9173c423be324e682b4ffab70755bfb9604edc5f7e679cf0e39f24e13e9e3b47b270dc9be1751fd5cc9d1fc226b5384a9bde67321c5c7254cc385fccd676440a342ff2af17b323b00c337d2868a0ffe297324913f062c76d8a65044fec28e123b4f5c8e5c758e4975887955253b59121b10f045d913706ab8c89b4c2d6229d24a356a1c886e2ccec302dfac86e4f768897b92b778535baaf613ae3ce2affd28d9de72fdfccfd573f317b10032efb2a77a9c5211a32eb4de9a6dd03da611d1baef31bb5840fe51e00cb13678afc25277f75b7778e30c45aeaac04b77fff06e3394168f56dd6568bc16b7b73d87c79f8207a04b16bf55d4c030f3651178b49d39d075341f5a6ae2b01a117c764164616db2531413bf712abf33ee673396c52474ac36f3da3f7786631ea7cd4c66035fe3005c1b976bc90f51bc999907e38bcb8e2f4214af15f31d7e2d61f2e77d0b628afaa3a8c94cc34b1ed2dc42b2e66f5c2c627fdfc762466fa84c27326e0ee4320aa71103d1e9c8a5cf7d9fab5f27d79df94bd69c4ab1d7448a85e1d70aa2f5970c108c73d8ca41e60cc5ca1d342f2c589af42f9260871064cbdf7727e2c0a859383bfd41067894d67cb345de5985d753ba65730a2f6e58971463d16b1ff0643f35324db6827a2b3dc84ef836f7b13e57ffa5884ce2ed17a40d17d7eae8ba9212acfd621875586ce3989fcb6f363ccb2b11bb58a09f8db6545d0572ee66a7989a44a226af069bc19092aca7d03dade59999b2ca4e8ed49b6fad3588bdc03edf9fa62b80c55eca910b617f72a0358cf3673f8fc59dd94c2fbda4ad02a01f07cfe9799f57a0a46d431dab20162845625f5eaa5c33d7a57dda05eb77c9dfab8bd03f66079589010d418e199579b096b590468321fb421dee0511299bc4c28b514b6b156a21c89d31f22652e8857f5010eee771e40526662716a7071fda91e8e2a6332dd0e3a59f61beacff2120df9af8e1081daf39cdabb077902d0df593e9c44b605742c3682f250deac74634169cf7d1732e897f7e12128e94426cfc11b781a0ba3ac6a958770647a65361a86d7f9426ee4d7bbf80c3d4c57aef45d65379a10f087f677dbe9c8bd4a94a79642c6b584842228be11ce77e830cdb9f6da158aaff14cd2a27e2c93d1dbb5597509b87c9a03754c3cd9aa6982f10ae82a8437c26d8a4cd198f0c24a288a31cc25402fc7194948c2b6b4227ab334f12f76f800c9c0181263b9e84d5447e2b460258a8f1d88d2371caa45b933ef691ad04aaa23195e47381983a9105ab68197c5f44d68f84f4aaaca85e2f11dae09d27b441ef1298e84186394c7ddc5dac3665e200d4feff2ff2e4cd8204ca06593d290c1db0d82d75b5dc25bd8e81e4b44aaa9274ea65d1a8c3c242f923e64ac9375b16242caadcf3952c64730d1dc8e61df2788960ec80c5e4ee0ea9d48c2e985464d93fadb12ecaaa1dff5842d78fac76e69a257dbd96f01f0f397c5fe43b2e5ced5d577914aa63bc58fd5374d8c36d1f2d02318afd9b903acdcc590b17f8f4179dab52d9fcd9249384664bec47eb90de70b896cfd7150cfed2ce27214dee504d1dca1a15914176f64a432af34d907f7c57c23a94718ece33c347d0e9ada3abc514c29575fa6cc2ae529bd7cf1239a1c1892a0721f38d3da14b3f3bab60a16e482b9cad4160e26e8443763ac8bd6e5e74aff8e4bd869bc10f10bf50af8e70ff9e0a5f49c0ea29e43dc6dc3b2877b81e5f7032b8b2523fc247bacef73c5d96c88f5813503bc1cb8aa482d6c235679d494875e26d467e01a80ff275189cf89d2fe3bdc0acfa0c50ca80206bb739b6a747f8660feac23269dc3060bb9b15850d9e61e36f4445f43e0b9847a4027a8b5e8137eac2176e9800c472aba868f02d6c7cd26f280064a11fb4b5a0878b410f495dcca902dc91d54dc99c7b446875174431fe0cf1c89e3a7a2f9fd21f3bd569f044814cd7217414d853787a9881eb6c1c25ad60d4843de8d8e31e8671f880c2db9f1c7b49ce607b2acbcc4eab9c9c537dc0a713d81c87d2c038fa6487ab884293d466dd61cb9b32ca97619f85a2cef5ee6ab3ce0578c521ba96fa13683d36109f4d271b26006d624021ff162f79ca79f78b9b3964813efc4e65e83c1c94d255877027dca156203315d06d5ab00bd808208b25fbfc1d3c8c050d8a86ac9aa438d4a72dc9d8b3fbccd00b7514103e3fcaf2d21abcd63505f866f6a89a1f35f3e20d59038ad5014556f93cddec58fc49e6f4c84126f8b2e269fa890c1f7d4f097bbaed6fc6a02647f819ca6e898f2c3c85afd564df6c7a1b07472c7dbececf2c2a63cd3a253f0c49dbb71df094bdb661cea962498f3a77f8f9d748c21f1b9da51791602c51bc9992265b9d2bb4ea8100ea6cd5b9df688fc1683246a4e96ba1bc6bcb0e0cef1eb76c028db2e7921f77610080987c7600acbd7bde8cebc5c7c3b84e9a3fa4aa6e4d1d97d6c4ebd6647fcb396b115afe09b5355b65845f5a36ebe3e7855bba27b342ee0cbd3b0027bf8188bdb7aa1b1c8c92712f4f95c751c001835f14ca1711f580278acb7fee2d3a66deb3ebca867a902bb9202226ed516dede1ddcff5830e3dee103886f87d91dc14164390d865c01d68555668a197034697458a3f42c5c69274f13f780e74fbad7477972d3e7e963b318cf8a86d8e0e52e7f68eeb1aa7e3fcfa11c6292a9d12b66e4bd44a6399a2f36ea82f6bf29a1c9ac63e105be6ef0a8368b9f620b2be7ffeebd82570af808f4c07ef22389882d2241a6338180c66e530a631f7e510a0ea8dd168b0258afa034fe4aafa97c710dafacdae2fa9f6d41c0a9dc1f000aa0bf96c0a419df45ccea603ed20de10e70adc24c5671d960a01571933b109faeac757a27cab15628dc522700b9bf72c60397fa8ecd62a68b2b43d6651486c59379baa3711f040f985a71c9e24616c729a656c9028437ca655b776f8e0cf3ea8f8509b34af574540ad3c3f9621bb666bfe564be463f53ed85ad0abd8c68eaa6c97aed1a040274cbf6b4b305febf10d9df2d3c3aa843596872bc8840cedcdd52f7b7df583aba97fff289e9a01684b8892dfa67cec734bac3a2f66a89e3bd4ea780c85aee6d82504874dfb2385821100d22e951fb1187fa979ce74c0959aea0fd0b28ea5d0afe203df402b73f2208a9ce3456954025b18b5cc70b873faf1596cbed55f8149182aa5906bf633502aff854f8ee9c2e62460f7bc7dfc6ad427672bcaddc1eb59fb43112135230ba787b8e29e6fdf12655b9d98d05d064c2b265d717c327c8b094076701a057ca20021fddc565211eb87e818bf91799ec208d583695d3c580860cf0bea0445c7a162df169b019e49f655b3199585378e74721c2038f4641d0b66904aa6665ccdafd6a94a4626bb4ddbd6a4e84236009d0971e37d09c910923b246c7bcdc8b256756367e3064e11e54112a4cced2c3d922a0d12e30265a98041a149e586b2af2a9b110127020008dbd012990fbfed54367e4f92984b4f98afc4e611d1faadbb10c8e8605f63c408f631dd6df7df03af51ae3e49e40d0f44e76df9aa8751403ed1a4f16ad2502279fd0c7b06cd75f6b4ab61e22011702e14f0e4e4fe4fb2f4a035d83308caf2a3c3b908f54ed8ab4ccd0b4044ff669b337291d0aff371455049040cb6238d70ce4ef2ce522b62a78f613af26bcf2ab7a6c594d960733434dca106e783a164f32c826f069a87b19146d701205f76a6eb1074bfa80165e2a420110312a16c97a343c8fa57d6490e92fa99267229de2260f8e9dbe599b0c1bfa5ffc235186a6ea79e8659690d59c1d2320e718fd0ede53de68baf38313e1aadf2d40cf7f1853128c22555e5479f1278769eac205c8d39ab62c20547d0f634968ff9a90033a3274d390eb6738c0249ac4eb19dccd6a564d2f5f6a3bd7ec059a105d461f9e6ae993f8aa844bae56dad9843af0e3c451dafd9268f52404384cff6dbcffc8a138dcf253d5ac76359c58761dc01c518b1dd62e97ef5da78282adfbe9951415ac1281128da8e0615f1f31f32a20d8a0723ccc5298491030f349bd121c8c1f912f867a770eaabca79b4dfbd311c3c27b1a1d420c2c0c995aa70bded46ef89ec59c032d824f519db37aa71a986d2f662bf36dcbadbba0657f4e2797b569610e2d82271ee6d813f01f6db922a5a4ca405d9e7cddc9dfbb1129294b8c27845bea337250c2f721887045e50288ad513acd6a6be8dce300a308e2f8e600bd585fbf61dd2ebe45c4158ab18101c0f1eae789ecfc205d8bb6fed9371d65a9e94dd2fa5322ff75452851abfcc2357025ea56e24fbfb1d4266b34ee900768fc3dfd6c2761f4716c97d6a36092192c0abbc81f832d372be535b5dbd578576e6c2dbf61d328c1f3189047a124ec0643e5161c87d8eff2ece54bff5a1a7a8dc46e2b2c8a6a120c131dd103d175951a1bb3d740565012637368dbd03629f10b2996c8cd1c68a8434fc0dc93aadf17b511eb81ebd1753f096df467a1068086600c6a8909be5b660807c6156f93ddde67d4f08877afd4c0752b0c721a31aa951ccb5dee7ad6cee5bae9721e0022de63b2d3575d6c37eb410739057d845e24c7a204e56b88fc1f81dc437948edee7d42267ba4934210252b6026940c77d27b7880379572cca4e9c4fcd43038914d16f4235c5cac81bf1ef9e0622c818d352b3247e1e2b6be57aa499cea3b6f82c557e449e3f42bb39b4537387a338f0cfc908f69725189c68acd6a2d13ff504aedacbcfab0ef73403b146db8ed4d87afaf57ea5587667e8db4efc13ddff08d523c81c8c621b325c0251907e219defdbdb3edddac9f96076c7c7dc93fbcb369213863a23cd4e3a5abdfcf8064be6c73efb0dec3cf1974a6fb47f3fcb328bc964047eed3bf48f5957bc1b48181197a6c9e0c87474d8366ffa28deec628a2707728017fc7cddc7d57b8814465f7d98d5a414d93d2986bf1540ad4cad010b8739e50eb9319092dcf7eda851bb8096d19cf81fa60f04041b8568ca314850be93a6e437cc521c1bb807d6a4386e26642a42ed8799b2ad5930079b08f586f6aa34989881b828cb7e414d5d053329f7f08c11aad618edcb8de8e201ed002f9cd750552876e67b42c56110ab52a9b29b41dd4f58938d8a06a92a60c103ba0be94ed026bd9ebc132cf8ff9ae71302d2bb5f07451e475f4f08b3ddc704d28ce186169d537f80a3b72f1d03313ad1a551ff53f03b2579f60576b6eb60f1e1dc7b1a379d2495a40431f33e541ecc12fcf70e24827894b1ba74fbb73b73b1b8139f4ebabae1289245472162dca9c4616e8c91daa346947813633dc0b5486bdf9a16caa6dbd15fd3d0c2619282194b4363d72f7e3deb4d54699be4d8412648dfd7a83503e83d63ee0b695ad52eb8884243a1911737b0e6d024e59908c757703e341c38dac86d5b6b6006b533c8cca4e577b25ead79dd8871ac0704572f210a87183c7a3265a970d3365f19b4399ec6b465d23f49ebba5ac169c9cccd61cd3e3febcea413a639caacf43e2f616776173876c9dcf1758f8547c4f5997246a236f0149b5d857364908104699f413b9cbff8125edcb0ffa3308b2351154fc4ea1721fd6b4e91b474ebd7cda8105c9d57e57da25be88b713f8416efa7e66bc4eb0c5b0d061e3e51af0238b7c52bbb76f0b14d8c86a78cb3aba96f91bdb4ce2fef3a25ac337695335efe2b2a869765acaf4cf23aa7c2baad2fc61e6f5b2881eb3ccc0742bcfe9c40c806398eb5fc6229dcdef41288e01d481303acf34be98be21ae88937675d5d613743e84b1804bbd3bf8ed97ef0aabe6a9e89a08454a0f4fad3b734f4fd3ce07ff1dcc3c978557794a0852be5a6c7a4fc198082893df5c51dae608fdf45422b803ffa4f719c979e53c6eb71af73e0d7e7cc10db6ccf8f0532f20b23610918484e69c516a94e7339f87ae734431f9d6011ff5f3194d217bc21e8e276e30f653fcfb7649fda54904f6a04a1fb0b72a54664fa980f690e34f2d2d80a12cb20d216ed7100726d7798e893ac424e6e34a191c704e1fa534a8fb02c09ae7f820407d78edec018c87f300c5abaf2b5d42c384a2167627cba50d0fd19c5f4437183ab8a9c47cd18553402c4a775d8b9a52313785c69451c06e69ee2815204e8ff656635fef44efa7b5eb61762261de14ae1da235f53af639fd5a1664af907f69371e2e29c2d6c47a1c4f40e7415e8b6292e3453126dcad7eee482915d0225f39770c4985e3a4f86312f63b0c38a62bfabd2c9115dfebe0259dde96ba2b58569722bb7602c621e3f9267ab0538cdb384389442642850b36c49867dfd015a50df8c676141eeef02fa2c347515bb25028d393d47555ba9d09b27a9e74e6338adde4def6a438c272240675e69e935dc776314957febde523d19590ccf66ae98c5ed1d8a7b6eee53a798abac2e888c383c8d3364932e9993236e4978db4eccc2c09464ff3ccbfdbab88b60e76dfaaa827693fc722a2675b3aa205db4b60da3fec55b8a1754619fa67ea0eed7cd48750150fed987eddc58fcf9b9ff8a06ab1d94fccbf79a6c38bd5d205fbd44f779d7fff054316a84572cb439c196c0743121cb8e6b13502b594028c75035f69295b7c27e206ce4969fd72491be8a1fa7a696eda3c347003acb0e4f9bfcbfb447a5fc9323e7f1bdcbbd43942a3a426f48126640625cf9744096111ac3eac148beaf90ba06332abdcdb8564b2bbc2878fe7e780df4bd9372e6c32fd168a2a5789ebe5a7f518b7eab4198fa93bdcda30172f1b49b816e7bc3d45952bbb1add10d8fd7422a29785551d26616b208f41bd44b73023430f81b2fb1606121c792afcf3b043002b8811875262991f133b9f8b7320c4a1e29e2d97d25e1444bd1d9a585474c0c50262e2de0e5e9559867a4a373cfc574a295b41f77dae2e381f80b1df95eb8be5c9b07fd5ab8ae49efcb3e82d0c9a568089cf754e3756e260b64af7ef1264e2f6e3e95f0ab4781553e880efe95c9b40f986532df8aa18af5303c4d3036471845ce375f6f9a396961ccc59c808c76fb4f9a19ed2a340440383aa96d9b906a1ee9c4afede0f0366f55e2ab716e7b79811155dfb19ca84697d76fd29827c637670497cec8ac75e89a19c86214312b794f3e12e0049db01098ba18e0553ca255fb7c90bb773cf1f4f296c6110d32641f6bbc19437195120a49c97cfa2d42ea6de23bf79f82f72c057fb224e0e5d8ed13df75b2317dec97dbb4ede549a7a16726242714a17244edc14a5629f8238a90fcb34f25d2b20b072be10c99f44bc1e129ca2a2eeace8dfed05a6b1e814fb21382ed34b94d97582aa4d60fe124a10a201ddc2b8ea11e3925dbb7d74ba2f2b73f4e970bb7cbb43cc8ec9ddf050132e5ebab60117defebb02b8a6a84f8849301dc08b8bc67739220a8ab3e624db285b80b7b60c641fcbb59d8847a586d4fbaf8b258592e116eb86a938abf82016022ec4934e33122ef199ef372ef3df12aef0488e4814bfde3ae8451302a26683292ea6b7ef23a6af08ae646fbd21ace3dbb8d285738fa73fbfdd4aa478636cb515c19390394c95f29989a97c82ad64ab1a5fb58578623bade2cc46674dc9972e408e07d68d1c64bbfca20af80ff5baeae36b6e18c74ae1bb3c3ba4c613339a5141fa9fd58b11974dda8e156cc5990425bf4268ba00984dea24b2025b693fdac0928db82793dab23a9bb455354415d4de169b31d384e8b4bd54b5db91a05cdceeaabddd4737c629f4b8ab570bfbeaa19681dc661ff49aca9714bd9d0368f9155df3019bbef772732ec9e9773b6d95fec1797c51d9a04d042a1d3fc32b23c31871240f6ff9534e322b47d5425e099650f165f1a1ab487dd5c8b6c2ea6351196ada862dc670cbd7cb8cab1554ee606a2ca8efd2b20f3d8bd40579dd7f66718a60ecc1f33bdfd1adc3c57c201b66f28ff64a7f962f7ff0156362eef5fe8f2584af4a4fe64c70f51e9f68236bf242408642788dc2666810a928538e92e457bd96ba55887d54eeb6c8d2d7497f962acadba595a2ede3621f957779c13acd4ada4ef6a1142ef193872ae2b546c1636b11fe7434475f42f86d88f5283f5425f2dc0c08bf7b81af29f6c36364b3e7e69d867d52d6f3bcf1959ae215f141856aca635c4503170bf9fc8610c97819498c3cb8c6a5e0207d7bc4184f5e678035285be0ce501e8f244e95a5918961df6ce0b32969020266274e0e761f32fd63e9cb01d4c09e543c71398fe5d427a48ec870bb48e2eb903d30e4cf24d038157529ef56cfd1a456b7692745b73728d29ff2c89fa7b2c72c0e20dc90b510d2623c6be1e5327ff6987872b441aa69015e9b6234eac6571938617d91fda73f964612266f179d3a099c08345d2e2fb845baf9ad5227154e7647cfbda1606bdaf8439effd388709e51d3ef147e45c7c36a7a432aaccf151752dcb157975383717cdd4b3ebb924cfb63c28599b432f308f41ef060b16d56303359aed1c0617e81a895af9973df92ffb40a643a8b7041f7570ba9e5ec6c5937ac5120c2d8f4cd89efef3466b8bae309c6fe238d6088352d17d2a830ca568e8c0255bf912d97e0f8c76c524ce6deada811201bf8dfd53d08cb0693c7e7b676abe9d9c3c35ac5696cd37fb1a28a9553693702e61355f1da18c519f511b1069215c75fd5efcd07c744789bbb1e208984bb8d38fa536f688cebba8f34a4a2b171683f4a7e6d10c97b1e4b62d6f62525b22d9814c13f98a3d5e00fd8eb0759619501963c25c1b294f568b057bdf114f45c1dfc38e33e4e3e3594297980b031716d7070a754941f04e6924bdca8657c6ff32b0e17d8e60c823c86bbf38e15c77b7b43631e934ad2639f5962745ee9d81317d362340abd603a5b262bd96bce87da3ee8d2046a5c696bbffcb8b119e494682a857d10012ac5a101f0fd9db230ef3828df31eb324f4077a91aa31591ec5de9abdfd32e44c4c960d175a5b2f9f399ffe9a5275583a9f401eb21b6043f7771122c30f8f15e01c7f43a32b8ab9b7ce4bbd1b916b5e6e2f0a506b0661f7b0c9a6c2c37530ba5686dc5bca6aafa2f336bd671b9849ed490c2db8c3537d9ed1226721c4175dfc37f077fc95ff1211dbd9bea59f4f572c529f71fdc2ebf960e2e91ae8cedd5e030ac416cf0ad2fb2ff81f151fb19edc44114e9ec770b420646c8888bee9af7af65769827b34ccb224d1718c7c586d225d0e827bc0d69739d3f766794c1e75fbfda74783a918d37e17ee35e9649da46f9dd2a4d18efb7c8bd409ebb53a7417274280c6e001c0d0a930d8d5f581862b0c2fe41a68d9e74c5f902c7f032ff47d47ea6d4e632a33ac799916b778781eea4139cc4e084aa3edfd2fe78a2cd3a58fa220f347d2cd794d377730453af46ac955e413a679883649add8c274f9cf8f36820a9c19f6919b9d2af5afe5029b74b19257408c823ca847b7b346a52fcbba582dd0ef2c971fa0839c381a01991543883ebbdb67ed0e02ce62e9fa86996e2fdeec9b74e97d1e90e6d36bf900c80bdf38a2376c9f80a54bc8f8a2677dfe61f5b10793b4b66f3773b018b4d54a552551a706f47c9c04aa8b1cbf0513f3254c14b7c6df36fc361252c8b33b3447080aa0bfb11992c540c4cab2003b8851d7d595da71a882249a563416ec29a15fab63d466edcf3784fe9c1172026b4efddca77f014f15219463ac22820ba6a1fa04d7f686003ef24004da67440fbeeb61fc68da14a94f9ab659bb23f457d9be80dd0f0c06338d4b621b25d5106d5ce9e3ffc1aefac77d75f1442c3f5419eb7f59fcb221cecee5 +MD = 2714b6e51ac7b317efdbfce1441dce76e98f3198b495651fa33b2c90479c15b8ae7811b203a739d3e809c2e28a4e1f95 + +Len = 88144 +Msg = 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 +MD = 312e2d967f977a0a1f7dbc9bf1c4c47a94a87954c99a3a6aa3d48ecbc0764597e1efbd988588395d95cc702fb53590be + +Len = 88936 +Msg = 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 +MD = 72bfe4c4e0f6faee65817e0a46e7b720560d2d8753267e398637ac21795d72f57469ea2a0d3f6ca65d948b272d5b5347 + +Len = 89728 +Msg = 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 +MD = b1934f70c974749fe74769d3fc2f2f2e9e315f4299a739e77c7317f787d8d4d48a8513c237773f1a3af055b4e20b1290 + +Len = 90520 +Msg = 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 +MD = 4f7cc474699e94f2576b1286e583a744c94944d276777d4393a5d478de1dc10e619596afc8ffd242f8ff3fbd395e674e + +Len = 91312 +Msg = 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 +MD = d0db3925fd16e5d96a41eaf6afd702d62f52855a84e3eef742edda22b0b1829e0f1f13669454bb06d72fe133a65eba6f + +Len = 92104 +Msg = 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 +MD = 425ad2c8b6755836b4525a5d957e29fe7347d03b615293542485300eb39276c3e2a9c46458964d2b3a27f0d61debaea5 + +Len = 92896 +Msg = 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 +MD = d66832b9f5d269e35ec9dbe48fb70aef640ba53b60ca7bff88eb092a56a5a7181c63d25d567a25c07a9f0ada0caeb21d + +Len = 93688 +Msg = ef4d163db14a90bda8415c8318ef955188538c3e8063b30c92fdbab79720f74a3b5c0bf6bc87c365eeb23c4c835b4b4089e51bca344518bddefd0cc74c4e884733a9865efa684c49c2bb94eea4e5e9b439a8549860fd387e3b097bc47b4de61dde1dcf9df553f5102b44ab9003f33957a1857fd18cf5dbf5b2094dd6ad85d975449e2dda35b184633235ca5b29ef01cec864e39c4194c9cd4ae5cb24685e29f76e15ea3e40ebc2e9dd7639779d3f0ac4b72ec9220542c9ac0c853dd737409d4a636b4cf0a067774b36f0400be74d1cdf74c9798b6367a53bfed2eb169f93ff172b869c18dd8f6b304589273f907fffc7091f3bfee06b23212ab21c0a2abf1505cf5021e07dca6541112a353c1f3f7a257d1757a306b70c06980e1adb5f2ca8bd56b0256e0a7f2f26a2bcb32a1cf456a1d99814a35cb127944fcf2bb0c6427fe6c88deeea0c188f860025e9310f055be2248cbc266ac23e7157db98b1e86a64292ed1c57d09fc4e09344f1f7781dc519166da9553b9521745b81ca9084c0a1d2e8f63f24f8b93345845209d27fae00055a86ae853d0ca7cb97a79a5da7b8c739cf32bbd871945081b3b82aa67007930d7f124fc4e37903374a6d9d652fb562e1c62116e4d3c7a94f91e5c905f1d0fa8bf49f01b6b770e041f4426829556d21655e5fd4ccb7a9a9e9bf7959539d80a31b4b8b68bd217abb9625a47f2ce1366f2f083d7a0265e0defa9cd17021ab9d3935e475e95ac9fce18e4f2246e23bb7c8c944587b2896d3b4fcaa9c91f2c49d09666fdd0812198e1eb4e13a53dbcd57baaea31f5ca1a318d85a6929333970f6a0174e3f49758894bf847c6b2a9c2e9cb1599520a300131695be6905d888394099e2fffb21f7afa7408781233f85d80d4954aadac2b67f5389732ab0f64175e1633405bf360ae73c4e289ff1073b421fdf2a54cc4057406630231ec92107bf7f7894eff9da31d7da35021953162f054b0f351363b044feb50648c5accd4d8e7166802f19a30ee9f7918e8dd7e0d38a15561f773f771212c6985ebfea6f756b4da98043bd04f4a62ae0388dee0bbb59152043e0ce2941152152cf4de08c31ce8aae0fbe52948594daad9a6a03db68fab10a4cf08e3b448e4bb235204db7e530af00990f58c6242e8d562ed2c7f44ed77f709516fe11aed6ac530ab78057122a313dc6a75e0e62ebb986502898caef77e70fa6d49c60f296c9a1ca84070e4b23a7b1e326c0f1c444f59ac90bf4e3cd747e141cb9f79d92473a2aef066021e2a57909a8fe3004cad2b81fd3dd7ab35b25bb3a41278e2c0050645b02cf2a569b383b9172ae19bbe90d77921b1d88de3b3404fecebdde90ef5aeebe803ea400b7544615caa6ec8ba16dca8e095cadb8cff801be1fdd576091bf2fc201e58bb4d9725ed32b8926f8767c1750191b67d79c1a3814af16871fba05ae01e2443fe7742abc661fc56786eaa0e4a4e4ca35af21f2fe8f06e9ec22aab6effabbeb4f0d19d6054b11dc1cbb7084c8e8d6f995c3e41aeb89c1d8051df65b7c28e94b27ba3d1cbffeac4dc51aaa802a887a1a06aa750a75814a5150661f5bc8f914d458634057430d398aef08eb3b802048bc16c7374a33220b066cafa8405cf7a9175facd62e44d35423f91ad50f603ccd5034bebd429ad8ae37983f03a1beb120a4bbdb610a2c0d869971d4da84513a6266fed5799c13119e8581b8c3e8549215eceb8373636ef84b6bf7ab7e22c9a5b260b3bffeaf32694670b7816b9cb536f3507d398fc294401d0be9233273400b47ee11d2af048f5c4079884d6d27670c338fcf7208b022516619c4b089fe3ae76d6f97c22d347047171092513b20d07e60eb70a180b49fc8d0e618f8071c40a6cd5593e2dba79bc624d664517801882a16040f5c8a487302c811645e1c65c7d5d240b4d94cd64856142b5cb28652048bad69da1787c4229bc62c35574c53570106b178f9f3692c834f8009f8f89acc1f917d8f570be054f04586ea68197d6494e5183ee951a8beba4184ea99413445528ccf9d8f790550ace0c21225063c772df7e5951c0a4d558794aa8d17e2c706c0d9c0634571abcc2e026e3b0285291518b9ba19f66f9fa757b3515ff97fbb96e723009f0d685c1df034dbd38538cbb501a5061c2d04482ac72829d1b25a9a6c31d2f09f4bdf9edc9ff29b5a31738cdd55344a3a146abf36425d8480d715dc0d3d6420f28549dc6e89c63d6d7bd7e4f4aff206e240f56d7045de01fbdc3408d0767112274e29ad6a5a2a325bd8c87ca16e68bcb33756eb5f6e2422913637a97c597434ac0b118a566d890ac3dce7bc6a1d02ec0b6be1b16a17ca56ef8983266762d818ff4073eb99407d37240c982c95385b058953384816df3b1f752ab908083f272faf82d349c98f7147facc7c25d94ccbb98b81cd27ec20e0fcb0be4bd6f52aebf92b46b23d6d870fadc6b0e6609cc6ff48a08c12c95089667f2098be1bb4d280f60100833edbe3a2d9063e69456633405356b69bb4fa754607536e823eadb2a0b6af54e8b6bb11c56a37e9974cac1e496a1ca5ea733070da35b7843ac86637a5bba498354d818e01d1ea26e30ef4e474ed70ee617ca918cd8acb9e3a4174fe1a658f6f0b5ba5d4c2908b9aced4d7324d6de1d4a339aab98a671e01132230627944ae2ddd79be7292369aa9cd66a9644d5bee1d2252dbef8b5b1d5157e34f014ce9af791e1021e3eb2495d8610d02170f48041c5120b3375ae748037b1d17570fc501b56fc786a557fb1bab2c6077a6edb2b246d25ba70d739c2c9bff383fd02c67238725084333431a8a9671e950b0631c7741083c4dfe6fda498f46bd0f093d20a352e04aee1a4713712ee40043a029f5d18f757b1e769a321d51f4243b6ebcb1ffad2417edc6de765dd8f55dc7129ccf3f86ac707ef2ad24268889f61b7d257ba6fa62e7d8d573a3af29285a317426194fcb0fb5061ef330e3977abb45c101ee27cf2f4325a2a13be393ff7e3931605450c131c13a4816e8d30348ec30b6cc99f09fdba25acad19fa9bded4234f6d611010d952d920a82ac736066f162db000f9fe10a9dfeca9f5f5feb643ecb20e1cfcf04bc4293d2b0fc5313776362ba26af94373e9e780e74eb74c106dc524c3df1194b19b8b63d4c68e0b0dcdaa6b0bb0a6c06ea1c5d22ccd496b347a360d525258e453fe87fa69f72aaad199fa57b27a095e49f90248431ab2456a91c7d6841cd8c97816a66ab34aa2f8ca05af56616f28034b1a254cf3dcfac0fada01e521e69a296a0b6f1b7a65fddb423650cfde370d98bd2cb64503bb2ac62b7e6ba3f157a4ee6f046b7686f3433d7f57652cf27bc006e7563e9b3c61493e47a58e78bb1800fed02920e19e9a7c05ca8e76d465e3473311c144b566735f0f9476f0cd49d0b643d5a318c58c02b11b6b030c2fff16ac09839550fd499c75235b1a1b086128cca3c59adb8b16d4ea67aae0aea588bdf76f84f9eadaac829161e3b99793ccc84c08ea35ef9905b82dd0cf4ae59ec77f2e4c5e159bb458cdbeb17679ead452573d598a9dde5920558441216b388285055b8a5712eaf4162601fb5a859e35ba7ea87eeefa30313154f69fe96b2fb98af68510b8186000ac356427d8033b1ccee4945e5e736b8bfe5c8bd3707252ab9efbb5c6c94e8341e2a1ee1e381c47f3543209e3213019ce51164cc5fba72ac189bcf294d1ddde1f8212a7c6c2f74c21150f10f4815ac162f02a405dd5323e6112e044621aedf60352329808bebdd10ed924af79c419ecafa33f7084453c16f40310b318eaa555531ca6c8cd73955f226818f05b3394211d34fde22092ed3be322f3489e8a2d8279a6193ffb2aa87dc58994db8016f4e814690ea01a056c349538320adc42ae05dbb931067b2b1db35f064077d1b560c9fc0c17b25be6e289710c7402bb595067e31c962436be1d8958a5c3cc3657014d3de3c31eca7d76c3e168623621193a2ff799f1a1132bd088182fc6e29846fffb3fb7b7ee4e1151694b12a3b0f7c895e581f6ea86f9b95d37076bf0c2ddc8815c6a4f9e2ad1eb9a0319d3e07826af8811e8fc28dad2b1ed1e8e23ea73ef26aff627751ed83a547a1ab273c19495163c3c947354a5855ba7c6131d5bfdb4a8b254dcefdf02719219357ebaed0e2b44d8eded2315f0faffb4b60022ec691695b2fbf3868aaf5ded9edce5700deed28385ad5bd314c219e53b76bbfa45befc37d675d202c7e8e8af31974f5cc83a71196b03464df923ca55658fae6d0d044dd44748e32b3db4f91efcef2447c7fcef4fb17716576b1bf5965a883f43ec43f3b52dff8cc9951b7984246bccf9b23b366d809133ba12b382f141e9d8438c84d522af1f37a377254e27d494b03a30002dbbffda053e97f259ae423be03792cedb62f5324b8289db615032f036d2e952bc8157d9f5aaa2e162158705bfe5a92aedbf28c0302e76449a466609c7888639cb06af1669c8da86866d35cfdc15779ff37f704f4d6fe468e1539967cc25afbd4293301aca5ee8ebab007722a191a435d5ebf4690c0d7c501fbdf390ab720be70970016c81357318ba1473847520d9f47b4bdd95d4cfe5033acd9b0ece3443be09e54c95f41524139cf25180c089bee5cee7525c0e7ec7891ccbba699b36fe4a283a361b8dc5a3e637e23a9beb95fa0fb4067c4420e2ccebabff77277c3fe5944fb6e988b30f9799752b565f5c0c367b16f283d773c39a30d1b0fbd2d816a0a367a28d63cdb9a9323d17cc537cb6192fddf18e9d6fe9d96075286df11684d68056464935458c80bb76ecc5ffb35a4c35ef4cc51d7c1c32847fadf60da0512f3106ea46858250c53b0af368ec6ac27695364b51df03234ca3d688beaddd4555c05dd6acdbeccd1fbbe074dea107b4405599355a6b6ac7d1c56401ec593527ed344551a2bfebca3742e0b74ea6f4f9517fff54074a1bd066f2105fa99a10c1a296a5a550bae711b4d8f203e1849759531a52ee81037c06b533c2ec1cf6d6d919ed6418df5348683f85fea2bec25a9beb2f794cf01ef730668f62ee6ef7ef38fd416cf3771376988052ecda0fe8a489c3c55cb67b23f318210fd9aec625c4a6f49ba47e3f81da691e46a4f4f97fdce983e4e3734a9bd8848dba0d744d07bbeba602f4006025daa2c26a0f37a60e6c84d394f6cd860e0d3d5298e7882a253dcebd7e44c30287df0d13c413ed3e1dbb2259de7d0a5702fc0b19b14f318607b318de177c0d4b305270ba5f995ce834318bc0c96073e4010cb58a0e2eb889368391b3d6852766a799945e408acecddc3686ae5e87505692a5054cb66a655a391701e4c2455979741e41a871cc89159c32dccca4dae9d43e2fc108b1ed802298d53019e3a5eaad20473e3ff949d6e7fd8d55c1a34285878b12b265089d5108dc27e6f9428d2429327e55cde0e7fc6b86afb93563a56e9703b7a00cc26420358c74ea2ce6e64d16322a4cf72e9045cbbf01d0d2ededea2b2e8453a4e72934d13023055bd896ae9ba8b2ec67ec2bf72c30e9623d4800426b93e292d680d4d603509eff2e1e878fe11d80fdc522a05bb962d036217cc8be80ba3a264a934c4ef3754ca04cc29f380f19fb47b8d6d7b997dc1f1524922ba5922bf2d8a72b7be4ca2695af5ecbc8f04e228b91e912b759f1263cc7ee911341c86f746e954d48e0b0ece1f60b42e900c6c298a500dd2a82edc99114288167d84b0d26b0be039b89cc4e983bfc2eeab09e808a49a440187db34c84c47a6a0fb3438d7268c7545c2847d42247d897b248ffe4ca467d4167936c377f9e8b55f21ad778bf5c5b4973054806e8e248862b101077be6434eb00094013e96b0449fa542f54745520e8c968f86d50d3f4013c50fac0cf6a7143cb2a56662af38c4f0eab74acfb1bbe3b44997f90c3e48313cd4fe4486522db53b03dd7bbaafecc6e1665ce05bb76de4acddf04f7aadb9ec1c756f795e9521b229889ea97d0546caefbcb64e91c2e281b4d84af2b6b81ec1510ad5a31c1c3d9b86957b88406bc1317a3255fdf860a43b9aacea9b3709e1616919c36a4573dbc1e0def6909b40069b2f7bbe67061d4d829ce061a171ffac3cc326bb37412886c5b6a9924af40e61886dfd4222215528e749f732ae0e25c9c40dc61f82b596b92776a9d11fc1337c59b44ba3b800a4d0ea3075fff95208e487975c72e5096afd67bf442597a95ba1afa0cb3580fa98cffbeed10c4be4056707fe6e57c6c301cdf6eefd224b12e39bfaa2108a15958d90acb38cf9fe4ac7dbc5b18030b068f7a565845939928477a5cb369013fe580fad7d4d2e4b88ecbcbd314f26903a61b91e241ddcee1674647981ecee55a3b8ab80de0a297384405075eb25b5f8bd53c292c329fca23f695661bf237fe19e4dcdb54f89030478ec2fb043e3d2ccb195a09db3273d1885e9a9f8e378b92a567e02b562384f60cf56a6d6ebf7f19ecfdddfa984a41293826bfbc99f6b4ea264cfd70b8696632b0006526443d096e16062dc40b81f11b5ad66b83e336994ec31c9a7125d21e2d5a381cee2dc1c37370beb22fdbdf6bef17f605be15ff2205a45e21f74367952c3323f58cd151956f23acd403b16c97ed960ff733d6593759f29af9caba2fb17a634b59cad9f867ac5658fc0734315e5d00a8a8abcf4dc090d5588ab233325b5e1138b16eedbb2170324b90040d35a6867c4a80eda8e2a5f374213c7756797c1f66706341b4a4ab04df0cfac2e38059b1337ce7c30821cecaf87c77e0ca0bfa06897dd90bd7baedb08423a0095f1b5d264cc645f39710245d88f2a3b638f1bf5ba2e77994fd05cfbb4a19eca1290d9c2df0b00246feba8df34d0a28c14731b166db34ada3cf8e3a6f58754451e85efc0e47c38684e524f2d66f4c6ec9a0d5ba6e5aeedc02f55c1412d7bf12e24417671078863a75f3583c4c1540de96eae4c1bd479c6d77167747edee80bd1de73fc47cac8284e0d15d519e676fdeefce67ad99cbc7cacbdae8b948c63eadc776defb9a0a3dcd8f273b1b148e60d79ef465684b0ef65ac6ebb6546b86844aab9cfdf3b2bb417e489cfa81f5b29b326903e6d91a37b1852feee9fe9d57d7fc90ffa2960ce616fdd4d8a36a8bfaa95519a4f3e8506e81b3d08e8aa12761c12b3d47d8cbf0b442b4fb843ec01c8f11aa767e927d34ddec4c6f71a02451cbc93f7b1da47aa54d4f098448d16af1995b97473ace800da97cb8d53f336f63be78a01229108b74d8c56639cb6650523f1086567facd924fdb960caa14c6aa56154b6ca1223e7a57d2a32e0b6045a86a9b7de69f63671c1ff2aaa153ef1fd5fdde7ea6b80e574806608d542b0b470d700d8074946732e2bd757ff80c02d10d859b9a2bc1d5f1b4cb8e6b727627d7a8b6cfb69be186bf9acaec8c8d1cc058b59fe5047868e98c5539e4d4057736760eb14a96c8f1427bb8aac066bd10d83562af33642917e9858db3ec4d8998c7a0a3f21697886e1ae5a0ef898524828ae599361f3f9a59368be2dc0d3e7b655bf60cfbac4f5692808c080bb06e3fec88e7ddc700dd68a750fdd914d02d577753d4be208414b01903ed3281cd988ba932ca84c470e4007cd959f4e0dda0aa195fcb1c23368e216c2577d4d4498a846318fc32c0f7e9fe64303eaae27e2eeff5c057cb562c12270655ba4395acbaa684bbfb7c4efe35aed7e60a8f7c3a2e958735f9204bdd574d62253323287faf8e989c56a5c10c7dbe527b4c0720ba364738112ddf76d2b3e11a1460e81f3aef99092a8c63c9ab18995e5081a67256cc5192f2743d59a4be9ea893c206ec56e15270f70b2acb42accc761639e1e3986761225a5aee86bbede26833d504026c3b474a72615f386b90c4143cd34de7077dd260a940576090b8490365286413d343e4103d1d95a39e6b1cc324ec4f1f1c9641d87fd30c89cba42ef4b82aab733491b54ca79e529f5392330d6ef369de50372be43e716264b54820a69d6a4eb2f8ab475a52621a8e13bcb35d8b7722b74ae6ed2e75aa1d73e60abaa39545c255a806f6e3ce1751e26730fa3e0af60e3c551c2211a5eb8259e6625976206bbaddbb2b50636b1c9d5eb69584195dde90c0174d57385fc435693ee57998df4a7cadba8ef043c9f051359a60fd8a04bf3ef4fa00f90cf3b2bb34481ab78622509c582eb8331f5b2112198b19a30a80167d5d85bd840a1245684daa688fb88a1cae6f702db550af2d547cf12631156052e04c430984aa3bdad117ce656eca870d07563755d3822673acc2752d04352612ec53aa4b7777c1018a153c87e11699b05baedcd73a1e61a26fac7f84b8d431d515f62419d8fd525807e87d46632742850fdbe918459fd128217d78c3bb9d23f7e1c658eb35a5502cbee3f92771970229885fd49f7291157376c8197088da6d19d426b135f9fa5b1e33aa38b198d068ec79bd37e36d7c7f22c41eba019d268da951a9b590a286c3aaeaadc46b555de76c48768b6a82bc9ea48de3d2fd84fbf6350ec1ee71dbb53a31685124bb13a9fe17791e37cb5efbf47758aa0ccacce5473b5001c45fe2102f602156c237704f2d8c8016d55c5e950129a8e3c00fd15ce12ac9dbcfc1722203b59a013556d7b7e629f1e2dcb40e225529e32385234eed6481d0c2693cf855578056f2f69fd66ec87e4314c658fa3e60f6bbebc4bb71f141ef09683928d144bb7edcae7e88e8fe34f7f82f1ac18f13a51e87af271ef702f9b0d81fb82bb95a7fff9f8635987bc0cc3585945264497c921fdae004f44abd0c85d15b5eac0d114591143cc4452b60fea58fe705d7b5b3c8692a10e6a1f969eabc69cda52049038cb1df14a31564593cd65b899d926073b898f9c454ce6fb424f315c9142ef99bb60054b04a9fb30407268d1e820ab616d31dce7cc7c03a063b9879e0343e9b6461db1992333a941bfe34a8f86bc74327b8662cacc82dc4daaf3aeaa57dc5aad810c0a23ce58c83eb828f13b9b35e7410c90078d6de7dbccbe0490c8b696aa471334f6302e9fc0f0d247471c4e116e58c958b477d63266e449f4144048f8414ca59d5e0a6b90fa1fb64a337cc8da703d5ae552d130ebe75cf0cb2159348a8784de502bf7acb3dc930c389ca1311755b9663fc7e3a29ac5fd5d92a15da3d4e5b7675443401991cf137b1a6cd4b0518494956ffdf555c8688f38517b92bc5fc1ace7b1902ddbb13c69abf78a5d6d0f6796917cda4f71fc38da280e9741a8b2842c0770f9051a9b895b45d7de8491d96587ff6e48391dbf9da5d6d3ddb18e5597ff6f986512fdd820b2f1c350914437e62e8a4e2efa8198ffbaeaa7352c97d160edc631be9aadef673556c1c8cbadb25254d82373dbc60fc6df0b9387f8ebad49beb444ebe65268c8ae1ddc2e7cf5d112c191f5012414ac5adde19dbb5eb171b939e3d7d43e13cca9e3ed196aea431d8c3d5eccbf1d92f8237b15d0b9a612a61827f8f561e918a2749e6f82645dc01d2990e7b1950d697a8a834f31691835d3cd509ea37a318a7290a54b1e051f94595181d3ab6b3ec0baf5bb36cab3fc4380427c7beb075c91c565c028f53377e6596ddacac329f6c041cded73a280996335de7337d4f0b354215bb9ae10d7acdea6e3617600b87e91967bdfaec1b638be7b09fc7b661d7efc11da578676da07a6c71ddf7c6afe1e5a42655a8e303f217bd92be1efaa7605b01a4a61582f22d06344811b8709e41d44cbf525bbf6019cc3d8ace83aa7e48f99c613a0cb44994f40a679df3de652c576bb920ade1be6f1befef5da04664d66de9c9ddc88bc26cb63736cf14608315c1899a3cf9fa8d56793d66c7ef7ed9bd0a92451dc379fb08ef436c21a4b77672b54ee923da5a4b5476be57a9eb946b4161fe7956a7ff621de1c74e222f43cde7a5041c61c991770d96db58700f27982806a6cd24c08c8600402b736d1e85e7c91341aa7342209ed65c2cdfc6d4b8ceb55b23b714b7b1d5548d08625efd0e52bb729019d4ce983143391b53fad6b89d9df1eddd82f80fde8f1ab6a174353dad235577f102e958ccd8b03f6ba88fc773364d7d971c0be710149bdea74961a445953e51b68a0cf2d00b44017d4c6a35fe12d05b7a3c6de8088962e8ea5b0cc2ba759fb5e0d6b3f6d95f76fa0f42e0a48ca82ce00d5088733652126de10591297a68fc3cf68578c54749cb819848ad93ad8aa5d3b714f62918032cc631e5994913d3d62f6df2b5fea86eb440beba0b83ef2efd8f0de6317a2c11048a43777f92054aa035bdbb15f38b12b3bfe91384d5a009768a8840c4d6e1105c329c47cea4dd41fcc87c5af3545dea6c578de1c4398ebeb34e9cb12acfe5657657b2b310e1fa3e4e50103ee8819f6a208033a1340009933653e1b3cde597a4f5521d65b0e9eaa417751ff3601bddf682f260de4ec99f3b7222cdc5388876335bca32bc591d2d17eaa001f4e48388340606abf58f16be1be943d76205591fb51c18a943640c401e2a595cd000492c871c355b837f47e4c92e2f85168ea7e28ea8d5d7875c37b20b691987012ddd4984582716049a0db1a7935e5d5f6f256d44a47a43f4bc1ff174295916f4d7d05da02c24620559a8935bcb58d6b911321e6b718e85080e259cfceda093479892d76f1ae5a5e258d9083a389777900f5e8467a28af15dccf902fa28888265eac54535a6b38837f1ff9ee75da2b690c41b3dcdb9e84f52730ac1e06c694adc38c835b852465f82cf8cb5d7ccf32a17d9f889021a2ec5828acb68641bcb73172d1c275b9ff6a24f4c10eb7fe91138b1bb6714a965e71a6a8ecb54e9c93781a312417894024d06e9e22cae64447568dad2f75f280f79a486f98b15e5f735fd1c92d8c8060bc1f40f4c208d1961a8411fdb19c702898efa44557b29ed283f5bc0293284062efdd01bc4ad0603b32247ed1e5efacd667f923f2d1c1f63cecc144a3fef3b28ee49418bf61287b7db6be3cf273758ed28c3f2d3dafe54ee7d54cd17618f6be2bc4cbefc5b01a0aa2cfdbb3280237ff63304a2bef99278e19671ccc4186384d83b60bed96dfadf5f3a4024b3a3a3be5d27ba083d0368d9e1bcabb9bcdf3c145dce3db7af995e924b85ebb6cf2c58b2a6894cb9fa82f22663525b1a8e2059a907f73c3feb77ad78039248e7e16482fb46aa453e53f2bebceaea0845a4764ca14b48d4be198377eefbd1f04e96f6e2d6d23d2bebf5dd3f2bfd065be18c6b959bbc259fc8c6474e75a8e76a415c5dc8f3bda479694c9cf3e1fe199e64c25ac506bf3005d65e3d818aaf252f66ae03d5d08d62a62cc4cc6d7d82a67855d2de4b60e8daaf7d5dd0c1bc532db835187379dbb60a4abcfae61c6d0f3f522b3a60a938bd97e504519b8f8959638d2308472593cc0ddf804b74712f1846b45b658c5f0ca1fa5f21b6083b50165926c709d9798733efcd1d52e20c32124f277ce0bbed4b3a74765c17a155cf0e910d77a9b4e6348222abea9dd96e24a1cb23e63869d472eb88a2f9d2f17f44c68db9db5453ec1a3b38e48e98a4f7553b5d225dd920951239b99da19473186fc2b1a45886510ba6c3a51f6fbfef38724347ab1a4f7aafb7a999aee9b890a19e87af6585dc16c568bff9a5148012b1da5e4d46c207d294c1bf8b6f18dbe4bb5f89d975d9b23f89ee84a92e0385b9f41be0c05ddb9eb2e4dee00146d56ae9b6214db24dca9515f996b63602b34d3f6fa57f3388cd80b6004dcfbdde95e21a329247dc65ef113474ffd912ebaa232d85158e29302e3a3687bcb2f38ee0ddf0b1110cba46ada3359c9841e2116eb40ef4ca9213ec6447cedbaa4e54e03cbaf7a23c00de788cc773c0ee95063c678c5e0f632f86260615e98c7506546b0005b98661c8bb6402fa9982615701c52b0895654dcaf2759a41111acb6f7497d14a90ee20d8d3a1b6c8f171aefc57343fa53f7708d8db438745cff71bde37ff36f62849f795a9aa0e9f25ff15e99911fc0ed6b512edb328538080b1c4f700f99794ea1a64a3bff580f9918b34c329e71691d5bffa8e2c8c95adddcb753e822f79b340efe667891c9464eeb69a0d9c1be5dac6f83e1e79f8a41a31b49b091df963bdd73afb759777df7d77f1a42d6229003624ee4c335de5355226fdb50b46ffdc31276c22325dafc88fd7ece1971ea6ec506a12a3513aea9fe2281741a98f9b49999c23e9426e1cc63888d8d0ff241e10a620f5d1ec83716a46af81cf687a644273afd2bf1a2b577ee4056600ba04e703b3c4186689da021afc37ddbccc79e34d3bfd09122e27d8593ed814ef6c53aa3be5ddeadfada125387f5b8ba84a1080c07eee2790e2e627cb956b660b6a72c02fc8d8fd8bcc7b43294c850c0075d0c552a91dcea9fce8ce6c7449c9d348e4d165d93fc1196abaf483f04eef63b43d496a46e65edbc09224a277fdb0d58c4c5664a39cc5f70d02a1dee703962099b8557dc4e26894d284d3140cf1cb80b90bb7a2945a8cb327c4e370ad5da0e59ac4a213cf8c6c63b7334227afc07a7333957db6380375bc4f84320fcfb780214bf497a2b36eeac6c3200a53dcd43e1b908c31061b222190e8c30602baabc45201caaed11ce4644c9add842f10b796e864524a18aa3100df97f3d7dfeaa4dde670b96ff578975953a2ce582fe7e50578138a517451aaa3e6b1b9401dfc2d5d8d0d4353a632f24a7a8f64eeccdee71a391286bf9fce198b44da65a7435bcf93842beae259e88fa83f9543c09c423835aa05fa1cf16be81778869ba5c675e6308a7122a48705ba030178ed75f4ce42f8595236d22fb7a0d9002acda43df71bb50e619d02c4272bdb6e8ec4678cefb1d2a57bdf77812dde506a5b7e2b004bca816e718c9587a93fa1e56b5b2dcb02ef454d075685cc5aeb1e158d1fb2c3e09d364925a3c548287ff6f483342115c465c08e792e8537bb7182902434d3ef51ee441cf2652a9c01673b1a5ac1fa1380bff50845e9ee79dbec3e78d56ff6e91c482b686c332de9e07ffed57697014ae4482338f1fb39f918c5a23e04f39447ac355c99f7a067b82244a2a45b25ef024bb90baf11e4f03c0e984e3e379254919e306840293f309d633fd7057cf11bf0436cfeb90a3989c929ce9317e1be804d4ec3def9756230f01fdbfc77507b008b57ee7d055f5b9f1706f3214997cadfd14a5a111470abe156b4a393887a364549f5b8171285ed88bc02807951ce59abd42d7dbf2f8f9eba37ce212ca75eb542a2a9445d4f2241ef0eb900fbaef9ed7cbc44a939a9369d3429c8cf3862727a912bef3da039990b2aa5a6ff38dfbef8daf04c6701201a39e7933128472869f8a94c33ee90607eabc41748d5b162620e4f268131a6128ef73d1a93a6c99789b2039a13e19e3227a663ba0b1ed5c5978031b5af83a8ff2947ad166cd5400e6629288c0bb13a4d487d62248a554677d4013b2413f78a546dcdd01d292e3b1b93d090a897d7e51045b347dd32f363f78c13b4085ae7baa0b0dc1e95653c2b3d774ad45624b03f09a3ca9d5a9183ced3440a44c8d0eeca62b70501258d6980e2a4fa5c3b4ee4a8b7d735db132270d789708755ec32672a18d4db20342e40eca99151a0ce82ffa2997487799d52652e88b60d7fe8ec0b6a419ec0f447a45ccf00b1033a664d4bbd3cf021f15fddbb245f78ff2b556a25fb6b7948e5e6ac179886a86191b92a537900deb7fae0f10d698c2deed0a849516e04f8f57d87820bd989dc0f3f3d96c13683949bceb748b65e9d695f1867e618329c923933a0e29422a8c06eab4a0effa633c6501559415083e1afc25afadce4d990d996a0d93a5ad451fa026e851f7928afc877472d77567a1765ab21079a41d38043903d76f5da9f23ed5ce16534c83e462f73dcda6752919d2f9bf2e4baa9a0f944a87230916dc38d1ee0bc70eb6767956fc85eb67dbf6ae161f759389a96d25a6161d76cb9bee1fc0330482eafd1352c1df7456847078692b15fcc69d6a3d8223e3ee5a1cb388aff3ece2cf4fe8017689e9319563fc5451f7237b4fedb2b32ff1fa2256642552f15261cc36a541e9ed985fe5306e47356f63901ab7e34c7733faa3e0f30cbaf3ecc6daeb4054ce72c0d48cb7af0b18c1c957a60384e5ff3096242550b77a3a14a8359e6674c45845f627b7d09ba438a06abcab5b415d92866159ca9b2c176d5c2e89f6665b5da609977827577ca0707b5778e84d73b2ce239b80d8e9da4b1a7485a82a137b888267acae2575d86786fa9975a5fea44c7bac4c819861487f0b03b57c82945fabb2073cb3f952396142c439992a995b9361cc7c44522cfe1906b2c7eb45128c30ff904f6eeb1526f66e823fcebe4421ef472934b04e718483d429c2dfbdb48c7d31abedc743e7288ed0dbb1fbaa277dc8f66b7bafd35963233d0fae3f30a3e5fc10ff1fa648efc69132789908376cf786373b5a292a0c2263080c94f3e70622136335ecf3435688675a00fedcaa381791d041d8049cb149aaffca7be22a06c82cf4f45d967c43f678101ce9614eb666518924fd296f71605fe8ee6bf641cb61ae89e579783bdf992c1e74617e6a0b6b2f2c8cd180eb73f0ec8c236c16737c7501ebaf487fc851f8ec4baf6e1b4562ae917f235df15ae080b8b30f872a09428a8de2fbd2946ac29b1e5e76182128e1b8e04c8ea86502df992b245ac31b4b442ab9367120a06b5a0b2c207068765bb010855978bac22d99c2ada9ad29cf81abdcefaeb839891140cf7c5946650326f83ee66e879cf2213583a608b0bf2ff39e299713792539a59d6f78d09f18b0d1e1cb6d556355db26dc647e0a0a8f23e94697172d5bed966e9874864f248766a3923e81d5b5ed6786b6ee9d7763a194aacab0d8c407988ab65a65109c7dbc0be5341f89b5256d7d87eaa86c1765fb687f53fc42a0242efcc30bca7d8051bf88e0eef7efbe5adc0473a11b51b2b6a789b00902be885bb8d3dfd12c35c34896c6d9e94d1ab8fd42e69002cdb50ffeaddd85134ab246543cf950d711a02d0b4bac1b4ca9726bb5a80a27364801f7e6134e459a5c87a0b6c5555e4304268642e621ed40935f9e2b15587f64149b3215e3c33ac5c1a65f2a58cf533e8a2f95956d0f96ed94491b0791b8e2b5b7ed88352523aabd00754b57ff4f75ef2d2323aaea5d5f7a3398a8f024129651bb5dc1ebdf58dea9a15e2be6c1bd0e7f746af82c64f39010f9b40e8ed74ee45fa855a4e11b491eb22cc8c87ea7016415e76cdcc1e4b971d66d06148ab1541407043cfabfe0deb2002a1bebc8b704bfda0f919711719749f517f4848cba0c6e73597a8b2c37ffe1ba23be5a6bfbac69f67342f0c5137562947fe7253bfb5f3ac82e771fd12694f4099d1bde107be2a9909ce5b185d23b02dc2e48be407b33bf310c9a7e56b885331422993e5f3e8fc6d010e4a0f8b7d172f5ab7d1842437246d47a4d6f62f2bae60439a044ff4c9909df59a586c7c91ffa067ef0fbea590217d900f8bc9dde1c55006b98b699adeabae5ff922a9a110de13730072ee0c7cd7a6926012bb18391c8313ee95dd46a68210988115617958471b2482c7bcb95b9b7ac75d18543e90286be3cfc015989fd85747e8cd0e95f6af09c4ec6a854c9b015c974d091fe1958d8d0ed376acf1590304e686a61b677a9a720ca3d7e226d99dde8ac6619871a79068fd8035fdf130868becf13d127e327de6345f8c5de885b5833a3fce389f44f582285c9a9318d4f76ec3aefe8e3adcedd904761452f23e0cbd0e3f8b9aab0c115b27cef106c8a4ca20131666e93dd84ebcd56dfc5be450f81e7f4c4619255b6876646df5c3913e733253ce02ade79335142fcda0f32f6d0c1a15cc6a3eaeb18f4676aff553f2f08737fe4c5e56d8bc25819c0bae9343e0bd225a568495a7bcea5dc70b9c327e697a838b07d67e71a1945772ae81c6c26a8fd9c561119890bc0e2eee1746d98407c1b77297078f52f206386c3ca7081b5908a2ef828dd20a6d6f3c543971c3b469f1465d506e03fd1bff96e12c9ac1cf4a9c10212175bc651f81f88218c98b8ffe9da2a3ea8666c08de4e57a04e9ae4e9dce9412c455c24160eaf6000baa9b67440b7edecbcd424dc65ab68f3bf00829e124c12cf1aa7e2fc00eb746a8917ddab8ef1d666acf011563c58c99585a79d1b31309e81fe06a70bb61bede661a9d6aeb9d10f34de83d97d4b9da30e0957de6622de0dcd593f1b4c1887f2fdaa284985aa9fbddebc54245a7bc21ee4b2d7ec89ce9e8638931be7c60f77ac35cc5ddd364aa30becac2d9bf3b20e61a1e7f1718c1cb8314c1462b382813242192f0d3bcb80251fe718d4e552d9ca95cc126b1275f373379045dc26865801dd2e3c030b4b336c21576712ab7fd93fe1ee9a0e794e3d18c08c8c50e9dc7a2ca5fe5906f4bf4dc13ac201af958098b26e8ee7a24e1fe1eff3c95288a48cd1fbc110efdd9e2eb56c91b24e734a5f006e633461ef38eec740f9ce004afe9c43b55aec6751b2a053b550aeb6267324f8bae96970bce0c5d753fa23fc5f9f16baa4971b272a +MD = b2adaecdced52a7bdd889c2cd0e8162ccb2212d6ecbbcf209fcfe7785ade1f07ff904cf4711db0135b7e47cad876dac5 + +Len = 94480 +Msg = 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 +MD = 4a4765fe4c9b6e121007c34b373bc4fdc7720cf3a4631feba046dd2d69962da52750ecb74afc8a5833182536da727bf2 + +Len = 95272 +Msg = 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 +MD = e5010c8264bebfb39e73e4b25e8882e7e158e3dfb56b7bad0520079666a4581c543184970a7d9cfbd3906679c076c235 + +Len = 96064 +Msg = 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 +MD = df387001cbe2401386ad011b2bb2fdb48b156c3026e6548f7140838ab2383f88bdd44d4bc50fb52406cd9fe8ff7731f3 + +Len = 96856 +Msg = 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 +MD = 339bdcbad66c73c3ac55d2fb66f3c3ef4fdc882b45493d04ff63d87ec93f402468ae062057e330cd196812fa7aff006e + +Len = 97648 +Msg = 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 +MD = 1ea47ea434f0654e4c183c7bbc6880577bc2ddab5037393115d2bca4ac5b0fc9cad4ea2542fbea7186507135249150e8 + +Len = 98440 +Msg = 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 +MD = e7289fdf3a44e9636b76dcd8d94a0e91ca14e655067b498fec91789ee7d3f1d929b31cc8c0da83344e468e126ad415d6 + +Len = 99232 +Msg = 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 +MD = 2fbac29e12a3d83304ac661cb664e1240aaf810a0e13775f7c4319c895168f4f82e3b904562e711bb8e0410e328a7507 + +Len = 100024 +Msg = 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 +MD = 1b759ff129719524de78cdf9bf814d78aba88a51cdd2861ef2b1c7fc3b5e9c73059a5ec8180018d6d4e770b6db1327d5 + +Len = 100816 +Msg = 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 +MD = f9dabb2616b848d02b9dc3c198aa4418b7eae1224c8ae06d17fcd4d767ee429f139a3b86aa4dc0ab76382d8b4c9135fc + +Len = 101608 +Msg = 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 +MD = 8748824393f51c3259221007ffa84d3304f2fef336716733a249106f78b164217fd0dd5202fd2ce0400d456ec121a3b4 + +Len = 102400 +Msg = 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 +MD = d558f26d7e8e293a3911d606e7b7c822a92e28675a8e92389ca27ab0cbe71b2debbf0c360c8d33586c7a374550266db2 + diff --git a/guest-libs/sha2/tests/test_vectors/SHA384ShortMsg.rsp b/guest-libs/sha2/tests/test_vectors/SHA384ShortMsg.rsp new file mode 100644 index 0000000000..15fd9adfc7 --- /dev/null +++ b/guest-libs/sha2/tests/test_vectors/SHA384ShortMsg.rsp @@ -0,0 +1,523 @@ +# CAVS 11.0 +# "SHA-384 ShortMsg" information +# SHA-384 tests are configured for BYTE oriented implementations +# Generated on Tue Mar 15 08:23:39 2011 + +[L = 48] + +Len = 0 +Msg = 00 +MD = 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b + +Len = 8 +Msg = c5 +MD = b52b72da75d0666379e20f9b4a79c33a329a01f06a2fb7865c9062a28c1de860ba432edfd86b4cb1cb8a75b46076e3b1 + +Len = 16 +Msg = 6ece +MD = 53d4773da50d8be4145d8f3a7098ff3691a554a29ae6f652cc7121eb8bc96fd2210e06ae2fa2a36c4b3b3497341e70f0 + +Len = 24 +Msg = 1fa4d5 +MD = e4ca4663dff189541cd026dcc056626419028774666f5b379b99f4887c7237bdbd3bea46d5388be0efc2d4b7989ab2c4 + +Len = 32 +Msg = 50e3853d +MD = 936a3c3991716ba4c413bc03de20f5ce1c63703b3a5bdb6ab558c9ff70d537e46eb4a15d9f2c85e68d8678de5682695e + +Len = 40 +Msg = 4b5fab61e0 +MD = fb390aa5b70b068a54d6d5127df6a6227becc4d6f891fd3f6068b917a883c9b66f318fddb6384d10be8c7af0d3132f03 + +Len = 48 +Msg = dad95a4b4d37 +MD = 3a2b40f453925bc3ce17d640757ee0e899390b4a8d984d0297c1bae6b60b9f2603bf71c323fd171011372335e5702e40 + +Len = 56 +Msg = 121835fe3700b7 +MD = 7bd06a94acba7beb3c5a9b9e8769c3da6691c482d78b1e5c7619b36630eba4e596d11c410a4c87006f4716b6f17bb9a0 + +Len = 64 +Msg = de60275bdafce4b1 +MD = a3d861d866c1362423eb21c6bec8e44b74ce993c55baa2b6640567560ebecdaeda07183dbbbd95e0f522caee5ddbdaf0 + +Len = 72 +Msg = 8d45a55d5ce1f928e6 +MD = de76683575a050e2eb5ef95ee201f82416478a1d14bf3d96d1fd4efd52b1a28fed8dfee1830070001dc102a21f761d20 + +Len = 80 +Msg = 5c7dde9b3894d73cefe1 +MD = f31b22115fa7178e78223e06aae870547ab93c6eb3c3910b0ee16e6106db55935d6c0eb820132a2078ece1067efc81c3 + +Len = 88 +Msg = 967fa34c07e4945a77051a +MD = f8f24d81c4f8f23ecb42d76ed5d2b34c9cbc1f0a97234d1114804b5999759f3131c741d5768cc928163503c5f55f594b + +Len = 96 +Msg = 2209112ee779bf6d95711105 +MD = 09c54bf533a26c7447caa5783db2ec7ef5e55752da7f2a2c4e360982a94ec1ca2cb6a157d34eed28de978b4145e17ebc + +Len = 104 +Msg = 20442e1c3f3c88919c39978b78 +MD = 50bc95b036e0f54d833032a80d45c2ac38b3d29e9c7f72a2eb14781e9241d2a4b8e8dba6ee6f4c9e46a758d5712dbd39 + +Len = 112 +Msg = 4d43702be4f0530319555d7f1a33 +MD = 83c8f0bb762801eb26cc5115abebb657c18ff811de500b32b7a568a220a287e900b6c75224fe7429169fbd534cb588e1 + +Len = 120 +Msg = 5e2a79a544af85f150f7a9d209fd44 +MD = 8051ebc9cabb052cabe07e4023e2140808b77d25b07b96d2e3c22393f71b116c1a1e41bf62e57f73ff67871da7c93cf9 + +Len = 128 +Msg = e1bb967b5d379a4aa39050274d09bd93 +MD = 3b04f96965ad2fbabd4df25d5d8c95589d069c312ee48539090b2d7b495d2446c31eb2b8f8ffb3012bdce065323d9f48 + +Len = 136 +Msg = bb84a014cd17cc232c98ae8b0709917e9d +MD = 85227ae057f2082adf178cae996449100b6a3119e4c415a99e25be6ef20ba8c0eae818d60f71c5c83ff2d4c59aa75263 + +Len = 144 +Msg = c3411a0592f1f4fa698815238997db356418 +MD = 233ac44170d9f452a1a0231622030b15c104ff8ecaa3fccdb9e9e5031fd5b4220186a8edd032849c8b93dc183a5c8627 + +Len = 152 +Msg = e831b739e8eb9f787f63c0bb071ddcc9f44cab +MD = 91722d4b7aecc211bb8a5480c6855f3b71be4647e1dde0380c23afaa03f45c642606a24506e0317bf51506a483de28ac + +Len = 160 +Msg = b8a7bbccde46e85f1223237d9353b78c3b19727b +MD = 28ba69dc05e6e29de91924114d6c9fc7612f6d2a68b07fa001df059bcf98f7aa85389caeb966eaa299c79fe1fd1e40e3 + +Len = 168 +Msg = cf391b8aabec6f81288c8b7b92843be23d2e847574 +MD = 121e5ef697df491a53d7bae121416aa653d759a37db9d0b993031b18a0ef160ed98842a291e1ba2cea8b998bc5eee0b1 + +Len = 176 +Msg = 9d65d88bffed764c286f34894f991600d1a67d622382 +MD = 84b6e0d6a45329daf47a793418ed5dbde01336b4b9468bb69e5da61c42b691e6794e6ed0e8fb1b8e7d4cd3cbaadc520a + +Len = 184 +Msg = bab6ea46fb717f73f0628132a2b96be383774f1e5d8b6d +MD = e969aca1b50e928cad29a0d756457f6de8d7a4e589fd41e53a1e758c3b20f9b81b36bf098a49102fbf869651ca9a98b5 + +Len = 192 +Msg = 8853b00e869764adb527a07b073c85a24e6c208ba47eef4e +MD = 09ad44e85ac190e2d1c3ceb4efbea10ded34d0de961fe4ee268132c48e38660e6cf585bfffb8f7b00b0fad1514312b63 + +Len = 200 +Msg = 71fe1ba5d299495d2a56039c64032ec6263d437f55e3f5bedb +MD = b41a5d3b4af6d4b9c349e0788538e9a0311086894df7b72cf5aaf4091a7e039e4e89cc77a123474e6d1bac438e5e9f88 + +Len = 208 +Msg = 4ebe07d03c93e849b4bbfe9f2d2294bf6ccab457f76d3f99cb64 +MD = beba464d7065185587fad89bfcea9635bf0ab775c3eb8c147b5b2bd8601db6dba0590b50dd1068733f20dc68e004a090 + +Len = 216 +Msg = 918ac0a97ec1632908489e5242ba284bc811aa7197242cf7226fcd +MD = c4baf6397a4c6e26492b63a4aab7dffdd0051d8f51938ac24cfd8dae2f7afed1a4aa2430d7aeb0be2a72b21a6c50198c + +Len = 224 +Msg = 97477f7272d8a89e38e796c533e9f8a8ae4c92ccaa5d907ed26a1a15 +MD = d1ad524ebe908d7c5aff50e6cb780fd3a70e87c914a36b93c4e35f5b2cb03850b122b480ef8587d4a44f22467f4c480c + +Len = 232 +Msg = 718e0cfe1386cb1421b4799b15788b862bf03a8072bb30d02303888032 +MD = 6d8b8a5bc7ea365ea07f11d3b12e95872a9633684752495cc431636caf1b273a35321044af31c974d8575d38711f56c6 + +Len = 240 +Msg = d3b07f0fd5d4cd3188aead8dc8338de42056e2e8487eca51ec37ef2daf27 +MD = adcc2e954c91db3db2d71d0dee1f030e723bee1a23816fe003ac5dc862a0872ef51ff386c18be6ebcaa493f32d1195b9 + +Len = 248 +Msg = 695b9efe1809abd5d44eae957ddf9c2cd3c75fae2f522855712a07c639c0b9 +MD = 3bb95d164d94595a1187f77fc26c280ffbb08e74ec7947aa3e5b38bec7c6f8115c4d880788c2402dbb3e5b94afd130ee + +Len = 256 +Msg = be01e520e69f04174ccf95455b1c81445298264d9adc4958574a52843d95b8ba +MD = c5cf54b8e3105b1c7bf7a43754d915b0947f28b6dc94a019182929b5c848e11441c9e4e90c7449f4c3cd12954f0f5d99 + +Len = 264 +Msg = 98ef7301f957d73d4e821d5873e8a9b5970fbd219d5cf74ec2291b8381181391b4 +MD = b2564bbb159c3aeadbae0e4a4437f7c5111020e9ad0f4eb508147a961ac22a01e1a26df046b14ee5e8a49d9ed22b8cd1 + +Len = 272 +Msg = 873ba7f8b71517ec50297b21cf94cdb7a58abbb8829206f0d3f328ff8a6939ac1d1d +MD = 7405fdd557d2b5d4f65e9e85f508d3791495f1820d37cabfc8dbb74d7b41df8613d995c612d378dd88337e00951d0280 + +Len = 280 +Msg = e3bd4bc3a60cddd26c20aa86364bd44f4a07f3302825ad0ac127881de4eafbccf988cb +MD = 199d5423a0e26438f4cea0081a89e0b6c84ca93f7c3120c8104b51c6edc04e0f6a203bb77d59973a7411a0efbe93a09d + +Len = 288 +Msg = 8716e4b86deff9da2a8ed55baa43582a7586ec9cd38ac3a933156158cd8e5b7887585e91 +MD = 0d2306d9c0a8ce57bc7869b439376c07ce352a41d86ab6cf4a5654cccd5c724fe1b62b2c1101c986222f5264ab3fdd66 + +Len = 296 +Msg = f8a503aaa25ef2cea25e31930c3a90db468cd3a862f4a93aab5de2777e82dc905cb03ee23c +MD = 773ee958fe93dfd1b73af24d27ddce33144a9249d5a671682a56df30d0bbf92b9327130022075185d396de752959304f + +Len = 304 +Msg = 669025175ea917cdd7a71ff4ec0c45bf1246d2a6f031c00b71de701e17939bfe92128b21911e +MD = 9ff6be3f02c7c5d0206f4b944c0843cb68bea8f9b7c8cc0b729503db5005c7cd5cb14e3457d8f5eabf733fca9084f16b + +Len = 312 +Msg = b35fb2262edfa14938a0fba03eb2a25d377974b11f556491a781d0ba2b3c0ff3e42749925fef8b +MD = 835b05a4bf00c2594c3c8c13da6c273a0d9efdea0da72b71b19d326bf5ce968c2e577a7d99fc0f985afd23b46423129d + +Len = 320 +Msg = 9d86b45df8d7dae0cf6b0bc208666ee1163a39e6116d6d240c9dc1c3a3c1db1dd3b1c6680fe9a196 +MD = a84c469c24696f81d7df4ee8cd76aa584f8c9960eaa9908d3e3ebc5eea7d0b50afdded39deb94fd59323a21a6539e93f + +Len = 328 +Msg = 414f5619f6dfd45853bbabd224cc305d77350ad253358910a74f3a4381a9b86680b3c4068c089849c4 +MD = 848d481e3bbf5dd726f625cf6a444d995b36262c9f80d583b77accf1707e3f49bb3dc480a560694d769aa1ce65d69428 + +Len = 336 +Msg = e2658324821ae7b0faa0cdd63ee9efb9fcbe82092d04696feb3da92c82521dfdc98f6b41b3ef365d219a +MD = 3ea5d0799f1a4dcab9149a40ab74bec9c8d76d8e392c1e63e080ddec2ec535f80be9f00927be281ec97ac0c882bb0bbf + +Len = 344 +Msg = 7e80271bb5f2cc7ddae4158658e4e8d06e04a39385da0ecac1cb8e91d68a9bd21ddb7320e79d10e3110758 +MD = fa00bc0359a642dcb3559656094eb2fd4f63bc57f0d34abff26df5c54cc63dbeb4eac75905296e7fb69f871e134083f6 + +Len = 352 +Msg = 43d2828e86f7856b78c66cfa3d602387c290975afd021a8b76af0918069cac35dec45de3cc52edc4ba14432e +MD = 6c9e367e066032ce47ba2575565932002cc786f533c5551656abfe7391e7dcb5f9d9e047adace23d32f8acedfd0cafc5 + +Len = 360 +Msg = 3f49bb645cced7530b8b82e6cf07fbf670f7ef0ba0583d16debafc639bdfbfc99b8417249f7f5a05410aa3a71f +MD = 2b301a14647a67429cc3e7da02c4093a739640f7b47a305251d2855e75e09e60e262b279a073077d1fb6d0f04788f2b8 + +Len = 368 +Msg = 31aac06a59b74bf478617c1637fa6c5593df168b8d58b1e923bf3e3d80e55d7170b16454160ab29ee1f7412ebc05 +MD = ddd245c9b29ceac60506fb6bd6e8037889cb73d6ecc669fd129060a8a8f58971ac572d3ec9b44404f81381d0fd35a649 + +Len = 376 +Msg = c10b2852054d8034e07906c7fce3ce99402321a648bb881f13fb276afc224c6aecc64800cd767ed2429db94b95a9c3 +MD = a44640fb4ce6dfd4a10290a0aecdb453054a9b54f2583e97bb7dc2b005e5fa2b4fda17b1f75902f51c18c0caad35833c + +Len = 384 +Msg = b1eeef324b499f19eba322215fe3ce19c9f000b698d2b2dab7145015046cc86d049ee15ad59dcd1564f30112e06444cb +MD = 38742d18bfa6e918b888d68d1034e61f65dec0759172c2dbf08cf1e132b217eaf4ec29e15db7f4b07e08a70cc5662012 + +Len = 392 +Msg = 790dbba09965c9774dd60a32e010c50d6d518968a220141dc33e7410f2da6c08ad0419bd9864d5327d2c5c44914b2e83f9 +MD = 9174958bc8f4ed4731eced999bea2f63032f52bc8c46bcd903232f3fbc5046f0d6c203d43a078b822fc05101404f2635 + +Len = 400 +Msg = f7b577f1396b23c27eb637e53d3d92460270b001cc612fd3b4d68bcdd09c2d50571ea4350636324cc2428a087e7bd8785f82 +MD = 80afe111e44ad9aff9e39c4cf9e6b4c520072b4550e62b1740160a04f8d530612dc098917a556b44977d0e73df518bee + +Len = 408 +Msg = 7370d9b453936955b9c9d336f4b283237986232de007bf412fb426ff5b4093c80c428c19a12e0b187484dc6d5f4746537fb1ed +MD = 6cd29159820d34e5706dd867e6363758d312660d4daca8d2abf677f234746e97a0a6224eb054066a0b74e18c70965368 + +Len = 416 +Msg = e8620170f0f39328bdf8888148cfd17730f314ea68d8fea02d16d98a3cca61484139d3ee92b748091dc841dda08483f1184025ce +MD = 29c408a6a5045f397b56dfb5292c7c16028c63f068e699b86a891ff8501208ec9398dbaf463c00f39af7b2cbe45bac15 + +Len = 424 +Msg = 75d4216bad77943bfe82be216157843b0da0fd16eeee847153a00b43e707b2ffe2c898168081f0bdb3af58f214cf67b920c385aca1 +MD = 0170357385a20865a8d30c2df39406903ff88c7f70fa1a7a5aaa86711d64046c432a1b139668ae5abed637d1dc4107b7 + +Len = 432 +Msg = 2fa90c2210e3096caed122b74eb9559977120e5d9a97eeb3f99bcba6c19cf8cf791ac6c8a0a94ae49246611dace7f24eb05673a36b3e +MD = 6c2ced3fae94dbd92f4170b63f1ff6fcd8194f60937b22b4f3c95fc9e104b77148f9bc6c16a890de86d9ef1554c96fa0 + +Len = 440 +Msg = a8de55170c6dc0d80de32f508bf49b7046aeea4b975a511b5ea3dc853bfa4b1e0138202d6785f6b3017914a86f824288d586dc0e8bc924 +MD = 2bc3b10c148200f7919b57afe1d7db773ffd235e04fec6897dd94f13ad9c437ef50900a40937f82a39daf2aa2b3dfd68 + +Len = 448 +Msg = accd9d05fb7ef3043470836137554af117440b3ccca7a280285494f90dfaea60dcbf40b230271932cd3875b1d3dca60d38865ff874180efa +MD = b9e02df93e9254180d6a15288d77088b5a5ce517644109b4e2532be315f08dee43491608a1127dcdf69397406e23d231 + +Len = 456 +Msg = 32b835c180cc4006c11a61c65b03c099510e1d4f0a94b63d54bd6bd5a8ab207ab0f4639206564edc3fa6af03280a67744f68106dc51ee35723 +MD = df97a1c5dda6f9dde749f213e429db84f0dcd481d43bf58e6142968d629ecf05b262830a7dac87f67f4383975f3e821d + +Len = 464 +Msg = 9409f9efadbf190b253367629f8f368c9d5ac262e94ab86f3559f9a1fe1a9b44b64e313121b34d43001c430bedc62fc586ea398acd8f17c7cfa2 +MD = e1a69388ee6b6d234108ec29402cd0afd74957d990c7bdb544cf11e8eb2ccd170b6b5a74431be70364d7a31b926ff53c + +Len = 472 +Msg = 289586baf8daced50db14c936529a0a6438eb5da8d3d469172b6a06f4ff3a956d4f9219563ac285cb8e70074cfcc152c02593a97733c36f4a9e97f +MD = 509e996c1e11611c243021b8b78f2ad90c5a9263bbf35910db7c8ec102aa7c518066fff8ce88562fec2cd6dfe04056ae + +Len = 480 +Msg = 156530cd6ed3baf1fd7232c7ff204f3c7d4d106016afa3bdff3786e84843ec556115626fdc84b2e874f1074e4f7d53e08079ee9fd01f80a8be7f20c0 +MD = 7b8a598029ca0ed475a72c0644ac81c63d72fd51305dada07b0ab4a29e47422f59e12643179269ca3d7d10446b372b2c + +Len = 488 +Msg = 30655a6b5a5965db992e7248d24141055e988d726abb8e729dc5c21ffcbaedbc0b1b5fea35b8751f6ec6625517312fff2234014176269b60959723787c +MD = cfaf443e95deeb3cc1910771a2c0692a54b18b3633dc5414e71ae08877f0804818f67f7196c52e26b762dd12bb7a86ca + +Len = 496 +Msg = 345c3c022e20144e135604078762ef5c8a8f038cf1b1d6a91709b59dd068396a9e971ab628f74886e765384a23607c1a1e6e973f8fbb0ff55104c46f5db3 +MD = bfb1d5ee3a0b629058ecc521c706c2f9241c48cda3dcfdba660a2601d832a7a872a2bb840f3b98d21c37e28f9041a5b2 + +Len = 504 +Msg = 0b94a0f43a92408963a59ded01a9338283a6ff1bfbacd9051a0104445c7f041e8037afde3b5a87d22d5a4796144cbc944091d6cc47b5ffd1f997ab1496ca31 +MD = 07a045c9590e9901d0598e604c4649554a823de996fa438cc81a634344eeb98e5f3c0c234ba30e2285a4d7ab568f2610 + +Len = 512 +Msg = 93035d3a13ae1b06dd033e764aca0124961da79c366c6c756bc4bcc11850a3a8d120854f34290fff7c8d6d83531dbdd1e81cc4ed4246e00bd4113ef451334daa +MD = 8d46cc84b6c2deb206aa5c861798798751a26ee74b1daf3a557c41aebd65adc027559f7cd92b255b374c83bd55568b45 + +Len = 520 +Msg = bfb94dfbe0d9a509b78d164a722050054dad91c9a8e260545d037eb450321aac48ed4459fdd8a41572bd6c9c84d18b6ec339247482cc3ee52a1bbd6bd4ae918216 +MD = 13af0be02986ea3176e8c65534ec9f32c23b53c93a73b15c26b9ecbd8a1181ae184a372e9f5e0596cd6606849aeae8e0 + +Len = 528 +Msg = 1c8924a16fa7c602aff5ee961798bd44fe53798bf44c3d6b0d13ef837de07377651c1e94ed236eb79349f86ac31ba151a7e711c5407e65beb63824f6ec39754b58f3 +MD = 5be6482851ddafde582f2804071a702ae39bacb688741b7c37bbae99821ce4d3f47d5b097fd8eefa0ef9248a34f5d3ce + +Len = 536 +Msg = 184215145da49db417e8bdd573d6282de073e674c3dea86b6c78591d4947f5655a9d9eb0e5f4ed046b1d8642da9aefa80448a299504160a1b000c9b4d3c62ab69b3d96 +MD = 8995cd7fc0956e124075440686beece17a6256b282e7988a0c998f790e3995c974383179893477bcc32d1f114129b496 + +Len = 544 +Msg = ca7a63adf41f4da33142910c967706b5c8a093350eb3e6d3aabe69a46a2872f47a39bbe77cdc1160daa450225b0e8e36f506978ce3ac9ae5f75721ef30da46b28f07242c +MD = b89cc12b11e3afa58908580c47b25407abbf584f8e8d4b5631e9f450464c7e53cfd7e9f9d3cf35e587a6f02957ce4c28 + +Len = 552 +Msg = 1da41a0af202b079521deb6109e312c2ade48544d2b498c07e91a102dd4650ce354f3f201b3ecab8e85e21d667959b43d08f4e90fa18dca2ccca8f6ff5e9a902dc8bf5c5da +MD = 5c297e20c307aab7f325939fd4e2883b034fd547f1dd17fb6b97ade8b148e06ebbf3ff60cbf469e4933d5f48f0166cb7 + +Len = 560 +Msg = dece42c8849be40c78b8de6da96c2a8d7e940545b9f3f39aa1ca03ec60a85471aa84d8e29f095874f331b90a4c157da9eb048d2c8fd235399672707366c766f10bb833f02183 +MD = bb509e33e9ffcc4c01233146226ee9364cdac5658132460a76edf617a035b197c86434ee889438581458102618769382 + +Len = 568 +Msg = 952008ebdedd480449bb96a025576c5f617bbb8307958a010767e0d736ffe5a196ea4467d8a5d3ba1f5476ff07b6410ae659dcef520a2c14e3902f8b399a289f41f5fdadb502dd +MD = 9b63d9145bc714a8253dcdb8341b2f5714eb58b9d4b22ce45aae07f51297a3dc9c5b691a8a3cd438dc5bd18be400af21 + +Len = 576 +Msg = 100132c315bfc9c4fb93023f5d3500d7208a68acb4d2c63096232c361a161c4c67c0a74bc3e4d72c11664b1d970321d405401924b3a0f6ce2b1a2899e7caa9a55ce725fc37f55d6a +MD = b6ca04467ed3e623dba36f2e0248cefbe134cf555fdc14731175eaaf08e244ab0b15fca2f173a0ec98feaf359fb84a11 + +Len = 584 +Msg = 99cba4019f5478789e674e08fe5d6ceadd698b0757ca39c605457c22c3d3b8ffb797d2be8f12960f099a5606b908d47207b2636a779948282de3661bb08b1b37ee576590800a492730 +MD = e5378c7c251ae96f0359a30b3134fd77d61d0db68c42a1a2aac293195a596df42f677e6cb98abec90d6722baac63fc86 + +Len = 592 +Msg = bb327a0bcb2574df47080e8c0d8a45ee1c0424ae0414dc0a9b8717d9f27d8ac987c7c9ecbc946073884d1fb96dbdb583aa758186b16fa429dbf15b8d5bb48cca71469e7ce0ad8e7fa14d +MD = 0f75e65ff8494ae28d9a0a2e65959653275fc34b2fa27b9e10faafff07c45addef3b8f25953d5a2e54e31ebe6d429d26 + +Len = 600 +Msg = 7fd9eeb5ff368040d299fd17a943b21d65deb2eccf6128d18a33eb174693538935374c32c333a867821dba08636f20022c2ce01826c7b7e41640ad186f90ed0ac647d47086744867e5c54b +MD = 007251a2a577add048b1edc79d96c7df8fd5b5fa0d7264f122e4cb54c50bc316a8bc5f4f9dfd4469e29e9b030f563a6d + +Len = 608 +Msg = 7ca9e369e82186984d5fc729e111a7e5d8ec19c5d74e13b5ab22e4993b05c88ebba6ba72237389a6e0722e12c96c5d6a54515ab00ad80efb38665a76e831abab0fa5cf020807078441585de5 +MD = 3ee8c4184de9ceaecd0d3aea16271835f3d45c873358c93a515539c38e819414ea63b08d0a109346793d5e0f703125eb + +Len = 616 +Msg = 5b4d945d55dea22e37821ec396476a4bfb617d2f392ad93afe67bcfda9cd9b725bc4ccdf516a83fd71dbff5a22b005fc61c58e471240bd2193ce13539730e63232f70f80308be48dab7266a1dd +MD = df82d242e4cdc2eb40bf3db6a56e1aa0a66e553f1914bedc65c8cc6ad9564b6e85df59f4c443cbe4e0aee05986f7d690 + +Len = 624 +Msg = e865f4a42bbbd0b73fe275b8ab90d3a9fb74ec5070192d38f60efef9564498b9adb716f31d50cf77c20ae4b2e85515307bb8d95fbeb9ad964001ac550dbc60cf213fd8a522edfaf54e5b1b93b2b2 +MD = 091fa9ae2184e2268ef9ef23c7c809efad244536e00aa9e8b3a6c228d90e31da051b40f268a13bd6f62e69c91ae8cd2d + +Len = 632 +Msg = 1d408c7b68e168f41bb46f9b2e9c8b04f968e4080252546814cc1cb2917dd5690886a9600a09c2673aec0329a4daf655508b06fc1646ef3bb3a472191d964db214a96a96fa89576ce4c4f6dbf1d176 +MD = 7e23472c03431925f3b4559d886e8d5d837b3d39b8efe1b7a91e61a13810c4dbc2439634d7c6ababfc66e9b18e6541db + +Len = 640 +Msg = 54ae030a4e27a05c1ea4a12e69c67544af9b4044cf157dc8cebbe8b2d49f9bc0779077603c90c5c55b891d3ac33b87b65e79e1b19695813718191b3bd8b7e42d5583f7cf1e60f84495b8f869f3719969 +MD = cb65f823585773cb8802b6339182f13752a82864c898b445be5a11a969657ac2dc4a3bbeb87ac0abb232a2b124171096 + +Len = 648 +Msg = f73cd386f73d0c6ade05771b33117117c602e52693f05b47e90032eacc39295f9793258fe6512eeab291baa0be222e143295a28e8697e42fa27ec02b44217f32a1edae2f4f35213562ca37b6d6cc5ef72d +MD = f665c4d17a83d65a7ff16bfce279b58558250d76af68b8eb943753e411a57ceb31c1a131e54bcb7672584416e3d5719e + +Len = 656 +Msg = 1d259612e6867e7d788c71d03c5136864ad6d84f24eaf913a34e69333116f812395288d4dcee6665e6d7dabd005ffc6327e3ca305cab78569d1107a115e619fc90110436317925066726774d1da3639c31a6 +MD = 5dcf512e2b93d6ecdf7c3304534554ea79d22392e59bbe90df21e978c9fa3b34ff82e6dcfe8fe2236aa4af4e662e2a9d + +Len = 664 +Msg = da8734414c45fc1d5a75a3cbacadb1bfb523d6fc391f882d0db0eef21f9ffd78b6a1e14cfad09e71b65cf7b05d7e8f2f4bae4e454e16068d65465639c729cfa92738563d37edc9676b7be604ffbc68ec3b6b72 +MD = 8b328a31adf67dc7aeb864a359628410d5814a2f0cc683303f61432ce32177e1f538feead7e5000343916c7042f8b3cd + +Len = 672 +Msg = b228c75903d80fbc6d1cf629ff1d14a92ec4bf0e121fd97bd306ed265efe7a5d5c5d8fc764af98ed6f5978f88d7cd8bcd71cbef6a58261d201de3cb15b3161287e6a104cc2cf882d839f1da0d3f68b426cf08ab9 +MD = fc92ba4eac9a1bf120a7b6c2cc30335b9615b1a98e55d14854ff872966e71040737401c6bc08db5842ceace14cb7e7ea + +Len = 680 +Msg = c90d473a6fd30be9a98bf442a9ad65a697d4629c33cd517dbbed02710fa8ee991360bc8e557b0a0bf0b869e6b0c3a9457607580edec3859f2060c9c0340289d53a5d755918ca54876599045a86a9bcb8163795ea8c +MD = 807582b2520e990cfb74367343268b9148b2519b9e7cd9182edb3db9ae7afebedfe8ca118130e2ef9d31af9081da8222 + +Len = 688 +Msg = 6df8c5c28d1728975a0b766cd7de63bbe7f48c3db3e6fd5a4b8df6e3905cef0351f3d973b4f2a7eed80b0de5b85c877353fb9e930ad2679149ad4cbe69910e68d5500b096c5abdbf27d684fcfcf1a57f02769283d5a0 +MD = 7bda57d21a4434aada6758e282e612a4c0f41b242f9c790804d5bee25b81a821dc6f2a0ba56f1b3704802c9a6e153d85 + +Len = 696 +Msg = 2cfc76f88cb6fb90927b69526ad5f03d6bd335f4f75b52b6a3c21e8f989ab0d03acb1ebe07e68a87c1b5607acf17d976e10ac4a3d30a8561d49a5e7ec720edace9f5f632b4bd63e104f4894a79caad2e1c31c736453485 +MD = e16670ea837c259e418d3c0e1eaad4948c3457e15b1573056e24da25bff5c66b7e95d24c6bc1b8d6c2b812f64adc9553 + +Len = 704 +Msg = 3f05108c2f33d39b3aa9e73efbad4b011b4e9e9fba409b7611e7e03956b2f3e5e0aa86f68c4bfada5f9223a66d574b08f9dd797cdda8f3c32d8e01921711f4870dec676027ecc56fc2010b496e95cfbf071c820f21edf25b +MD = b272bab680f3ab27de72d94df384323f8555f1d17facd2588ac8648def2451f82f9b99c05ead8316fd181a2cfb97483a + +Len = 712 +Msg = 1ffbe1aff0a1e7fa3e68be31a74612a1519b59397e7007ef61fc015f316d55b57be528cebcc2f09a2f22e3c5e4a6ae9612776b17ae87cd763c1a9eabe6846c5bcb347ffc99f10e3b5e64b29a9bd71a5e9b3c01a802715de2a9 +MD = f08bda9d6762607519d53fecb0bffbfd3ff2924854833a759d631e910c42ca86741fc2e290af42e94b94898609b91390 + +Len = 720 +Msg = f755d6b5642378f2847893901d9aa91c54a4b7abb97c5c7184063e8f1e97aa2de4ad7ac927dd3cce770c906921e2d298f67cf9844e61bf104db803b265b86b821c5f4d901067d07b38764e3f6c95fd4f28e3cfe48d8a9694a8f3 +MD = f85e98ea054455242280854e97c4ed399b85ee7bc5c5fc3d62910a76f3a9600c3d904c832b70b58d7d998db8dc978135 + +Len = 728 +Msg = 773577f3a642c4f13b1cb1f4103e9f6b2da86268a52f449cbb174c8349e3c0dc636ce85c373115a337eee26f7b70ba1060a79a1c76fd186399e6a5255db80f83b0be4a34ba876f7908840553ead380f3195507729d067ac2ee8eb4 +MD = cc27869cd7e63695d19082446b068b77dde4e8604f8c0e9ce20a1b71aa9eff1460f32d5a54476275bdee8e7621491f46 + +Len = 736 +Msg = 651589927e17e1aef780690f3100a377f0179b18b31fd5b4418c84038573fc559b496a782beec3dcf6e9faf5aef676e10bbec34b1be5888fda49b91e02890d2524c5b369f8a54175f29dedf8156fff690cf186ec77104a798315033b +MD = da846042fb908eee5f5defd1055ff3e57103708278d379a8681f58bedc6ef89670b9f957c4e0edcaa42dfd8cd49df6ea + +Len = 744 +Msg = 678652600eee42580f73623412e9c011cc02dec4d4cc1b79b27b6f9939695bf2185b2012ab0630f317d2e2de95dd69890e430783e99d7ed121c7c8da9ae70780b5aabf9022d1435cf5ed6da6fc6692c050c2b5f22b24fb1cf9135f9cb2 +MD = 8a6ae41c9bccc16eac4860bd5fa91205a86fbfd09692578f7f36b3c135d96f9e9001c192dbeda975f7375bd43a23ba68 + +Len = 752 +Msg = 416d3fb7b401fa5e78cd96d479d8860df147eef03adf13fce1c61131fb89cc2ebc63289745bd7db9bef14571a55318496572dbe52b9b349ef59f406cecd68909f364325380bb75f3aa62503c84f47a55aa6b9c9b199ebe414409ff3964cd +MD = c5f20542e0c0ac1eb433de6229fe5baccfd4502e2c2275439385efda6374a1d0fc50cd9bba4233d470ad91a3356ea315 + +Len = 760 +Msg = 6f09e876c0b83c9934ffb777f006338c5142a31375e9b21cfea9a7de12998c4ea6708ff1fdf5a8ee6bb67c675ffd8209a10064e2d758a8734eb48f07f7cf3d43b09f1bfdc5d07a52b77079f23cec28bf863bed97c859276df7f7129fce71eb +MD = b3c968f3025f87dbd5cd3d364bf673e62827c35889532431becd87cfbe2cc75b7ef45696d19cd3452d0e7c2b69d09544 + +Len = 768 +Msg = 0dc2b226b3431c69a76addc018fcbda22bd72c8ff01ed6549596798bd950f361c489a09c95cee2dcfd6401208ae6368d6630026b417cc4718ccb8b42e8872937de66895fd09142c42f066bf0ef3ab2b03803a8185fb65fc7148c376ddd4bf58a +MD = aa645a4f8f602411260ace24d381f3f5dff0000c246343eb528e3dd027cd743815737906ac5c74ea83c2755e56b99509 + +Len = 776 +Msg = 8dc71c84c8772753c86ab6afd80e8d1df9b0d7e8d69ebe67fa883a82412c26738c3399cab95573b4d3c4367c85c81852d5a6564c0fc7caaafe16c05e62aa06cc9fa542ceb35c88fb6ab82c29d5dcd530f807d3f1c3bcb3974421101d1aa6ac112d +MD = 12239813097124e6248e7dbec985a6a25f622b1d07295cfcfbaff33b847df7fd94265e439fa535f3becbdb576922ac41 + +Len = 784 +Msg = 3df3edd9fc93be9960b5a632e2847b30b10187c8f83de5b45fcb2e3ed475569a8b2ed0784348f9dacce7b323c6b65071abd8b32d1022b1e12787bd4989d3c5ac329d576ccd7608dd336716532e9b4c7f825826fb2e343623ef85c6270619bf5e3b27 +MD = f36590f5211a9cf84eeb0a3b2e5dc1164e813191cda7cb883f3f4a074605ce6780cf2f1a105658706fbd2829db8a2a58 + +Len = 792 +Msg = ced0ec6500cb891e6433d104ba5b1c1ebca397f3a5eeeaa0f0561729621ea50d4ae7ff1d0827178dccd84e4ca06d9891a90adbb7a9f4994ac947cf6296e71d2f49b826d64b123a7bf86f339fa4679caddbdf19cfed7d0206aa5f527a6b0cc00f52aa2b +MD = c2c2d7d65d0b9108648e3233d15fc4e4cb62ed8fee9cdd18ab44b8486e2100fbe45ddcf74f46c15eb77fb1c893c12202 + +Len = 800 +Msg = afa4a2c4fbaffe838dd149c78ea7851ea9396304b41806a093a90aae59c0c5bdb170cc9a7d22b90cbce52cc1b105108942df20c29ef3a913223b915e7ebc98ef135adefaa0f0a6441ea05920e868ce9d1ff6c8fe4dbec06a4849e5e55ad0627f9e09dfcb +MD = cf6ef91d8567414f5c7f0b1f4ad09a976afc7c8327a382fca90f5a136b19be33100a664390a377f8d8a3015fb882125b + +Len = 808 +Msg = 00f65a485bfd381113d6e79bf9e0d5e518c891988c073ba198ac3a20f25c2c81619723e88a3c0ed3075075fbbafb6a7b61d3bc336a5e6d6f08d166c4861e6a3bdc2e49b2806b567e7e821a55cb674a6cd699f7dc61a7054a8ff3dec73eb667f59644346be2 +MD = 809c6b5d41da7cd10df90b02b193ac7d40cf2e46c139e9dbd208a988da2b25002cdbad1db2ecc1322da20b7d054e5fe6 + +Len = 816 +Msg = b9ce382e1e82a873cc444248a3008c2cf64d18759057abe8f91c9d87f5dc83aa4eca0c51d30829b9a1d2712da1fac31f52942d77c9f20c2bf6d3751028d7d4f0d336d3dc92b27ec368caa4444b3180c1e37e98b58f25e647a9a6361f0b04cf78d17955766168 +MD = 18cd10b3ea907b3770e8eb91c974666e2da2525afe7020b872b3ec6689e5e1cd0059dd4fd49ce44d75dc4c8430c322d6 + +Len = 824 +Msg = 6778d82f3a98eecdfac55ddeebc52476a070094fbd65831801fdd60f837d80d23b90d472c5f4e5ca6273a50f40154ea8fb94013f6310ad18800433a1d379c84bdf799a99e8c7b676fbcd29cc2ed66552297de7a6e565179bb42b70d48299e0925a1d72ca2c792a +MD = 71f08d9333df5cb885fd23d6cbb1db84f9b55908d069df50fa4795cc713a18439bcab8daca078356f5c75a619f2f8782 + +Len = 832 +Msg = ba3a54a77d7c2b8ccec6d53136cd48827c87acdd1cd86ad1f56e862642ea2e1dcb4093f85d60f7bd77160738462e6c3fd3dd9d3a7c5cf7e2a1d60f489f84471902179f21f656ce0fff089278ea14441e04e7af71891622565f44c428044728fcc686212a32a5d809 +MD = 3cc154f0542d8e3cacf9d79f231416816178a7ef2275fb257a48a2f763ffa2e15a33c27b970a416a057925aa0412d268 + +Len = 840 +Msg = 7eec4f4f491b4eeaeb1cdbdb95e9511c2872372bf64a1f61cda1cd8032729c8beafd1edabf78036d80023c814ad8606106cb4e7f33f214c3e69c0f230e885474fd594f7f2444aa581e0c70ebf13073d89063eb81a43c5f608b2fc99fa1bcf5e2bfe62a6802e70c52ce +MD = 2f8c5682a07438043e55f0b7759fe7eea5d9bdfc8b0f89800ebcf777bc05a941ea7f3cac45d4659de0f505d814590b6b + +Len = 848 +Msg = f3715b9e3ddd7862e15ee87aa23f1aaa0580591e55cff3fee9b49b42aa0c0cc8cfb8efa3eb96ffb72ab06b83d7b47b3d22a5772421cfc51214005150edf532af10138ad45758add459908601eccc3703e810002a2e4c6202e98d84281475d55d3de9f3d98809cce1f665 +MD = 04e7d55b0eb4bc3d3a21cfd2941dbb4dc44706588967186b40da54902aeea97b262c97f75e37ebe3cd60a804e7b9feca + +Len = 856 +Msg = dfd7d792e162bf7a889109550a0fc4c415232af0c0d72dcbc2595299e1a1c2aeae549f7970e994c15e0ab02f113d740d38c32a4d8ec079cd099d37d954ab7ef2800902cdf7c7a19fb14b3c98aaf4c6ad93fe9a9bc7a61229828e55ad4d6270d1bdbca9975d450f9be91e56 +MD = 08e5ef57d0c2aa23edfc75cfae39e6bc1a43b5db08b2e27bc9823114edf760367db9cf3cd9c3779755f6d39e219b7079 + +Len = 864 +Msg = ffbc7c47f52e69f5c667f4ed578b46ff4592048f789081f3fb39321d0aa4627a6d4f261905649410a53a301c231fa787ae55c04f615a8f84196cecf2844d23007b44edd892649fc8ed10a2e855bf23fe8afd0b9edbb33296f5a7cf89f94634d9d1a2b8cac3b7f4e546f2329b +MD = be10c7baf94608408a0accfbc8ce95e159d08d8ca75dd6c273f935947a7ec3463e10a58d3ceaa0b2198b0887a3a24a29 + +Len = 872 +Msg = a39f202d866e8e96765fbb53b6772537dec043322f4a7475247036d7495c987850cef2a46218d3fab36e3bcd595c0aca5e98b9db14fa484ca8c9772dfa3839f7ac3066727a50b0d5c933d82f82f1220720e8063f08bc283f199c8a4f85c70043df4fe55e751d0d71df36fa43d8 +MD = 3b2664ccb555a1b1f3ec996860146ea75ef7f3bd62028a19c26f63339399f4275a07f3c064d34766ebe8e4dd532f6629 + +Len = 880 +Msg = b2c8261853e2218dfa135cb5387810352b8962e94e9fdc8695b41e7dba6ad122d14fdd0d2360dcc039ccce8b37fa0ead6ccc85bc26261d47cbaa78b925c6e380fef1856fed31dc616fe16b2039b1ac85cdee4ce04c0497998b41321868db08e35f358606585e0bb8c3da9a3be7a6 +MD = 45b286f49fd05c45c921b7bfdbe2cb024441c372e07394dcccae0de834cd541f13a79dbb3e5078896e88438542bd2f12 + +Len = 888 +Msg = a04f390a9cc2effad05db80d9076a8d4b6cc8bba97b27b423670b290b8e69c2b187230011c1481ac88d090f39154659494db5e410851c6e8b2b8a93717cae76037e0881978124fe7e1a0929d8891491f4e99646cc94062dc82411fa66130eda46560e75b98048236439465125e737b +MD = e7089d72945cef851e689b4409cfb63d135f0b5cdfb0dac6c3a292dd70371ab4b79da1997d7992906ac7213502662920 + +Len = 896 +Msg = f419494c3c6d0727b3395a483a2167182a7252f4fd099c2d4b71b053f94bb8b3adf3b51e8460cfec084ce9415c95798fbae4975c208c544645b54c44d2b97f2ecfce5c805be61f5ba1d35dcc07afdd51a87baa990506668cf710e18be9b0ebf943f366fa29c69f7a6616de72a3353b66 +MD = aead8688c58c6ba4e9cadb4756b465dce0fb06f1cfaa478197f2ea89414e47e9572034adfed160703c79b82b3fd7ab78 + +Len = 904 +Msg = aaf7584d53006cbf2d2040e51b7feebd2bbf1e9f6d817cd8062a6a9680e7f10464eefeb50b07cb46b14b9b3fcb2caa3b9ab664490115d5919456613bf172b58c5388fd52646a5783535b88212717ef605314b70b8a085024d4ab1fcbe2be74609e4cbdec0730fabd3cd77151d647a3767b +MD = e6e79d8c61d0ea9fc70dd4dec1fa432849c3396e717b170badbd87a4c7974efc590ab8c1183a6232beff14534f004b02 + +Len = 912 +Msg = a467f77369730201f2812204fd63ad0d2757be580d937dfeb221a06b21ed3213531d936152a0c1f09f0ad5fed19fd11e80ad982c61203e86b2508279d91d99fa483e2e97a3d6a6ad2548a8da404dddb58344f4bdc1c9ea907088885e4f532d9c4c73cdfda43c3a9e4ce5a2809096593cfac1 +MD = 5a7508c2cc096bf65a4d4d337aea22008edb9a3bae869f94e09fb526a52c3368e9b28576fb950f078b7e43b5562120e6 + +Len = 920 +Msg = 01abc90e9180fc9bb8ea67a405073ed6848bf33048076566476c55836bcb19d3e55e9400c5cc657bc7a95f1d703c390f5a8687e7cd7fe9138ea3837bfcadad6258a3eb8d65121fa8319bfde532aec0e694961bddd2b673f284124be5781100f40381b6ff99db92ea9cc82a4372e53924dac398 +MD = 96b209d7cb2c2033b38350744767fa5c253e1bfdb99fe8418bff83804df02248140fe3b77b0bfd4a79b51f70405a434b + +Len = 928 +Msg = b555d99056362bfc2bac2a1bbb71ba112d644e50b82b015e5a1ce3d9cd5e90b8b74b08d32119baa62abae251fc0015e400051ada4ecafce3681e5de727c20d47f5cadc663d46ac682022ca396a4b7ed1c413e0b72bd7eec4a0dfdc2a2185abb5d99afd50940528ca75ad89daeb9a1b61e15747f0 +MD = abd39f79d72c6cd2e8e130f3603032fe3cef4177c3563930096df1f10b87e79cd4e2059cf1b9f8252184bb26f659a5da + +Len = 936 +Msg = 14fb01ae9d6015ecb3e56d6ecdfa4bc0533186adf8457f5e4a5c57c687895f3db395d06ae7ffbd67ec41452009550dfc1878eec0df2eeab09e8665f7e59f9148a86b2bc695b36521a55b2302f2e869aac83f14d6feafc9e587322c3c44f052ea1c0578884f84f56307bc6dde31ba48118a0f62b6fd +MD = fc9b9a95a8ce1c157720cb63101a7594df24f4cc74baf735b0ccf6abb925478ad507cd048d30cde1c788806f43ed3a81 + +Len = 944 +Msg = 11ae0cbfee7bb3df90ce585f09b9cf8ff5bea69a68eeb6c22553f8ed118c9a61e7b752cc2c94f38766e63e1b891dfa05b23347b617d42fde3ec17eea6e76d3cb640bf8fa46586fb9dd5c4d9bfee04c4649571b781709f848ad7081afb6e2c746f071a551251050fd5df72ee65248ecdc24f2cbe74ed5 +MD = 3214b5feec925059149fa852e3ae285a6eb377df926504e2f824572a3aebd2050a20144e7bede7e7fe238ee83e69f72c + +Len = 952 +Msg = a5c4a47a04f4714269d5d922ba4694060aa2df49193720c819fac93bb8787ec55a107ac9a6602f0045fd2cc8e66744bf863ced91eeabe60e7d2c1d80276ecf3bbe91f1757096cf589214f3569c2c48bd74be7f8befddb28395814780a47c180a58b0d0276a7e9873d682f473e27de7275c925ede23b6cc +MD = 6bd9e1303579d815f58e8c6c9855850133251778a632f7b312c4b3163b29b5ef6cb9511a08a31a237d9a7604afbfa056 + +Len = 960 +Msg = 75264774af69ec7ee3125e205bd6d1cb8fdb22f7ea6dbe72d1f2c0f7e2205902796d75e379c79b11498615c21c9f52b8761a885eecc69d132b2b48c63bc074c3055ee5cc13f51d6c987e8188b030b837e8f754d40122b451f15b28cd2bdd576920e1de5806593a36d8e1e89b9ef3caefee5acd80b3e9c9d1 +MD = ffa9e4e856d06227c1ccb959be558309cc10633173f4b66ceb382923b52b9150acfb08a7393500477a6ee4425a827e76 + +Len = 968 +Msg = 791a36d748695e62db5003a8ad367df1f051c1ac6a21d711823e8e069b546e3fa06ceeaae06de70a1de249e1dffd0d940edc6acac00c4c15504c02d4b0933658005423455f00023b01cdc5b681b6083379c24595518a47c654f5e1a10947df10c05a3d716b2a973faf98e1ee3b675816598bb8d4c2a3b06eb7 +MD = f8d33369680524ed6c6a716d4c502de3eac891f340f40e82e37501be1a90fb61d26e5daafe92bc6ef5ec0ae431168842 + +Len = 976 +Msg = 74cd86bbed14d895301d8a54b2956b1c5cd1451eebab620b978d4ecef2cbdf7a14367381f5ee79281a773337740fb9f5853f4253c4b19f684341081d8f561b2ad773224151099588da90e04dddd565f67596c536d64c5b87e9480ad43601397507ad1b61ca0e349fb88f19feb48f770676fd562ee8259f50d0c9 +MD = 73ee8d29c30821dcdfa4441639f037fb6ba3a9ca596dc43428043785756608f6207d80b7f78e573174fb9dfd42f0b8cd + +Len = 984 +Msg = 46612e1a4d016c41700a3b5ccb38323353bd8da5b9942c9c9212df40b4bee06be362a15dad62c8b2924d789168b2d325fe35bd5100e1e29f1ac0fa7a60a94c9eee5a70cccbc75ac214b1946a5679cb523b378d5c690751b7a7a3b80d413712feae7024ce71d6295a3d5d16515c3622a052eb862ebdab81ca7fe3a0 +MD = cac13a3784225be03d526f9abc1eb50a762e72c0e01172a15d578801089e5c9f26e53cc00ff755909453e2964d7df838 + +Len = 992 +Msg = 1a857c1f105d068ceab0b1e12494890ec196362a48b0200a0d75d712b18fb14bec6bb5b68a33b7e0b4fdc5b77142c29c6d9151b9f884f59551f476e5256986a653d4a468f28141ed954721f2cd02054df0438738194545ed70234173ac4988b7d62812de4f2feada14f68e3b41bc9948d4139f4fb4da5939f26c0261 +MD = b75d92b5cd3772846f7b68064a3567ae43e5010099f2b649f35087e7592aeec176646fc8c2629288944261cd35b5fcba + +Len = 1000 +Msg = 9d36818d0c5a008be7904d1917aa3eccb5ef4f38cecb8c4e63c4b2e9b4b091a3bf25b4ed0332445f894c2a4c258b749afa17fad03cdd41713a869f899ba9a085e73fa9474a58db7a950d3a2386b60f79495d8bf73e72acaffdbf65e1989ff9cc206ba8c46a368d8512bac7c7c191d713aca949d45df297b1b6594a1a33 +MD = a88da844579f3e3725d00daa8e1e287da4bfbb2d931ebe8d3b16021154be503341d6371d382ada744f86f5bbb56cdcfa + +Len = 1008 +Msg = 4ae50ed626ee60dc5ea556e3ce0d3c18b9e6225b5620814e8b9621acf8f939dd370ad9c7620d85e6d67a229f37f517d1b580acae8df0b5c9d29d756f6d5ebd3b63b554e556469b5b4f8e7113bad1559fb254ca827fcd00425d18b0be7f2b48c2544c48d90982ec624f490be65e893fa93ac9467f35a0a8e1b56d9a403748 +MD = f8cd943f429333c7c8d30a8576827f92c92ae18e0dbcae770601b79687bccf8c23e9e589dfeb45c3b9bcafdd545e45e7 + +Len = 1016 +Msg = dbed7612448d46cbe0a384d1c93233f02ffd1c984ba765299518656d3723b766c1658d4b1e7047cdc729459e366ef9349efc40cbd990f2a9a24db7a5045e1dea12dce8f9d9f2aaed933f93031e7b8959ac5e7bf6bbbdf30b48f7eb783f8fe292371a2f245c5c94b4acae160767a20ce7c0ea7723d97691d8eedda9efd1fe2d +MD = fb531a1ed181c732311e56f4b56ed91dcacc0dd6bf1eb4a44be6f87dd7cb1ef9dfb0310f4a79eaaa3f32bf3914d8624e + +Len = 1024 +Msg = 3bf52cc5ee86b9a0190f390a5c0366a560b557000dbe5115fd9ee11630a62769011575f15881198f227876e8fe685a6939bc8b89fd48a34ec5e71e131462b2886794dffa68ccc6d564733e67ffef25e627c6f4b5460796e3bce67bf58ca6e8e555bc916a8531697ac948b90dc8616f25101db90b50c3d3dbc9e21e42ff387187 +MD = 12b6cb35eda92ee37356ddee77781a17b3d90e563824a984faffc6fdd1693bd7626039635563cfc3b9a2b00f9c65eefd + diff --git a/guest-libs/sha2/tests/test_vectors/SHA512LongMsg.rsp b/guest-libs/sha2/tests/test_vectors/SHA512LongMsg.rsp new file mode 100644 index 0000000000..c601ed159c --- /dev/null +++ b/guest-libs/sha2/tests/test_vectors/SHA512LongMsg.rsp @@ -0,0 +1,519 @@ +# CAVS 11.0 +# "SHA-512 LongMsg" information +# SHA-512 tests are configured for BYTE oriented implementations +# Generated on Tue Mar 15 08:23:50 2011 + +[L = 64] + +Len = 1816 +Msg = 4f05600950664d5190a2ebc29c9edb89c20079a4d3e6bc3b27d75e34e2fa3d02768502bd69790078598d5fcf3d6779bfed1284bbe5ad72fb456015181d9587d6e864c940564eaafb4f2fead4346ea09b6877d9340f6b82eb1515880872213da3ad88feba9f4f13817a71d6f90a1a17c43a15c038d988b5b29edffe2d6a062813cedbe852cde302b3e33b696846d2a8e36bd680efcc6cd3f9e9a4c1ae8cac10cc5244d131677140399176ed46700019a004a163806f7fa467fc4e17b4617bbd7641aaff7ff56396ba8c08a8be100b33a20b5daf134a2aefa5e1c3496770dcf6baa4f7bb +MD = a9db490c708cc72548d78635aa7da79bb253f945d710e5cb677a474efc7c65a2aab45bc7ca1113c8ce0f3c32e1399de9c459535e8816521ab714b2a6cd200525 + +Len = 2608 +Msg = d5e378ae9fc2648f4a13bbec4b0935afb4f822f5fe0d5063053d2fbd547b33b4a32e7a009ee2afafe83d2ebd603568e4a38189b5d24d59e8953260f15f654ed4f42f9a39299d68c3eb78b09e83779d5718b433f1765d35350eac46493d194e84d1ce1f81c95b59725cab8ab73d369ab01e7967cf73a3acf1789227ee75fdfb6e40f353ff0484486542be053115db2896bab86c774f8985c4dbcc4c078f7b1c3a4c867cdc6580fe44a598673494cc0fb1f6598b1295768a584041fdbd14fa7b90fa6fe33f71b743b68e23f8e7407217aad9440cc8cad28152aedb82388be2de165496d051b292de6303460273a43508296b6237c07804335d2e81229f7c9a0e7761e38a3aaf7799f40fe9cb00457ea9d5b59953232676681fc71b261a6f8cd359293f5b21f0cf3a11b7f49cb5adb3c357bed2aa185d8fe8408192d6d3ed1ff465b590892efe03 +MD = a70c75b9b1f0ac2ed2c2797763ac9a6601d95f46889b00fc3ddae4d0ac6923750a108d79eb764e77ac07b7cb5c01cb4b3747dcf69ba3b35c51fb995da2632e70 + +Len = 3400 +Msg = 4f7a5618870945b89f194e31b1aa802c5350326dc691df58708e34b48ce666b021d7c92330a69f1832412d8ac224156c9679dfedb383d9f9e13c21035d3d0002cfdf79b97ba0223cbbc833b0ad4cdd5229f2ddbbf6b650623d6cc9623da8a17d41db8e61cfbe772b23f4872adceb81e5f403535ff5f2ed996a67535994edf12a5f1230a494c946ed500e5280b5c8a82ddff369611afe58a85272e870cbd59a1012ce8509338a368b2c5dbb3ba2adfb33d30c494acca43896dbd8b030482841374055b81812c6f00c9e2bebe2096021feb69418a272aa356cefdfd22074ae91a8d2f1ef599a481c788dbe0afd54aac39672d401ef76d9f83175d177c9b72e2f6ab1e7525533d761d8e3603f14ea538904ed142abb3ff929ed55f4c6b17a72c685c3820b93463a67338756b2b033231a4f119cbb8d35d270a97791e8622340fc02f2093f9b393ad79161eb8c5897e21f7fc4b3ddeec02b736cc3ef04641c6179e825c319f6769f59fa5966f5957e573f9df0a2b76548cedd3e2158433dcb9de63f44f9be2b63319477570e14ee504b23b07cb2737a358154277912cd779abbeb1036f459c26ab7310f43 +MD = 713d5c26de17e1440a36aab93f7cd8111cd62fd8bea5099b2b6bf93e470e1eaeab8b925c646e9e67ce01b03b33d2b500b9400e59f0ecdfb00dd7ddcd230cc837 + +Len = 4192 +Msg = 5e0e84419c02ddda289aa126bdb40a060464aa58b88bad2708ab5f1e3df9ee439cb470e28eb627c6fe4904af033b6b01bf3536ba8748fca643c993d6185fd34e455a9dfe4b461cf451c04bcfc689b87748d9870bc5f6b91be004af18961fe90821a7147e1cdb44cae9aa7e6d50c579d068f9a535bbbc6deda506b9cbfd62b8daf744dc4b499d26b18dada371e7183773e73d991eb1c39f845b74bcd9964fc72a91d8fd4b1ab34a120771c4c2d4aa78ca8d4c6ab0ee32d748caf9bd29a90f9e61b50c8068d74638531d9fe84a5fa2c73c22cf20d1bc329ea1b93bc6a37ec9c5e82c886c89c77d79de98df18f0cf29a9316d6dc46b61eb7af7f1e2de2f5ca6c525bef3c996338194193fd85b9c6e66a81137cf5d652684f6b23b970eb58dce248232f6a0766379116edc33b93682824b45489cf3a75326973a5d025d1d57686d665238f8139f8e794435973aa754a41a33687d8f1930f8e7f71fcad34f039c2539e462d9542fe8520214ade7d52cf59e445f1a37a305236d524b977834d894d662b11b4b215aae27123f1dc7a9529d5ee0f41af62d19ceb1b1a71355b22075074b810c57626a097ddb7e8ee20b0dc3e370f126d19fb5223c7dfde471b2216a415b1cdc04ffa520dec59ba941e4a68fb35a1ce5d2e12147951f13b2d41d25980bfa49345be1541cd1385c15eb1a652a58083d0000dba56444fdb12687d9722aed90d2bc62eebe24df9c8b7ae897 +MD = d4a3b38f18b048e61686c2159c666469ce9a9400632fd40ac1d6ed33162b921b95ac26238af9fa00a4314a6046e1733fd4fadc6033f3ac33d2b8c202afa5f02f + +Len = 4984 +Msg = f516561edc530bf7aa1a63307d62812fb560dd5da66297298ffb0c4fd060a85a5712fb675cbd0e2d4e60f73a0dafab7f59b6140f8bbe63248274a863e1489f617814cd65fffecc700a9fe47a3965dbffaf350dbac655bfb1018ab071437df19b3e63f79f2dddefc8c61d51796a4bb8b6a027f1e5c1ef51d6f5834c025dc7441092499f9e4f241c3d6a2467bd092aebac12d2e719e354c49d44a8a69d99ee41c95d0ceee8cb99fdd8defa4dd07cca1be9ee8018dd944bbe0ed741e3ca5eb98fcd85f50b070b053aa00ae72c3a2df3f1761d77abb93c9ee73096962e1115f1d624f44c1e83752f7b9ed7352c81826d145a86ffc9354313e90b69eeadfb245ec0d7905951e273e167d82b2a742fe5ff2e9d10629ada127369a73993880ff4c8f3ed4363caae6ce1a658f0102dcbbd73e448a5e6452f0f85120deccbe8d5edf7176ef3b4b16ec8f8e1260c2d7ede728fe0612cd5f3bda31389446cdff5d677b3d5638a922fabeeeec04869ca90ef6c1ccaf38c75cb0a36e379549f17d699fbc3d5d3ef466cec488beac8ed2e8b8612e14903af0ff6a031bf88466fbab4a7dff0bec60a188fb93d9708ad82a3962ccea8069b7cea9b07fa6d5e21c312b6868d023844c34fc09a35d9c1000f6fd9670737a9c2db50e3c5fbb5a4ed826505c06bc1ed5602352918981abec87bdb7dc22657d981b487f6649b6102b296fcc8dde3f48203af10efbacf22a60db02faac291d03edfefd8fb6c41371f79e61f28635c65a254b2293d0940b922d895b387f1b16a81e4758b1a635701a4495a154ddc3edaf34ff3c8398c54a7da3012af3dd6eeed4a982ce87dd34485382bda285ecff01c1dfe5b350bcb73b3751d0f6af3f9b12040 +MD = 1288010a5092c66dc87771687ca6227139ce5dcb48a79dbcacb22bd365f661fb1229493c662881b86bf1eca2071095bde47c96b992ee16d3e3277662cdbf960c + +Len = 5776 +Msg = bc4b7d3a380be067ed7a2a02f6137cf2aaa6f5332aa0dd34368d237e45db0a97d4e11f26fe206e574dc8f581d07e59076d5cd87c79397f0a862b9d147c4b771aecb83ddda0df3dc477f9577f70d4b1ea04d7ac34b9411640f4b1a14b0eeb93d0abd9c0a847d0b57612153742fea0ec64161f57a4113e0a9f2726166d2343c780ba4b8ecf1b7c3f34c7257c13a367713d4b3dc314aabac2efc892e6c0e2dc79f4c016919a436a41c83e2f103a86b3aa3d4d38d6cbab3ca8f87efef88d743d13f26643af51e82225f81e3edaffd10bfe2bc1187a133d4d2381f271341b01eefb4354d9d23b312d518d0f57c2aaa9f8d5d152e6963288749b54cbf382b4b0789baf31e0e1a147122f4fbb84b082380198f5a6a91171b3397837b28cca9ea96259fda561c4cb51592505c7cc8cd0a6aead606569d518e72423f34f45f42215349ff75a626301788b9d79de383edc1b877dda382ec96f4bbe02504925e8881c77d463f5eea68be42ffe71a6ceafeebe15702bc701d5be088e7e1549348f18e5b25f0a210a75b0bccdb0b6c798c54eb7dfef1ab9e9e14c451c000cf67bcf1a996daab484c0b8ba29ed1b10ea9e69442f6d6070b6efd5622bf1eefbf90191d55f311c28c61757ef5218a746b7e784174e482cf5681a9948e294b1abf9cfbe9260841d3090183a9860d5bc22d57bfc103bf7bc7174721646918db2e49feb3c99c3f115928ac949fc7aadc26aed62bb771f0277ac85ff32a46065586d935ff532b1fd6c175b346d65c92721e7a6a4a79421f2c46d41cad6a978a30a107c33cfa552328b87ab618c1974cb4161a94aaaae6a4e0d7e50daeb9e01cf3293026db439cd17d8aa24568f61a4218aa09d5cab0e219eb9a55b3757cb227237bfce178b374b34bc486c1d5f8581b2656b2be091fd6f6b30ab0aea04780413815c88383ce7f312a0282bbee2cd3205388bfbe046c17c3bd95804fad8edcf3a7832d8d9ae91ee38ea130a3f0281e0a26cc9b463b1a26f991e73f26f +MD = 34b4cf4ed7281ecb07f381e9fc3805072238e21ea0d1d2c5ec0ad3b23ea700247b8e9535de9fac6783f955166c4ca9a90f4caa47056fa9f313be75daf27ec8d2 + +Len = 6568 +Msg = edba7d6312144e90ec9eaace7576045a46e553dcb8ee5a9849272de841c8f1ea9502e3760b929c539f9593aa259ee3ba31064ece3483826ce7fc9cd0ed9ceb99b426f6c19c88c0d25bb24a57a0a85a91f6d67b6ceba545b1724bde7d87e7c1f211cdbe2c0c1e4277e79dd9bf2bbdf1485effe19f277a2ad0b3bbfcd956d0fc5f76a044a0a57eaba90dfd47c8110531453126884d2e2db92f6ff5fdcba4802346a9468f03adcd83cf937a9d5c98a7a1f137f6795f4ae47a3771a1e93ab71fbe117368a73f6d36505342bde2620acccab43714bbbec0c7f6508066c910d9d455279cae953a2ddf9c9ce26e1ec2ad9b32f7fb2b5650db00b4e363eca4344fc771f0ecbf60de35f0ee123b355a64ca3d632049e153ffe2b43c56e3dc828e642199d42b441011cc92cf1d14b89d30a8d9e599eadeb9b21c0e1713c8de6b065f0a563b20e4aebd3becc62537a2ef0e91983ec8a6cb9051d233cc80da99688487a92f8d944841c9cb285b926a9958e6cba2f8174450e1c34d4ee307e0b680f02627ac324f18d11dc16b16cc7645e1a09f1e9aed8e14b3f2d285e50fa4dcbc3282ab559319fb67a168e0803b235091245534adb14ac00ec5ac0059ffecb42232e35eb316ba99093d07ac2048385f715a350eb8cd41fbfa2421e8c74181e6bdd993684d24f99bc2d9e5fa7e597f1d872a87d143a83b6e80f77b65b73c2b19920dd9f0ab269fa9975d4bf023d8be2fdd7d92a8d7aa00c1a726009eb258b1f5abb7fc1e5682746a92b181b6962bbe407b399fb9fb3b579b789af9bc3ffddd240fc0451bd5a24087babdcf755fbc47f66748f62c37c309a4f939ade6e793754bc60efc0fb0eccba7176a7d5507f121f9ab90df2a13aadf8534ec664531824215d98b692270cadd73b29ed27d153413f24ffba2db18589ee6319c6a01a5330c274f1dd37a9ca33d939242171611ece68959708666cd36116ef72f0341cb0c9b2c30ae8442bcdeb4aebf3f954784806265d3d6d4f3baaaffc68e8f762d2c76b6ca8425c2a059e50a6c427b9139f55a4f2fc417d5ac681d2f96fea20eef4fda27a9546ad6bcfa1f077722e05613ece1758e351aceb75ef86a854f5212acbc9eb472a76508bf27f4727467552bfef17d9c2b2dc70a3c24a1783b8a85c9 +MD = ffcb3b313e576ea5b0a87449749b82c1523947ad019c633401a185fbcb4fd475dfe42289c5413f440d083f73b65abcf2386e0eff39acfafa398a3d6b778fde23 + +Len = 7360 +Msg = 89eb3056770a6157f06921bc153834447c4b6d862d10d185f1c3f984cde5b81cc9eafe8bf532fc4fae3a89f41e14c52a0214fc1ab0cdcdfa583b8bdf8a42e3d3f857bf287e7e6b0c5f74f65dd22ddcbebd81e1eac022404875d105c0f6d1b8cea09c3bd417d6f5b58a7f319f396cc02834f8e69d65f77496d0eb31ce1a7b7e3248203a38ca22e472b8c3ff635bb9bb91efe2d1dba734af0df2f3d5b2fd267f2a794b84fc9e4a7e6d70a82b5141fd132177a86b4e8fc13ad5624fba14a7bb01dbba85e0c79c360ccb3a967b10f21e11ff53b07c9c24865d15a869a89a21234d7093361841caced5b79ef5b9497606fd540b64cc6d6f6b5ff64da767ef7244ab0f8cc6f21332fb2357252daba3d69b1f47282b226a76598a9fd873beb9a20862e12e9e37e5dca33cd356a61ac719c7be01316c483a43362438d13476a1ba56bc0d0024af5eceaf6954bac8cd5c477124a9ae910486deec76ebc151574ec115ffbb8bc121271208f202d7fc8e0b6981976827011ff64d61c8de2f342969bf2f741555dd56e8b0941f0438a8237c85de6066252461319a7f6239a344b499bd8b6340e8e11748ae3d388362365556a672c7ca2f6291e0cd2c8b25a5e9c087c1111467cc332aef16ea84a6df0cec41d12413bdce2379aaec528ccabe8b14dad6a9ceb0873d5786f0834c963594b0e710dc8e6689cfdf3801d8ad4f7592793b013bdb43a36668b542efd87aef3469ed6a827eeee8ce8c3113a636dc5367b7524caf8149a81523231618707b9256defee8ff2c7c7388483e2ba46f9bdf7096c6beed09ea1cb4527973e55cc1a861d8c09039e039b366da0750baa0b2a116de405fdebb4d89aabb5e623ee373b9bd1fdb6c19e24c2fce0c338ad0104921c156673868de9b765f277be90b4fb94bd17bf8848779de6f29a46be1ce0889e8dac7e45074bcfb6c3b5d781334e6bce807b4bfde6cee17fce06b565e9cd0997dc7f95eb0eb9b96f2a627fce5a2f1a417c691d784ae891e5d59299d0822b0a268f2b47e5eb3c49490084baf693bb7996177dbe97e37921c1afea6e7e849f0cc32c1c0ec64b67f1ccec9923aa6e882c24c805a9cd2ed5138bc36a9dd04f7d73e629ee44fcada13563551c445a4929847624ad6998aba0e9bca68fc276615ae2180f0e94f9609ca6b4c08a9776c1f42512b3d1787ae85106cccfe656c168cbd9c141f9895d22aea839b5708790579c8082ec1e40f4436a0d44b5fad541a424cd8a793b7c98525bcc5aba4abf277867293f33f07d956b406fbcef39c897c21a3fd +MD = 6b8be942ecd6e8509b88c0ebed80e0e2193eccf212430429e7d3d097285726e85e0d1d22d046cfbf37f80f922e36bb1c3b9e9d43cbbc477dc80eefc783adc20b + +Len = 8152 +Msg = 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 +MD = 014fd2fa6b05c4fca1a5c0753f15c940b5f976b41a40bf6bb14afe839d83a4676173940717bb7e746a2ac77f573e6744cf0002b78b5b7f664e22434e22d0ccd0 + +Len = 8944 +Msg = 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 +MD = 5f1da3c03d633d35d6f28c1987ad25ae9e26b6afdebb2aed02f1719b706d20e5632b2005933db62129032fa3fd2304469928f6810af1742c27731a5beffb15bf + +Len = 9736 +Msg = 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 +MD = 1c7665a61930433fcc7660b36049c016a7c646dd1e8412721314f969d3661554b97b18fd35945109cfbfc783bdc424b204ab19afaac855c284daf7f2cb333a65 + +Len = 10528 +Msg = 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 +MD = 97c433de3cd8f18b75e494bafc3c813e112b2261f1261ea6fab9dce0aaee5e5359f0e763f02154cac1589bb70c2cbe9cd22f976559032923c4e2beaf3f88f196 + +Len = 11320 +Msg = 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 +MD = 44a012fccd62e69ae9a2e9e46427fa491b88f66522cdc1f4ab5c5157196b15dba3905b99c460bf690711797ea556fcf4b2550539151f80eeb522fbc00450c723 + +Len = 12112 +Msg = cb7e0a2878bbccbb7dbdd8a2e2791ea2aeee73c909b5d9a19eda01aa43ea0e07dc4d9c787cd60188ce99d208b4fdaabb2d1226537c24349c87908ef87dd6810bbbf0f3b7f1e2a44b8093b4f727db6684dfdd23410397c241b4b706c37cb068f2310e17cf1d063e6b5b528559843cda638cf8717ce63609f6eff872f589a14c24064f11a6496b5650277f4d1513478fc1fb0a18eb6d2a9324fefbd975ecd1b409025de826bc397462acc115131c250c07f5bc2175e09be834aa67432bed672809eddda436c0972009b2c1e43be7fdd99b42b6930486b08e8cbbe4b8ffd48c308c8e7a4ebd9bade3ad0026c275bcf87fe7aa9f767fa8920f96f91c41d9e86755faaedaeda596a444b65f99b7a9e23e8551f51fd3cd8e69f3b92cb4e5a172211ebb15a589d5f9a4cc8c97c2ccbfa2f67343eae0b1d8805cc05c1b57ad3fbae114378b842b350cd401977048089f4448d22452871887c69300e98fab9f9b08d0bdd6d81ed9ad175d6d3fb2d47431105d285cf5bf10c2a7373ac75058c69ea416a401c31d9d25616798ed240d165e4d5d00539b2ea2716c70f75e2607272ed5da4e1e16267f85331909078f9cf80c4570df700c7cd57d5e65be16d960cc34e544459797e486b5d59b48f7bb2822243ebc4f1d0f52b2ccc23f1757300abc991a7d10d20ffcba9d8f16dd23705a9a8f816cd7c26e583f47e3258a89f4aeff43bdad373945192326a9b251f576da6a3356a600c5ef3586d60840a014edf39e1c15fb423203e1ca366a962ad3944f9afa0492508f5b918f6278b8e060e382a00b6c90ba270ffcb6b61bebf327946130cbd55a5188791660d17cb4d3d59e020df70894277f3213ef8f04d831583cb9368d0f238b18136a030d5c5cffdce51cedca322e0fa234ce7ea76d866ece55ffb32afb1885a8ef3580fc60d9eedb8278496b3286fcf8ddd46ae89e1c31f1a6dbb089e15ec79ed720dd88d053283c3bbd28c250c575e9f5cebb39dec30329f9f334920920d96490d22498f3f13365d99393b7d41303dd43637a8177a36bde14f2472dba844460e5f45d1312dc99c024a4913205972c3c903caeaaafe3f178c07ef1423eb28ffc9d2e8ee3753ce2b3e3952a1b2d7a7b6ea4005f9bcfac1d5fc53f3bb9dbd3429f7f27c1ef643894a8e011665a92e375db4758953c1e2578fbebdf2c7ada0fe5b05588fd1f27f83906e1be4ed77cfba4eb41ec5975e67789b5fa03cd6e838d0199e5f84b5b05a55835af44e97b35ea8f075963b22e6dc9d8f3b955247b1d761dc1f820b28b48677a9d124c402c04d7be955966a94ffd44ee1ef17d3c8af2f1c29055a83a97366526a6d17e59d330eabaff079c45c0dc0f529f6a231a844827776ec637eb6718c8e4b8b6813e59024d0aab2bae8e6952548cdceceec84f6840c4c31175cee435b73c3b87fef7a4c22536038f438c33a938253f3f864dd59a6331f7ff0ceaf4d75bb7970d9c8a9eb89dc76dfa04480427e5a42f2a94b1fc25b8477258a1478044dcdc341004012e2bda44533398c9c61683911477c0fcae53688d9de4dfee71c561347a58dd633b6507351c03a9175fbc397555ecb137d26a9b8cde6a6be6ada21246d2acd0b9afac4a223032dc3bb96230d75c52106a50b378ca9eb4f0371e23189aa2d5850a7149cb94f788db3cba4f903f9070849b107628d1468814eaab909bb8539ca35e6984b313d9cd4e224ccd80355910b6d4f9fbd3293caf7f063b30c2294ec7d3be7fa42a253ec8dcf6562228421ff84d1cf5899f58eaf1da93b84cb674fa1ebc309bf357548e422ebfbf97b1ed4af1f27cec69b7e8b615cd9a092c9f21be6b07bfa5b763273103ec85717443bf42c34dfac4e441610ae5ff211618a4b804745b70853976268fd3bd505301053f703605a1664066494d271933c758edc23302614d23c1b6da107a49294d8620f53a12c376bac54d2ae7a4c2d50433a3c7b2ddc05d67964eca1dbf3917474abc69091e2e83a8bd1f8b4024a311b5f3ee4debcd21a83a02647f1c6b35232996ff244623efcf196e03f5c06f64eec2def5de459a2c37824b217f7746e454dbb214ad57e9ad62f32122efcf4cac75133de101280b881129baac549418efb246e6218ca63811 +MD = b4641572cf72bed4513dfc2771dfeafc1aa6dbf7f6b740998c905f2f48ae471d00eb0e284291290360c9763500a584bab1a1603a8017accd15c3db7fac25b572 + +Len = 12904 +Msg = 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 +MD = a1a60fb89d420fc84c2caab24079d75ddca9a4676eb8677b3d64038fba8711203a459bc26259112c64138d4cd1ebba406720cf29cd1e4ac35e35be50464ef1df + +Len = 13696 +Msg = 1cecb230f8c80f87e65e6a5cf1de4301b2cf1ac7c4ae81c478d875d3c9aaeedb92e6b555fe58760840ba161785d6463e27ea595924505226ce5e424bc48cd19b20d41a95f25fbc2dee5d2dd0613552a26ade4d0a668c9770ac904e457b79d044308088f8bc23087f560f588d6d438eb4e1739fe272aa752b793442c8d6bb136029b0a88745ed8385e1983f58914a23fcf570f7e930f216de9c13c5ddbd99c376732d2249730454c7f7bf8938b59039020e9ffc2889aca2117ff5808b185a080f76bf9d472fb2a5cd014ddf36c15ef64f95c657a6631f404c89a21adacf4709b2992dc187623d9b20650be8589dfc856af0aeb06ba894191822e13cd2caa8efe747413713f2ee60478dbe4da832b20cdb891fad803e5355fcb27b8e7cf1c5e137e5c1a7f3c90d1ccadf31b52e66c8b42bc7e1f9ec0fa41b81a139b7df2de50828dc76b82dcde2f632c52bc9f12285a4e111bb3ab701cf932d58e1600364518c44942813cbe8b41705a67331f94f330585d17619eafe1be78b3d3b30f17f529413759f60d401cda7ceead2944ed318fe9f6eda3d8cedd23c20b911d0b0672e481ce8a24651ff73cd12f8109af9987cb8b850af4fa5b53abd763529e748022dd1e753fb6d49ccefb15b3af5ec0184a95a57dfbdf63e409b8f14174c1ec23a9957fc1f707ec44f897c301748326e81e60d0583ccdb5d753fdd82c8421d25f6b801e4b5ca21cb7088561af7d31348767af949a4a3a50d3c6dcd49b1d38b791ed4f8267bd0fd64173666a0425c38984aae45abaa0bfd537d6c87f039c711c79933644adb4cbb9a2cd9d54a61ac4966e7ca1ab3fdcc8b39208534ffc7e55616511d6cd83c04027297bacaa0ba8bedb834169fea05aef6c60e00fcfec5f6036e2ddc385906c27bf640216e2bb6c1cc9819d9fdd72a79e7022d2506769ac2bfd715b7f155a04cce2d1055e972bd158f0d7e5d5b03d5f405f6663b7befae11335af1f5bf52746aa21feda062fd3850de1f4be8e2f46ce8f9a9a28c82ef69ab06fea9dfc9dae9e69fd5c04801558d3a60d768c3b934591d6a23c75e44003358e1cc26bd387467876e567296f001269bbe3cbe360a4b025b016dbefae9a974df6cca4ed733a95614b7aae9d25489693ba0573388fabfd16a668e70a8987394094e020a74e3ff1f5621da0f445876c0e2ac2eb003b31a2c11408ec4b079e4fb9e307c43dd7000281555edcb34214f92578dcc1eed5de37d193776a159b5861166b93fdf5b0134da18fbeb04e9da9c4763e936638f1fa32b4bf44df1ec74e13f289253c834be229d29badda4aca9e647ce6976693122e19e6d1f1b9bb1dd7bebae62c0e4b0d052da0e3aca92c5b6b3f960b492161b8e253e4760e987f019de7fbed28e1d195f4cf79024bab67c2a8ec7e0739554948af873a35dbe9df14f9261218ac659b592995e7720b5f8182dfc18184d840ae53ee0a547c1a2c5fba81dfb9f317082ce92c0758bd5c440e3e68755ceeb692057d3673cfc329de7584c09b3ff6f927faa8749a694ecee76237eb6e4cbf44b7d307115a08a58b8eb4e62def30bee36389198bd58590c3c82211d112ed711330bb83f7139b9ddfab92613222289536395cdeda2f2a3deb44c25e9219bb9ea28b13966037051666c3928865fa74249227ea5af83de3a0a61bd770d6d943b263257f90e53ab199e14549be41cecfe767adb6006e583e63748bb5eaf7e7f236d59e5415dea53da2afcf0c954e25884827394471952496f0d732f24f8dac53a69a644597e4fd15cb52cf6f8ff38539e161591a21151989c36e9020f0f0bcf48c0205a89970a8b67e5aa4f710ca64512da69bbb9156bd83657b21a681c9904151ad01019d1a4ebc36280e17ca4b496a97576f8d34e2671051bd76176490acb6820bc4f5053a45837d5b69660efebaf2b90443139e40dccd1275fbe83bce88e0b79eefd7846923a8de652556714d2f660d2dc4f34fea54f62265218d59dbab4c4ce6e03d7d1f7f88b3c5e05d73cf2d410e445380ac4786380beb859b51509a55cc7424ab51d59fcfa80e190f98ed1b2026d87d6035f0d71f2979a686b4c5cc89b0b74b95c5143ada159e4dd1533f9f6ff16ab0f69f7ecdf815aff2d3f693b8748430c3713963a734a706ed47352f20acf87b8cd82b39e16f5aff09079942e492d1610ae2114c8b6bb6c875d5a1442543a67b6f798bcaa7f163d747960f7be77102d8a05cff274debdf7376014a1733e085eae75f13a9881abad93d03db77277ba2f81246559c65318b687c5e7200d2e0016a72fd554f1837ea6557d58ffd3b2f3c5fef32b70477e94537e741cb9968eeb34a90c8e323bef55d1c368f9f568908297085968607ec5f9762556fa9698c59163bcf763fd012cf9d6e47a68c1b97a314ca7416650f4 +MD = 3ed79e61d5843b36b6228023670b333208cf9bf556b1d6fc54e95808dfac2402ae06fb749e45883f21211ff41b28cced38d706390a398afa8f5eee760da041f2 + +Len = 14488 +Msg = 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 +MD = 838f976308b3e38471c3b4d8e5422312e4f56429b381f91b39bd27aa471e91a6e3ad8e313c64e6987792416c44a2a0e06afdae11a946af8b12c62f57af73cad9 + +Len = 15280 +Msg = d2860f7959d1d18e4ba3a08b56c5b7139aa164880349012fd7bb268e8b641d19dbe2960e1a0e9c9ec63ac84d5fb7b59b799bb3e411c0c0851d10b4406600bbe29a5b08229d41c8cd216f552076c1ad75a3f42223b5b1539f57c75ae7a3b947203878ce7d8d713c6485caafcc43e987ea3f37180c9923a1c5ae69824aea94a91cddc14ee790a7e0aa19d43f196d392b4076e9fd68651e943e4a7d9332e19bca1eafbff1284eea9ce906146bcf9db981bf6f9438ffc1ab1354528bf56733d5906dd9f91f077142586773139cb57a7072b153bf339953d0074dee1c0fb1864ae45381f8414e9eb7fc6e89573b94ad66e45c49f355fec697567248b74bd88303af16d042bdc37f5270446f6aae34dda3c00a7ab706f5c008e90b85e410a3d107d7ffed61fd2fbc1a9c314ed45f5db330ef010d93ae48e92aa860d02bc7db185e465600dd6759fd18697f4e1bb4d7d61458892b0fb5bdeb057bb84f15d6480211e263333c650be952bd7496c91769f057e2ecfcb4841d6ba14b5d2a29a6b23527956dac085e0b28d2825a4f65efdda6027770a709812f1407fe958aef9fe159a845be93c8ba2263a09e77a078a4f9a21bfe5f559715bd8b3e7ea997f0299d179ddc9c1105e01842c2fb14b2899e868cad5eff2de4a88d7b4eb1e178b3adad170d41504e463ab56c427f78ad20444b0bbd8199587aa3698a40818456c191da00005c2271132fc18a2714edb8c60012c8554e74fde16c17601bd5dc58a03fec7a7e1559a2f42703437aa1b9fb0139a16b7cadda459f6d5fa6e7942fa7da1dab2f90543f0b728a4440420d259f5c58c19b3b8611583e0d0b04aca8c66af795dec43d011ad114c14c28874279cc5cc33a0099c1625d46b3e12173f8e9ca7d0e4fe48e04331f6332e3a45227fda98be3d4439e47157c3dc9aba6436cdfeff6f0c4358945d21be646d15caaa4f95f7020570c52fe72dfadb62f3a25ecf200e9a2065f38ad3fed2565ddf797a1b41593e38a02becfc1ab1de2368620606825df8edd0ba322c1bea8f8d11e210677f47d9236cee9a2490b16b587323cb08a885f1b10e1d18da1b6f865737851bb8a24b5972318db6053251f97ece581c5a04ef1b16988cad728fc9c168cae2ea935ccc35819879def2721c0f02b47f885f2a21db8aea996e69bb91c71e367c0b6c015303fe0c336390d2881280d01a8d9c7aa6c98a8eb3ea4451401e0424c10cb722683b23f75ae254d62eba75abb9aa9698e65ba1ff7c9f86d36d1ca6f0425d19428441b00450e9a2ef685d5da1cd4de1e779184db743fc95a461797333808ae6e42fce1e9da5d82f90cd71b54cd605e2f8d765fa30ba801556d58ae5690bf4c489d326cc3dda3c4f7ce6adf92764613e4f79eb440640d87a6d31e79a0b354916a606e2455f5e8486d62c58a5abe8ce484de91e97b267543959ff05fd94ace671bb4387169cb35f6a6f07185754d3cb85969d5681af9e91d6afa57c8c8fc36b5a5c119bbc50691b6e9a1f437abcc5d79a9c1f497e58770fd6c0bda1c367293634eae986a324f05707d9cd807c3e3f80ebd0d76e0a67512cbe4fb01c4eb54ed585fa43ee6784e980cab0aa45f8739145fdd76e1aa236ed76f1af15426af494d7e1fca91975faa5272bb13e1a6bd77b9545024bf5c2518c8d156165cab4af9babcd8491be6af0c3b8af5de16432e44efd5603e9760741becdae091a0bb830d3cfad04864392f1b5c3da094cba0a249bfca53ecf21dd8204c70ff8ba8bf232ddb2051f0f2f9a880bc71065c8924e12e301b725857fb19cfee7cfd2cfd1df300a017a1684f8fe3e2630f6d5fd637b29a4bb005a74e62fecfdce7209b263fb82f92c508d90361a5ea5a001ec53d41de35177154045fba51c91e97b101ab8b3d61b913d06b94d9b940a82a61b543aa2ea89c47a695136bd864ba76f785156b493f1ee93f458c5ee68b55777e5772db679be2184582f1dd5c49ba6b3c50eb46a371c8309f907357f3736acebcd4513a54b5f2ce77f48279a41f255dc689b584149ebfce3673cf2ea9a2ee1664546830bc9fd34f85134ca57a8f0436df59fc8c646e0cad4d172a4ad0bde939befe402666018d85b706d9caa4415eddcde846c85b8bb6b32ba40b13306f641e12fb60821b81295654f6b151ebdc3b3ad85d1e9fc09ac5ca1a41fbf1905d65ada87350ada3caaeaca60a5aa01709a4354ae109795d4642d96016814cb932f7cec78d9910c682246ef36b5e21f06f9fb6699b91bef83434c8464c258c74941f69b971c2124c5293848440453b3db737a57fb43dd75a0fa37f140b6f19872ce766c448531afce104d5a1b29555c88871ead253952a4b7d98e5127ae85cbaa156ad313ad5929fd87e4b91e9d8d9578b576daaa12220932619e488c217bbd79b7427486ecfe1fdde0acd9e0c952eb367f01751c66b22f9b43163bd0a849fa4c44aba500dc96fde9caf440e4355bca4c544ce0ee9f99646cce54bfa7bb871ebc1df4f933e4ba40ab975962ab89febf24d5c7b283252e542183f82873d3a97723d3ccf572adee848de64ac3a90fb2364a63f07e8ca0078b54046f1ac77927b02de6720e5f809a362b3856e86f6f1ccc379f55896d98bb667ec0280b1524983624c6a2c85d1553d1edfdfc455100a4ed76d87587a86790620c37c18ddf5e6195c304dd97edd491e450b7a +MD = a163a7136bcc92589303cb15e26bc6ba7abd91b8ed194e2ade3d47f381191dc402e336c4c1aa8c0f9a2ef4149b1e3c2452d195d36aa3b96451e5059f5985ca19 + +Len = 16072 +Msg = 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 +MD = 0a6bd4a3be10c690ba358fd4abe6bb3b05c6e74762ddb16c96122156c6104102a0f4da5d119eae98c369b4a39bc75f86f76b829c7efa5d35b8c43dbce18a9c45 + +Len = 16864 +Msg = 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 +MD = ca2928c7468e8e421b00fb128b1c114a983745f9b20521e8c8954a68178ccefc2e81d0f0c49255157e9b86cf09e59e187ad938ffd35664f9a3ddb471b85ee250 + +Len = 17656 +Msg = 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 +MD = ba3ad050bcbd2febe8989cd0ade135303de9d9a419daaa647f0c89e2d8c78e1a701a4f9ea3ade33ec68b28d4a6e7ff15d637a1a803d2de1ff35b0d4298519cbc + +Len = 18448 +Msg = 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 +MD = a86c70c2063f12bddf997c91d1ebb57f5c55ca67614f397c1c52a87b0621fc4378c2eeb07732e5eb0fbb4b3c1fdde87e9ed71b50f83eeb02cba03bafedc84764 + +Len = 19240 +Msg = d99f82296f56251e365764e1acf4d20728f89f546cebc6217d918700b3b418a30c2398fac5fb449c2c25ed68b020aa6c3a01ca06c0b80c48179413a1080a14baa7b2d29fe092cc1f539fb4756281242887978d2feb3b70593547d0eca0d7e78c5151185fe7a3256f53cca250ea9ea902b8c2d01818fc581a82b0a729a3a6f8e1b30a528403b7b654d5b59d4071ffa2c3758a7b0a6d842d55a3d9809f39fcb18174e468545b55e99681608e8e1f2d753365f8764b125a58d043ca4497886379343de84218180525fcfed75e831baf8c1a3113a92330063f54088ad959bb62b8c1b61cc817614fd34ff522f3658e0d4d4081e4fcdcef114ca89a20292df882d7f1868ae39b5fbc59570d47377c9fd0226dfb7158bd7602e696a2971b5b67493c8c563a79ea39d320dcef501112777f72684ac4a30dee6174e4c8f4962a3241505acd32734d181c90a64244686d3da2a4fa14e5c7157eb7605bb34184e47ef27b22947cba0c2420117caf2c26d61ac222eb02daaa1d4f8a11c30c86cccf76e326ae5220356f84660c28de0f329536665303bbad366c8965efe47ac956333f9cb7c4b024cbbe6177e77076f574f2b8169f09e866514c53cd6285a6140a5a04a5982d56926640e2d90c1d20e7d435c85a6ec7300be503d54cd270376ed08beb872fb1eb71ed3e3016e1f783eb3aa590bb28033ca6d9da3869a76bd6e0900d1cc9e61718ca470072b6d0c5480c8e8b35c03586b33e1519a4ad493f2b703229c0f3242984a45eced13f4051164fb82fe2f2fe183edc8108409e21b4dd289e27ff8d50add70719f0753b996196bea0d9bdd7e980858705ef35c695919510bc4f0020d46cbbfc60ad853142be6f602fd1eef95f882f478915aaad0ea0fa2f75e8ec33172ed6891b4f2aaaa5304a3d4b5e9ee0c9f6e524f5c3c8d9f5a7b58daf3cea4f81bad0b9321c8b2d297ecf5eddcaf5128d934e273141b7d4b06f6d32539123fb7ada52918e5dd1423672a5cace5b1a191527135725d79e26a9c0cb274a30bfbf6a54041b1559237134d27589045a367dc77adbbdbacda555466177737a61e523b9f18d5eb05aaa438b67e6a4690f70c40d534f5fd66af6ebf11c181ecd6cbdb0cf79966248a68d3fa4f9a122e4c1f1784e7c164762f7b67011b756312a9870ed15b4c630c386f5eee5504d0b5cb9e020f1bbd97d47bc106a0dfbdbb3782e2663f16ac6cf0b420ad6b7339368bb40664560d940076b012a634fb04caca1760698cc623d470622f381836b1b40e89cab6e029ef2efb80e2ce23e9e54248cb839160f65d4a19e6ed977afc18c9bcb15d6233fd1983d152a3f70428c9924213ce765203b33e4ba6de33ea5fa8f814cf510ed7f3cd9f7699f8b94c344c3b34849360b69ac011841683a60cbe1cbfb538280522aa55e279eb337d6298c7bdae92951925080e6451da705658b3de910c8064fdca8d5cfd49baf6bbedd2d69a0ec225e823f7e8c7435726dd34cd590c993c7a4136294d30748db51d545ef340d397d86619d6f98ad71119a347572692c9c0ea87ebea912c78d7e0ea2ca998429b982f0b9d21bb5f6b9cbb30f70dc1b44cc2282a525de351c52e1cdadd4f503fd5278c511464a8959f5eae1eda4db4f16094d5b1000f9e40e7f4db47fccc95790eda92cf261c4bcdd0db44b557937adac3cd55b48b5c3c6a6fc08eb9f18de28ea735b4ee38b50f78ae9721acf57b7dc0d4e03a9d4ae0484ebb15a9b9522fc1f14cad7526c2cb8e269726b75e3a6258541251f6e3c5184c5e6878decea51eae315dc656115acc224818ee9851ace474f51ab71d109080a329d64e805250c721df58f4ca367733765db263271fb37e5e344c640fbc23a60731a32b20fcebd5a75bdcdd63fe9e9de4f7d238f620f4ac9e82260d614ef4e4c2f65d734316ecb6b92747d495e24768188716b4880dc6dba07f360794318ae970e843db6948c9e6d1d2287ee279e83e6b8bfe8a5f2ec097fe8c0ae72b0c6c109ba814a7f5fb09e28bdcfd20dc3e176d6886d80eee1c787e1329032098480ef69d863e8d9bb6233641b8448ee5975b9199f851d6a74f34da88e6cd485e7cfa0811333fe0ad02bc5e8df49d0d812e0b277a70ea662d4fac59ca35b7c30003a3c1710f8735bc592bc7db024521516accbb84511031e286456841a651250f8492bf47aba3114c32080eb361fb7eb8c606ba323951ce699b7672a9a927e2ef684d6e0f7821f7df15b79fa1a41e5a39c85f902e9a2d9024f7d6254cceba8122374a3a22f5725de78cd0f710492c58470a2df9b3f4022b9713daecb57777843a7a0fb04cc412b7e7ffeab1a9b1b3fd82d3f8436cb78df552880b357e53fd70ba99047cc734819a62f75b3bb88e33ce5fee5509d3851f81c9bcdd9bf1b49abb051cdedc3ce75d79eb0ba911d73f2a2f5091aab972cd45557f3ac88cda39fde7bc8de57b185cf4eae2955ab0802515b4e7669fdeb4f08de4d57a52847254956b4364beb5e405e641ec2cf6b44e0074d386e57ae624bf57c48f04121f6484dfda3c39d1391a62b0235a5ae3898b31c62fd196e26c4c5a3158ee507dba2b5b5b990955b36145f3d113cf77d79cd249980e49e35ced9681b92685f80bf13148974c2d70dbbad149d777be3c198abda85913425340c68d964dc1e863233100ccf1582af3c0c256d511e3a8e04fcfa7ee87c36d8f4493bc386d9f881a7a06345918418456f90431163ecc123cd0d82b7cb2932ddfcee18cc8a733e79676fd268d6a9ccc22eafd1a9dacb57c8a5330b2e35806f5cd461c89c77913795f806261da76ce54e01d195dcbfa246a513d65c8a2e69377e050c13dc551b2cfee4cf260b0bb5ad10715e59531958d4e49f5e3e74beccd06a1656c0342cf865dbb3309cdb0a6c6a3105bee3b5f0d74aaad1337994ee9183498fa6994b05122a55eb934e34ac7965d8465afbab4d06f02232bdd591c5a09843f96664cae750c394165f06bffac4e62eba986bdd37cd0d7149651a144be1577fdbfdea58db9a77bfbbfc8a24fb35355bebe1faf2b614eac29e910fc4893d0826bdd3f39ee8d890ff63d2a20ab7b59986619e6f93d2c3d03bbaaa7d4a869af25f2750474416f2547b95491819372a5cd8a235936794c3050424192c4d4be25e53a2dcadf16dd10c5cd9c9b3fa827ec47838102e1703fad1466445e476defb942ab5dfee4df65bffc9b7ba3a55a0971a8eab95084a27517e2903956d6d49cfdc0be9c1d201b87977ebb88476d19a5fa544812ee8a909b053d488738ed994447e1ec5ea21b5bb14bae9638f2f1777bcafc0444297dbb00097707b461162c544c18dd1c2a310081211ec41432ccf3f987e2a7b38de89242793246575bcb1e6b6ef7d95b220bba65dc41c +MD = db7e2ece42b5186f84e6c1407593a9b9e2971aba7122b8167b21b31ea5f0bd21ff754e4fefba71c9327eeb19625702b64426acce7fd88467adc3d2b38a861abd + +Len = 20032 +Msg = 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 +MD = 99820341517e3140475fc1a9e57a7f8b8bb85293ff7ccee237542e729531fe9daeeed96c3f41d87faaae3a7c6ecf308842b2e08aeb17e77a64484f41c60cd93d + +Len = 20824 +Msg = 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 +MD = c1d54f9d273a339cd1750ffe36b10b1b9a60c9be1f2f36d238674e894d19b9929ef7be13043028a862c528e79026504c4a8b04a375a66d9d84efc1ee24325539 + +Len = 21616 +Msg = 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 +MD = bc393bc550a3705fcd5828ea43b536f6b2de8426bb7d0857dbccde4cf0ca37bc8a3c27a93096b4ebf7861843da5e4c31a43fd7155ce8c986ecbb039739ceeb04 + +Len = 22408 +Msg = 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 +MD = 6b543633eaad9b4acbdd18958c2f76d255fc32439ebf5b7125e6826da4c2165e4fb7295d2804e627a072d2382ab10d43bdf0c0e5e7ed45f3543c7cef42761f1d + +Len = 23200 +Msg = 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 +MD = dc0465690127cf6bb6a066a8f400e64582e2540fb2794332533d37873f08dfe7408b2cba3b539138486fb75aeaf081229c525963c0d86efbd4c744f75496cef7 + +Len = 23992 +Msg = 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 +MD = 950233b2ee76ce1943d2c6bac53bb945b5e9793a41270cfd8607028df5c09be1eb311ece3fc5f58be0c5e233f42ddfa1b63c61326244a57c40a7e4df6a7e7f18 + +Len = 24784 +Msg = 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 +MD = 9b73214f933db062db8f1b46c60c266962c8071bdedf569c0e870c54730a0f97e200d199260a2988a651524a2abf9ecd8dbc831762f0a784f830462539ac24a1 + +Len = 25576 +Msg = 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 +MD = 096a0d12871ba1ec81261a8e8b5ab587aba950b91580286aab0759586e04630b8a9e6a05a2422768cdf77645d2d144a7f7a3b8480968a809e7fd3f832fbd2424 + +Len = 26368 +Msg = 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 +MD = 4cb6d5a4382d4ab1edbff2c1fd938c982fd4270d33c42bafdb00496d860643e554a9039dc1d8ad1a6004f55874aecd7a73830123dedb3b42aa6547d6f4179ef1 + +Len = 27160 +Msg = 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 +MD = 4018097493d3386e4adafea20ca962c9925bd5dd9c61c1a29198b064fdc313b599e9615bec715f9d3a2db986e64cbac04cb253e8ec977ea45ca8f1c9f802d965 + +Len = 27952 +Msg = 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 +MD = c5ad53c45a03b0e1c8dc5a70031ed1ea16bd09be869d4505ea811ac6ea8fe988d264df3b698e08113cad1908b8710494e31f6b94275544eaa8dca047147f48ac + +Len = 28744 +Msg = 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 +MD = 858deb41f50d96cec9a0850ed70b0d96207e6d5d8b3641fd09af5084d65a7c7b71fbb6fe04876ac728750a543ee31e94e388d42ca5aa2197fb006379dc67b423 + +Len = 29536 +Msg = 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 +MD = 52e4c7a5283c2c147f07e595e81832f5f31f29ec02b4fd68ea956d54a1f6c6bc953fc268df43ce47405362d3773f8f89fa024d92b54a1203f6d390bb88a73227 + +Len = 30328 +Msg = 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 +MD = bd8fbb9bc746521cba8628670493cd851f43b6f0263f49d3b6259519fbbcd93cac1c7d215425a26a73a3c0f28aa18833a4811e3ecabeeac0917f2e18f7718c8a + +Len = 31120 +Msg = 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 +MD = c1644263ab1ff816fb1774369156e8e7001e1a164abc73f1bb4caede515eb2cf5708b21612f1ac475e00483f0552869603a7120c0d3e5a4d15380bb6d9aa9e82 + +Len = 31912 +Msg = 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 +MD = 27aa551dfa2fb1c0f4504f9bdfa68e50b4693d9327612a3fe8984c00d05d9cf6d3a0a8d0223ee5957504ea56a228e98acc6954fe35c7a577ba6be19abddc5dd0 + +Len = 32704 +Msg = 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 +MD = e8e09fc57bd3b8e18b2726418836852cf1544eb2cf28c18f5b98436382d0b621953d2faa60d155dd28c2cb76c00ee93d3de56289b399c22a4fd82f00dd35ef27 + +Len = 33496 +Msg = 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 +MD = 6c66192d7e119cfb52e822217591996077095c73a7b957a0610ee815f9000fcdc7756c08cc6227798ec73b651666009378c879e47a2402e8861fd1cb80ec0369 + +Len = 34288 +Msg = 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 +MD = 2711cb980cb4fd62df85446940d9c5d0e382912c96e80ecfdcdaf7195f377130d01f1530b429e3658c371e7a91e3a738814ca8c7b1139d9847756f24e9d247fe + +Len = 35080 +Msg = 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 +MD = 73e3a0b552605e08c1ca390e9b8d498fa2679a4f2f29bd80ca7e40a86e20a5ed4a9b8707db0aeb79e251c8c0f4259ecd25dbb9c82de838ae953e712d36991546 + +Len = 35872 +Msg = d5233637f4320cf1579673430ac26259595f2e48d742aba0a59c9440f0712d6fbc4c2628e030c3b452d13a7fa5045d24d07578ca31987db3d2e25e12ea38bb1da7a8bd642a574261d4ba3a50c009504190f1ce6b6d8abac3498845cd67b567b21e9fc394da8dd01e63b83a5f62b886d8213df6d392ffacf793f8111a70d07856a999ff5ff6bcb6138933045393f9461209bfb8aba8e1997837988aa00c713830d1fe3a6e88cb3d6acd935ed55bb4d716d2e1de9bb817ca6dbdd278084380ed691d363c6897a2aa48b741118dc3d1820d030a2e4ac88987ffae0da2f91de5e02816a9cdf62c2948d7d0a3e522d2398f1f25a17261e31f185690b0d11ca388599642bfb5c04e485e3f9f22a13d91d24673bf1070870ec1c499ee25cd19dc529fdb2be1bb6d05e733a8ad270f850685ee3259bef1655357d4f14dd35e97d129fc1e5975a9a559ee10398018f5a33b3bd1837c13bca3b9c9908537224c3e88f7b68753e5451253453d1aa25e1c3e38da358fae779be848ff407e337a5eb70ba21640a197585afad402749b624cff034b637e7a5254dc09e12c03ca435daa6213646ecbf5a9255784a76ff18b4c8da677a377650cb02803589c3d82e512be9333e83c5965021c703b73322e40e69229453da2f90d77743f4ad753e6c8429ca8e9ead0d45129e64fe2afe6d9ebe0b3929c7828bdbe7167c3a1266e7b55b8eca81cb152c420e72cfc62a4b27bf3039aeb669d31398565aa9943d1b6cbf23b559cb686ebaf3a04967da197bf9bc017ef3c8af4e4f6cb1de5c91a20525d08927f8b9eb1c21f0748cbdc89d334c1bae4598bf0c56a7bf95fbf590c5a6bb90086137dbc7a019bef7b7421019f3a76493181e28058eb5075f4e05303c9286840dfb97bf828cdac5a643852f042f940d5c80f4822f48efea9a4f1bee6b3b2f13265188b3a0551d8b0ccc079400598aac66faac6bee37b0cfb369aa39d6130dc3ddfd9b86a57b2aa597bb49dd830403984effa623c6bdb02d57482090f1bcbb2c817a30770671ba7bd39bbc7a00b18777710a82684d5d6699e2452f82629abf93dd31f82347db25944ce7dfe80dd49eb07995c1a7e6993c8be0fb179c9d2f73c03dcf5309fe19f475701a34a60f0fa1d9d54bd45136e3ba79dfd4892e05fd80082facc1997da0bf95c9bd5b3288a54969f0774af292ef58ea3b6bf4d541875cf22f44c4605b11ef8bd65ba42c0f47fdd777b2960a9efea063801bdb20b45f7304b941ebed2afffcbe024fbfe1076a27a8b7883617cfa4196c4a7eac8ee2e85ac65a0ea89e419d7fa2fa33ff00157e5f645c62ab9889723c7af71ef97e51b48cad8e157b0253acd0e10a92f1e79e171d80c2cc770b70db82061247427d95367120c1f0e3a7c590a8eedfd7392615a6ea84773028ff0a62729428b2081b01f0b0c6a22b72fd0bdb5022d68b254a20b04ef6063821c1aa8996abb6d9cac54c75c4158b1f9980baff7f238b2946a223c5933bec4f0221f5c356c32918fb0ab9381383f967c7c1477f8e776a3c3decb3598ffc95ef3a6e60a24b610c0a2969fcaa3798897e9e3d35ddf694f02e4b8843de7d8e9f934b257fa8dd0bec27d6517b6e98d997de8d530a9d5fe2b99a2fe349d6e48865c5a4d5a739943a25fc725fa9d7cfbdc0f205b13a20130722ea2bac59e57d608500e80d7bf7096265f29de32c8834bb7173a7c64918c868c8a8ff31e86c70bd79df852b6243951b1894a99a67f2706945bdd410bbe9d88e1750fb2279de86d5b0bbfcbdfeb1dfdaaa6d35e3e0a90b3daa5b2b0f0715dbfd9b7cafec82de286fd610cf33b5b43217b7e6b33e2b0e5daf1bb61d4fcf2f3b2dd176adfe97cddde236986d3b0bed3458bd9bb227aba4f03416591b2158888ea535e945d72d300fb37e9d672275af7f1427f6a32ee70f5b7326dea54247d44eda554f2814b7a73679faaa3d88979d5ae0838216b261a007d2c9a16c112174e4539c12c525db95faac574960ebc61950345cb88d60b0097de97b3ba01c59fcf79796dead88ed8ec4a0f0f571baa5a60796101467a836ae361db81811d275cee12cc20d31cc71e41d1e7428d0739ae5e97c4a20460779f0b8e60cc101c1f98d49799a18f25f1d587c7b4d6e0db53a3b6e5d776698ed0e838ed8e5b12069499a8904ab9c7fcf243e5b2dd94fa9edf8391eb00441e0e748d9207cef82de370a99386463023a7b4b0841ccc418058c5941632a8d6cae84dd64063866909bc9a0ebd00f5ce4a301d668b8ce8a81d11ed1f6e4138f21622420a6b8920774f98fa104d86bf5ae59e17ac238b999077d23f6bc0a01661aac63a733a0202eaa78078f96ca00c9e9bfa89c974a047c036a2a3c235d8acea2ddb1f57d655968ab87bfc0f41d74460154b5a06a5535a01038a016af5706157486ad8ff660a421f2b916e9cf5b2cf69fa9974abdf2c3a1b869141ac27f09c6fa27a4db313aa7070a7cab6e6afba1581f3edbe0049b450d666bf4bd0f3e0c7f9e41366bb05bc8746d52fbc3698757f6fa84e204c0c7202fa4b1c071e82c949beb53d0b5e63c8ef695dc769d3d86d73fdc0c482d94feeb94edfb15ddefc338a86be0124e555560fa1e69ba307962a5af1e457cced3bb1de9bc785365789a4f218a666999805ef51b618b15318fa329d14bb10e6d1f842d7a9aea078d24fa6e93e167552bf981a1c6f9d13624f2d0fa22eeef6b9cdad290e403a0b0d9779c0d7beb63537a23960d9951ac9b6f45749d30724112b2882efe92813cddbee2d7b24612dae31890e48eef03ad9394f9f669766066a252ca01bd228e2eecc1f935d38ef24e826bb3f5ac448a24dd1a72ef055153b08901f2f35300a4f77c771d5f07b3042ec0081f51ec365fd2c68462c6f77da6cf4524a56c66b94016fb32e18bc56ec30c1a523581d530ff17fe572c069647e413455f53e55eb8fa1de7a9c87482fea956fffe98fdedd0d264d3074126884c961d27f680f6a17c2d6cd0303471c6ff31afff41ac3e9c728469e31944bf33f8275d5baeaf08d59f7494236ad83c07fcf67786e001bc77b28f67bd0199393fd732446edc4094718f4a248fbe161bdc54623e254e1c0ff5fd5e0eaf54d11ce2662172c003f831fbd8288e43ae60999ab1ff6458e06d919ddf6acf68876ee2f2218f68fdaa1869eae69a320db05a4df98248aaa03b78f9e5c5502a471dd513b595d68786532394a54719c03c6865a14f41b84189d3c0a1544b888fe98ca637c34f815ed883cc5ae17621b95e4b152c226cd8f9843dc7106fce8e90be5844c7919b3a6f92b05524f6003c7df1bcdb57098025131dde0ecf9eeadcbd3415533ba7154c3a136d607b7951d49e85424aaa7b18272eb5490a57781ced75f928340c8a5a413ef92f70c6d207848b978fc5aeed9149bce8e34c1071d15b4b6c2579d2a1b6b3fea25b08af967dc6d586d9eedcd788274e374146b322a480ae0b7196f683d71ee9ad849a9e4d41160cf1d528accf692a431ee78c97f103083e65b11e10b727dc908940990b4cddec8266e605974bc0dd4c0e5a703763895c5cf9487189a2159783b3f3a68f4bc0d4e634a0f834c30baab993fea429f083f78a34cc23f9db4cba23bc22258290864999098a830ddbb63d2c3e689ae83e9f5456b6a0b7c9c929cef11060989dd19ac52b4407387adc6cef046c0cc6ea94481d42ed6aaf720239409c4f239229757ac20d829b8b146b7c4ae2bb7faab997fa9ccf478e7dab0cf7a955c6df94ce02a2eac033dbfd630f70db479b25d8cdc0436d5c538094ad5fe183ee261902f3ffaf89d3d63cf1cf1ef71a938983b3af939ef99aafe5a71161834a95db547f23c2fd49c8e8332ae1306b8357153dddc78889ebdaab22077fb859781d55166be5f318851ff862eb21ea3a9012bca8b9be25809ecce3ca4840cad096c531d35ba3168dc6397520c5198300eb56ee58d9fbe10f9cc1d842ebed2f95112dd01fb0f393d9a7b5fd014b20b14adf9428c2a0f941a36059f720650d4cf391d7ee502e4ff1688405de88dfefeb74e73b0a7ab13eddd88405cef73609a9887323bb190620c5c705b9b83c15cfa81bbcebf1e58d54fc1b7255de1be17adbd04fb1e4deeb0e77818732187f6f586dabbb078d9797a452e8a5ba932309c94a478202ea164f818d04831f5de75f02a2a15c2e1c1562d548ccb8b48c80f18d7b7ab497395395f28ceca3d216e86766ed992ab05bc37140643405c438da3b2ff5d641df612b70f9ed9653ead2170afdb4ffa13e9b36357e2bbb277a167369393fd6d44befe24300258e0dc9fdd7dc2f8f415a4978f231f705de8836a400ee21b018c67d343c9e9ddb504c0018cf3d84d31aa041636bf94398fac29a6ff74c820d08a2e3ec7ee63b6579992da151b18636c83db6e927fddc4bac4115e8cb06d29d22e400674dbc615a667f933603dabc10e66d2a88aaa239947f9e29acf0af8be6f42463330d739820a359e1355a1b8f0801c90ca058a8d419c134460b0ca91670f8ce7cee52be486ebcc2982dc8e6876296dbedfed65444323dae1ba173762ad1ad6ccde7a20f0a8b1f54189dd4ee3dd702004ec29846f2743165eafec9a9017f8e69c6bd7fc8571c4768e2e402750acbfff09fba12f3776638e6647173b462e1184007ee407ca688d17ba7bed62d76c7dd076133daec4b7ed0b9f8b8062aa78ce7aa01d898be81572a26a78cc46a2a4115cf23de5483d724855b1820f57e47f958f2353aece0700dcdd482cc61dd6dce56b26808146ca30dc344535ad611dcbcf8a32253b194db23492fc9fc12d9e9d60c5bae4f9f09577117003aa40ca7de2e534749d18b4e5b2e0872ed9a6c0206dea315571358ec3d24fd092ebb1d82b4e3d5592c22de7f5884a8585e35e1c84d7eb789f301d687fc6fe1d9b00e9d4509741b5339c62faa6bdd853a9c4d089f360cb6242289ac6efdd861fc5efcf061343581b0034a0341fd8f4bb4384e3519592f3b7e36192ef3b9e4f9eb9c24ab59ddce950a091cddf89610583fb2c81bb91f4c93f2de4ef2c8c91c1621e81442a15ea5e1dbcbbd3410be0737478c2910e0f0eb6c2c5b897c50a3f45329d32a4aea4f31e48fcbb98a2cedea5566351fa933969230756e57402dc2f41d8dedf5287728191990798064cf9e305f163dea692358c76d786746c2a2be91f1a888f35fda61b1fda865a0486b575fa0c21737c522bff19fafd6c69871ef645c1434b375a694a30d1200a79972a1eec714417641d444b723864d5525fdedd1d95b91a3fe4e2942c477eaf4fc87f6543e675d34639a7f7eb5963b80ffb92260d5d8f0436e53a847b0548516d61ddd268345cae0aef7e8bea24a11c87a3635a7fe3701102a3989f85d025f8bbaa6beec123a0b09987ee90d962c709a49f7900daed024a8c67256fb373bdad21ea5240b77aeae1d949218d1fdb7c874d36fba08644edb6bc78087b6bb4b977876bb951b303e14ab37d3f0a2457699f6ab111c3ebb0da5d7b206a4b165dc15fd573c9a71b842ef20f6a6f8f509e3658e458e5f071f87148afa573681d347c6cf34ba9cc58c678e1d659daa50b778abba1739caf80e6597e41504a59e60293a6c93b8348d3916820ee92a8d3bdac0dce8a4a618880403b071a6918a6db8ead15408a7ca1f3aca6b6415d00a2ce03689b87255a04d9cfbeec203804d863a273c23e82be611fe1d9abb6020a99a645432a814bafaaf35b8b343d043776e5048db4ac69710fc1f6a90834c8f040ad3a45815e05890236ac49e75817d908cb7da2f37388bc3440b4c0d4a5f9d71f4ca917aa089b10950b89a10e59b711167cd55a887927c85704e3c317f0dbe9bfe95b61ad65556bead8bb3bb0272d072960d45f7aa88ebd00754b5dd9fdb74ea7ee19ca905f7ac38a060bbed5acc1e4c8df4256d1e704c2b8fbb33423b4d42e5fc1a9fa5ddd543ffbfe3ed385cfbad07c61e6ea961dd2ff05fee5f0fcfd7cb070ccd39a1cc62908c7271f21c97862f2cc4e89c1d034419d72e6a73a6dc0f5fc61756152d304424575e87551a88fff73400ef383871397c4841bc2ba7de5883bba2619c98c7ee71f8eab070a2bfdda7a6009ecd9c3a21c9bc505fe1734547d950446c5a84e1c60be99d79ef559a83b30b5a83c6b8dc91a4bbc0c22f99af51c31c53d2b9622c6f4491ed402b93a7969bdc651aae0ec70d7fbf199f80ab8b0ac388872143c0e64ece8a609fbffd658ae481b6d00e0e97f9cd4ed1246ef956e77d1d24f47411dde90c5b8e0516f362e50f93d6504158bdeb1fe37e1d5533915c3252d3b8e4f541c2805dcc0cbb061e198f9b39f7f24 +MD = f054933142774856dac63b63f175544298a3d36874bc37650a2682201f8336b621cbf9d95c87a9838181c1b5c015dd0c08723beb82830326382b5db51ea9283c + +Len = 36664 +Msg = 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 +MD = 221ca8cb81dae78612b8a7c2ced624bcf7dcba005250e194818805acbc64a41ffee4403672405ce5e7e81751736ef1e7addcfad82509ac4f0f5ec6100eea39f8 + +Len = 37456 +Msg = 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 +MD = 9ecb44114c5cec8af0b3a10498d7cc4e0e60fcc3b5bed7d5f7df23ca7269ea002235f97062a6ddf3d8a42e37e48122a8f869007da8855da0bc62468b53b8fddf + +Len = 38248 +Msg = 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 +MD = bda8abf3e35a759b9444370ca91c0b845a93de37d4bf5b814bad94c6733fae356a3d90c779a4cc9decd5722a07373b8edbc42159562a5eb764962b9541ce784c + +Len = 39040 +Msg = 9c8b9ac56e6653fed43fe530cee77044ab3ceab021f0cb539d8c0aa0d8b449ffabac4d70241bb072d90fda237c422da8b09c80cf1bf8cff3bd2b302180420978100c81d6ecd934b1be802b42e8a70be95f3e8ccdbc4d2dc390f02771f89f9fb372b31f3def2647822a9bc0d5379e72ce5f2cf7f02b764f88bfe2d5d8695371757aaa10ee558d51aec567812494afca21596ea78191fb9b0df10923a0fbe4e989d0f83a314593bafe38ec577625637ba8f40a86c715657b19cf6ef90fd5dc6eb61ba5874ee7c2eb372b3228151241ed2cd90a7b0ce03b56730118406f20c367c303bade8c64a14a244542de4784d28974af756d96190594e42e0fde06031f3e79323e2634e4b8408c2f235f55a39cb54a1f5446afe94c9c34fe5cbd1da77a5aa04d39498e8e90363691dd95879629da74d1aeed9d7896d82b1b06c3fb345b2300ffb42ee28bb092eb11796624860161bb6c8b4aa8ed6eaf902a15daead14b0160edb5bd7803a0bd735afebc769aaab0e799f4451a7159892dd692e930a6d15c89c247de971de9209612747ec3fbae31c0ffefc6392be1cec8c484d816dc759c44246f79890112221ce2e39454d0954b0d4787b54f448de72a9ff38fe49bbf2957bc377694d8a32acc7154e57142e5659818c1faa2e3e53a1b0de8f5e20a386c8a31a6bd01ca25a26f68ce5b617928e9271ba77d7a31723063b669f4585267cba72bc43718fe1ff1cd6e5add6e9ce53e83f740272156bb32c94481738d9ad4af74549aca209d197fae2cff54ded3a5cc745594dede7949a6165c355bca0b0881bb512f5f63ce9bb4da49c5a6fa48effbc2ddac8bf8c2a2f512a88f9257cd8aa742cd8cdf27ba2ef8186eb4bc0a204b3334368f17b85a508885d096017c07e28bd26eb730b58859b33243d57e568641dc930945686669dbc6377c529081e2999332dcba3c5561a54dee6f2fd425a05a5ea7fdd7684a16c916f053cc28ad8536292cc09de94e6d992e159bcaa7c1961d2138bb4cfdab8aa4e277fd0baf491841b486c26621ead3bdbe6f6eafdd7091138e0eeaac11d3edf3919523170f9dc5439c09891fcb6fbc9966c391e5607bb9c20bf033008b08663f8b126df92ef1b2c3487dbecfcf264fb68cdbab74162a35b401a83e4f53931d0f37b682b8f68d074922aa087f1557b59b9a7d6565e9c42e71d9fcb2a151bc3bebff480b5c4db8ed5d91571036844a15d0f67267bfc093cb7ff9b538fe6dcae85b4a92afee1dbc8c88fd4e7efc064698de0a81588a82dd3568cb9b776f8f074be8815a17754ddf0b51ce55f9d98295664c3c74e1cf19eb93b4b57518fb9fb98d190a69eaf9c56a92416d3529d6e17da6a2f612a9956c050ee9210dc2ab8529d5774e87d1836da54bde40b6b7fa094781699f2259e46372ce9176291e86299f4c89b57b74192dd75cb3b09f4b4ee33a1e289e6d98c4e67cfa331c92d39473621ad7a80f7ac6ed49ed4526ba8cd857a0a6675dbb0f3edd69ba587b108add4cbc66e98d098c8f9544271e08cd23a24ebf40ae43d3655930823887fb6aeb6a9af35848cd32517e0d0e31c5bfa1b7b4aee11586b87f431ec80f9948046a9d4247501a7bd152729a3def34c2b4fef114614c4c76248551938b580823fed6496d391bd10a003196eb0d31589e4eab79cc4d480e07f0ae36c262a4aba1517796f45a9ca87ec196667a661bc4e0f472f6e45c1f83bf82c29bb3353daa4965152dde901bc55d7e4b894e2ef4a110101911627517d2294389276ded692ea4a278b533c5df50329e16a86f4f0516b6096971507f7a24ca9bcb83f870715f387167d7fbe031728289c06be6af964c5b472abeb5648ea02cf34f565ca89d649038ab3b3fc95952d7a61179ba38ee6b863224a29a0b9c6fd6b1de49a17c346631600c8807689f1ab85fd07bf3d0579ac0321ec3065cebb8503f4004d0d3808ca552526759a54aefae1bc7189a61170190afe2c9013fc5a423033d2ef197c7ff7375457f3f68a4fb4043bcf9b6d277c97e11365d949c705bd6679c6f0aaf52e62330ad79c099f366f63d78c64f0bbf1a12c0e327c55b3504f1d127712503696a3ded51fce42080585872c3266ef4371bd524b1ce9e645cc7fcaba4d9497b53b34a13fab1b4e593f8ef4a64c1197527f54ea567fb279f2dcd805cdc527fff5ae8d20a703f37d0746e422e25405b76d6cf06accf5567f5f03e054c9782ce77c4315b397b5076ca6ae3d984cc4b39df8dd2839faf85664cec4211e39d113ecbdab76f0ae38977b9be7f3db52289bd9894264fe8d0322c8e6aff2e89b5a8d7e3e4a295e46f944487b969f52aefa3ee8933f2f2edfa05c2a1b2a0e3a6a9efa2a72a1a562fe919e51aa0ca894afb40d49bb25ef218f4a52f6f0c4bb8a23f8da600f346385417bf605cbec9827c0d0978b45894d9d088bc7bdec02936e5402bebd4894ec5b9c12fbf335a8f672aefa6e1bd6eb92e7c7cefafd81561e4d773707a0d325b85c7b1110a89bb43c0bb67be179f3cf87a8699e8d144541b4be1a2055a913795ffe6ae0c47452a0e16973ef923400a774455a74fec09c681f1699391934ae023bb7f7fc8804fef18ef263c010c8a205e14516ecb0511b0b860d90fbd2e1e742d41f8edeebc8f5288d6cf287bda64c5d672e2b50526435deb2097de3132f73ddd1abbc02604ed9b8650fdcb1296b54307e77046a556871440b70dc894a7bc8159cd2ec0175f51113ce715ee6c4767e018fa63e7529ec51cdfafa1958e965589c9e2bbb46ad5a3fdd022805731f561e531342361b404e5bef190bd0cc906a99d56e1c966c66ecba76a89a6cf0aa88b9a7c1c187c7493d0429ee0c8f7eaffa2042853bf9cd433b15733a5ef1d9f69cd461e3aabff3a506cf00d292a1c9c89270866c0071f3c2b3d5552fdc40b973f0f32421642b4ad45a20f67f24a4385ad21ef38ae08b7a55e58e8f01a8b5f9a3339a70e39476176795be9d3c492364d727602c7a72a2bb7d5e85a3582aee2524c33ebaa2a20cf3df47dc47a2669bc9de10f893b32d5451b97d6f148bf935c6492e5463f7137c6a9bff1e984a0379c1d00d4ccbcd871cb79ac0bf65259a4957b0d3802f597f20e62e1a0a018ba659f74d9ad12701f6686781d6eb07ad647543dc61266f323bb6e116271315efd598d4a7483a582921d3ec1f1e669e9c0e66352c45db9629df9af5e4b4be37ff07c2e49d73ccb18b6fcbbfc305d67c69ee888630fff44698d1399f0a318ffa31c3649170cc2cd5b156cc4d0e3baf43af9b58c18b0e24f317c73f47072bfcdf107f0a85c1bfbf37236d623e511e5566d58b53618aeec21e2f2808885c02895923b1011c10ad18485a1a09ee4c2c5d5864350500c110704a375a21dd8963b9fae40004dede32bcabedf34fe75fe44bbae42eea09be21a3e9c8f417a10fbe0326c9c26248aaef00b4377f80a3fce494e0cdef7f06e280c18f6c7c568d6f8ff98f4d9ec5d3d710a903cf1568ceb39bdd8c99ed3062cebc7dad9a597afd29480176f7eb9c2b03660a1d2d6b54a2048869f0c0beaaa7e3332cc6cb21d17abd74bf80514f4198b04da852cac7c0e87028decfeaba4a60c093536d875c0680ac94883dd22072b75e4608674fe159ec86fba06c6096ac17d74b85f4477e869967360ff203059c017dcdaeacf51e7c28a97f6378eaaa2c27a7da390d93efee3f8dc79b6f5c752a019f730fa672f5a44758327c57b18b672aa2bde11bf54689ed70c7cee856e5a92223a4bfe641fd6eb323a36f9b7da0c99b686522a1d419062dc0c52f0f7add95fdaaf113eeeaac37e69c40c1b6a780eff4596e5231b8bdcf7afe3e104740c37cfeb5d6b012b5689c6c12a8f73bb7a226b00648043e3bcb624f79913712414dcaafa4c419146ae908be373a948d369b2a68ef70cd39a5b85b25c37cf812e4c31b8b2857c346537419477a741e4dacd257999576f1b6bf1b16a88c4fc7abb3c9cc1b80f0233b17b02ab24cf3f8df72ce3a9c68d93637c05a211204884a5f26d868cb7f2bdd651013c9692f18a8c52105401bfa05ef3f51fbf72cfcc4e4afc6658e2553794646d51581e6a180c291400e0482c98ba12ffc872543b5642b100af788b3ae56e272ff4bc0b5449acab6585ef45b47e8e0ac286237e0cf1482127d1504f0f043565bd71d225f78e525c6c26e9c10059c22165e438b9eba248e4995346f67c9dd0673f500134fceee682526b3684b8313da010671acd80732a407dbdc44728b62775de1ab0ff0a7251663edc3e56830ee9cfed993182726bd67efb98310bbc5a22d6c156494fca207950590269ff09f9adf52101e5a0699235e53d6bf50adf8ea9d4128c33ece4024787cb642046f3f9715bd7279fee0ff12dbf68be780c3a5ca4b5f644d69eff20a355bb8ac9f5e9171d4a3594c535098fa752a71a21d975cbfbc297079a2dc380760051fdced2925a9a0863cfc13d02758ce820055a3837e396431d5ce760da2ca6d1b74495a697cacedd8a60f9cea0a9c2c7fb098bf328ad5d80b0cc2500e92c1d1012e788389f6fa213d2d0d7b08b35333761ae1ad0f13039c076debcd59b86c1058d6f0d525352fef162a6c1aa6c20c5827a7b70983a75104d9a1a14a795447cf84d638eba5b7acbbe636a2186eb7362ef6df8f512aa82cc6d4208953e826e35307d4b72395eefefc3fca55e0aaf35f1c563ad1108ea6153699731a862080ad4f643b0219705ba544856dee0ff616e5a4d83232d40a21a8f89c01cb3dacf224092c718039cf7e2e094989d0f2ca82785cff6e1af8479b36614e551206f80bd634c320e8010dc6f7df1eb6a535b2d675a92e36f019a1736c254305955e9c3e4246bac1700ba5e6a12a577ce14529836c1e07356894a25aa8a8fc7bbbc103f9e6b395cbdeb6323da87f96350bada909ca2ffcd1db15e4b18a60ed2ffbbab9df320fc6b87a9d3d3c7c435d879adbbbda2e5381b4ce09c3087fd197aaebc8484eb2cfd01fda2d21739b0a1fdcf55bdc84f72d3826c7dce7dff79f7e64f26619d8f758444a83e2897393585fbdc1ba859ac31182c04f2bad98901f2406a610b90e6e4d95f0fe69cface3a28f928654317bf0a4f419ca629ed2b7e50ad87d54a04f8614378bb00f8e801a8d320399c57ab92e6bfe8bc01e261efd65a572feae5a2ced50bb832f6020bd965ce989929acbc2dabb14aed6bafdcddf25866e908a6116f267a46fe2e83085e5a6188d0720af396436d8fb64c5606fcba92023e9753f9e33ed64ba612428a986fd41864e139f8d7943bdea00ca08854164f51b5ffb504330367eeb3080937908d6e72dfdd0072f888635f3213550aedefd97ed6a894d8665f7758ac7a9eb74d9a78bbc9cd290aff062c3cf4ca3d33d02b76af29fab81d84394cb019cfcab3d77f3a1ea81b7a67f6f5e09a6e971fac04b46f0d375ee87c96782f1f836f55d33725fcc1062ebc32e43fc5a429e3c51c91700cbf873aee9ca30668cd71c207be747306cc6a6eb612d2cb237fac17f52c804994eda1f79027b3ca3fe16b30a81d96509f685d4332b0c78144567f997884d82651c10efe97c2cfacfc83f921ff97a6a611bd6615f6b3cb496f4f2bd316cba1ee896155b6ca17fd94e6dda4fdd5d5aa5ca2f20d4cccc4e60beb92372b96aae38b85f5fe86f3ce476a4614f32cf27ead5a9b2fda507a8b21af01482b0bc2c8a7e48da692d8d88fb51664536f161e3bb488449e568ac8af831df99990da60cef4e1e89b981343014e8188c09e2321b4c9cee464086080d9153e1bacec003963d36ae0fe989efacc1a91fa830abcc290f314c4ac783b68b0def8aeaacae515304b67bbf41ae3c599212f01c53b47ca783b422d9c2f844adde634fcbaaff1bcdc64c0c2a7a7496e106c44e7aeb82e0213a740655cb4a1ec0735db4b05258cf510265e3d3fc638bbd802b6f26509d72f0a42f6b4158ffc16d7d4d3e4b3b31e89749a2774e30018769aeb6f6b13b6ac1c04114c64ef49fb92f4ca060febe20f41afc704aebcdc5265fd30559adf471390aa1e2bbc11690827081f5a14d538c7e36ab6dd35f2e24c51aad852c6f2457652a4707903a4778a9cb8dbb93a9a3fae374c6d9b4fac9a6f0148eb4d3873383c2b990f2082cffce9baae070aca627f2c07fef62445128d233f80722d398ba6cde331040681bb7f8c4992ab350c547faa192759625f4e42d1d1fa73dc0f62199142155615478f88dd110bcd214899c78e36709c3ce48541df805df941021f18f010ed0d331e749f43d9c277b8c658df422681c9991ee213b7145109445ceb2c521460324a4c924d266b5fb0e1cdba502cb101e763538a3fbf5580adcd63eddb1f1717cb411a1019ee8d898184a7e7a0b69f99ff81cca84d610b8fecc4614eb0bfe1bae300d0178c0408e8f08a9a065a47b7f018dbd162c604fd29cf119c35309a3af07f6fb6ce2ccea32508d9ef400346c2af3a59a9e0310ff4f45c9d5dcbe518ea61a976145e84b528e8ce5aeebc251d897d6de39e4b16ecb8989d4eeb3756a2b8b668fd31ee19225dd84cf5dea34733d103ba61f6cbfd0211be9a0d90a20b9e6d97c5ec56a7757b0c9e8993091cf2f065e828bbfa876fb9c70e5ac392348d76d1abc62bcbb11f29fbe28d1ab550adbc0cd5c0d9f2a8f379a12fe5563a146390ac9b76a2d8339f95f34b61742b6600ff8d7289a3265512aa68ca43b0d06b1556c60eda3ac5557e26bb810c87b3877321b1668b02ddb753b4e4867db79c602c2ee7adfcd9d94143431d2d963d94db8f8a405acedc61f63e00dd0c9955e51c2f82d620e3685d1c7656dff7087c1889dba302f55b1bf8395bf41b03a271f5c7a6b95c0e97d099119fc6ca86692e85bae0d2bee039a5eba833f965 +MD = 64fe3513e438e5e0a977586a1780d30795367d6bd622386b4fa8cc9a91a88bfdd5666a5a39ae2a9f7f2ec67943edfddb42e96e5ab81aa0cdca312f9d60f8c9dc + +Len = 39832 +Msg = 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 +MD = a3481b7a56b6ac361213e5a69c0e99594c332567a0cd5181992dac5ac6ff236766768e75968685cd44ae68ba7a03c1d1471bdae070deb899cbfc1690d4a69b47 + +Len = 40624 +Msg = 4bff0a260be42b8bc0585e920f78107e83b7c26130e8c4d7979940f4caa37b7bd1ff58514bdb1e3158ed7aa0b708c8242ced8eb1256349649c8a6d743f6ca765cfd5657ec665987e3ce3b88b0bd4096b324c1ef677059bcb51ae3f43048521a30e283996c2a823da33e0203953055ebb5c7e791a6ff541767baebe4a6117719f56a1dd7f88cf46ad048cb993d7c24c7c7328a703555cc3cbe531f2719e4a20bf6ee8582360008a5f78918b81de345d1640f5b19b7161aa3456e0e4a10245b56d20a4b2689163755857949eecb28218f1888a9ec80a2d7d1895639bc0d631b810327df438652291006940fbba99d50575169276746ae7c4df6b611fb76235b10f6d1d257a226266c0753aa9d5dc55ad0bb1b34186d7b808f0a082796fee7a29d499294d16114e7afe452db023c3299719209508e69ac8cfb5fc6fb0cfc228a8c67e4c74f37a0b58239fbf198e957a4b092ce1d37cfb3ea49547d0ccbe2666b44de32ca3fba5c485984c98ebfd9c6f52419d3fa83041420cf8484cd626615cd7d19271e215d99f8ac414612e571e31332b3b5691eab6fe9146c88cd5eebc3398ba51c4372960c4f00ebec2ea8664e7762dcdcf9592a097bae88f38d1fe7f137f71e9cdac20805c3fe014622871b6baa4b11d51bc1048380f4465f7d23ef223155c223348e0828ffda1dceaf0005bd2441ef1850f4cf60719c31271e1965c8ce1e4c39e1352ae84b4b8df01481b9d56dedc1213952ef22c5fcd5d4f05ee07756c7196b8165e4b64eb8fe5503aaac26ffb5348a2579f83d06acb0f39472e39073c6c612658eda3562b8db67fcd95134422eb5ada5b85f21bc023f0d6ad3e3b6adb3bed93e1e5fc83fb1a193509c4d8fedb0c1265abca8834eb3fc8cf420655c5d14802a5ba309f13e39ed71af72059c4ae1e36e84f548a4473855fcb0b6ece40a4fa6704eab4d42d6b81b8d79e8fddbf24898f0e4d0d4372de5f7d73125ff005deb8e659795be2f91c2c841407faae16c4b5e57cafdbfae7b634e96f5ebf013906ec454c700b13a07d050378384a12f2160a00dd7da8f6ca826c6c66f7784a07a5fd4d84d6aead4a1775fdac3b65527ba3f1a7d7bd5b8044cb6fce01e67013954253c6aab32bf91e70e539581835b6d8f2d0a41279dce07d18a4d7e73291a40b65567865106a3f4512bb8023d5a185328c10bd37b8135e9cf1754ec0e3c14492976e2b5ef453c7e785619ab57c9009b0f71abbee83e842cade49fd3602ea3c525e03a63d67ced82a4f3d4fb714ec887bbd5565dee143d32e6889aaef95f3d572457db2a971c3bb39fab967d1a69c4bba652885b0da0c5af1169b1e93a7c4541ad144174a1b1ab93a0e3ba9aa39889a9678fde10c762b1f3a71e821cb3d4504748cc09dc96cbb1856112ddeebd598bd377d3b4398be886a3200d87b3f615e2ca5fd590bce6d8e20b48df6ce3b82b4fbc4fc4971ffb90b83004bd4f3961af713d8ac782b00247c1b7d09fe414349c49d667e9133e76f9db1ceda42527871f802332283c3089b6b4fd80eadffab31b0eb448a7a53f9e9243ec1368b608f6c4941dee6e49c8dda4405ee236bcf1a43602d87a86c97dc2e897003e618e58016d2180280017e38e7f085e6d0a07b3886bcab5660cfc93846b590bc7250a9f6747ccfc7794431b1cc5617e99db4c9ae02adadda3b0cafb73a8fe513639a7397902dad5458147c9f915d031f130f8224bf197a3ac08912ff11feb9313f600d0b71cefbd2a5d828ab3cef90afb9196e41c6ea5b9f78afb9b8d3ec523e91093dfb1f480268e9fafd7cd7f308c2173b54ae1e069831e9e66e8b8940f961defdcc0fa381073faae1c3bb6950b17fb6dbfd13cf5779179d97f71f3ae2f6c2b0a382ee0463557e73f5420ffbf0d40f1d633216e2c3457a1c281d1eeeb9918a8e6526414ad5334ec99e422194bab899d439b9625e344681ec03a82dadaf12e101aa82af7dbee8d736448a983c96a74664c75a9d4b91c255978e60f680abc0ee90db5ce1a608bd40414fe31dfb6ce73e5473df70b1c2021da5330d216e96e5dac35e7d7ecd9afab273271558da24c1a82ca70e8299ae4e029c5976568056c7cc229cad2ff85ce7545234e8f0e0a77dac75cab17c0a3fee2c0667643cbdd4aeed36fdb39c3136cb4f68df248e16db6374b6448e050d5c29c26ac79f7b2df8e46586ea596c7f10f0ca3d8e90d982a9bb25777c6ec6a9ed48ed51e0efbcd8abb05b9ac96548ebd29cee57aaf57a2ef9ccea41dc1866e6db93d4421a1ca7c7d359f7fb03a0d77b6418e3409c1b1822b4dfe99acb568ecc0c52a0c5ddede3015928633001d2c239aeacd080cbca5c65c03c4a0db1eee66469cd7862912b198e2665c4c12ac3b02d999fdd9d9ecaedfe072b361ff7a915b5da4c85a29e9ef07721584537e53a4a5e0b3b34217fe275f870f4d55a034fc4c74816ee0c6d0e11c331480b199c0138d4edc6fa94d5dc9958e2de4e453ea89aa39974dc296443237a407f41efb6de219728895a7c077e03284732ca68107b4050b7ae777fec04cfa535430d429b9aadb0a2cc7a637f915b708639704ce2925dd6880ce6986e1bbd4af7dd9798b2fd852645d782d0a4dc4836873869781ab39a3ef6d552fc504e94747095087c65ce5101f8f19b4cde297384327adc7422a79f8fe853e231fc66fc2887b288731bd7b849a263ed5e953e84616f46f2c9603613d145ccbfc1d82b9f70247e3e073dde63072d769f8e31e422d626e3d2fe3e279f0df78910344e6422532f3f53bf31acfa43806fd9641ae3f5e93f9aa69b2244ea4ae5d2fe10c4db30da913eef23600924038399c569b903a6a4a2b3932976539d90f7efb1dfa4566f0b30c338bc32bc89511e3b8824740cdd0f3776c32fa11d5fe715275028559e87f0f5155911108fd234399c4d1db4c54131e72a5e350b6ad95827c304743f7b2191c87e78ab6048a7b5bc053adde2f77b1298198bc31c02b2ea150bf44acab4e5f49244be108bb0afda8fbe77eb646a33ba338973623cac93a6c74749325e137a2339b052cafa8f93ad9b0f2dcfa4e61032a1c33e99d332249226bf2ab4635e8926a70a5c6114adfb36c64084120833ba81c80f13f1495a0cb918bbc059415eb903c29a065b40d18d7cf998a33bfa18daaf92b41af106edf420868232a860dbb3c474a77642e8c5f4871d60b3d2e15f18c5e6fc7d2172b283d1595da92a299d1e71a47bd49d734fd65f18e1db6025ce1bcaab2d6109f67362d377944d65026ba3103a5c49f54938dc0dd460446c2d2e8cc6cb90f032f8f6382eca6f45e3540eeaab1d93fdd1d247ad983728157e634612c12d6d5223e204aeea3935ba2c884f9a49376817b97546f2082b80771e2ee056c4b90caf641a656c10ab30d3c604f45bf36f22bf359dfb526597af92d5f6c2ffd657b42e7e0ae119a80aa6b93b32c5d7b0ad0b1fceaf3076b862fe8d2a24b5b600efaff7f818405db83de09313798cb388d9695c0b14ab050976b591a61e8123496943335aae49e24a2c268ad4400f9a83dc85a1753435a85eba1cc5cf4deeedb9adb90a2d33c54d65bfc0c608f11732aa9ca71492779507c1167a523019c4bd58a459a3f70f7d4912def56e36f36c23040217dded4695c93972195f4eebca3a2f346a2743a9367c58710eabe7aed61699f61c250b07fb96ceb63f15b329c90d454636bd966bbb8e3f6053a4a28a1db37261ff147624901889cb359ce63d8adda2c3038e7abcd328cf930c82efef08a1962909d1b5031cf47197431b6f8dd2534f911ac2760445f211f2816c564561890d387f85500e67d58f03b0bad7836c17539ac38013acda930c66fa8b60f4ee12e074ac57cfab3861e9f7c6a3a4851fd0b6c445f0d71a5ab4c8d5be06946478e516c7d770bb4458408a5ccbfb61fdb22681f9ea3b4cb78dfc4e2916067bfdc6a9b71847f79c40901b771808ed9352eec3bb20f889faeb3a14a5484ab39b28a207cc4e4515f807a69ab915c59ec4ec9b4c6c21b801681f2ba3d51ca2347f4bd2a75c5319f25901626459394a397b33816c9ce472cc1eb92652e78b65b2acd01f306f0e0bb546968e225f6edee4418f67c954506e11a423f4c9e27fdd54ac1d514b0d676387482ef07bd19bcac79d68160b9b4ff3f983c35dafcedf5043059c309f3f46688fe6315218b9a8570c172657db7ac94aac420328acb49307a642b383d50c9363f6a8077aa01e7ccad83731f0e1f8a4bc51694a1f6a9b824aa6e8cc14947d369ce3161830bc09016e5686f1a9c41dc98f1180ff088e8b96616b814ea98599185b7fb9cc3e14811e8aab8bcf4c2cf1200b13108cacc38cb6931c95a10b4f681fe8f1188c6b4f8ebb6502ce319fc37d917a80a058d3afa7ca29e2aa2d029bf2348a62bbbe7e1638c14881d8806c2ec805227fb9cb44fae3bb6be44a59561140408bfa2bcc401088167b5030257918da624d39e24dc94d496fa14bfc8fce58592931e0ef1c79e685a346985e868e27bc9241d5a3462850dfcf133e4937331945d9c53d8f18f03f3850f181eb0d7503757b467c841e2aaaafc309e6b7b74dfb0d368e3894266fc4a706c3325e21f5550d07a6560e3d9703c134ca6ad078e4a7b82ad6fa85b0bc1ddcab05d43f29d5c58d1da78ac80c37051b089ff31ce2c0c44e9ce3abea1da0f1df28008e178fdefafca493413bf1d256c729d0a9225ea8fbd873ff714cd5e3e8b666f9896dbad89d6286b0a2ed552f9ecd7da5b36a5266f45c99707731404dab6b4c3becc9128b55c8aa47d668a1178633ee653a7c27c056e5f57ee324c6a6e206c10de0b3ffbecb35f89f04343b52b503635a65e1467fca786f73deaacfb5358dafb68db4e93ba7b1580255d78da8d545c3ca5d20156bf71fef958f4dc3434a0afd7f1a5338c89044b2b6f1dbfde18bfff8fe49c1fe4b86e15d2e1f940a18cc8493b0b019542e2ef7ee04ffc8f5c4813be93e524c68e81ec7a184b5070cfc61045991768da6342ad1f434a724dc1a5f007ed2a04abb0b68d7a4df7a2f31b7b1913769953794a42cdaac8e13791aabcc579f015a435e7a0b1b4c899693e21065331582349f8745db1bff5a684e173f71463414a9bdbbfeb09b82c930bc85d125f2db227c4ee8dee09bd3dfd12c3a9ef6d82553b442395eff5e2fe6703084c098d7719295cb1d38e2631266749aed8f02125a06a45940649f6c39297f7945a667e9bf1aa69e901b8a79a237792098dc3dfebc75a08b38d639cd8ada851f324a3a31ad01d750a74e80e76d9a0946a14b51a331e8d15e897d748a0841a9a8b176b7b524915268cc9b6bb559d74c9571a5e309a2a65e5c9c21f9a99da5149e2cf0897f0a103c6e66c8f4e95035699470b19e39f8f8700dd78a6f353050ee880a81569749c7c0eadd9ec28d39fd88cc0639273a19262ff8a37f7f33a8885eefb3f1c703c7fe036598e57ea8fb78d3c39c032914ef78c2a569c9d1adef968c5a8f0883cd6efd30670165cf4380eb700398d94ad06135529c8f300caaecc2a151068e33fd240b6d767fe55e65afa187146481327556a706667f7cd9338753c55c804a7e99d371e21c7a2fd21670e1417c66c38a0bb814078a9f75df4fa8931f0465050dab6278b9e05a09d45eabf2c5c50869fa9b6ec57c9059e3c70637c8d8d01d87873ab965174a883c0c46481d3c76b139292b60028e01148d38601c3b17491098954fc08326e36a9021d530aace18c8fdc0c676136563373cdb663f3405f5a600dff15f190e3269ccbc1449e1a232b77b6671983f28412cb8581f89faca5e48860c287e6ef7c0eeba84097c09e14ce57cc436aecf00205ac95694e0d78d0c5cf4c4fc05cb08135f2022beb26cb2efbac7821ca00b148a29377dcb2e1176864c10b176dc7869b525c73d3bd1503ea19e26472b563b8d0601c976ce59f1af547ea3799debbd432ea9777e86c2feadedf95fbb6cb8a7921d4a48e9a54abf5dfe5c74c47a1be2be0452f78ca96ebe2658333b87e6af974c556c7d7d56eac3ab0c4c4d3b13522e01c1871111acbcd8d16cb48253a22152e239cf2ddbeb2045bf07b8f4857279ea35ecb28bb2959393d7b0e5fcc6a6f8217d4edc23ab6bd38cc17707324b9f795f810e3a2e196edd3860ac2c7089fc1a4c451ef92694dfede1dae2a1cf35a038d20eae87c2ee3f810f93e9f2a844ac711b61308ffd3e4e558c31d2ee93ea7fa08e0354010fd80e676099eea06a9ebce3d5fa0c077152c0f3d5f0ce5646134498da898910dc80e577739a439c7f3f365ac4373bc74a783eaf033c5f41af57f507fdc8d31cf38ecb998fbd7150afd021bd2e4144395057ce7160400b17975f9cd740e7bd8d1aa9c9b5fe2aff22c1f986f45c3fafc44a987b2132215d40c6d340efeb0fcccb1a79e5b3060a757c7f616ce6965a05cf02e24aa7c20ada24045aea3746678a3ebba7297bf0855cc5afb1db7d24baccc43ede45eb58210c2b199ca19798187e4ec4db9df504c23b651a90dca04d868f0ac73473d63c8e7abecc426df72b493064ffbc480a89ea9ac488a775375ae7d309658bdc4eb57aac43e6f4563f452329e632f332a0c924014ac19eb02b93042229df8b893c0c0d2b24305965572fcef03e262863a00a99f95f8c1c9562400603d2ffdd81898a6e7ec76f1aa12731710dd2a302e4f39570096bb2c92bc5a914ff6c8b29cc1b74c62d966ede13989234090c7129bc7fb2d2bad6fc4e7a3c16579d5f4c1673dc153cc1f7f44ec1909c406b535746f32ea8e793082f538ab0cef665130a4d7db3b4f9c154c812b5f895bdbb0e1e0192e7c1d61c69167f64071a1adff18d76f2879824b514b3d1f7b9c6d382a78e019f9143c8dd62787b0f2b42eb945f9c38db420ae6259f7d338db977a846856fef251677e45f591cee93028e900bc6013b3fcb52679a5deee281e2f06792108972295da55329b7cb81f9764532cc8f8228260ab8ce9cb6cd83db1b7836ebb0a433b54e153cc3e54ddc486eb1f86020e8a798e78444b112e4c1a14b583ddbcd87d9d0d10ec8b6496aa688d1180b4ee3fa5f9e4afdf063d9f941dd5cd9a6e9cffb0d83ceda1f894dea88c189c3921e3e82f93f1b6cfb3973d5ae963541969e1ec877d52dbf68c4589429fc7dfab6599b461c8442198c +MD = 08b3276cdb68adb64cfdfb6d54002354108ff18c3f901c1fedc48b5a44c81bbce19e2a231a319191fb5b9652bc43c20d80ef6d438f7227e72ed57c7fbd9c79d1 + +Len = 41416 +Msg = 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 +MD = e0c80702526891b3335d5a0b3180d47025a76469a296e823fa7d7228b9872897799dbc0a1252c7b7e89043eff1bf3092ffe7b67870327324cf95742fdf0e4122 + +Len = 42208 +Msg = 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 +MD = 8ecdb553cfbe2451feb4b6440056099dd6511faef2ac7ba92b646c061be2857c5bd09710aa56658d4e3f566850b680b23f2e01344902fe0c83e8d3c8714c8fac + +Len = 43000 +Msg = 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 +MD = 49e91bdb49492471e1474a3934cb235d877451e4eb447fafe3a01f6948e06fe71575eeece2e41d9634110be5369199458c4f2f68ca380079845138ca5c4913e8 + +Len = 43792 +Msg = 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 +MD = b1b2dab94b3db9eeb1d579e65f06f07004b98f214026e4d53b36917808cce2f338b6d195287cbf2430f3867bc1fd5c1a38a4cb3ec741521da718e2ca33c9359f + +Len = 44584 +Msg = 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 +MD = b4e49d08be92b07880b5f9496ef0974a09f44d57ae3dd5ba0dde1b498f09eb219bbf3019dfb28e5a4d79d12c299462cefa246cf4a13fbdc81f719972065d3ac1 + +Len = 45376 +Msg = 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 +MD = 19cf6c6dc28eb06cd9fc0a58c87c8af1aa605ae7fda192ec6ea3c12ec3b6dd529d22c45ee32a00597ef615af5a8e790d3902818d1bc3d33341e648b349c5377e + +Len = 46168 +Msg = 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 +MD = cd200254e5a8cf6e0923e70fc2cf3ce26ccfe07366a1c5e14944959078dfb803cd0d0289132a45bcad2bc290605f33e90184d306f35f0522e3d1a315da594bbd + +Len = 46960 +Msg = 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 +MD = 52ef6d43536b1fbf828b21b669fd459acd71e0ed8c67b97e9a7a79f145cb3a5210143d692ee36db3a09ddbd18bb26f8c50f473919e38e07614b8a0cff6e11012 + +Len = 47752 +Msg = 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 +MD = 398b4e5c2570d043e9a4a037b0a01be41ce56d58a26a6014ad7dc5bb435c86b4f8e1f8d9673b0e4a50e1e548352475af8b1081f3b618274a77182a49a1d9e877 + +Len = 48544 +Msg = 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 +MD = f52e19999a5773b270b3ac58b152965e6c5b37ebb082d1f7a6d723ca9cca7e2faf4bbcd94ec326f16d350592ca7c3210675ed12a03b559ba66f9e681dff9ae71 + +Len = 49336 +Msg = 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 +MD = 00c0541af4657e4296c95c076cc0b87504e771aecc78e2259b3dee92b0ef30f59025653b8119436a86aba5e7b2155ba2d112532d3542f5a9684a6277131ab387 + +Len = 50128 +Msg = 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 +MD = da9436bdc81dc6aa3be907377519049371e61a409f850375d3a503060112f0eacf8539c1d98cb3a302f9c125c78ab6e3a3e695575fed3eed2214a0b9e3fc6b51 + +Len = 50920 +Msg = 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 +MD = 3fb5d3d8d7154294799650b12df25c71f508c4b0bcd4da2ad6e57babc98439a1fe21d4ef57c7c0befedca85d517fb9c5d5a705ffd90b1a5b9f1717001c8ef547 + +Len = 51712 +Msg = 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 +MD = 1333d76d9642fff25a78e1df287d433bf30c61c2157870e19abec86524bc248c974a61a14546cd6edd382910b9f269a913b09f72f44534797662d3c4409e5701 + +Len = 52504 +Msg = 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 +MD = 4bccd0e158f345b34d583f929c0a74d2b502d3a8f4112aeb8a3e0e253a817c52caa947a62a4bf857d1e37b3fc9a5dead09fc2266319733ca2371051a4e358e0e + +Len = 53296 +Msg = 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 +MD = 2d97d18d0b70ab231a0ecebed1a686c739914673521ed64ec6e27c1c78e2000981df932439a697743cded208f736164468a1a53cabe2b65b9a0ef10ad42f0372 + +Len = 54088 +Msg = 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 +MD = 0c25d4a35196e3771cff30a7452ab30e68d71726cf0ab02aa016432b1d643dd975e0702f458086d8ef7a35b91d9faa6d29e7458840e1acb02e208b3d79ece077 + +Len = 54880 +Msg = 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 +MD = 7b87a9fb861a84bafcc146831ed9a54fe3512dad25668512b17339175b0c9523596209336b0ed0cde5648faf6c101043ba3a653bde0ab8a8c3959b33aa9f8624 + +Len = 55672 +Msg = 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 +MD = afbe632820e278b633260ee86ea0c2a88735afece12932ef44d5e762168bc28530a88bf49bd80ba36ceabafbeba7fea0ba783398109b10bf1373a3316e72ad68 + +Len = 56464 +Msg = 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 +MD = 6be720da8b47b9ff169100d51bc971bc9cf9968cfd305c6bc4b34f9fb233b3dfd4dd0eb59def8f329fb60a32be902dc8aa3aeeb8dd7c1896d0e0bc30ac1a007e + +Len = 57256 +Msg = 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 +MD = 2e232557233b61c0aba3bf10b0cbbfb953974c8931e639b6efafbac76320ddd47100ab406ce17e216463658ec43bf0ec8acc2bc3d076ce08283477c5f6149ff2 + +Len = 58048 +Msg = 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 +MD = 3844eff6b7cc4eb3daab90181ccb8947842e8c702858e59089f96dd95600b866ae647f9cd9213d726b4fca636e6166a2088e2be0c27154c28732faf360e30e8a + +Len = 58840 +Msg = 7caec9d15fb000b65233a196a792aa486deec990e7d172e53d112e7770f8367093a1407a39a599822af874bc5a0d82e81b41c2d391769b2066fe2848c0bcd3e07085251b6dccdc8f807f3e3c402caeca41687d12897102e04312edf7b8c7d8567a221fbae26df264bd91a81c43375676492ca154b70ad0ac3b15268c3f636e5b1940d76182d0028a4af65a664a75a4759955d6a203892d0db6ce7a0d3fd6bd76b5a6f417343d35878d76fb223c2fbe4e9babc6035535408a1c0692849f69ec2fb61d1fe5e0fbb3e5f0d8335603adcc89b5f6177f955732abd68515f84764230e856d00d16e53a32bdae6ac0c8637f7af51fd711eab372af84a13ac721e0f8c9c885e3ee6c78d2de2b3660b4bad156647d6897de97f1d51fae178fff90eb14c6028b78229d1f17b91e221fb1c608e43d9ac62e2e7f951cf38037bb595ff948ee2cd4273a475c6b2c0d1df228587ebb3ed3b504920021acb3a19e6764ed7fe78abe0c5ba5e9c56fdf8e76828910a75e00cea1b5a9d80c26d89897fec2d7f383242c709fe5f2ce782bf8c83b645d171f2bd238abc655d8fdfacbd0fbd39df8ae52fecd6e8b00fc269a028fa74abc52a11894e6618807fca462b1b5d917bdf3bb9fbb5f420582b2fdb20239309cacce763f7d17715f7d0bacd8f0d3311f96895d52d8c2a4d5f6a7500c9e6171eaacfef138f15855cd136a9995ffa57e4bd60de624dd84117ceb2deff22d74d5a54b78b47d9825894169bddd5234a92b3cfb15f87e4010228acedb000b35fff66cf6a03285e81b766cfe69fa76464ac263541606d796f32250102342d05e7f3e923d29fdda5786c7a03ff3737a8b26de4f9fa293b94899cb9d5d9b2ac9fd5f28c59d6a78e36d03d77baceedae7a9b9d9623c2011abdb9078a315a72a50992c4f7785d62659af2f306fc3a09345f8703e3b98332327d673a401c6dbb41cc8731d188511987584456ced22dd2f0e1de6874c52402aa5bf9fe849ffad7a76f1b01c29299141ff8302d78438f910b870994f04e8dbaabe0d81bfec1e90c017ab5fb749c1d9b53031d42ab58468fadd96e4f005da6a15c926c59558a22a37476bfe98cb1c5f64b00735b10183b11fc6076614cf95701e6fc1d8031028de32aeaa091b5d6796c307799414e8b566223a389917b2a882070a354573c3213164b5ec0bb951521462af0f9bc0eb980c9482b10a836f82148231177a71b219a82fe5a8731d475a5cd60f4fa93f8ab9f8d947e716f246c0abf27cdf03879d70b716c675dba1bffed46fb0a0490b3689cf72e2616abee8d2bcda35f25d2fc5d4f29bd0caa1d12b9e1fc22bb7f79e8f8604f3eab65273b646cbcbf50803d4cba4cf318d2d62360ad6a36fe8ed3173e64d2ddee93c8aab4f7b6d2a526674012f6ec16a5404994ade36e3bb70b69325eb3d9e86468a6fb0150ef597a6c44a5f61a16dc8ede6b38a361d65474baa792efed5fbac8b167e3c977019769a77e329f2db28bf834a5d6e8318bc95d24f6fe9a1b4b9943f7722ab472d2d597617db0b637a76c0dcb5d38245b74e29cd0bf3f074385cefdc131986c4b4c5a2f21a9e6e241dfc7f52afc2400e578e75646681ddd70f4a01d970bf4960a567057706a9ecc5141e4d8d9eb6323d9811fb60f5b60c5a78259cb016808ddb5d75d37d5289e1c72b50add6191bd373e76d3e1b2fed066f216403188b09ae656b96af9d84baf79a923822c4955f9e11d3e4b02b7bb356958989c74b34c735cf4e3dfc2013b998b007395ee19a1e1cb7dc3cf3fa7f95675e2f1b6bf0ba25be5983d04bdd96024fb7e8d884b5adc3b9d66eca7c0091ffc339607d638171b1a2949af200fe72318712b5aa66a936dd0fee1a11aae6597ef4a7ec343075f1f77d20f217de3b3ea3c9410c036744cbe6897f4ca713144c8f763a20d47556b173b85f27b615fc61e590d34a87f900d36cb10aa50f5702c1adc2608ce284ac4692eecfba515aba7283783a0fbcae75f3dc0100819eb94a8f5653abaec2f0df17f18af3187e1f0de6e9e9f5a9f5fa1c93b103f180e9ec43dc15c48c051a4c77ac0c1769d0a0c56f45a56096c7e86e5d4988347e117552975e687f720e3cf9fe893f1e84514e00470532668dd7f87db06bde1cd6b1d57ebd7ccaef0e48cf7bec1626fad338ea323dac0d865b689a9acea10f27cbf06ed31ebdc9bdb1433664b9094046e6f619edabb0b32a7fe86368005fa7ef9e4bc5f233a7c155fb6c0626fda9178d3ff7319529a9bfdd7bd5d747ee1e44cefe225f5eb4b15e324d41a345229c09383edae5cb2ffd8009cfcf6accf05342504c22bf7aea610ced3752b241b048b1c2741f9ae23722a059fc239259af954d1e08bb5ac97d4d39e14a2da79f3f459dd66013b59cd7cf9d287170e290846aa182c45aa5dcb5cc81b8e620f7d0180939ce9375ea3d7a4ad31fd035dfe4173a0c290f8f45275c6560ceabdb2766e309f2257ea49d56a73aee7a98f0eed6c089c96b3ad7ad3bb9be43bcfbbacad618ce6375923e436ad7065bf32c2093eb28d085d3e6c2428c562dc6ee665e36a031dd0a297e91710c923388041a536393a8b4bdfd83bda98bca3a56ed7c240f57b6ac62db844caa9e51490f17d3e7d262d8acde42a24846cc8e7a70349daab95f2fb2e9e653ce54b2accd6dc8f97c74cb210f634dc2e0aed10b44af4e4b60d93905971be45da503cc0d270071eb8faf4f2a72e9695615460bd95f60b515d4c377c0bf8550125f4c4ceaec83ad3a7006614d6ddd4fdc64b10f60f130e38d752c9df992a2b4026b72d7ce9443f566ebfea41266bb4bd64d544e4ac09c6402d0591e08c6e07abe382bdf40a4edd4e1521c8a11d40ff7d44db43aff340fb12664fd7a86b2eb3e9663ebe5b994ddb63a20d475b45c47ce46c46567e6c2175568a17e25ebed1f5a3b7d176dc1ea9023e1f6ab0982660f59be6fcc579a012fbb3a245fb2b0ebf9681dc252e9c22c91a8793224b7f467a304abae7d8ca167c57d1b5c06a37e15f5e2adf202dc62d17ebe5071c60392f7cf798eeeed79656c84f59cb7277a9c21b1447c7acbd80c5fa3c01824037ed69cc102d8cf80908e95cacf3ec426aaa365a827f9db024f274dad6830c7618c47ad443b29befb74556a2354621188a61c7856e7b6813ab46c1208212ada64ae6ecfa5acf24ba29782500b4fb71dc20f7fc02a1e330bf9aa1343206566eb8167a47a81b2b2e41a7c7dfe0efb9e57674935d3ae35efe9b392d56792af95694c4a81145506fc16c795a0ba9b02984cfce5e7395fb94d98fcf12ae5db8a06e239c9ad439bf42e523e65a31c3bdf356cd7680c57cb32ec983a678c54776f5bd4be57517eb314da34e37efda96debe6359b320dc55d1d4d65f0486219d2ea04bf5e96463c56d3802d5b5408d8add32b45ccf663e891e2d090b32644cc8a649200aee8d3f2e3daa0ba0a576d20781f850bc107b758162e26970783bce31a79745703d18338e674bc59752b8317591b83f63bf8709a4659afe741d332d3ff832c1111e2ec74eb4c438a3032f333cd6198a3723b18059eefed1006b73f35963c39cd3d8f784d4ecbd6caaff035fc418c438228622640ac7b6e9fda824a7e9aef2dea0b59af189d7dd6a958f5b3d751e61510b2e023c1eb6694f511d6dd256a266905ffb3f97d53ccd394dfb5f56b8b297ded9647891fd84bf09e61277fb0807c8baf8f310fc21e535e1b98b3931f39a0ee57670acea0ff96221a2cf69aa67a5bf6252e532aad398bb6bc0870e57909f6f71c99ac7cfbbdcf79e6f9b6c68db43f4925719d029551e0ade4c36094ef5896287ba2af1c86cf7298934c0a8bbccab0e51eed610ff0d3fc84244e14fa08c208e313167515e87109de9d984442ea2a3b6a8ff661ab665c29e9f8fd00bd4bb2c9c76169b101875f0fec645306946c5f4949d730f17d6c37133fe174b6373ec74335f510c557f9e5ff229620b3e8d9d664f3b301a2fe591123066c39a7f0486c1fcf2cb0249196a242119175fec8a93c090871fcf896d366e3ce07b04880ff1db9f396ac714714209359e4c729ac50dccfe8b28754ef51a4d007327d2a61d948ac33c17a2dd0c8cd4d3c0e98e71c77450424e3455a506a5772327b04d00b5d9961002bbdacc74b14ea588d7f99917311503d829b8b7273fb34e04fcbabf5f27c630933cb80b301a3f53fdfcfb393daae3ea32f1e4ace050ca2913f4640aa3e7e3c8f78484bfc82e6f852741de79c249819f637222abb940855b5b80920a0a7fb58336798613c454a5e20f8ee8822d75b9c97396b9dc3b77aa8de4898be71b5804065905052dadf6ab12bccc637c069551106b43f368ed5e0166b7f598c85fda98fc680f4b350b7b47be36e1958fd613121e52631677575b548fdbae01d55c6d390b697e9e54644b428e86b7c7e12356c49830dd6b3002d769af589a0e389c7aaedb663c47b142ce6329b335409d78c62f290d993abc753b096f37a30716a767c01566308d762c6c7438c5424ae95acb1a77f27fcb4338edfc777fb0339a039e37617242bac8ab8d3b62c5c82bed53cd4f2ae67765ecd4570a6e38a8dbe93a85db66915a15d146998250baae2cd3ea3494ebf26951dfd0dffbfd6b75472ed48673cdcb60e5b985f80fa9acdc95c0a868b2621d3dd845b4ef96cb1ffebf8f5708c93d283c73a8f012aa16a439aede13d171366fdb404609eea4815c2b8b344d73a35fb1d707c5104f1d3fa8afbe55b5d8980ff02bd1095644edc62ae4f2463d2ecadb6d17e8386c182fcbc3250f4d16e3f197a916d5b72358394392113dedb0a3065865e5602a8cd3a763fa84e7edbc5c4273a1829277f994509f9b9ab5502d391e7e9f2ab5c3f9ea4eae57b28f5d31a9544ee05951725e5ffa834e679f983c58dcf725cc302a3ac3ec55e1984fc6fd34efce6f815acfdd21fe97b16146ec65680668ffb51988d7c849ffa01e6e50a663da9b55e4f5b7fb432582cf6ef17531d1657c33cbb804595f2c559d2d3622b6a0df5e9a686a52422b37edad77e75b27fcc1d9cbf854c747f25efedfabed65b552c4bf47f700c73942fc7f556571c5d04fe227ce2237f829e8a8a36e82dc4029e052656378013f68f03be1ce1ed7dbb2338f0f4533a7c088a9d0ec53984bdc9cb451f9f6d2b3e1589ebeba208c61c7571192383712ed47ea9d9e8095d782609535892209ef5fd690b24bb3549657ae474fb14caca751b4da2cdc083c25c8f59dcbc289a2b64c459896ab74702300bb0857b5f0adda1a2fddbe502b516c67c33bdec3d6cc0fc457f9b0a6a47f1da513248f65ce409392e27dbbc392db93a5f1f7d655b08ce20d343a6a03eb866b8ee123618b8e70bafff3418bfee5e282cba8591c40bfec177003e32b8cf38ff5034b8b34edd84237aa8ab196c6cb6f21200fea164cacf39735ed7d5a0761a1a34c79e66f5552c0f2dbd05644e6ec8858ee4f312d401fa948a4198f613de0c55db094bb7c89a7f1d4daecb7fe24f1380f7b8fb6c9e6bf171305afa1a7f616020b78c493c2517dddc3ee075d2a4a82842e11f80253043544e09fd93b94f9ab6095ed30f5a9777d8da86049ce321e46769df6b29c3163283998bbbde6901048e7e354016999c14e086c78d9947c69e6154472e40ccdcb41fc21a18329030195a0ddf85e77faf99856f57ee03772f209690bcfb6db8e0428976599548d559539926c2070a834e505802dba853d7a83587bdb535190dbd584114beb5899ee94ddc576135f83af4e3b8dfb74f130fee27b529a48ddb31e07fe73badeb6d537c62842e41a5291d4fbe28546f34b9765d819f632f481cdbe623dc49cbb97c996f3c3109f7d715809b6a371f880bcfb172dda7089a0666523aeea0cd8ca22fe74e255378e84e562b7452658f8636ce37ca968c78993b403b5b3ac54565380fb3a5c87c09877d637477112422ee482d7fc1468031917922fdc392ca3fe9ed8484e2901b2a79d6b5d1f020f37824b275fff35852d2072287200071101b8f3536e1a116a15a23fcd5ea9c0c740dcdf8204edd5654c88ed9f5389e604766c9919f404dc6af270a524c24c73df6424e9bc4d2ebcb06838d01f5bdf9ead0b02d951627651ab50fb17970f6fe202ac42b1fcc32ab20f8a1863cf106af7b3c762fb2341d739d2372add4ecf7cd6d61e1e7f6bec497f29b810eed8fc92b9bfb37447b8178f5c8aafe53e7289da1703c5a19b3153f4eaa8fc08b862a7c0ab78d52104386f068279c114832bc6f16d32a6b14c757d91bd315ee80a94985a9687374f7ccbcea3734774a0f5a00d29a00bcb37dc5ff48abe6fe5982c9657ca4293e1e7f597bed0f69dd16fd9fae6ea77353b1c91183f45b607990066916c767745d9d2b8c7c6f5d523de6a7a60d99cbb59fe46b4c8e62c6ca4820900ad60c8fd4529f60d816f78d680a5791ffb6fa7341e1d9f8c9671a5aaeca9994111b9269b3ad93d3bed3fc2c25c2e850ff32f73aa2d9f0e63ab691a3687159972e602fa1bccef8e8c35c03b60617f74936fa268e52d8c7a7f2f56f2d91ecef2db53c0ab43a475d0467e7a4b7a35a230f3974eefacc7eccd2949be955b59dd8ac4817da1dc6a72edb2f3f45bd6809f9f7794bd6ec9a3c8eea9212b6b84df494b7597c044adc6efcc18b9b6d13eeb7cab678e774f026827c547e024dc1c591a1c35be12fc805ef355c0fb4817771d433b0aac02f820be123a4bae3250ea6e59e44e1efa311bdd8670f1df33934cbffc36a917e8d3eb4f9035fcb2db2fb7c70d8d06de004b47e9b005f58dfeaf8479ad868cf7b1462ac0a99ea415aae14b0b3efea627acb2cc2a7afc122e31d2e6f26012fb73e3bba7bc655d89fe24ce6ee3f41f752087ce724aeb3d91ea54633cd31cc23eb3089928e9cd5af396d35ee8f738d8bdf2180801ee0cb1bae8f0cc4cc3ea7e9ce0a74876efe87e2c053efa80ee1111c4c4e7c640c0e33ed4518c74df6bd12e5f2249305977bfaf7b72ed08007188b2d4bf7d71f8687bcd294cb1c3bc73d9bacda075b9982958d6270569f22e27a4a3330a6172f18ed947ff02e621ad820a0a2f83b34bfdacbddc79e8391ed2b96dcc29cf1b2ff3d907929f9bb3f678406d07ccf28b4e4ea9f6a7b940e5f6b6ceeb1600333412c6f10c98513ea0aae6570997ee16862a54c709212f38f6e0a10f2767fe603382317ff03f5c1336a5bf6ce6a3db172b47d7af003122f5f3465a2328a96d7ea0e7fe2bbb710a43fc50cb2a0d14dc1c030d9f08e2bedca2648faab4f6c293b404a8f39c7615a1f67b11d13685d0394d95e5737bb8b2a365d12359679a9cb92be62fd97b29136a5339519b3b56c13ad369351cb089f4c066c36a2fe61b1d260bcee3776fda53ad83c079efdf89ce27d60766634e5d6c7bcec2ccf4d9812f247b442c972193bcb2ae98ef96ca25de477df8e10efe3d021bc554b16fe7d5b9f9a3d172ff385b38c0fa471d58a532dbe3f1c30de5672f9eea72038169b91ea2eeacfc1d785d3baf20925769fc18b9ac435af051b2323e282efe56a4aaf764d44bbe4e95ca3839071b9c503d4ccac039afdf07173b066f883091d582fa48af3658004e43bd706029f741b8000e64526a6fa891c6498ccca638510983215408b05d9b848d19aeb5fdfca8191a0b8d7427cade16c5a46b5c6a8d697910e6c4762aa1b778dca599426b74fafaf30bee30580aa91c7e144c27bd79ffae8f1240028c6d7ab3992ada0e5ca55ee4f3d62f8de575302d5861d73685423c2e6a6d6fb3be090fbc2a701821b6d8fd5e8233f794b6549cd0bb52b390ac31478307bffa91a9bd9c1bf93ffc846356fef008ebee4bb3ee148e0fb1893d188e4934d0d088a433d14a596c5f2e3e49648a22edc6bdbcc58dc1edbd440046b3a169ca2b68c2f5458c40fded975557524dc97d998c0cefd277cb772bd4c1b263b1d0cc824e508bc837a78fe3b119d86557e288740582eac3f559b4c22873891208a5c23c4bd96ea21aa697b67324c869ccfecbe7f9c8b7814f932bea0abfd4a7ec1135c12705a7bd7d669ecda61b2f48f244cf582f865ef3cda2640c404d9a0aa63cac79aa7e3dffa80e2b9212a915e912dd1b307063e500b7aee78e93c4e3237e4dafcc9be93852e2c7c76c7e74833473f038d88407569254de3ddacbcdb7dabb6cc622c4f1a19d75b9f9c3b32480115fa6acb6331bb890ed5bed56b00f1f17a7c37ae3eb3c7fc8a70b49007a6215681c270134454714e1ca4d7f6c093322c288775277d972dabac1e63f8999d64921f39abeb98132716f33db7b83a0e0c9c3a7b3d746563cba5d0a7164c7d82724242c276cacb085d721702d6a023bbf1b024c9d8fb92a422898ccd53f2201fdae590ff892779ae74fdfc86cd453a3772067bf5d04361c2b2b534d395903da02f0a9e432b8810701df9185c03fdda0b1e0db471cbe26f59fcc76d7c638d02ddcf1faf2006732bf7b921fed503508fa1564442d0244f27d4812eab0a366f3c033b936828825f289fc6d7249453d3c784ab38cba361d007ccb059520fa6bd25bb05143dcf27d292f2c7a70e0c6e0e1e3f9d59933e1d4babad3ad6071f0cdd7c8fac00b4867f43f77b4c002fcfca45f03c9d355e32aee87fe061333e9af1668ceba0e740e0f149c2a3c4711e30f141fa063b4a6113af5ce120c3ef7d25fcdef34984468751164a9106b1883de26b587826e8076043871f9bc8e369272277bd3c33b69cec6956cccf0ea3a423569110070933fac054de86fc53404ee1230a77c434c858d4ac5b56e9360b5343001aff3347afa305ca1e498f5a5aff2f9a2d9527c72a18f46c7c6f8c2769243171617c694cab9ea515becdc138a3f8571a49abd3556c3bb05c327d043d4d85631cfd2e3592c82c22ca489a3e98abd91c05e702538a0f6f9cee26160de218f54c75567b04b475fa034a341553d4e30fd2ff9e6f24bf73f31e84bfb0f5d06bf2721d05e9731c4576cb2819f5ad87da0b1069d818c3703a84b9c287d44862a71b6876740fed44a720eee65281a82c015948d71cb5bc36d3830329e70692336ade94142934ffd82b96e307866fe02bf98900c9e4bc8b9ddf7c6f2d75be5fad179a8968ae2f172133374c0e1e06c2221308cca4b8939dffaeef623fbc620d4a4dfdbd067b24cfca7e909e5c91ecda88fe67110a10e17ff6d24a90f3139827856e66a35008dc862e3e113e958a98a5db0c12526c861cbdfdda1c5fca23d73b090963d0e7efacd6e71257b12b50809092dc99154e70abb48f36e333376595b42faf83da20882c3e6f9bd2aa909c3b474ad069de2279251015792dcfcd416a2f73b13503bc7ab129322af07f57b63f265d9813217af80f4d4b015a79ee4fbb097fcf05f1fe300223d9505f940346f2aa65941363ca85c0b87a7007b63d090edeae495539783065cabfac7ead05c6fc6fdd44e939939af00e3e35a4291bd5dc2b79c0c12ebcf4726a7f8fbc1ef1aeb2d33f2b12f768bff3ab00d2be371d5eb95c8cb5d8663f04ae9f737ab66e3966cc7105c71f41bc5d721b6cc7c464b40c1cfe31a8e95470e970e6460dec0f4f979fc5bba96c8cf10bc1dbcc95453672667d9d131a929de50b7fbb61b9db96c6b9b34deb32995dc9438968cabbbf20cae66195ab7b52971df311ab50fef38911359d75ff030428878d2f4ec1bb90b840045f94555bb7d48e38dd229e5dc26ad1a3b4da719b6b71ce5139fa5c1578615458ce05cb2c20dab83548ad9446c6906a7c9fe7ed5c0dcdf0281007f449c4b08a5c4366577d2c1e2e70dac8ed5a8eae4e38c53abcc58991bf8a67d414d9142a5477462294bf3813438409f1040979191f60bb2f8a785d616ee0a7fb5833c54335424ce70d72e35eb9e75cb272c41475407ce842b0e507b1a0d336fa18fa767fcf35ce102c28ac54d4035989b41aff2743e5e320da8bf706d7cabb3ce18da64464da503a6b51019a347076e3328e87b3ac44222661edd9d5764fab504c7db345a8a869c2658c71934da74b5b889f4cbeec102befe17afea22eda6db0a44b4bd80d188144852b7ae4a2203d5f30bdcc9d85c276d9c3c3f40143e398faa366de9ff4a31d4d54ce8be2b473c36a957a75c3fbe38960a35948577803b38aa450c9f211e0c4294ed63322070a740a5155d6e6d0fbda30ea9b6a391da323dd31a9bc72c759ec74fde2ff371c5cd5caeec07e6a8763ffb7141ae80ab75a808ed5d2148697671ccccc654e8666f35f08b84acab391b4506faa483060c792400c0b6a70c204a0cb7d44edbf847966766058654a76827572c737a3d1bfe0d2f8d13cb34fa9918f7f12f1ecb0d5b61ec24e49a07c17cc2fdd5a26de5a9c7595017b047d0fa1b09bbe3a5dd2c0eebf94b94f067cee1bf13c0695123 +MD = 6064b25061c48d401846b922a6f28cf06001e0e9210a759b66b4cc6315b18a0bac5667e3edd91563ea3dc002c732d1b93857ffbee08e12939971704348edad9e + +Len = 59632 +Msg = 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 +MD = 338a39c789636826a396214578166eb987b5f0b91ccdccf363ec13ad2262ce869fad36cd3eb7f89fea6b8135e2b2b24b9b0a2be7e57db1326c370dd7424e2a85 + +Len = 60424 +Msg = 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 +MD = cbee0413f1f169a6512ecaefcf5a0c665ddbc5f5365749da16dd98a04b9939584004295aae3867f2697c52a28be0e42db6d1d20954e386dbdeec744770fdd2ba + +Len = 61216 +Msg = 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 +MD = ec4ae4e3668035491074838888491390f18c964bbf2aa16f44f76a167ea90043cbdce5fe79fe09c2e78cdb1fbfb8c3eab143299bb7ef98f9787a4a9f94ca413e + +Len = 62008 +Msg = 090d8832d14f33207b3bf973d374be0e88082e7b46fe01251f2e7dc82f563d25806932fa2b2ae731c0fa0958e8ee26514925b54baa5957f158b35ce0c8e4895f7d71184a2c4e01501faf785fd71bb75bf5c2fd165b10d77d8e829e0f5eb94194cacd440b1ee309e45e024f6fe722f89554860fc69f4c093288434b3c3bfced2b2d24be2347108855469a9572622c71652d1af241bf357678109d6c4fa5d6168e6f1e8c7cf0fe050a9f20524f8e60ab344a25ae7102f2a5b8ec38082fe56f43245864b8fd60d5086d313b8eeeb4e72d6b71504c3cb2ac1e58e5bd27c643eefc55af9e4a8de1bc19e5c39452371be87f706b43d38c158a6ac2c3d4d1fb067bc9893e744816b9dbc1da1fd2a5120d8c2aad00a54b4875b5105c4e240fb678403328cb8cbc7f315b87b40b9e9067d0fbb588f71fbd58185498904e56e8dfdf62c19a1f91adb09164f4dc50a01a1ead5ca86b1a5830a447908bc58a11655f840cfc4802292490211d8fb8b67f4b1fecd78cbd2ff9ac1349917062cbfe8d1caf646a983bfc280929afe0b104e42b52d596e8e6ffa9398f687ecfd1d9c568ffa89295f394b3c102f0426f300476c39fb0be444e5211e000ea7f31797c0dfef0b6bf05c2d3f6f764bffcc59b7cde1aefc47a285df0d8a84c18be1cc27c7e58d82213406bc16cd315de08695b35c338285af01d7ba0a79a5c3a601b14a0c17d9d35b5d05826be5cfe958ce3d9f7ce2634ba48aa102b26bc189890b3d7b17e752934ce3defca949b072cb1bc7c89a7ebf92cab58845afc186879746e73785c49626a850d9a74949619ea9e7babb5f58f61f841ae3ff3d2b6352734d351ba0400321e03cac0ee69571a187ca8d041601b53653134a9be4f9c65e8f96ad7421ea280976ffbc8feb9e6f4fe72cb52f69296b6bca4722a851cd4e205ebbc6ed75138331ef2291c6d2d498de4a96d999c30087446c1f12b0ee06692c631507e4045c835fbb4db23026c8acf1248150dfbe57a7448b138122244585f72f4ae7046a35d6d76dc9945871fb1a0cf784c16da56f29e0d9bcf4989f0b430535b5faab113fcc3d793eceac2edc4ea6561991c032e7bdadca83f360b8b82ecaf8fea96493caf1f65005a7a7d7fcd941a2a84873c131a10fcff0f4370bdc87dcfb7d79bd5c77d69694c6d5d7e7cd38637fc95bf4eaed928b6cac7d77f3090cafbfcaf201f5b6f892b9eadfc8e8ddfa803fe552c01a6bf0a522ef0590189e1bb7a86f98feda18b68f31fa1bd745af8e2c8594b361ca3d49f18551133bf73c438967c3d4f0841dbec09f6d109fa8a261ccc340046694f21cd4f67b2cc7e943f29950604c838e267feb44dc549e6c5713e59b8fac2ae4fad7d418b5b8c09945d76c04ed462442c35873e4906e301b5e230b50cc314b44e819834ea95db271c23085f793885f6c9506ded141b41130080da285ae3a243f2a30471ace7219fd49bc5bab2b599145ebd9a0ad68cc9e44e5424fcc7e0d623e31dab40f8dac63a63cc96181fd506679685f4dcb6e2e53b4864f7777d44171bcaf773e8f6f532c072be63c3e81f34b716b165addda4fce195ba39e3a496ccf44f3746b3d0c0cef9a87a1501361b8ccc8949d4c3735a759fde5ed486635f5f7619e70be7abc300acae07921b3152746d955328689f8cba3bcb56aea9e3263769d10eaacdb28731a32b6dc459004b5564e2d94be189c3327d03acb1934c73bc951eb50aad0a93caa4c8b59202cc8e987719e224795a86452f2f68c48ec5cf56c2a9e315cfde6f31782de6e360bca4a36fe2779b773a5e5b17f690cee076c06db71aa0b27a54a4d0e70108a1b9f914e013e49f982250d2dcff012eb9d288d0693d18f4c9f894b90eb8ec24b356aa66b52dc86203c4c56a30adf8496cac2387b21c4be8438fc73652b59840017ff8238c8335c8c4a3c0aec0e981eacfb66e6cb01c5c83068815a406a4aa67737b0bd2ccdfd4dac4076a27f27d4718ca389207cc04f3cefb2ba589914ecd9ef1940afbdd074d9fe93aeb5c2f2ff0db4579b7e06c9eb7cf0abfa0705b7ba7ef63101d2727c3471f1c836ad5e0c9253b28c20380fab051901c8e2ddeccf2e061b1386edc12dd6b6346290f1b6b118d415b5ba16edc03681917de755d4c7d21fcc35422a5061b60724d7504b53ad0d1f4c68cb7327c5fa570e5f8a07443e212c981ac64076b47ce551baf6e2bb3cd985d529d6e55408cb09f6c24d5ac19ea5acfd4875a8ca9275f12961f780640d28b82e5d5ed5e925130ae96a93c8b365da117a22f2cbb2884b9b3a80c47cd48a5526d687d5dd5d977cea349d1fe9b020391a7d5ea031c5025843f38c00608330f9426c4dde5427cc731886fe24364e6a4d089530107388ad469bf2d81db4068d8f9b3df3dae2ee5060164ef25326d480706c506bc5f963c570f3a7198eefb51c82b1ea3e5df217bffe840b1e2f43e91f5dc61d46234bfd07720b8eb4d68c455a7cf6ff71ca1a1a6798c239d61b05f2a36f967a73dad39acfc414283e77120dc3c90acc22c1c38ce3b95159be98f59799207de6693f38e3aae1cde21b030994e5013dfee5b776d5b0eac1f93c3b9b2e8d1abcff9ad2d45e0555997adeeceb614ab030f62f2dbc8b5ba79476d3855f5deba8f4147d384e708b8a0720fea73ff9415064506386fd24507a397118e8ca7c3165b3c3a4c20fb19a0977930ec45fd3756c488c2775c1271bdd317670d8552feadb7c9b96228097bd5e9b3f63b6f376535e7e07ef5c911a2a3b0ce58ff697df94749eead5bc49a951f3c284a211736877c145522fcdf554182e3c4caaa5fb11bacbcb5fc801e35d14639e115e4668003f1f5f096d2c568b4221301a6589075cca3b6268f195b62961187e53dcd839f435d32b8c2bfa4d2654be98ed54f235174f6df484e6ea6a94d49ce3cac24961bad8773b68f0da419bac50c723ed741cd7b6be12321c625935cb6b8ef4831c97aab395ff0e302ecc71d5726b5c83a12724acb61bff16b00a72c20eb05fb3b4246a4399e70a8e8a563f5cbdc605dbebdc747dd0a25a4a3606d254f0f86ab8c29060050d93ec405f676aae7d879e4ad6b55db6b815c24b76d6eaf0bcd7b426aa7432646b86021a20887a474c20b444d43a26e3b716c57ef4e31331bcdeba71ee48480e3e2e0a506031e4a39411b67e76e386917805e27922c3f1748b6dec2f0075175ef00c53a7b0ec40600feb334c2139f32c556397bea2e1ec55a305c7b2738326d31b918c74751ff3f8fa1da93285b5d330d9c053a3d7d58a319e56eba0da1b0d072b6e033b3f55a5eafd1996c5f6efcd3b9faca4ed440751b4c7a1b67e86752077a9e256807225ac92836f7a7b07304798f17919ef7a0fb94bd9a6c6a01b5a178111af04d8bff89e9c279fc2d6392fb8f599c6112edc5747632eb67aba0b1248cffd248ca87b56e264542b0e4c0f56b7cdd30439200d66728741516130d8363ab0b6d35c7426b91e978381cb50fc1dba8e47c3e0676fb5d144bc181888f54e63eff94bf2c054a7b98240447889721d47b35285a56985edda17e97aff36f4c36aba1eeefe1187ab39d114e3946a13bdd5d9adb9f6bae246f37d73ea83df692da5cba24cccfc322c15e07bdfbd575377eb6d93d162b00789b3e1c5f744c694f5ab711dd5edc4e6b2e45cef9941f5b3e3feebbf7c67fd580ea1e16a11c0a13aa3f2670c2aef1007c81b82dab0c0b9b78a96d08b1b84f7764e3408dada75e3bcc0f109d7ac3f7227e4221ee7b6c807c0c439b8812f2842c4d0f0a492a1d2f28dc55dd61aea6d4fc98fae7d710bb68472295e102c37e043d63f4e511c18667230396f484065d72d6f33072b11301aa45e428a5406c64b9f2cd1c3aae1aebed74695cbfce29f2b7f8b66c2a432b462ebb78835008b4aa8a92b40f6fe9dc53a963352ea507c06c8da90a3677570193dcf4062f4b23435a5e673f53ee88afc7833890950ef672d4db331717c1b33cef9c37b7b2fd59c27b1fb797721d533d4e633aa1186264e83189dc04967020856356cbb296cd71d916b4cbe3f466142bf031b2913f0a19ca8b7eedfa3cec6684f6f2f9206225352f3205eb4c5f309124b5d5e887926cddbfeba4ad208f9d4de0b05809299f6c6b6dd7fa5efa3de293cea63724ac9af1786f58e2669f19ec9d42997043f4d409dc3a0d7b6e1415e6e2d1ca40ae27de01b183da205e9e623f1d51ba23eeaa8966503fdd7061c270a346d62ad6cd21e60551a37946df46f0ff96b61a57547247ea8f244ec1802ed5818785cce2cbc23b6321763e3d2fbe4d95d118c1f5bb7594fd60906956137dcce86c85ba4dee316485e6a530eb962f01679320b8e66cdbfb078c2b351762dadd40bf7ffcfd7f97e9d16bd757395ec192dfa7760610afcb0170dc9ebaedb46b91f1461a98dcc51b53b177b5bc0fcd9b8a64d4c1b35dcc6d30a1159100be53586f63caff98d10ae6298cd1e766562de6715de1a9c8b40aea0f0002ab107485ca00ff12d503c3941ff3ca42145df4c4c9cd3497d84cfcb26a26f66a95f1f593e9ca2be845e29cadef3ad292e4aad3db6d2850bef3471f0c14feec14f7ab2bc5dc575012f73c439b7e840e890154d9b9fa09191ea5c20460111e48c97747fc62cc2fd7599219a0a6f35ce5ee1063f0a897f9f77e93c393f6890e7351c0cc52b4e0d82685bf829b187747bf8bbce0ffee6c7f52a76855b415a357d6747842140141dca75e257d1c3731cf0426aad2eed4a2239262ca7d4f078780d8fa48b12a9216c3c1ab6d150b4d4a7b1d888541a5a2616d1f7562454c125e11e0aad7227baf8813db363e4f50a0e9d37079f3360ba0d0e662a8d7b4937f5093584dce9cf19fbf565fc54135d378376066c19cb70a161815c1c5d1d20d96848da7abd42873ace213b4211dce7d1f5ca968272acf894b6082a592faa8a09e2387358c92cdea1c19d342127b2234dc7f37dc7442837188d1b677d9f73d35e154096ab8af933c388e1d7160033ae1f6c8902b708edda81593389d60739ab5a5409caef6d48252486679a9d25c1d6db6603ebee3b6e4173acd9081f014c506330ec76910a9a31494cc6f52312fd3be646fc9fc9562a0a63fa847895082c812d3e71303ccd5fd6a63e688d4452365be481cb74c4e391a3e6b4be41f4a66abbfccf307e4f301983dffdc4b97d6e1da53a9909218d5e359c507deefaaa46874f768592b744dd47d73aed74104ac103a67d1f3e1c7f30965255b8bf192272f2da1ed42071ca1f7b3f6b9fff0818e598ee1066c2dc170534744af78713e9b64dda5a4d52442b91142ac687be2774664dda99123fd6d1468060c4bcdf718c8ae8debd53b09505bcb337f02749f4f9ad82fa7ba41d935a6f1aa6376b30b8775b6445ac89b3eac50cd8d56d111ad6f535e8cc3c8ee4980f0953c337a5236f36c240adcc41e4cc05fbe58181b7b9641399dfde50551d6b7b8fdc3639dd1ffc4739fe75813ecbaf252479daf29d9e22b133e89f5b7930740c7d047db2858ef6353cfe4b7fb2c10acf00f630243541797abe839db27db6584e5b7d18363118c36d45d08dfc507d75500bfb2f9b014bfecc744147f9d5277ebd95a6743952261a6bdf15cb9b8a496544bfe927cba40619230f922c96020c5de6d60140307b3f31cd832e62d1e2cd51399750c73a70086f1aeb06ba2ba6cd7c36772ddab02edccfeebc9b0243dc61cf9b1cb27c6c07eb5710811f8f0f15e36039037cc23ccf773b5bf5dc2845f9bf46e5da9ec5e4ddf767a08c3d09d4e206907b058e853adfa70aa1c972237cad2e4da63b76121964e5174746ffb8f19d7f8368f7c3923ef1e4c44c91fda23c69475a68c9c90f8e2f1cfc715bc82b09aae6cf7f44cc87cd98a8eea909cf2329d092d38a00181cb7bf077dbb3536ce619cb4bb4a96f9c44b267be0637b7704b955897f9678d3b83a774d21816dbc11bdd5620d4748ebd65c3dc64ff87175e55f8aa3851a9e9c606afa566e705fd89362f7870bf1e5134c55412093d4864c33a0c269aa92dbc2a3edbaabeae4961cd1f5758c5dc6f5f084eac3134284248a8e11af54467bcaf6f1272ac5fd6aaae95be9d20a6952e6141e615606e283c691432693ebef51e6a9e69bed2d3c8f08de7fb48f59c5125fee877d5c73ea5006f0f15432a91b91b94bf2d0545a1ebe3a5cdbea2012e791adf04e8358f2c075403a272eee1441d7ad5d845902c51a64b9f4eeff16ce473d6ac9d217de0c0b601cdd331b38a5f8705d7f399a7b06b63ef2272767e5e46a8210cbc0af5e1831acf74ac3ada4d6a61823f171191f9788998d7423b91fedd80c2a7678be5bbfc9b85a13575ab53ee12bab84d95982e00800e65c526727430648326a98c9495b4a2edfb75cb6ec4730275e89c0d027789af1976042068e9c7ba2a3187f54b983195cd2b74226ac87f997b770c6118fd9d8081af050fbc852beb806f0bae52ecfddeeed83a64e8859c3f930ea57922e8c35a0dbad2ddb76fe3604d893c9ff1b8a0e318abd0773026515c8755703d686084a5873f73709ed07780592622b17024a00e124b3d458ad126581df37496318c66cab5e5eeb2bccf70b26befc6ca165a87c6a66289b43eafa49b1e91b96ac794f32f5f554d89589555604d8c2fd32c7fdc729a95bdae93e7528d51d648a370a1b33d4f3798dfb949aef1c5a465b5fabe287cb78edf1ad2a1b997806b282775db2d5c4c32d59b281404cd9cdf7156c83df24bc5f5fadf44075f1f71f761e01e69e9f51dee0ea5ed1edd5c9ae75aa0de24c2478c7113e72e3ece8fed23fcb4b2736f6e8b144ae5508ec4058661287a839c20d8d3ab3419db718e4dbc97008d7b2348315e4c9243998c3e3329f8e4cb01cd9566644b645d92c625c3a6fa7552bf9ffba45e3deda70f42d54b4c52957d9edea85905f8ac9b9a651d5773f464ebc70f1031529063f9fbd610b6b5174377a3f7e2197f5a12bb3c77fe73ea2fd43fdb9c0f3f04ecfc21a57077dc2df0f6a15842ca0e9a1aa1a6c0244e7ed550cd38426e81353afac107553993257b85b7e304e4e8a11de05e426e9397e0fa0257bd46acee7dbd62b9935358ebfa697d8d25f008c438d25353788ded600021eb7bb72d7edc7e55cbecaee6f608c1bd80814f65d4e73d7f1c87316759324814b3400c400dd5a0c9dd633e583b70e440389a49a970d816ede302534200941f9a03afa5c781604be341252cef4eadc9ba4ae0fb04051f2de44fcdc7670a0eed7a83ce6a0a0206e7699f3a61f45847daf3615b4ec0bb45e82c08ef761e9e281b7ddaa74350b64ddc249eabc4ae80c47db223142824b9d1b18cb77047afe46b0f6bb04219e3c8c093dce77f3c67efae1cc138127377284befcd04592161055e320cafa5d2095ee4725922beb365cc8c1ee6495d15022f3b09b796b1ee7d298aec277dda580ba143e262f67110f240e7ebeafefef80df72a69121680954b7775a686c2e99131b8644cc10b9f3b547346eb94fefc02dfa8a076a62bcefe1318a9c6ef27d867c2cbcf163c0a501bd38c3186aef25f1dc26923983b7ea4111d34aeb62b53b1c108040daa9c9b8c9ab9b43024fe813030fc623d3798b609b6b0f20adc02f07c864989a56ea8655c9f4c12cc2d4e547622d6bc75bb867c06d5167a47a23ba33fa0ce821fcc2a11c713d6cf8c09641239dd989f538dcd78a25695f5ec6fa01604f6df18042be846d6dc9d12f920086481488a3260133551e521768b82aaf7f1d270c372daf2acad90e3ea0499da04f2574bf49e23b686b0d71e016390bd09dbb2f6c4ba2c8b3ceefd1004ccf7a01f63c2ce1d0a25de873c81367da69e0f9e7daa7028157f5d60b0254c359498d82060cbb94e9fecf4019eea4f347b35087e7fc5c638ad5dd0e29b117dc38106ecd09079f4cf85025ebc7d1a526c0bdc10708808e13caa4d4c8958c88cf7bdc842f79cd468e8e3ef8680821a286e7d1b8f3d407da77c34d8391c8f5262197066445d2be4fbe1e139d21555f1b782fa7aedad512b013f7184ff64e7b8e571c16858c9e6b29601a96aac429da7e9efaa829288601ad7cf8cdc06290901ff46d957e8047445229160097bd00245a5ffb4bae79618531272ab65b7329d3597e2e0bb5bd77fa585d9319fa7882ed2d2f841aa529f1edd9871f7a978494a5d958bfd1a1907acdba92142b3982fc6565a2378db3c6a1dc05314972fb234b87fe08a58fe8a5fa5ee74b1bbcdb59075da24c882d40ec0bb052aa2b37fcebc90a662271aee16a612e6d0d0c5766872e164182f861d2e69a0b30465752232a97ad702a96b7325a39acca4c88834199cb2ff1e9fad3f062d75d2cba3039f48c31d1ca85a72141f1fe6a7d8df2b922ed791b01e621fc1fcd4e26b66a5857e77d2227c3c8058596ce29e7f535ed61510eb268100be032b7a258e84bdb32448269d3000a76444ca74b4695cff8db34727a01879acfc8106e7e92228b8140784bfedf0aecf4e5ff09f5def47c3b3e7afdbbe0fa00b63c3d9abe8455c3f1258baa98a0a909d85d15256a4d94787199dd5950cb5ff033dee2c2eeaa02a3af33c724c3c25aef953c178ff53cf653308fb42bb53af9d7dd02d88d7b7db999100dd3510cbe90eccfe57eb043078a8b0c6297db75ba8836266a67310169db12c81638a5dfe00bafccfbd32cb047d18e49b500eefec46b79845817741d18e7bf3bef6fa9b9e0fba730e18d5be9685bdb8d1987ecdce314309b5e71cd0ae57fecffebc0c3273c1141703935d43b039a014af2854b7c8122e9b0000e92676a043a68be0488a45bbd2d2f65351c41841c8e17c291817a49181386df366abf0105062ab88360bdca8fc8b2e8339a897443d0581c25354285543c743e91bc7e6502fe9a7dd5f1e002e982af4499e57f5eb086a061c8cd61d077c30cb0991e31e08e825c7064a2978f5b09690cd0639fadd30f6525e4b054a4e355b4d7c4f6562df81fc522b7f960da64bb94a38fcb66ec2bd93afb1184979d375301069ddb7787d0458927687cb87e9727a69b205361844b828633d7c0a703e44975ef9c43f288b7820cd0de932ae652cc13762ab21c109289db729feb0f836aa787d538b673cb1e63c4c182d3149c38176fa7175df31b915daf39e27a3d963b0bbb6a1ba967a96559357c0dc3222aa7982fb07ebd830fd87c65fc37d4bdb6e5d485108da33ace3cd0f352c7d9cffc31dcb824a9674867d874b43c18a11c6ffba0796b272a8983f5797308698d7a9b6743ad765fd1cfae01c50e6bfd65b61bdcde0cdc70a5c0753f9148ef3b54be82a86b7417ea93656ce4fbe91e6e7927551a0bc3d6e2ab7c0c7bd6c989d5d6083c85c2b09be202c60f1277b8c5e471fca623b812fd05b218d42ab8896ac177e4437fd7c784cec64e1eeac701f4e7e682899a419eb152402346cca50d0486c0df11f7194d4519448a070e68592de12d7579ee56ab9640ec27eee22ac8d97e375532ac15965f4a13e671ddea32c388dd31e18065ee1e5a0c93370bb8517c4041e32fef4b5755e9ab0fc9d9bb0368177c347b00ddcaac262801b999ec1b4f557705643128f4ab6070528992595f8e45611980d04cb5e20dc4dfd12d24aad5365d486a224ce2d2571a5b3b9853bba87b424dad8f215432a9799a3825f064a05b5b08cc2315c66d35ff865a4c289c4921864d4b8e0a1a1051acdd3924edfd233cf6d2e4d41203de759660603e4665d2e0b395056d557c2dced4f56eaa6bc8f073c7435e85d02fa89e7575d7df4bccf83140b1459d91fedd59989f4316f84c7a7832c683d8beae4e3923333bbf87260b8bb42ea6af4e16918a5e17410b121c33b2cfc91f4d5c0441ae1625064fb7059f5884698312f857fce99c1a02e757acbecc04e76b5436c62595d4c7c21029e02640480e65591f3771ffe903e34c27726e1c689e127dcd786c68c597f9a17e4a22ab6569e7f231499325ab617c9a1001e44c61498f2a8e7f889f8f22076412a827226318656ecce2c30389bf39619fdf93a485963bfaf85ffcb297d285e8958eb62dd7a6883f40a7a401da79a42325600edd5bf0c36fa9ae5b4a66460f9f556232262970aad43b1c98b9342d376f4f47b85f4ae59fe900cf06bf70d8df0900c72db3df2347de2a9623921d467da68bdb2292e8e14c079c56919a4e27aea5f6222b5f7f1b09ad8dc8d7150c51f15959aec020ac80323beab98e53549ee906c417ad717fe45ae2d30925ba67dc1d08473733810c2efd066a8c4f833acb08abe8fc16a2580ba5ee98fb820ad6415b23b318df2c8e59f6e79a336792672897f5d364095aadfd85415e048e8ede2e564c4ba8358bb99dda60083379194034117521c3f812d826738b90b8adaed60f78d27f89d9470476f2001320d6807c7a0fba42b055536d32fb1dbf7c61f354414d66ad222cb6f551e838797002506266ed35b49dc3a4d39f768858e44de4df804e7972f5c28412db277979a5af11a88724680600a58fb1c8905beb74b40bee28f67b5f991d06d35f3a63b2361f3c95575fd1957d8d6c7e4ab2f8f5a256d0e6c7dffcd170aee7bd7a9b57a1a5f549ef53fa031168edd3afa268efe60188cc8fd9556e6710fa8f47a9b4f5d679a3b1ed098d6cd857494dac4c1cb16af6dc671fca01508efe7265f85921aeaf35bd1d34e4847f78cd22432ab468edc306c4293d367e33b79dc91446256be2ba4e93d44d8169cb613efb4c7187b7e5acb5c29b5e9af6988f734112b78afe428638ea8f9d4cb7d1302146d23712a44976987a260a6434ef65138cd9d2f6534e819903a7bac2f9114418977cd1f19889bf033d61b72ea3b8e6f30ee21ef3f5573ac381a51c60a81c4b896f94d8b11f16f4aa9ec6eb56bd85739649b402006f0d106ce71038c24f42850831b2c1cd9271a5d310de1d78fcc59981bfd812a82ac0b0d9a661a6445934aef9707f1 +MD = fa933b224e0912687b04a51ddbe1383a5c1ccfd2c0c15a3aa8b40844fe70f356afa3a3317175b664cd3e01854adfb1e2a6e20fb2a4720d53c4fa9ba555dd5e9d + +Len = 62800 +Msg = 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 +MD = d4292e3e757b4819873b554278a8c484e99c019a18d1073459c56ac454c2d518298050a78e46e2af85b25e05fcff6ad5fed4c436577a90a3107f25b99f1cc999 + +Len = 63592 +Msg = 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 +MD = 06b3fe00a2c681dbc14f6e81ae1e7addedeeaaf4c7485d28beed0b52d128cb9e7b295838dad384054a826cd316fe20b8ea1aa35de2b39ae612342dd1911212d9 + +Len = 64384 +Msg = 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 +MD = 8bcf4c7df9b79044ab522ecb2d9bb9dcf54b6e131404f1f2bb413b2790968c2b83c4d34c61edef8302e3129e67e3f95b249d160ae5e0c4d3488079263e5ed128 + +Len = 65176 +Msg = 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 +MD = c9c7d9b0413dd75496646779efd98d505921b9a547cbd5c460450b24fcb8119a769c27a9b63e300402cf04442e900cd496c0a05682f88c820d5a6d431005eff8 + +Len = 65968 +Msg = 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 +MD = 5169e69bf0e777581ca94e070b47454ad7f6af034dd3e2ed564d020f6557fd908f721e2b19e548fb0c41763fe0abdd89efdacce8e3546faf22f3fd089928b019 + +Len = 66760 +Msg = 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 +MD = 68c34d5aec130f666c98d7088506e213c84ff3a7e86c21932039242a68b4b78e36b7b3948435d89d2a86a5194ba1b321832ae7b8ec286f86b6dbe3e39da2d2a1 + +Len = 67552 +Msg = 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 +MD = 9dce12e49fae09e0b1a60f44199449fa31b9bb277857a84efb874b0c23118bf8453f8435f47b161c9747e719a642f805bf14c06b6202535e7abacd53e25ab84f + +Len = 68344 +Msg = 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 +MD = e95fda82d0384a00d1aaf90744ec582cdbbe31f5c6b2ea26b963ff633c7224340fc4423203a8972fe7d90c2a2342cdb8fbe73e0ab036a29b81d08d859978281f + +Len = 69136 +Msg = 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 +MD = a4245a5f76f6228113344929db4ea36401f1b48ecde3714ea7e9f90132f08658457e3b90d935c5e400da23671ab42ca836f0b070609d4dd94480b24531026eff + +Len = 69928 +Msg = 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 +MD = 2529d5d0f4625ae701397a41b5184bbd45b840c3fee6652a467ff1a49c622604991157b16393136cd123a515e4a0412dd2bf2b3227dffb652e11a6304523c31d + +Len = 70720 +Msg = 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 +MD = c8b144ba9b9a8ae0ff3cf8a6444cf9291cb72feb3d8402237d2598a57d0d8389b198f67b5203576fa8f878ef2728644f706421fbc3db966b967cad4990a49480 + +Len = 71512 +Msg = 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 +MD = bcf7e3ac677b340318080a6212387096153ed60c24b1ac5c1744575e7f94fd0363d2e0ca6fa4d7445924963aafb47cec33632399c3533bbc144bbaffeeabe46f + +Len = 72304 +Msg = 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 +MD = aa13b83b4db9a58a7684bad6b864abdad23bdd71b4e5bcab1a8750aa8e6b1ca70730a7b9ff684fa6b73a70ca75c55aee6afe1b6f573c8fb6ecf3962a30e0af0b + +Len = 73096 +Msg = 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 +MD = 6730a70ed95c48d1fa1c04dd32c192337ab47f4df3c6a1e9d101c0983cceded1a10ab25fe0437de24a6f9e3848f892c2327fc7fa6a0fb1854d81bf05d9733573 + +Len = 73888 +Msg = 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 +MD = c49a67a96dccfe9597d5c1070077f46024b331f4b64d8713709f9ab3248ec7b95319da1ac43e0d67e2f3ac558943a5fd9ed2a67decbe6c873efe01f59db57cb8 + +Len = 74680 +Msg = 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 +MD = abdeca34f0dfd5d9097f0ea9e44263d17d93c6e02372c2e8896e8bd8c32957ea39055a956e4f803ea2a341166a87edb91cf0adb758fd39eae9438d0b2cb2cd39 + +Len = 75472 +Msg = 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 +MD = 956d5ca8fb9c84cdc882eb0bf3f5ff0a61238f982286673bb9185a45858ea13827dee168b4abf313a0b82aa5e98d2a01510dfc9e2228c657425f2941ff0c6d63 + +Len = 76264 +Msg = 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 +MD = 46cf632194dc6c65bea19ef791b91ebd5a6d21f55a42893c09c77dd449af60cd2a8c70fcd2905cea2081c1043fd0d0b973cd86ccc936b735effa0ed01ef8c4d9 + +Len = 77056 +Msg = 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 +MD = b5a4f6d83ff891451101726f1ad4d1caf87a5d9adb3ab3b90196fdbd440e75cfb8c2e70040f56a60f70da600fc144708597cec73d1ebf7b01f0fbc001a01c31b + +Len = 77848 +Msg = 8532190ee23ddd58861065fe170e971ed3ccc88cc7738a5f4166c5b089250a9ecc72239559b2efd110956d1d16f916e1ce0c705b05b1e02d6d26bf184de3b10776c5324f796b723517e163b1f97b1071a2043021a118fbea0bcf3c38289ca8c16d746ec3aa320f8c853a7040275c2ed735fc31650270849e03aa6399831796d497c6fe7955cd6edf41e9bc540864171a713c9aaf908122513dff5dc2c41d2449de050bf9e005363533356e74045b73423c0b9488b3137e0ca016523b5576fa272977bcccb5a20f974368ae298308ec5880b34776d3ed3fd61636698d9ceabf765f663a793a6ca30c59c9a6f9ed342862247ada0358d80eb887a8ca3f03411b3e6a18ac88d92b979c5d9f7b6faaa7cf6b10a976b7aa9c93b9d9b59ed9f042b88831d63b81f9a6964f3733581022298a782c874219310175e1f5a30de4cdb63b5b9ce70fed01a6462ecfcd6366be820193605e67b156cf5d38c3ba3ee701654fc093954f545bf34f400db4c4f8e479dbc394740c077fcdf2c72b445a6af4179abefe26243c6e555a8eda32a44efdd8c011b0135aa416c4dd95168788f50e94c45dc5e3b52fa2940f1e1c8d2bf172655a839c81790f817cc5aa6accf111b7a376a5d1142bb45f7715fabd0e8068a9e94e24400690d02abd530f115bbc45570e589f0801ad540dc7152aa3fdcc3b0c2b47f984ecc770774f2fcbf17c121a569b115253f16495144cb6b4b8a236f302f5eb0c51794776d2f900e6f4771b171c134ac79b2e7702ddcea1a2e244e717f20de2648df7386aa2846e690193fec4113daa04c6fe0f20ce157dfc0b2d062f463cd50922acc2d54eb9235bff1ae4a99ee3da13bdaa547950e8f3c81aa3bcc3654a6c04f6e10b3d405dc4c4d852f44f29cb81fc69796d94cc11ab10f7ef315cb7ff4e5cf3dd3e2ddf3bfcad7384573d1cbe48c5b1b583f9a8564cdb8a598c81a423241900ea812a931a701db8f734fbdd84d7787ca4bd314e807f32bb28f6bb947d9544044efcbec4c1cb1c8ff5b412d6e5d51cb49044c32457eb1c72a69691efd64ae3e952d970daf9b3b2e0c4ff096da9eaba40bf3f3794a239a19719958b1df6ea01963e3dc83d8ad0e893ad3c680c97bf59087ad716042b10c912ca1a3186a51ea3f35a524f563cccc590f894b81a79fc01f40834e6deb8199dcb014e0c93ab8ed3e8ed408c8bd74c51bfed2e7fff1549baecb37d328912fb24aa0658a3aacfe1985d412f084522fb9509d4334822334c8dd8c1db7f6d015f669820617e35dac0fb3a9c4649ede67e9854f4ca98ed9db081a07b7557f24ced6c7b9891269a95d2026747add9e9eb80638a961cf9c71a1b9f2c29744180bd4c3d3db60f2243c5c0b7cc8a8d40a3f9a7fc910250f2187136ee6413ffc67f1a25e1c4c204fa9635312252ac0e0481d89b6d53808f0c496ba87631803f6c572c1f61fa049737fdacce4adff757afed4f05beb65801cdc0d0193f79ba5bbe70bbe3c4c5c4f160dff13f375cb191c94e288df5a4d1cdbfe668335226077c41338f18120f4939fda3cd2bf1b223e3d80c29da1c04341c6a23fa9bb61eb0ca7f066f6754bfdc9897b3083a81c79576668f1b953abdc91555e050fc734bfc6cff52247891bdc536b5766a15ee854f71fa3ec56558b9d8e1088330fc9293358b498077f2d1f14c3adf54bb6440d398fd1d83f1f37ddfa9a70b7663431ae0a14ee6f62d7e1c43b9cd9db5c2ce7f98ba4255c565e7b1178490e71fb17a13198ade5d1e11c37b9b5316780148fcb4befb672d6deae8fc49b0c423e8e14985263662365fea6af5e1633ef7a01596e72ca4952ae1489e675d766a4738bd5779efee03fa207f1a93fd316ca3fbf1431ecafcf3d68a47b2f93c1eaadb760b4df65bf9e930cb997c5cd705c90278a4ab63804daab8d0afccbbccf0ad680c94d20554a13b60c700375857277d9e80f577bd36dde1581c4793b3f6339b7661208fadc22c22127c7cf48f66deafff7cad4f35d4f6c13fd4d8b0eba3319c8bdd772cf68be3c5cf52d55b0aea7487abd294dad142de72f4622aca6bb930d631e86050e8980e4d1eb1d213d0cc2f2e2cec72c19b68dd1bff2c058a39227974efeaa4a38cd1f5e188013dc5e9f558cc0a300fab9b2f3de4e99c31985fc4549c4d4b0bcfe91edfaa94aadc185e4c3688cb083341d87d44f63918759be5890877d4735d79076816cfca1478b536b8138bf9dba52b5a3c3c79770a9b3cd157df2c0bcb624bef95e079b2a7d843792335fd1b102e1029526b942cd969222d181fe37bb9e2eda88f86d0d5ccc66b2f74e505ba1196994ea91a70dfeda8f501b311c6aaa6a4073a3c4ffbbae908d561936bcb5d45a56dd027903518ae1f5f5310fdfa22fb7140ae868523e968672817670f788c142235b7b6170a5f8498062d172baa6b1e11400b546e6febafab0d57da1934d0e6d7980b3df5173dd7d99296b0e2fc0b794cb0598d540847289c2b2bd3d026af238a3fd5a37385390facac97c36c188c72ea38a11b7d158539012b9a3b7e77b33304d11dd2d97cdc94d7fc36380f277673b27feae532bf2e4ca4b4acf8694e647f0df7e9b16f23acce22297df714514fe36d2e3cd3ba2ec9c84b6f6af3d9d4496d6d5943287ca3332657dc74e8c3bda12ae3ec9fcd5f89de15bf03db141831ea66eb9e321f4a24f9023cbc22f46394f3b0dc621cbb67f9f59bc81908446d8ccfd3506ebf7e1fcd85cb9b728f013efdcedc2038ba851ba597c12d59f7691f0d811a6473f02d44c65fea3aa5c3f89a21b91876158214c3b64bf1b86ab26c77de87a5ef52cf1501380fc5e1fec7c2c0283ccca8a17a4ea7539a932ff54136bd2469dab9b6641c9d4b1dc65a24a245f839df5e7c85ac1c0ea50b0d5ba1aaae390ab0238945b62b622612546cc15c6b897c2b37bb69206742d326c80417f7bb32b5e3e729a7cd2b96f276d6de7afe1bbd1aa7bf2df4dd158906732cf2ff3047f2508a8d5f85b10282d6cfb679f98e3dda3bdc5e99cfeb0f2c667ba2ec005b39bf012d7ff4876b9a6efba75b05e617b82906507dc8a2523e721ac590bcc28279e2f05524b05401d9a288852d4ae89e76f2a48d8283141a89a54bd95f28eeaceea34789e45a957ea965a6f2940fa82d5e7d3d1bd790cd4cd70b204078f92ce282492b5227bcf1e7f1017d75f81ececb5811f880e2b776f012eec28141f6232b1c1ec637559c114699bc3496c13d01814cf7fd460dc2b70c2194582424e97c8fa46840c0d6c39ca288dff4dd5735e956227875f4bf7737aaec460bb28898de160370c17513f93b04a8b1e4d323cd2f52c2da88135fa09fd15b4b03b2d5cdf2c91f7e70df72059673e07c2dff8bcf7b7d15655d2a5703968a56ed67ac724e60afe1d975855cb154f71886f6e9f80174e001631dc10e69c5dcc5725f28c9e3cfd031cbf9ef3ac31e983819681ad32dc3826f1aef61ec99d3cf902315af4156e735f89a24a672049b5f297bab198219106b48d3fc90595d696b9f48aec8426e51e51c8f1d316e3c7453d1f4e66e6f8e02a472d66bd9bd7b2fb9da2955fc34f2b5e887f20d189433507d19ce41a200534134d76b65c180bcccc02a0d30d280abba471f0b1be44eb0d8e3e94fe53c9f3276235eda12d20ae8e988753e67d28c610909ce21701c037db48f2ac1fac4b3f1497aee6a9993c4c72d1aa5022384c1db4a367b7e33481a608b89c26aa7c3a45961407165238c1420417da0a28c7187e324d70e688df1fd2205d79b9315c0d932677dce11d74663bdccb95065c920473f3ff36e28a69e138bcb839c836c43bc440239edb7de481a6477d79b95031967b844928506a5d7c4628595ac84d3d4b456db7db69e5f1a9fdeeade6b7861e55116dbbc3a49b2247871db13b5dc72fc29329950111083455cf3ccd6a7580c0b6b21ab7a753bf70e977e73079ed47242839ee5bbe6537250b76ac6c8377b2b131fa15dd31e22991c8952f8784fb4fb2f2b6367c51db053c31a0d7fbb032ae786d45d98d01e47c3d7b7b5106fafc4344a8749c6769e6f4e27eca2a0b7f2ac68ebf11e05785bf29bc5876e63f3a84c461b0017abd651d88d0395f2d0c4ee4bd5cae0ac4cd3be6b497062479a0c2193592aff97bdee1e3335df7dc5b8ebdf4d56ac08cf14e92ff9f660b1065dc203e29300ea8fa5c5eec771430ce3ff33abfb1517d14f05c397e5ca1bda74531e34811f242ac80a63a7dd67b8aa134ea53b9d3796a3f3c868dc78ec2b475925279db8231e280a95d133bd3fc5bf1e4d47777be7aee68405e0e8f785185e7d7be626cfc8774b1cee1678af22f3b3cda32347dc4be902cb6334a1adbc6889a7fb61b80d35b6fac8bc3a60fb38c9eee6f941940a8bce608d8b6bf1e1baa52fa150a239bb93639fd4a746d2e8a8cfd831f6a7444bd0e56695258dbfdaa656b73120b193210906a1095941b5bf9b8dd978435f41e842b77daad8a3f2e1a9048b201494ac87c028682f7733f3c9388c5a818771712908cb0d934cb3743eeb361235d3556e35df505c0eac25734ba853c1156be3be554ba97f192ac82c399374b43a06fcbf728f07e56d9d1d1d90126a78fc97bf0fb632da39041ae7021aca47d9f5548f8988f8d46b16f526d9df9f5ae5feb20d4b92e6e5a51cc31ade28b735e9306618b3bd413f56cf5a458f7f76aa72e364d35c328e522a28ce68a8ac83c84cb1e39e255a93d00e61758427b9c1e28672571b29de53aa2ff2e2da48ee55886b41742ac7a61510fb94edea89d5a58b887430ec9add5d741e40a876a73656fcaca7c1c381ebf086852f6a7f9e1b4c2ce2b29a4f9779d3385edbc846abccadac78ad71713b6f4bbb15fc964c4cd2de4dfbf13b4a08f8dd7f578be9523df7842038192c3cdd7c4f3511c116587c4482763bfcbbe8d5a3a5cf7117b3a0460100e152b49c2d4f58237ee34795ac17b761300a9ac32ee7c250b31449d03bac304b763046674b794bf11ef156b94e0374a302d092fb26249d09b0a8e7e52859cd8d673897359f439fde9ba5b62a482ac36f75f5ad0ad7757bf65095ba9d70331fed3dd46eaf2f969a147f662e91a272ebed10e1b39949c2a63f1a438a9d1c2470947f6b947c055886bb519b879662c536475bfd6c4f85f4640d961b1f90341306aab564d2452973a9fa9aae89e0920aeaa2deaf9fd592f1fe884d83401cbee72b566729eeb2a1cd4cfae106fc1839295029226016d278a3bcd7c6e4b7e9c48a24c01e21b06a7750b6e3ae0ba8e56009b001ae7997ef40f1e52389a74aa04de33c1161b4e216b3e331dc8a2555f00e9452550a60ebd4f1c2c3931f32c2e962daba71b94a4a5d5b6d030dfbbccae14bb17d4bbf7fda2893009c500fefe66b0a57e507ad4bb2e879d8759f8b38d05f1f487b0b543d2b932f92b981e14480cf4d4207fcc51fe05f140bcfbac2012f12934292be5101a8bfcb60624f1e9b56bc33836677892f9c6835ee5985277fafa3ae850b8c3f3517517252dee24d5b32dbc5034aa182e1b0aee3695b29421b17ba79fa2e9ca44041f429507761f6ecdad40aa8fda2379ee2d726641cce9b3b31fefa8942170b8aee4efa4273f4a2b6164e0a5bc6a130cffc8c06c7e59abb49c3183b1b9124f97be507ec101bc5d721b0f2ce05ecc6f6dac4748c7afeb829ab96af449661ecf87bf0c807a2b7f920956e675d8cb83b10290338bf65af4e6dcb726c1be4fb978ff2d53954e08fbb027a1a55c0da72250622807fa8714085100f1ff7caeba74c47485d01dab3ea3107387a66fdd562af612f05f24d84f88499e164f75995ac33a6e550c8a2011283b63757401e67cffea8b75839b887207490a80a15cec8547536317638b2b44dda97df788b2a77033d632242fbf163007c7dcbdaf8336ee53a7f9597f714b2e45e3399a7f02aec44921bd78be0fefee0c5e9b499488f6ea8a908777aadd0e51f3611cbaa1625b0db255640fb92e94208765cca12afebb0e5eb5940e803ec33458bbadf4aa723aa101f9fc45ab6ba16bfb85c750cd34e1ce427fa59a9a07286a084b43b4f482dc22aa87bcb6ff777614fb3731d4e5cc09aec867428852e69c5764a894981a349e073e774bd03fa2a0dfe8e282aa1f34a1246304d174452dad81004c06fa86082ec31051103de6ada0115720304cd40f26c3b4c108dadb6cca6b6dbe2178b27ddcead2ada03c8ed9025db868d149aeac290110342f289024719aff776a8f39e646f2f7c5826892b53619af34dc0d09ac266107c6dada0de5418457f048aa8701eb5fe2612d4e8ce2b9d98e0cc7136f7f9d782e01828baf0f98cbe9b152472431389644e9176af7b20c11f76909095aa6fc9ad56ccca9fe3405b637530e019c04cd4a71d5b72a4dc3bb575dc2383b55a2c25db0710fb165d316e7c32dd25648ed07c10bafa3290998361e23b0db45eb039d4521a6c23e906d3ad51fda45c1c55a76be74df61c3a5a01aeb0bbd48958539dbd5ab868aade882e0029fc0eeb09bfda877400d59a6cc6bb822583026c6aed60c73d098df9be884a504e57a23bf37270bafef92113ec85bbc78bbc1ec45e238bdc4134627650b130830637e8b4a21671eacf6061ef83400963288db1f9fa9f24e3b062708a5ea8e7839ac469bede54e6012d5e1e95f99fab40451f4273070936c3d0ba3d9dae1877365225acc26ed4d6e6611bdf6f1649ab44299a59994c08c666ea6553180aa7e98675833a261b3d4981b3be2ce4a2e710591e257fd59345deb3458a3a6138fd445a4d059954ad3747ba6a6f8d5c6420e3666ae83a8ea26885922b5278e200c3909920d453b2ec6cd979d0588b3f259d2b52560c152d4218c4ebe2e597022ca1d52d3717f0aa9f8106a62b9eadf6ad05f0072ab995183bfda2a6b36a1f28823e1cfddaf7f6a39021d729c46c7ce7c4013b6c2e1644b855c027ace60996becc436cf1509cef0585f252eae3e87f7b32391369aa4ca97558095be3c3ec862bd057cef1e32d6237479c81d2d03a3e1abe5480e6e5824cb80b7f4734923876d7572349e5d9d2d8a39ec86cc7d28b412d32fb8acb28e1b6e737cbf2879a18ef2a284fe5b57bb5d8b0511e1ab23203111a54d53a00bb916e6ca49564c524b2788c0d82aa4a11fbeac62a45937c39c9354bed8b976ee6b9fcad1a84a6d4782e9965cc64a18ae3cf964defe6df0b2c063526c4c4a9fbf182e9146140bf9edeb5da1d2e9ed15e385765ad69a8074956e19a15a32979902313bc074072b70a9e6fc41cfbd843ae5abbde4f6034121dfe83ea7f50610e16c595fdf081c297ffff83decafbb9fd638f248a999c31086e6b13b0cc941571731f2f3536ead766674a19b090f5ea096320baeff4e448f126e6ba716337eda891790aeb41445a2c29c85bc3d4b3136f9855a497c90121d62cb7a0b7ae0190bd561b4da77956f2f12dbe6f9efffbdb35e9750b0a7ebc63be6826ec0914baa7b7ac4c21f146ea48be5b777dca7a96ea653dca16ce7ddbb6b2c27bc7f0fd29d99f7a56ae5210c6039a9b3aaecdac4ce9067e9aee6d2c26c4b922fd58f3d117cf7ca87f1b513fb3cc8ed54e2931fce48021932eba6ff56732db70f5c89af94c31561d1091773b794ba1f1fc177dd42856bd64cea35a3f64ab2094ab3e6ddb90a636c350374a6ce027dbd78ca03a9bde14e2d9c1d1b871e6d5917667e3f5e0abd623818936543bb009446f46ebefb8cf6198da516b10f5b55835ff71deb970646a253f01b51d0eb098e5a271212495c3e6e84fc499eb3299dd1515105841f4840a44e502dd2b4ea97dc55657696299824bd9206385d0905a0c37a18e7916d2d45d895cd2d50864645fec743eec2f2cd337743576544777bf8ca58c3168bf74190cfb8ab9c63cb6a6e763e56fd216b67f52c0764531d84f920667bc424ec4401ebea25801d84dae3abd318f32429c9f4f45c5cc17420c809921831b0852aea0aa1c87aef032c5b3e7885e5ccf644b5008b88b1d36af6a729d860390cd9d04fb84ceb175d0fd2c2c74f0f3338d61aa2f75521b53e8a17b8e65dcee02d7564eb9757b2893e7600883aa9ff7fbb56141a55dbc7c547640c53abbcc4d5b70a6154145cbf5f27e84e31f513a729e8f8b991b879eb60a28b3d2df65fe2782deb5dffdbc681f78dc914468316c6d03630839f7bc9ed25b45232ae62c19845f69aa3754a1f7ae0f4baeb4c611daee127900a9a2c467d73117b753b5d8c66dda5baea2aebe23ab9e1103baa1ba2f00b3189a7285679fcd73e498d7b631ace8dbfae8aa73d9911d0d77b9de61f511a8ce8afe1b076defbc09f5ed3e50fe74004a9081d60cbbec0c44c5f8a86e8829f04b15552c8f9dfeadda92df0eea09c5ba0f63a0aedf2cda812a43e7a1313b1edf1202c72e87c075a7d00296d1ee18482012bb6ebb55f40382a939af5010d8987d0c997ba8569efbb3d28f390ec3f4a4393ce21384d7da111aa8ee773d742541d31f219a2264ff39d8c97ff04ed165820d731fb692cba7a94e10ab68f1c6ecbee834e44b2419abd61e9b1be51880338aa5a0b97f6b9a237528c7b8aaf36cf3bac53428b737dd697b8d31ab3df438256308acf99799ad161dafb65d64cbd003db70053605e21803d02e7377236a6104b63e7d2726a46b4849ebc5e2bf0258e3c9f391565eae323f7c0849c6bd0363982a50fd8b53123b81a0e5dd8ee21f6e5d2d56becfea2293e628239ce23346a6a96845126c476d8788caa4e4aaf5aa7937af9f76ebd0c6a3c07b885211aebc93ff1725a6142a3cb6267030c47e222ce13af6d8a0f03922cb941e3e559c56eb9061e0f9a0c9230830233a9263528f2c0d2eab0824274cbf712cb84d8bcb525d06996bc8e8d45a585c47cfd1ab6e643267db7538ead83224ff4ef2bedee5cb9a5e6d5f9a667df8b4a459d8f58219cac65608fd6fd94b12d9dbc374983534e828fea66577020b25a46f23fc07d29de971427febb5dbc715676f52e5e377fed291500c2468a4c808b1266be40e8240e8ba9306e612d796635521c5eea88e8cb05dba66457434faca622ffa37127a4bef2ab266968fb6fe232b5be336ee6126ab12a67e6fa49aea9240f3989e1ca20628470567a4335e487e72847366bdd813eb3a7b1a4bffbee089d2da0cc132e2b8b99cf5d0b807b8bb9bb1033e251ddb9d975ca103808d8823d7a04d20475f22aacaaeeb6b7911aca1a370420c1c17520ad7018001b756e1fda332b29ad9a84a2584074dfe905b2340bd37a8a4f2b225a3d5b080db9863afb4151172431e17426f0e2e8452a4ed03e2128f9dd050f73db0b6f1095bcabbdc9157c4f6e3bfb3f2d091abf92f5ecd36cdc9ff8956deec8079a54c8347f6664edc8ed3a542638442923507135c6605a2490b10d5ff439bd745c84a5668c36defdde5c7e627b3931bfc21c939a3639d31a00048e793280c2a5e4772ea86dad7a5dc8226235c56e763557e79d5cafe9bca18cf3228da3446620a4b4da769e2ac5a208d7bc3a7f58804e6739f4e9ade0954fba153009c10516592fc61f6d884f4f5f22f4b2ed1387fe4f729c40cdbabeeb98f9d35d8a063351d3e81393d9c68b85e9a8f20cba2c6d3edcfc86f77550f53e01dec5f16afd6fa7155035ae57d35007d60d78104e1488c05b87729f7cfb03fb1ecb559249111a94821a94e574394d23a8b2cf7405865b316f85e79f41336ba144621ac680ebb4a8ce89c9cfab62c387d65b809e8cdc64f07d8a6e7d6e74acdf17158df4ced7ce324f303cc359ea6392e34a33f62091368c0a077fb0514947e30b6817a36f8fe7ef88a076672c2a9dd3541152117d4f3072998f83ee962bbd7b95dc40590f5e622f0f4d0f318ebde2d7ad435386ff50e322a085237ea9868e074ae4a09c1addfd8f47b85fb8fe1ec30e5352b0bd3360df4ab37ac6f718042a04af13b0e31e88fa7ec654e043e6c7def5fab2022a95d9852946e2f6ce4e0f21f216dbf9a486e9e97c0fb54988f543670ce7f3c065a335656cdf503b8ad811f65e36bfc376e06b5b05885bf3ee960c1bd1cfaa63e4f80f0073e144fdb322b727b76331d6c0b7a7cfb9c4bb77fb45ac6de2f618752ef0c0d6dd0133b5bdda59268c40d48c187909a7f759463e15908ecd9f1ff06cba19e56916939f1c215b92934b341a6bf4a11b844c9aaebee3e32dcb8481b4c30cf00737af2cf9697412ddce82d165eedbcc47d5382d3782ecca23e831efc8009e0f80b30541d5563cbca558a19d598d4467392b3865832286b1fb9405aebcbdf3c4fc6bc756b54ad1a583c255ec77efa4ee49e6cbf8140648470f5f9e43055384bcd4e253f01bbfd969f38bee63135e93ee04a871395ca6a7d5e9bb5a413459f743948739926b3dba766f25f985ee8297c2f3e0b6cdefac3c0b1537d82dcc399225c5faf6a2464d0b577120f5c95bd4072992100b1a2f6f6b331c45866d2f9b0baff39e09c41f56328983fd71a1ddcb886e69b6fca2ae68bc0a5974e383e0d6ba5e87e0e16c68e1d689221bdba3f6e1922dd565f9ebef30a4ed77367e06827524be0d741c0fb5985dd2d61cc25439be9ad48f7d817a545fcc48d01ac469870ee14aeec8282277b23f030a70941718ab28fed29e21c2903e98c90e92452160fc6691c64d844931f7f07659a7ef71064fb2f949286969055570da8d2d7ed292d63b0f0e74cee886b228c92e332306a504df707dacb6b2364d0af9c64cefd1bf24b53f31fe5684c8793e5802a2dd2c5772f4e0daaba842a58dbda3648106b328508b8edb1ab9a279c5a7cf71678c66a01299c6daa59c9ed5901f63c26a520b70f2249a648a66d63d200b7bf4f1af5a115c34af081b222b38dc86b77a59603f1b71f6ce58adfc747500c009f7e1b46b2db86be5ed7cd78c61fbba2af6eeafb2aa6898b741f5d921a3f06be604b84a0e47cf9617f56b0b16c355f01ac29a9f2a803e70d19b028b425c67658ca5d5ced8020a59b1aa465b7eef83ef1357ddccfb5f7c25a9de54917b00ee538a55dab14ceee10d5f969f470948fdfdb14128a7a97aaa1dac765c7a1023fdbc5b9f279fd160fc475e24e63c6a522ca250f91bbda96430cf561d9aa3c6580de67cec5cf90a0ab49e59efabca06bdb8839efa277d9fceb8b1331e8fbcf1ff97886ab7db4b5b3e9258bf51707e52ce0a07d7becc75e0fc9a79c013bc14179d3308a19c3315499f1e2d1ae4a4a7f31599a5b7d18b2521906e7f89779047cbb368edce03f4d5598ec071e933d8f55c26fff3abbcd419b60c9d48fbb4bcc672d491be2c89810a0f9021dd96a98dd4f26495581ffb47b222d3bf4c9375922ea17355e059977821d045aab6cfc023d55a711279a0f7568cfc783d20fd24a0dedc021e0ad1a83acb5001d393e1124b54f8becfaecb3b7108b78cbf3c753c79658713627431465954e377250b771a650251b0458dfb5227c3c8638e15b8377c413729cbd2d4fc445d1ef82773fe32f13c09f81c8dbdc5fb3cb3af423312a039f070b7a2ad59349c5277174363e306708065f8bd348ef16bd21dc2741b310122f1a84f8f4a1a89c1c360571151c20f836e0a248ff8eb7eea324b4f8c347fc4d7d352440a5fb556452e8f2a19d417b87a536b2e3d715fc906cbe09903257b75b90413477c44a63497024822b551609bf5ef1d582e04685a420d62517164a0ae67024fcc8daf69bf57dd1fb38c501924568f7544ea4871cd1c8544eb4f588ba9326c8c4596e67c20d81d9a6ef766bddc4cb32776eaa4187bf6a1fcd8f5979920cb913d4520804a33c8523cb79efbdb3e29089850a7add8f171121ead1c98559f931ef73dc313705288f97b2fdb85ddc47bee3c84c9dc1fc81c241eca2ce14d6019743eb1f6f68af79aa1da2a45ab5209c5d2a865a9a5796a487671d29ef8ed2cdf2f782424dfd6ad8db9de5965c2b47897645085cf9062529677bc38fb45b15054af2816d505ffeed2cffc1fa462918b50f1c967b433570b76b6627fba5e36750a71e30ca02f6335fa42b7ff8a1165cc9339777deff4e40f7990e91964b8e90561262d67eea2ad1d64b0a66baf45adb6ce79ef5afb5b85d91fb5c48882dc557c092a6bcb490649ffc2a82c065c75d5d4735195613eddb8f2c993896f8d3ee863630d22b927d0a6676487cd324a386aa0224f0e334301f9e70798bc10ec673e35ff3cf69403886eeefaee1e91d0e3f8944bc0be43a05ec5107a53b12f48dba37e4e383bee7493eff0d6297487892f0c4b50652a14df5aa71962532d1cfb02d496c08d774af399c61786e88385eb7ff21fe09ae619387c1c6c8ff5646cab832e3a06bb3d2bf8f06dbd9d99a03f704d569c7ce056e37439918423d91b90a2c33cb2813001f40d3e637d8acb7f06a01da63b75b410e5fb19a2fafe7ca71ba9497caab08a4a4598ea33b1ceec646e03676d977ba488a345a2dd3b503e9b70079c6a8d25389a93347a5b04ea7af4e802c1291aff3042addc5b8cbfc9bd5d30461282d44fb9575f586545d15e05a50736a1455060c5b35827aa5e02db6780defd72521a908b252c8d3180c1aa0af93e078e6eb240f37f54d025adaf05db9ace960254bab83c786d4b7598305ef9661f0dfee1bb2037fb064e44181ec9780fa19869074f073bc5a40b97f8b7dd5f700ca2696af58f11bafefa8c09cca6cb53da8d0ce6420e079163562f2ec2a5bbab998d5456dbde0f23a17d741f531e441bebec647e3e4d2e502da381a6eb588c7d47f75621f8ad8ee9803f82b52ca080ac581f163b9e452ea6658c560d9c6650699a98d578b66e2f613dd93e67c3ddff99a1cd88badc7676f89d6912af404f85f503ea58b7afa04f3f1ca30da3b3171f684b5042589351a5db47d22e188184bbb40654566b3ee48cb7bf4586f564fc7eacc75fb9b13d8729a2f7502ee5da96600b247f65000e9b667f983920d973ee8bbbb8347531455770f42e5b9b73b604f18ee0c3fb1279355afb39f671cc4a6dc5397086fb7535731a435f5cda6eae510e93cdba9f1f1952d8bf06e5e04a631ac98a82bfc2d9a84a9424fcfc82231dfb15de4dcbb78269746e4fa1bff2d05855f743815751faf84e6cfd9983292daf7385b2d39fdaf8e40a9a017ccd2ffa94afdce8ded62f45b00f0341b7b9160abd4afca6117f7fcf0395da990aa60e359298f8df0dc4c1466a0d05a5d9e6ff36d1f1d94c6a132c816296ae5addc303fdfc91c9ba90abae7980b8d28e72953b3e77f8ba0a4fc357cc6b9d93eb58aca7c01d4acdf009e34d5b9ea2f850045c608e39d00d64553887ec991b19bf2deb70388ef48413dc0424690e4bf5bf21a4f5a2720841ef0ccb438e758fae3aafe7e3b3bc4f6a9a79a6da2e6a2439103cf76117db11f60ec8f4010e7b7bc002612a78be4fbc0ff87513c5183cbc60f7c8cc395abf8da8482c5b470935500d9ae43bb5d493cae2b251038bb2f084dbda57bbf4f799cbc72fa9699bfb1dbcd5689b84118342ec716c9fde748b201e283c5c1f1a5b146ce139c2975650af02c5f019bc1236b7913a6bb40d361d35d8c492589e100199d174dafa7d3ca663d24dc5c11c3e8b6c69ac44202846c5bc554f70ef918c97b4a9f097d3738568d69bdb5e344d0cedfbd6559a86b81d313e04075c6391d669df46e304c022e71461dffd3de5c6f3dac057b4b33a252fcc0575bab9572784147448da865303c835a01f31c9580299de747e4842cd07f512dd1aa81c5ccb2c043e1035b10e8ebf492bca0794fd9 +MD = e855da51d23beb4647c4ff3607c3ac88e94a705866fef02842b76be3cea65b43b545d673dbef9972f35d2658ecd60bd82373a5502376d1a407f83a369bfa6947 + +Len = 78640 +Msg = 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 +MD = d0eb914e0164d7b272e0b8bd16c18bb311fa528db3e31c84025f259641921649c222ba1be6a205439cc07bf44b8faa02c73caf3af31776cddef89e8e05c11a5f + +Len = 79432 +Msg = 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 +MD = 5c59f5748218446099dac3a2beebb570848a6ba3190f7c5ab97af95dbf50ba080a53d382aa213e9e6d8a27c249ff61cb424900a0043696d7477ce2bbfdd2605b + +Len = 80224 +Msg = 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 +MD = a3cfce930b5e8de54554e9c31cb3e4b754b24e6cfeb6b89ada2ca51b907a057d3814d11980367109c1f55b35d7b187e3be90cbb90867bb59b78cf6c04eb2587f + +Len = 81016 +Msg = 5d146aa439e41599b3a48574dd33f12144f8f8541773e1c28c182791805e350d5e136e9c41f270f45d779a8b9bf2cc4f83db6d985f65b35b9d551ea076154636cd04d7a55a11da640788364c9a2b764d9585cc605a7b56bc9324a14dd1db6c627392aea6ca69da517b7f619f24077882429f1d9352de544f362cb780dbd72df91963fa86da21f8237f03236c7fae5b5551d1661b8db5357b4e166821da321463851fc32fd261bc42dcbc859bf447a7308cc2b1df54297fa7a289bc181713a608806f1188fa53af175a538e15cbfbe27ab91b05c7ee62bc3dfb2ebc4ddaa36d51d1fbed79991c5808c07047c04cf1969aa1836bbba58773a421ad6fa96b09f0a4426a5eeaf9e73f7ed8bab685bf524afa0ca3e9a3bfc12d44dcadde12116eb76a99646dc360daede268dae54d6b458701c2238a6785377185f4d60f7115fa4b0c9f9321ec171de99a3977dcfe99f3d4178aaa53f03f12c7cf30d20cafbfd433f01c9c824e66d9bb10133aa2819183b9a42de04e243579b78a5946ddb25725f780d82a98cf9436ecaabdcb3ebf9b1ebe10746e82ecae95ca1e37dd8864251420239ae36c58eb5b03d201d1bb9fffec6cc424fcf731f48d87f3923d17ac71ca35402b6f05d2b17188efa5f51e0804144a260831b6d94d8a7771320e9171826fbe4154776b232f9f046872de71e4f3bfe19fe7b6c6cd02b42001dff9ff9da12a438ddba3a735ad0efea73034bc1a1414b79888322ff65a320c0960a5681716234d8c889ac0ee73e5fe13a7a10592af3c5677b44efa3b9f2dc3f37ebcd4c7298363a62505be38c84d8c149ecb56340c5e46a533b22e8317cccb2501e34c9522720e43788baafaf66e3112df5ab6e873a30d8bcd05d3b80c38ae09b1c4d6694817d5cb4bd58b1c436f747530f72e962b3335904af0f2c1c498f40555077d2be49b40a6648a6985f879dea65a4ac4267d35461b711a918688152383b75446c33e25d73c8b534c1f5cb3f60b25fa8280b1d1c6960b2cbbef9fd7c5ea9d513b199ede23f68ad83dd1b946440d58b0708c0f313f68e0cd75e4530561a2d0a963164ceeab3a28c0438355595014bd139533de7a38f9b8a6c94deac880131802c6a08f7cf7712cb4671d7a15a3891accf95b68d73ab15b5ebe12ad47a9a53c056da0b1b090045f5bb0886ea2c4d23882a4edf36eccf8919e5c1be4ab64c006595ffff8b3fd59895e26aa79273b59dfde9fd2c8677636210eac50d71b39cc3ca6a4a3adadc6da7264d16ce5cc9185d687f1f02febc0d3d455b59acdc0b131a796457617c574eee116bab6f8bb4dbde726a2316f223337721c80df10c153570fcf495f80248efc9f1ce871fc19f76bd863bb7cd23356cac30a1309e647a8a63cf9b8452ef29c6e751d6383371117f672e542b89e46b1f58ec878fe987a3787f5bd9b126a5627ab28c134d6f2c836c67d5542cf1c85cd1e9dfdb7a86d81886003c3f9ad7c78b61b83b162517469db43c15ac0a8941631afb652d6edaf85239a2fb2dafeac81d1264d95f5db071a8fd5069dc62b4e21650ea26fdfb7a4ad919e3f3246ed429900344d14f65ef103d9e413c65b4091cff2a529fbd9ed962259d3fbed466285e7ccad4cd76cc17b4e41d8b17c88cfa7475fda129fcd77cb0b03a02d88e145be94bcf912865feced204f19a86754c0d6b234172702c23d8c91176f9bae207e36c7598067c8d7c68fa48c0fc030c7fb6738fac32ecdc02620dc1ea70e0509f532a929ab1345dd39a8ff7f22c07fe969a2003845f0a7d01cd113a0af4e35a793fd62b6e0dda6782d825cb1bb72fbc3f0ce3376073539f807e55f23f123e7ff3ede1988888f93b18863e1a8409c4d5c7934f83d70c42a42cda5e731d455c31bdf1cf7250cefb38f3394b6ee1b071dbced1d7813e86723b65759d451c0ab70025f002317d2c6af1a165d040bb27b12ec32cfdb83d7e4cc5b8d494d0c1def97bca4d2c5e644db2e5a1905f3856fc0d4f332934812a504cc3957bc7be854e7df5298da0718c9f8d95825d6aae6b99d0cd9d3b0e74abb8fcc589efc856fcb5cf1cb225f0f37c8e3581b201652b5f7db62a7ff70e1b27f4d73c1484f9429eb15742f29ab05cbab6552abf40e127b93427d649d195ed25a066a7b3ffed09d1cdc11869704125ad9467011870613bff49a061895f48533b581588e69506053c77770d953b35e6eba4e5954c3467c0982aba4cbcf497f5cf687e603b08f6dd352af382f45ff108eb645b57c8e1576e2a53d0086326074d587e0bce1fb011ea6274c11915532504335f22e92d2bd29d0c517c150a8808b27ce54813031f09c53ac16a5066b9348139f1e6a9c7684bc5d4a02903219f2ecd935abddf83ca20e624bd599966f691d895c9111a562b358119cc615336bffc07322ac7a4203609d5b6b50984949fdfa2ad413ccb27e912473232bf75b87ed2f7eff20fd156e7171c773504828e1970580706c43cdb268490b48f9dfb25504608133cf117a651fb12ecd9d513a1f7e661296631dfde67eee6171f77441bd8e7c0426815c78d0b08616e0ff5c88ecfc4668afc2024b021d3cfe08ee5f0fa8d1aa8f40fe8617976d1709143e11182e57cd0b244f9cbdee8b5b6973a64724fc1613abe90d385fa39e8d8ed12117f4cfd822825bd3905e9210722a1ce7d589a3a5dedf89781a59da8b0f2e7f711724b5c76e55be158933d6f6a9ca6979b14583c634b48805d30c257bc66f86f6b8aeca6cd80db4df2d46a38329d0c423826086c13db14e7d0c816db8d9dc4f78a39cf40e8931a4f7249edf011ac494aef0e393dd205e43a76cbe988871fa40bf7ff61df7a849f826174374b6a42f40e3a5d591640643d04d9ccd8f34b653c292f5c22c6d5edd1734ae3e48ebed973287463e6a9c16e95b3543b63b03cf6e3ebbad0a09b9d37669e9909645e72087d1657e2705ce79d74e280a7f833fe5d31a004ed59c232e9b560d665352f463848544f2974a4156950fee99324e2e1f0bc02a812ccdf298d54667d77e5658de18b6eb4d96213fd6ac084f97d6861aa69d9601ed16847038aba1c08c1d3b5cbbcacc23352c720e21a39f13ac741249a111064c3b9ba9e337a5cfe02c3be8481f222fb4526225f75e023e018113da0439f076d512c32494bc4b388f60dd456434a948664e3f2242b6524ce3bebbc69296c050621b97ddcbf0264595d00d3af722e67d01cecb51375019317f0b74be3ddf0cfbbcfd1ebcd0fabd5cb923d2af4b1162374c7d0f9b1e55e2549d0e47aa4b3d59dfab6160aaea0398e7c402358ca628a3df100012e63eec321f07723b7205d73164f6ef668d6233404c7f143cb9518f33db1502dd1ce03e93f984dd59feb3d61bf2674e374f80b13cf5af02f11e946f9a95232976234c728c4adbf8a8369d61a0f1c427dbd68ca614481f735ca4b6f05e73021de7e5cab1a67bd56a30030aa146c9d6215b0cce3951af96108431013909df79873848a22367f23adbf94b44bd98e265e5bed78e937a91db8171aebb732340520f6f361bef5918d2f50cf891de1ba5391a0c2113db1755b76d2b042dc532fe535c96967e3e0455645d70f03a2c597819694ed1a63ab165f27cbb199f58c0814517b44f1337ef12babe2d1d86ced9c4ce7a8bcf8fd8cf28545728d759535430efe7d24b2203a2b59abe4c65bfed23f221f4cb0316dcf906a5a67a25a2df77751b75f771f3c9a5a8cd05d4b22bb0c068d7801655836fb767ac10b9eac424afb78f692ba9ceb281511b3ccdeb14403790bbc575ad1db892b3323eee100549875f146a76dbfae6bd1a4b0b3ff8c0c410d1946ceff32de01152ffd8217eae7784d37220e1efc08ce16a271933c17865d492291c8d0ffb0ebdaddb85581c06d5307c713473ce68cc75a8750fb02d834b0a3d437e56e9cf6b1c2a8eed9dd2578c12c2d94e355e3acf023efe94bf262b9d3a39aa395269f11fb832dfb9f788e7c3b20e71152d887dbd10938a516794b684ecee26f68978a851192e97916f2600a399c6023265357bbe250fe1eeb05d6d27a9c47f5d04fc3e29c5847e1c0b94e8544e54544ce54b7af8cb1aca12a26a98aff8237c15cadef9d0469e5c03d5bae7fd591e2f0cb3b4c396891c0e6546a37f436273e7c7e307226e24e2f9edd58147c6438e5b1ad9569ebee77d7591a3f0690c6e1c861a585e002ae5ba1d8312cf4ed8930a9f1d5f1b52996ea5c73bc13aa031a48622b730cadd2d138d8f6d948e465bd1fcc5be4be9294ea5fdcc0da9676adb8c1982457335ff9f35c2185263a4757686cb93a4a7aa690515eb4caf62611032af3e706d2986afa7d4c380db88fb245239dfd2777b455be844d80ec9f40ed95d945bb2d75ba5356d77f78faf0a799a1772a049e1cda2471cbc2ddb0268580f85c3da112a1179d91aa6c60c77f10821ecb976c288a7a975cc05507b02c526f8d1c521550f51ece3d6ea98c1da458ffff997c9031410422c1ea5abb672135fde6a219a462d25e59ac8c9d574810ff57d679301d62e1155b63a26a454fa5bed07775fabab2d944d4819cde5ee135724e35e3686017eb0ca594910a51c41a4b7bc2108be4eb6a60a33f07e31f7392303790506c04cabf7895e73e915d7f0f6a54490a33af5716405a376631f579b7d7a86858d18815eee7a0ddf3b5c4dae599fe9ebb8876905d526e2d30418d5e06c71540653f4663e9c86adb68de24624d68df15bcf0d721b0256372ee9853ab0f9d029afdfbdc5f40993881f680e8afa7457a5077133d75bf17be9af9bcc4eb52a7f4ea8b9dc64273d8ae443534ae0d73ce64d182563626cac7e4180a157d99409670b1a69b70b8041540a4ad6fe1263342031b57405d9f73b4887c6838ca3f89e6ea72d77b884a61cd7425b7990e64766ee9807e57f05a3a4c003accad57387f07d6c086c469643d6fdd39ec569252bda39cc35003aae19f1cdfc57fd9913e9077da0d4d0c808fc78ad073c41f197b697e713684d9e9c012a59bcf2a43f49c7eb548cb829a8a37b08cf245d76900391a5e1b6c855149602554b89a34731dec9a5ec78dd014d2f68914a7328eaaf32640c10fc7c9f0266c47c8bac926fd69a963b2bac6adf1f746a18083cc627b4edd6d45b2fadb3d1d2f0a6006de9a39644d7b8fb6f884c86392aa7f0c75fb509fa8f06a995821aeaa32edc9413cd6cd9a63321430b5fcfea485045ea5b1a1a142138aae478245bb3a025252ee8685107865380ebc616f0b36783fbde411fe03f2c79c6f31ebafe96937e89b632e2da88addedcdae9d637495f6bd0b4c2978ef1e1f964bed06d8cfa42e010153a638fc5e37d3efabbc62d15f7b1cc5424aaad910a618b2dd5658c4777f4c3314812f924efd8ad32860f597df9fdf7a7af7fc4896d58442877c986e4f862a9f3a3179f0e9b96316a90d843ea2bf65a93ad3f5b40d3879697fcc1023b8dd1ca43959b09ecad60d28a234a74c55745fc016411fb1e03958962ad7789b300e92f0a64c6c024eedd997b858d73744392e5da1d1e2a8bc72b2571d210a2b41853df2e59bf4b2026b68d23fec8c861b8841e04208d73efe5f173acb3b7d6a69cb7e299bcaf32461d92b76bd823fcf27dc3ae69b5875bb2268e7afc9792acf255bc4131d5bdfe009a1a1d3b59c796915cf89df024346c3c52ab4247c8c9acfe0b0b03e0eb1236b567f6c97ccbdc1ea51bcbf480b4bb2df631efd4778c855e33854c308d48d562cc4acdc31474891d9683e3ba03af4526468a0337722cee4bf98d26d120322f0baf0c4711ed9df71acb5ce9f7605bf9e095278e7322ef2bfab9e941ed80f248b8c5750dbdee8d4e9dae6e84b37f0100e24cce39916d1f65f3d962468c97d047f1764cc7cffe8eb52ea6805df748e881b4d148ac983d02c3bfc3c0ddb64c13543e2a5b1d4d07e654561b5c1bcaa35aa5df8e5d8e9079e26ee5ddcbad74870599284968b541f0de549c75c86735789d94eae9d4888209058ded914b5fcd30ec3b363b3c3ab2a1bedd891d8de93faffa755d4c774175d5b4496046079aca301165f1699f52a901ce16a4797348f030b970c11e0c6271c436cac563c807726dbc3ddf3958a52dfa562875f2412d50e322af9dc75c927ec0d537a452564ecdd035eb8a1431dc46739d3b84f1c13f68b07d5779af2f7aa5b1d7b8867a7916e341c3987a63f09ffc55ec755adcb9273f801193dd3e4dc1ed7d8577f143f907bda9af6c358c5e9558868b017e1cf28cdd39278952dc7d105f0d279970159dca62ee428e45f9436761efc205781a34174bc507615ff1880f0149054988582e07dafac127321067bd2078d9aad13d4670900af9448de53765dd1966adc37475652eb3775e823b913d9b0a171710ecf23eb4f2455a632050bbfb6694eda8d2378d6503ab5cbfe18b92dc8bc575bd91fe29c06432ca690a9bb86116d532bfd83f2787d1a44870691b62ebe52beb609333dbbb4709bd270be205191372a491ef54da9d04ab4b1e3d0a56cefe91a2825a59f9ad85135a268ceb492b43b36aa57f3d4ead86088d50c41f158fc03fc1aa4e382e9f0595caedf37f2d9d90dfad83f1c32cc23e03358e66244836117c7161d7971f97afda3404aa665979e14094b4abae1ce114e46c618bdf96c9db92da2e5d4077a06b29c1f4176874c71d1c48bf17c6c514f0f2594f9b1aa85205c7239948f9dcbf21c99844a44d268d2ebcf02c9cd2d062ba7625e2fe9b25d87764752a008bf7feb903e37cb8dc19d5fb68b584a19ce4d45ab8f7a21d2bb66419b0f76aedbe6f641b1fc725badef2a66c67bf4e90eaaa70b900f8165e9103fdd3f5d2e07759ecf930656ec6141c5c0969033512d085ca40bd964fc62a97b3ab8d792d15072618c6de1c00e72d5bfd04da823f59c935eb4c4fc1263aea036e762f86318f03eb98d20e8ea4106d667da2a72d07a9e3c1b59a58cba2fb049ede67a16205d8d5711726a90183ca3c0485e8b94cb28d86f3d235befaed90e230a985cb55d378e3803bc895bec59c02fcbde0f6276b8a1a91e7226b972f81ea8177d995a9c0f597e0acc2bc0d910f2717cc914705582a07649f6a45e98f578658f169e8a4f6d95858131c04350faa131d5b039430a1f4b5349f16363a36991d7ebe3faa909dab8db118dc578069f52fd6113fc6ee6f708dc9922e25d04ccf16bc8763c5b3dcf4a0b3620c9c34c478e109974cc388ea27f5ea1eb8f9f5f881dbd8f4db1f56dc3bf8269ab3bb9a4bbc92809432754639a05661ebbe9cee6238d39aacb1a2c0c508fdd267da9bfa2348ab01b1fac36f856319f4a247f506b37b66cc58ed353bbee4177f7288269c77a4925596ab944df5f9a46ceb5cec8413d3fc349f95bf0def55aef463c543c76d59b144ea4dd226b2e961906d0469afa9c7fd9c2ab32a7f81e52afae199dac52dee6f9555e96443e3bbb62ad14754d19edfd1caa14e5dd99c1cf359940dd4dce0eb3312818532ecb1f80d00be2d953019a3e186aa6f4063678171d925281755aed96781132c24684427cddcddbf1514439c939af01dbb650b9c0d413cf38c78be3e72abb6e32201c3d05e84d604bac7445150cc1960b626b0f52d5b80741b8c39a5bc5810b414fd567c28c050046d90434a81e6ce4019ef7c153bed9ab5addb4693ad4fc9a6e2a527b1935af4c817b668108caeb6c6cc089a839dc031be28ab0e92ad5a8ac174415bfa071869579e82dd2adbed7af9b7b930c7bd9cee957645b929243ffb0eb2191ddcecc457baec3cc720d46ac1e2c34a676a014979447df16ee17ac7c394857493e1aa2468f7e72c517be1ef3487d60266f3d38e79d327f6554017ba8a5cd39ce590a90142187999a0c269427bf2d92a56ea9a3497485a9e97d063e0fa6c86d73c7151228d2489cddf7dd42c3d2bb50a5ed7bd047aad002f5c19c701b9ce846ec00d0b51f224fe0e34358975223850eaa743a6c3ca0900f2cba2a9e46f8ab7a998eb3d54181fc2a5c770f2e5d423941258b6bc3c3165422f0df37252c5a605cfed9451f4a91dbcdac1b97644f8f468c99ab6673655c8ae2e49948b13622c582ae68eadf94a27d4f44a957d5939b1b35995cd0f78de3a2c36a80e5aeff0239700ac63bb2ba543f23d898e6fed3c645f0870821ccb75c4a49052e749ae1494aa9a669ae152627cfefba72bb5c8ac14531f545df6f7c26cfe856eaabf17788678403dbc893529d7e077ccf4b5b22fca77e568e706c46c3c225b25dc24f3c401eb3959501a9da05e81f91e72d8736d8db3a4d5a7b2fa1c3cf85a9e07df0aa00eeacfe1defc527218c7c8c82c86d21065efa2c2266360797369cc02b25a24b2b35e48fdef961c450d9b2ef0ab2899bd5a132958ea82bf2ce95bf77866fc09a5fa2dedd70a52c3c246e671bf75248e1e75077fbe7d75dfdca6b72529aa2d801feb400694b7970e90ca8eda5c14e47adbbdb3ec1d67a68832b3669c3c065553c88d7fdb5f7ecec657a17db1ef10ce249c3b00ba9d2e7b82d5174fa4da02dc484ae8d2b35ee85db3c1d4993ea2ef4c5608f5d42f655c5e946fda59872b272b284a0422d8b97cad9d746accc89b3bc5d6c7f519959e78b688a5056e8b56fca8ba73ea559099c2264c186bfc99027ba16d8243b5326f0beb24219e75fa840abcc86aa155242643308856e013f7003847e3e1e5924f019c65318bb0551adcd7cf18da3108dc87863418d6d0f82bbdf921008be596337cb38b768a40f83487ed4a7469a358ffe51498c53f43937d6046968c294aab2807d9c7bdc758458facd493a2bffe2cd76773c6573941cc3411a70e4e621db874ca9480cceaff24757412146a854a6baa362d24966ed38b9afaa5f10fdf65a460ee6f1f6c9a3e7d2c07313496638fffc179ca1c498300b8f540c7a897472a59349bef0a657f1c38fd8cb95aec00d6cf6459d0153a23d13b8e0e9699ae4375be38f89eaa7f42a13e302b30f0360526c3dafec9772ff44cfcad8a992d1c7b4dbbb42e0367828bd5750d0e205d3a1988c36d8f3ca9f19e7be49adc58cca896ba38ef64a6aa3501c1c6dc5a1009c1e503b76334b21548ca66d99c2d5bdf1c3dc41d32c310d9614d6c19e43a895c92119f870517b222fb2014c4fca52bcc3e177452c573c85ece17de576ed412be7744641c9b5dc438d4478d8e036b4ffdd7cdd1c0f09b569f44062066c250339736265b5c6d3170bf99e8d91df6a84fd8ae06e34dfb6443068bc2393028d7744f98608b30c2b93f1f13aa015b2083b4c78d6bb3e22df516f96af4319ce8915e4e659afd80e41db8c10a360c2fc82504313aa34868cf7757e2ab44119149a578fc657bb7351986640b4633028035b5ca7e7e57abc529118f281459e0f9943b4ac25facc335aa1cc9668e4aeb38b05c8b15212fe2e383ec45336edca6bb127d5d061dd5296adf06713bab23d03e8142d160ebd2f7a8252f016b80746bbf08913831659defbbff6de4f06665b87af08e23c6a4e9f1fe56034b3814ca38edc19f64ac00ac1f0f5478a8ef85b8acd445690aaf131bd9cc6090ac02f085142d84d067deb6abc0502450479ed0c6b334c7fa0d830111b6fa89fdab31dd4e0867984bcb2e4e42db65b81c49671134d582bf6ab4ab3673906f1a73d12da3cd1b834639170692187736580534b10ead1aa675e0878d7ae870155a19a45e0aa95569d6c2d4cd48d69cab4b3392e390d78b8831850f9295185dd39318ae2dda8bbe01900d89ea392352acdbcdea675f5a2f113b80d3224eac5f910b977700da1a5f34bb43bec72da8a2214efbc5a443df0f27dafa5ba66e4c7e370cbf8540d3ff3fe8a18bfccbec0d93f2ede7aa02040e31b3581b3084be9fc3aedcb762568ee16606880ec95e3df92e0700b621e9698e9f9efb0ad926034e35dcc3a896a8d069dd77b9f4b0e8e9147a48cf93b2c13c0861ce0cf0def20800dcaa0bbaa7a0643fab217c6436d1b9077f9ea1a4e6f243237d2dd2f4c852945ec100fa141fa5110ad8ee1986e582727a45efc01144e44788fda2973f1ead6e10ebc7dadf861e9e726dc5d7834461df14d525720355000fdee814a1f8686b5fbd62e5f1426275d421718dff83dbd7c77e362600a29fac65ce476d3a482ff32f0d2f4488663d117bbcec30d9ad334df16070dcb215ac510f002194a857f9afa6aa59cae6739e5a5beee795ad2ad32926608c2dcf850458d61b7e71334c51068b39e86155900eb83b5c68a4c32243d42e299103a1192d2782c867ec2550bc60a865e5f01be51493e4b17a4562bc0cb7d16187456efab128dbaee2edc48ac425c3d3575f819b38531f932260d420b539d7b176db7f4f18c2a876fa5c5a23f0bea52e4696cfda0260b2ab6add5f77c6c107c067ac1c41e85cb3c7b4212d42c891161cbb7c4dc9fb2365a059a44ce9c8b92a3761a28cf8ab60c24a1a248510d507de45bcfb4391aa02021af79ee39d428808bd6da4199be8359ea6334eacb59e89c45354faf85997664fc34db16bbcbc9669fb929b095228430f840785e958ac7d91eb8862b54a4bb8164062c62e6dbe4b1598d86da547f2f2dd8c9fb28321854c0db76219c28c4d5e1d3c3fc672d9d10fd33d4703359fceaacf6502bec339b35f005fe908674625c22d5dea9780277c4a6d92e845018544d3aeb8388ff1c8be1d328b2517eca15c4a0d4b6d23a0804864a93ec21b501fddd5422c4a0f55f52ced6be21f2f98c4796087afd050190cbcc550eadd6e6c952018536a3f2436e98739720cde36b4d7046b6131190835f260d52a3d42249b109605a9191fb8decc566810b26a16880486d3647852323a5bbcfdfee0f82726b8c5020be2f3b293c522e20d7cccb55c7186ff582d82b6716e59a3967a075d55b43778436dc2fa9efc720e31110bfd78468c5905f7b27c2254be31b8b478b06f2d74d017619478479ace56431a2fd423ac2048327fe96b9534730d2d365207be4a027050677114d5c7be210d3e4124a7cbcb34a96d2f6d113701a1bca79d4988346bc2b62662b692aacbd8552648d44aca148530688c69e085ef532fb062601612372c10476e46c46c7ce1e4794ccc55d184a4901809484845c58d4df8a833b00dec1828719eacb4345aa582e056f4100aa1f79126adf092a00cb6dd2877aa9d4d14edc44df9d0aa2bec8cf6036c34c29bf6e7fa3a814a05bd4b35a8e7d7ad27f93613ad82879aed79baff0a899974b4ac08dd95fb8b3eebc50a7476ded1249439dbf2abb950f3c7454c64841be29c2f66613f2812d5b58adfd1da0eb46cf72d378af2859a5dc17eb72b242d60519479f088767c2667952c3429cf3a12b10f3a18cb7b05ccb5ee5bf9dea8cd01ed44da7305eb59e047c817eb99bbc0a0a652030726f5f1f86060a630ed572ca5be949c17610586e87f34932daa07690555a9cf2a24c812c56701a787e19811f5cd6d0603232bcde517c3ea22e219fdeac6fce8a94c5c30dcd1b7a62440d5469821b55f60d3c7f480155c62f1cc5a44f6003494ad271913e4a66cea2f95759137c256f055f940c46083e645c3ed3206d20b371c5e3b688286ee07bcd165e0bb7ab936010b1efe052d684bd9bfcf0a0a25efefc8e313af466ab27064313a7d8c080d3fd9aac9697f91cd72670ef9481998b443df6534572737fa8f2a799bb6cb8ac657c25983e9f932b94336d7f356fbd3631aab0b28c9ed96cc4c55ce11f242a7ed680240d3e63db834a69043469a787d045e72fe766c602e328f2f5a239ab7088959e28841c811cc4783bb7a797e573e9df67d65a6a748a83340fe455914f355a212aa5955f73e16f8c200a3146862c038ca146940e46cabd7470bb73bc9be35417ba2da98db8c3d514ba7e69fc25fa8dcc27e32cd8a95e0278c9ed75221df506c7c123491dcc2ea5a06f86ca3f317a192c605e7d5018bee2af7ffcd2585204f2efd418ec963aac41adc3b5da863525161beefb0deb0167fe97175c23c5b47da8ce67811c6d60a7499b3b7e1347ad860519285b67201fe386ae049de200c1d98901fffe5129faba1df75b51ed1a070776a2a0f21185b0ac3b72ec44858016a3241901e31352455f4f5087d3f063de43eb56ed519592604c8d8412b296ca1f64fa7221d1db5cfcf14e256576a5bb9fa5c39471ec5bbcbb2eed303c9a8e5538898cbbb43d31c07e3abae458bc8597c7b7afe9b344dc8b0dcdeb25ae5ee4a81eab5b444d978f133575e62bf608087ee2e3f0d545dda083e4c407d30c6222392e24d6aa62737bdbdf4d704ab1fba6e78dd546d58e29402ddc9bb3a6cb56df9ee3908f6c77536070c82be9ff011a094804e6026910ba23ef61af7f3f6faf752fdb7905f910b9d5788c9ba38787b5783704a0c41e51f2c44ef089dafb6dde7b926238aadeb309535999074d92aa80ac3ae9900c53e685c9d325b557794a665b3d446a1e9bc2e462aa7a19489eedfdfdaa403e3ba832c58d025dbc652789c9bca6ce97b1aee4bd7bd1ac2c151ac67fe52b8505d299cb44865324f99484a08af8557d2c04868d070775abca3374c8990b354471819704855e4c0817561f232c96cfdca197b12053bdfcf57e346b78dbd83dfb2b992e92fa7d6363703a658621208c6982ebcd4315d7de25a2983d3bbac4cc157eb9ceeb365c3fe3aeb1e64e0b1e01b06a612969d01d9f98f1cf8895a869561fe5440681ab7317f52d4d1fff3cf7d62da298640924d7c7ebc65acc2b472e729719c853dadc6aa214666c80fe5946505dd611fba5669edd7aaaca7640f99c980776c7456b4bab54ce04a0a7dfc27226ad7f3e5ec317eb46e2198f258b423c3ced76c139b77bbdb68e6289f3281b13cfb908ae0bf6db45aa9e9d19487eb375d7c5a436cf43defa2dd21a79015bb59391ecfcc1919513266f2c90095d8fcfd20f0c899874a508195145970e40df448a33d5e6197e4242160b08acdfe322e9e9393e9186a83f6973973562ba30472a501bf03f262062fa8d04af4dfd67fca423fcd84661f89785a1863df7fd6e17f99dc0c87278369baf03f2acfdf25a61810aa07632bae421ef1b94dbe14848c614cbb8cb1a701f30c2135b7e374f38f60315ea74c101d982f84a497b993b5ec60e526a74b1be48e6f623859f8474922eacde31708bc7672f53d62ab99a471ebc68da5c51b2a352129dbd278d5ff2e47fd0bbfbd5fd9c1b7b6427aef25eec170d96bc14eeb7dfb9383b58a7c4345abe6e3137c03180c0451bbbb74cd271aac64e3a801aa81bb3ecec518e8ce0ac1c7e7e20ea150fdff49274cd1d9ac65cf3bad2a6bee41a58d06b9372b75d4f21a8a324324b70bd45a9721b0ab2ff3a9b67534f7dd0e7b219b5c3c2117b8f7c3f9fcaf4e7c459e66c4f7273173010cb97762e19125ecc1bc8c473fca033a9f440526474a3fd3707be66f21154ed45e5db90a9d426d0d793d09d0aa7b1881353ee70fe08194eae9db680af7a56632515f24764e50dafb0d6db9fe657c7e171f7946bf6339a411714df1cd9229e3a24d8661addd04963de31445d959155c84c7bdcb3fb9bb96d0709a29c2d8e9edadba9918b733a6c95b65fa54696c8eda4e93d21e96c84f93af4e8abaf0b22caad90061f09d367e9addf9e68fb7872e22ffed7fe6cc7a3cc33773e5495f083c45b187a69266d0d3324c09a19dca933e591e3c8dcbeab6cc4def48738118c35fe4bab82fa61ae8efb930fcf428aa7606aa34e8c577f763455a5f33fc0722c9deb07ef9c6d3c26618560f3aa4d5601ace3bc859ec8ffb6bf011109d4786850401d084b331c164319731732b7c4ef365de3462f6cdbeffb5159b89ef1da44a5b0f6c544f39190b33b473e337433b6b417dbe8b292faa0929fc1f528f460978b552ae7733a683bc53b644e8c6c043d195f501c95ad9fb24afecc6f4e78a5e17fc10bc74c940a68179e7cb0940bc0f2c498c24a7ef945a552f2fb8f65db14b301792bed378cf2b618d8d31ce0dff4784448b4faa51286fa6910b1ce05b8277c9ee20dd1da71ab96578f19dbf955192e1703aac5ce85de11ebdc91a3b48c68bed690140d9c0eaf993205b3865407a984cb4e060441cfb58c59cb0dc8e8c452ea1707f118f2a0793f56e122a47774102ccf8c696ea56c97ea4140a87618fc709efebe075c74d392e934a609aeda070786a243574d7fc90f8c20e1d463db814c4dec26d960a914872739d8bb0e025cda12d217322927818712873333fa871f30676dd6e9cdf5efb099f4ddc96a76c21261dd5c8c9a330298fdc29929a2c222e77c0242bafcf1c1b981f449b71cadf33ae42297e91938e8bfae81a828051 +MD = d1089feae2a08019d9b7b121bc3fdb2e64d90647735608bf4e34be89f453d1fefa35e9144cd3a4f389d3b911b330af775ced000746dd0b526a1ffef1648e88bd + +Len = 81808 +Msg = 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 +MD = d440079d982249c51971bc2035b6dd4594766485424563d0e4d6822b26d385c9b415702dd7aaa6a1b4c180938c4d30b0ba63d09c57cb2312d49ddcb8b32602af + +Len = 82600 +Msg = 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 +MD = 97dd0fa2b0afe26af1ee630a4b1b0f7c075753a79e1f7303c0577d869d23f117c4a8611e845cc4065f6a85b9a2e0a684883236d6fa65cd772363f1a26ee85bdc + +Len = 83392 +Msg = 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 +MD = cc785d5ed3094ac12e2069c46e3b81fe9830ac5f7d752880ac683a7c80433c8d9b2c9bf59c8e717af3b730aecf76dba6de4d4e6d4cf9fb60f550c6eb77baf5e2 + +Len = 84184 +Msg = 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 +MD = 9e99388d377aac36afac4a8566b9d168c6f0faad772b3495379d680a83d5b482a617c89d9744f12694fd47d1c9dfffe91ad04bc3940faceb2eec299ac386c4d7 + +Len = 84976 +Msg = 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 +MD = 0d61f8f4238bb647fd02199f8555a38d2eb4ac07cf948d499eabd9e77c89ca753963e95e036c6673b6c88e010f34c32c57d6f103de1b32291705486b29f93975 + +Len = 85768 +Msg = 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 +MD = 5ed9a434feb7ce1332733e6378c7ec0d4b079cdc80eaf5a9a7204d871ae6bdc685c95a9aaefb7246f4e882428b9b545e9a93aedd4aaabe1dd14461fb1694b896 + +Len = 86560 +Msg = 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 +MD = d34e6a8ecef67262a956051b3418db500aec04c537088a86059baa48cbcd6f6504a7354880dbc1910f9ffb0cba8b77ff75ca9da6856a7ef522ff21d39658170b + +Len = 87352 +Msg = 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 +MD = 9354325be0d8127722ab167c4ba9b8c04d6fb4b76ceff8e6f32c55300c70705a3c2bf20cd85706d3f67fef2f2815282456cb9042ca8a6a6b9cf57e9737ec2592 + +Len = 88144 +Msg = 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 +MD = fc85c2a27bac262772a53f8eaa19b3df653c10474adc10497637f246b32909b8b4c97bb19fb209bbbd217ec440e2953ddece86dd54f3000b00b37ff34a61d2e5 + +Len = 88936 +Msg = 8595ad7ef34cc6b60238f58a9a72827a4b199a47e29a8c583a2e385d55a4c332ab609006c2a46cbcff0e0991bc62ae009b8a2ce319db14da669a27f074bf0e7c4df84c46abf170ebc2d38f83610bf180394c0bd97cd7ad69abfa7d92a9d6a4251366c786d4bd390bf38f6fa6b0f3b4c4d0671d743515c0ccb15521881c72edf5a4b1eb0e658f2fe43a4b9143d2a45d9206e44cfb691db3cc21b3fb1df61a51b4a9e19e2587f0ba3d3d0edda1eea656b383ca7fb54378f031a31cf3985f573829c9ffca14616742e0a7e03b0a2d7f05eff0219eebe8adddc3de99f1407eb00a1dad1256241d7c2f931ec993c4b7b9d40df5f290e68344e4497b31dd5f7cad2f58fd222a9ae0b7e91f4ad2cd18b3db2ad739443feb3ac66c8d21ed9f3b80d610a260382ec1d5a1d84cd502d14e496e6e13651f924535badc5579d31f1cb3b413c37e5a4ae021c165e1646287aea3f90a8a208b713a9da89e6a2bee464c3dcea1820093663eef9ff6a8a2f8d780e60465041391c4149a181994de43fa1245ac23a88ee86a2465c4f56734ceaa0b3d18e749e63873195393b59a3adc24b5f3d7fffdcf633edaabb7c8e7c5ece698cebcf82040896792f1a0da46e9c0ad7e70d69f496c0bcaa8ea00d9f0fb58756fc1780052c98a86c69bc8f05e90f77bb5e43169540ce8f7d64a288e4a7e1c3dd83fd467a82a45b9ff7a925fabda8a78a27771c7e65803ababf2b651bcf740281b705995e70bc2e983b68690f56c808a8c4f1d20c6f863cf700b32890f0eca1d7f7b8ef3da1308fc9c762ce904f1e19bbd97bddbbd93104c6ebc259d0b6ac4034d88fbe748eb1fdc8fe20dd39f0fb5927b75da6293d11308ea2e16f778b435c4cec129daf83b0f6fa724b0b7906e05570f11fb1c105c73ed2f888dfe1e932647474c9f35b3aae09f2b619dfb9db7d8d2c194a871fbd938e284f3121ac5b09e740351e55e41e09b5262c45d098f9237ebd82669c91ef36bce30972eb334b2a53349f984bf6a864872957277472da6298a9eeec78c3f50139b7c9b68313442436c606b03bef644ede60d96731f419cb6975915492227983830b02849fd8d08810791d0eac5acc194960f56daf8911be6fa52c278f49e74e2751465587d07ab66ec2450c23b55a6446ae6da3339e7ccc29bd11eda686c8c1a52ef7b1d1a69d4fb0461121288b99a064ad94b064c095751621d51f9e75887e7af8b91203c7d2a47358f3f6213a046e11e2fd1dc98bf639c3880825dda2b0d52742ed0ea4c09565268f8fe3b46d251ddce31933b85d398a90340da8ca7adc86289216002b0d6ff2486e27823881664024227baae7b0ba082ada68010b8a65d1fd6ac68f0d2accec67596d5a44236275963596dbae231202f1cfa9c7173de77914416103d19536b3f1f5c3c46daf841e9170ed5e9220bc3b63a845835421dbcc1b9a98270ec927d976a7bd590b9255bba478f1ac2a3622e21ed8bdae68c2ad4b61eabe311b532acd6403dc90a47851cd5dc2563cdcefd0c781f594a0bb8ce68785c655ea8dbfca20588e8403cecdf2d41bc16d89309a603c1b734d12d30d12010591f18bec6b5042c2ac561af11fc3506d1aaa39bbd23bb069d6597d35bfba385ff213cdadd287d510d1c55ea1ca5dd2d012be96d533dde4eb934c385a1139adf35b2f0858a1cb37e1b35447577a0cdbd36dfd59231bc11a2f3e87dcc6ae3ac27e21b5c4635584eba3b5755d988b5acbe57108c91c168fe0933cbef2e1e318264f0a5aaa544a5f70e55ccb09db9ae23394c0439f26a094d8b61233e3525c6c39e4695ff2a20cb568052da7e497152d934fd03023e9366a63065399569e86a18ddcc36865e3192121b18cae766176877ba52570ffca648af0127551a51cde4292a6acf64c8dfc2d3e490e4127b15b9a4d0334789b40a7713058fbff5753dfe9d8c08a7c4f1932243e5a26f2810d20d0980881a98ef27bb784486be4f5da17e1d0c8e07cc5fb37b082537b550adb62b4dd13919633365dc87c7f29b50925f2d50b1e437a49ca995caac35fcb3db29dd19cc2e8c130b2ca1e795bd9f1f9be1d3df83f37f7530db383283868d782193e915774fbbcffce4d340b6cd0fe5008d38718aa12767a1b32ce7b110b0c8085c18e8dc85edc090f53a3c330c36c94acd23afcfd776a1799738923ebdaccb17ec323b03b66b0e4ec79e8113605bf400085e40597eb54c3ff126db3373cba8d6acffb5f2cb7ee0bec2c7b75eb3c58daaa5afce307c2d8f7c28bc69971c5388cd0247ffb3ad6c5e694f7d871decbdbdd00edffe5dbb2393b7a4c3e5729f8d928557d1c04e427db2d6d4879957f38bacfbaab67ae721e27f78cd02f6cce4c1ef851466a1c974fb018dbbae9414b07781b2e1fbead698b17c480b4345aed337c6559fce4a2e2a2c76176aba205c0bc9657e1b78f53307d7b2adc64c7a1f5436407e62d162854c5a36fb4b73e638ecc87fe6c0f34405559d483166e63c284f078587c33692d4c1cb6cc1c4a08eaf3bbdf87238357f546c4b675c53d933d0acf3bcf82cc7812573c73ef23f0bc0cae0f0f7aaec064d28332936b5f5ed081f53400e5a044ad77f4998d415237a2390c3a9a517422d568a927edec4b5ea631d2c36a233b3883eeb2b8557b2d8b65f09cc302940a374438171948611f997ebd3201fa10ea1495c6f01d5ef52c6871d3de4ccacad78a1bc16b8b157252abd4948154132703655d916b3d1c37c55b40535f1c756e7277d68504f1e7987b1242584f4e67ee3da735ee52ac1fcb8ed07bef8dc674e751ad0f0371f2313bff4942590a654aceef56d93e64cedc18ef646f18e8ef5bddfb762fbd30e074d565dd5f47312d3e51aef091f20029c3b87d83a4500eeb8caae68fa322d051450d353ae38351fad51ed3010ab9b3517922afbab6355e3fa9e6994623d4ced9044be3de99adfb72817f12049de60cba7edffc761f29557016098a260c338acc451a0854cc178c18e60ae277e6176ae92748fa5239bc8311739c4fcbd6cfa2cf89dff92a05608242553abae75dbe5c4205161fbba06f7598251740940e29953745366ccac0098ca3619701bf7f5b6f79ba9fe32efda2ab68acf3031b3ca1d0b7f995a9b3a682e9a08d985d8cc57f02d49a7ecb388bf673279dc80dcdccf8f3b629765671035d57ce5bc734bbca89b507470b5e54d5fb8b4959fed728597f6cb66770e98f710925813eac1de8f90c047622fe02f085f24252841fe5b74ca5aa2d05edd96b7a16f16db8af7f80cb965fa5b0af6fb7f6ab36b78e93c007211c3aaeb765bca188f739f85c49d00fdc89551a9297eb07b266e6fcec02dc746143acafee70f9ae283a6d959c23c602868553493b500b5c43b5c1971ee5b19ba7ac6ea50d9826fdc2411ad9fa95b7f553faf8b60d6057422528652ab9a4e5f94eb70f22a733ab2d01bbb039ea483c54ef5aa3e59b314545d13f200c2ec8cff9d113fcbd4ddc1c9840fadc49fd83b9ada334e35c675b5bd3c25aa0cff0d9f639d913b5b96409f1ec0a9edd6ea700b66c0a1a459ef4370178931b65faa250ff15c166c8bb8c45a174e918523c7927b91c9e6b3901b46cecb0ade1ce00b5b6213a146db4481907c1ef56e7c927e671483bdaa84c393a6563f88d5e67669d8223035c98f6c3bcd8d9a7ce8db0a56165da564971ddba08a91dccabd1c0b0ec4d6afe14890ec2ca213f3aca8a97598c7df5d855388be881a050a9a3fc486404607fa6b6be7ad9c3898904d56eeba8da42014ea86cd5693803c32be03e8ce48863c789bd99b96d5b6a3db279ab3c17ad2aa3359d9f2890be1bebaffb08fcd6eadfd913b3bb48e1e45bd3b011aff72aa7c05209bf301413668110c25eec26af9e3d3ad11383b7fbe0d6c18a481dab564c8b745787e01655e3abf8ef867888d334f4434e7793750fe353bdbd9754c72efde4a09b71ffbddc98250aa40c0e91e621ada8e83a5b0e926e6afea669e5e9194e746d32280f691bf664ac7c4a4ed06cf6b1d24ad65ae327e4752ae13a617fa9b0b310d7f49fa698a0e374c4db99d2bc26b945c2f613a134d81ab8faa3280954c71951e9722104d71a39ea3a3a700768242c79fd0405b74ddbb42f6f1ed9f4bee42f96e32b13e25bb4d08338e171ecf59173e5657ab1a3d741ea049b27c7e02cba5e66518a18ed9b133fc64d6b1001f8d1282e78d497d565bd24cf1b38a25a329c3e36b109808519b7e029e421cad4c675d1abc3ac38fa7dafece57bdbd9a1751c478e8e33eb375c155a2499b012d402f1d8e3b26c0551838caafe297bde7448bcf2d44593d972e6ae165cda90789e12d7d67ce18e9d992bf5f76f90b3314141f0c8be73a3abc62df4ad29334d7c819a9a32cdcd9e622fbb5e5ab06dfc7276e54a419394ee02bfa69b772010418f2cfeab765cd325e383d6383d770dc202a3973bf5fa35dd4ebdf4e50cb80e07310eb39e29a08e8f9243e1162819fcae7245fc484e68b2ec104f7d63f677992902954de4b54f7c660ede807aa31fb71c31ec78f1c355a8a4d7f2c4ba9ce52e01645f4211c1a01933b9b218c826fec985d1f591cafd57939206365f3b9867593ae6cb2497a758e163137d3e912c4da095c2ffdb2644c4e03e3b88a1894194873ffa776a08fec0618ebc7e56783b72d8a69569b9b632443b03e868200650f3547b2fd286c8307d26111563f4cfdd14de42c9d1b1dd5e4bf07d8d637f352eea2d96e77b1f67e4e58b94ae9c9e0a798a2df4c0b6581e2152ad15aaf903b8340f9efdc1cf786a74a01e83e8a6b6daa96954272a9620fb13eebd66b1a751f218ca152a3f4e364268235b596400d392e538cd7457ef80e6be76cdeb41ecee6545b02ca6c075dd7247e5deafa14978d5a56f0646e9210c8379914b1ddc383d94334841edf5e4e28c9c7df4d110cf1b156272ab294ed93833eda4b168d117d40179f8f18a3009ca03ce425a7843303ed4b4ea08960986788a73579d76c11a263f7248b7e61f53185a65d95bffa8eb6896153bcb07a9a761f9b2f06ba23cadb890c4ce019c046f31f2ebb995f1c27f0ccbfbfe5f189fba68f42525b885a4411fb7e9ef6b169faccb8fd85984d92059a008e1a821235c3e122c325de08b8882a0274a3360e0319a3963a43fa5203309d6bf5eafddc28fb0e1e4730f804e69d10e416e106f737ac5f020e7e263618b1df551db9bd1707ab15ccf5fc11428c8ba9e98de2cf35adb9ea44a1bc86c1788f4a082d0e2a8b7dd9de74f610928c515bdf5b012efa910c4b2ba41a8881bbcbd2c5cb4e72acff308f505e71f4e1a8dd149880994bedd0fd670a6aa1677febbb8337e5a86cab3dc8d455d18f31685ed9bebea27ec312bd27176fdd60e3e81aeea88a9f62848f0beeb1d417784e8e78ed623807d81ed01f336242467c8325100c4ca541a542c0324a2cb67653d3babcc007eef7cee28ebdc8516bed20cf9c95be747013982fa77a8350e137484956f4fbb5c8bc8899b6608fead31a7250b671ac2ad35c64d2aaaa41223ea18137c9e64574ae9d2fcaafd02f3760159a8ddb6b7d75b66630b3328c2eacb5fe23257b5b474d88e1ebfee1d55140fb25c10f744dd95e0177255ba8e6f0f52f94599bd41aa9473ed1e3bcb4379d0c8d940f5ce7dd6aeb9cd86b5172812f0592ad49223ced126bb8b5408c90bdbaa3fca8abfe9ee4d5266fd1291dfa2594e5c88f1b411b9a2ac0dfd529f6dd31510d32aabe7dff29c51763a98748a699c69cb782f881d9ea9a4e9978c7830359095215e16f5f7476e0c55eaaae59e0a76e3249d00869dea50a1dcfe742ba6afd8b7b8f97e72e6491ce38491ac6d80f1534b064bf7281929321366a6bc1247ae77f9087124d71374338780d42f64e9aacbf1df2995f515e7b88a0504a6c479cde8b97e49ccab15454c68e906a6742eb34b881daa4f662a827e7636bcc6cad36a95a9a907b8675258c1f81bcda413c6975c6e40429603bd95de588a13be9deb21192a072f7a84511b3ec5978d9abc47c37924f586fc4645ae62a15dcdd0a6176dedcb2725a59a98090d41eabb0cd638c41c4c9bec04b66928a5f1503fcf8bdecd8dfd778eac02adaec80d93fa8d0a0015c035b1e621cc8e8102c8dfededb7d7ac644176cf1064f888f97921b07dc044450f70c609e6112c6423887b5cbda268a72b27a36b552a1f041c24f27151816bbe549e46cbc3fcd93e62c0a100d1d4283a2d209bf7fcda77bcaa91a4b1cad5ecfe2a1eb2a04e080b6c5af1ff7ebcd58cd1f4ccbed969ee991f1f3fa6f62c364e811a62a83be6cb399a76acd52ac12f1d0b1c7c9a944efef9b7f49f87b3080b16f3801a85d310aeea354041c09991394f31feb09dccfe542ff3d521a57ce0fccca205a6da2a6e3ba3c93261404faf9c9a13361956c80aa6927f0b76aec84963d6391578238651f9ecc2d78be2b17eb193fb3d175439f66ec79631ff0209a3e8da153a3ee09b6e523bbeba1216737120a3668e2af477440545f5d33b3dc572e43eb2de4b9fbe15dcf72934a459ea39626ee1a3d4d6246612740a59bbb09058fe7abe8c3ecf82db12d57ed1a33b9a49ef5cf918a567b5ff1f08404fe108dea8801484ce78ee7e406c2d3c3baf2a18052fe429470d379051734924204bb524e421a2a21f9a7af4c87184fdbd18a3c7fdbc9aded97cb4681fb7dd42756c33e7be4b9b92fa0403aad59b631fe080474eb61de7962a846c91bc652b17a9c303bb897675d3e855f6f51a724e2f40767300a0bc60fbc4b4dea1aa03c91057d0a304c83ab7e154f0f367f97ebcb8575bb58260208d5c227e691c8b0c2dc8ea25a0480cf0d847da755777e51925379fb09d3856e2c353ee51ca66b1f6cfbdeb328a19ca415d73e353b1a97fea1e19740588b6f76ba96f62cf4114c14c254bd577aeee8294cdf20a0c80812c6a0dfa8edb0672e423b60b4a578bab3b84d50f3365ad3ab873904eb91042737d018b474a9194f09fb37fa3ef8af8ae733945747f9cf382fe565af66aff8604d4591c8c31d9c2b47c934ce5ccca16732ac1fd28248e105ba6c56465aa3ab9c9e4c91835df040e331d3bc43d8c9573ada4b77276cca9922954396338f1425c1700ea24d0acb0e600f4256c17998d8ec283a23c0cd28fe780894addccdab6fb80cb34b8e91560c88293d8bb006e12c63649eab036d0a19ed5a8421abdc10906aba6215aebb384444c6ede179484b5c89d6a2985a1416f06ad53d7c0683ea90bec2438615501abe7d2f7ae282077f6f45c66b712c89f78ed8bfe745578be1789b6b7f282b18a38119ad0b16340a256d7e7b24bee19553f81d61a90505bd9e4febfe3e8359da7c950286c804f71be45f1e3ef308e100d3382303ac4378dfc91d95c3a71d05604c021e02da343400644c0c5700d593921e54d0ed188718b90aeb8102e3809970bcd0576b692e51824e3c300e74b06112dd570e66145a4d1507c0970319347bd3740893079c7bb8694a3772aa771eb24ab746c4b7c8427fb96ba4bf0d72bf15511bb2bc209ca2cf7dff46ba7530a9ef00552bda295dc9166edc9fe16a16abcdb159d4b9fc912b00861670f0b5c8d87efd5e0d3702fb777afc02bae5602c800dbdd87872e3a29fb24b36befcb36733c8097bf5c58ac9d3132b87fcb338ddc43c3b3da5cf1ff7844c950836c6b7334335eb54ea6b0bf0654ac3106e333a5001c1f43364b8f7b965382c34e33709578f2e6d90f411cb98b5858b48164eadaebe06b060bc15b210c7ddd861ca35f0f9a01955d71b9f13e74c2d4cd4feeadb1e8472366cb5ce992334a36137f5a9b642fc5f6cd368fe2b08b1abce5f2ef00ac9da6d500057cbf41b33f28e606b7ca1592d697a2ae2145b216c65d98fac4983d6485fc4c4abf50b1f4d3228813494fa66bb9e478492caeb5b06c5350c82db8e6e56b05b5fb832255808cbf74559db08932c659a8a7e0922dd0632a97fb89072b98dc9dd7a866b8beeef26c351e13815060a283de3b0b74ad0f414ff90544f79de741012bc1e89860887a95450d49267e7dc4ef63830bda95b59d2fde660ffe90694eec2ce87725cce5abd72e83ad3475f2b3f8e31040487a7bbd66c2ae38a0b5873ccb457c9105569efcbe4c11ce2fd967e62cd7536732edba5871303e6d727fd9b10b100ed49bb01ce39738481a7d1b35d217aadcef1e5209c4dbc1a70ce851c94248171fa07d4bd8070e7d9720a0bde50e35f80d268f39e2a902d1689576cdee46eec51f831eac68cd90867f6f3f241e01142974cbfa17cd6b82fa1395a266b1558ba48f0af43447adb9dd7154acf019411ec9943de37e3282d8a6089bff9eaaf48b200e969275ed3dd70d0d7f7ea49f54c252fc0adfdfaa95806fd806e2e8338a89d1eeb46e03c1d4947fb45e28b3f8a2ab401ca133aeae09f6b2027500c603adf434dfe31b507e386eb0066f4fa0bdb1463b669fb38da566b8070844bdda63c556c332b0fede7aafc248643137ed67070f8f7a54a3df391250e96a248e780c772e07879c9d103fc13b935e22861c8d2a73c6b87e9925c1b33dd3986307414629e66c5f147a984603374b74d1ce9088822f7bb16c07f3e7cffb5023ae9ca8a9541c8c29971bd915fc41bb18cd55fbf1a48f18e5bb74bc13aef5e99c55d310be8c3cc167b2f5453802e77cea53d0b141180f18d5cb7400cdf6d9fa52f72f3bfe48c3b699f6ab7f24bd950b3a23b3430f334c16023a6a448f3e042cf801257cd1004dc650b082f95482e6e0b8ab6233a4bcb27aeb86ec09cfcb00dbec124a45df49479b0c9f302640093987c6698215b9eadec1f21f5dc318444c91afa90239919a2d8f2e1117888fa7198ae3dc874bb7641d85c6825402f12063e8d313e1ca70698c2d4594cdb29be31344b172e64815af1b20d95e433bd2f5d33bd7016d6af43dcfffd3b8b716ed53935f8fdb23bd6d32544daae1cfe0361b17152beff9bda59d857178fb68480c6f3625ff53c3fe168435469bdb4ea2a336bc1f524e4b14fcff292c75bb45a8719c585280ab4bacba1b4ab65c9943d5a2af1e94ea8aa61372d9477b7a96f3baa571964fb4102f2bb06e01174dba43fbad0acb104553af3bafc25d08f80ce71110756c97ea40e30da202f4d3efacc3a73ac04e3c0307cafffc30d63f6e9b943e5b1e47a5c3ac0bb4f760a296c2ef474ac466245294358dd2f0ab3f995ea18f84edd2b3f3b0b01dd4390d76ba67f04368e272ca1e895b7c4715a8159148ed3d9731493e2c420b7dcdef7ffdc93f6e4c841d6ccbda42e7fadee39de4d1adad32e7ddd84299e80cc014732eb44dc9a7c72ecdba86106179ae0ce32329b4fd8fe3f93c166de71332694a7c9026b2974b47cb8bf2a57b557eea538cae60c5d8f3d53de47a1c7e742afdd2545ab18218a752dcc09b8665af66544548b6068e90779b386f79dada6b44d23ea2d50156ce6a5cf5141bc559dfde6044bfc09779e4998a8b259c2575691eab01e095828b3902ea86ef09ded2573582f45a54900215c84788af6798fa0e26dcae7622b1a9e8ef6014c9dc3f69b60a50b690f89cd1d48236b3755281b2caebeba70be31b2d4eae72112d09638a6ccb4e1e0c12fa438165fcbe1fe39c4a1fdc5c8dfa8d2bafeace852e9117e7aefc06df8d243a54e1acd1edeaf7a1252a7d76a3b5da576f8c3dae0daf9e9e3861e43b89a661e51936c754aeeca501d8de845955d113f8536cc7eb90269df2d22da5e7d0dc4d99d3ad617ca415a08c03d094e2e7424fd673ac09f5a12627cc417cb18a49a15fcf00dffb9861f862b6529b5fb1dc9bd6784cc4846ab520b46102c9a7915898110b1d2906666d27640731a92534aa4050644b60c7a94098dc77a2bef89b9222f9c4a52302352a153cf52d8485e9d4c246110bfb343fd810f8768da715176ad4828225588fa32d34560692b8024ff0b41014eaee6a9ce00ba0d4303c9d83571f33ca1a340f2eeb1737c22dbe2ae5627846c684c4cb5efcfb5e1746c9f26dfb759612f03ff136e8306aae4af15038ce9162cc4618e6e4836298b61de9a445ac7a11e343e6d669b9125731870c22b87991fc9ccb553ddc27c3e937420623990e9f4fc181c33f25b22f95e24e6902f317fc6c9e60f440843eb1b8214fca00d67657a824365f9c0977faaf371d9281670e334b67c3808f9b4c9e9e0a838fcc9c9825a381ee166d638f15fba671131e82e0c9117f5f948b8fe5fcf339a9d1d749d89bda60f58233e24be403c6e5554ad52430475b918ac4b07f5f60551f3ac16cbc2ca557f91d800452e7600ef6f396ec4d0b557305ddbbcb9d386dd350250b83a75aaccd7552c22818b298e502587336cfbcd45c2927e13fb40a644ae91b260d4ea84937d6cc7aec21b806ffb40e602320c74c7d77d3c56b4867ec1246a791980698133db9e52abef28a42a568800e5fe4ad166d7e8be8fceeb37dcff534ee82639c93357b37522f0f8bd47cbc47ae3b8fe0da92a99acc530b8f91da715d9d7afa3831b5b72d71aadd3f24fc1beff0448704f193858ad01c234eb0d8578c1ed01efd8744ea4219b0d036bc9a03c355196e8c03c69ef694a6ca93633ff43af320565efc49811faaefbcf513dcf07c4d18aae889d262489a8165d01177e404aafa34cf196a1810b595c7ecc33b8e7558d0d09cec1d5c1b523a89975426b353b6bc4ee056fd0bcfca619590334c2a3908b0543ba32e08c94c40aa5ba3b2ceb296e4e9154d98f89749d1aa81fc755051cd55ca27677ad4ecf9225c9f78a2b2abdc12b7e055b46b21b4547b34775d9d3a273f86f2718a6ce0d95df4d55b8ceb99f6b41fd417e5bfd9aa688c1a4c5b6d6c96bc3f1f89d31d6f7d62178fb4c7f6276747a5530c8373399c8c61b5e3f55d63ac7a3720f8fb82c355cd49411cea5ebeae5bcd0f9c3421cbfb4e70a9c6b1c9b9c8f82389476a2996e30dee7c1c7a71da5c5f1b4c5f7e47fb571d5d486d274ec98c9478cb0d857e54a5829ba31beefc04c1c004abbeb8625230776c145fbc692d67fdab68a3f3fd873de9b54893be49c8af3d1da04278ed7af7fb41b016e7856fdb823fe4c32c23a8ec91efff2c6ee7804514cacc733665b04e07628e1b4f4feb57d09ac1b3a48d24622990194e8751e653e59072d987479c832a3320e54a052a8d5770722de396940f0f3a39628e15453c2e0355edd22fba47d257fb0d6e61c7cc8525886a6fdc7273b162d200f9be376e6c97c818ad7a73fcae357eec32d22d95e83e7721afcb4a10ce9e75c24099378b1fc25be27fa474220c504f0a2dc2d68a0f2fc0cc39ef8566a541870ef942bfe2c61773e3df5a15488b3cddffb5d05d09587df7c284c5af05d3f0a84f8a475b35de1bc29532f7e1e0995f9e3571772ba452bd7ebd16ca414ed9203c1c8a2373c4e623aa7f210a547ab53d1233c723cceb9c42e8147689c6c23354c4ee6f43a4407cd3bdea100e07876d69dc835d62ab3f83b2a6511a60ba006112d54da0446718e0b05f9e867f5597304a5f9c7ab06120a7914c0b790b8589e0cedfb2d39236bed03e01e4fadad91a9c630df7c599692f86534b9c28c6d3bf40fd66a66fa98db2c9c16765f3ad0c9210587a1db48a3dcc9e6d179b904f0f10f032eca0db16e6951c0ee289f7726a8e1a7f3696ce1f49785e63427245f0a23f8ce3e42aac56dbc6656af5c98ca76d7f395ba5cb88a536c354ca6ec8c058379b55a4efbc69e5d7d7245a23cd09c8afd5eb824a446ac8603e0006df0775e239a508da61de8a406537e770fedd15628c32bf77b699eb056038ee9d15a70d2b22fd0518dcf993f30e791d33e9a235e19d1613905d249fc8b1547f11c52fcc9f7df3e8d4d3960d7a2e1b34176694c1e25ce08680c08cefaede014ff9402a5abbb53a1292c84c5d425e8eca90082d6fc1363296bd633b511430dfcfc8390f2e0c632010c73d8509e81a445f3240e4962ad37cb2aab7987a8574308ce2f246bd0e0256720695c8a9d7ebec5082a352bb7b9f3f68dd505cb29ef2b3f5ee1e799e3d1d4d94c5839fa39e3de75ce5a1e0663003eb27c9bfd09fbd46ca994e000038260e66278869629db7aab5b2efcf261ce4ac108df448aca86ceaf4e58769832135704078c3c9c9de909ce811057d8c5605f23ff9e19d39432a59c3793e9d7ac007cd5d271c273e0cd59eeef5db4f9b981060da0a16201f26720da6b2b82e4fbaf9802ca0d60427aed32b4acfb5b7dc5990927f2d0673b698d0812f20a89e8a68a7232f7495e31f1b35cc8c0d4948b71102e18fd146faa830c25ebd516460a36f7d40e620e036acf869ed133cfa74b464e3e89c953c375c74c3f0e1b3900733260843d124299129bcdc1780dd3dbe6cbbb00215f77acc6bdb61e22cc5a014a222c4b680fce6654def28e6457ca7a8489bf3e89c66670c2eeb089d0f1618fb88fc3f137629bb3561f5cca3d199bca4c06c3be68060a5793e1a34ac09035f3e5008d3e511290c740e67340ad592e1467cc2d49672849ab611ef82799b4c075f8fdf2fa5f2794ec3bbc9fb75a216b9ffd6367a72e320db2532e15e90462e95c1a0e5aec08aa91686f2748f6ec783ab53551d7a0642f3db692986458a8a498f272bc2dddf5a26e8403b1d6c60c67839c3720e7fcb124c1fd45e44b3b2e81b57d298ed395ce1713881fe2b1ef62f42e9d2c57fe82bf1b81cf959b345b3d022946660db4dc3a1268bced414139952a23003c7f83fb331b6476aa4486817e2dda9552bf387ae19954679256ef6c4e0e4a0d8e1fe030b82d5439ab67a973980cb1b2152ec8366cb7c2d339a9214f34aa8b0c4bbf7ce6f458395fc18d05fa34a796e4d6e2cad98371974608c340abf005cf449ae8bfe88fa4f931133d02ddfa047274bd62a82bcdd1bc09272bb5482927fcfea42011fd32197df7caff08e6912d2baaf336c8f4f3de1964bf69e7ee8819fc8290f2daec85c0adf90d5b7fdba22aabcea0e694fc9ca0969ef8063d65b4e2b51887e3827e2fa0717e05dacf85d401d828ebfa720b71201c01f9892174568a1108b17d717bd9c1b2d0d90360acd0bc9c00fdfbcce81a6591d3eb7afae5161af799354710ab2a2c5635b25e9a183e63de9dfe71095c3e77df5df5622f7e9b994e143cc9c5d5cbe847f6b874e690c4fc864815e2912f855fece740c72a088e0f00c1ed8cf9c363fd6b5a12ccaadd0d917b496ad8cc299924a2b9f434524a9684f4e87117153b9b74acabe9ef4fc7bf29a7e826da22111fcee71a382e0f0e5c0112d1eff27f061b54f12f64633e1683cdf16d7171fbb1c266a554343fc91a888d42c490a6a1ec8aa52130acb2de920084411f7223bfcf28f3c3ad11eee837c1316c087cbae2b4907026f4e8639603df567f47527bd634f97d296ef7c3d42daff478e6dab6a928d6bce7c441ffd030c74b932d38fea8a8de0dbfde0d47f6c4fbde4ea6d223600e04914ce7df0df3e2616c66194d369df37ea96d477c01b4c44df7d7908e886e2fc2f73da7e91567e155c0de53b9aa1edc835c1bef6b7a77f44c48f9eb336d3b53b6f7a24a88a093f54a4fe422a3e2912c922bb11f0338a81da1d89d01ec5a2f418b986319e335e1e6e82261d0336760ab5620171f6cc5ad07f4afac18dfd8b2c3e7e3695c235cb87bd8403ba393c0f12174423537cda9f07aecd60c79346e2c9f73de9a5b6f9d807dc2b15ce4e875ae569799f3af4e6ad73e3154a76c14a5059ed693df5df081a2b54d7eaada5d0ffe12652e3ace1992cc1a6c316338a704a588b80a21accd8f84e822ae0fcf1715481c8608f0de53a936d845762a2714137425c34a468e2f508fe1e9497209410ff63da32fff2527357d3e632ae37f845adb3d9d5b374c3e4a2b674958bad101856f3d64ac4decbbc008156f5576891e624097ee45dd2d2107c141eae2d16f7f001be47086c47a37d1412410ffca8d0bb20cfc5f101f7b010fb73875ef9e2be50862f970c54b19c4f18f35ef31c9d372d2a83497c5e47c05e877149288094d5823ac460b72c90f8aa65a0eb3f35aa27c4b7a073f6c167a561c679de8b3fa1c02db6191ea9428a5b07b0b78054b654450a4ec3dff0b9cbb1b33f19a207a59e10bb7e9a3b4334f235ef5083b8d43d3ff1865659d7eac5e887db37cd5e1e50ee59b3fac44125726d1be9eba1ff2e28a1cf9174df065564428a4266f14d4fb026dd8fc133bac0995f6f5fd89ecdd3073e21d410bfe5b1236e5b7133420a1c41bc4ed758452295084dc2e9ade69f536769bac6b098f09e71c05df0332c1ef4842310032684f3235dbc98ffe1f5fe3fb7c8dcd1dae6b17ddded1437dd1be669060fb3abc28fb6ebf820640b0b6974e876b02a9e062592cfc64910c0979e1afa35b6bc29a2a1e86f661db6a3809d6dfe32d40683b8d23f04d968d612f92f072891dc9c154d88021e2618f351f82e73e16a88f31b7978f0dd75d0c6b7884b4564b8c5d5e7399e8e88c686cc8ec87911228c6392cdae96628a29f58516bb8f504f0926ec27ed42082fb5fb84c27829b03226d85832fe96fecb746b73c91947b2480164514fdf3ee99372fbce859dacebb0b87ba5b3b0074fe1d38725470810d5d04ff2b7d795d1bd249bec0c509f7f2dfebfb21df88963b09dc5fd0c092e8755782376625797a6fd738f60c0abf41cf1acbb102349d148eb3fda11ba97f2f79bb05a53e3385b2b1500cbee7e003202c11b291a58502e033a487e89936bdc0e2319231fdcf256dabe4cefd9b6f5efcd26fa88351f84064f285821b9490d601776033c3e923e213233c859d6ede573d8adab56f4fb5de0795fef72252de525c02f1ef434c54430ce2003985a956774b1afae23de8e56430e2b6ede51c49b738498bcf996c8dd1c0b0d7f29d93fe448e4a7936d561b05a49a3566c4b39f98ffc16d7d9ae92f412985469b9cd76ff486fe4fcba1f053d49b99e857c3ef31561122f7d176805b190fa985f95fd98800b54ae2e74041bb5b9e89cec26a690c6b6e15c2491b00fedd34f42618f1543aa14a672b46e6aea3f303e64337169593315d167744e6ff6d061001b16aefdbda5ebcef639b03bbb043823c00166709685064a1617568b0381c473eb27fa9e4e9818320363405dd62c58ff76fe0ba38fe311b433b2b1ee7e2984127a3b7bde40ab233c60da28ba83de193a4fd36aea8b76bf7784f0687eafef27448ffb3aa6d9089553d74770380a42013c13288b2ed46597fbd2768125ddfc3770f40f3edf63d4f6de2e521ec1b2819a6d8aa47455b0d922a9e4ef07c952773c006f1e8f6f243acc472ea23c3cc5c36c367bf02f4968fae6e78401ff545489bc5bc9d036406560a1f59fe0d190892ffdfdb0b4c4f043ef6d1e785473ad2c5a41e9cacf3a386d6efc5049b3e6a747eed82bef9739348be13fb789916abc2211521239c0a341868d66c0f3c4826846278229014198fc86f7e2187f60ed697dd7783edf4e7a42f6e566ad67bbadbbd003845eae5be92f7e5ae0ab2268039c87d339d5851fc622069d847f6b3f6f882baa6731bd8d32b7b931c1d73a52b43d862e203ff1db8fcbfedd489ec8f8d1b7a043b30cf87e7d7b80a50b038ec50834c30fb2e4ec2bdd2426cf3b73468fda3177f7ee5625d7d1631ade4899e76a0869869f792d3db7b915c598e464acac93dcf8eda2760d3f3757d103ff000de9bbc51705fc80ae262a862563cbdac4f602a16b4e +MD = 43767f4cee6749090fe23cb07e7db664d6c7c512f8afa70304f2f14b8a7204779e7223aaa2c8ff3e82f8cd72529e43d5df545e886f647a766ae4172baa56407d + +Len = 89728 +Msg = 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 +MD = 9f0c0f9cc172a2780b8f378a51155eb7ecebd238579767af5cb643b5903e5ab7dce0202de501f061d467e4a8485e1ff211f9277bade2d389c9577d5495930f24 + +Len = 90520 +Msg = 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 +MD = 099417d1f998a3717c085abec333e1e3d577184352aabc843e23ec8cbd4b7cdfc5dc7e42ade402189f2b310e3ffd7e6fd2d722d1a7a7cfd3ed9ab6293160c972 + +Len = 91312 +Msg = 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 +MD = d3891d0e889883471e15525f8d4ddc25b68339c0c17e3a725c8f858e7784267ce0767b12ccefe62728983c53c6c847d0c38adc3f52249b6ac082c01722d86125 + +Len = 92104 +Msg = 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 +MD = 661b576d9751845a0dbcb2bfca1d1cc2b556e22a0d671e35dbc349eb51baee0ded828f5288a01d700509fca206e4a39815dd85af1b7d706da78abb8e99701129 + +Len = 92896 +Msg = cc5a4209a6a60dcf12621e17150b4576b918732e0ee8d9ba6ff94ea6065af1a4936310dd68a34985b81aefb212a8b06e29c6740ad67487b66072fb4ffab348788d0f36ecb838fd1316efaad3bf78c4a8114b30f7b00c529fcbbd75d2a1336d2344c67adf9d4d70a1b14a15212261cb4df90f6f9ba298809d384184d604c0a7cc40f1a65e20caeb581391fa45464c0b84697af89eb7005ad73066ef032943409b07f680104897b65fc32e1fe63022cd76eaf495a9f42c28763a9480021aa57eb9233fd19e1d9d19df49874cadeac9594a03e50c64630532a1df33fd7bdfccaa4e1c3260afa7c25c002e064b417b2bf7293db526760b71bf81a6ab2f157ea20b817839f7ecefefc6e9f911e34ceb2fef3b1fccab88f459193e1765de79010eeb7bc1bb5cfdfc0da0c33212db7342bc88a73192634127a686ffbac7d24f6ff790647e205889d60232b56170fc6089bc0c96fb70164aab3e4fec183ad23ed147436338cfb33886b8c4e80f930ebbc816c12f06cc8b4a880bbc2eb827a8ee2ee54ca0763235b413159e84c3e3d92b05b2f09bd90f8beac7f414ed22f41a088eb9f344c0b0a6a2850308b006c824594a78e001fca2ded26fe0a150df0bf134faab80779eb1cdade56949945faab9ed9e50db8af8eb4ca988b9a98076d2f41978a33a60999d737b3a2eaa5956f15e8e0a22275e54549d171b6675a56fb3ed6013896b2838dd60b48c3c73277305dce494d60da4984498c62ecf4de65314a2b0d04559f604d75c01e37aec253f4efa984754d5854d23065bccdc786ba95fddb2b9bf4cf384f42f0a48d05c7c413582522884c728fa58af81fa75405df9fb640ed5e08e47409ca076c2260d5301203ab9414e2bb6274d5bdec282ebe4cc50ff6b2c8e6619c03879ed5a6445d30878ec76999b48565c69d21a2bebc227a8c67871c7b21b918d2e801917734d24dda65e31385167312214dbde3d980d4f18c596c9ad35f6d92ee87e9f01396d6d09105991275ad06e00b640d201711483a1b5201be6fd3f162bcc3a2a209fecd71220a43e6d9ccb367fb7c79d7e5f1eeccdfedf0e7bf43e730d447e607d8d1489823d09e11201a0b1258039e7bd4875b123089b4b73013a165ab710e91fec2babe0ce4e221f7096067d775d5ac4165ffc2b3c1b7ad60b7d279d8db96e0ea27a67b53d3ca89bd0f65e0c05fd9c9daf25f26e002942adfc4dcf5b2d4197539949e388f19b1c8e0b08e05c92df5550fd0fbd73bd8b4bffbbf3351e01700bf5b7e047e1523325000814b5f487cc2ee3e66485c2dc0a3ed430b7836d700e73fce686bc48c8cb6cfaaf62045c4a8cce60546e71e4c36ec33443e0ded1e2e276710d846a46bb2d9883e83af61d45e7dfce2e73aa60dc7f8128dcb870d1bfb5bd5b14227862931f52a49be3b3bedfa506365cbc58be8e0521b7e38561f5704fefc2e2a80e25b86a4264b0a662c77f8ded9fc591a18740c74aea4090d9c55b78b5ae615e561693d60fcb0fcb2bc08f693c115339b0425c8ea5c8db21ffcae9f8b728788c75bd8a2a62e1a19a373276ff9b95edfeab774922da599c7ffb8b82969c370f7996a20630e2af4c5aaea59c17b0317b26bbaf6f4b90a56cf4f6908f1b0de40f6edf4e70ae383cf955b89f697b26efe6fa077036d16fb531c618627650b1365eb378482e6d0b9091d17baa45f2a3d714c2b845067b2190d53e8888a1fa3135e5908a18aa3504b4fa17224d9843cff0eec6f5b347124b3e3ea46f8a76e434e98c4d3d474acdcbaf1e6fd311ca3754425c4de744615f98c85640f4f15fd5635b3c31b85c78ff0789e320b67c4396d7d547a1b57fbc27ad3503594044c3946692db8524df9b91604b3374f5186b2803b2950888ecc035358d2f397a0b0aeae4965291a8581a4c80fcf5b1b56dabb47de030cb8814d650d6d8c126cbcf9b9f85708a9d6d505ff80ca4112021016904f067fe32dc7e643f381fa1695b16e07bf2276af19b4fd15daf4b6e095e5f0ede0250e984adb2d4cb046ab74a516b4046d3c3d9d559dbd8420ffaf6b4970c030b5ba2d80b22398cbce2bfeb10d55323c7cf4dc190cf7edc71d4b99068f291af53a465b20d649af6da792825051158f1c78fcc096b26bf45b0a78e246f9777797d85a161d39a5d78ec72ac4d6f2a01130ebb4899ae86267cc830839b0faf46cb53a55fcca5ed0b7cbc74534b974bd6ef64fac959a1163ce781169fdb9162840c9bada7dbca852b6910282607c59a60ee91f458318bff88efa201eacd3dd7bba31e447f768c8945a7b1362c69413f26785c52fc09b66893fcf59b6d595a3772faa413f1853122e29e67456e5a5263b1f68ebcbec9687ae37740892f6832a93278f5c204f0027789b6f9fdf2c0412e87ceefd9a459ea5d02c64c7638e00b568285d8f8c09f47b1c2573108c28557c7326a4752b9a184387853e10891ab2e66ea89165d2e7b48f715e9d50be68fd9573a305ece02897d33cb85c6e741afe300f2ec779a556a4c720bd4aeb164c81205258afcf689fa1f7885c3c5bc50d6714c2317c3573e559d492b80849f461649fa7ddfe87255dab02c2d77a42fc70622730470c23bef2581a5fd551f809463c55dc997ebe96e13797a4c082ce7ad293c9d1e603cef72c041ae0abc46fa5496cf57921acd04dd8bc28869de258d0a2608f1f750f81bcf10258bd91bc3b59097af105fcf566aa92cd37e0c6157c8e7e5ce9819a6bf660cfc7465f3db5c5a4f4eadafb8204dc3dadcf385bef98a414b4ed6ba0ccc5978336b7863de65da919aa3115d25747cb979856bc5050e85a03e49677d56288efa4b4777ae24200401787e22412f34a9f28c0e84656c08118cc8beca0c812426945d77ba6d4c73a453f1c729845dc69d161e5f838d784ff6adf295488d1526e8ed70e389c9dfc8802f0d666e4d389320ce3460b367b34bfcacc3b6272998989dae8c732cea6486623bd54339c54703fac2d8f95b18a464ea314409af0794e10d7eb90feaf7631410225046d213127ff2991112c2cbd3038ae37b772a5090690006009f0c1965dc528a86588061216dd1fbe89331a6c98ea26b72e6de2b15983eee680bda77f145f21c805f8dd4fd365f926364f0d10d6ffb70313f14c1aad68eddfa3b9c3a8fb7b67f45443f962d4364038d6d4775270c5d9bbe6b1439d78bba7bbd179a89c79a685bddf0dfcf39fba8f96b977ebaa0cf9094235126bc241f8871b9881c8d2257ce5a514ab4a6aac5f21a07c8dcc7ff1f5b0268d892721afac167f674696d2754b122a8390844060b0c0e68e9aac5cc63878e93ea9f8240842d047dc5ca525ffad85beaa721d1d834bc7e96e331db9005dcdfae6e97151e2693f15561876450b10dae207b4874a5a8cb129a9cb632d16c229ec04bc0523d46bcd68632e8ca84e216c2519dc555f7ce01717bfe84f11a002172d26b6362244e7159191e34ad83f3bc4185f4e09d5510254441f0e241f029a104ebb5c76c5ba47825150fb534d34ec7d0c46ae17448d50132f459174add4f69fb131136996bb299e082ecb188fe59ff1917e60f0157865be49d236c3368da42005267f611dbde9e33689d71d08c7e2cc48551b46d0a89fc01443529251a32f4bbb19f50fb33924dc5d0093d3503241579179116dfe947ac32ef77964779bf47d337a28c7ffc35703fc11a5ddfedb283dfd48f7d807d28321fa8d1fac20fea03f1ed56f2c7bd2fcd4844b718f5d1923e9ec43333784d95586f762b9fbd6419efbcd9a4caf8fee72d8960c8b7a0382b0e5fef667feee1f4e4cb626dcb61feb5d4dd05745b3d48c757a91d368207a9e5bbca5e0ea80ac2ae9fda727fc7d667277afb79afeebc2136155183e7c153ac280c861814f7f6772c5145b049db4327d6a9bf3c3bcb9d149c2d299bc4bcabc95cca3c2561b4d788d5c2b324b44ed0c42929d055023a09a66268d86cb5bb3889e9bd938edc27d87e10b9cdd5a66aa7c88ac1d8cfeb832861ee8e07fea305217338ad345a6c971ee047003bcb0875edbb603b7cafdded21cca9675d5a74e38f10af62c691fb4ed436e15da40ec3b8cd23125d66ffc2c11d6ffbba8387129daae6b7a3f23c709220094699b0a7bd7b6d8a0af03ec7814843d34d51208d637b997fb93a6061b2ac2adfdd7c089de006f577afbbab0d02c7bc7f05f2dd7551c485631bedb70babe41b4310cd54f813a08e73698856db2d89affb8d666246c3c2951847859f3f42811bba46563bc03d926005a01de738ead545d04b755608a0bbf228a3cac2075fcd51cee8dd66fe482592b5bc43052d21f2a585a9e662c4d2f8c31b9983c56aea0ee6065c2b7dba1b9e4c0b25c258c0ba29f9a20d832d8140c131778f7a5371cc8d02ea0b0827fa9e48b890446289fb9dc266b0e1126047d25e64c6ef751222eb92cb035d3b0cc8b96afbcb7feb40e6b20516368c5ca21e7016838f203daa8730646cd8bb8ed52b544b40443f242488e23931bc76299c0f0232b75b8a9ac4a8834d0bf28bc72a2c5734ad84edd6dee913a8deca0741f52170fa27b19553088bcd93d1d736afb2d1aa6d6a12efc916112e9846e9a76b565da2b6fc19a9321d3af47fe511250e1624363ea076afc573091c5291a0be7167c981ae5d1b2efdacbde2596f28bfacfe2de1ef773993929dd8c31ee678b419cf70f32a73408c7d5c1a7d6999a26b5010f394c716e205f73d860d436df8f12c3757e171650f2b7ad65baff6890993c4f77e380fa6f96cbefb1ce10b50a8dd71468834cc5c1174bcc1885f4a67e49ece59d6b3104e0730ad7ea126bcb410e1b2a50ad28380cccd0ac6a775ab5cbcf437df04ef0f3793b88d6f1dc69fc3b963b5fbe5a5def8ca9f2d8dc2d8629018fdc6300fd25788256e257598a8fca52acd43f1219424ed9353eebde072b72a802045f5ff462f6a45b93f391bb41b82eb85242fc7869f86ad4f13fe0a2af1527cc87ad5dc32de057c01a162add2438185f5205cdf6595eca2fd64fa47e85a32955a2f79af7dad8051af149957eabeca7f83ff206f184f46fac4ab569f9438ef523f2a888011e4044d29608620e4d28661998825818715bd3b0baebd1a17d4b43cdf34ab55d5cbb8f6d84dd010a8c8ddb49e84101c9a2f79ef3c36d5c15776a7d9a2148a38b1a9c5d724a3202f1fe8f6fefabc8c4939e4a19dbe0b469b3d66f0b4f194cc308dc8527576291d862f79faca14f53f0f4c7d5ecef9f5b9b0b1ebb852327a1945516e885a34a8701cc1c5109d56fad176bb42d70955bcd6099c4e273dcf8f1b80e6e48f0dc8e9c0f9be1261012792eb866e7b35d63a2744ade4d864fc2e9b77e832728e1698b1b6260ca9157def8435484d709fbd1000aca473ce9817b966d8861e5fadfe0ecbfaaa95d2539a179956c341693e473f0db5f72f7bea16d6b7e46092f5164b90fe338d3fd443de0599f7ff30ad39fb2f1708ad02268382ef574381777aee88881109d8f4f90ed3224cbf050485b96248e54cced3168ae36b0f9eeeb337603a5dcd26929b87dc01d67957dca339e602f3412a63899428bfb2a59db0307491eb77fa2fc31cc7d4ef8aea668cf711e76696f14a730ee885a02ce1e7d0d479ac223e60cf735f011f25a465951ee654e5139bbe5306495ac80d418d2556898dd7681ac6acab4b7de42b8eb38c995a4c07936870ee2422321a8f596ffe4836f93a4473f56e72ca824c8aae9cf2053a3f766c67cfc2d681b7a2addc511bb0c306ff3eb1b6bed1c4597fc96ee76f6b6e765929fea278234e3289ef32f9239517f94bde3ccf44cf1f4ba470355eadd2dd39d94f97b3b71471ebf6ddc32fbf001c1d49ad7c08a774c49ee4076ac7514271d01e6899c828b0d32a1200f7bd97f8b9b91e32da2b8fc89b9a661777eb06c311824ffc6caa72ff5a3704df376a5285d614f5f5bcfea6d48c895327c392725ea598959178213e09ef59f502e9fd99af5c77f47f8b4b919f80b1d2c0b6833d1a165a17b124f534d77bda0df2773f137f312a4357b0d8fb315d5c0c69b88810004a10fee3daedfb70e400733647f869fc3e750b05916d8a930dd028aa316793162a0271b002d23cdc14145056c3ef422f6ba0741298d4e6cc76554f0b89e96d669e78999e026c9e24f15dcbdb51ee471ea1f2a5052cd4b8e48235a91528d646f88fb99d374383ca4f65250d4c5bbb20d3c6b4c766b434a8e418b65d4f77f6c8d2e30ea6032ddf676557b23e31481f7456c32f01be9abd5dd31f229442dc1199fe84bfdc8929471e6fae4e841380e2ebad81a87c94453780b981bf7574c0ee6184581466519d859773543f0a786bcc2ee2e76a5f701d6ab89f25d6296f8c56c96a49546de3f25f797c30cdf6eb71a5e5fddcbcd3da8a1dae8cf3aed7bba61178ba3ec918c8919e6d8f2a4271f1fa34b8044ae5005bf41a0a88d391a8de78e7187c1eb99087e00a1ab62ae4a2146e424d01182e0d7ac327739badc5c46268a04eb6d36dfca8496a29f818fdb2db35974ffb2edf23c05f0d91ce699352cfe003c472442d85b33387415edcd3c8ceb7fb64fb744069b431930d28ef437aab47d922b759415331062a0bee5fae0d765c363408d29808de9f838fb1271d668005ea0f8efaf08daa29192eb287d8a95a8d0f682a303127c612a4be72fa693bd582fe34fd0f835ca4061d53b23d98c303b050a8697651eff5f3bd43724e6e243325dd390f8042e7a904fd22f56a3583f72fbf9bce8c4188f2a897c5ba0d754721584ec5c9357557408b834283f4f812c07025ea605a4919459bfaed501dc6cc27831b80351764d3f203755c64c52998e6dd493d28c8b0ca7732ad633e68a9dccd0c0a145a0c578445d49c17a1c3103cefdcf53a2cbfc0c50fd77ace8cd4669f9c5ce42640fd9591c367c01c40d8f42765d7ef8c7625bf2f95f127d7404b443c1bdb7061f0d36723f422a9124ceb1f81cf3500d90ee4f63391e87d2564b48cdbd3f1786a717415625f6e1ea2cae3d771b65ef0cafae2adf68c234461fff687a64a07c2eccbcae7758cb4e874c4aa651fa1ba870644092ca30e0c44321afb7ac30a83188d07bc2485035acf2f412711b418b18d36f43fba609d0a4441bcaab05a9bcf40f52c3116b94dca9b7c4a422258a3abc901106ea055c3850e35edeb7094835102cd4213033af16a1402e6e3e232cb100410a27d27ac07e568b7b5a601984c7328bd5249342f77a4026a1df2976b1748060ab154948af1931b6f1dc3ac8f7d9c786c62bbf1c168df2c5bf7578a2a10bb979846db32190af5ef042c2bb9a19f33bc837d5182184a825b7e7dfa03983cd17f6268fa4881d974ab1febc470f539a2baa9a8f32e5ba8f7577bb6c449dd25f3850f1f991deae7791967607718b4d3503b87ed893eb307a5e8f9ab9ba6205387734773a0fa7bba6aff85952dfb05f6a506c553fbfa47f1f4d6a0626960894df70fb46df7275cdcb0262092cc5f112809e50ae231aa40ed4ce819e514c0429ba922fc1486ecb6d5b456e15d3d8d00f4e49efea31396c58415e70c3c850e70c50773c7713691b12bdd566f0069cdf9df9efa4a9d8a06ff3cb79c206da5923e5377ccbe8aed5d746892f07483376724739fc196d97c4115a09accfe825b94d2ce63f38869949928133dea95ec8ea2aa3750bb895dd390303527424e828e5b54be32b1ce16148ef4b5450d7c4558c7b3b317afcc33753b7885c4c5b7762830eda94cce3897538101d51221d1967c1e66705d6707634c8a1417da1ce165105bc41919126df63bbd76fb0cee3be5e2efecf58ba9e1f33ec42d73d21075572e2403950145163bb3897cb09b3b633c72826dca073e02ed3533ea2212691b556ad2cfa66c2eda6ca22c3b7a27d2f1a2141e10783bee1358181d74ab04ef7a65acaf53d2c2966293f2efdae418798c20b00dfd868d80bc3dcfcbf2960f693b92dc01b4a46b4556b78a1a8273d6f9dcbc2e955d7c67bea4a341858d6c9aa105e1e2111da1cf035de152f55ab1c91a8a8076ff58e3306e749258936db30f5d815ca627b45356981f1832c78b2559a33e74709315425059d313fb3cb9f6d566570a118ba14169cb456412da3c57ef5e9f9f0598bd212f476a2c12c99aba54842ef309840df36e6577cdda7496d0f11156091b5877083500e1e786823789f47eae20775b20f2cf2f5c5c72dec117c9850bba9b196c80ca4bdf4c3dafb9ea1d1e8098445901c5f2ee9d18c260e4b4dd8265bb6e24c31056f10c6220984766372a4c6356c3d9f4416de10ab341273097d00c137ac1a54141bb113117850a84aa6bb98a97e4cf082273d1382bcbb3125e36a9caa9373a9af36e96c10bbd29ccdea97014ee030c88ffc715ac1344b0e2997de4e9e2d0a9a3d4d5421be289cdc63cac19094267b7fc3f32546e54f54629b26d64760cd21be44db7be4686311efb2a3b5b727d59f9ec4a7c3684d4269b6d10ced27c1186b7e6c4dbb14addfd43f21120de568621fae1886d65f87d1fda391b68d500d834a630a20ac430d13465335a214bbd4507e16361cc86d2362729123b03160c49240f4a500c9fff4920ab476b074aafa253d7f83d634418e687b082d8663ca74c9d1bbd34a9e9bf2c073eb5ae998235854c032a84f844d4778899105a5af0dac9e9f210b8a94b786432450589a19c56d63b8e809e54310dd070094529a7daaca84ebbcb43d36c33d8e9e9c066e53f1b7d689f82f33fb1ccd9872aa7ad15a125d1159f773cf0f5f87074526dac2f148a621b5fb9eb816c187a1724c04f6bee4d2d85c59b0dc88dcd141aa794c345c3ae6e9cf5acefe10cf99b661f187573682da2e855bf1d23ddbcac2411bd13eff38c87328ae46528367724bd423589f3b8cc1984796bd4c98ccc20dab77104f74c2e962746e7b71e949bfd64b5a1f1b485327ba357289a8243055884c237fe24789b84c1503f4b8bce6c0fa3a1e4177e7868ae8b177dd715aa703d6a5998693d1cdb3749d1738b378cf240c22e84611939759c84e2f3f34b6814b5d4a51bad0be3f79906f00cdeea75367908830b394c6f612bd8e01156ec26faa909cd48325672f69142d691ab6b313fa3bfc90106e0c23545cd385f69c08b280252faa760e574e00643aa8a5c836916a42d27ec2f9edcf8d1ad1365928e40a8a6f754c1a0828fbde253958058fac5c1669ac6561e4b62b2b7be98ac3a20ec827f40021d58f36b960cb8bffa0798ec4acf50cdc63ab2ff6bdf49f0bbca3c38bc74742d43f201b1726cba4f80d12487b8c99665c5eb9a592c3195421aa8abcc606cddfcbcd474095aeaa36e9a1e683d143bb3b6da99ca18fc95ecb7523e344f7551c1980f68141a556eb943d1562ab7650cf0e78dac0be5e4f39477eaf3a16a040a6928c414a98d6be046f7ace1339cb3269521668c2568eb33d6a96a2eb9c4147f1dd56442fa09a42890b1b4274b950770ea8beea2e048193dfa755a594306ad9825c77659d037092ee09a6f91394a68d2364eac54042d76f9480443db08d7d73dc82582c1f3bfa1db7dda6785c762de34c391280b58c10b4f087ead1cd0e09b564f1710e12b487515b198246cbb86717ed77deb30a5a9df28810b1e8462c800cb02c7a923407a8bc5c2fc2cafde5d2a98bb3a7c29b390fa6afcd1207b88380f84295ad4eef9ffedd4f92f09b4f890106bb7ef63604a1c65ffc1fb3a6908d8cf690cfb1aab1f7ca3289e5943e5d1c62bdd12c4293b32f527cd18aff5b6ab4f4863f3d002c07a9cb3abf9a160a930a884d716e2552432c448be4915d7ca3946825825011496d20427435130ea67dfdd224209716f821431d1b99b576a0d7a648632ebb7d895ef5f06daf02e6989a40e0e04349800bd9ee3c9a5589a36e836525bd78d1ad725995359571cc2637648e34e07df808f3d9983386cc609c2c134b70931535198af978827a21e1462969303ec315251a469ccb827f52dc996013d3c99268485a399b2a878a33e4ded514c17ef6cd432c7ab012b9c28d7053a11198912a06add814db2585542c3958d0f3dc6609fae4b816afe84a2ed0be3375790457c864b82b9315f42c467f713c8382cb946b229c5590f8c6a3e2c108b133d6918dfc0709bd3af800ed0fa20f02934e298a98c8bc8d80073857acd2f26592a6eac44352151582edf647ee38753356b270a92171c7b84a67b7e5db8b0dc8e8665a6b2cfa6cccf1642ead80a74657646c2b7073a2607e8696cfdefd6dbd43cb817b132754633c0ce724be5572e4e732b7d4813ddef9489b20da9390df737ea2a4c73cb0f4aaeb3c0372dadb3ff35b4831e65bbe8c049f1e7272b42464e2c2143cc948586fa673153583939042d42c2b76eb50944e14ea772822a136a26dc686b5ebd68c09e83c1ef9f169034019f242d35e104d79acc33b9e64fb25fc86f470acc967da67e2decfcd26cba29c371624f3b90b48a33eb1e261b42290f7c0c4688dcc6cb20e28b39e2bae5c0cdbbe30584476b2246f3d2ee1fe8aa80608adbee4e57f65a1711c5300a1f27a906311a9433231a55f124aa2e0e1730bd3c3905c6c204cd3371540459dac9da7dbe6c4197c6954455740c9a635a6e7bea8ad2b2574dadf45d18f3703dbb7fa745dcb57e96a466912bb8f3cb176bb6340e329d0927581812e0f2363063160b36084854f91a355eabdea42364d1a9b602321be233c0490ed0c5e9646d5351332eceea91dcaae14437761fe38e1a7c388e5d2fe958aa8957d613e4c74e96d6c0379faab34ccf10e2e0fc137a71794c027f9755f99e6b81bbcbd2caa5fcb30b79fb84700473102afe4b776731347681de7ee8755c308d9802570b85479e325a281f8424ca79f5976123ef03500099839233597858349835f323c5fcf55d9c2a934ea8ae4e8606bfd30e6dcf1ffc6bbae645f14436d312c258d70817f76178e2832ef7f6d8c0cc0b1bb4f7b3e551738fa45db9c23e3485a6f71bdcbe94d14eecc06779e4b052cee103bf9897ec2639689222b7dab780784998954ad915d5a7af12a236611d6294aa51d455637aa446ae7a3df575ebde741305f05950c2970993418737536819a7cfce9d38ffd8f221ca22557b792077006c05d2120be33cff0014bd83a4da9e8eb642c248534e3a522252134fd09f72a4bc5fe47bf3c0ef0e5e55ed223ab91ad1c975eb8d4723a16220d41f7b60b0f8e86bdccd9feea1d6c015cabe1dff4db4f96f2ebf10c4a151d82b6f2007139a3155e1443583e5cd199c8d3cd97bd9e0958d0f37e6d8b00e723caaeabef9cfa74472865fc631c18de12a2f72e544b2b8e415135609edf5b32b17070ea25b7e1d5ac7c3f426b0682956f361368b80711eca1ae254d05879d8a5f0a9a3743407459addfecdfd08c4e99f7e8c4e7338fe5a6f23e4f8e22026c5084ff871db8d52672d3ba0b0f442bc14e5531983447441b4fab8810ce84de2c17bbc5c3f806d47cb3a6a1266b26437f44ffb6e9da63a22749361215689e8971526c03dd60bdcceb8eaf0bbb7e0791fcf06fdf564439489e164a72ca06ef82c0a32e203ff23e3cf786557026a26865bee31e115a0c0895e4492110ab03e8589e6c7ab168070883251d22651492b95d399f9303518c82189e54828234ea29896f10ca2df219cd5df8c59e60f1a98ad6f188671bf950165f20cac72e04442373b752a4fc4ac4cd2be70241ea3a614d717b2ff2c1adf135c8101e679a759c56d60b8493a2ee72a86b847585677b5481ab3b08ceaaebea70f1f0b1fc5e154d43fed038fec869cdef9b3572017f20fdc7e2b5a5731e3fa6584b2747fdcf7fe16b7ca9e27ec3291103398eaa2e77c7b770b67f8858c215af4c523822d484f1f34dcdfd137c29c8f673d504606517dc2c1ca4fd24180d0a7fdda5b7e5291537fd5b614e4e8f72a5d8b1ec2b375da5dac64c2cc30b19758a927c941b0153d6ae5a24e521e611246c525ded57b170c850105fbc459fd5821281b9cbc5f9fd6fb1a42ab7fc9cb9b578ddd8673e5136e5b894f7e21964e4b93ec805bb6d417e470e75ed5852b4d1ac57e5a1c83389188480ce752c92fccf917bcff0c1658a6ed30129ed54a8c1018f76045abecbdbbe3b551787fa66c9ee9136240b9c431747ba363a9b2b8363b1d57fb453898bcb7060821a80e9e94eda3f1a4ea69a7a7a81531a42874b670f7af4c1603cd6e7cad79ab441f069bf1e0b0174ba525a9046b44429bc2242b816c583e7b26715647c6c50482866f84c9a097ef1f1bf4b18ee48e3e1120c901b2c19f95f0572d386329717da38552416554e0dfe7f1dea88f3c7e8dcfea6b1f4b1f0cba3e3e08fc1900057c6ec3b6b90d2514516dd2eb744d9a99979ac7126d94ad28132d820a8bb1700a6bace9a3d6093bbaac776424fe112769c53d5fc7d3d4947a0984cc3bcb73a307b1259e217fa0bd5a58ce4f902e220a757d7e5b913955fb8b050dc3a4a5a7c184b6a18b399c1bd37dbd3a3c37edca6c4528276379875d0be16d8e104c0194f109e2e858f216c2a7aa4382d322214f75622ffe1e86a535eb06aad05a3bc8835c1f9dc1ac55d3dd5e695270bb58b3fa4c53f8cc35c07b25c582259b4a7ae0bc2a4d4ff62f68bcb4234252ca9de18c131aa0ed584f2ff274bedb45b688103387821c604d8a35b98f1cbeab5920c692e206d2756c15dcf06c009b71ebbb05a82c8c13388f65c4b3b57164c5e5ed0eafae3970f7ce2fce5e53b34913008b6226f272ba3f84671b906f4bbc0836abc1cac1db02dd47440d2572fe6e92bea22e97235999def339443a05d24fdd1303e8cb6113108e9ffca22b110a9156eda571e2056b397ba5834797bf2da4aa459d8a99d70923729e01945a78ff3ac7553f33efe1d0218063ec2a91e48544d89520af1e6be6c2f10cf8eb99ee04f24dbd167da6feb0d953f31cf70fbe01b5d0c8355f4164d27673b08cb0cfbc413f50efd256efa632ea5e1dbcb6f893ca81f9a983a3ea0cf4c6605363eae62bdfac38b11cc7b21f7edb07ab746d36ac072fbaffb38201a9753a20bd25a1c58106be6dcc9cd7d7b2bd34b863eb26b051e1487d916c056f847c5a1bb67bdd5406ddff5708f98e46a7177ed80fcae84eca8053a92857331ae532afba060da77b048df65e2cdbf4e746b33fcf75b8bcf85e0bd8a68c1b14eb13bfc06374820622c13d2beb02ec12a2d6ba02045e5ea89656aa60db8561b0ca584a157fca8203318616276450d1ef60a1534ce19163b710fa8772b2dbd110a0fafb3777ceb7a5909b407133df359307eda7a7cdd871ee4e92c7969255123b5342fbadb149c6f42848e291be77be078103de9a30f92d5739669554e3bdcd39cd7872ff97025af8dfd525106fdf1452b42b1fae73bd41f9b7be17350ed9a913f4e488b690c319ba9e893075ade1e07c8aad9269fcec55dcb1e175c079724fd0b2ce63590352ab414eae2c48df43ca8eead06056344e10091018d87e8d4f6678ee7d2e705a78b995d58a40126fce798fbbddb1fa83aa1b87baab68f5b23a9714903a0f84fcfdebbf1d659559c44a9687e71cacdf52ca1d5e99e24caf51f98aaa7f4d2e1c51a9e8c60c8952a8467fc87f55d57a8c0774bf979404ad34d055e645a5feb4c0c14459b28c3da0845d35b87ded5042890c71a939925bb20a991654eae995c9f8b495e58c84c8a77771330e8c97d42d5fc789824c7d2d84bb12047ba33359944d9265355bdb738e08ea4271b13bab6395a283f3d93cc34acfa5e604776b933e46c37cf0277b867ec0302a89f6c11b0bb30329a3e6b7652dccb986966f7a8bee6cafa2bff84b499e25abb3ff62116d4e4154413b7ed65b553cb5aada914689cd45bf9f4ad7330317c1c4a47bfd14e953c8fc9462a681ece9a6031b77e7b8d5035b593a38cb1bfe101ce1c7a4d0b0d643d063eac168a06111930aa11679b8b6b736e73c32ddeb80b2bc6ce223e2ce7e45dff10bffcb1b02f78a32035f4d2f76125ccf6edf148bd2242bcbbe9f3c5727827f0ebec5d7da17c013e30bf96d035b3b577b95e878e43c8ff16823c1e4311a213722ccbb95c5e897b6857f8de11eae5aaf517cf411dc051b94a9d931e4469f4b8f95fe880cc5bda2fc8028c2af66b699eabbeaace85c77ef9ef8a796447cfd2810cf1ad545c0dd096c3dce41e1c5bd1e921fa6b7044dd83497bc56990abd7edf4139e849469f91f58f2239b27f2209112ee779bf6d957111055caee140f06899ab39328d194b218eeb9830bb8f64e39b477a2b692c1e8aaf72427717edfd047dd438be48c6abd5fb0a087d071b7593e46440845f48ce6b3665d579e21acb9ab4469f552353a6f46574d8e63c2a3c61130da14c49c98f5bcd677d7cebce44726589d4bfc6ca26c8f3af723403c5a19550cb054aceb848a49cffa247d9114fd3b92341c4d8321297ce453c2f03f38c76c524d447971ce18cccb5aca355ebd407d89e4c2c029451aa1dbea09ee5bce54d97a2760b4cfd415c851104580765bc54e9825fbeebf7cd4909a0044a50289462f1cd545e9463525bee9c102e9686ed031455e1433b636dbcba75d2fced4082fdf92cd4081757fbd330dd39edab57505b83a13a849ce1194a57c4717a640b9566d7475fd07ee0240a725ce75ceddecda65bedd146b477b93c0816498c5c91b6e4b4a65e7f7107b549dda2834405254d2ac7c210542b3036daf7f2c2fc7ddbcec1b8d237dd97d397d89936736d9a34b631eda75e75aa11766c49e0449170f0c3430a5254b2994cb0ffcda0219f5511f201f5242370d924623a29683712ddd97fb3d3ae1bc61e7ae906a269f3a2dec6e7e208c1c80e5f70e28cbd1303486b9ce8593a6ff6e1cf662b343f18533ddc5b7f1e4e07b317e5fddfa92d6810fbc343e87c681c4cca54175cd3cc35a83af7d6a0fcee7d4d5312d43fdaa2f0c7f28dd56665843d844a5495652973495a5fd84134c310acfe898ffcec6744318ef7705b495db75a082978e92f7f5adbd17527a322bcde1a2f83037dcc983ab5ced014dc7baa29fc3f2f671aa11ca97374438b05522f7d5146071760c9b4ad04f0462260e39401aa9123c930a24a8999ad93ad6eac6318d9adde73acca05c4a45a2142f0696568ed66cf48341c4f22d6e42b35e618a2d538cad0be69b6d1a81f76291b92f563854c26f98a2df6749bb17fd4ca767e32dcf807a4a09f776180fdab2656506fd8814f396a372318011cb3e7561424c65c56a0cb24c357f4fd75c460df9a32bf0a837e08eaf81e6a3ecf628479bdfad8686bb97d16cc9915edaffeff1d903fce42b462f9417527d372da49be056a009c9e42ca8743666bc2785532efa8e07f82c73b82753655453ee765edfec1c53dfb46045b507337d7e3e78fe9984831fac4e34166e592408190e399d8aa7676b9dba7d8f5406de7e4608287aa62c52bb97ddcee97af1de0e2b2af9d912cec257c260ae71fbffb1f9a219162fdb5e677c393fb699c3d9fda708c939aa0eaeb798fc2b7596135e387020f5c4b6af974bd20f088dbfdf5e0d93306d6b88e4e3b1af999f655430aeec623102b687a9638a4d97acb6b4341a7833409c21ee1bea3b1c2910f034ea6e485060d45e1b4f4f7d5f51b0b42f588be807a7b9df524a4ede6f394498c09728d6bb1eff3dfa17b7cf87cba92879b31eb790d46b064dc67df609289ee18fcd4b1212e9c7d8ac7948eb4773ea663bea6f716f6504394936f42c8aa5744ceb035174e85fe2b09b0a5f4b1ed9190fee54eaafe3c839eadd024ddc540e894d7acfe889bbcfc4485e4187798e69a987f9891cbdae7c508d61cee7a005e23255b7895ccafdd7d1225e953df116a41050f5fd724510000cb37fe35df200bf041819d64ab34ef6bdb1249c0f4c3826e21d5c3887b0c8d1b2df9fe61d5ce50372e71a2d1edcffbade8738cc57d57350932fa4b0c99b299fe7744a4da24b234e035540f46592a082b817138cc44748cfa81a580cc46ec2991f03f79089473bfd49e526d2ab8ed1ecdee34d73c0fc38d2956ffe82e496247bce2130454edbaf9f9b19243e5d2c0457b76e3f07da7ec427ff9300d9b6cbbfa6793e7cd24f62eeb38b63d19df6f49861d62a60cf7d496b3e2b15f777c75a04b7a4ce45de178789c7af47a787f5733e89bfaa7b2125d69e73bc7b4ac372db840dd55323bf43c3f14a5b472e62f512474dd860b6a360c0fe673835836365cace478f6f8efc3072c5ca23e4ced5727c431cb4efdbdcba72db8702d739ddfca233c33775f02b8a4e77b5ada31155d9fbd274e9aa33139f76e661c0d2c679c3ec652f71f8efb3ad91779b4d049e5aa82b45e4cb12550e8c477f65e6bac1ed4823d2daa38ad62b070645f9767bbe5a69754dfaedcaca240d6f3731d8e1b49ee5c2fd53608e6c0842f7834ede8b09db9a842b15d6360aeaaf488 +MD = 115f8631397ca4c7e373734bb7173658c109e88a9c236d29399005aa3a6cae0ea5552690c8ff8e0c27a19a6a435f801798c05b0b4b1a6583abcb4348773c43f4 + +Len = 93688 +Msg = 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 +MD = c8a7f49e8f5e69ab5c99cccdcdea01c60765714043896cd560afe968ef583ab4cfa6e16b8600e930633ea7c6304c288b4f960937e36490d96459b1be8149b3f1 + +Len = 94480 +Msg = 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 +MD = 7268dc371d074f606ba817ad4a8868e55f391724640f2f2bc85308b2b27aa312cedb9427424dd909abe8ba28b6ec7e693894f867712b86754bdbffdd5eb4654e + +Len = 95272 +Msg = 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 +MD = 61dce069399909fa7f4ae87e5e9e814c1521d6555eae792393a7422e43135321cdef56adf36216eedabe1c6f0cd039fab855d837923391c2dcc9d31f1a2ff6ec + +Len = 96064 +Msg = c38f4de032c8500e46f9bd0ac75742db703f1ae1f628316746d789770ed2dcf2801683e0530c96040aba55b37836c6e78461a0902ad1682ac20fda9485038a204daccbe79c15d05fe084112ff5f4f041ecc59d190bb33766140534d7cb060230b2b9ee9d17c9464650bfba234677081230d5d927a1b4e543c51f5ee8e7c48c4b37a5b5abcb113fe2e3d3183a71a95681d9f81b60f5bdbce85cc7226ee424709965d9e5b9c0d6055a2028f31a807122b76e952c6c0eb7027e61644612c70df541c3bb496efffeded79026136b7ab6b3dc7716d5f4f488002c5d5d937b9a69646cdab4a8738f721381b93640d6686252177ce2dca0b01afe1bd71cd151651f0541302dc96f781beb7f25be4102515c479006610917495344725708c83e2e1720e94f8c750bc3e0b0fa5c28df993d8cda709cfb2602c71d195a65893fe8ff39fd8bbf3a74ef77a8a819e4dae24035da53dfc718f908335fc7fb8a0700f7df6de45006a08ec29c5d1d05473e12a13f2ef9040e204cd29401947c4dead114d79b1c60ae258b2d3be655e50dba366466701508f97be507f2eac906379b7be7edabeee23f3032d75a2b99e2bcb81831af88ef1210918c505504adc0cf80c6172b85a2fe3f2b4c6904143024de9f7eae245ecf4bdccb0b55c6368ad39d02794d991180de387da18a3e8964d2fad73186ccdbfddbe48f29bd4c68a66629895e303e38cfa7b18ef9e312727b1599c8f95fafe5c0e9b046ad31f0824ba2fc7e3b6922e0d98433c61c1b87b7be1442da9de2d665629dc9596058b96dbfaf9d47d99f4df2e49b458dd2dba54075f87d75e7b648442920b62e0adbaf0f4ab4944e007bc85739146f4be2cb75f5e8e8d2019d830d685e9aff2f7361da5136d96afa77a49af5201839681592febf5e0dcae688f32ebb48322dc36293431bc948a6b208c3cbb6e0cf2c4c33d94984218eec8c70acb2243111c751a019f1564d26d0e079806481c360cf5f04475c2e7794c15b1d56a18a5f5f5543f69aece8089e70eb93826b3d0ff3aa0a4f8541a3a947d0bc569a04d71b43600029be3dbb43d50f3b1e72ebd40db246b3de3a00cdfecea115e420e2f2ade56ff0042eebb645f63438e2f7e92d05c32ac4770f9f92c052bccf908f43c35d6e0a7b4e92fec05827684aa7ba6f303f4edea3e3ac28dc35faaa53208f2f327306b909ce917fc3c29032d9346384c5027cebbaeab8a292a7eff2085ccaaf2736d405024dd475a6cc5b1a4d529931d49874d86f53dc169c5c581c550ee5ca8aef0175ce9303e851beada80ec9047d45475f2d2ce8bf8be29d5eb0a4fc8b8943e7b492d568c5e0abe0b16584614d7000586573586f0a094bb129375cef62f23a6316e28094c2669e798cd817e11c12ee13ad315ab16499c1e2e039e4af121058ae4fef35dea38112d3698a3013186cf5bf60ef9c7676412c76ac3ca60444e8830f86415d10103aed346e0135bdea85fea5a5368585e70b72b6b4ca09b6a084a4cde45e61f0b09818e5c3c790a83a65f20ea58c7da860ff7cea216a758ccdeba43190d0a7472ca37b2e9164a79caf15b740887ceca58924325a1aa5525074256983b21f99dc2b63fe56005ee461f19c3784758b3a4509827c4dc80109c83c3bdd0b74d19e7956e18aa7373faebea90258219443d0508921430d520800bdce34e710fc701de4552405675f8e6c7c7f5004610e2b148eb00a6de0e142a0f6d1186edc728480e6cf3459df9fd488631a8d228a0bcb6fc72744e40f9d36513deeef5cb5ff932e476d1a6c572098693b23c19ae5b2ac4ac295d78ee1ad6c7c58cdc298e4cb278fcfd6dd2817096277cc41f454ba2c550b48a3cc55a03a6c871015980ab0fdc70b46b285736683bb1ade1d2f3751a14e1c21f92a20926bbfdc2d6e7a9a63bdfc0a73ab1b378eb629ba385e792df13820e3153ef9d60169ece177826f3044354cf41f67a55bd5c936bfa3addb1ee31952caec1a4161335b7b00b6f67fb49a8a4231128e2ec784e56a91e7b25cf0706d6c376d370ba8716af4a0b175b20eaee7632914c9bb63e2314c98cc14048cde5cf794613a5e9302bee02831a51126c8723945edc0561739d6643d1a7cdbda750d7a4890ce430a307ec702fe2ea3e42f534beb641a06cbcffb3ae69891eac27fa97dbbc299c1f541d32f95e0b971312db32184437fd467eec957fd0ffc382d42578855bf43e03c7ee4a2499fee81f308ba44795099c6d3dc6842e84764cd010740247e4e75a8c82fdaa7860274dd14098f3b30540de7f7e1ff83110872b228168bd89e39d7227f9cdcc7b4d2f48d7a785b8e1316863cbb47b6a3de1aceee88b7612d1d4610554a0c13883bd715970f9d45c68960aacf0854b629b9441f890b32eaaa633ec94a12c9a67584d98005b9bf766af9f821a7c452279d094f0d8c98ce4dd7d8e8a907bd19be13f5a0dcdf62281502cda794ccd9873188350442fe16d5b33ce50e5996344583ecf7f3d22bf11e4b166c35ab472d3cfa70a72863e76f8d4362f07680ff60941c87f39c0af34eea402f3e6a0d1faab8ade0c6861b508a3f26d063e9c7482850b26c4f612b3e61d41bd4ab0e635c3745705dfae50f404f32830ea42fd67b73bf6c24750bde151223058e1be85407bb296b71ab0ceabfa6b083a51d10549f2b2b7336cb62ca7f492125e4f6c1892620adc8a341c452d577ff4e1c3454e9bd37daee2abb2d9884ee14a45ea461a9c44d19ac7b24d5ef8baa680bfb53c23edc7f150689ab36ef2ce945a9848d905de62ab54182bd076be82733e3cbe124fb04eb23e3d90543788022fc5ddf1a164d969fc8af3f72226bf4d6a8fd124640c83d634eaca5301dda878181e7f6b1ba20db949c1e3baced9ab8a00f825be9de4b90cfdc8a72948cbe49ef1b7051bc457fbef177b5fcd4319d3b6baf992b34c82f041716a4ca9957cccf52132079a18011459ea29c0c50b61f8621d16b0c8ec51aa223442334a748ab2094b11ef5ca307f7a8365fcf38a44c69fa8bd1f855f9cb571dbae2e39262504449b3d934d9d2070658907fd37e8a33a90eabbde1f1016a779289bee5f7eb77e4451ffa60a84178d0d96d2c662d49a2461cd13d06007fb98c2f0558a3117c6c2279c3f80b3e6dc7e7a930c80fcb5f32c183b0c1cd2ad1332551d222b345a1a77f5664448d02a38eab469fe528bf374f9bf1befebfd6a251a39954bf9f2ad7a46b7965727eabaf379c4fef06599f6e6345d54046468a7fbfb7642171bf279afd77414c04588fdd5d4b13c2ae0ad251084fbd093b09bca5b7b150ad0babc2782d134c8c7c9325ba6a3830af3ec50eabc92a076e4f61e3d0e421dd7bcfdd91db8ddff9ab4dc703c2d8d424f95b108acb006542e3f5f7a66dcf99690250dd0c51ca2de72cea5cb08333bf7f5565660d4b5871fe0eb1336af8c48881d5111298675c9d8385e4dca278055aae37f04ddc893bd0a743139da7fe8d6fc6689326dc78af9f6d4acfbf602dc82610157e209f112511cd359f9ee3db64cf952149823f224db3f2e00d8d5ff0f6a263728196bb7faeb5ee3ab7cfb53bf5188cb3c6ad36e0b16bb2ea20cf187e0b6006d38d08b831232d68d6eea8928cb8eb0b947d105a3075372bdd9bed203180ef88bd130f2bb23cf8ebaec6b1e24a2ab79027ef442f9e03a6dc1ef16fed97f191479396127c9f5698e506b2544af0b4feb8f29fc11d85d72b3232a3dff73dd805e1fb88ab21350a9dc3934438231cf220f489010fba848a44cccd35b5d37faeade6698d31c03fc37825b8feb6012b6ceec15fa5987d1677741a331979e8f9e009b341f65ecffc0ba88a0c34667ba88f88adfb1fe3dbb8394998f8e1a4ce2906a9d739768aa7166dbf4ee1a7b1e920d4af28cfb28a5ce63a25c7a300cee9799cfec094603dfc0b441d02fdab20e000d6c2b0621ff4873d14a924b60940d1881d891e0755f12547394244a4c15bd6d4f063d336aaaad10933444ea66da30cc102c93de6ba4cb956a7ef627b8c9b5429cbf31fd20525c0f72077a3e8a07df1b0d74faed72f992eb63a550ae66f97ee5bc3f0e4b891eded6366c3a311443a36d4257cef4d086f0be24b139c79dcb9ec0772fdc04ef37bacfa70a8eaa4bb5022a757e18dace746c76774bba5aa7679f399537a41298c478608c8a7d92798686ba6f90e089b4eb8f7b221bd94fcaf609baddfe6d5ccdeea1f3af930fcfe4ddb786f8362ce8ca12df35edc8a08e4fa062aa182d3fcad5ddbcefd6ce4d4ad4e31cf4d81806df5712e60da2fb17ff7e8c34710e6b2244fab851bccae23eeb93c03d6dd6dd7556a5132c69075b458b9ee3067787611fb282a8e8c25378eb9b689ba25abb2d8235fa3c38b2e6913218f9cc61234bb73dfcb6d40a6838385a409a9cd4214fb233649fb592510544e68fd570ccdf2114850bde653e1843c995c372ed5a2c5a1192ccdca7c2ac2c1d6ad97bf7cf13d320fdc542820d3a3ad4a40d38b3bce1a4f5a753f83a502d25c3c5dc3388f2252784af132954fe34e6008d05341983aaf40479e23d95c53bb7e0ff82444bbe7ee6e8a3dedd02996f0ff65a92ad4436ee14e61062f1e1a93da91921b2f869ba86d8f3e00ca4b566537d5e139eed5f5d14ca4474b95d45829dc4183154950a6fa5c44e6e86c795ee49f7dfbe103a908086dfc6aed1c9eadac2d0853a4f6455634473a155358dc9b8b7472165d0ddff28ab1b13c4907df738149507418dad7320c9ae939d00407a4c0633cd0fc51ed6dceb45d4c1e0c09525fbda4750f5b88c2e9e3bcc4fce26cf339f848bc5d9443a25ae27b0aaa8dcec28df69ed6e6fccc71329e2f5738989f1f4e801028ef399558a5c875089d01723c92808a0a4e3324c59d46db60f18af07174b74db72fb634f935d2e5b653fba63903e8008f93933448706a2b62d63e13a252fa3bd79daeb50c81ae47a47df0cd3068a98ce755915d726264b9ed45266b2a5fc5851ac76797fb2f970553697579cb2721a9a202c202cbd9e2e150dcd88961f19593f12b85404d8639c933a4fe1e51c5fcc1303989e6cd4d514c4dfbc8d0e1bf06e2eb388c608c2c12edd5beff4d7cdba78e22586d5bef433c4525207be4422e861c698cf15b3f979efdaa260d69a4ce9e4af8edf0e4ba32008686e96635dbb69f9b0c8738a2c04f5a7331688cf552156d9214789913a6c04a6ae3c51c4846fdbfd944b5e6d9c6b9b1e8fc0502930d5671ee0576ea6b4d44767cbc32128dfc5a736192a76062ab7d51b97a6a02a54ef867d95c67595e1655113680becd99645336ce86ca59cff6f0a68f3d2611ce9f71abce89d85a5e8a68b722c1d9c1dd277e866a919d279421ba1cb4a4c794516768ba480e38820f21f5b4bc000173dbbe42eee033ae5e31c44040d441ad2ee04f340fd06a0654c26592a68cbbc478078136eca9ed6c523b5719af68a46535edbf6a38f21dc0472addb618ff65a1230328c0ec323f55c81342acb4dc4d8e3dfc2071b217aa04dd9ae2d6689e9e1629310d878a13a9f9144c1f7ffdc9ad66cb7e1af107db8f328cb52d8a31e4b591ef33b7e122c8add4cb686619e69b24ad52f6175ea6984de7d8ec1637e15c5cb2e96da06462cbcb6751da8ef10bdb73b068f6ae212ae8668346b22566138fe3e7ac516f97b687733f5c2522abea04fb2e61f237dee14659935aa9d3ab34d9fbae9c717de18a9645bb2edaa980ed922b65f27b5cee762ca7968935c96dc1d4f4765e6043d87b72b3695e6d8c36932d94f58ee485d66625c11b56e84f24470b7eed668059f2f5a73cc86f4053338711c85babd02b3d1dac468058240d6530e7eb62296448a785ae4266e60596ee15f92616bdc0e579193a9863e18b6cb71be4da832b8e689ca7e274b3373fbfecec4e4ea549392d10f55b4744a780e580649cccaee1616218d8fe443bf72146b6568ba295d2ab7aab2e78d390fea71067a78a2263ef7fadc2956c217f8a8cb3b1012ba246fe8a469e113dbdd77b6075c351178c40ba5ba4107986acec85c49f8368c8fe570168296069f46696923f7e29fdcf5aa3b667fd88d20847016d5b5293e9cdf744afc78b9885478e4cc7a6a2020a3c2e2b883712a24b5b706c95c3857920b53d7e3e2af5bcffa16568a04879f212c86746844b7be341eab96cb39fa0999a0921825104e034359cbc88a0677e60840ea6635f07a1c2624092b03b422c7bb25453ff6cd7e3a4c383c40b4cb617d3fa796c206d1e1cd608f79ca5915d91a6060135240636787526114c9f09a6eed2c293190c22d15584c27a27db5a34688f01ba55bea183072bd9af96826bac5bd398e63d6534d3d4551b32d4bffa7929bd31ca261dc350283f5ac94273e749075cd9dd69ea079821dd6fdc13d1f69e4db722cb36dfe010443625f8c0d2010f49e4f1f2fef91f80c6745cb0759fe3165cf3312808638c65f396c7a8922b5d61bbf29dd19d20e1402ab05e6a7a982473cff7f98b0b472ca3aee7cc7356fe30d2d60c29c3a4dff138c727e16483594f293f3bf84ebff9457bee8f80c35fb93ff510982273a6b4c3ed442182292031d7c8f34599fdb7086b312b14a1234cfaef2b043d145c231deddffa63bd42f1e032b5a49b7b1260e302660d1d8a1d8f11a2f729517bd7aa99b3838234ff2c48b30481cba3f8274e27afacdce0c81c96bc1febe88bc5809da6c96a543bc45fc538a1afc105bd96ef24d7583324d79b04589a6bca328de18cc39416e8dea957c7ffbeb23d2727fbb488fe1aa84025235855c71966ec4174e88eb7fbc8942aaef176a01b988eb3d04ec2a84694d95d4ff3521a57171f6ca54156899b7c02a4bfb21bea6e5ba30d9f1e404a7e9146dc7b75cc08b783527c1d17b9ad786b90b4248a7e11fcff1a81b293a07915261f2f30403206bd041c0c26ec3688052fc4e557fb0bab7a0b4bbcd55f61a8ccbbd8c208f312b8da41d2796d3f4b9de4212594d484531b5808cd1b51c1e24de7caea31500eec8381a52c605a71677377f8296f14a6d2e609600529d27bc0fd08ebe9f9bfe42dfb65a6704d6923289d430d46b0b2e3099020b98a64b1ed7c2aa2975e87a3136594d8de448d33e4ed7fd7e9142619b965ae106dc3687a77825b4745ae67a42d11c46db52fcc2507549f9914082bd3aa85a45b055681b6da6203698f50262d91c11e96b37876c73acc712906993e5b36d7f78318aa5cd16699b77bdcea2fc9d1d207d661e51994dfd398ea395dda1adedb2c1b00356674bc97ec0096e300e37de324cf38cc210866f87b6f44ac8bbd131dc675549e1afb3cfb159a75c12614e672d9c3b0b429bc70a99d2a813bcf9c640e3b34ae3b06ef7821c8abd20b2bd8bbefbb666223900b8d7572aea7521253423b1edb459296bbeeba89b744376ea96ed82e29b5a0f0800ddaa05e0fa5f05c5e02c5dbe34b670b1103bd3f34cc8af16fcac6702392c7b472578adb229de621f813e4a8dfbbe4378fbbe7b63c30fd5b4f15f8fc449f82137b5ab68898a0603ea0dcefe4c36a9adbab41adbeb30b22517d685a00912dcc27697297f8da640b2cf8dc3bf216ede761f41353bb41c1b64e7b205e3f81b3e25acd3dc3ae504f235750807d63429c76651acf9e3e50fb15dce8ec7a0baec8713826faae0ba2d86558686818baef2cb45f5fd4d1aa78fdcd77271b31f760d20549f757dbb33a762daa7101925b74e52dab63a182a222604997b63b1a755076fb0adec3c1179fcf08c82acb7ee76c7c4ee396d44597d5b916c926da9817f60deef51ddcf2bb3b39633bf65432c14e48a49299db8f0e1b6eb185f9583f61ba3d4d8354f1d510a55be960640a528b92d0ab32cd35c3675c07b6589e5274c5255b934014a10caa669cf7efd47c62a8b2badf4ea1618756200a71bb9657dcb4b00f4cb5dd78fe0ae7731b34f818c79b565dbd30d6ed4f3cfffd801961c6ebd2f2bef65effc83d94a084bfda2f6e05f5d64fd1a3ae378fae54377e0c912e068255f11ca62c3d2fea4a387249fafab22acae798f1b7eecd0cb56ea80f94fbc165623c2c15c346597e1d04cefedb3d30bc9cdb9fb584618bdaac09ba9cfdceb0de9ff6a14855624ec2c170327340a4262dc4923259944e50baa07f023f2c05495077b71898731f744ab0112941ebdde6f0fa821d7857e3900f2b553b50c03def8d82040e907cdc7e98615e2fe51d3917988741ad7c4fefee6ab512b29c2ae737c83753dfbb0337a21e6dbdb2d755441ca6f3476eeffcc1a03fc64e045bec7fa6b3103d189276afa35f3dc65e93349d8a8ed719ce4deee77a00e75dad2a8595a0b09506459177a2d6dd49fe9f933b93d5c2ab2f681086efb04090c809727697da534e65f35266cfd10b2adcd261cac582e4d7feb8d2653907914b23c5ee4014a80d94d28e3fc475168b48c7b38962a11657e60e3cfdfa61d4557ed75ed8728a9e6210b292b421310bb03c659f74b3c504be7de4610dc6e89b1fb48940db7e7821d34aac9d7a0d82452c6e3d12ae0e9fd26ad807d18c4b3be052848ff861c45bd6e39b26fadbd9f747526694a9b003a003ffbcfeeaf407ea38905771f205f4a432158a98577426fe86b4be22c10513541def752029df8d62085bb5c5ca328fefa7ebb1972fbd651687e5cd5de527be4a94bc99121a993c31d40717f1fd61e6acbcd87899e02224cdcf481cbca29274f1ecd9a14b49dba4d82035069ce82ea959e55e7827153ce682c16e44b575cfd7d89ad9264213f147d371680a1d36f34875c5f018b53b881ad412caaddedb5a476d334d808d2584a5a25c128af9465a349eb33fd2cacf7e324017efe09f4fac542e2a795882daf03ec324c711c7b2cdfe2351904ede4d99dd455530658d4f407eaa051f06d9c0ee83c47fe826fee8b915a21593e57632657c625f5ea51f66b1375f479123d863ba0514d208430574c61ba963ad2f191a6b8005aaad37dc02790ebc566228353ffd4342afa9ee81d35f6097e05e843d720698cdabbe9629bef2754fd6149c46a222cebc8d4f91ea80ff94fc003aad69b5e12728f70538af08c80b983b2af8a356c4f800df6bc5a60a1119444793e3146265ab860103a7d25c742213fa17b5c1ba5e6fae3a71024adb5e7e1f2b2ccdd4141e96834e5c5c1a46615951976d6c38494986231311d05f711223db2f57d60f3776889f5351de0d331a31cf978e746d8020ebfdfda0a84a67e6bb16c897844c38f7f248a4969621cf291bec7f0d76d80b7f019d4eb002a22c46a4408b7e6101b53d540db69d2cde66f8a836b26cdc0e27be579faab267dd3abc6fe6ec7ef4d628913e5d0dc80ab98713474cd62f2c8671695e63864a50722fb28e78601ba82fffae01b51ec9a839cc03798d6ec6d0c774fa968765ca450757b370839ac70375c6ee5eb46df48de59243cf86c0b67147befc9079cdd4cde35f49c686d1238f5e0adca5c97feb4433765eb9a78090869d9bf9ccc932dc43bcb2ffe0f0b793b42f37e36772c91033a9e4aeb88e32c7792fb84cbbe419435ef9df10606fc2aa1a9fdaad143ede0604bf69de5ca93bddd174709fde58f5cc78015055c54266d91af66fa44c8c332f1ffa7248066720361812715db4a65cba1789a32a701738a33de9733370e94d1dedd19a8656667482c57026f0df4ac2bec5f933f8f16cac8b0bdf620511e4a03506eb5f03bd159d2652140e03aeb4ac2cfbb6af5be9a127030d4ec883bffcb116f38e1c6abb032eb356848300a3829d97316861cd99535cadaace2329db9014362c506f05d0ad9d9c4b2842727e22fb700f74f7c8b101a1ed7cc3ee71d55d2e0529d8d37f8e736e4398a5b8c36f146a69de72ddc7911a9b44fbc696f66da28326646dc6325503156bd753529e26e55ec726d88054ea3cad36905cc921e50ea7fc74a5d3c8b4bb27577fd7ac4d06044d2a811c8c0b0cb65c54d2ece18eebf00109c317789d3e3a18b90a99326abcffba0675b55d3489362d024bfd6c87d30512d0e819114a41de6de2f01e61719c4619ed6d49806bd02a93d16414e6b74aac71d45c415a3a70369b67d8edc5fc24560141e03f723b72023544a3b9dc97a36492a68816aff839c135da2d7dec5505ddf496670dbf0e0f6b65ce9352baa38dbc09a9f41f8f0e1f0ca1ac56552126811c786d7a4ad37dd8b4b9f1ab760d655a112b6148b273e690877340ebea10eb46bfe139926d3be59e8cb63064aa4147a9028c6ece75fb0c2eb03f4a66c3481dc726d38d37eb74efa131cf1d4755f2e4fb1ea1252dd080f95a154a2b5f77233882efc3dae35bfae68162891adc1f9ea7b0b40e16cf68a238933548662e5c2ec5fa8946951d255a84cf9d58ab9b5da11a7a6137d62b94db447a8e9e7d6c08e7309e71b05e4dde0024ec20d261fd96a6b7a8b492c5dafba8a7608fd0f390f3d912ff37b5991dfc885157bb7ab08b512bf9dc1cc37855e376cbf5c7744b25b370e79d59aad7e5f74f94a2bbb629bd238d7b75082e601502d24caab3fcf692be3b28e946249d3e54e2694db019301b7467971415580fa0d05783efd3df88707ab441738b974b9f9bdd39c92708661eca26e739b2c4f971b2531c45a59063477f68ebbca8978582429ca0a58f282e4fab67d6466ee990104f71703cb7b4397042d562351b99bd7edfad185356ed1b268e870edab85a75f50e1f1a4578bf5d935b665f6d531265edd99b1b532cdb9f2bea20eb571d8c1da854d894e0771652193fa83dd5fd961177a6c324356f583cd854b1e65c0cf2e9a2da2a5aae215db98a5617780f59993284fdc1bd7aacf766a444a69a4a05238c6cf480e5ff05f9e66f3540b86a25905b9e15236183443dcf28309b71b1a492586f4a78c163938f8b2053905986b0100f3ba3449affe3afb8ccaefcf71359c3e042327e677c6862fa464792e5d5a79cafd61eb1d43109a1d61a2647b4ffa34cb65e430e6299e338c66977d4e7e76a9ab005ee07a7d704d889892d0815d6ff714d4bf2a52d5c925571d26ac2da2c779ed243a7a27052839845a239caa429ece60773d7df3225046d8f49a6d927256d2d7907c20ee8240485bcfdb2ebea78fa1f976e59191b93a7c5711792a47952a9ab06dac3c959dbe61531e45ef8533495925fa40cef4418fb11b9c4e4a12b44bbbc1e25235e5fdac6bb670e647c78fd4dc2d2bd49de36357cc6dbe9e35bc77c21b5218f773a64a1150caec489f4b62381459302c6427c79bb5959ef3520d8596a4aa37225ea02ef6f7d8bbf25dda557de8f032cd8c88146354db66d40bcc87cf3c13665c5e9a4f624827046ceb3c10ac3f3c58417ecef3b591863bcac7c32476cdd3cd2cdb5e555d2b01f03faf393acd0383cb0fa1c10b9b54e0475cefb805923e33951a3db2e9f088aca7f213987be61b0eb2bf5c29051c852fb212e974d22b777be6aeec5fb3214771500d7d237d016f2536d919cd88400cbca4741ebf324a60f3e771502d5afa5098131857a0e525e70f7fe63f763d10d1cf440bf660cdf5e1e3c1ead1e387838b69199c08d85e5b6b16b46e36eccb93bcb0ba5eda214c37e2929ba2d84be1c3e12c8a21f8938eaae380fdf765f7dcd2b6a62ff530c857154b499e1fcb2b11c238288e2d8f991d1a3796830b365f15d3a5facb59611e95990450f2eb144cbe887aa64b4a35b1b4b34fa06e3110eb20a073f5b511d6ebafcaf5efbe8e1976911e8deeecff52a5fb7e13e6e6f25b65a54106dc16a5f6f74cb0076e2a8e4470318b5b4897d44e3b99826caf12d480934bbc48fa159e2809155420146075fc0448d7cafc7552913c37c740451a61e53dbb1b1f96db83d6ebb2bd292a85caa8f87b0bc451ad00836f7c5679ee2721f32d9d6675f78fdc6763caf30bf8c416b215742d309067678d9e1136fdf3619b122a98a331665a32433a05ffacc643e08123db48f502cd0d158f9d6fb69cef57abfb54dc3b2b640bd2380de8f6dc2ab07dea5761fdec047c850bc90a8a30f9dd24697a187b8ed4f27b2487b6d081a20e0e3191822f99373c43da3d0e63f9a9b6e73cb260d9d7d26ca9c71e7221ffd3839cc231b273508cd3b9c4a083283d25695a3ca3bb3d4d8803c1ea7823d39ce4968f63defab1582bcb4d919a72c145957ee730f6318f391c3e2c533dd1cda1fdd04fdd4060d1fa3dac6908d5e21559227df5e252cab7e3b6a552cb1684f75648b844f800efbc7eeafc74f3f6db0ec0f4efeb18608f9d937fc19b19ab453902ead6d77bc6ac582c5945d618a86593c4325c339bc88729919e197007a31b7bee0eb26e3039a18e4bb30ef63f91898dab044a343331ba44243c36375ba60fa563dad573dd02d547251fe03e32594ee2be934356a74331d496819e5ade5e289fa776c64c4bc9506900c64215b8a9bd7b4507ce01c1a7f3c22d94db3f58706e51020b0d6342351bdd25d0bce39829dc408888749d470508f7329e75509187e9a4bec1331e8aee3d8cdc64d6119b80b519ce3cbb920204795aecc6f2f35049a27e22bfbfe7ea9dbe5d6daa1905895650ef614e2e49ba4d4dd2a535dc925f5ea0c9752e39252beaa7371fcb0c282a55b3a887e4522837888c49a312ba94846feb6b0035293f157cff043bef38e24523e82e8927b198405c3fa63086156188248c4e0bfd189f70fcceab093d239ca468f767af3ed2029f716dd192b9746132248a58ddae8eac04111c14d1de57bc0dcde63d40513dcc1a701eb111d25ffc4c18ed73c06f11ce9964f227dbfa5cac49f9bf97868a7b607a015a30f7fa5e9a9ca7be86fa682b6df69c57cc6eb8b8d220968a5cc70f132486cb2a358a58faa3ec7a0478d4c263f1e46254ebd440f59859494d764c088d82087795a91415ba7f0238c73396a541c32b5ef06c53bb9a65bebc12cc5d9e72e1c6aca472db582796a68a0f9e88384e4993373337345130a01597e04641f848a88a135e79284ac750a218e5a1f2a411ece4962534bf293eb32781c0cc42409a411a54cba642122516bd8950241b101314e522cf4c3b6c4c05bc23b846a69bed133e16f3e273dac64ebe86590f4ca5da2a5f843865f241e3fe9c25d39cb633cb86c001df1301c734626eb6074acd8bf0941a6368682ad18a068e2e16b7ba30bb0267be96223503f6b895c262bee6e9ddbcde68683e2c43c9855be68b7dfaba46effaf520f857b694bafb517251dfe72708733b3fcd40c028e3cbf739d7bdf7f2b5424d867baf0796ce670c40ecffaf58e2a083f5ffad703088a60628ad4d124abc076fcf95841f855ea29ad3788f66f7b12ee893bbbd7a68ddb4be61e8f031d36d1003032d2026e9d175a533dbd7378ddde61420e8b6075848bdc4eb6eef7d172e27b02b2bc943488fa5d269ff1f48a1ce8daca470e13e893288c3ce29921d9d68121e4d76c89e2c00fdcb7ccaafc1bbebee5b283a86488204de6113002039ed849af674f865601c8c44387426cecb649ed0c7b22eed4ccb248746c1dae3fb90e887e0a598e7b1a19b41c05afac68e224ffa984d345d73edfc4b1be0a121890dfea183ea3e98b84295bd0c352edd3180643577fe3420e56ff2f288793c230bec2db0884ad2be9e87e280c40da95cdc0346490ccf167cc9d9704334929331aab6dc7b96ce3da28af8ea528fea558bb9355dfefec7c2ba47b4dd07c8368e928df275cb567c658ca51e15fb15d519b1ed9d111cf5ee21218987a106eb6a1590de285f68705e33c31780cc42ffd5dd17a3c3cb6a9b4d19fbb4da240846381071c2e0021a8b7c8f9107a675f1f5f389060130f1b195eb938ef336cdd581a7677e63a3c6a94fdc623c9d197ace9e3606c42f6bedb98ed178246c21063443bf02ffe9f813dc6688920d036041a2a3a63a9956fc254a2c05ae03472537ef3489c93c7c68517c7588094c5e033434ab4b0ecf9e6c032c17911f73adcac6ccfd0ca57c427ae85127e2ad41d98bb94e5f2e6aad2e42ed26f87cb1bec6971c9446517c0966b6402321a06834997f3ab66756377a2f064d0277cf4e2bb914a10eb65e38290ea4c1ba0eca216cc9671e356acb5b7fc8418a863b91dd01afc9bd04f63dbf2563cdd4de9466c0328fcccd931196c004227a0c7bedca4689cf3fd93caef6fb458cb8df565b7e2cce1334af9803be4c5064393ba83483710b42fd5b80858fd2d0b1ed4ceb0c194f887e2a2c0ce84be9adb7067fd7b9c346ce2f8bad9623122e10fcf581654f4010a7f833acb66a467e61436a40ce2492ad1cbf7235463186f64b9357e88ccbfa5775a8d9975f2fb6f3b52fece6561cf88e3b19395d5a57f412ca9e9be727294f0c38b7a355cfdfa330f1a415d93749fed17467688c983c6369d5464ae800104718394d194ece23151c5dc96b813954ab5e0fce8829ca89dbe5b3b2eb52dd29eb61c090c4ea24a315a141c7784724e5081d5478209eb6e5656dae0c068d871c42d015ab2b929806aaa6e4c5c491bfa31bf68b8db85225f907ea0c792301c690544d7fc4d7acf4f4dd148fecd5c8d337eed2fb34d8adde6dcb421623cb16612e2ac147044ea2fe17b5d18a64355528488997ed960917abe8b95e14328534229dcb12b6921ada7f143ac61d546c9e867ff22fa9dbd2f85212d8264ecedac3cf853f2a1297c2be3e9674db90e4000db5843380772abcb89c9430820b1d512b31908fefa33acfb405436cf92a3e7b097cfe54749fab4ebf5116c95b954a72d41064c24bb3a4c8269ac32906348765f9a5965bf268881076393fac97327bc52634a9e02588fc357bc6bfb3ebf6ea4447f6f352e11ce68a431bb8e0202bd9d38a6408f2646b6b9f1b51df1391b88da25a38be402b01f0458fc1286ddcc88b23666a28fff2a4198d6e03ca50dfc298069a329e2eb75fcbc8c3f1385cb550b93d230cb30fb67b2d87dca42972bc5b34f96fae3c236d80a29b457490b4920d8daa2a134e2b9838cf15cdfba38212cd890241723f2735ab9b477f12d77d5a452df1e246a359802229c0a9d1e186c85ebea978485042f727de53d792b6bff741c19ab26f5aa35682600fd8ee8a89c657fb767cf6177d9b3d9447b7bed4835049722e04541b1102a09f8bc21a4790f4006af2b6443bdf0935e5ac865cdad04da467343fbf8daa6dc40cbacf1dc0a53aa030a48cfc65712a57f808ac356fafd69cca34ca7658767d36cf2668be9ccf8080781467e43c3ae4eaf6e691113c27d377c0b60f41257d1b3d1157f3c68417aee968cbb0c66942203806cb9db8e8402c7e734375ea9cc83023fad4dafe1f83ac212850cd689391c787514138f11c02caf90b626437645ea22eb125832b161e6270e12b28926330bf20ffcfca8580769330af9c44f226475ba75fd2581810edb820bbe5270e8026f24b37febb3dbba3706a88787ee1898c41d62b63bf8cb6fa9778dd0534a3947b4650215473df769249f1be7e78cd36343e023e61224eb04ce5bf7013b6184437a576e65b5a335849070b78369b7dd4473974bf54e827a5eb8c3e9b9815363a63f606ae9bd8030ad29001de294fbb0cce1975d7c279df3de0723d871bb8c51e072148a09b56153335ce1b1adefd4d86cfc84bae353d3e213281035b24098d97290d84e5e33a327c78a8a051dd0bfce9552d3e6b349c0cf9e99fda403b6f554ed3a402a4fbee228da505daaeafe390dd6530983748fe106c0eb6085ee952e7eb0ccd09066cd8ad0dc3cf0f56dbebd10c09b99f39f7cb1323a7add6dcb51a0915dd70e333bc629ba5dbed8874e98d871b48b09d9acc6bddc6bf6c8ce3283084744c76d65276f3b3fcf4478d2e623079b52bfdd8814c4636fc5bdb729ac8fa1fb164c52b8c1ff2bebb16c565accd3b7080b889991701c4e66d85e2d02a20e1a4742a462a0841c98589494f5a17b2183424f93a2783724eb4c24469edbab54ed964a8e11aef63dfcd0f96cdb297992e8d4af6f9ccee274a69a3a158127311a7882ae57f45680e9c61f40427b6530be5439ab6afce80a922cdb7a297877dbb55776ee906f19cc96808e19c45ae748fa51dbb414276607f3ca8a7520e94ff3bc16fd7bd6067b21cab897e650fe221aed6e4569f9c0cb73102c21ab6a681211a52370d6873efd38fcdad72676e9983efe06012d9a3d8ac48dae3b9d845950ddf6f99b9f229d027ab363c66aa481dc2da2c5998f54121684b2ed22cbfd419e812825b83646854d5f74ffe013787b405f720978ffe5d3113c265581a733c55dd3bf24612c51ac106fc7ebaec1511a774cf25e1a0f9de4ed435e73d2cfd639111e327220f1d2660e1402c3ace4cd03e39e9a40173f0aec1d32d1c4909643315af9189b7217474798f4dc24450e5aac079cd03bdafeab4d239326c4359b09328ddce80ccf1d3ec5437aba6a11ae789775f04acdefcf0d8c82eca3ff5c6e96a14c321742b2641763802e04219d35a54a91015052c040902edd97ffd25f618a21f8b12cd9a69c7fa6f1876fd732346f39fb788786e6c3d1a8763d80e9c914522925a29f3e2626c603fa0f53e79b4b44da17ae66b6edf9408dff35dda224076d2b55bef4ecbb83890f1c2e36ff12bab4cf681b648f20317b43db297ca7fabb59acfb3eb461c143372cca8caf7a43334d7e8f58076c380cd07e8c80d447a7909622a8da6449f1d66ef1a77313e5a7256d6bdfecd5da9ffbfe72a5c47b1dc527b120c0fa6ae1a7cd8ed215aa1acda901932bec323656b28f33d4996ce7a6de01192be6175ee56d891552b77a1a9ee3685d1336d0df6d3a273f28e9f2905f5c8d5ca88ac9b6a1bda9a107ef6b99d5c0ca39c64231078a71647ec419fe0bc3cb5cfa3b1189e8c302afa05620071f0edb97a7b980eb653b02b7515aabd7c06094d060383cc08bb5f6fb91b21bd520a69e61257195686efb68a07541122844a263882d444f1605e6e51e03c0254e353983a74162d2208b581da0490bdf680f2591f4bfc3dae2fdf267a764f4cedac34425ea7a21d9a +MD = aa3a8e590bd53d04fc0b064006660148bde3ac9c9e44b82db2616538cfd8e175d0855aa9fa4bd60ace4a01d04c8c2baea401e61eaafd966a27d11e037bc56f57 + +Len = 96856 +Msg = 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 +MD = 64fd89d0b09927194001a751b742427940c96104d7bc37489852000bebfed61055d2ac26076d5abb8c34fcee0d0fb3e0cb99ee1c7dc35d3bd35350c9fd1b5b52 + +Len = 97648 +Msg = 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 +MD = b8f33fc394687880f8d658c24c4ef826cc1fa0387545762efdb7a546eef9128307f5ae8ee7b8ba5817b0e492aeca16149953b4557beb72117647968e8f12874e + +Len = 98440 +Msg = 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 +MD = 095cd23a91a9b7991155c63852ea124e6bf16af401ff3845011a428cfafdcfc2dabb8b6cabeb9ed9b7027126fd7d2cbf603268eacfab776c8ae48586fae3c093 + +Len = 99232 +Msg = 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 +MD = 24735a57531628f9491400828455cb7c7756b74dc997b40728961c275d3245128fec89dfc189ba7cde92e849311e662604eec6d8e5e85346b43b1b35e859ec33 + +Len = 100024 +Msg = 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 +MD = c51b6cbae292fa009679f7a0fde52d8eee0f40b6a2f333989a493097ead9ef6e9d95bd20dd54caec38002f428b828526ed5a92863b15524a134f6ed85219236b + +Len = 100816 +Msg = 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 +MD = 2ab21ec8d42db385b3ee428eaf71aa18a9c7e2a66a462125ed710500e71049bc448d6dad35b66edaec37ff39997a052e98dd6ae78c141fcd4a23f4469a57fab0 + +Len = 101608 +Msg = cd36720371f56dace87c59a7fa7eec63aa03de4517bcf09ea4932dda578770fa7fb726449abc5538753cdec795bcffc0d6b61b8b52ecbe1984fbdc1bae33597277a6cee7d97f8b1d3a96d8c3d941810e6c6c916708ec5d614010c4ed9179b6d1fe2cf356f7e615417fb0d1058eb27a37b44cc6420063d55c20f96fb9c9018efe5a711cf8bc98fd8e8cb250f47cbaf222f67f448503fa2ff46cdf65e51f72e9e1d39cd135ef3e4beba8c5def86afff2b77a2d9396d95972106be92cdb5875cf62b3d69b755a7f053f1d110279222981de877c39df4a27a69766404e013fb1496940460020c304357431bd44df6ae1a87f6797c0c61e0cd373a50b53c19bcf5edec4158a9ef375e2712df12c930bcf6e8260a4b0b51cb2028b7073c182337617a9856ac158b279151e59d743fbcd9adbcfbbcc8f130dbe3bc70fa022abd04f7ab2cc6e2cb4c7b8d563fc94108077eaf74fc036e748b9db840fc9b9fda63a0192e2e048531bfcdb2a285f531b8ad369cbe8b60b3fbce8afe74be8e7dbda3935641f0b21bef6178a1c55cb3aed82a7bd5e83e77220d762e26b63b25143af9593fa529321f6abe16cb4d286710dcebc8eb80999941101ee1d183f7020bd8d15c25b64c16f82a4222af987d82103d8da85e26015989aa25608f7c8697bd1dc836b8f3bdd34ea47a26bf45d0b725807c849e372a3a74322604a0fe4e78b0804a5359fc12f97b7fe28d8ab3a668b93c25083c3258ae995e9d58b697c3077e96d43c992dcfec170307e19280830953c7338db8b631485175f7c750b798d68fd8027ce707694da9d446ad573adb2b7dc8149f8421387a452ec1faeffc14686caa318ed41763709c6a4b5b49213341afa544b83f01d2c6dccf984de4d3ea3f8da3fddce0ec4307674b727608f20fde51e5406239d684b090fec74aefbd6ece7b5bd3f18de48c74a2ee5877e71be5741d0e9428152de2c9fa32fb7c51373687ae1830674baea43ad7d969fb941d48856997bc645176616580e2815cd9cfc60dae8fbfa89a992eec6e83235b60649d94b00725b16f2e8535cda41566b9f591c2e528ce200b3280ebef7211220c80792498e36c99ced4d29d28ee141492372e49fa59d8880e094ecbc32ccfe9d90f5fb77c92fd8800f7be1e2b36fa00f302f00556b98b2b239bed0e92299c0d565fb5cfe3bc54f6a605bc2b6d0553965ce78b7772be4293dc58e016d4ef122724f01fc056c61f801e9d516736dfad4f10635532e6ee9b5cb8dedc96f3e3dea1956ef24b5e36999eeb1d2234413c63b5edf4e1aa1bb0f1d0197c16e177be3e17483ad1c362847fbd9c038334f4821355262ab55f99abe2b89edf4398e8c4dcf2bdd242cafc361e6681ff18cbc9773897596344b5d935ea50b976c72fcf9e17ce66c3a9c483d212246d5e376b48524007183d246f62f57542e9b1361894b09af4c39d8b32b1cee7619eaf83b5f9c9c62eb316b8cebf511009b03cf4e5b092c32054be7ba7deb2fab8a671622e46344778ea9e866656ef571fad78a809dbbb1cbbaab4df9692f4e89405327726b628206fff2321c8c20696ef21d2b4075ea0243135ff4b81472b2d8e4b612741e22bfd9e9142ff68795d6c12bdf9ad60b1d8661b771c23fa93bc3601d99bf70232a64b6f218c93c7f55a5304e24bf8a88dca5ef4fe8a1d54e13e9e9940316ada202d766c205e7359be63c8403f582a314afc7b382cd78c42b818c3af0fcff75c43382b102e3712a04d20584f159cb6bd61f5477f9272e526a0d141cda8c620eb044cc5e5aba4e63e1a166fac1588228f7b3b4015bfeadc8303fe957fabc27c18fbd1c37719368285bd9c9ac1afa8f239ef45019515bdc6ea8a073b3f79336d68927dc02f075a6c19a049564a548daa4f4688e898345a38bf7b71bf87a197795c50973887e69f075c5a932e80a494bf32199d71898c4ea68480c47ed2a57d3466ceb4991c4762e8e05510800f005cb574c0f948d39e0994ec128605bb0543030a555c6e56aa4485281837f76ff85401a9e502bb10da299838a92cf0ab319789c99d0524b17fb270a62c7ff11e0d094823ee6064cbd11d04fccd2fbc2dcac91d270e3558c7384b1fdcfa5f0983beeadd854598b26f03527fcaf714b4bd317651a511737702746cf75f1a6bad4b7e875630a2f24064f1786d15af6296c3f62dabc64f360bfdb496ab8ef51c58dfdc5d26d86f238b581bed615f6e9fcefc893daffd3ff38413696680ff22f798ab58dae3cf0292efc2f32fd11aad32b9a17b44c2dc3c328bee134b3c222c63f958649f019715d70a1017ce50d9f3b2036d4cc178c5ec896fd842b3119a6a17d741800804c3115656c9ea37450fca9428aa7e42565cc95ebc7c684cc5ca7459cf014ba461d57d97527afaf9424eaa5f96036035dff35b290e44f466ad24c3c05d1227f29d40b310898dba92ccf91b8ad7e2c31a7a4c0a8eb1cc879f5c4be0d1fdfe95814b877a68689cb98249a1869c6ad2f76eb9a95fe6637d926547a244051e2124cec12c0bf58c0278464cda841acb5e7db112add3c68fc29546f3ca75d05a144649a2a1105e4059676d3b068c7c85efe67029cc0eb5834610b2e526feda2e528a7064890ff9322c0745b8b818380701923a4386592a0a728537903a3789076661d18b46535cddd4e89e3a51afd3db2e315e046f5b9a71d273538996c84361ca5ceb9b5b92ffb00e8ba54475cbe68ed01479f0d97e8d55e06b8535af19bfe9f8dc3cf95b4768351351194b96f4d67e91ec1c7d674a892316ce5b28f5b444fc6c703439a7d91cf99de958c437a32a46ee08941e9b380466001c23e7fd108915afb96fe0d3d08459f8a4e242da5f68544efa9f68e7ef959b16e5add747c6d2d24d085e7361b644f2de24545be1a207432f429cd0dfa9934ed5bb278b483fd89e9efd7e55c402b54098e81d53ffe38d802970fadad51eb3ddc6fd4f8880f400e740094e2c8d3e8bcfc350abdf87cc6197a7f6580b7ab74dd4553c7433848bd248caac4c5c3fd20eece7fe9e631b9539f6355332d732fbe7cf1af93430c55fc34f895707693e65d544716253732e066d184c07f9c29065083a92a41de4c5f85a4816aa0dc80b526552f9fc69742178819a76953b52157b258336cd7fe3f8de1deefd15ae1d49304594dc5d5f0ab8640de92f7b660a24b6d65571e608a2e0897480a71a86cd5a77ec86a2d5929b35716890e13b185f60a0811dfe8e16a61f72f4c99f39166cd1a1c0b4e825a2aa3af9280e3654a0c63bb0bc3917164862083315166fe1eb502136688c16ae1dbc3b93d2cd9948bdd3287fee53762f0c6b3d426bf373b5542bdbbe5a88b8df4245a9a9ef5b8497ce0ab956ade97628e12611196fdd55240f5453920d373959eedb27d3e44472b24fe150ed7167a1a45527463077508eae7b6e4b69f724327e41e1188a37f4fe38b1dba19cbf5a7311d6e32f1038e97ab506ee05aebebc1eed09fc0e357109818b926e0dfd0e3e8501e4ee4e411b04c3f8503824c8ba8b68f695807b7e25dea73b702d0876d48031f51dad163ba43ed4b8e5f12b5070fe9b5b7312d2ccad00d9c8c97d23a2b8cc145bdfb439784af437a7168d8bce88a2406c3137c6999cfc83a40cf2d209017ea6b6a9780a7f95d167138081b8ab5802d2a94e43a97d6c4e5f5dc912b60265146386197d1bca1b32edbeb262546f659cdca328eb0dd0a162a7766c4122375a39c55a9e47efe031a525e90aa3c19347ccc8ea6f72664bc2d6065e9522b900473b6694a64cf94a7fb4ca2317ba92bf553f21df709e35374714f6a6a22bed05b2a5a1d4d010ca715bce250d583b4a3c44507202daa31d3bb4abe2cf31c130a02315119b9a27c5ed6c7dd1085a9a4aa26bad23e51c4560c172076538b28716782ee6304962f68e27182048948d5c367a51a1c206a3e9b25135b40883b2e220f61cb5787ed8f185a6e57216426ef5703c8cead6d800048473463e2730a166c292a2ff749c5acd4ef56adfa4827e0a9a5173c4dce9cf2a59904a024bb00c898dd628209f3266de4c9afeb59de548e01761bcdc4ebc4fcfa440a7bd008252ded55932b562c18ba8f0f047b04ceb4e2a79e5be9d96b03068e6fce5aac04822bb5b64494a69da47b1feadac4c3bf4fc4e24460f956f75ef8aa43d9a682551eab362bfe24c1edd198da81bb2e605a2e1dfb90b0630136dfba96e8b2c818a30196bad948436ec5a8fa09fd2e21a14658d33aabd591a2d18d349a85e126369734d287ebaa5977cd2f87f385bc05502bd5d0e7bd57e9036f704ffe42ef2aa6d8be49e587accea2ac7028e242eb4233b3aefa4aedbcd5ebb991f10948633b2f0fa7e11ed6d70bb80b73c61c5b46401384ea3bab648ebc2156f70304bfc5c098e4f88479ffb27680913e47eaf95268b746917a514a54066eefaa6e37cf9e23aafeb8193d2ac678c4e7db9594449920e9a2ac9f85c6971a9a2cb318ea9e74cb2d06ef88b381997a4ab452966263a2d16f3f42918f00de626db419eb6557d220e9a3a5b92329b5e2dba1a9349c7ff5e412c75b3ab721b145af30e4ceef203d8aa57ee393d44da2193f56ea5589bf1bbf9adfff814551982b27471da8d2213f712b3fb0001013e6883e7a1de3724c9bcccf31374e80b71c7c9ea2cb6354845f3d418d15e81da30b96a0b548c59f4dfd7279650a89b17cc4a1dce9f6e6be6e2656b0101931442699aa2cb175e358ebca185f23811b20c71900a9c3a61958091a253f71c4c4cdc4162eab13ab25e54e89284a12a3ea15c1a202cdd8e4e4697dc510b8581e8900a40c89e686f3738d9dc20902da78dfd892e70f0fd1b72f3bf2af80e16c306825ef0223a2b054b59a01fd234f2408e2b0617090385628e2148f5ede8456014a83cc8164aa39d6d352a1c3def9985cdce756c6eb100e3ee53d7c5c9067be9915636410b4c5ca81b5fea69ba2c7dd7bb3c39b708a5fa20120fee23100534a01b30ddf377bba0b5e44e5370ed7829c6d518d55f6d3edb9797c9ee963940fa5400ac9647e2152a37466517da3e5f27c3b9c8cafe13082fcafdf67b87cb665755e04df1b6e0e553bcb04889fe234df26ec7e0acfb708e513aa339f7804cd1b636488962d8eaa8b7a6c07d3c6532c114188de4ddd03c3dfa5725e8f508141fa16597d38c2665ebb095e557a1a7f364f7618a39e024ac8385a104a7f697d79ca3745cd0b017f90af8fa9d8c5c2edb8636da2b745651681b8dc8bddb6ea7fdf536d315f581360aa2db55676fce7251c13cd31018a30ee5526d0eb017efc10da5c61241b66209112fe236c1966b0b0c8283eca69b5885bac4ce1399d1dc7b7d2afba26e97f4f9b32ea80f3a84c4615266a6a77d70d97e4eff0b57c98dc72fc2f12213fb1e9c80570b874f40bf6d0dc9ca0f63f33db851184dbf4bcdc0326675a4e3e785bedb4573632a9752aac778e94948d2b65677a6ad4d5470150da0a81b92bb8d8cfd33b1aeb1ec481edb663b2750cd54156f99d7847a65654dca947d1b5703867f6e384d5f645701d3c5bbbd0a7d1768becd916c24615c8bc68b704dfb7e7652eb665b810c16f5353ffe5a87092ab1911104f0ed037eb4542dc4d6a342556e834f8a0fe54b363152a1e9a511b9e6166daaba2ad2b83f077ed20b3a15768866882a5dd7f2734eb5fab81c3df5833bd04eea31b1a5a93ec03c51d31d0d0e93f8e1ea3646214accdd9dc10a779b0b9859c55e2027ee5cea794d2b90f1f280f480212dc7dd0a083d22ac7b49048aa9882d5174e9f00559be8d01ddd94b7e6416b6b663670f15522c2fa7453c473ce387c583dd139c93164795fad7209c092e96e71209b84ecbaef65f3e9d68c23a4013bcccf521900019020ea8a5eb661b56e1abd4af202ea575383bb30263080b55c86dad3b888ce4e87a619bd8be3c3d63837f7eb233212b5b7e3fa5129f8b188af262a53edcc5b9eb0d3934ddfd80e7daf8dc70c155c8d5b814e5952c92cdfa563e46356d82dce7c756e014244dc69323be3d3b4b2c882d11b8c7f3ded133195e1862de561f54f6d3d410aa5a139fc7e4403c6ebe1be1aa0eb6516197df6d0df90d43207706a08fb7112577ddd35f0e832b346b98a857d4f5ba1c3ef601de30bd79817c4edd61ead77aa8fd2e2196df96dbcfb279566d266d10730c680d093a220988724c07fbc0bb8d15bac972d9a375de68f3ceba9416eb76005a6c457082bd29d2830d2ae089e9c4e6314e4b8a02c6af8a7017296f4ee7474e99814f9692e546fa2ef09aa2aed8ceb4e11b104a760fdbcee7c1374106e700b85a25800de3310d69e6a4ebd4b81ee6ec5ace657d65a7cf809b7b78dc07613ed81cf78b291c36d9ac4a78a2d93e02ba06fec6cfa55a25175a3ba44272a8fc5e184245d58a765d382bbb0a3432994ac49f5d929354dc0e2fb628ba48b7640eeb136abed394ba2aa582c8d83473625d831fe7b064fe63c9952ee34bd01cd12f623416b119fa3015be2be441081e119161f33dbeb92479fdd41f0bd79d0578c45004a6cb2d0d70a4ce91adf343853fad0dd3b00c14499711591102cbe423b36430ffcb7b6151045e634e765d5b6b34f6d31c0f26eae0338ab0af58b769da298591afc5307b6763b918dcedfdd412aa155e467badc18ae7e067448e1882ab33bede7f5488bfb3073b6ba77543322e077efbeda5ff1c9c1ca8e97b037dc3197a669408d9f2c2c6775bb8489ccbfa1fc59a586c1e9970b65a5ab3bd6945afa756133eb6c5fd09042ca0ab3ad506905a7cfde06c361b524c296c5276100eacc76f5b5b03b906170eaf9090f8ae619980862030489ce335dff254424fa8474f1c2e95559a23ac614868a225fc999b7a048997a49bb38f8fe45da90fa4926e0af80c57dac4866e7c43f06bc6d116e2b668efdac9d00a7ee4fbb3e1171f5f0164fd8129473d61cacc83df43eff0b6f5d32031501c70024fc988ad83050a7eafe18f3560274f362fd67a7dc12de5ea3364cce69e29164b60a20d9305361061b8154f91c2e784842c2eba5469fd2b3129cfb1981b5c1d4660130d1cfe46abb8b854912e982467dc3e39a61bb4da3b2c5788809e6e320f73bc7109a3c49346d42f341644765a839ed48bd00c2841802c3b33bc81fd576763d45085bffec87c549b4821abd3f6424c9da9bade4acfa4c14335c7eb4f28bf87463603ca1332b6ba7ae545ad47943e75e7f7e8ea82d1137c1e233522da12626e90a5f66a988e70664cb014c12790d2ab520accb9670256cd1a7086d134c11a8a3204e019f52843e89f2d01a02a88a94d4a66e8d36dbfe924c6922f7ee5a1225aa8e75340cf8cbbd1c0b08e9296e81cec5f70cfc11d763523b12ca174433f246073d1c2877e4812828fdf2e41134bc8090fdce3faecd1e54a58948f59f3f78b2c1148b05687d712ab2b2d630416001513b9efc7f9523f53f92b6e4ba86e56e11e0fa09f2672b6269c411fcf8415c19e9d0c4dde34f43b1bc0a81e68e82909a0d6dd9e017fd561b8d6502ab629a8eccf15656ba9463931a7216d295981aa5c64c6e98569db166653f9e6d2c96d360e111d63cdbb9597df70abd913a01d68db876ee1fb4ac0cc30827763ac8bd743922f0575e887bba67122b08a61df03eb03934f256426b95d6ccecf552c4ff05805537e1a409020dbb317efdf9868edb76102e84254703d4057936239b6b830f9f438d7cf6a575dae01daaa773bd033448070bab740d9c51b9d6af09fe04721afdb49b313ca6fcaa3e9e580bfa0976d18ce473702bda5c955bacfdae63d6f3ac027009075e52c1033d7b303377b40f3bac7010d932f76e2751c3c81ab32a2f4f163e7e0744f2e970457ed926d304f8f90e7387f171acf88f05e3b956d4484e8aa1e7a238d6cd9f76be6dfcecf44256931cb583bdd0402356ddd47769b07877e50b341ea2fd2d099f1011408ec4b554923cfdaa4738fd1603435dab5b2e02d2e9bcea9a4d9f584f72a3324e132aa7177dd814a4968f29fa1e9e48fd35352d881d1dd4bd42a5979a77e098cd830d5ecadc57c31ab2bf0df62f565b14feaf43c10a94b93088f83212372d0a66e65723933821d0b4a4aef133bfd35f99be838aa4368a609b277e71de39f351c145ef3e9a179e031973461cd8557c1b337d994b5a2b6892a428219c27059b3585a7bdf708043626f2276dd80e7abb598b44d9cd0a719417f692c8fa14248b7e5b15a996058451ffe6c90d6bfdb5f7df491a2b5add8e78b7376d5bd4ce1d2df4ea969b62b82157589e5f0d1ecc8e997614087738fb0c7a3a10c1c1727c78e85fdb327ba44a62b0f7c1f45539a48d07e69415a5b08b7304672897e41c47be2386d5f131a5e3cfc4a4f88dcd04ac3baaf772499d0ab6497d0728f6ab1a5776483281dca5aaa9f1fb29eb345dc70d1fea7156ac478ea3184de2b7e7feb3d328be2b86fac0fec74fbe4d41f0edc9eec2301be7478b847b67dbc07e71c531e35ded398e5468e8637273d7a3ca655378aae2bece21523365bf9169249ce8dab19b3d243ef086afa6e08490b8c8adadd2616a22b34282e48aa7d6a4527050f7626d16b340d8039cb723574029f5ad1f266f2e0f3cb305df11a7123bb0f6e3cf2158e0b03c14c5f7bec356af9d564ef1995a984d147bc16c2347aef4e5358aac14e603e1d9aab608e546e7a4bdf5766a55ac0ea3e1a2a0d3e81010989a352ed4639ee70ec0a4bd16523674e831d90ed382ecfadb4c31895b8789a1ef76ffb5903708f4019909c16b2d1a6444a00aff7447a3c3bbfc2f634d293bc9c0229a0928b8ad93810be2ac4d9f7b1f7db2912f95cd58d10c9aa418f1f5acf1d5450e10e40d142a55be366505d0e00d5e1075887e3c938c95cd998f8f14667ff48864b40c5fc623465b0dd4dae7d196ae62bef177bbdd5c203e14b06fadf1dde693a3dbe7d549e41c8a70e1160cd622344f7451c772bca973942063d9e9d371720dd36fbe9827d79ff26574ff697819b980a092b78abadb5878c29014f096a5629ffd57d9cfe762963cf775df233ee3059d4a9b8f2b5f5a9492041f69e9c1e07df0287b80a312efcb0f2bccfc65b1e8e04d7854977c328ef289edf820fcdd898aa95cc3fb3c2fe504140b619f555790123834a516a6bbe0390685048153710a5271a11791c1c6ac0af39e1c0f1bbb446207857656d082b630b0d529d31305ca9df1005f8c5a60aca553ece696e0626a9a6274af9d231079a130e4506067223132d080833231844c9cdcfea57accd66c80f0073834c7ec92522dbb626e754fa7dbb72a6bcc6bbaf7b937db4304069eb0dd5a48f963e39e670b506045466514945e4e0400a1338a12c20c8ba67cb742a078473fdb71a0af629641dde33060f960843c1928fbaf7d06800217b82a064aa21b60f3c4a825a6eabaa73a22738e8773152a6ecc20071a3bbbc2865f551c3f208c4d6c9d4e9b0b663e2a7dec59164536d9bf0dd55964e9193bf4e0854720a98194b5b24fac296740eb73b0282820bb0f98a4fd29eeee7309c73f2e11463b0e2dfb41cec10af840df892adabe29d67267198046b227cc3f71294b77eb9b95f88c8998c7dab02f21abe0f70495a45ef1a725fcf1564c27d6ba27c1c3fb8e55ee060662a584e5f78f0cb7803597e1e0c03584c004ffa426be4d8a491a2966a47903394970a6f278146ad77075ab2785687bfe738a9478f28190198a855d6da920ebebf331271fd9372d096dccb9c07470df5abd88fd10b2a6ed9e2d0b7fe98d6b26e408f0f1b44381bd131f43aaf2d660cb62480822b48fb6cbdfd9b5772377e21cec31b3ebf9dd7883bd30e16406d3c1a6dcb911ebacb13892a6378a2d63900e35cb1684fd36d0a6e5d145afd044921ad891bbac403f3fb4a9b9ef9289f1ff76da485e6a0fb243934c1509b3d6f33cf3c949f4e009b761b37ae0a8d57414eda2712db16e09b65fc5215321f75f5cf8d4e1cc0cb52e5a41bc6ce50a5cd415821b6440b996d38a4bc6ca51388351c8ef4688e1ac3397710457e78fbf2e933ce568194a1bec5676301eb1d8f45d967d49d026527c632c43d50c53a56c5397d13f11fa12827878c236533caffd8f14c42dfb23e5234cd61ada6419f0bcd4ca1cb79f6d62944122b584efd5a0fc21b5e4c34ee7634af67b3c3be69f3854b812657699dc00f94f3d98437ae37199195f273451da93986a04f2211b4e44df0759f3a487aeb55aaaafb39a7aceeb7b81fcd3a88c643fb6af5a84b4898ede03c9860f68f14b495f5b624eb279fdd64b6073314688ee2d4bcd633a1bbac8cc68078101ea601b84af693cb1b3fedafab0bfac8937ccde2600cd095c7f3662d7b7c93211535c862ef3dc2724c492cc1e53a58f23a3e09ef27db633310783c6c798158187cb6bf40ed2bc0aee0dbc3b0cdb1a0446b14d94596990c902dc2b5a64b2f556aa7917cdedf512cc58b7048f8af127f33b899a2a236c64b21725b68876ae7099c386e7799303e557aaeaf231613dd2444b544fc7172f39d8b80baab7c4338e321a196360c8a53e922ccd0f87596625dfbb3af5d2ff5a17222db6914e17ea5809f75b14ea548324652589e2fa391528acd66213b5a1950678bd4df2b7377bd506a2748180fe449fb8df45f3f3cbf1e294e3f531d7c5860fc2b2f85659ec8d0e12628b33888f91b773a02acbd8d5a35b7d291ad7a035d839e852e1449cfec8091381c8b06cd011757fb160f11220d29b51f1fa8e78b8318dd3e62d44e834d6d0f345548292866de0c25a0eed0a7427abf683bcddc7153a1169b507dea5575c6b98f75730647c4c0125e25d4827984a9256278a4df5159acf9309959b3b2f05e0ecdef843487957de90937489d056e258572589656a80f9cf3a28ff0213847639d5446042a8443681ecb37c386f749706e3c4e3ad8f1e0118445b6e9c931e5a7e3d6fb7b5eba690f21f8b9cde6bbb13a2e14ec0adcab658b19bea0aef24c557b50ba8242579670d371363fd022cf3fb37380947ee8412a6a5251dfa852f4015e82737cf19ba4f565aae83c62c1ae4facad23ea1f726f894f9cc3c67e61a583d1e7864e11916251363da3220e49d55b6659634f5501631c9b7768e78984ed57760e87782adf5b3eb587eb933b31d10d70f6c356c82be85eee70d5c5625347f6ab55eb7d95ebfbf87438260262002db06d13c872e1485bbab8f78ee2815331dbf25c36e0fb3dc128f2bcd6f21b4b47febb2ee73628ed29da7b99f8c17eeb2791eb8fde24b35b474aa19492e4ef59bc42dba6b4131790ff18b6c6a7e4b3a1b592d77f55bb66aafad8014dde5d36d1f7174f19939c25ba380feb1c10beb80d5869769932378dc3684ba2471dbd8a4a9506a6061a33ebff612a98f8c7d1f4948c80296c081b813afc20051ee5986219f27b50eabc6cc2a706f340eb31a111cdce6170762bc9e96842ff9a43aa7046c6bbffd0360eb9526795e46361e2be681f9aa7dc3621d54ed1b934e243e0d7b0d73e0eb48665ac03a79a88710b6f7c90007dadcd2a9ecffa0deb6a7dae2d3138c215126e4a75b76efd815a1a361c8e0226e3fde3d1e71ca373360aacc0f40f372dcdc57df0a36dfcbfe6d39f708e4536e96a1290ba8f3db3b84580204ab9d44470b472642763222585378fa1594944b6de8c8654431bc5a343867558a9f322d91185b3a14d598681e40fe8904eb20f0a5ca7b3bf1a01270a8b7554c64d447d7da6ae03c5d0eb0d8a42bc691ccf7d069a0a5845219dd3e452169ea8e9c31246aa9699ed32509c29b727d99b8769eecdfe6e2a954c4cf870026b6edc43a9d110d877d5da875ae16d8109f3fa609cabb79fde7b3e6fa6037c940062895440255e8fb0ee46354e5f4b807f780048d6286606f1e69b2c47795caf5c161aac44739248d84fcabcb96a363ddef247a0b4e95bbc4ed956029fce828d04f61aac15405e9c5476d28e1a96c001deef2af897630b382befd9832d8790e5618f03e4411015e2cbfff839e0697b74c5bb34c12c29f7033f86a01e6f190a21185d50e546674ac495579640a956cb2f4a02ff8ab1a29195e03a5434d30740c88fcdac1f93ba8faa46fa5722e3f32169c242e5c5e6618d68c4773076f7d6f7543e6c5ff3b78e371c677495611ea330ecd4f7820328eb2d1442c9ff555c1c705cbac5f7223056e3936d32eb8bb7fb5bf0e89d4eb307a402f0e1aefb406e2c5e3a7b470c0b8ca91797ced1c3e35e70154e73a0c655e12091b72792ded8acab1385f68c09103af935a212bdb9386085ff3e0cae637c63f57bbf9b11f47ea5fd32b7c2f168e0a9dbe03acf7325db6cc16c582a22b0970e770372a2a8e6b2d8b72e585703c5ed77a589ca5b8ea45ce1a70f15428a38262f39db88e4c41005b35d88d0295f8aa7230aa4f95d5cbf2d5d9b39fdfc5154ba64c2666ab8002af7d454b4c7b05131ae1a5fc4203b89d0dd3f328f9a9e14a0c44d853680c2c972099a2144a792855552ec3969d77c8283dd14f17243ce50b6c42816ce736bac9faba367bae836685046170bf89796d342bd5d5c84b20371e13aa2eb80ab39060e5e5e8c7a122276dce8096c02e920f887eea6d8294db414baa84c780fa0918248b24a0424addd3d35c951ce1b34916eddf15ff8f27f76a5cd9d6330cdec3b8dd917e4632d23cd28055a7ea6a4027eb2bf66073352dfc191747aa5ca4df66da52a2fcc3e060c78c3c62bfe8a3ffb3f40a6ad2b1bdce70b8469d072990257ce54c64a4fd941d076ace2be4fed416759a52e473a26f31ddaeaf82f68217d78d41937f80dd963083d200571e1444adf545ca0b4c2c927fca631b9f7d4f831d1f55ef9c984b2dc2c32d988f75123cedbc5e3b88643870dfc03f519ca7781a20bc8b2863f230a2fb50e45f7af2e004fd514b6d02c4af4f7a46aa1b2079e62508eb4a057b98723d02b15d1dc19c66e4063c76282272777878e40c3fd3fd7febfd35fb4f8d92fb46006e029a0b7c8d243006453490787a330022cd865e3a2cb6262004ce40e6b1051c103a9d01983b0ba2362258f3de9ec73a8955b86938d6ccab36ce4a3d9e7ec27f1e6cf04bfa59e28554745df3aacd7e4fa00c9d9b006376b5ffc18b2bc249c45020025990aad0f100e8a30c39e6ee9e67ef5bfc9d99bdfc6c024558b358fa54b89f63a178ae86803c7b172b6d99e970a9ffa89f160bcaa6f7c7c37b7d6a78badf22f790ad1065d76194378237cca63c3e575c4caf5f74bc7ed6a1ba30ffad3eec3126edd4d8543e96bc6ddb3d860c4a4e80e0cc109ca1852bb849de7420802808545882980c3afc037a21fc2acf05e100009be7e0ca3b4a24f421aff3d4d9bf5a14f5159eb6015ad156b9aea4af794a7c61f464c8f22953911293f45223a04c0bf8656f91dd90a028d89eb9532f4eceeb2a550d6f1a53e89b9a06773c15bd1742891058178acf162f8938e5e1566db375e425a87e4da1516a15e2fe57b31968284d5f97d8c4a6030ff0effaf32dbe414116cbfe9c90fbd5250b8e524b049a87e5ceb8f67e93fdb1ef962cbf34ba29c27848b1d772ed49bef402743bc11029bba094843baeffbc66f80155fd4907977c41033efba76b73520084fb8061e0af4e81252c2f1211cb6b52bbd47cdd1ceeb8c5cdda31e41261da71188bebd27b1286b10b169a52d01208244c0f0496ff18be2b31ed42d1ebfc9d6f478c42bde93cac58ceac4416457a84963a705d1cbafbd69cb4dff715fd2ae52197664ec93313079df455f40576e929d20f5d4e1855814840e019165951d4f8af9282d79f6081e1a9077874c76d483dfd5240a132d6915b3e3c016744ede31f42c046a5e6786d80a48f7f8a05328009428c801c11471259bf5000b47fdb3da202a81b7f4784be2db512d1ff67cb77d5c74485885eafee88eaa57fc3b123ccc916d26a2e6a8b5e30041ad69a944217e9b402b7acc0170c31e8c2e45d83cb76dca6c6997bf69534d1ba2ef625359f478c324f7e52e086549be02f984a9ddd2522dc0d122b94ab2858ffd79966f1e8ee0769b142406504ae10fb750452a660c0e4de2e3b09ebd3220cfa9b27277127f6a280b26b3ff89a02d6611b8f3d475d2f6ad4b17edca4170a37d405082e5c6346a59fda6117414e383639a9a0d227db5afce71f426b667fc81fb49aa4435ba5c658f0b08c90e72a3878aba8a1daefe229e23efeee7fda12450cc3e4643016f45e0398bc55729336eae4e19ff91e467b846303d9ece0a7d86748296aaebc3458f6edc2862284ec7937c200161063d5ac53c95b35a35676d9171a0db4ebae5ed9765f94975c8f9bfb055933954e74437f7e5a709c7ba9ef1e3ec9974b84cf3b80c6a136766c5b47c43ef2a0a51b1839fced5f6a95dca0b9aec29ef1b6dfe77454cffbd1abb8b099ddc8d56fcddf165f2a881f71a92e057d918de1407d66beb05d77b58dbfaa56394d8d4ac99602375c1138e4ab5ed99ee2d085daaf29801b98a4a7169139a914ce1c7399d687ec43d9b9e3f4433f4534917294d0634194c7d330486706a11cb400526409bd2805027d2b72985fd1db8e317fa10d874d0c8b0a0a40f113806dfc79f847e3a701b63bf16ece18289e01766b0093d741d54f2de53879f9e15c03b5de160370bb9b65b8dc8addbcc52d20b2e7fc5477b962c5750bc4d9ca98c046a7dab282f5227d7c3fe78889cc5e06a10b4c7bcb35197bd62d25b54aab5f319e9913d6abbd032f6199ba6fb98f1db2ea494385e05886a9ea1bda14b3e35e3973543189660f873a7e8efc47554e28b8653473237b2a2a736909d3e8fbbbbe5f2da1ddd49b32d52539e555184451a7a07993855c84f12d61bbbdb8390c7ba72b3446bfbd326f1778fc686feb70e0c3f38d302039e3f6b7fb48ff3010cd6b4026f10b7e4f140e72bc2eddefc7c043a3370bd1edc08181eeca7999e37426d2b2d7cabac28f27571078360d80b51cc171f75a3f93fb44d9fd55b4517a6dfffa24c728193587549119347ec0c8bc6ca452b8e242bbf215480a2462f19d034029bf7c74f27d3e8406b5786dbd6fe4983270040ba10dacdd143ec0ec3ff33fd2a8ab80140b42bc9dfc0acd6bce1e3589b4f3623d2630318286c0b0b80425289bbf0f5b722c2d0a88bc43bae0b97db82571035be097cd89eee6b97c3007dac684b51393f41fe52f2e8e86c83447337455b3c6765cbd8bbd077c50adbb12bb2275d4e1b204ab133376b9fb7dd040e97102c0673b196013d3b78faecac0eb704357629e4009975f1f4787cc641a6c46b812e20c3280480cd6e469fa5ba95ba03210a875c36bac70fa8b3e1e027b93f3506f5edee4f73c1fcb78505de9dd2af3f58aee8cc591b2efcc29271ce15c7c9741ff7f04d8e706f4bc5a8dfffbc4201396ab7c0bcde571839d098aeb8823f0db94ac8ca696b96c32b072680719c605a51c5d991b64ceb0d57613afb67f3ab767505ccceea7d33782b0a8289dcb4ba05490878ee410b4398d5e2fdda34f0799e27df98802929f2f8bc3e417eb9abbbac5f911a48d5cffd2525e455eda7ff45ef4246a090adf831bf6f10e7b160d7e1ba35fe2203ecd1844cc7d3d78849767cd464c97942f17e9c46a420e9d49adfc8b94cbe44d21ed6556a4c3ff74c91fcaaf80fd687498c138f390bfccc5aa009ed24043fe725b434fd28238739ad0a084cc4a3fc5ef6f65d86e106f313b6190cab751d218d617573f7e0de58231c2a2fdec4a1b964fd98b31fd915b234697e5e9046c7d1bc27bb29b24eed11283c6ab9dd72b98c3da00bcab6abb898b2f7485647f3b4eed7eafdbcc8acd040cd60545cc5493bf34d90c7fae7c3703523f1ffaa1f1664c7752dc5a3b7950875973a7f7f22d2b97d293255da2faadd15ebbc1cc0a21957fa1862ab84fb82261dfa2d34977289a28835271ddefadc4f999ee818106d96ff05461c07c6f11e99a88aab1c4c30e887a305c1b87fd5d2585ea1f88a3fcdf9ca6762cc72e054a4e3b3bd56aef3ea69f96c2fb49e334d1787c3895fdba56fcc5a9f0306657782cf84be069265351ba84831f74247afdd364e76d99094c7bf89202abb2c67e307f90d25eaf0c766210e2493112d3d3be2991cd7073d4e3d39baab88efd0e2b950bbdd99fef45e2db725ff1de1c7e76e09ca836296b8506c6adb6d3805867e60f9728668a71f81f22a6a38110d94fecccf4512b80c9453ebcf55d5c6b0af93806ed7884077c4eb3a1745704ae926cbce9f933b25dd43b111d3c485a365ceba8e2d35638fe596f28bea6237fa090fd6e9e73f7d6a8d59009514a1ed5c99666bf0b126a8c57518206e302aefcce182b8b5529449c49146baec0e788d60c009103e9725b87faaab0d37752a18220751d9a75e4c30e28d9f587d3db2e63e7e195fee4bad231d0ac2019e25ca31a7eedfd23666c1c332e6c551cf0edb7874283993865b47693bfa1fb5f8be95dcbd0caf0ae8f89f6134114b4f581e7cc47052cc638d226f0b4b0cf682edcc0779dfe5220c45a03f9b74a1b3a9bec8f14ad1825448695d9e79d8c7f900d3cab9898f0ceb5ec2ea1ce2632c70e959bae38c063b63aaa1495045439fa9a84137068c58e85d7af732c1d68df61596bf40bdf88ce26d02cb921efe3a185af1bcad8912bc1c1ac94926d8d863b3042a66170b20e42bf3095eb474f51aa6bf75bc7abb8d26fc85f23f129c7872d7ef2cd48a35859a5c77f6d11cdcca73ef299cb73b188c381e416e4f92b73739c919168136d7a71e187e83a957c0fec4464bef436b1a605e05af960123a385372b346ff2996c05fdc479186de1cc028a4078d5c7975bda07275321ea51dbe2e9629391bf2e6d12a804fa2d85475876446242f8da2c3739d217ce6a6189dae0cf03e9343d62556dab3e644b95f4e0aa71202cb0f1b647003d4b64081d582b0f568397c003d1af6785f559eb06771f4f9f0eb8a684a205dda736c653642946bf2e6611bd98f8e5a0b6be5da45d4a4eb62c825942299bee22be5e7804dc99a880a5200995634492a9bbfdb1d000eb097eb82f910c46f08a6fd146cb74fd15eae46945c1dff95130d314382926a7d5da29b06af26d733c45258e74632c3c1a686ac94bdd05d18b4abd3df215e0a8a72b17b3c8f00e24fbb8d4446bb1a31033bb8473b6ddaf726f3ad8c7bffac689bb96f910ce1c36d2ab500ca19159721fee5eb1c6fb362552899bb61ff65a20d1af881e75fec9a012c7a53f1489ad01c1a6bc73519d69000846e7c5c539b68806df892851bf9ab25bdd12dc2bc93eea9bf97f699221f8d7fa43a99845fe92749fe8148712a501e61458336435b471851552f1d5070d6815aeec5b9e10c9707f1335b4bb572391c3d2c59177e0e00779b44fce763ed43941accd7857c40ec2fff764d4459ddfccd42da18787bbe04330ff5c6f9d97fadec46a537a55ce431c8fb2e20db6352e058f7b88b0041519d7335ce55feba105eb466e0aec089e1aff96ec29cb7ddb82ee5e42c7958d8b1105f9638709c0e879c1203e7047e0c1dabebdf9c8981cef92f9e929fa92848c4a821b99ce17bdeccb02ea4210189ec8270c5d623afe03ffc28a9887ae4179974acde26606e4431c7e231d1f66c8631f745b0dbbfd67d37a9642e4e23f2cdd4a763c166eee09f1060794312ce0f20e46371d477d8c5ffbee82a566d049bf3014716ef00acfe33827fbf8bf011b0fd0cb03d5831d6450fdca1c1486c83a731263b0e937c0492a98f0cfa32f22718c5b1c5f16592221e559abc722dd30add2e4d6b90d3635d62a83fef735fa1790f21db8ad52221221878ff21852d2b0006937dbfe7d73c1e38d99b10723b836d5db993e730b8663ffa2114b9426ffbcdea07bf1f5ac88fb1dae4aa573eee226cc934e0c44c4ee9e18ef7e06af01ccbd851331a7330cee57d107075ad219f06df1c3acb096f0d33719aa36b1dd95b248b03be96a3b210c4eaa4 +MD = 061e0be7fa3c164f342ce81295dbafdcc5fbc47486f2c8240d8f9e30399973c959b57f7cc6ea4b93a5f2d0354717eea8641191539c47f736dcaf46487f7390c0 + +Len = 102400 +Msg = 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 +MD = 26263445024bbdbd0518b331a7ab88e7bdc8d8344a3480d1c19ad0e7c7cb22447cf88e53d2536fd215e25c5158dbc52ef56585f7ab5b771387811a9f9afbdb7f + diff --git a/guest-libs/sha2/tests/test_vectors/SHA512ShortMsg.rsp b/guest-libs/sha2/tests/test_vectors/SHA512ShortMsg.rsp new file mode 100644 index 0000000000..ab5cd2a10d --- /dev/null +++ b/guest-libs/sha2/tests/test_vectors/SHA512ShortMsg.rsp @@ -0,0 +1,523 @@ +# CAVS 11.0 +# "SHA-512 ShortMsg" information +# SHA-512 tests are configured for BYTE oriented implementations +# Generated on Tue Mar 15 08:23:49 2011 + +[L = 64] + +Len = 0 +Msg = 00 +MD = cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e + +Len = 8 +Msg = 21 +MD = 3831a6a6155e509dee59a7f451eb35324d8f8f2df6e3708894740f98fdee23889f4de5adb0c5010dfb555cda77c8ab5dc902094c52de3278f35a75ebc25f093a + +Len = 16 +Msg = 9083 +MD = 55586ebba48768aeb323655ab6f4298fc9f670964fc2e5f2731e34dfa4b0c09e6e1e12e3d7286b3145c61c2047fb1a2a1297f36da64160b31fa4c8c2cddd2fb4 + +Len = 24 +Msg = 0a55db +MD = 7952585e5330cb247d72bae696fc8a6b0f7d0804577e347d99bc1b11e52f384985a428449382306a89261ae143c2f3fb613804ab20b42dc097e5bf4a96ef919b + +Len = 32 +Msg = 23be86d5 +MD = 76d42c8eadea35a69990c63a762f330614a4699977f058adb988f406fb0be8f2ea3dce3a2bbd1d827b70b9b299ae6f9e5058ee97b50bd4922d6d37ddc761f8eb + +Len = 40 +Msg = eb0ca946c1 +MD = d39ecedfe6e705a821aee4f58bfc489c3d9433eb4ac1b03a97e321a2586b40dd0522f40fa5aef36afff591a78c916bfc6d1ca515c4983dd8695b1ec7951d723e + +Len = 48 +Msg = 38667f39277b +MD = 85708b8ff05d974d6af0801c152b95f5fa5c06af9a35230c5bea2752f031f9bd84bd844717b3add308a70dc777f90813c20b47b16385664eefc88449f04f2131 + +Len = 56 +Msg = b39f71aaa8a108 +MD = 258b8efa05b4a06b1e63c7a3f925c5ef11fa03e3d47d631bf4d474983783d8c0b09449009e842fc9fa15de586c67cf8955a17d790b20f41dadf67ee8cdcdfce6 + +Len = 64 +Msg = 6f8d58b7cab1888c +MD = a3941def2803c8dfc08f20c06ba7e9a332ae0c67e47ae57365c243ef40059b11be22c91da6a80c2cff0742a8f4bcd941bdee0b861ec872b215433ce8dcf3c031 + +Len = 72 +Msg = 162b0cf9b3750f9438 +MD = ade217305dc34392aa4b8e57f64f5a3afdd27f1fa969a9a2608353f82b95cfb4ae84598d01575a578a1068a59b34b5045ff6d5299c5cb7ee17180701b2d1d695 + +Len = 80 +Msg = bad7c618f45be207975e +MD = 5886828959d1f82254068be0bd14b6a88f59f534061fb20376a0541052dd3635edf3c6f0ca3d08775e13525df9333a2113c0b2af76515887529910b6c793c8a5 + +Len = 88 +Msg = 6213e10a4420e0d9b77037 +MD = 9982dc2a04dff165567f276fd463efef2b369fa2fbca8cee31ce0de8a79a2eb0b53e437f7d9d1f41c71d725cabb949b513075bad1740c9eefbf6a5c6633400c7 + +Len = 96 +Msg = 6332c3c2a0a625a61df71858 +MD = 9d60375d9858d9f2416fb86fa0a2189ee4213e8710314fd1ebed0fd158b043e6e7c9a76d62c6ba1e1d411a730902309ec676dd491433c6ef66c8f116233d6ce7 + +Len = 104 +Msg = f47be3a2b019d1beededf5b80c +MD = b94292625caa28c7be24a0997eb7328062a76d9b529c0f1d568f850df6d569b5e84df07e9e246be232033ffac3adf2d18f92ab9dacfc0ecf08aff7145f0b833b + +Len = 112 +Msg = b1715f782ff02c6b88937f054116 +MD = ee1a56ee78182ec41d2c3ab33d4c41871d437c5c1ca060ee9e219cb83689b4e5a4174dfdab5d1d1096a31a7c8d3abda75c1b5e6da97e1814901c505b0bc07f25 + +Len = 120 +Msg = 9bcd5262868cd9c8a96c9e82987f03 +MD = 2e07662a001b9755ae922c8e8a95756db5341dc0f2e62ae1cf827038f33ce055f63ad5c00b65391428434ddc01e5535e7fecbf53db66d93099b8e0b7e44e4b25 + +Len = 128 +Msg = cd67bd4054aaa3baa0db178ce232fd5a +MD = 0d8521f8f2f3900332d1a1a55c60ba81d04d28dfe8c504b6328ae787925fe0188f2ba91c3a9f0c1653c4bf0ada356455ea36fd31f8e73e3951cad4ebba8c6e04 + +Len = 136 +Msg = 6ba004fd176791efb381b862e298c67b08 +MD = 112e19144a9c51a223a002b977459920e38afd4ca610bd1c532349e9fa7c0d503215c01ad70e1b2ac5133cf2d10c9e8c1a4c9405f291da2dc45f706761c5e8fe + +Len = 144 +Msg = c6a170936568651020edfe15df8012acda8d +MD = c36c100cdb6c8c45b072f18256d63a66c9843acb4d07de62e0600711d4fbe64c8cf314ec3457c90308147cb7ac7e4d073ba10f0ced78ea724a474b32dae71231 + +Len = 152 +Msg = 61be0c9f5cf62745c7da47c104597194db245c +MD = b379249a3ca5f14c29456710114ba6f6136b34c3fc9f6fb91b59d491af782d6b237eb71aaffdd38079461cf690a46d9a4ddd602d19808ab6235d1d8aa01e8200 + +Len = 160 +Msg = e07056d4f7277bc548099577720a581eec94141d +MD = 59f1856303ff165e2ab5683dddeb6e8ad81f15bb578579b999eb5746680f22cfec6dba741e591ca4d9e53904837701b374be74bbc0847a92179ac2b67496d807 + +Len = 168 +Msg = 67ebda0a3573a9a58751d4169e10c7e8663febb3a8 +MD = 13963f81cfabfca71de4739fd24a10ce3897bba1d716907fc0a28490c192a7fc3ccb8db1f91af7a2d250d6617f0dfd1519d221d618a02e3e3fa9041cf35ed1ea + +Len = 176 +Msg = 63e09db99eb4cd6238677859a567df313c8520d845b4 +MD = 9083e5348b08eb9810b2d15781d8265845410de54fe61750d4b93853690649adc6e72490bc2b7c365e2390573d9414becc0939719e0cb78eca6b2c80c2fda920 + +Len = 184 +Msg = f3e06b4bd79e380a65cb679a98ccd732563cc5ebe892e2 +MD = 6b315f106b07c59eedc5ab1df813b3c0b903060e7217cc010e9070278512a885008dac8b2472a521e77835a7f4deadc1d591aa23b624b69948a99bb60121c54e + +Len = 192 +Msg = 16b17074d3e3d97557f9ed77d920b4b1bff4e845b345a922 +MD = 6884134582a760046433abcbd53db8ff1a89995862f305b887020f6da6c7b903a314721e972bf438483f452a8b09596298a576c903c91df4a414c7bd20fd1d07 + +Len = 200 +Msg = 3edf93251349d22806bed25345fd5c190aac96d6cdb2d758b8 +MD = 299e0daf6605e5b0c30e1ec8bb98e7a3bd7b33b388bdb457452dab509594406c8e7b841e6f4e75c8d6fbd614d5eb9e56c359bfafb4285754787ab72b46dd33f0 + +Len = 208 +Msg = b2d5a14f01e6b778888c562a059ec819ad89992d16a09f7a54b4 +MD = ab2e7d745d8ad393439af2a3fbc9cdc25510d4a04e78b526e12b1c0be3b22966872ebe652e2f46ed5c5acecd2f233a9175dd295ebeb3a0706fc66fa1b137042b + +Len = 216 +Msg = 844b66f12ba0c5f9e92731f571539d1eef332e1549a49dbfa4c6de +MD = c3f9c5781925774783ae9d839772d7513dfcea8c5af8da262c196f9fe80135b2b0c8c6ca0a1604e0a3460247620de20b299f2db7871982d27c2176ae5fa7ad65 + +Len = 224 +Msg = 6b6cc692d39860b1f30203653e25d09c01e6a8043c1a9cb8b249a41e +MD = 2e5263d9a4f21b210e0e161ed39df44102864325788647261a6e70ea4b1ee0abb57b57499bc82158d82336dd53f1ef4464c6a08126e138b2cc0892f765f6af85 + +Len = 232 +Msg = ab1fc9ee845eeb205ec13725daf1fb1f5d50629b14ea9a2235a9350a88 +MD = 72d188a9df5f3b00057bca22c92c0f8228422d974302d22d4b322e7a6c8fc3b2b50ec74c6842781f29f7075c3d4bd065878648846c39bb3e4e2692c0f053f7ed + +Len = 240 +Msg = 594ed82acfc03c0e359cc560b8e4b85f6ee77ee59a70023c2b3d5b3285b2 +MD = 5ef322cb4014ecbb713a13659612a222225984d31c187debc4459ba7901f03dac775400acfe3510b306b79894fb0e8437b412150c9193ee5a2164306ebb78301 + +Len = 248 +Msg = f2c66efbf2a76c5b041860ea576103cd8c6b25e50eca9ff6a2fa88083fe9ac +MD = 7978f93ef7ed02c4a24abecba124d14dd214e1492ff1e168304c0eab89637da0f7a569c43dc4562bdb9404a018b6314fe0eebaccfb25ba76506aa7e9dcd956a7 + +Len = 256 +Msg = 8ccb08d2a1a282aa8cc99902ecaf0f67a9f21cffe28005cb27fcf129e963f99d +MD = 4551def2f9127386eea8d4dae1ea8d8e49b2add0509f27ccbce7d9e950ac7db01d5bca579c271b9f2d806730d88f58252fd0c2587851c3ac8a0e72b4e1dc0da6 + +Len = 264 +Msg = 9f8c49320af9370cd3db20e9b50d3eaa59a6232d7a86fb7d472f124508d7968b05 +MD = 81b002f15c4d48be8517f7ed89df302fb1435c9435efefed58f3eb8ea11910623f1eb9028a66e02121a7f08a7c604226f2324f483e91548dbbd2c441ab704ce5 + +Len = 272 +Msg = 4ab9aa069475e54b25e5688a52dd4acd134169c858105f01a0a1b134c72d4af51f8e +MD = 48ba5a63aba7e7bd8e420475331125a947928c67fdb00f65c4080d9a0b99c0672424e76a1ba6bd76dfe492c730f6f9adccaee7bb11571aadb31f6bb628cfa933 + +Len = 280 +Msg = f0c1d3407de92ef7421e42df5c9ab31d2ec0a750a9522869cbe4cabd66908d5823ec04 +MD = 9e75c5bca2c2af1d7739787f46e1d981c4f98e493d0724b5252c2fbae3c526719f1d27e6ccd0d705240281e8fbf3db75b9b3205c1413436d3b5d140004b8cca1 + +Len = 288 +Msg = ae8c9f8fb41b519b6d943833fe1c32d1c4292fb1ddf1dbe2eb227d9e14d31ed74ebaef12 +MD = 042f9fd0a4ed3d9fec3655ae11011c6f2bc7e457e8812b6d8be2cd45fc6c432a94558c88f22c01439618865e8e49e509c448b342ca914b120344aaf7bcbdca18 + +Len = 296 +Msg = da39fb86237f00303844e61fc6cfe779e42af53349839590bcd2f0e4cbbc279ec0b7e885d1 +MD = ecb43de8c233a731b38e30c5696f8876761b7ea72efe283fd07bedf20029f47c6d2a4427823e100fb087abaf22d7eff42a951c97c3dd05f48a20163fa4367cba + +Len = 304 +Msg = 3e7271d2070ef095394620c4b016576c150f34bea60784613a0f660d7fa5ae56872b88c58398 +MD = 8154d0da634ab2266061acc123acb407650ffe9164a22de3fe29bf05393b2aece92cf4db00ea5b4341c31ddb7de151683c8a71b5a44d5c3175790feac67d18ee + +Len = 312 +Msg = 311fb67f6a0784bb01a2d5a3f3092c407a9d3322319dff9a79f894291c5fac37319fb408402e18 +MD = 1870fe913abb0a4b4f53b6581ae18322cd05328514556607f3f4d7b6a2ac8e9185d94d947d8b9c88e0efa66d89b59f7439c75fdadd1816f7412306ab2b59d664 + +Len = 320 +Msg = 7651ab491b8fa86f969d42977d09df5f8bee3e5899180b52c968b0db057a6f02a886ad617a84915a +MD = f35e50e2e02b8781345f8ceb2198f068ba103476f715cfb487a452882c9f0de0c720b2a088a39d06a8a6b64ce4d6470dfeadc4f65ae06672c057e29f14c4daf9 + +Len = 328 +Msg = dbe5db685ed7cb848c094524c1723519d49dc66ef9fe6d57e6862a6435750bfa0a70f104f5d396e61a +MD = 2fa6e5b2c443a68050f093e7fb713bd6b18f6274c061ed61d79bf0688a61dba1940bcc30998276860943ab038902896d0fbf59b88b07c80de927037097150c40 + +Len = 336 +Msg = 9fa83e96b2a6df23fb372895015678e0b2c9cd18a8542c3eaa2c435a76ae4dc9bd5136d970daff933acf +MD = 3a2c0ec88a3e5347cf0ea9c078838300ef7356f9a6c342063277c106b880a00ed2be205c13064097bd372fde38007bc306561eb4e74bba2bb20bd354aa690ca6 + +Len = 344 +Msg = 8a5a45e398bac1d9b896b5a2b4e3566b91d80ad20c977ea7450ff2efb521d82f65019ee762e0c85c6cc841 +MD = 3c704620f4066d79c1ff67752980f39ef3d9c1023fa5a213a5265376b14a15166ffe069b51df7710d8907fef9406bf375d502ce086ac82aff17229aaa7a5a334 + +Len = 352 +Msg = 49cfffdaf4d031e33b1d28a447450545f6c4293b38d5afbcb9883976c014f080576ec691ac1bff70b742efab +MD = 8bcc4f1ea2b7862ef1591bfa73916665de8faf65439ddf5cc1be43cebfd5f60f205e835a2b186b675b041258c5cff42669316ce25b46a2f4d4218e102f0f5d6f + +Len = 360 +Msg = 2ff845d85efbc4fa5637e9448d950496f19d8d57da99b7bd3df7474822f0a790586736416714e364c6e1fae04e +MD = 236f6f4ed6e858c02d51787e60c578f731f694f8e52b5df4ecd5b04dff14c78e56bad1028d6f626c29d85aeee151a2a2846d3eed5cfafa9854a69fea8af6d04a + +Len = 368 +Msg = cfca05fd893c0f005f5ff796f4da19ba27a1e729956b8b715e67ce4b2d2a382a72ec7814f2f507b1825209a20fcc +MD = d80969284a4565add4dad6ab9b3bdf53446142f84aaf92d4b23dd22ee7241e6c81489ac8b246edcb6df9bd7b23d91a0c517f546feba4ed5790a2be6e165c1709 + +Len = 376 +Msg = cfc425759a9c36bb9f4b32eed7767af6566f68ded0adeae25c7a70ca78ec09774d16c8bc357f6d6f7bd441bf62d942 +MD = b587a785cdf455cc9c544e756c1e306300aa3c59f8725012e68ab4d54020b6d227a164d9f83c905e86f8cebeef708a69f976d6e7b18b9bf78e9b98cc4a5cd1b6 + +Len = 384 +Msg = 097c9db919515242c99d973acb1dc4ed482768f974eb83b465f9f6c82503372006e4490835e2ec8f92301130bfb790b2 +MD = ff5a376f938e73014caef7fe3962944a7230d020b7087869ebe7ec70302721cd06fcdc981c893a425d05e2f99fe198e4db50a088aee2bf1263212110efed422c + +Len = 392 +Msg = 77e73d387e7bc80419ebf5482b61d5255caf819fb59251ff6a384e75f601ea026d83ef950ed0b67518fb99dee0d8aaef1f +MD = c4c89cd882ec945cc888fb9a0127d35e585ecc14a75e4b5b3d8330538d22da28cf6af1ebec96dc247f109cd2aaab9756e6946a3d80db8363a4da3e6ddbb510a1 + +Len = 400 +Msg = 317e5d9ac73ed0633fa18ebebbca7909ec3a5ef790478f9c38cacec44f196d895835b425774483043341381e7af2d383e51a +MD = b10bb04491b9c0c334709b407cda1d503efb6b63ee944f2d366b6855e6e63e5b80115be4be7ff63edecdfb5923792e68123976d79212b3884dec2179d1fcf382 + +Len = 408 +Msg = 209461f20666a346fedf4a530f41a6fa280c43665767be923bc1d80bbcb8c9f8f93ad75782ea2689c8c5d211d2053b993145a0 +MD = 67b7a328d9444056a52ca2f695c5d3f3baafb625a14fb32eee8ff26a40ccb296bec1771a826b55f7ddb6170d4caf7795b612448e66a0f19356fe505927149b47 + +Len = 416 +Msg = 5d61aa45c446f3bf93604b0511313b4e2f306d6b046fbd94797b926746836f2e1dbdc56124060c6ca9c911b1122192d112420827 +MD = d3931bde2bde8271ed18ca0b9148b12f6f16161e637e376fc961f65bc33bcacf2f6addf26a3eaa81b196653cc37e8a739ec5b3df870d8c38c8f28691c22a39bb + +Len = 424 +Msg = 9288c795bb0b86c0419d9c5637dcc37b39bfa18d441e3fbfca75bc0306e5432e8e7b3a5627b5bc7fdc424a77520abdff566e7f2bb8 +MD = e363d0e95d8cd18c384016ebeed6d99c4fa2768e2bd58fca019c5108b9cde1cb46f3f884028a55ce282ec310a10037faa1b16b4a6a669957f0b00f350bbd63d0 + +Len = 432 +Msg = 780427dc164b2f69b8c7d569266f461e2d30c88c4cd6057fb030a6cf636f24e3c0d0db742a7b6193fdaa15eec50dfb4fae6ec7653c91 +MD = 2964b009fb1bf996de12e030b9d6e0608ae8b9dbf2acfb9beb76fc5361cc104ee85c2a46fb7b4cee90848312da302de49afe61c546477e2b25d223d5e3d33560 + +Len = 440 +Msg = ec2a92e47f692b53c1355475c71ceff0b0952a8b3541b2938270247d44e7c5cc04e17236b353da028674eab4047d89ec5dad868cfd91ce +MD = c83aca6147bfcbbc72c377efa8d53654ba0830c5a6a89e1d2a19b713e68fb534640deb833ca512247166dd273b5897e57d526f88eef58f6ff97baee0b4ee5644 + +Len = 448 +Msg = c99e31ad4e23ac68e15e605d0b02437f8147c44f5445a55b68a10905276cce8676481c33e8cd3efe322bb13fe0107bb546ccbec7b8b38d10 +MD = 52992d45a88221d972958e9f2854adaa9a21d2bf7051e1f1019ae78004da50c5b55c144a02afffe539d753949a2b056534f5b4c21f248a05baa52a6c38c7f5dd + +Len = 456 +Msg = 9aa3e8ad92777dfeb121a646ce2e918d1e12b30754bc09470d6da4af6cc9642b012f041ff046569d4fd8d0dccfe448e59feefc908d9ad5af6f +MD = 994d1cda4de40aff4713237cf9f78f7033af83369ac9c64e504091ea2f1caff6c5152d6a0c5608f82886c0093b3d7fbadd49dfd1f9e0f85accf23bc7dad48904 + +Len = 464 +Msg = 5842512c37312511a3d8ae41f5801df60cd682d58b4a997342b6e717e94006c214813e6c63e75591f957a7ec301779838bec8ae3ed7febad0805 +MD = 9763c43331ad0eb279d704c5f6e97e02da8724115026827f889e9fcda21f60fd230894ab35abb719890f3afa51afd31bc6852183b9c51059910af460abd2474d + +Len = 472 +Msg = ca14e2ea2f37c78f78ef280f58707ec549a31a94361073e37701bfe503e4c01ee1f2e123e00e81a188f08fa050825709128a9b66bb8ae6ea47e41d +MD = 4600e022a02258739f67fdd367cc1e662631fb087918768352062b9b3c8de8dbca0e9ec751b91f284694fbddb8d325c0637bccb21dd2efa92e48dbab2e5e9c26 + +Len = 480 +Msg = 647629c779b24c1e76f41744aba17159487532a0156a7d8264db50d645e9595ff81e0c96a850f2aa56c844c613a4b892727a9bfc3d3e20386766f805 +MD = 5bc842fc2d3b7eb31d2d3044df3ec32af114feaa7cfc27ebc8630f46ab6f0c543f59b812e776e5303861d17da3f1f16097641f3b808d4d5cb3e483946409746c + +Len = 488 +Msg = 1c5dc0d1dd2e4c717635ff3e9b67caf957aec0f8f63c1b1e221e800a4c14848f4ea06e644e5d3e1de592ef5a8007fa3f07171b24bd07578d68963e5cb1 +MD = cbf1ea86fa5b3dbf67be82fac41e84cccd0d296c757169b37837d273ccc015eecd102b9ce1cff68fdc7f05d22f2b774734f62ded54c8ee0bf57a5a82010d74f5 + +Len = 496 +Msg = 8a555e75477d065b3af7e615475f37c0a667f73a4c7af5e4a69f28a68d9f4434776a8f90eab7f1d137eb4b22643c0a0d6a16fcfaa1bd62f2783546a9695f +MD = c088e4a3d7da2f6f99a8f3f717361108872b8ffef921b383c24b8061d4e7c27fc56f4f20dc8f952a14043c5650b5a9e777c49c41cfeb3f2de97ee2e16b2c3924 + +Len = 504 +Msg = ebb3e2ad7803508ba46e81e220b1cff33ea8381504110e9f8092ef085afef84db0d436931d085d0e1b06bd218cf571c79338da31a83b4cb1ec6c06d6b98768 +MD = f33428d8fc67aa2cc1adcb2822f37f29cbd72abff68190483e415824f0bcecd447cb4f05a9c47031b9c50e0411c552f31cd04c30cea2bc64bcf825a5f8a66028 + +Len = 512 +Msg = c1ca70ae1279ba0b918157558b4920d6b7fba8a06be515170f202fafd36fb7f79d69fad745dba6150568db1e2b728504113eeac34f527fc82f2200b462ecbf5d +MD = 046e46623912b3932b8d662ab42583423843206301b58bf20ab6d76fd47f1cbbcf421df536ecd7e56db5354e7e0f98822d2129c197f6f0f222b8ec5231f3967d + +Len = 520 +Msg = d3ddddf805b1678a02e39200f6440047acbb062e4a2f046a3ca7f1dd6eb03a18be00cd1eb158706a64af5834c68cf7f105b415194605222c99a2cbf72c50cb14bf +MD = bae7c5d590bf25a493d8f48b8b4638ccb10541c67996e47287b984322009d27d1348f3ef2999f5ee0d38e112cd5a807a57830cdc318a1181e6c4653cdb8cf122 + +Len = 528 +Msg = 8e8ef8aa336b3b98894c3126c71878910618838c00ac8590173c91749972ff3d42a61137029ad74501684f75e1b8d1d74336aa908c44082ae9eb162e901867f54905 +MD = 41672931558a93762522b1d55389ecf1b8c0feb8b88f4587fbd417ca809055b0cb630d8bea133ab7f6cf1f21c6b35e2e25c0d19583258808e6c23e1a75336103 + +Len = 536 +Msg = 52761e1dac0eaea898e0b07cd24f4b2e6bb7bc200ea4b0528842f17b87154559a2ea94459a0e480ae0bdf9f757dd4a335aed0e510138b024a04ed1d591b4323234dbd5 +MD = b826fe80494e19c51b42f2582b2d080ba6b90512f35f2db67dd7fd5ee532eaa16498afba08b4996cbcfdf8d1a2df6b1da939e8265115a48aefa42f38205db436 + +Len = 544 +Msg = 3804ebc43cbea80c2bd7e4fda5c5515500cd2d2b846a1378dbf218d5c377138606eb3cb8ac88f9076f6ff4436f90717427c9df1ba052acbbe4585e98b6e8e0bf800f1946 +MD = 17dd6d87bc6773051e52047fd444996afa8124b0483fe121877f98553448772bd0e7751fc655e9cc2d29830211015d310f191474ca6adc0477a187c03b8fe252 + +Len = 552 +Msg = 2249d698c4d807a8e7b4de21c485738959a0d67e5d2ca6f77983dfccb5dbf47931261e1f1537f3cbca253afb6bf4fe5e7672e1dcc860b3d6c8d243afe2d9758b375e955692 +MD = 6af44563fc468d51182f6c3be58d45932af1d985c6f283976c91a9ff421f383fe21dc7322f397ccead583e26b3e3fda067976a7f34665df25a2ced7b4b09cdec + +Len = 560 +Msg = 32a9c17033658c54f22c7135ddfc879de94d79593ef2dc7d3041bfa872738389864eeda27801794ccc4ff1fcb5ef3fc48833801d6fe959e3627f8ea1536ad00fa9c7d7d9f043 +MD = 6a47699dd3ada2f11bc4ea42072b06cc20857bf164497df1285400c250f5848b6f71957dbdc845f5daeab913036661f69387893fc2d61c25fa59b9d85b19f401 + +Len = 568 +Msg = 3d65f69a590a5baaabcd274fe3ef9e88920ffc7adf05c16d7b0f4d18d72bac1e94c3b3d83b8f4c552eb80e9fde3911403f8b000579816f02e1716fd627946031d0af0793e7f3e1 +MD = ffb2d9450943c24b5933c24812459b75d3d9f380344c9bc06fa3e17ee448eca2f98ff79f7e2235ccd9f9a8176f68a2254bbc9b834d6ac8d2bfdbc1597c432c9f + +Len = 576 +Msg = 76ff8b20a18cf104f6cdb65e2ba8f66ecf844af7e85e8ef2da19e8848a16052ec405a644dafb5ca08ec48f97327ac52c0e56218402c72a9a6dc1cf344d58a716a78d7d7529680bae +MD = f8858144c6d709dd0689a526a548a43f17494950ba2ac20544799e8ea27201d78bce5b921e29a7b4029278e68341ef2a0ca4ba3894566b3c8f8950e3e545a689 + +Len = 584 +Msg = ca88dddfc876a12f45f19562bc9ca250f43267ab251a7f345c3c022e20144e135604078762ef5c8a8f038cf1b1d6a91709b59dd068396a9e971ab628f74886e765384a23607c1a1e6e +MD = 4f3d9eeef349ca51a7e419af1686f42795abde58a85335ce68d496e81e4436a80a61dc143a4300008c23a3e71f4ba98743195a3694a8d02fee11bd314569abc0 + +Len = 592 +Msg = 0a78b16b4026f7ec063db4e7b77c42a298e524e268093c5038853e217dcd65f66428650165fca06a1b4c9cf1537fb5d463630ff3bd71cf32c3538b1fdda3fed5c9f601203319b7e1869a +MD = 6095c3df5b9db7ce524d76123f77421ce888b86a477ae8c6db1d0be8d326d22c852915ab03c0c81a5b7ac71e2c14e74bda17a78d2b10585fa214f6546eb710a0 + +Len = 600 +Msg = 20f10ef9a0e6128675340171cd248df30b586557620b615ca39a00db534315a9012dbdbfd6a994986eb829dbe6cdaf3a37d4f59ac27298742c8f777b6b12677f21eb289129579868705f27 +MD = b4ead3f860eabbd36c770d66c7356f8107acd1485c7c94178c2eaabd50266d7645d009972586ef83ed43ed92882137df5117b88f35231b894ec1741ae7501145 + +Len = 608 +Msg = 995c8f747ea418f7d63aba2260b34ac3c7dceebb78438ca4b1f982b7db9798ec1a7f32622264cb024c0d9e60e955a6e1d677c923518851990a459b767d0f13cd803460f61870db3391b44693 +MD = a00a601edeaca83041dc452d438a8de549594e25d843c2cf60a0e009fb92d87abe28a72690ab657c8d35b43cd02d22ec0755de229d1f922fa6ca18a6d6c2aaae + +Len = 616 +Msg = 0feb23c7e4a19bcbd70bd300d76ec9045d696f8c9687f49ec4154400e231d2f0862495150cf250b6f12f172a7d130f8fa5d175bf2f25e280172ccdfb327951701165302728a619aa2f242631c9 +MD = eeb6dee30c119fb1e1eb5c15ff2b32d8b9c7464a4e4cc6815cd251a6bae29b49961dd5c2fa9c44a9b142ca062c7072cbf3db04299b767789040196bf0c06aa76 + +Len = 624 +Msg = ac59a110623f1a64666f160ed32926676cb5be25dd9d962f441951b0efcb5d6a67ac1a4eae473e49c6257860728853ff415c5e8ec76a8a462ecfd343eeac22dad820722c597332fbfd94ebbd32c6 +MD = f65ea942ae0a47e73b02b1442e5b26083db79307f64dd34a039c476faf18d5c514bb77a2c412a6074a7afc326ea66c74e5705fe2abbabf274333325a15b61fd9 + +Len = 632 +Msg = 9e3e1077e1333a1fb1aa633ccf2f746588ad426489ea08dff5511438b5f4c0b110d1a4d47b540a12b21ea2aa070578ccfa5c22fe0b743ec0cc621c6b3a03b75f4d3eea5dce89e03269afcd9603d0db +MD = 4b5c5df80c344c12388c723856cd06965b2190af652480476747dc2195ea3716f87c1762359583a5f31522f83f7833bec30f1f47d14540417dd463f5d258cd4a + +Len = 640 +Msg = e881e3284c79d8f5237e699e4fbca84090c664bb53229f58cb0842b0436710c9b329d98191b8f030e9c1df89b03858c1569c6ff49a7c07c4a23a8a434b0fde13be4f94cb44ee629d5b44d336090d3de6 +MD = 147d8071c7871ef9256cff32aa63ea031404fa5ee4ec09c56afdd5da919b0cc84a9d35d142c417715203316011cc620cd6855bb117063a5e52867facc680d5f4 + +Len = 648 +Msg = e58521098911503de84311387d375c25929e6e55076eb6934fd8f2b1bb7b9667fbd76d5ee204828769a341b1f716da5bdfece6c62a9f4d4f988267fce1f5615540dbe375324eef607c910d976b45a5ea5f +MD = f97ba056fa41f43b8e1987072a09e828c71c5ff6ad4e37f9ab6b89e2a078933dd23052fa72c6615b613904259e9ff9b55ef7b923b89bc8752f6babddd256e117 + +Len = 656 +Msg = 3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c9f133e5f8527f1b184830e07c3458c83a8ca9f9d9c6998760e610668ba0f22e22b656a737e978b246a17840b7dc4091da85f +MD = c8a466199acbcbc93f2ce042968508c046901631e3118a2d0bf39a9b42b4197a379b3a86cdeca9df2de1a3eb71b79ae9bf2d6575eadf1878029c4093133f54d3 + +Len = 664 +Msg = 9af608d031ccf309d7273c607a8e5e36840d449b55db5b13f03aeb9af49fa7e7cf1383ee2ed9c5a8b7515f16fb1c7c84a681590bf90f56597b844db5ebee223d78109b72350772f7c72ea996603e1e84f2ba5f +MD = f0ded9495b4f64cac585be8a737cfa14247a4a81cdf7f01ebcb134ace71f5a83df2cd72e7773fea1e82beae17e13857372792c8231e2ab9fbeb633e399d5f0ae + +Len = 672 +Msg = d0df1bdf1df6203241722fb9c9c1cf7405017497ae154538ccf9224ad752e6ce1d4ae948639aca70cfe86b2b06543cb9914ebd3085aa3e2963f6e9b93d0b03a31ae26fcb9ca974eee016c091a6fcac37b21cc1d7 +MD = c2da3ea3c8a3fd88a5bc5dea2bc076f861abedefae5a5fbd941ddfd1c41cc3312eb2dc826c2c0f65414fe72ebee447d2f9b1a6a56302660d1f86632ee80a175f + +Len = 680 +Msg = 8cbc9480553acef7bcdba9716ea8d66b4131780917de2b0b048045fcb32b5cac054808e1fce6e94ad851ecb47fe6cb802225d3551e08ea122093d0078dada564212eacf1d6394e0007cc62a1d595ab14ca08a284bc +MD = 63b39b88ceb848188b37316e04560e75a5340ab8d417932d231c997e892b41daa69d9fe3e9a14dd19ccfbbfa01488c208e7b946cfaf16ca2b1bf7c8d8da4e6b2 + +Len = 688 +Msg = 38f184448f3cf82a54cafc556aff336f23f9149e612134b3fc00c8a56455653d88640b12f69062b8432c4335ad8f7ab4ff66cb7eb54f332561a36f024d92c3e26276f4fd48619628cff88e4b8e85cf14ca4767ed990d +MD = 9a49265fc641c59f1a91872cdae490d3da73c0c60fd59648e1d17dba1a647a5b95629392bb4ff5163d1a3cb45427c1437a3b2e1d9f030c0a8bcc5ed22da9e2ed + +Len = 696 +Msg = 70900618b1e9e9db62296fb6c6590c9f10b0a632765c489c887f1ab7c07791765a62e38465e1be281b1d396c6e080b7ee3e6fa56a30b9799d0e629be153ee76f81bc6a3295aa61489bfa87d53a8ad24248a6ede0dfcfe9 +MD = 1c8c3357ff1f8d6ac4defb3af462a73e09159e3a20c6506edd8cd3052df941c81f68c5fbb893912619e28640977fe8eaae8e9d5d4e7d5f132552cefab4540bac + +Len = 704 +Msg = 4e6ddae0d805afcd10a055bce584c848d050fb29fe8f1c64b18e1abfe46b65782e6ff536e89d8d40928b41ed7371365c8080a9647f7532ce6c6d4ac21cfb0c8020783851ec9a7dbc3948f8fca7adf8b2a78c04d898d31ff6 +MD = 5c2f996c779b91b3c4639311f54fabbdde7e2212b53dbae4828c8399588fc00d3b2ae60918aaaf6bb48bc757e52b2bcea84f5d15bf4ec25d5519fb54f6f26e1b + +Len = 712 +Msg = 696825f6d6ea8173ec47d0959a401c4ddf69f8f08ddd678a4d2ff976e3a4372bb39f4159845cb63585e1d4108d32e12fa7c5c9d7ce3508a7f53aca2b4bd951adbcd8984ebb7536563f5884c90bc5023b3316f7e4dc6958f743 +MD = 3ce940ca96b00011375daa95c65f66907d69b3eb3b8d779e6fc971afcc05e990bc4c541f434590f6b18b68c080d0f24475a3e764e9cb85343301314ee2fb661e + +Len = 720 +Msg = 79ecdfd47a29a74220a52819ce4589747f2b30b364d0852cce52f91e4f0f48e61c72fa76b60d3002cae89dfc5519d3430b95c098fa4678516b5e355109ea9b3745aa41d6f8206ee64ae720f8d44653b001057f2eba7f63cd42f9 +MD = ba3d0fe04470f4cf8f08c46d82ae3afd1caea8c13bebbe026b5c1777aa59860af2e3da7751844e0be24072af48bc8a6fd77678aaee04e08f63395f5c8a465763 + +Len = 728 +Msg = 9263fe75e8f6c7d5d642e2ca6a6eea4f44e9a0f249513ed79c9409ffca5526ca4491aebb1382057cc7c36722b0b6c3b15123cde312214f25353abfe30bca170568a8e1ba5408917403a01834080ab607c56a10d0265082498fe0b6 +MD = 7736d7a7fc1eb05857ce7d88abfffa87f58c670bfdfc0a8031f60f379e4b6ad94ac8f13ffe28c697809b5cfac7f13be01e7496a85237c4025539051fb2e32fb6 + +Len = 736 +Msg = 78c17bfe0e02eb526d1a44a1ac127be082181452b625394bd6dc093a2cb432e6ee59c2f8b5503aba30dae41e1a1c6702697c99b2c94e94af48b00caf53b2e0e4e1bbee81ee282c7b2b35f58cf421a07e828d57a6622626af25835399 +MD = b56b6e343166328523e0d1693e5174da643ae83cf69c85a7b3c3bee247b77b84702069d9e6b4cab03bf17fe612009bf4239683ca78ca7e876aca7d07603ba714 + +Len = 744 +Msg = 298bb304a920f960447d8fd38b061bf8fe4ac1f871d8a0feb4549feb72ca694a5a41b6867d94cd5af77d468ad2f315d127b6c41a862800f3985e573e037740298e2c5c6186a9fb83609be2d49f8b4c31f96a2e49b56dbf09571b38587f +MD = 34e3878627904ffbbbd85266cc973c34f931e3cab5d4c31f841c553dd69f84838206067df4f9f3b9102001be19267151e673f5c2d4c2f8438a6999a0a325487d + +Len = 752 +Msg = a3cf714bf112647e727e8cfd46499acd35a640dd393ddd263cd85cf6225f59890a0686dad1c54eb8d809b81c08a98dba131bbdd6fce8ff59d95db824d8831ea480529da739227a6e0f62b603b38c35cdc2581f614a31879b8be54aeefaa0 +MD = 6f230ae4903ddbef0ba384c2e3506eab318bfd1a46ea76099f65a3fd529c91bc2865b9fd943e346de64626b8529f9db1377bf2c5e0129c66b50c6a5cfb364b3a + +Len = 760 +Msg = 0a427ae55ef3a7e6044a08cf6128cbaaabfd776c4e9374708f2ece246fd73603d2f54ac3e01d16cfac2bdaf713920d66e8f0a3d54ee68cff64267d5528cdf2f295f474d10f81173e0143488ac53fc503c444ed23dec63a080ce90c2443dba8 +MD = f6bbe5d0cf13ddf41c1436748a5d1ccae2948547b452c2171c7c8e8b66c6ae4de3c0e8b2962bcb60d3de3608479f80e455c9024d9716c38f6f1206861ab1eaac + +Len = 768 +Msg = 2cbbb87511f4948efec3a61b511ededb1dda8b6ecfc0210c11e43a77ee32dc2e374afae4268e3d30427804868232a966b56006d3214037076bf6a265b72135af0fb2ef7909fea2dea412f7717446b276ff153753662b4d4148c02347e3259169 +MD = 76897b87a8a1cf835c434f6d391c9e5227351af9d3e20a3389c796b98b424281a59068d9c8d567ec2bebc435b0126b059e2d86394a9854d6611e1c922f385496 + +Len = 776 +Msg = 2b23324c9992f60a7fc010159a03cb9a2b290df4fa6a82359b9af602f0a403a5ef33ed5da5b2caf87b77e6a4b93b650348ce2a7dbc08f8da9203d710b587ba5947c65e899f4a759f8e2b049ae7850a8e3e2962f6ef93ea4c631de5d78e729ec5bc +MD = 3beea0b373ed09cf1c919c51d86d642c9125e0ee81698dc4cbadf02e9e6925efb562fd9b87301a6377ca192be79c4118deabc450b54639000c2e312945451fb5 + +Len = 784 +Msg = 4022f930c7033b00d986c65ff6bbbdf9ebd0e58c52844ff658df3893c3202dc533f873d4a7f5a5f944419fb5528c9b6788479a1e891306acae7995fc06db70a59baa95bef7da79f5e793f2db7f2a55825e4fdb4a34884af881ded1089fd5334502a2 +MD = 0358775bbb733ccc49e78f544aeee512370d480d0e13c7e8d5c444c423e592146b45fdb91a1b694d35e36b60e4bc8397fca8bb9790e619339778b9cd1abe3fe9 + +Len = 792 +Msg = 1cb77ba43ce77e236b9fc925f589b1c070780a84f99e8f50c1ff846ac92599cfe91612c8178325bee642a34f4dffdba2aa2ebcf7064339829b26f27993e1106c139c70d578cc05f0e1a777cceddb10a2c67fd9675e4a009df8037d6eeb38f5fba233df +MD = 6502f46551a3fab3a96428fb97801d7a4aa2f17fef6603238df84e17c74309ed3d9489c8b16a9384ee634a3f86d0b3ba9a4dbc9c51ec8bd4bf8d61de6d3d87d7 + +Len = 800 +Msg = 52167de2d6c502d99fa10c27b2ab6203bdebc2cafbbfdef15872a43dd610c2362f796ad9bcb5528d95870058fa454453f1e6065b315d410a3f2650e5d71e69d78d9767dfb4accc057fd2069266b0f180cb319e30ded7535bbe52d24be151de4bb598fc5c +MD = 25cb3ed3983a91b4cf37a65193916c5e3e211b63e943e2f7b50a85d349a463b941aad33eff16561bdfdc92fda06a4e1d94b162de48f06d3c626940b31020925f + +Len = 808 +Msg = cede6697d422ddaa78e2d55ae080b8b9e9356c69bc558201a2d4b0b3190a812c27b34bbcee3a62b781378b1bf636b372bcbae1fa2f816a046a0a649a5c555c641fea4ccd841cc761f38f777972f8c91b0324e71c333ce787f04741439bf087ef5e895011c0 +MD = 0be42a25d77ac6ad995c6be48e783380bad25a61732f87cefb0cce1a769cd69081f494a1a12d657664ef2b4d9c41f2ee83f6e9a84327d8756af9f985595e7d3b + +Len = 816 +Msg = 56d18d3e2e496440d0a5c9e1bcb464faf5bc70a8b562124f5fc9e9deb5fee6544b945e833b8b5d131b773ecb2cdd780cd4e1bb9e4f1e3cb0a1d64d19cf4b30e44e6c2d0cbcb4e284ce50db7a8a8062ddb63f981d9026c532bf8eeddf8af5a43848a32262178c +MD = 982dc61c91a93770582eee8025aa55da8e9edb966bf5cf70d4a6534c0d53a2789a8c4fb65b7fed478cda02ed1e0d198d85c5c735b2417c5fab5d34e969fc8e7e + +Len = 824 +Msg = 25a7320dfaec5af65da4d0f8688e29e8e95532ecc16679ea8aff0f407d898db6922855b0e8901aa9681aa3dca617cb440764cdc7293fbeaf7f585b593c2b0531738e0ade7c8626b9995f4a84d9fc9b593d6bbee01abc53c5be14bf6956fd2fd81000dafc7c7686 +MD = 749c928c3d5510925bfe98659025b0ed7c01acd4d59a9bf1c54863a088091771dc9d407bdbf83b0f44b0902e10349ba79c84d0981d5e8c4f5c733a117fed0790 + +Len = 832 +Msg = 3d7177b28ffd916e7e0634895833ba0bd9e0653df2cc4202c811536a005aec853a505e75db55d3c7107579041099e382a1feac80dde65d72368e909ab85f56d88e68d7c3c80c38f85bf8c2b36959409cc34ba8e3ad94fe8ee1927612d672d92141a329c4dd8a88a9 +MD = 14a331508cd7d94fcce56a66bf65f20870a281c8442f8dbd4c2371454a2b66f8d0994a0b67692e771efc6a5e0b887acae7d6f4ec7338e1aa89f2abc7034c4e4c + +Len = 840 +Msg = c033e4a512297caecdbead892b11a9f7007af9a74bcab89e0bd4ffdd542ca03ea12e17a06c42bd43fc5f3f757fce4f6f5831997abac3f95676e1ebdb11ca43e11aa31e5ebabe18ce8d1bbfd8b02f482e1ce581b532e307e6960eb97441506c2ed299e1282523f41527 +MD = 95ac9b7d22aa458921874c4b4331e7d64761853217c3f83c601abcbccd7e2eaa6ca6ce9a22ebcfe5046d52f8a09097f043ab8bc59243fd770090bb432c3155e9 + +Len = 848 +Msg = 69fff0f1a3dbfb36e32f025819fa99ea9a0edaef73145bf7fcd05d8bb0a646cb3b5d5256d524856acfd2e44d6b72e4ebf1ff23c0ff6c56f821e782d5a15f7052a1445b06668eeb4af700679ee7ae26496fbd4640c06aa149964dfd6011df835ac13b73c8ff21151e8440 +MD = 45d4daa652558d1c12beb0f5662c712f325b4c802fc6eb9ee039c949d002bb786f1a732712be941f9c5c79b3e5c43064d63a38578e5a54ee526acb735b9ad45f + +Len = 856 +Msg = b2c439c97ab7c63736b3796324d68eeb7a471ed142bd9622684167d61234fff82f93f907537a909bc2e75a4bcbc133cf57197662c1af746ae8b81e5b83de05d9b589851de25d3c99c004c1dfb12d93bf50d450af49c428716f5b90ef088e3b6a6b2c46d3ce67b379599018 +MD = c48ec83be5fa669e6ec8db90aca9676cfe2ec0d5e8e7a2431687bb953c0a300be3db4075cca3bac4dfa4d971baf0fa1aff46639db4b238856ff36d1dfcd520f1 + +Len = 864 +Msg = c016f522f26b7470e922b9a287e6d45f6c28813b68c1457e36d9ba266708272f9cbc5411f8db9d8bd5a9449fb6eb0cde7d4d03e5df019f2814a90ceed377c59d7d92623899bcb0268033073559d4d8de488686cbe3d67796e6df6ad4276d0b52cc62c49ebb58d7c95287aa6c +MD = 7402f1a99b47e102b3b73140c6771b07ee6c33b3715e9c4027c441bee40511b735d95e508baea78da26fded9b7038e9a53defa58448aba40dc1e62d7ec592107 + +Len = 872 +Msg = a766b2a7ef916721f4677b67dbc65ef9b4d1bda1ad4e53fc854b0236440822152a111939e5ab2ba207719472b63fd4f4a54f4bde44a205d334a2d72cfe05abf804f41841b86d36920be6b0b529331ac163a985556c84511ec986439f83e1d7311f57d848cfa02df9ea0cf6b99a +MD = ddd60f93a3babc78299cf763e7919d45ac6f479700e1adb05ab137acdf89c1521ecb9dfeacd091e58ca57a1db964a9c3cd1fa39192cc1e9f734caa1c5fa62975 + +Len = 880 +Msg = 10f2be77a4055771a67007cd8630e3230e38288499cb160380290174d66da57455b6baaa9785c84c8a663de41ed3bd544055b9170cec43cb3eb120eceaba1fe36e3eaa3fa4f99b425cd2519f09bc0282bada52d14ce625b1ded3b24d86b1dad342d2b7be322b775b04fc6b86afb4 +MD = a872fa33d463b3343cec57c20c66979c33e1ad067bfc703454696aab5dd0003bc194318f4a8ebbc74503feb7211a472dadee991efe3e38f21a1310f8a76eac80 + +Len = 888 +Msg = 324533e685f1852e358eea8ea8b81c288b3f3beb1f2bc2b8d3fdbac318382e3d7120de30c9c237aa0a34831deb1e5e060a7969cd3a9742ec1e64b354f7eb290cba1c681c66cc7ea994fdf5614f604d1a2718aab581c1c94931b1387e4b7dc73635bf3a7301174075fa70a9227d85d3 +MD = 3b26c5170729d0814153becb95f1b65cd42f9a6d0649d914e4f69d938b5e9dc041cd0f5c8da0b484d7c7bc7b1bdefb08fe8b1bfedc81109345bc9e9a399feedf + +Len = 896 +Msg = 518985977ee21d2bf622a20567124fcbf11c72df805365835ab3c041f4a9cd8a0ad63c9dee1018aa21a9fa3720f47dc48006f1aa3dba544950f87e627f369bc2793ede21223274492cceb77be7eea50e5a509059929a16d33a9f54796cde5770c74bd3ecc25318503f1a41976407aff2 +MD = c00926a374cde55b8fbd77f50da1363da19744d3f464e07ce31794c5a61b6f9c85689fa1cfe136553527fd876be91673c2cac2dd157b2defea360851b6d92cf4 + +Len = 904 +Msg = 9159767275ba6f79cbb3d58c0108339d8c6a41138991ab7aa58b14793b545b04bda61dd255127b12cc501d5aaad476e09fa14aec21626e8d57b7d08c36cdb79eea314bdd77e65779a0b54eab08c48ceb976adf631f4246a33f7ef896887ea8b5dfa2087a225c8c180f8970696101fc283b +MD = 3cd3380a90868de17dee4bd4d7f90d7512696f0a92b2d089240d61a9d20cd3af094c78bf466c2d404dd2f662ec5f4a299be2adeadf627b98e50e1c072b769d62 + +Len = 912 +Msg = fe2d8ae200e6657fdc7494af5a12b2ae940348f1f983f0ba98febbe99c80d115126d57dbf37296765ebb5990256696588b3851d54c8fbe7ade98a6faf7c20b5e4f730f54a7f912ca0ac31bbb53d17949ef69aa0de40c7bab12a871a9b90f68813ca87af4256422a268f4a1d8ec3aa1a947fd +MD = 8025a8608df0f6a01c34cdec012d4cb25852e1b100b68172fc4e86ac8b7126b64859cb9e767a7e59060989cedbd925afc475ca7369bd43f85ae590e224e036dd + +Len = 920 +Msg = dc28484ebfd293d62ac759d5754bdf502423e4d419fa79020805134b2ce3dff738c7556c91d810adbad8dd210f041296b73c2185d4646c97fc0a5b69ed49ac8c7ced0bd1cfd7e3c3cca47374d189247da6811a40b0ab097067ed4ad40ade2e4791e39204e398b3204971445822a1be0dd93af8 +MD = 615115d2e8b62e345adaa4bdb95395a3b4fe27d71c4a111b86c1841463c5f03d6b20d164a39948ab08ae060720d05c10f6022e5c8caf2fa3bca2e04d9c539ded + +Len = 928 +Msg = 5af8c0f26db4e99b47ec2e4a01a786e77899e46d464ac337f175027b61aef3149848af849d76ac39b9b0910fe6594817859e55974fa167518ed72d088dae6b414d744d477974fb719c626da792f981233de24b7579d8acca510a266d73c0ee8ee1424343eaf6ffcc59c86c1becce5894072c6c11 +MD = 09da284d5b6556508be54c8ab6c97bbd472995c6bbd585917ecdb54ea9167208daaa070a7b2b7d8e93ce1315f0d1ef8d69667429c44dc5ee1499de57b229a398 + +Len = 936 +Msg = 49cd0ba0df5bb3f43f68464e3e83e9cbd5d5ee077ffa5591e30f939cb30c93f7d454fb3fbf8bb05327a89c08dc4baf1eef50237317a405775357f1e0d1f31d9f0f0d98124019d47bf18363b1ecfbfe155c10cbc83300e01bc9ce0347c596b35f411e6d8229ad2855e42022b0373ade98663c6d6e9c +MD = 30cbf0679a97c871574d2fc05d7aa760c6bc8a864b7d246c39b9e812f9b7ff7b4ef5197dd5b69493306688b8564de1ad47d75505c913ba6a78788f8caf5788bd + +Len = 944 +Msg = a8a37dfc083ad2f47fff468738bf8b728eb7f1907e427fa15cb4424bc685e55ed7b2825c9c60b839ccc2fe5fb33e36f570cb8661609e630bda05ee641d938428867d90e00744a4aad494c93c5f6d1327878078590cdce1e647c9820818f467641fcd508e2f2ebfd0ff3d4f272393478f3b9e6f806b43 +MD = 8e1c91729be8eb40226f6c58a029380ef7edb9dc166a5c3cdbcefe90bd30d85cb7c4b248e66abf0a3a4c842281299bef6db88858d9e5ab5244f70b7969e1c072 + +Len = 952 +Msg = 36af17595494ef793c42f48410246df07d05936a918afe74cd005e537c586b2843701f5df8952242b74586f83339b48f4ba3a66bdeb457ecdf61784eac6765cd9b8c570dd628dbba6ae5836b9ac3dbcd795f9efdb8742a35bca232abf36eb3b6698b2933965802277ba953a6edcacaf330c1e4e8c7d45f +MD = 158bfc348a30b4fabbe355a7d44bdc2122a4c850444c03f289003ce01bfc1ebf3ecc0febb6a8ff523d25db7681b05bdce048d11943ab476c1967cf6556c4a120 + +Len = 960 +Msg = 42d66edc5f22e0c13c25504c5101a5d172d2db7209e461efa323c0bfaed27e5f808042ea9c3838ea31f9b76de465225ccfbd0c09ca0d9f07e9a43e3e46c7693e00a7e1d483900ddb0a629d5563456dbbf299ac91f92c3d3c17b05d180e6c87c6c93194c39d90273fcf4a482c56084f95e34c04311fa80438 +MD = 061afb119a3c60876e04c10f12ad0f4b977593dc5a2d21096a57e7d3f7d4d44fdef934b2c17d7530674e4f4a1c176dbdcc54811a22e1b8712e4192fc2d4bf8e8 + +Len = 968 +Msg = f91bb2e1a9c4cd96bf250426b3a6afd9b87ac51e93254d2dae3b16ec686ba80fb0bd7a84d218660e9007593075bc4f4c66567f0c7a5fd2010c999a8a0efa81f89ff5bfefe0fb910f0442e6d4a7c55bbb618c69a79a2ddd82a0938927f6fe3a80f04beaeb7c7636e3435d12dcf1c6bb6ed0a4edb69c9657fa93 +MD = 6e692c8c694ee0a3565f37a299e0006b85ab4a821b20e76798220229f656efc6a20211a4e7e4ed77facde0d70e4d5d95bc8ed1d7a56d8df1446d562f044b344c + +Len = 976 +Msg = d1eb961ca6a8f67c49b61e4d3ceaa2a1de6f0ea927b132bf987abdaa725b0e1e274e46830e99a2f75af608964df0dff9a99024fc6839bac5acd10202f921ac71a27fcda681aa3109ebf5f21ee3a849098ea3a551e844fae4b48b5c5bb97ccc802bc5520d68a14cb7e5fc056b67d889d876efb82d0e9a9a2499f1 +MD = 39b2c76ec207120de4b320c7fe069e602c9c38f257596da7369395e87eb64b3acff988c1839ac269d5012c093f9edd4b7cabf13bdea7d42e969ab108269c6ab0 + +Len = 984 +Msg = adf2263200f376886ba7b6f5e4411d5f07f7d9d101590c73ace114bafbcb0fdc99269e87cd2cead2a1cfe5744394d333aba408a07e21f30233b65b907472e9e3c7d6e7aa6d2c47a08a1be7bb877913a6b5604c723384478911c339e3b5fe527c7e288705a89c95d970b443347897e79f6c522bafe62b11ef8f3135 +MD = 3c23d2d8cf4db6ac6a42e27208180f37668bef5ee0a3f879483c8e604e7f42583f202037b8d242c04a87345b8be6dc8b121d6484b9edad0d73c894c1288f5cae + +Len = 992 +Msg = 18e75b47d898ac629c48e80dbfb75dae1e1700b771165eccdb18d628bfc4063dd6c3839a7ec4cd1255c4821b078cd174647b320bb685541d517c579f6b8e3cdd2e109a610c7a921653b204ad018d0340d9938735b60262662016767e1d8824a64954086229c0e3b5bd9ad88c54c1dc5aa4e768ff1a9470ee6f6e998f +MD = 01c756b7c20b5f95fd2b079ab6a50f28b946fb16266b07c6060945dc4fe9e0d279c5b1505b9ec7d8f8f3c9ebf0c5ee9365aec08cf278d65b64daeccc19d3cbf4 + +Len = 1000 +Msg = c2963342cfaa88ccd102a258e6d629f6b0d367dd55116502ca4451ea523623bc4175819a0648df3168e8ea8f10ed27354807d76e02ee1fdf1c9c655ee2b9fd08d557058dabdf8dcf964bfcacc996ae173971e26ea038d407c824260d06c2848a04a488c4c456dbcde2939e561ab908c4097b508638d6cda556465c9cc5 +MD = a4d2f59393a5fea612c3c745f4bb9f41aaf3a3ce1679aa8afc1a62baa4ed452819418c8ae1a1e658757976692390fc43d4decf7d855cd8b498b6dc60cae05a90 + +Len = 1008 +Msg = 85360c3d4257d9878e2f5c16d3cd7d0747df3d231e1a8f63fddc69b3b1101af72153de4c8154b090c9815f2466e0e4f02f3af3a89a7fd04e306664f93e5490d4ce7fc169d553c520ae15dd02c7c613c39b4acd00e0c9a3c501566e52cecea11f7303dd1da61abf3f2532fd396047b1887255f4b256c0afcf58f3ae48c947 +MD = e8352ddcac59e377ea0f9c32bbb43dfd1b6c829fad1954240c41b7c45b0b09db11064b64e2442a96f6530aac2c4abf3beb1eae77f2bce4efe88fee1a70cf5423 + +Len = 1016 +Msg = c13e6ca3abb893aa5f82c4a8ef754460628af6b75af02168f45b72f8f09e45ed127c203bc7bb80ff0c7bd96f8cc6d8110868eb2cfc01037d8058992a6cf2effcbfe498c842e53a2e68a793867968ba18efc4a78b21cdf6a11e5de821dcabab14921ddb33625d48a13baffad6fe8272dbdf4433bd0f7b813c981269c388f001 +MD = 6e56f77f6883d0bd4face8b8d557f144661989f66d51b1fe4b8fc7124d66d9d20218616fea1bcf86c08d63bf8f2f21845a3e519083b937e70aa7c358310b5a7c + +Len = 1024 +Msg = fd2203e467574e834ab07c9097ae164532f24be1eb5d88f1af7748ceff0d2c67a21f4e4097f9d3bb4e9fbf97186e0db6db0100230a52b453d421f8ab9c9a6043aa3295ea20d2f06a2f37470d8a99075f1b8a8336f6228cf08b5942fc1fb4299c7d2480e8e82bce175540bdfad7752bc95b577f229515394f3ae5cec870a4b2f8 +MD = a21b1077d52b27ac545af63b32746c6e3c51cb0cb9f281eb9f3580a6d4996d5c9917d2a6e484627a9d5a06fa1b25327a9d710e027387fc3e07d7c4d14c6086cc + From 17f3a9fbb2088e34f72cd14f7fa3520d852d85f7 Mon Sep 17 00:00:00 2001 From: Euicheon Hong <78904698+gdmlcjs@users.noreply.github.com> Date: Sat, 31 Jan 2026 05:13:01 +0900 Subject: [PATCH 14/78] fix: prevent overflow by changing type of Sha2 message length field (#2381) The field storing the total message length in the `Sha256` and `Sha512` structs were both of type `usize`. To prevent overflow the types were changed to `u64` and `u128`, respectively, following the implementation of RustCrypto. closes INT-6012 --- guest-libs/sha2/src/zkvm_impl.rs | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/guest-libs/sha2/src/zkvm_impl.rs b/guest-libs/sha2/src/zkvm_impl.rs index 77c66b9f03..9d0b39e76b 100644 --- a/guest-libs/sha2/src/zkvm_impl.rs +++ b/guest-libs/sha2/src/zkvm_impl.rs @@ -35,7 +35,7 @@ pub struct Sha256 { // idx of next byte to write to buffer (equal to len mod SHA256_BLOCK_BYTES) idx: usize, // accumulated length of the input data, in bytes - len: usize, + len: u64, } impl Default for Sha256 { @@ -55,7 +55,7 @@ impl Sha256 { } fn update(&mut self, mut input: &[u8]) { - self.len += input.len(); + self.len = self.len.checked_add(input.len() as u64).unwrap(); while !input.is_empty() { let to_copy = min(input.len(), SHA256_BLOCK_BYTES - self.idx); self.buffer[self.idx..self.idx + to_copy].copy_from_slice(&input[..to_copy]); @@ -72,9 +72,9 @@ impl Sha256 { // pad positive amount so that length is multiple of SHA256_BLOCK_BYTES // (extra 8 bytes are for message length) let num_bytes_of_padding = SHA256_BLOCK_BYTES - (self.idx + 8) % SHA256_BLOCK_BYTES; - let message_len_in_bits = self.len * 8; + let message_len_in_bits: u64 = self.len.checked_mul(8).unwrap(); self.update(&PADDING_BYTES[..num_bytes_of_padding]); - self.update(&(message_len_in_bits as u64).to_be_bytes()); + self.update(&(message_len_in_bits).to_be_bytes()); let mut output = [0u8; SHA256_DIGEST_BYTES]; output .chunks_exact_mut(4) @@ -142,7 +142,7 @@ pub struct Sha512 { // idx of next byte to write to buffer idx: usize, // accumulated length of the input data, in bytes - len: usize, + len: u128, } impl Default for Sha512 { @@ -162,7 +162,7 @@ impl Sha512 { } fn update(&mut self, mut input: &[u8]) { - self.len += input.len(); + self.len = self.len.checked_add(input.len() as u128).unwrap(); while !input.is_empty() { let to_copy = min(input.len(), SHA512_BLOCK_BYTES - self.idx); self.buffer[self.idx..self.idx + to_copy].copy_from_slice(&input[..to_copy]); @@ -179,9 +179,9 @@ impl Sha512 { // pad positive amount so that length is multiple of SHA512_BLOCK_BYTES // (extra 16 bytes are for message length) let num_bytes_of_padding = SHA512_BLOCK_BYTES - (self.idx + 16) % SHA512_BLOCK_BYTES; - let message_len_in_bits = self.len * 8; + let message_len_in_bits: u128 = self.len.checked_mul(8).unwrap(); self.update(&PADDING_BYTES[..num_bytes_of_padding]); - self.update(&(message_len_in_bits as u128).to_be_bytes()); + self.update(&(message_len_in_bits).to_be_bytes()); let mut output = [0u8; SHA512_DIGEST_BYTES]; output .chunks_exact_mut(8) From 167632826b5410815c030bff910197dc5313ab76 Mon Sep 17 00:00:00 2001 From: Euicheon Hong <78904698+gdmlcjs@users.noreply.github.com> Date: Thu, 5 Feb 2026 07:33:19 +0900 Subject: [PATCH 15/78] feat: implement Hasher trait for Keccak guest library (#2386) Made `Keccak256` struct that has the `tiny-keccak::Hasher` functionalities. The actual `tiny-keccak::Hasher` trait is only implemented when the `tiny-keccak` feature is enabled. The `native_keccak256` function uses a static `Keccak256` instance to reduce memory allocations. To avoid compile errors, the default `tiny-keccak` feature must be kept enabled when the target is not ZKVM. towards INT-5944 --- Cargo.lock | 3 + extensions/keccak256/guest/Cargo.toml | 3 - extensions/keccak256/guest/src/lib.rs | 151 -------------------------- guest-libs/keccak256/Cargo.toml | 12 +- guest-libs/keccak256/src/host_impl.rs | 49 +++++++++ guest-libs/keccak256/src/lib.rs | 60 +++++----- guest-libs/keccak256/src/zkvm_impl.rs | 137 +++++++++++++++++++++++ 7 files changed, 226 insertions(+), 189 deletions(-) create mode 100644 guest-libs/keccak256/src/host_impl.rs create mode 100644 guest-libs/keccak256/src/zkvm_impl.rs diff --git a/Cargo.lock b/Cargo.lock index 3fb0266b49..9ddeae1b66 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6674,15 +6674,18 @@ name = "openvm-keccak256" version = "2.0.0-alpha" dependencies = [ "eyre", + "hex", "openvm-circuit", "openvm-instructions", "openvm-keccak256-circuit", "openvm-keccak256-guest", "openvm-keccak256-transpiler", "openvm-rv32im-transpiler", + "openvm-sdk", "openvm-stark-sdk", "openvm-toolchain-tests", "openvm-transpiler", + "spin 0.10.0", "tiny-keccak", ] diff --git a/extensions/keccak256/guest/Cargo.toml b/extensions/keccak256/guest/Cargo.toml index 8a6939ca7c..f2e86a53fe 100644 --- a/extensions/keccak256/guest/Cargo.toml +++ b/extensions/keccak256/guest/Cargo.toml @@ -10,8 +10,5 @@ repository.workspace = true [dependencies] openvm-platform = { workspace = true } -[target.'cfg(target_os = "zkvm")'.dependencies] -spin = { workspace = true, features = ["mutex", "spin_mutex"] } - [features] default = [] diff --git a/extensions/keccak256/guest/src/lib.rs b/extensions/keccak256/guest/src/lib.rs index 048977484c..2f54b0fc5e 100644 --- a/extensions/keccak256/guest/src/lib.rs +++ b/extensions/keccak256/guest/src/lib.rs @@ -1,11 +1,7 @@ #![no_std] -#[cfg(target_os = "zkvm")] -extern crate alloc; #[cfg(target_os = "zkvm")] use openvm_platform::alloc::AlignedBuf; -#[cfg(target_os = "zkvm")] -use spin::Mutex; pub const OPCODE: u8 = 0x0b; pub const KECCAKF_FUNCT3: u8 = 0b100; @@ -18,29 +14,6 @@ pub const KECCAK_RATE: usize = 136; pub const KECCAK_OUTPUT_SIZE: usize = 32; pub const MIN_ALIGN: usize = 4; -#[cfg(target_os = "zkvm")] -#[repr(align(4))] -struct AlignedStackBuf { - data: [u8; N], -} - -/// Calls to [keccak256_impl] require use of a buffer for the state. Allocation of such a buffer can -/// increase the size of the stack frame. Instead, we can reuse a static buffer. Spin mutex is -/// acceptable since the zkVM is single-threaded so there is no contention. -#[cfg(target_os = "zkvm")] -static KECCAK_BUFFER: Mutex> = Mutex::new(AlignedStackBuf { - data: [0u8; KECCAK_WIDTH_BYTES], -}); - -/// SAFETY: Caller must ensure: -/// - buffer and input are aligned to MIN_ALIGN -/// - len is a multiple of MIN_ALIGN -#[cfg(target_os = "zkvm")] -#[inline(always)] -unsafe fn native_xorin_unchecked(buffer: *mut u8, input: *const u8, len: usize) { - __native_xorin(buffer, input, len); -} - #[cfg(target_os = "zkvm")] #[no_mangle] pub extern "C" fn native_xorin(buffer: *mut u8, input: *const u8, len: usize) { @@ -83,13 +56,6 @@ pub extern "C" fn native_xorin(buffer: *mut u8, input: *const u8, len: usize) { } } -/// SAFETY: Caller must ensure buffer is aligned to MIN_ALIGN -#[cfg(target_os = "zkvm")] -#[inline(always)] -unsafe fn native_keccakf_unchecked(buffer: *mut u8) { - __native_keccakf(buffer); -} - #[cfg(target_os = "zkvm")] #[no_mangle] pub extern "C" fn native_keccakf(buffer: *mut u8) { @@ -108,123 +74,6 @@ pub extern "C" fn native_keccakf(buffer: *mut u8) { } } -/// Native hook for keccak256 for use with `alloy-primitives` "native-keccak" feature. -/// -/// # Safety -/// -/// The VM accepts the preimage by pointer and length, and writes the -/// 32-byte hash. -/// - `bytes` must point to an input buffer at least `len` long. -/// - `output` must point to a buffer that is at least 32-bytes long. -/// -/// [`keccak256`]: https://en.wikipedia.org/wiki/SHA-3 -/// [`sha3`]: https://docs.rs/sha3/latest/sha3/ -/// [`tiny_keccak`]: https://docs.rs/tiny-keccak/latest/tiny_keccak/ -#[cfg(target_os = "zkvm")] -#[no_mangle] -pub extern "C" fn native_keccak256(bytes: *const u8, len: usize, output: *mut u8) { - unsafe { - let bytes_aligned = bytes as usize % MIN_ALIGN == 0; - let output_aligned = output as usize % MIN_ALIGN == 0; - - let aligned_bytes; - let aligned_output; - - let actual_bytes = if len == 0 || bytes_aligned { - bytes - } else { - aligned_bytes = AlignedBuf::new(bytes, len, MIN_ALIGN); - aligned_bytes.ptr - }; - - let actual_output = if output_aligned { - output - } else { - aligned_output = AlignedBuf::uninit(KECCAK_OUTPUT_SIZE, MIN_ALIGN); - aligned_output.ptr - }; - - keccak256_impl(actual_bytes, len, actual_output); - - if !output_aligned { - core::ptr::copy_nonoverlapping(actual_output as *const u8, output, KECCAK_OUTPUT_SIZE); - } - } -} - -/// SAFETY: This function is only called from native_keccak256 which ensures: -/// - input is aligned to MIN_ALIGN -/// - output is aligned to MIN_ALIGN -/// - All internal buffers are aligned by AlignedStackBuf -#[cfg(target_os = "zkvm")] -#[inline(always)] -unsafe fn keccak256_impl(input: *const u8, len: usize, output: *mut u8) { - let mut buffer = KECCAK_BUFFER.lock(); - let buffer_ptr = buffer.data.as_mut_ptr(); - - // State starts as [0u8; KECCAK_WIDTH_BYTES]. To save the first xorin, we memcpy directly into - // state. - let first_xorin_len = core::cmp::min(len, KECCAK_RATE); - core::ptr::copy_nonoverlapping(input, buffer_ptr, first_xorin_len); - core::ptr::write_bytes( - buffer_ptr.add(first_xorin_len), - 0u8, - KECCAK_WIDTH_BYTES - first_xorin_len, - ); - if first_xorin_len >= KECCAK_RATE { - native_keccakf_unchecked(buffer_ptr); - } else { - // We pad, do a single keccakf, and early return - - // 1*01 padding - buffer.data[first_xorin_len] ^= 0x01; - buffer.data[KECCAK_RATE - 1] ^= 0x80; - native_keccakf_unchecked(buffer_ptr); - - core::ptr::copy_nonoverlapping(buffer_ptr, output, KECCAK_OUTPUT_SIZE); - return; - } - - let mut offset = KECCAK_RATE; - let mut remaining = len - KECCAK_RATE; - - // Absorb full blocks - while remaining >= KECCAK_RATE { - native_xorin_unchecked(buffer_ptr, input.add(offset), KECCAK_RATE); - native_keccakf_unchecked(buffer_ptr); - offset += KECCAK_RATE; - remaining -= KECCAK_RATE; - } - - // Handle remaining bytes - if remaining > 0 { - if remaining % MIN_ALIGN == 0 { - native_xorin_unchecked(buffer_ptr, input.add(offset), remaining); - } else { - let adjusted_len = remaining.next_multiple_of(MIN_ALIGN); - let mut padded_input = AlignedStackBuf:: { - data: [0u8; KECCAK_RATE], - }; - core::ptr::copy_nonoverlapping( - input.add(offset), - padded_input.data.as_mut_ptr(), - remaining, - ); - native_xorin_unchecked(buffer_ptr, padded_input.data.as_ptr(), adjusted_len); - } - } - - // Apply Keccak padding (pad10*1) - buffer.data[remaining] ^= 0x01; - buffer.data[KECCAK_RATE - 1] ^= 0x80; - - // Final permutation - native_keccakf_unchecked(buffer_ptr); - - // Extract output - core::ptr::copy_nonoverlapping(buffer.data.as_ptr(), output, KECCAK_OUTPUT_SIZE); -} - #[cfg(target_os = "zkvm")] #[inline(always)] fn __native_xorin(mut buffer: *mut u8, input: *const u8, len: usize) { diff --git a/guest-libs/keccak256/Cargo.toml b/guest-libs/keccak256/Cargo.toml index 276ec2679f..6eb4d36e92 100644 --- a/guest-libs/keccak256/Cargo.toml +++ b/guest-libs/keccak256/Cargo.toml @@ -11,9 +11,15 @@ license.workspace = true [dependencies] openvm-keccak256-guest = { workspace = true } +tiny-keccak = { workspace = true, optional = true } + +[target.'cfg(target_os = "zkvm")'.dependencies] +spin = { workspace = true, features = ["mutex", "spin_mutex"] } [dev-dependencies] +hex = { workspace = true } openvm-instructions = { workspace = true } +openvm-sdk = { workspace = true } openvm-stark-sdk = { workspace = true } openvm-circuit = { workspace = true, features = ["test-utils", "parallel"] } openvm-transpiler = { workspace = true } @@ -23,9 +29,9 @@ openvm-rv32im-transpiler = { workspace = true } openvm-toolchain-tests = { workspace = true } eyre = { workspace = true } -[target.'cfg(not(target_os = "zkvm"))'.dependencies] -tiny-keccak = { workspace = true } - [features] +default = ["tiny_keccak"] # Internal feature for testing only. cuda = ["openvm-keccak256-circuit/cuda"] +# Enable tiny_keccak::Hasher trait implementation +tiny_keccak = ["dep:tiny-keccak"] diff --git a/guest-libs/keccak256/src/host_impl.rs b/guest-libs/keccak256/src/host_impl.rs new file mode 100644 index 0000000000..02cb50b090 --- /dev/null +++ b/guest-libs/keccak256/src/host_impl.rs @@ -0,0 +1,49 @@ +use openvm_keccak256_guest::KECCAK_OUTPUT_SIZE; +use tiny_keccak::Hasher as _; + +/// Keccak-256 hasher state for incremental hashing. +/// +/// This struct wraps tiny-keccak's Keccak hasher for Keccak-256. +#[derive(Clone)] +pub struct Keccak256 { + inner: tiny_keccak::Keccak, +} + +impl Keccak256 { + /// Creates a new Keccak-256 hasher. + pub fn new() -> Self { + Self { + inner: tiny_keccak::Keccak::v256(), + } + } + + /// Absorbs input data into the sponge state. + pub fn update(&mut self, input: &[u8]) { + self.inner.update(input); + } + + /// Finalizes the hash computation and writes the result to the output buffer. + /// + /// The output buffer must be at least `KECCAK_OUTPUT_SIZE` (32) bytes. + pub fn finalize(self, output: &mut [u8]) { + debug_assert!( + output.len() >= super::KECCAK_OUTPUT_SIZE, + "output buffer too small" + ); + self.inner.finalize(output); + } +} + +impl Default for Keccak256 { + fn default() -> Self { + Self::new() + } +} + +/// Sets `output` to the keccak256 hash of `input`. +#[inline(always)] +pub fn set_keccak256(input: &[u8], output: &mut [u8; KECCAK_OUTPUT_SIZE]) { + let mut hasher = Keccak256::new(); + hasher.update(input); + hasher.finalize(output); +} diff --git a/guest-libs/keccak256/src/lib.rs b/guest-libs/keccak256/src/lib.rs index 29614ea9ae..da967389fc 100644 --- a/guest-libs/keccak256/src/lib.rs +++ b/guest-libs/keccak256/src/lib.rs @@ -1,41 +1,37 @@ #![no_std] +use openvm_keccak256_guest::KECCAK_OUTPUT_SIZE; + +#[cfg(not(any(target_os = "zkvm", feature = "tiny_keccak")))] +compile_error!("Keccak256 requires the 'tiny_keccak' feature to be enabled on non-zkvm targets"); + +#[cfg(not(target_os = "zkvm"))] +mod host_impl; #[cfg(target_os = "zkvm")] -use core::mem::MaybeUninit; +mod zkvm_impl; -#[inline(always)] -pub fn keccak256(input: &[u8]) -> [u8; 32] { - #[cfg(not(target_os = "zkvm"))] - { - let mut output = [0u8; 32]; - set_keccak256(input, &mut output); - output +#[cfg(not(target_os = "zkvm"))] +pub use host_impl::{set_keccak256, Keccak256}; +#[cfg(target_os = "zkvm")] +pub use zkvm_impl::{native_keccak256, set_keccak256, Keccak256}; + +#[cfg(feature = "tiny_keccak")] +impl tiny_keccak::Hasher for Keccak256 { + #[inline(always)] + fn update(&mut self, input: &[u8]) { + Keccak256::update(self, input); } - #[cfg(target_os = "zkvm")] - { - let mut output = MaybeUninit::<[u8; 32]>::uninit(); - openvm_keccak256_guest::native_keccak256( - input.as_ptr(), - input.len(), - output.as_mut_ptr() as *mut u8, - ); - unsafe { output.assume_init() } + + #[inline(always)] + fn finalize(self, output: &mut [u8]) { + Keccak256::finalize(self, output); } } -/// Sets `output` to the keccak256 hash of `input`. -pub fn set_keccak256(input: &[u8], output: &mut [u8; 32]) { - #[cfg(not(target_os = "zkvm"))] - { - use tiny_keccak::Hasher; - let mut hasher = tiny_keccak::Keccak::v256(); - hasher.update(input); - hasher.finalize(output); - } - #[cfg(target_os = "zkvm")] - openvm_keccak256_guest::native_keccak256( - input.as_ptr(), - input.len(), - output.as_mut_ptr() as *mut u8, - ); +/// Computes the keccak256 hash of the input. +#[inline(always)] +pub fn keccak256(input: &[u8]) -> [u8; KECCAK_OUTPUT_SIZE] { + let mut output = [0u8; KECCAK_OUTPUT_SIZE]; + set_keccak256(input, &mut output); + output } diff --git a/guest-libs/keccak256/src/zkvm_impl.rs b/guest-libs/keccak256/src/zkvm_impl.rs new file mode 100644 index 0000000000..4823f47540 --- /dev/null +++ b/guest-libs/keccak256/src/zkvm_impl.rs @@ -0,0 +1,137 @@ +use core::cmp::min; + +use openvm_keccak256_guest::{KECCAK_OUTPUT_SIZE, KECCAK_RATE, KECCAK_WIDTH_BYTES}; +use spin::Mutex; + +/// Aligned wrapper for Keccak state to ensure 4-byte alignment on word accesses. +#[derive(Clone)] +#[repr(align(4))] +struct AlignedState([u8; KECCAK_WIDTH_BYTES]); + +/// Keccak-256 hasher state for incremental hashing. +/// +/// This struct implements the Keccak sponge construction for Keccak-256. +#[derive(Clone)] +pub struct Keccak256 { + /// The Keccak state (1600 bits = 200 bytes) + state: AlignedState, + /// Current position in the rate portion of the state (0 <= idx < KECCAK_RATE) + idx: usize, +} + +impl Keccak256 { + /// Creates a new Keccak-256 hasher. + pub const fn new() -> Self { + Self { + state: AlignedState([0u8; KECCAK_WIDTH_BYTES]), + idx: 0, + } + } + + /// Resets the hasher to its initial state. + fn reset(&mut self) { + self.state.0.fill(0); + self.idx = 0; + } + + /// XOR input bytes into state at the current index and advance the index. + #[inline(always)] + fn xorin(&mut self, input: *const u8, len: usize) { + openvm_keccak256_guest::native_xorin(self.state.0[self.idx..].as_mut_ptr(), input, len); + self.idx += len; + } + + /// Keccak-f[1600] permutation using native zkvm instruction. + #[inline(always)] + fn keccakf(&mut self) { + openvm_keccak256_guest::native_keccakf(self.state.0.as_mut_ptr()); + } + + /// Absorbs input data into the sponge state from a raw pointer. + fn update_ptr(&mut self, mut input: *const u8, mut len: usize) { + while len > 0 { + let to_absorb = min(len, KECCAK_RATE - self.idx); + + // XOR input into state + self.xorin(input, to_absorb); + + // If we filled the rate portion, apply the permutation + if self.idx == KECCAK_RATE { + self.keccakf(); + self.idx = 0; + } + + input = unsafe { input.add(to_absorb) }; + len -= to_absorb; + } + } + + /// Absorbs input data into the sponge state. + #[inline(always)] + pub fn update(&mut self, input: &[u8]) { + self.update_ptr(input.as_ptr(), input.len()); + } + + /// Finalizes the hash computation and writes the result to a raw pointer. + fn finalize_ptr(&mut self, output: *mut u8) { + // Apply Keccak padding (pad10*1): 0x01 at current position, 0x80 at end of rate + self.state.0[self.idx] ^= 0x01; + self.state.0[KECCAK_RATE - 1] ^= 0x80; + + // Final permutation + self.keccakf(); + + // Squeeze: copy output from state + unsafe { + core::ptr::copy_nonoverlapping(self.state.0.as_ptr(), output, KECCAK_OUTPUT_SIZE); + } + } + + /// Finalizes the hash computation and writes the result to the output buffer. + /// + /// The output buffer must be at least `KECCAK_OUTPUT_SIZE` (32) bytes. + #[inline(always)] + pub fn finalize(mut self, output: &mut [u8]) { + debug_assert!( + output.len() >= KECCAK_OUTPUT_SIZE, + "output buffer too small" + ); + self.finalize_ptr(output.as_mut_ptr()); + } +} + +impl Default for Keccak256 { + fn default() -> Self { + Self::new() + } +} + +/// Static hasher for `native_keccak256`. Reusing a static buffer avoids stack frame growth. +/// Spin mutex is acceptable since the zkVM is single-threaded so there is no contention. +static KECCAK256_HASHER: Mutex = Mutex::new(Keccak256::new()); + +/// Native hook for keccak256 for use with `alloy-primitives` "native-keccak" feature. +/// +/// # Safety +/// +/// The VM accepts the preimage by pointer and length, and writes the +/// 32-byte hash. +/// - `bytes` must point to an input buffer at least `len` long. +/// - `output` must point to a buffer that is at least 32-bytes long. +/// +/// [`keccak256`]: https://en.wikipedia.org/wiki/SHA-3 +/// [`sha3`]: https://docs.rs/sha3/latest/sha3/ +/// [`tiny_keccak`]: https://docs.rs/tiny-keccak/latest/tiny_keccak/ +#[no_mangle] +pub extern "C" fn native_keccak256(bytes: *const u8, len: usize, output: *mut u8) { + let mut hasher = KECCAK256_HASHER.lock(); + hasher.update_ptr(bytes, len); + hasher.finalize_ptr(output); + hasher.reset(); +} + +/// Sets `output` to the keccak256 hash of `input`. +#[inline(always)] +pub fn set_keccak256(input: &[u8], output: &mut [u8; KECCAK_OUTPUT_SIZE]) { + native_keccak256(input.as_ptr(), input.len(), output.as_mut_ptr()); +} From ceb50450b89c179caf113fc678fa9f8c3ba74c1d Mon Sep 17 00:00:00 2001 From: Euicheon Hong <78904698+gdmlcjs@users.noreply.github.com> Date: Sat, 7 Feb 2026 03:42:33 +0900 Subject: [PATCH 16/78] test: add test suite for Keccak guest (#2388) Adds execution tests and proving (only for GPU) tests for the Keccak guest library. Test vectors are from https://keccak.team/archives.html (https://keccak.team/obsolete/KeccakKAT-3.zip). closes INT-5933 --- .github/workflows/guest-lib-tests.cuda.yml | 6 +- .github/workflows/guest-lib-tests.yml | 2 +- guest-libs/keccak256/Cargo.toml | 1 + guest-libs/keccak256/tests/lib.rs | 102 +- .../tests/programs/examples/keccak.rs | 28 +- .../tests/test_vectors/LongMsgKAT_256.txt | 1543 ++++ .../tests/test_vectors/ShortMsgKAT_256.txt | 8195 +++++++++++++++++ 7 files changed, 9855 insertions(+), 22 deletions(-) create mode 100755 guest-libs/keccak256/tests/test_vectors/LongMsgKAT_256.txt create mode 100755 guest-libs/keccak256/tests/test_vectors/ShortMsgKAT_256.txt diff --git a/.github/workflows/guest-lib-tests.cuda.yml b/.github/workflows/guest-lib-tests.cuda.yml index addfc2962b..310428a284 100644 --- a/.github/workflows/guest-lib-tests.cuda.yml +++ b/.github/workflows/guest-lib-tests.cuda.yml @@ -32,7 +32,8 @@ jobs: - { names: "sha2_256", path: "sha2", filter: "sha256" } - { names: "sha2_384", path: "sha2", filter: "sha384" } - { names: "sha2_512", path: "sha2", filter: "sha512" } - - { names: "keccak256 verify-stark" } + - { names: "keccak256", path: "keccak256" } + - { names: "verify-stark" } - { names: "ruint k256 p256" } - { names: "ff_derive pairing" } runs-on: @@ -165,6 +166,9 @@ jobs: if [[ ${{ github.event_name }} == "push" && ${{ github.ref }} == "refs/heads/main" ]]; then SPECIAL_ARGS="$SPECIAL_ARGS --features=long_proving_tests" fi + elif [[ "$crate" == "keccak256" ]]; then + # also run proving tests + SPECIAL_ARGS="--run-ignored=all" fi # Build the command diff --git a/.github/workflows/guest-lib-tests.yml b/.github/workflows/guest-lib-tests.yml index 736a23b3e3..681f338601 100644 --- a/.github/workflows/guest-lib-tests.yml +++ b/.github/workflows/guest-lib-tests.yml @@ -77,7 +77,7 @@ jobs: run: | rustup component add rust-src --toolchain nightly-2025-08-02 FEATURE_ARGS="" - if [[ "${{ matrix.crate.name }}" == sha2_* ]]; then + if [[ "${{ matrix.crate.name }}" == sha2_* || "${{ matrix.crate.name }}" == "keccak256" ]]; then FEATURE_ARGS="--features=aot" elif [[ "${{ matrix.crate.name }}" == "pairing" ]]; then FEATURE_ARGS="--features=bn254,bls12_381,aot" diff --git a/guest-libs/keccak256/Cargo.toml b/guest-libs/keccak256/Cargo.toml index 6eb4d36e92..f26603781a 100644 --- a/guest-libs/keccak256/Cargo.toml +++ b/guest-libs/keccak256/Cargo.toml @@ -31,6 +31,7 @@ eyre = { workspace = true } [features] default = ["tiny_keccak"] +aot = ["openvm-sdk/aot"] # Internal feature for testing only. cuda = ["openvm-keccak256-circuit/cuda"] # Enable tiny_keccak::Hasher trait implementation diff --git a/guest-libs/keccak256/tests/lib.rs b/guest-libs/keccak256/tests/lib.rs index 59c48e740c..ce89ab550b 100644 --- a/guest-libs/keccak256/tests/lib.rs +++ b/guest-libs/keccak256/tests/lib.rs @@ -1,7 +1,10 @@ #[cfg(test)] mod tests { + use std::fs; + use eyre::Result; - use openvm_circuit::utils::air_test; + use hex::FromHex; + use openvm_circuit::{arch::VmExecutor, utils::air_test_with_min_segments}; use openvm_instructions::exe::VmExe; use openvm_keccak256_circuit::Keccak256Rv32Config; #[cfg(not(feature = "cuda"))] @@ -12,14 +15,58 @@ mod tests { use openvm_rv32im_transpiler::{ Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension, }; + use openvm_sdk::StdIn; use openvm_stark_sdk::p3_baby_bear::BabyBear; use openvm_toolchain_tests::{build_example_program_at_path, get_programs_dir}; use openvm_transpiler::{transpiler::Transpiler, FromElf}; type F = BabyBear; - #[test] - fn test_keccak256() -> Result<()> { + struct TestVector { + input: Vec, + expected_output: Vec, + } + + // test vectors are from https://keccak.team/archives.html (https://keccak.team/obsolete/KeccakKAT-3.zip) + fn parse_test_vectors(file_name: &str) -> Vec { + let mut test_vectors = Vec::new(); + + let get_attribute_from_line = |line: &str, attribute: &str| -> Option { + line.trim() + .strip_prefix(&(attribute.to_string() + " = ")) + .map(|s| s.to_string()) + }; + + let file_content = + fs::read_to_string("tests/test_vectors/".to_string() + file_name).unwrap(); + let mut lines = file_content.lines(); + while let Some(line) = lines.next() { + let Some(len_str) = get_attribute_from_line(line, "Len") else { + continue; + }; + let msg_str = get_attribute_from_line(lines.next().unwrap(), "Msg").unwrap(); + let md_str = get_attribute_from_line(lines.next().unwrap(), "MD").unwrap(); + + let len: usize = len_str.parse().unwrap(); + if len.is_multiple_of(8) { + let msg = if len == 0 { + Vec::new() + } else { + Vec::from_hex(&msg_str).unwrap() + }; + let md = Vec::from_hex(&md_str).unwrap(); + + test_vectors.push(TestVector { + input: msg, + expected_output: md, + }); + } + } + + test_vectors + } + + fn test_keccak256_base(test_vector_file_name: &str, prove: bool) -> Result<()> { let config = Keccak256Rv32Config::default(); let elf = build_example_program_at_path(get_programs_dir!("tests/programs"), "keccak", &config)?; @@ -31,7 +78,54 @@ mod tests { .with_extension(Rv32MTranspilerExtension) .with_extension(Rv32IoTranspilerExtension), )?; - air_test(TestBuilder, config, openvm_exe); + + let test_vectors = parse_test_vectors(test_vector_file_name); + let mut stdin = StdIn::default(); + stdin.write(&(test_vectors.len() as u32)); + for test_vector in &test_vectors { + stdin.write(&test_vector.input); + stdin.write(&test_vector.expected_output); + } + + if prove { + air_test_with_min_segments(TestBuilder, config, openvm_exe, stdin, 1); + } else { + let executor = VmExecutor::new(config.clone())?; + let interpreter = executor.instance(&openvm_exe)?; + #[allow(unused_variables)] + let state = interpreter.execute(stdin.clone(), None)?; + + #[cfg(feature = "aot")] + { + use openvm_circuit::{arch::VmState, system::memory::online::GuestMemory}; + let naive_interpreter = executor.interpreter_instance(&openvm_exe)?; + let naive_state = naive_interpreter.execute(stdin, None)?; + let assert_vm_state_eq = + |lhs: &VmState, rhs: &VmState| { + assert_eq!(lhs.pc(), rhs.pc()); + for r in 0..32 { + let a = unsafe { lhs.memory.read::(1, r as u32) }; + let b = unsafe { rhs.memory.read::(1, r as u32) }; + assert_eq!(a, b); + } + }; + assert_vm_state_eq(&state, &naive_state); + } + } + Ok(()) } + + #[test] + fn test_keccak256_run() -> Result<()> { + test_keccak256_base("ShortMsgKAT_256.txt", false)?; + test_keccak256_base("LongMsgKAT_256.txt", false) + } + + #[test] + #[ignore = "proving on CPU is slow"] + fn test_keccak256_prove() -> Result<()> { + test_keccak256_base("ShortMsgKAT_256.txt", true)?; + test_keccak256_base("LongMsgKAT_256.txt", true) + } } diff --git a/guest-libs/keccak256/tests/programs/examples/keccak.rs b/guest-libs/keccak256/tests/programs/examples/keccak.rs index 37955be114..7c7882a25f 100644 --- a/guest-libs/keccak256/tests/programs/examples/keccak.rs +++ b/guest-libs/keccak256/tests/programs/examples/keccak.rs @@ -6,27 +6,23 @@ extern crate alloc; use alloc::vec::Vec; use core::hint::black_box; -use hex::FromHex; +use openvm::io::read; use openvm_keccak256::keccak256; openvm::entry!(main); pub fn main() { - let test_vectors = [ - ("", "C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470"), // ShortMsgKAT_256 Len = 0 - ("CC", "EEAD6DBFC7340A56CAEDC044696A168870549A6A7F6F56961E84A54BD9970B8A"), // ShortMsgKAT_256 Len = 8 - ("B55C10EAE0EC684C16D13463F29291BF26C82E2FA0422A99C71DB4AF14DD9C7F33EDA52FD73D017CC0F2DBE734D831F0D820D06D5F89DACC485739144F8CFD4799223B1AFF9031A105CB6A029BA71E6E5867D85A554991C38DF3C9EF8C1E1E9A7630BE61CAABCA69280C399C1FB7A12D12AEFC", "0347901965D3635005E75A1095695CCA050BC9ED2D440C0372A31B348514A889"), // ShortMsgKAT_256 Len = 920 - ("2EDC282FFB90B97118DD03AAA03B145F363905E3CBD2D50ECD692B37BF000185C651D3E9726C690D3773EC1E48510E42B17742B0B0377E7DE6B8F55E00A8A4DB4740CEE6DB0830529DD19617501DC1E9359AA3BCF147E0A76B3AB70C4984C13E339E6806BB35E683AF8527093670859F3D8A0FC7D493BCBA6BB12B5F65E71E705CA5D6C948D66ED3D730B26DB395B3447737C26FAD089AA0AD0E306CB28BF0ACF106F89AF3745F0EC72D534968CCA543CD2CA50C94B1456743254E358C1317C07A07BF2B0ECA438A709367FAFC89A57239028FC5FECFD53B8EF958EF10EE0608B7F5CB9923AD97058EC067700CC746C127A61EE3", "DD1D2A92B3F3F3902F064365838E1F5F3468730C343E2974E7A9ECFCD84AA6DB"), // ShortMsgKAT_256 Len = 1952, - ("724627916C50338643E6996F07877EAFD96BDF01DA7E991D4155B9BE1295EA7D21C9391F4C4A41C75F77E5D27389253393725F1427F57914B273AB862B9E31DABCE506E558720520D33352D119F699E784F9E548FF91BC35CA147042128709820D69A8287EA3257857615EB0321270E94B84F446942765CE882B191FAEE7E1C87E0F0BD4E0CD8A927703524B559B769CA4ECE1F6DBF313FDCF67C572EC4185C1A88E86EC11B6454B371980020F19633B6B95BD280E4FBCB0161E1A82470320CEC6ECFA25AC73D09F1536F286D3F9DACAFB2CD1D0CE72D64D197F5C7520B3CCB2FD74EB72664BA93853EF41EABF52F015DD591500D018DD162815CC993595B195", "EA0E416C0F7B4F11E3F00479FDDF954F2539E5E557753BD546F69EE375A5DE29"), // LongMsgKAT_256 Len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ongMsgKAT_256 Len = 16664 - ("7ADC0B6693E61C269F278E6944A5A2D8300981E40022F839AC644387BFAC9086650085C2CDC585FEA47B9D2E52D65A2B29A7DC370401EF5D60DD0D21F9E2B90FAE919319B14B8C5565B0423CEFB827D5F1203302A9D01523498A4DB10374", "4CC2AFF141987F4C2E683FA2DE30042BACDCD06087D7A7B014996E9CFEAA58CE"), // ShortMsgKAT_256 Len = 752 - ]; - for (input, expected_output) in test_vectors.iter() { - let input = Vec::from_hex(input).unwrap(); - let expected_output = Vec::from_hex(expected_output).unwrap(); - let output = keccak256(&black_box(input)); - if output != *expected_output { - panic!(); + let num_test_vectors: u32 = read(); + for _ in 0..num_test_vectors { + let input: Vec = read(); + let expected_output: Vec = read(); + let output = keccak256(black_box(&input)).to_vec(); + + if output != expected_output { + panic!( + "input: {:?}, expected_output: {:?}, output: {:?}", + input, expected_output, output + ); } } } diff --git a/guest-libs/keccak256/tests/test_vectors/LongMsgKAT_256.txt b/guest-libs/keccak256/tests/test_vectors/LongMsgKAT_256.txt new file mode 100755 index 0000000000..31720e5913 --- /dev/null +++ b/guest-libs/keccak256/tests/test_vectors/LongMsgKAT_256.txt @@ -0,0 +1,1543 @@ +# LongMsgKAT_256.txt +# Algorithm Name: Keccak +# Principal Submitter: The Keccak Team (Guido Bertoni, Joan Daemen, Michaël Peeters and Gilles Van Assche) + +Len = 2048 +Msg = 724627916C50338643E6996F07877EAFD96BDF01DA7E991D4155B9BE1295EA7D21C9391F4C4A41C75F77E5D27389253393725F1427F57914B273AB862B9E31DABCE506E558720520D33352D119F699E784F9E548FF91BC35CA147042128709820D69A8287EA3257857615EB0321270E94B84F446942765CE882B191FAEE7E1C87E0F0BD4E0CD8A927703524B559B769CA4ECE1F6DBF313FDCF67C572EC4185C1A88E86EC11B6454B371980020F19633B6B95BD280E4FBCB0161E1A82470320CEC6ECFA25AC73D09F1536F286D3F9DACAFB2CD1D0CE72D64D197F5C7520B3CCB2FD74EB72664BA93853EF41EABF52F015DD591500D018DD162815CC993595B195 +MD = EA0E416C0F7B4F11E3F00479FDDF954F2539E5E557753BD546F69EE375A5DE29 +Len = 2111 +Msg = 919FE5E7F35F64A7487649E564771DBBF10AE204ECC2181312D1A79FB579297C94F0DB9EAAE9E009A4F02057AF2C973C5DAFA7B60154371A5D2C8E992FB6429176F8424B1A866BC1D1BED00438E97FAB42040DCACDEF7CA9FC2033059B8898BB40CCFB2634B051797BDF3B915C503EC81839AD01E0F4F2F871EFF2008D40011730BE7A47888E7955A806876BE120CB0F3A139A3620154ECC6482A70F5629F6A9D3341BE6FBBF48E5AA0C53589A04F057DD44268AFFCABF75ADFC549F73F454264D46A98CCA80E3000C7446853DD5B430C9344E87E3230555B09FB3E7E64B5AD3989293AC0FEEC0E75F909696F028A5525D26DDEA5D2B2C813FB3613DFF38CE23209285CC77C60860 +MD = 6D0CE2D2E3AF33033616E384DCA4D44D742FF7FEFA4FF2C42EE9F1C338E89CDD +Len = 2174 +Msg = BD687B6D6684949FBD52A8196DF5D5927B403DEE88A47E4E4B52071BDDA6A6284A9EA1EB84950BA17A60277B0FEA83C930E5619D5A6D232901B9D3A696662C7FD5F1349B494BC166C67B717C06D03E9FB05DB9EE292D4792F459E0ACC08369E3D14684CFF388C940F30738FB71D97EFEB51C7DB553CB85B6FC18429815EC71420822151BB8F5135DD698EFE3D3118963EE194F94682DFA62EC9D3BCB5F826DA790779704DF2AC5C8A9FA2B50A42A87ED2FBADF1E1C8E55689531786A9858DE9E88009E56873FD2D431FCFC99B85574342DC7E78406678BDE94B9A06974DFF154EAC3BC7977AC7C123EBCDAC0641A69B792058BA373EDD1BA45E3339C2ABC032993B25F4E3BFA3D5FF620C621D94C40F8 +MD = 70C7A26DDF67A901DC137A757BCA5E6024F4C7C7151F1E60DB29DF9BF0DDD716 +Len = 2237 +Msg = D13409007A6B3242CBAD4CE01D9AED77EFEF0A7725B96A30097EA092FA1E49A136DE03F3F348464C9BEA033216F380440C7EC81E284738DCC640D485ED32F5D7DD1CF936C1677CBB3CDD8E0E001783FD5A3F388AE6EF7085FF9A22FA722C7FCCF4CDC239B200D5D11884B565D01C84E4D563C6623C241C5AE0812CE8F9201BBADE48198378A3E232EF3E10C03022620A266D0A346A6A22F202333A94D2CEF495DBA102B133B8237449C3350BF80EE51B6EE8A972CCFC3ED5FD7790444DA253922EEF6C611180F91DF1B6E58E843D318D94A958A017590B14D383C0F385F9CF2514E8AE1EA749795E10F991E3FB744C6030EF6B02989E8EFFBF8E8BF31FC39B692C517C7C012ECBD0E0785BDEF4801C4E036C98C6CD0C9328 +MD = 6821284A3084C3D2C3B344318DEA1F194D56F68306302311AA34BABC8B9C7E80 +Len = 2300 +Msg = 68F891C11459B2E9B71774E2B8A2A5C3C9CC36072E3498498496F1C7901684F3E9DACF13A3F1BAE22140DEE5253732E4D4196B534F675264B53D38659727797F0A18910CCB5B48FE2346C2E998B6537357AF8D15826FCB57BA804FE143E765F4680A0B28A9E3716A59ABC60EF253E357A4784FF1BE4680C82D797813CE50355D8FDB3C75936CC33E1717B99D9A8ADE9D0EA9172662B708EBCBC31C05064FE67B287C56D01C12411E9B890AD16238B36E192B15CD86D26F4EFDE5B523D71656F5CEA6CA73BDC04FEB973D303BBAF4C0264761092E23220CEB8359FC91C1D918FB3F32DBBA92DEAC1C71DA8BC4BE806803F6E7970FA64721C645EED4C2BED7EEFA2B720931FDBD6C67B83756B1CE51C51F839C250AD900B9D49FE5188FC4A2B5D0 +MD = 10BC8C24689934886934215778697A9536098474DC6F0330512720FB9ED54442 +Len = 2363 +Msg = 7D9222C58DC49F14BFD7198A9A1C338D17201C007822A91DCD262860364CA1DA8C0056033EB58E406E36D5A4F6F7E9D98BE57126C9FE7676B58FDF0F9899432FF78DE2AB65C9000071EBA6967123F97BA3DC1F3825D3C8C5148EAD7AEF0334F40CB0F6B982CB7C99CA39E1B4B2E3A3541683D1EC5560466F52175518390D38C7461C116DB2D56EF913784D2E8B20959BBD6F8F3282C597D94A1EDBFA8F25089E9D2E8DC465EAD90FA23E4388BD6BAFE22632749B7AAEA53D5CBCF9678227ADC3F4109F1849AC2539B6F2B25B4D8EDAB41E8BFCFC337728DC48A8EA5119115FC1B133300D68231C96A9D518F6DC3CA51581309C53F49510FE18F608A215069D41F2CFC84E53A9347FD723DFF9D3F5006F7C0B18441A29BDEF7725920260B1613C6532A0A994B488E0 +MD = 90CCD013F7105C658B92726B68E5BEE025A18D91AB72E60A19061C24563FD767 +Len = 2426 +Msg = FC447A550FC565F964337521DBD6481FF6C4FEC25A2BC946230C0021570E75B0E3D50320AB24C4949CB4EA7ED6D14D10E1EB9CB4116461A743D49F337597F12D09945285647B249A2AE3EBF69F1FC62A36532B2FC89ECED5B48AC27A0E18AF8B0F023BE5C00FF0BF8C16F412B34D4AE9ECD2963583FA268ED439B4640FFCC57384EF066362E23D2F0712F9658CB7B7F56F548C4A3C7DB51D8FF4430D14CE1042221254CAA4BF009B197E6F74B42067E95E42D6C8F2D37AA5522F5594D61745BA28C8F302E007316282985730FBCB8BDAB0C5A3693BEEC32C0D57AD20D3394B7AC72831FF5DDFC8208E09057AB9E9EE2FAC208E9FCB6D0B567C4DDED41ED286678DB3860B230C9A52C577867EC35A17EF902E258CD8314F36875D97543088679415FD0D7C2A9CB6CAEE76A2A1DC294700 +MD = 76D2DDF27334E732833109F2C15A4C7CA201F923E8D1A209FE47C33D6B198B6E +Len = 2489 +Msg = 3F989C5FAAB635E462C4181FE623B8205FEBCA482B0613B8CB702D0C47CABC705DA23CD238FEAE5A79B3D630C22F12FCB845FC633882BC7A46058F945E6376A5DF954953A82D5C6723156BE49438431529C9ED7A5ABC0E251EC9746F34196BFCB64850CDD962B4D4C0C37DFD7DEB4DADF6FA98F727DBE430A232BE68161A834100BF81412B9BC4B34C7E1FC4CA216A7A04E23B5A1E0AFF6967465E8FEB63A7B450026FB944C62ADA108A15FFF01FFB872925EE97EA314D84245E31745C7A3D3C83A59BD6F38205812B5CBB141833D381CA4DD3B261DAF19323BB790D0DE8F7EF8A28D1F2131B92DFA724B76BF6162872CFBAB0E3D426741F8946CE449787896308A0DA3E5B5F087E96470A6990681F10F37DBDD10A799032CEAA9CDF8DC0DE302E98980718C3F1C7D950A9D37216A3686211A658312B3300 +MD = 906A884702E71B329C84A34198F44B96B9EC72D778646B7DE895635BA706D36C +Len = 2552 +Msg = 3139840B8AD4BCD39092916FD9D01798FF5AA1E48F34702C72DFE74B12E98A114E318CDD2D47A9C320FFF908A8DBC2A5B1D87267C8E983829861A567558B37B292D4575E200DE9F1DE45755FAFF9EFAE34964E4336C259F1E66599A7C904EC02539F1A8EAB8706E0B4F48F72FEC2794909EE4A7B092D6061C74481C9E21B9332DC7C6E482D7F9CC3210B38A6F88F7918C2D8C55E64A428CE2B68FD07AB572A8B0A2388664F99489F04EB54DF1376271810E0E7BCE396F52807710E0DEA94EB49F4B367271260C3456B9818FC7A72234E6BF2205FF6A36546205015EBD7D8C2527AA430F58E0E8AC97A7B6B793CD403D517D66295F37A34D0B7D2FA7BC345AC04CA1E266480DEEC39F5C88641C9DC0BD1358158FDECDD96685BBBB5C1FE5EA89D2CB4A9D5D12BB8C893281FF38E87D6B4841F0650092D447E013F20EA934E18 +MD = 59E904B2AA0CCBF2A9D127446F113B7CC3D07B970E07A322325ECEE66AE0C9CA +Len = 2615 +Msg = EEDF03E5D5ED60D8D3C61604FDC305A752F5E0D08E394D4CAE31E23905E4D3261624F442DE4ABB9FF415B4807A301CC32332DF9BBE2B680B884FF13050FC862302A46D6036DC80D4D2EFB4C0133743A3700E5A089C1F38AA01DE8EB731DA7CAA7ADD9B6E1DCF6CA7DAD697D3741824D000A374A7E68494E4671EF84CA5F02FC5461762043F0B4A81E4EF845C2B8AB92DDD52F493C5DFA37F5D64AB49546AE281914899B1F5E55F982236428225AA3C2E7989FE4B0E64F79D1B7B1803F2B7548BCBF6D996E51533AFFF1AD11938A0ABA320B1B5E0832CF0C9DAA86FC57E2D89C0225A398CD06A75B321EE8DD8EDC3E55CE01845D2B4B24DB7E058E9151105C46942F9FE206ABF0E4F9FB1C432A1D48D0693B3487285BD956E41ACA8E4DACF3483B81443743F23F209932891DCAB19F9969F9A60B4D0F10CE884464EC2FD0F8C45FD26437FCA3C4C +MD = A25DDA4618325B88593E98CDE7C845056AB938A3E293E60AFC2FB8283F05DB9B +Len = 2678 +Msg = EFEBFAD8C1E5AD7909FBA16E59E3B1C2F11A33F86E5D74F7D304EB0882DF9B9693413CFB990BC71A8BCAEA4298AD75B9E92F2FE722D200FF3184BEB08C16979DEB19924DC8B94E1989FFA0E617359E2DF6578384B992CE3CF0C9525D2F2B3E40F314F7B094AFA5C81E1AD9C08F19C5B7563518F710A0A78DB40BC98863645889EF1967D6885F8DD61CC678559D9696220AF7BB644AE387679E9FA23D7E313102F85CF81E9F4F9F18D23CCF4B579B25FAE558101B51998B7DBA4CE1AEDA644E3C8EF52C7BFBDA575A66D2D77015D64C99A49E8CFAF179F54E843C754214EA63CE2E005AC0E86A6EFA98762B1CDCBECE2AABC46EF58A16448E21D36FF8FE70D37EF2C0460CE4BBE33C7DD0C5764063D4A5D55DE2CBEF9EF02FE113D51EE3D80AFC9D1862C034A89E99639D1946EB9E564FBBAAF11A8E28A772BA97ABFF7CD16ED8049F31226AA1691E07E76E94C27718 +MD = D1FE63096B01ECFAF870556022B7F75E80AE7EF533D0DE37C433E778D78027F9 +Len = 2741 +Msg = 96E80F323139C4D5656B9F390E59D06DBA5380EC91657CE996473A3AADCD5FC54EAF8EDE51BC6DA0CBB1463C7FD834058477B9C16DB2E861369DC123CD9433D354E61EB543BEC5BB6CC4685B5FE55B5ABDDA34DCF84F26312AC322D9081B372678506DD293DECFD9141E08F9C87E30609A996733BEAC8F426D1D1D0D51E636FE5644C64C0D2CCBB883311FBD9270A0CA399EC844FC5D86BC259565D6BB963FF8686AF002E1A3F6E4ADA27BF9AB22CED61D3AEA767DFA553DCECA77A06B1636A98C84BD60BBF677B1E518F4FB1EE897778E339F11A84E0C5D3B6A6DEF10E90D335ABC036B22200216E52D85BC8416E971D5B834EFECBBCE67AF4E896D20AA821329835473EAEE357B7DC50BA1DD47B9FD8CFB98EB8EBA1236D21368E8D118E7DB080B974BE33152CB71E8702779026630B5F8F435435B96A01514417EB6FD93B418706C62C5EAFB6ECD42481900E693609C014B2721FD88 +MD = 00706222D2341CCAF0BF00DF30385986291271B6368E542E7F556CBADE858D8F +Len = 2804 +Msg = D740CE55B0E86CF8A22D597CCF4A0CBE14AAE4696F07B8659C20B884BFC8B37984972C9A29DBBFA5DBA4F1691B66963CFABF07919F7728E305CC924E6F49385740414F4E89B5E398532C3CD20B586A50F6873D09E4CE9F7ACA4E61EE718CF2D21744A7163A978FC2169031C2080CDEDAAF4E35A70A4DD352E48DD582810EFDB5E225CAB1BED39769382FECA88A4E20F3AA229EB4F42DD425A8BCAD9526B1451978ADE7493E0FC3D387A09C27550DB88FF0ACB88A2B00E61E0CCCF210AF57CFD545331A66E55404FF353F3117C1D2DDA67709732F66869FF8B1DA3ECFF2898BCEAE360D9BA63B90A2BA2FF6EF64BCB3AC96FFA2B0D3077A8FE3336791F86394F5476869D5BA630386355B856B1BFF69328164B83FFC305C639597662294D2CCF1A04A4EAA1B1CAE0B73253BA8585AA9EF98517E154391D10226D4677BAFF84F5C81253B94EB5283A68789D1BA75C9574AECB7AE77C42AB39171AF7D9B8DC630 +MD = B74A8A6D620EA73EF1444130142EC60F7CDBB0509B2BCAB2BE5793A41AC46E7F +Len = 2867 +Msg = 7BC6030249D4F304CA26AD5F6CB11A137E7E3FBE0E7B5964DB2CCDEC90DD0D72007307C0C5C763582CDE75126F578B8C84E2CCB397E18E671D80E7DD4C962667D9CD7E35BD00AA35E78BA48136923550D9A74DFFF21C66519DA4EE4408290FB9DFE6D9AFAB585C8E3BE153F3A0D582013A26F527630A99CCB3D98F1775981B7F5CCC0E06BF6CEF1FB7E824C25EB685BA7B635DCA0C3E7F707EC05566378321F72C807D9E7B6298F9979BAB6263DB4CDB69C8351532B5621529CE758358781F52A1392F1FC0C3869B195BAC66F0DE146C71EB22825485B0412ED2D6E04E2207584F327D90BC7E7A0149904F9BF0C5A12F03AF2445A2E0C81CA302CE7F7DDA7C1241EE4241F8000DDB5C3A7FC7F53E6647C03775E4953453218F426D1E1255E2C160C6015FF17AC8F165DDF4246AE7ABAE4F1A8E5068158F98D9E01858C528A40BE36DC1F7EBB71BD36429A86B2F16C795F62D8A8DA93DB774996FF031812C8C5DE23343393C19A0 +MD = 60C139AA0B49F58F187EC1DA7B1C96053E2B7D739457649E7D7474C0E76B26FB +Len = 2930 +Msg = 8A84D3C4157E9D3BA7C3F06617398A8F9F14A29658BF07FAD9B1857DA8C48841922D98765852DD6D23E0206E79F516F0A727EFE27EA654950B06116BACF707E6D533C52F2357C05C5E633AC0C65BAE4A3314F5AF5068F7F00CA69D16373B1D13F4F11A327032A7BEC4E65B77182195D17CFFE718CCC801396054419F1A3356CE846DE55E76F8E8DFE2C14CFFFA0DBE6E34495AA5D27382830715D0739446D209D88AD28909BB91ACAA1059203DE1AE8F374B325B83A84C7F57B1CBDEEA408963C6FF404F3B6B00025538BE3A664A470A36FECC108A4CD45158EEC18F4CB27F40ABEA829E6EE1B8073BA9A837EF955654FC15D03B23CE91A6D36B5EF776E5DDD4AB47CC30637B952D49EB6019D8B1363ED64A56C783214DCD1F6F51AE2CF6431DB7B58E77A5D05EC5E559973C1FE5C61729FC1056C1AD1372C1FB292867FE65FE93836ACE2199D0369CC98F840987199B22CFECF21F9AA21B9FCCD50912DBA6319612D2D61B1FA1DEEFE78D54BEC640 +MD = D104F4CDA812E4BFDA132CBAF921D53884E353D0BB38C4E14809A54C7E16E124 +Len = 2993 +Msg = 81A2A2A5CAFA219CBE3EDDC4FB35BD2A39AF18F5D2619D69443DEBA137B30497F38416C0484E505C438459AE204520C9C8EBD2D43EF36F35760C5026AA58AFE09A1E36F37F8A5F7366E132DE069DE3164FB0C46B157C447E26713AD2BC14DDD1B92D258AED7B876EF45E16D4A9AE7BF4AFCAF1EDAAB905B520C52A8A6D2DAFC4D624C64EF4D7A8BB34478CFC40FE56B6FB5EBF39E677040738A1BF30378A43BEDAD81A9CB78425EA699A3597496F2D1D71D550D787C1CFE7A23BC1FAFBAA684B20779DE282BF7E9A604A9CD4412E36CE5C8842093C8836557046EC164982663B2EE4AE9CEB29D8598F6FD29811E4AB90C47B85BF3F9CFBC9F885D6F1C7AF235730D48540547847F4AB3F02157F48F69481C34F12DD01E1CA39A62E8AB7CA69D6422C54A2E14A5D238733B3156D7423C731E50C99979D1F8CE742933E7B26387F56989F91246215224FBC16375B9D464D16E35766C23464F18F8A6E705919E3E3C3BBFFF4EF14D7ECE68F5224A45D3EC90A2F1CACC3AE00 +MD = 02A7E231935565D9C1B6A009CB014A83784B76097DD29F6E3D5EF6C3E34F2C08 +Len = 3056 +Msg = 023D91AC532601C7CA3942D62827566D9268BB4276FCAA1AE927693A6961652676DBA09219A01B3D5ADFA12547A946E78F3C5C62DD880B02D2EEEB4B96636529C6B01120B23EFC49CCFB36B8497CD19767B53710A636683BC5E0E5C9534CFC004691E87D1BEE39B86B953572927BD668620EAB87836D9F3F8F28ACE41150776C0BC6657178EBF297FE1F7214EDD9F215FFB491B681B06AC2032D35E6FDF832A8B06056DA70D77F1E9B4D26AE712D8523C86F79250718405F91B0A87C725F2D3F52088965F887D8CF87206DFDE422386E58EDDA34DDE2783B3049B86917B4628027A05D4D1F429D2B49C4B1C898DDDCB82F343E145596DE11A54182F39F4718ECAE8F506BD9739F5CD5D5686D7FEFC834514CD1B2C91C33B381B45E2E5335D7A8720A8F17AFC8C2CB2BD88B14AA2DCA099B00AA575D0A0CCF099CDEC4870FB710D2680E60C48BFC291FF0CEF2EEBF9B36902E9FBA8C889BF6B4B9F5CE53A19B0D9399CD19D61BD08C0C2EC25E099959848E6A550CA7137B63F43138D7B651 +MD = 6C2A841318066B90A9604D0C8ECCB2986B84A0C8675CD243E96957D26E9C1CFD +Len = 3119 +Msg = 4502421C8F0CD496CA17736732B945C0CA7375933ECF7BE85A12846FE750B5AD6589082A161FB30D4E8B6361D55CC4B4D788D8B69A913914191CE25B7F2DE37D10C39B48709C779CB5A598551D6633C32F7B7E1D86BA59D9CB61CE00507456C30C2888212C40A1035CC2A107B1CCF6D9175AF5DBB3B2FC14ECB7A4B4479225E133E9DDADA4862C4E9CB8C02911567B0A9B62A4EA0781482F2ECC0EBA32A934AA8B748022D243121420C288CD5B678D8D8A1BF70DFDEBD8FA6F2796E4D9DFFD67BEAFCF16804B170B42C0523DEDC791F5C92C24976C0B3BC4916283D979F34E42B3A88687B490D45A60F37677EA2339FE3AC629051F2DDAEDA5D5EF0EA895157010875FD830D95D1CAF0D6FEB32F7C885392FE631262315FC01C95C8E48590B12852CCC735B73EA3DA5F667419206707DA444A610FB02B697EED3B0E10ABAEBD0BF2B76D4266F9AE4A75036DAD91AEF3212785A188133EFB26A72EB7AF84BF2161FF609593C65570AE8D24EC0426387ECB522824AE8D9BCDF90C363DFB2952C7236154E02A068 +MD = 98B1623728F17FDBB13302D9A3E1BFE368937E001C41F5237A1E52693788244B +Len = 3182 +Msg = 533C539FB585F9481E6F244F5234F35AEB4FEFC81B2CD97DCF30982AD942B8CF1DDB83063ECD6EC07510B34CBBCB8BFE44D13C915BD0EA0F35934C421E5E5DE9DB6839E725807F5729C04F4DFC8A2F912B9B62DF60E6E8F694456CC8854CD4C5BEFADD8524D0178BCC140353E672F0D5C815FE15F7D95DA6BBDE73D4275AE20958B3F7AF17933B90779E52C781899A67534BFF64434216787A5E74D56AF653AF2A2DA9EF4A56D5DDF92F8237C941CF18568BEC316B40631E9E85565EA17B184C463D23652AB3E860D212D51A2DA80BE5C7D1BB654CCAEF10D926CC2478CC33E93D45E9CB975B012D8B74A6795BD605F323EA1BA1CE9678B2FC05944DA87E036D10E60591B9CEDDE23CB83B1E9B1D02E61F19FCD54E02FD22809B960A51D238B6A76204CFF6E6F7482CDD4A17B9ED7B038517B0528A163E908843643D7DB9DAE6543C860CCDA905E1EEB5EB2A7E1418AA955DFD6FBEC4E195639A8A1374EF89EB4B7BECA4F796D7F558815AB0D99150EA5CC19A0822F45A436DDB5128EA00814E3C8055676D4D3256C24ACBFEC4B4 +MD = A20045D7AD3B869AF477B7CB2A9B6FAC3FEA8FF44F59DD1BA7880169E2231DFE +Len = 3245 +Msg = F470F22F4B441B26956FC237E7D9F36A176ED145243EAB7FE0B8B5B99A65ABE9BF7E43E4627DC3920D5567BB52C35BB2E59580A43270AA06FD4B9C901D3A3C15540ABC4A19385EC19D16F5CA1202B9A5B8B5E38CF7336385E8BE8BDD3CE4AD660A112F407FD257F054BCEBB75F26E601461A529C3A21E2AAE71F3D8234E7B1F0373C8FD1738632904F8B5F6DB5FBA3DA09FD9B49F06EEBFD3366E8980E3E179F08FE742453DFF8848CE37E84D0629A4C1FEB9B37EB125D598CD1EFA2FA47129449521C7259D0D420FA7B11545633E056AEFE805D2102D4508CC9A4125B1281870D12821ED98DF16ED1E43E9B699FB9245EA95E459C27784B4A5102DF7E7CB2D2E5CB1B82F5852E4D468DB5858332A2089DB423A4F15EFE773CCC4853312425F15D726EB0897E137AB1B669CE8A2727140247DCD8B639FB9212AD49F52378B6A8C77C1A938E80ADDBD331DB8A7675235FE02AC891B54AFBBEB8763D902C58D88E4DFE924351A145B0735F2A9A85EC6E8284A78B6E9316BD2760F8C4FDBC4DB88ABD0AA7B69320866D1255C22BF4C7D9ED39063AE25F60 +MD = 060E6F536DC02B5D0F0A59D8D66B2D0961CD832264CF5EAB9BA1B84E6B9DAB3E +Len = 3308 +Msg = 79A1ED96E3D59287D620388403AC2B41F054DCAD59976422C61BB06739294589A02BFE7DF658EDADB6E2AC7F9556AF984E093795AC568AF34EF516C3ADFA4060BA183A64267BC4AA778F1057E96FAF0E9FE451946166744F5C137D29CC665E03849162FCB1AC6A90241CD22A2AFF14F0D936931401F9171C55598C98316B006E29BE2F3F6C6C28607CF0DD05E7DC6F4499F84502F113097692A46B7E88D173A3CEF08A05B40BC9018404EA67C94997AD686F068C5F925DFFAB8C2E548EA98E1BCAFD1A7919B3287623E77FCFB1751BF4516C5F811C13E39B7C293E58110C343E75DC9E17C151528D280217BAA6B69F955D8316C97D10E553A4CEAEE68B4A74F9621A7EFDD222FE3CD061AB3B53FFE28E060ECFB534D44BA95DE4C9D9554008A495D40FFF3454307E8066E4F01D4E16A4D33D728958110A82FF88CB404A2A378D1C1A5F02C71914CA9BC9A597036F8FCFCC86DE5158951F5E28E9F7500C962C5C3D754DE89EFF234CE98C993D7E8D2CD9EA0319ACEA05FA8505A43015A305AA49E881FDC4785A762858EC90C665F03764643ED9DEE1BF5BB90B6DCF8D9BF0 +MD = 32020F5EE13B71FA9FCFD60F963FAE5368F547C0F9F3FB193F05E0F7D32C5D0F +Len = 3371 +Msg = ADA660319F056F7CC74116E2DB8AD193440D7DA8BB4DFA5E9FAC10EF695F7692C629C1104DE125087CBB03D4260F7ABF0177084E947E7B7CFE1245F1BC9999AC4084B6B4C52E5D349516475C565BCD7D507962BB3BD372BE1CD35C1BF3C500053365B87C6ACF98D94FD57D8F9E03B1591737AEC61EFD449A75E42A49CF20771CD259B189B881585D956AA1FDED4ACB77158D20E8F6DD60703566A49AE6FCAF4423EB2FB0F893ADCC7ED0C5C65ECB0D58CE9E6CCCBFEB90EAC4AD3D21C94452699245FE8792FBE884CC0545DAEAC5A30AF3C0DD05C2427D8108DAD035501CDBB46DDBDA25A0EE47EF8B21956D6F2560E3E2E220EED696F66995719B2A6D82255057FABAE99C08576CBB38E1F29038CFF04E46794AE1BB2693AFC6599EB675EEFAB808052A3ACF3CF6FEE0CD97CCBBDD66773F41F9FC3C08365CE379E258A667DB7D8E903F009CFAC7A448B8069E9698B1F0F21A60C1CBF59A709D6CE879817EBDF4F4C12271F40509051DA9D85585E1FFC5EAEEA08E3B65F2494559BB36B2EBD9242E554C45EED28F3B68B7FBEF5B4BB060F51A1CA24BC180B261A9F773872199D1EE71159880 +MD = 6166BB935317CD8B4F15B3D11BC3A7155ADAE626174ADEA7790A90854A9720E1 +Len = 3434 +Msg = BE58A686D280E96DFB0E216A4ABEFDDD56686F3C14E625373CC21A7DD30901C4C75C1D2B90D9FE54DA197DB88AC7AB6F1EBA8602C7947BF94C1A7A1251FCC1EE4659C03E6027BE9D521D9DE96FAB9D67C9A273979E6866CC9BCC8199C4CB0357E4B9F7BE376C2B7DB6D2D8057FC22066C9DC764298E3DE45AE72C85EA6EA44742887136FF964AB092C113011C8DF7A8B6C5D14F68704E31F4681B620FA9B97228D9F2A34F5BA7BF8848418E1B92823F470017AA07CE483BC5735CA2D5D54FA09A75018097CD150E42E3C1B14DE93FE4BDA4332A681B0464CEB59AF7A13DD293AE080628197199E19DC14B5B73B06296DF26F0343D3E45B29453048BDC9B5B5CEAC44748E867FD4B307656DA29BAB874CFAAD603F29825E041BC6C2FED82247A3EAA3A63306E7081653C7AE2E3BAE8B5F034794DB9C0A7B1A7F94BE84FB7375BDC625C9BDC55D9AD010F01C72D05D8797F13EC58331CF56E3652664B7CE20F7312D3736B6B2B5CA5F4BFF2AE95BDB247FFFCC8DBEAF1EBF15D297DF6D817AB48AB090E3AF98618514EB27E61A2C776E343D9FA92A0129351B2F904161DF75052E0AEDB5010CFBDE0D4C1849EDCCC0 +MD = EC2C954EE7951DED13BAF75E12AD58960708F4D4E3593BF06A80C0A6CCFE70F6 +Len = 3497 +Msg = 8B3AEB16A108788E8BC47818832FC91C46A6F5A51C59DF9EE67E17209D1295772FDAD6E111BB3806948137E392EA3847F6DDB06CA63879A64868113FCE622849864B57C63EB7D56D62915E400B65B9154B7DA537FF164A5C3483D28F5C4D3ED9A86F706FE277E9BF3B9CD63B288D406B321CF865D65C284559F072435EC829A2DD1F0F4CC0CDB9BED219CBF13A1244C4970655924EA7D9DDC3BA4F522EF19812F7BAF22926F52D69C80B6C32EF9585F3834A75DBC3B3F1CC0F709F7A70C82FFEF75F6328928FD07F73920BDA9525436F0C8D01B1D65304908E22B123A87B835C6B5F9821CC579E98BEA11B231B7423E8446D459B316ED6B066C2E2A2082AA35AAED9A0A267F56B9AE162A5C8691D15782996715DF16E2E32C179E4943AB8B07387BDA3C49ACFE7E825944DBD7377A78F8EFD4827A158EE197B3B46FD2FE6E1F8150B99EE03A85EE408B3779B15903D3B39C8B02B04D1D297DB594B2D2B9F99D54C4D978B97EFFFC099B458C875A949C0544E135335B98A2B5974B5FDBE5BF640A1E7BA45D4AE07AEDE1BCE53040F33729AEFB53E98F7A31A727E2ECD3CA7693067D4DF8E151D2FC465E039DF762123DCA150DC6BCF00 +MD = 8A8D9805AC75CEE22C9A7688A14A45B3438D2954366B0813159BEDFBE8C6CDBE +Len = 3560 +Msg = 20FF454369A5D05B81A78F3DB05819FEA9B08C2384F75CB0AB6AA115DD690DA3131874A1CA8F708AD1519EA952C1E249CB540D196392C79E87755424FEE7C890808C562722359EEA52E8A12FBBB969DD7961D2BA52037493755A5FA04F0D50A1AA26C9B44148C0D3B94D1C4A59A31ACA15AE8BD44ACB7833D8E91C4B86FA3135A423387B8151B4133ED23F6D7187B50EC2204AD901AD74D396E44274E0ECAFAAE17B3B9085E22260B35CA53B15CC52ABBA758AF6798FBD04ECEECED648F3AF4FDB3DED7557A9A5CFB7382612A8A8F3F45947D1A29CE29072928EC193CA25D51071BD5E1984ECF402F306EA762F0F25282F5296D997658BE3F983696FFA6D095C6369B4DAF79E9A5D3136229128F8EB63C12B9E9FA78AFF7A3E9E19A62022493CD136DEFBB5BB7BA1B938F367FD2F63EB5CA76C0B0FF21B9E36C3F07230CF3C3074E5DA587040A76975D7E39F4494ACE5486FCBF380AB7558C4FE89656335B82E4DB8659509EAB46A19613126E594042732DD4C411F41AA8CDEAC71C0FB40A94E6DA558C05E77B6182806F26D9AFDF3DA00C69419222C8186A6EFAD600B410E6CE2F2A797E49DC1F135319801FA6F396B06F975E2A190A023E474B618E7 +MD = 0EC8D9D20DDF0A7B0251E941A7261B557507FF6287B504362A8F1734C5A91012 +Len = 3623 +Msg = A91F9FFB50123C28AC06406A16D4551F546E68FD01E14713AC3F87E689BA332F36B4718DCBDED83617E1F4B33B02210F23BE3431FC319BFFCCDF8896C02AADBB3C8562CB7C243ABB77B8869F110EF49ABCD171AD7C5745186520CA67BB3FC329004C25A79A8247C310E0BB3B7A7A7FADF9FDC836D5F42EC111DBA810B433655C428BDC6226AD878AE8A78EBACDDA63BFABCC06A0F900BCD1640F44CC33925E90C0CECE8B6288E16805D6C9033F77CA6B9FDABB7D02626BCCFF8F6761E212361592FA527352A9983B6D9CC9F2516B78C6ED9399DC10115019EDFAC04457E5088C67630CD3F14E8F313F0C38C08C5F46F93E28712DC0D8AFD7B71B31BB3776331DC8BB5551B8D853D07DCFB9C93AE2B3E6C0719876EC38F73C2D43F6D10A726827F0998D38DBCC44D416712BCD749B16A5235CF5AFAD24E3FFF4A4C185D40752553ADDA4F2E5BE02836908F1235F3C59F99D07F92BBCECBE8EE690FBEF1047B08D1CD479627514EAE7B2BDBFBE52B87403E9D38322CC3DCDCDD8457676546E5D13775AF112B853ED3DBBE30215CEBCC06C5D02780C6A6A583E0BC9D482B3595042262C069C980F96AB49D3610EB5B18D9371CAA228FF7A435F6CA05FE3804FD29337A0A3CF3A +MD = 9C134B2F94BB4E991594FE6942D1C72B9CD5C9305FD32FC77D24B1B2E8FE561F +Len = 3686 +Msg = DAB63B4D897BD2EDD4F4D5F607A5E37B6ED77D5602914E48BFF6EEA00E24B03DC9E7B5B6E9DF886DFB8B3E73C564B2DD8B3AD3C1D13432B1A51D88863E454A557F9C93BC2B0C0B9D53AC8C07B03CD6E4874B2BE11249E0FD7B952F44F3754CC29F5CCEA0EBBD7A65C9CC904FF797AF7089AC2C74DF84A3AD0EAED0B93CB4848366D67C3602572B2619632224DAAD4F186742481FECD180B7EFCB836BB09339E94CE37D395DF9C73324B6B346AB16730A0DE39A0C5D2142FF02E5074A1518E46C1483B61747E29E9096BBEEDDBA6172743174795B3E57D30C043C611CACD8FCCAC817034118F6969BCC496356F2E89999333ADD4F3155B727D0D5D8C44712A33EC867AA43D80095EE7F9B27E2BF719D989E2678F0CD08DF0A8C68BED11A191351C52AEA1288B99DC98768A1D97E6C183662D292CEC85C239F138A926FEC847A00EC2354463A4960DA4A31A534E215B35DB99CF66DCABF04C0ACC2C0F3AC656AB8F831D699EF6BCD5F9A9FACDC140A32C251A52B3070FE2A348623CBE2CC2F5952A31990E5E299F3FFE140FFE58FBB533B8B628D660DA555D7C0EDE73E412D3C9FC0E037FAB1DD27E67752E654F2F1C11A2490D473FE2F6659BECFE52108D0081EAAEA295B12ADE031D7BBF3447C +MD = F2A5AF5314B1765C1A529ACA0559C7BE711B435297CB1163B215F783F254464F +Len = 3749 +Msg = 32C5008C09ACFB78F3E150E26F4C2CE916BD133064E386D5E5D6CCDD9E28EBDFC9BB77F9918B7983395DD9D12D1A5DC50AECAE8CB52A7D76620822C729339F5FBF1C1E0737885865756B814761A21D530A84A90761A7EE026A5AE9CBD8D2AE2401336943706A435761C6AF8DB6C87586B4B86AA1279E48CEC629EA913FB82948FCE13428BE2EC7EA1094BA1BFC7203623941B1B803EE695B7473E049F7DFD196784EB2DD6E59D1A681CDC94B3783E12E6DD73D52958E4D485FBD120752308AB23B5E1DB6B7E4F17BE54AE11AB6EC7A11F85B3AC6EB2E1E122689AAAC751046FCE444DF8EA943E8CF081AF283AB3CBE1EBFAAC9C20C2C138D590B628F820435EA8F208A2462345DF3F6CA0534751F88AE0FE4F5996AB3E5585F30235AB0AC05714E769707A318558C707C3F1E71A26AE690F9F6FD7A0E7E587694B3FFDBF2CAA3636D81149C8CFD04BAC91841183400ED195F64D0A2FE259ABEE593ADC15207BDD84E7CA355B42D1C7C9AD3C1CADF22FAFFA81AD5E0BCAA0EECDC3A8ABAAC94CD2AB61C77EDFD16769181D84C925991BFCB232E2095A1110DB2DFEFD1341AB37CCF5DC68BFC5DCB90BF4124F63675B18E6886E22E29AE89D483C6AA462BFB4F81D013D8AD1E423FDD5FD97F9C7A399143F190AE6CF0 +MD = F55AFAC58B42061CF3574759DD360B5E3C490126C022386DBC3909845F88AD6B +Len = 3812 +Msg = E555EFDF6F55CA69684C5F82213C40CEA5A7695BF48926E7CC162F8D6FF5667A098B241F337C7FEC1C0FF2788B2A4FAA11044F080722C21EF0D7EB33575147A481E352601099D0B69D8082C3F4A206AE01537E6AF92383C62BE5564B47486A265CFC626834870E5D73982E11EEE6C518093C59AFA526A22E811DE395B9E1A20495288BFE4E1B672BD63E0B44089502295C1E6DF36134771838BF676AB5C6C4D7B829ABA2CC701706B8AA46C663A5B855E3631EF0DA9AAD5A512E8AB1F012F939DC8F5F19E95CB6B2E578273CDA5D0AE5C994BAB573A8F1595959B37DBBCE6039DFA5F3042BF27D1D03AE649C64CB0A4E45F75F3F2352D236EF602C722BDA347D18AECF4FBA832CEDE5068AC451F64AFF13A50EF98BD9B97BAA815AF07B01EA7EDE2EB2099C86E31882EAA2E16682270D2CA1BFB75732EAE735DAA0822EECF7996BE501EB0D4CD394A5F134B8B573228F162511B4C52F3CAFC33061DE4CDA191F7AE8A0A3C92AB7265923445650ACBB60F8C03D31EC04739998ABC24D8F37847E26A9D8F3CA86B45EA4E5DF396C4AD19862819EE8CF701466FD98C866A9C5FEE59F4229EEE0EF06583B005FAAF656351F42378BA8C8A705A526DE1C55741EA79289E5F476497A2E92B875F87E50C6C9A8B6B620D548D3C26CB47AC1CFE0 +MD = 83365CA8871C77928FEF1D60FBE54949154308B16B2B7D6862B49EC67945A248 +Len = 3875 +Msg = A6F67243B89206299B833F810220E19D4599C310F51DBB8F1F1E81B312D77D52CB6F52500BD54CBFBC5684D39456799FA4134EFEE2BF3852C2C087ACCF67B06670BE83D360BBB9AE89A81041F5BD33A7A6267DBD8E135FC108FCDEEDE3A79C1AED141896278735A6114096D7AC265AB6A921E42058F1A4581982965876AEB4857F669B1D85FDD143D4216610B669DDE75C5F112B68A39C68D99CA45D3A21EB7627DD5E2D7F3A8B98C694215756DB73C06AC33124859856C046DB655C2A33B3E711F307454CB344A54B18A60B9A2315EE29DFF96E2EBC0FAE0E287EE373A84963A577C9D81F944916295013350983ECE1A342DC87EF8341D1006A8232F0D08B16C1B017B2A2F14B7AF0A2A9F039B90169622F7F2E60F1E66A6F59105996390EE628C5103E0319F26E21B238FEAF3CF07B38938339F9E3F437F994580DACA9069907049000C046AC8B4C40DF9E3BF14A2A04A9FAC617C5988F4970A6FB34736916D2044A130D22705404449EC24A43C49B821CED684DE0D9D6B92D78A27D668A9EE83B931D7A88F888538D2DF9588B4E6A2B927A2A80D70B0B9EDF57273BB85E597E34B3999BE1EFFD77C39A3B5617865DF75395466C53099F344259BEEB7446D9CB3850661F3EF4DD84A3978E39F672EAE9BD949E214130CF799868DDA74823171A2F350840 +MD = AECFC6FAA38610EB76EDD0498F1FE65F2640CDC49BE49B32F20E6C9438B3B3B8 +Len = 3938 +Msg = B0C099745EE2B37A0E6441E8A7BDE912B4DAE9273594644D5C71F68F8CDFAE0C27FD4F26104BFCC878B51CF31894F477268B4C2233CDE5C0FEC8EA78B9493C9A6306C610C2F37B3FC8F561BD9B2E9B931B04021ED8FB6343F990E1D0451D3E588C065713A0BA3E62A747A597FF6573AC6A3986B0E13396612A0884A23ED6B53D039FCEAD4E7BD62141B54652803A1A4CDCF7125A8CA1DB53CCDE72B3D26D825C701997DAF6F2FCF9AB01D5D4799BB2FCAA2AD64E22D760BD197FD17A66168CDE8198B40928453BD653DB90E1CDD48497D6F7C5FFFBFA2BDF99DF277709D1E72A4C3A7C7E0DCD4E76E9292D90600D5E45F1B8D681C7F04B993BB7CD2CAB47AB3E9072F9DE3A9F5A630982BEE13A665D211D376BD4B43A4FDDE542A1793C1C8586675766872DF8438FFFBEB00FC504A91873AD04DA5392F0E4428932F3A1A497E1F21CB13D017287DEA816E79E3C6A8CB0F4402FEAE129E8FC80CECBCD17BF60F6C79E11551596E4518C7444D7C137EF978AA70DCC6B33D8EEFCF052623ABE4E4117AB47E3C2DDFB228A7CBCE9306581016038B6346E97637695C30657E34998D3A3905778AC977FC9337E96114243C1F50A16248AA10CA76EFC51AEBAD17831D320F997BA8313EC8FC097571B3658C537B7D400CEF252AD4991AE10A02F02C2FF965C7994C1FEBDED6EEDC03700 +MD = E6544BE168EC237A2AE9F79547A6FF0F62AC2A96C319539A2680DCA3952014ED +Len = 4001 +Msg = 04604733D2E7140D64DFD192E4C92BBEBDFD5F157DCB6768A20D415F9E2C5B349FFFB6C4DBEF1843C866DF42FE37A6BA3C55BA405B08F4F7B4B2BAEE2DCAE54439A8FB377288E31DA41F732841FBD3B2CFB23B36FAB4EEA3D03098DBACA3C418315ADC2B062BE6B3FBBDD7E475FB7A3B6DB1972135AD7A1C1F0B1B86996F087D95E33331634A5793748EAB808F1BCCE8D042E14526F7A36F59BB50DB4E0FE0EC423231E1941393973AF062DD8A00435BD5236B44210EBEDD7044C0C4FD529EAC7CF04199F7C7A4F3573647FDA10E36E948E10CCE386D0132BBB6BC3E00F6EF46A75F808FFD4295440289B81AE992B7B11C77E5DE24C3A711F1B3BFC1AD7F94FA6D35EC6A4EE87DE140B149B1EBBAB90345A9C117F85F17CE8AAB07A727642468AC6750335717061D35E07AEA225CF08094EBAFA1C02C325E0334B1EA55370AC11D3440F8A9D2659B8F2462FBA6419B87A67B6FBEEB9A1B5FFAE709BD5D7C88E5B785951A129B504184CE46700C6BF50B496E8A3675F30E01F9785A946919B722E8BECCCA07D97AC8BFF8AF9168DB7C296C18ECB53E604F69E2DA08E2C963EB42D9A7463C6873F0BD0DE49352ECA2F209313ECC5A7269B801DF9428676C83B9B8AF12C9A827BB01B5F8DA36771AF274BC5499BE3184B624A048EC4CA7B3CAE0857E66132337EC9585115CF04621129AA8C92BDE6080 +MD = 5C5213FC2A5DBB1B99997913B057052326170038E8B46B83385B0266BF1E396A +Len = 4064 +Msg = 4FBDC596508D24A2A0010E140980B809FB9C6D55EC75125891DD985D37665BD80F9BEB6A50207588ABF3CEEE8C77CD8A5AD48A9E0AA074ED388738362496D2FB2C87543BB3349EA64997CE3E7B424EA92D122F57DBB0855A803058437FE08AFB0C8B5E7179B9044BBF4D81A7163B3139E30888B536B0F957EFF99A7162F4CA5AA756A4A982DFADBF31EF255083C4B5C6C1B99A107D7D3AFFFDB89147C2CC4C9A2643F478E5E2D393AEA37B4C7CB4B5E97DADCF16B6B50AAE0F3B549ECE47746DB6CE6F67DD4406CD4E75595D5103D13F9DFA79372924D328F8DD1FCBEB5A8E2E8BF4C76DE08E3FC46AA021F989C49329C7ACAC5A688556D7BCBCB2A5D4BE69D3284E9C40EC4838EE8592120CE20A0B635ECADAA84FD5690509F54F77E35A417C584648BC9839B974E07BFAB0038E90295D0B13902530A830D1C2BDD53F1F9C9FAED43CA4EED0A8DD761BC7EDBDDA28A287C60CD42AF5F9C758E5C7250231C09A582563689AFC65E2B79A7A2B68200667752E9101746F03184E2399E4ED8835CB8E9AE90E296AF220AE234259FE0BD0BCC60F7A4A5FF3F70C5ED4DE9C8C519A10E962F673C82C5E9351786A8A3BFD570031857BD4C87F4FCA31ED4D50E14F2107DA02CB5058700B74EA241A8B41D78461658F1B2B90BFD84A4C2C9D6543861AB3C56451757DCFB9BA60333488DBDD02D601B41AAE317CA7474EB6E6DD +MD = 0EA33E2E34F572440640244C7F1F5F04697CE97139BDA72A6558D8663C02B388 +Len = 4127 +Msg = C33F4ACD6701A139FF1B19E61AF5D916C056722FE04ED799AF007142814F01D9790B2E1930AAFEE9675FDC721CA114A1BE15409DA17FE6E25334FBE90A1E57B88B06041C991F6DF84D7B72F620E429F20EC7D7B675B2E0587421ABA23909B8B586A702E32D6B3B63EBBB5D3A89189BBF091A2749A41369863603B62EE37E36BFB11980784DB47AED6DF9A8D72B8FA0CCE9A43AFA5516CFE5BB4F771832225D2C6C62F134458588B9CF75BBCDECF9FDF097B818EC3401010A5E36EFB49B83F5E7433628E6EEF82A18BA3AA265A810AF756B08D1A73EEDD1B33211FC8EC5A9CF337AB591DA8551E25C5BC85EBAD959B623E35C3DFE56B25032AA99B7543A52F639EFAA386F9773B22FE96EA3EBCA6177E263EB4905E5240915451514D8C75F6720EA0736E2D067B2D4AD40EBABEC6E5DFD7F5934F6EE612EBD7B7CFE398A48FA3F3C3136D688374439F9B40EB53E4BC908D535C5DB6059D203D79A306D2E07F03F4ECBD6A4E5789E9C9282AC137AC851D7D32CE3ABD3632E63095D6CED7CC50E2D497384BD1721DA7F709967CA1D5E4251E95BFFE32995FF30DCF9A39B291F3A3024BD1027C00BE8798A98B7BC111CF72F58678EAC07B442BFF1484B2F2131E217368AE40187BC7A69F70590731E2B67A081AD1EAB813A9E07E52AC0A29A74FAE5465E163EF3D290304392FF87CFCC55CB2ED931AF94D8AB11513DFA8884D1C917F0AB227E +MD = 4D19B8FF10D5603AE862AF287CBACE579DF0508D3C2BBB685212676FA881B4BB +Len = 4190 +Msg = 981D1C4D7D6831BB9803217FE266F901AB0B149539543456A65A43BA3BB2FC4332D3692D521A47314CF7F060A1A5C99CCFD2FA582028FEE9F76B0BF021CADDD947D13B1740C7B72AFCFF65CFB8AF966995074A80BAAF076C35B082E41007ECDAF89319AC8548794CCBA24DDBA6083CBB54A224F48C8A35F1B1F6418AFEF3C20BB67014003750BA1D78A7FEB785F1549A8BF351758F52CF32207CF44EF4966FF4179BFFFB56A4CF16E53DF25F274FD62968B0E3A6594D4B9CE8092AD0924345B3BF8FD515F79983AA06E3C69AEA794A0BF8F4D8452045BCF11620C712B6620481499BBB73E6BE62FF17E0038D937CED5105C7EDD4AF4FB9585BE02F71AAD8E0D1829DC81C775E540E8557F78C67F6E3D3AA349CF329599C90895755460746125AEAEC933E426A64E4BAB1394C12FAE9EF279A439F224183A00B7E7B3D1A2DC350D5E4A548BD62C860D19AC3A0695DAB9F4994DAABDFAB4CFC5C4B51A6CA76F83BF2B128F76FC86FC6189377E9EFF327EEAA57BB56935CFFC58C92D13C1BB619D91060BD3BFF7B17FE1A402227AAD8B742D105E998AB978267AC599CCDDE71FB5A5F2D4473F68DD4364136ABBCCA7EF43802A8BC76D063400F07EDB4F57453AA00750405E929A4EBAFB23B562EFDDF4C8588C0446A01590F6D7C0B005CC8C69311CE9567CD2A8C0D7D247DBE0E1013120BAB10C9326BEC40D296E21C063522966DF84554065C0E0EFC7DDE02D4 +MD = 365A7C95220C130F0F9906148C9D3C464285764D417EC7F06166FC883D466CBC +Len = 4253 +Msg = 5C29534C606BC5DABB095A52B3FF4D1FB972DCC5AC44FDBF958845E1F7B92A9481A5B21A677B455DE739FAA00C1B7FFA2393BC8DF1DF3EB43864C05E8E493CA401ADEEDFA0C29610221443402846C81402D19058389A76745C14A7F5E8391ABF0726750F4D01AC6FEE319481AB32C81B2D3E08BB393816022F45E5802B7BF91477015E11479B65E23C0C938FE29D8580D58A5EB1F3F9885191B34F2D99FE307DA797709D6C704D297DBA448D3D67BD1246195B76342191B9630BF088729CAFF2651A2155C744F14D8681108B8A048D864D555FD69E757EEB4EC55B98624D3DCFE760EF8D5A7F3075796265B8B5AFB5949FF68D06D461D789F54AD6EA1EA622E072575B64172C30D6CC12CF09F89DE9A0A84508B1C48CB65EC31647AF9F2392D28661B205A66F3095CBA41DA65939D2E8DBDC1496952819472745B3D3EBA02E854AF7EECCC9C8917CEF0D796F8935EC862AF8B65883B1D20DD09B1C8CFBE4A2F929020B5911FF0DF00B5377A2E64B69644C8A4DA03F924BB760CCB956B470D4BD47A285ABE6B5B659F1851A0E6B59A811F9110E7AB924402264602AAC84DDE8A35062E29EB20DA96ED6B5B1273D0B8AB3F98E66DBE9058D7FCB6673AC02ABF76B065F5CAE82BFB6BEEE2383C692D4A191EAA4681531EBC30161D86945D4EB042BB6812EDE11791B92A2FEC0E08492C471F98203BC0075A01F85562D0AB0B88433957E8240AE61CDC4BA853DCEDA82E8985B111370 +MD = 68A67945A181C26748F588529B01DE1F13CA8490A81B16A2AABE435D7E541607 +Len = 4316 +Msg = E0DBD070B2AE5CB131C4C06790A62FDF30E39DA6D82448489BFD2E5EB90CEF2F2E930061514BB9BE280EDAB9D290E8D18A0003C57A4D45A9B22446FEF05B68E5A0B8FCBEB0326AE64144BE46855BB67EE4A446CA8F5625C0C12238EB77646D86B927BA63C07C454495F22BA87113D8540AA6476B945EF33907B62A06DF49781E9DC101CFD20CDB5C46CF71255B6DDA0C5E08F315580929F714E622194E076CBC85FA858CF341F49FC9E3A43A2F83C3DBE63D08330177C1F44722556B738AA8E4B3A83BCFA9DEE64C61B81C7E71C282403F14E7D625BB9FCF3A7985E2DD7541C5E4398E341EC100A19AF03E6476C2D4250F385CDACCB985ECCDD95B0EDD0759AB82EAFF5A2A5026F290CE6F6DECF5FD812BDB4EA39FE760102C829CF7F09665CFFEC89A8DB4E3A353996698132E4702D8E29D7D1290916E49B2B6C4ADF75A7BC4768602F30F23916BD4630B223564E216982108505ABC9FED7082E14F2997C973B2DC85E899FD61CA94EA65FC0490244442E6FE3CE5C4922E81814225E45985B3F764684CAF3664ABA3A642B850313691B8BED8D461E66EF47263EBB9CF0DF18944698394832265019720B9D6ABBA59AFB5E39716C000F4D2A19C0F8AC4E622C48E0FA0EC193593C76AB524CA5588C0DFFA6B88507F66A02A2FA2CFB226CAEFDF2B5EDB4944ABAAFBCC0934257C2757F3F1D6FB556BE24D8E3281C706BFC8F30FD4B5E30FC28DE29F87BB030D1126A81C11A7F883034B64437678B600 +MD = C5B4153BBC90C5C224035B113273C6F5A9147459BF4484F0B5325323B854B4F4 +Len = 4379 +Msg = EDCEF97B09E8FD6ED5F0DAE1567CA6F3655ED62C0CE1C115BAB70471322136D01993387147AB2C6214C89D25902600BED8224423FF7E8BF3C5B6B0BF5641342CF58052C0A85C02FD02A8CB703790511D78F63B9E3ED3C544D3B854B06CCB474522019E45D2A5339E656C6E217B21859BC3E528BEB05BBE7D3B20F44C1E3BD20113157A84D0DD8B00C65D386791F00A63FE486B4DE5AB0F4A00FF740B0268CB0B8D977540A122DCCF531B3B84C2207382AB6FAEC01BA3863B8CE0AA688057182EF862C92A5B76E394CB07B22FE25B7BB02A5AB222868B7B7602CB296C6097E99C49BD014C057FCE1B01AEE7A674C66EBBC0ECAE0CB0514BDEF041F6037F97CE44BE72051BD688016346F7AE3C86EDEB3D5E8D71946EFB45C410AD04E31A06723F08D9D304C6EC7140F4161E1F3F79BE060850C04AB7EDD81B8DB3BB5C19D49231E3A5FD7C99AC23BDE62B45869A2594335FE785C1A944C77C5D4FFBF416F9267B45871623D948E44DD24B3F0532C4D7D8771D1C51F36B89309EC99B554E3DF0E5D6279E882B95E4A801E17DC00A11F3A1FEBF22D4D4BF98D3341E9412640ACA22665FD0592FEBE02A3A51983E4F1F07A3F687F76B68279C5FD6887A4A2D765D3E6680DB4E161E556C572888ED4DDFD113DFB991B1F549D4563C42AAEECD8EB506521276F64A626125DBBC3F4BD8C7532154004F9704379D94BC940B8C18EBCA4594EC00090772B60B5443BF89E1329F04668F4C21A93AE91083338638D29E9BAB3364C840 +MD = B25A29A2D3B8FE2F6847F658ADB9BADEDD9B33DE88593CB0D2D1D748C49FD1AA +Len = 4442 +Msg = 6BE075E50733CE00C70D8941B36B8745F119FEE9ED7C897EFEB3D7123DF20EA7C38FF7B10E0E813959C97C5B084F443E9929D5585C958FFCC3083A1A6BB5A89B0FFF5ECAA6CD200535272C595CEDE8EDAB694E6B60ABE4D710895B1234BFC2A35E7D59AF092B58D2214433268E8513A5952F6C26E4803F843EE7431D4C36BA442B0C4379E7FFCF099DF22D8C92C5E7B103A5125799210A7C4E06FF8FCA80C948A6FC88E395CE822C9A16398EC26869CC6CDFC23EE9A1B2ECB64356F1C65E030B70F3C754367EC2EB5314FACF2B971F671FE1D14EA7C7C7FB552CA468DFA79F4617ADDA75E95097C895B4A5FD96FFB2FBCB31BC57AF92955CD383807C7CF5D2D1F79454C1FF81C679BE6093DA5793C116204BA58F7D251A4F245F0E92B47437B9DC3F1AA4A5689B7FE11197C0613C60A9FF70CE5C8B1EEAD51F4B8C65F8C89934E656A16108FC6C6DA0F0E2908128023DA57F7AF411DF32452A8E324A01434F92E085DBC30E245DCB841CEC09055BEE1CCB67BB1D6B364FEACFF7EFF1A8B23775C2FF256080B1E483D5CDBACFD984FB0C180346217474FFE128C9098016284DF14CB48EE1547F5E0B190DCDC3D10D787E2F03EE267BF5AAF6232E84D4788ED26BB0DD265422710983472F2D294B6E1A14F11DC3858F3598B25CA1B8A0A3E82A9B45E8262595E6986100AE7FAA50A11FAECD37150EBD88A242E7F5D066B6B33D27A48B8622E511A01DFC72BD1E972086596DF9E8EF0C1F65ABE5C0D7A1F1C3AA12DF73859CF086A08C6CA25CC0 +MD = 5C4277CDC2B96ECB0B3D54A75D7B18ABCFDE6BF9AFB2EC75E47FF45685A2FCD5 +Len = 4505 +Msg = AA0FE3102072AB40B7A599400A9570AB1B5AF93C4C925914D3EFC96B4BB3A8B8E62333B5A57FD4175AD61C3D728684AA58134F98B4EA9BC5B7CE4DCB0ECE0D2FCB109B794343FC194FF86163975194A2D7B6C60DB5CC0453A3FA7B44C7AB28ABDCDC0B2FDCD7B45CAC13FEC3DD274ADE2C9973D7A29E1419A856D9AE78007992E512FA230E8622E82675AE83954C14F457E19BA640362DE795B2B1E1E806868DA826AA4CF6B3932C7961310509EEEA20678A47E406FDF382FC3BFB5C88EE37126719AE2E22E58BCD02B13EE18F561C16CECF87D0BDBC18FA9BB959CA202640E3F9EECEE33D97A98DF65C4190FEC54ABDDE32503670AB52648DEAD81BF2C2CC938591D0C088C37DAAFCCED365EB3181C736C03CCFBFDCC9B599A184DBE6DE47E47BBE9706E754B42DE8CC7C959178A0BDC64AC6ADF15B3738FE6D33C9FDD3C4A784062C5F3AEB26CED578B94BAC6B72FDB13E7906B8BA141EFEB13B28B42AF2A1590562329CA5C0EA26528B0C265AAA37804E25637E3A92B2D2ED73759A9B5919B634C812299E0E66E648F91C8B0A7BBCF35C3492E462311D9409A256CB1F6134ABBDA916B2B882DA392DF677FD3E2B90321B0AFDB2E5F22F4B1F6A5CE8DCC2B66177A7839E4B30C1AAA2781189E69757C1BEDADD29AABBBF96ABE8244BE63CB5C56242ACEDF1263C6D0D6E43DF59288DE3721F1462BA2E777FEEC4A16A39DE8DF71995F2816B6479F0090EAC748DBBF556A09A981D254FDB2B0E6A6B6F86192EC5E71F25A71DEE0737FA033567CE77713BA7C500 +MD = C33DD9144E5629E6EBA04E810E94B693E8F4F7175CD81B003F30EF109BF3F89E +Len = 4568 +Msg = FE06A4706468B369F7624F62D04F9FAC020F05152F13E350016B2A29EFFF9A393940C138553356B0E2848C01B622B95FFA11AB07585F7DCBBF90E9F8EC5FA2FB7B4CEE0D0A4E8D33490ABD058CF3BB85F0CD9B1BD3E9823082D70B1A92ACA6F2C87216B4BA09FEDDCAA4CF254336146CC75604FB1F286918FA2434CA36BE2621049438A400BDEEA6C657F0301503CD7E6E38350838F60EA7F001755DA4142CE4579B39029DA83F1646B7ECB9947EE89ABA377099B82026960B9EE600779BF00D6EB0CD09226DB6915A7ADED27E6749E2CBC2C8B030CE1850EBFBE24C0658F29E9E709CD10DB8A77EFDEFC90FDD7B9AD7A7E0334412A53D248C4C12BF2987B7ACCD2A8A602F184583AA560C016093B56B100154477B834664E6B85A19F8DC909B4D79816AF12266C731E29A304E9BED8EF1C8030365B7DEAF3D436957308117C7C5767E0CDA6E342DDAF824233CBF4E699DC667357CB35C602AC6BDDEE71B352AF55CB93941A1A6301A9904447AF9EE486114D57AE03901F10084ADC0096E465E2EAD2496273112F2FAE626E230D42EC22EA10A8289B3E35EEE42150769D6E663A3CA29174316EC93A24F148D984053B8F98664EACA3E0DEA0B42E8EE30F81A2CD6E42C189A25FECB6E643E693E1F8871B837C3F5FF2AAFD1650A465DC8E5C1993BE65CFFD87F2C680C86B0AD3118834A5F2E490015137BA945C2775DBD77FB3E5C67819A9A7A94A656FC4761659C5B30ED2AC55A6D249B700BC9C93D590490AAAAA75A9FC34A90D5A9106F2860BDE19FE5815436068A7F8EA4636A +MD = D31038EC77CCAD00AF3D9D5E9F5CE717F5945BDE71C87CEA837BE4B360DE595A +Len = 4631 +Msg = 5528C4991F9B364B674A30BCB361A668D45A9A3A1A54CC502EF1300D3C1D16513CDC016446465E8F13789F7193619210804564FEACD6803F98D1957BA5CC28B0D1764AD265095532F8173F62C8B30756D9BAA235F4F1E2BF5FB63971D633629281A37715D7FA9C21C3925BA48B81EF95596341808002D1AB16540E4B04649129215DDE7584F5B1C9317025BF24D6A70280BA3AA4F3A549BD687D2CBA3612E488164979F0A2F5DF2082F552371F430A7B46F16F77A09678AB00604CD4C728151F9374AE8B7E50F175D4744A5D8E0A037FD67ACD832C254706A87D6EA7BC08C48F240C1D940A16297C52864A749502C56974778E36F3ED3B65C0FF3403EED394B27FF3201D10BB1C97DC12CB60634C598DA6C83D8907726DD883A34B73E68EF3E01B0DCC248387FF332E3AF456E084E01697625B10A2C395A6534E87C1355A9562C8F9D7EEE23E86C8C19E5D8B10150DFA85F9753B15ED48D769E0B79F6340D5D747682668D79B15B4291B06121D56B05EB441A0C45F520AB788A41759A114E07430CE6A5775409E72932BD49798B553762DA2C31F5359EAC0D7D1C7A093AA54F331E29B408F572322726B914D65684447770B51C68213A5BF891AA8AB1A1C2579E909B91A562EE1643AB57EFB37028194577643CA44B5C618A0731C0F099FEE1749EB919BDCFFF3B04D865A526AB15EAED9B4BBFF45CF61CF5F57229D6ECD1FA4070A3AE583B9E2D1E7E4E317EF277E7A3A0D30C83AF70EAAD00A574132A05CA580D0060E1AB608AF5C427EAD9AD6FDFACE3045777387BD778E62B91DDCC38C4626FBB0 +MD = 441B24A4AA94DF518368BCAB43CD971D53AA4052F7E0E2F030381576F513788D +Len = 4694 +Msg = 75FB9B21F48F51345A6CFC9EEFAEB4D7AF2A7EA92C57F1C63A175B012ABE6DEC8FF694D70555F960B828DDA954F927DB9F11A623D276AA6D3453107F3A8C5325B44C448B880A08EC4CC9E3773CAA2E7239BF842BEC72FFFDC4E88018C0B0108B410FA8C99864CE0F0CE16A5AF13D75716C69DB14D84A10EF1ABB7BE88CD64DA050D87C5556E2B73D101BA38D407AB1CB4AD9BF24C235DA1A18A12F0798B1DDB023CC7C45CC24D3A4BE7073D6E76CC89BFD76C2E82CC7888BD4C2D7E628A70B62FABCD97B08AC15F9763A14B698A197870A45CF7EF1A9AB793908E84A9426AD7197A76ECAB00196581DB67417A507486095F0FAD1804491B69B046AF4CA6E5EEF8BA0CADB8A966BF90AB7B4C0EE7F1AFD59C22B98D1F2DC6B081574BBBFEF01C29C56C012BE9146698C4A0D1D4A2928DC52666B4F5F785E73E9887F85EC158584B558501BDD587C16D982D765E4CD40EBEA53309CD04D4CE7668070A106610E701B2EC60F7F9AB5303AB250072508538F45ED45E5CBE2B50A83E944FA09556610F46A56590A08DB4C3A255737779B7E476E2B9A54533B4432B157ECE7EF4B1FE29CE049BDC98B3AF9651F898F6508E8F9F87B95D338DF76EA40BCA7825DB908EC41A6349A74379E2257A78BB38C9260E623A752645C445AB2BE90AE8555385F2C2C5C11CD7AD0D79F0429643134A22EC7C5470861371181FFB8F4A279844293E7B348F9836FD4B9AFCE0F2C7D96DD716F535F6E16543822781B9E4765B5C9A0F3A916EFEA89FB9E2A556453BADB58FB1B97979F6A03D3E1D936D3DDE74769A8A957207AE8C1AEFD22A39950 +MD = A3E0C9FB8A7E7C596C1B67967984ADA2800889EB399272CA5379773F938DC2CC +Len = 4757 +Msg = 530A21A1F81639E9183BD9E2550CCEAC4C2EEE446CB3057AEEF7D7D48D5293B178109178C380D30E08006E488EEC440C819460F72126388D219D9DC4BC45469B42010DA47B06464980F163672A9E234B4923C4944680F95BC101042BFAD8E3B76AC76B8C78BC3312D0EB65267BCB8D23AC2ECE87648A6B4045B6D0CBFBEC92798BEFED6B164E4DB5A6FE25A345B4D079BE1669CCDDB3A72809DA3BEA1226BE6BDB11F4C8788A68C81D7D33973E2EDAE93A59D86B68D3C111D2D61072B9FAEB753C955F222EB82484967940694618ACFABC030AB944F47D4200E55D729FF24694C9B6F73DB003FA6CD3B0A4DB4756FBD56F8CED99456D208FBD98EC58CBCDB7339739BF32DBCF6C94A103E523B183FEA9EE41A6D7BACCD7C7C06DB3430FDD41F95943254BF14F49BD34B33AF7BD955A56B9A6420532A52E91263B10CCDA84BF0C37FCD0128AC5C420D56F4FFBC954EBC57601ED63DCE25094B6FC93083273EC5EFD3FEC09375675C61C7E934DD9C4BB1C0D6C892C689CE7EE754717AF9F85A0D9BC9CCD02AE606D6A30F43DD6ADBCC8365340996C9607371D944D6FA33FBC4B80D479C5107F1F2679FCAD31CBA006C5AF3FC73EB9195E3D042114ED5738CADF4F22F64B70CA2D6F82573AE865273DE01CF980CB5382F273BD7100FF3715B42A68946C12D523A297487EF89C3D2234D5FCE4D2B03B7B8D8E3503BA7812296870E2C25A9B8C1AB077096C137B246BF5DE8D27B57DE327D38C228C5BEF436AED530119BA6E59B28143E91F570751AC264D107E12BE3A0072C2EE326D5AA7C64BBFFADFD56C8DDCAF60BACEE96E64E59874656B1D48 +MD = 130A507692C0ED242D6ADAE313983901BA7FF9C0E4C5EFF9EB2BFF13C43AFE30 +Len = 4820 +Msg = 777310C6424095406AAB8A2D5B9DA774B57058F994565B93620879A798BF6CCDAF1EAA41EEE7B3CFDC041C4F682CDEE918855CCA54C4A5F7340691C598CD57FDDC16C43BB76FEED1B92E43AF109E9DA963D6E594B037DC901891F8B1CEB009822DFC8B2357D400EB9BF60BB2318DB3CCC1918C42695DEA23C46ACB7A55B572BE8216F7CA8B7223A8F4876F1625A2E5CB1D00A9FA13BA2F10B347BDD4EE6DF4F6FC54FBC802D92CBF8D4FED28353AF86B9BE5D66A67B35FD94747EBEDCDA298D5711F88FE8841A2C739EA33B4B40329FF8266725FE4587758D33590B679F2B15D487149D5CA0BF843CC9A1879F7672F6A5E0B262A84B5CD6AF7F4A1E587058DB8F18B879E3ACCDD3D1BAD42194A8E91A5B7B7318969D40A3E39F6BE6A41AF0942E62B617809AB205F5F1927586867191C12B2AB5011B9D627DB952B1736C3BEF5950044DD719864242A9C152F07506851B7133A2670968640FD008015F3188E74C971D954765FCDA74A08B4248D5CB17D2D416D0467E910A038740291CD0DF9ECEC3BF20ED0491CADFBCF45F7951A55D08048F936176062760A66030513784E81FFA5F419C3593009511CD741CDE2A2214A4A72CB8D28F977B01FAABE566DB174D09D4522DEF20FFA64C22D32D80E9593D0942BBF3CFA4BCCF6D086A3EB697C73E382FB2DEA9ABD4374CDF043B6C2104132D647EE662739FE2EEEAB2D0329F60803FD937043CFB7AFB3C51F9EB6A888226D182999B755EC3ADFB6ABC643A2151400625C2AE1AABE8837A93F3D0D77519816DF88D979632068BCAB39D3483D348399AE39A4F527C96D13D010EFFD5866A99532BA1BDB98FC8C30AED0 +MD = 35765CF07CD969109E37BA71F027040565E30D15FDCB5BD73540AF7BF685665B +Len = 4883 +Msg = A7EAC41CFA6C39CCF07C3338A5BCE577FDDD3CFA6B2783176DFEE616DB8213997173A7490A39079C4406D03809FB6085B02F3EE8EA7163739E93F2E5DBDF2BDD8A7BF127FF909BCAD66B4114290CD4F7602AB8169FF24628E381E484422B9B6284B6BE909E7AD6A4A5FCD4143D6E6945ABCC356331FF0F0405762B55BB7D18355A349A51E20FCF32534CDDFB3A290B00E47495801312D8277EC7AB856BCA8E2F67E858164216C1D60826448C48B3EFFD77F590F6C4A2B73A74F89F6B205FF95087A35159627E38365550BA68E3C649297E24C1CDB3231A795B7857112001DFA5552C62B988F7A40EC290F8135C415E154346B2D2C22B623217B4EB08D3767A736BBB0941B0F8C38A2E06FEC5631FC2CB05FA547FCA91E573D5196A82450B2CC58BFE857B7200FD8092ED662BC012B4EB8E1F8CBF27E6B64F2BC5E4FB60C893E0088EAE6732D3ED042319D07ECF60E4FC9BD2B2B8B679C559D7C636ADE3167F45581BA6BD9376AFC77C7622864635369DA2915D2F52AADB87F840D80FF6C81C20A480DC88325B9CB855CEB73D780829E8D25FC85211C347D88F30EBF140F8FF4CC63FF9A332D258F67FB159EA2420284B15CDC638318ED0B3A8D646A86569168C5CE59F65CD00D69BB4351E1FD9EA3370A8AFB3D2070746677DD56962032346B1A79A1919FB853C939B3A54C0479DD0EF93AA01F9F3C8C157ED11C45B77B3B8B4CCA7AC21F016547A1C2676582CD36833749C085EF06586DA337A2136C75F031C030415573C743F1AE9579035BB318DA063AB4D1C540B8DA10AC2E65CF80A1E77AF56FA6D81BB45E3E37A433671144A6069EB6CB86B4C7DD46B91DF213E7452B7D1E100 +MD = F5B6FAF1439DDD81A97E0EE223C421555E60B2A05A16F9242E203769D6EFF46F +Len = 4946 +Msg = D73FDE8A7A241A3CB145DFAB20F28ACA1EC8B83298C163AC86BB89FEAEA086A335E1B78BB754D4C403DE9950FB364EE0E0451F4D2D680FCDCD7F6C88D9A2565CECA4CFF1C1077023E44463B7FF8834B210A2385CE136324215501EEC08FE59334C67248E28C1D498276BD1B7A88883C28528BA5B03AEA1D9E16CDEF929D67A828B4CCE4ACCD9A2757A0DAFD91405E78EC65105F2DD7CA7A7C96E453074DA6F7EAF53E130D1429AD0E17022F4163B41AF7227E11096346B5407240299A24D27C1059FA7BBBF48D5BF572EB3AA09501CA3E7B337158097CC85E76B2CB72A7A8F7D128012C60033BEA510645BEBC11E1A48E23417D591129C5A15070C1A2BB13C30490A4461099AB7D2D9E15BAC3C48D39631BCDF9F02613329919296D192C027DDB322C669996C560010E7F1FBFF3BAB038C7A94D254513E31A380B1701F67F5C32F342875BF48EFDCCB4613C06533CA2D140E27413A10D263FF52C0508B68A066B7A3FB7802F0BF5801A0EC0DFDD1E9B1D86F26BE20E594FC08402A62D038A8D7F4F96C3A9839550017AA8023C2AF57CAB06044DD13191BB8942D95EDA689E152B81CC66941D47935F0AF3529EE6F3710E0070CB86EB7ADCBCA884848662528D7D3A868CF4955B7D563C35679B5C6E266A693317C11CD51836488BDB5F3E8CA6DF84189932EB4BD5C5460226AECB4A949B87D57E60CB437E36CDC121830D29E12F1BBF69BB2CD2EC0AE98AF84C345F9626D106210948F2E877B67F04FCAC3A521DDB054FF85521642A2C2B836750ECAAE57A2C356D946B7E8BC8B20F33360C281D241C3A6ED49A62FCEB6639D74595BE7C2E91F0EAEDAFA74CAEA92351C7868BFDD8ED598EFD43548CC3B00 +MD = 1F7F8701C861BDAD442B737993503A4147ECD5456170F3B0EF8AC42237E9FE5C +Len = 5009 +Msg = 5F706A6F7B3729ACFA563C9D04E985F217899A8E26366961A43D20BB2E9FBC0F5E4F34AA4FB77CE0F47CFC1F1147335A0B0F516725C3B81921FF196A951A2D4C5A6F38586CC7CEF1EB93C914F5EA96DF25CC08856865CB361BEF7EE571B02026261E590C901B2A38A5BE3627982C431AEEBA550DE0DEF84F8E113F4EBF43C7EC32AC8301488D3553CBCB866E7BB33E3B8FD58C565C5FBB596A3185F1ADA14384D6BC50134820E48C0F98D82CDFB4F5AF5C0BF6076ADF731E13F516174841438393DCACA34CBCAC06C949703883537B42359C57C48C6A5AFBAAE3BEE842B7BDDC8264ED432D6717BF64542EF047AFD9BCBBF52B232D16EEF3807B4CD0EF923FF16E549EB91A4E72BDBC3C5F4622A27373751654B103410A6EF4C544004ACE29987592FB580D614D9B56012AD4FDD98CE8CF10CECCA30190F37D96220CBF029ADC87A41917CE204C7A8E68C3867B77AA8A5033E311B9B180C24DC9FB4495E3FDE729573D414FA1B2BDF1466D8E1CD73616E293F73A3A9A4BE7928E9E4754FDD65AF000EDC3C6E9C1838DF08CE946C54DCBBD1DCC63A373E6792189EE7D5079140131D7C235B04AA226A56D7C7F1E3B824B386B0B65638D3DD9C38B61D3A9BA7DEE5C2D1ABC8E7D54FC7839DAC0FDED3D167258E8DDABE466579E9B4D66EEBDB99AE7D53B554FF2BFAFCB388ED98AB6317BBD6CCD1BB25A0EE4C006109316D86828CC4B11BE26A8AECBE99CFD306FEF10B69ED9FF38C67D29D91CFAFC331B6E4D8F08FDF4821759CCC930145ACEB8691BE455E21C6C126736C949DB383FFC961163DFB61115F3151AA72133A5E6ABE4F692365224F7EFC9AE8EFF7C8E269C4EF0CC4072548E9773628302494A2BAF00008B5A7900 +MD = 18A5390797BAB8C1048077FC18F818FDD5463CF8A235197F1B397E6215027D02 +Len = 5072 +Msg = D0FF6E045F4B636F75A389799F314066644854821B6E7AE4047ADFDE2D0C0E02C250F0BE582BEC94011189B964A8AF430F5921ED9D9F4446E4C788515B89CA69E5F7CDFCCC9E83E8F9460145B43DDC41C07CC512B7E6FDD0E1E7AABA29A6C016CCB7BD54B145F3951EAB9BC4908F623E5A9B0C5B36056292540B79FD15C53457DC74A65FD773A34D6B313A056F79BC29A3FAC15F6A1446BFAEEAAFBAC8ECF8168DDE5F6AE6B6E579BD3CE74E7ABFADF361D0FD32D56586A8D2D4FF4CFDF8A750FAFDE4C2E9EB32B06847FA30B13CC273532D1A23C8257F80C60B8FA94FA976F534145CD61C41C0A511B62CADD5848CEFF643F83CE43F8E6969C5A559AFAD60E310599A34B2E5E029FBDDF2988FCE59269C7128A1FC79A74B154D8AA2850DCFDBF594684E74099E37882B440367C1DD3003F61CAFB46AC75D30E677AF54559A5DAB70C506CF61A9C35E0E56E1430746916DDEEC8D89B0C10DAA02C5D7E9F42621D2B312EAFFC9FF306297952A32D26C2148570AEC90501CA739CE5E689E7066D9580A4FC25E2023897C74C6856273133E1275A0D275DC5B75DB724CD12C9C01BB95AB5A227B7850020630506096878D289923177183EA9282A4C78EC212D2E898CB99D81A3364DF20927EE34D4475A5CF5CDB24088ED75B60201922E9C972D8556CA75F8274D15F3FB88A6B42C766DEF6B21329DEE7C457446DDE8C26405FE5D0309A04229F449E8490CF9000EE8DF400CB7C7EE831BD7059D24088FB42D61681CDE45050FCA78FF64D9C8D1F58B55F802FA5D2F2E723F3E4EED4338B060D31C8ACC46D26870BD45D0DE0798D48E32AAD1A6D4322E69F5E72309B9D7FA1F24BB1D63FF09ED47391C232497BF222C542A70975C8292D275197A4CA +MD = E4E3BB662BE094610F04D5594EEF5F78B1AB080F2EBE5ACF41D661FA13A68DBD +Len = 5135 +Msg = 299833B50912BE5C7D466B512B50B52E6F521D9BAC4FBBE3ACED29C48DD8FFA9142BB0F98FAC9CD88DE416ADCEFA2F8E76366331BE956D7DDDB63E60114DA19B80348BAB45B79F2B62ADC846FF857BE296DDF3CAA6691C7536994377F66175FA827D7B7271BE698E35B923EB282C4F44B48B94E75DEF4D0E6B9FAB443B23FA71CF9E2493F6604FBEB73021C71E28854E1411D6DAC64757E66E54990278BA63DF1381E63C01A0BA600B8B810C1C80F7B92B8A98D90CE0EBC4C372C2AA65CAE277394D09577C09DFB794D95058B1C2F785A8061DAB8C4ED5C102B3E3EFF3AA07BFE0D1A51A3FB853C3DCDFC738948694BB9F75EA2F32AF5F8151D18833126ADDFEEB7D6C9D0720C87D9990C583495DCEC1B648AE77921C50966600D9C6C37EB2108E491039C6800BE84F94F8D497EBF4336FDD9E30B81BD962EF18AA6EBDD863AF8AD4060074FFA69498D1A86AC01618FEC341AD4505F36132E81CFEB1745792DE3602C272488B647C03D6825AF74CC6FE74972ACA355A3381C79D323AAE34007B306879BFFE50D4898C9C46F98CB73A39EB7239C7132414C8B0FF73CAED633870A916401FE43D23724ACE39993100218D571CE740C075D6068935225869F24F0B3C99E62A0DD6176455BC1069EEEEB7CCBD3AF15CA12B025E67478872DF226553DF5043209AD36A92CDBF8BA7B3F53D02EA6EC528C4E87ECF5A9E68852307D30E6C1239B19BFA92CADED3E3379F63CB6BCE912A040B2BE95AF0E0D99B49E8EF3A9A073A1089179D657BB363A94B5F07ABC5CA544A017AE4F7D158A9EB6900DF6D8F70FA776716A8796F3F3656644422973A69CA86D93C12E1342B3E3F91168F4316BC84EDFFF16F6F199B8CD8D285C31E0EABD08045E009E00A614D755E6AA5A43D0A +MD = FBE4A01C506B1569FDC084AB3A93C16FA1AC1933BC7D60AA0D59601BC7C998BD +Len = 5198 +Msg = 8B5E4347E19E43822E13AA6361397ED7E20F1C5115E29C56A9035835604884978AAC96CAB180C345480C283DF3232D7A9F2F96C7047199698BFA140FD7911FEABC04B77DE6C7FB42B71C527B3EE8BF01315CEE868EDDCE6D411BEE50E13C98DADB581FB98BFC6CC360B147EC98009507971E5C69B065A333748DDE9942F034078DDD2523ECD570A916BD0BBF96E6472CC793BFC0AC5BB90C618362B8B65F1FFF0F439015E3DC4C8873D102A70F2E85B05E6B726119E8CFA539278E7ADD777433F524788735D73A8C8581C090E8D43716A8885FC4A0B52AE371F879A75F11AEF6811E42296419993C3219FB6D465ED124F35DEB8816FA173379549C088F60BA32E43C3CDF864A3FBED69871D18203088426396205B5B5E7BC4DC3EE112CFDF2AFAF69A4EE7CFB59673D8DD5E2041B9D1D45F8C17E880871954D073302499AF3EC5D3B48885D7AC1D43863E59BC7AD41769A4F284B703A719349580979D88D8D9CBBF87A5C985E7ADD266DA2A87361516497C0FA9DC5B5EAA084A2EB03AAB9044450B7339F3F769B865BD89DB2FF36AEA29D6FEFA55A741E7C9A9765F56431152035848F07FD059A7E03EDAF6F621014C37AAA5467C5884E8A34F1F275E1068811D6C3A4D54CC5513DDF873694CB9C63E98EC65F3BDE10C1F6F7D24642C3642DDA8F8B757B086E5C85419E8026A0381623AF57460DE95FFF52376442E5178A00CDEF7017E412FD8A685C6BA13A8A5DF72E5CD843141C0144D27036F2CD489C6FD20AC9DA23C4B822C1FEE7065083E6C8179346DDF4D5A621925FBB4A75BA3AB9C3981710E2B9C53FBC94524624F8321110EAC01FDE48325BF5D7DA92CF416E4A0F477A549B3A819EDCDCF911F090FCEB51B2976ADFDAD0119CF987538FC1B616F201A2C9EFA771237BB7A4 +MD = DA7D4511163B68C3B08BBD205B02565F31882C6E1CB9FCE907BCC14BCD7B92E0 +Len = 5261 +Msg = 1BE8B3D98CD21229AFB427D6FE66C885EC19065E181078DDD9FE6CA4E9B138BDD942DEBBC641581E7C1AFF0B33E9BD8B0B373702FA0D0C74BB96DA1BC6BD0D1CEF35797BBA3B9E8E16667819F87B7649EC5C2A835BADF7F33FB46F79D1957D7103401B99FBDA5E494C5A760D1F23F8C2D51584A1F4FE2C0AE61965B42F4E6E84CC62D207BC499544000B294B17633C5867E629B3ED913809C2EE44D6408DB6D4DA688AD71AC8F0C25C3D9000562BF0AFE2154F660C045507A22462D279EFF8E815185BD421E86E6CD1C848AE9632711C64123303D6BDA9B70249FC55DC3776FB795ABE83C0688743989DF72DBE80A470AB62BCC07F9A092A78CC2AF1C74FB25640A61F7E64A34E310ADE41476F42957650B096D1AF87F86733CA8A77994E3F75E08115338838B06FCC58F0974AA955C58121D82C6F7FDBF459FE8E893744F54D4DF7D1ADF33AD92A97B61D9EBF0E258530EA0CD77819510EF36448C4A4B96396CC16E3C57A8AD57B3A3A23238B2AD2381FE4A9BC12F99D36544ECAE70F65243F7E0A2553F4EFED0EF501A7507B89F3598122D139E46288B1C22A600E3DC6DF5649C4E3EA0DD9D8D2F85CBCACC18B2CEDA4AED99A72DC283F354BD6F78056F8438452B126F91446C0719D10FADCF957C1D101DC9394D83013D5C100CD4BE838BF9876481F50EAA0601200ABDC21CF5C1D5A0F40BF5197AC2E98447ED76715F87BE904FD0AC30D062B89E529A5C628AFAF2DD043AD9C1489EF5A1B262327DA3D13181041441C67CBF827B8B0D9320C87B26034EFA41F122B70CA5E067E15835F502EBEE073C96E48FAE708CACF4E7C60103C627D8F9F4280F43173D46A5FB0E0EEA43AC75EE8CB628210E55507BA56F0F3BE60221BD57302A6B4FD585286F06F9EDC03B97D165958743EDE5AF79C18E66D06E8 +MD = 15232729FC59B84A9F078E63E4C580F287926575A220346117FA1F02FBDF1B09 +Len = 5324 +Msg = 0FB99FC3E9AD2E007790D21E15401A9E4C003C0B8F0847B67597ED134422F23D6CA7B6AF09AB6AF77FBFE2D846CCEF40F327795826F01A530A0DD526883FF88AE10427EBDDB4C4BFAD10AA5FA7C618A226C913C52401BBB8DCB1790D86AB9CBC36BEF612D2F6AD589F4AC3748D7E9B450FBA2A2419C6992A34254D4BBE044E807235798CB3761C99F3C059F9EE2DDB4A964B46F5438C65FA704C61D70F4ECBE39F235022396926F3278AA31712672A2E6EA76FC9BCDEAB8F325CF345AB5804B030B3C3871FA9F70F5CC5E2F358F63B91618AB262EAD9BD4311272AADD9B9F4881E51F77BDE02B0D81B21A1C2A743A41085EE70AF70B7C9CC34E4182F9C0EE04A67430A19B3DB7B4E00303D4B8317AEA2EEEB794A4FEFD840FA9C250BF165579FF5FA0C92F5EF1078ED594FB1913E1F486A910120A38FC31A17A60306B6582681ACB8ED12C2C61C8025760B9A5BB1A75AC7EE6F3CAC8DF00D0C7B817DA9AC170373EC38EAAF3D7E0ED02D8349599C3998967C0E41676BBD6F6EB9CF5B8E671402041BA0060AF7441679C80EF68F48BBBB126EF5D19F5027ADF0E4E1ECFCCC5D74C990151D5724DAEF4C2B213930FD743C9D394C5CBA4433B19BEF5298D261C61156C51A48EC33E10BDEAECCC10BB2D2DE13E8BBD0535F50C4B36D5C8AC8E263A4E66E0057F68742BAF003B4B6D7C1767F31DC75E716DA3719FB395AE73CC69056AFA9C0655532688B9B031B868C3D0D2C28B74C059F02899869DB6CC7775D97CCF81D1619CF8B094EB97D250ACC54CD41203F9B966E9A5B1AAC45C14AAB6927570AE21BE493A8DBCB9037B04E348F9B27C72A0995ACDC078DBA1F138DBB43DA12C37157EE7B5F1E1D19C0B1D9C340E646F30CC02424C5F574FAF8572E90948B87C7B280E4097E0024E06B3061ED69655D13A64FEF6FF9AC7B1E80 +MD = D867513883D5768F46EC49B1310DD8E8A6942C7C1B3C8990352219F3D1609CFD +Len = 5387 +Msg = EAF78A7320972617700E9AC416A58AACA623B3B704CF3D608ABE0C1051FE1F97874541B3EB206F55140D2FA0DCC0B8C24861E9EC2729F717B4C84764F63759660A7760C5C7C0E22DB9305727EED029DD270511E62ECADEFF71B57F482D78705F9D2C4C66A8F07EB67FAE5D2D16CE8CAD12772AB355BB31DA5350CD5CD4D4412E31A5133AC9B3007AEAA38E9E5F6FB30C9E801F67C0CDD7DC19CAE652EB1CAB99823EF8EDB300F5DFB0DCDFDB38F796AE8EBCE1386E6CEED67F01FC64E6E4DAB271D46EED235D6FD3DB395DFA1DDAAAD1D078081A7B601A10C99D92ED3F2B0CB4E35AD47CA3A722DE12F4B8A9F19644F78CAF4F608D51A96BDD637CF8CB42A33B0110A6BA25ABD4190F630334CAE8471FC02BE41E32EBACC3575EEF878BFC53F66485FF0C02F321BA9E521FB240B3CC93BF748BA4DBBC2BEAC0BF66B81C563233D2E64E5E6957744570B64E027947BFBA3598668C3266E73FD3FC3E1C236AD2BFD18C28B04F153BC3ACCA6A5D2B6E86764FECE77211AF25EF9A4B822FDC3475E9A2366E47994D04A247BCDA82956E8E1855E3153D712A2C1907E1E12D3FCCB4F9391CA797AC41DE645B696794AA262E6557B9FA4BECCDAB65E4D2C0D006797E340348224A48F50B61D666B9F6CC03AFE1DB11B6B43587639E06EBB9C1D3E417A592864CFB5AB9D2A18E87C2484C9B3DDBFE1E4A9BE77D0E42287FDBB14A4EF342FE3023E090DC141211030692AEB5927BBE61453B6B687E35DAE5A6EA7F3B4BFC0CC67770380792FF7514041C927BDE1B6D8C823FFC2D14CD256FFDC12A5FFB72055A81EB200C27B5B414D079D5ED842C4022A44CFCA9453146882D33654ADCAC47280BA7649B6468EE78E87EB9248BF16BA42CDAFDFC4D2100F1AC69891848D79F491306267507F8C19648157F81850C3E372DFE96C212E17DF2590873D75F7101E0 +MD = 05E3CC3F266A1F38994D419702F0C7297BACCFDAF16CF8FB3AA42AEC353AFC09 +Len = 5450 +Msg = 8BFBE22F6FB83B7B0AF80441CA027202197231A04567F373C529F8E09B117AC027E234CBCCA05EEAF008EA23B8CFF0458C3F32061B424A706DA1DBEADE8F7D9643435A911D7DD06DD0B6983D404B1FE212A84281C9CBCB7DD9F96E051F540A30E28A276E4B329712BCF478AF9AFDFED054C6348339F012678A783049547B8446E7B8BE1EDB606347C5652C3021881F2532408536BFBBF2D5FBDC46C46DD03C4ACF3B4C35D742620A190E090967D872C7D2FB296A5BC7964E795F787A26510C7B20D944EACFEB3A12902033A7DBD14D0C5EADDABFE53390000B6B91BCDEE177799F0F3DB35B773879EF17A7BCB652C8A6AA9CE8D3F0DE635379B87381DF1177A627B6C154FB7D5319027881512E8C548CB8008FB1F1DFD55CD2DC0FB3B1E67431C4A240FF6C6D7C7C5E79BA22CB5A3A6ED75BBF2A0622BF4E6BA0F25FFD2835D366DAB3CEC648A347FBD7F865E0FCFA64F07CC4D534D23595480EAF8C139522F8B334C2C22AD8F45BAD02AD15B6CE93B1571B7FB7FC6CC1174B354492E38D32DCF30BD452F4BC5BE47B730709232EF7E4D36C3E01C6E0188821144B91DF57A0ACD7E4437FD4B50639BE9C6A9560A5479646258F14C5263C6209A8734A74B912862EBE88EC9175DADCAF61E898DE4294A4311BC92FDCB5C7808D44C4C56B92CB6F956F34933EE13E2B79739CB0DAEFEB213B434E6B25725CC78F350D4A24945BCDEAF62ED5F81F8CBC107D680AA183B600CC4009041B94D715F78E58A6E8052D31E78335738D050A78615ED26CA898B4350BD165CC8B4A504BF59107BA07420F4781962DADF40ED87241A9DC4B94CEAC6E0239146A66D7D0DA93E2F501E0502061E5B6F61CE970E0557282F2337EF417690FC486B028567C49FA2CB02E42F6D2CF8DA6F1E733CAAC5B5C42E7121FDA8AB17EF7EA6A98032EC8DB48794D0B1BE3633F7D5215C06DB8B440C0 +MD = 470C3F0F4C99469791CBCD48F1303BA0A6CD7616A28DD13D757198037E1932A5 +Len = 5513 +Msg = 2EFB4BC32CF427BE438DFF9983CCA1E39A14EC401167F255E175B4E2D341E1F7EFD16DE5A836838AE946B06113A13D2DCF7BE24B0B882867383380D0D4B9E9E460416AA446FDA42CFEFEE464ECB36B7456D6CF0E9AFAB1270B5DC9CB134CEE4F5816EA6D2AB1C661FB052EFA9E6430FC55781072EB69A2DD4766A8A4B967AAD205EB4C4EE3CFC8E8C6B6DA297CE6A5AF3F2315A45B96968985805AF914B630749895F0C742DFD0535831AC5A71AC3505C69A412F22A4AED13521684C3645F6EA23E05EFEEAF258585631B28ED23D69221CDCDE71AB6F5AC7AC2B2BEDA638AE8B3355E427108DF80B8F2C6715039D264CCC75F249CA233F0A58FC71019FBE47E5FAE2EEB9AF3EE41770AB07A36A0CC470336E519A945829BD135ABCD7A5CCD9920B301144C9F5109A41130F75709EEE9AC56560A88D05D50D3655909BB9D9D71D3C6D18556A07732712FA0D80073BA21281F261185A0CB527B82D60837942E756055B3E995C15A68BCDF70D7028B1818B70902BE015C4DB3FBDB0079839178252D0A542AC1B8032CF1AE3841FEEA8E471BB70DADD7B3265E06833764C896AE43D16089DBC53030F8433F6A0D3DD4F3DDB7F5BA9E0F329F9976FC548B549F272A24C9F6CB793AF5640BBDFF90F4CDEFFA0DAE6DD403A3615CE7CA85A70BC35CCEB2F9B4F1593370F7B12D4406D6A733ADB475DE831F2DC48C592D0D168C0332915911EBB50BCAEE0BA30D46C311ACC6605BAB32557E30399D2613B0AAD0A7FCCDF556B380C7FF55D4121B431FA020085F1E448B423E38788751C73F7D02EFB51C5EECD7FF4197F067DD332097058BC40635B924A8F72D8BE9CA2EBE33A9D12C8A8777C5C671679EEBC52575DE706BFAA83B1F483141EA72AFC26511B11FC1A4C5854CBD32E443DFEF445AFF23F0338FF6E3DD167964BE76874C7699C90C95A54335C1F2C85715AA062DA852D0D85D70137DF00 +MD = B58E6FF5E903942A11E399B5399D347C1D94D1050DDECB1B02820D0142E4707E +Len = 5576 +Msg = C9A0B51F3199339C11A5753C9D9C95104B400127087177F14D3E15BE881EE89BF416F97D4F7AA9636C5EF29EBBF8930804006EB26839415D3984B920882499752C36A5BBD583308E716DB16F28DB98B3A3E718A2EBCDFEFA75D7CCBB6A746E32FEAA38D034843461DBCFCA7F983E19F5B23EC2E3D74D2B4402F3BDCE7D7A9DF1384668C746CCE466B0654CDD5CA56A77D68A100AE06D63CD9AF512AEBAE78993808CE672330E2065C0F71E05C0FE821CD5F85732315F04666F3E4E6C4F3E9F415E31FE0980D874994108E12464609C6D5C19CEDFC85846B0A84EF3CCBD3B655FB0DE8CB892BDF774DF39C955F04F322856D470981BEED0F752D82EAD73B4131C5DBF0424B4AB654F72E26EF0CD292B87BD5B66FBD5E7EBA96C62CFFEFD4B1D870BFEF312B86E38ED5C0F50935E2ECF9FCB8C95D35D19A8FC8F202BD9DBA768CA48FBBB071179413C0DE4FDE86762ED4B13E1EEF2A00ADD5D1C2A3AF7937787DEBAF1F6F12F3F0225FFE587A5540CB550F7BC11DD6AF864D6B6D16DB1488CB226EBB2199DA75FDD59A71158867298F63961B40A31209F8F16629B1CCE7FFB617072748FDE8920D11CC0D0678389D1F719DF3ED19846FE9893B04DB60FA603170D9573B1BFC7DA663E07254552AB6253DDE814117185F84373FECD7F98DED170C884D41D1AC81814C73EA48AD94ECA1B7733D8393E320C8C467EF6189B4AC324C68C8A2ECF679C893B7DBC4310CD05DADD80BB6326B51ECD99A441BFF77BE8D644D752F3C5C794E7D45BA76283ACF8913BBF2A420F9E5D14D7A23E95FDEBC69B455E466423012E9D1DE9353E40D4BDC3107C3144B96C6DAFD41CCEFEB2B7FF848CB9FDBEA8648BE32160FAB7E7DFCCB807FB019EBF159231EDCF2D487D76A3E882F3F50CA48DD08A23B06EE887BD7DF9D7C6CC2BDBE348E3125C4532448F400CD57A8679ABAB13E582B13D49442638E2698FB7A563C7FB264157 +MD = 6E1BB4D034E9B9816ED1A846F903F62CB1BDB8A00D446C9CC777E475A327C58D +Len = 5639 +Msg = 625CCA81F193855711F153E04D05A354D19EF07C6CBBA1F0F6B5BBA8DCE2309597C8147C379A6377308497A01449F8A6E81F8EF0DA26BAE93634065173469CFC2E68414DC1F433B9768E78F23674652726389A307129D29509F1239FDB959375EA3ACE5935C963CEDEFBCFC4EEC14D76157A07CDF3E0C7B98327507EBBBACB24CA939186589BF571F3D7F4B99EBA6CA148F5C9EA30783729B337F6CE37517D3E27FAAF60DE51BF02C496CF2F102D2E0C6254A47199E510C8856FBD53ED6A5FBF2F0E18C909818208790F137969E2DD34B4EBFE2F4AB40E02CFD9BF44E7A51C446F14C4DBB624EECAD1F2E5CA9905F70389C979F7CAA1CC22CE7DCF53F68002753B4ABA9DF81F60B0A7C12AE5C0FFEE337C70230C5951BBD3C281D2F73B9DAE384837A82EF5030A9CE3439C885FC2AEFDA64C7AB6CB332ED50B94B7C4EF51C5077336C923B9F806512E31B918691494B99208BA511F1D1935A6B1BBC44D334CA159CF52D761CC8582FF87C844B0E3EE4E08B2C567FF8C22919E31BB3FAD4707D88B23F8DF27EDB6DD383E48E93ED5ACB4A0D5719DE814582D56EFBCB660314DB38E8C4C6E6F79701FBCFD7D1A332EB24227FCFE5025EE49DD7C65FFC6FF5F1FF870A118C138396BAE7CEE4E6457F6D48A907E7F5185D366E77940EF29AB1BD881FF4E45966BB87A8527E8CD666C93C6F524E87F3CD83FE304C561FA099228AE138E9E265043C496E24DC50E7127D0561032AA452BC0409B3CEBE7B7819CBDE0BB891633A9343B17BBD1486B64A29DE6D1A2003EED9C4DD34381A3D29CBD9EF2D077E74EF7652A8B320ED76E1750589C49D0E383E9829A530126D68708AEA54923CD6646C273C632CF5372FCDC6286D02A7CA1F221C75DE29C7529100B49EA0050DEE6D44C5EAC8FE2D4E28F116A57F988F08474B27D2915C891D2D51EEC776A863B9C523DED9268399E03C6468C35ABEBEF8F85B822BDE5C1D7EF7466316D7C7F12 +MD = 3480C4E23FC5470545B15525DEDABE98309DB5B1E9E8D116128DACD26FBCBBFC +Len = 5702 +Msg = B71810A29FEF6865DA2C61DC366B357AF704D65FD229CC98372B010FD2C401E3761CF7DFB8942DC02E960ED0345179B1D48CE077096EC1BE77340A6C10D9E154293DF647B19547918020E422CD36EA8346FA744FF09FBE71FD0CD695AFD5D772DF296A41AF70257902DFFECF450F79ED6C1A42E8C06CB912E5B29AC9D490046F0C6243796984CBC7C5F92247A95D6CF4F77BD8112B0C7E4D1F393646192B42250B53AAEBF09841D6C1C64A50B42781DBACA8378B7B8CAF6B825A5799DA3F3334E2D3C0642ACBAC4E5B74E9B62722CD94E2C7AC11823B36E62B5A956F4F64FE4059FE61367DFF819656F70F7E510919549A1EC528E528E63CE05F94126944181526BF737017ED9A678DE7B18C37456E890C5B1C30498D6B5AF89C891488846EA3DC792615B00730BBD482ED62B138B892DF268D7EA013AEDF4D223B661DB98C56196A04E97D622918B302FABEDBD92D97A55C0A7B3CE0A09A0DEFE13A6F66AD7A180212A769B34AC0AB793A46C29D1D86A94C2E3FDFF125929A48C56F1453CA553C8D4212F2951500BEB08F6B42D28169F1E5C324DE54F60312973F4BAAD3EE001EED90F5A5711F97EE0EAB028DD83994F3F298B4D33CD5AF6DE17D5160F8D9669B2AB3222E7AF537A8B7951A8779514E0754260FE0B0E6825C02EEA14B4B25951A4D4A7AA4B7E4669F57D9B84E1E7C18F813FF5A2B0DE26803CC6AF22702C065076B186DFC2F6D6EAD9758EBCC8B3610194B5DF877F8B21C71EEF0D860B41A7AB56B94DDBF244A51801D05C1497CBA0D11173F7508B5540A84BA4F26D1742C0B45B5642C3DACE4284FCD6A3DB62FE20B27F88F6B51168161A41B115A3EEB9C93E23902DDE2FC7B831E176C981FB3DE96C9E47E51414F9115B91F2F0947B1D1D1DAEC52560F4D8C4D4F0599AD9FB702F87C7391731CA8184D57BE7ED8570B6F2FC0AFCF8B9AC921CE17D7F40404E8D53B1EBE580BA4E20BE5C68B5CA45A33E754C0EA106CB69B62DA8C +MD = ED0BA15DA7E93420AB5B1FBADF6793526AD0D4D61CCBB03A10179DE978986C05 +Len = 5765 +Msg = A72761F14149B6E552CA9C4DEBD0033892E3DD950CB1A41FCCFB6F142C09AB5E99228759B13C177B3F779A8D480BFCA23BD9C9F32736F7884B1ACC3F5C7C7DF07F175B15AB5FF63912D8826C7F214F80857409436E19BA31C77C99F00989E6379F80ABD82D232BB93AFB25D5010EA2FCB25C38877F71752562671605B90DB6C4C82B0D8ADCA38AAE5A991FD1E1E44FA5754A5243462EFA218A5949D8AD95832C92EBC6D32877373DAF0AF8A5D7E7EBE56C42D5740C35CDC3CB504DCC3DBB0C4F88E50334DDA66CAE42EFA50D17B94388AF52EFDAF8EB07FF78026BF798180B525B876E858F1CC26DA8B3D6081BB6C6D75860BBED17575C0A021DA46CF9352F8764D730320D0B93B23B2872ED710949A9E4CA2B0146CA1BA2B49E613C42748AD11F771CCEDB65A99C7A8F6801E7FFE5BE6BE61F6BFE3E53669B0214CCC5EA58E7B7B65A3DD13E8B46AE3A73F5FF38E2899793F7815D5A8DA6774C0002439CF1CFC33BEDFE2B307C07A9807FD7B7DB419093E70126453220C9E0ABB93B18EC061562BE36526AD96DDB5A303526EA415BC105C1EB1FC515DF2AF9DC8A8AD898BC16A4C61375746E694A7C67F4CC7860C2F02D6924AFCDFCFAFE2543D4B4E04B585479F7E5EF05C7490B2AE4B2088D5822D0C64F8F2661EC796A141B14CD783EFAEA7F59BB1F07361059EDA7ECF83BB209283704EB20964190C4FD8803E5A45AEE1FD99108FDC53B064CC1E27E2A5F9A7F28AD219D205D46AE04EF7BC7090530535D780E43FC743A8E97D4245F3BCBE824490E7D5C89D5B8F7EBDFBC90AB432947FCE03FE02D539D2165798FED42AD6A3CC94E668EEAB0BA0B1FC1407864A57D72848C528C85E42D31283FCE96FC5473E9720E8935791C26F1F26A534018B647811AF7132B979C45F12E956161CAEE6CA60AA6984A11B4E70EDD631245F3F8108DF89E11BC4A16C58761F0BDB2C64146CEBFBCEB4F14D522BF813C1D5C62F777793F9D9D7F2ED9FD4D564A89AD0A6F98BF1528 +MD = F69E7DA2A06800FC73C8D558D6C97CCB0F65DB55D1BEE1C60FCD552EB79DDC3E +Len = 5828 +Msg = B54909F612BF2E07C26E05B790BE731F26DC3425B40B0E28C99B7D5B3770A5B223D097F5FFD52402556403F526000F9E45B3BBA3157C2CB853D601E8E991D5CD483A5D263ED91999334693239179961F80AECB4498D1739BDD72C75CD1323DEE0912A92A666A991A8F6B0C574602FAE4972313077938B9F734541D36FD2A14ED2EC76B1899E57B1BBCA52B93CB93BB65219319B610E2F2E0AD6161B52FB5E5738DB11A22142A224519BCD860E18EA15D6EF8D6DE3CD53D6642BC84D34765509F38855B5C9ED82DF4E1A2DB3BD10DCA57F053D71B492FE58B59B3D1117F3BF5CB7449307D89C0574FC142607A920BC2C401CED9B3A1B82F3DA856AA4A0B6AD73F0B598C882950CAF1FCD6BD6B54369A7CDF7F9C11816C0BFE2AE19409959DA5226369C26C8241C8E0C6756CCC718EB91BBBBDC90721EAE5FD2CB17EACDB5C52726F3CB9A6B0143AC2ED19AB595148389026FED6DCBC4C352160F4FA9688C932B8FAC55C99DC3776ED704DBFC19872538E5AD0BF3073A51DEFAB51BC4465644A3AC41E97C2A1C02A49629D3CC30C369F1192EF4CB35A6263953FEB091740BA8C5E4696225314B519BC177750886E3408005564952FE80B72A2E124F12BE7C9D59269E83708CCE65DBFF16EB2FF784E4644FE08830D09129D9B07BE33457EA2C6CCEB7E148E24A3B9819B827A2D9F0078926CC1FC10CC68901B394355B071BA34D5B58F518FDC50FEB96379F804E7D0BBB2714C0A27F3BB21E74BBAB5C69D3F915A1FECE707E195FC7186BBA2BA3C6191BE3324F8DB99549249CB2FABA2FA05BD77AC0214F29E61696E9376758D1A0CB47165986EA3B932FEDB10097365BAA95FB83C7AE14BA04CEEC2DD141C8B8299308E72603F9D336040FCD7839A9FF88E8E9748736FC7AE9FC9FC4E194EDB7623ABC9500D2DDFFA700EF51EE5AEE7DE124388B42CD32209336B2D224229113CDD5202DBEE1FA42F01D6182DACDD5BB0FB7047A23E78DEAFCDEE0982745233EAC83FFEEBB7B14B9C711A49C0 +MD = 22AB54D6E479509EE60FCEC4AC089A00E222E0619314C4C4D197F0821CA43191 +Len = 5891 +Msg = 6914318A640D20E50093EB0EDCDA4EEBC21A37C71AA212D10077D3745BF7D9794B3EFC83EC5ABE5DD0CE3F965CF7CD88BFFDD61EB4412E0BA0414B19CEC7D34822AB8659C20034C460FD5C226FA14A56432D6F2B5A34ED3E161CAA59CD9C090CF615AC9D3359A6259AF6D5F7C97E1BFB14633A78E6D9ED235DB1105BD26D559B421B75499712CA52CEDE2E315F886A45176D209AA7FDCD9C8D5378850E891F4DC14E2A9CD7E242EB6B20A89335176E481E2E6161EFAF7D18C72C43715FCB68DC6B0256E5AB90A5B116A9FE3F5330D3D1BE18DE2B84CE24C3D08AC0A82E3E98544F68B8A903157D7221FC953F2A20609475258A23CC762DF74B8A05C22AB8A3B633C18C96C0F36FA7CE3B0E23F164799DB822048A953E54964FB13011F79F8692F7E332E669DD7DFA18C5C974F5807BFDD4AE1EEB49504ADAD4C121D3927D98EE44A60FE2FED3CE6045801A061322EA85B0444FF3924AAE9C8A37B88C4CA70F53E16039ABCABA7C89EFCA4ABA3F935C897C9A98CDD9F70893A6FC1D7E228B588C688346020C61431C0D32C60F4459FF86B57697B74B13CB3D56ACD49D1D1721B8E6EA62DAC161A862F96449043E051B948BEFAA4F0FD0B41BD168E0CE55991150993FBE5B58DD7A0277E14875A0E5CED081CE8215A578AA82A8D54D1E04AA100C1ED8D386A0F040588DB4C7469D52F4402E933AA3CDDF4E71C7C5C2B332C736694558E98C15757CB5E0188729953AAD36477A65869C512A5B53465D4756DD0F6DA5EC8D3EFC829682DAC14F597FF53E4E7800211D8D19C0D1CFBE92CF105993D326A4D7145E3D73C69DB18DEB6D01FBD073DFDBBFAFD76B857B7CAEEB6D8A5160E77C386C217CAB6413C531A9AAB1130EB8F274195BB6D2C6F086FF7D55BF69E7B994F73E89AF51B294621F0DB6D40A30B3B8461EFA05557ADEE258885D38B7B8726D3C95480E6FB56F87F52812958D8D32A3383739B60D5616D21347D4E1015B5EAB77AA91F56104EFE01A73AAD8398F770F1FC9C08CB379B3B2076F1DF7652DC0 +MD = 2A1ECBF75D9FE1C419DAB95D910CF7DDC31013E1C8422BC6E7EFBBC4E686349B +Len = 5954 +Msg = 9CB83412023898BCA0B5579BB62AF6FE433A5EB239B253F654879C45AA9B709DAF10BB6A977D35E2D7C3F126569DC4E415C21FC18DD3D496FD806DC931AA85CEA9781CB76310339D0A3DEBBF1103D14B9FB940D71CEB5128BBA5073CAE8CCD9CD6824682466332DFA85742B3C486A942891FD0FBE17CA21A3D33C72A1C252E1CC75F299F9B290CC0DDD391C374862CE8B3840371182F94929246781AA1E0BC81A327F3CACFF8CD0D151D0F3DC7084EF8DC3C05F75937B5958D3956B6F08697665D16D1AF7C11355342671D4B5FF9AD3554F6C23A364F0155F5E61B64B61ADE913A20F3283D13A40ACF32550A31ADB76FD6C586D3192D345F7D69362B5B003087BE23523CF21032662237C78793BE64289431C3290D8B92C9FC2987A5A18C0639776D2DCA3E205B4569ED9E2318D82B2412D219C54F078CADE66E28D4A179DB3355C0EB0ED8290B4F38883DF6097966951D8DFF6B5E08FE4944F3ADCAF9A09A180C00F1607C5CB22493EBBC36B9B6DEB5CC4E22E2A5F1C82C2988C1795835CF8956C0B18E369CC9EF145C4970483655DF6CB95DA7D578DE7F4F57EA05537C206CF83488985124417D3D6D647BE8A33D618A46075F6239DD5A4CBB0B484163AEE84840FA53F63DF42D7D8C6314047BDE026B11963A50892991BA149771FCB9DA624D6A13A6D01F881BC9DDC7471CD6E5FD26F9EDD9309528ECA899071942A2BD70DE754FA8E349870B5ECEBB2583931B788B3D497242D8A16D23439563FA76D348AE0600A7448FA116BB70680CFA7554573ED8EB4253427903D0325B3131BAC52F4B23F5F97228E586E95651B8C5FA325C0AB5D86C217CD1D9C7833B9091447B3283CBEE04F06769013378DEE88991469EF675165F1B18E8B86A36CF9CD698A1500E6B167F26148BF0EA58F4E673F27E39240C54E0ACE7CDB002500D72A1570E11B4465B8A9619AC0FF1A3ECDABC6E6235506721F2C04D30235D2C6528CFEF8C55FCC98E2618AAB4FD513B8C7014BF7393B41966A93C31EFEDE19488A101804551F6FF3EBF6A79EB8900 +MD = 2F2A5DFE4EDB0E5974EFC865713F20F116A28694C8C49476277F1CA64AB0CAB3 +Len = 6017 +Msg = B6E69511FFA9AC74535A28F0E2A0A6D11FD2A3D21CD8A514FC6D6BC063AB51D4BB89ACF599E46D6AF1F137E063F1050E6F51F2A5F887E8959533D37EB578422A3E4AFA37ED6037D4C69ABA1414DBCBF7EBECAD42C3A81FFE73E73135DCF90B496C937B4E20DCD73A3F0E235C249609391A508B50ED941436E8DF4F8CA884755EA301B82865688CEBAC2DB8B0F257A481A6382622C7908C319675F81191A5AEAC8A3DE42335581545A7E908DEC6D92636F1B00517BA2F718A97831C6B0172C68605E3D910E523A77C11900CE2E1204F3BC459A1B85310F7D6223009FABA3E51A940EBC63C0FDF02F03FA17BB35A918F501514F2B6A8FED85A2DEEDC39D2684351F49BBE5BA2ABC4655C89842B56DF401FF0A8956E41DB417B2D9CB0BAC162B4EA4E1CBD315371DF86436E2920221C19CC75602BD1E4B60C312110824C1EE49CA91375C7AF0D2D3CDA48CC4DE41204CE9814DD4AB05B6A627485BB49D2B0FB237F57CF543D2EEF06C60A6236DCB54F145F9FB2E9356D71867DB80E2D74F93BC7EE55AC5A0DEEADC397A6B5F8C826A69F9CDC081D1781DF7ABEF448BD4B4B1EF7100F0115D11571C27C6EDBBCF2E5B167AF3D336D8BA43306E6E6EE8E685C0ABA72A16B902BDB7FD777962AC9B83DF9A8A084EEA33EBB287588ECAF426BE987C9D12153C3EFC6F0FE6F7635972B1990B8639EBE073B6665C575ADD66EB79177FC0E7B29FD429E63ED33AE99282E2DC7671417A15F4F1C53E09F36CB959948B972EF6970E32E606EBC1FE27C532746481A840096284E3953D6272552535B03253E34A9609B4E8AA8A091538514DAD89B5111C3B135C0F36282180D90434BC8DA064F10D27D574F8C5F15D1BD5CF9D5F5E02B3FDB8BCC2DE688B8BC79FD5387CC6E0DCACAA8B5DB53528E398BA1C7D7F691EC16EB31B765EB42AA9193AFC1D0A0702903A36BEC2E4F806A5CBD755C7EB38A273E1F77C1E9D4540F6B4E00167899DF77D00F5B35431CA5FCD398167D21F9BC504A0EE354C22122D11EB49F5A71B98E91B968909528F0AA6CA0D58EF7E429283300 +MD = 2F16BD44D10A98278D51E092D43F5B5701B03EF917F96597A1DA9B8EF789AED6 +Len = 6080 +Msg = DA5B2118CBD59F408CE56362489FDA69EF73172F46DEC16C0D4A66E3F3CCA373927CB6784CE62BBCB08A490D003A8F77391E82CDD87860909383B054DB95816720112E2F96DE9E0FFC8BABC1350ED46B9AEB5D46B66940EFA311F4853F3118063C550733E7679D871729001C12270E98439E375E0CD24769D318E03CBC97D643F1DC5F1B5EF59D12789F22449BD8FA43A13CE78A4186166523F3807B0B621079CC528F4E17C258D4F9BDD095A3E365614B94F2CD778CACABF26244891531EEDC24E1BF4598319EB8B7527736BB1E734429360F47F04B2E95D5AAE997763A467CC5303D1141C2C01F7AB9EDAB860D180697C906CE1558AEFF5ADCE603F8A4A10FC6C1699189E73B489F64CEFB89AC557C5BB8826C0317EAEF2302E855FBD96777898104365D96AE8A8ED8669C568C4DBEB0A70F6CF4C22FD933014473F91871C08D5A7B44A928295FB2AA56D5E2C39CA79D2837FB39B35C6810C378D749AACB543368A19C137B872229E0A6F469022AA93BCB2BE38B761C85AC09415CA7DEEB38FF2A2101507206FE322A89666D32750AF0F4D7B2E59571F02A048B8F94FE2D231072E301C8641D1CDB4F841AB165AF297495A348BCCD937712E68852A4ACA948C1294F8B733D06D67DE89F206498DD401E149FCC1EDCA92DEB92952EDE4EBDC7CD7992104769A04DE8705027A31337B88E8DE93F6624E8F10B9F9924E8CE5A9D841C9260753FA1492CDDFFE6B4400C5719D76FB5B01B234F32FFE64F04D0A00676FBFC58DBE17B4D552FDF0C5B802C0CADF723F73F86E8FFC493992D23E8C0B84F7220A983DDDA21170B1F730C736E75549AF6ECB8DC94FB25C26BCDDEE420C83E8A45AE4C345816B7163CFE016DCCFE47C66979D610A7F9B4A7B1BA5E230344C9F46BA076F2FCEA68AADA8FA09BF0B5CBB3850DDEDD80A30E1F7A639AC69E5595C6A4083AA959831EBBEB84C018068723192F58BAECDDD18C857E212D4C7E7215B6C954728183FBAA07720B97189AF6A7729C30D28DB33A889F225D027D164F254535770C504C506AEE4EC4676771F69F935BA08A1C6C85 +MD = 6319C9117EC0FDFB189C83B551015145FC61FF66B0D1B1568AC8D17D61F2A08F +Len = 6143 +Msg = 587D20FCB467C62A25455AFD348286EC914A4767E4AF71796204EB1D5893ED42CDA250F5BE00E2C4E2FBB132EBFF837CD9C5236716BF32086EEF1ACC6F59CE1A46FF7FEEEFBF3DB0DD42432D9858ACD78BCE793093237F49FB3515D5BA657D706E790D58EB33A725A47D99AD55A91A58FDF3727DC3105DF313FC1D7EDCF430257B8E2BEE38B99EF9078C44F2C03B33C79FC9FF21B05ECB8A5725BD15C5F6F8370E7462D0134C200FC52238373BB44263116983E3695B8FD3F9EFA73A250685F498DF069A79F78F5595709AC0CB0E324D93CA71764339AA890E058598C19DBFD07EC09E02E1FDFD65D7B26DCC0CA025AE40F55F859FFD2A0254EA60174B1CD9BAC6C410A731BBD8010AE44DDB3D25D593DD4D74824322BEB9D9A62FC988342590058C34B8674C431FB6F9B68860950DD4A3009110B479A83979A6C412B521ED1958C2D582DB9C5D3F603AC4E20C548F7C79EEB7FEA879D68333D991E2281A664555FD79F765D9F087F5390F4F58772C05E10CC3EB166FEFA01311664E52F62086C763385069B88B0848E7CD81F25D0424BF2D3CA172C920786CF83119F4F2338765ADFFD918B7943ADB8229CC2B43F2EB4C946DAA03F37EE76179F28B3BD7D91E09A5FF93DF7CCF83879665265F92E931BADD61FEEA4CAA0A86EE120F9FFA01971A916EC023B6AE7AAB354F45647FDA515F5EC1021ED76679D78CAC9309413EE09BCDC04F04FEE24C473EFD0F13122B3E186A1DDA35DF5F5D0E951AE44DB38CEF6BCE7303A430E9EAEACD5903383954515C886C93C5D7C85FE7D0B071709E186D11D3204C7B21B2EBF4264C34CA5C373385DD58B8D61443BFAA423D7B8C5AFD10D349C29A6BC0E893D175F83FE5DC41876E6C31586A126C7C4140B9777B7D800932B57397FD0FBC28FA8BB7001F4D6FEC01E6328971E115E8FAA9032665A7F9C067320166076D4561468F10C8AB7E5168314AA6F30B48A2F98FD0774AEFF2C040AF531421701F45AD3DE80E965DDFEB4DE3BE5B4D2C71DE1AE64B77917596FFF5820FE9FA4DA48B2083E258959381F7845518CEB00E0CC37DE3557E5F8314377A +MD = 4591A37AE205DD170A0F7FFF9A0402273B7477636BB68BD8A3DDD1AB0B053C71 +Len = 6206 +Msg = 8863868907EDBDB49F4D5DC4C32957F7A65CFFFEE3DA80D0623036FEEC778E132A5BD98CE36633FC289BB87858123F41F06B85FFC425A36050671CAEC1F33FDE2CBDF6D3DC1004BE8E4ACC3EAF189ACD44D19655D95F2427B6DE25B4D279FB403E041F3B8FBAFC05DC5E5B108756BD41C8AFE6B086616E812323B536A009D78F8EC67B10F00CB6B6CF367572D6939645D212F2E5267AD907E11CC994E7216837A3F5CBE93848F2B5671E2DE23D98FCB62E9741BB92D3BE8F474850E8C120A402B42424E952CA222CD9A92D56009FE995B9E5BE530DD714D421D3CBA4831D74A927610C5C9BD6AD5BE58FA9A7BA17535F95984D181BA944C1D53AE68BF2843E92D5AAC628E3045799F72AE5B5631EB72220B88C4862E34BEAEBF114B5B2718F4C996EA3A0CD903E0D04B291F903B0BAE11224CC401D04D5A7848BC5868D2DF30413D2CFFDF2083248F78EBD9A629D11F8E4AB74303923E5BBEA3ADC7B0EFCB7B209B1F271A0DE025E7D47AD1290AFEB62D476F7CFAB96BFEB0892704F8F4E356BA025DBC955AE8AAD8AC7185F3591F0B871ACAAB2D1EB552AD16704711C73C7D4AB007AE143D808CAE87B07DE1973A49F89DFB6E7F4ED9D5E53A9AB3F4FF8C3E2759FBA9AAA7428099E2083764E4D2B488135E67B5F6D5A30D713AEB0EA49618131930B86DCB215352BE4249D60BA72A67745894813FE5775DE137F8196F6C6ADCBBD7A39A669C34A92584F662CB9B21CF216E518E8532FEE601A504EB0A3E954705541F7406968834496649C99AA34B7C01E7BF07E75686C12666F4BACD43F36EA224AF9E45AE00ABF1B100F060B7E295C1054335A0530AC9CBDBB2F700220E8A4030C638E0B23290D0A4C7732097C695F6EF0D2129379B95FFD312D80C3877E12DA26E95AB88F158A4B2C9231263E157C9D483B5F6D8CD9A81ABCCEF9F8DFBB0EAF6483B8DB13FE51D44AD0E7DBE6540A90505F1FD4047110E105CA0828F943FD05D347BAEF38D8822011B066359F51FBC2657D693066E6C6973DDAD1A114802DA12C4244D94CC57A8E1DDA43ED379896A20BCACD74A1A69A9D387385220EED0F3E23862F57BB74 +MD = C1950E0C8056A1B0481A1C71DBF205EB273E2E31D279455D55FB97D1A50D9202 +Len = 6269 +Msg = D6D2CAC467906CB31297D64853954F2BA4A96437FDA9592A6F76024D512A39AB32C45F6E181B891079E4913133C91B803440B38A07B42F01FC174ACFA3A59A5FF20EE77CD67D46728751FB2815BD2EF651B5AA66ED1EA59C2239AE988F6ADC43A0D0FEA105204826928E9217B602B240CFACCB413848F9A0255D7E05F1A99A92AD2C91D5EFC38083ED16C36C0D6F62F9C4DD7F48AA42FE4DF0719DB47CFB9B7888EECF73762105BA279F046BF2D4B3381C5A750BA23E265E03E99F051C71416312730FA38800B0003811616545D3F2EBC8B578C9E5E3672DF8F8ACB41C3C13E330F1358F01421E83639C2CFAD25C9F3650556DB62E9FF9EE59F8F05E44CB2A30EA190EC1591DF29EF6648AA20D2B099B9F1A35F934C3FEE547797C0D656B86D4F7C05F0AAB0CA58EB32791241017BBED95B33FD83133A07B6232256B2775AF8B0F333C599DBEF8D35EA0D209AC94A175CE4043A6E0C5699B0A9E7E95404AC69B8AACD051F39A40492040C2225047F986501ED20A01BA0FBDCA024851EA116128A594FE9A26F812C57E791D811952E9289A37B5F5C7B434711C245EB7BA083F2B990AFDF7933CCD5D736D7F0F3C1C7E8E5DED33288E5A2180819D82EAE2EC63ABFF696EF272DA338AA24CF65DCF6F7ABED2EE63BC5FE6BC88B4259777BF2BF9C431B86116A448EC1166FC1F5C49C516382EAE9AA6449F14417A8CBFFDA9E70A956BF7DC25276113ADE0528CEB598E3EAD13DFB39C04E15E867E77C460B006A35FF960D6E26107F165005E1CC2900CC504477D39D6467757061B81AC41CB9C8575B4EC5AE0C04388516D56984865B52E1CA9F6B1E9D359AE4B37BD09B1D7128639520428D69F6BAAAD53202C26EA46E0715CAE1EB2ABD938D55983A93490FD59AF574553DC94EDD487099A822A9297DA539E4A3FD7D61E1645537E29147568999A1DC2E35C1268323D3D3B41F3E701DC8CFBBED4A294563B6D5B8B440A55EC325D7B434BD6ED06D3E658C478DC9926AEA819C8FF2CB0C03CE23A246372C27D866601CF7A3485FA9FFE3F3CF0359B85F3E205343BA580FE130589BDA19B1A4B26900D5A34E24C8E58D1D5B28B41AF5A0B58 +MD = A2265B644EAB518F245ED1362DA858F92599F7444C7035EEF4214040BDF64759 +Len = 6332 +Msg = EF21AFEA6E71C04344491C83A708ED9AFBD05A534E72806B75570CB6ABE1A94BE09AB798E50F10B022B353858AE2825D4E3FB6AAFF9E905A5CED6A01D00F8B967EB28AB081DD21E67F7A2680653CCF979352389A7653A7E441AB27CDFCF6550689DEE57BCBBC121A65378411525ACF631A503303F5DFBBA4E48FA9120C8FA8B150380DC53C5C8767D17D95F7C386F504F9EBCC7094B9F203F34889829B93F737A4803838CE9027466176D973738F50F4F47A5F4BBD76A0CA07C8C106D7766AAB9E55F2429BD7F62CE92431A206FBC17A0AF9D70F11388812BE321F9D50434934008BD4F1B9409AA221119523CE87CCAF474FC971C719A75C9817E21D847567BD202657FFAB75973F30D6AF30A94896F7130FF07AE3E2DEEAC1212F1D73BB3B64886ED2B658405368688CB27D4F056C91EE369B4E714FDFDB3484C657D5554732FB329D93889DEE4AF8C80BE883280778159AFFB3051A9984CFBFF7FCD4ECFC4B2D5BA773B374910345E7300423BB9AFF8BED019CE8E7EF60108B9A990CBACE2F892DF3C8C7A5A40908C9F1AA3A4D39780CDBEAC19AD891AE9811E450C0F612EE37A68AA6C109AF1BB9FC6E5E701788BB6182C7C92BF4C7BEBCA7367B3D07F8E081FE457A00A9042C884827DD0554919DDA81C56C4FCC568AC2DEA06AB9A439821037387FAA910E097FAFFBCB4C9A64398FA52F22E70222AF3EB32C5B1B6C8356E380431A36D32D82F98A3AFAC816B8DA9E41D9482764B0808B26B21E0E61B45632ED71ACBED968904A8E1222959BB9BF723C09720B338227AC35C16F1CCF4A2A4113F60F9A2361B279B4D5C670868F57ED720D476F24DB1798246966575379FBC1EC2FC3C3F2A6CE68FC0B7DF8F2E9422D38AFF926E4FE7CF095DBD25A9B3803E47616B30504B527FCE970EA5BCCDF162B8F74E39DF6EC02C1DBEF1D8B20669E64C945C171346044D2C031649E1CA8D13D6CC58699BD51B079A7E1C638938DCDDCE42F1ABB23F0AE24740984DEC7752402183DDAEAF91755301C3D5C979C1863E71CF155ABAC99CBCE52BE6051997D54E3DD09458889FFDA0DA457479CB44D4E451CA5C20FFEA5D20C58B00DC4FF696C2A2BA4A1E6869A70 +MD = CBFD7A72747D6F9D23EEF430FC898AE395A57C7F535C299A38AF896DAD0A4652 +Len = 6395 +Msg = E857AF8DBF7325BA815862B22BAEA57D82B24D9A4820F6E836BEED71AE82FF5EC966FD86EBFA008918A85193BE55CB3953B4C17E9884E6DD1060272C7A67FC3AC7DFF32933B10DC9957C76E5FDF91B89F787D70F684CBDFC79C7FD19BB0BB76EB592DC276EB15472D97F3204AFE7702F78DD2DB214965CAEE5E8243630CF7DD54B5DF7BC6934712075E1A302DF48878629DC5059B3977825BAD0A5B6D749E3E6917BB4A04141CAB24B80B6999AA0A34623AE4D7ED0CD7A8FEFF64FB58A2A8BD3A8F6FBC5F66A12515707544B33E4D3A1612313C3F421B1BF6E764B5288335AF4B1300143F327FA15D46FBCC53A18160DF6D0EB9DEA9FF7C4FDBEECFC89F582E37B667AF3B835B799BA043F2FEFD541402968F358AD03D0E03E78FD691BE532985F75B503C53B91A57D4EE4338F82291779CBCE04A395A5A739F7E4000B294CE705BCF523848B9D9A48DD9A73D90CDEFC3937A278EB2D5B6128A7D3A1863A032241197AA2BB2D0E18A4D6043CA2B0DBFF1C3420D9D56E80C5D3E0BA4B28665AEE1BE710EBDA24E6B8D32892C8276A169FBDFA2905561B79EF24D4ECCBF70E922397AC596CB692A94A703FA1F84045DC9006C2358ABE177D99A58932F5C2FCBBC0A783931802B84355D0C0C06A189E960BA62D00194EB1AB2C7D1FD2F8C315185230C97303D3CE711F8F6DF9E9995F90559C0A6676170214777DC8DF85ABEF4214BC95DEC08851E82D9F11A066811EA7E6E552D43E1553F86AB4EC6502CD2DD7585831BE2AC890030505BA6800A819E64E27E6D284A76E87D27715FFD217E1C5A248F9D32DF8ECC4EE7FF789D5AB64919A0F715A657C230793CC9782D5ABB12F6D279BB61761B2C6B4A6470761345E5851588D701EE6D824D2FDEB210E7557F4B978DB0F665619762A215F79DD86032E8B0FC896777B7BE303ECA8BE5DE3F37816369C589FDCD0DABBBA9667F49E7BE176937DEB692F0706253F5B6A91AA295D17F4CA1BEBB6784541CD3E51FF9DB97A99CC9BAB34F6ECC51DBFFFA2EEE8191F13A907966DB87C955E1CC12828322DC9F7733D575CC9B328972CE877FF8542ADA2A2C50666F4DA362B55A29FDFFC57F4B0DAD7DA11E4EFD014FED633E4F02D54E0 +MD = 20CBC99F0EE0EA4CDAA9F83E6861723D875528069965D0887ECBF01857A6D0DC +Len = 6458 +Msg = AA0A0C3DB258A2B6D9DD4D1EB16C56B9811BD41722A2479F610E09630284282723E0E73C0EBE366D44B2F71CCBD711273B60DB1D1F0DDEA008675227048522690CFC10F3C0C2AA997EA64B1D46D54430108B2B97ADD6797749257947D389902BAEBF9EC1057494A0B66DF6AB98102251E3642DF44F3A75E0AB18DD765C98BF864C219E77D43DEB3C7932CB5DF1A0DCC34BE0C1C964AB89C25004E922D19C966D417D1687A947727C3BB7134DD34D60DD7E954E7B18F0897A69099F2ADE049B95382A4AE700753FE5118167D0BBEE90583CB40B883CF75C66B90EE8AF2DB6465AF85C57A1ABEE077AA4339C158D755110BDA069DB9C6B8430D3F6B5172751FDCC352D311BF7D6B47C0813DAA240840C5B5C0BDE7D714E0118D0FE46AF727E22E9CFB1F284F2EDFD4D245661FB3EA36E790E7E5ADE713DE267CF93DFD1EE6C6229F01F291991DEB72BB7B2D02A78F0AF853DCBE8CA640164CE65002C48E1F8FA1C57603F2AE1286CCCA589AB5110EA594D5117FBE0954786C71983414F12C64722F46FA3583438610B82F8FF57B68A0351F2EBBF06C6F2DC08870B2FCC1B99CD5BF17F5BAC3B5EE1E7A7F3D8B8BF4DD9CDEF405E64B2FD81107E985C2C8F7C751F2391F4A18B1B032F0D84A135873BB42978EA1224FBEFE14635A778DABC938EB45A4A6600AE7EB0172E6B609CAFE72ECAD895F1F061D43EEA19BDB1AFA51BE9017B2A26036B5D4C801967C0AB8E618B1279104313EE7546996CC09A3A524DBC2C0A5F4490062CCDBFE1E1649CAB9258CE21DAF09212B6D3C60381ED543A503B2D2498BABF3DCB4F42F205B14FF994D1A83C7EF6EDCC01F89F5D8680150CDE355FFB2B96AFD7B02780F7D2F52D1D520EDC5B8DAD6662E62244E9A01903BFAD50408216775D25B1465B5821F8C53F03E67BC0B646284837117D6706A6E96EB78D2BA26B81CC4A22BF90C0BD90AF04A8F142D28D1AD4620EE06E27BD41CBF2B56335C5F040946580D6FF6ADD8023B3685B3AB5E0B6934CE8DB603698995ED576FC788F6AF28464AC48056E70E0EA904879C2595BCDC75A6668F372B254B01AF4EED2C3EE5CE8604C6B9A037DF4D779E520F77F31D3F21472548394AE91EE1DD9CECE6A9F741431C1B0C0 +MD = 9B9818B9C5DDFB54CB210B9BA9D503004DD07BE084374EA5DFCA4CC2AE585E1F +Len = 6521 +Msg = A36E30BED5872E0EFBBA19CC4C32E3E5B54A80548C2BA57271F6E4C394BC326E2C9B1A28DCDECE6CF547F52A06EAB6DF6325A9347979C396B76BDBD7F45A070D6140835F938638A3DE8FA4A9DEAA53DF7AFD6825C980F1B9D465BDBCCC9C983B49A995E4F2D775684CB44F23150FFC918E629ABE26335871D512448841F15DF92AEDE1BC1B543C9A0305CD9600CDD36602D10554C2DF96967CA994539DBF31224B065C37A40155D3AC7A847D0B807CC603BA71751473B7581981D30222F434D2A9FF20666C492CDF369C2434AABEA4F822D92D5B35748E99EDDBDA5077354FF6794FC5B2E77DF92D6D2CA0E6D638BCD180D3E95EEC8C9F28BB01C9EF4AC17C8EBDF132C4D99BCD71D5D1A641EFAB56E24EFAB3DC7427B33349C21ACF6A8CD114ACCED9FEB46B0A830E70536D266CAFB651A5CE6432A2D7DF730F1ED4CF7100EAA3F5E7AAE140626769A2C17B9D3457FC91C161ECA43E2F2B530E22F83AB2E9E21D4AC8A43777F3C2AD2A44427D4516ADD22C60A995C51AF58D3375B4FF33FE7A1FB5CA54AE86B121AD22315458C5C555BC742A71CA2D098885B47444242996FF7240204DEAF2C7EBD346AD4565581DFF28377F11239FF096BF1D8FB8FE668871B020F525AA7C5C880758AFC7C73CE041A061AC4049F7429DD1C2E9C5E00E00BE1BC02E67BEF24845731B26020EC2DE3A225D714915C71902BF804B66EDAFAF5DBAC0022CECCDDA36F67F91608B73FA5D76B8B97DDE2226B112A9290AD232264ED0D24189E7F86EB0C1BB32A0692FE7909FCE19A5DE04582E16E6B4D519AF352A86859B4571D948C2FD037C72711869BB1FB3EEE6D797AA7CE4B51BC6D8AB787C359AEC94491C7DC88FD138225ED9DB2259D5F300FBE8433E35163ECB1BCBA1A7CCD39EA6EAFD93B07E5BBF6CB7AD6F05412083A4913DF8F9E03A92C6C88D5CFC73AA392D3BC7EF08860CCFA5D68FAC4AECF11346CC24E86BD07A1507504B28B7F4FAEF86373A964083A254B32F65BC0669887ABDAE83AC839AFF6869D8B370C7345376E5F348DBFE2538EDB25E44993D8DA6B57AA4F599E9F11A48DE6A7449B65DB9D0F8114EB1EC842E49B213E5D4F7AD67CB7E879407974F38377BD53C1DFDE63E192703A359C5614316B22FA2E980 +MD = BFBD50F87028363EE82C35B6C1D68FEDA8FF1D6047C26DDFAEC063F080D0FA92 +Len = 6584 +Msg = D1890B4704E169C28E44DDF62A1091450404910539FC2DAEB26E8ACF4533B024E5215C2D02820DD8FB2CFC1743955CBACFF0F8F35DFBB5E3F942F36247F68211D518F3F601AAE12A1CDC000BAB43D4C973F287E80741DD1FCF6C34F2E6B4B6C313D01C4FF3CBF9166F26946F18EF2D58271BA9233F09A6B77BFD4F48B36EB3D73D1133C4F842A7DC3907F680B0B773242C11E3DD973A44327EA7CEA9C0F8E07D682B6651E506B587559FE01ED721000BAF570A16FBDD9EA29FA3DEF4BE912058321A8B720C5C102E48A6E7ED6F8838D400DD57D06EEDBCD15323F86D855C94B21E41B14EC9E1BBC8019211FD88138C91F9ABBD9BB3914D26C1DDC21673D2D51263B39D66E741D924CF2B192C5D2C1A140126A3D64A2C77BE6C2C6EBE8599978AE90BD36CBB9AF64D078910C4094AB3BF399C34F2AB8EF843E9FE1BF88BF443BA21E4377E5F49C07FD9653B526E14562237F02D11B904BCA6AC31AE721A43E3C4910A24AF6F4D80C031C109FC0FE49F15274BCA92BDA04C3B4196C192F6CE489C63A806ACFC895AB52CAD657C1783B528E12D0ED856E1F8FC91F2AAFDFA0A92498D68530772EE73B359FCF1418D1096C46B34DCF90E5B468BBB2970BECBD70089CFB039D64CC50FFF5EEF26384D34F24515A6558B06A1FDD88F1050C5BD78CC6ED83D4C2B0E882AEBCF84AFB0430D0BF09F2FB42B8B4589158093A7709AAE75A790910E211EE1333FFB6FD80778DA3BF73858978E9DD647978841B18001DBAAEA43CA0C0A03DBB9BCF30CE76A6F4B2CF2A9B6531B3E4051E7E05090CD421BC66C4731E7122AD129FC42DEDC83BB460E3F889992FBD3CA072686E56B72C720FBC98D723EF7F247286F77CCDDC728738E941B1A74D4F16671C21FDD5643A115DDBCB88EE7EC67EA66FD2BCE718DF6E085D4B5FC71A72696636A8F7B3A68AFA51A896771FAAA7F1F827430AC5E8089DBC0D4175E1B22A057BC5F1724EADC1A41E78FA3ACAA8B97E5F2E19EF9D59AE12B04E7F0E8A621E098A66910E2A5ED2102B824CD3EA044A854F1CD0B33E61E7F737414B2953549F25DD34D19AA1981DE7CD5649FF6C6364A4F25312EF62395A747AB88AAD722C05AEC40DEEA8EEE5E779EF458A68840BC6BD5D29AD40F98B3AE010B6213372ABB7BB8B8 +MD = C7490B05B172A1DBAAA66FAA823108D44C82F1E82A41FD57FD95000F30DE747E +Len = 6647 +Msg = 66658E48FB1BF202AB801C65A163A1B7CA6D52D5AAA10488DD09177F8D2A1BBDF8ADA68C6CA257006D24FCE6FD9BD0C785D07858333E0317637D9F126AC2C3A8477C13215B896B7EEEBC992ACBE3BFAD0F3B7DD86C16F53A036FDC638D7DD602F45EEB9E6A8FBDF6A4C58ED5984F3DE1F7E47BFD293F7D21C7EF939491FD3C2C59F929AADF93DA73F1E5733ECBCF36E0B0D42302DC1DBD510AB8B5263E5634142B512629BE398DB846FC56496361D2B602502ACA3A0DA21519DCAF81C50D9AC9FCB3D5DACC204A643AA2EF6F3FD3894EA099C3A5F46CCAE374C676A9AA23C6DCE7D8EE6A5CE62E7E6398611900EC1F597B957FBD8280FAF4190BC70B100C79A6D24EB8DB1DCB7FD20965B3F90E962B72974415F082A0A10A32CABF0FC93216AC98415B3C9BCB693A0B2A1740835C8441CDF317E1C624306F74390DE224E2404EC30210166F1F89C0C3778BDA439A76731BCB6FEEB4086503B1AD2AAA08EBFA711C5D56D8F46411847F7222014A3B410FC00AC34ED0A91241FBC80323E4264DC48F82F9D9B94F5F109D23C60C647AC656A19279521877A9B1A0E00408BDF73AEC3620D87277517A99A7C9FBF97D3E40C8A0D4B70C7FD9E3FEF32908AA37E2A9E7A3B40518274CE33E2942401082626047BCF2AF58530CA584640B15D17D8DAA07DE376352B95173ECBA52741720E80B4570ABB1625A6DD29316248D07F4E9C0AD04AE4B24CEEE66E7C3946EF09088EC936CBAA994D1808160BF83293C71CA18291D94B6119A881B2D9066BCA590F67DFD8DD07C33045E7682B0034E660AC08AD340A0FD1ACFA2C1CC58CF84C270532CB06AB4AEF03078675593B331F544E40ABBA2591C4EAC491C17E8F28B0DF42E56F620CCA689A32D2D5597B900A21593EB1207E786758F3CAB20D15C9FBEFE575A74110D2C01279F1D3AB2EA0C8F97CEF75D73EEC36CBDABAEA0D7602E64C67A10F73B50B9B7A1FD3CA1B512C08C596083E54315941833CEF0D8827168B99FFEEC4EA03A1D44E19EE6D7D515106843C05E3A420E6CCB1BBC950392072FE078E003227C1AB7B5B8D15251245FC1F9D23EE68194379D994A8332B227ABF373208DB0B69E7D619880C9815E461E303B57C7F589EAF7597AF6431D115EB7CEFDEACC8E08E20EFCA73556B00454AB0A1A7B1872 +MD = FD9D9F192C7CEAB5DBE60DEF3B01FC54CECAD1BC2E89D0C9940D0FD63C8406E3 +Len = 6710 +Msg = E4CA44F3FE4752E70F308262B44EE929E5E9865543B5F3EC576DE0CAB0D28C94AF6C79575A62D004D75A8AF772EB54CD1E3E4C496D6E18A00818FBBAB6414F68E0E20D2841D9BB6563DEAE138D246E75A69FEC74B79C6E97685E38CBF2E49418E466A2890AD26EAD33DDC7B107914D8AA281113594AB5454E6DA6FD6AA96F2466B7D6986087B00DB4BCEF896B5C6658805A5EECC9B2CC82866F316F3D893EFC344668028358DB89016BB7246811F9B7C3037FAB64ADAAC51640055ACC4354CB8A3A1D206912FEA164ECF33732149C3CFE81D4722DDE2E95CFF9B54B56E7FE533D8B124F4E52909F05FC07C84DDF26B8D7DC80E154EBEFB31A2B0546104FF05E8365214FA5BA4D5D20BFD02CEE5BDEC275AAC34E6B9A15E3238C542B3AE6928194126221E79EF4278433A01F5AE5F6CC1B8DD3BA61AEBE08FC479B6CDC4618E230612630305B435BA781EDB973951FBC5C3E4BB65C0AAEC6EE179808954ADE93110046DBB12993824837C0CB522D095100611674F605730172C3DBA6A66C718B0E769F7EB5531E93BDEBABC6F0C8FDE31B3E8523FBF996100002A96247512F769A5D0525DC5FA7A1B07A3185C0657A4A4644EFE9804FB9F17145CFE123EB051CC387AB119B74E57EADB8522938578B049CE282D65085B2E0424AEFC4F62EE818B4762B39665F40B008BB5D77432BA7C5719F46A17BBBCADA052794D0788FD504C58801222ACB86B463B99FCB111D63513029CD6B9C28C50D9CFC7478578DD4684DBFE6B7376A96206701AEE10A4F72E4E31506C6B71D9B38A64F7A46CC094E2822A5220D14FA1F721847CC06D7D9F99D77B7760F5B99178D3B84CF417C4C98BA6C56AA0713D970E8591337EDFA72B3A45A290CDA01ABF9E47DA239C91F8AF6F4D65C707669F431771804330AACB7D66AB2713C747781EA757492E49F20DC1DEB7C2EDA68F0F5481FAEA21CD3849F1A124BFBB13D4E3A950FA7B49CA9AB00A42C925DC733F35DFD2403EF3DFD52D8BCB02A8CB3489369069FE91AAB5BABE391457DA7ED8683AC8B28791B18506B18F3B74197A673EF9675419E6B26EDAF7BCDE1A960F8D2919F22873C5A772EF945898A1A31F811B5BF1C28B11060C64BEE57F5F859BD4EC6D49B9FA41544FCCE47F58E10CF80D7E5903D78A3E29E38CA56396BA13270E92D91F70 +MD = F44A42F111B1638EC07CB1F1B841DD9B27E72999647DCCADC65B09B9D6DEA88B +Len = 6773 +Msg = B55E4E9D70D224761697647C315F2DF520D62DF01B0471E8372F58C80A5D5C128C1038A4972B64C7A33A7769062065D29093CA942F42893463A2100F3064366391CF070BE9ECCB1AAF1796A7393C47C39FFC8F8B30BDCC0FB24EC76854427DDDECE1E0CF82486A06F529F9938E4AD2D9B3042EC402284C7B8DAE4EF5733FC96E0F22B7E3957CC069DA40643A6D385ACE15A5911396DB8DF86C60ED088524508C45CE0677C8FEFB3D5A5AA43CA1E983D8C9F921AE473A7EEE43882801C20D590D36B132073B536593C3136695ADE14E15185F9A9C2BFBA75E175757A2B908BDCA6455327A3A3DB7833C0AF11533FE0D98522940121EFDECCE64A471C3DFC73295F8BB1E09CB6B8B80E6AD068C2151E4C490980B610CCD8B5940F705030CC781EC80038D3735509DF4D0FEE51B55810456C078358610ABC60E625B58C3E593660094ADB8519F428C79D3019B360DEA4941F24A32799E4052393918AAB21555D5948236A1DB9B86EB7F1C9EE9801D86F06D5646939014B5EFE5A3C0436A2ADC1DD6E6B0300A30F39DC3DCA633DAADA8B73B41F6E926CB60B6984D4AC3AAA850578DF8A742B3A44741D5035EA56E9C3E5D1383858D6BA033257F184A5C4A034769A39F09A0973725AAE8ABC753F9D99216294FD38C157BEF282A4A596912691F1C25FBC1D609297084106071747CA57E07AC033F4C45D93B16C719520E47047C2A53D674DC56FD551F7C7B32204058FFE31EF29F8DAA4C570240A84245B94DFB4AA23491F84B979B9BBC45DE0ED963440EAF7EE731308528E8E0615B6BAB86F72EE9409BBF9721C2F258AC236AF1D35516AF16F39268DEF0EA8D164E5D05B5B051CFE81A5A2ADDA3B23FCC9CC2EB780A655C93AA6A41EBE5363E32A858D19DF1E561589C0067FE66FA3ADD9CF087FB24D4979D8C8913DD6BDB236BEFD2EE09F8E056826F33DBBE050B105C6CCE1B7BC23B0E6F63B25E1399BFF98888909A16D51D258EB7ECAE768F8F2A07CB9B2C3E9A5B257482DD301BCC686C983D08E3C0CCD540E22558396DA1F13E1D31AE1F02A840523B400FDD41A7D4FD63B66C30F680F7E5B0EF4D97D02E747234222AF5E0E6B8CF3A028DDDED292D56159F459CDFC732C2FD95B46F936BF5702ADC72E03FE02E48E5B240A358985DD897F78EE78BFFDCFAE4245D7090CD17454E06BFDF768048 +MD = 7B3600347FB97510390A1091A832DCD93DED06E6063F11B762B4A2D7A7E0A923 +Len = 6836 +Msg = F463D85A381ED8417D17BF2E5AE6B65FDF96E9A581448053DDAF8A60718A2036653E2B1C4F2312AD16F278ECD0CF5AFC3620D5A338E859630DEEB396CAA02986F818F91A509FA7EC71DB0261704BEF62FDD4507D86D0CAAF0C4979532DF3A823859C75769A14D1BDDBB453CE3FBCBF37CFA0733753965D85A1312B8EC5C3C3474D34E6FCF015CF0F8F6A875772CC176B34CC7A966F47F7E0EE7AD58E1D028C65B497C1D440CC690F5F545C3EE8544FF8575A11FDA7FD42C0F42AE194A0E1684F082105C693BAFCCF5C2B094C7018E20546D3820AC8FDF6B8B5BB252EE43B1364F36ABFCA055CA95E5FAA9183AC9E85EF59536B408A163AB800519C05E063D46CD77C24175D218F531D96713125A4AF8E737BA2700BB2ED61764961880B40EC22CF29E5E3D3B651E1502BAEB9F2DD19ACD2E98065B19D2A3598F9E34AF2EEBDED3E898A07075F68D21C5CCE3AE338EA84895313B86CA361FC2A009F226FB8AB72425788FB8DA7B1828C797DA700826CCCB90C11C46EE322A2F397A01A166B1C04EC9967B802FBFFE8BADD9DC648EF271379AFC2965C4F174D7399CAF690847720E020315E266C61004A4C5A15AE2BE20559232CA779A396979E2140B3B33FBE41C463B1B39D42288D8C82073797529C44FB2B75088CB0CA42457F1601BEBD013C374DD920BD494028D19366663FFC9C3F65A89336CE7F79E963D2A82F79D048A22BA64594874BACB0CD77BD6BBBA867FCD43F0A2AB22DF3D83969879C7D2EC353B41DE5ADB0325ABE1022D90754B989715664C11E1765DDB9ECFDC5CE7498457272AAE4EB0A30652128D2BA44F3D86EDBD68854C24763061C01BB32285A95FBF9D005F4694ECC743EC29DA74B7612052007E340B1C7E594EA1A97756B89A7F192A19CD55E213C8FF3FA127A4572B64208A37DF254FA04172337B8A90F7CFF8C3FE53444130829CC96B485AB524072A1D3FF1C5F4B9B6BC9DEA1EA238A0BBCF5B340BEDA2C1DFEB3F3D121006EE2DEAC7E4596C57C2872E2649213E41BCD581CAF31EEF68A9193C0411024FA67F27F663D7F1C1D92F146AB85DDAA9196642CB5787C7810C2E04B4DDAF7E6FB2F2CF2BD38C4460A5FEF74D8B509D9087AC383A954C35002C73272B39A36203BC380238B8EF6E9911B75ADAD067BAD5682289CEBBE8C6CE2A794BE63461D6961C54B80ABE3BF388A74810110 +MD = 08D7152F1989C7AA7DAF7EFAFB83F14988B2F3E328053C38FE062AE3F605EA80 +Len = 6899 +Msg = 7A7D6313A2EF8EE4509E6AC62229C33A49B27DBB1F52C2E4D4C5EBDFD18DA4EB112700782E57F3F1C78332C0F9DF8BA99FDA68F95BE3D47F5A78EEF86FF578C8F647B93F96F2B8CFF953668C72551C9CD1520BD601832F69436124F0C2D4A470B6084F636EE58037C474A9902086D5A36353E6E40854891657C04A4077F20856004CE3DA17A73583D858048893C1B83484C8DB0F68C12A00C94C68B57B250BCDC6623A28A1AFB48FDDAE4B353800FCDD7DC50441454E41C31824C434C7CB01C03CC9AC0A92A7348E51E5CEE17871C5153D034CFC4CC6E9D9F2BEB323EA1425482A1433A76DA25CE36B9733CC1FE29A08BBC20D62F3A60123722CFEACF2124FF9EF7A01F156749FF7C2986A66683EF5B9F1853D04039516545B128031352EE59D63CE5050298FB6FE8855B42FEE4B11372AEBB81156A35F93E7539583AB3408AFE2960ED976B63E1D14724E19EE42613BC1212FFB00AAB8958999046968DF0D473C54CCC44152602F41486400EF4A3E79817E5E298C1042AA478C1B6267462AE4BD0750867B7A4DB927508E0D5D3A0E5CEA2EAF67E7C95D0B72774B26212B2ECD5A0B4709E92386B38FC5C2A02B4044BAAFA72DC9F0EF93096388C8403054D7BA5DCC1E5371F9008CA5A93A1CE494291944C3E676D17CCA2D3D70F9A5966C4354AF3AD3968E07F497FF8280E3BD9FB724A9AA369FFAA0B51CE4423F1CE71F90552EAB4E3336FDF8469CBC8C1E4CCB7EF546012D7A6632554D4E179445730AF11935F74D65DCEC9214993A4097C6378C83EE2AEB29587504A7AAB7DB636D019A949BABD8824A37766248B4EFFE9D9BA23532CC006BF26FB49E0899A23A1521E9CA734BEA64AFC19792F2A192E8125F807898F2945F4A8C1144F4C88C66821C41F3EB92FEB5DD6DC03F251363D1F5E95D25E6ED2905B558582B1B02F9684AB25E8E5CFFAFB998B133346634980C6EB4ABC32D86B6B53F1418053DE710C8A0BA6DF319B7DC50A11E4B37939E49FB2960D1FDC03A345C020486511969797B39845007F840F7F71F757C7DCE71B76B618BE37A23E00B16B17EC47A1BF4EE17B01A557807F466B57CE2867F57B51F5D6FD0A8AB3554F9C85BBE6A066E82F5E353EC8ACCCCEB56CA470524F293C81EF4E52BAD2540D118297FD97AC0BE3328BE00D74F2A258D570DDCC12CBBA6AF4261C348DEC57C3C7566B3056EADC6CB636F2C4A00 +MD = A519510017D4C3AC7238302B84646958674758ED5EB46D905039ABB74A42A8BE +Len = 6962 +Msg = F6D0114B20C0FAB1DA3FDF59EBD3A09C04E41724630B6EDC31884945CDD9146B707E7E6C25470500204549A60DE79AC926FA8164C7E2ED35D2B819A588D95B8F1574BCDE0A6C768EBBF735A97C7CACB27F9B54433777EC94E2C8DB73B119AD7503674CF3D81322350D51BE6B985AB09D5DE56BBAC1CC45CB30D07D5BA66709C0AEBB71C2E508AF23BB042CA97C386739B3FC6648A73715E633A3462A4824BC5D9321BEFF69EBEA995ED99B6FD2D3B65DA892F60E5C8259269C6904BF67B612FBA0673DF84F8EEF48E6E255E8CE93D8E2D7864329A271DFDA0D1E641564196076D3BE3FE1BFEB80990CFFA399D76BAF00447924B7DB60AFA331A7310ADC8C06DFF6FCC1A8D2B62C365189B44A5CD651758B42F28C656E77310896734A2B71093FB8FFFACBE8D12F107CAD309BCE25765F1285A6DA063E16C75DCDD575E0D2F15E3F539A55D9F14E4071442EAF12B7F97A4F2ADBA5EFD98A70CAE2356380A59E3ACEDB41CA2775468486F5E1E5F70669E52F231FD51F8AF4EB22ACDE0EFFD3384960A4A849230A81156C026D0E72DCDCF406158C7D18BBA67085189B77406599B58CE6079F27ECFA92B87F5217557CFB60B6BD1FA4FA91B4241EC5DBC164AD414A08A9FF1995D893B78A7EE6968D50694F4C29569984FB73EA907758EFD38E35F37FC7AC1225CD247E5C59C0992702A2207B64BF66A7A01148F0DC3686CBB2A16F353B5AC2643A3F1FDB4E6999B26246732B890831790F52536598D8E1EE28DFC84814CD2139D00DC3860599CF23DFEC709C2E9E0DC24F697F12687674D1A0F25E28C632DFE917D66F7B1E51C80168238C40F24DD4BDB50DF4D1191B924EAAA841D2EDC45A34822C430CE668B91B5D092680E0EFC40A4DFC138BE123907FB14D01C648D97B3809D1427BD2BA32AF7672655B460CC78641EDC8BA40FE8B3F47DBA9EEE46B608B8CDE553313BA8CD0A1F9E10DFAED56DD6601D30C4BF66E2914A478C7882DDA169446372FE7525166C12E4151626DD04FC9E310D043AFF6B6A952C08C978EC9CB11CE39DA74A902EA2CEF8BBFAFA0D7B8C6B426925015217FA66EE6D9371C0DAA8C325DE6B1B29E2B055567232028449BE79ED3EBB174858A6BA0864E8726F876ACE34C9461174CA04A34B612019EDB27F1CCA17AF84D0162939AC2B0174887DF6B7E2261E4DB04F31E973B5F3DAEA87E6C20759A9F37612B54BFD4FA1A2757519700 +MD = 1C2CEC719EBBB237663A4C5640F485B74AFFD5505C2C102942D46C2E60E278BA +Len = 7025 +Msg = 6209AEA4A5E46514D858CDBAAD6EEC5F657E745430B13123661EA806B69D5C7A4CB8FFF753218FA993D0CD4D2B1E4932DCACEA7CEEBFB9295F89C0D66F9AA94847BA2C560F09399A18E68645B7A560B9B6BB9190C3F2ADF182F8426736C7CA27C45B8EAE8F651D7B6FC98EBED8CF712A3BE248F4034D3B9620E7A62FB461CA30A2D262A0CDEEC7118EE809DDD4EDBA76859DFF70E69B656A1183340BCEF29F270A545765DB03FF61D6A27CBA923A361D4C95D07C55C5045D3A20F55EF38398A836BD76BD5529F780FA2120DAA503B436AC4232A852EA00F2EEC750CA125598104D47A1E470683C2C210B584BE03099540556A343EA3BED38F223947F9CBA29C69FEFE67B27D32A043E608AA3444377F8AA00B23BC206A58FAA1357E04B7C0CA9A6F02DDE3572BA20C6B0382DB3C8AF16712AA3034D1052FE61FAAEEF907C93D1117704426D39EDD8676F2EBB507AFAC886DDDCF299C4CB664A95B751DB20F266D24FDD131CDD12976148CDB6E7BF4500103FAE5CB4D4F298833BA2D368BE7D3A0B8B479B2DFC21787EC7F0C2B8ABA368252BC5850A77AB86EA9DF7D87783D220DF09D0E09B6FD3B986CCD8D251B6EFCB9A439B951BF505A5D1F314F79F27446904874FA5C2774E4485AED552A85A55C4301894B510073EF2BFE591326684F12D89692A44203EE4B21C03A9D0C0D919B741467F146D01FF9B8900AF7CF476A69B7B381DA16DB09A895BA7F690D4B663EE4BB2CE46D52A7C8007A2FFD7B965DC3758DC0C0391E3A133D73E2FEF3E9E71EDDF8430C295C664C6596187595EB870FDA82AF476CFA189857E8B2D3F8E013BD16AAE57F7F9169EDA24ED3FD51D5AE7ABF129D9D3E2CDBA70205857E8B1A936C9B9831E597B5A7B5E2E2ACF03A2DB7335143AC57A1A94E178889670180EFBD4F5431A718D04CC10A4CD79D1E2203C06378D5DBBDA54C9C05818F0290CF21EC005FA151015CDFD46917823203C3608CF680DCE1D25DA96DEAA1BAED760134C7AACFE5B34A91A792683F401A2303077FC886C3AB13BD0ED1C55240DFD1AB230FF8DE9FE23D10B26D87D818C4073195BEAD5DC0870EFA2EC647B4946340D2637FA2BB4D7AA206187CA099A24C3B5D2032CDDFA3EC1361DB8CB7E7A2568A3907EAC22D4F1A0BF9496C46AA31BD5EFF04D01C595C4E3B41D9F10A2A103CA6169488FBF74814E6AFFC2315EFB6D0500851CCEC111780C32EBFB96BB41FB423742BB00 +MD = F820FAB4BC9A9FB1A8D226BB399F511E37BB4BCA39AA154658F77363415FF6B9 +Len = 7088 +Msg = D9257004993C7AE50D20F534B42B4EC39BF358393B9FB5C8E37F87AC7361354554BE596F40E67B2ED499887E26DC435C4331CDE3BF1A118F60FD821477FFA3B92F6469568CD2CDA6FC0A2B13906AE459CF5D5417DE2CE104D0B6499D3683BEB40715582CE70DED5C5F8461EDEAA38BFA31979661A2DC96D926307128F77700F2C7D38B8A9D6C6F70A3973005350F938B9B4A64E228CC3B3F9C4FD446FC650AA6377152D7F46903D8EC8E9340710E28475CF21E641737E7D7DA3CDF18D01C8F37131E727C7274B2DB759C5586FB84EC36A5CE2D820E553DE6426B8B96111295C19DBA8D17A2B7047FCDF662A59C2AF27A9ABEE37A7F8AFC06944346E343E779EBD895119D7460E7DA998962FB1100E950A8D7FE214360AD263B8D070F2B7DC91C9D77C6692DA0F472A0A4646A1EDB069CCD9CE4CA6FC24713D650153B9A253DB5136A3710198E60934DD2053315D313E27DD2C6FFD2ECF028625F0E937AFD8C2FFB1F646E51A768204D83A649798A51B8E87FCDDA7BDDF58ED943BB7E29C7D7C5DFF024545F6A689AA0E727FECD80B561011A731ACDD9B3F283123098BA66B6B9FCE6123B35B6F3A20EF1055BE9E257CDE97E5AF41EB796438727A62AA665CC9B771C4A2052EFAC61BC91BCDF573F7263107D44DFEB125E66D1F3DDED3BD63845AF3BF4185A9A24A7F4B777C32496A6107B7AC940AF24BE983F6A758E5064F8717EABBB86E6AADA7DA75F72ABED59A42DE82B1AA2642F5EF1B2E7304F642EB2AAFBF00C1183D9B5FB83893EDD48E9034DC7A7AB66F3F392F9666C00ECC9743AC4F777EDCF47B6818A34B7392B4AB8E38891FAB4018DFB99AF06369115D60C4FA073240D9C2605E020A42DB2E1E0AE4ADE3A04B825927A05D4FE3F50C1C7ADD7A496DA7E95825C064315196C2007524D1E1EF2C51303DD1203AB66D9FE89DE553CB4B95A6C5D629B89B7116463EE10AB3CF2C2615F95741CA226F9E9A20E99303888F725C77476533B4C393763170F18F292C89A22DF68EABDB81AEF11CC2AC329C174BDAE5D3CC0BDCEA6EB225E00C15021432264BA7C5EB49A49231D1F7A13AFC238BD4EFC04DA3C15AE0BB7D693A0150E6A5AD9B1E11A490B3CE90C027442501684C528FE260881162D9E5EF84D6E4F73F222E779E58B71D5176D9A27F65E49D83EFBB2D7810E5B06619D8CEF7E7B51CDFB6E8138E4CF5674242F947EAC13FAD08D68A8A11AAC9754A5316C93738BA7F3C3BD2E827A +MD = 183642468BE2707C3349132CD3B0633AA63E5752488C3ADC0D501265FF0529B0 +Len = 7151 +Msg = 8F7E0705219E6A4B9FC32E64467C8C04B804CB3EF04F40C32B00451CB3A9D94A658F47183514F4207905288E78E02D28896718A0776046CA04893517547E7BA9E75FF33FB52ED38B07B4E5C53FFCB64C001075ED46CE91D4A5A9BACF3781FFF686D157E230805A25788B5BDE518E379F1B5C90C7D6CD357AAA1421F45EA33B0B11653903222E48B029F4266DE460E43B733AABF5FC00CA9C12974FC95DD4DC1D13C278D80A46BC3D0EFA151BFE88E21DF5AF7159FB57285AF1C4DB063E8BC6BD062BA2D051FC25112929776E952468921C682BB6749B2EC7395A90386B541A78AFD88F2DAFB2B321F6AC20A53FF9F505D22587B45918B01AE302AB0A51658BACF310FA3CFA8199138AC7CDF811DFC5087E53DE233BEADF51E4DCBD5AF0DF98FC0C4E185758649DC77E42B5177BD4AF033A9FAD6AC424FB6B0B9BDD3069C57DE82438A3767F01405C99EE0FCB0DC1D12607ECF7A936B398A84E42A512004A3EC50106AE1E93198F79066F7875574D1021F599DDE9C1A3F8F5F67B8A2DFDB2AF39819E573FD01C7287DE9B3281B1B9AFC1C66F80D8C719C6471EE95D38650CB6F7E80643D49E107E30133F2A76B3B0C35263501E33910AF3BF69DB0D7CB5BAB31A30B5D9F043CA2233018E6555D0D8704021C35F6545297E5213660200C62F6CE9B87109EC579A2F3607E68BC849D72BC93365E7719F934D87CA153E3EC9B7247027AD00E16A5966627BBC0104F7DC158E58DADDC54A364C8DED0FFA65EDC426F0A028B914C668CAB89A5798E93BA8BC9D41EFB5CB747E0C4F4C6DA1D1D3F2210B9B2CCD102FA114BEF68D8388C2D647B6DEDE168E396D7A369D332E3791C645010CFD357C6BBF1132C9D20148DB43FDFAE1BFF716B4BD7059B4145CE43AF2AAAC7C8BA5C23684C7FB52032F6B60214D102448E1B3420F92BAF01A32C753CAC6DB23CAF6C25398349A09B9C9EFDDE371678E3898B3A1B4BAD9C50D300D0087AD692D5D40801363AB5EB1CD361A898C1CDE2DA8216F55D62855D6AAFFD90539C39CCF1870CA57B0A9439F20EBE323E353F2DE74A607E8AD1B9A7225597190C0B37AE73D483499878CEAD670129D132D56B1F06DE4D01200ED269185C720687AF0CC5FDF1EE1392FB099F63F3EC54A0A168534C65247475BA5CA23C0BAC15925288D3A611C028A0927B70E656A9679C971798FD53B3A926A0898A2E349F6BB6ED3C39D2BDB3D542F79331D0258D61A2B77677F71B60EDABE097B7D54E83346AC +MD = 0A0DB0CD7F70E6A8A3A862001D12D30A0C12113E9CAA0E1E0BA323378F048101 +Len = 7214 +Msg = 8479D5F1A451AB0737F3B98011C744DF55E94704E5A85F7063F65DA84E10309B14E7AD570406602599BCD3EA1302DCFB3D81C70E7204CE67F17206226676724BD22326CA0E6391B7BDB196149CBAFAEBCB1B81F0944D742224D872CE6CACC0E5E2019B15BB7D367526B79A991122B6B99C5A1217B8F5D0BD6958D520E2BCEE07BA043F0FFEBF1AC15F9511037B74E2C3D1A0CB747BB1E3937F904DC1821707B4D1801C70A9195424D345AA45A3C88647BD93D72AA92F55D01AEF2F98EC2E828DA0A8C2F4EA2BD6209B46B337A8AFD2C7457813ABA5F4CDE045F40BAA27628481EAE3BE624FB6E3C2F9D0DE83DED91007AD6A43CF317F40A733EBC2CD29E58317845C077CBD52A4B87C9E50F7DA191CD2918038A4D8D7907FD7C54910E2D305D0E0E494F0508DC25D0CB06BCE4051E6AEBB60322D607AFB5F25A9763FCE04A41038DCC3DD1F4458206E4AAFFA2B2E1B67C02E8D46825809F2CF5FC4EDADA724F3AD45FBB7F45849F12A1D42A91DD606D72CCFF76C0A5FC13192E3C6D8514192D3B891881233EED33F623998294EB4537E9BE6BB0FBB9A2D837B6B2074FDCDCD22BB7A0F1FC1EF2F6479B3E7AFDC0D8AFC39F7AE830BD7446FF3541BD22FDBE5A3F3D6D5DBE1613BF08A366FE87E4A9E23A1DED497ECD1B95566DD88E6EF0BD8EBCC23BC26BEB5CC9D0AAF8C8191AF4F8B99F2CC1D57315EBB2F7D5F81CFA75C4353F96FDBE539EE48E8053A8E496A39CCC4F475DC191AFE51A40987661DB17097673D322D58F1C2BB27B8990B6035CC44668BBBECE0EC43C1236333E1CF84CE996201FC28F3E83A2AE5A48A9CE7CA6C3B1E4E2A77887789995D09D419C658468D1315AB9E6D4316D5D68AD37BAD294C28ED950717C2D6A808E400AD4F5A5218F55B735BA08C24895ED62413707A57788D8986E73694B7A524BC09B5D72005B6D462B65376AAF6636ED05F8D52DE378C0710FB91DEB061773C70FB99EC34DA836A240C9B2517A183BAACE693461CBF29DAF1F2E894041578B45706A4BFD00EA9B073F6F97953796848A6D569020CE6E98E8B57CF300F36473688F16389BAE688A075B3360B6C0EBD50EEC38C6E10D823B4D19A64F4527DF41FEDB20A8B006941869F72464D81E0F2CE847CE6F53D0CDEBB7212C0EAF6A3BC125635DFB0355C500BD2B9D8A9645E0191B7B79F5C19999BB6F63C5545EC6653A7407C59BD834A54415B1A821017E8AAD2D089452736C06D795F84576F65EE65FF70B1457307D25CD8C9F05B2F0D70 +MD = 46E44D82B576CD5539AC5B71578ABF1D7EFAAD86FA5A139A614E31A0C03D7FAF +Len = 7277 +Msg = 26C418BF7051833722842B4C2D61501F2032D57200C34FF65906441A3B1E0E8707EDE3072B460959863D83317EC35C2F1DC78426B56D39E896F599D99818119DE07FF554DDA0E2D48ECF49FB07F107605C0179F7AE10BCC1B09749076B35124FEFFC229B99369CEFCD7B4FA970712EB8DC00D8CF1505959515EBF47D457089BC625909D501541A284BB38902890EE4C3223965B322D0D13B7D0CF5F0DD2CB00BBBA2F08EBF686E47DD354A413F10DEA4C3A95ADB5C87C957E68AA8361EC474896100DF796861678B735CA13A67DD27EBB29522A52EBEA2AC41763F8059E2D9B2D781F4501AA31D55C25AF6106110CE7FA82CA9A4EB31300879531C6980D256240BE41DD85B62A8B794A1C4E6450488AE3B026B03E2D5D7E31ECEE46261FAD0EBBE17FAB50FC1D9714AF5C850D2D397021A4B10B361D5FA166D518F78AA07C4050C98E9353518F58EB932ECA7F6D32770A20150C3B4B5F903E53E6D0BB6C01896EBBA8814347FDFAFA5206C08D6AAFC47DD08ECFC3A7E818C95A8097E00A625EE57025BE90A193F60FE2491589FD740DE39EA26E88256F037890E52BA8747F09EFC9DB76E082D5B9006DF0643143D5FD86B0DFF02C6632A0E84523D37AA39A5C3BD60F468B88BD3C92610B5E3813E065D932B2C3D59E76031A43FBD7087A2B9FAC28C8CD196A396F6A3736143B68035B34AC5468EE73DD0DAA8EF366EF3B54E9BBFF9560E7ED06DC3F8D862FCFE7F41BE666373355164482D165A35845C6ED54F895B947028BE1D2F3EE44B346E2F17002B6E030B84C08F2AC14B7B0ED3EB8F2C0044450E6E6D29840068C11CB8A00C6705D7B39EE96EF0C1FA3788069E941BCC1E8D4834DC2F1D0D85F698412370D76F35712DD000538E9461C47183A402AF7EEFBF80B1113C939D2420C8BE276AAC8D8DDDDE7FE7108A23E9DCAA14CB112424693491004343F9478789F1EC1F7602C7CCA35261C7525FAA3107C3E1B2501CAC135CA2E64322089D51F7A8F7813083270152110EA51374B56269E241A2BD3920FC6618D2C209D7A0AE77ADD9D74E7D2A2D0CA74CFA6D4669522BA3DE367D0037FD8C54E6A124302A778B6967C3073F84F183BA01A68B12ED2BEECCB77B7463D98AD398B23CBCF95B757F187DC7CE6A959BC0AE321E96CFA755E51F5F34A4E2371AD9FB14724E10A5BABA3ABEA670E335896DE2C1CC4CCDC6FACF6066326AF1E607BFB535172567A2762F7D35C8871B652DF30D5901CF3018E953B45FAADC4A2F731EE6C6904E1AF014B7E40A3D30 +MD = 78EE7EA4E2F2C6C608EA9FD9733C5ABB448590303F43E191DBBA3F4F9B535012 +Len = 7340 +Msg = 95289EB0F620864E683ECFC94C8522A386341D700372E8FFADC5A1B0563B58E4D288620C85FB4BEC9C844BF5E34B91EBBE21C6F5CDE284BD9CCF71E02A651CE5708C40CD9AA6B1E50A0475B588D1D73FD160D413C337A3CC2D5FF2EA10050DB7E61EBA60B030E3603FB2CFFAF3A4C31E81A6922CDA5815D4F257EEE7D5A2BFF8901FADA50149B525E50A84D06CA8FABC25B9221DF28CDFA7DDEE853B30FE113E64FA2179CD97832FDC3C99CB37F903980F33514D7D3BBA15A320A17FFB59DB9222CF2EF3CB31DF8435A46C93896E0E7E09691633F0D38057499750D24FAFF50E0762DC8F4B7858BE42B039B7B06CDC78FBFB1090EDA4B4E14D2D0D817E04646F0DDC063CD34EAEB113A5AD47F6656063DB87363E4326FA1128F85B018E1AF7C6516C2DED84B4D82700F7BE9E943A8EF72BFCC68E64AEB90ED21CBEEE27229CC3236EF3F08193A9A24E7B2D090F0A6AB90EF3DFF86170A630D71FD650A9EAF77B5E88D8454A59ADA5648E416D945EA402E081A1555A7C27B9D59176A042172797AE1D24F6F43365BA92466914EE87C9364692E9EF06EBD3BD31403DFCB66CCFFED70EBF7DF3EDEC4536D0EAFE6C594115F00B90DA6F94CBE0C2E7EFC7AE8E53A49634496851AC459E1205DA74158092B0631EC2D4F87E68DE1B7FBC43CF7A4592D68901805A10ACC0D6D851A9DA28E28C03B154C612CF05DB4E72F01F6F35F9611309805AB028E395F0531A45F82EAA73E0AE3DDEAE3DD4D0F8706842BD0BCDC6A3DF6E2F7940CDDECD2DE4124DD03C916D7F8CC39D49C9F62666323F27B4C425AE0514688B5D7C62299DFEA6AA7A4E725F639905EE204C7A442C056AE7F407F62AC137D1630A50EFC126AC7499B16FFB52431C0CFF613D2AA7889CE3A5DEC30996162D377172F1DC6B5C6A5CFDF131BE77C340444358B130BABD4BECACFBCF5CCE801B37DC3A094DF0CF5E3A6929195447B6089EED3F07DFBC3B8A9664A4FB000E4B7FCEBC74B87B98D778C06B0B92454AC54F5F3E83DCE8CA496CFCC6793D0C5DAA4A05CA0818B17ED380A9A7CF239F84172251894AD17985AFD5DAD307E763313DF6422DE5EFA44D8CFE5D758B89DC2751BBEA53060AF3BDA5B61744994A3F52CC5009970DB498E7B7F5AD29C84BB217B9ACCC7F261548E7468D28EB5FF0187C77E9D0AFC89658807DEFDDE85A2584C73FFB63F49A82638F825076569ED7097F6F4B774B195F12ACBB30D0080A443E4C1C1967E346872D102297DA418CB5DA71C78378B611543BBDEFC6FDC1203352083497F6AE00 +MD = 1F01B7EC56C36F797E1E4A02529B9D916C021DE92D3C39C23F1DCADA293BAF6D +Len = 7403 +Msg = 051963E78854346245265A5CD55B90BCBA46B993DB352850208BF184C7D59455EBBE89D5C894E5F965CF1C76DAC864043A46F1661C1249309D1E989AB9CD479C6842E4F27E41ABE19AA19A552C1D8A4FDBFDBC027A133EA680F29C128516144842664D1B86165B10855FE82C526424FE59C854CF5E091B28E2AFC02FF231086BD95B7A982CDA5F642326A5A3300B8BAA252BC5247B25EA2F3D8971E5FCE80F1C2430BE37552AC45A63E5CA382F9C86D3270E41A532466877345D817E848AFD70DBC2C56A3121FE03ABDE599533734049B9AEDA37A6952535FD72FFFBAF0CE69CAB771CD1891AC28BEA903200A2BF2AA1D4468A9CDE2A3C0F012F7D5B6DA412427D12762D5DB936455E63797D362991270221C5CA4E8B726BB5AC80ABB694E84150AF1AC5860C867E2C7409326EAFA12301B7314548B604BA3B4A21C9857C8126D24C2E1BD1F54B5901D0D0FA2C8A6514AA7478F62C8B6AFFF5EDA3BE6D55BC4C8A8325932568564CE5A5A4A8131CA2CB5190EC351B7E0EC7575BBE92B7738E39E9595A3F10B176E7DC9AE87C2E333DA75A7B1C3148738D1E404C680E0AB145510B73931DD4BFE2EB36E83930411A43BB9991045F0AFDDAE5D7EB9C1468616F0B1A075E4169B4C9A78FE7310692BC0677D95F1A4E3CB584E31BCE4FCC1D95FA4A1275FB5C7DC00BAC3B06EFEF1F8440806B56C98D32A3DC99C9CDDA12DF5ED4922E66B572A8A2AA06CD28C9879A8B186393AAE5F15654A1A730997A282E18F899ECD66691E1DFFEDBA78EF1CF1AD1360C8C0185A11BEEC682C0A81D1103BC99FEBC16A533E8EA241058ED280BD550140A7E938F98633042CBEA47F996C34A922659ABBD2F80407571DBF434473F3D0EBA58B23999F7F8E53DD7F47CE113374A16395C1F7D8D284D63B87D7FB6B99636D2756ECB25BE3F42C187EED49E4CF21B325CB4638BC0744060266D09D59F0271123B86C2A6301891E76AD92803F449AF2174B020A7BD25C66F9421ED480FB5B2E6C3FB3400385CC7C40CED2BF8B974028602F9E9D17206C7DADBD1DE350F5B88934463D6542F502F6C0A40FC217427B5DFA285C02FA47E2C092CB979963DB032891A59D7E69799228126EFF0E2976170C11F1AAD9ACF26A59462309A428477AB8C20C3A24A5ED0AEFA94122B8BA4E18B2CE478AE6B370C9F5F4183EE9A488769B5B7B3ADDFC7B2C046A27585797EE291A64AFA06B6FE83BCCB31FE6EEBD46811AD66FCCE24915D763283A04070554949BC957EE410435337B456C2901E54ED4C32C5768797A196CE3FB034A35F0180 +MD = 0BFACAF31A0AFD986314D7CEB5FD33331499DE3553BFC17F50E5AE98C61479F5 +Len = 7466 +Msg = DFE357A826050AADB681922C333857B1B995C8C1BA285F3CD1F0A6A6BF7358F6503ABAFE3592D1616630F153FA0EB4A3B97449716D87B5E050A29E43FB02C8D4C4279BE087F1D7FD5464D9589C89846A842625EDA94E57AF1BED5424ABC0B5CB634D1E10C8250BA0C9AC87579B449A147FCB891799524567DABE35A56F48C4F5662515149791FCA8B16075218991A19AFA16C3B1C08B45C7EF8351970E7DE8B3C02694D2A60E37B5B26F0A1386F3AB9B36E16AE0267BCF230558683D997C90C6DA553D7766254E78CF5FEB97BB7FD966358BE1C7A454BE1E0D0569110C9D3F2DD53FB4C359B977765D9305C377B93921DA13160338D791D12F8C63F5B50D13F81CEA4DB9C04184DFE67079CAA291C8DC890C33C2A165E41F42844D3731C0C61C911AB5EF5DF0CD74D324050DAF63440EE60A02985B514EC9FDCC3255B4E19DC3EC5D567E31B524C903AD768AC234DE16FA58122F84FB83461BB2E8BBA5E3E1ECF0292EFFEAF4FCB3DD548DA19E6CA9D4D45C2B029632994FADA19FAA4BAB02B8138F3B9C5379C1933B2B8692A0608EC24C4E54A6057AB4CCFCC4842C135557D2FD0C12EC3662699EFB35A90958D60D2DE1E82CF846CCE847F475B41E5D8A4D2961BEED3B0B024129229777C44DACB2B26D02DB8D816D07BDA64ADCCFDD0096D4ED0CEFB69B270E06C01A0CCC6EBF441AC7B0DE897B5230206C3F922E9C451366A285DC7398497BCAB2096E6B38A00F313FBA116BD78DE010C3AD5380624821332F76855418A0ED535AD7787A3B0ADD124EF2997501BA07DB25ED1DCCF519E34D9ED79EC443C1CE77363B69B141A731882C2AB220C1B741EA1D4727204A0743FDFD85BC70B2FB75B2442B5BB0EF7EC5E859E56B9A6312061C28535AF7E74AE0620676B0A30ED835283E91F8F061DEE7E01BE9FF968767D95A18CB94833DBDC6FCBAED5168B503F5C3EAEB8F69C7D3470CDBA44CD29D78608DDD4829FC3389D6E6C10559FF8EB214D63D3AC0BB2E5185879DF20EAEF05A5919DDD9ADA191984070BE0CF63659AAB60EA4FC684AA0CA0B7904A26207647CAF7D9E7F7EC1CA35E5130BD20D471132FEB2FA54D506D6489ECC3A027C55631CFC1624488D33C3D94AE6A03FC7AA9290B11A2EACD15652F0D11C6384B3478D773223EF5E55D7E4F227FBDABE50055890F3EC763385A42A49397B099C4AB2116285A482782BAB5D64D7C02BBD4565D69244E6B7B7F7EC13B99DCF3B6F703603B89FB48C2DAADFD194B6C800A38A629AA2F0C2673C23D02E7133B7DD28293D9565FF343F8E55A6E79B741D70F4E624E9C0 +MD = 5E84CEAAA5AD9F5F1B17F003B5DD633DC30998214021C6C5D4D67A88D7C7B4DC +Len = 7529 +Msg = 53A0503F5BF74B87199ACDF708559E24E3798023808174FB5C2CA2A273890DAD651EB5F4E0B0732F242EBD70505BD7AD761801824843FD4D4714A483B911F0B39BAF58FE8D835CA2CC2080573954303D7F2BE1ABBB1A512B6B0833519491F2EFD5C7B60D0734BA28CFF9BF52A7AF788907D41A29C10BD055B0B00CBD6E85B3B1C44E61ADE2F8A9F82EA435707A24F65EE63D0324F373858386A3CB552497624C6ED76432903E6BAF3BED146112959FC517164A114C10E7CEE6152E1478D8E204990124F6BC990FE8E653D8DBFF506136AACCA86A4355D49918FE5F72EFFF0F912A8F5538CBA0BBB55FC2BEDC0E453C69DB46E5DD697B2DA3B24FEAB5B9AA197CEE699FBFD2D652E46E07941EED8505800D831542D2E4ECCACC3165F126C09996B34B608D2336ED30CE764D1F43D17E5B7B4CC04DFE4702AE2B1ADC2CF218E941DD78A036EE0E3B208D20B783C3CA56B5BF7F3D5F440F2A3734634D36F9932622787C4E2D2FAD6124C23A1E51D806CA26671BCA90EFB4E888BE53A726DFC6C90DD3F7095205A7718DBAB534803A9A62FCEFD4527D6E8AC90203F8B23CAC8B21973CE5F5F66F691D64E875216D8012A0C607B54A9E8901CB5458E046F333096B4344BC62CC5DDD7704E7DFD9635A5375FD6DD081E786C71186D46E0D3BDE93A18A1DEF8ED2B992827BD4F532A419D520C89C7F5613A6A418E99C529DE1761E8DDDAC7285157E744507E1CC40EF75CA14D6B5AFAA7EDF37203BD41334D991FBDF0D490BEF436C0C47C5BB6D66668C3AAFA74D4954A53935CCE0F6E429CADB58A3398FCFC7B54392EE4EBEAA3CC00457B284AD7A75AA3EAD3B01E6C3C666ED358AC18E9BDFBDA98F618CB53C5C5BA831020F875DADD4CB08C0254EEF44755C4ED131B54309C82782DF484B681DAAC341E57C68140ECB5D6A66AD87BF23695F2935914D308B7E3D39E6A5EC2737E987AE4AC358D6EECEFAFB77BFB181DED5C0323CDCAA315173CE8B9D58C0FB9E35AB9EA9AE3ECD6019B2C68220930E43439CF1BB23CFF59B67F1E6D80B0011DD010A776D6DB7B91989F7154695ADCAC5E521793E6CD530A89C68D6E8081AE1B257076A52ADC59A54C1E51BE547C25370F277CCCFC5965BF4D16BC41BC441991A995B37C4D6764F1EBBBB6EB787CD41223F642FF9456EBBB1ADD55E4B9452E49EF602555681B248FC1234A6534CF4D41A737EE7C8FE9454F63E6BDF37A06DB95983F7DA579A986B5A19BA6CAE285F1C26A1040D46D9F35209A7B95E3CAF35C0435EC38C613861558CBF5F7DAEFCBBFABF8DDAA76232FE41C962635243365DA7EC368E00 +MD = 85FEAFECEB801A156C2B91BECFA5AB474A0FF4D28B71B6811B6BA452CB82EB63 +Len = 7592 +Msg = 09CF132AB943654184A3FC8D0368B421FDAC4EF1081A29F3691A527FBDBD74C6372233B38DC432BA610F9C54FA68699F9EC2A6BFB0B2CF7AA6D10AE2207A7554163AA14FB6A9CFA023CE63546B7B02AF03370A899EA73B27BDB5C380613C0EA670C659803D5F6F75C0CE62B311DC157DE843A93905E7A28A2557684AE3DB4FD009412A107098F881DC06622ED9E3DF2C8FE69FE50BFAE158B87CA761FE1E221856610BCA301EE68958C25BF58D3BE203AF928A919ACE53C3D99F55AB00DFC8A1A28AB83E78617F194EFC46DAA77573D02FFCAA1F9D96FD8DA8DEAD3D4E75EE5E65FC360B2A567CD34D52BC9AAB8B71160312E8E21AA506105D6644E6863E7D5E75ED47C1760743D113A4526553B303341FCEE5FDD005D35929F2AFA760BB8314D0C0EAC960FDA3263A1E6688098251618C90332005C757AF958714571B77BF2A69030D99F71D1A5259658BE565FBD098070122C43EDFD400999C90A98ACE95315FAEE4F1C0441C9315D527C7FF1A8171415D2A076E2C513D40B03CFE5513C0E74EA3A03AD4958C00A3E1916D34273E301D517B0A5E770393880D9AFB4D0EB44D3140FF7D827C48F67C6D92B865D8FE7C7E45AA50DFD8525F530DE1188F3AF98B3DC625D335E191FBAD5EE9DF09C97B43F203BFED798F7D171BF00C82EA0ED17D5890C3D6B9EF6FDC04C5FFB645E3050406FE2FB6BDBE2FFE083E751DC19F2F06445397019B61CF1F505875520F09C6B719E642B81B2FBFBDCC072B7981A666D51E7065E21244679DFE056BC9D42B8851F9D2905FD838707B279A8106EB894B60A72E4851C344119CEEB5BBE110B1C5B21C9A5F7545283002D4B1C115308B1CB20F6D9CB869ED0459C569662AA5729A7D7178DE7D69E4885CA77C011E785ECF0E2ECBB8F5245579DBEF7A5EB30307E0B40B817BD1112D28EEFD548374BC867E0C34D2236952B9F859903E87E977190FF94F5D815699154F96E5449DDC1A14E4196C83E4FB02F5F58C30EEED691DE47C81F4883BD84F6ED711FED0C198BFA2B8296182D7225E8989ACF55D3612A93E77D24F7B6EEF813FD514CE2183571602976391F5AC4E86DA59A64233230FB67FF0BB9EC40667F54CCB235D04B3FE1D9A47E163CB19C316046FC1353A6642219E9CECF6E3151C0F4FAE1177B67F19B4964DF96BB6AF37012B8EA9E5EE24C57A010C872B15C8A65D0266589F6DA20E38D9BE2E2C215C69F558084E48EEB61F4EAAE83C57F3F1CD08D05783FB9F5AB1CDA5E4B86291FFFB14FE9B497EC73292BBD295C5657D71CC74D38A2F3DB73BA972986B7169F76BA376376F4747ED65F2F1A5E67889AF38A380 +MD = CA372BECEABF8170B01127ADD4D3F709E1267AFB3EFB4271E2E68FE955080367 +Len = 7655 +Msg = 1EC28FB30DA6341F2D29607A653972A7C6F7BE5CCD76373DABE8B84B4F3AAC34A22A97D1E6149581F76A780C44B3FE3A741961AF4A16A1BAD3F49D8BEE2CD76EED192435FAF7AEB5DA4E5DBB7E8E1481E72E1630D8EBA8C23A06C386CF8A428B864EC514C5C4F3037D3F4785931E34FE7350DB77AEFEEF5D7A957399B7846115E094C238C744AD10013A86FCE061247F99071451E68A5EB306663C4FD2B669C094ECF2CBA0594956BD5D8B5E2FD7A6773ED23AF3EB64130BD9D6B7E41290D5606C96138167CBE52A88A17BFD1B8FC75281651BE870719AECFC7B0C51BA31C7B35769F219F7BE1EB468F8719BD67408F687E43EDA98DAE683F279E9319164B8AF8D0E2D6014B145119D83B9461E61A7B1D9B7496CA141633B364AB3937561DB25BA71CFF74318BB7854B4FA16807013FB6DBEEFA5DA43A84DF5A261A6FFD3A2A0997D52C4E945A3D591F20054389818AA66F8C0369DD54A3E9316F7277866AF62925BEFE2FC50C110B567548500979FD095E67B8918BD55E0A653D1169EB734E4293E36D9FF10C2CC31C1420144E269CE7D5EBA51DAF7C9E6A4997665EB49BC6E822C4BB90BBC26D54325DE3E8412136AFBC31DC2ED0C52F3048C27984BFB0BBFC8AD435EECB9B3DCFFE5EFD3494760A9AE23DE4EE96EAC49C7953DC47A8D21DDE6297280A86726FE3807FA65F66916A015088BAB56D9B3BB689779E3742B2B11B8372B0007B5EA60128AC9DF7A058DFDA7D4613312F625912FD63D677CCC9B95C266796C4DAE039EABF3343CA82E15B7C86D34FCA7920A528A96A72B0E59CCDD3166A8857507527F2FADE5986F2A28E1FA249971BA664E026EE92A1B371D6F78C4CD7EC587174DB43F6688ECB267ADE54BB0F8E3E3F762D4A9786513D65C2D6A6F3D2FFA6E6212233813AE2C48D27CA470B154112D9C0B47514BB3628CAFA9C89ECE7BB45DD880421D0020B4CB0BBB392F760361A9291672FE3DF06A7BD5026F6BBE1649D512BF3EC3E7B4C5FFE55EF9F0E7ACBD529BE5871446B13F832270634DFE10D94E0D7812369C8621D2A01AAAD244EEA847BF3B3D9D90ED51B089092C86201F859CFD7C13292A5937E2CC8EE9AB6D652FA265E9EF344849204400988C55D37FA413207721B4317EAE603675DFA5221C7DC222F8CB370D51AE1F54E34A57B532AB8DEABE2FDC2BD0C28A4C3988A4C2FBCC578EC5CC28C91F91532FA79FB902D0BE4E39815EDE78EB02992D21915099A8AADBAB7B6D71014AB164B1AD625CF9C2E50FB0E943D795ACA936AEC549A5C8E6CAE55111FA244C4555A019C963F7736DEBFB32B28EBC5AC6B215FBED5A72E1D18398D131AA4841341520 +MD = 1AB90035DB0C6F0E6048DDC0530219F3980042BB2495E41A2E9DBC62E92199EB +Len = 7718 +Msg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en = 7781 +Msg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en = 7844 +Msg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en = 7907 +Msg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en = 7970 +Msg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en = 8033 +Msg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en = 8096 +Msg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en = 8159 +Msg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en = 8222 +Msg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en = 8285 +Msg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en = 8348 +Msg = 64E62E93E9D3C8AC04855E1A63560AB56467FAB62FFB088C5DA9B31EF961E6BB14039C29B0FA85A1A86DF5183CAAA7EAAD86845264267F9741877E238B636374C669FE8E32C7D2267DFA4CAFDCAA15E11264B1BDDAAF022CB6569B6946C7A47426C01859AB0AE784EA6F8D323131BE1EFBBF12CD0548D31C3063677C4BAD631C4F856C790E9868487C9E369BBC0EB4C07C2492988D9E85306871D4716F04CA1CED4632606C458DDE98AFCBB2AB2075C52D114E974A26FF0D55BAFB015E8A4A0FCCA90D575690705453A751337C600757C1CF1DD00E740EBCD1507C9794AC126C9A328290FD76668A05175C7CCE035687FB7723BE5B650AAA171D2734EF9CA9544D59FDD7E65E44CB9CD7A3848655ACF09B5F9C381ECDF8201FC35CF54F4547D66651762225C1905B2AF9EF27FA36B43715268D185A1ADA2DE249F231A56A44F634F888883A8BCBC447C3701A361934A71D744A5ABBA351112789B62D7DC0C647DA2E1C73021E7BD525BBBB4103C1E8A5E7630374D1107CC2129B4BB3ECAAB303FECFAEC7797F4D41A19663B746899CD1F0D28FDBC3258AA113FBAF1278866CE474D0C6B0E7C662CABC434AE4407FED447880B1C413B9DB3E279ACCB835B8E1AD82EE2DAAC9F8DA1266582D2AABF63D3B44E26C84B8E511F9E6A24A44AF6FA76D17D3F52DD31651C1C70B0AD13D73750494F8E830330A017086E4E9714E9D252609E18432F54515D049BDD21BFCBA467A9EDF4CDD478558404B5EDB2FD1E611123D2C815B3275AF4538C39D6573712F436083659FC1FBD3F2DEA046E77B5F1C68A7D2E4DCCA366950FB492F4722C84EC98F7F1400ABC2136451BC07DB52457DA81D7668D5E1590AFD22E8CCBE45B9C91B91D6050AFA2B21157C01C6EDFD8D52963DD505A0335D67F7C88289DA89437DA90F3973AEAA60BD97C95295C88CC75A0B7C67F4B0EB78AA1FC2391332CEBFB75A645268CABF44A6F821EBBCED36967788A115DB0F6A83B0B203305FED80B6162FD576EDDB5EE9D5EF06199BED1A5F85AFF6C28DE55C168270DBF5833C77BD70B8795E7CE5AC201EE1B764F80E550CE6C4D66D6A2709B6FED1EE0185AFFB07C4A6C2B0A13F45E263095F28B3ABA732FE06037655CD42A5B01586BC8C51C5185E8DE14114991C489F23C8F64AA10E4DE47596EF45ACA3862210CB80E4FDCEEC49144C5D2C891459B9421F75E834C0F1AFAF6E3FCCC27D10B768FACA17DD3037F16CF2912BB22DA3DCF7F533F45F25FF6E5CF04682718FE9BD94904892B2719404D33DBCC4458A1E68E67E8FC849B3E7A49C02249C5A3E8F2D8C32D926DE4428FEFCD07E0D5E296D8CDC506524CAF97487FD0326114BBD3E20CA6CFFCD87213D1C80F7CF33D31A1E5BFC4B2FCF731BF2A8FFCFC0BE4617D94AC79D1DF0F0CBADC7CD2BABAA6E910D67D26523C45CB3BA4D872B51E5134B9045AE7FBAE060CFD7E73CF1EF7250 +MD = 221326F36B580714508FACB2DCD9301059CCF8F7B34CB6A1E64027BD216A0888 +Len = 8411 +Msg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en = 8474 +Msg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en = 8537 +Msg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en = 8600 +Msg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en = 8663 +Msg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en = 8726 +Msg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en = 8789 +Msg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en = 8852 +Msg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en = 8915 +Msg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en = 8978 +Msg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en = 9041 +Msg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en = 9104 +Msg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en = 9167 +Msg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en = 9230 +Msg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en = 9293 +Msg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en = 9356 +Msg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en = 9419 +Msg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en = 9482 +Msg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en = 9545 +Msg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en = 9608 +Msg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en = 9671 +Msg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en = 9734 +Msg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en = 9797 +Msg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en = 9860 +Msg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en = 9923 +Msg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en = 9986 +Msg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en = 10049 +Msg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en = 10112 +Msg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en = 10175 +Msg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en = 10238 +Msg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en = 10301 +Msg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en = 10364 +Msg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en = 10427 +Msg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en = 10490 +Msg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en = 10553 +Msg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en = 10616 +Msg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en = 10679 +Msg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en = 10742 +Msg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en = 10805 +Msg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en = 10868 +Msg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en = 10931 +Msg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en = 10994 +Msg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en = 11057 +Msg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en = 11120 +Msg = BC259972AD109BDE603999728EF0BBF23A911829C1C910F0517AD7584AAB80B27D4A59523DB11EF7B86D73E480F82699E44E2E281172D41CEFE2A15AAE50E13918EFB63DE0785BA415C7DA3746A669C7F6ADAC8C7ED04FB5F8EC70207615C5B6157F3BD9AC31478F5005F0E8DE1139FDF40D2E01DBF54973F7225CA545AD7B8FAC8233CC579D4E06395BAE791A5E49838A806F69B57858612063935284F7AA2E3769104F13F0D3C531A3C766B1F008DB437A2BBB041691BB9377012A9A7359BA410836EF7BA949E5F56F70E83C99DF961CC3F49D4133BEC543DDAA14DABAA54FB6E5F5263B83DF6863E84179722577101CF3F67C08C753C5B079DE795D2922FA21AB23E2437A64C62AF634985266039F7CBF1E1D762DF49F12A4FF7EB9846E8E5DCEE559084F0AD175E0C6FCA984B168B7512541B7560B68C8AFD02FECE115F0E9327D3D6D57BC28C8F914E9A5B31D822B48E0E4865F652E9313F0ADE5665229631923A497D65E701778739C5842A08A09FB25683C38BB17EB95BAB4B358EF5647BB29D3BF86E15868E02DA7E0229E8213071A24B4CD373266563E36464C8B245DE4A62BE1AF9C7022F6C3894DE6AD8B9B17A6DF84AF65466C319BA43A5EBDBF24833CBCF17410E79637AD5B771B21576113B851BB73AF7BA9FA19E5CD7A5369068A51F5D6A928A8306829B810F59CDDFB42C3B58F6B0926877DD35C4173628BB554C7036779C000E80F93D26C8560DE78057EA74EB12230C8310D577473D94C2DF14577B4361B307D8BB6371BA7B3F8641488B1490B24DA9CEF1FFC732CAC6F9FCD69728C1B7B4E72E8FC5C42B6687F32FCF7B3A90A460E302F3A4E33B57B29803C611AD93BE3E6C33A8CEFD2A5297C28249FB64CE4C1A30DC1F8670482CF6E220A3E17CC95ADB289192FFCF0155F071AFE473D5BBD4204FB4308CD5CE0F13088A2587F10362D86465C3AAAA730CB82933F56912BE62F78BD6A413BD9842D71F125EC8A07442E1BB6AE8B9AADA6BC47CC2FF79B680F832685184FFCE05EF128D9D6462CF7728F2E582F8BA77EFF16085C262F945E3FB06B238B4A5345D1F83373DE40F95E0AE3C5F62EF4BEC3663688294F64D15310B6CCF4AAB03A358B0071114BB368FF489A0CAF7B222C013DD5D9AC39C736FBC2F7EAB5B4F5DA461C8E65D959140BDFFD2A871858ACD3F9DDAECE497B44565560FA96CA9B761764C6BA9D0888CF522410B605567D1FEC21264AD40F1CAF60F79452CA4F12616D6AD8AE73BB57112F6F77901FF444152BC287A90FD2C77187D50DB1F64801B8235FA410563C6EB4E5F3D3D285C1BB2203C618D1F4DF274F6C47A0CC6A892217C608CB3E9DA3E15A5E059B6C26CD5357F9AE1CA6710E2DDC79B5475B42E8DF2D9D6807692135B922611DD41A750B44BE0E4FEEDD632659BF0DAD6EEBE9FA9236E84AAAF278F69DA65428283B66E433387B3A4FAD8032175E7E9C565C95DC94A53E8C52B3BD25A66AE5C6975F32C45276D6DC4CBDE155B2B7BDB7E238D93F01B18BFFBC301E0A8A7036A70C4A656C66B9A1A85B51F690F271B7EE68BA6367B4C512209FC24CD286F0CED9F62572E22C5C6EA48BB92137F7B819CF54F62E4CD1F851F11D08CBD09AC24A6BD3FDDF65ABF05CB8DEAF2B94C7A3C8CB9913BD6FA9B68E22AAEF51729011DA21215571B39920FDD470CD2B4A0BD08C405578377C889418A87DBF14A8E4FDE203A2AC855F18DB0F9D910CA41AED5AC5EC7D08AE7F6ABCDA0646997B63343B35008EAD44CF3A8EDF0EB104BAC1EC3BA1DCA808530332D9C249C6271D25CE33B536CBA3D2F8D6C8B6A0DFC830CC426FE13D69ACBC24BACE7CBE27318ACBA7FB54BDA4104D07561B5BF0D8F0670FE60E6389B2D6E96924EC4E4BD827473668D4F28412123C31CF49912E73AB8F40CDBE3032BE127F36AF2DD75AB2D3DE8D2E017470A7AA3CBBCAE318B20D +MD = A26370EDEFBA1AA516FA4E4902294F9FF7B491D0EAACEEC7486EB262E8B1249A +Len = 11183 +Msg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en = 11246 +Msg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en = 11309 +Msg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en = 11372 +Msg = 582E4AD8EAEDCFD361E2D979A3B35F3494D1D25CB4CC2985BDE2A40B8CE98598C4E22240EA8BD3F9F19DF54BDAB71F5718520B87ECB06E441416FF82F917011CDA41B81F6CA13D1C7B7095D797A6AE75EE792CFA6E920330B37AE3524C85DF1C427DDF7A0E785ED89EF08D9A5039A560B14E06BE78B8938305667E4D26A7D74B9027DDF213C0AFA7390A21FB052689D167F15337340355F99C700ADF2E9362DE3A504EDBD104919990B7AC2F9C2D43D6EAADE93B86653F4C4AC6CF008BCA6BBAA54D42194DE8071613ED8CD22DC3E3F8D97E1904C8B729E9872A90A5E678B025EC618A4238F09B98437C0ED493425AF1FDF1784910E06782B049B2299F93CD776AA1D406FD65EB996434672C83282E82B3C5767E3A740587F9562F2D71AD355D6267EE277EC95CF4B65B5040609F33DA99134519A90011CA3010A02502D2233781DB03832179B27083585D811CBB4B4C1C11FE392BDD47872FFFA39B69B986E8237CE9EE4BA02D58292FE579BCE6666E70E1E9C0A6F9269CBD6ADDADAFC262C1C78DA85E486D04256BB9641AEBB589BD344AD4AECFF72CBF8BF44B08D2D486FA3043E596AC9296A6E261688DD73D91D5AA7ADCBF867C4465C8E9C739B6E6AECDE36E4B32022950879461D3F91E729606EE7B2A4E3B756F0FE7B3D08E4A1253B8A272605E900D72D03E90CCFDD55F610B5A6BB69C61E9C368EA8053895681DFE6C1B7428E898EAD12DC0824A41DB2875F301FFCF2563D74DAC3D91B34A9FCAA0B72CD57DCA6717D49F151EDC53590537504A648CA3359058EAE6BE2F0E37C76A67747C68EA9CA51BE810BBAC576C8B20521EE6EE0532DFD5B02546DFDD933E3AB3B07EB9678B662E6CDAA678806A1E1A21E1F1B127B62B5619DBC7A2A5F3CD4CFAF87A301E4261163EFCB410FDE2A00477CE5EE140CB8198942464B421C77302562161867F071FDDFE6C362F155C29098911E44754F2DED47F23908DBAFF0585951444E038EF093D85CAA6CCB0BCC16A22733398F73235F30F5AB83A5AEB72A66084C635C3303F9C7BBB957B0B36B9CEC120E789A8C890745C3A71694DB8EEA66D23B267935E6CA9B847193AC01581404D7865418F522437EED48C220F1F0CB4B99366B1C851E474792CA58FBA7AC120090EB1A568727F7ED96D3A8A0E29921E26761012B557D60E2AE41AB31D191696987B5F8A4A9D9FF2ED4CEC0EE5971BF228D54CC296EB568C344D98AC38FA18E809E3908D2777460924BD997E3944181F0E9E7EC83C8157AA14AE9531699C1A48AD50E5E96D87EB51C9EC9733F92969D0FCD695505198CE8054B909D136947DDEE76D44358EF3F0CDD77F35AB0367D74D496C3B2EA8CE15B690CE308E8AEE5A2137B9457A27EF33C57F6E3858C684EC5A9148BED6F07AE11B5699E0D3A04043FC03C739E5EC5D00AE8F0F40CF9FE4932BAA2B2D4871994E957A3A54C5C25F30858F26273F9A2446C3BD2FE0A5F65D8B822F9810FE968F1BBBB5D2E23662220BC37C0C2A7F7E80A38B91A7022F537B90BA066FBEE33C8F99EE063B7160D6810AFB4299E459C5A2909CC7F8D961F743A0FBFFAC3683E24BE6D0E1D38A876C3CF201A5F4706CA531CD7F7BE05BA11EF01B3C6DA42717929252CD24CE47D16714A586B1ACF6956DFBFF7FB680DCF2D6696CC722ABF3B2260C4B212E6C643A4FBAC071E47982A416FDD6848977ECFA8553F8017F21324C3D6015432B99984102EA5B7C72898EF163B16A3D1042E95C851A9F0CC68BBCB0B979E93B704E5E5E95CC2A13B3B4422CAFC6E11DEEA1E53C488026CDA37BCFEFE090418C86F9F0C628FB5BE0B96E34900DE7ABD12A416B56436925407055E1C8D3101389F8261DED7AD8E657C1679F90A4223AA4979A8EA8716B6EFF2913BDCC6A24A19B2B2EBA820BFDE55F49AEC9DC2D6F527A5976CAAC92B6629D6484BB703BD480109DD2B305799129B15C1BC9BF1D17A14B8540AB5634CDBE5C252E269A25963B1432EE92A75F4E0 +MD = 6A731971D6975979CC2062AB11FBC41315FFF0C8F1B1985561F23EB3FF445038 +Len = 11435 +Msg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en = 11498 +Msg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en = 11561 +Msg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en = 11624 +Msg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en = 11687 +Msg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en = 11750 +Msg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en = 11813 +Msg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en = 11876 +Msg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en = 11939 +Msg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en = 12002 +Msg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en = 12065 +Msg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en = 12128 +Msg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en = 12191 +Msg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en = 12254 +Msg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en = 12317 +Msg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en = 12380 +Msg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en = 12443 +Msg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en = 12506 +Msg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en = 12569 +Msg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en = 12632 +Msg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en = 12695 +Msg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en = 12758 +Msg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en = 12821 +Msg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en = 12884 +Msg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en = 12947 +Msg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en = 13010 +Msg = 6C0238D3835C665B380475EA4F6AF3E9714F68C5036962398219D7980A4715FF863899C56B87FF113A303B83BE1BE6B64ED1486BA938C44CBE971C51C145F2F5492724EE20DB6AB1E6247FE492192A3E3195EEF66E70811D2146E38D969722A63568E6550A007E7A9D538DB268E8EB79A6CDAB900DF5122C2BDD59B300AE488F7EE6D7C6E02086833DE1F772AE9DAC887CA4AA155477A8352808BAF9726F6C097D932D4FAE9F46FC74D977716ACFB5D7AC7965622E3792596A83686A9DDC629A970B29C2BF46451FE940AFFC40C6A8C0BDBB69E46FF29E01B7970039E1FC89988677CC02F2B235E0FEFE3FFA39B909F5F8F998DDF3CBC890E1D388BCC4B3E055E7163BD9400556AE1F6BB64477BE19FB722BC320E4BC0C101B949E89B2D1A16728C0CE3157F4D70F1DBA02573785769BAB4AE462C319E3D0342F07C5F8CF200F656A02DBA828121C64C9BD309B73B96A48F9F3E6519B5B29415261D37D326A8E3DE982094E61CEA8BB2090F21549B65AD92424B4547F4508CE7E487B7185DB2927E7F96725E9D2357714BEB5EE6C94FC32733C8AC68830665262909377ABF6CFF65628664D980E4022B87BE68E4FBB5FF6D25BA1891702D542E2A2FBA52D7BEE3E0A90A45535A491E15CEC564450FE2A4FEF30F5A686D4B73719F9F35834D2C3E224DA366F10080A54290041BD56DEE5C2676D95EAC58BB45E0285B1F63580EBEB0CF118400141D075B86C17C149C29FB71B8B8E2E28171EB708B7A55990B695EFA7F3780E3DFAB3613662FE3258577C81BCBC50D609658A8D9FB14E5A86F1747F46B932FD8569845748884B5CB0E66EB41C0F1722C5B20A4EAF72DBCCCF3853E54157EF79AAD1D65E0226F98F7B6CFB7863A661270519794F3B822AC9A16F012BD2D885CFC1D16AD88A09200DEF62B34BA8F97639594CC007847C2558A22696CBB01FBB246C6860E5C31F2F3D097FB1B495E0343ECC37CD8720D595FAA7E50897C5F8ABD16D45A39FD875B20C7050AEDD4273434BE5537ADB1B5E11830A7EBC9FBFDBB7CA49925B72EFC5ADF42252BF8AE13854D0502A9B65C9F488EA2B41A26B137544010F38BAA7722290777DFD01C7EFF13A1EBF0F417CBF7FC43714577501231A9FCEC8B6DE04789D0C311E3DEB3C2FD1672F1FB00FE5F4EF9E74DB1B1F46D9D21BBA645A3ACF3B0F84762FF9229F316407E2B26F1D554C296FBE1CF568C281AA7B5F4D945B9F19D3C0A1511A5E8D829C8227CEFF4F227A79B7F05176F3BB93756117F9BB44C1DED2F2D57AE1565E7B97F0D58E7CD5F35217E296725A23EEA62D101C72FC5B4453B735D99A09AFD249882B98CC78B8D33A87010339B8118C150483518ACB1FE379F67DD52F46FE436F07EFCBC587BE1AC675CB762090E6B88BC2CFEB92AB05265D2567E1C52A9269CBEE49C5D1B73FEFB05BBC093E1A35B46E0DB913ABB86885532BC00692DAF55651A713C871B021B126BE20B6632BAB2DDFEC609776979F44C69A7DD4643A3BADDB9930CED4FA362388FEB65E1CE02C3F51796B04253574891E56AF13BAA268AB9F46C60ED7B67C13353209E15BE3BD43BEE5F20D5BE0ED51AB6F7A209A2E131028A948C708FF0F4A6B65B7F0ABA5B93CE10ED8FD6D64ED6817529C77F65512D20E2E706C0A81E5CA299A8FE64B5545FF6E003F015178A38FA159A11DCBFA08AA371F27E3E4043B1B1A1E140B5B036DD920422083BC53E84AE350B8D9BF7F4C6D1C4AB2452548CCF70E4A55F03CED2F1F53AF86948DBD156F3F2B57C7BCDB2B202A7A8E2B934344232412C8EA6C3AD648D77FC414723AC7E75068855A6AA2CEA4CBA7C10795289796F64F7402EA820FE62E3B3333966B7D15E2CEF4C8A3366FE1A07B7E2E26BAC63878E74E6D4F4B15919F8C72C715318520D6607F65751CA4F0FA820357D645994620F27BAA40E7E91A3FD1499C996F944065578545B8776915DC5ABBCF76DBD217FEF7BA9260A8D570586E24D4C58F8E4C0CEDBAA881E993D17459FBE6A3C84BAA99D7EB1FEF0AA5B330412079E14403EBACE6D68FED3296A58620D4CDB8F0A044971A4770E8E2EC5E98F5CBEB37724742DAB99222D251A10B3760F7BF9643D95184E3C70D93163CB24FF23FE796A848F566B7A9D6CFDFFA101D44684D0E6AA637ECC69FBF83DD32B073E72354D96BC592117FF7D6A3B6570DFBB5CAB74767E11133831E7D5856E2BA189AB0A6FFC5E17D60FC03B472F11A1C8615508F7DAE68E15C7AE71800EDC2CA4168526B892A95A8CA78CDB814771163724A7640BA7F278AC140 +MD = 7E73E69A9A489F4BAE64215591547F144E9B0357CA4D52D01A2E2120F1AF2DFB +Len = 13073 +Msg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en = 13136 +Msg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en = 13199 +Msg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en = 13262 +Msg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en = 13325 +Msg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en = 13388 +Msg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en = 13451 +Msg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en = 13514 +Msg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en = 13577 +Msg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en = 13640 +Msg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en = 13703 +Msg = 6002D85E9C6C2383550947622F5F350141C09F9AFBFC103C2AA6C788C663022DE6B0A6642893E731675F545E9980BC4439F29427BAC2FFB7A75781B66D6F6C78F2BE70211EE0CA92CF0DB06E103CE4C99665797990EAE013174BD05FCC54158A5635188613E3AA726F2B0F97D1FE14538CE090DF8DCF9B1A5E6956431E57C8608C3A2C045DC78AEB4D6DDB8F04E20602C849833F9C2F7FB0A04CC5BD648379077541DA73BF7D6E245DB921997CEAA70B72A29EC1CA8198002DE1C6C747D48F4E4BA842C1CCA512C073A66E425BE3B7B3C86B1690866B03479B25FB5CF0AB5FED95BA6318D37CCA26615C3B80C06997DCCBFB2667500954625F8B27BA89A20C81F20F715F19BA58D86E057CFA97F2B69F4A34A14BEF9339F688ED415E01CAD4C48827B3FB68680A1263C070BC760F64B278C0A4D519E853CB2C0D9C5A7529BAC55221A4752EF752E9CC1923565AEFA58EA6CE2BD75406C31291E822E49241DD0827EA6BE24333CADA91374B2A8926594C7F8C5A37CF7DD8948BA3EF19641AF99820083868E3FAF1CDD52CAEC63BFBA13E5DB7BA7EB020CB688CFC3068D6827A8594E39124BA4DE25D13FFA82D464089C1FD4E2742BA87514F023D1BCE22BBFEDDA637D17BE467E86BDFE8ACF21B130A1397C4D221847C659EAF360350E2660BEDCABCBC9BED0B3030AB7DC1C8F3B923A88620CB2CB92103882D60CBB4C4D466D5891E9C456B7F10C10A14B78505421691E467EF1EF16F789D3DD1DC22C7AE286422EA1D987D04DCBE518D78B543B9B354C1BA190042AFE2069F91A1A17DCAC918274C6583AC6AE07E02071C7376A0E47AB30001A6C048BE1A84100588D28EC5CB24CD85490AF092371F6808305C0083C5F42094DA1136E02D6A27770371298BC2C19B7DEFE40910C27FAF0CFA449156A6FA0E8E4C578868D1D88A6B3E5BEAC8537152D57FA81308DEF7FF1A7FCDE7D6072C5B6021FD8FF9BCB0C427FDA9C6A22BC718F019AB76005715BFE4516796A67DECE1DA402B138DC199F0D35DD86E9C376A5708B1E6906A68943150DAF6F6BA20AE79EA8816965F683D318885CCB2E60ADBEE28D38716085B0313876E1263223C852BB26F5303497007051A694BA921CE8A85CA481D4D1361DFE4B2E568274F0FB67157AC5CFFF9B6A1507DE88B4B9F85CFF03ECBF341BB4BB435CD92E1DA013056201ED02F26380093F6E49DD04D6A69952A1B37FE1DA69B862C2F699576929B6B7DEB0F828608FF485304C2BEAC718DA943D8629DDE2DECDF08C107F32A9719AC66C5D80E2704F20BF0BD8E69BBBF1AD9FEEDEF896AB781D9EC534F5D00EF921BC842E79560FD018F1E34F31DE01F0EF59C2B63C779A38352748C3F8E5D56BF188F37BD41F881F85D57F1F37B9F4C28A6373C6EBCA916B8535F20BBE446A36A33616847B6DE24ACB59F5A6F52B107D6DCB3CCEC82298153482AD5BFCA606DB5488E4285116917173E3495E659BEC1716C8C26ECBD4A8EF79B67FE4D22BEA9A490A7F8C649B878733F9E10F372B1F918B3FFAD3789D89FCD5ED68537ABA81B09EFD67D412F147BA604DD54D20F49CD2251F33DAFC4A7EEF24EA5514A3ACFFA173DF8FFF63FC990CCCC0455BC2EBB8FB97EBA10F6D61D7085A2FA19D634A278194FC65DF4205B434FF0C54E7BF3F8BB8FC4F4E47B12B85CA765135B8C7AE249B2B5AA846E7EADC81C76CCCECF2823076835EFB768956740CC4D8D28A1BDB7479B5A4C52B9A33D0BC23161ED2589987C5E7B3542B4AE95B455E993DF0C683DAAB0799FA6E612BDD80383F35C385790033FBC65BA4E152AEF52436023043C9A8A950C1C9D608EEED9FC920BCACAB738853F0EC14039F9E19B637BB08E58D9A14E56EAEE00E77AA9CEC497CB4835BECE29C5255D46ADFFFE99EEE59B5440A9B219FA45A21785BB31A41E7426576BB0FC7B21E500A45979189EE6B6F6174F929AD4BB32C6C689BF3E5475F05FB658A85124C8E5053F4304BC448124F23235D09847345A8BE5BCE39EED2B68B17C038B59792D72DC2785CB723DE475710B162CF6D42BA09663448F69CF108A91EE5C85018F921BEFB86BF5E980A5C1E8426DADFF9B5392FB6E6364D9DC56A7F5C8C3CF338796CBD0405F2BD0DAD8C7CCB95ACFF0A9ED33BBBB016081AC92C93A4E116DD03C476BDC0F32676C62C33F10C1D30A5335FA1EC14589D98642C6D1E7A5DF42585E18FA74C75874BCB5FDA95C4435E863954AFDA89653FCE06D387B6E63686BCD20084070FDC2DA5CB10AC0096684DA8D2B82AF6433A27016CFDCBAE6FCCC5D79BA72ED41C001ECA4122069F102207D183FBA8D2360D5EC4AADF18D3CA77564831CE3C53D3845DA762319F1BC98896B844E233421A11334E4B0AF228E735D2BBEEB6AF797A9D27F6FE30F0CE23008EBC4D2BDE0 +MD = 228B0298267641B0D35ED14A5FF14CF920C242904B34E1F08556EB8F650E20A2 +Len = 13766 +Msg = DBDFA271A771AE0827AD04BDEEE475E357266F170F6304760160EB3D73ABEE0E3CC0C66781D72957D52A58F81A85B4C3ABA2D68F02B0AD2A8462D9BB03F214255A7D4FDD9B45C83873CCA3D1FEF35995F45FCCE933207F438FA967A2DFC00713EAA4942C3DD67605DF749B8CF30739D2373BAF7DE7CEDC48561A4CE6C7735806D4D3E556511A4B071A86E9F31D99E887A2D3A474FCDE54C8407C8B6584AEE3C3AE2B9E60464D5E3DFAC67BE8A00512DF48222799B1D87505363D486D6E8AB9567C7BAF1D32186CD9E62A466A7F03A2BE66FFC1D49406511D413AB7FE409E688E4A165F99AEE5259C9892D93120EE03BB94651C894E3F99696E317E9B46727674AE1DF624B6D68DF9F624473864FD166942CDF1C166F00E43533EDCB7A433CFAB2B2613F24E1EA61388D8FDA4BCAEB5989221A696D305991B47C9CB7D70F3B369437D2016B686A5A83D8FBBF4D67288C7B632BB61C6F8D2E91BB63A70EFF4DDB61903C22D620AAF9426B8C639C158E756272D218CD0E5EB04F157A910B1F1B1973741F296A9B8658F58400A2852CA501D12D29BBC3DCB43AB4AD1A478E550CD0516D8C6E392B4E77DDCEC0265A1672EE81076DC586A1F0CEA4B5BBEC686B240111FA6F3F33018BB14EDDA47F79BBF370278A66D3F2AFB0D2D228C34CDE494259D5B420771785D37F2755612FD0F99D79381E02635B3ECE07DEDB75339A7AE7F6EDEE9014DE276B1623E21595A5F2CFCD67C71792CDA6659A48B89C1F2A963404BD795E0197E49E66E148C7C4A92C5C0C2844B09358AEA59C974DD7C912A512E4527E828E85094E069F02CAC747E7CEC49BA7A5BC235EE94348BE6005E8BC118FCE5B2B59A94EF1E42F32524C8102B369D993525E59D3FAA4B2D6EB0EFEDB403DEC95571B53922DC286E4759CDE97C18BDA7137891071CB620D04B2871FEE17AD624EAABABBBDD0536A78A9EFFB2EECC9B3D053621536A5C6E7AB3456A29D874C1E429867BE7AC3F381B3E024D1249872A4D7CD5ED18C9EED612B70B07A473D2CADCE20D5B2D4F50C3C6E5EBF1E3B92F76B869EE782C769C8C406E4BF32C2834D33066AB80200FFED5C2493199A52D65BAE5F646CA9A9E7AAFC702F3858BFBDD134CF092234B4CF28F696FAE3222EB437576E0919734778685280897522C7804BC753CABA4E8AD3EC3D6F8D71F9A6C91B05C72E96F718E76AD39B1DCFC9C6EA2D0D49A7AB6AD62ACE65A08665E661BA4F06D9B52BA573A0038E9F674AE5D0612C1870EA424E91EDAB0FD34FCE706BAB0B90C2AE0BC547079E24F0473C450F7FCBED8C4AB8B64FB1009FEFC8195A1329B6C927A89B951E9C5CA7D1E7998AACBD59B2D7C3EECB69F0F8B376C153E3E42B21EF1C71905C810BAFFC6FD169340B65C8D8E1A4DC2E6D25CF543D57C33A166D4A27EC3FC03BDB72CD2BED0CDA850CB9F59D764B7CF95F088729BBAAAD43FF78D1C29C51FCBBC77651A11425C3416B08649C2DE1ABB8B08746F8BDD7EFFEB4A1801F235BF3E33F873BAE60177838466AF670E18C1BBD092B9FD3F1854510FB0D95F77B11DE014C19D0AE84823CECAD1AE7C661EF741FE123FB37DC40027348FBDFE45FBC3E6A9A556594BF575E28623C8BD59D5150738F5639B1C42DF179C8D26294915F5845D89808F7C48399BCDB71FDD47316CB53AF11104F4D4B984911B41D5FD8328EC81AF2AA672F30E87B7B103573EC7080F1EBAE1F80BB1CF8BCC126282649D559FFC2F36BCB4B6795B8F03EC90DE5FC0DFC14658841F09A90D08A8ACFA75C7B92AB48892C49B1359E1746D82A0BB51E7D1A41308AE212231E758662AC180A17257460FE3426E73E3E43E2CAFADF06A9E2F5CFE57F751D230EE3D98182E7C7D3B08B9D63150275B29D233B76FB4A1ED3C6264266569B60975EC494168345202FDD2073DE9DC829BEB5B5290FF2A232C895997FB6BC689D040D97CA23E13B4475FA14F3162F72C2E41C5D4690AA14A91AA5ACD6DA0D424AC74C8C82288F8E66C59E4422D11A6FB3F6C6CC0D2EEAB0231AD29C8FACB15F54FBF9C98AC658706A81AC463D94B9F6BA30404C0F476D515471BD4DC48114ED61D9E167278D82331E4956DE28E9548263494C12E03D2CDF176D2F7B1D64DB6B3F0CC043C86B0B97123EAAA3EE6685594B8E7F25BD26A31F08162D4F214E9E8A08B6A71163A42C2E6E3D342434B5CD08E8956F8EA851407C8179A62A3B0F76A85B42DA441A40901F29D706D385B4709951EC059E3161C34564C2359575957F00C494474DDE41BBDFBC2D12186689883B0A228E9A5855553422998314508A6470E0B2DBAFD5EBB32222C9DEA8AD123A05A63E6950F72725D76D72E6B1459A4947912054B1603AF445EBA3FA11256D3CA861C8C72797853B58754D86281D027F7FA3A90A01BA0AC926EA49946D995696308 +MD = 08BE7D181A74B78D11E01A3A3A5E464CBA14406A222D998AB0C67237A5752EEA +Len = 13829 +Msg = 41E003ED79AD9B3925FA2FC6CA2C75EA191FE953D862873AA7BD17AE7E2E7242981015F05935DC21C20FFC2F417A0905B991778D7E3215BE2A37BB9C8729F37555C307D61A74946034E3EAFEC4A8D80D48D60D66D9E3C042D9B7A366E801F4089E54601EBB6E02302FA41253C3385CB34FE1E54D245D7731D3EED6FC1875BAB53DF9CF6DAFD448DE90B6429EBB4B8E16C059F3104CFAF204A803E36A3484C8B8CDB5BFBE45551B3118643959F1A2B6785E432284446CD4796CD3A989E52EB4D42DEA21EE4FCDC4EB07CF889FECFDC0417AB8B13DDC49617B94AE734FB64C9E0BB73FB2B598467384B08B3114976FBC78AA4F0AE25B47FB41E0BCEA4C747D3ED7E11163F23D792B8D4ACA0E88CD7E8CBE604C2BD54678F0C57B239A617BBECDF0C223603893D45E0C604FF9C45C532069FDC10D0763BC72561C54CC14F9C2C75AC669ECED747A57F3BA122E2CC6ABEC5DEBC707CEB730089A93AA7C17D2EFDC9952E1562A43CAB0B97D5B028C8A66CF85126892FCC8D7EAA6EFFA9C29616532789A67320C66993D1DA789960ADB8555DACADB77435DFE1C10A50C04D1257A42882335C22C36488C4E724C3D90E396DF05C5C56E55173C0E1D22647FE6C91D859A4B1146E5486446F4E55D155000516DACEF5695BA2BB2D7C5CAC171D6CA363C8BF757D7ACF2FEFDBA960BF59E40EDDBAFF626C10FF1F738CE798B44A016B73C7C8F0C407C3088AC394D79ED2416A31AAA6A09E5AA2E8087A848845C3BEBDF46B39F7E379D450916B6670A44529A332A88754362A688B881A45E3C96AC66F7ECF5C1A62CCCD937E8E71A5AD1AD1847E1BD3F756BCA89DAC3BCB6B78C7C23EC108FDBEE5C61FBDC40895643F13F198260CB09F17049D5338ECF1882981AD7BADC2A0873567D12E8CA239F9A7A60484A6FE29C4A425C9805383B54657164E793EE9D02169438001E0EFBC3A88E0E133FFA053155B3188B6A28FD99341E908D8704D6BEBC51654D6D701E71230056C352B333FEB6958E280E22F3547EF8A2B8DF06AED027CA9DC42C8D5A441BF407F4F40AC7DDC6A2C5CE0F022F35878D12614BB6468C2832642E2A91B21239AF1F0A08F6E8D0C747E2010E7FC084F963562855F09A3DB84F84131D749C06AD8019F5182281695B03080597C0633B8AFE8CE369C1CCB2A37B7454551BFDCC084EA7943DD92DCE6205508BB0AB806CE0626F0C887090AE7156A4F291F4FB44E124434FCE972A241D898C68721FFD9983340192AB6B991FEEED7C5D0C6E46DEF613125D6F987218B626FC10AAB857A0BC97FB6B173F7383D244222F67445E44180E442617B5B6CDDA3E96B5C7729CC912D5CAC8B4633B06714DA58EAA7D792B4DBD931BF7F5A3F2BB6619EBB4E6FBE8313F6A422F3ECE9EBABA535F6C64154B12194E072EA044BBFDDEB58A4D148F67C0AB8F57D3A3543A0BBE09A074543259BFAB4598E645480E94E6B9CC9E521B3588906DF2AAB6967E65EB9FB0880132EF32500404584896BF112C908A167C6C49E370619E5DC8842A80A48181B18B5B94EB03C17FB239766299F8FD488E020E08641AC321E03B88B0F60D8D1AF328E3186902AD8BC338D9074634F4F5797B65DF6915C3EF8CAE1B16EBC9C7B398E818F795E3275ADABBCD6ABA72B4C35FAB22E70CA6F57631E7427C32106499A88EF984BA0BCB2BB9FA998CDE7CBA04855117DCF6DF188A48F58B54FFF79E00DEB2BF83700D7B689316127681ADA98DAA8A0D5434EA4E287305B295BE7FF3471D9F73DBE9288A6B48EADDE7B530AB870494C5DD982B04BA5B15862757B35388A11A7122743E82077DD3D0DBD9982C1A1311CB758664B1A1ED0131269E8C176ABC23D9AD8C3F60F0F5A462DD0C16FB8EA2612B4F36D6B4CD3B00057B613468EB0FB3B515724A2793CB51D9D9FDFE932E6CCBD4EDF342A0FEC6DC7680629ED70BC72B61B1F3E7F4CDAEB742D508B279F8BE015610BF85D74B633F60E64464D70BBC2C9E839A3D6D64168E15B525E180B7E8A020E7D2A7F99AACE81CF6339296E54E1A922CBB431EB572E9E8558A6638853DDE9677D0D83F22515D18F10989810D6F78D273C871CB4A6A600C7F54D5FEE6BF24B53252B9EC0356E9938602B511DE1F79CAC55EB4E530C76661548E21257EA625C1BCA015172552D3A8073CFBFA18DF1029FC657F3B50B99484EF4C7468C9D9873ABFAC674E2B9041F8EFFA1949CD3F1630097205B7C554D3607F782F46992A7504DDD50B41961121B9D17E45449B053446F3CDD8E7FB56302568E97107763D9CFC8270942B09C4D32D5DF0854B8E44B09DD5EDD70C55B3A368A29593C31B010B5F9B9F46B6624F3A79F4BBBF542305280EB8CF7F7768D96A8EB7BF632C78D4B38070DF45E401FA3528F1E641714AFF7B2FA1A41F65B31AEA318D0B3EC0E3F8B60F86CED9D45AE32FCEB0 +MD = C08FAB7EA50D98681B11BD3C42F7687E5CE583B82A0F184E13E2EA45E6A33C2F +Len = 13892 +Msg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en = 13955 +Msg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en = 14018 +Msg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en = 14081 +Msg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en = 14144 +Msg = 5B4D2985E61AA7145B5E760435FF0D8E12B546EAD825400FA6677B5E44435593A38AE2FE152D8B55879A6FB05D72DA1DF4F5CCAD61712B8E76BD69A9D3EF09DA0B2FFE0A00FBCFFC83263D48E3A263A97582D20D9195B23875176FFB45CB8A942C4860E3CE6C26437826DDCE61D4DA4FDA3878187D551C3BAAB37ED66EB10D71A18EA6E48B96FDE7CC1CECB821E7AE5BE07E34C6F5C20604424591A4EAC3728DDC786E23B07006441BAA56E174AB4C5CB417008A3D6656ABD07BB71787CC390F4E9004476D0DD9E9CB33DAC68A1C6C0CE45514DB4461F7992714B9DD28194856813C9F24C1DC4ACFFD0065B9D50C2662B41633472B25C358DAB53F85198D76C93AA20C7483A1DB21C373627538DB87035EED0E78BAF5205A2BE0CAB925A0FBCF141543B04FAC7AAAEFC3A53F64AB3A71004684A3507535D2530D8FEBB4E7909A3737F9A4964716108B19C491089A01249E4571742FF85872E9FC8E8E7569AC15655BA084EF6ABC582F6E91FE2309D5E4E3FADC554DCD87E118262DC408398AF5DDADAEF2CAFA99F6E033B3A422521F43DF2D720693124D6DA2BAF5FE2B37E775AE3ADC4610807C0E9B43ABF8FA71AB977CF9D3EDB07C5644F8556D849B2C40F523EAE927BCCCCF9FD7B76892BA4FCE9DE71F71FA7006E774F7EEFC201A5BBC694008F8076EDE5B85EA3FFF1867C8E215E192EAA9CC8883CAADD68BE57DFAC989B25D92AB8D53709490C6766AE8C21720E6A105888C2316BB301D392E8ECA464C8694300455571FDAB6CE25BFE3EFCDF08C7CEF99860926AA8CFCE6803DF0A7D0EEA883C2A54862E0B40135C3B3FB9D0EB218E5E1957E45FA64E2F7F8F2E294EDF69F26A8D65372A2CDBD792B7514EFFEE4A38FF2A78774FF8470FF3AF1A1B21D054B978A3F8E16D5D76199DDDEA87FDA4C290B6789067362FA6E6C37CE6660ED905EBD3161B9D05FCEC8E132956885518EBABF8525BB3C356301048151BF6DAA28EF6F125F165A79B8EE314A7FE20F25A7E2AC8CA3655096B1E77C1005582D82F28FFA108B38D1C2510C40F06A5F90195B8B2367313523981F2C7AF63F536DD3DC191A5FB0984A7AD0CF994DBFB8A5C8991DCA74BC1848C6CBCAE6EAADE0ABC4A45EF03575E82A2C3E0BF5EFC19FC9F2EB36C07E42693004397459D555F0D6F267504EB35AB798856300D96025A1A017433CBF492F7F3028381CFD1375C3D2C5B71CE285FBD1CB22987F5A2146043D2C1F26E6E937849935B6D6CD89601894AF6A0A7C94FCC100E8F167A7547D7C72A3B425FDC0EAFF68CD3674F9C07B4539BEE7E885749008CF538DFC3657F3708D778A8F39E5D7B13AD8ECF84DD4C0ACB65A4134C71DD590AAD97D6EEFD015FDE1EB5315038B483628CCAEBD095B1B4203B66095731E6292BD806C6DDE417CE9B564E2A7C9F69893F0B01FA8AAF3712258A3BB070CC502063B09C303EEA0A646A204E1EC0B31ABD6ED56F4FE3CD7F2694EBA27CAA4F581F31254C420B9A51B4339FDC813A446D29C61CF817467F40F6F55EB07C0C7A86182A1472B0BDB9BEB874B2572A2A1EA65242AC5EE41025DBF0D4BC338F09146CE59ED656F93C8D87BE9F0D73909291AD1336103E05FDE9E9BCC77ED75220A2B6339FF6CD8A388153F55C9CA03BE9DB5DA242B9E9F299E23217BC937ADC6FBBA90980A29B619988360301F7D8DDCF7B8FAD0651F31231B816620A295D1D6C6C90643E2F2593A0DCFB700C017F0A88E03D3D6871EBE420B7F435A58407C667EA684D5906C91D699D0F3868294432FD7FECBEC527D213FF7D94012A52C9F818CC19B3FF9F3D834DFBAB4B1A6B069375D5C3CA6C1704AC5CB391A3F4DA4EE3588551633B6B01476F9B13F1B36BAAA3BB6B5EFEA0D9D150E3325357151071125847038DB3EA6ECA114AC55F5DB1FCE8089E18D478D7AE82D173599A02DD670B46794E9E2CE91BAF90DBA5AFEFCD1BABBB8EA210640E14EA8E085A404DBD9FE15DC3CD0BC3A59BF997BC6A10DD4EC8970FB396505FBC17FA5D61D90C989B47FB367F7B2EB17702FD039FE16EC8745912003AAAEDA09CB644449DD85EF010488FB0FCDE2D804A0ABB59F2C4F594B3466B626205703507701BD4FB25AF83343AFF8A09A004A559F750CDF6B2ADB2CAB16E2AED2BDC0481ADDE1A8A79513E94E6F959F4E4265CF2ABADBBF173A897C50FDC2A219D260AFD0C3475148C645E65E343D4085B76CF14ECC839E4F7C725130777535ACB154F74B6738FDC82327F0BE5794D630CC81B87D5A19637468B191CC2AE6B67FD5C3990FAEED6A05F482E5DAC91DAEDECBA379FA68BFD85A218275F44A8011A74DE303007E9F5E955DF052D67465D4A1C1791B88C71DBBB6D14F3CFD49F414ADC26CF8FBB797C7F4D65AB1B260C43D0DA063837877883E87859F99A36FF2185289FB3B265CA1D017C731D6FA6437F954E55C4E7B90155156955D2495C3305EF196F9BD62204BF18DC1F3E8B6BE2C38956B169B75 +MD = 83F1111A37EC61E9D5231024B81E8883F7BD11BBA9A5DA46FA0F6F19B381B2A7 +Len = 14207 +Msg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en = 14270 +Msg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en = 14333 +Msg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en = 14396 +Msg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en = 14459 +Msg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en = 14522 +Msg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en = 14585 +Msg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en = 14648 +Msg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en = 14711 +Msg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en = 14774 +Msg = 993762CA5B4849544B6F58452292B4F589882FC3C50FD6A8F9381C23C5A67E1CFCD4B23D7CF87777CD5AFA8F3C49311CF88DEA54E587B913CA7FDC024D3E298B4FF47367AD397853E3D77E109205412B132FEBA9FE21D126D038678D4DDC8BE19D6FA95C1D75AD9B4C52B81C08A6C26D89906E17A6CC678F41C0B776D0D7D679A447D075A9B41E735127CC8E996ABB70874CC0EF60ADC5EE754803ADA8B9C89FECF9E16548DB53C7D32FEB5DE1BC90B0869066E3DEA1113456D036A85322F4A9782FB29ED7FFF8D16C2AB2985FA0BDA84EA6C2344CA9AED4833B047532BB13FAE830F386E3A71CAACDF06BA46ABFD7C680E3DFAEBB08D6355791CC0917252A3BDE4437D96F39ED68D8251A7C38135277DA58363FC05A0BD651F2AB52BFE88884F8C0EA8BCB6B668B4AC21D1592167BAAD85E25112BE20A9BBBA90EDB48293CB7A79F50FB21D9E1876D7B07583D0FD0C4AC4EFA256D98DEA288AE8E814746B23C8148CEB41000ECC383B6F85AA36A46D6B9F6A6F1EED4CF84EC0A549EEC5D983B3C6D8C20CE33A45BBC50DE236053ABFA870DBDE8761B6950229C69EBB5EE8E8ACBD557D5D926F57FCF4967E068593D868D3660AAC8C3FEC5FA070289E217035B033D8A1801870A8C3F1EE3757F2F3196C25C7407391BE6B6F3D21C81AF6DC99D543CE42197BD127A8CFCB724249A1BA4EDA2282460069BD7B90A8A54CA9F483F6288F36C912E3150B11F26F68BFCDA085923BC488E0FBBC39917055A77F37AB76EDC19FE50B45CD3D175A016A8A904AD41D56626EFD75E2DF6D617BD3CB4BA19C717D4D1FE781045803F365D6893AFB9E44AF6CD99201CE7FF1021D585850E3F6D6AA06F135E27F493FAE2DF3D59933E0B42AFC28545926999EAA9F05902A8A620CCD7FF0F6122C02F7EAC0A39BB03922EFF6404548091A89330897F20F81EA038C124DC691A9438C6D2A0E21A969D695374A06D07AD6741CFE9BDC43BE48CC5F83317BCFD0B680443CA014F3791C8C7E8829E4191612004F4200C2DAD8D208374302808256BFA770390AD52A7767745EAE3853C8B2EC5FE4F7B182B8ED9BD5FCA1B5634F06B35FCFE13B92E1649A6B67589B6576F5D0630C56ECF6F62B26E35B8D73F44FE323531B274F066A35F270EDC43A681A84B46E7DE079C61548021F7C54965823B474C415544E041E6E95B848B03F0AE1C88A24A1F4772A04A8390050981F2B4500B6A613BBA3E5D37CFF5AC75650AE592ED6FBC781B2621CD381EB0B29FD0D97A77F83D05EE7E744C8827BBFC2EEFDD7A66ED6E0401A40C1317E4531144AFD4D1471B19B8E0F99079C0A2B5BD472735A924F9659AEAA1857969F5414F5F14A24F06968D698BBB4E5681084118347685B4A201CDD1E382215A01DFAACF51F988156A5D94F9802E9AAE7E204A096D37E416BAAA4EFADF84EB32F2FE0E5C5A6164C3ACD356B3A5C9EFF99FF216B17044FC2701689378C7EBA1AAF103C5210B7D3298B59547D9C623D9E21EAFBF706C36A6AF75B7E259241DEFA6FAB03B3A2208C35DF832AA4ED5B2934C56A58F0C0DBA2B4153286C380AD040758004C49A2AB6E7ECAC389AE769C5D1AD13EF41F756CD761C8457315DC027682C97E181CC79B292BDF93DBA2B1960C0394AB501290F9AFE49D4DACAF37CC1EC3E039CA10C8A60F65DC8ECA012584934725AF85881B8FD2508568AF1F6F23B5E7F010BB9EC82D4F4271369D5A283066321A4B58E03C5D3FFBD92A532603E2F7D446A7821DB82761B7BB896ED606D6F481B6C37BC3B60E16A0764A272C6C072D6C49FDD9256BC8E49799D4B8498A0FF5B9DC7BC676684BCC35E60E873307E089A4C9F5C59A0963C925DAE85DA6DFB9365895BE3E659748351F2BBA1D95224D4715DCA20BFCAF439A086C8E5B61D8CDDAA927C349BE5B8D721A30B21684D060D1B981EEBEA31C82674FF3B05B340787769882B704FA7202982B41A83B03931E212159DE09149011C8DC25C7E7DCB4BF85264CA959F4F15288E20FE2560B1B2586084D4CEA16362F2065E5AD102E221713FF30C16B57CF27E229AB5B6E8124A4C9CD110E7DCFFD53642BF447F07453B6ABA6087240F86921641F32D0CD7A41BD9067F41588E461C2779239F01C28414C5873D5B846A99F14D7F36E29796D7F08E14354A7A9B24C9FEEF1E2ACABCE6186195535324DAFD87073557A3B75A264E9332F7DD2732DB12696FF3857714DAF3833F5E7108DAC97D4DB337E6E141F561AB0EA8F41B91D497FED645ADCD2BFA8D4A96C40CEBAE13E70F315A1D5E11438660F33484C036E851D7F441D3C15FDF8BF7F61759BDCAA09FFB46F02586EEDA7F589B0D1D713A4BA55EBBBCBD7C8E7B460D159A02A4C8569FA0E7A4C012E561A44FED890E1F7A707E2D8CD84F918F8DF9FF7C4C815DC91B32AA6F922C823D19142994D6A438BC6E771BA2828954FC8EFC5CBD5CEB20F82B7AED4876B2A5AD91A4E453324366445A1AE530A71A871614E5A13A9584FFB1F3286E03AA7C4275D211878E979D9CE96955C18CF071654FA6EAAD520592A75A70BA7B6A1C8A7AED2D048D51C33A406C4DBBEC2CE0C4685DCFC021C0CDDE23451B9F44A0021F9C +MD = 8D47DE76F7AE4ECE81A0589C321337EA640CD5B03C320A3E31E5C1B82F452F12 +Len = 14837 +Msg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en = 14900 +Msg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en = 14963 +Msg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en = 15026 +Msg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en = 15089 +Msg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en = 15152 +Msg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en = 15215 +Msg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en = 15278 +Msg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en = 15341 +Msg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en = 15404 +Msg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en = 15467 +Msg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en = 15530 +Msg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en = 15593 +Msg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en = 15656 +Msg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en = 15719 +Msg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en = 15782 +Msg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en = 15845 +Msg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en = 15908 +Msg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en = 15971 +Msg = 2CFBC348690343FCCDE647FC6F725401956C8D21F99DB93FCABCAA9271D0EFBED0F8538741A2BB665D3D71D488216F5FD1CA43D6CCD904ED98D77D10C248D4EB3DF996CB05C187C526CC406BB3576262502DE9D1F51BB41AA3A70FDDBA9C0DFAAA614B9C27421D9D44015DC5BFC98D463400CC020BEF082331BBACBC1EC516B064B3828DF879E9BC8D139D813CB4D142981A7A3AC41CF3681A9D4F36966EFB1255B75280A72C0E2B59ECEFD89A78B5EA5F8035E802AA59CB68B6FB3F79B4E812EE5BA6A31A0D206D44435F776D8DE13FE39FB15FE2C4B181425CBB5903A46942CBD46BE64C94C48229F7A5544F00C0AE2714EAD5A871E3FE44205232BE74B516F863FEAC7858CA605D7344E8151C96F9BF1C5D75846FB5B02E2FFE6DFCF656FCA1123F414F058F2F40A8EF3B28B689B60015F380E3B811C8FC839A7676CC15146D37AB34715AF30A92584561A2FF0CC09C347ACFAFE2586F5E6C751446147CEC878AF5D8DF0FCCA8FC77565CA45B745533D95EAF4CBB23599D0725E37ABC27DFD5CA264EA4D2F74A85DF6191D66ECA4346A83EDE29274F552654675BAB788894F8241D6F26323C914DC50E6EF4CF9A710637E2FA398BAD74DD77B2AB2BD77C0B69523B9D45638E0EA80613FDB0224074882CDA2FA9E963D5F4B7CBD1D66C722BCAD818833142EA902064FAFA9AD1E865C8FF0C97717693EE85337C24F2E810C4C2A2555485386D729F802843C4FAC7EEAD74DB3F64002DF34442E14D5656C1958E3AB4E2E30BEBA39C9B7D50198C03B0963BF9DC6A242BD5F9AFD5B4D8E65DE43092A727003B7AD4A12E575D166B2C412604CE3C82B98C5F531D7BB903145B63D2CC43362ED9FCC8162E1AC35DDA8B694FA916237F2B5BDA3F131C885503F3B46461CBFA034E3EB36F5E55B78A3483941B7F4009330D921CC127C11E3C7115A91420575CDB7B36F353E6B4A4EDFB68F68F8E305EA776046FA9A31DF33B58C655A7A7C0A8C6F5ABEF49A6494AC4842D053989702465E8071AB6261B5EFD95BED54CEC88AEB640565EF504AFACB6AD3259B5D12173D81743F0D0B96A1EE904D53E68C9E02870F5BE79A443089608E9E0762D18DCA8158BE4ACB0ECC397A935E4EC41E6E0CD345F1A9DFAE1C0ED2DE71736DDFD9172BFAB5DD482D845F8A8FA4444E92A5953835412B17A60B443D041AD01EEEF86D5882E7A30BA9CE2B2669C4693B5331F355A01CF03120FBD4E97AA725AEB44B292A80205969AF981A2BE726210EDF650C5AFC7F0F981746555A5CB0A345ED2AB1C75C06AB26C422139050617785B8EE72E4A452C114D12B306FE80F6990764C6489E4439FEA02F0A0AF480A0155C48762AE272FEE357528232183EE48BC07F7C969997DDBCD339889B565618665FFDC528F8DFA5C9E9E5FD1989B0A172A32557E379306DA5D706DDF0DC537B71B736197DE7287F3E95219ECE010322C8953D63719D738C2E0370EA51D52E0A04910295C74C9D15C8E9E936006FB9CB79AB14AE898AFAF88024561DC2EC5DA1899050540844A385A92519C46F16F3A78E7F4C4D152C42431526CE4272AE667B89D2C83D6BF640812A09EF6F95ACB65BBAF75A291F0F50C48AE39CD4C28200BA277CEC4FE4808A5811670B30C107E945231B40C9A7F3CE657B8838C10FF26B61833E530CF6D657BCF4BBA42BC7D9614374E6F00440F816C4BA2A239E0EBE8D0F7CDFB4956473C2FF16344CEDC409BC19C8A718D9E308E1B6323C73BEA74667B646DB9A7237BB28DCAC552ACE1E7FC15720E59FEA956ABC9EAC35089BF53B2FADBE8DD2FFB116C5CA2D6D8FD015D1D128F109011027C3F978B4D415A32E780181EF12A34169698A98D679C2725D48B35F110CDDAD1DAF15692193F3D4A64C56A59C58389C682CE0AC9E3796AE4BFCA9883E69A0D94B801437FD77EDA60827D0314201BCAC9942B470A483A866703F8C82878935479F8B22FA1750F2A28201DD87BCA5A51C4FB870BCD68888843BE9FB1563C76316C34D4AFE893BEB5C0B50ABF85885B7CA6D0E33CACCF2BD8AA15F0117C2DBAF9B0114B9CAFC800126E314D2CE7B0B93923CE3985CA6A046D8CC7FF897AABFD47BA9DA839F74641F1EBD46746DD6627708C8B44F6CDB3C85D666B2FD5BBCF29FB197CB684AE54B2A966F512EFFD8BA479E4BDDBDA9620A2CD913FED61FEE80A24E7F86D684F943C5E49E15A1DA80D0C2C088BF4324A2991DD5744FE7200C0ED1E1FD87B734254E8A8E9F68BC98D8BA4050CA4CEF91D571A5D8921AD639C948C9DB228EF0F16B4901477D6A54D68DE1354897CD903B6DD274BB97462098EE134FF57F33AE8731B799CE009F9CCD6E769AB28CF92C91A8C1AF4D4EA4490BDB5C44466CD61A90DAC3E5B07FB8EEC36A105DA3699DFC745EB6CFF89CDD2E4F1FA8A52904FDF243C5DBEB67318A5CB18B8FC4946048CD3EBB6744FD60D829A100F234A7DA942D1CA4F2FE463629CA974EB322A056D85E4B73453D101187FB3D520F264D0E0BDE510613D535DAAD181136F3F999C2F8885A0EA447952E0DDF2F38053234C820F4C9B2ABBC9854DEAFCDE93E47AD6D3738FFBBB66C842E61B3122835C1329BD77093C2D1EED5D0BC676459B23A4EC6F239CE2B893CA0765D4FFBF907DBFE9FAE6428D89F3E2C05A46E48E1D54518A01DAED4EA056DC4D473DD39C7155C9ADA233997F2700009A38EB91567454C6BF34B7306F4D1015ED8DF985C2C6806C16119AA0D0D23F7385594990D83F0017137997FDD521D38A4661687E671258CB8E0AABB463C175D55635D0A358C797122533C37DB369A538C4B00 +MD = B841471EADD3C98D8EBA57C5CE15E407EB5053CB062A1055113D350D3A1C10D2 +Len = 16034 +Msg = A347193FC71F3B6E0A667CD91EA742E912938A705CFAA3FB7F27FF0321C7078A99FD93394B5270CD4D12AFF3C8336DAEF1A92FE59C6F4BD9B3C9BEA41FD1A7896869214FF49CFE82B3EC9A45EEC69DB9ADD2697D47E1D45D8ECF1DC858DF8C95D8F9BCD88EBE57BD53D4B5253F3919F339DC2D41FB4C787AD09E3A34206AFC5A44632F58848377B25B2B75C85E3987F32895F222CD58A6384BDABFD7231A818326289A9A4C0755251E166CEB749B20C70AA033782BD3C1AFD908803A48916082801F4484C4191927E0F415927573E63681425475CCF6EAAF0621243A5FC96EEFEE6FF3ECC76841728206A576FC389F404EF432B5C57C3AE909BDF6B314DEA6A8F5A3DED1125B4817C2A858DEACD029DE5737E3444115556F11E7BF9CE21E107A021D1242A595074860312EA7538A6B0ACD76021B43FEA515D80CE9A0687C54C1F364A6C2CE49E4A34B03E80154463A7174D2067405573A503196DD3842D90B67B75AA03D662DC54CAFB6467281BDAD086B62BFE3BA4895F16A5E056EC0571B45AE9B7630B172AC4F22D925CDD008F64E9E639640580432029AE92C3B6C804DC493BD9A22911F877B730916DBE6DE36771082D36E1C20B6151D4C4AED31B252087B6768117A48C0DCD80869BF759E53A316A6DFAB9EB7F06F2393B3445E80CE8CE76E53AE982C43A1CD1BC22F06AEC878AF01C6987D76E24224B6EBCEC4DB629C4BB2F35C009FB902EA1F3E89A4469883B814C58864CA2F34B12F37B61C6DBF6AEA55C492D8AF83CF0E6D2D89521EFF04B14C57A8310335A004E44A576510C40857A8E68A366DF24879261057676BD22C8D3F5D2EA6599C4F013EF29483EC7D105897647F342E183639FF1AB102871E5B90F9BD831552FAE5AF2EA71EA5811CFA8FC0F0733C9C33C7BD24B9179CEADC5F5CE7044755D7247F39485957BC741258A8B4835F1971149A6355A3682913953CFC34727DDCE30EEB447702CF70FBC7CC6154B6D35030FC6935559E8A7A28F919E4233D21290C01E8D0BA9BD1C87D9BD5605A2A7EF017C27F924AF5F7D794DE9DD72EAC61EA52988861604DF1533F8C7063E721A693E07E7304B4CB7FA6550A5A61E972E2770FB8D32106FBF7DC111F841D6BA7EF4441EC369591F318A7D1BD28B5F3F156331FDB9C696A33F9211832F5E77BBF104C5D2623857574F29AC4A4479A69501B8173D213C6E5065FD60D5D2FF16D91BEFCFC125BE385A705B40A185AD2FED26A719624FC2412AD744B4BA4A834F357038038D65E65E28C8919855DE612093E2BE3984058E954F510EC1C681C1CCC1E5F74B8C72D986FB81CA75C118B07F625E41C0A4A42A446ECC0D323640DEAFDE9AE507A18387979CC273E16CDA9F011FBE798B1427B932313EF3F60100BC0276FB88AB8210F6615B8ACD51CA7970487A87EB114005C86D6A7DDA8AB06A6FA700B355C1D847BCD414CFC82AF25649F91E6EF08B79AB238F868D9384DF0F23ECA5C1617672CC8540EF78C3A9CF674E6B51E63D36A445FAAAFE2622DB9C4AA3CD79C6C10578B649660C32F41A51DBF066A8F1A7A157A71BE6ECDACF630C52180449321AB8E091ED3ABFD8E933F062EFB28952D43638E8291F6F51A6127932739DB83DE79FED125EDBDD4EF23358648EDB070E1B9D138C3BDA010A2EE1E905EE159BF845A1C2F7761E76FFA2126E0627654B4C248A0263C18F772E56B3CD7B5D618D2D5EB0F84B142E6D8503D5EBE164334B0DA26817B73A7F7BD49F9F994C844E052ACBF0775B7E6E8BC418213094D827DF2F70052CB8E559788A1520FD0EDB85232536E6A480637EE51428321740F7A12B00872D72D559F6C0C20EC4C64D27C751CBCE019C42F556299521AD10195462BE1F78504044E44014DFDAA6471564E5E06C7B6F815F38164C52D7B4705BB209A0BE362CD8497BBE163C10B1579C950D7035A36BC06929D0AB5FA299F1A3CD06357BABCB7803622B3F6B3968A171ADBB5BA74BC5BF1268FF8082DF052D8F21949852F629D8689575D0236A77ED5F9FD7DB2245BEB40B253CB041FF4ABDF94102961D911A656F0E9042D13352638B7C4DDDF388B551651B10B1622925962381BD98A620075733B2F92AC282E5714A3C4E9BFE3398AF2293712AB9AD454828600C2D47070A6411BE25D9A98A3D182DDA8D8B0B1C16D3DAD2DFC74A24BBFAF5300F1B598BB8868DC078574E90A66A5B9BC49D9BC94384802B2FB43069D3117880EE5294560789ADE37261A53398AA3AC7AB5BBFC5A6C1D4D8FEE273C393070D22CDF8F538DFF76F0271673B0CFD555943F80BBA18DA30DA697AF1BD43CA17538C4D75DB348A9627D96B874B086E235F2C8592273388378A4373A305BF47A51619605C54F1663C8A80EA6B5FF7A688BEBAA42288E3C03132B70E2CAAD3D5D4150B1E0A4DF14470E0225FD42FCC0B1CD5E222A650DDC903C84D6BB9BA15A54E793041BE2331D2418AD5F654B9CF19C4539417CF4A152C83ACC5A592FE057F320FBB8EE1147C5D04A18F5BAF737E1742318F305D8F5004BFE00C0AB4EEEB40E385B5133F6482586A6A35612591A8830E3C454B139C4A01FF5DEF2B18698DFFA6387BB55149B6A65429E7AD97CFC901BE89762D2A8D6423CE952734C9A9140261CB17024D6C377AC60DA6A6D680BB32F51627E87726D671C3DD170AC430C4994B4163AD71A96ABE5062DCC0E9033F1275EC78DA3415602DB31F06FF07FDD6B1F5D8CD81F7A44C549165DC0352A186AED7BF0910B848A18BA961A60DD84E9C6F7B31E29ED61417EA72C08184F4F6D1E9AE5C33A76C5615D85DCEA44F7BF57195DA77D0F1DFD1C80 +MD = C9877E7BE60D35B4D2C0F9AAB6DBD311D9C38D7E14EA8442076748A2BA243702 +Len = 16097 +Msg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en = 16160 +Msg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en = 16223 +Msg = BC67A04FD01A30DACF5CD032347EDA5969BAC06251D1F70B25A63FA173B3334EBB1F8A23B84377D77A1BF0A2BC0D1FF8C5E714938806C49B5BD2799AC8E8D4DCAEF418141079C96A628A9E713653C3AE4E1E61E77804A3CC53D4DD0F8F41E1A949D9732689EF4D8543D92B7A0F362173F4834BB4DBBC4E9036144F68690E52F4EB21B006564D4C8E856EF15B2CCB9729ABE1CB281EF0C9AA0853D41B2635A223D6D041ED43CF3758FF4831F5B8D18AF4C3BA13ED66F193CFC658841253D5ADE4C9B44A9CD439D9F5B836AF90F640E943C5831744CF9F2AAB1686BDDC8ECA6F5E4B50B6C54C3BF727683ED44441BF6FCDB58B0590A05E14E39B729D7E396CEB07FF532173F7F4E45B5D5190E94EBADEC732D67122784F2F4FB67D0A952882D57AA4CC721CEC1242986A3B91F7EDB203580DBF8B3D7D0ACFC80039358C1F35786C021CAA843C26244FA52A4092ED152832673E0E40601160C8688C9D44D9604362B49BB8047AE483B83A74BE85CC1C1233239418FA8B78F368F1F53DAF66C7479277436756F12B4BC7D66B1F75385682D02F86496778F4CEDC74478BDDC9829CE35B8150BD9C4AC8362D37947C2983D1028F9B05D64C488A38F68432207C12D024401A890F569725C1A33870FB19CECA591A7130C52E98165BB2097ADAD3E553B89DD91B53199CF1E338ED58EF0582685CBAB7AC8F815EF1BD0ADF2C2CA042FBDE090589E2B9541223C96C91AB54B9264A26A5AA361F02DC46F2587940E0D8955FB864B2EB5E63B2882BACB3A07EAF2929DE8EDD5F9BBD0563093B1FA8B247BCEFEEA043515D49CA696E73D2242704174131ED05A9D639851399D5AE261E01153EECECC3D3CB93B45344A49C2C2776A7E3DBC1A7C3208053CA7F73CC61D0F0A01A64D7C2F93316FB61197E29B15682632A36CCFA19B739AE3C636F4EFB70E87B98E2E92952CFB45F0731224D043A400DF614E35BAC413536217509B5E9C293A6CF3135DAF616B9193CE53715C4D615B78271BDC0A0861CAFBC5B14C258650DD9CABA38548E6555EE2941696815F683C7019FF60D7103A3AB5749352116E90D90519252D608C73C0726674D918D20D90E7BD9A6315CA6AE8D0BC4EECD1153819DA8EE99ED7076A11E1C25AB4D693ED4C5B69F18D1676D48631F621D860DE6CAD29F1CA8E1ABD7014A318885AD917261F8E0F3531B922F1277579A0325809A6E4FE84FAA9506869D279D954B8A8FCE21629EEA030658E6C27B03CC279B4C8354D84A47F97E0B860DE122A82DB8B4A6F3E6D916CC95DF5241F4177C40ABBC407E42B0F5BE2DC029C4A36F4B6E5C5F877940C80ACA91F0E86140872C0D0648639203DF06B8630ACBD7A8EE1CF2E593BE0AE0CACEAC020874571CACBA68EB7CB80592DFAA6429F98ABDF48BCDA5E2D48E7354878C1B119D027CF391C4219CBCC5E8D36F87FA23B08B51FF7345C9353C724064F4E658B80BA5B31F2AB9D0BF5EC49EF79FCB7E5EC184C21A3E5C00FDC7733FC9D1323136A1F6C7E4BA8222CAE3D4AAE23C537802859C7F4C96F091728A9609AEDC88CCF86D001D3524511959AB239E77CD3427782346A00AC6A483FA82332B4C51A7D914C1F81A8D55C9833383A1B98AECE735EDC7503955AFC68671C474455710C88AEF71109354B3918CCE286223ADF3C345C254D6BF9A4D13CF70C88BD6D8EA2C5C41BCE807409CB1F153C05307AE2FCD5056A45007243DB4B3E56C9094A65033D08591188FCD77E81F0B4991FC2151B0CD699D7C19763825AF7293CEF0EE95A3B6A52894033C98600421F9FD76650828592A9590444A790EF32FCD5D8DBC3252A4A4E43094179A02ABD0A7CFFDCB6DFE1EC07819E8112C4C814C0C8E0F6144B1B0322FEBC4B41963669DAC939993048506E27EA2A28E856B098B75D9D962B4F085110A23D67B59C1E2233B6FBD3FBD06DCC9ACEA98A940684C9734085CBC4863FA0176C0FF785F948EC62438CA088F49E2AFA750EA56858E33460E7AC1D55658AA3D7AA44E5053BCE67A6287C52058D8D9F0AAF81D76A0D8C4B9FACB885A6E9CF6874931848D4011C47C56BC30F99A6A877E50330ACB34F571FA6DDA15525CAAF345B39F29F8F4B4CE70362C3E5CC7575225B7CB6B956580528368AC606DB89879F3C3A1A2339D0B52236613AD64C99D3AA021D0A1E271E0E5D0893B40FED7F1645B390AA703A0327A78040F1EC5203BD88604304A627913BC464085627055DFA98935317AE5171D5B0CC4C40F54905645FFDCA0D7E3AF07DDD43A5259BBEF38B8EE1770C5F6EC01C53496EC68BA0449C7CE70C36D2A0BF292BF9560BE4D397B78B40EEC6FF46F51A02D972B3F9331AB80C6A7445C83A361B0882BE4BCD71FB41D670242B8B05DCD098568BCD0C9BEA10BCCB881E096C855A7EE72EEFD4F48318035423F54400684E7AC9DA71CE56E3668EAFD253B2669E6CC600034F7F5CC6B64B5762930916D25FE3D6CB9768ECACE80C99D5DD0711E3EFE237D3D555E2EB7E3BA18F0E49723DBB2C545E3176D6F97B812A0E067FB9F54146D6308B1DD62A50F20542EABEB4085FF9F29B33552CAB4C044DDE8B2B67FE74115A927B5727AE1CE5DC207EFF957C9D1D11BD421B19466012067BBE7EE36FDE257E58718565D87BDCCAA1E9BE8B93ADFC81FBA9C4917174FD97B7C226ADA96985BEECD8E5A5C2ABB1EDCDB993E9C63FCB7FB482F79C9B94CF6C9FF374E2476FAF1421B220F8255E13B5DF731352FD85CF05A383BD46168D4CEBDE30FA056A41E8AAE15CE9E50496392DF24B5CAFF44462BCF750ED0443DFD78F81798B4A692CBE870AF057F8009B1E91DC75DA3ECEAC11BB134A91AB99F1A7C9917478BE3C71C2CEE +MD = 3D0A02CCB11BA023F2DD7046DBA286E14E8821E776A010EE337BFA75B05B8CD5 +Len = 16286 +Msg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en = 16349 +Msg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en = 16412 +Msg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en = 16475 +Msg = 47BA3D8C972603646568BCF8468F38B5838B68601E473551F160D46E48CA4F48217660AAF2813732C941CB510BA6DF5A2253F28CE5471A2C8A3E2F14E7140E980C3D374053B596F7C967F725AA051BF1565E6424C8262A66F4B8E6822CE74A33CC846C6B23B7959D5C8C6EBACF992653F86BD2118725E36846D027F0C6B3292D6CCB0C7D8CF6ACE7F385887FBC2BF8954CA5BC793D8922F252EC483EFC8C8D598CFA8C38F813191ADB0E470BAE4E5B0D20422011EFF36C93E2D39CFF806263A5082514456E0D596DB26A915A774DA94D91A94D31D48AEE292E53B27036EC802460E9CA4309F6E8832F64ABB0D537B707EE0971C0883634996B0DD5632A13A899E875C58DA14A540E31620662EDC404F3A2EBD2940D80929F10E318DF20588C4EBB731F12FB034AA6327F25AE2E366A549F9DAD760C321D9B4E97287B92CD9FF39C6FCE92D13A1CE3C8E04177E5E2B2923119B4AFBB04893C709736DDBC8183B4FADC2954136E575BFA27B144F190643037F614114A21819224773A55C6A1CA19745D98B710E446194CFFA9B2B2922FC174EE95A087A0063D200749961707D3C35A2E00EBD29D8709AD7DC266EAC97458CEFBC99762900B95F9EBD3E495B7EE4B3CFFF9D0141516D11B28524F1AA2E679AC54193BACA6EADDB4D7639755ED3EED253BD529DA24AAD4B036889ADC1A5A02157B6FD667AF45E37D6F34A24192F4E289E720F59A838C873269CF71885768610D7CF4F50EC46C557DDF0C3F47E528423A10F70911912E7AD4991EDDCDD7E3B2ABDB4ED69911FDDAAFFF4222B59834996AA52937C8EB0F314A1D97EBAE2D400145FA82F0F6E4E3BD1C5672A7778C0EAF17D5CD5B3F80B9B06D5B7FF525400EF5C0C9582C46FCE030DA9FA1BC15770ECE43F7178521CCAB3D386792D2812B60AB2D58CC914B3BFD309496F2978BA00408A7DDEBC4A9C6560871F5A1AB9A984334144EEF52F500E8D6F6A7A6A5637B56F7DF23FC9C9D9F7F7E778E77CA7F892F79219F86BE5D5323027A33F9CED00973917D4FFCC7C7E4D3F9E905089E6FA7CBB95E15C5AE510652C62F20BBE6C457DF17CE51CAB4A05E4F0104B1B12A611040E116BBDFC7243D57587370B9F795BAA19DC7F0A8EFE278DDE4C22B73EE059436FA3BB606AD3F9D3399C25FD08A918D83C7249CED416392B49531E126F1918DA3814CED0318E18BED7DB066A4776FEF922EDBD74CFC6F979F1E605EE27566C1AACE99BAF41B5774BFE0A925E649D09981205EF7DFB6945A6F34C624F8DA0491CBEF264F0FE74C2477CD99E23FF9B1FDCC9EBAF1BE520E31904D72FACFEBA58DE606CD4EEE5457D2A23D44839FDAD08DA62DBB349D9E42EB1C0113AC7CED169677ACFDA71A327517E66773709C70636DBBCCE7234BA9430EE131EDF3CAA5A738B67521F2B5AD070034FE610A129EAEA12137B698E4FF79F05A7D21551550B1EC79044594354C6BF4B753331397C639D9674DB20D4D293F52569F6468B23731D434E8D1A191AEA3880EBBDCD952261717EB1966B7575555582B70FAA4F594885ED04BD824D76C63D2F9FF585C805026265ABF31E5697E30DFCE123A13EF98F06CE6C4083CB0E1D5DEF36700A385972D7D8A63711102725DF5555FA5B4FE324F672A6D190A8E719C9DB0677CE8DDF5D1F7D33E66057A6D542D38B470F2D5FE2CC9B0B6A645A5BC5A2B8D9DB92D25CB5B5A9FE1933E1C5C9F70F56DAEB698AA0C7646DDFF497367928445DCE2D4027DC23399C1EBFDD95F676DFE4C433E8AA79D01996AEA62890FB9FFB079236C194889FDABBF15E4C86F9F7E2EEF32760C1400233FFB638526C9B4B51B7106DE63E523B252D1860B61889B428FE0B5AC8DEE1E509130CFA6130A6BD21163138EE73E59165DA5695A9C283EFC09C370A3D8F59C9402661B3387C96824BD0AA8B19B35B957007B52F5942D8BCFE185FD12E8AB988375AF5DA79D5D69D18E03577709BA0A28C36D0DEE431DAE7B7EF34EB6500A5670628E328A089BE2B59639A4F5DE37AC659ADCBF82EA233DE63ADB9C2629866949103216702758E05A4CC7A3F0757085FD8D449C799B6EFE67CA9C86949EF88E6DE2180D25054281FF4B2F2D1E73F042F9ED39DEE3B7D9FA4D9744F743E1A8F02114132CE3A0A046E65ED23550D766B4CB4D372C0D57883EDC38A84617332607D8A8F3E293CE3238045922A836FFB349A5A877D49AE7A82897539F74F5965DC5EAC73F4A8AD20AE18EEAAFB60F8579F7394F3DE3D7BDFE6053884B43D9D217469FBBF08D77416620B38971768A25A9D3977B166A36640C480B04FF686A0F39823A6E769E688F190EE3C80D35146D8D1A3E32731119A532E3716E8F3587FB5FA446D2A485B21636FC448555A1953D40A73B6F34B5ADD181A0F09C2C4CFF37F29F405BFCE25E3E9369431B358391CD59AA096CCB0FD26889C39B957E2101A0AFC1080D6A1D868D8398CC4ED27C1C8C600416E3625D0B7C9536D017AA6C69D02192A51AE5C1400408B18BA24A2DD4626532846DF5284F461445ADCA1F3F27E911F42EB078307CC62E8598013F5411248179442AA90E65C2FB64576F0736D2975691BBA216692BC187FFC71846A53867C320BAC97988A1CD340E0C56E1460D681A88E3051B9878AF431AF000881FCB45E9E3019BE3EB67D92A62056625867517E195E369A14FD8F12488C8FC37D22B07A874938F4F68BB5F3E9CD5192EA7169D36F6919CA1AFC4E21E6133FF07D9E9BF24063B7C42A8615BF83A53556713A5A23A75772C75087DFDC2D52608ACB44F50F474DD3A4D7B1E1B023EF8EC7AB5F95BFFD2504A974D7E69959D889F641D973ACDE7CDCCADC05EE0AAC615A7CD47AD3126EA8D0AE3EB09BEA449ECED7ECBFD735CE5953EF5DAC1AECEA82EBA2E902C0460 +MD = B49161D8D02E3F91D0C0C78021885B7937DF33CE4740BF2307C16C4268D40D88 +Len = 16538 +Msg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en = 16601 +Msg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en = 16664 +Msg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en = 16727 +Msg = 5857C3781568788D7703A060540BA1FC0539F571B0B082730496E652943DF66F8475294D0E55E93E0C4A0C15BC9E1731C8A9C9C21EDBB541C1C1DF438A0B0A40DB6D1463EABAF20459673249A13357C38EC3E22C69309767B90C030B6E8C36167870C177A90975D207728BB94D572685619666E2D5783DBDBA177D555B20847DB0984D6D1C0FEFABB59EB8560206D0E2C304962AD57F4E6687E0D1071218FFFA591BA210D9DF74765FA45BD6F16DB01C134747F7BC324F8D3B96EB0BD56C0717481EF311D196ACE37BE4BCADFD88FF9A6F5D0500949C715B173CFE958697EB8F58911ACCC1AD1369FED5952D5A722C44EC6CEA2CDF2F3374100CE672082D21EE9434BA8096B1583D500533232BA98DBA46023C73CD60655BC0201BED3C8A0D5D93AB9C2C1F12EEAA0AFF88AD9BFE739CCBD615DFD23D7BD5F19103C55496C5FF083665013EE63BE6384CAA735C651C2A4D1A70A118737E2F70FFF282C5AA61A77C050A69551A53A1015B0653A8E9F540613279E1C86593F6A95B4A016691203CDE57C91412C864F9B994457874CEEBDAFF967D7856E9F5B58DBD32DE998C3CB592EFC711102C8B04755C3A1B41C9BA1E1BBDC45D6DA59049773CA6AA65D54BBD3D7C69DDE800CB58B15A359D4980BCD128289F0FFC67EF7047A90FE6EE12E43895C8EA2E112A414F47D6A35DCDA90A7FFFFC2980FAB3E8D051EA00D0A05BE03A81AA13F5DB5D70F72C69005DA2D7E459440F1434DCC2E00A4610CECA3D194FA2CCE3217B6CACDD49C0D91D6362A2B01EBA9360F81DFDEF40A74761B66F9264F3B55A772EB24A36CB92224F196B0F792E62A75D491D2E2DCCEF42BB6EAEEACA0DCCCD3A8AE421E575B917FF83B3D7DD4890FE29F2DFCA586A1801629DF55BB5CD7A3FDF727DF013A3CCBC5E69B12EDB334A2C080C9E4649C0A0E8C52B068E8FD23969BD99CCBA61910C3CB79F066F0625EE642008239651E89F1B2156656C5E1F990D4D270B0044E8C970FD17C68AB5F1F6DAB9526AB0721EE62CBA7E22C8791B966BAD042A5E4B86E3D3153E4168E96246896A90035E583B3A3CA556516DA90786DEC86EEBE0D384AA5D09D6068DF90560ECE60D1BE3EF31E75EBAA13E1CCF11C93D46C3BFBC77609E546F8360D4B899C011DE4DAC72CEE58DC03B2703E803EEBFFDE30712187EDB7D06400F8483E9C81C0B5A9CCC233F8935A10FBF82612266B81BB2A0453AB54E333F7FD6A19094E7A3491C1E2A83FE80642BEC3EB8B861218689EAC065EE9038DBC7CC1D954EC5A0C96B0B63BE6314364BBCF8427F5B0FC97DEB44324739A70637DEB2AA2479FC250A9D5C46E091A52FB55E0AC4DE3B984188DE82B0D1A9EEAB804A5D2FCD2543DF4BBFE7DA817B9BE42A185AD9E93AA52F162781DCA75B482BC3C94814052AFEDC1AAF63153088324ECCEBCB4F6E8CCFBC16978BFFF9E1A5C305971EAFFA7D680A7E960691033622BA2CC78099E8E883DC090EA2BA5AAB0EA7654FB646073014FA354C7D9E99824308F0FFCC41CAF711105559F8F38C8403719C3801CAAA9A5ECC63E45B8F2E9463F62620FEE4CBB3E9B95970749A8A4EDD1030BF6C45EBBD706E2378D8765C802FAB109379BD4078A70916B1CB5D5C52462660B99660D3EC5C336EE285D3C0066512BE633D6DB78ABC70A1881994A76F269FDFB23472DF8539B20C8019B88AEF3D53B656A8FA01C8535AFF6200AA47E90FAA3315F091F0E723D44B4FD44F7A222641881F98237AF0F972C3C047C35711BDF0AC775164E33A910BE198890F40AD086A74F23907831322AB61F51EA0DF0DB6ABE432502FDC94992F886824801D99447199C516CA9149B8055491420BB25CD6C7334536BAEFCAAF81D9F7BD291EECB6CBBF5D8BB6F88487F3C152BE382B64B35623664874238A5918FDE0CB1292A8626E73A89224CF5DD17586E42191B32DBF9F044CE1A8D07E934F968AE9FE313D46BC5A349D0F4078BB9CF447D44092A97188F191DDF1786384A4FF6B402665F3EA45752523B432F6F5D608E43732C99281F54E9FA8DA13A682A2CBBFD93E4E5EB89D742978C5B7625F4C726E9D54F24736B43CADA0755D0FFB30998FA5CDFE09E1E6B336F179CA8C50355EBF0C0DD3A6B73AAEB748F9F150307FB8749ADE025F5C917DAC46ED7F430BC5D8E37B2E380955B65920452615F6DFC601DAEAA8558B6853775F450E87CBEDDD5BA4F8B180024BB260AF0A272111B120F47C7DB07ED650DC58823463280AA02F551CD8B966DEB953375C3794CF98F2A99633AE9F51345C5D428D8E9D9570053A77F85E9758DB6184598983EFFFFBA6073032FFEBAFC8781E7100FA76C2BAEAA75C5A1279C9FEA934BF3CF0D63AC6BFEA33F3EF5ED23B220A6128597D297F880B4BDDAB930269FFE57DAE7E5A7C131843F3029E9556B0C7B038160C3B2E98A9D37FC5E7A2AF94BDEF3395932D82B307B3FFD384600561C7D3A690B7E534D12C0D8F40C0D9FBA2BCBCF7AEC883D38045DF8CC3D087265C1AD3352A6504949B52403AF31428ED5FE383E1FBC40D403869289B27A67A99B2BBDAC0E9650D674E7824D63FE17A9EEBF4CD40BCB57E2F4D4AEFCB82190CB0590702983F4C3B582C5D52DDB327AC9D8AACBB6BD2DD584C286094004361CDFC77F71C69F961696F9797B4E7A1B9F22130B0AD46DF53351DE4F04825B4B06DCD514683D033DCB9B64D0F240CAC269BA8349A0942325499467538A8DA11188568BDCBC71B65D0E4A7BCC5625DC24E2F16221F23B74B0377FCA3C40ACE44293E11A5B328DD67401083E3D52864F6613A96DF24886DAE8745AAE110B89A120ED69928AE805AA4A839F2F79C7FE5FF11BBFBC3B1DFEBFA562358A2807AD9C9ADDEF9F9176ACC86938320F39DCC6B68F4BB08BE0722175575869016423B9EA5BF7CFDE501B09AD0CB22424A6AFE3133F44638122DEC91E6A2 +MD = 8DFAC22E563C0CCABAD48E9FA32FF17D9A82F3EC4757077D9B614B1773F41F5A +Len = 16790 +Msg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en = 16853 +Msg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en = 16916 +Msg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en = 16979 +Msg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en = 17042 +Msg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en = 17105 +Msg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en = 17168 +Msg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en = 17231 +Msg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en = 17294 +Msg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en = 17357 +Msg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en = 17420 +Msg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en = 17483 +Msg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en = 17546 +Msg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en = 17609 +Msg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en = 17672 +Msg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en = 17735 +Msg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en = 17798 +Msg = 1E8396189B19C3808C5C1FD69B3FA73FF9DCF7681A2660252B3646F474F3D9E2C80D50DC3A6720B3C9481A9952787436B04B626B2030BB58A4BF086690A30575ECD23C29DA87C822AB9B28C086F66371CE368DC6E14D9F58C11FA603EBD35BBBAB787DC09B8C5BF3EF8C49840A664CCFB7467E83ADD229C26B9F819462C6BC9CE058160229EFD947D2E6A76AE26C514D56F23C8FAF04C74D9B3CA6326FA606E5B67235010AAEE609DAB1E23DBC1CBEB80BD8428E4077CAE654370BC28FC939000BE683BCD1789284997F4DB9BA191CF44ECD788F6A2F0161EC973B7164B31B5C7A3AEF22F9AC879666C92C654298C36F4F6208608C19F09E937D03A7D1ECB97E68BBB187649A6E638F66E7A0934F73507F856D84D506E2AE5045D94E5FBCEA1A1897A045D7D0819BD2E5A7E640C40FEF32CD237BEA9A7305535320BEA358E987AC98AA11D8CF6F8E2AE4CC1AF3FCCA6D3A507194EB43BF8DBCB52A13E76BB690BC5271FF6BDC0D464AC6104DB5B3790FC3E6AA465E4294E4970D67830EEDDC8D35A68068C073528A32319D52CEC8B5EB2045FFE5D8482307E87254046733FB91701594D0A6C7BC061DBE6A63796B463FA4B717725C05F13DD1B9240B90255E2B9935FBB44F02C4718B455E8BA13F83C37297CA0597B5EC4D04A4DEAC98A4E7D2A0D9B3B16CD0E5D213E3D5E029A5D2AA29F4A6239BABF71A251D1CA93502A2CAAA36EFCECD30B34901258990F984CFBC9D866490C6F1E396B89AFAD30AA8AB5F29E47B1A9BD15E0F340D225AA7FD25BA1218908904CB05AB6A44FD8348BCD6EFD402AD32F00AC0ADEF5847988DEEC11BD0CE7848F1C13192F8FE7F54EB2550B512E75CE6A4658887796276DB6884B9B6C8D0C67FDEFE44058E57C64765E8006D33C52710BDF0C34F3C66C5464BCC3652410D19A0281EC533DC96D37F630D4B9796D24569098A0D00CECC082FC39E91366ECFE48D9EE3345185AC3F136B44F739AE859F29EB42136F08F56001E6055FB654AF7CC78F1DD73EB66FCD9BEE423FAA837348F446709654CFA854770C325A3EF1E9B71EBF09A3A2E0B6C3A8D482E631837812C1A42424FFF75151F432EB05D8E89EF22C305061851319F7E3E24FDF043823FD0C98CFC9D04763F779355BCF1245B1227387BFC0191A736267F5AA32D0C45B767B0CFC472F1ACE244805CF234FB9D622DA9134DB862A359F35EF1FCFD49E6ED50E8386B4E545D3088A68BBD62395152B4606DE40AE1C97CB1A852AE949287570EDB751C08D17E182AEB72FF89C093D1281B4A8A426702298BFC4DF1F1E545EE6FC1193725A710026505B5FCC807A2BA5D18D1FF054790862A206B66601FFCC956D62F6C8F0B2B9A8981195026CD2F4B9F59291A56E62B671FE9A2466C3EE969A1BBCE1E2AAA9E63E2E4158D4D9118CAA798FA133FB31339E1CCE30E9E14C2731355969398001698A1038BF9ADE000321370FFF053DAD505A27D705D68479072F391E14CA273EF268CE2947EE51E73DBB6F34557D6FCE0C62BC7E1BA4BC5C1368DBECBCB2C67316E41C08AF014849AE6C201425D30B6DE0961E357E0E07C30DDF3EA9CF1EBB2F2EC3D0AE140BD25DBB7DFD535DC8C41EA6E258FBE7234C620DA27B0C7F9BF2FEA426494D19990A1871DD734C776D35FA6CE00017A4EF08A2C19B88102C094F52842325D7CF87CB380CC10C68257305C77BDF3CDA45157EA1FDF60FB6F521119388BD8950D536FE5848E18372C2CFF9D67B9E582F303BA3467ED9DFFE62C6C502006E71A7D5E227042095455425517125DB00744B81BB58AFE2B743581696C5CEEA35A1396767394CDC5674E961194A51B6870A24790E3BA1A4FE906240F88C13B8F4A33F333D1B4400BC0B602C18704F29585F7E724D18C9722B9E346CB4B85C21A9AA554842F19727685C26E50C865E20716FC65FFAFEB0952A1ECD1830555F84A3305B1D737A18DC1AB9E1F1E841CFC13F2301BA38367351A58F67BBD365729200116E480DF64488677F7D5FF31C8641E32AEE721E6D0201C11D518AD39F8A25B384D706E8BA20C1174F2FC3EB89B2AF519959F33B17FCD71D4BEE8489FB76782AB2FD7567BFFDA63494F924C7B6E0B308E0BC10A0AA7257CAF398A7E44420191C4C6930FC4EE77805968027F2A12502BEAFAABDFC679F606CD3B7CDB5C7E6A637BEE270A2143A1E7A4D87D0352C4238F4DFCF03E2A9F361AC47D1C9D9E48D020E3A04D19F08608B1E0E2F72D183AC8A54968ECB0DF2424B55749C2693650436C0A2CA30A73D0E14F193CCC78C3C0D7595D2E8FD6508BCD42ED0078B6EA2A350DFC16547639752A1873DA349C780B68913FA1D43A7688ABF1D6E44173845E576B6E9CA03DB91659728FABC834B3FD14EA283903AEF91869976BAC07A2F419783BB7C15A73F5D6E110BBEFAF39A8216CAC1E6A1F6FAF96AB54EAEB75E29A5CEC6B3E483436D52B137133552B1FCFDBF98B2AF26081AA7931E25D70AC882E390FDC6B800698E196A20AD22F3E113F39AF5F1D63D15CF4183C297A5A139BF10F617305A2A9AC403186112B42EDDD62896F10E8AF9346AE2256D72EFFD88922D04E64DCEE4E1B09C2BA6BCFFB5EFBE8D039C1754D35F8D629E270E8D3D4CE32E0569C5F921CB5CC5126A9BD5A38B5FEB1D36545B80BB6F8A03382EE318D345ADBD6B0A0CC46A74BA9B590B9952808A5A8533B36FF574B5C0FA30547F37206CF77E786786EFD036FCA3124B0DA3DA8D558B248E1D6FBC838C9008915A386D1D71BEA031DB1C69D165DD5A14805080C6EC9FFC35E1E2BF62B6D55B5BAC5F0BE059730E5D8C581579C8DF5DF9F5EE3FDB65A76029412EE2C824989E52340844400D92643F7F6AD163CBB17BC1DA734696198E0391FBF936AC41AA0058F134B97DF1BE960F2E23288D99370BF43C95D956723447A1A5EF766B8993734E6E9763430A4BDA67FF347DD06C2500C8104CB6A44254BDF46C2885DA3FFC4577AD0FA98D77C3E0C58E6017AA826429857C4CA642ECE3703890CB0DBA08B5340B6585D09AD79CA32377F90FC41A9E67071B6E65E0B691E1D850C10B905CBF366E5D3C3BF9605A2F739D2BACCD6A0F7340145AC9F3E320E8F57F95088487DDED6D0E0C8EBF3DBEE81EE46E5D0A7DEC +MD = DBB47C194D6C2C2FF6C639AC1F3BE7AD636AA3418378DB18D8C259A3A922F26A +Len = 17861 +Msg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en = 17924 +Msg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en = 17987 +Msg = 203A990FD5863BD0EE9519B7194699581B0C029602D1562BF6ACE46A4FDBBD7BE74D7FDEDD16B4887A260116F0786E371B09460F583D2917846BA1233A21F8390F01F0F37617ED2658845D5D65A6956B39A34909EF07377FA15E5D4C7F8F8CC6F623FCA6DAB6558BFFB17F15E62D7639AAFCDA2D9ADA6D2D7CAF26F19A6A204D29F8A3D4521A425767AFE0183D761F5C11B85592D9797E82464C6C0B0D1F58DF417FA5D196576D4C400ECD5926B01513E74059EDAA39808DB397F27E8A7064277915561AA167DEE3AB20F3EDB7C5D21FA684EA1C687CC15D90ADBC08C87B150368D97E4CCB8D82D9BA8EE6E8983052381414DE151BDEB0389D352D5D6806D77F6A75D5A28D7202CCA1F2AD0D6722A60516856DA3AAB4C8278919B6DC45CB120814971B7976724686C883CFB1B072D8EA841FF7B29674AE4686FAF4C75033E73F1F90D96C09DC015E549BECDFFF88EBB8645836B983F7CE8EF56ECEB419695F76B84695EE3F09FF0D5575592289787FBC64F190E0EF5063F8A7167E92D689080F80E709A1EFAFDAC93DBABCC0FD4941E0E91368BDE57292BF32DEBEC0B9FCF7B8FB256D614D08D4A2A5549E34B3E2F527432E96A5257AE187D4B66D64DDE2E0E34523F59FA74A5EC885261D7672D152E989BCB8B116060651AF561ACC619F062ACEC8F0270BB4BD3C96E63479294510C2EF924A6BF1658879F323FE9022DA06EFC086BD8F328BDB5EA1ABDA84458F5606909971E8BECC7BB59474D1654EBF85B2C2DEE80B8B67626A11A636FAEDB2444ACF9E25B544CBC04F48DBA7E39012B63B581012A8457BCBD80A751E22A04D2618B7AC04AAB6A9FF3DDB6189574FC301EB9284A67AE79EC64A4D22D9AAF2CDA673540C4D31B68AD3A32AFAE4D3A568EE974B5588B2E7EF93C053D436BC47A67CF73E9F3CAAF2C837A59F8F217FC2DCB3875396D883E747B0F4114D5908B87D60866C3FD4665C5ACA01FA72D9789EBC9731066962A442364219029316BA367816ACA2363DA6432D1EEA7EEAB875D6BCDA3D919C08083073C3FEB95F2CCEBF6CD74CF5309030FA313F4C76472D649320A4F7964083E7C535841344F7342AA4EABB546ACB0D99F8B6FF580D9218BFD174C91D543A63D079A01E712A6E1D6EDBEE3BF60733115C6DC7BCB36B4270B82A4091F9615314A3299AC39310ECA67413C6C7532FB985182F2103DD75079971EE7BC6CE26781146BA4814FD9EDBA7F90832506C840326841190134D4F24099833B246F3D1185280F5E6488489DA9FC3F283568B3E75992871D3CF85745B490416E57C2A87D0CFD7A1E316274456863864322C8501FEEB4D072F707E75A3E1222B9E1306D697185696367CA2D81E04004407F95CC9A5BD2C38E65C9FA0A492AC1860251FA8808318649758EAD4B6219ACD89ABCADEDE00575654E11A069CBADD20F8EFC50DE92CAE2508F80EDB8A186A0AB10375B9A271A48DDAEA7D397CDA6438F99718257866155B65E26303FE640C2C3DA8FF8B99974BA233A0CD7BC8196349128965DA9EBADB97E819435E23DE10576574FD1816F39B7B79C0839C3C235886C59265B0BC02F0DA1D7CDD1896A304A4501A2DB9EEF356471402E7024937C7BAFBE925A8E8B434A62884FF49AB30518FC337ABE15CEC4860EA11A795244671E62FB1EFD5771B5CE6A169B7D9BBCD7515D352053C76C2F37388BAD54EC9395C61EA51521EE80090125FD26BDFD8E0B66EAAA1D8B9F04B1AAAE2A947C3D9ABF155D728D99DF85376988924E112F8D94687D2D8A1F9ED9FB13F8A901169C4FAABA6567A7DCF800D664616FF5A2C850EC004CF1A59ABBD7447C55CC21471E6313A2B8B2E4D498F1559182385E7096FF881D746047C2AFCD2E23AA4706ED8ABBBC27D080A1D014B1F89EB370249582D971C2CF0BB5C8DD90FFB18266DFF5DDAD2A4D79F1AE55608BB442F90A7E1EE696E058D5B13101E8F856660FA26EB039B1F36216F2545E293A5217348D361B15226669636F9F276CA44CBFF883CA759A0A724B6740F414E0F8ED3D0E44CFE646302FE4DE9F51748187C45E096FC0A6009E7C2F304A85358D6FFD973863DFD60CB55B2361A634AF2984FB21FF009B493E7B4700672372470D4C9C91113B513377C5F134C768BBE02ACFCDBC95B6BB55E7C0FF93628A1977AB833C2D7088A82896A8AE73C9092E17DF944A00C1643B7E74180BF114C21CECD5764AB1AF023F1F17DDC0B8C8C7EA1565EF5DD3AF8F7A44B722269FDA7FF9D585C1E222FDAF7256A0A96EB29EA8FD59DE63AAC02C0343A51566982BC4D62BA8481A1B74D8A329986D5871E5F1B9647CF392183C55964CECDA71B7C0CEF1C880A771F398C1DD721B15C5DCA7F62C7A9C982229195D583F6F7DCD69CC050CFBF1ED89C9B5D13DD17469CED24B94F122E598947012BA36BF4568ABCFBCEA789EE2D62ECA91AA82F22BD395E8250D44265B4BCED2DA49D6FAF223CABB3427E1783FCA9C9E40432357970A23C27F787637FBE33BAA01F0C1144BCDC81F09430E73B0C08069E5C2FC1A89F5DDA245093156D745B428CE920E788CBD68849E1FBADE8F7391201B2830DD057C9006BD8CD006B399A98C35C41F5EC47F7D48F1D9E05F7F8D7F1B31B34E830B175984722195CEA0307881894D916179D0BECB5942CFFED99987178D3BE1F4DB74A9529C36017D2ABF29A51195D05BFB4E641FC9B86439DD1C082E8562B74E15184C1E7D3A4BCE151F6C73A484DCBB76F7A603089E936C318323FE77FF8A24AC252929971771394C35CE41A36C8F8960F0667150E9DB91CA5BB3551C53619E1E15E1B2E3C2739B9688E6AEE09196F67398E8D1282219CDD3C3360EF16A562BD2ED29D879E96EA2E4A388F78372DB889DD6A9FAD6CEB053C2D2B3ADB857193F9ECC09018A5547BE73DBAF671C271264E6676AF096EA00FD7F4980785D3EE2B29B458B95EAD2CA284C8DD5D8E5729C60BCFB20E1A238E74BA57E29D1246085DEDC7B7FB9B1BD37CA6B2DD44737A89862CCB2761D4B224E5EA2298E119D6373961CF7D261709833777037DD3700489D2E59D7E93FBEAD57C9F94E10A4837DCE933BD16FBF60CADBC29A055F4444E30D1DF6189BBB0181674ED196DC3CAC40BC5A0EDB74A2548C4A894C17BCA585205A06D6F8B14EEE370F0B86C2F29F5E7A02DCDC0 +MD = 8CB23EDBBBC1CCF06137C571009D2567E2CEE154858C267B8F4F5B665B476806 +Len = 18050 +Msg = 2307A19FE608AF4496DAA431ABCECE34E39367ACF7F7A0829E380DE48112E34C4B6C89937EFB557B67B55B0A390B1DC766F5BE1A6A1F2F6D7EFDA50B18F72F9C9BC96AEA41EAE69B37345C2003D2359E258A7B681E34DE6842899D7A73149529338EDC4C98D72A1C39FBE39DEAF657BEA9E3553AA83EE91CD6B840E9DDA46C3A9208FA916BA82EF9B27D96EE38DABB0D00AD83E4A59ED301194C5A911269FA3E87A1EC80F3D211EF90559F3178145A86F7D870E5FF490AFAE99D24629CBCE8A4510DF2F1BE840B7D25AF00B9656737D2FDA497333A4D3B88F08A99C1C1F2DB2F2E5FD5E03D11E488E12B44074B5D93662292A03EC9FA263C5C08B63C71DB9FBEE1341BD82996681E5094D269C1724FB43EFC9380E4A94DCFCFCD41941559243E10E23C1FF3814378B04A545D9165CD338BBC95A0AC454FE303877F279015D5E3A33C7F48CE073808FA719D17D85FCE28BE19BAA9A38255EDC397C00248AC502C956913EBABF3551FA28832A9F325A4128A3DA4212BB35148B7872C8CE4E248E1C1ACABE43D6FBD79038313999A72605656FDEE792482116FEC2BB31EFFAD3A551A6FA64C324C1874C0F1923E453B6737EB5EBA8E686174719E33356B192DB9AFE19D4A5E19AD7119DAB3E5960FC29444FB6A44B4674E0764BCE518C4635E3F3E89BCC5100C7999BE894AF51F9EF737F6C535C25CE014E4E15D2EB217BA37CC1FEDBF1BF6C78262198961F6E7D314A88EF05DDCDCC04D2A704BA6997EAD32B945CDDF38E2793CFD03836CB201A69906CC3B1B70EF6881051C4A61686255A8C758FE5540D3FC4E898EA697569CC025C81A956D6B0C8FB8137652E312C6005FCE3714EFF92281F3334A93C39C3E6AA4A64B310AA995A77EF35F3FB4717571E6BBA2C1A512B55D0B56E8CF5194594B853EAEDD7EA2BDE9AE2EDFC2606CD453D3FBD49BE051DA268266039980BEC91C017C7C0DCDC745037549D50B1EE2E7C46302BB24D86B7FEC1BF1CD556813143B99358F017EC126B52AD0270E604E7A974A82B9766947A8F1CA3B1E863D97F522B75239409A8F16FD20D916DC09DAB4DDE8C4C8144BA72443C544B4A4D026E464A3C7F6E65A25AFEC10AFE62D0DBC93AA7DEFBDF71F57F3BEFEEEC5918C1C31EFC2E4D7CCDB0A6C2D791683D99C6544D6DF8DC3630D348CFBB2262EFD89541262EBC3571E65CEE54B97239377995C66E9F01C7B168D87CB161FE5EE99EB759432FC71A5B006D11BE42707E0D3B8227381FA4CDF81297E154482C0EC332096881EC178EB44C36A5B2FDDAE5BC918F07E7E30E095C1359B4CE5637EC4814CF2503C1E11F543704ADFB7F9ADA87CEDA6E678675745F11E05A2B1A1D466CA2AF1C23CA8B8BDEB1FEB73F364763653C379FFBB247FAD8A7AC444842608A8E6E08952DAFFFC66021833918D011C83CC86CC448E6C7F3489FD32912926075984C2D4DD227078C5AC1512729E78D0E16E7A668F5BC77033956FD72AC757B5AC5CEEA0BB7304E59C3447A00685D121D2EA8432E2ACA10B758C12AD9C4FFC9CC00EEC0E5432D8A68FB38EA61567F88515CCB9ADAFDF94D911F37C06C0D8AE5BC08769D28C5DE5DECD5A63DC25487E27A601917ED0BB2F7827973A24FE0F1013B5FAA62F8E8C1F5AE1DB9D37462A416897B595CB8625D45CDC7B1DB809A7CF295E39CD63DA48210D0284E679CB30EC04BAA2540AB7A3BE6979691EFC668C8A546B900E512C4B373E9CBDAA2D41FF01ABF833539DE344476E8D6F05D584894EF463A33E6A120A8CBD3A2707156D4B6487BB21E027D1170F16451E1751A90E839B7B8F8B7F80C2868245DBE288862CF247110019593F9743EBEC82ADEA7F3184E596F2457B223B3722FF2A0AE0D2B076BC4438BA3F73C7EC1FF1C2D103CCE33AE644CAA66CF59B6C60B38C882CC3D2AF2A9343D1C208D7AB35B87F9EDC74F45754B42502378692E81ACB2C357E130663A6DEEBD38374D4665589364B851D21C110153EDCB2BD6A21AE6009195E8AA0364BFB2EAC47BE8B048FA104920318A40ACFFD07A8F445ECF4ADBD778362264D037D493F2BE8D60D998AD1A0F0C8B1A6FC86911691B489BDF543D31F3EE42983406C0979A761FE759840F11BFAC59510E84C2B829D152040C9B8FF3C38D2A111D431EB0C77657134996507F24A7856256731C65CE89697752F9C6BD562D5926B82831C384987AA5592C1B14E92C551D2AF6355A792364B1F091FA9CC349770FAE924FD0286864E4FA7C1756D99E17F2E31350D64A1721EDC1792FBC044480C5A0E097F793E52630A53B110717102A38A78F470B8CA4BDDA18D78AF598928CD131143A342C4F154C35BEC215B48504AC01DCE3E0DF837A6D962BA44FC8EA65175ED50F9C2A089733AF9D349AF7C9139933AF548434C5504115BCB0609D6E145B22FA3A26489155A7DB362D2827F894C76102CC26AA87AAFD61EAF26008B88C4B63667309DE319A128F845C7B06717617BC052F9771DF4F9C8E51DE6F62B4C4A46737ACA22EA181F280F8DCD9A725467003BD19335E4AC43D7D65080ADCC294299919DCBF0117494D827E6370E9E2F96E3763AE1CC4E0402D0857EF6D84AF992C9F718B4B755A45F54E05206F29831CC645A557EAE032EB986117ED3662242CB42ACE424C1D73923B5C6BC801BBE3CB9538578A084C015C7E4380525483E50DC4C5270C2F2B111B1EB68CCA289C769877F8D54FA85EFD1EAA976A07E0F141A0FCDBDB75823BEB371BA26697AF9CFD8C0CCFDB4C039EE92EF9999F7A2B07D12600FDC90ED4DAF8511F0D687962E3CEC57058C3064E8C6B3FF6E8A62CFE675BA6AA0E846D90B8C06F6B710D788FB6434C9B787FB257703E5127BA5DD4C824398BAC06C2D7E216994895DAF185B576073AB402A3613FB8C8D8704691AA62227A22C6290E3E8BF1A56C38AFB038A9FF29B42AA1B1E878FB6723F187469C03129739EA54FAB45F2A924944974EFC8E23DACC888BD913349EDA879F97763387543FE3E0FC163863424D8E4F3073B2317347EE84BB30D30A0D687664F3B202ACC7733A856BF1AFE382AB946F3110FABBF88FFAA8FDDD948179AD7325EBFE7153B22877AE06777459F4FBE3C9E8B813725BA3DE1C3CD9ED234AE2620427D14116EB9B674991171B8B715B99A3F34655FF4C04131B3B5197D37EB75B56518B24800 +MD = A632C7ED930D20F3E00A479E9340C1BF6DA937277A116B459DBE9726F8334615 +Len = 18113 +Msg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en = 18176 +Msg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en = 18239 +Msg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en = 18302 +Msg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en = 18365 +Msg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en = 18428 +Msg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en = 18491 +Msg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en = 18554 +Msg = D17590525F80AFA357E56A6EE25E9F813069901FAC38527A17C26491215D0A9B7446525069D8418A0349FE7163169AD93C8D727F2602C581D3302F220A4E98D83D69AD188BC3425A15FFA930945F16CCD1E7AC2E928BACCC43AAB143A2565A747F81E4B00106FCAA2A24FD7564EB714DB3A69BE228D6FDBB34DD8484C306F98F78833679DF0E706768B7370EB3C961F59E8ABF15F4B4F366A1B9A66F12301D291CBBF676F6569A49A9A6D86219B860ACE366967FF7CAB89495ADB4F19FB54CD9409B5C40AE711B45E915477839FB2BCCF05A04EEA8D437DBAC4236951283CBD41E9A55C5EF5EAEBC4F183CB20AD443D8AAB6DC4817CAB8968929229A0EDD605B76B0E302CD157F55832E4318AE3D4039674DD92B2EB227ECF4AE22D211EA63F6CACCBF0145DE5FB15BFC6CF93880675DA69B96F23D7BFBF763F2753AD06CA188187D07EB9A13C0586EB512BA9BAEEED4D25361DAEA297398DB35DBF802374B61CF380419575B0A234569CA4B59AFC44ECBA24EC66758441F1827C9F2949D7CD5994EE855606C7762BF30C1745F925D84BB4A1CDAF8DCFC5A3D36FC3226FB7BC4594566CE8F40A5B98BF2155D5BB6B35F0B5CC7C0994E32C0B61E5EB1DEFCF0357C48C225B64568C6955590E1FCAC56C8FF476F74ECC111FC1E5B40B2F50682987EE3C4C1E0579C9965B2F95EB494AB4A3D5679836FEDAAEDAE5977CD1882F5053689D86229BB84F6937E6C175AAB8F882B2CCDB1574A4583874F075BB68BBB9F6A4CC07256D69E95FBC6001C4724BB316870E907238E0809F4877C2A1A6E4C2D8EEAE2230581C030B872848219A8B093443B945798796981B29A8EA4211E1455D394893F95CD44834800B541EFE6A3E524612B805185DBBA278F66C8DBBE1778758F3C743DB262D13F4C90F5387AB3806F3228374A2415D088ECE8A24910A8DA41A30BA696942D3122098244782EB8E34F270363B9DFCBFFD62218EBE75FE003D4217968B546A4B3D5F00D8D231CFB5AB322BCFF83C5A804CEDD9925B068848C96F60F054D269BE2A18DF4D12AC24887F2F116957B7DCFCDF8CEC32ACD2753555657B7C2EF830EEBE9CEA91A987D15A1A0B4ECC96E721CBC2205BF82A228919C39373DE7C5D24968BFFA27DC2D9B4B39BD26BA38A1E5B30715AF7D689667DC2FA02172366017541882B1BAD893CF769B858650F4AB4405A6FA20C726122C1D0FFA0EFF39CCC059918DA3710428D993B8EA03B116123879AFC976CAB40A000FE4EE3DD55DA959D46B14BE1D2987547888A706913988BC769D11433D1B1DEECAA0D43A0A64D0298ED5B55481AF49B79ED6C810C19084107DBB28CC4BFFB2776DB2BBE2A32CBE3624BBAC6685A00B259730019FA07B49359B61FAEE737DE77DA7E9964824D557C4851CA90B5B67EDEE1D9FE9AF270F79F61BFD7772FF903E792696FE7224027D7D49A1C817F55DD8AF25206E8928C8193BE66A7A96F0C72E6B438E7895C89864CD7B4F2304A6B99E174425C637683FD34BF68B596804CE254A3E39BCF1B7A5DE56E2C2C7DBF2B7D343F0286A4ACBD2CB20404099FBE202A1C1C50F10764B18EB0E9D07A676DD93D63C4C06B565D2469925532191D4F35C708AD1E592CD2DCA0647241840A867133688B95AFC144EF2B0C41713EAEA8F16F64160F97A31683264BCAB1D9DD74CFFD157982297BBA7F86D6485B9D3DD5B59FB364BBF8F2B34897083924E2067FBC6B527BF748CD432339B3C79601F89CC0D9B1C60C011AEE99CE8B2260D911155881621FF520B07C6790FD8FB3FF387CE9BD1854C6668333B97A202A548EC65A6A5B196EF455004163ADD874971BE1947CEC863A723BB7195EBAAA3209333B0DA815BD11E10455A80C32FAA467DCE5A06D06D56A3391ED68804086A165CC2AC591FE52357910D29739B177F203D30AD28516EB8132B1894DDB052F01438604ADEBD8DD5221409A7CEC5A2EF435FAABE956A9AD93B1388460879D8B19FF13CFFF16D2B7EC4ABB7B030B7E72BD76EA6BEE290420BF9659226289C66ECE4B5A6D467907DF7D51E20370C6F56A9C4A9D09F6569F0730F31095B3D45E71DB114BFAC587B3817EEF364D82608288BD36596526888BD7169A979E7B90D7BA16E0A20BA4B21231F7E3B19C5E279D3CBBDABE86E5A9E7EB3E23DD7676F593725C01FB386FE54DE54D2B53F19F784623DDAE31F901AA66834B73125C4ADB8606853411B8FB90304E40412F44D190C041503342161D219B71C4E59243549935FD66C9FCEB1BD80F214C3549AFB3743DD10BC1C43E8B65DA39821B024BA2B2510D31516D5D45F73EE0AEDA561A4FAB7F9A60B72AF5D81A5C5E5A1CE3508A6556809B5805425D59C400A5CCE396F0F35BFC18BBDF9CC23EAD19216547A952270D9CB3F6D1A19FDA1C272BF1917F3FA983689D2E83C8B2ABE0D25E1785662680BC4DE05D749536E55218A819D0799BA84951BD337412B5F60B9EFF8785007153E549B07480CB1AF710AB71B2F625941E02E3EB0F7B4A0E8F805FDAE8CDDBD57568E0644C908262B40C1684F2294C95F7C4AD9832676BBF41ED1F66336CBF22813D0F41A1CB9F24E013028011BB2EE903C3B927D90F181C178B4E3B89433ED5604FD335A0726B20EB46A3584CDCF549F22954CB1017585C125134D547DA95E1C5A3BA2D79BE4DFEB766CD415E62E8654C0202F40141F86AFB6008A4228A9A5103DEE2A882992B33DA4C3031974C157E2458CA64AF9155F4F81B66C63F6F8830FEB305A1812609CF9608F88BEA639B1C34A996DB55AF7857888878C0F2DFFAE84E3D97AA14579B6C09CF836F7C5059509CFE1B573B582145A089A555DB7B1D4BECD1A4DD255DCDCB81319ECF48C8CC21E498498E0837A6632F682E666B47EC69103777F949FF51412E3D52AC6EDC1B2232948060B3E4E90B9D9EA632AED2AF1A6577F551F0B6048F70D0B3CBD580FE09FE523FC634EB21AF449960A1621ABF5374A74CAAB315A070F995ED0DD137A9F8ECC20A2D33E5B139BA5E8066B16C14D67346CC11916AF7BE026D558B8540F973B18008D776F637959D3E3861A5C3E4BF524AC5B3FC4D9A8CDCC3E34979798ABD1D0392340B12E58310D8EF49F221C52872355B578DDD0D668D0CD943B09432B1B47A43AA4D88832B390FC2A61CC5121909B257D25B3EE6E46C3F32C9A54AD3B711CAC23E7965AA65712C667283785B6A7C46160D89C5E8A3FB92B8F243AB16AD98BE48EE05F1D77F80D460F26F0F7815F80D6AB2F25D0C23151FD808200 +MD = A8E69974CDD62C652B67F89A7C96BC0954C9F024CF09F724665CDD903B59DC2E +Len = 18617 +Msg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en = 18680 +Msg = F5080D4C59E804BF8F34B334CABBCC7D32011BDE3677F4B9069416AC204114CD9DA7A0ED0F4B4D8344416336EEC15553EF526B6DEC267B1242657DD0B508AF81FECF9CFF9C82A6A7A9539814DD7E097615EF15373836B5D2F765CC8D5F82E90449F13AA741D5EE2FE63898E55ACD85116846807606FE1E2E29F98F9940B067D0D1DF01F080211B2EE4B0A30803782A7BC2EAFDC5EBDBA91EB05F7D7DC8E34BF6D44FEC05824F53418F235FB64E899EE147BCB403C8855E94AF378D182D79C3EAF977CB4E9D4A16D990A6C388CEB567B97785E6F2BC6745102B99AE765E960B6B32BAF01E2379CD6ECB74D3E1A56552F5976DFE5C742BC92BE596CA742FFC3D0FA032AC29F9F7C1A5C43BCCA62DF7D9DE35D0C7C179DB2E1AA255CEDCCA55064C2049FEE1AF2CE5EF696ED4BC46B7C55BDD51F2D44C8713FB2475C0B85246AC0103CC3863B7EB026AE076A600313F6FB40A4DF62A2AF81B7E917951EA870ECB31B3401928B5046D9A1E62D14B30FDEBAF262868517318FE17EC3C0D52524F44120ED8ED3BA70C643300CD0BC70DA72C964A88F52C3A91EC20BFEB5CAEFCD4D9C7685D8407476B5F34676C5EBD1E88A6CFF1C625322F8CD59B9ED60CEFB21F9491B95E72791F7AC7EAA3C16159FE9DF7A989ADD6C2282C47585E11397EDA9F47DF2B40166E03BCDD6186B46C6835118268DDBEF19A28BBADE1BDE0228FFD7E8B3C3C598D89E24B8CDEE79C940254DE26CC6814BA2722E42F7571600B7325E1FF300251D52A895B8CCBD049B2953B8D231445F68F7C26EC25A4B8695C8AC116F736BE939EDD762C9B4743E463C9B9B2F88E0BC0CE78781CDDC3BCA825ACD463C7CAC2AA6C430BBE820EA94AF9A40B1B5C006E9641A2FFA6E427379E1AD49C81B98320B3431FF0030DC683D61026438BC6A6D34B2C73704D9F62EAEB13ABB3E4B0562B4E0482CD6B2D7AEBC0367EA29A88F4A76F3D76FA1197E1DCA92C8216C84C1AF9B8C78C9E3A7799A4A79A783033B0F5547E8E75E69CF3615AB04EF989FE1A463B1672C571D50AB56972896E8A50C242F22C7F6E27CA4CA793F627E79608680F5421B28BDD2589F05E65430DF774EE873FCD1234064F7A33CF5A1FA4E368137FF9C1597F1FA0FA36493F20538077669EADFD3B06F788C912C715FB5D334DB6BED133A8FDC40F5496E66AD63881F0BA3727416715865253DC5290327B515BF68DA188DD5B4B0EAC7CA712CAFA8FCAE0C5503FE58A219182F1C30DA6D0C19CFEE897B7D837C97996A35F4CA8CF0537A01D17E7DE0CC9C129E4DA0ADAF1FDA85030DF9127BE628263B0624F372C47C3AC87EB945A57F5C732BEEE81A7403001798992F3DC944114FF3D54C4666AC5AC8C98D0D5596CBDEB420665F5EDAAE747D54CF7EDD37B162E372249D135938CF17D174D12D88279CB4C32BD6F018C766DA6983D4EA51D6BD8FF0A9B34E9A93BBDA70CF1B4B867D60A74811FD98D52FAA559B52C755CB70A76C94BD19654CAE7017CCD70222BF08C5D7AD1F5E4E6344FDB3ABE703452C29A696F39F9826ED8BC510A4A148E5BF8A5DBE6B82D7220164F08011C05AC5159D52CE9D45D758B645BBB248C2D341DBEFA1F8602C5D458A64F38F3B04DB39089807B6A10E1BB52770B92CE72E2D3BB0C2241CDED35054B84558D1CC099EF7B2296951951D5B6A22F93BF962AC5EF8FB55EC6CC2B316428EDF12078ED1B66D525D022819CBD489E1BEDB02FFBD507D55F9B5D4E22F6396EA233453754688D20151A09C70044B8A5A9AC033C3C3B847AD833D5C05B33407666EE82F9581DF9034EE15A9CA67D52F1D9B634B84C1B8BA9E515F1F060A5AC5CBAE2DE75F94E112F7198E239DF08D3103F065627438995026DF511C6E5BFDEEE5667D511D4181850C7C5D179107C1B86D24D5532A88A4149A2810DCAE73731B0E1247281A6FD31613DF6891B4C17B7A6A9AD9B77468254B93F85958AA0F01CEFC10B25169DC46E035D3F24557B4BF0E7D60174219108D916FFDC55E25BFFD9809EFD058E12C14F39C69D8FB73D3EC6458F47F2F8DB901BA76C86550B11B54D0641D4DB3EB000057DD00F2E511FB7A47E959A4402A3AC5462234B40B184020FCF7A0396C4D00A987C8741A4537BC17102A5C42AFEAB9F71EA66ED4CBC7B5EE682FF04F56F4BA1EA0BB326C4089930F9E3F3FFA3E06637CCE32113881A06CC3A13837448145C2BD01307A580FDBC385D8F46FB92FFEDBC8918D269DD1871164D4B3E2023441EC8B99C82A5F09821CDDF6B38C9ACC3BF3A38D5628016159588C33EAA29D9463A537C000A16AD8C177DC4CF716E625F46FC4CA8C19FBD8EF320F1D680639195C8B195B0A02738E0665F4190D6287E589CD6DD45B9E8CC23B08E1681BFC6F66B88DE6B091E825EA4BBFBD697E10BC407570AE4F2A3EBE569554639C2B8E051656CC30C837F5A92260EAD1D552B45801B6D28134166796C87F900225CFDC3CC49D72DFBC18D8D95B1E160ED3CAFD5C3467D48AFF87402CBCB1E1420E3FCB588AA19C8F42753B59DB6FB6A9FDBA127CA806DBA7DD97F2488FC2E438EEF57A4CC85B88DCFDE76AE1FF61225A1CA8BF4A14F729950322EA681B16D6492902506702DC8F348E4D3AE7FB55FAC1231FDE82091B34F1791B6AE37587B10325F6FF5E23B855845B86EAE90785B9D10D90A16644D01BB626F343B908A9591F4069B21822CA4ECF985C1E710475F33DF9AF4764CFB0FFE649063775338F15BEA7CFF29F164678160960A80ED148C9B7FAA58E9139911D3DD9536F69646F718F083DC9029D6294FC4C607688AA75AF350AC2C0B001A157D023D73D86ED8133809FCB9592D12089CBD7A1BB6BBA882FE227C09A53FF088907CB4BC2FB4B7F62D41D3D397C4FE0AD12BB3964370E21712951C679814D506E738C0201E42181D231136A435AE0397B61CCBC5E8BBEBF8EA77C8BC48BD6211F29248F9D498D818E2B544D28A5E60BA727F32EF4BA2707962230C900076FB764D0ED5CE078C9DB14DE894BBB836C6DE9E83202AE89F9A8D8CB0341E1C81B5FA8B16731B8E231E969C0F1EF95336D4E73EAD6DA23DE3AD1EB608ACCE4D4D93996DD76EC1F5F2C576F6B3B76E07BD8A810FF5D88B00FFE48C42700B61CC499336E7FB57AD72FF44FC631C7222C9A3D1ABF6E77B5ED7FE2F7228FED6C849BF7142C4103989A80F7C15642AE61650CDCA7E854EB25E9E72F4C3E3768E6CCC8BFD556B56D3507EDDE9E5C331DDEA75568B07813D20E8F4C9547838ED28448F2E67158ACF0C00B131473847816C5E2DC215 +MD = 6C8723DA27CD98E20F2583D01868051EF2DAFA645901F82C74D5320EAFC18AAC +Len = 18743 +Msg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en = 18806 +Msg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en = 18869 +Msg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en = 18932 +Msg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en = 18995 +Msg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en = 19058 +Msg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en = 19121 +Msg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en = 19184 +Msg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en = 19247 +Msg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en = 19310 +Msg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en = 19373 +Msg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en = 19436 +Msg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en = 19499 +Msg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en = 19562 +Msg = AD39EE24007E1413B9D92BEB444FDC7500ECC9E7753A1F563359B9BD6F77AAF011B0B69304D4CE27E4D2516566F5CA6AE3F0CA11CEE72F88D42EF7E3531D036B009B608E8013BE9D6FCD65296E0D115A6A1A4F0B16BB47D13780010DF627905E1CABB23B99B83C30D2C4BDCE362BAAF6B176BA0B4BCA425618E7D319831C34DB818E6210225DA5DABC8E0ECF3E2418687A83DAB34CF7C5DCDFE2834427C0081D065C3E661DE89E18C43883D0EE345542A4B9B58F4297320409302FDA21DF5C91FA5ED74ABF68E32FA16960C22E3CEBA25C38EE11025D3C7189DA711D0F05A7D31CE0C884FC37F8AEC4727D3C9DD8039569E54EBCF9BAC6D1E139D578EBA94C6CD3AC1482B8FFF7FC73009984F573EDA12F9AFF4895567BFDBF769D8FB2FC3A079C935597F11F3803ADC751D3E213A4121499BDB3AC7B37D5D6CD92E3BAD9B4B94B679E52381A844404A251316CB2A60AFE11CE02B6E6D01BF8DB4820FB2284B1ADD2519AE65F83A34F1C0548E9AF808E6767E219AC9E22B0E392A74E41EC21C59D25C52E9524A32E7183982571227CFB7651FAC6C552D111E7EFF9C40D275017C57149FEEA6E7D85B46C29245784B2F484606ACBA7D87BE37D0DEA44B429C81EA84C426DDF16DF124FF2E4F1528BF363E6BFC166BD3D655E686EF2CFBADBEA79AFE0501814290E387B433E6659CA8351A3A2CC75F2BAA13A2BE62FB1E2C0B3AD75E874E11CC71B4F3E631E3B77868FDBB608A251973BED3A688E80BD089F30064A5E677DD9629F2651C70F6AC05C48DAD2616BAA91946D7D46136F2488DE79AF122A1034261ABD69DC33A0E332FA6C922BEED7D2D5101526427167CE9541C84EE5EE73149EC7A95829C623915D6005940CBBB30EA0AD321D1069E5D4BD03A0DF1C9D3EC97DB77D3C1E0873BC19E8A90D01979FAD78D98C5CCB756EDB87B3FB97AACD300DEE5E411AC56D9A29C2CDC7B85B6DA05EFD3E4CAA4A7AE3F265B6ED36EAD160C41F4134FCBD4FFC291137A8F4F0F3B1E5695AB4E1D023CE952FD1B1ABE3CD32F9AA860131109C03197D2D2CF4B71FB2B496FCF283656B7C19CE68E78146F8189C6ADA102E9DD35E295CF33BDC8BC3F2636F699B0A2DA67D556DEFE619EDBC62C597C54AF2325511F6FC4BF6E13BAD3C0F21A0DB8461EF6FAC40F4C558CB7260B62BB579B65B4850D8251BD2EA50DDB9E2ED8E2CEB387E404802065CA0C83E21592EF99765A82DADD30FF0A53873CED2067ECB9F0DA5C7D055A2B409CAAB1FE67441C6D1431EA9194C34242481FE86DAD5B579093F587B1E8A00D2A07B4CFA4E0BFC7EED2BF1BD9F5C8CBE5F9AE5DF41287A3104DD90AFD2435305ED5A916AF860D2F9A78FAF9FD4A3A6D77BF1E5C933E54F3D832A196BE05F222F32DD5F339EEAD7DD404CD47B7528FD84BB2E55DDBF552480078F67329610473288DF8B656AAA6185F312E52A4F64943ED86C36EF68561544F589F30909BA6C9CF0550301888389232FA597D8A62C2DB21C6BECFDA2871B00251071F22DFC293D95F40377427310C72DABE1B72DBD83EB11D3F94BF72162BE7DE50132179DEF4662D49D4BFE97BBC0549179E1BD92365EE7DF135B7484DDDD1CB88C8AF7DA0B94FF5D778C47ED7129098732F8F0DFB6522B66BF61B2E8751CD03F6DE20C47B3DC62792B6D8426340E56D1A563307BD01F45C34F1A5D82E676013ADAE3432944D06FA8195DC153C766E505B90E705EFF4583D9232DCD58FFD1887A7400C2CBFE0A6EF72CF4DB2629EF390B4D6428405342249E828EE21D8637C8C949CBE00C67D5232B29B67AA9BD9728D9A50A306514130E4C5DF5AAE641C3E8D68B95ADEF8D4BD44BEBEFAF91BCBC29F4757B62E0F343E5AD05C11AB08E89AA864D214A5DD2BDEF04234130F3DD732FA7B4DFD48BA13A93D6E1043C524DAB4182EAA6D222B439379B892B4CCF038C8570A9D33B20AF26CEEBD0E8CFB6179A3FAAB45DBF40E25631424E011442407C0AC6025B585A638C32CA3167F9F014F4A50A195A9F9A0050BF1F3A2A5259B832CE979388F991ABC2D47388D47971E3862FA03B31F019EB1D983AF7BAA7A5755DEAE869838F265A57CA76D5CEC2DA7617119817B114EDB622F27704573B67D11A69C46133D12484253E4184DA0CB1D7CB999BC47B7ACD903210066E48C662AD2FBDBDE849C66DD33741543873B4FB4E35E4B61308764A4F62FB169FEFDF7708A489BEA195E0F9B483CC9B1532563F98DC27695E7531489762D01E02517C70968B7158702C1745419EA58A4E50D9FF2EE013E2DCA3B34E483DB9B50114B63313CBD2C529FF6FF1475706841B5A02827C938C39B51035D367D35885BC3022978A59BFCE4BA8455E75DE98E0523546BD0344310A6D027C4F0FA57F7BF5A91A3C8CF9CD999CC20D944FBCFD36DFB141A172F91CFB67CF15C4EA695DB869AB9F93D71C6509B80BA533CFF0230A7BA7CBFDF613D70FD4870159430B389662104597E9AE6E08115A6E78E7BBCC794E59AD3AF20639D60D2FE587B9B8FAB0736BC5A5183647069DAC756E378FFCBE3346B43390AD49777466A649BFAB79BE9C1EBBFDCF7AD3DF085A1B06090F7B641D6540463D7CB5D591EF533D93D633320BEC487771DAC1F19CEAEAE8F3061E6B982897EA877D4CFE268867055303439EA3AC2577D754313D8379D00B74DEB882E9388C0E5421C10E8711442366149B27BBE2D94CB83AB91EEFBA21773DAFE98CE18C39213F53AC601A169F29332FAAF59CB2C013C21E6DF727AFB9A5734CB6785ED24B6D588FFDC4FB14949AB72B39D4FEDDB4DDF581165A97EC63D0FA64515F3417585B9E78F51848E6E715468041BFF022DC845719A42EFFA459D8B3A8163279622A6AEA41C371E7792A75396F6A11D24C1190D46D9DA32550A93245A236DDEC536FBBB92E412446654B547C265F3763F512F40F9908730F5F1DE2D223DDEB88F4F1AE2D924A3366E9654C5F7659378B5D8A308741FF1A264873C7A98509204DCAF7A3519B03F281440AEA0B60C194013E69138DE249865B6118236BD4AE82BE0A397C77F37679D2F9F9E5E9361E54E6DE91BFFF8BFCD48F613AF4EB327EDB3EC0FC99A2A9CA23D0AB0F5B0F993F2AC8C3543235279C0A358C7B10665275AF17FA6EADFA9624D324645898AC3AFE1C9D87F2658A4B189EF49CF43FDC9335FDA643DDB396DEBBAB667F943BA9592F31989E0CAF1DEA0E78CBBA01BE8A3184E888AAC912197DE5963066AD439C09C994E34AE045DBBD2E9331CE74F60629BD59C70A2B97B49FE94B2AB89CADEC4A9DD6CDECB7B18B98BB3AB501A6D9D2E809767A8CE1400DEED79FD69989FC07305B4D530FA0C7B982154AD875AF641A2F44B9F092AD7299D36C9B5275B55B2A251FA30BF5E08FAA807AB1F892167C34D9FEECBBFEF18B90F4D7374C279498E27F7E79C2A53524E5B903F8D852C63FFB00 +MD = 55E76B918042CA8C7897B8A9C2F78DF46CD7E50000E50FC11CB51B6A6914E1B1 +Len = 19625 +Msg = F7EC810FD44E6B2CBAAEBF5A662F5BE1CABA356F220CA034D220786AD8E0FF0A2E75A2E82E52C1A6F570BF439ACAFC8D85CC2055D1A8EF6B491B7B8D87F397EC17E09AFD707B541618DDA62DB524C6017CCF48E2842D1AE730D2074E92F5192036A0EA1EFF78BAEB61363A20F715FDAC6FEBFF065A050EB6CD1AD89621A2B3993B0B0614B92991994FC942F6D09316B2A589A6C4160AC519BAB7787020C693F5A8FE2516D62E8BFBB62DC11A9D608D0419AC89A70645123A7E2DC6DD58E1521539EAC65986992B2C27154687BD445B865BDAEF0B96F21210931C7ACB0CE48D7EFF45AFD6E0E9935013E86159F066E6D0321F188F08FE35F1F6723F68101AE1C47AE394E34189D8CECFA85EA8CC241564532C2A6E8FF240E44F07205ED780070E1A8C8CDA151D93AD795E113FBF456CA811BAAB15D471006010F9362F4CDC2281BD01D14BFA3689FAF1DD651BBC6FB844DFBC28E111411A99025FFCDFD6768ABE311535AD31934020969A3CADC0A3B41ECBC288DBFBD696A9906A0243BCF3C4EBEF83CAEDD7CCF0B64DA64B8847618ECB7C760B57E40CB9D8FAD4A38398E92FD3966CF4C96B847D09B5DDEAA239BB25F0E1351E1A28A797E616B5E2C1DF5B098493016165154915A95C4B61264162F7CFCDED1DE0AC826CC3828F19FD68796B83F9E78E32A2A89CBBA9E2CBB725B1196FDF7BE31F28520204A3764D4DF2CD2730D12D6E3EA234757446427D775FEE8678270B31BD61570FC96DD44F1E1E5BCACD9FB9E9ECC591DE804FECF818D29FDC5D454565CD259E31C5882FE514E95DE4B229AF94633F7F97B0974ED9D696FB320C4E70AE39E59B93FD48DE7C3B571185B70C9E7A076C4071F873A9C581A33B00684991C695D93B1B071D12B742F7D8310E2F8CD7FA32D7487A8C6D11E76F287553BBCF35ADC9A29885AA2D77E748EE142B5BA156CC91AAE08FA1E2DF4298D91D98B864B4DC7DAC40399E1BC07FF98746355C695AE109C7C6248A7C8489F431DA5C952DBA885D66B13B2482A3D4EF269C117CB7CCC958065B231CDB5E1DF28CB466ED69955996A126D21AEE23A54F86F9E096A164CC3E20BB2740F4B866B27D71DCEA62A8889817C01B70B095D99037C400DD95B94A5A2ACD1AF1CC2606E435C40A5D814BFA387791351BD4B12B331F68427CCA192DD7E5C553A56BCD0AD5B6FE3384DC63E91353661244D123D1746810169DB35F9038329D681D6C79D6264D149F2C71B06E444870192E86B8B39AC725DB1BADEF73ACA91D6B31821A4B558D8BA69192CA49D897CB87490C889D14132614683F1AA26DF44A6FBE6CA3EF2BDAA20FFD88C0BF7D5F78782F97E6A8EEAE85B1837B2C1D6E0784035E92962078F951AF15F1B4CD13B88346F2E3607FB83245867F4D1F085B794EBAA83B82FA496B0B85D28489432B5DEECD509B2872C7CA2768BC1EC55C21E6083114E9448BE6BB206E3F84276BD1E6411FD78E0160C3A97425B0D2AC939E42777F11D8BBD551CC84F046E498F60F48D2750A8FBC5826B035A6EFE1445DF3D70C54DF10072DB58C841E9F8FC4C13789CC51B7EC77E456971FE626B6556CE661B9C79B8D46430B703CD75ECD954E4B3ABF60CDCDB040D036AAB93A947B8C2615CD40A8FEBFA244C385C462AD8454DCA21E25DC09681BE23E27790E19A0B6DFD1BE1D344245688BDB7E46CBE218D7BE33E00D0CF50DFC68A9B7F77DC3A0AF7ED3A5FD33C8CE34482A4D8B62B12EAABF9CD9302643EA4EDBBB01089BA228B64AA6C0B52A90B3385D0DC5A56A8B8C5456818BADA242EB5241705A31D785D114F9A3138B34B41B63351C61A8ABC6AEACEAE741D04A8660F8BFEAE30DB63300D9541CFCAE0D51E39C8B9CC725B4F87F762B5B47A8564AF30E5C7268D79A7E940C78506AA9F83C3D1454BECD63504474ECAD5119AFBDF7B49D7130C37731E0FDDAE6A7B3C1C2636DFB3EF83C7BE74E87CB593621306CA15077AD4E18423BAB0D092FA779B3568720A86D04048F134A12206283601B061DA4ED86B65B18A3D8CDCB48DC67F3B1BA4B873CE21AD7BA92C9A546848D440B73337C45F1D0DDCEF8B0CEE2D5193C6833CEC353F81697B7E44BF6AB725ABD95DC8FE4EB9212F28612A50D8B22A84B7308A610EE6E36AC2F75F1D91464770D36AEE31D8B15D459A78D99771F619427750869EFB2C69407C2DD1224E7CBA3480F22D1BDD6CAF694B2DDFE38CBEC702B8620B8394430455CA1F7BCDE1EBE58DAA36F2E35BF778A1A7C3CEE0D695F2FFF092A050F4AA0AF294B3A4CCA88D66863BE2C9376462F6CF96ADEB05A75A747A9942D69795232D8BEA8D5072B3ED33AE4BE8D8C9F4728C06522E13A5B2ECF11FA1AA84AEDBC142095121CAE15E8B76BB9F4CAA268B7F22775345D924365EE5CC194F12874FF64036C4DC43B50650BEC8FDD0359D64D6901ACA662E054ED3099B7D8E62EF423173FF2DB37C671285C8BD2AC8B4FEE94B729624BF40363BB0AFA2DF8FA7B4F92E4DDD8957E60AC03CE69E8CC70F4D0196D48F2EDA10A53DE17EA4B67A4021EA98842A4EA1E91AE8B14EC156CB51AE80903CF0E43F586494F8A1345DB3ABDE2DB0B2D13FCC10CA14314AB507DF5402AB618D3BE26F9CB95DD4FBEF9BC2C0CA8D049C07158F1FECD0D655524B1EEA254917B3B5FB199C558517EFD645898FFE6EAF0717A3B01F9065C3E31F42C73EF67E8A3FA5D5AB36FA6985E59DA16574BF80FACB6C8040E5C7CD08563A3ADC2A5DF048A4A78667D7420750CB2224EDB1D5CD493481812F6759B55B07E9255A04AFEDAEA3B5EEFF3533698182EBC54DF17E6A5D1EF5C912107EFDAE20041ACDC5EE590E9A4346512AD93AE22733591F17F20A7320F1E5F68088EABBA1177BCFAD6876F213B62A338E800F79DC21F7E078F1C58078B733F0A9BB0BA92731A04DFEEF941BD2FA807A76CB37EF7FB9C1D7DBD573FB8EAE5679929074DF25D08EF325A96F211F29F57D71815D7B3C5928780E5929505419318E98885D60BEB52D4BA2D9BF0B8A9C71F60923FE8B81C2819B4523B427EB9070DE301521E8E8014EECF412B7974E47DB18CAA6F04B1B6D5ADC2FE5DFEB280B971E1EC25EFF77815F72FA92CAA12AA6630B3CDBA4EB25E5D0415AA6FD7AF6644953BDBF257E7A9C27B2CA49B5259A198303571693170ACC5FAF887333772F72D07F86DF4872C34437ABEA3E4CFAC954F409FADC48F0283296FCB1172BCEE5D5BA431C33189780BE5B01B2F8F3E66462EBCEFF5851B66446DEBD44F80609575A208E87A12BDCCEEB87D8149800B0BAB83447E37D9B42CA8873F28A4902B15D76C15103937BE37C4834D776E8D05513920B8D6F357D2CB10EDFEE6131833C8D4E269CF40111B92EE052890E7BBF38E986B07099AB06438DCE4B0A17BCB292CFF962D223BEFC95111E308C0649E8395B4A6853EF8ABC804A291EAE395BCD2BB442EE75470FE7800 +MD = 4018F79A2A8FE61E78E8B5D5DBDC2773ACEAB7D3CE8E7884D79B7439E2FFAF02 +Len = 19688 +Msg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en = 19751 +Msg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en = 19814 +Msg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en = 19877 +Msg = 74E48492C9B0E2540A9F5BDDB38E34C958B564DA9354CC11C338066D59188972746DF5CE425B6A6F9E82CF33797001BC1256963EA4764FB9BDBA9600FBCCF46C559169A14CA8C65B1FA75ABEBF0C6F0B25446F0D824A43B17DCD3BAA4DDEDE6D14A8CD5EAAC23A0B06EEED7141EDB756C847DB07CD9683A6124B09F3BC97DC3898E855788DBDBED91CC20734216C02E361469A919FFD7E381AB8E976F99D8038C61C613C5E209D1506EB314A2DB43F8AAD177C34CB1A86CE7B37C0A67018E1295E31F703E80CE65A992CBBD8F7A9BB224DAE8BBCB5555E5E3177375AD5D298DC9088CF05F0E51BC2EE38660355F8E2D6D3C5B7441C54F8A5A9A2675BFE7E1D91236F80795D100AA84AA596329F7DA5B10DA92DFF11A2FA6D6BEC7EC496311FC59240DF0CC6772C9728BDEDAAC19B64140577DB602FD6AE298B6EF52627BBD81530DCADD167ED555F348F52E3891F59BB1A6D276C57D2135EED302AE7B92EE1AFEDCE4F112198DEDC9A29AF394BDE5452F2CA0D096064B9C7DCA4AF34E4562DE280D15405F17969E7F62B85CCA96B80C1107650B52DB35CC166784ACFE512AAD6E6110AE3FB895B355ABF36E30A172F8CF8C6902C26BFB5D28334198B14366C1F7CBCF448889FAB2EA8DAD865D6B0B5A8F526C84D041DCA236E5898A47FCFBC300CE454A0D735AE6E3FFC9D4ADB2802E453703DB01B04DB44C9AFD12069362935B72BCFE553934F3D0381A742BBCAB2DBE7DA8C1A9E614007F0CD5E5A046BDC84702F321BF5BA2316A263526B6712799A764FEEAE210C36823C0D5D60EC20EA1643EA69702309F45EC213ECF89A1104721E5F4605D0EA7BD098594E1D8A50B3E8C44638B41C4E447462EFE8CAA9089AB3B3270B6F21F79F1AEADE11B90040BD2B52A919FBAFA7FB77237B289CE1BF92D714A820F5D085035C1E207CCC6896708061707ACCCB8DF742C244240AF5DB04F2D85E2180E41316AE61E234EDA24E8D25A64915109BB30F014F59272DBD1C02ADB8C0EE8CD84B9F0E70D75E27FD08C379652FB6EAB3C1CF44814BE7C717C41D2D7266240352C38847B7B57A2C17C48B75C57E673DE2705965BFDA2518D5FD11B9BF319EC220C52B6B4CBA06E1C8EF46E36FFE5F2F795A210F5D75887FB8FCFA7CE9B43127D01DA26F1D379795F3F9D485C357868688B476CA6EA3723F4AC59DF8924F26287466072864B2D662094F9F84205674DB43F94A9E236C84BAEC5F3007D779F965E9ADBDA25B9E76E6CCD4412EBE6B9D12EA6D7609E3B4A12726972FA0C35ED429939D0618AEFC9F8EB7CACFA47DBFB2314F38630DD169E27BFAA8DB2DAE86ABB3D5B54502D099C250CBCB812B1495583D2DA484532A4A797FD82A1E26E72B6EFC3D536956D7796AEDAE539483B66545EF05E9A7685C0C262B277818838B372EAE75F57AF28241FA065CB1C26EE7F5E77E40F1B90A418F7E79E61A4DF86A26EE13E2C1961FEF5B78EA6347AB0EFF06919A72A69FE800F2FD2455A48F1A757674E2EE3C27447AEFDE67C31D17643BF6A0E4308AE7D057818570543597C8433C43A2EEFC4E737879AE23CAEAFA7389D5BE0101F82BEC5AE74228EC39375A1AA237EE075E0CCFFAE281175271751150FF61A4DA8A40DC3919394DEF6F87B33C6D47D269EBE60018CE24FE51E6B0BB3383263064D3B972925B2534950C325A780B87BA6C8536962D3685AD33A4C647448E792F415BD560BC612DDACC858EF531CB77BDAB3FC630670E5A8B0CAAE85A0A546DD6B114898BC63C996EDC6161AF33B490721800A290CF4D68CAD5813EDDA3A2A3C8C9AA87319F5FF657B329A0C0F8283F991B64DFF554EB83791F91ED584829C7B0CD7FD369EA7E79937E3BD21491890B09A53C0490903C7D9FFCB5242D37CC53FC52BD4457D6E7E0E41558BF64D294963C72E9C75797E0C029592EB4431A3604539CE878B038E3D11548ADBB180EB2BCEC70806106F7F5F5D7F8406581AF0E57C6B99BF0FA0C29AE7091F0FF1ECA99BEF5D750AC7EA9B184694ADF8110C72161BD26A6410BB49C53DC07BEC7D8132B0E993BC253CE390D78ECCADB4C2B4A0A751A7E72760A6DBB087B1D1C0C998AB80FA3F72B79E1DDAEB21CFED8350170D2568D5A562174A7ED1CA737E46DBA14A85EF215F6F566BCCEEB1C9CB120B72EE9A9010985BEF189855E1B6752A4FDADA60E1EC895D01A50E2B1B6E2B93CE39CFADD8D966DB64911EEE5C2EC1174AC2C2F21F2407034820DA710C068EA81D0A5905B06FF054DB2076195558EA586B80A6A7242D9235598E4A177F0D6C70A043F2C0CF66C27900AD9791CB2B25B021A71E10590C71441382CF1F929FCFC827438F11CECC4F83FE065A5F5EE209CA02D54D4BB1858C1742E6F9C3C9BB3775DE8E29377C6F22D517C7F8A331A11BE78A5574CF479B8492B7F7E10C40E7CDDD0653A42BA1DAA66D7061555B26569973A914196ED8F098EA036294CC5D349AFEE5D9810F1F6C65F269521FA23DF2AA7D6988125B9FF82291FDAFA028624D8BBE2427F9D563D9A0FFE019E821B79B7C372121113D55CDEBA1DB0A4473A2E3D02BC00640D0E375328143389EEF1FF18F1A5402989FA3EB7908A15DD3202191DFB11DE53EBB1A37E11CD3020BA6836880CE854F81523E43318D095A98264E725D3EF37954CFAC2AA2339E751D582DC080C0EFE9C455B70C6F189FF648B6860BF87850F376F5E4A3FFC6B2AAE6C726051F79DA538BC68E7F5CA26A83B2506DCF82A81B727603E60160413D10FADF00421AA6DE4C151E3BC99331E4E2A605A88F514A0C32B7D3BE0D812E8A7156B59CC70E3F6FF63E6F8A1F5A9C8B08A322C3375FB24ADA208AA958EF72DCF8A4D59F204AF6C948DD25BFAA8C16DFF85460F2A3454E8D65962A4E2432E052EF029AC5AD87A9AEDAF9B4B826922B1ACB990BE36F4AFE2A68437368F343A364736DED04F1A2C05459E15F52E996F746588D6082479121165ACB5511930F201B993F64265AB7BAE0E499BF76CC988558ADA69129817A3868B5B42EA39001A4CD11EF53E71657F326532BCA82285C3C48446DF4A7A25EBF9230302C191D74C1FFCAC04B6EDC2E1895BC8B9D5FF6E0B5897041A7860D91BB99E6B69A4CF9641C3B307A8F15C4D9B3C64F4EE0EF689390AC45E918FDC5903431D1F545AC83B05EBE1228929A1955B51DA271DAE688AAFBB7988C14FFFA23C65D67B0447807FD1F1ED690B50F89EF97BE34702B7522968B734EBD52CDA10E79E30295AA3822208A14378C5192285D2A09AA2C7119997542015627A0BE48AF80017F614E4B8A708667A2C841FB9DFC251C28F0D488079DBAC9E7476A8F4B85E7D5217F0CFE892B77FD33631925D610B19AA523E2BB55E440F4D5441527983427A2C411853CC2119B0385FA22FDD8A7C2E6E955B951379637C5809DEC14FB65BACBD4CB68038537D021BF0A4CCF1CEA7C40E2EDD0A9B118CEB4E946C619359950F7E6CF75BE25E9C42E3810FB74E499DC16348BF772928 +MD = B4CA931EE384CA807EB1024751B63530A4D9A69AB67919F5235E38556B97D03E +Len = 19940 +Msg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en = 20003 +Msg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en = 20066 +Msg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en = 20129 +Msg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en = 20192 +Msg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en = 20255 +Msg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en = 20318 +Msg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en = 20381 +Msg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en = 20444 +Msg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en = 20507 +Msg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en = 20570 +Msg = A86E0ABA8C2A387296B1ACA6A14CE872BE3E4F3B7CC5E4B9970FF495AD51D8790334B2702E8E84F19A07B4A1311EE77FC6FA485DC311465F5BC3655DA878EFF892372CCA61022C6FCD8FCFBBAB308A38341F7A29019D7CB0D34B94C0B6597302F2E9FE9E087C9BC34713787B2649E8998B16AF9A5A05ED685BA15314CD1F3AA6B837146A348E8F26461B9465E809BEE04EBED5CCFE5000AA5BAD8DF817E0A639B1A6ED10D54932291212DC93A3DABC237B91062647774EE9EA3A8667AD62F6ED140DE1F61A8A32BD06791BC27126DE8F5FC32D97EB9E18DFA9D98258EFFD1C48475F13009C33A0A30F6BF5E947806B76D0D049B72B28F1CBA82C45E9BC95CFF287BA6E4D7DCCBFDAA160ACD4445540EBB0F0CF7A54ECA762C1A60B02702A9C7C1BBD0A7B9912FD9F274A93AEA95EECE16406B13B3447E144D50BB0C9238A0570D277BAB6146C38C37369130BB25C1244308585F0F2BD81B2A5297E56E88A958BFB5DECEFEB14CB0616AD336EC802705F61AE59DEC7DF51FA016365CD9ADC2AEAC2C5A489DB438FF9B98AD830CC63516C81DB76A2CFD4B7B199338F6689843D94DB3A1C2D93F6A39FEEF2F4E5FA034E31CE0971D2FDBE4AFED4C55C78A6912FFBAA2FBFB515D464544FD7695244283CE9A985C2A3304FC72F6DB554CF1D8EF0E48BD4F59DE7084764825007C8ECFED4AED8E28DF15583A4902CE89B2B0A5584D859AF9467814E7A8C4FE1CB76466D7E096C273C4593BEEC8D2902E514B5B8735BDD60C84FCA29596346B27AB67BE6E0BAE2501FAE53D10B037FF2941FA3F52E62F9043958BBD7D67649DC1886992F0B034724E5334D75FC788CE1EE3523CF48BCF5186C8D2603BADBA118144B09D25AEDBCB06B01550219DAA034BCAC230C6D9907A81C2DD41FEB91FCA3DECF6E2667062503B7F89D9CE9733D8E322AED1BD1910F3BE7DABC4BA01DD4B6AA9F9CA29709EC99605ED10300EB9EED8E728F69F12CFF451063FFAA2D5EFBFBF1A30474FCC3FDC1BDFFDC272F64BCBCE17E3AAB508A86FB2B65FEAC600F4A66730676089F1F8BCA5E35FE1001197373A75F8BAEE1E396D29727D1AF9B8BE30DD1A5262D3E74612612C83BD6EE3278AC16DF783D749109047540336D0C46F3E26EC02BA65D9AD47C6C3315111FDBF730EF14E9A7AEC88BD79E7381D1609B31D0ECDB7E92C0336190C67CBE603FB24E8513FCBF6B9F64BFADD74F71627E2B9B8124E5E44C0C40D66B6DA863F1C438753E3232A65CCC18CC3EA7B80ADDC089CC7B622AF6DCAACE16C84A8E910A48AC2F1AFEF9554CE8FC14C7BAE4E7C959015554E9D8C989B76CD00D49287575B8F218A689CAAB05F536627C86F29D0495B651FBBA34290278563D99E58DB3982FF57EBCC2B47EAAA7B1CA94398B168ADFD8B8083F9292DC846CB43EE1A790F4BFBA42B47E3A2F8BED7A810B7D8DEA09B77DA6EC6652B12849FFF7FE01D72C81A917E6418CF07FEAC585AA48E817554790660AFBB2F89D53B2A704D3D3F0350814ABC42EF77C0BC8D97085FC3FB641831CFAB984C3BF5157B3E012208A4B9316DEA767A2E396CB1BA2654B1C364B1BE0E113C104319A031C1627BB1A57B317F967CD668B1EE21AEFEB1FE9EAB7AEC003661B05105ADAB693F520A014B31C7AEEAF573F2B74A9563186CE62206317FB655B4D0D8D0E1455CBE73E4516D5F03D481192A78B510DE471409017F7A077AE4F8E0A356F0D49C12AED8D3BFEDBF48F3BEE9EA5E5257383ACDD52D74AE0317C9A6E37A3C09284BD219AC5565012716042DFE8254B47C14F189419891EFFCC05EAD6C24261F6B9FC0B10F04AC508F0627B208BFAB7EB268D7EBCD7FD6D727BCA7232A5B6FA920068C1539BBF063584897B0325054A6D8D2CFFEC8E22F00925382E89F09263F6AF1038492DB40A6C782D259C8060256AC93D6B5D8CD9F740A5F6C8490F1FC82D68311D464AA77942718CCEDE1395C8E67A9B8DFA1F21912F0399B839CD1D8327BCAF9E7CD5E26E140B8E3E93BF0B30DBF4CE7E9E88F7ACA1145F1DA2F78FECE594EA756643D4202E8BA4F5A4C334DC755934BFF993913B9414B92046A9CB3E5DEF35B20F23DAEB906BFB4CFED5B50A2C3B3A405699EDF83A0157EFF01A28C3BE58B25AF7B13694455518E0A03060A7BD7E1E3E54BCA248E02BB138D11316906B89D57D458E7BCDDB5EA07BA9B2E87C0B9020F93FA86A17D414790EE09F71C2E02830FD653A112AA68BB4EA372285C400D5941969990038183CB519E850080D205830AEB24FE187F451A59FCC3A93099CB5429437B3D05242DD0C2C6CB0FF0FD31B2585CB135055FF33F34633CB4781CACC3921F028ABB0606298BE1DCB62DADA5BCF0DE8E9143D6674D6064A2E20C9D9DE4DCEF010A49BE2638FDFBDB91CEE3B21B635C326B451680291C98684AAEE9178C2FEEB9868F45A522DF982B54767FB4543A0BE3EB78C8D0D7F3E9BBFA80C4A68F66A08E2855B9A6FE867CF213427A11BAA6D4064B3ADC802D46E9F93CBCA1C959CCC99ABE489B91C0CCE61BE95895BB2D9C61BF73D0A853A7B74B8CAA8B9570C76EDDAA05EBDFC6B62785023EFEB2FD548D8C00C4D796FF89C0DBEFDA5CEE7E556C87894453EE0654C8DFD40E8A4710CBB21AA6D54C8C74FFDB44A2D239199E3F9BF2807C8DCE3145DE81FB406F4DA94539A7C929DF0B20DA7A16636D10ACB1C0337CA9DC2F10BAE899991CA0ABE9FCC6B309480D41662570B59C9755E6407CB5D423C87DBE93F89C1451BCDB126C3E78EFB00F781069ECFE3577010813EC58557E1F426E909C4A9EB40BC8F38DDBF1E7F73C6BF9E69093C3BF942085E4A55D916AFE838519C1A50C74FFEF90BA916F028634D278A513FEA524C7F70AC9B864723A30E07262B018A083F2D3D65841A6F4F998CB41E368F89AD69519C75359E0217C6F3D6CA63233961A697C8F019F09057D14D0AC2763631CDB51546B007847210301FC4129AA1E35E81E8B73FEBA046AFDADBB0B9CDD62423C8ACED397BC23CE6CD00EE24168A85DE4CA29C87BDA88EB0F0BBA5693387D3743316458F2391501483AD3D2E75FF8767D47F95408402615358E8A16662800C7DE64BC175ECE878227A0A4791496A6976C1A9892B3FF1223E9840FAFD67734B3FF1E5ADC6B7E52041D77BD59F678119BA83590E8768CB92C6F70F4CC2BEA8A8DF65F9FEA9DB6D5359A484599231039205496E163757215DCB37DFFE472FF99BD7A8E2E79EED58B589165A23D9DBFAC621B9E63D336CA77309D5DE0482C0F3755B0668EC0C814D94DE65836F011CE5B57BADFEA1F17792A589C95106C94C67B08B4333A95D862773DBBA6CD70B8B4258957FBA16D8344BA8334C061F431026C200AD57CCEFB7B39F4D3C0F92C30E353A3E364CC4EF5068DB4F8422D54844EB09E5182E0977C8F6F2799604B7124FBE877E00307418CA277B3E95F91C322D9285FAFCF356AA3E960456349F00BBB5BDC73CACA5799308F37F5E8C5E5E96E3DC49BB9C456B53002F0689194D466DFD9032D869B518DE6DAC21CE3FA64AE271352D40F18415B8D8EF69C9C2AC22F6300223256547FA8BD78152A595B526DDC216170EBF17F1023BAA770EBD944F5A2979A6FAD7AFF89880CF00 +MD = E2EBDC1F360459EFD8A2402706F5A3D3F44E915C4BD22DEBF7990CFFBD8F9706 +Len = 20633 +Msg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en = 20696 +Msg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en = 20759 +Msg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en = 20822 +Msg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en = 20885 +Msg = 1751D252F8753F7FD4A2BD43EED46044C4DC9A199AFE99851B961B1976EB61BDAA3D0A09AD58C243BE0E38C46D1B81B8812D0677F61E9797A7376F4009B5984E5E42EFDB54C8A80E99F63F9F243E4B09EFE6AE2F6F98C33B36E79A6CC249B4554DA3133A6C0429306F8C695C4B3E9069D6CB475C62CF32FE5BE4BB8C0E3EFA4D602AB9445726B74124E6D8829874BA28B1B9F3CFA66848751F4DD11B8CEF538AEBF487D82EE5E407AD6E24704E6D1503A2123DC3C137BD00C5503AAB6C8B5285910DC3BA68CDA4D71E5D07A91339E1F4E118C8BFB9A95E7BC904E2CE2F4E2165DA6E92480A0DAAFA31EDDFC651B546BEF0D891C1AED3407E7C13268228BD8AE6A9335DC49727AA5908418209F8463E75F67330C739030F898EC9667824705F433474BCC34B5BB92850C5F07C35DCDA9CF614A37E22099E67EE3016AF006AD405F09C1C4B696FDEA964CAAB6E7341FC6B9FF948FD866A70DD82A227069B99709314B651542E90D1B6FEC23F2161DEFEF3B445A255BA8DBEFD53DFF9A6D94FEE15610D206891D4CC252E1199280B056394966897B372E5DFABFDFCF38EAF855631260AE7A2E140898F88FCE1F168867E97E6C298869A15451AF44C35470C653188FEC04D9E524F55573F76E252A5F2C1DECF9D049F39C791B95353C6DCF99D996746E2FB4ECB0A4370A57FECCCF06499C7F2A0F5C70484F1380A407C4406F06C52EB093B0857A6A548065AAFBFC2C73B78BF0BF39C39757F2FA26DDA4851DEEE8CA5CAE3001FFBAE9BD709659630CF272DF69F5BEE4F9206E0BCFCCFE0F990C3526463F37B57B11667661592C9203AE7DE1728ED03ED9CD02DC7E8D194C2805D08FD827052132E3E023F0AD145258B39DAD63828FD7D6C881DFC685A61B0D5910C1C7C02D4B02BF414E8660A9B0F2797C9002162CA67A0E6087CD53D7F21F5BDD6874EC7A96D42A9C019A12A57D8C8EBF2F1AFF81708C27BF68F4E35A843C82D57F9DBC6B0380B5F544B943782C06642831CAB979D3E2C3C0E61EBAE504778819D914CD7A8B99445ACA8428528321DB233BC94DCC3F3B91922B7E3FE2FF4C0F482C83646FF9FC6993FFE33F13438AD424828C6C44745B98D3F92C7909E432BDA5F202C423DEEB42C3CAAD7F4EE42367A5CBC9714B46B8A57BF89FDF1785A58A59108DAE99DF538E838762AC7F06A24313686F0DEC97586DDB623AE72622FABA7A52AC823E97CE14A5F3095EF2C0AC2A44DE0AAE1846AC3F40226C8EFBD871F066913A66D06310B3152B377B003D5DDB7F956DFCF0C2B62F8E41305F17EBA5821104556D0A63931F3F127920FA1A888ED4D4F8384B956FB3B1ED76ACE55113CB352B1939814ED13B908172D83F02B9F52D5A818C8D226D62BD6193ABA732E931132477386F6DF6BC55DB2736A71DE9BFC0E62CDD82D415F2EDAAA0B43511D1271626E0E174723AA26FA9D92EE4A7BE61153729BF738E1DDFCF35C5D8884455643BCCD62D1947E5420859D79EF5095F323086083D88122B8184702DB22100BA5375D88479DE8B567443AE3C64BC95A5E048DBF275425898DBF2FD2074B3A4E4B439D023EBCFA4DB7EF6B8C8C60F8B1018C3E5B55CC11BCA8E095FC36709BEC4D923B672870D8B168F8EF168F6ABC71B6D395DF16A9C7455C4B04710097B79B34BD7B58E7F327675EC5CCFD374201ACFE5862E1AC09AE0C196FC7251D03509AF29507C9DD35B940C801FE5232C7B5F434526476F0D10C208AC58849D2FA21D852690CA8B6F4F7A60506C2247A55AADE378D62A863861F4B9B8DF98CFD0FD396315843F296AAC8CCF1A012F9F62846CE458D9FBDBECE2523BC703A79E9C01E6623E34EE3D0706B95272F9184233213D84BEFDCDCCE9DCD9673BB84CD77432F22EB2FB9EC17C12BCFBE9C96582CE8685F1D41868EFCB72E2885914A117FCECAD5E59E6216AB61A0F39180A92E35B870A602CA7F6ADCB2B0C659FD762630B5A97E293307B3596907CD183856556AF7FCA2AB0FD7F6BB1D8ACF29CF753EDC3F5B7E44110F98C0C4338FF439A9BFACBA0605837192C899C76DA608BA8B0B22862F9F6376465691C01D30488B292380F86A61087A7E99075F82EB37CD6072A67DECACB18300EA3071B91A4284369B9E1513219F300BD75847110EF8FFA9C13D915C92CECEF60C9D0367B8D2AE5E84AB47F98F47C426C2DA55253D8F7B6205A1B06D24488CFA9E83D87404DA7F3A66EE8154F78DE2369218CDDB5B22CD3DC26C3D85EFE05841616B46F170BDDAB058049AF21CDE0568C21C7C48B539F50FDBF348BC9AA46DF2F812A9635E642D642356C776398E3ACED7ED26FCD4E8CFEC57F7EE609ECCF9DD30FD9EB4504018BF0D26FAD23DBE994B808C514FD2AA4B08A1F1954D2AE667BCDE4BC9189A7336C1456D8BAAAAD2D7E79F678337DFA57C25C2D7436285FF98AD5E276FAFA28AF00176E8A4B4F38E2BAABAF6D6D76986242248E36C5D11603D93B3F704A8181720555437CDED236A4203C3F5A81B9B2603FD151F0DE86C9E2906750165E3586D14111BDB65CDAB6CB2337689BC05C060791AC2B12DDF1EF0D72FD43627596FD44C0BDD860010C3F92C13969648DDAD4894667E274348FA1E7AEC0C1EDFCDF8E8AD8282079F12323F6B67AFAAFBCD77D83BAC650234FF64898FAC1EB91C5BB9C232B56580DC4C8D19062B79283F75F56A74A99AFAAAFAB2915904A934A338CBA50640603D7FD390C225E89BBE3E4F03EFAA7C8DCBE91377427AEE70A78E1D6D10D3C55706A6DCF630CCC7AE6571481381F1A9423E3009CF0BDF9258640691A920EE88AFB636CE1D233FAB8640800BB1381CE45B8C987B5047622288E4D82CECD1DDFFD7CCB8DF7AD75F468026ACC1E4A93DD076BE57623A748AE0816CD823C4AAEBD5CBA2B7007B0FCC84A3F372E3F98587BAC2A25E04FC2AB518763C2EE2D4A513E3CB875F429B142E92020D79B0DEBA1E9E9897FF322DFBC42FF2D443E249F1C0D45B4D0B0640754BC03FA227522275019E41985036EA132059DCF8CCA443C7467BA2951E9FA973342A330FA8CF47AB1914D10875627C24E0942B1E606DE004DC1F3295DD4EE996B9388FE5F3EA74470673055F388DB41A045E6F8ED99AD7A69896CBF54A33BCBCFAFA803355715388AF5F6761B94FFB058786A29965FF88D1BC2CA322A0CC3C95BCF690F60C9C3DDE635C907F3BE19BBAC2A658B4B4503ED84C8092530623C1AE198FD2036F6AA776C54986A0E3FC2BE7FA60E13F4CA98283A8FF72A2C946818B6F33FFBC631C8DCE0996BE4F218C736085077B93A9CA98C24D88D6F83D1D943B534BB4C241D8AAB0C93F7947FE96F63872B0530AD5DDA8415C91D771583977C23F4750B35C8F790665ECB538A7EFF4B77722BEA0D68CFFC6A418FF91C6D7611E17454B80ED91F241746D68F3B03BC770D9D876B659E6E14C548D85176BBB6E67BFC04267E679AE691B7B39FA91FBB6C1D6F4A8CFFBC3DE8F85E72AB2B28C36F320AABF1B8371F1E71B7ACD69EE896B4842FD0BBD47E7F6823EF6E0FB480E8C0C389B0990BB8D7F9AB3E07F6093DB2F4E6BD97AA820992B5497D119C48E19157E49462F37632F436AFDE8B1ABBBACC86B74AC852208BA4DF1EEA15151E207BACB5F801235CE9595D7CF5D3A2B1F9978D687FE99AD2342AD7999232C75F678A2C7EE3DDA67F0 +MD = B03A0CB29656B649D6829EEC9999516A7D8116CF8061099CBF26860BF79115E8 +Len = 20948 +Msg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en = 21011 +Msg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en = 21074 +Msg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en = 21137 +Msg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en = 21200 +Msg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en = 21263 +Msg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en = 21326 +Msg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en = 21389 +Msg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en = 21452 +Msg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en = 21515 +Msg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en = 21578 +Msg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en = 21641 +Msg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en = 21704 +Msg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en = 21767 +Msg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en = 21830 +Msg = 60DEF16B8FBB8039D95069B247FE368763794A9ACA5C0D5F6ACC18782B5A04F740BADB51CBECD6F1CE2F016962307476F2CC10331A743B8650FEA70B99B85B681D57A1BE7665D8CF4377449F2B55E38BE15899AC522153C2E7D974DE02CE441DDCB8D3E2B9949E65756C8E5C25100451380C441A012525B420717781BFB9EB8FE79DA7574D6A372ACC5AFA0B6EC2BB3AAC0DFC1F6158AD74616002EEE729709072DFE9562A5C722B79980CDB7B1567CFB3316BB03E5ED3AFA6694E4878ED57E72B0CEE361D2D3BDB7079B0D9EE43638611C3F9B67143E3860B460E510A10C6BCE412907A6BF81B3D8BA4715FA422B68CDD16A418DCEA81E0F9D10EEEC9D4279FE907D68CC8A2DFD8A34988D1FBC39D3CC59F24BBF8A96A4DAE9DFC4F945BD49415308C43F05CB750B2F185D491A4E20B3FC6B7469F262E96BE1B2241963D7BDD97B81AAF8A56BB8A110C552F539CA98CA7D4AD27CB04D452A97528487843DE833AF592714BB0BD4FB2BF8A2840418DC6E50EF95BF5D2861349B14E029FF2C2DB7BE7189AC392C26903EDB929BBC50DB023207F70611E2AEFF54988315D1B0C3FDEB0AE69F92D248D930DBDC7A1CA8F5E7E2216A2984AC911D79288B80F2C3E6871E58F5B4C828C48A799B96A9208AB284FB736BEFCD3C9E466867CD380077CBF155010C9C0B55927DBA5ABB5C7D4913FFB3F5E98A1AA957760E713360B2C6FB11497448E2C10A56B2844BAB329D7CF27B412A36B6204060446E09B9A71ABDAE0F01FBB15E0A54903F25967C4EE436BD98DEF0F183DF0D22126F29C2A6846381898619E95F13342C11E7F66CD1901EFB335D61980B94DC9D72090C04207624668EF793B18E49548657F8D3427CC51E98CFE62BDB32C1AE6D86767F4ABCC23E1BACB4EF3BDECD76FA8CD4D71D7BE043A31963A4783D035961C85F23086F43BD159600D2EDD62E1DBA641F82D343D43D30E617178526886BF6DBA2F46BA7F1618663FCA4CDACFC60A3FE2114C3B3806302F96D776AE1AE8FA69F733F43EC2544ED4C45F82FB1A079EEE3031AF8ABDC20997F8A4FFD3D6B3E65142A64DF921514967F200D8BAC9E3CD055E18E2AFE905CDAD0B424D74FE70DBC47FCD00C61F65926D0453EB4BD41DD85E6244A1191BC05FA4BA83A7C19327F8980A5A9C8D42E30CE3FC37CB685658EBC19164C498C53F6BF1834BF1D6D5C8BA932F86D209545CBCC1661864AAEF99AF79DB74D4DB113DD85D7A6C150F3994CBBE59DED6BB37F868C641DD65ECC9FFDFA0A7274E2C67EE4B86419897C5B6300436765C2FCFAE52B5CD6EAC281F493D683BDBCEFEB9C9DC720843E62AF3625D84DB5209ED7988DAF655BC45D8414047160236DCC02371F7622E20DB5F7EC9DC7AAD6AFE142921520EE428F91B8D3E489CC444478CAFDFFF3E5E919468844058B6F8167B4F04D03822E3247ED214488C33C7DCEC22DB27D86FADC41CAD876B2D22301C6201E142FAE31DAD6B64ACCCE1D94DAFB9CA0298CB47BE8EF7DCE159EFF9FDB79838E60C16FA323A58B772DFFE3C267347EA034DF0CC0A857D25A41F7866B738E08CC806308467D4E8C59114F6CAD09758D925330B4F64D024AE87EE7D1BD82C7F0777C2ED55FE15A2137FB080741B3DA401651680C23183438E35AB9130277E696C12A2434B7FC626C5C43C4C8685BE44223FDDA21E1D0E2A66FAFE7A98DB922FDAD9368C914DF3AFB69438D0DB4BDC187A9F8A6F89F21C80538B26EBF70E2868457C9F596544B81E7840ED457AF0A7791CE277208409C57B7389BD8825F25400FDC0D16A50C0E862E264CE5D7C8902DCA8B8304D0AC71044D5CFD0A9D4BB120D93803942004562936201E591DE8A674BFB83D51865C4C804220E25D5A38735AD872B24F5A9C3A17C2EF1C2B47D9A97531564FC4926563270ADDE54DFE364762EA5787F80C3D03AAD9B572AE0F09008F5C54521F8F59BEF8E01BCA025DD33653829D79304B6FE3D302B0CE33ED4E60A962FEC74DDDF8D25D82F6413E92154B3C165341649DA0B9F536AD4B8FEE05F2274C904C6209305EBB0E9F1F6801BAA1A08D9FA14F36DEDBA1BBB8F1A311E27CE8AA8080B3DDFAA6B32089A375E917461402A446769EE7C81EA6AAD3BE083F300CD82E15F02E93A4A02159044BA17DBE287F3076FEBA598BA6365106A8CFDC4AF80A3453E175AA894871FEED46C2E17FC7CC4A28B3996FC80EB5F0970A5F2FE8A2E0D324CCA9271A0A40F362DB8F0CB84B7FDB7B6C5A175E0364B242E0498088863A846542CA746F7BF3FDA951CB87887728B983936B27981F570570538241571379A20E63B6628C690F7E62CA0A744D880F32EA3134DA6A77D5FCFDD2CE5464D14DF9333F041123C2388BF952CFB805997BDC02C04B30A2E17CF5C9BDD37642C0D37408DE60CE518102FD1F7B0A492DF069BA48E826D2604BF04FE4B3DC934D63D6AAE5AC23BE678C77FB3209E353071FB60E7FFDBB9B1CEF9AB65FA4B060F49E4DE732845B509D26EA386F6E3AD94408E2BFD637E4C6E595FEA8FBB4E0E51333BEC68BAF670185012DFD9956B080EE20864F7FEAFBEBB33C334B791FB5791E357BF6861220260BA222C4AF6DCDD20139A365E57351D2B9E100F2D32A83BEBABF5BDD686597F189218E115FE76FC9D132FC681FE64CEFECA142BA1DCAE641509740964367B75C8C366EAFBBD99824890F8FD8852F77B81CC05E5A20E2CE716CD354F7C2A424B8771E8BAF4F3C3CC3C340F474507F360E9788215D9914B97ADDD8A8496226774A072A35098D3FE1F4F3E35F2493AE9514FEEC8BF68C3825E7E376E6A0F9C3F9C099353869B2B5B6C8391468B6103F4C625408B1E191F5C515EF82D2999170CA9F88548D0FC74A0FFD0985CB9F6AD7A8804A1E93FCFCE2AC31082AC31EAC5A5352DA76D02FBDE7DEBDA81D7CD9E3BB949E6E7B865D8E1E88D38E83BB26A54C773C4D7D13F9A1B96FB57D4B42280E56875F411699F9BC8CA5983F8F87CBCBA819587323B6E30E97CC20ACA1409FDE955D6B4F0BFD69ADB126B2396D1C47517609D4BA97DF4251A8E2C56E6B4A2A13DAF80ACD88ADD8A4587D7503C8C6DEC46F8C74EAA2AEEE2A3A9A489609B171062802B2D83DCB9A74AB473E73F64A449BCD6284CDD656622F42670573644E8CC7DAEC5B8EAB098DC2BC8EB6D78E0C8B3F0F31E777AE3AB82AA27C1D3917C2728EE1E4A897E1475BACB9CB8784DB7DEA2AE8EBA5EB8BEC19BF24A39B6E2C566F172479BCCD0B7AFB64E23EDF785886CE6709DF6219BAB2196FA64419435231AB66445D9A79C92805B64DF7949B7509911B560831D2A55CE40392DF6EE8921000858149B7564AFC840E152D941FD44F7D6006AC836BC4DA8498705F9E9D34E915CDE4D564601A40CB3879291BA969B4EDECC8056B325207ED07A5DA65E2541280E01DFFCA2766C2B898046A321C17E0FD6EBF9466F61F6C41BEFB1F1D75AA609F72D19B7576C1967DB976D91128E87F6DFB3E58968A23C8C3BE7FD27E23CC46E459B905EE57384F6BA63284AD0D29033A22600C35AA6A348858FFBB26E74007E1463DBC0B07E5A982E6A63BB0BB988B26CB2C454E3BEF5E6A413D8A4BAC16D80F2A6C8138F4650EF29AEA0DB2D04F15DCE1FF5BA77FED4CDF158F951DF90FECFFCF2B0967B4A966174B37A90BEFCB74AD6FC346E8702201D6D558ADDD31B1AC2DCE6CA9D605834360838051435A2E3814C0ED5D62FED7F54FE40D29598649E75ADF51233A6932297E247431F86FD348D89B262DF2CD65F0CB5DAEE7A14D5F5352CA58674AB91B753C93E0A4C40E19C6FFE45C27445903FA53D33D379013A0C59631114BE2B193263E98DB47F3BA8 +MD = 0D47AA30AED3D268E63D03CD2C2B24F4DB51FBCCE1A7DAE6BEC23F06C7E080D0 +Len = 21893 +Msg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en = 21956 +Msg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en = 22019 +Msg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en = 22082 +Msg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en = 22145 +Msg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en = 22208 +Msg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en = 22271 +Msg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en = 22334 +Msg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en = 22397 +Msg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en = 22460 +Msg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en = 22523 +Msg = 2816DE20F0006239E3636D8CE8C9C63F1CAD0D6C38084A671D07D447C7B70E60A02A5463118363B4DD68168CAF602DB83DAFBD990D9D1964A6F3566CC33F11F928BE460ADAE4A6CB07C310764C0510BDE36EDAD182D8B74DDC1FFA42B7DFAFD8EC5A1BD4F458404347E8B86AF9519F96496B4E1B99E6B3F4535E274C7834AB7391454694C8418C51739714649305355A46A46C604E7986147EF207BEDB708B9F5CFD296BA99DBF1A96910A279B97AB405A9256A6A42C236F044DA50A44B4EF0E405541363163AF9211498587B7DFC389EB63CC9B39E4EB105D9847865AB632F5BD7DD6A58135FBE407E3E0735C25019A13F3105AD1432DBDD6B02730A90C3B17E0AFE7C539F8B33D30378048BFDF5264670358FD6B24E4820192C5CA2511D4D3C793D938993CF01594733A4F1AE97545C937F6D5100915483F47B6636BF7BE8DEF6FE6D1987A9556E18F7C0CBACEEAE84D1EB6FD523C518B528A6A2DF18CE6393944EA9B9050C584E2C48B8C037E5976CEF344F07EFEFB9F29565A9B4BB682C4C6B2C2CD24C86C064A291E07008617F8FE09C04B7BFB02211666F9A311CA7DA4611CFA83BE014E1B4529E71F4B9FE5D1B85B0CB5A43273C13EEC0FC28FE997BA4A958B39F5DB51A1C2DDF4FE7B38F324C9C7F5029FE81DBA6DF1D484CB653A2CB6C50AF9AC5392FD5B2A0698AF2F785744397C4E981EFB9E02CED1957B287888615470A7405DA291CB7BC6027748342C5AF7172C6A3282F0A3A013E394369C319E57D08A8E44551BF2ECBC98896F7530FB588A7E26E9AAA6F7DA60956608606BABBE3D3A8B1881E54BB0B744A65D8BF168D4C8CACA87451B6F5D7B545DA2B8E2376D554D52F275DD091F280DE8D3D05041DCF847BD8810193C50158401805554194AEED740114E6AFB9402E61818364D7B9AFAF682530B75A9719A93F826D90875E0DB3BB07FDF47E3380E8275CF9722A756E6B046FED58B9DCF18BF3EC47BFEEE6C90338330F3B00DC6BF8CBF270C2B03E9CFCBE1F330B7ACE10899FBE46A284715F83BB3A13E9B397BF1D24A1F10CB2FAB75C5CDA7AD9FA00CEC07E8A2AC26D3F212809CFFFCB74F40A8A8922C08D61AC159229EB949A1A246A32EE595FA559327A74A25046802DA8E09118269926746DC7BA016584BC5D180AE55FB4FD3DC9507375AE1EC2F8E315DA13CB2FC9C625DD38C627794B2FA787BF977987C503E944385C3F5685D33611511EF109B4E071FB3F1525AB642AE4F06D886229EE3589B6BC7FA966603C1967A706FD7853B5650D94DFF18FE26EACC82B1DA1789A7035450FF7710AEF88FCB41A191E6052B1FEC64303AEBFF959EB6EFB4FBDAFDAC163232DD51D11BC37AFB5C1EB94BA52D2E799E8640D7C7A058BC238F6F3B670E079FD89D0D338F0341C5F429E8EE775688C9567D64DEE7FD20FC6F67F646515CD3BDBAE5EE58D95B91B9CF4301E57F42BDFBA9ED29C90D9775BE2356B9AB34910737F4BCAC098FF162CCEFF7F2F690C0F875C73E44FAB7EAF4D2A70F82D4F6B96240BD8086CA9A90E33442FC4D876E9DED05C1DA23579619AE728747639F7ECDA4A73A9CB7241BFE6AC4B09E82D13AC7A722F0420B4CB9ABC6DA416603A9B67D4D5B20B65D3E17431A3B46EB184FDA55CB88EA9BA64A04FA29527FF63BD41C02DE392D013F02F39CABA8FD24F221E6918899A572C3BDF571C9494A2AB32848D8D4CF898FDB1F3402FFB280019CC51079984A2B46CD1A6ED6FD2D3DAF460DEEE3E007A5FB192D79F9FE76F1FD10B1AF9268705ADD6AD76544ED5AD9545CE5AA16DC2D28875B308B10AA5FC422A13A92F1E1388BADAFA11123554078874FEE61B585DE590D3FE13419DBF4896D86E0F83DEF33FAB4710E6BFF70C0B9A5D0E3A57175BF9306DD95EB319D75AD636046432E1C4C0A8DFF99579669CDD0088B370AD07A8F1E08116057A872437B2225B7AD25E3B8150CC1AF0709328661E00AB06317C10E70AB00DBEF8175B83AD1E3F4B2DBC555948FA6A5C95CF43D0A522D1F82A10CADE1EC45846E30AC8FBD550E9EECF3084FA249A62043E8954D7EBD5C1AC2D807EE6A82FABF2EEEC1E86143BF44518FD7ADFC904CFF138804F639302633566DEB3960568112A8C6FD9A9E6ACF9067B236BE4AC321425277B3D76204DA6750DE0C4FF807838BDB41BAEA3CDC1E01752358806D29073C69F9A1D031D76A82DA54288430A3F993D85235DA9BF930A6AAAD1498E61432936FB46C69B069D2318DF0CF24935CA0870F12DAD595DE0362EA87ADC64756A6CF18002B9578BF42CA751155B39FDAAC6479C1B2DB8052604C94B9D146795998BF2CFA6F6EBA74BD1D7FE1BECDA86251647CF72DC3BF4153CB7B233EBD19F4C18822D30FCF2864CA6CD8232345F506472502DB535E398CE2152685B080A2AFE315F4BDE4ACFDED335C3F48012E70988480807C8634159FCBC9F93E4F9857D2674A784197B2E40BF3087A7A6050A7CCD163F4E0C2AC09DFD273AD73E06BA8E7EE92C0649599D3C6DB2F5DAD15874BDF01FAA6299FC535DA92967E76CDDD9D7FBE14EB08C07E3B46E6AA8126D89FD6F5ED872E2D961D03C1D5FC31E2F9AF90FE8F0CC80C07495313D7402BA2632467516723495C4B0B6ECA8542BAF8D51106D8C042D6C5EBE2500AB15A2923247B59A5A9DD5705002CBDD06672DAA1D8AA312331AE5F6B9677EDB6B6385283A3582EAAD0F0E47C9AB8CCC8CD06BB5C72084F9CFD53863C7C8B2BFC6CC947AA536AC762F13972EF168CAC5D08CA69F4E320656FC5F6C3F754B826524A883FF9B452522C3E02AFBFC06BA311CBCA586223B8632D2C8677F07B051F0196272DB002A4618B4109B311CB0A5B61100E3C47580CE4FD9F9D39CBBFF25278ED70B1CE916838199D04C66419EC95684A8C67C6794F8BA8E742698F1B67E7A371630CA233E8D499E30F810008B97C7783FD52F5E0406550382985E553F819D30129902322504A5B15EBA1A523649FFF0E5B9214263C170DA6DDF4B23DF8DC36F7F05EF0357E0C0DC101A04564A7EB73286A16548CF47C97AAB03AAE86FAF1B1B7B84EA4A9337031D5B468C0BC4DD96EACAC5683E8A0A19D212E16C02D0AF4FC2D5DB4D0C1328D4ECEBC3A89D54C086C445D20D06A60E238D8A9848861B5BB327CCDFF6CD4BC57A24CD07B0FD64BE00F58535DC69C471E8F5D322123296A64E41A1BE5FB2A39D22CE997674DF3132209CA3542B4093EDCAC41AD4ED58BC6227101EF377FEC1572B7DCC16238A6004AD9D6AFB717D1EC2E5D080C3345BE76067BDB4B45575991D8B80F7090F501F263540A4AFE09F63C8564B1142BF5A6E5011D51663E93F2FD93A2B022C17D829ECB291D54D749A9C688F8A1BCA060B104DAAAAD220A80A238953921D44FC76FB1CC1BAAC7966F8939061C3FD7990DF482A7DBBFC1AC5D478FFDA55BBFC8CC0BF70EC405B2AFEB3ACFD1B725F7733FEF3AC773647C09F66F5E6789805C50CBD3DB2CAD13F114BB15C3BA6625F1A92DA45B3F38962B115ED0402947ABD7155771F59812BFAC3C3B40E5E77C1E9D98CDC76284B0AAEFC6EDD5D4D3A3D26AB95522EB6502924E1E164173F8FBC9BAA41D67EE75F0D9D2015062E8E53B6CE8F4E42569F5885F70B4ADCC0F7A955022016CDD707D3EF4F59DF66E95C7A616E7A8D2B1EC27DA719382C97AB047A10313EF09B66C6BF7BD0BE25333861759EB31A2C22DAC6DE264784450B47A32B762554E3DF40E1F7518DE67A2305AE3890967A087BB5D0D3D10A3E80C5662DE3B7B8ECA56F37333EDA21879A82B1753FB363880219B3E45240E3FCECA63528563967AD20CE1FE79560803844C5BFD33D4999D5BD76A7119CB6BF3BD8368DC31891DD82E4EF573AF7AE0E8BF206EBE0A56E1F30FF6FFF15B3761D7802ED65390585682CF4D0F82051533C4F58E0B99E0986311F32CC1BC462C192AEC8C6A9E7A3C4D60230475EF3E87E2FC634600 +MD = 941EA354A206437E1C5DE404AB2C31C6BEEC1BABD87684C6824B944258AB57B7 +Len = 22586 +Msg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en = 22649 +Msg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en = 22712 +Msg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en = 22775 +Msg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en = 22838 +Msg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en = 22901 +Msg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en = 22964 +Msg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en = 23027 +Msg = 21D892205EE5B97D45AE1CBAE336937E13293367DAC89787FDA6F8AFE1EA2BAD6B9AA128E8632CB6E9C525F4A61914DCBA4E2859BB9A309D7845F511E20037A4C89FF0F3B6C280A381C860C5DB06749F433738EDB635CC8B05C5430B811E72584BE68AD154F844683056113F612D70934782E25BA646D2252038D07A1C5110599E105C1701E94572A9DD25CC5D412D31E004B46DE13D76CB08D37291AE6C387150F15C6248ED7E45FC8F1CDE89EF1B30ED6071CDAF6DA1917F62378509B64CE29F82505699ED81A3661452F4EB426636BC960EFAA338A27A17FBFFAF8C94A73F4D39F1CB7D1432F615A0A858F8F2B58E44BFB9C1ECCD0044C6AAC4C9EC40C8912703E07589536498B89BD56EBD4CE94B301EE9724D1F5FF1C15D1C7A441C6DB8B2B78E9F6009B301F5C644342092790636FBA8BE40BACEB3C4C045CF0B0195E6C8C56E4421FD2A5A8D49B26D6C06E727945A280B4ADD2E153DBC6355A80B50E2BDF54FDB9E89DCDD6E39E16BB33CC00A2AE57E2108A59D9128EFC3859220C0101D3C1835419147DA14D74C7ED59890B0C2B39454C4408B8E17ACFBEB3F94857C162B0785EC6F0B8FFFC03D3C5D93006EF933A90192A4C24ABFB63E682C7418BE0C2071B55A54602F0685CA8F44359E6D3EF84FAFA4784D2B1654ED5C8902C3B7ABAF8423BBF13D688C36DAD9BE51C1294516E10DF53A0CEF2502C4EF7E4F52525E8C04E76447F3BA7EB19F86E6655CC2E831C54ECAE5AE6EC4C7F1C001D5565F26C3E508CDA5EBAED73E75F4FF641EFBCFA2BD13F251656DE131A5A171CD95867CDC5CB5A61C84332ED6665C7D39943061BB46A414F40EAA725FFE4398A63E2C6033660E6A300F8955EF67B2708114924DBA37E59473C4C81D6E9571757F6A61DF02A5EC29BDC1DE277A402B4A9755477C5BF6866740F28FDC1491F227F130AD5F37F0111EAC3A314233C3470701B246017AD0E542FC37CE7860ADACFF25A8574BD90371B4E8A06D5A0ECC0C64CAA867831762CBCACED74BEB7E5A5D96062B27C025DE77ED3AC2320D361A38E77E417BEA08889C95EA0525DA70EE051B9277E3B25396545EC30321B0353976610937D929240A8412D16DE80926DA0F84E7D7822F97617378ED5DC2A78E09C5509B4C6DEF5D9A5B116B3D0A65FFDE43F9EF78DEDB52786453760DE6E16B6DDD4B65B65A9D5D5D4CE1BD228685494CF0A08B5D9926CD2FB6A0EA124AA55AC6823D8A470495ADED9F8FEAFB3DEC1584241B4E209F5A0CA13E8915CF25C2199F34EF373A7C5DB794FFE3389AE3E650A84392D1105686787B4419CB443D6A88C41E67B412161969A6A0CCC869FAD61DCEF994835EE3F31F01CA026638A4A6145E89788451A759CB16882BA57FE8B9BB1710DCDBE55E6403AF03131EDA2FDE324173C6F729E52C69D0A6E662F5C7D2984FF4A6AC5EDF82E7BF75D05D036E75536861BB1EC7DAB0B4DA608F41F91CA2E6579FAD8C56314BD1AE11B5B5942C253DA7443CF1900856F30C0EDB2C1E69C37E704B09AB817DB41D81EA370E52A61B0F6CD48792A8752513987D5E743706312A6D8E2835C4ACEC1D45514CB11BBED80C0850040D4CF35130A18892A3415BBE6EA7D7700117692906548DA35B271F47D258B13CA3F57D2A3D6A690792B86038284B2F78484A02ADBEEEF155B570579AD4A619D87292569ECADB4F5AA5305F9F644D263F58A1B2398C722B02EA99ACDD372C30935616DDF488D290004DD08808AC46DBC8A31BDA9E3EA1FA7C66CC49C19EAE39C7DDE6565DF94E7DCC15E9EC71833662F2F580F2D8412F115E87EBAE2F409D2F7FFCED6F4299B915DC03636C424332D043415AE902BB164E04BE535BF1DE80131828A3601B90E5C95A2B741DA8695AFF941A5264E20A909704E982FB6E232A737AABE27BA2A5753A032ADB93AAA8EC7AB3E44F07D5D7CE41F6B02165046C7BB3D535D539B07F73458F54E86B774ED1835D03E5D46D4805B156BEACFEBAF107BE5A2B0977BB8FA8C6ED71056B616FAA333F754F03B2484F2349AB2E17A1D43A8E32579F70213542B63378C33D3FE6EAD5F599C977983D565C818F7E951DFA55D944AD10801BAAE77E60CE230E59D1B7E550386994D35EA99A7E2FEE67C56E5067EEBA246B947680BB9C767226D563594CD54006D8BDACB2F9CEF97C5C5C82CD53F7C4812D4BFD33CDE19AF3339CE57EE6A7FEDDE56D6BA1C84766DF33BF5EF8547F5DC0EF101446CE9E96BE2BCDF971C1FE9A6B0AEE588E5FB5C98BC0F3F51E7B74DA307FD1A7E5E06456C42EEC8A2C006E49B85D9111D4B95BF223E4CCF48DC12F0E3CD7E0B5A96383DA3E2FB4D10893E57B700BC6E0785A81F8B9EB0AF95D81C2D70CD50D8AE64BDEBD0D7B613C729D12A68BC090C3BC7F1ECFE582404E95530AB52AA4D2DB7DEDC9943745E7F74051E37B95FD82C27FED81A7F34599FD75C525B5C4F97C4C4A7E9B033C5025A8DAFB6BB5B14E7081C825D01A7CDB9C2EEDD9AC4B4ED578D081887A16289FD890DF90E565F37767100226A84ED080471366A92F211B61D3BAC4F579226BC907055ACBE49FA62228FC2B8E7ADEB4BAC9C11EC22B2D127F6C576D18E619C8DEC36BC26F349BD3C091EB2908F150172B86E3523995F430D3923011491B1037ED5FECAACAE13D11A5F90BF3B4F7F988CC9995E533BBEB1C04F02B59826345A722AD8472E188DFF01AD2B876E91732C126451A37D83983A21B4CFCFD86CF2054AEDE68C1DF63B7C4D51234E323F420F82469BA5567860BB55F5F41F309B01FC0E68F041E43B6D0928410DA44590587A8AD705065676F37F95C97982AD3ACD274693945B4410E9881AD9437A6FECC558F1E5A627D5D13CE037D7F8BF35F8C80B87EDDD07A941082258F0755C35E93D937B43C2465EFD42F1FBB540EEB2ED2ACFE2905C9557D820A131428E0DB3C46A0FBEA99DF81E0E9F0380F894DE2B20C427181630F0A1727830E5B28018E4242A5ACF53BAA957FB0303E8FCDCCA83D7D2B3C2F3E606AD8AF87245C943C45572BB6A6D72350A3E50747DF697D6D68C529541658C556EB1CF177A7A9D6B24F0CA5976A23F1D4ECF95975D70F7C71C61DD20844CE3AC968C26079C6FB34F2A67B1F04E7A75FC6375BAC49A8C809C428B993DDB57081C25F8C3E64F5FB3ED9C88DB11709E7F2CC44F028D0C7811F661A2A104DA8F06B451FE1463EB483857D46D2707E43577E2F8550052C2E859E965D173A1BAC2A3C806C3A8D134D7D815A5634343459274E84AF1CC418EEA134A2AE8479CF9EC50F1A1F67C0299BF2143B98B4A88CDEB512BFC9DD65B7272215E46CFD3F27FF36993A8D3473AAA4A132E532B7FBD99FF84E05DEA2C2B3F4DD91634CB10F1E3D53E71A9FDA70803129966EC7D75B7F6EC303E3A1B3BAC9F71720D5F22B6DAF17ABA82D7E77EBE2AAE79B91228364B793C943F595DA0382CD390ADE49B2DD4750D3BF093B0C2D8F5311057FC90268EA8D8F921AA583B7CE47A7FF89446964730F7982F3639F4D51D271CDF3C878AA333833BD8F3FD8528D0113425C09F1DFD2C6886AE08B700DD528E95CFE14ACBC75B2ACC2021FF0F1BEB32130B155A309B24C18C2E4A40AD6C3131D98D5A084C537AA30381D096FC5A0B08B03883B876F21DF9E8D3D764F96E152EC61770F4B6855D341FCA59222988C43B07CD4714D45B8F2F23CF4887D2AE207D7D8A18BE78B1995605CE2FF1896001A746D1BB800321CD1873E0B47E0ED96713077615CC55EED1FBFE0DBA74C538FD27F209EAE6CD95A18C6A3A164995D1FA7398B736C4B23A0E10EECE9860CA17B220B3AD062D48B793FD663DE899489D4C89B139469B787FEA4938580B50038D3B9D1116C2A55AF9F15BFA8A699588E258157032A017E5DC62FB7C768353668811EBBADF75C766F7E325886AB6F92A1D7A1E50D07113BF7D04EB5A9748508414EF07DD84BAB2737E7806012A223A7391880F5273429D895C30AAFBB75F6D0859E58942BE3D52E2D418F08EA945F58FD3DBB4EA311C695D5AA2A3DBCC70F0804315CF3EF9C0DF3D9CD9527D18A670E9DA700 +MD = EA0CEF12919293F8293581A5FA545405B5BBFE86C19DD768A1B1AD317768FCD8 +Len = 23090 +Msg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en = 23153 +Msg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en = 23216 +Msg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en = 23279 +Msg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en = 23342 +Msg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en = 23405 +Msg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en = 23468 +Msg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en = 23531 +Msg = 23FBC7BD59AB164E2BAA9FB43F6163D665AAF6D5B0C77788EF58824CA4B57F753DD20D76E677AC40290542E52F42C35234A61A7489CA24EAE76D7FA23CBDE2FA22197A0E0A3CFC396B5DF18AFBEF7D587C94EBD3E5E6C39520D87905A8AF76ED26341FB3F41CFD421C633191F47CE0062285A8535EF2F5F215AEE581CBC99F2BE04FEB3803E5BB802B65C1931B69090174633716006B352EF706A6C2C66E9E87A5C9A2F33E4BA77AEA24B9BF97BFFFA389317E0F43A6B7022E8BFF2ACDBA53A0B631D93DAA8243FC0318F0A2B83C4CD2E64BC780A145E5B6A2EB25449332AC1310D0B208592DA1BC8D7A59E07E57C8E4E1C6A9650ADB733A2C3B4ECAEAA64ED96EDEC439B6D123A19B02222FE655B30013203940FCA7A5742DB9170B7044B0EAB7993581191C3A5CB220D23BB56F63244170A78A1A7F88755F6AECF9468EAF49A082244147659E440ADA083C77E4E968D1B0AC0B54EFDC48586BD6DB043B0A5F1F745D521CF89B8000C80EC354487AE26321AF07A61960AEC8E3E0F549045299976E920A58E3FE059F60611BE71D0C1B1A30562E9E4E2319BE85CB494E732D50CD59F0002384BD1E31B01C37B53BE9ACDCA457CF1F6E41934600411B719FE49C161DB626F491D3AF1935765EBB98E7A40AB41E32856C8B070444D3BD3C791AC812631C9562C2426DC148B6CA6C432C2976B7D778E31F3FA7093F5EA82052DEF65807B0C909BC71098051556A38CC7F2DF0F5C8E2809FBA0E99E9A9BCDA42EBDB11F011E1ADC8104BF90E72F2FE661137A995D336E8961D5B4C0F98DB3B1968365133B126D0D1ECD350C75ECA93C5991386907B9D99C86104FEEBBEAD7646FE01949FADCB02946A798ECFBB8CDEB90FEDCDE40B7FC65A0DD941921CD13196B689441E7DCFC638A778F13C0767FBAC162DEE7532EB1D614AF459EBA309CA9B2812D3C1CB023E07EFD5671EC8C1C9AEC35A2F74BE83D0AD1F76561A15A1856A0BCBC1C15BCA12DF39CABE9D7B9450EF3B0EF04990C31566E61A14F72609FD7EF48BB91498FA43F7D267FF17AD0C5F90FAB3137404C26DA81340B4CACE05C19521B810C4282EA96ADD5B32702440A0C043F9DB99DAF80C4C58C661508C0270FD5E5889D39171A09118C6A2B27B0007418D77D829B35633305220CF5568836E364B383F9DABE9CA2A80CCF991C5DE5342570EAB8BE5F531CE7198116C800765F8711459423194F03ABEFB3EC067475C617E7C5A18EBF20C1DEB6B367BB3FA3294062EB897D16E55ED4F921D9201EC727E8809E68EA44C98863DBB7D198B0C722494EAA3271E7D2A50653139660AC5534A1D7481E633180472A7F41761BF0D45AB3E70366764EAE900C0E2AC952BF977732591442C10963D67FDFE18161CCA92066F8BE5B71A271057E4E5198D48B22A09DF3DD8CBB2776928EDFAD7A5AB4CA7FB24F67B2F21B14CD861B28A0F64B17A858EE690CFBAD831E681BACB73CBFC4D277A0F3B4325E2030055A0A588122C6BF993E9936ADE49C7EF789FBF48A051FA24B53BEE1EDD59919AFCD751E4EA8B93EECECE0AB02A3C2304BE843DEE43F4956C39C68CBDF173F2F3D295FA646B4168EAA3E5C60467E6A0FCD983477A3D9F6E89BB2DEF88C82CE179DC8853E8DECCF48C316332AF4812F45EEB022CE23BEC7D4C76F99A9EEEADC02E927CDF6AF02F099A993AA2EF2ED1F470DB01B9BD1EFEAA506A75DACFED486685B40855A58D3690986658E825EA31902E54C5DF325A5A11525ED12CFC9D5A82E443208DEEFD9C561317C0D1B44D3B1DA59DEBF982172D91A038722A03D250CFA699D7F7F76DE2C0B71426C3513CE268B10AA733512D6C10D65C1A15C2FE421AE67264A1E9224CCFDE99DECD5237D6ADF02742E0A65E87F007CF0586D774AAF2F3D4F8AFA50053EF77D106950C0DE55C88881A543135C42227517F7A6B8A28A4B9DF6C818A0607483AE388D811F43B9C600C1BD8E84AD7704D85840EBF97FF24F6E9EBD8641610C11BDF596CBD53F53BBC0F300EE3209C91EF706EE7368990CDFEA61CCE4B30A10B7A5A490DC994ED7AABEF0608650EF90319B1E8A69385B3CDE36BBC3CD10F4E1E6ED5C7BECBC09975E4BA0AF33FE2145C4F4535939912BE0E97B034F835263E852C9C8DE0C1959F491D4F826D03CA252DB92D88B11D3A9D56ECC21747A353C782428AA10064FF37B4CC92DD226A54B6684C4C0B01ECD01F1EE1EC8DB5387E6936A3ACFD43C8DCB51F282469068BB418E528E6097B8C7A60F25B45446ECB31F462DC7B2C2B3B70E072F8E49C9AB21846646BB63907497AC92A3BCF602DF973137C08972F2EBDE5B86F455ABD4BE489E8DC18D5EC44B3793D8B73A1EC3B505E7F1F5F4FFFDA9D70ACA345CF2ADD67AFD6C1D77224C8852CB1C4927BAD579C5225C68B88C6F2DDB9FD5FB480D58FE2B74E795E96035EEFA9BA16F25EAEDEEE09F2053004E74759DDDAC06338F2EF30A2CA998C0695C849B213113B8D43951B422DB1F1597069F43390B0FAC119E429EC8E1A23047C060C5837AAB68E721F5B1CC73ADF4A6AC1628010B40947B9290D8A5A744736B1C5DBA780BB8DE3F9440AF743413C6B2BB83A96A5A067938C0B19B5F8F674B5E92947E12E3F69E7EE4D02F8D86E380842656237700399C264FDE967F13CDA3A448567787C47E5035CA8320E54AA4CF7165A2E718A37C7EA76279E572BF0A978958A499815C7B00038E52C2D2F09E689BFAFE1501F20F98A767C124567C8649A02F724EF2F6EE394B19094EF2BEE045EB4ACFB4FD5D6716D6314B8EA18A5BAA93985EBE382B382603740332BD7DF85F9B002DC55BA998D6200D45FCBA5D1C5F82782A14D99B3E906D8CB1589614001393C8AAE3D4256BDCD7DA6AD833DD107FE06A1FC6862F4D14634367468F28EAE855C3A1AFB909F3FC223338E62674F9C7A53D1A3B75F8CD2BE08218DA021E3631E884C0C687F7CF4D80AA64415E9295DE8A81F2F9A4E0F0A1A2C10DAB9C666E4B4AC669AC28438AC3EC256783F0970E37718A41E142093B527F1D896555900716E46B000B8A89681AF080ED67DD1875FBFA8A4B7BC20B1DF28CEFAE9C4F5B5CBAF02D01CE855713D7842FA8D4F089F1B133A8324D75080329AB0B87BDD1DB92595A3A0768F04112103444FDE524F6ADDD1E108F8F0BD690D61E86D24571535B016675DCB0A221E376C20005DCCB93AD403762B46EC56DBAA3BA52A2824B199220CC2A7BDFC35293F8402C81145ADE07EFED1CA19FE8980773398E130FCA5DDCA35D4F5F9E4439748A64E287F8F45055D6F095E98A786E19BFB1303417EA89A4BA3AB18A1CE9CB5528E9FE0E160B3E693D536301A5331CF744C0E3AACEB70F83B5C08922E9AA77863D769EF22DEA73CBF1F04608D4646E55C8CDC98DAC1550C927C0AF89ABEF32CBC0316146E2C4AC9DE276D4294CB44DCD63B697F716177BB04341C0E1FB759B8A6806971E9A60FE6EB93662A26B0EE0A0EFFF39A5B46218E61E51AA337C063104ADDA97323E40C2921DD1EFC124ED70AC2C5B8DF0B7ED729767E72A8DA250ACDAB74C73C5CCDF371A2B027DA73527F77665361D9BD2BA2F66716D9EB948DBFFBE1A0D403C7DB2AACF7E404B1831CCB5D3B0FB2C1124BE85D88FE291BCCD3C3017433C1C96994165B5E46EE827266ECC2686109E93E409C02DEB47C345F3FA79E142AA90B3EE0BBA137CF09E2CACADA8C1F4AA23A5647DF1EA611E4AED40245DF4B0668C23771F4C3C29100851E862F998B526A09DF264ECB1911713CF9CCED354425A6B19A08680119449D6D696CA406AD0C5D72D491F05DC953F5D953392B6A319CFA8E5E931AC15B21710943708B1EFC7BCD7BDFBB258EC96BC14C139D02BB1F3965F01DE94B65DA272C597E72BAD291E658EC130ABB68D2A2CDBBEF5784537542FCC84ED093789D8FB2F1B3C5CACE50717BF2115B2F1214BB9694DC728B42751DA64F8E833FE1B193169DD6BB7E83DC3C56DC66B280C745FF147E2498C2AFEBEC78890FF362E03E1E697A6A90C1BD1550ACEB4F66F7A62E99CC6228B60F43B59741D2C0409F7B31C644F751AF37F3A3ECD35CA60B3DB2B0E880F333F8B879470633F96DC7237DAFEA0032865527AD4CF0F6EB5E4E3F2916D347D3E448FC874206E132BD17575D00 +MD = F76492D0BCEAAC6AE6ACB83404F99AF3A57E473CA3858F9E78081659E16D18DA +Len = 23594 +Msg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en = 23657 +Msg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en = 23720 +Msg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en = 23783 +Msg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en = 23846 +Msg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en = 23909 +Msg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en = 23972 +Msg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en = 24035 +Msg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en = 24098 +Msg = 62908A06156005A3244454C8922D6F2425B73E398D1D4199D0C3EDF24A6BA549F3DAFC76122DDA55782BB9D0CE0745CA445130A556016BE3F69CAC8D5076E9881A20D64C7716EAE2632B9DBA75BCDAF8F08CD57502DDF8A825957B3343C116812A4A95DAC9878007E65F6E567072580BD83401AEBE6979D2D130BDA6CCB86669D59625CED1AABC1803D8F5D4E9E6B6727792108CB8FADD37A61D72095370524491D5ED6DCF4563D4BBD8B582381B517387394E381D6E3BD43B466EEF003CC1CC4626A292605ED377D74B4C46D1755F25DB12FB10A4DB21BAD263A79C1F1E4AE130EA6B346D1182FB39FEC6EF202B2B3A7776A1C33327B0E622FF6B03F7F25F155BB83C3C2708CA31BE764749B17B7006166C7E4F8BBB863CCCF9D74469B4EFA0276C61C5600BD72B2B608D90559D9D8BF8736E7CD774A2655D0BDF01122671CA05568E31DE9313EEC937EFB9F44961E229980134A30800237E472C9A9E2DF07018E3425B0BCCA0CD3F50DCA6519CACED7C0C6056C304D2B34F48013CB8C1C4803020F8A2F9F73E4228A97746481BF9C88FEC4F79E4599BFF37C9165047751EB8F23661DDC9C80D8A5642161C923524E2B11D86ADD7C74BDE35D913B2FD6714203D36D56A96F31CA63B07C525B5D931234FF4111800BDAF6F5B908CB4DAF117BD0E7C560B355EF053F231AA6DD5710BC91B19A359C8E155E1DFAD50443B7DF67C794068E2671ADFDDA8B7828661A3DCD50A4C1E21C62BC5718C021A01153E7F48ADA48DE87344B61762EBEB0A18BAA3C57BCE83F28753A73DD6F8E5AA012C2A705B61BFC46D790EE553B0F8B10369E3DDFC582E1768C1F0CCFAB74B30A9DB13BF3996AE84738540739A893F0EE9F3334DB67C94B210ED6892EC2543F1B72ED1184C7309D9A51E094C667BE6D9E5520162105C0615C28BD5B280727402A267AD6CC64E128814EEAB14A5669DADC7C6FEA9E2916D55DC6E966713E8292728227FB87520DC00EACB7C7A681FF243DA23E4E773C7DA874C9F7C6EC7133D64A7A26D2C47B74115EF9D4D4F13CB962FC01760738572D3A1682AA0D7133B82633FDDE3372444018464456070F4B7203CE59443009AD68A87A646EDC6AEC58D3AB89D8108147773372F842DAAACF98726EDAA732D1FDBBFC2CF7A547F29F2A4A7CEEBABCE8DB9EFB686261AC490F1C91F17AEE3B5105CD84479778FCC0E18FC42430AB6655BAE8B4CBE1D00DA77B4921B555E929089CDB48C96F038AA0A65945B732C2D6B857BED850258672814583B4C5B4F7F256341D29DBB04FCC09E27D599E84D4E41A83627585F9390D54A055D8378F97BADFE5C80F53EF701D886639E1E5BDFCDFBBF0FCE3800CE3EEF876AB0FC6B831C437C7E4C478A7BA21B76571D9C8EC19263378ACBCE61602BB0FD9369C6B68F8ECEBC4F0E67B72E138F28C800FCAB4ABDF7F7287F23C852218C51843CFAFA5CB14E7F727334421F8954469EA9E54D53F07E5EC80D2CEC8F5E1060A3E9C3336034D79EA283EB8A3D6206F786B27DCAC94104DDAD6F1E2D3D229454E03BED99B8364C0BB8FA3E0043DB4D677185D660D6B03622C7B0A5244F3DAF56385783CEC51E18736021701301A63D41E69F2A22D20DAFE853033B05C1B7298C59EECCE413727B9CBF3B62995B723E0F83CC606BF9D5E5A624D531A578E3BB41A63089D2A7D29DF32392AEB8031566E3DA7CC48024C339AE6F09ACC8797B5526A72D40AAA7E4958C05F785BD0F93DDD8CD07491372FC635587AA44063501E117ECE9542C13FC2C5E1A996666F03CA161DDFABED001D5659C9794C1E239C274BD5E6BB3BB8EFCBF36424D7AD9ED5EDF0E006DD7B2E476578676122558711442EECC4CAD73916B0ECDCC0D08BD2551756D3A09285FF5C6CFE87366D350011E696A2865757D6C67124B2307C180830D8425FBBA71814E1F2634AC8A08F0C025DA4596799163E847026A62D00ACA42B4D14ADDB23F63A32ED46C30F9A4A1A66990A51AF90F26B6A8DF451A258E1703D4E0E5398E263A5A131EE02554DFB66CB15DAD977D435B271DE0C4704D4D83CAA3A66937C00CE08103E11C303B33621AC320EBC2C982BB12B390214F8B961E3FC5D6430079909D7C8AFBA425B77555F61393C98D19E3CF8BDD95D507AA7B70EF59B20E3D3FA61C55C901BC6C4A7E06B1F708D9016468474CAED21CC236DD30E27A48065270E402A93C7051B3871F0D55A0873DC5A1BA3119DFC2A5AFE2B741F5B759C35E1534595F691F03EE5718A634273569CE7533837C013BA0BEAA502C3CDB7BF9B8896F8E59704EA9529103490027D40366D63597EE751EC4565ED52DD5CE75C7DB06223B253A01B9BB63CC382CAD5754DE58DDF7078E834A2FFD6DEA93A32F0250AB6237C396F449676905E7B614B964CA2C17B8BC1ACFF825EE4D426856CBAADF9AA7AE018CEB5DE4B27B34DA26D404B503D48BA6609E6B309676B5E247C8A4434BF34DE811205E2B89EFA81FC2E0859BDDCC4D73D30850E5BFA212575860A61E18D19A6BF04DC901A2F52C3E4F4380B76354AD959798A4C97E0AC65BE8F04B55F5195B7B7FDDF0B58846D3A3716EB7C52DDBD0033C612147B6424B80672FAE0D2B6EB1661D8A51C295C3BE6581883D3147CCB2DC57D779450CB753F04F07703BF780B3D22A61D053EA72E84CFC151754585030E670A0DBC45AD531DA7A50D8BE3807AC5E0106EA02DCB1ABE6BFEA7C427D43DF84CD3FBBDFF686478FBEC3DA9C64E8C5D9AC89BDC1A32D04B97B5821959913AA884A893EDD1CB3CB37FD9B495DED5C1A32A3FF5D6A4DDACB1083C9A4A14CA6E1B8607D4A7A3F20D8E1225FDC65E58932563EAE101FF2D4DB744EB586EB92E3024939BD7422BC57D2A8ED8016357A21615AD4CDCD7A239195E5FC19A2C6449F4932BC5DE445ABD6B26F483810BBDA4B7713CE822B19FE656D521011CD63CB22A94EEDEBD63985B20982ECCF71ED8F4B715100CF10BBA2A9FE5F8ECD04909948B9A73ECCAD4BF9DA96C42E33335A0DA1493B7B00095171268728D9707DB1E76DC0E5E59E40CFF5BDF9FE353EAE76E9622B711EC1F1C351949AFE2BDD09CD9625F6C96B96D53541AAE632F25D3AC274AEAA63469C189373C8D540B280D9D1396FD230EDD83D8AA640D575B84213175A9EB76761985D27FCEB36924D5F4ABAA244D0073EA726D6ABDAFD25C10ACBF62AC1B916E631F05E41CB68A05360A41EB136782E5B9FE674AE0BF7649936258200923E94C11110FC6ADC6846E94503211276028B3D6A055631FB024219760FFAC12D3240FDAFAC20DFF67EA14200C7666F44148A8545467423FBDEAAA3FA0C42E5143920D42004B4FFE01541AC22EC1972C23AFF8A0E863E704D09262FA0E21D542178521DAE9346233E384BA4B21B2C407F953B21AA2D44DABC9E7C0A1C674CEF4CE2DC2C83CEFEED90F8414BB69E72329C771ED2E369B9E543538A0964AAD39E7ECDBC4DC71D35EC7222A82A1E42EC7545420120405329577DB034C3194E7A49520678F4B47C5499E790CC1531BBDCDDB3166E9B87BA8DD8734B789ED4E2761B919A69BBE8B2A3C1F2101449AA292BC29E52603D56B0C560581D3DD0CBB378EB3509AC2227CBF5CB3BF244DB7D0E38BCE12FB40D2FE9A0AF89DB5CAFA0D1A68CB823740C2092B86A6AB8DF6A3A662BD7E73B8D3328D6AC7B589350BC83A629733C823674196D87C8EEBDBEB7D9406349CA3C344ADA81F7393128E6AF489EB1C5E08E23C37970A913568B433AEFC4EDCFEEA939D3D7139752FA41FF15E3D69D72864DA1C365C30F1B3CA221FBA9C9BF2EC276A802F76D932D29D528357597195C2022018CADF61B69B4743D7607F10CEC863F8E8F88D2DD47796296472CCF67806EE95DF439F4DAA91EF36C9F9574FB66C02F9F1BCA1EB016775BFE72F912A427712C6FCB07021BA024E39D155CC8AFC5F4ABB67CF72CC6F2410F6AA797A1EEA0A8AF4F304314A499492E1BF8E71B50E4DED0D22B1EABC52A078872415A143E9513528381A9EB77E41FB400EC5837A3A48025226DEFFA51CC2680AD0222C6E968F5275C1AE3A396A1C92C66853D51BE945A95C0A8D19646A86BDCAF7CA0F74D0C44A33BF04BC457C55A1AEAAC5935F1C580A539DF71B18685A5886ED8BF48B3B085A907832CC0E850D7F34C8B3084B5C34CDBEC2B020507798B53A6FB6DB02B2F03E86D4CDE00F7816BF95D6C9319D6D1B4889F4D6A98E85AA51DF1A3F6733A4DE29AC947E5002D4D0B00 +MD = 73527550BF0E1F643BAC04D7928646FB5B1E8FEDCDBF62FC3F5D0F2271411FB0 +Len = 24161 +Msg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en = 24224 +Msg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en = 24287 +Msg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en = 24350 +Msg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en = 24413 +Msg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en = 24476 +Msg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en = 24539 +Msg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en = 24602 +Msg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en = 24665 +Msg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en = 24728 +Msg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en = 24791 +Msg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en = 24854 +Msg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en = 24917 +Msg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en = 24980 +Msg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en = 25043 +Msg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en = 25106 +Msg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en = 25169 +Msg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en = 25232 +Msg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en = 25295 +Msg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en = 25358 +Msg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en = 25421 +Msg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en = 25484 +Msg = 6DD1DC4FBCEAF50EC30E5AB7AEC93437CE244D3B52DB49347E88F70FA69AA63C6504BD2473B2411AFED5E87E9C1EA8DF1B9990C49A58AF44F8AF616B6338C1AE432F93F9031EB07E87240D0649E49F1F92523A84B4F017753D7C3FD11A2E12ADCC50CC86F6AA5B6922DA39034A13D73499EB11F0B4A600325BFC9B221D625A3B741ABBD51D12DBF3F8EC39649C7135DD063DCBEFE65A1A07F60E8498462B70A351DF4E50774CF779425E6833D3667BC73E510A8B7602AC6BBB0B32D041513AA1750BA4DFF7DFD883D4D102399BA634575ACF6487F54932328BFCB2721DE35248FC37DA883439BAD9E953DFA9B38C60AECC94F233533208080B80ECFEE15F83F96357F8F76F36F956B16EC0D4192DB6994822B1C4A35007DEA68C4CF8777481D3A88EAE7FEA967249591C60F59BFA66869DB01A6A1565911E18FD2F9B1DCEE640801A6471E68435394687D3A773D60AC0930312531B57B01AE682972E6CA5CCDD4B67F7C27382DF42C36528E3A4BE5F692EFE2526A85162CE1EFB45ACF4588AA1526EBD7D2D914A246794D4B00DB87B652262976FA34106A6DA0D5A0CE0FFF47DF94BD03AD6E9882243E93FBA0E7EBAE78E9A394F0BBD1BDB977F6FF7D4AFD626120F97DDAE282E58FF6314F124A7BE2FEF304A598F822CFB4DE879782B782F53B543230102DB46EFA550928071630419FA43D6A807DB14322FEDAA277A0C139ECAE21969BD0F2A3B062ABBA6700A02B3538761A1DB9ADCC96CAC10083C1B263266E349F9384D9D347DAEC37CAB23C1D48B2250B4CEA4FC2D1EFC2177A770A53C61BDFD5EBED6464C4B70B03D57491F2E050ECBEAC8B0E54A67B8A87B83C4294C5D5FE4F3EE565AB859E21DBBD25053EEE0316A59403CE9E57CB02591FF60F0D1A6ADC8FC02AD3A1846FC3E61425B293C9E229DAB5731A9C4273B05DD84C1A226485E6BE675706082848E3EE84876E14434C64A83F418A48C7F5F5B672A8A6CB1622C7C996AA8BF50DB9AD32FC11E8A73AB14BC72E2C9545F591DB4370876B1A30351F456798CD27933B83F6266ABE74A089F38D1C184FE7D11147465CD0C01C47825F6F5062879878AB4B588FF981A7A6AF5EE507B6513BFD6C7AE50C7FB576DE698F2EA28FE7681B91D482F271B5F91A40182C1B9AC2A36C436D02CA6966E3964D9A0A872DA2788D8CDE74433BA25163534ACBEC6CCBE2F71D09B4F998834391B683B153656C71253296757F7EE2B44B14E508F4B20C76D1E1B7DC0F06AA490E93F600CEE71AFC02FB4E469ABED68DA4270FDDC8DD147F03E488FA429F65350F1B3CB351DB80E8B9D3D14BBAB48077304B53C1F57CC9144B65F9A0A7ADDE678ADC81D4A5F2F44082A4665976B5241FE242ADDE6DB2AB022DF7BD839BF0B058B5BC9636F3E359A3D8A6CFFF21B2ED643A0D9F617FB57BD7E4771413E865AFB90C77077F5E0CE241E0B3E5E526E45810761A5874B86899C5C39DE71218DFA11C888EFCE1D1AE80E1BD09793C698B6B0705B98FCE39331876316C49FA39545A05A52B8DBD0ABC8F3B82F1A571546846FED670531530A232701CB337DD970EAA02FA2ABFED2180D9ECDD82F8505BD2AF003D0B139CB170983FCEF4ECE5E64CA411BE0FE07976746A88F2A82FAE7BE94A158C0394EC1139403C280B3F6577E1E3567F812414F6255DD7625E76D238D0E935ADB804B0DCA60AF7ED1CF0D7C0BDD66308A25CE6C94F516AE816802240E986A6B6144B1721CF7A02EAFD80941AC151C1C8AC28D0A7F255D9AE092CB66AE67A8988D21557CC86497D8C3465323DE44F1C85791EEF92644B51307292F896584046F2AF9DC2797279A63F9BB3FD920DC632E321E177ED2F96E824B060702E43CC167A7F63B80A5CC31975CB4DF56EDA691DEF0F7A1B41632C5740EA3B00A217CA8AB80970B240567E64DA7F141163981EA479E37FD5567DFDBB078FCF9A342AADAC6D665D6581D58950E882F1EEFDD6C297C9D282738F08B075E26D37C203C310BA86DFA1AFE83FF1F83798B36B48CE724FF2FD146D68DBBAE57CC08480171D4692B3CA772ABF0EFBE4097EF18196522E6EE9A64A1EB33FF200C34C185FDA218B187486FE63F00EE2142FE2D5D5E445AE7DCC597DCED84198C8F0E0B22C3B4168AEDE29F61EE7B1AE5F1780400C8BE834197D0C43663E4547D2BFFD52DCF8A6AB67B9C1B9462003907EE91F7DEDBB839ECDD677EDE6625E9BA73CCC2D44570259B4573631CB2BE7C38594C5A8BCF2E8A5EB956E31FA3B716C7503131A78BB29D06D416D9E81BF5DBF5C83856BE6C7E97C2E4CD7EBF8E189BEF059D221F88BE5EFD6034BA2D8338F52482E85D02C81B1F9A9E18D6EA89E293EC42CCAD0864E3D61919C7D0837825665E0BE77BF94ED710E2B2BC4F49383505AA27839F2D067A1BC85850488EF269EA67DCC21B5C1421FC27DCA8764D9B40214B4E066F8138A3871D6DEFFDE0C1579AAF6B4851F6A348D959ABED63B5FCC5BFC139D5C0598F0B965552DD58720EC6C3E3C7B1EB8C29596DFCB388E08BF5B83988E78A88BC9CB9EB7B6F46A6B1CC8BC3536958C635543E5C562D8F4E0620C4DC0AFDA711C5F50907771993E6D1A1F946B90DBB541BB2709C0CA2B981D546149E4915199EB0460B8AB50186996A7B83B54EFF9B03C7E71DF29CD90E0AFF93AC3885BA08E51665D781E6497103982F3CFC401A6DD51A6A2A2965708F6A97CFC6D5813C7AB7FA996056BE5E78E46AF182212A843DD2E30B4D3D42B57E4D61E03AB5FF3CBE8FDAB99806985D639B6D49C769DF480E856FD8592D89365E26AEBF3612C1FF5382BB4F2F98190DE66E4967DB784707E1C016EB57EC7A6DB2B995E57348536D152C49542373CB309F7B508EADBBDC9DCA400A217C9BBC613B639402287DB87E883E4CBD14462036E830FB4E27CCF60CDA2FDEB35F4FDB592A3B88F47EE980632FED1C09E2D24CE497195314E6F94A966DFDA7A531769A92020AB5CCD63729E188F0A8E771AAE0A5190D30E1E9A169C8684ECE97FEC2063F3E35B541D54345B6E805D2957EECB89D6BDD88412B7D58B192670E895431DC997EE75D6FB0C3C74B14514912F81ECC67739C10EA60888D4A582AB92BBB62654B49443EDB6C47D2441576414760792FBD1C512CDCFA680DDD11CC834F2CF6A9C0E2B6E77B7587A4DA168D141327B0A6EC9CAC946D614ABC1CF22362908B90465E4DB03BB573D21EA5F3035237D35BA951E992B69C8DCC5092DFB8C248C1A99C69E4E88DD8D1154914AA63545518EA5F54516790234633E0A0B757C9D7F22F7EA32DBCEF26868F43F375FFA6D95F578FBBF993CAE8BF2F2AB9FB89B7AE4A3C3CF9846C85F4A4A2BE608B5941D158E8D867ADA6F1047D7EFC01DDEDB27B9249277B709E597501A24E49FE294B0DC7402D0665A80B35F04866CFBEF45ADDC416728965787ADCBA5AEC1181AB924FF3086D5089E2CF647F88A47E415C34AB734CA367BEB57639E8BA199DFD53F8D8AEB4D1CBBA767A3ED296DDD89E173C980AC73D51D347CC34697677370F96C3DF6E21F49A919DCD536FB19747FDE67EE89B77CC41FB78AE8188E7E353C6D37D80C1CB2EACF1C618DDBA20F1AF0FD71CD95B203D56C80D410E0872256F64A19BF61F701FB5C03A952076781336E242EE4ACC7DF02F4915C47EF8CAF863FF999C0710C891CEE92DF62C251305FA410D9B224EE8B8300068CCAFCCFFC7AF0BC8E955B4824D1B200EA52224BA2C4D1DC2DD668BFA592DD3A00BDC28B1076BD70741F88F9262E147DB56BBF3900D37AF47CD1D30B3B3FAC4570AF8C7BF02865CE61BCC95EC31B700C112A2B92E4B0F7030A08DE94EBEB38B398D31D86848A4F4917FA9BBA0C06845EDAC5E28898227D31B4C44119208721AF6D6D7421170633EFC85CAA93C72B93A0D6FF681DCDC6375CC981B45B20522A4D516B105202E296591ED24D57ECE52A4A039D322F7089B7F7D4F13E4EB00945E3D592C6365E651A9679D1D9D6B548DB1E3C9F6CF1B713904F41884621F3B57EC4D1886DE29261A33721D30A758F5339DC287B0F7640EFAFD06A74A23D98520DC33820268469180AFE764D01BA5A48C0AE1E9AC685B382614DB05BD191915BE17EC01E1AEA8BC737E11B2479428BBA56BC79A956D89FF70D397A9B429D27E01D55060BD915BB09051902C8D030F6237677A9884DB62F9927F05ED5AD10934FAA9DBE9334CE8DF778D257BD1997044A6A97E83CF714AD63F29F5996F8B36E4B212D351BB8F96435097321CACBA0D1CAE4F6E0B46990F210AB402BCC08BE0FABB42AA76B5DA9E48E58B389AB9B2A64542FB794290CB93581FEA4FFD04A13D654ED7899C946268E450C98BCC9BE517B2D118156E3F66DF7B6B50375B723293C90A3FD9C751FF3EFB535C60EB121037973974A95FFB622E47C83F94D4C611A856DD94E4592E4D3C34EB224B9CA6A6F89F02A8D8FDF7F8B8BA1183BC553FEA6078E3621F25D22984727B4FFCE0D54EDE5A3D39F0 +MD = 6F04979674B366F0E6E65F72DD9D9F8A71C4D0FC0FAE66EE43B0D8EEB19C80C7 +Len = 25547 +Msg = DC722C44A89AACD669217E6D423B26AF59D0B0090A1CC35B8D50939FEB3864BA77BAE3CFB30D7B05354E80894812E9563550BFD962940D535078DBBE63ED14128C41CB47AEA5FD1A0D0F15BBAA0BE6834BFA60A6A8C2CADCFAA62AEEF2D4CE4A81FE1EA7153F07CC8D3FE429C40B58A981A0CA48C5F966E09CB65E52A2F2164042B6E8AF71C52653C0F9B0D4B6C276809A8423FD5D5796EF5ED3783842ABBF5EBF83A479A1C25BB3D4FB66623EC2B72C4D1BB6F55123437228F1B81056C414C34D9D57EFCAFDB9CFCEC7765F57681A3544BC763A6403C016AF8C343021CC2D36898986D25564DC964A2C06996AD915D3035AB1A6B1441EFFE74385B380A8E159A3712BDEFC30DA45892484BDFB14A32C0A67F201A6BD0481512A843DBC0B204C5B37FCBCF9A7293CDD0B1C0A3E991608B62B1C02B1CBD1950384F42F5DA15ABC00EE0CF01CE075E64BCEA4E1E82EDF4DEA4F5AA8CBA1FB618B7AF166E0EB181C7B43352E33D64FEEEA7894C31468296A9FB4C950FDF7C9729E4C0AB1CD1C9A486AD0AE220635DB51584221ED0E526F8252D533DBD0AEED406C6227540E2B9DB7CE66BA8ECC3AF5DE2891799AE5CB93D81BE1BEE42E96AF038EE86F2625683BBEF784E04B3A0EC74B7AA9430EA4B4F0B27B6FA445E34554C0F4803E62553E250AB164BC11DD24613D6FC9DC529D74E30D04E60C98802241119A9163C1EFD7E4F686622CF3AAC97F67968A261CC4D1E6D91D3E327E1086CFF8EB464B4017E35CD3D208C59804156C0C37AFECFE4EC71D2B61B303030AF103CABB1A2134B3492352E44E4449EB42EBF2375EB549131FDF2DD5CFD2C3A1376646355105AFBB21E8F808C0FDD7A34B612F98FF623EB765097F12B557F4810E86B198138F510D75D66F3A061A35A9E775E3BC04E06671E5B282E1B38B5BF4A735B65986A7D176D35978A46911755144256E1DD45C946B692586BF21CE9A1AA08131C9EF441A7FCC5F2E0E338E27B027FDC5B9894E403DFB5CC9AF9B719D4D1252FC188A1406B89A86D6E11E8B049113CAE88CDEFC8A8E55AD21D8A77ABA18C9598418BCE3DE093540C4D555E3046C7A025FE14F85F6895EE9325AE581AE4EC4C14AE0CB2E7EB7F07553F9DA5E85A82FF1FE03026B581BED4346686C0657C165B039E8B5ABF5EEE80A94E44FE32C5A28A2D74E1D89C4E3A67E00A90638705D8E93ED597385D506280A92E9903A140C31424DB7B9E7079CC2F6828502DA136829BEE9E49C5C697C29B4B3FEF510872B5D6BB6D956125BB92333AEDF4201F366DF2987E2008E79F209CF166534E62BD33EE38941D5C02150859213F6D3B8952C66B11DBCA9310A5741622F3B89287506C28352AC791AA6CBDED66FD0AB620F1F4FA8E0A6AF38D4C6700EE14D539C952C5E6E3F5A50F71AD823DB7FA3D6F00F444E6C97FCCD8E1F842645F1BA64AE5F7FA2EFC13E7153EB587DA40D9F0552C46FDB4024857E59934836727BA64FC5BD05619A2FFBC13EFF6BE9B5FEDC88179F3AA650E2D022DD6B5F022F736F9ADD50ACC276FEF807352BABCCE21C2E23CA45038CEEF0F7A4A2DDD48447E77412869729C3BC08C8DAE7740DABEEF7A1FDBE3222A2DD0FA6D266E1455B7B2E68EBAF285436F4C17CEAEB8B040C40FB8C3FCB62325FD5E75F81E4526E19A5CF77C575B579316F3EAA4C2E06EBF9348342451B163BFBF6FD55838BEA751290F118CC05DD3166D5BAAC1D1C8B90B6EB2FE8F1EA4E9DA6150A291BC2B0B717252CD6EF42B3B37F8A5E91BEBC4F1601315E19C0756DCBA6DD1B582388433029F936B43397D9ADFC5352E5995FA7DA02C686EC4CA515F4F8F92D705BA5092D1AF0204AC1038425A8D630F88856FDD158494565FA981CDE5B8EDA9113BB1A8B4682A96C11CC95F8E880A777CCC531B259BAEEA9358324CACE17AD8474E0B2347D8C6C1DB67ED1D8162F0ED03CDCA89E6458E7742258C5B80549AC83C02341DD8D6220B062F234307288C8644F68189D182A52150E0970DEC733151B16814BE8C8AFFF287342A58B55138DCD03932DD549BAE1D01C397E769CAC292F325DD02264156655A60C9EB88984B826C479DEEBFBEF085F56AD08B33526D77F4550AAD9C054CD91836F5930B81462CD658C4F8102F926B06DAF848FD0E58C8505F79A358C3995981BA568A7F2A74DA3F342D16E412E91C8918770BF255D317949DDC880D07BE59624F4AB21CDA0E098102531B4DF9C2DEF0B3A72F4F9891F94EEECB1BF25565603CFB62BF560C7D5B1E4108F8405FA50190FFE99F339407FE20768B3982F9AAEEE591DF611965DC2A564CFDEBF9D13D1EFF3C8B40AD3EFEB876A64371CAE3FEB3AB4CB9EAC3113B67ADC8BE89A14F1D5FECB9BE9C8C40F224324AFD9F1D55FD8B3E066F68A60E6C7F2B48D957C66F9D73F7E929AD47EB4C98539893C61A2C09284977B8886E826C93FE2CBCAB43D119ED7C19AFCA878514D9EAB79FA983386ACF968D0514565F68D0A7367665827F03E655F8EDC9D99D218D4AF956A79EC288E45B61EA8479A436EB2EBD79702BDBDEE984D08964177E91DF5CE8354818F4D216EA77DF2E951159B36C32AEEFD684986C628AF7514324060D5E79764034C3C985796DD010D0E25C464B5903CBCDB2700E06997597E5B2525109D5C8ECE1D72544DE9E44B127407CE4EB48605F2D2526C22777FEFCE832EEA265FB13EFE7D6CFCD41C351BC7F1761049407812CCBC229B9685534A4EF7ABDB02C8E8D8F4AF7D68E422E62B50ABDDBF1A0CA36F0637CF03C901A8FF12F93C3BEBFADF1E4AA535A44204DFDF24EBE5A0A20DB0782BFF45719C4DD9E25A839A9C4CDFC75E4787F184724E1EEC1358BBD28E44EF2F3429B55E8589B3AE87B75DAF3F9E15620F07F5E02192BD405366A8695E806E7E0A8DA405368893F8B15BC7189F104B86D0A4235042ED27F744E194ADC2A244C32E4D3A12CA65E13C2C231936A8D9C1AA229159CAF6089EC97A9CC531D846D16B2975077DB14584561C24F37EAD5AACB9B73BB188C7F7C8DED0773D547498FECE6DE6FE65DD4E05755DFD973B95783F1B6D7093FD6E69954F6AD215F018F5BC45B47B068B0C03367864BF3E472B0335A5311E79A9DFB5AE67BE50845E95D58A1911D80E86FD24B0A4B4FB7B50C694FC16C5D09F1137824B54B0F5794229ECF1637A88F140273C7407A4A5DA654AA10A318A46784299A1963DD490A7DC180374D560FFAD5B72540ED9C9915BC34678E22BCD9DD71B512E0CCF2DE35C01B9AF26F3D2886DCAA9EC0ABF40AC4081C760A0D46962BCA25DFAB141398182DF905F4EB0EA4B1BB3A3B7C8A562A3AAA099624A216B30016F1C4A4C71F9D39743367E3D522CC1B702F558C5516D9B348D5C8178B7C182C16B05C1A60D0F28E283CFBE614E4D414E06CD1B539466B738FF87959CD525710B23CCF2484D9D83595B2D2F68D181FAE3B351D9E434748200808D8EAF6B580FE0D3199795B181394EB0AF42F12486A7DC7A68CB8C25942A348052688AD73DE5FEB2888AD9E85B4A91866009396AE33F35FD615E06FA1C5EEC635E01CF9D91698EDA7957C494897154A69313AB5F801F93CFC097687F88696331C3EFDDE446FAEFAD79BAE0B11C5560E798CBEA9946B72F6DA5A847A08AD16A191F38472C59BB751DD56145769E3BC2CC94E42BDAF00447C885D41D406E2A533469EDBB57C5DF4F606D8123CDB1A4FD574BA847F5BBA04DD567D4ED63A25B33204C3728FFE1BF0EB147682453A5FD07FC3F9A651257AF020EA956AF776A3F3BF81E6F34214F65B4844CA937EE95B36182A92AC56797FB0A48741BA48CBB85E180DE0680A9CF6B4608581646CE2855277AD3AECEC2E8E4905F4592CF42A5D021BAB478C4BD1E6F0FC19CE738F10B34D2B33C373B79D14EE68104C87B6A47014D9117B4A460750BC60FA53BFC33E1F89E86DAFC2144FBA305E6FA6F3A79EB5F62655C5C8AA8A3CAD9E04990681334AA6ADBE72BE224D72A8D04954516217CDA5C7480AE05A967DA6DD0B7D092F43DF5C2D88DC8FFB45500030C2185094CD67D9BC1CDACF2F67024CCF2460C660BB53D7BAF5DE17724C90F2860A9632A54FC7ED78EFAB4AF5F2BFEB53A06393D8B41876AC468A307E5B8878C452AA53EB4C3E2265A7FA0B2DCA50EC620A8A645E8E99DB6E298E32C018710F784CE11605423953C87BF7BA9421A213D5353A95EC58D351A8D3ACBBDFAD36709C8A0A84A17F027488C63A43D7450DBC499666B7047639A69FF1C1308B6BE25663CCB90CFD6A32AB84FDBE5BDD92CE87FF336051223A7C47C136CD061554210368D72378E798AFFED313BE3A7D599EDAFE18BA63D6DF53BE61C951BA61251DABFD98187DCAD7194BECF713FA713C3C987B04C328267C53CF6463A399110192C1BFFFC2FBE6AE701B8A141979D74D8D5F6BC2F3DEF2A1847C3593BF7D73D758A00E3A463B2E830D82E1E428276523271FA24B1CF72073A19CF469D98A1958315B47B265B92A16138E360BEE0 +MD = 6E16AEBFDFCAF7E9A15247BA83A797E4323371E351411AA6C61D5CDB2266AD80 +Len = 25610 +Msg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en = 25673 +Msg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en = 25736 +Msg = 858EF34C28B8939BFB4644D1E458A67A034B9AF9F82DB786892D81C343D27B96EE49CFFBF2C3419EB11EFAEB9F8D0410B0EB688156654A8E32EE2A570C5A88007656A18380DF33F7756A6004766A6B96BB27A741057A7A0E22D732D797C488EB613F179DC3F1094B2B5C8E5A34BD57F26DE85E234FD894A2D276E8F31D0F7F23E570A0A4E13BDB635CC8897282A1AE00CB0C8F04124EDC6EDE1404272F1BFDF55AB2A0B3D5B3534A4C01CB0E1D5750EE71328FE3DACCE5420344108996B6DE1A443834B6BADFE616534EAAEA32681D57A2E41C77173D6DC0751DA26A17731B01833AD0B9C4D3B48BA23773AA6D2BB7029377F453484A44E6734A3ACB3725FFBA0547F1045F18BACB1E9C9C801759B9A16209F0158A4E8F21CCA9112FDE82388CF1FE58ADFA1F684C3158935EDF9388B42AC0E5B3B68E6E6A4D4476C4EAC78F166EC5FA464B565D481F57A9D263BAB7A1FED05D737974C4F7BDAF2CE5BA40B2A993E867E5844C7750014E66BCC5BBF5E500402529DDABF1EA2E395DB084C4BB85766FDA993B547788FCEF35381FB16AF0965A08EE5CBB4D68C934785594B37F78E76A6558AEE73E570E40CCC889B0D5269756BC40897EC0C2D6C33A33B1897AEF297F377CB58A7A1A389EA60F4B5F25D1305D046E48D5BFB1083A82C5AEED09208FF83076367156B9071BEAB5AA12D9DCA9F8AA093872C4C95B84CDBB0B84ABBB03F33B63A7C603D723DD9970524548E61F3804B7A914852AE55D377E25A8431B1E7CE78F1294664925D62B7D8CA3C880C4AC80E92F8E86554BCAFCD39CA44CAC017F4C4550BE119EBDEC7AEECCD527EFB478348425FC3668141607D14DFAC90451B2996DD46B23683210916B90E63EA2A4A006BF72C4DBB6ABF3D0505379C5B360966A25471E658EE24CABCEBB5C6ED5F8DCCC84614D64BCA54F35189F579C170F2A2B773AADFCF3C1C435885D0ADE7121A4D2FCC96AFA88DF6EA2C519A98AB279E9F75400AB053D457ED3FF957C20F282BD121EF67F53053FB4963D08F70EB287E011DFD015CFE492ADCB927BB80093545014736A12E236569ECC3453350A5E57D50B1BBCA5C8A01A946248370CDE6177D7B8C84F11EABAB0C3A5CE654FF85783EE8EEFEAB58451CE73E164A9DF47DCDC9ED24B0F7A87E0ECD1A3DD15E6D656B8945F096492EC72C0B51D13613B3134C3E31CD1A3093B8023649C1B3A3EE8A09E5A8D612A91B4B14646E22D575CC09348A5A58E0F9B641037D7B63D32B40EA5FC16C55A0875F3E64F25CA97F2A70DA0F4567C9626030B5B8463D8A55C34665481F2FC308D2B87111D23B1B6CA96013FF033B23216C27C9D2E1222DEE25B295E180CB6EB9BBF72F59AEC070AC809A79B3306E0BDB701521D4DE1D755F75EEAD5D79A72DCA55B6E25FD10C4EC68BC5C585AA1C392DA26BE5DCB75CF2FF4B31C3C578F9708191F59D04C2E00ABEABC6B217D89BA9BCD0CBE76E72E316A4C7F18AF642D9FAF3E76A6E4F4F5E80E1252E52F996DDEA279BAE6D88EF866AE6F3D77E0E105111D04D4145F09691925CEFC2A8DF96F0D340AC86C0B48EF5D18EC1DF59748BF5F261580ACDC4F58CDD2C2649E4B357872DD982D9FCB59916037A8247C6E374F0CEA924A25ED9A0B5DC15DA9AEECA8A9A9DE9811E1DCC4F05357867871B959AC9E1D3C4AA2633C9445AA2239D02E9E5C7D22FEBA47E7A0332F025E83DA06EAA82F30ADBFC8E1167391C6F3FA82B87857DEEC2F39D08D4AA3BA59E1598B54D665BA68438FC7493B351AB54B907A80945FEDA0ED5ABAC57584182E40CD4C8B48F61987A07AE6FF6196E5435324B3546F7712BF453A1F31CAC5778F94647B656DCB4FDD8B58AD3645FA1D54FA7D8EA1B627F65D68D40B9256778B46950CC2D1E4C3313D542105A3476A7AE2E51877254BD756E7FB55A55526A32B78C95ABD169DA1929CB3A1A098D246F029AF5DCD0BED4546B2559A6A4739396C2E222C77CC4D3AB47262CBE363465CCB3223452A35B91C15D4F2822FD75A91A191ED0B19EF0D4689A2F793D31607DDFAB5FE0292EB3126C6729B37BDF4EEF808A1A715982BEB2F9D6AD6571D2346AC4CC75374B4641A2BE62140DCEF6A105EB3AA593207DE595C439C8E94E8596F8D995690813B897F150670374DFD9BA0588C7AB7603958565BC31C274ED42DA1BA94372EBE0B4F08611DFE26127E7D05AFF7B9DE63B360B8C3E79B0057F92B40348C4A6CF8C238BDD33C204926C342170D9C15DC3D69C7E61F2A94807A4B84D04DF599411C11DEEBEAC243681FDEC8BE382EEEADEDF61F728646FDF9A421EA231FBBDE6613DE7A4F7BDA125AF5DF1149ACCAAABE2C2A01841D24E165AE76808CA9AF94EFFB1CF3B1E31C765559AEFEFDCCE122BDFE567E67C970E6B40B468DA0AD6B82BACCCDCB293722450AEAAE801A342ADC7F1F443D9935F5D438A16361A087228C2E26C12CB59BC98774CBDD9B49B2A065C8A767334CF16DD2717CF45A0C8EDE97B4F4FAF99ACB013B5E0079F2B3A6A2CB82B611DC7818221A679C007377EDBB9FD0A2000B32C6A17E1B0BE9B91208EDD3E417E631C2E6D23DFA763FD792972F9A9B1C8FA42F0AF5297EB49B0776BAB810B6856E0175EB1B87EC83CD2CD12E2C5C1610E1EEBE9E665A6C3467B870A1574E6F2CFC865687515D8A35F5E90D85138C3D2C9823696E25317B1BA5B0BE623FDC6CAA1041374D398578167F4352F315AE9DB4255A32EE4910F2742633D79D5B5F105ADB63B0A3D776350B8574477E572EFDCA09574445ECE8DD6382FC21D7B9D68B3A4BFCA158DF4A7AA4CC1C0DA1016C364C9FDC62ABC991A3504EABB590809B2D41E4D51CCBB0E92E8752A4C0F72E74CA7E45EB1968191D564D813131DB2B321279FE7A104ABC6E33FFACC553D0A62D69ED3CB67798BF8E927D4DB02A35334E9466052858E6828E0C28540880742ED54923BAAB85922E05E0B66EEB401453C82D5B4D7FF25297C1F9F1358BCFEB5D5294773DE203D7F2FF9FAD19FEDCE6C12896C1AE44ABE0905EA80D24BCAAD927AAFC6AFD48DDE526F3DDF4E6CF94EABB9E99CA6852360DF3DD2BFC7907E42A35744BA720FB0F366EEDAA8E86E44059F64B384E296F00ACFB469472AD01232E4A4833D11A2CF097C75492E2AA1FD7E425082195BF43F4CEF3B3477D16B606866F1AA62644F1A31119B9BC787ECF70686468A96AFCCE82625C860CEBE802C270605EA003B2B40124E8CA4EBC78A9CE226CBB3AE74A7FC829F53A51D925038CE9A3D3681CD50DC463AC3488C981DBB0ED6E4BE127CD3AEC473765C2AA762611A641848022E33AE6B5A1BD57D17221D172A1775AC54DAE58A1B0E21C54853BA59BA46CCE0C62399A547DE37557FF4B6694B86FEFE062AF6EFCC103C4A1A2BD06700E8769E4C70641011E5424C2A2F0A6A2C8EF989774FD59C0800EB0CB19EDB51B69E88BF4FAEA43F5C2C2818F9B95E27BC68F60BFBBBCDC778C6F6B116333DBC17DD352E2E97BFB5E33EBE9B3E518F93E86067E75F064A714DB634E37CE71D4BAD65FE2BBF326EA2793C87CB44572C965AD6598312BD9838DFA8E1B599CCB8701DCB397E8466A8524B568E77BE95CB96C79A64DC180A736A6D996EEB896DCD9D9AAA8B6A4A9AEEE6F213DF1A071F6F309C1ABAD52FD477F6F707F876F40EBFF3530195EC39887E3D764488EC4C7618FFBE79265EEE08CB809CDBD0F7D38A8A2D292822661C2273D8270D1E0B2BDA7DBF1362349A9206BA25C0DC1C668B39DB7724E29050618E43BBA05F50F202D9A026894EB20FEE7D6FCBB22D7DE3EB89EEFF428AAA1B3F18A9847FD5FCFE6AFB9EAD2C864E0DB5C0C7533E574CFCBD82F14DB20F851979722277AEB0EF579802336C90D3BE78B47DED5C829E83956FC9587ACD1B0157918C4A1DB3676E4001F068128CD4C4511385F4AC39EBC687AEEE6EC7D7535391062191F86B4A2F1818E6D1DDBB24E1E7CF743E399106AA1C39E52AD7EC2BE7BDFB32B54E923D50EF8AD4EBC6A80C65614EEA4AA5D07F48FC597A29EE20026DEF2F300C7D3CA727E8857A098A0FB22F2C6757268E390F839BE20D459830A9E3DAC71EF418215D9B89BA559A80341E1590DC964B8A6ABA07FAAE4A9AD8E5969E9471D53E4DA76889AF5F9923B18BB584D71E30231E0EBFD9FA4891AF34007C1235A9CFB2B0DB0EFC1A5417CBD53F694C6F3882E8553A0E01F7AE34C24439A97DEEACE8BDD2F59515DE0760589FF6230D602BE3893D27E34DCECCE7B8E310D87790FFF49AE5B530FDFDFF71E61BE2E1B90D4204194EFD263D1CCFF4584938C06666B0AB675A6CC5CA0C6578851730E281C107B58A27099647541CB2B9C46626662451137BE1B34438ED825C45628D7DD49303770BC3330E5E98E9ADA7A1CCB694EE5E00B27F7A5AA000D1D9D1F7614532BA4B8AB8A92367B6946247B5F69F870DE10775325C65ADE56A7D063757371739E053E971179D2BB6517C7D9F8EF37A78DD3B9D15C9D2F021D4B81FFE9437353A965D79B82177B6798A70EF8511D27FFF215B741B9 +MD = C8D65566E346B9D8D5EE750C13457D0D5B18223B5A92E3A5421DD15B3349FEEF +Len = 25799 +Msg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en = 25862 +Msg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en = 25925 +Msg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en = 25988 +Msg = 94635722F1305977048671311AFBCA4CAB4339C371280239207DCEEF6EC7FA91ED4D40731443C4A77BF9F057F8D49DB113697583D1F583FB7A8410B05212C9315F1F4A3C4CA33C47087861771134335D4BCB96628C057471CFCFCB07A7265C078E0B9664E03FB2521704C720B6489EB254AC6AB1524732F48BD7389F2FB618A9EBDA8B0BF0EF33E11BFF5B4F10BFC6605A0E82BE6AA259848C19A671590C5BE0615F4264D63FCACAF83F4F672A7F561749D2F006464E416A03B82A436094D7FBDF988E27EFB01278F1D97C9A8F2976C92ED4CD6DA07A247F8ACEFC26D88E8B3529BABB4D97EAD0D2A1707F83E0B37FDAEDF7B46B649D6AEC1EF8C67387C848B8F9BFFBE7F51B22E2A585BC510591E576B1F903185A412078678170E0636730A4E0BDE9A2D99BB5FDE489B781FBD0E5E48538EA89F330E55D74EC79989557803EC236478AA45741C2F5AB4F3B27A16101BE03437BF93B3647DDC964B528C6CD1BD9B8C411B6CC7D437377FCD33229CA1660A7229AA146B5F4398E52AEAE6A2874359B9DF46FB29CFEC99FECE4CE6457702E741FE00A8B433AE6A10A3A2B14E95EF1C6ED1C7B616C0731C337CC10874C12C1C23557EBA4CB05D01025DE700EC1A5CF35C498BFBB64960375AC632A283E7218C5F1020EDD4F3AD036894062845FDC82CEAE303B67ACC70371C8DD7C3BA21DE4513CDCBBFE7C60D4DD5902E11C379AFBB91360D72434969CF37E977580446219E37144F0E6265FB3FD522FEA419FE0D77A4A9F965CEE8330767C37E758C7793D9EE9F29B2B6329A73943E19ADC8955325ECD3FABE65EFBB61D0858B5DD481E4F26FFC035031CB129F1A8167C020BAD7A80B225BE296E027DD4756700A311686FC3D1F31EF4E05942C457EEFBD831C6DA11BF8FF8F07004844542C17C0016163953FBD25FDA0EFFA292CAF870762B14DA29A4D8A605A39559DEF8402E846082B989617C1E07B6EC0209B2AFB81EFBBCF67E8E994B465CAA03039DCFFAB730BA6246CFE028DFF842030C3AB6C7CA9C5209562A1EED115FA805EC352BD24F7A40258D6CA455357A1F935799304955FD6BBC88C4D2143C54259DFF9191E2FE0E99749C5294EDFCC29DB194D20A00F26B7AB1C9D1152D1879B6342E0A2C8304EB2CBEE14F65938131DB71185BC6710141A7E20C3BF0F43EE76577A7C5A67D66959E556559255066AA6AAFEDA1271A7E42EA8FE75065EB3EB4B8CFBE42E1B34C2DAEC266FDB4C566F764C1AFFB806401D266DA00F41486ED1D2FC1542DE8B1DA3E6B30360DD8D5AE2476A4ECE0D6F1E6DF70AE91409E54559C0AC21488EA47BCB53B1D3A506A8FFD729EAB634C1E7FAAF465A276994CFB84060E5260A54631BA398674D9FE4FD5F446225381E368F290225104784E695C1A16D736E91D9005E29F6A819683942A27F29200233AA4577DFA87733EB44BA0C610FAABFC3C8BF0D7615EB55C3E4591656B968CFBC6C5CA536D7B955AB7782AD5BAF3052AF4410713254A0372D0E332A54DA9505B4DD90C896D794524111AAF63FA67BC57485755F745EFDF892C5154CED216BDD4ACF3C5032B4503FB004D2F8AF66F99DC9A458C1926D5340E1A88DC97799301B3A84DE893836282D408BEBC3BA46AB41058067C0B0717553387213730960A78E009E2DACC659CC51BA89352D5F548F7D421F5317B9B6C4D139EDC302CCB646EFADB883E1561F952D119CA63B06E2FD9E6F78A25BC0352029F900C701359F5FAE050A815D8858D23C18006D8DFA415596FF87EF3672F63919FB803A95352EA9C4D2F3967B39F99E20D96771F256DA05D53ECDABA59563D53EEA59C697FE8F4C4104178888E26C0C57A35BDE7A0BCBF0374B6262B15274137D46278A7E6DC485298A3E190AEDA6CCCF9A9907D294126DDE05C6CAEA2C959319C3947DC7F247AC0522F707C9EBEE2D45FA734BB93AFF5809808461774A5D8B2B47539AD59ADC312CD7D1CB5F59759DF05A06F43186C6ED2CE32574D1220C9EAD7B8AA7B5243DE6070938E19D25A1EE601DAF84988AFC122BD03B6420F47DB70B385B06CA9D87B869D668A6D523FD5D5039DF10652365D0BDBE4E955D4809DAD1FFEE35D4AB84C52CD9950884112D2E1572F6DF785609742A4D1F1062F81DEAAF37275A7820846A5845AAC8BEAEE37892AC483CFAAB3A8EA5F655BDF1BE884E12B1794CDB1FE6077E6A16C0D5491E3613009AF5A7A67D5889624A9F3161AB2D299D6CB393B7EE56FF45AF844FA874F0029928385F30582ABD781E687E448695A9CC7DF08C9D007F1F018744399D0B06FAE1766332DDCE848EA1650DDE0739A77903BD70A1A8CA0D6768A7146ADB89A64C519514D0289BAEA7A51F0563BA51D256CF2ED21EF41047CCEF0BEE2D8238EBA8B68890CF0E4E7860A705F905D1E2028DF454AF86F665401217D18A0466197D766F907ACD8A45D94005EB16E7F7C6803D77E2562D3696C4DFC5AE55325C8CEAAFEE604D041EE4888B2BCCEC5AF0CD5AB93DCA6B6C38A567B85D467D59337C66B083E29E20B8C8F754ABBCF1089C57FDDA6E31DA39473887A5100A34EBD0207D14410387406BFFC84DC41BCEEFC90A315ABD1FC8D878192429EA5E876C511735017D099E9BD8B0577B3A93AE891FF1C232E2E7D3AFF4C0BD74DB925F78A32F90D15274360190077CAF5B09CA13F1C2D6263D3D96E288B547FB2E472C8ED527FB849D4CDFF1EDD0FB89F34C1C519DD4E4543DD292F48A1C7FF6B18FB1AA10123275DF668F0E4D6DA8AFC50628CA9C8EC222EA0D2065F0D4F744076FC215B81D863850D607BDC51874958D8BD2B35C5E5DFA3A1679C52B0FA90218A776324C4699B9F87EA0124988C9F6A0B8E1039A24EEBF832DC8A99DD7C738A52660A1D6589BF9E3B9BE6D8B1B5B3EE5AD0CF52C31BE40F6555F57595036F8000A5495232C925F5A1CAB3E8098260EE1F49948C872C32B47E8495F1BD88ACC06CA9F56178998E153F95C0234251B617E5782A48F3D1F2FFF4FC3AB3C176AF65EB8B262552517143D535D0E5DBF550839658AD6B2D6D0F76229CB9BBF1884CCC21DEB1CAED242855EF5E8F5D8ED199B8E3B38297F4EA793B4CAA66CB84756A28D4A46F955928F116CD12757C5D2DAA56A5ADF6A44C0973B3F36ED9402577EB60D96E8C982F06E7CE57AA38DC3D037F5A8EBAC3F4FA78AE53BEF30F22073AD61CFE0CC445D78A209C2822DB277DD13CDBE9694FF8EF6D8BA215192A392D4059E0D3E75777DFC93581652CE1DC4D252D9BBE8B5DBFE022CC959A9CF81A81A31663682C554762C38124D11E145C8C66946300157CCAF6A34C857B071E6D038E251C553715840C61C6B049AD24AABAB8A3683B6AF1264A9545981C0F33C8187199029E74B87DF27A9723D27C03B0ECB6231A5F4D0E4CB0CDCCF22B803DD402578807906679227F3FFBA7C34A543D7C3E4F33B972A1B8596C923553213DBD275C7DD0C46E238934D4E90ACA663C98C01687DFFB60A4AC227A9EC9E9C5F7D6729D52E37A278AC913A586A2377B0AA817A8A7ABC48441A5D5E0534CE8E0D3CF88DD6F831D741BF3C089139D53C93625AC926FCE3BF2604CD3C0A3778909579ADA6C5EB48A78F68EDDED6EF4DCFCF07E1990B12DAF7A09A905E8E75791682482F432F69CE8E2A1837135EDB2EAEE044442B704E5E2B65C05020FC7E1F143478149D079197D53A39DBDBA73C4F20F317B6C9F2C47A570140F61F0C1808B0D7A0B4F86B80FEA7D0412AF5BF628A859496096B20EEEC12026D981743203A8F91E6497A7D69D06CB587E90E7CD4A6ED81486BCFEC0170E8133D519256ED5BB5F79407F74B03CECD797266E879B2B4D881CA4C3D196186F07CE1DC3BB7841C5DFCC902220300A4B4FBBCF44B8483653B502754B45587A40FF2A6788FFB64909DF3BD42C26B6B44463D606754633BD80D473677FD85D5A1B7095F8734CC87DB9CC325787D5BB3A94EC59B6BFD751584908890D4A0A8924C34541265BE07B24E2461407DE28FC0F0F9DD2E311C1A6D4782BB6A6BAC7C70B78DF796C02D1797F90B778E365E9A3B8F2FAE7DC23C020C777D77FEA2702E95210D6B0C92E8E9AE2E6F8E6CFD39A47068F247C931CA332A984AFBF6CE829423BAEC9725102082A89D349D5BFAFC7020B21903A8916A0EE5A5C9248DE7E37D2BCB0A95CD828F250FA54630E663AE3401EAEE3402D3282747A40B4EB7D75A38723FFB4193BDBE8ADFC5F05521BF9A347D5D63DFE1B7997C4A9E1252A8C113C1A21B5BF814E6FA2C45A75765281E3609E500C2B2CC63B6CBC2786E90741D6E6AE277AC15AC4757470ADE4534815EECE6BF9D301CBFE36CB7498FC8D2BB6EC225597A5A17F55375D0425753D6E6CA73A67B9364B61F4F45507BC218FD01EE2D86CFA0685E0B35584BEC2CEEE8EC5247EDAFE1083F20F6635169D7B3F050287E6FF87C6D17C76BA616A25B1E2AA42B1BE4C0B8358603687A023576C1E1DAE8AFCD2FEAB9E1652FEF80B2142482966FD8E0E0DF3CC113C291721524A13A196E469A32EE0D30817552DF7FB60D4B4F1A157E97F47F132A22D2E8DBB0F7214B1F833823288B53BC65B9B40 +MD = 1E2FD600F93636CC38D99062D25D2805F30ACAF73F00CBE62C653E0AC190C25E +Len = 26051 +Msg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en = 26114 +Msg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en = 26177 +Msg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en = 26240 +Msg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en = 26303 +Msg = 7B07446DEF536B02FB39FA34FE55CAE1913C83FBEE18E7C01D1BA66150A4377C6B83E6BBCF4560CB06C30A6B7C89D2BC1368D962E8C106F95AFD41C68DED39723E9AA1C8B0AD380C340DC4B04FFF8BC0F39F70EC64CB5525701DF63031C1AD9AEC9A2CBDE278E199F5A9D6A468425AD7AEE8314FE5C938643F10189D87D630195AE3ECB386DD32A21264FCF7F8869776E1AEFC079899AFF9F5BC15EB8384E1193C541D3DC4A5A03CE6C009863FC7F9802424F6A8FD6F2B4A7594F79A352946E49AC1897F21B753B598B92A731FCA3312D751E3495D04939F3EB5869A787D6CD27B64FCE6083F9E8062A50AFE72E2AAD25C5E784F55748439501F0234AF358D45AB21729DDDBBE04F651B56D9D96E69F442B64D5FE8F162947C3D7A1BE783D1632979864C9E7D3D6993D920450457D9FD5CD2C6DA64550BBF4D64CD43BBE4BAE629E4E7B1D4A2A329644D23E5BC8B43C5C4FE1EE29368F721F458FFA1A7F0A48548D8010563991E973B81C1808D64EA2AF64EFD0DF3ED6D317DB5B2EA07695CDB2867F52991B9E440FA8D6721C1949963EF6736F941058D4702A8692FA6E2EA1197D92F5E32031E74071A0A952D280AA477E5830C311E4BCFA31C5422FB0935CE3C17B80115B9B190D842DD2423721C950CF2149C296D466C6E55757B80E5A9A62F878AB0D7A1154C972F2A86935EF62EF5B9CB7C69721775F49BF47769AE9C287369BED101B5A5B4C225293EC614EECB2C00E45A1E3D2E492C420108CC502105A63D25A0B61742365E974864DD1D6E54F9A3E1E263AE0D46266DE26ECFAA54AF0EBE440623963AC538C86F5F23E939C248474FB1DA825D531A6A948F83B0266817D5D119668331C422F77BA291D314A8F77333B192BF508733C0A13793F989A1A9E2356D86FFFB5FC6EDC1975A5C6D0097A87A873A2CA4D365AA6DC4C232AE3E0D3946C542939E328CF193450B48DCDB7B124AA6E294214895EFA0B4709F19CB93CB37436AEC1EDE668337A55FFEEEF2E9BB9AD9E9030B7C37F4FAF0E52849595FB87A16D3509235E8C28AFD567B71B84680E02FFA6D0C6B9D1CF67CCF44CA26974382C3DC619FDF3E836FA3A428F16FBA43719E4397867A95E1634E1FCBEFDEC13812FA230731E1D3FF9CFC7099AD216369B2F45F97DE72C3ED8ADFD3C84C0C80686D9C0020C71005F2B9F0878AC2BC0BFA0B01939D62B3C63E04F4559F62F71D0FFC1F0F9782F096D27DD81E6C33037D6B9A7BBF5421FEDBD7969A50C2B25E643E2C37BAE2651F30FF092CE4182B843EB57BFA75FF55E3E57087C5A902D82373517E3EC5534A85020F2B0EEC3D254E3DE5440EC07722AF3A6283C9C0570DD1AC30E64A5B287A2D9E525BE5B6EADCB8636E374C3953825A11B920179709938F714E423DF7B0FAD9B02AE540D047A65817DB5B57DDF60ACB0B479FEFE5733A570A97956E1054E486A14DA0E01175C82F3B3F0D413B61C649299C50ECE5BC08864EACD1029FE723A79F4FC4C16D808CB77DCDEDEA520155BF404200B495756DCD1FA0AE636C07E91B366EE2B8E01CF97CD0BA3BA934A80966647087C1F16BFB83BB7EFB1AA0071A122A0C7BCA540C3A23496EBA0EE69963DD2D5C3F9D504F257D146EBDD050ACF5453DA9DE6B78448003837251DB8562075B7CF0FEBF082492296FF42168D7F58296EAA826374281FF9195F604FDA1FB6FAB8E39AA4E306731241D6E83C5F40B5B330E8C4DAF6DA618B9BE73F9799C5AB4A25755DF8864CDF743804C85E570EB57FB0CF04DF326D0B6350C1C07F49BC8566A3FD5C6A4DEB5BAE83896FDB1ECD3E620AD06D1140D042B93211E530E528093F8FBFD01E9802EE804C6C97C9E0039B5E707B222B52B660AE46E3927C105FF9FD27658B39477CF6D7B8698FB039F40DA3D4A4F796BE5A68518BEA564BB6F24BB0D59740ECE891613940DBE17E987548212C8E038213CBED484E2F6BF64B24712028A4FF4A06C87CEDF1CE3426F54C2719549A1786FFE195713729B0AE6E44D657061D5CBB8C03E45E6F6C9CB099A0F80878E88D45BD64835C5C28484F83C99208E634124A02409605E7EBB07C8C95462BFA8E90125CE28F08D3C4D7537992218CA8ECEEAA245F9921242DB5EFDB953E2E414A890DD247D9B9326FBD1C71C4698BEB9EA148F4EDDA71B8DADBF2A6653B93C0975A14C95D6703338700F564711BE8493DD6C92C3EB492EC1E6AF821B1CD31A6FFF7442D04E1ED761B7BFA85C5AECC8307E694471E5FC32FEEA59FB4CF01560722A88E66764FAE1A303E24420CD721B64C04D3240B3AD08A34EC0A13A0F1972F50427B3FB59B401A54449077007A356E91EAD172F7ABB16E15266B1A92F881D573DC3A88DDEE16D9DF1E6DF4378592AD448F394032B9CC128D91933BF84CA9CF6E1B544A39BC37A4B45BB425A096CF2DE60AC6B65E0F94C7EA93A43A13C64D329666D958E31A20CFD8353632EAD01181CD87827BFDD45A366935F58C56554C3FA694B22544365294B9BF5202CF7A40574E612B8D11A614DAE0C287CD33D7354A1E9D861034C0A8BFCA4C6431137B9FE7336E648EDDC7FA31CDD3A3EDE133FF7E8088416CE23C1B8CB9FFE555B10A2E2B61AFC3195F5B6C61A3B118593DB4D2B69518FD5A0EED5D30ABE58D9DCC033AE622A16089E7FA957C904E6CC074E9568F080E3F92D22D035A4D05D00CE991925A2B01A8C2D819F7241DD3A8D88A9C776BC33453F45C0AAB7B9856A924AB882CDD8A3C6262AB1001781B26B284142EBE751527BD32F32BB87C0849EABB5AE52ECBE720CE321B5CFB7FC327ECC1421F5368F434ECE0616ABE6B00F8C8DA8BB2D3CAD4A47F89370DC16BBCC4DD1EC2B0BC036DAF7CEB40C57240D20894566EE70B7047C2DE9CAE179DB8DA1D73D85B8F288E1620805D2832E0AB57770504A5D2D76E682B9E7BE4B702664C5713EABADB3D06B7E1C93A2C2698A5681FB994FE15167E4E85B909061FC4D48C75C0EB669C85C3017A5026588C9CB521C63C381FE2084951C9C193C6F5BD9A16407BC49AA7DA70ED3DE9561BDB8B19ADF4536B678D20F7BF8077BA897E9912CCEA8DB5214F9AD87281C35DDAA65EB641D266BDADF86B78EA014B2074248ACAEACAD7728F6E7D318D0D73ED63118CE9ADC52F332401423FA75554ACC06F6C7FB8CADA0532F68F1C25798CAED2F3925CCF235F5FF6294573C62A79B6C14399E167D3D81B3874155AA882D6B991F7ABDBEA352FDF4C2D4F9F72C7127C93BE9BB87BA3FDA36869F2AE313A999739B0B668A8B8ED85719ACA0928BA9F8B75230544415BB949C8910ADCA7B1E06B05CAB0402BC6C1804F4E74EF6B4B437AD5A1D7802F4FBA246E61A83DBC08731E781E7F6F372A184522D31FDEAA66A0AC8470E8921DFDFC892169644DB445755021D6DB7A430353971A9715A3971518660ED853D7531232ACBEBB5EC563B20D6739E0F9EF19A88C599E093651A569A72E106EFB822045661C9BB481C29FB5691F39F8492E74BA34B86BB80B5F59B033C77C102AA43C0C78DE713C4B6D2A3E8D75C65F07729284CD1E1897E3ED1A984DBF673A072EA595432F3767F7029DD408C77EA0FBC7FF1D22FCF6F492A398F5748E3B43CCE3753F130754B213AD415C8964E629245E8691C8A0EB0F45F32315EF5EE4C9465FE4CB5BD55C06B91FA4584192F203EC2363DA2D7B207473E286416980B8BD71ABD9661BEFBB335B51F88CD1CB732841524272EB56AEC7772E39F940ED934F5DABFDE3EEAF5140F62F4BD19D356B91FB72053D7786F3C0F48444E7FD0E140A1F998801F698AA8C92C2399D06A78C60037832153F19678102DC35468CAB83BE234CBFE929B0B9A1EBFD7684592577F000474248F5804E203F5179B90DEA188986092B3C2F5F6D9AC433CA285C154ED83E4E3FD78664C4961F1699756AB9F6E24BEFBB951D8E73126DB63443576B7EBFDACF1DAA3416A016F9E8AA6504CC8C1ACE55E451EB958705FDBB2668099F76CFD6A43DD650714AF80CCF5A4DF9F7622B9105E5F8A7507EE878DCDB3571DC6DBD79C2316A18AF4CE2B4D76A9B06A2994152090AFCB83FB5C33652D1DFFA03D2679A60F67CC23DDCD3B13A940006509C3438DB79A0C46D85A4023BF09A9076F9A08F859332B1EA900715492EF1EAEAD7B03FD56A8BF86286853DA26E57BDC5D382CD62378BB098B2399FE187F2745B23A07997A58BD1C8252D0434543AE013FAE3FC45BB49D336538DCEC2B88A3306F095BC44B8CE111E1330177EEF921B7BB3473F59929E2148FED38276AA27BEE5ECB3D9402973F9ECC565D17AD325B49BE3D5AEF9243EC1353561D04ED603C599C97B98615ECD88114C36A95559B2D859B1947E654E63CE303918B058BD0571237BAC421316EA53A509280D822F1DE395B72F8C4772B70EEEFF1D6E31B9439611B05D349934DD514472202764CF9B95EE86838EEF3926A9F8154361F1BCC5F2B9086233734E8772479E850F93E2A7924F3674156E0EA64F0C791188EC3EC2800662864BEFF9685AD9C3185E99FC6F74486BBF68C6683AF667647FF6615D4474618850321CF60C6496BB42A73B6A95AA58ED1D30C75AEC06C7ADFAEEBF3ECC5F2B0E0335B5243735CB148380FBB06FA7E44E5AAD1CC158088EC7EA9AA +MD = BAE6B2E7E952A0657DAA18FDC18A5B70FB99FE037FDA2385B482EA1759D59257 +Len = 26366 +Msg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en = 26429 +Msg = D1C757C3CD667E7503E21BA66039AEAF5D3CB3FF0ECBA7D5BD5F6E0F42358DE95247B1D186798825831F7FAEF65EE144230F4C86814AA52907DA4C7A48EA2C6D5E09BB92256EA3646ABC87999CACF8360808C71C53BE9A8E7A34A314C56F0115F500518FC5DB06687FC75B2C1951584CA39302D1F2F077D7ED8E188B15BEE4BAF425EA58C01B8CE774E071114B224ACEA29BB99B41C615C2B013BB86F6E257E20304E9F5CE265F447BED8198ACF2047053864F074BE7647E134BBD504898786885B53CC9DE0930D97007FF1C985429106175919BBEAC2C3E755A9A6B3DBF11DD24E42036EFB53959DE73942CDF641CB7A4ADAB4DD1A846FCA147043B27B1F7A698965B137AD9BB0F0E34DC4A93FE15A7D5A14C3FD10EEE07476C711467A12AB6FEDAC4291076E0CDCE0255658866A0EF5C903C5D27BCE013C363C49B3FA6F17639700D7D1AD20322D44E44C3521B98B06A2876EFFD6D999014848C735DA4BD6337771FB5811964FF16A66CA12902EED8A0367EE050008FFBBA8E5AFBFA60743C3F638DC8891BC574D535C8D701A9103394FE27898F38E8DED2C2F4F010DAE4889BEBCA2F6E7753ACAF72EACBF7E9BBB3D8DBEBC1E7FEDFECE2E8183B1CBF1AA3177F065B3342531D328C9CF4AC6B4B1726698443FA723B3B1EE9933AA5792D59A901297CBA43724FC4A37A53250ECD9052983804F113AFC9EBFF324812405C85D38DEB86458E97FE5B6DFC0982EBECD47F1BA9421DD1B756529044F69AF5B3B67D8A67763D42FC86E41AC3527706E87809B532FDDE2C6AAB775AFD682206610475AA9E4750E9D16BE8781A6ACC9C13F8FA39EF983257BC7043C33A00AA13B1426A1705CEBE891F73C13AEFE1BE8844CF1B129D97655FFEA76F62C0A547912ECE02315263431ADC8F5FB929AC74F8F40203330D79EC71BFA77014E90E64C8D4F64967E015AE52B2B943170E5908BA25BDAFCB55CF4450B5B0230D1829BF2ED94CC3625ADD90511BA5327CA8FA8924AA5BE9707C94BE48FB926F47B73B1A82050A40168BA34810A488D4F673C62874BA6D46AAAA86C92BAEEE332F10F3968283AD1A6EC56060D20D38B3E2D812B89B1A4DD7FF58EBF6F3454533952CAF0F845034D8992030B9B8C885C5A785A0CBC8BDBDD40B27805D8EB17C47DD0BAF4B854310966EB1039D755464CC9752A9F0DC0684883372CB65CB6EF9C08A53379F8134E48459FA6281D1FFE3027D4D41F84870143580FDFA6E55C2B1706BFC855BA68180DDEE72DE39367D5DDA8FB4E1B285D61FAA354458769A474DFB9C25127603EE29120FBDA5E72CFBD46B15CF532D4EC222F4E06BBC17A819498A6AA5D9D7C4243D94538CEAE254B0F10B3D0EFA70C427DF3A37647894E37317B0AA825CB55FD83F1F8A0B2AF14097973F5B26F13230D42F2D3E2BA9AD92F082FDF6E1515BDB691097DC7503D8E68DC7AFAAB47C1D002AF92B696FC254F80CDF179121AD245E1744A4046B58BE0D9BE6910A1C6378C001E98228CB73E774FC9947D1D8D7A460E1FA45AB04ABD70CA95E628D6F58C537E30A38E4BC5E0F5198458967F16F658112F5E84836AC061C69FE5F09089644DE9AF8D22A49F6164AB6F1A299727C31D27AA85671D5CEF6A1469A308EF4A5C1C5D4CFC0A193AF554D2DB1EE8BA495CB0457E9D07FA9994233D99C1645626A7C7D19900D751CD09A3CB075DE3B7673CE335C59E16CD998968C7C7C45AFF1F74019D1D4C53F4E13B5315D0D99D5AE2A0FE3EE6255C9D6889189FC0A15C7A508C9F7E8AA8152605C32828E6E54876AD3970E4A0FB1E8BB637881205CA656C15891BDDC7C8480DE39B47B75400DEA161575E472D895346607C2C0B7338A69C249DB227789B8DA4193F7463E28B5072110BAA90171757144E317F81933EC1AC26302A807C2CE3B09252B2567B120446540E09F79FCCA0675D804CB57E15DC18C120C642320EC7419618C08639F4E18816C555015EBBC10F57874309921858FDD83E9B629BD0EF0DF0400C4917A70C6BA63ADA193FE28B10FBDA936EAFC0CCB38C43347543688156076366AF2DA2938E9276A44257E052FDA6A7CCA2614967916EB09F4FE2C3105C9911B65A81BA41F6E3BDE708F65F9687B04880F4E008C0C13E3BA449202E2FF9F81A6AA85DD2D184F037141AAA13F2C86649A1463637CEDD598A008F5485543FCF68B2583E27ADD0D10AEF197C1D76D32486809106F43021407E74F3042AC1D13F945EFBB92F5A0BA00E6A657DB2ED038A81862D885AD37195B880D6CFA9CC19BFE87121C8505F29C6495B9842B05B1391D818778B76EF88BC797171FDDBF364F027E9791A11B207777A94BFDB503AFB92783A521EEA4F59F49AEB9D2574B75669EA31FF6A28FD217B5521D936FDBD94F907098355DCA54748310AE747C7D45D8F42E9A44B1C26B145ED78E2CBD3F167BD7B55FA87CE78BB8F850DAB00EB76F6C4C98CA0969ADB83DDF5F1CDB8A0243A0BB15428F0D862C08A95AAE49A327F15C62481224573BFC4727BA6E92452149AB7699FC2029F0730436370FBDBFC9912BA05881BC6211F9216ED0317AF1EF6AD5A764659259515F990933AF83077903C3CF39C6D6A168C46B20CA9158FA67074640E1ACF79A1356CBB51BAA74C79706F54BC9BC1FEFFDFDCA3FFEB5E4F9B316C55650341BD83903D35A152C9D9DBE8A1A3570A4F346325F98B22C69B7A88CB549A3DAECC4546486B1D8FDFDF091C6C47E1791C2E38B4FB619B329DF9FB56193067A1B352CC4F730E10C960BBC45B606D0C45E571C29EA1C8B89F59F3E9C215C38FACB5509406D89533FA412F87DD258D92A4CA413BEE7065A4F2687393E9130CE7D367924E59E9FB7EA55F1954EE6AD959E021D86A78C0BECE2109E3097FE940B4E757427BD21D6ECAC0B468A31D8AE109C71DBBF8881A8DC9914912AE7BCB6165CAF1093BC3706A6825FDDBD353B195122C28F7D8C73E25B16EA853EE25D0E01089447935F0EA735EF1AF420B4DEF0EEB7798A7A7589B192CD7467B6CAF47794D8B5C261694B742BCC3609C121B3309B11F2C2D3AF70F204C25A1094C3717437600C450207EDB96284260AA7EA8F0385073AF4CA3D4773666E7D779CAC22F5101816F2D825250603E967BCDECEADDEC04C1D7DAEFD11D2A32A5B1D21D31DEA1FEA01328C3B51174B839BA92E3F632B933E8F4CB335A7E1485AC14109C92A2CF44AD211ACF30A9F703CD0459C66BC9A78A101D35C1CF6F1F8CDE0E82F821ABDA9C1B05D8F607F9F5C00D1906C868028148ACD20D04A7CBB2EB48642A84AEDC06DC764F0B64CC14ABC96BCEFC04C1777F18A71538E23ED9F36A5276A28451525EAB9D155C3DF2E09ED64B97F640C89D97D220C85728AE4097F5E20A69D746CFC7F695213646CAF4B0B52FEE2757F796D53DEF0F7ABCD4058623327C4B182F96CEC243816B08295269BC14CF798B7E4D975981921986D5218A1BCD3B2AED5C67A734DDFFF112DA76DFD30A2B606DFCE0D4957BC86C5FDFE5873C5DF3E37A4243448B1C368F8FD9F7C8D6837ABB1EF92369E2A8FFDAD3B007EB98D7D314299DF6E02DA5582BDA7897710DD9030D67C429E27A8816ACEA335C985D7F1FD242BA5D60D2AB28D050EC0E60D97BF8ACE749F1BF70AF85E0C9DD1C140736F1E0F997521B8576E25DD5C061B1603524EAF11E6F9D9472ABACACBCC9E57C25FF9F4612D62A7BDB3CADE450CD87F7C6BD2989BDF6B35F941AA98D387D2736B4C5C64ACACEA0E594753A8DC23DF1AF5CA7DE77C23781C59D6E3601A1802DE74C4BC7C29E0E2E1CAC46CB4B35E50B22A44DB2CFD689DF83B51F9873B1778C758547429AD8FD983582D3F03990D7B7C00733C513526E3CFBF22467C103E560E40A622777168FB4E253EC9744BD8882DD9ABB4191869227750DD0CD8606C3FEFDF12D48CB54002B67716598DA2ECEA5B7955D5CFB3A5863551159A6F458DE7035F3812FFBEB419E2260C66CB4F7C3CDC8FEEC4B53700B418C3D1B8715700C24E9D2FB5FB01E5F14EF79ABCFB928D4E015B22C23D309C643FACD85E2D8793BD8FC6913C4765302C46A0AAAA8D37CCB3652FCADDFA03863FF78C4FEAA5C0118EEA7CB4349A13B9886EBB5ACB972FFE8AA544B0D29E4055869AC49901717211E84850C42C44695BF8865FA341E0CD64FCD23020E4A4352B23A68479EEDA6849CDED419802D78940C8278ADDDBD27EE7817CDDFC8048CFA85C1014CD6768DC7A64A8AE870E457D93C27BF1C7CCA1659A26938CD160A6476B05350A24E38DDF779E5E674CA03C01FDDF78EDB6927C01943E92A9FEF777D65BF9620B36E55285651692A62D5156D154111724E0F6B1FAEA165BFFC0AEE24D65EE5738664D5A2564B64A7F1FC07C01DD6E3048B56D4605A4EB26D9C81B6AC74A1E77B95B842827179BC44EC47DA747934C0E4325D646D8B5669FB7AF407BDA4F9AD6DE21F8007EC4496E2145CD58229435B2E3DEC8274701B5AF629E51BF8C409BF78B76C1874509570893958EE3A0DE57D0BA0982CECB3428326BF775BF8066EFEAEF9A962AF1CAF8FDBF3BA59B27A698C5DED2E3A4553B5DC0F907EBF807DB753749A8C5D4CE24898C3F8994DFE2430A6B5ACBB5DAA939C452A4C1865054EAAFC53A4A276B8B23E480D3CFD9EAE7FA388AE469BDD490 +MD = 3CD776944DF1CC84D8AC2CC1640E94AC15AC07A092EAE815024F1311E9D18059 +Len = 26492 +Msg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en = 26555 +Msg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en = 26618 +Msg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en = 26681 +Msg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en = 26744 +Msg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en = 26807 +Msg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en = 26870 +Msg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en = 26933 +Msg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en = 26996 +Msg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en = 27059 +Msg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en = 27122 +Msg = 7B2888E9876E46F4C9027AF731122005D643335BAB9F0E5814E33393FB89940A8E4A23ED59164CC23625139032378837CB3D3092EFAD7CC6C2BD8F1A9EEF1D314B7BA4EEED2CAB64C5955FB4362667F37A894CDD61757179826BBE862D39297E5162E5F60CED9F3E7F773E3DA4326B5599381E92C7E298EA0AAA02F3333AB228A2C018682031F8260E3201AC8434BCFD18C16A90861147129493E4DD208F04049C67BF7D034E125F0C1D74A344C0A7AC4A0EEFD56DC41C88B91499776030AB8E185B447CD868005C8E3E8255D3F5D3FB2FBD04A2B3E05C330DC85817B4EEECA79325E7F39D93EE2D44038B25B7F7CD03B36028F1D2BBFE7CF721A903E89FB73CC133741ADD3DB8143B4348C9C28D448523F5EE43FC7F5AD69712B464AFE5C4AF40830F6E3C54D4C5D67CB2330013C53127968C6CD18DD46D7382447E001C3B441977B7AA70D20AD05FC15A433ED6AFFAF98D6E4347D313E779047980ABE1C957BE8F11692D883AEA314FB7822757342A66B28CA2F6D8EC2134F1C8B8CE3ECB167B24C478EE3D485A604EFBBE4A7AB03A53F4A9855A7E554043747567A85E17EF99B5F4C9A52E13979663FC7EB53C8CA1E3939867D4ADE89DBDEF84EFCF67089E30CCDABCD28D61A8C5532A38B63CB8CA06E5F58C388867992316C926C0336CA9EA9A672DAFD5F27B5149FE7ED284301792D469E25C2BBA790C35D6499A8D1AC9011D1C55EE1088E802B33A44CEDA4F1D4A8C110190A1E218B9749051CAA2C977455CA890782C086A6716BF9621C5FFB25683283AED551FEDEF86B89E3ADBCCF4E28D6CFCFB8EE736959D7592EC491080B34FF8F161E269AB48E5226644EFF080D312A14679BFFF6D311224086EC7FF1EE72DD4A8AAA44717F17BE2296A5AB9EA4E0132AA0E366439125DE5B7BC5E40E10F643B53C16235707689EC695E549CD1E0CC3890566F88954DE95169F43F45B4B8665C213B6397ECBC1EBBB2359B4B08033E4C8062F0C53B258C56FE0A1BA14F6A180A437267069E06D45AD1CB83AA58D51838A4F54461DC6D724024344B920D815430495FCD9C5C8293864329B07AEBD9CF465A481A562DAECF091B6841EC91998819D958C71E5C9373A0B33EE83EB886EC009EB9FC04F5D48A11A1DAB3C7F1C30BF982B665C484DDB0C88CB11E3881F6B4AF78F29BE8FD9A206197AD0C712CF77D36E6A230168CB593F00572949B9FE50B48C108C66B9FF8D00995DEC31A7A19043FA63A55BFE0AE86A9F14E030A1FD961BEC0C069731760E29A030C445BE8D992961F4E58A6295E875734FBA6A6851871BAFC3F5B56EDE68A2C761B9640E931DF499006C97F196E0C71BD60FE7EAFB0B5E914BD542AD2795D0F3D39CBC578C0B0F629811D054422BA9F1433CF828F61B7A5E453B3B947EC5FCCC7727A998A1FB8571567E8E9B06ECED4F2E381B6D6162445A85FA62FD65FBDB51A2E4650B0237CB3C9B6BE52742F8B1D3595273BFDF61F2920E12DEB796BFB0713631E492AB4A10C6BDF190835C62CA8AF035F05206C9977625BE574A8597D18D8D2D20395D5D074B08A4C070DFE3C95547E09FAB30D53471B7ECE9C4476AC783D25B0905DFC9E89FA1C6B1A621627B245A8C63C0EACD5859A45F1288358C348336C1319F6AF8F3D2969406EDCA14E50D2F4808C9B405EC0321C981A7B7E394CC249CEC9113CFCCA49B8F37A213416155E9D806147E8922E5F3198FC2804D88223DC23948FF0F0244044E8881424A499F63DF50934CF6DB7A00A504A3556A522EE0649DC1C7C4C4DEA43C8E6C1FE23DFEC341F315EBE8C4C76ACE29B44B3A4D7547E688A327EB024462B68CAF654CBCC84CF37B406C25310B8FCEF1499F793A27579579EA749D075478587B3C2027C44D395B362602F104EA6EF29DE7AEA1759050AEEC8D2FB1AB6535B77D71013090E1889B2689333A5BC9201606BA46FED063D6338AF61C58AAA01E6B5CDC759B0266326199F073C1449598D80AA00F39845753F8171825D3F64A04F17D770E7F3C678A357C638E4D2D16F6771B05600589C071D9AF11526DC5A0C0F8383874481B828C5EFF230E36D24456B83DE86D549F414CF0FD7688C48424D0F4843E29FA3C379DC1F97F76A13A9C3A7AE325CDB131D37BF3E0580042C78D763FA73DF2CCB3106F5C11A29001BC568552260E891DEEEA1CAD17AB14FB56D8507B599DEC8617BA39BC6B7597411E6B64D699536531E82E8C3BE540CC8C1578928CBCB436C06837627E65BF065D1B9B3E1CD4DAE80F17CA031A58F22BA33DF1D0CBC3391C2C9AAE70701E6A1EBC7DC22B118869C4813948BE6A09D0BDDDE6FB3F04AE3031B05A755EFBB36BAF3244A98486B859D2C0C0CFB7518CF8929763619FAC1FE32BB5F9C8D8DD8BA393CD36FCFED5413668F17D54D4F38B31D563BA7F18167F2783BCF43CE0C7D6A52CA4FC73BEFFE3BC70CA18CA17C1CDA0506C811A67A79D620782743E93F5F1A0A3F1198D7DFC9855730EB777A84485E18F2EC227034318B00DBEB98B0B9B739F234167983130CD6DDD0C677B1282B2E9AB5628948446A1343A19B89EFBA0CB132AD3C4D21AA3786E27384289501C5685989EA1C5BFA4718175A650A6D747AD5A64B6E6D509E15B6E3D05BFC004D1C0BB23C956A7E2E9A649AD95611A4824B563A00D178F89538395497F2AFD381BAF3DB338F75D276161F35F22F9FDF6229B84886A82600335273BF8BA605D8904B144D6DBFCA90AFCF6BCB132522F414F1E65439469A3F165E15D5B801F88D59CACA2D5B282C6659EC2B35DE0951F68400205B8A398CB09BEF15F52F0E376E2989179AA8ECECF6DB670273501A019354A649638E27B27F3C85DFED50DCA755729F2287DD4A742B21232C0D99C42BB78A9D1148066C54B110FE0D681C8CA738ED8CCA64AF1C9EDBB53D2FCF15E14063CF4D3598F923FAF0EBAB4FB4DF8DBF887EF00E55FF846B049CFADD3FDB63BA9987825B09F7C21C27A61AF6BC0F3ED0F599BBC980B30F0A811F22DDD527437D892A7A2E80414E9E1AAF9606CE66DD2B2864B7F1B530785B872E053C8F1F1888E4BE93A7CDC7403EFA0648D09193D91B587B258372195DBD77743956E820069F613907EF60C9BCF8D81AB0652A87CD52452396B47FB2A992400ABB25367C730CF28099B215A59E7024709782BA77FE1F54FA970AAFD8B7873D965C6D0E1F70F721C1B357E4E74CEB11D8EAD7CBB228EA04B37F569FE51E321CCF5EF96C48BEDEC31CE1D0E70FF3A9F3B21CB1FAE249CAEC869313A89B61324FA4F920FD9CBD3D0F6034C3C58E827D819AB303EFF3C8CA121C7131D686C4A228AE98337DE8B8E6312921384999494EF62B6C2B14D5CF0FCA2C82841EA93F3BB37E2EA30DBD8B888FA28C3DF8AAB88C7FE700769234EFCEA6687A4535A91CDF3E23C61599935FE0A58E5B70CA4CBD51DE46FF1333FA9C0A32E87D96CA0BBC6D2C832759EF51509577FB77A30B5E7CC770879C9D0F605889FE4A8C7D81FD0F6722A2FFF5FD529F9126B95F9BE445EE0B1ADC31F5CF0A2AEE785BE8EE89CF43DF778447D95FAA2637BFF0BEB17EA4CDB264B2847EC2BDE4C94EF6C318E6CC7EACDFA715DA60539D862895A66EC547F36633B12AFADE245E1DE9D2244A7F26008470019E4FDEB48CDA4CDE643CD74C325C9F6692188B605D8D7D920F01D80F46F41CD05D33E3F348BFE4D21824A942513D81A3939AACF13AE1DD871523E990A9775775E0F0FE5E2B4475DD426D5792557C8A5445B79740A46E77234B75DC051749A4B04A795A8191CBD0F2A912B70372C420121A468D6D1EF0B38EACD09D61E68283C7F5A55B2865D3727DCC6CBAE3DAA5BBE5F0F9D7BC99D72C69BCCE974A9835144F59F0EBA70B7D1E28246AAF872176339CFFC1AACC0ABDBA0C63629BF71B51EF926D82182B4AC7A96645DFD28D82663F421AFB24D64092F0F270A78736D011DC2A5034B8CA90DA1FD373ADF12954883F1DFEFD87268BF408C591B81FDE8D60FF54C0C69EAD88E4D389104FD8C3607A1E3676CC2960B4A54D2AB2970B987B8B69ECA1F517AD10F2760CA6384607602EA85B3A692DFACFBD939E8C321E5056DC7890966BEF43A03FECBC8A0431FDE5B5AED7B61D9FA1B54B67F7EF785C75A88C6592D3E8EDCBBD4C8C6FAAFE6C97116AC7172B4B581485D2A7198B91B21A5CC2124E008BBF542A4461DB5C62E26E040E511E4CA7C83E35E3E8AC0A854934634E531EB54938B3EBC6FCEEB4EA845FA3E4579C2BC029342801F1889E8FD9E6177A6B42038019E48453524AD0D022277E3F8C7B09A06BA61EC6B508DEB1E1ED12619126F83F571D995B6AD2326865DBB692DA7D794CEB160E63D75608FA18CC4D1E4379BCE7BC15F6FD06F203FD2EF2C9980C3EE48E5EEDD05B836E07D1C2607913C0F65D7BDBC3E286718064F6489C03EBAE1110767E2FCF42868AA674BE87EE6374AFC17CC5222551399478B2DDB741714148741882A36690D7F2BA22AF3CECB4C708652342CB3B72C2DF07A7AD337477195DE3C29103483D7473C352C8D6ECAA52A19BA83C8992BD495C480ADD986FED94B6CB40DEB180EB81ABC5BA82272AA77C284DC652F36C63A5AA5B9AD32B2F2DBF11616C827F3BF4391F6953ADDEFEC35EE820A61B84F81FF0D1348C44F68ADFBFA254AB8A3DA51C33C98432A5ADBC558549FBC3692B6E13C5B4BEBD97ED2257C4688C5E944DF94E08A059D26E3B182B05F30FBA86C056AE10D03F2529CEDCCAADA21ACD415A075D5066295162FE1782A63B8EC46BB1E205F9EEDA00 +MD = DBA072B85EABB173A9472104CD395664307D50C8E2E75217CAAADB11F5A7255F +Len = 27185 +Msg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en = 27248 +Msg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en = 27311 +Msg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en = 27374 +Msg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en = 27437 +Msg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en = 27500 +Msg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en = 27563 +Msg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en = 27626 +Msg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en = 27689 +Msg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en = 27752 +Msg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en = 27815 +Msg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en = 27878 +Msg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en = 27941 +Msg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en = 28004 +Msg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en = 28067 +Msg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en = 28130 +Msg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en = 28193 +Msg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en = 28256 +Msg = 3581D4AEF0860C1729EB3E6B504F00919C656A1C56C10111D21A2F9A77EC0EF7118BFF2A881973CBA46686D4F104CC94C30B93F62769AA2C0F4C7F3FB931B696DDB632B0FE71D57CADFE27573913CEA488A68D0E45B90CCEDA68D966B725152CCF054757211D4E9EB42A97308C6AF1E0B7A0DF67C61F9357A1542CEABF000CFDAA1FBE71D305300D43A448A4845EC94DF696C7C0129B088AAAC29A43BCE19726F94DFBADE2D0F7CD7C4EF0FCE12681FBE496BEE9D7725F549281F4AE666110BF40F5235526606127EE041C09874C103CAEC8EE320D5E9F2D62BDBCE321FDF7681FC988F453EF999B9FFFD9DC285BEDD0EBD36FC22B613765A34BC097DCD1F19B14C60140C8E23D7894132343FFC2B8ED144D9055D2795CBB20B8FEE92363F6672BEA4D40F9ACD55A2BE27CF813B0599CAB2E08225C4F909E7B647A39F888B9370EC69B2A6E6591604A38A5BC2E0ABF8B722E9AA2F05AD9AEDEF55A37810F935A46EEE33389C375613941102D670CA6709506861BEDD3DCD0F1467F4A0AB681084BD482730F7C753FA3F5AB47B7845C5CB17D17392581219AF440CD67013986CAC4FFA4B6FA004E7B5EEE95742E7C40044B9C5A4691C2B584DDE6A8A45A36481E715D6D9FB2734E5339DD5A1856392E8FECC416778805117989E30D422AB8D358B690787E9FED3767A408DD99234463B25B91C30ABB93F3CEEC89823C37023E7393F29F5065ACD499D22E13B5909857180F7785749734027AEB843245F5569C715A881A1E7554179D5D993FADFF2AAE71CB0016E1459AE6C2EC7954C0B6CC8BB1116BBB8CBD81CB62DDE57442F602147CBC64C2A4C456C1523B8075D0DEFA053578C31492B3234CC7370AEA593AEC0359ABE3D1C7431CB62973E93B0CF3C37018B468267B664DB3F45FCEE737CFF976BCE35E061AEF48E8CB20F0461D729FD1691E0D2F8F2E0D44F77B640131B9E62B80C751D0186F183760B63296B6BDCE97A9C0AB4CC37A27A85E1897F6DE52DF9F0B08F37C850F2405831CBE9826F3584E99F7811F08FD05B335F6D07409A80229A567763AD8F20539E1641236E87A7CD3C847C9E8EC063A5A8D21F77F941CA7A56E23F90130B74798B71E7A9CF8416739A4C750C0D5752A781B11F994A0B0E1CB6D8377488EC2DE642903F9B44657E85D8A213F1FC80E674DFFB747C63AAC85E62E295428AA315F60585BB5D5203598DB4F6BA78FBF3F053D579534A0C270B542DA82848B8189DE8A77A339D0052B74B21D806217E902D9DEEE2FBE97DB9E414CA9439ECE353FE0EA8A72ED2116F002365C88AF05D0E803AB494C3D1720297ACE858CAD90D30E8185D02DE9BB4CC3409772C08734CDBCE22B498661D73A18FE2738297F25F5466BECF4DF3BE1F3D9160DEF5566318620A22C0BCC27E91CBB3F1C586FC8E09C60DCD424E8C68418ECCE193FE29E4529E1419B1B0EA3597A98F19E999C780E543068CAC84D7EA226FFD535F75DE15134556D8D637064CF85F62799CBC15FA46A62C03B0012AF4615F7CC4A6FD09396A1A6D13D55D27CC76E9DD09597D6BECC0467B098F5DEC034EBCAE7A660394521CFF7D82BD418FF8CEF7C1E5C0FBE1C1F262B4DFA186C785B00CE614C4558D93716E17766D4D5EAC4B0B81C0B866E41E68BA0BE222D32F8D83507925417BAFEC4B7EE39C374412F71767DF78376605A002990845B9E791011724151CD3EF26191E6C2DB99AE0ECA5579F3A24D021F15A09319235508135B396E97819DCFF83617E641D6778829D6E3A26F7186EFB14DDEAF2113B9EA538FFB2C2207B737F7B708EF54C16252F2A63297FE571034FB4BCAA1EA6C4B65017FB4EC7050BDFA24BACB1AFE2E2D526EE2784E1AC92512E4EFDDB72E4B12810997CDC39EA1A827FA08DD2D7D88E781862E7C5BD964A143F61223423689B81675231CF97C64A3A71618F7CF6A44CE458037730A2592711582EA9D9EFF63400FCA70B7B5251DA70DA3D339B768762111D27B1A2E9CA559F544ADF00F8C2372CFBF03C215B75CEFBDD6B3634A8FD1054A5C016FF1FEAF0526ED8B968CB44D279C04159E77A0289717D3E2515DB6A7B5B4860681CF8C7A1589A3D85C5724A28976193312ADA24C2397D2C10BAF2FA933D71F2BB2794190730242E117C90FAA6391FDAC1EC61CE780A7864F6F1D6D8CC19C024F4791B4928F1A2B5EC91CDCC1FBC1E89E7CF5FEB974A0231DD71D435741D8FDC3730012795FCDB4B15267CD200E576B7D1EB9C5210F24B916A01DDD1BFB1378AA865ED86D0056CA5C92E5F7BD57D447572560ED23107EE6C08F0510E2594F47E19AD6725BB303EED63BE2F94C0501C609C565E40AD74211FE97DE80CDC82B20977A1D24A7E35C3EDCAC3A590EBF65EE6F5D044F43EEFEE6CA71326AA713FDD878CCB6F53D09913420113220AF1E37CEC5FD5B1F1743EC129267A6D5503943BB5D4D21BDBE149E1FF74626B191BF75B19B5A2E4225FA8EC887914787A75EBD7C0CAFBFE0F5CAEE05F2CF468A1604BBB1C5FFC78944017A814077B07EDF48524EB9A9BADCED4E562674210A5EA26507DFE26211B57AD3F613CF951306AE51D4DA53A976E139B3EFF7830D661CEDB059C92F93BDE0209C184BED15E38373A58E8E107B1FB0DF85DFFFCAFE9B005C0EF9C8C7BD3166F777FA5D061EE827CD45BAE34BCF7EBCA1A47F76F459D6DC5F85EFB0D9B5FA5C4BF19494EF7BB5F76FCCEC4EDE71B4BB4A4B37113289873F3D57D06B3D42CE543C113C789CFB88DB8207D26007C809BE2098C20034ECA5539AC8122640A714B0EE35F6B466DD0D0A1D07D6547E6EF4B243CE9835B9BF6CE2D1711744BE3A405F6E46E1824A625BEBC42FF340220E68B785AF5CD5C05C215A6D3E31DF1CA97D054298C0399FFB08B4CE8B2D6D08A3CAFB33EE536BB01FEFA5FCC7AA905C83AF895047CC7BB6051482DCD5AADA28E906EAD9B90CEE2B32F9B917123651258D474CC699934FE732A9DB3D830CE1C33FF39E946F6BBE363AEB3A3F0895CA09F78ED37B66C919A15D85E9EA68F9AEF383A7AB61101BC6D4BEB7E36BB9BCC04421A0BF7A263651C30A40B652286A5678EA0DA516D4BAF89D747D0559B119199A7A615528CCDB2D5B10E99B2BEC59B742B40F8A3046481858F70D18B5441974D4A5F4A732041B999773A93C3FB4325B6E5F5EB7849923407E15A55BA46F3804DE3E8CA9561BF87622EC8E91698C0FD97B6413D3212F1410D9AD0754B457F041A6805FC30D7A7A98700C5D6ADCEF4A1F23E51950F2FA40F74FDD6AEED47CBAE6CBCCB93E8A06950D980CA261705A8EFB5B7BC866F5451F709E8F01791600AA7E93AD41088DAB6AC9EA25285214D4FA5A1C4C31ED4E0157A3A6BB94F8E0ACB66B0E5FB323284C54FA9E07542030679384AAEA817576329FAD20BF28D80CF824D751206BE17A0CE16A9C2EBD0D80C7E643867CC32FF9CA92E9ADAB3E1096CDDE69B6C2990466611489BEDAECCB9BC135EB2EF54502ACFAFE497ED668AF4C984959CFF284B2AE81638F2E11CDC463318845A363EB08385B4002E3638FFFA347039B40EF7315C88EFBF01F9EAB73A6F0596A1A16943B03139F4E1A3EA5182B401F8DBE08527D81ED45682D6459BCC9362DE5D351A5B8437D79D24899BF5316E81A182ACF4F740EAFFFEF365AE54832822AB4F58D89596014FEDD5B99CAABC0E877604BF4DA5A4A8F8A93DAC8B5FF7F68BF4167560579317A7799D9ED14B7C4719E34AA3312F2B9F07321BD38FE232B66FCEBCFA5A15EA6971C92C0EB377C44A8B2C92BE3634705F7FD01F8E2B10F61A7ADAAB93009B0B612CFCAC9315EBFAF321C27B9FB2DA0120A08F512A9A9149B4797E400DA17E749BFD1683DF628DE0D062A86B931DD19A639AA7EE332C53A8C771E787F7B7C6D817F53B6E57153C32B25F87A1DF9407D2390F02CF6DA3A508D1721F55E155E6E20BFEC0D2550598D815F71E065426E4AFD677A1FCF41A24CBD82DB6135F45D74D0E8AED94BDA26A0F42D19F52028122DF55106E45F8B364F65E314EF77EF0B7BCDD82425D8E3212E3C7DDB4EA1D378E2300F10AE707466752B15EB4489CEA807E9AA03B886F3D623514A7D16672B6DC025502BBB69A8AC5E374B94A0F153DD86B3B55308AC05AE5869C0AE5E18208BB0AECEC3D5E399936D58FF9FB933BA349AD567F9CCF743C264606B41D8AA1A4C164FFDFC9853FBE6ACF11F213490A471E80C15DEF7D985AA9C340C126473D1D14BCC826C12C200D72E1A00B392767BDE0884005D270A1C62413AEF754804A2F04BA3C9B4A4FC9076951860F9A0DEA80BD6CF5FD6E51983AF344B887AC3F907A40A694DED8840998C3A273FB1267C4C7CBC2FD0A51315F313E32818B45D6C7FBEDB5AA673E7A8069C931AB838DE2045E79852FD832C0546228AEE6BC77D72D8E984575E27EC610E411DE7E02725085AAB0BA967A9300583F27A1893C1432F3E651BE3E49D60690652D6177B39BCD6B8E0A6A6A812048FB2CCFC6CC636A0FEA989CEACA7BFDB5286E9F9B34EE5BBE0CE93D4A4614A354EA91DEA8BA0FE6AF3A4350288B0CAAB1FCC135275AE5A659E4C3A08C9E2481FEBD150596E684009137DE6A0F1752E25240283DFA58451C94F9AB96BC4F3DF5507230E152BB0C7F0F4C0F00D9480509595EB25BDD3F3B299CD0D165EA4C2F2BA5B022BF57A30E8E39CBBDDE047F1C91F87B658215076EF534FDEC75580E210A948BB1C3ED8BE98181DFB6E15FFDE2BB7F3EC5DA5907A71FAB770D29ADA2762D5887B306F7A8586223D8CB89A8E8421609CD80F2175F2DAA61AE3BD7BD135BE39EDDD2B2687381420E2C92A107E28E3E00B507E325F4ACE54137B37A0A750E3629D64596E1C1B5091F1761F3EB7C34AB6C54E108A89DD1EDB833D21EC688EF3C37AB1F762E5AAD7C6B3764B5EC04B3C3F319732C1A3D20582D9EF30C4B3536B7C47197C97C76792145CB847BD2FB84A7CB460842F0956020C320D48 +MD = DF6E9B0844153E3CD654D460D5370EE1917762F67DC29BECE44DF2652EA6AE59 +Len = 28319 +Msg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en = 28382 +Msg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en = 28445 +Msg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en = 28508 +Msg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en = 28571 +Msg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en = 28634 +Msg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en = 28697 +Msg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en = 28760 +Msg = 9740CBE9EB65AD1CE913F40BE236B1AD7141F8EA72104B122FE9AC99B6552B1B3A34FD6C1B962F1ECADD53B530866BFDAD8D81F8405C1D54E20D99F30FB041975F70DD971C17424C601F46516C13534967318D3C5D60ECBEC607C42D0825FFB84D7C5C69858512A3C59EAEED3F61124DF79F13D63C382CFF70EBD250FF94E1684EB5AD806714B4132E855CB20C09951E3D1F185DA09B0DFC4C026FEF5D3487E5F607578D34C5A4E9C301C07DFBB72233542C04FEC18ECE500C4CA479A4762E5DA2BFE630F6E4558192D6561B69BE3695688362DC88DEFCF859858396F974E59744BD0224F578F3B1C6F46C7EAA523F672B52906DDA5AD7A410AC6ED5D3AB823EB7235B1CAB4BFAC92DD73F4FB796A299C5F39DE590CF90307C6BD8A7717C3251CD613917358DB837DBAAC615ACBE2885558FC7A0BEA8E15176756CF5C9204C3E3B02764ED608DDFC52A3BCCC2CF4AED6F8AF14953363B08A0885C131CBB5715EEF0A04D18C4E6EFD59E999F74EE69C79E96A9CE7A5D9FE27A6A651FEF54B09768C1AA49FB03B09B6AEB19B38B00065EC6DA01FB471D1792F7E3D5D8C14381CF68C42708A43EF343135929FCCFF2F6642C13ED2008FEBFE9972BC164E375383F50798CB84FF34E1FD07940A218DD174DC869025E5FC459BB0BBA969A2240EBFE0EFC1CD34154EC1AEA73FF7858749735F1B2722C6DDD4A6991D2069FC3D61A8B23977FAAE5C32D95F3F1897B0E86BC8705CFB6984D49C1EE26A90B3C8679EFFAB5ADB871A3E219801C7B15D6DFC62E9DCCC887CD7F25BB73EA2C3FEF764962246390A4AD96610F5E0E7EB59B32E7EC20145308D81F6F638299057B2276ED045AEA7103B44BC85D33CDD0FCD738035E670B285762C65C3EF52452ACE980C41161D8593F46DD2816D435DF7FE90871A9B4CA1C5CBE6362E225E8950889FEBC47545F607A7AE4BA8B86350B554F61D424FB51C8E9886000E4E07DEC324BB5119A5B5099BBB126B0C0CA0CD8FBC304780A9BB44A4ABF58D30DB4245B65CE20B0975C7869B39B966A59FE69290D5AB3FABB12DF5024DAA065A48A07A8C084DD61016178E69FBAF1FD87CDF78E1AABA8A3A03B9FB893AB7B674544E6B1E46F943B149CDFB8598F98AC08EFD8722836BA320AA13B406890449F985FF8A568C6643B24DB35C25DF8F0BAA2A17EF66C2EE0E6F6E2B42E184475921508FA64632A4629B72F7F39513A08C6B55A8F0483F3FE1AE7528E128FA30745F0583C23C27B9D1EBE56AE86ABC1E2448B15C4649E5E26E189090EA986223688F310F707575F7378C7AEB070E0DDFACFF069DEBEC773B8B50DC86A012DB58612EC90D64AEEEA037C3CF40E42F1948EF837937D67C7059732BB32FC618A203AD06D5F8B472D0D692D93707B6B1B85F83161D13BD0930FCDBCFF94495277D9E390AB671371D4540E66AC18F03D625C8D38E75F628B06F478E6CC4A498BDE811B9DD8B636F7C761277A56122E59D0AD8052AE00C8D08436408EA5433D6027F798F48DDF15BA7600363C7EF67236FA6EF377425CD9F634788E9CE34D08A956E24E3137149B08A0EAA2D831B0F3285BFD230859AD02D50FEB10B63EEA8044DBE97693C29C105C2164EF436B88D5D870F88AD5919FDE8149B39AA65E931BF5D461A109A423E81C376F11495C0671F3CF371F89F81D52235D3413992713141C3F28F14A926407A239D6AD9CFE565CC29F8A836E5643F5EAD4CBD6BC936EFFDC687B758384D070273C8C2D2DBB81123B524147979A8E0C0D99B09812EFAC739465D1A858EF233CDD13769BB8996856CCF509D50CB33E4480A6AD951E451CC637933BF8DBD5168C06A76DD08D42E6FB0BA1044FC33475A2342A53765BD4099546C9EF96DE5B78C59CA6123223E6F72680A0B9DD9A12B24CAFEE32F0B6E145515222CBF2ABBD7330B9A91303B688DCC35DB233C71046716821EE409083C790BCAA893D04C09A8F6A9C35C072E5033108406009564B4135C00FE4037D2D51AB1D721AE6B74E867074199B73B93A6D89DDB8EE74681213BB677014D1CD75821EADDDD7C1C78B6B75ACF574CBB288D2B778D84F8599A421C5B8B9A3B120F8B8F98B5CFB81F4F8BBC416E3E1E9462EEA5840B96EA874A6C8267F5D16451B93B72DD5951DE2C4D6D3F94BA87A62A19DA58E30CCF7FB782745C233CDCE1B0AE1B1F1476983D123440A765D5DB0C3E38C47BBFEC5CE37B94969377394A25A90471AA9DDC98D559DC982A7630B6009A7748E9E5F6FE9397FE4AFBA1EBE530B8C46F4F18CCA271856EFBFE5791FB9297114D952F0E37949E3DD5A38FD3805EFF33DBEC3BAEB22A8EE93B42F85C845CF3C2C00C706E11EC7975F6366C6A38C2417EDFDEFAF03AED01A987E464830D7891B0AB7F67F08096E81F937DF9AB605C3ABFD1F2673FA302882806718C0B8750C59D0B5F27BD16579E5E5AA1B5A98257627F97AE38BBD79A0C21E48EF7BAE4360C003E8F86B89B042B65F436CEDF39CA030DFCE9FF772CD99274BDD0E6252D8EAE877330A21BBF6F266F27D119700EA597A39ACC8C212B43DA9A775A6E165C60F6EFB75701B7AECA101F70AE541A44EBA7500DF14EFC38F2E8E12238CB7479FD4148322F1055680BBCA8E535CB5ECA77A55612E563F6CE2A57B1FB9B663AD0B55EF27B2EE32E6F779C6F9E74323256D3D0A2E247943DDD75836F4B07B1480A00CF4F62092E5FF60DBE75418B6BDBDBA59DA397F23B5470BB337487C863ADA5CD8483E6C54D201883A3367DA2B2F49C66B7FC675AC47DDF7D26CB3B40DD864CEA1A178BB1277B28F198937C12BDD8C14573C429FB139BCE19EC9B446552808D25F8610DBF949D33A06550383DF5F3CBF799B0FA41DC5935DAB118A7178381ED3EF9BDBD632472CBC48F21DEB7B5B26C6D6A4C6D8BBCA609EE39C501787F6EF2A9B45FFF5C6C57355DDB17B7A271C7B56F1B7B4CCAE8DF84C01514CF9F8138150C77AC95EA22B5C7DA74DF60EFB0605F310D42EE071438C514A418B62247DC2C55A23D0E731EF9E514D1DDA73F57B2B6FC4B4FCE62F1F0D0B545AB8FC08AD4449B966219E1D533F26A4C4F628C2948530C0518B96FA8B97925629DAD65FA6551BFE9102CF1B9B7C43C41F8BF4DE993FD53C4E582548ACC64F67B2E9FFA34B8B9E2F64C87436CA6D1D0F22A2CA236FBA10D9192400B11D77307B51487D986DDF418076833CCA1639A2C9B80C309A3A4EC9ED9108A69EC136B73982441674239A6A380850A7E18584E9556B7A6295578E4ADB010D5EC2A3C5BFDD3062A9BC5A2A8AC6EAA45F63BE5002A5B53A037CD2E996D3E0B256AFF17783528AB93EB48B2806ED0D4CA4A037022C585EE7789F8F253803D897EA6F0C40F07F04574AABCEC469CD98B7CF1B352857AE32DCDB2EDF8CC2E3594679B0969095CC4507DC3E9059CDE8AA2BF16FF730696FE75CB63555693C9E003B47E2902A05132745D5D48C0A36F101778C66EB9CA3287397E278BA4A3D1E80E5D7E1FA041344E2FF0D4795476B5D2098E39DDC7738F5B9A871E4D963483EB7286681A3DFAC38D5866BB95F2D6BC430FF11E395279DB711657023E2F4E542D9F39421910CA02ED7BC767B47A33D09696982FC6A0848F12F0A84BFBA1A0B42A0B55C3E3D98B05978B53BAA813130D18ADD76DB7EE8483A2D6B3410B08C7623C6B463E04D4D53BAB51F0A5A3F26B9E0BECF98C1067A21677C07822F5F730FCF5239D69D6D34B1D83EAE3409C4A9CB26B754F248271DFC775CF455372C61C6099F2D8172274EA4FA40D87759C2EF2F5F4B9086CA4A7DC6A5A2001A3B85076A6436AEDC3088E26AF74C98F185057E0781BBF8D52C0E4EB3C4A0D3E22CCA0A8E2D15FE75D87AAEA723A991D813A67D93E26B31289B46E21416A00EE86B785E0F470C2A3D0BEB18305915AE21D0E7D3C27C2D37A05C8FB808921D4E759A4D3139624BF2AC8D5CA8AEC0BA07D5A03E13BA45AC71AFCEAE9F2B55D0FE70AF8334245E716FBD6411800D6043F30D6699A81E1A902F8FB1DD23FC0D9443F05ABFFA7FD25B6F0D83701578C54E051055A5D2785941BEE2CED39E8FCAB9923B7C305FD23CDACD5C6F71E645517D0BF34DA56F7CC06175ED920CD1A6EB713200A212538690F481CBC4433B37BF7337C61EDF6D27FFAE8556941AAA5F43A5EB6110AE73E28E190AE0EC6E6A436312FA72D0AFFDD9EBAE433F60507F624BB7A5FC48C3AE853A8C146A332785666367A8B7F9FB5863AE75B09FC3194D890A3F724D6161B0C8D24E0F0F26BDAE711AE13BA8BCCA55F9AC3BBD9EE43CB3A451A13F9D53FBC4D503F91EC773022158FC66662A7B75A617FD1B9D030727F2D2505231C59D9223464AD713152FDD353AD500D605C38317FB5C6A9E052B95261BA6405389AEEA70855C0CB2870E97089D7F6A6231EAADC116AADFE3581D91B30B7EE22E1D8D91D812E641B7786C04C0BB4AB5A58F93DBC48493A51755B5CCDDDA373CDE4D71E2007F5BCC903215983BA847909739C8D80955C350208C61049F40272496D550E01397E8D817B91FEC0D15D61A28DBA51618FF3E8619AD9DE3CC3A9E35FC1777BB6189A1A50EF42CFF1EEB716C827F793D80AE55065671A29AF4BC1360C36F73D3281C690F7CF2E0F94245F9CE8A96CE53A99CB2302940D09BE86CF07CC7A37073382D2F560D733739FA9D99ED4D16FA5A81066F5AF01E17E757CFFBF9EF6CA9ECACC8128B0361B3ABDCE840C504C31497BA5E15933F18A1BBA1214CF2F019752CB5AE61F9000C85CAABA2252754936BA350A60C02B33EB418DA3572AF143CBB2E99D6BFD8856A88DBFD5329B11813E410A56B0D570EE39E262F902A82F890136E1AFEEDAC591904764CD5EF0676B7EF2A4317A484B994506E9A7FFD93550762975BAC0173C90992A9E938E6DEAC563D7F360AB7DA003248A1CBF3FD430672E21F87FAF0A1A91B305BA1F6AB46BF37BCBF70210B40AA22BEAEF8C878315C24E503B5AFAD8B9D2384F822AE8C3A7941F58F36C484B8298C39C409C32CDF2551CF8A90DF08DF6C4313799B0B781A4AA05D7631B73969C5404D00CB053B786B5EA67DBFA9C +MD = E379775AE8003B80A825F794C83EB652969FB064C541A799E174549580CB7659 +Len = 28823 +Msg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en = 28886 +Msg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en = 28949 +Msg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en = 29012 +Msg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en = 29075 +Msg = 1DF42C75815FBBF936AE9204971456A2AF297BE4497F9C248E3AE31887ADB9C5B6BA44863A02F140A69DF2B3193C8EC6DF0AF54B25F9916FC3C30E92614B6009AF89FD263D533050F97F33D709CD8B0A6BCE38E6D935D4773A64C8FC7C3EE11F901689A7270FA1EDDCD633A468444FC2323CC7BD07A09A279560A9044AB3A49C664D04C88B4A7E9D8EE0E365BE5280A8E17F1925E9E8E3176EADADF05D37E5A955C445ABE4E011F2D65E0867645DDC9D8AE3620CCF6B87C8EDD2FD66D0DB9FC4253E2C38939E0FE18A5C84369347A805331AFB81D50866703867D05047043A8C43ECA32A2B815E8988C1656BAE11291B70EB9BB1817AE9FC6640B0FC4D3270C0476A235351D5FEEE91810432528444966656FC7ADAD822050A9A3C2D4100E6861ED2B9CEC22B75857CB46C5294B74B6831FE8F1EF0A9B432A8FC902FD8D853D4363637E88E71D46DCE6A7E8F56EC9347CD318C7ECC8775CB4EBEADC1FA17D2AA89442949D71DE4FDD6E41B180B66DEC73BD04A76EDC6F6D99A730A64C80183F7A545DBFE551E42BFA0A387EC5C345B063419283AC0B804444EFDD0D09A55399FCC2DDFFA27A1DA82EDE8E2ABD67E931968DDDDFDAF8489D3159505F48A85415DAF247846B9E35DABFFA48D8157FF1E2071EA02F1AF4202D4550A4A61FCA73BDF819B9B664A3EF03C35AFB5B58D71EFD347D785E24813DA5F804C5C2B58BDE149F066D52F63113A45C6E0650872FDCB43FB4473D4CD54F59B0527D685379A91B45FCDF03EF47ACE7095756C43EEA267555596CA10AAF65ED9B29D645AB38694B04ECF698C5F484D5122FD374F3043F1878B5902CEAFFF1631440752DE411AD48A4B12C9389D3170CEA199099A0CE17AF7C4B10C716F724464C2F7F621F59450EFE10FC35F95F81AB77BC0DDC7FC821D03385F4B499CB9F4E9D9E4A8577AF8CF288128AFD25FF034CA5482C4A9C89DCF3F9E6E5066A92A05F9992A61054A6771093643366345F774D79BC5209BDC088341B1E7522358FA1DBB1BBA1165BC3AB9E607AA46D09B934514F12FEA2EF48C12724DE549AB65DE33E7F03D78EEF42FB952AAA568FE3C43ACB475804871F6892B526D031260AFA63E58E0FD3D86ACC6470B5AAB9A24D60316C354A00E40E160CABDAF35989F1877239F7E93419C1BB3F9312340D730D179EE9694A819393073260772A60830F80F710B9A3B23909BB5A2907A327B8A89408427839391930A470C48597A68854587DAB88BAA487F85D521DC6D676CF7FA097A1A3D00395949666B6E0DB1902E197675806AFFE199386D369CE6BFFD0FEFB6CB5E76C3CD061E857269E521B254E99924E61C1BB074BEC5CA5B7A303B89C80C59136A12C33B58AAA730059C3142A35858D9BACF8C54CC0B1DE43F7CF3426C41B880EA86933764ED50971429A5F976AADEDE6521C6AB78C479D8F74322AFEBA7B03485238DA7EED284DF37763A76D40C420E669D19F3B8DEDA7CCB11BC2F8E98E9F453091F6160E29403DEF792C6A5A4FF2A848D42849BDC031573FC6A2671644CFD9E44560516FE187B43CEA217276C2112DA0A9A88D80A40607C09B8E57911D294725717BA14748949E459A1A5348B74136B06692C0F8039E9B67FAEF66F29094D9576276C163E7D72D80CA1644E5339AAF5463C87B7A619F25D8246885D6869A8AB96E90C0E0A2CA307D69C035245F0E6EC4615F90568BD4E148A0891BFCF52FCDC782E59FC80351C0A0E6015109FF83B0A46CE6FC4D2240DA75AF1CBA377116B59E06C4463DDFB1B522A19AF9C942F23FB424AA2039D9933557B8518439A2A7F9A24358327C875B9A123479065CF4D5737EAD94D161B4FBD63058C36D4ED2A67FD782C6A83C52F4B12DE92C806FF479CA00BADB46AC14A2648F5F554C2A8ADC2B5F17B52933A3CED17B2BB27FADB8E9B8062A9DFC179996A894B57EDF43076235FC85D95FEF8157951489157D88ECC936A0A72C49BC285B5F9D61CE1D4E53DF7B0997ABBE9F2D71E5FC930C573C5EB181C58CA1BB8722F7CC21CEE90778DB69250F1D2DC86A783D504A607FE78177EF8888330A610D64F582D9E6C7C240911D610F9E645C1137733FE721EF043814682842266979BABF626A1A6804964F0C312FC0C2748A36E70BB14EF2B27F06A2A9AE7A98EB6FB657A95F6E9AF2C7132E62A422B3A251548B00D6A9C7A2FB26ACF6A920760FE53FFB9BB8EF109E02F91C81888F8F2A6D524CAAFE8AC7936F174750DCAA53E779DB91A2D97E644B330AFBAA743DC74B104F178A59FD82D0A0B1222DF724CAAFEE648A27F44BF9766C29C956FCE840704C130CDBAAE60DC4A72CBA361A07A5AB228BCD7CCFB27862F8E471EBB5C8718F3684DBA234C571564EC495F309D178DEC6555A51E85C2B1425A037319D2ADB1102A5C0021A6D683AF9E2EEEA23A4EB71653D1C4256090AB4CB0E6DB2CD7602CC58D3347A3D5C33B4208845F7A455E3F22B733CD6B8E7E36D8D2903A149DF96F60135A6F5AB008749EA5E9B2736C340391352AD240A192A62F8710BF958F9BB6C99D69FACC40AF3A3E0C19B1C7591753BF25B9B1EF647968163A8260353E0D3C0323AB8008D388E8D79E8BAE63E7985ABC0B33409FCA398441AE99FB2FD8D097D6334A201EDF2477DD273E91E6C893D37D27EDCE73D3FE2ECE1EE5E69646E5DFE56BB877A85107A5760CD668FD76D06087D8E64EC4A9B56AB15AD8460A84A2D24205700DC67B6D97691A098115D92AD999CE6866D21B548F397D08AD0EF0B276BEC96E4E6D8BB07C05D15B2C9775895A593EC491319D846DB0EF5304D9F8E02700B0CB1024D9BC843FB07721898E9B7872FBBF98337C7DD8BA13635C5E481194F815464AAD2399DAB86F9C428B9F08F07694DD8170BD474F88096E9ECA47D5260C39B538D91AB33B1A3E8A43123A36DC3CA7C6CBD51AD697647EA85ED6F0F36F6DCE24A1398C8E6A675FE2BD703B1B0DC837C2EE3452FE66F05B037BCB6B9690C04108578EFACAA304C3FFC1762044265997BE9B13A53D110D08DEBAB76CA1BA189E8F8232A340F268167AD124E3FDBBB6D288B7574D09619EF023F45D56003561A85B445D7AA8B9B994176194923F079821F2E44FE7DBA87C9B8E1E26EFD164B5A625E4EAC46CED9481F9FADB23DC899C3A26E3A327ECC74586E92D2C8A04F1648E4640F4081FC0279B9A822559E1229E847666572724A238794054876CA3D1C8F1121E890C63F0F0F7CA6D952430E05BEEC17B2372DFDEEB5B53F48A162CCC768284888029DAC733AF2635DCAFEB2F78C8C0B2F7423C8F35EAD8085A1DA93EF08C00C206265571BD1FEF39A06D928D591135B7C5099D444A1E2003528DF1E6765DDF31F6DF6D0EE86B2DAFFB10B9E8B82B776A8662E1A87B9335ED2FF0D449C597D02B648E85732BCFC69D363AED12FE61D25793AC90E5E5128AE3E6596863D416B0CD7475A4EDFF9A58082E2359CDE3B8C9292008026A9F26C2B4544430B8BA913A12E550028A9719E9B294F57A7EE9AA65E493AE1608C394FA7218C436738F31FEC1C1002C6A8F91319ACA4148BF888E5164CD5634380B1177962090D468A8BFA9F0056D212855B3380845DA5485C07674B828067DF1BDFFEF118073E525D997D49BA8F65F7732815E09F8B12B973C8A8FDB3A28AF0D3B1CF246F04FEC963110BFDEE8ECC16AE221BC5FB0F45BDCBE91D4F3DA5C652BA867AF26242DD6D0526D5EADAF5880FAE3148B2713E87009A02B366902CDDB99109A8C098C6D30D64EA0BE4B3503304A96AD885594730D972BBB8B90979B2D612935741D8627953CC54860FFF9060B36076B7115EA5842D6A6AA59ECEDE5EDAC8B18F30A159C9BDA3C3D763DB2AE1D63C96B4ACADDB06E9999F8AB9CF832CDB7CD0A3CAD6D5BBBFBF6285C281355A7A15E4CE36DF9960CC48DAAF1146126DE9596DF209BAD15BC647A0D0BBDBE08F92B975613B2C038A18C684C1981AF66F27977F03388C758E301D41530F7A76E574F15BABBCD451B7D4FF6054D4381F944C8BE10988CC872B71F705CDA1AA4446C7449DAC29497C21EE5625F0C3AA780A865464B5BB60E8A5390343C086CB1D5DB227F02A9BA15FEAAD9C02BF47F886203732465640344DD07681394373397EF9719AA802CD0523C96A9743F685ECA647E58A8FB468551007ED57936BAB7D67F295649CE20CA7C710A08A1AC8B631CEBE07685B12B092DCB0392DFD97ADC85306044D8B286D1BB8DE7F81053FD21811767F7077C76A5AC7082B9D227A29E579C936749C6D45C5757EFBC0C3E1DDD25AD484A0EB172FE2223A5B60278C7BC45603DF635DCA3857DFF2973CF90BB3F73B46EDBBEBD5FE7B5F1865A49ECA9F6F00A2B20215C4C7C0B2255FBC7B4AD8DCBD5636D805A0256E38D6B828EFF6E8FC78470CC485D7B75657E0A00CDCCBDB371CDA5AEADFE41F3D7BEB240BC16EB08F42ADB3735E0B8C218C036BFB9DCD4BB4EF21E4FCD53D772E76B7801890E5A5BBD7C01AF52B62FC3192840EDEA2AA2D6F9BED17F63346EC50F1997CA7E9FF48FDABBEB5477AAA3342CA06CB9C0724120FAF695592E081B05DC79BB0486F4DA270E745B1710E37C413987537346D4A468A1D9C30DF80C749DE53781DA9A075397EE1B7E581CA6C4229C87235D8FF90E6698C877D58AF41C6D811EEAD9D7D8B0968BC5E50326CEFF8FA69842212B6CF7D5B44FDD9332FD0A5958399A655CF56A860FAAEC6479FC15E69E3B1E408C7664DA587F2CFAD218FE577A43A263C6E67C77F1B8E3029839578E44410F7A1835DE6FD79F56AF799649C408B7646E83A3E4123075A8429232E818E1B8003BABB9EF31A5CA5B1D9D4E33ED59FA8BAB27093A49A14DC3285F55796B66C1704B4782513AE71D38B112F762F5F1CC4EB90430AB2AFBE3F48AC6A7F23FF0152244AC3CA258D2D9A43104E43ACED4FA9ED6BD54D0A081DC05079671EF9E9156D0E2C90A84FAF661A7CE93730E7F620645B47E2088E6D8D35E9729C15550E4099A046FB7B1F42EC465B73A2669D55FF5C46F602A996E4CEAF5F78830A8D649F2895CDA17B65724A33793C6E9E9CEFAB51DEFA1C2FA82840834EADD48383741FB74BDBE4DE1C73AE10A676F4D232AECC35F6C16BE34C8681EB880 +MD = 9A61BBD6256EC4A61E68C940354CD0CAF6BAEBE15DF052F27FD48E9273C2B1E1 +Len = 29138 +Msg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en = 29201 +Msg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en = 29264 +Msg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en = 29327 +Msg = 52C46225471E4F60F3B8261175B4D24B806E5159F2B731A82EA9423914E7076287D3AC52552F165C1F9129C80AFF97C1631AD4CE2599A755ADE9F25B8824ED941C1A2C37784A15B8B70D032B6220AA765E4A6CC16E1C0607A329A2069619571ED3BD2C80813D81F1672A3E0326A34A950902E485A5AD9BEF04353E8DB141D837C645A09F2F450BA42995C0029514D5E2835DF95612AB67A99C06D7D69F2E914208CE88B81CBFBD5330434E6342D8000C2F164C212D6270B34F79D221B68C24EF02F66EFD4F74D769BCE6E81FD235A8F5EB79E3512D6FF3B53134AF201821AC3790E9DD47AED5E5330363EB90C0E77902BCEBDB7F09C9639D3524C0C2DE09A19A5A04486F907F3F88C52B269A936CA478723D3F26EEA3846D3D4E6126AD165CCC290F318C825CDAFB2E60EEABF0CC927F9F56AC5914D058E1B61D53EEA38346FF011871B38FC4FCF130B8E76D3B95500CAB38F3AE1A55C764C0AD7D9B919C013AF5641C869B464A896B43859BF256AA19C09496633155EC21F369AE551CBB708131926F492F300B0EB2CD489FAF6A3D6FC05C08FF3E7166B78819259288E96B49436FD014D0AD4E03FD4F86752C701AD2A3A7EB917023147440CC81F8805905B84D82DC1739370A4E9A9EEC643475D8375437D2435FD1EFA849CEAD575388B157DCEA5C264627A861BD6412FA36547F5969E78635E5A82FF88D5A37489E7826697C1E483BF90A11D54B044D8D08E76508B06098F17BBBD16F32CE03EAC581B659B5498CAC349745FD2C68380A726F76702B5C516864CCD596552CB399D4EF188055DB423C1DA79C154E0F89C7F6E0CD2BCF58DB1985AA9D4611B8AA7D38DBE61C5B01D7B183AF4E85581ABB7A8C552B5A263C62A2C4E073F7334CEC3FA3FA999F8B59835CC4E865D6F8DC89773E35B8A58A84DAC86F9200B64CF55E9D276938D8383450D54606A4DBDF149E9640276052DD65EF866800FB379E8178901C9D31030B8F9C354B2BC8B52F830F9DAD0D964A6541F825CDF787662A4754E1639C600B4F8F107CF86B8947395C4609492FD98FEF2C4744916F08044C544FA886292FAD8A7E70BBE4EAB5A705282EB798AF635122B53057BB5F113EC0721BAE41D1D3BB87891A7AAA68CF0C2A3FDBD623D9A435D35202706ED8DBBC355AB81132D3D5FE80E47D59D53A9B448E8ABBFE69C33FD92C49746F2764989C9269571D006F358301F320E873CE33B4C551986DB0599D89AA353C77D1851DC806A4A73670478E532ED87A56A0EE4705936A17B3BE40BF4DEEE3793518CAE2B21A6AA9AB3C40E3B6B212353EB2128C92BDA055546BBD5F510FEF49143B984A25B508FF13BC6C1AF1BB890DC98D85992AD0CA93137C2B710955C0487C1138EC8E7B88AE89E3105962A7977EB55CD5FCD42DB8E450CAF6DC258441BA0DB7B476DFA233EDFE7A6C931E0C546C811AF5CFB666CD633D02D35BFB6EA1C50746D7E5DA286375E7680C024D3D4EC9547BABF5E6724CB5CC835C0C3B56EA14D5934F6AC58800520DBB68C55C3938AC0D9319A6BCD19D7847D6EA656362ED97C103D53A748E6135297E0D187C4895DB3BD02DEBCA9837E550C99B6A64A23F8DFEEA28D854418073E04E7D54129422C8FEAFCCDC17ADF7C092E7CE246A47BA8B30C937B20CC637B499DB2FBF63A596EB410F0832757167B23980C96C6734A0B25AE6D3C3E3157D329594432DEE0265F3659F02A7FEAA122B178D5812BC66F723AE38EB80A279A4578A0633B6FF15B9104022225143AAC74EE672E70CDAF5B7569C27D1DF970EDEE4B4501BA468A56424B282FA3BBF01553691461CEAA5B03817D393258D646E66F07D8E33DABB122DE6B2361F43BE6080F4F76670D192101E53EAAF898BF066B811BE539850B94CBA6A1D61B3E0D83E41FC3925917BC1D19396CA80E3386128395B1D9B9AB6471ED8BC69562E6DB5CB365A50299C591C3DD139C924127B16024ED59B833CFF5211B6E71E025EB420B3E1378FDF1019B1165067E53BA96EDDA0940CA06DACEFE19C63E64E53D1A83744A8F90CA055877684C5D8BA481C1113042ECAC1DC02BC166D2532FC3E0012007F9C01ECECD77D50B63DB44153EBCC1EBC91DD25444A8EAE581E3B2E235503708A6FD881DF838A3406DEF69671D1B89F59A756F8C603AC89138EA8B44E1A947A11379EDFF8CED0C47BAD169A7FE777E485C31222C3F4E1332544A29B531C02742B86EA43BE619105551BA00ED4FF530052BAB276A316301FFC625EB2E01ADEF02A091034337D3BE1BEE157D756C6015EB92413FE8FFD2D3FE469C1251A945A2850116315667639153FA4F9CD56B38BA55700AA1A257E4DD48221DBBCF96CB35C765CB7F49EDE4AEF8B9B089247C5CF982F0C3C3B1CD641A578A6D26539C28C0AD9FFE4729BF09CCCE74469B284C0FA4D9A00860A4E76D57FA86ED7AC6096A218DF3BDEF5021699EC3E53E0D5FC8E06D05A436BE23E5B48F1BDF157D1E02E753023FD700D8DE3DCAFCF9E5DAF33A89BBD5D5F71F247805B41BA4877F540BBD93A5B969D76E203A9544003932471978B0400A521577555217AF9013A0563130AB004ADDEF8E3162A3F32ED651E092A6F188738E650695764C6C86DCE0A5AAA2CBBA5960E2179550C3316227C54725CA46708A141CB770EEB4B6EE693921CF83E3A32B67D6922F748D2D8834F79A0C804EF4F84ED8879C441A41E27C457545992B1CA2F5A850B6AF777758A8FC52EB7E47973AA56CE979CB1A662343D209B38A46A2595EAAC974D366AC10A3982AFA2253AFB24D5081796ED5B5A960819157B8BE8C64AF98E4774B98F314534A0AB23024734768A38A95C4DA728F5CCFA7D00C1903101CF94D6E32ADB5B9827C3CEBEA3AF94E3BBEBE63FC5F62DB7A88B1CA082E8F540E0BD9939C3B3B1B4D7DC47F8C21FAB108BF11858371DE019E25AB1D7229ACA08F004440203889C1338DEE70AC4C31F51D82FF93CF5CAD1D96AABB7124FA5268FB00D8C5EBF5969123AB6E4539289019EF152575CD6F660F55474B394E0713F1ED33B9E6B99EFDC3D92F2A4060BBE305796F154B3451DB343A9E03C722883F7C344013BC89BE594860CEE4CB7030572E52D31D38309CAE886DA6B0FB6841A916FD97D9D0AABEAF1FD91DC08312D12DE2817CEFAB3260FD5DC89EA9A86B7FB593EE23658AE0DF088C98A02E51F0BCC223D02680204B4DAC504A205A176F7753F5EF9CB45BBBF3DF84995469AB44A3E0EE8B000545F3EFE39CEF2F23F7599485761B632792906E31A4EC3C93E6BE981C14FC5A3CEF459747CAC63DFC1EA636DB0BA48A43867EFFFEE4DA1E276EFF3D4C4AD017C6108B34E7FA3EDD376CF94187FAC4390295837B3E7AB726116D895F1F885B6D3ACAE0E2695F2C51E805BBE34B57EC3F2F6DFBC7150903C4F62776739ECA60E96EBD4A6F6628A1C51952323E3022899C6B5DBA47E31DCBDC074B8C82CC9CD3980EBBEAFA15A3F7F536B1F823AE89A6BF235A0C089A49C329E0B316E36AD63A35C7E70EE01E4707AEBFE33F4720CF6D6B77CA4FD5E1C3DFD6A105804630E2D42B74E54B7B4237129A3EB35919BC35023AF1DAFA9B0CBB4BE8D29C36D15682A4414C15B4F7BD4BBAF7887447EC6704157FBEE35F8F309C921152D82715503A8096E724AD302406C55099D1C30403957F4D7F4ED283297922D09E4ED67E38ED94F81BFF3277B565BFD15EB7BA96B9F16B793CD1195BBFC01A46CBD9937797EFD8D3503A1C01E46A3D59BD046B89F4ECA06DBF02823F54AB16CF4B06BC772218F766917529F01FBA453AF0E77E9C47EDE4E10E881472A03D097927C06F5023A2769817650C5D86B3645E9351F22B9BBAEDFE14F849798502613250EBF8F2E96496887C9ABE5EA01699013FA98F313D6F5281B5F656ECA6BF7AD4A222F2DBD0A6939F3ECBDCB6AEC34C392F88DC82D1571F9CB730B9D2905502AF52387FF69428711073E54E3F410EFC6D0167E314B8FED87B06D215AD61A42C77ED854C47703977EE75DECCCFDA0722D95E08272F6D310EF658E7EC6D54D05D31DEFC7ACADA0C745486EC478CAE191752B04F95D4CD9F185BBDD09A614821A63DD1F3F8EB449E45004FF0DBD954450350E0D2DFDACD189FEC729E0EFA8AF8246C3E85019D956FCA5264430588D62883AF59DC7BC6D2608148384DA5C11A32BF5E3CFAD2C3EFEC2FF27A1C2E1F7C65D851AA3B82B5BEBA85610FE7378EBA42F7A69841F076E8B5CEE299738DC83BEB916FDB6561961419D4454DC1E4EFF2128E422B844CFF0952F15352E2F48902445CC17FC83F3DB034D8C0DB9AAC387054718809CF3A71C3E4B7DAC6AF2C000A456EB4913DEF4FB1B0CB7DEF81E681DF6718972D77A07BCEC9B3CB0E3A4796A0FCA98EA24599A8CEFBC766A4625CB9C6F4E709C7EEC04D9E60A669C1DAE5D1524945CDEFA54E30535607CF0BEE473348C366578D97D19CA7DBBA5397D9B00043D606B2BCD08F138E999FFE6294D769C6EC6882AEF9832F3F91DC6CE6179C1EFB0F3BA4B3C85A70A68484E2CAD37B8E233DD296D011FB309237E2BD7083A505A20CD4CC99CB2B21463068FD3A3CCC3C64A334D16A99DBFD69EAEA2721EB85C400C5B7EC3608195FB5ED8E890D122A07B1916FB5934DE7B3F884D5745C12B762BEE1D7A602AD0BA1F191A8F7D5C08EBA8912D736AFBBCA20C2428705A0AFD2080EF34622DEC525568841FAC9FBDF357A2FE27887BCFE35AC4EC14557928517A760A6DD1366AB1A1C9DF3254991B65A6A44F73E1C693A4CA158CE0670B15B2D5455925D3B24A6BF02D0D1FEF0FB09FF4230A8D211E4E22618948B387C75FD851DB79EA75E3A9D722782F081B8A423B3C2DA2B22FAE536DAD73547AB17142B9511598E93CD7ED6F9E020141E41E3D8FA0224772EE5712D17828729AC182978F70CA3F671E91468D47CC590274F23753E1C7D54A248804939402CB609321718C2DC6D7CF40194FE2EE03817828D53D50996B19440827C654CD3ED392A383A162E94CF582BAFDF2EFD094BC5A5DFAF0C2FBF4A408E5078DE365580AFFCFDFD362DC6BF73B5AB15DF5B5153CCB93850672133A854F1137102FD34CB8E5AFC4C0BCE3C27E0B0910EF623C37F07CFF161122CB106F88D3B3195E266D0CB61A794EA929CBA0F0A738CEED6BE0734B9579505F2FF8DDEC +MD = 22A9C331B47BA90D3EF43D337CBB689EAE1BCB9555D2C7DF2752E482E473F115 +Len = 29390 +Msg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en = 29453 +Msg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en = 29516 +Msg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en = 29579 +Msg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en = 29642 +Msg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en = 29705 +Msg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en = 29768 +Msg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en = 29831 +Msg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en = 29894 +Msg = 2840336A7A1EC10CCE2B91B81FD9CDDCA7949B4B290F1538E6408E4108DE014E5CA133B8CD435B435B75983AC223E957962D943D409BBEE6D1157FE260589EC6F3D229F9362D2E915A4C6858388BFAF80B5C5C58C2ACCB1D15B66BDE4EF8814EBF1687295CC3D27E12487C20D9E84C5F0207CE59ACF5F236560123A7A40D1C2166F884B51790ACC7B322DB7D53BF91CB84FE286B7D98E58530C90ABCAA537CD40674C75D20D60839C101D938C45DEF855BD509DA23FF8EC2D8EE070E6662BCB02642CD574B2649A8FF6504C21AEF69AB059338C9B1879C38C6D8769361EA47A10EBCAEA46C64657A0E634F04741FC2B9DFC005D37817018570BC781AAD83E03E139F36FDF4E345887EA120C8949CE25DFC826753BB8DE96E71B7F9BBA21B812C49D6CFD986A78B81BBE4C9901925DF897ED6F195F93D8CB4CF78644EA45738D40B74366BF01ABD74525D0AFF153AA3729B4F4A7783B84FC19D2F795922AEA174C1F7F4C0CED657FF5489A7ABB2E7743933D1F940DD1284C5A7111A097C619BF507BE9582ED11D44F1F5C70021835BE2B46EA8374F7CDF53A10CE0234A14EF4586CC87B3FF6CA0378AFF1A68A3E2766A7D2FEC58E2E8B3605EE789E9A41D211C473A8CE43013670CBC22A7BD3DDA91D1E5C22E6BACD0E8036B30718AE4AB09C451C0A9DEDC07840175F2070DE82E68075D7C2640470749E721E9402ED86633731D5833B17A887074E781A71F5769387A49C3EEEB5608B3D41AFCAEF8EF112B7ECD84C640239ED97B75295AFA13F77D81F77E95A90284C3C23BA0E660620A39C4C8C8FADE8DCDD826051699660939C72DF9DF69DDA13C9105674569E1B88377FFFF07B01DBA52FB0542409F1432DFE0C14E69F339D50701F75009ED075EC2790601756BAE7EF4CD87CD3FAC00C10157CA30A57F237F7245B1F813BB1871EA556EEDF5297B5FD87AE0002FD9265CE4F48012ED45BD7FD76550E1D39A01B79C50799AFD68891BD868341B78A1CE5FA1F16D803FDA7FBA77F982DA340EDD329152991FCAE607662A5EA744B0470ABE57911F1B5E6FFFAC848F5F5CDBDA22D6121F661F7F4D3A06F7245F7E679528E5DF347CA67E7234F53F684946605AB044533120685C2011AAFC758F8E7CF2C05B632233C40A429D12236098A0570E05B21A3972604ADF8296A2E7ABEB323C7F71858FDC6EABF6783BB0CEDA249C948A7BB13FB88693A50360DA9294389E481912F8B47EB840C6335BC6D9397F20BBFDC0BA23337D1DA5763291E117D61D0B09C7C3483B166CCCBBAFA889BEC8656282DEBF5FD0F9A619321A7D008C26DD5B61CE1C318120AAA46BE12C8D13EB90FAEC612DA6F169B322BCEA4D6002D5D452B386E569B2B9A8EDA58B89C77C2F637A329CC9874A8FE4F22FA04D6484DC41179C1F65E0D5649D0958B6C41189F35D27EA45D5C343C48B4214385A8211EFACA4C504FC5489C323EDF9AF768047FA7F5A63ED7A88FDA532444CFD6C8038B6DEA55D87EC0F9B77FD5C42DCB6B541D3C93E012216CC25B7841687189CAD2BC18D285D60C650BAF5751455E4ED267F91E045E2CF8E2DA2C912C33F460CE51E04CE16B281005FA0D61FB31FFB28094C1476CE500AA212153F3CEC6BB2BA88B3252BC2029B899FE678F2FCA1084560C1E9D3240A4AAADF12953DF43B0A0AE140DD3C5C93533EF6DC06F33D36B6339E8BC32F7E3AF29186A621D4343CC56F153FCF288C164E8D154F733322C8FA395F5F40A6869628488B8EE708863919A0728D1BE7A208CD5B4CC618BF8E962B68BF9D2D97ADCA451D3EDBBC0BA522612BF419C0EEA8C6FFBF0C43EBFD86A696D458CB28E26BC18B6E61372ADB4A26E4B1C5B6F20039CF2881405ECD882B00117185FC2A69C7718F836891DF2CC84DB61927D8EAD0C91A9D22F8DD22E88FAB75795963973422564F80E0F75BE5DE9784E13350E59AFE95B039376E9F8E7AC0209A8AA2E635560A09C234F11D6862B0055C3959028C352797B83C2C7855C67BBED2C76D37BDBF17C120DDEBA5819958F8DEBC4A03763E90F3648F915AC915F5A1BEAB21AB84985A520AE7DE45E73CE27963EBD1E747545C8BD63A08523DA04F2509400C2B988825893C33D5411AD71B2A98CAA2F18E0B9145964197F2C30D48FD34232F0FD4305EE9BCCE53EBABF61C443D4A959DA280E118E0D24C9CD82FC7E7D5150CD7444FA4D570C9E3CE143354410B93B9D0B443087037FC090B02CFEDE0F1213C1C6F9038CB26AD681BDE43C40FFD15B3690EB8091CE967874E0C455C5F93F4BC785AC88AD2A2EB0F10526392126242B9A7F04333E8DD40B60E130FD6368E2276EAD1D813B07E2276FA334B495CE6770ECB80F2600F83DCCA60BF5EABF752BA4FD2F0DDEB1D994E169922ADD4F48C9DFD534EBB8FFB3A759EDF18E01AE12C282535CFA269AA46D03D812DD2F57447F837D747830D52DB04EA1D6B690D4913F9324654CCE386FE2DAE19883446C7BEBD5E1B61FFE9D6ABB48EB7F5BAE0439D437B2C3C2D04CF72F6CF023B96895759C5E9211E61C0EC0C2A65FD3A5042849341866EBEA63F8D6DA7A7A3A338FDC7475697209ABBE40417C431B8520DB29F6424AA1705370C5AAA5FAD83795DA0A767EFD6F604EB153F3C9C9EA34287AC53DC8F09F4879297B0AE58368DA409A33CBE11FE803E752512622F1A7797F2B2CB180D73BE9F5AE160302410032568D247232D85AD3AD4170BE29A9C383B89068FEABE5FEF9A2B4A31976118EAE49195778AFA76378E27DBD2B8BC55642FBA6A1A573A551F4B6B2380EB5C39A6852D8F19D2194E716AF0A9D020E57EAC39C31EB5C628F7DDF1F9DD269798A78B302FF58EA7D2FB23AEA1586C4010FA3302B140161E551DFC12A5D2214681FBCE82F4541F19A08E4D2027CFACA3C69E88F0365FB05FBDDCA4F6E55EC9D1CC90D4D327C692BACEB8BBA8398787CA85AFFE51DE10F58E6DE567F48E17898D51160FE62E08F9ACD784ECD0D562D23EE8AC76751EB4425BB6F8830746FEDD488A413459B25D8EC5D75700BC7B40BBCF5D9C12A075BD91C9B40CABF1F22334DED2235B09E1CE4565E8FA97E310099C69383D772E1C47B3F2B4A36CA7308E5657AAA420B78BC2805F8F99F95F6346C5F6C6E6D80B9937E5058A6FCAFB15471E43322DCA402BE4B581BEF4B63420DD743147D14ECEFE6C44F23C2C8D31038642BA9A19C15214985D59E459D617E49E2A566483270DA034FE8F21084CD162833C5607A83E38A9A289E00131629085A1E45ACFB8F6E2DE1DB47C2B7CA92C06C8E0A1A831D59D7976073ECF7756A229131994036F089B9E50A8EF44834C95FCC32ABE8021F5921EA9D035AC16ACA0FF2A58DD1E4543AD846961ACA7A854757C3B2D6FC97821E8F60E75BAA8111708F9B79F1D15B41FFB62356B938F91BDF58AE323B03A004EB931773861C6F74BB49976D808FEAA42F9E55338ECF7772A6DDF5EEB4EC289383F5F441CCA73868686C0A314FA82EDF9B576EEEDB413FB7F3B080B138732B1AEF7E0013D7E8ED2D8AE4E391515B9582C6496AEDD27CC0EFBFBE623BE7882FB09D7229BFA44F633519708F6C2DEFE27837E4EE156EBA0043A15573E630341E18EFC42F2ACBCBE19B7C497B5C1F55F2FA2C219483CAC3CA6A623F3C0E0981D3E171C670C4237B1361D65EAB4126D59F4EACD405947776FE3666CFD96EA41444306C51E0D51EC0536F7D2CF0449E7CE2B4F401597C109DF2AC2DDF0C7683DEA8E874208FD4860548415D2D3B948F01A7213DB6B687779D29A7E21F954878D39177A64E8A6621C7826E842BBB6D581F584240D2D3A092DC0CF10E7725E1ECCCDDEF3D609368556795BB8BCBC21930E2BB5B46FAFB509D7850285F8885D21046531D5642FC01380D67E6EC2ECC6F53102AAAFCC027B1BF2831379C65CB62EA12A4579B4800F5B72948209C851723F44C96E90DC83C9DC8C4F421F4E7B05E6412CA207095316253D7B3EE66FF9EAB679949C424EDD55FB85526284782E2C26433976438D42138B8684E18A0560B80106AE008E2C88F58E164C73FFD6B117322347BD668DA09A40722D9A4253589454793AB0AA9CB46DC703A5ED7B886451BCAD6462B5179C50C44A483B36AF3F13DEC336D420F3F58F314939F98E817568CFADE6BB890EC0A7443310B3E0BD974AECEBE2EDFCD40B88B71F8C37DCC56286251246C0922123E962505A481F1BDFC611C4F59E4BCB20BC761554462E628C03EAEFC1ED1E3A41BF4E089281963305AC6E09568B74B201C7FC1D32200A7A406883052D5BDA18D3E081CA215249AD37284DF3EF1F03FB9EFDB09F6A5304F7F876C5726FFB197289E263745A250AB7FBAC1E21E7A1CC300FBCEC9C84F91F4BB2CA991EBCD20EEA636B11B409817AD0D34F2FDA88F37E120B8D265BFAE38A3DE629FCF48448BDF0F0C24F65D2CD32B8BE168A1965A4C70772A3EE469F2F530F1A6EC0245D7A11414111DB64D6F3673912485E7D8942AB666AC1AF3D29C52FD27361E36548CC8FC23D6CA9ACADB5F34C644B58C5AF7E44A1FD270BE460066F1BBB9A3CC54C101BED5A81504EF1F5436190992632771422DA86EAB73F67F1B6D51BF742D029BE8B78D615F671CF42D72F15178C5AFB1EB09A5FCF3D2E40C6038308D63DE3326A4B9C2BD72ACD84AF5A92A9EA75B34C1502F9016E08112FDD8D1B0C30ECB2D66C0D01B19E3247219B7E31912F12BCAB60462BC350AF02AD82ABA81289E85E4CA97B25321A9E72FAC8BB4AA8134A6FD7AF66103FC52EB682530F05BDB8D22BC00FC16A61710FB2BF29D9ADE60BB88F023EE79E6F8067323005CFB0163F426E171B1566FF2FBC7356FFBCECF95C207108837216EC80E36A02B0EFD6E43EC42911DA268D210AC95B805DAA924DCCD899D86E89FBC46DE56D76835DE2F76C44046AA353B12469914281A7CBAAA5AE43D5C3B02CFC30252101D7A43A6322AF6AFECF9BE7496C94E8304D4377656D5EDB2F169BA0E269A9EDF71BD7362C9B85ABD4C313DE9E3D7B65B70ECD5E8DD92A1A33292BB77C6F6FCE6E933637F824068FC03DE31D383581D2D8CD1C4B9A690D0AA0C1ADF2A8FFEBF40A7C4C4F487CC91727433F15E2DA228FFF1A014EE0753ACA220D9BF50FF9C8AE80C6DC0D8FA4B20EE4AB66C5E245CC4A5A4CFA62DE96DA49F4E10A6F6DB2A77614C5CE493334B7E84BCE94E04E88E91FB699330F7FCF1D21EA6D64ABC18D2D8519AB97B5E3E4F9DC64917340241FF79BC570AFBE391D090039D37558016A7109207A9E2F4 +MD = B672501D86D177463BFAC3DD8F04516C356F097B7EFB62579A4C349509851370 +Len = 29957 +Msg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en = 30020 +Msg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en = 30083 +Msg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en = 30146 +Msg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en = 30209 +Msg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en = 30272 +Msg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en = 30335 +Msg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en = 30398 +Msg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en = 30461 +Msg = E819D4C74E2246C339BA9DD8056DF7DF0AE53F0E2ACDF89C3CD3E190F6EE79054B6FD77598C258EA8CD69421388E72AF357B30E3BC50EF17AAEFDCB478118B29628B22424095D2F7F2DC53F4BE36FC7B7F722D77DC6B53AB31033D6C70517133C78A4463FE1B92A9875B1156F81737730EDB6FEAE6959CBEDB9405B2CACADE94D80EC7853E13563855119A58EA2BD5D30DEBBEB8356AEFC06744D5C08D777F88777AFB838B4927195180BC90C5BF060B0B0DDBAC179FC7A103761C04B04938EAD3D6D895570528D79341A6907687C323F43247066CE050F4C4EFB367D16FCC89005DA4F107D92BEB67928F766BA73C18ACD73742E636DD693141087D41FB276DD69C337E56C9A177960A259836641671A71426CC370336ECBEACDE61F84D6712D360889BE52C568EAE521D6F9E5CFB57462EA6B34831BB65B124AEF69633D7D68CA4A0282058FA526BAC8D39C05DB30BBC2D695ADE134406C6AE3F244B40ADB9C748EA7E51CC40888C65F89D58446167BFC8AB11002394F30E13709FB4F70A497AFC3897C177EBF44B7F43FA16D9228CE460CC09E6196684D2CD0B406AC5BBB473EE27F5EBD23207C3E50AF6EA8AADFA4D48494E0B9847A257B68094804632E3BB48ED5CDA8B9987836728739F28FB0AF776A38101420E2A6164EC70DD083DB536684932AF3708711BB69FA8606F2A32920A51EB5C6061BAF33F5EBBCD30A74E979EFEC40CB9E2F5759183BAC35ABBF581D509155C879E422C3DCF1E91C89123AE6CA86858F260B9C73020AF1D4C0D75F4F65B929DEE0B7F20C2ECF8927859E498CAB5FE6729F7B6A2BF6EEEA1523EB0B26D90E24FD132DEE5B44EDDEC3DE16379FA6C9EB48CFFE0EBFD64F62E593FC6A3303AD7866EFC91D218EAA1B0FD2AB786A70727948921624DEC653DBC2EDD999B218E146A893E0ECF6C9EEB5425AF5E125EC52176042AADC41BF6763962EDBFD621388E121FE3BAD936A8C9FC9C0F2CD8F99FFFE1E41D7DC320598738D4D8725B8189DC0C92D0D4FED946D8DA8F94BC4343ABC736A1713A03892E9FD534A04596DF8F5EB8099CC2B22873036507638973D4D8BC6CFDB5EBA053CB9C85193B2184ECEA365D44362832306438CF3994B07CC268D10B788017B88647CC147BC4AEF44733B68A846C04C55A22209B9D328326FD8357FBDFFCBA22EA8EE06C07A472DCB2A88847D7E4D23BE8557AC01B87FFDC90F3A9718B542078744C7DE68AF0BCD2B631C83C4B21A35B14E699C6BA2C15A9179C47E6AF71380F44A31661D90A7627304332F211CBA78FF567F2C50156C8E13617E12C08EFF5F7EFEAA3BAAFE6BBD085FF089F9BEDAC20261BC8E84F2762C875AC0B1A5782C7334517681EA1672F42D93B51FD48BBC0BDB9A68E1B381E4EE2318582C948E434E7F38A25E607FBF1C3785C2A068AFB260B38CED02FDF2C113345EF412BF64DEA8EAEBA68C0619FC0357B6E7EDEB26264E75127B4044AD5B7C792C8093FBA2A34B279CE68AC7C170343D5BCC47DEF1A20E6E47F4EBAFE6B823C8617EB8EA6E27C4A8A4313C511D6F1122BB00DDE924F78BB9E8F89303CD0FD249630CABC81817BB6E99A95B2DC243BEAB272B05896FF1ABDD93654F8F82104C30300E1A4E3DB7CB45E05ABF3F2F86711AD9B258A4EBABBC6125930191228476B13CBE765EBFB6457377A1B6A6B896BDB84AB9241B82B58321528EA7ACD2FBEE31E793581FCD2860C0B9F27704BFCF587777EFF1A0F15EA55DF470B2785D38A00FD5BFA882735C396EF5C04DDC29AE1CAF9325886771578F64B00338F1B2D19FB8E007F1946D932E7647CDFF8AC99ADA0C3481A6ABDD30342597D362F647FA2A791696B261F9CEE6082EE4A60BA8126EE3088DCEF394D5D1BCC7C7E00F368C14342BDCFF5F99526A1A4EC5C4809AC97FB11E5AFB76E54D289F23A5439D8147AB84AB1E54091ED2A3B3258A933931561419B070E475354B67E30A9DED872E3983FFE218E806B0D80B449AE814E0AC24CBA5C869029478F8F98B7014646F5AFCE8F81A4902FF974224B2FD4BB4D4C55E22CA38FCC916DC025190DB7ADA42545AC59D89995BB4640EB8CA05DB80EEDE791E9B6B237B0B9FD682447C9DA992C9429F9EF2E8A5C8B93F73F64A17A7D6D0715438A1EBF418759158F882ADA4E7489A769629293643130E9D20014184F7705E85DEAE5C555B809AF5B26ED47352675C3F5BEB2B78DCBCDA83E20EE8748D2A3F7A09D78119725F2B8BF4E9B8B08EF984849FDA907CD0744B5B5A69A5912F6861AC592883587DEE2667E0032F5D391C1563C64B35DDB69B118F116F4FEC1D5AAB18D19F22F4919E1400572899BE77021C310D6832647A9327303777CC6F9C6FE22183848B5FBEDE19D5C04A236B231994FCC9C6C40F04C0CEF4E959DD0AA4D74543E8090C7669324D4DBF2A69CBBD35EA1FD4A9C199057679D2E122BD1666F87B007E386E5FC9A838519C2C2D9D930ECFE0B5B0905F27CB360ED81B3D8A7D706FC63D542201471D4D83FFD3E9502F28A16D9CE0467EE00B26F18CFB2425FD5347E4D3380EE5EB67291151DEACB0FE48C5B34BD056C2825C99D3185576504EBE0831F8557DEB162BD9C31ED31F5F0F2BF26DCCECBF625511BBFE96982CB31C19F124AC3A474C8EF1949D2A29EC29853751D4DC38A4E0ADD7D3A6BE21E028094E70D428B8F231EFD0D0DFD6F77E84FB616E8900C3325543F3E6A329E33D25123D922ED55911AB8AF1FB8F6E1E3F5FC99E2E1F2CB50AC87D775DCDD2701B11B7D5782CC75DD94CF8047FAD55B5E9AEF462AD66080C370E3D53305911A5BCC445663E0CE8E50C3ACDC9E7762BA7B8EF7FCDCFAD6976DAAA8CC3A562F386B7F81DDE8857BADF3318790CE836E0DE533DB85B04C66176732FEA05F7CB2F5A2185B6C87DDA02E5C60A7E50413B894370A7FD69A7DC2B096E409EA336A01B2F17443E3B51C08B91F89F7368E103C823127CA82FB9011D533C9819C8B990D9187D2FAD0E22E86975517EFEB288AE9864B7C6D1F98C23468603EA1CD5047E1A553FBBE5332DCF78434CF8480D703C53778AEAD6D38F7597628A3F8EF60952F795B745D3CC3C8177754A0CCCADF65C25B3ADE9CC309537421B35977874C0C2BDBDAA249667908123AE616F4921CE8D0FF547249E151984659A1AC1667EFB346E8C0A58273E3A9613858A6A98AD53E8B7754B9DC293157F0B9F0048BDDC5C56A297548C6E94CB887D1E149F6F8BFF1D06939835B05A07FAC870FEB205A51EDCB42D96DA0FE80604745D01374F066A28F858F4086081FBE9E90424D56B09A4CC47676F6ABE2DEB700EC8A44FF9797E31D455BC1434AD0757C01C923ADF45242FC63C9D1BD36A1A36780EFED40DF408C770C3781DD43F5AF0C593C9D5548B30D75982C8413D47C84483CF05DBB245DE72310B3136D9C07919B16388D8031F1284E2D4233FA97DCD21219DDB7F615D5066E3DC79F7FD613367EB09C40B353705AF79D53C5264806D862511F065F5029D57981CD6BB2C58E70F2F13BCC54E85053E38794B628DA57AFE619A6449339C8092972DAB0DD999F0505248E686C671550B0D31E1EE963F590BDA83FCADC36E546D2C4B82B656015E00F5C75461B9152ABB341038E06E0E864D70C1FE8E80D9E6DF7EFB9F6C1608B246B9A7381109CEB239D67A83606508341723FEB9EF8639EC9AB091F439A065315125D4C70DEE7B814AF022F6C9021C0EDD34FF585CCED89B33671BDA9C0773839EE0D02F8B86165CB57BAF1F59BAE5FF9473BB3CDCE7D779D554EC1EECACD6D2E6AB7E0BB2067EF34F31D1C9C0B35EC6166BA4BD3508435BA082D3D16FB18F070B0D13C944CB9CC2790195C5465EE49A61310A1F8BCD5FADBC3180E1EB94F72CD549B9CA8DF5B56F8898843D5546B48C5EBD84DE455F2D03D18115745364F0D60D890501A11E8533A4EB39A6A4FE42107711810E7CCF483508EC0045FD99A42F9A82727F6B932D0306D076CEC7398197654321E2C6E55511506DAE162209A535571D5FC93B6E647C8CCC5E8C6BE85DFB9A837504D85A79AAF568573ECBDB69BEEAE02F3E7BCEEC2BE30F6825E77EDAE5C9844D87FF731464F888EB9427A0348BF3E05A9E1BDC0C4D5BECF83BE18F5CE6CB9EEE59A267DBDD3DAE4A859345B9FCDA28A96610AAEECA3E855E45850AACAC393F9B29864B2FDAD46B6AF2638F1847CB69B57B70E2D9D7FC87D3816E3D06AAF3918BCE65FEAA1EDDE404EE676942E3626C0A32E882E73954FA297860B3698C2ECB76C5C609F93624190F4FD33470A015B1FA44F74EEA3F19C5B265A6D6A31C8D037229CCF754FA215076F70F407A6E5BDA54F2174B4115937C9CB0844379CEB0D1215BAB89FDF3D24A43AF3482AC24155CFE8E0E916B2BB3224DEAB791ACBACD5D612045A571916D4DFB5E4AB73A608259DADD3C9BD70828433D3DC315D4F84AB5B66976D0D388A87B1F20508339B215BB558F3E5570B1441D1D29020F3834C5AA429EF407EBAA56621E9C2F58ECEC95E1251456C1B9C4E3C2CCDF5B3F000B5F908DE4328C4E2327BC097FC7A0185817B9AFAB41475F2010A91940B02645F9076F4347F4DC39E1F04B4C4A54F79010A9BA6AA8177A2E385E719CA5D1754D368A68DC5C5CDA65E4D5B06F5AE3EB2A070BA55D01F0F7AA9E2009775C0A6D5695686743CFE3A3ECD8878318C0491145EA54944AFC12CB3D9687B4B26538E8E52137ACFC79CBA38A2DBF0E081B470DC5DAE3517207F30CCC354C95BD99EB97D9B22E7FF5314C80B6166B6E05839E1F4F8B4CDFF65ACB279913E2AC91B3DEFC8E8EC19B99EC026699BAA0E5C316A00F677354888D7494EB64CB0F1C068705775F5127872415236941A3016CE9D93A90BEF4DD056B2ACD2B3BDF5DE40049B4055EFCA1529F5DAEF5158800F94B6875145D27270A4D6838316719216996790BD7F1B30D8EB7D2B46EE31F3A946104E7BD22508FAD187E2648D6F135137427B94EC29C751A1E85B9C409A7E2BA608BBBB3CF3E342EBD9E6E688D114D2D6E9A58F1446D56706920C5F1CD7D9BFA716291B717EE5DAEF25BE86A64CB44CC15516F85A319D17B883596C37B2AB05E47F657F14249EA01C31430ED994E9BE75327D93A05298ACBD1731259D41EC6E04A6D53EAA805CBA00EFA7E6FC8CE24E761B12772DF6C4E20BCA5E7E32E0A18D896F4A0BAEF9646393F84A12AE04931EC5FFEB60BBC940E19444A2C9D77AAE3EFD2B7593AE78564A6AB11732E1DF9DC9CE13FADD7A181ECBD67AFD977C53B0A689F45241D2F17BCC6A10A6A865C15B86D4BBAE42F77A9D6776E17F794830CE15CDA630F92F2B89EFE59DBF20D5D1DFBF1FA3A03A11128940F217936007570B62DE7E45A83E3738 +MD = 883D90EB13F0A3475F7F79624C242056D11C7A8CDCD26338414127295ADBB934 +Len = 30524 +Msg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en = 30587 +Msg = F0BAC9A6A4524E9BB9177A93DFF68B6C7F646F533ED48815B6281269616E46FFC9944AD0775628FFEA1D0AE40D4A3AF67ED50701A805C9646AD573B63B9CBBDA4AFD8099F745DDBA187630AD688F2DC08CCD2B58A66D51A08323928A43BBE26012AC001CFC0199EBE6473793CC75ED65FD0F8987791745D6BC150D4A898F29A5E4E404AF4AD8D8CE7BAE208EF23B731EF4652FB6B659A723B7E09869DA33A221EB253094D6A6ED2E5C43179B8D054AF4518C39BF5991CB62A5BC1B2D482BC823871DED0A6CC6E3064FE2703BB875E607D268D264D5665F3E9E1EA5E6615A2869147D466A59563B3FE2ADA0F003929DF6C812DF6B6A75786314A0869947548EF97C77D7643FDD578D880FFA62E1ABB30786FD5295C81AFBFA8EC466779411398D37FA25EE93CE087BE6DAF68805297F06734E28B6B4D3DE44615B05036A14FDC1070766CE2A982CC9D2358140BE2452D2D1C530259AC676821DA9DE333565D6F349CF135240FDC99276F19A8F770C2360D7C4D8A8ADB682FAD95F9B7F4A203320EF5C1B7C50DFDC0D2A3069381686C14F5E2127C5E55629FF9D7EEE8C7658C26110895E791C001353107DE9025EE8EC9AEC41E8920B216F786A91FA845E3B8A2D2A6A9E666B5389DC9990595B7FC6EAA0D2E0556F24FD7640A2B55756422A54709F42CA1B7A02A40D6761445371C06763820478A1D34CA5C95E42BAA4E4951391D2AD1CA0DE8FAFB1BA02D227C07F21506E78C5CE475E12C2605543CE9C005292D872DEC5DF55A7D039511452E96CF4188517C286A44D8A85A0EB7432057EC32F0F4A07C3F4FD0AD6859593A4BCF57898239DD063BF9D7FEC7E202CAE83E477266473AB22460900E377A2AA901F853D68580D17A6A102C84C12046EC81CD66539BBA56EDA08496BC9028A6692967577CC40DB8EA14EFAC60DCDF23B91970AE5B4AEEFFC1E4CAA07117F775700E8BE600BE6BE7E9C46BDFD7EED2E541CDC5FFC9360E1BFDD895ED7B642AA44E9B624D54642E139E2CAFCB5F255F3D504513501060007CC8D225741AB3BEC797023CB0B8155A5EF30CC3E4AF196BD331AB4197E9F419D85EA008D0045A4B3616A4B41C6FA1C574A37E15EE31DB0461E9F50B7A2171964CF76E787C5B7095B1DE63897713118C049A1F0C1D68686F2963EAEE7C0A975CE59BAC4207CD6115B142B4B13FA7AA5934B88C175E232781350FA37B9CAC5D20BE840BE7D57F6A58C113223A10618E620836B315ED2D8CFCA100EE5E78EBE40F7A5E08E7AD9E05B2046607A1134E4B38F9E054FF31902C9B46FB7E5D880762E58AC12D145A70C900249988F3113B24458D3EE1F6C8CB87F58DCC9B694A99A0ED0CB6D74455EFEB8C9FC32F01855C197D50B0ACC8375BCDAF99A8842D25050126054D50C900C72349F57767E37563D725DD34F483DA7E0B94E0F0F6BCE9940DD94EFBD8370926F07B12FD382CC32CC751E8DE6A0F69974D0621DD7DB2D1BFF0548E99084C0D1C2420F75641C4EAF3BD49B7FE9CDBB685F93988295FFDC7BCC3F7B9C21F6E389D4F7B5F921CCF803BFECA5FC1CA23AE9CD85889236A4F0D3D9C520A16ECD9F9CCB7865704CB81DE0711580E1E789544C857C4BB943E4AF4772606EF9576E3B4DAEC14A2212A29BDCAA44A9424DD1058DEF59EB9DDBA22C38AFAD0B1E0105DF6517ECBFBA2BA1C0387A8D4C295237C40270B333B2D5E930B44AB85B606E6D63404598560B80F93CF1745E0B48B045DA4FD18240A2DEEF20043076FB7E34736D504CA710A4C762FD08D79C0BF2D2298AA04DBA58A14A77A413A5A10F3487A78526E49FD669DCFCAFE0D23F6B25989F177B2542BACE29ADE0CE2E9CB699968C9D571B277A26D680CB035C40B26376BCFA782E9C6963FD0ADD1AA0946A9DA1F4DE13F186406F015F5368E51A6C6ACF58D650E828B683D82AEB091316AC55D47974ADF95DFA8CD01997CA88B81EB5787A037578227B247019253865D0D1DFAF6A3A5F86A9C65D66CB35EE210BC460D580B7CDC6160011D20F5C0D81AA2E7C09FBDD94E0FC663F0612A03738CC62645A8237C3D72AAC26D89079CB6DF82AE306AE36F5053021BCFC494A053E3D235997FC962C1F666E293F485BFD7669905D06ECD6D4F061E7D699F3816B89AC6D4F7475A9A1182A18A4FADE885EAC4525D245D4ED58422E59188A70D529F696C91FA69C43148410179972AB9BFF94A2697008B12FF928DE703AA067BE64170BCD5C0A0B07655AC58C10D2FA17EAF59DFAD01D5935F8570E591FA31565D7E1769B335A4543C2EFBBB530DAD5433CD3ABB59DC9B9B5D36FA356E3AF6DCEBA45A70D16120787159B452084CC0CD0D878D40BCD8E3AB0B6727424D40A5123518402CF7C5930BB599F97BF19174DC9679F205A814DDF32ADE3E0194398274F240FA7E4A9FAD1380D98CDD975191411FE608A6416FD9229F15BF1FAE8F493E62CEF52CFA891A2842CE7DF6EBE36124F6ED9C73957193FCB4E39886D57082A8A13C36C47483C19658D5BCF48C906B49126AADA06686705AFDA2EE1DB05AADC43C1D2196FCAF58113830FFA9B995D0E4AE5B658F7662EF07F8A77C76D1CED10D9A3CE3F8186A407B1FA1253304D4AFA7869FD1023A9C6613D5DDF247E7E52BC34D24874F6ED63166E95516E3B534E90727CEE5CA35C543F779FA0774F909CA99603D48F68E047B122E4B15CF1B886ACF17947D62E5D47CAA213A153D588AB66437AD40C81BEF1050F4DCC20BF120ADD14E2D5FCEDF35FD08283B23786D59B93BB81F57F6F98904C2BC6ACF61908661032460C41A70725B8D3DD58AA50D5CB7464988AB38411F42027D659F47E14FDD0B11C4ED842B08A606F49E8BEC120799B443308D7FC4E4E7395FE11CE311E1FA28430B0B358194F393C28E5D8EBF0B49CC71E282B4EE827DB0ECB98EC8B36246F7B983FA6B4A6B6EAFBB292C1DDB4CA4FF88D197F2DC8E9F407D3032C06D351BC4274755F2D78EF8A53D8989B87C46E767F810CEACF03D088AAF4D918C0C2FE34F606EE5A4EA9216DA3BCE156B74B920872462C0EED0C1DD26C4493FD906BAA143BB6A6DFABF58B259170DC38EE19EDF5D4B06D215873BB05C40E02547D9D064E4889D8AEFF48668E4C139F2EEA4E5B3D538294D062AFE98840C2C04297C7DDD8D356000CB66ADC4D0942B1D695BCDBC23147C9B335B5E3DA735C03B81F843CA318283B70999B0B9B038F469986EDFF1249459123BB6E3A80F2B50F0F2041CF7D7375D11B856385595DF0089F512786A0D63521830F123D233B51D754C9D142A066C7CBD696548D3F6D4866A98C12DA29543E94280F7C60247E22AB5FCF7F9795913460103572BDAD12E5E4D1CD7B216A7D3EC5A31668F5008FCA58ECB75E10151F392AF0E0D64EC296EEACD0C0B48A458665E0EA964A455320B579F0B62E8C2C207A7932FD24EED202E93EFB15539A7271864EF4E1E690EB70995CB1F940998479385BEDEA48C01DAAD932316D9A43B146BDF12FD7BBF57BFC4A735E7DA83ECB2E8F7B023733AED7EF86C7507D5DDBF36573CD643072E0F3D832DCC5235E4F1A522C455B181D35BEAC60D5B6FED4B974B20A4CA6ED24A11BC02303A036675E43EB3D621F8805E1845B294C8558756F2A247F0ACD14D519402DE678C5E472C4A1F7DCBEEC21AD1F4CB0999BB5113B889447C74977E1E8F363E8E50A6B7517351D5523FE8179BA6675839827A3B0A3A19A6348D92BC46CA86D6CC0E84CF81719AED20EADA9D6BE39391F66D7BD532BCC5CCC30E9B9C70C11E3A094D741611F891C8108E7B56BDF1E323CF5C283287A5B3B4155800FBB83B137EA7247FF72EC521F621C69E8C3A7BB64AE3012EBD078E9941FBFA7CD4E6BF513E61BBAF8456C2630D530E01C5CB843D7C36095C15D3E9330CC407D4E60E3F3E8A18ECEBE92D99B18B27846D215361868939309A8BDC2E03067BC4BB73F47C1CBBCB45C124B1231A30F695B768D03C9DEBB24F32B023E7A6461AFB37BF660DF470AF1F509A8A103FB2207813099B8B23913C1C443F963DB260D38DA9C83B32A377EC08F2372FB47C01EA258431516AA69F79705E385501EB557749000E470A899D436B8897F7A7F2AEBA0AE455CA49FED5877A43C90F117FC3EB7836BC92E7A3FE76FEAD1182E364AB04E37988199F3A50889C9A8CEA78A64984F2915FFB06FCC2CBA5F34DF4963791B41B4A8BC6E51D783F41A83D046041FFDC00E21669F3BE5AA849319A08AAD94419A711F51C98EFD7F10507894F30F1B82C1E6A320653E7B16CBAC55DE4E952FCC501799D02BB30EAAADA550CB6263AFCC6796E39531861AA52BB6CCB238A529F93F9EF485A503DD9EE826532237C93F31A3F9D210B245CFF25E0A078538FE32A8B1EF22B6FD664EDFE6C5A75BCD224D76848B6506D935597FDB79AD95C259092F15F1119A162E1565FC914A01347F9B017A20770098B5C0986714CEE356A96C3E258D0F1B24FC3E76985EB57D9DC7699E1D275063EEF6065140EBE30DA38F1693103DB64FE91EE08B7AB617763928C14B8A0ECA3E77975365A3405851D8A29116A8D0159EAC615733FB565EF7809F3689A43475A68E8331C4255021706E6CB2545A785FB48DB5FA36F3BF0534B3291A4AE32A7ED35C361800ED7377FC625B11DF3A89F2B1DB8C5786F1BE8F23A14258CE29880A2E104AE3AA655ABDA5437582199FC111D2177E51D26E8A54421C56E4A83023703D35A32587408C7D05DF3010DA0C88F23C142BCE90F8FC4A17191EAC5899424C9E1E5B65DCB9AD95386B6E0EB2286923BC44BED151A2637D2A121540DCA12C345D3F5E852197BFF352105FE26CF3BC2E86715436E21467BA1FF7805F4A61A2E07F971CBF1870B9B6E09B6555DDCD133A5FDE7EB960D099F7018CFC2AE9F86F4829A5ACF4D0F00F7328D98ED77695C971CCF1F8E7EBF992149058F88F2247F115B4174FD06DA8DE1E7D3E3B328DC9FC392A5F408D05CF26934DA40F090A8C893C7465FCA9F0BE137EC79C00FCF4C2857AD3F2F7A6C376BC46A864A75873ADACBCCECDD8DF4C464C95F9AFC5FA82421D399790823FED2395386B3FA5795600EBE7D987B325EDD901178BC3378788096650195886AA3B3F902106ED58E7A6F178D972EDD2184B30A5B2FAD040A4B6D8C4E9B0146851F8AD592F682447DFE2E2AEDA78154E98975DE4DA3A7450E9FF767B89E40148841B5902AE2B99BD50DCB6E8EB82EDF2F3550D00FB43AE24A61D921D7BEE5316DBC9D6BFA8021184211A1FEBF272645255940DD250BD390446A6ED074A830A8FFF3BA0136715F850A814781BE174A9401D9B1DA7F2AB9E26DF8BA8789C1BB0A7E94DE789410F7ECADF57834B250489DDB006924018D08D96DCDDDFF1D7E3E72F6647698DE976C294E0D2CB60 +MD = C4F22956D8F8B2E43E4ADF0BAE5F12098DBB8FE00376394819B4BF5EC88E7041 +Len = 30650 +Msg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en = 30713 +Msg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en = 30776 +Msg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en = 30839 +Msg = 8233E8AA6BC9D358C592048E45BE3DC0A196F3C37507A1F9B9091997BD9F29E8E44458DDE26C1976B481D1B12C2B825A56B83219506DDD663B679B9055AEECD5C18F2339D6F14EAC05F4FBA5EB093A3161E6F4658F46B2166B2E1ADAA59CA43636398CE9F7F748E136AECF07A413945E1C4FBC5489EA3F0B63201626F80B01FE8716125FC9E31B5382DE8080E6B729980BA0EBAF6ABEECC4E7A174B504AE1CD8CCFE83DCA8CC600791513619E2D5E192CA9CF94B981F3C95B58F4331ABC77BC36FEC2BB6825DEA3CC4F070EE252F944ED1452F5FF37F1F48B92CB34136E034105598E199927DAA4B0A10225F45DC9CE20C486CA7F61406002C4E8D0C44647D5BD7D03B8923019D30BFA442344019BAD19A4EE71819D6AC68758CC93A1BB28B9863F4EBE6512F39202DC600138F4E0193CAFC76C811B04285938585462260B567BDAEFDE67D133974D8C4379B4F365F95645958FDA4DFB71E9D792B0F38790107EEB5ACD0D199B3C2A0D81678C2F016E683DDBFFDACC031CB3267F2B7F2AFEBDA8D6A5E4B5D2D87238F744812B4050E2947970204F83F27DC7481BEDCBC2085F90818749EB231DAB36CE4A703A20E2AB31AC01057350108280EB26181656A4874376C89F40BB95A15AD16A95E567999297C22374DEB6BAE6A8DFFF5F437AF8078836014D6C83E36760D2F66F2B1945929DAF71539F6B155A2E7348227CE1097E7A4FEE1913C428C10FF74213D151F6B8E2ABE7D7FDC2A59120438EC827A2D4526F2BAB1632CAA938CCF0043A4AFDE9F1E45A32A5FCE33112618D55A7444E62ED992D0775FA0C41AEB458079268A1DDB22C0DBDA4CDEEF447F08CED8AB4408EB5D8F33F147222DAEF2F5013E7E4B6542737D1DC0379808D1BF835643B23D08D4A8DB6F9137755999AB14621F0AF385BF6B25AD6D1501E7E0CC9F0319370F31E5CB2D4607470E01441EB5A4A4BF02DF8EAE3E56684B29EFC39E236E91974958C218A506FD8C9DCB1F7F9E491983247E58712140B5A91F8B2735FB9B351B31AD97E283F084FE1FD2C752F0CAC98A4B17516741FFC0694F52F6C80FA0C87F616E53990585140D3FD1CA003C0ADD92F331C1DDF7FEE7C4F73A81DFB6A1489848DDDAD151C20AC92A6E53F22F805994F24DFEA9626B0598EFF17BFA79A659AE3725555350F88E1151C3F15499B238A7B235F55427724D77CCFF32F06DB691EE6E03AD878C473B8FF657B4B13D0182CFA3D29B113F263625045F3EEF10FD8D0FC8CBBB5677790862AB503E0D02014754842D1713A37A866034B37A4053A9161CC8EDDC46E86EE8B096E6F876BF3A4B7128E3C5324697708A6090B5AC096FEA1EB5DBA862CE92F2DE0F3C5741592C18AC0CFC3CBDE145E0892E7555931D59C5E4BB1C49070FA5556F28D76191A7EF648249ECAC2D496D98292E5D2966C43B1F042E6330BEB09E0FAD75E3B87F04607E81087576A7C8E033EE1D65180BAA65A22D19863B26B86FA939CDDE45430E24BCFBE6CF8097E40A207845FD48F6EA46759746174250A7E00B06470F22FDCD68CE8132E99DD351CC9EFFB0EFF94A43354C49FA1D7489954DB40206B7D77A3A8F5E4DD0845CB090BCFDC4B3C272291ACEEC9A35379139D28AE6A6092AE6FB1B1ABA65584906F71576B44DD28BF519B79D9C25D47DB9167F51B0249D3192A7B2278152BCE2682183CE106BE6ECA9D451E9164D96E8467045A80D290DF65EFB2C1866EFD0CF508B95D29C2B31CCF2F9323B9C5DD001F12380A4F4FCFD574808451566A2D4A7E4F641D7240999DF37B8A061686C829D7D4D3FBCD17CC8D7F4F8641DBE998415C4921B70BB7F3E717B86869FE7319AB945B49AAFD35DE541FD7EA6076C92D000E8F596A56EE06DFDF420917D421FB51A763F07B19444E73F6F574728C5FD73A41FF185F46C81638860061C9E4F56D20075620B11F5A77C55C46D47D6EB648DB779095C6815CF2D34B63EF234121CEB635618D64851BDC030E7801EE499AE42C7081A0C66A8A79352FAD740F87855A4268592F183E7DCD76CFE0D19FEC662FF5FF0B71F17659BABC9E519B658CEEA2142E5498A47FA9847158FF5296A488929BE831A2C05D3D2B6787798F2588B49BA1F5C65EE7265F57ADE8FD3123C22CE56BD92E97574AB9068D026B8B0AF33537A669C4D12C3A3D2F58D990B6D2F9787F220307B08DF1049B916D5A168148D0750236E43B9FDA910237E0A1260B15BAF46ACFA369028BC3FCDEA889C217CAE803C96CEF3125A8240B3283E4FD89BF4E694471F4DAC7612EBEFA6720170B4D97B428AE0FBF00E591949DD65E4F3B1AEC784F21A87A2BCED49B2A36495EF6D118CCC699EC0BED45B1896CDC47B01E79FFBF3E0B97E806C20CB94AA9841F336E12F8D632210EB3B0196769EF1D6315FD63B4DA430CA7F14C1482213EB0B75931C8B4F48025E052C3511C1CB7EBD6BE16F2F6BA7B315C74F6EB92B0DD3980DED5F37DBF534BEFC7F6395C20C6828FC0A16BDBD3C24BD6DF3FE673BCE9DAC64CA0EDA5097578B38E7070DD35769E58A9913B8DE572F2C107BF022A01564E554B925A6BA5E24448D01FBA0D22BAF5262B40F1FA55298C289095D3DDB95742E6FF4D869606FB90E90B6F800DA217BD6BC79A94EF9D837B310BDCF58A6E05B1538252A0DA0EF476E92EB914ADCFA4D89B2169C2183AA55E290128D624515065289E71CDA40546EDA865EC2283AD744BD40839ADE26AFCD53C3AB06BF57346490985419422F8097575905AE9C425245EA4DAD44927A2D78142D391F3D194D7FE73DA6A40CC3F1DB8E25A6B9432B19329843A75F0CDC5BC1B4FBC8B02D714939BFE8EE64950615B9FBED4B8DD7F1877260D06A515574C2C7B4C2993CA0F636F2F67BAF96C85B5169812CDD7BA17088D52F2F8F0BA27CFD53672EDE2A0D955BF1D85F006DA72638926C7FA2D21FED54FF72528D8C77B02EA0DF9D12F9CB702BF154A856F84EA7273500AB12C1EBBB14FF6FF080A80BFCBD0E8E709FD6488314B5ECA165F7E9DE631056676C40433867A23BFB854B1F8FAFB6F451C6E72022393770330220DD7860AA87BD29E56F2417743D42DAE6F364712B47627AC9E2B7BAB16FF21104FEB2FEE9F9D1F331727A90D9D82490D4D48E8227B06CE36B14836ACB2365C33B0558F2EF90F9A100DF9F5B5D0E75B172A0DFAE3AF385DF143597DBCB99A1CCFDD77D862E7D81F10BD9B8836F73E1F0F21C87A20BB8BA0F9BC0EF46FD82594C69F0F7EB9CE62A0C7FA03DBA03226E88FCB409EA7AB03B0E261BA9179DDA31D8DFE4E5CEE32266297E99CE6857F96CD53254EA730D236CD4E8C2031FC5B0CE2E324D18F8B89D673F1BED679281887E78E798DCC73C55686B9752524A268CE7F2920C26F96CF870C10573017C33118943381947CB0A053D3651D099F5664AA02DABA4BD39E96BCD64C7D9DC2E8EAF1C21B84DC904CF66C3051ED5CA1162E837C9CAD5AF0702D553C6A5D2AC614352217FE2C0A22902632E040277BECD66E2934BD48C54DDE62C37335269B777E6113B5D6A608BDBDA97A66762AAD965DE3A3A98179580D7034F9FDC6B10710911FBEE8C87ACF253963DAE1D577C4B1FFC17F922BB7F419FD6AC7024CD0B4AEE309A436D42B304AA5D5F4441AC9386B3615EC17DF8DAC8FDD11EC3F8940F6F6E726DC5A99A027402C17B32F74EB4B7054009F035C91EC09C47065F0DC9077501E15C9FCECF85E9B69EB1E7E8636CEC1D26131BF4CCCF052D1DA781E9BFE1055D8684DB8720C39A887AA458E336BD205D24165CC1CFA2DBDC80BB029BE1AA56089883C01063C7E9B8DC24A12A10691D42B7F723C93449DBC8D0C83D0C09B00BECF01E756A1F0C85F0CD3689DEECF09B5C8CFD6B8C56497893938F42E41522FD9DFBA5CDF18D5E8B07F9AB55DEBB14A0E94F55AF9587C2D1D5B529A44BB0D05C299312E25BDA63A031EDED9057B37855D2090BB3F3CAAD9EE51322EC36C98B4D13F2B77E307DCE466E57F9073F4C767FB97FFB4B711C765DEDBEAF3EDFBAD9FB51E563844FB642760EEC188760E10DDC5ADF6E91E6B1B0C80069D6404CA2C58F5E827FAE524F08D0994D4C7AB052DABA393AC196D8AD7AC3839A7B15D2A4E39EDD13AFB242AEC7B9D402D13A684663BD4A390B6D631717516BDB146D5F5C8F81319CC28DF4D017ED00C14BCD6E9841F78361789AFF435A133FAC83A9BDFC9516CFFA41E1E13ED86D28D49BF43C9DCAA3D75DC637CF64DB0A817667DE57F14303B001C294E5F3157FE828257F2D1A4F1856C0A43C25902205F43359A1CB3547DBD8EE690973A91FE5927879291DC8191412BBF65BC5D68BED1BCDA05DC144D5239A896D32B74D3CC8ADF35EAFAC17EBA2C8C3545551348C3682D5631585F24B2E0BE57184357519935E08803B1B2E796586FCBBD60B6B86468418DA331B76BE2CA7BB385DF9C8D268B4EBBEE7DA46657B2DBD6E34AF537759E8A3861B60ECFAD5F1D8A2D936A427C30D845C061EC18C7374728F3AF3E41A5EB5D1A325FE55139DFB9F34D731ED4B9D344B6581C85E5C5F3993DBEE3237ABDBDD33DC40CC909B4001FAA98C2E60B8ADABF863661D6F2E4B9366F1B53EB69BFA897B654A0911BBC8A1ECE7512F846C5144DC6821B0FD81F464463C64856082C366A7E085BD684977011A9D109261E95719013945013CBED9BF008BFF6112FD5CEDF244EBC736C07E0D4074D9101709F67F5FFD5194522C5C244F17AAAAEFB9DD0148C5C90EBF31F748637608AE5A993DFD0DFC5789E11FA39CF1BDC144515444710C497BC0A55BD1301AB6DD511034F75FD9AB9F27D72F5F6E849901366C1450F4ED5A784F412B8E698815B198E688109A852BE3F34D9A98BCA809C90F5E66EC74DDF0A48C81504A5236D69BBED1F5A4282C46EE172025FEE503ADA837B47A45BCB64741347A567F6918132658B2A8C7197F59B7C249E0485C78F42E0DCB43B046D2F9785A0145975BB5805FD6EF81001BD801FA45B47D95ADEC2367F8B3F1FD9A99CFCCA4D3BC7868939D6EF228A9F776BE4A9EBE933BB4D757D93705730C2A103E1E90B3A1518B54C6E1213DEA733FCF9581C5BDAB6CEF4DB0768E46EACB63278D933D411F459F70590C15851FBA8A7821EF82A2C32037C6FAB315BC9A32951274AA279B4CA0B162E1B3214C7EEDB9D50BDD9F95E799CF9A0C40C225ABD857869F100FC33C3C6D2D4BDE41F2CF0AB17A5383487FD4811AC32A3E078E23C7F10084247D4AC422C888DBB39C3A6191D8428E023BEC897FC49F1F395A2B745AF50819EB86BBA720C08D68E9E39DE7E3EA0AABA252201544FB5A87BF7F0F24537EFC5D56DD2F81A7C37CD1D84B36A33506E8D5FDFDFECDA3D99C8B4AA8CD3CA99CB4D60CDECA2CDBB0612D3284F562B554F7916B047AE455EE45A08EC63376AE6F632BB0E04E80B2D6F3DEB61C60E74920C054 +MD = 765846C8AD3203328716F894011F23FC0C670070AE6509359011119810DE43A1 +Len = 30902 +Msg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en = 30965 +Msg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en = 31028 +Msg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en = 31091 +Msg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en = 31154 +Msg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en = 31217 +Msg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en = 31280 +Msg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en = 31343 +Msg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en = 31406 +Msg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en = 31469 +Msg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en = 31532 +Msg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en = 31595 +Msg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en = 31658 +Msg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en = 31721 +Msg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en = 31784 +Msg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en = 31847 +Msg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en = 31910 +Msg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en = 31973 +Msg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en = 32036 +Msg = CB405D4593C891573466877820FFB3C76919D4488AB8F2433B92511AE3C7E83F833A13C8852F5EDB363E92CFF75E9D85B7834F3ED4E40A9D38E06686DCEAA671D269796F7F88A7969FF10B10E0434916726D0CEA7CB7DBCB8D126E5271A8746437F69687F36211EF1A5B113CDDBE0EB613167F31A812E59EA75CECC6CA8BA0B1EF6DF67B366775C00771DB94BA2D24E90A394FBD3F5E7EA6E1F60E7076655265DB6067DDDF78DBF41FFF2018BA3D6DB23058C1A7693E7F94E7BC5C89CBC6111B7FA41A0F3702418F1AD0C32E27DE889537C851F3CB2A8F0E5B4579DC293BF2D2F7AE6B7492891BB126987E940696A44D8A819D4838F71D6DFE14DBDE746A35A13DF95804AD27FEAEDC08EE6590A651117D83C18E5D87A86935C1666EBBB71F9FAC0F0A43EDB3AFB9F4487F3A04B63A2F3783039444EF8C2BFE05C96C2FEDA0C8F0258347A90500B5296723917D9D66AFDB0ECA502A6C088AF7E97FBC10FF9B4FBC68C42C07664EFA48A3371C9F5D249130494BFE7127BAC45E4BA8930C90BBECC22EBCC149BD734D8DB8B045DC1AA1BC2188D7A2E3AC05F95445B0F2E1260FEC77F7EF3C423ABBBA256967FFE000DB3B2B6E55352B123B7C9B67450DEBD01C5015186486FFB73FF433611789145EA85F0E89DA2B6C996FCCD297479B75B55FE366F7B02116D7CD87FCEAB52D5E78DDEB3816010C03317EC0C086E34164462595BE41367B423502B25214A602C1FA5A8002383F619EF4FF478AE51DCE6978590A9B0F21122A6A9746B5B58EF4CC9178BEC3A15422C6E4743E5A03A735A6C273B79336F5CA85F3F2107C68EB5B69FBDE50E1406719447955536744CF76FEC8899353BF8736D15B6EEBFE6BECFA0B48623F23A4D0A809F6B540E59B2CFF86752FF6EB2028E5BF67864A021DBC4A326E32C74D4E3A66CA59F72D0425D6E3981900C986F8EB1AB66EF7E9D3EE7E2656D0D04ABF4802929C947F5D4E6F9CFF0BE1EF480BBCF8A85CA0AF25CE81286CE7C1AB6D99B6C2EA0CF7AEC5A0F4AB2B462EA9F1F6D53E9597D79EDCEF3F31CD22FC6A025CDBCA3A880750829BA9D34AEEB0BD48CBF22DAF42F6593ABD565A539348B95A32AE00D1E24B03D51CEA617B07105E2B549D0F635196C3F7AA97E2843C43B795B67EF870E7FA08E370B8F7C74FD137DDABF45FC9831B80AD2E9846383936BA19DDD093A7C87BE59BFFA894B0B2C0ACA53A9002FE3594C8367BA73C15AC3B4DBD6C39640B7B450FF8B03E33B7A0197A10E2CAF7F594A344EFF707E0BFD78AD37D678C1CCD0EF7EFA66D9460E078D4CDFFE25F127850FEBED147AC821382B0609169E18BFF0ADF08895DEECECCE8C0CC5227CD9D42EAE6BD38B0E6E7A093E5CAD3989100572F12EF3B9DFCA5BDCF6E46454B8309BAC3DEBED51162E236FD3A0E555BD8798AA26C24E53CC16FF17FE282A747EFAF26D52A09B573497A92DCDF9BEC54274769EE51842DAEE843CC6C1B20511DBD5ACED490B3260C3679EE94D486C53C4FECC4032875A36A1AB9438B2DD0FD4910E62B02A25020E3289AD9BE2077494DCBE2331D7EF2333720A96D57D621F95C729346239AD6BB8DE45F63B3BE4AE19CF716FBE3894140D7B4E4A1444DF2F35AD76C1FA90E1AD23FF0EFF7CCAB4E4FF4E106A6D7D7AAA5E15336F0361A46619D3DEA24DDD7871E4C9C5214CAC7066DD3A5D8D3F0AAA6767BADDCF5DA3B6F81DBC4A8562138278D7D1AFF72A4E69C012FE9B2D0D2482FDDB1D8823C4E1F93EDD6BA370627861C21B28D6A52217FB5BBC8949C9B2E9911338F6112C30402503739A8A3E06B61D212B7EE029102015BFC6A0CA13C29EE112CD28C19183B552AD6DF6FA51B5C192A4AA8BF591251B0B8FD92A75631443E5C429126F8DF976D56A0795C0E5F98F7981FD0902EAB627C81D252F39EE43C139A37158D0CFA9F7D819928024F2C1EF6039B7CF7A85C53C4BD526E5A9EC0F162D5E6C3ECC1A8C9393EBD36D5C2A2723A773596FD71C4A9913048E0138C9ACE294CF53A09E36A9B6369AD71161D7B22BBE48FC296E88F3B63132A24C6350E46B055ED685B161B0D911F7A373BABEE4FAB49DB487D05A2F7831B1201773A0D9D2C8C44A03FC0ACF8FFA65FAEF6D9BEB56B101B4D72D6ECFE5C58D82D0F99DBA4F3429FA9E3406BDA16A8E1084A0494D9ACC360CC89830E0645C60E706B2546FE7B81AEBE89F93688D6EA0F25E60A624B9AC2143E1B396FBF1BFB1E8E6B45CAA36D4EF979C1E1DCD492F207E45D70748B7FCF4856006825718CADE4414FA91243295B9082BFF9876F5B59CCE24B93299CF29C35E6C5E34AA17988895E33A9F6BA5648AF1F16BB636A6BC4B4B511C5918F587B3407114DAACBA8EB3C8BD7BCAB2972CC1FCB945E7D7BF6BFD0FFC87D872FDEDADC58DA7937FACE6F9E554C6D08B075E7C66DF9E8AA76F7FFBEF1A5C3CD481F880D38F16817D2BAE176BE0BC5569BFD6D505296FD355AF0B052E047D50CCF361484B96A8EB8F8DE867CE901719E974246A062A395C2E8D41C64E3F6DB9658FC81CFD1B341295F896D5BE146399861BCD4ED13C46C91F5EB6BB5597E3E02B61734828688A951B7339DFD3F23E23D261DA70F2CD888F945776B892AF07798E26440AD88666B6120317985C1EB71DAA931E6E091539F87CFCF054531D81996C5E46BA97B80B932003AA40BAFEF95F7DD0EF243E4253BA15C8503F554B72E2AB0CB31A17C0766D54F70091D42B0BFD126F9B50B76F16347A077451121ADDF2DE9DF6CD6827A2D1EBBF66ACC527C6B103CD66C0420F5BC1599D7980C454A0C81CF096100008D89D5736B14522C0BA7F6D0359279571A13DBF89748CCC670C9293F8EF5461CAF0D25597049915109B478EDB9731D1D8214EE1825726C6DAD324A4C2A1881349EC45FBA9CC4195F079A1CB1BDC5B6354B68D009132D91243C480221869B38042515534CDDE7F6CB99327BBE431ADFF6DF3685A3F737ECA71ABAE5FD92E6CE3090CC8A89AD2B71B38DDB008B37CB094EA39C21DEC4AB5566AB846CC0A562C2AEDD5FC02B9C4872501AE80206D5C237727ECF1AC6CF2E655C08A78CC1164F25128558CE20F91105BA99E1FB83EC722D83DCF71A8F859D470A0292A5B6C3AE12CC74392D5A3F103F7929DF7FA39D7442AB411744BAF8717B928E4E90AAB1E9A0C7123CB11660455EF5CE386CE8FE7A6CC96C6E91D44C951ED7C5B7846A235ED47CF26D14EF2A340B378C738ED473D2A7A8FD322DFEFAAFFB538B5D7416DB0CEC2C48552AA2663387E6D75878DD5818848778BF3B64F8EE737A995D1ADEC1AF9EE87FBF2A9E689EC4F36D52C109106613DA5D5607BD2C36AE0EF4A1BF5BE3905C40D823B18343707328F70F377EC1C2ADEA2738A532BD5B7A816D5B0542602BD4AF293A8B72AFABCBFD4FBB8DD134990E0D48746C03B9D7E3F112D4F41EBDF10F44D8FBA2CB6FFF1AE7FA3CCCB34C998C2A9AB302B90173143EAB804C98E1D7602A85EA483399C5479F41834A4ABE16E204553086E444C2D31DDC5672879B175228B0C62A9C3C904B01FB391ECAA932F039ECA02BF68524542EA404A486070422E14740645E1350A1303197C0EE8E8964E60C9036CAF890FB5A07473B08E29E2CE48A90FF2896FFF2CA40A5E53FE5A900C7AA3CC1E6A8D3D4D1CE5548F46CB6E8E3FB18AC3267A0A18EBCB0561B03E7B17963F2F173C3DDE7A1DF6C2E958872C61167BCEEE96C2EB010F66810A6210E359663AB3B76941BD6335FC804BEAE9F629AC95D83A032AB66D301888955C70341C82780A81F467B77E12402121598A573B3C21F2D0C139315D653D0882A1A677BBF7E87CCD8793C4A55DA330C71CFBEC4E8C32EFCF2E2401BF2231B40015AB448CFB5D96210F8406A9EC71F91F9A20FADC698E92D05219C5E3DE44A390F1652738BBC8CFA12996CA5E27ED6FC78D27746F99028A73167D763F886188B0C5E2D245F9EB25300B4E125549D79EB194D511915D2B7AEFED61498DF886462E0B0ED30D4AB74CAB6B8CB375502C8A8A85075669E7888028AFD3FF1711FE088F43BCD849D05771CABF1E2319B1E2B9517CB957B962898665CE94F887F7E35076471C1F77DE1348ECA32A3AB6D1400A61BE9F3EDC8CC22621E48432AD00C85630F8E5DDA51F1AA585647822593094E032C1D9C88B6B760B8B835C33A7B6372A4C23266E4C7E514A660095FA71CA33ACFFA004067ECD6C6E5854694D541B05361327EAE97E936580F5D6CA6120B46CA745031ED0D001DA0615A60346744812BD69B340B952293E56BC45EA3CB1A73E4FBCA16D9359DAA23B37CC41993DC4E05BD365C75CDA846D3F9051F8B1CB8152B0E58E8020AC74354952024693F697E1B5FFD2B6C2CC947BDDBC7258D0014A101CB90802B49B82704CABD885EB61A20AE05889D39F90FF7E49732748AA0949BDB62704D06F8F91F0AD6DC70114EB13FFFBC9C22C2CCD24F1562104B90B702B2DF965E9D8C3DC15AF57B822AA36D1F6ACB3ABA9A1840278193DD0D7F8D63CCA7C6A45277FA31D50712B74990F18D7F70F69C5A22343C2FD0F728A944CECBDDE1C90CA392AD7CC66B1609FE81BDC02E432597C1BE9B7698C86955E65A16A88FBB4F3E830498FFB33065104A9066947F35866DFFA8E4619C88419F3E033D717370571290BBC0ADABD55D871DD665BFF1096E9FDFA6223BF43A5D7E8BF8740404B80D123D92020161E9CE97E589FE38D15E4431B9BB7F79AFCED1CDD831AB7468F30841BAE720563FDD966025CC71C46DFE2BBF0F983B8B9C8E73C22194D897CF5AA8B5025B5C2D1F42341CD30B36E74A34D37B9FFAB536BD6C90C1FED6B40B2183CB1B80619813662F12B4894098B60882CB99A6018B47E526AB1AF454536A1DD006B3F931FBD6DBE0EC683F5811591FA6F1EF6CE5E8219A25DAF5EDE409E4151C4141EB3221CC54CE650CEE0A5F7781A50A789C3D5A503FF236026C92716ACFA7F3468CE2A8634D0D9A1360A007FBFECB2805A31DB9563983C5AC89AAE38D885A76EF975971D1BE6577DD5D9FF9C87669B5B0CA4CF6BFA0D30DA75E473E71980CDE91DF40E8B1EB2AB790E443A2B350B194E18487FC91EA2328B449A4DC2EFBCC08A4645908EDFA67E068A890CB932DB954B8CFB4DD97486416686AD8AAAD70720458258A1F8C3B07D9F9AB4AC0D7729E5CBAB79700D6C9A57900FB63FC961FA21571FE664699B0BB7F444305848DCFC9AFD37CCA37A9216506EA0A82A8644F9165102F70C6865773A6144C6ECAF5C4FA001567458ADE381D9D66BF6FEFBAD2CB1E221B77D9CCC7324AF55008EDEB7B824897438280D9C6C905EB6CCBBE811FD4520EBE541DE74CE33FD19F696E985D3D3B17D7D26AF95CEC1381BFA82C6E079616C3997CCCCF3542DBEC96B1E5663F234B3D20352B27F0773F5F54908CE383008D35732061E288C19C112968A50B7E85C4E96A904D9A46B44E228C4D14F6A89136F44856B07B67A824C1F93F3A1DD4DAF91C1657BB9FF5C6358C6E09ABF18D731268065098E6251EB9285163C664C12DD153744261F9B7FAB19631CE02A2D204075BFA55D5124B98E028AFC011AD74A3916EC2899EF0CB5BE850D6B7D597E42628BEB68A5502D6AA600F2167BBF92B44B842AB4E1DFF1BDFAD8124F5ABF25AB09E0B00 +MD = 3E49345EDA39DC944EE80FD9DA9FBC8E584A35B59EF788A483C407FD3FA74EAB +Len = 32099 +Msg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en = 32162 +Msg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en = 32225 +Msg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en = 32288 +Msg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en = 32351 +Msg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en = 32414 +Msg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en = 32477 +Msg = 44ADA524C191E37BEE5551831BA281796944EB0B8CA6B5E8F1073584EBCF702526EE1A4F93F9174E3AA790E69FB1B2DF36CB17CA29751AFB26D6092B7B9C83488C9FE4257C557BC14BDF774CE2AC4A2A5C03D7E15DDA57AADA6F014624E71E805AFDE5B27AB1546C35BF28D1AFC48A9C1A1C690D0A1EF0A15CF6F88E6F3DB0741946DDBB15084A2F935A5399CEC60768F25A8F4A6AEF9007D9E15A7686D8DFF8C931BEEDDEE4F4176C36FCCA05EBA7068449CAECA2818595E044F36CDFF74458606AB97578A7672D16A51C4E4CC1ED3826070CD8769908DD5190AD0A089AFCACDD0DE0E92B15D383D3C44F72962CB51CF3107011E263F6FCAC4D803B8B7EE857690736D6F4ED4171601DF1A07B78F70BC7C2760143C99D1BC2B0C394AE8F761E31D4FCD15F960C94F90B8814FB00AFB75BC8AAF000467E58FCDB2F6749EB0D99211478169A10F012D6F9D83855DEC15612BFA478E8FDE4AAD9BD3D3E9E2CA6A9D7754F5CCC746C6C7007D3529D77045F1ED1D056669FC0BFB20325E56A6ECC5656FFEA1A75C0422C5122CF8030A5D8D8118DF2779492037C290FAE33F43D3D143266DAB1EEEEC4401CB208D652FE78495631C763B6ED95C0C15276ACF3D3608D2C0755383D9AEFAE2BC6C095B55F4A38B53FD9F57ABE79DDF3BCB4C8C472576201216A7A3B9FB442AD1B86E79B047ED4620E62824B637EF610BC090E36440768B03B3ADD719CF70B3D8F3A010AEF2A51FF0DEF899C5F823D7AD5A26F1C40C1817CAD12D395BE6CD4C39ADDBCB0495BDFAD302A537B9DEA0AD10BF11AB144E4C0674838491F0661F8DD026A3A79D48D6845527439C362C6E7D7B9551A82EC4569CCD9864753A52128D56A8E9856F17EA4F6FE08274B567668EB15D7C4593B108E3158509A29967894D5FBBD9E4BBF6DCD8154B56DBD271A2978405DE60012A1F1D7F35EB3CD319E183694DAD739F5B7476F246B4081398D8FA3E2BAE7D2BE2C49C4C4996156A2BFCF6883061D5E46178A449E5D230E570A66F74F6F77AA054A57B93C9751CBA8431C051BF83EEFABAC3D57C4FF21496AE9E5BB2824DE8E8E37EDAB269BF2705725D6B4F72E6CE7E4E830B94859F4601B9717965ECF7ED0E697AD02C3C260E0F0CE2E44768548208E0D976B844A38D7E7133474E6ACFB1F83A6E787718D69126585077805B4997EC1E3624BEB02CAE23EC241F3A2E6DC175616A80AAD03E5F5A2C8A591DD6F82C10C1180E3323B24AC017D0A347F2C315A682ABC626DD0B7AD75E74EC9758FA6C3E0137F810E221EAECE6CE1BE611DA5098302F6DBE37D7E9BE6EB4795EC3277EE38423FE027E84EBAC869E5C18921D0087D72F6B5201BA5B4AB22D8A74DDAE445322A429A241851DE208E80B5493DCFDD3024E32F34F8FAB12EC0FDD332DE68B333D432CCC3EFC4D1E405C24332F3F6A6CD2E5B98D1AC2F6CB7269D94F25A0564C352419D8259D85C29A50F19732C8A3A27357DDC8542157DEB13DCEAB8F9672E19D54616B5E390B13826A474C5E8281E3701C99626A2DA3037449FB20DFEA2C6D8C6F786F072C6B28B0C78DF205796378718598DB28635CBC014FBD8D27C176EDADD308834DCF8835AA6C41156613DD79DD15F5ED2CE7922ED30D6986BCAF5EFE86A5494919E1DD04CABA5323BFCCED1F11F894294C9F4C1F8A9C813266C03F2D8F7AF82059EF2FCE6135CB27FE496E2FE288DAE15E3297C92CFBAE23F896686C587C58898D9C2D6FEBF8B3BE2C873CCC2E5827EE0FB99DDF9047740A2FCB298E6E14025EF89F3509A1A453D33A29F02111B5B36261E4758EBC5864840F869048F6B6475A52000AA1F3CB034A4B677AABBF50850D88D811BD9ED0B50109F86284B0925D63FFA3192CEB96786AEC9611C182F5FF8FE0463E07A4B7531B597F2C933A168972830FDE0FAF5BBBDDD20DEE15B0388D97A378D231F4DD2E7FB6D32A75DE20E545DD588F18BC4275789097FF205F2C9FE32154499E6B8E410903976E81C16080916E9320210BF096559439913F11C3EEF6F330C533CAE1A08613C6008997BFED80E69C5AD6EB894A41A7C3AEBE17297827C9224552239B84EA139696A2EDC2FAD0A006C314B753E14BDC3DD03BEBE0F92C09E6C353B3DC709389386332B4DB493811F296B06B60E8478395833B8A66E0D7B21122E5B8027CE101403DED808AA80D9FC89D77ACAB9DF9DFEF4777E38F9CF60F5044E73677F7E5D2E3176C9FDC4E16D4689A2AB770D198FCCCAF01866B1DECF0188D6757EE292FEC021A16FED7E21BD34C141AB1688A5B24EB11DCE3F9F7E75040E51DD7603BA1166424A77D48D14783FDB077EF6A93C328142C270594CC314352A18B99DCD7C1CBFB8BEEDDB122DA9FCBF84EF730F9CF30F9DDD71FCD813A228E0DE10D2F87CD9F72121C0CCE80C12C1D8BF57850AC3F1C43E0F4DD635C2F05A23D7C7C8281301FCBC936CE1CD5B85D21A9173FF628C47FEB72A49FBE5B2759E4ACEB205283EBE14A1E14691EB3F9B977FAAB9D0DC82033ADF168F6234CCCE930BB619DA5699D71B5815A9CE247E63D3A7C18C497F7CA8822A0BC9B7F33884C27043E4EB402E844F45ACCD0128B471CF2880E3EF566C91A44AFF19625F518F60087DE6C37F29D7BCEADEBDB76DE6CD1AD7B0A73715FB91F05B1249CC021070E286E9E36EB8C4B6A5C09314DB826E16B9977C3C1E2C0967F50E0168643F9A448446F9E4B4729292E79E5F74674BD351FAA0A64599231E3AC35FF1B183CB096DCC33AC579574254716AA5F82E02FC0AA72FBF30755708CBFBBACAFAA8D45AB2971D9603F087591D0240CFABA604DA77DD246F6F7171B7BB32285CEAAC1DED692AAAB2F24C081751B6AFFDF8D1FFA4E82BB587E11A2E70D52E4915A5F8702615FF090D57339955081897167A5F622C5339D8BE10EFAD6DF7D38943EE4965FB3582EEC7133CF0AEB0EBC2295802A17EEA807789B7173A507D3C1637E9186C548FF2546E186B60317A0435E72E8923D2D33307609261D63AFBBE28EA191EDB893AA4BB10484A45696487CD58AB774D94DB72243BEC14D8D4F88182EBCFBD4328D8630BC5841F1FD7A75F44637E3FB1A33D357A47C1F302867B66308C1DBC56C6777054B992DA4CDA8D5C0641D026432456344EE5DB3C7DED09708C38AD85B76070AB27DB6388914E608A7F14B0D0F3323847DB01B303442E8D6671E2E3E7EFB5E5418457130DD15C4D3725143DFBCD79D02F72932968CCA9213C19CF25E04473947B3621A9B4C46F6FC7DA0A6894D344899C9308CAB0332208E6282C9E6B1D2EB9D7FDAE977A3A1371EBB917C704C77F993194F1735117DCACD77B344AC1BDDBB00531F2D1AE78C971D4904A77BDDA6D306AE804AAA9D19687D8500A21FB29F558711D7B20ABB0AD0A34A05D706AE30D04CF0EB994638A54D4DADFA82CDA4E91C28DBB9A0860EDBCE913CF1FA7E11FC6034365FFCC113D802FA287E990F80327F3DC3857429980F2D429C8687DDAFAEDA549A6B884B0BFE0E6782398AD899B9E3A30A7449010B38C3C8792DBE085BED7F4804748F0904EF0F4DBA278B9DF3F162FE5188D531638B19C674437CA15157E994CFEB7A52B705362C7A72E005CADD34F8A4D71723BFBE47CAE7D95798A6256C79CB8C15D24F22D66FC3A731B28654804E87CC2E982425E8642DD5F9786AC13519E2E2D0B02644894ED788D1BD1E920DAD196BA22BBEB985CF3A6CA4A8E7BA347D70BA7ECB0CE1FE88CE2BAD6DB95E8615C03663C8E7A5C675368CBEDB718F9AF64572AABE0459B55E1FFC5F98309598B1BADE9DE58F09E135F40E8C335F9F750D17C0DECE028BDCC73450A74A7CA01009C0ABC1955CB84ED825D2EDA35CE4F02D53CEAC41BBFB58594F0EBE39AC9199788429C6C5E1EEDA8036163B388BBC4124AB5DE62CBA75099D537DD7528C03B2865B42691B969AE3D82AADD1E4643861B300B0E8C1BCBB398370417A8312B9B85C04EA22546E9B3003E59D3ED25F252AF24E100C3E5D03790D02A56284DB083BD4742395FE02A561B93B2BDA52BED3706C7F6A62610FC09E743FE2884CBA0E7AAAE442CEEC64C488E961767E1218DE6846C2487BBA0992CA5F5901ED5F76011737F7F38FD560B6D2D09CFB4E88BFAD13273D7137F7250D086AB96CA228D8D48E2D860A713B46A128C3C46EB791C1B4753B9E9F9C6202AE1673C5EFE78B206BB596B015F5C70360416E5DAD7BC3808D206A72E69A84DD0A71DAAF88915EE8206A6D29376C766DA3A4C0E0FDAF42C47DD486AD268998599872D8B818F294F607092C044FCC1BB5486DC1891FB8A3DEA79F9F2C1974675087C18DF2E4C2E039F6D4112B3D0D9E99D9E4A8E1B2FF0B2841962B5F850BBD1007608DBFB90B342D4B4D27EA7259D8BC55347DF22A6788447DCEF1307352DE0FB2A2C0D7CC9DCAC295DDBE1C837C72EFCBFA185ED8C650A11C8F10D9E8B1B3DBC321672301483ED11C043D4A4B77A3045A5E98CE41FFD265B6C8C853EDF7AE2401E43CA47CB357D7BAEB78EB2EBBFB32D74F24D115DB71AE22B9C36ECFC513BFCB24AF3869C282640ADEF8E6D4AE4E3096734449A0460E02F3DAA75AB258960C5C617BA1797F55DDD529398EB3904F0ACC61E2E0E8145A56CCEC3C3CB3663F18884EF3AF738716B92F33C14E1F4F5AAAED915A4A87B013A833F39ED860C987542CAE758D44DA6501DFBAA56F6AA3C778F58DEA13F3C5D97952B81A11C6F68719F8849529DEE384EBBFCE29690AA0F64D837BB3AA18D1633065E3CFEED86AB6F589F9479F9497C3ADD6E4FFDA76931452646ABD83669BEF590B95A696959ED1D380092FCDA4E00B52F5310845A0ED52593F3D6FF43A9EABFB32CE2F44DF8E81094A01874DA4E33E3F0DE5EF7623D87AEAFA016D545AC46D65C6BF25678A1D0602200E08D7CA39A9F8D73F137B074062028F8919E7F920E9C8A1266F6DA3EE32BC4D2C1CFF5EB459BD19D995D34F3D66F1A129F53FCBCD5E51B618F9BC88B9C23AA751593056ACB26FD31A390A4998C7D35C0804AAB615E573ED1AF72FADCD4FE578CF4E570DCF90DA66A7E1A9A918B83F0A01E7FF5EB96567BED70424F8C735669627572717662EB61BAFB65F136D57F05C6238745B9A13211955A6037D6A80513678530280C6617510C644FAF81010CCEC14EA48652C8E052B1943DE698DE6FD050AC97AF5C564CB358E0FD63DE34E847471BBF51513C0B113E1CFCB6CDDA28FC22F5AD447820EDA4A7838294846094D590D6D8B38D7E3345841084E86176930CAD47FAACAE1A94DDF9F6613193C4AA786EE82C55EC3FEB9681F52D4CB283ACCFF8991D541CFCB4B02FC75BA6407CEEA68CB224096C7B3E4D3B7DA1D06E2E0A59B51090D1CB29AFA0CC15A06A2879D817C39E4529430BF835130D9FD067EECAA1CF7A104E07D7C5A2C90DD5161CBB1959EE6FD43A6EBDD6712A12D808E9B0F8771B48C1B37BB1A6C50804F8E55BD10876566F2527DFB580FF7C3BB8C5A82D542957E492C95FD1688A9A6638AFED54825956C800AF677A77D9B89576975CC850AA59630EE3400328A065F91685C1A851A911793B382B500512A21E16290DF3B06831A736D293BDB4B2A15C21BD20850F83EE6465CCA7CBC10CD5D9649EDC2CF92E435BF6E8AF33867BD837925BBCEE1CCC6D2FD808376DBBBE1EB81A11385AFC4009356732A77664D8682E1225231244E78EA27B871C1F4703B3E0A8E0E341901DB3AE88EE0 +MD = 713E93B51C39A1C8BA2B47FDDF35BEA7D6586B49521EF7B517C4F8D2113D9312 +Len = 32540 +Msg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en = 32603 +Msg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en = 32666 +Msg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en = 32729 +Msg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en = 32792 +Msg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en = 32855 +Msg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en = 32918 +Msg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en = 32981 +Msg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en = 33044 +Msg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en = 33107 +Msg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en = 33170 +Msg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en = 33233 +Msg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en = 33296 +Msg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en = 33359 +Msg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en = 33422 +Msg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en = 33485 +Msg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en = 33548 +Msg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en = 33611 +Msg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en = 33674 +Msg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en = 33737 +Msg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en = 33800 +Msg = 6964E2D650B19AA6D31B839C604A90AA3D105834F3854DF4A41D4787A387042CC413DE27503A1EFC366B87ED677EA63DCCD40D9C7F699FFF9B8A42B596173014B9E811D42D2DE574ED5C80FC6A5A86B772A3EEBE5640102527401C0E9BEF57E05BBF06986535D3163788C60C92EC7460B7FC685FB45FB8A18FA84EF5A37C94A2EC3A948DCAFC69B83E2434ABCFDAFCE948D8C76ED9BA780D39AC3DD098EBB3208538A666CED8ACF1B3031C5EF23592FC432AC25BE0552C1A6463E3CC778D456A520432A8C55436573219C49E6BC27474AA4BD9B1B3BC64917D016B6580AEF2A0BA41ACFB98EA869D3995012715D06D64E0AAEFB2627125F225E2EFEA21AF7EC49304B8E6399623FAC15D6CDF39C4177A12254E5D807B4AAECED6D591F4D0BF50C07F5B69E7D60055062654E7B1C8B96AF726BCB34B10C60B7FC3B10DBC69107C7D81043BCAA681EB354CF19AF26AE3C7CB321B892C33CD044A24A5249F2F2EA3F804944B5049CA887EAA6D4CD5E52D17CF01CB0FCECDA47425EC85F8362AE045ED0D109758C90134EA27C4CBF6E3ABE7F283F4C3FFC4455EAE4790329AE47658DB2850B09A79A89BDBF72A20DC887B6AD7ADECBD5A86C08479D446EF817E13A37819C227792E3E0FF80A2831B20760B879A489A4AE50AFF9FB1DFF39132DD84300EF7ABE05E98C5929683A2DDFEA99468996D652DCCC698183F9A3103F7C049A7227733D0C14ED1BB809B4EF750DF19094885961D327394D6CFA0A21B341681738B7E6FEEFCBF4DD474B7B45EA64A3A60B97BFF297E8A52CD4AA6E92D6DBB7FEF7F736D29CE3B041488A6DB68D28F3C0204CFFF82CE6EAD11E11D7B060A0FF550711BE33288ACC63B6DCF2062251771544AD41B35B1EA5F11C4B196C48F5FBFCB4B39C60044A70E1DBB2CFBF9D8FCC855DEC9A0B33F2021CC76B236ADEB5A1356CFB8590FC1DDF8A721D9331861DB604AD0C8C89871E960019A0DABA43202ADDD526C1706E782FAC5F98295F4C6036B8E2DF6D225B6335D1314143573AB8E66A7750BDB6420452FA060B24FBBC3618D951490534718D97E3AE994D5E770D103E1F405A5357A2521E9393ED2ED197E7AAC87E142205C69DBEE846034FE6F2168DC207D13022E11427E8F02087D2F4E850E7FD21237D56BE970781CD779F7B0D8E9F689E6CADA3386B5E779E382AE3DEB6CB20DBA16A94D147101FE594790A5B331D40551C8C1D81052CE00642F56E4048F6831D713E74E3F4C6ED2352854854E35C06313F0104FA47EEB282AFF9A3ED3D683FC88E9684AA0C460C3EC333080D5F557520A359803563A1D8BA7C716082CBEA808DFF6296947CEF7EA30CBAD458C0B90A07847E3E557CFC33B0E3893D32924934DA966F6D451FF8C6B28ECAD7480CC137327E5DB10D180D41E8088660297DFA99126F7E2AB290F206C02644B4F28A603E959077E13D65C650CC0513259C36324CB5223E829350EB0A567317FA176213EBEFD40B98C38055B24AD85171FF0724410926B38D8A06DE500775D39E472B0B3212122204136D0793ED28F6EA070ED50745745DF57079F7D4C63C6B5A862A031DA93F4E576873E6ED03EAABC2A59D4FDE5A670850A52B17DFB059AD5A0822FF68B9A3A11A26BDE519E86A2C7F743BC932BB29208383621D509DA438A56B56E1AAADC330A0CEADE51EA65ECA256E3DEE4495C3FB94F41C121B03B6996981033D5D9E5540719E29EB1AD9A10C2182811629BB5A7D2296842FCA6018E44B1B2B0EE56DB63EDACFFA837A0147D1FBEA737FD66B614FA097819422DAEB9E1F04B81D4B1E569AA84708AFAC7A9DD92F95D9CAC1137404F950C70D0E337C956BFD2C7B64A3B99F1499F9B297391B0996B42289E205B47900168F8BC3A30C84CDF00AF52EF14D8B4A87675F8859E9C3980524C2081D3A08DE576C1FD5B40459E299BA89FBD05C8ED01E3BEDD893F7EC17DD1BE1EEE0B19186E739DDE650566C395EB143451C09EB51C6E14EEF3FC3E20210CE62C49D0BB862CEC28872C0CD989050B56EEEB062AE2645C1510635E4085F5940EEC6274CA982E312AB21BA0930BE4D6B57AD8D36BBF58DC05D353E32A5CFCC4EB008610E24A8F2A1FCB57BF6E4ADCF80D3408997D6872A2EA5E94E74CC184ECCBBA15882745E03146045DBF6E94127581CEE20F2F408841D1982132E5B7F582B91784740761EFDC9346BD9EBB3C1FD341C3056F4DBB4B36EA9E4BF05C965B367346472D0EB55B840ED49EF245C6F86EC5394063305BA0DF45DB30F7658D28AA988CC9AD97F0A9C0B3E59FB623D55C61F2E202521714970C2285BDBF7C6119FA3097D82F6A1EBC33D42C85A93630AE18521A2F8AA785A17C2D9354033FE297B172EA1F06CCA686DE4E1A28836DA559E4405856411D58533CE33C6B573EC51F0F565499F6FCA8837FC80BC4925867EEB6BDCAB15EF1C70B17E02A535E2F423D36591A22CF527D118D5C540A6749E1C206058C0452BD9C8F5885EB5823BA8515C105F8D96FD5F4AF9337E66D35069D19EC041A7D979452E5743A6A22DA0DF662FD9D1A2AC3F8D431A61F4FB944089C52233167E0D53899B6D45C51393F3EF6894921486D2F9F4D5E6E95107FB975C8E856AFC76B06BF3648668EAFF6AA59FC9A3AA536E548880D4D79C9EB5CFEBA4D6D5D402197C0E1608500D69833C069BD1C45D766A7BC783C0194A2C813B223F141D8AE2868FD65D68DD67EF463E34E4FC20C7777BE17A3FCFA51A9D98FB23B341B12CDD2B430B0602CAB03A226C7CEE4F9488C8319DDBF4EFF1B614BA9C1FE0098E9CE1B57EA4D8D777EE89F4C2E3C729216B6B2EE2685DB9C1945B27986C748DCA51BB361824824FB2A31EF9D7244B734779B86354BC0DBA438D378193A84785B6B864306EB6E6A0A80FA2AF04985FC540477B911D7EA859D8F956DD1DF3E464D884A6355E8B24CA3F05F25EE53B23EBE43CE6C32774FB74BACE33A12E7C1798B7116BEE1245CBE323882464C49B647D61350ADEB84CAE9C61B02BD702E6D8DE849FAD57A57AD297150312198D89EF1366E45286F4BCC8217DB2EDD39B144D6BA1D6CB0D1C74BE396CB535E6FF9900AC371A6F9E8DAA45DD1B1842FC685D1FDEE0FC127A165B03B561002CA56F19143024C41520489BEFA82AF92FCE5BB220DCEC1AA047B299F7FAC2BCB489C99044AEFAF2920C324597DAACAB92F6347BC0EF95CA619DC19A7F28A1CBBACEFC85EA2BD7A769E6BE424F4AF08AF7F24F5475EE2434ACEECEC18BFBCFD3479226363B2BFA915DA76B839857A33641B4B9F64F15702ADB3964E5DB19FAF48489A7F6F9F56A2A258C54E0E5F97F382FA99274B2607D3D6A6B94CA075EB454080B01435C5ABA8B45AD6EDFD00DDC0270C7E54919A43DC715CB7B37E8423C7D2285D222AEC66E4DC4B55BC6EED3CED1B8D5B364F5FED35BA0312E46418192937792E865EBF5D5315F1E395194004B77F1D15E48203E3E5BD2C508E3CD8D1E2075B3D6DB0A5B28C10F155B13954297DB518A3E47DB5DA1C0ED8536FA7B5945E952BB5C4E24C40FCA0C344302A5202B92A351738225505209D810789F7A590672ECAAD866ACE771A3F9091A1695DA17B3576213A0DB5C4641E78045822AFD939B6272D12E05CDD1040681AAEE55523BE6371C53FCED13638A9448C0E9AF8AEF55ACAF723D513DAB5138F62E28FEB489E75BE072418051CDFDABC7CEB0C99F181C6AD95E7EFF5226BE5C4F4EDEE7A8C4A0500241EDBC363CB4C3AC12DD046EF0C840933740F48C63DE39C082FF4374C2D8453F2B813F397B822E90FD59B448262C00FDCAE73BCF90CAE164BAE33041CB809E7CAFCFDD658065B84B7C370CE3E08D505F7A2BA783A666EF74D8743336FA4DF4E20A1F8D58CD0B0EFF66FA77803F42169F51109A4CCFD008F36E23EDBAAA6ABF53B822C9EF356B79027CF28DF9E5D5D7CA360AEB407CF02CA2689F8131C78CE6DE7C5D8A2DC65A91DF7ACA7787ECD5145C5C791B7428F3F9CBB22F584EB564AF89263F5750CB37C8151F205B2FCA7DF746226D5AFE10177C8BC456452EA65D449E19B4253D6625D5C3349F3EC3BE554D4158DF219DE226AF379A422A8DAC91B97C64E19C120141D806767F7EE931D88E293EE8AE1EFD2766EE83174DE19BB645EE3455133B81E2270AC1C7CCEB037A50A5CCD540F00ABE27F05BBC29A2F10542CA0AE130D2B2A1464DB03C0B2510A9E7FB98AB24FD391CBAE0A112A66EAC05304127D1545BE6638B6D35606877719C3CD782FAE3FAAD1B89EB603750C7B5C3CE84F93FAC147346350C750CF2CA7EF9099D6725BD31172C37FAE60E07F33572CB843E67E8662D0DD55E424AFA9B1D57CBF9DDCDE447A3B8B604EFA253EBB2CEBE01521F0353C521F457F451CD93346D815D6BCBA87B3D2F96A22ED17C17B90BE3DDF7E04838C4F780BE2C96B781558B4A4999B3ADBAACA1229F22FF637CFC068CE8802F8684AAC32AE32BD09CD5C1D770900CC7C5FE8DF41E8110FAAD782C15C3CD637BA619A0037D7378C72CB0C95A35A9109BE11F8C4BF0D3BB80949A15C64A0D6F52A9B52A521D06DC749CD0E553418E127FB519BDA401F59E5AE517CBC2F538B6C32F9CE5C34088CFFFE03FDC7D36A7A912EDE8254B7EA46F1262973BE564089C44825437D8DBA98BE04CF7F6AB5D03C5C10AB51557F331D0B1B919B9643EFAD709080D2FF46BE83E081551F64ECD826DB09469179FF4B068CCA172D1E16750BD6D4C805146DC0221A555C81931A60206AF7CB485D2FB7FA9D7AACBC3E3729EB09979D2E683EA3ED8AD3B4BAAF4FE25F8B227568795563D3F2902A97375C521BA20F9C5E860DFAC83A0F0ED347588F250A44F01C93611405AEB04C6E75153F0A6E064E19D895DF7596C6A48A0BB3804A78937A45BCD05486314BAF72661349E8EB516FCFBAFFB31639716C5B88CAF4255E20EE90A6EF402E7A39C5CCDC5B196A99C5455639E9ECB788F94ABD7A711833B92DB9FD56B6412BF84C6BEE9505682EA300CEEDA496EF06CC477C272318F9883212794E9AD88177B65CECC1BA8474D3DE7656B61A3B832240578A4FF704CAA65E01A29F365C1ABB1DF23D61AD41C08B092CE870BA1103857DA37D8F5647A5D5ADA7BB1D9804C547C187BD1767258292514491CEC97BA41F48C6B581FE8E74520D0F0F6B0E44C9920290F68684D169253087540EBE733AE2465254BA04BEB703F3A309BE14B4F22EA63AA2DE8E674D2AD446F356D1CFE1207A5ED7C2D565CCD5CC1EF0EB1E7919C26E92B851F7478C83DE6CD21A3547CD4464A6B6B4DA6A8D8F736D16D818063D1FB95A8D6A46911FC564AA5CFB1CF76EF09D0C104648F92DB9B28816F560A24935923A945A1FB52AD9FAC6EA2E640A64F79F25693398B0A0E567518D950714A8AAF343A68A4EB1EE1F518ACBE99E05041CA505AD509F6EBCC68C84D85DC17E60F0240EC848A842F4A1ABF11371F46CE69D5B535FAB5634523E359AE14DD07749FBC6390EEB9E5330FC07926C971C719CD02AA565048CDA7E534365A3F39555F25BEC847C0FE5A76EF68F038FF552DA2722581CC14ECEDA1297942A1A67D0501815747C61517A9AC876DB662641F750A917EDFD8EA199D27E5D56855E5200791CD404D15B6EF6F5771234B0902C9DB5B033F260359F1A52E6646DBDE9E4F9876A7BF2C5FD7BA028BAA306FF9D4287DF88AA055C833ED8AC6A56D2C83AD69AD3FD6FFA96AB717444035D3B8DAE9D26D475767CAD452B607B3ECA6C573C38530DB071968B7E1DC26058827C57AD84A14B495FE082419255C495C5E13F5BC34D96CB498378CC16DBF6683D54836E12D44D76956A6B0CE788AF5282B9F06B5BAD30347A1D537EF864BB0C1496176B1B10118D02A56407609C0208E860B86A47C82B6FDE76CEC5AA70CF58B4B110D67E70E7B37DFE3A1D530183111E2AC6B30736BE4FFD6DBAEC5DCBB7194B9F0CC733F0A3A +MD = 89D2231FC658E28BE2A1CA2382187137479E3834B498D8E070711515EF670B4D +Len = 33863 +Msg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en = 33926 +Msg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en = 33989 +Msg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en = 34052 +Msg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en = 34115 +Msg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en = 34178 +Msg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en = 34241 +Msg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en = 34304 +Msg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diff --git a/guest-libs/keccak256/tests/test_vectors/ShortMsgKAT_256.txt b/guest-libs/keccak256/tests/test_vectors/ShortMsgKAT_256.txt new file mode 100755 index 0000000000..d36ec39a47 --- /dev/null +++ b/guest-libs/keccak256/tests/test_vectors/ShortMsgKAT_256.txt @@ -0,0 +1,8195 @@ +# ShortMsgKAT_256.txt +# Algorithm Name: Keccak +# Principal Submitter: The Keccak Team (Guido Bertoni, Joan Daemen, Michaël Peeters and Gilles Van Assche) + +Len = 0 +Msg = 00 +MD = C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470 + +Len = 1 +Msg = 00 +MD = C3E5CB55999EEFF4E07B7EFFEC77582D0A5A11A94FC268A872493099273992E1 + +Len = 2 +Msg = C0 +MD = 3A1108D4A90A31B85A10BDCE77F4BFBDCC5B1D70DD405686F8BBDE834AA1A410 + +Len = 3 +Msg = C0 +MD = 7384D12118DA4AD51A519806E2529FB2548B5DCE2A87122B8507F71A28A35DEB + +Len = 4 +Msg = 80 +MD = 53E5E48805AE70306BF9DDC26E9EE2DB87AFE95EF0BFB9F9C44211BE11A4C810 + +Len = 5 +Msg = 48 +MD = C341F676DA4D10D32D9DAD5140D497FECFE9565C79F4F5AA7F1D3C36B290FE3B + +Len = 6 +Msg = 50 +MD = 80B7ED96C53F37EBD0A0F2F7C63B0B35480F57215AB8C5FDF9F5F6E989A53366 + +Len = 7 +Msg = 98 +MD = ACA86EE608E0A6E31C0173F2EEDEE26C527F108F7F11A19A2E4327116485414C + +Len = 8 +Msg = CC +MD = EEAD6DBFC7340A56CAEDC044696A168870549A6A7F6F56961E84A54BD9970B8A + +Len = 9 +Msg = 9800 +MD = C4F437FE4FEB0C18374C8DC1ADE599C5E3F1B68A27D25AE5FC63AFF64215DEC0 + +Len = 10 +Msg = 9D40 +MD = 347B1E3842FEC39CFD8E4368AC9DED9498C545778C665DE29B355FCD32B968EF + +Len = 11 +Msg = AA80 +MD = 5C0E432A4CE0D37047442ACCCB27F5BCF8817B085B0C476D83A0324265023A23 + +Len = 12 +Msg = 9830 +MD = 5F533B014DD834E4A833CEFD68185B84E4E805DF6DD2DA8D9B891B89BE414516 + +Len = 13 +Msg = 5030 +MD = ADE94E747FC7B97F051467FC4B62799217054CB4DDBA5EED5166522C30671767 + +Len = 14 +Msg = 4D24 +MD = 65126BC60DF2CA9FD9BA08D22540CEB67DD9F5A1B90037084A3C2098ADF35AFA + +Len = 15 +Msg = CBDE +MD = CEEF2CC62B98D5BA981C5AA6ADC0CD811D2B703D82A52B741445B756D3A17E9F + +Len = 16 +Msg = 41FB +MD = A8EACEDA4D47B3281A795AD9E1EA2122B407BAF9AABCB9E18B5717B7873537D2 + +Len = 17 +Msg = 4FF400 +MD = FEB2D9EE5DB62E192CC136B0328F1A04732CF5CD4DBE067B5FB35E729D9DE106 + +Len = 18 +Msg = FD0440 +MD = EFDA1D093A29B770CF95BE39BD960165BD7DBBDEC9DECAFFDAEE3E34426CB670 + +Len = 19 +Msg = 424D00 +MD = 2967863A3FA769311C98153EA71B2F58FAC2AEFC92D502D2B030DAA097631A09 + +Len = 20 +Msg = 3FDEE0 +MD = 8FC23D199D8DB9044B6B313D0789D39EAD31CE7392A5C1F7227810EEE619F949 + +Len = 21 +Msg = 335768 +MD = 857E9BC126CE62A333CAAE30B7BA7BD4A84F4E8BCF05A72E4B127FC7A0990B1E + +Len = 22 +Msg = 051E7C +MD = DB333F4801AE3F521636EACB798C17BF6C317F2DFCA4A88E2E4D2587A2C5E28E + +Len = 23 +Msg = 717F8C +MD = 93246A0962C915B7319711C35C5A03B318101C9C970852FDE60A5288CA55054B + +Len = 24 +Msg = 1F877C +MD = 627D7BC1491B2AB127282827B8DE2D276B13D7D70FB4C5957FDF20655BC7AC30 + +Len = 25 +Msg = EB35CF80 +MD = 4AEE49625742C0E7713DB8409F7B5A0ABEA42A52BE534F2362B30F0BF04AD765 + +Len = 26 +Msg = B406C480 +MD = 5EC09D130EC4396AAE8C7CA02637C572A38BE2499243DABFE8DD04BE24B8CD86 + +Len = 27 +Msg = CEE88040 +MD = 4AE73C07E666D4709C8551A05AB88E36D6F0AFAC66B6603022FA662DC5A15E45 + +Len = 28 +Msg = C584DB70 +MD = 18AB7589FD160AA6E44D7D7E07E271F3B8CE4C92103107C0495366286946B993 + +Len = 29 +Msg = 53587BC8 +MD = 4F04A937E7E18C58B575426766B0D94B47CB305CC2205B7CDDD200021F9AED22 + +Len = 30 +Msg = 69A305B0 +MD = C96BF48340982CA3EAD3C1471F2001BC21FCF06771264462EEC6FE9B67048483 + +Len = 31 +Msg = C9375ECE +MD = 8DE0214DEB21ED025350FCE18E9A53D72B43114AEC720775C62D6CF6C297802A + +Len = 32 +Msg = C1ECFDFC +MD = B149E766D7612EAF7D55F74E1A4FDD63709A8115B14F61FCD22AA4ABC8B8E122 + +Len = 33 +Msg = 8D73E8A280 +MD = EF82B3BF37A2E5E4D8307FEF97979FC369F30F1C5C99C9CE844698244FBA539C + +Len = 34 +Msg = 06F2522080 +MD = 142A5D1A4691A4CB45718917B47A90540C986DB9EA492F952208CD1513A86109 + +Len = 35 +Msg = 3EF6C36F20 +MD = 5981816520C69459284F988464C2830BEA42198D07EB616253FF7692EEC2428A + +Len = 36 +Msg = 0127A1D340 +MD = 48D2AA43D1287AE2ED57B900FA0912EB166C6BA25184528C3A7E11A9B5BFF302 + +Len = 37 +Msg = 6A6AB6C210 +MD = D3D34FA208E7F89625E31F13245919A837954B228CDF020DC1C2ACF8DC00829E + +Len = 38 +Msg = AF3175E160 +MD = 3465375BEB6397B152B56B5945521CA60328E08C3C6F8D2B4994B9BB6FA1D8CD + +Len = 39 +Msg = B66609ED86 +MD = 3B81E1D58A40849F5F08FD56B1B09547AF3915C9EB955A0C97188462520C5B37 + +Len = 40 +Msg = 21F134AC57 +MD = 67F05544DBE97D5D6417C1B1EA9BC0E3A99A541381D1CD9B08A9765687EB5BB4 + +Len = 41 +Msg = 3DC2AADFFC80 +MD = E384EEF58B65B4889D9A573A8D29949D233950E6E35974ADC381F100CAB7457F + +Len = 42 +Msg = 9202736D2240 +MD = 6920522DD6F3233CFC549F354F3C9C559EEDD0C9615F99E447653740F8D10B39 + +Len = 43 +Msg = F219BD629820 +MD = A32077883406BF909951F6A56D02990954C2450B0FE78DBB08F9117179F3D371 + +Len = 44 +Msg = F3511EE2C4B0 +MD = FE07FBF11CC5B997881A8ED1539033BF6EADCC5741A38A54BCE59700036C3CF0 + +Len = 45 +Msg = 3ECAB6BF7720 +MD = FE2865FBB5D95F1952EF200F054AF4F2D80E32AB54B0080C3E5DE6861AF0FEEA + +Len = 46 +Msg = CD62F688F498 +MD = 239BC9DFEAFB7A887C8CE1105CFEFC5D00C27A57A0B0DBA07728007F154B837B + +Len = 47 +Msg = C2CBAA33A9F8 +MD = 1CE4BC22AEA81814DEFB4612D8114EE71C466336E768A761979652461B2273E0 + +Len = 48 +Msg = C6F50BB74E29 +MD = 923062C4E6F057597220D182DBB10E81CD25F60B54005B2A75DD33D6DAC518D0 + +Len = 49 +Msg = 79F1B4CCC62A00 +MD = 33D0AB4E9DA0A2E41B994BCBB41377A8DA5DBEA4B3D77FCFACB69341EBC14059 + +Len = 50 +Msg = 90239D7EA2A5C0 +MD = C339C439548C707B9DAB9127057205A11CDF36F2075E602BB1F5E3F64A004943 + +Len = 51 +Msg = 9AF4C2D144E340 +MD = 8490A3D449971C67C00BEFD752D02F9FC8D9B219B08CE3EDD4EE68D5E005CFD9 + +Len = 52 +Msg = A4F2613FA7AB70 +MD = 259DFFA01BF8129B7EF2E92704E012BB23B183DE9C141900B354681E9150BEAA + +Len = 53 +Msg = E863B85EE7B528 +MD = EE8E37D25CDF9A710FF49C6620DB31D101E6125F30D8EF4D19BBF797A169EA54 + +Len = 54 +Msg = 9F3D6D6A44B684 +MD = FD8299D867C94F304F8D4838A55BE47B97CA8DF1E12FC202A841B56417892AAD + +Len = 55 +Msg = 14B06DD54EB364 +MD = 86E77130D9663D9763E5DAE108ED78C352309AF29689A5A5BAF3DF88E431DB91 + +Len = 56 +Msg = 119713CC83EEEF +MD = FEB8405DCD315D48C6CBF7A3504996DE8E25CC22566EFEC67433712EDA99894F + +Len = 57 +Msg = 8569DF971E674E00 +MD = 9C8553DC980CFD3583275AEF2B2E55DFA63B792A39B112030DFF1615FC5C275D + +Len = 58 +Msg = 42DA39AC5951FEC0 +MD = 1BD2B7C59EACBC6848178CE2C617A327542D9CA8095D410378D17228978E77DC + +Len = 59 +Msg = 230688D359F31380 +MD = 658FE74678830CED32A106E4E8691F914008A9478820762494141DB6803C6590 + +Len = 60 +Msg = BA594E0FB9EBBD30 +MD = E2F7C1B451DD1241709DB7DC732A71299716F649E05B495BD2088D989749B684 + +Len = 61 +Msg = 9D1BC347E3B05240 +MD = E8DE03A3487DF1A7B4E34972B1F1639760D004A6B8075EA2957A2E7866F53B02 + +Len = 62 +Msg = 756FDE7AB6CB531C +MD = 9BC9A5AF910479719493F9B4A1D600AD652BA2A12CAFB91756D8941989321449 + +Len = 63 +Msg = 669DAD29EA0D289E +MD = 76C5BEAEC4FD548F181410E29ECE5D805F20F7C02A450218ABC7F77BB9190054 + +Len = 64 +Msg = 4A4F202484512526 +MD = E620D8F2982B24FEDAAA3BAA9B46C3F9CE204EE356666553ECB35E15C3FF9BF9 + +Len = 65 +Msg = C86CCB0A4116026080 +MD = 9BE1D600B0B7DB2FEE56A922999001544F5A7B7E13CE15DA4A69F51F805F9934 + +Len = 66 +Msg = 7A556A043BD867FB00 +MD = CED8C33839842BC9EC4DAC86130537E99F2D7A7912097DD28CBC37AF8344767F + +Len = 67 +Msg = 91829C7B4031005880 +MD = 600BE2EDFA4FD1590D8A7BD3BA7A29DB29C57613456DDA61130630EA25418776 + +Len = 68 +Msg = 0462427C865798D260 +MD = 10D53FA10359EABFE44C087E9F05D91E41C905302A28D6AB0458BD02AD3A56D9 + +Len = 69 +Msg = A51806364AFBD2E830 +MD = 547866981BC411E6EE472C0FAF656718E1FC9A8E4E5BDC77CA9B1500218AB6E0 + +Len = 70 +Msg = F8CB65B7FE6995F200 +MD = 55F89B76D9BB2CB95ECB973EE7BC98D6884DF65577E4817AF980F3DD931B1E82 + +Len = 71 +Msg = 454C87F43DA37EDB04 +MD = 60C1C82A3CD5785520ECDAE9E1B4B81DCCA50ECC71C98D87B5639B7EA2B4B54D + +Len = 72 +Msg = 1F66AB4185ED9B6375 +MD = 9E03F7C9A3D055ECA1D786ED6FB624D93F1CF0AC27F9C2B6C05E509FAC9E7FCA + +Len = 73 +Msg = 5D7C71C275D9F5613E00 +MD = 0DC2DA8257D4EE97045302B7C9EA1FDF5A74617BF76A80D40B642039FB98797F + +Len = 74 +Msg = 1A533E4BD100A83884C0 +MD = 22392BDF4D73B3B30DF521F9732277BA0660EA874D6FBF590D45A7D92550B74A + +Len = 75 +Msg = 7C8433BB4FD46EA17BE0 +MD = E84BA16D775073EFEB3267EB71B03D300FB24AE8E20C7A429078BD482FB5CF58 + +Len = 76 +Msg = 8CACC33C81B29F0E8830 +MD = C48D7A60A5F284571F8137F5E977FC1E58029F7EA8C987881622F8707CE046A1 + +Len = 77 +Msg = 9CD0B4A48455A6716AC0 +MD = 8EAB59D8E6EAC8D2C952B68D6C9E996C0564D9B24B4692A898A76E3A236BF265 + +Len = 78 +Msg = 4DBF1B5FFD3D72D20F50 +MD = E954D22C63E93AC5A7CCA219C8C105699628AFEF2F67668AC386FE1FB950B2D0 + +Len = 79 +Msg = BE31E2945E1BA17901C0 +MD = 8A1BE04E3C26CF7AAAF98DAD5B48B82C00C451358FB73D0E3EF494C27923EA91 + +Len = 80 +Msg = EED7422227613B6F53C9 +MD = CAAD8E1ED546630748A12F5351B518A9A431CDA6BA56CBFC3CCBDD8AAE5092F7 + +Len = 81 +Msg = 77B56B460796582D1FEE00 +MD = AF2070D4228C338B8B991A069B4ABC6DF90AD457E0D819D0D9DA6D6C6FBCCC9C + +Len = 82 +Msg = 5F085C1F91F2E5EB05C840 +MD = 3C212ED21664DE5382F61BA448C4A6CD3EE393CF17925A402C78F5A98D9516A3 + +Len = 83 +Msg = E5E559373233E6EF933120 +MD = 56BC09BD629C0702991D75C81493E0EB68DCAEF196D1E51744F35A572ED578E3 + +Len = 84 +Msg = 670C357239C46D9E96DD20 +MD = 946B017EDA027F7414B6AB77209D85568A01A4F771DC4D9DD3DA7E0701C820A3 + +Len = 85 +Msg = 33BAF96B35241EB2243230 +MD = D9C45196B356D0B4D8C46A429F7AD0E0132734E4E5536B7CBF1E53C6D30F0A25 + +Len = 86 +Msg = 7148A621D35D6D486BDA90 +MD = 79830328139FDB52054C555CB3122B34BAA23F3A498280B8A7EA0D608CB63C21 + +Len = 87 +Msg = 9D7146B5E9C8246BEA8C4E +MD = 721B2FE59047A3920353E7804168D318220AFFC4CF1478EECA9771D3119314EC + +Len = 88 +Msg = EAEED5CDFFD89DECE455F1 +MD = D61708BDB3211A9AAB28D4DF01DFA4B29ED40285844D841042257E97488617B0 + +Len = 89 +Msg = CAD98AD0D9BF161229074280 +MD = 464416564DAA60F07B0025FA54BD6F9BDB08594A92F7CF41F77DEA888928D881 + +Len = 90 +Msg = 6B767F82890709DDF7A1EE80 +MD = 48706E09CBF498AC1DC9CF1939F90099E1CADC6D3F1169981CBDD443DE15CD4C + +Len = 91 +Msg = 73697688CBBF28C51DDDDAE0 +MD = 5373BBDF231F7979CAD769751E17E5338858D6D9F2BE36F8CDE32538092D1EAE + +Len = 92 +Msg = A3C1967A97E58B43453D3760 +MD = 608F739ED99E8EA245B6874C2A2F4594D96894CDA33AE77AC7869463712BCCC6 + +Len = 93 +Msg = 03981280D89F7EC9845C29A0 +MD = A8EB2E66E6314EDF500A190646855C8A0116307F3EBD1F42EE39BEE10C68E6DF + +Len = 94 +Msg = 0E42E6EFD4D3785EF0BB3A4C +MD = E8ECEA06E06A8DB063DB045A935BE659F9D972E4DB0BD06E1A2FDE0AE171A4CE + +Len = 95 +Msg = 6CE6B3C077865CAB3D099B66 +MD = D285516254B574EF9EE5DDA48BED01D4A0D3E9C3A8D017EFC4991EBBEBA07CBC + +Len = 96 +Msg = 5BE43C90F22902E4FE8ED2D3 +MD = 0F53BE55990780B3FAD9870F04F7D8153C3AE605C057C85ABB5D71765043AAA8 + +Len = 97 +Msg = E94F8C8A909FFB8DF22C19FA80 +MD = 266B884DA48C7CE464A4174D6598C01EF04ED0377AA36A467D81C4B4E45BDE9D + +Len = 98 +Msg = 004761F6028ADBDC4D5A8CA640 +MD = 29D30D4B14D3B4EB9A562678ECD196C76C4F78DD76D00CAE4029499BE4F4B819 + +Len = 99 +Msg = B1BA2223CC3AC042D06554EAC0 +MD = A43DA9A3F12E0C2A2C81D97826798D1CB71309B26A8F4D132D2E586FE0074AD9 + +Len = 100 +Msg = 746122438AD1B5B8989D64B320 +MD = F019D82875634377FB3EAA757FDF20DBBA26F8035B92BF69D279DC9B31557631 + +Len = 101 +Msg = 3DAD6E4B69AE8BD16D830213E0 +MD = D01B0A44F48FEBAD0CC64A47F70D204D61A8A863B8CCF0F9EDA6F078B852802F + +Len = 102 +Msg = D441F54B918819F36B220B9608 +MD = C60B87A90EB000B8E052B96527DDE5C4DA8799C6E28A3431D5BF8AC58D2ED0FF + +Len = 103 +Msg = F44CE7427B6042ED343F6D2194 +MD = E9EAB397AC6131A795BFDE8BAD3774FC01374E96642153BCDB5C64A76388FA0E + +Len = 104 +Msg = A746273228122F381C3B46E4F1 +MD = 32215AE88204A782B62D1810D945DE49948DE458600F5E1E3896CECA2ED3292B + +Len = 105 +Msg = B883CDD1742C224246784DB69080 +MD = 39E35FB6ABDCF0A8CA677F0293EE5F291234CBE2D11ECFD4BF931BEA48677515 + +Len = 106 +Msg = 555FD729751EB2F8986B19578740 +MD = 32A5A36D9C8A97C2CA967C9559E05833D4765AF541CE2E4DE58AF2D206FFB8D2 + +Len = 107 +Msg = 7A609524C0F706F629441B978AE0 +MD = 9FD99800F420E182D3EE44C9FA2A8059EF364D11D135D84B8806D524F40A6C71 + +Len = 108 +Msg = AC79B374D401EFDB3232D0826C60 +MD = 91AF28C4165C1A73CBFDC11393B1F4BBFE53991FE7EC93B3F020A085520DE92D + +Len = 109 +Msg = D8FC20BD0025C7582B7946947918 +MD = 59EC9EBDC7BDEDF08DBCDFDA17D5A6D1B0A0E561FA84AF319DCAC0BBEFE3FDC0 + +Len = 110 +Msg = 0ECB1FC3F81F3236FA7B91F7AACC +MD = 9D85D53877B4A00EBF423E8133F352634F3751111D9603CFF9933A05A9CE938B + +Len = 111 +Msg = D5334CA10554C583F11D9F84A71E +MD = 7EAF924D551248929D3EF4DCF11004EE30CAA94C5A13CBBBF9608D9A34D70E5D + +Len = 112 +Msg = 3C5871CD619C69A63B540EB5A625 +MD = 9510DA68E58EBB8D2AB9DE8485BB408E358299A9C011AE8544B0D0FAF9D4A4EA + +Len = 113 +Msg = A999538B0C31D7339A217C1484C680 +MD = F20B43DA43F4CC425F540F1D470EEB0ACCE64A2690E5FF81A19DBE22A588394B + +Len = 114 +Msg = F4D4FEE364CE3CF439D0160EA7E780 +MD = 405410292E9D5A0876776860B39D16246D26B76613740D114B8AE357B968AA81 + +Len = 115 +Msg = 55A4FA6097E8753CCE38FB4E59D460 +MD = 80C395D6BD0E301D6B91B5D4B0E085B711878B4FFF1B6BBBFE257F6F7B876902 + +Len = 116 +Msg = FEE0239360210B6E3761E6059DAC10 +MD = 09032D83344E0B19322762249684E17657F7B75B122D7A765BECA24FDDFED2E4 + +Len = 117 +Msg = 1750D5D521528582177DCDB046E008 +MD = 8B01B5FA46BE87BDDE27A5B7DD395EDF18FF8AE40430D2395713E51311C2CB21 + +Len = 118 +Msg = 68BF3921EF9DD0B6ABF732D9E508A4 +MD = F6DB1DF0871C6DCB1BFB0C196B6CE3F4D60AAC64E108EE05235608F585DE735A + +Len = 119 +Msg = C26037F951B3CE27D56C0303432FEA +MD = 869543C1792B2BEA42AC487C0C5AAE4D778400C508E53B3EB80CD2118E951070 + +Len = 120 +Msg = FA22874BCC068879E8EF11A69F0722 +MD = F20B3BCF743AA6FA084038520791C364CB6D3D1DD75841F8D7021CD98322BD8F + +Len = 121 +Msg = F3D384F6F8B0F7683C2875EAFC19D680 +MD = 5A74F8D25CBBAD796120BF67C12E9BA8D9166DB360E7D428C7051ABBDDA97E74 + +Len = 122 +Msg = D8A9E01B7ABA9C15F27C650AA6D98040 +MD = E07719E87A46E9777D31CA26824CE514A9E0E0AFA9A6B9F6A74FB8CB8C16C466 + +Len = 123 +Msg = 2CFF7186405B02024C4203A7FE7A11A0 +MD = D864BC877ACCD078DA604C8100922EB630C643114916DD3CEE73C71BEFC61275 + +Len = 124 +Msg = 87217854ED19AC6E8AEF3B39B97CD350 +MD = F919B9BCD8BA8DC86A07907CEED97A81256A04B72FA0D4318A822435D1FB4602 + +Len = 125 +Msg = 441D8FC5478410033BEE2F3DA9FFFCB8 +MD = E543380A64ED6BA555A59BD4E5AA57A310DD8599EBE15EA51AE803003BF64D57 + +Len = 126 +Msg = 0341698E451A235FEC3A6BBE42C07B04 +MD = E08309D0DBF14E7B1E8184CF1FAFE1C51330540685293B39AD45A22C94CC3424 + +Len = 127 +Msg = 2C288B527CE3F931B0C565BED2C62758 +MD = 8467438B7D0AD91E49D6B8274AFB2485A916CC24230AEED6163E7BB45FDC2066 + +Len = 128 +Msg = 52A608AB21CCDD8A4457A57EDE782176 +MD = 0E32DEFA2071F0B5AC0E6A108B842ED0F1D3249712F58EE0DDF956FE332A5F95 + +Len = 129 +Msg = E35A1AC6054BA5FECE64AEB3CB97ACDE00 +MD = D6D55BD6196A54EE9DE46EB6794A0C34474AABE72314BAC9620CD47754A69C27 + +Len = 130 +Msg = 34EE2C639DF9C71BA46E88058962D3C2C0 +MD = C09E1CB05F2643016AFB668027E0A18DFAAB39CD323B99253E3C0991522ADF11 + +Len = 131 +Msg = 5EF1EC3AF3A823667B01CEB7069C3D6F20 +MD = 43A58FD8CD4AF591AFBBFE329059F24D1CF023B96E17CF531F32B68F3D8B86AB + +Len = 132 +Msg = A4E76D43E7CC38C19ABF5B09F0E2104E80 +MD = 8196E06986391F4F63D6A1992011BD4A74EE5BF4282D0B2B6788DFE5363F99F2 + +Len = 133 +Msg = F7E6911439AFDEB747AEE1DA0E64165B98 +MD = 04B428F393B865631396C4BC128A7637095996DBBED2DAEA7CB2883165055AC6 + +Len = 134 +Msg = 365C16113FEA84CFAA647B4B6BAD705F74 +MD = 820D9AB1F49BB115D42416D82F6B63EA7F7EDD190450A16D99AF3A1ECD6A4203 + +Len = 135 +Msg = D783EE042795EA5E2FC9817DCC24CE1BF6 +MD = 8C21F09B1C58C5FE6EE2039DB6543B93D810D00CAAAD83897C475C04EB7D359F + +Len = 136 +Msg = 82E192E4043DDCD12ECF52969D0F807EED +MD = 9204550677B9AA770E6E93E319B9958540D54FF4DCCB063C8561302CD8AFF676 + +Len = 137 +Msg = 7E3F13DB88EAA22EEFEC3AB47B7CC5AC8080 +MD = 9891BD74C31304F9A333FC79DE33FE9635C3EE3C6DE7E3397A84832FE5885D33 + +Len = 138 +Msg = EB673EAA409B4F98C581D8DA542EB58B1380 +MD = 41F8280B2302ACBA5F60F369F5189DF5BB1262E1FC41CA699D9347912FE11E9B + +Len = 139 +Msg = 84D42DE0D62B7A480FFB939533283B7A4440 +MD = B640F87CC605761DAFA931A942076EC3BF19D3D4362CB2B99BD1ADF0F66ADBCB + +Len = 140 +Msg = BABAD873529BE92E9BC49CC71964A554ECC0 +MD = 34333D89AEDCE8581A561D35DFC10155EF0DB17A45D295ABB69596C205709A75 + +Len = 141 +Msg = DC3BB8370C04147834819A2845A79B5A20F0 +MD = 01A5AEFE5D65CFF12D7CCA72C5DD0A26483BE735DCE3D941DF2E379989105570 + +Len = 142 +Msg = 8952BE55B2BCA64F32B5401A99A8392AE39C +MD = 622BC8A931343CDE78C4EA5BC2C3174DCC9B0592C04175D6B6FB429558F9916C + +Len = 143 +Msg = A53B4420787D32433A0DFD5D09E5D8E7374C +MD = ADF40CD8A7E8F39DC02F889E037F48C57B5A5DAAB19DDF612C213FD13B7D0E3C + +Len = 144 +Msg = 75683DCB556140C522543BB6E9098B21A21E +MD = A6D5444CB7AA61F5106CDEDB39D5E1DD7D608F102798D7E818AC87289123A1DB + +Len = 145 +Msg = 46A2262940F3D7D9AB6B1680A300674AAD2D80 +MD = 8ADBDACA8987B439E8906AAC1010CF40938F2407B3BBD85ECBB62938C56937D0 + +Len = 146 +Msg = 86804F34609F9945125324B33E672E8F79F600 +MD = 040655685678F4D827C1F5915C47336E751FA0210FD7DA4459C7AA4D9BC75DA0 + +Len = 147 +Msg = 7B2DC42D8B580D6CBD359C46B0321BE37429C0 +MD = 9DAE06EE54E564159D3B5EDA70C4457C8930B2BED8EC2A488EC853ECB96E282B + +Len = 148 +Msg = 0903A731D853AB15F958B8E40CED0B9FCB7110 +MD = 4F52009FA1AEF58238667BA4B3FC16DD4042EAE40991CA7D136B55FE3399090C + +Len = 149 +Msg = 8E3C148CB528836E4DD538D903A3D5BE586A38 +MD = CE99FA4CAFA21AA87A6C9391DFA0163FB3751C8C9A18BAC0EF112BAE6B8C8515 + +Len = 150 +Msg = 6EC0D6E14E4619ADD039F4A24F9FC4D0DAD3DC +MD = C6AB8DF3DF806BD4A5FE6B2D4D27DAD319BE04084E3DAE6D47D962DE79024639 + +Len = 151 +Msg = 12FECA3B2A8699FF59120DFB38BC87793F8AF4 +MD = 1A4CC1223A33BA6F9EC25D458BFE08849DDFAE456DE932A9B457B0ED571B0D5D + +Len = 152 +Msg = 06E4EFE45035E61FAAF4287B4D8D1F12CA97E5 +MD = 5796B993D0BD1257CF26782B4E58FAFB22B0986D88684AB5A2E6CEC6706275F9 + +Len = 153 +Msg = 8ACDD913E4C985859FEBD62F6EEB412230252680 +MD = 3841793FC223E26D064A7C5B3CCE93146603754E0C79D01E61852249B27F51CF + +Len = 154 +Msg = 3487448A5103B1F7EB054C74FB1CCFD3E7B51A40 +MD = 68B4AF82A857FC06F1B1961D336CA08272D1320B95F96D5324A6ED1733A54072 + +Len = 155 +Msg = 21B898B65DE49038D0D359CA991356FDABD719E0 +MD = FE462A1116F4A7053ECAD692DE01F27F8F711E187771E5052FB5C46A3FABB99D + +Len = 156 +Msg = E35DD4BEE303448271E4A68160A4152B30D4EC00 +MD = ED8278F51DB0B5A9460E4C663B199E82294E884EDB54F9EBC70E61A78D40368A + +Len = 157 +Msg = 8E2A8A60383170AA48152522610B8D5B547A0CC0 +MD = 30B9D671F85F5FDE2B1219C00350BB42DA8973832453B4EAD951C3FC0A608549 + +Len = 158 +Msg = F674C01755AD0D41FEA8EB4F984F9033E38C65F4 +MD = 151DC2B346C843E377D09D603C5830B76D17BF6F155E778FB3B4E1B2AE30C966 + +Len = 159 +Msg = DEE4696A6DA3B8A6137BF9573B91B40F288200C2 +MD = 50631CC968830B38404167D9BF3823A3A4DCA58CF07AA37E6E1577EC566015BF + +Len = 160 +Msg = E26193989D06568FE688E75540AEA06747D9F851 +MD = CFBE73C6585BE6204DD473ABE356B539477174C4B770BFC91E9FDBCBC57086E6 + +Len = 161 +Msg = 7659DA517F96FAD5A0B1277F52FED01E4835313100 +MD = 7E4A46DA3DC2BD0C4BBB4FA52611D47109037312E115CFBB9FB6F5E2A9734BEE + +Len = 162 +Msg = 11F80B2028EE430ACC4E525FA85488E64C64A0EB00 +MD = 08144E56D502F5653AB90FEBD248D971A32EB9FA7A915AF74B99161C4C32B468 + +Len = 163 +Msg = F2F533845CA07407654214C0BF1C5693824E0496C0 +MD = 33B016241F354B3E373F18ED492B9B9096993590512AD3A5CE85F41D399F21BD + +Len = 164 +Msg = DF9CA9E83AC80CF76F0C596F15C8CE5DE722AA9460 +MD = 6BD1D49ECBCBBE7F6C8479CD56F09CDC3DA1504FF17786B11C3AD6B28D1C7834 + +Len = 165 +Msg = 59D9E0612A067556CA31FCE628BC9ED8CBCF038198 +MD = BFD5644CFF76E7FE600E4BC9B2B82E0F675DED8F6A7E6F7E9DEC6D464BF39C98 + +Len = 166 +Msg = AC3C4EF2B493AC819DC2DB7E25EBE4580115473C04 +MD = 971DE3F5080D6FCDDA54945CAB1A928C4C86AB5FA1227FA482F34E2EA7A10DA5 + +Len = 167 +Msg = 91935544B8DA1D9A33120838D090AAA9508D7395EE +MD = 33267B11482749CC2E1BC147CFD9320E0421F77A0C4CF55218987FEC08529407 + +Len = 168 +Msg = D8DC8FDEFBDCE9D44E4CBAFE78447BAE3B5436102A +MD = 31C8006B0EC35E690674297CB27476DB6066B5FA9825C60728E9E0BB338FB7C3 + +Len = 169 +Msg = 0AAAE7B9E64C5379E6C385712FBCA90088C5879DC600 +MD = 709FBAA3DA87D0F310EACE55ADB3EED4CDBDD95F7E2A5980A4E4E3AD87C606CD + +Len = 170 +Msg = 89BFECFB6566E0FB46B71DED91D3C392B31D167BE680 +MD = 2E54167EE1CD62FF3BB2C3CC104BBC68839D10886073757BDDE02A02C065B4ED + +Len = 171 +Msg = AD723D09C67B09677286E46AE2AFF84ABCE35B621D60 +MD = 85B69487936E4ED6C5215CFCD13A333A0903D3E7EDD89F2EBC0C7C3DACDD589A + +Len = 172 +Msg = 6037223B33346FEFC063E63E10D7BA78FF02C00A8A40 +MD = 7FFA709F2098F335061E9AAB006983D6E0EBC55012119FE8D07B7849F15A00F0 + +Len = 173 +Msg = 57E4329B428F70DE94A211479B2071BBB7E508F1D2E0 +MD = CD91A07EC4A6ABBAE994DC7C1F79AE856589F0AAE8D722B91F1770005D57BA12 + +Len = 174 +Msg = B0FA56D8833B44F45FA2A5109AD4C2CAD819050DFF1C +MD = FB399C9544C580C2C1AF05848434F28B975E28E40AE7A2F0D59980B11D5F02B3 + +Len = 175 +Msg = 4582F3EE0E0BFDC5CFA3FA7550E939BCF9C0B5EFD04C +MD = F000553C885A074F3099F0F51B2A261C3AFFA5649C347C3DCE55920CC61E25BB + +Len = 176 +Msg = 57085FD7E14216AB102D8317B0CB338A786D5FC32D8F +MD = 3B8FA3904FE1B837565A50D0FBF03E487D6D72FC3CEA41ADCCE33DF1B835D247 + +Len = 177 +Msg = 88B929BF491A1497E86DDF6A4040B31270EF97D88E4D80 +MD = 66FA2D248DAF49FF267015D11925B3E26081077595FE72BBC3FB4F6DE59624B3 + +Len = 178 +Msg = C5DCAD3AA886AA7D2336333D8D777EB15B143861A70AC0 +MD = 352FB05E6AEF1985704E7907176CE19E7EB4E26C5A978576064EB87850A4C1A9 + +Len = 179 +Msg = 12F94C52AFB08898E37C2FB4B778E458F37C6858C1E720 +MD = 56E80E7874093481CF99F090CA7BE3591DABCFFB60D34CF7D7BA8D41AA53E474 + +Len = 180 +Msg = CD911C2634643EFC060E2B641228BAB22C223B8B1186D0 +MD = 5065AAA6591BCCF7856A029E5B57AE76072E2A319588022C490E96DC5C27B456 + +Len = 181 +Msg = C194643A333C0D9CF125B6B729069530858BB4A916FE70 +MD = 98F57B219DEDE9C486EE47968E612E67A4CC9DF9D254437A17702DDE3765DB4F + +Len = 182 +Msg = 093A095AD39D10B3DD25C571B44C612193056D1B112AD4 +MD = C18D21A543916E2AAF8BB91A9D3250C564BC68E03CF7CFE77BA01C120ECB24DE + +Len = 183 +Msg = C95D9E47B11AFBB807B10CB90260A1A1263E9934EB181A +MD = 03C2044E472C6844B277FD86E18F775FA247EA61AA9EA0AA43F5C0F6DF1DE269 + +Len = 184 +Msg = A05404DF5DBB57697E2C16FA29DEFAC8AB3560D6126FA0 +MD = 37FEBC4DF9D50DAEABD0CAA6578812A687E55F1AC0B109D2512810D00548C85B + +Len = 185 +Msg = 4380398B1D3E170596F1CF7AAE1D32CD20B5684FF1D81D00 +MD = 2082CCBD3BF84EB70476AAD419DE901FA4EBE7C8BCAEE633958D8D76021CFCD7 + +Len = 186 +Msg = E7EA48586E6665F113727B7C9EC7BAB64D3DBEA3FFF317C0 +MD = A754E04A19F59987327A47EEF87AD56AA479B002F136AAD4A6228BB742E2500E + +Len = 187 +Msg = 9DB8E92F7CB06389B57BDC2B510E30566EBAB9B72DDE5EE0 +MD = 4CAA1AC4129788163E1AE077E8EE1E05207536ACBFCFC8035D869E52F1865A68 + +Len = 188 +Msg = 9FDED6A700AEBB65BF26400F30F5862CE6B550F67681BEF0 +MD = 5A29AA9C293495AD1E2A1BA07919A2509F5D1AE81760C0163EE5FB690C17CCF1 + +Len = 189 +Msg = 893B3BCFA97A81076A579D81CC66EB540351DC3A241290B0 +MD = 99AA5988D0AA6BCC2E7EEB2BBF54DA7951451DDAB0DF2E13CAFCADBC2D152065 + +Len = 190 +Msg = 90725E6308171BFBB26B928FC0A6F1C3B32718B74A37A0C8 +MD = E5856D60387AE9402704A17C7E849E95235A647AC4FD4800183B07AE217B450F + +Len = 191 +Msg = C1A516E38C83393D9F049EDB1E50CDD2DE3CE448E5D676B4 +MD = 7F66BE08695E49B53C3F749A8D9DF781E577C48B98C0212DC661BA86D0429873 + +Len = 192 +Msg = AECBB02759F7433D6FCB06963C74061CD83B5B3FFA6F13C6 +MD = 2329810B5A4735BCD49C10E6456C0B1DED5EAC258AF47CBB797CA162AB6D1BA8 + +Len = 193 +Msg = 90105B1F751AA0EE546B3EDAC10EF8ABE9CA71C0F0CDDC0800 +MD = 86252B78C292DC84280605710889B3513BF3458E868F71D7DE2C4312A4917A0E + +Len = 194 +Msg = E0CE59E9943CE116C7B745FC595B3C58129052321F67FB8840 +MD = 92BCD77C6BF5A7220F45E6F762FE7C92226764EE002EA39AF42665221F8390A2 + +Len = 195 +Msg = 0502D3A22A7A0E6729EFC524FCC50BC7C62B35C12C537E70C0 +MD = ED55BCA2C0427A5728FB88E3EC3E24B0DBCB850F19DC71EAC2C04BC9B351E5B6 + +Len = 196 +Msg = 4D9BF0AD887F1F21023B749F3F9D2340C0288F009D39214600 +MD = 778AA4ADA311AA3BB78F3D742B30407EEA2A5D2E228D93401DEAACC45B93ECD1 + +Len = 197 +Msg = ACC9748344B37FDDF81027547EC8D26B1C469531935B7A2AA0 +MD = B2F08CE35817FC186EEC9580BEFF6BC0396B84C8B808D8F012D023DD799D64AB + +Len = 198 +Msg = B704443E84AD25B0E73716EA414234BA929F2D927DC1E1B890 +MD = 54A5690D2FB409C32198E2686F38E0EEFA8B48DB4BFDA5D378AE50E0E44B7B82 + +Len = 199 +Msg = E916DF6F4B5E9356DACD76B89F593B70C2B44B3EB1B5835ABA +MD = 127BE5FD941EFC9911F4258C08999BD213ADDC247942BAE4F93BB6D5531F0B61 + +Len = 200 +Msg = AAFDC9243D3D4A096558A360CC27C8D862F0BE73DB5E88AA55 +MD = 6FFFA070B865BE3EE766DC2DB49B6AA55C369F7DE3703ADA2612D754145C01E6 + +Len = 201 +Msg = 396D32D8553DC0DDC72B415A684349AD9B1BA8E10D05970AC080 +MD = D32C8C54380EA7CEA67AE584A977931BF0E67340456DC0CB4357631122E87470 + +Len = 202 +Msg = 35DD0644FA89E942858FC0D9A614C1E5B711EF9F178C04840D40 +MD = E79D74CE6B5BE111F5B256D07E03B11744CE82AFEFDEB0E15C9A6F4DCE38ADEA + +Len = 203 +Msg = E9617EF66F3BF56D461F2C20CD395778FB8AAE1B557A9FFE43A0 +MD = A058CDC93D85412E8827BC813E65B363B2784D22E4FEC70ED6D3CE2BE48C04A9 + +Len = 204 +Msg = 6123803C735CD7D81C5E95AC866919C0348D46D4FE04E5CA2DA0 +MD = D0742263397FE5EBC1C74EE17F0442B957C23354A403571A65164124F297116D + +Len = 205 +Msg = 982408A37B19F65DC9522146F2C44B62F2A09912C3BAB1047110 +MD = E12E4B72A9891AC9D556B62C4244F67BF431F5F9B2D4F054694D0C9336B1166A + +Len = 206 +Msg = 54EB64D8FB23A010586155CDF5C33B1D864D0F18CCA0C03BC97C +MD = 16104C3B08B6EFB71681A9343BB194E21FFC38633BBB9C6C7038E1A349525FF6 + +Len = 207 +Msg = DAE26BEF8C3A247D8881C8FDE00E6F0805147CE81DDD81B53B0A +MD = 1178E8F66BA17934B499AB531C19DB4FA8B42F2D7F32E6FFADDC4DD1DFB0730D + +Len = 208 +Msg = 7BC84867F6F9E9FDC3E1046CAE3A52C77ED485860EE260E30B15 +MD = B30761C053E926F150B9DCE7E005B4D87811CCFB9E3B6EDB0221022F01711CF0 + +Len = 209 +Msg = 9254E832A57DA5D35623BCB77EE4A376280FBA69225E388B34D280 +MD = BB68EA06F1F649F3028555D165ECA33793C21E732B61811862D21E35EAD6ABB9 + +Len = 210 +Msg = 7F891B766CF192FE504687E1D56C843BB0921E1280B5E7287466C0 +MD = 220BDEBEA193D478B576F1D1A61800B78FD04C7D01057A27FBCA4574B4693709 + +Len = 211 +Msg = 0B007253F2DC7DF79883A1C7128EBEBE35E0D902A5D3CDBF539460 +MD = D781AAF38BBF2B5A70945237A859AD3D1A4D8774475136E294D06B217F6A6D55 + +Len = 212 +Msg = D49B562EE6EB7311BA70A8E78F655A4B4853332C116D7DDF16A100 +MD = 9952A3ACC0D5EC0BAB97D2802B920052F5BC33B6F4ECDB7FDDD21DC9E27E4CB1 + +Len = 213 +Msg = 5B1D8934A654645972E4CA94DBCB2FE1AF9156853A2DC2D2B18DF0 +MD = ECEF9AD6318AD1B5223369D5FC6B4D49B6B9A6732F3FA266E0F553BC646DF861 + +Len = 214 +Msg = 9484FF47AB375A83B5E0A83FDE85EC66509706C9181BABA42478F4 +MD = 1F94C94821CFFC53EA41E10C668F1A1C855C9D9572A693DA04358176EA3B7644 + +Len = 215 +Msg = 939C03856BDD26D48A3DED1A121342742F5F833A2CDF39C266306E +MD = 7F6782835E74A464D016694B9743A3769B33FB77D7FD87EF86268D65F0926978 + +Len = 216 +Msg = FAC523575A99EC48279A7A459E98FF901918A475034327EFB55843 +MD = 04F1B3C1E25BA5D012E22AD144E5A8719D94322D05AD9EF61E7DB49B59959B3A + +Len = 217 +Msg = F891360CBAAFBC60E0CDC1CAA548329F6A80778ED08874FB85266A80 +MD = C91A07EDB84E33F7003285A700EFF5329F33F5A0D59B1D63A5A130230F983D4D + +Len = 218 +Msg = 02CC21DBC82B94B3CFD25B0B5F99C45F14D8485A88E45DA3C6B9AF00 +MD = 05083C3EFD60039CA3C3D7108F311C5FCE165649F176DFF9CA4E0343923A59EE + +Len = 219 +Msg = 42D3FD8720077B184CB3119815CCA28C0D76F259B5D764AE47F71120 +MD = 46EEDE4CE47CFD08246339C289185569C3F77AC1EA0755FA258E8EF8D09B3DA4 + +Len = 220 +Msg = EB9B5A62EE1BEF70A170B96DF0D7E8F974EA8B5997E22CFEFE0BA840 +MD = CDB2CAB34F20335D477F19ACFC9A9F829D859DC39C32AD0304440ACF150DF9FC + +Len = 221 +Msg = 4A1369D63E894C71D6DECEAA47D797EF1DF4E8AEF56F76CE0FFF4B80 +MD = FC66413B1EAC39E757205B422EAD5B011FA9D743FE7682280D933749413BBF69 + +Len = 222 +Msg = 4B9C5BB731732C0BC83B1ECC8139164D16E92EC105F66B78BEEB35D4 +MD = 4EBF4E075D5CD1B3C4A363F19CD6254FF31ACC9BD737A82DBFFD36BAC7701514 + +Len = 223 +Msg = 68F41368B7B347819494CFF74E9D8E649BE4EBB287D9B4553248F52E +MD = 034609955912A58B10E72C2AA10C13D28C7A6E5B0B83A3A34E1BBBFB1AB0E4EB + +Len = 224 +Msg = 0F8B2D8FCFD9D68CFFC17CCFB117709B53D26462A3F346FB7C79B85E +MD = AEEF4B4DA420834FFCED26DB291248FB2D01E765E2B0564057F8E6C2030AC37F + +Len = 225 +Msg = AF4BE96D46A63B08104C3345CE0AB60EDC88B4104CFB74BBC0238C3A80 +MD = BA5E9652008B0A1F1FBC7186AFF770746A8218D92DFAA42B4353353CAD104DA3 + +Len = 226 +Msg = FDD3B8E0423BCCBBAA7019DE3E5C7A49A7F5A192E2FB64011DBA892540 +MD = EF6D2C59813F8EE521BF99753594830D32D81827993333C8EC3C2ACEE08120DD + +Len = 227 +Msg = 69DB49ED9D36946A357B2386FD5C652918762D8656F1EA3CA86D393B80 +MD = 6C821FEFFA23E39BEC9E7D7C2F317E9741C7043697A86C036B90CE368DEB35E4 + +Len = 228 +Msg = 984557523A3444AB956E0C040B96C6D4E5F93D0F181606260BD7A731A0 +MD = DD3A30C8CAB68D62C1F94DB18D2CEE4FD6D52BBC4C1F65584147B7009163CA01 + +Len = 229 +Msg = 0C6D4DD90DD7F01CCC7EAE273D8502C9B307F9F913415E9207EE76BA00 +MD = E04DB05EA2F18CC0432E95AA1F634FB1EA6B65B96546571E3ADD3AF7485A5573 + +Len = 230 +Msg = B42F11FE464CEEE0516A17B8B9AE5890FDE0B929007B568AB9F9A9B8B4 +MD = 69B1E209EA1CE962687E7B8329B7FEA5EF51E9A359B15FC6DB96D2D23BE81F87 + +Len = 231 +Msg = 915BB70E3A5ACD0EC87D5570058A4CF47CAE5A56E552EC102E0F1E9ECA +MD = 153A44022228882A01E8F055C46156B5CE18406FD9F49AF7FDB2245442F9169B + +Len = 232 +Msg = A963C3E895FF5A0BE4824400518D81412F875FA50521E26E85EAC90C04 +MD = 03D26AEEB4A7BDDDBFF7CFF667198C425941A2776922DF2BEC545F5304E2C61C + +Len = 233 +Msg = 5A45392A407EB4671C94E2181362802E090D71BD19CF1B3E7CF08E999780 +MD = 4CFC3FB0D014B93779A97CB09E25B588C315DF70778A9FDF3F2419C91FE6670D + +Len = 234 +Msg = FE51F40C4D7807E4ABB5DC347D97E2787F1B175BB0AD9584F8DBC494B200 +MD = 606410A2875BB6458D5AB7F611E85C231E5DEBAD293779F0F694324428FD40A1 + +Len = 235 +Msg = 3FC7400AC8F98C0B419781292E3DBF605BA9DA9C7E7C3FA2FA625BE18B40 +MD = C7DC1F1778D0B62861AA0293417C66E57279DCFF69BDDE7FE07406C520F33A33 + +Len = 236 +Msg = 313C7ED0191674C883C2E6A46CB162F9F1203EB8DA3CC0979CC46A6EED20 +MD = 778E4AC753301D939C3AD483353E93C9FB83F6182893BCE3E2534991E2E7AFA5 + +Len = 237 +Msg = 7F9CAF49ED7EC9CA1693C0D5700965718F7D6C178B7CA4E577F07FE5CBD0 +MD = A590D76A336B2CCFC17452FDCE20ACAA0ACCB5BAA8579C7BE0C889F9CC51314A + +Len = 238 +Msg = 5FE7F0B783293004B9D834D71397512B9F807927383B88D996FB32B5D748 +MD = 0BC5F893E4977199A4F689B94BB024BC3ECC59DE5BEBCC2A7D9414494DE5D3B4 + +Len = 239 +Msg = B94B68ED7FD70E3C30854A2C690E3AB48452ED374786F893F2187FB8461E +MD = 177CF5E63EF346EDC262B4281FAAD1E3DC6E798AECD795E9BC6348511195AAC5 + +Len = 240 +Msg = 03A18688B10CC0EDF83ADF0A84808A9718383C4070C6C4F295098699AC2C +MD = 435CFC0D1AFD8D5509A9CCBF49706575038685BF08DB549D9714548240463EE9 + +Len = 241 +Msg = FF47DE5C77211D891494904695A30AABACD0CB707C358999599E28A4A2B300 +MD = BB871EDFF7E70DE5BD38CE73DDB9A34A6F85F4E2EFB6E0B410FF1FC4A9ABB30E + +Len = 242 +Msg = E36648955EF0236283244693B5B9FE95C823F6D3E339DE3E1EF42F8E059A80 +MD = CD8E0F984EEA5A91BE26C1513417C93A9F4E2EF014825A7CECAE051A5E83B734 + +Len = 243 +Msg = 9EB5DDA4A42EC1617D3F5BB18369F73E4DAA180450769CC0CEB1B2AAF63800 +MD = 5FC15EEDFCA845CBC7EAFAB3D7AD4F11685E7CA28FA5C01E14F0AE794ED98F35 + +Len = 244 +Msg = 31AB94F53C25D46A0B436D689663878B757F1380C6796A20EA481CED41DC50 +MD = 2F0FE11BC018F83464D2ECD6E048B878CF77317138570526C2ECEEA069F50F34 + +Len = 245 +Msg = 3A77FFCD08FFD1F9DBC4F3DAA172EAA998413E67E6DCFC0F8E502CD9DB9090 +MD = C3FC7ACFB511AF6B01701C3DF659AB6530675B8A260AE01668066F49467DE010 + +Len = 246 +Msg = E07B79FF758BCBC30164AF289E10788EE1B893988AD243618E8478AA8E3BB0 +MD = D3139987F703848A135188E4FA71C262B47DDF1C8069F60BDFA22D5B78229E75 + +Len = 247 +Msg = 9E4417A445A11ED1B9F8453ADEEE21E419BAC1C0FC7541C99DA00D53735020 +MD = BA566F36BB50B8B06EF090D92C3E2042DD6056099EFAFF04B674C634AD242692 + +Len = 248 +Msg = 84FB51B517DF6C5ACCB5D022F8F28DA09B10232D42320FFC32DBECC3835B29 +MD = D477FB02CAAA95B3280EC8EE882C29D9E8A654B21EF178E0F97571BF9D4D3C1C + +Len = 249 +Msg = 064FA8C3A9904C17B6E284B7625BD70E8B54DAB53D538B66D0A52954F90E1100 +MD = CC0182D57D87938EFCD731B6B298DF836DFEEAAF18A8838DA637015F20AF59E5 + +Len = 250 +Msg = 0372CD1CE0B74CE05E717FC4B9A82CE1A888F4EF7B0027A5D6DC5F8D13936E40 +MD = 3D074CFDBC193F2D9D5C386D02D7F0FC90AEFDB2657700EB06197A7C6C6D5C56 + +Len = 251 +Msg = C7BC6DF69FDBB01BA287A66B0DC82F453119B7ADB8AA0F7DF4D4D1BF5E0DBE20 +MD = B7B3102BD46196F5767A735CEE949893E4DAD7B573FB1561C1228CB9ACA91A52 + +Len = 252 +Msg = C6D8EE5CC53B4BF75956E31EFA8A4BE99D7AB651461FC44E9D16A691F6859D10 +MD = 380840C8302F3273798765728C175AE48C339633B73DC231076C904E39F04329 + +Len = 253 +Msg = E2076C55D1BE257EC034FB68800508B12F91444C99BC1AA12575FC7D7A6A2088 +MD = F3A77A18796603E71E6A14F737D477996E30E8022B15F847ED828F657D09E5D6 + +Len = 254 +Msg = F667B870AA707996CABB9F7788C9357A7A6EA28B2A711DFCE10CC86FC6C6DDD0 +MD = E013D9CFD08BFB2BD41F8F177D1FC3712F7F2C0BFA6BFD132161DF5C23F358AA + +Len = 255 +Msg = 820AE9D30CACE62A961B6ACB37B86A72FD46D1E2E0F9574D3B963F387758FBB2 +MD = 12FE3F288B71EAF1B21C6922E0AB82F9F288DE76245299E4584FE27D640F89C4 + +Len = 256 +Msg = 9F2FCC7C90DE090D6B87CD7E9718C1EA6CB21118FC2D5DE9F97E5DB6AC1E9C10 +MD = 24DD2EE02482144F539F810D2CAA8A7B75D0FA33657E47932122D273C3F6F6D1 + +Len = 257 +Msg = D5AC1E30C10BC1CD15E27866FEFA48E33AEA2E319868F932A2B84C64663E73DD80 +MD = EF45D3AC1927FCF04C5312F379542C4B933DBF4996BB19A21291B0C42165B5A5 + +Len = 258 +Msg = 4AB430957A6D231FD5B96442302A63812493F7EB505E7EDAF5D79F1DBF7D3E8280 +MD = 693607850F53603CF4CBE2F85478022AE432A2CC473A937F23AD8300954699D4 + +Len = 259 +Msg = B261358A122A159ADBA413F8CF0F2D02D7F9E05901F47A6C1ABA5F9F77FBD3AA20 +MD = D5751C421C5B0CB6E8D85984199F120B91C6FE1C7221082D6DC4979E4253DE2B + +Len = 260 +Msg = C479243928CF52640DD0C74157A672EAC366D4A5BA0D4148EB2D09C25C4FDBBA10 +MD = 4235EBE90160A42D89953F6A6484EF10F8FBDCEA2D93B25BA40210A0317615B8 + +Len = 261 +Msg = B3980A9DEF20DBE4D286B75DBEC249001E420EA4393B562B2B17DE15114869D820 +MD = A9A593D264423A733C4C17A53744D72A4E10B16F0614BD244C7D8299E1D6405F + +Len = 262 +Msg = 1BD985CDE3B3494404E1B4D16B2BED5172D095F8EA8C8F8C347B19B83BA2E92F98 +MD = 6B6914C370E037CC7417D8D4045FF6EC3AED6656C7887C8B7D6C923F8DB8332F + +Len = 263 +Msg = 2B47DAAD44C64F2DAD4423AB3366D82770019669115714DB01AAD8141EAD2AF914 +MD = B36CE79CE1DCCF8B5C82633021308FAB54B83FADD7CF6A108BF8B0417B7873C0 + +Len = 264 +Msg = DE8F1B3FAA4B7040ED4563C3B8E598253178E87E4D0DF75E4FF2F2DEDD5A0BE046 +MD = E78C421E6213AFF8DE1F025759A4F2C943DB62BBDE359C8737E19B3776ED2DD2 + +Len = 265 +Msg = A96D1AED0D267920DF19544968478BFD9ED476D500FBA307B9EE8CB02179629AF300 +MD = FE18A795348502A2D5C94B3F65AF66A19BF2F304ED5EBBEF2A4F3946601284A7 + +Len = 266 +Msg = C5DFDACB24DB60BC725FEEB11B15F88D1EEDD5D654E14B9D681AA533A094A9F8ED80 +MD = FE6D935F258197D386590108F3CEA1524FC4F06A7288187FA09C1C36ABCC34E4 + +Len = 267 +Msg = 9E1D99E9DBE5FA828FBE655788BC8B715EB75E71F225FB895BD4CA6D758D5C03A980 +MD = A1959D3DB04D231E471C0D5A4AF2290487356EC4FE743D193D2D72149DB8C831 + +Len = 268 +Msg = 87C9BD4514CABA10C9D867BDB49C8FFF5BD6BFB6FBB018A67E7D5374B31ABFD1AD40 +MD = 073E128997B3705834A0D478E2F15BCFD5FE9F9BEC4E2E2302DAB3597E8EFBA8 + +Len = 269 +Msg = F9E1A6D9D6792B9F5C3ACDDD9EAAFF0370F7A217983152F48D23AC1CE87E3BCCC960 +MD = 9B96EF36E08215697264411E6E2AA3164038C20B1DE066ACA59B8AFDB4F9B01D + +Len = 270 +Msg = 3F567A6078B6F952DF6E07681E04D178DC76F537B3696DE0640F0AEA78AD0B98118C +MD = A1C04BFB4A933242F5B15C6D75A850581377F4DCF6BA1B3DE3639E90242061F9 + +Len = 271 +Msg = EE6B41172C01654AB7C0CF20B7F36AB0703483E938AEB8CD18E6F9BCDB29FFB3BA90 +MD = C4355861A59F96CE29AE04FA1B04F665FE984091F7719840145319DB31C81C85 + +Len = 272 +Msg = 62F154EC394D0BC757D045C798C8B87A00E0655D0481A7D2D9FB58D93AEDC676B5A0 +MD = CCE3E3D498328A4D9C5B4DBF9A1209628AB82621AD1A0D0A18680362889E6164 + +Len = 273 +Msg = 0AB446212263B276D8A86F20FB75AC94156E2C8D9B1C7DE35049D113AC96FD18DCE200 +MD = 2CE706A37D46F6545B32D62C2780B3196C807FC66F2F0FC039D24D6E6CAEE421 + +Len = 274 +Msg = ECE9BD39477F2F9B4A8FEE98906D5526D0F994E5D8F6057F13A20DFEB0467C60FD4AC0 +MD = 4C66C805591C99D0CCAD64454A8DB1AA303AB9E644B71E2DDC4608FA3196B1A3 + +Len = 275 +Msg = 0FDD7CD321A364E44EA135DECDA4910BDE8120C1FB23C63C795EB17DA82628D40FBAC0 +MD = 0C786F73D8AA8FEF81A01766F07D7D0496954E97EA01B38A62ACC60A8A48176F + +Len = 276 +Msg = 54210A5886A04CBD1EFDEFE792DCC7C4085B3A2E582A5A4C0F5314B63216FED382C820 +MD = 686966F4A197423632E2CE84C2855EA843F9BC5968D0FDA624972AA70421C82B + +Len = 277 +Msg = E4EBF54BDC9F4B1B91A42C0822BFF0BB5613ECDFA1E0A01474BED6897D5A37CB1D7CF8 +MD = 77DAF427B4DD6CD9EBB78C220659C2090B43D430A7BAB9B7A65F68FAD9E8153C + +Len = 278 +Msg = D9C2020DB24BC84887F7DD078CC6C243029ADFF37C3D41A33C291E95837561FA13C948 +MD = 02B427E95CF71240D7460E0609CC7523B6EAFBA4F953AD75C88ABE52B01EAB7C + +Len = 279 +Msg = 21D2D64C53798DB8A118101B76FC39957D286137A838428042F13D5472AA42E41D38FA +MD = 2BAA310A691136A323544A2B956AD66E001772CF4852998EBD04A7707DA55460 + +Len = 280 +Msg = B2DCFE9FF19E2B23CE7DA2A4207D3E5EC7C6112A8A22AEC9675A886378E14E5BFBAD4E +MD = F871DB93C5C92ECD65D4EDB96FCB12E4729BC2A1899F7FB029F50BFF431CBB72 + +Len = 281 +Msg = A40D0922D28BE97EB6C2C071269A0A11547F7D206D39D3C53229078220DAB6704FD0F100 +MD = E864EEBFD3C79C8DDAF57583BA4A0CDB7BC69664729A2A3DD6E39AEF9CF71997 + +Len = 282 +Msg = 57F929AEE5B4628EF6FE014E93BE6C509E0FD437B33C86625841AE12DC302E1599222140 +MD = 95BC94A1CA51F8876D68E8B6EB6F88E2FAE2007FFD419B3E3C0BFC07E3702E48 + +Len = 283 +Msg = F69533A9AB0CFDFBF2F5A5D990C52B0533F76A4427225FB6FD458F965655483096389AC0 +MD = 21FF4B091AAEA576AA3FD66363395BE745548C681F105CCE7B663681B1F1ECDA + +Len = 284 +Msg = 5322E6BCED609A2177C5FD2BC95DB4B7DE2F1884A8D710B41D473BD544AB3B0D8126CFD0 +MD = 543795C1EB306634683BABBA42931DBA748B4C3798A2B2D138E08ADEDAF5D2B6 + +Len = 285 +Msg = A599E2676154A6E3D1D091953F0399CCD63672AAB01334070020E5D4721DFD96DBC3C250 +MD = 039B8D539077E28B923736827F00EFBC445A91DFB72E1A1C0CBFC236718F60A4 + +Len = 286 +Msg = 6C22766FDE70CEFEADE46F7C9197724211216DBD0D89E2B0AE2273548CBE15C5473C4658 +MD = C62AEFD5C35ECD4ED8F3519756D6756EDCDC299BD4F1232694DB27CDBCCDB013 + +Len = 287 +Msg = D3D02C5BE255684FF0094A2A97741C6AC6BEB6FA68CE253CDCE6F315390512D8C9441566 +MD = 142DED8E63C120952658F9E06934802E006EEDC26412A6F3A9A424508A3E99D1 + +Len = 288 +Msg = 47F5697AC8C31409C0868827347A613A3562041C633CF1F1F86865A576E02835ED2C2492 +MD = 4EB143477431DF019311AED936CAB91A912EC1E6868B71E9EDDB777408D4AF34 + +Len = 289 +Msg = F1AC7DE5E3616550BD56CC0C77FF8A375AB68D13DE2B722373F140F8ABD139EC88F44BD400 +MD = 9889CB6346AAC872C974192E3ECD0AD7E387F984DBC8D78DE9E652514BF01DCF + +Len = 290 +Msg = 678527E5C580FA674AF530CCB276BE6E9F8003F428E3F47C533EC2BA518F1779DD78E5D380 +MD = 47634FBAF03C9FEDC46F633ADDCF54B86FC527921719D3A3864A9EB221E49468 + +Len = 291 +Msg = ABA2217B97DBC72869B04FB6B3BE2294F1795A3186E1DC73B4424918952D0C5314AA9B6FC0 +MD = F3A5F3A9A920E097AD9AD64E3383DB891D8605D2A61CAAB13EFA08AA4E6573D2 + +Len = 292 +Msg = 332E1B3FC86DB38A50EF54E186531E2562C586D502F93CD60703F2253EDC1513DD728572C0 +MD = 71374C8A8338E771FE1307CBBB4C67ADC9E78E485BBC7EBF6AFA65BD3EB73CED + +Len = 293 +Msg = BBD8DDFB18D02307F142BC0CD7589C205809D60BE0D947F1D4B640ABC80FE4EFA55CE3F940 +MD = D5048BFF537E109D9E3B541C0E05BF1301CD513D25BE89EA3A0E4FF2052530B5 + +Len = 294 +Msg = 405FBFFFDD6C1208747AC3220F509CC8702554F8E5C6D1E680963DA085483B87124BC3FDD4 +MD = BE43B5B7B299EA90FFC531581CB9F5844453B28B8CB1FE2F920CC2B56F102E66 + +Len = 295 +Msg = 1C148D3B7B7425FC2AEF8D56A3DD47EB45CDAFE5B2F0560A7D3394FFE1F268D2FBE9B6AF20 +MD = AE5383472FCBFDE499FAD005D56DD079F9E5BE4A15A9938168A666B3F3714817 + +Len = 296 +Msg = 512A6D292E67ECB2FE486BFE92660953A75484FF4C4F2ECA2B0AF0EDCDD4339C6B2EE4E542 +MD = 9A0C1D50A59DBF657F6713C795ED14E1F23B4EAA137C5540AACDB0A7E32C29FC + +Len = 297 +Msg = 227D677CF3CC4A9414B92D0469A682A990D6065003E8800AD230F8E1E985A524D795D3576580 +MD = 7A08629658DEAB879B7C1CB16287A34C442E0DCB9B644F3A705FC033F1007021 + +Len = 298 +Msg = A613BA9874384B4A8C9F3499E920D06C194FBFECEFBCA745454EBD9A9D396613511A72B78740 +MD = 69CDA2A0858D554A4EE6DBC964B66DABA4F80D2F5446F85ED0956E0E88123CE2 + +Len = 299 +Msg = 1C5CFD28B933493A66DC9BF5CA3D9DA856919248E5920909C915BC8FCE40EF1E6E0B0C6969C0 +MD = C779815D4C6D0D4B11C956F1F759D671E07D29A7A9ECD5772048DB146902AC3B + +Len = 300 +Msg = 204EB3CE02AB77FE6F3FFFFDA3F7A257B53B2A07E67505C7DBCCCB50832D4F9A2882B98BBF40 +MD = DB7436EF36798425051A1E879302CDD7811AFDF58E4DBE6F348B9017FA933F89 + +Len = 301 +Msg = 38BFDB67DE50E43150FA5CD4DB63798B5E62BBFF32FB6455DCB255F5C6AACF27B13D47716278 +MD = F7CEFA237F1F23B19899451873BF62D43B7CC32E71A2AB690183D5FEEA9E593E + +Len = 302 +Msg = 0CF6117A1614A773BD4840F01FD2ECFC04AC73F07C5A94F98A9E3BFCB7985125D4A1BFC9D1E0 +MD = CC57280531EC39760938A761D3B9C55947F33C918AAEC1372D322E991266AB3B + +Len = 303 +Msg = 7462D66CB57E83172A87412759B5F9CDB8600388D1C3F90F8FC8A89E0F3C513769B9BC8FCB82 +MD = F42F3012335793C2172BC5C57B042509E25182C9DD25809986A31F7074309CB8 + +Len = 304 +Msg = 973CF2B4DCF0BFA872B41194CB05BB4E16760A1840D8343301802576197EC19E2A1493D8F4FB +MD = BA062E5D370216D11985C4CA7A2658DDC7328B4BE4B40A52DD8FA3CA662F09D1 + +Len = 305 +Msg = 3C97ACA85A13A0106FD47D7C59D81C58F2E2C5C7F5C717A6033E6819A0EBE6081661AB141BBE00 +MD = 3C20F5DD14E0B5B3DB527A3B7475846DDFC93DF6B87B2E61851B2049DDA0E5A7 + +Len = 306 +Msg = D18F5D56D451363967D4767E79BDA1A4A90DE871687084C922EDE4319A6716E4FFB5072D8D6980 +MD = CBC67223746844B519E0763F2F035893FDF8C438BB1AB6FD3372ABBB64E636F3 + +Len = 307 +Msg = 557058858B0E5697FC9C4419E6C907A8B85F622519ACA056DD4E3704D8CBC35B91A5076D0D33C0 +MD = 658FC02C10632C8D9A1D24A23235AED9EB30C40CCCD8230505F2C35E3FEBDE07 + +Len = 308 +Msg = 06B2CEC17D720757AD0B9F832AA958141091B25B0AB2B4920242CC3EE2BC438B04754FC84A4D40 +MD = 9AB74A97EDFB84597CFB1B3A18531530511F0E535E9AA4B1E72A4741CA5B1E42 + +Len = 309 +Msg = B98CF17F2C7EB0E739634CED318316AFDC815897E4316175DCD40DE242ECE3149920E2DA76D140 +MD = 0AA431D1C6041008CC9FC2C222B47F280C87026F4FE99EF45A78FE5BFE7763A2 + +Len = 310 +Msg = 9444C95EA6A36C1649F600A26586135A34F1E56633208C767F4265A9F0B47776E3CD5AA515B5FC +MD = 5B6261C228BFF90B3C9E0E511F454F14AF4274E6102C733FE051A4E526F90FDB + +Len = 311 +Msg = 9C30ADFA9CE9F25A6AFFCA7105DFBDBFA98A0E2F57719A645C5D867F5B7D5F8A0D821C605102DC +MD = 7C849389C0AEED7147091488FB3E72699C875CD35F0826331A7F9832167B9FF8 + +Len = 312 +Msg = 80BEEBCD2E3F8A9451D4499961C9731AE667CDC24EA020CE3B9AA4BBC0A7F79E30A934467DA4B0 +MD = 3A083AE163DF42BD51B9C664BEE9DC4362F16E63383DF16473DF71BE6DD40C1C + +Len = 313 +Msg = B82A59C86DAC0285610218EF2C068238C941F5BE67CA5A5CB471E195B3B93E984B65A6CADEAD3400 +MD = 98257A06519F50E590F05DC25D33B84AABA70D6DEBA5383D3E8EEF465B9CC4CA + +Len = 314 +Msg = 8F4806F43BFDF940A0E0DE30168832AC32A3EA1456DFF574FABA15473FCD6F1DC7DA773277678940 +MD = B4EA979E884B333FDB94C5612415860AAF812ED555B64255D0E1BBA168DD5C03 + +Len = 315 +Msg = AC1264C9D5338FFDAB0FF7F5AAF487F7E046601056B15678180A54C0B1CEBABA915A4E77CA5241E0 +MD = 2A7A201561E0BA3E5BB4BBCC9FACBF92EAB9D6383745847EB93AD0178233831C + +Len = 316 +Msg = 2CC2C66FC829514F585D9BE4BF8CC7E694323E42777A78C917D33538F6E53B5C7786062597424390 +MD = 52D6DE82A7B0BE301FDBD03E821B856765104AF6AE0C967553BAFAE26D449B5D + +Len = 317 +Msg = 29BE069D897FFCA132F8CA5C1D2E34FD1D02603FEAEC338C768F9676FE581A03EE3399AD9CF180A8 +MD = 545DD6D107C05A9A0680D5F25EEACBFE32E65FAE88B41F5980FD863EA4D26A63 + +Len = 318 +Msg = 991EB535DCC32C260C0D46DB6DDE353DADF0839FAA4903029B3B0D9B49A3E746D49D8EF3F8271A80 +MD = 7CC8881955DF6550CA1B22DF2EE3F0FC2F8F671C047A32BBD682FA415768DCE1 + +Len = 319 +Msg = CD10861F3A9632FFA513E08DD9BCBF6B2E7BA21CB46D55E724C7D3BE5B7C6145DE686CA9F9F6C20A +MD = CFDD75CB01505AD890245A1F9641259964FB6ED1673003F2964AF09EC3F37067 + +Len = 320 +Msg = 7ABAA12EC2A7347674E444140AE0FB659D08E1C66DECD8D6EAE925FA451D65F3C0308E29446B8ED3 +MD = 4876E273AC00942576D9608D5B63ECC9A3E75D5E0C42C6ABDBCDE037785AF9A7 + +Len = 321 +Msg = 6AE52D5CFD459F254563F1AEDF7619AAEAC27C70B83CCF7AFE16DFB4E44AE45346CEF0994DD642D580 +MD = 6BBC636995355DDC7CAA80E3E619331F64A23A00506240929348867A50F2EFE1 + +Len = 322 +Msg = 0D030F9A2E2A5EAB466D6FBEF14962AAFFAC30C866086F50DA454B9E6AA30A0DB5E620D272C9B577C0 +MD = 5CF6BB44FD4017E16A3242F5FC2D375FDA00D9DDE92B95375627E2B856257F5C + +Len = 323 +Msg = 260B122E4E17495DAA1A9E004C5AA0EE759DB729EB269435EF9D229F41774D4C7ACEAF6352A5628F00 +MD = C94A11AD4E8235E5A5045F902CBC99ECA4340F09C556A17B90E2CC8A350B324B + +Len = 324 +Msg = EA774E81D5A63B0C7894492C70A0960AEAB24E88FBCC765D5D2AB69F1D66852F715A4A1316DDCF12F0 +MD = D10E0B96A977B0441B08050DD0E7C07F2546A3F600B71A20F900EBFA9F5BFE2F + +Len = 325 +Msg = 46020957F94AA4B4574527455E6E9DFCB571A073F066C7707D8FE4BAB714C99515782295ABD51E0628 +MD = CD0BB977F1F24BF0C1600101E16F87E713FD3292F816D1A1631C708A8D00A13C + +Len = 326 +Msg = C8C1BECD825C7F75CC12F31B1DC070B375768BE540D49F7D8475D83D64DD11891761AC99B1DE6AE2A8 +MD = 5355A9325713407F373EA4596AE5A491F27460789B1789FC44E235649E00F9CF + +Len = 327 +Msg = 4A5F9BCAD4914FBB2FE01FCEFBE7C7B5F061F3BBFC3289F2275CFAAB8F69312ED88C53FCACAB6B9B8A +MD = 27C2D8EB268B52A1DCEA5EA7F315A057DC199F7669F92D65E5AAAEE9F5495DF2 + +Len = 328 +Msg = C88DEE9927679B8AF422ABCBACF283B904FF31E1CAC58C7819809F65D5807D46723B20F67BA610C2B7 +MD = 4797BA1C7AB7197050D6B2E506F2DF4550E4B673DF78F18C465424E48DF5E997 + +Len = 329 +Msg = 6EBA5B65EA4C5EDE782C7178469530309F30A19D25F36C5CA9061320F2D541DF439F0A6646014F87D180 +MD = F7D17A0D0A3BEB35D27777C76624C6C8FABD1D816119C45C20BF7CAC4AD1BC5E + +Len = 330 +Msg = 756279C3F03DA783BF46BFE8E6FBECEC6BD372FAB35732CD8B1ED72C62C28DAE0EBA4FFC02245892E900 +MD = 4C10AD89E30D88C68590821A804CD6F52BD5BAD49A840E617FF7BE53F1C72BA5 + +Len = 331 +Msg = 2CCB8AB11969F71041A9F18F91B4A76341FA6DE184E9A9B2CA0A4951B128DEB705EA81E190E772235AA0 +MD = 9987DDB3E73C58F9670535EA6113E8FC5BFECA03E9998A33A7FA6B67F6600C05 + +Len = 332 +Msg = E6FD7544D317CFF635257BDD529C4A986611D254C7CE5200F5485928684F40E0DB046BDC4B2633AF6AE0 +MD = DD8FB1B5098975BE9A9AA02BB27611B2DEC8D943B3333A2CBEE7475ECD9CD0C4 + +Len = 333 +Msg = 0B2173D6DB9B9E03F799B6B59DEBCCE1FFEAA8CD118F22E3A5342C53D4D78A2109D7F1798AFE499F4E48 +MD = C0656E2B9D0A9894790EB7BC71D59AB31132A8A2B4C5F0D7D51E77CC20D773EA + +Len = 334 +Msg = 29DA389850B6279E146BB9F948913C4C6595DF8317CAF71FC4836B29A963FBBB0F27776F111F7AA7E42C +MD = CF8A4BE123EE5B7A96B33EFCBA491EDB802A0C8F338023A594FEF1D9D0FA48DD + +Len = 335 +Msg = 9393D143C10AE0CA7636DA6CBB692146C86528A9F8C3724BA57C74A9E00FB3848A2473C221529A16374A +MD = 14C475E85BEAD6BB7F69EA4EF67FFA199EE4FC2924F4A644D9619223563E471B + +Len = 336 +Msg = 01E43FE350FCEC450EC9B102053E6B5D56E09896E0DDD9074FE138E6038210270C834CE6EADC2BB86BF6 +MD = 41C91BE98C5813A4C5D8AE7C29B9919C1CC95B4A05F82433948CB99D9A6D039C + +Len = 337 +Msg = 7708476C99437E2FD9BE4754BBF89A08324C36D49B27D852034F1CC54BCFED95B4E0E11A7C909E8D128480 +MD = 1AEBE2B1E73E81BE73F34A2F317FC75303A9B677152435F00C027C3695728808 + +Len = 338 +Msg = 12B37259E6C70B2FAC786F0E573A7A467DD9178B7D2EF0CF264E8E12ACCC3060C62A4971E0100BB93CD700 +MD = E71D9EB57EE3AB015B8F40C52A966F887588E01009209AAD7B0BA44974E53F45 + +Len = 339 +Msg = A5A38B8A372C372049ED7D377535B6EF29AE7574986DC30D0A79D9D0B5DDA3103A9D85741B5D58BE366720 +MD = A576739D8972B46209CFEA0E1371975DCEE9533018278CA8A39BB34F72D32938 + +Len = 340 +Msg = 028A103A894572CFAAADBF89765D49F1E3ED6DA3F00A4A48E84545B11854D47C3FF0C936E7E897FA60E250 +MD = CF855AEA5A97DB64124FEFA6AA93BAB0324B91D0AD2B8D2414EB73B27EF4F62B + +Len = 341 +Msg = BF3AF568D5BDBBE53AD42A2C7D419015A57E47663F0C73837CD483B190C09BFA9F120713E4E743D5394F20 +MD = 57B49BDA1B7A3285AC40D18BCD51625A8740DEB01A381161F7360262CD29C776 + +Len = 342 +Msg = 1540A10CFBFC8593F64F4949CFA61E01E577C30C987DC150BA15F6C39ACEBAEDD240B9BA78322D79863970 +MD = 26CF520A3F866FF0A7215C9DA6FD897901DEAF17B7D0AC8F08A200E2584E5FEE + +Len = 343 +Msg = FE2DA1F667125A9EB370B832ED0C5161AFAC4BC7A03976CEEF8B89FFDFA61008CF4BA2649D190F2AA721DE +MD = 242A50B87A2E860B9177C38ADF3228B392A2955F6ADA3B7D69504F8E43B9246C + +Len = 344 +Msg = 337023370A48B62EE43546F17C4EF2BF8D7ECD1D49F90BAB604B839C2E6E5BD21540D29BA27AB8E309A4B7 +MD = EE354290E3F9CE9123C49BA616E1A2684A90F3DDD84E73A1D2C232F740412B18 + +Len = 345 +Msg = 1FEDC8DDAAC6856744AEFD7CBC018561054E6E3585CAB3F46710F6F8A997AB9D9EFC09FBFCEE9EA1CDFE4400 +MD = 16D3610F4B69B82B263B9ECB1F3467A801110059838E7E363D47445CA0096353 + +Len = 346 +Msg = 656D58E735A9AF7CBC79B31C648E200BDE86AEB02349D5FCA38C3C1E57D3BFDFBA46059244A808F528826480 +MD = C96F7F0B1515409705C87A615495A16ED017089BB648D0B522A8DC4C8C2AE0E6 + +Len = 347 +Msg = 06E33F05EC6F55B818F18C7C20E1C7BD7370EE97DEC79F723EC80FF86EE286F379B5183C9CD6242BFC2D4BA0 +MD = DBFE7797AB0DA616471D9920DC189D1CF49FF95F519C6831EAF04D29CABB92F8 + +Len = 348 +Msg = 09B73DEF13C73B22E45263E5B9E5F4F291FB0132B24425A836A3BD6295DA7AAE2B4301805933F67CCC35B510 +MD = 35ADD8DF5816CE54CB5BD8FAC457313F7D286AE8EBC0BF919EA32BB4EE1CB593 + +Len = 349 +Msg = A2CC0259EBA6A30CF724502773D94178E67FDE7F510C5BF320791877752B815BE201437AE318CFF42BD12230 +MD = A8DE947664E60C10D4D53066502973576553310A882067459CE3D2817B220FFF + +Len = 350 +Msg = 2C76974C31F633D26395D833037C6BA084B345CAFC3858303D552838BC9832017178D72C2468A9CC347D6C18 +MD = 3E617D9068894D21136859AB113F3433F92DAF650ED36899222079C3950F79D0 + +Len = 351 +Msg = E0F134DF7984DD0D183B8761DA86000C298E7B8AE7A7308EDA560F816C475AFF5C85ED74103B683C2867E0F0 +MD = FD3448A59D9FB00FD53ACFB6F3C8A8D3ED4ADD8D956EE654297A1A2D9AD35617 + +Len = 352 +Msg = 6892540F964C8C74BD2DB02C0AD884510CB38AFD4438AF31FC912756F3EFEC6B32B58EBC38FC2A6B913596A8 +MD = FBEC0B6D71696EEDE900B77AA6D7D25F4AB45DF8961CA9C8B3F4F9B51AF983AB + +Len = 353 +Msg = EB093452BC1B8B5C069C93383A6888CBDBDF54EA27EE2A6EA03866CAD6F8480DDF46010BCD29511FEB34E7A200 +MD = 9B2C9E2384F77C1A80B3E8481669F61322BC867B6710C77FFB091DBCD28113D6 + +Len = 354 +Msg = 182124E36883F7209E73389F39F72B1840ABEC27A3F072F1687BF1A117E6A500AE98F62CF1512C62EF2ED00800 +MD = 3267CE4844FE8A9B61BD84965F563D64095391BDD0F095FAB47AD27B56CB521C + +Len = 355 +Msg = 2CA783CB3D5E33AAE3DE058E16527161A84B7B53CEFBEEA929A60B146C92124FA69B61613FB1748832C2C1F060 +MD = A1B8B0EB9854C44FD90142968C0A6EE99D6CEDCFDE9AC29CACFD9D25B31EE407 + +Len = 356 +Msg = 7E36947B12C82FA496D485EDD42A6F2C3C32894878DA04D92F1D462668448DE6ED6276D18C349DE0ED4732B500 +MD = 29D0579F2731503F502D9E66060A726030C211D2D37F6366B548DC0714F99EF2 + +Len = 357 +Msg = D6AD21DF91125357AD9F6B6D67E3FB441BB479EE5EFA53478E3DE2EE183B3E079432CEEC47043CFF7759D717C8 +MD = 4B64E9498CAF59D68122471A2F645C85DDC15E948381F8E6466BCFE5CB0E305F + +Len = 358 +Msg = 15463F7D27902F09F4BFDC40A704B38A6F9D5CB5C01EC8B9BE2C1DE8BD0D02A950141652B8C0E68A7A88C25F9C +MD = FC2BDC9D76A2D5016DC796E8F9D76A54C600E7B6AF208554E76E22A08B85C347 + +Len = 359 +Msg = C6608A516B83270FB53379002DD11F426C0CAABCEBB89F9F7D89DE9069F7A6EC76699B8503B8FEFF4418206CC2 +MD = 6EBDFF64D0D3CA3097216DD88989723E5F688D62A4B93EB5DA89641F68256E1D + +Len = 360 +Msg = F5961DFD2B1FFFFDA4FFBF30560C165BFEDAB8CE0BE525845DEB8DC61004B7DB38467205F5DCFB34A2ACFE96C0 +MD = 9D24AEEA08F9A4B5FB8B6DE85A2296F5F4108DDD1EEA4F8EE58819CF84EDB765 + +Len = 361 +Msg = 501C700F800129EBF944F9F60A87AF09AAB22CEB2507459EA596430594A0607E9CAFE92DCE870F251D9CCBA22500 +MD = 00461FE341B5BF6BECBEA9F926566FB4940B8E4E9D08E494830D0C806960DB3D + +Len = 362 +Msg = 446594BFB8B97519D99B1EF9DBFFFF5DD75DD72F60E6788A8DE42F1BD917B450D76B165E97343353F4659268F840 +MD = 25B06AC01077F053A3FD00993EF0408B6A432E99AE1ECEC250FDF7AF80D3386D + +Len = 363 +Msg = E6E6686481E5A98343D81BE7CDBACB5DCBD7AE77ED892B4EFE2E55EE914B4C4D3F47C31D3BF02AB52733265EB280 +MD = 643BD76706C6EC8783A7FC7D2C8189ADCB1E4605EA5A6A8BBE9B2AC0590C42A2 + +Len = 364 +Msg = FD7D50DFA2F48B2D1C72E99336F88F389DF5A1F616F49B616ED4C51C05F6340085267910BA7137B36BF3E9190990 +MD = 4FC6952642F8449329FB8B0BE2841A9CB7795753B9DD632708F269AB0F9A44D7 + +Len = 365 +Msg = 57D7B43D26E8BAD1FEEF7ADF6893ADE1554F3AA453CCB8EBE8ADBA7A8F9E64BDC8126882F3E8872EAE10EF8D9EA8 +MD = A84C075E331DBFBBF3B1DCD4825BE039A4420741AA66645F1787DA8639AA8D48 + +Len = 366 +Msg = 56816DB5D0458EFB764D88C5101906337FDFA82082D67DBA964B35EACB019FBCC202EAFA9966A47656BB52E4E804 +MD = A440994AC6B49D180B281138000D8587EB4A67FAB5AA83401F0724EBD3B62D4F + +Len = 367 +Msg = 0780658D267A25094629F1822E2D430573D6D1CB3D057D66BE241278244ACB3EA4418E8B21D5138455A80BDC81A0 +MD = 8A5C12BC3F7C39F201543C395FCB7715112E798FFF624915F8F2614D0DDCFAB3 + +Len = 368 +Msg = CA061A2EB6CEED8881CE2057172D869D73A1951E63D57261384B80CEB5451E77B06CF0F5A0EA15CA907EE1C27EBA +MD = 732034CAE3FF1116F07FC18B5A26EF8FAF3FE75D3DBCA05E48795365E0A17C40 + +Len = 369 +Msg = C6CF28AD22398E68491C6EC930B95AFEDBF6E44330BB8A9E46B2B7A77B35E3793E6F684E2103E3954BA173CEE7B180 +MD = D1AAD542917C13FBDC897F79FAAEF42CA9EB037F1510DBFCCEBE73F668F70CDE + +Len = 370 +Msg = 245C8B218DADF2D694AF106BDFFDC34CB24D0D00EABF16F94D010AA3D53AFD1E3BA64B8CC419B2291D8BC84D0A8280 +MD = 0D3222D0A0BF5FC2E93ADBBE241135062D048CC9C3EFA01FE250A9D35D572D1A + +Len = 371 +Msg = 6B3056B6F3768AFFE4952DF6E33D991044D92D8EFF9CB886C0516BA9B15827C69DD5C87A8DD7F3AE53A0928AF153C0 +MD = 694FC750A02CD153DC03F875344AC873268FC5DDCBC136DC012A6FCDB4474D3A + +Len = 372 +Msg = 7A0CB5B2759A5E0361CB2238B2BBC1306B3605D6EE6DA35B77E26EA7A80C9480C7D72C9C1F0876F2C850A8B9BF2460 +MD = 6D3F4D4CE15FCE198CFFFDCCBBB581A5B3F15808EB7E21FC8091D5F68166E473 + +Len = 373 +Msg = 3F589EC4DAAFA9125ADAD0DEA6C0CC6230ADEDFEE2C5C8483B9C05814452B977BA3E487DE46FDB42788DC076780250 +MD = AC8ACE8341EA2DDA634786DFA0D73C477743670A6233EB64EE25D993051102C3 + +Len = 374 +Msg = ED78EF2E98AA9AFD62EE9BB8A531B69D91EE5F8EE701BD97EEAC88C2B09A75056C03DA7F2438FFEDD03A47399A07A0 +MD = D1A4C6FAD38082DEE2B8568E5FA11834494EC6F2882FA983E954A2F5D2DB4262 + +Len = 375 +Msg = 7193F965E130AA832EAB17149906EA78B4F2341085A5A1A124C1A9AA182118E5693FAFEDFD6FAC7AE4BBA79E907A4E +MD = 74459A4336967D75F58C73D72BB103C703474D65CF4EDF5279E6ADEE617E4844 + +Len = 376 +Msg = 1743A77251D69242750C4F1140532CD3C33F9B5CCDF7514E8584D4A5F9FBD730BCF84D0D4726364B9BF95AB251D9BB +MD = DEAC521805BC6A97C0870E9E225D1C4B2FD8F3A9A7F6B39E357C26414821E2DD + +Len = 377 +Msg = B01795726D8DA32E9C36F37E09479F4571DA850893CE76BB1510A4FFFF85DB3E2DC89E23917955D748A79612E3141D00 +MD = 766286F97788E1E96A4A8A4024C21C5D6A0F7D0344A2CCC06719BEE55C0E3AF2 + +Len = 378 +Msg = 9BFAD4C6CBE6C8E010C1ED56D377A507FB745DD26767F67F5F84569BD28DF01F697149118B37826F0C064A96BF6F8440 +MD = 31ED34CFB6B5B54FC3B21EB8AD48482E0D90DF8C19633F91B622F00E45577C48 + +Len = 379 +Msg = 0B36E609EC9B746AC8007967F4445CB9BF020D4FB08D72C893E17CB7632CFA9B43C3C39947AA674B2FA47469EE512C80 +MD = 75C5DCD6129318EEB8474D1008DAFADC4DA353CDEED68412EFB8BA688AC4ABC9 + +Len = 380 +Msg = 50BAAD7D4756E451D9734DBFCD6781FDF01E44FECC02B822F489FF7640A07320DE9E0CA2EF9452C146605E7A942C90F0 +MD = E30D1C81A1945FC7F025A2BB4FEFDC6EA7A48AD2B09B3C9AD25CB69F3597058B + +Len = 381 +Msg = 868EDB30D33E50D2639082F69CD0C61BABAE09129A8AFE697307E95D3419D7B90ECAC04F3EFD627E285C04DEE318AAB8 +MD = 2F93FA059B56C386A40FE89D9C9F9C9ECD0F69B9E2DC8101EA6E20BFFE1FBB30 + +Len = 382 +Msg = 9C540C6D4043298DF4BC9EA0B789EFC43216C3CB20D1997C7BEFE94B677A03669C3D7EBD0D3D156D5431BCC1D4669CEC +MD = 5B53CE426FBDC3C75BC56C6B8E9DEFE85338114B38D4D2B38972FB2EEFC0641D + +Len = 383 +Msg = 80C9184EDB1C247FDF554231308F15D6C5F45ECF6D21E7D6BEB8EB841410B1146DEF2F9AA9C452EE60361CE6C67043E6 +MD = 464020013307E018317B11795240E0A9F11417AF40F0ED1E2DBAE829C4BFCE4B + +Len = 384 +Msg = D8FABA1F5194C4DB5F176FABFFF856924EF627A37CD08CF55608BBA8F1E324D7C7F157298EABC4DCE7D89CE5162499F9 +MD = AD55537347B20D9FCA02683E6DE1032EC10EB84DA4CBD501E49744A666292EDF + +Len = 385 +Msg = F6D31F3C22A3D006881241A2D0F4138A2C3E683C8C75AFBFE1DACBBBB6976D51BB7598210B606411602B04C774023C5B80 +MD = 2874C7A3D60F42DB812B0D7BA1BE4FEE7A0ECA56EF819AC244B4491A1673035D + +Len = 386 +Msg = 9E38E9FC2A49E920FDC0452A2CAB48D187952AD2AEF98D1070BB409E5E363A15F8A8D4E56716225478A9AE429F58E5A280 +MD = 7A1684E5C7B6C0BACE372DF894CABB8C97FAB86C613F6EC9E886F127255E1A4B + +Len = 387 +Msg = 0C2B7646EF6BB85EA55D7CB3D15DDAB2F03F74DB6BB92859E5D06EBC364300174619490E907219D3664FC591B36B6FF900 +MD = 0EBB135B43182EFC46E756778FB848BB5658C0C983571177FC2592B153FC2EBD + +Len = 388 +Msg = F08C6B743F2BE9E64E55BF64219455FCA6ADEC2950599CF90F87D1CBE3E20EC9C2ED5C5688B8F6F68F07D2ECB7E9DC5CC0 +MD = 4ED870970556DB67A6DB0516765E508DA7A5F9E6C25920CD15CFC830EBCEC815 + +Len = 389 +Msg = AE2BE2C31BA294971E252E26FBA821A90368507DA6FBEFBD213C3C2B20CBBA0E4759B61261B95A3715549E37126FED6ED8 +MD = A1497D4D98868F012E2CFA49FD93FD65B9344D687716A536502A2808EA63D1B0 + +Len = 390 +Msg = 2D394EB3C3F1DC9A6BC8A88E6DA85849A89038B2DD26113BF503169D3EAC0079B56AAD799436A343A0EC5F53E5D9E94A40 +MD = 95DFD06F3480DAB52BB73B98A485FD9066051D9B6E8963BCE08F6440775679E7 + +Len = 391 +Msg = 53C96678A5B5E16BD5E23C68078774D685E8506F90FE37DA9F5DAA027D8A92BF50A9802B12C724A30FBC1BCB665AC9FE36 +MD = 952CBF5A6ACC67A744821B122A1F20D6CA5B0F4894414144C09365D62C8FAA00 + +Len = 392 +Msg = BE9684BE70340860373C9C482BA517E899FC81BAAA12E5C6D7727975D1D41BA8BEF788CDB5CF4606C9C1C7F61AED59F97D +MD = B1F990204BF630569A3EDC634864274786F40CE1C57165EE32D0E29F5D0C6851 + +Len = 393 +Msg = B107511A7881EC739420A1F7FA56FE6DC9BC265D48FEAE99E8F6051EE7129F25F90C7D56A6B16F80733E174DCAE715000280 +MD = 817C776AFC04869C1E846F8D93C9766572EF8C87FBB80CDFB812E3DF0CAAA154 + +Len = 394 +Msg = D7661A5026665CC9D5A9676E92BA21F430F044C8F4C61941C8F0C075D5E7C5CF0009B6471368222412A70F96C24D194118C0 +MD = 1212965B133CAD2C62B14E28C88BEED3B6D303DBEFEFEDFD18FB0DA4C76C9E35 + +Len = 395 +Msg = A0C5DEAC53C00561B7340D31106E4B61B6B8CDAF7950D5B9AFBA9BA0B8B7418DAE4680B460B1A288029712DDB946DEA0E640 +MD = A47605EF13A281AABF32848BB2B6BC51E901E6D44E27B4350F6F71E3F2ECB54E + +Len = 396 +Msg = 06A82E6D3E0067A21BDF39EB89FBD0729618A0803DF3F362F81835622423CCF9177EF5BBACA40EBCC851D806594F502FEDB0 +MD = F234910B55FB243F3E546B40F0576A86AE2C504355886DD5693DDA7B27EDF075 + +Len = 397 +Msg = B8284DBDDE2AD5DDB44D04251D9E9A6EF9702CBE564BB8722DFE0DA70A228F0AB8D0164F86772F65AB25FA3D029C892439F8 +MD = 0B62F50E6B950894D7FA43BCA5B581F472D295E87D988F3EB4E0B47B5BD078B7 + +Len = 398 +Msg = CFAF722B7986FF2C401957C8BB60F9777309C978520A21A692F47F6BD08C054F4A42A7C1E703153E3C61309F203E82C38C44 +MD = 1255F64B92B359BD8039761C90A6D1E7EF077FFC81D1660A82B0D1F537A93741 + +Len = 399 +Msg = 9329A4CCEC09FB23008F0C59EF522D1B5D85B7FB3832AE3D6C3B15EB7847ABA6128036088E8E1722166A49565A93B7F11EA6 +MD = BAE8BEBAF428E89DE4115A6AFD97509235A5452229B9D093D0BEEFA3B8147983 + +Len = 400 +Msg = 7E15D2B9EA74CA60F66C8DFAB377D9198B7B16DEB6A1BA0EA3C7EE2042F89D3786E779CF053C77785AA9E692F821F14A7F51 +MD = FA460CD51BC611786D364FCABE39052BCD5F009EDFA81F4701C5B22B729B0016 + +Len = 401 +Msg = 319ECAFB15FE7FAAD64C4BA7560FB257B2EE2C1E4AA49E8426612938B08D717F0120CE812FFC7F2D005713A1682BB1DDB98180 +MD = 139548D046E372A6E0A1C54526100529E7033D2218635957567CD4AC03CAEABE + +Len = 402 +Msg = 47D9F1CAEE18C889A12A410DCC086C8D863901B89FA5869FF8FEC5A64B065659F57E7EA54D9911BA05E8A57DD222921C505240 +MD = 67C94CB7E41FF2E43270FE283C9F24054F3C054B4712A92F69C8D859F0D9DAC0 + +Len = 403 +Msg = 74927E91B6F203D54E2E81EFFB4F14889B1958A64568C21053E3DC5A941E14C2077D9DFFC18611B9CF5646DFB6C27E0D304E20 +MD = 32A4C1121762872F68CF206DF3D3A8E1D5FB09C7E711EF3717E92AB0A23FF978 + +Len = 404 +Msg = F6E46F9A7261261D239C74300F434D21475A03D2AEEBFB546F0C5AC6BC4EE97A197FAD9CC1B3C396C244F8F20F97632DC8EC30 +MD = DE89F827CE3147108A6D815B217206DBF7BFFB6B55AB7722BBAF0A3DFAC398A7 + +Len = 405 +Msg = 429DE6D5EAB64B3353736AA20106409B58C0C956F4F751E24CA3D519B730308AFF43232262F1DAE6BE948E87F6C187BA725FB8 +MD = BADE09EDD44A44689A61969B80FB4C57C89BAC052368903643B66B75BD83C084 + +Len = 406 +Msg = 429D066735761A1E5EA847E5EE3EFA5ABF2BE447E9D6E2715CF702F99FD2028AF3432ADD0D7F409E0A3DF144AF995B67B46A50 +MD = 9FED6E33401A696BA8E78787D98DD9F9812B8BD8A072EDF55A48E2E544A48710 + +Len = 407 +Msg = 0A798F7C67743E076AEDB61F0BA84D657DA0DA2923AD4D66DEF4D5934C49991427CDBD0134772D97DB1ED1522BA9EB7F972B30 +MD = F63A171093752504B8C3924779290DE22371F5DA8CA82113DCBB440B1ED70D17 + +Len = 408 +Msg = 9A219BE43713BD578015E9FDA66C0F2D83CAC563B776AB9F38F3E4F7EF229CB443304FBA401EFB2BDBD7ECE939102298651C86 +MD = F7B0FE5A69FF44060D4F6AD2486E6CDE9ED679AF9AA1ADA613E4CC392442BEB5 + +Len = 409 +Msg = 072B844D05C1141680E5A86AB9933E524A9C7FFB0006FD2CEBF48C420AB7890FF685BFDBA54E31571FAD5625C1F08467C9EEF300 +MD = 9BC90B7F39645653F29B39DC300DB5596A37299401613DEE1893C3749167D989 + +Len = 410 +Msg = C6547E7A0D7954F0D14A531E99B6BA3B22B93194D472E669C926FB3BFEFDFC638418425B4F2C11C438A8903004922C9242A1BD00 +MD = 2FCFE6362AF12E973EF82F8CE332E8B5B1EF78628C9FA3EEF8EF3F3BFC3972F0 + +Len = 411 +Msg = 84844062ACFF2734EF26AAF41303D0E767527DF9C54781EEE27F84D0C3262094612C44A8104471ADBD7B9D2899AE4B751CAD1700 +MD = 4E890E3E99A13E6C8FE22A22FBCDE185312AF1338FB7F539130C8DCDB5B800BE + +Len = 412 +Msg = CE88E129B93E120B3F80720C43F187308A336418787D20EFFF630885E20948862BB0ECD3539E1D23D05223C988A2E5495A92A600 +MD = 95AC38939407538753A628212509D2AABB5F4D490D85A8992C4A518E8CAC5BF5 + +Len = 413 +Msg = 4D4768585B090550A4289861A3EA955EE420D41A04B71199575120280DA1F0B9038AF3F35EFA1B8FDCE29F8F5F35DC6A803D49F0 +MD = 10E33DC2E796704B18D73B777F8EA3B9C8D7A7B4B1D6AA35F076314460408023 + +Len = 414 +Msg = 010FE46B5A0E37D07218028437F52F2FCF41063B6CDEF9433769D3AE35885599EACED0BD468E731C8A43986851545A7D200787F4 +MD = 0466529F6873682559D681B62D2AD09C6A74C7457EFC323B862128A351DE4036 + +Len = 415 +Msg = 5A7586F07BFD09DDC140DCAC2D5F6822EB9868F8258DF4DE7D6811EB43C37624A727177EA10F28943083AF7603F954E5CE1BDA0C +MD = 78E30BEBF8355B13AD6089A2BE203C81D72BC2DC729B62574A341F5F2BE31EC8 + +Len = 416 +Msg = C8F2B693BD0D75EF99CAEBDC22ADF4088A95A3542F637203E283BBC3268780E787D68D28CC3897452F6A22AA8573CCEBF245972A +MD = 24204D491F202534859FC0A208237184471A2D801FB3B934D0968D0D843D0345 + +Len = 417 +Msg = 8C7FFA23F6AF3DF0385B9EBF9E14F6998354025123E95E92023A3885360ED163DA1F430A259F6C535A6E3975A3AA541FA536F34900 +MD = FA6B637BD1AB6B54AEAE9555DC1238A2F3FC8B4157D95A74B91A62A50772F8DC + +Len = 418 +Msg = A48E78686CEB99446507346AA71D0C7C5D97AF093895DCE569D8F69B16771696E429787C87946214985B0B6EE9301EC89746495640 +MD = 2D14744BB8B44AFA4C9CAEE0E6A3190887BBCED2BD778093E6BD047007A7BA84 + +Len = 419 +Msg = D13CADCDEF36059A4FC6EA141CF4460B93631519A40CE26ABAA635480687A7AA39D15CE827BDCE367C619AF46F838B3B1ED26DFD40 +MD = 6844EF2F85F3DEC87DB42696B765F75A7BF18B7D140473A2B422AF6EBE52FEF4 + +Len = 420 +Msg = 82275CE8689C8466DBDC50AE683961A5C5D4D3A348025498BEE894E8F0D6B9328D7005FABB85E13A48DF19BCDA503234AF7124C980 +MD = 5C20B106657D98043446BB607C6B1413225A4EC670DB43297629F6B69988A53E + +Len = 421 +Msg = 4B6FE5B999B90B21DB0CF4B8DE1E4351F80D680C49D3F040869256F6371065FF35DAD6BA971698248931C769B95869855377DCCC88 +MD = FDBEEB73D7AAF78C665A19A174FC2AEEA02B3FCE5A154E7EA8C005E4B60EEBD5 + +Len = 422 +Msg = 3CAFA3937071BB3055C96A364F9B1FA56266F47E03A1A28213166177495A59713C04B7475E1AC2573B979BE28EEEF0B651E195CD8C +MD = A87852A9F3A03075117FFF0C0662904F005024999A79712C162CCC3AADD5AD7A + +Len = 423 +Msg = 93302958B1CA9E71AA01CA51E8E6E370D7414FEF7288714EB71F2005CAD8E605C6D173A1617823DCA776AF99A98ECA41274AA1610E +MD = 111E6D2A855C4E6FFA79429A0E9743B2C1CDB76DC826FA305F9CD31B8379EBA3 + +Len = 424 +Msg = EC0F99711016C6A2A07AD80D16427506CE6F441059FD269442BAAA28C6CA037B22EEAC49D5D894C0BF66219F2C08E9D0E8AB21DE52 +MD = 81147CBA0647EEE78C4784874C0557621A138CA781FB6F5DCD0D9C609AF56F35 + +Len = 425 +Msg = E6F4D535970FD7C9E4DD8BBB2D4B4257E68065391F4DEED3B4F7A7E4FD9E61C3D77394C673571F1AA4640D91AE3318DB62D77F237B80 +MD = 3CA2E430212DD6198BF40427401CDF9D822E27EBAC3D7F54DA3F408C66F6880F + +Len = 426 +Msg = AD7CF7E15D97E0AEE75B907BCB48C30ADA54CC6C9F1B3371C7AFC74E176E6A07B1D8624B135102E395AD98A31921EA81F121CBC85E80 +MD = 800F328DE88FCDC3357E76F8ADA88680A77F6C63A3095BE8E3244D4F9987C3C3 + +Len = 427 +Msg = A9154D621C9B4BFE856394C8C47D5204EF218C54668713568F5C30BFA5980B24B63B4759EF05C16F5E4948BF91BEA979FF990A9EB520 +MD = A5671913BAA4B7ABE2468464D46B65E8ABE0E99817686F4A01C4BE38DAD4FC63 + +Len = 428 +Msg = C020B6643B128F27BF4E654D131E6C41669FD6F5941BBE0102053FB0C7CE405574D44AFA98D9E9A41EEDC1B6E21FECFDBCAF89EE50F0 +MD = C0B3231031B7F25D8E7EF58BBF604F9DE5A9228A99F868083D4160155FE61078 + +Len = 429 +Msg = 3D26CDFCE6E89B4D1A4DB097BFFA4FE505DCB18D0C191836F3978CE1685F7E7FC59F89D71FA443F0EB5A29092628B5ED778EA9D8E280 +MD = 84C6F63BC7D4A9E79DAC9313CEDEFC70E88AC301379C2F6B5A3150A6059F648B + +Len = 430 +Msg = 0BB08EA725002AE244064B3560D147027CED860FC32F289E08F5BB3E33DF133D2AD6962B8DB6BE7E050511D0743B66B5D2238B66DA6C +MD = 1A6987604BD092BBC246D7BD4092B4D83F3E44DF7BB750AC93A324852F035273 + +Len = 431 +Msg = 49FF7A3964CBB260C1A624EA3423BE62256253D1128B81E75C3E277B419C0FEDDE0CD4DBB5DF0DBAD5F16ADAFCFE09F2E642F5117DFC +MD = 1019395EF9C2F0A2513367791AADA90C3E4627B90BF9A9FC55817C979ED953CF + +Len = 432 +Msg = 0DC45181337CA32A8222FE7A3BF42FC9F89744259CFF653504D6051FE84B1A7FFD20CB47D4696CE212A686BB9BE9A8AB1C697B6D6A33 +MD = 5B6D7EDA559574FAE882E6266F4C2BE362133E44B5A947ECB6E75DB9FC8567E0 + +Len = 433 +Msg = C9E5FE547A3E2A4F070F2EDF8915A1AE232DB0A6974D8BDF88D15C7FC828AB82E919B061312404128457AA460B055330E74A72250B4180 +MD = A525C358AFF2A3A78A79D28D118A9E709A7B018ABE9150ED468195BD9DF4611A + +Len = 434 +Msg = ECDFA7350DD9A1C79FC41FAD4276264510A4F53748BF58BD655D0E041D68D81A839D9D9126753759FB2C2EC92DC690759DB8972EB2EFC0 +MD = 962F2C202C8740A0AC7838EF0222CD4284862A31A165F2F46F15A943BDB1A1AE + +Len = 435 +Msg = 60E9D7F0EAD1F704D626ADD35B269BC6BA9FA723D21D3FFD07BFF7BC2A7F253427C669468413D50DE4E087E6DFB40D3394180F4D885AC0 +MD = 0DBAF1BBA4248F3F0FF56362F9356284495B7AC6421238B574C18AE6169CD72A + +Len = 436 +Msg = 50D69429B80F785AFD10DC3C47AFCA11D66BA16F591AF56DBF5D283C427FAE7544D06A88F4F2DDC020A90E39231019364963C9D0271680 +MD = 781EF1BDDCC55FE63081619808F447F4EF3EB4B50AB35B593CE5C4D53586BC5D + +Len = 437 +Msg = E3D2906D5DCDEC5910F6C1B43BA414C0F6D8FFD992C2CF76B082AF565DEF8C00348739AEABE24879B1E49C50ED9CC281E25E47E0ED8460 +MD = 5DAE96144863093D0F6131289E4984436C5EFA15EC9313ABE8C1ADF46EC48472 + +Len = 438 +Msg = 352FC252E3EEE275D29AF0C2F5803C762259249E8BCBF9F293BFEAD094328454275D817F98F302F3E899A406C8D39211D0BFB7F36B80E0 +MD = 7CE3ABC8F27AB2091EC633659F0609482754BD55A5B7889631A39A7497D337F7 + +Len = 439 +Msg = 6AFF359906DD15357A5262CEB17DD58FF51B74DCF55FF951260CF6A419282752E13B7CA0798612E3E1094202603A2E331792350FD4A10E +MD = 672A6B2C69C74BEFA327F1EAB7056D09C56E49EDBE366D677DDA4C224135B0C1 + +Len = 440 +Msg = DE286BA4206E8B005714F80FB1CDFAEBDE91D29F84603E4A3EBC04686F99A46C9E880B96C574825582E8812A26E5A857FFC6579F63742F +MD = 86F87E75C87F9BE39E4AA6D0C5A37A5964D6FFDC462525C0642C9DB010DE38EE + +Len = 441 +Msg = 5C0DAFD24AC5712E9772017732C245E30BA569E247F82AFE4D05305375141482A8778D8C5F0D6C5B27BAB687568C04CC1D883466549CEB00 +MD = A2FD6FC457BAE3DB51EAEA8D6BD71D2D9F69294C8AC6B81153F1486C90EC8838 + +Len = 442 +Msg = 70CB8949582A95F73E1C00831431E1A7AA4372FDAA3DE4DD66B554539E8003DC6638A292E3C07BC09AD007590670D9DB9995F76CC6044100 +MD = 65D645F08AFDCEA5B216796AA7F54F5743C9FA32C89AB0595230FAAC7330BC06 + +Len = 443 +Msg = F1724864E3A8C9EF8F9FFF07224B295ACD1DF21D5CD318F0C8484642BECB45DC9FAE4E18459451DBE7C94524165BB323A363AEB34F12AE00 +MD = D7155BDB40B8BFF6FCF5597D8D4D0FEDCE607728654705004C2CA97C456BBEAE + +Len = 444 +Msg = A5E2F570FF98F95601BCB7EBB0CE9D22FD5A9A0727F10594DAAE511395FE8D48472159B20EA94B81414CA50363A716EE0130881FA81DBC70 +MD = C3A7C802AC1124C89FA3FA2E172E3CE7C252BCFA92EE159CA32AE444089F9A1F + +Len = 445 +Msg = 59C8DFC6BFFF8D1FC4ED4B362A0C73D1E2C47CE11FF4CFC3FAF74B69BDE0D70A7D44C91F21324E93A0562DD088351AF94B97C4CAD3D38D10 +MD = 11EDADBF244ECA9D625AF2F5BCA0B2EEA543B47CFBDFBD933642F51671A6F177 + +Len = 446 +Msg = 456D25084E73FD7F8B4E9E0C5A28A3DF6BF72A95CFF996645C0D6989B7C36DAA989F6D570578838D276366101DECE16C188E2AB0D1CBB020 +MD = E25B69275BCCEA86B76B0CCAC9531921C5C190CD717AD578174C74DEF1A94185 + +Len = 447 +Msg = F6203A102927E1F775EE10391B2370C4133EA999EF76E822FB47B2C47372FC5A0B2F61C467FDA567621DE7FCD29559C8B479AFFEC131572A +MD = C036391518CE7A26AF5C2274128824030B3FDAC33BFD76AF4E2B6A613314B1EE + +Len = 448 +Msg = EEBCC18057252CBF3F9C070F1A73213356D5D4BC19AC2A411EC8CDEEE7A571E2E20EAF61FD0C33A0FFEB297DDB77A97F0A415347DB66BCAF +MD = 959FE007B57C2947C36D1D66CC0808D80DB7DF45D68A34852B70D2DDA192C25C + +Len = 449 +Msg = 1251A40134EAF29B0FCBBA4E9712AD63E95DF1473C561127B1BE2B64375804F7D54C442B0C89100E66BCFEB906013437E7EC5885C197756580 +MD = 841D93CE5B5217F0EB7C5402D5DD41804363649C55277B6C7D8E53E5013AF89C + +Len = 450 +Msg = 71DC616856F90F79E04F31F16DFFAAE002EDC5725CA3FA59D2A468F69587D80CD90D1B488F86F481B4A00B447B26AD425E7AC7AD4D09774740 +MD = A3DDA8C5D90D0C90CC6F51593418C2DEBF8232BF5F85B8E635C30E8D9860CFB0 + +Len = 451 +Msg = 57AE1BF18725675EE13EC67FA5C4B6EC1911CE82F73C00F4BAD877D778EF22FE6EA93224262015A5DFCACAE3087807FF8895B72B5C530A3640 +MD = B77EF3FD6E74FA981E79BD0BD43AD4AD5E63D658BE44CC1BB070A155176C3865 + +Len = 452 +Msg = 841AAE4092D3C3ECEAB075CB9EE06EA07AEEADD236767B1595FC7510888A87C4747C3CF4AC68E5093E069423CF98B767EA4098886E1CD64D80 +MD = D5AA12506DD78EA97B395C40F5752087E4D1AF5BA7C3AA907B599A14FAE21DAC + +Len = 453 +Msg = 5D6A069F7980F35DB923E7D3DE2835F8878630BBC8751670EBA733FBBF614EBE3E0B03E860334E56499E43BEF8D6AC1C6C9C1588B1A56FAF00 +MD = 560E08409199E8A76CF899754CFF09C09355E48E09AF1121DCDE713653E2E813 + +Len = 454 +Msg = D2BC7F70B8ED9853C98C2E3017F97E8B1643C10959227D3D0D334A938F12C53EB3C1371608732A50CD5614768F804B98C9E587858A469B7DF8 +MD = 2BEE6176C0FF0ECC3F590A8B2F0ADC477440B0D7774FB25CE3C93A0CBF9F2850 + +Len = 455 +Msg = 55B1386C80FBECC7B54207EEAEF70069B1836378558309973FE2836322BEFD420AAAD73E399D1BCA063A590C3A82DF8708B1457B61A2C80352 +MD = A38B9B0E882EAC9E225D36A7C218094FA924D539FBE236BECAC62DD0F6B9D6B9 + +Len = 456 +Msg = 416B5CDC9FE951BD361BD7ABFC120A5054758EBA88FDD68FD84E39D3B09AC25497D36B43CBE7B85A6A3CEBDA8DB4E5549C3EE51BB6FCB6AC1E +MD = 1A93567EEBC41CC44D9346CDE646005D3E82DE8EEEB131E9C1F6D1E4AFD260F7 + +Len = 457 +Msg = 9F15C32E77E8DDCDF9576D2A17AAFADB77A66A35B0CB244C6F6079A3F033B2B42AE723DA59302984BBCC7D25EC57714F79C7316C81762EE98F00 +MD = 6FEF82CE035259721B2BD902B6E1EE2ABF49369532C98AFA422DF1114232B598 + +Len = 458 +Msg = 0C7D0C80FC9D6F36EA9F87C248D503A29761221BB58AF67327DC82CDB25883B5251D3F7F148F5EE32EC47AC70498CA7C6A2EE82B18918B381E00 +MD = CB6ED2BEF590979CDD64DB0FF82E9DE9CA10E92E9EF0CC5CB37FFD19EB515AAA + +Len = 459 +Msg = 1A057422EDB7E08FCD04AD53DFD7A8C123647A1032F5025DBC7C22916250FCACDF1B2B5DD0CE295EB5F424F541FF55BF6A8D777A571C0B508120 +MD = DCE1BBD5314DAB485ED59355F385FDA72E43D347A025E5580F06DF3FBDB438E8 + +Len = 460 +Msg = AC3EACDE274757E1AD019FC3B68250DFB627414EEDE1FEB4A4A313F50BCF18F84EE1466DE13E5AA62E72D8C28E5365873F36C3DF581A7BBACAE0 +MD = B82BF1D50686BCB59D8EA149098E6F9AF6A8D6311AD0A77674AC2E83B935ABC5 + +Len = 461 +Msg = FF8748F7DD2AB2ECDC95EDA2E0189D55F012748DD9EB63B3E77802E215431A96D5F59F3A4C9E70F023C2F91C218E308EC8DAF7463082C15F7080 +MD = 8C2F35F3832CFEE6BEEFE219AF37B0CE48401623ECE067A05B7AB5A4C93DB165 + +Len = 462 +Msg = DAAFF074211D1E547725C49C5709F0FC904D8944864B0350A1453DE2E56F188DD61534C4FAA59384436F6A6CD9702E1931E675DDB3BD6977B2F0 +MD = 169D531FD463975B048F444826C71A07D30023A5BEAFC3F337273CFC47C426B4 + +Len = 463 +Msg = D191A654280C7618570DE0EC2E3BC1578E9EC81AC48022FFEE1224AECF2A67E572DF39C343E7B1B06E56417FE83233FC6CD40ABF2602BE6FF640 +MD = 5051B4DFA8FD244633224C903CC24DB4E3B8D735EA536ABF2F6851DA4162E085 + +Len = 464 +Msg = 5C5FAF66F32E0F8311C32E8DA8284A4ED60891A5A7E50FB2956B3CBAA79FC66CA376460E100415401FC2B8518C64502F187EA14BFC9503759705 +MD = 549DB056B65EDF7D05BD66661B6D0A39B29B825BC80910F8BF7060A53BFF68E1 + +Len = 465 +Msg = 84D9ADC0C9097A66ECBA5BAC63BA2EAD6CC52D95BE23FAD7088234D87A3B6B6B956DCAAACCE94B98C9314C47F41BFB20D601B5F20CCEB86C4A3F00 +MD = AB3B7C4BC4E75D0DBC6B5DB91A266DB341C7E1062620BEB3BD5210B3B656000E + +Len = 466 +Msg = 2B90FDCE3B7D08812A3EE16E47ED849B134FB644A09ED63B274B09F38EFE46E5CB6C1E6F3F4C48CB23F8DF74D81E594C0C16100E1D446693AB9A00 +MD = C25924C45A75294A7446B1919A0AE686C6C3140D4ADEE18AB22A82AE6A0F3A66 + +Len = 467 +Msg = 883B4DDC623CBEE9365494693358E8DCF0E253B345C12A1270A4937730A04417B66D6E2A3A712560C6A07859EF56EEA6BE39CE1FAA2EA283FC8AE0 +MD = 41C02A159125164AC18AFFC85866381548EB0FD8596411DF88BDAF2704900CAF + +Len = 468 +Msg = E679CBB7F00A3902E805D1FE5DD015E7C4692ACD0BDC6BCE9B6C0CC31195E6D43DF50586F030691180543A54836687398FC51DFA57562980755140 +MD = 5CE5D584F9D13736650EA43FDFD1F61B67B6EFF50CDF32D1F598D45ACDA33D4C + +Len = 469 +Msg = 9E86F90FB087F12F7F9B7C6F526B5352EC2E6BA8A1E27202323BFACCD1A85D0DD6456AF7EB02DC01F9AC7800BAE5A55A011AC869EE8E9881714F80 +MD = 64DF7C16B2AECFC6A1F0377918524611F26A92E400D733CE154D18813B2B8EB4 + +Len = 470 +Msg = F24E07FEC11D49BE67326349510A57AB414774A1C56111B46D988B93AA29BB35E1C1BD47E80F8621C06E8A78D590B30181430BED12B27702168A24 +MD = C43466E31B383B6F278C0109390038C677108A86D7EAC115925893F859D76702 + +Len = 471 +Msg = 5E391FC9253D20EE80CDEC7B9259C01CE479BB4C97A76CABF722B6DB2F105EEAB8B91C5A4CEEBD05C39138A0E9398290CF6C9C13C62AF335CB0A60 +MD = B94976913C995EF666FCECE30385CAF1C91F1DDCFBBFE059C78D8F4559A09693 + +Len = 472 +Msg = 7167E1E02BE1A7CA69D788666F823AE4EEF39271F3C26A5CF7CEE05BCA83161066DC2E217B330DF821103799DF6D74810EED363ADC4AB99F36046A +MD = 794ABFD7EB622D5608C1C7B3F0A7821A71900B7172847FB0907AA2899972663E + +Len = 473 +Msg = 031321978E471EAB14C2EE6E3EACCF57B203A9662C2343CD764A41FFDAAB43D5830D29A15E568767627A116D5B8F47D2363959DC6BA7B0BFF674C600 +MD = 980F5456316F9C2398CC30DF9E8B9F277E340CCDB84E28370A1E9AEC11F83C5F + +Len = 474 +Msg = 8A07ADE176B3DA0C6CD3C8B40A3CC8C6F0C214C660B885A7486B4E447677FBE0C62284F00A816E3B083D1A4F614C44A5F04E98255B5BA15849767D40 +MD = F485E1FAF42FAA9FED74B782EE9EA9F16181CDC8DF02E98EB1AC11023739727E + +Len = 475 +Msg = 6C993A10F1EAC2D1BD759277077D7E3337822C428FC92EDFF444C58F106617BE61D23395F77AD6D0C43659CB29578E40BC0CCE1292C637236215BDA0 +MD = B236AAC9BB67A3C39A5BBA209A40866769ED777E233E74FF12A8A5A70AADB053 + +Len = 476 +Msg = BDB3EBAD9FFAFE0EE4E4AC7FDF0A970BE38E8A915684EA15628EF03DAD5454FC353D9EB27A93C428C7A7ACDAC6A4C51E7C35D845782BF6B9AA74B3C0 +MD = D68CA6ED623A4087055305DBD40B9794ADFB601D9E7369C8E0C5491741F58D58 + +Len = 477 +Msg = 04C9968BDC58062E20D602B6BBA6596280EA44E4DFB4F11842F847436C68722B8CF82F9AD7A474B1257A73D3D3CF8CC7CCBDAB52DBF2C43D16A82038 +MD = FEB160540D0848B7F81CE8C54359F39E8896368EE29A1519789E0687E2E8CB37 + +Len = 478 +Msg = 33FB9B9C1403340C038504CE1BA613725788CB765CE9D1A359F15BCDD2BB888A8D0FA370312048601E29536297738485160E1B0F3FEF938A285A2A74 +MD = 59466D7746504F569BB955B7CF519C93CD7A219358A7FABA96E28CFFD38C0CBE + +Len = 479 +Msg = A5B8774B9D957DB574F9D6BCD8B888E70E746F3EB240DFC9507B3983B8F2940B6625E36BEC3100C90FDB40182BEC5DD007276FD1281AB704792F8E16 +MD = FA4A748A6523391538D23C38E27B8498E00644EE970DA6E4080531F2FBFC4F45 + +Len = 480 +Msg = 2FDA311DBBA27321C5329510FAE6948F03210B76D43E7448D1689A063877B6D14C4F6D0EAA96C150051371F7DD8A4119F7DA5C483CC3E6723C01FB7D +MD = 9CE89958CBDDD8DCB22F66E8CBA5F6091A51953189464803BDC773ABC7FAA906 + +Len = 481 +Msg = 72B72F086513EABF4CC313157CF04745B40E5A77A04206103005FC3EB7A77D1EAF81B6F9020A1BE6BF7AD8C0C2011D8AA8F18EFC0620B893B50EA03000 +MD = D369FE5477DCD6571AC81BDAF47922F850A08FEAE36F6E3456D96F24F54BCC27 + +Len = 482 +Msg = 7FD02685386254BBDF27B52E5CAE59FC7BAEE3AFD2ECA52B912738354245804D87D0303B6060D076F2F12DE3FD19F475AEC0FD410CC14794731806F640 +MD = 3854EC626079B86716E0FC469AF8AF887FA71FD861B5546B2077AEAF6F792E9D + +Len = 483 +Msg = 02DAA8B12F35FDAFE5AB24B236E00245256500D472EFF4904E954DD4397B9F49DC142DCCBB1C2B3B4D3AFCA3FCEC4EFAF9854B3054901A53A180168320 +MD = A13D4883074BCBDE2F437CCEEBC31C83E0A8A1507E82D67BA5A7102CCEF5E81B + +Len = 484 +Msg = 260632DAC6BD8BC667679202D38C471383227D0715AFFABC37B6593544B3799C257DD168BE9B39576FCC583FFB5012629E60C44A51FD67BD432047E2E0 +MD = C7736CEEAEEB4CC77CA4DF011A749255BDD6B17D91847EA36302F2525FA07F05 + +Len = 485 +Msg = E61BF690723D45257C7B2004E8CD05D876C8D792D94680D95CA2CD869FFFFF5ACF9D0B162455AFB6F19B8C60C97B2D8CEFD4F74AAC7034204DFDD7FA68 +MD = 05DB4C18D4443FCD59527652D2C90A00E9EEE19BE74D9031239D9C82D8339495 + +Len = 486 +Msg = CF719DD9A1256446A6220A91F975E26934E33C1CEBF2D5DFD7FCED270B7073D3E96F2215BCF2844E4A25FD506567BABF039BA9F622F935410ED3F6BD58 +MD = 30DC5CE9E086C3F1786616CADEABCCBF3A3CC3C80A24981730F3815DD44EA92F + +Len = 487 +Msg = A6E86899DDE05DF1C81826047106FC6C258A4B6E347411CB66D28CA203DADC465548D1986C17E548465646CB95801A2EF4E6322EC13320FA551E2651C8 +MD = 8E32AEDACD4F231F482B591C2EAF1362AC9F06231A4B78B996C337384F554AC8 + +Len = 488 +Msg = 95D1474A5AAB5D2422ACA6E481187833A6212BD2D0F91451A67DD786DFC91DFED51B35F47E1DEB8A8AB4B9CB67B70179CC26F553AE7B569969CE151B8D +MD = 6DA733817DC826E8DA773BECA7338131AB7396417104EDA25970980C4EB2A15F + +Len = 489 +Msg = 1090FD6C2652EFB04DAD880724CB7414743FCFB4F93CF8312CB0B463CC27FE18BE9F745C499925F8FB4C43C11BE87D17EBA1359FD2F9E5CC2C40A84E8A80 +MD = 875DF7AFF1D829182B85D543B13AC857014F74F9FCC3A35C610B008FD5813F29 + +Len = 490 +Msg = 723BB81B01FAB9DAAF8F48B75557DBAA5103773C0DB24168BFA06886E6AFAC0EAF5A943669EFE84B0E3FF2BA6B681C4A16626D3A3DA58BF6D4781203E5C0 +MD = 574765B3FE24702A9FE4E61F34B42CF10649239BB7F5424AE9E36BB34B42C415 + +Len = 491 +Msg = 6091F9DFFCBD33C3852046578766797323339BEC2414C7DD044D60542C38DA9A5A6F8B385BB1BBCE2354CE744CED5FD673E7C9A4F50E6298994328A24CC0 +MD = 211EE1E7705F3F201D8223E1A4C2AEB9DE96F1234D6C8232058E8402BC31FA46 + +Len = 492 +Msg = F406EC84ABE14A45CA8F161EBE319125E83A19E4452AFD47DB3BE542501A405EA7DA19C317006C1FF9FF7E305C836881638A56C0427181809139C1D21900 +MD = 58BF33618B83D9BE5526B455E94F3DD579A18B083E2BA6D9E723911A5AA1B6A1 + +Len = 493 +Msg = 1F3DDCAD0F956BA1A34322731FFB1E58C46C66A0E9E5D60CC08E62FBEB55E63061894C13B334D2FC0B9B8C0293228F2A4BE36FA91B96054756264697EC28 +MD = CD71145C316B961C369C128D01B9500A72ED279988F22F64C270A308E00A15B6 + +Len = 494 +Msg = 3AFC3DBCB3FD9F4ED17D707AB37EE10590A8F3CE8F49E3C5A99077AA2BAD362F81D715B7132E62922A629FDD5A746C36FA97A7218146B55D559C8330497C +MD = 74F573C32A0B2256E72DFC700BFB6090B9993AAA94EAE8F5E7F848D4A14F2E7E + +Len = 495 +Msg = E4D811304A25E7AD7773FCAC8F028E60E4BAE3867EA81FD4B99FA53FC7991F34937D7278C146865F5BA10352CBF0FB8ACE858B42B0A7EFBAC0F62C6106F6 +MD = D85BA60F91878C0851240A4094D9EA2F64636BE5CDFF54B7AD5325D616899101 + +Len = 496 +Msg = C71BD7941F41DF044A2927A8FF55B4B467C33D089F0988AA253D294ADDBDB32530C0D4208B10D9959823F0C0F0734684006DF79F7099870F6BF53211A88D +MD = 66C9CDC8E8C6C9417D7FFBEF3B54B702EEE5F01A9BDA8DD4E28FE3335DEBBB51 + +Len = 497 +Msg = 061AE36ACF15BF6AAAE8A35A8196E13337FAAA50340FD70FF9F0CD02E53C3724E84C16EAFFFBC09D6EE55F3B344E6E37ACACF3B687B0F44CB06427A23B5400 +MD = 624D80B5D4F0655C266C848C6FBB5F8EE8B9BE12F1C9337368835AF867D0CA1F + +Len = 498 +Msg = 98B5605377B6A50833F0561B7AED5FEADB5411A7851EBFC8F9156C82714F6A6A07ECF372E4591F91EA3F25AADFD47A2220B55EE2838BA02ED8ECFAF5FA8280 +MD = 5D53111392EB1F712C1441B0AACCA92F1948B8836CC2AAD5C03F88750BF2E3E7 + +Len = 499 +Msg = F4CC640571758CB1BB7D83B8D4FDC9BC8AE34EDDE4867D3ED464593F939C646E9725553DFC9346CE8A966225A716FE520EDCCB6F7CC064930E0A8D89DA76E0 +MD = 827583CB39E7EC0A8CA323010C126CD072D45D247623497D4118D2AA65E194AB + +Len = 500 +Msg = 67674ED72E45F150D25F661EBB7F60F21A6AB07EC53EEAE794906E0137959B034F495A1DF0E71D9934C28944C4693AD7BACFA66236157E37746A6D165BCF70 +MD = 28F7584D74D55D54E3657DAB7F493C1B38CFBE43232B52C2D6375405C704B774 + +Len = 501 +Msg = 19513D84D7B9FC5D5C1C6E57404888C6D201B6D6D054D346EE000933FA7467E0E4A6AF3A065498B4055EA1AFFC9EF805C4D7161C58A9EADD68049B9FCDAC88 +MD = B5D8321A74D122A45EFA3D102DA71320A8976F21392BECD207D80EE30B415F79 + +Len = 502 +Msg = A8D213B9586C9E81AF32CCB8E70E1E76FCE9EBC2FACF250F4DD0D826912932A3045B0BE6DA7839361FBDD8746B4855D08E99DD94B7196A77538269EC06E370 +MD = B4C57AED67C3C2DC7163899302FBAD24A25642902A4D44D00B0685AF2C7469FE + +Len = 503 +Msg = A1D82877A8B3C98D68FD9937CFDA320688798C2BFBAB2D55C078D853E3052D17F349BCE2F875756B442D26B54C13E119C0FB96C5DEA16A05208A53FCBFF950 +MD = 22A4F749EBEF42960F87319C585E6CEF04C8E9DBE84747133AB8583200AB5A82 + +Len = 504 +Msg = F57C64006D9EA761892E145C99DF1B24640883DA79D9ED5262859DCDA8C3C32E05B03D984F1AB4A230242AB6B78D368DC5AAA1E6D3498D53371E84B0C1D4BA +MD = 24AB37A93674CCB1CEEC9E5681EFC8BDF9FCC7721CF1CAC175E0B20E461575B8 + +Len = 505 +Msg = 8473DC5382DE32957E3A15CA3D791C67D20CF9EFBE3E46407DCA5D02635AC86D2E0B22C76D7D080D362E82758914CC0AE2B89BD35F71D84492D9430742789C80 +MD = 2AD97A5C7B0144C66797421450BC16CBE6BCF56C062C11256B3AF88B77770725 + +Len = 506 +Msg = B9E3E2755ED1215381B24557EE14F8CD2687A071AEB3C74F421CFEA3CFF8A6EA0D4BDA2AD4BD8243CBA72B481CBD526E1EFA1D9FD432B987E81265824429BAC0 +MD = B5127C8310CDB4E0ACB33E9408B891F52D00B0A1E639A6BED3C676EF3F0BCD44 + +Len = 507 +Msg = E8332535E9A2052467A10205C87000BFC6A68D73962E69E4E56F10BC79C633C52F4D0074D6077595B660072E10740DFA66BC1320469A3196E021E1327CC03AE0 +MD = 60F97A108464BDAB44FD7CC3E5BC80BC7289A07ECAE2B81D36DB8C41E3F6DA4B + +Len = 508 +Msg = 6B078FB58DCF9A52EB84BE6EEB7CA87DF711160DB96D1FEE6A289A299844DEADC99BA30FFDB77FFBE36B62DA8116D59512DB3813ECAE09459ECDC5599343A8A0 +MD = 6F3F8EC308FF8991AA4E2542D15D06D6D4201481CFBEE9B5B3504EE32EAD72EB + +Len = 509 +Msg = 80EE82DECF5B9FD94A7A8F9866ECD1925715DEF457A43DF01AA1196101A91E1706A31868305AC282FDB8018D19930A07E229BDF92835BF544C585CA957031538 +MD = BABC8BD0845DBB44CF04981D2FA77422AF00613D57CD1CB3A68DFBD32ED63EEB + +Len = 510 +Msg = 15E0FEEB0F7010B047634E909D4646454FA1F06D7DAE63E831191CAD21604FEC81FF4FE69E540169A752C82CAC9C167E15C431F29AAF752B57DE63BEB0319580 +MD = 43040DD3462A8617B231C5419321A317733ACC6E0F7E7D5FA929CCBD3EB8B6E6 + +Len = 511 +Msg = 538989EEFA891A2F2FDB195E6C75A36FFD9010B0D58419CB209EA58178284E38491A0A8549EECC27ED31C02E24DF4321DAE90E6867DA851898867D2993997300 +MD = F86279C0A027B729460979D4EDB49601BD1315C3B0DD7B0D691F73FB59CDC2F0 + +Len = 512 +Msg = E926AE8B0AF6E53176DBFFCC2A6B88C6BD765F939D3D178A9BDE9EF3AA131C61E31C1E42CDFAF4B4DCDE579A37E150EFBEF5555B4C1CB40439D835A724E2FAE7 +MD = 574271CD13959E8DDEAE5BFBDB02A3FDF54F2BABFD0CBEB893082A974957D0C1 + +Len = 513 +Msg = 559EE28FF19F91DFB5F12A4EA7823F7C6F6AFCFE31FAEFE1DBC810521C59CCAB4CE747B6A37E3E700C4DB3B243D2210D59FA18CCF344BDA10089ECAFBD2046D700 +MD = 827D56C85DD65862A97613AE8172F2CFCABC938CA4EABF346F4EE380527D3F57 + +Len = 514 +Msg = 3369763B630EC3D1F8DF47DA9804FB6AEE5831D5B5EED07A3B5FD8DE1B96F721825AAA698164F58CF1F3DAF8E7790947E8698E718CFE1808D571F4855BA312AC00 +MD = 2BB8A1E3E55A021A16A9DAD2A13D4CD0AA44A08487F8C97067F3C7E6ABFB1ADB + +Len = 515 +Msg = 6CB17B2EA081DCB1B2AE30BD5DD5A1A9F845DAEADA0C0F76CDB3E45DD92F1516FEB193AE54E85678C16DDC174C1546985520E54F45CB1E03AF7C27A9A89FD16340 +MD = 316F44A0423C1B5A92F34D588B7F4AF4B0C96EDB7F1CAFE38A9129F8E9E74F95 + +Len = 516 +Msg = 2BFCEBE7E89132B9A809595E5F224712B4DC34164B8AAB486490291353D176C2CDBC967C325887288CCB7BFEBA29A4778B13FE78C97E2707EB5501096B700DE890 +MD = 0A14C1DBF40EAE287D861710B747C93259DC9B875A454295D347FC12D52860BE + +Len = 517 +Msg = A3E70F2D2137770818805804DDDFAF6C5D758AA50101B255B9731EDCDDCE604F9A336B4ECA8370FF56B96E8C2379E26B94BE3B5D659CA4550AC2CD50F25EFA26E8 +MD = 0A86050A0F2495697EED5C0122FBADB946282EBD75414A3C9175AFFA79A330FB + +Len = 518 +Msg = 2F1F2DAADA4BEF1649F2E6DCF226CC626183FA45FB9F8D561F5E12B96A7888A16D78DD177B0CD8B153E02768AA408A1166630F450394FEBF8B76CC08F6B545B0D4 +MD = AF2292002173557C8969CAEACA470513CA34EDDEE11FA6B14049A30CF9188E62 + +Len = 519 +Msg = 010348951C308EA6CD8B9E0D3D70AC0469AD4B1A64B69873690041177D4F25FAD90BC94A719466079400AB2BFFE4A45AFA49DDAEE6962E3EFC615A4D6EF82C5966 +MD = 15334166CF20D1506B75ADFB38D5075D03E5506254A62AAFA2F92ACD7BBC2803 + +Len = 520 +Msg = 16E8B3D8F988E9BB04DE9C96F2627811C973CE4A5296B4772CA3EEFEB80A652BDF21F50DF79F32DB23F9F73D393B2D57D9A0297F7A2F2E79CFDA39FA393DF1AC00 +MD = 1947E901FA59EA789845775F2A4DB9B4848F8A776073D53D84CBD5D927A96BFF + +Len = 521 +Msg = BE442CCD00200140AB3E88FC0398AD7DE7E4EE191A3261064D53922ED599DCC855AF4FC7C8910FF871046F486FBFA66080A8920EB2AB4AAC2AF2E28B0F7AD3499D00 +MD = 17EC135A9EA7979C4530CBF8362B01E7BD433368D805D2F0D15694231E113358 + +Len = 522 +Msg = E3A99A6DF6DD46AC6426E66F8F3C0D5E106D2CDEEFD318D2B156D63D83F2ED89C6620A05D95EA0058F34DEB935797E33288626D18083449AA9C8A2A2AAFF573383C0 +MD = 4AD6E1D4BB4A5E97984220AA614F76466A10CC9FF73E74BB90FF6477D6CDA868 + +Len = 523 +Msg = 2F7AA4AC44632140E9225BA95CB9BB4DA26AD78222BB746D1D98D8B57FFCD00C2D5AC271487FEE2CC27A0D9C62F3B577DF3F8B88239E2BFF2934FCC2A047AEE5B9C0 +MD = B4B5DEF8F1DC85E67BE2DC03F73DB473E55A487C204ED9D9177DE0E7C58B30A6 + +Len = 524 +Msg = A1EC099A79B5A35A4223D4C881F0CB11414BC90FD2FFB4667F1DEA99858AFD889D6D1655A19E46FD629C6AB50A7B4C41C5B4E23C6ADE46CD1312720571A268E39B60 +MD = 34CC4B87943A653E56B386F25C26E993E94B7DEFE98F2F86B1222F3B2A5B62BB + +Len = 525 +Msg = 8E5973C1A658519BFA2D40C26CC3E73314A14019F7D8A2E66C1DC510547250BFFA12299557902CA95BA718CB6ADF2ED8D290ED7F390FFE44D11AE6E3D9C62400CA60 +MD = 5D77BFA332981DA6030E5E420308BB96B06C317AEA322B4F55463788DAC1B130 + +Len = 526 +Msg = E00A470BA681EFA0F966BE976F98C42036B34A116154E4B4E10A6CD5D14F001673D95C1E0FEAE1C0A5A9F80F8A1608AC3C9A908EB4CACFF8A5C8BFDF699A4312FD24 +MD = 3B78CD555BBC070D5B4F46615E619E8A04F1194951973BB450600590A53C861D + +Len = 527 +Msg = D923883110D5D4F4614C59A9189185ECCA7C5B99319022617382CE2C2C5E8699220F0B0CD0A43B474759BDF463DA0C5165D661DC838FC24D7C4341EBE9E190EC5AC6 +MD = CE75D4EF4D9E8BBF7CE3D68DA4F2DBAB707F819A12728474E536F67D7D5EB0FF + +Len = 528 +Msg = FC424EEB27C18A11C01F39C555D8B78A805B88DBA1DC2A42ED5E2C0EC737FF68B2456D80EB85E11714FA3F8EABFB906D3C17964CB4F5E76B29C1765DB03D91BE37FC +MD = 0C1B8C1AF237E9C5501B50316A80865AAC08A34ACF4F8BEDD4A2D6E7B7BCBB85 + +Len = 529 +Msg = CF1D9DA31D5673D04A9514C9C4940489A3A7D5F92F163B653F8325C1E63947E7E2AAFA97F18F61FDEBED5168FB69BEA9749C48DF8529A2D371FBB9B62A52D7CDC19400 +MD = 9F74A41A930D33D350C9AF8755986877A17A256D7064100A139544EA1B1AED8C + +Len = 530 +Msg = DE0C2162926F18E7B7F04C967E4EABD01CCF78F36645A732782C638C8B67974FFB9309E12FDD140CD880360509B2112EB2C03BEC4FD03C2F658FDE72E524C861CFD400 +MD = 0E610DEB20AF76DC3E670A6B0F01EE3F9C7461B70D3F63B15B11FDF0E3489D35 + +Len = 531 +Msg = A05C7165CB93CC0F09CC1D9D1118E3CAA9AEC51EBD44D10897D0771FC5302AE55176FDDEA05FB01EE4956BA342ADC7BDD6A50D74505828D87EA49EC62273E32F976CE0 +MD = 6B79F993A974F34693F9E4BB81287713FE4DE0F57F28E821ADEC4491F058054E + +Len = 532 +Msg = 728AAD14235696C8974370D9238E80BD16A93D050C865DB08FA06C5E4D12EAF1415D59DA4F7CA16981481B10743AFDAC95BC8292CD837DE24692AB5E70488016140B30 +MD = BBCFE1318FCCF6532BF81828516E3ED1EDB77E90795C712B9952B9E531E5BD98 + +Len = 533 +Msg = 59E0177EAB8DD3EF68BDDF879D196D651E501F878C364B363BFE1F291546F6A9286161C569C7078C97DB9BA14011807B7FCF671E692CAF601FFB4C76F8E8289A280C70 +MD = F6D2C7B1939DCA8D25C0AB89811DDDF2E5C6650EC336254A9653B79F1E40E960 + +Len = 534 +Msg = 2557EC19609AC2F7B3F80AAFCAD251AE9406E68638C6F34753BF051A89D19CFE4B13D03B4D4966EDF8565D18EED198E295209C93308CF7E83AA41DE4A1074D19F6D8B8 +MD = FA5E7E0EE763C5E568D4D8F17C90C6E9FFCE5998EBCC3C436A4626ED2DC6F4B6 + +Len = 535 +Msg = 0C6CAE1F4A2400C0E320993AAC01CD5007B32E10ACA1690EFE071ED9CB980DBDBA2B08B90A01026D2B6781E189B05E394AD5950152040A4E10C97BCCAC7B2C1A0A83A0 +MD = 173AE87CC1ABBC1B62D6F36A045E55A6D2F70676D625150FE6F5ABE88415E152 + +Len = 536 +Msg = ABE3472B54E72734BDBA7D9158736464251C4F21B33FBBC92D7FAC9A35C4E3322FF01D2380CBAA4EF8FB07D21A2128B7B9F5B6D9F34E13F39C7FFC2E72E47888599BA5 +MD = C4315666C71FEA834D8FF27F025F5CC34F37C1AAE78604A4B08DAC45DECD42BE + +Len = 537 +Msg = 4470C0B4C5821BCF0B9EA25B6F7D90C9C50B063FF923CEF75638D73621B2F4F5B56D92DD720536357B000162DDF401FB5475C06C4C88F80C38EB8FDC8617F661037A3E80 +MD = C8AD8F956623A87D1547A881E01733FEE0000D81A064CDFE6937BECE1F2C5D38 + +Len = 538 +Msg = D138F1008FDE534C233CA94A79C14FF6B3BAF4B365FD8176A0A58170314BD70AAC14E58561E8A9C47163741365A31801F5F4B6E32AA8E3F4439890CD30AA97FDB0A6CA00 +MD = 6F43745C787A936798D0A8A98A553E1D7A7FC2AABFEF5897D0C9FDFDCB93CFCD + +Len = 539 +Msg = B4578CF28E7891C9CC1CC79D0F4807DA6A5C37441ABD483B77C65E502A318A86AEA5581020CFE9E9E6A230DD0A529AE90E84086209E16779CD3DC0753713F830532C96A0 +MD = B0D9E839F90C500EFF089EE65C52839B6758114E52543F937CE938F0184FC2B6 + +Len = 540 +Msg = E33A87CDDC83DF9E9DDA70693E20C31F13F7766F63BB97547B9676D9A6BC999DCC65EF9B486CEC34002A149E840C3D87864C90AA1489CB7FA9C4167E475CBA337E485A30 +MD = 4F13ED8BAFD0578498E16570B98C69E291043FBB3DE8FB150E016B23060735B2 + +Len = 541 +Msg = A1238AFE1839BBC600C8BA91C17BAE23E1146BBA2D76FDE1A9EF1FB7BDE3D2D9C7A3201E78F2800040ABF26D3606209C4D22FE53370DD03CC8B12ED95272A9A5E1557820 +MD = B6E7CB14D4D437429A15C236644199BE456B29864061BA5A50AD8DBD8CBB942A + +Len = 542 +Msg = 5489A48EBA7457530F8A2723352515FE794031E11CF5FA57128448F9709FA27CF20E3E379FF7D5724C0A55E3550656787EA45BDF7510F5216388320112AA692A8E33E704 +MD = A9FD31490F859F9EF2DBE9805112378D482CDAA7BAF607007B50DB82D82F8FA6 + +Len = 543 +Msg = 2EB78EF630423B07F50CD987F31EF94142905400E5259BCC235A51027B153318352CE56562436588F6E332570F96E873AB189C1DB6264E91FF991401720D25F31FD4343A +MD = E13E37C74C844D14DCDB293F91BC6153FBEF5F04E2026A40CB8E60A32C2E1925 + +Len = 544 +Msg = 36F9F0A65F2CA498D739B944D6EFF3DA5EBBA57E7D9C41598A2B0E4380F3CF4B479EC2348D015FFE6256273511154AFCF3B4B4BF09D6C4744FDD0F62D75079D440706B05 +MD = 5FF8734DB3F9977EEE9CF5E2CF725C57AF09926490C55ABD9D00A42E91A8C344 + +Len = 545 +Msg = 7FBFB37A08D050D584F6D58862373E1627DC81CD0F650A4980A783487FF3D3ECEC71909DACA59F13A47E2F7FEEA949A5D444587B5B9B483B5E5D25776047CD00237C619380 +MD = 3E0EE29D683A50BB7E8519DB1C669FED21CE1F0125A7F8CB5F975DCEB819B9C8 + +Len = 546 +Msg = 3BD3EC7D914EC6461AAC5412025903B049E48584325F81AC822B7091E992A36B3401C7349170F7647D46715F440C5FC40608FC97D01447B65898906F5C4E61088AA7626340 +MD = C4F38BBB71C0C68250FE09EFC09632AB1F2E2ED63CAE8AD109C73301AB6C867B + +Len = 547 +Msg = 2516B94FED3FA3C8C8892F0EC0AA8F74D9295904810095BF4F88ABEBF93896A8F0256496182B76A9A1D37DB18D154E31D07D9A87C38712549365DCEFD2291A46520856F1A0 +MD = B56A134E051FDCBBFCEE12088A085DA983185400C86FFF668A03F5F01D47FA3B + +Len = 548 +Msg = 763AA494184999EBBC09D59178B44E0F24102A737CC43C62FED6B5F6B175531C00859FFA1AF9FF292283078A26A602BE4C43DC3F54C806927C401B905CD0D73E6B1A853B70 +MD = D9BA627D95DD98CA19556AB027516C31ADD7D997CBE5E3BDF9D4AAE8C8D9FDCA + +Len = 549 +Msg = DFD617A8BA7BF6C2FD65A7D531EBF0DFF617926830D0FF1E146A03F103422648C645907F47ACCD66FB6E510CD3F69AE9D43A69EBDF6B32736F5C1394B2FC5D445EB3E72EF8 +MD = 19FD0558663D86CAA3174328CCECEE1B528280C3F914EE56CB375B03DC665D0A + +Len = 550 +Msg = D2321825C805E9BC50BB8138ED2102FEBBF4A48D39C468C576B055EBC4008FF8317E544BF78AF36E021A5E1809F5032D84C7769EAC4A59D346B64957D7B715AEDA82089C44 +MD = 5691B6DDC859D4F7D9EE6608856CE01DA3BEFCB11DDB7424509AF449B12AE587 + +Len = 551 +Msg = 3D97DE13463FE4FBBCA43FA797A7594614DE028CFCB477033EEA9AA00FC7C7CC085B130639CF3AD64401EC1ADE15C7398BF115F4B33ACC6B9F2F20CCA6DB7F77828CCD633A +MD = 26DE72D25CF479225E41F66306AFAC044A4E47F4DE3C76D6C7B20E4865CA808F + +Len = 552 +Msg = ABC87763CAE1CA98BD8C5B82CABA54AC83286F87E9610128AE4DE68AC95DF5E329C360717BD349F26B872528492CA7C94C2C1E1EF56B74DBB65C2AC351981FDB31D06C77A4 +MD = 1E141A171CAB085252EA4C2F8F1F1087DD85A75AB3ACD0B3C28EAA5735D349AF + +Len = 553 +Msg = 37603DA843EF88DB2515EEF27405CC61410C4E2DA79B6C8606FE93343EFECF6180729350408F382031F9322EAEDDB85899997DFF332D029FA2EEAE0050B2DCDD25198F0F7300 +MD = 202FD91237AAB35CFF1C79E6D049428204E3F0660280343A190E7F7DF8DD2EBE + +Len = 554 +Msg = 3248B698D97B6F9D9EF74359134F24A653A66A989FB1E6DEA74E4D13C1843EBCBE5B8AF1629C181A095E1B3F4C2F1B84552F006ADE5765BF3EBB8C1F6FC2E6D234E14B193AC0 +MD = 63A1862285375946189BD698D3F4F2C368AD7BAED59E31D7D7CA0ED4147EE8C4 + +Len = 555 +Msg = 2680D25D09089F163BE9F8D1F5A08926B71FE579BD82A31CF3EB1039BDD5244D0D9F14649843AB97547F65B443C7F2337914C8A2395EAE93F0BF1C43D8C01EBFD58C955741C0 +MD = 58683F565E58B3C120F6FDC557104FF3FB092C5F15089C7021C22266246FB39D + +Len = 556 +Msg = EB31208EC2EB7695CA12D5DA41D70D247374D6877A4843E63A8812EF8518C0C2E0E224DDA708B88B9F958219E74CB5A7ADE195FAC3690DEBE41C0928C5DB54F8ECC6FF3248B0 +MD = 559744F0AECBDB5A411A58BA28A3BC4178BA030F2CA6E289921D00EEBB93029E + +Len = 557 +Msg = 757324619B2F5A81EF4126DA2B22E556FBBCAEB03D2D71AC77F8F08792DD8576960293EF62ADE524CDA00FAAD2D0FF33C60C001B352C29AFCBF0DD995B5085E3833B55C0C6A0 +MD = 72D118B741FCA015E5FACA5FFA80F64760F5661E648234D2A542C3B8815C3327 + +Len = 558 +Msg = 3F7727465659B9BC8379A1BCE9EA8636F07135ACFD75AE2AB86D96691B7797C10170E6EFFB1636608C18EF065872BDD8938567BD9E76F5ABEC4052C07221402C93401486C6B0 +MD = C2A98025F0D7A8EC1DBF20D0874FEC67721A3404C65FA93C773AB9B998727F38 + +Len = 559 +Msg = D02655C3BFB9521DA291885C9E448526B25864570ED209E33CE2B65BA737A717022A95CE93A719166B0D8BC9EF7E4AFF721DFB1C1730B70D9ACBA858E4A4A9359152921EC73A +MD = 75BC09581937F9E2D49BCBC38CC8B17B8DA1E922E29EC39FB59E6AB5F6C91A88 + +Len = 560 +Msg = 94F7CA8E1A54234C6D53CC734BB3D3150C8BA8C5F880EAB8D25FED13793A9701EBE320509286FD8E422E931D99C98DA4DF7E70AE447BAB8CFFD92382D8A77760A259FC4FBD72 +MD = EF763F22F359DD7F5B3FE6A745C423D6B641EC07BA5235232A0701510F74426E + +Len = 561 +Msg = CEFFB8673C1722594E925B0B9E7CFFE54861AFDAD2AE51528A507A25F26E19498EE305566788A05CDE16FD8F6C92F1049047F89CA1D46FEC489C745A12C79633F13C927DAE7380 +MD = 72AC517DF6D6AD825111ED7183D07D5F50B8ED13B36FA7DDB7AD31EAEAFA5C5E + +Len = 562 +Msg = 9C46E4954EB8286850B9AF257EDA31286625F8E935137E6F582B2930F2167BA25DA85C2C4949100CB391B214A097615CB8A9E8611A9D9F94D54ABC3865E1F28529C4FDCB16C900 +MD = 91F377193C2190A543C1E26D70BD9F095F4EC3649271A26B7BE96D3F7FF9DCFB + +Len = 563 +Msg = A56641438A5264B3DEA5635B9C9F308CC1DB42C882ACA9B6839C08618BA6E2D771CED4450698E2AB0C1C489BD69EB1D0A79F90A2B9BCC28230CF151F827A4D6762342869AB4D00 +MD = 98E2C8DDFF8ADC3639F6F81017F7B12A66294E89158447EA9A1A5EEB905C1B38 + +Len = 564 +Msg = C371B57FA3CBE85892E163BFA45D95F803686466FAB99259458ECC7FB465D25F2EF17189DAF7643468822AAE499FE5227986908032B68A8AFC299CB70339722652E6B8D7B75090 +MD = AAF0B14552C47969C88970C723E42F8E46F641946C8398EA9D6EDC92016EFA68 + +Len = 565 +Msg = 114EAE7CE0CF58F7FB56676C4936BD7B018CEA5C1B19F08AC785CF9CA1F034607BD30B574925B3DB0BCA5CC9C0F3D4909064CE15B637D38691FBA467438B51F0E02D723E45D3C0 +MD = 08098B1DCABAF55577394B7B3472787EAE2D8B8AE22633814CBCD5EADF8DC00E + +Len = 566 +Msg = BFD7C3C1B5D442B4AA3DDC298B95FEFF68212C64233AAC2319C630B2E4916911C0CC01399D3FE2F699A70403652B3FCB77601E0BEBB9832B50E33ECAF033E4F7AF9565C1B25874 +MD = 425F7BD36A0656BC59850F4A06B1640DAA5F3E18E13B1CD2D6E34AE52DC61740 + +Len = 567 +Msg = 02462D5F711B30301F0A39E0397651EF0FC444A701D8177A1E76BC77ADF9C461036EBDF678DD10C9C9F365457A07F885BE5660B4768D551281DB67EAA5283FB383A8702E637D40 +MD = 177FD5F0870DB4EFB6521F6C0E3C886B84CA9222374A86BAA5CA376B174ACB8A + +Len = 568 +Msg = 13BD2811F6ED2B6F04FF3895ACEED7BEF8DCD45EB121791BC194A0F806206BFFC3B9281C2B308B1A729CE008119DD3066E9378ACDCC50A98A82E20738800B6CDDBE5FE9694AD6D +MD = 6A769F93F255B078FE73AFF68F0422A279939920E4690B4AFF0E433CFA3D3DF3 + +Len = 569 +Msg = 1AA7751BB1AB38921AA754162F00E8DA55DD9A5959FB1B316D6F622A6E7D27D6640D4B2D13FB70B30B87AF3D5AD06A1A7746AAD25979AFE91925D28E1B585ABAB56FFD6E41268880 +MD = 7ACA33C9C9A381C6C0FBCD34EBFF49001D7FB85CB6809E9A8CC9DC5D32B379EE + +Len = 570 +Msg = CC592E8F00C441202D834185DB8B5B9441E1AD1024573260393AF6D69269B6414D5E5C2BE374C9A9DAC4425693ABA78C729308AB3E7DA6CA43B91A717FF0FDEA4EAA7612F229C780 +MD = 766F86D8CA1BB2A0AEB4291F6A5AE3BD6A78D799FE86375CCB4799CFDDBA3A4A + +Len = 571 +Msg = 18057027D18CD129DFB5584F87C48D8ECE475A366F33C62736932F55CD9ADE656B6D7F27EC182DC565B5FC6E3E125D4A0C5904A3666CD79F611562755C66D87EE6038B10C1E44F80 +MD = C1C5B1FD6EA1ECDEE387842353EFB97F5907B6924443C3150D6A0A398DB4E1CD + +Len = 572 +Msg = B3C5D348DA8B5AA4932E196713FD43A200B5095207CCEBF0F2F347A1C565C1F709231D8D7B3AE4E11EA4A71BF10C75FBF075D5C88E846D24C607D93A4992111D7AB637ACE577A700 +MD = 600F5861FB4DBF8C5F00ED6D00D6F91A67249813A1C09A72723596123BFEFE17 + +Len = 573 +Msg = 77E244AAE547DA970AC2F73B0AFF4D870EDCCA2E0EE14B1F6F2A8702E4B482162B12F67BFCE1F087A7F240C9D0CC0706991E63800822B2F948BA553503AF630F4C182A1FDE676F60 +MD = B753EDA92638C9F5E84C11ECD7CF3A05FB7CB45D0CF3F235E372AB3DEC45DC1C + +Len = 574 +Msg = D34964352D3F10A58861BCFD9E492E30FB3FBCBD1090532A83590EC4B56A52B2E9AFA17E9C2B803143AE63915754D4887CF98C5B8BB8A48AC5535EF72B75CDA7612931E71D9E9E6C +MD = B9EB858ED6EDE4936F3A6F14FE5CF9739DE0E6EF86C58DBAF7A1939739B4BAF1 + +Len = 575 +Msg = 5610326DF88C0154A99B962BDAFDC56A0206232EB7C2B30C40469D8011AF8F176AEC5A416A992C71A9F94E03E4F7BA079E4AF5174B7B0CE06369156D45F9385384D07CA55D837D10 +MD = 3AA1DEBC67B92F4344BF255224F942DA8C1C792F2DC17CAA7BA4EA42DBF40E71 + +Len = 576 +Msg = 1EED9CBA179A009EC2EC5508773DD305477CA117E6D569E66B5F64C6BC64801CE25A8424CE4A26D575B8A6FB10EAD3FD1992EDDDEEC2EBE7150DC98F63ADC3237EF57B91397AA8A7 +MD = C06DD4261638C44AFCB186F0AF5DE20EA53AA63316FBB71728F874FF3DACEB0D + +Len = 577 +Msg = E2A6C7C31424B9B1E391EC72D45A0758A41B7794E6161FE1B4EEEB2E9F345B45DB8B64097D0D2C09E3C3C5380822E62426DC169E94808B6E6802D27C067CF3A03BD1B2AD2B89483300 +MD = 3E53D442D745C0721603B77C6CF54C98168B53C26C9339BAD1C0F835C0ECEF93 + +Len = 578 +Msg = BFC9C513134AA3E5813C125CCF279F33FB95A36C540274ECAC1EEB43189B2A1299F6F76F4F381E3D33576AA4BDDED13148314779C5A84AFC52CBBB8B42346466D3ED126F0D4C466400 +MD = 4A80D28E9837CC55EB36E6EBE3A54F22C004943E5CAD2AC671F8EBFD72D4652D + +Len = 579 +Msg = 2A8E0C4A157E09AC3A83F7131C30599B3C8C8CB8D1FCABC4E9B606E265275C0680843CFDF1DF70AC5BAFD472F6A3AAEA93E2E51DDE78192D1D5313A79754926115AFA58B68D39DECA0 +MD = 38A8F164C804E136D1B6EC36C4AA152D7C5DE922CD420977AE7958228DAB9EC3 + +Len = 580 +Msg = 7F08ADFA726E42B95752387BD6248128D4E52706344AC7290314D9814356A121CB1EC7D7B018F0DB15457FBEEDEA5E1A1CCF627B164DF5A341B6E9AB23D6C79BFD9359578669B9C000 +MD = 07A3E0E09AFAEE8E78162FE8EF8B6C41096015509E657EC65E00B3B54A5CF52D + +Len = 581 +Msg = D0885BFD63E133FFDBDDFBA5DDABE302CCB292AD79C6CF2C848485446178472C123001A6C06245B0E7725B6C278D556E9444A6624EE3A612C27A194C76CF8197B275EFDD3042FC8600 +MD = 546132EB430032E441440816D357F51F5DE1F8602F9503A3C3FAA4A49A9B0CBC + +Len = 582 +Msg = DF98AAD16AB9EFA536176798654E6394668F576C9D6DEF29B6085FA29C9878966EFBE223E5F56D5BB69E8B27AC9B23F4D89A856EBA58EC5D20C7EAE6E58102BDD58C57EF843EB5D798 +MD = F2577791605939059C721CEB0C6AE605A3237A8D389F6841532A088FF0F496AF + +Len = 583 +Msg = 9881E0C17927FB375634460158644EA6549E3F866FEB6923A99E3548108AA4E2420CB8C280991BAF535E28047EAE07832D543278459E21156F90B913C1FF926316CC813DF101007912 +MD = 1F27183B9DCBC6EE3846721EF46A449F47679A217452D6C60202F30E76510A6F + +Len = 584 +Msg = BA5B67B5EC3A3FFAE2C19DD8176A2EF75C0CD903725D45C9CB7009A900C0B0CA7A2967A95AE68269A6DBF8466C7B6844A1D608AC661F7EFF00538E323DB5F2C644B78B2D48DE1A08AA +MD = B5D84B1809E83B5E75AA53BDEE79E3A97F3FE3A7D3162EBD4908240FF69131D8 + +Len = 585 +Msg = F116DE7433D03DC10339E3661D06EBC8AD264DBACD05614B09119970AE3A85FA80D8DBB23403FE2874A967F66732C1711C455E6F299111F5B0FA378519D7F25CF945BCE7B8668203FB80 +MD = 5C0246E423C71B8B63F5D756D486991B9206CF66F147F542E190B02BB0CC8F0C + +Len = 586 +Msg = CF33DD0DD4CDDB006109E02BA6CC6ACE8EA839DE2FC68A3357C1758EA1E2775E05019F12F2CAC5C2EF594D4F1DC26DE2F9543FEBA34E9F0475508EF848D6BEB4C26C2417BF1CC1419300 +MD = 215733339DD6565634817902A9E674FD379A95FE6DF0D80E5E5F0C6313D7203A + +Len = 587 +Msg = E32A1614AB569B1E5A897DECCB8D55CAF82CDAE61D0EDF09BF1AF52163F1E63668C4AB8E8A0CAE4C82E0E187BF5260CB9D2112211EA7C12AD08758EB8AEAF3258BFA07081D3038ADB760 +MD = 3AD5CF7080D5D794C995FD808D1EF910F406A9E455A6728BE02F1A93407E94C3 + +Len = 588 +Msg = 870615E5FA42425D15D4DDB1920D99BA17844FCC6741BFDB1238B907B1071E241A1FE9D6122C40B640056786D516DB3C5495793EC6BB3309BB66D53D623FF4A28620E6613BD39B51EEA0 +MD = E2D22C55C332DC805CEA8A759E82D8640859C6D49CB2C6C50066786420EADD5A + +Len = 589 +Msg = 9B1FEFB7B55DE30D70525169271683A21320D0E01C38CD630A79F36B15D05CE96B622C586F48F4251C948546760EA88D470F5BCEA84CEDADE74A0FA68A001F68C6BB1EEF8BDB6630A400 +MD = 94567EDE0801E5500EB0228BBB9DD8DB7C6805258C507D0396CA32A6647C7BD2 + +Len = 590 +Msg = 6BD0B9A20EE65C9C4E2B5ED2662D01876E76FD98283317C7941A6107D40F06EC88F6A3B235E073F7963F9D3DFD178226C6AE1C67FE00C2266FD608697EDADF07AB4F6C0303E82FBEA000 +MD = 634F3E7962690CF4CFDBD5083B8F2886EF9D340F6EB18CCFF71EF14A32412B7C + +Len = 591 +Msg = 43DDEFA4D3868E5C6671FF04BE2969549E9728D876A800879D84363EA77121371DCE33832E6092945E44CD5D8EB33ECE8F459342BD47A0A1D0BF165028119EECF77C154194E9E41106EA +MD = D338CA19B2DCCB0D96ACFA78121B771E26D8413D9DFA9CFB9706B55F1295A359 + +Len = 592 +Msg = 0EFA26AC5673167DCACAB860932ED612F65FF49B80FA9AE65465E5542CB62075DF1C5AE54FBA4DB807BE25B070033EFA223BDD5B1D3C94C6E1909C02B620D4B1B3A6C9FED24D70749604 +MD = CAD7ABB5BBA5905B5181DD2DBC4E68CFD01BA8659F21C8290D3F835C1A68BBE5 + +Len = 593 +Msg = 89ED3A52A979EEC4BBD0191089043B7DD1475DB503E1B9CBBED58C46D81C9493F15A9832411C0B5455696B1142945CA022B4845299ED17B3EB276DB83DA3953433BEB873DFC1152DC59A00 +MD = 600717428818CADC978EEF42EBE4183FCEF42F03A834ABF2DB4E97C5C7727DF2 + +Len = 594 +Msg = D6D1EF350BCF8029CC20400775A57090045D7D9FE4D51C52B4EFADE7E69FD952CDDB66FCEA59DDA899A6578B0E4C115305895B909241D4D1ABF2A4DCD97CAAE0E22563B7C6A61009C8F040 +MD = 6D3EFFB1A4103412554C8D5B8031416B0A83242A0E804D70986B1FEB6DA6AF94 + +Len = 595 +Msg = F535C15710C29512FEA5E1388C742D3D181C5F52EC4FB9EABCE691125317D7FC5C4098435C0FE6BC44323B8607A7CF9EE56DAEB7048939940DA2DA4AFC1CE8652AFF60C53F72198E2902E0 +MD = 2EE5BE1F53D870E8B1432895356618AA5CEB64B8A9D8A09F14179E3EC6A97AC9 + +Len = 596 +Msg = 4606C6B2B2E9EB8AEF7D956640FAC17D6A2FCBC407B84D4B4C7D852B2121F08CED0AA8544EB2DBDC0AFABEA2CA0514C744637A745089E3B534EDB8E5D9E9EE7DEC904CCF7DF45365F8E020 +MD = A11DEC7E8F9CBE2981D9485B9B70204B492998F626E908003CB09EA17C6DF970 + +Len = 597 +Msg = D7AA2C9A3EF05452042FF75509A59521200DC3A76B77F067AAFFE475D408E055768ED33FF1B95572942BE792868D390700E82D2217DA9EDCD561254325EC98B3F85A24063F25F51E149110 +MD = C5B79A16870268508A6F2CA006F79D31AA9EE223C13D1EB91025D07C6E4877AA + +Len = 598 +Msg = 6D812DBC3315206E516E52D4E810CB0D274DDB5586F192066645B6B7E7022F36787CFD6E98E553FCF15BF3F1C8C07856C4D9D44D9715ACD92DD02CD68B6C95A5322F8938F2654FEC102344 +MD = 3A4AFBC8739B665E5E444DC0C0FF8C90999EC4C8CC9A8E4EA10436795C057372 + +Len = 599 +Msg = B22FD723C48AE0A1D2B6440775FE49A44720D30E36F1D8D07CB5C49A79BF432D62B95F1A13C6D51D35B6B8AF12517CCFBAFE0691567BC337338312AD24066DB73731CBE66F49C76ACA085E +MD = 60F6372359E2E327C3D42C510D7AB6693EB15CC8D80A7F72A563ECF126389657 + +Len = 600 +Msg = BBFD933D1FD7BF594AC7F435277DC17D8D5A5B8E4D13D96D2F64E771ABBD51A5A8AEA741BECCBDDB177BCEA05243EBD003CFDEAE877CCA4DA94605B67691919D8B033F77D384CA01593C1B +MD = 83CA09C1F418B5DAD0A7F64A904A2E07C3314F7D02D92622F8F4674BC1F6AA3D + +Len = 601 +Msg = 0C86E4810BA7A10163172A8D718D80CF20F519C4191E8080B9FF3A6A21ECB913A14A05F04576BB95E38676296D708D74CD30CFF86D103EE2A79FCD6E39A09912D0CF7671580E0644DC74C600 +MD = A40CDA7EB252867A874654BF2CCEA292BB4CC60289474D0EAA67FBEAAF1A5D10 + +Len = 602 +Msg = 869BEAC3E5B5A3FE99018564592A004B396DAC8DE9F47AC01B5870FEAC4C0371D7EA84D4AB8E199959B423FE069DE86273EC4A73DC3D28BA66FAF7E80A26AC6B3525E530C03A2E2E30992980 +MD = 1B794A840185816CA0C936EA92C3CE6D52C5233559962A520B9C237E5A1CE990 + +Len = 603 +Msg = CB2A977A3760DF60DDA2EC3A24865490299D27165F4497518B1F3471C1BD73E1FAFD2CE0DEF129B02BF6EC9C08D903C3A544F695FBDE5945C23975B0AC0CDD513810CAC6A998251BCB3E6DE0 +MD = 1C9E6AB0F31C8BDBBD1395C2D17580DBAE602AC79284BE19F8A6B5B3CCCA63EC + +Len = 604 +Msg = 389B167E0A47A88EFA81870A0E8D8D86365B57C7CC3D77E0120685FAB3DB28319348101E1453B56F671D7E92D50B7941AEB88E493A1E1D9D06894DB8CE83C6F57C218A9652A5302BFFBE32A0 +MD = 09A9B84289DA79A121C7E641C14EE9EE55448001DC87D8B7A5CCAF01FFA0E572 + +Len = 605 +Msg = E5E15235A5E5787BA52BA4BF335C297D36A96B999F230942B6A8FF1DC4A64F9917C6D564E27EA229938BEA691F70F334011B8C03B778E616FBE1C220B1564F3519144FF35C73AE1E98C4DA28 +MD = 2A7D12BF400FD7EB3E6558413AD0FBAAE90F4201174172373D208B5013D2DEB5 + +Len = 606 +Msg = 1A0F8F926C0C9D4E4CC4E1E5F130DE44EDB8544421AD3BFD80E28D092E2C878EBDDFC62F484BC30B3C93FABCC924A5B9D3A7FA227609D921BE26ECB46D112CBE5C5F91B22F54CAD85EBC2578 +MD = AD3E0982D0C9BCCF635002A2BBD02890F9A0EB0BA0E93B4EF0A3EC95608AB784 + +Len = 607 +Msg = 6299776218D85291AD65FC0E7782D3D03A6FB17BBD72F3C93A210BC49956E3AFD3BD048B49681300DB7676337271DFB46C22AD929DA6365442ED785671FCF2BD549832614270DE119B086EC0 +MD = 0D50A0FFA5CF875560FD0736E8AF5B0D074323F45C8BDD581E7E9EAEB2082898 + +Len = 608 +Msg = 90078999FD3C35B8AFBF4066CBDE335891365F0FC75C1286CDD88FA51FAB94F9B8DEF7C9AC582A5DBCD95817AFB7D1B48F63704E19C2BAA4DF347F48D4A6D603013C23F1E9611D595EBAC37C +MD = 330DE3EE16AEF6711461A994863EED47AF71B362D4C2F243534EF432F63A091A + +Len = 609 +Msg = 32B722648C5D5A9558B328581F00BE0473ACCB994A92533904E7691A83C179D22A027CA97AE8FD09DD5503A307D23F03DD9979AEA237ADC9D76ACBADBB1C482D5FB3023AA194ACC84D4428C700 +MD = 8BB648478E2498DFC55DCA7F01E6F469573AA2E7FC312ED550F4606C9C2A93AC + +Len = 610 +Msg = 3C33B1AF42292D4BB3E86744DB23DFA39914FB81885A564A52ABCA01215D552F6CA3BF56F201086232DC24EDD0B7683EB0F59E9FA96AB1578F8AF44AF903AD496E11B4766CEF3460979CD83140 +MD = 35AA015A033C5B6F67BC4B643D59396D90EE1DE6E19907674449671C699348FF + +Len = 611 +Msg = 1A3051F42AB45179AD429B1616BFC686CBD15FF02D200FDAFB1F89A38CCFEB6EBF00B30179CF0BEF176A2D4CA63CAC0FDDE1A50BE122F408BACE72EEC6320F98AF6ACA4AFC79185B518FD8ECC0 +MD = 520BFFB9A0B672C21691A40014447602C736538CB26A70CEEB64019E0208A647 + +Len = 612 +Msg = CD041C63D5330432294D0926228B1EAF6D234BCA839CF4C9EC8C823415FC34450214AFD2E4975045E6E933E8BF9EAF52A998EA879A06954488E95D0A3359F601EA5401201DB5FD8B3B01EB86B0 +MD = F05945E331EAF0B155A7E3C2E48115337C1498E11FAB2D6B3D07EFD2BD6B8C1D + +Len = 613 +Msg = B88574119E0E2765562879FE7171DFAA8FDD492AE7F4D9DF4B858AFEFD95C55BBA259267878FCA3BDFA6B1BB23189BFD81207CCBC50482E830704FA2F3EF5362A0DDC6DACA3A74413E78F97868 +MD = 1A0AC0B2E3BE89F88782BE3C4EC32304255D5FD4DA7F0171A249C37BD1270347 + +Len = 614 +Msg = C2DC8467DDE39EE6896D915A7B4ED9F3D389FDE2D19D176857891AFE62E7FC6C3070AEAC3CFBB07BF32EA8978B689CA890A083644E54C4AB950DE65AC6270E2C8CACB766C8C494818BBEB09068 +MD = D723976E4A1611939B5F3B745F9012652BD95AF3D2C835720BFBC4108942EB11 + +Len = 615 +Msg = 03DC684CAF8ADF39F716F19E4E899E8CFD8CE1F75D01FE529A85A2B9736A00C7AE6D235E48C7CFF83B08A274E8A1F71142781A40132429808096A1E442EE6A3F76DFD5EDCE623DBAE00F7AC3F6 +MD = 638ABFE5BFF4B361278386DC57FDE4D14FF382F03198F976920BDCEE0EA5FE4E + +Len = 616 +Msg = 64105ECA863515C20E7CFBAA0A0B8809046164F374D691CDBD6508AAABC1819F9AC84B52BAFC1B0FE7CDDBC554B608C01C8904C669D8DB316A0953A4C68ECE324EC5A49FFDB59A1BD6A292AA0E +MD = B5675197E49B357218F7118CD15EE773B39BD59B224D9A45CA71C6E371D938F1 + +Len = 617 +Msg = 9A53A66C40C574D09FB5CC46D7BBBAF18D392FAD22FDA037E45AC895FE32A1B35691AB42E697E64F27239BCD0B3B9929FC4A2C8D730AC3DF39AEB066282E1F7B73984F0BBF2BE4EC40AE8B194280 +MD = 5BAF7B51F625AD6D46DF6468610CC693FBF136FC117595CF9F213B9D2F44B087 + +Len = 618 +Msg = 2ACF3BA8177AF3BF39D6C75B4ADBFA997FD201D5C489260AFFFA0ABB9E4908417DE5B29B005AA277A82F8BC6153AB7AF6A9B418357F2DE6D9AC4D77713695706C99425DFD70586D29AF60863F0C0 +MD = 3341C9A1F2EEF69FD05BBF4EE191CD405FAAA2BCEAEADE52F9D98E2FD350B74C + +Len = 619 +Msg = 5C38BA82BFF584A77A0DA5635C2FC3B3E82E43A2BE5C338215735A06CB679228A5AE18853909E64561DD2F5600E5AC9C5456DBC9F6CD7B3EFC2F925BF4412B3B82148C2F3091B259283BEC309F80 +MD = 82DA55EABCC6FA918EA2D86A6E481A7DE2CBD9D55FBDB4796382E62FFA863922 + +Len = 620 +Msg = 9E75EB68CA9AC9FB4F4AEEC3805E3C4C15DA0DEFDC9678F5062509BE84B1BC0345E25E99C1D2B7E2399FEEFC39E84C3042FBC7CE27D702547D6648D560FAC8268114A96E079BF4721D53F92E16B0 +MD = F272161B313C3A09A98F2E0BB1CEFAC9AF55C4C740336F6E19C1B8CEDCC1BB3B + +Len = 621 +Msg = D4565A61C040688B23AE1AD10FE5934D776ABEC6E718E91EFBABF51F2DF9AA572A5427048D98D1E7813AC854FB348081B0332052127FDCEA10D3F40FC924C07A4B41EA70342BCFA4CB79EC8B8020 +MD = BE8CAE49FAB03A8E0AAD0A7FF3E27E81A1E7221A9B3D0171166B2660D8AAFE93 + +Len = 622 +Msg = 83AC1F77EC3B31443B117F2936E1FBB7F5D635CD84E0178B16302D66D80923214FFBE32AD36CDE4E2B62CB7EA91DCA5F0DD9AAD99B50B984F00F5CF2C617BEF6BAD0605C2DE03641AB6AD3CACDEC +MD = 9E05D0F774A402CD96F01CA747147E96CC2B56E153BC1AF9F7B59C5AF2821116 + +Len = 623 +Msg = D5F52D229676FA418C0F976AE854592C7AAB09267816B5589E10C60C6DB702D2C0590983AC0FCB70759C4A97D61F50B4F992666C4B4935B6409EB37BD4890B72BDFC46B3738DA166510F7F01C92A +MD = E035C3A4C8D9B88FA3DE507E0F22CAD03A2D26934834B8775FDE8AEB1D5D82E0 + +Len = 624 +Msg = D4654BE288B9F3B711C2D02015978A8CC57471D5680A092AA534F7372C71CEAAB725A383C4FCF4D8DEAA57FCA3CE056F312961ECCF9B86F14981BA5BED6AB5B4498E1F6C82C6CAE6FC14845B3C8A +MD = CD9038C1066A59990DF5752107B066EEBBE672CBCA0F60D687D03A9D821934BE + +Len = 625 +Msg = 588A1024CC2DF536C93ECB5EAAF9CAA4BBFAD79EEAFFB5B05468658C46F14BEFB47A2D97F29E462C71FBB64686F2E613AA04D6ABF053284D4BCA9CF6B57F0C8DD0B718423E24CA9347FE4F5CE41380 +MD = E409836BB4DD0485B3D659788F4790D59E3AC8D8DDAC660DA8F4EBA6218E945F + +Len = 626 +Msg = A539AAF94509CFBC8459CE5A4E95CA3D6875B19AC3B119FBB08DCBE553BC83457308D3F413D4362A6E74C35492B1DFFA5D7185BFCA34E85B4B3EA30EC0108A3CA82E55305EF5CD71BEED761D1F5540 +MD = BE561B75E8F9BC3400CC57BA34EA1356449B3C78887343CFE0B923441A008D96 + +Len = 627 +Msg = DD82F62080CB62E34FF4081376030A1306AE226BA181413E0CCE7BD1CBCF83EB09665F4F74176FEED3FA9619D391947F5169330409C3B06904E01E7B3502C88693605EDA211BF315D0106FA3968E00 +MD = 9CCC1D16D3873F913E72937DFF96BB05ADC8472B21123F8A06FC27CB270EDA20 + +Len = 628 +Msg = 7DD4B776E7A5CEF671F43948269DDB104F0A5CC315F08FEEB0749D79F626F4E55F4213EC30ACC38B9F78E44716D858A785BD938E8FCF57F8FF2B5BA15407A79A69A83BD5DA69B379C64EA72CB9D5A0 +MD = FB2B2A49D5F2459E59F42C805664123942E467EC24D83752964CF72FB2D41323 + +Len = 629 +Msg = 9AE70DC8965C2FCB43D79F2A2EEAD4C00A8C19D565EF8B125664633F3FA786F3BFA7DE1372FE84764314A480B8E04A71BB00A701795B1C7A96B7F22A3ED7E86DF8487979B6525A66A10C4C9B63AC50 +MD = 3C6E0198FADA11E379EFDA5EECFDD70B775013EEDFC44E444490D04ECF604B5C + +Len = 630 +Msg = B21B8C40CF1390EA0392F145E9C7C4FB58B2CD2D8C812D0A2839BA2128A1088068B5F17B38324AEBCA2FF9AF59E8AF325948830FD73D1D8EC98AFDEF4D50CF95F712A0874976DA3C0F77202253356C +MD = DAFD84BF95F88A1C5C7854A6FDADCB782F8446D29C42C5E5084A5ECD6D9B33FD + +Len = 631 +Msg = D688AB44EB8723AA2B0F45736F3DF3B5C6D6B5C316E6C182FA8A45AB2D469D68F6C82C81C999B1D5BBFF731FBB65113FD70327182307C07FBB74F97BE8196C183B0C860881FE75DBD9B3166BBFFC24 +MD = DA3B6E006B6D6CF425F22D66DB5EB035CE2485EF5C45B562CE48CD9C53FE63A5 + +Len = 632 +Msg = 12D9394888305AC96E65F2BF0E1B18C29C90FE9D714DD59F651F52B88B3008C588435548066EA2FC4C101118C91F32556224A540DE6EFDDBCA296EF1FB00341F5B01FECFC146BDB251B3BDAD556CD2 +MD = D3172CA263AFF2B9DB6FB13337F2543C5AF51151801A76194012F710306C14F6 + +Len = 633 +Msg = 093FC95304175C45118A6EF8EAF0A58A9D45C6326D6259398D8C6C88567AC9B12C6CDB0B80974D3C104C389E3D721F528ED51B7D8B110FDD955EDF4E13B4883142BB23F7AFB99E5B899D92D5563A6480 +MD = 0ED96D7CBB8CFBA97B49EA62466A3FF5F2F51AD04F4CB9DF9D2D84866583866A + +Len = 634 +Msg = 8AD86DCD3D4EEE9F1B28800E8E6E66B8FA0594C285B67765EBB4035F96AC4155A5F21A61DF4D25441B3265A411ABE9BB5D4ED7FE4D6037D49F2406560AF5E46483C8E1694ABE8A4CDCADED44FD8ED740 +MD = F18369BAF5510D9BFE3BD98943EAEF3E4513A8CB61C3E57BD9ADEA811C88675A + +Len = 635 +Msg = F72D42FD9BE95CF4E1580CFC269747F172F3C17ECC0545DFDBA77C2E5C9DEFB98838C539DAFCD912F39D1D7C126C93BDB2F08293603533DF36430AD72EF419581B011B64224933D0A8BD9DA2A4AE9E00 +MD = 05BF3FC6E7590262671FB166B660A0BB4AECCD6BD318736DC85CAB1ABFD2578B + +Len = 636 +Msg = 4FAD29DB36DD7FD0D7556D77D422DC0AD547CD156321A0C0A988662F3A9919C408ACF3049CDFC2F87309D553CC7B84F3B5ED89DCC6F1F707E0009C6D7E93B7F8089CD57AD9C2A4CEE97FAD6425C93420 +MD = 7723F9F0A4162A467A9CE1054D1E3E334C0A51D0EF97D249577D8864EAC27EFB + +Len = 637 +Msg = FA18047AF5A407B03BDE3FD0554363C2B95E36122B83FAFAF0E9EE933E6B8FC30344E34B7224F4A13A3FB3D1E15B4EFEA5AC8D8BC8DC3F59BDE305E7F337B77830674EB0DFE041F2B6F18F01CD59DC38 +MD = 6A3054142C3E3BE22C385D9F8A1019C9CB6A2FB1DA7B7514939F2445324297CC + +Len = 638 +Msg = 37E3823B27C5A47D59F9A801CB773C72DC1B6C04621AAC60D7ACE9590D0A202B2308B07BF1AC28E6E015B873C95B0143CF6B83805D6BC9EE186E8A75404642D15901334E09D731C02BCA748A33C965FC +MD = B0DF5900C221ED3F65FBF9348DA4B6C81E105445DEA488CE24CF2A7BEB47AA34 + +Len = 639 +Msg = 99A25B5CDE96655B4F29BDE8A691DC8D0BF9AAAEBED84B55E8BB044CEAA98FFD72C6F0B98AC4222FEAB773F9175796047FAD484F18F33A72AEE87276957F3BCF5ABC256DE0E14157C4903174823657C2 +MD = 65BDE4D923C1FF55E024E8455407A617671E39F5A29329E798F4109661184801 + +Len = 640 +Msg = 871A0D7A5F36C3DA1DFCE57ACD8AB8487C274FAD336BC137EBD6FF4658B547C1DCFAB65F037AA58F35EF16AFF4ABE77BA61F65826F7BE681B5B6D5A1EA8085E2AE9CD5CF0991878A311B549A6D6AF230 +MD = 9E3D4BCF580EECE39BCF13E5716E5BB8F5E8C3FC3723F66246F836D8DB1238F1 + +Len = 641 +Msg = EE9AC0C239D9644C82660B488FA2598C3B288A01C84608EE555AC027C01FDBB614E18D5C1B3036E88115B5BD42B465526B92CB94776634377290333571F8D28518EA26F37DF8DE37ABE87DA2E55BD2DF80 +MD = 194534DF958781BAADDE7FBE36658C57D3FBB386AD15130FDB22558EFB4D634C + +Len = 642 +Msg = 10D86540DCDEEF9B16EF516608D711500ED8F8E3F4122224993B3EFF37053DA602A9378889058954EF5B0BC3BF55DA2C88C881C583FEDAC724E1259E62CFC9EA973CE0F3FD2F9B92A19773A5312D493F00 +MD = 1E58863DD20BECEF2B2420976331FE4B0053D10795E4776BC3B16DBDC487A60E + +Len = 643 +Msg = ED84FA0338D35196086E1116FA0BC0B31790D4AECCAB9AB51B42AB8AF76A6E97B284ED9D0321E891AA6E42C906325C4CD3379188F4400DB8BB2FD7526896B3DDFC733E19AD2C8BD0269872DF02D8000A40 +MD = D7CFBACDAD0CDAF7F779D0CF1C1F678399DD1FA6DCF501D28B047F8C5941CA67 + +Len = 644 +Msg = 47A28CBEB8ECC3BE04B9112668271CC7A16C1015118CA72257EA0189D994914452FE7C5C66D83E10607DE3F144B04F9DF70003087237B55320AD925BC02BE3CD4BE9E9664A7C601DA89C1311565E03F430 +MD = 66A0DE4F2D33E76628D0B684DF025ECD45CF716D6F13881C143F593D98B91730 + +Len = 645 +Msg = 4EF91000C81FCECDD34020116B25E51C00871C104BDE349969BDF56A5BA844B4B78D7CD167CACC46693E0EBE9F72FF4ED3F3B4F03D2CBD26E9C0FB2BC422F84F35F248F4AF366F952E2D98B8441DD13A80 +MD = 79FAB51B387D4CC1185DA33757574982496246673792F0D3F90EB46B6367140D + +Len = 646 +Msg = D8C5BA1029D56F569D9ECEFB0E4556298B474A8014FC1EBEAC8F4B61A1326CA2D40ECD50A5A15C9EAAA17253434601F548F4F380D843A53FFD2697A845DFF2E2237AC7ACD9056894E5E35E563CB02769A0 +MD = AB93840FB1683BCFF27C16E7D0284EC5F5199AE39600BDED44A1BE171CC1ED00 + +Len = 647 +Msg = 3A974442BE9FBC1F4321AD311F3B7D26537CCF129655F16EBBE11D6271C9F30001E910CFFD71EBF57794C5E07A9BC228CC2E93B0BC56A17F6CB49EDDAF29DDC1F83E68EDD1A21B84AC5BA1FC5834022C08 +MD = 143601D6DEE9232E5AA78C2AC6E70CB976ED675D69C5ACB8B2F7615BCFF4098F + +Len = 648 +Msg = E90B4FFEF4D457BC7711FF4AA72231CA25AF6B2E206F8BF859D8758B89A7CD36105DB2538D06DA83BAD5F663BA11A5F6F61F236FD5F8D53C5E89F183A3CEC615B50C7C681E773D109FF7491B5CC22296C5 +MD = EDC2D3B49C85B8DD75F7B5128DA04CD76BF4878779A0077AF3F1D7FB44F18931 + +Len = 649 +Msg = 291A175AA79A73524CC5A8D1324E068AAA6E2A3CAA43AD44216BC1D94580A4E8997EDF665A8E2142D63FDB55C005AB6B1D81C695C1460BE418F0C2122B4FBA09CD381ADD1B8FE1C646FD03784E246437AE00 +MD = 55951D5C9D7EEB80AD66285790932E7E2A92389B404AB82485CF0CE47EAB2398 + +Len = 650 +Msg = ECA7ADB20C7BD746B39A1A1B4EF9C1F319403E601D6B282FFB2DC6C01A83E6C01A01BFC72AFEED867B5BDB8FDB2987105CDE36F38BBD7CBB6A185AF91CB3F3592FC20BE27B0C277D6D398C21530B333B6100 +MD = 1F97C53D9218A8E040D1CCD26D1506718FD485E08FAA8D782DD6E398A8657631 + +Len = 651 +Msg = 324C69CBCA2A5B8B42E1DFEFB2D7290D5871F3442CA554B5D34227F06A732DA857C4EA2BE0E8D86299A70BF0E754A06512D8C9ED4232339BF6E338B89CD7F18848B81CEFA8431ACC2E0941D3FBA7F17F8540 +MD = A7C14BA263315F83A45C77A2355ACB816186B2B56A9C5208EF0854659321ACF9 + +Len = 652 +Msg = E34B1ED9CF859DF804A8F42B71E68C2DE6A3349EEB87B450D350BC2F79868748E71C44E8D4D41BD3A770E521DE7AA98C430910212E294AEEC65C0E7762C7CD9F03A2C61AFF873C28A9DB3EEAFB2C09E24F90 +MD = 1F6AE878AFF74DC102B2ABC28FE7D843AF457DD8E2808947A7A5E1A88B9C5A79 + +Len = 653 +Msg = B19701F0F71E36A61B27E9DEF9A7062719A497BFF82CCF01E076E8C08F94B1F6C67473DC909B192067BF6481B44A44FE77340C4EB7FEC31B2EA97A4341D09E31EFC00C48D11FE125DA151B6C7635094EEE30 +MD = 62FF7AF711CDCC3812D48771949C89E7856FBB2C11AC821955897DB635A0E575 + +Len = 654 +Msg = C700B40AA21E2C2FB143377421FB0E5C4C665E529D8C6C6E5A4DCB0B388B5726926D41A9A336E6AD38CC3F239CC85DE38DC221A4ECD281B4E271D90BF24A1FE943A6A5A637C36B48424FE6079C1F2C2D7878 +MD = 589C42E8B575886235BEBD048777E6A1A3ED1E6F8F5FBB3F46665AF475E9FED5 + +Len = 655 +Msg = F2224C30809A42D86701D95473C9DA3AAC8324D8D59AA8F75BF8E5A1420130BC971499725FFC56D1047F5987620492F383F477CDBF98EF01DB50F1FC0A7B3D9BD20C31ACFFBF60FB18E9962896B2E0431466 +MD = 168D0D3BF06651F72413E794B859493D94B92E4F4A7D6516E46F74EA40EEF083 + +Len = 656 +Msg = E728DE62D75856500C4C77A428612CD804F30C3F10D36FB219C5CA0AA30726AB190E5F3F279E0733D77E7267C17BE27D21650A9A4D1E32F649627638DBADA9702C7CA303269ED14014B2F3CF8B894EAC8554 +MD = 80DCE7F04DD6AC17CE709B56CF6EA6C0A57190649BB187B5E6D95FA18100C7AC + +Len = 657 +Msg = CEE8685B3D95B231028587AC25C7E1790A7EAE52A5BADDF63C44DBDAD15DED0EE60708BCF52594F2FFE21BCC6849558A06770559A409450E6C87917D447D53D321EFB737668072DBB86B4A57C2CD4E5B3EDE80 +MD = 77DAAAAF223AD1FADB80EB7AD5C278DEABF416E96C341D29B37B9A84DB009CC2 + +Len = 658 +Msg = 0B813C3BB65702538E6A0B953C9D272DD738817C86FB21A6DABAA13CA63E7F7A92F39036E08A68886EF8D495D6C2956125B4AF181B13BB41C89E83CC8B6E9CBA159CCB92C755E56CE1C3458DAC38718652C440 +MD = 6A462E87BB5060D4F1F01B278B3E0787623F02D3295DF42A5F7FE529868A8D3E + +Len = 659 +Msg = DDA54A9794F7FD0B7DBBA54A8341460FA46A067BA59EB7276D721F5182B59FA17F3DAB0015776D8BA29CF88BA64F6629B0FD0847FE2A86699CBB1EEB441AA17BC9070B432CCEA7B81060F742CCB4EBFE409260 +MD = 281279A865FAB54689F6E8689CB63C6786DD2837D610AA4F84A610C77728DBDC + +Len = 660 +Msg = D71B21EDC24E6FAF788F909BF9015775BE75EF9FD9C179E9C9C8281813055A1627E1604C35BBD465FF7D30FBCE70ADCD6F17F11E786FA85996AE178532531A5BC68DEC364647D2F4453AA7881E232563283D20 +MD = D0F9C72925390FF3A0596BE1654C03751883173E8B94D34608B7D37ACEEB7DF9 + +Len = 661 +Msg = FBFD53BCB158FA9DB2EAE0AA165B704ADA66AD28D5FAD0AAF4F075EBE04F295D5D4F69CC2936881FCDBEDDD48D48A6F3F0FDF1586382F9B97DE28CD225364D2EC0CF872AE691B76F10C7622B1409F1D4C1C648 +MD = 87BFDCBFE4D00D7D786EC3BD6EE4275B73D4A843EC8AC0DAC6419F5A1F712F0B + +Len = 662 +Msg = 7E767921A14D35F1662B628F4A3F9E285F3F165316128AA84E06F032A0003A445B6C1816CAFFB61D7318D249C9179A27BA6F758103E9D82F3D1F7AE5726D485270AEA9BB40E9E11831D9DC4ABE6089FEAA6960 +MD = 48F52837EEFB6E6294046118C4F72438ED9185003344C71A8DF1330B72649EC8 + +Len = 663 +Msg = 020B34BA7071093BA752B2913F9774C29204D00A137ECEF964F4B05DCCDE457837E0E724431F606E75E3C14B441E9F2C53C7504F5838C57400BA593BC59E74E4E923EF0CF44D734C07A20C2DECB1DCA82444AC +MD = DB726786CD584FC23E5EA10BE99AA538AEFA83E210C5EC902EF903AE95736BBE + +Len = 664 +Msg = 6348F229E7B1DF3B770C77544E5166E081850FA1C6C88169DB74C76E42EB983FACB276AD6A0D1FA7B50D3E3B6FCD799EC97470920A7ABED47D288FF883E24CA21C7F8016B93BB9B9E078BDB9703D2B781B616E +MD = 49BBD5435D2706F85FE77B84A5FA15DDD8259E5D2C20FB947F139373E5C86121 + +Len = 665 +Msg = 5332DDDD7949110448AADF3FF60CC30D6CA83E32C49FAFF9625C3B39E80BB94AB82D9288B85A5D4315DF92FB9A8D1F6643C2DA0FAD11F62411899714FF8688BBACF01915598C259F5301EEF92F9A2CD965D43A00 +MD = BAC2A71BCCAEB34B9FBC1B675A638B51E7ABCE6257218F3A4E30901030CE0720 + +Len = 666 +Msg = A90A69E0B616278A1EA45ABFB27876514B9A94C1E1E24C4C22A47DB8569DF9FC64820C5A46E8762ABE56C095AAA1F5E97509F16BE71C437E8965BA7395CD82F6566B6B4CCD2595A9326151716A2041D97419CA80 +MD = 02E59BE9E4B9E57FA783D9F1F5DEC0FCD215E911BF922BAD7AAAB2830746744B + +Len = 667 +Msg = A8E6EA7B074CDFB1983B864345B26C1C51B6799399092F146E5A83F68544D139B4DCF355C18563D5924106AED6135E8789DDA606A264B9F6EF059E009BB6D9797F56B307CEACA7330B103FA36A066B07D5FAFF80 +MD = 67EA4D958DB562A79DF556D58DBE5481BDECCA7CFD79C1B384439D0C5A46D19F + +Len = 668 +Msg = DE6F56BE8FD2622BF9A9D72E126BF9E6C709B7DE2DF49F025D3A54335ACEA3913491EE0A8FE4B511BAF9B0BDF907066E4E70B8165B5E7B173F9D8F491248379AC2E0139A2435EAE5B53AF8B9BF974E02E68B1530 +MD = C21DC75D435E77AD9EC690C486DF6F8A495E82F1921FDFEABCF29116245D94D2 + +Len = 669 +Msg = 183111D07A16E338EDB2BED4EBFFE453C900976F33ACF6D521F014B98EC4BCDBB606AC70CB557CA17E0C02CE8395DB05611100B0A3DE4861FC0510CE734D2718E9A2C01940DBDBBA806BAD0B5BB3B13DF37C41F0 +MD = 2D9A461D24EEAFCFEF1EF58EA5C9EEE090819266EB3D77F9020596B62AFA5281 + +Len = 670 +Msg = 05CF7BC0F43F7DD750F7B238624157941F0C26F990D967C1A9A6B1713E090E790D574206DC47F2C61D570F1641A0C6F240269E9F1F1754E4AECC734BB7F55566135504A94B03F775860E4ABB0E7ED6ABDC275FA8 +MD = 0905CBBC7728871AB9A1CED4A2BC8D34F4FF47E94BEDE87172616D2A784256F8 + +Len = 671 +Msg = 39FDF47FD4BA466DDCC6CACB1D4A1941A67AA2985B8832B79A194CC31AA9C308FDAE7A2393621C14836A4BD32A2D75C0A0F94D8F6DAD905565D8F437438D080628809212621BEC1051527B9CA217545BF35FBE8C +MD = 0746C6745787EE183F160599BA5AA96045081056EBD4C78D7522B8B2BCCF5D16 + +Len = 672 +Msg = 4B127FDE5DE733A1680C2790363627E63AC8A3F1B4707D982CAEA258655D9BF18F89AFE54127482BA01E08845594B671306A025C9A5C5B6F93B0A39522DC877437BE5C2436CBF300CE7AB6747934FCFC30AEAAF6 +MD = 6B6C11F9731D60789D713DAF53D2EB10AB9CCF15430EA5D1249BE06EDFE2BFF6 + +Len = 673 +Msg = C65513559AFE979CF98A11ED2BA28093FD980E4827D7AA88D4EC8509A0621B4DE6ACD0313E0DCD79CB791914D6BDA9E0DFDA44424FFBD29F0BA7824A37605AFF32A9AF813B38293174B929BD836B19108B206B5800 +MD = 35EC2E54F944B72A95CC84902D42BE4516CE3A038CAB674590869794D0CB9724 + +Len = 674 +Msg = 57EAD014B8ACC155958D62563E9F51F709D858379D699AF657C67DA30378AA7916AF2DFFA626EA24019F4ADEA5DD2F776FA49191673B08C804C2396292F82B9A36C90E5E0498370A221111EE58F7D2137B96D58740 +MD = 2225EBBE1B13F6D742DD44289EC6ED6E5D24263EEE6F25A2AA5830C6E09B7B2D + +Len = 675 +Msg = 815D4AD9D572A2DF8656281CAEE841AE46F8FD3AE24EE2FE148929C570CDB3E7D0B08FC26F42B5636A3ECE524355E6FE28F019F139839C2BBC79F18C765F8ECD7EB139DB97816EFB832A09534C07FA18DD68033960 +MD = CC23BCAF812DFD4A85AAF43B3B3B3C36C2F1CEAA86C62246953822F32E7D2016 + +Len = 676 +Msg = 6D5BDBEC01986DCE1000A7EE1968BA9E6BEE72560C230F33F5DD758B593AA482CE01730B4234E7D9E8A211B9602BAE5C918971B816604BDFA382EA6593D27AAA40628358BFA92DDD44E84F4714FC41AF834761E4D0 +MD = 126101315A22D767B40A156A2E0BFD45DC34830D57F4AB66B7ADA5AEBE645BF4 + +Len = 677 +Msg = 4BA150A5EBA308AD19F868282BD246A6DD84D7FEC4B2E5EC43918F946D61061B3D1D11973D22D7C9E7E5702E59C7414B034D2C53EF91729522C9CD82A9F9378FBB4856F1BD10898296CCE3B90CFFDCAB58945BF580 +MD = 801A5EB001E014A29E7C07965EB513B8F4009A62CB4DC19CEA2CE8EA3120E042 + +Len = 678 +Msg = 65666871ECE7F4087742945841BB624EF9D5C6400F4D78857810E704507195D6AD0B047EC823D29EA20967FE037BC4546BB2E4FF5B85EC7FC8AA8D1260BBC5C5ED5AF6789B81928DA011FE91A5017C8867391DF504 +MD = 7EB95C36652D806D320A6A589670EC5D69FA9B7D21D9EED16DCBF1BDF7535EB0 + +Len = 679 +Msg = 01D6257DF9FFF02334322A6CE3948C5C17A9C525D04B5778394B7690063407A9BE263E3C3CD8108457B2176854542FB2A1053578A9B3A36300630D2B3DD82DDEAACA7A10DA4C6B387AB7DA0B4897AC129822F0DE1C +MD = 59A556C3635B0D3F6002F7CE7388272991BCF1BB865493930C42DDB0CEEE4D04 + +Len = 680 +Msg = 08461F006CFF4CC64B752C957287E5A0FAABC05C9BFF89D23FD902D324C79903B48FCB8F8F4B01F3E4DDB483593D25F000386698F5ADE7FAADE9615FDC50D32785EA51D49894E45BAA3DC707E224688C6408B68B11 +MD = 7E738E8EB3D47D18E97D87C7B3FC681F86417883CED92BA93C3077812BBD17E7 + +Len = 681 +Msg = 46D226D1AE24FFD00A066EFB6D561AECB244806BF048E60330BE461C07793F8172BFA3D52F9A98BACFAB2CD39864FAADF72C8A7F94A977E1AC7597061638ACE3E21BA36CBD4007EF139E7DD8B620139DBB0AFFA81D80 +MD = 0627B24653950D65769F904C18FC1D108CC89A9E912C67004B13D4A3ECCC0750 + +Len = 682 +Msg = BEC8AC7466698A548C1015FB4BE3450D86983940D0948A6B53D9024C51B356C3CAAA87E9A15A06873331C3B0E2023346E87EA14CD757FEEE5F77A4DA821087D36229A4C3BDD68C03FB27D0F80C6E3D7E9C8A036A9200 +MD = FC21EB896F5721FC0D55398EB88B0A2BEF94E90E2F810FCC020C6A7CCA587592 + +Len = 683 +Msg = EE0C430A0ACA534E72BDB81416F8A84C376529637209779A74F82C0934825CFF164AB703513B26E4E64F2EB05D462B1A422B8423B52205075FF2E8FBD36FA82E343AC0B06A3CB2EFA7E509A7B0B04EC23C5C4AA20760 +MD = A4659CE10E34AADFDD0DDD1B427BB65C6D076286D91FA774CD2A0CE0B2E3B3BD + +Len = 684 +Msg = 5262C0E6A835DDC17CA500196D4B3F74F30BE0A85E70D0AB343AA33BA65B08E35EE2E05F2812D3420F8466A75E550CDAF47C77E3E6BA22D0DFDF0D55697DD9759695DCCC84353DD2B81AB0FE59CA3E9A6680A5C29EA0 +MD = 267B15A2C6F1AC3EA70685F406C569E7186D05DFEFBEEAF64F03C06E2C7212A9 + +Len = 685 +Msg = 7692563421ECD26D31A2A48D509820C69B1CE339B689C0421DAA658E43F62618EDD77EB6FB8C8C876176A13A7DB1E6F5CCF458F17DC76C993208D722D942E1968033DCF445E369B6375D0D488930B1653C12EA1B33C8 +MD = C51BEAA768A1B02473751705F1487262E3B026E16FA2B82C4E49995BF5004BC0 + +Len = 686 +Msg = B67F18A877D01C5FE24A5A81431CE673D6941FDE954FB92D593291D38E5BECE6EE5C6DB0BA571C5B11D96DF1D683CF14B560E3FF015DE782D2D23CA661B18FCBA123CFE4EFF13545CF10C20E8619C513826B8B017590 +MD = 722D0D0C4AA5D36332AE81905BC1DEF4AB61D03E286F55E43727477C4E0CE5FB + +Len = 687 +Msg = 3DF1EA02F3B72F7DF4C2B23BDB4A07F8B42CA5BB071039C7A5854B87D20CF522B6542E882B6A40C5CBF4410AC39F4D0259B7133E65E6D3931AF6547563603889968A5537429A5461693DE1E248EB01EF78B971143BCA +MD = 663E31372909C019530A4675B950E8FCA7D6E44995681F4FC776C9A9CA29D1B9 + +Len = 688 +Msg = 68C8F8849B120E6E0C9969A5866AF591A829B92F33CD9A4A3196957A148C49138E1E2F5C7619A6D5EDEBE995ACD81EC8BB9C7B9CFCA678D081EA9E25A75D39DB04E18D475920CE828B94E72241F24DB72546B352A0E4 +MD = A278BA93BA0D7CD2677BE08C9DFC5F516A37F722BB06565FA22500F66FE031A9 + +Len = 689 +Msg = 4C4B4D003C4341C9C120B0E717622C70F17AAF88F49DB5E4C10124EE6BB1A090EB3A638BC262FC4A761B0C6FAB9913ED105DE2FC6FCD4BB748B9270305A34994BF81E43A86F8A026FD6048285A4F93455A598D5C47B980 +MD = 88A3D01748E19612E89DAD45D8EDD6483A9066DBE339DC1DDE1116BB63184BBF + +Len = 690 +Msg = 61A7A180B5122B174C0FD9B531C66FF1E273353D348DA58C345F78565DEB59A973566B89BBCA79F403ADEBA899E56FC9AB9885A9AB6ACB96A3920AB27C16FE424A93A21A72D6749756FC14C92EB08F078D6E21D0C0EEC0 +MD = 1061ABC5F14992F349D6DB54B7541C49BE14D6E5A6FCFF4E46549505DD712283 + +Len = 691 +Msg = DF1081403952FF202893B5849BBFFFF74BBDD670C20EAD37A69C6A04291033FAEF0C94E4EC4201A2911A73E6367268A5F66E11561A6636A05CD2CDA8A065B2366B7DB0880F0E0B972CBDCCC70F3F4B13A93F63275C4120 +MD = FF7CAA7418CAC369106CFF32786DCC35F225D77ABAB161EDEBC90D5AA7872E26 + +Len = 692 +Msg = CBD12C05EE3BE8484D9005E2B9F017F8E5EB0E7CF122A393B1C570C1ED9B4EE1C65CBCE0DFF77CB991E6F3F66D7B0EF45204894E5527C1AE655321D84CC2E94046F265EA726127628D15D4EDED37BB42D8E40B3EE6D430 +MD = FD3452C8D2011F9F7264161A9A5D2596A47F49587F9B57B72124076BA2B18004 + +Len = 693 +Msg = 659AF27FD1E6C59C9DA9318DA4E063707AF5204A963038B7E83242DCAB783F009CB034E39A82D26E1B2B6E84422281421687244DB5CE43A187FD96C39A59196AC2FD820FDB52BAB8DB579F87AEEF3EEBD0851952B70008 +MD = 4E482DF1E56CD13540D6F41B7B3A6EC81E956AF908EED855E15D22E8D155E57F + +Len = 694 +Msg = D32EE5CF0455CDB7459BEABEAB67AF3E385E6D7D576FC3F9A3545EA4C28C94AA4833AC1D477C084FC3DCBA799D7DB42260695D651CC299E51987D60F8256A8BAFAFE2A3E414C235A56946DDF9562DE66D80B375DA578C0 +MD = 2D589A2EAFE0A335A1182828B3A23374F94BDB5966090FFFBDEFBD83793637B0 + +Len = 695 +Msg = 62683FAA989429CC513787CD401953E80F8C9C7D41634D1888A08A3242D8FB2BEC07E5E02C7D8D00C446F5F08BF846927B5409E6BCAFAE4ACF70F30383D6C29D062625870F6DDEFD1920179CAD59A2983F0E20E78F5440 +MD = 7879C4B7FF41FC9D1FC66EE5D0E2D4491B61F78721138C3F05835B0A9E20FC2A + +Len = 696 +Msg = B8D56472954E31FB54E28FCA743F84D8DC34891CB564C64B08F7B71636DEBD64CA1EDBDBA7FC5C3E40049CE982BBA8C7E0703034E331384695E9DE76B5104F2FBC4535ECBEEBC33BC27F29F18F6F27E8023B0FBB6F563C +MD = 9C0A9F0DA113D39F491B7DA6C4DA5D84FE1CC46367E5ACC433CA3E0500951738 + +Len = 697 +Msg = 806CCD839B87C2A7C784F9AF9D5BF1F3CB663E39BE778FFC58865F953A837903542727FD51ACE8A276F9F5888F9B9FE1755B5D603284509D9099B310E01776281034FC57E91EC6781FCADEFE9B5E34C2D58ACA5636D7CC00 +MD = 2A60B395AFB470A412B470EA87EB14E6EAB446961329384FE9DE6CEBD22B5FE2 + +Len = 698 +Msg = CA4D271BB220A5E1B6503C8E44AB9F3554D85F2BFF4C4F6A6ECE5C7E91FA10374AAF75D9FB45D4F0B442A3058FC1BAE39127C4C71146F5B2D4E87034EA34E67F822651A57D5D70F7A564FADD4143E940E971AE985E1D7240 +MD = 5CB73C12C593C7590BCD0615DE9E0B3BB00CDDBDC208BEE356DF61EFE7972921 + +Len = 699 +Msg = A2786A30089CF96D17574434B2E274B89CA8D7AD73C3FF491F50ED2965614288DC6B47B491B879857E384EEFE7149611E56DCAFA6498CAEEDFBA30C0CBC52269A3C6248587D77509E2019717E47DC27210A449E8EE0E9060 +MD = E10267036E3B19B7626D0FC1B5960998037A96A7BC057A91F7D0168CD840B510 + +Len = 700 +Msg = 96FEBBB1DD01497E3E9EC768D864A48734DC7DCEFE567F84EE9309CB46B5056F6C730B1A6836912FFB473C0EB7BBB77BCD1483D1470910DE99328A43B2F0ABA0CD4BEAC2938937C2DC38C5E2822610814CF44DA89181E2A0 +MD = 8DE4625D212E4FA34F1584FF0A6B5026CDA6D695D762F1615D52329B8AB5232F + +Len = 701 +Msg = 871EE5187FED8FFC3049079417641B332F0B73B2665C60823BCA8BFDF0989CF312D36732EA456405A3E0EA72F770329DB44949DDF7596318D37D99C8E0F8F71E22534493708CD6521711100EE059C53D2C2753E1A920B6A8 +MD = D938C827808048F91485B55766786BDD13132CB684A865ED32D93017CEB9400A + +Len = 702 +Msg = 12A6F918BC8A7E16920F4B4033F71ECDC3B5FF72894936BDC0A26BBF6FE66C594244FC37DCAF4CE0F24E75B12E486CF4C41FF97C8EF4E66825503B657787C284A6ABCEBB6B175623297DE98745A4A3C62A93682CAA4A8D58 +MD = 36480F72B1653221F7584A5060979CAA231697806410B0025BC181278E0E6162 + +Len = 703 +Msg = 44D3E60CCFF7355FBB2168287FF0A1CDA69AC68D0A7EFE45F3A81D3F095FC8EF2F29B028942CA304A1A6FF223E52BB10A335DE8395B324CE26D802F770E0B47BD6B6FFBC1D9FA0B15A851ECB0F7F62F3C6704A1B16CAC2E0 +MD = C7BA5E35985793878542DC8EC1130C653946EEF86BB84F6A0FF032B0FB452E75 + +Len = 704 +Msg = 0D58AC665FA84342E60CEFEE31B1A4EACDB092F122DFC68309077AED1F3E528F578859EE9E4CEFB4A728E946324927B675CD4F4AC84F64DB3DACFE850C1DD18744C74CECCD9FE4DC214085108F404EAB6D8F452B5442A47D +MD = 6BED496D02FE4CC27D96DCEED14A67DA7BDF75E19B624896DFF6B0B68E4FCC12 + +Len = 705 +Msg = 01EFD67EF39BB09135E89B144997728AD2B318BB6321F421D7EC85BB38DD655FF2C565CB86FB427F4DD4EC69CDD079624FF6AD51438FC7264F86ABED42A93091C80771914884EFE67DF9A1A169A7806392A1E82D71BC748C00 +MD = CF841CC287665952D29DE86C272AFE6385449D4E02308E3E82D77831974F9F19 + +Len = 706 +Msg = 1B8B523F851D64097271FF7F02DE002EB26AA338D93D760EF8BFA7B798CD5EA16BF3A32AA7261288CE542B07EA93E8FB48BB545BDAEFF58EA990CA44001A6000E33436BC10C28E5AF184CE442BA2F3954E6B7B1C15E4690680 +MD = 05BC3FB88FAD0B109D4548BF5ED2536D2D4A1BA0B5E3D3C3C0E16912A792D6E8 + +Len = 707 +Msg = CC579BB31BE1F113D7F436511B6B600889D1169F0A82C3777ECE9857B613AD5CF5DC8C621F95744F1A997F947CBBAB981F1BB910753B6658C11EAA2C3421D410E786C9727D34E79A8501123F1AE43A9ECB933D1256EF103EC0 +MD = 4000AFDF4848D97D2EB14B15FEF165E0F8546F803463F1748EDB4DB425093EA4 + +Len = 708 +Msg = 23DBD6EA6FADE48BA4D2D596F4BD1608E38BC566812A5899041D2B8A867B20D0C6080E3EABF6208B7BA26E2243F270810A2ED2F2CF6A0AB9975FC3D0460F19CF0C8EA7842CC15A12AF2F31C7A97A19D5421C368AEA8CBCB1F0 +MD = A693D6CD8F2386059ABC325D8BBE13E467F858880A0EF95091A8BBA9167C87A3 + +Len = 709 +Msg = 33ACE56FDA97E4E458E135A93730AF474A233C9E468E4BA8D2D6144D3D86FAF619FFCE35463F136C3EFF4FE16F8D4F7B0BB3D6BBD80880A935E7FB55F310309EDB0134E3770BEBF81622C8CCD6CA04AB7C9D9BA40DC0C7BC90 +MD = 98F31A479D977FCA0E647D462036F939CF5FD42389B2B061737355505218CD27 + +Len = 710 +Msg = 37402934012C4CBCD189BE7AEE367F3C12B32B306980416AE5A20674DAF6BA41EEA9F09981D58DB2E38AA3DFA5173218E2DE374575BBD95FC039FDCA99ADFBCC30220492324189EBC2DBD5271A28CC8B8DB90D7D2651190810 +MD = 0AD5E31B1292472031659EF7D51113C28DF0A8430BA1E561BDFEEDB058189333 + +Len = 711 +Msg = 44DA0511C6401815BCA95272F343C27F8A67B19EAED67169957F4B364059537A8F018D5C9DD478C0643F26D723EAEDE5BD2834751D291A0EA86BBF1C368FA2952D4ABE5B3F424B6D3F6C5A129817CD2F3FD6EBFC93F6B3F752 +MD = FE29498F876FE72DD3F4AECC4ABAA86DE73FAC66C4A0BF72CDBC9DDC35E90953 + +Len = 712 +Msg = 1755E2D2E5D1C1B0156456B539753FF416651D44698E87002DCF61DCFA2B4E72F264D9AD591DF1FDEE7B41B2EB00283C5AEBB3411323B672EAA145C5125185104F20F335804B02325B6DEA65603F349F4D5D8B782DD3469CCD +MD = ECD2E3FAF4BA4DD67E5A8656CEBEBDB24611611678E92EB60F7CBD3111D0A345 + +Len = 713 +Msg = 5498F0A76D37803918FD6B15EE166DC9FF9731F1C5A50E058713E285132BC43F2CD5960444E234F8467953890F35459207C52E6F39F0102E4684A18AF3E95126D7437F8A4266FE304B484E73CE5FBF96D2CC4BC29EFD03383A80 +MD = 818EFC3212B9877E8700227EC7452AA827A1377930F3AC66A04546E4F3C3F43C + +Len = 714 +Msg = C0E4A4D8BEE0E03415D5A2A3D11E83088F11F27BE91484A691A15D9C1450F82F295B2BF9BD80093987FD95033F9EA7334E3C832EBE019406B0B7B32F293ABC3AD98BF65459FE860E817B106AB4FD41A6DCDE128205DBC1AFCA80 +MD = FB7150BC46AA671CF1160C56DF7BABBADA45A4014BE8A3108E51589E204F2E31 + +Len = 715 +Msg = 2E99D58138061701615DFF1A8953E671548D6324CF19476D9CD33849043696E1540AAC3F44A011EE94423A2330B61C2FB2A1CE77FFC12392DB812F4F0BF8608223DCCF19019D80755A46902019DFD790D342DA79D5A84C009F60 +MD = 5DAA03C5A70298154647E7561518C4BA70D4A4FD5102BDF4BF9457A9E9AF84C8 + +Len = 716 +Msg = 447355A1A902BDF51F3AEA5D6F904BDD7B958A269727A8F15B1520E15FDFA01DC8D23DA925F622210A587098033BD8AED48727CFC66BC11905410FA4623E8D8456F7CCBBE6582DB121AE2E7676461007E4E225905AA2D30A53D0 +MD = E3E0495A1C1999960974A77EA14818B8403236424C3E57BC446932A5F89AE82D + +Len = 717 +Msg = 64B9BE2D9BD49866C57E320D7079476C1FB62FCE5E8196AC82A62782F693968539D331B8F46E8B76722B3DDCCDB3DB194873E02996CDEB199237F0CE4C377D46DE925E7EA0540337D03378EF3FEC8488F0728DB40CDA98C11988 +MD = 597CAA4236DBF22572A14BB87A680B2D73E5A70E3D8DE9461B5D6B5EAA595D28 + +Len = 718 +Msg = 8408659B0998506DD15A6375D400D017CB1081CFC1322BFA61BC19E4278AA172199D091AE29F7BB5B0B9E01F3F9AA2F5ABFF8DA03709092A65074F965CF0A1253A1EEADE65A132AA5C17E4E880F1382709BBB3056C643A12A928 +MD = 12728424BC92FE89E47D9CB9FD38154545D5B8410243191C9E3903769C7D6FA2 + +Len = 719 +Msg = 8E51395F9CBB75F8B98104508108016D275B6F769588DCCE2858E1D6995EFE7BD216B9835965FD90664CB4F2743EC5817B6820868D039190BCFD07E68B9C13A014FF2703DE6B081B86C55D72BCC22F4770FC7965D1E75AB9948E +MD = 40E725729FC76C1F72192545F6E61A272A19ACBD980C2940CBAE2A791B4A863B + +Len = 720 +Msg = B180DE1A611111EE7584BA2C4B020598CD574AC77E404E853D15A101C6F5A2E5C801D7D85DC95286A1804C870BB9F00FD4DCB03AA8328275158819DCAD7253F3E3D237AEAA7979268A5DB1C6CE08A9EC7C2579783C8AFC1F91A7 +MD = 634A95A7E8BA58F7818A13903EC8F3411B6ECB7E389EC9AA97C0ECF87FADD588 + +Len = 721 +Msg = 1CFC3DF19818EAA21C03FDE78CDA0C704EBCEE5866F71DD8E3B1B38C9B7354443A3174099928AB8589F5EAA4F030074D3185BEAE29B75A9B7B449106EEBB05E32B7A621962FBBA4C74162FFD111BFCA10DCFA4F909C7C1AD98E500 +MD = D946C964DCA96870EEEC874F76C33495F18D1BB00887A3B53A4BC8190A9E7D2E + +Len = 722 +Msg = 2202FE7CB2BD3C73A7FFC49EA7A459AD89B62257B842B189042EE58720D7734926FAF10293D1455B7C9A4718CDEF1910F54A3140CC70268A3138819526F173595487AF4603F31B4CF644B3C4FCE967A520143DCC7438B396AC04C0 +MD = BDEC3CAA91566CB312AD9DA2D082EA7E02879289822D3CECACF87BFF5AEC059E + +Len = 723 +Msg = 490671DB10124CC0462CE3AAB939A6873B6111DD47A0CF31DB0F188FFBB60CB1F5C29BF6A236895201B52ABB93988F3B5091B3F00524C7BC5B70DAB990529797FB08CABFA7C01ED302E3BDA464344478296D584EAC426C3862E260 +MD = 8F3F1A2B13441AA5A224432E0B07C9B598C6E802083F8C3C1454BC33223CAADF + +Len = 724 +Msg = 5A2A63F0BDCC12F2E6FA0D3A7CC1230890489E03100CB2B5FBD196F3C5CC46611F1C0BB50217B5FF5BD0B00604FB3B408937068F23492F498980329ADCEEB3F3E7C5869DAA37EF56C77EC485BFE84D07C31926FFDC1998C391A3F0 +MD = 0AE0C2ACFB5B75BE11D1C7BA61722C36F9ED31ADFCCE72AC8288552C80B1B914 + +Len = 725 +Msg = 0CBF90E972B7FAA236A4EF379B189E96475488C0CDC8163C1501355F283FF2EF2A3359F2966F3E5DDF5B619E4C8AB2840FD93284BDC1018AC8532BE123CC7928D3B1B7BE9929A1BA3F7F59D4CFA6D8C0CC5BE7EDDF878A5EAB35D8 +MD = 2F2751456D4015A80F3EDF35FB5BD93CCBD71EA03C8389BC5989C7BC012E9DAC + +Len = 726 +Msg = 43B5CF0EB20A1782F17DD07E95BDA2AED072798E4DF4FD9B6655EB087EBA8549D68A2C61B08A6B26ECEA623DD5C7D7215F0F3C5E5C4F45BBD4B580A8BC2BBD8ABFB76366E18927D25A74FBD1896536C36028CAF12713544A753A98 +MD = 173D5698E74E7E160FB887E05924662D0794A69F3BBF544AE4361182A901E640 + +Len = 727 +Msg = 0B1CB486FC934262E8DAADA5789855E2DF164FC5B5141336077B2C1589064ABD1BE8F92E455AE6AA2CE8F4F7ADC653B36F4AE3BF82134D639111BE7CC40EA02DE51AF9AD1F653E8EC56D60BD93CC4937D3256DE51CB5F1962F42B6 +MD = 6932EFB8A430FB932E9904FEA77A85F8CB842B1DBF4C7AAFE36B8220B71A8F41 + +Len = 728 +Msg = CF3583CBDFD4CBC17063B1E7D90B02F0E6E2EE05F99D77E24E560392535E47E05077157F96813544A17046914F9EFB64762A23CF7A49FE52A0A4C01C630CFE8727B81FB99A89FF7CC11DCA5173057E0417B8FE7A9EFBA6D95C555F +MD = A0FE352BA2389B0430EDBE1201032EB09C255514C5C5B529C4BAAFCEB1AC9817 + +Len = 729 +Msg = 97BD1EF155DBFF92ED40EF57502EB5B11BB43D0525805EB66CE6CA6B2C4F27ECEB69E7196FA0AB9E097FCE104FD621CADD0CD24A660725DBD32D336BBC8054FA5F8E8631239D90CA428700C962F70304EABB7D21E7A1C86093756900 +MD = E3B90E71B171CEA3B188B501A7A8407F0C0239C1180F1A2DB60F42E7B3BDAB05 + +Len = 730 +Msg = 5020D3EF88B8A5154DC7CE9FFBD5E717DFA478990A5F54241E83C4B67F5BF0B486CCC4C441A75DCAB06B5F680E4CCBB4949AC79974B242113CAF54838F926F2674810F2258EE12826DF2B95961DEC901B59361877B3566A0385E6A00 +MD = 0EE353589DA1B300C1742588EF2826B38C04A602D210E6127AC525D6A79F8382 + +Len = 731 +Msg = 420F2E0A79EDF6879787FC94F2099AE0C4A3D04BC8932274A8DDC95ACC8C7E1403659777027A8002881E4588B03B3DC6369B7AA32E4ED7624C30B10AC8E2F16DDE7561620D3EC186E0A8395A7F90E67A52931E779F8A8D6297EEC6A0 +MD = E644179788EA36F6B745DD4B4A559EAD0C64E113EB005087D3A2E435A8CA47DE + +Len = 732 +Msg = 2FCE6B9232D11B2AFFCE835A8420C8F940390D5BB74E32A85432BD09286F1F5FCE5795225247491929D92169C9E7989AFF84B61D10597B651B875253FD07C098C513C8155652A7C98CB3958D2E8329FA43B7EB5685AE19D4F427C7A0 +MD = D6772C0905BC8CEADF686B0442D08695A9E4631A18317023BA4965C701B05907 + +Len = 733 +Msg = 500A6E6A9AFB85255208BC8AC021AED541E93975BD9F83E0C7A5ACA7DBA0C6B92090B08543D888E8219EF073C959731637DC2C2AD8E425C7D85CB80FC319365DCE32B271EFD47148D2E89B39D55A820BF092C5E0739371F96F49CA70 +MD = 750785A8A9E8595E5B00C9FE65DA32E891932C0663C8E5E22C4E23B46F34E4BD + +Len = 734 +Msg = E5C9075478B6D0EB732C668AF5C3F523D4FA1983C564FF060FF725164E9AB9A0C80AF83FF749A5BA3E12538F0AA89E596E8293DE963EF6B3D25D23A53CC11F852B41539A3897878741F29CDF04B7137EFB104A395122DC4F2D8DD884 +MD = C56612982B29321314CDE272F14B1E92E6B3E9BF3F4C2025F6FC3DB4F0106814 + +Len = 735 +Msg = 92D2A406FEBC4031759A4BD3A7449812DDAFBB1F814125EFB0680458242C24C60AC3CEEA9446CBD8B5829CDDA4F17D12D621416F8A84070EB70680F2EB3E54684D97066FC5697BE7C3F8284F896966CA6607DBEA21713A18582C2596 +MD = 3D13AEE62B3613C03FBD29402A6FA47D01414BE9DA124094FA8FC45102F2F039 + +Len = 736 +Msg = 072FC02340EF99115BAD72F92C01E4C093B9599F6CFC45CB380EE686CB5EB019E806AB9BD55E634AB10AA62A9510CC0672CD3EDDB589C7DF2B67FCD3329F61B1A4441ECA87A33C8F55DA4FBBAD5CF2B2527B8E983BB31A2FADEC7523 +MD = 9A0BFE14F9F3127ACA86773A620945731DF781A6D7DC82930CCDE2F69DAC8F94 + +Len = 737 +Msg = B2CD11B36C8EDA2E79452DDD5A6D84A5B30E32F0E7AD88CBD234CA5C6C8DA088E559889130A3CD3E7FC8C2EA2BBDA9A3AD0E099F87A54B0C1C772A8425D81263F15B280A3D26772EEA18C011D66314D98F0146DAE57B03CAC8084B4780 +MD = 3A09B6C82A608E7389547428E29E82A2B34CB4DCFD6CF100712E3EED48411777 + +Len = 738 +Msg = 03E7746A3778D7AB8352C9B1B78FC83D9AFBED688AA1D8B1DF3DCDADF47C79D9C686074177C98FD35701E3CB967E2A34516BC1297D6F72FCF4164DBB286A646D30FA5C9C9984CE7B25BF7E76ED96268CD6B3F1C53592605D190DFEB200 +MD = AFCF69829DF13599D8BE8FBE477EDCDA7F152B53CD5845186A556DD611E86F13 + +Len = 739 +Msg = 81A038A15FD7D39F55041B3C436B2D2ABF168A589244AAC58AF8E3234657E0E9892344D87E57F8FF8535282CC3046ACFE21795F55F521E9720441BEC60D8948FB7F4086CA1CDF11A55E6F477B08E1FE9993F20B55533A05617EFB56780 +MD = F6609C74BF55ADAF3C6C44600FD6902E56CE3C49CC70515554F9D43E97652DFC + +Len = 740 +Msg = A2D5A45983DBEA20C34211B395736AB2E93B185F2AB4A09C9BD1221D070E196B34B736682CCB9E5ECA84491EC2CE45DE770B79BF138FE18DAE6C1CDED27992557C939ECD5E99431F2D8EEE6DBF8FCDE40040522EB74058B32EA34DF4B0 +MD = 259295D9CF7FC45B1285F1051A72DD58C6BB2D226325B94EE2A3A6F224599D76 + +Len = 741 +Msg = BE4D1EB0174E7864361BF6E36D4B017E02DA05C498747457A01283F10889205877A53D588AA2A6515888D3DC411A6A12FC7DE5FF9FFA2487CBA37204F2116261361CF243F9A686251665345702EA29BF61F6467F353FB3958EF501C600 +MD = 8245B6E65947DA886B7F07EFEFE792E9F16A4729CF0B5853F691E7AFC07E36E1 + +Len = 742 +Msg = 2034010759152F3222157B787FAF0688A0E9A470772FC1C41E608C0738085B00EFD92F0CE2AEB194556CA83C2EFF6CDD0510A7CE3739308B2D54A3668A799271E14721C33AA50359406825DD16D2F21983DB25BC195D7E2292F9B7E624 +MD = 24C5B293E6203C9CB0178BD5F5F118F5F01CF6BF0CC500FA909CAC1ACE46B012 + +Len = 743 +Msg = 32A05FC349E5A290FA9B3CB6B1E692057992AD2AEA4767E30644AE845134A1024E5A68156B4FC368DB7187063C99C33896DA02A99FFA4F7D8A22B578DF030E8CE34EF5FC3661CBF56E86801C1BE531A67B4317DC6C6576C12A9167D0C6 +MD = 7AB6D47C0D0635A5A6A4903A84140F37370DC0738A703C1292262E8B2072EC2B + +Len = 744 +Msg = 76EECF956A52649F877528146DE33DF249CD800E21830F65E90F0F25CA9D6540FDE40603230ECA6760F1139C7F268DEBA2060631EEA92B1FFF05F93FD5572FBE29579ECD48BC3A8D6C2EB4A6B26E38D6C5FBF2C08044AEEA470A8F2F26 +MD = 19E5101BDE60B200A8B171E4C3EA3DFD913E10111D96F9682ACC7467282B4E31 + +Len = 745 +Msg = 1DCDC5D09B905D1F932BEEF9D3529ADCC20322937CA3576086DF22FA0DB226D4A2E49F41A21908C2B6F77055ABB72D7769174B35813586DFC1802047D801380350FA7EBBD158DEC6C82E93AEB06E8B18B6CD99FCC72E575E5BFA4AB32100 +MD = 04CEA62D4852E54AA553EBD0C98FB32919509D493C0BE2AE8147D6DB401DE1EF + +Len = 746 +Msg = EEACB938F6285732979F3CB7CAE9023A0F187CDDD0CDED771037ECCAD2DFDC9AABE803035AED9B42A164F1CA5E754C40F31BBA3A3E253958DF75CBDC16367565FF426D30FF4435E9013655BCB52CA1140345E712D8F7A4921B1E18B04300 +MD = 8A2FD7C63861FADB6506EF623081E0A8F3158F3605AFCF176E9B19A8512810B0 + +Len = 747 +Msg = F5C107B8C6F4C0B86202A1E943B049A09FA770F010333DC67233A7754D437EAD8C183D1F8AE3A4D62045DD69F9E751E82FE078768B0314898FEBAFF3B228CC85DD7C7AE786004555698B930D288CAF17E97A3200E4069EBEF80059F32780 +MD = 057A9E28B3DBBA424A1B1134D0C748233E821C4E05C23CD8FD4635AEE20C2AC0 + +Len = 748 +Msg = 2488C513A23128D2FB1694435F708E15C4DC0B2C2FE7B6AB060ACD0096E696F8D735B6557FEE0E518870AC2D4F62759C990F458DE19AAF1473288CC4252AE745651140790058F2ED53B30B35E556B865D331D1A0B4875809FFDF3250FB80 +MD = 2C58EBEA4A889DCAE93ECE646CF47742CBD27F6D81A424F81753EE5E56D1065B + +Len = 749 +Msg = 44DFB4D53F3F197A602B273046B4D37E78C2FAEE6B64EDB48A8EC18AC173D21D9B1140A1EF00A184E75DA7262CE9873ED99AB740BA75872A37BFE3179127ED0C301D26FF6C7EC76D80C691452D2B84B05341E1D93457C7B6623338621D30 +MD = 8E871CE3BED17F29D30869CED80A739EE4B451B2606D45BE278A1F0F812AA083 + +Len = 750 +Msg = 798CE6CA7DC91C938FF9C3F3253DF0B57FD5D548B162562082A88AECB01F69FB68092CFE8E7921768636AE88C35FFFF093E0E380B28CF939750FAE3207198ECECB327F0CA80DB4B0026D2BF1B9E8C5B01DA7C761BB1DDB4ABE2CD9DF6C38 +MD = 2F837F14DD5462E88B7553AD23CD7E5B8C6F25594D6B4B02625D62595635C45D + +Len = 751 +Msg = 8177FAE4AD2299632B8CC7CA64A77777C4CB0770DA8AD86A73A1387F2A53B473EE373DB0FCB73163CFD6903EF5ABBA7464AD74D7E3342D0118C99635CFD2DF68349ECC0D2B3C56502178E33C52CE3D7EB486C5DC33FA1EE79915D232D78A +MD = 3FC5E5F0372F5C382881FDEA5766AC380A018F900B3D0275C83509B02E11CF14 + +Len = 752 +Msg = 7ADC0B6693E61C269F278E6944A5A2D8300981E40022F839AC644387BFAC9086650085C2CDC585FEA47B9D2E52D65A2B29A7DC370401EF5D60DD0D21F9E2B90FAE919319B14B8C5565B0423CEFB827D5F1203302A9D01523498A4DB10374 +MD = 4CC2AFF141987F4C2E683FA2DE30042BACDCD06087D7A7B014996E9CFEAA58CE + +Len = 753 +Msg = 6B6F9EAFA4DFBCC5968C0E9F2FD05418D0D14408DDD4F815D823DFDC3B86A6CC4CD7E251EDC6D1CD01F70ECDC0E10F57B6DDE2A299D964C64B3369041B8903B85FCBDC6F421320EE88C1963603E91C1EFDA49A9EBC6CD3BA5BDB56810BE400 +MD = E78614175EF0751FEC7DDBEB030FF4AFEC10F3994125A5AB3B96EB307300ECB0 + +Len = 754 +Msg = FCDF2D9025A965E76B1062BEBCC4263060C47FBF50B94D8E6543CC4C18D9D451B70AB93D5D33880F41AF4AA1EC9657B9041D12B5360FC2CA584886F5123751E5DC4950D8371DF9E47B28BCB548D23E0E0FD2398415B435E638BE561DA9B6C0 +MD = D739E6A20533AADFCBD1A5416EA3B05544E53DEF3A51CA481E8F99183C3002E9 + +Len = 755 +Msg = 686E9C366F294D6CBD34198F99137212E06602B3946126EF61F129A751AD217C9B65BBB64777D0CB79B0287C111E2CDF7A230ADE611F3E686837D2CCD482D6EE8989547CFFEB22E9EA6486B8F5B801A43055AFF71BB31FED1722B561FB9B80 +MD = A137FDBFF6C69AB4FA6AFE57682717D8CEB03731920B256BD2F1CAB872A638E1 + +Len = 756 +Msg = 8F3F248C4ECC21F82CD80EB4B9351EE7F1DA57CA05940F5A16AAF673320FD07337F2EF33D949A20B4F10F46FCD4BA11ACA937F485DA1F8340976BF5B8A0AF3E9E9A1357AC423B0A5D135DD22D46BA708EF929F87503BCCC210ED3CC07762F0 +MD = D7751D974A9613FFB75D78A14D6565ECEBB7F3D59265B382A30A221E30C99452 + +Len = 757 +Msg = F81B17BB20E5EC27B38A136443DCC8361D0407F9A703C395C18210B5013EF565B79D2F211D3A57FD12FAE93E7AE049967CEB74ACC197187E7CBA48A3AA334F7CA54E1EFF502E10BD8CC0261B61BFEFC109FFCD980D94339E526F49CA8C1168 +MD = DA8933B40B6C99271907F36888BBD6ED8591D25F9FE02B7120E2D5651CB1E11D + +Len = 758 +Msg = 44BC65FEEB041D28F92DECC9CCED0C82EA96A625578D136F3433BBFA45D4560FD02C4137880A5A5340BA50B508664D2D2F28E9A1DEFB835DD11917B7CB1F99C0F68255461CFB3D5B63605A41F2E767A5312F22C2763AF9AC56DF84AD2B9360 +MD = 979B9A2510EC3F007C905BC52509AACB5D37C24A613E3A177BA7F31720EE2D36 + +Len = 759 +Msg = AE840D40174167BB2263166491BCFC27D22277B34EE01988A1EAB70D588013FB67622EA09814065F4053B608661C5D1ACC9EDD2CC60FD1237A3FAF54752357D9A4BC668C22544BD278FBFA8137A70F2D749F00B64224D7F89AF7D21C658F28 +MD = C237DA7B9A1AC14C192826CAFC565B389C5C6F35E1E64104A91594F6F4B7AEA4 + +Len = 760 +Msg = E1FFFA9826CCE8B86BCCEFB8794E48C46CDF372013F782ECED1E378269B7BE2B7BF51374092261AE120E822BE685F2E7A83664BCFBE38FE8633F24E633FFE1988E1BC5ACF59A587079A57A910BDA60060E85B5F5B6F776F0529639D9CCE4BD +MD = 9A8CE819894EFCCC2153B239C3ADC3F07D0968EAC5EC8080AC0174F2D5E6959C + +Len = 761 +Msg = AEE916551172614EF72AE01261F6A0A83A3CA96DE06100D037370B33F1E1C4A48C6E03FCDAA0EFB1855DE62251035568C2E143B5ED4A7BEADC8E3880F3EBAB6043718FE1716DA54857BE77B9665885BFD917FCF3B689EAA656EB4BCD40C3A000 +MD = E8C960B776EDAC27C3E0143380B4A80990B5FDC2EC783F67D5387C16804951AA + +Len = 762 +Msg = B62D734A657549F5F0DD26152D7520393E93FA79120520AF6D18160EF699842894B298C965D1FF9CB4200F778F4DEBB7910B34049488974EAC2EEF9372DD4674CF91981C5DD04FE47878D82F7215A1DF00B5DEE6D657771F77FCFF4A0F0FB700 +MD = EC421D29BBF2A9C0E93BF85C473A31837B99FCB44C00DB991F6D35616465AF72 + +Len = 763 +Msg = 607A7830E232CC6C8ADA43E6771A47D6D8F85533B09350591BEB1372A4968766D539D9720CD6FE0DFBE37B4B2B477DC120DC152B9662B9BE32403920B942D284F092D5C7FF6FC86E14ADF7605A0B356876212FFEA7313780112E469E587ED6A0 +MD = 28A6CB2C04D6DDAD0D4B14206C9BA150045B5467F7CAF4F32B28D7FC700C0C57 + +Len = 764 +Msg = F9BD410B5BDB01459653C9043E69479086CC7843259BAA5DF4E7F14BFEA9161EE11B149CE9977DB82F4666B2027E33FB5E2F2F298EF7E7D17E54957F63D5FFFCCE2203613D248F8D1C87C675530531677C1B2F2301640748F2770F2F9399DBE0 +MD = E4C5303625E25794AD515DD1AAA901D89A46FA39FFFCBE5603984A8DA1A96971 + +Len = 765 +Msg = EA3C9C739E567B78C16751BCB07F497B3062483431236FF300EFFEE566E546610727D5EBEBB653A44616BB898D7396E9C8050F5D4569100EB64EC70DF3182A75A2F3108807E7CF8CF9CB46F8DF2DB20570BF49BE10A7CBA0201CDC68562C6598 +MD = 1435457349E61274F3B58D498DDDDDDEB19BB1E05774A80DC3E0CDA6F966D0A7 + +Len = 766 +Msg = D2FAB29E41C33D863B9D54D5289CAF08DD6A1807577A67C667E9A15B3E028D35D8FED331EA42491D09BB442900810A9188562E043BB07D445B8BCE72DF4FA79FB9883680CF619C1C33FF2FFCEB88652785C9B1DCD84DCC820971964740A7B694 +MD = 825A1129DB8922565B5B49A0512D7946F35FB12AC6D52297451E941689375258 + +Len = 767 +Msg = 7D1D7760367AC57888886DB653E275894F5E77307FD0552F3C215DFBAEFB379DEA88D2F94BCEF14B31CEDEB8B721CE65B51055357AB8D56AD4F131B9ACAD1F71861312F5A4BC8F7DF6FAA913A40DF179B887CF946597709DCCFFA0EBD4675812 +MD = 5095327A2DD5F272FED01C6084D6E12E33C828783650E8B3A557D0DA40068B40 + +Len = 768 +Msg = 69F9ABBA65592EE01DB4DCE52DBAB90B08FC04193602792EE4DAA263033D59081587B09BBE49D0B49C9825D22840B2FF5D9C5155F975F8F2C2E7A90C75D2E4A8040FE39F63BBAFB403D9E28CC3B86E04E394A9C9E8065BD3C85FA9F0C7891600 +MD = 8B35768525F59AC77D35522AC885831A9947299E114A8956FE5BCA103DB7BB2C + +Len = 769 +Msg = 2EA8CEC39A5FD5C5D1702E3414E3E1B2E7F995EEE85ED45C839D6F9700D0A98717105A653C1DD4A6BA203C37C2139A94A2BADF7D91B78EE47549A44DDECE61A7D57545D1AF181264D80C3E5F6048242DB8566C4B5A19B917A6E743376C80C5D900 +MD = 64E69F5AC52460667AD20482B862D00A7F8E06E23F13E7F4641C1D9EA1339436 + +Len = 770 +Msg = 2F7BB5955EC214D7888D9905F242672DBA9AD7F069DCC7223BAE86D98E06963022BDA9BCFB4FB70E08A9D925259CB170116A232EED329E9ADAD7B2BA6265D228A5ACFD9217A26E3566C8911DAD49130E5B94AA76B63B2791B3F03DB1E223873D00 +MD = D20ED1571E784A2792CF6395413E866B0DB6827903DB0D869992612DB074A668 + +Len = 771 +Msg = 9F17FEC7F006213F7CF73F749FADE644FB82FEDB4AD040D6215C2C37E231777A76ACF2B11322BB77C48DB77F7DC4FAD97D967990CB04414E3DD5F59F51492F84119CA604A258BC449AA334548100A4E820ED8E62A3168889D8D23464F1F34DC0E0 +MD = 359D2792633DD0CA70FF79EFA2F02EE105377DBFBB792863355E23CAF6B0DB73 + +Len = 772 +Msg = 67B2619FAAF64FCD3EC0185032761437131683F4F75DAA2CB234F5C0E8014EF0CDAD47C93D3962052FA629CDC759BBA3EC8AB9CDF65D5C9B2EC6FA803DAF0A583FE1176768B81EADC4793E0CE47FF204C758B02DC21F9DEAB6267C2ACD5356D290 +MD = 2350957ACFF060CEA13F7B73CF7E79BE7A45206877156FB98363FBB3D44305D1 + +Len = 773 +Msg = ACA049B282819B944F1F6114F989DD133A8B777922A8D2D487F04776405C31DB13BBBDD2D2B7AD994B28903F9C3C74549B8AE0DDB89D20221B30006DE9A13728BC2A553C8363FDEBAEC392C4D9AE569ED57B52D8BC20F593D96D857B1EFEA18D10 +MD = E1D43912D44E4294FAEAACD49887AD11CF07D23F48EFE32F45231C523288EABB + +Len = 774 +Msg = 84D4E78D5A5CD08A94717D8AE14FE24E3670AF58851605DD337FD29482BA01BEFA38F954C9C5E021EEE41D1FA230C0AAA1BA306D6059ED113A9B9CCEB9F70D92A4B6886ECEB7E805D51E823BFA7A6B270199A0DAC2F6514EC6CC0DAC2E2D8CED10 +MD = 2F58F022B07FB10CAD763694194FCD58109D0EFD4CD21A9C6CFEAA6AABE9B43B + +Len = 775 +Msg = 43C5378EC8FB95C451DCE02DFFD1DD6EC6E73EC464AEB26D9BE6ACDCD10A246E12740D939D480D0F69FABB6216E3FBF6C53C723B6624EFD8A79E90BFEFA048AFEA723F54B0F72168EBD6B271F981B5395DEE468278C80B014EC0D483F3C037270A +MD = D9C5A20280649BC2F60D9EA0B774587EFAE67BC773B5086139C95AF39334A42F + +Len = 776 +Msg = 38A10A352CA5AEDFA8E19C64787D8E9C3A75DBF3B8674BFAB29B5DBFC15A63D10FAE66CD1A6E6D2452D557967EAAD89A4C98449787B0B3164CA5B717A93F24EB0B506CEB70CBBCB8D72B2A72993F909AAD92F044E0B5A2C9AC9CB16A0CA2F81F49 +MD = 955F1F7E4E54660B26F30086F2DDDAEDD32813547C1B95D305D882682B4FF7A0 + +Len = 777 +Msg = ECD731D02EEDBE3A4B9FFD5FDA34CB343D655176C691D8E8FBABC6A15F73B8E168E2AD9C97361EAD1EBD3C3335C1FC683882B81DAF55D9D657DA01EBED9D06A52C5C938B1D970AEC5EFD5034CE61DC9F67074A2DA145C27B4329CFB0F8B489729880 +MD = EF4FB1B78427183892416F2F893C2C081C71A2BF3E05E721BE073FE5CB13FCAB + +Len = 778 +Msg = C9CD6851FC6B8031E039FB7BDD8F1A6D7EC7854272E2309DA9CBA90A00F1F90B5FD3AE6E394067E17BBB4BD60B7BC11C8F425C430303EFECE951F5BA99BF550D98897C3723D758764A3A9F1D0CB95CA20B0BB919F061BEE4F5ABA38DA0FD146E46C0 +MD = 86ADE53C36F96F07A9F76182CFB45CCC348052BD9EAB2688FB6A0FD662966595 + +Len = 779 +Msg = C48E7340EB22C6EA14ABF7890E781E355FB37A7C278443FC710E8C17B87D13FEC7153E8E68BAE3DD640F966E3EA2813B36B017DD1B3D8D5099C4CA1EAD1C9BF5D1B92214BA10E8E0D783CE1C364FFF56F137A03189E0E62EFFF2B3535C9749F1EE80 +MD = 019B301CACB5F265B7143E10EB5D2DA2DE4E7A422CF90C274D0112986E050F90 + +Len = 780 +Msg = 01CE485175B07C55FC35363FEA239A26718D34DFC08E38E1391D4002C2B3F977A0074ECDA3AB485E6F3B0FE394BC64F187ED6A3B04A7B93EAE9876AEF77F01124ED2DD88956565669378C2CEE09D49728D3935F97698A6A3EF7C49E69104BA38F3B0 +MD = 3F41E543EA5B6AF470E7E0EDE605F7D3D6BB40849A135F8BA3B99AD43C369567 + +Len = 781 +Msg = 69D1FE474AE0892557398BA77643E7A7F0AB218374CBCE7A9D2E51B1B319EA39B1EED38378482CF5D3780F543A773D80C66783F11B793BA267F32F23ED16473B6488C4E1006916B686044247BF3777224D5F16233AFA837A9988E436AB5BE485ADC0 +MD = FD82C2D851CFFDC5FB4A56D9B77BDF02A7C7CAECF9A26537618F715E5E8D9545 + +Len = 782 +Msg = 79EF097DBFA16820E6A40454D428F3FB0B19047DD0AB46588F825ECC6344C53BDDACA3DF63E2FB087984BC58C22F2B61003CEE298C2B35EE788CD4C834A82DE93A04E8722826A645CC3EFD07F32B30C3CD59BC5C82CFF16B213A09CA24A53DA12E70 +MD = 968F4DE10B35405253763CB5F4ACCC181C5AE5B06E291C18B2065618FDBAA557 + +Len = 783 +Msg = D03DD6E01CCF153ED2878C9D3DE4E0DE7D96D91A2CE3BFD7E77ED6652616EB87188C466D44E6DA9FDB2015DD896761B88033E0D98B960C322153B51548CF21EF26029556E7FC85D62783B676EE38FAEF56F156383CCD06915FAE4395B3403E50DB66 +MD = 8F6EEF9E8D67832EE2398F69B04B475DCBF52E9E71D7D346B02F5EDC59B0D5FB + +Len = 784 +Msg = 6D8C6E449BC13634F115749C248C17CD148B72157A2C37BF8969EA83B4D6BA8C0EE2711C28EE11495F43049596520CE436004B026B6C1F7292B9C436B055CBB72D530D860D1276A1502A5140E3C3F54A93663E4D20EDEC32D284E25564F624955B52 +MD = 8FAC5A34EBAFA38B55333624A9514FE97D9956E74309C5252CD2090D3BBE2F9E + +Len = 785 +Msg = 6A15D2C891310B9D31EA4DE5ED861595938093F969102EC4E61F36688005876CAC6AA4DD19185E756AC6C75B1A77C46952D5147B52862DC108D8B690191DDFB93F9463BC95EA6054688AC748A519EFF46E0D6FFF33F312A9531B90E5B81D1EB9BC5400 +MD = 1DA5295F10813C0F72D636883C63AE8BC140744A3F28CB8389ECFA7FD74D1A64 + +Len = 786 +Msg = 4799898B930C206FD677188EDFE87F53978DDFA62418695F83A764F096CF0C3E77EA9EC22552F4EC608B59DFAD49691B076181A15C9B18539A6A64443DBED8B575CCE0BCF1D01DCB3719CBFACAC94E36CD466D253F3192F74D0900667196BFFD8BFEC0 +MD = E1AB50948EE70B7E8D36B44D2B5B073A88C38F49F408E29CDFBA73CA46C42EF3 + +Len = 787 +Msg = D00AF463BA4905312AC7C93AE0F5814D903C2CF3E4314A09D8083E8FF602ED65301BF032FFFA16E57CC1D39B78BE5F7F1B4E7D118EB4C9C60B2AA752377820F4B23F52AFB3DABA13C33E354F2AD791B98C0285B3289D017FD0B015E275F56452C64DE0 +MD = 62AABA395E7A3C6836D9BABF13938A7B6451BEDE45891814891184314FF0EC58 + +Len = 788 +Msg = 4BA02BD76E684B9DBF18AB2EC6A5CA2EAFDF25F5A7D4C90177DE0F93392983E680A71F03185136D6396A65F583837F84871CF564E62E7CEC42B58C8BA153952B28F7A9880D9D7B5FD8E1CBDF9CA005FD78D72BAAD574414E4128CA28730C29804C9CF0 +MD = 01257E4CA00F14D96C8ED551EC4022FD25F466AA32ECB348B9D4A76B7E46CEB0 + +Len = 789 +Msg = 4540739B329C3748092E2AAAD779D52393B8D97B42F784121F4C045A586BF21E33EC1A55AD2A16B398587A15297B9A8B5858572CBAA405275748ACA67FD75D5102466F5BB433A77C41F442120E1D3C95365C9A014B324B01A75D3182F88F9F89AB5B08 +MD = 9B4F94B8B9753FC6569F45B310755FFF872A1AE4C24C3C00F08B11B57BB3E66E + +Len = 790 +Msg = 19218B21018F5392D90433A5BB255292CE42EE74A3CB012B28EBF120F1BB35B3F0697B33043E90F4CA5649984EE1866AFA01457FB5F8A160AA54FB249E171436325AED03B959BECBBC8D6E323507470C147D7CF6D1CAEEA06218022444E01B5A2D54F8 +MD = 6034DF011419C3E22DD921DBBCBF27AB9D8FAC8141136EFC91E8916757963C6C + +Len = 791 +Msg = 29C1C9CF77BBF33FE3335014E7E88BA5EB777B55DF264589B44D05FC135E4C5170852968ADE4D911476D5C0D0D5E82506345A7B6A1A84EEAACDD49DE05487A6A861CF30AED0B86E320B73AA2E0BF6A67277662C0B7696E585E97F690DC51DD1F51E41A +MD = 18FFB18A1866871FC0324D4DE9D0EAA6C2BF52526BF8D858766D5185BFE8F0EB + +Len = 792 +Msg = 6EFCBCAF451C129DBE00B9CEF0C3749D3EE9D41C7BD500ADE40CDC65DEDBBBADB885A5B14B32A0C0D087825201E303288A733842FA7E599C0C514E078F05C821C7A4498B01C40032E9F1872A1C925FA17CE253E8935E4C3C71282242CB716B2089CCC1 +MD = 62039E0F53869480F88C87BB3D19A31AAD32878F27F2C4E78FF02BBEA2B8B0B9 + +Len = 793 +Msg = EDE8BB44D6C9F552F8B2C14750B8D8419370145875D04CCB213E4BD41DA0ABA1CA36DECA9710BB6C846A7DB3E90AECD10492E8135A3289393AD1F8F30FE1EB3707FD966369F766D6331ED4DE80D8252C03D88F6101781E987185EC7E277BFEB7312B6F80 +MD = 9258F0CADDF3201C8157330F743D89A18E8C5701926863BFFCDB83D0BE34EFFE + +Len = 794 +Msg = CE727EA48D1188D5AE6308DE82ACE9B491A784153CF45690B8FD23A7FE9FA4F43186D423735D56BC9D6E4E69E7B203698AA2EAACFE42064EFAF1538434A4780F13D1AEACF78A5F84C60BFA2E8753C1E51A518B05ECBCBBD86FA27EF3B64838F5FF2235C0 +MD = C862279ADC72B37720E8620F4C317E3BFDD03EAF80A21BE74EDCC59C83D38A1C + +Len = 795 +Msg = 3457335BA5117C3E7568CEF312C75EBE57BBD6EFE2C06E0D3457614F429A27A6216928507CB18C198CB9CDEE8BFF4B2EC62F29AA9F9DEF4A0AF45741CDFC3C5B96F10B8E2886AC4D24A6DDBC490E402031DAF68A742AEB7EC1C0426807A073C86C9EBA20 +MD = 6DFD346EE4884CD634890DA0BDA637D48CD1A0D745564FB4223D022B9DC07F13 + +Len = 796 +Msg = 886F0BBC8286AEFCE8684D589789A401EA5EC013B0F36CEB015860168458A68B66CE0917567D3401B6D3725F16089C9EF77978180B282D6C315B54A60D7E76EE1676C66C78367C2F3361EA0D7D88ECBCA4C4BB58381AEB2E5E061B6901C3684599B4B390 +MD = F0BF81ACEF373F41DAFCA8466058EF2327079F3AE33CEB486F83AA359C33A316 + +Len = 797 +Msg = 083CCE8161113669202D9028456FDDF2F9C911D06B732290F8C17F28675E71DFDAEBCAF0B0E2DFB89336B3B2AA6C21232949AB3567F10888437B8D895B4FD0E82D099C63B8578A51352215309900495A71BAC7B60FDA02318C381A984204532E031948F0 +MD = 27B105FD85024A805E8D13CE6AFCFEFA5F9801BE59887F100A3BBC184DD7F197 + +Len = 798 +Msg = 57E254FFFEB91C9E6625991FC2AA3083D47BE7A967E187F72EF31EE024FFD7754FCDA48C584948BC4411B166326299D0FE63D2B11A0A5F9395C88F3DBEEEC5E130BBCEA280FDBE851C48BCDF49A56ED9BA9569C244A9F7665E1ACC7921DBD8AB0B9ECE64 +MD = B07C48E426CCA1C8163BA659CF354715F5B8FEAD20019B43BC4F56986490E185 + +Len = 799 +Msg = 7425D92769338BB8EB433A25BC7CD734276B7735677AE2B95F5B485AF20D238C2EA6676ADE03BFCB54B4AEE8ADC461EE2DF2113987FE7BD3AECFE78EF6CFCC6FDB00C11CE655A2EE21AE4C9C0780D26999674A7C10FBC11780FB0D0C0E9166D34361595A +MD = 410A8522AAB2DDA6A5C5E6CF16E4658839B68E5334E19F8D609BE4DB00CBB4FF + +Len = 800 +Msg = 433C5303131624C0021D868A30825475E8D0BD3052A022180398F4CA4423B98214B6BEAAC21C8807A2C33F8C93BD42B092CC1B06CEDF3224D5ED1EC29784444F22E08A55AA58542B524B02CD3D5D5F6907AFE71C5D7462224A3F9D9E53E7E0846DCBB4CE +MD = CE87A5173BFFD92399221658F801D45C294D9006EE9F3F9D419C8D427748DC41 + +Len = 801 +Msg = A5E5E7F725AF8C544D93D2D409D6F82D3BF941D5F9783C279FC6156699A8D8D3133FDFBEA9FED5446315C33A18A93C006D2ACA4EBB4878FCC55970C477AA4E88D44094B0BFBF12C50CA62EDE8AF48AF3E96F78A96CC6DCD98480086DEC487DD003A4BEAF00 +MD = 5CE5DFDC43E6322B2345A8D841DE6E1CCEBCB69BB7836B8C0D8158A02684B0BE + +Len = 802 +Msg = DFD88A3F1A60E1B9A763B264CFF5CE6B34ADC92B3CCF29C6841D261D0DFF42415D10E3FCD96EA4BCA762BF5984B06F9DD2359538C6EA628D6B810DE79A6E572C18CD3F49DCE1CAC943E9500E19CA2E5B71142B9AC511F240BE6523A49A37282189D4A69800 +MD = B7AD8C78499986DB7D65AACB57A05530BAE330270906B419F30DA058AF16B805 + +Len = 803 +Msg = 33054CF806168A875E95D33E5B58622BD057A49373376322E9350EAC04F7424613A0C86802AEA9B8FD7BB93D41CEAEE53A94D0B66951FE0C7E93E75659A2987833765901F1A4A20A0EAC3F8AA4DC6BB075017812ED4E8CF883BD23AD17EB7DE6CC54B21E80 +MD = 0BF60AA411FE0AAC99AC17B91D5330F4795B3E69EBEE72882C9A2FA28EC48636 + +Len = 804 +Msg = 7E8EFC3504D6EFC19B36327F55DA196A13A082688FD85B63D0C48369149D6BFF4293D120A1CAEFE18AC17F046B4196DB0D6CB4CDE7739727BCB8880E652C60B2F48668FA3A40B1C94BB393E09E14CB1591343C943874CE4195251D930C772B9439386ACF60 +MD = AEF903C9FAEB819DED24786E6CB35401BA851D4AC1BBC150A2371E15505BE758 + +Len = 805 +Msg = EEB67D90755792773D303BFD27895032E74F41AFF1B3C552A2F9707842AAD7745E31FCA6EA35FDD47EA99EB27A2B063B0268943E75E629073E77D7FEC8C2E8380FDD7ADBA292803B3E7BEF8D85B23B937BC2444AB69740497902A8767F19AB91C33EC65A58 +MD = 4926474171ABF79B1AE61022783E8DCD54112BFD45E0CA1B1978116D9743A9D0 + +Len = 806 +Msg = 9C433E350E1BE986080C5757ED51FCB47EB31D70A9AB061236AAB0907C82C9CCEDFBA2EA62DA2C783CF5151683015EA75DD545E79BAD38DE99B287D25CE11C657D507D94435984A4276D8940F4EA571FFC9B550379F6148C720E4B9133D71EE120B8935A3C +MD = 3B8DB532490AD4890623CB73F0DBE567AE629137F98A504B9DF8D38659640CC7 + +Len = 807 +Msg = 769CB7E6B4DF1D6A4E50461EDF4DD06502F2EC543E85A3C64CA6B9FE378E71B1A461AEB8F12A16D4B113CC688BD3E142968DA6AD191EBD84C6FD77268E11FA83E1B5A8D61B5DEEA355E5BE623ECC5C4C5B11FA0B4951CBAF741A674065368F761594D0C77C +MD = 71989E2170F243C4791205B1FBF4C7935F013EBEE4BBE8088436657629E98F80 + +Len = 808 +Msg = A873E0C67CA639026B6683008F7AA6324D4979550E9BCE064CA1E1FB97A30B147A24F3F666C0A72D71348EDE701CF2D17E2253C34D1EC3B647DBCEF2F879F4EB881C4830B791378C901EB725EA5C172316C6D606E0AF7DF4DF7F76E490CD30B2BADF45685F +MD = 2EF8907B60108638E50EAC535CC46CA02E04581DDB4235FBAC5CB5C53583E24B + +Len = 809 +Msg = 5972087DF84E1087BE6AF080329EF86D8823D4DFBCF32403E58F9F33F889C15FE13D36E327B78A61BA646D54933A7A7B7B55522FEB9C3748CBBCE5D9AD190A84A65CDE8FBC3195034D419F41B883AF393D39F566FEA0552119F0EBE6A36C80DED27C9E6EEF00 +MD = 5CE6C84BD1F82103E84491AC1F637326F7ADFF8CCCFA9D04A60AC7D8DB3EB0EF + +Len = 810 +Msg = 6DB3F5D3691D10F0FBF2A40E56C0754593762446B21BF42C602790F3F0510D14464DD730D0648591119B425A94DC7474648127D39AD764698E5690D82357D3396DFEEF12A91F19EC62C6355A363563E08BA942A4BD06E2D05FA5C9037F3766304A640D01D800 +MD = C999446A23BACC568F11D896A32E00891ACCCCB3AB02BDB75E424123047FD32D + +Len = 811 +Msg = E5EC70D574A9AF9A358F33A15CC8C3830879D52939E6F95A695F76FAAABB988ED2A7BEF8974957C71090D3129E773B56DE379637DBA6BB29E8DC3F7116B67B690A056F2DDCE0A3C3FF65A7217D0F6EBA4BA9F5641EFB67EE88BDD80F0172086A60A9ED322960 +MD = FA6160697E3229C04EDE2A007D9C2B9FE79E2292B2EE58C9FEDD375612B87C65 + +Len = 812 +Msg = EE5B52EF1C171ACEE68C2E3C4AB9BA08B91153DBA6C85CA817BC14E3484EB6B0E4D93766AAF37C3A571A52950EBE5DCBFBDFEDE238866EC6CF0B41FBD86518A07C360AD1BC4AEC074EF32083E9FD19B7F2C19ED5E7A0F162AFE1F1FD11C38F929C3D53BDBCF0 +MD = 0A0D6BD4ED6B19F7252F767D6E4BFE0A1FA9020D3A5945444F28C753F22C93A0 + +Len = 813 +Msg = C27E137ADDECA1E45434891C08DE549E79A79D148E46B8A99727FED7C28CBA6662BB9C8DDFC9E631E410FBFA899B2FEA7DD27CB49DAEB1BC51C85F3FE220711ABB10836F97B6A2D0D27010719C002FE8BD88406E051506BD560E945AFAC765C8ECDC0E476ED0 +MD = 737AC3E61EBC494CAC48B8C368255C11F7F5A4EECED51B55946C190011050BAF + +Len = 814 +Msg = 1A4FF48A014B9B9B73ABF97D0D6C8043CC542ED70226C9A06439251E676B59DFB775688A6AC7BE695A4C768F4A635186C98F7D87D31333BC0FCC3562B41333AB41A1495C615689892008E50C46ECD6F0CA33672219F15F0F583248A5283B3EEE67A750E310C0 +MD = E6AF688D65A0C60C5B38A83B505141CD2E38AB6AD4C18F2F8511CEB6E85FF4CC + +Len = 815 +Msg = EBFE2BB16E038B5E58D23E44300E75911B153B031AE0EA461F3AEBF8DD9B4E4BE5703F18E8205293E2E0415AED09AC41E8A5937FCDA3796C2997143F5DFB6B585C7652F1ACCB8AB4B6123196628880670D5B07DD989E04474372E32FFE65CC7192C42D25B1F0 +MD = 2A0E9E66E8E14E8DDA0C880610C4D4D15BF3873226B806F41C302836BF1219E0 + +Len = 816 +Msg = 006917B64F9DCDF1D2D87C8A6173B64F6587168E80FAA80F82D84F60301E561E312D9FBCE62F39A6FB476E01E925F26BCC91DE621449BE6504C504830AAE394096C8FC7694651051365D4EE9070101EC9B68086F2EA8F8AB7B811EA8AD934D5C9B62C60A4771 +MD = BE8B5BD36518E9C5F4C768FC02461BB3D39A5D00EDEF82CEC7DF351DF80238E0 + +Len = 817 +Msg = DAAF92F1DD17419CB8CFFC3B36436412E393C29822EACE765F18D5531BDB87BA878A816D73FA52842FF6A4590614E9B50C1FBA6CD3D538E8E07E1BB7967014D5E4906BB5CF070097D4B57FD44E705AE825A2AF35E265639E85C49323CAE2BECF48C13E400ECB80 +MD = 55082A7214B5240088297A7E58825A15063B14867A76A088F73CD37DA79D8244 + +Len = 818 +Msg = B5655245E132143776E7DF7EECF7590B09EC823EECC6E2E3D3E4724C4CF7264094A7CF6EFE235AE4CA71C11A64D020FE13F472259AF9D0C8773CB0FCDAF86D2D602CFAF6690854CB8831730529950DF7E65D8EE9CC3B4C89CFECF054EF0D4BF8404D8F9B849AC0 +MD = 6AE29691919FD5A093DE0E4848F9DFFE46AEDC9FD39C918B911147E5D477BD86 + +Len = 819 +Msg = D4A9D0503F80C8A4BE00A5A1BF4139B846DD1784E9547D30EBC6241ACFDEEC1DAD4BE6D11A8AEEC157D59F61972414BDE06D17CF56274547201A5F90C9EA82B64E88D78850C7F968E15AC8A82BF08FF53328A3E15DE615A21C28A3D42436F84C55F234EF23CA20 +MD = D38301C7965C46CA87A9E977D40C03AD946CCB79E326CA3B04290E01A29FB302 + +Len = 820 +Msg = 61EFBDF5987F9C45CE71F21DE495E46DDEAD02E679ED9C83A0613BE3FCA8660145F47340FF300657271024C3E8BB7E27F31406EAACDAB3C5F299B66C101B0083EF230A7283E868337E8699EE3A5723C42BA488B0FCDFF172E819576C5993B496BD768276A113E0 +MD = FBADF8F9B4946790BEA1F9EFFBA945664EF63E99B277027131130295792317B9 + +Len = 821 +Msg = 6674A76DB4DB544DA1D6FF5D7A01ACD0BAA446911421C7BDB19F347DAC8145337FA2220A1760AAF88A5803A6C2502E796BA486600946B60F2171E7EEE138F9A93CF7EA8785496B078CF26FE15627240D528B205054AD68E6FEB7F5F0B0DBA570A86A44B88FE3A0 +MD = 7DDAAD764C5C95374844C85777F34661002A59E9D132413EBA45D36328F2D5C6 + +Len = 822 +Msg = D5CDD6DC483DD693792AB8599E31F7E678E2E3F50E9B09DA1D16537FE21B8700B47CFBEC2F2B31C83CF612594A3D847B2A0497D3C1A4E78A75CFE94B850F08580D799921A2A105B7280B07629845E2CAE0ACDD43E62C3CC76F2BE06F11C233B32C8CB32D2CAFD0 +MD = 6BFB5E14D897D07BE45A29F4203898B98E68FCE784D8EC7A72F43802AB89DF5C + +Len = 823 +Msg = 95430200EE2A59BA3D4FF5176E9328EEB792F57838631334BA0D95862CE2BA8550ADDE662EC5689D2932B6637ECA4268861BA868C5FB08DD016DF6E3F5E8F7BC86C063F0B471A94BB02C999C13D8A89F2DC536ADFDE9048E836674E781CA2F5247A23FD280CE30 +MD = 53CDB6CF8567757C7946C9A3A79D5365D99AD550F5BCE92FA109D3A895F56FA6 + +Len = 824 +Msg = F13C972C52CB3CC4A4DF28C97F2DF11CE089B815466BE88863243EB318C2ADB1A417CB1041308598541720197B9B1CB5BA2318BD5574D1DF2174AF14884149BA9B2F446D609DF240CE335599957B8EC80876D9A085AE084907BC5961B20BF5F6CA58D5DAB38ADB +MD = 52CBC5DBE49B009663C43F079DD180E38A77533778062A72A29E864A58522922 + +Len = 825 +Msg = 96EF70D6957AFED1EBF9C5E3E1CA33DCEE14589C8AD2C7819B401D8C93473A06D0CFED12D4155488DE13496426F7808C666927DBCC54CD58F82A9D7879541D6F66FCC0239E89DBA84C85AA34FFE93DB632AFE2B490E2794F95A8A6C14706759688696354AF9E4C80 +MD = B96D49E84B4404B6854FAD6908F10C6E15DB9BE58E155EC7882C97E51E1162D0 + +Len = 826 +Msg = 22BAE2BE6335304E5F9779FA2FDF496D9636492A8B3E6B650420DAA6B45BE8B25A2F00045DB1364B1F69DF590EEF88E61EF2F2E11FF9903C9A484B0EFB2A65E2984710C71688A00A8C04AF9335A826FC0EDF197B3F3BE1AA4685BD39847A18B7F388C56D5CF749C0 +MD = BE1F38422DC757E7E1B8B27BCF11E7FD957E34753130AE7918DC98EFB407CFF5 + +Len = 827 +Msg = D076043F4045A478C51530D457FC950916FAEAF555C2B28E8567394D0BB8A3C7D8A7225E6C0C94D39D03F0F50133ABBE6F009302153014025FB4B1F7B8EFCC9F4F9C3EAB0608DB41095AAD0D2B63037F3986DF71D6651946EE9F18DF52635BBD360F21E2555C5020 +MD = 80CBD03A05E7F0327D8904D69232189D2CDBC00DA720F00B46CD25D91D86414A + +Len = 828 +Msg = AFC0DFAD531BFAD5320903F56AF3D1C6A1A7EEB365004B5193F48B3F1B6364B502B3E767BBEC8D3C8CB1888BEF939745427AF225DB0B80227382E93478D80798D6F7CC79E1229126763B5595747708412E2A1065468967AF88E87CA44BF7C70CD94D6C0285D77D20 +MD = 26B719FEBE8B5D91C3DF27D6F769DA2C156871F7EA885043DF4452AF0437EE91 + +Len = 829 +Msg = 38F33BD532B7A176B1BBD5440A6B6F34BA5EB710A4ED3B73195E79CB0D227258C97771B69CF8319D30F71A86B06A04D4F8F564044B25595FDDC559435426F6802FAC0A9B8EF02A66CD99E052320F3EFAC5E98F41DC62177FC5422C0C7CFFC845B61C93465BB61A08 +MD = 26829A633FA2985F5B5DDAD881ED67FCEBFB904760CD7C110D8BF23070B82991 + +Len = 830 +Msg = 4A1D225317981D38424F1CCC96F7D895EFD4DBF51A0B568BFDB33F81AAC34098EE0D1F8F5819885FCF53823851E2DCDDC4D42164E223DB7F0C8A25655E91D193D595D31808C1B11115BD5913548A2A7F7C954719A1EE305D67A59AB3EEE0BD1326D2C46FAB79FAA4 +MD = 10FEC90DFCA98D1D2E21836D6B49E0AAF14A5293EAB60D2A0F8A2AA6E788298C + +Len = 831 +Msg = 071E9535D8B487FBAC04DD0C720CF0902365F55279752F4A4AEA2DC849F6F596562DD874C2FBC90A0773CB9AFFD80BCDEB16673471B2A4EB40410CACA3D7DDDC57C727D3FB4D25DD147C77426DEF0A86BC0840307F6495493714BA9C0C3C1F4959016F1F81A5D466 +MD = 74BF8B9CDC80656EE3503776B1F4702427617221480E43BFDE529637D827CB8C + +Len = 832 +Msg = E35780EB9799AD4C77535D4DDB683CF33EF367715327CF4C4A58ED9CBDCDD486F669F80189D549A9364FA82A51A52654EC721BB3AAB95DCEB4A86A6AFA93826DB923517E928F33E3FBA850D45660EF83B9876ACCAFA2A9987A254B137C6E140A21691E1069413848 +MD = 3A8DFCFD1B362003DDFA17910727539E64B18021ABBA018B5F58D71F7A449733 + +Len = 833 +Msg = CDF3B81753BBE183F089CA5B99AC4DA2944DD2CA4AD5502A5FB27D51FB4C5DD3A73337F3CCCD5F3EDAC73F23BC14677F8862E94A9C899607E9CDD242D399C9CF2CC17AADDCB2B1FA86691B82BB3F80B8F53BE95B3806BA1D61555ADA06C1F16AA011F99CF8EC913980 +MD = 605DC4FFD6CE912E1269D62DE4CBABB61DA63B643FB25421404D299B5831A2B7 + +Len = 834 +Msg = 1719A08AE56DA8261AC8CC3B0E644425C1A4AEDBE7563BAF61591CA0462F4AA5D0D31CE15F9A616C8980017C0C886C80AB258958074ABFCACAC023E671D8509AC053F5AF9456C22D9A85BE4D1788DC12E7F14C076534BEEA7FA37921A4F1336B02721AD135B6E57C40 +MD = F92AD0A89F5D247611F9F6425C3EF929C96BC58BD3AC73262EB2D85F002C4614 + +Len = 835 +Msg = E483D597CCF87190A723FCB835B7D58E051122D6641B5A2BF495BC121B50A1D087146DC722D08785DA3690C569CE1E4FB0C1241E501A4D3E438BD598E637275B08A3130F13789F01E1F0B87317BA3C70155E6770060C1058C73966D534B38D1D99AB40C39810428000 +MD = 8F3385CE972CD1311D27D8FAE1B14DBB85DB4711E4650F4BD09E75F21D7A66F6 + +Len = 836 +Msg = 6C9018345E122A389CEF69E5DB5FFEC001A5D9BD4ED6A05C82D236CF90A6D4FF1AB5DC991572097413D308272FA40EE4EE7BEA95F4EFDAAC6EE20EBFFED180C9A002F491CCC42490B1E51A284E309E326F43530A5C2745E82412C6A6C7AB8603E0F264F8B9941FD260 +MD = D2FC4C582A0AA483F6FDCD0BEA63C0D0B1B59A0C25A9AFBF8A5A748627E5A246 + +Len = 837 +Msg = F3160A912C1F7C08CEAB5E6C6E94C50FD124F3DD9C4D8034D27C80B39B7B9BF130F861D365AD61DFA407A8EF91AEBEDBE23E9DE96406FF0C6C312553FEDB125AFD59F7711210861A5A476B293F3CC355425CB949C2E833AE4A30DD9B4CE35EEAEF2FBDE4FD6D32B660 +MD = 7275027BE5A0B4389F3FFB3A13E2C786D429B33C5FF1786399C5DAD25420213F + +Len = 838 +Msg = 4BF1FAD35729900567FB4A3E0D5681C689CD0066EE0E97479A4A746F5E771517C42B6B827BFE16381CD52A985002160833BAC1AF81269F18821B0E6CD6C54AD33827BE5094BAFA6A08A67502714EF0101D5D91E8AA9AB81031AD2B6DF4963709DBC790ACB88A527698 +MD = 1EBCED66DDAC35E1CEAF1B5105068D4ACE58748F96950261EFCD4CC4E25F4825 + +Len = 839 +Msg = 195361302C2F5B1B927CEE67B003E885A4E1D4FAFD7D13B02F5FB743608902060CCBCB200A57B374C8D220828DB36CCDADD6EE2AB33EE53B2002203D632B36B45E13778DACE865A715B375FC8CCA7FDBABCB5F1FAC8BC2B890D5A460583BDC5CFEF67A0BBF143D3918 +MD = 325624004121A0072F67976F7EC23488A883A16F015472B06D1C8F3A6C3F4580 + +Len = 840 +Msg = 64EC021C9585E01FFE6D31BB50D44C79B6993D72678163DB474947A053674619D158016ADB243F5C8D50AA92F50AB36E579FF2DABB780A2B529370DAA299207CFBCDD3A9A25006D19C4F1FE33E4B1EAEC315D8C6EE1E730623FD1941875B924EB57D6D0C2EDC4E78D6 +MD = FA221DEEE80E25E53C6C448AA22028B72501F07D1FF2C3FC7F93AF9838B2D0A9 + +Len = 841 +Msg = A9C9225032B1662ACA561F01B0CD87798649F98A7C3C71F716AF72E55838536563BD092AEC04323328C107EE20D704D0ADC7C0DA8FE6598218078DB1D0F00874BFA7048039416EF082B6925623FCEEB145919D75C27591952EB7B363F784258033AEC75D5F3A9D81CC00 +MD = 495B712A5ABD6CAE4E435CE8C36772E18970312E315C5C824EAFAF3BEA7F135E + +Len = 842 +Msg = 1713AF8638ACE90592AC2B3BD76514C19F032C734641D29131412FA04ACD5C80CAE7FF34675E7B26D38488C0A5A34F88C36903ABAC06A319F59559C52F409C83C92CC07CAE1E1957F1B54ECBFC52F5F38F4B03D9573F5E2F5A5C7470D7F1F0BB4D356F13C4D401580400 +MD = A5CB86BB638F86836F0757CBAF33B845B62FEBFF8EC52011EF019DFBCE8D03F2 + +Len = 843 +Msg = F0B3C5E666BFCA1D234692223F77A6B80A0AF6C1E2456E8BFFE24147DC8BB7311386E21BE38FAC428447F89CE69BF5D399D4F10CFCC384B0643229D22AD5D1A96B5AF06743CBF8505C99171439E6F6305C28EC2D87473ED6181BD2FAB7C35610FA3D4B373D5683904EE0 +MD = 894F76989A753ECB43A24F0D32CE331B50F841EE333A6AFBDFA6A180CA940390 + +Len = 844 +Msg = 51F0F520821988794FBA4A96C05CA8128955155F49F5B1D4609C8BEB3796E606E105873C4E1A9E1A1BBEA9C037BFA266748DE15EF59A3698068B2F64E448661E528299DA53F217527109628261FE236227CE792C93C27A86B742023A91E9F4EDC9C16AF3F9720BD6EB30 +MD = 7BBB2A3D7B5C6D73ABABC8EF7D0F2D0A730D85F4184DBED9521CFAFC3F1D188F + +Len = 845 +Msg = 5A601FC60FF03D6849FCD88E8E124B8AC906EB9002B91465B98EEA0F1C638EC35989EF537DF63FCC37FC465C3AA0E409378786B21CD884CFAED67C00A4784DC7855FF0CBF4DC78A9FCA92EC641BC5EE01960E6FDDE2418FFEDC338581479B09680C1579A063E7D7344E8 +MD = 9631CEFA06F73B894377BADFB34BBD6F2D7BE73E824484291EA116E5211FC745 + +Len = 846 +Msg = 51B98503D91D779B7661CD7D28851F2F5FBD10D3FF1ED31743A9FC4B6D65FAA01E7385E0DE50DD1B4BC392D09CBC2042DADF5A827B305CE513648A46B35C003D6EAE1524379BFA009FD0CFEC537A5BE2516A524A8309A65AD93AC83B83479F4BA700307A7A1C5295CA18 +MD = F3C2E4CEEBEBBA8EA3506241282A6BD6AF8EC2280271BF22A1F59E0A9CD8BAB0 + +Len = 847 +Msg = 3DD565D9B8F291493D80301C50833F016FDCA70D35E6B66D8ED41AFD12B21AF8C675D487012EDC75A168124C9F7AFFEC4DD754A3B3050AF799D23E9322C328C61E131789DD7EECC47D0D973908A4B2706E3AAFA9CD9285470DD1877C164B12B9E45B7E8804D1C01CB866 +MD = C4054807C918150648C19C4FFD0A2B1F5BA683911F8B947E0A8FF6E5CA7040EA + +Len = 848 +Msg = 5954BAB512CF327D66B5D9F296180080402624AD7628506B555EEA8382562324CF452FBA4A2130DE3E165D11831A270D9CB97CE8C2D32A96F50D71600BB4CA268CF98E90D6496B0A6619A5A8C63DB6D8A0634DFC6C7EC8EA9C006B6C456F1B20CD19E781AF20454AC880 +MD = ED9C8B87FCE27BE4E95610DB1DDD0C035847F4699DFC8C039A798A30343A6059 + +Len = 849 +Msg = 8D22D0A3F113581C2C91A309747D3480D111FB0162796E06D48DAD005BD2275BB189B08A55FC56FDAC5D28BCE6F9EDCDC32EE464C1675C738AE8624CD20F7FA84A173329E3623DF7541835FECDB68416F665E4F5B4A357D74AB09EACD4EE6E3A301733536294A937FDCE80 +MD = F4422E22CA6C6555FA094E739DF73D401741F161B558A894C376A9AC578DCE63 + +Len = 850 +Msg = E7EA0B40D3BC92E9624256442D52F477AEBF8473F1742B50C80783548BA450FEBEEC40D7DC7D3BA8D2B03BD72CFE1E36FEAF85681D155C0F435195E7533BD6048FD0796C05F6BB7B539F9EA5F51C16C6AC74DD79C3842218565C4B46D85EC00FE324E8489FF25FF5DFAD00 +MD = 2684D4B11DD959E94DB6614759401BFF2A88B521EB811B7FC4BAF34777ED6CD6 + +Len = 851 +Msg = 60A997F14924AF0BD818AAB8FB4FE112B298FD0D7556A4A118974E1612EDF6F479C5247F4BCF1E7ADD3D1D485317C668A1F627E0181F9E6ED35C4499A487783CEEC5F7AD330EA18989700C4A622F578A4A04FE0DF9ED9A7E45D7E5D79E5F26A68B0CB8D5E5D96CEA36EC00 +MD = 0F6B19FA5C3332F1EC1BF9DB72751965B2AFF74CBBB892C55CAB355F4F7C3F7D + +Len = 852 +Msg = 162EC5B24DDFA48F4AA65289645F89CE3991040461A4240C59397253C89765295B27B12E19D5C1CF9080B45AA7BCCC14A0A79B3D7C428F48397EB429E925B4FCE06782DFE2487C6B0F0480B8124A15F6301259AD8211C3D859B705357E8D23AA92EEE769149F5171A33C70 +MD = 0EDF608A17586A5E751BEF65BBD43B30D6E422A4FB48E668114A9DE6762B8131 + +Len = 853 +Msg = D9C4E4068DD2D247BCFCCAEA5734472961D5C916EEBC714CC0FEE54141CC5DA3435CF8D492FE3BA399ED175911A195FCDFD22EFB57FD9D7D401C445B29AB330211E3103399794B205EC65B9658F9E425972C214ACFB1F1B481CBE2F4CA561564DA47383772CC8A190A1090 +MD = 2BDC2402BEFFA5883190FDDBAFDC51C657B25FF3074E413AF1271A8D08B97274 + +Len = 854 +Msg = 574493FD995F2E299A0794B67AEFEC00A2015B0DA8E8FF1C1913457580BBF6812551A2F45821B5C864B065E9CF8CD6A4B2C7E11B64F7F572824014FDA485FD6235D30E9B7ADA48FAEC98F6AF9E5022E422037AC57EDC00EA528181E780863EF47E834E0F457FF410DFFCF4 +MD = 089F41DD86AC700670C4F94DF48AE792E14FF5DE7DE4DFCFEABEB57A1B8C52DF + +Len = 855 +Msg = 3AEAB6285D74E6AF887D78B6A22059B2238CEEF2482D961A9C36A032158A8262061336ED09FFB7ABBD3D49B8EF0851DD5DAEC4970D27F6A69BCA5117AAE0593AEAD6BC6615D11ED11B057DCE996D614FA80DE96EA704C132578E9F20550659A6E483B4893122FA3B224022 +MD = 372E4DA57B4C03A09B8B59B57539B52EF7119054F8DEB4F48074283838B0115A + +Len = 856 +Msg = 03D9F92B2C565709A568724A0AFF90F8F347F43B02338F94A03ED32E6F33666FF5802DA4C81BDCE0D0E86C04AFD4EDC2FC8B4141C2975B6F07639B1994C973D9A9AFCE3D9D365862003498513BFA166D2629E314D97441667B007414E739D7FEBF0FE3C32C17AA188A8683 +MD = A485CC9CF4CA4F659F89A0B791A4423953424AC57146B879D385A9E4062AFE52 + +Len = 857 +Msg = 11ED52B37CB6F8AFF28BFBBB49E4E346B84CB02B5DEA39CA1409C16C589664BABCE3C7AB4539626907269657249DEA708A63E1073AD1E2AF1804E43472399B6EE58992638254B581843924CAA9AA3C461D09241E76FED2C282E07E95039C9889DD6383E8B1C941D70B5D5280 +MD = AB3B5F3125CF3F57F16EDDF4F1515564F36051D35B47E3136B9D1994C270CAB6 + +Len = 858 +Msg = 716B179648AD3C2346DED9AAE6968D91088CE60038DA2898BDF5645EA6EFB342DC043F21ED12CB2503743B618600B92EA66543A0B676165A2C161876E5E74917D1CC8E6649C51B6C1DAAD6BB39CE9362C1043C6A2DB31C05C64CE78FD3A33CA595A534FA036E40A89712EC80 +MD = BF6CB47ED00AC2B9DC58F30492468E579D3E90C12102FC5D29ABB2401F52B350 + +Len = 859 +Msg = 9FE7597F6E6F36CF0880765DDA6B7B9DDFD35B1C1F06F08A234751DA553BE2E54CA9FAA02751F6F44C37A69F666D12D80ECAF508185831DACB5014CBD3F8097B2D84DDF808CE2286C8D5502C3740780D2593B037A24A9A5A27C347E85C6C985AA933DD204E47D33EEE294440 +MD = FF223486DA6A0FF298050C6A184D8FBFF38B7EE20FD27D7657505B4E6588222D + +Len = 860 +Msg = DD644126DE54607B612C2384A80B3B47F3E3278BBF40372D7DA4C53003A4F7D39E845A7EC6E6FCDFEDFAFA31C0B13F8988F48F2329C0533E16C9C84FF40C123C421BFF9D8CC1B5561F1BD89178360ABDA3B29CA3870523D18FCAC8FF4B462C3C0AACDDD7FFD183FDC2E65810 +MD = 0B4971D7ACAD5EB55C8539BD841ECA62DFE8531D813CE71B7EA8824C9641ADDE + +Len = 861 +Msg = D5836C5A1E008D30DE039FB99096EB19D3A679E32D33ABBF7F414F37A9B1B790AAB4625D50299487BFEED13AFECD7F6BA9995AFE7872151431A04E04D101085DB55A6703858F0A43226CBA7343076690B2B97D58F1B39226F5353073F53C4D2B9590AFB71034B2929340F528 +MD = 6A90A232ED59910F2496C70E98441406B8140F445811E51CFE2A13A224906358 + +Len = 862 +Msg = 5AE530EA690D546A4B86ADA0775066C3C7C94A8F0503A0F1939EF21BDF7916CD3D63F154C91C401B9A0A875DC17927E2FC0CF66286C8A2B2139F573036CAF94B2DCC2B04598ED332975308B684330C8FBB7045690E25BAE8CF2015F9927C73C529FB699F60BB9D272BAD2340 +MD = 0A8D8BDF0CBE8D05C61AC2B9456A3CFDEDF57DB4B261D424BDE026C2683D00A0 + +Len = 863 +Msg = B24C20ADA2E35BF97724BB745334D4DF9399F22CC3D7E249ED004AFA98F4E2CE79567AAF543EBEF35DAE9D4545185B88BE1D33E2AB5E5B5FFBFAF00BC96AB6F4BE5A6A3E12E173884461C5DB1E67A81686ECCD9B45D69371546A28C50DC3B2D21EB097D20C14A7EC4F8F8C38 +MD = ECCF64A8BDF56E1E7B8CCC4E05DC130F81DCBA5556A00D88FE9629445AF8873A + +Len = 864 +Msg = F31E8B4F9E0621D531D22A380BE5D9ABD56FAEC53CBD39B1FAB230EA67184440E5B1D15457BD25F56204FA917FA48E669016CB48C1FFC1E1E45274B3B47379E00A43843CF8601A5551411EC12503E5AAC43D8676A1B2297EC7A0800DBFEE04292E937F21C005F17411473041 +MD = 93CD4369A7796239A5CDF78BCE22EBB2137A631C3A613D5E35816D2A64A34947 + +Len = 865 +Msg = 6C089DC0C0746EB94EE1BDDD372CB9FCBBD340F858EC3379B1B43C0B9F48E9FD66FEF9AD9AD5F9FE34E8FC385F1F23DDC6D4C6E4DE2AA2EECFD328EEE188955A5D8A3BF87A885DE41FCE956520867C43A00E36D0B6943B470B52584F5740058D78031B46DEAEF6BC9B76D02880 +MD = 90A4E7216C8452D1EB8F0BF92F7669B53BD5E738DBFCA4E4FE8FD687F824A09A + +Len = 866 +Msg = 38EF1659BF482F6DCE756B7D3B7F96AA8FCC7C25A000C590CBAD9BE30F5BDDD941352621883D0E5135766E147578D3553A484BD407011653DB0105CF28DD825836ABE332C0E04D6E36981290B21695B213035F4A39A7230B93A1174FF7D6107145273A42177F9649D5096DC980 +MD = 0296211CD2C739F7A68B3337823492326F93068B7693B69BA5EE9064366A2C53 + +Len = 867 +Msg = 1ED4FFE25D9FA1F051658E44DCC5299DB496FCF0BF7B5A0533685BE2A96198C15259A21527C83951DD8AFA04F65978A7CA01CCD6DFC6953EF152B8B112980136BDD47C78B8E8FD660BE8CCF67D890173529061C722ED593478ED4D2EF7FC0787E2E259045259EAA8152576B520 +MD = FDDC251295080930F51517C540E983586B2E745BA1A939EAA291BECEDC89834C + +Len = 868 +Msg = 4EDC5CDEBBAC7C80D4C9FDFF4D3482116A02FEA7E4311F6AC00E17383C6E4542D9F51AA753739D1250A955B37081BB573B0F06103300CDEC753C7EE544B36A735418EEF115BD4777871F887022893C4B51E54F90122BF9A06EE20448A7B75EB649A36D6E543765489B13A1EE20 +MD = C685E5BF466297404BA52F1084C15A81EF5F833ACF8C74EF755E9263A37FEC1B + +Len = 869 +Msg = 98450F06D846FF0F6DAFB7FD5A9E902537527F31FA6CEA70B8F22880A9DD01F1EBDF20884D235B884F438CE98B5420F195EC0FC4631FEBA8964141F28EED890522DD31F93EDEE85F96B6DAF92A85BE48E959642E922299FDE360F25B5BA2BBDF1AF40A222D09EC045A5AF5C608 +MD = CB9092C794E9D63F432E7E392578DC7D740CF8366BEB66500598CA5CEB03B2D4 + +Len = 870 +Msg = BD8C839CD9FF816E7D8706EB66F2FB60D3EA400394504AC21A3AB17DE594A26A7334A8F7A6AB5576EA8D78A6C69F1D9E3EA5B7AE20B2834C72FECB08423244FB7DB810CDAD3F041B54E12BCFA6678AEA075A366369525B195173665E78C0953EA46C4116D7EE9CEC0041A9BB0C +MD = 0282D99A60FD14BD9876B945D215D32D10C23A5F5492C860802DE569FD9D72A7 + +Len = 871 +Msg = A4C6DB6224A23DB87F291FF0B0C6C2A7925224594E60E1FAD4D4EDBFFA35F5EDA3798029C3BCE4DB2A78AB04C4A408D5A542237DCC1330AF47F0546D35AF06B2977DCE2678814E30B45418B5E97C6041BBC13697692C347769905D5CF06877A1EDCE1D6AB4F10DC0FB4F314648 +MD = A12A3762184C542BC887B42A0ED761AE044CF379211B265B41198BFE5DF35E33 + +Len = 872 +Msg = 758EA3FEA738973DB0B8BE7E599BBEF4519373D6E6DCD7195EA885FC991D896762992759C2A09002912FB08E0CB5B76F49162AEB8CF87B172CF3AD190253DF612F77B1F0C532E3B5FC99C2D31F8F65011695A087A35EE4EEE5E334C369D8EE5D29F695815D866DA99DF3F79403 +MD = 3751CE08750D927EB5C3AE4CA62A703A481D86A4FA1C011E812B4BC0A2FEF08D + +Len = 873 +Msg = E0473E8455316C13A301D697B9C17DE7D843F6203E669CF502F2E7260F0DC0717DF3AF7C64C3E28DA3A46C2DF401CD0049E5008D2FE32BE8060AEB272720585B8BBADB413547FC5EB59680CBDD68430B7937A5FBD3E83F9DC8D08CC928F48773A8166C4616C53B9CA0E8D56E0000 +MD = E5F196138E6D7F8E3D339516406E81AF2C7A727E7857BEEFBDD8FF35181DA03B + +Len = 874 +Msg = D9293EE8603E4D1977F7ED45626ED5498D7FE581F27BD0E62A8608CE5EDCB826D711830E50840D2E532EA5DB6E668563719B6FC8FB317C989C692C5C2964E5323D209FD600FD876941A0F8D6EFE5EED4EC8D011D6147B4E75E1062FE812A27A1D010B45E9FECFF24C55DCD5F8000 +MD = D54D5D8909BECDBDDD1A5C823E88D4F8D27FDFFC69BEEB7CC83A28F4C14512F8 + +Len = 875 +Msg = 885AE9439FCF219F75F227AFAE8AE85183C863D2DE3AACC2D3633D90020B9DDE7CDF0E5AE202FC18987F265F782459712A43FE2C4D435E64E6DA7F813113F566E4EF1E445E36AE673A34733C383DC421F1B13D7561A65BC9AF5779B9E65DD51DC98AC6CFE1B7412B53AAE68FD480 +MD = D8519C926638199F7A65A8B7079CC5D7C3D5F0744C317CD4340D4E4AA8C4B6E2 + +Len = 876 +Msg = 94BA5F913C14061E96ECE9E552301D4A1ED6C43CCB8F86392A0D5C4574146BC1EDF34CADDCC197F8AFF61C1DE42B92CFE24908D88FF84952E6A60BB81392AA7110EBDFEE2D3627481BCA009769A4861E7840D83D316E612A01820D1483B07E393E9C75022DE3D2323F026B0E3840 +MD = 1E25A00423F27DF1E87207A3F3E1E5A2FBAF0DA750E079A514BF55023C13ABC0 + +Len = 877 +Msg = 899A55982CC299EE96744F2A374850A496D86A3386CDEB1633DB5607174A8EC31FC881DA9B8E2137F92625F33A69769DD830F358E64E76605CE0DB6DD547791DE9F2D64EEEA8146D18C59F81B9FC93D91BC05FB85AEF9F2456668EC7A9DA0A86F8B4D607226713741393F744DC60 +MD = FF0E61FD76EB2FB4AD27F2DF72465464B549E5D776BB2B0822D0C8A649111B77 + +Len = 878 +Msg = 85F6897B45BBF252A97CC12A6E3EC901A05AEAE252062C04551573B5078F8C973A709CE932310355881CD0469D10CCED841863E3AB1646831F298D0732984B15FA085F65B484A5B31B46B5549486F95ACFDDFBE9C4523EFCE83E7817E03824E906D6C72BB17C0E4159875782EBFC +MD = 5F0F3FEC7E77C61E12109B99DA675A26315861EA38CB460D75C4C4C12B712B07 + +Len = 879 +Msg = FA5F18A9255EACE5136C5FD603199E3438A45618547D99321FFD907EAA47ED4F16B8B4A5B40C878D6C9804BBA983F007AFA7CC98C6A274D07139927CA2ABAAB6B22F65921268E954CFFEFBB1DC2B0EC09F5FAA2EFE0ECC0638601A94A52E15CE4DD3F01C1DC7AE530710D779F908 +MD = 668F97012C9ADEB43F5C23E551E7DD2D52A15E639F8C0A59279934EBE81C705D + +Len = 880 +Msg = 47C6E0C2B74948465921868804F0F7BD50DD323583DC784F998A93CD1CA4C6EF84D41DC81C2C40F34B5BEE6A93867B3BDBA0052C5F59E6F3657918C382E771D33109122CC8BB0E1E53C4E3D13B43CE44970F5E0C079D2AD7D7A3549CD75760C21BB15B447589E86E8D76B1E9CED2 +MD = A88C7EF7B89B7B6F75D83922B8FD00F034D719F97C67884121434447AE9DD3B9 + +Len = 881 +Msg = 9B7D4639E3400BDD19C7672BE23F354FEB221570BE8307942F52FCBD3045FD5A681AB50B226400AC6A213B6BCC0B5E9CB05614177F77BBE3F06CBB2E2F13C167478DB5779ECCB585E3E9391F3107DAAFDA2A6ABDBF91BCE6540960EE2F415D7599022B81405904038EAAA89E2D5F80 +MD = 9B728EF38E26649688735442C9056D0AAE2D8AF5EDEC9711B95C95948F868472 + +Len = 882 +Msg = BA02BF87C61CB69491F6B5500A43499483C9D1DA8056F30D0199B8AA52AE2941FEDEF0E8AC94CF8C7D1E6F1603D75618BE563D3303573263BAF5BC706D6685FB8D08984A756BE3A981DBD96A3FE38CDFA0206CCFB6456CAE650C829EC3A2480E165B3C671C70A2EE16460698D82040 +MD = 7122FD303B4FDD25FA84E001FA1C49029C01C299EE3A622639C37E06FD9ADA72 + +Len = 883 +Msg = 6C54239533A5FBC9617060FBD3C76719EE224823624739482FAFB1F6D7A39C31036CC8EA64FF265054DA2DEAF00F90207A2DB4691C8AA623651A575D25424603C682AF9A8346E4F63E74956E160C1E55BB7118DAF1D1A9FB390F53446823502680F98D279F420F2D614C2218D5E000 +MD = ED4EE2B43DCACFE7161A86386220D272E87B4F837B0E3140EB518B8AD2283AD4 + +Len = 884 +Msg = 492BB221C33A3D456C7B2A0C41C6145501451D247569F470A1F7637FFBBDA6FECAEAA43ACD76E24BBD607A55596C69060C360D519B7FE9EBE794769B7CEE6A5035265B069E641BF17CE887F0490C90D655F5FE91B95D46A1F5EB9138CBFD232DE94B3DF9944131D0C64C69E4652990 +MD = 76436B21516571FB4B370874BE1C6AADB995BFC7AA9D31862912DE244D574395 + +Len = 885 +Msg = 8F71E8CEAB8CAAC38430EC1E8011D9C81B73BBCF32D60A495CF8207876D5DE42526116A57352A7FD2A6F20EFE100FA4FE0575EFF13F205AE33D0C3345ED4D587BAD1CB2F6AE0A15EF6681D168FA473ECABA29EACBD10CD6C64702A4EEE21535E7CCCC0037EF1F4C0B6199C8F413D90 +MD = 31363B9902D22A6083F1851F14227DC05A0DA164C99EF02629066F9E561BBA5B + +Len = 886 +Msg = 0D7BF755403AD46BE09C7DD8FEC713FBE9D96B9EE5D7AF7AB598FA6C4D5EA86C29DD6EE9C7A8103E6D572865019E6F0909F86FA2E59ECDC5B16678CAF64217282E2B474F40F53007F71D4ACBFFA230E1D2313CB44C812D71FAC6EB58A30097D4336BAFA8332FCA1EFCD6C48E9F9050 +MD = F5EBC8CFA639074119C7AF891D35B32C636DA931BCB7360AC96A0A2E69C325D3 + +Len = 887 +Msg = 5E13D7C65724A037F7DC646FD1815767F3A83C69C69052FF6624DAC438967A7257DEA3A269042F3ADD1CFE53B3D1A5AFB72702A90F60EC5E02B1EDBD7121532E2DCF37D82B96184B347F9D4BD57AB0E1E086406DBE941E0660B5B4C18221B9939F51A4D242E82FA2FF7CEDEF196EAC +MD = AA5EE68B82CA1C0F900C9F5A5F45B5DD6DB7AB300CF5697E5ECD8A4E89CEA865 + +Len = 888 +Msg = F690A132AB46B28EDFA6479283D6444E371C6459108AFD9C35DBD235E0B6B6FF4C4EA58E7554BD002460433B2164CA51E868F7947D7D7A0D792E4ABF0BE5F450853CC40D85485B2B8857EA31B5EA6E4CCFA2F3A7EF3380066D7D8979FDAC618AAD3D7E886DEA4F005AE4AD05E5065F +MD = 2B4F8F9EF7D6ED60BB4881E635E0F887A51B0C1A42BAB077976B43D2C715E11A + +Len = 889 +Msg = 36069C92F2AA4915D08FC19E9818ED0DCF80157D3A8D6646ECF8B4A31ADC3036744FB8B70499E90C6C7E1D2C4BE35B81DBF5A386C7F69BB320A2450D17B56D641BC7BAAD77E5D55BB6E9ABE594E04A3676F056AE60082EF33D2A74380270F6116CB4C2DF973FA8747205553A8768DE80 +MD = F9BA6DC5C313ADC632D3F905A6A70CF532F31998DA545394E660D17F009A11A5 + +Len = 890 +Msg = A1379F64FB9DA0EF3D4F819B898C30348E41E902552B60E437B513A87EE84C2EA0652ABCC2AA9D32428D76B569B3ED9B3D937C93A02C22F8FF0E4A3E09D9C8A22B2CEBA9F8E921760E103CB12AAE2B1196FCF2E5C45FBD0C381ACF5E6E4A8032D59EE9E09FC4ED561C5CECFBF43D1240 +MD = 0A3204DC720CB39079904A95902BC36726FA93E6D28BA312AFDB11A84072C90C + +Len = 891 +Msg = 9742A31BAF76E4E828011592CF2D4C9A94BC16A6856726F2B3340E1EC6787A99AC6832E6CDD32A92B92BF10F976EAED09CB9B538583421223CEE3F76182E9C5B8066BFD9FC924848C7F888BB42019471062BA2C82D1A904E94D90288487A32133CD51D04603588517305DF93697A5520 +MD = A3BF5FF73CF02475248777BC2508C6495518CDAC1FFBA7E115546356B6525F2E + +Len = 892 +Msg = DFD9ECAEA5316F067B49D5B04A229C55B8FFCDBD1BB7B4E92B546887A5584730F3BD4DCB1CF8AD362E2301F5970E917DC457EB1634729CC9CD3EA362C66E20F29DA5006CA5D7F70EC89FC75CE1470C5C20B21838B45EE461DA1F42C257C8CE940CA5CB0C3822047D10C875D6B41A1D40 +MD = F20404EC42294AF3F35050178AF2BC050ACC82F6AFF9FE98D36984ED84360DE1 + +Len = 893 +Msg = 6AC7E1CFD4573ED4595189E12E5B963FB45C167BD56544CAEB461F6D03DB1084D14BE35233310F48FCA0F9D41DE619EF1E29C78FEE50B412DD4E74ECEC9FA6AD45D2D6BE7BA7D8D9381DC5060A2110334D84CA79235BCE5667B0D49BB4137E2E23970D40044104AB0890FAF8437CC2E8 +MD = 0CF7FEA38D32297B74FD619A4EC1FB8CDEFC43E76D181A655E60F8F8F71B5916 + +Len = 894 +Msg = 1257C5E3E177DEF4ACE316DFD5ABDDFD6BA7FCA241173927411F47DFE2E79FBC5139B775A912AAD0822B220C08521E0A25C8EE15D4F215B1663D92647A28AE0A2CE23F054E77456668AAB17DB63858B666A4638FADF6BCEAC8152E9BE239F0ED6AA404A1D1C2C55C14655D8E1B33A828 +MD = 87F0DCD36B9858B13CA460B403EC28200A054380DD8D334D0AA83567E1886B97 + +Len = 895 +Msg = F2E39862B18601C5C4EA3B13745BE51AB578BE0049C2B01C6D9C2C283532FBCE5C5FE7BD77C36400944716F53F692465BA1C70B28F1203EA123165C3993E0A371E1284C74DD37EB53A0043ED84DDCDED882E233482433A3E0104E6517E277D3A2D2577CD28622CA177D8A41443AD8F94 +MD = 8830330494B879D4201CA91FA494402B818DF0E914C4D17BB9BCDE32E7D1823A + +Len = 896 +Msg = 58D6A99BC6458824B256916770A8417040721CCCFD4B79EACD8B65A3767CE5BA7E74104C985AC56B8CC9AEBD16FEBD4CDA5ADB130B0FF2329CC8D611EB14DAC268A2F9E633C99DE33997FEA41C52A7C5E1317D5B5DAED35EBA7D5A60E45D1FA7EAABC35F5C2B0A0F2379231953322C4E +MD = 586CFFDC434313CC4E133E85AC88B3E5DEA71818ABCAC236F0AAE418F72B6CDE + +Len = 897 +Msg = CB1BD5900398E5753E85BF405F77C3C344F7F1775B59E7F8ADD11882A5B27FEEE9011DB75A20388EFA2DDAE78A82C8E5EC9207C149D383BAF293C2F68CFA930A240599B662033C05C86DF576F53D0F04CD105544CD5695DA321B94EA57BEC41DC9CE192B1343B2E1AFD541FDDAE1B50200 +MD = 1AA25286FA074E9B6C27CCAE93F6D3786DBC932D3ADDBD2635BFD697D6E721B8 + +Len = 898 +Msg = F35C7F97B4D789FFF4E7DBED0EA1B5B2935EA6889332084669255230DE67E35090B3640F3C6F375E98AEA92BF5B3618478FDA284B7DDCECF37259378DBC0BDC192F656F69F5066E91A2F9D285C5988D39BF8E163DDCAC828A927AEBF42B5F174321ED3B9A968655A942DC0CC37199041C0 +MD = 25C5D3ECD5E06D6A38E6478860E18858FE387F670E2CF6F7ADECD1FEABF2F821 + +Len = 899 +Msg = CE5A6C17FAE7130BAA565CDB84F919E7E1C13027B50F0E103071C843388F2C51B51E4D330555F0D919499110D3FAB5EC8D307CDEFC7D15CFECBDE4A06A36E1278C9D9A3D8238D4982F135C2DCFC0B28D10796A4979F9B4CCC5A81B35C1259A7B072FD17B46D555CF7C3BCCDD801E4819E0 +MD = 019C770ED500E68322BF9D54B53DDFB60FB346D00A55B68EAE42F6B15A77B38C + +Len = 900 +Msg = 3A7391401865505D3782C08C9291C87611598862E2632530B1AB50252D62EBBA310FD943A378AB3897DF53F424CED09986143C6A4B68B0818B9356343D9F6097407BFEE7FF15D41E73C50D4F8B38468BE9143F68741EC8C79A6F28D6B4439CB82A1E8FE59C8131123A07C4C5300FB19E60 +MD = 558DFCC29B4F97F62076D15A7415E0A9112E960D916635AAD0C58560FE06743D + +Len = 901 +Msg = 3DA31721130FB8F85A43C5B5656BAD56F0A0573CD32F3363E4E9E3B4A593A2AED2E184B2336844EC6C8E8D6F47002FD998A8BD63B2D405DD2BEDDCD2E4C0C0FAB13113147B381C2546BF513D6C2C0B3B860C170B680EC1A5B907D5043BFF1EED67EB35F6AFFDD0DCE5B17A5C1BFDC5CA38 +MD = 417DB1289315AA9D806057B8CD7E691CBEAAE6777DB6AC9A7C00F290DFF08011 + +Len = 902 +Msg = E582A3A06EC79B463562CAE62212DC63C40A4E76A6C06C08CCC3FF442229F217B143A0AD650F16241A94A65956BED1C2D2B57AB2199E130EACF60A92D1E9E5FA03BFD78874EA655092F3C07A98F0A491874523660AD80128E7CCBF7E8012066F18E00DA1EC5ECF397A38C747A61DC5E7A4 +MD = 6D1C9BBF996FEA51EFA9631AD9021E2CB2A9ED26708B2AA782DFDD710A2FF749 + +Len = 903 +Msg = 215D67DD190F953146EC654EDC04B574C1D080D1FADDE7FE272E88B8BECEE0EE9272B903C0CE25DDA82C99B2CD8CC6FB0BC554D78173859375FC85AEBA208907FAFDDEA3CB89410E6A8780E5B5E270B124A9940DA148F41C3F18B9696A6FEC1DB8BB81165F104CE061BDE070A8F788FEE4 +MD = C217527E8A0D4E6FBB289E9BB76B8A03857BCE483FE308ECD3E63D3744859D83 + +Len = 904 +Msg = BEFAB574396D7F8B6705E2D5B58B2C1C820BB24E3F4BAE3E8FBCD36DBF734EE14E5D6AB972AEDD3540235466E825850EE4C512EA9795ABFD33F330D9FD7F79E62BBB63A6EA85DE15BEAEEA6F8D204A28956059E2632D11861DFB0E65BC07AC8A159388D5C3277E227286F65FF5E5B5AEC1 +MD = 52D14AB96B24AA4A7A55721AA8550B1FCCAC3653C78234783F7295AE5F39A17A + +Len = 905 +Msg = 4E5FD6C9C5E693E89062F8D79B7479ABA27CD93729E03179804BB8BCE53F270A6D0F29604835646619485414C538FBB4473067228A4593340E30165A7EBFA7F470CACBDB9CC192AB424D7B7926A5A96166FA56277DEF34ADE6C6A7C31240F86981E30BB3F2AAC492B1850016B1F5F3622A00 +MD = D9E2CEFBDD986E812715C2E86191C1EDC43DDEBBF85418BD244BEB1E510E45F5 + +Len = 906 +Msg = 1DD8BA4977A97AF96F65FBF2BFD718E20C955313D9E08A8F3FB63B092ECA604C3D65C7B8AF97EBA322FCCB3CD0B091747DD1445DF3734A01611A2EA5CC6882CFEFC3FB78200A162744DD353A51F10EF43311B9F4340BDE9D57028ED8143A2DD7A765DF9DBA3446D8FDE72A601F0500E98440 +MD = C13036559771BC2843E8BC5DE013202AE72F7E52DFBE9D8124BD6B3E2A921580 + +Len = 907 +Msg = 94A8E87E831C5E5196512F3BFC03A72804F00A5F8B7814957E1109D7C6AE32149E5AB11D70C7AB52F5BB67C290AB1CAEA35CFD3490BCD8C48F96B7ED876D0D5357562E34B4871969BB3C667C11E67004D69232CF1FB054A2910A4A72DD158656A2C0FADAD10B708442128C0331C49032E940 +MD = C8A310B207AF643FD3EC8B11E30A21E96AFC004EC1C942275DBF1C0A24B25C12 + +Len = 908 +Msg = 15A42B05F9C3C1551DDBFB964D698040DFE50240CA07E7394DB47BC628A36A31880AAA7A1821BBEFBA965645C560046B296AE7CA6EC45A04E0A9741FFD88BE539E335AB26BBCE51F3958A4CC61FD3BE079B029731D9917802935330F68BE6358D7B8FC120570AFAA25B1FF54B7B0A788A7C0 +MD = F13C3C22E265BFCC79D944775FC6C0C5E76E652339A7CD1AF4D1A6E8D69FEA94 + +Len = 909 +Msg = EBB1C5063C59E47C5D879549E8A5180D7E764D8BDAE5AA8E570ED50557DD19B601E488106018079AE3F1E787DE14FD12F985B38ED7A9A953FEE7975E47218BA610B5060EFC67637EDD9E6A051DAEC967BC86CCE55F417BD7CC7732BA636E55FB4831B117644ADA00C8BF5309BD7FBF42EF10 +MD = 2452B5425CEAD395C99AF476DF2FF3F104DCEB8DD32BD9A9E62CCF6AE68C19E6 + +Len = 910 +Msg = 3C8BCFC309833426B1EF0BFD3E9083DC116F28F26FCF034A879F0EC0CD04BD0B2E2A32FEA71AE279D67313CB5293AC7E158D2EBCE4A73941924EA0785082B13AB58F71C620DAEEB7FAB6C85CDF2D40E0CB787767E8F2298553BA9C033F820AD312C12E90AAFBB3DCCF4D852F82FB3FC70664 +MD = F44B9225BD85A82F362CC5221C40269DBB1957F0E1E5C68C2A839521F61EEF91 + +Len = 911 +Msg = F34B462EBF8A5D882AE3064B434506D605D2750EF56D33020BFB47859CAD2D26C902DD26906C3AD53A2FFE99C7C0D5A0EE1081657E0B5341511C3177B745847C55805B59837967763A5535E42547EA81168A71CBEEA4AACD0F6AFB06B2B9ADB7675F6763BD142ED87BD8570567AD64FFDA90 +MD = 3F95610702EC5EF44FD01BEDA561AD197DAC9D0AD7193FFC6601871B3E81FD15 + +Len = 912 +Msg = 8E58144FA9179D686478622CE450C748260C95D1BA43B8F9B59ABECA8D93488DA73463EF40198B4D16FB0B0707201347E0506FF19D01BEA0F42B8AF9E71A1F1BD168781069D4D338FDEF00BF419FBB003031DF671F4A37979564F69282DE9C65407847DD0DA505AB1641C02DEA4F0D834986 +MD = B6345EDD966030CF70DFB5B7552BC141C42EFE7A7E84F957B1BAF4671BAE4354 + +Len = 913 +Msg = B1E06AEE75FCCE86BCF194866D0779720F1DEC50586F29FD22C2B7CA37F19D257492EA0C05CFA98AB7B42D33A53B78E5CF62643F0CF02E934B9B70224E0952673B572463F25659FC015851C73E3F040AD60983CF4A048BB9F277EBB18F4936064D73371D7FAD0AB3D1EBB6E7035CDE458BCF80 +MD = 97F0BCE31333DF5A27B4E4F8FEC22E4B8A4657D7E56B044D3B9DCFDA7377E11D + +Len = 914 +Msg = 7A8B81C5FE8BF2C12BC8E9E7A0894F837320ABCFF2972A9D7352DA7175AC7C5039D654EAC136A020334C956B49323918998580BD1F2987A342F905FDED93DF4CE76A91428F524AB656B24AEDE625884511484B707C3BB3C52E46428B44F8A87676BD73480DD3951E8E826EC14C24F52D48ED00 +MD = 64BC6CD88A3A2F258D82DA56A66343831B7762A977905BAC0E7893A7772A855A + +Len = 915 +Msg = FCC03C4AF57D9C21C777D2B4AE611DEE9F4653684AFB0AB0F98606D2CD2A43B24288B9C302BD296B702FFC8D88FDDFDAF830451CFA97407179E864C77416AF18F19617582317C70DB29834F585324B44333BC6076F3CEA3F3F5E124C7B259C482EB42BF5C85FEB3691A9CD5D227145A5DC6600 +MD = 0CA9CDB7EF249E6A79EA2CA2FCFF0D91B6798A0B2B3985E73432AC1470047146 + +Len = 916 +Msg = 96CCCA331611A6E0FDAF50A8E4C10967F1741C19EE95A11BB9D02A689971380DB8DADD0F8523C6A1D3F6F12875C3AFA0B6A8A1D961FBEE33FD48011DCB829036701FFF6B3084A19D7A21083FA8B08353C6EC5BE9584FD2D9CA6E63EE51DFDBC721740A43C0568F5A732AD5374C965B496B1480 +MD = F1B9E7AE6259036889F2118D771F2665ED29B227CCB05037D3A5C144E4277E51 + +Len = 917 +Msg = C6F7E76B2ED480FB33F7915128AC1383A275FBE15AE9C997907E11BEABB1E49C8C9BF783355CC3D8C9719AF1B0B94222956AAC2C19B0F68AD4CC2449412BF8CBAABB014D277AB446CFA90D0E3CFA1A1F22273D4AF4A8391DD3FA0FD75015F39C204CE592715A00036953401BECC68A983F8E50 +MD = A308ADEAA044F6182A7B82CFB5DF7E125EFE20572A5BA03F0B63A2040A660C25 + +Len = 918 +Msg = 9ABFB3294448A7EF38BC194B4E61027CA0671CCFEF6AEBCC0A706F15958D777CE0FBB47F1FCC3E470E878A991D139D02F89D36A54053EC3E370BF45E1AAB3B58B25122584D4CFC4BACE5F7282F25F322107E8043DAB875E8707F94358C6ECDFD96CCC09803756814D098EE3C4A7A8BC2D44398 +MD = 0CA5AEA064FE25FAE938C072F91DF4F1B94EBF2A06F1D9F79F8895A96161BBFF + +Len = 919 +Msg = 3EDA9C01C0BAC0A7DF3288EAEB878C44FE750F92EB7FC1AFFAA3DD1B492781D220E210F169B673EB469594C708C2A4297CCF1ABA5D2C438E9FBD91EFF1A0941564582AFA650F03ADFA4336AACFF855F49364D234842C907E7FCA80CDE686E545D5CE0CB43C0359E18155EB3079469ACDEDEE92 +MD = FC9E866098B84043F74029B87FED460DB41F28E3D325DEE029A0A48004E54896 + +Len = 920 +Msg = B55C10EAE0EC684C16D13463F29291BF26C82E2FA0422A99C71DB4AF14DD9C7F33EDA52FD73D017CC0F2DBE734D831F0D820D06D5F89DACC485739144F8CFD4799223B1AFF9031A105CB6A029BA71E6E5867D85A554991C38DF3C9EF8C1E1E9A7630BE61CAABCA69280C399C1FB7A12D12AEFC +MD = 0347901965D3635005E75A1095695CCA050BC9ED2D440C0372A31B348514A889 + +Len = 921 +Msg = 269180F685A910A96BABF3F6EE41D59E1A147773B610A81849ABA32B9B3F67D92CE4B575503C9CAE47F0B8D37BA66830952229BD64BD113B5055C1C4071BD749158188D343606C5DB34C3C1831087A0251868DE2F1689F358BC98832CD8C292806BF31A575895089B72004C037C8990CC845BA80 +MD = 43CD228BA170FF6CE0B79197B5CC87354E0DFC601C66E3D0AA51C72FA4B1F04A + +Len = 922 +Msg = FFFAC212A9A44997E7273F3B708F37B778AD53290AA2B523EB10181EAD0785918211FA5130C0BF333BB9EEAF35BCF8D3C210A041DFD8A43F9F045589218542B4FE2C63D340A968F0E21354D8C26C6B55A437E1C0208C1F53A2D32F13170AAB6978214F900C0FD6D7C589459C9506FD2385D376C0 +MD = F86195A58446744241544BD28E3065C13CE5E9D30C0D9F8A38E55FBACEEFA4A0 + +Len = 923 +Msg = 3B80BB9F2BB7659C2F3B2FAB83E68033EF455E97C6831D484BDB52850EDAAB4F89EF8FC39ECB29971F7349E5EF2C4030CAF069C40F58AD755E2D013249FDFD2D41583569634E0126A3272676CCF6A3D7A7429327923590574077D3A21BD282836D198AC6AFA14FD4A5927E594A9753509C8F1100 +MD = A0C4EE7B3E108EBEE66ACB6C506D049A04F748104E20B2074D3E8117C3A3E64A + +Len = 924 +Msg = ECD96FDCD43F1456B19C563E7531854DDA6A724CA160717E5404B8056322F7036D50056BBE1538F5128B72C90862A7A4C6AD3E5548353D88B255F3149C4097B7B412F5B45B27DC9E7293831A61B20BFE0FF57E7299CCABDCCB32DE6B006422A0B7DCA9630F57D58A258CC32D28F39A9628337640 +MD = 811CF4F0D6F43BF4E5AF13BA6F6EE331E8198175398A86624A412352B1B9594E + +Len = 925 +Msg = 2FC972D13E9ED60AD42189018D21F46A99E50E437101549A56FDF91C80A7F63B1CBDD3A1631502AD006DE0CCDE3F74E14BD189BAF6BB2CF936B619D9DDD644100E9603E3170AB7D0FA3B6D79AC15BFBF8FC1672B908E82EDCA7DFE5C7DA8B6A5004BBC1C1999164E95772DF1B5D5078EECBDB350 +MD = 05A5C57836266AC23A37CD2BD0773BF4A9646080BD12809C68E4DE0C0C877FB5 + +Len = 926 +Msg = 3DA3A0681FA83C46C47B8D2D8394EB3138C899956108F7C0534CB3CAECEC2527434B441CC79E580B260904D4C95D9D53FD45DEF4F23E90EB01EC7FACAD671DAFBA8D3E66EE650F0E7A029BE3FF2DEB340436D004E5910E65C28174155D8DA004059504F484CF757314D43426FF458303F1885940 +MD = 1E02434D280832D8B0B9C118B625B01DEEF303E3A3C12B32474BC3E0FE9CCCB1 + +Len = 927 +Msg = EBDB935B08BC0C4077D649A2516D0C035BBFB64D69B783BE8F12796E44707EB2F244CC27089AC2A07A7412486A7A18F895F1570DEBBB638A36597008ACDA55FD3D128406C9D46D7FA32F71B718E52EEE8AD83D6F5B5FD6C8078121073518FF83D582563FB4E95EBCC4A6A6100E030EEF9A82F616 +MD = DC78A5AD5591797E1566022CC09C796838F690E83412C6A1A6C73AB834EEB462 + +Len = 928 +Msg = 2EEEA693F585F4ED6F6F8865BBAE47A6908AECD7C429E4BEC4F0DE1D0CA0183FA201A0CB14A529B7D7AC0E6FF6607A3243EE9FB11BCF3E2304FE75FFCDDD6C5C2E2A4CD45F63C962D010645058D36571404A6D2B4F44755434D76998E83409C3205AA1615DB44057DB991231D2CB42624574F545 +MD = F0BF7105870F2382B76863BB97AEE79F95AE0E8142675BBCCDB3475B0C99352F + +Len = 929 +Msg = FB7BB870E78E7EBF63E1C4953C5948DBBD548CC952A4B6D4788E0D190B9ED9CE8702F2075CBC5DA62945F118819C5621FE22587F51461B91F7DCE4D86C076DCF945CE93764B01ECBDA86DEA3EF17EEAF0D5BB4233028388A70CC239D39A427941C77E19EE99C88BF12F9BD6E687B3A826240568100 +MD = F2784BF3B995A3A883C59AEF628E3A6D75870B052593E763ABA1EA997923B9AC + +Len = 930 +Msg = 04DA38CBBB45475B6B5EFF77AB65A7144AF92EAA062AD6AB8A84C714DCFCBFDD666443E08C1EA3D4DCD3BE730F7401760C6EB9EA600FA5CF1CBE5297F0D4F66671BEC146A58DE30E5547FE9DEFA9B96E95344FC8F32CFEAA4AE1D4A109964BA3AEA697FEB6B6BBB42AED1BB365E324DFF650764FC0 +MD = 2C629F116D83110530F9C1B1EC4FE50A1CA7F15ED0321CB7784A46D4523DF017 + +Len = 931 +Msg = FE876EA28A466698DD179787EA825DA434D02A0641099EA4CBED0641F15E3DFC2A37322A094269D4C590455C3EB8F019C8295D24A434FA4977FD078C691BB540C7CAD0B6E6284BBAAC1C8545CE00F71A494945AF86A4FE2AF46F11DE9C89EFDB17E62B9AAF4526BBB9663D4623FD589574529F7580 +MD = 00941AFA95C4511AD006AB4CADE1679041D4DF9EDDC0B8F9484EB72DCB4B09A2 + +Len = 932 +Msg = C4DDA8D7807FEF102A62B78CD4700A6BFAAC60D650A7F5AB6B377EF3936639EC67FDDDED1EBDBCD05ABF3EC0BE4980ED84E1FB536786CDF0954854FDB9F3DF27AFD5F350E4AA735FD9C32C790F6F424A1915CB115A37E6AEC3C257A974D6683E0CCE2926DFFBAFF8C0CAF094307733969CC6834520 +MD = D765376503A0728CFBDDD907732A05416B69B05CEB6890A0E0F9C65E083AE0C1 + +Len = 933 +Msg = 0E4D1948742EDD97D4AAFA0163292AF7899C469489A0DA98FC9AE4B6430EE112CC7F22C29904350A9C196C214C13C9117E8245676B3E5C7AB9D51120116B3CBC07026927CA0C33ED516796E98A0EF9865746DDE811C8B56EBE9BA469117D9BCCCC70204F1AAB358A703987EF8637BC85BE18A011A0 +MD = A8D3C2E4F4FAF5AFA3D798E38EA770CEF76486C5EA4B297F050F411426E4478A + +Len = 934 +Msg = 73E79155019FE478F8D817C3D5EF3D4F66D3BDB22ABFF76DE083A8E5CF1EF4F8E5C55917351BCE4AA707483D9302DB11DB21CC6CCCB4012B0980ECB76077CD0309775F7EC98BC40A27044BA830FF7ECD42825C7B7B28133BB732218234D9165372DC61261878776985D2C980C9868BD6521557AE3C +MD = 0964D0676C5A8ABD34015C2C2FC3449CA2DF72CA27652E192FCBCB9D832C685B + +Len = 935 +Msg = CC47E530D64AC0381DEA486BCE637E3B631232A5B55165358A0F9C2069C1A3AAD14302F2AF25FC4F4F40D41F708760AB080861D8F92EE65C1927326FD095EC52E45B7F5D67D4B4987C43FE8FE61AD6E5476535564DCE408606AEC8E98618B174542B530238A51AD13EDA91AAB7C34DA7AD2F28E50E +MD = 66F83C40337D57B7913D3B167486E02E1DA6508BD2FCEED70008ADB1D06F3665 + +Len = 936 +Msg = DAB11DC0B047DB0420A585F56C42D93175562852428499F66A0DB811FCDDDAB2F7CDFFED1543E5FB72110B64686BC7B6887A538AD44C050F1E42631BC4EC8A9F2A047163D822A38989EE4AAB01B4C1F161B062D873B1CFA388FD301514F62224157B9BEF423C7783B7AAC8D30D65CD1BBA8D689C2D +MD = 631C6F5ABE50B27C9DEA557FC3FBD3FB25781FCB1BBF9F2E010CCA20EC52DBC4 + +Len = 937 +Msg = 0033695F13910B1E68323B64B7FEA6E291C07DE47C448174C72E53E69AC2B9281E6D6703BE904F601301A7A92012BDF1E7AC0E389DA9E420283FA96681B0495B250CF11CEB845903468DC2B34B825294596C86BA38A41B636E155B3CF55A986708DACD1034C62A0BB3449322AB57A2A97DBE9E93FC00 +MD = 9FBFA16F4CD44C94C6C81641AE7596E0657FD61AC4C75A33BAA9FC36D0467D1C + +Len = 938 +Msg = 77485C2226894283A91EE91E83192068DDAF49E99FED9838344ACC569348BE9D9ACDE7CF447C0BD84FFFA3559A16C5F61912E4ECEBFFAAB31B3F5B239C87FC3EDFCEA7303E1C57827E8B45BA3B4F357167FD749EA101B15EF913F838A6CE68E4792F276BBD2784554B84703376891D951321D0C8D600 +MD = 664793F76A1BF10D7682A1DE4B79BA39160E9933D2262DFA0F7F85AD9750106C + +Len = 939 +Msg = 6C95A9A1DEA097D15316AE7F5B4A6D2746C6C81D72093614C9AC25AD1FFA68996FEB8666D94F453E9E405D42BE6C9757A94BA777566F054DD6315DA3DD837E70FC939F7129D1D7D4DDC3A7D5FFDDC54B60BDDAF2622060E8C5E5830794DDA711E85C52B4BFFA5F716BE50BC978574D88C579F2E19CC0 +MD = 51440BE99FD040A9FCA3FDC21747CE2812D49806AEC90DFA4825F2231615D050 + +Len = 940 +Msg = 4F62C87A0F5C45700E4A39D2EE331FCDF9A8C33E08E26CAE547306D1FB80DEA35A6E58E63839BDBFEFFFB1C35F80386EAE52CCCBCF61C835E9E6505DB798AF26D42575E021B96B3F0DF3405B817833F3FB4B89B941B8D88BF9D6E467A0863BE72D950BF006CA84E3DA31D71D562A9F0D8231C76CF5C0 +MD = 878C294E17E17CFF835954ADAB3611458BF8FC4A1D02175E7058DF5714B22044 + +Len = 941 +Msg = 5136F1DEF48BF98D5FE05CD02C2309F994156D650FFE1583DA3ED50AA9B13BCB0DA8E83C68B8D331672110B25EA928F4D20D869E444B3194C044C09EFD66D966964A3FB446D6B0F027EEB79D50DAD6A5F0005B19FC68F140D768488C0D401B7FDDF8303E0FB8860A6847CD453797ACCE3C7C35ACAAE0 +MD = B52F9C72F2D48B540A9672268A204EB6A2EEF46982AE15605A0F18CD73D3BE1F + +Len = 942 +Msg = 0F9EB1E210E28319D732BA71FBE8B3A99E337D3F4FC3FD4959F51AAA15C2E8D7DEB32EBC69A031057AED466181089FDABA63B3337EC0960A0EFA3F5B257446557B6C585C324F86034448D0419CB538E328877F669CE2A03B9B3A6E5DDA904666F1E20B0ECD674B84E1AE14AA2278F18565CF8E37BDBC +MD = CE50FB68AF8E6A8692A838726A9A90BF95E6793F0319CFD89DB4A6982C9683C8 + +Len = 943 +Msg = 7C9853BBA660650A5C27C4C948FD65A67150FB559C5863BE944AAD3F84E946777C93D3D9BE3AD41155A05197ED3DB7ADB0BB55A55C69DE9A5896A5C677EDBC8DC4F3C50E22BEA9ADA9D21E6408D19974B7760037EB6977BD118F6CECFE7DA5240082DDC2FC2304A407C0B6073B70315B3761246B9652 +MD = 8A3D659675F99ADF385E89C3A8F82EE6072F215AE5ABBD22AA93682B736C5EF6 + +Len = 944 +Msg = 42E99A2F80AEE0E001279A2434F731E01D34A44B1A8101726921C0590C30F3120EB83059F325E894A5AC959DCA71CE2214799916424E859D27D789437B9D27240BF8C35ADBAFCECC322B48AA205B293962D858652ABACBD588BCF6CBC388D0993BD622F96ED54614C25B6A9AA527589EAAFFCF17DDF7 +MD = 3757A53D195B43B403A796A74AAFB2064072A69E372EE5B36CC2B7A791F75C9F + +Len = 945 +Msg = A154F2565761BFFC5589EA8CF6CB9C29F4C632D1471FC80534F24749C908C23E56505BE40785612AF08F921AD19348D2D2453649198265249EFEEACCF4AA3E6DD60F4970942FD828E25FD2F88BDC2274C5C94B7DCC7431715B3C2428AE7A922213F6485502B4BD84F1522EBD8795C549AC800FD99C5E00 +MD = 2AFE335874A64E4F4872430F065B5786771783DA4C6507409045B0A286D184AD + +Len = 946 +Msg = E7A82BA7364E23F5BC770F6C5D8C3B1A4E24B328943470700FCEDA84B8D316B716E2FED583D2324C17FF1E9EE07D72D42CF58FF159070479E6721E2031C9D7D94262033DF94CE492D6C64FEEBC7B3B1DC9F719D9681F51F25461D8693E7FAAEF05DECF1AE271858BA473577A372DD79FC9D1B0F69C46C0 +MD = 1303F6932DEE65D9865A219E62B9D7779AF916566866C580F94ED944727E8795 + +Len = 947 +Msg = C3AAB6905BEA639451D49C444D9D470D2F033C7D92405C2672CDB78E724D4BB7ADAA0C0E5A57A4B78F4F0BBD5B542D06086CEB0A42F2A6CF4B43745EF870928BFD22579BE8B5753328111BCB996B58F10A8A6D6C04806FB089DB9CABEAF212C9830BDAC08FDBA87617AD69B858FA1D5337273AE8367320 +MD = 9FBFEECE1E773CC36F53531F8C19D67A4D039D3056B8DBC7FC512F8CBB9DDD3E + +Len = 948 +Msg = EECFEAEEC17BC07F2EE0913E696D50C194C13B6A2738092E5BD5F30BFFD3BAE559F3E47191AAA333297475F113EFCB1B4A088471CD800934FADD0F5DCC9B1B67AC488B27B8A7D5408CEC9CDA91EBADA76C9AADA32986604E113790BAF3A4B433CD81ED3DDFB9DA9995E49BFC8B7A15D07B363AE8376F10 +MD = B6FC650974757605E6D3D2109EA8B4CA7CE6B6B542A65DE7FBD17838726F14B7 + +Len = 949 +Msg = 04A5269B1ABA9E44557BE500D16D2C5C830C9AF49D33AC8B0566BCD699679630180B74EA9824A3E9538789397FB6CFAC8961BA7F0F7A5B0181E7072C53651CF91451DFFF3B7FE5C00B890EB13A984C11B78F801C9EA33FF9B2A52AC71907B92F028D767085A01F3234AA9B98283F684065B60457BD9880 +MD = 5689A1CDEC392456547C9FD7A165316779F5C141962CDEA3F0AD427D0A915DF5 + +Len = 950 +Msg = 68541BF2F087D4505570E2C5DBD2FC596D938E57CC74980F5EF52FB229F5CBEA92481E9F62E92891A7F333E6581E21354FFF2C5A43899FF6BAA2FBC2E737B350CB5586CD7D7A6634BF5DD9B6BF4DB0A99021D432A0D76F16C74D4514013A3C13A88C53927B91411C7718931445913AD4C71A7B710DB168 +MD = 4481CE129A1B35155269C66692468D3B69544BD1298C0C8671BFEF6A7A66F992 + +Len = 951 +Msg = 2BFC949736AA36D4938AFBC3C01B604A7EDEE1C6D17EF3798EBDB86F9CFDE9C033DDAB4175C8F346E00E7BACC20DF7A52F4F0DF2744FC5EB9377E64BF6AE52639F796B1C15ABBB47BF938FB3D6253834DD680EFE244E832F810D315870F5E73BDF53130AB9C4CD203D828D183C5A954BEC1EF434B21BE6 +MD = 5294E055104CE23BAF581196DFFCFF826AA7EAA16BD7C12B6761BB495FB4BA86 + +Len = 952 +Msg = 3C9B46450C0F2CAE8E3823F8BDB4277F31B744CE2EB17054BDDC6DFF36AF7F49FB8A2320CC3BDF8E0A2EA29AD3A55DE1165D219ADEDDB5175253E2D1489E9B6FDD02E2C3D3A4B54D60E3A47334C37913C5695378A669E9B72DEC32AF5434F93F46176EBF044C4784467C700470D0C0B40C8A088C815816 +MD = 0CC903ACBCED724B221D34877D1D1427182F9493A33DF7758720E8BFC7AF98EE + +Len = 953 +Msg = 1E8E26C707DB4BB0F459F069840D28639F22CF740EC59D8F3BB840F7654642C2DB228259BCCB3532944D85D2F33BE1B401886E9FCF7101FBB4539CDA1E81529C160ACCA588E706749FFE70B20665FD4FD91BCA558E0D28DC03CF8469930CE8307519E8724373EAA2B6F22ECF04989078F91A2FE9A8E4A800 +MD = 6CB2D2859F103CC71F03E1A90C7220613230691C8F384DD8739D1D0A342686B2 + +Len = 954 +Msg = BBCE8A5EE8C0EB938B8BA8D0E9390B12BBBE6178ED29EAACBF92869F72BC157AA4F20F150059CF228399079449AAF9893FCF65775E5CE706898C4FC89DEBC86447C64A2CFCD22DBD2F639F199C1956571FD1C34A11609201F520921B1489F58B51EFBCEABF3CDA1853A7A66D076162A9C2053051BCA78C40 +MD = 6DE9979BC0C8636315A18A3A98611D3627A837CABCB832A26E053D7C5A3B3F25 + +Len = 955 +Msg = 036E2807A1F1675D8F01F88F1A5C34D664F49BBFCFCB60892D24DF43CBD6566BB7DBF33D47D816DBF244B7912E6A72740508804D3FDB4575B67D97B202DB80AE9A2B88EF84E7C74C3FB6A1F0FBAB8E62D96F76855E43D0BA372457A21503BA621CB52FF039CAA32DB99EA39B466CEA191287FA069118F1C0 +MD = 8EA1FF962AB37A915828BD0B74B4107C2810689120B6E9951070894D49A87680 + +Len = 956 +Msg = AEB50208D1F67BD48A95A3BB4454C9E4ACACF2C8935F2E48C06B1F73AD8C497FDB9F99E11BA78C12D83E93ED8BC34BF7BB27770F647BE727F0C92FBBAAB92DB31039EAA3416A8BD803470A531DE363254942F921AC597E949D95858FF42B6C7F385F90DCC8869A95B5E31466845347DCCA479B07D35822F0 +MD = 4D8F7278166B26AE6147B281639E955A45DDDE7E4B5322C774A26AB829E5D4FB + +Len = 957 +Msg = 5F69A5461117B8C2DE8048AEC04B2D0C7865A9107E3D90B7CCB3CB20B0E84FB7E162C75A766D7A1B9F6EF588581683B5CD125EA541CE47E6A78904D542C23F5184A64F073D931CC23690457AFD3538844914BA118A7D7C8A24F198CFBCC9675CFDFEC29F1E84658A0F8A344910FAA51E8D0719A9027E4298 +MD = 9F908B4045320D8E388AC5E905075759D4D8688608F6264002B8C914A98AA104 + +Len = 958 +Msg = 4116C941F3786516EF58063F0C226264F17037040C08817D86DA911C86B04DFAD0A64CD1BBF611EAA8C21AEFD71FBE41123090F71373B8BE43B1DBDB8758E63219CFBB7FC1F665834B8F5DB8FFEB5C8144E5ACDDB42AE73ED3848B933CB43E9CF7E2F77063D0BC5693FBC6775DDED5B57C0B70FFBDFE3AB0 +MD = 5913473EE9B34F6ABAA48D322F8DAB89B3CAF382FBC732BE4840F71EFFB9136D + +Len = 959 +Msg = CF191D62C44A107949F4D8E62C61069DD7771CD42D183B27314874EB19067EAC1919C849470B31B0DDB1D2886EFADBBD68D28B22B021F9A0F4890F02D7084EC08E3DDF0A14C0132FC8EDA62A786FA28F3092A517E525567F8EB512439431DBDDD4768FB7BFA596D8A04603481DD84740D296F8FEA8A52978 +MD = 8A3212B7A3963F5375DB5D543910F92F67FE20EDBFEB0E935412EDBFEEB0AA60 + +Len = 960 +Msg = D1E654B77CB155F5C77971A64DF9E5D34C26A3CAD6C7F6B300D39DEB1910094691ADAA095BE4BA5D86690A976428635D5526F3E946F7DC3BD4DBC78999E653441187A81F9ADCD5A3C5F254BC8256B0158F54673DCC1232F6E918EBFC6C51CE67EAEB042D9F57EEC4BFE910E169AF78B3DE48D137DF4F2840 +MD = F23750C32973F24C2422F4E2B43589D9E76D6A575938E01A96AE8E73D026569C + +Len = 961 +Msg = 9475609D6686B9DCA38EA5DE587DAD1F458D59F96BE790896A32B2AF82F897389BFED7572018883432007222720EAE42A654DFEEAEC1653D3464E28282D567E8E59CC6EC53FF6AB20052D2FB27FB8001313E75700F58D6339EA4C55DBAC4833DB7FA59E5512019DB87022F8BDE9A4366484C755B410A01AB00 +MD = D32DC2C5CD2C61A0F17AB3D65DF98D88CCF2163135464AA6B605A64DB6EFEEE1 + +Len = 962 +Msg = 61BB6E84099A381FA591A31CBF684DD9B68B5F752A2246E78FB57C016F66E43102C5CA5B0F19A7F6AC5A20174A7180FB9FB2B6D2DC8E4CAAEDEEDCC6F4032054E8B698E613B545D75AE10C0A344B656C8FB759B5A615DD6DD3EEF8254BEAB7FF03430E8DD0BF8FAA19A9F469DA37D943E71DE3B477873FFB80 +MD = C5D91A67D1C0684F830D84FE9555F911430432540BD14C6CEF51BA8E6326409B + +Len = 963 +Msg = DAC1487938375CDA49E04607C6B7A3CBC3AE585AA81B05F009353C52D4A0A9398E12F10E3EC433232C2FC21E46C614D085D1570BB70D107039C2D13A121B8BC45B0681A19D05D62CB582970B14E982F04BA4AB2B6C5EF3379FFF473592DAD92B61BE8E967A90F3E1D2962947B9FBF5DB7C48D8139ED85DF2C0 +MD = A8CB50C0BB21E977035DA840992849A38366290BD62177E44D070895776E832C + +Len = 964 +Msg = DCE3F8690BB3AA06BFCECBFFD4355049288C073272A503BB9B351D82062E9EE85E7BABAAF87AC25ECC2E3895F8CD1FBE2F9DCE21A4E9295BF1F8B0CB8DF98726B390D52AD21492CF442385959E226047BBE0A9B10D013E7AC9BB3D3BB89E262EBECC0AEA914D6375977C4E39E55063C73EEF6C8CB533D18AC0 +MD = 29FD6870D7A898B5888E1BD642C94DCA164A555A606D4F62D9631DBC6CCA4BAC + +Len = 965 +Msg = 1BDF288A6AEAEE17B671269B70FF9FC51F7C6B27A8B492C134D37CC217C225EABAD8A904F555E19F78B51E579D77082569B6DC2DAF8C30516B40611781ABB58DB528FFE79336F34CD07E0EA394E6ED982F5992EB89FE8F693B0F51F177518A7B42C3794AB9C55A02846F1AB250480E81AA82BCB18C173A6030 +MD = 99264B82909851AE505333AA8E64226EED2CA8D7BE1FB8E0BBAA1AE19EAA2C79 + +Len = 966 +Msg = 588FE175F9D58E6149FA78E460E72D2BBE43EC3EAE3ECD4E39B292B627B4BC24E87E410087317E1A9D0855440B56A036349C18FED313D01CD85B30B67973F7AE119154120C2A0EAA3174CC89D68A598347353DCF8AB4D2A5AF0E2B954CC0EDD3A5D3725D60A870351000A24E7B9EE126F54790C3649E0C509C +MD = 1273D991540C10D57CE26634D653E4993DF4E25A0086C03997CA47C9A835E87C + +Len = 967 +Msg = A5175DC9A97A1104E5CD368A1F3529A291BEB228E2CE94DDD8AA413FB6E860A654C95C649F594445F5F681484DF635D244213C8211C01DBF382942C3F83A6A1252E138529341FB45C06CB08B47D34E305390927FF9811933938B35297E63F668D907FAF7CFCC2DC3253A4BF80283AEFCAC42C63FE20D8F097C +MD = 7EC28484456C5FED8F7BCD64D81C71861EA576E17551655AEA4ECE2003EBC6BD + +Len = 968 +Msg = 626F68C18A69A6590159A9C46BE03D5965698F2DAC3DE779B878B3D9C421E0F21B955A16C715C1EC1E22CE3EB645B8B4F263F60660EA3028981EEBD6C8C3A367285B691C8EE56944A7CD1217997E1D9C21620B536BDBD5DE8925FF71DEC6FBC06624AB6B21E329813DE90D1E572DFB89A18120C3F606355D25 +MD = 1ECE87E44A99F59D26411418FB8793689FF8A9C6EF75599056087D8C995BCE1E + +Len = 969 +Msg = 8B7EC746D297783731F7FF197779A6C0E053A84D255D9B69CF811CE154510B7D829F46E2F8F1FCF3185DB1987C7A137FF644A05BC0FFE4795419AB82F43D2EE079335101C95950740F76A3324F935C84EF7A122665F37CC7040824771C3198C745B92FAE74133488A0417C5E13E1D8C64532160789B93DCA4800 +MD = D7642E070229378CA0DB224CECF5885C3200A8A5ABEC565ACF82D843BDCFCA69 + +Len = 970 +Msg = A94F24D5ABFF3CCC0B8D72C4A721E3ED82FC279648E6BA849CA895B0600A086241C7810DE204B25104E82A528CB2C43057CF3660551D04D9F737D58EC0DAEB7E3A4573EFE20C381D8E8C79B6868F6FF718E5D6CF0613256B651CF06A5E8B4E20C43D6B7E6BA050A1F9F60C56F47BBFD970C3CAEC91DFC13E7100 +MD = ACE3DE0827811BB36B934587F6E7304402AC1685C8D10A412CCF3E609836E73C + +Len = 971 +Msg = B9BF29E393C058AF5C3BCF93FED768EAEACD6CA7227E9730A2E78FC6C8E8D944967F2B412FC8B9BA8E3DFF001AC96B1E04AC0F10CD5207B3DBE7A493BCF49C2719AE0D20CABD072D7752F10EEE993373737CBBB33062CCB6C27A6606DDD8B7B57887ED9BE9FDF615D513830134867D039BD191501A77650987E0 +MD = CEFDA7FE976334C5DE8B563271D33FB07204D7C36F0F0B6D3888182AACDEA1AA + +Len = 972 +Msg = A4A5663566413E82C9FF0EF700F98298437A3186142E70862E19DEBF018BC209BBCF4B251A994A14E1A4F1C8B07FE4DF5AA10556391F3BDB6FAE11FC8EC2AD36EC31767C73EBB71BCF688F6122F0015FFB5B65FC9B70401F8B4118C8A98AEB287770029CD0BB29FC451E4F114EEDDA588684C4EC8D18E68E88B0 +MD = 4A922BFC39BBC6E757B47FC4C3316E4B381B9527FD84A4DD4E74F1CA61C512FF + +Len = 973 +Msg = 55DAED515EB96107C3C810648169BF65CB31CC423D10280C60F872855AF11088598254FE85EBA0C5776C787D314B5EF092209D354DCD84F85327A92C177AED949A6C2739022597119D1ED4808FE9FF2B1BC4FB2D902F79C6E6E5435A4F4737CEC79570834CD3BD4E9BF7F2A3F7E0D3DCD006AF83CD188D61A4E0 +MD = 911748703B203EFB39CC4B820DCE6020B32B7D8886C6F31AFD0F294CD41A629B + +Len = 974 +Msg = 107FE24AB253AD1B0100BAA74056A3637FB2A4CF89B13F618F947268BFDE6268F964B43C87C99D908657E9BA033059432A4DEA8E1748F7043C73FAE823B74CC10214965EC2F1E021AFAC25D4A3928C90D88CE4B881DB75DB5137B0B890211B9F1F89E262CF062223FBDB7B7831A320439B27013C83B564DF9F2C +MD = 08533DA64CA79FF3015FE3974FA3AF9446ADE8BC3D9173228AC7A983D379F953 + +Len = 975 +Msg = F6202E868BFFD3E288A03F4D334B78B723CC20F86FEC6AEEAA06693E3C6BD631C42DCE3B999051BB23EAC7500E9D94EA968C7BB0D63011D9CE2A4A58954EAA2AD8DA5A275E39453CAC036227E4EA4EF0712252A5F11981A63EEEA45BD335D33140208CB20E7CB2B4870AD4DFFB5E0E8C06D7E822756782B5D2B0 +MD = C43C0C183BDA8E13F2589E053C101E4CB94B33F2414A1BE5E32265A9E1FAD222 + +Len = 976 +Msg = 651A6FB3C4B80C7C68C6011675E6094EB56ABF5FC3057324EBC6477825061F9F27E7A94633ABD1FA598A746E4A577CAF524C52EC1788471F92B8C37F23795CA19D559D446CAB16CBCDCE90B79FA1026CEE77BF4AB1B503C5B94C2256AD75B3EAC6FD5DCB96ACA4B03A834BFB4E9AF988CECBF2AE597CB9097940 +MD = 71B4F90AC9215D7474B1197D1B8B24449FD57E9B05483D32EDBEBCB21A82F866 + +Len = 977 +Msg = D92EC59AE7D2C38D0D6C4203EB551D29AE72AE152241E0D42D6DA610B3070A4DED3051A3A607CAEF6EF487402BB205C318AF4C22048F1E3C9AE33B087C2DCE7A40F7D61BBB6AB8C0BF8EB60CCAF24CA5222A72967AB74A99C2096B8E432CDFA0F38E6BD59DAD95E1B0A5932328A36B62897E872A20358D79988D00 +MD = CCB959C41AEA5C490EBC61403566EE9AF1BAFFBA8DFEAD830848A39646E82042 + +Len = 978 +Msg = BEB1651BC96984876B509D703934E82198129E9F6F07492C1F37A6C8F8A7AF06D474BB23388AA492F41F589A0488C94FFF4BB6C518172CDF1804EC417DE35C212A44B65C73D236882327228DCEAC23BB05796735AE4AF05A7D837824CF6E4DC429963C16B2145B29DBA1516B37ABDF0C0C4F917EADC2643BFDB580 +MD = 8A4E93CF78CE4347BDCF10276DB0555D710F362ED8D576530AA9E475119D1A68 + +Len = 979 +Msg = B19714A2A02455CAAE27AE643E9725A143BA473B9A6A40E8557C23072F094404E0D22A4649264C064B9869AF35F01D9453F2B452AB469B7E794A60727B23C1DD83BDECFD8269DB59FEA168E524A9D7A9F700247C5965F8DF5A179FB667CCAFF1BB189D708E6D018DFB5B3CC16466B50B6E6244793887D637F60E00 +MD = 2E3EF7B4378801005868D7D2728429AAF1EC53889E4D906F01CC6A2FE1CC0F4E + +Len = 980 +Msg = 9DAAFFB294AE4DE0628718707F96B2714032CFC2B15B7091610EE876EFFFE498390F5625B33BAC592BDBCD5AC419F1C4133F346931BC2EB1A82A90AB5941FEE961529358F1A739894104CA8EBB3DEA22B492E81F2A8D7EBF7B208C2000F0DE664E7BC4B2792439AAEE2E796ED11D9DE254B583C5A1FAEF2BA01EE0 +MD = B6F24FEA8C192304703E6292AA2B1C7A478F814DB0EFB7AE02881D4A34019530 + +Len = 981 +Msg = 29800F52B584B675C62B0B26053A303D82E8707329E83689FF63DE1A55874D2155305FB332E49E49C016731B4CB4407D28703FF3CC40116DC5AE81FB8080F0DD8E29298570273C0255CBBE85C6236984F0FD0021A4951BD979ACF8C092485AF7DFBE4B98EDC81DC92CB2C3AEC62DCA758F70288FF04EC2AA2427D8 +MD = 2241314734398C0EB7136CB47000262772B7D27FAC5900A5FD34F67C786AFAD7 + +Len = 982 +Msg = CDE6DFADC607435F1D98A2E6C907869B5272F9CC63B851BEAE6185E4E1C08456C612ADD38FAF4E089A0DD4D8C74FD2705805F87417744938A99038AFA6A708BCAC88EB7723747099781BC44B79C35C00F0E609EB8E5FA65B197B3A6CAA4A1941CB5B9999FFBCE1ACA410D1F9EFE7BE43CFF02FB35FE893345EC070 +MD = 2BD846602F5995ADE5C00C10B83EC71C394EAC5ABE311DF1AD06E5BADCBDB872 + +Len = 983 +Msg = DECE0DCDAD18A4A646CFDF248D5A68171B9968E65F145574E6DEA421E73569DA82A9B941CA3973A342EA5AE80588C73489D3F42F28D347BA2FE9D67E0E7326BC3857D21A4AA0B70CE596072AA7979159F016AD11C28B213BFC467D68FCA254FCA30B0089AB52BE070704273853498FA055C7085696AF13DA063F7A +MD = F78DD313DB43C1BEC290951E6FF5545CD626813B388B0111636D28D2DC723C10 + +Len = 984 +Msg = 8AAF072FCE8A2D96BC10B3C91C809EE93072FB205CA7F10ABD82ECD82CF040B1BC49EA13D1857815C0E99781DE3ADBB5443CE1C897E55188CEAF221AA9681638DE05AE1B322938F46BCE51543B57ECDB4C266272259D1798DE13BE90E10EFEC2D07484D9B21A3870E2AA9E06C21AA2D0C9CF420080A80A91DEE16F +MD = 3B3678BB116FADAB484291F0CF972606523501F5B45D51063797972928E333C0 + +Len = 985 +Msg = BF5EA928E0690803906D6B96FD0EB1B2791C097B2E89A833CFB31E39925898AA6AC461F68585C43A4CA02F1E2E2E0079BAE65F93FEE50F0338913B806CAD9BA941D8A089F219635B170905D3C6564B9D8F30923873CEF618D44DA784B659F0A070454D57BB93AFFA4BD4CF2B12266F5BFA32A8BD97420DB526D02600 +MD = E06A736EE936760D5DA5DB5FC9EC14F0A3987417FC3A49761A0962FD8846AEBC + +Len = 986 +Msg = 8739B52698115E947D96E0F4B41E488BF1233CDC7ACC1B44A18EB0FE4DF8A6EDB47B5483B9A1389174753441289E00205C4CF7A55FD4D2ACF5570686DC12123DC4CD26DB5C6DE03CEAD5207BEE94D63F280CF40D26EBB7206122F34D17ABDD570A4494DCB665D40BA8DBDC46650B4166D2613D628B3FD1BB6A60C9C0 +MD = ACB9A6BFDBF5E0327D53A59331DB76AF8FFA644C861BE060BCAB03F48C2B221F + +Len = 987 +Msg = D610C8FCCF7577909810F3C630784EFCD2FD11F4F5600774977A55CF141CB15254237645BCCB124420F4AB52268AE4E3D128FEA4AF96EA09220874F5ABE331AFDBA7282B3108F5633D00EC247F862ACE4FBCE38F91A02C21B03136AD7FBC105A3AC0A49B08637BA4039FC3EF1FD2A82AC756FDE1C753C628CADC8C80 +MD = BB82D877D0EDBB177F86A464F33AA531E173FEDBAF395A30823D1F5A14310FC9 + +Len = 988 +Msg = 075487E9BA7B7C40CE8107A554A8940D6B041920A9124366D88DC20E2F89622E8A98140CC1F23AD25C71E6261D3C31BD9BDDB9A8DF92581350ED66272507BF63A6B838AC8099C31FF7832423B1B7B066706F318E5AC45F04999C5A29587CD11A21D3A96EE4DF76D5B25D5E5A978A79B67398FF6C12700A5290A4E580 +MD = 7EBAA4BEFD475EB1ED4F7A4EEB955DF1CD955B30E8C9111A48567F0D39A4170A + +Len = 989 +Msg = 102B3D774615C1D8140E59F3FE9AF4DF5FF0165A61E5D574244ACDFCF8F20CD0EC99B5E4D8562C2927E47395D7649461A1FE98C845F0164BBBC1CE42309B4C7810A49A99A16FB123418AD4B88B012B5DF7216402491A63B67D55989498F15A94D4AA6C55964EE0F557509C19F1A6E3BB76926FB6BBB5ED7AD6E23B80 +MD = ED3F6E91B9A657AA303679E9DF7638F339FEC7A15494FFB919B377C2F4E3F6E4 + +Len = 990 +Msg = 2E67063E542E25159C357C82BD71E869E7A1F1C364D9C4932C015EB6954E2BF55F087AF672D91BC3061933C8E94C6E524DE8FA2D85B7BB9E0C9C50ECD078A9147F431CAF3AB207AEAF57A10C20016943084B0225238C6F8F36C5631D359E6D6BFD29440A404C9607981CC8DD2051002F049F58FD3D08390B8DDA62A0 +MD = B08929B637170E57B30B6570164A3E26F759B5902D768FF7B95D875715CBA2BA + +Len = 991 +Msg = 335674F14CD689A1D83B1BC3568CD0F1BE5A8024349E5A863C40F3FD2B4DD49F5F13823C4D2F38BF87D4BB30561B21D99294E82653B98495E8186194D636EA00D66FC39EE72ADF537ED3C9B46377DA722097753957932CDA5FF77F0F756585CA7D1C98F084E90E96C1F7425D7B486F1C9844EE3A554B0F8AD620FC7E +MD = D67FEA66F6EB8924B8C095C291A16CDABF787DFCA52B207DF4A85EC88E2366FD + +Len = 992 +Msg = 53F918FD00B1701BD504F8CDEA803ACCA21AC18C564AB90C2A17DA592C7D69688F6580575395551E8CD33E0FEF08CA6ED4588D4D140B3E44C032355DF1C531564D7F4835753344345A6781E11CD5E095B73DF5F82C8AE3AD00877936896671E947CC52E2B29DCD463D90A0C9929128DA222B5A211450BBC0E02448E2 +MD = 4068246495F508897813332962D3AE0B84685045E832A9A39AD5E94C154D2679 + +Len = 993 +Msg = 891C926AD668CCD7BB7718C43C2E22A8E5C2D398B8287689326506EF244112D0A5E03B2199F85B01F10DA8C4AB881773BE0870323A0F1BEE0B340DE96BA0EEF086784B496572ECF67B31AFDEE367B808109609D8B997604C0DFCC54CBCB50297E6768B74A609536099B308D30CCB665DEF4033F12D48F7182AF000D900 +MD = 0C5BDCFD26909A5E260EB984A711BC2787307A51323F06F16BCF073D15940E91 + +Len = 994 +Msg = 0D5D9B2A4E8F4B3EC6B901A03AD1F0993E75BFAF629E94CCAE58470FA6411CD874CEF26955CB5ABDB3221BEB44996780E23962C7AD87A92509A98920F1A4486AA27387799AA3255F0BB56CFE17C11A6E9F8CB4FD4C40EE7A514D32F1231B63ED092310D99C2351DC50BC79439DE971F12C863B9EBFB555BA75CDB86B80 +MD = 87C729A9AAF7898B0CF8FCC324922D3CEC38C9B6322D52CBC0FDD41D4D42BA65 + +Len = 995 +Msg = C41477734638902C6CD4EFBADC2B78AB296AB64643D08B54FB4328639781993EFCB34777C3642FFD7FE95E773E8F9DD849243C0B268A3C1C867EE6674A303E1E8AE048B1058827C48590B8398ACD53EDF8EB6B97B036ED20AB921B9ABD644384ECEFD985135FE185D69045CF33F5FE18B6193D5B87E330D553999E60C0 +MD = B8400BB7EDEEE79AFFFB9B51F54D9CABA0F145A9378417ACFA202C57A6978ABD + +Len = 996 +Msg = F8DCEEBC6E71E0654F2C0AD8ABC7C07194E32BCB1655C86AA04088A083A675A76D266CCE0823CE15B5C8C059B795B318DFD115E51181414F4FC1619C1DCCBE909ED9A8154ACD44BF14DEA59E13E02C8940A122AE36BDC86E088A1725113560B5F6F3E33DEDE2495538F6D49676E0BD590C721674D55BE3B138DB3BBD50 +MD = 124258D92755413E54A361A4413C6CE1E187D0999C4A073982CF7BDCF9FC2FBD + +Len = 997 +Msg = B5A120C542550C04AE93A55997D6AC48A3A3CDD159C3151882BEA757AB79CE25892B11C2A6FCACC19135DE170AF6DBECACD6B0172F1DFC9646DA56EA3623CD6179F2F023D06952505731E85F4295833819268FA43BF3B00E5418D355AF79D830400E250E5F04CCB7CBDFDC20CA1F1534AD8D0C0AF78A7048D8CDDAE280 +MD = F727F71D5E316D5E75F478F3431C476AC2D5637BE50121412073F9CD1B4F58C1 + +Len = 998 +Msg = 29DBDC75C55797AF9D8EB7205B0BC8703B69308568C992E23FB33506F880857A02EC1D4B5149A0627CC898022F7C8F5429C5C7BCB0D6F8FE8802FEB85A5879CE613EDA128C473AEFBC11EB5ED774035A0A5ABEEACF72B4BB633389745C662FCF678C0691910110091EADC11912D09EAE4877E3B03A997A89261DEE46B0 +MD = BE08AEE8A13BE58E189ADCEB0A3C766C3B4EDA5C486EE8983FF6556A6126F7F3 + +Len = 999 +Msg = EFC078BE55C0BFF648E9FD2DD9A33B283995B7C4BD5B0999E804EDA614EEE19D224108C5081CF84389165DC607B317711D5D6ECACD080D272B28C364A609138340D8F2681CE9116E5931CEBF9EC81781E19DA49AC394AB340B6543C377BFF08C08AD9EBF9455030644E5A18ACC73CDC64EC0DC58785885A12CCC08D570 +MD = F01370488D9D7E2DDB55C317D12FCFF442E125293F57E77A9A23AAA0247FD62F + +Len = 1000 +Msg = A64599B8A61B5CCEC9E67AED69447459C8DA3D1EC6C7C7C82A7428B9B584FA67E90F68E2C00FBBED4613666E5168DA4A16F395F7A3C3832B3B134BFC9CBAA95D2A0FE252F44AC6681EB6D40AB91C1D0282FED6701C57463D3C5F2BB8C6A7301FB4576AA3B5F15510DB8956FF77478C26A7C09BEA7B398CFC83503F538E +MD = 82696259536520E5E4D47E106BD1DCB397529AAFB75878F332D2AF2684493F1B + +Len = 1001 +Msg = F8A80B5D707D5CB67837175D946F507B9FC4E58A809044BC4E61F4FB2D2B986E4169ED4708E6B2ED0C0C308148129AB65BE6DF0E9C62C115C003580B388D40F29AE4CB435F30C9891D595D72CFFE36FADC5E39FD5B2A423B528106FA717580FDDC65F0B405159BE436C049D22096E314059540D64362439FF04FF07BCE80 +MD = 5BCB793BD1610D665D5B5384969EFBD9F8C8326366DB92A94175686D0B06BA04 + +Len = 1002 +Msg = 881397A6C422988B891645BAFAFEFF2EAF4897BC1ED598C693B14FE16F33A553B45BBC4C0FE5F6327460ABC45A35D70427A867DE78BC7BB27C087DCF0E0E416C71D8EF95CC3FEC40AE699470A354580BDA8EA4CD21CFEA433CD2AD7A87DA309C3A7CA82FC80EC318CB7DA213EBAC14D3E8937C07B6175769451699373580 +MD = 7D07B704F0AD8423F9E603198972E2515B910F840352749A34FEBACB5B93D104 + +Len = 1003 +Msg = 2CA31ECAE38ECCBDD176B36679ECC7914EDE98BD88D3426589EE92A0BC1CEA705712B3D7CD9DD823A56F22F506966FFE58A2B6E10130B47401A62F67687E4DA182DAAD13226F08784A7DD8C8E1C1005EBC8D631D6A906C1C3EF7846298A9B18826A23F7A88BF20FA80E583A12D3A5A675998D5B561CEC96B9072E4169040 +MD = ABBDC3AC1028662C4FC47F8C69046298BCDCC4AC4514F5021F7A60EF89ECF6E1 + +Len = 1004 +Msg = E352E6FC140B3A9CF77DD2313ED07C5BBEAD0B6DB80C38D9667036AF05BBAC2AA8E31B93A63C98A966E13356FA8E6FC312B84D8FDD72A29AFBA5429D67521F9E650C0D68501DA50274FBFB946365FC6F5136F855B973054B8FFDD9237E8A88E955CDBF7762E66DC371F00E0AC8F91FFF6572894D2C968393EAAE5B0B68A0 +MD = 61A3820627C0B2780480AD49A0D2D66194E16D718ECF9F62A2BDE5724976515F + +Len = 1005 +Msg = 6A8303912378CC2EFCD9B9A67FC21041FB19CE06D716B180FB308BE88B7F3B3B089C833378D9D97C8D0B2D35F68C48CC25A2202565F8FFBDF926B2E99F0E62C7E7A876C25A58219A46C639D0A8FD12474A6EEFB717A4343F301E5801A8F4011FA7391F8C37386A3209B0E29A8C2656D245E60906D2BB0671402018CBBDD8 +MD = 955BAA0561F60006667B8CD349735CC1316D1F49A3FC0407E619137D009F2D83 + +Len = 1006 +Msg = 91B2A9D434D3EC751C5881B9F738D5F799B553D6E9D4B8F928C845D4113142FB6EB9BB3D10ED463D83782FDCE58389F2930FFB4AAE89D505AE1FE7370F45E2C4D52EE64BA7F1BAE453CE068B494880F83B8B06EAD4E41889F30EFF6780873E2DC880D1C0500E85B189143BC170231891699D1E42E80375EB48B8A64CB61C +MD = 3ED6724B67774CFF3F3E679B80C16A7B3514302D8E678F037E2EBFD00F0CF5DE + +Len = 1007 +Msg = DCBA43253DE673A87C700169DF961A6BB5DD1ACFBD29D882933E67CE38A28FCC270028FF5BA9F0CA3CB243FBFDA95955B065873D33C397969E0F6B6BED989B99C72A2C6732C2F4C9A50FF224EE7FEE4A35D008C89A08DD7A69BF0514F0B8418D0BA90BDB5DEC7237B4CC4756192B43587025C49D678213A77ABB8CCC6838 +MD = ACA04294ABA97422D58AD32FAFBC7AA3B2CC74E2AE7498CB3439A0CBE6038968 + +Len = 1008 +Msg = 0E3AB0E054739B00CDB6A87BD12CAE024B54CB5E550E6C425360C2E87E59401F5EC24EF0314855F0F56C47695D56A7FB1417693AF2A1ED5291F2FEE95F75EED54A1B1C2E81226FBFF6F63ADE584911C71967A8EB70933BC3F5D15BC91B5C2644D9516D3C3A8C154EE48E118BD1442C043C7A0DBA5AC5B1D5360AAE5B9065 +MD = B494852603393B2B71845BACBDCE89FA1427DFE4AF9CDF925D4F93FA83B9966B + +Len = 1009 +Msg = CBAF5193380537A7BE1DBF6FBADB77042397BB65E092DEB4CB80BE1B34F92C75F7F1665AFA86590CE2E72CC8B36FB7C0326E37C02D63E153CE92D8A7C8A0AE01B27B41338B21C0C5FBAF8F717D930A2259EAEF2A0151878630A4CBE4024F71C3287687333BB163B1A6AD90102796CC902FA5FDED9E8D036DED9F4FEC12D880 +MD = 8FC652A7195D12C375F727413FFD5F85A0979FA92E9FA306D66B2954785BC759 + +Len = 1010 +Msg = 2BBEC642C07331548CEBAB8CAFC7A9678156C6D9E0F344D76B924D029B395B5C5C9289793D84C982EA84048DB0241F1A765F6A62BDC005CF6D2A3DA487A83841624D2C9BA17B9D682BB07ACDD98362D58C0956FE14EA33AB66AF46369AF0017E95EFAE72877FF0BAE5F971CC1ABA22FB0407C56A45A29F8CF8613B84C8ED00 +MD = 5B3DF8AE7C0000B999208CDFD6F6E033F3CF0316B655C943D132B4AF093AC91D + +Len = 1011 +Msg = 4A51CD0024B4B64885B922480C07B0D8B5A0FB9333255262BF8D9D5184A2DA73FCCA3E41C9100551D7DE7E2C1EEEA23BEAF4C3D6DBEB9E776BA9FDFF1A12E2C0E1769A1A2504F9CF1D295015E0C302930865F873A81500974727D81B2885620CF3F6D84375E97AFED7CACEEECC4D973E99E398678807EA990ADE94BC6D3F00 +MD = 6B88D0A1F9AFC3EF040DAE3F3B57A45D3EA29337E3019B743C2F592CF9FF055B + +Len = 1012 +Msg = 42E9B6E6107B2AF444920DBC1CBB9CE206A544D8CE5BB35901428C12E417E1672663EC7AC0E880636ED2F6D314942BA1A5B8A130F5B27756721CAB6B07C210D4292D23B4295105259304659C3A2198F2805FC8E0DA23132E53776309BA28D98CAD0C50B8104FF35A67C609310EF324E20365E695A21AA751B60742EFE9C850 +MD = 26C8C2E278298437E1748BEC1E6399189A2016D0A11BAFEDC59ED67B06EC8E79 + +Len = 1013 +Msg = C1D22289C5BD9E6E58CE5DFD1E04F8554E21C45DB29826C2CC00C2930FA6523B6300849B3CF3F687156EE70BDDBA13FC0B159901BA0706973B231F1B14DE4E5D6B0530675318F7C9D58319A21D674C56983AA8633956318AEABC4F81C4A67068965A0C32B822C541562E2B73F2F77C1812963C16BF862C1E56F908379A28E0 +MD = FFCF162BB08682E5B0B4C2F6DF8527868326E5CBDF040AD16CDF14E425D0F869 + +Len = 1014 +Msg = AC30B8A0576A71EDCF7ED976281063BB934E29B0DA7149CDEBBF8AE7243EBEA77E669D0D831E9995F56DF3B3474D88D721DFC91AF2BDA84DDA53B56C8B3CE6FCC0D4858ED135A3E549B8EA79B8B9CA41B5FAC6E326B75ED57EBB0096A54B2C13421EED8AFA38D9DC88F0CFB71ADD6561F564F28B3BE0CDA21D045081B74BC8 +MD = 2672F58063E7E4E73CF92249118FD4B193EFDB733F78F9B516B9A2085368DAB0 + +Len = 1015 +Msg = CA1CB2686F67E663F17744F498F8C7191CDBCEBCB4C39E67C1136FE707E59F1993E908FA5CB3C31ABC31046B896615096905062BDC4A8909A253D967DD9CB47BFBA1817CDF7870D3A39F5E2C058ACA26C88871D94E3C10DAE7E9659C3D8BA1732B97271F1B41812A89644F3DB0683DFDCAD82C28B3C238B73602857F5DAC3E +MD = 8005DE6323D8C2A57368AF52B303DDB2AB73F4B9C7911F4D474A8F957E59C236 + +Len = 1016 +Msg = A62FC595B4096E6336E53FCDFC8D1CC175D71DAC9D750A6133D23199EAAC288207944CEA6B16D27631915B4619F743DA2E30A0C00BBDB1BBB35AB852EF3B9AEC6B0A8DCC6E9E1ABAA3AD62AC0A6C5DE765DE2C3711B769E3FDE44A74016FFF82AC46FA8F1797D3B2A726B696E3DEA5530439ACEE3A45C2A51BC32DD055650B +MD = D8A619C0DFBED2A9498A147B53D7B33DD653D390E5C0CD691F02C8608822D06A + +Len = 1017 +Msg = F27A756754DF98BA50E2A4EE3A11535C80A2076191D08CF98015F232BE0599317EABE4168C8A4ADC9EEEEF6DF285B9B00BD5730EFA61CFB094024D5B4C20EF6F8CDC1DF6CB6F75389905BB40F662C2D4D293E61E59A6EC2186600531E17E9A4D58F785029E6603B09C4AAAD31F0191CA3FFCB943A976E508F15918BAA7416500 +MD = 71139E48BC849D5ED09D287AFD4AF1F031385A3D4BA5E876CD88811E61FF18BC + +Len = 1018 +Msg = DC3A0D1D54DE91AF722FABE877CC34147D356EBB79F45F18F7BFB2772F53167C712FB6D6CD8E51FA6DD3D3E78E49C2B6489FC38AB0311FFDB36A5AB6B658FD02A4710B8897324163E3B233FA7EDFD672F44E1AD4CEFE2EAB06C8D8421D05D4F300DD967215EEC4A8AD9AF47F04D2C99C0205D6B66415B6DF4B7EF60DE972FE40 +MD = D28D77B7285B46A7FA2534914DBD835DF755BD7F505F6E095E3C92FDC932FF2C + +Len = 1019 +Msg = B39C004D0A5DDF2AAC50BD18F447723AAF56CB3089D8619AF0A86904AFAACCE22AE12C376579F53B5E63B16A37E710ED86A24F7071D0AE6D4E697754896BA7D647B7E10A0D56E5EFF13C4D213F20F34E57D2EE99E0232518CFF32BFED139337FA4FB8E5AAEAE68A6671AE852724E0978BEFB518B97E2DDE76760739CC0869C00 +MD = B5CE72CC252E590D8162CE1DF01F30201D76574D21BF7F6A2400C6757841A411 + +Len = 1020 +Msg = 25016111E052E9A09A597EE2AC0F5624C970A4E1A1411160E13D0D37F4F0013358A5DF1590D1215397BA8ED93463142D9194A0CAF5F6FB3C8BA2F7B151C764A873A6F1A529D38C77F1A993BC7E98D6FE7FBCC66E9F8C96AB7A17A728BA2FB01A017769E208802BB1BFD7E837709B408D3ACDA2CEF1127D4F8332F7933B664980 +MD = F863BB30BC6BB08AE67217EBD2EB7B0A713F0A9875AB29CE125029B66A27F196 + +Len = 1021 +Msg = 7E699CD10F06D8CC6CDAE2C97CB90DA76FC28E1349276390C7DC7388409B7AF6118F5F291559145E09A47C346B32C89DF8F6945C6C901875CDF143AB3BCF6F6CD122783900918079B193E18461567FABB6FD6B18266519C7E4CEFA79CA89558A5613B67A375AB603AA796F0F20A3D79E7F47ED84E996F23D9F3DAB645D30AD00 +MD = F83220A4824AA7651124C730AF7408A82F4E6097AC8FB8DFBB9C81C3A13646FB + +Len = 1022 +Msg = 7C5260CCCC53E47F31F2389A70B999403F90933FF1EBCDE519D5C13F98F5209BC1D3DBE907DF24AE4655F64DEAE48DA7F932805BBED5BD670CE1180A9CD095BFBE078316AFAC497D45DF3DEEA8BB092A8827C0E4C63F5AE2408465B22BCB793271207818220B5E9001B14FF788E992D5C70FE7EB19FD1AFAE93CF8D22EE33168 +MD = 7E29A41186D41280C7FB705170B7C5D5DC13F9AC78BBCABCDBB3055F06E4A06A + +Len = 1023 +Msg = 1B4BF91CE5B2317E526F4046E9CB668AECD040B0F445E74A57544BE2A4F8572C5BD363240474BE6E7285B1A094E0F938D927BAF67B26C648A4A2933EECA67B3610210B7D3ABC972A0A6E1698BF2FC8E53E50FF4458C2DC5D581F78CE93A7D5758B3779FE9C169282FBB5BB0FBB84253AF925D1599D63C1216232CDEAD5A6AA6C +MD = 3FB8980346623CE1C9B76F73393162C226C3925C2C0E6B27B28E04C1FD2C8490 + +Len = 1024 +Msg = 2B6DB7CED8665EBE9DEB080295218426BDAA7C6DA9ADD2088932CDFFBAA1C14129BCCDD70F369EFB149285858D2B1D155D14DE2FDB680A8B027284055182A0CAE275234CC9C92863C1B4AB66F304CF0621CD54565F5BFF461D3B461BD40DF28198E3732501B4860EADD503D26D6E69338F4E0456E9E9BAF3D827AE685FB1D817 +MD = D82E257D000DC9FA279A00E2961E3286D2FE1C02EF59833AB8A6A7101BC25054 + +Len = 1025 +Msg = 6EFE4CEA291F0EAB9A6240240558F1D65CB9570E0D0DF643146470CAD699F010D2E22AD80E1B5C0312B9615084CC515BDF63E5F4153D31D97322B6583D962FA5B2864A7E5759B6E5E5472A8EB058046170B9E6FE71D49143B2B095261A0FEE5254B5CC94AF47E54BC23AB122AF7662BAD4C908A80CCF380A64854FFF50E1600300 +MD = E72D4E64975A9EAFB60651495386C620CE3F924FB4C6B38050086BB3FB19F2C6 + +Len = 1026 +Msg = CA5E7C549122799F037C32146F540EEF7F559847000F24429C6163D88BF3FB8D8A973675A565340B84317C49F6A998125F0A0E282F9F0750D167DE1B52C2F17BE54297910FEB779639436FA5A07B56456EED08C838296FDA8171854208C9DC9EC982A5AF9B407269E89DA2DEBD8F26020DD91232AAD4D78C1BE53D1E3261FC3380 +MD = 3C397240AB0F97B174220E2337A9F55FBD87583B6F330AA1B832C8D805F97380 + +Len = 1027 +Msg = 7CB99BC76B5B91CFECC52A2D78F09B63364DCBC4055EAA2CE91714BAB67F00B832E8DE22E9CC577C1496B7A303606789429D1C13DF87773A36D03EB33AF1C7500B6124FF3E2097A79D601453A635294C5F5794625363AF403E49B8F7823704C3F4A1F33A44614CBDE133073FC692F7030F5B2564E509BB84CC65632FEE1F35D980 +MD = 7623C1AC02D62A3C0BF67F9D6A890BD5F958DEA001E5988CAE93B0699A9F3A8B + +Len = 1028 +Msg = DFDC85887AA85D70021BBEC37A88C783BE70256A977A14C11B5991ACD3BE5B8945ACCCEB2774E37B8161E105E30F3DC38E2A610EAE923ED300C56006E719F4BBC070E04BC14267612E0ABA5F08A1C7C5070DDC31E30E2B6ACA6289CB509B356B6D67A1BDC383A51E70F689B0CE6F333216AA76209FD23C51E65BA2D04829308610 +MD = 6D5DE2A1B8C51016FB886939917E739BB702B916E6236132E6F2821AC081D9DE + +Len = 1029 +Msg = A4490E4E8AA88667CAAA47DE7E8B1CEC83B5C75D883465AC3FC2C875FC068C2857D295B17A64C91861C8D091E54BBC30CB67C27FF77758FF6C976EC39ACF03B0F16E53320A4BB00F3B43D9ECE4151CFCA00C5D0F010165AC8F78A31F6A25F978A5FA988351F7B14EED3D72AC36DC135E86B44A4591C25C7AF98D88032732F9EF60 +MD = 4406A05FEC93D3986C199B6E5F4AADC21F420E6C9A8D98E5DE9B6F19CC9F8E25 + +Len = 1030 +Msg = 254D2D7947E9A7079C88937766191C20706B2B550576C82ED60B25CB3D262A42E458AD0C900080BD9DE109E25A414644C9CD8AD52554F9519B46952185E04C2928BE22BC07665F04C02EFC5A4EA79A6FA631726BB98EB903AFB014EFDE7DD1261D024A377BC4DCFEEC04E3387F89BE8CD10CA73D1564666D2CBB439D3F9141E4A0 +MD = 28553BA3F5E85F928C44C8124C852278E6A19EDB8B1DBE84801D94644F16F4FF + +Len = 1031 +Msg = 78EE5BD77828543846085243397AC50664B2C96499765E491E3ECB95AC6A969B80FE3421A86D31FFE267DE151BA6FD7723CAF30D3EB7EE316B3891C24F8456934AE808DFDE484C421A8BFD3F60AAF2CD2D52B47A6F57875BFCC41A812E90D883448955BE552E351DDD41394124413321435188516FF1D9A461F282CFB835EBC862 +MD = 50AB697A29CA2CEAAB523A193F3759E6B6E27353AD056D92AE784861497C651B + +Len = 1032 +Msg = 10DB509B2CDCABA6C062AE33BE48116A29EB18E390E1BBADA5CA0A2718AFBCD23431440106594893043CC7F2625281BF7DE2655880966A23705F0C5155C2F5CCA9F2C2142E96D0A2E763B70686CD421B5DB812DACED0C6D65035FDE558E94F26B3E6DDE5BD13980CC80292B723013BD033284584BFF27657871B0CF07A849F4AE2 +MD = 8D5B7DBF3947219ACDB04FB2E11A84A313C54C22F2AE858DFC8887BF6265F5F3 + +Len = 1033 +Msg = 17934FEEFB19AF1D162F47DC010049B39C84AEBC5E11D43D9B46F843CF75F8128D7C655F10E7A815E9A6339D1B427268FE1D16B803E1F1C9FBA0C76DB007B520D821FAF833248F539A368ED17396DAE14C85009FAD853B158C1C48FB06006465367E3ED31437580E094E25452FF26DBAC133553D3BD22B7C1578E314BA047B799280 +MD = A4671A708213291E78E743D8A23A1E2B80532FCC7B293B9CF102BA89EAFD0FFF + +Len = 1034 +Msg = F828FF08E8D707D43B3D19E6528A3E0692259A8BBCD079A4030EE0A43B095E7C508666123E7DAB54D93A71A3A67C8013EA2E20AE0629A62242FE190F7891BAB9234CBB7AAAE3AADE2E427224D7A018B0BA866AC05FF87A7B7391FFECEA5E94E66B62B63EF03E314F06F3BE2E54CA6339B6DAE797D17DCC78BE7144C54B670C5B8400 +MD = BB20699452E161F8AE36C5D99765292425D18F490A6126A806D7CC5D4DEC0498 + +Len = 1035 +Msg = 3CE70939498490AEBD7EB61AEB4216954AF123E90DC7EFEAC7BD364085BB7803B9C0AB20BA9EEF065B301B417FEF08B994BA4D2B52C75EDDBA92A57D3FBE962A5B519A0F3B1FA3ABB39EDCE126A124741842C8F745E33D1ED1B082AD01D86007EE431A8774981EEFA9286D1D256F75624A59C222AD70C012DCAF8E19A7ABBE27B0E0 +MD = 4BAFC1FB85F1E447BD2AB383EB01568B869FBD7D088A23D91C82D75633C9B42E + +Len = 1036 +Msg = 0EC5838E1DD9C1E01BE54B20EA20A834D4573A4F4CEC151A40EC8D1D9F97FA536EFFC957AA86CC96616C4BC5BEA6F15820E9E1BA794674309ED6B90D40394D644D9A81220AA7A6EF9645ED760375A3EB3F515EF80E2ECC816809EE4E0ECA9A41482C1DD65964EC78B3566F8F5A9C7DD8746A66ADABACD2D827331CDB3CFCE2F94CD0 +MD = EFB5608ABF503F99D86182FDBE874A69F064D291B81F69DF2760907099BD7F0C + +Len = 1037 +Msg = FE5F59C765736017B6105040F249FC5B6957FBA1ED5E4A4F625C7F4B9EF7B6F2E24ABBC543B1CB53EC8B52DBA94450B13893320701FFACF1730073752FFF295DA40485F8B8DE9B3F7B1FEFB4C1E07564022A3DE7F102FCE0F37C6DD08220D1C39537DEFD9DDD87ABE6833C4727DC08E81E2DED23CADC3D52F28FAAD89C69BD66B998 +MD = 0195C0017F0E9060FBBE9103B193471EDB35D3800435C2F93FD8BC9082D6B128 + +Len = 1038 +Msg = 964B2419D5D9D2840AA6FF56B88321D60320599B00852613C563A501FDE3C14CBF4591759FB6CB3BAD876FC0E39DFD4866B9978B65EF92ECDE9FECF3484BEC6A125D0ECFFB00ED074C2570CE913C8916EB3A7EDA6E9D70E133C0E61879CF2AFC0F4D2A3685A8CA979621D80100F6C0B2ABE9F9957D89724180AF98655CA7955D428C +MD = EF51A37848CC9FEE4AEEDEBE198D2ABBFBFF0915366A968F9E3BC6509F563767 + +Len = 1039 +Msg = 221BF8337CDD673D323A6DB530A225E621A573D5497B1841D27A96D32AFF8E499D1EE360CD8D356C907371A034709A9CE02E650426A0C5E9618FE41FFAE0A57FD2CEF4C47437557EAFF02CC2BA394303C336A464BC9241C8FC86C157B68E35B36B8BB301ED5F906207871ADB49E02EC8FE2BDF342D23C8327032DF70855FC6B1684A +MD = 695CFF3007B5395482BEE446B5C2FB09A2035951B903C10C38D45DFB2B8C424A + +Len = 1040 +Msg = 9334DE60C997BDA6086101A6314F64E4458F5FF9450C509DF006E8C547983C651CA97879175AABA0C539E82D05C1E02C480975CBB30118121061B1EBAC4F8D9A3781E2DB6B18042E01ECF9017A64A0E57447EC7FCBE6A7F82585F7403EE2223D52D37B4BF426428613D6B4257980972A0ACAB508A7620C1CB28EB4E9D30FC41361EC +MD = 607C3F31342C3EE5C93E552A8DD79FA86DCCAE2C1B58AABAC25B5918ACFA4DA5 + +Len = 1041 +Msg = 3D90A93AD2235F8BA283865E49711D1C3C990F5621C18A31B626421D431476F367B06B40C5867F416935FB556FC2F8628F7BF9AC3C28BD796C2A332B46CDC624A62A21D22AE6CBD931F5A9EBED57092DEF55879D7AC9D05AF4475C75CAFA2F2F3720A830114056FF13CF9B0CDFBA04CF358E2D6F0C1186A68C871ADC4DDCC70F476B80 +MD = AAFE9F4E7262ABD17F3D2C22432964A6B7BDDF529CB99A1569FD003237E2EBA4 + +Len = 1042 +Msg = C8A7DD1E3C1C4B00E21E0709922D5A2EE2DB3EF4D8C772DCA8006C9E99577C2E5334A3AC65E696D0878F9E526C51518421B37204D37A571D0F71C193A7C426416F5D4ADF1614D6B50DD2F316AC427291CA41F369B20E823990D6C0B4F557281624776669533F9D01EA31D56AAC5D6390EED5D3A6FB055BE7E7ACC53D28C657D3B66040 +MD = 7AF136D3DE31D47B180F8219AC82830DB8C7A1F0428296A47415C284DD04FD69 + +Len = 1043 +Msg = EF927430586D5B9B2774F1E92055A0BF6E683E0F0A68B3B6034F9E5B839BD0FCFD058E99C655B827318AD098DD2DE10DED60BC1B11A3A7AA1370EB898FA4505867A20236EF89EFAD3BE5A82EF39C785F24359B14B4B629008327E708F9A9830CC66356AC6F9D5E5D4EA6A733FD6CAF59F5796FBDEF70DE66B1A7C0AC56F12DBFB924A0 +MD = 32507938760D8533BA389BD6D86B871A175150178A83E39A747C732599C7C2C5 + +Len = 1044 +Msg = 8133BD79A1E1499D04B283B2AA1238CE2A50C1467248010ACA4FDF9D0046F6BB069DAB81EBC0F29DED2168FC8566E6C44EB222185C894D0FB582799A47F3A4F9147CF11A4359C5D4CAA8A00B60843BC04F08425073222E083D7897F8F760AA3640D09EFA0CA1127A536D19C09E7DC1C0E3409269FEA735E10329611772AE1A5FE87B60 +MD = 9972F5714329228C7DB0BC2522FF3F54412511CF13C24B17A14D6E86010FAF50 + +Len = 1045 +Msg = 017103601A622CC6479298FC16091B08BEAE94B0C20380EDE796390CEF7957AC31AF910E0785768817FD68DC0BAFB27F15960B8FB417E792DBA5779DEBAA9DADA43EDA2522277233DA2F544E53394633F3BF92DE1E30CE5B3395BC941F5229F56C76FECC6026FDF5E4A95EB6CD3E90121CD16E4DFDC617058A51290A1EC2F663EF5E70 +MD = 7D2FD1FEB7F236322EBB22EAE96183E2CDA382C185ED4403387588B12A932839 + +Len = 1046 +Msg = 9AEAC19F616A4DD3BECD72939B6F318651DBF59C6E04DDB52AA4923C4054F2B2F6A14AAE357CFC2C941DCE1B6E2D2766F29F401E7FE51EEE5D67504904B6600C2CE16B8D0BD3D2074FD00B516BCCA62C78246A5062DF3F7B19F47856F0779AF1A5FCE21CE60EEE6A3129EB592539C31982786F881744B16E0EB2357EE72A2BBCFEDA3C +MD = AB258C39523C40B038F369E998D8108DABFED417494398B8C1F9421FF4C97669 + +Len = 1047 +Msg = 464ECE94E81ED3387EE92183B43B4BD70F06A9F2FFE3072075102001C3BB608DFEF3CEA25EA521D74C95BEC09E4D2EC0BF3F65BC0C8DCE25FBC9D7A90B31ADA562278A89C3113563ED449EE12124ACD1591D3D586476B5B27D3B64DBF27934EE8CF97FE1F6259A0D520844886B570551BB532397EAA46C317F63728A37AB22A94D98E2 +MD = F1AAD5D2954D1236702B00177D645C1A9E5AB139A7462AD58F736EA3811EC424 + +Len = 1048 +Msg = E88AB086891693AA535CEB20E64C7AB97C7DD3548F3786339897A5F0C39031549CA870166E477743CCFBE016B4428D89738E426F5FFE81626137F17AECFF61B72DBEE2DC20961880CFE281DFAB5EE38B1921881450E16032DE5E4D55AD8D4FCA609721B0692BAC79BE5A06E177FE8C80C0C83519FB3347DE9F43D5561CB8107B9B5EDC +MD = 0656DE9DCD7B7112A86C7BA199637D2C1C9E9CFBB713E4EDE79F8862EE69993F + +Len = 1049 +Msg = 21DDEEF5DEEDD0438878B962A1D8A389678E34170A9C7DF55A2B0555D23AB3BC604D219AF38CF4B53F825CFEAF5B6CBEAFE028F61260CD1730F5CF32E2D9AE09ED879D4157B52618D6978A7C30C4DFD42A9C51373C98F486797589E362E3D0B27A7D29EB2086549A69E1F4EA94E915A2A2B08C19ABA3DA21192121B39AC7159356836900 +MD = 0F88A56E7EC95F3130163606C0CC29F216F1396BA54A945B48FAA2B5D77B9F31 + +Len = 1050 +Msg = 6A57AB28E6B5AE23DC9B0B3D9DB281C25F2CAE1234A491C5429A367C46E237F33246E28BB822FD7F0C8FEE333FF8F810C5F25D8F1755E7E7B35954E1FB5D546AFB1573D6DE44C4C6E15AC43396AFC517B2BB23A134BFBEE7C4FE7DBC4E966F93A1A92DF5CC79032E37B35BB5AFAFA31A2BF03152D8668C6A669321B94A5B1399236955C0 +MD = AE3C40F98EB1180168FAE3C961CA4F6B05AE93663212B7D113DCD7B67D6DF3FC + +Len = 1051 +Msg = 33DE2D5AE75E8F29C17C780363BA7A390AD99082C59C5131FD7EC40033D6BF32DDE1142D6079F2A3080A6CDB3F276C02C461882114DB8A6AEB5F91C0D66E189B2C956FAB3565E4FACDCA863859303557EBB538700CD5BDA9A40CD97150676CF8850A1AE1E7D349DA3E9F9A987E8FFB8A434E54A830833DDC96B9BE8E66D4B57E260B1D80 +MD = D8D40BDB9B22E2C947AEF914E7C644D4F93E6D91C3BB507E97C78AA5564C41EF + +Len = 1052 +Msg = F5A418ACA95D064DDB98A6E9F2782583280F70B7403D5973F622E50DAA6ADE937D9CD544BB8203092C5DBCAFDD426892E6B46EEB84940AD8E1D57D686EE51AB61D453672CDD90F4290F5FACF19FA52FC7DD277429CF978F174604EEE3E941F475EE25C5B839735F2087DA632724211DA3E5A9C551D5633FC0AE624FC93CBD09B85706100 +MD = 3DFDF7FCD3CC9045B776CC626669F6AA253784D20C1A9DBA8D468CEA5F6A4011 + +Len = 1053 +Msg = E7B4FC9419F04B5BCCA5FCBDEAA781B365FEC1453BBFBC96D48D8AA601433B22760055AFD7A200B6E3A5EC998B1DAC6448900D2C733701049A3AA90CDE4D673DA4E70C4A12340B5E88370ACCE0236D7F617240599E50F53D13D6C5DC461F8994C5CC90776305944DA2BE7F154FC18A1C1B5B31F4F3362D4DB7BED6248AD6E87831A99B30 +MD = 9C64D51393EC5E8CFF6BC46EA24ED6666FAFCDCF71730468FA8A95911037609C + +Len = 1054 +Msg = 446DF0CE24DD985DA3A3947E6ABB50AFA23F2FDE99D3F9F59F1331B9814FD363FFC551CA46EA987D10F1BA25E8CCCF2A4F5DE02C51A08BCDAA8306140B32B06A9C0272CD217B95926215C1AB32AEDE04F6425C1BE94AAE51CA0923097C128483029B2EBF8CDF38380EBC72DAAA62AC6FACCD9E35DECD63CC28326BD0550F54FEB9904278 +MD = FA5612023BE968804CF3E2F1821307B64D49E7625E3E5553BAC03E6F114CF1A4 + +Len = 1055 +Msg = 3B176161456A7EFACB82F588B41E9512F3595948C9F54630A25568116CBFD2B92C4174E11BEB34AEB35C3E496728734D4CB2B6BF3FF8477D34802FB6BDA003D3F03691B1EC4ED55BB58C7539A16636C09C60E03FA0FE6AC5DA402E57F03005BB0854E80E941D6C5DBA3CF2414F4140ED5F996B108FA054A68A8DA5BB3ECDE20EB5FA1768 +MD = 20868683870EE71EBFDAB9FAA6EF6D217A7D50931B7801DDECD44BE9062E6E41 + +Len = 1056 +Msg = FD19E01A83EB6EC810B94582CB8FBFA2FCB992B53684FB748D2264F020D3B960CB1D6B8C348C2B54A9FCEA72330C2AAA9A24ECDB00C436ABC702361A82BB8828B85369B8C72ECE0082FE06557163899C2A0EFA466C33C04343A839417057399A63A3929BE1EE4805D6CE3E5D0D0967FE9004696A5663F4CAC9179006A2CEB75542D75D68 +MD = 4DDD6224858299F3378E3F5A0ECC52FA4C419C8EBB20F635C4C43F36324ECB4E + +Len = 1057 +Msg = FC4C32F6D00559A9BD84443E62CA62BD3F9AD791CCC43DFB58A562E73F9050196DE4D1AA15515B22560429F7C6BE74066F3F55F2BD77A9FA2E8072E5697A76A9AE7349C72FAFF8C549060DD7290F2C34B23970F0F5504B120B2442802BF2E75641B977728AFCF4D36485BF2D155B4DE9FB392B657D5EC5BC835A344899DA6D996663858900 +MD = 248EB684D97CEEC1E9E699E926DBD808D4BFCF814AFC23569A440726432C95F6 + +Len = 1058 +Msg = 14CE9F192FDD23BBB8A407021CC2724E0DA6ED7234E06695E7693A2B02C1C043DE9833C273C0D1421369E73FC206FE3860D5B7F258301112DB5D85A5D2CCE3464CC6E4C45494A155477DC4A9BBBE5A34F4D8ED59371F74CB19809249BCD281226C0172E73C354923D25142712D307B3C4A68010117DB88EBDF7485B734FD1F7400F0607300 +MD = D7BE0345BC3151354FB959A11BE25BD2FCB3261D498564B1B76561670AD42267 + +Len = 1059 +Msg = 280E16F8EAF76DD5CB1319E7A832E9C8C19665B90D57034947D3FDAAE11FF7C9C4063543AEE6131F1240F1454141C18A47AB997C9DEC0C2E603A2B781C8886A8A27B19F72D6BD1BD0290263510A9452AC3AE81BAC01C91A759C404AB3D28F5FF4D6F193E3B22F44E2E7107F6D5D019EBA4B016BFE0E2C337B5C3D4516CB5C8E17FBE13E8A0 +MD = E33962A7C34E66B2FB88D8E38777366D2F7177F1F967B6101E6EE7FD5B933344 + +Len = 1060 +Msg = 0EFA3A88C6CACC9734525F2F6772CC9A7B55D07B87A53CD89E2B630909A96124648FC5523E0CACAD477E2A903F2EEE62B700902BB571E1A55282FAC0269378DE49C210D3D3564017A8DB4684755C0F139C414EED8CEF6993CCB1D76E1983B6666F90B16F5ED2B9A53D3D0439F3F532BAA784648E14B674D33AE96A823ACA205F2B1FCD5D10 +MD = A54434AB561F608B3745FF72DEDA6ACED767E9535859B75BAC4A325E6A273DA0 + +Len = 1061 +Msg = AE1BEA529E00EB3269266AC316C88D3300ED9EAA08805D71BECC8AD93C916763A1616946F7A90F4CBD99C3B9A2122DC65D7065A915334B680843A94EFB5BDC0ACD4F20B8B7575BACCC415272827CF359D81526CEDA8E1B8FFD030B2F4E5168ED8F4088961BF8AC8354703F3E6E427BD98D5FA0F60EED513B05E2A5DB569CB62FF1685C3088 +MD = 2A182CFC8E3428D6478B599675E7009A991D99E10F6F53A84712141BE19E898F + +Len = 1062 +Msg = 6BEABE530BDDDB616E859A1C553D80F91A1015C9A0AFE1C16519B4C14FDE70CA20A05411BAD72CBAB6A125206B1F44ED8042F45581AAFF430DB140942C3FF3A6DF70B0AC32BFBBCDAC05D7B2C03DE2554334DF6BA3A921511FE7EAB8F7309D4FF3E81C550B0E0B33FCC638A3F80C21E01963781B588B93BE505D914549D33ACE1FF83FB010 +MD = CC0A85151B57D46BCB103CCD2C657C8AC60052F3CC5A5494595C888B5753D677 + +Len = 1063 +Msg = 06BA6E79C6A8C0EAF1A1FB39FE0009BE2E7800A4692C1A01113BB666607D0EF90FDFCC0DF4F8A70491A28461669F2B8A45EF158C3B604ACC4EAF046674DC5FB38D941BE12E57BA96833A573140AEFF34ED4203DC4324AECCDD11F1F2B5B2DE5B77C0689040FE7607C67F1199D498285DC0A1B4D5B2CFF4F1E2EAC54CD09F26F608AE6B6598 +MD = 0046F5357F60B35A9EE6042948B247F0E240F806E8FA4C5918A844EB55300B6E + +Len = 1064 +Msg = 59AE20B6F7E0B3C7A989AFB28324A40FCA25D8651CF1F46AE383EF6D8441587AA1C04C3E3BF88E8131CE6145CFB8973D961E8432B202FA5AF3E09D625FAAD825BC19DA9B5C6C20D02ABDA2FCC58B5BD3FE507BF201263F30543819510C12BC23E2DDB4F711D087A86EDB1B355313363A2DE996B891025E147036087401CCF3CA7815BF3C49 +MD = EC096314E2F73B6A7027FFFA02104C2F6DD187F20C743445BEFD4B5C034B3295 + +Len = 1065 +Msg = 53C04FEA5FB71DC880D097A3AB90D549804DC48A73117B901C0CBC5C3EF590331569C074E0EE30354A94B34AF1FE4CB7A620C8E21A94027EFB0A04CBE18570D8B0C957E35782D46E5993FBE747AC158B1F0E4CF4012D57204C5226F578F0ABA56B517991C4309F3D1D1F7F9FA9A2CDF1E45C874AB297A0DD295BAFD951A6268117F2C258E080 +MD = 03E185ABE79B45716C0B7279DCC3090776B5AE89D64074161BBB64080CA39032 + +Len = 1066 +Msg = F8A6F6BD845C0831FEE2F05132462FD77F9252404468A658FFFC537C5A1965B69F2935EADC66C16FDF98B3B3D866A4D53EB0EADC7F1E639574532ECFCC1C67D16530821C8EFE9A28CCA527F35924C015B466C3749F72DFD84C82732B8986ECF7E7B2E4E5F31CB5347AAAA5E82171FFDD92647A7F823E4E2F8889F732B38CB072B14B5F13E740 +MD = FA67AD79083ED414B337DED1A72265B4146E09F667CCF37E6AC95828106E1B6B + +Len = 1067 +Msg = B7A4C88E4A3D7E7A38CDBE3BA7504290D21F255078537C3D7EFAC3B5AFC19F81A0C2BC2F2F4C3209DD7D2C30789EDD143C1641B274FCB8840D4D94B809F83AD303FA7C23BE570873FA615F20AB79E2B85C09AA80061D823D4D3BDF6C49937350888984A9825AD67C9D6DCF6B05B3F989419FF63697010633C1D397F7E4FBC7F28C816B9D26A0 +MD = DD1645A8A288FC7E9BBE51427B8ACC32B15A9E27065E28677DC901543B8D5D9E + +Len = 1068 +Msg = 0915646912F9D65E80B4718E4597B3D33C8A634964A2FCCE96DC7871C2E3AEDCA6D83A78D57380241C9E6C4D010A594D31BE0CDDAD2403567F486CA5E7A2EC49358A87E0E311839BD0475F68BB6CB623967E21AD25216D985E841F2E248853FE45AF8001FD02DDF42C62B9AE6D58CCCC77DFA6C3652AEEBD3147835965A524F61F20DAB12DB0 +MD = 30513CF60CED61EA945DCB7F89BEB377753E26951399F470DC6777952C2B2CD9 + +Len = 1069 +Msg = 00A9047B379AB468B988C672FBFDD7B66E06F2B33E3A1E35DCE0D57566E3430983237FFBB7C3B469CDF5239CD6B151EFB11B8AED6516723DC2AD77E448962C118A2B1E51502463678F86E47309158967A168D33461DEB278F7317333ADF3B9C1B8011A39BC5211CEE3826678FDEE96C1BCA6D7035B9CDBAF58A4A9148713E1C3306C03C7DB10 +MD = 62D5DCC0D314FEFA064AEFB2CA1E60EC6DD4AB3E0D6E1B4CEB2CF05EC2D06F67 + +Len = 1070 +Msg = 409DBDFFB836B5B92DCDFF82825CB19043D26CB2BFC2C1961338B87647E7925DD322DA8A3611989F16DB1D5971DE0783FF6FE86D33E175EC55E4BD4F43DD8466CA3FB4A0468E4BFB571CD7E3C2A44D3356CD583EB63D9D9583345DC3773D9D257A1FAC8424AE528C3F8DB6C8383915F87EAF86488CF0435297B38A5341CC1560055149FAFF90 +MD = EA39F020862AA4DA2AE1EEC898B8E0ADA814958CE26442CFB205F2FF30B50AE2 + +Len = 1071 +Msg = 53383978B3D3F0F99DECB33B9F183136D0928A2F4EABDC4937F40E021D7F28D49FCBC48F92DB74B3CDB14C243DFFF1FFDD6C2810BDFC08712BB006D5717D9B3B19B31A6B78A4BF6E4206A1E229C61813DFB5D38AF3D2C0A19F47FD813A8802CFA837F1AA88F20ACDBABCC3CD574C81BB69E26732D2E77B06366546B3E6DD75DB443E0A1B16CC +MD = 10DACD4005ACF19BC48500BDCF1A4332C3D15A33106D61D16A30B11AED971A99 + +Len = 1072 +Msg = 77EE804B9F3295AB2362798B72B0A1B2D3291DCEB8139896355830F34B3B328561531F8079B79A6E9980705150866402FDC176C05897E359A6CB1A7AB067383EB497182A7E5AEF7038E4C96D133B2782917417E391535B5E1B51F47D8ED7E4D4025FE98DC87B9C1622614BFF3D1029E68E372DE719803857CA52067CDDAAD958951CB2068CC6 +MD = FE71D01C2EE50E054D6B07147EF62954FDE7E6959D6EEBA68E3C94107EB0084D + +Len = 1073 +Msg = CC4CEB09E892BA340EBD8839690C8C77B6276E33E1E87ECF9F3F475A36D22677258FB019DC08EE7670A685DD766213ADB7A55924D05FDCEF85A0B033ABB97BEBB9210D278EEB6837B4511FBE53BED7AA1880B1575EB1EB6999E0AA2723B50C76B9D72C384B78EB418F7456FFD61030ED761063FC5CD76A7BD16ABE1C050B7C20AB7AF6FCBA7B00 +MD = 7E18E43E66DA2EFD7D82D6D64139A72CB4B823F3874430660DF71DF461AFD03D + +Len = 1074 +Msg = A171F7F0CC38AD3C6185BED8BB94EA42AC92CEDD458215264B8CF9D2BDE36D4BAFA2B885CD8EEE3BF0491318D84ABC1D15407080B7DD8F4652CFDC8CF1C709A8CA3F322C92954D798C01AA17D6B5C45B5039E2B66839184ED72770620015C06F54C53E6CD538CB7EFD987D5890C7FF013CE93240D34C68278B92AB9C73F771CD3B1DCD1B8C3380 +MD = B1104B36FE10BD20B1C925D52660F81150E126EEDA44677915F23ED336D79024 + +Len = 1075 +Msg = 34A955BBACD0F8D9181E6D573290010DD36F46C16D5342DB7DBE9EA9049B9B14766F822B644A598DAD015FCEC1A2FAC8C4F2EE961E8A9E962655D05144F54B2525C7A7D98D1AF46952F782764C6AC9BFCFC9C0ADF3E12038C89BAA3DA273D58B406D82E1D263D417E75386E9DE11281DF4D96208FCA32B19D871A109A736FBC5C3F29FCCAD2DA0 +MD = 4BCA5CEBC6FCA99BE62FB23FEB63943493A9EE46D78916FB5A63BBBCC7AC2B80 + +Len = 1076 +Msg = B9C7F790421747555F738A0F4F2BE81A693F440312A99F9A1835AD2427058B14E2202ABF9F12DDC25091A3D91BC80C03546E97789C667EEA433E9E1CF967F7A28AC1F8D81F6CF8A06FCE64DCAF549B77B374CEEEE63DAF77D0EF7BBEE45902051E14F85847B7F16F8C168A1A147ED0EAAAE34F4CAD779B8831301965AA3486DA726B1A7CD62DB0 +MD = 46D956A495C1C3DC4AEE2E72B64F781415A946FAA22F142E7B95688C40DE49E8 + +Len = 1077 +Msg = 2E2F9F6F2F735C837CAF7ECDE1AE9F41C4BE21C15797F63528B2055889F0610450A5BB973EED188F9392C9DC7B4E73E65D18437DEF436E299D465FE7E437A11FC2F8311840233934D4596B1959546E34F5C37F0FA9316CD586744BEB8DA770AFEB0D8B1248F5FCB2F542E8F9B9F34EC1802B042D50783A3884115D08B6471EC383C25484DA37C8 +MD = 52397ACC77A6310FBF260718CF124DE7E2ACBFDA72E74F0B4D09BD48EE0495F8 + +Len = 1078 +Msg = 01BF05739A0A3633131E869E79F3CFE2D4400F29786C04C4D04726E632CD9EED3AC89FE6A206896FAA447FDBB131E34B83B6713280DEF5167193634D68987B608A5C1046287E64EEE7EAEBA308F5137E0C188FC35AC15F264139C7B93F3E1597328B9D39F13D9A959632A9330D852D726D982AF6D00EFE996EF92410F85AD4A742681872C6FDC0 +MD = F0628CD4634414473CA1AD60A999AF5E906981B8C4E7551D910DC8A450F0F776 + +Len = 1079 +Msg = EC686F7C71E53D760FA840B3AB715D8C0BAD257072CC56EC259D1C240851D329BBD11F48993FD01A73B48DA16297D95F62D8E08A1A465FF6A5ABD63EC21037F68F14617BC1CF15B1F71B120C7C8D60CE32F5C610F00D306EAAD3991B442ABFE5ADD064046BBA9FB8F4F9A38D99037D80765DAB0342CA779B86B1E7E8C3D698CC3E5304318DCC28 +MD = 088846A8BE7E2893A06C93715C56A63C3E9D9A2020B11009D1EF9D0B4BDEF3B8 + +Len = 1080 +Msg = B771D5CEF5D1A41A93D15643D7181D2A2EF0A8E84D91812F20ED21F147BEF732BF3A60EF4067C3734B85BC8CD471780F10DC9E8291B58339A677B960218F71E793F2797AEA349406512829065D37BB55EA796FA4F56FD8896B49B2CD19B43215AD967C712B24E5032D065232E02C127409D2ED4146B9D75D763D52DB98D949D3B0FED6A8052FBB +MD = BD6F5492582A7C1B116304DE28314DF9FFFE95B0DA11AF52FE9440A717A34859 + +Len = 1081 +Msg = 4C727CE979CB8F2F98C2821E6797161CD3BED5806DE8B08087AB61D739A32B760604695C1DEDBC3538E987E52DE252A46D80C260B3560B2C71CA37172C6A7F6D581FB4E0B0BB06E4C9504BA6B3F172CAA2D5AA92022D2BE4AABC96CBA2F917B7519E397DD6EE35A122125FFE90AA846EFE38E774711AEC8D55A4045F927D433B42018F0F72E1A480 +MD = 1D40D734701A830018E7D49ED1DF04F84AA1BB91B59F4C98299DADC234CE448C + +Len = 1082 +Msg = D44FB8AF633D0DE91CBADA6BC655EA864A291E404A829BA9089851ED2513461B35BE92AD602018567A4A92BBE37D20E353832D7562618685072BFDEF93D287EE6D083CBE2406332701923B83452656B67483B772922ECDD4BAE3D5D5F0C8064E32A71098E628084DC9549773C2C078C04CA18CDBB981E7AF5791C0338E95A01224283F1D3FC94240 +MD = FE74E920A78BAA99433C6AF81048B07260241B9F91AF1C20C1F6DC2793F8D90B + +Len = 1083 +Msg = A676AE811E49EDACA42C55FF4305E2A12648C465B8FCE4828598D85B6F8821E7DC35731B21AE6A963CDB6CC3D35F1E30B165D42E5844B64475A9E75D6474D9A044BD46696D44929FC185AC54580165FC74BB855FF1CA1E31041B960E6E5AFA62B3E9E216EA004D3EDA3C893B5C2A091161314EDD55DDE464460152684C5154298E0FDEA58C692E40 +MD = 32F8F70827A3937985CBC9C7FE363A5BC2AEC52361108A47C1D116E9CDC97EF5 + +Len = 1084 +Msg = 70A4730279D082EEBF6500E4E61AB4ACA585FC47EFB9CC68CDF701EB55C53A5B7FF42477756A16B6B727DDE9CD90AF741428018F9D0A6A219A1A4649521E7B0EE57F38B60D900ACA04552CE4ABB537034B017900182C6C639E8251BCC31D897BCB7804545A1201501244479EB92ADBFE6C29B738AE9F25C2CCF04A7064BCE438DA1E98FE7686E740 +MD = 22F0409E52112AB70E25F05D87625B2356123B845058A4AE6DA30EE55E7F4872 + +Len = 1085 +Msg = 7DE762652C7A3135A8B42A45E29C5C4E31791487B1777F151B29FD2CBC901EAB6864AF5788EBDAA54E5707B82D96150E47780C05CA59347B72864172F40C1E91B786E3891BBFA66D761A2ECB69873C28BABA3E1EC725E9346DF6A1F315B96DDEBC5F10F97CA0CD30D108AECC747628435BB93951FFAA0A965EE1A9A1943CA018F0133E9D946BC430 +MD = 9D180AABB04429EF33B723815DE8C1469614BD31D9B7B3D02443BFE1D7D6B77C + +Len = 1086 +Msg = 549C452B52BF24CD363C8C6F832FADF5AE643E51BFD75D31968224ADEA8D8EE5CC9A4B7C6A8DA0EEDE2B0F0651A5E1889C4F03953155AA4F7EACC3F17A55A71984E36018E9D8150BA31A0317C14A457C754C72CCED34250B3CFCA8A330DE2F5A6829433615CFB4FD0E63921593D1B519399EC8BE42A32AD96CEFDDDE181ECDE193707F967E182684 +MD = AAA4559ACF91B138CAE4D56263520C10A8CC02E2466B135ABA32E6F9501DB402 + +Len = 1087 +Msg = 323CB91D4292ED7F95C98DFD71074379D2CB19E8CC83186B241A62F495CB9B5562345F70DC9C6A06A10424869DCF9C6D100AF700ACEFA7EE011CA6E8C41AF13FF8C9D7BEF1526A8C601F69B7E51E1B8E761EC597C22C0476A74FA7ECCFBE0D2084B0482C46C0D9CB359307B6528A3C88AD5236B990EBDDCC762339D095B34DD503C7E27EEC0D0ADC +MD = F1C7CE26AD6A977282AD6C9547FE0E0E5845BB4E4EAB94E5ED2E3A977C1FFF87 + +Len = 1088 +Msg = B32D95B0B9AAD2A8816DE6D06D1F86008505BD8C14124F6E9A163B5A2ADE55F835D0EC3880EF50700D3B25E42CC0AF050CCD1BE5E555B23087E04D7BF9813622780C7313A1954F8740B6EE2D3F71F768DD417F520482BD3A08D4F222B4EE9DBD015447B33507DD50F3AB4247C5DE9A8ABD62A8DECEA01E3B87C8B927F5B08BEB37674C6F8E380C04 +MD = E717A7769448ABBE5FEF8187954A88AC56DED1D22E63940AB80D029585A21921 + +Len = 1089 +Msg = 5B11A12546F0ACB075C50D1B5345605D9A8542B87AF03EA106945D3BEC5EF7A9360B03187BD6BDD510576CB68E8B89649711C1586F58D406B44331609A4152C725BA290B4357C0DD33039306342E6640BBE5E27035E6118E13E1F47E74436053446175368A82647D433D693FDC5927DB2C5AB7B49274AD2E522C3FCD8603964246C1EBF4C78881E500 +MD = 0F6B769B9EF4C883E978D5FE25EC6BAAC97D615F28336EC0AA97ED31E5D16E33 + +Len = 1090 +Msg = 95E4E9445A009D7BA13582D798DA2BA2EE87D523FD11079D7D4D7415EC275578A6765100E195C662FA22491C91D929E5196525B061C7BEF28B5C7E007754A543BC7577B1A28002A12C8AECFF500488673EEBBAD04B5DC521A23A62C48E27587E40F96585998EDA108DB8536E4DE4F0F8F7ADAFFEAC348FB0ED7C272432BB3123E0463FCC23090AD2C0 +MD = 6AE9810E259C8A21FC9DF9D4C2BF1D3C7E314AB7C97AD308A38DE70EC9F1BB4C + +Len = 1091 +Msg = 99890D0AF31A29F66EA71EDC5B22CA37A1E32281D75249797335D503350CA4D9393B88A493E519CAE8227CDBE43EA16C3034FB2F3BEFAE6A24955968C095F9AA8287ABEDFA012F339B38059B803F8A49CDFE0A44A1FDC0F5A95417F39D0A6A7250BE89421B9E6C6275961D2DCCA2CEEA8DDEB9F815E2E229730C98B81F899443DD11E26548A08F2D60 +MD = 14F08431A319B3B296DEEFA1C7463DA64B17A9AFB677743646AB93B08ED796D5 + +Len = 1092 +Msg = 86D3A8756E45CAD9D351BA6D187A5FA35D0F898948E922F3DCF7D1D24C991791031EDFF0FEC7AE1B4B93406FB555CA782869900E7FA4BAC5ACC6D1333EC8819D8809004E544CFD2AE83C6E34854CD2D07C72F64D052259E138FD44204660317E73367D5B6E89E2B0AD53D1D5F00277625D8F8FB3D418501F76B127F9426688AA1D70ED3A3645950D40 +MD = 464FED76AF7F4982A12550E7ADD1AA909E68B22367E425152081617C19986BE5 + +Len = 1093 +Msg = A2554C66211476EF2B6527FA9810A152CAB5ED42AE8926D582F4B0BF358EA30AAAF75EDEA37F3C7E1C63A66514C5B244316B562EC47D7816D6D4AA209E5B3D718413B4A30A26FCD28D2CCCF4907DEE332A090975DBD481EC5A945E17C1F3D2751AEC0C7EC6F3EE61A8DF8DA4D41B1B8BEE408FFD1CA1475B9F7A04EAED705350DCB86010D0FA03FAB8 +MD = 676E18D66FA96BAB1CE63C3DBB62466BCF2B0E571A73BBDCB6CBA993ACC0F2E3 + +Len = 1094 +Msg = 8913BDBF67DAC137CA5E1C7FCEDFCD43680574F7AA64FD63E8FB7B672CB39E7B1989E44916FA2D44DB0108F56AD945405D6D736633EE06E82C36B255B4677437DE5F0FA61064F659CC2189B3BCE909268BBC3FE1E02885A755BD60501C611A09B6F101F119850206FCDB7D1E20E60185612ACFDA62B487D1DCB40994165DE81ADF43EC22D39DAA831C +MD = 12FAF7E6C15BBE07E33689243AB879A692EBC8638DBF9A2319537CC6EFF00F7E + +Len = 1095 +Msg = 2CDA1B5738756EE102A02BF1E2538A988D62894143D4E9F19CDBBE8F89D365E4BAEC3EAB665014E09FCB98751F1337CCC33852A1B062D20AD04E844D87DE82456412C8EC1D837BC75B2292831B80A7CFA0C2EC8B4C5238690BBD7F32F90FE4F2188947393EF43720E888F9D0AA6F22EE75FE03A96F28CB3AC08ACE6944BA59C81B926B9169DF7B1452 +MD = CF160472628CD619A19A1290600422BDFBF10F8C1BA919AADF58C5AE623367A6 + +Len = 1096 +Msg = 04410E31082A47584B406F051398A6ABE74E4DA59BB6F85E6B49E8A1F7F2CA00DFBA5462C2CD2BFDE8B64FB21D70C083F11318B56A52D03B81CAC5EEC29EB31BD0078B6156786DA3D6D8C33098C5C47BB67AC64DB14165AF65B44544D806DDE5F487D5373C7F9792C299E9686B7E5821E7C8E2458315B996B5677D926DAC57B3F22DA873C601016A0D +MD = A95D50B50B4545F0947441DF74A1E9D74622EB3BAA49C1BBFC3A0CCE6619C1AA + +Len = 1097 +Msg = 8F20862EB9CEEDD84B3F7E4E7387DE2DE46E141DB60C9E29C45EF6809107D79334E086129C757FD820EE5B3D0123C4C28B34B11C97ED178367D0CAE25DA80641C541973331B1FD3DAC8F5582B9D42ACE951F4916DD4F76C16D3FB877CDDD20B989CD67A109CE139DCE137BE25D03256273DE1526EDF611E29AE7CEAF881E64BB30935BD07B22DEF87880 +MD = E673876649FA3DF5101920886AA83D65BCB3E43D89A56552D8D12005173A5FE1 + +Len = 1098 +Msg = ECD1C8A48651172811A515025A25503A9AD8AB6203F05BA929E8DD58CBFC12ADA9C7B3BAA565367F757FCCBCD1A05C1BF394D9EB4477433E4F143B6B405A3EC913AA756921FC5AED376921F8676C1A467FA219F381F6CAA0246FA18B16A78CA55FBF58C7711663AD6129414F97F88AE25FBF53D1F55FF9C3CCC6601CAD7AFAFBA2E14F34A47007F809C0 +MD = 4275CDD98C4C43E7B0DDD59B322980FB7FBF154B4FC1108B452C7DDE144E74A2 + +Len = 1099 +Msg = 091ACE177B650C3E607A71AD088652C65C8F3EF813144AAE6589EC92A7C511DC195470357171A23EA904A316CA405364C55EDA60A409C808609CFEE8BD2C8CF5D3607C37C77074A87F2235CFAE2222FEA82C5EB6B8C117D21CC8E29A7698FD9211118374F86F92DF1724D797210A66CE91254978B50259DE484DDD62F0EE6F5D5A5E8E00D549E90DE8E0 +MD = C3AE6ADD15294EDD83D70682528D7CB973FEDD9B1085D697A35CA94650F8FC4B + +Len = 1100 +Msg = 534B61438B3CED888D051393506E80A2A71FC2B2BBA6099C8DDA2CA48C26563BF91B5F201420024A0865114F5749B496539E99D78D5E691D763454825740B6CDE5EA88513A09C3BFC65EBE2EE2C3F4D56AB1798559972D92520DB6BD79AB7BBCC416F22759183BD0FBBF16CB02EE5A5DB3A0015EEC399E8BA9A2949E1AFAD4203F427095952DEFDE4FC0 +MD = 6484915BBD975618C3DFB98D3DD1151157FCEE233509E7A454EC55CA351D6AFD + +Len = 1101 +Msg = 9485B10269346EFA89E972BD6912DD9A878E0682F548BA438B52DED37E374135CCCE076BD254F80B4E9253C479343AE53D7899578B61E6C01A1E1B50C26A1554EEC28783C45FF9EC90D013A7BDE8724B369E708BA547C270B0BEFACD16F4AA427C1B7AF937420C5ED61D3F7865A52065FEF7F803411BC2CEB33711E9E67ECCDC9D774FE532C850D934F8 +MD = 8DB30A222800837071E2FC469609ECE689B05B615E3B607FA51629ACECFE4997 + +Len = 1102 +Msg = 51853A418DD59D08475390A4AF946B850CA46A508A8385C782B5312304683D9D287ABC97099EABCBEAF589AF4EC9F509AEB4323FB600EFEDD49A1A6BFC802A4B11D5DB9C49CF0776A1E55406E5CE46ED022F1B7458CC3A1287A748D0FB574376382C34EB8346CE941B6C78639CDC4D10DD58B5A11E3F8FA4A4129FEA7BE28E0040985408905ACB7202B0 +MD = 2019B22796E6E2572C1CF3770912B1886A7208C12DB920AB0658C023F6CE957E + +Len = 1103 +Msg = 02A2FC7D539DD0FFF7337A0C42C23C2F9B505AFDB06F38F1C8AD8EFBFE41467F4727D7ACEFB17668957D2B57BA67971EBEA22FF1D8933F8F2759708CF1F96622258EA221AB8A143A574B59C96FC5250548DE6A4CDEBA0ED4BF49D3CB62F2F1F0C5F8F05C4F8AA249B1F96003AF89DBDEC3C578E3B7D62A1AE591E67F3EB57243484124A2BF71626DFA7C +MD = 866DAA02759E7CC51D1AB0838F6AD5CB4546A5EFEAB2B483573F79FFE0EA1120 + +Len = 1104 +Msg = 8B81E9BADDE026F14D95C019977024C9E13DB7A5CD21F9E9FC491D716164BBACDC7060D882615D411438AEA056C340CDF977788F6E17D118DE55026855F93270472D1FD18B9E7E812BAE107E0DFDE7063301B71F6CFE4E225CAB3B232905A56E994F08EE2891BA922D49C3DAFEB75F7C69750CB67D822C96176C46BD8A29F1701373FB09A1A6E3C7158F +MD = ED53D72595ACE3A6D5166A4EDE41CCE362D644BDED772BE616B87BCF678A6364 + +Len = 1105 +Msg = D885277BA59CD5B0A510BC8F77CEB8658E407AE08A873ECB0D2487590905C55CBAFA1A108D4BFC4286235984B746F10C03AB15F7EDA75A6DC302622CD212C44434DD027328630BA5377CDA18C62F07FE62BCBAE8EFC3655FA772E604A08E2F6DE068896A67097187B75B507B3F5874F157DA74187F5FF868FC02AFF44AB720FB7FC84CBEA70CA0C32F6280 +MD = 7CA3A4A3278BF315CEE14984F6293E8092934468519710E4BAE8E5530645806A + +Len = 1106 +Msg = C9E4994C72FCB03CC6DD0B5AADECA313D1B99F7595C9E40BE56DA64E8BCD0F12C811E029AA414780F16F912DBB00E4B226B9A9DFEBE9298FC0EC157F466BCB4871FB2B2D7B847DF7DC9281C0DB2B16F140B547089B2454A72475A709B3A3FC8D968C367C6A14AEE8E2A1025259D850E999A8B994746BE4A79011946F3122A9B8097654224CFEDF13C47140 +MD = 49746417684F7D8A8442D1D22A678A3942435095B862C4CA4CD7300625D21340 + +Len = 1107 +Msg = 18DE896CCAC5B0584C6605CF8DDC4BCA77E2F8207B3333482FBC02129BB8AB2763B17B3D3753654BFB5ED80294B4EC2F0A49DD0000FCC4B5BBBAD28922106180F1ED3EC72D73F278B613F965E5913ECD2BB25DB1765A76388593E9DEE66BFF75AD42D7266EE9E67E228323926C178FCB582E402BCCA3560B24C47F3D983316396D69FC1A7D1C250531A8A0 +MD = CF42559F1E0907336BE2CCED951FBF391084042166007BB770ED77BA43EBEB16 + +Len = 1108 +Msg = 10927E62CBA50DC5D92EF8B03649EEAA5932869AD735A22D0EEF2B2DB5DF6433308DE06723D75D2630C9A21AAC0129014DE427FB07BDA5FC28CED642B665C1D4930B49080E50C9D8B0D4C7279834B71AEBB69C57974E45C81130D9C4675DDE38446AB64B26CEFD8BE1666F2ED8B78AD30673AF75CF73DE5B1971AE038F379BC51920263E9F5F18EDC21C40 +MD = 236F41204BEFF692AD672C8AA2A18030311103C06AB3456F18C2F314CAF2CA9B + +Len = 1109 +Msg = 3A58F6C016F9325FE3DB0E33919263A4155B673CA916DA362214638085FBDFB0572781B1A9CEEAE62FF993DA3B01E21383CA63A490F07D733381C6A58D83B84D812BA1E5B25694A3898F063A73EE6E542911303CB749B9B8B971538EB6112292128FCA1F209CFE49A98F532DBB1A4EBBA10330580FD73B33F31F93D799F2F4030C5CE0F0882A78F9681558 +MD = 6987C1423E9B6D4EB8F1F67B8152E3895FD67F4C9E4DB16B3C314EC71FEE72C4 + +Len = 1110 +Msg = 2D17254047F202430E864B21F820FD944356E8FBEEE769616413DC789C21FF5EE290550338921737B0B73E45D14AE85337284BF8942950342E0C278B191E16AC07DF2F34E8E3BD19971EF6FA4743EB75754AAE1E34146DB5F7CF7A6083DD01D675BE3256AC7FCF1B3E518AF902699BF7C49BF153A5674E25BA8FB19B50E18E8631DFCB5274CC794BC39324 +MD = 766868F4C63CD8BA6A474EB575836B7B4FC914CFA24BEA3C0080B60580468832 + +Len = 1111 +Msg = B4CCFB77F6D11DD5E48E1A0535B8F9775122ADDDDB9049B072138381939643FA5D5117BEC65B5AB487F018574347E437C0F41ADA18AF6373DFD212C1EA732181C0F2C5B45462D40F299A212D212516E9089EFC243665CAA06921EECC653677D94B39E6FA325567BAB84A984052546E9A5C4ADE161F5DF6DF97F73C226F993948F63181FD8D4BD9192D084A +MD = A006541DF0CA78AB8B22F433F28213F17D1B35C9B171A8115407FF3D273DAAE1 + +Len = 1112 +Msg = FA6EED24DA6666A22208146B19A532C2EC9BA94F09F1DEF1E7FC13C399A48E41ACC2A589D099276296348F396253B57CB0E40291BD282773656B6E0D8BEA1CDA084A3738816A840485FCF3FB307F777FA5FEAC48695C2AF4769720258C77943FB4556C362D9CBA8BF103AEB9034BAA8EA8BFB9C4F8E6742CE0D52C49EA8E974F339612E830E9E7A9C29065 +MD = 810401B247C23529E24655CAB86C42DF44085DA76CA01C9A14618E563B7C41BE + +Len = 1113 +Msg = CDBA5700B140CCFD21E0B8FDCF0E7B879292537BA1020B5A5AC12C1FA5CB09BB69E11F6FB2B8E18EA44CC21D31D30EADB150A4619E664333EA7195717EE311D94DAD45CDFCD9339790750A738548F17C4BEC9D0563C805BBE943BC2ADB95627D3984B34D2F8413A98E19090FA4497C8B2FD9E59DE706599DE09134EE1B9C58372BC87B6925B4E1208623F980 +MD = 316C7D67A72CADDB21E381B0958F20F0686C38940303EBF0CCF3E666D1467357 + +Len = 1114 +Msg = 8FC83D24635224EDA4A9CC82B63291A87E6CDBD4BBCA2497D9EB075784B2E749F5EBA53C80AA17ECF658D91A3908A564E6C2BF6363C3A7E2A508D471451559D4CC0775247695E6FB207D383F7906A0254800976818B6DC32F9488F4D907B4432807DBE607EEAAE9508532346013F4A9770110E200D72E47B0814623F810EB3BE968B8BDDA22F3C99B61CA3C0 +MD = E8D7BC2CB76B1E60F8D6ABF303E62F55425F5D2AF1A5FECFCD785FBBD3E2F7E0 + +Len = 1115 +Msg = FDC09E81D5C6D2481A3C57A0828F8FBD17B4C4C288F043F5BCFD0C55024CFE291567EEDC2A82FC849E349DCE8C2821D3A7E1DDEEF9BDC90220E7EEC17C18F5557B4B2D64D342C45794FBAB47CC0E1610249DB940DAFD66C70551934C1AF804EDD9DC834ECD8F036280E513897009F0C619E815828FF0ECA3BCE5C30203B5E5F038ED364B1229DAFBA20278C0 +MD = 6D92C318B3E13BE5D884F107F884542777F286267DD9207B36629E304785B359 + +Len = 1116 +Msg = 2B35EA4A2CFF637B951841A2DED38895D6D4CA4AFE8040EC61859A76432C5D3885B75B9D13228FC629A0E3F123DA446035B66853418B67D0EEE1BBB983B361083A078F02622FCEE37302C9DFC9085A1885F8454EE56F0A9EBEC38026A0638771B4AA6C09E461BEE69ED16677610B926709D7795A47C1B4D6E5F443BC9EA464D1F2077AD18074AFE30ED27280 +MD = 7601A5F8B12D623A9D3E88AB28C9C1901A752E06EBC60ACC97F51E41B6AA35D8 + +Len = 1117 +Msg = DE1B928D0D48404C330ACEF3492378B2A5D9F4BC2EA16600446CB058634935F35D32471BF24C15072CCC54C6CF83A0DD5194B9EC140DC0EBE691464B0D730A4092CA0BF08A0098E800582C453E5518E704E998787F9E34C3D69CD0FC7DE2333784385B02B1480A5CC4C4DDDF2422509344DA2C7A8BE0C654133A7B2D2AF3D367569CDA35CA6000076F3870D8 +MD = 8E224E86FE19EB3557FACE5C7808FC1E719FF0D6E450B4C8362AA35FAF082F88 + +Len = 1118 +Msg = CB0334F2129D291773071EB41BC3A7BC95D44A01D945B604507C2DB5488D30806B220CB03499450DC3F8D2EE936CBB93552189E624452827438311FC11753B8173133E7235501430CDD199E44030EE9FA6EF063734F4AF0CFCB36C1C0C0A127DB579D78640AFE5E7C7823775D689890F612FD4FEA4012E3C7AF289A24FE0F17072AE6B2FEDAEAC5712060174 +MD = B3E64594F733D82AC1C26944C506793179406809C012E20B671CDF24A9D4EADD + +Len = 1119 +Msg = 2D2E1CFF4DBE19D856447906D6E14E532E713E20F2CFD73AD76F580A8E617C1DDC1FF9EA781E8974EBBEB17ADE82CD57DB3B92512A2B8C13C4ACDBFD941F83CAD9F664AE321E2AE972422DB187D699933E348E52374C1D4714A13632BFEF26D168D27948F3241D3A0266F34014DE0BAA18BCEEE6C0E7AECDADAD53FD92FCC1406C0F30128F98FD549C6F8C2E +MD = FCB2CC9E0A34BCA693D7FFB93502DFB7DE8CEC3C4679E72C16CA42CAE42C2654 + +Len = 1120 +Msg = 9BB4AF1B4F09C071CE3CAFA92E4EB73CE8A6F5D82A85733440368DEE4EB1CBC7B55AC150773B6FE47DBE036C45582ED67E23F4C74585DAB509DF1B83610564545642B2B1EC463E18048FC23477C6B2AA035594ECD33791AF6AF4CBC2A1166ABA8D628C57E707F0B0E8707CAF91CD44BDB915E0296E0190D56D33D8DDE10B5B60377838973C1D943C22ED335E +MD = 9F01E63F2355393ECB1908D0CAF39718833004A4BF37EBF4CF8D7319B65172DF + +Len = 1121 +Msg = 355872C5BFF81DE902B8E9E82666A99FDFD866545F39AA8AEAE26EB3A3A7798BF7085A26FC83B42D0CA2541A589F7C4DF3C2637202281AE22A137C9CFB5B7F324AD1DE1962B388EE699B2164828DF997DE802FC6948D166D3E00C70CC78E522B7338926FBAC67153DC5CB219BF8E24743D7E38C2C00BC32006B43E113C2F5CBF2067E35C754601982751498900 +MD = D5666A8F93B20234E827B6F15C6209BE3CF0403724EF5F2C9D0AFBB1B9DE4ABF + +Len = 1122 +Msg = EA3B98208EE7977FBF045230E52F8482F1A9CBD7F3469752114A1130B4D0CC72F5C2B52F4D316E94183B017BEE71536993AC43D66B40F60EA12005FAF2952BB4BD0202AEF3AD8B34DC8C200859327C65BE9C182A130E0D7AE0CBC4F6CA92D5F12075402A68247FC7F2BE557C93B9C689F4ACD825000D3FB630CCF9573577563090A1277C1B4C62CCE7088F2280 +MD = 6FDBE8EDCA99A507D6AD4E20DCBBE88D531B22290D0DDB539C7F23A912D9EE8B + +Len = 1123 +Msg = B85D2AE087D8E2BCD2DF5320091FE59F356962E278FE17031328B2B4BF413600A8F782DA6ED3FB8A06F3ABDC46CF7491A626FDE9DCFAB53DB60E35FFA444909482C2B68E622028B3F047728F19955181C1ECC1AA0B70B661548742AD62444D4F3A27E9FE7ADB5E4DE2C98D4E86D2FBAA0F6D41F913A718BA995B9B04A33AA5B2B5716EF1BBB9899BC2F2421960 +MD = 3E2944A604203ECB3AC6165978C55C98A240628CBF68E37DEA2A7E372A93509C + +Len = 1124 +Msg = F2198E064F7F0935554FD140CEC82B3438E615876B22F36C7B2CA852C4902F12958E4C5CFF290A69156E21E1DADE8BB06EB5BC9F0B7A2926722786944358283D1EF9ACE91C72B0574481DEEF365A33023C7DDA3E6016424EAF6B826370C400DCF24D03D4383C1A102506D9194746E5D74139E81E4EBCDAC6886114F5AD59882B0A9B0EB494BA4D98089EF032E0 +MD = 54700E66FD70BF9EFBCD91844F3F9AA7837BF4A14F071251A3A4FF532F59F1A8 + +Len = 1125 +Msg = 95A89F7A1CB4BDA4D383EF4FCFADDCB55950A7D340D49BD65A04744929252162E3FCB9F3568EEC982C08B2F2BA932B84092707353DD102B37AA081A76B73545DB577FC0E80F43908835E9FFD31E1A661B1B14F7309B461F972E8A4A6A18427F8C280AB441BA2C619AAD5FF9D67D3A9920E012B6FE6A473E7503DEFB29E34B85ADC06E7F807B3F39A7636280630 +MD = 54BD4511FE046F471F5ACDA1E06CDC159A10B4E3CF1A5A52E0CD7EB780D02AC1 + +Len = 1126 +Msg = D1273FCC09485AD18C279A7E332ED3490D058A0B5A8D03E22B6715A5455394F41059EEFDC3DCD7337FE7D82293751EDE700E017C7344F168605A9ACBFBAA68879D74DE31B8C1726C9117CE956EF7D4AD1CC4426A767BC799849A478B7F1E04F83722F5AD54CE2C5171735533CCECDE5740CAA2D0A3A8E0877CB87CA866C959E9FD5114D54E779D190D41ABBBE4 +MD = D5EE300FC3CD5BBAB4A2B3010BF61F7AE2023ADCE365DE9982B902D34F371ADC + +Len = 1127 +Msg = A88C9A85D29A2E99FDA4E4CCC67FFA1E87072F844B17D45AB076974AABED7DD8CFD4A32244A2D6C4312D5CABA2D73306333E62E6A121B4E4E924D0B31A303A51732709BC26087B18C46CD4A1101AF4F2A7E781E71D8ECC72CCA63F0D968CE958B79B16690AEBA169180D181A50ECF2149E318B200D3F40C893E599B0D749E1BF8A95DF4134192D79FF8D9CC95A +MD = 436199ED67BCC8E9A6EDE9E5341802B9AE4B00E90D859483FB1970BEF67B5D0A + +Len = 1128 +Msg = 2167F02118CC62043E9091A647CADBED95611A521FE0D64E8518F16C808AB297725598AE296880A773607A798F7C3CFCE80D251EBEC6885015F9ABF7EAABAE46798F82CB5926DE5C23F44A3F9F9534B3C6F405B5364C2F8A8BDC5CA49C749BED8CE4BA48897062AE8424CA6DDE5F55C0E42A95D1E292CA54FB46A84FBC9CD87F2D0C9E7448DE3043AE22FDD229 +MD = 7EC11DE7DB790A850281F043592779B409195DB4ECEDEEFBB93BA683D3BCA851 + +Len = 1129 +Msg = E63DE4330EA9871CF723133AE8F2A04EE4B9A78AA044E500B8022E99A8ABF8070405DD291824CB5DA14B916B9E18028D9C76018B3C74BDC456D13A97FE4BE140FC940CCF0A648207A0472E4C8F60F6D235F1F097C2E5F48BAE57695115FF5707B5A7F4250A6CE8988DB9BED4596325DFF87E08DD2204FA1D28A17F6F7A20293156130D64680D176DA80734027E00 +MD = E277D80FE51E747DB05847D35F1C5B23A08CD6BAEAE21A0F942840C569BF4932 + +Len = 1130 +Msg = 3CD3193249FCA77C04CEF261CFF614FCC5B5BC7EBC9A99F6C88DF6C6232784BD03B0B119CEFFF2DE10C562998FFBC1F2E3D64ABE50F026CF1AACE2492CE19AF0A9C8F4BE6DEB1702A34B5792F1D79460E74A3825F3D3D46769E105CACB8556F16E61A60BB640F4918D0A0E689CE6E5B92977A53BF6C3A1AE2852C6F355049C797152B87367083387ACFF4EFABB40 +MD = 2A26B9324C4177A588827F78B6F7FAFB9E17B7E707A391BCFAE8F6CE291866B5 + +Len = 1131 +Msg = DB898DDB4201457E81D5ED2A739FA8A1491FDE99C5E22AE077C577ADF84253E7BB72745733EB89FCA405F78D80887CF055DE93F19E200E346547198E5AE4E0E1EE2F819DC12417EF8D0C352EEE351914450A8FCE74A3E242EF0535558A4254F9B0AB5025D65E59177F83F2FCD2B83B955F91711252FAB9F613CA2EC038588A68C201B777757AC9B71B5262A91CA0 +MD = C8678EBAA95766336AFA1DEEAA4B565D9B37189ECCFF75ADD646EF03F42A4010 + +Len = 1132 +Msg = CB54ADB942A2CD04BE65D1499564188B4D1AC647CEED1CC5116498EE2421EBA700E63F8DA23DAEE3223B21096FE39A0C8DAF21E3AA8B07FE7FB58836D2E70348837B72412B9AC8B5EFBA5AACDBE685AE6F7594197AD7DD95F82CDB4D31FF37EA89422C27D0C89497A1593CD96B6160862E1559BD558620F1831B0EE428C25D1456B88B3CC613CE8F9A8794A3C390 +MD = 5EED9731EADC8C1F44F55EFB83E388EE82EF808427EE59774BCFD75F231AF472 + +Len = 1133 +Msg = 3889F0DB5E6B929D85BB0D1C26A06C1E87B6A1EEF7E65B90E51DC1195C94F58C19C1CD7717C4F276BBE8702179D4196793C4069D4D91CB3C7051962B9675E978B9CA5FF5C648E36DE672BC06040ECBC1C9F7D8FFA3D1CB9A0783F3682D0C4BA5705AED875B9F4528192BC30ACECA099F7FC7D9F8AE9161FF092D935B7F4C5343FEACA0D69BF8082B16CE95A415D8 +MD = E036D913FB953B9D24C191AC2C6D586583A16B1DB220F783CE620E10717F4FC8 + +Len = 1134 +Msg = 05B41EAF294ADFD909A5D43A53F1A0F5ECE57CF2DB3EEF714EFE75A226290476DA995B35148DD1D09A18EC000D41ED59D1E5FDFF169504F771961732E7AE05877CBC301E02108A0F42C56D093F484EFB86436F06FC0C38FBD52F1BA418A0DA28B7D8D9B73C0532E7A86915797D121A9F0437AC230D2E887ED7BA55CDBC2ADB946C35A7A989848469E77BD45470E8 +MD = 2496F7D70F4DCDB2E2E1A16ACAB6941F9F80C050720E3FC337CC85AC342E61DC + +Len = 1135 +Msg = 9090328108C62427294439D9BD43C1D5E5A7E2604998129BDEDE9DA02352C84D5318735BB8B9E66EDD6254936552B7CBED1A86E48CC9CB92C136BC5282FD7195DE09A05ABBC7AE97AD3D9CEB7C2051B3446CC4C4CC2B7FCCACA3DE155F58821EE7AFCAA026C969518B4C6B411392C612416B15196FF9532E25CDA2AFD9925980D44E65FF878761D26A4159FCBCBE +MD = 5B65BBABF8BD807EC0912868C7EECAF401248FCA70F568D221FB677580B53F71 + +Len = 1136 +Msg = 94B7FA0BC1C44E949B1D7617D31B4720CBE7CA57C6FA4F4094D4761567E389ECC64F6968E4064DF70DF836A47D0C713336B5028B35930D29EB7A7F9A5AF9AD5CF441745BAEC9BB014CEEFF5A41BA5C1CE085FEB980BAB9CF79F2158E03EF7E63E29C38D7816A84D4F71E0F548B7FC316085AE38A060FF9B8DEC36F91AD9EBC0A5B6C338CBB8F6659D342A24368CF +MD = A74AF9C523B4A08D9DB9692EA89255977A5919B9292B7CD0D92C90C97C98E224 + +Len = 1137 +Msg = 01A2142EB62A90EA4BDA88F7677EF008E33636A68FABF1C88624C4C99BFFC7A1E1FC32EC7005AA20A36227932AC2E0D21F56FE1B9E4532315968F46DFF3068EC334CDF3F78BE88BF68E0F387829BF9FBC09A1A2F7237BF199FE75C46E60348D768958DA3ABC3D16865A82232E2E75ABD1990EDD2F1109685AB61AFD92E1C63BA59514FFB1AD075696C7DA7273DE700 +MD = 66B86D6A118C25623EF71842ECACD13AB422ADFC2E8743B0EA6B2FF7E752C340 + +Len = 1138 +Msg = 635B23C427214AEE08B4BFA141E1EF5FE2FDFD1C0A0BFD60CF0AE6B47D18ADA0BC2C24511BAB5ABEED7FEDB7BA4A1AB9801BFF5812263682FA6CF4CE4C9126FCA1F1708A54596C6C3D8B3F8C9915AA0E061F2455D8CBD8976BA96D9EB6A4BA8348F62B7718D15DE2AEEA8B805E72345D1D29E7E499EB7D4F615DDD20BE17BB8FC7188E3CCB59B42B8EF40ED0EE9F40 +MD = 74463E33DB7443E64ADB4F5FD6BB69652381D4A3843EDB11606C57F46E478A89 + +Len = 1139 +Msg = 35EA1F5687FDF343A7AFC05028A6F0DC3B3519069A260543C0CFE54968441731F69542683480CCF2A638FD8283E75FAAC5B9AA3C2264BE88701E8E71A58742F7C7DA7BDEC9213AB89B8568C339427ACA8D11497B01E8A2F68C2702BD95D3BA665C388B7AF0CFCB87E48BAA072C9FE708A7465A57200A85A21A66B0721CB49E93D8FEB62B0830F9136DA5E18462A400 +MD = 2A422AC905B2FD45525272096CCA82CA07628C295573BE1FC8D2F20E39438FF2 + +Len = 1140 +Msg = 03C7B22BF3EA9840CAA63B4F1D042C816E79FC6A611ACE2BD8F4400ADCE54EAF6208DA56E54E5A1F64AED4F68F0BEBE288C98798014472D23028097B12809320C20A56AFCC83721974BA088759CFCC2B8BD78F4D14CBBA26F7C7FB4271E2389BE54E2D32261EADD992F4F96692A52F6662C9518A937A37C4F92A83337FB0071048E29C3CB0A197565263B37C20C900 +MD = F2CF026578ED6D07A13658551F31881CBA7796219E518CE188AC24354889BD67 + +Len = 1141 +Msg = E74F49AB1C5D5239EED54252D90AA7C0638184E8454E53B6676F7021E50AC7656368A5D1911CF9B26E6FBC17F67DDD5E7F765765192889290552BDEDF7DC3BBA7AD73976FD993944757CC458A3F608BC6EF7B1E15661ADEEB0065CA1C40A209C90CD230276A6F9E548E234339D5EECA2CFABDB1599D8F7CCF58CC772452D6ACEE4ABFCDF61B6B5DCC698387A339FA8 +MD = CD450169BD2FCDE1E21064E9A308E8DAF69CD54659FFA81C646694086A70D068 + +Len = 1142 +Msg = BD2F38B76FE144C9695BAE33AF7EDB0F76F0F25079D9236DDE3C5213E44E6B71B49878C55023F69E9760A625945706CF6FA262F294B93FAB898747DA5A05C0B06C73695F9B827132D163733F7B6E6EFFA16C35D7F2A0E344BDAFB18B0718C5744689FBFCB7A7DDE8EA83908F985C63D65DC26B971C43EFEBB4AC8B6C416231F680B4D88DD7A27FB4631922045E8F94 +MD = 06F55F7D33614442C79049E85DAA009038AD9DE8DE55E8A827F21DFD2E631906 + +Len = 1143 +Msg = 21254C00B81AEB85763DA860D089F5757C5659E39F73B9127A5B3092A9B1FAD24C8CCB407BD0B6F6504C7E10F672855EF7311074866D8B95B38FFBE75AB22D67227DB8A36E262F396B5FF253947A276B1D9954E7F886EEC0AD6B8DED19734FC4A3A0F9374D3ABA9BCAB67B0646970394EAC1C7AAB16D5285BB44F721B8A5D9A52D91444196D1A3FA019857D7048B1C +MD = 3654BC5D15E423914E6060FFC4F92695F5498825EF1525CF1D734272E9B8AC71 + +Len = 1144 +Msg = EA40E83CB18B3A242C1ECC6CCD0B7853A439DAB2C569CFC6DC38A19F5C90ACBF76AEF9EA3742FF3B54EF7D36EB7CE4FF1C9AB3BC119CFF6BE93C03E208783335C0AB8137BE5B10CDC66FF3F89A1BDDC6A1EED74F504CBE7290690BB295A872B9E3FE2CEE9E6C67C41DB8EFD7D863CF10F840FE618E7936DA3DCA5CA6DF933F24F6954BA0801A1294CD8D7E66DFAFEC +MD = 344D129C228359463C40555D94213D015627E5871C04F106A0FEEF9361CDECB6 + +Len = 1145 +Msg = 03DFA64F87FD32347B4FBCDF6E9C93C8F24DD6FDF73C0714A1D3F2238950A0B17E17241281312FCFED19182066E8481BF02860BF3159373E812CC0723559E989B619E2EEAC2A98A7D671D09342B38485C544D7604EC34F5B3E9B75127F606BDC3FDAABBFA76C4485FE3153CCF0B8D3AF0082DC22C3DC3B50A1343792A2F75434C7ADA300F426B2E372E6F4D78482C000 +MD = A8D8BEB23B2ADDB876619C6739B5B0051C1A514ACD1CECDB041DD80099EE83BE + +Len = 1146 +Msg = B7C48C1E18BFF9ADA3D2973DB9D7A9294F1AFC90C7A9BE72179E12A6D3EB74E71027718116582C133FA6254874BB2DFCA6801FDCD65BFFC6CA77AB064E78F9961FFE0A580E3444BE1E5F26EC81242D85F829577FFEB15DACB76E5982A6E7B3A7C57FDC71E70F7F9C2C60402E86E4C784727E57EC0B6FEEB386AEEB91055A16450D8B633DA0403A4FD6DB89949275C740 +MD = 6D49989453E51660CF1B906A1475452AC68E8764EEBEBEBDC2B43CD9C173C886 + +Len = 1147 +Msg = 856344695FFA7F9E71CCA31E66780E83E946374FEB320A3D0D4E944EE8AD38917B892B1E4842817E9B9572EAE8BE6340A1DDED6DDB8216944CD9D403E137F1B3CD53688043E145D6D5BBE9C6A5078958AC10A96F1FB9953983996D386AF3E368394F57A7BABE20A22A7D9F8F5AC665B996B34989CECAFA60A618743CB5970FB4167F6A46635090E32C381D9A8E68DBA0 +MD = 123388928E061CE1B97B68E7D104B597EC46AB405B1AE14809BD26AFFD2EE289 + +Len = 1148 +Msg = B037F0650E028765F25A5323E3D6DC8AC4E9ED37BC69F08B42B372328A99E38827E7BFFA32FE443D09657E3835FED992CD2AD84EC38C21FEFBF3E2F9E55690A2C176539E9E12ABF4A81AD6EA9E6DBF34AEF4AF2438805D9A5A6189A64317F81FCDFABEC47E963612CD565C792E4E619B7912C308A489C7C57875BB49D3418162DC8BBE776F351B71DBD7BE5DB781C300 +MD = 626932F7884408589ADAE08D46588FDA63487B9147377F6AC5AD9F847B758CEF + +Len = 1149 +Msg = 26A1E2EB41FEF9EFAEE544083D4069AE01DAAF800A88A35F7C00CACBE5789F19891574FB25E19F15CE8DD52066F3030CE12B9438E6EB929BE14DE20F064AC1A8E8E1B76B99448B1DF719EFE5BE37039C5BB5399D17957C796B9EE91F6488FB4F2003ABDE0BDB297790BF4D252041583EA1AFE847C9CA7DA85A28BE30DC1BAEA372057D120228E0EF01C4EDDFB54F8740 +MD = 448D9C282CA818DAAB0C7290B5584947F23AF543394EA0E9EFA7EB948802302A + +Len = 1150 +Msg = 44F98C05A2BDA1602DAE7E8BCCD93AF9F16F1A0F415DDA94D0037B2E2EDE5647F5BA095E1744828A51E1FD65C9BAC3811817F10E69CFD446DEAA9000092B508CCC9EEEC23F3B5E0BFB99A7262639A8B8CA8FC0F54A97DFF5CE43531ADE028F23BA5DD79DF7C23D4813B9E5D89BC1DEF8D8604FD6191CC370D3B55624C30203DC2A467693D9D0087AAB7E210D14459F94 +MD = F28028CBEA0DF5854CA27B78C58E632BC4809720EE33642B3CB1E14B9B0FC8D0 + +Len = 1151 +Msg = 47CE52119BFE9170B124036E93790352ECA551962985658BC3898D1D05919B7C62BD8809568C008DB20395B1317F4BBDF3AA2E982A3326C6E9ABFE5992EDD75583E9649636D9E642D1585806832B257A45D485E1B17B9264C9A2386660E18D7A4F7F2F862816DA8382AC9E4E0C3A599DC1D84ED57C69F7F172EBECEE7C48A7E810B13B3A3FBB5188070B05A7833047A4 +MD = DC47800481C0A25AA515FD362F4C33856C5F691B3027366342E250A08A0C282E + +Len = 1152 +Msg = 157D5B7E4507F66D9A267476D33831E7BB768D4D04CC3438DA12F9010263EA5FCAFBDE2579DB2F6B58F911D593D5F79FB05FE3596E3FA80FF2F761D1B0E57080055C118C53E53CDB63055261D7C9B2B39BD90ACC32520CBBDBDA2C4FD8856DBCEE173132A2679198DAF83007A9B5C51511AE49766C792A29520388444EBEFE28256FB33D4260439CBA73A9479EE00C63 +MD = 4CE7C2B935F21FC34C5E56D940A555C593872AEC2F896DE4E68F2A017060F535 + +Len = 1153 +Msg = D17D32EB803ACA60E349E8389738023A0D053F8753F02DBF1B525252DF546AD52B8F5A1AA36DE05C14DF40EBC6BFBB3FB3743AFEE9ABF4CD29D2C4D707372923DC7989781277637627925044E0BB0B79D03B899CFC97B05E10481AE57A53351BA87955D956236837FFAF5AA3D8354F4C612422CA3FB4AF509A4ABC7F120A990072862FA1A8E0BFB64D9E119D691CB32B80 +MD = 3C5149C75901AE99E273FD5B258A9E6A2A55E257A0AD125A0F90D99FB6EAC349 + +Len = 1154 +Msg = 18D8D02EA80EB2F461E55B0C55557EEF0468BBCB72B298DF8A760A7A70633D5402FA38E709B2FD800C5D5903A4E23DC5540A52517A6AE4C25A27AEE13C7F2D9F14AC488D926B24EDD63B9FF7B12F2773F22080C101BA2466797A5D258225F05D56803D9D3931B9947B6CAA2F637A979C3069344DB2D7F346FB3B0AD94577660121F2BC87B5E0D0F1D8D9C14680CE652800 +MD = BBE5FDFB3A174D73BEDF68B3EA0552D61565FBC24A0DFB987F59F7549A26DCC4 + +Len = 1155 +Msg = 11C02C0B259C1566EF6044F8592FDE9E60F3D53348C71A04C049E4F197C3506223D415CC18F867CA0A660324644A77C8503B129B9B7AD3035B1E7B26F4C0EE8AEF299304448B1546D35B1E7DA4A934D2F8D7AC91C67E2D61AB2A9DF72DAD133934E7CAF18C82823DAA4624CA2B79996773E20AA86AED4728CB40D3B912FE3E271603FCFA9D7A2846822DC33B8DF5DD75A0 +MD = 01D5C0FDA1567715CFB96299EEE68730B4E28EEBA1596DEA5A4369175F8450C5 + +Len = 1156 +Msg = 6503E5415EF398D9731CFBCCCFA3203C17580D31035D512F969F9CD9A8C17DBAAB8CCF7289F36EA81A312E0E2A087E196C3F6E82C37A58898BDB8CDC77C5A0E100B1DB136DCA7EDA83722333DEF9472C73F42017BAA45BFD76FA1DA558126EF57FE9ACE4B32763F1996CB578FD0A7E51FDCE9B4DDAE2FD761308F2558395DC247C7BB4A108166B4BE73A54F4A8DB5E11F0 +MD = F0D121FE1C3E5C67589FBF6B778E4750A8F5B383A551857372FADEBA29B0534E + +Len = 1157 +Msg = 2D04416E47394C0C28859633A9CF4B32B07D941141D2CEBF4ECDA5B00D91422F619800BE12CCB50BCEC630A4F8069AF9436CC63FF79B15F8B725935E4185701AF832BB99EC7AF362E831A986CDAD2796EA904A2B01466B2B94F17F2C6480556AA3A795C3CC57CCDBAE6ECC8221206D5065701036C8F95301E35069F682EEC1548C70B56474E314074BD869219EA9D4B570 +MD = DFAD893B66140528432FE5D174EA0ACC9E1F4E63C362A3AA96D201B6CB011312 + +Len = 1158 +Msg = 3C8A5A0334A2C9A8B4BC0C08A6C4FE0FCFCB4C95F09A966D2BCC432DFEB24517369C15B75FCB6D11C9143D22E5CB79FE0AF1081D9A5BB31B837CB33703014D908D83A61968F455F09AAF85AE01CA1EF1B8E0ED9D02BD2C47206A123E7B90F3A028D14F9E11B52BC705165CAE9B9A65F3A2228F3D5390076AF0B5EB53AD2AA6599DA678658D4E72E7E3025B59363F754EAC +MD = B4FEE8393673569A70097C5DDB836E2F93417C90140B002777E988A86582778A + +Len = 1159 +Msg = 12B830C80CE922F2379641BB7FDD4E0442D3856B4BB064241836053C4CD11FCD2A79A83CD342DB812AE961267819063897E0317052E8EA1B7C93890C74D7EE6819EB9C9C7BEF48D29C62BA42C47058D3F5FAE90FD30F8C49DA48138D8490F3F347F8999AE34551A7C748E8612CAA1D7151F680CE993DD807235FE50A3CFE9DEF4006393E1B0D63F8533765525D3A35E93A +MD = CA4229529911018250C019DE7CBA92B40410FC1B04967BB2601266D518ADBAF1 + +Len = 1160 +Msg = 836B34B515476F613FE447A4E0C3F3B8F20910AC89A3977055C960D2D5D2B72BD8ACC715A9035321B86703A411DDE0466D58A59769672AA60AD587B8481DE4BBA552A1645779789501EC53D540B904821F32B0BD1855B04E4848F9F8CFE9EBD8911BE95781A759D7AD9724A7102DBE576776B7C632BC39B9B5E19057E226552A5994C1DBB3B5C7871A11F5537011044C53 +MD = 24B69D8AB35BACCBD92F94E1B70B07C4C0ECF14EAEAC4B6B8560966D5BE086F3 + +Len = 1161 +Msg = B6D26954A6248D430EF24FFEE1945470C465009DB645AE80D9C96D0365081276C30A4B9962C898F126F94C20C64045F1EE8A3E92E053BC2A0E523E7C431A3E52048C37F4803308E8E87508108C5BC4268CBEE526F76E160EB143D6582F56F2CCEC95250F6E2DF32041F9378BA347CDA1EDFD1C20AF848F9763298CFF00ACAA53A390F44CB19CA2FC3F68CB1B002042E38D00 +MD = 92A4CF327BA933964D27D3EA3BECE1C525DF055830AE487B5AA081CAE69DEA70 + +Len = 1162 +Msg = 8C4E31FA1C8CDBD79E5FBEF356B59E9380DE9322F1F38A94C373DE21449A309D194226ECAC4C2A3043104D30337C455CE77061156208DEF5BB7FA8ECC6B4B121247D4E9AB472BF38262995C0E46AE9BED99FF12405B900D9E37A3EDDDB06D0DD4A74BB19AEBFCD7EAE1CE2236488D73C58EDAB5F9834EA0C7FDBD90F1E8FDD8683023D28711AC96824D2424FB444C8365580 +MD = A299ABB750F31CEABE652EE1C2544ED00BE93996EE194CC2FFEDFCF9FC34160F + +Len = 1163 +Msg = 4414CA5B0EFAB33109A7280A70B8133D70C0697D4E7FCCDA751C7136191E40098A542BD8966E16837A0B3CD80BA313A2B027536E4C0016D258477E1FC40678C1A815AA1304BFBD5485F58BED84E094641C412B94975A800E595AB2D654ED93FD0E90AAC471FD243C4C8C4572FA62C89C795BA60D610AEC5C5FB5310346EE4EAD650B220F41B49E50CFA6DA45D510E181A0A0 +MD = E50F0D5ED0245FE5B136672616BB1FF15F2B54F831D324EDBA497C474D6FA2C7 + +Len = 1164 +Msg = B549E5BE6D307AC5371E9A361BD86B4C140E61F2FF38B6D17CB6079C14961D7F795D443D1CE3F3C9BAD4390B5DF5B793FBF8E618C42D66E194C4A2D7CE4C3B0977259BE8005FD30B9A3E861F363875A9DD176BDA1BD050FCD5993E1142A7C0EB2B5E8CB6B66CAC6CF0646B19EB3FB14C4D9FABAF48FB70EE777491D760951CFD736674875D579A1A615394E08EE8C331A430 +MD = A20F98A4358F12AB1F5E79461096337FF187E0DBFAC7428ACB1E05FEFDB2B9A7 + +Len = 1165 +Msg = 901816742594C8C7DF11FDF358E919E98DB6317A965426E43CCDB094214CA72FA5AB808C0BB8DBA1DE77CA3F5FBAD80EBC85AC437DF212099F4510544C7163BF214E42968114EB0F7BE50227B7A5F10BE46EB4DC1E55432C39438CBFEB922A5DE1E2070388998542ADCD095B9D94449EDC473F64C011B90EAE24B89C0DB7F4B55B8BC8154EA7E6D35BFC1E47770D5ED43D88 +MD = A7CC217CF709A7BE4E7CC4BC73F1E4E1C0A65338529E8A43B4366EEAE257665E + +Len = 1166 +Msg = 68F3CA7119C4F03DF39F854337F916C0D2874CE0D41FF1F357866781C76449C2C5D628C47CF8DD4D83D37F84F1159333602DBFDB899D620D2C593935C3F60E504C358CE2C4C7579522921EED2756A9C208FE1D91CFBBA72969B0191B619BF1D58D7B635D590F80825439E09B75A41DDEC0CA46A6A680D2A63DD93E8A50E49B7D19EC0BA6B545996499D79CAED4DD2AF35270 +MD = EB1568687D3456F5CB256631AE2C1A16AD79857ADF29A90579516689CE88B1FB + +Len = 1167 +Msg = B9F9D504F5929F3BF59F2C3CD1EED63BA74BF1444D4CA4347C61F54B129520C0077C3D4A9885288D5D58B33EF84C89B8801CE6A11E4370E7B479E0EC60C5408B73758533243828F9A414F4D6280F66F84CAA1A05965C8E97199E2A192170188F6FBF55B7F129072C30E87FB726ACE803AF6DCA4ECA9069D550B427D7EAF6BA0EED9A296500C442CA4E97B013BDCF5CF4FFE8 +MD = 9696EEA20185FA48A159A9510F1D40C320309E829929C24E49BF7B3125C11D6B + +Len = 1168 +Msg = CC7784A4912A7AB5AD3620AAB29BA87077CD3CB83636ADC9F3DC94F51EDF521B2161EF108F21A0A298557981C0E53CE6CED45BDF782C1EF200D29BAB81DD6460586964EDAB7CEBDBBEC75FD7925060F7DA2B853B2B089588FA0F8C16EC6498B14C55DCEE335CB3A91D698E4D393AB8E8EAC0825F8ADEBEEE196DF41205C011674E53426CAA453F8DE1CBB57932B0B741D4C6 +MD = 19F34215373E8E80F686953E03CA472B50216719CB515E0667D4E686E45FCF7C + +Len = 1169 +Msg = 7578F49DEC3E779736091AA8EC290A2F2A6AB4E7E02DD02E655748233401F0D4B07313ACE1D7760335D53AB539EEA95ED166839427DA6B40FF95705DD2F7B6F73BBA222D876218BA59CA6877CA198C044BDEA0EA0C67D49796CC326A237677D6732F3D1BDA0F411F7BEF6BD17E26CF8729EB89A23C25D93C9B4A688A21DF1ECF93A62757DE81A3DE44AD98292CB5CC3D662400 +MD = 4C131C14791CD2F5673D4B737E2F78AD6E0E11DFFFFCEA003139209063C4259B + +Len = 1170 +Msg = EB14DE5434C648F26EDA4758903B2860FE1F57E40505A0CDF6BAF3B0CDEF2635017D42C42399AC686B0A23459C2F1D73613B389E7407BBA9D5F93038622B9ED5494123233B5AFE63565C847352B2C76EDCBBCE5A8DCB5AABDE305AD7C3A2F72EA4BDB7B71BFB1093D669B364E51ECC1DE046A6F6C6A5DB3FB791C390373717670E29C8DBB48A1A12EBE3CFC3CBD44CB1340180 +MD = 12C4B663BB2382E8B5663F21F2186C3FCA190481E0F9571D75FE029D777D4919 + +Len = 1171 +Msg = AB7B466829094B1062BA045DA7100C355D3942C06675FB8E304277EB3DA4F6F4AC99FE0E69862363BDCB79C2593DA19B435D83879D61FB058C2DCB0AC9F3C489AC54D787937297E53A400C96543319F151BF1218A7249776B8A55B2DA79C4D659255AF260A7E63DCA829079554244B3CA82CFBEB4C19FB5BD6C69D97AF0F41854F418619706CC5E8F87A2B2E8D6C6AA7C8F800 +MD = 443BEA197FF89182C33D751A2A8E39D33525EBF9ABB04A87371AAAC4C669D0EB + +Len = 1172 +Msg = 910BF093C0DED15736115D84AF3E44E8314B77C31D72BD72C4F4D0CD6C567ABEBB245C216A5DBD914AF09FCF09FF3CB1BF0D2F19BDE7B418891B02679A6EDB0D432E66D83B155E71A5F8FF881D54F03C568C501726176CA24E0CF3C80CBAE4FB55B2F8C8AD021C43D855072C4170E31D45AE6C2F1FA467C59D38DEF1948E9A3496DCA570DCF5BCE480C7B51D9233E7F928D920 +MD = B8F2C23967DDCBCF8DF95588DBC01B69C753D5AD04F378E4FC7E4227FBE04871 + +Len = 1173 +Msg = 6C2317F5B39417E3ADA7C71CE7A8D69DDD1E25B607B86B8BE099111D64D6DC7C4A2B7D9CF60A33AD7650C21C702C968204F92CBC3D2BC18FA0EC8DF49F0F4B880E5C4E144498DF0DA067C7AF37EED9A6540885823BD984957B2A0EA87DF8264EB4BB17B26C68A9F9734BFA6FF6EEDC6C5C8A6BB036FD4D7791455AA5569CFE6E643745252450877B62E2116808CF1CFD882758 +MD = 064D44FF2C5B2D0DA5B5FA0D23212DD2D36621667D8DA3FB01EBE1A833817E7B + +Len = 1174 +Msg = 25D3A9228CC1232F8F65C1C95AF61637C115D4516464EBFA6795BF778C5BE311128F5F41D70465487A22C32D22F1D9BDCFFEA0547996207B913A6543516EE27694B7FA7FF182074E0C709339EC36781E3C91A724326FA5AB72F59032D4FAE15B6C4F512FC29EF0D078FF6010EABE0CA1F2B57E351FE5AE34C97AC09C81FAFAF251CB1D21F76C8C3FB16435C0B057C35F9E7B94 +MD = AB004A687D4C815FC659920F7DAF6E330EE2E2D77D37E4CCC8538E9E3CABEB4C + +Len = 1175 +Msg = 53DEB99B91DAF23B4467DBE3B98FE9579D1A1766A235585D7CF6D65C10C844C6EEC0D59C43BEC7B3117A5E42DD35EADC84439F884349AB94FECF403C1944F25BFACEC73FED352C49D1D6D4CAEE5F0F58BA1D4E27388E87E2EB9C0152D0705DC22EAD4A8EEF13C2160C9795ACD51FFB73979D5C21AAAD813F0A9E1A9E6E0B13F6F4E7E5314250620BA1B80953EA80F8E821AE9A +MD = D777681624E89EB72070EFBEDB143295C2D84BBD7D703AF3E1FBBFE6132918B2 + +Len = 1176 +Msg = 7639B461FFF270B2455AC1D1AFCE782944AEA5E9087EB4A39EB96BB5C3BAAF0E868C8526D3404F9405E79E77BFAC5FFB89BF1957B523E17D341D7323C302EA7083872DD5E8705694ACDDA36D5A1B895AAA16ECA6104C82688532C8BFE1790B5DC9F4EC5FE95BAED37E1D287BE710431F1E5E8EE105BC42ED37D74B1E55984BF1C09FE6A1FA13EF3B96FAEAED6A2A1950A12153 +MD = 290BD4808E5676EB0C978084E4CD68E745031659A26807AD615B10CDA589B969 + +Len = 1177 +Msg = 9AFEA0868A1A5BDFC88B78BD641243C8152D8F9D1601A32815DEF06CD9EDB6139B0E0821F742BC203B6C3E550B80948FDDA65FCDFD427BDAF90E6F94716EC99E7844B261CC6F1FE737195E0DEA72EDFF6BA96992D59747BE0AEEA610B7F0FFABF12B86C4E17E5F79501B9F29668F8B2D7505410981229B445BABF8A2A5D1BF38C9D0F3668C6893C5AA55E13B3BAAC6C49F47B100 +MD = A00DA2CCFEB7DDF166181944A9833E3ECBD5AA651AB92FB1B392E445DDBF5C01 + +Len = 1178 +Msg = 5866E10C6B7ED7A1DCEB9362F737B4B2F51AD1747915CEA521DD190734DB6C58A69E9B807B6E91651A77FD1C018D1B9F237ACA44E861A8330D220A63EEDBC9ABACBE57B70850BC9E70EB95D3D2F611CE07603C394799997716D244FA8DB4B5B3E91178CF93A050D6F5AD5DEAEB039F4511593D533BE38A2B554B470A33C74D070B04592633D389FF6C7530577ECF0F572A31B280 +MD = 20CD738F3E5C32F36742E9EABA3A1142C1AC86E68B0A38CB50297EA26B18EEFB + +Len = 1179 +Msg = DC5F38825ADF0C2ED13063D7A142494DE2FB8CFD78718CD87BEA1B17288D18FC6A914D6F2B6BDB7218DE003CBABD3F2B5C1248DCA7E221FC0B141203BD7C96AC3D6746155147363D5C75E4BB05D6AE03C0DC4B8CCEB689AF6CCEDBCA79F2FB901107C8F91CB146E57E79921097BCE553DEC9FA17AFC94F55CFEE76C4B9F8379B3E87857B874DEEEAA140F6DBF158CB5E42085360 +MD = B70FE51976B8A4D96184859B52BA9BB22BA0D5C405D30A3A7E5AE86E4882FB25 + +Len = 1180 +Msg = 788BD86E95800633621BD3314977F9BFFD02E73D885AB580D1EF3DE480103FF2C449AD81B2CC15CAAF350D794E48DF3F64804B5DC5ACDA419EC34E95D50A6614EFCB4C6DA3267F26B75BFAC3C87CC0DC81C2683EAA9ECE7C3F5E7847ECF00FA1A9043AE5A90EE15F8B81083F38829933C8C75DF3F08075847F2B64F29B973BABB18592438F9A69E20BE11C084372895E91B837B0 +MD = 41DBFA3DFCB7916FAFB605654405A98B824535184AD0E08458FC7712B1E0668E + +Len = 1181 +Msg = 375B857529A24EFE7A78B2CA46E1A4295912CD7B739AEB1CBDA7BEFC901EB4FFD8BED49F3366E4E8C0EA1EE938F60E17D2D0D05F5100F288415CAC3F7E82FD30689E2CC692BE02CB3E34CFF7D3DE7975042E3C5C3F8AE348FF3402A6107583E57C8E038D25668D76E43772FD92E227D5C1E8330A929D342CDF8DEBE1D314C88EAED559A13461772B73CF39093216C57679943FD8 +MD = 463A22B21B8211D13A794C814359F824FEE4F816A36314D91C76259753E8370E + +Len = 1182 +Msg = C40B66822F1F282D598F05CB2094EC4E69419FFDFE3833672A289B4ECF43EF408EF4862ABA90A81570E35E73EE4809E6A02CA9F6B14D96AC2C401045F2D5D86137051B4D3F5556961DBB96CB32CCFB38D215F826D00986037C6012EEA06B9FFD10170DF6E4E20D75A46C8F7A345B3C67917002276C73F717E4E61ED4329C3E03643E9D56FCB266498DC37A72A932F3A890FF1CB0 +MD = 4994DD26CEBD9B496A56C49868376EFB3638953D630572B40BF458ED3BA7A2BD + +Len = 1183 +Msg = 494342589E394B324577E17E59EC8EA27F4ABC8D0454EC70AF0BE40FECF638A278A290137220AE9F00A2CA70CACB85BDD4013823917DD9E4AC1B5E00521D3F385729AAAD85AEDE5B8BBCC9FD1F97AA614FA3176DB83D192CCF775BB5A3C51F9CC9E1E6639B3F58373BDF3F20CD2F7BF780336F4F5F12AC6F3AB01DD1A139D067FCFDEB184B291DE76C7D770D8EC122BFB4CF890C +MD = 88A85E40B83BDBDC9D41446DB278A9F10AA39DC4D9E7673CDA1AC26A5320928B + +Len = 1184 +Msg = EB6513FC61B30CFBA58D4D7E80F94D14589090CF1D80B1DF2E68088DC6104959BA0D583D585E9578AB0AEC0CF36C48435EB52ED9AB4BBCE7A5ABE679C97AE2DBE35E8CC1D45B06DDA3CF418665C57CBEE4BBB47FA4CAF78F4EE656FEC237FE4EEBBAFA206E1EF2BD0EE4AE71BD0E9B2F54F91DAADF1FEBFD7032381D636B733DCB3BF76FB14E23AFF1F68ED3DBCF75C9B99C6F26 +MD = 70999AB9818309AFA8F1ADC4FEA47A071A8ABD94012F7CE28CC794A0D997C5CB + +Len = 1185 +Msg = 826DBB35FA1752054063522EBD05A746B5AEC31C1B27031080BF56A79BDAF998065B5DB044FD6AF4E14A3AD246CFED7AF104E8ED2B63A696489D610DEAF6128A742D669FAA149CAD862F467D73E53793C1C8D6237839F5677D5CD3FA78816B41E640C62F9D593E7B94595CBB1DCF3AEAA0CB05A88F890AFF71F30C8629FD3AE3348CC7338B1743B9E5768DBAA8BDBE6446E5DC4600 +MD = FC6DA7DF19ADB0DFC05B703133D05CE72463AC1ABB0BB23333FACAE57AC508DA + +Len = 1186 +Msg = EA5C8DFB574F00CC9CD3DB9A5D499C2F722A35257347A4A80B4C141ED02DDD7CEA584E1608144B6D579029730244ABC25DDE51EF19772376D2607A13ED513BA3E43D6ED7A99553D23EF2E0171538FEC263EFE422AFF4B723BCD0B85E3FDB07E2DEA2CB66C8F4F4C6D9138914E6ADD822E276879A122F75C14575FC77A7117F05E274A029ACD74F8DFAEC843DB2581CD778702BF8C0 +MD = 202ECFEAE5ECDD955452C4AA40899372AEE7D82178085859CBF75643B408B764 + +Len = 1187 +Msg = 2EB70DA0700DDF3821FE877474EE9F5B8A516C8818F18D57E2DD3F85E537B4C47CDFF4944220BE5084212290B9EFB10D7099A12AC41DEE0C6D7DBB2FE376DC8EBA1A845D5DA62634E7C3C15DC2DD6C6F44BA4B82B73D7B58ABD41A35D2AEFEE2263155A7B60CF2454FE240FAC4F8BB75A0829098793554CD2617CD7B02307848100EB5CCE098520C167F42FF4F32CEBA6AD91B45C0 +MD = 40230018F9D2B28B9EC43FD912D5850D7EAECB0638FF5C01E26D7BD608A41F22 + +Len = 1188 +Msg = 1FB040B1196A11132472801DC17BAB0A09E0A85CB66DDC8F19415317B04A2B854E0C3F798AC6488C8FDB452C9A83E23FCFEC96C5CB99BD6D5FB53415B3A24CED6925B5092E75EC4A91809497C34E1634BD1F851DF04896869F105CAEA4B881FB1905113B67BDA4507CE676F45B65D89893E2C2FD9D883041A8F7AB576FC927A51C3BC97B18F87903E421A7D9A26CFB5C4BADE82DD0 +MD = C0B3CF50D34DAA4EDF5DECD4F3AD20D40A8FF3B2A22FB362168263D2D008513B + +Len = 1189 +Msg = 0AC19F7A5B5B5587B57EB2A3DD742020D6F25DB96E18D88B96E264C6C7CD95C39056C62E262075A89C2E9C7F95B7DA28BDE2EFD0AB61E08CC24905D3758C07EE9E044E08891041B3EE94DEF1CCAC41E213CF637289E859DCA3563F38A410EAE04B0256464DB8AECD6AE02C2F0750E241F825B4BC3D2746CCC41FC709ABC5403E6B8AD975ABD5086EC452D7E4EA8BEDEDFAB8057C20 +MD = 6CA28941FC7AEB008295A64D63D5BE9BF7D64C7A435B76A653A0FA0D28581978 + +Len = 1190 +Msg = E5DBE6EF5D7C8260E18896A8118B42B75BF6891D7B79E784213C7385FC06DD68637A4ADDFD25374AF0122C04FA01DEC789B6BA08347EB226F985437D6EB855DA96EAEA2714373ECC6BD02BA3C77DBE2A6CFAB6FE6738C6DDE04A8D7D107CFC0EE87DD66B850F70D2C676AF4EB9ACB0C771A2EB9495F86C21F8B59847A53F8637863D0D29D5015F0129CDBA4819755F1339840C15D4 +MD = 5598939D1227C5AC439FD04E121E65FB2D04EE02CB5413CE10EA388EDB8A0AAF + +Len = 1191 +Msg = 59CF21660C207C793EC978C2D02834BA9BF79A9F6B47164193BB3C45F7195B78485EE73640CBA87D563627E6F08CE6D621EDDA03063CF51810B56B1E03E6601545F5BA3FC80AE74F055441DEE6AC31B02363E7624734D89259B52D69108C2839DFBF4E64553D09F5F5A4EDA85D7B69F9E668F78156B06EA4C0002F33495CBB464808DF0F48F07D4AF65573889E3C10CE188F7015FC +MD = 43B7EC632B32FB667D9177DC4A62A1F21301CADE5BA3F0A6477649EBA0E10A1C + +Len = 1192 +Msg = 1594D74BF5DDE444265D4C04DAD9721FF3E34CBF622DAF341FE16B96431F6C4DF1F760D34F296EB97D98D560AD5286FEC4DCE1724F20B54FD7DF51D4BF137ADD656C80546FB1BF516D62EE82BAA992910EF4CC18B70F3F8698276FCFB44E0EC546C2C39CFD8EE91034FF9303058B4252462F86C823EB15BF481E6B79CC3A02218595B3658E8B37382BD5048EAED5FD02C37944E73B +MD = 83120033B0140FE3E3E1CBFEBFF323ABC08535C0AA017803F5D2F4ECB35F5DFB + +Len = 1193 +Msg = 880D1E3AD14193B4F50EEEF144EE2B95FD817D157521EA14512CDCE43B1E498C0F3DA6906B3152668B79E542732D3424AD8AA392FB1D951D88AFEF7BB419E9E6630F8543E089D44F8397E420A0EC1F439AC2B1353C4B811D752E3B9D47C2220FE490ED4B2E78F63E8B05758417AC89B62CE2776156AA316C07414BF840B61D2AC875C23D313354FDCF2AC13F48F18BE75804E42E2F80 +MD = 314F089789DAC8E432F20EAFDCE760091780FEAB5FD33FBB32BE6293E042BFB4 + +Len = 1194 +Msg = 90486823C70519411AF34F204AC4138D7B6915C43D1A0910955E0DAABA761C55E1AD5F75B2A834DC90558B112BF80D24B9969DD22D1FAA4553F94AADFF5281214F3B41D2E8190F83C4B15B1545766B78C73DAAF920D06194456D3069DEAC4344C176753F5E6A7DB6955CA6837123DC12CD19D0D46DD3DEE721199AFD8CA7BE9D8A08A85E5E97F720A82C6BAE20A6666322820A466A00 +MD = 8D25F7E639939B7DF914AAA69E2189294B6E1D99248DDF02A198084223D3D1CC + +Len = 1195 +Msg = 1554706EED3D3C4BFF57E5ECE7E346FDBCBFEA1369C8819813AC26F9CBB9EFA54000343E9FC91A1751B4E5017397936F63229AE21FAAA04049E3EE32808B31EF53818C893D67248835D9A9BE4F7A72466423A1378666D95769203303F2933452E302DFCB870A642118B37BA723F88E28804AC1E39DC81FA98F6E2D150FBB5B05FD19F527F4B601918255BEDB7ECAAF71D83B5002EAA0 +MD = 63A856A19F473551ADB58226E78C23D41F00DFD8E2ED2B5C53649A34A9430C57 + +Len = 1196 +Msg = 700516F8246D73E28CB79EB2AC2F806A67DEBD5CBC438F9B58FB02B85E6667C3E96ACF02168F83CCA0AB4560FA6A31A10DCF638B2AAE4D0EB9DFEBA4EB723D574005659B72D3596BEA991809290C612D90BA4448A8D413E2B8B07F41E9AAB65761366D7A19C97E3ECA66496B16A5556989093937CB365B029FF0DECFF7C74E26810D7E00CB4EE35D965F19F70046FC5A062386C0E820 +MD = EBF7611538453ABBF40511DC484FBDC7B605280B88B1D04A01D38434EB811765 + +Len = 1197 +Msg = B3151A083EF4ED82D6FF662D632D3A15CE93EDE988CD7E31EF91E2944DAC669BBD8D4EDF28B07C0809A9D7965AC023E143A9D8B66C8442A51283F69E7684000B8C8CB3CA12891E3B8AD8CE342514F5671FFF3506D937D734505D1B7E4557CB69B83D76F15806C56E6696ADF027C497BD7E30C19B92E2F5E4536808917986E59FEA339DB1B19186495DEC650DB7B85EAE5925AAC57158 +MD = 2E7829107F9EB756AE76161B2DECF8B44A1287BDBC7A8043280CDEF973B137E2 + +Len = 1198 +Msg = 2BE9BF5794E6A8EF2BA1EB5DA245610577FEDB653B12EAF68DB8FCD5AC2FC0495475912D5F5D83E81B51098F9A7FBE1E2B4B8D5370EB64FA98B73147C0DB53C74D508BF0BF96C0DF5C6F765C94E4DD1A00DE2D3F86A6A67B2EAFCC31E97A0B57A5D068E62C59D5CC2459DFF4B5F385E8D360918E8FE7C61E0B54369A7DAE211BAD3E0A6DE8D798399A45886D2A1F14433A20C46B640C +MD = 3DF7D323FE1FDC75C1E88B064264447ED0FD9C8BE8B28B8C4A55A6DCFC06129E + +Len = 1199 +Msg = 513DBFF1209835CD5C01E7FF2A85F1CD70A37CEF3D61897F88C25B40D448D7F4A14DE631A2B44E366238CD1637DEA9EA0437B78693AF5F1E37ABD61BEB9A6F302FC0958976D7E35508D79052C6CB37CD0EFF35031DCEB6D9C0E6E8321B2A79BDF5C97F1AD9EC9EDC27C359B0396A3FF4A276A8C3B6526599C90CBEF761FFBB4722CA389597F69E9A67BCF5403649252A857B56BF6C12 +MD = 02FAC01790BD2F15C97B259755C9101D439A6EE0F0D831E4D42D58F89EDFEDE3 + +Len = 1200 +Msg = 4CFA1278903026F66FEDD41374558BE1B585D03C5C55DAC94361DF286D4BD39C7CB8037ED3B267B07C346626449D0CC5B0DD2CF221F7E4C3449A4BE99985D2D5E67BFF2923357DDEAB5ABCB4619F3A3A57B2CF928A022EB27676C6CF805689004FCA4D41EA6C2D0A4789C7605F7BB838DD883B3AD3E6027E775BCF262881428099C7FFF95B14C095EA130E0B9938A5E22FC52650F591 +MD = 5584BF3E93BC25945C508B9188D0502C6E755BBEBABFC8CB907FA7A252EF464A + +Len = 1201 +Msg = 0409C9EB80912B2931EEEE3255E452201EFC972E6427EA1C9FD8DB51DECBDAD5145B0EF578EECD56ED3D9026F65705B30ECBDB27B32866ED5F6205E72899BD9FDC76A81F4613C4ACCEE9D0B19CCCAC6EC99C93A0F337BC2B9FFBA0EF5C2858CA503F5B4D2974AA0DEBB407F5E01D707DE7CBB96AB993672FDBE46C6DC462A1BD38B853B9038B45A9023D14585CD3F21F761A5329930000 +MD = 5964D6B9F8C58F32FAE8A6F7306E01849F0A8343AE0C91D6F37BE5CCE247B204 + +Len = 1202 +Msg = E4C0456940913E4F1D513208BBFA725EABA66714F89D4830D0B1D3EC3EAD6944A533F661AF7F37145C5550EAF106A6E5EF75647EC078C48DAB5579A71C3F1394847B329951806F160EB4CCDBA77033F21665ED9A6CD872B207F83CF006F5DADBA8A2FF05CF7576648F87E32C3B3DECA8539F65CBF65663D761C3F6C03EA66C2F60FC18EF7C5200B173E9D136A16066A9022465AE02B440 +MD = CAF3196F2B567E817D8C796DD2BAC983DDC9F37657F3B20934A4A95C3CA66C97 + +Len = 1203 +Msg = CF2B1D3749F0FCFE15667C2180E01A3090C60387B864522F06C8C6754F2655359FBDB91AE7EDEA95009470FED761B30641DD3B98390EF85B4B8BCC927D63DFB80DB643534B65862AC148DCDC95162D707022510F9996689AAA1B4B50C6A8867A74B11D00B2517FC81D96E8D1BF24CF0ECA862CAC750059AA7BA1B81ACE44DA18287DE4D7AC0386917F3570BC2C4E3ACB6F233C85406EC0 +MD = 79B48AF23621DF99AAA5FDECD4EB420FC84EB929ADA451E0D1F423BEF929A62B + +Len = 1204 +Msg = 78D24A6EC44983D0836B45520E6218A0B017F82547E8EE1EB61C8F9D6C5AA5A0ABB6B0635320B9DFD2EF8C4B3523AD4AEE16B24F17A069B6A477F2797FCEDC02AA9499E4EA579CEC79510288C11FABB4D1625EB84BBF4A20DD65C9D406E7309C3D897F83CCAE2BE9FAFF2E2303A86AB75E424425A339D2C6E2846D64BAFCB9905F84477132858D0C03F5F546F6D30D108253AC76B64880 +MD = C9D87E47B951D375809EABE2358B5CAC14AB0716FC0C4CB0CC1A88AC63ED17C3 + +Len = 1205 +Msg = 8D1B3A5DD6AF7423E91EC02A68D19A902166B12968BA6A9B3C2C86CE746161B434DD2EC00607563061DC04EDA5646DD5AA49B1DA5CC7EA2BFA64E6832939EB1E70B61D2E0A44A519E9C6469E7F9C0C3C65A819F306273DBE1022946675E476A604FB08A1A0FD9DAB905134FAD2F26E732A69FCD7DB11A1ED353E24841C400B0A4AD734A8744B024735E8F98A9F7FF39A0006A1B3F1BF10 +MD = 2FC002E1D3E666812D75E3A6E1C096E20C0DDA3F52FF6876630B0DE9704F7A68 + +Len = 1206 +Msg = 91544241F70505C5295091A16575C6E00E55CD65D205CADC8EFEDAB50398B8CB34BEC20FE7A5E4D31C79731405DAA46879B52200B8B2B114B22FAF7B7B9C3BA530D76BFC9EE733CEAF49E4A14DFF39872019FF7A1196D8333076BEF518B6410F764F60F413BE7969F56D85972B6C5B689E9400038211C3238ABDB2A32AF962EB2FC8E28355F594F091B5675BA0F6B042F83D6BE7876234 +MD = A6AA76A37C86A060299A7A521E03717E4829AD017C73BC8D14438607133DD54B + +Len = 1207 +Msg = 56E0C89263D8B0EAFAD6AF1035860FC6C542B1B7B9B9B434D29A3A125307C85C882DE03ED68BBC937A6340970933C89271846416042640AA90F77C9C8F670FB4123D9B628799FEF18C87AB4F914B2419DACAB45D2E0FDC686D48171EBBF17CA4DC28A7548C0836B996F6C387631AA413117DEAE5A1D380B94DE2686E61476E230B2ACD642FECA0D769482E30170888981505E9FE8CD8BA +MD = 36E3F6EB9CB3E6F55EF4905FDC9CF5A8290BBE23C6F295BF3409A45764250759 + +Len = 1208 +Msg = D3E65CB92CFA79662F6AF493D696A07CCF32AAADCCEFF06E73E8D9F6F909209E66715D6E978788C49EFB9087B170ECF3AA86D2D4D1A065AE0EFC8924F365D676B3CB9E2BEC918FD96D0B43DEE83727C9A93BF56CA2B2E59ADBA85696546A815067FC7A78039629D4948D157E7B0D826D1BF8E81237BAB7321312FDAA4D521744F988DB6FDF04549D0FDCA393D639C729AF716E9C8BBA48 +MD = C234B252C21EDB842634CC124DA5BEE8A4749CFFBA134723F7963B3A9729C0B4 + +Len = 1209 +Msg = 558AA1969870FA3F59EE259B5797358ED42E6B3F7E7548FB4C7985461EA9E3A65BC021FC95626DD462FF2F99BB5A6A8E19AA27AEB184F41630E67D3265688857C61AC58B205406BFA6F02C6D6463C33598F824F0387C86797D8AA9EAB639B6A77B7076B52EB5398C8F31155A6A1BBDAF2DEA857C798E8F9B3168CCCAAAD4EA37C5AED9BD9E3B94042C94963C5064F572B163B6A8A6CFDE80 +MD = F51CADC40F85B8E10114283CB0E542E86AECC255A991024BB55EAD52E2780264 + +Len = 1210 +Msg = B25A91F9A28E69447149BE857CE03282351517AF22F6512F7EE3B00B161125EE2673840D5765E9AAF2098732E7D9780C31452872AB6CDD658C5F2D8A7529D0E622394C26A03B11F45D15DB0FAFF43107B1B750B822E0433CA634354EF8782216ABB666D187BA1486CC3CC923F4A270300886B4CC3FE3E4507ACDC605EE440733F786852054662E43811CD1B77D97E6829C3D7AA9084F0CC0 +MD = 0CF76725ACBE948E015C87C8E85BB9B8DAD8F04BE53A7FE97B99011C55CD508A + +Len = 1211 +Msg = D5BC5EA66BFF1C5573168AB9E814082331157B8B885C9E4976088A7CCD342186CFD88499887DB0144A9743F13B5F4C402C18A6B060DD8DF0101E1C11482E109AFC78C0C6352F7D4AE47009A3DFD2AC5B3C6E08CD253D717253FB89F94E98DF386FB09333A1F4E3BE1792ECAC7C2CAB28B447ED0363A5EC84BC1E26A2AA7F3C5208E0C0015125155C63A4AF5787437D7CEF410CDB393A2FE0 +MD = BA1FBD14E86771E7C6EA16B6A239D00251C0E747691B473268EBE8924905537D + +Len = 1212 +Msg = 7B32C25404B828B7975B85A7F8E808CAA26E48DCE8E28C5CD0D98A29D3FB1E34D09914421C693BA70EEA3CB5C79F8842B8EB70DF6548B223B14680E31566C6C126F53EE77A0C5A4FE46A6DD6E81E1281E39F5CE580204702728509A3207AB6D316712D355125F8310026321D2E0E318B58C6E6E49CCDC867BD908803FF4AE066A9AF402FDEAA1006B100679A4F68145588C21E9D569C5B80 +MD = 1BD57A0DBCAB8DFFF4D618A42E1EF77841908CE548FD4C7DCC71288E88050C93 + +Len = 1213 +Msg = FFD56A3A7BFBCBB58E076EC15B32FDC6515E6A3CC797671D8291C7F9905D5CBED34607D713D1FACCE5CF240F4B0CEE151A43CB96FF832686832E28FE24B603D95FFB82D757B2AC496C80FDDA8E5701DAC77F597DE05D9D74008652CC06E5A724B3D279A43CAB626EAFA8732B446CBB24C2A574EB6DB20C736678B65B71FD0BECA4004C0F6BF8E656E754CED34295FF3B2977DBF083301050 +MD = 98ECA14A1249DFA1D6ED203FA5F2D0C67047FE168568BDC3BB93B97FAFE73BE0 + +Len = 1214 +Msg = C8ECC9C02A54BCD934F3AA9416D4C8539BFC445C20CA833678394503C6B87091B8B51185859DE712FD9CF8EF6DC4237811312F1BCB9276D88B256CABCF2BE94A04B91FFE528B3CE13E68748C16D9370A228ADC895832FAB7C425E3D75A6B1901DE47993CD484AAB82EA902C6332B5888BFBB60415F4A0B05748EA088212D8964228A5C1899CA4F8C8F21C1236FA118B68B5287AA0A9D8F04 +MD = 3DAB9BB3ECA13DF900FB629BF359B1654EB9993E090C46E31F2FACF9B06D245A + +Len = 1215 +Msg = 625AF287E043C8F40C535BA8495B07A4F20310AD069F1C1A1698E2FC2682DE1294F7290C5BB7C4CA4397CFB9380ECDA6FAEAA39230513A145646BA120D95E816CCE3D13F5C9E6F667B2C17CA6D20E29DDEDBD74BB7051F3F61826A7554D537A26261D0B5759C615530D36139863811429ED257F8D85F30BCAF67D10B9C926C398DBEDDA79C0F7C858BC1C6FE4EF20DD3580A1419F4414834 +MD = BAAA7000207BE4236B2D0144E7F1887D019248AE5E9D06C486F8ABE83A206100 + +Len = 1216 +Msg = 842CC583504539622D7F71E7E31863A2B885C56A0BA62DB4C2A3F2FD12E79660DC7205CA29A0DC0A87DB4DC62EE47A41DB36B9DDB3293B9AC4BAAE7DF5C6E7201E17F717AB56E12CAD476BE49608AD2D50309E7D48D2D8DE4FA58AC3CFEAFEEE48C0A9EEC88498E3EFC51F54D300D828DDDCCB9D0B06DD021A29CF5CB5B2506915BEB8A11998B8B886E0F9B7A80E97D91A7D01270F9A7717 +MD = 645F25456752091FFFCAADE806C34C79DFFE72140C7C75D6A6ECFEEDF6DB401C + +Len = 1217 +Msg = EE795C10211EA9D303C7C8333C6CDE90E606A65C1D5D73C4A26645EF592950FA96B2A666F360A3C56C3C00584DC2BCFAE83E35B738DBB63C65EE199D44EAE8D82654007F9387327378678A82B649EFC8E44EAB65DAD64F4087BBE76BB90060B161B9826B7AD0ADF81F503BBB964AF705F1376DFAE246DC5C4B4995BC2AFB4DC5E43FE44BDF5B66B949AC499E615BFB04A0DDAF25D6A0702300 +MD = 35B6E1FB49C1B5822D7CC48E219D91CA29CE188AE8AFE5CE6DEE712EB39229B2 + +Len = 1218 +Msg = CFCE57319D4C68132C9491522458BAA42493219C4E61CEEE5248F6DF0A65CA2D82C846BAFA01628DEC4A07911F1C71C4DCE7AC66AD005A8D973D3E8D646C9EAA47FC8FBE0899FE69A43BC20DFDD262756B7A703DC6D1A271B544D7E8EF077C3EDDBD0784FAC5B7AA197F25E8A83E1A507D0A893E24FE2AD4EFAD28F65C8682EA423223ABA8E04E48EAE78BE0F70FF0F0C44749AA4972A4F1C0 +MD = DA6D4E1C699A1EDCACA945C624B854DF903B4D6B83D603CAA8BCE083B966722E + +Len = 1219 +Msg = 91B24F53E90CDC482054BAD312C5126F80154C3AE92C1680A0807B2592EE95AF75C2105FE437C3F70F6B6B06F98AEAEA13E572FFD42024E748D1BEF6044A54D7D057303AAB3D5B940D2DEA3C405E667484334A628F94312086D72E3744A75EC43B645879D45917E7C587A27573B63BC2318E080767808BAD0286F1EF1B41192667037DAC968D784B09DD6342B31CAD52E936E65B8F3DC097A0 +MD = DDFF7AC91B5B524D6F7C82092F6C369FCA7A0D804F875AD3A3C8B7C440FED0F0 + +Len = 1220 +Msg = 77E951D75C4B0CAA1BD37CD917B05E25F17259FD831CA35166350425844422C59B85C34E40262A01EDA5EC99F4D0E1BA62D371284CFF46FD1ED5152C3AA612F279CF48095157FF8CD0A8951CA8C4B56DE177BC493FA3601976184D05F2D34CDCFC9F230DB5ACA5CAC3CCD60A05E67FE1FCD9D23930F1D4708697B2B226CAAA3E4B89C97EF142F17D56A2F417207BC51F4F30245624A1647900 +MD = 103CEA662315F952489CFC8A608CF905B3B01D4BC4F4F5BE5D1ABA85717466FE + +Len = 1221 +Msg = 78E4FD46027326BB88D6C727711089A2A4643BE28267B6BC224EB4105B4BE07B73E28A2A97C02F17980F296B1494BFA51158D4DA1DAC27569B7598D8B11A10E040497A87E892EE035826CF948CDD957CF23EE17E88228849E00E8839B2D2DEA60C3E2CC0C7AFBA8EF335E9B8A0610EC25A452533D1F3AEF251166CA8D384E440EA616BC416706C0FF8D6613B89D62C6E5BAE80078A6E528168 +MD = FFB638F8FCE0F51CFBA13545D2D8BB7A85AB6303675EFFBCEB2825DEF0E3B493 + +Len = 1222 +Msg = 49A1E08F3F4B954DB2998AE9F6B6E48A5E0CF52CC402CBC34A5472A5FA7A5C16C2818EEA453408514394F390DD5889D58FA6AD8CAF373F48F58E7FDCD1A769BDC47B24D8500CF72488D93453ABB336A82D689F0B983600B80623AE818B00108A1CD4A615C9648E1A2D095DC544563E19071F7C4FA13E01379B67A723E58B6CC9620F2D93CF7D6B25F4346E3932E8322847610E718A41F3EAE4 +MD = 14F85815327BD1D7EF8231E8E20347676DBDF75EC33E0A491D6042E952AE4726 + +Len = 1223 +Msg = 54C62479E70B5E674958039D5B0A720C878A69C9197A905B0445C8241F256DD80F146545F4A97F8C3C3CA4D9AD5F27E2704A98822CBCAF9A1F3D32B8570406C9D9CE13ED2D78FDB5C2827A4BA9DE242AC09C26DB0AA135B06FC7506E3B9AB45958059F151919A99B3E36F7E4331D7620D6E720A9A20042128CF47EBC231372EB9A1B7C7C16B268F375447DE1F094836CB12C1EEF00100A14C8 +MD = FF6CE68B8C921E29B20A164CF448582094B3B2AEC2506604EDF59916E1D6C4FC + +Len = 1224 +Msg = 6C4B0A0719573E57248661E98FEBE326571F9A1CA813D3638531AE28B4860F23C3A3A8AC1C250034A660E2D71E16D3ACC4BF9CE215C6F15B1C0FC7E77D3D27157E66DA9CEEC9258F8F2BF9E02B4AC93793DD6E29E307EDE3695A0DF63CBDC0FC66FB770813EB149CA2A916911BEE4902C47C7802E69E405FE3C04CEB5522792A5503FA829F707272226621F7C488A7698C0D69AA561BE9F378 +MD = 2D7CAC697E7410C1F7735DD691624A7D04FA51815858E8BA98B19B0DED0638B5 + +Len = 1225 +Msg = 0944B0500C2FD3F0ACD0B0623EDA2E763BD95483CA40A44015BC0689F840AA97873AAEF58FF7CA01B0BEBFA789D301D3BF25AF39D32F198AC941BFC93C2051E1F2A38389AA26C7B04CB76D7B23361232587F923E630F27DFC7AE0E9FA8ADF10FD7D022200FCEE5847148003CC7144119DB20D0E2AA6564F261CF78F1B9F79CFB3DC8A9867BBC7FF49D719F493686006F2060B93D8B3DF679F900 +MD = 4713ED1A75A97AF37F2F1EFDE209022D3637B64AFA0B0052299CFA033EBACA2B + +Len = 1226 +Msg = 07CE3EBDE3C2F23BC7CAA9D38E5312961A470F9375EC3DF44809853D47862A2332D0BC4F29B267CE3FDCA659720BDFB84713BE1B2F7387D679E3A8AC8A12837E8003E9EADEDFD3E29AEF2150594604F507CA276A9DC5EB3EE8EB74B511787EE2862AC0976588106273795CC6F41596ABA09B9C59382DAB0398E95F75193BE0B14A7E45C88CA9B8186C9B0F0485A4DD9B4FFC361EB28D34EC1E80 +MD = 8B8D8EF1C6BD1A23F77404B0D7E905D7F34E4B5FEF2D1A265960A061807697E9 + +Len = 1227 +Msg = A12682794B203ADAAC278FF0FDDBA860CACEC00C1CE9A1D4577E3D7EEF99B291E306189DCDA797C45D643C1E9542AB0A16C9369286A1FDB6AC4D5C1C213973F95A468DF114BC7FAD9EF3118CBB8312E4685FB6B46ADF1AEA568AFC69BF805FA48B9D25064A98F3C2961ADEE697250FFA4FBBAC491D698CD46BEF3E7995E3416C405F75062D739631E901670BB3400BBCA014FD22700919780C20 +MD = 6810997D15F94DF66D305B03B38569BE30272549D655632061F1B92BC0A5EA7A + +Len = 1228 +Msg = 6FE5239D775677E62348DC46DC379F70CA024DE4A4744D1D6070F6A90F26F1E1720D0A9FB31668E41C8CF350B7EFFA2DA0CD1DDDFC8203011A80CD325259FD47E8E2CE329284D54639C73F1AADA1E034F291505D672B979C94A08022EC15FE2241C687B8E2694B4F108A39E1DD672F9503E3A3A99B95DC87B8BF74A95B332201A916CBDEB8182D3D60E6E482FF04A3EA05DF548595D487CBCCA0 +MD = 9204E388C001C84F9364DD74D43FA5620521E9770D42FB146A15D093E4286A1D + +Len = 1229 +Msg = B063F65D94AEA4383850A817286586F22CE3EB09C7EDD293EE8146BB8B2706E0F1BEA7784B708D6CA004B28ED7BC4E3E432A76A4A644BEA920C6EBBDABE3333C083EB682878D7C07643FFEF6E50357DAC346B2106DBA30E1288A1886D01A7F3D2BC970ADC5AD33C5C86212544F692D4C56C83F448836D79B9882E7F85DB38AA3E07AD0399F0152A08A08B6EB4E5CDF21851C8A7C73065B068140 +MD = 9D87AE546739E2792C614C71C7B9A13408731F7FDB07D6ED8229C0F7E0F1FF72 + +Len = 1230 +Msg = 48A2ACD9C115E1AEC54BEE539F842ADC43170FF60E003272E9E471135514A50F855094BEEF742A175835BF1102B747BDEFB149EC234D81F2BECDC17C079ABF874C3CBC4741E6115F34831BCAA7D4D954EAEF78C04C640EDE7931B1AC63BF8F665CD4724886487FE13F68097583461B58E88EBBE815F141BFD3C7BAC974D462976234D3706884C663A9ABD6FF86C046281446AA07317F36CF7DAC +MD = F56ECAC0FD3A57167F3342AA703B446E146FCC09617A90AE71B9438E8BD2235A + +Len = 1231 +Msg = C6810F0B8436125C00646A67D9AD7F1689821E3B0F02BCB47A3DCD2DCC292CCA93170951FFA4BA6CD0A533C5889BE768CC82FAB0AA7433AD928073894D1EB21DA667F49020E3EECD26234FC5EA28665BACCBA515C40071CCE0C139281D8A5AE4D91482C259C15FAA9794E699880E9D48FA06C71968B2CD34448495AEF6C55506EC96E71E6326823C0EA399060043B0D5BA74AE64B6F14797199A +MD = 184D1E43E81DD748C63A8968F84029E9F463993295C0EC3D6DC83583426EDA34 + +Len = 1232 +Msg = 51B7DBB7CE2FFEB427A91CCFE5218FD40F9E0B7E24756D4C47CD55606008BDC27D16400933906FD9F30EFFDD4880022D081155342AF3FB6CD53672AB7FB5B3A3BCBE47BE1FD3A2278CAE8A5FD61C1433F7D350675DD21803746CADCA574130F01200024C6340AB0CC2CF74F2234669F34E9009EF2EB94823D62B31407F4BA46F1A1EEC41641E84D77727B59E746B8A671BEF936F05BE820759FA +MD = F664F626BC6B7A8CF03BE429155EE1F5CD6ECF14816DE49A5E229903F89A4DC6 + +Len = 1233 +Msg = 5CEC4FED86E4B4355F1DB08D3BCF6C9E2BF3624935F49F69BFBF10FE95121BD62AE073AD191722DDE7F015C3C19F9D3AF6FFE2D767CF0A0EB9FDB244167182D7ED6831319D4984400EEA1DCA41CE0D27D85420A59C68C54EBDAA9AF331FD4B7C1B8C118C2BCB2D963643580240653522A1A1E42FD8D941C886FB3BD8877803FB959F2A851E9834192C4B93A64F2DF5E268EBC12CDF8E5C0EEE9200 +MD = D9ADDC52ED89932E677510CCCC9F91F7EC4C78475A9CCA6A727F388CAFBAFFD6 + +Len = 1234 +Msg = F1A47FCAE4AF23100EAC7E8CB58A24A00E61B1E668E86EB3391FB1D369E5EEEC2759F39AAF9F2A10EBAE83970E75007F8625B3FC95B9D38E927D5AFC55186F3921E93727E4C38E1535ACCED7F697926AB2221D3B0873667F9DF870F4A6F376EE5E75C0A5DA919FD4EE923A488B7F6A20BE349A06DD19B4C7327ED57A7168129732A3BADAB7A3DF08A186E677838FF49B7E7BE57270F8FDD12EF4C0 +MD = 7CDEE73373ECD20571A7384CE0AA2C16525B70C7D16A9123C9E858F79C0B29B6 + +Len = 1235 +Msg = 9C9BC5FF6E2A46A6DAE4D51E6FB46CBEBFB3E308F00F6BDA289E88FAC4CE4CB51ECB8C9685450226B8AB2B5E567BF49B3D04397AFA383A08185FA86F55DB6FB88ED8467A4BA95F69ACE83C955BAF5E616B1DFC73CE2EF6D5B696AEE81C9D742A8F9699704FAE2FD370740640A822FD2DFDE1C7E156D6D4B9E6AC6EA2F3546ABD60F0841BD49EAA8B8D26CEF0DF273171EC9F20D2E1FFFBE0E9EB00 +MD = A99D55133882D79C8C5F5E98A4CC634314BAEDB5F8EF91CF0138C1E05719028A + +Len = 1236 +Msg = 6BC7AFFE4C66FA084508F7343E698EAE4A74EFE0A4E8FEB2F83AD82C01ABB999D07F6F3082480743D309841E4AC44BEDB69CBC6A082505BCA690BFE52BB67FD9D6CF5C37D981BF8CE5E6B0B7429B4518094DA9604BCC39775D63CB49E2B50C35D12D78C5717142710AA48C7DC4190B2D4C18FE53ED42B9DA9FA71E9700A9BE0B6041733E17313C00FC309655EF4476421E4061F59EB15A70C4FC40 +MD = 389C93D635951862053E77C119E646682A86EA831B309DDC3C2A006E55240DB5 + +Len = 1237 +Msg = 29354E6F76ACA48E55F1B5D3169F02B066277DCFCD00230340F400056852F7AA53DDB2B6329325643F40A5E7AFC06F66D7AE2B2A08F8F142A929D0D21AB8636BFB32528EB928966798EAD25140A6B3FA2DF9024125A013189FC79B43F2C4448BCEC44C6029EA4CD4F758F23515E4FB327367069BCF55515283087F32BAE0A8C5B8F577AF52FEF9E084453CA629DAED5A36454B0BAAFEF0C15CF7A0 +MD = 039FA2458E7D60259192CD93F4191394D2B837FC5F3D137F37CDD0C298CEA38F + +Len = 1238 +Msg = 626F397D0260EAB42C6EF7098A132C01F266B7BF8B931B7DC9B386801DD1F56271B0B45E1C36B7A69C29F53B05827944DECE0D4BF50084FE753A1C471F4C895905FBC35829196B9539A4C395F5F819D37A248AA3C1BC4F42BA4C3B09A5BE323BCDDB0A14E7AFFC2E2E039D69266515727001D97E585155B6B1C5A94B9A1CFBD9B762B38DAFBD956125B9A0FAF437241EDA5349C2D3266DDD1E796C +MD = 0C48A2B73CAB709A7235E602217C99A48283AECE10AA804CB8D1089924D3EA26 + +Len = 1239 +Msg = C8356DFF2E7F57914AAB911BC03DD06FB3A90EC2D10CFD003A28FF8673230ED6B972FEBA869E4F7DBA1F07153582751FBD62D3B7D99236A09A5F0BA4252E35CDCBF87D6B36D40EFDF3EC5A5AFE70014717F2F730C1C4E516908387FECC704E2F17C8E88F58FB4B1D51A17CE63D45CDEC2AFC6F2CD645D63DE0C5D62AC280A75881B00E76E72C43D40840A91AF569398BDAB704ABD85F1DE2C10C76 +MD = 346DD042C2837A3CB10401D71DFDA32E37C968050C67A2E4F48D3C85350E9758 + +Len = 1240 +Msg = 83599D93F5561E821BD01A472386BC2FF4EFBD4AED60D5821E84AAE74D8071029810F5E286F8F17651CD27DA07B1EB4382F754CD1C95268783AD09220F5502840370D494BEB17124220F6AFCE91EC8A0F55231F9652433E5CE3489B727716CF4AEBA7DCDA20CD29AA9A859201253F948DD94395ABA9E3852BD1D60DDA7AE5DC045B283DA006E1CBAD83CC13292A315DB5553305C628DD091146597 +MD = 06425E83E4AF817D735E9962C0CDDCE2CD40A087A6B0AF3599719E415AB9A72A + +Len = 1241 +Msg = DC77D6CC04036F3EADEC0A3F2DB83F877CF24A2AA319A804C018840956F50B3830B8900428BE0505AE0089466A22845952CF8F4192333ECA1F4243434012DC5B833DC514ADA93CCE39AF280C961746E3DE14E5B1AC280911C31498796728DF1CAAD96C4B0C9D907773AF7C86A6A5804B40AB86697FC4BE83E0CB386D14BB872A9276203256285902DB42B05F71050ABC71ADE1E06D37F4950CEF3B00 +MD = 69C14DD722DA8C72A8B7866E0B721A1E6D681EA10A56FC349EB9858C6BFA454F + +Len = 1242 +Msg = D57982D9B0D4B3D9B18117EC323DC1F654ADD71AB06440C77C49E05F110F82AB974B5C22637F6A1BFA579B78DA05A17D5CCDBC2EF464970414779448545EF2410EDBAB5D93FB8E85C6C15C4D5C4182E13A07C8B1CB016A41298E6D6512DB94606F8C843A1F611824BCBBB0461B161B0AE0D6D5B9B80720E10103FB5F2DAA3BC7A16CA73C36234F72C8A5F7441D86DAC1AC3436743C8CF817570C7640 +MD = 51D052389077C2CEC34EF218D89884B2B7B14BB9A662C30282E0AF4ED7AB15E6 + +Len = 1243 +Msg = 162F77C5AEB35AEF23D128AD0AC9685C204176A0893FD8BB45274B35C2D7C9CA4ED1773632C9B2720B751E73ADF5FCB331B9DC4517805457D1C22E59AB1FA4A26FFC5F4A22BA0B1B1D12A047FA81CEFBFEB9EF20300ADF43DFAA4CDC468F17E89179CDB442AB24A61BB693E6EAE09073FD410E7D0DC3553CD8B3EE4212EE3C9F90627A35217EE3A8B0505D688B574CD65B7198101ECC065E3991A520 +MD = D8FFA8E76B47B213DABE7CA3958421240991D245117FAEC08C54426052ACB32F + +Len = 1244 +Msg = 099E4A3C983332023A43028E13F12E85DEEE45A88E8BBB4916729029F86BE3291475178DF24726684F3BCDD166E8214B9342FF80305707F72BDB86005116B9741A8D4F2AA953BAA0294A1759654D24C32C311D0D81F077B9086BBEE226A93E9B906553E32CED52BB92B427840421A5B711CEC2A2D07C1CFEDADE4DD8CE5509039816EB54B5210A45B088E4975E99544B22E2A59F43E767F33B5B05F0 +MD = 16FDFA3159E22F413BC9809BA9122680DBDCA6C77AFB616DB5C608E0AF7B9766 + +Len = 1245 +Msg = 7B9B005E94027DC151F29B0836D4F2E3716E11EC9E1B0875DA9581F3BFF5F412E22AE3D790281F547550BFA6EA2188A976CBCA567C5A5327DE7BDB4229D48C253B0650C3B518E5ABEFA5E1F7E079D38BF18F1A13500105F4D96C4A29002203D18047568FEA183ADBA3C1D06576AB73FE88CE704495204B7B31D40A0C6D09AA6CF65310DCA730A5488DDB0D5EBEB7583D75A75480C0B06C0EB1C48CB0 +MD = A4B2CD5A7151528182B26E3152B825817B7E4E4464416582C61C5D0AF2FA27EB + +Len = 1246 +Msg = 50FCF726597FCF26CDE79CD42D68C338E7E26299D0AE41EB2B87F417409F65C0FAEBDC4C95D52AD3777E774E8BF982C7DB1B3CC1B43BB1298463BFFD061A5DE2162DB8610C747D41E71BC4A49414205B56B1D86FBB81E74039DDA4FBD84316E2BBF7C9F2599D340A2E86CEE58BFEE5D34A684F1858822BEE5F73193DF8C46303D949FA8E962789699C15709C74D702FC96C5A3B82982370788A74BF4 +MD = 79E5D70659283305FBFC9FECAF61430927D4B75780A755BE7B8B6298A1CE5B31 + +Len = 1247 +Msg = 6BBBF4930A96E1A18417FE5A539A36AA9A3F70E055E359091E5ACBCBDACED975DF2BD07B770899C1888EA4623E70CBC0D9CB398EA1FD9BC950F047EDFD478324DB645F7A90F81EA98E38E93A1326558EFA8813FDE52DD073998046A3AA2AE3CC39EECA6012DA5AA8CFF1A4F3E59068EC163C75EB56EEE8838E0E2E03FCA370E54F3ACA668DC5F77677645B7915A52C788EBCC9B731F91CD9A0990834 +MD = B6DDD37E7A739773EF55A1A0C26CAAA9700DC23E79D0171ECF97348BFE37A50D + +Len = 1248 +Msg = 2BE9BF526C9D5A75D565DD11EF63B979D068659C7F026C08BEA4AF161D85A462D80E45040E91F4165C074C43AC661380311A8CBED59CC8E4C4518E80CD2C78AB1CABF66BFF83EAB3A80148550307310950D034A6286C93A1ECE8929E6385C5E3BB6EA8A7C0FB6D6332E320E71CC4EB462A2A62E2BFE08F0CCAD93E61BEDB5DD0B786A728AB666F07E0576D189C92BF9FB20DCA49AC2D3956D47385E2 +MD = E8C329149B075C459E11C8AC1E7E6ACFA51CA981C89EC0768ED79D19F4E484FB + +Len = 1249 +Msg = E5C9D107E19D9BDB989AF870BE40F1B6FA06DB3DD70E741D2F03198DE02E58E2A37203A7E766A8B918836039A2503062AA3D4778D1EA931BDC6E76554FC965584E0497AE75627686E10E50DF6302C2458E087AD4E8F0ADF22538ABBAA431703349BCF5C026C30BAD0F42D93C64D2918167E161A3C8A1848ACE16F56CF5DD5B8E0796ED50805346ED9AB04038E91676C92BCCE7FA74FE258B6D01350C00 +MD = 94FEDB57A10E0681C96D4FE776374534E8D25DB3C704E5A953CF64A05CEE14F2 + +Len = 1250 +Msg = D43686E59F554A3045CE43C0457D8EA84E70AF4F0C8133905C27C85648E6EDCCB1ADDB46AB7E5AF68B2EFD6C95BCBF9281DAECC1191A416CAB872001F347B66C5658F0567EC86D2CAC8EC531F32EBEB8D8CCAB863A30B574F575F227452BB4129C84C6050F693F0EAD880B552CEDB4673AF621AC9678AE17BFE2AA2C940CC54227662130E4ED37020409D308CCF72270F74DA075451339BFF8B27D60C0 +MD = 39E564712898F3A566E4E0DB8E901B62B7BEBB6BE39CC2D6ACB24462AE3DBE77 + +Len = 1251 +Msg = 309D9918CD4DE7ABA6E69619B8C0FAC749D4B96B71A58739AD3E3379DB4E6323ED7A3AB5FB6C8BDE28A8D362A4DF86CF9C418688B06394211A87288F2D3BF7BD60013C0E1AA153B5B94A6E2AF9C3964A561336DD115C74AB25B2A63E4B17B521709A207F41EBA5E412A65FC8CBF1C49D1C927CD92482BF6C2D22BDDE6D8C21DF69A9222BFB4B5BC57E891BE4DFAA41D8B725F7590F5D6A07CD0C0E5220 +MD = FFF2C196F03A48A5456A49461BD70E31A38D7158B57FEED627367922171D8785 + +Len = 1252 +Msg = 556FB9FCEAF608496C7681F31E303E911CF23E3D436EBF7997FE695A567B190409ADDCABFAC6C044E9B3BEBCA670CC42809B930DEC67BDBBF264D13F15250196AD387E0E51A754D3377284B77BAFD740529503BECAFB2399AADA3E7394EE46A997CE3AFB26CC0E8A8D9D616E61B786109A14D1E9414AEAFC8F806553B86194680F4D17F97FF55E35D5894EBE177402BFE5BBD6185C5E05FB4EFED46C90 +MD = 4B76DF51A8AFB4D739E03F86C04145830E5BE458791A5D9FCC5AC5467A8BDFA2 + +Len = 1253 +Msg = E1BB4075E498A327DF0160C8101EF6983BC938D67C47AC3F642A00655914C4A99D7CD0D0D70C81DBA014EC7C8A7350CCF30ECAA24F481E7064C8E9BC8CCF02AA5B93AFEC8DE3966662426C6AA20051CEAE8BC3D04B7801591FBBC6D41C1185C510BD153D51E9CF64F0458BD84E7344C4C5AAD4B2C05C8B9D9416EAEFBC91EA7686B5B5FCBBA9C913F4A06CE26D4F041686A6C800263BC4EE612607E6F8 +MD = 467185AA19E823396BCA00B1DE62A17033811E80C811FB1F1126D2394FADCA7D + +Len = 1254 +Msg = 26E8F3698FD7145A13658E12E46B76144A404387E1FC39AF205532F3A04DCBB5C4C111B6B538B45B66B36E2FC683D2288EF30E5ECC3B557D4849E08008AEC60DCC565AF19C9418C5DBDD68D1727E8D08ACCDB5382F64DC0532B866A6F7CE4E2396FB4E2FC4720B0596DF649F7F9CCD88E95F4B75890945730C60F4FB5D5D6ACB54B463B7A817F241C1B3D09CAD036093588B69A07DE5928FFDBF3768F4 +MD = 5AABAF455DB8C563D1F93A0C117EF9B5840948824042B69B20C8A6D3AE57CB15 + +Len = 1255 +Msg = 8161F4946F076CBAD3E13E8ED4E287CE35F00DAC4E7870E3FBD1F3EEF3C380255FF4A858400B8D035C6BFC6C25D17AD0A5A8D625E1F8F6116A9C5D40CCE992806FD508DFEC50C4841E4D403B788A93BE86F8E3687A939FCC16CB6B826D4025FF572545945EABE4B144D10A669C4B47F368F11093E748C559142E2BA4B007321DCBE166EFFB5C36306FEDD98D98ED5A6F273D56724C8B611B802314EE94 +MD = 68FD32662CAB7A49F0019F1AD7EE3DAAAE8A67013544CE17C08DDCD1A5AD8790 + +Len = 1256 +Msg = CA76D3A12595A817682617006848675547D3E8F50C2210F9AF906C0E7CE50B4460186FE70457A9E879E79FD4D1A688C70A347361C847BA0DD6AA52936EAF8E58A1BE2F5C1C704E20146D366AEB3853BED9DE9BEFE9569AC8AAEA37A9FB7139A1A1A7D5C748605A8DEFB297869EBEDD71D615A5DA23496D11E11ABBB126B206FA0A7797EE7DE117986012D0362DCEF775C2FE145ADA6BDA1CCB326BF644 +MD = C86768F6C349EB323BD82DB19676E10BD8AE9F7057763556BBB6D0B671E60F2A + +Len = 1257 +Msg = F0119C8BC95F23CCBAB4DEF542665D9BFE015AA4619ADE158F1D21FAC3C4F7E3D68E5EBD303F920B017DA561F6AA751235D55FFAF241CA8759E376B0AE60F04AC31A591E3DB1F58BF4850329BE199EE1D6A750792CC3B7839B66C06753ACE50786223E0DD16EAFF479B89BE123C1098D8E6D30607B1FB9792F6D86608FA26A1D9214BD619D614FF4EC326EDFC6BAF44A565061856A6A796C5CCFB021F980 +MD = 18B5D9F50B90CA1B43174C81796B506A3C1A4EB5758A1CABDEF082F4A22535B8 + +Len = 1258 +Msg = 21A57777A8B0B5501280BC7717E54E6B0F8601B8362BD3ACD7C25798FE78A76515B10651F736CDEB08D9AC70C05D3E12BBEC98799C7EA021699D852B4C1EAD48B301BC6C269157422EFFF2B7749CF0D19E2D47F757E6A56BEC71DF86482EAD78E342944114D3D7BE2D381B01066FAE0FB328AF0530CF29A1C2479922BC5E82B7D1108570262E55555391B85A347CB186390D9476247080758013E0ACD080 +MD = B6D197DB0368A20F10D44E6CE0CEA8FC5E3E045CE36F6045E54D131A73D46991 + +Len = 1259 +Msg = 0E7BE48BCB01238A181A4CE2D5F23BE4337E96DDB7CB9504250209886AA050BE6007E594E14E58B64ADE5B9FB8F90C7CCC9B5939B1CAF74174BBE6A554BD40148AE7CA525C4DDA1CF0CFC11812DFF12BE121E388794AE8AFD75615475E9D2C2267F0E332F298D17DB1D597A97DBEDFDC34594E00DC107839A3AF455C1CCA44597A53A314ACCBDEFCA82D123EE53D0B6663BF3395311593B0265F87131020 +MD = CBC3ED192DF1F85248DC1B1C07A7E279E16B5D856BEDDDBB02FEDBAA36AE8337 + +Len = 1260 +Msg = 6C38EFE88285521063F33FE108162D56EB5109EC0DA8AED88EF76AD7B88BF1361D135ECFE67CA1069FDFE1E0DD7A175C0DBDCBC3B3E55388AF3A866AB8ACC756927CAA142E2A4AD6805A616D1100B51E9B1B3AD04708BBFCFE27E4F8BBFAA823A57D127B6FF5359DA704F61F96BB882E6FE33C648D5855C725B092C4E4E0DAABCF6BABB56BE3450C73C3F07A2971E16E1954B6E1D17E92DC5795743FCEA0 +MD = B7C0589555B2E9654B7C07BCB4683115E46FDAD06717CBECBDCA9CDE0C040B8C + +Len = 1261 +Msg = B8BC88E9B1A8DEBA56DD1E9B418D379AA11252E609ED52AB42A67458D87E3F2D60AF36595D8E33E317701CAE5CD58557C20617124068EC55A7096FE49480E625A51E987D73729FC4C531B7346ED8391AA3F0D6F8827ECECBD74C7BECF9373E692FFF01947CC11C92CB619244E0EF3562A96A17030414F44FCC35B2756A667C003C88CCD1AB31992FC659552DA1BCE4F1807B3745C349D3C96B38CA1C93C8 +MD = 9F79B4E6358AA815DB9669FE6BAFAC98BFACC3AF942AD201B5DFEF266AB5E3FA + +Len = 1262 +Msg = 3FD3693A5376B0943D4D99601D92B3C55CA7B3889E02431B7CBEBDB6D7D886BFE7B057819E14764FE39B828D233FE9FF6B7CA010965F8F8777A80393A0B86E61379C26DA68A304D6A47A5DE2C029561CDB4CDA5CB471A84BB7358D8EBCD50521C6693B138348388258A032DB48D067FC0BAAD8266D6A880ED1B8EC9C559C26E97C6C2037D5D51F753604039461E26D4683382BB2EFA5A13E734E2CE90B90 +MD = 36F9D1F4DCC11D0F0C47CBF38F866DBE01908F0F7D1B99428F0FDAB36BA86D8A + +Len = 1263 +Msg = ADAA5A1187FD564FE9FBEAF43E48D41438B609CF80694F3E0872AFC1F172FD18E4D1FFD96B674B4A765A6D1A63827E0ABB708EC776B9458F5EE904501B096F625B7A47E7D6CDE2E19009C5C81DA80194BE8EC613F0E038F8E0D39A92851774729A25F00068660BD25CEF0E7F734056D5972AB36757FE45F55F2768DFA29038127269B46AC68079A26E0CB8C52815E22BB61E32E48A78FDA6A006557D580C +MD = A94E8A80E5F8D206C0132CFA54D0A82AB04F8180C1DE6F26E43C8005FA0E060D + +Len = 1264 +Msg = F76B85DC67421025D64E93096D1D712B7BAF7FB001716F02D33B2160C2C882C310EF13A576B1C2D30EF8F78EF8D2F465007109AAD93F74CB9E7D7BEF7C9590E8AF3B267C89C15DB238138C45833C98CC4A471A7802723EF4C744A853CF80A0C2568DD4ED58A2C9644806F42104CEE53628E5BDF7B63B0B338E931E31B87C24B146C6D040605567CEEF5960DF9E022CB469D4C787F4CBA3C544A1AC91F95F +MD = D97F46F3B7EDBFB16E52BFEC7DBA0815B94D46E4251E48A853EABDF876127714 + +Len = 1265 +Msg = 91440F1C8F7CD08B2FA70D334BA56F12FA0AACA189346291DA0B69F58BF65869DB2CC98FF82D56B4F9EB9106D4CF20AAB00DAC3669DA29944DA8D9D23B797D8D2ACB22E5D0127473E8DDE2EAFF6BE3DAA7FF7FC7D9F8DEEFE2634D8F3071D196AEB24DC1D9CDDF4D865D794BF120CE78B20F06124B656BB7CC5172E87400C50E6C3249E8372240ABF5A8814B66C9C3FFEEF2B71BE2FD0183BBE6DABC95AB00 +MD = 57E9DE53B6E7DA995C630484DE71E699DFE859BEEAE2B6E40FE4E61ABAB0F348 + +Len = 1266 +Msg = 8F66375F8723070CABEEDCAC50B0A986B133E4685F68FA60E36A61EA0042747029DB1E7672EFD41833674EA9D29E30BCAEBF74E23D7C715B9963F78489692C3EFBA4116CF30193E74926B1FF7A2C6465928EAB794496D46101F45D26BF1186FC66CE159AC50A3E2E379A7981DC6419F29F7E63FAC2751E696C97403BE37C6B01B34557DFEE5B68FFAF22071F0466576016334CFEB6CA53FC40BB1C5DAC9CC0 +MD = 5C41BBBA8E209F9E39D08DE0BAE7BD96D539E531075033402700D682FF554A2B + +Len = 1267 +Msg = 0D030E023E6C3B59E25BAF6023F1CF3657C566FA66C0F8BCFCD04F3163AFF6C2DBA0661132FA477F3D32C514F53F8E89B316DE84AA55A4AB38C33084354944EA9AFFCB8727AED5675AFC52EE6201961C15B28B0CD38948AEEE51F6E17C172946BC1B51ADD5316C30703CDFDD7FF87A7612CD576E7FD4956C0283AD12E13A4FB548509526A13B6A867353AE959D4E70B31959097BA28E25FD04358EBC568640 +MD = 72330B3013E4732F75520076320D9B08F6FAB2CF7543360236FCFC40CBB45256 + +Len = 1268 +Msg = 99883206EEFD96B8ABCCEFD8872185AF185079F568314B0AAF55D2A5291A5B1AB29B9D25839A369F0260D55E29E2B60AE448393BFCBF18F8D091A8C1A0739F25EB2748C7A45BE8F88C9414745CF3C236A40BB1AEE8A85B53BD088684BF4E7DD1A9370C1BDEA575886295675A01D03FC06A7E01100F03436E5A3FC224DFDC6D9E8A00345AE14FCFBAEAF428A11AE4B4BE9B839B50CA80843435ADBB964A4F70 +MD = 1018589F343282FD3ECAAB843A2A3D7C9118D4AA1C15760B82C83CDA6051850A + +Len = 1269 +Msg = A6B3EEC583A09261D745849CD236679E2F9795123478BF76245F5E61F00EF6FB32497499B967CD550126BE3D88B4BBDB55EDF14AB745654B70EEEFA79A26FF00B6BD86DF619D53F72DE374965F277BFD87CFFC9124CDBE422A2AEE0A784D705566B78239A66D321F4FCA6DC11DC553D26C7F57EE05A86166D4E073BFE54DC6525E83F739C70DD4CF4CD07000CB595DDFA749D9D1D5D3CFC0A4CA2F5ECC7528 +MD = F2A16610C2A7E43E7CD7F8EC13DC8D92CD2565573E71A34FF6E614CC8888293D + +Len = 1270 +Msg = 817F2D641D62B9A54D78DA451D7743A234B424D1AA73D173306C0F66D78970A8BC13C87A9BB24071B0BD9F5B5512A7146C4EEE5BACE25AE3B9F25038592EEDC07B8CCF0FA262EC2B091C0CB15557E5A2C6F9AFB264662417E570C0CF37A770B963021A60E7D5CA2C5BBD8EA1E01C95408CFA335616F253A489F89DB1B49CCF1AC66AD4D7D4CCFEC6719F8C0B1CFDB40CAF5DB8BE02E32B516EE89682BB6ABC +MD = 97C8A266ACE8415007116C3047BD7EAF5B8C06ED03C05492A67CB7E90976F69D + +Len = 1271 +Msg = 825BBFF42A57069513C6DE0DBD31CFB7C114E42F8011892F9C53E41DED542F88051A3219007B85C08DF9F83E13B4B836B83A0E39AB9DED55B4026B85A0789E166B27B94D64938F9997BABAF6DB2C0DB2C680FE7D094708F8A6309F4AF8CA4F835A09289A6BA63697D87C730BCC3794FA3CD5DE836E64E5C4DBFB024B9C230C6E3645559F38FB97026DFA542E04A5DD50876FD844E95AF2E3CD2C9C3F8551A4 +MD = EF6DACA1430B8693CB3CC255381CF87009ED8D612EFB406BB473C6DC24B7736F + +Len = 1272 +Msg = 25B8C9C032EA6BCD733FFC8718FBB2A503A4EA8F71DEA1176189F694304F0FF68E862A8197B839957549EF243A5279FC2646BD4C009B6D1EDEBF24738197ABB4C992F6B1DC9BA891F570879ACCD5A6B18691A93C7D0A8D38F95B639C1DAEB48C4C2F15CCF5B9D508F8333C32DE78781B41850F261B855C4BEBCC125A380C54D501C5D3BD07E6B52102116088E53D76583B0161E2A58D0778F091206AABD5A1 +MD = 51D08E00AAA252812D873357107616055B1B8C5FB2AC7917D0F901DFB01FAC47 + +Len = 1273 +Msg = 53171F51D758037D43E75BC46D0160792E060C1F61A78922CC13BE9CA84FC9227404FFE6A3B054AFE5AF13D62DE8E6E5CF6A428B794CD6EEA56DE923DF662D54C8ECB3ABCC0E09A31A66B7ED02DC03D9B55AE44872D51A2A4F95756B9B611B87DB1757389F718BF0C413419C46BB9FBA8E7266FE2C438F8A4D8377F220B71C4C0CF3E7DBA8471CCD615BE0F49E97448BD2748FFCB47C46A508809E72F8CECF00 +MD = 7F3D544B3730D8CB835D0FCA2749555886FBDF2EC77FDA6EC1E50C81AC3A01B3 + +Len = 1274 +Msg = 8B766DA40380903F6A333AA1DD549144FCA246E2136252A5831859711F08BD02B449A1F85ADE21941C81CF5C70AE27DF71F797C3F3991BF7CBF64D5FE5E228E03A9BA275B6BA6B55C847D3E3EA01C011C2D623A712615D5804DAA36527174814C711623346A7B2E50A50C1D906AD2CD1345CC23E2A08161F027DEF1AF127A71A43D19C19034D99F3BFDB4579486E61134D84BAA14000A32E74B1CEA54969F480 +MD = ECDDCB7FFC7E2F01DFE5F8E5E3B57044DCBB1A9E3DF75D4739927ECB9D4B066A + +Len = 1275 +Msg = DEA895DDD527F9F680EB69D0881BC6308044D98E2A407C6ADC64DA9D8DE14494844063DF64F94EA19D94C7E5BBC528E3078E1900A92D2F8E44D15AB097C9974B10665D3235C4BB08D9E6C6DC5DCB281EE116A29B345DB2DAC736160E772D609E2F091B166F8A09078BE95656A4B6F17DA17DEA7A7D51CF41F318690E566F0501106FF3CE7EE0A0D2327202B23CE11D91F6BB5C873A41D3BE4AB4F6DD30D6D660 +MD = F31545DC17EB59AAF37822B6662734186D83586C9AA52C97AB7D2BF77A8E0886 + +Len = 1276 +Msg = C927E69503AE94F153360DC508B0E77682465E5B8365953A2C9626E2DCE4D875FAF1E3F3ADD70E34AA7EA6EA175D79A9E700D652BE8B7759707306D10FC33D1528D70D389E6ED9B8E0F8D478ACFE5BE223D4B791FED6AE65F363EDF4186FB088F69CDF394D74BF53AC465A3541432C41C7666B653858A7E6D06B0985C0F7B1176D1129DD1146357F847289A439E543E480F932B8602B3AFC754F540361A61370 +MD = 14A822E41ACFA962CC06FFA6AFFDBC3E9DFEDDFEB592BCE1F2C023D38F0D3625 + +Len = 1277 +Msg = 32419664499B391A213850C12E86F4FBA5B2BF3DADB0DC65D4EE9C9AD2710FC1419B4D4E9B85205E51BFD3CC0F6EA075C14DFCD1BD6800ED644FFB9EF737F1FAF9FB77E5621A5E15AF7F93D04E6D2DDABD71A032BE5BAFD0D0976D0DDB54DCBE79F192580BABEBF54F2EB6F421CE60BF939FCB8F237289A107B329C5F0426DE9C32303DAF98F3AF5F87C5A44EDD1083C6A2B8C045E8FD65B318304823C313400 +MD = 63F4E5D3E1189ADCCC0C819CCF529A9F0DC9B05B7F73335F1749BCB4991174CA + +Len = 1278 +Msg = 470E65B3F6A5460C9704053896F3DC638C1D735F393855B28A4F5A76FC5A419563845B553EEB30E9057D777FD2751BD6D7863E7D881DA2C2698961396ABE2518A64CB8BAA1CAF73B8B5AFD9D42CF071973A9904511C81164D509F3CB7A4EDD89C7F79A6761E9CF2A600FED47EB4A225310544E0CA41B1D8C9649905324EE0BEE1A5AFB3F1B7D9A2CFCDC8B52CE611B10B088EFC0991DA73A7845964BC83EB794 +MD = BC4A2C7370C15FB047404839EF4392DD1E24FFD60FEEDE3C5B3D1797D88E7B74 + +Len = 1279 +Msg = A4E9FA020BA2E03DB8678FB9F502FCE8E58EEC36CBAD94756E5566DEA5681EB48381C5DF545029B435F7208C69ECC279E993F56F808D59961C9822471A04F501EFABE78236B7D1D759F6D227F65CBBABA66C5B81FB88B6DF218BBA89024E4558719F005BCACC96FDCC4DBC2D4FA417DF849D96E3D0F4778FE2E20864DC058563527ACBC197BF04B692CE00CA4339A8B21745D3B54B88C22727287C63C68EAEFE +MD = 770C3E4F43B3B46A5457F408CD3589027D490847A5104632106F6FA98F549D5C + +Len = 1280 +Msg = 21CFDC2A7CCB7F331B3D2EEFFF37E48AD9FA9C788C3F3C200E0173D99963E1CBCA93623B264E920394AE48BB4C3A5BB96FFBC8F0E53F30E22956ADABC2765F57FB761E147ECBF8567533DB6E50C8A1F894310A94EDF806DD8CA6A0E141C0FA7C9FAE6C6AE65F18C93A8529E6E5B553BF55F25BE2E80A9882BD37F145FECBEB3D447A3C4E46C21524CC55CDD62F521AB92A8BA72B897996C49BB273198B7B1C9E +MD = C6A188A6BDACA4DD7B1BC3E41019AFE93473063F932C166E3242B7F52A3C6F8E + +Len = 1281 +Msg = EFDFD54747AFC74789E3585D271BBFBFD2B45AB16DE6F960B8176F3E18358F106B148F585144020D6E055A35572EB7AEA1D4E8662340FD641758DF09DC5D7BD6058A2679076CF8AFD9440F4EEF8AB76AB23E2A9801EBD66190B742B0EDA0DB513E8B34133CAAD28D9A74E1B3F0A44622B5FECC6D88ADCB47BB590C8F2078270576FA8DEFAA7473AB7BE4DDFF9142DDA4701E2FBF30B0072BBD0E42DC761A5A1900 +MD = 8CB50A5C0304AD051BFCF4134FC867371EC793FA4C34203D5D522E4EA68BE5DD + +Len = 1282 +Msg = 835C2A951B9770857A5BC36CA40428294E8A7F3EE5953CF7D612349B7BF4C2CA54FDC48D22206E0564C9E42C5FEFB1D799BFCA4A90ADB6CDE24C4B5BF58230F85086EA86C5C7A3A58D2DF7BD7A50EE51812AB957F075D60316381C99D24121F24E3089190F5A64995A898D25DCAF6ED422AD5A11046C156FD2A9B3A901FFE9E86B3A434B9EF8E132D1CFAAA7DC0EB6BF36974FB02655D9FF7D2E6806FAD8F56240 +MD = 75389648CCA850262930B6563CA0B85F2982869CBD83B7602367AC2389A8D105 + +Len = 1283 +Msg = 487BF06ACA4F8CCB9FBE64BED71AA95E8254DCCBCA59A391977CA1CB657D7772C8997A9513D46C6560A3B3208DFDEEF161F1791BBE78762669D6035654872DE662FB0E35507C3C47F1CD7C4FC48F429B610223932065724BC8127C938CFC687175E8753203C8DFAC4A45ACA459E6CFC1C42F9E686418F9803438875EE94A99AE0C73E65A4CDB070417A437734BC89A46B44A27F305CBB693299D5A80C8BD426900 +MD = 8058250E36FEF7FFB46B8606753CC33B00222D34F230F5A51C8693E9B07E1B5D + +Len = 1284 +Msg = FDD4EA48CA09D3A4876ADAC2A22D6E016C6CA18A35ADE17DD52466242249EB8937B13129E6CC5CB7AF48307A892EF40B190BEC41523CF0E6EDC72215B7B33E6FBDAF475E0E2FA0E863E83727FD0256A0F943646286BECA53D8A1A0117E13D2D46376340873A608ACA2B3532A516B9CDFD23A78AF03BD47EBDBEE97AC9A536AFF8B494E1FC662E5E1A4DD64C284C16B510DCA8AEA7D74E5CBAC8BB61DB5A0DAEA10 +MD = A434DFFE8E2A2C18799DC7CE32A277F34498D442C8A25C992E28CDC83DE2A324 + +Len = 1285 +Msg = 97819B95462CDC009A37EF3C6A91169E111753FECD21364FFBF95987EA73825771740DF970A5E0C68015E819CB4670C752EADE35A1876638BAE3B7FA7A5441638F52B092CBB026A2C16B60FAEC950D41A35F2CA4EF4D6154FDC4EA58CC617E783EBEBCD55E72E05DED2D34D68EC80CD3A1AEBBD053331A8C9DA25028C0DCCC2B1FAC93B4740BA94B3B8F066EA9C666DF5F083BF864CE9E0E54CABF10A11D1EF050 +MD = A68B1B174409F96A775FA94AD5E3BF9A649CCFDD26930E94567921950F854797 + +Len = 1286 +Msg = 597550EC49C64E81F38314DE7A825B56D0ED8B801394B4F6701100C3AB8BE122D124F7DACA5187DA9A1BB8AB905031CEDA2AC1F0B4644CE9CA283F65236D43E8709951B18C17D27CA45BA90B8EE84CEFE8E73EB209446D75DB554882A6DC0AC284B7A5093975F5B10409749BED474E92E19C7B479AB17B254BD9B9D3A35F0CC912CCE433BE6092A89CBC14C1F8D5EB76F370683039000D757FF5E06BA4A8820D20 +MD = 5A9EC537E73B7A07C81E14E44446212A47D5C4EEEABF4DB03A60A1B33EE56475 + +Len = 1287 +Msg = E79F049F5F8FCABD20CF328EB4FFA20D4AD500FDEC6DCB9692CD294E1DC54513E789D4D76D6DD2B17542E131826A6AB20ECF7BFCE476334F6540307C99FC76CB85AD49442B36B25F0FC81279BB2AB0B27846BCB7E9038092EBC3F6E0011746ED397D8CE77B9CA67AAC8F01DCEA90352FCD8893C276BF9DBB76C78B5E217063CD8930314A5B96D0641D82182E2EA67E7FDE3DEC6C13B75DC65659B15E56E75B768E +MD = 9B3BCCBFCD1FB4C5EE4F4634E6519BFAED8C97A1A99B91B99AC60672A04C09F5 + +Len = 1288 +Msg = 4E452BA42127DCC956EF4F8F35DD68CB225FB73B5BC7E1EC5A898BBA2931563E74FAFF3B67314F241EC49F4A7061E3BD0213AE826BAB380F1F14FAAB8B0EFDDD5FD1BB49373853A08F30553D5A55CCBBB8153DE4704F29CA2BDEEF0419468E05DD51557CCC80C0A96190BBCC4D77ECFF21C66BDF486459D427F986410F883A80A5BCC32C20F0478BB9A97A126FC5F95451E40F292A4614930D054C851ACD019CCF +MD = 2B31FBC565110110011AB2C8F6CC3DA8FB55D41B1AE5E04310283F207D39682D + +Len = 1289 +Msg = 8AD7F2067E4BDC72F3C66DEAF459D1D15323EF79004735603069E1546806AA3783BD572E76EC472D215794537815ECE3213DE792C359B9EBD678CD22772C73708D3E9F83C3F6EC5681F96100365383AC1FD38BAB1A777F48F267EB877604DD8C3E9A27A4E42392858268E8215175ED1C9FA7F5FCD2887BE6658D804FEB5DAAC79C6DF26B90737C2CF48F3FBD0D6D87BF51C0925658BFBB91284C9158AA327BD66880 +MD = 8779EA62C78E99778D2A7EAB66F9B1352791311506D9643270FB683F9FE349D1 + +Len = 1290 +Msg = 3C48158E1B2C890D8BAE91F9610D7E7CC3ADCF77FD18FED0F1C121D11234674C700B5545DE6CE4713B7C3FB79E20F11E3A709EFD942D9271B6FE0E5CB600D5ABDF178D27E37E9474EBDBCCBB3DE7C0F499E4E8CDC8FBB9D845A1E6DD89A0C28CEEE5CC74D5F90A041D4BAD61018DC1866543FFF1C09694F5717D2A2B876D397F7542D2A35776FFFFBC2B39A53AB06DF9E7B7E8C9F339495C8F31C5227B4DA8549540 +MD = 222732FD7242393C0123963E3DFA7F9E9ADF9FEFF687817E5F7B9D3199C82B34 + +Len = 1291 +Msg = 4812A05C8906BD360455A99F2F968B8674591A55F7213CA7C5ED298E3B199D278BFBE27D29C2372B94648DFAC050CA869F875CD7779958FF3815402050ECF110AD4FB2FCA4622E13CDEF51F80526D8E3E7149E7A8E8874E0ED8B612585DE2C14546A2AF86B8CD892EC9D0C222B66E4037D417880FE07F25C8AC5E4BC02F3CF2DA743ED72EF243791E7927E3EF0DCA6258DE98A700AE53450D57EB86554494FEEBF80 +MD = C810050318288BCCBA62038C17153BE2E76B0BD04F9C7D243D8131680A754764 + +Len = 1292 +Msg = 433DD44D7C672F2E15670086DB548C15B30B92219C8925685FFC5D97EB4EEAD9A76A613C382A399192CA8E6EBF31743E279C71BDB749190EC136268BC008856C03398AE0DA550E859F47169E88F950A597F0560336D7E5C58BFA20C0E0B57DE4B902C6ED1E99868E2A48FEA544DF47539B215E9E1DF268F0FCD4DE3215D1A8AC4C215D896B041FA24C0F8639AE2A6D67D1AD31BA0D1A1DBE783FECD3B49A1EB3C460 +MD = 778E1C21C34E4310C2CECDD92CDCAA9FE798EE528BAEC2CA2C4DBAD67A93CC4E + +Len = 1293 +Msg = 3C2796DAE592507DC2AE56411DD6295B8517F0F009CEF9ED8C7D52024A4D6744916935ACACCE820A698E837B51C96D79501EE3662FE918F441CCAF82F00F6D0DAC0EC0F900E50A36BB93DEE19C319757D39B46866590F80D451681390199E030472968BC6616E657781EAE0F4B97EEC0995BC37BB7CC448A7FE441D05B70E86E5DA8C7854ABB45318C6DD83DD99A94CDA9F3B82B62F1962730E1CCE1F7386CF1B970 +MD = 5CDA8D0FE4FD02F79A18EDAC0270CCD426CD4F66FCA5A65C6C814030D0452463 + +Len = 1294 +Msg = CAE6C210EEA071097DD53581E47239AF612213DB39225EC8C03D62D3F1BAE63D69B0826F9FDB540714A11D84E43786D4E1F984677E30280E4EA2878E424D86ECF3EAA986F08CC24145B333476877B0072660A3412CE92AF94A4150A98AD00D3008A8B78A00222530DD797E020EB259D25586B905FDBF7CFF103B972ACE04BE42B43CA538CB426515A7A6F86E27DB0D8D5D0E2F61B103D842D09928F4C56F59CBA0E8 +MD = D7DEF3EB236871D10A5B735965C3CC91E926998676284FE60266846AFF186F47 + +Len = 1295 +Msg = 2022A89E86B267A920CF6E6BA856A8542B9DF1CF736F0A0B3ACCC09BFBED6F04870017261A29DA12E61FFBDD68F7D55D034CEC90A1A31AAA69149D185356BEFD2D592E8126462142AC330D83075AC661B46A73BF5FDF0595B3E311BE13140C4BD041E1713689A7FAF7F210B06710917BC79A0A739E04B09BD76BDFA9412E39050137D39025DEA5A1264DE08780A53C4130AA89BC024CF1DE63239EEAA8104527EE4C +MD = B9E87F09DD5E005B9D6C797C7400428B786772A9297EEF107846C92F615E4749 + +Len = 1296 +Msg = FA85671DF7DADF99A6FFEE97A3AB9991671F5629195049880497487867A6C446B60087FAC9A0F2FCC8E3B24E97E42345B93B5F7D3691829D3F8CCD4BB36411B85FC2328EB0C51CB3151F70860AD3246CE0623A8DC8B3C49F958F8690F8E3860E71EB2B1479A5CEA0B3F8BEFD87ACAF5362435EAECCB52F38617BC6C5C2C6E269EAD1FBD69E941D4AD2012DA2C5B21BCFBF98E4A77AB2AF1F3FDA3233F046D38F1DC8 +MD = 1351F5DBA46098B9A773381D85D52FAD491B3A82AF9107F173DB81FB35ED91D2 + +Len = 1297 +Msg = B11CF575F6678B0A418851761D3D2940DEC21E57314C0C8DCAF7CC51F3543C7EA3238F5BFB65C254F3D8F01C560CB9F5DFF6FD2D87FED5F2FB2C8A3DFFB2B7369709342F80BCCA077202151499F08FAAECEA4F6F07E85763FEEF5E062E4E6BA827AFFD278FBBA7F4FE90C748B582694E5A80D1561D5518343D0B1F88FDF6C61CD829D147D692AB9030F0712513259A5F73F37995B4CD923E815E95A9D2FE35E8293D00 +MD = A4627AE4AFE8E33AC70B96011EFD81E69D2C325736327EB6CED4D9CA600E9C04 + +Len = 1298 +Msg = 6AD2B1B7D7D8F12D7ED616E464F7DEC1E64CDEBD637FF3DF232AF9ED5C810065F4CD00B1B75657F1089E185F3DB5F8F3467F685100697ED7667A7FB87871BCF8B936E05F99073CFF15A36CAF3BEBD22A9AF18113970B5B0777F643A56DDB5ECA4AD3E14E994C6D4D0CE43B8489C46097514339F12C4327EB8232E1BD929BDF1B798E71651D841EADC34817F2F6917DC5AC9D54BFB4A45E252BCD4039D71702F9AEE140 +MD = 14EF4061E4941A1A5C3883E6299031698C465D1E131AA66D7879B82279A95F2D + +Len = 1299 +Msg = 5662FA185A69C135AE9BF1BC3031A8EF17E3FD3595D78C768DC7318C43F2BF158DB5615BD5D87EE05475233C836CDB687AA09D63951EE5F2AF339B145DEE7C1F07A36784B469836C7B19C61BE08D64D996155E7B6B40D3DCB28E68A6C8BC0F5C8EA240A6AEAF719A061DEABDF819CCBEC87B31159716B193522F68AF57F7CC376A57FC926AB35E942F54D1F3843349071DD24E1D59C860ABA71CFE11C1462C8A954DA0 +MD = 340608E934DDFE9117DC4A6BD9F1C46A775B87069A015EFAC21C7209EA8712C6 + +Len = 1300 +Msg = 7779B3E263816A8F9F86D7CEB0DE612784D0CFDF4C9A54E8D6F7959AF5297F46F0E7528B64D24A7647232F4A28998F57FCC61E9DD78A678EE8F0BC5E331E2640A98DCA85D4E2E498AF62508A7A2511EC20AAECFFA8D6F26659789FE36CD6D33568C0AD6086060985E3A8E992EABD83216AC1F5D267BCB805AEF0E359CB65E69730473FE00D5DC7758EEE979077DD67A2BE990B4E242C2790574B17FCC6440086A22A60 +MD = 0D1A12F25A13179BA7502F56E5E2DC0873843C6CAF2F554A00690F6BA26CE325 + +Len = 1301 +Msg = 7FC8C0CC3D01FBE25FFF8C68B48A22805582D1697A4258874DD185CE20E3B1206AA69A83FED342ABF1ACC0BB480029D9C899A929E9A3E12072318CF2905FF97206A3F28409E309C2AF4529F212C9AA5030FE357E2D6C697FEC3763959DCCD61E295BE47CD76C4F1A9075E178C8D5ED01A3232422BD5AAF7DCEA80696367E5908EDEC837A7B25D600A9A8F9FE9507513CB8B1F283FF5FCF41A0AF18C7A121726C4EEEB8 +MD = 6067E9666EC620C4EB862597DC0C9508964F5DC517F3BE18A34AB435FDD82494 + +Len = 1302 +Msg = 5F9C4BF48853C04ACD6E4DF5D3058623089C466CE9D8DB0F56E8DF97E6EED8A77D848BF7B3D5B7E561BD745424829328420387B2951BCED984D59764443C3A8DE197BD5CF090958277B6B609C2AF771FAD8053DC2CADA33FA3E177592F3E975B3114D5C87AB3734D7E9CF5A4668AF60CB84202949115DEE795BC195E54AA3B0073172EDAFF954D46858BE26A174D92AD5938870FF1D5612049508F5FEBCA5998714F7C +MD = FF3C87A0EDE1A1D8AE8E2C894E073FA4184AA4255777B18784C7B4AFA366264D + +Len = 1303 +Msg = DFF4935452139DBF9E54D1BBDF61EDF88B12270DDA0E8AD766053B91B9343ECFBD793093D5FBA674DB77C92C42740E76C95CB72DE88F817C174E43A28EE12567E79462F3960FDF27B0B2D03A008C7C19943C7435338BC701E14ABBF8A783E505637425AD6139922DECA4524263ABED9D384EFD62A1A82C4788263A19A931A98AD9698DF7706128663629D67497C60489356FCBA61662D55A5831B7F1A64B49D479CA26 +MD = D01E62CF125201E7D22F21109700DF010818832B5EECCB77DEA342E695652CAD + +Len = 1304 +Msg = E90847AE6797FBC0B6B36D6E588C0A743D725788CA50B6D792352EA8294F5BA654A15366B8E1B288D84F5178240827975A763BC45C7B0430E8A559DF4488505E009C63DA994F1403F407958203CEBB6E37D89C94A5EACF6039A327F6C4DBBC7A2A307D976AA39E41AF6537243FC218DFA6AB4DD817B6A397DF5CA69107A9198799ED248641B63B42CB4C29BFDD7975AC96EDFC274AC562D0474C60347A078CE4C25E88 +MD = DFFC700F3E4D84D9131CBB1F98FB843DBAFCB2EF94A52E89D204D431451A3331 + +Len = 1305 +Msg = 9471390C1E87C0B03050DEE02D4F9B4ECBBE43981BF41F7EED9B38E309999536E4C550CF4BB9CC80A585F546CC25726B7041BFDB5FCD1DF123236064A297C11862CA1B378BA81B52F179FAD165F1E3D9EB32C53D2BAA5C4EE1380B8E757E288EA55BA911A1F1EA72A2E7D1A3B92E284966D316F22D4D0065AAD3B1743D47533CE8B362E26286C70C61997B3E4560CE6FD84384DABE495216ABA7DE1013147FA81688C900 +MD = 8347CE79088DCFA00BE7A0A9F140D38E50A0DCF310FD51761C85F36BD4B0C1A3 + +Len = 1306 +Msg = 71ABD048E4D533B8C8DAA416C8ACBD4D70EA10EC8F0DFFDCD1244CACA21E8C1258ECCF53763DB6FDD1AD92A6968767E5A03BBADEC5CCE37762A2C6F7697F537BBD2651FE372A9900D957ED2F60BF62A8407F1AA5F18600C0575A3FC10CAB9B23ACB86ECF40E83D8E111FAE6B76F940FE8173071D8842981886E3FC86C4AD30654AA086C110562B50A2F7292409F91131A63E3617591A4AB8AD11512C0449A00E35FC2300 +MD = FEA386D2232F237D42CA19019828608864570687C2229D13254329C7A434B4B8 + +Len = 1307 +Msg = 96B1EB63101ACB4E8D4B1F567AE85F344115D62A2BA9A3A75FF2B203446862B10296625C87ACF3D14BB1928B3FFF49E137B9458713C11950E0167586BCFF8FEAEC9E54B6DDAD31DEAA4B987A5BB5642CC224670B8F685D44A4E251A824295F6382A8C303FC85DCD5A55B6974F2DBAFB05A4A46C79A51407CDA912E5A09D4040ACD7DBDA7B0F1B57D733B26EDBC77B977420C3477D5E06B4A112FFE8E3C275C0D0C516D80 +MD = F94E744C925B69537B7A9A8F427C621390FC2001B93DB8F83601E5831ADC0F01 + +Len = 1308 +Msg = 88DD2CB6A0A2FDA530FEBA6B06B37412BEBBB69BA3FA198052379BC6140395604ADF13345B3E313B04D2CDF8FB718E3BF36267C5E209EF98046C3812BFF94D1870B7BF302C004889452FD3C4A2CED2AEFC848878ABF70587200AC447F8E6C2C8BEA5C5CB72AB7BF4294208A7234C23DF5C963DC6F530BDCA1337A49B760508CFF20927FE64E68BF6A558464B1897AE65EB18C5091734BC8E1AFD63814F8990C58193FDA0 +MD = 7C65788545FD7BD14D73DF831EC1D7AB6434E2E0E6AA21D39A1C202097197B42 + +Len = 1309 +Msg = FA163114DB716206F3C7F7BE954FD93043A2D74484E53F510396F69CC74DF96D5A3A1BA46AE5D7B24529C655BDEC87274B94FC52A7857A6F3E888FBB20EE286EE717FECBACC5462DAE1FFFA610ABF9605F2D4494ABBE3B7F03A2CA857B9EDF686A2E9D28AC7B6F582E0E2AB5D32D986B7B39270B9D45EB9F34A443B3CC2E5A5EC2966DF1B6FED07FC9B1C357A84BF9D7F61F5B65C93B696234F953F8C074DD28DF4749C8 +MD = 332E3A3CE09CA1AE9616BFA4824B081DA7891D0B7D6AD90398BAC4294049C266 + +Len = 1310 +Msg = 20C6506D220F6F7DC38280C9B74ED7EAF33462452729FE54F74C5A1D2F664A80C6D93BE893AD2F49A332D88E42D0367FA52A420FD2E78D039323AA19EEFD069C0FE3AEEB261FC7F6060B597BEF88DCF08F2441B74DF23DA1111117CBDF9D18F9EE0485EEB25E980944A0449F5C7CD7D3BE8E6A9CC44D435A4CE4512FB11FA594809C9CFD9B88E6020F5282D15AAF9968DB4A49DE99F6081E2953FB489D6A6D437F207D50 +MD = B2EE2A91DDFFB16776F5067DF412073A431AF6774BCE22778877FC5C47F793C7 + +Len = 1311 +Msg = A92F1321F39DB5C4DB733D4066E3E4B0E7D21CEC0BC7E2A056AF5EF322FC41B1F8E2ABA2AEE1D3989F2E4FDD42E03BB7FCD2575EE6A1C5A8CFE9C24ED165E3F71EBE9AE5998F12A058CBDFBBBEEFA10DA4822AF880C222707A72D47A376E95088EC09B1CACB895F75F425D04DC72D507CBFB7799784A1D0C2881AB675896442CA424B55F6577E856A1A3C960CBA3D455066AB5284A40ADDB1F3B9BE1A77CEC192B75D108 +MD = EE36E145922E88260D7D94829726DB8F1850D813CF1D2FC4E8F33FC3ED115576 + +Len = 1312 +Msg = F6D5C2B6C93954FC627602C00C4CA9A7D3ED12B27173F0B2C9B0E4A5939398A665E67E69D0B12FB7E4CEB253E8083D1CEB724AC07F009F094E42F2D6F2129489E846EAFF0700A8D4453EF453A3EDDC18F408C77A83275617FABC4EA3A2833AA73406C0E966276079D38E8E38539A70E194CC5513AAA457C699383FD1900B1E72BDFB835D1FD321B37BA80549B078A49EA08152869A918CA57F5B54ED71E4FD3AC5C06729 +MD = 26726B52242EF8ECF4C66AED9C4B46BF6F5D87044A0B99D4E4AF47DC360B9B0E + +Len = 1313 +Msg = 9961309EE2294A79F63F67E15FA0F9B64371A52A33857230E8353C3131458CB573CA7B42C62A945E44DDA553DDC4F830305FDB11B39F61F6DC7A77F45D8A78A1DE5E444871850DB3D77A5FA22664D003CF58CF270EA826D875DB95860A47E057E8E985C91BFC850B0FD10286D7EAFABF60D43591C1EF72200BCD620D9C823D2B571C79A0F735F7130C8EEB485F0AD15F3C3FCDE12B6F903568263820E09FC596A98E4CDD00 +MD = B701884BBBEDAFB4C629F5CF7150BAC2BDA13A435DBBEF90043AB7717ACF4908 + +Len = 1314 +Msg = D7FA17AAC404782878C2D2699B8FBF799081144D736007CEB5D26AE1E8FBCC91FFB451FE0ACD54FA46FAD5015F6E054B5FDBB1156839B2ABAC25175E305E7A5B2290C095CE6DEBA98AE8FA42EF2A55570AC1F9D8AFBA87C7D164DAB421BE235EE4E20969C3601CB5F553B800308EA4F0AFB4F15B66F24AF0658FF64831E1AB34105ACA3150CF5A263EC55D0E6A7727BED78FA74FA5FEE2763C0E3DB49D7E529CAA85C52880 +MD = 942BD7D40697681FF8E6EC5FDF4249BD78572CA62D430768949454420B898964 + +Len = 1315 +Msg = AC37BCD48E5439D0E943E371F5BC1898A4E012238AE77D9B58A3E0009992C4A133213FD26CCFD44E55126B853300E3C55585F1CB273E6A47374481AACE9609AB76D8F11C123A7CA069E74826B82E15304CD01958769BC1118EA86F911CEEFB9EBE136B2A07FBCE3B54D86A9D8FDA25CCF6B51181FD37DCCF5814EA3BE8A93459EED41FF29851518894536B3CD6D0FBF2346FBA2F9D832CF694E9BF4E901ACF66558972A2C0 +MD = 455DA2A607499504054A57B78CC3779A2DFD2BC6B8B1F1F95EE69D93419336AD + +Len = 1316 +Msg = DF7CE9796053F5F36763BA2245F6627DD1F55566D4131D5884E68E74AE069929F606FCD502614D0D2D426A3D462962E779B9A22426C97406ED169719AA2E81E47E68A361D8D0AD192A27262074E872D2ABAC6558795DF2DA248CCED42D2C81E90154E010416CF9A20F53F7CA80967D888B0935F5747ED74B10AEA4A3403033C7BB2819C65FB91FFA65CBA3165D38A0881BFC2EF576890AEF8A988FB0179C38545C357FE290 +MD = 6ACF95AE58F0EEC20B1808E4D51A41561DBEEB1ED6F051D77EDF27B317C3583A + +Len = 1317 +Msg = AE8640B2496BAB96E5B8011A948B207A656B1B78CD05DC6B7CF47119C742B5277837765B9250CA580788441441318E181960FB6C429FAA217C4937EB1B4DABA073A2655EB4DB6E7075E5E3BE85CEC13C5BC50CE7641CA251D617D47F86F10E8B3F6E84C17E0704BE08C6D3DA01CF21D492576E86AA1A0450FCCEA682966E00E5B460CC3FEE46075924CAA941636BB5B0759031F38C067429FBEF3956B05F911D8AE0405CC0 +MD = A54C3BBA794874181486F5ACEED0219A9CB130CB09A3E41F030DFA194F39E881 + +Len = 1318 +Msg = E13B3481EC450F9C4E1BE94348D4A727EA03FF80FECBF0873BBEFAA88A0CF4AF1FCEA38BF55218710AD8C01703797D22AB1C957D4B6552BEC094267D40BB91EC5A6459A142089079369E125361193E166AA50205E66A5BC1723F3596B21388C50CBAD03FCAE9295C48493254087A5742741521E85E6E78B95F7CBB4DD7BFD49CD007A7E651151DA15EF8C6E1754B92919CC60EA7BE1B58B8D60A2A9584A47E626C598538E0 +MD = 4BE1251043A555F40DDFA8C11E170F1D9223AB82A01A863EA262470C131160E3 + +Len = 1319 +Msg = 2F3F0FAECE6B161E84BD245332DD6458A97F266F7AAF6917FB4A5729DC5989B5A918C6DFAA698268F126383D190C4F13A40F765CC76F25E8705FFDF9EBC6BF8984DDC7E5D673F2DB437421A5EBA8360CEE5D213B407ADECCF16E694E962C672DC058965E188A5C30CD1C5AE278325BF0CF21CEA9F6857E982CCB54E68F6B754BE9372C9A9AFEF256B5F2B70A9F60204B0A9B2BFD4809F319B3695AA453A52F62E2DD2C6F54 +MD = E1313E9B03FD95BFE99664A1A5A4881847D272F80B28A2BC6B204BDEE514B288 + +Len = 1320 +Msg = CF8562B1BED89892D67DDAAF3DEEB28246456E972326DBCDB5CF3FB289ACA01E68DA5D59896E3A6165358B071B304D6AB3D018944BE5049D5E0E2BB819ACF67A6006111089E6767132D72DD85BEDDCBB2D64496DB0CC92955AB4C6234F1EEA24F2D51483F2E209E4589BF9519FAC51B4D061E801125E605F8093BB6997BC163D551596FE4AB7CFAE8FB9A90F6980480CE0C229FD1675409BD788354DAF316240CFE0AF93EB +MD = 25E536315F08A40976ADECB54756EBC0B224C38FAF11509371B5A692A5269AB5 + +Len = 1321 +Msg = D8D4CA5DF5EFCBF2D65017ECB36C3BD473D607A30C25EE755924FD1E81E859F0311395E70099035BE27BEFEAB73CEFB3078BE02A61EDC1B01710D41EF113E710BB8C1BA51F5AF87FFEC0FC441515D06C165D076857C56597D01D80F73A700DC0797B609081EF2C71DF882AD6D35AAA4700C510621215CDA7BA2A2D73970556BCCAAC4D55BFED9F38C25645B98126CBB76D662E927A314C4378327941D1A8965FD1059E85A180 +MD = DC213F17A2DF43026E3D24C95AA567701882521C0B047A5CFB7F5FDEEA20984F + +Len = 1322 +Msg = 10C81B77ED26F307D86E4B10EFFD230C8FEAA519695DAB1869346C89B9DA7BD33B5BCA5C0C43DDE500A8C02AF37A417C97AD0AFB6A07AD274F0D09234C74229B3FAF91A5658D2D2A35EDD6992B2E3B213E8336C0B1DD29211EA4B215C358F5810E025B3DF5AF083DED25A6BFDD39BD34B3D7356A17657D31BE1E03E3F562C8DD249116AF11B1CA8DF62A0198D21F855EBDF9209F10600C0B0AB655DC2CE8DE056C8D8FA9A200 +MD = 5EDAE0E733BE47D033199F48F391CFE6A56E2DE2F672E575F7ACD5A60459F72E + +Len = 1323 +Msg = 38DF77114DAC70D214DE02A6253C53D03A44AAD53507C23A6CC64123A59D08511BCDC09505CEC62131C63D89B0A9C0F7071FCBF0A14EF340D0C33C93F37705B076AAAB9E4F590399547754F97B10C79C304907BA8D18D93D16F206198A2839FC265E3D942ADC8ED27D073910A2824424C3725409FD46064C426A0E7417B416E833A8A8FE57046EBA806AFE5AF13E756A6375EA6BDBEC8F5576B615622EA259CB161A878E50A0 +MD = AC22E3D6124A9723CF62CCB426B0EA5403565D280D698EEDBEBF519D71D63E4D + +Len = 1324 +Msg = 430F558E2C30BE5DE10C71F8CF89A448EFF3D6BB8DCD62D2A09DD0FC9171DECCD07C65E77A79147F1D8D75E646BE71379A7EB1A317078D3E70D4CE560BF24948CDDDE283C1F87D907332181404F327DC9CBDF037CD00759EE403AA72874D7B99FE298310AAA01CD3CB1AAD14A116E6E5B1AB95E48E67A73019704D59444BEAAE4DA1C1A432A57233D5B2A233E98ADA735B1AB5B0975C1DFC33C0A7C8AE18775DEC8169A814C0 +MD = AD98C94D741635DC353F18CDD3C34D9D31B4EE26D1A6C12E4654EB5B33C470B9 + +Len = 1325 +Msg = 213D28C42575EC3A807C614609DABAAF4C1CBD06C0FC14D4CB4FAEE17995404399731CBD6D2B3DED3F0FF8B603A7F139625E6193F269D825DE24E2E442AE02AE948C6B3D7E91C1FEB5210280985BD2E1D5D1E7ED1B63896D20A18F8E14250384131E3B1AA2B47A23078DE9EB65B735133992CAFB56B22549313C632B8FEF70BFA8610E5B5C82BDE68C88BD957FCA36B5151AC18B3C2030315C1A8049F6582A6C210115293728 +MD = D6B5845AAE5AFD1A0C133F8B591589A2F6204B220E4A2133ABA78E324053F395 + +Len = 1326 +Msg = 15EC4EB1CB742F14FFBAF11D1CA740F17864D55BA3AE39EFE5E43DD58B0A9A7345B9155F91714C9CF73DA71D59BE61E170CF62E15A5081C4D165693580FAE1401D6CB047D6F5ECFB38453E9906E9A8ECCD861579186EC2EFA503C54420673F2F3F49DF69FF76052B93B92F39F50235C83995B54CEE108F2A9327ADB4CA7098B53647A9E4EC5D4EE6EE042717FE82D505AB9BD3CAA78C4B576E8B37E38663CD20A467F091397C +MD = 4CB80B2F687005C8125EE9A033087606113753A2DF5347EF2D107E193A3A5D85 + +Len = 1327 +Msg = 65B08BEF40F0B21475DD76DD4928E3FF488CF3EF73F4E494A0D32D72F303910CAED04B767690E66972ED6C8B2878CFF3793459FA91A59F59EB7D75C50BF5E49A97455C9B0CD2F0C76B8DA25EDF988655C3BF92DC69E487A1750ADC615AD8DE7AC35D3BCF9F4A034B26D55AEFDA210B753C29101340975DFDA82BE82AA4BF4C9AF108FA4001242F4A412BDD2883F33A46BBEEDC449978B03134E7D7CA7CEF9649F03FE5C2CA6A +MD = 142299923F22EBD516D1730B1943DDEA61A22B27FA5F92F23CFD13A283227CB6 + +Len = 1328 +Msg = 2ACE31ABB0A2E3267944D2F75E1559985DB7354C6E605F18DC8470423FCA30B7331D9B33C4A4326783D1CAAE1B4F07060EFF978E4746BF0C7E30CD61040BD5EC2746B29863EB7F103EBDA614C4291A805B6A4C8214230564A0557BC7102E0BD3ED23719252F7435D64D210EE2AAFC585BE903FA41E1968C50FD5D5367926DF7A05E3A42CF07E656FF92DE73B036CF8B19898C0CB34557C0C12C2D8B84E91181AF467BC75A9D1 +MD = AB504592AD7184BE83CC659EFB5D3DE88BA04B060B45D16A76F034080DDE56C6 + +Len = 1329 +Msg = B13731617DC804E12B6D0208D197E1CA5A19206F697C7A77A36CD015F2A8332DCB4BABDCF4A5C63605E27AD0B57A03B423859ACC51D82A10AF5DBB8FD50909EDBCFB7D429B4F77933438B76CA9532BF10BD1F36B42612C662AAF299B8C9C88ED55E88A1FC780E6CCCB61594CC0B5D9905184AFDEFA5DF5DB1BE814312CD2EF6C89EAF002B0DBCD03814B71B6B1E581F51BDD7DEDA95733369F39849A9E8529F4104BA2B3438280 +MD = 2D5F8C248CFC6E78B8B8ABE01FB26F8BA9641039D5D4A70E7450336E0E1E5428 + +Len = 1330 +Msg = 01368F9B4FD19B850547FA39520B328FAB5371026EF643ABE0CA52A1FE3214AD838183533E5430E79C4E6F6079F576797449AF05761796FEB48C2BCA074D318B7F3281778016F0E204B2DB0488F1FC5FC1452590FE60D133886003CF16FD5544362EDC86CD6570F7C3A653E3DDAC125BE266E39E92BB65AF965BB8F59D1326BCCFFB71F952AC9B95B68A30586BC524073E98911F10E4CD0D0BB9E0C0830BA0944236A747353D00 +MD = AC0508E6028D8048574E759245F77D4EBC53ABE2F6597AF6112A98FEFFCCE661 + +Len = 1331 +Msg = A876C4B9EB23D6D1A0874DFFB3DB4A23094425DACA15775BCAE881E6B3425D116C959BAB6B04DA1A772532EF92EFD9709BB1DD4CB3FF4411882209D3F95D90952692AFA66F9183E8CD2533346D3E5118557CFFDE039D3BABC38647A7C1DD0BA04804EBD8EA3E905BF334FC5844C0E6DB853B4F693D4E087DF754FCBA1C5B2C234EEF82349006C5856AB7E6E8FD8ABA1A3E7E373A486F4BB710A507955A7590B887BB6EEAE01F40 +MD = BD3713B2C58BC9177DB5291B802DD9E74550D446CA09F543B1A2DD903FEEBB80 + +Len = 1332 +Msg = 73461B72151939F14C3463B9133B21CA31FEEC81AB2E32D1BC0EE079609A0E27E903FAC07A733062C1495B35DD1EAA2D11FEBE2CC98F832DF67BA3BEA187C9084FD421EB179293B209BC142B35159AC5057EAADFDA530668C6A645B235E0ECF290BF3CA902FD27875F129EC1913C82A6E6D6CADC63FA672D540554703B25A8CF1B92948B310BEDB4CF3CE581C188661579401CF107B3FEFAC9B642076A589CE28868B3DBC78D00 +MD = 18661D5F926DC2A369CF51C044463B08650A495F8A61154EA25203F9AE0CEC64 + +Len = 1333 +Msg = FDAA7C54912A9D81983FC765E53A5B99B5D478DA0EC137A942D7282D3C97FC674EE734CC9B3DECA4D482E33052D1D0E1F47327ECCE1129BDCA5DD9DE6C5722A54DE82E7F4B223219E6682AD353815A74862B03B2B852CD7A246433FEDF1E7F3C95E59A9FDB00080A4C7CB5473E5E8A9FC2784AFB8730F5B3ABE0EA489C501BDE120B9584D45074192A16BDDD8172545DB3BD993FDBD3D721F4B3E145594CD3410229427985BFD0 +MD = A4921DD15CAF4361A8B713F7455030957E51BCAAA3B690458CBF773987105DDC + +Len = 1334 +Msg = 3FB8DB0394383660250C48371EAA971C4C2F5A3088F028E759FB9FF3775CE1D6BF7D3B114143B21B5C98C7A60D760784787420BE0B29A71663774D02CAB07895B14D18AF5F26B58D97C87AB6DFC5E6C5023880F2D181D868A4938761377F085C51134D383B19F10B9C2527E20EC3ED5603A5F8182EA3CC7A1204B331FCFB17D1E0D42819D18691451051B12F07C2E3FA908842DA0B7F72CDD0E31D7B80552526B36F20C90E4A6C +MD = 30C9FCA521578465A17651C27F552A965AD70FA503F650170796B831E3D57B9E + +Len = 1335 +Msg = 9135F850B5F1C12FC35D88D789F6C0C489F4E5D09C3FFCB4C0A21A6532ACE66D192B214E8E82F099F3CEF20930F1E8FBEA47933016457972BFF66AED7FD8295B01F1F2528CC98A04F1082033D8240749EAFF393E6247C03F51C8250717F10D4BAAB223C86F2189396B48036B0285FB38773915F8CB9AEEC5A0BD117967FC220534A23EC333C6CFDEBD66C526F10E91EA82CE0AA4039C6463278A10F9763528C5A1555213D4A2BE +MD = D1C62819F05E5756C0018951E6ADF847C5FF7A2CA541D4DAA51A407F92BC2FF2 + +Len = 1336 +Msg = 0D8D09AED19F1013969CE5E7EB92F83A209AE76BE31C754844EA9116CEB39A22EBB6003017BBCF26555FA6624185187DB8F0CB3564B8B1C06BF685D47F3286EDA20B83358F599D2044BBF0583FAB8D78F854FE0A596183230C5EF8E54426750EAF2CC4E29D3BDD037E734D863C2BD9789B4C243096138F7672C232314EFFDFC6513427E2DA76916B5248933BE312EB5DDE4CF70804FB258AC5FB82D58D08177AC6F4756017FFF5 +MD = 5D8EE133EC441A3DF50A5268A8F393F13F30F23F226AE3A18EC331844402FF54 + +Len = 1337 +Msg = 39CFC640D96492FE5EE066C51815F22D0EC9069BDE5A1062E578B1FE19A045A4F77FC367B44CC052EA0092841AA1B2D36B5B4F5023F4139DC9D36C6A45E25CCF173DE83CAD177485E1DC089DAFB5FCE3F3103372675AB5D1D54D8AD9F91A9CCE0E55E14FF565ED156FEFCCF244E976ADCC41458D1C8F709F0D2BA20E836B532D5C2475BDBCE95CE32633C63CDE42A76AA032F2F4A01F6B66EF2B666C34B2EFFAEC5C85F880EE3600 +MD = A80627E58496328F7F0AC48A7C1E19F60BB82AC3104184A0CCCC93F5BA433FCA + +Len = 1338 +Msg = 6E126C93AC75E3C7320CCC9DF871C1E414D5A88C01A90BB739E84F7CD4053781C755DCBF96C9C69558F270972F2AE1622D5FC47D52DDD07161ED302D66363C50C7E8F2523B6F4ECA6C1CF71BFD3BB91D8EB83ABDDFA0C1E8CDCF4B2EB2A5949D3EBCBC6E9DA9918AD21F5EB1261C1CEAAB1ADD82034681460441D0E5380DDB02678915113D77F95EE3D42C3170E14A559399C3CB8941FC953EBB3E913A73789E5D298D6C840DA900 +MD = C629149880EF991754F87468E343710307620DEB00AC4D4CC0FAD1165D685BA4 + +Len = 1339 +Msg = F55557FF8DE74819A835E310339E4487E743C20D60DB4162581B160AA9C1C5F45DD760A6FB350FA7C3540E718C25FE6E045478D57932C30E710F0EAABE473AC7E4C789DC2BCB10AF75A4B0DAB28352EA889C257848C885D5E25BACF44ACEA5613BE7C2F34B0E1C3E60B092E84393592761AC201AA63CC1327C9BCC590F0415FDF781D038CC23631977FE6FF968D63C0AAD3BA1678163C4705F46BE48AD84C418A10291E7048B0B40 +MD = 6614B2D79033A0C009A56C113B4FA43A3A82741E4B4E9FD78303A147E6CD8A18 + +Len = 1340 +Msg = 58DFF83B67C6E67DDADE60ED6A0C268047FF37144EAA34FAF2FCE48AFA56B7733C0F4107AEED3695ACE8C4B55A59195E1E2FC93107C1147A38B1E48ECC1601001EC488491412FC5F23565FC7F51AF9B0DCCE5FE954E59309BDF99BE3959865BC9ACF18296F150BF157EAD0A3BBEFC43A50AEA865AC390DC0A69F813FA2D9A83A99695B918538DCB798F29D9FB909EDA9B06D83302B8E04773F911CB2641AE861D3D12FD49FDF7FA0 +MD = DB74124C020EDF536E7E0A05F366AF4C7108464ABD143C0EB2ADE3CF4C107FCA + +Len = 1341 +Msg = 3B5E3D1050E346FCB62F940EBAD635921CE417C934D3589691AF4EB303EE1B0268E19D3E7E77F3C053617ECDD8677AF9FFBD15D94013AEE8BD2096252A1B31014CAF1B75BF197566EC217B979166C43CDE5EE8D56732719CF0CAC6096AAAA54CD606BCF7279FC202304C1FEDBC58A77CBDD40FB058FDC95E6569B0B00C8ED5EF60E54816585F71829AFF637C75272C7A5E08B6B380A23B5CE11368BA6BE566283E4B78D043733810 +MD = 3A83ACA0F278B691E96E732DBB2D3F19674A19B1EEA67A03F7DD587C3C16C1F2 + +Len = 1342 +Msg = 5D2333C4A14A60656AB7FAC56229020ED2CE882448E1FC052EC15468AC4B4BE980D042515EE3280D0F9A6A100E20ECBDB415BF52F620B85C94D2652304FBF053256A6CF5835C57652DFC7F999307E097417EF294CB3EA68BE9E55AB65B55D57E625CD1C4C43D6F6B2C391B8229CA1051D085D485729565BA2B4BC8EBFACA0A849A8CB5F8B6548AD1BD66E397E3AB812026210CE7A918A7F9E41B600D360A5DA1C4D9508733815F50 +MD = 401647451A983AEECDC4A1A8DEA686EAE1D1FD68E6D7AFFB1F2CB6209DCC9002 + +Len = 1343 +Msg = C2F40504BA614ADC304AFEE4C618E6CDC679B644D42829C105F1B0E4470334C566D580FEBC52E425A85DE9E341BA19BB42DFFE31B5096027E13334603896B76E3FFA4C9B40D9FBC4D0DD6BBAA824CA0B151FA56C1A6709928FB853804F0CEA2242B08159F046B28741766337E0957793617B0446E1468B279A037ED18305809EBDD74E36E7873C01B9363ECE9AAFA8E96B43E2AB289665234F8893707C491C6C3738E604C289BE92 +MD = BA3740B8DF5787188403F761C7EECB76B3944F378CF530040B90646D564F2B98 + +Len = 1344 +Msg = C3236B73DEB7662BF3F3DAA58F137B358BA610560EF7455785A9BEFDB035A066E90704F929BD9689CEF0CE3BDA5ACF4480BCEB8D09D10B098AD8500D9B6071DFC3A14AF6C77511D81E3AA8844986C3BEA6F469F9E02194C92868CD5F51646256798FF0424954C1434BDFED9FACB390B07D342E992936E0F88BFD0E884A0DDB679D0547CCDEC6384285A45429D115AC7D235A717242021D1DC35641F5F0A48E8445DBA58E6CB2C8EA +MD = 712B1CC04C009B52035CC44C9505BB5CB577BA0AD1734EC23620F57EEF3D37FB + +Len = 1345 +Msg = C3CB3CE5975C2DD22C8BB03A4E86271D01D07EA027B7557E6EBA98A5CA4B6E8CCCE18C02878C7479D92E546C2961CB99269E80E7A61BED7F1E0FD5ACE5DEC74B8D3F5F2CAA0717822E78EAF8BF1BBDE53913BF9814CA4103C3A98D559FAFF2CD503972075F3C04C8D9DBAB07F67DDC2B1BA43DB3A13EB6574C5E7B7042CC1C7F182BF8CA384CAF5704D3C16EBED4539A7DA4A396F8180EAC0186A99F910B8710EA081B5934B39A1080 +MD = 4D242B68D08078B16A2BC8568759315E913413D30B84A6F058F126EA4C202096 + +Len = 1346 +Msg = F40E5F1455783F8572FE80D3153C87D5BC3CC1E32163424E57083619716ED21C5A055FF1E8E0B49F3B860E1704601ACFFCBCAA546A98F9B86709B74121753FDB16DF79D099136570DDA02948921F52D22CBE958248E0A2B9B6E409146C3DAC0002224DB6BCB40E86DAADD4E51F17ABCFAF21535171217D421E828546A5F1F648D4003431BA5C24A0A540FE1F31A7CCA19BFB5D17B943FE774BB3DB387C8B7352E7E1B2E43A423C6A00 +MD = 97895CDA15E41832B552A536B6FB22FBA1BC9EDA1B80C506FABF1CAB8BD32544 + +Len = 1347 +Msg = 7D9D6BF2422DB04E8C9D0F8D2AFFC296A305021A82DD99B5A0CF36B7B94AB0BAFFA1683A5899FABEC74909636D1EF585F80DB9817E37D09667A4A4FE5833624548B24F87BDE66B66D758A4B49F208C75A5EF80DC5088BD05E3DD12DE637506D4E10D5E1D73179D577361C7B7C98B36DC16A7DA068F3430957FCEB669D3C0ABDF0D7DEF41F534ACB9B124DDAE7E57CC9915440C1B6D8996179E6D796C90D254A4EB8F0C4CAC1ACFF3C0 +MD = B7CB1843FC8DC6F2BFC93FC76ECB7F384297CA4171E2FD96AEB125B824BC05B0 + +Len = 1348 +Msg = 07B8187B9A37B5ED72741E4A43724ABB1A14AE3D6A62B74E3C81A8B54C9B71EF81A2704FA5DFE752A2D7FAF9DA5D046AB6BE4F3E7F241D89D79A77CC6B46EF7442308566B4604431FB4B865781BFD4549C116160FCAC4FAD092ECD4C443DA5FDD5E2977D6C18714B1315B84B2778141710218B6DB4A21BB4D1F294907E3F1BFB6FE51E7A004DB8678BE9B799DBB14BB3A4D4190E7D33C69AA8EC772EE2A20133BF968DB96F2F8E1760 +MD = 0CE942F691F4A4A30EBF1E743C41ECEC312271E012CD22E9E49BF6D2ACFBCEB6 + +Len = 1349 +Msg = 77206E0087B19C5F785F0FCA287AFBB804589648A52A4757614FC17B4B90BF68D3F4F103487F8B7FA7A31A6C6E888EF6EFD973766CD0D189C80E7B33277D22B6DB89108AD4B3851709B749F535ED18181AA564F05ACBADEB21BFAD4AF5FE1EF08DD72D26F4720586D153C8A6F2BC14881EB07FB0C6B88C004EFCB8A96317468F62BEF8B6532E6AB4F205400B33DA576E0694D4667BC66FAF8AEFBA644A820D548D3F90657398B96020 +MD = 7C359A3A9D6DCB5C5130851BE8C4E9E123F9D4D5D99B8C4870CCD6AA4B69B9FB + +Len = 1350 +Msg = 96D0600089A412478237ADC295FFFE4D898DDD2EF945BDB7F2202905699E16C9F623A17F9525234A77A4C51BF594E8419D9A82419AD954A5FCBDA1E46185CB872F2CB729078C6E5EF7B99B8AC4BCA5F9FF58D9C22F128CE12E118661CD4BBB32166191E46348977284EF07FB9DEC83FE46794B2556FC74D0E8AFA9ED59C25C928F03A2D7CDA4DEE0180FA00B0C04EDE8879836D8A61BC0168226F1EE0CECEDE25C835A4253757CAE5C +MD = 7B80DD00686D3021B2EEE17735189C657580719F12698E5785714F1317FBA583 + +Len = 1351 +Msg = A9FB6E614A0D60016E54F7F76379AB10662A8147E40C19DEE4303DCDA99E08ACB8CB14CF41A42541C52865A5106C8B1278CFFADBE74015E4AF6A21EFED08A57A0C8E71525D75FF08493398B7F1A45BF92E6BB571E05A01DF3004B5FA4DEDC71405EB302587A2001D82CE4AB6540552E6418ED617F1807018917FC9AA772FBD4BBEE3FC43BDE9113D7E33A6CEA09B2B8B6ACA762DE6F35E78F52E28EA131DEFF81C34AA51B24D8FB210 +MD = 97677E106EBC1D3C6414D44AADA4E7C0420B08DF4690BCA736D189695822F97F + +Len = 1352 +Msg = B39FEB8283EADC63E8184B51DF5AE3FD41AAC8A963BB0BE1CD08AA5867D8D910C669221E73243360646F6553D1CA05A84E8DC0DE05B6419EC349CA994480193D01C92525F3FB3DCEFB08AFC6D26947BDBBFD85193F53B50609C6140905C53A6686B58E53A319A57B962331EDE98149AF3DE3118A819DA4D76706A0424B4E1D2910B0ED26AF61D150EBCB46595D4266A0BD7F651BA47D0C7F179CA28545007D92E8419D48FDFBD744CE +MD = 942E39E230A2251FFDB2F85202871C98597008401B322FF9840CC90CC85B337D + +Len = 1353 +Msg = 36FD2EF569A5A40207DEC3C593DCE23194D2DE040551345672589F374ACA38C0ABE149F4E38D53C1B24F02BB06DBD9FE3703012F0E5DD9FB836F38BDC62FB11B55EBEE418686155296A54077D71E05546188C6381D0277BB367D2C64EB1977F100B178AA2530E1219DBC0381BF52F1C81897AA2B7075FF775EF42FD948A5F751C8A2CBC0B5F591685B39039BC08FFC7246E9EF8EE8B65AFC11A3C59C25E9F020344CAE26BB62DFCEE600 +MD = 9F2EC711914CC267458E0BF5CF67BDB4FD186E423F3C5E67E2E2D2D3F58781E8 + +Len = 1354 +Msg = A868924523128669E906EF130800AE8CD611A019CD74A3BBA69535EC017865BB576DBCA2530803D74EBDF9A280D0342F84B1D428E4E447635C0237D44C48190E595294B44283BED2141FFC8CE76B8D2C4CAA166B81AF988ADC13C28CFFABA21FC625EEFB2B70A6D3C0BAFC91B7F07CB4861B689A45CF70D0F61F37934A5D7018F206D1E327DBCE56F347CBE576F1218270DC49F7C1D63B76A21A354B3CEC87A1A57E8BB332BF39D6BE40 +MD = 329BE72AB74A8EBD6E934CF3E53C234DEDA83B4C875F87C4ADB35FBF8C936A4F + +Len = 1355 +Msg = CAEFDB135D53FA74983D99E6C0E003D451084699ED4AB28959A931ECDA5FA7E45D54D3345987DEA612F20DE812F699E9272EC5599C365D1BD948B0AD2C30BA9C61622C06814FFD397E34CD0D6079D88C5477648607BF33160AB1853EDD71547132A4C0BCB89463CFE0D579AD4D042BBC6DC2C8D529353E004786CF7FA457AAB6723A70B2BC51F71E7B472B5A7C0D90725CBBE355323BA4ED99CCC6703FF13853F686AE3381003DE704C0 +MD = 2797425AA10F88B84751092739131581F9E7DD304C8BBF65A0318005D0993A2E + +Len = 1356 +Msg = 49A49E75573AECAC91FE025544C29871E97348F0C26232E008BAE56EEB1D9522C98251A44CC8E34F081554E3156F41408965CB9315A1CA7A53D14193500D155EBDFD3CF93F7DBAB715C49D2AAB0C82D165E7A792B8A5DAD7C2C1DF57501D14E20CD6F3C207B07532F772A55756E237405BCA9FDD0E9E6307FBB2DAA3F8B0FB6B2BB0D350E933837A6E742AE9D242578ACA6084CEA26E3D046A0A7158ECF4E852785DB96F72D8B780DC20 +MD = FCD0A95091EF89B769326603D89B5787E7C84FC927C26B7C1AC67B6BA6941B44 + +Len = 1357 +Msg = 939A4A630A161EE6428D48E351FD28190F9CA3E99418855FE282FCFAF85D9B995EF83C934020FE4D7104D9E6191AA489CDD37F7002C9EBC3ADF792DBFFAA2EA7BE1A1F3D7C0616479376C7660BBA1DCA7633474F4101A68766CBCFBDC269E81305468C93D4FF6B01DE681A38C6351DF0C53DF8807374B2AAA487F93A37D2B8C319218EAA06DE9470D94EACFD3083BCD78D29A5B85B4653BE36F1A722DA6AFAA5C5609EEEA47BCD33C850 +MD = 3A5A299C92B890CC7D5233DA6DA490DBF65A98FECD89D96F978DF593486ED7B6 + +Len = 1358 +Msg = 5309B29396779ADEC58AE82992BC55FF47213BD044F67070C5453201A83CA555C9A009FD7B372C50282E5947008D0E7FB125004148884EC2C88640C91372468B6EB8F884C983C83090282EEA7737D953DD2C6AF6A85FAAD6CF72A14512849961913F14EAD5F203A4AC7A5481AE2BB722C6F0427D61E6CEED47FB181CE29642C753282563A78BF6ABF1854D9B1686559439A073E2AC2FDE86BD9955721F9B69288A61F575BAC5450DFBF4 +MD = BF5313FD051D7F48F792D741FB32CA325DD5D526AAA8E13594B8A4E46D757A38 + +Len = 1359 +Msg = 2E1AA86E98FDA5D02B5A87975A497001E6CBA9DAA3DFAB73247BA5711C94C920D746B35F91669F84B5B9D18938C2A670948BCE4050AE33615B1EDF6F4C4463C40A0DD16132A27D8DC2E061744FA443522FF8321A92C71B14B6A3B75846760FCFCC94580FC830E5BDE5C7C3B3BCAC45CA8A7B71D6313D181F6B3A02B66FD1C2C8790DD87A743F7A7A48958BA1BE4F57B2A07D6B314576D9607F4BBDB62C3258DAFD24D3167A3127D1C00E +MD = 47CF9735653CFF477ED98998C36EA94D6BB6234CD6DA3AC75119AB160B793FD9 + +Len = 1360 +Msg = A983D54F503803E8C7999F4EDBBE82E9084F422143A932DDDDC47A17B0B7564A7F37A99D0786E99476428D29E29D3C197A72BFAB1342C12A0FC4787FD7017D7A6174049EA43B5779169EF7472BDBBD941DCB82FC73AAC45A8A94C9F2BD3477F61FD3B796F02A1B8264A214C6FEA74B7051B226C722099EC7883A462B83B6AFDD4009248B8A237F605FE5A08FE7D8B45321421EBBA67BD70A0B00DDBF94BAAB7F359D5D1EEA105F28DCFB +MD = B542B6CD8EF2DAB4ED83B77AC6DC52DAF554ECDA4EF7AB0A50E546BEBE2D8E5A + +Len = 1361 +Msg = 65A13FF28557E4982462A50B622D2B33D68CE803F2BD202F9F930AE5BE9026425F26C640992BA53AA014F7B0765DD49FD7C843A20D42A3135C2A16532B79CA414B65E9672AAEF56D20F72C63CA115153BF9E3EED2EAE0A03A3B054F4868FE8E9F83B4F9E4CE1A9CB87A88280780F8EFBDEAD6E3CDC1BD27000019D38DB3D4F4FD467B4F9CF2DFB4D46A1ED63EC518B72FA301ADA91746495D579FDB94D147C55FBE8A8E4F5A427E28E8700 +MD = 008D603F40C1799CED00F56620086F917C718ADAE83937952D3908C7E225FB52 + +Len = 1362 +Msg = 1045E853FA06432CC0C84304B661E0BF42E06D1212CE69CC6BE4BA28B6B7C4C62679B58A137C5B8CADC43F0E353A2F824457D0D9FE8FE017150DEE305F6346EAF01F9E220A4233F5674AFCF1C29F2EEB4B283D97E3695C007E62D453FAB2D192F16CF26FA7E048BE5EED75809688933D55EA478BEAAEDED1F7F07603ED77CC19B9557197848E606426D7B363ED592512D0488B95618940451D295D32A26E6C155D13BF3A17C65894F598C0 +MD = E691CF5B902DF8AE620FA428980B1CA19EB21C84081B7575FB76FD22C6CCD150 + +Len = 1363 +Msg = 3C10731D5A71E84653384B14B09D136B3B5A5C1F426B6C717521643912FE1346178CD03638F5FFF9584E3E4968E6D8BF2D0D00B893BE39A09F6EC23239053D5E5AA8D95BB999938CAAF66E12C4BE7D65DE0713DC352D9FF372D70BD9C00B3A0133B989449F4535B4FFEFDF5262C3A8D1DA90111853C0E10D4AD880E911880BD7C325804BA23F465916C273325800B04BD6F18C7885D7D2368A099A84367AAC420A865021BFD1A379E29680 +MD = 1AF0CD528E8FB1DCDCBB37C073A4A3702129C9BD551A4BD78B90AE1EA9865635 + +Len = 1364 +Msg = E1D0B5DF1D9D66347907624DCE47F60B127CE791BBB92933E5E4A976509CFE339527540B602A8A73151B654D5B8ABE44D2BBC887CC78A08826D15A2FB8A1FD33DE8E7FC57FCC26C93E2B95F2D7C9322D4DC6C955B844063FC00508ABBCF85408880F73298211A7E7EA3179097E5B8113D3CB95C85F3BA015A87DCE752A0A5AC4E7D0C7B53014AA1ABA3921AA12A32689CF7DFFA5AD6CFC6EB68816AE3DDB5BF6FE77AA80A647995490A0D0 +MD = C86B06E07A4F6C5F0694986AF052446A77F6820FD8D94F5E134CF6557219D013 + +Len = 1365 +Msg = EB46065DA3891E567295BE6219759C53F3DD0A85BBE66C93292120E35C0ACB54AEFA0785791A0FD1BE185DE702A684554FE5037C74906332F0755C88A7D8D5281A793ABE36C9FE1B0AAA79C67DD80FD84C0A07D83F63D053980FCA4FC5E11C8157FD57CE84E939FFC574EE8274C8B2C3608A0FAA1FC8D980CE5526F9D1D73E65B1057560B62A69BBFDE5649A31A4FEA16DB8835251673E1A1CAA2542B248230A9F7C7DDBABFC4474B8CD20 +MD = 1940F78F64F5AEB78B98EDD04C6FD9FBB844423EB18D5756D79CF96A88A3B345 + +Len = 1366 +Msg = 97C3A9F14749A457F890C34FDA5EA43A7AB1CDEE0EA0355FDA7B0027D47072B25A8ECA77C5FF22CFD0AB66E443E33315D3303E06693227A05F56D45648430556307E0CAE518E64E173EF36DF0B3A18900A4DA6D31AB65D40EBD67CB027F2584B3CD266625358905C9C482B61E41F6F11FB749785161FFDA33079F21DB116E2C25C7773BB3A7EE85E23D940F95F3579B90DC088E407997393A5EF709D477BD7E5A682237D1C7E835076FD60 +MD = 16A959B4B324C8E1A50709BD8A70136FE43AFA91D5D49BEFC8348F4F2370A3BB + +Len = 1367 +Msg = 411BAE7879445A945453DD7EBBE35049A2537031F12F7A90C712E6D72C720E7B21E15D4523DC0A5EE090522A69D2786253136E5DEB20FE0D260A67ED509B88EE4444B86EADFCBB9D365CA16BB937065E17B6D6BE7697FB337E1047E91E211489615BD4BD85B5F90B6B44114D0871D9A0890CA0F9BD7960E927C5E6EF0E0651AB7C66E2D1BBE65DC29E8557C15DC5A15076C7AF08925F93C615FDB8A50F99C0FF427589619AB54960880226 +MD = 17060230630300F43B0E947FE9192B13CF16B2170CEC8FF45E10B317EFA14090 + +Len = 1368 +Msg = E4D1C1897A0A866CE564635B74222F9696BF2C7F640DD78D7E2ACA66E1B61C642BB03EA7536AAE597811E9BF4A7B453EDE31F97B46A5F0EF51A071A2B3918DF16B152519AE3776F9F1EDAB4C2A377C3292E96408359D3613844D5EB393000283D5AD3401A318B12FD1474B8612F2BB50FB6A8B9E023A54D7DDE28C43D6D8854C8D9D1155935C199811DBFC87E9E0072E90EB88681CC7529714F8FB8A2C9D88567ADFB974EE205A9BF7B848 +MD = F7E9E825722E6554A8619CCA3E57F5B5E6B7347431D55CE178372C917BFB3DC2 + +Len = 1369 +Msg = 85B3E18D46E358D5BE8A54559ECD1869416AFA911BB6D553040FF39BF7E0886FF7586EE57A4972A9C85ACA71C7D85E2391E2B168C71FEF71BCE1404DADA3C302861FE17A1199CA115A20F3A5F073A3C98FC65D36A03F02099A0B5E9D3993CACEB2636357DFCD05F849A71B8B765FBE0558033ECF0A4E8FC6678325804B5554DEDD02F5A50B88B81898E31C621557624B52CC3431E07B0B3281CB452B4D92C5F7D283795ADB9787E0C4D1EE00 +MD = 4B154B811D7F1C4942431D75803E884C1E415046398AF60C2D396A16DCBE8363 + +Len = 1370 +Msg = BDC1CFD804C90965C32F231EFD3483B12D81CF36497D0C5CE5AD10E9F1D6A47690123D86F5B7D92A35B13A4A19B6BECCB493841C5D78014D7F200DB2E6AB53EA9E9D0F32371E037E14F5E03359A5F5682577E47E08AB5BE223E6C34039D3BE6CEB345F2CE3C4BABF4AFB0CDB336D97CF06C6431C142FC05B50DC0700EA3ADACEC0F08078A5F7EB61F4C6A7015BDD1519389B4FAAB4F93051377B0A324FAFE3AB84F2BD31FBFBDD919BBE9CC0 +MD = 4A3AE535354BE55A338F5A93CE48D1783E9FBE8C84E207AC148AE9C91733411E + +Len = 1371 +Msg = 182CC05EA535B6507804ECABD9447E181E602C8B80AA08C4F594753F4CC8156DACCC95263AE798D21438E085A4C68E3B3E29E99B7B005CD6E7479D113B255804084123C3313DA10C6D205B384809B5600ED73EAD804B29CB2B39E478941C84C937D6DBE1B670E0AE4C40316431B1DC9E84728E079CD1C087823471F599A2B02EDB097CD17B251DC10AF677F0E9B6254F2F7BFEC1CF9A30F4E5790CB671AAAEBFFB6862D8E75195D2AEAE9E40 +MD = CDE4F6BA3EE57B4B3D049A32BC3EC72C7A7B64323BC98608B1E0F2426FC10CA5 + +Len = 1372 +Msg = 6DB97D9CDC81366D8B1652EBA9608590A389871428F38725C8665F571E2F69B12D2268B6912D7AF51EF0C3B254ED335F3924675B2A6F83699705D3CD5DD8B2AF4A63DC44368DFD6F5D4E15696F4FCC71D6727ECCB83734AB9243A6C29C7184BE593D335222A2C1B15117C7FED7527B8D5ACF773DF6F61F34B79A225B66FF74BD1CF839C5D5DC28E08FEAC32A9C4959931D114AC39172A1F6EEFECFD0437D86309FC8538777A030980DB93610 +MD = F9CFA34CAEB3A3A69306384F7F3DA16FA06509DBC7C1CCAF9102EAB12ECD6054 + +Len = 1373 +Msg = B71EDC0731A448ED973F53998CC6988AE0B5FB1C8A7B75FBA3975C6AD65E2F003528D6B1BEBFB236BAE5D731766E97784EAC74EE93B432933F72A94B063BE3ADE93AC63CE35A78956F9FC00063EF6170B565EDA7A71294570F0CAB1E80B924EBD343AB451C96A093D9D8823B2CD2287C45298C800B1433F0C5496C1652008147D7F87B160F717E6F57BDE6A5974D46F25CD8CDD9202E90098487088461269E21E581F12529600E68D6715AD0 +MD = F137F345877422731F9C4E901EC8921C3EF8170534D89349407E0970F4ACAE41 + +Len = 1374 +Msg = 64FAAB8A8E7D4548A733309F81FFCA40517CEE9EF4B134157940B0E52C8F071EC60F073BF95C1D5172999783B8DC13C7EA5FF5E487E04E681D307C89AC67185882A5DFA18593D3C6552490A06741814DD43C333D2E70BEA94D3DC2100FC67886B27378541EE26D8AC08D14BB1A0BE10963B031D821FCE5FAC64E267307F04EE942F5F2D4B5CF621C2BFFB6DCCD03A200A11CFBA6ED13E48E9DD9D9BFBA1851159BC9E8AC4A69D0A97DA1AE88 +MD = 9DAEEDEF722C48F7622FD99430396F6A1EA3F761DBC187654D281896A1FE875E + +Len = 1375 +Msg = E8E01A8CC8EA94EDC5E43E3B1E147DB402CE56040B87A3C4036D868AB599C4B10BF522DAE9D96551C29B2973EFD816310DD4EB56DBCA9E4F4BAF51989A9881A5C5635C4C0D6737D5C34C89C6A5F0B23D4CAE3A72FBC6C52E3B660BC9A169AA805580B804DB77027159CE5581C5479A070FB0781E059FD422F7D17C7BC14B8CCB600ED857E1C0951C9DBD9EFE72A65C2D937E9405025A251DD5C8BEF9EB191D89F035A660A4BBDDD74BFE8606 +MD = 7FAF162C10E917F04BDCE75FD2062D238AC19C8ADB05B20044BA2DA4096586D0 + +Len = 1376 +Msg = B10C59723E3DCADD6D75DF87D0A1580E73133A9B7D00CB95EC19F5547027323BE75158B11F80B6E142C6A78531886D9047B08E551E75E6261E79785366D7024BD7CD9CF322D9BE7D57FB661069F2481C7BB759CD71B4B36CA2BC2DF6D3A328FAEBDB995A9794A8D72155ED551A1F87C80BF6059B43FC764900B18A1C2441F7487743CF84E565F61F8DD2ECE6B6CCC9444049197AAAF53E926FBEE3BFCA8BE588EC77F29D211BE89DE18B15F6 +MD = 14BB22B98EAF41A4C224FD3C37188A755F9B04F46F3E23A652DA3DB9E25D2F2C + +Len = 1377 +Msg = 52C72BD51E24E67F69619F02DC7FDD64EF2ECC334E3F425CC96D9B634A0FE1346046D4F7E19A7075562BD22EA8B335AC3E1068F86254B43DFC388B702E77D90B73BB0EAF6F341E0CF78DA95C9D098911E7A93B691160CCD7615AB5F7BB356D5551326EEBBAA00D6CEC324BF08D46DD0092062840BB790C5D4145EA722B7840A06B4F814E0CA2243DBFB1D9F869A2711C691004FA56CE16CDF67886C6FD0C6280C4A0662DD7DA7215E9BFB3D480 +MD = 4D5C7B10A3E7D14F37DF13DA339A9C7F0060F7B44D9F1767C738862B09449EDE + +Len = 1378 +Msg = AFB597E82538398591806218893B1FA841954B165037B929D0B3524F9FE10D9F0427847F565141EB216E27FD2A74A7293D3C6EC0C6652F02E8F68F9CAA1C1711CACE6681E857EC6DE0C2F4ADE4965934A0C2CC54B2C3B5C8C2F4C8932FF2EF22860EF81776EA18DF6C3E03E9F61C845CB8971C63DD9D7DEF53CF4EB71BAC71890E08855A5134783A2268857C5098C30906118DDF44A60ABDB8289045F183936F65E5F036D92A5316B05DA64B00 +MD = C679FE7FA7342D7E78A788A73D0D9E9EC2CE082C4F08DE5C35727F978C66BC92 + +Len = 1379 +Msg = 791B9415322D15723051857ED74D2ED3C7C6576BA23E8AE8204FC05588C16C8FC70D6005ADBF7C96189CC8B0CFC2CFFCCC6623ACC59E5C7AA94130308FC98AA1768279DBBFEBE893511B10C23B93173D0E0D0045679F0DA7E3003034F01A7078D37A4D1061D48674BD924612E9433EE034D3EEC990DDE038FD2276CE680C933E6C987F20E3ECAF01012CAEAFBAEF8CECC41CB42897ABC51D9C4325507D22833F2ADB7132FC8C653357308E7880 +MD = 517F5DC8447902A514E2497CC7ECAE830DB06B9BC5CD5015C599B0D2F9677964 + +Len = 1380 +Msg = 2CAEF41468981905BE646B56CCD195134864FEC4EBB1D745D797E0F1C0248E7B56C2DBE73EA06F0BBE9033AE741635B947845D0DC4DEECEE855B4C7017E638468F20363B60273F6AA8EC3C5440E9D5D8CF6EEAC954B54D37343DABEFF6ECE1D4F9C85A5F79F7AB64C10B91CC6A9F5309FDC8C36C5704870537131E9918CC44FB308679EE283E729A097329AE4BCFDF8D6244EF97A7BFCFDEF00A6DE4B1B34A5EF2BC34DEB40C98F6AF8C7BD910 +MD = 9CDA248411C08BB59A5398A75118F2E95F9BE01E39A469496DB8C9A01A80C089 + +Len = 1381 +Msg = CD157A1F0076499D06D822BBF48EBA19FE4D9EB7A0CAB55581EA89FBB362FC67FD4D58567C7AE04A55FC4CF821A28360911782838ABE0EE4BEB982382059F5E4E944338AE9BD974E9B4430B65FC8759D407166D6C4AB9EE23F430E7018988655BE974A8FF08E4B932858FAB8CD314804FAA12B51B17BEFFE6846B0D3F3A5A42A13D844846ED813405D3DCF7F06C51B995D6DACA4EA50C9A77A372E4D67C295B1362EC96F6DC442032D56FB1E68 +MD = 6B0422B844547B2CFFFA356542574C0A4D53DD8AD87C72E12DD0A1A83EC93817 + +Len = 1382 +Msg = C4E9236E259392165FFF38AF36A5797AD66D670D0CDD283409CE1B2DEDE1E3D2CDDD50003DCDEAF3602FCA089DF1749B5718CDB1303488DC3479FE9C6D08A9976EA90A207628FDCBE513793068A8D6B1DC7B2CDCE92BDA7C9E3AAC8EFC00A9230929B3B4752B1FF753E20A8F79DFC65FE433B4B2A4BBA4591B053CAF333F05E590DD9BB5191AFAA8B6AE12FBFC92736B5AF3DF31B3900C76A443B667394FE6AAFDC0045D4BC3AFFDF4822E565C +MD = 61C406FAAA4D20C9FF777876A657EACBDDBDF165EEB360CED1B291E04FF14147 + +Len = 1383 +Msg = FF273A0DE1AEA7B291BB606A75DA03511A80372BF12777462BD2151B6807604CDDD0DA1912691FCC03143C43F3E01E8EAD912FA16A2C31AC1C09144ABF6A41F300254EE0DE5858AB6E9536FC6C03F6DBBF91CF2C1DE2604BFD662072299C6A1547F1C3433B91BEF6616B7CD723433842ADCF6F1D38D3B6E3B28F603C068F4CF1712F3A8A2B7C5778F167F835981665B1030EA8D2591C4C5EF22897BE6BA626853D0F180A899CA8377943829646 +MD = E595E3EE0867471C5171EE5E01ADC0476544549FA3232465427E1C49F7BCFC8A + +Len = 1384 +Msg = DB11F609BABA7B0CA634926B1DD539C8CBADA24967D7ADD4D9876F77C2D80C0F4DCEFBD7121548373582705CCA2495BD2A43716FE64ED26D059CFB566B3364BD49EE0717BDD9810DD14D8FAD80DBBDC4CAFB37CC60FB0FE2A80FB4541B8CA9D59DCE457738A9D3D8F641AF8C3FD6DA162DC16FC01AAC527A4A0255B4D231C0BE50F44F0DB0B713AF03D968FE7F0F61ED0824C55C4B5265548FEBD6AAD5C5EEDF63EFE793489C39B8FD29D104CE +MD = EB5668F9941C06E5E38EA01B7FA980638B9536CA1939950C1629F84A6EFF3866 + +Len = 1385 +Msg = EA61FEE3D84881B73252C723EF892EE3D60A8C0E7110CC35D63AD57F0763804DC54C312A2AC900A3BC853544FE1B9E8FEA9919DD96C7C4CF2ACFF778A7F7D7178D60E7EFA92D2D4B799DF82B3211EEFEDA49A0E95EB20A7396295FC7C30DC364D74FD23C324F1F012839B51E972630AFD62589AD3B153CCD5B9BDE845312D62B2A62D6D0C133643AD6FFF829B2F4CDEE0A398484FE203A853EB509E1269CD5EE7E7FBEC1B0FEBB044AAA36016A80 +MD = 1E10DDCB69E8310AD2499DC07A10079C36C5E7299EAE452AECB058312EB9C5AB + +Len = 1386 +Msg = F1586589214B8CD84E5D927FD50736234739505CAB71DF09B22A38518ED55A880BED800C9E631F6AD8E6CBD3A92412A53217E5B8CC92E75235FEE0B383C7D336918B029BB7187978F15271D48C7022A99A048F93570E358FB8BD973FAC8D68D635E5C49DEAE188F081A21B6D3A029417DE1066235E2DE8D52FA10F4F593686BF534337AC15500DF139C391EF3E4EA43B4A1530498BB6E90AD08C1B7E0878AB1AE94913B36185515B3FBF7CDFBF80 +MD = 8EDC7B93DDF297FE874EAE26CDF1D340B7E263405D7E55410753330DE6E5BDAE + +Len = 1387 +Msg = ED10EBF6ACDDEECA6F59FC92B58DED1903484E3760DF203E6553624144B1F2E092522E1144B79DE50E741780BCCE881B074CD9188A978428B1246111C894098A76CEFC4D7DDBDF92DC1D86BE09271F5A85D058DA63441B51AD5C10CC9E9262B0ADA8196AFD5C8B8B89D5C69FD4CFFFFB402ABA352236D582A16896B338A69B9571C79B53F3B0103267516998E4A709DB983462037DC23132E4611A4D829E3190CB58F0FE447BDC3AA224EC768C00 +MD = 3EB0C4A04B1015EAE2C29F1E7200744A95ED00B8F19DEAA637FAFF6BE1E3121D + +Len = 1388 +Msg = 4EE2DBF84BDC18BF4069449BBC6FE90C089D53371B8414D74F40FE3D43FF5F61541C643E259A0DB2A34EB8E7DA502C92A3919F29C61FD3365E8D7F571FB862341A2B6AD9BF0A4F71413188C47C3D4DFF35026AB91E55D4B3B659EB721170E89FA87E076124BFE598C254F5D9B9B5E1B7CC96E45F11402729FF7F8E4071AEC38C8EB303E3B7889F7922B4C54B8A66B5131D712809A7C18245EA099401FEF20A89E5F5680807BA7AA320CA30250B30 +MD = E669DF384D0AF8947DAF1F84C79BA662F57F217114789CFFBA5FAF0F886F192D + +Len = 1389 +Msg = CFB1DB8692375D3784AD79DA62D9BC0C04365706936AA01B23FD2351BEFD1BAE7DAF96B50C6BB7E1FE2303C50E4634C0812E3F097E123F6955ABCFD8F5CC6E37F68286A2135A327C24766311F5E1595024677F5FB1B3E0D7204C3797729A6EE71826D89B8E96E3D31AB98BA6CA2F266C39F8710BF4C15F388306077153CC26F395806FEA930C34BCEC873A20DCC2F9CB2D77A9C3D4FA3B54B20FE1FC2AA89D5BBF0C881A5EF04FFD73D51F701A10 +MD = 9D3B609E2A75787ECC2EA1A20F26DC383816760448E485B63AFF847531437B82 + +Len = 1390 +Msg = 8686F3296230432C11D4C534409C7F6C9410C6F01791E137C456874DD6242AB34485785F08233C78010C5EFCFE3AF755B9EB61D0E311BCB971EDE86AD070069599D33FD628DD4C818C318462940AABF9577199120D7E3840C2BE07E5BDA2F12DB777BFF7251048ACE87FE6B18F33630C2D6A50CC9A6B05C2C85A7A9972147A447CC036733B49CC5722139A2B299BA81ABCFDB83544C7F711B602A7C8372B0436B304C303151A4BE6850F315C8608 +MD = 3EA7D0593298716A616552AC667ED2E89CFDE86FF09394A376F9A79DC97D44CE + +Len = 1391 +Msg = 16C331314AAD721AB955B9C268B2B40C7989E438D91ECF65EBDBD4ABBBAA69D77270FB48BA3CF63B249E78B58D9AF7A57E49E6883E1457188E20D1F8AA8A04A3ED5688E6E0AA4A0C011D02C04EA127D0F66908FEED9CA100E66C976DB5EDD08B832402644537E2ED1BAE1567418B11F017C026E473236B90EB1E171288AB04B945A494282A6FCBFB901A7E567AB31A89A30034F78AB6D8D199C4F03470CBE2BD8374C81866BCE9E91233E1BDAB52 +MD = 01A43A259E8A7E70B8F039F48F96805DFBA164F8C095A9219CCD614663A5682E + +Len = 1392 +Msg = BEBD4F1A84FC8B15E4452A54BD02D69E304B7F32616AADD90537937106AE4E28DE9D8AAB02D19BC3E2FDE1D651559E296453E4DBA94370A14DBBB2D1D4E2022302EE90E208321EFCD8528AD89E46DC839EA9DF618EA8394A6BFF308E7726BAE0C19BCD4BE52DA6258E2EF4E96AA21244429F49EF5CB486D7FF35CAC1BACB7E95711944BCCB2AB34700D42D1EB38B5D536B947348A458EDE3DC6BD6EC547B1B0CAE5B257BE36A7124E1060C170FFA +MD = 913014BB6E243FAC3A22A185F8227A68C2311DC0B718E276BBBDB73AF98BE35F + +Len = 1393 +Msg = 418FAB3A13197089C90621B9BFE43DC2096DC0A0F50461C17AE025BCFED1F8DE587F6AB515EE1987C6D96CCED7F80F9112ACF4B67BE67B0247414EAB033DCCD6028703BD346DBD61A478EC67C17C7DC586563997FD8AF3C9CCF7E5D66D25386FD7F056122C43788F502C14DFEFE435720A277DA4FB8456C237C2828A7442DC934B7D1B1D240562A5AA721BBA9A6E87ECEC6E55790D71B00BF1D8C27D56ACBC553C6136839046B1B111A0919EFCD600 +MD = 43079C9B46D3AA7580ADB5EE3AD1A36C4A3CE4E4451111E00E18825E3F4367A9 + +Len = 1394 +Msg = 2AF8395D282C705DD7A2DC02E6F79DFADF23E7E7DA63FCC4E14D60FBBBFD723F5CB0C861AA79AF16C425E11D28FAF444C0C1A8A769152C92AA9E8B366A8553C596D68B0290F19F47A3F7D597CC04ED1A0AC32AA7560027633E8CF814208D6DF5972BB2F8752FEBF4B23BA23CB9CFC4D5908FF74FA49938966FCC9E95A31783CD9B60DF0590E8A74AD8176142C788C3AEED4DA04708E4F0665AD24C8A100E09ABF9D7CB5BE9A588F45FDAECBB81AAC0 +MD = E442FE265FE0ABA2BBA4C2D9D4F211512BF275A58F80FF612903F659B251C482 + +Len = 1395 +Msg = 18975325469743A4A76EF7C718397A460A489DD0FB36D977D88FE12BD1BD5D1209362A1D116DF0E627F7C96187BFBB7DA8702349F246267D623BBE3C8B3BD69A74149D03DA66834D65AA7B4371842227D6D336456C39FB04CC61A2469C5C5C97F325B1A86D87A081599148E50448FD3ED41F21083B718E875B13CCB9070682A56F96DD27D60D13A15808A80422BCB26429B857B2DCEA20AD6B26B2B367B0F09482616152C180E84A907E8EB7A2D800 +MD = 6E5198B21591F000DF70C36B8F540E8D14E0058ACC32BB06598DA57884234913 + +Len = 1396 +Msg = EBA3F211DC5247D0EB7583D5A99C8A3A20DC6B82A392BEBAC86F083891E04FA0DB97A3B6A67062DAD957ADCE8F6168FEB5A9BDC8A708FF92970A66F930179C8DCC4FC33D39268C2347B2BC2D42FC27E64D4058FEE185B79547DA0EF0B07FDDFD88DED5A12EFF174C50D6978C3CF28C08403B6D48C36E15A244E3170E217C6E5F117E621214C327824C59176EEDAA2FC634FE9E05D514455C8BE239F15949D12367969DC6E5C9BB3E733DB09A68E2F0 +MD = 42615A9FF398D098AA26268AB3C43705AFD40FD39BEF67F204F84041B660D1DB + +Len = 1397 +Msg = FC42CE9E24AACE4B51A0C3EAE31CD7E0832708318A2B07EBE636DA95FBED1A3195456FD4C465CF1E568CA6B5F015EACA47801FE50B739850CE728C25004D0D355C6405638437A6DC1A27CB10D4DE70597DE383E070C46E798E96191A326D4C6F42DD6F64BF8D2D3E87F5C892E195F2AD6ADF16D2865F2DFCF0759CD495925FCBC35D7F62F1BDBA3670FF0F3062F2975D6D82A532437EE3935A4DD1268BB280E2957BF171571105EB7E676546AFA438 +MD = 893B1C683E12E5B608912B3B714224A8DE1BD4ECBD5C176997EA571195264518 + +Len = 1398 +Msg = B2F147D74B33F101A11948F56B0B7E5FF2A1F30C5944B32ED076E09E18DF1B803CC368906E1BF021B9D3305E8B992594B2C461CB7E89383C7860D4DC1CBC4B503D5158C1D81CF752483E46C28AF0C8BC0A51A9E752AE436CF5D06A0C4CB15ADE6BE96AEA3365405FF63582ACA21CAC5F7B9BE377D264D599C410B8D01CCF332CE15D56F9FA7B79919DEA2359653E8D7F0E9FCCFCC48D1F9769B623EBE4E2E6973D792F790B63D969FD5290B93D5540 +MD = 29D57FB8206508BB3FE9933BD068C5544AC8DA99FF9E5EFFE1E8730AFB65D9E3 + +Len = 1399 +Msg = 440EFCD5D8D5CF760A5DCAEAD7B30F9E0BC1261044269AE4F9458311DADF289B5E8A8FDB1214B650F9BCCFEEB4D0B27295C4539D40392776667B8146CAAF5D8E7DE6AF353EBE6305635943A53DF4391C88D8360168D4190AD62FFB48F31FE986ECEC14554C2377E40F426D674626823575C1A40B15C54A706203A70F473CA441300CA70BFDB191050CFEA75961CC631768EB20AB21F1FD8CC5D64A5DDD885917D15E16ABF8B078A59B6D8096E76E1C +MD = A046D1F9AFF522CD914037783FE45319E3F7B57A170608C4E886FF8B18928A7F + +Len = 1400 +Msg = 5ACA56A03A13784BDC3289D9364F79E2A85C12276B49B92DB0ADAA4F206D5028F213F678C3510E111F9DC4C1C1F8B6ACB17A6413AA227607C515C62A733817BA5E762CC6748E7E0D6872C984D723C9BB3B117EB8963185300A80BFA65CDE495D70A46C44858605FCCBED086C2B45CEF963D33294DBE9706B13AF22F1B7C4CD5A001CFEC251FBA18E722C6E1C4B1166918B4F6F48A98B64B3C07FC86A6B17A6D0480AB79D4E6415B520F1C484D675B1 +MD = 0284418C10190F413042E3ECEB3954979B94AFBF2E545FC7F8A3C7DB2C235916 + +Len = 1401 +Msg = A1DD8A52168BFF3504304272CBF393FF2297B1DE115511B7071FAF15CECEA7C1D2E498C46E9BAEFCB0145D4FD220C38271E5AE6EDBC482D3214E3B6AABFA141BD981450B130E971BC0E12C0EE89DA62281BB9395C9935EFE474D8E6F6B99BABFA0E4A6538A90C51E6567E1C8AA7E8EE62E8AF6290E3B74295C023877B8909F00EB53755A62B089C0924382CDFA7DA75521056CB6D1C6D6FCEBCE124C7DCAC671D02BFA5E5A8A49A4B6880F33ADB88900 +MD = F3029A841555F3D50C38DA5E876B8EABD29E2D0914DAD424144C59C86C72B0D9 + +Len = 1402 +Msg = AB6037D426290CD66B89DF7DDE674805C863F8101C2D76443B1BF25707B695B8174F0C942FF7D2F952339FCC936B2897E7BED9C02371A5DCE95D45DA60769F3DE0DFF5A42B962AC9AF1A1612DDEF9D2D586E7E3F090C1C34B9D621235A5CFE124BC4153A1F78DFA15261F7681237D7AA132E96300B9313CF456F0A04188166E3AD6D39858D16ABECF77244BAEF5C72AC491724C8603CE01570EA1ACEFDBBB50BD9BDCFF0BCEE8C1366B0A6B6A5ED2E80 +MD = 2B11EBE60C360B5CC4EC7E6125415A358F5669D76CAB460A6DAD293EF641D2A6 + +Len = 1403 +Msg = A3550EDC3CBFBF03416D72E2D0597D87BEFAD3D31F5B34C4FC50EC47E9CEA45E3565AE04D27EFE21DAC37660356B1CF75D3BBC522CE936A22F8219E0F27DA6BAF3D00D5793BBC2A9CF0960DEB3221844E2C18E37BA2176098C3656AAD8E69FEA5C76C4AC9EDC05F19B63D7D867A6C848899A42461EC6AB4687C0667C42C539698E755B6DDFAA6F4F316BD4A8F91DD173257A309E6B62A3090E6E5AB0DAAAAAD1B8F2DAC5D03FD2CBC3B804A951143160 +MD = D7CAE79D2E21C2EACEFE7BBB885E0CB7AAE1D562315C596530E054D9E6E33D07 + +Len = 1404 +Msg = 338673A0B843331C60FC9FF2EE15A4DFBACB8E77DBB541AAC44E2F6A9226355535E54FDEDE98A71D970F21E1B549AF75C7F91DDAC6693FD1AA4AAF970D3C2D88B4636DAF4153B3ACB92CF76529D9ED18D31EA1BCE1563F1F3A076F97C58A32583B137B9BED88D9A8DE9648E14462A7154226B949EDA577D3888F7C9CCA560FBB53808B32713BF62C95515D857CF630E3EAB52C50CBDE730B48951D165E14FDCCF9B5CFB9ED2169D9615002A6576CDD90 +MD = FB131F846E4FBB1402968C32C32C63A8975F797CA0A27E61C2106CAD007AC89E + +Len = 1405 +Msg = 62C779F840173FA00C27DCB9171DA91E6A8E6CD65805AD17AC31435DEE8C50F5E3EBCC4A9A8DB116CDC602138914AF21BDBBB6A962BAF4C49FD73C1A55E2A3F4C44648E03E5201D6FC6D298BFC3D6716FC3A5C53989C53FE933BF16659BFCD46DD099790E2E617CFEDC88B7F5A48AA7BEE7AA5B910BB748BF089DD12339444EA9029A90554BBB75B5AEB36AA400C1082C1C92BD27F442EF0C93994FE3BBC4559B94DE6E3629A9498526212ED021C1980 +MD = B948FFEF85A65E3E3099A29FA908B3BDD5C65587885A11A316253F6E90DA6400 + +Len = 1406 +Msg = 30F3656BC45520F876ED30757D6F6D6A3AB361C76C8E6C5F47CC7C81A4F0E25D8AFAFFBA6C40E831E6782A09B1EAA138D7933ADBB8C51D4E74B1504A8B40D7D54F70476AE16FABC3C64F71E9F9C8B62655DC2D8D082E0E045E133430378CB399A03E2AA0A6ED473987080CF2C5F8546A1F59680FC1A356A99801CB291EA68DEDECBF5178920F3077977B99BC704294092F4D0066CCFA76D38E6AD378D3A7D5FE1BE18C9F4589311AC6EB2242C812A7C0 +MD = 5C4879E7364D5D46C2A507C4856790FD2B8E82C44406BDAFDB331F19FE254589 + +Len = 1407 +Msg = 1FF51A1F8BDF6283E70E07F6BE761AC51B6731DF858232C78809E1526010464A70DBEAFCA5A165C9E1764A0E6C6EFB3E911D034E9BF99EFCBA863216C261A404B8B825E9E8098C226BB7D644CA4DCD219DBE957992A82D1950E7D2992FBA55C7C3812D61D51ECEC3A6ACF5F09F36E480F2FD99BEAD455897D32094A9017086E5B813CD39E2C46BCB31E89AD6C6BB10C58EC67D89E4FD4263923EFE969D89F561A745FAB1D1B81BD48DFBB27249C386CA +MD = A54A82C54DBECE9FFB297FF30804E78C60E59EB3326B5DDCB50A3497671EF140 + +Len = 1408 +Msg = A5AAD0E4646A32C85CFCAC73F02FC5300F1982FABB2F2179E28303E447854094CDFC854310E5C0F60993CEFF54D84D6B46323D930ADB07C17599B35B505F09E784BCA5985E0172257797FB53649E2E9723EFD16865C31B5C3D5113B58BB0BFC8920FABDDA086D7537E66D709D050BD14D0C960873F156FAD5B3D3840CDFCDC9BE6AF519DB262A27F40896AB25CC39F96984D650611C0D5A3080D5B3A1BF186ABD42956588B3B58CD948970D298776060 +MD = 8FEBFF801787F5803E151DCA3434A5CD44ADB49F1C2FFD5D0CD077A9075A492D + +Len = 1409 +Msg = C0A3AF99262209CD3D272635B9DBA05E7A15EF5C0BA6326EC15C1C98704884C0962363F0B9B441C7188E3E2FB8F12DFECA0E17C89DAC0D58D7206FCDC50259990A305BCD1B748E8E00E9757094B5869294136E977F889D5A2760FCC03678C283289397848039FB9E7E1F45EC308198A4630B48FDD54D57697A190653B23251385C04DD77397E9C27428AA9202554A1C170C813A4FB4B9322BE237B406BA1D5EA2E8F1CA247A135A16AD8E28B6724855C80 +MD = 968678A17C2C7055B056E87473831D9BA5D2340EAE7E24CCEC403486A9D3DD96 + +Len = 1410 +Msg = B0BC6D10B7393F90550D82BDB1B21ED87219D301CF90F738557E606680476EF33A181F939F67A65B40D6BE99E4715B7DC6C8A78F78D38C94D93AD4E342E25543A18381D3E7CC932D7578F3386C0ADD1C20188100AB99FF739D6E9961F86780089DE081F0FFE54C38682A1B4A320A2EE04B2EAFD2D8E63D691ACA60B35B49A3AED81110805FCDDA7819D6A19419F507BDE40C998B2095294714A51D32D46247DCC162D5B24F4B80B9C631DC7C542323F080 +MD = FE305AF36DEEFD82110B845DCCE0A99C7AD783F823BED6E366D420DBC0B6DB91 + +Len = 1411 +Msg = EC886F18CC5512BDD6AC13D5B6711292FBCE5346EDF45A688F4130E5914E565EBBFB4EB6244759D0C061170C730A58DC4A05D9F7CE785EFD635AA625B47D6A5A2BD4FF4F12F3DEE95CFA066750C5EBFEE47D71B511184607EC6ECC71DAFA87CA7348612F02FF564E468B24216C9ACC6A9D0259627ABC4CD470B50FC4330D60643D1846E1B7594B01CBF63505EDC5938AFFB8A497BFEE43025BA7FB323EA46F2261F04ACF96E381DDE0E4AD3CD7D86238E0 +MD = F78BA046966271CFA43B30F2270517556D14D86869086877CA3119F97A4F4420 + +Len = 1412 +Msg = 813E99662714AC60D61C1D7D7F7A5269D8902FCE95B7609224F8CC92F73EE92385A27E670D70EDFE5585023F22A0053BE490554AB97ACE2D0997D7BE77F61C9FC192C0237E5688FF34AB7CD441460A4EF6395AAA2C7F2799CDD143531961E6554A93459306874965426A3E1C5A075B91381DE55CA07D2A783557B953F3DAF67FCCDEE5C0D027D335D07615B75CE699F41EA0B53F5B1FFDB2CBF0116BA1531387E51FC65F9C829B2A504E794932BF5E3A90 +MD = 62BE3CA82BB044AE4CC41D03B3C467C97FB1165587F30C24853018BE6D06F5CC + +Len = 1413 +Msg = 60B651B269E159E5B8C5A1322917C61AC875B4F508F3534D2AB8545BEF7F12B8EEDD363DE66BAD766C86C102E491C29CF45FB7A114FA2BC7A4A95D61A96F8B159244FF088528F7B5B732FAB280EE2272BF4D4A97F167CD546941B8895B27E170DCF46CFD7E045810AFA47D16C8993AB09617C137DB70E84BAA445440F2DE8AD261BF74722DE32286BCB798393CE4F997B2B01759908854C4C45391EFF7BD4F1918F7B9E5DE12250A03CF09A81740C79738 +MD = 67FA3A41947484D2F523A6A9E51AAD8342DFB0B18F5F7B2D0C2DF54F3CE5BC6A + +Len = 1414 +Msg = B8E9A3D80161E08435E4993A2B3D8FAB8EE51DEB9431DB1A7719E24563D2D2DC4F8A4A3D32DB8E0A205090CFF3656BEACAD4B680D41709E5933943B49DF67803C9B0502637B15382A81F3EAA1A91240347BE0595064BCD480AFCEBA8F465EBEE3B2AC41010660453C1897366BBAA433F6A3E8CDF9901AB7A4D38C8772F8BF0A8E7E9D637A61CBD9766A4554B8759F7750CB586D2BE320A18BED8238DB5C02CC227F4311D02C3F12C0C7435C036CB43A0A0 +MD = BA95C653A52C696E94796C9C10ED458C13047692C42C3D14F83791FAA51BB6C2 + +Len = 1415 +Msg = 3A65D42C96E4AA1CD020DAA204E7EEA764F1CD551EB2B00EC645C12427D10360A140BC91EA1CAC2EDD405DD863DA17DF51ECCEAA3344E9B79575F6B86823384024DDF524217A90125754891E2C509AFD15E9D34C414100BCB5D9B5AF98E95B54252E7C82E7230C1249F4BC5E05CD8EF2CDE11474628185AFC3EA5BAF7081E4E84F0522976F9C9FDB293721DA2BBD90B955592953CAC9635877B70397434A08D15F8EA3EBDF62A28B0869781138CC56675C +MD = 9FF6F1088463BAAFD9DC1D36E1D6C67B86A5BD4B9B6B1C35DD64C13A7FC30AFA + +Len = 1416 +Msg = 06CBBE67E94A978203EAD6C057A1A5B098478B4B4CBEF5A97E93C8E42F5572713575FC2A884531D7622F8F879387A859A80F10EF02708CD8F7413AB385AFC357678B9578C0EBF641EF076A1A30F1F75379E9DCB2A885BDD295905EE80C0168A62A9597D10CF12DD2D8CEE46645C7E5A141F6E0E23AA482ABE5661C16E69EF1E28371E2E236C359BA4E92C25626A7B7FF13F6EA4AE906E1CFE163E91719B1F750A96CBDE5FBC953D9E576CD216AFC90323A +MD = EA7511B993B786DF59A3B3E0B3CD876C0F056D6CA43CC89C51C1B21CCDC79B42 + +Len = 1417 +Msg = 630F25144D78BF5D608715AED30D38FCCB9D529181D7AF8C13840A910912DC83DD22AD509C733C04D362B13A8A61568AF79F78020B83039C4DD9F793299D46DF5CC5DFA6D1A43A0497432CDCA64885BF7F091149E07AA2564A3DD1BE08A8465A7DC71CC41044AEE1F193C9D27B12A7A1B986C869243A560FDED3812C5D17A1C8B8EF47CC0EABF9910A9C8EA0014526C211D954299ADBDFF445CDE4517C3D9613E52F35EB0BC4FF6B7D0322E47B36688E1A80 +MD = 0A0E9ABB1360E2D9E5C53ED15B3F849C648BAE84EF871B8974EFB209DE05D730 + +Len = 1418 +Msg = 81515F0C225B6CF2BE73CA43A2B453DD8BA9310A72969A11399CAA2CEEFFDD68B44B1EB2C6AD5C92B15901CC7293DA540B50849DD4587DA32BD2395DBFFC4573F677CCEDBFF15CA06A14E737AA607942E31BBB16F96BE637B6ED4EE8FAAFEFDFF57EE9473ED97BAA6D7D8ADCB9F5EA8DDDC8092BD695FA669DCF9090C7F61417CD583A935E000E9E7C70348BA48DB4368794222D613B909B439B6D630ACFF7CD5A00858C5195D675C824D4B7EA2E6018C400 +MD = 359A9449B1163CD52C082F39742A2369767B91AB313D89920C3FEDD519FA736F + +Len = 1419 +Msg = DDF22A40EC1A0B060063F956521F0D4F5C578554F845600C747C7DCCDDFAADFBD8ACDCC6B3C4730CD22A0356FC5FB59D3597C704924F99F143D57BF65BD009A8351F04C879D75AE6667A9BB4A91DDC1FC7F4BCB0FF420E410C70B9CEC1672AE831598FB482216822C394925AFB758DFCE484F3A4FD41E2D072EE15D7DAE46858FA595B6C6EC51DF9D56FB4DF693D512E8F9597809D7C4D4A43124E8DDB196E924366173952DCDD9A385B0895B8118BB24820 +MD = 36C809B04AD7E2797FD08A75F890F3EAD2582B2C5BBA93F197F8C4D5FD97E1C4 + +Len = 1420 +Msg = C0D30C478BC1B4F00073128BD8D67ED36109A807E8950278F99F30054E610AB8144AB0EA6CFB7AFD181BA4A6B08EFC900F52B418D649A864464C05B27BE7A1034EF537AB4132A4D39D20D6E7FE5C368FB281E16E624A3AE185A89BDFADFDE23E765654BF5DB95DD04BC8860EB03AF6CB2D44F26B75852FE6C1EBECCA1BA0E1DAA247FE2AE936A7A7389A0358AA52EAFD12735074342410BAC6D62665DE6F60F1E381DBB70D24E9DC0F9B39CDE4F48A592980 +MD = EE943170E54EE087EAA019E2B34CB357C9BB502995D12D9A8994FA511DB20BA4 + +Len = 1421 +Msg = B18568A3A8FEC3EF94AE11FC3F950E423446F6D598B31593C2EF3C85BAAA314E388446572B4A1DAF972C8F96ED05FBD30C2A7D9519F9F4D481691D6D80806BF5DD2A6B6BF4DFF749017F24AF44DD2802707637C9B94037DC75EDD16DAD00FC4BF273FAAD88577AE66E40D7BBA9DF1771E6EB4C8DFCA59F3F80DCBE713EAD814532E05E23D29E24E52530EAB98360799F69F34D84C4CD406F0694B07ACC57A6A5A3A5CB98F206FEAFB774B16EE8222B88FC40 +MD = 6958134ADF13BB1E88ADB7BE3926996B30565BFBA48D0DEFC31A7DD0200F8289 + +Len = 1422 +Msg = E3C6B699E534C149A2F343D2E1D626992AA5A59101788EBA6D878EFB946E281CF95752DB91169984282CD9BD610C217058AADA5369D7CA45EE4B240AB84E8F8FDE3EB18A88015DDFDA475C146E32E6047AF1365899DBFF520993D42BBF6520492F7E3A1005C2368E2C45BDEA46B2B7AF9F17783CD3BFDD346EAD18142B348180FA173618B7385E5561ACF1EE8E5A11B583A94444A8B8483A5316073890396B14697AB3EA2DB759AEFCA0D723E56B9C43C5E4 +MD = 65000687F9C8362D1E96BE006C8FA255D5B2A8B615FE60F288AA7C52CBEAFEEC + +Len = 1423 +Msg = AAE187C91F8EC85BB6DE3F46E9E30D176C4E070818834DB8FABEEFED1F51557C6BF16EE80AE3A7465AFC513C1C0B92CC9E1E14C6C8D7A03375662117AD498ED2300799ED8B0BE37FF6A95D0D57BA4A9FEFB4BE43CC2B7C095D571986547F7825C83A1C6148891803847A7EFCEB5D78D835407D608CA8EA1E6FCEC4BB8BC26D700D04AD0C2306B148E00216421745478215917D3E5D5B17428C27A13566F4F87BDD020DE5A2B6FC4BEB0C0F73FAF72E5C868C +MD = 06417E2DCBB1F48EA34348FDBE205C76F8AEFCFCD8ECDD13C1B9ABA46F0927F6 + +Len = 1424 +Msg = F1C528CF7739874707D4D8AD5B98F7C77169DE0B57188DF233B2DC8A5B31EDA5DB4291DD9F68E6BAD37B8D7F6C9C0044B3BF74BBC3D7D1798E138709B0D75E7C593D3CCCDC1B20C7174B4E692ADD820ACE262D45CCFAE2077E878796347168060A162ECCA8C38C1A88350BD63BB539134F700FD4ADDD5959E255337DAA06BC86358FABCBEFDFB5BC889783D843C08AADC6C4F6C36F65F156E851C9A0F917E4A367B5AD93D874812A1DE6A7B93CD53AD97232 +MD = BAAECB6E9DB57971D5C70F5819FF89C5093254DE19EF6059C43CC0AFDA7C5D34 + +Len = 1425 +Msg = 27FF5954E8891FCD89DABE745EB7CD5958DFF6D7E3E3D2CF97B2D0E2EE4CDAEFDA88C0758648BB079FDBABB329133F6634869421B535E48F989334E8A856ED39DCB05910D58DC95781F3C257B40BE661409C132EC32F608AE30D29C54A3654B1CFA4BDFA3D390C3C4A5E38F45A767BCB00FD0EAF9058609F1BB406C9CB74E407E5BDF239BA4E49436AC0372AF24085E06385798284F0DCE70945BC2527A8B1F120E052F2C07A4B053C157377563F3A90697580 +MD = 744F9581D967E0F7EEE479C5132C0F9DE5996CE264AD08E54EAC6E486217E4C9 + +Len = 1426 +Msg = 42F0737B6AEA5ACA87B2C457D174D642606D7453D0C9A4506340BF1E512BE60F14E69BB3DEDB5B104AF7EC2C9081C8298981FBFAF0BD0E60BA4434EEE1851D921B04BE4C9AA5EC34448912FF855B8FFC1B21CEFCAA953501E2A941C931FCBFBDC04FF3BB20C5FE4F44350C940B3EAD03B51A9D96C0A207872EC9A0400D9F0B9034A2F52973DC162666C42B2EB62C79C00BC037675BCDB8B89A088F5C9D71D794ABA89E73BA02D6897F782587CB3D48D4EA39C0 +MD = 7AB0EC7ADDCB43E036DAF9751E46392EB51C7A0D7C7FC1881691BCA5AB99EC81 + +Len = 1427 +Msg = 9FDB2A4D221AB91136D757429CB01EAB202E2F0CB45594D71089E64A3BFBC162CCF9E5D524B59E86FF0D4A17FCEA00527406F0EF14530340480330FD4C4EF48AB6C711A8426908207992697B270B6896F9100B821B763E2C8F0CF8AB5717835D8BC79130B33C48FF8B922E9B7E94C99B8BD361248211CF56D763363E9677161793541C04EB803377B8082D5655C3A3B407465CCCBB85A1F3A713EFD1F4D1430E25D6256FAB4E933F1A559D85F8B65A56749100 +MD = C1007ACF0F2D53F34A7CACDBDEEFDA528E2EA25D03EFD68A7F7207D40282BD81 + +Len = 1428 +Msg = 057A73197CCC3B7A68FC6723BD1C32AD3D5E01AA6B52DB53D546EF1F7623F428619D25E3D7AC1704D6B23AE2D8433FEE576A0139FA46FF0B2E13D4DD413812E7B767E822A4C3CC69DF40B45478D95C1199270A6D28894F99584C2025156540207A3493E239EC7E95E7938376D0BABB5EEBF41C461653F9752A6CD4B1521E9B1F1163F13E186F8B82434A4DA1D8FA0882AD016456F046C7175FA0A8834C8D5DE4AEF28C986B8B5EF5CE4581AC6B616AF6F509A0 +MD = 40CF2F1918043827A222BAA31CDC9754E4F935D52743236DA5FEDD9512C5389A + +Len = 1429 +Msg = FCB2CCDB7CB717152580A4D6FCB174C44B33153708EFD174F3AF31CA0A01C8DDF6C8F07E608EED84F450EEE51096F951446FDE340A9BA3AFB0C9E44E84208498A99D02C5959A37815516E140E3758B5E00EF67DBD9BDF8B3C6A01623D328F649620D85A757902EC780CA3BE2A54DA5A8929776DFD578C44A953FDDE6A6D35B6163510C22E02CBA7479D277F04883CBB83A05AEE5755342DEC6EC49DCB4CC44EE99AEE761EDE6CCF851FA3B23D3467D44487F00 +MD = D39ED14A5298E58FC843FED662D9FAD6404C64233334B5C24C4B23B06D9DB642 + +Len = 1430 +Msg = 710712BFEA5E62A9D7954D7B01F3F8674990BB1F59CC6D822C4EF08AC5A51DBE500359BCA2F2A74AAC4ADD615396A30AE28FEFC53EFAE850FE9536815035A8B8BC064F7D43B309CEA40A825C008F0E4A0F9BBBCCCFF4C4DAB40BCB4AEA16926DE6516C6793C19BEAD079358EBDF6C08D5AAF9EC4D4B600642843B904C0DEF4D3B865A80F0D47DCADA317E9C341EF8C791085ECB7724724E7D8779E9EF05B4B7F5F813D6D9A37EFF6D46AB0B01CFB402B247C14 +MD = 1BACDE48E6EACD69FE2D6D39EFD30EFC6D59E3CD0DFBA09286611FA0E5E361DE + +Len = 1431 +Msg = 84E71B4DDDC7FF264CDB550A47ED25478E863E97CBAA6059F471A13693A5E96D4433185C3F7514EC6CECD03AB6564F23D716B2BAE4A13B251F7DBE1EB3CDB00CAAA677588AC611BB45293C550B647A3DBDDE55B20AE6BFF0E6F3A1E1B6B6BD34731EBD87019EC0FF5E396459C70577587FCD0E12443FDB66E7D9C0C9C757DF7F0569E7F4BBAA06435C7CD2A7530197BEDB0046DD51FE2262FA729C048A49EE357F2D135F9A9317C163997CA714B3F6F5C2CEA2 +MD = 1DBD24EDE78C4CEBAE168C4A910876B712D3114D56561F39D72B1D1299AB6764 + +Len = 1432 +Msg = 9D9F3A7ECD51B41F6572FD0D0881E30390DFB780991DAE7DB3B47619134718E6F987810E542619DFAA7B505C76B7350C6432D8BF1CFEBDF1069B90A35F0D04CBDF130B0DFC7875F4A4E62CDB8E525AADD7CE842520A482AC18F09442D78305FE85A74E39E760A4837482ED2F437DD13B2EC1042AFCF9DECDC3E877E50FF4106AD10A525230D11920324A81094DA31DEAB6476AA42F20C84843CFC1C58545EE80352BDD3740DD6A16792AE2D86F11641BB717C2 +MD = 56DB69430B8CA852221D55D7BBFF477DC83F7CB44AB44DDD64C31A52C483DB4F + +Len = 1433 +Msg = DBB381C83C3DEEEA298B3675314561096DB1F8447B93ACD2588E66C568C111B9DDDE0E5B504A05C041D0DD293D46303D5DF2DF40AE977D85EB2DFBB2B572D41163808F3B227E2C5B262EFAE57C3FD8E379407C1F05085686388F731B0AF0E085ABF39BBB8A73785E34B4ED59A10C97112FDEA64AE17205CFBF8D40B31AC29C206E535D0EBE38BECEA633E47D2F5BC8B35CA5FA6F87C4E22E3789D797E0E3B6188FBA2ECDA83100D3360F73B5AB2D7305353D2D00 +MD = 1C2E5087176DEB2E739CD5595DC87C19394CDCE3EBA2660637ACA228B72899EF + +Len = 1434 +Msg = E0CD21C86AC23727E5E5DB80A53C5F827CB30453E30F603A4442E5B311E90C152A129F8221AD64D1F8FF54DE336F0A1F92CB9D62C7660100EABB8F850C035F2A88689F9AF69FD598FB7D1A8995727B99170AE840758E88C1DBFE5873EDF336F4E68457A0EC41A21C99EBE8CD10EA45A56B3870B710D4FBFB7CABA277291A3368DEEDDA83C18D1F71701E9EBB241497C689272E06C84AF1505675EB998D9B61D92CFEF5AF71F93BA6E69F004EB7FD70A7A949FC00 +MD = 28F5AE2D592C2FD3942D5AD7F72A8E17E69B2BE34C6068A3B85FF34BEDD298FF + +Len = 1435 +Msg = 33769F64E496F6B1F638DE77E3538A49912116ED9BB6DF2CB78291F05F95C274B971AB1AF1ADCCEB32477171C4415C0D7332D36BAB37EDAC0278DC8C392E906F7075280BFF6EE7817D49DBAD67966D36119D82BD49C19CE299EB7C64A00DD4BCFA921691BF064758E3010D5F2C7B5878E6E0B763D3113F3BD6E80155A4DF33137360F735145E907F1165C6739DBB58933C6483C962A7C3F139115FF428D61438A614909BA6BB233CF953A953FF4561C6F7015240 +MD = F4697AF4ECDBD3F5EFC4ED222ED6245BEA6A66C510B8F5335C4D8BD3555991BF + +Len = 1436 +Msg = F3B541C39E2EC19FF5750EB4079E723F5E6BFAD3CE36CD9BB5B94C8BA520784F3651714D6ED955777FDD5A8FD543245B61C7E02B2C3CB70FD5691861F52D3EAFD3D278BA01C11B8A133F8C83C59E6D92359064543B418919000A1E80B908FD605766635B796696B57DBD8EB06C100AA2C1045D6C4881E2DA0038D7103A271F00F1AF4A048F246E8D8EF1509D9544FEC29E935E1FB12649FA7FEA43FFDFE84174A3ED17E4D802189127AD58B4D45781EF60CF2270 +MD = 9F15B662B7A60E17F3C148FF6B6042C1333EB06A06DC4CB87EFD3ADB0FE0BB06 + +Len = 1437 +Msg = 485F865DB14C353CBF0DA045E31DA2C6A0AB5D311EDFC6FAF819E524D55C3352D026370C5B9B0D3A764DBB76CD9B34BE367FA1A9BFB0AC617C94D47AECC92F3FE5F57B27B1E34F99B994470248BFAC53BB7D58B978FD048CFD8FB12A0EB30F163D7820973F3C08078F9C07D8AC1C2029D8639EDB51EFB60C461F7740E1252E42EEB6EB3466E0BEE310148059E352766A8D3ED0C08E2ACA6F5EA39680DFA2E691EF44ED4DBC92B27B28C22E666118AAD88E623A68 +MD = 7D4919B062824AC6BAD7E52C29C689F08A032A5B68CBB23A09A4EAB828F7E925 + +Len = 1438 +Msg = 47B4E93B903E93CFDA571880ED0D0EB2B409D724A6A6D835CCE0C6554AE633B2A385263323EC852FA11D8212690F7078D8AC78218C72953C2FAEB4A5065A779B0E484248003A3FA72EE244EFC6D0A4B1D1CED8EC099492E13DEE522FA2DFD89D8904793A9E22C7272C77CEAF265C7DCA3FD08DFF17C038F7D72A513B415A083D5F5101D2982B342D75ACA0A7FFD8B00F59BA8C0D2B0AE6CA17EE763731E1A54BB071C21F63965F10FF8B50C4E4AE6EA311C15AB4 +MD = 807D1DC023376D17A27C9AB1167A4C51F99F2427757DB0A8CA9EFB4DD4654726 + +Len = 1439 +Msg = 192D3A6963242323C642AC515B34F048904B933B7FC8C437EA751F8764B489BCB823E3658308B1D336A6A0BCEEF2E2ED8F27C2EF30C6F3C6F80FEEE59594B29983CEAA98AFBF04FBA3E6A9C9B2EB8A178076BCD838FE9658F7BEDC9275487A10C43CA8CF0D0278CE815D8D4FABBEA410E4857F45A5F1D593A49AEA704E3D5BEE8554CDB7ABC51AC584CC13F099CE3D1871C57032476951DD46E1C162D155B89BCAFBBFA867C2622ADF42321205E7F097DA3EEDA8 +MD = 1ADDC1AF963660BBFC917B97441AEE037EF17BF817B70CB2B8C46300CB1E88FE + +Len = 1440 +Msg = 5179888724819FBAD3AFA927D3577796660E6A81C52D98E9303261D5A4A83232F6F758934D50AA83FF9E20A5926DFEBAAC49529D006EB923C5AE5048ED544EC471ED7191EDF46363383824F915769B3E688094C682B02151E5EE01E510B431C8865AFF8B6B6F2F59CB6D129DA79E97C6D2B8FA6C6DA3F603199D2D1BCAB547682A81CD6CF65F6551121391D78BCC23B5BD0E922EC6D8BF97C952E84DD28AEF909ABA31EDB903B28FBFC33B7703CD996215A11238 +MD = F8538F597F4463CAD7A91905744B87156DB33C65BA87B912427FEC3669F425D4 + +Len = 1441 +Msg = CB28DC66F267394A3C1D2D1F0EB3BDD240EF9247529E8720395D64ADC644F5B57893658A6E57A34BA62F68E237283EA6831CA94A0FE337BC9B1D08A773133B968515FE7FDA3F851E108EE51D8FD01BE0A8C5B725D530B6425B7E9A988501982901932E899F89DC606D1ED8B1431E4C56015DE52EBFD8B09CD259FBB2D1B3A69C58B9684C66870F0D60B0FE0F75EF310177D512CF549256CB656EF3ACEE3B2EF6728806F74DE8F627C13B272E4E9885EC4DA7AD2F00 +MD = E12005D42C2ADFDCC1D81B5930FCE06E66EF5382939EE633CF037878554836D7 + +Len = 1442 +Msg = B2C51A76F1B06AEB1253AD6E8676DBBD29B8583ED2D3783268FEDEC3CC0CD4CAF9F12E6FE389294FC22A26C88E318E047D9A98BE25EE9B732F93D10FB57E8F3255F6A063DE245942664715C9A3BB9170587AAE67352E7E622369C2BB879B665A0B528FB1575EBEAA297425F6C7C4084E56C76BA7A08025CE545F0F4E9B32A331B950EB6CD55164200E35D04DEBBE5F16E62BA8624E93DA2FCF8AB5900A21EE87DF4514B3C5C93E5FEFDC24D56F9B691497256B2BC0 +MD = EA355D7F74A912B933B165535A5493EDD313C9C1D639AFD026FAC01D5CB94950 + +Len = 1443 +Msg = 36D5168F9586EF46911AEA6EF807874442C0DA3ECBFDA4106E0A71E921C511DD57904E9146E40EE1FF73B0A27C31CF06AB50B13D1DC8885932D37CF5290FF9D99C3D5E82700C569123564007D6DE15C34BFBB6CB76C7C86586156F668FF41E1DA02C7545E913F9FC9E68C3D8E029647FEAE1EDB069B8DF51A8185A50BA1FE44FC460F6CAD0A07CBBBAF5A09FDAB67158BC6D5DAEE6DE926D1C38B3AAAFB9A3EE43017ECA11165C9AB567E8A88EAB7B5DCA15ABF4C0 +MD = 3F2628095B86624B123037FAEC22ED38271FC58B2C4DBCFA3F0E4AA0D7192FB4 + +Len = 1444 +Msg = C7873F231D267158FFB7CD6451E1A0D8CD45C1F2226C44D875C30DF55660BDA0CEE25962DAC638D3473A088BD101B62EF078DB5C2B6F88DD2C76CAFEEE78615D1B36D0BB40569A486AFCE45A1C00E8B36148B865D415DD25D451CD4A84239B899A5D37F4E1FFD8A68072529872A890B6C339EB013F931B5810C6F65859BC1F8A3F7C9105FCD2AAFCB6A837C2715B4BED69C29CB21EDD6136C114C187A3DF169CC4BEFC1F6698E1928BC038AC8CFB1CF1C7F26EEC80 +MD = 4324F625FE591710D31DB6B72E2E97BEDDEB4FD62D41CC2EDF2DEDBDE4B301FA + +Len = 1445 +Msg = 597C27B64C8D275F6417DE1F56A9C78CAE747E024E8DEEC25B79C28045AA3A2A1416DC9976A000BF766DCE03023615D82DB887C2A8DBC758206CC4A645319A5A32AF70B3B1A5058209AF0564C8839C0D2D5A298539D6D0F5EAB212093AA116B074D1D66A785064AB5EAB3258D307D4CBB2C0B3EB97403B542EDCDA51AEE1077CF1E0187EB4CCA42744EA22F1CF0FBC6B96B112AF1B235A8D618491E19B4112DEDCC1B6F8C3722C8408CCC6D1DB3318054B2A376560 +MD = 9137A03284D46C83C5C3DBB7F9E15987B7F42EB4EAD1582E9D372D42C66941A9 + +Len = 1446 +Msg = 6AFD2AFB1B7217CB78DE5C9230502D0092D8D414E00D4D042C659A8DA687E1B09445D95F87B6A48901DBE3784C71D4C0A98724C05C80A52529A76C0EDA6549F9876219F1103A5C1432A4ADB76F5BDFFC30C46D9E22A2B141524F735369190E860AB33FAD9B34D17BA936AAE4059660A5C9006E5E6EF070142A0C3B6CDC550E5658360993A14665AA63B71495741F23076696BC799234AAB0AA598E53C9FCCDF14EE38060C11D4F799C9BC3B608189FA0BDDB006344 +MD = 4FECA94898F9EA969E82FC84189C47084919F02CC498D5E2D51E1E5747B7F9D9 + +Len = 1447 +Msg = 0D7CCBEC6DEA7B571B4BA9D8E11FAF3CBCD363DEFBE8BDF97F99E149BF3BF004AEB600784100AF7AC53A1CCF43166FDCE8AA87EF6A9A7CE66110C72B8DBC940AA6487C9A0439446EC0C555B7DF3E0D219A21392B740461574693FB814C15A4068626D29DDFCE3215F0701511AB4B1CB96C544B8B25DD385F0E870F5A32B88AD31FD49FC5F25C9867E682DA5ED1707A6022A58349405E665563BFA17F815FB0B402FFE5AB89BAF3D758DB8B4291F65329C8C4CF950C +MD = A2F02F4B44E45F51757056FA199328830518AB394654CF1C3834FA4340A14917 + +Len = 1448 +Msg = 576EF3520D30B7A4899B8C0D5E359E45C5189ADD100E43BE429A02FB3DE5FF4F8FD0E79D9663ACCA72CD29C94582B19292A557C5B1315297D168FBB54E9E2ECD13809C2B5FCE998EDC6570545E1499DBE7FB74D47CD7F35823B212B05BF3F5A79CAA34224FDD670D335FCB106F5D92C3946F44D3AFCBAE2E41AC554D8E6759F332B76BE89A0324AA12C5482D1EA3EE89DED4936F3E3C080436F539FA137E74C6D3389BDF5A45074C47BC7B20B0948407A66D855E2F +MD = 447EDA923CFE1112A6F1A3E4C735BF8EE9E4F2AEE7DE666A472FF8CF0FC65315 + +Len = 1449 +Msg = 3564C4692887D8CB8067A9D799396CF83E3DDB7E32CC4FAB3C87D31222B668852BFBAA78E3D2ACDB5AD889361E31B9DFE0FBCFCA00CAEBF8D07A9ABFA3CA818D0EA41EED422BC2C7F0AF9EF15C6D53FCD781E20112F9E41BC8F1C9E1DB278A723FA1C2D5523AC38BC0D5A93D3306AC033E62848932B10394AD1040F235466B7ECD11F484A0C874BC84AB18175C7BDB4F816A3762AF418D64978823A450B8696A1F78B1ED66D649EEC8ACD35160C5885E11CFBE86CC00 +MD = 89C2B04225862076E03FCBDABF35FC228BEF398BB8191A327A964F104C4C7672 + +Len = 1450 +Msg = 860296392D96C556086F61E4ED34E50C95B721A8B051544F6031AE174250979846DCC2E5811201CF7A16342976B7EDA6D2B3C4644FE8FA3398C05921C79CE3DD806264E80AC1EA1FC124FE51D573AD7823D2C7CEECF4F06C98CCE809B5C16313E04DC0B48A9410115B36DC5331F6C2BB7606ED2F7E6A0D575F8D0E93D996FE246D5BE00AC2A5155E47E87E73D568C990C44BEE93530073ABC1952EEE5904F41254FDF82030C4ECB46F497A695A43C87BB759AE1FE280 +MD = F8E300085054F9B9824991608548F74665D774C4DF5AC599B1A7D8234587F103 + +Len = 1451 +Msg = 8A59028DB3B6F5C6073C6A778DAB8A9A3F64D3AE4F13DCDD25481DEE57D2DC82481C83CE4D43D8A173DF49A04303E980F28D2F4BD898BE8DA36F0E470DAE4752192F9923B46E5AC88D7C4D3DCB8C8D29E8135E0E0DC44952D45D7DF503BEF6E53FE9776F8E4BD69F238F4CDAB93F063FC4639F5B72B65B90FDC96421C5BF23B8B30D7F87DF53B74EC6ACF131701693CB6C744AF9DCFE4BB4831C854AF76FEBA6DEF37D4469041DCCCFEDC1504227EB60570A450A6C40 +MD = F08CC8CF5C2B0D8ADD327A3EF4E453F7877CB3ADC454422AB170D7B61A98260D + +Len = 1452 +Msg = 79E4BAAADC1878BFB1EB26C7D4B23178446845FF6AB3E45E571BF06FC28675A7AE0FE524FB99925CE7373ED9DE395B296603C9F53CBE738393776B9C5AE265965D26ACAE303C4DA1DC45F190B057B561B1F8B13A4C02D8CAD6E1DECDFD8825A64A40A78FCBA195759D596AC898A2B984B459ADF1FD7781B3BE50AADC6D7529C38DBCEB9016A8600D2940213C1DEC81F7BFF72E6D753D2FC540B50621B759F1430233E588BBBEDAD1E978AF4D78859F869BC25A587C60 +MD = 39CED503AF08A5565B53375C556F01C251D7212F86866958723BC3A9EED1833B + +Len = 1453 +Msg = 0FE88DF0E99E878F8DFF574D6FEB68022CD544533B7D81B07ED92C67ED85A6E890D635E1801026E84B202551E7BCADAA869D9E00B1CE69C0EF2AF908248541E0BE5134B5CEEF8AE1A2B548FA0DF257477F7A0669DA6092C2D9894F00C299B1FE7EE480978D655F463942D159F0F6414E77DD5795E3AF080D060CB06C0765A7582058C47A9C8C1B2A255CC8655F8EDBA851413DAAE7EA4F4DBE6DC9AC91ADB6FD702A2F039B82E461EC29B3442915D4E12601A8515928 +MD = A9641A953CFB13FB2A503CEAD6343D13A4B4D1E6CC3B2BE0741E35B562870CD5 + +Len = 1454 +Msg = 679A778BE6C04980258827BA7F375C1592BBD320C505431B9F83547E686CE1AC87DDF4954A481F3227D27ACE93CFDFE507A8131CCEDBE29578D3523DE3E0590C4D17204B2044DA755EDD8B2D429E0B9092A8429B89AB2A62E0E7519450A193EBFDC2C4FA695C90C07F29C016CFF238F777D6ADD5AB606E1CFDBEE92420A0D8F9A23D5F291F496571AC573E98D8FBA2C31BBF04C1218AB9B7ACA6FB3C6B0BBB0FA9B8EF9684AE3F77275D53EACDDCFC5DAC4220189940 +MD = D9193873A72F32EF7572CF62A5383F6B6D459DFAAD98552D5024319339EC9D87 + +Len = 1455 +Msg = 69F739517865837781C3907381AFD544AD54E4B4E92E4F6A94E4508C592606548EC974CE57BD5EB500DB5D5DE19B6A5205C826EE7E805930BB01296F245F285264759C5D87C10CBF9FA8FB2BCA99EAE647E18E39D23CD916C7B8C709740D88DA333A7772ECB55BD639F19F25BF0F3CDCF1576A5C5B4EF558284D427C226DDA5828F2A638310243A42BB9A180C89DBC7533BDE057A6ADFA799D7C316B4949B49488FFBC760CA818F9E4B11A83FF144B91076C98691944 +MD = FDA877B2675BD648EACB440E25115EAD4173BE2E9F4348181D8DC12FFD6063C0 + +Len = 1456 +Msg = 0DF2152FA4F4357C8741529DD77E783925D3D76E95BAFA2B542A2C33F3D1D117D159CF473F82310356FEE4C90A9E505E70F8F24859656368BA09381FA245EB6C3D763F3093F0C89B972E66B53D59406D9F01AEA07F8B3B615CAC4EE4D05F542E7D0DAB45D67CCCCD3A606CCBEB31EA1FA7005BA07176E60DAB7D78F6810EF086F42F08E595F0EC217372B98970CC6321576D92CE38F7C397A403BADA1548D205C343AC09DECA86325373C3B76D9F32028FEA8EB32515 +MD = 74D94C13AFEA4DDD07A637B68B6FE095017C092B3CDCCDC498E26035D86D921E + +Len = 1457 +Msg = F8E43655B94493FA926E048EFA326945C953FFEA2316BF10C90D8B89FCEDC9E65E9A9BCAA73B5EF6B2AADF520D92094C9FABB9D4BA8E9498A1D0F91AC13CCAE05DA45ECF860606392BF868A0DC145F85D3E763DE868A65A9725C12F594D4645DA14C8C74B34BEC7AC206CB2CA3279F6CD594691F434C25D365A3CAF900908A45F051032FACA859544555FD9D09BA5AF7FF07CC309926086F92F1808D711F7EED88068EBC5E1704A3C2601F6B30DA0FA73C39264EBB8A00 +MD = 251D7E2BDA9073BBD555985DF40D54BF6CBF21EF44313D1F6078CEAA9BDC0D46 + +Len = 1458 +Msg = 05CC9F30A93EF36488B4CE5EF2C7C3996CF902620215CF9F06D63F02F5B4B33A41E6AD8BA5F86A91CC811F6BD5BD8634A90103D1DDC83E3F7FBF3259C85CB1D2BFC5499345A0F5A5A40DD26D7D85EF30C49402995300C7E5794590707162AE45194A916D304BBBA40ED09F9FF063EB0C9925F1743F968BD78EBFAFCCB67AB4E379065DB6C6F4AA5E933A9905A2328C5762819EA56B496A1834F017C387D5CAA70631113F3308ACF1AD2CC01B302E0BCDE3635CB699FA00 +MD = 4AB987C0F66C58646935BF9CD4E01EF6DFF69D4FCE677D03368EFFB4F9CA9FC8 + +Len = 1459 +Msg = 918872C3409496104D1F1CC94F168356BFCDB801DF3CE29D512E0F1FE736192EAF690EAA9DCD9216497A29F8AAD1F662BB38BE9D2D94B0CC25978FA5C2FA1E6A3F8F594BD354AD4DA9011F35C2A9B47FCFE20A83F5DC7C9750FFB60D24C7013923B09E4D8C8F299280BEA11781E2E5971872926728C2FF2CC2DC946D342E0B9C8B79576CD8F75E3AFBBABA4C3B2CC2CB21671A24F2190650D2AC23EDA04061440A31AAA50122C745D0FF9A3971BB1B3C698147DE9981E0 +MD = 71E53318AB3A590B23D9863D3CC0ED41576F1095F249B777EB99B46EBDC505C8 + +Len = 1460 +Msg = 307310A8B3FC2728EEB4A10D9620098D24A8C5059A6EAA111E401689EBAA2B10DE5876F12042A1422EBC9B33F9C306C506F59FD76FF5BB194C278E41370226ACF7BFDBBC7E88C82D4D28AB26B669562F67EE3EE9A882B1CA390FEDDE8AC0B70EA2E29CCE4B9169A83835A72BDE1709BE8638BA00D05149977EABBCA5D0B70D0BC935F77F85458DE4CEA519A32E29EF01CCC760E7E549A347BC227C1B127E7D46F730C01394681D0E3B3300446EAB291207CAF424C679C0 +MD = D1699265551ACDD56EF9036E02FD795E2CAB9B3F2E8DBD89E0E7AE8C80441393 + +Len = 1461 +Msg = 29EE9AE317F88A0A03059E3AB719C6D6BD690C9F2A54751E329EB1ED700E5D2199F80D47E711F83A3FFF5D7E6FB1ECAC25E4E5BDD8CF81757F59AE3AAB01FBC3F8F4BC1EB9618601FD00E3BBB9AE6B7CE52AECD8C7D256CCD22FC7F097C70D637F39EB138AAAE3B826578273D47C12869413F9E3EFC920286CBC247D0395165BE7BA0AADFB40F431F0AE40122DAA6993F99E15FE3FA0B37D610CA794B60458205F85A1E8C5AC4B10B772A7E96256F87410C62E9CABFB20 +MD = 630B2698587C84D4B6177F42EEF3569DEC73487C503B929CB4608D956B70E1BB + +Len = 1462 +Msg = D1E9441652727BAC2E45E25C2BB6AED06FF14EE8C4968183EA986B05B096D4000AE3AF0AD3E565B82D973B574C30E5D58946E987244520EEF1E0D76841235C1C7DA7AB073B86D0F185505A4491C19A963ACC10B166EA9F7AA164EB40989674AA882E9AFC4F58344D7C60B4784B831DEDE1C484FE5644E98EC02D3772F762565AA95B52A75D4A890E5AEBB607956F379F20EDB1EFB87B21163BD14858F8025426A26630AB5C43550658F04DEFD54ECAED3513AC077CE9FC +MD = B69919307F4DBFFD1B0C5A1E883152C27BEC823F93A8FEC17CA76BF0DC1068D9 + +Len = 1463 +Msg = A12F4FD666CB7D9226CFAAE60161177991EB2319316E8BCEEAC1EE41E2F44D6077E5837748B1DFEB545650429C4C76883408152A239F494742BEF1EBEEDE1C79617712C8F01BB17ECE00EA31BB14747B657E6C1EEB69A1EF5415E3A0C96EA2A3772417A2ED061C47F358C0225463002F280AE990F0B01FFF211B0CDB479E20F90F88D5C67D2A5708D655F6F05046E92F8CA0BC440E1164520D9B57D0E0F4048E8D0DF854B410B4207571561CF1B3BDE8293C46F6FD19DC +MD = BD3C5B3C19237BB4D9FD277871CC7C4860ABF719EF06D536A47883D1FAEAF401 + +Len = 1464 +Msg = 3E15350D87D6EBB5C8AD99D42515CFE17980933C7A8F6B8BBBF0A63728CEFAAD2052623C0BD5931839112A48633FB3C2004E0749C87A41B26A8B48945539D1FF41A4B269462FD199BFECD45374756F55A9116E92093AC99451AEFB2AF9FD32D6D7F5FBC7F7A540D5097C096EBC3B3A721541DE073A1CC02F7FB0FB1B9327FB0B1218CA49C9487AB5396622A13AE546C97ABDEF6B56380DDA7012A8384091B6656D0AB272D363CEA78163FF765CDD13AB1738B940D16CAE +MD = CC11196C095BFFA090A05BA0BC255D38BDA7218D9311143F4F200B1852D1BB0D + +Len = 1465 +Msg = 55BC529569E0801CD498C8AF42B5461FBADD2C26EE7D32CBD5C682B62B41584B1E268A85E039693E4690815F116C315184450F0443F585EB53C4E101D02BA7DEE60C6FF63CE5F9FBC04FB8CC4564CE4BC2906B23917AB86DEC1E5BD443578E0DC7A3B4A0D06E0C6D3D869AC686EEB943232F44FB71206899A068F0D7503F052A765D509DF738B6C9EBA2F0A349FC7BA9BF6827AE8AD7959FA186054C31766DD4535873577F20EBCE2E6F1972357CEF9915320FBEAF253100 +MD = E27CD776614A96404CC66DD1DA4A9FB50C9721BF2DA8E72C1C800C954DFDB757 + +Len = 1466 +Msg = C29B2724C942166ACA51A1FD3DCC1BA857BAA82329022DD6B54AEF86AA4C60359B60B0C377C56A793807D645EDE0A20A8D0C1EF21B3BA7D4459609BE3DDF434F1ECE24ABA109F90E1CD2AEAFF4C924EE8252CE18E5B60CC598E8F6280B9681672FE0556D22FD2D7F264909F745545EA2D828512877C9B1BC12E0597DE7B10FE8A7C24841A09BEDFEFC7070FF1EFA61E7D602A7B6C1A3EED14B4D3CEE999CC484C455373412812D609183F8E2858A9FE56852111E17769B40 +MD = 098AB3FC463CA896515C6588FE2D877389D82ABE20F35EBCF41473A78E133347 + +Len = 1467 +Msg = BBFEC968BF89177A453BC37ABDD7049F5B9E3FE88E090708E6807D8502A61443F2AC1D28E2CA0BDF925D55E869CD89CB9A647C2B17D5F561B462E2014D78DDAD9DF49E9AB6F41C76C0FAAAF7D6E11EEFF841112305756437DE2661E73936F7F1B497BB99293F1E04A89B70D41A045D37127F95C358A66813F8E894544E8D287EA0AA576F0D036AB3849D34443D77EA4E4DB8879F41921A103FA1390C001E179CE81D3C08EA23C0F3D3DA4ED4827B018FF5A6EC816EF890A0 +MD = C818208E1237CBDEDFE24CA588B011045DB50C56629BB7D872AC5D8103AFC3B5 + +Len = 1468 +Msg = 4F1873004061A5730EB73DA54F66A5E2769165B2AA9834188C124CDCFCC76863F252484FB91EA88D83F01A617578C828A39EDD28FBF9B150BDFA10195F229B6AEEBC4044F8E020135448C0C9AC6F218FD775864DD0D5276EDD9A2312F427D3BA76E993DC660764D1675188BA27F16C858952307203C2627F81B8CF39C617E9A1CBA0517F4EAE73B26C8B5793AAC96D51FF8383D24222937DBFE4489FAF8E2A1E2F2511E58860320E0328CA6853C862D3B9FCA83A9BD50450 +MD = 7DFB092E2C14F321EFD63D619EDEF97A7D891DA40F74C26A21C9F4CCD4835A15 + +Len = 1469 +Msg = C15A364863123C42B27DC6B60BB754C1596396DA21BF66BB4E874C52619D122D065EAB67ED766710E17078E886BEDBF49DF81035EBF94DD8121962F221A2E68F9A6D0AB13B1CF2DA0919D9DEC33860D499F2DB1F3945972EE7634258B6921DA9C88FAE360E9907F7926942F3321B0A4E68893528149F5BB078F3A72D20896AA327D3BDD615D02337B1F1B60FC81B02BD68394D681B2EEED6E3F20E1E40C94BFDE855AD8B13536C4BC32364955BE2952EAB3A0C94A195BE80 +MD = 885C4D3E77208087CAC3FD8FB803A2D4134F7CA2AAFB88C9F5A685FC759D001D + +Len = 1470 +Msg = DA29CC2E02E9904345DEE5618997310DBDDA21DD65E28CFACAF637837B9466B9791059277C197A33CAAF2AF7B88FDC143F16DD9CF976B5FD6C0390B18F8AF6C7B93000DC2CCB061D7B63C60055B840EE0ED935D455ECF9586CEB935B041E2C58BAE410651F5DA2BFB3CC23CAA30AA9038563747CB9E05764277BDC9D50330BFB96255071FCB22209E033A269A9537C5529CE2A9F3D332CB903C715512E611E4E984191A7EC7BBD4A68143C8AD136E7ECD5719DF0383AC218 +MD = 5D3EA151B8E04DC28C3793BE34E914C5720D78EC0F4A8C9917C455C26FE13986 + +Len = 1471 +Msg = 94EA90EDA1D00D2F8299F99C7AB8F2C19D05452155A5117E07505A1EFEE1B1754B011174F1C41B72F0AC72AF62BA24172565B5AF8DBE62EFB6BAE9B746F3487A9F61557AADF0BE5A2C8F877A7D2E301FDF45DF9A50633F87C99C38102F4E011435F451278A17CED52764FF55BEAA3E7576457E81A685F1A03770CCDEE8C06C1158AFCCF0746D58DF1E85DB956B75DFD86B26CA9A936D0833BCC64356782F27D5E9F9C76898FAE7AE1AC44B07272AD64918BA3E5BCB272F02 +MD = AFB3A3A9C1D8F13E4BB1BE5248F46B49BC234919703D4410458F9329C897F955 + +Len = 1472 +Msg = C38D6B0B757CB552BE40940ECE0009EF3B0B59307C1451686F1A22702922800D58BCE7A636C1727EE547C01B214779E898FC0E560F8AE7F61BEF4D75EAA696B921FD6B735D171535E9EDD267C192B99880C87997711002009095D8A7A437E258104A41A505E5EF71E5613DDD2008195F0C574E6BA3FE40099CFA116E5F1A2FA8A6DA04BADCB4E2D5D0DE31FDC4800891C45781A0AAC7C907B56D631FCA5CE8B2CDE620D11D1777ED9FA603541DE794DDC5758FCD5FAD78C0 +MD = 8C085B54C213704374DDD920A45168608BE65DFD036A562659F47143604144C2 + +Len = 1473 +Msg = 44A75B4C7422D2FC2879347615AC5EF30D1A10D6EA091C9F93748CA7BC5D48D8961BD5DF974BC9850BCF8F529C86237E1E836271EC0A4D6DBD9DF26A016B22A12571476FA219A9952B3711D19DF31A840BD3381B51E94F3212385DFFBE48162AE4AA4D5EF8B555B83EA5B37FFCF30E1C7982156B4438FA12E4D55D5066EDA3073D630942AAA5415524B2891B17020E7C71BB70EB24405CEA0A091D42E6DDD5E2FD3C2401E21F4EFC0FDD58E9D592D8DDD72C475A5026C99C00 +MD = B6E7D65B3D913E75EDE69478073DF46A5C17FDFB6971B3225E892C9D2DB10D8E + +Len = 1474 +Msg = 09CFD94CC99BD82ED115021FB794B680352912BE0A8E28CE534E82D4AC283FD68585CE8BF121D1F1953F2FA98F38427525D186635CFB0AD88D5FE7FFCB4C469235139AC64DEE44C8B1361363F6FFBEEF11060FE26C516FDBC421752D0E4700F91237F38819AF9F4F35E519CF52FF4E7FEC87B9079B8ADD4B8F6C49828696122F279997631DB09047B88206E2DA672B1DEF24CC5C022D3845654A680273872D7E0E86685DC809B692335667E99D2D108AA9E0084BC9AE177780 +MD = 17870BA981F90F795E4CE8C2F442DF5632F0151D9223B71975CC68BFE3262C0A + +Len = 1475 +Msg = D445328CDC413E194E2674C4861E4B02834DC69113CEE287E147902A8182E845C722D0B48BB4CCF68D69380F93DF2D783CDF63D1935DC118E4B209A6B2082CF88F4CD4AD6502C0F1CE94348DEE1D382C920450FD1668A1C4087877CDE362F4F8AD35EC122F63B8C93BBB06CB8D11C4305D38E783F3F536C9ECEF1455C294FA8175C910EF540E64E85D4E84216BCFF45725AC1AF6BC30F3005BE37C359F7CC0296D508A64B7D91F94B874A24FF602AD7908199C3BF08851CC20 +MD = 2E408C64E8D9188A20496AB5F2C3D6FDDC962B5675E7E18FDA45574E7B6AE7DE + +Len = 1476 +Msg = AD7557DB28F9AC08D6F70EF4AF59606DE6431BF5CB1AEA43E34D3A6B2A33DE5B654A11D95CFA02E24E19E65BCC45BD78D0266F1AECE3E10B4E101BB4238847BD4F88D019DF1F03D089EF5E51797DA0F2A117977861BAE10AAC4977F4C0672057B535DEB34C6F99BDB94A7ABDB015CAFD017A27CB710C5CFC8EDCAE842930F10A35806F5E1A9D2398AB23DBECB14A50106720523A1BFE54E3D2188C672F177B993FE3574908789FDFCEC58CF811440E9060497C8281C5529340 +MD = 268CF616CD0578B737CEE4E21A2A8BA91D2F7E1AA62E4E4F253783FC3E7A3DE9 + +Len = 1477 +Msg = CFB596177B9CC328223225536EE388C73D740E80E777BFA3CB117F9044EC292EBF6BC61521C6A2E9D25A7737EA702AFFF5DC7A521EEDCBA633338FAF7E13F6B62A1957D8DF39748DD4A0CDFAFD9235294375C5041761C6C54714E23EC10249AEDEDF5FDD1D25ECCFE9C240C759E435F6C8662F5CC1DAA40DEF573ABDDEA0908A4D6B07CC148F4153E34D6D5965B24D3553EDFC34CAA0634A622B22CBAD494D5C2D0C908B17B5E7A3E785AF8F8B80808B1F0DF0EE838DEE3F00 +MD = 674B362447B5840ACD5309D6F94A51BCCA2BE620D5864169DD9130831A8ED3BF + +Len = 1478 +Msg = E93C98D933A5F2C8D34F02E9BDFA64694F79FF969897F7F71D776D16E518B4F91443D3799DD0C4BFC6582E080B6712BD93295922C6BDFA99BA209CE536489A25C4755264B053DB2A0948B98006648E00FEE6A3B1C644DDB775EB4B092838FFF335C92B7EEA8D51A44C563C969E9CC09042C6809AB5D09FA8208BA2BD78B7F6803DA6A92F145388CE4FDA96BFAE287121809BEBF7741EB0C7A27E7E7A445C4D448D8A98BBB6C1D31EB8183DD21078E6BF6DBC9653A2E2053890 +MD = D3E817B6E378C5C7E42C57A0BCEB6D11408D9D597B118C335E46E0C81316A415 + +Len = 1479 +Msg = 532FB4C8E6753AC952A1B707308830D930A10D7F4422F2FB54CD2FDE1B584BB75ABDD8017F2F2966633E4ED2BAB7DF21F7C6652645215B18DBCCCCC64B27139A68143CFF9930ABED16022164121F38D4D12E62308D898420BF00A59DC3A7F26F07C8AFEB4F8CEF3DB3C98B307787C495B60A83EBA8594658D6E5F4B13057523E38D177F20C715A7C0188C2B342CB26D7282C5FBB124C6CDD7A1122F63080B8FD2C671EE1E994A874D14C1B4325D06733E9FE962E06219DA988 +MD = 2B231211061EA1B1519D63443AC1AD29889CCDA6A637F2883E30AE3FD51CA1E8 + +Len = 1480 +Msg = 8D2DE3F0B37A6385C90739805B170057F091CD0C7A0BC951540F26A5A75B3E694631BB64C7635EED316F51318E9D8DE13C70A2ABA04A14836855F35E480528B776D0A1E8A23B547C8B8D6A0D09B241D3BE9377160CCA4E6793D00A515DC2992CB7FC741DACA171431DA99CCE6F7789F129E2AC5CF65B40D703035CD2185BB936C82002DAF8CBC27A7A9E554B06196630446A6F0A14BA155ED26D95BD627B7205C072D02B60DB0FD7E49EA058C2E0BA202DAFF0DE91E845CF79 +MD = D2E233264A3773495FFD12159EF7B631660C1B3E53A3DA0F24AE14466F167757 + +Len = 1481 +Msg = CAD77B5AF3CD58692829171435B8C7B878D31D7A7DC56B0B89F6D13C75385AE8B268E309717C289F988ED5EC216703148CBD202FCBF9A07CECE0E9E87C108761CAE85DF513F1BBE31C6E9A2A4E9282BDD037491B65F70AD1CE54FCFE4CCBAF3FF59CF815FCA87352B7BD1BF1A61C32524AA4E8A41BAFE3B5DE8BC3E82EB3DD989B8D4FA36B023FBCE4456E6D253C70018DA40033F61821DFC937B0D2132E78B235903617E6511E3CB2AE00848D3B0ADA5AB00D04CB8539853500 +MD = F75881DC5C34A0F759AF6D2C4878E24309969D062968DFEE9B32742969E439CB + +Len = 1482 +Msg = 9FA55EAC5F6D56ED388E535C9BB95EE7129168D77438427E4CE012EE9DCEF6C489F72D660C6766152A15EBE3CD9CB32D143CA8A44D925BC8763B16CC8820C2C4312E1F01F691B3BA08A4DD9DBAD5594887A9129025DA743FAEADED8C593889E6B12D9EAED305917155761A62B64B5FDC250EBF7E172FA047A18B5E2FA3F65900A2E8B487305E296DF23260A08056B8FC092C997A82C0A0CB647A25D4EEAE8AF4C5F301DC630D43D41331C3C722C60F904CE8F1E59B54B8D40A00 +MD = 93E193B7AC4065B95A4585D8C3499ED6AD66331B48E680616B71DA98BEF07407 + +Len = 1483 +Msg = E256110F06106A8DE854A108A4C6611E415D5E73948718DA023521B2E948CD898E6B2246D7905C6D183D8BFF98A43554F813E9D19E09757879ED5B29FAEFCAEDAF1FDC8CE2C4AEF6A5D26F35331C899895ACBCE4B234B222CD5E0E19CCF9FB4D75AC50153684C3F8647BD0067307A07ABCC75E8C15CF62B842378528EA95D34837A87F01ABDF385D507423BF9803179DAC1FB8278FD28CE90C7194296D0AD9432591C0C1AC2EDAD8DD5C07E395A05947B8235AC0434286ECD5E0 +MD = 6FD5BCD0A75517D7B52D042D32C66778AA935A0CE58108D63D2E35DFAD458780 + +Len = 1484 +Msg = 54BCB9646D0C68565627D302A0FE16B1729E78A0528F96BFE95C130797F1A619C779267A13883D0CDC992CB0444B0FF694787EEFB42978BC483027BF22AD8F43B41B522B74776109D40297F61D104E6DEEE4C189552A2228FF97679E0889D6A76425DDDD08911B8C14B63803B76358B7B2B9FBF121208127E4E5EE2CC9A3E71CF29E17C735C29557F09B168E1818DA2215C96F2D4E08A1B09F996974CB8D40488E0A02B9287F4526DFB13529EB38B80761BF918D489C763AEB40 +MD = 20ED68A1C04A5DE02CDF2FDBC11D4A6DDCB8B32A2EF4DE399597A1E4CFBD384B + +Len = 1485 +Msg = 4BD43ED651E7BCFCFDCBA394595BBE757608C73A69B10A94B40DFA689EBB4629613602651D716DD360A98F1C942EE12E73236B4689BBEA3F98DD276255803F9F9A054E855E4C16EA37577D84366E227E3C66FCC646B8851393895A8C18960B1C6A9B3001B30F172C3B13DCDFE89E71A7D785B2E9C3D49C82F2A87625B5BC544A7DF12406D65D627AE666AB4E6D7CD133A92DF5E1B2AA31E146D9B3300EEDCDE1817A77182FD9F71AC45CD42C70CA5D6739164AE6146AEA860578 +MD = 37230DC1E4A5E17270AAE02EA93946CFBEE4B02C9D46254309905AA142DA9263 + +Len = 1486 +Msg = 719D1B312C421896259055DA2BCFFEED2AA86B319FCBE4370B8AD722952CD203B4AF18396F45D934C6513FF21A90A44A0EA7C5B931989F0BBAD559334E020FE6925C76BE4F6339D6C8EF64A6E7E011FAA3CA768F40BF561EE58AD5B9EFBD75E6FB51EE8DEB820F61E398837723D34B49EE251023929CCA4FA70078738E2A49F15918FC0B680F9E2C9F91145C68D35064639FAE4417E422FAF9E723E8278FCD8530484B4A41A193BE9426DB16AB839EE616F80512E59BA55CA304 +MD = 224274868543B534ECD253D90A7807867C1D39077CB68C1643708382351998ED + +Len = 1487 +Msg = EA044B09C5EC1E6A714E329A63B70B1887A6085274EED2DCB8F4B56B2991D2768313A56F6733231804D3D283863A764843B59409A9BB53FAB192877190813F9DDB08A19ABC32DE2F1FA58FD38C002EA8BA8954182CFADB37E90170C2E0FE3CFDC614237A1E8F0D7C4679BB4BF794CBF3E22953A5EBF55C22C531A282CCDB0FE8B9ED6EF4D731B4B73495FE632C328B7682FFFEF79F5421D99D9E32947E290F24F76FB45D38BC2159F84FC2675D5F059B3A56B7F60B35FCE832E6 +MD = D749550E136DB4989C490DEEB107EC8EFC9341EE21A6B68A65F4425DD6FDB419 + +Len = 1488 +Msg = C464BBDAD275C50DCD983B65AD1019B9FF85A1E71C807F3204BB2C921DC31FBCD8C5FC45868AE9EF85B6C9B83BBA2A5A822201ED68586EC5EC27FB2857A5D1A2D09D09115F22DCC39FE61F5E1BA0FF6E8B4ACB4C6DA748BE7F3F0839739394FF7FA8E39F7F7E84A33C3866875C01BCB1263C9405D91908E9E0B50E7459FABB63D8C6BBB73D8E3483C099B55BC30FF092FF68B6ADEDFD477D63570C9F5515847F36E24BA0B705557130CEC57EBAD1D0B31A378E91894EE26E3A04 +MD = FFAC7CA5FA067419D1BDB00C0E49C6E1A748880923A23ED5DD67DDE63D777EDB + +Len = 1489 +Msg = A3B6E919C29F0779F010018E9673A03EB7B45D635CABE817ADDE1024A39F14406956BB363A3C9E5D05CCFE04C98E26547EB5D044221B4A2EC10035187D7E29FEC3FE04E540C53FF0A5AAD283FF6DFDE44A4D66152F3A57341DF67554E504D4575B151A1C1B03883828E22997055CEC567979BB54784C80D57C17AE590B171A4A8E9C539E9B35FBB99369E35889A78F93A47298054C29D16C627A61228C3D489355158E4B3F39F7F515F93481D339F72FC8B3A5F71CE123212F6800 +MD = A0A418B5EF7B9696F0F1D6416066889398C5BC2A454B793C51B573668C2E673B + +Len = 1490 +Msg = 4EE4B06A4E24251F70866E9677E9D53BC176ECB513506058D0A77799B0817F2DD51A1FB6C092579435AFDD86D996EDFBC9A503C32FEEC9307755C83F6A39D057DA88CF3EEC01EF6609CF60D2149D61633AAF027A4AEAE25BC64C469AB4EBA304B8347D088466AECCC5B3D18CD3E24D3C6C95BFE2711E61D17805A92D05BBF8639A0BA9ADBA6D5394A09924415BF28F778679F1BF578549CD71A0AF3E57DC74DEB58B65792D3117C0835A03F0AFD622D8649696B92A8D2D343E7300 +MD = 3B864B8A3FF6AE0E10BD18FF31BA93871514DF4AF87A8E1B42367F27B353E7EC + +Len = 1491 +Msg = EA20C22288323559BF6E70257E5A591DA6AE97FDA9BF2D2AC91DA8CFF506B2DE939F49DBBF7C8F31DA22A7F54DD2C5898256EA9D7B6A509FF3B9E593747C4765E5F228C8156062DF6A15135DBF582B0789AD1F12565552DA81825708D215B012C3CF333D3568A26D6F5DF383E8A47730CA657333BB65534EBE04E4A6253728D5C31DF432F55F71EE5525E430586153C5D8E99B4C9AFAF7B4199990226F47A1F68461FFCF3215CBDA693485F3C155C559B47FB86FB176106258FB40 +MD = 89BE9AD92EC6CC6BF879A4B36DC983EC2ABADE6317A303216B2308725AA40768 + +Len = 1492 +Msg = 441C41706EF18997EEF9B4990BC7B67273D9A90E99A64E161F0F79223A079EA8873500D722834DC7177A9063AFFC05E6B1C67B3AA10BB905E393E6C998DF7ED17EDF76096E4514D352EBB5E060911DA466D6BF26C9E540D10D5F0A0D5D7E0244B89CE207226112A782CC9D98B206EAEABF5C31A3F752C780A3FB57A46EE81E4F0F28A4D5A0ADB405FFD80B35CFA93EB2F6793EDA5BCF5F9E8D57362FF4C65ADA45064098F110EE799931B04C913A05E5C43BA6427FDF1502B546F0 +MD = 3AE44231DC9F22097BDCD3AF21D0C6DED3415CDF144CBA02457FD5813701AA79 + +Len = 1493 +Msg = D61ACEBBACCE0A1C2ECEBF549884696BF89A6FA017148D21ADE0BEAA038B417A0423B167D18286B3F5981F73E15760E7655C903EC27B41745EC22CB790681CE19857D34B249EE0FDE3C4F2211E6ABEC7CEB7FACDD8C23B1460E87EFBE81B4869851374DDDF3A79EC5A9020A185E6F87CC6F7BE11A6F8CBA0C4819F80E0875A9816116B9E77634CD06ED3CD88BC6B8846CC622B4769D20C9B19CE4C94B3CB2BF932864F9C472919280835692DE0DB831A0DF8A3884439ABCDD93AE0 +MD = 657BF90B9E692369400EC4B5A3B748AE554516169AB9C6DFF55BD10359BD31F5 + +Len = 1494 +Msg = B4A2C1ABB183856531A1D8D13D5419E2905427814E0D941428CCFD0805D96B9AAB2BAE33C09A5940823907A58B0672EBCA981E5302F8143D48F85C2988347750606E80AA2FC4AAF246D0066BFE85B1D43882AD048B373009E7B75DF4AF50C792FA3C22216112136C80FD303CE511E9A2D9B906CF0DD009171952BD062933F58A96150D3AC0551E77B69037A0DE0569C6181690FE780976758E10498DDD6A8AE269FF8BE65B6EC809C8F81DA31029798753F3BD53906B8B3441A448 +MD = 22F8321EF9BB4F164FD5C960B95C7F6F37DEA51B23861F7B3B7BC02232FACF28 + +Len = 1495 +Msg = EDB075B34AD833E5481CA7E60C44A435F960F741B380AAB44DC0E7D36DFF686967B6B2CA190E972B02B574BBEED5B4DB6649094BD1E858599276591B2F9D8B4F09872CB8E2689D3263D363C185FE353D34E2B4D74536DA74F9A1EEEB5BC820462DAA02E08DE18666EE45DF1E3027C324757090DB9A428FD9616B77C7469D7D342FB3831D3C2ACAB9BCD3C29631445085AEE08EE985EEBDED841FB16EF45484E6EF05735CE8DE6CA10D71DF778251F993C5B59FD56E40C2F99A77B0 +MD = 094E03BEA3451C2997972424A02B621866CC2EE33B898F27738F0E181AB1DE6A + +Len = 1496 +Msg = 8B8D68BB8A75732FE272815A68A1C9C5AA31B41DEDC8493E76525D1D013D33CEBD9E21A5BB95DB2616976A8C07FCF411F5F6BC6F7E0B57ACA78CC2790A6F9B898858AC9C79B165FF24E66677531E39F572BE5D81EB3264524181115F32780257BFB9AEEC6AF12AF28E587CAC068A1A2953B59AD680F4C245B2E3EC36F59940D37E1D3DB38E13EDB29B5C0F404F6FF87F80FC8BE7A225FF22FBB9C8B6B1D7330C57840D24BC75B06B80D30DAD6806544D510AF6C4785E823AC3E0B8 +MD = 5B2ECA0920D32B1964BBF5810A6E6E53675ED1B83897FD04600D72E097845859 + +Len = 1497 +Msg = 91D47B29F4A6397296F8FC30D7DEFEEFB9A0A29D56A31F0ED443996E66EA7B9CFC0122F8D942B8946F80C352C468DDD7F1FB261C3EEDB4274040BDFEBF60FE4F689FA7DE2D0B692F9E401BA17B810906535C4DAFDB004AD235798205BF9615E5B4FC385F6192BBDF4865C4E4B299B1494C27D98844F7179EB21A7CC464833BB5E6A0165DB54B9F9114EC8604F662B6B3E8A02E22AFBC170D66CD06A78C7831083119BCA3356079688837B1F2488A4E0A12D754166FBFB4FD81CB2F00 +MD = 4D84119C33336465A8D0E97131E5A85C70C3BEEB29DC7C46AE970E5593C392BF + +Len = 1498 +Msg = F5CC4F8FA3793571B809F6CE2A3D500B4B435116AA90E04FD2A1F591DC94EA41699033076B30FE816769F0B59F37E72D2E476DE192CAAC4110C2A46635A05BDD8516C53BE98B505182CD4A75E6263972A2AED090FBBEF69F929422EE15737C23DF60B26797937A257383699FD13F3A85B41429CBBE83B6E2AD4F5D7C5D935A956A73E17330D822F7C869E7FAA76E4E8870D9E0A3B219CF145BE394D339782A927386F1FA2B1CAE28337126927501A43F6947B6FB80364D0B823DC500 +MD = 8172E73C2696C88F07E9D0245610B3EF5965A434A58B68591CB5BC0D1FC70236 + +Len = 1499 +Msg = 5D712726889DF7831304D027671BEB451F1A32492A7170D7FEB2FA755AD8BB2E1CD6BBB5DB2BF4DE1588CC0225F674F10F8AB9846CE5370BFC99FAD1110D7CAA132B2FB08F371B4D067765ED91A8E23D385EB065D47530A394D588777B3CFC22D1BF8F68DB285B597FBA71D243A4C4AAC7B0D1376A468A364C16A25F1E4404620EB9E9D5357BBC30F529FD8F02EC09D959417E2D4B3E2980A20D8F633BE8B9F53FB8EB276DB34CC1BC10CAE1A6BE1ACCCD75F3775DB19EE52B361DC0 +MD = 2B6051BC5B6A8B61E4B8BECC23017D0FF276C018372DFDB96DC02A54A08D2FFE + +Len = 1500 +Msg = 1809F981B54AA5B37007A269F6CDE7144081B3E6538B3205B366DC7C85DEA9A1655B3CED86D8B9CBD892E3A06FE3A57736128D469FCDFE32FACF51517405FEDA833478A3114B365746762373B6DA9BEF0E8F08F0E8D7D4996B5AC19A48A61223ADA7F7D20BE3BBE9805784A47C04A8FAC94AC5552E75E3082CBB2757DDE0744FE97E08D403240896CE381B4E48AA5F45CF3F5B7F33D402DC6070CAF90D742799E861BB792C009C636D8D73EF0C1805EE47365EC0EFA6C2CD794CDB10 +MD = 6EF4BA5828D775479DE2E677E268CCF54E283543AD5F32F5C0E53F73A0885171 + +Len = 1501 +Msg = 06ED3B343E6D7B3E85BE6CCC154FE33CB8F515DFBE0D90F0E707E957B06F89C0CDE0D7E767ECA5DC6F39AAAE3A5330FAA2674A63E76125E66D21C82482E3F51A3E08F17B4F2887BED5810408CC243D52D535AEC4CB63E8FB655FE331582CFD29793C16A2E502A715BF6F71CBC3719FAF0D0A1C74B1D222028C524CF3125C5ACFADE467952CFFEFFDF7AE7A439320959148DD5F21E6549F602C7E329B9E59465D5E14987F7FF101F725FF7AB15AF9F73848B058C61275A3B1FB0AA630 +MD = 7A49B1D46F0909AC9D2A9DE4E23761B883FCABAB9A3EDA500A90C63F5E3E6782 + +Len = 1502 +Msg = DDF19649A6FFA95A56CB8458A9DCE9BA51EE5FD82120952C38D7E0244EEC4710F2D2D67DB61079E7658D2DC9A69B14427E1AB52EC3E973BCF6041778D95EA4B6A172E8E7ECE8F245827AAE4D057708913FA32ABB973AEE71EEA0F3F62CC8B4A21B924C20AEAA00359A48100F8DB8E8DB10ACF3270681150E326EFE99739332B4FA7568344D73A0943606E4A6FFE49BDC1788301FCA269987F7F3AB43530A0089D5FFF1CE8F3389F6E1889309ADEFECF15B05CA13295BB554E8D2ED14 +MD = 48996BB2E69376A40238BCB275B4F34F233F35B32FF770AC31482D74BEEA52A8 + +Len = 1503 +Msg = 4E72712C6C4A26956F86B9EA99A334147AFE15580CEB51171AD5F95E654AAFCCEDFFD10E214F5C71B7AAB2147C4A48404088C22EED0F4BF517D414CE1D2BB04825FEC5E692A72283DF63FC947323ABB95FBF2AF489BD1E8F769405BCDE2D48B892473D8527374AEC620E0E81AE5220C1BF8C4266C8C657A681F7CCFFDD16EE545E20532D93FF70D4F5A47A5A168911EC5455BC4E78706D6436AF51F6939AC8D8598C0C43FE8E11912DDF8B342DAED02777F2D858B967FB80854CB054 +MD = FCFD9AC24B1BD1B1EE35BA8C361F4971A559C2F2BE5BC1692DD8F47A8B4813F3 + +Len = 1504 +Msg = 6B018710446F368E7421F1BC0CCF562D9C1843846BC8D98D1C9BF7D9D6FCB48BFC3BF83B36D44C4FA93430AF75CD190BDE36A7F92F867F58A803900DF8018150384D85D82132F123006AC2AEBA58E02A037FE6AFBD65ECA7C44977DD3DC74F48B6E7A1BFD5CC4DCF24E4D52E92BD4455848E4928B0EAC8B7476FE3CC03E862AA4DFF4470DBFED6DE48E410F25096487ECFC32A27277F3F5023B2725ADE461B1355889554A8836C9CF53BD767F5737D55184EEA1AB3F53EDD0976C485 +MD = 68F41FDFC7217E89687ED118BC31AC6ED2D9D1E1A2F1B20A2D429729FA03517B + +Len = 1505 +Msg = 21C9F4F5D4B2F235C5DB749C3174A603E5BF933C0C383FC4FA5832F7C110080497D8A93D3707DDA98042343A2FC52BD4D546A8806241E7C59E98D7ECD2CD3CB4497514FE12ACC0F124024906755F1D76C187349BECCCCEFEC2AFA2C68C50886121087C7FDD4E0E5BFEAB080AC98525900EF581C58A9D71880967F147E6E1D8CB94B9B1CA93EFD3AFCA6A365E44A0D1AF1759A5FBE089A3EF75B0049C09CFBA8D535B629F8FB672BA08B67B3AC7F6045E3116C98DE660D146141608C800 +MD = 7028A2CCE94A46F93060D40BB8B373C9BD78B73C0A6F802B55E5629E4A94618D + +Len = 1506 +Msg = AD079FF788E9089DC1D3E82BAB818ED4CEB3B31F501A1A78E59EAFAA6C5898A42D4A766E775F364D9AF8E0E3378CA0C0B3E3CED670688D6271966F6EFF622A4E862C847A43E6A600F9EFA1EB9E6CC3EA624921185F6F8909E9D98C599ADB8EC63ECB752F5F86C4312E7A9F6679E6FE3F181B525F50A6313DB2DF33EAA70BBC0302EE9C7166DD84D2E91CD064F9CAC2D9102938E76D5D78130054D532078FD3BE22FAA84845CFCD91D919ECA680A67D1987E264EC091D81B3C5C66FC440 +MD = D1020E1FF78DD11A8D99C2EE1042373C7E8E703677FABFF29F78FF89ADFAB922 + +Len = 1507 +Msg = 8837670BAFF97C556C9C46B55ABA348121CDBCD53A976EFBE084A1F635E37AD9B7CD3F510093010B74F663564F221A80E2582413E0334338525857EC20584D289870E51BEA927EB26C17B2B0EAC46863C7992D73C8395FC914C91C73B9B3A170A599D4C04706E314F8866292C663A8BC130C41209A92A92D6E8957428F1B0A03A36ABDCC1FA2F3CDE567A6F92ADC03496A2464B4B9F9E1634712BA3C291C4A5979A97D105B65D94FCABA9F717DF9B93C799E9B8ABBD7054B8E8AA5B640 +MD = 1503B883CEAE4F6D3FC015692EC9E890F4E70F0EB9238BF8DA526C275725A1D7 + +Len = 1508 +Msg = 5B41626C5658D205AC9F26DA1670435AD18AC4AED629C65F5DE44CCF1654B871E20FE5F0601108B7D3E6E1E773209D6DA0CE4D20D3865D57F7FA08B36B4278DC0CD5548EB1C8FAF0D3D04373A3FA5887796C3D18846A2A190AE553DACBFD712987CB18350CD4397E89DD7D176279181B762B4666471DBBB53BF8B9E53D604054B65E6AAE00CB588424FD867F745AC82191274939FA4CEECB109F3279649B0A9AB74A5B3DEF529D3C3E98B65E0E32E3568AC227322B67DA6DB28BA57BE0 +MD = 441C6882D04914527DE431F8BFFDB7F1BDAD4F7BF62798750E66D5117B3DF694 + +Len = 1509 +Msg = 76C5DDB4AE2FB58B7851A9F87A8257CA9FA782F690D436EE0EA3AE1C649258FD7DFEFE8D638D1176869B02617FB10C679F37ECFBCD6D8FDFB46A30D068F371867B858BBE3CFAFFB030D30F92BCA496D702759908ACFE978A986B000BD0C2D91918CC1AF38BFE0EBD997017CF687F70D3ED17EF486BFF5449C8141FA64548A6C4F34E477B4FC0DC9CA09A6EB9EC0EF5EC119CF14B055240D9078BBBA339BB8713F0B4DB7B74CBE88EF81B8B2851E377C26672D36BB908B32D8DCFE33820 +MD = 42D85C245E0C6D4150BA329F8029F320BAE181E4E578FEBA1A475E5A3148B620 + +Len = 1510 +Msg = 3231AA77DAFBC66F776E85C3121AC5B75EAFFE1E75E684E9E128332D857B397983FFA193A1982C966BDA623F065D7FB79F78794B7C70975F04BAE50C1E843E00222527B996E9407961E4EC08DC83851D2C6E4EFDD5F1B408AF0D9EB361E1E7CDEC6F3CEF0DA71DC0F4B165253F9AF8974039D1AE2B2FFECBAC3F366FBF999574A16B85277E74384B587005211CA3ECBAF1D8A6E2B4525D85DBB6E025A5A6A274D4AB5728BB9F0B60FF9E97598A3A322303FD228B487DEE554489750604 +MD = E18640F91142C9933B2F1C52726A5882A897B4ED6E4FFC5298EDDC0379CBF2D6 + +Len = 1511 +Msg = D40502C71D588EC7373853BEBB5B6C453EC1A10C11C0CBAA921723C5C43CA3FCAD59FE103A439421E0E1EAA81B927F7F90E2D9881A3ECF12BB041CD74FA925AC0F41800CDA6732720A94E1F64716EBB3DA6341FD33932EEB3A2C78148A4A241E54F3CA789C9E9CB798CDD048255E1CBDFAF9BB497428BF33D589FE2404966EA6ED025CF9D83974F82B0A0424DB9BD2E819EDFEF2CB75973BF5B819F1ACE8E0AE28A7FC82BC18A43B92FE9F86D1F9F3E09E5876DD33EC416357B036DD8A +MD = 3BF09FA05BEF999810EB0D40B9309FBC665ECBC355E2FE5620C5B6C3F028CE92 + +Len = 1512 +Msg = C9534A24714BD4BE37C88A3DA1082EDA7CABD154C309D7BD670DCCD95AA535594463058A29F79031D6ECAA9F675D1211E9359BE82669A79C855EA8D89DD38C2C761DDD0EC0CE9E97597432E9A1BEAE062CDD71EDFDFD464119BE9E69D18A7A7FD7CE0E2106F0C8B0ABF4715E2CA48EF9F454DC203C96656653B727083513F8EFB86E49C513BB758B3B052FE21F1C05BB33C37129D6CC81F1AEF6ADC45B0E8827A830FE545CF57D0955802C117D23CCB55EA28F95C0D8C2F9C5A242B33F +MD = FA2F3DE31E9CF25AB9A978C82D605A43EE39B68AC8E30F49F9D209CB4E172AB4 + +Len = 1513 +Msg = 164EC736064045386559CA629C733C82B4869BD8890BFAFF495CDF01D15EB92ABAFB515BF16374B33541646D671508B2CE2E4E686A1880A7833277AA51A69D5530339FA446CC614A423669B03B2305869A15FF83CDE64752F0515EDF5A9E48F8D032D13A73B7CCA40E5B2629CFEA0517223F39992BD3EE66F993EB52BE8FC70CBA3C401ECC4E7246CAF7F352CD581E4DCBF0C1A57EE47BE34F2F8D6B005C5898A9F1D0716AD7C2BCB028D939BF1259CC71EF3C21513139301B5A2E996280 +MD = 1A3A1D7B6E75C3400EED98550F4A3D32375DDCCBF1FCD7A6B6620E719005D230 + +Len = 1514 +Msg = 93A3301751EBF08B69B4F632DAC659C973EA72B97AEA6745C3D256B4BEFE304391C4A8178B3E0D68AA32D935F10C455F2D2B419FD4041A0362E7F80E99C0F7EE35733AC1023664E80F97D3CC8A23226C1719D1CA3AA5D57FD37249340F280573D7D4F835CD2AE93429C26635322CC5B6127026CC7CCEDD13686D085292136ECEE97C4027A3625DA2B75B3970CADE67F5B804045C91F5C8C44004958EB6FEF772684B260164C15A55E98781898AA2453899E373EC0DBC940054D35A789400 +MD = A17426A2C2716C5F67B0E03586310DD92EDDE1E786ED1C6E1C48FA64004AF3DC + +Len = 1515 +Msg = 2F64B5FD5A770053A8DBF0244449755471C20AEF67A7B7F80119FBCE5F1C7684E491495D28A1C2BE005F7F973A851957BAC2E70B034E198B3E43D22B40ADA9925808BFCE4FFDB92C96D90A185209EB0C1073CE48282C7066CA26F06138E574CAD984C2F76AE1D17EB05E873F1FD5C767A4EB43C2ED184FF148D55A394F862F140431BD0D1D57190B5238C065270580066CEA65F6A13FF92AB663F7AF0EFA9102F008C1C017C9164D5EB01F345A45A1406885CC039D79421AADF30E038D80 +MD = 1AA4576B20439FB8E3D2F064E91D96113776F00D79027A2161797793C7994AAB + +Len = 1516 +Msg = C95EC3A4573DCDEB8ADD58F4529EEF16D9E31C2F9CE4DCA1781F22C9F9E74A47D3045526C7C053030079B462E6A38608697D6FCF7C0C2563C76449271F64B00025BE2DC445ED740C95D605CFB974769140477612080500A7FC64BDF267C8155AC9A068929485CFAF0A2C1EE2A8A005E993A4AD60C1FD2D6EB9AD6FB24945C807AA0A879B601AD735655121A119D87E14D0E3432EA6580137FACD27DB351ED3901F5C6330B7EE827BE2099904793FF3C6F3C88B2D684D10531432DCBBDFF0 +MD = DF653A7E5EBCFED10A12678DBF2FF011B7ABF54C5AECBF0307E62D9F71A13816 + +Len = 1517 +Msg = C1E2C87F7DA563CE3970CE5F1BB25EEE582DEEB4D95D5930064982B139CFBF0396DF7F4625B175AB5DB3170A42DCB97FF3588FFB9178A45D9B7B147B5361156393DE9581297BFC47A9EB4F4DED2C05119C97174FF0191C27C83546CA1F06DB74EF562A16D61330D2F3568A2F09659BE40D5CFFD1D8406711D90B51990AD575D1C34A8138A9ECD2F7468CD39DE4B9536ABC19CCA8EB729E5437DDEB86319B5A7412975DFF6EAD33ABD1F598061CAD24DC0810DFA064A3947A773A338C00E8 +MD = 826D2B2807F0957E07C98FF29DB17A8620A45072A5F4C6A829D2636A99C81345 + +Len = 1518 +Msg = 98F2A571C0545A06CA3830F8C73789AC2B5361BBB2B93AA1AC877781F827D3C207703FCE38031BC54189F87A43F10860D4B402DD65A4DF9B5AC88AF2B0B37F68BEA1086929E65DC2AFF2C2FD215D6C8374DE7A89C407F48C63B203896C353712BAD1AEC664BFD196F906952149E50600F831F05DF71301E0DEBE49591375956930D72D15550655E48A8080D651129C5D2FF92E80A3C13745E74397FCA228AF940A349B3E90F51CD58666F1BDA760B6A46F0558E140B6DFC4F5748C58BF4C +MD = 88CEA4DF2EF7429232AA9FF09F17081E8F263FD994FE102BEF45E60A7C0AD926 + +Len = 1519 +Msg = 0A1CB542A7A25319117119DCBFFE09F7DCBFAB7B689182255A9A962E8CAE47736835CF659D7514E0DE2C68D319BDC2A220159B1FB090925AAA1660E1867461AE0FA3CFAECEEF44344D60C6803498DB0250E193482ED57871FA5393604B77A5B5C9A9299152F889407A1FC6D7309888F23FCD9955A43E3469FAA8B13676687C46DDB31D3547708AA814735735D39BA14CEA70E893DBAD172A244E51B5499D7607DC7D724F74ADC906A8C3909F643CFF39E5C3A41F12EBD18DC52E9BD4DFC0 +MD = 81D3F99F822DAB970A02046FBF121275D35BF9918BF13BD8CF1E5077A1524C62 + +Len = 1520 +Msg = 07906C87297B867ABF4576E9F3CC7F82F22B154AFCBF293B9319F1B0584DA6A40C27B32E0B1B7F412C4F1B82480E70A9235B12EC27090A5A33175A2BB28D8ADC475CEFE33F7803F8CE27967217381F02E67A3B4F84A71F1C5228E0C2AD971373F6F672624FCEA8D1A9F85170FAD30FA0BBD25035C3B41A6175D467998BD1215F6F3866F53847F9CF68EF3E2FBB54BC994DE2302B829C5EEA68EC441FCBAFD7D16AE4FE9FFF98BF00E5BC2AD54DD91FF9FDA4DD77B6C754A91955D1FBAAD0 +MD = BA2AF506C10DA8D7751E67ED766CFCD47D048D6EF9277DBD2ABFE2FD5D787B79 + +Len = 1521 +Msg = 047A906EB123927C5EBCBAD31211D731EAEAACDDC7CAE1A13D4068154D317BB7C010D5FCD6C4D800F3809D5083F8625BFA9AAB71E1687689F43FAC8675F51400DE5489CDC525421C8230B732EE5EAAF76B11B9BE4CC49C815FFA8B658CF0F18388C9D24202EA611E086D31BE4D1311E372E0115CC5E4ADBBC6E0B2C371410DA89196D8E447DA34E6B3787DA9B4293666FA6585A76FC2B130561790DD10C478A7E071F8EBFB933664F54ED398ADCD1FA35FAD11866DBE05DD8CFEC00549D700 +MD = ECB24E86DD22A2B483A98087EB5B7EE04A26661C77141631DB29D4BC0D7617D5 + +Len = 1522 +Msg = 18059DD3D09C5F36814FE25AD96FC6B6BEEB0DB9ED79D6E8D1E252E2A43DDFDC9E156FD215BF8426F6C5EA127510BB99777349A0EB03B68D03CF8B9F10BBEDBA7482A86E1D8E054E60F9821083424000C215D13AFB47D3C33699F452AB7DA5E2C95685C7C87E4F465FE78A8E79C76ADDC3501C99C1734D09DA817EFCD4809CF57A105BC1253A6D2A4E23D2E431A426607CD1C61980CB26143F03EE50500503C63F0206BE5B238888A038B9EC34C24D5EB6E70DF31BED948F373B4F7E52B240 +MD = 2F3918DCEBAC552600BFE9F9031E26789F8E8FA505CE29021925E8D23073F0DD + +Len = 1523 +Msg = E31399BE5D40239F6B1925B165BB34573FD8FD179C082027792F94B67D2545630F0A680E85D2B835E31CAC2504ECDB49D191977D0E4AD69A76AFDE5FD7A4D70074E9B522008D3A5A1A6D60B722F84304395E2D7B7E29805FF653216833DF11C367448AE10E11D37091590D22EF1C97E16B3AC8CB900ADA0D357C9FA2944313D6B796E1C9995B07C03098E3777B7582A7091F0D03A611BC76622B8CBF80DC007574490DF0A5B93F25A1A6EA9CDD4515CD9CCCD46A56B116B7579E97F8F22180 +MD = 0CA0D877FFC81447951DDA26288A09B7F46522AB3DAD47AC0A2C7CEA10673E30 + +Len = 1524 +Msg = D66E3B30963A1D5F71160CEA74CC1E8C3CEFBA41D2CBF5D0E7DC3A97316E6B21A7D7C5ED1FC7FEFDB8B628BACCF0CED538FE6F6B18A8D1A9DE4D8E31448170F4CEA96CDC7A9F2FF0A18A4955C75C604DEB98AC158961D6891AD5FA867239781DA424CCC806E57AA77DB7BFC85AAA7EC720BCA36A6F0501E2D55D7BB16469C9E4018CA34317F5D1AD6DB2F0E410493BC8FBDF38C1B8ED1ADDB62C2F5B7592A8D8627CFE97F0FF180524845C8D6C5ACD823FA1D810FF8E228C531EE61BED5330 +MD = 283B35A21337502E8FC0846D9B10AB00FFD315042C3A92670FD29283807F8FA7 + +Len = 1525 +Msg = 9274C08E458E1AF850826A75FB9A25F7328C6F427EC1B9231947306D864A8759E7D743F85EF79160F6ADAAFD829640C2E6C88892A21F0E52FE1746C57CFBF740D5674AA41F59A0135E66151B1FD654977A32C5DC744AAB2EE36D60A140FECF6BB5BC8A5BA8CE7CDCFA218F285B93C89B07E0349B6157241F7061901DC426BE93956089B38093513C792CDF73034989F8129B3232B540D5F8C86417194AD4AC481FD5465B7777952A4D3A784B0C10AF4A75C6FC09AC20973780B30110E28B98 +MD = EF9A46534CC6E0DAE81C15BFDD10649DCE007F32C54EE4E3D96A36FF429E1B3F + +Len = 1526 +Msg = 688D106A612E437C87E453D503FF3341FD0AC63A6C0AE190E5B7CB426F671DC919DE4A8A9FA6DE17B8D489DB16ABAFAE781A83A349A570BE5D5493D2882AE4FC881CB10BC97898BB67DEEC91C1A15F85FADF051B256F0A3098F539C84D51E42049011EEEB9BCF709146E76F0F491E1AF48EFD41EFB19406DDF842D25EB8DDEA67AD1AFDEB758F6A604938EB746680C5123080D5FF2B3CD2663A7AD7A7DD76BCBA59739B36ACA628C5454EA76496DB11A1538E00E632FDD41F386EA85C524B0 +MD = DC73F6E7C1531A76FCCD81D12F0B0124E1AFB08D548A17C651292E42FC8DD4F9 + +Len = 1527 +Msg = 1D7E3221FD66FB9CDE83AAE60A4D78AB5A7A7CA08B829FFEC5D38D838F114B2115D29577C055188CF149F28C81F76D6800DE3A7E96BB808D13081914C9159441963F9833175B952E5B6BA09D62EF241AD19CA7942049E2575597B1A53365692BF46B211B6182D3C2321C15883A9D22FA8BFF917F26102F4E82331109B328DF7359836BFD008FE4F4AF0854EBB6BAE0561EC8BAEB054877F3BEDA6D8D402BA47270DBF6207A243F7ADFF17658E35D6F52186E4D79572B99D8812C67C41617C4 +MD = 892A5285363673DAC285A0F9E7636A9E12268B1FFF68A7463D4071459167A1DD + +Len = 1528 +Msg = 588E94B9054ABC2189DF69B8BA34341B77CDD528E7860E5DEFCAA79B0C9A452AD4B82AA306BE84536EB7CEDCBE058D7B84A6AEF826B028B8A0271B69AC3605A9635EA9F5EA0AA700F3EB7835BC54611B922964300C953EFE7491E3677C2CEBE0822E956CD16433B02C68C4A23252C3F9E151A416B4963257B783E038F6B4D5C9F110F871652C7A649A7BCEDCBCCC6F2D0725BB903CC196BA76C76AA9F10A190B1D1168993BAA9FFC96A1655216773458BEC72B0E39C9F2C121378FEAB4E76A +MD = 3CD33F8811AF12183C53E978528F53AE7D559432724029E55FCFA9B990B91713 + +Len = 1529 +Msg = 7C7710BB2B7F643FA7A2DB758E18152AA812CA88461EFCE1177656AACA4F236555CFC69040EDF76686F30B233462AB67614FAFA20028DC0A42E6F362C8A978F12560DA7A2E4ED5CA37CC7D79F7A5E8DE92A6B9BA7D1E4ECE52E22A56904E39DEF32F2D03B7688AE1C3E499FFE9929D9577020465847E5B70710E7426A4F2552511F9DA9F8B7D0F7BE1EF17102E4562531F8259C07B52270DA01179BB320F7ACF3F5A6E22764DAC232EDAC5600D1C70FEAE0B011EC28D9D0B66A6CB860A5E9180 +MD = 64F3ACA645D5452C662C7A5560F6FC32405A4C6D503EC390286EEE4E25E7E8E9 + +Len = 1530 +Msg = 3BE11DD7FF78BB7C917005B235AC496BCA96A4317FDE079F6D358D95BB0352E9E89C29AA781203E5FD63DD2F685810386950E5946C0B9F0EB88877AF5175EE884E76935F5301DF59C79A06C5BFC6620C4D6FCEC86FEF9E518AB4146EFFE8813759D6415505D84B0EC66D58860D4D415FA36A28753F7C61A5B7845623322BD7743E079C82E6B9206398D665AC18C50FB073BE119AD5532A7164FB8FF8064D0D1706A2FB430E37AB478E4032CE110AA96B7963B636043EBB873F21FB106C5CC400 +MD = 07DDC41A0D02CAF37765BA23EAE2FCCE8EFD65BD7476F9E2EE4BEF7888FA1CE4 + +Len = 1531 +Msg = 50E7C9F830EBB80B5AC8B0A5B110483A97D5C549D343AEFF2259BE20E036CC1D80268C085B9C25317101E24E165C577D04E07887AD17A58E799C4C6758D8FBA836B4AF48D2CF31305A11FB92CBA4B23C4060F4A11BC2A1B8151AD547C6E9009DC1D46A38C633D956EF5CD75E1D697BC6D1251FB33A591AC4B138AB72C4D5551FB2C73BB5D946E16D7A9FEB18AE38BC58B2DF4254E650B8EE4AAC94D9444DCE18C2CF4D38A80278BB2E7FF0E167F252C54CE34589D93887BCD6371C73B99E69C0 +MD = D3F8CF520D0931DA6F6D960C78234163CCCEEABD68479E681555CB6492601F7E + +Len = 1532 +Msg = 939685986E3BE870F1D7514A7AAAE50CD58EBAFF6EFB1FB64082D27AB939A40A568EAC0C1BBB33594E2471BB545FFB09A804176250C6E7DB8C11D0833EE70C09CFBB888116A7C8EB064BB52794425058AF707848DA63418A979231977D11FA509D7696C58FE3647029B7A85F9E6A682E195DE0D9F2AAD7E4F0DE6F22040B7A26720742AD89F34B09C8BFDA2072A0D43EA0AE4159B6178EF28A8A8FF9899679178B433BC78097924806B4DD854214D3EFA67F9C44DFAEFFD944E94E03C5728400 +MD = 8916790B645E686F472F69648772FA122DC8C2C7227A5D8189B9A7EE7CABB8AA + +Len = 1533 +Msg = 82EE3ADEAEDA69F4A21548A9CF4DBD79B6E6652782541C9B0F6F4C1589316E20E9EC5E6DA563449DA640E2656B5B790E1015BF59B647039625F3517EAE3D79279FBA90C40BE10C26D9D68C709893BA8EEE250C12E65391A66E452989E5CAB836B371975DD71821F23EBFC5367CE5FFC7B10FBD79A80B1865253810CAABB06DCAB11345FAD11F2A95590F4F35EB3D465BBECD174AAC660821DF9A71BDA01FA9C71D96E7AB191290A0A03EFA2EFEEB25C141F8CD8B4FAC6A075BCBB67E3B275C80 +MD = 03B687D9FB5ED35486AA3DFA639DF17CCD8199D8C17D8346C58F765530E5BC8A + +Len = 1534 +Msg = FFB1B0703490FEFC1C9FCB456E94CE7BA6366570A8B71D1B65B06468AC317461946ABC9B2330B959183BE534661975956C57DE13EAB4147E82C3CB72EF21524B35EF0254F934D966EE7A01861A3AFA9CA333251549859FCB105A36F16631E72DE0C9BB3D1051098F016E0864CEA78B4144DAC493C5088C2F212D29E115EBF3B6C7D382C25947950E9759BEF6407F8EF8F1F3BB9C65EA9111C3F4854732B8E8FD7F9C369D7DAAA5AA57B6061779ABE02C34419ED60159C8CCA33FE2831E5A3814 +MD = 69840F46D6C276D6F4277A32CDE54F63B9A40EE1C20EED678A15DFCED30A17D8 + +Len = 1535 +Msg = 2EDA3FAFE9381A10FFE89C83D818ED3E3F061F08A7928734842BB8B81D99019A342752418607DCE8E2EDEB229AE1D7E78111AF6B5C19FDF57BE5ED53F89BD7ADAD2265D25468529AA2A20C5FE4AF81ABF93FDDC23C37103F9795E13ABAAEB0B89AD0F7CBB5D65CE9D9C66CE49EC666920BED8A8E7CBE1343336BC82448594FA18502AA72B5FC509CC140F69453138BD07C00ED7B43992D04518416A863AB9793E527F31595E6E6E8A6D71582444006D2639A58181EA2B939B7AE1B2DDEACF3F0 +MD = D0738DF5F13F9CE11E0B7F7E6FD09DB91265D904B1BD30E4B39D261AABA12108 + +Len = 1536 +Msg = 08959A7E4BAAE874928813364071194E2939772F20DB7C3157078987C557C2A6D5ABE68D520EEF3DC491692E1E21BCD880ADEBF63BB4213B50897FA005256ED41B5690F78F52855C8D9168A4B666FCE2DA2B456D7A7E7C17AB5F2FB1EE90B79E698712E963715983FD07641AE4B4E9DC73203FAC1AE11FA1F8C7941FCC82EAB247ADDB56E2638447E9D609E610B60CE086656AAEBF1DA3C8A231D7D94E2FD0AFE46B391FF14A72EAEB3F44AD4DF85866DEF43D4781A0B3578BC996C87970B132 +MD = 3ECC9D27994022045CBEAB4FC041F12419CEC8060C8F6F9F0372884DF6074B5C + +Len = 1537 +Msg = 22BC0AE27FED148842D8DC7A4F75EDAFCEB1923BFFEC9837198C87BC5F982CEF077B6031316C06346D9A47240C5C3B719C8A13D178BB248724E79DDA498483EC4DF8114D007630A995F81CD17899B264E1B5878645842C1D918C4427E1F9216D79F1B9CB8C69393D0A4EBBE766F3ECE21AE05DF4F67F045C1CC10F713E4A035D2C4B427ADDE84327FE6B8DA75520692F094EBBAF83D4F2149B2E968FBAE7AAB189CC988B4EBC2E20259F5C24C985FD3DD451ED9F4ADC3532C792C3E404C75A3E00 +MD = 1089C8051AC3A5456CF84F9967BF88FEBEA7E143C47903F82C380FEFB1D8A28D + +Len = 1538 +Msg = 13486FC0E375B8F22813F4066F9DC1695F945173CFACF57B9FB00518869EEF6AB5F50AF27DA2B72AEEC03014CB5E43E5FFF3EB6F1C912DC35C790962B834A5FA85BC123E09EC6D366CDD283ECB250CA85FB27F298A4719FDED869CEEE330C699D0AEE9A5626D9F6CA7D7891081738A5A897A1D3017AEFF03C74EBA000C53BE5AB121598CAAD58DAC265EF1ED5D365B25D13675FFEEA3B329210D9E3275CA305911075B44EE1B5F18572CB7CD15709957DF8FDFB0A05CE60DDA4A99C1797A0CA340 +MD = 1DC6F21A9592DD5BAAF8E45186EEAA6A57AEE72F57BD2D60C3BACC093344CB90 + +Len = 1539 +Msg = 4063E5DC8320BED3AA4B6F13EF74C24E98E28BB686EC8190B5DEE2CECF117A905795710BB201CA7BCD6E5EEBDB83D462370AC4311389EFF237934CAA55777A29F6B3F1297D4BA0D41BB0A62BC2CF97A6575B2DE8E7E9CA0489D4B9603D883F3576161763C53E2043DB33C34F6C898C975F5684CCAE891C27A5C81A72BA06994B6036BBF3B8646235B317C5CE02BE028FCD26AD04456C89E23DF63304158AC1D6E3206B94A4DC0C5978F3143BB98F7E0466E4A826C40CFCB88B72D56F0968D4EEA0 +MD = 6D975A4F20C21CC3D9433CD5DCF13154754956C1E31FCDABD7D63436F430D469 + +Len = 1540 +Msg = 6A8DF103843D2D0485A3A89E41D83DD78A5310735F3788D4A69676CA4892190FC81B5F2B7AA11C68F00416383F13ECB8E299215C57A313A5EB4BF1A23B08C978C548151C515611A5CB0E75689A480A1119CEEF5EFD2043C1E7746A410396CA2873F6F0D949F35D6767E4986113061DCB15A5107B8E6D2AF4679DDE9E8EA8916076DD202D268C44114B26FA113E254A9512D73D6EEDF6A55BFFDF46BD330B354586191967C0B14FE5E3D29E8BB7B2602134E2EFCE6A1FB1797FC14D73A1AE5F8FB0 +MD = ADB1C85C0D8086627B439A0CD4570425E8C68EAA725D6B031B51A7D58B20635E + +Len = 1541 +Msg = 3CA201D57CA5785111782561451B1F8E3FBA9E6162D8DE78414F1F1C54C8E2A201958CA179D41EEECC204212BE77D90E73269AB485ED35CC96365887C076688E25E89F5854FCF9FDE708F6570BD8ECB12388D76354D6CE6944F2DB2B1499627FF5181119F60A0C864C3E3382CFA21901DA25B0E7DF7A1D944AD894E47CAC5895CDB75D547DE570396E6C1114B4B68702524D1CBC061D099B6926D9F2AAE4F8B54C5620319315381185795F3F0ADABFAFA6188C580A11527CAD352C20ABD9714280 +MD = 5C21B75085A686D69BE5F5F0FCB16A091B3151109B94EFF7B674C7E0318BA98B + +Len = 1542 +Msg = B20C646228BDA529104BE210123D5E51708EC173F76C372912124937BA09F9CEBCA094B382B78A567963BE62D958937BE084B82C10F31E03A5675529D8BE52E1EDAC3830C19F76AF099AD547EDBEA4698ED985A4F077C55CE029C512383C8CA6BC523A66DEA3ECFECC2F267F61C57D74ADEE7AC446903F7C90000BF0D2D84DCB240EAB650335979F93D67B5C206F1C8308EE90DDDBF8EFAA5EADA079379E3FAE3F414790F6F63A1AD54651164F6A9BBEA1606D84229AF9A9DB9826A51244FD804C +MD = 273B512FB8B36CB0AB58567A389AF391328849DB93CD142C3F34CE303F199290 + +Len = 1543 +Msg = 0F224183DD571D3B290DCD180DB3677C9A9B162D484C8244CF40D2DF67A249EC305B9094BC309FC182F3C12BDBE0562B8FC44EF0961A0FD03317BD2058D374D45BACD55303B1F8D5C59C7D5FE05479E5BC2CB2CDB5B447ADD45427932003BCE15F835AF3A9B94E1C4A7F492C0983D8D406C8428D67C023C6361578C9A6B5F0EAA9DAC2913D4CAD882C05C275B8A7EFC4BEF0C12E066AABEF350DDC8EE4451595379FBFE98C7D2EA9F6C770FDFFDE3852C818322927347B4CCA27EA059C8644D9A4 +MD = 59DFB1DAF2BE0521FD414955FF98FD321BE8AB8936F043236217E796D28BE1E4 + +Len = 1544 +Msg = CB2A234F45E2ECD5863895A451D389A369AAB99CFEF0D5C9FFCA1E6E63F763B5C14FB9B478313C8E8C0EFEB3AC9500CF5FD93791B789E67EAC12FD038E2547CC8E0FC9DB591F33A1E4907C64A922DDA23EC9827310B306098554A4A78F050262DB5B545B159E1FF1DCA6EB734B872343B842C57EAFCFDA8405EEDBB48EF32E99696D135979235C3A05364E371C2D76F1902F1D83146DF9495C0A6C57D7BF9EE77E80F9787AEE27BE1FE126CDC9EF893A4A7DCBBC367E40FE4E1EE90B42EA25AF01 +MD = 1501988A55372AC1B0B78849F3B7E107E0BF1F2CBAF670DE7F15ACBB1A00AD3D + +Len = 1545 +Msg = 094879F98FF555E949C7165606B1A9A17BF188B2CE0C904C89AE519373EF772AA8A08AC42FDFFD933F18EA8DFA598B5119D6F2FA75AA69B5E18951F4553448002BB547763E7699D458D04F893B065869ACD14F7C6A39CEEA6320A63158E7878B94AF3A3116A6150AA23B624395F1555BADCE532C69C256433BCDB2E74985E330CF408F00DE21F0A191C83E91FDE112598AE5B49916462A6636BEECC0372E7AAA0F70E8298EFFFD9E4FA943D2AB32B1936423AC4295BF143EDB174F5F1E40F52E6400 +MD = E8FA5111C2C887618F6D45C8283639D60F245B1A58570A437A039DA01E2DC21E + +Len = 1546 +Msg = F535558E373874104E154A503F82CBCAADD4617A38E9670CB3C012869DF16AF75DB0E9AC8866A48576A3EB212533E1064A60AC17AF43BF47A7D2464D93BF2261D0DA09A9F97D4FB5881CAE75B065E9F76967EB9E39A4770889423649B70CD15F1E091A8950C51F3AA29F66E99BC8C084627625899FAE82846CEF1979A94E29D9AA90C0C5E32A30BE520E7E7BB5EF0E9CB8CC5D2E9E7F41C37EBA0017C427417543744915A77B72DDC3161929ADBA0B992E9EC3B8626348DC889383D38060A8589DC0 +MD = 648747039FE92CDCAC3A865EE23CF9085B82C17BCC3AC1E8A925858F99B1DB97 + +Len = 1547 +Msg = 4AFB68BB38DAF4C64A43D0892DE39CF0EE0B24499F434BE306967C933CECB3412F0DAA124E67FF1A58BB26C9FC9F91B6401317B84E0047D4B6E57D2F3D9C88459D1603B2748983A8C3B4CFE6E81EB9DBC299BA3927A3E1F76A5F54812EB9037189EAE3B19417B8F48CEB2C025F122DB62036FA4290B38DDB90A9687008A1B7D67DF503371785D1C7519FBE21B5B09C448FA69EE914355C95230D446CDBAA90DBDF354AF8C86E01DA389F02296A6B86153A078467B85885D276AD00216FF797B68C40 +MD = 3166E37AA88120117A00DC72828895E3A05EF36F86A0D10DB7F0626340D1DD53 + +Len = 1548 +Msg = F0F4921AF9447384288AAAE217F8C827444426E8F5D06C61F7E6F02ECA806556C4A0AE6268E6A9C2AEC1A3081503BADAA999036760C234A66B6879ACDD9F59FE28EF3026310C1291007F0FB092D26F7E4B7B60C448E455A114D248CCDCF7CD295E3DA226E2FFE2C4F17E5B1EA6328A2A32DFE7D50083AA7516D90336179D3D6E10E77C131562834330233EA33E4B96C81570956BEE98946B2D2644FCAAF829A7299438DD80E22E81F944D0B295ACEB19608FEF6ABDB52A34C2422E18ECE9D8FA9A70 +MD = A62E3E63C74E7140BF0D7D5207AFB3AA1269C74F8A70526798DBA39999990FCC + +Len = 1549 +Msg = 1E9E4FD505A9A5C29F41B86F0B4EF8F615209F7D231E08DE0636F4F1B01FA7DB51F1869C05591D5F0E5D758A1EFCFB32F4257805823E67C4D1F4C6A70D4AFB70C1C99E8E144922985400F778D676173278DE0B7540B667005B604EE77064C80F0B9A7BCD2317DEE692E2A7DB69BC4A1816675ABF2815AB732E187CF76BD7DC9D46B7258A6F6207C66F97E26CF154A700216A0BA6BF410AF4189633771F25EB8C38ACAFAF9B52AF64E29ADFC91EC48416BD51CB90FE6747F9706CC1FF347AA8969CA8 +MD = A9FAFF3D30B0682E3FFB504CDA03E45B947CF267AF8D85928746438DA6535363 + +Len = 1550 +Msg = 1140A34A3BFBF1949E57F8209A253EB83F61FFBD9C0565433BE3ED949DE5E4C3197D6DBA2BAAB08A8E30FEECB6A48DDC96D5FC223A9E2A558C981018FE9EA08CE870ED81DD7D59AF73D4D5BA16B060CC82788558DE63FEB733241451527ECE313EFA7F05ADD1F3BD710069E0929B1ED4C01307C89655E07B0F89EAE1F701E9926FE6A1FF414E10FAB2FD0212C33F648BB3A3C9DA3AC60AB93A37F18C4B59888811B82349008A277415720D72EBD37C2A45B66094128F10D066D358E7EBC6E226B0A8 +MD = 05EA8AF1D0C4E6E5B9911CF0646DEE4CD828DB127078AE7AB7AD249A23F84CB3 + +Len = 1551 +Msg = 7A1BCC212431E90B8FD721E8D2CDF5B07EF8F8CB4B57DEBAF2A5032487B46F20F99C2951C769BC728C053B532F29420692220C958BB6783BDD83D36AE85761EC47C546B742EA51A041CBD7A8F57BEA69DF6DF348AB4272D7300AD9F263C7F8F7E631874B4CC40CA3FEEFA74D9F5AD720E6913F7A79BD94EBDA147C4830AB443C08D5986E045573DE8E65AEFC979FD84B25FA1C6F638AB86570CC5443DEB36D05A8B05A28D8A7F95B6510E956F2BFB9FB90A30BCD8C9725D1CF35CDA63DFB1E51AA46 +MD = 13BB6EC58B7020B65ABEF338C2ACD2D2A3ECFED8F3EB780A601F47AB10E120B0 + +Len = 1552 +Msg = D16BEADF02AB1D4DC6F88B8C4554C51E866DF830B89C06E786A5F8757E8909310AF51C840EFE8D20B35331F4355D80F73295974653DDD620CDDE4730FB6C8D0D2DCB2B45D92D4FBDB567C0A3E86BD1A8A795AF26FBF29FC6C65941CDDB090FF7CD230AC5268AB4606FCCBA9EDED0A2B5D014EE0C34F0B2881AC036E24E151BE89EEB6CD9A7A790AFCCFF234D7CB11B99EBF58CD0C589F20BDAC4F9F0E28F75E3E04E5B3DEBCE607A496D848D67FA7B49132C71B878FD5557E082A18ECA1FBDA94D4B +MD = 5C4E860A0175C92C1E6AF2CBB3084162403CED073FAAC901D0D358B6BF5EEFA9 + +Len = 1553 +Msg = A49A1590851397A7413ED265B02F89516A78D73558C36139B23BE5864E2C42170C24F08E3058C07CF8F07A41C1C161870D32AAAF5B11D08FA5682727B85B8D6AFE70000C95463DAD5E87FAE024881569BE2A543677F0BF62955E4836A2254D0047687AABD8D41E3842F37D5CADC4935E7C9526509FBF6DD4F4E69CBDDD2CC4439A0B0F772AC4EA3E14D560A85EA98B5929C54B33C0243F911AF5CE4A87A145763EF85A72B94BE5222459F49D330D1A58281383ADED89ABB3CE78A471364C2F9895E800 +MD = 0FC6FA835A58C63BDCB38386F3EA11E0A85072C92FE182DDF45E9D7482E37B60 + +Len = 1554 +Msg = 037810EE77BCB2D3B7438AD56F145E4E936C170B5056FE2074D1D274C432856BDDE9568DFD9DE410207043632DC20D634159022A300D6CD82A6EFA4C0D7AB7E899D0979E5A445076FE31C898EC1F0F2A7A171417DCBD88F581C7ED7F61234C05A61CBBC7FB8B2EE4D656096042FC54F6A8DE6E472CE691165B9F3CA143E5021B606B9C1780F84FDE02255F75A9082A5685744C2059561444EED3271F6E6B287C36B729597A6755E257FC41FDD23AC9004C72B878B3199AC5EE1FEB36F94BFC0DF6A840 +MD = E933C7F21152C3E6DE5597E2E38B5D5D7A8826D837A2389DDC97E8FFAE92D00D + +Len = 1555 +Msg = 71F4A1CDC25DA28537CF2C3DE9730490516C3989543132786A77CF8D6CC2668D0DDF4D78A057B4AC0CA61324A18172010D6659AE7FD66EDCA465B920390ACFC93AF248BCF8841452CF749256A709DDB58AE3A7F7410247C9746B31518AAF8FC960697379AA66CD7F777666CCE898C8A22FB5C34933960B98E1B599F4795A7C60706147A7C08DF34004449B94BEBE5AB258DF9E1D0FB1D5A9FBC22042D9316D3245BD80EF488084C00EDC7CFD47A445BA99479F7D904ACD1031A0186D70C0B0C2B93980 +MD = 22A3BEC36BE28010CCE93F8BC6758D51218E8A5E8068030A1093874CAFD4EC86 + +Len = 1556 +Msg = A74842C1312297AF8D3C14B1717A71D2125AE4B27CB1F75FAE2BCE476BFB2038A514AC60F4484894885FBE3F28E9DA5C5BD9288D1F912B46EFD2FB928FFF70A6B3844E2953400303D5E270286D8ACDAEEDED6EF00DBE865DE3F6D5E54DC76B93C3412B999F39EA46E2B1A9969F1B09C8ED8E0DFD4F4E882BB29A0C1F2660EC4EDED872A7108A4FAC824623567B15D2B2EDAADCD5D7A8756405870CFE1C15F0C763CE4AB525A32207CAFFFE093BFBE7696D8A14571AFAA2F08FDCF55560ADA17A52BC00 +MD = 958C00AFF6DA289C1226190B1C31E9091D49255BBEAD4FC5F2E5608DF650FD91 + +Len = 1557 +Msg = 0E9FA73B82BDE1AD7B2D37BD10CBFD89AAC53EEA32EB3C2DAE512B23756B9A696B19770A02B0BA0AEFB5142C8FC7314B16D8894D0426C7C0ADDD875170C0B709BFE52998656E22DDF7FFB697D457A1C07A290BA236C9F90B2D03BEB8FFBB23D750601BAE49A732ADC3C3CEE3029370E0B26FBD4317A2F23721B20CB760BF7D4DF04C30ED3A11213AE500F9085A7EC53095A99022D75E989F1C983D52F40112229D9BBA5D342D2638FC7535D8F540168293106E1B280CC4491E4AE551041EAADBE20878 +MD = 35A4AB18E068BEE6A9095A2A3AB61660B04CEC5977F1B9EA154A241C487F1AAA + +Len = 1558 +Msg = 7F725C787CF708E35CFD6DFE7F66D223C1048FEED331B3526C6360F846C0FAF23158CE2EBF2621140C5B4FE92AF12EA8448DF6821208D2C9A256D357E43566B5BDCA2F33CA9027063F557975B766F0ED1BE8626A17F28A94F41D4E6C51F0B8885C505D75506C6730CEEAEC765C4B0783A22782209740745DBB8172E89E92A29E136298240E7907BA38C893E21F23ABB2ED2D43A56AB9747555C9532AB47BFF6A56653B9097C05DAA6EDE9E262622987715BADF5BC25E9FBFE6E12B74F789367BFF8BF8 +MD = F6084171094EC576A2CA795C411EA33B6EC03B165A011AC5196DD0E42DE54D7F + +Len = 1559 +Msg = 185219625F19DC9F8E12AC7256DAEE6EEBA17AD72FF821E180A602098C22372C5E18D969B9059A882A22E10CE2512BF7A8C012E43A8BA8B61381C22BD1C5C4276722AAF3CC66C95F0450783D9150854CE0C21DC9F92D3C64AE6D1F379FEE822E886949040813534ABF765756B20B8586A2B73EA55A170B135A20BC3AFDD1D64E8D667CB5BDC815674F3BED646F890CBADCE08B475CD01CA656F8A6F87890271BB0AF3D98B51F3E98C91B641FE67E8F13AB1715768CCF01F34A61E4B61C9D559D0F1290 +MD = 7CCE291E01763B4D5B203A0136C55BB94045D8CB30904F7C4E26974E28D6AAB9 + +Len = 1560 +Msg = 8F65F6BC59A85705016E2BAE7FE57980DE3127E5AB275F573D334F73F8603106EC3553016608EF2DD6E69B24BE0B7113BF6A760BA6E9CE1C48F9E186012CF96A1D4849D75DF5BB8315387FD78E9E153E76F8BA7EC6C8849810F59FB4BB9B004318210B37F1299526866F44059E017E22E96CBE418699D014C6EA01C9F0038B10299884DBEC3199BB05ADC94E955A1533219C1115FED0E5F21228B071F40DD57C4240D98D37B73E412FE0FA4703120D7C0C67972ED233E5DEB300A22605472FA3A3BA86 +MD = 272B4F689263057FBF7605AAA67AF012D742267164C4FAB68035D99C5829B4F0 + +Len = 1561 +Msg = F7F5B2062D7FE77A5C1CA6173B2C72268E83D68BAF6AA3F4692EB7587930F0338FE2A400369E6E414AED899068ED7AF8BF755A1E720F3176DAAE62E65BC8D91CBB1BA7409B4373B245D3655408D22B402FED1480A92D4EF3BAE5E6450E2D7846650C684E1B174FAB86F05A228969CBB3F7D11977A2E1F6EADFBC6A0531EADAD2970D62B63E69392BD0A55FC315F92BFC9C383579D390FC447780E429E5D28DB5116D9E7129FA5D61920D680C743986D7B4E21A9C54FA272066978D740BF35C572F418C80 +MD = 7A40E260C2DF2DB33344CD2D1D9981036986CB82BF155753AB94039E7E1593FC + +Len = 1562 +Msg = 89CC05BE42885C72B4A3E790F3E8E0401707A5B9EDC34893C4DFC8D9227F9B98480AFDFCB8521A1B2B7D19F9BD77712D3D7538EB74F9BA09A1910BB065A6A809CFA777C25DB447B6047CDE44FF96C1ED5D93784A2F4D261EE4DF2B083EA5EC3FC070832648A43A8836616AEC89909E89CB1BF034BE1C69E25E48369FC2EFC345F9A4AB91FA20EF0C96F81EE00F597A9B13E5FC1816F5025802A30F79055FC607B0E0F114DE264FA2E3F2EF9B488615BDDCF810F8944162C682BAF41642A6374D773FEC40 +MD = 43FE0943434D08B712B9CB060CA08620289A2F9F8152CA985769CAD42C7F71BE + +Len = 1563 +Msg = 4F6927F8DE4BA416E9C4E063B80599F4DFF974600CC6EBEBA4709EC0945395EF99BD5B7D77471EF6C04F17F9AB7E1B91622A35E47148B7533331E9986220B9E4D08F254BE34D61A0074DDA157D3DDAC8F2DB4711BF5730F65097A0629B741353CD263FE173BF72D76A6849330604349E775626F49943AD74F583C060431AE9204060EAD1BAC426851D894AD41E52CBF0BD48E734C52547A618B10F6415E92C200795635A61C47AEDE65864AA48F17E3A7729D5AD883C2A6A924EA54266A384F6F92EACC0 +MD = 3431506ADE0E16CD754922E2305C7889B4C9DBC7F35B87B723A0189B1C0C536B + +Len = 1564 +Msg = 7A76F5CD6C47FBDF0B300E156ECF26155B385F4185B844DC560F413F2C2437D3F653D9E84070AD44B173BD568D0A41ABC009532C0B0EE41A7A35D45508E7CB582F761D2158297C15A8BEE1857515621B5446696FBBB7EECE96B3BE7F3B7F3B2E46A9A8328D0DC4C61AA56AB3B417A31B6D1D6A25BE3CDF31EC6B0084E90D2BE1CB2397B66E6E93E2EE0D5532CD1E4DE1C9A1EFF1CB5E6D4E037097931511716A25BF2AD382B16EF07DF13CB9A800CE8D7F1A0F664108147DB5729E64FBF6B55AD741E8D0 +MD = 21054EE3AF20A37D0E9CF2973C2175BAC445A887D64E1E2CC2214A85F1DEEC17 + +Len = 1565 +Msg = C3D691B57082AF833B84CB2956E41FA99D40314FC4D7655BA3C10851812161EAE38650CE8C37CCB8306B91C2F5B650C33E0B826E8EA97180FE7E5D8A2FD7C0F3264DB8465D68533CD7289A1C0682D30AF11A04C92A82FCCD569B5D432E83E57268C4A219C176285B25886DD032BDA105FBED64F6EB233F1EAF2CAC49CE7A3A7F72F0B07310677D680A3800DF2A164107A7581FDB77E24201BF84F0D6FC44FE7711CA9AB59308A8FD72DD2C551EC10D43FE42EA44EF96B5004352071FC212FFDD05F6C3D8 +MD = 6C7460493D1148489F01E1D2AD751782C434CA5515D5781BD0D3AA7C36591712 + +Len = 1566 +Msg = F0E6E8CD841FF441FDCD2CB144A2DB21C2D41E7700634B3F8A93A02E979349CB1A6873B78965F5880B8782432D22E856EA2C78ECCF2BEEB4B02E43A3574139364200357144601774DEEF24BFFA5357D5336AF4A61F8B7144D9834576796C9B95697783861A51B35B79FE28EA9F04082A64A563EE52882D3811652FE95FCDA0AB4095BEA34BA55A05DF43AC7BC925D080F890E9C8E7C37CFEFAE2E075DFA5B14566D7452117C64E3CBFF151694B29A7C599339E119F6C48ABF398B3CAA65E21A2EA19BD58 +MD = 7FFE2289787E9EDDA98E43444A2D94FFE1B21E68BF754D5179569143E796E5CF + +Len = 1567 +Msg = 2FA46DA3D6241ADC5773DE113EEDE19EC18F8E3F531EC13C59B1CF91E73FE39AE132390692669BC5BE14DAD8C88749D97B4122FC691990D353B0EE4A55A0BFC4462B9F7D876FB4A39197E887017835E54A26A4C98EF91F154185D47DB1A681F6F0183C8BE8756D10F511059619E8634C38B55955049B4E0BBC214517448D6BC33E2DC8FE8D3D286E1631E4580F07C2EEF5317642FDE6AA5A2BE4C55D25585FB9B303C24DAEE4EE0E623C0A4B621AF20314D74434264B7C6EDACA3358257EC39262BBB55E +MD = 396585EFEC6F5D65C4E65E70DF0FAA3ECC95ED3685102D0D7110131EBA4005A0 + +Len = 1568 +Msg = 84891E52E0D451813210C3FD635B39A03A6B7A7317B221A7ABC270DFA946C42669AACBBBDF801E1584F330E28C729847EA14152BD637B3D0F2B38B4BD5BF9C791C58806281103A3EABBAEDE5E711E539E6A8B2CF297CF351C078B4FA8F7F35CF61BEBF8814BF248A01D41E86C5715EA40C63F7375379A7EB1D78F27622FB468AB784AAABA4E534A6DFD1DF6FA15511341E725ED2E87F98737CCB7B6A6DFAE416477472B046BF1811187D151BFA9F7B2BF9ACDB23A3BE507CDF14CFDF517D2CB5FB9E4AB6 +MD = 9B28E42B67EF32EC80DA10A07B004E1D71C6DCE71D8013FFA0305D0D0CE0469D + +Len = 1569 +Msg = 1924D11C865F5258A151DC2CEEF6FFEBE86E13120A3DCD3ED6A1B790D1C653C8DD1AA2933EEE9BC3C7EB4BD42855E7C5E4CF073C09B179F2FE7DFE4F990B62ADF093739DC25607265D00DCEE57291047BD2B23000A843842566B4D28C5F022885BDC76FE0C3CB0368CB2DDA3A9D327E8D0BCB003668C53BFE1FA294496C5128B7C3B41EBEA639D070C11E4B2997E886C8693B6D1E17D7B5A63F752A74D2AAC2D8BD25D177B5E4A532B3069A6B71EA3ACED5B6D5EDF0DC723DB2E336CC8F5D4690D1477F580 +MD = 8C9699443FCC88689EED869757625D71533907907E85432881A962333E420332 + +Len = 1570 +Msg = E7935FC6CFA5B3087D0FBE6242ED76FFD17FCB91CB388CDA8507B6489032D6B8772BCD0FDF8AB47A353C3F5B42A09E1B8A81DA59295B48AC250506D3742CFB4F758069A89017AEF3B6CCC9FF79C4322971788CA874D0664CD5F5900C8A57B4551107F58674EB19081DF0175241850BDE8B1D28D3345FFC0B53146A6EC728F72A866162AB9A942B0DE6EDE0D35E56D1102B71C9E6DA261480AFE9AA032C910B7E9E5372510603CF888BADBF5E9E469F6A59049FFC8F05FA58CC4ADAF10FF6629286F0F85EC0 +MD = 73E1A081B8703CAB9A036BEACA54E8B84C829FFFA54B548A9D210197D885BCA4 + +Len = 1571 +Msg = 14C24ED71ABA68FADFA20979A31A6F0E64C839AEE476B018FEE6F1E6C0829FBB764197BF0357A2C03EAB0E61E793F7185BD3F1863E8E5A3970A1E0AEE86D401D7FB079888E5CD442F56780FB05384DE328D00834C504751A28D0E1D028AD1455277BC662A3DFABF903DB129342659949F8363AA94E9ABADAA6C33956B410D4B914713A2DD59AAD28B66791A2942B3FEE58F011F8E8CB693D9D52481623F11E300BB51E808BC3AA346905EEDA2EB59CB469EB99A0B1F2D7DA56CE6167D5005DCB18DBE728E0 +MD = F98961A4CEBA4E38091ECA7BB33EF8E54DE9F0775F56E112A2C70A3728378584 + +Len = 1572 +Msg = 94A31FF206DBE122709C56660F5FA690FE65273F918B44118D647BA94E81C8FD837AB68EF7A67CC9C3FDAE7F29883B31E786D0B4E90148CB146D11A68828BD4D3E16FFF6FC010E93F5FE04453C23DC6B4A995B1DB5D430E383B78F8D90D7754434F54E56808A7BE3EDF21DFDF2D824B94D7CDDDF652D1655A7E1806C436AB5BE6BCB673CEDF407AAF4CBA98A9335339B6F86BC11A08A08738827B29058DD6BE75A83D11D6E70285E062E7AA1E03D79098997C13E6CC45235EA37FE02BD0EF47F9E4C5028D0 +MD = 090FA3890381E7D413DEB23360475988B0B93CF4BFDF6151D9EA0A741D963355 + +Len = 1573 +Msg = AD30B3BE44B88B1011FA94DAF026E1F9B7CF834B972463E8BB77BE43F068127AE9BE0DB3D2B5B20118C50053239870571D9971721BB4AEB5F716FDE77ED2932E4AFBAC5C4E177CE68A0B849E91373CD2202A22085A775F09765AF9CDE7B359B8CAF4ED89B0AD46C856A40AC477641A2E793FBA446A2973F70C978F8C9116F9932BB39AA530DB1B4AF2E0EA9EB8AFF1225C275EC204A5FB091784E5D49814C5788CE7D409893B38AF270115DF681082EBCC051F2390C20B5A80EE74C213BA29499FC9255390 +MD = 9F95DE1E9AB813A8D768070D0E797BADF08EDD44568E169CF9051BFA5E89A248 + +Len = 1574 +Msg = 4C86FAB1AB85CB3D2D6394869241DCE2DEE5B3097373DC2584858C4B0D2A8494A802BDBE3C1BF08FF1DE84773FFE307A0432310B6B874AA55833BAC8B56FF7C0FADB831A00143C9BC17EE0E2547A90F95FF2C73F1E6BC8E3AB0745ED5814972AA247D72AFD7161C192981FA8B85DE7CDCAE3F023FFC4CC62E5257129D85F6E0D950D28C457512213A84BE7DF5AE54FBFE7964D3FDC009C70322FFA50782F443763730CB4CF49600FD4A3C831D580D1026E6EAA1801846EB2A8175F528DB9A09B1987AF148C +MD = 1A016692ED8380D9B136182EC3442C24C311EA2D9816AC1E7C1130072C8DB497 + +Len = 1575 +Msg = F2E2E57FAE32B0A84C5D7B43174C74DAE20144A875A52ECFFD0BCEFFDA3B86E7200C1FE848A7A89D737204D199AFF82CAABC2723C7970618BEDB3FEEEED2CC172F5FFC0525ECFB7F6402407D85273A21DB19CCFF4FC5F1487EB5A87BFAD8E1C9D4832C1DE34D70ABAC87A68342AFF65881DD881876570C1404B4612345341266457243D5A03D7C01B4B34979C01F6EDDCA3EB662A79A73A0E12992424F8F461321466C8D481E2F90C31E8DF4A79F39F9F5E87A8CD12055B31AC6ECD4B81C975B7BC3F30048 +MD = 03279AC34316E17CCE120508902DCF8D90795A0623B758702676AB77097DE644 + +Len = 1576 +Msg = FDD7A9433A3B4AFABD7A3A5E3457E56DEBF78E84B7A0B0CA0E8C6D53BD0C2DAE31B2700C6128334F43981BE3B213B1D7A118D59C7E6B6493A86F866A1635C12859CFB9AD17460A77B4522A5C1883C3D6ACC86E6162667EC414E9A104AA892053A2B1D72165A855BACD8FAF8034A5DD9B716F47A0818C09BB6BAF22AA503C06B4CA261F557761989D2AFBD88B6A678AD128AF68672107D0F1FC73C5CA740459297B3292B281E93BCEB761BDE7221C3A55708E5EC84472CDDCAA84ECF23723CC0991355C6280 +MD = EE53F83D2E2CCC315C6377EADDA5F42F42F3AADD664E3E895C37CBE9D0E9B9DE + +Len = 1577 +Msg = 90E5EC58E79320AE60ABE631E3073FDCE992CA5BA19A6E3F2272F6B0E9F9A9BCF70236C5FB0DB8DBFD980683DF4C176F07C27A944699A5AC7552C0D5D3824BD3E95E2DFB7D412FA0A8F5D2B73E0936F11E6B95FE8AB3FDB02A8ACCD1AC7867066318A3F60F244F79D01CCCB340BD4216B8C9222294187122133605EE25230DEE6262DE75506648BC6867A8C70FEB75B687661EB9C5D87C630BE06CED62AEB7A6C8B2A7DF23FF8A34E3BEED0CFD3B30A3ECEF1B59BA1C8988A46971686658FA110AE238330700 +MD = 40C35AFB8C0DF37988E5FD7288B313848541B041401C5323AA64042D340FA10B + +Len = 1578 +Msg = 7D10486481F81E0B593C849E54D047DB523A6F31E7B19FD80E747364F43CA2B1773DC9B62B004D855CC38330EE82DE4EDB37F07402A9301E40A6E135EE2DB0B8BFC493B69E4DEB2543E0241D8416467D8CAA0FDC73E6D6E177A0A18885946318416F0DF593BF680EF5D10ABE8E752EE3646DC6280DDBCB500548290D4E4826D685DE446037C25068A9424ED6D0C9B63EE650A42674B7E231F40761F7F367C043537E320B79C9D9071362A7E9F6E65AFD9BF4536D860AB58015715953718CDEB040240A731E40 +MD = 5D1B0D28E543D7FC015D71BE9A6E7FC9550BEECDC82B7598E7ECC74F079FA324 + +Len = 1579 +Msg = CDCA251E2C752A3E724A0D32B65AA4B1D5C87DEBC1F87D802C6DEE8EDA523C10026985390DDA593ABD375E86FCA31950FB74FA6FAEF330225BE70C71D2492C95410E6B115BDF694DD5965C6D4FC5B585EA4DF25803C9FAC55FAC49EA732D736752BC8634A2871CAA788261E352A1C8B3A645D0E22BDF10D62C6756E656F9E78314BE069B2E1444B32273B8EC132A4DA2D10EA148EF8161D238B11A437F2983E26B7C8AE95210B393BB3E624D99FEF3C72FFD1B521B8B4D41B426E4F8055C0B50776EE059C6E0 +MD = 53ACC0E54EFF2421DF7D34E1A77B10499A2D355914E7E31B55424CCDE9C23830 + +Len = 1580 +Msg = BC114681C35F67BEF8C8CC81BBDF40B879EA33A05D034B38B6EEE163819DFFF9E15B0B9ED7A80D9FB9C9499AD2DAC94AD8CAB68B4871E3423CD35C67D710A37830478C344EB4439B0BA4ACE3554B682F6BA20209923932ACB9F743D8BD6A4938466531FC5AB43E6E8DAED4815F288C16D909402DB7ABCABF8B96F305BB7BBD1D73D86FE03012A9CDA5AC4577BBA3ED9375EB9566C12A0BFE08F4B8EBC663A8B0CDEA53D65802847C09A07E9D8E51BA7DA92F575D523F2D1418EB5D169CBA1901B7829339C4A0 +MD = 4876BEC10AFCF1385B11BEC372085BCF53AED0EAF98BD3D525ED8E4D2F5318D0 + +Len = 1581 +Msg = 5019CE0DD714A0C8B92017E26AF6BC433E101A4EA01D2E39BA4FBD467974C0831EB6F4E2639CDD8596EFCBEFC546C22C75D8F742C0C3439D49C199F9D4ECF9CCAF4D375BB8508FD8F7314473A1EC2E3B9A12386122773F8AD12E6C9319134FB1C8EE836C8CBA8B714FB1D0BF11190D1E9A2A80D7907160607F43FA0DE59E77850FDD32161F05A9C13C8C6BB0F5AA8D2F8A4FA1C38AF78C61A26B560F06FD813121BC133B54D88CF1033EA7069E98AE8D8A6E2F99B584AD8F56DB1ABC1590E8DE34ADDE195CC8 +MD = 739D5A5F1D3837EE947D713A5A77C1EED2519CB69C578EA2FC22A294D076D7DD + +Len = 1582 +Msg = 2CC35AADA46B1AE9F81024B610740D81451D81426C6A02C00110687C39F45546E57793C5B31EBD9A1F52A14279A767C58816D77377873B91DC392888C467916C876391A5312BEF9C13898FCAC965CC7AC6B7209D757E40618EB94FE173A27A102679173E1A86ACACDDD181E1B0684F78EDCCD712229979A0A9BEBF55B27A8E74ACE453C77A681428D9C775C701BBAD9D3E4EB8EDC2BCCD09DA540F7AC232DF89E379229F47330668730E2E262695C6FE1F3E7E553125241734B1002EE7F6B39FD4695A686248 +MD = 6C937C51B2BE5E6003AC4DAF3EE7297245FF02A456E3A2149CA0564999A408BF + +Len = 1583 +Msg = 1916F52B31159E1BD0C2F375057A01A15CF716B49160C7AF88BEAD7A1D91ABCBFC20595DF3BD0A36FF92F0E35495E12E9EB49FD9C38EEA08567CBF32074389843541090B742915BDCDBD0286F66A657FFAF248E64C15053A14D02ED841F268205716894BB36D13477F2045A57DC8CC51BE67FD50BA15757E18A71A7F529BFC8EBE84F8562645169CF4EA0DF921233287B7530553545839FD5DFED59DC7610D3A6ED7FC97B5CEAD9E17AEE9E5452572075E7656CD517E5E94E4A01FE66403E26A6F3DDAE8A504 +MD = 54ACEAC9EAF579FF8CA90CD6D71F73E2D40186E70AB76BDC0F944ED00E245DFF + +Len = 1584 +Msg = 70A40BFBEF92277A1AAD72F6B79D0177197C4EBD432668CFEC05D099ACCB651062B5DFF156C0B27336687A94B26679CFDD9DAF7AD204338DD9C4D14114033A5C225BD11F217B5F4732DA167EE3F939262D4043FC9CBA92303B7B5E96AEA12ADDA64859DF4B86E9EE0B58E39091E6B188B408AC94E1294A8911245EE361E60E601EFF58D1D37639F3753BEC80EBB4EFDE25817436076623FC65415FE51D1B0280366D12C554D86743F3C3B6572E400361A60726131441BA493A83FBE9AFDA90F7AF1AE717238D +MD = 21CCFDA65C4B915303012B852AB29481030F87347C29917E21F210F2BD5EFC9C + +Len = 1585 +Msg = 4A3FAD4471E41E86724FDB35F4D3B26BFF60DBAFC5D4BD351135C8A7478A3B07001CD9C20829D41471A146A3EFB8EE598612F921CD1E4CC4A47FCCDB8FF0F67F44680E3378A8AA64619A33CFB5A4378FE4079567813BFB481BDC595B307BC97D70493FD08E2DAA4D97D2AA64FD08192C11D0A41A8D26119B0E8EDE30EB80F4E8BC2B8B0794C393B6FC23DB16F46DD6BCE8E52388B8D014CF6EA40EF553CDFC33EEFCF4898436B60162B98D99B1EF472FB4C79301B56AD49BCD6659BAD899C81F49B81D67CD9200 +MD = 8D9242ACB87ED06DF6EE6B3D43E922E72CB853F9B0C20EB55433106C24A7E9CF + +Len = 1586 +Msg = A68AB5DEC5519049A81EC8B6EC950DF8A9D989B58B5C4C397B22801DC85A24266CB91ADE2E99F53B91B5AE3C23B7D7185B21BE6582048BC8A1570E828C5D46666DCE1DCE06921ADD366D9043BC797B3E6EDDA00782FB57C13ED2D2F555AACCF7840D01C6DD75FD3D700C3BB18A49A7D60A879FD4BAD06D68A7C5763ED677B0C5A248E3CBE476A674D31F8C7DD5521C4F652329D56D6DA138D50D3126BE315C1963F376B4AFED50EB2F16E645B86593FE7433FB6BDB40621EDCD2F41E8D6DB8A1031AA73D7C9180 +MD = 805AA81741084214E97890A7F4BA5A315124833E5A06AF4885924402A109C62C + +Len = 1587 +Msg = E99B30E55F72FBE081ED5AF28A0B464810B49F98AD1B41C14BB47CBB1EAFFF99BB30A753099FB3FDD7964B06C6340E0C96B7EA1B95E928823A5090AD6B668E3CA047BFC8C653673B193F892824971C4449B37922304BDD160465CB842D3F44AF50C742A7F71C2A08682360CAE493FB8384644F056B5D9B25E4B2799ABE70E905CF7B0E7DEBF82496009DDB054754A9560C18377EB64D1BBA169C353A443CD9D80E6A39801FEBB9BAE3549399982D8C3578591B198ABB8CF2720C33012E76319EDCF1BCF0FA7580 +MD = 772480FF931A24867617DE232900317A19CF404E326989B69521F41058341486 + +Len = 1588 +Msg = 108B8CD3F79E74BC10D98D8A48A480A171ECFE1DCFC279D849AE49A01484A964070F0AC4400F85D8C0ACB88CCF5B6D41E7DFBD3FEF08865592C4052924DC0674A9FBD68A16FEBDE0CE7FB61C2F0D4AF7CF57DB925AFE0BA6109348F11BFD346ACD5A6A8674A8B6D6BA3229D4588E0419849A555B4121426F22C61B4978EEE4A22DA23D2A8E96BFBF5D5BFA4C2DBF3CE6FDE6433058E9738D1B3043134DCC1D00BF5860CF17115B8D6FB2AF35DE707F222520CEFE5001951BFE965DDB654B37B8B935F4BDA1D9F0 +MD = 3469032F8C5B46ED5C436ED659166C5512DE548ECB15213238BE74F4717548AF + +Len = 1589 +Msg = DE5BFAAE3D29D15E1B522121DD99D62671BD1CD310CFD04825B0A203BC8E4068C765FC005F916E218FBFB3DAFBE565AA27E3E26401D450CBAE7EDC8ED460431BB0CF3BE8471E2ED60342613FEB2E6685CDCD2DEF4053905565BF9447F36A1F4C1DB380E607D9B331B64AF73F9875540D8BBE1A2C6AAC1BBB8D7FEFC22A9136F5F9CC04001B621AD5569D341FBEA3F829D76ADEB99BB4C6A1AA0D70C22DA85B40D3ADC0EC31812CE3D40ACEFD27377E99F748EF930FB60AFD4A83C9810679806EE6B0DD9432F530 +MD = A8289D032DBD05754E013EE44B993AFBDA7EDB88F36D9EB51E6F58B7FA80C709 + +Len = 1590 +Msg = 04CFEB6AE07A84B6BE0A8FBCE81E3BC966D4CA35888C9F83E215FCA0280526ABA19081F862591B91C98D52DB46C9CB0ADF79F8E74B66C8C8F7D9BFCD2DBC6D37E25433F81417E84DE6A1E79CFF48A7AEA7898C722D4754110D9A151F9DB4E7A0E460C0BBD0A607E3F1B9820B878B3BA21820CB41E15B9BF6FC46FD0126064E0BE9BF60C0E6175291DDB35B53A39DB570EB1DF10CB6BC54D40BFCF2A84758C54EDD42A43658A87C2B6D6E7071D2D3170E2218AC0C9389888B2B9E25339C8D4E25D62B789BC1EF5C +MD = 7759734D259B22696806348B9243191C009AE51E034AEDF4F0E66A7AD4D92A15 + +Len = 1591 +Msg = 68C048F9095F71348C5534663C9E927ADFD3ECD4F99CB381AAC3266F66315193FD08523A905714D4E6B4BF72F605A68E164F6057538A3DBF89683B9665A047B018168E16A24990C61E1CFAC62CB3B888B4F2C5008F49452F1DD81B94288BFC94B89886B5DC23B55DD74A51C74A4D44DA267C9443340438FA3ECC220B9E5E81DDE7049337522473996E8FADB6AC0775D3D3C6ECC8FE20EFE92275071909229830024262C762C9DEEEC2DC646B220D5D5CFE6B09BA8790CCC10D01BD8E5178F5ECD92C6E5233274A +MD = 4A38D622B0F8A102054BFE74C81210A0CF63F8F8539810C46C5D8CFF8884BFFB + +Len = 1592 +Msg = 74356E449F4BF8644F77B14F4D67CB6BD9C1F5AE357621D5B8147E562B65C66585CAF2E491B48529A01A34D226D436959153815380D5689E30B35357CDAC6E08D3F2B0E88E200600D62BD9F5EAF488DF86A4470EA227006182E44809009868C4C280C43D7D64A5268FA719074960087B3A6ABC837882F882C837834535929389A12B2C78187E2EA07EF8B8EEF27DC85002C3AE35F1A50BEE6A1C48BA7E175F3316670B27983472AA6A61EED0A683A39EE323080620EA44A9F74411AE5CE99030528F9AB49C79F2 +MD = F5BF70710DA440EDB43AFD3EB7698180317FFEFA81406BB4DF9C2BB8B0B1C034 + +Len = 1593 +Msg = DDBDE9D6BA8A0889828CCEE9243EFF68E2C4D342E84273C9F4B4F6BAA3F2CF622354FFDC7EB6D31C9F55A341881FE7AD266B45B8CCACEA665C0ED227AD699051C020EC1C51834D0B7BDB69352B196CAB5C0C1648ED3A9BF9D77550A136EDCD294FFB41732E010CCA56BA0FFB20B3296F88C7D2A802F60AD7E39FD1F8AAE9F5B1B075BCBEA2CA6B3A79FE5BC2D13AF5BE022CEFDEB32E3659E2437F10BAD7210DCFBD21AE1B60E54862AF0B302FB596ECEE90783BC98798A31CFD9ABC07D2BE5B7379480BDCE1BF00 +MD = 2A934A2BF97174F364F0F9E95A1CAF2B750D6E53F0378D8357510CCEF9FC0421 + +Len = 1594 +Msg = FD76F5473E5DE24298193400A93C9ACD88CE44F855C1FF2980B0A40AE8418FB7119CA8FAB283221876EF54E7C3CE09AD70EB14C1B4A18A11FEA453DE45DFA5D16BF0071392224D15A7DCA73A10F2F0476F5300AE8BB88F706F22DEABFF0E6BCAEE981E4FDF7A028AD7B800A65A994EF73DC2F34166C92EAECE507DB3DA95264B36E29B30EC9D852172D5E227468E735EC8C43177ACD1C2EEC380A7FF6B44748580F5190EAB108C37517217757AABB265EF18CF97B3DDF7B2BAC1ED07105B8825C5F2B955F23A6900 +MD = F57E1D15A4A397E8BC192D08D0EC39DAEFCCDD0EDFC55489303DAA3FA874F8DA + +Len = 1595 +Msg = B82326F747C89F4976951420E31FD1969A46153D0F58D43E8D795F89DF7863AA752CF3210123937C76772C03B8C824ECF3601C4BC469ED02804126192534568B662FE8BC5CDAD86EE7B6F9B0F2AA98D996A810316830833B2B4C153F0AC30646D4E02B34417930EF1A5BA15A0E640C092750DB48E79EA7BCCD9ED1A5E24B93B3AE53C6F6380817A5491EFC9A29D8C8211C45152CBB28E1B8DA29BA4E634097BEDC1DD3C46ACE8E920BEF9B41CEEDAE26EB1733664CEF70CE8B9B4CD8E5377FC498C7C64348FD7C60 +MD = 608D3F1EB0DD2754FD0CBEE454DCDE866432D955DA2C02CB130A2E02EFFB1671 + +Len = 1596 +Msg = A1C179F412135FB1CFEABCD4D97D1B9AC22DBA60C174A5E889A188D3FA23E31EED0DF9EC72A1B48FF965DB0282143E48F15EEC05B0502A34B9B1770F79B299E1088183F080FD4C390C069AA310408D3B9E39961EA9457A18FAD96687DCCD6F8E4C3CBFCC55537919CBF0816D563BFBE2D7B32727625F1FAAE1A7AE153A6C1AB45CB8F8915F66122CF0570BE115849A24901CA6CFCFD96FBA7290455452881CD09D143867A67313C9D4ADD919436149200C1A4D9ABFA84A66A935F2B6203D0125A9654A5EC16117D0 +MD = 19AC48728A0BEB1449977129AF947592899FE749D67EBE4709B8BB0301153B56 + +Len = 1597 +Msg = 56585935F30E0C5DF323FCE4A4714E50186A1868342A2692302C0A93AA273B1C0E9F4DEF90117D0D20DAEFC40E7A3643DD5BC87BDE18F59E9AA7401309A18341AA687411269E2E847D6647274D05807536F39559839F3ABEB1D92939B8CD682DC2396EE27CB5A5FEEF2F3C66294119A4303F16E76C5A74303064941B2437212B73BDBC83E02ED998CC520E8EFA5D388E94D869F02D2E82992F37CBDB238001033CF481776D706759C29B1D69A1EB9EE1653D140BF47F9AB2E5774B60F14128DB0FDA416DB783D5D0 +MD = 631B7070796F79BA5042EB41518D141D101FFD3EA5D9FE175FE20C1CDF888A66 + +Len = 1598 +Msg = D3522A6A36034E5CB35A86D9AC147076015AC3FB2E268A7B2BD1961E7C50E847BE9690BDD655DA76641CF0A9ED6185AFD5904145392DFD0D7BD4EA7940AC6E0D49EFFF68A23D8278C1692CD4B08AB49E840FBDA309E8342FA77F38CF779885138ACE50D1BE596A36C959CC8741E607C453455E63BE1F15FFA3F1558A7D48C5F2B3781158117E5839BF4097F003D9B52B4AB21F099FF3464704F48C68505F1CCE098F071C5A6741918884A14B81D12E02A88F084299832CC51EC8D87DA25D5E4C4F6139B5C3F48DFC +MD = 50A4B5497A5BC67D133D4ED7DF1CD96E8CACD3B004F4947D70599BF9699991CC + +Len = 1599 +Msg = 347858A3C88CA84AD4E03F46CFD4A20D0CFBD31B9EAF5E2A428D8050A1F53DA5D8D42730B8E9B5D10578760CA2667F99F0B73180A88E22E75B11A524E789AB5E9E7863348A6D26C337F55307DE45D6E18FE951E0EF65745A54826A6C4F141588B11F904F9477041FDBFB40F260B5F49910C0091894812F3E91786050A5136E944EBF60C57A3415BBD5DE0C4BF960E1983C6F0A36A10B5336A800893A2AF078E734A946A3E1105B6DD64A16C62379F72D7D808F14793FF6264F635262553C9312DE0F80C0A5D43ACE +MD = 8EDBFE2E5D998AAA285911DA350990F69A8307EC08C6D68848496100D99C31E1 + +Len = 1600 +Msg = 8C3798E51BC68482D7337D3ABB75DC9FFE860714A9AD73551E120059860DDE24AB87327222B64CF774415A70F724CDF270DE3FE47DDA07B61C9EF2A3551F45A5584860248FABDE676E1CD75F6355AA3EAEABE3B51DC813D9FB2EAA4F0F1D9F834D7CAD9C7C695AE84B329385BC0BEF895B9F1EDF44A03D4B410CC23A79A6B62E4F346A5E8DD851C2857995DDBF5B2D717AEB847310E1F6A46AC3D26A7F9B44985AF656D2B7C9406E8A9E8F47DCB4EF6B83CAACF9AEFB6118BFCFF7E44BEF6937EBDDC89186839B77 +MD = E83EA21F5BC0976953AF86069A10EB6024A1AC59D609688E4A9759BB8B6C9441 + +Len = 1601 +Msg = 24E94DA7D1C92C690323242366867A5B805F81EC7C1132C024EDB5D0A09614DC67C068B0FEAFCB6DDEDA0A1C346F2238B0C6D6AB17A197B5170BE004275106E4CB9711745CBF1696B3BC7B764C693AF4F43B30DE3196A8B61A3FB5754EB7B99F5F9B65C8B2190B12CE038C0DEE4D3F95BFBBBBCB662EBA3BD42143A61415C728F736CB8350F5DB2351BE4BD6B8785F20209625AC2F56A789DA397C65F2E6BAB2F5C651F543CCFA554672FC46F9C6AB63887A2F7FD30B13BFE66155CD964ED7FF4937EE8626CECA4880 +MD = B34C6372254BFA476892C4539BB3314348A65110FCB7BB8BAEA252EE16138BFF + +Len = 1602 +Msg = 70BCB8E40B6F1FC372AE4582872E2806F12270013A5DFC58B2591FF68CD1EBF89DD5F201E226C81A9EB7F4B391BB8E3469AE3311B3279BEEB191DE6067CA55AD661DE8DFE3B0D88BC9577EA5A3CAA8364CDB54C40ED345EEF3F46E8D8D69B35C0B9D9A881DE6FEEED0EBC814618D1F5A9A033F59B51773D4B91DE7D366DB28C71D8D08CBEFF882920ECD240026EBA6281BEC7A4AE692A77C830C4DF7606ED3161497EF547B6938DABAE45E01FD2D3B403AE9086F98B69FC377C6B0B353E62FDF7FAFAD48CEB91BDBC0 +MD = 3204C462224CA62F6B71DD27518B54298AE3F1E4DE958A29162B0FCCDDC98223 + +Len = 1603 +Msg = 67A2ACDFE159EAB1A5B7D9161BFEFC43392FCD250EB68E95BE7D309BC453507687DBC8E26EC6954BC8CA87D825D3E87B149676D717C05F8FD953CCB2B998F57D9D13ACA970DC073637D1F303D0CB12E6BF2E6E6561A09B3EA1CB6BA3217B43B73E679BB3F59FA227E7BFC6A785184D24516335FE9282E231DF0F28D36248E125D9A6DE1A3CB08FCE7955BC1984DDFF6502BCC100D952FFA62E69D664CB76B6B4D4D02993F92C5C3F2EE115C384C996154DAA3EB2914F0ED2826AFBEC2DE86594DA71ADA1A1F04D5F60 +MD = 64F2F0F4DC03E8AF0DE1E424A051AC6755FDC629C8868F2BB1199C822BDFA509 + +Len = 1604 +Msg = 92C85290E7533F339C3F8637748E6B756C4CE24D21C6E5F2CC29D5D5B0FE770473BE6D26398D22B88B67D5DC398F8EABB2747487A5635DCA0C18D95E3F522A1D0605AAE2F99743F591D31961278ADEB03481DBFE3FBA5ACC722127567EE9A60872890A976E656872FF9696BCDFF8120C49C337A44522507E98D30D96DAAE13197C8464EB2CEAF011C79F83ACFCE448B0C15BF5FA94AC0E6F61770DC55FA0D9AD3B708164BEF6665DF6EB51F3E493C8E7252F3562B464E94E849A12DC52AA19A0067FA41F090C607950 +MD = E4DCF331D2FE833D2903B2BF2BDCA3CE73C26352850EB87BCA2225C0853506F6 + +Len = 1605 +Msg = A8847BD4C5F54B7BF00F4D0669F7ACAA71BD0C69A12D53F998910C858BD69BB2A09D46346C04390E0FEC9F6547B04209209E1C0FFA41C497BAE7470B6D3228E081773454046B655D0910088FF7137A17869AA97992C0CBB34C513BA06420EC3C0610C0DCD1A21142A5A3BB50CC50A5109FF8D81796D015A8E99DD352C1E6908B19C1F55E617A04BFB699F98798DE1B456627CFEC2F2FE10BD880A4531B4EAC2867E782A8C9A1D564A5D6349B3E02C27B513D676FD9819FD28D37187C80406D1A377FD16C1D5511D288 +MD = 827EB2BB2BF005252B1FDCBDDFA2584ACBB560638ECE47F123BFA71A9F40A134 + +Len = 1606 +Msg = 57B6CF67BE832C5FF9630C6C23F45EB662D91CCEF2313DBA0B3961FF63A1C95D2193511B3CF773A9E149701506DCDF66CF148682ACCD60CFE5261CA8482001A75AAFAC4452AAF3EAAC7B0C6F963AF736A8C07E175B06DD38B8AEF3491343C2C319713EEBD2063125D970660BCD813B25EF8E208AC96DBFE21D0106ABAEEFBA9EBEEFDF0AEAF41C011E6F91C0AE8D84B104E7C33CCCB863CA72FACF09D1B8FD0EB1BAC3A5B07D3004664B9AD568EC5A254F470CA99FDD5BA7270DA6ECD0983B5F3F1107BB6F8F4A9BE4 +MD = C074CFA65A33CC88B9B3A970C608773102675ED4F82FE0A76E20304F386A03FA + +Len = 1607 +Msg = 773E8CD756FDA30FD5D91E11765CE2E07B9ADB1AA5D28E54690C42E2C88270522EF70BDC457E671A2F0BE72066FD6AB9AA4FADEE137A2C7B33890B7926AD69514ABF915B094E4602833A4C3EC2A294D4A86791637BECA3A2E49A6B1678C557EC667177F2C98BAD18137A8ECF7AE31ADE6645871AF70894DDA7D5039A1CAB5836D3F1FCE31FC4260609C5A85A3728D7E50D521CF196922FA72C6AEC3CE6A5EBD0C1C1ECF45CC8F2E4EC0B283B359F1E7CF62070888E9BA2EED005BD1E7B9E50A6CD7146361773610A76 +MD = 5E5209477035363FBC95C5944AB12C87D17EE4D05DC5B5180019E2D1E746142F + +Len = 1608 +Msg = FA56BF730C4F8395875189C10C4FB251605757A8FECC31F9737E3C2503B02608E6731E85D7A38393C67DE516B85304824BFB135E33BF22B3A23B913BF6ACD2B7AB85198B8187B2BCD454D5E3318CACB32FD6261C31AE7F6C54EF6A7A2A4C9F3ECB81CE3555D4F0AD466DD4C108A90399D70041997C3B25345A9653F3C9A6711AB1B91D6A9D2216442DA2C973CBD685EE7643BFD77327A2F7AE9CB283620A08716DFB462E5C1D65432CA9D56A90E811443CD1ECB8F0DE179C9CB48BA4F6FEC360C66F252F6E64EDC96B +MD = A2D93C6367E1862809D367EC37F9DA44CB3A8B4319C6A094C5E7D7266FE3A593 + +Len = 1609 +Msg = 9FF8A2A4213E2CD5F76338232761F86130B1609DDBFECC9EE0712A7F3DEEAF36BFF36D0959DF5547713E072DF78E87BA6F9A0B27B55A15A48FDB21897DD5C76C1CD22266B7895DC06969098C9E4EA6B4E73287D50075ED84DD14535214ACE53CB9F8935CCC7DA8EB0B0A14A5655B19429B4C9CD842B4E1A3DFE980ED978236ED49E6C82526D18122583B61DD9A04E04372344BED009271C83CB352219A0E802D2ED016EC94BB799D69663CADC92EABA4E638A2781828AEB6BDABCEE600510BE61782CBD3F30361AE5E80 +MD = F6BAF29D218E7CCEC98F675BC09450D9AEDB910113224EA70B6C9AD4DA9D321E + +Len = 1610 +Msg = 1AC32A48B8F354AB80580B77B6ECF9231CB9B5749DE765EEC1E7A3B8A751B6D7B3100520B27EF10D4ED1E9671D31721374BAE63FDF4014BE492E868FF08F159BCAAE359FDFEF88C66A5AC7A2A55DB0D93BE929234F7FFC8BD8D3FEC296DC2A588CF47AFEFC10FBD7E67E81CFAA1F61403E9AA25CA4D11314590B1D74828F90416288A2D10CBCA43057518EB7C583197C44F03ACEBB7A8E12F1880860335E54D30BAD54171DE4904E5BD3F22F91004A2A95467F24F8BE0D88681D79978D1948711EA3E49308225A3260C0 +MD = 6DE6B5C76A9B33D3EDF45464CAA54FD8744FC58469A8B785C550AEB95ED67166 + +Len = 1611 +Msg = F0AD4970D30ACA266FE736FD168F4A023FAD4E998BE61BFBF20587432CC318FD57748DD6792B973857381A095A8A1D234D6D98B89E44427ABD07A622298A28C888D1C6DEB24FF2B8E29029E7616B9D4E3769437B6AAF8028CD856A67AAD1E627E52C941B1DAC239C6555F9E8655A28E89AACBC8D830B1C5AAFE4A104D94C4E9A86BFA24FF74C08D341FAE30C705EA84C78784366EB37A43E3F7FBB671D0177B61FF5420214121C0BBD451BBE6BD32E5A6CBC2A4908F48601AC24935D8D861846039BC53A16C583019420 +MD = C18108F81EB8FB777442ECD49ECA27F05A8B15B1BCA215CFB1D342D7F921175B + +Len = 1612 +Msg = 3BE987D46800EE451CC793FDA988C727092851357138E7C112FA5F611114320951A65BC45AB34E1887A73B7FDF932E6743CCEF3731737A5520C6F4B88437A8B4CFC89A78885C1D8612BDFF6F4EE5C0E5C36DE87863AF9E63803740E06D16C2EB5F44BE7161F0ADE58A94DD6584DE18C80CFB88022A50C1040369E8962B70D9160A847C4207B104C48803B1740E9D1E1F5F0F4FAC4202E6E98D2D5C09FECC2C382084FC63CC9D26AC8DCF307118E8D72CDE0FCF04067443A5A1A9A833912E041FA251A9647F2FE2BD9330 +MD = 5C6BC4E3C84BBDE26A492C11C3E2688C4633329ED5347075FC88469BE0F6635C + +Len = 1613 +Msg = A8FD1D5C15E4CAA7ED292CD3693F9418E46AC4C9635A1AECE4A8E0EFA9B76EC1E356F80A54A45C62FCEF3B782E2882115FEC648E89A58D47669131605AC558E14F43A2DAD745521F37676F4B2C491FDEEFD42C3CB6D9E313638D843C59702EE637BCD813303FC34CEDF0DC017F93595DF8636505E4E96FFDE3D369DCEBC9493E7AD0AAFD1D44FCC25121C4BDEA74C07EC0264D20973E526D5D9876B17D5050978DA6B39EBC530EE2112939804EE5DF60712778B66C917DDF3428FEB2E5B27BCFD69CDE6ABEC96B5CB500 +MD = 30F9B26BC71D4254C1F29450CCE79A1CCE7EB8DD49075C904A150BF5635D300B + +Len = 1614 +Msg = A46537443AB90410B94FE953B2D17D44BBD81E996022690F081EAE3AB7FFC9A9BFC419BFA66F88F3260C44D71E1D577BB9CA1C3A2977FAEB50C6B4F21117BA6976BF964DD5C2146286A35C608474E8D87A708C04DD0165655C4AF624C0CFCB88B844B18E4B14514D3A416C46BDB0A95D9D42301AF1EE9F82E6CAE0531A5C92FC6A1663B9C07BC16A982C08017C660E77CA1313ABD742CE18EA7B92C0944859AF6E2462C00BBB2399D33A86D2A10ADA9AFD3DF6CDCC001CFBEEC4A320A014EACF3C6819928F54C492A430 +MD = DB8B815070A367EB3FEB3164835CD584779A7D34C9B24990EF721485D3E7D0A2 + +Len = 1615 +Msg = 2FE16DBF1226D02C64CE853C981B1F6FE6953504EA690DE36D8E88915C979676306185132CCC2BA8F603AC355C8258044FFE942FD60B8CDF2E7D0C0B0C8FB37967AEE1F6327253C3AFF37FF0FF45C06C58141F389542582BA07C36AE59F173F83141C9144CBB9800B77661BBC0A16BCAF6273E1E476A72640256CA952F67C130F6E8F54B0BB5FEA837467C5507A0DFA256868F6868C1B0F98AA9DAFF35AF40BBC816DF280DA9A5896B722353857CADFD0793D2F17FF0DD6AEAF4D0E589D09A13C22A3C2C7623BC86DD30 +MD = 803EB566E6EAD6BC190EA69A7D8A7DADE16AFD6C1C4BA819661E1112D433BF97 + +Len = 1616 +Msg = B6134F9C3E91DD8000740D009DD806240811D51AB1546A974BCB18D344642BAA5CD5903AF84D58EC5BA17301D5EC0F10CCD0509CBB3FD3FFF9172D193AF0F782252FD1338C7244D40E0E42362275B22D01C4C3389F19DD69BDF958EBE28E31A4FFE2B5F18A87831CFB7095F58A87C9FA21DB72BA269379B2DC2384B3DA953C7925761FED324620ACEA435E52B424A7723F6A2357374157A34CD8252351C25A1B232826CEFE1BD3E70FFC15A31E7C0598219D7F00436294D11891B82497BC78AA5363892A2495DF8C1EEF +MD = 3C647B195F22DC16D6DECC8873017DF369EE1C4696340934DB158DC4059C76DF + +Len = 1617 +Msg = 9C931DFD9C4D8C101C8F629C7B12084CD414F91DAC571E93F843CB77FB6C073BE1227605078AAE37D880F31D660692455314C9E818AAC083F4C9533CC2F9DCE60229D1C4F3A6DFA50AC6DD4C5C7F2AF2BAD5BD7F308BD3618B40FD9495EFFF87FC338E55D6949BCC6DF902CE0EF1F496E2D8E63DC225AEB9D2FC7CA7FD081B86E54D87E441FA1A5251ABF4C004C691C684E0009DFD3FB7D6620126CB0D859DBB884AF8DA735CD51F89316F28E11FEDFF238C13D0DBCFFD4BDC55AAE2C0C20F6AA4C9CA620955A050B11D80 +MD = 7C47261EEEBA522468902C4481B5573DC35A46CD9A53AB9914F3BBD65954B455 + +Len = 1618 +Msg = FC9E543C76D384217780D7D47167AAC9826EAD5BD2FB0727A1BC37A15D31E45C75C2543976CD4F2C9C244DD358402934B37242C0210052F1344130E48D2D1605334F0F05592F1A2D9A40E0CA9F24821B51FDCBE2B9ACBC78D0CADB31448262D90147943550B913445E07AC1DB311DDC2CBF37AE39DBFEEB2353DB1C66C4D7448281CDEE230ED6075F5F8BB1BE7BB708337EB5ED98935F81912A86A6F727A611183945F4DB323E2374B70C6743961B84A9DA53E45397E3B8566CCB049C97B43704CA7CDD1BEE8543D82FF80 +MD = 41E86DD977362B56356A8C0ED71A630532D96D391ECB2D4E6B33C7D65F061B19 + +Len = 1619 +Msg = 69B28A0A8AFD90F5AAC6C3C3906D619C2AC2312C5B908306C75E0D1BA79551B4FEB1EC9331A463385397EE0BE08F5F7EE8F5CA73B849B35817F19A827E3628651D79112BD514291FEB570057ACACEF4B0B99500BEF10C7638A0517B3F2F69E0F76F6DD15C11E38CAEC38B02C1CA4EB53028E604058546FB1EC5647F8544ABA1382D63D6020374559C3DBB35CB11B80208E1C464BA71C35EAF87455CFCC5E820592CF4D094BE9222F027EEA87C9AD0FFE42E84EDE6B4F2C6706E78B81449918B5F83D7D72481E9D11603340 +MD = 4DA26D1080704B57FCBC90A5B74044D529F27ABA603D6B3D96A7643A0D6DAAC6 + +Len = 1620 +Msg = D616E9B17727CE826D28E5672AE1124235B8D3CCA505F931DB0E9FCB68AAC2324FD78D81F632DCCCE2E55654AAD4F4F1EE055147034F21F675E11833C2A85236EA23BAA44C3F8CCA4CE61C0CDB1EE635C361833CB20A16815942C637C67F3B5C0FA833D2717CA27FC339A66009BA76EB0CD1579312946FDAAB821D508859BC5AFC1C40042F2B61A0AD9B68357E216885113A052FED54D791BEA264C904C037321CE39EFBB8FB69DD700DBE53325BD8A71F6D832A7B7817F3DEAD7248EE86C698826BBFB58F6807F5E03AF0 +MD = E9E126FB74FE24807054D1C424F8D059FBA009011B74A7812BCE6DE4F1846305 + +Len = 1621 +Msg = 570A724BC4DB5A97944847CF9496A80699944D703300E06AEACD03BBA32BFA3D335C265DDAD711B00B0637DE34BE4920395028A4021F51E56B0300196EA2E6FA0F281205617826B76269346F725833EC2CBEF01E8CD10D506AE1421924A7118830194978E5D5FF48D64315940B740E149436D0C6665E1EDEBA26D2E898FE8B153CDD7AB4D542F4845F3836773D6528329D0338768CDD1A83F40FC7DF5601EB840C7CC60A3E1AC40DB4A2418058E5C0C4AD572CDAA8E5DF2D94CCF97C5E9DB945F7157602383A0709E785C0 +MD = E15B5D0CAF9C2B027F08F8A5478A4A91F383075F1D270D5B5C2A81C2FA3B454E + +Len = 1622 +Msg = 705BB313E3151FA58E67D27A222063D89CC1F51B0F85AFBD286F7A2679DE97E85608283BCB05A722B4964FD00469DA851DB6478AD123D15BD7C345168644E655CE27B26BE4860226846316590FE4A928EB70EF137EDA87500A1D2B7C926CE24F129CF2C26108C13FFA54DD7440E7A072E86F892A7CECE5B32FFA64A8EACCC0894918BBE03356EFBBE1CDD0D8D2874D4F0CF2DE97B6FF136C82E52CA2DDFFC7C071B235FDF45EA75F882218AA447DB1774B524E491A71C8AD36EF7E237586B8EF8C9D1F51696FA87BB7BEA8 +MD = 90A86712958E12855C635E4665FD3480910BA194A7D7203D970E306C18610F38 + +Len = 1623 +Msg = FB6A9DFFEAE4C1DDD12A0B91B6DF791491C66FA5F63C17AACA03E05A021A0FBDF6110AB4F613DC4A18C3529510ECCAB3487B52F29B21C721C36A9D8ABACF0391BE26628855F488A67EE544F5A8F4ED28496F7D2EEBF0A6293848914D5AB313DBCC97FE8D6557BC0B55428EE9F9286473E3CA7F419958C3A6834B46DCFCF7FB33B9D212B8499AF8F742F63680C8BD3E9ED47483A765E7A24BF8E025FBC6F22BF119DCCF0C8325DE3842D7A38A2D7814609DF157CBC468B90E5F994E3FA5ECAD60086584D7DE80222F19080E +MD = 1EDE2B6FF9592B652A5F95B2EE47F7E7F91B7A6A08A0EF15A2FC8ACD210759D2 + +Len = 1624 +Msg = C941CDB9C28AB0A791F2E5C8E8BB52850626AA89205BEC3A7E22682313D198B1FA33FC7295381354858758AE6C8EC6FAC3245C6E454D16FA2F51C4166FAB51DF272858F2D603770C40987F64442D487AF49CD5C3991CE858EA2A60DAB6A65A34414965933973AC2457089E359160B7CDEDC42F29E10A91921785F6B7224EE0B349393CDCFF6151B50B377D609559923D0984CDA6000829B916AB6896693EF6A2199B3C22F7DC5500A15B8258420E314C222BC000BC4E5413E6DD82C993F8330F5C6D1BE4BC79F08A1A0A46 +MD = 3BB394D056D94FDE68920CD383378EE3ABCC44B7259D3DB9CD0A897E021F7E2E + +Len = 1625 +Msg = 4512826ACF04E03A179B4637CDDA71C13DE4A063A95616E213DD9BF6F738EFFCEB958D8C5FA812CD9F7E0DC1071642B327FF8FA5E30092DFD3422CD66F371AFC8F5771EB86734099F9E731F303300E49E2196371BC90359B2099241F772F9BCEEA3A994ADA8E8A9377D50400264CD6BA2C016C6DF662194962F394C684CD77D1896980B6269944196A29EA086B6D37D240A242273B7BE94FC2F9DCE896E68F2AA6DD7E02360D80F10819A0B7B3631F9214498465ED58191F33A002E85781E21C711E4239481C704366E15E00 +MD = C1272511066AB7890F4EAE81DD9123B809FC1A79C1F34C93D21FA20598CF7A5D + +Len = 1626 +Msg = 5F0A71F137E9E6C4A89323D63F4C64524A8C571FE3B461ACD6ADC6868BA280CF54209AD953F2B6C79D94EBF15440257B0FAD8DA1989528EB001637A9ED39B5335111B580091106D3578BAA32220763B87881BF1C04E6F735316B1DD60939ECC8FAA36723443835BEB11375A8D1777A1E67F8383D13DF4D4AC7EABED0639F6937FBD56BD4861A2619916E378AF371B26302978C98D29B2E0D5687FDA5C0042865B31C18CED3D93E6955F868BB2B1DA780FEFF91FCF8C2FF368A19B053A4924CB118D4446B061C57AF4DA86100 +MD = 953808573D5D48C4FE34008078F11CEBFD17C2E053C1BDDF8156125F3A12DC22 + +Len = 1627 +Msg = B5508E04114A8AD105281386E03A926D5C1D30675AE728200DD66183ABC7CBADA4B04461905FB650ABE443C35A9CB1F02036DADBBE4AB835546DE4B073A169EABF7B65BB8A7A189469C5FEAFBA84EB212AC4032E2C0E98B440FFE7AB41315F6925C019080AEE16FE28797637790A9427723EEB09E9501FA7EF18D332BDD27E9A211501AF5D4EB85A08B29004031DE3A819FAA9F1FF60351BB24DB87A0C9148DA4F3D36A59F3A1234B0065169B7E04341FED4FA38A06DD11B2F48C5C717DF6412D7CB8C86306C1432A70C1300 +MD = FAF00AAF0F32AE99D056FE30FF5A69628567F86C88AC742C678FC5D0C701BAA0 + +Len = 1628 +Msg = 460E5926CF79EAB6CDB5EBD255A787EC57EC030675F65C2CA6000B39C36B6CA62AADD1A9B6DDA1FF864C57D939A5AD53F463A4AB0E2839C9687B3695A2A78C9FF44A4A1822FD0CABA41196EE879F766FE11B7DC5E6E65BFAD3D3C3ED215C2D501771C16C483E57CB0D33FC1F8ED374A99E68AF15A412F85852ECACFB8F852A72EE683B9BD417F79AA217F6DD7A94A7BA87336A0588831E7A4028AA6418711B9E666573411DB81C2B3CA5B0243EB5DA495FEB870E0314D23AE7A667CBD3D6B5BC7CDE2574D09FB4FDA4581EF0 +MD = 41FAF2E64F608427AA23DB85A29AC9C46D4511F451D092E7548AF717D5DE877B + +Len = 1629 +Msg = 13F4F5E8D19555A5E0636AEACF49EDB517612FC8CFAF02777FA81381D9F17FB9EBD3CD7B68C5BFE27C8FCBB83C28C4E9708EE72A5170CED985E4B27A68914D0625B03F9641F4E610B53B791CB9362AF625F1391840D0A375EF19FD8D038F4F7BCDF4A203E4B4CB3657C7254D183E3D88C171AFB511D043671E58CAC1ADBF03AF311C19AFEF2EDEEA14D53FD4DC7118506B0F6300CA176B2F891278894894AFE678A379DB28FA5E4DCCFB5E6A43D0A67797EC976FB6EFB312B1E8ADF73DEB9EA58BD2C153EF7CD20A8C48BD78 +MD = 4F53885AB1D984202ECCEC03C95B6344BCD6FC6B6A39608ECF409C01AA9A02C4 + +Len = 1630 +Msg = F8053BBDDEFEE95D05436D656F5CA1B71672EAE38D2E77071A086E1481D32EEA88336D78B6E75E7534B86168D317870B322C7733948FDE6EDD6A043B84EC6DD5D98FCDA0D5D2724E4A7CF497DD360ABBBEE936673953789BC7224F0585B655D20FC21E2064355A419194204C22C9E32B58714C62535CE5266EFBC885A8058A870AF26859A2BC09691B4B1701E267C92FFAE916792BEBC5EB31D1C3A89211DB21472CB045177E747496F0DE3BA5A7ADEC1905162593C9DF1E0AB50B00B2D3E85C9AB75EC875731B13474C9298 +MD = 52C828DC907BDA077BF81F3D9F6F39BA7D5509152C184F105F185263E2D3DDF7 + +Len = 1631 +Msg = 20F91E3E6BB637C2BA5B562FEFB1AADBEA72F6DDE874469E7453B74D5EC85E59F390CD317D5ABCA6EA15CA5B307F8517EF25328A2316E9CE32D9DB2609178F8B8DE2154F5EC37BAE069FA9A4BBAECEAD354D4BA3387F043085FAA6E5DB3BE7D0A257E1F46B8AE899BCB6932448B554265E8CCF7251710BAF133A4083F17279759E4AA27CCD1274B1B299DBAF19257C2DF5FD2F2060280D55F1B11B7EC362F894A459AA81D0AF2B3C43BD6D3767CBB6DB53B1DC54D4545638FC7977A7D81CCD1485B11F8D7309E200AD569474 +MD = 61F8498236C228E1E6672A70AC937E3A25C8DA86B4442BE44B28F3E5F023DC80 + +Len = 1632 +Msg = 4499EFFFAC4BCEA52747EFD1E4F20B73E48758BE915C88A1FFE5299B0B005837A46B2F20A9CB3C6E64A9E3C564A27C0F1C6AD1960373036EC5BFE1A8FC6A435C2185ED0F114C50E8B3E4C7ED96B06A036819C9463E864A58D6286F785E32A804443A56AF0B4DF6ABC57ED5C2B185DDEE8489EA080DEEEE66AA33C2E6DAB36251C402682B6824821F998C32163164298E1FAFD31BABBCFFB594C91888C6219079D907FDB438ED89529D6D96212FD55ABE20399DBEFD342248507436931CDEAD496EB6E4A80358ACC78647D043 +MD = 43640F408613CBF7393D900B921F22B826357F3B4FDFF7168EC45CBFB3EF5EFF + +Len = 1633 +Msg = CCBDCDBE422FEA72623873EBCA042A2F27EFEF40EF34289984B308672F89D8B9E0B9C3BEAE4972A892A4597D2970D402DFBE3429B6FB92D8B5556ACDD674EA060928F7A9A66A2613CB00AF3E464894EE32EAB35E9DB227747838B896AF8A9DB1151BB470E1535092944982BEF528BDBD00F444D02A220255898EE8940191C15476E167DCAE3365ACC671CA62BAE9FA5B6AA03BDD55D2E8F9BF76857A81658D01992E08A2F6418D2335BECE9E97D6906BC3C8D6F29D9C5749F4A57910BFAD25EB298C056DB574BF585C82EDCC80 +MD = 9734F75588BACF760B03AD84A91747EAF75D81C4CDBB03F1170EAF8F62F88F52 + +Len = 1634 +Msg = 1ADEF1C21E7469C34E78EA4D2D257FFE5622D172B2DA0E93EC6FEC7FC825158F7C7C2AD1E56D4309FE8461BDA8E06C5003A912BDECD3AE2824077F89845D2BC0D83199567CAC50D05F86B9FD42901C93952C85405A22CDBB584303A613356B53B739828865243D6AA729C4D9C10AD0DFE8B748BC2EF4303DEA69EAF396D6720E1F11995D2703CDE2AF6CD6E8AF7DA17067A3E38F6B231D199D32CE6AA71A0BEA2B815AE3F68B0BBE42979F46FC50EDC801A2C5CE8DBDAD0DE61E92BC8F8A8CDEF30F043BCE6F55D49065188780 +MD = F1E66EB02E6AAE08D01B76985D6C475A347D09F9C6807F460E7EE2261F6A93E5 + +Len = 1635 +Msg = F15F5FD8BE90D7DEDD1314869BD2039DC2F5908B908CF4741728AA8EE6F24D982658DD54772D6FB451CC4A2463EB47E06CC1D0D831F4890C68654ED11FF62932B5889729B861A629980AA86C9F8615DC9EA1502BC3AF35B918F0863E5022DA60AC88490D0C64929517B7EBD0CD8CF9FB82517E12C27F06D5A8250CDA267E53CE4CF7D3B26169197B38DFA2589C29E3005C2556F3E50E26CD4DD809DB873303A3DD2141008E851B3D4B7562E14BBEFE2A97D47EF29341324E551A3C13E08147D40FB6178BD98DB0BA5CA4640F80 +MD = A081066A4B0F77F99BCD07C5D3331677C6DAE3DE2E85BD69EC6A48BBDE0F385C + +Len = 1636 +Msg = 0C34D0BBBD2657D0C028A030BBD626F2E4427119D2281E6E75B0BD087C2E7FF0947C8AD5B17E151EB991A0D5C9000EB8454417850BCC869D87DB0BC38C04ACFD1B94773810681888B83EF92ED5E9EE671618DFE67A9CA62E5F6B840195FED233DF5E2CF2026CC89D7997AA3C870C061AA877DE2DA503503BA703C3658FB1B3A2B6C886C4855DDB6C779A3D9721340D41D556B7B5F91BF96F04B8BCC37DE2E0B666BE14F7E931DA6BA91B7DFBCD2E9E16CBDBC660A9A569A4360ECEC700873C8501AEF6C260C564AFAFFFB568D0 +MD = A7992CAC87DFE6D0909A0296366EF46D30DC8127B08008FD0BF7E194066019EB + +Len = 1637 +Msg = EE248972CCC5FBF6536657A10F190E2DF0266662AC50680581ED4D5E3B7D074E950E47588CA113B307111A599D797E08814B4A166633607CA024D296A0733DABFEBBFAF43A7A98B16836DD0983C31B0F8B0335A50BA8C5EBD5CEC7D3562CB8851BEAF6677A9ECB951EBA7CD2D7433E6FA77469AC2ECAC93D88F42B9019D41E8F588BC6544512E5CA8BDD5E4DDD2428C73255A7582C4BE5788057067B530C2539F5B01671C146D28A99C1264C69B76A079B2FB3D3FE7E6ACF0679E7B7DA1ED7484A52CED5D104CE4224EB13F630 +MD = FBA69B71CEDFC27C3EFAD73A538FC3B2F78CD9DB8579C2C26DFB5990D7D2161A + +Len = 1638 +Msg = E6391A7E201B049AAB723F633CBB384ABC9C7AEA14BDFB1466E06BA8060F066848A3CD53325F07A638D074B6CCE4837460E228F9978F5951563462BB40D8669831A75E815DDAD72089B98495C2C853E80BBD2EB59FC96EDAA227844AD127045AF51D72527139A935618175B98885E4FB71BB3480CCEA51F7E75CAA344CAE25C6194EF3BC77DE186369C97DB534D70C606D9E1013EEE2AF02413D9101FC4A61E3350E81A3528DF1E746FF5ECDB27DCFF89621D240ACFC80F074D7F83824E5842DC1F4ECFE74397E4C91AEF9F520 +MD = FF77691937F3116A9B32D8675FDDAC879C86A6CB7743E08D7930002C28715C0F + +Len = 1639 +Msg = 0BA293C65A0223662A04FF90E97F152B2BB999E3C46966030918CA341D6701E4C7A19AAED4ADA69CAF9C45BFB2CA35E813A7BC92C10DAB5C68F64C5B97923D5402BEBAEBC962C77E188A283672210FFBB62A92157A09AACFCAE39B8DE00BF70376EF3F504A5ABB488242BDF32E946C6BBE590472E4A9C05993BCD9F1DC6E52431FEE6F20AA9CBF952548482CBAD43043E8725CCDAB58D5F37C5307DF9B57C199C71613AA3C4CEF6C7D13677226B213E78A8E404607E5BC592E0E88DD48650C8CB2F6DE18B71DA2CDA994C79948 +MD = 975B6A69B3495C1D9D00845A3762BEF590F9176E6C946DF4A5BD0D1ADE2BA65C + +Len = 1640 +Msg = EECBB8FDFA4DA62170FD06727F697D81F83F601FF61E478105D3CB7502F2C89BF3E8F56EDD469D049807A38882A7EEFBC85FC9A950952E9FA84B8AFEBD3CE782D4DA598002827B1EB98882EA1F0A8F7AA9CE013A6E9BC462FB66C8D4A18DA21401E1B93356EB12F3725B6DB1684F2300A98B9A119E5D27FF704AFFB618E12708E77E6E5F34139A5A41131FD1D6336C272A8FC37080F041C71341BEE6AB550CB4A20A6DDB6A8E0299F2B14BC730C54B8B1C1C487B494BDCCFD3A53535AB2F231590BF2C4062FD2AD58F906A2D0D +MD = CB3713A5D5ABBC6AF72F8B38A701C71269B3B51C62EC5116F96AD0D42A10FD90 + +Len = 1641 +Msg = 9D8A483570AB16908C17E63363E8B292F8EF6D5B7043BB17EDB7D0B9AE9393A2D13FAFD0909E50E437C3934C18ED11200301C61196C2340BD70D6891A74CE8C2A04F31BF653E9610C5A93E3203A6B188F36F3D753393FADAE2A01A0D4F5E51BEC7AC939194A15C707CEA4BA48ED4D3A85F333A69F33E63E7EC7156AEA49669DE0BB1E75B5CCA3A759CB039DB7A977A5C1F6450FE069D595F30E965B7BBF6184CCD3E2E4B44FEA466C517A1EE1E5B40AC7068EB0E62CF13AFED1AB13DE7F679BD19840770B3070FE7FBD453BE3A80 +MD = B8E5488F2FFEEEBD2A82C81EF7904194978CA2C2D5EF44FAB9C39F2E690A9E7D + +Len = 1642 +Msg = 37B1027E4AD24931103547B93B8A36526E738388503D72B153CE7D867A3094B92CD0A6E35A35FAB85BBD2BD211153CC7D623EE0B756C4F6169A36289775F1F42257FD3E799B63004C5799E32B46973FBDDDC46E5E9E6049043E03E0CFD0B7F51F6C5A75B31E4A0F47A65EDEFFD37A830A742F7AC411033A12333BBA0BC3F0757A12DC2B38A5AC54505D8E2F7CFC4C04ECFCA80745C22F40F0A13EECD55A60E2DB5C292AB38E8626CBFF2A66C76BEA11CE36B7726F9E2F7EF9779EDB7282A883FECD8093E4A5523185365C8877980 +MD = 2A6C14FC80A4F7410934391811E46AFBA5074C2E8094891440B66F70A90DC5A0 + +Len = 1643 +Msg = CCD746C21AEE13D421F7B853F2E57D907150D9B317E55231B06FA13231A42B8661C0036D4C03727F48AD32C189F68DB5994611ACED2FF28FA1DDCECCB714C84B5D11621F0A7B59676922FE06914633FE0DAE5A72C3586D194C3971A5CA0B22FB1EDD7DB42C8B992949E642C481E1375B19EA92FF7EC3E7511BBA02A0D4CD66A3A57E854533AC3B46C8EBD47FEDBAA837618A9262FB03BF1B5AB140DC5F46F98E4A58B252EDF82AAD7E01FD0A89AB69244B4F7BBA5EC2CAA096ADCC674A5F0B3E55D8B4CD22F19B7100E034FE95C0 +MD = 06D4827608F662EE8C0B66E09CCB7AD7B7920E5F029202B0BEC83DF287727EB1 + +Len = 1644 +Msg = EE5AB1EB81BD8A647E1225744B90BFA8A998FF3018202AB4DD9C4F2891FCDA96AE786FF6D6530B0723AC3C7E943762996A7DBDA33DFCB8B2CD33F53150A8FF6BAA16E0E0CF8122C4F4B6BBCF4A5DCC5BC47F1BF41A1799CDE31C9D814444E55892E513DC9AD6E885AA305B95C087494513E2D1CB65D5AD9D1932FD53AEDE0974C4190535730C4C58920735E175CF4BE06BA5B1942F535B8898F6DC211593A3AED8C7AE1C32FBEAAA3C7FB171C46B7753679567BDB829E6EC769FB0A1C2E9F88CE55882A6E52AA2763EFF719D9620 +MD = B86C0CE72774CA92629297822D61C5E916437734F67738E1C82A6C242326AA20 + +Len = 1645 +Msg = B4E1CD73549230E9CA7AD60D99CF67C757B5A6C1105A39BBB4B92F3F11C7F1EAFDFAD71AD607BE795A60868C209711437A9D0B10F2FA3F0AEF49625197BA5014694C273740D76031BE3CEB6D2D959A7EA679B6DD2810AC4894780724E4714271E5C2957D20E55C384221791D1804BE9FCD656907342247EA85EB4D7982AF5B9AC6840FD60751DF25F5FA29B143A91FCB486013071619C8095548521665EA1098E7B2394B1161AEE4E1CB0438D080B95B4EA303E3FE8AA60C2E6FA5395E980E8B03FDCCA41D1C435A5C476C911840 +MD = 57BD0833EAF05F30C7072422BC0C6EE30E0860E9CCE768A8B1248BC50F4407EF + +Len = 1646 +Msg = 034D64592B99303F21D91AC35FF3B9A0A4A93EB886C4BB487B566170DE393F1E5CA82B704A6C029343B8BBCD674ECAEE1AEED2A6E21ADD8BF5219A37F8E1349C7A3F76839A3F39ADEE5CF4B9E91FCB68622ED5DCEF01F546C9B99A48456CA3FDBCC5013E47A4C345E54EA0FCC52FA14445B18F956B2C3A3B6C35FD9E72A60AA81D5E7E1CA0A54AC9B5F45B1A9E7ABC4D78D2452691EFD6ED268873CC94CEA342332832686E70703F88EFA1764221CD8884391607F8ED1FD5138ABF28D0FAF5904989C9D54D4BBCCA9C77374ED2EC +MD = EDCD34606F39289ED102E2950D2F49AFE12F3BB55AE93CB41C1EC90586BF2AF0 + +Len = 1647 +Msg = A290D488AB0626BD0BBD35BE8933D6063AA4F878A966E33B73D42E40AF66D0B242E3A3BBF42F7F00DC933AA19DB48508A62349A1142F9A1AF638A8A6A459F096D83A03CF5E7BE4545EAA22819AA816010D35C6AE5AD5412FB14B526331A9445BD374DB0272303C71E92924A2CDDBD8186BBD193C2C0B83C08E041B393CA0A8A25DAE892F112634C43FF581D0510BEBEEDE0E95FA8A8F0E25302DBF77DD22CF1935DD09D2156015825CDF95175EDE8816305459A901072E4FD2E2BE191D5FE13BDDE04C535C6984BD9EBE2DCA7B12 +MD = 062179D2CDB512AD5F56A8908BFE121E763962C8FEFDE138FAD3CE6C06F0C01D + +Len = 1648 +Msg = E64F3E4ACE5C8418D65FEC2BC5D2A303DD458034736E3B0DF719098BE7A206DEAF52D6BA82316CAF330EF852375188CDE2B39CC94AA449578A7E2A8E3F5A9D68E816B8D16889FBC0EBF0939D04F63033AE9AE2BDAB73B88C26D6BD25EE460EE1EF58FB0AFA92CC539F8C76D3D097E7A6A63EBB9B5887EDF3CF076028C5BBD5B9DB3211371AD3FE121D4E9BF44229F4E1ECF5A0F9F0EBA4D5CEB72878AB22C3F0EB5A625323AC66F7061F4A81FAC834471E0C59553F108475FE290D43E6A055AE3EE46FB67422F814A68C4BE3E8C9 +MD = B304FC4CA22131857D242EB12FE899ED9E6B55717C3360F113512A84174E6A77 + +Len = 1649 +Msg = 88D11A550DA2A6C99D1A1E1ED5FC7D8F4CF3593658F13D30AD65CF6BF862611B87AFE11F22D46529E8BE7CC9D5834DFC3812D8F74AB895465C5273D7204C7D2D9A015BDC343AAC4432B8E97A9BD60FC496EE3C1AD18E0CBFF4745EBF9A8E5E917C4CFE68958A1DFF1B5E68FEFD553C72B5F3725054E44E38F94112CEEBA3128EB6049EBB77CD67014A9D316D218AF547B695866E7E058611E8237B185783729690FF9A1D97E99AF0EA84683BCAFB12496BCA91E3AD271EE225F8971AE8CEBACFDB18B8CA7EB67DBFD2A14684CD7580 +MD = 3A8C30139F136E9D86547D29B94D863DEECEB27C4075D84C320331893B291652 + +Len = 1650 +Msg = 8770ADC96669E667525D133761D4E914C2A4CB5ADF81DCC6129A88A496F5231FA960101F76F1B43036F76084B773E76E7566F489550FBCB0919013ABE142BEF449553051D2249DEA6C8ECA9ABEFBBD7A167D3C5641393B02848D3269DB8C13519B11087D6128BA9296B63B639FCD6132E5372A93C9E30AFBAC564526098A6DCA0ACDE2C659EFD9250D187864F82505B291683B83A686709D792BD785B8879DB4658381E84BB4855CF7D78A16B7BFDBDEAF352352FD34D1C204A8AD1C558E128B0788D7D27F6F508E7DFF2F46028A00 +MD = 50DB9257BD22472F7ABD51C90D2DF9E93525D55147FC5D013BF3232440CB378D + +Len = 1651 +Msg = C355A7E5BBC13F1F080B810FEA90CE4C034AA1E7C3C6B209FB87399FCBA4A344706EEDD97AF881610C64FFBF44AD0BF321CA5249CA6EA09EE34FC513DEB34D5B98C6ED7340ED0D292D967C60856FADBAE4318FA427B879FD6852CF5A871F9D6428AC10CB048F6737DE6847F2AAAA998021A26C0F85760E9AF6CC8A5428AA308FBED9BEF937BE4BEB24A9DAF6A4F8374991D6C7961D1EEC6FE123713F42D78713734ED8792A278368119C83C9999BF952B1B1F7FADBC8F29C6237F5246F17948902147E6659260D2120DDADE9266220 +MD = 2554FD05DBBDC468066E41D328E6776EB1DE7A584A2BECD74450D91627144CB3 + +Len = 1652 +Msg = 0EB9AC23DF20C16D5184AD7252974B6A436D0F3F63696E5C3BDF6CB0D413AE9A6AD4873ADFC7449715FDDA2FF70691DF23FE97A5B4B26865B4079420EFE15BC91D49EDE69824460D9C088BFBFFA099BCA0069BAA011B5D6A156DAB76EEA11FCA667511308A797798FD06722DBE91AD244C1783886303E1C97B9341EF1E15F5A0CF776E047EC051A5AC226DE0080E81AA35D14910036D920F62DEF9A28E66E0120CBC15A6DFEAA937CCE1529DB8847A4400CF89D5BD9D46AEA1E82A5DB785848D8CF5D7B85463256E56B67F3DB31B00 +MD = EA3A1C9DF79C3414A0BB7FA0E011A27B350C1BC94C8225E9FF35B7D17C911177 + +Len = 1653 +Msg = 2123F23DB3299E66FF044A90F8668E0C935758B51E11A690F1F6B9A95335FD1A2A2F51B45747C2565CEA770C06E2C95A879B61399B9B86A0D44C557B9889A367416EFB6F3CB2F36D2FEEB487F93B33CF1587DE397CE5EBAA29DD808F503152562CF20F6B5E1CCB111A7E79831B2071AD69D69E8623AB3E7CC9445D30DA19521CCC7352F6FDC489427599A86A963DAFFF24483F256FAEC750C931AD732E8642355F73D901D4819CB922B92CB05D62C2899CCDB557EC15326B4B135E2957A548FE861F70052844AEC9CBFF7F57D64DA8 +MD = 98E89D2A4DBCBB1D8FA6B8203EFFD5184ED301D4D693324552A11203C5F9B024 + +Len = 1654 +Msg = 0AD619AC99A7F310B9D30C4AFE98149E59B6155B94C064CF2B9D2129F83A062499CDAB4BBB94312687FAC290410414064C5951973FB6E8ABD75975CA110B9885E2CFF19B89A33AB4C0BE0A7762F001A7732AF2CC5791C07730757524EF7BA7D5BC40AAA820E6DA3F16A5975CB3F68AE52E074433FDBFD831A5A625DB6DD7F3D2E08F51103F499D9457B95E28C6E003A0C29F39D0E5CDBA736E78E5F38643BCB5908779D6BCC711D2AEC62B9A7B24876A30D9D9BA65D032FAD16DD75229DD9DB6E87309AA897491D8AE19BF84CE0380 +MD = 2882FA1D299DA6DFF73EB699DFB6E9058757A291CC66BB116CBFFDC44F12498A + +Len = 1655 +Msg = DD5ACA2737DB9BFED4999C08898B23D933AC9C173387B1FDEF93BAF1224FA1F39BB22E3B2EA9C983B18ECEE377081BC56570B60733D686CDB0CB94642C91E34331E372E7FCC400A22DBE4A984871462184CC3276EAB7423616BFB827CBA65C5E7DF4E0A1E9F5139C2E87892C35C9A59A62D6E204264A0429FC33CE476716B4E0F059543E034A0B7E03A1EB15D4C497AB79D5C6B4A9B3AF26DDCF30CD5D7E398767E871DC823CFDD694C00C2F6256E28493777B09C51E2A2E285AA9C6FCBC80493C0A3F46FB3B13FD280C29967268A2 +MD = 8EED8C2D233ED238F7E5F447692C8A838595A95C310896B953940B9BB5A6B81C + +Len = 1656 +Msg = D2CB2D733033F9E91395312808383CC4F0CA974E87EC68400D52E96B3FA6984AC58D9AD0938DDE5A973008D818C49607D9DE2284E7618F1B8AED8372FBD52ED54557AF4220FAC09DFA8443011699B97D743F8F2B1AEF3537EBB45DCC9E13DFB438428EE190A4EFDB3CAEB7F3933117BF63ABDC7E57BEB4171C7E1AD260AB0587806C4D137B6316B50ABC9CCE0DFF3ACADA47BBB86BE777E617BBE578FF4519844DB360E0A96C6701290E76BB95D26F0F804C8A4F2717EAC4E7DE9F2CFF3BBC55A17E776C0D02856032A6CD10AD2838 +MD = A3CA830D4771C1BAA7FADA76C5FCEADD0F3CB9736E19CFEC52E9E74F56BFDD55 + +Len = 1657 +Msg = 061446729772A1A26F7F9A87702EABC582071872B6AB1373A1B88EBB259F0EFDEB159E12792588061C011602F6C42B8392E15AFC582388AC0903628E64C1DBE4F2B86109683F28EDC22C12CBE5541683715D039FEFC23E91629E9E4A330C6D0A68276DC60FD72C6AB20B71B79D2888159F49D327693CB48B61DFF2DE0E74D8A452320F9A9835D2C28613D555346BBD78F5320896E87AE92BC3B00A1B1BE403022D81258AFE07437BE13D339FC4481E96856D5CB49C547776C9CA467D05C38B8CBCFD71C0D899645705584F6ADDCCF000 +MD = 74369695B2D5D4052593C4A22058C060A9D8598382105505DFEF52BA33C47265 + +Len = 1658 +Msg = E2A4C02A8657C5D41445E9FA687E6F613278D5A8E9B6EBD5F76D817F1F5CCAC6C72278A70B96FAFDFE30ED00C27F20804FDCEF3882E3E47E3A36DA1708BD8059998BC367A1362F543CA8B9D224C6EE1C86E274B7B20D2CB64D6DA4ED53C751F7B561238AFB974D96ABC0878A386A7E28A9DFCE3C818E1B124ECA55BE07139CCF6C6020A4E4596A2EFCC7B84D271662FBC72074A16AE5EE37AAE4E5CBF19088A3C6C54A3D573B41889CE3D04459A0C466F0DD8E5CB3FD9C18211670CEF5F11DD406CFB922F14B7DB2F1F4B5C8C3D97240 +MD = 8E478115D28EC71841A76F2F714F4CD06701D8F0028B737648B2885293601D0D + +Len = 1659 +Msg = A2871DF706DD5662C5E6ABBA84790DCC435B5D2EFAE1650DF11245EAAD20096CB90A216A0F36BBC3DA6497087B02C81270B7698E97C6047B5108DE235C97EBD599DB942844AA6B3E0737BFA5FC8EA09022F310378A8E8816E155E535F0C0E4D2ABCCDE37916D9527680860DB6745C2B1B245BBCBED0C2561656DEAAE921B8C82872E667936F49A6105FBEAB4AD46A5BC7BE0BE0303EE92EA250BBFCDC3A6A23D514C0D9CF8DEB91FCDD421CB6A4EA988B4F9E6DCD2566B6A4702E9CFC437AF87EE22A20E558B306A97E11ED0AF891300 +MD = 4501B9301DDA16E6CDA73E08953FCC9CC062347425815D895F3C765B875DABDA + +Len = 1660 +Msg = D7F71FB30197E861BE59A77679FA5CD15239843842F4473EA9088FD6630A35949863D53DAD1E74093237CC822933387E7EE37A6D6190B72C52A08CF250954582357BE1E81317A6B65B247F21E0AD32BCFF600C5D671F8629C4946EE505C8CDEE4B8D6A7217556193538CF965FE9CAC3D44BC52898894CAFEAFD11F7ECCDDBFF518D6279D5DFC66C2D09D7DD23B0D3C3245167BD44C1089A1544DDB9EC1177290A2180B7606EEA44663D1589F1E9207B37B74DFB97D17F4D137B0719A09A6EF0C39F6CC0741D3A672005C707A09732120 +MD = 67D2A9BF0203EB2F4D9D06DC1D3D142BAE8386B257F875EAA0397807EE8D4A58 + +Len = 1661 +Msg = FE7DC1A26BF9B564A32930CCC3E3F143EEC2E2C92A63D31025114D0C335949CFFEEE336489D1A830731343974B9DD1E7DD6C83659B238D7F2EF4C91DD38C382BF03D32A0C74E704CF382A8711AC31149F76A1EA5FCD0B89B064562CE0C6BC46B34861B21CAD36CFF2AD07CD249FC2327785191B4BA0CC61DF7428298F852C250324CFBAB818294C24C534097FCC5F9403266955B65C47123E3E0D8CBF6E8478A231523F9913F3F6C6BBC8050D116400CDBE68F431860DF7322CC813B48DB3E8F52D35409D1E95882BA54C5857DB67A50 +MD = 6F929402E08474BE42032A55DF4941EFC0D83792586BE909B366A6CFBAED1A16 + +Len = 1662 +Msg = 872B77FB2DFF6AB011C7462CDC3B4892AFEFE4F6A786952DE02E49FE0C27FF89D81986E36F173D68B25D61F8D480BD3D06607545E618284EE0D4C2114BF7B00497D41BA41374709BE4FBF06A3F883701799B5FCC7382244C566F91C7398B13C06CAA5EB79F6914FD194CD18023D431F4A482AFF991B130ACDF7425009DE58A2049E577A6B19C68F14AE6AAA18492DD85FD6BAA91ECB346616819BD50B929298A7C0240812860C9ACABEBA7DDC13460F36C3ED6F068B200D0A3B8AF51ACBD07DC4CAF4EDCCFEC52A1D79F0465E12E74F0 +MD = FDD1D73EA2DF3CE624D1ADFB7E96E63AC28C21A191407D106B6C8300ACBB01F7 + +Len = 1663 +Msg = A73BFE2AE3EC4855C30923FFD31C8258B4B34C739C869A97A13CA07930E60BE81A0F7893741CF2F2DCDC9272559CE61A07F8F750A0BEB50A604BC22A35046B46AC78377F82707FD436961291FB862F9BEAE56B4569009C486FC73B3FD36842A3074B88E8C6B5F8815703DEAAD29F1915213EF61AE55833F52BBF8DE07EEED341AC93F3622FFC24FF713D3B5FDEA439CCFDC8B41F7449238717249998E651E3E9C9AF2F0D56B9EFE2E2AE3E3B67CC8E70E4CDFF3BC301B5C8BF92089A2BBB925D0308543C8BAFF4782E9A415C17367E0C +MD = 012E1CB7C903AFE57194260296FD9B183D3DCFC55B23986F47D7A73CAF5C86DA + +Len = 1664 +Msg = F2998955613DD414CC111DF5CE30A995BB792E260B0E37A5B1D942FE90171A4AC2F66D4928D7AD377F4D0554CBF4C523D21F6E5F379D6F4B028CDCB9B1758D3B39663242FF3CB6EDE6A36A6F05DB3BC41E0D861B384B6DEC58BB096D0A422FD542DF175E1BE1571FB52AE66F2D86A2F6824A8CFAACBAC4A7492AD0433EEB15454AF8F312B3B2A577750E3EFBD370E8A8CAC1582581971FBA3BA4BD0D76E718DACF8433D33A59D287F8CC92234E7A271041B526E389EFB0E40B6A18B3AAF658E82ED1C78631FD23B4C3EB27C3FAEC8685 +MD = CA158C46370E64A9F032F5BA8E091460FD555EF700EDF7087E56BEBFFA261DE7 + +Len = 1665 +Msg = C3A6C9A38DE76C9A716E9861AC10D549F0C5EB678DC9FB2919018B5DC88E365F9F3C03DF1FD9DAC46728ECE38E97465A418F599EA0674680EE6D3BE167E1C6D7E0750228AD7FD8C7EA070AB9DD73D6138DC70AC4D9907235DDA108E379E81F7E00B1C9E2B7F16FE8DBA014853032A619166BDC2D488B3AE8615CCAB2C2A9E1A2D5A38753D9B2422CD91599F2D5D87F89D6449491EC7418F4DD39C53DCD9F1EF9F3448E75E8A73C33C32EBDC3A613BB5E5490540B1C74E48CF9AEE17BC3AC2BE50F80CDD0C69649336E5545E612DB2AA400 +MD = 24C5F9AAEF4D1C2507EF097882FFFF026C378141F66F050CF61CA035110E6DF4 + +Len = 1666 +Msg = 0CE9C0A8B363C6504DD16AF53CA1028AEE93444E0A82A1573DDEAF6B41B7450CCD5120A72621983ECABE5BABB8CF0F1D3CC9E67AD8309D71B0355C3F9D667D1412982A0379EC376DB3B8D44D01AB58F7A97552DB4B1A178FB3FA15E33DEDBA345D7BB475731EA53F20E8D6CA0895B33117446094823E1ACD7A5A5632AF20ECBF94ED42B62169867FA6B4E9D512B9A4B443B2AA6A5752EE68C63CB42E5FB2C022C60DDBDAFA25E8A2493CDE12586D17089E9AC4A9E9CCF0E7FAAA5252049CB1ABE8DADC9EA9F552DA996B780E7B90144040 +MD = 409787A204CD78B9E09A24D4F728A89DB8CEB50F4532EB7BC34EC6FC93B461D9 + +Len = 1667 +Msg = 566EA91163B197DD99311CDA8083A3FEF200E9B5C84BE85A9F60D0AA73502EAD446FF757E4B37C026493573BBFE54F547FF6124E8F4C9478F68BE242664886695332185AADF0D68F38FCAC08AF2AE40F0AB98BDE182D4D597E6F1371B90D0FC4FB1EFC48804F528A2C6C4EBE47BE3FC4B74F0B795C422B4EA4211440299953714C51784D93329985537903ADCF14262514E2B576F916E2463712AE0B6DFC041B411BEC16FE050AE3018A28C6211AE20D65E053C5A68DB5AE09F0B5D2C22FFB9EC83D9BF7EBC54E66F0A01A2299416123A0 +MD = B9BFB2D909830AE0950C1A985749C291A38B995147D65E335D4318FEB930FB56 + +Len = 1668 +Msg = BC89FD708B4E589FDC763193633E4D86D65857FFD3F69BD8972DAE8B8B029C8CABDAEDD159B0D0EEEDBD8302C279A5EF5C379F1DE5CC7D8C0021221E04823E28BDCF6535940B0DB0E87F39731B8CC48B95608544ABD5E01E1E3BD4D24DCF20863D7EDC003DCD0FD458306D3C4CE67E93DC4EA2EF2B6F5A1EE908CA23E32984ED946E9EA2588E33776D926024FFC5FFF715BF87E424D05618D3A914C77CA954B8A80BC50624CCB8EA30E226DFB50BBB956F147AEF1BF0DFDA43A6114E5094E42E6B6F39B00BCBFBF2C600F2629C3FB66320 +MD = C6F50ADD6473168FABDA907CDF4F8385327253CBC7FAD16134840DAE360EBB6F + +Len = 1669 +Msg = B594C19EA19FBC4A9C7DD9DF4993CC7171ADD9B0E872BC211F60EB89D313CB5B5FBBDEB5D535AD20397550CA6534B859BA881D0713DEE6774471F57ADA476A511AE98414F07482F49F783F069D7DC5AAF42EFCCAE350A7320A4703254687258CB0B056558E2C6E31A2B336D1C36D770043DB799DA99CA06C38B93DB93F776891F2BF2BEFA70BF87C0E4C1383FFF4444DF05849D9F04699BDA9A95859BA5D038D42AD0EC4CE1AF15499230FBE9D12CC0998316266FB02ACEF9BC4FDFFC84E5A17FB2A605EE8F0239383A2DBB1E1A4087488 +MD = 5555621AB2A133A7E7E106284D61DF4FF6728CCAA805A546E24EA3F9EA81CFE1 + +Len = 1670 +Msg = 32366020205740D26523E6A91E2ADE18D6D7018535C132F17EF6AEDF034BD8D812739188436F1AC21E429C0798FB0435975D5555E34DC5F1B412647571D32B2180E53F45DD83BA97524DD38AFA67A6FD54E93BD33746D80E70B46D5045F2403CDF329DE154099DC721F6288191B9583793F0AF20774C730DDEF605A5B4C36A93B726D1CCBF9A2175E425A866326BE8BC1C3600F7C95200BC28F498CFD645757D8D90A2CDA7E6E15307F61075B78EB82016C0ED2DCB4F6903F71CDBEAA2DD273C4880B6EBCD601F1813478269D05D370D54 +MD = B106889E9AEFAE908C2510E43881E6404F356661FBDAA5DA738BBA2882432910 + +Len = 1671 +Msg = EA87C7C79D9C993C4EC01DCF55AD7CC433F8BC8101C9584455939A975EEAB6DC9C7DB7A00ED54CE15B473A26BA861C0E53394D762E2E72AC6A3930AB4E90E4D443C1B3E1CE337DEF21BCFBDA38D863D7330B33425A2251BA3D3A4935F5C1B62A2FA08F40983748131160F11853F05C1B65075FE224BC6289C31A7B93ED78C3C2428F14ED79CD0A2F7164979757251BCCC4A255F1E50DB5DB171CC05BAC9F893E9E86885392C66FC183232F7A3633F1D701575261B702769E161B8DA670D07B97DF1D9B36D24A28EBBEF639408789CDC39C +MD = A6D1C497BB3FD964641F3C00C544FE21B766831C5915E8FE2F813BD265DE9AA1 + +Len = 1672 +Msg = 447797E2899B72A356BA55BF4DF3ACCA6CDB1041EB477BD1834A9F9ACBC340A294D729F2F97DF3A610BE0FF15EDB9C6D5DB41644B9874360140FC64F52AA03F0286C8A640670067A84E017926A70438DB1BB361DEFEE7317021425F8821DEF26D1EFD77FC853B818545D055ADC9284796E583C76E6FE74C9AC2587AA46AA8F8804F2FEB5836CC4B3ABABAB8429A5783E17D5999F32242EB59EF30CD7ADABC16D72DBDB097623047C98989F88D14EAF02A7212BE16EC2D07981AAA99949DDF89ECD90333A77BC4E1988A82ABF7C7CAF3291 +MD = 5901CDA0CD1510DB5455D072D2737A6721AD9EE3272953A19C7AB378BF3646C5 + +Len = 1673 +Msg = 9ABA7C331CFD36242CABC3C6BA887C8CE4675F51FDCFCF49E706F6BC3C4215CE421D15B304F60CA6D19BBF8535D39F300BB415940FA23D8C788BA07970E0F1AA494AD3A6D988873E84B2E2E2A21D50751592C5FAF8EB1B30012B73B929C2734DF234F4FD7E0C2978B713A2B757812FF2D151D3C1C627E121F293F8DEA2DF2F9EE9A66E2859F635B615651736FACE4AC7E58D9B9A05A652FC0E6A9121B8D478FB04B5809E1994B3E3BC7E6A82D2A450071589AB46C6F5264838E425082B7D8BE92E49AA3632A2A54CDBB01360534080312600 +MD = F3E8947A1CEE1D41657D1BC6066D71C5960C6BE23053D73FAAFF1C3C36B4A9D6 + +Len = 1674 +Msg = 477BBAAF6240F4FBF19012F55396AC5E1C9C21AC4710866E58811E4A721D1E1BA2F13AB04EBAF2DF5A0F29C0213F8C7D3CFE34CBDE94A17D2ED0322A298F43123FCCC9A05059B224751607464C8B60DAE1E67A17B18F4252C2F54A7AAF4B6A5B52A640BDA2F58A7F86F61870FA5B7C2DC183CE5B1965DF783C30F63223551EDD62D563208094392D2EBF9C6C938AFBD408E08AD0A87ECC926BD25E784EE4D4D3C3C935ACBE870D8A777D7CE6DBBC675E32409748FE1CC641E4EDEEBEC6FE242E3A88434F93FF9F4677FF8994EE6F07214C00 +MD = 5BF3FE93E4F2454ED5B7FD3871786A78B26B4E20BFDB670123E816F9554B9C46 + +Len = 1675 +Msg = 96655F154EFCE33E6D9EB56C3471D5BC074E95358CAEC947B638FD63EBDC1B841A88FAEA4004D9E068341586D03437A3A3871255CCE036F4E7770B740A05B79016B9E94132DEBE7CE7BEA242ED7067927D4812F448E3B9AA9CECD01DE26AF84157AB79D3E50C83D1E821714A333D23279918C7C04BD999465B427919EFA9CC0A05936B42F3AEC5AF30874064A163D7E086977B32FA81DB19B6ABEB7DAF81512579885E9E8C257B58487231648BEDB6E33FF1021A97147BCD39EBCD4E2CA4228956DC674F61674175E16DF7AB56FCC518F280 +MD = 1BD0EFC94279D167729D85FA9E300B509F545975D77C514B4EA17A564C316528 + +Len = 1676 +Msg = 09FCAD77247BCDF3B8683ABDA5DFFD6B58C47C0C8D88A274CEE217B35C702B5C84F3DDF8C57B6947B6D04046C81CA0A4672D4780B9EB694AA4920FC0E01ECC56BD9E137892892AD2D31BCD491A23214825843897322BE5D33729AA22EDE7F21A115CD74DF0AE3CFE28BB610C26461BB2911420C7C4BA932626A9DEC6CD22A8889076949ECDC415F86DC788D73D733CDA4DA49D6F65E67E8F20BFDB825D8AFD898E5D0162EDCD536C2BC5F978A8AA128550DF987EFAFD0BD6799BBDD9EF8F3D04D534D5B5816C29EFCD43ED78F538AEC30850 +MD = 089952BE03F0591204C75A57177FB9455A85EED2834AAD77138AEA5170669975 + +Len = 1677 +Msg = AB8A10D700174B4B43C23BACE4393A55E0DB75135AA0AF3EE8A3A1F1102DEDCC427795DDA341DB51B2E26880B4240C904FF51FB0C78EDA9334017C07E56A5795ABA4DB246F3D477FA76F2B69568F09F6ABE8B0F5B2CF3D4B293EF76CB22A658278FDC4DCA98F3026E7D12417EB9928B9CE4A70F59B64E1DC834AC27D996E5763A867F354C50E73DC4244DC2FA350A7B6385DCCC8E9B427472759FDB7FB052156B10D34DAFFA4E71E60DA992E0C4E48FB3F91C6B2CD127E1D2B9EC6AECA04D54B1DCD9ECCB331D0EFAE15A2AF47950ABA4170 +MD = FA0A11F6DAE8366BD2628F383B4B7E8F997039B8A7B7D0A802494DF5BE4E5895 + +Len = 1678 +Msg = 05DBB0DFC9C650216514DAB69119695C0A0F80EB7D678EF91C8D0CD8123C6DFA6A88287177D7D9797DD5F84134D0A96451CF96664B7374EDD453E8FB31A106334E957224A434F156F3E9A83B7A44E54666EFBF25685391EB9BF541E2F6ACCED20ECEE46CE60423A744F5F5B7104E1F96A8D0C5E66D58AC121F300F88A3D017BF5F79AB64382EFC524DE1129C3E2E456D7203235A4D11F040A2520AA517E73DBB1D580B283797612838708DA911B5C7FBD1D4B48D41F81C87C7863305663376FB80415B82B8038E1686AF5D826B74DF282C80 +MD = 48A4F7B681C218E63719B98740232273DAF5DBE001A53B07A264420E2F898BAA + +Len = 1679 +Msg = 987AA5D10B8C1CE8D2A389535A7EF6392D68D4EC80819864603CB92860768E81225E2B1606B83CA62E8047291B9DCA25393B776FAA0C4E3914DD0AFCAFC21392C43AB37058F028A6EF330E6A3B53E3ABAFFE2EF62D126712C00C855765A91C111A89FDBECC5D5ACFC676B566B32B0BA6DA12EFF945A8886448A610AAB9B66B2548DB32C5B8612588A8D0A02F1E0C83878296FB2ACA1A09C25D438F8F2EC7875A61B9022FBE7F1BB7D972B0ACBEE28259B42A09B4F26105F1D0CBA58C6066F12FC2ECD14F286DF4635A0B691416127E34DECC +MD = BF91E90356E16F79F50DB9849C2285AB1A7ACE4EF4D64171C6F90508EC5A8630 + +Len = 1680 +Msg = 9F2C18ADE9B380C784E170FB763E9AA205F64303067EB1BCEA93DF5DAC4BF5A2E00B78195F808DF24FC76E26CB7BE31DC35F0844CDED1567BBA29858CFFC97FB29010331B01D6A3FB3159CC1B973D255DA9843E34A0A4061CABDB9ED37F241BFABB3C20D32743F4026B59A4CCC385A2301F83C0B0A190B0F2D01ACB8F0D41111E10F2F4E149379275599A52DC089B35FDD5234B0CFB7B6D8AEBD563CA1FA653C5C021DFD6F5920E6F18BFAFDBECBF0AB00281333ED50B9A999549C1C8F8C63D7626C48322E9791D5FF72294049BDE91E73F8 +MD = F64562D6273EFB5EBD027E0A6F38C3FB204A6DBE894EE01200EA249B747CFE66 + +Len = 1681 +Msg = 2CF3288DF0C40A7AF765DF75268CC32B63098A1E42CC6941A795108BAFB6EBF09EBC92949F1E92AB140B8CAC7546A3B51C923524B1539D22697529358BEC7EA462E92E1CDCE8B7A3081997A0EC9CBED66BFE8334EF651DDCD8A69C577BFC10894E583F1F443BB88ECFF1719CF7DCA3F8E7348EB721038E97E090D138C2F42C2B0A19EBB63FFFC4966D6377D60C64042AB9BBBA423A215406E21901AE3C6339918288596A1064B56C328B3CB54C6327ECF5FD741717E1BCA1BAD8751AE21FC13EE04E4148E1B34F49FD3915868A981F5BDD6E80 +MD = DE2A5177AA170C064EC8133988885342E41EA9FD9E00038F09E88CFD6DD7C5A0 + +Len = 1682 +Msg = E406B68F1C75EE4C12E73229919DCB8C1EC3967E0AFCB0D349968BA95EDC915654851090E15793B67F675635A1EAAD6347904493E88DEE6395D295F93E223CB111D325D94F5A34E11C5C8773C26614D10F28CB07822D6875D7B76D8ACBC2F5EE2FB9F08B87CA1A006065768264D81046E8C6ED0BD2222F70A81074F5DEBB3E3EB5FD588874C7D89131EDD5C826C3F75A38AD60EA417CA26B5F4AAA3E95B1E2AF4081B5CC1CF16E54651111432C58A367F532A6E87096706774BB9FD2C11A75E6B706B53EF5D4EE562E22621B11F47FD2284E80 +MD = 6A3C1DC5027161CBE85EDDD9EAB7CBB06221C54C8259E3339EF75A9DA6F494FD + +Len = 1683 +Msg = 6F551116863B6CA50D37C17BE7547CA8CBA1D34C93BDAF07BD94DD9D422099E2C896A73B5084181CD94F4325A16688A5D9392DD59C26C6A3619BB40FCD1BE58DDF8A94CEF25215077E734FB8CB52809CAD9A379608AD26FCF08856701FC5E1AFB2F9D5A042B745F0058546A1B28BC3354B11151AF38C52F058A41663C65E82EEFBBBEF366DFF01797DFCE4E291B1CFF9A1045F8B7F784DB6E2CBF7DC33B4F4CB0E4DD4F2C65E773B2EAD81C4899BE4056E45F840D473ECD394383C2CC8E0E5686C84130EDF8E6625AE51B3E1F07A0335474E00 +MD = 8DE961EE22ACB9C0F552A12A9B4746867593E2B7353A94E96FCAD297AD7897CD + +Len = 1684 +Msg = 77CE50C2A1AF8A234F2C50CF62806FBD5D0B856736129015DD361F6894AA9AB427A3151C2BF036953F857269C8C429BC7D715673B56FBC8B8953ED28885388569E15CA47E4FC31B3C4DB8FAF09AD46A7BAD593CAD9E1B5709531FA6F44DC70E03804BC4D0BF5D23A6D7C0C1B55F321FDCAC708879F212C0C917B72E33689635B80FA87C8A084A239BEB4B4B4CEBB40ED948ECE200D7003D4E3319B3A1589B62F5B34EB6D02071595CD26013EFD1CEA645454EC37DAD75A23E2A73A844364318F0D1437CC9B5BC159C3F00EAE2CBC3789C06780 +MD = 1037F16BFA15DBA16F834B4A5F66893F6069FDE6AA2FC2F757FB1FE5521B9DE1 + +Len = 1685 +Msg = 3388AAC4F2F412000389A9D676060B736C2D67263BDFA6E63BE3D5660B5EE69A2D5E15F81EA0A967DD47E1AEE70B6F9445B5AEC1875F699D5C4821F97A543754EC6DE498B7B59B570F239937712FB462DB40008792DD0FDEFBBFF6F333C8879C3284C3ADC5D20D6888F01F2A91602931990C90101CC26FF86D29C547AB80C00E2B001262F7EA283B87C822DB2A07A52D9C622537D3318F9FB1EC88FDB779B47FB33493E0D165F945FE674621AA0A908001C84903995D0616BA5C6BDCEC171F6746EDDD8FC9B94261165C7DCEA64900661D9978 +MD = C43B2D1477FCBEA51DA1C236EE1D79C0B318E5ECA7D5440B6D31575CF05B90AD + +Len = 1686 +Msg = 2CA96922D63B06A48D96B05B502F4E296B91D73ED57617BBF68278D0DFC2FCFDD6BD20548E6E717675FAE637DB6B5238A08982EB783B19E508DD5E87EF4845ED933CBC8755FC645E2E84859ECA2708FC9329B36FDD0F7178839D2D10B610769F791972BD93A4BB292EBF55BECC9F8152CE72EF6A379229E7CB0993F5590F6BFCE875CD339804BEE0ACF5F354706BD79909443F0B512DC7DB4C1EE3C0C171EBC0CF1C1DDEBDB963F6F880AB8CF357A93C5F551F6246526121FBE40E10B68C3319A2FED010B4F02B34514A5E7E5CE84616F4A0D8 +MD = 2789DDD488B064C33FB2EC86BA3C9FDA9E9E87D5148AFE250D19EC311FD0552F + +Len = 1687 +Msg = 9DA1EACBA5D0F46160540A856F1E212405809F0574C7524291A3D20B4E7CC3CDF5022DE66FDB79888BEEC81D0EF338AAFFFFAB7C5F8A5DA403E6E41826864718EAAB9ABF1882DD8852BDD443E4F23C29D05BC8B44735ECF8884505351E3DA083557CFA8663D85203CED742232F7E150F24B55FCD5B7B2D1F2990FABABE62A8F85435809DDDAD0E268554FC6258809062A113AE1755E747730A969CECD37873C8F99049E8310F676BF352C41A122F2D8E75D58862AB6ED4E196F2202C862464B1A5F4F25BC03F6142DC6EBEC5C30C2BFCEDD57E +MD = A8B38F5F2C286592F6635449FFB8F8102C72AD28B82297BE53C3410A1EF8B55E + +Len = 1688 +Msg = AE159F3FA33619002AE6BCCE8CBBDD7D28E5ED9D61534595C4C9F43C402A9BB31F3B301CBFD4A43CE4C24CD5C9849CC6259ECA90E2A79E01FFBAC07BA0E147FA42676A1D668570E0396387B5BCD599E8E66AAED1B8A191C5A47547F61373021FA6DEADCB55363D233C24440F2C73DBB519F7C9FA5A8962EFD5F6252C0407F190DFEFAD707F3C7007D69FF36B8489A5B6B7C557E79DD4F50C06511F599F56C896B35C917B63BA35C6FF8092BAF7D1658E77FC95D8A6A43EEB4C01F33F03877F92774BE89C1114DD531C011E53A34DC248A2F0E6 +MD = E7D7A113B3A33175D0ABD2CF4F9ADD8E41DC86C93C9552C5B3588277FBCAA24A + +Len = 1689 +Msg = 0660E0A141302B50534D949C8925E6707EC8992E5A2C644C7022A94D19271743416868E874FF8DB9B83F7307703DBA2C0B1E4CC533A1ACFBC16F44B103BA7CFF0FA74C026059E8B87530A1E8561EBFDD94E07DAAC12DB30FB7DD888E1F09B75A22CA86CE821639C2D2F053ABD75D10AF6080427F0B9A676A04BE3A0E45ECCEF9C7D228B423519B8174B420E6CA812C74C79D77EFF70F95545AB0CDD4274A22BBC9A636043BFF1E1EC56C9839119BE62F2E0BE9AB3036BC0E90FF334B60BCF6173C81FAB7E5FD55F1A5984093D82F563FF09F0D80 +MD = 80C7587E2F387E50FD0A2369719DADA61C816A2D90D5E0BF1267BC8E8D4231B4 + +Len = 1690 +Msg = F4B026CB6D798171DC89A186B1E41EE8E349C26F69ECA4E3768AD90B1F1C6F067D7EC0FC0C0464483FBDD806574F5738E2ABE34086F569C8A91266F7F09596D77B993C3DC612AFCB346545F0185D645A8EB83D1CA3FF7DD6EB7F679BBBB8F2E52925622807DF47E7E02D3B6A9EFCA343984642F36AC9008C0CDF899F9905613082B39E83AE4390F78822579BE7BF2DA24DE753207D3F2A3645F147FC113545974B2C4C563752413649B7B6CDCD7C578DA209F45FCBFF681807B9F5EC6DC003DB7BF59B715E542587D9EC850543CA6B9729A54880 +MD = 5D551CD1196AFC1A7BF4D70E991577FF636E83C4DB420515590384CA31C3413E + +Len = 1691 +Msg = 83659B5B4040A75E046DFCDB2179EF7A7680053C1C86498C4D9FA39D6C0CF3648E0946DA8EF5630C6430E2DF4F194C591D1912B5DA03AECAF6C6A440C6F41F304F252D40414239EBED0FD994CFEBF0E95248D229A9583E8C66F980F5B2D509EEFDDB28BA8BA55716D809B9030A1A2ABD663467E8DECA0C8FCB6B44D1297AFB2FBD1B9F44F37DADF1D3DE4FE301F983ED8222C3C0BAAEAA5216A421A0065D6DE18810538B17D5FCF00A98BF46A9B103E353D0D33CFFA04288DB928C0ACF5E1C0A748A2072651E32915E0CC1E9D745D2A6551C2F40 +MD = 0A82BA03F8CF22B98E89483FBA819C26A8B0D0362F977F99637EB96CBB08DDC0 + +Len = 1692 +Msg = 856F1B2F6C81E8A8C3C6532106EF4108B2FBA424BBCEFCC5F12D67387CE8FB8ED88C80B56A7AD4EB79E39FE779EE65BBA038DA0D7003BC16FE087DE0074ABF764F33D075C2F152415858B0E18B33C7120B27972B608838B5D8B4E303C569F84515ACD539BB53F583630F8D3BB28C935935D60B973120ED94A8678AB79800DBDF2D6463D26B587C630F725DB8C3F960E1BB597CF963EF543B3CC7A05FB81EDB7BBE6F893C631BB48310453E900F0CEDBF9EFE9FFEBC08BCDC198E46DB9156B4EEBC40F9977DF341647AE371BC4CCC06470A0AD690 +MD = 1EA1B727EC13EE2070C2D5BE2E820C1FE5C86BE4C5B5A2FB84F051E6ABCD5972 + +Len = 1693 +Msg = 4AD3F42F008EF17C88465189BDA1A33E2DBB52A1ABAAC899388E50B54599F3C2C0B1D2FD28B9343E82F8B7C5BE7558C8D611572B6D55845433E2546BDF23F38FEF02455F8D5C979BF96E237A3F5E9ED2E05E1023CC12FC0B6ED4136638DAF8AE1AFAC247F4DA8E37051FF13DCFF2DDD5FD8142791F067DA654A58EB0FD27DFFFB53FEFF7331AE8CF2D03484CA5680BCA02141B1219D6F2AD8A42EDA113BC2A250D9C960D568CE448C8EFB5158267ABCECC8B972A6BAD7B4F5E8D278B45DF1E04173120EAD2591CC5298E28D2E60EEEB4938D1828 +MD = 6A4682803D2D7FB2F4EB934314AD483476007F76CCF8DAF27CFF796197E9AAA7 + +Len = 1694 +Msg = 450EC015C3BAFA6F1A17D87AE57F449A7B868276783D0E259B7B05CC733E43667FCE3561CE954AC0C3DB26E86B52A9587FFA1F6CE15523B048B341DE8C868F126A8E06CC49717D9655B46359A2CA802BF19F93218BDDFBF8E2713DAE7B59FF826EE72F83D35B5E2807C8DCB2B6DD84DB5268DD874BF92B2D7E64F86EB8286F04B9748E117DBA480FE66CF4D7C5B2635070E866AB6CEB2D2EFE231EE88448918D327110ABB5CF90B6E7F99596723639A295A209A5FD0DD6C6D5EFC660546885FC0CDE34F441A4892780006F29C0F3297CE30EC788 +MD = 0A0C190E7174B8EF5734CBEB59B2943302D8786BAF6BA0EA3FFFDE7DD1B7F228 + +Len = 1695 +Msg = 82D4B43E3E055B976435EDE9BCD1F157601562B53688338BD2ABF33A8A602658254165B79514636A0D8541ED8983E0EE96E8E20148125981C7C9EF20C6ECCAC0A7A123066C3F1D9A2DFA3E16F515849BEA3F172E2C1C4D81972FD5FBF4ADD14FD27983DFC1C53E43E7ED296FFD496CAB119E939E3E3EFAB7A30546DAEAEB491C322E074DF3C0F4973CC20ADE3BAB5A4CDDECA7D6CE47B8CCB53070B62FB99BA28CC7EF69BB850A24C84562D72EAF152F915E544343233434E702B3F64CEA729BA16A3C11B359C900D30EE61DAB54E55005B30C16 +MD = 9D4779DA0D5777DB715FCD334AD07508D003911BC3C13E4486A27F226DDA78BA + +Len = 1696 +Msg = 3B8E97C5FFC2D6A40FA7DE7FCEFC90F3B12C940E7AB415321E29EE692DFAC799B009C99DCDDB708FCE5A178C5C35EE2B8617143EDC4C40B4D313661F49ABDD93CEA79D117518805496FE6ACF292C4C2A1F76B403A97D7C399DAF85B46AD84E16246C67D6836757BDE336C290D5D401E6C1386AB32797AF6BB251E9B2D8FE754C47482B72E0B394EAB76916126FD68EA7D65EB93D59F5B4C5AC40F7C3B37E7F3694F29424C24AF8C8F0EF59CD9DBF1D28E0E10F799A6F78CAD1D45B9DB3D7DEE4A7059ABE99182714983B9C9D44D7F5643596D4F3 +MD = 3B40C1493AF411AE7849904D478DF2407254BF62B88E9BFFD7B42BD2A60CE0FA + +Len = 1697 +Msg = 1BAC2D5646DE9AD40B20EB6C7B8EB53354B90BA0743658B3EE64F6B12F472CA0D3AA9F75A1E2AB1B08A6BCE8EBFAE3FB921B559C04D55BF8145735DE94A4F6EB5A4A82FF38D19E1BD5C8E84F1A4E0307C50DEDCEE7B493C7E0B7688AD9795BF2FEE617DF7EACE1BAB2BBB1A4D4CF2A363FCDD0F352B6AE39257F4BD0E3941B0714E28F8B46F89F0A238EC7DBDA51B4A18BD4B10693F3533F50148D6C30C1B46DE82D2BF5260B397CBD7F169EED2910D347B19BCE6ECFD5C4382A00F31BB88AF480BAD53CA75C32D0568C14A4DB3D4D50DA70A8EB00 +MD = 9159D612EB09AC16883DEC4A8703CBBC3FBDAA79266B8D351286813E6AA974DD + +Len = 1698 +Msg = 74E106832472376088777B910B6DE296F18678DEF09B672C268FB5844D9751E56CF5BFA6FA8BD1A5E1DAE84BC9A706696DFC1AD035B5F034D8A9BFC9175F3F6E351DD9625D0E46E3BD1829DB6B9E7E0E3A74A5BB5AF519946A86ED26EA21121AC7034DC6F56570EFA31C65EF26F53B21F8C1D922AE1E01AC42F5777BF7EF06C20869F60E2A8CC35E2476956C0BDE6BBEA9AB74E09881E2507560092A68582F8F2C5B050A6B06349A9F21BA72243BDC8CCE423DCCD9B3D1A83CB8108BD04EBECC4F11D6E4F66905A35C3DA1B1F430DE32338F5F0A80 +MD = 38E3E8D23013B9C1A5924851B20A3C4C96031F13FEC324ACC671CD6ECFBB67BE + +Len = 1699 +Msg = EDDAC5821724B9E4F0EDDE899155DEC46B0DF63DDBE51E8911B2778BBAD4A32B09B3FAE2F40D27BB7F450F1DFEDA4A891273B02867DD680B0E0B0EEA70B79B81FA8EC0CF94E7D7CA7C1FF4CA53834760E0BD781032312DD5B609C30F37CFEF3B445250B67023C15581477ADF21F5BEA45A2CE4C94E0731832290167713A42CA5E08545E6EDE35BB9A9A58FDC4729862043EE68A51F4328B8DF73B320A436FC01C2BA93283782D506A7728A7C2D360F4922D9553BF9BC37AADCABE0134BAE04357F938621631AB25A457459BA1B7D43827A2726D720 +MD = CA6ED878610366051125E8706E400D3943FC3E82F6C442E3850AD0A23A634463 + +Len = 1700 +Msg = 34B7D9773CA69D76B7EF15AD792A7353D76355E7DEC7F922186D04CD0FE70042FBCCA5821AC45B0395A99DC69F0F828204411E740219069DF078711B208572E7238251D953003B9380E72A39F3EA0C82C56DB020C38AE3824D2C209E644328EEBF40101437F823181DE665D734070171CBD6367A09786A2CA5B75A57A18C55687AC022B82E9D36C5E473F4D3C93AD137971DBF7DF1ED505BB156EE850EA4451C6A7AD4E6B85F47275473F01C2D8BECC4EDF5EC31A0DCBB4AC3366359F6D0DDC1A89409CDC624DC227F7CEF00B91BF1333932510610 +MD = 1F45064553A37124651A6A17383FC0D1166C6B906DA8BCB6F45BBF6DCB3EB5ED + +Len = 1701 +Msg = 25BF5D329447C8A7414999D32A955EF80D2B7AE38E1DFDADC0E82EB94B96AD8BDF99C24E742B0503E80CF897A6E81C2B613FA2E7CFD34F1500E2B5D028DC6294CF89947F16A4AA54C1C58F9272C17E76970ABF412629BAE4E88DA49DA0AFC676DB1F9AB23F7846EC6AA9DF28DC1E2654869C663A25C4A803529002CA250CDE571029EEA4365BBD2B16E353923DE5D8F4DA452C1110C51447128E55444B8643704B668598B7B42389C5A92AE193EEC1185CF7189B987E2EC23C1499582091D8930143573B03360D420C2E4F6EF5D4A710F4C62C75A8 +MD = F33FE9615F7D185A30843753E777F6F2B96C1088461120EA5B748CD04F72647E + +Len = 1702 +Msg = CE4F3CC47B14C9D6DFF5ABF17DF95B015F7CE226A4D4EF1B41AFDE76EFFDB7FAF342567D413BFBAD868C00AF20FE8F95CD7E12AEFDC6085C6AB2AFCD302C0AE10724AF383E8292E01BFC5F89E9420324989FC63817F7C967BDDBAE816AE7C7CDC27AAFE230479C1FDC33D64C98199DEC3347A6E5CD90034618A40CF87203287B9822E712B73A2AA32B5CA917BB756F1CC22D41F197354DC21368C65148A431C5E9285D9F8F2C9CB0352339BE6C46FD6D12228B2D562A648804015CDF03FBC8FE3C1B784FF8718865143BDF9883F3D2680E41C9BE64 +MD = 5FAF3D03F34E1D5F4874D42B6E698F4EEAB21B8BB456DB228A4CDBD0FF6B270A + +Len = 1703 +Msg = D2D80B91FC1C69E71F6BD25E1FE274A83FAB06249F909780059C3778EFA9DDFF75D5AF3A52DDDC219A6F0E8AA796E9D65103D90CFEB032EDB567FE9ECA7E86B0D66D1D2F550F07C7364D323564C8F3C41124EF4FEF8981CF611BFAD99DEDDE8E64E5E6BF8D9872D41E03459DE9CA7EC4772E08A6469ED35ACD59FF428537721C07AAB8FB005E6F2B3E5F01E7349B3F20E79D7454A2DE51505FDA1698B5E54647313F2E839E7954B6ABBD32762BF9C57162561EA101650AE81AFD766C7AF1A7EF0A814D6032C59220CBE449765A4D34D59BD104EDB4 +MD = 7472DFD58381B4A8F23D7524E7EEF0AF5D7AA67DCE19F22BF84F0D3F69DB999A + +Len = 1704 +Msg = 3434EC31B10FAFDBFEEC0DD6BD94E80F7BA9DCA19EF075F7EB017512AF66D6A4BCF7D16BA0819A1892A6372F9B35BCC7CA8155EE19E8428BC22D214856ED5FA9374C3C09BDE169602CC219679F65A1566FC7316F4CC3B631A18FB4449FA6AFA16A3DB2BC4212EFF539C67CF184680826535589C7111D73BFFCE431B4C40492E763D9279560AAA38EB2DC14A212D723F994A1FE656FF4DD14551CE4E7C621B2AA5604A10001B2878A897A28A08095C325E10A26D2FB1A75BFD64C250309BB55A44F23BBAC0D5516A1C687D3B41EF2FBBF9CC56D4739 +MD = FEEB172AEAB2F0DEB748FB77801CA22D3CE99B7A9F9789E479B93D1F4B1D227F + +Len = 1705 +Msg = 231AFF791AAC840DED19CF4D259A955CA2993A8E60727B451552E83F26A56506E6E635F43242946B2B1629E687A3162EE47AB6A32F7EDDF3BABE0D9E9F253842E81E092DAA9229FE770AA9E4189820DAFE92406F30874202461D10204A208AB90D5EB3582B636DE48D2DEBC543CA2023C0D12FC14F34E2F62112F9CD0B6295E2C1D37408018B424A79C319A048899A3EED77F8CDACE914037716C23E73E3C79B6D7BAD4F1EA0C19A60B0B7FA3C07D90A18B5FC9C0A6A8FB7CE62800871053E4EB1AEE0F3BB1928E9598CAC63BA44B5B54772E4DA8200 +MD = 5485C3838864CD651A4365F56004822C999D8C8DEFCC8EA65E98139DD486DDC1 + +Len = 1706 +Msg = 7AB9912186325DC1DF33C032BB1475A10B90AB8C15B2D26DCB2A178903178C31F6BC88B3BAB84AA16434E9302FACC0C463C99375BF2A05EE35D53FAF0E4BE126FF670F2A1783FE23B31D22BA224AA4E12F4B1068D1D837F1B0077A186C73F96D846345FFBBFCE48A21A6C51F0788FE52E4938B59F2EB1FBD0705DEB88C893151B61FE17E2EC29BAEA4889C14236ED992C5434358C0E3C3296A6315473DC8DB49754B68DFA97B2DB837E155DA5FF5E4241DFBEA2857F4A08865C9A8B6DC958906DDA95347E1E59BC1308F5B2FA0BC8BD8969465C28440 +MD = 95972AC3F63949A0D085FB253FAACBBB876EA6C75F744F0C4E5CC5D86ADA4C7B + +Len = 1707 +Msg = FB8C83012A74DE84888E3D41279319F93332F920493A71B81C6F217C699EBE842251DDB02625F3B5295A2EEE825F4B9087F42334847EE290CDC6B7B8B28E67ADB5EF6E4CCB455BF73876797DF7C39880BAFDE4B9E461770B0CF118C66703519DD42B6C488EBBF0135E22C35E31491C595ACC3DC8DC4C71E4B028E88F9552D2A9E3CD98F27C0D755212B04D35046ED8FA4F1F5E8534B6447615C78A823A9E7B4546FBBF4E29B51DB3C2A1ABB391A5F6F35CD424106ACB645590D20DF58FE8D564BE7496313216DB51BD3DEFC50840455CA48E7FED3BC0 +MD = FD9A4ADF294122F8A6D13D4B7EC7A47985B30CF3A851E761547244CC617431D1 + +Len = 1708 +Msg = 18BD2C8E4D1220A39AC90CDF0295F8A8BA1BCF49177752713A3C808AEF218F12C4F0FFC030572704FE1871ABC2588FCA54566DEDE0EDDD608CE7058F0CD6D63DA5060EFED342AAFB642FE01E377EBD9D6BEE63507E702D270773B4E10FA4C066D25E4AB5BF16FF4FF4407D6E5451C23548FA4FC0266EB5381A472376756ACA6A94AA02943B2DB286EAC1311C4A354D236A3924AFEFC1C82D2B2C1BFF7B10E25485006346B6E95ADAD69AD172BEAA1184E00E89870FCF53C23C2071B0529A9D09BC9CFE182A869EB793E2261FB0B667D52156F3628C50 +MD = 2A728B838197FF54339073F7BFF63BDBE2E285F5AD3FC5CC3C98BA8BBFD7DA55 + +Len = 1709 +Msg = 347D043DA6E918EAB702D86EAB0CF7960C0ECDE65988FFD03BAF9C0E020884257447C7EABE4D7FD9435E1419024400F22CC10D37B51D59BE721E7D8AC235C3E66989538A2D8DCC8738B214D1DB81D0ACE89DBE6119E8D7C81CBC510F2DEC5A809F5AF767C8E5ECA0EB2736563D85DC17824CAFC2F6AB039B0B49CB0F456ED52F4FB3AB4227B80B5E9F12F167097866551DC5921F04364EEEFC01C0C3BE14C03713547ADA71CA681B753B647F3DDB5C27C405C5FAA5F5A752EE27CD25957FC1134C1E442545D8B585631DD18F2F858B3CEF53F57BFEB8 +MD = 69A2DC276A0D80A924A9EE7A21C0FCA7997D55C06894CF59547AD6FD1DC1FDC1 + +Len = 1710 +Msg = 465A614C0AF40580A27871CD12DA42D1EBF9B7D9D4CB71B4F8E1A25EBC99CB36BFB99B8B8247BEEC9A10FD5F278226624F8C3C861D14C533F9BB0763DD5F394318F7BB67B4C763FF9891B7366B21B623B260F26AF524929C2E07733C9B8711EDF7C682214A1E740ED16301639947CB42F049AC40BCF3AD45D498442DE1BCD0702256116D2F24E6FF42049A84843AA71F923325878C7BB7C6AED482B103D56B1140EB673BB958B9363E3F71C693C542F8536A3D859326C987C27EE95B76B7E4C855E8E758B02C8AA443E6A1D88BFB1656F4332D070128 +MD = 6033A1885C81CBD3FA0D0E42D599FFABA052E736789EF31AB0BD33C7B0A91527 + +Len = 1711 +Msg = 52D90524A8479E97249EF04DCBD00D0D53A500466FCC2E0CDE71ADEC409A11FD57D242103B77D9298A7D213445CA13C1B985A4149BF025AE47FA4D55C0DF836B607E9E8F9C0A1F73EAC9F67D2FAFC222D40047552FC1BF7B39BDDE7FB5B4D4E3D836AC9412BDE2E91C98DA15E2A08B33C446A2B1ABFF97960EBB426744806D712953AF4B293F1F79A1F2B5389EF77EC13FAD66ECF4DDD8F54BCFAE99032BAD76911ACD9A0BB0A4C4D787F33F364551D913BD9D6A91372CCCC9DFB652586C99F719B17586C0839C4E60654126E6CE46A3C672FFE0D528 +MD = BC0EFDC1F30AADC9FEE51102C92700388AC80D528700CAADB002F8EBFD3737AA + +Len = 1712 +Msg = 7C7953D81C8D208FD1C97681D48F49DD003456DE60475B84070EF4847C333B74575B1FC8D2A186964485A3B8634FEAA3595AAA1A2F4595A7D6B6153563DEE31BBAC443C8A33EED6D5D956A980A68366C2527B550EE950250DFB691EACBD5D56AE14B970668BE174C89DF2FEA43AE52F13142639C884FD62A3683C0C3792F0F24AB1318BCB27E21F4737FAB62C77EA38BC8FD1CF41F7DAB64C13FEBE7152BF5BB7AB5A78F5346D43CC741CB6F72B7B8980F268B68BF62ABDFB1577A52438FE14B591498CC95F071228460C7C5D5CEB4A7BDE588E7F21C +MD = B240BC52B8AF1B502E26BF1D5E75FE2663BFBA503FAF10F46754DC3D23CB61C1 + +Len = 1713 +Msg = 54B61F11272B78B0FDC95FC10117A54D290E051D004A8C3EC2C95773CEEE8B18DD7B97B655C6498054C0C0A5DF34A0FD040C20C46D5AECA2094D4EC1E59B7558FC27E179110D058782FF3A2F627A91B606FF35BA0C1A2355D7388D6EFDFD97147698B633D4D2843F040BE31E483D3102B8418D8A8A2EC6FBEB1DDB291E04BC18F01D0EFE92E6F72F49D9D64D9408522FCD12E3BC8B6358CC9F0952DC0783E81FD11450D20CC37C6F526FACF9BA0C04464C45772D3537F0767F685C71D3659B88953C244A5F82B01E5B0C2B106621C70DCC3179FA9BF180 +MD = 951FF583973BB0A288C9EBCAFF6828603961370915331692D15384ED188DA13C + +Len = 1714 +Msg = 1806F931E78B282F08D9B153982963BA7009198954F820F740CBDA4CCD4F74712A84968E741F67E81B0EDD71B53D016257B9021D491CAB64AF2953DF73E2720C275849356966734422670F4D385C2916E561BC89C432FA92A81EFC9FFECB2E59404066C346200514E79E46C4EE4E351DFA8BED90CAC2DEECADC4F7EE3AE381146C5C21EF3859CC9A231DEBC71E7E5DDBADFFA9E7DB7FB86B3682D7142ECCF06B8D78B50577CC03FB9EB0006BA63174871AC7CBA303B87EB9C69FFA31705AD943381338F46D3F216232411A936064DCBD4E3A0B38D82D40 +MD = 9D9018FABAC206F0058DB20090924BEEBD16E2AB6167C03CA3118BB0C6519D1B + +Len = 1715 +Msg = 55A7A7B48849199F1BE5C9CA6252C1BBECA9E3D4B9A81A085D201191EAF2290556054C00904F2F854F7208AB29312EFD205F95D3CA4CC26ECFB02707AF4410A54031E7F7727D72A1B7B50A031D866674306511224B1057D9920177ADD762E391EDC1269F0D4FFEC5689F9C2EBD22167B708173830479C377BBA8FCA1792607273FB4214DFA3A5130963A45C96D65F0FB230AA1DB3683F9C58CED7F5555E757B1B596FB79B54A1E61D5245763DF724CED620DF2F048EC703988B3D1D307DF9CB6B1A78A344782FE6B0F9AF5F5C074AA4BE1D596512726C0 +MD = AB8D36D88CF66BDF58578DFA032B4F749C467B9412A3F4FD41F89786B97F7AB2 + +Len = 1716 +Msg = D85126F4772B9166A15AE05551B00F3F0924D1F0EC65E9109F164C3C337CE978AF02477FF217EE571A17DF901A158F02FD8F79D64F09CA11A15B453480E08E46F49961C6CBC4C6FDA9706E094682BC8C64F1D74BCFBED70C389397CD76BDFB52A728484297EF974C0E524682C926697B2D33AADA7E749E930AA78731164E08C2EBDFBEA1BBA1DE7739212E14DABBA84B502C3F6550EA79022B7533B270BD6168731B7F72492A3937E12047FB4DD3D261EE6DA38AE01A4110E0E1FFB8E503E0269B1CFD43D2A4C1DD8D3189E5022A2188CDA4DD60C9D400 +MD = F64EBA5B07BCEBD121870F7BF0B35CC30A8877FB39EE1471508157BBB02B3177 + +Len = 1717 +Msg = 74573A14637C34B05ADDD60A85BF22DC7E818D04EB94DAC9DAD5EF2891AF122599438F08CE2297109A7AB161E163D9BEE71C366270B6BE4E8F92D4E716FAA3ACE866C049F4BFEF5E5CE5F6A5DDA0C877D17FE2B179599C80B75B2485DEE6B912C5720CB63C906AB77DF480FB9AA3A8CEA11D8B2C63D88DD3AD6ADB8311197E469818200B52C4ADDD51D13D6DF3F3810AED15890A7C1F9388EC296CC79905AC65E006DB0DB3207DF7674874D733AE5A50C5348A208D115E247F023766E1D9F3DBF3769EFA1F5CF950AA6DD903CC36FCFF08321D71D7B2C0 +MD = F46E7EC7AE4F0ECC6A14BB44A1BC3B6BA678546FB08DD94CEE7D7C9762651D30 + +Len = 1718 +Msg = AEB43BF2C27EC6A64D5A8FF892C67B282AE35FA1436323F0480689249AC3A552EA43AD8B983A4DA901A024403EB23CC3A07EDEEF1B0F836110305CAEEE070FE0254EBB70C17342599AF6ACACEA2392ED56526FA0DD9B5513309D0D6C9D5C222370144B531DC0897B80C0FAA16C050116B74BCE3D026BDF4C2AFABDC67381BA6663C47E509012B8EB097A86E5190BD32F8F8BC1B51F3CFCDEC3FA844358671B42F7F510ACEB9F3BF3C3449B47E7F64997EDD5B6E4F5B8A2241F4F8EDE88D0BABC7C10173F5C51C27144EA745D11EF876126D487E842E57C +MD = A38464BED5BCB2B13511029E2927BFDACE8EAB1FC256A0A0BA20E6B0270FD3A7 + +Len = 1719 +Msg = 4E6558C1D4F2C474AC32B623E7088FB80820E127A90D9E9BD584F81FE3BD701F5DF85C57248FB42E538CEF05A5139D4B6741D6EC47361EC47558037F7B3606C351382A0132EB52A42FA75E16F043B16126F3A12D50C5A28CDC7EEEABBF10C081C56163DAF2AADF5ED706D568E167A843DCAC64C56AE3DFF0017CF359115F22528B98AA209EAC24734870C186998FDF32CD12DA1B8C95BB103650D51FE3766397C23C202B40D146EE82CBD25BEEFD79CDF94B6E8C90638FC23856728607FD873A683402FB46DE44E746E1FAEFDAFC805170A72AACD03620 +MD = 8C173825AF6E6B00584119451959729DC7BDF21E82E8EE9E304C6BFAB8A52323 + +Len = 1720 +Msg = 7A6A4F4FDC59A1D223381AE5AF498D74B7252ECF59E389E49130C7EAEE626E7BD9897EFFD92017F4CCDE66B0440462CDEDFD352D8153E6A4C8D7A0812F701CC737B5178C2556F07111200EB627DBC299CAA792DFA58F35935299FA3A3519E9B03166DFFA159103FFA35E8577F7C0A86C6B46FE13DB8E2CDD9DCFBA85BDDDCCE0A7A8E155F81F712D8E9FE646153D3D22C811BD39F830433B2213DD46301941B59293FD0A33E2B63ADBD95239BC01315C46FDB678875B3C81E053A40F581CFBEC24A1404B1671A1B88A6D06120229518FB13A74CA0AC5AE +MD = 3EBACE41F578FDE6603E032FC1C7CFEEF1CB79FE938A94D4C7B58B0BA4CB9720 + +Len = 1721 +Msg = F50014B208EB74778C5E65F27F3B7AACD008D7702D56890C769A6A62E4A9BD9C2A9B7E62653B061AF29CC45E37A4E8160B21B5EDE780F0558E1A94F1F23FFD17ECC4BB543F0E278141ECBBE2D3E7D252E22BB87CF64346661B56BC725D90B655E3B4820ED7D1E055232FDD8B08FEB0DBA125C05C42633ED8E050A5D98E4047F64BA217395F9503983626F1E6E0E5768A049E94E7207E9CF9FEA593DEEC252CCCEC7DE21E9A1BE2347A5BC3A0D878C1778112B4F94B4123053B0E1BDE994B8444B7CDF1FEDA2A28FF8E3343501B58E9ECB7AE47354BCEEA80 +MD = CD904F1AD18E8856BCF75A9813C7D79117BF654004559C2EE41191929489EF88 + +Len = 1722 +Msg = 63FF7ECF12ED74A2E1D9162ACDFDDAB310EF6AEF426E53B88FD29759A6B6D9B0CB28E22C67A1D294206EDE4780964E0C20E27F8221E15E2BF34A3A9F3B38E573AAEF778E6A490C4CAA18729E88395BC866DAF1B2B2D3391F59C8B9699C8E54BF0A758CF5C3A8B097D606B9A6A4B3792B27F132CEDD00E105F2B85D6307664FA39A14270DC402C308409A18695A93BAD45E071CC235CC1F84C418C91081B0554231466700D8A7FF1790C1DB9ED496AC0B38655154A3BD5C70FB9466CA20C69170C4EF3DC18323C36E5A0EFAFBFFB017944706F70D004C7240 +MD = A0202313C5DD813C0A08418680C0BEBA173F70D6D5C69296249389427CABDE8E + +Len = 1723 +Msg = 3D02827ABA2E9C794A33E2A1ED946BB0437BC419CE5DCA92EC886531946C96A8D261C70D5422DF0D04221CF0AA4339694C560600E757D6539518B4347D341CCC5A57613A29DD31301C0C0055F1FFC44BB15622ACC47DB80BA50EEEF8226647F7D5F3FF8EA03A968CC6870157A8CADC9924BC9388A9748F7908423B344D915BC29011ACCDF57A04F4400B1C848B493AEB1BF9839865F44BFCD4D643B2FDA2E20B883D5A2368B137EE700D3E83D8E9FD01661E869E41410E686905BFFF2983B6C5930346A8452164972F23715DC9ABC673B0D41C92A65B89E0 +MD = 01ABBDD47384C211E828A6E3ACAB8D63258B9B0B2B6BBF6D3AAC30DE0118A450 + +Len = 1724 +Msg = D6CE68E12CD933EB93A09F6DDB922855604613B4A76CE6F5D6C58991779720C91E652C70B380960ECB409AAD5761DEE4A3DB5C288EE7C13EA16E8FC7FD6BC6C9FCE77A4B236B99314E1745AD8C2425ADC0B4D8F746D8E972FF584131A4ECB2C4038C0BC0B0FAC7BF1249CBB58215EC07769F8BB2E78267D57B978E2BA09DAA70E022C1C57005F33D76718788AC81817033AA6A0BE89EBFD3DE3E5F8E743C1068D3663EE22D206273AAE6A2358101C3423F1DC99658B7916C581A1C39EA42CDDC180E7C8B136CB633CAC407004B503C4D0623FE3107B1FA50 +MD = FB70947924E5C2C06233BFF3864B23CCAE091081E162DD982206CDC504DEBAD3 + +Len = 1725 +Msg = D22AC23AF99096368C3C7992DE621B9DFF7A2B9EB697064E2DD184F7A4BD3DBDCB76DE8520F627BB7BF9DA2016BB04957BD202295F262DBF7B7008E10C5BB00D70D7615E7C1142C1E05BDC05EA51AE81D03414E28B0B61DD78BC8B5BCC06776F4006CB04AC5B0D417E557DB9166CACC5DF5A514C488FF47E42ABFCB87207FD5240459F2C6A723677A4DDB636EA83CC0A323D7609F0E03D800F7767E220C52D5FC828AF4FF003C7198485214F1CBD30A9757129F4FA1067F3DC896EADAF0DB3B78923D4945A90F731F5C1C1DC07666CD651D3BA6DF6E922F0 +MD = 0768422D13BAC93596F89D34998EC4C9547107FE36611DE83D3F1E250BCCD266 + +Len = 1726 +Msg = 0D7B88F3C598B66455959C84D2636CA1C834B73D7F56A97AA07755EB99C4C8BC9016102A1A6A5B45ACD2879DF56F79A1CCB54CD9B1981A3EC9B6FAFFDAA8ADBC6F5E64A3E75594E0659294FCBEC07563D40088637E8771C36BAFE082FD938ADD0904564D89B9FC697EFBA9A0161C3A46014D77901F42FE1F27721115988CBCBFDF5A93C6217E32EA88EB18FD9E7C248F5C43593F03F194E4D3EFF5B85AB474A653E5FCA0D7FD955DF0784B2823DE88A80D83AC93F634A06601D3378CE6F318F63ED5B3F478E61468C348B83697EC9CC0271A99D23B0FE8B0 +MD = FC0341AD4D675D5183DF5A16ABCFCD7B1788A6B4F4B5C6E5ECE0238638015887 + +Len = 1727 +Msg = 6D058830F672327A9003386CF0E0EF22738E2027B4114991DC2C4BA6757A62BDB190E3414A4EE979F172BED470FD9D9B085F62D4D9D05621140ED834BC8FC25A8DE066846DB9DC7920B4FD201567C9B7255E41A4D724C87CB7C287FA4BE3D5DF6A1ABAB78F3C8386A33B5D9A03A26784E63999C8C7DC784F541912786E1DD524E2A9F0BB4B6EF87FB1CCA144EDE9B1576E45765589DFAAB5CDED2A025556404469E39E95C74DC5FD11A0FA7FFB21423298B5168C5CEDC34762C36BEB2A1B6BC90E691304B661C638AD7E0BBC2E7A6B3CC87443079D73D1B2 +MD = 6B8D7DDB14D3929F8FB5E0237E2B34731A9CB473BC8BA83ABFAE0A8ACAEBF3BD + +Len = 1728 +Msg = D9FAA14CEBE9B7DE551B6C0765409A33938562013B5E8E0E1E0A6418DF7399D0A6A771FB81C3CA9BD3BB8E2951B0BC792525A294EBD1083688806FE5E7F1E17FD4E3A41D00C89E8FCF4A363CAEDB1ACB558E3D562F1302B3D83BB886ED27B76033798131DAB05B4217381EAAA7BA15EC820BB5C13B516DD640EAEC5A27D05FDFCA0F35B3A5312146806B4C0275BCD0AAA3B2017F346975DB566F9B4D137F4EE10644C2A2DA66DEECA5342E236495C3C6280528BFD32E90AF4CD9BB908F34012B52B4BC56D48CC8A6B59BAB014988EABD12E1A0A1C2E170E7 +MD = 65EB4BD5ECCA7164CE9B66727F112C1AC6120DDD200DCB5CE75B7487843FCDB8 + +Len = 1729 +Msg = B0AB1FC29576BDF5BCF22A14049DFF38A48B5CD9749C95E4733B18039606DEFD52A73B190C10B59EED4297384B928E6E60304F145F45B3BC4B72A68BCE4EB4F644CEB3E8739881EC43F36C7489AD32A207F3921034647DBA76DC0E41E1358ACD2A45B606BA8CB75472966D1E0A2AABEB880BD837F8317EC8550F326E712AED4EB4AD11CDB6F4FA597BA30954A09A1E386B7E335A45FF2110E6A365876C8BBE5C4475906D0D2400CDFE7FE4672BE6A5168748E11F73F155C3AEBDB3415BB0BDA5BC07F9C2687718B65F1C753A52D09B27F4724651BDF2D09F00 +MD = 8B004FC69C99677D0D210FC18D7E7C403EB4F706B7C95231BC321806EE890ACD + +Len = 1730 +Msg = 5EBA9547DA91D476A5B6E44447652756F86ED187590326EF32D18E4D05D05678339AA640B22E029E6C22FF5CBBAF154118F219E3A8EAC24135F2732362AEA3177321EE3DCAA7A94BAA5B04E69D83F0E99E1EDC58A93D0B0BEF8F3AE7DCC0B9CF5D2557D225567FB2C768C59BA8EC70F5C05E480232A64C6ACC0C561BC13BBD28A5BD0C2CE2C23491EFEF39ACD313A777FAD4BCADF0667C6CAD1B8BD8583690FED2F6CE17C33421944A8B3CC62806369D302621C11A66BEB642526308945E5FF32C37DFE81870C3987EA69BE829C83495CCF7D929BDA8A85240 +MD = 491EB3827BA117AF4C228E9D4ED230DCF8265336548932FE9E86CDF2D8482E34 + +Len = 1731 +Msg = 7E2BC340635BA8777E065C7BE34A876EB20A8DF3170DAF70DEBC6CCD47C2EB126F5E3DCF692FDA19B751B3EA503199CBCE86177AFC261E0661CAED6884CA4C109DD2031CF69EC1EB24BCB73CA622DE18B43C01B1BBBF6B2A22FB4DD6D3B73BC1C2A8BB6085B7971F6909ADD9C5316184F5370889F5FEF6D27CEFC4291202A90620573B150EC3EE31262C455517FBA064AF031F74EDDFC05648AD7BE1DB52CEC623CDA6DE842676AFCA1AB318CACCC8FD137B65044C4EFA0B647CC2A0ED3D075DF0877D42116800546633A445C44F21079661EC7B46A5B80C20 +MD = 573990A6D6636B5098262F5294AE6D5AD9593D9276D6F0CB03C687BB15CAB533 + +Len = 1732 +Msg = DA35B0DA3A478D7E4929262859168B4B717F5D1FCDBC249763B5C4FF33B7781822BF98CE97DCEF54AA4AC8B42A4FFAFB5FB934F29DEF33363C561B606FED6A0EC0C2A3FC746801B87333D18CEDA22D9B519DADC6004FAE5A3320E1CA91D9225C47CEDFF521A349CEC7BC34BAAD64FED23BED387833526E22245B35DF621F5DE0DF72588B95E98A442242826F3A38F19F4648606EA28B68B3044DA72831709DCF8E65BD6D047DD81DD83FDFA262757D668FEE6FD65527B01EDD0A6D14334503225BD15CC41EB1D5D6075282913C801B43438AC6EB752A018530 +MD = 6D6E29121BFE38836E900AC2B5C1D0FD200136CF1B6373B53F49D566FECD13BD + +Len = 1733 +Msg = 4F18D64F8FD0E7C23C75EB389D165A47BC97E57ACC4E415430C9C2A89E1A2A0EBF7B58DCEEC95CBF998D4373ABDF564272CECCAFAEA835026CB62DBCBD0CB9CB38BB21716EAEF0D4F288BA31F5269DAF12C9B50B21EE38B2A620FBD9499784B73A9CC8F6488DAC51545A680D07978A961A517181BAB99684FA2380ABEDD5090A446380995FCDAC7A9B8A45E49B3A88F7EE37DBC147521F902564BD83F7680D4E3F5A96C6BC9915E5E8A8D850B0C8F37B878623AE7EEE57D704FCF4163D4EBD2EA0D665C65F85CD049CD3C4F930C1A2B2C9F05F9F79690F2C90 +MD = DBC67095FC446F410874E215785ED9F567D3220C6113199BF748ED42F42A9656 + +Len = 1734 +Msg = D165744E9A601CE8B758FF58406FE6D3038A1FF50C98B9AB59D68A23A19048268775FC65142DE0080D954BA1C9ACD44203C1AEE14CF2595F3104393C0421631AF62C82CACFC9D08311523AE9D533A32E353800B73B9EF0F276F2E68846A2BC84276A1F6FED9A23D40B4B664C7922C609AC86DC2F55656CE92BC015C9BF1FA7AF4F1E42ECAA6EFE2B499DA3092D0D89D6961870D17FBA8753ADC69CD7BD3F6B194AAF4A2EC3CFD08E25491E63502921E7CC10A5587A71A9CA0F16B98196EA03C4A72BB443C80835B9A21C48586198064D12FDFFAE79726F93DC +MD = EB5E688ECDE28CCF2B317BDB970EEE540966F593E23C50E5A5BBE0ACCF77D88C + +Len = 1735 +Msg = 24DE7418E94F7355E13E5D931BBAA9D4D54F10343459F224C884F367C80ECAA3C80CB17BAE478FA79944AFAE0818CEBB614A7F2AFD8CCEF604A952A35351A95F0EFECF03641DD7B82B2CE046A3C6CB3AF281597A4E87F2E322863DFC1B61DC52793C6FDCD107C5AAB3B81F75ED2DA006569C7378AD3D418B9086152C58473660C61738D1C33BD74867F3F94D133E6708F34F8456CFF843C99258ADDD2B9DA18A6FDD87C9A530E2330C0BC6731AC9B8BEE51FE3CC3D81B07304002DAB6DB3A43BDF45CB19E03873682A1041ACB6423BB638DCEF04AED9F7DF1E +MD = 9076DB8758EBAF7F69AA63148B1FEEE4C04848BB35C8D3324982AD8EB93D060A + +Len = 1736 +Msg = 2D8427433D0C61F2D96CFE80CF1E932265A191365C3B61AAA3D6DCC039F6BA2AD52A6A8CC30FC10F705E6B7705105977FA496C1C708A277A124304F1FC40911E7441D1B5E77B951AAD7B01FD5DB1B377D165B05BBF898042E39660CAF8B279FE5229D1A8DB86C0999ED65E53D01CCBC4B43173CCF992B3A14586F6BA42F5FE30AFA8AE40C5DF29966F9346DA5F8B35F16A1DE3AB6DE0F477D8D8660918060E88B9B9E9CA6A4207033B87A812DBF5544D39E4882010F82B6CE005F8E8FF6FE3C3806BC2B73C2B83AFB704345629304F9F86358712E9FAE3CA3E +MD = D7155F6D3A90801F5E547689389FF62A604C81B7C1583D9204AC6B0194F0E8DD + +Len = 1737 +Msg = F38433CA26FAE8B01EAE24EC59EAB6FF4CE7909E1D73F3D8ED5AD663730391BC561D163FCC44CED801F7B48C4BBF0D578979BAF1E95ED5FA5506AE07DA805FC042074C3E1F6D34ECFC842B3C652746F1F2DF086494F0E0EFF56DB48AC1EC12DEA198FDDF5257EC18395C75AEFFFE8317FA9A7235EFF0C4418DA43E929B7E53DDD09607FF6F9A907F6DCE3EFE263A75183859EBB4682CCAEDE876FF9564CCBAE9817C088FF61381207A8B5276EF41645652B7C1FE9814C175C30587E2094CD44A3DF8A7EC240AFBD4ADA10AF53859CAF6EE3DDA2A79DD77CC7980 +MD = 2E98A175BC9BAD09AA0CA89F7851237646E4B41DE0090CFA5E5E102127F7A89A + +Len = 1738 +Msg = E5D9B23AF789159A99ED98663E1543957FB105A093C2486B1ADC776581BC5AD9AD88282E0A256F0C0E0C1A60F1264A06EC528788C71AEB1A5BA87208E467E890C0E0AD964EC3FF1D8F4908F6C277A070F0EA921C69DD2CC720E2812F6FEC9565570441AFE65040D1CC591087C15CA804CA953A1BFD5410811FBC7E56BD2EB15AFEF1B7A1567E42871AF1D0E42DE6ADD8BEFA7DF866CB7D446CC5AF3677F68EBF9B9DCB95AA596097B98F8AB56F080620C10A0B28C34461BB7C948019BF650FB3E7B12E8CC7CADCD3CF78C77B6EF4953EBB28634BDFF4E11780C0 +MD = 1EF9FD33B5D0563F7A772B0AE3E971D7459FD1CA42F1F6559143EF8B490A803E + +Len = 1739 +Msg = 73CB144295AB9BF193DFF255E2BE770102DC59890854039AB39DB11ED6AC6AD8797144832578C21CAFE0EC25C0383CB0EC4648DA2B23BD4203006B511AD5362D3ED4543A279DDEC3FC0E17492894FEDFD052CEFFAE126395C3E6BB0DC9AB43772E3C130534A53E5F1D4B49DA36C47A22E99422A776844028BB0AD862D20C125F56DF6722D807229D27F18DC5B95841DD42EFAC25DAD229112B63F8A7BBAEC36DF280766F9301B319F4A2FEFBF6D5A7B17F620E38959F056E2F39E721636846EE8C66D93FBEA3D0AC06D23301C8CE46182B2DC7BE3EC2EA485180 +MD = 3C1C04F10B177E0865DE126119D0109C7EAA427C0E73C0E5D7B795B70C5AB932 + +Len = 1740 +Msg = 1F55FD989BE2EE0BAD7FA02D95355FC64C3BE8DC25C76EFE980CAF9FDD7DEFA19B5E591240441C634DAC479CA9103E78040F490510C0C8689D8E35CEC420BA1ABD97EBBE9B7ADF882E0AC256E55CF5F38F83588D49153EF53FE2F25A612676EE764D744047476C3747B40659039EB560A2892507F05FCBA688FBD004F680BE23AEBAADC9FF61973FE6728719C5E0E2B3AF19F540FAFC295D13F55BE06C6C93F489CA5A7294A66B1EC0757BAB1CE8C6EE8595B53BB927B65F02536742EC3A1C275CDBB09C2D7A4F612AD0C5CC00FE93EFACC74A4CB0C05C8F4DB0 +MD = 612BC7CE9EA4CFA6EFE69B2F824FCCA356E49E3AF973088647EB2658CFF3D8A2 + +Len = 1741 +Msg = 0555AFF140369CD288EF4850691D9F5DB6431DADB004BCFF7408E47A0F5DCB4965C3694FC2A6C754452AA775DDC8CECB241EDF8643757E603843F27E885CCAC475A33CD968BAD907438DC37B209681291B6CF5E794A23967398A76D9925D76DE70D7E2B9D623E4126CB95A865EB7E17C2347245528ED9976EC8048C663D50C4E05D5BB8ACA77C98E1800EAADCF0ACEF06E68852DCF102A52829CF2B187EEB7DD00083114B5B913BACA3C5A2381F0FF7A35A5D40E691035EA8D9E0A74B7E17ABE2F848313F6364883D742D82DBCFA61A113CBAEC441E9A33ECD88 +MD = A4971C0E1772C1DB2D2E8C76CF2D7B5D5718C0DF426AB58EB79772D40FBF8878 + +Len = 1742 +Msg = CBA6BF1318BBEF28CD3AF3CCD6FB4CC78AD723997E6FDDA09FB98751B061315BC28B6DE6BACE893911502BC21DE0D93C20DB7DBB32013EF22A3CFA699063FBCA483FA27D0EF2F98491B04E0873C4004D419046B112A0F253F5A9EADAB2EFBB59650E0EE8EF22AB26B00F4F8DF463BD5EDAC2B1EA58313C2BDC90C9837A30BFA7970FD3306E7493E769FC9E9E1E293BEDD78A152866954927C97625A6F6779698D497116AB7CF6621D3EAE5E7DB7F3726B35B36A6AE27343FD3C980E218D8A7D9427357219FAD1907256F682A993C6C5C7601DB1171DADB584CBC +MD = C58554CB9825BF81CC0107D2D647059F30DFEB58A29515D00F3E3156A7963D62 + +Len = 1743 +Msg = CC1E708654358899B253086A1FA3E7F41E1FF10C6E145476DE2D86B27F1260B12C470EDA91FEBBBD8421A036FE200EF55D76E77DAA2506337C413BCCBDEBA791825C0EFA5397FF77AC8625DD3BED03B7295C9BDE16DF5A2751C383655987427E6DB98507E9FA1D5683DFEA692881C91A89B3CC71A4F41F13AF6C4BF70F0B8839AAE0CC27A6F49FFC16D69C06132D5E2198C41139C219B11205DCE4BFE8775C23AB8DE0F5537C4727E60D72D8D24979AB46878B626629DB4A44F7D0480A530B59678320FAA6B6D5D01F54853134FA5634560547D3307ACACC3C5C +MD = 8F3B1B5F6AADA94B0AC0C3882755083DBB0D611317DF6250A5A7B90B0F410A2E + +Len = 1744 +Msg = 5E19D97887FCAAC0387E22C6F803C34A3DACD2604172433F7A8A7A526CA4A2A1271ECFC5D5D7BE5AC0D85D921095350DFC65997D443C21C8094E0A3FEFD2961BCB94AED03291AE310CCDA75D8ACE4BC7D89E7D3E5D1650BDA5D668B8B50BFC8E608E184F4D3A9A2BADC4FF5F07E0C0BC8A9F2E0B2A26FD6D8C550008FAAAB75FD71AF2A424BEC9A7CD9D83FAD4C8E9319115656A8717D3B523A68FF8004258B9990ED362308461804BA3E3A7E92D8F2FFAE5C2FBA55BA5A3C27C0A2F71BD711D2FE1799C2ADB31B200035481E9EE5C4ADF2AB9C0FA50B23975CF +MD = AA7ADAF16F39E398B4AB0ADA037710556B720B0248D84817B2CFDF7600933595 + +Len = 1745 +Msg = C880C4B995AD9D758482D3640E7219DBFE62180D012C37FC7C8427298ECACBC9FA5948C3B23C1F42EB6069A8850A075F709F88CAF61645B26BDF30C6BFD8BE91800BA8F1C63E162849309CADC88CC2E319E5550569A655A4B6419F88037D8FC6A3C4A4C35A3B21CFBC60910A9AF554EDDAC3982676301BE9069B7537F93C7134A0177A3517EA00A7756D9BD9F3B7D40C5985C14D39A8C58CA8420874D21EF372288CB153606E7E5E710B340F8F29854DCE08197BD1F127B47969A2B0EA20A3115D4F7CD1B48EEF6C3F6639607969C57E47BE42D4F2024D1B34E800 +MD = 0B17CC1370C841689B1D2756184E6E667C76FDAEBBC959C1C888E96AC13CBB60 + +Len = 1746 +Msg = 697718B0CFF69EDE70B7C49FD40EB4778AF938B2412E2086630800CCBFB27645B86C854BD95B7A0105B5C8BDD3B4E9AD76C79961A8D18F6A634F36753692E1527A4D198EA39757BF8AAD72844D3135BE711C1C693E5D181313F98FE86B8B7177467942BDB3EBBEDC08B96F384D4266A48CBDCF3CDA17E7C77A4F419C87A83950DA70D7840E7D254A174D403AE9BEB731F72A211D0211F170220318C65154432D3A0C254A96A6CB614AF61AA3B3C312D5C2B47A1E766BC109B6CB98827D6A6661F8990AB73045BCF17AE31A90AB3B8C6A6D9C0B24B287AB16969600 +MD = DC12D921D4BF6780416BEA785132BEE39A5245AE9DF67A97B497721F606738F4 + +Len = 1747 +Msg = 5710347D5FEE482797696CA7582540372408B58898D3D97515B7794EAACD5D8D88D838F817437E172BB7DFAF8E5A996D9EC028C4D6047B09721AD2EA28D348677DF40DB9722D2DCCE46F2D786C0A4F053CAAA4E2C71459D7653262CA7B6DADDF07A1F5A2A0CB52335CFBEE50BCCF01F6714224793C3C53F117DF0C6EDB849042A03526E74BA8A42680695DEA4A09C00920F83A680F539876D526F29C48EB76E2C32D5A5A2D1B9E412A789643A98433BA4E3C33973528502E95FD8389FD8A88A0FC570DC4DFC081E6D02D7756E299C32AFA9FF94A39D7B8AAFCA160 +MD = A6103260A115773BCD4FDD889BBD7A886BA2FECE85323D627A2213C5622B597B + +Len = 1748 +Msg = 9A1D42B3E5E3C43C39EFD6E3816765D650B8AA14ACEBE53FBF4061CD0D3CD880C94A1B98D2A165F8EC0A5BD803EAE346F326788A9C83971C002B5A5DAEAA84A7824E0928C86FA9218A1317433CA520A6A4632CDE0CC7EE35C764624BEEC5192D03504BCCABDFFA8D0455864AFD50ECC78F0DCDC62BA98FECA4CB62349B4CDBABDF7158046B3CF8A4201D1FE31D5A40EDB8A0F2439384D00566651682FEA8778EECC2B02781BEA796C7BA0DAD376AC869313728A420D50B074289DEE922CF8864CF32C52C070848ACD58D670863E2016BCAAFD6E44635B838CB3E10 +MD = 783CC756232A4D89DA76F7F570DB8594B2AB156F09A1C4AC79B0B61FB3812494 + +Len = 1749 +Msg = 44CC34DBF0516E0402BBDDF524D4B5CEA882F4E5408D86796056FCE392FE5AF771681419BD0BD4527010FC33F879AA9B2B95BC4A51BD7AEC455FF38403B8C15CA1C692C896889A5D734C382DE86F581CF34BC8C51DFB522EE032FCFB0B8136A40B123D3A6AB200D18E79FF5A11818C8249B66123B3D4AA48A3017D1B3936349FD8F1F9BDA1710CF0D23B407C2367C84F8A6FEC389E1093BA70E51602FA2E35043D1AB93B9941F6A83FF14DC25A023F550F853D7A0BB16D4991678E19340D30A7C11FFF8E1F6610222233C691A68EB45133D096CD254A2ECB51B5F0 +MD = 1208806FC24420FDC23DABD3FCC9A4D43D08C2DFC1EEEF049690468D32460035 + +Len = 1750 +Msg = D25B283D67DEF2DD143B65F00401876CB84122B5351C42590D9E23F87F3C222AAF9754B5CBB703BB4ACDFCE294BFBB03990D9D26786B603D6AF0C7AC0CC83C7DBC90FB3581EEAA4EE2326E4DD1C06ECEA4ED6D01CB941A40F6AF3441552614807B908F58A0EF5900B2705054C4B599F85D01EA04B3D2028BB9F225656BCCB4B0E8FA36FA4FF4A49AB646C271B2F579D6953C246DA236B189167F5C470439B3BFA95526BB654F724631434B1E040EA67F684A85B3B4F283E185297059603110A40404AB12D4650E662ABDA2BA870AC2C3A3D313815EAD2026A461A8 +MD = 22A93171023ECE0D1962F777AAC1C425AD31F83E4EE6893A5A78F5AFBF087FDB + +Len = 1751 +Msg = 067E8165EFCD31852B49536B78D91461A545C83E6BA5AF83F94E9419ED8AA4BCEAB4835005DA56BA953F4273C98B311FE4EDF3CC0560DF033E696B7C353B404D0BE599294B6301F1D473F5166C91A1741062A56E8378C0E0C0F1A64794C6A178B0BB821C025DC11A597EB1E5E676F8736661E864F42F5E84D1846251CDFA03C7B2D848FEC46CD75E9FE162C08C451642C9578D6828D8BF763F3113089BBC0786BEB3466EDF013AB675B6FD49DF4A9F1E837D53C3D011628B9F206FEF1D9F0669BE2E7A7873B4A68957EE7BA8B0DFC7F6E5093EAD29B3A3049FA3D8 +MD = 6AE31F7E149F87645C20E8FC0AC41FAC8528199AA594EEF0764FFDFDF2D45E0B + +Len = 1752 +Msg = C8E976AB4638909387CE3B8D4E510C3230E5690E02C45093B1D297910ABC481E56EEA0F296F98379DFC9080AF69E73B2399D1C143BEE80AE1328162CE1BA7F6A8374679B20AACD380EB4E61382C99998704D62701AFA914F9A2705CDB065885F50D086C3EB5753700C387118BB142F3E6DA1E988DFB31AC75D7368931E45D1391A274B22F83CEB072F9BCABC0B216685BFD789F5023971024B1878A205442522F9EA7D8797A4102A3DF41703768251FD5E017C85D1200A464118AA35654E7CA39F3C375B8EF8CBE7534DBC64BC20BEFB417CF60EC92F63D9EE7397 +MD = B195463FE22A160802BE0A0464EE3AB4D2B117DE517B331C7BF04C8BA90C6120 + +Len = 1753 +Msg = B0BB9952B8C75305D9ED7F8C402A3414F7DD1353D72E2242E7F96157811488CFDF7E2DF7005090E703CBC7D1EADB690345CB685DEFC764D7E02DB36D196C5E068D06A103BA3B2D6E3C5B6DA7CB789DB167781DA22EECFC2174E2BDFB3AD0434F557EDED255D635ECAF3C8C145EDF64554807FB42E011F25D630FE7C5F1D7B7E582C9A94D10F58C2D5385660E68BAA49D188381AA31D6A5114B08A870735F5C4356F37C9F935609A8703216243C21C1C7E23DDEBE432B1B64266A4D831E2B6F2826955F35AB376D7890AFF04DF6CBC378632EFF128A2E3AD82F494200 +MD = 1AA45271F7F8A41271D2DE66CF26C5220DF213509463E652A8DA2DAA061A9CC6 + +Len = 1754 +Msg = A579FA4FA6B6E09B5809B2EBD750D35A4CBAD3F28D70D808825B73D40BB3C0A749634C0FD7F86B988CCE10B6A54B9CD885C103BA8B019BB7F2D366B2E5478B5AF2AB94661C55EA6D7FB7F747ACCA8E7E34F8FA0CD7E9542B4C4D31D6BD4CF25413805DAB3C9F769D00F9F5F53D74F5B21CAAF8277965A8599E6946E59ECF286CB001CE26CCA3CA96D7F2B483E01492D90EFFE57A47FEDD201C9604FB5D870E7E2C213B298DEB828D1C6170E208A32E8E1D3376DB0033A86F2E4BC2CF2A87A7EE7065C19992FE938CCF4FF2F63C69535279774BDBE07D3161B3FED6C0 +MD = 463956A99CE05907BD0E617E990FC6C234ED351A5FF19EE683B21B456FADC5C9 + +Len = 1755 +Msg = F8D48AF2F89262E4E53EF211B891FEF6B999EC4F60EC1D803268526F7E0E11086E3DF232F4A0C4AE9D2CDBE93A2DF937E4AC673CB0174ABA62DAB5219CFB998590E6E986762943D99A5C3B9DAAB43AD333660793017BCD7F8060F85C338A658B27DF2AC36916F9EFC6CADB099779F0DC44803AE8A66F50413FECC75E60C9BF61ED54CAC360FE635588F112DDD2C02FE05A51BFB4639DC1CC970CD5B33DCEF967DE44FECF12F2D5362BD61D7069DA2D3FD0C00BA410CF1916635B1886220CA07D64E126A00C107A7771E251E00DD176146B93A6E23FA2F60FACFD7BA0 +MD = 55157A4515EE7DF2641962DDEC9B754F827C603AC69FC7D9F2AB0C46E7C92166 + +Len = 1756 +Msg = 7CA20C32E491F1501148E67EA2E7CD36AA5BC7A2F24818554FB7F74A1FC7943DCBA82725C451B13C4BC9E3A1B87F759724BFA5A3D82C0DE79DB7E2E4D112CA7BF9CD7392ED7BA92E9A44CF449ABE096C87E8556A817A400F75855953BD839257372EC32772D10A75BDD2242FDE9773C7B06551DE2F3F25C32BB1C9549E4A16FA45D629D28F21868229A4D22324EE27C207B0DDBF86B6802B9094DF8929AEEF904015D4D127CE3F7966BD0B35AE01F2B29A3A8C867CA3FF0980B812EF2081B43D63EA288B3D736EC8E53093DEAD12AEB3F8C9B1F32E494FCF166D65D0 +MD = 11D3552105E519D505ED69F0AEA876E4EE3F04F845A0D22F2691B7024D2F2D9E + +Len = 1757 +Msg = 3A1DB864D72DE4B6171388B5438A7D80C16B93A2C14A9592DF49A2420798FA25B969423BD3EDCD78508AA3268EE37CE5B94396570B819CFF3C8DF24FD57833CB3D0B12F615461205E9604243239968CF78B131E8F1B7DF444B91CD3B227ACA9C2E2BC288B7BCD23F9E5541FC9EC9B2C4ACB08D16BBAF409A99C5D94C6E635790E47427A967B30066826DAD10254CB6D7D59AC8E77020646B14E485EE2602B6DE382E4B7038CD5E68476CD337A77E687A8D60B3E74425E4A38F9FFC9B9F2B912863CC365D12E0AC1463786BDB7081BEE4980416CBCCE7F1A7EFC4EB20 +MD = F97D94E828A4DEE0C72FDBF44179513E7F0CA433FCF9F03DF460BC91FF64629F + +Len = 1758 +Msg = D9346257711A20A2CE70BBEE79A7C667E787691D9B1526DCE935F897A7B08F10F913D6C1EFB6E43E16D95A2993D945D911EF001D3EF9A902A1F42D0A72763C57FAEDA2AECA9B1D4B8BED766D058E8563365F83593EDABEFB8BF7EB896DA65DD3EF461E860C55390C0016F3B9535AA7B8743D73499D5B6E4174CAEE284F2F272CBD548FC81FECBBB2B8690AE55AE0B9CE920BE03424C94A4C8A6CCF96A11B484F170F5F4C0F834196AE5125E01555A85DB2E5CC88693E7D96E30DE1569E8C1AB74375DA3A5686E57639349A629D3415F19BA17D820BEADA8A115A6FF8 +MD = E595748AD06D051CDE4B9EB43E0C40FFC0889AF74A3A3D132638B07889523B2A + +Len = 1759 +Msg = 200988CB395E9D56BD5DAAB00100EDC9D4F0BCCA0D080E16DB7A9C0CF0DC3E064CB74C37CAE7B44DC315394C5712257ABBCC89D1FD90013364EBD1A55AAF6C17AA0924697FF58F68DE9698DBE691FC85E8F3B95AEB65CBDB655C5E8DCD929E94BAC3389667A18D65DD9BC8D0EB481453964ECDCE89453260C48B57F8ED5A647987D0EF3E7E045AF257CA60DDCD05BFAC255218D74A101172AE2C4BE286F931EFE855C04F1E0B570E17B70733E2CBEF9F16D5F35242482C098873B24C4AFADE932D17FB0E2A139DCDB0BF98D4FFF5D7E83BAD7A4290CEF7B75CEDBED2 +MD = A919F85A0C33739396C3B5BBBAADC3DB4A826CF3D94D8D66A591B51252FA8AF1 + +Len = 1760 +Msg = 7145FA124B7429A1FC2231237A949BA7201BCC1822D3272DE005B682398196C25F7E5CC2F289FBF44415F699CB7FE6757791B1443410234AE061EDF623359E2B4E32C19BF88450432DD01CAA5EB16A1DC378F391CA5E3C4E5F356728BDDD4975DB7C890DA8BBC84CC73FF244394D0D48954978765E4A00B593F70F2CA082673A261ED88DBCEF1127728D8CD89BC2C597E9102CED6010F65FA75A14EBE467FA57CE3BD4948B6867D74A9DF5C0EC6F530CBF2EE61CE6F06BC8F2864DFF5583776B31DF8C7FFCB61428A56BF7BD37188B4A5123BBF338393AF46EDA85E6 +MD = 9F9296C53E753A4DE4E5C5A547F51763A96903B083FBC7A7828EFFE4763A7CE6 + +Len = 1761 +Msg = F83DFEB95ED2CE9382DC80FA8025D5C20014C597CD70382655A8B647328A656E7552FFB590BB9F4149168332ED4EDB0895FAF01B3C957610164A19B0C91FA0A8354498FAB810B835B7A6F46FBE555B2D120CBA7E86C347F3905882DE7D1897984D04CDC39121A7806EAF90419D242849F98FE519439B1EF88980C28F3481B63AA5434E05EAFA90C5A5A7BAFFE92A6B489689CF157E0587EDCFC4061F367482F4AC8D0374847BF2328F409C481A025D4998FDEA0C84F20BF6EEC3335582FFD8C5ED31EECC09216F55D559B3570E423BA35015E52A86BFDE90A7ED981D00 +MD = B4DC57FF16E594446309D5A1418CE92BEE3A6E29913B2B61189BA9D3BD243206 + +Len = 1762 +Msg = 7C2F7C86D647031A2D9465634783954FAE406A4CFED02B9951F64687F55FF5DA2D6DEFC329E5A6CBDE17DDAFC4D6AEFE552FD66829B1D3B218CA430994C475B0A74B64B1E60F25885F0A4DFFC8F6C5FB9CCFBE6B75246764F2B3A743F911113F6CCD42B3DE0E34EC7C50DF188B2771B96E1979947F2B53E8F2AEF409BFD97E4FC569E8067465E5D2AFB99FD05C4EC5FB6C033DE47CF0C4834D135537F4B8AE0CE96B2048B25D10550585891BA9171FEE557E1C0F03D589FBD77D446D1823BBD77494A93C749AECEAC1E35C80B645D9D935F61B2DBD575D94F415EAEA40 +MD = D613F0B347929A5D62A5B60773DA01E204C2DE01D92C622D8EC9BE5B122A64A5 + +Len = 1763 +Msg = A900BC22D5490F6540345B762F5329FBB563BB48E9A443AEF9CFB0E4044E53F88832F3C660E9D057E236E9DAEB95FF496CA830231DC2A84FB5D8598E259DE4EA42D1E98DD7ACB604ACD9F758ED08DBB4A8B8CE7CA73427B77DF31B70AE9A08E2792FFF16008796E0D7C048E575E2972D71A6A07707B34CE92CCC9E1E7793D3C4BBE233A42AEDCE3F950254AE25588C65B313505A507E7819B4E8437351BEA586921D53F5C29A9FFBB16D34CF5826B33E8C620CBF5CE7F4D91AF9E04BB176FA56443D3B1F97036DA112E236304EBE8888BC4D14212FB65776A26D976DE0 +MD = 5C5299FD6DA35FDFA0BB2313DB714B24ABCF4CAB50DC9ADB0494D2AFF461F501 + +Len = 1764 +Msg = A8B4422DDEFBF38A277C587515DD63322690FDE56E5D7EDE0BED671C862AE75EF5906F8091B8FD6FCE7B0A41DC98A09E9326AFF348B59A81D898FCB4F2204E6F3547B9F9F6B127BB66793997C93922A6E65835D33F59E094E055E84FB6334519A39F4D22B2A516268768442D56CBFFA087BB10487BA5CE886978C4141ADECFDD66392F4CE557CAB50B398A3EF252234ED711D0CCB3268B9658560B33C1E90CE47C7054B92DFA052BB941154C4C249A8EE2BC71D54884154D28ABACC62744B5D120AD291CBB93834557402CC01F9E0D80AD269485171F8577D878EF6D40 +MD = EC6456A2D1EF1E866376FAF430A504832050D14EC56A41FDB494A41C4E7696E0 + +Len = 1765 +Msg = 0B8736AE4685DE67E038637B0F0E13DA2FC538406DE8B1CBD84E2B93AB3C566788B17345BF1F75AADFA74B9B57880DB3B7DCCFBF692E833FCD637C067C44BEA40A64A76C1349029FF550D0AC011904E91DCFA3569FB6BAC4862D0B1FB3DA23F88DC5EAA7491EDB68DD38A53997E3B40B2164AAA7D77E8ADEE5C48DDC40B4DDC99D95E810D9CA48E42169AF572174EBE5FF0FEC604C0914F695CAF83BA0F4307460D91623B107C110E847E6834324DB0E5A49A948594A0BA3557003A3E44B41262F6EECB7EA29EA272DF0D1F32FA2EAD1A03305639C8D4552E1A06D5520 +MD = 079F72F4ACD9635FE7B8AA4CC0BB90C390435D8F359BAA4CA547842A0CF98CCA + +Len = 1766 +Msg = 8472162B8C5D55A99F235168982A178A2F46BB53CE1FEC5E3FB51F62C11C2D7EB770F5BAE3B1D66B10789D28B5249209608D28BFC5D0092237411676DB9ECBF8109BD8AC577127481260BE41B5772EEC7AB7714FF05EFD0D9FD6A1318AFBA473982563E50B2A9B788DA93C434BE4A9286A2B6DECDE6B07AB4EF170CE5E49835CB67A9684B9BEBABC9FD3E91DDD6E36F7D712398C5DCCE633310F7853176926D687D2C0CEE030797C2A78625D92E85AA2F6EABD22142C2445617E54CC30ED9E3364C69EF8B5C8409F350ED954323BDAAE9001369DCE3861A4996D3D0D18 +MD = 1156F81D51C97EDE81DD86545FF8233345A7A1C1464CADD69B9400EC30121CAC + +Len = 1767 +Msg = FBD1BAAB1A2164DE65B47C947571C963E46500CFE29C6E2D3C654EA66600F2540FACFD02C2E12E8207CB2A18830C2CBF1CE4E2187D5A1FFD830CB3AC60B8F1C108F632A232E92132F673264983F1682A89807774371DCAD3881F6DD21D00CECC9298285AF4393FE9870603C7E85478AE4C482E27164909B99FABBA5EC6E6C9674A16D0F4CF3D398BA2E94A0713BB15C10004554C88CBBDCC957ADE527C8AB091A23AB05320CC0EC3DD8AC7F88FAFF3C4F9F20B2A1875A50FBB7981469936BD59CCDCECFC3024B8295E120E1C5B9004F23EA1556A860709908955AB51A2 +MD = 4576744BD88F7A7CF8F841693B86A9E9A5A4B3FF1C1296B5592FE9C852A7DF32 + +Len = 1768 +Msg = 7FDFADCC9D29BAD23AE038C6C65CDA1AEF757221B8872ED3D75FF8DF7DA0627D266E224E812C39F7983E4558BFD0A1F2BEF3FEB56BA09120EF762917B9C093867948547AEE98600D10D87B20106878A8D22C64378BF634F7F75900C03986B077B0BF8B740A82447B61B99FEE5376C5EB6680EC9E3088F0BDD0C56883413D60C1357D3C811950E5890E7600103C916341B80C743C6A852B7B4FB60C3BA21F3BC15B8382437A68454779CF3CD7F9F90CCC8EF28D0B706535B1E4108EB5627BB45D719CB046839AEE311CA1ABDC8319E050D67972CB35A6B1601B25DBF487 +MD = 51DE4090AEC36F6C446476C709253272CAB595D9887CA5D52A9B38086854D58F + +Len = 1769 +Msg = 362A8F973645373B80C928F334FF23B7EE402C2464CE49A86EEC3BB5275BBA3793BFDE3B7981139E0C208F4A5E46D16C22E95FF3358072478898138DEA56910522CB6827F8A6733C8B401C65F1389ED4E06FCD5978348C33FC29BBA2858CA06116753F1DEBADDC89DA4F68E6A8510459BE5C5576EFCDACC4F0FE545BE377620F75C507E2D4F32098B30BBDA06D69919C9E313C1D402462A4AFCAC637F23B52D247D6BBAA483D3B350CF006169FA9D7A9E94C1B103AEE8F93ECAA91EE0EB8224B1CEB5F87B4C715DCB5BA9F534F09B8231E4C5F2C5D54922515799A83B600 +MD = 991C1C14BCEC3CD8E1CC6AC25E5130125285A404A3217E3E0FBC47CCAA7016C4 + +Len = 1770 +Msg = 1CC22077B4338E60F383F43C1F64D73C8877BF0879F4EF0E1EF4355AA96F40CD5FA9FCD75CA20E7C52C072F6FF3C0E5132EC69C5339BD30CC2F0D6779DBB576C24BD4C54D64A745280A9FB83FBEE787713DE725475D697B2172D87A194E1EEA61014222C518A23F4D67C604C9742B0EFA8F82BDE5C2066540E8593CB8D3AE8CA62844E9E80CBBC01A70919E7551E4ABF9789DAB9A3C3F76412F72B0AAEF0EB78BD18D00817DF1278F19DFE9E4FDA40C73B029CA06EB9F7B6ECEE3CEBD92D51429976A8F93B75993503B4764599A1153598FFD267E102AFE4EA304B246B80 +MD = B730A53C804D1BBB7D5DCDB047C38AEA802A67B89395B520284538E261727436 + +Len = 1771 +Msg = ED975907D6BB37C0DCABDAB298C7E9E174C9BE1EF386D1EB2ECB82FE0364DF8503E3568BCE47AE0873AED18F0B8CEDAFCBA27E2ED0892EBB31F49E26139A61C0FCEA7257F8D919622DD325F0908D27D7A80BE461B2129E462B8F84EFE42331DC2CC4C8E5AFBF339D5D1C0A087E444D6E432FEA224051ED58B4BCD839C41FAD6DDDBCDC3EF3B9DD65A91ADE9619C5BF90469C4D29AD631B9C3F7675BE22D4D1369384F34094C9EBB255C4FD19117278A727AEE9BE8A37991D1EF430952274446DFC2299497B4A32A18594C1BAA6E993906049B0DC9B70DF34F71C5F7CAB40 +MD = 2E65607D26FF9AC3A9618B904DFFC6B86E3D54CE2AC9BBDD42E4A179EB306ED5 + +Len = 1772 +Msg = E5C0FBEB6B9B24FC8D6AED56E9B813E0B335159619E32279D68CC1A60A32A905EE810F31D79C65F557BA5349E2076F5E86D3D0967BC67A1FF4D67E86643E79267B0547CA98C484D781F621545EC35830FB4710D87FA5ED6F6B0C7C3ACE434D71F6B00EAA423C37F2841DEFB2F3B76387ED86B94A7780A1E67458A5362B281A19EAE50BFAE97C9B116AF64E93086500978BAAC32C989DBE68D2BAE2EC86048A56DB8EF1C42C7B73EFA712E73CEFD9711F22573C00F03BBCF43CD46A8F08015A6450B68BD234482B8AD1F87C28F3629414740615D6A631ECF5AF486662C6B0 +MD = 4F1107FAF7FD59704AF665B2789109DE63EE772E5C7CA7749B31818D39A2A960 + +Len = 1773 +Msg = FFB110826A187B8217E127508F7FCC8D047F91228778BC82D1CAC8EED4503159CDC07C9BC64BD7AB4D199B9D058DC48AC77868779458DF1B002FECF875782C9E305A682C233FF7B3428A3F23BB4A60DD32270238DE49D4973031814FF2D7EDFB88482951025A51358BAEDE5AB72968883E906B65ED277C934F802F1B372959A53E9DEA5FE96E2D17B2219A96FD02F8AB193C8B570A4D842DCA0786CE0D48A5208C2E0AD737163703CD1F8573FB910521C746E79F1EC6FEDA7503264E117D9D9F9AE784B83B8425E714EF0001F91096220644156A834F1EC08C2F1C035310 +MD = B9E6DC8914B0E0C13581089483B92F7D3BD33EABCC31F4A5197A38D77EA53E6B + +Len = 1774 +Msg = 858FD6156E56C400E14D20C9797E5C3C77DA1FEDFD9F78A668223890E539A642C032D54BBC3DB3D0523DEC2B54484622FD1E552F3D13412D4C239072046C26B6C831B936E64C539712EE9C7913287E51E2701664E8ED5C3DA4BF399B8EF9E16DE5B8E20A07EC662AD3C85F93E87E06D1B1872EABDD98CC6DDC2261AF5EF3E1B308AAC3B1F6E5586988335A179DDF710CFD0E4404A0C737D5DFEEE0ECED5B622AC2C5C3ECB2121D56B7B2F556C79C116607577B340588485B89CBEBF2127F474EBF2C0D381450A5012963B1C94AC794D86AEC05E53420D9FBBD8E719E5974 +MD = 42BBE0982473C49D38B17059AA98181206A85759F692323447E9BD594D5D83A8 + +Len = 1775 +Msg = B8A81A70EBAE566CBF2CDBACA0D32F504281A5F6199E2410009F3B0EEAE3E6F22DFDC976DCBE56DDCFF18560A5880827E13EEE8D3E8973008E7FA21FBC9BC617909648D30552923B304061FC0AC5DC4B9E9E0D6C7D6C0DFCF14A7871C88EF98D6354226F7665CDC7B26AE9D5C028BCC3394DEFFFB09C5191701EF82CD111EACBA9FF23D943A9D93879A0F4F094A4A0C3B6524F6BDA783A3A1B571FBDAA5CBC6A29616B86F0160361ABD99175FD24D79A87959B98AE7DC0C53FEDB2FC065A2D0086C4FEE596F8A047DFEC8C9A24353E60438E6868A695A66AE1D1E3425384 +MD = 0EF7922F6C51B9E5A45A7CA0DA4178C37DD68DFA515C6E860C32ADEA0FEB62EB + +Len = 1776 +Msg = 988638219FD3095421F826F56E4F09E356296B628C3CE6930C9F2E758FD1A80C8273F2F61E4DAAE65C4F110D3E7CA0965AC7D24E34C0DC4BA2D6FF0BF5BBE93B3585F354D7543CB542A1AA54674D375077F2D360A8F4D42F3DB131C3B7AB7306267BA107659864A90C8C909460A73621D1F5D9D3FD95BEB19B23DB1CB6C0D0FBA91D36891529B8BD8263CAA1BAB56A4AFFAED44962DF096D8D5B1EB845EF31188B3E10F1AF811A13F156BEB7A288AAE593EBD1471B624AA1A7C6ADF01E2200B3D72D88A3AED3100C88231E41EFC376906F0B580DC895F080FDA5741DB1CB +MD = 87A17400F919F2F53232B2205E1E8B14BD5698A76E74B9BDD5638A5C7BA5DE1E + +Len = 1777 +Msg = 689E99F0F012A351D6D4C65C6E45F66F75133492B96CA3FBD2FAF9C7BD0A064B0272BC6FA6E06E0D6C9A40F952D3CAE3AAAE8D8E45B78B7DBC4AE55D55977B77855867A93BAF38D6C1EBB80C3FA2D64417412822C5EBB48E39C0BE2D1ECD8D7B32E9ABBCA89BFADDE5B690BE604E5D636D1E14D7CA3600D21555526D89479E0959D7476D25FEB82C9D07A51C3A7473D6DB944AC3E272DE038AEF2CED6FFC7925CBE5CB28808B0481C6B7CFA7FB98386B3E285D1C27C4CE95F043AB15D2599BC146A3213B49ABD62622E9B8F004142402BD6FDB22E12C78BD2A1F1A79867100 +MD = D2744974AB7B8AF6B125E61FC2166CBA054C0CD05AD3D25B9E758933A1413C67 + +Len = 1778 +Msg = B5EE16BAB537B6C45B4F6A4037CC7C7AECED7AB9BC6F64D5A84B0993EB079A49DB78521DA17F82B6573A1E1C17088CC249E3860A1C775DF37E3396A0DF546FF0580F7198385046F24A4449F62421397838D1839BCB0D1074FB0B130BAE7C6770D38B5349765DB7480EB42F3A644AB106DBEECE2AD154A849F65F8206DEF6CB74E8D18949CDED9DD965382829755700271DD8C2128B6FD4F73741D0EB611EC10767D8C362586DB58AB5952E8D40D739063B838DF5F26E719B777A370DD4B4598C3F0012F3907EA5445CD43EE622144B3E8A6F5E7A95288E58EA31D69F9EB200 +MD = 257371D12F1FDC2F9F96EA9C228874716D44AFE185E2040F69EE859F996AF681 + +Len = 1779 +Msg = 59E5284707E07BAC72F72F9C794598045B6CDC1B84D6868F41B9C3F56BF2B8B8066F3A4FFDE362D5F8C9165D0F4F2422DD961B510C1FF30F1522044719A7843C5E2E86462F34D011C90382294E1262BF9210EA74E6EC20A341E1A61FA695897D5FAEE35AA02879DD6E61C953DE7A948F4A6127412A905A7800BEE515957F63ADBAA6917C60DC47D2BE0B9E7D2BF5DA653B79096E266B8B0209AA5B47AA547F0009F4E3046D130D0CA7BB80FB3D08602EBC52AAF4326F9A3A090ECC10BA3E75887E899ACA9E7225591A1A9818C0F942E24296C4B92A94507F982B7806074220 +MD = 4592242E2516EF1A7F0821762886DCFE2FD0965F2D044A292639377209C24801 + +Len = 1780 +Msg = A826E94F52AD6F99EE16FB3C8176F742ED6128DF75F5946979DA9F3465D8EFEA205182FE62C0AED722922EFA0340AC02261E94B520A016CD0F9C5527663A4012E2A8CD1F5D5BE194693AF7B0FB56CC63BF67E98B3DC891B362FF58C0885F72945FAA606670F4FCE2D0EA0C58146FADD1AF2D722A8BE13812B875A4CA7776D548C52937CCA376B06A72260D353B39E85E64368C0185D154C91887B41CEA32CEA0F319E915F38CAEEABE01C47DF2961B28269B260E430DB9CCB8605F99D6A534B5DB5A079508E726135D73BB462EFC3AEFF8142FC389865DDF4662EB42D22D50 +MD = 2F0D7B07A915FB5D44C04AEF59D4C7509E46C259EBBF0676C38EC2B3E62EF7D8 + +Len = 1781 +Msg = 596FC0D7AF7728C870648A62AC2A4E20924CFDFF4127378AAA6A18FBA54C9D572E7E79039D4C449458A36DDCD5AED4FD463FB207BA99841BDB8C9BCB9AE8AE75E03536BA2A808A32A8C81194C11E8365996107CDF410D2E5CFFB2EC9E2297FED09154FECC91658B9386488767E6D9501E50876EE4373A2C65C7A5573F7F04A46B05B82ACC35151A66D610278DEE87389FD1CB125FAFFB00CE75F22F39AB08D13A8428C9C59C1BFB974759542EAB24DF016C5C231CF504A2624E138F6304E0F52CC6B3F40645EA0152C085250367C889B786FD3B8B25E1D6FB01DDA18694470 +MD = 1682F4E8AE749968AC6E2BD83139EE61BB196F843BB4C8EFD188E1AF54F676D6 + +Len = 1782 +Msg = EFB3D29588D15242E8BA1350B47160927ACAA45EFC76A7F49C4A645493A0E481263CE4633E9BDB4E5F0AF7A9590ABF367EDCB427F8F4356A69856866CB677970E229D34E36796F78C75BA454217DFA3C68891588BFD38D0444C89734F58378E8748E1A641FE0912C8767CA3F2CCC9E8F4EAABFA09297A4633EDDFD420F0182BB916AE6B060A3C03D754D6AB223CA8914AAA0E357FE80A0BE4ED410C80DB9FCED2E57F46B5AB8BDA63423D8A0C03E113891EE6B5B7C0D336157DAA8AFE6A944F5A121F1944A37399B930CDF53F84E0C66A4B77A1261187686C8F7C2F16DECF8 +MD = D01951141A6E1973C086D13B515CF29DD51F04F892942E6E64ABAC45F3C85EA8 + +Len = 1783 +Msg = B8E7A79771D4F282C163A1E2C72A0E9AA1B51C60BC857DA2925E30678F8AAFE7366FDA06CAE7B39F80C17136C990734EE58674AE4200F847C2AE1BAF8BE24FE7951CDB7573EF0F0173E9372C9DF3A5C0334E90636DA48C23460145D9BD486DEF39E4FA04DE9BEE953919FBCE96D9EF6C73A2D1DC5C5FE20378093A6535E6299585B8C63F2A080BF5FE5F11818824B206AA65AC4B358EB2093A6DBD656BC3D17498C56A36190F76D32FA130B203570EEC3A44AE20F76FB2514FA7B9A3104AE07F62DAA2FEF7387D46B9076A109FD2E0290D0DB3280DE6D72F0003AB3BE2C66C +MD = 31AC89F6F3DB358E00CC52A4F1A67F0A125723113C2DD788B165DF3F229AC899 + +Len = 1784 +Msg = 5AAB62756D307A669D146ABA988D9074C5A159B3DE85151A819B117CA1FF6597F6156E80FDD28C9C3176835164D37DA7DA11D94E09ADD770B68A6E081CD22CA0C004BFE7CD283BF43A588DA91F509B27A6584C474A4A2F3EE0F1F56447379240A5AB1FB77FDCA49B305F07BA86B62756FB9EFB4FC225C86845F026EA542076B91A0BC2CDD136E122C659BE259D98E5841DF4C2F60330D4D8CDEE7BF1A0A244524EECC68FF2AEF5BF0069C9E87A11C6E519DE1A4062A10C83837388F7EF58598A3846F49D499682B683C4A062B421594FAFBC1383C943BA83BDEF515EFCF10D +MD = 9742536C461D0C3503A6C943FA8105DBCD1E542F728D71CCC0517CFFC232EA68 + +Len = 1785 +Msg = DB5F9F96CE8C4916DAB039CB29B925B057044C126CD116712C4A91D5F0CC3CA08C1F27FCEAA7706D3F183A541210B5D0DA8FD7093CFE660C210B6BC06846FEBCBCDDB9BF68C34FF9AC1DBCF325CA6EE41552D7D28A0B200BD7509AC6147907557C3DA239F86A3A600BEAE2CB5078CAFA77D2479CFCDB13590B90B376044FA4F4C29D537CD5F537BAA1C0839EA3DA3C57120104A3F804641275F8C5940BDD4C81F18B12EAD0B37249CE33B3079622FAB25E174F9C72599B41BC536BBF9749B65B8A9A783907393C1D2BDC437E5B4DDB37E9FA1C81CBD7634AB31883878EA1DE80 +MD = 69BD65C6F7854B2E1EEF7E027A34D5ABF51C6DEFA75BAA214E17159DC4C955D6 + +Len = 1786 +Msg = 109D1D580E527C36614A4743E2F8B92E13CE86CE212F70D9E08951297EF173298806274CCE4F3AA756F2A6BFA4873322BEF2D2A0C3131B1FE1AFF81874A2A715561310A9CC7D8338DEFE44A27500B5AFDAD4300160B507A2BC58CAEEB3683B9596D822011D0B01E3C314741F3948F9148679B822A55E55CA19901D41AF8195489DE0980A4E0DD892EA9420A60BF83B1203F317C2295CE73CE9FFE9E498A3335B8AC4683E0C17E18D9F7050528469B177F5A3FB4FFA1F88E6A0FAF60C8018DADE63A2D5F0FE8B970C5589ADC8BF706D9B574190963CAC5ADB827F60DB174A7680 +MD = 6FD763449546C5575F56FAA910CF15F50A2DCCEC095E4D59C26BD8AC6266839C + +Len = 1787 +Msg = 22EAA6EC79BCBCB54AC77F96F50B5932D35ECAFDF8F1F52F680D29C57E8F6F5C5C456F772A1D2F398CAB6E8487225126EB71AC8E306ADA353FEC4B71AFC588FEA5BFB0318AF87E319C627BBE499A67057FEFC24DAD44E525194DE82081BBACD4911E2395DED81F97A381E13E23BA1CF3F6E58B9D297BAE7B3C3CD224C00F6D030B4658D19A69B0B5965BBDBBE8F8339418E8E28C0BE9D7C7CDC71990CBED39D45D0E423F8F410C306FFAF581A1D73F0737A33334463DCD18054F899EB79A89EC7A99249F06703323BF05952826A4C0932B820FEE9481EEA07A859AACD1991A60 +MD = 96867478A6FA79268B3467A38AF501FF3A5599BA0EC2CA5A6C7AFFBE127F5F2B + +Len = 1788 +Msg = A398525B9304377B97BE57240B5E03932B0A798000EB2387BCCEC628D068B6DD5B4CA1D0FE037E325986A4669EAF2EA4888B6E6D36914AEF81B59F4B4B4C87EB452E88A38EE3FBE408594B5F9991E6A2529E80DBD2F5BC32F8C48EB5708754E8C2D7487EA8C741051DD38160041DB4D16D6E92E0C2158D854AA84832DB900790434C9C6D68C4F0D9BC53B008FAEE397A460A6D43E23AA404BF090D584104A597BBF4C5A9B5817EBD985651393EB0CE96C668045E089C2BF6F8472AD2F6BE0F9D4735428CE214CA1DA70CC4580B9D4EF42C9185DAF0BF5EBECB9EFF45B2C0A4E0 +MD = 1AFAB26873F8C405CCF4C17B79A5EDB2113BDBA5AD078072B11A385E293271A2 + +Len = 1789 +Msg = E6F462213A8E30F8E6C9D36CFA3D6DF08FFC26D96646DFEB1418C8A198FE4F2365E303671389EB7A4AABB4EE3B6C4E86C86198742F76CBFC45AC2153DDF5E672B8C1A8A753E83DFD25E1458ECEFBDB571BAB1D6C5DDD28A1B1184B27374F65C28B9E4529716A843031CCA409D9DDAF6B99FD0E2623FCB96E02D111B61CB16705C5726FEEB414AB259FF86C392E9C5F5AF40357A244EA0BBFE5E1F06510F40E8B09EE516FBAF1C5E3CC44F7755B10BE5DC9EA06F6A25E368BD1324AC64F8350D85DEF415AFF1C1148CE50EABABECF501126AF66C6FDFFB6953122C1AFDE846AB8 +MD = B18FA1123DF6C3867EB61A25DBF3313CF62C446A4011240BB4038B3127B8DE10 + +Len = 1790 +Msg = 9B7474751EC3E0BC817A13FB0D8D98AAB5DA9ED6192BBCE3B8358A6B03DE907A7DA7F45868AFDC72A8C178CF893703C9D25B2E80979664868A0D725C4A29697275D51C94E203DBBB7D84768F733CBA856888EBA76958CE9D2EB687A0FAE48353183032CDD560514D01243AB6E0D6DA65A2FDDC9561366025D4BB1CB67FCAF66B11EF599EE7CC40C4F88238B8C24D75E8D23ABF217351935C4D85877059EAF01CE68425AD8979E6C8560CEE26F0613CB0B090BE7F74C1EE2950B134486F9F11E9C911FB7F07C957D1E150C29B938D01B813FE4E99008CA1AE70761AF1D1500D10 +MD = AEF492AFAF26D87CDA68B211F0E2DAE9FD7B162E291620812A3C67F6A929AE21 + +Len = 1791 +Msg = 8130BEEACC213C8789815550C32C2548E750A2516FC174498BB346743379B651A3566F4116291C6C86FA0DD913E41670ED1BFFA3FD95BB8ABAE218FC16C27BF4DCA132ECBDB589E807BBE980B25373E59B3093DA9ECD4303311CD36E800E7029A953219AFBD18B7A68616EE0B372C81319F0238AA6260FD4D6044C04FC9AE7A82CEFF96D518F340928EFF34145817DB8A18E4EABD6401623318198A3B90FDA9F86D93EB14BD976F6E980331A2FD7F41AACC8ABD1559ACF38EEE6407E38EDA98420742F5FA197B577A5EA34A3D452BFA3E77F7C9CE1CA386AB7966C6CDCD0ACDA +MD = D7BC6B87765F5A9AD6939784520C0B3B75C006683B9FA31579B02B4BC34594F7 + +Len = 1792 +Msg = 47B8216AA0FBB5D67966F2E82C17C07AA2D6327E96FCD83E3DE7333689F3EE79994A1BF45082C4D725ED8D41205CB5BCDF5C341F77FACB1DA46A5B9B2CBC49EADF786BCD881F371A95FA17DF73F606519AEA0FF79D5A11427B98EE7F13A5C00637E2854134691059839121FEA9ABE2CD1BCBBBF27C74CAF3678E05BFB1C949897EA01F56FFA4DAFBE8644611685C617A3206C7A7036E4AC816799F693DAFE7F19F303CE4EBA09D21E03610201BFC665B72400A547A1E00FA9B7AD8D84F84B34AEF118515E74DEF11B9188BD1E1F97D9A12C30132EC2806339BDADACDA2FD8B78 +MD = AE3BF0936497A2955DF874B7F2685314C7606030B9C6E7BFB8A8DFF9825957B5 + +Len = 1793 +Msg = 27D6EE9DBED93F4FF6F3A7BAF8B72C092329912F4A15AF0EEA52F9E322A084BBD9B406672D9BC94A4A492AA0845E9390F04330B8EC31F2EDCDD05221F4524EF7FDAEDCEE67CF2E44FA2D298431EBEC108750F1CE529319A50F8392400C722F5E53B6D53C63E16BA27A374E99715E9050FED4792682184A5F268DDB6D1625716C2CE8509F36D9AC9565D742759F658A90C1D20AC4E66BF75FAE130114D83EEAB638A4C77B3CAABC4F631B3271805ABFCCA43CE5445AF17CCF1DE7CEC30A5E3107EBED862AC949A163687E309C6F6ADCA442F707BE5957761647AEA187F10F88D080 +MD = 1975A1ADFC2696409F2F5DFEB5A2898A426B6B1D7CEA4369F7A0593133C78AE7 + +Len = 1794 +Msg = C79C9FE2A1606723EC5D8337EF848D1AF1E7A1E856BF25D36464FA5FE65563A2AF9E66DB7D52BC3F2DAA1238CA2EB67AFD32349A70308751AAC7495DD1AE4683F8F47F8EB67BF0C09303763B14E7E56098B4EDAE326ACC8ECF2760071C8D5E953B1DFC4D078D2D1380F93B950D54986B586D61A908C9252ACAAC8423A5406A0DE1A0AC74B936C493D194EE413FBAFC96F3DDB4721F37BC451AE41B6DAE9A5C0A813DAC3062679B0B95388BE628E027948A99B34BFFA65B4DFBCACBF5F5B2A64BA7E0611A8302D18354E297CB3AC65740E060876440F96FACA71B655261A43E6BC0 +MD = 19D16CEA0B863FD3576638067AE38D449B7BAAE333CC682746BABFDF88476A19 + +Len = 1795 +Msg = CDEDB7F4BE61E5253A46B965A08FE346C388C0F77680B3D402EFCB1013B83CB0F72C79BBB3461890F24634FC48F4A77B4035C2B28AA75AA9EF49FF390F4C3726121A1E4FDE6E97C2D72E51ECEBB76A9750E80A3D6D58A6F3D0709E8362AD005E10D5FF33B9953D45E2AF090654BE13B1D32950931601BF84B037BFAA2694CF26FD6C8833C0AF72FD78AF0C01B301FE9D9265F9B6AD3ADBC0DB1C7C4AC3E6F48709C1B4AB8777D6B5EC9FD7D409BD31900836ADEED56CCFA3985E868C6AA7EF2B8AF854CFF7AD2692EED15DCF83C4D948C8AB7A25F79A83D761C1EEA364059B4300 +MD = 133FDED48CFE24E4DC6BF402C188985024AED5E5F5BD2A964B63974FBF8951A3 + +Len = 1796 +Msg = 8DDCCD9E22F2ADB324237FB5D57C093280ACD83B53DECA3B914651E8CAE649E2904DB8EB0105BD4E921975D71BD5342060765BA915CE51C0D65BFAE74B52543C32F923E86CAF8D7E2CB19D5D9E935CE33B32FD9CF2E5ADAE48BF1419FC83ADF8ED00D624B4C1001A840ABECE16CEDB785277A1AB6CB02335CD867240BCECD0C200C747E428EFBF82A49961AA30226B9ED910C4B4E8971C7D27B5E2115A7DA0C2D91E15CE6FF4FFAE854FDF4DD14AACBB0A562B03EDDE104CA3F7658A66B6D4DB8AD7428B58816DE25802EA871834AE1EE4CE9A80F5F12826438B663C279B143480 +MD = 17B5E98CA1706B315BF53C85152D64C10B7E759AC2D8A02EC11219919B8971CA + +Len = 1797 +Msg = 48840249A35C396A5E9AB7C6CD2F0FF7EA3166BE9EFA96532F9E76E58B350595E7885C6E4C236B34FC66A14873F11EE0691DD3843BBE0F38A73638FC8BC689DC42C8A1C3951D94E538BB80FD94787FD58398A8FCA3D8BA0863CA8E6FCA51F01A3370D59A37308BD2334FB7315C74413A02F620F464C819F159C75D3E1017B7B768FFD9FF3B5A6A45C03376FC2E5E08398E23E67F80082C825A4635882D953AD6B8E34DD7236AEA73681AA53ACE2FACE0583B0CFE81C467F49F0E05F9EFEA53C826E18CFE9F4B288F1405485DC207649CAA7B93A4820F640D02C788854F49E76E48 +MD = EFA146FCE061962A941A834678F28C8EBEAE60DA9D6831888513C1AE29A18BDE + +Len = 1798 +Msg = 0F1D284ADAAE48146EBAB918BD31203EDD82ED4204FF85D7B0389784222852CACA0D54E415520A5C033711EFEB6B9CFD7FD0B8F1C605C729224357362625FE976A58DDED74D028218AA9099C24A9DB1499BDD9FB89E3A14F89DD1A602E78FF4EC2A7FEE4DFDEB35E0A71E1CA7EAA0010C8EFD92881E420A22C92D12D697D4F3A36B30E2F7C1B054A9865684F855679E9F8B8BBF58E4075085FA2FD27CB57C5A8F6A9D86F081EBA58643956E1680337BC6B7C547B05C7183A1F40D569B15B0329ED82FD59511E930EAD1262AE3A15BB284DA0C99F42615C00899B80C1D645DBC6DC +MD = E106B73F09DE77234C393A707FB95C2841830B1320D1F83C8702FFC81D4128F0 + +Len = 1799 +Msg = 9C9827C405695B340C750EB7B48F70EF04742A95157782810B1E090EC8CF7F1757379ECE9877586ECBE00F25022F962F131402EB9C5FE4BDC739748D340A79A915D11F660471E9B2E833652E07CBA8B5AF1363094AA8086AEB8A46E01917B4A5DC9DFC0F5B93B7E8882FA2EA69BCA02EE516C6AC63C6121A623CD909A6043BC7CE50FD00B706D1D23736C8D9DFE34F9887CFB9E7CEC0FE45BD1FD1C21EAACBFBD3A55CEBFE2AC7D35994380277E178A77242E11CF73D2247E6CC5F2848EFB20FCB870DB1A86AB409716A7D146C10824575BBE183A2CEC05FE923E119DA578372C4 +MD = 3906F8B896B5556F6B07BDA5C5AA8913C890582EBFEBE04CEC4FC61EB6471FEA + +Len = 1800 +Msg = 8CFF1F67FE53C098896D9136389BD8881816CCAB34862BB67A656E3D98896F3CE6FFD4DA73975809FCDF9666760D6E561C55238B205D8049C1CEDEEF374D1735DAA533147BFA960B2CCE4A4F254176BB4D1BD1E89654432B8DBE1A135C42115B394B024856A2A83DC85D6782BE4B444239567CCEC4B184D4548EAE3FF6A192F343292BA2E32A0F267F31CC26719EB85245D415FB897AC2DA433EE91A99424C9D7F1766A44171D1651001C38FC79294ACCC68CEB5665D36218454D3BA169AE058A831338C17743603F81EE173BFC0927464F9BD728DEE94C6AEAB7AAE6EE3A627E8 +MD = 5FE0216DCC1BDB48F3375B9173B7B232939AA2177C6D056E908C8F2B9293B030 + +Len = 1801 +Msg = 93E0C330DCB438B4B2B735F7AA4753EEE8123FCBEB25223F98A17F97BAA4221C22F3538F35AF743F5A17660E8E1FEAF0E6A6D17265FD591F44C194C2454BEAE9510014FA5D96EA632A889E059DB6932D327E4BE6A616186612C5724468FD0AD4F2CD1DCFE4E8A2E512815B79D89C2E9878DCF4B5DDD41678B6FB612BE2AC2075DFB3A7B1F9A00A540BE55D6B787FA38E02E084B06967AC8A2351790E88D8632663DD28B6E4CE6BF7A6638630362203974BE186671E76B17C4372399415A2D02F50E82FF4C65C3EA3434207C61035539779E6A91677D29AFE1F87C4C0339DAB2D1880 +MD = 6E7439E5E78542A553AB9171BC05DC9D46F861EF9418C26B22B6F2449D8A2F57 + +Len = 1802 +Msg = 0A12DA8B95783EFC78ACF14A765CBB96FD14E7FECAA12F3634AB8FBAA1735B938474E0E5BEF5B85D02CA9AD30F8285BF6D86A5CD8E8E31044A3C93E0831E29BF76BD2122621B3015F37A0C5CCE07F5FD6B16AE6670CD1135BB9BC1ED8DE5FFD8A8E25EFAA3DA1C7CDF7CF4E00713251A7493EB3B8CA59940B4B7831BA83C3C3DAC506086D0892132636F10ADE3EAF2BDC1C81FDBBA5358CA69F5298ADDCF82D4B7657549B059B5C028385A0C6596EFD8746C83032B4F4C57F84802EE8DE0B2E5CADDBA774494F78F9F194DE1097C83E2D05277CA4B5A55BD19EDB6D9CE5A6C5044C0 +MD = 496D163A5DA7B4E059CEF46626D2E6B8269D094C7A7D97822C33F4B1BC993430 + +Len = 1803 +Msg = C085E32E69584DAF2D6EF0103E7281FE361715A51E68183D4271C7D8D84431758F42F74FC551CC5AF6907A896D107DB614FEC36C809173B3062004F9DC6E45142AEEB962D8BCB7CBC7E710A61AF23F7CC18393F2281C8CBBB5927BD09E52F6CCBCE7CBC2AA28104294978963376DD564418CB771B78A386DCBAFFBE05C06C814A156DF02DA4F252C00C8ABB25278F87E2704563136EC829C5F92C516A236C68CCB2C4F0611454FE04E1C9A4E85C6C8C52EDE60BD578C999643DB5D929F4102E84667CCC8EEB7B8C2FF2B8F4764D31E74BF2BA36D19D0EDF438E2C814B98C5D05F7E0 +MD = B3BF1AEDFB07323BC2E6A0CC5B586D9365D63AD55568BD391CE06A57C7BA4354 + +Len = 1804 +Msg = 5EE5BE16B15FA56AD14EE25205AE1879BBB0E025963270ABC462BD7CEC673390DA462D2737ABB4D926D7A15E3C5AAC86F076E6D7F7F10C86DD2E62CC856F814394403EC7D85C5326CA8902161C005CF1280F71974F2731F42C4F03B779DAF07610C4A34F1C4EB4044B77546D991EDEA239E6A6289E2B35E53B4F59A96D18FB55A2E2299D6CE0182CA4283444819E36EED59E9FC3AD186F14D66F60ADFB1596AD7AB29C65A350FFB00C58373ADE7787428468567BCB5B3CBFE781E2A69C365FDD5FFAEA902368BF2D6CC53A1A3401BA729E94F778B031BBECDD49DD8391634BDE4B50 +MD = 35E4739CF2D4A8094EB7072AD2686038A064807AE72B466BEF3D9F6CEC31C9B6 + +Len = 1805 +Msg = B173953CAF23954D0A0C59DDE1C74651A4ACB3D38148F5ACA07C2891A8086C8D5BC8B4B34C7F8BA4F63F313FDFE3C40F74EBE48BE5379B8441BE37F54A810F0809E5CB8742DA8A3BEFA52F749DD6C3296B777E4CC1D6B22810E21B72B7A00E169519627C6BDA77DC9559B87E64282C0045EA13F1FE62E53FB0BAFDAFB0B7C1A2B8105318CDC10A559C32206EA85A79CFDA54F363975B65F91DC2D42F0F02922768E9ECE2789F1FF71486F9B5D7F56104FCF5DEE191D666171222BF47F73E69904168EE565A634B970CE57032B6394BEF82E78A807805F4C39C5D64A29B7135584368 +MD = 159DEB2B2ED972B6E8C0FED7F9AECD6D93487B563234C17A104B5AA3868F34B8 + +Len = 1806 +Msg = 30D48650BBDA8EC79A0DD891FD707160A3C5E16CBE1207330F170A5850E8364C6019325A8FF4AFC809F144C118D7012D315B3F4622268FB5F6F350BB5D0048924FBB30A5390CC5DE60F264E183B90F2D38A1E499DD8CD4B06C3C57A70A612604D2F4E937ACB4E23F02C7FCFB73CC87684ED61C70A98A2B3BBE2181FA14879A36EC965229D73DC1E2743BDD285B12A75B924130D630CC2F02D917209AF4775E01B5446FF76D12A2108621D900D7495CBDCFAA64A781A3C33A6BD61653D61BD0DEE7781796404492099CF850B74F5FE86E0C385D5C314B5FD209E8FF990FD76BDE8F18 +MD = 0945D546CD730BFEE479B8AC733FE54C24858BF59CC67569BFEC59C64C50D081 + +Len = 1807 +Msg = 37FF7F5AC736908E07CE01969410B314A031372CB1D184FD683C2FC43A30678B2C3DDD92F040A89D5E3F1D5247DD9FAA9EFB501CFF4F40014EF6508DFC37D410AA679EA3D3D0545189408167C1CB6826F97615BC27FCBAC7DBE5547A721FB92181F037B4CBC63D4609D2001727BA88C7ED78F3B3A50E0EC4505DA4D9BBF6D3C5F854D90128C2106E8F1B4D81C33F67FF804B080EA79285904F4AA71B78F71A8B01E6E728DD55C294E86A0E1FEF0915C1AEA1523DF5B15AEC8874AEDF60CD8F2B26B746A3CAF4A9E60CED23861DD5444128187ACAD282F076C1AE01EC7883AD417BC4 +MD = 7E93BACD92E79A0D2372D6CB9ACFB1F049142C7833BD9EF46B552612CB989A5B + +Len = 1808 +Msg = EACD07971CFF9B9939903F8C1D8CBB5D4DB1B548A85D04E037514A583604E787F32992BF2111B97AC5E8A938233552731321522AB5E8583561260B7D13EBEEF785B23A41FD8576A6DA764A8ED6D822D4957A545D5244756C18AA80E1AAD4D1F9C20D259DEE1711E2CC8FD013169FB7CC4CE38B362F8E0936AE9198B7E838DCEA4F7A5B9429BB3F6BBCF2DC92565E3676C1C5E6EB3DD2A0F86AA23EDD3D0891F197447692794B3DFA269611AD97F72B795602B4FDB198F3FD3EB41B415064256E345E8D8C51C555DC8A21904A9B0F1AD0EFFAB7786AAC2DA3B196507E9F33CA356427 +MD = C339904EC865F24FB3F88F142A8786D770934E006EAEDDBF45ACBB6B38431021 + +Len = 1809 +Msg = C3166574DCF055139638158B619D5E8A424330DE6518B1B452E359EB4AA5DC5EB051FF8A778305871482BF5AF417A5B9540B9DBDBF5B67FAFABE2B3BEAC0479E236ED078A5D514BE7DFA179667451609EC25C6F89A629A2C55258164ECB8374E91E75649D3713BA757CA92C7E744D4FF66B653679F77CFB3A007467E802701DA3D2DCBAB7E3CD9132061A79F50BBA74359EEF864ACEC727A11114687C35C5605B6B8587B9A57C2C0AF5FC9BB8547A0F5E3327174048576B0D970DF5CD54CEB67569361A1F81329AF65FA370AAFDC05453FCEBC9003FF8AFD9527D4D7EE619E35D2B780 +MD = 662CDE2F6F71FBD09C5971048D24155639DE349E5A2A01DA315D427BB0808F11 + +Len = 1810 +Msg = 56CF4692BCFA741A977A5B7637842054E6DE09EB578CFF84F6E5F5A8CDF06F85E535B35C6E27BEF83228133B58981752B855CB789A8CF41ED956C3C8CED7AE8BA913F41E6A930ED8801C27FD28141EDF70D76AA99DF34E0A2B585A22CC66A60679640BA012668D5B0F1F6D14E160C6490F3B609CC1D34E7A819AA5A65DAE440C97CB68B6CC803D4FDD298C0927B42DE9F3BAE2DA2C9A455E1BFD8D6A004D594318557EB28C0659C1BE67F539C79F0E915834739B3C8EE6B1F4F2B3E7E708EFA4F952210701CA055425EC7726A585233145CB881187F2A3517D0C15CC788E49B13870C0 +MD = F25D19A77C2DDEF76E4CC02F9757B4AF7A3D17F6B812D90C830EA342A57DC827 + +Len = 1811 +Msg = 26276D9B2F77FA3C271F2751245817DBCF869BB0C43C5E64C10800A438C8B37463DA85AB4F64C267BD4E29CD36D53B27D41FD3049FB430C7BB5A975675424D277BECF1872F85A08FC6E86ECD21140876B233F5D29325B578662333DCB18B16394C5183FFA25FEB71FA74709EA089B7D70D6C9495D347288D69DE56CCBF1936F2E96F34B1895E275CA531081EB5719B8B58154A09A2F8ED0C8CED5C76BA3CFD8ECD799447706E8CF3B10F8FFB0AE3A653A6273478079815FF9DAAF2D14F0024AD43DB447B41B28C35C08B7A2405C82581000F3C317DEB6412159CFD4BDF201D0F1A13A0 +MD = D13B7E74D4A1E54DF85C17D7CFAE011657349EC4F0F9DD27B7790BA8C477DAEC + +Len = 1812 +Msg = B85BE89EB4D326C87509C30ACC237B17A04D9AB91C1F29949C19F300B7385A5C248AC36D3098EC7254CAF61ED0A9F0F9A6E05DF510A88D38E9BE6981746F43589AAEAEA8FA5311F57942597BD048222EF1F490D818D162092796863ADEE21E25521ACEFA7E757E02B42F4A2134E1D69929D5BEA7ED5C33798F6DB7C479B6D11D085C00A0B00F650ADF38B56FC8895739B5F7E5F475659F08F35244189622B0D9634F390FA84C5EF41162C6E330C04137F1F4EF16BBF76AAF1B99E5E3823242CFF278E8140F350E04F71571C7E94647A8446DDD6AB32FDD16D25ACCB7323FFE7D5857E0 +MD = 1467910890A4A58DBF34095EE3E4EA24B926C2A8BCB26DDDA1D475669C45BE90 + +Len = 1813 +Msg = FBE6F14FF1D32FAFE0BFD62E3B16724B8193F83BD3A4F8ADFD89A3FBFF74D2BC5D2933A671C1B1ACD08E1EEC94C4824F6C591259E6A7418F39B6AE225C78B0DB5B95249DDFEAE8D61B3B8D97795CCAF47A19BBC4AAB6BD563CB82854D0E0BF63A60BE398546DB66893F1DF6751F3089EA3820541001878819A7522050A6F2C9C3C75474F5FFDA0CD119CF01CA322616178B3ADEDB432D8EFFAFF881E3FB08C5FF0149CCB1573B496EFDC20B38646740A0901875A7643857CBD49CF60935608ED6E1F72CA61FE6E48CA17BB060E34DDCCA119C7F257C2F66411DC3D679558F884706F28 +MD = 335F846AB42CBB8AD6AF3E5C50FD19A2A508E92D837DCE5784DE2FC01AE69088 + +Len = 1814 +Msg = 383D6998DF151E192BDB63C6E79DF5BAA9D7D7A55D895377CD6A0C2BA9A4325F9279AD1777E4A63BC48BCD651750FC2391BA52C35B8C3F83413608277888863668A8E3915286D6724B394C872F672C39CBBB37B9F9117DF638A828B87D97D303580A7537EC381B31F5DDE578B0D577F4BFED8D222A4FA26FFF77785A0F0C44B21939A768BD1140E642256C9A0226A355F06BA02662704EA757E6FB9DAA9338B865A0325A158A4C17FC7D9C0028745BFF71B244CD8AB1DFA55D9F979450834E2E98E95961786253B07BACEDC6E1249FD0125445607091F5CDBEEFBBBC1776D43BD7DA7C +MD = C03B4B834AD5DCC39462909C8EE42985ED03F2BE698680FD5C72F9D7D7EA3C69 + +Len = 1815 +Msg = CCFA0CB8A230E9E9FF0C09FAD375CFAC5E815A4CE1EF6FB81B6E37BB199559C09DACDFA913DE0FCDD0B3628C09A9F488C846AF0D43DB7A4D2AA79445C7E6A6FA7143B0B62299C8BE6F04F9E34E8DD30C63E782B3D27D2EE4ED1CB75468A7BA4F66B061C3DF16587E208A6F3A2F260983941271C3CA7953EB4B7F0E8E4C8BE1827C652B1DBC48CEEA4FB39F0B0FD6BFDE38E273B75E6DF8509E5093A6C9E1DF9DB370C6E6F57970D718F8B934AD02D0E27C31282D1C90E9AFBBFCE8053A862587A3092FA400F6CC70C8D2C47678B40A4BCA21A1E881895717FE6A2962A332A89B7BF2FE +MD = D5E10EB9D8686758CBE9024769EDDD8547F7EBBBDEAD2814484DE7A080DECA14 + +Len = 1816 +Msg = 23AC4E9A42C6EF45C3336CE6DFC2FF7DE8884CD23DC912FEF0F7756C09D335C189F3AD3A23697ABDA851A81881A0C8CCAFC980AB2C702564C2BE15FE4C4B9F10DFB2248D0D0CB2E2887FD4598A1D4ACDA897944A2FFC580FF92719C95CF2AA42DC584674CB5A9BC5765B9D6DDF5789791D15F8DD925AA12BFFAFBCE60827B490BB7DF3DDA6F2A143C8BF96ABC903D83D59A791E2D62814A89B8080A28060568CF24A80AE61179FE84E0FFAD00388178CB6A617D37EFD54CC01970A4A41D1A8D3DDCE46EDBBA4AB7C90AD565398D376F431189CE8C1C33E132FEAE6A8CD17A61C630012 +MD = 4CA8B7FEBDF0A8062E9B76185CF4165071BB30928C18F14338C305626789C6D3 + +Len = 1817 +Msg = A77640D2D35F23FEF37D6F971F5AF60A63763E74ECABF3AB5393AB48793C0B8B25433B4ABF21CE1C5F22A8D2386FE9D7AB860E6331938283D2833A6D0390D29BBEEFB32C2805EDAFAB62F01B38899404A386DBA844B93EC6D70DDB3BB2543B41E3C32861769A27D020EACE26EAAB0AFE700D1771E77E71105812079E77B7454A9D9D3F449CBC4A68A0DB6E961932371B39318CADCD025B6F477B7CA85AA86FF6465669EB79647C850EB856B57E5B16AD90E5EC8C710B4C9F45BF02331A72968D86DD938091C4475CF88D31CCB41389CFEAFF34A7809B86D140B11FAC7DE185A40F88C180 +MD = 8AF26EBBBBEA9AD620B5F9739FB82FC62A53DF473BCD9CE3C1FC41BEF4209A1D + +Len = 1818 +Msg = 53EC7B6F97B359A2263D6040F3260CA95752B7D291A962C47BB982B6774CE13ADAD766E030ED85C982F166B0AACF9BBD0F51BC0AC322FC6F65E46D591BF86CD7F152975EB03CA48F0075F0D06F1EC205B42BC0A6D25B111BC475515CB91F4D988B1FE94DD1D5721B8CEB73DE17978DA68768843D44D6B02032E9D51F1DF2CEA5FC1DFCDD0830EBFA03A145E0A794E7EAD3D2B322FDC1DD6C6F135CCA1E73DBDD42598BC0C78299C6EAE2DCD675538F96CA9643F70B094165786B98B96339DB327532B84D789CAEC650973BF105A35465B8BA69B44DC991EB66C2C29139537066FE846380 +MD = 413BE82F18F34CF8E74529C15CD40F3AF1EC91C2780766E1083B552F931EA76A + +Len = 1819 +Msg = 9D4DF0D98116F5F8BDFBBF3FD3AE80B980EC6BB9AA27D05CCB8EBAB8D7E5792C62E5F2587703F74F51F9C94AFE7984E756A5910397827E0F3A86076E2794DA28499F301F251854A0FD444D3BF201BBB50C4761E61FFA99CD21F43DE1F6E059BDCFB7D0E216257B55EED61BF5172542D51F9AD264DCD1A89D473CA615BD6528FA5BF330E5EFF67B5C995741BBE1B3721B832003C17488FEF20FAAA29B57E27DB7B8C27792CC0A9D8BECBC0660F52EF67EE6BA3369B1B1681B84747CAA4BD730A6A1B246FBE0C14140E0A3406D55258B8F1C851B181112F21183F7450F93215790CF6BB160 +MD = D6B91AABC996E0FA3F663EEEAEC32B57B4352A4A0EA1372CACF04003FF3BE456 + +Len = 1820 +Msg = F14B19040E8437EEBCCD46724A7A2461EDCBCE33184B017311FB3D5871A8D6A9FBA5B93100F28060ADE0A6D4B7CD5EA7C39E218174F1F8E237BB5D43B51F12176000EDA4D70A493B957657EEA9F742DBED3486CEF3901902BC4EF4A6BCE18A6EA2F27D7EB51D32E33E2CD928C5B1C31A5C1FCEE30BE01AC70CFAE540DE372CC176A1FAA63E354860971B595D2280387DE39FBB12E6399448121FD265FF47B5B95D84BBF871EE23080912A2C841EE86BF238D2533931BE9ED8C3B8B194D81A9C358DEF0BA28E01E3008C857DECCF0D1630789782D13A414849A292AFAEC50872A9B2767C0 +MD = 188D93348079F8D9C0AA8E21F21B4CEC754DF5300D5068188FDEE8F0681F2E53 + +Len = 1821 +Msg = CA663A31D8D4362E485F1359CCBD0B021EC94269F501F50FA6C4FC6B9AEA3BF94BF8AF5EF88CD81355002BC33D1938B4B3F3ABEBF6A4E0F47E63D6F41780C9A9028D6A99FC1194097A8DA3DCF8CFBE40A11B1887C88822B69815FE28E2F90D4FC09229D0015F0587656BFED67CE889F375045883D86B0341A76E2E027CFC621A67A8CAE74209FD5BBF12212902F36A9101E02AF83B82A28FA99AEBC367CD46F2B648AA34F497F5421770D62CA47C0F6127CF3C82E77CFA398DA87DF2AA9C99516745ACD0041D45C426BE97EE0757911931FD9E7E58E26EFAF438B812FF2E52E6D17F3210 +MD = 926C6BBB511B8A023A66B856985561DD222AF8F8BBB00C065B1987DE512D1092 + +Len = 1822 +Msg = 123F3665D10C6BE2668F87C7BA72F688E549B1A41D097F75496DE8AAAFECECF890D8EF3F4D130B0F4A9E0BF46B29AF25E7F0592F7EC179CE94151800E701AEAE9DE620D625D03B12EA8ECFCB37969493708BB85E536F5E16D37F0CD06EF861945492A828F345528407F457C02B3D60D3BCB4F49AEABDEA5392FC5CC94A97E7A7B41B1893EA99BB80D22D1346279717647ECF6AE2311561E834E5D112F3540CC880E9AA0F582C64667E8CB4AD6D5C04BE1557F6A0A56E2A371456499B8D84717E0510C11AB67CDB756783775F6B9EC11F5925981BB5D4DB7E35131679E55478DE329D3A68 +MD = 0DC75E1F214E002C0E7BF44460EC0F8EC69D2DA8C4743D19356969FF44E27537 + +Len = 1823 +Msg = 402643679D796742D356236A01DAA1AAADA71F66D90B79C1CC220FB33312650A938A948980B6D2B5DDEA9122547BCEFBF6D165E29C8656A5A3FE55FCE33CC96AD45B98CC34D6F81B54CA7205182D623F7A86E83043C2F4B58A8D129D713D5F41A5465C9B695B2100A6369D57C34B33E2578C313EDE53ADE7C2DE3A75095D1DE9BA629E2E3B90062908E691CD94B5D240E65837CE476E137ECE7B7818579AF7FC4B1E10513BEB176A1BD253EB80C22BA8C60C1A1C5EC316EBEA8828202024A543D289DFAFC4DBF1667416D4CA5AB8D6E42D0C1E9C9B2B40751D20ED4A4FF7E2F90784EC60 +MD = 0EE2CB120041D5DFCA3E1D8817E665896223C0959FB02EF077D9DCDAA9CD565B + +Len = 1824 +Msg = 0172DF732282C9D488669C358E3492260CBE91C95CFBC1E3FEA6C4B0EC129B45F242ACE09F152FC6234E1BEE8AAB8CD56E8B486E1DCBA9C05407C2F95DA8D8F1C0AF78EE2ED82A3A79EC0CB0709396EE62AADB84F8A4EE8A7CCCA3C1EE84E302A09EA802204AFECF04097E67D0F8E8A9D2651126C0A598A37081E42D168B0AE8A71951C524259E4E2054E535B779679BDADE566FE55700858618E626B4A0FAF895BCCE9011504A49E05FD56127EAE3D1F8917AFB548ECADABDA1020111FEC9314C413498A360B08640549A22CB23C731ACE743252A8227A0D2689D4C6001606678DFB921 +MD = 23D2614420859B2F13AC084453DD35C33FE47C894DD50C087FD1653FCAEEA00B + +Len = 1825 +Msg = 26BD6C97E9E30DB3DB590A76835E02AA4BB89990A51C76F4F91B7A0B2AB6FE1C02AAA8863B4B3674F9DEA77050C6CB545AC5EAB25D1AAFC430528CCF416F1FA1A8EF34A3797E005877D37AAD7A0D849EB4A6CF080E0DF10EB2D33CAD7F5653CE49177DE297119961A3C6A9AF7557CB33BAC84441DB417B5342C2F92E8DFD1BCC93D2653BAB8870D1EDC19033E9CBFACFD107FAF39156F1B54B41F703B3168F018A81E2E1F4E99B75BC2C1E769E283F2FBA11DC253C6630375EF425D4BEEB51F572C060767C85BBE9588B296056008F095E1EA46F875CBE22C984B85B309930BEA70890E680 +MD = 306488EBF206D436E615F448F5F273C3F4A1AE6016C6D207FA9472AAE80436C1 + +Len = 1826 +Msg = 5C834FEB24D7F670BEEB8B67568DC79253100E1BD7EF2C828D6CFC22039BF49F845C25546EDB592C398CA3F81CAD9D2750573822A72D60F23234B010C5D540E0A144CC05E85AD2B78EFFB7E01A538E8CD9F9E331DB6B88664D95846C32F8022AA774793DE2C28431B798B6601B10414F1BD4F5BF2E8D8D8A1468E7258EF6E2989E76814605CA6D26C2B43E3CE73674421EB27A4401324FD7B5C64C70826F67DBA8262D53FF8D6E7EF03DF2C2CFFF2D567A31603F839BC5375476383C051912885B39D652B3306CBEC139ECBDEAA32C0F3A5D628FA121D29F3D24EDBBAF501AEB0AC6A1DC40 +MD = F7DB8CB83EC60656D3DC47FB27CF3687E5817D89A860E6A287655707AEE6D4F0 + +Len = 1827 +Msg = 89DD51714894F40D6736792CE595850AB69C8031ACC48B986FF0556DDBFB26EC1A8D28087023042AF29DAD8D026FF0A6A1A281EDCD5CBF708A9A8487F706897F9EC68282C01046145B8ECE4B47D062EB69E9DF4EF9B45F9A557E035F6332D987693D4387CC4B665476BF058E9B33CD20503E1FEA00B8A302338E5EB2676A3B1B4A4A25E4168EBECE4CD5ED2B84B00656795D2089FA8F92EBA0AF2A5C705091F781D49B24577197A3025A52CC7B6D01AC1A3B28E60CE8FDD9940D46624FC8A7AE159E54124490FFAAC2B5E6D8F2F0088FA17ECA432E0F701D87A444D289403B974F68F780C0 +MD = 977E94AF56633F57915B7B1512D54D370C0B09A21766D858A31FECED8EAADC90 + +Len = 1828 +Msg = CDDD2E9A96131C7E3A1AECFA200B414908370D1406E2240F257228028F556DF1043E10DF7900063D19B239DE71926512FCA45FA43FDC2ED73C1D4B96C1D305C70ABC09296BC6B80079FB84A6E544ED27DE2BBF1B2799360264858C661F331CB5B01B355BE13AE25F0BC87178AFC650621235DA7AF715D8E4D8DBACF693CA0F8C59105E9B5F457B600BD8452F42571FE3CD658F9F3C55B652A627983A5A150BD8259316D39FB1EF768DF2C3316C249B776A912035F7BBCA1D77C1920BA72EEFCB80933359E0D785C5CBA4B40CAB791B08CDC58FCDDFD30623DC3D9B6D53C7FBAF2054C977D0 +MD = 218D0E67892F9A096163141D8E5A99EBAEB6844C8C7860D4993DC7166271F0E1 + +Len = 1829 +Msg = 7598D75D07175436BA21F3CFC27DDA119096C793740DCAF11978B785150CEFE010CDBA27C4AFA5798F58D689E639D2B8CEECAE84EDE6599C00FCE4541A3E0F5B2B72C65EF0C576BC479325F761D8713161CCD4EA27302EA53CC4113EAFD94ADCE60CB8C4E3546538578EB28F2116B32E92961D5CD08012CB890B5EE0BD4D7DBD667B5D988E8566AFF6675F57433D40E6547D7280BDE4C5E44A4FF442C6C9AE8AA37D197B2416A6BED8422690A6D2091442E5E90F5E3EC5A7D7E89E4581189293C6CFCE1ECD667F792521752D0D785E7A767B55252F02E8A9A4342E084943A3FE1EE9366310 +MD = 6616C517E53D08E82B11823198B6FA901657C5FE5047A5A60F7B103D51A974FB + +Len = 1830 +Msg = 5663593146BD2856F9206D81F0F64E10905F69BF1DEE07B1EA4547E1644402FC338C5C92697859653A7F09456EA10A846A5B0940B547828C666521BA4339C93F6A1AD58A44E32F34B5C7E904D6778D1F529A0C5905E9D0E4385B3F08D096EDF0DFEA1EECCBB67BF8B935A8B4E182C36DC2D69F6090F1FB6D18E6883C9772452A4EA5130EB277B84782E190CF03FD4E7D88B050AD2AB22C9D31B34D6A6A202BBBFDA8F0B61C7B665D920654FDF79655CA37490A6442A69F8BB33EC128FBDF992A95FAB380E3CB8E6EEC89D41950F9F645FACA86489F5D24D2CE86E4D554685E62A7567D7A58 +MD = 04D237A3C75305A974F1054CCA88D3651739991D206BD0DEEB057297F30F4E65 + +Len = 1831 +Msg = B38CE3DD3F6A1C6ADABE07481F8BC37378BFBFDE6562D5CAE1F65EC787A70FA381033C163F944FDA956DD2DE1CE94AF1B1726691B61CFB32116F2D5428BF128F3B673444D73CA3DFCC323DAE946C036A15BC1BC1799C42EB970DE6235B336B5F10AA568547E11D93E873DF1F318381327BF0993FF9302952EB86C258C461DA3DD7C649390BB0703A2EFD82F6DEC8B08C541C925EF75ACEE45BB11A4ADCB321B0463119A409CE65CB9EAE75AE8D5BFCAD3EA54BD5A960A522E740620D8A2B07E71BFA14B0003A50AE4DC73C50DA7C6F2C438AFC5E5B51E3608EEEC16B443A439D9C8FA2DB98 +MD = 65893C788DC7FCE090F5C295882132AC206AE26C5091014F338DF33D4DE40CBD + +Len = 1832 +Msg = 3875B9240CF3E0A8B59C658540F26A701CF188496E2C2174788B126FD29402D6A75453BA0635284D08835F40051A2A9683DC92AFB9383719191231170379BA6F4ADC816FECBB0F9C446B785BF520796841E58878B73C58D3EBB097CE4761FDEABE15DE2F319DFBAF1742CDEB389559C788131A6793E193856661376C81CE9568DA19AA6925B47FFD77A43C7A0E758C37D69254909FF0FBD415EF8EB937BCD49F91468B49974C07DC819ABD67395DB0E05874FF83DDDAB895344ABD0E7111B2DF9E58D76D85AD98106B36295826BE04D435615595605E4B4BB824B33C4AFEB5E7BB0D19F909 +MD = 5590BB75247D7CD0B35620F0062B90FFB2A24DE41220ED629D9E9A7ABCADFB51 + +Len = 1833 +Msg = 7AAF064B8FA13BB2955744B2E18F0AD1E799850D68236B45FB62A3AA11717936FE42E5722E30397A7474D3C551A290979DDA5127E51A27B7EADC7D7A2EB563B6882DE50D3391FB17D96B74AAA1A5EFA27B1B98FEEDA557385C0CFC69EC680D0EDA5D4104658BC9835B714968208091D1DE0FE4082DB62F6C10CA62757948A83BB507B0159168A39349EEF2AEDEFC85755FDC402C6B44AD1655D8A9AA4D6EC1BF026508B41DF0527333C96ECB91C2C626A23C18C9C61CC32320009B895F6F2C363197119F41EA858B23A377A548802A6147E852B5C8AA008711AA6CB78F1C6F2EC8BA270CAE00 +MD = DA26F0FF71637386EE925A2AEB3E31127DEC36E222DCCC7285BFC1DE09A29477 + +Len = 1834 +Msg = ED1CC805A521D45C409965AA7A564CD5DCC0A27891008B296CEA8683BDAD85A9C35E6925AFAC9DCE2A7E33F47C5E6BF9D8EBC7ACF035BE05F38330DBA1770C58087412ECA4FC41FD0004BED47C31521F17DD592E5638272E3ADDFA237D3B497518502DD3130EFC9C9D77158228AA671B4105E07F8D6002043BC99E956F15DF49A9781C8209F68810698A6DD22DE1D5095283B0A97015F73E4707289D9C1236789E3D9E9EF6BF3B1FA5994AE21A51BB10E8DB3CA5879A7EFFD3E9FC01C81CEF0BBF332F44892E2A509E02EFA417B39B8046163CA49E4D310522AED1874184DEC4F2AFD9AEBC80 +MD = 6745E3FAAF4F8BD08EE428DB7BCE16A72854E200CEAA4FCC7576D46E2802CD58 + +Len = 1835 +Msg = CF68D10756BD67D4BB27D278DBD54353FD1CFD416AF8957B66982247AAFC7F95AF90D0746150994EE72CBEC0F1AB55D3295D4EB59CAA48A49A6221ED63C17A436AF243EDAA4CFC0CFC8AEDB3395514DA8F92FD4696C0251D69B622509C7DF56740C9C3B938E044FA5FC0182A3EA9CCCD3843E5ECC75227ECF305F5063338AB7B73872C288DA65E7F04D7FCBC5BC14FEEF432ED780C55D2DFCABD65E6D95C8ACA350886C6514AA33574645B8ADA868FD7DF75F81A3AC75FDE093BEE15D8C9CD01AFD8731C1FB87F12E845FEA2FCFD5AD961D46C6A7BD033380A92D158F727DE24C8D6D7A4A140 +MD = DFBC0CDAB13028BCF40B17DF54DA6C15A3471327FF564C8C10813F5987F0A798 + +Len = 1836 +Msg = 06C383F828F6D58D1F99567DC5AAB7BBB7F8B9F0DC941CEB0938C0C1367DDEA5F03CEF432C4BACFF10E314E3B66EC473EA6D238D86BFB2DC83FB744E1B63618FC0B72380942AFD0919A3CE11F9F5F781402A14A00FAFD0C79CC516E74058963411E5D3C59B8D8C87AD916737F4C216B9B28F39FEDFECAA3657C1B284CA7AC897B85CF6FE72DF44E0629EA2C61D8E4C0FC1460002D7F1131339DEDD78CB8235767B64E7417B06E13577D02A94D9350EF66A5C12553E56B7840D0569D4E5A5928050C9A738F9ADB557671848C58A504F63146B946938935C76C28264F675F462C7D76E95FFC1B0 +MD = F0A9F96DB49ED8CA2FE36A0B0A377E718330D8C537BAB046570781FD6D3C6B05 + +Len = 1837 +Msg = 27C482CF399044DB05B251DCF9D8A788C0CC214DCF7451EDB9D2423A13BA32B6447D17825AE67ECB70EEA8B182B14FED66D2F1179B4ED66F53C56CE0C679598C09589A4B8FC1C3E42A0091FFFD4B4C464763FFFB1ABFB7DC49337C46C097027CF3BC5B14B34E590E17A2C4059E50971DF2DE66E2E714E5834BE769371DBD56107C30BAAE1438E02AD5F825A4B690D8477311871AAF7C5B4C540C0C3B296F724668862AC9144849BDF18FEAF17DF98246B5BA88C929C940EDC42EE9116F7656F1E2B40385F9B05DAB23243014FB122967B97B8CFDC369478866E57CC8D98949DE41D8835A1148 +MD = A120FA3640BC0C148A1D22873DAA68EAB217BE55CFAFD70030B70D2160C9C3B8 + +Len = 1838 +Msg = 3F06A9590EBDD717DC6150AB4A4EA1904BCE033B78C8D437C013D78B6D147BCFD8557298E44E11A6E1C82986F626092F435278DF0212DAD2AEADC09CB84926C74441ABEA04E3F0095876BB4D6463A9448B775B082B5D7F0B3AF0DAEEB9786A3D404D16C2DE8DB319B34D496B5E03C30608A171FD180E7D32A0F496AD0903997183BCAA62A57FC6450098D480B7A3F8BB7329528A1D4358B2520828BB7C3DA65577406A4C241F39461C6F03D22C054A9E736F4ACBD6916B254C7145CF73347A024B418D8801236EC61C74955345F6BBA944D8C8135B594220C104C95FE85C9BD187505041176C +MD = 3278BD9C69478C70A3EF15750136311A38EF210F8CA874C670E4D926E59871D6 + +Len = 1839 +Msg = A8A9555BC035CA2CDA773CD7C01159FD6EE4CCF03C3E43C565CE85C88A842B14C765991FBB424F01B53F7157D413F5E7D3CBC0C9B084F6205E9815432C0B83B116E1714FCF9E20C07111C3C202EBE068D4D4B6B163E42D2922B9C36BD32BCC768C10489FCEFAF472D1E160FC7C5726A89F32E0632D15679972EAFCAA4C8AD48DB3C4DBC42FCA6B12B6979CB12C72F22BA5056A12AA99CECB65A3958AB8F66920818D6DB0FF34AA8BE45739BE1FE9C991819DBC896A078DB828641F5736858BDF0ABBB3CB786C49045028F8BE1C836E8E88DE775D93ED42914AF9C7AD38091A41485B155DBAF4 +MD = E8140EB3DE6BB4BE8529C9C3FA18D2584BCA1678AC4A144F960C7FC168C266E8 + +Len = 1840 +Msg = 747CC1A59FEFBA94A9C75BA866C30DC5C1CB0C0F8E9361D98484956DD5D1A40F6184AFBE3DAC9F76028D1CAECCFBF69199C6CE2B4C092A3F4D2A56FE5A33A00757F4D7DEE5DFB0524311A97AE0668A47971B95766E2F6DD48C3F57841F91F04A00AD5EA70F2D479A2620DC5CD78EAAB3A3B011719B7E78D19DDF70D9423798AF77517EBC55392FCD01FC600D8D466B9E7A7A85BF33F9CC5419E9BD874DDFD60981150DDAF8D7FEBAA4374F0872A5628D318000311E2F5655365AD4D407C20E5C04DF17A222E7DEEC79C5AB1116D8572F91CD06E1CCC7CED53736FC867FD49ECEBE6BF8082E8A +MD = E5932441B012E503B0B0C6104703BA02613E472AD65655C085B0ADB07656B28F + +Len = 1841 +Msg = 133F3DC8F20A325DB666A5F7D9D66468C052553A9F32AD1394A2B8CB1B952872B6920B8E34EEC5A34CD64C019948CA219826CD8A5511D3458EDCCE0537E30594ED4CB6BA4253B793B9416A8634327C743D7BC81E601A09097647B3AE0A215939184AA82856FE0F8A6F03E844BC38208722756AE0AA8FEDC14D91DD46E2D367779BC302D4960E80FD8851AEB8629D6A6D10F5A85161C3CE21E83CDC91100B18B39F9CC5EC6B90B883877FEEA50A5FF5B7E2C66943102187BD71069022D7218367D10237119ADC218B261DB11B3B31C3DFB76D87E5569D397462CE9A888D047BA3924C2E3F955F00 +MD = BA9CAA01631B9FB9C332574A088EE80985F9D08F09DCF16423834B87544FE5C3 + +Len = 1842 +Msg = 7691632F35A0F8EA7E14D97B4F782FB51902A0BA5188E09551E979496011C62AEE48687E1DD9895703205B8EAD514FE531D9C44D64B3DEDAB2BED907FB07EAE2511838B38F1184BDFF60FED005C5A520869030F76E15A7C3F890B5D35803F8FD348DE11ED20BC0EE231DC208DF079AB03B3923D765DD94EE48B0BF604AF1E8567BD31576D7C221C6EFDC8E17A02B914A0D442D81FD1576F840C511D1712D1089BF465E54A358BC1AEE706CCB539EE55BE1E9250A7B32EDC5821BFB41D6B8257BDF98CF5C83CD0266C65073EFA88BABCFFB23F0C50D64B1ADF4E841140BA8D178CC9CA3C6DC1900 +MD = 4CE21378DC030CA4C17C4F0622AE455CEA53C3344B2DA189901CA3C72AF59C68 + +Len = 1843 +Msg = B1268A9996DE08A4B261958C314BE9FEF0A7234DA9EF1A84C330289FFD3D4C185DA8BE58560450F026DC2F71502F2A0E238BBC6772F51FA12E9059323ECF5DBDFE9DFB273719C63E68B1E799FF107F7DAB82EC9B60705DDB2CA9EAB37FB0E45DE36F58E4D3E6382CA5FFE8D16A57C27E8C34698D27DDBB3A28F6AB805C800CF7B6D7A38939F49DC33D2046EC0CBA8F47D96F8BFC17FF77039E5C6A32BDC9455A3F3D835E3F21B9D2116AC6F6729CA5EAA85EBF5B46EE23D2C55C4C447AE5AD7672E18DBF95E53AC1FF933611F2ECD728019688CFB266AE775445B036B364656286ACF50A12FA60 +MD = ED8B45F0541DD8725692D6FFCF5C62CE51A8C875058F37BA5834D088F4FF019D + +Len = 1844 +Msg = F6FA29C1E172DCF3238DE51B812EA3A94CBD505C5E8A7227E6A6A93E26275C9DA60A90A609D8F0DE42995870519B0A159B4042D44935A279976048C8F6636785DA95CB0FE908E7A915756BBD753CFCE8F7F72F2A42CB096D5D217F7C3084D7E45C6E54B333FFD1B35F95B748160FCE480F6E12033F6F368095ACE612766D49BB91871604C0F91EFF86AB0F0F943838823B104471C2F6229FD12C2B48F67CF7CABFA0D7BEEAFAD1D06B691D063D1C23D286F327A66A154AEE0308A44E05C94BCADF2103C2CFADD0EE48E3C793F3BB2CFC163190B573C489EE580D231F1D0ABE1B42DC9D1AE9D100 +MD = 78619F9C029DE69738F8046187186529D3DE415A93C0C9A656F067C7AE40D8E6 + +Len = 1845 +Msg = 927D50017CC3FBC15A5F5430E4F5ED97872FCD5E8DB5295EB2FBE7D3137EF7FC454A499B09F733402AF972E13E4E24B42D5F7037550A80A4080051483B00CA5EC796D4DCA3ACC32509990ED14FF32EE4A38BEBEEC34EB49CA4882041A1FC72EE2207977DA9C0DFD9689EE039F5AA9FDD37BA789DDEE2E94E4B93E896F71699C46BA45C9AD29C6351318292AA3707BA47DC2AA1FFF1C112E18CCB0886D1BCF306A0D7599C810D02A9A1FB181615CDC818E36B219F83791F89C976B3673260579986BFB4FF99FF7089BFAEEB1345B4F49802B6CCEC7F4806DC6C93E77AEC16F6950C88417EC62070 +MD = B8C1D7EBCEB911930BC265BBE88CDBC59EDB91995C44350D5AA33A037F021D65 + +Len = 1846 +Msg = 29BF8670CC82FAFD3FD81D1EAEC1B312C4F6F56D444275DCC396BBE88942E4D646920181235EDA860987824BD9D925187CCD864E602241759F17AAE0B3E4132D14808499425B93C5041E2A053BA742C1423CAD030FA29E28B96A52CF1468238E783640637C169F27F02990D1E243A2A6E967E038F1D455A39A47DCF28F7EC7151DA0ED58166AEE613C1C759E0CD99076CCF6B4B7A7775F207187AEB15E288E3DBA49024D56A91EC65812F7A113F0EDF2ED7F50013874A1320A2A86E67EB5B3FCD12AE0B0860ACCEDE9DFA7427914374956DFA2AD4619664F829B2C59038EF54A7AF0B94974C644 +MD = 20A49A144970CB73D723466840D46A16E4D16361DAFFA425F9DE8B307E120469 + +Len = 1847 +Msg = 2A4DDEDD34CAAC49ADA033A9695DD6A97722941E4B79F03F55B367EB6DEECF372CAF3D96E28125B4C43EEDCE9F2D22F407F250D5E7CC29FD24E800CFEFCA6DE46147F7BDC3AF25878C6D04BE42B50B47B767FE03779153AE14B88BF95465CADAE27FA15BE654DF88ABD6B4A275A3B51764D64F4D9A8A0DC1DC0320A1592ED2E867ED9F15E2EDF8DFC28110ED52749B5A7B5D4CB307A13E19694F2EFED47EE974568858D6DCA09DC936AAA24D7B8A16969EC54352BC495BD67963DDEDF57D5E7D8131CBA5DCAE5D08C663D35B05605638E6FB091F483817995268DAEC4004A3451711E5C66B3640 +MD = 663257D17EDD4C9199241DDAE1D2506234CF2D31E55AD37056A233E8FD43F67C + +Len = 1848 +Msg = 57AF971FCCAEC97435DC2EC9EF0429BCEDC6B647729EA168858A6E49AC1071E706F4A5A645CA14E8C7746D65511620682C906C8B86EC901F3DDED4167B3F00B06CBFAC6AEE3728051B3E5FF10B4F9ED8BD0B8DA94303C833755B3CA3AEDDF0B54BC8D6632138B5D25BAB03D17B3458A9D782108006F5BB7DE75B5C0BA854B423D8BB801E701E99DC4FEAAD59BC1C7112453B04D33EA3635639FB802C73C2B71D58A56BBD671B18FE34ED2E3DCA38827D63FDB1D4FB3285405004B2B3E26081A8FF08CD6D2B08F8E7B7E90A2AB1ED7A41B1D0128522C2F8BFF56A7FE67969422CE839A9D4608F03 +MD = 21C0D84EB7B61774F97DB5D9ACF1DFFAFB662C01ED291A442BEC6F14D1334699 + +Len = 1849 +Msg = C1783FB7FC7DB5B8EBF9A0357442BB99233369A73B0749F33C50136FCFE2479C2FC94ED87A6AA019EFAA119A2305668E116517BE31A4DF84C44B672918999C198CDFCC0AAEC695182AB1EFEFDDFB8EE2AE8C9FB981BFC69FC403C24ED7C17F564FAFCEA706AC3FC7DB4E3C08E2E488262E47EBDDE6461AFF5FBE876FB1EA5B764996B6B94CEDA388E6CE29724D6C9744A6EDFE1639138598FC5C579EED9A56FC5F68D8732DF2A4EF70FB272338BB096B16C6C12DD4B603DDE5CDD05C9686825F936EA6560D08788D35C6EF6AC44BE032F68029084B915BF007803A3B1F8E8D05C68DB8609C153480 +MD = 5C3963E7ECD492125F638B0F5370046754049DAB886F61DA9146E59201162473 + +Len = 1850 +Msg = 5FC6470564242C4BC6997B8D3CE0BE6BBF3C132A052FD3C78C6373B13031E576F6E7FEB36A848410E5E48228B0D6B18E0EB64423138A3425CDD50EBACA32D354442403B6D395CFA93E8B81C57FD074E8CC36698B5CB50932A8430AC24EB986DB1C9CE1F4CF2D71A79B4FBE65D393F0BE516C94EB471C256C6BE81A70E17081B5951F7C3CA5E84CC7270884F0A65A6B2BF8853914078C611BBF5A73FE89274ACA6DDCA94B970DE7CC88FF4911C825ADCBDABBD5CBE9A63644A2C15DF1935F4BA8A2AA5978149D5B8DD4B4D14EEE842DAE8BD5BA044B207C4795F872B4B219843C611A7E466F6BED40 +MD = B6D94D34BAA4D0AAF00280EF16AFDE9B562AD1BA23455A9B95C3F3797BCEC10D + +Len = 1851 +Msg = 0D6CA1C8C4E025937AD2C62FB841FC6AC14DBD6208A418C01FADB43DEE62CE03D70ABF8614F3F773C7ADDA7DED6EC569DB516FA7408F73A628C68AB4ABBCC0DAF9CF1EA313A8EB0D8239F3726D20ACC285B617FB3F04EB20AC6E7F588144498E40E4668D54BC7692F84F7DF2B4C2099AF34F077F2B46829D43DC5037FB3B1B144CE110E7753CE6CEC76CC01D848EF0C169068218DA9AE4EAC53D845CAF91C206B8A46B6F869C6890A09BBEF06DC65F1F63FDF1EC33C5DDC2FEAD36A24ECECD795A7ABDD3BC4051EA2B748391CD7637F1859B7A027906C2D8D922E2F20C99E110BFC67593B58568E0 +MD = 7D761270C602AE7C6EEBEAAB85A22BFB7CCD20FF4A3F3FF5D7FF5B3DC59CFB7E + +Len = 1852 +Msg = 9D68E842C8636C149AF7ABC5AC9FB685B69C872BEDAEC8765608A2A27454E4F13AF557A300DAE256835BBF4EF9256F2C9B5FEF61C51FA573F9DF26F4672AD4F97B25969AB60BA6CC5DF2449456F54F2F1ED8B4A5DD455A38BAAAB1C57C8B870C7C62F07575337B3EBEB78D0671213B22201A1F96BD82413D854C28EA3D043C5EA8AFD23D3217E9EA53B099859D5096985CBE655588F3F2E5B3A4BD6D8A12E8E930AA3EDA60A5EB3FCFC200BFF2A413C8E7D0919CC2B79F343CF792666CF9C3EFF4AB199428974C3EE7B48D48284A486D586E07CFB21FBDDD2C75B9ED90C33120D9469C0ED84A7150 +MD = DF4D24DCAE0AE8F12102C4F3262EBB83CBB8B90683E29BF775E4AA40FE4157D7 + +Len = 1853 +Msg = FC9FAA47BE421F49AD0BC84E7EE489268084C00592F45645A2CAFB817C7E33DD82005894FE333089EA8E5FE6DF3743A5A6C5CAFC3A86C3CBB4030BF743FFD944816A71EEF4FE45A357CD81A3E047C7CE8EC3B90E90AFA4BFC4FAA324A97D095A68EA070CCA14779E813733432A046F9393B08E614615A5C7B573A548349670F36F3DD69D3FA9F2228957CF4C81FF8F9A4BFB514B68D35F8E03A710577D6077C48D4B9947B1426BA5386F41D11DF6A560AFC4D5C030AB7C11E65BF2D5A2C7AACCFB05C1BE6CC7C9CE9A301CD4CBB7BA63A2BDC9FB2A71404B832C8FD2C9FA53DA520B4587EB80F610 +MD = 6B53963E74CFFA308ABA1A37DD4CDFFD0F530FAF50A340B557B84E8993D56A44 + +Len = 1854 +Msg = 30DFB1FF68E242E5C35344B6D5363F9BC0645FE35111DAB05357B0FD5F2AA4355D56D537D54A17B18DC56DEF90784ECAAF92CD67006C174BE4E232C773841E8ABA05B71D2A950568E2ADF766058744A6564D883DAFD123704DFAE1966E25A036ACB268B7547DE88534A5067411D55BEFDC0C9B98F27DA16977EDB972335D320B8954A0CD6F669AEB6764D271B6D2250F08B2DD17A537C6F6B46E1AA793C261C01056D081D48D939C70E8BD29B8697BDF8ED885D194C5874E329823457D85E0DAEE5589BCE1226B144D69544E790C8EAA77B3E771A5AE7A08E292D321304D5BD531B75E43E892EBBC +MD = B108862DF875D15AAE6A23880D00F0B7FB7DC301FA7CC31B324FE979C857B036 + +Len = 1855 +Msg = 8B8EE065F4F8E1E18C037F99F0657ADC659559676ABE160D0112EC4CDB58DAABFD58BC968CCF2BFCBF8CCF84670912515DBDEFD64ED0D35F7DAB9A21A7CE95EB0D285DD9DEF35C2825AE7C2999A6C099B5640D97979402E374C4B81E92302C24C33BF7FAC1660D04AE731250F6EA3CFF051606A5E0AF66EC669FB031310B278F673DA3B7DB78B521C0E81897D88C8C6EC7DE470C4F93C25350B381F5420CCBE2CCB56910919FFA1750D96738C3F80C2DE309889972616B31976A8E5D76CA26E111F2CCD34949BF3CAF5F682837EC02FF90981660CFFBE403C7619D2C38E764BC794463986B788AD2 +MD = 838F64832E71A53BCC62FBFBA418CFF956D88AE4848B1A312447934A776E8E3D + +Len = 1856 +Msg = 04E16DEDC1227902BAAF332D3D08923601BDD64F573FAA1BB7201918CFE16B1E10151DAE875DA0C0D63C59C3DD050C4C6A874011B018421AFC4623AB0381831B2DA2A8BA42C96E4F70864AC44E106F94311051E74C77C1291BF5DB9539E69567BF6A11CF6932BBBAD33F8946BF5814C066D851633D1A513510039B349939BFD42B858C21827C8FF05F1D09B1B0765DC78A135B5CA4DFBA0801BCADDFA175623C8B647EACFB4444B85A44F73890607D06D507A4F8393658788669F6EF4DEB58D08C50CA0756D5E2F49D1A7AD73E0F0B3D3B5F090ACF622B1878C59133E4A848E05153592EA81C6FBF +MD = 0D1E6BB88188B49AF0A9A05EB1AF94255E6799515A2F8EB46AA6AF9A9DD5B9E0 + +Len = 1857 +Msg = 4426F07482D08D23BEFE266B3289AA606B8656403368843EF5275D93A735A1EA48D25293B2FEC242DFB58F7C387F0943B53E3BDF49F922B10A89CAB3D192010ABB2CCFBB758F7258895B3680083B9BE3E7EE79ADD241EB063CB2A63C0BA4278DC9CE078257B9B42AC4C6F7C6F5AF6B3328284F1DA4C04102A456CDECBA73DBE380C8BFD9AFD2F05DB7B558CB318E15C0C4E4FECED736145BF207356009D76F81F33F25459B74E079FCAC54145DFC2213AF55F7EFD34F5567A4F4A3F6D01503619808C7FC361D366643A4D2D04678DAC223832D35C83B759887C060AE300B1F630AC2B9BD442673A680 +MD = 9048CA918204041A98E704C67173CD4AA251DE3D03A7FAEA7B1AFB5D8EB4CB7B + +Len = 1858 +Msg = 4743DAD3E151BF5E0B9090C79B76A7E425F65CEAC259F901234BD59BC01172BAFCA5D80C3A80841547CF424E52D53C66C73407B686FF44A72638CAF89A09FDEC13341DDD297795D256C3A3FC58D1925FD1029C55FA76C9AF2F277F42CAAFDE084E708D0C89DE48382D582FCF8343965EDC1552749245A9DD7DD2881FE904968AEC8012AAF2D6C52DA081682BF062D39B7DD137BF1DA53942E24E60388546D60C6E074D96D6330B3FC262D2D1053324861B4E9C482F4C4159FDF0BC739A39192BCA18D5C54F1E9748068D63E0A232C99F3504C3B211EC5C727049371D52515231DAB097C014786DE080 +MD = 61E174A7C2E8463066E0933C1EE3244228166DD6B6A7C9D0176C527BADC9FAF4 + +Len = 1859 +Msg = 3C892301CE8E40088696DE300C1AF4BC362D52CEF0BDF4BE2CB7782D4538ACE3A69DA72C6D0A04FC416EB1A6F5F24AFFDC4AC3A8BC58574DC18A0FB4117D4B6083876067E18B62D0B0D35F537D7FE57E921F361FF598194B9F12DB83D24BA10D7976BA334EAB98EF5524EC074B0F4D663E8991D568142189A89FFAB0B6D851697366A2B935BEA15780C0929368E07E3DCBB7E421B58486F6850F20A9E1B499B549338EB0D32DF8362552ACC97AA388BB81BD64FBEAD0F89938613403C43149B79CFE391505673EBC19C01169E4A3BC90C33015896C3F9EC083F6C77C914E6C774B42BE8A6948AEA840 +MD = 1DD59C3382335895589B4D1A9068C73B646558E61EBFC17C64080AF1AC0CDD0F + +Len = 1860 +Msg = E6991E70A7A1D85F9E99EAED812879054136F3A048D96156A4A0778E66CD23CBCB13197FF5FD92AE7F316AE045120BC5AC67DD4F887442F4DCCB77048BF2E5D7A1B4A17DA0F8D30A422EAADB498130CB1DB102CC68C43E70CFE883A58659549CF439317FEBB48048450D3C7D04756ED880E8760F48652FE46E41CB197A6938D5CD81D2BDB058F180097662CFF5727A3E7FD351803E97D4A2D54F2CE7F9EB76530F3D9C7B69540221C894F2164D1F98379CA174FC276E5D97B2BCE598976B7B7B658C3655461C9C15E62CEB380A35305A8B5978F44D86B5132F0EF5744AD0DC51F6D7E40BDFBE5F0380 +MD = 11900DEBB745229669F86B36BEAC9333C89C79B61C0E8241458F96FC3FF90EAC + +Len = 1861 +Msg = AF52B30D7CB6ABA2053D0208FDB3924AC2C32B931B14629AF563527E2A4E8F069DE7E3EFD5E769371CC80D7FA106F202F90CB270105FFF33C345AE2E346237C5FCDC8AB91AB8E847660F215DF3E1B570874D9482C221A5F6B445652A4393315CD60A79B24AEAB8F0086DCBD09A0979CE4431A4BF2515C5274670AD8E3F4489B49DD0DF064EB00DDC33BB778014B53BB2E61A3421BD94754FBE5B9A7FBDED04329E65FAAD493F3B4922CD8115C86F116095B46BBDD84B39CD69E484E08D9CA1B5DCDD9EBC126877DD4D6ED4227DCB3320C56F6F1E4017053841859A3BFEAA77ED640259F99A51BEA460 +MD = 821A65955CF1584A39D5F08E8D4C1D031E245899CD5881326474FF6DF6C06841 + +Len = 1862 +Msg = 42AA49F4A2E8B72F5621122E00B059647A8C6ACD8400BCAA1EC4BF95B5E3A093D32022C6016F42581C9C2C3DF81105B3EE9D53BA623333406B4319FF1FA71F7ED8046A6B2892F601A6AEF902BD7054E67437C23CD00A28ED3275F6163EE2CC714C4B31EADA0451E40E0A66DFF244595A10E200582D19D1B78DC70B2895DAFC390D2B9386E194CAE4429CAC6D98E224015645E2827E1C016AC54737CACCF071CBE8E91E601C5A926B847C60636BFAB114158679D0E451AF3F3A97D716F96D92B51FA5EC90165416DE5633B5B8BCAA6B45D599745EB31AE3BB98C6B19E6F789BA6E21EFF754B16A4C41C +MD = 4F9CB3C0B0C4F5D8864D9E2F0434E03662BCE485C3AB5163472A1019BA632E7B + +Len = 1863 +Msg = EEF6D5C6F1147E9A29D854F15E8C5BBB680BC09EBFF8BCDDB963CA5267C668E648B47024F3972C9BCE05E74753735BFB45C50461D900DE1BE6BBD5DA4626BA6548BC7A47A8FBDBE45508A5C03C6980731BDA8BAA557EF6AE6117707F153D91982E1CE06E89F28D576B7602C3AC7FE77C34AAA1D36572C58A8A9A39F20A608A9EEBD4108F664F66D454C78EF4883E1C8C37319EC69C88063812A5FB2BD23AE9B4E49DF8F34FF9FD244D40D6E1A4B454CC6ABB4716C75327E5C46AF21EC8B0E1B0520BB16E4638C1BF3C9A6F8445BCF3FC9329BC626223CFC97175FD0A16EB8730F7EE2C8CA5CBFF8D06 +MD = 1CCB3D97406F4786453F43482E333587C5362DE3CC12E17BC7A1CC2AF84BBC3A + +Len = 1864 +Msg = 7C815C384EEE0F288ECE27CCED52A01603127B079C007378BC5D1E6C5E9E6D1C735723ACBBD5801AC49854B2B569D4472D33F40BBB8882956245C366DC3582D71696A97A4E19557E41E54DEE482A14229005F93AFD2C4A7D8614D10A97A9DFA07F7CD946FA45263063DDD29DB8F9E34DB60DAA32684F0072EA2A9426ECEBFA5239FB67F29C18CBAA2AF6ED4BF4283936823AC1790164FEC5457A9CBA7C767CA59392D94CAB7448F50EB34E9A93A80027471CE59736F099C886DEA1AB4CBA4D89F5FC7AE2F21CCD27F611ECA4626B2D08DC22382E92C1EFB2F6AFDC8FDC3D2172604F5035C46B8197D3 +MD = 935DED24F5CECC69E1F012B60B7831ABCE7EF50EEB0BEA7F816C3DBF2B4ABDC1 + +Len = 1865 +Msg = 4DF4BBFC86C99AB997A02CC93519BA1B6D58CD568237DC930E71C4963F48F304AAEB102EADD5E93902C441368752098DC02CD9518B1FD3E26FFC1C34E6773866432E25F552E44356C2CAA4A1BF375B73E17561D28DDF85C8FE6EAFB3A17D51AA0D512BF106B4325F9BD0F47E532A6D9A7DAA2F90D8AC43426209191512FD59816F245495CC6FC14DF5826D34B2381A1812B3CA9C4C8324D7D66A4A76F7B483032BAFE76128C5853968B80152D21CDC2BE64BF2AA9439C178C264062AA61097DBB287DE1BCEA6AFFB08468D3751AD533B4357CAB562E0105A0F848052DF66DDF9E2B7C062558114019D80 +MD = 37DE765CF89839FDFC382E5EB75C0C2965BFD59AD12EA24004E9E8DDE88ED4CF + +Len = 1866 +Msg = C1FD4A92ED91E80437F2492D1F0933D8B71AA1FA1457C8243EC5C1A4DDC1996F04A3AA922EF7571F50D11CD10155C20D198D4BE9846C4C46E5CB8F602241B7033E542E7C8BC4D03570B8D7DA6CAA74B104856CC97BE1510864D7566E76CD19E8182C496F94CA7E9A5A2329323B665F5BCF41A7BB5BD8D729A4876D7E9A76B7764B830FE75312A3F268DA28E476985257FABF2C04263E6A1D69E9F5C34E11CAE04CE015A731FB1B492F405A271D6899184C4AD3631FEBB554021C36DA8E2A5864BC3F8DB8461D0B7AC9AA94222119DBE9263E0A9CFB8E8B98F456C1EA717433B4BA8A509A5CC4631140C0 +MD = 4960DD63EE6FEA3A03451AB8A779BCA9FC0646078F58223DEE2A60A963664159 + +Len = 1867 +Msg = 25AE6A6AAF2D2E5E0E0F1AC428EA4A982A601334D7527E9A0B7D699EF19C0584C5332623D4A9418156978F763F6C142009A76C5DCCEA9FAD261C93D9BC851538202745BFA220EFA3872C60D28C5A45AC8F85011F95278A28D029D0947B6EB8AB359FB4366DE97A757EDE3536B2EB7F25026B5179F32324E03086D1687CD1F335874F2161FCB387300AE9C460F8BA20468AD070C64B94A8D8E9D38A5C1328983CD26000F77508AA430A49A5444BFE451C19A2ABD1DAB0492C80307B61240BC18F24B2CBE2DA5AC8FC85C9B2FF984D351AFC303A83F4E3170D02B8083EC2CBB7D671A9B2AEC95BD719D660 +MD = 05E712544BF2507428B21341DB7A0398CA3F5D8040C9D0E906A0D764D4A20B93 + +Len = 1868 +Msg = 4251F3233CFF0E056271F186FF88284C5E29990FFFCFAB44F9CFA2EEBE619B72C3681DE8AFA75739A6B9DCE88F4463AC03F1FE21139E45C968F72347A6DEEFE78863DCEE29E2309733A8B477AD67524A4317E47A40C2027992C057A934A9C09D3C4DFBA062F4F653626F2E65AEE5C08378E9B5FCF87D937F71320E5D8CB9A5CB89360A0D7BE1BA7628AC1B0253D8280D32F7C03942A26659768AD774D95AB91269DF18576DEC613260872C558534C80290ECDA296DF12F6407390D78E7A192FEB2F4CE67CECC90CE7DC62593B3610D8FABBBA4C1E468815DFA614767F3AC0BA72FB18899426D3D76D6A0 +MD = 377A6A24459864ED9F4BE7E2FD621A86F8B7F870C741FE30C46D9E4821045C60 + +Len = 1869 +Msg = FEB6A3B8C8168406BAFA4C6C4D437B0E5ADA67BDCD5383E2217005A81092047263ED80F09D72EFF2F1B39282B94B2AE5A79D099BC8AD3F38E124644AC5825A37C22506048DF9AA75FFAC09EA24BB218E1F7730D354FCADD36E02122765AABAA7D56EADE503AE02113A52011A87AD7A113A717608BDE4F8F5A1DB524901B582EB2FC351612C13E604F425AA333C5C5229DCAB69F0E02821F2C00045BBE119975AA82043BD4AD5B8FCB57C3F766E7DB60770040419F4DA26846803E2413A356B607952049B8F5E7C694B0DFE703768AF3A8BCA7C5446C01C7A257D0D3476E5853DFB2BB329BDD12B14ED10 +MD = 6183C3DD1AC3FB4241FF06E51B204322B8575BC25E41A622531EC14F97001083 + +Len = 1870 +Msg = 07B0807CEBA5AB708AB70FAA26C57DC848357CE71F54B1BBB640F34C2392ADACBEF2779999ED9ED0BEDA61086E3F5C427F3FEFB6D9CA7AF1DA684CA977D69B755CF10B5DD9B5D229016329ED7A8C5BF65E86AD07672F6823897A700152907FC188A673F1F748BEF8EBAF740D08403A34FDC6EA6498B552766509387440B9E557C3BD2775691DC1DF4A70D867B8DAB848EE1272910CBBF2FE02B836A4F44B69A031C82D4E86758E67491DDDE0DCE19F0B30229213BE2C4EFE138D21B746D7B76A3E4370F46065736A06433AE27BCF475C1E6B99BE1414B2C74EFCC8C5F209B5EEF747BC491021A1B1AB7C +MD = 3E78152A23335D769A5817D8F756DEC403E072C760F38EF389A3EE8C8D186365 + +Len = 1871 +Msg = 077EE43315D81DA192AD7FFDEA1F8846FCE8E6497BB577FE0D84A3B33CB09997606C10E735922DAB8CE9508BC5FC9216493DABFB6982C060C8658DD0FBD3820386B8CF69C299E478AF4B46F677DF77B10B4416F87A984ADA7BEA287E7241C18F1D373ABE08B69D2C3EF3191AE6D88B794A2CD49AF24DEB98C24E2F647F1C97D37AE5BCEC2EAFED490C9153722ED8B8D2A1DD116EC398E147C6A1C15098FDB40E34666DB897A460622DC22C5E0EF0A7CB3A44A7DF8CA1521FC03CBA3DA3055DD0EF57DF1951277FF196F310B091049219ED89B9FB9AAB1E8C803458B383F75F8B71E466BD6B379CC445B2 +MD = C6ACB257B13AA983D807588C20AD575EE4FD15FC58D8BB07860FF103210CEAB4 + +Len = 1872 +Msg = E29D505158DBDD937D9E3D2145658EE6F5992A2FC790F4F608D9CDB44A091D5B94B88E81FAC4FDF5C49442F13B911C55886469629551189EAFF62488F1A479B7DB11A1560E198DDCCCCF50159093425FF7F1CB8D1D1246D0978764087D6BAC257026B090EFAE8CEC5F22B6F21C59ACE1AC7386F5B8837CA6A12B6FBF5534DD0560EF05CA78104D3B943DDB220FEAEC89AA5E692A00F822A2AB9A2FE60350D75E7BE16FF2526DC643872502D01F42F188ABED0A6E9A6F5FD0D1CE7D5755C9FFA66B0AF0B20BD806F08E06156690D81AC811778CA3DAC2C249B96002017FCE93E507E3B953ACF99964B847 +MD = 6755BF7E60E4E07965BAC24E51B1DE93E3DD42AE780F256647D4CC2EF8EFF771 + +Len = 1873 +Msg = 71DAB3D5E14975584855B425C41A4553606B8D758FF3D9897F173EBEE24BE2D269E0915FFEE407582B4FE64C1A1252D07AC56FF7D164441DA25CF75ED3BD15F582A41BF97B36101AB73D2495BF77F77277A52E41993DF8A6A889331AB48B4BFFBE5486671C673F618C7B758FEA417D358FE1A617A6F5A8BC3619E1A58A1B5B4A40AADF4E8DDD4CA6B557E777FB7EFB7E755F3E4E0DFB6E89A53380B4013BA9AD071C3E147417BB663867F65D478DEE59E71B0F753015DFF08207DC4A985754B0BD81BA2A9B66DAD4881FF73B82BD31CF62B2CAD3591EF3EC790711FCAA3897BDA87C2DA9E564BC30601D80 +MD = 6287BD04E9B9A03CB8D570017869022846A98792F7455DDA476CD32304D9935F + +Len = 1874 +Msg = CBA489942ED9C4FA6742C4442AF01F4503857D1BF17107169319A95B03DB4DA89379875761C26E82ED2A87EA5B532DAF6C9E3E12E6CCF8ABCA098D6ACE16559C87EE70802AA6BCC24D322D3469D59EDCA58B485A8D761707B2AE6A17746F75089A4FC0AD748B5AFA77DA2D32F2DEBDB7E0204343B6F732A91CE97E6694EACD38DD31BC1FB319B5322391FC69F4E6EFCF87ED5D75FA43CEF00A7B64554D5022E41FD07A09E0B08C8721FACCFAB978CDEFA81368AA965F3018D40D1E3EA5A13C2EB45508EA71B9084F664970153A36FA115CB538FF98B082CB2674523876CDD60145234A23F1BC6E80D0B340 +MD = 205C6FD77899A9095496893A4EB55E3693FA7A4B40845239740C927392C8385C + +Len = 1875 +Msg = 2A2084884877E8EF481192AAEFB04AE7E016905FD19EBFE4AC13480224472DA2AC2EE2C2A652C72B1EE84C090B89F015060CD8ED31A320EE8CDCF0652197C8290AEDE81EE0109FB4B5F33E96AAE6004099AF9FF74E0C0D3CC69B5E655C2E6E2E8AD884C184D96716FDB8482EF16028E08C9518F505F9FAFB22A5B988246F2F45C7E8C32A4CD5ECC7C8667C5249D294E691E3E7855EC547D18F5FDCDD062FCE2809873D53527EF72FF707CBC994AED439B2364C10E6346D52BC8037C6D82E73353518CFF35E62A453E5F68ECD5F13A2F0E55A783923B41D8FB53D0C853DFD40E5C7CC8914958D1394E76C60 +MD = F5FE09206C722F492DE4335713DC03B6CC308B09406B5076205EED821113AC64 + +Len = 1876 +Msg = BC7AA0446C7B561CD3CA9FF43904F23C761B83F50AD0F489EBD9AA9C466771F1FC6C8C77D1C9C55929532DBC1456D0D4ED1E7E9FA1DC9AA6013B555C217D480DA0735997E8A2EF951D978936351C444CBA6A4CCAEBB3417616677143BE2F4B4DA61D1B8A385185F74581249B1212C7820AC6DBE0B3BA8081E259B78E672152513E357943B927E01EE4BCA4D903775E6E67195E105D9F513F679DF949D852ED2A77B96D14A967D76D34CD4B18F8C4970DDC95436EF8614ACD896817954D2CFB995AED03B3983A72FC67F3BD96949B1FCBFA6E26ED6CC2DECDD4EEC72787B868783A9B1758AFB2BAF1BBC010 +MD = 16103427F821162B18A769257FDB258AAE270C3C9582A7008B8F516FA0BB0ACA + +Len = 1877 +Msg = E91BFE2738D209FE5A8D7DF18EED381E2119D4EC5C507E7C3776F4EB0389A67B0B4E1D62E71BF71C37F84B994624DE6CA18C2C5D50E1E279EE0989E526391E63063E55553DBCD3AA08DF0D10A2D24B121EAA009A57C949498F9B21D80D1A81BAE55BE5F902B035406AE16E1BF7EBC1E21B377D3EA4A78039C5B572F2187D4217181741EA9487EE2FC4B6295EB152EB66B62F83E38D1B090AAC2E82220CCC46F8E1C16EC2D772805C6ED31243C5C976DF1B25F4FA04794716D9E60C84C13FD17350930C2B9D01DD44A19E2783B4E2DB7701996DC612C4246AF2428EEA9CBA510B14C9AA6C71F66785A5B2A0 +MD = 5D4181419FC98A6CE71979B64AE87167E76FFE4175F8D73355C24E04FFB7EFFB + +Len = 1878 +Msg = B5B7B936D7040BBAF4F133DABA95410B59734A61C50659654B2C441C4D74FC5BA926701516457F66CDC65603DF61E3D0E44A928537E438880EF48E93C29B60BE180BCD6BB28C32B30B29B20812E138C554EC8824CCCE7E49A6B2746018098056539133DF334C92D03F3DB12F32316C15D236576F00392D4FDCB065B4C8ECB96A81C4492CD93DF4760212A7CA123F019FE2EC2F9FC56EEF3FB7F21991F31621C8082E2032BC45754546C016E449DAC7B70DCBDC63FABE31E7A806FD226C798F8B34CCDA13EDC088E6DE58CCD03379269F58E583A670C71F5F96683106967E56C29EED242645AEA259CA0D2C +MD = 3709340D85600BF96C79079338ECD1152D04425C884A91F9ECD82CEF6A86F4A9 + +Len = 1879 +Msg = 2D9FFFF282AED376A69AFA50A700619CA32967E6A057A851B111C5387FDDC31BC54300F7233EC3A19FB2BC9EA509FB1AA9F2A1EA05D9427CF751CCCB39B3418A3BA0F01D63BA626A7A21B88F8D8A6DF57F178160C829E88E6546A65E0EEF4DCB0E5AAC1391F2E7C4890B90B6C38BA1A5828CE4D80119866F3F33DE9C029C1A8E89E7152961CE5FCE9013534A91A2DB42B086E7B9C8C6589474489103CD0FF683ECE788D889C81C75C80394613E0CB66B6B6FE962E356E3EE9B159F1460B2D753E2992744C34489DCAFBB429E4E151CFDB1EC5D43CDFA44FEADD2C1CF25C097EF26C48113E5F75BBF950AE0 +MD = 5213098BDB6C737998B438952079D7C852FDBE412166A29A93595CC476A2D40D + +Len = 1880 +Msg = D85588696F576E65ECA0155F395F0CFACD83F36A99111ED5768DF2D116D2121E32357BA4F54EDE927F189F297D3A97FAD4E9A0F5B41D8D89DD7FE20156799C2B7B6BF9C957BA0D6763F5C3BC5129747BBB53652B49290CFF1C87E2CDF2C4B95D8AAEE09BC8FBFA6883E62D237885810491BFC101F1D8C636E3D0EDE838AD05C207A3DF4FAD76452979EB99F29AFAECEDD1C63B8D36CF378454A1BB67A741C77AC6B6B3F95F4F02B64DABC15438613EA49750DF42EE90101F115AA9ABB9FF64324DDE9DABBB01054E1BD6B4BCDC7930A44C2300D87CA78C06924D0323AD7887E46C90E8C4D100ACD9EED21E +MD = 62C9F5E5B56E2994327A7F9A03888DA7BAD67E387593803B1807482B137B4509 + +Len = 1881 +Msg = 9B5DF8D7D727C54D2E19A7A525180CFCF88067B5C5205A0A41713EDDC19A6A0CB8DD7C1C1DE7E9F038CFB3A9D3853CA1D24C2D17D55B0310C2BC696191C2D7217177E00DD4354276FFAC3FD8FB2414E309937AE3BE9B94CC3D0904CCC966B70031FE4F589460B1E831FE46C579F802AF8210B48D15409FEFD6DA627DBAE0D17A0F9E95A1490EFD05D458CB4DED08BF6201E4139CAB7BE67514F5766D75AC28BE0BFE57AEBBDD81FB6A3C2A5E088AD72312480BDDDBC85CCFDFBEB13A6FCD0970AEF6F00AC922B8EFCE8AEA4635D15C63370E92F6DFBD2B8201600C81FC58CD57148CBC6FDF1D862B30211480 +MD = 1729A4CD0F541CB206D4EAB852E2FE8EF839F3B576683E5A9B90515EE1923446 + +Len = 1882 +Msg = 6D35A20EAB3E02B1974F66603A111EBC5D3A1BCA88226D2172215E57EFB59DCE76E78E55DDE1B7FFFE0F1F9194AA9A7C9A88AEF15ECA5577D5AE885F6C1E94B960B697D9210EE5E08801CD5727CB870C5CF62D2AC769D52527413210DB7DAB8679C1EF0AC288B4D20D401BBD503D02686F8324F7C441B9CBFE85BAA147E24E4B93286C9B24C6940C4391D0CAD11F75A5CF326AD6033BB160651F5B8F825D4F460BEB14C5680C6FE90AF460FDBA3EC45CE26BA68649B88D9AE0FA737B88A4DF28241D9DDA4F24C02B53FB1063D54CDA4780BB877A48206C20115147B3ECF238DC969E2B10EF0BA8B2CC2BA5C0 +MD = 8891055818A4B8A675CCFF43B220858536787EA72CCADEA68CC3E3631340F9F1 + +Len = 1883 +Msg = AC0DFB4ACEF738945A21058C6B8E9728B5F5D8BEDC5A62C65064CEFB085C1BE69573CB7261165EFBB479AED2920235521FE64D09B5B68BC666B22014078F4E08072B854584D2F8BF910BEEBB018594CAAC5B5B734592831EEC4F954A33C506524301D28CCECC3D7D60C0BB37F25FB0286F0A3D24E5FFB04E2ED33F17557EE45C1CB50D821929AC534CAD695FAB1C12A5ABC44AD5818CD0F899D7023FC3D1C797CFBFD7E7AC6FFB79E367BE21DAB7E353DFA5C79B69638720BC914102B599F130052A1B81C373856CD017F647C0EE802F3600C5D52B4EEF5DCA52C82A4D0814428BE9E37443F9AC287D430E40 +MD = BC1ABD85BD847819E11DD8E37EB95751D123B9724E0B5E3156E72C5CF7BC3F9B + +Len = 1884 +Msg = AD54F5E5D76DD3B229155AD1F3D9063BC1C624A4E265BCF03EFC4475F3ACD9E85661F836E3A25FD2ED900AD6F43FABBEF7580D06D54315065B2AE6EA76FCBD28564382D0AEC2E61CEDE74F8C14A67E722E6177154AD1875D9939F9EDA3E3C7A84244D115B0907E4D0C9CC6E8FDB143A3444EC54584D4A909358A715ED0F43D108C44ACCDACC366CD5614D560F1F06A398F5DF4C6A00391EF89F97483B8FCC42C14E2D154F4E07C3F8A2D6026A5BA025CAF46AF2D374DC7E8B2301B0F500F43BCF1416C3FD87709A204AB342C2762471D28ECAD10C852D32DC053636465DF2265674855C72D70B306297F5290 +MD = 64FD3282AA5BD7EF2EE8A3DEB0338780E38E4943BDF1E8F1F04FA46D638AA6BC + +Len = 1885 +Msg = 53D52F2032B1C46D95C57520FA0CF46EDC7BC6C0C33001D9627E7FD56932C7CAA7CB972083039C1E4060405D210FD60E546997D9D912444EF583455018FC3CFD51F9A4705BB9F6DA7F629A08B23F3ABE6EF27CD6CAC03349FA5062E9B9CECD5DD4EB64655705FA491C6AB62012E35231669512AD5DB1AD4185142C3504835E5B5CC4A18D9EC05DB517D5A05174097AC305137CFC30DE721F605DCBFA88465C1D693C69CC03EBEFAA36886BAF39DEC8ED6EDC49EA34E6768EA13D462C6F9827AB031FCDB0C514851A5F8754FB451E1EBE55CB69BCED93E7D05951152E8DDBB6F57B838CD1340C4C01BD33CF90 +MD = B035C1393C66120D927FF0DD65E5E29F1E5F5673E4B66239B2D695BCF1CAB2CC + +Len = 1886 +Msg = 21FE58214464B868040194D4F73D5C23118ADAC415179F783E76ABFB26DCB8426821E42C350A5AB99E1ECB27BBFE87C35A5E30A1420DB9E82A29A7FD9AAF22768946DD8395DC015F6EC475BBCD8446C89A7D76B4F15B3ABC12DA9B8394402A4A336D4EED27AFD435EB72C91715E06F6687EB0355B89D9966D7CFCE736519F50CEB43E1FD4433ABD1DF3AB907C52434C15E02DF9CB91AF7A90FDBC0DBC59E5D3373D5CB0A2172B2FA74700DB3B7923CFEBBF84F0F51F63999CC4CDF2555F6314A2CAB5EC7FBCEAA7BA6B1FAE3EBC71D605E5F9C27DCA3ACE176DAC25523E511B0BBC52FE5F9C5F299C381D488 +MD = F5F7009458C4E598ECDCA5661B132F7B9EDD4731E09984FE379680ACA42B4A38 + +Len = 1887 +Msg = 0DD7BAA7F00F3B72BF6E9F5EAB0176819ECDA7AC23AA78241F3D885EE7D791200C0970280D7772805E2806846882E7FBD0B09062782AFE528C69AFB1898568B748906264965BD2730F93F3501EFFFAA2A972DC37EE3B15BA330190A1945DAF78E0C75E191082F604240A6302D23935B13222347EBFFC7C0CD9B47FD7EF152DB68FC15374F7A78BA6CFA1272173C34F73051202C3D5D964A07AE03A12025E39DDFD4A5E7B0B95B84E81DAE08A0038F5EC4457A251483C4867D7E3F2DE4373FEDB63FECB542A936E59DD71EBE077681D3BFC6BB6D624E04199937BE910A5FABC44626A6ED49864C0C4B7A9A1FC +MD = 522CFBA6508647171EBF5AFB23AF09702FDD94EBB46A3687B81CB3C4E33AB782 + +Len = 1888 +Msg = 3A12F8508B40C32C74492B66323375DCFE49184C78F73179F3314B79E63376B8AC683F5A51F1534BD729B02B04D002F55CBD8E8FC9B5EC1EA6BBE6A0D0E7431518E6BA45D124035F9D3DCE0A8BB7BF1430A9F657E0B4EA9F20EB20C786A58181A1E20A96F1628F8728A13BDF7A4B4B32FC8AA7054CC4881AE7FA19AFA65C6C3EE1B3ADE3192AF42054A8A911B8EC1826865D46D93F1E7C5E2B7813C92A506E53886F3D4701BB93D2A681AD109C845904BB861AF8AF0646B6E399B38B614051D34F6842563A0F37EC00CB3D865FC5D746C4987DE2A65071100883A2A9C7A2BFE1E2DD603D9EA24DC7C5FD06BE +MD = 9927FA5EFD86304E73D54AA4928818C05B01504672C529471394A82E049E5F95 + +Len = 1889 +Msg = 6EF15F1D7C11CCB07B7B3FCD92C8086B27C8BFD1728F6B4AFF7C29DA17D2B3E5A2181181BB4B11DA8BB2365368594A50CA9B07969753724F2BEBCF7D208A6CB02AD7C8A694C8F86B551BE9A68D98564A941090EF6E5E751CD39909F87BBC7B516F9A829E3AE277E287C3548A69EB1019D5BE3951C6F3583B1B82F09A339E8C236B178C3C9DE3E85F6CE38E8B6AE0D02C0B7BA75DD589887A834AA9EC1B3F50D3495C72DAFC0E67E5FF5CA36FAE7155230A1C54EF30EBC3508E775DFDBF6BAC06EE23B6EB8ACCF8FBE8CFD2A45CB268E11FA574B016FED1DB09458276F53D8AEA57B3AA046393719127F4A07700 +MD = 48970883612070E4E2D4FF6E3B4B25E78CBCF52C0E725007E1DD18795B9F9D74 + +Len = 1890 +Msg = 8F1FA4E6804B6EBEE7584B7B1E2F76CBBCCC1699BA68DE8B05ED2DE8F4ED2107340E4E1DA49DC7E72D96251A8EA551DF35410D4296250D71EE5FE4D8C396CFB48B2E5F2B184F7453E0D74FDCE51D99DC2A39E4AC291BF18BE2EF1D5A1A02DFDC9DC712D5A1A45544B1D45F279394F2316212BF7B5A0E7DF002E3ABDC57D91D7AEDC8EF95F0ED7F6E38EBCC7BDB7A254D6D50EBF8D4D63D27C8AD5F4DD843E4B7CB14A57349985A45A326DBE775AF9E97909A84AD9927E614A4A6D7EE825F84B5DE6695D1E9C651BB6EF57DEFD17E876D8CF2AF552C2B65C2446B177D76C02E0342DFEE23E4D7CC0B994A122080 +MD = 9F100B9428077A2608EE34AE3539B21C42616468759506628F9FFBD413C94065 + +Len = 1891 +Msg = 86045C9767C27085DDCAF969CD015AB4B8FDD157E1993A98708376BD37ACEF1F9D057D5A1B25FB1AEB74C361EA478A37D1ADC261ABA42555AC512B81FF0E689E1C76830BD69F9BCE4447B452300216452099D059B8D67EB157D001A0416FC2701384A5F2DAABCBC94C7FCED505064C1F0494694F7007FBFC4D43323E4C8D719DAB37C0E2D73D3677B3283114C41F611DEE02390466A417F43734DB9FDD0842A102B88238B5426250CD92F98EC91C540EE24C3F5837BB8F058A08EAC3FEDF32E25BEF8972ECD1D9EAAC379E1939541CC8542303D75F1D807857E545989844DF52F3C44587CC21102541D987B9C0 +MD = B4D76FEF1127F14CD82F3B1617CFFF4114092F7154EF0C2690852E56CF76C828 + +Len = 1892 +Msg = 7AD8A30BCE5DC62809ADCD37A2579DBBE2DDA653502892B72E2F9894DF9F4825606A13EE7AE4D0590F2F241C6614660E77DA5BD8D55D6C6F02B614E62B92087FCBD24B2E0CF746CCFB1C3C3B5B41058786AFAD296D6FCFE9B53E35404A7347720D1EACF3837B4949C6CD9317E18F8D2C3AA2326C4B848C44D524D140DD2555B4C6E96017DBEFBE3C473CCE502AD528636432FFCB4DE6F122EF2C9A05B6EBDFA1286EBBE42A131FBC54FAA8D060DD9574B363216189191AF074925D19D22B79FFD4B00DFAB9E6BA72F3EC0BB2AA1FFA170AE34FC413E5BC424D41C34AF4D991128FB3F5B05459A96AAFAB37C740 +MD = 48858373A2969929FFD88FE5D400A4D01BF77DD1E5E7B908F03E90341AA03222 + +Len = 1893 +Msg = 385AF75BE90E5622E14E98D775F6C880B790683A3369801A9DBBBC62D40467ED2B1F0DA3EEAB036373B8E374CAC3044D1D248F06B8C197D20419A2E8D4E7AE87E8EC56BCD165756475FA98FEF04CB81035552481D7262E5F2DD872C750C15EB1E02F4EFEA20890112B958717D16CBE93E8F2E33A83FF6DBC3E04BF9D89F03938526E1C277F86F12CDC1097CB13152585952A6ACEE5027206FC6FA3D72C8A3B3D065FEA75A4D1E2BE33F0E32A6628AE7541B0E81088CBDB7905140ED757E0A5A7798326AB0A26FDB85D9AFD35EB25817C6B2608A1F20A1FDB198CD3A72422C7512F2C744234826E1254AB8B7038 +MD = FF86040519B3BBAB55E5D92AF8BA4F0CE8079FA22DB0E3FFABFD6BEDC49010B7 + +Len = 1894 +Msg = C5ED28E519062E99AAB7E01D6BBBC42FFA0CC6E304E8D489D8C854BB2E4E949EBCDAB329E147128AF11C75F92988AA1A42875CDE9AD9FA4861C03F4A66018B0496A06DC48E70E15E2A7E51E35AD6B4F15220C249BD40ADD5DCC9C58C844383BD436EE9803C87D48BE54974CFAAA19585587FB088E0F8580A851A7C7A2A5E5B2CAACCC09E9560298129972CD26FB603FC5E86425AF9659B93F3F6695A1AE7EED525F31C717FFA699ABA0ACAB0317D7DCB786FC1F238C0B3D826AF10BCDB372DAC68C219674E7E9F9212BA4EE0E2E156F1BB818D4887D9D195247108B4A131448D91046773A6F48FBD748FAB9F04 +MD = EF04583FBBE2959DB8C3C8B0D38C67A7162E3252F3DB7569F04D71C8CD498432 + +Len = 1895 +Msg = B3303FCEFAA4765F0F8BF01AECC4ADF3BCE7CA9F5DBD9FB203EC0347C583A477FE8D7AA23756C47B2F8F76C1337305DCFD2AC0942546E04F30F1A4661F36EF4CC10A49905A2EA717D5E2AE1615330290B06E0C2DD6C55BF3B8FB06D49120D1B28B8EF5B7FCEADB97F2BA0BC64B458CB1E79934393CA7D4E03C7B3601367DFFA70B0AB51865389C817866F73E1279D97D762350737D9E16F6CD64A09391A956316D63BB611B580905A9670EEC91749CA1D1041324729F3E35248E183E6113E08EB6674B06AC41FA391762C8B0D1FD764D9828F314F80546EC300A26AF32ADB9F838214E457301F1805D2A1579D6 +MD = 0E99CF7CC075338F56BA592C8DAE5840AC5A00B8700090BC8E5BFF8536ACF654 + +Len = 1896 +Msg = 1861EDCE46FA5AD17E1FF1DEAE084DEC580F97D0A67885DFE834B9DFAC1AE076742CE9E267512CA51F6DF5A455AF0C5FD6ABF94ACEA103A3370C354485A7846FB84F3AC7C2904B5B2FBF227002CE512133BB7E1C4E50057BFD1E44DB33C7CDB969A99E284B184F50A14B068A1FC5009D9B298DBE92239572A7627AAC02ABE8F3E3B473417F36D4D2505D16B7577F4526C9D94A270A2DFE450D06DA8F6FA956879A0A55CFE99E742EA555EA477BA3E9B44CCD508C375423611AF92E55345DC215779B2D5119EBA49C71D49B9FE3F1569FA24E5CA3E332D042422A8B8158D3EC66A80012976F31FFDF305F0C9C5E +MD = 84E056BF7BDFC73A3AAA95B00A74A136D776069BEEB304423BEAD90120DB6350 + +Len = 1897 +Msg = 30464E409A3B937C485408A41CAA7CE8421BAF61D2B7DA168CFBB9405474ACDFFE48F5D8F4DF6A72BC4EE068439A25048045D51A8A47446785C005798FE8A89EC63AADBAD883DF27989B159D04459CB3FECF20E32B410A39785D2D03188B012576FE15E5D2E7BE31DBAD9B7697A08CC49E6EA4E53218BDF1BF3D2107DF74CC05923BE9DDFB75BD1692AAE1908CA32F4AFD9DA23DB66BC723619498E0697D3934518F06E2D0909B8571096942ADEF6E31B5E31D0853C36334F09F7AADA41D4D0AB49AF327DFBDDEADA12D7AF97E4D5D7989DB22E1F8EE44FE2E36646A6E1225C8625BBF9A63A6769F5C191FD11A80 +MD = 09E688EF0B4CA068DCD1408E5D7F48D376EC63414D7B6603C95299ABAD08CD47 + +Len = 1898 +Msg = D0D5DB1EE32912B390DBB8642F314AAAC36F58D46E98D508DE2007ECB63F487CFD2DD81930D003C60E7EE781FB987959A86128B754E813B933B91A714C8C2BD09C338C3F2170D3753EEC2FAA812F81C287276B85371F398EBB7CDCEB9C20528FE9DA86A1C19749173C62A1917CA1DD82D5036CD241A45D0FA5733C8986B9954C173CED51C40FA1A0A0B8134DA1ADA8019615FEE4BAB7253600513CB960DFD335D1AB376B921E4D47A1F5AD75F88C7575EE32A5B2BF175EA230995B3252632C1D4B7B3E4045A1EFC0C6EFF757B31CB1A29C80AF96DBFA4BCDECE8BAFDB2EDC6F0F85D6C97157019FDC7B3B5033380 +MD = 8BB1DED4268B22BA352A03ABF8581C9F48DBADF4585A31CF7F6D1B7184B162B6 + +Len = 1899 +Msg = C7865E96161416FBB9568C2667F7B69C2AAE38FEEF6E89FEE038199C889E72D1A0A7EC5E37181C2D6BA903D9A14D6C74EA1B009179BA298CA72BB9A6E9D5CEE1E2C03719D850D7703C692C83C58D57FA2EEE1AD28CED2CBBA6203F1FC16323A5352D08CCF63CD1E69DC35EFF1E07D1240EC099B956680EA8F7E907A42C8A5D7FF1C8CA85046113F337C9F5DC5F48DC2BB8CC548222274167E61262124E4483725E5E5CFCC8BE9AC6FD8CE4AC978855F9A63023187F4031CFDAF75D1E9AB2D500F7578770E1F08FD7515EEF064B6B0D2E1A6E37628BFE68CD33C54E5FFBFA0F2C3C129902F3DAD6C3EB2AFF4431C0 +MD = 4CC5D7F930483A914BDFF0822BA005EC909E8C4D9666BCEDE6EB7048C869F5F9 + +Len = 1900 +Msg = 6A0D95FB7E1385C290FED05695D0F9E1BB07CC16A34E4BE0C6E9AFBC809465EC091FE41102C9DF99797B33DE52459A7CD266D5005F33F565CAB3C020CB9331AF08D5AEF45F59242FEDD25A933DFDE0FB6ED5537B0C0F132D58CE45ED874A91D1030CA3D6ABEF53F7EFCA6658941769B9447649C92E062C863FC8CCEDDF87984211225C4999592C6FE591F4A31D397D96884304CEE028EA830222B15BE306EC567E2A2397151DE8D1D670D80D0335D78C3475BC4D3AF25C3E3851600D2A9EEBA5CDCC48A438E5D023D8EBA08D1A6445912BACC65717962071D96AB499A5A36C950573D801F6066E9E0837363110C0 +MD = 2C703CF300F3CC9A6833A494A4587C855A4F39A802B8DC20E7F8101F5193DE14 + +Len = 1901 +Msg = AE7DBB62E7B9A47FDA5643A8221FCDEE971907867A43680CAAE6EE618EC365D998839AFDD3185E8F56DC5E57EC71090089B815FD2F2B6DCFA19B1EF25001714E6F9A3CB58D35C858E6912DA487FB806AE3A32A0AB50034AA7B3C063CC47FB7D207E961396ABD557627B0FC1C3EE14A84E6C94CB27BC74B6DF2DBF2C26E44CB031EF8AE82D04B11739E2CDAC18341C389DF1353C99D419B26D41B8B4F916E79A124FB16F30743B305A56674772B9AB9167C01C5745FA0598B2C5A63C43C27797E2B9D63F1B1D9527FD6A4997A5ACFC51B124750C59A356F70FF258A86BE32E4C08D4AC352642580368586B69CC720 +MD = EABECAD27D2A15FF7421888A7679AD974C2B8EB041C1627BA231093B0C90FA9B + +Len = 1902 +Msg = 25B99AEF0E7C37266F10CDF83715CFD1803E0C3DAA8B8D4D44A49D3118588007449EBA78E6759B825195D53D7370E1E20A687B9245183605EE92C7231DA00D1F83DEF383FCA4D437F047E7A1AB23F3EA309D0E73CCF6260BDB9C151E3F3C0435C72E986035418E4DCE502A2F63751062D42DC0DDCCC92243253681EACD2B1224B5F82A8D875BAFB362F76EF7919F2A0A17B69E13095EA71F06990CFD70156733B0C42DBBA31A130F648D451300EFEC70DED0E1F850A0C06F6C2FF0E38C1C9316046451CB52A21F06E1301A071C5EB8EA23E39A18D1B7218BD2833ABB98F4BB0CDA30F4B49FDD2FFF493D7167DB3C +MD = 534D4AA6F7DAF407CD50BE8D9D1F3686AD57A4F3924F8B96641A8AB87ABB95B1 + +Len = 1903 +Msg = 715E9D91D3D364B04ED7A446DF0CC4AD51A5D8B31DC0A90EB9BF6675F9052BF3360E3D5A7D9C373C94C9AA9F6B200450272F4B37EB9A5BAEBE95C86AD74BECF18ECACBF3C8B4D5AA32C15E0D1457451D664967B6AA4676C992DBC1CA6A6576BB1788C94E0C97E1A85402B8624B03791F896A85A4A4132B7FD7679E8786B8A66E0526E1FD0782CD14D1712173F0A96063D68242652F52F8ABBFE284E637C62BADF97372DDC7CB2700FE31001D094AB77378D205CDE474710530028CD598FAD893536B6752A542171F6FDBA6893D3AE06CB8221AA27C89570E463E6C31620CA976234479B15B8A6258D4779FC321C0 +MD = D8BB99DE1614F3643056EC6A559B21136AC13EF5987F9EB49B6A78CF3488FA78 + +Len = 1904 +Msg = 08D0FFDE3A6E4EF65608EA672E4830C12943D7187CCFF08F4941CFC13E545F3B9C7AD5EEBBE2B01642B486CAF855C2C73F58C1E4E3391DA8E2D63D96E15FD84953AE5C231911B00AD6050CD7AAFDAAC9B0F663AE6AAB45519D0F5391A541707D479034E73A6AD805AE3598096AF078F1393301493D663DD71F83869CA27BA508B7E91E81E128C1716DC3ACFE3084B2201E04CF8006617EECF1B640474A5D45CFDE9F4D3EF92D6D055B909892194D8A8218DB6D8203A84261D200D71473D7488F3427416B6896C137D455F231071CACBC86E0415AB88AEC841D96B7B8AF41E05BB461A40645BF176601F1E760DE5F +MD = 401C3BE59CC373453AEF9603F7335C1D5FE669909A1425D7671DCB84A49887CA + +Len = 1905 +Msg = D54EBC88B04A14EBB0AA1D59C3A4498FB560438B5884F6E6A744C78761AC06934138E03FDCA96CDFBFDCF94A2D51151C35D5D03ABD61FD7850B8309D65D3EC495DB487E6A7B6F50E6B30A58DB0FF64982A79409AAF49766E032F7893E0888EC71673858FB57224F9A3FC170B06B74E54E2F512F6188684937C070E5C21839AC032FE1150F48D229CB6853769DEFB8C1998B48E79A96EEA86993D215FF0152A30147761D8D45D5CC6B2B81A46F99B7EE7904F2C825AE1B454931A24E51F3B0D4618AE5D784C94BD747F08E5689108D7E2DD291EABA7AC562BA7C768219AFE2CF7325672F3F2237CCBFA743D184A9D00 +MD = E6A96E3F6430A11FC546848D538FD79CE46665C8560AAD127E3C6A56CF255280 + +Len = 1906 +Msg = 1B9DBAE7FFD110EB2A4EC1C27A9C2C09F59DDF426A1D32D18766432B4D9EBE9D6FFDCE6140764930D5526D38CA45C2E4BED10B620F4B5F6B42B2B2B3F539A062DC36465483F660A3B0DD1FD5130156C31497F2BF2EE650716897B9D79A69018CEFCE1CCE2955A5EDE0EC457B8533D802316B5D4420B9D5BDC708E9B1F39E0E91722D9EF6A646DE2313C4AA88E71C46991E799A564A3F53CB245A91DC9E704104DD930F2EDD1A39DA491329C13D75FD6E71B076E1F5A1DCFEFFD1E2757FAB630F4C7A28874BE66287E733B462D45964889B42080C0DAD909D86D44CE5B16503B41246C827E00DDB13BB936185B15A40 +MD = F1CC0FADE0D411B264F89CA8B657136DE424F34D97DC2769F8B1236BE1800CB7 + +Len = 1907 +Msg = 948B3189A832A89B77011CCC3A5BCB0BF9921458DD9E8B0DF900E7FD1BED31053A714C7BAB9018A94E5145768224724F0715F7F959629120FC5F2AE282FC16C029759FD38E109CBFCE44DE36469613FC3E75A0DFA599F4B74358CCDE5E0E75934675C8A65687B08FBB8B0914A8D2A7D26578C98E996A12E6AEE779DD5B12B6F1381BC3EFC84DCD86A1488B1289E296484141587F9C2DE5814AF5CE74197ED41D6E47974A1012F465446B8B568DF4CC56629F0C34A9FC9C4DB1F2139006D02A071243594BCE5BA792F0D5ADD297FD728DE29107E60A87E8F0E3E360FFDB10FD23BB8B8C5824F0534F3C202838BA7540 +MD = 3946521895DAB8441D6CE767B85A549B2B0E79357F9380E9C71E21B56B9DD521 + +Len = 1908 +Msg = DD78EE486F318664E7A4D66B15E5ADFB15CA07955E290655CEEB942E5478871507B4EF5AC241EF683BDBD0611806DFE2DE432E04F1AA93E1608FD6A2B36BBB799611CC80B912E2FAFCE43FE688EE8ABD5EA5F04641B84E6D1C23C0742E64BFF7364BC1AB8B6D9C0FD89AB8EB4E1EEFBF7A17039891819092BDB39E493C8469A2ABB8F691E6BF40B45F98205C50292C7E860514460DEA5FD3A331342CBD70D7E8B2D5D6A94C341F27B00706C967A085DAB5E75A499E7B885AD3A3E3DB1F2B2DCC6F4AF700845F010E91BEB0594758EC13E345B41498E6D45BEF60879CC812349C395934ABB047BDE1E8129170525B60 +MD = 3B345D2AAAE824F690D22292D18526CA585322FCC43A36E1C8A31857792990EF + +Len = 1909 +Msg = CEDFB16E8666009C16626B4828156C6B374059093ED1E6F9D9FA3F524EB7FFD030F21761426E5838448F3D43FA87366FDBC1FC58D75C9F4762CB34FEF1746991EB3E0BA6FD0BEB93F0EE5A3BBBA466B2A667C818AB4C8BB1699DE0BDCEE984E45972BBB737E33B271B8C52B612013980996990F8B4A8D63F499D121DEEA5AC2D98B3C86BB6D0D62948562502F18E0C8DECE3A86FC28E39EF39A2FEF225A406B7B0AEDF4B3949B894F1846FD656AA8DDC0FF1ABD33F54F0A74FC35A9C6C299A4F89A24098CF3966F070BADD4BED889F3E1DAB75870127CAC9106CECA696CC186DF678D2E392AB592DB003AFB2659E78 +MD = 24C98FAB4CD5BC9D759EF81C921699C73B61A7E2F94815CD57715EA20552E2B3 + +Len = 1910 +Msg = 88B7A04F09EBB5BA5AE5D406C00A42CD7A809FE193956CDD28EB763DCB771DF5CA02A0C3E963CC9D4ABEE25037E82A7BF776ACA0129216E80D2AABB7A61C84AB5A2E675F2DA118EB159E0495BE9B8361362B7D376D08BB2F407B65E69120A1009B55CC0A8425DFDA0422BC1E7005DC4E8EDF925B79DB2230447D7E0BED9111566A8DE861B6CD11AC5F4BC9F7701312BDCA9019C4D799D085396FF8A83522D7842FD8AC880AB792EAEA4C4DA5670A586D1B13B005B8D26B371264AED50AF8106FEF5FA9232FB4D780F7118667B31F219E0655C2CD0D9ADA7F4C0032E8A8C40AEEF8E710635EBD3288F81DA883C269C8 +MD = 49DE3BBB8761DFC0DF09612B0C902E68C0E326F79B68A50CADBD5EC375857EDD + +Len = 1911 +Msg = 60BCE2AB04FD3142DAEF5C0D8BD52DEB6C60195DDEADC37BB50B8D7AC49D0736B9C98AC3F426C5BD548AE17CE4CF25089ABE525AE70774D1F52C219097D9CC7E25EE0A9AFDD92E63C720E09DFE45BB8D83EB36CBC8379C361C6D4A31401FEAB4DDA2E867937E5A6E9E2190D2411E837A7317FBB46859F8A40E24B4079219A2AA3A94EE94376B92D4BB86F3BF79457C1F32083F3AC6330AA9E87F49FBB75958E205EBF0133539139A68CA8498D9BA099251635F804EF3711B72D65E8F0D7ACE7A135024FB8C15DA8D8B0194BA4E8BEDD18E593DDE80558E2B9E697D053BC6363A98CB273594C9A8EAF93238532E25CE +MD = 4120C046FB4D56C4581D43B131BAC27331AD625A86ACCA5BA64A69C9E77247D0 + +Len = 1912 +Msg = D782ABB72A5BE3392757BE02D3E45BE6E2099D6F000D042C8A543F50ED6EBC055A7F133B0DD8E9BC348536EDCAAE2E12EC18E8837DF7A1B3C87EC46D50C241DEE820FD586197552DC20BEEA50F445A07A38F1768A39E2B2FF05DDDEDF751F1DEF612D2E4D810DAA3A0CC904516F9A43AF660315385178A529E51F8AAE141808C8BC5D7B60CAC26BB984AC1890D0436EF780426C547E94A7B08F01ACBFC4A3825EAE04F520A9016F2FB8BF5165ED12736FC71E36A49A73614739EAA3EC834069B1B40F1350C2B3AB885C02C640B9F7686ED5F99527E41CFCD796FE4C256C9173186C226169FF257954EBDA81C0E5F99 +MD = 020485DCD264296AFDB7F643CA828C93356F1714CBCC2FBBDD30F9896C3F2789 + +Len = 1913 +Msg = 1155C2A0961A8BAE0B6D7525BBD4F8C6462DDCE9F37A406B9207C3F103FD12D777784434C89C0230E64768A054160B530F0E9B0183B00964F9AD9286B0D3DB255CFFD3B68FE526C3761F72A45F842667C277B210F157F1C9EF5C9AC7F7A050C2D3D73C4D48E85E29842F9E951C07266AE96A24285D316D4F372C067B7480B663A59AA04FE75AA96AF5425E2D3BE0DB2525FD9348198465C7917856716A667503729940B2E7190281D58B3ABE3B96CE9EAD0BDEC79F7DBA5172989CD1A73CCB8B51B67214E19D0EF7ED4F2ED33A7D773862A4CB899F8DE45197B878866F8FFEF1ED73641A5BD58F7745EC17D84D42C980 +MD = BBD7ADB084877CFFA4CF63C7902C04D0C3A96597CF723A64A7924B0372CF819C + +Len = 1914 +Msg = 8821B2711521487594E20F09E0DABC97A5B5E29A37121BDF965F828D0972FE9386B28A37D47805308491811C8C1A4357895ED65C427E5AEFEA2926DBE7A909B8431D3B362A850A0810E6F30D7EB00C5A0FC8D933B088D8CC52932DC297B5CE2B644CF56D4DFDD59AB0760D5C11CC1A10275D4938EE0D2BD54AA9513D1B179587E77227703F0F6E66DA34CC1A0DD382B6213A6B313CC8C5CD75A956D027DA212DF965128933FCA4F7A2507C19E54EB6E915868C29A8188782998FE07E8CCB50FE433B3C2E66CD6D794A06E9E7D40AAE843D6700D1D4CC1D1C34AAAC811BF8489996F7FA81D6AA1954EEB441EE411CAFC0 +MD = C1A43CCD8D52AE582696C516C33B591DE6EF800433FFB369332D6DD1FAB1AD63 + +Len = 1915 +Msg = 5C6398D4A6AF6BDA6C973B04F9E7E8A2800370250D1B5E9FF3595CC651BB246E73B0BF208E47048415EB6FB3C09CE3ABCB7C996C06B40E18EC35427AA1E5CF64CBF6F0C07B02E98EAC25C141ABE224D3989C3A34FB6EE68934875A40BE3BA10ED0BA7DFCEDE81C6B7555F6E5C9D4B9E92436E478D1169D436134F618201027B8131575CB8F057EEBA566FB8A1680072D32E60A978693FAF9FCBF82DB37B91F174FE5E88D625F2017B61B5DB7290FC6583C3C933B1B0A745C30D780AF04CE6E777FB258AAD030B3F10EE1B4FDE47026332A49B9C9DC5586133C7F5D69A1EBB0E70B841F72FE1AEA8A7A3D39E3C9629320 +MD = B1FD2E6E4195114FB6F9F1DDB2AD41C928AA11CC53A8F77E9927E94EBE2D78F9 + +Len = 1916 +Msg = 893576B07D2B49F97BC412C47E1799E6C620124B69290F2C49EAE0739988CD48926A6EF536BD3B0C970A060426BB360FB5793C8371E61DD70C318A76FC993C77763963831659394322E579EFC766835F966B0CC188032C8B6856D02BB9FE5FD7C388914D72C2AA94331B4AA185DEC2B3270C6B1E5463DF02CC4C9ECCD42AD2934D4D1D821615F965348C0CAB875219A61C1E8C12F3343443A53A66699180153B0525F95D2E3A655278DBE91C09F102718A90B7D5A4ECD6D237CDB9B0154E373EC89B6C1C705275B999D8C9A1D2F1A8D075038DD4A98EE9E156715CCED4D859B4D56B41F8767FAAE886CF5E67223EED50 +MD = 1EE0D360EC0DBA70DD6F0335D345D7F5772CA6EFB36D17225E3801D0EA32C9BA + +Len = 1917 +Msg = C67B666E8F9A79D6B28AD45690009B68E78C65AC5B1D932B4CA91C320DFB4A5954E5E2994F9E52283229C62E91F030DDDA4FC3AE227A85BA7FBB96823EAFD70E8B98D299A40807451FA5778BD0F055B2D20FEC21FAB0D9A6D5AD2567A5974F399F28019F45964DDC7055A49676DA6E307E36A098C9BB2A01154BF7CF6D0981EE82C8EDB82FD36989795FD8638D7EFD1A9B96612AC7DE5CB00C29FF0280EBFE742D02C22D0DCB0702EC1246FFF5705C14462850E2F818A9FC8A596E5FD6C8BDC9B947BF76A5BE37C0727A8922A55D6BA20491FF4D6843EA0154DE71FD6EC129D38E2370124B5A26B47B247D1D7C3B1008 +MD = 7BC399E1399A5A848643D85052E3884CEAE68D9EB914BA42DC1750CAA317A6B6 + +Len = 1918 +Msg = DA9269FAE1BA9E76EED4C864050ED952DAFC19882DFF9A3373228B31AE0190E601E36ADF1E791453A1153B48EF19D903772E062E47F6D887341A213AE96FCEC5CB9C2022A04A469C41D06DBC71CBB5C6BA2583574878B84B62E368BEA0E081E0304C7AB441399702536AA5A17BB13AE368DEBDFB83F560E65C74630DB48B146166E09F3AA31D8B10F10F4670EA60EDC1632CA8580A2345C04173F469B249319451893A198640AC2CB0A7E3472A17A19169C371D9991D2F859238C4F9EFBF980E05F26F3C9E172D36B8FE61D4337B4E1AECC4039A4103E7D2BAC1A7080F1932D8FA4FA0A2075C56B2F6BA83B63CE9D39C +MD = 8648244438563D21621A4FBB382C5AC56AD060B926817C60F240CBB932708C60 + +Len = 1919 +Msg = C8C9D74ACDB42DAFFBA0B1734BEB5C54778D7970F2226BD9C8EB24E3EC1AC11E982FA705F0479C049A9B6046E85A269A258C104CF442C8156D431960D021A533D73B709B8D212C221AE2D03EE7A6182117A823A9E3F3B4CCB43FA0DBD5B238241CCCCCF05CE5C62C3762237B6449779635D992D2FB730D2DD382B2E61CD5F23F680F848A4162D80010E87DCB4182F192395D73B93A2040C0FAA3E404AA1089E40E1B0B08A7F08036CC5E4CE1CE90F1C10DE4BCD4887564A6FFD7166639C79588B763F95101A32AFB77F727C45BFFAB4C6238C04E837E513E12A88C74B940EF933FF7547D08B8ADF32F8CAD5F61C38DEA +MD = 8B8CBC3D98059270D24E594A746CA1D3044DFEF451222AB752788B0A0F626A83 + +Len = 1920 +Msg = 5FCE8109A358570E40983E1184E541833BB9091E280F258CFB144387B05D190E431CB19BAA67273BA0C58ABE91308E1844DCD0B3678BAA42F335F2FA05267A0240B3C718A5942B3B3E3BFA98A55C25A1466E8D7A603722CB2BBF03AFA54CD769A99F310735EE5A05DAE2C22D397BD95635F58C48A67F90E1B73AAFCD3F82117F0166657838691005B18DA6F341D6E90FC1CDB352B30FAE45D348294E501B63252DE14740F2B85AE5299DDEC3172DE8B6D0BA219A20A23BB5E10FF434D39DB3F583305E9F5C039D98569E377B75A70AB837D1DF269B8A4B566F40BB91B577455FD3C356C914FA06B9A7CE24C7317A172D +MD = F8C43E28816BB41993BDB866888F3CC59EFBA208390144D3878DBF9FBFA1D57E + +Len = 1921 +Msg = E1CE71B61ED330EEFBB09C280FD34A878F0378A0BFE2A046516BDA084DE38083ADCCBF42A6820DA5D46F1AB062B1CA433BED4DEE26F3D7A094F90BFB8A56EAC4064CFD3D5E5DBEA334D2984D4BB148F582B7CB64C82970AB0C4A947E28646E2742C1C8BC1C636FAA3A21216C2228E644FEA74B8E7CDD3DD006757317E1E5D4F2A67DAAD8D868D8831E36EE6BBCD7DF34FB38DF51DB43E26EE8E6C493057841F3085A6E825C4DFC8AEAC9A5B311A6E235FEFBA6C8F8D3EFF658639DBD957510DD001D2D18151118949B80B6BEF15F9CAD579ED30C3B2C95DAE83EACBFB5EDAD3A42C03DC8C8C7A713152CB065F28B537100 +MD = 54C342B49ED802B4392A57E8239E974384A7934A7F50EF1DEE1C5E57963E194F + +Len = 1922 +Msg = 3BCBD35851DA712C8C509A0A03388C743587A1C36055670DD0B5DD3144DA20CE739E417E7F197E72B91790D3B49338E667EABA7DAA04BA6046BBF0F1763787681BB487D690239DE655DA3031B7DD39EE1FF9C550ED6EF15E742AA0DCBF56D6A05782783A003E5CBFC272D3F71BD641C54215E8A6966A252F8D17BD5B208F25D7F8F91F4754D9B16184B333D2ED695483F99CEDF5224C4BF1F0F44323A9B3F801735DF8B284C072B4D7C3BFC31CBE1DB3FA2FB45A595B9C9FC8D98D8429861DB1D0EE3EA484C61F86877EC61AFE5DCBDAA38818EF002A4A4EE8305FB1109D3CCD222EC5F3B2DCF951A1B39FEBF19517B7C0 +MD = F148CED078AAEA3F2B079CC56D9ED1DE1A7371F4E057EF5472B773FD70088B04 + +Len = 1923 +Msg = 6C48CD3CE2E401AF5C680E91EAB0A386B90520022F017BF60A5B04A1D52E6618CAE48C0CC3A2D7F16848F9A372E4D0067E73E1183370220D73549E9C510F02BE4044761F82B2D9B227E059D3ED089BAAAB8FF61F65E37495A19C630AED17D8F42C5D24C109AF39E528856654835D0CBB2C55904EBCC2B95506EA73D11A68EBDDF0841F14092F2A4249EB9048BF7E26D4F929A0C26D1A8EE98D3ED6BA5D7E0E45E3A7C59435A7740D1D6D6BB638ABE271554DE4F7E88730BAF804F454924D33AF28FEF287FC6F50199BCB2207DE7D1C962D2E9555160D22DBE3C32FBB7733A669F8783F6551E8E5769B6291AD00CEDCCD60 +MD = 774DA79E795CAB0131828511CD8FB082163E5DC946AE3879F904B370C9084E0A + +Len = 1924 +Msg = C0F2D732005BCE3A7572AC90EC56AF2AA22B3349D2DBB534A4D88FC7C9493130E380ECF6B9244868F16DE465C08798D4D6E5087346C7AD26629C7075682DFA28D2FE387E99557A1C39A8AD790FE665B59EF80ED0ED784B30C4DD5645C9EC6510B358AEEC8AE20FBC8DBF0B2DBEA557CE15B223F33D9BB23E38927021DB61ABBD26DB50C4FCFB219EB7CD540BEC18D23F60748972C58F7F474EDD58384F1C3411D67ABC5B5810E95CD2648463992CB4EC6AC8EB63DDFF8BF6890A69B3249DAE5E7459A489A5B66D899ACC09525177E0DF731949AE98C327B942AA6789A6DA286C7285A791F0FB2D3EC42C2EABCADE008520 +MD = EF2AFB01FFB6A0F55AE4A71DE0638F3CC4122B30FAF135ADFCEB26A24B3679A7 + +Len = 1925 +Msg = E851A3020ABB0B3BB3D4A4020FEBCE6F548F26EDB8CACE828658D444701AC43931402030EEF8814002254E64ACDFCE8DBA162431F032027A27AFA93F82F71946D97BAA83AB79703DB230367952819951C068FCD0E30736B9D69F87620DC3EADD25F31C6206D7BEB14D0841CE44DFB75E69346D96CD9FE9B9398852F71FE25B1CB25DD7B8A96128BA039374397EE4AD1B22789D6ECA2C1CE1F3A7E637E2C7E78EDC880DB188D7AC6886FA3576DF4957CC600CB66783D799E57B7C4BF7ECEA78A741589B2EDBBACBBB0489F3A66F14529BF20DAFCB831A885F7C35016B768E7F2434D68A941DD86599C7A1D412D4142035C8 +MD = E4A1A26FD5172C8598A6D496CF6B719019B23FD6713AC12BF1F607D03E7CB2D3 + +Len = 1926 +Msg = B5D87282661F6A707A64532CA1FB72C7B80B47989810A15618A44CFB71F07D53B24D6D80C45EC2BDF485743C835F3C6B057DA0769F07462D1672A4AA6896B047B2010EF16C54ECC74C522FF44227F8409CB86F3C8BF488739DBF89F5B40477C48914764BB98E4A03561D74A5B3C11324987F0986C191B00BC5584EAA710CD7A9A1A44B108E8367FFC27B7F9AB82CDA038D38E36D4AABA71E3D844FD9D356AF4B8AE611BF842CE819582FE64EE26C5DABE4884519FD1BD8646A13ECB0D9B0B6F42C0B9632BE73B2C45A8912BCD70AE9F5D576AE77C9A1CACE95DD320BF9FD252BEC627C227AACE9CDAFBAE0748ACA750214 +MD = 0678F9B768526D91E05344BF6FEBE91C2AF3C4DDCCD9D73F7F13C18F9F6A6FC5 + +Len = 1927 +Msg = EC432C662CFF134BCA2CC20ADBB5A8AE473BD56F229107C5F5C830E5CBC92DB0367677304E4AD2949E93DEF6B5DDCC6AC2783ACF8AD34A8F7F8CF3B8C79263AEB131ED8BEB2958A593868F5E8163216B363865693CCF7B730F36F948CED775D0FB1E6A76727845A1D25F140F3DB68F6D3CA9F6B4D2985831E3287DA61219530EF21BD82BBBE28089D1E68A4C3DAEAF574A5E91F15A68AEEA7836735ADA78A2C5731CF1129C94398DDC0C2B5AE53E8BFEBD81AE08BB2B91FDB36C770C36FC77807486F19AE716114F61B23202F7540BA27EE2F72658EE6F8E81F11BDA44921544E749EEAB9ECD5C7BF857F83945D3FF8F8E +MD = 2E801DF6E7050063AD18A42EC17D680F982F0F4FE99FC343F459F60BA68A64C5 + +Len = 1928 +Msg = 6172F1971A6E1E4E6170AFBAD95D5FEC99BF69B24B674BC17DD78011615E502DE6F56B86B1A71D3F4348087218AC7B7D09302993BE272E4A591968AEF18A1262D665610D1070EE91CC8DA36E1F841A69A7A682C580E836941D21D909A3AFC1F0B963E1CA5AB193E124A1A53DF1C587470E5881FB54DAE1B0D840F0C8F9D1B04C645BA1041C7D8DBF22030A623AA15638B3D99A2C400FF76F3252079AF88D2B37F35EE66C1AD7801A28D3D388AC450B97D5F0F79E4541755356B3B1A5696B023F39AB7AB5F28DF4202936BC97393B93BC915CB159EA1BD7A0A414CB4B7A1AC3AF68F50D79F0C9C7314E750F7D02FAA58BFA +MD = 4EA524E705020284B18284E34683725590E1EE565A6FF598ED4D42B1C987471E + +Len = 1929 +Msg = F6D60894154B44006CADFBA9450BD0D46F297E634844235C322E7A06B2D1B335F69F4EEFB914B4674CBADD6AE48AFA1CD9BAFAF884417FEE5F36C54AF8C34B8AD179206BCB45BD858FE64A5E3884825E90EF29489DF07C69329CA1B4D8BB5E638ABB382D8255958057AAFBDEF0899A5E470FF7222DBAF9B66B1AACF9F407517870C45289A20BE83E673E96D0428B75C8C98A30A6FBB4D6441890ABC54C45529BC7E2C78F167D3D1DF034C360D101444798D0C9F1F65A3B7E3D9761EBB5826B81B749F716EB428D845C5D5B9F2BA8B263659B54FED4DAFDD2DE91DCBB0CABF7C70D827A37E0388EF87C90420CFE25167EE880 +MD = 39F926AE02CAB39F8B12154AF3B12269069B49BC99F03B38D5C5D4BB4060F730 + +Len = 1930 +Msg = D01BEC496170470B95E81ECE9EA0A39FCC640FDEE3DA2E94582BBC0D51C7E5FCCF7C10728D0CDE4397DCA66CD95281A998B6F0025EC854A0697D54E09082F387FB3593871F12B6642FBB302BB9AC82BECCD1BEE69ADBB25A82CB11A42D0CA2F057052286746BD93F70B3774E1AE0FCFDE5D1E870F0A0CB380770C1E352F2E9CB8958496EDF7389F9B894D7AEB78D6FC1933FBE6CA5938660C5EA1054EFFF2F17F8C6C082A9E776B0FA244020A0729BE8BD5AD4D683E9FFA550CD928E773588385CA8501EB7F47AD60D98AAC1B518477C78DFDCC2A680D1F596273972528CE90A68A8AE4D9D3152AB436003D684CFB83C9500 +MD = AE8EB492B8466D028FAAF1DCD8C84476CCFB845AF8892A5D7AF7D9C2F46CBFA7 + +Len = 1931 +Msg = F83EF50679FA09197746549D69559A19D040EB7B625BB41CBE543257D605E3329B19B65DE3884B55B3EC22A899079DEE016EF3D8D2BDA07D85218E0D91D1A604B71F97E7C77FB0D4E685AE7FEDB7C36344DF1EDA1879139E0E723FE5AD4DF1EFB6BB56661591ABFB17C4C8DCBA76342D9547CC2B7F0B8EFE5C6704307538F1794497B01745FE00C24E83CEC5ABDDFD37422A898FA04F546F66529D66338E9C16D70C34FD4D5C4695BA79091F6EFC5504D79B078994CB12238D11B078F4AF709F3B7AFCA4345307921570791F755EDD739CF5CD846476FF5F3714F578DAED1451CB9F17BF8931FEA89D693275B7A0FD775AC0 +MD = 46E510C8409C6BE2FFF41A951CC65633382B79451C0D9C701C2ECBF635CE42EE + +Len = 1932 +Msg = E397D0A65D8CB58DCA01E63AFB0E80D42DD48A722C042CD0248155DEB09E4520B20E2CFC093B1D19B60DAEFCDB7D5AC389531305570BDD10F7CEC6F2B7505E651880EC29022E954062E220626FFC2D0BFA30E4F27A8FC90110D72847562183A5AEF08623EF14EC1F760A11544A536342107675525276A97F07B84EF89A89BC6585DBF79C982203B26F1C73D5620D5A5AEA82DB45B87E2E2D096C70593E48301F7D13ECB5A6803A978E709754631F2CEBE81E0B24B00521AD7D1E749385944064E7B437C18C3B5EC81C40844D3EDD7703DE23BBC351EFE62035C20D6C4A0C051D06B88A51C0594CCA1923FB389BF63589AFF0 +MD = DFB5FCF50389FEAA3278E42459AA2E0728DEAA5F028C47988B0D28B79A2164AF + +Len = 1933 +Msg = 41FECDC28FF9A09A9A50831800EBDC57E0BFA56A6BDC15D110EEAA608BEFF84B87AA7D18DBD19F4B9AB3104FAD569B49EDFE479E42ABD108A0B3B46EFAFBEE1C36A4C46545F26FCD830156FE3A2413689DA4453B28FACBCB6D77DE0C9EF7A19DAE60F9625A833A77A39A58A69F2EA4FDCAFECD7A6ED8A2DAED0B5D21E5A72F2D2FE57CBE170DB151919ABDB92266C5F3D36BDAA93FA9924E7010914D35FBEA35B54BCF1C9A2A60CC5C7874ED873EE98B0542A4E63A1A9D6735BFBC27D108003F0A960960C38EC286C560BCBA0FE2945D43B571BE0335D4E0ED7379047F35B2B026DC0A158E9387A04BF369E1DF6E414F27D0 +MD = DE194ED39E2CED6041C0E524FEDC82FEC18A201C0B62535B13EAFEDE1596FF4E + +Len = 1934 +Msg = 7A869D4DF91F80B8A8B95AB98D919C84D51708E420A44BAC3CE15AE2865D209E4473A25093819173B75EC7D2D6760CF177301ABC5ECE66658BC64B0DC64B83E9B609CCF9C85F3A2EE13B48E1D79DF6D56F9D5FF5630ADCC4CEA8B9E9414717657F90511F3F6DCFB04533DA5B1989AC0637501C0B38C47FB0059B7C3A5E0843D51B7F3D50FCEDF32B7667D82696D457AEAF9885B332390863A0566CC1827B29C7FFB8B0E808625F41672EE698A892DDFBCA2FAA5912407C9EC646B23E8A3449D47DA8DD3DD116B6304D75667880F07D5A3E71A2A06B8E8781F9B49B845E9A778C422853F303E0FF3326FF14300ACE16BDA68C +MD = 6808ACC93464C964412DC678435A736F2E34453C480857B13F9C40DBBAF0C56F + +Len = 1935 +Msg = 7DB18BB52773D68C0D01A7D22F43EDE79401EEA2FBD6B8CAC5A27C095B17D757423CF06D69653DB9E8AB88B0BA9D7FF8FF9A7127D53B75816B0ED9E4D418DF5E670FCD67DD1129003B424307794B74E9C21A43CB77ADB1FD3F31980A7C4D955FDF54F9DEF230D560E0C7A0DCA0D8F4E50BA443E5BE91211A16D94CEA5D1D5988BD6C6B09E0E80CE4C84B55D3F9F5E584B30E2FD7C42DA1F07FD717A8E0F1AA80074C8E69990FBCB870022719C70B4210F3D538C3E1F96428E56522E9DEB3A33AAAFD71D06A16F69DA49A94FA15E13EE90BBA294E7A7D0FE376FF4B07596EEFB517074ABAB621DFA2F3F8099A167D2BD601B4 +MD = 49442B01046FFD40E8506F1CB42A8D32DF79A0538042BE5327177BFEBEA55407 + +Len = 1936 +Msg = 5668ECD99DFBE215C4118398AC9C9EAF1A1433FAB4CCDD3968064752B625EA944731F75D48A27D047D67547F14DD0FFAA55FA5E29F7AF0D161D85EAFC4F2029B717C918EAB9D304543290BDBA7158B68020C0BA4E079BC95B5BC0FC044A992B94B4CCD3BD66D0EABB5DBBAB904D62E00752C4E3B0091D773BCF4C14B4377DA3EFFF824B1CB2FA01B32D1E46C909E626ED2DAE920F4C7DBEB635BC754FACBD8D49BEBA3F23C1C41CCBFCD0EE0C114E69737F5597C0BF1D859F0C767E18002AE8E39C26261FFDE2920D3D0BAF0E906138696CFE5B7E32B600F45DF3AAA39932F3A7DF95B60FA8712A2271FCAF3911CE7B511B1 +MD = E4963E74AE01FF7774B96B4F614D1CB2A4CF8D206ED93C66FA42F71432BE2C3F + +Len = 1937 +Msg = F1672F20DBF2C8F24A2683F43D202D70C7328A600DE10802AE491FC2EDBD56B29138807A423626679B0F191F4948B1606C547A310052F325871F837C0DAF5B43485E3799952F53073D6823D0B69133619826DC50632438C65E32D7C11D402496FECA7553D8A4B93EB669D2FDF87ECD69E1E24AF18A3D8976BB63E33F48809673E390A151F0CCB0F2F551D89128F95B6B3697DFBABD98D4E176278B7034884EED380F5B0BC287DA7F28737A9096CB017928BC72B7CC603C1ED0B3C035FE49517F77EACF6209DDE29DC7495DCB29A8ED6ED86ADDA488B3D53685BABC734CD5BDBE2A9D4497F7B337A0B49C65496CF1977E356280 +MD = B2985C7F05723919A5DC9CF7C36AABB1E50CF33A6B2CD2E13FFF677599EE42F0 + +Len = 1938 +Msg = 1AEAF41B963F4372F9E9B283284F91E257A93A728E7DA3737990BF7F6E62F5A504034AE08E2A4B13A07B78A950BDC6C677D740E32673583E0E996440ECFF6F6F5E734FCCDF1F94398E8D837FDF99F8811319DFA90BA5F4910B757F9926DCEB0896B08AB66C874B5A272E0E590803B77F5D0189FFBFBEF81CD305F7A8749C4F6FAA00FEB58AD242D68DE4B100BB2C30512AC79A3168D25AD0AC4718DE8561DD01CE6F38262B835728A85853486357486978A311FF1009082D4C3FCB7ED3E759AF2E7434669CF569E1326CB269BE5F51E20F1591143D7503F64247BD9C36C65122C2702CBB4A9A097FCC0367C0BA13F607F06240 +MD = 000F1A90D02015E2229A993155C118C4A878173B10B3903A2F629BB65541DB6D + +Len = 1939 +Msg = 657A2AE32158D7A4F49CD42430779EA1403B434ECAE5229E8280AB3154F2787840F4E3797682B8194D95E0D2207D3C68E7F92CB9F1382C4C79D57E0D78F801F32E77CA71A5982E1D8077723B7D7A96576108DB019F9DD4F314313CA80EDDA39BFE9AA9CC60C9AC776CE720F625842C4EDC3CDFF27C90968B7D5B5F51389C4B7E43636882A531B033BB25AF7747E780AD316E71D4B95D90974185D00DE7A07EFD6B5D86CF06CC49D986CF3E70574A84EA183059C565DC8D1B2676ADE9983447423586C1486AA1C2E0C7958C27075842BBBBBA68025A58D35E85B3699D6CDF95758D088C74ECDB5980C7BFE1AD0F73E1DEDB8580 +MD = 66E2E8D72F628CC846B633D16EA6AE3A5A81DF3FCB66E49F370E1F8BB43D5CD6 + +Len = 1940 +Msg = F3B8DFDD776558056FA3FF838F1A97119A5D7A7D5B351F1BBDE608E59CB534AC068A86B37B41BEE9CE0E032948542F2125A89BF502612A813D83E3EE50559724EF21B0F25BECE0B0EC3A96D207C5C34505F0FC19484AEABA1129293530148C58379E00BA13FA7C241761ECCB19039224FBA9EC2EC1F7648AD0FDC6EF0ACDDE258F76F97D8049EF1E3885E835CC9A93F037763470179AA2905197AB76CEB0E3FCD46CD023EC166932CB65B1C11F08EA57AFC68D536F9164CEAEBD654C1170F8901C26041145DA94719274350C86EB5AC33FAC19B01E2D1B178C0AFAF80BBB4D6784CA00F5D7D58B0BC6D9DA5043AF55176886B0 +MD = 962BDC3FC270457E1D479B7389FE55A2B552893CD61B1ADFA09C07E098511D95 + +Len = 1941 +Msg = 3970E275ACB10C4632DFE4909D143EAAE1E2F39720B73B695E5C71613088D7872165C98A6ACBF09A746C05460F33EE8E00B1FA46ED219CE5C8FA8788297B9E3C6A96615970137839B03C352204CB21489921F774A16E3EBAAB9ABDF1A19CC6321DD6EFDD25C0253403548572BB4417663DA33EBAD92243E6B9E8C0F97B13B884126262409D2A20CC01AF3EC2F238CF51A1E3D7ECE9AC4A98C0446210DB4CC4993274494DD452D46BB66A3A528713480AED5AF3FBABF6BE979EF50ED443438F795A087D400282B6E0B5B52EC747DA0E2C5EDA9EB002426689B115A37CCDB46D6440830B9BDCAA59078F62BA0635360BC85EA388 +MD = F43A6892E684DEDED0D5C653EB13315C2129F5C686698206B610CD3BEE34E4E7 + +Len = 1942 +Msg = EEE6D0C949C72BFE8F83AC35A5DBCFB50181BA1BB3AD4F77E2636C68E1FB860A6AA0A0C21B6160A2453478C9C0769FEB0E7E6D122E67A7C78CB1ABFD0BCDD569ED8094FA1024E78913423150E0BA500615DEC54846F15F9E297E8F1C592AA7802F37E8F8A29892BADB5DE3E445946A88FD67A657A69B6B9098C6A6CB08286B04D541B88333E59CEB78615B0E4EBB54896E956682015FF77FBCCA79B1F68AD3FC82C9A56E5A68C00E4AA795C9C97EC7EE618D6E5D977B9EE1DC94E363F073D02FF9AE85554DBD7940441275C082B560CC13DEB402CD8692EA6C4A690321EF275862821558255E73BD8AF9309B735ECBD810C0A0 +MD = CCA23853CDE42378C3493B8AB9D25BAB7613FC92EEB6950ADB8260891A2706D8 + +Len = 1943 +Msg = E93187EA359EA34D538A88DEDF73F6DA1B62D445EA3C520AAB03D12B127123446DC72D1092EC3A1549E4BE4DC4BAF9D73511244D57A5D9218101353D3731D464510A74FAE679F346D9098DDCA12B9E3D23BBCF7A23617F326F72FF75F7BA6842D55D71A2220FD15F632225B66493220ADFD891339AC6C6D769008BFBF5A19E27D20627E16D5A445DD2C8DCC1AB54CF133C7109FB3FFCB6000AF08AB4A2C9161F883FC2A1FB7D0CBB5C748D6309660C1DA9E22ED9648E57346E02D1DD5D0105DA6413F4830A921869D869683E8D584175E65724B890CA53E7879F390C146CFD4E884BF681C58403944288AFA11B79ECA3F37F1E +MD = 803860F858C8064CA88A15C66420B9FAA14EFFC602B5C7762E8B0B29D010F480 + +Len = 1944 +Msg = 03D625488354DF30E3F875A68EDFCF340E8366A8E1AB67F9D5C5486A96829DFAC0578289082B2A62117E1CF418B43B90E0ADC881FC6AE8105C888E9ECD21AEA1C9AE1A4038DFD17378FED71D02AE492087D7CDCD98F746855227967CB1AB4714261EE3BEAD3F4DB118329D3EBEF4BC48A875C19BA763966DA0EBEA800E01B2F50B00E9DD4CACA6DCB314D00184EF71EA2391D760C950710DB4A70F9212FFC54861F9DC752CE18867B8AD0C48DF8466EF7231E7AC567F0EB55099E622EBB86CB237520190A61C66AD34F1F4E289CB3282AE3EAAC6152ED24D2C92BAE5A7658252A53C49B7B02DFE54FDB2E90074B6CF310AC661 +MD = 0F0D72BF8C0198459E45ECE9CC18E930CB86263ACCF1FC7A00BC857AC9F201AD + +Len = 1945 +Msg = 79734C970C947EA9B10A7909CD077AF990A1305F88F918FCEFA11266A5C6B6DEB5D3D3C1782F0EDCDD3C7BFD64B4B38C08F75BC13210261859B0D062C777AA1A8140DACAA59260781F27777799C462E76F59499B18D7978B717955BAFEF3476C626952B91F9EE67C2E8CFC0F61CAD2DB8BF1198EEE8DD4B74AE5D28A4617091A1461DE098F5E1CEA67B7E387BAADF0BC08D3F8CB150F388395BA926F2C4FFE923DE7218093FF709C43E300F0DB38E79C6C07BD1134902E768A76FAECEE6B3FFEFFC90F498E2BC78757852F6D2B4CF9B3EC44C185B770B39D17482C5A547C4B4EED24748AF0A54553392542EF58752ACB832B9000 +MD = 2F6DAFC822C4DA2E9BC74B2D6E0D22088C8D6F841729D9F6700497FEE6535FAE + +Len = 1946 +Msg = 471255C92FED4F68F468A69B5B71B02D688EDA01FB0F12227E8B84C10C80462126D821118F4882633284574456F49C7E1849C5044191748E0162FAF81F239409751BA227BE04E0D890CA74FC77B5C5887101EB09761B445C56530011E3518659C1521717A9273CCA06A7F287423E9DD5FA32DA7FF996EC5A629B4D908A4BAE72FCB3CFB4F9F27128EC9E566BA59E907E54E2FBB8243864ABFB6FEF98CCB4B715FCFED874AC30FE850273E53D879E3B41D5946011C60D6C18BED388E0CDBFD8B55D25533B7308C5A7F9B25D56602543BB74481E142127CEF2DE20287DFAF62375606557DB8365B81EEF89CE7E1B3D4DF3F1B01DC0 +MD = 2FFBEE3152719BC60C1A745B9A683974356317E6DADF403FBF4981F8F5F8CD3C + +Len = 1947 +Msg = F2A7F95A3286702B02DBA5DF8E6D9F76DBFBDB08A945A3CD202503158F7AD59D4A06F304CA6C1329523ACBCDF43B9419D612B0D1BFB9A764D0C1588C3A9302202FD730B85E38605119F9C0326C38EDDC6A126AF6388BBFE3BA486F4A5820974477259DCE99678EF608871DD08A6814001ED99CDEC13A87650F449DC7DA3F476BF19A5FB0D88AC65BE45E5A8B94CFB3408C371B9A4856099C1865047272F8252A69E0B4650E432084FB53E1E583BABDB8896EE9F7E037DC96C87787B5CC4F504F8C3E649139EB5CD2B4292EE5E5A31C7927DEB948CAF5F30CE7664702DE79537A46CE8C5EA95B39BA1A05870C487E781D9A549B20 +MD = 7A987ABA3089087D2D711BADBF4048EFB4691D046A2883B868339CB457E604C7 + +Len = 1948 +Msg = 11281730B07493309A2EF913FBACA2D4277B2A5D405925839553C7363B2DA90C60A6526AC86363CE6AF778A0CB7E4A1D9A7DD75E16A1DA94702EB8EB8382BBD0389D436D05B8EB303402290A43F240A999887C169B8726B0B02956751A6029C8C3BB2C07AD102B37A0C52CED9220B5B0FB1A7F985075C6D4C06500187092E09D8A9A1749262523196A42CA1046F01378550F60924084F6C9AB24DBCA521E7D6957411AB83B9FD856A1E08D9725D363F28B0CF032BDAED78D9121099366C7A48003092B3B94E97EF04512A9CA7B7968DBAF134EF08DB292658F624A54674FE7CB79F2BA47D90093C867F4F06D33144DF9E5BE1370 +MD = 9069F34181553A02D07D67FAE4581250DE86631302DD6DFA646EFB5601767738 + +Len = 1949 +Msg = E5073AF60BA51D98E8645F20A209416A2391A365A0B3A78A3601E4CD1130FCDC846B32622475A9B601AE33C8FA463D8D152C0846040A9A4BB0EBECA1B9258111E886996049F421133C7D21F2ADA0525A06EECEDBD5ED8FE310D34EF8C71F27C18AAAAC2EE1E38BB080851383DA7A684699F80C0A7BD51A0188311C12AD5A058CE5540ADFA3A425CA5D1C00EDBBE3A5695AD08258A796642220C5D8BF9144B351C3B5753E7EA77D46903A4733EE24B4989D797E2FC6A187BC0AB855CE71A650A13BF4B64BF5AA6DA142320E1367D37439E99E2FA95DEF311F596E682A01CAFBA051D515C31823A93B9C71970843568C379C073578 +MD = 1B7E5B8B8D24FE1BADEDA89CD5AFCA91BD5BFEB7D5B5E24091FD39748BE41B6D + +Len = 1950 +Msg = F5E87603D3DA08C7C37AD0FDDD62337B423B6FB0651236F818458FF022F7B9FF714E352E196C7DDA164708FE21ED7223CC0C4670E3BA27667ABE7027BB471562C83BDC247EC9313B9A7E5F5B17DBC3B39B258954814813C427A9EB3234975DC3D3536AC42FCAD7C18435FE32A5D5658DB28BE1E61451137C677FF36834188EB6A6631FA27B2F2292FA07386B3978462FA263EBEB85CD16F30A0835512693AAC397C55E401808B124B5C4D1427E4EAABD826D74824C036E857250FAF95BF5011FAA9D7EC93AA84033518AE0E2C283DB10129B43E9B33D47C6C7C8909D58C18EE95E19497E387ED9646826EA2958A7D4BD07029F14 +MD = 86FB2DA4B4885D300BCADFA6D37CF67FDC859BA8AEAEDE0951DC3F49A0686D60 + +Len = 1951 +Msg = 39696823C4BCC5F0D504B14D276F56B130AC9117288C81B6A8DB585A8CC436D300DCEA5C85118F594184128BE8D80AE307DAAF60E42418A34A626D4CABD960451656E60565B6519DC4857FA9D11D2EF1D5D162D95AD2C7C806218A00A7D8B71F0C6F2106173D95C77EBC8922A9C81816283504036697EE9915C39F844E2BE638D6591233A87995F98CF3433DD47D0A4613D6BA67B4EF77F855D31659C25C345CD6FC3ED635CC443622821977B46D56EB45062D4508BA1210F7A70FD01A2E03DFA5134167673A31ACC4A42ABCC1DC9AF7A409508F43D99163F604F3A32780EFCE330C03A1CC9BF5AC88092C914A23A27A96E5161E +MD = 1EDCC22D1FEFF34B4BE03038529243E789BF5E6003F01D0C9B3395B19C192EAC + +Len = 1952 +Msg = 2EDC282FFB90B97118DD03AAA03B145F363905E3CBD2D50ECD692B37BF000185C651D3E9726C690D3773EC1E48510E42B17742B0B0377E7DE6B8F55E00A8A4DB4740CEE6DB0830529DD19617501DC1E9359AA3BCF147E0A76B3AB70C4984C13E339E6806BB35E683AF8527093670859F3D8A0FC7D493BCBA6BB12B5F65E71E705CA5D6C948D66ED3D730B26DB395B3447737C26FAD089AA0AD0E306CB28BF0ACF106F89AF3745F0EC72D534968CCA543CD2CA50C94B1456743254E358C1317C07A07BF2B0ECA438A709367FAFC89A57239028FC5FECFD53B8EF958EF10EE0608B7F5CB9923AD97058EC067700CC746C127A61EE3 +MD = DD1D2A92B3F3F3902F064365838E1F5F3468730C343E2974E7A9ECFCD84AA6DB + +Len = 1953 +Msg = ABF669BCDE5C63620ABBF5E74E8C613BE25B9F7DB855D2485FA0EAD7D46FEF857A755DA6F1ABC1ECE8E83213591C6EF5CAB3C346DC317332EB35A0127F1E833A945BC260FBF9404ED8B4A75B2A2C9D8CD69661541873B3500847861C803AC25208FDA7E896DF7B586FD018EF021768F43AA5EA0E5861843AACE2847263813BCA7CF762E6BBE72468A688A0AF80E9A73DC11C74524A13C0E8B592EB8077F18AEE77D0F106617799187EA3512427126B59904A5CDE4AE6D20034B6DF59C21DAAAEE7BAA7D99B13C35B58BE23406CC1D276A65042E9E78BBF42DF8AA602DB2BE09852B8C19700CE0D7519948055EBACABBF24EBA16E80 +MD = 68D695C2F6837410ACAFE318CD6E1B9F44A84A79EC8639FB10CB07ADCFC699B9 + +Len = 1954 +Msg = 16410D74CB95F744EEBADF9BC50688811C4AC9131DC59AA3761DD2DAFA8A2C02E3E4021B613B3E971CB5ED40ECD2161B3AB9161D8E30F8A227F497E8721A88D67FB0712639823F824426FBC1FF08E27DCFD4474E54F9E6B4EBDD57D89BC3D5A847C55C2AA1002A0C0F653DD5971772650B4A9AF6B2358B5C5845531446AE4DF144EAAB797BE5D990E22B7DC582576C4FF8ACB3EED02B96948D252C66E8C28F043F9D176772AEF45FFCB61C85035ABE67D57E9F4EF7BAD93C39B4BE09682B158FC43A591EA7C06C456F6651D2C6562E1B6086E7A27B135EEE694E3D2AA07D13343E7BB2505E15FA8A486F114E1F5DB4D8D4D8145600 +MD = 67E7CF42879B9EEB4A1E498E224497610066042875BB8DF696EA8C5F6C0774C1 + +Len = 1955 +Msg = B9E9D8B68C875D73D858308A6605688E6FE70FD52893AAF1B7BDC413892E3FCF4A43AA4CCFD985E0E73EA2AB52545B2DF7170E70FD275649651A0FE095321E878087E256DD3D9A67CBAA1845E7384F704CAC79EC12256CE217027F27536E36F8CD4F12F862BF5AFA786861D27627BB3AC4460426CD2F1E847DE9C72B20607158189BF77F2D46F22CEA2E4436CD9FDFF7E296D6864F47045F4794DA08F0B02D370296E206C16FA311CEA6E2F6272BE995F81B291B70534EE6D8932B606219784145B50B2C67C67CFF06AAE6294FBF282780CCB522B61E9DC2C8572782FA3B90981D63280E477E6D920B6249181206136411D859C020 +MD = 8A29310E7A7D34DE0EF9DD60408B5DF1273491E779543D594776C7DD86C25E17 + +Len = 1956 +Msg = E71727BC500E230A97CF57873E425E5901107C83F1448440DA95F4018D51C486FE25C39EA3D361E199DA66198851532D3513A9F74236BC02F0647A292A57C33CCA61F4ACCB32890BC94894EFE36007E3506C1E89D495B39999529DBFD62ED78B8642E1A7CF4D478F955D0695CD506BD7368675100C35F12D679B6F99F9E7F57506F0BF13DF269141EF5E746D57FB445F3C2F3A95F7AA55378533165DDA3748F8E804C45088AD748CF2DF7E8E5ABFCD4A36B0656D7C84C231F3F38D7A50F3593BEDDEA2D8414C1EC538D243E86AB1E51015DF0F0C535F96FE3C63604CA0BFC30ED6EB8AB18FEEBE0B18FEFDCCF202BD322277461B80 +MD = C36DC295E2E526357CC8A6C7BA7A321A55E049A7D090D94A0966507FDFD87ECE + +Len = 1957 +Msg = 5EEC164C54FD4B1DF8E215DFEE8F22A9AC70FF7E96D92EFDAD389EEF1F0AA918DFB4EF1D714989AE6BA1DDF9D87DDC8D04981E6DB5C3AEB569E9122F1F6E608D44F4661FBE39BCB9CB9A6968F7670FFB67BFBCC2B328D3C315491E7AE9F8E28A501B28F58D9E6C261FA7CCA6E756001217F61D561EDF515667AEF88E6C7639E0073E7DA6FEC27AD73D8ECDC408B0448788289801CFF6F4322541FBBED19FD72D5C6BB2D3358940B40AA59E1753CC8278A479520BE1C567A480D62BC75AEC2B656DE8369E2A00D4C426DD556EFE3C4531C8E2E8020862EFCF01D525A04D7355A56EDA0D09EE21C3AFE10635E824B9895E9C723259F0 +MD = F09BFC8FDC52448D77505BADBA1CB7094F7C74F9F0447EA022B615E7E9B5A0F1 + +Len = 1958 +Msg = 948BCA040669ED34E540EFD1CD355103D23B4453AA59908627C6F3B21CD0F5B0E06E8C90CB4DAFFD958A2257BB2352A6F20341F6475368E17833DA438804740AB547142D3C62DC9EA8D335CDA93E2BC5938AF59F7A70222F2BE15A2F2341F92BB7A4BC92BA10E16EDCD7884201E44C87E74F54C4B210F40EC00C046A59AA165C88DFA6841571F86CA8A3EC493EA3B20781D09CBBD1BF3758FFE56FA23ADCB16CDA95129EB525CA86AFD9CEE8E0C76B3AC30E39AAE2953D7E06DFD566B2B530D8CE4C0844193775FA86804454BEE5E97E991E0CF5961F934B3BA2B34B731DA477AD033DF5D5BB944E811B4A9DDDE5AFD0971515CC40 +MD = 774EC5C589DBEA39CB31B0304156C4FD73511905BB0DE510932CDA9FE62E606D + +Len = 1959 +Msg = 2B344C1DFEA8F82F33004C08B3C41F31B584D250684DD642BFB736F6B47B6CB8A0694BE038469FFED59C97303CDC5B8C8628159C6D4A610849CBE034AC2B61D1CC3B70FB8E19A6E4408AA9040B0281F966AD20483F617F06F071C1885F37D0C539B551D0E8B85CC17024BF1EF07D98812795E623B426BAEB12E4406625392E10F598E257430B51A4CC1AA6EA1D9BE8DD00E826A956584BD56530405739BD8BCFFFA43A0B94E77456869E730CFB7C674F1BF78FC3B282C37E16BB45C1C6664B16322265FDC9B1F23410DC1BC83CDDB0A4100A24DBB82981CF81025761CA8E69E8A5D3FBBCD2E0BEDA902B6DF7E621BA1957CAC83E56 +MD = 24CD9C35EC1C8E672F01A3D19826AB29AB9CB8EC852577E093DE85D78A4AD7F6 + +Len = 1960 +Msg = 90B28A6AA1FE533915BCB8E81ED6CACDC10962B7FF82474F845EEB86977600CF70B07BA8E3796141EE340E3FCE842A38A50AFBE90301A3BDCC591F2E7D9DE53E495525560B908C892439990A2CA2679C5539FFDF636777AD9C1CDEF809CDA9E8DCDB451ABB9E9C17EFA4379ABD24B182BD981CAFC792640A183B61694301D04C5B3EAAD694A6BD4CC06EF5DA8FA23B4FA2A64559C5A68397930079D250C51BCF00E2B16A6C49171433B0AADFD80231276560B80458DD77089B7A1BBCC9E7E4B9F881EACD6C92C4318348A13F4914EB27115A1CFC5D16D7FD94954C3532EFACA2CAB025103B2D02C6FD71DA3A77F417D7932685888A +MD = 21BF20664CEC2CD2CEB1DFFC1D78893D5CA1A7DA88EB6BFD0C6EFCA6190C9E15 + +Len = 1961 +Msg = 1CCACD735B6D80BDDFD9F35303AFCE91279D5B500DFF2A3E43E0DF18BC47A47EF28F25097DB8D0D46A714F4C9E45819AA6B76D0CF93CD40C58EA79E84878C8DC3C8235F13DAF55E1B0FEB2A8ECBB6F58CC64E5D2150875E9732154F6FDF18494C92DAB65DBB8C607E91EA876A0E69DA35EEAA2F76A006D8C96C16C58E0EBC4FBF425A36BC1D10372E30EFC4AFEABBD8A41352F8905A8B206A7415F970381B50F555475856C0F74FB68F4B20F53C959C7D4F8F9C6C4442890BCA2485FE72F1130A496EBAF5D1BCE106B1CDA803C443D0069E1F9B00F2CA2DD2FFF9BC3B72970C27F7242E23E44A992D77777E544BAD9E3FC0E86498000 +MD = E592B4FAF6EE646BBE0073BE90AA42AC2FF297AEC27C595D1B48A04B5CA3E3AE + +Len = 1962 +Msg = D7F33625BF8D38000F44C468F593E88028F26DF18E25617735C7AC39B585C552D1CE84C84F75447F9F75A38115C0525D65D60786CFBDC9B11465BE38407948044BF24F6010C959FE222E86285FA829F118DBE44B331C7973BD32A5821A303078454A8C694BB36206A0EBD9186448451E65476164F4D8617DD55D52309738D7E3EF91BC21FD4D99B746CFE60236D44B53D17D7E28CB09275790184F86D71CF52063130DFBC615CE0EC7F7A2BF9E993D4C5137518079A29D75F198904DB796EE3C5F9814F4112DF210A9967CDB0571E353E5F7AA5B472B725B156BF43860F8C150A5A8F6A545AF9C3ED4F48BE4C65F961EB542795B4200 +MD = 7DFEF57950027BB14946093C201DE50282793818A0DD5F9DECC41B993C55945F + +Len = 1963 +Msg = 94174FF8C5D36489C7E6D98198D1C7AF45147D146FD3ACEA280A7E316396605E822ED71F82BBFCC51A235267C58CFEA72A69450287CE7F3F9B915AC11B18558890F711D3B6DEEEB362AD037B39A79C7D213FAD77DCE5D23BD1A335D178EA70636DB86988E6483A6D0D9957EFAA944822FAE8C1E70ED42BC6ABAD56E93876BAB5F3BD11511B51A44A6A44965E65A45D4334B6A44050C86318D1EFC235E443532582F6EE13CE5DA824CCE76F56287B5C6C3711EE99ED602FDCF397FC0B629DA4805AB7DFF1B503467C1732D77425C4E31549FE21FBF5FA67CEAA8EB9B8F44202C4CE0DC0CBDDAFEB38866BA57EF156371A809B21CE1D80 +MD = B1625556A3E6E5CF0254A10BCBDE1C822FB5BE11C5C2E770FF91A41C4CE63801 + +Len = 1964 +Msg = CD5532D4872E63E8DD65445D2DFF5E5F98F5AB898C51BF15F3B81BAEEF33FCAB207DD00CC4489D0C6C1E55582793A7766677EF55004D12E642F30960237F733B5C0039F2EB395671B006B694862C1ADFDBC21F7BCA7635933E58F8ED826EEA0340895CB0C9AB05D3E8F70CF561F27E794467C9CDF12AC6AAD70925F3F192140FCCEAF88A10528C39FCC14F5CBB3F8394A576FF0C2B98CFE390F7645C1DE0DDC02D3FF1831F7047143F001791F7C9753D8900F554AF61BE43A4553F02860B2EDCC4EACB5591B05235D299640654A5EE4A38B5DCE6447C655DF36C82602FB9383F04B1AA6FFB495F101B4BF9BC55607027A55BBA536F30 +MD = 7BAE739A96AFA20D183A1F516D539CBBF8700FC3AA7B2519B31478029B56B81B + +Len = 1965 +Msg = 6EA799C47249BA1831270FA6B7235587C4F04527EF854290E156DA1C494DE0E65A5F6AB9A257DBEA55717A3D0D127944585C5BAC713D35A6AF8C8FCD5B0529A8684F6AF238FBFBE31149734EDD251FD4AE4148073E73157F1F7CF6EAD5366B6AE389D20EE9F1AA425E46C509C9178F83EBB697AC71439A8B9664810499315DA0B01DA01752D78D6C0F111FE5E4ED772688C70EC6652C29916247C95127AEAD9F585FFAC7E2AFD753F8F8E7EEA44C93377FB945BA6817920A8D763D069E73B0FE1B7059B88C43C3DDBC1AB94BAC3A718AD48F72F2E6303527046BE49CD2BD452FFB3A1F26673FF6B8F5048AE41F9DDF49EF9522496408 +MD = 1F81CEBB620C8F6133BD45947E7C8CEC8C7FD095A3EE52858782EC8527D5A980 + +Len = 1966 +Msg = A1F22C756A6CB226E7FAB31F870A4E3721035F9F592F429D56141D9B73DD7A09BE3DF7AFF6DD16E29C01BBE00CBD4F4D681EDF5E2173B51F17F8A40F54E5D9F02CED20AA341FD48C203874D5EBE485554221A8C4E9C20B4070C688443A48D31F479B564071AC2F79CCBAADFA8C432B61BF9F767AC5BFDAB1E747A1D8ACB0761ABF58DD8768F1F2726C97ED5936B0629E3E1AA1FB581845179E5542F84523E3E71212E1B3B6843D9FA31A2B8C6FFF5A71B3E37D6F1F6A9A904A500BEA9F9650D0D6F6E9448FA83BCAB431D26212E057002884BC55E908F59A90275C5E3E53084260BA75C3955FB76DA67072C20477037BAC0159BFBAA4 +MD = 600115FFF20B0EC03E4B5953EE54A3D9591D0B22B2BD13365709566A2D829AF2 + +Len = 1967 +Msg = 81809338942312D6009885462990E428637F38E8E692E23635B052D285C393B1FE82421747432266CFAEFCC25233A4BD1F40B95D1244A73F48F9ED0BD418409A0EE45041FE4E800C1AC1A886FA26E91C3375FC9A443D4C4791BEDD8A562569A5EF11AD5E5FCBEF3CEB4C8D6D7CB62A5CB373E2FDC17074345A5E51DF0B363F70DD7A286685489101622FCA652622ADD70013C694E3E0167001175F10DB2EF0E442071ECFFA676DC3EB76D8CCADABB493EEB209967DF3A526CD606795D3B52A495ABAA26750D6805169F81BC840C7E7398BA977AF73AC0664384313747DA5C09C312EF2594F28F38B00A8FFF56C55231B8EAF0DCDA6F8 +MD = 67523ED38C39C0F7951D87FB0DE9A4D9FF5A4E8E637EBDAC668D38C70D2D38DE + +Len = 1968 +Msg = 2969447D175490F2AA9BB055014DBEF2E6854C95F8D60950BFE8C0BE8DE254C26B2D31B9E4DE9C68C9ADF49E4EE9B1C2850967F29F5D08738483B417BB96B2A56F0C8ACA632B552059C59AAC3F61F7B45C966B75F1D9931FF4E596406378CEE91AAA726A3A84C33F37E9CDBE626B5745A0B06064A8A8D56E53AAF102D23DD9DF0A3FDF7A638509A6761A33FA42FA8DDBD8E16159C93008B53765019C3F0E9F10B144CE2AC57F5D7297F9C9949E4FF68B70D339F87501CE8550B772F32C6DA8AD2CE2100A895D8B08FA1EEAD7C376B407709703C510B50F87E73E43F8E7348F87C3832A547EF2BBE5799ABEDCF5E1F372EA809233F006 +MD = 6472D7C530B548E4B47D2278D7172B421A0FB6398A2823DD2F2B26208AF8942E + +Len = 1969 +Msg = DBD3544D800AA1089CBB836C48569B2E763E156D6A8F09D6BC6744334EAF929455DC50F1EAFECC039EC10539DB8D8695A60FB242C96911FA4A3CE955BC7A46C4F057C58B93633BF80047D4450D664461C5D3D4DE011483710E847AB548BE8C9D70296BDE75EB478E34FFB1C90672435D4DA025C15EA940C8BA6C2C6E15FBC13244D706395EBE5DC90D48A9A4C9F0FF0269E7DD3B352CFD0AB10BB88C4C5CB8A822B31F1541486138DF7B212B522AE091FBEEA721E63EFA3000487B0A52BEA62F15ECC44A2BA2DC8814075CA990A7EC45CF73FF21E7A0B4ECD683368AA32032471DB5C80FD3EAED54757BB930A52AE0911940784B2D9080 +MD = 85B9EA2081FD048448E22767732F6B0F7C83CD406C9E71E27CD8C45ADA64F335 + +Len = 1970 +Msg = 0DCE440272E7BF0E8808D973FAB447897D8E2437FA6B38F5738B9BA24AEB92DF2AE7ED077BF290998AA8A53355AE2B54BE1834EB453380DAA81C8A9ACE210DF4D5D9A6F303C1CCB3CEE10AEB826AC172253869B56E95E488D5E315BE56BC46F7572CAE284B6636B67A23986F35D02D01E28A092899852CCCFA3AD3575FCBC7376BB2F6F7C76177C066ED0C1E656A21DD2B8AA057BE4417F09B81B94C17EE37120426FD2FC9C8A146C85CA6D6543EBFC658D408DF7D18F1987AEEC78E8CD011DBA6DFBAC87D9EE4756759E15A92A9177AE040F5A2C3E92FC508E4F3D623D84F8395C8BF68DA80EF9257E74E192277CB1DA02FE0F8662B80 +MD = BBFCADA17CD57385ADB21014A667AC8301728CB25500413B6C8AB7B43968F8DF + +Len = 1971 +Msg = A2F6C9FFA8253C61D6C8F78BE1237183E4B65C253EA14132A79DEAA81EF92F5A6C3D9F29B0F938E3EFF71161962A8ABA2FEE2BEBD3A02F8573F92525F5A98022C41D3D4984941E04D02040A8483F5743BFBDE3D622F64E53CEA89B5A237F1027F6D27A8B4046FD5366DB8F4CC056C23280B9AF8D7CF39E084E42762C4D3175D2B8CD9BC78229894CBA719201F4DA580034305AF981E57EAA123FF1444CF930AF1DE2EE6171BE5269C714BA85D15E6D69F42BC3448D993E82AF6C3372B0585CB51E39282CC5675677EC7F09E1890BD98C2618ADEB7C5BBAD4EB3FE58ECB44F8A4F8255E0A6129D739A757E79CCB39EE6748BBCAC21EBB20 +MD = C81AF75ADE43E296DAD8BA77A656C6A45F7A66EC98589885EC0C47D78B32AB68 + +Len = 1972 +Msg = 3B9779B86531629061CFAA92407403174AFC68A88CB78D3EB1CDE576BA91E9BCD160CA18C43C1C16F9ABC6C391C05704506710FCB8D0E2E42EBFE764A53E78721B1D2113AA21127BD90C263D4B4A8AA4FB2635D29EE4EB6FCC3CE26BB0B14926F0001CC3712CE5E18E21116029ABF3F61E72A7FC2E5FEDE35741E86CFE51444600302DB629893F0731BF6D2884AD972F36A53F9982669EF8E9792E7FE4FCD456C8DA6AD11A176BFBA5C0C6C0A822C37D085A610F9510F0560935961BE285E80002A9D178B9ED01127463B72000E61B1A146E78B815216114F777041CFAB127962D0B1159DC9B3236FDD03C2C401C842E99B9A433850EE0 +MD = A4C2501C5318159AD854F5DE7EFD1B8AD264A6220F542FF3756499F3F4C140E4 + +Len = 1973 +Msg = 4460F6EBE4C0F0C89A96962AAAF68A01064C41E45BC3B0C3073F09319F29EA541F1F43F27008DED6D1EF1F0386FEE37C05E09C68A51849C22891575FDD0ED0E632EF818A875EFDB7D132D6E8F16946BE22C6294DA34288ABAC37FE8CFF2E5BA5FC79E6D5FBA3418F6F0683F3BC4B8D1880C5B7A716593615ED64A1A84FB61B5B29FC773701E6B60D96F4CA628ACA5A52A490439FF6A29855EA58D7D118BD83451AF3685A216DFF00A8179237AF0DE8D847117A6E834AA00DFF30748F31643D774EC6647961E446D7AAEC1CA5C57FA205C3C66F407A4F629A7A2DB1ACBE20BAB9C41F6019CCC2E07CB96567291EF53878BCD000CD1BE3C0 +MD = 80F74A0AD29F4399AF8B647A64A842ED03AAF51AEB8A6F84B013BBAE42E729B6 + +Len = 1974 +Msg = 7765B5933AB981AD4263A6313B20E75F946BBA84B3DA7FDE2C108E1F45EC9443EB2159E4CFE6F94FA71A46E14F6A31E87CAB6A46877DDF8F8E19E62621D27B2FCB05FB817E9B325993D826D92CD1711A5DBA1315FC53784B0558873CBFB903447E2A24E0CD84A84678CB9CABC4189CB8FB2E1AA53E93DB4DEDF70CBDAA402336E5AEC36C5316D124DB57C4FD68B63CC46016DEF71D7D8D04E988F1B3731F0822AFC717A036A54CEB947244E208A21E4D61FEE25A5CA55E6F7DE52A95629F379CDED7C9D5EED4F44D215FA6E62BD55B390AE5503EF2666AA564DAA2A4122B64B99632DE6095EB1DB5B92BCA0AF12E041B7939B96B8D3734 +MD = 1A301D333E4AADD513AFBFB77F42BDA23FA48D1BE28D574713C1322EEDB7B3B2 + +Len = 1975 +Msg = 17D27BCFC84896AEE10DF3866AA3D8A18783644307467341B3D585A544ECBD50573710C72D2C2639545EF16BB6902505A556841E7141238E5546384DE52F1E3F56FA342AD0A3D6315BB0565E67DDFE47C9574078CF7AD385082E310B3E14CCF9C32D0F1CB69D3A19668288425287263A899687445E4B5A791186494422CD40ACDA3876E51F8BF77BDCC709864F60D15A73DCBA9DFE257A30CED49A76724643C5E8F8D75E5B34066116DA94EBEF91C52AAF508C8DF1EC5F982227C95F7BC0CE2BF0A712AD48F7E862C61FADE2289866650D311D4213857C4ABD6C2CFDC1C89C7C450951E3DA5557C0EACDB218C97958F600DC7B22746CC0 +MD = E9094D7D63CBFABA4AE0822D2150B83CE91F8420713932C674251C8F49DEAEF0 + +Len = 1976 +Msg = 721645633A44A2C78B19024EAECF58575AB23C27190833C26875DC0F0D50B46AEA9C343D82EA7D5B3E50EC700545C615DAEAEA64726A0F05607576DCD396D812B03FB6551C641087856D050B10E6A4D5577B82A98AFB89CEE8594C9DC19E79FEFF0382FCFD127F1B803A4B9946F4AC9A4378E1E6E041B1389A53E3450CD32D9D2941B0CBABDB50DA8EA2513145164C3AB6BCBD251C448D2D4B087AC57A59C2285D564F16DA4ED5E607ED979592146FFB0EF3F3DB308FB342DF5EB5924A48256FC763141A278814C82D6D6348577545870AE3A83C7230AC02A1540FE1798F7EF09E335A865A2AE0949B21E4F748FB8A51F44750E213A8FB +MD = 2AC7FF80EE36D500995C973B8746D8466715E6D8B0F554AACB5D2876D7F5B874 + +Len = 1977 +Msg = C8805073A9044F80741F09AF69CAADEF2A17B56E785F262B7BE09A27C1EA05A4D58D04FE84F513CA24E2F3F323B20FA5427F0D8D7143B424010EA901A02D5969D8DA81B99FDF67F3FFC7DAC9AF010C7EC6C454CA5512116CCBCDAA15DF47C4D55C58F9B10724D3616AEE9B3938484227718A458A9B33440E61A9569F1E99667BD26D7C70B689C1EB6F1C557F689BC58FFE274C21E4F88C9660321569A6ED4A8CCEDE6640B4BA4E8ED6968DDCD5CF3FF1EF6DE0F036CD0FC81B7DADAA4BC7FEE9C0AE62AA115512F876FDC8896EADAD48C9A6123D6D8755B812D19E77B1A40C5F973C4586E774BE02F0AA2C6F62B1617D00F0EDA15BEE6380 +MD = EA00558AEF726C2605077D6AEE03D76EDA930A53A62127DD82BBE174F45E1E2E + +Len = 1978 +Msg = 187F478A37386BAF26EABCC1A56AED42BFBE0FAE4D858405A66DD88637D1CAD7EC3E1F7DA226DAC75FC33686476A29B7427544069EF6844C1E9F5707F24B671918ACD172F352AFD2F30AD91289D57F20751D58E23E928B07CF76E6617CB251814D264BE2658059E0CCA41C08FFFBEA7803DCC6E125E5092D349EFB0260FF0BFF9CB8A4EB7D82B195C4FC17F77F5641AF9FEEA9ECFF4682856638D4F12105DBA8755009269F2083E0953F3FC877D180B253F8F5591E1944D13C83776AFD8C7AC861BD5F083A2078C65B51B4ED174B1F57428CA24D798C12E724911618C4E620A7388EFC719A647DE1586541FA690BC1E1F2F2131B4FDC0C40 +MD = 8F32E68D2CF3B2371BED9D6B9C7379375D9DCDBB7D40C60E3F18FE425A40FF48 + +Len = 1979 +Msg = 752534268E1492913DF547FE5A08FC558087006C000B2005E763093386C6BD4BD172873CEBE156F45BB4CB1DE99661B61870DD8C611B99DA07D15A6B2CE220E30B2DE3BB778BE30F30392769C84EAFA3697E04D9C8CECD1AD8065975A03D9984B3FF73AA757968F1E2F3C44E6E611713CE9FAE1849909F076A0BE17B80319515B58F4A27FBCEDF7DED27653655C05F89133596AC136630B3BD728988D833632ADED5834368856F1E77CB8B9BBC37D1CB5A989DD1009C8348C0F8FED009F62D3F37C2994824FA80BA8AB0AD3B484EF48979817BDD482064283F4E89A93AB3126405695EBFE166CF3070764B3126883A6C854901CD7F44DC60 +MD = C48246C64DEC56399D5DCFAD0409176254D641A3B833CE0F7B19E80390F382C8 + +Len = 1980 +Msg = AC1569ED914F50B464922215661963F99EEC3C048FA809B032B9EAA69AA7B138B5F049897B1A73AD8CA4734F1B6FD6DF0112983E29820E8FAEFA6D530AB1FF03DE9349181D9C235D14689EC5C30419EEA0D891A8A33F295333B02227BCEA4DA7381584353AD9AB5603E03E69B66D8AEAB20B15AE84C26DDCFCA9EE7DD14EB459784495EDA6D273136653FA98BD42BCA1A0A714A8A3DDAD33C7A6B1916838D4FC25F0524E992DAFCC15FF866CF2DF1613A0C3B81C1FA6BB5D34ECDEFFF540032338EA9D372ECB57692A3AF10B7592179B6D70DEF5281A804BCB83C6EC48D8938CEB66EC6F3696D5A729D130C3F94FED71BD4A4071EA86F950 +MD = EFDE175633ABD4A9D012DAD20A4CF72166E452944819F14C79C94614CB1884E1 + +Len = 1981 +Msg = 24EBF97325E94624ED9571F110D4F9C0D459D6B659B30000F47B52BACA0E7C8E41C8DD1D4FAAE2B0803B22F7C49354507011DBFB157A8D110BE9F8B056470EDED8BE8072601C6FE963584F3A32FF989335EADF05240B355EB4A59770F7F370E02346058C74DCEA0A7DDD4E2EBEA8CB9036B0859B04F1132625A081993BDC622D8CFFA64A7F003C46067C6B224161C56C6D68647124C3B92BD0A1CDD24A98E15462458EA4B8510C7A7027DA769317AA0B399A1D0447525E3697A18C3F4C91D2E4064FFE358A459A3E97DE7DBE8E78DFF5A277F4DE7C4FDDAAF8D1A492420C1D6C60665D4E72598ED24EBD2D695053532561A5810002911588 +MD = FE74A15D357CB6210BB6616A4DA9DF75EC5BEA5D1E771AAD650418A792368E50 + +Len = 1982 +Msg = F965E971E9A188AC8F57F2BA40A21C0739FA6AABE4FACDB1F5EB88A9093B42D1D4FB562335B5D10B10C0C6940A2CC0EEBDE1BDB840FC1256DE90CEF0E008B3F1BD27B7141DCA0CA42B579DB8629B7DA66E36D578906152AB3B22CB0ADF3C5544F9D8249BBBD51089E6C758349B8AE53D7C459E8DA42E7BD7C7AA6237C00DEFFA268C059E3EBC450760E658D104D7177DD45B3F3CB254E3FB1AA8D2B7DDD24B20A7727D34DF50FC5A103D9F2623D3A9488A4A8938739CEDADC30E0DF2BB00DE74E7E4105ADEF42FD83FB97B315AFAD9456795D492B02EE3F9FA942408F74D1D716931271A044CC25303BB04B4C057008E74D2BEBE20931FFC +MD = FBED87B478D2FAC5B98B66901F249B25A12CE6D69B140B0D8EBAC5A1F4596DA2 + +Len = 1983 +Msg = A3DFE4DDEB6F6CBC08CD03EDA2A386676E9E32DF1C093937377295A7FA10421449E7087C6FEDA907DEEB478CBDDA62BCF56CD9361386E607D486F887F77D9AAD16ED65EDEABBC5D2DB830A8E5059094C190E39DAAAE4C4BB9B5743A9218189EF5FA1CBC2A6E8FAC2878417D37E4B0ED6FC4794B6CA8A9D213452CC02E6DADCAEF439C940DF132CCEA86722563FF416D5FF13C38F34EDF3734A9E6E69304CAF7FFB959A2AF03D08ACC6B04A5E43FAACC9ACD2697F7E60DDDCD74948EE73171C751548A506A9319E0103DA0B8C97B35CE261647E92D2E10EFC9D57114B9C9EF8ADA583B084B8F7099520AEEF26548BC9C50F8A7DBB18FA2928 +MD = DE4BB57A937716DD5BDD32DBEC8566395E00007ABD3C3A40F1F32523086A698B + +Len = 1984 +Msg = 6B860D39725A14B498BB714574B4D37CA787404768F64C648B1751B353AC92BAC2C3A28EA909FDF0423336401A02E63EC24325300D823B6864BB701F9D7C7A1F8EC9D0AE3584AA6DD62EA1997CD831B4BABD9A4DA50932D4EFDA745C61E4130890E156AEE6113716DAF95764222A91187DB2EFFEA49D5D0596102D619BD26A616BBFDA8335505FBB0D90B4C180D1A2335B91538E1668F9F9642790B4E55F9CAB0FE2BDD2935D001EE6419ABAB5457880D0DBFF20ED8758F4C20FE759EFB33141CF0E892587FE8187E5FBC57786B7E8B089612C936DFC03D27EFBBE7C8673F1606BD51D5FF386F4A7AB68EDF59F385EB1291F117BFE717399 +MD = 9FF81D575F7BF0C4EF340B4279D56E16CE68821AFCDF2A69105D4F9CADADD3CF + +Len = 1985 +Msg = D32ED64B8AC893E8814F30BA3A421FE80F06FE8BB2599AE6977CF0387E07B7F6BD57AF3980F039921945522F75A1D9B1B1CADD6B666E6D19A9930847B3E7A1BCF942B8CBB25F6D63FD0C1A61365F64E645EC1957D1582CC75790460F92DEA77A3F53F4E695A1E712211BF187A379E04C40098BE74F5BF2DA7EE371E6C3B16B93D2A01A033EB41A3C5F834C4ACB817AD78BCF0D24B8FF876DF98ED9094A69FEDF58AAF100DC82B20CD81520411715FCB054018456C5BCD6EFF22ED949F9EE2C823FB2F22653118816CA66D7FCE9554401035B71939039B1E010A15DAA57A7F374025BEE3F9CF85A79CCF7751E4AFEFD4B1A8C71B6AAD3A40680 +MD = 00F1062CAC1708E49F6A30D543714BCA2937CE0E4FBC2C49D0E83AC498243209 + +Len = 1986 +Msg = CE81B8CDF42C400880AA4A46486ADB10D8E58DDFF5AB61856EC7417A93F1FB0B0C788D0BC3457BA0639078034F22DC1FA93635B0259C4DADC9A59C7A3B80CF7D5FF82C2C8029E27F2F0FD612BE4D7271D3045947E173C971D1FF3649A7CF97F5B8849ACBC34E86FAC4ACACC467786666E1D753FFB933DFEF1C214D229505BA51C5CA6705E9513AF7909BD7A4A43F035F1A78D383F663708669B62922FFD5EA59B41EB44A3EEC3D38092F74093455F1A54C4A73EDF6B23A74EAF0539518A74F174799128F6CDC7BD2BA69CD7B2E69E35E97B9424849605187C6B3F3F2D0A0AE5443378438BFC504C6FF354BAC02E073D31C5C8DF1AB31B553C0 +MD = 163292F36DF595C1191FCE41D700E879BF1A513ED957F32E4E454D9D7B201DCF + +Len = 1987 +Msg = 142C2824180B20EB38CB707804017AA76CBF53ECCF69E084A1B09EBB13ECC2B12B7D58EEDF06CE7446D231565B6A34C18E782C339039CA41CF94002FCD502270DB6ED60A2C7E2A06E4AD98EB37E94173C1CD531417F29A9188422727456F44E113E1611B363288D8ADBCEFC725CF0FFBA2BE5A91B0939FC0D1FF81CACE638B34390D2D5F0018E30D2C69780D715BCB484687D7D672F06DB11E557EBF9BDAE5CF982BA0C1257996805218672116D34CAD98328C6B62D2ED5C28E7A1B30DBCE0EFE498BBBFB8797271F1D8E8903D5FD9217435609E86FD3595762E824CD4C7DA5B1597C4251FF596FB267DF0C44863D3D24D72ED5997E5E59120 +MD = E6634480682005C5B7EC8E21AF83AFE3254BC963834AB56B6AE140E21CD9D0AD + +Len = 1988 +Msg = 329A07D707AA29AFC4D5E780B828DD5F183C0C481C6E12FE60CA6B188C233DF3973C832983BD59B474E9D39D0C54502D7DD983FB404C77DF6FA7FC349C8E74F18E7C2533346A0B505BB7508C7CD11687BEFC78D7A2EB6C253B99E427E0DE4FB7D2460BB900DDCF6B3528207A057F5BA40E89C810B35174FAA3A94373FE1CD2DDE4C8CA7274E0D33365597654C4F75E28F7FE03648A76B8D27F28B0AAF87331C65FDA4E1B0D26DE1849931134CE4BDD6F0FE898D05AFBB7F2C2D2D1F5C4E9A8D81A1476D04AC82225B7ABC2857B129CEBAEC02F343E2B8285729662872B8F29BF8667D9FDE69EEDEA464FB460D80134771FB375314E985FBF60 +MD = 00B950AE3B1261B7481C023F51B2D8EC765823FA64E01D77003B9B0EF5B0C3C5 + +Len = 1989 +Msg = 531375EE838C53F7A0F60D2EF68193AB311A57BB99DECBB5318FA03CEC28C4614CC301A76EC10A414464A128402549708EECC35F14D0F41972BD85F1B2BD0F49EC725D32738A745F63C59864EBFEF162A744136ECE8FD317D04B48EED993D1C2AF428FD65CDEAB6AA83827C3C5F1944FF39CB3FAAAAD89E7F69F154A1367AB04A2BB739D42CE4075309057CFD50B197B63988DD70CAAE8632D3602984664FE7113E6CEEDBCF46F61461A36E8DD555334D0272C1BD3D834B55B3BF3193191E458D72E8BC0CDED3F311A95388F1527F98A8515EB1FB77F298F03AC73D587AD866FEEAD91D17925533EEF29AEFB53F8DBE534DA4902F1A564EDC8 +MD = 81BF8EC8F34A690F1186F14933C08126A116CD90FBEB3BECA09677B184164795 + +Len = 1990 +Msg = 3077B114046798409B052A162823AE9CC4DB68F0C32E8E8A9F12B039C99B8C8D2100AEC68BC7AAD75F5AE414A8E458B2D10B430DF82A30178B66C7DCE52F1FAC05C8D28D511C39A3BDBDDCD43B46B68C7A591CD6ADF6F5AA9E5306BC308FC771CA43BF1B63B6CA9604A24F70B5A2ECC3C4772C5B583B6798F61352EF976DDC14FA9D12BFA3EDC1B70BC198837318E687670411D049476516AC35DCDEDEC5F77F36B5FB3F18607C13CDB7F9E0B413F5AC2C8DD8B6070BB84F40368F44C887E1B3D08F1EA5B52D82799F5BF18A0DA9A64DB60F6EAD631BBF93EADA405C7CB4D39E1129945E265B75A9322EFF74983470134A454B1AFF0F4529C0 +MD = 9C293B37A921722B7A74209A96D34A41A536F4F67E63F0BE1CBEF38432C22F56 + +Len = 1991 +Msg = DE175365B0EB7442D7AC52719CEEC2A930CAD9B9F9BEA109F0F78668CD568EE0C1D4D7A82D44D9D1DD2C01B8A3C74A4EDBC9E59FE6A646C496C8955F96B385284FDD2F7B2715C71FE0A062A3F890F2C03713A234E46C7AF287FEF559CE955FE33CEF3BF62C0A811B3E366782000CCE4781C94F1CE71601936CCAF21EE51622E7115CC769C1282E9A4930D7E4BB0FB324C5A8F6414AE1C443E61FB1910C1384B3848AF40B8A4EE96241CC132F0BE6603DA079E67AF04C234972613857FD5718E54D66D1B542CBD964EC074DF0F48C21509641ED11B0C4FF3F6950DEFF55526A0936D4DCDB28ECCB9D83BB9D68D93C3AB18B09AB8CEA1B6109D2 +MD = F3067ED65B0A11E2BF9A96882636A2B05D547F7AEFDFAA59470E5C7FC70ABB65 + +Len = 1992 +Msg = 6A01830AF3889A25183244DECB508BD01253D5B508AB490D3124AFBF42626B2E70894E9B562B288D0A2450CFACF14A0DDAE5C04716E5A0082C33981F6037D23D5E045EE1EF2283FB8B6378A914C5D9441627A722C282FF452E25A7EA608D69CEE4393A0725D17963D0342684F255496D8A18C2961145315130549311FC07F0312FB78E6077334F87EAA873BEE8AA95698996EB21375EB2B4EF53C14401207DEB4568398E5DD9A7CF97E8C9663E23334B46912F8344C19EFCF8C2BA6F04325F1A27E062B62A58D0766FC6DB4D2C6A1928604B0175D872D16B7908EBC041761187CC785526C2A3873FEAC3A642BB39F5351550AF9770C328AF7B +MD = 09EDC465D4FD91C5E86B292F041BCC17571E1F2E17D584DFF21DD7DD8D8BFF35 + +Len = 1993 +Msg = FAABF245E59C1E88C39FDB7ACB77B2B3F67FFF22CDCE4F109B321C5B720DF0E4C3995B01968676D4305C88CA3A539A9B740A97068AC91F966F2111C7AD7E1A32E947CAC73F1F5DB8CDB85374FAC8DDC0B964E506F042FC8C76D4273E6CC1C370189E60DDF920FE9895F4C2E6DE87B742D09BD90D0C6D792A0DBA942EA21D89C735F90BC71CCC32BF661AA35762EE8C4E5C354B8D72F9124134C02E15AF1E7BE14B8CD862FDFE7838CA75BA76D8CFCAA427B0D4D65068999B9195948E387EFB1596EAF8AFDCB4D953F2833C2569FB0C40252244A356DC044ECC03FAD63D1BD2D2FD9A683731A28C0D13254EC9BDB5EF09EE3A1AE3148A143EA080 +MD = 898C5A728CA311D708EF4D5CE98F5316482A40B336E17A80173FF5CDAAB92BD9 + +Len = 1994 +Msg = 41C9AB2D7A66C27D36633BBD90024BDD2A07F4D266AEDE26023FEE9207565467B4FC917C4712D5ABC56CE66F0020390E5A2BDF7C36821AA032078721A8EDB4CAF94D055A26C182D42796936A6A1DDF29F4383D169DA0FB442F899505FFEDE41C2110163E7ED694562A687EDDC54D5EF2E7EDFA91FC7D3F73FBA2D80D37A5F980435CBDE686408B3BD2E6D8D2449446F7C6C2B441965DA6D17779FC3F33DAEBF05E1060D378A21708DAD6520B1F8F53FBC65328C24B507B5E20DDB5E2C80766E794A1A71259AEA52DD1C885054E1D83ACC38010E2D26CEBDA306762762149648763328D341725644ACF60A09B2ADBB96002F01263572170188540 +MD = 9DF23BB5888517DF685AC79AEEAC583B8F100D2820C7DE8992ECF93E11B43882 + +Len = 1995 +Msg = A245516F0282C8B0E6F2EA8718D0ECCB66D9C1F90CCD26D793BF9DF3101C5D0913029BBBC09832E621D65527B3823C47708409464BFC59199221A3EFA28B413563137DD4A2EBBB5D62CE6ED865AC9F1D9A7696E891D1832FCEDA6DA96DBAD1F6DA4B52121ED3D4BB70FD7C9D46386ADC38821202B2B6F8D4562F5B10008E35BEA86B21991F9438B2D63F753BFD680FCB509A9A23087672C11317E44BED611A113CF7A5336B36C311992D9403A9E181BFE3CF48C0990FDC347B12FF6997C5C451E720396631BC26E43CBD69CFF6C77D8FBADFE738A0B91B7BC213A37314CE4D645A3CA98EF451165CB394A021ACCE94F268FFD2F95741B8883D00 +MD = 3EE55B64E13B30A2E5A9FED54644747E44B2974217F70F9655FAC4584C61D1BE + +Len = 1996 +Msg = 2F30C488FFDB8B60D41FFB45CDA988F0EB13DADB46DFB03654CF1BB662E9CFAAAF49830D2F011BF511E0437B2E55A0F56D7BB4BDBFA63896FB7DBF6741C3227CF9DB40FB4AEB4280A0BE09638F735F320B228B2CC65E88FA75339A948B7A1BA147532593DC85A793F723BF4EBAEEB9181366D9FA7DFC49C9F07B52E8F601B92B7F54A55D3393B6680FF65317DA41C0B0040E9206F65C3C183D8CB832DA4FCB465A731348ADADE1227F779D20788A096405A26CE76444E7D8713DDA48DDE0F56006D38E910CDFF2F1D0F20EF4F38D9B2BC9D1C31C7509D370E31E298892CE85D547ACCB4ECD36FB0BAA61935073CB2DA89B83A93D23F21B4D5280 +MD = C96DD58CAE7B2007F3B815677CE559C46425790A197990E5BB43A11151DC86D5 + +Len = 1997 +Msg = D60976242E138CB0311CF692E23FB29DCBED3AB53B9B9A5C810C8CC5EA22ACF5E5EAD41A541A66FD03DA085A088CB6BE50166B2C604777771F90ED0CCBD8F6C445BE01C650B655106D713CC18613F1EDA3C45FA92A68FBC24C660BA1F13440BBEB36E8B2813F2D85D82B5EF19163D0FE77B80A3E66B378D3F14936917A2390CBDD5AC367DF32E109704CA448F4B8F5F1937494976A7D721FB3098671DCD5615739E15A22E4D5D7CA1064DA010EC5E371EA286CFDDE523CF3EDDEF2BDB58DDFB021599B5DDEF9CB9DC83E5BCA43247FE5C31A9E1BE19D02C8F84F7816689D6E6F0444940300ABF38A70C9AFABEB54B5B926B3D90B5ED0C5AA3AB8 +MD = F500106BD32FE3D777835E97EBA3F9FF229CE0C98A82F76D68B97181820CAB12 + +Len = 1998 +Msg = 8A1B7485D535E846F7F57A9C668B202F71E36C4970CF9F1EB14B433148193B466A7DC82012AB7C5E97A9D0E622CFA4A9B846A5C7B621E89CFCABFE752169ACE355CCADB19243718937F55E66682C6538B0C66B94830D7B03DE0FBF63E4104DECDA39E9667727602C37A9B5ABE069569F6E3D0417842B96576FC9FF3B20ECE46A68BAF6B4EA8D6855E84A72D6DEA2CA13546F9447D229E83D185698BB5FB1C073570B0C94557B90C45BDCAE552E45313E99A4B94D422DE9DFC84494E2FD1E90CC922EAE9C49AADEA642638F44222F71CF1D63BD2E7164396FE1EEA7AA8DE59EE4CB35FEADA22C3B752F569F2E3B2BD14191E956318D708E9D0600 +MD = A83BC68026373F9E4764175E0DECA14E2DD36CD3F20E601A792539EA2C97A0AA + +Len = 1999 +Msg = BE48556570B10A62DF06BC43B6A034A221C26E455E28A1541AEA3042ECF9778BCA7F81AC9F7525E190124E359E7436D15C629FD388AF0F7EC42F4096C7C421E0733A716F78C86A1D77CC66683FF16B022685409C3E99240255BFA2660F3353D5B9F1704890C9156E5CA3A5ADB62952239D3B6D3E6C2EB7BAEFC4B5B385B3E7A41BBDA175B9D00F88CF061E78A921C90AA0AF22CFB5E0660981D071CD67800A0CEBA6D6732D9D3EA0CD821378B5BEA369BFB1D42280F4A81D44F6C254337CFFFAE8C69F49A444EA23A736451942B98439C03F13A52FFCA6A77F51E46D4A71E384CDD93A39C713293C10FD79C906FBB0EA5251A2E7B55905DE81C8 +MD = 93353589DE9D65085348CDCD00EF9D37F3EB9967B6043F624B494DDC31671A66 + +Len = 2000 +Msg = B3C5E74B69933C2533106C563B4CA20238F2B6E675E8681E34A389894785BDADE59652D4A73D80A5C85BD454FD1E9FFDAD1C3815F5038E9EF432AAC5C3C4FE840CC370CF86580A6011778BBEDAF511A51B56D1A2EB68394AA299E26DA9ADA6A2F39B9FAFF7FBA457689B9C1A577B2A1E505FDF75C7A0A64B1DF81B3A356001BF0DF4E02A1FC59F651C9D585EC6224BB279C6BEBA2966E8882D68376081B987468E7AED1EF90EBD090AE825795CDCA1B4F09A979C8DFC21A48D8A53CDBB26C4DB547FC06EFE2F9850EDD2685A4661CB4911F165D4B63EF25B87D0A96D3DFF6AB0758999AAD214D07BD4F133A6734FDE445FE474711B69A98F7E2B +MD = C6D86CC4CCEF3BB70BF7BFDDEC6A9A04A0DD0A68FE1BF51C14648CF506A03E98 + +Len = 2001 +Msg = BCB3D6F4A9BDBEB6222F317E94CAED0A102FC75E32C4127A8DBCE180166D4B034E6DF22C2B4A77636D6ACBB5CD1EDDBB280A97CED0E4C396723C9703DEE371BF2687F8CBE1D3A007B2C475EAFB030601F9034506412F0674230A6A6EB9DBDD08AD8D545C19FB0DA52506A488A789E5FC6B92799E5A8DB3D57D8985398F7E9C12A060CFA0DCD8A1E34E0A635055B616FA91C1985797E0FCA6566E03791D29D684691A39DD0181B1D584AD1C51004300FFC5DBD63D9494B2E0368776EB54624FA8BD1E8BB5145C76ECDF0D1183D67E7C7A0AF6621DC3E81637C86E160AC677851F294FE6730CE34AB488C447F665A9F59D356D7273A2675494A75380 +MD = 95E5E3F6299A0335C0BDEB3796BF7F51AED259922B55F4DFCE61F05AE3A35BE2 + +Len = 2002 +Msg = EEA3D4F70866CBB97B2FEB1F13E05791E52A8EDFC58B2339A97ED00070EE50F9EC377D8BCC8DF98DE2B99BB53345C13CAE6D6EB6E9CE0EEDFB59C0AA64DF00FF6B8AF3AF56CFEEB0DAD9AFA44564B11C3DD295618B07BCB13C6592B785B2E5B4698BC0EC8C6D57D602FE8FDCEFA619629CB52BB1079000FC478C92C24FC94E76B29D84BE2D489A79F16E42EAEE1D9842E9CC260BBEE9AE9A42A1170662E2617F72CC4B72A38B32642F7C47555532779FFB5B86FEB63E06F4C42E0849110ECE84D37B18A65C7156E23BFDB32B9756069DFCCABA8E3BC47E6F0FE8BBC7C2D9A4D2E071A595EEABF3E4CB6F637CAB25704E8D21379AFEB0BCC6483FC0 +MD = 4FADF9EC19C017BB740024376DE73FCF0F491593CC19731D2CF8C9A9669AA4E6 + +Len = 2003 +Msg = 07BD6D792691D1134F9DC46A34F930F1E073455F53A5EC48AA0113713A41238160C8E421097EF56EE05D0651DD91E6B77D3B7685A44BC480A1D0743305859EA10A24C4315DE8262842D79711A6B7B06D97E2D494229BD291E038A80A07DAFDE7E051411DF08E3BB812FC12F1AEBFDFDD0843B3075FC9431C4CFCA0A527BF7D4CF474783AB3675D4832B2DBB0E6255BA65D649FA0C52DACEDDA27E66FDB7E796DC6EC86EB06ED70F547634E82933A478427ABBDB73FE02BECE63D942C204F4F7067C990F6EBA66E3B80C4411FCE9333C3BD5783D222C1809742FE30DDA06C08CACF82D67ABBC903300D8B26A3F073C00AFA8D5DB5488FAE653E87C0 +MD = 1F399885F52DBDCA9862A517B809125079372CD0EDD61C262824C7F77ABD59B5 + +Len = 2004 +Msg = C87A40A7F50BD9E5D0470D3888727F55F650491B815BEFB245944C2023F5DCBFC061894E69225379C450999472FC415C8406A5CEBA2E1197FC3D611530A994F9EC73F7356E02439F343DEB16DD09599500D362C7BFF01C76002B437A7E86B45187FD8FBDAC88F8886995767B9EDA6ACA959E7B82C7193FF7E6644F36BD861C17E490CB14F0F7F9319DC502AEB8F30AEE58143E1536ADE6C3C6479C64617A3C04C13BD16DBE91AA3AB8768154B6A6E27D8C9B14A5A4562CB3D1B70E124ED38D09A1593EF6C1E10400ADE66FA267D604C16F990DE32F3CD34A85421F19189DBECF7C02BCE65BC094B554732C721CDC73AA39C3C4A887785D42C6C730 +MD = 53628429AD2D2CE447EDDDEE546392059CA29E5A1B4522B9C76966A27DE4E6CE + +Len = 2005 +Msg = 59897517159787EC93369C74AB7AE836A65F1F76421B8134EA32ABFDD66BCE4240723A8BAAF264CFFC4AF19F114780D4C11A8B978A6060D42239F3702CB8D69E03C0355239A7CCAB99F5F2E5B9B7C70A0CCCE87C215A27943430690D3F4971B696CA2FD552D362FA4C9B4923836BD2DFE678C0EFEB56C8E87223B609EED0768E75E3226735C3BCBCB399889286973DC2190EEDBC5AE2FD698E921395E7FFCA61DB46BE5187CD8F380E76DAF5625931162F4972517A6DCD875AAA46D2FB1C8EE156340156666D092FEC19C3891A4F3E375A9859C4E48ECC224E2B010173D59744FBEB0062E6F07994C725FF32F4525348238D9E3016A0D79A6F2278 +MD = 625A4A3520A8C5B5E66258875CFAA96B793025719C1FBA34B85F7D6C9EE39F7D + +Len = 2006 +Msg = 43898A8F7A09FE62ED0229A3102CC1436A2D662224278D3053A94B122045EBF2C164EC70B79389F72D81629F47133C98A2CC0AF6C935E640B39F1C197FA824DAD41FCC51362AD27AE80FDD0075988742A53058AB8DE4AF7EE577F35B9506EBA415F16B4533CDFE5A952218A6D76DDD16A4DEC24C7D9332A41B6372053D1419C37579BDA0C358EB984C1490E7146372FD336216D0A0CE9F282D6D9919406B4C97113ED412DEAB3737C3DE9C6F6BA813C1D7253047DEF24637528B6447126F0B2470DCAC0D693C72816BBF0F74762183030F7F5C9B5D11D6C90E7BB8F50499982709FEBF58E291B672D523089A02D112F7BAED00DDA8B4138BFE207C +MD = 033925886C2F22B5A38B9C31E2820B778BD991D82BE7D44DAF24CBA4FA315574 + +Len = 2007 +Msg = B0077DA24064BAE6404B2041DD10F3619079446B7BAFD1B3901CE4DF21FA9BC02145AC75F8DC975C74C4BBFB110DC171736C6EAA9EBEBC17757DC4AF3FC4B5B4CA1D6004D79B95E2DA6099903B3E08B74EDBDC745185E67C7878EE47025D11B446B533BF710429606B0F64332EE985E100FC4B5A0189F1632CB498168AA59FF99149E857B579AA617C0D4C90A642C25D0F314C3AEC6C52A7BFD25AE09541DAB3CF3B1B547A20EDC13D39ABB120E52FC19C2C969D171CB2805FDC2C2192B52494B37B97A35BFD17AD015BA5830DEF975E1BF7C910B45729F7BA97A3E94D4517622A9397432C79B297876562208A0F8BE1971B32DF82470E29541AD8 +MD = 6A4408393F760368C89AD56F9E4ACF0CDB008A80A320B3AFF04438FD28F274B0 + +Len = 2008 +Msg = 83AF34279CCB5430FEBEC07A81950D30F4B66F484826AFEE7456F0071A51E1BBC55570B5CC7EC6F9309C17BF5BEFDD7C6BA6E968CF218A2B34BD5CF927AB846E38A40BBD81759E9E33381016A755F699DF35D660007B5EADF292FEEFB735207EBF70B5BD17834F7BFA0E16CB219AD4AF524AB1EA37334AA66435E5D397FC0A065C411EBBCE32C240B90476D307CE802EC82C1C49BC1BEC48C0675EC2A6C6F3ED3E5B741D13437095707C565E10D8A20B8C20468FF9514FCF31B4249CD82DCEE58C0A2AF538B291A87E3390D737191A07484A5D3F3FB8C8F15CE056E5E5F8FEBE5E1FB59D6740980AA06CA8A0C20F5712B4CDE5D032E92AB89F0AE1 +MD = 1AFC9BA63EEA27603B3A7A5562E12B31E8FE9A96812B531E9D048385FB76D44F + +Len = 2009 +Msg = F38261A1E0C715F8BE26B6F39B82CED03A42B1920AE44F32AC447C5A224B7CF3AD428C1395678EDA9BAFB746EBC7035124B2BC38EB18CF23DA956493035DCC4BE8431AFA158AFC1B8BACC8F4C609F903C63B4B34FCF935AC9EB787ED4CBEFD465C220B18EBD03E634044DF8C76E51FAA484C050E5B1D6DE2A87C17D6C59FA10AA10D1A3D3F55937FF92804C7F99ACFF2549D9938BC255600ADB7CEB7D4F461B1B337A0CD2DB31AF31EB32718C623E51E2773E3143C433613E6B8971675B5F6FBD886EB52112976D3D3CF3551A522F264E08CD23A54D560FDBADE04ACA0B0B51025AFBFB6C387698E3D03558E978C1976E50EE472A114E277255FBD80 +MD = 60ED0DA10A63F3ADF686EE8FEEDECBB464F9EBC77DFE21C40446D0B7AABCE0D9 + +Len = 2010 +Msg = 0400F2747226C0098A84CD5B655AFF6374D3FCAED87289D590116712BBBE96F8ADE6B5BB9C58A3010CCD8AB0142C2750544B2AA7ED2AD5FF341D46D060C0095C3D1252ED17FE0560E7942DD9520861B3CDD5828B13886F88811F92281CD0D90EAEEE5664898A82178A86803F4B357F4497F5B433F13A69380F748E5C4FF58DCDB311869F74EAA70803CDE14FAC26A6F58C2B4C5ED5FF72F81930CFFBA834DD1696A78015A6A1300F5D1F0E557A07D19972FD133092CA07902E66D1B41369A986757875E33E0797A2724C38BE538EE4E43A49D711F816FA450A5D46286FB90A5D5F38CE0CFC8CBEEDF4FB164830E3FCBE059792E4A819FB9F3A903A40 +MD = 6E867E3C61830EBD6B39199117202B71A3D58B5E25A3C1291935818FA0966B72 + +Len = 2011 +Msg = 7978F60D35A8F4D678A3C3D9C9D4B348C151CC3665D67F3B391FF621CD2DAD46CADBADBFBE0B254F3F37194F20BDB05C1765F8B3B69C2EBEE5462918C2B92E22C2FC1959197805547E55B4527DFFBACFF0C7F2E91E05DBE570698350FC3BBA4A3685498F4D16E70FA79B427A1286C84BEBC91D19AF251CB553072929F0268282F052093306BCBCCFEB866AD419EB084198277A6F876DA551985499A6098155FED43EE6CB6EC6236D3D01778DD3822BBBA0A1D3A1870F9683B6FA81E1B78F8BB37E3EC126B34929012B99490E124DF37E1FC9D809C8A337358F9B03DB7B9ACCA3F5BD9DEEC8987E166D0F33CCE7E061A33852F5636B807F948273D3A0 +MD = BA8CE8BD5C8AE9911B908F327F6760996098FC2ECD6FEDDB4D31082C6AE33813 + +Len = 2012 +Msg = 521C82A5144B864024C414840BED6D9D038118F25D02D1A8B564B7C669C46A080466BA2FDA823652966A44620C6FDB666416892D427B76574A7BF2A33A22500E27AA6C00A655A0483C849681DE3B1DECBBE0FF7A17EF4092A4C9C64422A2E6810C0AAFD133DEEF9D1B8326B898E5641FFA338AB6A32698179F36B16C67707E1846E52105BF246FFBEB0341C92C4BE4E62B772AAAA84A91481C8E5C13B43330B66A27D9DEBD891989952EB41330B9AFC3C3A48DD35E8A62DC9777D5D3A83C478BF92A347C9DFDA5FF3295F093142BBA5DE4CEF213AA74FAE5AA2068BCE9AB181967944E379B959FE2AE8F5C22A21A5516F74EEC7B296D41C946864CC0 +MD = EDB74EAD69DCD94151B14786CE277D26A48CECF856A532AE100F0B24A58758CA + +Len = 2013 +Msg = D431DB95235C0763527A87EF5A698EA7DDC832FA8377FA56A661499E5464B9C6638A1896F826FA102B8CE891A1BCFB3540F1C9F26BAED42603BA3EBA6F24E493E629588FC08C6F5599123C2931465CD90081EA2BAA35EA39293CA49FF2B83B4BBAFA7B1677A7968C97D8325DD9A41113D9CABD2FFDF3D5709AB4C84F6AADA004F3768071C1184BD34629760E40BB17EBABE7A347DCAB9CEF57B44B2D010CC7FD13411E86157D0D839CCFAD0C4B5C17E33BD5D879584B77682C56E86AACCA13F348F5BBD296161B20B4C53D537A82CDCD212031AA2E91F27FF8B8E0641A6D6FF984ABF8020F58C83FCA4C06DF580ECA80480C105007E1BD1B404F4020 +MD = AEC6AB9C6D989A5EC700546E442801FEBF111E1FF798C38743A22C80A5C4E487 + +Len = 2014 +Msg = 17065477F68B70B0EC8D04713DDACA9B0009FA8065AEEF1490D6156CEFE776FEC243003D10DB512A4EBCCBD840B0E0F210B5DE02288DB6E14F96A46D3135629A30D932E5D8B3A6A657B3FD1A66FBD8A121CA0B531ABEE644C425C9F858998A17E22F8A9F0323A6113A1F0BBB25A9DD8F4710354E6D4D1101FC903155977F27C8F4F23B358049FE6E289BF713ABD332F1712F6D15A3A8485D0583FA6C046D154D4ED7CEC383F568350D64B28985863978390DFA8F176A9D7A915CAA34DBD70EDA3D773E4BB8CA2935664F7E87276AFB0621F180A40BBDE010A8CEAFBB5BF17FA564A21E568902B77679A3120595A89EB768537C90C524440CAC31B304 +MD = B0935DB2234F644632DD62B5E71B11257FEC09619B2608B0EFE2901E61F0412E + +Len = 2015 +Msg = 43F40589C133BD422DD57CA9EBF10AB028B7E9F0438C38569420688D0204B6BF99214D7929588122BCAA39CC3C6DB84598DE32A3868DB1BCC04EED36812E73333084FAA1CF535084F99BFCFBB0FE2DFDDF5F04CCF348DC1C7000210807DE593ECB24530E289808DA43BDD752484E32455014537347EECDF17CA6BF67084199DDE1A5E445C824BF65BD965423EF21EBDC9B6FC932B78F0BD68D54DFC5351816E0F6E7380F46086AE66D5475F022385B6802EEC5F2330F76D2FB17B7861372F9D0370D42C947D268882AB68FCAF473C543470F881EE4458048D782DC42A98FC810E56F1EBBD8DE11E9B230F753FF20DFF76C9593C5CA56684C43194C78 +MD = E7FFD1444FB142E88F54309A2FA26AD1E919F0C82E1BCB6F3B0622CFD051F56C + +Len = 2016 +Msg = A7ED84749CCC56BB1DFBA57119D279D412B8A986886D810F067AF349E8749E9EA746A60B03742636C464FC1EE233ACC52C1983914692B64309EDFDF29F1AB912EC3E8DA074D3F1D231511F5756F0B6EEAD3E89A6A88FE330A10FACE267BFFBFC3E3090C7FD9A850561F363AD75EA881E7244F80FF55802D5EF7A1A4E7B89FCFA80F16DF54D1B056EE637E6964B9E0FFD15B6196BDD7DB270C56B47251485348E49813B4EB9ED122A01B3EA45AD5E1A929DF61D5C0F3E77E1FDC356B63883A60E9CBB9FC3E00C2F32DBD469659883F690C6772E335F617BC33F161D6F6984252EE12E62B6000AC5231E0C9BC65BE223D8DFD94C5004A101AF9FD6C0FB +MD = 9B5E15531385F0D495FDBE686E3E02ECA42B9F1B1CE8837AD3B3E42E6198050A + +Len = 2017 +Msg = 7935E30C177572EA9DDB189E2EE00B99239E31E88A1D04D48D80A9FCF7FFFD2C006C09E9C377D6AD161A3F86909C9EEFAC16625271A12906E58105A69A8BDB8774FD5238DB266F41F0F0E6AABD635C489E937A63A5F297BB043A38D4DAD91D1CC94E516818F5D61FC46BBC529F3E3260702BF9364D6A23D39C1FB3DBB2CF21C19E4B42BE38BE5CDAD468C62EDEACD91D8811A773A0432D804E630C8403F181CA1AA8FAE62BC76F7EDC4C6F9B55CEAFAF4E8152D38C4D49CF73012DD0B51CA3BD8818729EA595E460D202BF25197F2D088F39959C8E6B07F2346B1CC149BE41206AD5D027A0A264C61074F7DCBFEDB9E82A9280D80207D105CE51233F80 +MD = DF9AF1D24F2D56F46C50691AD073C601652A45EDDD0A73787313E57D6B1B6231 + +Len = 2018 +Msg = FA6E5C7AB3D80FCB11F68B4575BD8C6D4FC9F754CE29AAEAF56AAB37AAA967A1023A228AAB4C67580B607A50662632A5A0E9259C8DAFA3EBDF14E8810CB9EFA5AF12611804BA687B0BF0F0CF1FC881657688D6A25E0B5DB7F6218BD9CE61A6982FAF06B5CF6F6C9DC85E8D74F0CEFBC4AFBF881F08491B885095BD3BF17BE844BD80E3A6510FE272C312837758F80CDACF3921EE01930929ED0B60CD2CA97276EAA2264C288106482CA521BEA53FA4B62CE26A7DF0BDAEB23C57C638E99255C727962BCB9FCB49F4661DFFE50B3B86CFA4C697E461DA1B1A790A4F7858FF59192A90965DE79A00BAC7362C4E3B09AA019959B3D96C44EFB22E4371DD00 +MD = C95DB972D0ED8E43883B38075117289B3786C8EE52E8528D5A1A695E09765718 + +Len = 2019 +Msg = 230BF4BDE34E022702183439EB2A7B99C763C09F738E92DAD945C2AEDEB9624AFFAEE3C2858AF2DA90E301A4E3B59E27C6926C5CD04C390018148373F65A3A9BF72E80EC38DA22B1CEA155541ACBD64CE01D62605C88C43D51459BFF591F7445EC651A2CE678446F921C9D45FA7B1AA2AA16A83E256F61AB8ACCB99C4369A0A6545211B4C3385CE3DDC0C9F5CA5D2B9A6F929FBA7CC3EAF0D6CC7F018EAD2013E99F7B482D58E148DE1A0086E7766B50FBE266D31CB77129194B4BC2C5865CE18A0779911725EC751EE5B809F5B401B4753E4FE841E18551E5E16F35C77470C61CC692C45F8C4476FF99C194C820A2C7F3A2C657C2BE97573878C38C20 +MD = E2DC5EA2C7A1FBD01C20926BF168D1EFBBAFED3213C210A46BFED9BBF49E8F45 + +Len = 2020 +Msg = 0367DD6457986EC8B94A722727C79DEF1EB26ED506310A88CFE4065B9BCDA02B95BCB8F5D4AA2AF1A0011290F302970D54BB0091B48FF90118AF051E65C00839EAB6FF8462EBA232C0E406A4573702DB72FE8D58B0C15AAFC079CCB5D5D0A702871EF3DDC46769D3EDFF0CE8E9AE9A0A15FC9F36153C9E5461748899308CCE2B5E8C97BB9F16C8505A34DEE5DD7DF47AECE9ACF4F13B2845DE7E48BC4326471ABC9F86D73FAD9C5E42C9AF89D0DF00971F39306C91F0B97102AE44749CE2111938C4E0BFAB15B68DD34DF8E54B52D8928E1804313C363E46A7DB7ED412C6FA918C1F7985320C412D457D3CAC140650999775CC2C9D9D2E918FA1B0BE00 +MD = 9E7AE9783E9E5EAA35A368F90C89359537DDF5B36B6314627A54CBF2C97B1D30 + +Len = 2021 +Msg = E8C1EC93AA28C61DAE66F7C29F9271464F045FA279D6601BBC838EFF3A5B53EA2299C128C00FB997FC9BD1E579951A0B2B4BDDD0D03BCD04B71651B7C74C8BF3C6194663CE07F68C37F13CF53E8E5CAD3C491EE25539BBF494C43017BBFA6645E49544DBE203E803FCC809E2C93A0EB191BBD3780BCF5E70491C1C5A18E659FE79E94FA2EDA8EFAA739625955B9EA7636EAB2E746AB571C7C9B40EA9D899506989525E54633D5186DA4F93AE6C7FF238A852BC2786F7EBA8C36968F26546191B983CD24FC3EABAA757DA7462E1C2253BECD08D4B3ADA75850F32C835D9DA083072BE453EFB5E514255BA72EC47AC344B944EC384428CE785FB30613BE0 +MD = 66B17AEA4FA260DCF03213E3F8F5E4AA554A80F83DDBBBB69F5ABDAC8825A69E + +Len = 2022 +Msg = 7AD52ECA2EC84E56B93ED49761733D65A8143382CF7D9995AEF6F3C8F72D24F52B2342743B08687CF416A16F00BA58CE218745A63DE2E07E671232109A14E3F5F085E60C967836C5F12DE97246A1762620DB570C52E3CEA7FE47EE53FF454DB3F610E72E35EE59E38D77519DA8D0533BC30C5B5B6380541238063BDCA3618C5FD8D2A140943DF297FC83611671FFE2C48E8BAA204C15A1A3F78B4FC9C66B4C259FDE8445D7F9160CEE1CEBD7810B543BDC152A887D53D0AF866E3535827C61282F34E968FD350608A38E5399B1F8B171097BC059E7685D01BBA86A1EF4FB748A2CB0D24193389EEF52942243D09903397480F5051B3D28C2FD6E066620 +MD = 73DC612CB3472D166468F452A8A45261AA785197860D738DFC944FF784EB8272 + +Len = 2023 +Msg = 895AA7BAED3164D54B1E76CA9891E3876B045A3588FFCD0AEC989A9A96CCAB03EF6056B252C698B59E6BB552F17C8996388A80FEB020BC253501EB8FD6C034A61D9251DFC06DC852B3A99161F65200D52B3E26531EA5FE1AE297BEC2653CEE2BC8A2293AD619DA5D853F561695AB52DC1411A88738B1E9608D7B7D86EDA2BCA385816BA58A72D07C93D2F31F2A24343E5A5D64FE6912F0E99AF0ADE0C5E83C57E50D671B4D9CB8111B9B5AAADC821783FA8D69ABF292E07106D85504CD7D11272F27FD51C216910A7DB2CE38372A58E3D688CEC8B76414368C929B50AC2BB068B2203C67035D1B52D69E52A6A5E4805F88F8F9072AFF5F6F98EDFD71F6 +MD = C609E90785686ED9C672489246278A6709D0F0961E4E20A3D54956CEE6743DA7 + +Len = 2024 +Msg = A6FE30DCFCDA1A329E82AB50E32B5F50EB25C873C5D2305860A835AECEE6264AA36A47429922C4B8B3AFD00DA16035830EDB897831C4E7B00F2C23FC0B15FDC30D85FB70C30C431C638E1A25B51CAF1D7E8B050B7F89BFB30F59F0F20FECFF3D639ABC4255B3868FC45DD81E47EB12AB40F2AAC735DF5D1DC1AD997CEFC4D836B854CEE9AC02900036F3867FE0D84AFFF37BDE3308C2206C62C4743375094108877C73B87B2546FE05EA137BEDFC06A2796274099A0D554DA8F7D7223A48CBF31B7DECAA1EBC8B145763E3673168C1B1B715C1CD99ECD3DDB238B06049885ECAD9347C2436DFF32C771F34A38587A44A82C5D3D137A03CAA27E66C8FF6 +MD = 216FC325F942EED08401527A8F41C088527C6479342622C907EA08FF3290F8C6 + +Len = 2025 +Msg = 51F8BDCACDA5A57DD68942F72CAD34BE06CCB06F9603359C80D7E5E39D2254FF3593226D0E068CCD06E54F0490CA6267CE2CB73CAC45552173BB980FE06C6DB076B97405088D6203492B73E40532C4A259B760504216A46BCF04B8251FDE04D8AA82354303C103163D166E2F79E9204FBD1F09B8ED474DE23BEA752F9D58C9B39A955B7B8B4BC610BB554B5B6D5220F0DF58FA3308D5BDAB635F8AEF9532309AE48EC70133788B93A14F155D3AC0EF7597E84E9881E49E9BF709F0AADB79E8CA5987B15FFBDC0F10B70E4034554952315E156B01A0AAAB6AE3584FE3F522FA5DF8F909A4C2F27AE26CA35C04198D77D1271E2CE12B92566F243037204380 +MD = 70FBCC7BF6DD9BF9B3D9F6617DC3E6AB26B7FF5ECDAF5438C205C3FDE3E19A0C + +Len = 2026 +Msg = 21E921EA42279D39789AE6DE121C4EE530FF4488638F8AC66C9C2AF97CFE8AB41BFBF2BF217946396743E1B6377BB29440CB73AB40921AA6D209134D9D583434751A8CACBAE380E8F222A07BA5B5DF1E1629C68550E1F3B9546BB816296DB08A8D8F1BA97FF3D8DCFEA8346ACC1AF1EFED1041BF60C65E3F99DA9E534ED13DC91937123B2F9C95C476102C16E436CE1F8505AD7E6986CD92BF59624C2D4140C3DFF9E824BEA580651B8B189EE21497E1B1835ACE948ED9E0C99CCCED5798F618B9680BD5E2ED3C37353B87C1DFD7219C2DCFF2FC6D08C4692450B6CF88B38936B8E79FCBD40949421B878371CD6E070C01B3C45AFA40D7558971362D7C80 +MD = AEE72923A76B411BF3B1978159E58AE19A3784AB9AA11C9BFCD235597B98838B + +Len = 2027 +Msg = 136B91AE480FEDE05560946E2498ECF3DD14A3A690621367BC96FAA7A7FD17E9877CC7680586DBA63210A50761005BE42BE609F0FDFDFC57E2E9CD7CB313A74A685B4381461BC636A158830FA668058F428B62A914A9ED8B8CB26A82062F91CC9119D303CD95A6B288AB9B5DE4829D340EF99CEFB84842840D60680B870E82513788E744FC1C779DBC6481E82B335203D20E6420273235B105072DFAC5B0BF5B40D4C5F42D7B74FE753924C80E68E049DFB5721037C4F23279C84B50697226D31F1B827BB33E0CF53E398AE128B20BF9BB77F8E379833B8813B8BD1897610A568033BCC1CC953F9D9CD20674D85260BBCBCEDDCD5295DCFB633C12F4E2C0 +MD = 8362D1B9ABCB02E46BBA72CF33C987D46DD69103B2D8E4073EB84BAFA361A334 + +Len = 2028 +Msg = 66507B499F6D8A15A968D9EF30289B4CFAB08ECBAEED472D58140D3C0726746155FA07D73B0374B8D1DADD60432252A4B4F891EC83122BACC96F6A7488B0702A05648488BD0B31950B21D1EFFE567A7A2F7E2D12499DD2D64ED98242B235D9452C35D6CE72D0AE4A57019966AA4C0802A68D20C001A58B0344DBF0D216497CD9414F5079058AA667E30E7D00278CC872542CBF5E81FDBABD321FB0CF877C3972A7EAE36ECC95801E879AB410C75FDF82FF8121214873ECBC4D1F20CC3E9EE2BCACE7659747BD65C37E6E3F209519C7CD189F023C89EF09D7F232243463169C92001818670FAD9059377ABC957C97B94ED20D2E71DB202C0C1036F0BB9510 +MD = 66907C8E6FB8C95FE234D4759E227CB3794B79240A0EB5AA6C241D9A96B9C43E + +Len = 2029 +Msg = 9FE62860A9C15D81A218CEFC0C50914B49F04A8A86CBD9DE7132CBD76EA878140267C917EA83BB930BE41268C01D63303682BAFE04F576DBC7C167953F9B90B9938CBE27F83BCD800F0F4602AA88BBA68FE3D8E31A3A8BBA76CC9CD30235B719E5838307CFC7B635517BDAA796E792B72DF8ECDC5A26B6D2949CC443800D12D705354D1CCDFE88E526AAC41C71B7E9A710659550DC7338FB97E774CFF9C44BAD6A31B5783745D503FDBEA6B34CF611022D20CD1B5BAA64E60D111E40989D0F50683BFC5F1CCA929667157977FF1101817DAC901C7E9FC3032ED7FF4DA36A9DC90F8B9C1D81B20B5D972A662975F4DEB7E2199A3FA2E300703FE38BDAAF38 +MD = 80D6BA360BC1F182EA1C2C86EE68D0F503BF33FF779FC926FEA6978FF71BCAE7 + +Len = 2030 +Msg = A91E640739831082E52FFBE1DA2BEE69E8DCCB8AC4175EF07EEE805087A53F164CCEE639EF5C510ABE9B204AD46376878301FA785B89B1AB924CB069E8F535933F61E469A2DB92F4BAD7BC6E9F550FF38ABD06CDCB421B4B60E64E00D3371DAD1F2B52DF5D0609BD653088AA201939A3324411B59070F7A4016439C97E27E0A7FFC463C8EB1896CCEFF358E1E3C9EB383CD6B8D8F27585280DA8C70E3D5809D08FFD605CDE24940AF1999802ADA4E8AA2CE9DFB8FDCFB877F4EFE1C6945A314BEAB88ADE3DC3F835A4C76ED46008A6D0688C83307E740AEA16D12B7BC56183CFF9B4374C12C53D4F364B0D688601624141B225988D75EE3647EB4EA22D74 +MD = 586A6F5E0BA0FB98D60D09706EBAA19AB3DAE82DE7528BCD3301E2142602C0C8 + +Len = 2031 +Msg = E5B97559FB95D8E558BA351B7F715DFBD2835417B500231EEF8C9AC1EA163A4EB890E6054F0B9CD4F843D249846A0E6BC3A1B0C88B0DBDA86A28F8E6EB30508D78E70917A17BAF35F98FF98B3BA3402DBA0A3111C1F0B62B931F5CCC5B179C9CC1F66CF687721A3551098F5B3DD7CD642F245398E2B36981405771E614422DDFCAC667449C39399DA06D2012B038C1AF106DB458BD4C3D67EC01B44FC473E1E98048816F70F17AA5FC347E0FC494C302334091D323F40A8C1894F610729EB7845DB749E40C7AC0BB37570F42434E64905BA3928AB359AF4F6BD2AAFE2A74DF01A4C8176840D7B069AD0AFFC8C403EF4C82BCE137E491F421149C172B2228 +MD = 7829A879ACC9BC60B5AD9C75213F1C6507AF73E7A67467F249130F02B4BF4B54 + +Len = 2032 +Msg = 83167FF53704C3AA19E9FB3303539759C46DD4091A52DDAE9AD86408B69335989E61414BC20AB4D01220E35241EFF5C9522B079FBA597674C8D716FE441E566110B6211531CECCF8FD06BC8E511D00785E57788ED9A1C5C73524F01830D2E1148C92D0EDC97113E3B7B5CD3049627ABDB8B39DD4D6890E0EE91993F92B03354A88F52251C546E64434D9C3D74544F23FB93E5A2D2F1FB15545B4E1367C97335B0291944C8B730AD3D4789273FA44FB98D78A36C3C3764ABEEAC7C569C1E43A352E5B770C3504F87090DEE075A1C4C85C0C39CF421BDCC615F9EFF6CB4FE6468004AECE5F30E1ECC6DB22AD9939BB2B0CCC96521DFBF4AE008B5B46BC006E +MD = 43184B9F2DB5B6DA5160BC255DBE19A0C94533B884809815B7B326D868589EDC + +Len = 2033 +Msg = 183E87351ABE6CDE83B3160C5E174B7F543F6D1C2AE1507171E532607490E527194E030E25D543C7856BCC3AAED1A0F6BD5EBAE7D569DB10FDC684DF99DF107A78BEC6B0682FF647DEB9429A8FCCF2C13EE69EC8E3A4BD85DFE2BC2F0D8FE4CAF2EAD4BF96890A21DB95609CE8626328DBA475F3D09F22126CF83646FEC3059DC735C12A6D0C0E2AF306C26C99EDA34FA3F5885606725718E2216352999A7F9C5F19219249311375E0EDE0707096B48F32F01FBF3A53FF8D4F5D7D950EB49A7FC1D2A1E8D4839630D854CBA801F9A354558B9866F7EB2F12ABA56F8CC3D60A5D151B0DBEFFAEBB6305C3716A0F939F9D3BF7971DE2AE9E49750BBD7C8AD300 +MD = FDF852714B9E7D7436E4F23A0751BE746A8E79556C8DABFB05FC473A02BAF1A3 + +Len = 2034 +Msg = F8FF3B3787516E0A7579734B74EF878E7C64C19103AE67A47B9BB72D884D1A233DB5FDEAC236D23C94CC5E0A50F80FA0354EBF950A25D22A5D077F0017D0250F5B0B43A6B6958A74D0EC2179441229F698023DF319C408ECFA062B70D5FAB0545E955BA6F77C3B848DD041A4C40877FAB1AA89CDE0699E7C98575C104D713E7265405109B56A034A91A9BABACCE8BF2B493E84AD20C0055EF281642F7FF49D5775C05AB80415102B94FE90CF920DCBEAED91DC4B0BEB57708DBBAE82329EDF2FC0980F47266893DCADA678B374B34BBF75E8716464A3BDAE28A6281501B503A17E4A6E87AD35BF0BEEF0C81EAF744C4BF02485C4438B41097AF72D070E9AC0 +MD = A11DE7B745AF73D6A06AC2E6AEC098C6BD4286CB8B01E1C78407334863289A62 + +Len = 2035 +Msg = 7EA3A713810E1A3CE414301D5B3E5698844F8DEC10729045C5299F07AC74C8A926BA6241CC4FAD0826B073A36CB9AABD7EE4763CFF17173957791F3FF615C897264D9A88A509F932D332BA3B95E5F3B4469AFA7183A67BA46F7B6D43B99A5F5B92823B9CF22F3657CBCFAA8A5FD0EFECC507702AB1B0D1DEDBEAAE326B49AB080188206024CE0F1324A5C9D10AC07ACDB9F60F008A345DA3A8DDA50CF90E364DBCD0845B031D0AB44BE1DE22E7F13F7C092B945055EBF8B17DD8E06D4F4D8D2883918B309376E07D6849927CFC0F99F32AF039C866E723D3A951A374AFD532B50EAE3BE6FD3634B95D184574CF0F5399352FE164D3BCAC75C3E07E800D59A0 +MD = C8345B39D12EEA0351D767BEC36177911792E1B83FA3C2D32EA26988CAA8115C + +Len = 2036 +Msg = 5F878802DA83E8C9822A0262D2C29E1520E3B8B21D01928610B2DD3940379A70B635E1028D236AF0A4F3E7D19F64BA5A286B61DEF259A8B2587B3673BA13533C8067427CA0252C39BFD6A41D70269BE40D35BA7B9B9AC38CE4B980168BCADA5149AA8B49363FC93FD12AD4FF4D89EE8FA87FFABCEFF8508E949EBE8AFDCE5FCBB55960C6BBD912D80481736A0B485F1911068D242596C223C5D6CDF4DFECC7292D24C8925588336AE40033ECB4A61761BC2518E7C51F14E62FDB67897EE6BF398430D87B8B1427C3FFDD43B85AF3B329456E169A02D4573484478DA4747B81056D0D51D63E5B13442FC16BB228C6E87632A9EE59D48EE7DC3E20090EA6CE90 +MD = BD4F3CB5D1F8B2BC446BFC46A611726970E16766E28F253131765D30DFF0D531 + +Len = 2037 +Msg = B652BCB949215CC82A08AA428F90CAA72755D785F102D112689205ECB97F68844B120FAE0F68F87AFB41BE7AFFE3946CDE47AFDD5F1A2AC8326D1C15976C610CF261F95D49D7F13DF9619D58B585446D0F572514C046AC5DB3AA8CD2BFBA41DC9332ECCD4C9DD946FBC60EA604E9E69319ECA5A3EF3910E446D57AC1543CA4DD29F2A42ED3F12B2F21B40911258DB642365F8D5F9737E3F39D77B8BC53CED9E3A2E0C0C8328F27428764E25CFA14FAA401A42B8C5EC1586DC1B4EA108D8AEC3CCC312738D8320F41917D413D3E5214DC46A7AD5EAB4E7326279CD5CEB30FA881535621E096925D18E62C71CBABEADD9DA58321F80C8F6777FB97C516426A18 +MD = F9D8CE964CEE86AF7B9062A6A674AF243551F95D6C0C8C157779154DDCD0AA58 + +Len = 2038 +Msg = 6546D6A5C2F0D01D65BB637E5FD0E07E8320380580E1145BC90FD193D43A615625BF84014832BC89F4D7B06151A6070D29BC8BDAFC7CA713350A1A690ACE8DDD8491C0CDD5625537DA096C76BF8B0D92F43F2EE0250B49F31B3FEE950A4BE5BA0C92A9865F13F933521F84D3F6A35679EE5A1AA7723143B0479CDB749EFDBD7ED0C4C4577A57EAB953AF4D4F51BDBC25D5152ABC17431F4A54EF54C09BD4559F398DEDE349CA00EF9896B67241CDE6568C2E227D1A9B476DD6CFAA213AF4DF680A10227E40AA3287AC52A3E1FC763A5800014E0E986EB22109654E18C65493E6194E1735C631A74F9C5EB2491FEF909983ABDB45C98E673C276A431E2AC418 +MD = 55F6BF5AB090EF170BAE7D2F39D8B10F8FA714554353D51D02F17A5A04BCECEC + +Len = 2039 +Msg = 032E441D08C89545C5961987E89BE2560F04BC3F020F798A83F403AE49A45F16B2D4BAAF899FAB28E85680A5B0354009827ADB04810FFA3E102CD50F3CBB5F13B38162EBBDD866F9AEC7CA8BCF702BD2026497B9F4AFF49507461C9658C6326815FE96922FB96977A79C3A0E81B7854312B8B5147F3B5D028C666F99D57899A68D63DD6C8261A0894636EFDF628338C4AB39B83F9AB66FF748C4FC41458BA8926ADF757A74F59603F61C5EA8C2F1C1B5D9A015F37E4443B50F20047405050B81969C1108EB01C09CEF25F081FC9885FF5623E76F741B811D03A9E05EA2D6DF1C735027D715DB3C8074ADC2ED16082A7A2C8D948275484220E682FE0D0E9A70 +MD = EBFD162EE4B2E0AA57F1A5EF5B0D2624196DAB9071B4F77F25040E4529A80816 + +Len = 2040 +Msg = 3A3A819C48EFDE2AD914FBF00E18AB6BC4F14513AB27D0C178A188B61431E7F5623CB66B23346775D386B50E982C493ADBBFC54B9A3CD383382336A1A0B2150A15358F336D03AE18F666C7573D55C4FD181C29E6CCFDE63EA35F0ADF5885CFC0A3D84A2B2E4DD24496DB789E663170CEF74798AA1BBCD4574EA0BBA40489D764B2F83AADC66B148B4A0CD95246C127D5871C4F11418690A5DDF01246A0C80A43C70088B6183639DCFDA4125BD113A8F49EE23ED306FAAC576C3FB0C1E256671D817FC2534A52F5B439F72E424DE376F4C565CCA82307DD9EF76DA5B7C4EB7E085172E328807C02D011FFBF33785378D79DC266F6A5BE6BB0E4A92ECEEBAEB1 +MD = 348FB774ADC970A16B1105669442625E6ADAA8257A89EFFDB5A802F161B862EA + +Len = 2041 +Msg = 7163B9175ECF3A64D3713ECC73204470A0DC1B015B4DF7ACADDBC68D14DA8C923BB6FF08BB79C1CFA8E001B85139E0A9B18131FC34832C9058D9B8415FBC3DB4C75EB9D8CC025A6F5203BD7A1FAC956C737C11692EA194D18D80F63ED5A2ACB3BC8E3E235DEC9C43819E0001FE35AB6FC3FC25046CD079B32B0FA40816F69E0C47C05C3D7AA68863E8CB4197921DCFDE83BCFE3A8F243BAC68374FAAA6CE9A01438D7AED50CA231954CE9A59EDE88A408CF8114012F619003D6E192CB7CBB7AC3A9BF1712F943453D3AF925F2F1BBF10D6EC0094A7832BF3D0A52CF727E52EB2403FCF3AD7D4CDC8A86DE388840372C250A8011F27BC1B029EC3F39FC14B9180 +MD = 74986D58217054772223ACC7AE7F55D3DC044D0005238AF8C62CA92FC31052B9 + +Len = 2042 +Msg = 3DCEC0E888A6A238E2AFB6A02F6F270FC30B93C2CD4FFF9F6E9A0153D50FBA559080A282519C7B91396147B7279937805060E529F415150FD7A9E1950DEF27FB2DC0B201C73C2A834AE0CC073961B2CFB074E40DB425B0E6628389CC622D7B963DB1F7A35823CE80D40DA1112302EB90461EADA4005EF4D5DDA5C04BC7AAF3A9DED53AC54BC17E2E27967C7B828AEAFDC192DED6AE741044347BE7888B3B6DEF63A118830ABB1F6B6D5B2D28E5F7D5803E8507D4F6D06D85D90D1E250E6389CF63D182F4587E5C5526847A0C95E2EFFC3344E32BA29E56757BC0125148FF08B83553A8CDF0F68AECB514F06941199799C491E0C55C58D240560905B56C6CF800 +MD = 11B0BA5E49BE3C5581C84A64751272F0B54C1B9170BED46DAEF08CB6C186C6A4 + +Len = 2043 +Msg = 41355A235D1F809C3C5B921CE7FB9D517ECC1E7439FB304F2D1CF919DAA5DE13154FAD2BC8FD7F3EA3B026CEF34BCFF61B5D779CD8D2C76461FA3821D6343AD05A791BC915164543C32A74C85FB225DF22A0039D6F349C6E39545CBD490359EE5152D32F263BA5B6169223F6BA9E125AF53BAFBA95FDEEF5A068B6299871CA1BB743235076471144501E03C911701476152C218EBF1A734198655498EB6F82A1FDDBE4BB845B0DD7636943CE869812F9DB13E59055A7ECA774C60105E95A59E23A9156E23FB51AA9B7AA95BE82D8B375542D320A1989A85E6F9ABADF85CFCAB576C93E71A1E1367A2789F21DE5D4BFC0660DFEC110860DAA15F23FD3A4600620 +MD = 224E1626DDBAA48AE748E267F9F2A225FE32A8A7B17B4E19E5C7FCDA5271F6E0 + +Len = 2044 +Msg = CA0B483D9E27EE4DE097CC92AF14D4A1B096E7533E85AFF050C49798A09167C63CCC9E85BEE8FDBF3681547C687D71E24B4CF618410FE9DF0B0D161AD323E14385C661EA7DCA937F62ACD0E54173FB18C22DC0048B35470D81BE6F1790B8CE63CC5495821AA34211DCE1E681F95DAC61C960EA25D74FABCF97BC3CB800BE6DFB4325A608BA2C701756B31C179B6E0724B7DE0E95E9732865034AEE72C19617BE8AC5CC266633E949C733B38F4915C94964EF5EC2F5C5BD65E1446F2621A120376B10DAC06792625799E67BE6F474D4DEE4D4E84C8EA08F03FE4C95D8967C3C28E82606FE7390449C4C0EBFC002054C8228157D04D8B4346A1667EB173CF238B0 +MD = 73025029C2ACC3E37141C8A802D7401FA35B8857F1667487CCA67E49E9F9E733 + +Len = 2045 +Msg = EC545360EE77F181B55B942CC77E84B64A74241F8E02BB940560575964C5FA131C453BCB179B6547D317180BDA99D8EA69D4216B58E8C38BCABA42E2B1E23712C6558C6A1A14996955540A4D54A97364B1ED11BAB2B20E0DCA2827FE47EAC10E7BEB694ED6F48860D419F3C370F893F57D9858193389DAF69EAB130C0BCF00D639E3ACE5240E232D733D0A1AB4A805BB8367472DFEE0873762CED8006DB3EC84153A48088581C2BFEDF78FF9DCD628B2B9DB64FFA900B62EEC1F358E4ED5EA31CA719EFBF381B6AF5B366CBF2025099E30B39BF446C8CA123AC302FFCD163946306F5420E3C2E8D50F48169402EF2E1764228D30A4F14A3EEAD1C0A106667518 +MD = 21A4F9175B2FA204D254433D6FBAAE95B440A667A3B42F7E6D2096EC63D93838 + +Len = 2046 +Msg = 36CF74E3561474F90A2B62718C8740CE553A207334A1EDC7F95B702848595EC23285F826C989CD975C4390E24C485335B616BCBEBC16EB7C24E895F1A633D5E331DA67BD2A86B088BA6874BAAC74F08F5483D0702F0E41229C14A588BEBD592F86DADB5BA72A1E7FE310728B4234AEC7361AE460DB299D54235DBC92DC20DA9A9B3DD3FD7E68DABEE80C8D1272BC1D1C98093CAC93DBF7FAD2D448E2F1A7992256ECB537DC501756F66D6D7B4409C4C74CEB9355E8587136F67FEE9736667370EC924AF34DE22F75410C1251B344653F2535A163B7FB90ECD874FB0362670E2F9182EFDF0221B0F727BC63534E9F98F4AD713D6B9486F58221442273B9D1EE50 +MD = 0C2337DF0E8BEA0033934D0608E115E261AB6E11F8C7B8FB46930EA07F103908 + +Len = 2047 +Msg = 1F42ADD25C0A80A4C82AAE3A0E302ABF9261DCA7E7884FD869D96ED4CE88AAAA25304D2D79E1FA5CC1FA2C95899229BC87431AD06DA524F2140E70BD0536E9685EE7808F598D8A9FE15D40A72AEFF431239292C5F64BDB7F620E5D160B329DEB58CF6D5C0665A3DED61AE4ADBCA94DC2B7B02CDF3992FDF79B3D93E546D5823C3A630923064ED24C3D974C4602A49DF75E49CF7BD51EDC7382214CBA850C4D3D11B40A70B1D926E3755EC79693620C242AB0F23EA206BA337A7EDC5421D63126CB6C7094F6BC1CF9943796BE2A0D9EB74FC726AA0C0D3B3D39039DEAD39A7169F8C3E2365DD349E358BF08C717D2E436D65172A76ED5E1F1E694A75C19280B2A +MD = 69F65D8D5EB315315F044E675ACDF45F6604CC998E335C50EC5A381C3D525F22 From cf88e41610c96e2b627c3c7e9e73295d1d5496c6 Mon Sep 17 00:00:00 2001 From: Euicheon Hong <78904698+gdmlcjs@users.noreply.github.com> Date: Sat, 7 Feb 2026 07:57:08 +0900 Subject: [PATCH 17/78] test: run sha2 test vectors together (#2397) Made the test guest program process all of the test vectors in a single run. Time to run tests has decreased so all the SHA2 tests are now run on a single machine, like it was before the test suite was added. --- .github/workflows/guest-lib-tests.cuda.yml | 39 ++------- .github/workflows/guest-lib-tests.yml | 15 +--- guest-libs/sha2/Cargo.toml | 2 - guest-libs/sha2/tests/lib.rs | 83 ++++++++----------- .../sha2/tests/programs/examples/sha2.rs | 29 ++++--- 5 files changed, 61 insertions(+), 107 deletions(-) diff --git a/.github/workflows/guest-lib-tests.cuda.yml b/.github/workflows/guest-lib-tests.cuda.yml index 310428a284..c602badc25 100644 --- a/.github/workflows/guest-lib-tests.cuda.yml +++ b/.github/workflows/guest-lib-tests.cuda.yml @@ -29,10 +29,7 @@ jobs: strategy: matrix: crates: # group crates on the same runner based on test time - - { names: "sha2_256", path: "sha2", filter: "sha256" } - - { names: "sha2_384", path: "sha2", filter: "sha384" } - - { names: "sha2_512", path: "sha2", filter: "sha512" } - - { names: "keccak256", path: "keccak256" } + - { names: "sha2 keccak256" } - { names: "verify-stark" } - { names: "ruint k256 p256" } - { names: "ff_derive pairing" } @@ -54,13 +51,7 @@ jobs: - "extensions/rv32-adapters/**" - ".github/workflows/guest-lib-tests.cuda.yml" - "crates/sdk/guest/fib/**" - sha2_256: - - "extensions/sha2/**" - - "guest-libs/sha2/**" - sha2_384: - - "extensions/sha2/**" - - "guest-libs/sha2/**" - sha2_512: + sha2: - "extensions/sha2/**" - "guest-libs/sha2/**" keccak256: @@ -139,15 +130,9 @@ jobs: if [[ "$COMMON_CHANGED" == "true" || "$crate_changed" == "true" ]]; then echo "::group::Running tests for $crate" - # Determine the actual directory path - CRATE_PATH="${{ matrix.crates.path }}" - if [[ -z "$CRATE_PATH" ]]; then - CRATE_PATH="$crate" - fi - # Run guest library tests - if [ -d "guest-libs/$CRATE_PATH" ]; then - TEST_DIR="guest-libs/$CRATE_PATH" + if [ -d "guest-libs/$crate" ]; then + TEST_DIR="guest-libs/$crate" if [[ "$crate" == "verify-stark" ]]; then TEST_DIR="guest-libs/$crate/circuit" fi @@ -160,24 +145,12 @@ jobs: elif [[ "$crate" == "ruint" ]]; then # only run integration tests because other tests are not OpenVM related SPECIAL_ARGS="test_matrix_power" - elif [[ "$crate" == sha2_* ]]; then - # only run proving tests - SPECIAL_ARGS="--run-ignored=ignored-only" - if [[ ${{ github.event_name }} == "push" && ${{ github.ref }} == "refs/heads/main" ]]; then - SPECIAL_ARGS="$SPECIAL_ARGS --features=long_proving_tests" - fi - elif [[ "$crate" == "keccak256" ]]; then + elif [[ "$crate" == "sha2" || "$crate" == "keccak256" ]]; then # also run proving tests SPECIAL_ARGS="--run-ignored=all" fi - # Build the command - CMD="${{ env.NEXTEST_ENV }} cargo nextest run --cargo-profile=fast ${{ env.FEATURE_ARGS }} $SPECIAL_ARGS --no-tests=pass --test-threads=1" - # Apply test filter if specified - if [[ -n "${{ matrix.crates.filter }}" ]]; then - CMD="$CMD -E 'test(/${{ matrix.crates.filter }}/)'" - fi - eval $CMD + ${{ env.NEXTEST_ENV }} cargo nextest run --cargo-profile=fast ${{ env.FEATURE_ARGS }} $SPECIAL_ARGS --no-tests=pass --test-threads=1 popd fi echo "::endgroup::" diff --git a/.github/workflows/guest-lib-tests.yml b/.github/workflows/guest-lib-tests.yml index 681f338601..25037b9ecc 100644 --- a/.github/workflows/guest-lib-tests.yml +++ b/.github/workflows/guest-lib-tests.yml @@ -29,9 +29,7 @@ jobs: strategy: matrix: crate: - - { name: "sha2_256", path: "sha2", filter: "sha256" } - - { name: "sha2_384", path: "sha2", filter: "sha384" } - - { name: "sha2_512", path: "sha2", filter: "sha512" } + - { name: "sha2", path: "sha2" } - { name: "keccak256", path: "keccak256" } - { name: "ff_derive", path: "ff_derive" } - { name: "k256", path: "k256" } @@ -77,16 +75,9 @@ jobs: run: | rustup component add rust-src --toolchain nightly-2025-08-02 FEATURE_ARGS="" - if [[ "${{ matrix.crate.name }}" == sha2_* || "${{ matrix.crate.name }}" == "keccak256" ]]; then + if [[ "${{ matrix.crate.name }}" == "sha2" || "${{ matrix.crate.name }}" == "keccak256" ]]; then FEATURE_ARGS="--features=aot" elif [[ "${{ matrix.crate.name }}" == "pairing" ]]; then FEATURE_ARGS="--features=bn254,bls12_381,aot" fi - - # Build the command - CMD="cargo nextest run --cargo-profile=fast $FEATURE_ARGS --no-tests=pass --test-threads=1" - # Apply test filter if specified - if [[ -n "${{ matrix.crate.filter }}" ]]; then - CMD="$CMD -E 'test(/${{ matrix.crate.filter }}/)'" - fi - eval $CMD + cargo nextest run --cargo-profile=fast $FEATURE_ARGS --no-tests=pass --test-threads=1 diff --git a/guest-libs/sha2/Cargo.toml b/guest-libs/sha2/Cargo.toml index ffd68f551d..7dd779c840 100644 --- a/guest-libs/sha2/Cargo.toml +++ b/guest-libs/sha2/Cargo.toml @@ -32,5 +32,3 @@ default = [] aot = ["openvm-sdk/aot"] # Internal feature for testing only. cuda = ["openvm-sha2-circuit/cuda"] -# Enables rust integration tests that take a long time. -long_proving_tests = [] diff --git a/guest-libs/sha2/tests/lib.rs b/guest-libs/sha2/tests/lib.rs index 3536e1bd28..aaf64382e0 100644 --- a/guest-libs/sha2/tests/lib.rs +++ b/guest-libs/sha2/tests/lib.rs @@ -79,47 +79,42 @@ mod tests { .with_extension(Sha2TranspilerExtension), )?; - for test_vector in parse_test_vectors(test_vector_file_name) { - let mut stdin = StdIn::default(); - stdin.write(&match sha2_type { - Sha2Type::Sha256 => 256u32, - Sha2Type::Sha384 => 384u32, - Sha2Type::Sha512 => 512u32, - }); + let test_vectors = parse_test_vectors(test_vector_file_name); + let mut stdin = StdIn::default(); + stdin.write(&match sha2_type { + Sha2Type::Sha256 => 256u32, + Sha2Type::Sha384 => 384u32, + Sha2Type::Sha512 => 512u32, + }); + stdin.write(&(test_vectors.len() as u32)); + for test_vector in &test_vectors { stdin.write(&test_vector.input); stdin.write(&test_vector.expected_output); + } - if prove { - air_test_with_min_segments( - Sha2Rv32Builder, - config.clone(), - openvm_exe.clone(), - stdin, - 1, - ); - } else { - let executor = VmExecutor::new(config.clone())?; - let interpreter = executor.instance(&openvm_exe)?; - #[allow(unused_variables)] - let state = interpreter.execute(stdin.clone(), None)?; - - #[cfg(feature = "aot")] - { - use openvm_circuit::{arch::VmState, system::memory::online::GuestMemory}; - let naive_interpreter = executor.interpreter_instance(&openvm_exe)?; - let naive_state = naive_interpreter.execute(stdin, None)?; - let assert_vm_state_eq = - |lhs: &VmState, - rhs: &VmState| { - assert_eq!(lhs.pc(), rhs.pc()); - for r in 0..32 { - let a = unsafe { lhs.memory.read::(1, r as u32) }; - let b = unsafe { rhs.memory.read::(1, r as u32) }; - assert_eq!(a, b); - } - }; - assert_vm_state_eq(&state, &naive_state); - } + if prove { + air_test_with_min_segments(Sha2Rv32Builder, config, openvm_exe, stdin, 1); + } else { + let executor = VmExecutor::new(config.clone())?; + let interpreter = executor.instance(&openvm_exe)?; + #[allow(unused_variables)] + let state = interpreter.execute(stdin.clone(), None)?; + + #[cfg(feature = "aot")] + { + use openvm_circuit::{arch::VmState, system::memory::online::GuestMemory}; + let naive_interpreter = executor.interpreter_instance(&openvm_exe)?; + let naive_state = naive_interpreter.execute(stdin, None)?; + let assert_vm_state_eq = + |lhs: &VmState, rhs: &VmState| { + assert_eq!(lhs.pc(), rhs.pc()); + for r in 0..32 { + let a = unsafe { lhs.memory.read::(1, r as u32) }; + let b = unsafe { rhs.memory.read::(1, r as u32) }; + assert_eq!(a, b); + } + }; + assert_vm_state_eq(&state, &naive_state); } } @@ -148,26 +143,20 @@ mod tests { #[ignore = "proving on CPU is slow"] fn test_sha256_prove() -> Result<()> { test_sha2_base("SHA256ShortMsg.rsp", Sha2Type::Sha256, true)?; - #[cfg(feature = "long_proving_tests")] - test_sha2_base("SHA256LongMsg.rsp", Sha2Type::Sha256, true)?; - Ok(()) + test_sha2_base("SHA256LongMsg.rsp", Sha2Type::Sha256, true) } #[test] #[ignore = "proving on CPU is slow"] fn test_sha384_prove() -> Result<()> { test_sha2_base("SHA384ShortMsg.rsp", Sha2Type::Sha384, true)?; - #[cfg(feature = "long_proving_tests")] - test_sha2_base("SHA384LongMsg.rsp", Sha2Type::Sha384, true)?; - Ok(()) + test_sha2_base("SHA384LongMsg.rsp", Sha2Type::Sha384, true) } #[test] #[ignore = "proving on CPU is slow"] fn test_sha512_prove() -> Result<()> { test_sha2_base("SHA512ShortMsg.rsp", Sha2Type::Sha512, true)?; - #[cfg(feature = "long_proving_tests")] - test_sha2_base("SHA512LongMsg.rsp", Sha2Type::Sha512, true)?; - Ok(()) + test_sha2_base("SHA512LongMsg.rsp", Sha2Type::Sha512, true) } } diff --git a/guest-libs/sha2/tests/programs/examples/sha2.rs b/guest-libs/sha2/tests/programs/examples/sha2.rs index de22f4d9d8..8daead0965 100644 --- a/guest-libs/sha2/tests/programs/examples/sha2.rs +++ b/guest-libs/sha2/tests/programs/examples/sha2.rs @@ -13,19 +13,22 @@ openvm::entry!(main); pub fn main() { let sha2_type: u32 = read(); - let input: Vec = read(); - let expected_output: Vec = read(); + let num_test_vectors: u32 = read(); + for _ in 0..num_test_vectors { + let input: Vec = read(); + let expected_output: Vec = read(); - let output = match sha2_type { - 256 => Sha256::digest(black_box(&input)).to_vec(), - 384 => Sha384::digest(black_box(&input)).to_vec(), - 512 => Sha512::digest(black_box(&input)).to_vec(), - _ => panic!(), - }; - if output != expected_output { - panic!( - "input: {:?}, expected_output: {:?}, output: {:?}", - input, expected_output, output - ); + let output = match sha2_type { + 256 => Sha256::digest(black_box(&input)).to_vec(), + 384 => Sha384::digest(black_box(&input)).to_vec(), + 512 => Sha512::digest(black_box(&input)).to_vec(), + _ => panic!(), + }; + if output != expected_output { + panic!( + "input: {:?}, expected_output: {:?}, output: {:?}", + input, expected_output, output + ); + } } } From f82823e881bfea2940e8e2f4f7235b61a3ea2e50 Mon Sep 17 00:00:00 2001 From: Euicheon Hong <78904698+gdmlcjs@users.noreply.github.com> Date: Sun, 8 Feb 2026 10:12:59 +0900 Subject: [PATCH 18/78] chore: feature gate dependency on external sha2 crate (#2395) The dependency on the RustCrypto sha2 crate is now gated by the "import_sha2" feature . The feature is enabled by default and when it is, the `sha2::Digest` trait is implemented for our Sha2 structs. To avoid compile errors, the "import_sha2" feature must be kept enabled when the target is not ZKVM. closes INT-5999 --- guest-libs/sha2/Cargo.toml | 6 +++-- guest-libs/sha2/src/lib.rs | 4 +++ guest-libs/sha2/src/zkvm_impl.rs | 42 +++++++++++++++++++++++++++++--- 3 files changed, 46 insertions(+), 6 deletions(-) diff --git a/guest-libs/sha2/Cargo.toml b/guest-libs/sha2/Cargo.toml index 7dd779c840..ca880f9118 100644 --- a/guest-libs/sha2/Cargo.toml +++ b/guest-libs/sha2/Cargo.toml @@ -12,7 +12,7 @@ license.workspace = true [dependencies] openvm = { workspace = true } openvm-sha2-guest = { workspace = true } -sha2 = { workspace = true, default-features = false } +sha2 = { workspace = true, default-features = false, optional = true } [dev-dependencies] hex = { workspace = true } @@ -28,7 +28,9 @@ openvm-toolchain-tests = { workspace = true } eyre = { workspace = true } [features] -default = [] +default = ["import_sha2"] +# Enable sha2::Digest trait implementation +import_sha2 = ["dep:sha2"] aot = ["openvm-sdk/aot"] # Internal feature for testing only. cuda = ["openvm-sha2-circuit/cuda"] diff --git a/guest-libs/sha2/src/lib.rs b/guest-libs/sha2/src/lib.rs index 2aaeabbfe0..d557e88c61 100644 --- a/guest-libs/sha2/src/lib.rs +++ b/guest-libs/sha2/src/lib.rs @@ -1,5 +1,9 @@ #![no_std] +#[cfg(not(any(target_os = "zkvm", feature = "import_sha2")))] +compile_error!("openvm-sha2 requires the 'import_sha2' feature to be enabled on non-zkvm targets"); + +#[cfg(feature = "import_sha2")] pub use sha2::Digest; #[cfg(not(target_os = "zkvm"))] diff --git a/guest-libs/sha2/src/zkvm_impl.rs b/guest-libs/sha2/src/zkvm_impl.rs index 9d0b39e76b..7782110820 100644 --- a/guest-libs/sha2/src/zkvm_impl.rs +++ b/guest-libs/sha2/src/zkvm_impl.rs @@ -1,5 +1,6 @@ use core::cmp::min; +#[cfg(feature = "import_sha2")] use sha2::digest::{ consts::{U32, U48, U64}, FixedOutput, HashMarker, Output, OutputSizeUser, Update, @@ -54,7 +55,7 @@ impl Sha256 { } } - fn update(&mut self, mut input: &[u8]) { + pub fn update(&mut self, mut input: &[u8]) { self.len = self.len.checked_add(input.len() as u64).unwrap(); while !input.is_empty() { let to_copy = min(input.len(), SHA256_BLOCK_BYTES - self.idx); @@ -68,7 +69,7 @@ impl Sha256 { } } - fn finalize(mut self) -> [u8; SHA256_DIGEST_BYTES] { + pub fn finalize(mut self) -> [u8; SHA256_DIGEST_BYTES] { // pad positive amount so that length is multiple of SHA256_BLOCK_BYTES // (extra 8 bytes are for message length) let num_bytes_of_padding = SHA256_BLOCK_BYTES - (self.idx + 8) % SHA256_BLOCK_BYTES; @@ -92,11 +93,19 @@ impl Sha256 { self.state.as_mut_ptr() as *mut u8, ); } + + #[cfg(not(feature = "import_sha2"))] + pub fn digest(input: &[u8]) -> [u8; SHA256_DIGEST_BYTES] { + let mut hasher = Self::new(); + hasher.update(input); + hasher.finalize() + } } // We will implement FixedOutput, Default, Update, and HashMarker for Sha256 so that // the blanket implementation of sha2::Digest is available. // See: https://docs.rs/sha2/latest/sha2/trait.Digest.html#impl-Digest-for-D +#[cfg(feature = "import_sha2")] impl Update for Sha256 { fn update(&mut self, input: &[u8]) { self.update(input); @@ -105,16 +114,19 @@ impl Update for Sha256 { // OutputSizeUser is required for FixedOutput // See: https://docs.rs/digest/0.10.7/digest/trait.FixedOutput.html +#[cfg(feature = "import_sha2")] impl OutputSizeUser for Sha256 { type OutputSize = U32; } +#[cfg(feature = "import_sha2")] impl FixedOutput for Sha256 { fn finalize_into(self, out: &mut Output) { out.copy_from_slice(&self.finalize()); } } +#[cfg(feature = "import_sha2")] impl HashMarker for Sha256 {} const SHA512_STATE_WORDS: usize = 8; @@ -161,7 +173,7 @@ impl Sha512 { } } - fn update(&mut self, mut input: &[u8]) { + pub fn update(&mut self, mut input: &[u8]) { self.len = self.len.checked_add(input.len() as u128).unwrap(); while !input.is_empty() { let to_copy = min(input.len(), SHA512_BLOCK_BYTES - self.idx); @@ -175,7 +187,7 @@ impl Sha512 { } } - fn finalize(mut self) -> [u8; SHA512_DIGEST_BYTES] { + pub fn finalize(mut self) -> [u8; SHA512_DIGEST_BYTES] { // pad positive amount so that length is multiple of SHA512_BLOCK_BYTES // (extra 16 bytes are for message length) let num_bytes_of_padding = SHA512_BLOCK_BYTES - (self.idx + 16) % SHA512_BLOCK_BYTES; @@ -199,11 +211,19 @@ impl Sha512 { self.state.as_mut_ptr() as *mut u8, ); } + + #[cfg(not(feature = "import_sha2"))] + pub fn digest(input: &[u8]) -> [u8; SHA512_DIGEST_BYTES] { + let mut hasher = Self::new(); + hasher.update(input); + hasher.finalize() + } } // We will implement FixedOutput, Default, Update, and HashMarker for Sha512 so that // the blanket implementation of sha2::Digest is available. // See: https://docs.rs/sha2/latest/sha2/trait.Digest.html#impl-Digest-for-D +#[cfg(feature = "import_sha2")] impl Update for Sha512 { fn update(&mut self, input: &[u8]) { self.update(input); @@ -212,16 +232,19 @@ impl Update for Sha512 { // OutputSizeUser is required for FixedOutput // See: https://docs.rs/digest/0.10.7/digest/trait.FixedOutput.html +#[cfg(feature = "import_sha2")] impl OutputSizeUser for Sha512 { type OutputSize = U64; } +#[cfg(feature = "import_sha2")] impl FixedOutput for Sha512 { fn finalize_into(self, out: &mut Output) { out.copy_from_slice(&self.finalize()); } } +#[cfg(feature = "import_sha2")] impl HashMarker for Sha512 {} const SHA384_DIGEST_BYTES: usize = 48; @@ -264,11 +287,19 @@ impl Sha384 { let digest = self.inner.finalize(); digest[..SHA384_DIGEST_BYTES].try_into().unwrap() } + + #[cfg(not(feature = "import_sha2"))] + pub fn digest(input: &[u8]) -> [u8; SHA384_DIGEST_BYTES] { + let mut hasher = Self::new(); + hasher.update(input); + hasher.finalize() + } } // We will implement FixedOutput, Default, Update, and HashMarker for Sha384 so that // the blanket implementation of sha2::Digest is available. // See: https://docs.rs/sha2/latest/sha2/trait.Digest.html#impl-Digest-for-D +#[cfg(feature = "import_sha2")] impl Update for Sha384 { fn update(&mut self, input: &[u8]) { self.update(input); @@ -277,14 +308,17 @@ impl Update for Sha384 { // OutputSizeUser is required for FixedOutput // See: https://docs.rs/digest/0.10.7/digest/trait.FixedOutput.html +#[cfg(feature = "import_sha2")] impl OutputSizeUser for Sha384 { type OutputSize = U48; } +#[cfg(feature = "import_sha2")] impl FixedOutput for Sha384 { fn finalize_into(self, out: &mut Output) { out.copy_from_slice(&self.finalize()); } } +#[cfg(feature = "import_sha2")] impl HashMarker for Sha384 {} From 9e800a55fa8337be122657410e4f60bb66becf90 Mon Sep 17 00:00:00 2001 From: William Lin <63217833+Maillew@users.noreply.github.com> Date: Sat, 28 Feb 2026 05:31:26 +0000 Subject: [PATCH 19/78] feat: remove memory access adapters: CPU Boundary AIR, initialize/finalize memory (#2318) Closes INT-5723, INT-5724, INT-5726 --------- Co-authored-by: Jonathan Wang <31040440+jonathanpwang@users.noreply.github.com> --- crates/circuits/sha2-air/src/utils.rs | 20 ++- crates/vm/src/arch/config.rs | 37 +++++- .../vm/src/arch/execution_mode/metered/ctx.rs | 13 +- .../arch/execution_mode/metered/memory_ctx.rs | 6 + .../src/arch/execution_mode/metered_cost.rs | 15 +-- crates/vm/src/arch/testing/cpu.rs | 7 +- crates/vm/src/arch/vm.rs | 6 +- crates/vm/src/system/memory/adapter/mod.rs | 35 ++--- crates/vm/src/system/memory/controller/mod.rs | 31 ++++- crates/vm/src/system/memory/mod.rs | 38 +++--- crates/vm/src/system/memory/online.rs | 6 +- crates/vm/src/system/memory/persistent.rs | 122 +++++++++++++----- crates/vm/src/system/mod.rs | 2 +- .../keccak256/circuit/src/keccakf_op/tests.rs | 12 +- .../keccak256/circuit/src/keccakf_op/trace.rs | 3 +- extensions/keccak256/circuit/src/xorin/air.rs | 5 +- .../keccak256/circuit/src/xorin/tests.rs | 24 +--- .../keccak256/circuit/src/xorin/trace.rs | 20 ++- .../rv32im/circuit/src/base_alu/tests.rs | 14 +- extensions/rv32im/circuit/src/common/mod.rs | 8 +- .../rv32im/circuit/src/loadstore/tests.rs | 7 +- extensions/sha2/circuit/src/cuda/mod.rs | 4 +- .../src/sha2_chips/block_hasher_chip/trace.rs | 3 +- .../circuit/src/sha2_chips/main_chip/air.rs | 3 +- .../circuit/src/sha2_chips/main_chip/trace.rs | 2 +- .../sha2/circuit/src/sha2_chips/tests.rs | 6 +- 26 files changed, 278 insertions(+), 171 deletions(-) diff --git a/crates/circuits/sha2-air/src/utils.rs b/crates/circuits/sha2-air/src/utils.rs index 1e956b82d0..86e495839b 100644 --- a/crates/circuits/sha2-air/src/utils.rs +++ b/crates/circuits/sha2-air/src/utils.rs @@ -74,7 +74,10 @@ pub fn limbs_into_u32(limbs: &[u32]) -> u32 { /// Rotates `bits` right by `n` bits, assumes `bits` is in little-endian #[inline] -pub(crate) fn rotr(bits: &[impl Into + Clone], n: usize) -> Vec { +pub(crate) fn rotr( + bits: &[impl Into + Clone], + n: usize, +) -> Vec { (0..bits.len()) .map(|i| bits[(i + n) % bits.len()].clone().into()) .collect() @@ -82,7 +85,10 @@ pub(crate) fn rotr(bits: &[impl Into + Cl /// Shifts `bits` right by `n` bits, assumes `bits` is in little-endian #[inline] -pub(crate) fn shr(bits: &[impl Into + Clone], n: usize) -> Vec { +pub(crate) fn shr( + bits: &[impl Into + Clone], + n: usize, +) -> Vec { (0..bits.len()) .map(|i| { if i + n < bits.len() { @@ -216,7 +222,10 @@ pub fn small_sig0(x: C::Word) -> C::Word { /// Computes SmallSigma0(x), where x is a [C::WORD_BITS] bit number in little-endian #[inline] -pub(crate) fn small_sig0_field( +pub(crate) fn small_sig0_field< + F: PrimeCharacteristicRing + Clone, + C: Sha2BlockHasherSubairConfig, +>( x: &[impl Into + Clone], ) -> Vec { if C::WORD_BITS == 32 { @@ -237,7 +246,10 @@ pub fn small_sig1(x: C::Word) -> C::Word { /// Computes SmallSigma1(x), where x is a [C::WORD_BITS] bit number in little-endian #[inline] -pub(crate) fn small_sig1_field( +pub(crate) fn small_sig1_field< + F: PrimeCharacteristicRing + Clone, + C: Sha2BlockHasherSubairConfig, +>( x: &[impl Into + Clone], ) -> Vec { if C::WORD_BITS == 32 { diff --git a/crates/vm/src/arch/config.rs b/crates/vm/src/arch/config.rs index 4d4b84c853..b249b56527 100644 --- a/crates/vm/src/arch/config.rs +++ b/crates/vm/src/arch/config.rs @@ -20,9 +20,7 @@ use crate::{ Arena, ChipInventoryError, ExecutorInventory, ExecutorInventoryError, }, system::{ - memory::{ - merkle::public_values::PUBLIC_VALUES_AS, num_memory_airs, CHUNK, POINTER_MAX_BITS, - }, + memory::{merkle::public_values::PUBLIC_VALUES_AS, num_memory_airs, POINTER_MAX_BITS}, SystemChipComplex, }, }; @@ -117,6 +115,11 @@ pub const OPENVM_DEFAULT_INIT_FILE_NAME: &str = "openvm_init.rs"; const DEFAULT_U8_BLOCK_SIZE: usize = 4; const DEFAULT_FIELD_BLOCK_SIZE: usize = 1; +/// The constant block size used for memory accesses when access adapters are disabled. +/// All memory accesses for address spaces 1-3 must use this block size. +/// This is also the block size used by the Boundary AIR for memory bus interactions. +pub const CONST_BLOCK_SIZE: usize = DEFAULT_U8_BLOCK_SIZE; + /// Trait for generating a init.rs file that contains a call to moduli_init!, /// complex_init!, sw_init! with the supported moduli and curves. /// Should be implemented by all VM config structs. @@ -227,6 +230,25 @@ impl MemoryConfig { .map(|addr_sp| log2_strict_usize(addr_sp.min_block_size) as u8) .collect() } + + /// Returns true if the Native address space (AS 4) is used. + /// Native AS is considered "used" if the host config allocates cells for it. + /// + /// When access adapters are disabled, all memory accesses must be of the + /// standard block size (i.e., 4 for address spaces 1-3). + pub fn access_adapters_enabled(&self) -> bool { + self.addr_spaces + .get(NATIVE_AS as usize) + .is_some_and(|config| config.num_cells > 0) + } + + pub fn num_access_adapters(&self) -> usize { + if self.access_adapters_enabled() { + log2_strict_usize(self.max_access_adapter_n) + } else { + 0 + } + } } /// System-level configuration for the virtual machine. Contains all configuration parameters that @@ -359,16 +381,21 @@ impl SystemConfig { self.memory_boundary_air_id() + num_memory_airs( self.continuation_enabled, - self.memory_config.max_access_adapter_n, + self.memory_config.num_access_adapters(), ) } pub fn initial_block_size(&self) -> usize { match self.continuation_enabled { - true => CHUNK, + true => CONST_BLOCK_SIZE, false => 1, } } + + /// Returns true if access adapters are enabled. + pub fn access_adapters_enabled(&self) -> bool { + self.memory_config.access_adapters_enabled() + } } impl Default for SystemConfig { diff --git a/crates/vm/src/arch/execution_mode/metered/ctx.rs b/crates/vm/src/arch/execution_mode/metered/ctx.rs index 3f02fc8abc..10ac7164c0 100644 --- a/crates/vm/src/arch/execution_mode/metered/ctx.rs +++ b/crates/vm/src/arch/execution_mode/metered/ctx.rs @@ -70,11 +70,14 @@ impl MeteredCtx { segmentation_ctx.air_names[merkle_tree_index] ); } - debug_assert!( - segmentation_ctx.air_names[memory_ctx.adapter_offset].contains("AccessAdapterAir<2>"), - "air_name={}", - segmentation_ctx.air_names[memory_ctx.adapter_offset] - ); + if memory_ctx.access_adapters_enabled { + debug_assert!( + segmentation_ctx.air_names[memory_ctx.adapter_offset] + .contains("AccessAdapterAir<2>"), + "air_name={}", + segmentation_ctx.air_names[memory_ctx.adapter_offset] + ); + } let mut ctx = Self { trace_heights, diff --git a/crates/vm/src/arch/execution_mode/metered/memory_ctx.rs b/crates/vm/src/arch/execution_mode/metered/memory_ctx.rs index 76fab4ee29..0a542adba1 100644 --- a/crates/vm/src/arch/execution_mode/metered/memory_ctx.rs +++ b/crates/vm/src/arch/execution_mode/metered/memory_ctx.rs @@ -107,6 +107,7 @@ pub struct MemoryCtx { pub boundary_idx: usize, pub merkle_tree_index: Option, pub adapter_offset: usize, + pub access_adapters_enabled: bool, continuations_enabled: bool, chunk: u32, chunk_bits: u32, @@ -134,6 +135,7 @@ impl MemoryCtx { boundary_idx: config.memory_boundary_air_id(), merkle_tree_index: config.memory_merkle_air_id(), adapter_offset: config.access_adapter_air_id_offset(), + access_adapters_enabled: config.access_adapters_enabled(), chunk, chunk_bits, memory_dimensions, @@ -232,6 +234,10 @@ impl MemoryCtx { size_bits: u32, num: u32, ) { + if !self.access_adapters_enabled { + return; + } + debug_assert!((address_space as usize) < self.min_block_size_bits.len()); // SAFETY: address_space passed is usually a hardcoded constant or derived from an diff --git a/crates/vm/src/arch/execution_mode/metered_cost.rs b/crates/vm/src/arch/execution_mode/metered_cost.rs index 924d05edf9..21d41a5aa2 100644 --- a/crates/vm/src/arch/execution_mode/metered_cost.rs +++ b/crates/vm/src/arch/execution_mode/metered_cost.rs @@ -64,7 +64,7 @@ impl AccessAdapterCtx { #[derive(Clone, Debug, WithSetters)] pub struct MeteredCostCtx { pub widths: Vec, - pub access_adapter_ctx: AccessAdapterCtx, + pub access_adapter_ctx: Option, #[getset(set_with = "pub")] pub max_execution_cost: u64, // Cost is number of trace cells (height * width) @@ -75,7 +75,9 @@ pub struct MeteredCostCtx { impl MeteredCostCtx { pub fn new(widths: Vec, config: &SystemConfig) -> Self { - let access_adapter_ctx = AccessAdapterCtx::new(config); + let access_adapter_ctx = config + .access_adapters_enabled() + .then(|| AccessAdapterCtx::new(config)); Self { widths, access_adapter_ctx, @@ -115,12 +117,9 @@ impl ExecutionCtxTrait for MeteredCostCtx { // Handle access adapter updates // SAFETY: size passed is always a non-zero power of 2 let size_bits = unsafe { NonZero::new_unchecked(size).ilog2() }; - self.access_adapter_ctx.update_cells( - &mut self.cost, - address_space, - size_bits, - &self.widths, - ); + if let Some(ctx) = self.access_adapter_ctx.as_mut() { + ctx.update_cells(&mut self.cost, address_space, size_bits, &self.widths); + } } #[inline(always)] diff --git a/crates/vm/src/arch/testing/cpu.rs b/crates/vm/src/arch/testing/cpu.rs index 44e4f6a7c4..81825da6cc 100644 --- a/crates/vm/src/arch/testing/cpu.rs +++ b/crates/vm/src/arch/testing/cpu.rs @@ -35,13 +35,14 @@ use crate::{ }, vm_poseidon2_config, Arena, ExecutionBridge, ExecutionBus, ExecutionState, MatrixRecordArena, MemoryConfig, PreflightExecutor, Streams, VmField, VmStateMut, + CONST_BLOCK_SIZE, }, system::{ memory::{ adapter::records::arena_size_bound, offline_checker::{MemoryBridge, MemoryBus}, online::TracingMemory, - MemoryAirInventory, MemoryController, SharedMemoryHelper, CHUNK, + MemoryAirInventory, MemoryController, SharedMemoryHelper, }, poseidon2::{air::Poseidon2PeripheryAir, Poseidon2PeripheryChip}, program::ProgramBus, @@ -324,7 +325,7 @@ impl VmChipTestBuilder { pub fn persistent(mem_config: MemoryConfig) -> Self { setup_tracing_with_log_level(Level::INFO); - let (range_checker, memory) = Self::range_checker_and_memory(&mem_config, CHUNK); + let (range_checker, memory) = Self::range_checker_and_memory(&mem_config, CONST_BLOCK_SIZE); let hasher_chip = Arc::new(Poseidon2PeripheryChip::new(vm_poseidon2_config(), 3)); let memory_controller = MemoryController::with_persistent_memory( MemoryBus::new(MEMORY_BUS), @@ -373,7 +374,7 @@ impl Default for VmChipTestBuilder { // TODO[jpw]: this is because old tests use `gen_pointer` on address space 1; this can be // removed when tests are updated. mem_config.addr_spaces[RV32_REGISTER_AS as usize].num_cells = 1 << 29; - Self::volatile(mem_config) + Self::persistent(mem_config) } } diff --git a/crates/vm/src/arch/vm.rs b/crates/vm/src/arch/vm.rs index 46feb53399..64c82ddcf5 100644 --- a/crates/vm/src/arch/vm.rs +++ b/crates/vm/src/arch/vm.rs @@ -23,7 +23,7 @@ use openvm_stark_backend::{ p3_field::{ BasedVectorSpace, InjectiveMonomial, PrimeCharacteristicRing, PrimeField32, TwoAdicField, }, - p3_util::{log2_ceil_usize, log2_strict_usize}, + p3_util::log2_ceil_usize, proof::Proof, prover::{ ColMajorMatrix, CommittedTraceData, DeviceDataTransporter, DeviceMultiStarkProvingKey, @@ -619,7 +619,9 @@ where let system_config: &SystemConfig = self.config().as_ref(); let adapter_offset = system_config.access_adapter_air_id_offset(); // ATTENTION: this must agree with `num_memory_airs` - let num_adapters = log2_strict_usize(system_config.memory_config.max_access_adapter_n); + + let num_adapters = system_config.memory_config.num_access_adapters(); + assert_eq!(adapter_offset + num_adapters, system_config.num_airs()); let access_adapter_arena_size_bound = records::arena_size_bound( &trace_heights[adapter_offset..adapter_offset + num_adapters], diff --git a/crates/vm/src/system/memory/adapter/mod.rs b/crates/vm/src/system/memory/adapter/mod.rs index 5b27c85c9c..7c687b63dd 100644 --- a/crates/vm/src/system/memory/adapter/mod.rs +++ b/crates/vm/src/system/memory/adapter/mod.rs @@ -53,21 +53,26 @@ impl AccessAdapterInventory { memory_bus: MemoryBus, memory_config: MemoryConfig, ) -> Self { - let rc = range_checker; - let mb = memory_bus; - let tmb = memory_config.timestamp_max_bits; - let maan = memory_config.max_access_adapter_n; - assert!(matches!(maan, 2 | 4 | 8 | 16 | 32)); - let chips: Vec<_> = [ - Self::create_access_adapter_chip::<2>(rc.clone(), mb, tmb, maan), - Self::create_access_adapter_chip::<4>(rc.clone(), mb, tmb, maan), - Self::create_access_adapter_chip::<8>(rc.clone(), mb, tmb, maan), - Self::create_access_adapter_chip::<16>(rc.clone(), mb, tmb, maan), - Self::create_access_adapter_chip::<32>(rc.clone(), mb, tmb, maan), - ] - .into_iter() - .flatten() - .collect(); + // Only create adapter chips if access adapters are enabled + let chips: Vec<_> = if memory_config.access_adapters_enabled() { + let rc = range_checker; + let mb = memory_bus; + let tmb = memory_config.timestamp_max_bits; + let maan = memory_config.max_access_adapter_n; + assert!(matches!(maan, 2 | 4 | 8 | 16 | 32)); + [ + Self::create_access_adapter_chip::<2>(rc.clone(), mb, tmb, maan), + Self::create_access_adapter_chip::<4>(rc.clone(), mb, tmb, maan), + Self::create_access_adapter_chip::<8>(rc.clone(), mb, tmb, maan), + Self::create_access_adapter_chip::<16>(rc.clone(), mb, tmb, maan), + Self::create_access_adapter_chip::<32>(rc.clone(), mb, tmb, maan), + ] + .into_iter() + .flatten() + .collect() + } else { + Vec::new() + }; Self { memory_config, chips, diff --git a/crates/vm/src/system/memory/controller/mod.rs b/crates/vm/src/system/memory/controller/mod.rs index 68c2a7c09f..e971d082f4 100644 --- a/crates/vm/src/system/memory/controller/mod.rs +++ b/crates/vm/src/system/memory/controller/mod.rs @@ -13,7 +13,6 @@ use openvm_cpu_backend::CpuBackend; use openvm_stark_backend::{ interaction::PermutationCheckBus, p3_field::PrimeField32, - p3_maybe_rayon::prelude::{IntoParallelIterator, ParallelIterator}, p3_util::{log2_ceil_usize, log2_strict_usize}, prover::AirProvingContext, StarkProtocolConfig, @@ -23,7 +22,7 @@ use serde::{Deserialize, Serialize}; use self::interface::MemoryInterface; use super::{volatile::VolatileBoundaryChip, AddressMap}; use crate::{ - arch::{DenseRecordArena, MemoryConfig, VmField, ADDR_SPACE_OFFSET}, + arch::{DenseRecordArena, MemoryConfig, VmField, ADDR_SPACE_OFFSET, CONST_BLOCK_SIZE}, system::{ memory::{ adapter::AccessAdapterInventory, @@ -287,10 +286,30 @@ impl MemoryController { ) => { let hasher = self.hasher_chip.as_ref().unwrap(); boundary_chip.finalize(initial_memory, &final_memory, hasher.as_ref()); - let final_memory_values = final_memory - .into_par_iter() - .map(|(key, value)| (key, value.values)) - .collect(); + + // Rechunk CONST_BLOCK_SIZE blocks into CHUNK-sized blocks for merkle_chip + // Note: Equipartition key is (addr_space, ptr) where ptr is the starting pointer + let final_memory_values: Equipartition = { + use std::collections::BTreeMap; + let mut chunk_map: BTreeMap<(u32, u32), [F; CHUNK]> = BTreeMap::new(); + for ((addr_space, ptr), ts_values) in final_memory.into_iter() { + // Align to CHUNK boundary to get the chunk's starting pointer + let chunk_ptr = (ptr / CHUNK as u32) * CHUNK as u32; + let block_idx_in_chunk = + ((ptr % CHUNK as u32) / CONST_BLOCK_SIZE as u32) as usize; + let entry = chunk_map.entry((addr_space, chunk_ptr)).or_insert_with(|| { + // Initialize with values from initial memory + std::array::from_fn(|i| unsafe { + initial_memory.get_f::(addr_space, chunk_ptr + i as u32) + }) + }); + // Copy values for this block + for (i, val) in ts_values.values.into_iter().enumerate() { + entry[block_idx_in_chunk * CONST_BLOCK_SIZE + i] = val; + } + } + chunk_map + }; merkle_chip.finalize(initial_memory, &final_memory_values, hasher.as_ref()); } _ => panic!("TouchedMemory incorrect type"), diff --git a/crates/vm/src/system/memory/mod.rs b/crates/vm/src/system/memory/mod.rs index 2b83452cda..82ec3b99e8 100644 --- a/crates/vm/src/system/memory/mod.rs +++ b/crates/vm/src/system/memory/mod.rs @@ -117,20 +117,24 @@ impl MemoryAirInventory { ); MemoryInterfaceAirs::Volatile { boundary } }; - // Memory access adapters - let lt_air = IsLtSubAir::new(range_bus, mem_config.timestamp_max_bits); - let maan = mem_config.max_access_adapter_n; - assert!(matches!(maan, 2 | 4 | 8 | 16 | 32)); - let access_adapters: Vec> = [ - Arc::new(AccessAdapterAir::<2> { memory_bus, lt_air }) as AirRef, - Arc::new(AccessAdapterAir::<4> { memory_bus, lt_air }) as AirRef, - Arc::new(AccessAdapterAir::<8> { memory_bus, lt_air }) as AirRef, - Arc::new(AccessAdapterAir::<16> { memory_bus, lt_air }) as AirRef, - Arc::new(AccessAdapterAir::<32> { memory_bus, lt_air }) as AirRef, - ] - .into_iter() - .take(log2_strict_usize(maan)) - .collect(); + // Memory access adapters - only create if enabled + let access_adapters: Vec> = if mem_config.access_adapters_enabled() { + let lt_air = IsLtSubAir::new(range_bus, mem_config.timestamp_max_bits); + let maan = mem_config.max_access_adapter_n; + assert!(matches!(maan, 2 | 4 | 8 | 16 | 32)); + [ + Arc::new(AccessAdapterAir::<2> { memory_bus, lt_air }) as AirRef, + Arc::new(AccessAdapterAir::<4> { memory_bus, lt_air }) as AirRef, + Arc::new(AccessAdapterAir::<8> { memory_bus, lt_air }) as AirRef, + Arc::new(AccessAdapterAir::<16> { memory_bus, lt_air }) as AirRef, + Arc::new(AccessAdapterAir::<32> { memory_bus, lt_air }) as AirRef, + ] + .into_iter() + .take(log2_strict_usize(maan)) + .collect() + } else { + Vec::new() + }; Self { bridge, @@ -158,7 +162,7 @@ impl MemoryAirInventory { /// This is O(1) and returns the length of /// [`MemoryAirInventory::into_airs`]. -pub fn num_memory_airs(is_persistent: bool, max_access_adapter_n: usize) -> usize { - // boundary + { merkle if is_persistent } + access_adapters - 1 + usize::from(is_persistent) + log2_strict_usize(max_access_adapter_n) +pub fn num_memory_airs(is_persistent: bool, num_access_adapters: usize) -> usize { + // boundary + { merkle if is_persistent } + access_adapters (if enabled) + 1 + usize::from(is_persistent) + num_access_adapters } diff --git a/crates/vm/src/system/memory/online.rs b/crates/vm/src/system/memory/online.rs index 6a16e0d12b..fb66845c0b 100644 --- a/crates/vm/src/system/memory/online.rs +++ b/crates/vm/src/system/memory/online.rs @@ -13,12 +13,12 @@ use tracing::instrument; use crate::{ arch::{ AddressSpaceHostConfig, AddressSpaceHostLayout, DenseRecordArena, MemoryConfig, - RecordArena, MAX_CELL_BYTE_SIZE, + RecordArena, CONST_BLOCK_SIZE, MAX_CELL_BYTE_SIZE, }, system::{ memory::{ adapter::records::{AccessLayout, AccessRecordHeader, MERGE_AND_NOT_SPLIT_FLAG}, - MemoryAddress, TimestampedEquipartition, TimestampedValues, CHUNK, + MemoryAddress, TimestampedEquipartition, TimestampedValues, }, TouchedMemory, }, @@ -944,7 +944,7 @@ impl TracingMemory { self.touched_blocks_to_equipartition::(touched_blocks), ), true => TouchedMemory::Persistent( - self.touched_blocks_to_equipartition::(touched_blocks), + self.touched_blocks_to_equipartition::(touched_blocks), ), } } diff --git a/crates/vm/src/system/memory/persistent.rs b/crates/vm/src/system/memory/persistent.rs index 0ff24ef174..c50eec88ec 100644 --- a/crates/vm/src/system/memory/persistent.rs +++ b/crates/vm/src/system/memory/persistent.rs @@ -18,16 +18,21 @@ use openvm_stark_backend::{ use rustc_hash::FxHashSet; use tracing::instrument; -use super::{merkle::SerialReceiver, online::INITIAL_TIMESTAMP, TimestampedValues}; +use super::{merkle::SerialReceiver, online::INITIAL_TIMESTAMP}; use crate::{ - arch::{hasher::Hasher, ADDR_SPACE_OFFSET}, + arch::{hasher::Hasher, ADDR_SPACE_OFFSET, CONST_BLOCK_SIZE}, primitives::Chip, system::memory::{ - dimensions::MemoryDimensions, offline_checker::MemoryBus, MemoryAddress, MemoryImage, - TimestampedEquipartition, + controller::CHUNK, dimensions::MemoryDimensions, offline_checker::MemoryBus, MemoryAddress, + MemoryImage, TimestampedEquipartition, }, }; +/// Number of CONST_BLOCK_SIZE blocks per CHUNK (e.g., 2 for 8/4). +/// Blocks are on the same row only for Merkle tree hashing (8 bytes at a time). +/// Memory bus interactions use per-block timestamps. +pub const BLOCKS_PER_CHUNK: usize = CHUNK / CONST_BLOCK_SIZE; + /// The values describe aligned chunk of memory of size `CHUNK`---the data together with the last /// accessed timestamp---in either the initial or final memory state. #[repr(C)] @@ -41,7 +46,10 @@ pub struct PersistentBoundaryCols { pub leaf_label: T, pub values: [T; CHUNK], pub hash: [T; CHUNK], - pub timestamp: T, + /// Per-block timestamps. Each CONST_BLOCK_SIZE block within the chunk has its own timestamp. + /// For untouched blocks, timestamp stays at 0 (balances: boundary sends at t=0 init, receives + /// at t=0 final). + pub timestamps: [T; BLOCKS_PER_CHUNK], } /// Imposes the following constraints: @@ -80,12 +88,14 @@ impl Air for PersistentBoundaryA local.expand_direction * local.expand_direction * local.expand_direction, ); - // Constrain that an "initial" row has timestamp zero. + // Constrain that an "initial" row has all timestamp zero. // Since `direction` is constrained to be in {-1, 0, 1}, we can select `direction == 1` // with the constraint below. - builder - .when(local.expand_direction * (local.expand_direction + AB::F::ONE)) - .assert_zero(local.timestamp); + let mut when_initial = + builder.when(local.expand_direction * (local.expand_direction + AB::F::ONE)); + for i in 0..BLOCKS_PER_CHUNK { + when_initial.assert_zero(local.timestamps[i]); + } let mut expand_fields = vec![ // direction = 1 => is_final = 0 @@ -108,16 +118,23 @@ impl Air for PersistentBoundaryA local.expand_direction * local.expand_direction, ); - self.memory_bus - .send( - MemoryAddress::new( - local.address_space, - local.leaf_label * AB::F::from_usize(CHUNK), - ), - local.values.to_vec(), - local.timestamp, - ) - .eval(builder, local.expand_direction); + let chunk_size_f = AB::F::from_usize(CHUNK); + for block_idx in 0..BLOCKS_PER_CHUNK { + let offset = AB::F::from_usize(block_idx * CONST_BLOCK_SIZE); + // Split the 1xCHUNK leaf into CONST_BLOCK_SIZE-sized bus messages. + // Each block uses its own timestamp - untouched blocks stay at t=0. + self.memory_bus + .send( + MemoryAddress::new( + local.address_space, + local.leaf_label * chunk_size_f + offset, + ), + local.values[block_idx * CONST_BLOCK_SIZE..(block_idx + 1) * CONST_BLOCK_SIZE] + .to_vec(), + local.timestamps[block_idx], + ) + .eval(builder, local.expand_direction); + } } } @@ -141,7 +158,8 @@ pub struct FinalTouchedLabel { final_values: [F; CHUNK], init_hash: [F; CHUNK], final_hash: [F; CHUNK], - final_timestamp: u32, + /// Per-block timestamps. Each CONST_BLOCK_SIZE block has its own timestamp. + final_timestamps: [u32; BLOCKS_PER_CHUNK], } impl Default for TouchedLabels { @@ -206,34 +224,74 @@ impl PersistentBoundaryChip { } } + /// Finalize the boundary chip with per-block timestamped memory. + /// + /// `final_memory` is at CONST_BLOCK_SIZE granularity (4 bytes per entry, single timestamp + /// each). This function rechunks into CHUNK-sized (8 bytes) groups with per-block + /// timestamps. Untouched blocks within a touched chunk get values from initial_memory and + /// timestamp 0. #[instrument(name = "boundary_finalize", level = "debug", skip_all)] pub(crate) fn finalize( &mut self, initial_memory: &MemoryImage, - // Only touched stuff - final_memory: &TimestampedEquipartition, + // Touched stuff at CONST_BLOCK_SIZE granularity + final_memory: &TimestampedEquipartition, hasher: &H, ) where H: Hasher + Sync + for<'a> SerialReceiver<&'a [F]>, { - let final_touched_labels: Vec<_> = final_memory + type BlockInfo = (usize, u32, [F; CONST_BLOCK_SIZE]); // (block_idx, timestamp, values) + type EnrichedEntry = ((u32, u32), BlockInfo); // (chunk_key, block_info) + + let enriched: Vec> = final_memory .par_iter() .map(|&((addr_space, ptr), ts_values)| { - let TimestampedValues { timestamp, values } = ts_values; + let chunk_label = ptr / CHUNK as u32; + let block_idx = ((ptr % CHUNK as u32) / CONST_BLOCK_SIZE as u32) as usize; + let key = (addr_space, chunk_label); + let block_info = (block_idx, ts_values.timestamp, ts_values.values); + (key, block_info) + }) + .collect(); + + let chunk_groups: Vec<_> = enriched + .chunk_by(|a, b| a.0 == b.0) + .map(|group| { + let key = group[0].0; + let blocks: Vec> = group.iter().map(|&(_, info)| info).collect(); + (key, blocks) + }) + .collect(); + + let final_touched_labels: Vec<_> = chunk_groups + .into_par_iter() + .map(|((addr_space, chunk_label), blocks)| { + let chunk_ptr = chunk_label * CHUNK as u32; // SAFETY: addr_space from `final_memory` are all in bounds - let init_values = array::from_fn(|i| unsafe { - initial_memory.get_f::(addr_space, ptr + i as u32) + let init_values: [F; CHUNK] = array::from_fn(|i| unsafe { + initial_memory.get_f::(addr_space, chunk_ptr + i as u32) }); + + let mut final_values = init_values; + let mut timestamps = [0u32; BLOCKS_PER_CHUNK]; + + for (block_idx, ts, values) in blocks { + timestamps[block_idx] = ts; + for (i, &val) in values.iter().enumerate() { + final_values[block_idx * CONST_BLOCK_SIZE + i] = val; + } + } + let initial_hash = hasher.hash(&init_values); - let final_hash = hasher.hash(&values); + let final_hash = hasher.hash(&final_values); FinalTouchedLabel { address_space: addr_space, - label: ptr / CHUNK as u32, + label: chunk_label, init_values, - final_values: values, + final_values, init_hash: initial_hash, final_hash, - final_timestamp: timestamp, + final_timestamps: timestamps, } }) .collect(); @@ -280,7 +338,7 @@ where leaf_label: Val::::from_u32(touched_label.label), values: touched_label.init_values, hash: touched_label.init_hash, - timestamp: Val::::from_u32(INITIAL_TIMESTAMP), + timestamps: [Val::::from_u32(INITIAL_TIMESTAMP); BLOCKS_PER_CHUNK], }; *final_row.borrow_mut() = PersistentBoundaryCols { @@ -289,7 +347,7 @@ where leaf_label: Val::::from_u32(touched_label.label), values: touched_label.final_values, hash: touched_label.final_hash, - timestamp: Val::::from_u32(touched_label.final_timestamp), + timestamps: touched_label.final_timestamps.map(Val::::from_u32), }; }); RowMajorMatrix::new(rows, width) diff --git a/crates/vm/src/system/mod.rs b/crates/vm/src/system/mod.rs index df96ff42ee..f1f1ba5ded 100644 --- a/crates/vm/src/system/mod.rs +++ b/crates/vm/src/system/mod.rs @@ -117,7 +117,7 @@ pub struct SystemRecords { } pub enum TouchedMemory { - Persistent(TimestampedEquipartition), + Persistent(TimestampedEquipartition), Volatile(TimestampedEquipartition), } diff --git a/extensions/keccak256/circuit/src/keccakf_op/tests.rs b/extensions/keccak256/circuit/src/keccakf_op/tests.rs index 903c36ea29..2112404aa2 100644 --- a/extensions/keccak256/circuit/src/keccakf_op/tests.rs +++ b/extensions/keccak256/circuit/src/keccakf_op/tests.rs @@ -261,11 +261,7 @@ fn cuda_set_and_execute( let buffer_reg = gen_pointer(rng, 4); let buffer_ptr = gen_pointer(rng, KECCAK_STATE_BYTES); - tester.write( - 1, - buffer_reg, - buffer_ptr.to_le_bytes().map(F::from_u8), - ); + tester.write(1, buffer_reg, buffer_ptr.to_le_bytes().map(F::from_u8)); let state_data: Vec = (0..KECCAK_STATE_BYTES).map(|_| rng.gen()).collect(); for (i, chunk) in state_data.chunks(4).enumerate() { @@ -371,11 +367,7 @@ fn test_keccakf_cuda_tracegen_zero_state() { let buffer_reg = gen_pointer(&mut rng, 4); let buffer_ptr = gen_pointer(&mut rng, KECCAK_STATE_BYTES); - tester.write( - 1, - buffer_reg, - buffer_ptr.to_le_bytes().map(F::from_u8), - ); + tester.write(1, buffer_reg, buffer_ptr.to_le_bytes().map(F::from_u8)); for i in 0..(KECCAK_STATE_BYTES / 4) { tester.write(2, buffer_ptr + i * 4, [F::ZERO; 4]); diff --git a/extensions/keccak256/circuit/src/keccakf_op/trace.rs b/extensions/keccak256/circuit/src/keccakf_op/trace.rs index ee86dbdeab..2a0ad5fb48 100644 --- a/extensions/keccak256/circuit/src/keccakf_op/trace.rs +++ b/extensions/keccak256/circuit/src/keccakf_op/trace.rs @@ -13,7 +13,7 @@ use openvm_circuit::{ }, }; use openvm_circuit_primitives::{ - bitwise_op_lookup::SharedBitwiseOperationLookupChip, AlignedBytesBorrow, + bitwise_op_lookup::SharedBitwiseOperationLookupChip, AlignedBytesBorrow, Chip, }; use openvm_instructions::{ instruction::Instruction, @@ -22,7 +22,6 @@ use openvm_instructions::{ }; use openvm_keccak256_transpiler::KeccakfOpcode; use openvm_rv32im_circuit::adapters::{timed_write, tracing_read}; -use openvm_circuit_primitives::Chip; use openvm_stark_backend::{ p3_field::PrimeField32, p3_matrix::{dense::RowMajorMatrix, Matrix}, diff --git a/extensions/keccak256/circuit/src/xorin/air.rs b/extensions/keccak256/circuit/src/xorin/air.rs index 95151b69fe..0cbfa70e2d 100644 --- a/extensions/keccak256/circuit/src/xorin/air.rs +++ b/extensions/keccak256/circuit/src/xorin/air.rs @@ -161,9 +161,8 @@ impl XorinVmAir { *instruction.len_limbs.last().unwrap(), ]; - let limb_shift = AB::F::from_usize( - 1 << (RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - self.ptr_max_bits), - ); + let limb_shift = + AB::F::from_usize(1 << (RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - self.ptr_max_bits)); for pair in need_range_check.chunks_exact(2) { self.bitwise_lookup_bus .send_range(pair[0] * limb_shift, pair[1] * limb_shift) diff --git a/extensions/keccak256/circuit/src/xorin/tests.rs b/extensions/keccak256/circuit/src/xorin/tests.rs index 6d602d2ce6..d0dfde7c3c 100644 --- a/extensions/keccak256/circuit/src/xorin/tests.rs +++ b/extensions/keccak256/circuit/src/xorin/tests.rs @@ -124,11 +124,7 @@ fn set_and_execute>( tester.write(1, rd, buffer_ptr.to_le_bytes().map(F::from_u8)); tester.write(1, rs1, input_ptr.to_le_bytes().map(F::from_u8)); - tester.write( - 1, - rs2, - buffer_length.to_le_bytes().map(F::from_u8), - ); + tester.write(1, rs2, buffer_length.to_le_bytes().map(F::from_u8)); tester.execute( executor, arena, @@ -313,21 +309,9 @@ fn cuda_set_and_execute( let buffer_ptr = gen_pointer(rng, len); let input_ptr = gen_pointer(rng, len); - tester.write( - 1, - buffer_reg, - buffer_ptr.to_le_bytes().map(F::from_u8), - ); - tester.write( - 1, - input_reg, - input_ptr.to_le_bytes().map(F::from_u8), - ); - tester.write( - 1, - len_reg, - (len as u32).to_le_bytes().map(F::from_u8), - ); + tester.write(1, buffer_reg, buffer_ptr.to_le_bytes().map(F::from_u8)); + tester.write(1, input_reg, input_ptr.to_le_bytes().map(F::from_u8)); + tester.write(1, len_reg, (len as u32).to_le_bytes().map(F::from_u8)); let buffer_data: Vec = (0..len).map(|_| rng.gen()).collect(); for (i, chunk) in buffer_data.chunks(4).enumerate() { diff --git a/extensions/keccak256/circuit/src/xorin/trace.rs b/extensions/keccak256/circuit/src/xorin/trace.rs index 07b920d039..a971f6ae29 100644 --- a/extensions/keccak256/circuit/src/xorin/trace.rs +++ b/extensions/keccak256/circuit/src/xorin/trace.rs @@ -12,15 +12,14 @@ use openvm_circuit::{ }, }; use openvm_circuit_primitives::AlignedBytesBorrow; -use openvm_instructions::{instruction::Instruction, riscv::RV32_REGISTER_NUM_LIMBS}; -use openvm_keccak256_transpiler::XorinOpcode; -use openvm_rv32im_circuit::adapters::{read_rv32_register, tracing_read, tracing_write}; -use openvm_stark_backend::p3_field::PrimeField32; - use openvm_instructions::{ + instruction::Instruction, program::DEFAULT_PC_STEP, - riscv::{RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS}, + riscv::{RV32_CELL_BITS, RV32_MEMORY_AS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS}, }; +use openvm_keccak256_transpiler::XorinOpcode; +use openvm_rv32im_circuit::adapters::{read_rv32_register, tracing_read, tracing_write}; +use openvm_stark_backend::p3_field::PrimeField32; use crate::xorin::{columns::XorinVmCols, XorinVmExecutor, XorinVmFiller}; @@ -295,8 +294,7 @@ impl TraceFiller for XorinVmFiller { // safety note: we leave the upper record_len..134 bytes with zeroes // because they are just padding bytes and unused by the chip for i in 0..record_len { - trace_row.sponge.preimage_buffer_bytes[i] = - F::from_u8(record.buffer_limbs[i]); + trace_row.sponge.preimage_buffer_bytes[i] = F::from_u8(record.buffer_limbs[i]); trace_row.sponge.input_bytes[i] = F::from_u8(record.input_limbs[i]); trace_row.sponge.postimage_buffer_bytes[i] = F::from_u8(record.buffer_limbs[i] ^ record.input_limbs[i]); @@ -311,10 +309,8 @@ impl TraceFiller for XorinVmFiller { timestamp, trace_row.mem_oc.buffer_bytes_write_aux_cols[t].as_mut(), ); - trace_row.mem_oc.buffer_bytes_write_aux_cols[t].prev_data = record - .buffer_write_aux_cols[t] - .prev_data - .map(F::from_u8); + trace_row.mem_oc.buffer_bytes_write_aux_cols[t].prev_data = + record.buffer_write_aux_cols[t].prev_data.map(F::from_u8); timestamp += 1; } diff --git a/extensions/rv32im/circuit/src/base_alu/tests.rs b/extensions/rv32im/circuit/src/base_alu/tests.rs index 09ca64eb05..611ca349c5 100644 --- a/extensions/rv32im/circuit/src/base_alu/tests.rs +++ b/extensions/rv32im/circuit/src/base_alu/tests.rs @@ -160,8 +160,11 @@ fn rand_rv32_alu_test(opcode: BaseAluOpcode, num_ops: usize) { // TODO(AG): make a more meaningful test for memory accesses tester.write(2, 1024, [F::ONE; 4]); tester.write(2, 1028, [F::ONE; 4]); - let sm = tester.read(2, 1024); - assert_eq!(sm, [F::ONE; 8]); + // Avoid wider-than-min-block accesses when access adapters are disabled + let sm1 = tester.read(2, 1024); + let sm2 = tester.read(2, 1028); + assert_eq!(sm1, [F::ONE; 4]); + assert_eq!(sm2, [F::ONE; 4]); for _ in 0..num_ops { set_and_execute( @@ -198,8 +201,11 @@ fn rand_rv32_alu_test_persistent(opcode: BaseAluOpcode, num_ops: usize) { // TODO(AG): make a more meaningful test for memory accesses tester.write(2, 1024, [F::ONE; 4]); tester.write(2, 1028, [F::ONE; 4]); - let sm = tester.read(2, 1024); - assert_eq!(sm, [F::ONE; 8]); + // Avoid wider-than-min-block accesses when access adapters are disabled + let sm1 = tester.read(2, 1024); + let sm2 = tester.read(2, 1028); + assert_eq!(sm1, [F::ONE; 4]); + assert_eq!(sm2, [F::ONE; 4]); for _ in 0..num_ops { set_and_execute( diff --git a/extensions/rv32im/circuit/src/common/mod.rs b/extensions/rv32im/circuit/src/common/mod.rs index 107fdff226..4be873b4f3 100644 --- a/extensions/rv32im/circuit/src/common/mod.rs +++ b/extensions/rv32im/circuit/src/common/mod.rs @@ -9,7 +9,7 @@ mod aot { use openvm_circuit::{ arch::{ execution_mode::{metered::memory_ctx::MemoryCtx, MeteredCtx}, - AotError, SystemConfig, VmExecState, ADDR_SPACE_OFFSET, + AotError, SystemConfig, VmExecState, ADDR_SPACE_OFFSET, CONST_BLOCK_SIZE, }, system::memory::{merkle::public_values::PUBLIC_VALUES_AS, online::GuestMemory, CHUNK}, }; @@ -251,12 +251,12 @@ mod aot { // Therefore the loop only iterates once for `page_id = start_page_id`. let initial_block_size: usize = config.initial_block_size(); - if initial_block_size != CHUNK { + if initial_block_size != CONST_BLOCK_SIZE { return Err(AotError::Other(format!( - "initial_block_size must be {CHUNK}, got {initial_block_size}" + "initial_block_size must be {CONST_BLOCK_SIZE}, got {initial_block_size}" ))); } - let chunk_bits = CHUNK.ilog2(); + let chunk_bits = CONST_BLOCK_SIZE.ilog2(); let as_offset = ((address_space - ADDR_SPACE_OFFSET) as u64) << (config.memory_config.memory_dimensions().address_height); diff --git a/extensions/rv32im/circuit/src/loadstore/tests.rs b/extensions/rv32im/circuit/src/loadstore/tests.rs index 7f51369ed8..9374d8c912 100644 --- a/extensions/rv32im/circuit/src/loadstore/tests.rs +++ b/extensions/rv32im/circuit/src/loadstore/tests.rs @@ -214,7 +214,9 @@ fn rand_loadstore_test(opcode: Rv32LoadStoreOpcode, num_ops: usize) { if [STOREW, STOREB, STOREH].contains(&opcode) { mem_config.addr_spaces[PUBLIC_VALUES_AS as usize].num_cells = 1 << 29; } - let mut tester = VmChipTestBuilder::volatile(mem_config); + // Use persistent memory so initial block size matches the 4-byte alignment and + // avoids access-adapter split/merge paths when adapters are disabled. + let mut tester = VmChipTestBuilder::persistent(mem_config); let mut harness = create_harness(&mut tester); for _ in 0..num_ops { @@ -265,7 +267,8 @@ fn run_negative_loadstore_test( if [STOREW, STOREB, STOREH].contains(&opcode) { mem_config.addr_spaces[PUBLIC_VALUES_AS as usize].num_cells = 1 << 29; } - let mut tester = VmChipTestBuilder::volatile(mem_config); + // Use persistent memory so the min block size matches alignment without needing adapters. + let mut tester = VmChipTestBuilder::persistent(mem_config); let mut harness = create_harness(&mut tester); set_and_execute( diff --git a/extensions/sha2/circuit/src/cuda/mod.rs b/extensions/sha2/circuit/src/cuda/mod.rs index a8f5705ef2..1f904d49bf 100644 --- a/extensions/sha2/circuit/src/cuda/mod.rs +++ b/extensions/sha2/circuit/src/cuda/mod.rs @@ -8,15 +8,13 @@ use openvm_circuit::{ utils::next_power_of_two_or_zero, }; use openvm_circuit_primitives::{ - bitwise_op_lookup::BitwiseOperationLookupChipGPU, var_range::VariableRangeCheckerChipGPU, + bitwise_op_lookup::BitwiseOperationLookupChipGPU, var_range::VariableRangeCheckerChipGPU, Chip, }; use openvm_cuda_backend::{base::DeviceMatrix, prelude::F, GpuBackend}; use openvm_cuda_common::{copy::MemCopyH2D, d_buffer::DeviceBuffer}; use openvm_sha2_air::{Sha256Config, Sha2Variant, Sha512Config}; use openvm_stark_backend::prover::AirProvingContext; -use openvm_circuit_primitives::Chip; - use crate::{Sha2Config, Sha2RecordLayout, Sha2RecordMut}; mod cuda_abi; diff --git a/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/trace.rs b/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/trace.rs index 6feaac8066..1a55c1fc01 100644 --- a/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/trace.rs +++ b/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/trace.rs @@ -1,12 +1,11 @@ use std::slice; use openvm_circuit::arch::get_record_from_slice; -use openvm_circuit_primitives::utils::next_power_of_two_or_zero; +use openvm_circuit_primitives::{utils::next_power_of_two_or_zero, Chip}; use openvm_sha2_air::{ be_limbs_into_word, le_limbs_into_word, Sha2BlockHasherFillerHelper, Sha2RoundColsRef, Sha2RoundColsRefMut, }; -use openvm_circuit_primitives::Chip; use openvm_stark_backend::{ p3_field::{PrimeCharacteristicRing, PrimeField32}, p3_matrix::dense::RowMajorMatrix, diff --git a/extensions/sha2/circuit/src/sha2_chips/main_chip/air.rs b/extensions/sha2/circuit/src/sha2_chips/main_chip/air.rs index c5aeb50fce..ecec691cd3 100644 --- a/extensions/sha2/circuit/src/sha2_chips/main_chip/air.rs +++ b/extensions/sha2/circuit/src/sha2_chips/main_chip/air.rs @@ -83,8 +83,7 @@ impl Date: Thu, 29 Jan 2026 18:18:35 -0500 Subject: [PATCH 20/78] feat: access adapter removal bigint (#2369) Resolves INT-5728, INT-5727, INT-5729. Summary of changes: - Everywhere the code used `Rv32HeapAdapterAir`, we switch to use `Rv32VecHeapAdapterAir`. - Everywhere the code used `Rv32HeapBranchAdapterAir`, we switch to use a new `Rv32HeapBranchAdapterAir`, which accesses memory in the same way as `Rv32VecHeapAdapterAir`, but is compatible with the branch CoreAirs. - No other code uses `Rv32HeapAdapterAir` and `Rv32HeapBranchAdapterAir`, so the `heap.rs` and `heap_branch.rs` files were deleted. - The interface for `Rv32VecHeapAdapterAir` and `Rv32HeapBranchAdapterAir ` now becomes different to what the CoreAirs expect, so wrappers in `vec_to_heap.rs` are used to convert between them. --------- Co-authored-by: Claude Opus 4.5 --- crates/vm/src/arch/integration_api.rs | 55 ++ crates/vm/src/arch/testing/cpu.rs | 31 +- crates/vm/src/arch/testing/cuda.rs | 10 +- crates/vm/src/system/cuda/memory.rs | 10 +- crates/vm/src/system/cuda/merkle_tree/mod.rs | 8 +- extensions/bigint/circuit/cuda/src/bigint.cu | 52 +- extensions/bigint/circuit/src/base_alu.rs | 17 +- extensions/bigint/circuit/src/branch_eq.rs | 16 +- extensions/bigint/circuit/src/branch_lt.rs | 15 +- extensions/bigint/circuit/src/common.rs | 42 +- extensions/bigint/circuit/src/cuda/mod.rs | 93 +++- .../bigint/circuit/src/extension/mod.rs | 72 ++- extensions/bigint/circuit/src/less_than.rs | 18 +- extensions/bigint/circuit/src/lib.rs | 172 +++--- extensions/bigint/circuit/src/mult.rs | 17 +- extensions/bigint/circuit/src/shift.rs | 17 +- extensions/bigint/circuit/src/tests.rs | 84 +-- .../cuda/include/rv32-adapters/heap.cuh | 15 - .../cuda/include/rv32-adapters/vec_heap.cuh | 10 + .../{heap_branch.cuh => vec_heap_branch.cuh} | 51 +- extensions/rv32-adapters/src/heap.rs | 185 ------- extensions/rv32-adapters/src/heap_branch.rs | 325 ------------ extensions/rv32-adapters/src/lib.rs | 8 +- .../rv32-adapters/src/vec_heap_branch.rs | 386 ++++++++++++++ extensions/rv32-adapters/src/vec_to_flat.rs | 493 ++++++++++++++++++ 25 files changed, 1412 insertions(+), 790 deletions(-) delete mode 100644 extensions/rv32-adapters/cuda/include/rv32-adapters/heap.cuh rename extensions/rv32-adapters/cuda/include/rv32-adapters/{heap_branch.cuh => vec_heap_branch.cuh} (56%) delete mode 100644 extensions/rv32-adapters/src/heap.rs delete mode 100644 extensions/rv32-adapters/src/heap_branch.rs create mode 100644 extensions/rv32-adapters/src/vec_heap_branch.rs create mode 100644 extensions/rv32-adapters/src/vec_to_flat.rs diff --git a/crates/vm/src/arch/integration_api.rs b/crates/vm/src/arch/integration_api.rs index 433ca5c477..116ec26b48 100644 --- a/crates/vm/src/arch/integration_api.rs +++ b/crates/vm/src/arch/integration_api.rs @@ -324,6 +324,24 @@ impl< type ProcessedInstruction = MinimalInstruction; } +/// Adapter interface for branch operations that read from heap via vec-style blocks. +/// Similar to `VecHeapAdapterInterface` but without writes (branch operations only compare values). +pub struct VecHeapBranchAdapterInterface< + T, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const READ_SIZE: usize, +>(PhantomData); + +impl + VmAdapterInterface + for VecHeapBranchAdapterInterface +{ + type Reads = [[[T; READ_SIZE]; BLOCKS_PER_READ]; NUM_READS]; + type Writes = (); + type ProcessedInstruction = ImmInstruction; +} + /// Similar to `BasicAdapterInterface`, but it flattens the reads and writes into a single flat /// array for each pub struct FlatInterface( @@ -816,4 +834,41 @@ mod conversions { ]) } } + + // AdapterAirContext: BasicInterface -> VecHeapBranchAdapterInterface + impl< + T, + const BASIC_NUM_READS: usize, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const READ_SIZE: usize, + > + From< + AdapterAirContext< + T, + BasicAdapterInterface, BASIC_NUM_READS, 0, READ_SIZE, 0>, + >, + > + for AdapterAirContext< + T, + VecHeapBranchAdapterInterface, + > + { + fn from( + ctx: AdapterAirContext< + T, + BasicAdapterInterface, BASIC_NUM_READS, 0, READ_SIZE, 0>, + >, + ) -> Self { + assert_eq!(BASIC_NUM_READS, NUM_READS * BLOCKS_PER_READ); + let mut reads_it = ctx.reads.into_iter(); + let reads = from_fn(|_| from_fn(|_| reads_it.next().unwrap())); + AdapterAirContext { + to_pc: ctx.to_pc, + reads, + writes: (), + instruction: ctx.instruction, + } + } + } } diff --git a/crates/vm/src/arch/testing/cpu.rs b/crates/vm/src/arch/testing/cpu.rs index 81825da6cc..58299c7e10 100644 --- a/crates/vm/src/arch/testing/cpu.rs +++ b/crates/vm/src/arch/testing/cpu.rs @@ -176,7 +176,8 @@ where ) -> (usize, usize) { let register = self.get_default_register(reg_increment); let pointer = self.get_default_pointer(pointer_increment); - self.write(1, register, pointer.to_le_bytes().map(F::from_u8)); + // Cast to u32 to ensure we write exactly 4 bytes (RV32 register size). + self.write(1, register, (pointer as u32).to_le_bytes().map(F::from_u8)); (register, pointer) } @@ -226,17 +227,23 @@ impl VmChipTestBuilder { pointer: usize, writes: Vec<[F; NUM_LIMBS]>, ) { - self.write(1usize, register, pointer.to_le_bytes().map(F::from_u8)); - if NUM_LIMBS.is_power_of_two() { - for (i, &write) in writes.iter().enumerate() { - self.write(2usize, pointer + i * NUM_LIMBS, write); - } - } else { - for (i, &write) in writes.iter().enumerate() { - let ptr = pointer + i * NUM_LIMBS; - for j in (0..NUM_LIMBS).step_by(4) { - self.write::<4>(2usize, ptr + j, write[j..j + 4].try_into().unwrap()); - } + // Cast to u32 to ensure we write exactly 4 bytes (RV32 register size). + // Using usize would write 8 bytes on 64-bit systems, creating access adapter records. + self.write( + 1usize, + register, + (pointer as u32).to_le_bytes().map(F::from_u8), + ); + // When access adapters are disabled, all memory accesses must use CONST_BLOCK_SIZE. + // Always write in chunks of CONST_BLOCK_SIZE to ensure compatibility. + for (i, &write) in writes.iter().enumerate() { + let ptr = pointer + i * NUM_LIMBS; + for j in (0..NUM_LIMBS).step_by(CONST_BLOCK_SIZE) { + self.write::( + 2usize, + ptr + j, + write[j..j + CONST_BLOCK_SIZE].try_into().unwrap(), + ); } } } diff --git a/crates/vm/src/arch/testing/cuda.rs b/crates/vm/src/arch/testing/cuda.rs index f8500eee62..7887eddba9 100644 --- a/crates/vm/src/arch/testing/cuda.rs +++ b/crates/vm/src/arch/testing/cuda.rs @@ -210,7 +210,8 @@ impl TestBuilder for GpuChipTestBuilder { ) -> (usize, usize) { let register = self.get_default_register(reg_increment); let pointer = self.get_default_pointer(pointer_increment); - self.write(1, register, pointer.to_le_bytes().map(F::from_u8)); + // Cast to u32 to ensure we write exactly 4 bytes (RV32 register size). + self.write(1, register, (pointer as u32).to_le_bytes().map(F::from_u8)); (register, pointer) } @@ -365,7 +366,12 @@ impl GpuChipTestBuilder { pointer: usize, writes: Vec<[F; NUM_LIMBS]>, ) { - self.write(1usize, register, pointer.to_le_bytes().map(F::from_u8)); + // Cast to u32 to ensure we write exactly 4 bytes (RV32 register size). + self.write( + 1usize, + register, + (pointer as u32).to_le_bytes().map(F::from_u8), + ); if NUM_LIMBS.is_power_of_two() { for (i, &write) in writes.iter().enumerate() { self.write(2usize, pointer + i * NUM_LIMBS, write); diff --git a/crates/vm/src/system/cuda/memory.rs b/crates/vm/src/system/cuda/memory.rs index 730cfb2724..57ae83144a 100644 --- a/crates/vm/src/system/cuda/memory.rs +++ b/crates/vm/src/system/cuda/memory.rs @@ -1,7 +1,9 @@ use std::sync::Arc; use openvm_circuit::{ - arch::{AddressSpaceHostLayout, DenseRecordArena, MemoryConfig, ADDR_SPACE_OFFSET}, + arch::{ + AddressSpaceHostLayout, DenseRecordArena, MemoryConfig, ADDR_SPACE_OFFSET, CONST_BLOCK_SIZE, + }, system::{ memory::{online::LinearMemory, AddressMap, TimestampedValues}, TouchedMemory, @@ -155,7 +157,7 @@ impl MemoryInventoryGPU { mem.tracing_info("boundary finalize"); let (touched_memory, empty) = if partition.is_empty() { let leftmost_values = 'left: { - let mut res = [F::ZERO; DIGEST_WIDTH]; + let mut res = [F::ZERO; CONST_BLOCK_SIZE]; if persistent.initial_memory[ADDR_SPACE_OFFSET as usize].is_empty() { break 'left res; } @@ -163,7 +165,7 @@ impl MemoryInventoryGPU { [ADDR_SPACE_OFFSET as usize] .layout; let one_cell_size = layout.size(); - let values = vec![0u8; one_cell_size * DIGEST_WIDTH]; + let values = vec![0u8; one_cell_size * CONST_BLOCK_SIZE]; unsafe { cuda_memcpy::( values.as_ptr() as *mut std::ffi::c_void, @@ -172,7 +174,7 @@ impl MemoryInventoryGPU { values.len(), ) .unwrap(); - for i in 0..DIGEST_WIDTH { + for i in 0..CONST_BLOCK_SIZE { res[i] = layout.to_field::(&values[i * one_cell_size..]); } } diff --git a/crates/vm/src/system/cuda/merkle_tree/mod.rs b/crates/vm/src/system/cuda/merkle_tree/mod.rs index 71cb2e6fb3..e24b9a041f 100644 --- a/crates/vm/src/system/cuda/merkle_tree/mod.rs +++ b/crates/vm/src/system/cuda/merkle_tree/mod.rs @@ -1,7 +1,7 @@ use std::{ffi::c_void, sync::Arc}; use openvm_circuit::{ - arch::{MemoryConfig, ADDR_SPACE_OFFSET}, + arch::{MemoryConfig, ADDR_SPACE_OFFSET, CONST_BLOCK_SIZE}, system::memory::{merkle::MemoryMerkleCols, TimestampedEquipartition}, utils::next_power_of_two_or_zero, }; @@ -24,7 +24,9 @@ pub mod cuda; use cuda::merkle_tree::*; type H = [F; DIGEST_WIDTH]; -pub const TIMESTAMPED_BLOCK_WIDTH: usize = 11; +/// Width of `((u32, u32), TimestampedValues)` in u32 units. +/// = 2 (key) + 1 (timestamp) + CONST_BLOCK_SIZE (values) +pub const TIMESTAMPED_BLOCK_WIDTH: usize = 3 + CONST_BLOCK_SIZE; /// A Merkle subtree stored in a single flat buffer, combining a vertical path and a heap-ordered /// binary tree. @@ -362,7 +364,7 @@ impl MemoryMerkleTree { /// An auxiliary function to calculate the required number of rows for the merkle trace. pub fn calculate_unpadded_height( &self, - touched_memory: &TimestampedEquipartition, + touched_memory: &TimestampedEquipartition, ) -> usize { let md = self.mem_config.memory_dimensions(); let tree_height = md.overall_height(); diff --git a/extensions/bigint/circuit/cuda/src/bigint.cu b/extensions/bigint/circuit/cuda/src/bigint.cu index a116d251a5..6ac2161a8f 100644 --- a/extensions/bigint/circuit/cuda/src/bigint.cu +++ b/extensions/bigint/circuit/cuda/src/bigint.cu @@ -2,8 +2,8 @@ #include "primitives/buffer_view.cuh" #include "primitives/histogram.cuh" #include "primitives/trace_access.h" -#include "rv32-adapters/heap.cuh" -#include "rv32-adapters/heap_branch.cuh" +#include "rv32-adapters/vec_heap.cuh" +#include "rv32-adapters/vec_heap_branch.cuh" #include "rv32im/cores/alu.cuh" #include "rv32im/cores/beq.cuh" #include "rv32im/cores/blt.cuh" @@ -14,6 +14,8 @@ using namespace riscv; constexpr size_t INT256_NUM_LIMBS = 32; +constexpr size_t CONST_BLOCK_SIZE = 4; +constexpr size_t INT256_NUM_BLOCKS = INT256_NUM_LIMBS / CONST_BLOCK_SIZE; using BaseAlu256CoreRecord = BaseAluCoreRecord<32>; using BaseAlu256Core = BaseAluCore<32>; @@ -40,17 +42,17 @@ using BranchLessThan256Core = BranchLessThanCore<32>; template using BranchLessThan256CoreCols = BranchLessThanCoreCols; // Heap adapter instantiation for 256-bit operations -// NUM_READS = 2, READ_SIZE = INT256_NUM_LIMBS (32 bytes), WRITE_SIZE = INT256_NUM_LIMBS (32 bytes) -// BLOCKS_PER_READ = 1, BLOCKS_PER_WRITE = 1 -using Rv32HeapAdapterExecutor256 = Rv32HeapAdapterExecutor<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS>; +// NUM_READS = 2, BLOCKS_PER_READ = INT256_NUM_BLOCKS (8), BLOCKS_PER_WRITE = INT256_NUM_BLOCKS (8) +// READ_SIZE = CONST_BLOCK_SIZE (4 bytes), WRITE_SIZE = CONST_BLOCK_SIZE (4 bytes) +using Rv32VecHeapAdapter256 = Rv32VecHeapAdapter<2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE, CONST_BLOCK_SIZE>; template struct BaseAlu256Cols { - Rv32HeapAdapterCols adapter; + Rv32VecHeapAdapterCols adapter; BaseAlu256CoreCols core; }; struct BaseAlu256Record { - Rv32HeapAdapterRecord<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS> adapter; + Rv32VecHeapAdapterRecord<2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE, CONST_BLOCK_SIZE> adapter; BaseAlu256CoreRecord core; }; @@ -70,7 +72,7 @@ __global__ void alu256_tracegen( if (idx < d_records.len()) { auto const &rec = d_records[idx]; - Rv32HeapAdapterExecutor256 adapter( + Rv32VecHeapAdapter256 adapter( pointer_max_bits, VariableRangeChecker(d_range_checker_ptr, range_checker_bins), BitwiseOperationLookup(d_bitwise_lookup_ptr, bitwise_num_bits), @@ -117,16 +119,16 @@ extern "C" int _alu256_tracegen( } // Heap branch adapter instantiation for 256-bit operations -// NUM_READS = 2, READ_SIZE = INT256_NUM_LIMBS (32 bytes) -using Rv32HeapBranchAdapter256 = Rv32HeapBranchAdapter<2, INT256_NUM_LIMBS>; +// NUM_READS = 2, BLOCKS_PER_READ = INT256_NUM_BLOCKS (8), READ_SIZE = CONST_BLOCK_SIZE (4 bytes) +using Rv32VecHeapBranchAdapter256 = Rv32VecHeapBranchAdapter<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>; template struct BranchEqual256Cols { - Rv32HeapBranchAdapterCols adapter; + Rv32VecHeapBranchAdapterCols adapter; BranchEqual256CoreCols core; }; struct BranchEqual256Record { - Rv32HeapBranchAdapterRecord<2> adapter; + Rv32VecHeapBranchAdapterRecord<2, INT256_NUM_BLOCKS> adapter; BranchEqual256CoreRecord core; }; @@ -146,7 +148,7 @@ __global__ void branch_equal256_tracegen( if (idx < d_records.len()) { auto const &rec = d_records[idx]; - Rv32HeapBranchAdapter256 adapter( + Rv32VecHeapBranchAdapter256 adapter( pointer_max_bits, VariableRangeChecker(d_range_checker_ptr, range_checker_bins), BitwiseOperationLookup(d_bitwise_lookup_ptr, bitwise_num_bits), @@ -193,12 +195,12 @@ extern "C" int _branch_equal256_tracegen( } template struct LessThan256Cols { - Rv32HeapAdapterCols adapter; + Rv32VecHeapAdapterCols adapter; LessThan256CoreCols core; }; struct LessThan256Record { - Rv32HeapAdapterRecord<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS> adapter; + Rv32VecHeapAdapterRecord<2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE, CONST_BLOCK_SIZE> adapter; LessThan256CoreRecord core; }; @@ -218,7 +220,7 @@ __global__ void less_than256_tracegen( if (idx < d_records.len()) { auto const &rec = d_records[idx]; - Rv32HeapAdapterExecutor<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS> adapter( + Rv32VecHeapAdapter256 adapter( pointer_max_bits, VariableRangeChecker(d_range_checker_ptr, range_checker_bins), BitwiseOperationLookup(d_bitwise_lookup_ptr, bitwise_num_bits), @@ -265,12 +267,12 @@ extern "C" int _less_than256_tracegen( } template struct BranchLessThan256Cols { - Rv32HeapBranchAdapterCols adapter; + Rv32VecHeapBranchAdapterCols adapter; BranchLessThan256CoreCols core; }; struct BranchLessThan256Record { - Rv32HeapBranchAdapterRecord<2> adapter; + Rv32VecHeapBranchAdapterRecord<2, INT256_NUM_BLOCKS> adapter; BranchLessThan256CoreRecord core; }; @@ -290,7 +292,7 @@ __global__ void branch_less_than256_tracegen( if (idx < d_records.len()) { auto const &rec = d_records[idx]; - Rv32HeapBranchAdapter256 adapter( + Rv32VecHeapBranchAdapter256 adapter( pointer_max_bits, VariableRangeChecker(d_range_checker_ptr, range_checker_bins), BitwiseOperationLookup(d_bitwise_lookup_ptr, bitwise_num_bits), @@ -337,12 +339,12 @@ extern "C" int _branch_less_than256_tracegen( } template struct Shift256Cols { - Rv32HeapAdapterCols adapter; + Rv32VecHeapAdapterCols adapter; Shift256CoreCols core; }; struct Shift256Record { - Rv32HeapAdapterRecord<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS> adapter; + Rv32VecHeapAdapterRecord<2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE, CONST_BLOCK_SIZE> adapter; Shift256CoreRecord core; }; @@ -362,7 +364,7 @@ __global__ void shift256_tracegen( if (idx < d_records.len()) { auto const &rec = d_records[idx]; - Rv32HeapAdapterExecutor<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS> adapter( + Rv32VecHeapAdapter256 adapter( pointer_max_bits, VariableRangeChecker(d_range_checker_ptr, range_checker_bins), BitwiseOperationLookup(d_bitwise_lookup_ptr, bitwise_num_bits), @@ -412,12 +414,12 @@ extern "C" int _shift256_tracegen( } template struct Multiplication256Cols { - Rv32HeapAdapterCols adapter; + Rv32VecHeapAdapterCols adapter; Multiplication256CoreCols core; }; struct Multiplication256Record { - Rv32HeapAdapterRecord<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS> adapter; + Rv32VecHeapAdapterRecord<2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE, CONST_BLOCK_SIZE> adapter; Multiplication256CoreRecord core; }; @@ -439,7 +441,7 @@ __global__ void multiplication256_tracegen( if (idx < d_records.len()) { auto const &rec = d_records[idx]; - Rv32HeapAdapterExecutor<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS> adapter( + Rv32VecHeapAdapter256 adapter( pointer_max_bits, VariableRangeChecker(d_range_checker_ptr, range_checker_bins), BitwiseOperationLookup(d_bitwise_lookup_ptr, bitwise_num_bits), diff --git a/extensions/bigint/circuit/src/base_alu.rs b/extensions/bigint/circuit/src/base_alu.rs index 6a8e49a239..bd640ebf51 100644 --- a/extensions/bigint/circuit/src/base_alu.rs +++ b/extensions/bigint/circuit/src/base_alu.rs @@ -12,20 +12,17 @@ use openvm_instructions::{ riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, LocalOpcode, }; -use openvm_rv32_adapters::Rv32HeapAdapterExecutor; use openvm_rv32im_circuit::BaseAluExecutor; use openvm_rv32im_transpiler::BaseAluOpcode; use openvm_stark_backend::p3_field::PrimeField32; use crate::{ - common::{bytes_to_u64_array, u64_array_to_bytes}, - Rv32BaseAlu256Executor, INT256_NUM_LIMBS, + common::{bytes_to_u64_array, read_int256, u64_array_to_bytes, write_int256}, + AluAdapterExecutor, Rv32BaseAlu256Executor, INT256_NUM_LIMBS, }; -type AdapterExecutor = Rv32HeapAdapterExecutor<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS>; - impl Rv32BaseAlu256Executor { - pub fn new(adapter: AdapterExecutor, offset: usize) -> Self { + pub fn new(adapter: AluAdapterExecutor, offset: usize) -> Self { Self(BaseAluExecutor::new(adapter, offset)) } } @@ -142,12 +139,10 @@ unsafe fn execute_e12_impl( let rs1_ptr = exec_state.vm_read::(RV32_REGISTER_AS, pre_compute.b as u32); let rs2_ptr = exec_state.vm_read::(RV32_REGISTER_AS, pre_compute.c as u32); let rd_ptr = exec_state.vm_read::(RV32_REGISTER_AS, pre_compute.a as u32); - let rs1 = - exec_state.vm_read::(RV32_MEMORY_AS, u32::from_le_bytes(rs1_ptr)); - let rs2 = - exec_state.vm_read::(RV32_MEMORY_AS, u32::from_le_bytes(rs2_ptr)); + let rs1 = read_int256(exec_state, RV32_MEMORY_AS, u32::from_le_bytes(rs1_ptr)); + let rs2 = read_int256(exec_state, RV32_MEMORY_AS, u32::from_le_bytes(rs2_ptr)); let rd = ::compute(rs1, rs2); - exec_state.vm_write(RV32_MEMORY_AS, u32::from_le_bytes(rd_ptr), &rd); + write_int256(exec_state, RV32_MEMORY_AS, u32::from_le_bytes(rd_ptr), &rd); let pc = exec_state.pc(); exec_state.set_pc(pc.wrapping_add(DEFAULT_PC_STEP)); } diff --git a/extensions/bigint/circuit/src/branch_eq.rs b/extensions/bigint/circuit/src/branch_eq.rs index 4732f6f9a7..d71d93abfe 100644 --- a/extensions/bigint/circuit/src/branch_eq.rs +++ b/extensions/bigint/circuit/src/branch_eq.rs @@ -9,17 +9,17 @@ use openvm_instructions::{ riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, LocalOpcode, }; -use openvm_rv32_adapters::Rv32HeapBranchAdapterExecutor; use openvm_rv32im_circuit::BranchEqualExecutor; use openvm_rv32im_transpiler::BranchEqualOpcode; use openvm_stark_backend::p3_field::PrimeField32; -use crate::{common::bytes_to_u64_array, Rv32BranchEqual256Executor, INT256_NUM_LIMBS}; - -type AdapterExecutor = Rv32HeapBranchAdapterExecutor<2, INT256_NUM_LIMBS>; +use crate::{ + common::{bytes_to_u64_array, read_int256}, + BranchAdapterExecutor, Rv32BranchEqual256Executor, INT256_NUM_LIMBS, +}; impl Rv32BranchEqual256Executor { - pub fn new(adapter_step: AdapterExecutor, offset: usize, pc_step: u32) -> Self { + pub fn new(adapter_step: BranchAdapterExecutor, offset: usize, pc_step: u32) -> Self { Self(BranchEqualExecutor::new(adapter_step, offset, pc_step)) } } @@ -131,10 +131,8 @@ unsafe fn execute_e12_impl(RV32_REGISTER_AS, pre_compute.a as u32); let rs2_ptr = exec_state.vm_read::(RV32_REGISTER_AS, pre_compute.b as u32); - let rs1 = - exec_state.vm_read::(RV32_MEMORY_AS, u32::from_le_bytes(rs1_ptr)); - let rs2 = - exec_state.vm_read::(RV32_MEMORY_AS, u32::from_le_bytes(rs2_ptr)); + let rs1 = read_int256(exec_state, RV32_MEMORY_AS, u32::from_le_bytes(rs1_ptr)); + let rs2 = read_int256(exec_state, RV32_MEMORY_AS, u32::from_le_bytes(rs2_ptr)); let cmp_result = u256_eq(rs1, rs2); if cmp_result ^ IS_NE { pc = (pc as isize + pre_compute.imm) as u32; diff --git a/extensions/bigint/circuit/src/branch_lt.rs b/extensions/bigint/circuit/src/branch_lt.rs index 8dc294d70d..e4b83f4663 100644 --- a/extensions/bigint/circuit/src/branch_lt.rs +++ b/extensions/bigint/circuit/src/branch_lt.rs @@ -12,20 +12,17 @@ use openvm_instructions::{ riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, LocalOpcode, }; -use openvm_rv32_adapters::Rv32HeapBranchAdapterExecutor; use openvm_rv32im_circuit::BranchLessThanExecutor; use openvm_rv32im_transpiler::BranchLessThanOpcode; use openvm_stark_backend::p3_field::PrimeField32; use crate::{ - common::{i256_lt, u256_lt}, - Rv32BranchLessThan256Executor, INT256_NUM_LIMBS, + common::{i256_lt, read_int256, u256_lt}, + BranchAdapterExecutor, Rv32BranchLessThan256Executor, INT256_NUM_LIMBS, }; -type AdapterExecutor = Rv32HeapBranchAdapterExecutor<2, INT256_NUM_LIMBS>; - impl Rv32BranchLessThan256Executor { - pub fn new(adapter: AdapterExecutor, offset: usize) -> Self { + pub fn new(adapter: BranchAdapterExecutor, offset: usize) -> Self { Self(BranchLessThanExecutor::new(adapter, offset)) } } @@ -139,10 +136,8 @@ unsafe fn execute_e12_impl(RV32_REGISTER_AS, pre_compute.a as u32); let rs2_ptr = exec_state.vm_read::(RV32_REGISTER_AS, pre_compute.b as u32); - let rs1 = - exec_state.vm_read::(RV32_MEMORY_AS, u32::from_le_bytes(rs1_ptr)); - let rs2 = - exec_state.vm_read::(RV32_MEMORY_AS, u32::from_le_bytes(rs2_ptr)); + let rs1 = read_int256(exec_state, RV32_MEMORY_AS, u32::from_le_bytes(rs1_ptr)); + let rs2 = read_int256(exec_state, RV32_MEMORY_AS, u32::from_le_bytes(rs2_ptr)); let cmp_result = OP::compute(rs1, rs2); if cmp_result { pc = (pc as isize + pre_compute.imm) as u32; diff --git a/extensions/bigint/circuit/src/common.rs b/extensions/bigint/circuit/src/common.rs index 7d5ccb5836..0ec68e118f 100644 --- a/extensions/bigint/circuit/src/common.rs +++ b/extensions/bigint/circuit/src/common.rs @@ -1,4 +1,44 @@ -use crate::{INT256_NUM_LIMBS, RV32_CELL_BITS}; +use openvm_circuit::{ + arch::{ExecutionCtxTrait, VmExecState, CONST_BLOCK_SIZE}, + system::memory::online::GuestMemory, +}; +use openvm_stark_backend::p3_field::PrimeField32; + +use crate::{INT256_NUM_BLOCKS, INT256_NUM_LIMBS, RV32_CELL_BITS}; + +/// Read a 256-bit integer as 8 separate 4-byte block reads. +/// This ensures correct access adapter cost accounting. +#[inline(always)] +pub fn read_int256( + exec_state: &mut VmExecState, + addr_space: u32, + ptr: u32, +) -> [u8; INT256_NUM_LIMBS] { + let mut result = [0u8; INT256_NUM_LIMBS]; + for i in 0..INT256_NUM_BLOCKS { + let block: [u8; CONST_BLOCK_SIZE] = + exec_state.vm_read(addr_space, ptr + (i * CONST_BLOCK_SIZE) as u32); + result[i * CONST_BLOCK_SIZE..(i + 1) * CONST_BLOCK_SIZE].copy_from_slice(&block); + } + result +} + +/// Write a 256-bit integer as 8 separate 4-byte block writes. +/// This ensures correct access adapter cost accounting. +#[inline(always)] +pub fn write_int256( + exec_state: &mut VmExecState, + addr_space: u32, + ptr: u32, + data: &[u8; INT256_NUM_LIMBS], +) { + for i in 0..INT256_NUM_BLOCKS { + let block: [u8; CONST_BLOCK_SIZE] = data[i * CONST_BLOCK_SIZE..(i + 1) * CONST_BLOCK_SIZE] + .try_into() + .unwrap(); + exec_state.vm_write(addr_space, ptr + (i * CONST_BLOCK_SIZE) as u32, &block); + } +} #[inline(always)] pub fn bytes_to_u64_array(bytes: [u8; INT256_NUM_LIMBS]) -> [u64; 4] { diff --git a/extensions/bigint/circuit/src/cuda/mod.rs b/extensions/bigint/circuit/src/cuda/mod.rs index 01d8b3ade2..b020f3f39d 100644 --- a/extensions/bigint/circuit/src/cuda/mod.rs +++ b/extensions/bigint/circuit/src/cuda/mod.rs @@ -1,7 +1,10 @@ use std::{mem::size_of, sync::Arc}; use derive_new::new; -use openvm_circuit::{arch::DenseRecordArena, utils::next_power_of_two_or_zero}; +use openvm_circuit::{ + arch::{DenseRecordArena, CONST_BLOCK_SIZE}, + utils::next_power_of_two_or_zero, +}; use openvm_circuit_primitives::{ bitwise_op_lookup::BitwiseOperationLookupChipGPU, cuda_abi::UInt2, range_tuple::RangeTupleCheckerChipGPU, var_range::VariableRangeCheckerChipGPU, Chip, @@ -9,8 +12,8 @@ use openvm_circuit_primitives::{ use openvm_cuda_backend::{base::DeviceMatrix, prelude::F, GpuBackend}; use openvm_cuda_common::copy::MemCopyH2D; use openvm_rv32_adapters::{ - Rv32HeapBranchAdapterCols, Rv32HeapBranchAdapterRecord, Rv32VecHeapAdapterCols, - Rv32VecHeapAdapterRecord, + Rv32VecHeapAdapterCols, Rv32VecHeapAdapterRecord, Rv32VecHeapBranchAdapterCols, + Rv32VecHeapBranchAdapterRecord, }; use openvm_rv32im_circuit::{ adapters::{INT256_NUM_LIMBS, RV32_CELL_BITS}, @@ -22,11 +25,18 @@ use openvm_stark_backend::prover::AirProvingContext; mod cuda_abi; +use crate::INT256_NUM_BLOCKS; + ////////////////////////////////////////////////////////////////////////////////////// /// ALU ////////////////////////////////////////////////////////////////////////////////////// -pub type BaseAlu256AdapterRecord = - Rv32VecHeapAdapterRecord<2, 1, 1, INT256_NUM_LIMBS, INT256_NUM_LIMBS>; +pub type BaseAlu256AdapterRecord = Rv32VecHeapAdapterRecord< + 2, + INT256_NUM_BLOCKS, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + CONST_BLOCK_SIZE, +>; pub type BaseAlu256CoreRecord = BaseAluCoreRecord; #[derive(new)] @@ -47,7 +57,14 @@ impl Chip for BaseAlu256ChipGpu { debug_assert_eq!(records.len() % RECORD_SIZE, 0); let trace_width = BaseAluCoreCols::::width() - + Rv32VecHeapAdapterCols::::width(); + + Rv32VecHeapAdapterCols::< + F, + 2, + INT256_NUM_BLOCKS, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + CONST_BLOCK_SIZE, + >::width(); let trace_height = next_power_of_two_or_zero(records.len() / RECORD_SIZE); let d_records = records.to_device().unwrap(); @@ -74,7 +91,8 @@ impl Chip for BaseAlu256ChipGpu { ////////////////////////////////////////////////////////////////////////////////////// /// Branch Equal ////////////////////////////////////////////////////////////////////////////////////// -pub type BranchEqual256AdapterRecord = Rv32HeapBranchAdapterRecord<2>; +pub type BranchEqual256AdapterRecord = + Rv32VecHeapBranchAdapterRecord<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>; pub type BranchEqual256CoreRecord = BranchEqualCoreRecord; #[derive(new)] @@ -96,7 +114,7 @@ impl Chip for BranchEqual256ChipGpu { debug_assert_eq!(records.len() % RECORD_SIZE, 0); let trace_width = BranchEqualCoreCols::::width() - + Rv32HeapBranchAdapterCols::::width(); + + Rv32VecHeapBranchAdapterCols::::width(); let trace_height = next_power_of_two_or_zero(records.len() / RECORD_SIZE); let d_records = records.to_device().unwrap(); @@ -123,8 +141,13 @@ impl Chip for BranchEqual256ChipGpu { ////////////////////////////////////////////////////////////////////////////////////// /// Less Than ////////////////////////////////////////////////////////////////////////////////////// -pub type LessThan256AdapterRecord = - Rv32VecHeapAdapterRecord<2, 1, 1, INT256_NUM_LIMBS, INT256_NUM_LIMBS>; +pub type LessThan256AdapterRecord = Rv32VecHeapAdapterRecord< + 2, + INT256_NUM_BLOCKS, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + CONST_BLOCK_SIZE, +>; pub type LessThan256CoreRecord = LessThanCoreRecord; #[derive(new)] @@ -145,7 +168,14 @@ impl Chip for LessThan256ChipGpu { debug_assert_eq!(records.len() % RECORD_SIZE, 0); let trace_width = LessThanCoreCols::::width() - + Rv32VecHeapAdapterCols::::width(); + + Rv32VecHeapAdapterCols::< + F, + 2, + INT256_NUM_BLOCKS, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + CONST_BLOCK_SIZE, + >::width(); let trace_height = next_power_of_two_or_zero(records.len() / RECORD_SIZE); let d_records = records.to_device().unwrap(); @@ -172,7 +202,8 @@ impl Chip for LessThan256ChipGpu { ////////////////////////////////////////////////////////////////////////////////////// /// Branch Less Than ////////////////////////////////////////////////////////////////////////////////////// -pub type BranchLessThan256AdapterRecord = Rv32HeapBranchAdapterRecord<2>; +pub type BranchLessThan256AdapterRecord = + Rv32VecHeapBranchAdapterRecord<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>; pub type BranchLessThan256CoreRecord = BranchLessThanCoreRecord; #[derive(new)] @@ -194,7 +225,7 @@ impl Chip for BranchLessThan256ChipGpu { debug_assert_eq!(records.len() % RECORD_SIZE, 0); let trace_width = BranchLessThanCoreCols::::width() - + Rv32HeapBranchAdapterCols::::width(); + + Rv32VecHeapBranchAdapterCols::::width(); let trace_height = next_power_of_two_or_zero(records.len() / RECORD_SIZE); let d_records = records.to_device().unwrap(); @@ -221,8 +252,13 @@ impl Chip for BranchLessThan256ChipGpu { ////////////////////////////////////////////////////////////////////////////////////// /// Shift ////////////////////////////////////////////////////////////////////////////////////// -pub type Shift256AdapterRecord = - Rv32VecHeapAdapterRecord<2, 1, 1, INT256_NUM_LIMBS, INT256_NUM_LIMBS>; +pub type Shift256AdapterRecord = Rv32VecHeapAdapterRecord< + 2, + INT256_NUM_BLOCKS, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + CONST_BLOCK_SIZE, +>; pub type Shift256CoreRecord = ShiftCoreRecord; #[derive(new)] @@ -243,7 +279,14 @@ impl Chip for Shift256ChipGpu { debug_assert_eq!(records.len() % RECORD_SIZE, 0); let trace_width = ShiftCoreCols::::width() - + Rv32VecHeapAdapterCols::::width(); + + Rv32VecHeapAdapterCols::< + F, + 2, + INT256_NUM_BLOCKS, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + CONST_BLOCK_SIZE, + >::width(); let trace_height = next_power_of_two_or_zero(records.len() / RECORD_SIZE); let d_records = records.to_device().unwrap(); @@ -270,8 +313,13 @@ impl Chip for Shift256ChipGpu { ////////////////////////////////////////////////////////////////////////////////////// /// Multiplication ////////////////////////////////////////////////////////////////////////////////////// -pub type Multiplication256AdapterRecord = - Rv32VecHeapAdapterRecord<2, 1, 1, INT256_NUM_LIMBS, INT256_NUM_LIMBS>; +pub type Multiplication256AdapterRecord = Rv32VecHeapAdapterRecord< + 2, + INT256_NUM_BLOCKS, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + CONST_BLOCK_SIZE, +>; pub type Multiplication256CoreRecord = MultiplicationCoreRecord; #[derive(new)] @@ -294,7 +342,14 @@ impl Chip for Multiplication256ChipGpu { debug_assert_eq!(records.len() % RECORD_SIZE, 0); let trace_width = MultiplicationCoreCols::::width() - + Rv32VecHeapAdapterCols::::width(); + + Rv32VecHeapAdapterCols::< + F, + 2, + INT256_NUM_BLOCKS, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + CONST_BLOCK_SIZE, + >::width(); let trace_height = next_power_of_two_or_zero(records.len() / RECORD_SIZE); let d_records = records.to_device().unwrap(); diff --git a/extensions/bigint/circuit/src/extension/mod.rs b/extensions/bigint/circuit/src/extension/mod.rs index 634eda1f58..3cbd9c8100 100644 --- a/extensions/bigint/circuit/src/extension/mod.rs +++ b/extensions/bigint/circuit/src/extension/mod.rs @@ -27,11 +27,15 @@ use openvm_circuit_primitives::{ }; use openvm_cpu_backend::{CpuBackend, CpuDevice}; use openvm_instructions::{program::DEFAULT_PC_STEP, LocalOpcode}; +use openvm_rv32_adapters::{ + Rv32VecHeapAdapterAir, Rv32VecHeapAdapterExecutor, Rv32VecHeapAdapterFiller, + Rv32VecHeapBranchAdapterAir, Rv32VecHeapBranchAdapterExecutor, Rv32VecHeapBranchAdapterFiller, +}; use openvm_rv32im_circuit::Rv32ImCpuProverExt; use openvm_stark_backend::{p3_field::PrimeField32, StarkEngine, StarkProtocolConfig, Val}; use serde::{Deserialize, Serialize}; -use crate::*; +use crate::{AluAdapterAir, AluAdapterExecutor, BranchAdapterAir, BranchAdapterExecutor, *}; cfg_if::cfg_if! { if #[cfg(feature = "cuda")] { @@ -95,19 +99,19 @@ impl VmExecutionExtension for Int256 { let pointer_max_bits = inventory.pointer_max_bits(); let alu = Rv32BaseAlu256Executor::new( - Rv32HeapAdapterExecutor::new(pointer_max_bits), + AluAdapterExecutor::new(Rv32VecHeapAdapterExecutor::new(pointer_max_bits)), Rv32BaseAlu256Opcode::CLASS_OFFSET, ); inventory.add_executor(alu, Rv32BaseAlu256Opcode::iter().map(|x| x.global_opcode()))?; let lt = Rv32LessThan256Executor::new( - Rv32HeapAdapterExecutor::new(pointer_max_bits), + AluAdapterExecutor::new(Rv32VecHeapAdapterExecutor::new(pointer_max_bits)), Rv32LessThan256Opcode::CLASS_OFFSET, ); inventory.add_executor(lt, Rv32LessThan256Opcode::iter().map(|x| x.global_opcode()))?; let beq = Rv32BranchEqual256Executor::new( - Rv32HeapBranchAdapterExecutor::new(pointer_max_bits), + BranchAdapterExecutor::new(Rv32VecHeapBranchAdapterExecutor::new(pointer_max_bits)), Rv32BranchEqual256Opcode::CLASS_OFFSET, DEFAULT_PC_STEP, ); @@ -117,7 +121,7 @@ impl VmExecutionExtension for Int256 { )?; let blt = Rv32BranchLessThan256Executor::new( - Rv32HeapBranchAdapterExecutor::new(pointer_max_bits), + BranchAdapterExecutor::new(Rv32VecHeapBranchAdapterExecutor::new(pointer_max_bits)), Rv32BranchLessThan256Opcode::CLASS_OFFSET, ); inventory.add_executor( @@ -126,13 +130,13 @@ impl VmExecutionExtension for Int256 { )?; let mult = Rv32Multiplication256Executor::new( - Rv32HeapAdapterExecutor::new(pointer_max_bits), + AluAdapterExecutor::new(Rv32VecHeapAdapterExecutor::new(pointer_max_bits)), Rv32Mul256Opcode::CLASS_OFFSET, ); inventory.add_executor(mult, Rv32Mul256Opcode::iter().map(|x| x.global_opcode()))?; let shift = Rv32Shift256Executor::new( - Rv32HeapAdapterExecutor::new(pointer_max_bits), + AluAdapterExecutor::new(Rv32VecHeapAdapterExecutor::new(pointer_max_bits)), Rv32Shift256Opcode::CLASS_OFFSET, ); inventory.add_executor(shift, Rv32Shift256Opcode::iter().map(|x| x.global_opcode()))?; @@ -185,37 +189,67 @@ impl VmCircuitExtension for Int256 { }; let alu = Rv32BaseAlu256Air::new( - Rv32HeapAdapterAir::new(exec_bridge, memory_bridge, bitwise_lu, pointer_max_bits), + AluAdapterAir::new(Rv32VecHeapAdapterAir::new( + exec_bridge, + memory_bridge, + bitwise_lu, + pointer_max_bits, + )), BaseAluCoreAir::new(bitwise_lu, Rv32BaseAlu256Opcode::CLASS_OFFSET), ); inventory.add_air(alu); let lt = Rv32LessThan256Air::new( - Rv32HeapAdapterAir::new(exec_bridge, memory_bridge, bitwise_lu, pointer_max_bits), + AluAdapterAir::new(Rv32VecHeapAdapterAir::new( + exec_bridge, + memory_bridge, + bitwise_lu, + pointer_max_bits, + )), LessThanCoreAir::new(bitwise_lu, Rv32LessThan256Opcode::CLASS_OFFSET), ); inventory.add_air(lt); let beq = Rv32BranchEqual256Air::new( - Rv32HeapBranchAdapterAir::new(exec_bridge, memory_bridge, bitwise_lu, pointer_max_bits), + BranchAdapterAir::new(Rv32VecHeapBranchAdapterAir::new( + exec_bridge, + memory_bridge, + bitwise_lu, + pointer_max_bits, + )), BranchEqualCoreAir::new(Rv32BranchEqual256Opcode::CLASS_OFFSET, DEFAULT_PC_STEP), ); inventory.add_air(beq); let blt = Rv32BranchLessThan256Air::new( - Rv32HeapBranchAdapterAir::new(exec_bridge, memory_bridge, bitwise_lu, pointer_max_bits), + BranchAdapterAir::new(Rv32VecHeapBranchAdapterAir::new( + exec_bridge, + memory_bridge, + bitwise_lu, + pointer_max_bits, + )), BranchLessThanCoreAir::new(bitwise_lu, Rv32BranchLessThan256Opcode::CLASS_OFFSET), ); inventory.add_air(blt); let mult = Rv32Multiplication256Air::new( - Rv32HeapAdapterAir::new(exec_bridge, memory_bridge, bitwise_lu, pointer_max_bits), + AluAdapterAir::new(Rv32VecHeapAdapterAir::new( + exec_bridge, + memory_bridge, + bitwise_lu, + pointer_max_bits, + )), MultiplicationCoreAir::new(range_tuple_checker, Rv32Mul256Opcode::CLASS_OFFSET), ); inventory.add_air(mult); let shift = Rv32Shift256Air::new( - Rv32HeapAdapterAir::new(exec_bridge, memory_bridge, bitwise_lu, pointer_max_bits), + AluAdapterAir::new(Rv32VecHeapAdapterAir::new( + exec_bridge, + memory_bridge, + bitwise_lu, + pointer_max_bits, + )), ShiftCoreAir::new(bitwise_lu, range_checker, Rv32Shift256Opcode::CLASS_OFFSET), ); inventory.add_air(shift); @@ -279,7 +313,7 @@ where inventory.next_air::()?; let alu = Rv32BaseAlu256Chip::new( BaseAluFiller::new( - Rv32HeapAdapterFiller::new(pointer_max_bits, bitwise_lu.clone()), + Rv32VecHeapAdapterFiller::new(pointer_max_bits, bitwise_lu.clone()), bitwise_lu.clone(), Rv32BaseAlu256Opcode::CLASS_OFFSET, ), @@ -290,7 +324,7 @@ where inventory.next_air::()?; let lt = Rv32LessThan256Chip::new( LessThanFiller::new( - Rv32HeapAdapterFiller::new(pointer_max_bits, bitwise_lu.clone()), + Rv32VecHeapAdapterFiller::new(pointer_max_bits, bitwise_lu.clone()), bitwise_lu.clone(), Rv32LessThan256Opcode::CLASS_OFFSET, ), @@ -301,7 +335,7 @@ where inventory.next_air::()?; let beq = Rv32BranchEqual256Chip::new( BranchEqualFiller::new( - Rv32HeapBranchAdapterFiller::new(pointer_max_bits, bitwise_lu.clone()), + Rv32VecHeapBranchAdapterFiller::new(pointer_max_bits, bitwise_lu.clone()), Rv32BranchEqual256Opcode::CLASS_OFFSET, DEFAULT_PC_STEP, ), @@ -312,7 +346,7 @@ where inventory.next_air::()?; let blt = Rv32BranchLessThan256Chip::new( BranchLessThanFiller::new( - Rv32HeapBranchAdapterFiller::new(pointer_max_bits, bitwise_lu.clone()), + Rv32VecHeapBranchAdapterFiller::new(pointer_max_bits, bitwise_lu.clone()), bitwise_lu.clone(), Rv32BranchLessThan256Opcode::CLASS_OFFSET, ), @@ -323,7 +357,7 @@ where inventory.next_air::()?; let mult = Rv32Multiplication256Chip::new( MultiplicationFiller::new( - Rv32HeapAdapterFiller::new(pointer_max_bits, bitwise_lu.clone()), + Rv32VecHeapAdapterFiller::new(pointer_max_bits, bitwise_lu.clone()), range_tuple_checker.clone(), Rv32Mul256Opcode::CLASS_OFFSET, ), @@ -334,7 +368,7 @@ where inventory.next_air::()?; let shift = Rv32Shift256Chip::new( ShiftFiller::new( - Rv32HeapAdapterFiller::new(pointer_max_bits, bitwise_lu.clone()), + Rv32VecHeapAdapterFiller::new(pointer_max_bits, bitwise_lu.clone()), bitwise_lu.clone(), range_checker.clone(), Rv32Shift256Opcode::CLASS_OFFSET, diff --git a/extensions/bigint/circuit/src/less_than.rs b/extensions/bigint/circuit/src/less_than.rs index 68861d8ba0..b83bd59e43 100644 --- a/extensions/bigint/circuit/src/less_than.rs +++ b/extensions/bigint/circuit/src/less_than.rs @@ -12,17 +12,17 @@ use openvm_instructions::{ riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, LocalOpcode, }; -use openvm_rv32_adapters::Rv32HeapAdapterExecutor; use openvm_rv32im_circuit::LessThanExecutor; use openvm_rv32im_transpiler::LessThanOpcode; use openvm_stark_backend::p3_field::PrimeField32; -use crate::{common, Rv32LessThan256Executor, INT256_NUM_LIMBS}; - -type AdapterExecutor = Rv32HeapAdapterExecutor<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS>; +use crate::{ + common::{self, read_int256, write_int256}, + AluAdapterExecutor, Rv32LessThan256Executor, INT256_NUM_LIMBS, +}; impl Rv32LessThan256Executor { - pub fn new(adapter: AdapterExecutor, offset: usize) -> Self { + pub fn new(adapter: AluAdapterExecutor, offset: usize) -> Self { Self(LessThanExecutor::new(adapter, offset)) } } @@ -134,10 +134,8 @@ unsafe fn execute_e12_impl(RV32_REGISTER_AS, pre_compute.b as u32); let rs2_ptr = exec_state.vm_read::(RV32_REGISTER_AS, pre_compute.c as u32); let rd_ptr = exec_state.vm_read::(RV32_REGISTER_AS, pre_compute.a as u32); - let rs1 = - exec_state.vm_read::(RV32_MEMORY_AS, u32::from_le_bytes(rs1_ptr)); - let rs2 = - exec_state.vm_read::(RV32_MEMORY_AS, u32::from_le_bytes(rs2_ptr)); + let rs1 = read_int256(exec_state, RV32_MEMORY_AS, u32::from_le_bytes(rs1_ptr)); + let rs2 = read_int256(exec_state, RV32_MEMORY_AS, u32::from_le_bytes(rs2_ptr)); let cmp_result = if IS_U256 { common::u256_lt(rs1, rs2) } else { @@ -145,7 +143,7 @@ unsafe fn execute_e12_impl, - BaseAluCoreAir, +/// Number of blocks for INT256 operations (INT256_NUM_LIMBS / CONST_BLOCK_SIZE) +pub const INT256_NUM_BLOCKS: usize = INT256_NUM_LIMBS / CONST_BLOCK_SIZE; + +/// Type alias for the ALU adapter AIR wrapper +type AluAdapterAir = VecToFlatAluAdapterAir< + Rv32VecHeapAdapterAir< + 2, + INT256_NUM_BLOCKS, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + CONST_BLOCK_SIZE, + >, + 2, + INT256_NUM_BLOCKS, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + INT256_NUM_LIMBS, + INT256_NUM_LIMBS, +>; + +/// Type alias for the ALU adapter executor wrapper +type AluAdapterExecutor = VecToFlatAluAdapterExecutor< + Rv32VecHeapAdapterExecutor< + 2, + INT256_NUM_BLOCKS, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + CONST_BLOCK_SIZE, + >, + 2, + INT256_NUM_BLOCKS, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + INT256_NUM_LIMBS, + INT256_NUM_LIMBS, +>; + +/// Type alias for the Branch adapter AIR wrapper +type BranchAdapterAir = VecToFlatBranchAdapterAir< + Rv32VecHeapBranchAdapterAir<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>, + 2, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + INT256_NUM_LIMBS, +>; + +/// Type alias for the Branch adapter executor wrapper +type BranchAdapterExecutor = VecToFlatBranchAdapterExecutor< + Rv32VecHeapBranchAdapterExecutor<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>, + 2, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + INT256_NUM_LIMBS, >; + +/// BaseAlu256 +pub type Rv32BaseAlu256Air = + VmAirWrapper>; #[derive(Clone, PreflightExecutor)] pub struct Rv32BaseAlu256Executor( - BaseAluExecutor< - Rv32HeapAdapterExecutor<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS>, - INT256_NUM_LIMBS, - RV32_CELL_BITS, - >, + BaseAluExecutor, ); pub type Rv32BaseAlu256Chip = VmChipWrapper< F, BaseAluFiller< - Rv32HeapAdapterFiller<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS>, + Rv32VecHeapAdapterFiller< + 2, + INT256_NUM_BLOCKS, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + CONST_BLOCK_SIZE, + >, INT256_NUM_LIMBS, RV32_CELL_BITS, >, >; /// LessThan256 -pub type Rv32LessThan256Air = VmAirWrapper< - Rv32HeapAdapterAir<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS>, - LessThanCoreAir, ->; +pub type Rv32LessThan256Air = + VmAirWrapper>; #[derive(Clone, PreflightExecutor)] pub struct Rv32LessThan256Executor( - LessThanExecutor< - Rv32HeapAdapterExecutor<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS>, - INT256_NUM_LIMBS, - RV32_CELL_BITS, - >, + LessThanExecutor, ); pub type Rv32LessThan256Chip = VmChipWrapper< F, LessThanFiller< - Rv32HeapAdapterFiller<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS>, + Rv32VecHeapAdapterFiller< + 2, + INT256_NUM_BLOCKS, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + CONST_BLOCK_SIZE, + >, INT256_NUM_LIMBS, RV32_CELL_BITS, >, >; /// Multiplication256 -pub type Rv32Multiplication256Air = VmAirWrapper< - Rv32HeapAdapterAir<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS>, - MultiplicationCoreAir, ->; +pub type Rv32Multiplication256Air = + VmAirWrapper>; #[derive(Clone, PreflightExecutor)] pub struct Rv32Multiplication256Executor( - MultiplicationExecutor< - Rv32HeapAdapterExecutor<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS>, - INT256_NUM_LIMBS, - RV32_CELL_BITS, - >, + MultiplicationExecutor, ); pub type Rv32Multiplication256Chip = VmChipWrapper< F, MultiplicationFiller< - Rv32HeapAdapterFiller<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS>, + Rv32VecHeapAdapterFiller< + 2, + INT256_NUM_BLOCKS, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + CONST_BLOCK_SIZE, + >, INT256_NUM_LIMBS, RV32_CELL_BITS, >, >; /// Shift256 -pub type Rv32Shift256Air = VmAirWrapper< - Rv32HeapAdapterAir<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS>, - ShiftCoreAir, ->; +pub type Rv32Shift256Air = + VmAirWrapper>; #[derive(Clone, PreflightExecutor)] pub struct Rv32Shift256Executor( - ShiftExecutor< - Rv32HeapAdapterExecutor<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS>, - INT256_NUM_LIMBS, - RV32_CELL_BITS, - >, + ShiftExecutor, ); pub type Rv32Shift256Chip = VmChipWrapper< F, ShiftFiller< - Rv32HeapAdapterFiller<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS>, + Rv32VecHeapAdapterFiller< + 2, + INT256_NUM_BLOCKS, + INT256_NUM_BLOCKS, + CONST_BLOCK_SIZE, + CONST_BLOCK_SIZE, + >, INT256_NUM_LIMBS, RV32_CELL_BITS, >, >; /// BranchEqual256 -pub type Rv32BranchEqual256Air = VmAirWrapper< - Rv32HeapBranchAdapterAir<2, INT256_NUM_LIMBS>, - BranchEqualCoreAir, ->; +pub type Rv32BranchEqual256Air = + VmAirWrapper>; #[derive(Clone, PreflightExecutor)] -pub struct Rv32BranchEqual256Executor( - BranchEqualExecutor, INT256_NUM_LIMBS>, -); +pub struct Rv32BranchEqual256Executor(BranchEqualExecutor); pub type Rv32BranchEqual256Chip = VmChipWrapper< F, - BranchEqualFiller, INT256_NUM_LIMBS>, + BranchEqualFiller< + Rv32VecHeapBranchAdapterFiller<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>, + INT256_NUM_LIMBS, + >, >; /// BranchLessThan256 -pub type Rv32BranchLessThan256Air = VmAirWrapper< - Rv32HeapBranchAdapterAir<2, INT256_NUM_LIMBS>, - BranchLessThanCoreAir, ->; +pub type Rv32BranchLessThan256Air = + VmAirWrapper>; #[derive(Clone, PreflightExecutor)] pub struct Rv32BranchLessThan256Executor( - BranchLessThanExecutor< - Rv32HeapBranchAdapterExecutor<2, INT256_NUM_LIMBS>, - INT256_NUM_LIMBS, - RV32_CELL_BITS, - >, + BranchLessThanExecutor, ); pub type Rv32BranchLessThan256Chip = VmChipWrapper< F, BranchLessThanFiller< - Rv32HeapBranchAdapterFiller<2, INT256_NUM_LIMBS>, + Rv32VecHeapBranchAdapterFiller<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>, INT256_NUM_LIMBS, RV32_CELL_BITS, >, diff --git a/extensions/bigint/circuit/src/mult.rs b/extensions/bigint/circuit/src/mult.rs index 02eeafa383..424d20a2b4 100644 --- a/extensions/bigint/circuit/src/mult.rs +++ b/extensions/bigint/circuit/src/mult.rs @@ -9,20 +9,17 @@ use openvm_instructions::{ riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, LocalOpcode, }; -use openvm_rv32_adapters::Rv32HeapAdapterExecutor; use openvm_rv32im_circuit::MultiplicationExecutor; use openvm_rv32im_transpiler::MulOpcode; use openvm_stark_backend::p3_field::PrimeField32; use crate::{ - common::{bytes_to_u32_array, u32_array_to_bytes}, - Rv32Multiplication256Executor, INT256_NUM_LIMBS, + common::{bytes_to_u32_array, read_int256, u32_array_to_bytes, write_int256}, + AluAdapterExecutor, Rv32Multiplication256Executor, INT256_NUM_LIMBS, }; -type AdapterExecutor = Rv32HeapAdapterExecutor<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS>; - impl Rv32Multiplication256Executor { - pub fn new(adapter: AdapterExecutor, offset: usize) -> Self { + pub fn new(adapter: AluAdapterExecutor, offset: usize) -> Self { Self(MultiplicationExecutor::new(adapter, offset)) } } @@ -125,12 +122,10 @@ unsafe fn execute_e12_impl( let rs1_ptr = exec_state.vm_read::(RV32_REGISTER_AS, pre_compute.b as u32); let rs2_ptr = exec_state.vm_read::(RV32_REGISTER_AS, pre_compute.c as u32); let rd_ptr = exec_state.vm_read::(RV32_REGISTER_AS, pre_compute.a as u32); - let rs1 = - exec_state.vm_read::(RV32_MEMORY_AS, u32::from_le_bytes(rs1_ptr)); - let rs2 = - exec_state.vm_read::(RV32_MEMORY_AS, u32::from_le_bytes(rs2_ptr)); + let rs1 = read_int256(exec_state, RV32_MEMORY_AS, u32::from_le_bytes(rs1_ptr)); + let rs2 = read_int256(exec_state, RV32_MEMORY_AS, u32::from_le_bytes(rs2_ptr)); let rd = u256_mul(rs1, rs2); - exec_state.vm_write(RV32_MEMORY_AS, u32::from_le_bytes(rd_ptr), &rd); + write_int256(exec_state, RV32_MEMORY_AS, u32::from_le_bytes(rd_ptr), &rd); let pc = exec_state.pc(); exec_state.set_pc(pc.wrapping_add(DEFAULT_PC_STEP)); diff --git a/extensions/bigint/circuit/src/shift.rs b/extensions/bigint/circuit/src/shift.rs index f0fee73e3a..bc65019762 100644 --- a/extensions/bigint/circuit/src/shift.rs +++ b/extensions/bigint/circuit/src/shift.rs @@ -12,20 +12,17 @@ use openvm_instructions::{ riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, LocalOpcode, }; -use openvm_rv32_adapters::Rv32HeapAdapterExecutor; use openvm_rv32im_circuit::ShiftExecutor; use openvm_rv32im_transpiler::ShiftOpcode; use openvm_stark_backend::p3_field::PrimeField32; use crate::{ - common::{bytes_to_u64_array, u64_array_to_bytes}, - Rv32Shift256Executor, INT256_NUM_LIMBS, + common::{bytes_to_u64_array, read_int256, u64_array_to_bytes, write_int256}, + AluAdapterExecutor, Rv32Shift256Executor, INT256_NUM_LIMBS, }; -type AdapterExecutor = Rv32HeapAdapterExecutor<2, INT256_NUM_LIMBS, INT256_NUM_LIMBS>; - impl Rv32Shift256Executor { - pub fn new(adapter: AdapterExecutor, offset: usize) -> Self { + pub fn new(adapter: AluAdapterExecutor, offset: usize) -> Self { Self(ShiftExecutor::new(adapter, offset)) } } @@ -138,12 +135,10 @@ unsafe fn execute_e12_impl let rs1_ptr = exec_state.vm_read::(RV32_REGISTER_AS, pre_compute.b as u32); let rs2_ptr = exec_state.vm_read::(RV32_REGISTER_AS, pre_compute.c as u32); let rd_ptr = exec_state.vm_read::(RV32_REGISTER_AS, pre_compute.a as u32); - let rs1 = - exec_state.vm_read::(RV32_MEMORY_AS, u32::from_le_bytes(rs1_ptr)); - let rs2 = - exec_state.vm_read::(RV32_MEMORY_AS, u32::from_le_bytes(rs2_ptr)); + let rs1 = read_int256(exec_state, RV32_MEMORY_AS, u32::from_le_bytes(rs1_ptr)); + let rs2 = read_int256(exec_state, RV32_MEMORY_AS, u32::from_le_bytes(rs2_ptr)); let rd = OP::compute(rs1, rs2); - exec_state.vm_write(RV32_MEMORY_AS, u32::from_le_bytes(rd_ptr), &rd); + write_int256(exec_state, RV32_MEMORY_AS, u32::from_le_bytes(rd_ptr), &rd); let pc = exec_state.pc(); exec_state.set_pc(pc.wrapping_add(DEFAULT_PC_STEP)); } diff --git a/extensions/bigint/circuit/src/tests.rs b/extensions/bigint/circuit/src/tests.rs index 436d228e8b..d00b109e72 100644 --- a/extensions/bigint/circuit/src/tests.rs +++ b/extensions/bigint/circuit/src/tests.rs @@ -26,9 +26,9 @@ use openvm_instructions::{ LocalOpcode, }; use openvm_rv32_adapters::{ - rv32_heap_branch_default, rv32_write_heap_default, Rv32HeapAdapterAir, Rv32HeapAdapterExecutor, - Rv32HeapAdapterFiller, Rv32HeapBranchAdapterAir, Rv32HeapBranchAdapterExecutor, - Rv32HeapBranchAdapterFiller, + rv32_heap_branch_default, rv32_write_heap_default, Rv32VecHeapAdapterAir, + Rv32VecHeapAdapterExecutor, Rv32VecHeapAdapterFiller, Rv32VecHeapBranchAdapterAir, + Rv32VecHeapBranchAdapterExecutor, Rv32VecHeapBranchAdapterFiller, }; use openvm_rv32im_circuit::{ adapters::{INT256_NUM_LIMBS, RV_B_TYPE_IMM_BITS}, @@ -63,12 +63,12 @@ use { }; use crate::{ - Rv32BaseAlu256Air, Rv32BaseAlu256Chip, Rv32BaseAlu256Executor, Rv32BranchEqual256Air, - Rv32BranchEqual256Chip, Rv32BranchEqual256Executor, Rv32BranchLessThan256Air, - Rv32BranchLessThan256Chip, Rv32BranchLessThan256Executor, Rv32LessThan256Air, - Rv32LessThan256Chip, Rv32LessThan256Executor, Rv32Multiplication256Air, - Rv32Multiplication256Chip, Rv32Multiplication256Executor, Rv32Shift256Air, Rv32Shift256Chip, - Rv32Shift256Executor, + AluAdapterAir, AluAdapterExecutor, BranchAdapterAir, BranchAdapterExecutor, Rv32BaseAlu256Air, + Rv32BaseAlu256Chip, Rv32BaseAlu256Executor, Rv32BranchEqual256Air, Rv32BranchEqual256Chip, + Rv32BranchEqual256Executor, Rv32BranchLessThan256Air, Rv32BranchLessThan256Chip, + Rv32BranchLessThan256Executor, Rv32LessThan256Air, Rv32LessThan256Chip, + Rv32LessThan256Executor, Rv32Multiplication256Air, Rv32Multiplication256Chip, + Rv32Multiplication256Executor, Rv32Shift256Air, Rv32Shift256Chip, Rv32Shift256Executor, }; type F = BabyBear; @@ -91,21 +91,21 @@ fn create_alu_harness_fields( Rv32BaseAlu256Chip, ) { let air = Rv32BaseAlu256Air::new( - Rv32HeapAdapterAir::new( + AluAdapterAir::new(Rv32VecHeapAdapterAir::new( execution_bridge, memory_bridge, bitwise_chip.bus(), address_bits, - ), + )), BaseAluCoreAir::new(bitwise_chip.bus(), Rv32BaseAlu256Opcode::CLASS_OFFSET), ); let executor = Rv32BaseAlu256Executor::new( - Rv32HeapAdapterExecutor::new(address_bits), + AluAdapterExecutor::new(Rv32VecHeapAdapterExecutor::new(address_bits)), Rv32BaseAlu256Opcode::CLASS_OFFSET, ); let chip = Rv32BaseAlu256Chip::new( BaseAluFiller::new( - Rv32HeapAdapterFiller::new(address_bits, bitwise_chip.clone()), + Rv32VecHeapAdapterFiller::new(address_bits, bitwise_chip.clone()), bitwise_chip, Rv32BaseAlu256Opcode::CLASS_OFFSET, ), @@ -126,21 +126,21 @@ fn create_lt_harness_fields( Rv32LessThan256Chip, ) { let air = Rv32LessThan256Air::new( - Rv32HeapAdapterAir::new( + AluAdapterAir::new(Rv32VecHeapAdapterAir::new( execution_bridge, memory_bridge, bitwise_chip.bus(), address_bits, - ), + )), LessThanCoreAir::new(bitwise_chip.bus(), Rv32LessThan256Opcode::CLASS_OFFSET), ); let executor = Rv32LessThan256Executor::new( - Rv32HeapAdapterExecutor::new(address_bits), + AluAdapterExecutor::new(Rv32VecHeapAdapterExecutor::new(address_bits)), Rv32LessThan256Opcode::CLASS_OFFSET, ); let chip = Rv32LessThan256Chip::new( LessThanFiller::new( - Rv32HeapAdapterFiller::new(address_bits, bitwise_chip.clone()), + Rv32VecHeapAdapterFiller::new(address_bits, bitwise_chip.clone()), bitwise_chip.clone(), Rv32LessThan256Opcode::CLASS_OFFSET, ), @@ -162,21 +162,21 @@ fn create_mul_harness_fields( Rv32Multiplication256Chip, ) { let air = Rv32Multiplication256Air::new( - Rv32HeapAdapterAir::new( + AluAdapterAir::new(Rv32VecHeapAdapterAir::new( execution_bridge, memory_bridge, bitwise_chip.bus(), address_bits, - ), + )), MultiplicationCoreAir::new(*range_tuple_chip.bus(), Rv32Mul256Opcode::CLASS_OFFSET), ); let executor = Rv32Multiplication256Executor::new( - Rv32HeapAdapterExecutor::new(address_bits), + AluAdapterExecutor::new(Rv32VecHeapAdapterExecutor::new(address_bits)), Rv32Mul256Opcode::CLASS_OFFSET, ); let chip = Rv32Multiplication256Chip::::new( MultiplicationFiller::new( - Rv32HeapAdapterFiller::new(address_bits, bitwise_chip), + Rv32VecHeapAdapterFiller::new(address_bits, bitwise_chip), range_tuple_chip, Rv32Mul256Opcode::CLASS_OFFSET, ), @@ -194,12 +194,12 @@ fn create_shift_harness_fields( address_bits: usize, ) -> (Rv32Shift256Air, Rv32Shift256Executor, Rv32Shift256Chip) { let air = Rv32Shift256Air::new( - Rv32HeapAdapterAir::new( + AluAdapterAir::new(Rv32VecHeapAdapterAir::new( execution_bridge, memory_bridge, bitwise_chip.bus(), address_bits, - ), + )), ShiftCoreAir::new( bitwise_chip.bus(), range_checker_chip.bus(), @@ -207,12 +207,12 @@ fn create_shift_harness_fields( ), ); let executor = Rv32Shift256Executor::new( - Rv32HeapAdapterExecutor::new(address_bits), + AluAdapterExecutor::new(Rv32VecHeapAdapterExecutor::new(address_bits)), Rv32Shift256Opcode::CLASS_OFFSET, ); let chip = Rv32Shift256Chip::new( ShiftFiller::new( - Rv32HeapAdapterFiller::new(address_bits, bitwise_chip.clone()), + Rv32VecHeapAdapterFiller::new(address_bits, bitwise_chip.clone()), bitwise_chip.clone(), range_checker_chip.clone(), Rv32Shift256Opcode::CLASS_OFFSET, @@ -234,22 +234,22 @@ fn create_beq_harness_fields( Rv32BranchEqual256Chip, ) { let air = Rv32BranchEqual256Air::new( - Rv32HeapBranchAdapterAir::new( + BranchAdapterAir::new(Rv32VecHeapBranchAdapterAir::new( execution_bridge, memory_bridge, bitwise_chip.bus(), address_bits, - ), + )), BranchEqualCoreAir::new(Rv32BranchEqual256Opcode::CLASS_OFFSET, DEFAULT_PC_STEP), ); let executor = Rv32BranchEqual256Executor::new( - Rv32HeapBranchAdapterExecutor::new(address_bits), + BranchAdapterExecutor::new(Rv32VecHeapBranchAdapterExecutor::new(address_bits)), Rv32BranchEqual256Opcode::CLASS_OFFSET, DEFAULT_PC_STEP, ); let chip = Rv32BranchEqual256Chip::new( BranchEqualFiller::new( - Rv32HeapBranchAdapterFiller::new(address_bits, bitwise_chip), + Rv32VecHeapBranchAdapterFiller::new(address_bits, bitwise_chip), Rv32BranchEqual256Opcode::CLASS_OFFSET, DEFAULT_PC_STEP, ), @@ -270,24 +270,24 @@ fn create_blt_harness_fields( Rv32BranchLessThan256Chip, ) { let air = Rv32BranchLessThan256Air::new( - Rv32HeapBranchAdapterAir::new( + BranchAdapterAir::new(Rv32VecHeapBranchAdapterAir::new( execution_bridge, memory_bridge, bitwise_chip.bus(), address_bits, - ), + )), BranchLessThanCoreAir::new( bitwise_chip.bus(), Rv32BranchLessThan256Opcode::CLASS_OFFSET, ), ); let executor = Rv32BranchLessThan256Executor::new( - Rv32HeapBranchAdapterExecutor::new(address_bits), + BranchAdapterExecutor::new(Rv32VecHeapBranchAdapterExecutor::new(address_bits)), Rv32BranchLessThan256Opcode::CLASS_OFFSET, ); let chip = Rv32BranchLessThan256Chip::new( BranchLessThanFiller::new( - Rv32HeapBranchAdapterFiller::new(address_bits, bitwise_chip.clone()), + Rv32VecHeapBranchAdapterFiller::new(address_bits, bitwise_chip.clone()), bitwise_chip, Rv32BranchLessThan256Opcode::CLASS_OFFSET, ), @@ -667,7 +667,7 @@ fn run_alu_256_rand_test_cuda(opcode: BaseAluOpcode, num_ops: usize) { .get_record_seeker::() .transfer_to_matrix_arena( &mut harness.matrix_arena, - EmptyAdapterCoreLayout::>::new(), + EmptyAdapterCoreLayout::::new(), ); tester @@ -728,7 +728,7 @@ fn run_lt_256_rand_test_cuda(opcode: LessThanOpcode, num_ops: usize) { .get_record_seeker::() .transfer_to_matrix_arena( &mut harness.matrix_arena, - EmptyAdapterCoreLayout::>::new(), + EmptyAdapterCoreLayout::::new(), ); tester @@ -794,7 +794,7 @@ fn run_mul_256_rand_test_cuda(opcode: MulOpcode, num_ops: usize) { .get_record_seeker::() .transfer_to_matrix_arena( &mut harness.matrix_arena, - EmptyAdapterCoreLayout::>::new(), + EmptyAdapterCoreLayout::::new(), ); tester @@ -856,7 +856,7 @@ fn run_shift_256_rand_test_cuda(opcode: ShiftOpcode, num_ops: usize) { .get_record_seeker::() .transfer_to_matrix_arena( &mut harness.matrix_arena, - EmptyAdapterCoreLayout::>::new(), + EmptyAdapterCoreLayout::::new(), ); tester @@ -917,7 +917,10 @@ fn run_beq_256_rand_test_cuda(opcode: BranchEqualOpcode, num_ops: usize) { .get_record_seeker::() .transfer_to_matrix_arena( &mut harness.matrix_arena, - EmptyAdapterCoreLayout::>::new(), + EmptyAdapterCoreLayout::< + F, + Rv32VecHeapBranchAdapterExecutor<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>, + >::new(), ); tester @@ -980,7 +983,10 @@ fn run_blt_256_rand_test_cuda(opcode: BranchLessThanOpcode, num_ops: usize) { .get_record_seeker::() .transfer_to_matrix_arena( &mut harness.matrix_arena, - EmptyAdapterCoreLayout::>::new(), + EmptyAdapterCoreLayout::< + F, + Rv32VecHeapBranchAdapterExecutor<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>, + >::new(), ); tester diff --git a/extensions/rv32-adapters/cuda/include/rv32-adapters/heap.cuh b/extensions/rv32-adapters/cuda/include/rv32-adapters/heap.cuh deleted file mode 100644 index 98ed20857e..0000000000 --- a/extensions/rv32-adapters/cuda/include/rv32-adapters/heap.cuh +++ /dev/null @@ -1,15 +0,0 @@ -#pragma once - -#include "vec_heap.cuh" - -using namespace riscv; - -// Simple heap adapter - just type aliases for vec_heap with BLOCKS_PER_READ=1, BLOCKS_PER_WRITE=1 -template -using Rv32HeapAdapterCols = Rv32VecHeapAdapterCols; - -template -using Rv32HeapAdapterRecord = Rv32VecHeapAdapterRecord; - -template -using Rv32HeapAdapterExecutor = Rv32VecHeapAdapter; \ No newline at end of file diff --git a/extensions/rv32-adapters/cuda/include/rv32-adapters/vec_heap.cuh b/extensions/rv32-adapters/cuda/include/rv32-adapters/vec_heap.cuh index 88fe5d711c..6441a729a3 100644 --- a/extensions/rv32-adapters/cuda/include/rv32-adapters/vec_heap.cuh +++ b/extensions/rv32-adapters/cuda/include/rv32-adapters/vec_heap.cuh @@ -171,3 +171,13 @@ struct Rv32VecHeapAdapter { COL_WRITE_VALUE(row, Cols, from_state.pc, record.from_pc); } }; + +// Type aliases for the simple case with BLOCKS_PER_READ=1, BLOCKS_PER_WRITE=1 +template +using Rv32HeapAdapterCols = Rv32VecHeapAdapterCols; + +template +using Rv32HeapAdapterRecord = Rv32VecHeapAdapterRecord; + +template +using Rv32HeapAdapterExecutor = Rv32VecHeapAdapter; diff --git a/extensions/rv32-adapters/cuda/include/rv32-adapters/heap_branch.cuh b/extensions/rv32-adapters/cuda/include/rv32-adapters/vec_heap_branch.cuh similarity index 56% rename from extensions/rv32-adapters/cuda/include/rv32-adapters/heap_branch.cuh rename to extensions/rv32-adapters/cuda/include/rv32-adapters/vec_heap_branch.cuh index 845eac43e0..ae4585a167 100644 --- a/extensions/rv32-adapters/cuda/include/rv32-adapters/heap_branch.cuh +++ b/extensions/rv32-adapters/cuda/include/rv32-adapters/vec_heap_branch.cuh @@ -7,17 +7,19 @@ using namespace riscv; -template struct Rv32HeapBranchAdapterCols { +template +struct Rv32VecHeapBranchAdapterCols { ExecutionState from_state; T rs_ptr[NUM_READS]; T rs_val[NUM_READS][RV32_REGISTER_NUM_LIMBS]; MemoryReadAuxCols rs_read_aux[NUM_READS]; - MemoryReadAuxCols heap_read_aux[NUM_READS]; + MemoryReadAuxCols heap_read_aux[NUM_READS][BLOCKS_PER_READ]; }; -template struct Rv32HeapBranchAdapterRecord { +template +struct Rv32VecHeapBranchAdapterRecord { uint32_t from_pc; uint32_t from_timestamp; @@ -25,10 +27,11 @@ template struct Rv32HeapBranchAdapterRecord { uint32_t rs_vals[NUM_READS]; MemoryReadAuxRecord rs_read_aux[NUM_READS]; - MemoryReadAuxRecord heap_read_aux[NUM_READS]; + MemoryReadAuxRecord heap_read_aux[NUM_READS][BLOCKS_PER_READ]; }; -template struct Rv32HeapBranchAdapter { +template +struct Rv32VecHeapBranchAdapter { size_t pointer_max_bits; BitwiseOperationLookup bitwise_lookup; MemoryAuxColsFactory mem_helper; @@ -36,7 +39,7 @@ template struct Rv32HeapBranchAdapter { static constexpr size_t RV32_REGISTER_TOTAL_BITS = RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS; static constexpr size_t MSL_SHIFT = RV32_CELL_BITS * (RV32_REGISTER_NUM_LIMBS - 1); - __device__ Rv32HeapBranchAdapter( + __device__ Rv32VecHeapBranchAdapter( size_t pointer_max_bits, VariableRangeChecker range_checker, BitwiseOperationLookup bitwise_lookup, @@ -45,9 +48,13 @@ template struct Rv32HeapBranchAdapter { : pointer_max_bits(pointer_max_bits), bitwise_lookup(bitwise_lookup), mem_helper(range_checker, timestamp_max_bits) {} - template using Cols = Rv32HeapBranchAdapterCols; + template + using Cols = Rv32VecHeapBranchAdapterCols; - __device__ void fill_trace_row(RowSlice row, Rv32HeapBranchAdapterRecord record) { + __device__ void fill_trace_row( + RowSlice row, + Rv32VecHeapBranchAdapterRecord record + ) { const size_t limb_shift_bits = RV32_REGISTER_TOTAL_BITS - pointer_max_bits; bitwise_lookup.add_range( @@ -55,19 +62,25 @@ template struct Rv32HeapBranchAdapter { NUM_READS > 1 ? (record.rs_vals[1] >> MSL_SHIFT) << limb_shift_bits : 0 ); + uint32_t timestamp = record.from_timestamp + NUM_READS + NUM_READS * BLOCKS_PER_READ; + for (int i = NUM_READS - 1; i >= 0; i--) { - mem_helper.fill( - row.slice_from(COL_INDEX(Cols, heap_read_aux[i])), - record.heap_read_aux[i].prev_timestamp, - record.from_timestamp + (i + NUM_READS) - ); + for (int j = BLOCKS_PER_READ - 1; j >= 0; j--) { + timestamp--; + mem_helper.fill( + row.slice_from(COL_INDEX(Cols, heap_read_aux[i][j])), + record.heap_read_aux[i][j].prev_timestamp, + timestamp + ); + } } for (int i = NUM_READS - 1; i >= 0; i--) { + timestamp--; mem_helper.fill( row.slice_from(COL_INDEX(Cols, rs_read_aux[i])), record.rs_read_aux[i].prev_timestamp, - record.from_timestamp + i + timestamp ); } @@ -83,3 +96,13 @@ template struct Rv32HeapBranchAdapter { COL_WRITE_VALUE(row, Cols, from_state.pc, record.from_pc); } }; + +// Type aliases for the simple case with BLOCKS_PER_READ=1 +template +using Rv32HeapBranchAdapterCols = Rv32VecHeapBranchAdapterCols; + +template +using Rv32HeapBranchAdapterRecord = Rv32VecHeapBranchAdapterRecord; + +template +using Rv32HeapBranchAdapter = Rv32VecHeapBranchAdapter; diff --git a/extensions/rv32-adapters/src/heap.rs b/extensions/rv32-adapters/src/heap.rs deleted file mode 100644 index 10409d97e9..0000000000 --- a/extensions/rv32-adapters/src/heap.rs +++ /dev/null @@ -1,185 +0,0 @@ -use std::borrow::Borrow; - -use openvm_circuit::{ - arch::{ - AdapterAirContext, AdapterTraceExecutor, AdapterTraceFiller, BasicAdapterInterface, - ExecutionBridge, MinimalInstruction, VmAdapterAir, - }, - system::memory::{offline_checker::MemoryBridge, online::TracingMemory, MemoryAuxColsFactory}, -}; -use openvm_circuit_primitives::bitwise_op_lookup::{ - BitwiseOperationLookupBus, SharedBitwiseOperationLookupChip, -}; -use openvm_instructions::{ - instruction::Instruction, - riscv::{RV32_CELL_BITS, RV32_REGISTER_NUM_LIMBS}, -}; -use openvm_stark_backend::{ - interaction::InteractionBuilder, - p3_air::BaseAir, - p3_field::{Field, PrimeField32}, -}; - -use crate::{ - Rv32VecHeapAdapterAir, Rv32VecHeapAdapterCols, Rv32VecHeapAdapterExecutor, - Rv32VecHeapAdapterFiller, Rv32VecHeapAdapterRecord, -}; - -/// This adapter reads from NUM_READS <= 2 pointers and writes to 1 pointer. -/// * The data is read from the heap (address space 2), and the pointers are read from registers -/// (address space 1). -/// * Reads are from the addresses in `rs[0]` (and `rs[1]` if `R = 2`). -/// * Writes are to the address in `rd`. - -#[derive(Clone, Copy, Debug, derive_new::new)] -pub struct Rv32HeapAdapterAir< - const NUM_READS: usize, - const READ_SIZE: usize, - const WRITE_SIZE: usize, -> { - pub(super) execution_bridge: ExecutionBridge, - pub(super) memory_bridge: MemoryBridge, - pub bus: BitwiseOperationLookupBus, - /// The max number of bits for an address in memory - address_bits: usize, -} - -impl BaseAir - for Rv32HeapAdapterAir -{ - fn width(&self) -> usize { - Rv32VecHeapAdapterCols::::width() - } -} - -impl< - AB: InteractionBuilder, - const NUM_READS: usize, - const READ_SIZE: usize, - const WRITE_SIZE: usize, - > VmAdapterAir for Rv32HeapAdapterAir -{ - type Interface = BasicAdapterInterface< - AB::Expr, - MinimalInstruction, - NUM_READS, - 1, - READ_SIZE, - WRITE_SIZE, - >; - - fn eval( - &self, - builder: &mut AB, - local: &[AB::Var], - ctx: AdapterAirContext, - ) { - let vec_heap_air: Rv32VecHeapAdapterAir = - Rv32VecHeapAdapterAir::new( - self.execution_bridge, - self.memory_bridge, - self.bus, - self.address_bits, - ); - vec_heap_air.eval(builder, local, ctx.into()); - } - - fn get_from_pc(&self, local: &[AB::Var]) -> AB::Var { - let cols: &Rv32VecHeapAdapterCols<_, NUM_READS, 1, 1, READ_SIZE, WRITE_SIZE> = - local.borrow(); - cols.from_state.pc - } -} - -#[derive(Clone, Copy)] -pub struct Rv32HeapAdapterExecutor< - const NUM_READS: usize, - const READ_SIZE: usize, - const WRITE_SIZE: usize, ->(Rv32VecHeapAdapterExecutor); - -impl - Rv32HeapAdapterExecutor -{ - pub fn new(pointer_max_bits: usize) -> Self { - assert!(NUM_READS <= 2); - assert!( - RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - pointer_max_bits < RV32_CELL_BITS, - "pointer_max_bits={pointer_max_bits} needs to be large enough for high limb range check" - ); - Rv32HeapAdapterExecutor(Rv32VecHeapAdapterExecutor::new(pointer_max_bits)) - } -} - -pub struct Rv32HeapAdapterFiller< - const NUM_READS: usize, - const READ_SIZE: usize, - const WRITE_SIZE: usize, ->(Rv32VecHeapAdapterFiller); - -impl - Rv32HeapAdapterFiller -{ - pub fn new( - pointer_max_bits: usize, - bitwise_lookup_chip: SharedBitwiseOperationLookupChip, - ) -> Self { - assert!(NUM_READS <= 2); - assert!( - RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - pointer_max_bits < RV32_CELL_BITS, - "pointer_max_bits={pointer_max_bits} needs to be large enough for high limb range check" - ); - Rv32HeapAdapterFiller(Rv32VecHeapAdapterFiller::new( - pointer_max_bits, - bitwise_lookup_chip, - )) - } -} - -impl - AdapterTraceExecutor for Rv32HeapAdapterExecutor -where - F: PrimeField32, -{ - const WIDTH: usize = - Rv32VecHeapAdapterCols::::width(); - type ReadData = [[u8; READ_SIZE]; NUM_READS]; - type WriteData = [[u8; WRITE_SIZE]; 1]; - type RecordMut<'a> = &'a mut Rv32VecHeapAdapterRecord; - - fn start(pc: u32, memory: &TracingMemory, record: &mut Self::RecordMut<'_>) { - record.from_pc = pc; - record.from_timestamp = memory.timestamp; - } - - fn read( - &self, - memory: &mut TracingMemory, - instruction: &Instruction, - record: &mut Self::RecordMut<'_>, - ) -> Self::ReadData { - let read_data = AdapterTraceExecutor::::read(&self.0, memory, instruction, record); - read_data.map(|r| r[0]) - } - - fn write( - &self, - memory: &mut TracingMemory, - instruction: &Instruction, - data: Self::WriteData, - record: &mut Self::RecordMut<'_>, - ) { - AdapterTraceExecutor::::write(&self.0, memory, instruction, data, record); - } -} - -impl - AdapterTraceFiller for Rv32HeapAdapterFiller -{ - const WIDTH: usize = - Rv32VecHeapAdapterCols::::width(); - - fn fill_trace_row(&self, mem_helper: &MemoryAuxColsFactory, adapter_row: &mut [F]) { - AdapterTraceFiller::::fill_trace_row(&self.0, mem_helper, adapter_row); - } -} diff --git a/extensions/rv32-adapters/src/heap_branch.rs b/extensions/rv32-adapters/src/heap_branch.rs deleted file mode 100644 index 0a2c364d44..0000000000 --- a/extensions/rv32-adapters/src/heap_branch.rs +++ /dev/null @@ -1,325 +0,0 @@ -use std::{ - array::from_fn, - borrow::{Borrow, BorrowMut}, -}; - -use itertools::izip; -use openvm_circuit::{ - arch::{ - get_record_from_slice, AdapterAirContext, AdapterTraceExecutor, AdapterTraceFiller, - BasicAdapterInterface, ExecutionBridge, ExecutionState, ImmInstruction, VmAdapterAir, - }, - system::memory::{ - offline_checker::{MemoryBridge, MemoryReadAuxCols, MemoryReadAuxRecord}, - online::TracingMemory, - MemoryAddress, MemoryAuxColsFactory, - }, -}; -use openvm_circuit_primitives::{ - bitwise_op_lookup::{BitwiseOperationLookupBus, SharedBitwiseOperationLookupChip}, - AlignedBytesBorrow, -}; -use openvm_circuit_primitives_derive::AlignedBorrow; -use openvm_instructions::{ - instruction::Instruction, - program::DEFAULT_PC_STEP, - riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, -}; -use openvm_rv32im_circuit::adapters::{tracing_read, RV32_CELL_BITS, RV32_REGISTER_NUM_LIMBS}; -use openvm_stark_backend::{ - interaction::InteractionBuilder, - p3_air::BaseAir, - p3_field::{Field, PrimeCharacteristicRing, PrimeField32}, -}; - -/// This adapter reads from NUM_READS <= 2 pointers. -/// * The data is read from the heap (address space 2), and the pointers are read from registers -/// (address space 1). -/// * Reads are from the addresses in `rs[0]` (and `rs[1]` if `R = 2`). -#[repr(C)] -#[derive(AlignedBorrow)] -pub struct Rv32HeapBranchAdapterCols { - pub from_state: ExecutionState, - - pub rs_ptr: [T; NUM_READS], - pub rs_val: [[T; RV32_REGISTER_NUM_LIMBS]; NUM_READS], - pub rs_read_aux: [MemoryReadAuxCols; NUM_READS], - - pub heap_read_aux: [MemoryReadAuxCols; NUM_READS], -} - -#[derive(Clone, Copy, Debug, derive_new::new)] -pub struct Rv32HeapBranchAdapterAir { - pub(super) execution_bridge: ExecutionBridge, - pub(super) memory_bridge: MemoryBridge, - pub bus: BitwiseOperationLookupBus, - address_bits: usize, -} - -impl BaseAir - for Rv32HeapBranchAdapterAir -{ - fn width(&self) -> usize { - Rv32HeapBranchAdapterCols::::width() - } -} - -impl VmAdapterAir - for Rv32HeapBranchAdapterAir -{ - type Interface = - BasicAdapterInterface, NUM_READS, 0, READ_SIZE, 0>; - - fn eval( - &self, - builder: &mut AB, - local: &[AB::Var], - ctx: AdapterAirContext, - ) { - let cols: &Rv32HeapBranchAdapterCols<_, NUM_READS, READ_SIZE> = local.borrow(); - let timestamp = cols.from_state.timestamp; - let mut timestamp_delta: usize = 0; - let mut timestamp_pp = || { - timestamp_delta += 1; - timestamp + AB::F::from_usize(timestamp_delta - 1) - }; - - let d = AB::F::from_u32(RV32_REGISTER_AS); - let e = AB::F::from_u32(RV32_MEMORY_AS); - - for (ptr, data, aux) in izip!(cols.rs_ptr, cols.rs_val, &cols.rs_read_aux) { - self.memory_bridge - .read(MemoryAddress::new(d, ptr), data, timestamp_pp(), aux) - .eval(builder, ctx.instruction.is_valid.clone()); - } - - // We constrain the highest limbs of heap pointers to be less than 2^(addr_bits - - // (RV32_CELL_BITS * (RV32_REGISTER_NUM_LIMBS - 1))). This ensures that no overflow - // occurs when computing memory pointers. Since the number of cells accessed with each - // address will be small enough, and combined with the memory argument, it ensures - // that all the cells accessed in the memory are less than 2^addr_bits. - let need_range_check: Vec = cols - .rs_val - .iter() - .map(|val| val[RV32_REGISTER_NUM_LIMBS - 1]) - .collect(); - - // range checks constrain to RV32_CELL_BITS bits, so we need to shift the limbs to constrain - // the correct amount of bits - let limb_shift = - AB::F::from_usize(1 << (RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - self.address_bits)); - - // Note: since limbs are read from memory we already know that limb[i] < 2^RV32_CELL_BITS - // thus range checking limb[i] * shift < 2^RV32_CELL_BITS, gives us that - // limb[i] < 2^(addr_bits - (RV32_CELL_BITS * (RV32_REGISTER_NUM_LIMBS - 1))) - for pair in need_range_check.chunks(2) { - self.bus - .send_range( - pair[0] * limb_shift, - pair.get(1).map(|x| (*x).into()).unwrap_or(AB::Expr::ZERO) * limb_shift, // in case NUM_READS is odd - ) - .eval(builder, ctx.instruction.is_valid.clone()); - } - - let heap_ptr = cols.rs_val.map(|r| { - r.iter().rev().fold(AB::Expr::ZERO, |acc, limb| { - acc * AB::F::from_u32(1 << RV32_CELL_BITS) + (*limb) - }) - }); - for (ptr, data, aux) in izip!(heap_ptr, ctx.reads, &cols.heap_read_aux) { - self.memory_bridge - .read(MemoryAddress::new(e, ptr), data, timestamp_pp(), aux) - .eval(builder, ctx.instruction.is_valid.clone()); - } - - self.execution_bridge - .execute_and_increment_or_set_pc( - ctx.instruction.opcode, - [ - cols.rs_ptr - .first() - .map(|&x| x.into()) - .unwrap_or(AB::Expr::ZERO), - cols.rs_ptr - .get(1) - .map(|&x| x.into()) - .unwrap_or(AB::Expr::ZERO), - ctx.instruction.immediate, - d.into(), - e.into(), - ], - cols.from_state, - AB::F::from_usize(timestamp_delta), - (DEFAULT_PC_STEP, ctx.to_pc), - ) - .eval(builder, ctx.instruction.is_valid); - } - - fn get_from_pc(&self, local: &[AB::Var]) -> AB::Var { - let cols: &Rv32HeapBranchAdapterCols<_, NUM_READS, READ_SIZE> = local.borrow(); - cols.from_state.pc - } -} - -#[repr(C)] -#[derive(AlignedBytesBorrow, Debug)] -pub struct Rv32HeapBranchAdapterRecord { - pub from_pc: u32, - pub from_timestamp: u32, - - pub rs_ptr: [u32; NUM_READS], - pub rs_vals: [u32; NUM_READS], - - pub rs_read_aux: [MemoryReadAuxRecord; NUM_READS], - pub heap_read_aux: [MemoryReadAuxRecord; NUM_READS], -} - -#[derive(Clone, Copy)] -pub struct Rv32HeapBranchAdapterExecutor { - pub pointer_max_bits: usize, -} - -#[derive(derive_new::new)] -pub struct Rv32HeapBranchAdapterFiller { - pub pointer_max_bits: usize, - pub bitwise_lookup_chip: SharedBitwiseOperationLookupChip, -} - -impl - Rv32HeapBranchAdapterExecutor -{ - pub fn new(pointer_max_bits: usize) -> Self { - assert!(NUM_READS <= 2); - assert!( - RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - pointer_max_bits < RV32_CELL_BITS, - "pointer_max_bits={pointer_max_bits} needs to be large enough for high limb range check" - ); - Self { pointer_max_bits } - } -} - -impl AdapterTraceExecutor - for Rv32HeapBranchAdapterExecutor -{ - const WIDTH: usize = Rv32HeapBranchAdapterCols::::width(); - type ReadData = [[u8; READ_SIZE]; NUM_READS]; - type WriteData = (); - type RecordMut<'a> = &'a mut Rv32HeapBranchAdapterRecord; - - fn start(pc: u32, memory: &TracingMemory, adapter_record: &mut Self::RecordMut<'_>) { - adapter_record.from_pc = pc; - adapter_record.from_timestamp = memory.timestamp; - } - - fn read( - &self, - memory: &mut TracingMemory, - instruction: &Instruction, - record: &mut Self::RecordMut<'_>, - ) -> Self::ReadData { - let Instruction { a, b, d, e, .. } = *instruction; - - debug_assert_eq!(d.as_canonical_u32(), RV32_REGISTER_AS); - debug_assert_eq!(e.as_canonical_u32(), RV32_MEMORY_AS); - - // Read register values - record.rs_vals = from_fn(|i| { - record.rs_ptr[i] = if i == 0 { a } else { b }.as_canonical_u32(); - u32::from_le_bytes(tracing_read( - memory, - RV32_REGISTER_AS, - record.rs_ptr[i], - &mut record.rs_read_aux[i].prev_timestamp, - )) - }); - - // Read memory values - from_fn(|i| { - debug_assert!( - record.rs_vals[i] as usize + READ_SIZE - 1 < (1 << self.pointer_max_bits) - ); - tracing_read( - memory, - RV32_MEMORY_AS, - record.rs_vals[i], - &mut record.heap_read_aux[i].prev_timestamp, - ) - }) - } - - fn write( - &self, - _memory: &mut TracingMemory, - _instruction: &Instruction, - _data: Self::WriteData, - _record: &mut Self::RecordMut<'_>, - ) { - // This adapter doesn't write anything - } -} - -impl AdapterTraceFiller - for Rv32HeapBranchAdapterFiller -{ - const WIDTH: usize = Rv32HeapBranchAdapterCols::::width(); - - fn fill_trace_row(&self, mem_helper: &MemoryAuxColsFactory, mut adapter_row: &mut [F]) { - // SAFETY: - // - caller ensures `adapter_row` contains a valid record representation that was previously - // written by the executor - let record: &Rv32HeapBranchAdapterRecord = - unsafe { get_record_from_slice(&mut adapter_row, ()) }; - let cols: &mut Rv32HeapBranchAdapterCols = - adapter_row.borrow_mut(); - - // Range checks: - // **NOTE**: Must do the range checks before overwriting the records - debug_assert!(self.pointer_max_bits <= RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS); - let limb_shift_bits = RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - self.pointer_max_bits; - const MSL_SHIFT: usize = RV32_CELL_BITS * (RV32_REGISTER_NUM_LIMBS - 1); - self.bitwise_lookup_chip.request_range( - (record.rs_vals[0] >> MSL_SHIFT) << limb_shift_bits, - if NUM_READS > 1 { - (record.rs_vals[1] >> MSL_SHIFT) << limb_shift_bits - } else { - 0 - }, - ); - - // **NOTE**: Must iterate everything in reverse order to avoid overwriting the records - for i in (0..NUM_READS).rev() { - mem_helper.fill( - record.heap_read_aux[i].prev_timestamp, - record.from_timestamp + (i + NUM_READS) as u32, - cols.heap_read_aux[i].as_mut(), - ); - } - - for i in (0..NUM_READS).rev() { - mem_helper.fill( - record.rs_read_aux[i].prev_timestamp, - record.from_timestamp + i as u32, - cols.rs_read_aux[i].as_mut(), - ); - } - - cols.rs_val - .iter_mut() - .rev() - .zip(record.rs_vals.iter().rev()) - .for_each(|(col, record)| { - *col = record.to_le_bytes().map(F::from_u8); - }); - - cols.rs_ptr - .iter_mut() - .rev() - .zip(record.rs_ptr.iter().rev()) - .for_each(|(col, record)| { - *col = F::from_u32(*record); - }); - - cols.from_state.timestamp = F::from_u32(record.from_timestamp); - cols.from_state.pc = F::from_u32(record.from_pc); - } -} diff --git a/extensions/rv32-adapters/src/lib.rs b/extensions/rv32-adapters/src/lib.rs index 6d884daedf..1f8f23b9d7 100644 --- a/extensions/rv32-adapters/src/lib.rs +++ b/extensions/rv32-adapters/src/lib.rs @@ -1,12 +1,12 @@ mod eq_mod; -mod heap; -mod heap_branch; mod vec_heap; +mod vec_heap_branch; +mod vec_to_flat; pub use eq_mod::*; -pub use heap::*; -pub use heap_branch::*; pub use vec_heap::*; +pub use vec_heap_branch::*; +pub use vec_to_flat::*; #[cfg(any(test, feature = "test-utils"))] mod test_utils; diff --git a/extensions/rv32-adapters/src/vec_heap_branch.rs b/extensions/rv32-adapters/src/vec_heap_branch.rs new file mode 100644 index 0000000000..199eb888bf --- /dev/null +++ b/extensions/rv32-adapters/src/vec_heap_branch.rs @@ -0,0 +1,386 @@ +use std::{ + array::from_fn, + borrow::{Borrow, BorrowMut}, + iter::zip, +}; + +use itertools::izip; +use openvm_circuit::{ + arch::{ + get_record_from_slice, AdapterAirContext, AdapterTraceExecutor, AdapterTraceFiller, + ExecutionBridge, ExecutionState, VecHeapBranchAdapterInterface, VmAdapterAir, + }, + system::memory::{ + offline_checker::{MemoryBridge, MemoryReadAuxCols, MemoryReadAuxRecord}, + online::TracingMemory, + MemoryAddress, MemoryAuxColsFactory, + }, +}; +use openvm_circuit_primitives::{ + bitwise_op_lookup::{BitwiseOperationLookupBus, SharedBitwiseOperationLookupChip}, + AlignedBytesBorrow, +}; +use openvm_circuit_primitives_derive::AlignedBorrow; +use openvm_instructions::{ + instruction::Instruction, + program::DEFAULT_PC_STEP, + riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, +}; +use openvm_rv32im_circuit::adapters::{ + abstract_compose, tracing_read, RV32_CELL_BITS, RV32_REGISTER_NUM_LIMBS, +}; +use openvm_stark_backend::{ + interaction::InteractionBuilder, + p3_air::BaseAir, + p3_field::{Field, PrimeCharacteristicRing, PrimeField32}, +}; + +/// This adapter reads from NUM_READS <= 2 pointers (for branch operations). +/// * The data is read from the heap (address space 2), and the pointers are read from registers +/// (address space 1). +/// * Reads take the form of `BLOCKS_PER_READ` consecutive reads of size `READ_SIZE` from the heap, +/// starting from the addresses in `rs[0]` (and `rs[1]` if `NUM_READS = 2`). +/// * No writes are performed (branch operations only compare values). +#[repr(C)] +#[derive(AlignedBorrow, Debug)] +pub struct Rv32VecHeapBranchAdapterCols< + T, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const READ_SIZE: usize, +> { + pub from_state: ExecutionState, + + pub rs_ptr: [T; NUM_READS], + pub rs_val: [[T; RV32_REGISTER_NUM_LIMBS]; NUM_READS], + pub rs_read_aux: [MemoryReadAuxCols; NUM_READS], + + pub reads_aux: [[MemoryReadAuxCols; BLOCKS_PER_READ]; NUM_READS], +} + +#[allow(dead_code)] +#[derive(Clone, Copy, Debug, derive_new::new)] +pub struct Rv32VecHeapBranchAdapterAir< + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const READ_SIZE: usize, +> { + pub(super) execution_bridge: ExecutionBridge, + pub(super) memory_bridge: MemoryBridge, + pub bus: BitwiseOperationLookupBus, + /// The max number of bits for an address in memory + address_bits: usize, +} + +impl + BaseAir for Rv32VecHeapBranchAdapterAir +{ + fn width(&self) -> usize { + Rv32VecHeapBranchAdapterCols::::width() + } +} + +impl< + AB: InteractionBuilder, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const READ_SIZE: usize, + > VmAdapterAir for Rv32VecHeapBranchAdapterAir +{ + type Interface = VecHeapBranchAdapterInterface; + + fn eval( + &self, + builder: &mut AB, + local: &[AB::Var], + ctx: AdapterAirContext, + ) { + let cols: &Rv32VecHeapBranchAdapterCols<_, NUM_READS, BLOCKS_PER_READ, READ_SIZE> = + local.borrow(); + let timestamp = cols.from_state.timestamp; + let mut timestamp_delta: usize = 0; + let mut timestamp_pp = || { + timestamp_delta += 1; + timestamp + AB::F::from_usize(timestamp_delta - 1) + }; + + // Read register values for rs + for (ptr, val, aux) in izip!(cols.rs_ptr, cols.rs_val, &cols.rs_read_aux) { + self.memory_bridge + .read( + MemoryAddress::new(AB::F::from_u32(RV32_REGISTER_AS), ptr), + val, + timestamp_pp(), + aux, + ) + .eval(builder, ctx.instruction.is_valid.clone()); + } + + // We constrain the highest limbs of heap pointers to be less than 2^(addr_bits - + // (RV32_CELL_BITS * (RV32_REGISTER_NUM_LIMBS - 1))). This ensures that no overflow + // occurs when computing memory pointers. + let need_range_check: Vec = cols + .rs_val + .iter() + .map(|val| val[RV32_REGISTER_NUM_LIMBS - 1]) + .collect(); + + // range checks constrain to RV32_CELL_BITS bits, so we need to shift the limbs to constrain + // the correct amount of bits + let limb_shift = AB::F::from_usize( + 1 << (RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - self.address_bits), + ); + + for pair in need_range_check.chunks(2) { + self.bus + .send_range( + pair[0] * limb_shift, + pair.get(1).map(|x| (*x).into()).unwrap_or(AB::Expr::ZERO) * limb_shift, + ) + .eval(builder, ctx.instruction.is_valid.clone()); + } + + // Compose the u32 register value into single field element + let rs_val_f: [AB::Expr; NUM_READS] = cols.rs_val.map(abstract_compose); + + let e = AB::F::from_u32(RV32_MEMORY_AS); + // Reads from heap + for (address, reads, reads_aux) in izip!(rs_val_f, ctx.reads, &cols.reads_aux) { + for (i, (read, aux)) in zip(reads, reads_aux).enumerate() { + self.memory_bridge + .read( + MemoryAddress::new( + e, + address.clone() + AB::Expr::from_usize(i * READ_SIZE), + ), + read, + timestamp_pp(), + aux, + ) + .eval(builder, ctx.instruction.is_valid.clone()); + } + } + + self.execution_bridge + .execute_and_increment_or_set_pc( + ctx.instruction.opcode, + [ + cols.rs_ptr + .first() + .map(|&x| x.into()) + .unwrap_or(AB::Expr::ZERO), + cols.rs_ptr + .get(1) + .map(|&x| x.into()) + .unwrap_or(AB::Expr::ZERO), + ctx.instruction.immediate, + AB::Expr::from_u32(RV32_REGISTER_AS), + e.into(), + ], + cols.from_state, + AB::F::from_usize(timestamp_delta), + (DEFAULT_PC_STEP, ctx.to_pc), + ) + .eval(builder, ctx.instruction.is_valid.clone()); + } + + fn get_from_pc(&self, local: &[AB::Var]) -> AB::Var { + let cols: &Rv32VecHeapBranchAdapterCols<_, NUM_READS, BLOCKS_PER_READ, READ_SIZE> = + local.borrow(); + cols.from_state.pc + } +} + +// Intermediate type that should not be copied or cloned and should be directly written to +#[repr(C)] +#[derive(AlignedBytesBorrow, Debug)] +pub struct Rv32VecHeapBranchAdapterRecord< + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const READ_SIZE: usize, +> { + pub from_pc: u32, + pub from_timestamp: u32, + + pub rs_ptrs: [u32; NUM_READS], + pub rs_vals: [u32; NUM_READS], + + pub rs_read_aux: [MemoryReadAuxRecord; NUM_READS], + pub reads_aux: [[MemoryReadAuxRecord; BLOCKS_PER_READ]; NUM_READS], +} + +#[derive(derive_new::new, Clone, Copy)] +pub struct Rv32VecHeapBranchAdapterExecutor< + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const READ_SIZE: usize, +> { + pointer_max_bits: usize, +} + +#[derive(derive_new::new)] +pub struct Rv32VecHeapBranchAdapterFiller< + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const READ_SIZE: usize, +> { + pointer_max_bits: usize, + pub bitwise_lookup_chip: SharedBitwiseOperationLookupChip, +} + +impl< + F: PrimeField32, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const READ_SIZE: usize, + > AdapterTraceExecutor + for Rv32VecHeapBranchAdapterExecutor +{ + const WIDTH: usize = + Rv32VecHeapBranchAdapterCols::::width(); + type ReadData = [[[u8; READ_SIZE]; BLOCKS_PER_READ]; NUM_READS]; + type WriteData = (); + type RecordMut<'a> = + &'a mut Rv32VecHeapBranchAdapterRecord; + + #[inline(always)] + fn start(pc: u32, memory: &TracingMemory, record: &mut Self::RecordMut<'_>) { + record.from_pc = pc; + record.from_timestamp = memory.timestamp; + } + + fn read( + &self, + memory: &mut TracingMemory, + instruction: &Instruction, + record: &mut &mut Rv32VecHeapBranchAdapterRecord, + ) -> Self::ReadData { + let &Instruction { a, b, d, e, .. } = instruction; + + debug_assert_eq!(d.as_canonical_u32(), RV32_REGISTER_AS); + debug_assert_eq!(e.as_canonical_u32(), RV32_MEMORY_AS); + + // Read register values + record.rs_vals = from_fn(|i| { + record.rs_ptrs[i] = if i == 0 { a } else { b }.as_canonical_u32(); + u32::from_le_bytes(tracing_read( + memory, + RV32_REGISTER_AS, + record.rs_ptrs[i], + &mut record.rs_read_aux[i].prev_timestamp, + )) + }); + + // Read memory values + from_fn(|i| { + debug_assert!( + (record.rs_vals[i] + (READ_SIZE * BLOCKS_PER_READ - 1) as u32) + < (1 << self.pointer_max_bits) as u32 + ); + from_fn(|j| { + tracing_read( + memory, + RV32_MEMORY_AS, + record.rs_vals[i] + (j * READ_SIZE) as u32, + &mut record.reads_aux[i][j].prev_timestamp, + ) + }) + }) + } + + fn write( + &self, + _memory: &mut TracingMemory, + _instruction: &Instruction, + _data: Self::WriteData, + _record: &mut Self::RecordMut<'_>, + ) { + // Branch adapters don't write anything + } +} + +impl< + F: PrimeField32, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const READ_SIZE: usize, + > AdapterTraceFiller + for Rv32VecHeapBranchAdapterFiller +{ + const WIDTH: usize = + Rv32VecHeapBranchAdapterCols::::width(); + + fn fill_trace_row(&self, mem_helper: &MemoryAuxColsFactory, mut adapter_row: &mut [F]) { + // SAFETY: + // - caller ensures `adapter_row` contains a valid record representation that was previously + // written by the executor + let record: &Rv32VecHeapBranchAdapterRecord = + unsafe { get_record_from_slice(&mut adapter_row, ()) }; + + let cols: &mut Rv32VecHeapBranchAdapterCols = + adapter_row.borrow_mut(); + + // Range checks: + // **NOTE**: Must do the range checks before overwriting the records + debug_assert!(self.pointer_max_bits <= RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS); + let limb_shift_bits = RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - self.pointer_max_bits; + const MSL_SHIFT: usize = RV32_CELL_BITS * (RV32_REGISTER_NUM_LIMBS - 1); + self.bitwise_lookup_chip.request_range( + (record.rs_vals[0] >> MSL_SHIFT) << limb_shift_bits, + if NUM_READS > 1 { + (record.rs_vals[1] >> MSL_SHIFT) << limb_shift_bits + } else { + 0 + }, + ); + + let timestamp_delta = NUM_READS + NUM_READS * BLOCKS_PER_READ; + let mut timestamp = record.from_timestamp + timestamp_delta as u32; + let mut timestamp_mm = || { + timestamp -= 1; + timestamp + }; + + // **NOTE**: Must iterate everything in reverse order to avoid overwriting the records + record + .reads_aux + .iter() + .zip(cols.reads_aux.iter_mut()) + .rev() + .for_each(|(reads, cols_reads)| { + reads + .iter() + .zip(cols_reads.iter_mut()) + .rev() + .for_each(|(read, cols_read)| { + mem_helper.fill(read.prev_timestamp, timestamp_mm(), cols_read.as_mut()); + }); + }); + + record + .rs_read_aux + .iter() + .zip(cols.rs_read_aux.iter_mut()) + .rev() + .for_each(|(aux, cols_aux)| { + mem_helper.fill(aux.prev_timestamp, timestamp_mm(), cols_aux.as_mut()); + }); + + cols.rs_val + .iter_mut() + .rev() + .zip(record.rs_vals.iter().rev()) + .for_each(|(cols_val, val)| { + *cols_val = val.to_le_bytes().map(F::from_u8); + }); + cols.rs_ptr + .iter_mut() + .rev() + .zip(record.rs_ptrs.iter().rev()) + .for_each(|(cols_ptr, ptr)| { + *cols_ptr = F::from_u32(*ptr); + }); + cols.from_state.timestamp = F::from_u32(record.from_timestamp); + cols.from_state.pc = F::from_u32(record.from_pc); + } +} diff --git a/extensions/rv32-adapters/src/vec_to_flat.rs b/extensions/rv32-adapters/src/vec_to_flat.rs new file mode 100644 index 0000000000..615cb15b00 --- /dev/null +++ b/extensions/rv32-adapters/src/vec_to_flat.rs @@ -0,0 +1,493 @@ +//! Adapter wrappers that convert between Vec/Block-based interfaces and Flat/Basic interfaces. +//! +//! These wrappers allow using `Rv32VecHeapAdapter*` types with cores that expect flat +//! `BasicAdapterInterface` data formats. + +use openvm_circuit::{ + arch::{ + AdapterAirContext, AdapterTraceExecutor, BasicAdapterInterface, ImmInstruction, + MinimalInstruction, VecHeapAdapterInterface, VecHeapBranchAdapterInterface, VmAdapterAir, + VmAdapterInterface, + }, + system::memory::online::TracingMemory, +}; +use openvm_instructions::instruction::Instruction; +use openvm_stark_backend::{ + interaction::InteractionBuilder, p3_air::BaseAir, p3_field::PrimeField32, + BaseAirWithPublicValues, +}; + +// ================================================================================================= +// ALU Adapter Wrappers (with reads and writes) +// ================================================================================================= + +/// Wrapper that converts a `VecHeapAdapterInterface` (block-based) to `BasicAdapterInterface` +/// (flat). +/// +/// This allows using `Rv32VecHeapAdapterAir` with cores that expect flat read/write data. +/// +/// # Type Parameters +/// - `A`: The inner adapter AIR (e.g., `Rv32VecHeapAdapterAir`) +/// - `NUM_READS`: Number of read operands +/// - `BLOCKS_PER_READ`: Number of blocks per read operand +/// - `BLOCKS_PER_WRITE`: Number of blocks per write operand +/// - `BLOCK_SIZE`: Size of each block +/// - `TOTAL_READ_SIZE`: Total read size per operand (`BLOCKS_PER_READ * BLOCK_SIZE`) +/// - `TOTAL_WRITE_SIZE`: Total write size per operand (`BLOCKS_PER_WRITE * BLOCK_SIZE`) +#[derive(Clone, Copy, Debug, derive_new::new)] +pub struct VecToFlatAluAdapterAir< + A, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const BLOCKS_PER_WRITE: usize, + const BLOCK_SIZE: usize, + const TOTAL_READ_SIZE: usize, + const TOTAL_WRITE_SIZE: usize, +>(pub A); + +impl< + F, + A, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const BLOCKS_PER_WRITE: usize, + const BLOCK_SIZE: usize, + const TOTAL_READ_SIZE: usize, + const TOTAL_WRITE_SIZE: usize, + > BaseAir + for VecToFlatAluAdapterAir< + A, + NUM_READS, + BLOCKS_PER_READ, + BLOCKS_PER_WRITE, + BLOCK_SIZE, + TOTAL_READ_SIZE, + TOTAL_WRITE_SIZE, + > +where + A: BaseAir, +{ + fn width(&self) -> usize { + self.0.width() + } +} + +impl< + AB, + A, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const BLOCKS_PER_WRITE: usize, + const BLOCK_SIZE: usize, + const TOTAL_READ_SIZE: usize, + const TOTAL_WRITE_SIZE: usize, + > VmAdapterAir + for VecToFlatAluAdapterAir< + A, + NUM_READS, + BLOCKS_PER_READ, + BLOCKS_PER_WRITE, + BLOCK_SIZE, + TOTAL_READ_SIZE, + TOTAL_WRITE_SIZE, + > +where + AB: InteractionBuilder, + A: VmAdapterAir< + AB, + Interface = VecHeapAdapterInterface< + AB::Expr, + NUM_READS, + BLOCKS_PER_READ, + BLOCKS_PER_WRITE, + BLOCK_SIZE, + BLOCK_SIZE, + >, + >, +{ + type Interface = BasicAdapterInterface< + AB::Expr, + MinimalInstruction, + NUM_READS, + 1, + TOTAL_READ_SIZE, + TOTAL_WRITE_SIZE, + >; + + fn eval( + &self, + builder: &mut AB, + local: &[AB::Var], + ctx: AdapterAirContext, + ) { + // Runtime assertions for const generic relationships + assert_eq!( + TOTAL_READ_SIZE, + BLOCKS_PER_READ * BLOCK_SIZE, + "TOTAL_READ_SIZE must equal BLOCKS_PER_READ * BLOCK_SIZE" + ); + assert_eq!( + TOTAL_WRITE_SIZE, + BLOCKS_PER_WRITE * BLOCK_SIZE, + "TOTAL_WRITE_SIZE must equal BLOCKS_PER_WRITE * BLOCK_SIZE" + ); + + type InnerI = + VecHeapAdapterInterface; + + let inner_reads: as VmAdapterInterface>::Reads = core::array::from_fn(|read_i| { + core::array::from_fn(|block_i| { + core::array::from_fn(|in_block_i| { + let byte_i = block_i * BLOCK_SIZE + in_block_i; + ctx.reads[read_i][byte_i].clone() + }) + }) + }); + + let inner_writes: as VmAdapterInterface>::Writes = core::array::from_fn(|block_i| { + core::array::from_fn(|in_block_i| { + let byte_i = block_i * BLOCK_SIZE + in_block_i; + ctx.writes[0][byte_i].clone() + }) + }); + + let inner_ctx: AdapterAirContext< + AB::Expr, + InnerI, + > = AdapterAirContext { + to_pc: ctx.to_pc, + reads: inner_reads, + writes: inner_writes, + instruction: ctx.instruction, + }; + + self.0.eval(builder, local, inner_ctx) + } + + fn get_from_pc(&self, local: &[AB::Var]) -> AB::Var { + self.0.get_from_pc(local) + } +} + +impl< + F, + A, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const BLOCKS_PER_WRITE: usize, + const BLOCK_SIZE: usize, + const TOTAL_READ_SIZE: usize, + const TOTAL_WRITE_SIZE: usize, + > BaseAirWithPublicValues + for VecToFlatAluAdapterAir< + A, + NUM_READS, + BLOCKS_PER_READ, + BLOCKS_PER_WRITE, + BLOCK_SIZE, + TOTAL_READ_SIZE, + TOTAL_WRITE_SIZE, + > +where + A: BaseAirWithPublicValues, +{ + fn num_public_values(&self) -> usize { + self.0.num_public_values() + } +} + +/// Wrapper that converts block-based read/write data to flat format for ALU operations. +#[derive(Clone, Copy, Debug, derive_new::new)] +pub struct VecToFlatAluAdapterExecutor< + A, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const BLOCKS_PER_WRITE: usize, + const BLOCK_SIZE: usize, + const TOTAL_READ_SIZE: usize, + const TOTAL_WRITE_SIZE: usize, +>(pub A); + +impl< + F, + A, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const BLOCKS_PER_WRITE: usize, + const BLOCK_SIZE: usize, + const TOTAL_READ_SIZE: usize, + const TOTAL_WRITE_SIZE: usize, + > AdapterTraceExecutor + for VecToFlatAluAdapterExecutor< + A, + NUM_READS, + BLOCKS_PER_READ, + BLOCKS_PER_WRITE, + BLOCK_SIZE, + TOTAL_READ_SIZE, + TOTAL_WRITE_SIZE, + > +where + F: PrimeField32, + A: AdapterTraceExecutor< + F, + ReadData = [[[u8; BLOCK_SIZE]; BLOCKS_PER_READ]; NUM_READS], + WriteData = [[u8; BLOCK_SIZE]; BLOCKS_PER_WRITE], + >, +{ + const WIDTH: usize = A::WIDTH; + type ReadData = [[u8; TOTAL_READ_SIZE]; NUM_READS]; + type WriteData = [[u8; TOTAL_WRITE_SIZE]; 1]; + type RecordMut<'a> + = A::RecordMut<'a> + where + Self: 'a; + + #[inline(always)] + fn start(pc: u32, memory: &TracingMemory, record: &mut Self::RecordMut<'_>) { + A::start(pc, memory, record); + } + + #[inline(always)] + fn read( + &self, + memory: &mut TracingMemory, + instruction: &Instruction, + record: &mut Self::RecordMut<'_>, + ) -> Self::ReadData { + let data_inner = >::read(&self.0, memory, instruction, record); + + core::array::from_fn(|i| { + let mut out = [0u8; TOTAL_READ_SIZE]; + for (block_idx, block) in data_inner[i].iter().enumerate() { + let start = block_idx * BLOCK_SIZE; + out[start..start + BLOCK_SIZE].copy_from_slice(&block[..]); + } + out + }) + } + + #[inline(always)] + fn write( + &self, + memory: &mut TracingMemory, + instruction: &Instruction, + data: Self::WriteData, + record: &mut Self::RecordMut<'_>, + ) { + let data_inner: >::WriteData = core::array::from_fn(|i| { + let start = i * BLOCK_SIZE; + data[0][start..start + BLOCK_SIZE] + .try_into() + .expect("slice length matches BLOCK_SIZE") + }); + + >::write(&self.0, memory, instruction, data_inner, record); + } +} + +// ================================================================================================= +// Branch Adapter Wrappers (reads only, no writes) +// ================================================================================================= + +/// Wrapper that converts a `VecHeapBranchAdapterInterface` (block-based) to `BasicAdapterInterface` +/// (flat). +/// +/// This allows using `Rv32VecHeapBranchAdapterAir` with cores that expect flat read data. +/// Branch operations have no writes. +/// +/// # Type Parameters +/// - `A`: The inner adapter AIR (e.g., `Rv32VecHeapBranchAdapterAir`) +/// - `NUM_READS`: Number of read operands +/// - `BLOCKS_PER_READ`: Number of blocks per read operand +/// - `BLOCK_SIZE`: Size of each block +/// - `TOTAL_READ_SIZE`: Total read size per operand (`BLOCKS_PER_READ * BLOCK_SIZE`) +#[derive(Clone, Copy, Debug, derive_new::new)] +pub struct VecToFlatBranchAdapterAir< + A, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const BLOCK_SIZE: usize, + const TOTAL_READ_SIZE: usize, +>(pub A); + +impl< + F, + A, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const BLOCK_SIZE: usize, + const TOTAL_READ_SIZE: usize, + > BaseAir + for VecToFlatBranchAdapterAir +where + A: BaseAir, +{ + fn width(&self) -> usize { + self.0.width() + } +} + +impl< + AB, + A, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const BLOCK_SIZE: usize, + const TOTAL_READ_SIZE: usize, + > VmAdapterAir + for VecToFlatBranchAdapterAir +where + AB: InteractionBuilder, + A: VmAdapterAir< + AB, + Interface = VecHeapBranchAdapterInterface, + >, +{ + type Interface = + BasicAdapterInterface, NUM_READS, 0, TOTAL_READ_SIZE, 0>; + + fn eval( + &self, + builder: &mut AB, + local: &[AB::Var], + ctx: AdapterAirContext, + ) { + // Runtime assertion for const generic relationship + assert_eq!( + TOTAL_READ_SIZE, + BLOCKS_PER_READ * BLOCK_SIZE, + "TOTAL_READ_SIZE must equal BLOCKS_PER_READ * BLOCK_SIZE" + ); + + type InnerI = + VecHeapBranchAdapterInterface; + + let inner_reads: as VmAdapterInterface>::Reads = + core::array::from_fn(|read_i| { + core::array::from_fn(|block_i| { + core::array::from_fn(|in_block_i| { + let byte_i = block_i * BLOCK_SIZE + in_block_i; + ctx.reads[read_i][byte_i].clone() + }) + }) + }); + + let inner_ctx: AdapterAirContext< + AB::Expr, + InnerI, + > = AdapterAirContext { + to_pc: ctx.to_pc, + reads: inner_reads, + writes: (), + instruction: ctx.instruction, + }; + + self.0.eval(builder, local, inner_ctx) + } + + fn get_from_pc(&self, local: &[AB::Var]) -> AB::Var { + self.0.get_from_pc(local) + } +} + +impl< + F, + A, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const BLOCK_SIZE: usize, + const TOTAL_READ_SIZE: usize, + > BaseAirWithPublicValues + for VecToFlatBranchAdapterAir +where + A: BaseAirWithPublicValues, +{ + fn num_public_values(&self) -> usize { + self.0.num_public_values() + } +} + +/// Wrapper that converts block-based read data to flat format for branch operations. +/// Branch operations have no writes. +#[derive(Clone, Copy, Debug, derive_new::new)] +pub struct VecToFlatBranchAdapterExecutor< + A, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const BLOCK_SIZE: usize, + const TOTAL_READ_SIZE: usize, +>(pub A); + +impl< + F, + A, + const NUM_READS: usize, + const BLOCKS_PER_READ: usize, + const BLOCK_SIZE: usize, + const TOTAL_READ_SIZE: usize, + > AdapterTraceExecutor + for VecToFlatBranchAdapterExecutor +where + F: PrimeField32, + A: AdapterTraceExecutor< + F, + ReadData = [[[u8; BLOCK_SIZE]; BLOCKS_PER_READ]; NUM_READS], + WriteData = (), + >, +{ + const WIDTH: usize = A::WIDTH; + type ReadData = [[u8; TOTAL_READ_SIZE]; NUM_READS]; + type WriteData = (); + type RecordMut<'a> + = A::RecordMut<'a> + where + Self: 'a; + + #[inline(always)] + fn start(pc: u32, memory: &TracingMemory, record: &mut Self::RecordMut<'_>) { + A::start(pc, memory, record); + } + + #[inline(always)] + fn read( + &self, + memory: &mut TracingMemory, + instruction: &Instruction, + record: &mut Self::RecordMut<'_>, + ) -> Self::ReadData { + let data_inner = >::read(&self.0, memory, instruction, record); + + core::array::from_fn(|i| { + let mut out = [0u8; TOTAL_READ_SIZE]; + for (block_idx, block) in data_inner[i].iter().enumerate() { + let start = block_idx * BLOCK_SIZE; + out[start..start + BLOCK_SIZE].copy_from_slice(&block[..]); + } + out + }) + } + + #[inline(always)] + fn write( + &self, + _memory: &mut TracingMemory, + _instruction: &Instruction, + _data: Self::WriteData, + _record: &mut Self::RecordMut<'_>, + ) { + // Branch adapters don't write anything + } +} From c344a4d8810d975db8b39ad228653c3b857196a6 Mon Sep 17 00:00:00 2001 From: Tuanlinh12312 <136139181+Tuanlinh12312@users.noreply.github.com> Date: Thu, 29 Jan 2026 18:25:26 -0500 Subject: [PATCH 21/78] feat: access adapter removal sha2 (#2375) Resolves INT-5950. Co-authored-by: Claude Opus 4.5 --- extensions/sha2/circuit/src/sha2_chips/tests.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/extensions/sha2/circuit/src/sha2_chips/tests.rs b/extensions/sha2/circuit/src/sha2_chips/tests.rs index 36470e9653..40e46b414f 100644 --- a/extensions/sha2/circuit/src/sha2_chips/tests.rs +++ b/extensions/sha2/circuit/src/sha2_chips/tests.rs @@ -135,9 +135,9 @@ fn set_and_execute_single_block = C::get_h() From ef0ac9791099f606b635d0e362a548b39ee00ae7 Mon Sep 17 00:00:00 2001 From: Tuanlinh12312 <136139181+Tuanlinh12312@users.noreply.github.com> Date: Thu, 29 Jan 2026 20:09:28 -0500 Subject: [PATCH 22/78] feat: remove cuda from algebra and ecc extensions (#2379) Remove CUDA code from algebra and ecc extensions, since the production code currenly uses hybrid by default. Cuda tests are switched to using hybrid chips instead of gpu chips. --- .../algebra/circuit/src/extension/cuda.rs | 292 ----------------- .../algebra/circuit/src/extension/mod.rs | 2 - .../circuit/src/fp2_chip/cuda/addsub.rs | 88 ----- .../algebra/circuit/src/fp2_chip/cuda/mod.rs | 5 - .../circuit/src/fp2_chip/cuda/muldiv.rs | 88 ----- .../algebra/circuit/src/fp2_chip/mod.rs | 5 - .../algebra/circuit/src/fp2_chip/tests.rs | 79 ++--- extensions/algebra/circuit/src/lib.rs | 19 ++ .../circuit/src/modular_chip/cuda/addsub.rs | 88 ----- .../circuit/src/modular_chip/cuda/cuda_abi.rs | 65 ---- .../circuit/src/modular_chip/cuda/is_eq.rs | 84 ----- .../circuit/src/modular_chip/cuda/mod.rs | 10 - .../circuit/src/modular_chip/cuda/muldiv.rs | 88 ----- .../algebra/circuit/src/modular_chip/mod.rs | 5 - .../algebra/circuit/src/modular_chip/tests.rs | 305 ++++++++++-------- extensions/ecc/circuit/src/extension/cuda.rs | 151 --------- extensions/ecc/circuit/src/extension/mod.rs | 2 - extensions/ecc/circuit/src/lib.rs | 9 + .../src/weierstrass_chip/add_ne/cuda.rs | 86 ----- .../src/weierstrass_chip/add_ne/mod.rs | 5 - .../src/weierstrass_chip/double/cuda.rs | 88 ----- .../src/weierstrass_chip/double/mod.rs | 5 - .../ecc/circuit/src/weierstrass_chip/tests.rs | 97 +++--- 23 files changed, 299 insertions(+), 1367 deletions(-) delete mode 100644 extensions/algebra/circuit/src/extension/cuda.rs delete mode 100644 extensions/algebra/circuit/src/fp2_chip/cuda/addsub.rs delete mode 100644 extensions/algebra/circuit/src/fp2_chip/cuda/mod.rs delete mode 100644 extensions/algebra/circuit/src/fp2_chip/cuda/muldiv.rs delete mode 100644 extensions/algebra/circuit/src/modular_chip/cuda/addsub.rs delete mode 100644 extensions/algebra/circuit/src/modular_chip/cuda/cuda_abi.rs delete mode 100644 extensions/algebra/circuit/src/modular_chip/cuda/is_eq.rs delete mode 100644 extensions/algebra/circuit/src/modular_chip/cuda/mod.rs delete mode 100644 extensions/algebra/circuit/src/modular_chip/cuda/muldiv.rs delete mode 100644 extensions/ecc/circuit/src/extension/cuda.rs delete mode 100644 extensions/ecc/circuit/src/weierstrass_chip/add_ne/cuda.rs delete mode 100644 extensions/ecc/circuit/src/weierstrass_chip/double/cuda.rs diff --git a/extensions/algebra/circuit/src/extension/cuda.rs b/extensions/algebra/circuit/src/extension/cuda.rs deleted file mode 100644 index 9a5a98d94b..0000000000 --- a/extensions/algebra/circuit/src/extension/cuda.rs +++ /dev/null @@ -1,292 +0,0 @@ -use openvm_algebra_transpiler::{Fp2Opcode, Rv32ModularArithmeticOpcode}; -use openvm_circuit::{ - arch::{ - AirInventory, ChipInventory, ChipInventoryError, DenseRecordArena, VmBuilder, - VmChipComplex, VmProverExtension, - }, - system::cuda::{ - extensions::{ - get_inventory_range_checker, get_or_create_bitwise_op_lookup, SystemGpuBuilder, - }, - SystemChipInventoryGPU, - }, -}; -use openvm_cuda_backend::{BabyBearPoseidon2GpuEngine as GpuBabyBearPoseidon2Engine, GpuBackend}; -use openvm_instructions::LocalOpcode; -use openvm_mod_circuit_builder::ExprBuilderConfig; -use openvm_rv32im_circuit::Rv32ImGpuProverExt; -use openvm_stark_sdk::config::baby_bear_poseidon2::BabyBearPoseidon2Config; -use strum::EnumCount; - -use crate::{ - fp2_chip::{Fp2AddSubChipGpu, Fp2Air, Fp2MulDivChipGpu}, - modular_chip::{ - ModularAddSubChipGpu, ModularAir, ModularIsEqualAir, ModularIsEqualChipGpu, - ModularMulDivChipGpu, - }, - Fp2Extension, ModularExtension, Rv32ModularConfig, Rv32ModularWithFp2Config, -}; - -#[derive(Clone)] -pub struct AlgebraGpuProverExt; - -// This implementation is specific to GpuBackend because the lookup chips -// (VariableRangeCheckerChipGPU, BitwiseOperationLookupChipGPU) are specific to GpuBackend. -impl VmProverExtension - for AlgebraGpuProverExt -{ - fn extend_prover( - &self, - extension: &Fp2Extension, - inventory: &mut ChipInventory, - ) -> Result<(), ChipInventoryError> { - let pointer_max_bits = inventory.airs().pointer_max_bits(); - let timestamp_max_bits = inventory.timestamp_max_bits(); - - // Range checker should always exist in inventory - let range_checker = get_inventory_range_checker(inventory); - - let bitwise_lu = get_or_create_bitwise_op_lookup(inventory)?; - - for (i, (_, modulus)) in extension.supported_moduli.iter().enumerate() { - // Determine the number of bytes needed to represent a prime field element - let bytes = modulus.bits().div_ceil(8); - let start_offset = Fp2Opcode::CLASS_OFFSET + i * Fp2Opcode::COUNT; - - if bytes <= 32 { - let config = ExprBuilderConfig { - modulus: modulus.clone(), - num_limbs: 32, - limb_bits: 8, - }; - - inventory.next_air::>()?; - let addsub = Fp2AddSubChipGpu::<2, 32>::new( - range_checker.clone(), - bitwise_lu.clone(), - config.clone(), - start_offset, - pointer_max_bits as u32, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(addsub); - - inventory.next_air::>()?; - let muldiv = Fp2MulDivChipGpu::<2, 32>::new( - range_checker.clone(), - bitwise_lu.clone(), - config, - start_offset, - pointer_max_bits as u32, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(muldiv); - } else if bytes <= 48 { - let config = ExprBuilderConfig { - modulus: modulus.clone(), - num_limbs: 48, - limb_bits: 8, - }; - - inventory.next_air::>()?; - let addsub = Fp2AddSubChipGpu::<6, 16>::new( - range_checker.clone(), - bitwise_lu.clone(), - config.clone(), - start_offset, - pointer_max_bits as u32, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(addsub); - - inventory.next_air::>()?; - let muldiv = Fp2MulDivChipGpu::<6, 16>::new( - range_checker.clone(), - bitwise_lu.clone(), - config, - start_offset, - pointer_max_bits as u32, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(muldiv); - } else { - panic!("Modulus too large"); - } - } - - Ok(()) - } -} - -impl VmProverExtension - for AlgebraGpuProverExt -{ - fn extend_prover( - &self, - extension: &ModularExtension, - inventory: &mut ChipInventory, - ) -> Result<(), ChipInventoryError> { - let pointer_max_bits = inventory.airs().pointer_max_bits(); - let timestamp_max_bits = inventory.timestamp_max_bits(); - - // Range checker should always exist in inventory - let range_checker = get_inventory_range_checker(inventory); - - let bitwise_lu = get_or_create_bitwise_op_lookup(inventory)?; - - for (i, modulus) in extension.supported_moduli.iter().enumerate() { - let bytes = modulus.bits().div_ceil(8); - let start_offset = - Rv32ModularArithmeticOpcode::CLASS_OFFSET + i * Rv32ModularArithmeticOpcode::COUNT; - - if bytes <= 32 { - let config = ExprBuilderConfig { - modulus: modulus.clone(), - num_limbs: 32, - limb_bits: 8, - }; - - inventory.next_air::>()?; - let addsub = ModularAddSubChipGpu::<1, 32>::new( - range_checker.clone(), - bitwise_lu.clone(), - config.clone(), - start_offset, - pointer_max_bits as u32, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(addsub); - - inventory.next_air::>()?; - let muldiv = ModularMulDivChipGpu::<1, 32>::new( - range_checker.clone(), - bitwise_lu.clone(), - config, - start_offset, - pointer_max_bits as u32, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(muldiv); - - inventory.next_air::>()?; - let is_eq = ModularIsEqualChipGpu::<1, 32, 32>::new( - range_checker.clone(), - bitwise_lu.clone(), - modulus.clone(), - pointer_max_bits as u32, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(is_eq); - } else if bytes <= 48 { - let config = ExprBuilderConfig { - modulus: modulus.clone(), - num_limbs: 48, - limb_bits: 8, - }; - - inventory.next_air::>()?; - let addsub = ModularAddSubChipGpu::<3, 16>::new( - range_checker.clone(), - bitwise_lu.clone(), - config.clone(), - start_offset, - pointer_max_bits as u32, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(addsub); - - inventory.next_air::>()?; - let muldiv = ModularMulDivChipGpu::<3, 16>::new( - range_checker.clone(), - bitwise_lu.clone(), - config, - start_offset, - pointer_max_bits as u32, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(muldiv); - - inventory.next_air::>()?; - let is_eq = ModularIsEqualChipGpu::<3, 16, 48>::new( - range_checker.clone(), - bitwise_lu.clone(), - modulus.clone(), - pointer_max_bits as u32, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(is_eq); - } else { - panic!("Modulus too large"); - } - } - - Ok(()) - } -} - -#[derive(Clone)] -pub struct Rv32ModularGpuBuilder; - -type E = GpuBabyBearPoseidon2Engine; - -impl VmBuilder for Rv32ModularGpuBuilder { - type VmConfig = Rv32ModularConfig; - type SystemChipInventory = SystemChipInventoryGPU; - type RecordArena = DenseRecordArena; - - fn create_chip_complex( - &self, - config: &Rv32ModularConfig, - circuit: AirInventory, - ) -> Result< - VmChipComplex< - BabyBearPoseidon2Config, - Self::RecordArena, - GpuBackend, - Self::SystemChipInventory, - >, - ChipInventoryError, - > { - let mut chip_complex = - VmBuilder::::create_chip_complex(&SystemGpuBuilder, &config.system, circuit)?; - let inventory = &mut chip_complex.inventory; - VmProverExtension::::extend_prover(&Rv32ImGpuProverExt, &config.base, inventory)?; - VmProverExtension::::extend_prover(&Rv32ImGpuProverExt, &config.mul, inventory)?; - VmProverExtension::::extend_prover(&Rv32ImGpuProverExt, &config.io, inventory)?; - VmProverExtension::::extend_prover( - &AlgebraGpuProverExt, - &config.modular, - inventory, - )?; - Ok(chip_complex) - } -} - -#[derive(Clone)] -pub struct Rv32ModularWithFp2GpuBuilder; - -impl VmBuilder for Rv32ModularWithFp2GpuBuilder { - type VmConfig = Rv32ModularWithFp2Config; - type SystemChipInventory = SystemChipInventoryGPU; - type RecordArena = DenseRecordArena; - - fn create_chip_complex( - &self, - config: &Rv32ModularWithFp2Config, - circuit: AirInventory, - ) -> Result< - VmChipComplex< - BabyBearPoseidon2Config, - Self::RecordArena, - GpuBackend, - Self::SystemChipInventory, - >, - ChipInventoryError, - > { - let mut chip_complex = - VmBuilder::::create_chip_complex(&Rv32ModularGpuBuilder, &config.modular, circuit)?; - let inventory = &mut chip_complex.inventory; - VmProverExtension::::extend_prover(&AlgebraGpuProverExt, &config.fp2, inventory)?; - Ok(chip_complex) - } -} diff --git a/extensions/algebra/circuit/src/extension/mod.rs b/extensions/algebra/circuit/src/extension/mod.rs index 8925e6f815..d9bbf130d7 100644 --- a/extensions/algebra/circuit/src/extension/mod.rs +++ b/extensions/algebra/circuit/src/extension/mod.rs @@ -23,9 +23,7 @@ pub use fp2::*; cfg_if::cfg_if! { if #[cfg(feature = "cuda")] { - mod cuda; mod hybrid; - pub use cuda::*; pub use hybrid::*; pub use { AlgebraHybridProverExt as AlgebraProverExt, diff --git a/extensions/algebra/circuit/src/fp2_chip/cuda/addsub.rs b/extensions/algebra/circuit/src/fp2_chip/cuda/addsub.rs deleted file mode 100644 index 16e5764e56..0000000000 --- a/extensions/algebra/circuit/src/fp2_chip/cuda/addsub.rs +++ /dev/null @@ -1,88 +0,0 @@ -use std::sync::Arc; - -use derive_new::new; -use openvm_algebra_transpiler::Fp2Opcode; -use openvm_circuit::arch::{AdapterCoreLayout, DenseRecordArena, RecordSeeker}; -use openvm_circuit_primitives::{ - bitwise_op_lookup::BitwiseOperationLookupChipGPU, var_range::VariableRangeCheckerChipGPU, Chip, -}; -use openvm_cuda_backend::{base::DeviceMatrix, prelude::F, GpuBackend}; -use openvm_cuda_common::copy::MemCopyH2D; -use openvm_instructions::riscv::RV32_CELL_BITS; -use openvm_mod_circuit_builder::{ - ExprBuilderConfig, FieldExpressionChipGPU, FieldExpressionCoreAir, FieldExpressionMetadata, -}; -use openvm_rv32_adapters::{Rv32VecHeapAdapterCols, Rv32VecHeapAdapterExecutor}; -use openvm_stark_backend::prover::AirProvingContext; - -use crate::{fp2_chip::fp2_addsub_expr, AlgebraRecord}; - -#[derive(new)] -pub struct Fp2AddSubChipGpu { - pub range_checker: Arc, - pub bitwise_lookup: Arc>, - pub config: ExprBuilderConfig, - pub offset: usize, - pub pointer_max_bits: u32, - pub timestamp_max_bits: u32, -} - -impl Chip - for Fp2AddSubChipGpu -{ - fn generate_proving_ctx(&self, arena: DenseRecordArena) -> AirProvingContext { - let range_bus = self.range_checker.cpu_chip.as_ref().unwrap().bus(); - let (expr, is_add_flag, is_sub_flag) = fp2_addsub_expr(self.config.clone(), range_bus); - - let total_input_limbs = expr.builder.num_input * expr.canonical_num_limbs(); - let layout = AdapterCoreLayout::with_metadata(FieldExpressionMetadata::< - F, - Rv32VecHeapAdapterExecutor<2, BLOCKS, BLOCKS, BLOCK_SIZE, BLOCK_SIZE>, - >::new(total_input_limbs)); - - let record_size = RecordSeeker::< - DenseRecordArena, - AlgebraRecord<2, BLOCKS, BLOCK_SIZE>, - _, - >::get_aligned_record_size(&layout); - - let records = arena.allocated(); - if records.is_empty() { - return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); - } - debug_assert_eq!(records.len() % record_size, 0); - - let num_records = records.len() / record_size; - - let local_opcode_idx = vec![ - Fp2Opcode::ADD as usize, - Fp2Opcode::SUB as usize, - Fp2Opcode::SETUP_ADDSUB as usize, - ]; - let opcode_flag_idx = vec![is_add_flag, is_sub_flag]; - - let air = FieldExpressionCoreAir::new(expr, self.offset, local_opcode_idx, opcode_flag_idx); - - let adapter_width = - Rv32VecHeapAdapterCols::::width(); - - let d_records = records.to_device().unwrap(); - - let field_expr_chip = FieldExpressionChipGPU::new( - air, - d_records, - num_records, - record_size, - adapter_width, - BLOCKS, - self.range_checker.clone(), - self.bitwise_lookup.clone(), - self.pointer_max_bits, - self.timestamp_max_bits, - ); - - let d_trace = field_expr_chip.generate_field_trace(); - - AirProvingContext::simple_no_pis(d_trace) - } -} diff --git a/extensions/algebra/circuit/src/fp2_chip/cuda/mod.rs b/extensions/algebra/circuit/src/fp2_chip/cuda/mod.rs deleted file mode 100644 index cd316fd70c..0000000000 --- a/extensions/algebra/circuit/src/fp2_chip/cuda/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod addsub; -pub use addsub::*; - -mod muldiv; -pub use muldiv::*; diff --git a/extensions/algebra/circuit/src/fp2_chip/cuda/muldiv.rs b/extensions/algebra/circuit/src/fp2_chip/cuda/muldiv.rs deleted file mode 100644 index df767117a3..0000000000 --- a/extensions/algebra/circuit/src/fp2_chip/cuda/muldiv.rs +++ /dev/null @@ -1,88 +0,0 @@ -use std::sync::Arc; - -use derive_new::new; -use openvm_algebra_transpiler::Fp2Opcode; -use openvm_circuit::arch::{AdapterCoreLayout, DenseRecordArena, RecordSeeker}; -use openvm_circuit_primitives::{ - bitwise_op_lookup::BitwiseOperationLookupChipGPU, var_range::VariableRangeCheckerChipGPU, Chip, -}; -use openvm_cuda_backend::{base::DeviceMatrix, prelude::F, GpuBackend}; -use openvm_cuda_common::copy::MemCopyH2D; -use openvm_instructions::riscv::RV32_CELL_BITS; -use openvm_mod_circuit_builder::{ - ExprBuilderConfig, FieldExpressionChipGPU, FieldExpressionCoreAir, FieldExpressionMetadata, -}; -use openvm_rv32_adapters::{Rv32VecHeapAdapterCols, Rv32VecHeapAdapterExecutor}; -use openvm_stark_backend::prover::AirProvingContext; - -use crate::{fp2_chip::fp2_muldiv_expr, AlgebraRecord}; - -#[derive(new)] -pub struct Fp2MulDivChipGpu { - pub range_checker: Arc, - pub bitwise_lookup: Arc>, - pub config: ExprBuilderConfig, - pub offset: usize, - pub pointer_max_bits: u32, - pub timestamp_max_bits: u32, -} - -impl Chip - for Fp2MulDivChipGpu -{ - fn generate_proving_ctx(&self, arena: DenseRecordArena) -> AirProvingContext { - let range_bus = self.range_checker.cpu_chip.as_ref().unwrap().bus(); - let (expr, is_mul_flag, is_div_flag) = fp2_muldiv_expr(self.config.clone(), range_bus); - - let total_input_limbs = expr.builder.num_input * expr.canonical_num_limbs(); - let layout = AdapterCoreLayout::with_metadata(FieldExpressionMetadata::< - F, - Rv32VecHeapAdapterExecutor<2, BLOCKS, BLOCKS, BLOCK_SIZE, BLOCK_SIZE>, - >::new(total_input_limbs)); - - let record_size = RecordSeeker::< - DenseRecordArena, - AlgebraRecord<2, BLOCKS, BLOCK_SIZE>, - _, - >::get_aligned_record_size(&layout); - - let records = arena.allocated(); - if records.is_empty() { - return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); - } - debug_assert_eq!(records.len() % record_size, 0); - - let num_records = records.len() / record_size; - - let local_opcode_idx = vec![ - Fp2Opcode::MUL as usize, - Fp2Opcode::DIV as usize, - Fp2Opcode::SETUP_MULDIV as usize, - ]; - let opcode_flag_idx = vec![is_mul_flag, is_div_flag]; - - let air = FieldExpressionCoreAir::new(expr, self.offset, local_opcode_idx, opcode_flag_idx); - - let adapter_width = - Rv32VecHeapAdapterCols::::width(); - - let d_records = records.to_device().unwrap(); - - let field_expr_chip = FieldExpressionChipGPU::new( - air, - d_records, - num_records, - record_size, - adapter_width, - BLOCKS, - self.range_checker.clone(), - self.bitwise_lookup.clone(), - self.pointer_max_bits, - self.timestamp_max_bits, - ); - - let d_trace = field_expr_chip.generate_field_trace(); - - AirProvingContext::simple_no_pis(d_trace) - } -} diff --git a/extensions/algebra/circuit/src/fp2_chip/mod.rs b/extensions/algebra/circuit/src/fp2_chip/mod.rs index f3c9921a81..e85b6ec867 100644 --- a/extensions/algebra/circuit/src/fp2_chip/mod.rs +++ b/extensions/algebra/circuit/src/fp2_chip/mod.rs @@ -9,11 +9,6 @@ pub use addsub::*; mod muldiv; pub use muldiv::*; -#[cfg(feature = "cuda")] -mod cuda; -#[cfg(feature = "cuda")] -pub use cuda::*; - pub type Fp2Air = VmAirWrapper< Rv32VecHeapAdapterAir<2, BLOCKS, BLOCKS, BLOCK_SIZE, BLOCK_SIZE>, FieldExpressionCoreAir, diff --git a/extensions/algebra/circuit/src/fp2_chip/tests.rs b/extensions/algebra/circuit/src/fp2_chip/tests.rs index c95c347f85..449c862ca7 100644 --- a/extensions/algebra/circuit/src/fp2_chip/tests.rs +++ b/extensions/algebra/circuit/src/fp2_chip/tests.rs @@ -8,7 +8,7 @@ use openvm_circuit::arch::{ testing::{ memory::gen_pointer, TestBuilder, TestChipHarness, VmChipTestBuilder, BITWISE_OP_LOOKUP_BUS, }, - Arena, PreflightExecutor, + Arena, PreflightExecutor, CONST_BLOCK_SIZE, }; use openvm_circuit_primitives::{ bigint::utils::secp256k1_coord_prime, @@ -31,9 +31,12 @@ use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng}; use rand::{rngs::StdRng, Rng}; use test_case::test_case; -use crate::fp2_chip::{ - get_fp2_addsub_air, get_fp2_addsub_chip, get_fp2_addsub_step, get_fp2_muldiv_air, - get_fp2_muldiv_chip, get_fp2_muldiv_step, Fp2Air, Fp2Chip, Fp2Executor, +use crate::{ + fp2_chip::{ + get_fp2_addsub_air, get_fp2_addsub_chip, get_fp2_addsub_step, get_fp2_muldiv_air, + get_fp2_muldiv_chip, get_fp2_muldiv_step, Fp2Air, Fp2Chip, Fp2Executor, + }, + FP2_BLOCKS_32, FP2_BLOCKS_48, NUM_LIMBS_32, NUM_LIMBS_48, }; const LIMB_BITS: usize = 8; @@ -365,7 +368,7 @@ mod cuda_tests { use test_case::test_case; use super::*; - use crate::fp2_chip::{Fp2AddSubChipGpu, Fp2MulDivChipGpu}; + use crate::extension::HybridFp2Chip; pub type GpuHarness = GpuTestChipHarness< F, @@ -379,7 +382,7 @@ mod cuda_tests { tester: &GpuChipTestBuilder, config: ExprBuilderConfig, offset: usize, - ) -> GpuHarness> { + ) -> GpuHarness> { // getting bus from tester since `gpu_chip` and `air` must use the same bus let range_bus = default_var_range_checker_bus(); let bitwise_bus = default_bitwise_lookup_bus(); @@ -408,23 +411,22 @@ mod cuda_tests { dummy_bitwise_chip, tester.address_bits(), ); - let gpu_chip = Fp2AddSubChipGpu::new( - tester.range_checker(), - tester.bitwise_op_lookup(), + let hybrid_chip = HybridFp2Chip::new(get_fp2_addsub_chip( config, - offset, - tester.address_bits() as u32, - tester.timestamp_max_bits() as u32, - ); + tester.cpu_memory_helper(), + tester.cpu_range_checker(), + tester.cpu_bitwise_op_lookup(), + tester.address_bits(), + )); - GpuTestChipHarness::with_capacity(executor, air, gpu_chip, cpu_chip, MAX_INS_CAPACITY) + GpuTestChipHarness::with_capacity(executor, air, hybrid_chip, cpu_chip, MAX_INS_CAPACITY) } fn create_muldiv_cuda_test_harness( tester: &GpuChipTestBuilder, config: ExprBuilderConfig, offset: usize, - ) -> GpuHarness> { + ) -> GpuHarness> { // getting bus from tester since `gpu_chip` and `air` must use the same bus let range_bus = default_var_range_checker_bus(); let bitwise_bus = default_bitwise_lookup_bus(); @@ -453,65 +455,64 @@ mod cuda_tests { dummy_bitwise_chip, tester.address_bits(), ); - let gpu_chip = Fp2MulDivChipGpu::new( - tester.range_checker(), - tester.bitwise_op_lookup(), + let hybrid_chip = HybridFp2Chip::new(get_fp2_muldiv_chip( config, - offset, - tester.address_bits() as u32, - tester.timestamp_max_bits() as u32, - ); + tester.cpu_memory_helper(), + tester.cpu_range_checker(), + tester.cpu_bitwise_op_lookup(), + tester.address_bits(), + )); - GpuTestChipHarness::with_capacity(executor, air, gpu_chip, cpu_chip, MAX_INS_CAPACITY) + GpuTestChipHarness::with_capacity(executor, air, hybrid_chip, cpu_chip, MAX_INS_CAPACITY) } - #[test_case(TestConfig::<2, 32, 32>::new( + #[test_case(TestConfig::::new( BigUint::from_str("357686312646216567629137").unwrap(), true, 50), - create_addsub_cuda_test_harness::<2, 32> + create_addsub_cuda_test_harness:: )] - #[test_case(TestConfig::<2, 32, 32>::new( + #[test_case(TestConfig::::new( secp256k1_coord_prime(), true, 50), - create_addsub_cuda_test_harness::<2, 32> + create_addsub_cuda_test_harness:: )] - #[test_case(TestConfig::<2, 32, 32>::new( + #[test_case(TestConfig::::new( BN254_MODULUS.clone(), true, 50), - create_addsub_cuda_test_harness::<2, 32> + create_addsub_cuda_test_harness:: )] - #[test_case(TestConfig::<6, 16, 48>::new( + #[test_case(TestConfig::::new( BLS12_381_MODULUS.clone(), true, 50), - create_addsub_cuda_test_harness::<6, 16> + create_addsub_cuda_test_harness:: )] - #[test_case(TestConfig::<2, 32, 32>::new( + #[test_case(TestConfig::::new( BigUint::from_str("357686312646216567629137").unwrap(), false, 50), - create_muldiv_cuda_test_harness::<2, 32> + create_muldiv_cuda_test_harness:: )] - #[test_case(TestConfig::<2, 32, 32>::new( + #[test_case(TestConfig::::new( secp256k1_coord_prime(), false, 50), - create_muldiv_cuda_test_harness::<2, 32> + create_muldiv_cuda_test_harness:: )] - #[test_case(TestConfig::<2, 32, 32>::new( + #[test_case(TestConfig::::new( BN254_MODULUS.clone(), false, 50), - create_muldiv_cuda_test_harness::<2, 32> + create_muldiv_cuda_test_harness:: )] - #[test_case(TestConfig::<6, 16, 48>::new( + #[test_case(TestConfig::::new( BLS12_381_MODULUS.clone(), false, 50), - create_muldiv_cuda_test_harness::<6, 16> + create_muldiv_cuda_test_harness:: )] fn run_cuda_test_with_config< const BLOCKS: usize, diff --git a/extensions/algebra/circuit/src/lib.rs b/extensions/algebra/circuit/src/lib.rs index 30b670848c..4229549d5d 100644 --- a/extensions/algebra/circuit/src/lib.rs +++ b/extensions/algebra/circuit/src/lib.rs @@ -5,6 +5,7 @@ use std::ops::{Deref, DerefMut}; +use openvm_circuit::arch::CONST_BLOCK_SIZE; use openvm_mod_circuit_builder::FieldExpressionExecutor; use openvm_rv32_adapters::Rv32VecHeapAdapterExecutor; #[cfg(feature = "cuda")] @@ -13,6 +14,24 @@ use { openvm_rv32_adapters::Rv32VecHeapAdapterRecord, }; +// Number of limbs for different modulus sizes (bytes) +/// Number of limbs for 256-bit (32-byte) moduli +pub const NUM_LIMBS_32: usize = 32; +/// Number of limbs for 384-bit (48-byte) moduli +pub const NUM_LIMBS_48: usize = 48; + +// Blocks per operation for modular arithmetic (single field element) +/// Blocks for 32-limb modular operations: 32 / 4 = 8 blocks +pub const MODULAR_BLOCKS_32: usize = NUM_LIMBS_32 / CONST_BLOCK_SIZE; +/// Blocks for 48-limb modular operations: 48 / 4 = 12 blocks +pub const MODULAR_BLOCKS_48: usize = NUM_LIMBS_48 / CONST_BLOCK_SIZE; + +// Blocks per operation for Fp2 (two field elements) +/// Blocks for Fp2 with 32-limb base field: 2 * 8 = 16 blocks +pub const FP2_BLOCKS_32: usize = 2 * MODULAR_BLOCKS_32; +/// Blocks for Fp2 with 48-limb base field: 2 * 12 = 24 blocks +pub const FP2_BLOCKS_48: usize = 2 * MODULAR_BLOCKS_48; + pub mod fp2_chip; pub mod modular_chip; diff --git a/extensions/algebra/circuit/src/modular_chip/cuda/addsub.rs b/extensions/algebra/circuit/src/modular_chip/cuda/addsub.rs deleted file mode 100644 index 669af0196e..0000000000 --- a/extensions/algebra/circuit/src/modular_chip/cuda/addsub.rs +++ /dev/null @@ -1,88 +0,0 @@ -use std::sync::Arc; - -use derive_new::new; -use openvm_algebra_transpiler::Rv32ModularArithmeticOpcode; -use openvm_circuit::arch::{AdapterCoreLayout, DenseRecordArena, RecordSeeker}; -use openvm_circuit_primitives::{ - bitwise_op_lookup::BitwiseOperationLookupChipGPU, var_range::VariableRangeCheckerChipGPU, Chip, -}; -use openvm_cuda_backend::{base::DeviceMatrix, prelude::F, GpuBackend}; -use openvm_cuda_common::copy::MemCopyH2D; -use openvm_instructions::riscv::RV32_CELL_BITS; -use openvm_mod_circuit_builder::{ - ExprBuilderConfig, FieldExpressionChipGPU, FieldExpressionCoreAir, FieldExpressionMetadata, -}; -use openvm_rv32_adapters::{Rv32VecHeapAdapterCols, Rv32VecHeapAdapterExecutor}; -use openvm_stark_backend::prover::AirProvingContext; - -use crate::{modular_chip::addsub_expr, AlgebraRecord}; - -#[derive(new)] -pub struct ModularAddSubChipGpu { - pub range_checker: Arc, - pub bitwise_lookup: Arc>, - pub config: ExprBuilderConfig, - pub offset: usize, - pub pointer_max_bits: u32, - pub timestamp_max_bits: u32, -} - -impl Chip - for ModularAddSubChipGpu -{ - fn generate_proving_ctx(&self, arena: DenseRecordArena) -> AirProvingContext { - let range_bus = self.range_checker.cpu_chip.as_ref().unwrap().bus(); - let (expr, is_add_flag, is_sub_flag) = addsub_expr(self.config.clone(), range_bus); - - let total_input_limbs = expr.builder.num_input * expr.canonical_num_limbs(); - let layout = AdapterCoreLayout::with_metadata(FieldExpressionMetadata::< - F, - Rv32VecHeapAdapterExecutor<2, BLOCKS, BLOCKS, BLOCK_SIZE, BLOCK_SIZE>, - >::new(total_input_limbs)); - - let record_size = RecordSeeker::< - DenseRecordArena, - AlgebraRecord<2, BLOCKS, BLOCK_SIZE>, - _, - >::get_aligned_record_size(&layout); - - let records = arena.allocated(); - if records.is_empty() { - return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); - } - debug_assert_eq!(records.len() % record_size, 0); - - let num_records = records.len() / record_size; - - let local_opcode_idx = vec![ - Rv32ModularArithmeticOpcode::ADD as usize, - Rv32ModularArithmeticOpcode::SUB as usize, - Rv32ModularArithmeticOpcode::SETUP_ADDSUB as usize, - ]; - let opcode_flag_idx = vec![is_add_flag, is_sub_flag]; - - let air = FieldExpressionCoreAir::new(expr, self.offset, local_opcode_idx, opcode_flag_idx); - - let adapter_width = - Rv32VecHeapAdapterCols::::width(); - - let d_records = records.to_device().unwrap(); - - let field_expr_chip = FieldExpressionChipGPU::new( - air, - d_records, - num_records, - record_size, - adapter_width, - BLOCKS, - self.range_checker.clone(), - self.bitwise_lookup.clone(), - self.pointer_max_bits, - self.timestamp_max_bits, - ); - - let d_trace = field_expr_chip.generate_field_trace(); - - AirProvingContext::simple_no_pis(d_trace) - } -} diff --git a/extensions/algebra/circuit/src/modular_chip/cuda/cuda_abi.rs b/extensions/algebra/circuit/src/modular_chip/cuda/cuda_abi.rs deleted file mode 100644 index 1b6700b1da..0000000000 --- a/extensions/algebra/circuit/src/modular_chip/cuda/cuda_abi.rs +++ /dev/null @@ -1,65 +0,0 @@ -#![allow(clippy::missing_safety_doc)] -#![allow(clippy::too_many_arguments)] - -use openvm_cuda_backend::prelude::F; -use openvm_cuda_common::{d_buffer::DeviceBuffer, error::CudaError}; -use openvm_instructions::riscv::RV32_CELL_BITS; - -pub mod is_eq_cuda { - use super::*; - - extern "C" { - fn _modular_is_equal_tracegen( - d_trace: *mut F, - height: usize, - width: usize, - d_records: *const u8, - record_len: usize, - d_modulus: *const u8, - total_limbs: usize, - num_lanes: usize, - lane_size: usize, - d_range_ctr: *const u32, - range_bins: usize, - d_bitwise_lut: *const u32, - bitwise_num_bits: usize, - pointer_max_bits: u32, - timestamp_max_bits: u32, - ) -> i32; - } - - pub unsafe fn tracegen( - d_trace: &DeviceBuffer, - height: usize, - d_records: &DeviceBuffer, - d_modulus: &DeviceBuffer, - total_limbs: usize, - num_lanes: usize, - lane_size: usize, - d_range_ctr: &DeviceBuffer, - d_bitwise_lut: &DeviceBuffer, - pointer_max_bits: u32, - timestamp_max_bits: u32, - ) -> Result<(), CudaError> { - let width = d_trace.len() / height; - let record_len = d_records.len(); - let err = _modular_is_equal_tracegen( - d_trace.as_mut_ptr(), - height, - width, - d_records.as_ptr(), - record_len, - d_modulus.as_ptr(), - total_limbs, - num_lanes, - lane_size, - d_range_ctr.as_ptr() as *const u32, - d_range_ctr.len(), - d_bitwise_lut.as_ptr() as *const u32, - RV32_CELL_BITS, - pointer_max_bits, - timestamp_max_bits, - ); - CudaError::from_result(err) - } -} diff --git a/extensions/algebra/circuit/src/modular_chip/cuda/is_eq.rs b/extensions/algebra/circuit/src/modular_chip/cuda/is_eq.rs deleted file mode 100644 index 0829b1e7c1..0000000000 --- a/extensions/algebra/circuit/src/modular_chip/cuda/is_eq.rs +++ /dev/null @@ -1,84 +0,0 @@ -use std::sync::Arc; - -use derive_new::new; -use num_bigint::BigUint; -use openvm_circuit::{arch::DenseRecordArena, utils::next_power_of_two_or_zero}; -use openvm_circuit_primitives::{ - bigint::utils::big_uint_to_limbs, bitwise_op_lookup::BitwiseOperationLookupChipGPU, - var_range::VariableRangeCheckerChipGPU, Chip, -}; -use openvm_cuda_backend::{base::DeviceMatrix, prelude::F, GpuBackend}; -use openvm_cuda_common::copy::MemCopyH2D; -use openvm_instructions::riscv::RV32_CELL_BITS; -use openvm_rv32_adapters::{Rv32IsEqualModAdapterCols, Rv32IsEqualModAdapterRecord}; -use openvm_stark_backend::prover::AirProvingContext; - -use super::cuda_abi::is_eq_cuda::tracegen as modular_is_equal_tracegen; -use crate::modular_chip::{ModularIsEqualCoreCols, ModularIsEqualRecord}; - -#[derive(new)] -pub struct ModularIsEqualChipGpu< - const NUM_LANES: usize, - const LANE_SIZE: usize, - const TOTAL_LIMBS: usize, -> { - pub range_checker: Arc, - pub bitwise_lookup: Arc>, - pub modulus: BigUint, - pub pointer_max_bits: u32, - pub timestamp_max_bits: u32, -} - -impl - Chip - for ModularIsEqualChipGpu -{ - fn generate_proving_ctx(&self, arena: DenseRecordArena) -> AirProvingContext { - const LIMB_BITS: usize = 8; - - let record_size = size_of::<( - Rv32IsEqualModAdapterRecord<2, NUM_LANES, LANE_SIZE, TOTAL_LIMBS>, - ModularIsEqualRecord, - )>(); - - let records = arena.allocated(); - if records.is_empty() { - return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); - } - debug_assert_eq!(records.len() % record_size, 0); - - let trace_width = Rv32IsEqualModAdapterCols::::width() - + ModularIsEqualCoreCols::::width(); - let trace_height = next_power_of_two_or_zero(records.len() / record_size); - - let modulus_vec = big_uint_to_limbs(&self.modulus, LIMB_BITS); - assert!(modulus_vec.len() <= TOTAL_LIMBS); - let mut modulus_limbs = vec![0u8; TOTAL_LIMBS]; - for (i, &limb) in modulus_vec.iter().enumerate() { - modulus_limbs[i] = limb as u8; - } - - let d_records = records.to_device().unwrap(); - let d_modulus = modulus_limbs.to_device().unwrap(); - let d_trace = DeviceMatrix::::with_capacity(trace_height, trace_width); - - unsafe { - modular_is_equal_tracegen( - d_trace.buffer(), - trace_height, - &d_records, - &d_modulus, - TOTAL_LIMBS, - NUM_LANES, - LANE_SIZE, - &self.range_checker.count, - &self.bitwise_lookup.count, - self.pointer_max_bits, - self.timestamp_max_bits, - ) - .unwrap(); - } - - AirProvingContext::simple_no_pis(d_trace) - } -} diff --git a/extensions/algebra/circuit/src/modular_chip/cuda/mod.rs b/extensions/algebra/circuit/src/modular_chip/cuda/mod.rs deleted file mode 100644 index 3d2f97d853..0000000000 --- a/extensions/algebra/circuit/src/modular_chip/cuda/mod.rs +++ /dev/null @@ -1,10 +0,0 @@ -mod addsub; -pub use addsub::*; - -mod muldiv; -pub use muldiv::*; - -mod is_eq; -pub use is_eq::*; - -mod cuda_abi; diff --git a/extensions/algebra/circuit/src/modular_chip/cuda/muldiv.rs b/extensions/algebra/circuit/src/modular_chip/cuda/muldiv.rs deleted file mode 100644 index 80748ca318..0000000000 --- a/extensions/algebra/circuit/src/modular_chip/cuda/muldiv.rs +++ /dev/null @@ -1,88 +0,0 @@ -use std::sync::Arc; - -use derive_new::new; -use openvm_algebra_transpiler::Rv32ModularArithmeticOpcode; -use openvm_circuit::arch::{AdapterCoreLayout, DenseRecordArena, RecordSeeker}; -use openvm_circuit_primitives::{ - bitwise_op_lookup::BitwiseOperationLookupChipGPU, var_range::VariableRangeCheckerChipGPU, Chip, -}; -use openvm_cuda_backend::{base::DeviceMatrix, prelude::F, GpuBackend}; -use openvm_cuda_common::copy::MemCopyH2D; -use openvm_instructions::riscv::RV32_CELL_BITS; -use openvm_mod_circuit_builder::{ - ExprBuilderConfig, FieldExpressionChipGPU, FieldExpressionCoreAir, FieldExpressionMetadata, -}; -use openvm_rv32_adapters::{Rv32VecHeapAdapterCols, Rv32VecHeapAdapterExecutor}; -use openvm_stark_backend::prover::AirProvingContext; - -use crate::{modular_chip::muldiv_expr, AlgebraRecord}; - -#[derive(new)] -pub struct ModularMulDivChipGpu { - pub range_checker: Arc, - pub bitwise_lookup: Arc>, - pub config: ExprBuilderConfig, - pub offset: usize, - pub pointer_max_bits: u32, - pub timestamp_max_bits: u32, -} - -impl Chip - for ModularMulDivChipGpu -{ - fn generate_proving_ctx(&self, arena: DenseRecordArena) -> AirProvingContext { - let range_bus = self.range_checker.cpu_chip.as_ref().unwrap().bus(); - let (expr, is_mul_flag, is_div_flag) = muldiv_expr(self.config.clone(), range_bus); - - let total_input_limbs = expr.builder.num_input * expr.canonical_num_limbs(); - let layout = AdapterCoreLayout::with_metadata(FieldExpressionMetadata::< - F, - Rv32VecHeapAdapterExecutor<2, BLOCKS, BLOCKS, BLOCK_SIZE, BLOCK_SIZE>, - >::new(total_input_limbs)); - - let record_size = RecordSeeker::< - DenseRecordArena, - AlgebraRecord<2, BLOCKS, BLOCK_SIZE>, - _, - >::get_aligned_record_size(&layout); - - let records = arena.allocated(); - if records.is_empty() { - return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); - } - debug_assert_eq!(records.len() % record_size, 0); - - let num_records = records.len() / record_size; - - let local_opcode_idx = vec![ - Rv32ModularArithmeticOpcode::MUL as usize, - Rv32ModularArithmeticOpcode::DIV as usize, - Rv32ModularArithmeticOpcode::SETUP_MULDIV as usize, - ]; - let opcode_flag_idx = vec![is_mul_flag, is_div_flag]; - - let air = FieldExpressionCoreAir::new(expr, self.offset, local_opcode_idx, opcode_flag_idx); - - let adapter_width = - Rv32VecHeapAdapterCols::::width(); - - let d_records = records.to_device().unwrap(); - - let field_expr_chip = FieldExpressionChipGPU::new( - air, - d_records, - num_records, - record_size, - adapter_width, - BLOCKS, - self.range_checker.clone(), - self.bitwise_lookup.clone(), - self.pointer_max_bits, - self.timestamp_max_bits, - ); - - let d_trace = field_expr_chip.generate_field_trace(); - - AirProvingContext::simple_no_pis(d_trace) - } -} diff --git a/extensions/algebra/circuit/src/modular_chip/mod.rs b/extensions/algebra/circuit/src/modular_chip/mod.rs index 6efac0b8a5..24c0aa8b1a 100644 --- a/extensions/algebra/circuit/src/modular_chip/mod.rs +++ b/extensions/algebra/circuit/src/modular_chip/mod.rs @@ -16,11 +16,6 @@ pub use addsub::*; mod muldiv; pub use muldiv::*; -#[cfg(feature = "cuda")] -mod cuda; -#[cfg(feature = "cuda")] -pub use cuda::*; - #[cfg(test)] mod tests; diff --git a/extensions/algebra/circuit/src/modular_chip/tests.rs b/extensions/algebra/circuit/src/modular_chip/tests.rs index 6d5b458fea..a9e5e194a2 100644 --- a/extensions/algebra/circuit/src/modular_chip/tests.rs +++ b/extensions/algebra/circuit/src/modular_chip/tests.rs @@ -8,7 +8,7 @@ use openvm_circuit::arch::{ testing::{ memory::gen_pointer, TestBuilder, TestChipHarness, VmChipTestBuilder, BITWISE_OP_LOOKUP_BUS, }, - Arena, PreflightExecutor, + Arena, PreflightExecutor, CONST_BLOCK_SIZE, }; use openvm_circuit_primitives::{ bigint::utils::{secp256k1_coord_prime, secp256k1_scalar_prime}, @@ -35,7 +35,7 @@ use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng}; use rand::{rngs::StdRng, Rng}; #[cfg(feature = "cuda")] use { - crate::modular_chip::{ModularAddSubChipGpu, ModularIsEqualChipGpu, ModularMulDivChipGpu}, + crate::extension::{HybridModularChip, HybridModularIsEqualChip}, openvm_circuit::arch::testing::{ default_bitwise_lookup_bus, default_var_range_checker_bus, GpuChipTestBuilder, GpuTestChipHarness, @@ -43,11 +43,14 @@ use { openvm_circuit_primitives::var_range::VariableRangeCheckerChip, }; -use crate::modular_chip::{ - get_modular_addsub_air, get_modular_addsub_chip, get_modular_addsub_step, - get_modular_muldiv_air, get_modular_muldiv_chip, get_modular_muldiv_step, ModularAir, - ModularChip, ModularExecutor, ModularIsEqualAir, ModularIsEqualChip, ModularIsEqualCoreAir, - ModularIsEqualCoreCols, ModularIsEqualFiller, VmModularIsEqualExecutor, +use crate::{ + modular_chip::{ + get_modular_addsub_air, get_modular_addsub_chip, get_modular_addsub_step, + get_modular_muldiv_air, get_modular_muldiv_chip, get_modular_muldiv_step, ModularAir, + ModularChip, ModularExecutor, ModularIsEqualAir, ModularIsEqualChip, ModularIsEqualCoreAir, + ModularIsEqualCoreCols, ModularIsEqualFiller, VmModularIsEqualExecutor, + }, + MODULAR_BLOCKS_32, MODULAR_BLOCKS_48, NUM_LIMBS_32, NUM_LIMBS_48, }; const LIMB_BITS: usize = 8; @@ -67,14 +70,6 @@ mod addsub_tests { ModularChip, >; - #[cfg(feature = "cuda")] - type GpuHarness = GpuTestChipHarness< - F, - ModularExecutor, - ModularAir, - ModularAddSubChipGpu, - ModularChip, - >; fn create_harness( tester: &VmChipTestBuilder, @@ -119,6 +114,15 @@ mod addsub_tests { (harness, (bitwise_chip.air, bitwise_chip)) } + #[cfg(feature = "cuda")] + type GpuHarness = GpuTestChipHarness< + F, + ModularExecutor, + ModularAir, + HybridModularChip, + ModularChip, + >; + #[cfg(feature = "cuda")] fn create_cuda_harness( tester: &GpuChipTestBuilder, @@ -153,18 +157,20 @@ mod addsub_tests { dummy_bitwise_chip, tester.address_bits(), ); - let gpu_chip = ModularAddSubChipGpu::new( - tester.range_checker(), - tester.bitwise_op_lookup(), + + // Use hybrid chip wrapping the CPU chip + let hybrid_chip = HybridModularChip::new(get_modular_addsub_chip( config, - offset, - tester.address_bits() as u32, - tester.timestamp_max_bits() as u32, - ); + tester.cpu_memory_helper(), + tester.cpu_range_checker(), + tester.cpu_bitwise_op_lookup(), + tester.address_bits(), + )); - GpuHarness::with_capacity(executor, air, gpu_chip, cpu_chip, MAX_INS_CAPACITY) + GpuHarness::with_capacity(executor, air, hybrid_chip, cpu_chip, MAX_INS_CAPACITY) } + fn set_and_execute_addsub< const BLOCKS: usize, const BLOCK_SIZE: usize, @@ -380,15 +386,31 @@ mod addsub_tests { #[cfg(feature = "cuda")] #[test] fn cuda_test_modular_addsub() { - run_cuda_addsub_test_with_config::<1, 32, 32>( + run_cuda_addsub_test_with_config::( 0, BigUint::from_str("357686312646216567629137").unwrap(), 50, ); - run_cuda_addsub_test_with_config::<1, 32, 32>(0, secp256k1_coord_prime(), 50); - run_cuda_addsub_test_with_config::<1, 32, 32>(4, secp256k1_scalar_prime(), 50); - run_cuda_addsub_test_with_config::<1, 32, 32>(0, BN254_MODULUS.clone(), 50); - run_cuda_addsub_test_with_config::<3, 16, 48>(0, BLS12_381_MODULUS.clone(), 50); + run_cuda_addsub_test_with_config::( + 0, + secp256k1_coord_prime(), + 50, + ); + run_cuda_addsub_test_with_config::( + 4, + secp256k1_scalar_prime(), + 50, + ); + run_cuda_addsub_test_with_config::( + 0, + BN254_MODULUS.clone(), + 50, + ); + run_cuda_addsub_test_with_config::( + 0, + BLS12_381_MODULUS.clone(), + 50, + ); } } @@ -404,14 +426,6 @@ mod muldiv_tests { ModularChip, >; - #[cfg(feature = "cuda")] - type GpuHarness = GpuTestChipHarness< - F, - ModularExecutor, - ModularAir, - ModularMulDivChipGpu, - ModularChip, - >; fn create_harness( tester: &VmChipTestBuilder, @@ -458,19 +472,21 @@ mod muldiv_tests { (harness, (bitwise_chip.air, bitwise_chip)) } + #[cfg(feature = "cuda")] + type GpuHarness = GpuTestChipHarness< + F, + ModularExecutor, + ModularAir, + HybridModularChip, + ModularChip, + >; + #[cfg(feature = "cuda")] fn create_cuda_harness( tester: &GpuChipTestBuilder, config: ExprBuilderConfig, offset: usize, ) -> GpuHarness { - use openvm_circuit::arch::testing::{ - default_bitwise_lookup_bus, default_var_range_checker_bus, - }; - use openvm_circuit_primitives::var_range::VariableRangeCheckerChip; - - use crate::modular_chip::ModularMulDivChipGpu; - // getting bus from tester since `gpu_chip` and `air` must use the same bus let range_bus = default_var_range_checker_bus(); let bitwise_bus = default_bitwise_lookup_bus(); @@ -499,18 +515,20 @@ mod muldiv_tests { dummy_bitwise_chip, tester.address_bits(), ); - let gpu_chip = ModularMulDivChipGpu::new( - tester.range_checker(), - tester.bitwise_op_lookup(), + + // Use hybrid chip wrapping the CPU chip + let hybrid_chip = HybridModularChip::new(get_modular_muldiv_chip( config, - offset, - tester.address_bits() as u32, - tester.timestamp_max_bits() as u32, - ); + tester.cpu_memory_helper(), + tester.cpu_range_checker(), + tester.cpu_bitwise_op_lookup(), + tester.address_bits(), + )); - GpuTestChipHarness::with_capacity(executor, air, gpu_chip, cpu_chip, MAX_INS_CAPACITY) + GpuHarness::with_capacity(executor, air, hybrid_chip, cpu_chip, MAX_INS_CAPACITY) } + fn set_and_execute_muldiv< const BLOCKS: usize, const BLOCK_SIZE: usize, @@ -727,15 +745,31 @@ mod muldiv_tests { #[cfg(feature = "cuda")] #[test] fn cuda_test_modular_muldiv() { - run_cuda_muldiv_test_with_config::<1, 32, 32>( + run_cuda_muldiv_test_with_config::( 0, BigUint::from_str("357686312646216567629137").unwrap(), 50, ); - run_cuda_muldiv_test_with_config::<1, 32, 32>(0, secp256k1_coord_prime(), 50); - run_cuda_muldiv_test_with_config::<1, 32, 32>(4, secp256k1_scalar_prime(), 50); - run_cuda_muldiv_test_with_config::<1, 32, 32>(0, BN254_MODULUS.clone(), 50); - run_cuda_muldiv_test_with_config::<3, 16, 48>(0, BLS12_381_MODULUS.clone(), 50); + run_cuda_muldiv_test_with_config::( + 0, + secp256k1_coord_prime(), + 50, + ); + run_cuda_muldiv_test_with_config::( + 4, + secp256k1_scalar_prime(), + 50, + ); + run_cuda_muldiv_test_with_config::( + 0, + BN254_MODULUS.clone(), + 50, + ); + run_cuda_muldiv_test_with_config::( + 0, + BLS12_381_MODULUS.clone(), + 50, + ); } } @@ -764,16 +798,6 @@ mod is_equal_tests { ModularIsEqualChip, >; - #[cfg(feature = "cuda")] - type GpuHarness = - GpuTestChipHarness< - F, - VmModularIsEqualExecutor, - ModularIsEqualAir, - ModularIsEqualChipGpu, - ModularIsEqualChip, - >; - fn create_harness( tester: &mut VmChipTestBuilder, modulus: &BigUint, @@ -817,65 +841,6 @@ mod is_equal_tests { (harness, (bitwise_chip.air, bitwise_chip)) } - #[cfg(feature = "cuda")] - fn create_cuda_harness< - const NUM_LANES: usize, - const LANE_SIZE: usize, - const TOTAL_LIMBS: usize, - >( - tester: &GpuChipTestBuilder, - modulus: BigUint, - modulus_limbs: [u8; TOTAL_LIMBS], - offset: usize, - ) -> GpuHarness { - // getting bus from tester since `gpu_chip` and `air` must use the same bus - - use openvm_circuit::arch::testing::default_bitwise_lookup_bus; - - use crate::modular_chip::ModularIsEqualChipGpu; - let bitwise_bus = default_bitwise_lookup_bus(); - // creating a dummy chip for Cpu so we only count `add_count`s from GPU - let dummy_bitwise_chip = Arc::new(BitwiseOperationLookupChip::::new( - bitwise_bus, - )); - - let air = ModularIsEqualAir::new( - Rv32IsEqualModAdapterAir::new( - tester.execution_bridge(), - tester.memory_bridge(), - bitwise_bus, - tester.address_bits(), - ), - ModularIsEqualCoreAir::new(modulus.clone(), bitwise_bus, offset), - ); - - let executor = VmModularIsEqualExecutor::new( - Rv32IsEqualModAdapterExecutor::new(tester.address_bits()), - offset, - modulus_limbs, - ); - - let cpu_chip = ModularIsEqualChip::::new( - ModularIsEqualFiller::new( - Rv32IsEqualModAdapterFiller::new(tester.address_bits(), dummy_bitwise_chip.clone()), - offset, - modulus_limbs, - dummy_bitwise_chip.clone(), - ), - tester.dummy_memory_helper(), - ); - - let gpu_chip = ModularIsEqualChipGpu::new( - tester.range_checker(), - tester.bitwise_op_lookup(), - modulus, - tester.address_bits() as u32, - tester.timestamp_max_bits() as u32, - ); - - GpuTestChipHarness::with_capacity(executor, air, gpu_chip, cpu_chip, MAX_INS_CAPACITY) - } - #[allow(clippy::too_many_arguments)] fn set_and_execute_is_equal< const NUM_LANES: usize, @@ -997,7 +962,78 @@ mod is_equal_tests { } #[cfg(feature = "cuda")] - fn run_cuda_test_with_config< + type GpuHarness = + GpuTestChipHarness< + F, + VmModularIsEqualExecutor, + ModularIsEqualAir, + HybridModularIsEqualChip, + ModularIsEqualChip, + >; + + #[cfg(feature = "cuda")] + fn create_cuda_harness< + const NUM_LANES: usize, + const LANE_SIZE: usize, + const TOTAL_LIMBS: usize, + >( + tester: &GpuChipTestBuilder, + modulus: BigUint, + modulus_limbs: [u8; TOTAL_LIMBS], + offset: usize, + ) -> GpuHarness { + let bitwise_bus = default_bitwise_lookup_bus(); + // creating a dummy chip for Cpu so we only count `add_count`s from GPU + let dummy_bitwise_chip = Arc::new(BitwiseOperationLookupChip::::new( + bitwise_bus, + )); + + let air = ModularIsEqualAir::new( + Rv32IsEqualModAdapterAir::new( + tester.execution_bridge(), + tester.memory_bridge(), + bitwise_bus, + tester.address_bits(), + ), + ModularIsEqualCoreAir::new(modulus.clone(), bitwise_bus, offset), + ); + + let executor = VmModularIsEqualExecutor::new( + Rv32IsEqualModAdapterExecutor::new(tester.address_bits()), + offset, + modulus_limbs, + ); + + let cpu_chip = ModularIsEqualChip::::new( + ModularIsEqualFiller::new( + Rv32IsEqualModAdapterFiller::new(tester.address_bits(), dummy_bitwise_chip.clone()), + offset, + modulus_limbs, + dummy_bitwise_chip.clone(), + ), + tester.dummy_memory_helper(), + ); + + // Use hybrid chip wrapping the CPU chip + let hybrid_chip = + HybridModularIsEqualChip::new(ModularIsEqualChip::::new( + ModularIsEqualFiller::new( + Rv32IsEqualModAdapterFiller::new( + tester.address_bits(), + tester.cpu_bitwise_op_lookup(), + ), + offset, + modulus_limbs, + tester.cpu_bitwise_op_lookup(), + ), + tester.cpu_memory_helper(), + )); + + GpuHarness::with_capacity(executor, air, hybrid_chip, cpu_chip, MAX_INS_CAPACITY) + } + + #[cfg(feature = "cuda")] + fn run_cuda_is_equal_test_with_config< const NUM_LANES: usize, const LANE_SIZE: usize, const TOTAL_LIMBS: usize, @@ -1068,8 +1104,21 @@ mod is_equal_tests { #[cfg(feature = "cuda")] #[test] fn cuda_test_modular_is_equal() { - run_cuda_test_with_config::<1, 32, 32>(17, secp256k1_coord_prime(), 50); - run_cuda_test_with_config::<1, 32, 32>(17, secp256k1_scalar_prime(), 50); + run_cuda_is_equal_test_with_config::( + 17, + secp256k1_coord_prime(), + 50, + ); + run_cuda_is_equal_test_with_config::( + 17, + secp256k1_scalar_prime(), + 50, + ); + run_cuda_is_equal_test_with_config::( + 17, + BLS12_381_MODULUS.clone(), + 50, + ); } ////////////////////////////////////////////////////////////////////////////////////// diff --git a/extensions/ecc/circuit/src/extension/cuda.rs b/extensions/ecc/circuit/src/extension/cuda.rs deleted file mode 100644 index d066e0bc74..0000000000 --- a/extensions/ecc/circuit/src/extension/cuda.rs +++ /dev/null @@ -1,151 +0,0 @@ -use openvm_algebra_circuit::Rv32ModularGpuBuilder; -use openvm_circuit::{ - arch::{ - AirInventory, ChipInventory, ChipInventoryError, DenseRecordArena, VmBuilder, - VmChipComplex, VmProverExtension, - }, - system::cuda::{ - extensions::{get_inventory_range_checker, get_or_create_bitwise_op_lookup}, - SystemChipInventoryGPU, - }, -}; -use openvm_cuda_backend::{BabyBearPoseidon2GpuEngine as GpuBabyBearPoseidon2Engine, GpuBackend}; -use openvm_ecc_transpiler::Rv32WeierstrassOpcode; -use openvm_instructions::LocalOpcode; -use openvm_mod_circuit_builder::ExprBuilderConfig; -use openvm_stark_sdk::config::baby_bear_poseidon2::BabyBearPoseidon2Config; -use strum::EnumCount; - -use crate::{ - Rv32WeierstrassConfig, WeierstrassAddNeChipGpu, WeierstrassAir, WeierstrassDoubleChipGpu, - WeierstrassExtension, -}; - -#[derive(Clone)] -pub struct EccGpuProverExt; - -// This implementation is specific to GpuBackend because the lookup chips -// (VariableRangeCheckerChipGPU, BitwiseOperationLookupChipGPU) are specific to GpuBackend. -impl VmProverExtension - for EccGpuProverExt -{ - fn extend_prover( - &self, - extension: &WeierstrassExtension, - inventory: &mut ChipInventory, - ) -> Result<(), ChipInventoryError> { - let pointer_max_bits = inventory.airs().pointer_max_bits(); - let timestamp_max_bits = inventory.timestamp_max_bits(); - - // Range checker should always exist in inventory - let range_checker = get_inventory_range_checker(inventory); - - let bitwise_lu = get_or_create_bitwise_op_lookup(inventory)?; - - for (i, curve) in extension.supported_curves.iter().enumerate() { - let start_offset = - Rv32WeierstrassOpcode::CLASS_OFFSET + i * Rv32WeierstrassOpcode::COUNT; - let bytes = curve.modulus.bits().div_ceil(8); - - if bytes <= 32 { - let config = ExprBuilderConfig { - modulus: curve.modulus.clone(), - num_limbs: 32, - limb_bits: 8, - }; - - inventory.next_air::>()?; - let addne = WeierstrassAddNeChipGpu::<2, 32>::new( - range_checker.clone(), - bitwise_lu.clone(), - config.clone(), - start_offset, - pointer_max_bits as u32, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(addne); - - inventory.next_air::>()?; - let double = WeierstrassDoubleChipGpu::<2, 32>::new( - range_checker.clone(), - bitwise_lu.clone(), - config, - start_offset, - curve.a.clone(), - pointer_max_bits as u32, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(double); - } else if bytes <= 48 { - let config = ExprBuilderConfig { - modulus: curve.modulus.clone(), - num_limbs: 48, - limb_bits: 8, - }; - - inventory.next_air::>()?; - let addne = WeierstrassAddNeChipGpu::<6, 16>::new( - range_checker.clone(), - bitwise_lu.clone(), - config.clone(), - start_offset, - pointer_max_bits as u32, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(addne); - - inventory.next_air::>()?; - let double = WeierstrassDoubleChipGpu::<6, 16>::new( - range_checker.clone(), - bitwise_lu.clone(), - config, - start_offset, - curve.a.clone(), - pointer_max_bits as u32, - timestamp_max_bits as u32, - ); - inventory.add_executor_chip(double); - } else { - panic!("Modulus too large"); - } - } - - Ok(()) - } -} - -#[derive(Clone)] -pub struct Rv32WeierstrassGpuBuilder; - -type E = GpuBabyBearPoseidon2Engine; - -impl VmBuilder for Rv32WeierstrassGpuBuilder { - type VmConfig = Rv32WeierstrassConfig; - type SystemChipInventory = SystemChipInventoryGPU; - type RecordArena = DenseRecordArena; - - fn create_chip_complex( - &self, - config: &Rv32WeierstrassConfig, - circuit: AirInventory, - ) -> Result< - VmChipComplex< - BabyBearPoseidon2Config, - Self::RecordArena, - GpuBackend, - Self::SystemChipInventory, - >, - ChipInventoryError, - > { - let mut chip_complex = - VmBuilder::::create_chip_complex(&Rv32ModularGpuBuilder, &config.modular, circuit)?; - let inventory = &mut chip_complex.inventory; - VmProverExtension::::extend_prover( - &EccGpuProverExt, - &config.weierstrass, - inventory, - )?; - - Ok(chip_complex) - } -} diff --git a/extensions/ecc/circuit/src/extension/mod.rs b/extensions/ecc/circuit/src/extension/mod.rs index 1a28e75ec9..54458f46c0 100644 --- a/extensions/ecc/circuit/src/extension/mod.rs +++ b/extensions/ecc/circuit/src/extension/mod.rs @@ -18,9 +18,7 @@ pub use weierstrass::*; cfg_if::cfg_if! { if #[cfg(feature = "cuda")] { - mod cuda; mod hybrid; - pub use cuda::*; pub use hybrid::*; pub use { EccHybridProverExt as EccProverExt, diff --git a/extensions/ecc/circuit/src/lib.rs b/extensions/ecc/circuit/src/lib.rs index 272f36887d..2ae211128d 100644 --- a/extensions/ecc/circuit/src/lib.rs +++ b/extensions/ecc/circuit/src/lib.rs @@ -2,6 +2,7 @@ #![cfg_attr(feature = "tco", feature(explicit_tail_calls))] #![cfg_attr(feature = "tco", allow(internal_features))] #![cfg_attr(feature = "tco", feature(core_intrinsics))] +use openvm_circuit::arch::CONST_BLOCK_SIZE; #[cfg(feature = "cuda")] use { openvm_mod_circuit_builder::FieldExpressionCoreRecordMut, @@ -12,8 +13,16 @@ mod extension; mod weierstrass_chip; pub use extension::*; +// Re-export limb constants from algebra for consistency +pub use openvm_algebra_circuit::{NUM_LIMBS_32, NUM_LIMBS_48}; pub use weierstrass_chip::*; +// Blocks per ECC operation (2 coordinates per point) +/// Blocks for ECC with 32-limb coordinates: 2 * (32 / 4) = 16 blocks +pub const ECC_BLOCKS_32: usize = 2 * (NUM_LIMBS_32 / CONST_BLOCK_SIZE); +/// Blocks for ECC with 48-limb coordinates: 2 * (48 / 4) = 24 blocks +pub const ECC_BLOCKS_48: usize = 2 * (NUM_LIMBS_48 / CONST_BLOCK_SIZE); + #[cfg(feature = "cuda")] pub(crate) type EccRecord< 'a, diff --git a/extensions/ecc/circuit/src/weierstrass_chip/add_ne/cuda.rs b/extensions/ecc/circuit/src/weierstrass_chip/add_ne/cuda.rs deleted file mode 100644 index 8148599473..0000000000 --- a/extensions/ecc/circuit/src/weierstrass_chip/add_ne/cuda.rs +++ /dev/null @@ -1,86 +0,0 @@ -use std::sync::Arc; - -use derive_new::new; -use openvm_circuit::arch::{AdapterCoreLayout, DenseRecordArena, RecordSeeker}; -use openvm_circuit_primitives::{ - bitwise_op_lookup::BitwiseOperationLookupChipGPU, var_range::VariableRangeCheckerChipGPU, Chip, -}; -use openvm_cuda_backend::{base::DeviceMatrix, prelude::F, GpuBackend}; -use openvm_cuda_common::copy::MemCopyH2D; -use openvm_ecc_transpiler::Rv32WeierstrassOpcode; -use openvm_instructions::riscv::RV32_CELL_BITS; -use openvm_mod_circuit_builder::{ - ExprBuilderConfig, FieldExpressionChipGPU, FieldExpressionCoreAir, FieldExpressionMetadata, -}; -use openvm_rv32_adapters::{Rv32VecHeapAdapterCols, Rv32VecHeapAdapterExecutor}; -use openvm_stark_backend::prover::AirProvingContext; - -use crate::{ec_add_ne_expr, EccRecord}; - -#[derive(new)] -pub struct WeierstrassAddNeChipGpu { - pub range_checker: Arc, - pub bitwise_lookup: Arc>, - pub config: ExprBuilderConfig, - pub offset: usize, - pub pointer_max_bits: u32, - pub timestamp_max_bits: u32, -} - -impl Chip - for WeierstrassAddNeChipGpu -{ - fn generate_proving_ctx(&self, arena: DenseRecordArena) -> AirProvingContext { - let range_bus = self.range_checker.cpu_chip.as_ref().unwrap().bus(); - let expr = ec_add_ne_expr(self.config.clone(), range_bus); - - let total_input_limbs = expr.builder.num_input * expr.canonical_num_limbs(); - let layout = AdapterCoreLayout::with_metadata(FieldExpressionMetadata::< - F, - Rv32VecHeapAdapterExecutor<2, BLOCKS, BLOCKS, BLOCK_SIZE, BLOCK_SIZE>, - >::new(total_input_limbs)); - - let record_size = RecordSeeker::< - DenseRecordArena, - EccRecord<2, BLOCKS, BLOCK_SIZE>, - _, - >::get_aligned_record_size(&layout); - - let records = arena.allocated(); - if records.is_empty() { - return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); - } - debug_assert_eq!(records.len() % record_size, 0); - - let num_records = records.len() / record_size; - - let local_opcode_idx = vec![ - Rv32WeierstrassOpcode::EC_ADD_NE as usize, - Rv32WeierstrassOpcode::SETUP_EC_ADD_NE as usize, - ]; - - let air = FieldExpressionCoreAir::new(expr, self.offset, local_opcode_idx, vec![]); - - let adapter_width = - Rv32VecHeapAdapterCols::::width(); - - let d_records = records.to_device().unwrap(); - - let field_expr_chip = FieldExpressionChipGPU::new( - air, - d_records, - num_records, - record_size, - adapter_width, - BLOCKS, - self.range_checker.clone(), - self.bitwise_lookup.clone(), - self.pointer_max_bits, - self.timestamp_max_bits, - ); - - let d_trace = field_expr_chip.generate_field_trace(); - - AirProvingContext::simple_no_pis(d_trace) - } -} diff --git a/extensions/ecc/circuit/src/weierstrass_chip/add_ne/mod.rs b/extensions/ecc/circuit/src/weierstrass_chip/add_ne/mod.rs index 9973e8af2d..044ca35466 100644 --- a/extensions/ecc/circuit/src/weierstrass_chip/add_ne/mod.rs +++ b/extensions/ecc/circuit/src/weierstrass_chip/add_ne/mod.rs @@ -25,13 +25,8 @@ use openvm_rv32_adapters::{ use super::{WeierstrassAir, WeierstrassChip}; -#[cfg(feature = "cuda")] -mod cuda; mod execution; -#[cfg(feature = "cuda")] -pub use cuda::*; - // Assumes that (x1, y1), (x2, y2) both lie on the curve and are not the identity point. // Further assumes that x1, x2 are not equal in the coordinate field. pub fn ec_add_ne_expr( diff --git a/extensions/ecc/circuit/src/weierstrass_chip/double/cuda.rs b/extensions/ecc/circuit/src/weierstrass_chip/double/cuda.rs deleted file mode 100644 index 6c19ef1b36..0000000000 --- a/extensions/ecc/circuit/src/weierstrass_chip/double/cuda.rs +++ /dev/null @@ -1,88 +0,0 @@ -use std::sync::Arc; - -use derive_new::new; -use num_bigint::BigUint; -use openvm_circuit::arch::{AdapterCoreLayout, DenseRecordArena, RecordSeeker}; -use openvm_circuit_primitives::{ - bitwise_op_lookup::BitwiseOperationLookupChipGPU, var_range::VariableRangeCheckerChipGPU, Chip, -}; -use openvm_cuda_backend::{base::DeviceMatrix, prelude::F, GpuBackend}; -use openvm_cuda_common::copy::MemCopyH2D; -use openvm_ecc_transpiler::Rv32WeierstrassOpcode; -use openvm_instructions::riscv::RV32_CELL_BITS; -use openvm_mod_circuit_builder::{ - ExprBuilderConfig, FieldExpressionChipGPU, FieldExpressionCoreAir, FieldExpressionMetadata, -}; -use openvm_rv32_adapters::{Rv32VecHeapAdapterCols, Rv32VecHeapAdapterExecutor}; -use openvm_stark_backend::prover::AirProvingContext; - -use crate::{ec_double_ne_expr, EccRecord}; - -#[derive(new)] -pub struct WeierstrassDoubleChipGpu { - pub range_checker: Arc, - pub bitwise_lookup: Arc>, - pub config: ExprBuilderConfig, - pub offset: usize, - pub a_biguint: BigUint, - pub pointer_max_bits: u32, - pub timestamp_max_bits: u32, -} - -impl Chip - for WeierstrassDoubleChipGpu -{ - fn generate_proving_ctx(&self, arena: DenseRecordArena) -> AirProvingContext { - let range_bus = self.range_checker.cpu_chip.as_ref().unwrap().bus(); - let expr = ec_double_ne_expr(self.config.clone(), range_bus, self.a_biguint.clone()); - - let total_input_limbs = expr.builder.num_input * expr.canonical_num_limbs(); - let layout = AdapterCoreLayout::with_metadata(FieldExpressionMetadata::< - F, - Rv32VecHeapAdapterExecutor<1, BLOCKS, BLOCKS, BLOCK_SIZE, BLOCK_SIZE>, - >::new(total_input_limbs)); - - let record_size = RecordSeeker::< - DenseRecordArena, - EccRecord<1, BLOCKS, BLOCK_SIZE>, - _, - >::get_aligned_record_size(&layout); - - let records = arena.allocated(); - if records.is_empty() { - return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); - } - debug_assert_eq!(records.len() % record_size, 0); - - let num_records = records.len() / record_size; - - let local_opcode_idx = vec![ - Rv32WeierstrassOpcode::EC_DOUBLE as usize, - Rv32WeierstrassOpcode::SETUP_EC_DOUBLE as usize, - ]; - - let air = FieldExpressionCoreAir::new(expr, self.offset, local_opcode_idx, vec![]); - - let adapter_width = - Rv32VecHeapAdapterCols::::width(); - - let d_records = records.to_device().unwrap(); - - let field_expr_chip = FieldExpressionChipGPU::new( - air, - d_records, - num_records, - record_size, - adapter_width, - BLOCKS, - self.range_checker.clone(), - self.bitwise_lookup.clone(), - self.pointer_max_bits, - self.timestamp_max_bits, - ); - - let d_trace = field_expr_chip.generate_field_trace(); - - AirProvingContext::simple_no_pis(d_trace) - } -} diff --git a/extensions/ecc/circuit/src/weierstrass_chip/double/mod.rs b/extensions/ecc/circuit/src/weierstrass_chip/double/mod.rs index b65d2c03e3..3ddabab32c 100644 --- a/extensions/ecc/circuit/src/weierstrass_chip/double/mod.rs +++ b/extensions/ecc/circuit/src/weierstrass_chip/double/mod.rs @@ -29,13 +29,8 @@ use super::{ WeierstrassAir, WeierstrassChip, }; -#[cfg(feature = "cuda")] -mod cuda; mod execution; -#[cfg(feature = "cuda")] -pub use cuda::*; - pub fn ec_double_ne_expr( config: ExprBuilderConfig, // The coordinate field. range_bus: VariableRangeCheckerBus, diff --git a/extensions/ecc/circuit/src/weierstrass_chip/tests.rs b/extensions/ecc/circuit/src/weierstrass_chip/tests.rs index b6bf8d184a..7ac0972890 100644 --- a/extensions/ecc/circuit/src/weierstrass_chip/tests.rs +++ b/extensions/ecc/circuit/src/weierstrass_chip/tests.rs @@ -7,7 +7,7 @@ use openvm_circuit::arch::{ testing::{ memory::gen_pointer, TestBuilder, TestChipHarness, VmChipTestBuilder, BITWISE_OP_LOOKUP_BUS, }, - Arena, MatrixRecordArena, PreflightExecutor, + Arena, MatrixRecordArena, PreflightExecutor, CONST_BLOCK_SIZE, }; use openvm_circuit_primitives::{ bigint::utils::{secp256k1_coord_prime, secp256r1_coord_prime}, @@ -31,7 +31,7 @@ use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng}; use rand::{rngs::StdRng, Rng}; #[cfg(feature = "cuda")] use { - crate::{EccRecord, WeierstrassAddNeChipGpu}, + crate::extension::HybridWeierstrassChip, openvm_circuit::arch::testing::{ default_bitwise_lookup_bus, default_var_range_checker_bus, GpuChipTestBuilder, GpuTestChipHarness, @@ -41,7 +41,8 @@ use { use crate::{ get_ec_addne_air, get_ec_addne_chip, get_ec_addne_step, get_ec_double_air, get_ec_double_chip, - get_ec_double_step, EcDoubleExecutor, WeierstrassAir, WeierstrassChip, + get_ec_double_step, EcDoubleExecutor, WeierstrassAir, WeierstrassChip, ECC_BLOCKS_32, + ECC_BLOCKS_48, NUM_LIMBS_32, NUM_LIMBS_48, }; const LIMB_BITS: usize = 8; @@ -110,14 +111,6 @@ mod ec_addne_tests { WeierstrassChip, >; - #[cfg(feature = "cuda")] - type GpuHarness = GpuTestChipHarness< - F, - EcAddNeExecutor, - WeierstrassAir<2, BLOCKS, BLOCK_SIZE>, - WeierstrassAddNeChipGpu, - WeierstrassChip, - >; fn create_harness( tester: &VmChipTestBuilder, @@ -163,6 +156,15 @@ mod ec_addne_tests { (harness, (bitwise_chip.air, bitwise_chip)) } + #[cfg(feature = "cuda")] + type GpuHarness = GpuTestChipHarness< + F, + EcAddNeExecutor, + WeierstrassAir<2, BLOCKS, BLOCK_SIZE>, + HybridWeierstrassChip, + WeierstrassChip, + >; + #[cfg(feature = "cuda")] fn create_cuda_harness( tester: &GpuChipTestBuilder, @@ -200,18 +202,19 @@ mod ec_addne_tests { dummy_bitwise_chip, tester.address_bits(), ); - let gpu_chip = WeierstrassAddNeChipGpu::new( - tester.range_checker(), - tester.bitwise_op_lookup(), + + let hybrid_chip = HybridWeierstrassChip::new(get_ec_addne_chip( config, - offset, - tester.address_bits() as u32, - tester.timestamp_max_bits() as u32, - ); + tester.cpu_memory_helper(), + tester.cpu_range_checker(), + tester.cpu_bitwise_op_lookup(), + tester.address_bits(), + )); - GpuTestChipHarness::with_capacity(executor, air, gpu_chip, cpu_chip, MAX_INS_CAPACITY) + GpuTestChipHarness::with_capacity(executor, air, hybrid_chip, cpu_chip, MAX_INS_CAPACITY) } + #[allow(clippy::too_many_arguments)] fn set_and_execute_ec_addne< const BLOCKS: usize, @@ -412,10 +415,16 @@ mod ec_addne_tests { } #[cfg(feature = "cuda")] - fn run_cuda_ec_addne( + fn run_cuda_ec_addne< + const BLOCKS: usize, + const BLOCK_SIZE: usize, + const NUM_LIMBS: usize, + >( offset: usize, modulus: BigUint, ) { + use crate::EccRecord; + let mut rng = create_seeded_rng(); let mut tester = @@ -484,7 +493,7 @@ mod ec_addne_tests { #[cfg(feature = "cuda")] #[test] fn test_weierstrass_addne_cuda_2x32() { - run_cuda_ec_addne::<2, 32, 32>( + run_cuda_ec_addne::( Rv32WeierstrassOpcode::CLASS_OFFSET, secp256k1_coord_prime(), ); @@ -493,7 +502,7 @@ mod ec_addne_tests { #[cfg(feature = "cuda")] #[test] fn test_weierstrass_addne_cuda_6x16() { - run_cuda_ec_addne::<6, 16, 48>( + run_cuda_ec_addne::( Rv32WeierstrassOpcode::CLASS_OFFSET, BLS12_381_MODULUS.clone(), ); @@ -551,17 +560,7 @@ mod ec_double_tests { MatrixRecordArena, >; - #[cfg(feature = "cuda")] - use crate::WeierstrassDoubleChipGpu; - #[cfg(feature = "cuda")] - type GpuHarness = GpuTestChipHarness< - F, - EcDoubleExecutor, - WeierstrassAir<1, BLOCKS, BLOCK_SIZE>, - WeierstrassDoubleChipGpu, - WeierstrassChip, - >; fn create_harness( tester: &VmChipTestBuilder, @@ -609,6 +608,15 @@ mod ec_double_tests { (harness, (bitwise_chip.air, bitwise_chip)) } + #[cfg(feature = "cuda")] + type GpuHarness = GpuTestChipHarness< + F, + EcDoubleExecutor, + WeierstrassAir<1, BLOCKS, BLOCK_SIZE>, + HybridWeierstrassChip, + WeierstrassChip, + >; + #[cfg(feature = "cuda")] fn create_cuda_harness( tester: &GpuChipTestBuilder, @@ -651,19 +659,19 @@ mod ec_double_tests { tester.address_bits(), a_biguint.clone(), ); - let gpu_chip = WeierstrassDoubleChipGpu::new( - tester.range_checker(), - tester.bitwise_op_lookup(), + let hybrid_chip = HybridWeierstrassChip::new(get_ec_double_chip( config, - offset, + tester.cpu_memory_helper(), + tester.cpu_range_checker(), + tester.cpu_bitwise_op_lookup(), + tester.address_bits(), a_biguint, - tester.address_bits() as u32, - tester.timestamp_max_bits() as u32, - ); + )); - GpuTestChipHarness::with_capacity(executor, air, gpu_chip, cpu_chip, MAX_INS_CAPACITY) + GpuTestChipHarness::with_capacity(executor, air, hybrid_chip, cpu_chip, MAX_INS_CAPACITY) } + #[allow(clippy::too_many_arguments)] fn set_and_execute_ec_double< const BLOCKS: usize, @@ -893,6 +901,8 @@ mod ec_double_tests { num_ops: usize, a: BigUint, ) { + use crate::EccRecord; + let mut rng = create_seeded_rng(); let mut tester = @@ -907,6 +917,7 @@ mod ec_double_tests { let mut harness = create_cuda_harness::(&tester, config, offset, a.clone()); + // Run some operations for i in 0..num_ops { set_and_execute_ec_double::( &mut tester, @@ -992,7 +1003,7 @@ mod ec_double_tests { #[cfg(feature = "cuda")] #[test] fn test_ec_double_cuda_2x32() { - run_ec_double_cuda_test::<2, 32, 32>( + run_ec_double_cuda_test::( Rv32WeierstrassOpcode::CLASS_OFFSET, secp256k1_coord_prime(), 50, @@ -1006,7 +1017,7 @@ mod ec_double_tests { let coeff_a = (-secp256r1::Fp::from(3)).to_bytes(); let a = BigUint::from_bytes_le(&coeff_a); - run_ec_double_cuda_test::<2, 32, 32>( + run_ec_double_cuda_test::( Rv32WeierstrassOpcode::CLASS_OFFSET, secp256r1_coord_prime(), 50, @@ -1017,7 +1028,7 @@ mod ec_double_tests { #[cfg(feature = "cuda")] #[test] fn test_ec_double_cuda_6x16() { - run_ec_double_cuda_test::<6, 16, 48>( + run_ec_double_cuda_test::( Rv32WeierstrassOpcode::CLASS_OFFSET, BLS12_381_MODULUS.clone(), 50, From 7cf257a7f844a28ad87ecf48e4c202b41ca5701b Mon Sep 17 00:00:00 2001 From: Tuanlinh12312 <136139181+Tuanlinh12312@users.noreply.github.com> Date: Thu, 29 Jan 2026 20:10:03 -0500 Subject: [PATCH 23/78] feat: update algebra and ecc extensions to use BLOCK_SIZE=4 (#2370) Resolves INT-5949 INT-5952 INT-5951 INT-5948. --------- Co-authored-by: Paul Chen Co-authored-by: Claude Opus 4.5 Co-authored-by: Jonathan Wang <31040440+jonathanpwang@users.noreply.github.com> --- crates/vm/src/arch/testing/cpu.rs | 31 ++-- crates/vm/src/arch/testing/cuda.rs | 22 +-- .../algebra/circuit/src/extension/fp2.rs | 67 ++++---- .../algebra/circuit/src/extension/hybrid.rs | 73 ++++---- .../algebra/circuit/src/extension/modular.rs | 157 ++++++++++-------- .../algebra/circuit/src/fp2_chip/tests.rs | 16 +- .../algebra/circuit/src/modular_chip/tests.rs | 152 ++++++++++++----- .../ecc/circuit/src/extension/hybrid.rs | 31 ++-- .../ecc/circuit/src/extension/weierstrass.rs | 65 ++++---- .../ecc/circuit/src/weierstrass_chip/tests.rs | 32 ++-- 10 files changed, 377 insertions(+), 269 deletions(-) diff --git a/crates/vm/src/arch/testing/cpu.rs b/crates/vm/src/arch/testing/cpu.rs index 58299c7e10..24c56e48ec 100644 --- a/crates/vm/src/arch/testing/cpu.rs +++ b/crates/vm/src/arch/testing/cpu.rs @@ -176,8 +176,15 @@ where ) -> (usize, usize) { let register = self.get_default_register(reg_increment); let pointer = self.get_default_pointer(pointer_increment); - // Cast to u32 to ensure we write exactly 4 bytes (RV32 register size). - self.write(1, register, (pointer as u32).to_le_bytes().map(F::from_u8)); + // Write pointer in CONST_BLOCK_SIZE-byte chunks to avoid generating access adapter records + // when access adapters are disabled (min_block_size = CONST_BLOCK_SIZE for register address + // space). The pointer is RV32_REGISTER_NUM_LIMBS bytes (32-bit for RV32). + let ptr_bytes = (pointer as u32).to_le_bytes(); + for i in (0..RV32_REGISTER_NUM_LIMBS).step_by(CONST_BLOCK_SIZE) { + let chunk: [u8; CONST_BLOCK_SIZE] = + ptr_bytes[i..i + CONST_BLOCK_SIZE].try_into().unwrap(); + self.write::(1, register + i, chunk.map(F::from_u8)); + } (register, pointer) } @@ -227,15 +234,17 @@ impl VmChipTestBuilder { pointer: usize, writes: Vec<[F; NUM_LIMBS]>, ) { - // Cast to u32 to ensure we write exactly 4 bytes (RV32 register size). - // Using usize would write 8 bytes on 64-bit systems, creating access adapter records. - self.write( - 1usize, - register, - (pointer as u32).to_le_bytes().map(F::from_u8), - ); - // When access adapters are disabled, all memory accesses must use CONST_BLOCK_SIZE. - // Always write in chunks of CONST_BLOCK_SIZE to ensure compatibility. + // Write pointer in CONST_BLOCK_SIZE-byte chunks to avoid generating access adapter records + // when access adapters are disabled (min_block_size = CONST_BLOCK_SIZE for register address + // space). The pointer is RV32_REGISTER_NUM_LIMBS bytes (32-bit for RV32). + let ptr_bytes = (pointer as u32).to_le_bytes(); + for i in (0..RV32_REGISTER_NUM_LIMBS).step_by(CONST_BLOCK_SIZE) { + let chunk: [u8; CONST_BLOCK_SIZE] = + ptr_bytes[i..i + CONST_BLOCK_SIZE].try_into().unwrap(); + self.write::(1usize, register + i, chunk.map(F::from_u8)); + } + // Always write in CONST_BLOCK_SIZE-byte chunks to avoid generating + // access adapter records when access adapters are disabled. for (i, &write) in writes.iter().enumerate() { let ptr = pointer + i * NUM_LIMBS; for j in (0..NUM_LIMBS).step_by(CONST_BLOCK_SIZE) { diff --git a/crates/vm/src/arch/testing/cuda.rs b/crates/vm/src/arch/testing/cuda.rs index 7887eddba9..a064310665 100644 --- a/crates/vm/src/arch/testing/cuda.rs +++ b/crates/vm/src/arch/testing/cuda.rs @@ -48,7 +48,7 @@ use crate::{ POSEIDON2_DIRECT_BUS, READ_INSTRUCTION_BUS, }, Arena, DenseRecordArena, ExecutionBridge, ExecutionBus, ExecutionState, MatrixRecordArena, - MemoryConfig, PreflightExecutor, Streams, VmStateMut, + MemoryConfig, PreflightExecutor, Streams, VmStateMut, CONST_BLOCK_SIZE, }, system::{ cuda::{poseidon2::Poseidon2PeripheryChipGPU, DIGEST_WIDTH}, @@ -372,16 +372,16 @@ impl GpuChipTestBuilder { register, (pointer as u32).to_le_bytes().map(F::from_u8), ); - if NUM_LIMBS.is_power_of_two() { - for (i, &write) in writes.iter().enumerate() { - self.write(2usize, pointer + i * NUM_LIMBS, write); - } - } else { - for (i, &write) in writes.iter().enumerate() { - let ptr = pointer + i * NUM_LIMBS; - for j in (0..NUM_LIMBS).step_by(4) { - self.write::<4>(2usize, ptr + j, write[j..j + 4].try_into().unwrap()); - } + // Always write in CONST_BLOCK_SIZE-byte chunks to avoid generating + // access adapter records when access adapters are disabled. + for (i, &write) in writes.iter().enumerate() { + let ptr = pointer + i * NUM_LIMBS; + for j in (0..NUM_LIMBS).step_by(CONST_BLOCK_SIZE) { + self.write::( + 2usize, + ptr + j, + write[j..j + CONST_BLOCK_SIZE].try_into().unwrap(), + ); } } } diff --git a/extensions/algebra/circuit/src/extension/fp2.rs b/extensions/algebra/circuit/src/extension/fp2.rs index 6cbd524f72..80698cb869 100644 --- a/extensions/algebra/circuit/src/extension/fp2.rs +++ b/extensions/algebra/circuit/src/extension/fp2.rs @@ -6,7 +6,7 @@ use openvm_circuit::{ arch::{ AirInventory, AirInventoryError, ChipInventory, ChipInventoryError, ExecutionBridge, ExecutorInventoryBuilder, ExecutorInventoryError, RowMajorMatrixArena, VmCircuitExtension, - VmExecutionExtension, VmProverExtension, + VmExecutionExtension, VmProverExtension, CONST_BLOCK_SIZE, }, system::{memory::SharedMemoryHelper, SystemPort}, }; @@ -31,7 +31,8 @@ use crate::{ get_fp2_addsub_air, get_fp2_addsub_chip, get_fp2_addsub_step, get_fp2_muldiv_air, get_fp2_muldiv_chip, get_fp2_muldiv_step, Fp2Air, Fp2Executor, }, - AlgebraCpuProverExt, ModularExtension, + AlgebraCpuProverExt, ModularExtension, FP2_BLOCKS_32, FP2_BLOCKS_48, NUM_LIMBS_32, + NUM_LIMBS_48, }; #[serde_as] @@ -80,11 +81,11 @@ impl Fp2Extension { )] pub enum Fp2ExtensionExecutor { // 32 limbs prime - Fp2AddSubRv32_32(Fp2Executor<2, 32>), // Fp2AddSub - Fp2MulDivRv32_32(Fp2Executor<2, 32>), // Fp2MulDiv + Fp2AddSubRv32_32(Fp2Executor), // Fp2AddSub + Fp2MulDivRv32_32(Fp2Executor), // Fp2MulDiv // 48 limbs prime - Fp2AddSubRv32_48(Fp2Executor<6, 16>), // Fp2AddSub - Fp2MulDivRv32_48(Fp2Executor<6, 16>), // Fp2MulDiv + Fp2AddSubRv32_48(Fp2Executor), // Fp2AddSub + Fp2MulDivRv32_48(Fp2Executor), // Fp2MulDiv } impl VmExecutionExtension for Fp2Extension { @@ -99,13 +100,13 @@ impl VmExecutionExtension for Fp2Extension { let dummy_range_checker_bus = VariableRangeCheckerBus::new(u16::MAX, 16); for (i, (_, modulus)) in self.supported_moduli.iter().enumerate() { // determine the number of bytes needed to represent a prime field element - let bytes = modulus.bits().div_ceil(8); + let bytes = modulus.bits().div_ceil(8) as usize; let start_offset = Fp2Opcode::CLASS_OFFSET + i * Fp2Opcode::COUNT; - if bytes <= 32 { + if bytes <= NUM_LIMBS_32 { let config = ExprBuilderConfig { modulus: modulus.clone(), - num_limbs: 32, + num_limbs: NUM_LIMBS_32, limb_bits: 8, }; let addsub = get_fp2_addsub_step( @@ -133,10 +134,10 @@ impl VmExecutionExtension for Fp2Extension { ((Fp2Opcode::MUL as usize)..=(Fp2Opcode::SETUP_MULDIV as usize)) .map(|x| VmOpcode::from_usize(x + start_offset)), )?; - } else if bytes <= 48 { + } else if bytes <= NUM_LIMBS_48 { let config = ExprBuilderConfig { modulus: modulus.clone(), - num_limbs: 48, + num_limbs: NUM_LIMBS_48, limb_bits: 8, }; let addsub = get_fp2_addsub_step( @@ -198,17 +199,17 @@ impl VmCircuitExtension for Fp2Extension { }; for (i, (_, modulus)) in self.supported_moduli.iter().enumerate() { // determine the number of bytes needed to represent a prime field element - let bytes = modulus.bits().div_ceil(8); + let bytes = modulus.bits().div_ceil(8) as usize; let start_offset = Fp2Opcode::CLASS_OFFSET + i * Fp2Opcode::COUNT; - if bytes <= 32 { + if bytes <= NUM_LIMBS_32 { let config = ExprBuilderConfig { modulus: modulus.clone(), - num_limbs: 32, + num_limbs: NUM_LIMBS_32, limb_bits: 8, }; - let addsub = get_fp2_addsub_air::<2, 32>( + let addsub = get_fp2_addsub_air::( exec_bridge, memory_bridge, config.clone(), @@ -219,7 +220,7 @@ impl VmCircuitExtension for Fp2Extension { ); inventory.add_air(addsub); - let muldiv = get_fp2_muldiv_air::<2, 32>( + let muldiv = get_fp2_muldiv_air::( exec_bridge, memory_bridge, config, @@ -229,14 +230,14 @@ impl VmCircuitExtension for Fp2Extension { start_offset, ); inventory.add_air(muldiv); - } else if bytes <= 48 { + } else if bytes <= NUM_LIMBS_48 { let config = ExprBuilderConfig { modulus: modulus.clone(), - num_limbs: 48, + num_limbs: NUM_LIMBS_48, limb_bits: 8, }; - let addsub = get_fp2_addsub_air::<6, 16>( + let addsub = get_fp2_addsub_air::( exec_bridge, memory_bridge, config.clone(), @@ -247,7 +248,7 @@ impl VmCircuitExtension for Fp2Extension { ); inventory.add_air(addsub); - let muldiv = get_fp2_muldiv_air::<6, 16>( + let muldiv = get_fp2_muldiv_air::( exec_bridge, memory_bridge, config, @@ -300,17 +301,17 @@ where }; for (_, modulus) in extension.supported_moduli.iter() { // determine the number of bytes needed to represent a prime field element - let bytes = modulus.bits().div_ceil(8); + let bytes = modulus.bits().div_ceil(8) as usize; - if bytes <= 32 { + if bytes <= NUM_LIMBS_32 { let config = ExprBuilderConfig { modulus: modulus.clone(), - num_limbs: 32, + num_limbs: NUM_LIMBS_32, limb_bits: 8, }; - inventory.next_air::>()?; - let addsub = get_fp2_addsub_chip::, 2, 32>( + inventory.next_air::>()?; + let addsub = get_fp2_addsub_chip::, FP2_BLOCKS_32, CONST_BLOCK_SIZE>( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -319,8 +320,8 @@ where ); inventory.add_executor_chip(addsub); - inventory.next_air::>()?; - let muldiv = get_fp2_muldiv_chip::, 2, 32>( + inventory.next_air::>()?; + let muldiv = get_fp2_muldiv_chip::, FP2_BLOCKS_32, CONST_BLOCK_SIZE>( config, mem_helper.clone(), range_checker.clone(), @@ -328,15 +329,15 @@ where pointer_max_bits, ); inventory.add_executor_chip(muldiv); - } else if bytes <= 48 { + } else if bytes <= NUM_LIMBS_48 { let config = ExprBuilderConfig { modulus: modulus.clone(), - num_limbs: 48, + num_limbs: NUM_LIMBS_48, limb_bits: 8, }; - inventory.next_air::>()?; - let addsub = get_fp2_addsub_chip::, 6, 16>( + inventory.next_air::>()?; + let addsub = get_fp2_addsub_chip::, FP2_BLOCKS_48, CONST_BLOCK_SIZE>( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -345,8 +346,8 @@ where ); inventory.add_executor_chip(addsub); - inventory.next_air::>()?; - let muldiv = get_fp2_muldiv_chip::, 6, 16>( + inventory.next_air::>()?; + let muldiv = get_fp2_muldiv_chip::, FP2_BLOCKS_48, CONST_BLOCK_SIZE>( config, mem_helper.clone(), range_checker.clone(), diff --git a/extensions/algebra/circuit/src/extension/hybrid.rs b/extensions/algebra/circuit/src/extension/hybrid.rs index 1de13eee5c..7da7dabdfb 100644 --- a/extensions/algebra/circuit/src/extension/hybrid.rs +++ b/extensions/algebra/circuit/src/extension/hybrid.rs @@ -2,7 +2,7 @@ use openvm_algebra_transpiler::Rv32ModularArithmeticOpcode; use openvm_circuit::{ - arch::*, + arch::{CONST_BLOCK_SIZE, *}, system::{ cuda::{ extensions::{ @@ -36,6 +36,7 @@ use crate::{ fp2_chip::{get_fp2_addsub_chip, get_fp2_muldiv_chip, Fp2Air, Fp2Chip}, modular_chip::*, AlgebraRecord, Fp2Extension, ModularExtension, Rv32ModularConfig, Rv32ModularWithFp2Config, + FP2_BLOCKS_32, FP2_BLOCKS_48, MODULAR_BLOCKS_32, MODULAR_BLOCKS_48, NUM_LIMBS_32, NUM_LIMBS_48, }; #[derive(derive_new::new)] @@ -152,21 +153,21 @@ impl VmProverExtension>()?; - let addsub = get_modular_addsub_chip::( + inventory.next_air::>()?; + let addsub = get_modular_addsub_chip::( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -175,8 +176,8 @@ impl VmProverExtension>()?; - let muldiv = get_modular_muldiv_chip::( + inventory.next_air::>()?; + let muldiv = get_modular_muldiv_chip::( config, mem_helper.clone(), range_checker.clone(), @@ -192,8 +193,13 @@ impl VmProverExtension>()?; - let is_eq = ModularIsEqualChip::::new( + inventory.next_air::>()?; + let is_eq = ModularIsEqualChip::< + F, + MODULAR_BLOCKS_32, + CONST_BLOCK_SIZE, + NUM_LIMBS_32, + >::new( ModularIsEqualFiller::new( Rv32IsEqualModAdapterFiller::new(pointer_max_bits, bitwise_lu.clone()), start_offset, @@ -203,15 +209,15 @@ impl VmProverExtension>()?; - let addsub = get_modular_addsub_chip::( + inventory.next_air::>()?; + let addsub = get_modular_addsub_chip::( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -220,8 +226,8 @@ impl VmProverExtension>()?; - let muldiv = get_modular_muldiv_chip::( + inventory.next_air::>()?; + let muldiv = get_modular_muldiv_chip::( config, mem_helper.clone(), range_checker.clone(), @@ -237,8 +243,13 @@ impl VmProverExtension>()?; - let is_eq = ModularIsEqualChip::::new( + inventory.next_air::>()?; + let is_eq = ModularIsEqualChip::< + F, + MODULAR_BLOCKS_48, + CONST_BLOCK_SIZE, + NUM_LIMBS_48, + >::new( ModularIsEqualFiller::new( Rv32IsEqualModAdapterFiller::new(pointer_max_bits, bitwise_lu.clone()), start_offset, @@ -322,17 +333,17 @@ impl VmProverExtension>()?; - let addsub = get_fp2_addsub_chip::( + inventory.next_air::>()?; + let addsub = get_fp2_addsub_chip::( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -341,8 +352,8 @@ impl VmProverExtension>()?; - let muldiv = get_fp2_muldiv_chip::( + inventory.next_air::>()?; + let muldiv = get_fp2_muldiv_chip::( config, mem_helper.clone(), range_checker.clone(), @@ -350,15 +361,15 @@ impl VmProverExtension>()?; - let addsub = get_fp2_addsub_chip::( + inventory.next_air::>()?; + let addsub = get_fp2_addsub_chip::( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -367,8 +378,8 @@ impl VmProverExtension>()?; - let muldiv = get_fp2_muldiv_chip::( + inventory.next_air::>()?; + let muldiv = get_fp2_muldiv_chip::( config, mem_helper.clone(), range_checker.clone(), diff --git a/extensions/algebra/circuit/src/extension/modular.rs b/extensions/algebra/circuit/src/extension/modular.rs index 3afd74deec..bb3602deab 100644 --- a/extensions/algebra/circuit/src/extension/modular.rs +++ b/extensions/algebra/circuit/src/extension/modular.rs @@ -8,7 +8,7 @@ use openvm_circuit::{ arch::{ AirInventory, AirInventoryError, ChipInventory, ChipInventoryError, ExecutionBridge, ExecutorInventoryBuilder, ExecutorInventoryError, RowMajorMatrixArena, VmCircuitExtension, - VmExecutionExtension, VmProverExtension, + VmExecutionExtension, VmProverExtension, CONST_BLOCK_SIZE, }, system::{memory::SharedMemoryHelper, SystemPort}, }; @@ -40,7 +40,7 @@ use crate::{ ModularExecutor, ModularIsEqualAir, ModularIsEqualChip, ModularIsEqualCoreAir, ModularIsEqualFiller, VmModularIsEqualExecutor, }, - AlgebraCpuProverExt, + AlgebraCpuProverExt, MODULAR_BLOCKS_32, MODULAR_BLOCKS_48, NUM_LIMBS_32, NUM_LIMBS_48, }; #[serde_as] @@ -74,13 +74,17 @@ impl ModularExtension { )] pub enum ModularExtensionExecutor { // 32 limbs prime - ModularAddSubRv32_32(ModularExecutor<1, 32>), // ModularAddSub - ModularMulDivRv32_32(ModularExecutor<1, 32>), // ModularMulDiv - ModularIsEqualRv32_32(VmModularIsEqualExecutor<1, 32, 32>), // ModularIsEqual + ModularAddSubRv32_32(ModularExecutor), // ModularAddSub + ModularMulDivRv32_32(ModularExecutor), // ModularMulDiv + ModularIsEqualRv32_32( + VmModularIsEqualExecutor, + ), // ModularIsEqual // 48 limbs prime - ModularAddSubRv32_48(ModularExecutor<3, 16>), // ModularAddSub - ModularMulDivRv32_48(ModularExecutor<3, 16>), // ModularMulDiv - ModularIsEqualRv32_48(VmModularIsEqualExecutor<3, 16, 48>), // ModularIsEqual + ModularAddSubRv32_48(ModularExecutor), // ModularAddSub + ModularMulDivRv32_48(ModularExecutor), // ModularMulDiv + ModularIsEqualRv32_48( + VmModularIsEqualExecutor, + ), // ModularIsEqual } impl VmExecutionExtension for ModularExtension { @@ -95,17 +99,17 @@ impl VmExecutionExtension for ModularExtension { let dummy_range_checker_bus = VariableRangeCheckerBus::new(u16::MAX, 16); for (i, modulus) in self.supported_moduli.iter().enumerate() { // determine the number of bytes needed to represent a prime field element - let bytes = modulus.bits().div_ceil(8); + let bytes = modulus.bits().div_ceil(8) as usize; let start_offset = Rv32ModularArithmeticOpcode::CLASS_OFFSET + i * Rv32ModularArithmeticOpcode::COUNT; let modulus_limbs = big_uint_to_limbs(modulus, 8); - if bytes <= 32 { + if bytes <= NUM_LIMBS_32 { let config = ExprBuilderConfig { modulus: modulus.clone(), - num_limbs: 32, + num_limbs: NUM_LIMBS_32, limb_bits: 8, }; - let addsub = get_modular_addsub_step( + let addsub = get_modular_addsub_step::( config.clone(), dummy_range_checker_bus, pointer_max_bits, @@ -119,7 +123,7 @@ impl VmExecutionExtension for ModularExtension { .map(|x| VmOpcode::from_usize(x + start_offset)), )?; - let muldiv = get_modular_muldiv_step( + let muldiv = get_modular_muldiv_step::( config, dummy_range_checker_bus, pointer_max_bits, @@ -153,13 +157,13 @@ impl VmExecutionExtension for ModularExtension { ..=(Rv32ModularArithmeticOpcode::SETUP_ISEQ as usize)) .map(|x| VmOpcode::from_usize(x + start_offset)), )?; - } else if bytes <= 48 { + } else if bytes <= NUM_LIMBS_48 { let config = ExprBuilderConfig { modulus: modulus.clone(), - num_limbs: 48, + num_limbs: NUM_LIMBS_48, limb_bits: 8, }; - let addsub = get_modular_addsub_step( + let addsub = get_modular_addsub_step::( config.clone(), dummy_range_checker_bus, pointer_max_bits, @@ -173,7 +177,7 @@ impl VmExecutionExtension for ModularExtension { .map(|x| VmOpcode::from_usize(x + start_offset)), )?; - let muldiv = get_modular_muldiv_step( + let muldiv = get_modular_muldiv_step::( config, dummy_range_checker_bus, pointer_max_bits, @@ -254,18 +258,18 @@ impl VmCircuitExtension for ModularExtension { }; for (i, modulus) in self.supported_moduli.iter().enumerate() { // determine the number of bytes needed to represent a prime field element - let bytes = modulus.bits().div_ceil(8); + let bytes = modulus.bits().div_ceil(8) as usize; let start_offset = Rv32ModularArithmeticOpcode::CLASS_OFFSET + i * Rv32ModularArithmeticOpcode::COUNT; - if bytes <= 32 { + if bytes <= NUM_LIMBS_32 { let config = ExprBuilderConfig { modulus: modulus.clone(), - num_limbs: 32, + num_limbs: NUM_LIMBS_32, limb_bits: 8, }; - let addsub = get_modular_addsub_air::<1, 32>( + let addsub = get_modular_addsub_air::( exec_bridge, memory_bridge, config.clone(), @@ -276,7 +280,7 @@ impl VmCircuitExtension for ModularExtension { ); inventory.add_air(addsub); - let muldiv = get_modular_muldiv_air::<1, 32>( + let muldiv = get_modular_muldiv_air::( exec_bridge, memory_bridge, config, @@ -287,24 +291,25 @@ impl VmCircuitExtension for ModularExtension { ); inventory.add_air(muldiv); - let is_eq = ModularIsEqualAir::<1, 32, 32>::new( - Rv32IsEqualModAdapterAir::new( - exec_bridge, - memory_bridge, - bitwise_lu, - pointer_max_bits, - ), - ModularIsEqualCoreAir::new(modulus.clone(), bitwise_lu, start_offset), - ); + let is_eq = + ModularIsEqualAir::::new( + Rv32IsEqualModAdapterAir::new( + exec_bridge, + memory_bridge, + bitwise_lu, + pointer_max_bits, + ), + ModularIsEqualCoreAir::new(modulus.clone(), bitwise_lu, start_offset), + ); inventory.add_air(is_eq); - } else if bytes <= 48 { + } else if bytes <= NUM_LIMBS_48 { let config = ExprBuilderConfig { modulus: modulus.clone(), - num_limbs: 48, + num_limbs: NUM_LIMBS_48, limb_bits: 8, }; - let addsub = get_modular_addsub_air::<3, 16>( + let addsub = get_modular_addsub_air::( exec_bridge, memory_bridge, config.clone(), @@ -315,7 +320,7 @@ impl VmCircuitExtension for ModularExtension { ); inventory.add_air(addsub); - let muldiv = get_modular_muldiv_air::<3, 16>( + let muldiv = get_modular_muldiv_air::( exec_bridge, memory_bridge, config, @@ -326,15 +331,16 @@ impl VmCircuitExtension for ModularExtension { ); inventory.add_air(muldiv); - let is_eq = ModularIsEqualAir::<3, 16, 48>::new( - Rv32IsEqualModAdapterAir::new( - exec_bridge, - memory_bridge, - bitwise_lu, - pointer_max_bits, - ), - ModularIsEqualCoreAir::new(modulus.clone(), bitwise_lu, start_offset), - ); + let is_eq = + ModularIsEqualAir::::new( + Rv32IsEqualModAdapterAir::new( + exec_bridge, + memory_bridge, + bitwise_lu, + pointer_max_bits, + ), + ModularIsEqualCoreAir::new(modulus.clone(), bitwise_lu, start_offset), + ); inventory.add_air(is_eq); } else { panic!("Modulus too large"); @@ -379,21 +385,21 @@ where }; for (i, modulus) in extension.supported_moduli.iter().enumerate() { // determine the number of bytes needed to represent a prime field element - let bytes = modulus.bits().div_ceil(8); + let bytes = modulus.bits().div_ceil(8) as usize; let start_offset = Rv32ModularArithmeticOpcode::CLASS_OFFSET + i * Rv32ModularArithmeticOpcode::COUNT; let modulus_limbs = big_uint_to_limbs(modulus, 8); - if bytes <= 32 { + if bytes <= NUM_LIMBS_32 { let config = ExprBuilderConfig { modulus: modulus.clone(), - num_limbs: 32, + num_limbs: NUM_LIMBS_32, limb_bits: 8, }; - inventory.next_air::>()?; - let addsub = get_modular_addsub_chip::, 1, 32>( + inventory.next_air::>()?; + let addsub = get_modular_addsub_chip::, MODULAR_BLOCKS_32, CONST_BLOCK_SIZE>( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -402,8 +408,8 @@ where ); inventory.add_executor_chip(addsub); - inventory.next_air::>()?; - let muldiv = get_modular_muldiv_chip::, 1, 32>( + inventory.next_air::>()?; + let muldiv = get_modular_muldiv_chip::, MODULAR_BLOCKS_32, CONST_BLOCK_SIZE>( config, mem_helper.clone(), range_checker.clone(), @@ -419,8 +425,13 @@ where 0 } }); - inventory.next_air::>()?; - let is_eq = ModularIsEqualChip::, 1, 32, 32>::new( + inventory.next_air::>()?; + let is_eq = ModularIsEqualChip::< + Val, + MODULAR_BLOCKS_32, + CONST_BLOCK_SIZE, + NUM_LIMBS_32, + >::new( ModularIsEqualFiller::new( Rv32IsEqualModAdapterFiller::new(pointer_max_bits, bitwise_lu.clone()), start_offset, @@ -430,15 +441,15 @@ where mem_helper.clone(), ); inventory.add_executor_chip(is_eq); - } else if bytes <= 48 { + } else if bytes <= NUM_LIMBS_48 { let config = ExprBuilderConfig { modulus: modulus.clone(), - num_limbs: 48, + num_limbs: NUM_LIMBS_48, limb_bits: 8, }; - inventory.next_air::>()?; - let addsub = get_modular_addsub_chip::, 3, 16>( + inventory.next_air::>()?; + let addsub = get_modular_addsub_chip::, MODULAR_BLOCKS_48, CONST_BLOCK_SIZE>( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -447,8 +458,8 @@ where ); inventory.add_executor_chip(addsub); - inventory.next_air::>()?; - let muldiv = get_modular_muldiv_chip::, 3, 16>( + inventory.next_air::>()?; + let muldiv = get_modular_muldiv_chip::, MODULAR_BLOCKS_48, CONST_BLOCK_SIZE>( config, mem_helper.clone(), range_checker.clone(), @@ -464,8 +475,13 @@ where 0 } }); - inventory.next_air::>()?; - let is_eq = ModularIsEqualChip::, 3, 16, 48>::new( + inventory.next_air::>()?; + let is_eq = ModularIsEqualChip::< + Val, + MODULAR_BLOCKS_48, + CONST_BLOCK_SIZE, + NUM_LIMBS_48, + >::new( ModularIsEqualFiller::new( Rv32IsEqualModAdapterFiller::new(pointer_max_bits, bitwise_lu.clone()), start_offset, @@ -502,6 +518,7 @@ pub(crate) mod phantom { use rand::{rngs::StdRng, SeedableRng}; use super::{find_non_qr, mod_sqrt}; + use crate::{NUM_LIMBS_32, NUM_LIMBS_48}; #[derive(derive_new::new)] pub struct SqrtHintSubEx(NonQrHintSubEx); @@ -535,10 +552,11 @@ pub(crate) mod phantom { ); } let modulus = &self.supported_moduli[mod_idx]; - let num_limbs: usize = if modulus.bits().div_ceil(8) <= 32 { - 32 - } else if modulus.bits().div_ceil(8) <= 48 { - 48 + let bytes = modulus.bits().div_ceil(8) as usize; + let num_limbs: usize = if bytes <= NUM_LIMBS_32 { + NUM_LIMBS_32 + } else if bytes <= NUM_LIMBS_48 { + NUM_LIMBS_48 } else { bail!("Modulus too large") }; @@ -624,10 +642,11 @@ pub(crate) mod phantom { } let modulus = &self.supported_moduli[mod_idx]; - let num_limbs: usize = if modulus.bits().div_ceil(8) <= 32 { - 32 - } else if modulus.bits().div_ceil(8) <= 48 { - 48 + let bytes = modulus.bits().div_ceil(8) as usize; + let num_limbs: usize = if bytes <= NUM_LIMBS_32 { + NUM_LIMBS_32 + } else if bytes <= NUM_LIMBS_48 { + NUM_LIMBS_48 } else { bail!("Modulus too large") }; diff --git a/extensions/algebra/circuit/src/fp2_chip/tests.rs b/extensions/algebra/circuit/src/fp2_chip/tests.rs index 449c862ca7..93c6e64cd3 100644 --- a/extensions/algebra/circuit/src/fp2_chip/tests.rs +++ b/extensions/algebra/circuit/src/fp2_chip/tests.rs @@ -273,42 +273,42 @@ struct TestConfig::new( +#[test_case(TestConfig::<{FP2_BLOCKS_32}, {CONST_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( BigUint::from_str("357686312646216567629137").unwrap(), true, 50, ))] -#[test_case(TestConfig::<2, 32, 32>::new( +#[test_case(TestConfig::<{FP2_BLOCKS_32}, {CONST_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( secp256k1_coord_prime(), true, 50, ))] -#[test_case(TestConfig::<2, 32, 32>::new( +#[test_case(TestConfig::<{FP2_BLOCKS_32}, {CONST_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( BN254_MODULUS.clone(), true, 50, ))] -#[test_case(TestConfig::<6, 16, 48>::new( +#[test_case(TestConfig::<{FP2_BLOCKS_48}, {CONST_BLOCK_SIZE}, {NUM_LIMBS_48}>::new( BLS12_381_MODULUS.clone(), true, 50, ))] -#[test_case(TestConfig::<2, 32, 32>::new( +#[test_case(TestConfig::<{FP2_BLOCKS_32}, {CONST_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( BigUint::from_str("357686312646216567629137").unwrap(), false, 50, ))] -#[test_case(TestConfig::<2, 32, 32>::new( +#[test_case(TestConfig::<{FP2_BLOCKS_32}, {CONST_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( secp256k1_coord_prime(), false, 50, ))] -#[test_case(TestConfig::<2, 32, 32>::new( +#[test_case(TestConfig::<{FP2_BLOCKS_32}, {CONST_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( BN254_MODULUS.clone(), false, 50, ))] -#[test_case(TestConfig::<6, 16, 48>::new( +#[test_case(TestConfig::<{FP2_BLOCKS_48}, {CONST_BLOCK_SIZE}, {NUM_LIMBS_48}>::new( BLS12_381_MODULUS.clone(), false, 50, diff --git a/extensions/algebra/circuit/src/modular_chip/tests.rs b/extensions/algebra/circuit/src/modular_chip/tests.rs index a9e5e194a2..e2b039b637 100644 --- a/extensions/algebra/circuit/src/modular_chip/tests.rs +++ b/extensions/algebra/circuit/src/modular_chip/tests.rs @@ -70,7 +70,6 @@ mod addsub_tests { ModularChip, >; - fn create_harness( tester: &VmChipTestBuilder, config: ExprBuilderConfig, @@ -170,7 +169,6 @@ mod addsub_tests { GpuHarness::with_capacity(executor, air, hybrid_chip, cpu_chip, MAX_INS_CAPACITY) } - fn set_and_execute_addsub< const BLOCKS: usize, const BLOCK_SIZE: usize, @@ -305,8 +303,8 @@ mod addsub_tests { } #[test] - fn test_modular_addsub_1x32_small() { - run_addsub_test::<1, 32, 32>( + fn test_modular_addsub_32limb_small() { + run_addsub_test::( 0, BigUint::from_str("357686312646216567629137").unwrap(), 50, @@ -314,19 +312,35 @@ mod addsub_tests { } #[test] - fn test_modular_addsub_1x32_secp256k1() { - run_addsub_test::<1, 32, 32>(0, secp256k1_coord_prime(), 50); - run_addsub_test::<1, 32, 32>(4, secp256k1_scalar_prime(), 50); + fn test_modular_addsub_32limb_secp256k1() { + run_addsub_test::( + 0, + secp256k1_coord_prime(), + 50, + ); + run_addsub_test::( + 4, + secp256k1_scalar_prime(), + 50, + ); } #[test] - fn test_modular_addsub_1x32_bn254() { - run_addsub_test::<1, 32, 32>(0, BN254_MODULUS.clone(), 50); + fn test_modular_addsub_32limb_bn254() { + run_addsub_test::( + 0, + BN254_MODULUS.clone(), + 50, + ); } #[test] - fn test_modular_addsub_3x16_bls12_381() { - run_addsub_test::<3, 16, 48>(0, BLS12_381_MODULUS.clone(), 50); + fn test_modular_addsub_48limb_bls12_381() { + run_addsub_test::( + 0, + BLS12_381_MODULUS.clone(), + 50, + ); } #[cfg(feature = "cuda")] @@ -426,7 +440,6 @@ mod muldiv_tests { ModularChip, >; - fn create_harness( tester: &VmChipTestBuilder, config: ExprBuilderConfig, @@ -528,7 +541,6 @@ mod muldiv_tests { GpuHarness::with_capacity(executor, air, hybrid_chip, cpu_chip, MAX_INS_CAPACITY) } - fn set_and_execute_muldiv< const BLOCKS: usize, const BLOCK_SIZE: usize, @@ -664,8 +676,8 @@ mod muldiv_tests { } #[test] - fn test_modular_muldiv_1x32_small() { - run_test_muldiv::<1, 32, 32>( + fn test_modular_muldiv_32limb_small() { + run_test_muldiv::( 0, BigUint::from_str("357686312646216567629137").unwrap(), 50, @@ -673,19 +685,35 @@ mod muldiv_tests { } #[test] - fn test_modular_muldiv_1x32_secp256k1() { - run_test_muldiv::<1, 32, 32>(0, secp256k1_coord_prime(), 50); - run_test_muldiv::<1, 32, 32>(4, secp256k1_scalar_prime(), 50); + fn test_modular_muldiv_32limb_secp256k1() { + run_test_muldiv::( + 0, + secp256k1_coord_prime(), + 50, + ); + run_test_muldiv::( + 4, + secp256k1_scalar_prime(), + 50, + ); } #[test] - fn test_modular_muldiv_1x32_bn254() { - run_test_muldiv::<1, 32, 32>(0, BN254_MODULUS.clone(), 50); + fn test_modular_muldiv_32limb_bn254() { + run_test_muldiv::( + 0, + BN254_MODULUS.clone(), + 50, + ); } #[test] - fn test_modular_muldiv_3x16_bls12_381() { - run_test_muldiv::<3, 16, 48>(0, BLS12_381_MODULUS.clone(), 50); + fn test_modular_muldiv_48limb_bls12_381() { + run_test_muldiv::( + 0, + BLS12_381_MODULUS.clone(), + 50, + ); } #[cfg(feature = "cuda")] @@ -952,13 +980,21 @@ mod is_equal_tests { } #[test] - fn test_modular_is_equal_1x32() { - test_is_equal::<1, 32, 32>(17, secp256k1_coord_prime(), 100); + fn test_modular_is_equal_32limb() { + test_is_equal::( + 17, + secp256k1_coord_prime(), + 100, + ); } #[test] - fn test_modular_is_equal_3x16() { - test_is_equal::<3, 16, 48>(17, BLS12_381_MODULUS.clone(), 100); + fn test_modular_is_equal_48limb() { + test_is_equal::( + 17, + BLS12_381_MODULUS.clone(), + 100, + ); } #[cfg(feature = "cuda")] @@ -1016,18 +1052,20 @@ mod is_equal_tests { // Use hybrid chip wrapping the CPU chip let hybrid_chip = - HybridModularIsEqualChip::new(ModularIsEqualChip::::new( - ModularIsEqualFiller::new( - Rv32IsEqualModAdapterFiller::new( - tester.address_bits(), + HybridModularIsEqualChip::new( + ModularIsEqualChip::::new( + ModularIsEqualFiller::new( + Rv32IsEqualModAdapterFiller::new( + tester.address_bits(), + tester.cpu_bitwise_op_lookup(), + ), + offset, + modulus_limbs, tester.cpu_bitwise_op_lookup(), ), - offset, - modulus_limbs, - tester.cpu_bitwise_op_lookup(), + tester.cpu_memory_helper(), ), - tester.cpu_memory_helper(), - )); + ); GpuHarness::with_capacity(executor, air, hybrid_chip, cpu_chip, MAX_INS_CAPACITY) } @@ -1216,16 +1254,44 @@ mod is_equal_tests { } #[test] - fn negative_test_modular_is_equal_1x32() { - run_negative_is_equal_test::<1, 32, 32>(secp256k1_coord_prime(), 17, 1); - run_negative_is_equal_test::<1, 32, 32>(secp256k1_coord_prime(), 17, 2); - run_negative_is_equal_test::<1, 32, 32>(secp256k1_coord_prime(), 17, 3); + fn negative_test_modular_is_equal_32limb() { + run_negative_is_equal_test::( + secp256k1_coord_prime(), + 17, + 1, + ); + + run_negative_is_equal_test::( + secp256k1_coord_prime(), + 17, + 2, + ); + + run_negative_is_equal_test::( + secp256k1_coord_prime(), + 17, + 3, + ); } #[test] - fn negative_test_modular_is_equal_3x16() { - run_negative_is_equal_test::<3, 16, 48>(BLS12_381_MODULUS.clone(), 17, 1); - run_negative_is_equal_test::<3, 16, 48>(BLS12_381_MODULUS.clone(), 17, 2); - run_negative_is_equal_test::<3, 16, 48>(BLS12_381_MODULUS.clone(), 17, 3); + fn negative_test_modular_is_equal_48limb() { + run_negative_is_equal_test::( + BLS12_381_MODULUS.clone(), + 17, + 1, + ); + + run_negative_is_equal_test::( + BLS12_381_MODULUS.clone(), + 17, + 2, + ); + + run_negative_is_equal_test::( + BLS12_381_MODULUS.clone(), + 17, + 3, + ); } } diff --git a/extensions/ecc/circuit/src/extension/hybrid.rs b/extensions/ecc/circuit/src/extension/hybrid.rs index 71a75d29a3..9c0aa367e4 100644 --- a/extensions/ecc/circuit/src/extension/hybrid.rs +++ b/extensions/ecc/circuit/src/extension/hybrid.rs @@ -2,7 +2,7 @@ use openvm_algebra_circuit::Rv32ModularHybridBuilder; use openvm_circuit::{ - arch::*, + arch::{CONST_BLOCK_SIZE, *}, system::{ cuda::{ extensions::{get_inventory_range_checker, get_or_create_bitwise_op_lookup}, @@ -24,7 +24,8 @@ use openvm_stark_backend::{p3_air::BaseAir, prover::AirProvingContext}; use crate::{ get_ec_addne_chip, get_ec_double_chip, EccRecord, Rv32WeierstrassConfig, WeierstrassAir, - WeierstrassChip, WeierstrassExtension, + WeierstrassChip, WeierstrassExtension, ECC_BLOCKS_32, ECC_BLOCKS_48, NUM_LIMBS_32, + NUM_LIMBS_48, }; #[derive(derive_new::new)] @@ -102,17 +103,17 @@ impl VmProverExtension>()?; - let addne = get_ec_addne_chip::( + inventory.next_air::>()?; + let addne = get_ec_addne_chip::( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -121,8 +122,8 @@ impl VmProverExtension>()?; - let double = get_ec_double_chip::( + inventory.next_air::>()?; + let double = get_ec_double_chip::( config, mem_helper.clone(), range_checker.clone(), @@ -131,15 +132,15 @@ impl VmProverExtension>()?; - let addne = get_ec_addne_chip::( + inventory.next_air::>()?; + let addne = get_ec_addne_chip::( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -148,8 +149,8 @@ impl VmProverExtension>()?; - let double = get_ec_double_chip::( + inventory.next_air::>()?; + let double = get_ec_double_chip::( config, mem_helper.clone(), range_checker.clone(), diff --git a/extensions/ecc/circuit/src/extension/weierstrass.rs b/extensions/ecc/circuit/src/extension/weierstrass.rs index a73057206f..85dcd0beaf 100644 --- a/extensions/ecc/circuit/src/extension/weierstrass.rs +++ b/extensions/ecc/circuit/src/extension/weierstrass.rs @@ -9,7 +9,7 @@ use openvm_circuit::{ arch::{ AirInventory, AirInventoryError, ChipInventory, ChipInventoryError, ExecutionBridge, ExecutorInventoryBuilder, ExecutorInventoryError, RowMajorMatrixArena, VmCircuitExtension, - VmExecutionExtension, VmProverExtension, + VmExecutionExtension, VmProverExtension, CONST_BLOCK_SIZE, }, system::{memory::SharedMemoryHelper, SystemPort}, }; @@ -33,6 +33,7 @@ use strum::EnumCount; use crate::{ get_ec_addne_air, get_ec_addne_chip, get_ec_addne_step, get_ec_double_air, get_ec_double_chip, get_ec_double_step, EcAddNeExecutor, EcDoubleExecutor, EccCpuProverExt, WeierstrassAir, + ECC_BLOCKS_32, ECC_BLOCKS_48, NUM_LIMBS_32, NUM_LIMBS_48, }; #[serde_as] @@ -98,11 +99,11 @@ impl WeierstrassExtension { )] pub enum WeierstrassExtensionExecutor { // 32 limbs prime - EcAddNeRv32_32(EcAddNeExecutor<2, 32>), - EcDoubleRv32_32(EcDoubleExecutor<2, 32>), + EcAddNeRv32_32(EcAddNeExecutor), + EcDoubleRv32_32(EcDoubleExecutor), // 48 limbs prime - EcAddNeRv32_48(EcAddNeExecutor<6, 16>), - EcDoubleRv32_48(EcDoubleExecutor<6, 16>), + EcAddNeRv32_48(EcAddNeExecutor), + EcDoubleRv32_48(EcDoubleExecutor), } impl VmExecutionExtension for WeierstrassExtension { @@ -118,12 +119,12 @@ impl VmExecutionExtension for WeierstrassExtension { for (i, curve) in self.supported_curves.iter().enumerate() { let start_offset = Rv32WeierstrassOpcode::CLASS_OFFSET + i * Rv32WeierstrassOpcode::COUNT; - let bytes = curve.modulus.bits().div_ceil(8); + let bytes = curve.modulus.bits().div_ceil(8) as usize; - if bytes <= 32 { + if bytes <= NUM_LIMBS_32 { let config = ExprBuilderConfig { modulus: curve.modulus.clone(), - num_limbs: 32, + num_limbs: NUM_LIMBS_32, limb_bits: 8, }; let addne = get_ec_addne_step( @@ -154,10 +155,10 @@ impl VmExecutionExtension for WeierstrassExtension { ..=(Rv32WeierstrassOpcode::SETUP_EC_DOUBLE as usize)) .map(|x| VmOpcode::from_usize(x + start_offset)), )?; - } else if bytes <= 48 { + } else if bytes <= NUM_LIMBS_48 { let config = ExprBuilderConfig { modulus: curve.modulus.clone(), - num_limbs: 48, + num_limbs: NUM_LIMBS_48, limb_bits: 8, }; let addne = get_ec_addne_step( @@ -224,16 +225,16 @@ impl VmCircuitExtension for WeierstrassExtension { for (i, curve) in self.supported_curves.iter().enumerate() { let start_offset = Rv32WeierstrassOpcode::CLASS_OFFSET + i * Rv32WeierstrassOpcode::COUNT; - let bytes = curve.modulus.bits().div_ceil(8); + let bytes = curve.modulus.bits().div_ceil(8) as usize; - if bytes <= 32 { + if bytes <= NUM_LIMBS_32 { let config = ExprBuilderConfig { modulus: curve.modulus.clone(), - num_limbs: 32, + num_limbs: NUM_LIMBS_32, limb_bits: 8, }; - let addne = get_ec_addne_air::<2, 32>( + let addne = get_ec_addne_air::( exec_bridge, memory_bridge, config.clone(), @@ -244,7 +245,7 @@ impl VmCircuitExtension for WeierstrassExtension { ); inventory.add_air(addne); - let double = get_ec_double_air::<2, 32>( + let double = get_ec_double_air::( exec_bridge, memory_bridge, config, @@ -255,14 +256,14 @@ impl VmCircuitExtension for WeierstrassExtension { curve.a.clone(), ); inventory.add_air(double); - } else if bytes <= 48 { + } else if bytes <= NUM_LIMBS_48 { let config = ExprBuilderConfig { modulus: curve.modulus.clone(), - num_limbs: 48, + num_limbs: NUM_LIMBS_48, limb_bits: 8, }; - let addne = get_ec_addne_air::<6, 16>( + let addne = get_ec_addne_air::( exec_bridge, memory_bridge, config.clone(), @@ -273,7 +274,7 @@ impl VmCircuitExtension for WeierstrassExtension { ); inventory.add_air(addne); - let double = get_ec_double_air::<6, 16>( + let double = get_ec_double_air::( exec_bridge, memory_bridge, config, @@ -326,17 +327,17 @@ where } }; for curve in extension.supported_curves.iter() { - let bytes = curve.modulus.bits().div_ceil(8); + let bytes = curve.modulus.bits().div_ceil(8) as usize; - if bytes <= 32 { + if bytes <= NUM_LIMBS_32 { let config = ExprBuilderConfig { modulus: curve.modulus.clone(), - num_limbs: 32, + num_limbs: NUM_LIMBS_32, limb_bits: 8, }; - inventory.next_air::>()?; - let addne = get_ec_addne_chip::, 2, 32>( + inventory.next_air::>()?; + let addne = get_ec_addne_chip::, ECC_BLOCKS_32, CONST_BLOCK_SIZE>( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -345,8 +346,8 @@ where ); inventory.add_executor_chip(addne); - inventory.next_air::>()?; - let double = get_ec_double_chip::, 2, 32>( + inventory.next_air::>()?; + let double = get_ec_double_chip::, ECC_BLOCKS_32, CONST_BLOCK_SIZE>( config, mem_helper.clone(), range_checker.clone(), @@ -355,15 +356,15 @@ where curve.a.clone(), ); inventory.add_executor_chip(double); - } else if bytes <= 48 { + } else if bytes <= NUM_LIMBS_48 { let config = ExprBuilderConfig { modulus: curve.modulus.clone(), - num_limbs: 48, + num_limbs: NUM_LIMBS_48, limb_bits: 8, }; - inventory.next_air::>()?; - let addne = get_ec_addne_chip::, 6, 16>( + inventory.next_air::>()?; + let addne = get_ec_addne_chip::, ECC_BLOCKS_48, CONST_BLOCK_SIZE>( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -372,8 +373,8 @@ where ); inventory.add_executor_chip(addne); - inventory.next_air::>()?; - let double = get_ec_double_chip::, 6, 16>( + inventory.next_air::>()?; + let double = get_ec_double_chip::, ECC_BLOCKS_48, CONST_BLOCK_SIZE>( config, mem_helper.clone(), range_checker.clone(), diff --git a/extensions/ecc/circuit/src/weierstrass_chip/tests.rs b/extensions/ecc/circuit/src/weierstrass_chip/tests.rs index 7ac0972890..2f2aa1220b 100644 --- a/extensions/ecc/circuit/src/weierstrass_chip/tests.rs +++ b/extensions/ecc/circuit/src/weierstrass_chip/tests.rs @@ -399,16 +399,16 @@ mod ec_addne_tests { } #[test] - fn test_ec_addne_2x32() { - run_ec_addne_test::<2, 32, 32>( + fn test_ec_addne_32limb() { + run_ec_addne_test::<{ ECC_BLOCKS_32 }, { CONST_BLOCK_SIZE }, { NUM_LIMBS_32 }>( Rv32WeierstrassOpcode::CLASS_OFFSET, secp256k1_coord_prime(), ); } #[test] - fn test_ec_addne_6x16() { - run_ec_addne_test::<6, 16, 48>( + fn test_ec_addne_48limb() { + run_ec_addne_test::<{ ECC_BLOCKS_48 }, { CONST_BLOCK_SIZE }, { NUM_LIMBS_48 }>( Rv32WeierstrassOpcode::CLASS_OFFSET, BLS12_381_MODULUS.clone(), ); @@ -518,11 +518,11 @@ mod ec_addne_tests { let tester: VmChipTestBuilder = VmChipTestBuilder::default(); let config = ExprBuilderConfig { modulus: secp256k1_coord_prime(), - num_limbs: 32, + num_limbs: NUM_LIMBS_32, limb_bits: LIMB_BITS, }; - let executor = get_ec_addne_step::<2, 32>( + let executor = get_ec_addne_step::<{ ECC_BLOCKS_32 }, { CONST_BLOCK_SIZE }>( config, tester.range_checker().bus(), tester.address_bits(), @@ -858,8 +858,8 @@ mod ec_double_tests { } #[test] - fn test_ec_double_2x32() { - run_ec_double_test::<2, 32, 32>( + fn test_ec_double_32limb() { + run_ec_double_test::<{ ECC_BLOCKS_32 }, { CONST_BLOCK_SIZE }, { NUM_LIMBS_32 }>( Rv32WeierstrassOpcode::CLASS_OFFSET, secp256k1_coord_prime(), 50, @@ -868,11 +868,11 @@ mod ec_double_tests { } #[test] - fn test_ec_double_2x32_nonzero_a_1() { + fn test_ec_double_32limb_nonzero_a() { let coeff_a = (-secp256r1::Fp::from(3)).to_bytes(); let a = BigUint::from_bytes_le(&coeff_a); - run_ec_double_test::<2, 32, 32>( + run_ec_double_test::<{ ECC_BLOCKS_32 }, { CONST_BLOCK_SIZE }, { NUM_LIMBS_32 }>( Rv32WeierstrassOpcode::CLASS_OFFSET, secp256r1_coord_prime(), 50, @@ -881,8 +881,8 @@ mod ec_double_tests { } #[test] - fn test_ec_double_6x16() { - run_ec_double_test::<6, 16, 48>( + fn test_ec_double_48limb() { + run_ec_double_test::<{ ECC_BLOCKS_48 }, { CONST_BLOCK_SIZE }, { NUM_LIMBS_48 }>( Rv32WeierstrassOpcode::CLASS_OFFSET, BLS12_381_MODULUS.clone(), 50, @@ -1046,11 +1046,11 @@ mod ec_double_tests { let tester: VmChipTestBuilder = VmChipTestBuilder::default(); let config = ExprBuilderConfig { modulus: secp256k1_coord_prime(), - num_limbs: 32, + num_limbs: NUM_LIMBS_32, limb_bits: LIMB_BITS, }; - let executor = get_ec_double_step::<2, 32>( + let executor = get_ec_double_step::<{ ECC_BLOCKS_32 }, { CONST_BLOCK_SIZE }>( config, tester.range_checker().bus(), tester.address_bits(), @@ -1073,7 +1073,7 @@ mod ec_double_tests { let tester: VmChipTestBuilder = VmChipTestBuilder::default(); let config = ExprBuilderConfig { modulus: secp256r1_coord_prime(), - num_limbs: 32, + num_limbs: NUM_LIMBS_32, limb_bits: LIMB_BITS, }; let a = BigUint::from_str_radix( @@ -1082,7 +1082,7 @@ mod ec_double_tests { ) .unwrap(); - let executor = get_ec_double_step::<2, 32>( + let executor = get_ec_double_step::<{ ECC_BLOCKS_32 }, { CONST_BLOCK_SIZE }>( config.clone(), tester.range_checker().bus(), tester.address_bits(), From 6ffc720a91308d92b4fa18e105a0602db974ec85 Mon Sep 17 00:00:00 2001 From: Paul Chen <77174148+876pol@users.noreply.github.com> Date: Fri, 30 Jan 2026 11:05:45 -0500 Subject: [PATCH 24/78] feat: verify metered execution works properly in tests (#2376) Resolves INT-6010. Currently, `AccessAdapterAir` is excluded from the metered execution checks iff `access_adapters_enabled` is true. --- crates/vm/src/utils/stark_utils.rs | 119 ++++++++++++++++++++++++++--- 1 file changed, 110 insertions(+), 9 deletions(-) diff --git a/crates/vm/src/utils/stark_utils.rs b/crates/vm/src/utils/stark_utils.rs index be150ea75e..7d1c8d26fe 100644 --- a/crates/vm/src/utils/stark_utils.rs +++ b/crates/vm/src/utils/stark_utils.rs @@ -1,20 +1,27 @@ +use openvm_circuit_primitives::utils::next_power_of_two_or_zero; use openvm_instructions::exe::VmExe; use openvm_stark_backend::{ - keygen::types::MultiStarkVerifyingKey, p3_field::PrimeField32, proof::Proof, Com, StarkEngine, - SystemParams, Val, + keygen::types::MultiStarkVerifyingKey, + p3_field::PrimeField32, + proof::Proof, + prover::ProvingContext, + Com, StarkEngine, SystemParams, Val, +}; +use openvm_stark_sdk::{ + config::baby_bear_poseidon2::*, + p3_baby_bear::BabyBear, + utils::setup_tracing, }; -use openvm_stark_sdk::{config::baby_bear_poseidon2::*, utils::setup_tracing}; -use p3_baby_bear::BabyBear; #[cfg(feature = "aot")] -use crate::arch::{SystemConfig, VmState}; +use crate::arch::VmState; #[cfg(feature = "aot")] use crate::system::memory::online::GuestMemory; use crate::{ arch::{ debug_proving_ctx, execution_mode::Segment, vm::VirtualMachine, Executor, ExitCode, - MeteredExecutor, PreflightExecutionOutput, PreflightExecutor, Streams, VmBuilder, - VmCircuitConfig, VmConfig, VmExecutionConfig, + MeteredExecutor, PreflightExecutionOutput, PreflightExecutor, Streams, SystemConfig, + VmBuilder, VmCircuitConfig, VmConfig, VmExecutionConfig, }, system::memory::{MemoryImage, CHUNK}, }; @@ -223,12 +230,12 @@ where let mut state = Some(vm.create_initial_state(&exe, input)); let mut proofs = Vec::new(); let mut exit_code = None; - for segment in segments { + for (seg_idx, segment) in segments.iter().enumerate() { let Segment { num_insns, trace_heights, .. - } = segment; + } = segment.clone(); let from_state = Option::take(&mut state).unwrap(); vm.transport_init_memory_to_device(&from_state.memory); let PreflightExecutionOutput { @@ -245,6 +252,9 @@ where exit_code = system_records.exit_code; let ctx = vm.generate_proving_ctx(system_records, record_arenas)?; + + validate_metered_estimates(&vm, &trace_heights, &ctx, seg_idx); + if debug { debug_proving_ctx(&vm, &ctx); } @@ -267,3 +277,94 @@ where Ok((final_memory, vdata)) } + +/// Validates that metered execution estimates match realized trace heights. +/// +/// Note: Metered execution stores un-padded counts, so we pad them for comparison. +/// The proving context trace height (realized) is already padded. +/// For most AIRs, estimated_padded should exactly equal realized. +/// For MemoryMerkleAir, Poseidon2PeripheryAir, PersistentBoundaryAir, and AccessAdapterAir, it is +/// expected that estimated >> realized +fn validate_metered_estimates( + vm: &VirtualMachine, + estimated_heights: &[u32], + ctx: &ProvingContext, + seg_idx: usize, +) where + E: StarkEngine, + VB: VmBuilder, +{ + let air_names: Vec<_> = vm.air_names().collect(); + + // Iterate over all AIRs, not just those in ctx.per_trace + for (air_id, &estimated_u32) in estimated_heights.iter().enumerate() { + let estimated = estimated_u32 as usize; + // Look up realized height from ctx.per_trace, or 0 if not present + let realized = ctx + .per_trace + .iter() + .find(|(id, _)| *id == air_id) + .map(|(_, air_ctx)| air_ctx.height()) + .unwrap_or(0); + + // Pad the estimated height (realized is already padded from proving context) + let estimated_padded = next_power_of_two_or_zero(estimated); + let air_name = air_names.get(air_id).unwrap_or(&"unknown"); + + #[cfg(feature = "metrics")] + { + metrics::gauge!( + "metered_estimated_height", + "air_id" => air_id.to_string(), + "air_name" => air_name.to_string(), + "segment" => seg_idx.to_string(), + ) + .set(estimated_padded as f64); + metrics::gauge!( + "metered_realized_height", + "air_id" => air_id.to_string(), + "air_name" => air_name.to_string(), + "segment" => seg_idx.to_string(), + ) + .set(realized as f64); + } + + // Check for underestimation: padded estimate should be >= realized + assert!( + estimated_padded >= realized, + "Metered estimation underestimate for AIR {} ({}): estimated {} (padded {}) < realized {} \ + (segment {})", + air_id, + air_name, + estimated, + estimated_padded, + realized, + seg_idx + ); + + // For some airs, the overestimates are expected + let system_config: &SystemConfig = vm.config().as_ref(); + let skip_access_adapter = + system_config.access_adapters_enabled() && air_name.contains("AccessAdapterAir"); + if air_name.contains("MemoryMerkleAir") + || air_name.contains("Poseidon2PeripheryAir") + || air_name.contains("PersistentBoundaryAir") + || skip_access_adapter + { + continue; + } + + // Check that estimated_padded exactly matches realized + assert!( + estimated_padded == realized, + "Metered estimation mismatch for AIR {} ({}): estimated {} (padded {}) != realized {} \ + (segment {})", + air_id, + air_name, + estimated, + estimated_padded, + realized, + seg_idx + ); + } +} From 95be4c11d72433f3f47720a59767f9b78f56744e Mon Sep 17 00:00:00 2001 From: Paul Chen <77174148+876pol@users.noreply.github.com> Date: Fri, 30 Jan 2026 16:27:32 -0500 Subject: [PATCH 25/78] fix: exclude VolatileBoundaryAir from metering tester (#2385) --- crates/vm/src/utils/stark_utils.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/crates/vm/src/utils/stark_utils.rs b/crates/vm/src/utils/stark_utils.rs index 7d1c8d26fe..468b5a5697 100644 --- a/crates/vm/src/utils/stark_utils.rs +++ b/crates/vm/src/utils/stark_utils.rs @@ -348,7 +348,9 @@ fn validate_metered_estimates( system_config.access_adapters_enabled() && air_name.contains("AccessAdapterAir"); if air_name.contains("MemoryMerkleAir") || air_name.contains("Poseidon2PeripheryAir") + || air_name.contains("VolatileBoundaryAir") || air_name.contains("PersistentBoundaryAir") + || air_name.contains("NativeAdapterAir") || skip_access_adapter { continue; From 9c411717b155fcea1fd94a29012f2c06740340f1 Mon Sep 17 00:00:00 2001 From: Tuanlinh12312 <136139181+Tuanlinh12312@users.noreply.github.com> Date: Fri, 30 Jan 2026 16:38:53 -0500 Subject: [PATCH 26/78] feat: access adapter removal keccak256 (#2384) Cast usize pointers to u32 before to_le_bytes() to produce 4-byte arrays compatible with BLOCK_SIZE=4 memory configuration. --- extensions/keccak256/circuit/src/keccakf_op/tests.rs | 2 +- extensions/keccak256/circuit/src/xorin/tests.rs | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/extensions/keccak256/circuit/src/keccakf_op/tests.rs b/extensions/keccak256/circuit/src/keccakf_op/tests.rs index 2112404aa2..fec08a3249 100644 --- a/extensions/keccak256/circuit/src/keccakf_op/tests.rs +++ b/extensions/keccak256/circuit/src/keccakf_op/tests.rs @@ -114,7 +114,7 @@ fn set_and_execute_single_perm>( let rd = gen_pointer(rng, 4); let buffer_ptr = gen_pointer(rng, MAX_LEN); - tester.write(1, rd, buffer_ptr.to_le_bytes().map(F::from_u8)); + tester.write(1, rd, (buffer_ptr as u32).to_le_bytes().map(F::from_u8)); let rand_buffer_arr_f = rand_buffer_arr.map(F::from_u8); for i in 0..(MAX_LEN / 4) { diff --git a/extensions/keccak256/circuit/src/xorin/tests.rs b/extensions/keccak256/circuit/src/xorin/tests.rs index d0dfde7c3c..3cd3b62392 100644 --- a/extensions/keccak256/circuit/src/xorin/tests.rs +++ b/extensions/keccak256/circuit/src/xorin/tests.rs @@ -122,9 +122,9 @@ fn set_and_execute>( tester.write(2, input_ptr + 4 * i, input_chunk); } - tester.write(1, rd, buffer_ptr.to_le_bytes().map(F::from_u8)); - tester.write(1, rs1, input_ptr.to_le_bytes().map(F::from_u8)); - tester.write(1, rs2, buffer_length.to_le_bytes().map(F::from_u8)); + tester.write(1, rd, (buffer_ptr as u32).to_le_bytes().map(F::from_u8)); + tester.write(1, rs1, (input_ptr as u32).to_le_bytes().map(F::from_u8)); + tester.write(1, rs2, (buffer_length as u32).to_le_bytes().map(F::from_u8)); tester.execute( executor, arena, From c53e146b8e47c9cae60b590e8a0553dda8dccf2c Mon Sep 17 00:00:00 2001 From: Paul Chen <77174148+876pol@users.noreply.github.com> Date: Fri, 6 Feb 2026 15:57:18 -0500 Subject: [PATCH 27/78] feat: add gpu tracegen for boundary chip (#2378) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Resolves INT-5725. The `feat/access-adapter-removal` branch removes memory access adapters from the persistent memory path. Previously, separate `AccessAdapterAir` circuits handled the conversion between `CONST_BLOCK_SIZE=4` (the granularity of memory bus interactions) and `CHUNK=8` (the granularity of Merkle tree hashing/Poseidon2 digests). The updated `PersistentBoundaryAir` eliminates this by operating on 8-byte chunks directly while tracking **per-sub-block timestamps**: ``` Old PersistentBoundaryCols: expand_direction | address_space | leaf_label | values[8] | hash[8] | timestamp ^^^^^^^^^ single timestamp New PersistentBoundaryCols: expand_direction | address_space | leaf_label | values[8] | hash[8] | timestamps[2] ^^^^^^^^^^^^^ one per 4-byte block ``` Each 8-byte chunk contains `BLOCKS_PER_CHUNK = CHUNK / CONST_BLOCK_SIZE = 2` sub-blocks. The boundary AIR emits **two** memory bus interactions per row (one per 4-byte sub-block), each with its own timestamp. Untouched sub-blocks within a touched chunk keep `timestamp=0`, which naturally balances against the initial-state row (also at `t=0`). --- This PR adapts the GPU trace generation pipeline to the new per-sub-block-timestamp design. The core challenge: the CPU-side "touched memory" partition arrives as sorted **4-byte records**, but the boundary chip and Merkle tree need **8-byte records** with per-block timestamps and initial-memory fill for untouched sub-blocks. A new `merge_records` kernel converts `InRec = MemoryInventoryRecord<4, 1>` into `OutRec = MemoryInventoryRecord<8, 2>` in two phases: 1. **`cukernel_build_candidates`** — Each thread inspects one input record. If it starts a new 8-byte output chunk (different `ptr/8` than the previous record), it: - Reads the full 8-byte initial memory from device - Overwrites the touched 4-byte sub-block with final values + timestamp - If the next input record belongs to the same output chunk, also patches the other sub-block - Sets `flag[i] = 1`; otherwise `flag[i] = 0` (duplicate within same chunk) 2. **`cukernel_scatter_compact`** — CUB `ExclusiveSum` on flags produces output positions; flagged records are scattered into a compact output array. The `BoundaryRecord` struct is parameterized on `BLOCKS`: ```c++ template struct BoundaryRecord { uint32_t address_space; uint32_t ptr; uint32_t timestamps[BLOCKS]; // was: uint32_t timestamp; uint32_t values[CHUNK]; }; ``` The persistent trace gen kernel writes `timestamps=[0,0]` for initial rows and the actual per-block timestamps for final rows. The Rust side: 1. Converts `TimestampedEquipartition` into GPU-compatible `MemoryInventoryRecord<4,1>` structs 2. Uploads to device and calls the merge kernel 3. Sends merged records to the boundary chip (`finalize_records_persistent_device`) 4. Converts merged records into Merkle records with `timestamp = max(timestamps[0], timestamps[1])` for the tree update --- Suppose the VM touches 3 memory cells at `CONST_BLOCK_SIZE=4` granularity: | addr_space | ptr | timestamp | values | |------------|-----|-----------|-----------------| | 1 | 0 | 5 | [1, 2, 3, 4] | | 1 | 4 | 10 | [5, 6, 7, 8] | | 1 | 16 | 3 | [9, 0, 0, 0] | Initial memory is all zeros. ``` InRec[0]: { as=1, ptr=0, timestamps=[5], values=[1,2,3,4] } InRec[1]: { as=1, ptr=4, timestamps=[10], values=[5,6,7,8] } InRec[2]: { as=1, ptr=16, timestamps=[3], values=[9,0,0,0] } ``` Each thread computes `output_chunk = ptr / 8`: | idx | ptr | output_chunk | same as prev? | flag | |-----|-----|-------------|---------------|------| | 0 | 0 | 0 | N/A (first) | 1 | | 1 | 4 | 0 | yes | 0 | | 2 | 16 | 2 | no | 1 | **Thread 0** (flag=1): Builds an `OutRec` for chunk `ptr=0`: - Reads initial memory `[0,0,0,0,0,0,0,0]` from device - `block_idx = (0 % 8) / 4 = 0` → patches `values[0..4] = [1,2,3,4]`, `timestamps[0] = 5` - Next record (idx=1) is same chunk: `block_idx2 = (4 % 8) / 4 = 1` → patches `values[4..8] = [5,6,7,8]`, `timestamps[1] = 10` - Result: `{ as=1, ptr=0, timestamps=[5,10], values=[1,2,3,4,5,6,7,8] }` **Thread 1** (flag=0): Skipped (same output chunk as thread 0). **Thread 2** (flag=1): Builds an `OutRec` for chunk `ptr=16`: - Reads initial memory `[0,0,0,0,0,0,0,0]` from device - `block_idx = (16 % 8) / 4 = 0` → patches `values[0..4] = [9,0,0,0]`, `timestamps[0] = 3` - No next record → `timestamps[1] = 0`, `values[4..8] = [0,0,0,0]` (from initial memory) - Result: `{ as=1, ptr=16, timestamps=[3,0], values=[9,0,0,0,0,0,0,0] }` ``` flags = [1, 0, 1] positions = [0, 1, 1] (exclusive prefix sum) out[0] = thread 0's record out[1] = thread 2's record out_num_records = 2 ``` | Row | expand_dir | as | leaf_label | values | hash | timestamps | |-----|------------|----|------------|---------------------------|---------------|------------| | 0 | +1 (init) | 1 | 0 | [0,0,0,0,0,0,0,0] | H([0,..0]) | [0, 0] | | 1 | -1 (final) | 1 | 0 | [1,2,3,4,5,6,7,8] | H([1,..,8]) | [5, 10] | | 2 | +1 (init) | 1 | 2 | [0,0,0,0,0,0,0,0] | H([0,..0]) | [0, 0] | | 3 | -1 (final) | 1 | 2 | [9,0,0,0,0,0,0,0] | H([9,0,..0]) | [3, 0] | Each final row generates **two** memory bus sends: - Row 1: send `(as=1, ptr=0, values=[1,2,3,4], ts=5)` and `(as=1, ptr=4, values=[5,6,7,8], ts=10)` - Row 3: send `(as=1, ptr=16, values=[9,0,0,0], ts=3)` and `(as=1, ptr=20, values=[0,0,0,0], ts=0)` The `ts=0` sends from initial rows balance against the `ts=0` sub-blocks of the final rows for untouched memory, eliminating the need for access adapters. For the Merkle tree, each record uses a single timestamp = `max(timestamps[0], timestamps[1])`: | as | ptr | merkle_ts | values | |----|-----|-----------|---------------------------| | 1 | 0 | 10 | [1,2,3,4,5,6,7,8] | | 1 | 16 | 3 | [9,0,0,0,0,0,0,0] | These feed into the existing `update_with_touched_blocks` for Merkle root computation. --- - **`merkle_tree/mod.rs`**: Added `MERKLE_TOUCHED_BLOCK_WIDTH = 3 + DIGEST_WIDTH` constant (distinct from `TIMESTAMPED_BLOCK_WIDTH = 3 + CONST_BLOCK_SIZE`) since the Merkle tree now consumes 8-value records directly. Also fixed a potential `ilog2(0)` panic in `calculate_unpadded_height`. - **New test** `test_empty_touched_memory_uses_full_chunk_values` validates that the empty-partition edge case correctly reads initial memory at `DIGEST_WIDTH` granularity and produces a matching Merkle root vs CPU. --------- Co-authored-by: Jonathan Wang <31040440+jonathanpwang@users.noreply.github.com> Co-authored-by: Golovanov399 --- crates/vm/cuda/src/system/boundary.cu | 31 +- crates/vm/cuda/src/system/inventory.cu | 206 ++++++++ crates/vm/src/arch/testing/cuda.rs | 4 +- crates/vm/src/cuda_abi.rs | 66 +++ crates/vm/src/system/cuda/boundary.rs | 57 +- crates/vm/src/system/cuda/memory.rs | 496 ++++++++++++++++-- crates/vm/src/system/cuda/merkle_tree/cuda.rs | 4 +- crates/vm/src/system/cuda/merkle_tree/mod.rs | 31 +- extensions/bigint/circuit/src/tests.rs | 3 +- 9 files changed, 814 insertions(+), 84 deletions(-) create mode 100644 crates/vm/cuda/src/system/inventory.cu diff --git a/crates/vm/cuda/src/system/boundary.cu b/crates/vm/cuda/src/system/boundary.cu index e59f21c408..17c9656a64 100644 --- a/crates/vm/cuda/src/system/boundary.cu +++ b/crates/vm/cuda/src/system/boundary.cu @@ -6,12 +6,13 @@ #include inline constexpr size_t PERSISTENT_CHUNK = 8; +inline constexpr size_t BLOCKS_PER_CHUNK = 2; inline constexpr size_t VOLATILE_CHUNK = 1; -template struct BoundaryRecord { +template struct BoundaryRecord { uint32_t address_space; uint32_t ptr; - uint32_t timestamp; + uint32_t timestamps[BLOCKS]; uint32_t values[CHUNK]; }; @@ -21,7 +22,7 @@ template struct PersistentBoundaryCols { T leaf_label; T values[PERSISTENT_CHUNK]; T hash[PERSISTENT_CHUNK]; - T timestamp; + T timestamps[BLOCKS_PER_CHUNK]; }; inline constexpr size_t ADDR_ELTS = 2; @@ -42,7 +43,7 @@ __global__ void cukernel_persistent_boundary_tracegen( size_t height, size_t width, uint8_t const *const *initial_mem, - BoundaryRecord *records, + BoundaryRecord *records, size_t num_records, FpArray<16> *poseidon2_buffer, uint32_t *poseidon2_buffer_idx, @@ -53,7 +54,7 @@ __global__ void cukernel_persistent_boundary_tracegen( RowSlice row = RowSlice(trace + row_idx, height); if (record_idx < num_records) { - BoundaryRecord record = records[record_idx]; + BoundaryRecord record = records[record_idx]; Poseidon2Buffer poseidon2(poseidon2_buffer, poseidon2_buffer_idx, poseidon2_capacity); COL_WRITE_VALUE(row, PersistentBoundaryCols, address_space, record.address_space); COL_WRITE_VALUE(row, PersistentBoundaryCols, leaf_label, record.ptr / PERSISTENT_CHUNK); @@ -71,30 +72,31 @@ __global__ void cukernel_persistent_boundary_tracegen( ) : FpArray<8>::from_u8_array(initial_mem[record.address_space - 1] + record.ptr); } else { + #pragma unroll for (int i = 0; i < 8; ++i) { init_values.v[i] = 0; } } FpArray<8> init_hash = poseidon2.hash_and_record(init_values); COL_WRITE_VALUE(row, PersistentBoundaryCols, expand_direction, Fp::one()); - COL_WRITE_VALUE(row, PersistentBoundaryCols, timestamp, Fp::zero()); COL_WRITE_ARRAY( row, PersistentBoundaryCols, values, reinterpret_cast(init_values.v) ); COL_WRITE_ARRAY( row, PersistentBoundaryCols, hash, reinterpret_cast(init_hash.v) ); + row.fill_zero(COL_INDEX(PersistentBoundaryCols, timestamps), BLOCKS_PER_CHUNK); } else { FpArray<8> final_values = FpArray<8>::from_raw_array(record.values); FpArray<8> final_hash = poseidon2.hash_and_record(final_values); COL_WRITE_VALUE(row, PersistentBoundaryCols, expand_direction, Fp::neg_one()); - COL_WRITE_VALUE(row, PersistentBoundaryCols, timestamp, record.timestamp); COL_WRITE_ARRAY( row, PersistentBoundaryCols, values, reinterpret_cast(final_values.v) ); COL_WRITE_ARRAY( row, PersistentBoundaryCols, hash, reinterpret_cast(final_hash.v) ); + COL_WRITE_ARRAY(row, PersistentBoundaryCols, timestamps, record.timestamps); } } else { row.fill_zero(0, width); @@ -105,7 +107,7 @@ __global__ void cukernel_volatile_boundary_tracegen( Fp *trace, size_t height, size_t width, - BoundaryRecord const *records, + BoundaryRecord const *records, size_t num_records, uint32_t *range_checker, size_t range_checker_num_bins, @@ -122,7 +124,7 @@ __global__ void cukernel_volatile_boundary_tracegen( // For the sake of always filling `addr_lt_aux` row.fill_zero(0, width); } - BoundaryRecord record = records[idx]; + BoundaryRecord record = records[idx]; rc.decompose( record.address_space, as_max_bits, @@ -137,11 +139,11 @@ __global__ void cukernel_volatile_boundary_tracegen( ); COL_WRITE_VALUE(row, VolatileBoundaryCols, initial_data, Fp::zero()); COL_WRITE_VALUE(row, VolatileBoundaryCols, final_data, record.values[0]); - COL_WRITE_VALUE(row, VolatileBoundaryCols, final_timestamp, record.timestamp); + COL_WRITE_VALUE(row, VolatileBoundaryCols, final_timestamp, record.timestamps[0]); COL_WRITE_VALUE(row, VolatileBoundaryCols, is_valid, Fp::one()); if (idx != num_records - 1) { - BoundaryRecord next_record = records[idx + 1]; + BoundaryRecord next_record = records[idx + 1]; uint32_t curr[ADDR_ELTS] = {record.address_space, record.ptr}; uint32_t next[ADDR_ELTS] = {next_record.address_space, next_record.ptr}; IsLessThanArray::generate_subrow( @@ -189,8 +191,8 @@ extern "C" int _persistent_boundary_tracegen( size_t poseidon2_capacity ) { auto [grid, block] = kernel_launch_params(height); - BoundaryRecord *d_records = - reinterpret_cast *>(d_raw_records); + BoundaryRecord *d_records = + reinterpret_cast *>(d_raw_records); FpArray<16> *d_poseidon2_buffer = reinterpret_cast *>(d_poseidon2_raw_buffer); cukernel_persistent_boundary_tracegen<<>>( d_trace, @@ -218,7 +220,8 @@ extern "C" int _volatile_boundary_tracegen( size_t ptr_max_bits ) { auto [grid, block] = kernel_launch_params(height, 512); - auto d_records = reinterpret_cast const *>(d_raw_records); + auto d_records = + reinterpret_cast const *>(d_raw_records); cukernel_volatile_boundary_tracegen<<>>( d_trace, height, diff --git a/crates/vm/cuda/src/system/inventory.cu b/crates/vm/cuda/src/system/inventory.cu new file mode 100644 index 0000000000..16797c2abb --- /dev/null +++ b/crates/vm/cuda/src/system/inventory.cu @@ -0,0 +1,206 @@ +#include "launcher.cuh" +#include +#include +#include + +template struct MemoryInventoryRecord { + uint32_t address_space; + uint32_t ptr; + uint32_t timestamps[BLOCKS]; + uint32_t values[CHUNK]; +}; + +const uint32_t IN_BLOCK_SIZE = 4; +const uint32_t OUT_BLOCK_SIZE = 8; + +using InRec = MemoryInventoryRecord; +using OutRec = MemoryInventoryRecord; + +__device__ inline bool same_output_block( + InRec const *in, + size_t lhs_idx, + size_t rhs_idx +) { + uint32_t lhs_as = in[lhs_idx].address_space; + uint32_t rhs_as = in[rhs_idx].address_space; + if (lhs_as != rhs_as) { + return false; + } + return (in[lhs_idx].ptr / OUT_BLOCK_SIZE) == (in[rhs_idx].ptr / OUT_BLOCK_SIZE); +} + +__device__ inline uint32_t addr_space_cell_size( + uint32_t const *addr_space_offsets, + uint32_t addr_space_idx +) { + return addr_space_offsets[addr_space_idx + 1] - addr_space_offsets[addr_space_idx]; +} + +__device__ inline void read_initial_chunk( + uint32_t *out_values, + uint8_t const *const *initial_mem, + uint32_t const *addr_space_offsets, + uint32_t address_space, + uint32_t chunk_ptr +) { + uint32_t addr_space_idx = address_space - 1; + uint8_t const *mem = initial_mem[addr_space_idx]; + if (!mem) { + #pragma unroll + for (int i = 0; i < OUT_BLOCK_SIZE; ++i) { + out_values[i] = 0; + } + return; + } + uint32_t cell_size = addr_space_cell_size(addr_space_offsets, addr_space_idx); + size_t byte_offset = static_cast(chunk_ptr) * cell_size; + #pragma unroll + for (int i = 0; i < OUT_BLOCK_SIZE; ++i) { + size_t off = byte_offset + static_cast(i) * cell_size; + if (cell_size == 4) { + out_values[i] = *reinterpret_cast(mem + off); + } else if (cell_size == 2) { + out_values[i] = *reinterpret_cast(mem + off); + } else if (cell_size == 1) { + out_values[i] = mem[off]; + } else { + out_values[i] = 0; + } + } +} + +__global__ void cukernel_build_candidates( + InRec const *in, + size_t in_num_records, + uint8_t const *const *initial_mem, + uint32_t const *addr_space_offsets, + OutRec *tmp_out, + uint32_t *flags +) { + size_t row_idx = blockIdx.x * blockDim.x + threadIdx.x; + if (row_idx >= in_num_records) { + return; + } + if (row_idx != 0 && same_output_block(in, row_idx - 1, row_idx)) { + flags[row_idx] = 0; + return; + } + flags[row_idx] = 1; + + OutRec rec{}; + rec.address_space = in[row_idx].address_space; + uint32_t chunk_ptr = (in[row_idx].ptr / OUT_BLOCK_SIZE) * OUT_BLOCK_SIZE; + rec.ptr = chunk_ptr; + rec.timestamps[0] = 0; + rec.timestamps[1] = 0; + + read_initial_chunk(rec.values, initial_mem, addr_space_offsets, rec.address_space, chunk_ptr); + + uint32_t block_idx = (in[row_idx].ptr % OUT_BLOCK_SIZE) / IN_BLOCK_SIZE; + #pragma unroll + for (int i = 0; i < IN_BLOCK_SIZE; ++i) { + rec.values[block_idx * IN_BLOCK_SIZE + i] = in[row_idx].values[i]; + } + rec.timestamps[block_idx] = in[row_idx].timestamps[0]; + + if (row_idx + 1 < in_num_records && same_output_block(in, row_idx, row_idx + 1)) { + uint32_t block_idx2 = (in[row_idx + 1].ptr % OUT_BLOCK_SIZE) / IN_BLOCK_SIZE; + #pragma unroll + for (int i = 0; i < IN_BLOCK_SIZE; ++i) { + rec.values[block_idx2 * IN_BLOCK_SIZE + i] = in[row_idx + 1].values[i]; + } + rec.timestamps[block_idx2] = in[row_idx + 1].timestamps[0]; + } + + tmp_out[row_idx] = rec; +} + +__global__ void cukernel_scatter_compact( + OutRec const *tmp_out, + uint32_t const *flags, + uint32_t const *positions, + size_t n, + OutRec *out, + size_t *out_num_records +) { + size_t row_idx = blockIdx.x * blockDim.x + threadIdx.x; + if (row_idx >= n) return; + if (flags[row_idx]) { + uint32_t out_idx = positions[row_idx]; + out[out_idx] = tmp_out[row_idx]; + } + if (row_idx == n - 1) { + *out_num_records = static_cast(positions[row_idx] + flags[row_idx]); + } +} + +extern "C" int _inventory_merge_records( + uint32_t const *d_in_records, + size_t in_num_records, + uint8_t const *const *d_initial_mem, + uint32_t const *d_addr_space_offsets, + uint32_t *d_tmp_records, + uint32_t *d_out_records, + uint32_t *d_flags, + uint32_t *d_positions, + void *d_temp_storage, + size_t temp_storage_bytes, + size_t *out_num_records +) { + auto [grid, block] = kernel_launch_params(in_num_records); + InRec const *in = reinterpret_cast(d_in_records); + OutRec *tmp_out = reinterpret_cast(d_tmp_records); + OutRec *out = reinterpret_cast(d_out_records); + + cukernel_build_candidates<<>>( + in, + in_num_records, + d_initial_mem, + d_addr_space_offsets, + tmp_out, + d_flags + ); + if (int err = CHECK_KERNEL(); err) { + return err; + } + + cub::DeviceScan::ExclusiveSum( + d_temp_storage, + temp_storage_bytes, + d_flags, + d_positions, + in_num_records, + cudaStreamPerThread + ); + if (int err = CHECK_KERNEL(); err) { + return err; + } + + cukernel_scatter_compact<<>>( + tmp_out, + d_flags, + d_positions, + in_num_records, + out, + out_num_records + ); + return CHECK_KERNEL(); +} + +extern "C" int _inventory_merge_records_get_temp_bytes( + uint32_t *d_flags, + size_t in_num_records, + size_t *h_temp_bytes_out +) { + size_t temp_bytes = 0; + cub::DeviceScan::ExclusiveSum( + nullptr, + temp_bytes, + d_flags, + d_flags, + in_num_records, + cudaStreamPerThread + ); + *h_temp_bytes_out = temp_bytes; + return CHECK_KERNEL(); +} diff --git a/crates/vm/src/arch/testing/cuda.rs b/crates/vm/src/arch/testing/cuda.rs index a064310665..67dfabe03d 100644 --- a/crates/vm/src/arch/testing/cuda.rs +++ b/crates/vm/src/arch/testing/cuda.rs @@ -51,7 +51,7 @@ use crate::{ MemoryConfig, PreflightExecutor, Streams, VmStateMut, CONST_BLOCK_SIZE, }, system::{ - cuda::{poseidon2::Poseidon2PeripheryChipGPU, DIGEST_WIDTH}, + cuda::poseidon2::Poseidon2PeripheryChipGPU, memory::{ offline_checker::{MemoryBridge, MemoryBus}, MemoryAirInventory, SharedMemoryHelper, @@ -301,7 +301,7 @@ impl GpuChipTestBuilder { ))); Self { memory: DeviceMemoryTester::persistent( - default_tracing_memory(&mem_config, DIGEST_WIDTH), + default_tracing_memory(&mem_config, CONST_BLOCK_SIZE), mem_bus, mem_config, range_checker.clone(), diff --git a/crates/vm/src/cuda_abi.rs b/crates/vm/src/cuda_abi.rs index 6b3cfcb4ea..a24e2db3f6 100644 --- a/crates/vm/src/cuda_abi.rs +++ b/crates/vm/src/cuda_abi.rs @@ -200,6 +200,72 @@ pub mod poseidon2 { } } +pub mod inventory { + use super::*; + + extern "C" { + fn _inventory_merge_records_get_temp_bytes( + d_flags: *mut u32, + in_num_records: usize, + h_temp_bytes_out: *mut usize, + ) -> i32; + + fn _inventory_merge_records( + d_in_records: *const u32, + in_num_records: usize, + d_initial_mem: *const *const std::ffi::c_void, + d_addr_space_offsets: *const u32, + d_tmp_records: *mut u32, + d_out_records: *mut u32, + d_flags: *mut u32, + d_positions: *mut u32, + d_temp_storage: *mut std::ffi::c_void, + temp_storage_bytes: usize, + out_num_records: *mut usize, + ) -> i32; + } + + pub unsafe fn merge_records( + d_in_records: &DeviceBuffer, + in_num_records: usize, + d_initial_mem: &DeviceBuffer<*const std::ffi::c_void>, + d_addr_space_offsets: &DeviceBuffer, + d_tmp_records: &DeviceBuffer, + d_out_records: &DeviceBuffer, + d_flags: &DeviceBuffer, + d_positions: &DeviceBuffer, + d_temp_storage: &DeviceBuffer, + temp_storage_bytes: usize, + d_out_num_records: &DeviceBuffer, + ) -> Result<(), CudaError> { + CudaError::from_result(_inventory_merge_records( + d_in_records.as_ptr(), + in_num_records, + d_initial_mem.as_ptr(), + d_addr_space_offsets.as_ptr(), + d_tmp_records.as_mut_ptr(), + d_out_records.as_mut_ptr(), + d_flags.as_mut_ptr(), + d_positions.as_mut_ptr(), + d_temp_storage.as_mut_raw_ptr(), + temp_storage_bytes, + d_out_num_records.as_mut_ptr(), + )) + } + + pub unsafe fn merge_records_get_temp_bytes( + d_flags: &DeviceBuffer, + in_num_records: usize, + h_temp_bytes_out: &mut usize, + ) -> Result<(), CudaError> { + CudaError::from_result(_inventory_merge_records_get_temp_bytes( + d_flags.as_mut_ptr(), + in_num_records, + h_temp_bytes_out, + )) + } +} + pub mod program { use super::*; diff --git a/crates/vm/src/system/cuda/boundary.rs b/crates/vm/src/system/cuda/boundary.rs index ceffde9faf..622c497155 100644 --- a/crates/vm/src/system/cuda/boundary.rs +++ b/crates/vm/src/system/cuda/boundary.rs @@ -1,6 +1,7 @@ use std::sync::Arc; use openvm_circuit::{ + arch::CONST_BLOCK_SIZE, system::memory::{ persistent::PersistentBoundaryCols, volatile::VolatileBoundaryCols, TimestampedEquipartition, TimestampedValues, @@ -16,7 +17,7 @@ use openvm_stark_backend::{ prover::{AirProvingContext, MatrixDimensions}, }; -use super::{merkle_tree::TIMESTAMPED_BLOCK_WIDTH, poseidon2::SharedBuffer}; +use super::{poseidon2::SharedBuffer, DIGEST_WIDTH}; use crate::cuda_abi::boundary::{persistent_boundary_tracegen, volatile_boundary_tracegen}; pub struct PersistentBoundary { @@ -25,7 +26,7 @@ pub struct PersistentBoundary { /// This struct cannot own the device memory, hence we take extra care not to use memory we /// don't own. TODO: use `Arc` instead? pub initial_leaves: Vec<*const std::ffi::c_void>, - pub touched_blocks: Option>, + pub records: Option>, } pub struct VolatileBoundary { @@ -46,13 +47,24 @@ pub struct BoundaryChipGPU { pub trace_width: Option, } +const BLOCKS_PER_CHUNK: usize = DIGEST_WIDTH / CONST_BLOCK_SIZE; + +#[repr(C)] +#[derive(Clone, Copy)] +pub struct PersistentBoundaryRecord { + pub address_space: u32, + pub ptr: u32, + pub timestamps: [u32; BLOCKS_PER_CHUNK], + pub values: [F; DIGEST_WIDTH], +} + impl BoundaryChipGPU { pub fn persistent(poseidon2_buffer: SharedBuffer) -> Self { Self { fields: BoundaryFields::Persistent(PersistentBoundary { poseidon2_buffer, initial_leaves: Vec::new(), - touched_blocks: None, + records: None, }), num_records: None, trace_width: None, @@ -103,14 +115,33 @@ impl BoundaryChipGPU { pub fn finalize_records_persistent( &mut self, - touched_blocks: DeviceBuffer, + records: Vec, + ) { + match &mut self.fields { + BoundaryFields::Volatile(_) => panic!("call `finalize_records_volatile`"), + BoundaryFields::Persistent(fields) => { + self.num_records = Some(records.len()); + self.trace_width = Some(PersistentBoundaryCols::::width()); + fields.records = Some(if records.is_empty() { + DeviceBuffer::new() + } else { + records.to_device().unwrap().as_buffer::() + }); + } + } + } + + pub fn finalize_records_persistent_device( + &mut self, + records: DeviceBuffer, + num_records: usize, ) { match &mut self.fields { BoundaryFields::Volatile(_) => panic!("call `finalize_records_volatile`"), BoundaryFields::Persistent(fields) => { - self.num_records = Some(touched_blocks.len() / TIMESTAMPED_BLOCK_WIDTH); + self.num_records = Some(num_records); self.trace_width = Some(PersistentBoundaryCols::::width()); - fields.touched_blocks = Some(touched_blocks); + fields.records = Some(records); } } } @@ -118,6 +149,18 @@ impl BoundaryChipGPU { pub fn trace_width(&self) -> usize { self.trace_width.expect("Finalize records to get width") } + + pub fn persistent_records(&self) -> &DeviceBuffer { + match &self.fields { + BoundaryFields::Persistent(fields) => fields + .records + .as_ref() + .expect("Finalize records to get buffer"), + BoundaryFields::Volatile(_) => { + panic!("persistent_records called on volatile boundary") + } + } + } } impl Chip for BoundaryChipGPU { @@ -141,7 +184,7 @@ impl Chip for BoundaryChipGPU { trace.height(), trace.width(), &mem_ptrs, - boundary.touched_blocks.as_ref().unwrap(), + boundary.records.as_ref().unwrap(), num_records, &boundary.poseidon2_buffer.buffer, &boundary.poseidon2_buffer.idx, diff --git a/crates/vm/src/system/cuda/memory.rs b/crates/vm/src/system/cuda/memory.rs index 57ae83144a..c4b3bbaf0e 100644 --- a/crates/vm/src/system/cuda/memory.rs +++ b/crates/vm/src/system/cuda/memory.rs @@ -1,18 +1,13 @@ use std::sync::Arc; use openvm_circuit::{ - arch::{ - AddressSpaceHostLayout, DenseRecordArena, MemoryConfig, ADDR_SPACE_OFFSET, CONST_BLOCK_SIZE, - }, - system::{ - memory::{online::LinearMemory, AddressMap, TimestampedValues}, - TouchedMemory, - }, + arch::{AddressSpaceHostLayout, DenseRecordArena, MemoryConfig, ADDR_SPACE_OFFSET}, + system::{memory::AddressMap, TouchedMemory}, }; use openvm_circuit_primitives::{var_range::VariableRangeCheckerChipGPU, Chip}; use openvm_cuda_backend::{prelude::F, GpuBackend}; use openvm_cuda_common::{ - copy::{cuda_memcpy, MemCopyD2D, MemCopyH2D}, + copy::{cuda_memcpy, MemCopyD2H, MemCopyH2D}, d_buffer::DeviceBuffer, memory_manager::MemTracker, }; @@ -24,9 +19,10 @@ use tracing::instrument; use super::{ access_adapters::AccessAdapterInventoryGPU, boundary::{BoundaryChipGPU, BoundaryFields}, - merkle_tree::{MemoryMerkleTree, TIMESTAMPED_BLOCK_WIDTH}, + merkle_tree::{MemoryMerkleTree, MERKLE_TOUCHED_BLOCK_WIDTH}, Poseidon2PeripheryChipGPU, DIGEST_WIDTH, }; +use crate::{cuda_abi::inventory, system::memory::online::LinearMemory}; pub struct MemoryInventoryGPU { pub boundary: BoundaryChipGPU, @@ -39,9 +35,33 @@ pub struct MemoryInventoryGPU { pub struct PersistentMemoryInventoryGPU { pub merkle_tree: MemoryMerkleTree, pub initial_memory: Vec>, + pub merkle_records: Option>, +} + +#[repr(C)] +#[derive(Clone, Copy)] +struct MemoryInventoryRecord { + address_space: u32, + ptr: u32, + timestamps: [u32; BLOCKS], + values: [u32; CHUNK], +} + +#[repr(C)] +#[derive(Clone, Copy)] +struct MemoryMerkleRecord { + address_space: u32, + ptr: u32, + timestamp: u32, + values: [u32; DIGEST_WIDTH], } impl MemoryInventoryGPU { + #[inline] + fn field_to_raw_u32(value: F) -> u32 { + unsafe { std::mem::transmute::(value) } + } + pub fn volatile(config: MemoryConfig, range_checker: Arc) -> Self { let addr_space_max_bits = log2_ceil_usize( (ADDR_SPACE_OFFSET + 2u32.pow(config.addr_space_height as u32)) as usize, @@ -78,6 +98,7 @@ impl MemoryInventoryGPU { persistent: Some(PersistentMemoryInventoryGPU { merkle_tree: MemoryMerkleTree::new(config.clone(), hasher_chip.clone()), initial_memory: Vec::new(), + merkle_records: None, }), #[cfg(feature = "metrics")] unpadded_merkle_height: 0, @@ -146,18 +167,10 @@ impl MemoryInventoryGPU { .persistent .as_mut() .expect("persistent touched memory requires persistent memory interface"); - - let unpadded_merkle_height = - persistent.merkle_tree.calculate_unpadded_height(&partition); - #[cfg(feature = "metrics")] - { - self.unpadded_merkle_height = unpadded_merkle_height; - } - - mem.tracing_info("boundary finalize"); - let (touched_memory, empty) = if partition.is_empty() { + // Edge case for when partition is empty + if partition.is_empty() { let leftmost_values = 'left: { - let mut res = [F::ZERO; CONST_BLOCK_SIZE]; + let mut res = [F::ZERO; DIGEST_WIDTH]; if persistent.initial_memory[ADDR_SPACE_OFFSET as usize].is_empty() { break 'left res; } @@ -165,56 +178,185 @@ impl MemoryInventoryGPU { [ADDR_SPACE_OFFSET as usize] .layout; let one_cell_size = layout.size(); - let values = vec![0u8; one_cell_size * CONST_BLOCK_SIZE]; + let mut values = vec![0u8; one_cell_size * DIGEST_WIDTH]; unsafe { cuda_memcpy::( - values.as_ptr() as *mut std::ffi::c_void, + values.as_mut_ptr() as *mut std::ffi::c_void, persistent.initial_memory[ADDR_SPACE_OFFSET as usize].as_ptr() as *const std::ffi::c_void, values.len(), ) .unwrap(); - for i in 0..CONST_BLOCK_SIZE { + for i in 0..DIGEST_WIDTH { res[i] = layout.to_field::(&values[i * one_cell_size..]); } } res }; - ( - vec![( - (1, 0), - TimestampedValues { - timestamp: 0, - values: leftmost_values, - }, - )], + let values_u32 = leftmost_values.map(Self::field_to_raw_u32); + let merkle_record = MemoryMerkleRecord { + address_space: ADDR_SPACE_OFFSET, + ptr: 0, + timestamp: 0, + values: values_u32, + }; + let merkle_records = [merkle_record]; + let merkle_words: &[u32] = unsafe { + std::slice::from_raw_parts( + merkle_records.as_ptr() as *const u32, + MERKLE_TOUCHED_BLOCK_WIDTH, + ) + }; + let d_merkle_touched_memory = merkle_words.to_device().unwrap(); + + let unpadded_merkle_height = + persistent.merkle_tree.calculate_unpadded_height(&partition); + #[cfg(feature = "metrics")] + { + self.unpadded_merkle_height = unpadded_merkle_height; + } + + self.boundary + .finalize_records_persistent::(Vec::new()); + mem.tracing_info("merkle update"); + persistent.merkle_tree.finalize(); + let merkle_tree_ctx = persistent.merkle_tree.update_with_touched_blocks( + unpadded_merkle_height, + &d_merkle_touched_memory, true, - ) + ); + Some(merkle_tree_ctx) } else { - (partition, false) - }; - debug_assert_eq!( - size_of_val(&touched_memory[0]), - TIMESTAMPED_BLOCK_WIDTH * size_of::() - ); - let d_touched_memory = touched_memory.to_device().unwrap().as_buffer::(); - if empty { + // Convert MemoryInventoryRecord<4, 1> to MemoryInventoryRecord<8, 2> + let in_records: Vec> = partition + .iter() + .map(|&((addr_space, ptr), ts_values)| MemoryInventoryRecord { + address_space: addr_space, + ptr, + timestamps: [ts_values.timestamp], + values: ts_values.values.map(|x| Self::field_to_raw_u32(x)), + }) + .collect(); + let in_num_records = in_records.len(); + let out_words = in_num_records + * (std::mem::size_of::>() + / std::mem::size_of::()); + let d_in_records = in_records.to_device().unwrap().as_buffer::(); + let d_tmp_records = DeviceBuffer::::with_capacity(out_words); + let d_out_records = DeviceBuffer::::with_capacity(out_words); + let d_out_num_records = DeviceBuffer::::with_capacity(1); + let d_flags = DeviceBuffer::::with_capacity(in_num_records); + let d_positions = DeviceBuffer::::with_capacity(in_num_records); + let d_initial_mem = match &self.boundary.fields { + BoundaryFields::Persistent(fields) => { + fields.initial_leaves.to_device().unwrap() + } + BoundaryFields::Volatile(_) => { + panic!("`merge_records` requires persistent memory") + } + }; + let addr_space_offsets: Vec = { + let mut offsets = Vec::new(); + let mut acc = 0u32; + for addr_sp in persistent + .merkle_tree + .mem_config() + .addr_spaces + .iter() + .skip(ADDR_SPACE_OFFSET as usize) + { + offsets.push(acc); + acc = acc + .checked_add(addr_sp.layout.size() as u32) + .expect("address space offset overflow"); + } + offsets.push(acc); + offsets + }; + let d_addr_space_offsets = addr_space_offsets.to_device().unwrap(); + let mut temp_bytes = 0usize; + unsafe { + inventory::merge_records_get_temp_bytes( + &d_flags, + in_num_records, + &mut temp_bytes, + ) + .expect("merge_records_get_temp_bytes failed"); + } + let d_temp_storage = if temp_bytes == 0 { + DeviceBuffer::::new() + } else { + DeviceBuffer::::with_capacity(temp_bytes) + }; + unsafe { + inventory::merge_records( + &d_in_records, + in_num_records, + &d_initial_mem, + &d_addr_space_offsets, + &d_tmp_records, + &d_out_records, + &d_flags, + &d_positions, + &d_temp_storage, + temp_bytes, + &d_out_num_records, + ) + .expect("merge_records failed"); + } + + // Send records to boundary chip + let out_num_records = d_out_num_records.to_host().unwrap()[0] as usize; self.boundary - .finalize_records_persistent::(DeviceBuffer::new()); - } else { - self.boundary.finalize_records_persistent::( - d_touched_memory.device_copy().unwrap().as_buffer::(), - ); // TODO do not copy + .finalize_records_persistent_device::( + d_out_records, + out_num_records, + ); + + // Send records to memory merkle tree + let out_records = self.boundary.persistent_records().to_host().unwrap(); + let record_words = 4 + DIGEST_WIDTH; + let mut merkle_records = Vec::with_capacity(out_num_records); + for i in 0..out_num_records { + let base = i * record_words; + let mut values = [0u32; DIGEST_WIDTH]; + values.copy_from_slice(&out_records[base + 4..base + 4 + DIGEST_WIDTH]); + let record = MemoryMerkleRecord { + address_space: out_records[base], + ptr: out_records[base + 1], + timestamp: out_records[base + 2].max(out_records[base + 3]), + values, + }; + merkle_records.push(record); + } + let merkle_words: &[u32] = unsafe { + std::slice::from_raw_parts( + merkle_records.as_ptr() as *const u32, + merkle_records.len() * MERKLE_TOUCHED_BLOCK_WIDTH, + ) + }; + persistent.merkle_records = Some(merkle_words.to_device().unwrap()); + + let unpadded_merkle_height = + persistent.merkle_tree.calculate_unpadded_height(&partition); + #[cfg(feature = "metrics")] + { + self.unpadded_merkle_height = unpadded_merkle_height; + } + + mem.tracing_info("merkle update"); + persistent.merkle_tree.finalize(); + let merkle_tree_ctx = persistent.merkle_tree.update_with_touched_blocks( + unpadded_merkle_height, + persistent + .merkle_records + .as_ref() + .expect("missing merkle records"), + false, + ); + Some(merkle_tree_ctx) } - mem.tracing_info("merkle update"); - persistent.merkle_tree.finalize(); - let merkle_tree_ctx = persistent.merkle_tree.update_with_touched_blocks( - unpadded_merkle_height, - &d_touched_memory, - empty, - ); - Some(merkle_tree_ctx) } TouchedMemory::Volatile(partition) => { assert!(self.persistent.is_none(), "TouchedMemory enum mismatch"); @@ -240,6 +382,254 @@ impl MemoryInventoryGPU { } } +#[cfg(test)] +mod tests { + use std::sync::Arc; + + use openvm_circuit::{ + arch::{testing::POSEIDON2_DIRECT_BUS, vm_poseidon2_config, MemoryConfig}, + system::{ + memory::{merkle::MerkleTree, online::GuestMemory, AddressMap, TimestampedValues}, + poseidon2::Poseidon2PeripheryChip, + }, + }; + use openvm_circuit_primitives::var_range::{ + VariableRangeCheckerChip, VariableRangeCheckerChipGPU, + }; + use openvm_cuda_backend::prelude::F; + use openvm_instructions::{ + riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, + NATIVE_AS, + }; + + use super::*; + use crate::arch::testing::default_var_range_checker_bus; + + #[test] + fn test_empty_touched_memory_uses_full_chunk_values() { + let mut addr_spaces = MemoryConfig::empty_address_space_configs(5); + for addr_space in [RV32_REGISTER_AS, RV32_MEMORY_AS, NATIVE_AS] { + addr_spaces[addr_space as usize].num_cells = 2 * DIGEST_WIDTH; + } + let mem_config = MemoryConfig::new(2, addr_spaces, 4, 29, 17, 32); + + let mut memory = GuestMemory::new(AddressMap::from_mem_config(&mem_config)); + unsafe { + memory.write::(RV32_REGISTER_AS, 0, [1, 2, 3, 4, 5, 6, 7, 8]); + memory.write::(RV32_MEMORY_AS, 0, [9, 10, 11, 12]); + memory.write::( + NATIVE_AS, + 0, + [ + F::from_canonical_u32(21), + F::from_canonical_u32(22), + F::from_canonical_u32(23), + F::from_canonical_u32(24), + F::from_canonical_u32(25), + F::from_canonical_u32(26), + F::from_canonical_u32(27), + F::from_canonical_u32(28), + F::from_canonical_u32(21), + F::from_canonical_u32(22), + F::from_canonical_u32(23), + F::from_canonical_u32(24), + F::from_canonical_u32(25), + F::from_canonical_u32(26), + F::from_canonical_u32(27), + F::from_canonical_u32(28), + ], + ); + } + + let cpu_hasher = + Poseidon2PeripheryChip::new(vm_poseidon2_config(), POSEIDON2_DIRECT_BUS, 3); + let cpu_merkle_tree = MerkleTree::::from_memory( + &memory.memory, + &mem_config.memory_dimensions(), + &cpu_hasher, + ); + let expected_root = cpu_merkle_tree.root(); + + let range_checker = Arc::new(VariableRangeCheckerChipGPU::hybrid(Arc::new( + VariableRangeCheckerChip::new(default_var_range_checker_bus()), + ))); + let max_buffer_size = (mem_config + .addr_spaces + .iter() + .map(|ashc| ashc.num_cells * 2 + mem_config.memory_dimensions().overall_height()) + .sum::() + * 2) + .next_power_of_two() + * 2 + * DIGEST_WIDTH; + let hasher_chip = Arc::new(Poseidon2PeripheryChipGPU::new(max_buffer_size, 1)); + let mut inventory = + MemoryInventoryGPU::persistent(mem_config.clone(), range_checker, hasher_chip); + inventory.set_initial_memory(&memory.memory); + + let ctxs = inventory.generate_proving_ctxs( + DenseRecordArena::with_byte_capacity(0), + TouchedMemory::Persistent(Vec::new()), + ); + let boundary_ctx = ctxs.first().expect("missing boundary ctx"); + assert!( + boundary_ctx.common_main.is_none(), + "boundary trace should be empty for empty touched memory" + ); + assert!( + boundary_ctx.public_values.is_empty(), + "boundary chip should not emit public values" + ); + + let merkle_ctx = ctxs + .iter() + .find(|ctx| ctx.public_values.len() >= 2 * DIGEST_WIDTH) + .expect("missing merkle ctx"); + let gpu_root_slice = + &merkle_ctx.public_values[merkle_ctx.public_values.len() - DIGEST_WIDTH..]; + let gpu_root: [F; DIGEST_WIDTH] = gpu_root_slice.try_into().unwrap(); + + assert_eq!(expected_root, gpu_root); + } + + #[test] + fn test_touched_memory_updates_memory_address_space() { + let mut addr_spaces = MemoryConfig::empty_address_space_configs(5); + for addr_space in [RV32_REGISTER_AS, RV32_MEMORY_AS, NATIVE_AS] { + addr_spaces[addr_space as usize].num_cells = 2 * DIGEST_WIDTH; + } + let mem_config = MemoryConfig::new(2, addr_spaces, 4, 29, 17, 32); + + let mut memory = GuestMemory::new(AddressMap::from_mem_config(&mem_config)); + unsafe { + memory.write::(RV32_REGISTER_AS, 0, [1, 2, 3, 4, 5, 6, 7, 8]); + memory.write::(RV32_MEMORY_AS, 0, [9, 10, 11, 12]); + memory.write::( + NATIVE_AS, + 0, + [ + F::from_canonical_u32(21), + F::from_canonical_u32(22), + F::from_canonical_u32(23), + F::from_canonical_u32(24), + F::from_canonical_u32(25), + F::from_canonical_u32(26), + F::from_canonical_u32(27), + F::from_canonical_u32(28), + F::from_canonical_u32(21), + F::from_canonical_u32(22), + F::from_canonical_u32(23), + F::from_canonical_u32(24), + F::from_canonical_u32(25), + F::from_canonical_u32(26), + F::from_canonical_u32(27), + F::from_canonical_u32(28), + ], + ); + } + + let mut final_memory = memory.clone(); + let touched_bytes = [101u8, 102, 103, 104]; + let touched_bytes_late = [111u8, 112, 113, 114]; + let touched_native_values = [ + F::from_canonical_u32(201), + F::from_canonical_u32(202), + F::from_canonical_u32(203), + F::from_canonical_u32(204), + ]; + unsafe { + final_memory.write::( + RV32_MEMORY_AS, + 0, + touched_bytes, + ); + final_memory.write::( + RV32_MEMORY_AS, + crate::arch::CONST_BLOCK_SIZE as u32, + touched_bytes_late, + ); + final_memory.write::( + NATIVE_AS, + DIGEST_WIDTH as u32, + touched_native_values, + ); + } + + let cpu_hasher = + Poseidon2PeripheryChip::new(vm_poseidon2_config(), POSEIDON2_DIRECT_BUS, 3); + let cpu_merkle_tree = MerkleTree::::from_memory( + &final_memory.memory, + &mem_config.memory_dimensions(), + &cpu_hasher, + ); + let expected_root = cpu_merkle_tree.root(); + + let range_checker = Arc::new(VariableRangeCheckerChipGPU::hybrid(Arc::new( + VariableRangeCheckerChip::new(default_var_range_checker_bus()), + ))); + let max_buffer_size = (mem_config + .addr_spaces + .iter() + .map(|ashc| ashc.num_cells * 2 + mem_config.memory_dimensions().overall_height()) + .sum::() + * 2) + .next_power_of_two() + * 2 + * DIGEST_WIDTH; + let hasher_chip = Arc::new(Poseidon2PeripheryChipGPU::new(max_buffer_size, 1)); + let mut inventory = + MemoryInventoryGPU::persistent(mem_config.clone(), range_checker, hasher_chip); + inventory.set_initial_memory(&memory.memory); + + let touched_memory = vec![ + ( + (RV32_MEMORY_AS, 0), + TimestampedValues { + timestamp: 1, + values: touched_bytes.map(F::from_canonical_u8), + }, + ), + ( + (RV32_MEMORY_AS, crate::arch::CONST_BLOCK_SIZE as u32), + TimestampedValues { + timestamp: 3, + values: touched_bytes_late.map(F::from_canonical_u8), + }, + ), + ( + (NATIVE_AS, DIGEST_WIDTH as u32), + TimestampedValues { + timestamp: 2, + values: touched_native_values, + }, + ), + ]; + let ctxs = inventory.generate_proving_ctxs( + DenseRecordArena::with_byte_capacity(0), + TouchedMemory::Persistent(touched_memory), + ); + let boundary_ctx = ctxs.first().expect("missing boundary ctx"); + assert!( + boundary_ctx.common_main.is_some(), + "boundary trace should be present when touched memory is non-empty" + ); + assert!( + boundary_ctx.public_values.is_empty(), + "boundary chip should not emit public values" + ); + + let merkle_ctx = ctxs + .iter() + .find(|ctx| ctx.public_values.len() >= 2 * DIGEST_WIDTH) + .expect("missing merkle ctx"); + let gpu_root_slice = + &merkle_ctx.public_values[merkle_ctx.public_values.len() - DIGEST_WIDTH..]; + let gpu_root: [F; DIGEST_WIDTH] = gpu_root_slice.try_into().unwrap(); + + assert_eq!(expected_root, gpu_root); + } +} + impl Drop for PersistentMemoryInventoryGPU { fn drop(&mut self) { // WARNING: The merkle subtree events must be completed before dropping the initial memory diff --git a/crates/vm/src/system/cuda/merkle_tree/cuda.rs b/crates/vm/src/system/cuda/merkle_tree/cuda.rs index da0b4faf49..73cecb2400 100644 --- a/crates/vm/src/system/cuda/merkle_tree/cuda.rs +++ b/crates/vm/src/system/cuda/merkle_tree/cuda.rs @@ -5,7 +5,7 @@ use openvm_cuda_common::{ copy::MemCopyH2D, d_buffer::DeviceBuffer, error::CudaError, stream::cudaStream_t, }; -use super::{SharedBuffer, DIGEST_WIDTH, TIMESTAMPED_BLOCK_WIDTH}; +use super::{SharedBuffer, DIGEST_WIDTH, MERKLE_TOUCHED_BLOCK_WIDTH}; pub mod merkle_tree { use super::*; @@ -143,7 +143,7 @@ pub mod merkle_tree { unpadded_height: usize, hasher_buffer: &SharedBuffer, ) -> Result<(), CudaError> { - let num_leaves = touched_blocks.len() / TIMESTAMPED_BLOCK_WIDTH; + let num_leaves = touched_blocks.len() / MERKLE_TOUCHED_BLOCK_WIDTH; let num_subtrees = subtree_ptrs.len(); let tmp_buffer = DeviceBuffer::::with_capacity(5 * num_leaves); let mut need_tmp_storage_bytes = 0; diff --git a/crates/vm/src/system/cuda/merkle_tree/mod.rs b/crates/vm/src/system/cuda/merkle_tree/mod.rs index e24b9a041f..037b884d93 100644 --- a/crates/vm/src/system/cuda/merkle_tree/mod.rs +++ b/crates/vm/src/system/cuda/merkle_tree/mod.rs @@ -27,6 +27,9 @@ type H = [F; DIGEST_WIDTH]; /// Width of `((u32, u32), TimestampedValues)` in u32 units. /// = 2 (key) + 1 (timestamp) + CONST_BLOCK_SIZE (values) pub const TIMESTAMPED_BLOCK_WIDTH: usize = 3 + CONST_BLOCK_SIZE; +/// Width of `((u32, u32), TimestampedValues)` in u32 units. +/// = 2 (key) + 1 (timestamp) + DIGEST_WIDTH (values) +pub const MERKLE_TOUCHED_BLOCK_WIDTH: usize = 3 + DIGEST_WIDTH; /// A Merkle subtree stored in a single flat buffer, combining a vertical path and a heap-ordered /// binary tree. @@ -303,7 +306,7 @@ impl MemoryMerkleTree { pub fn update_with_touched_blocks( &mut self, unpadded_height: usize, - d_touched_blocks: &DeviceBuffer, // consists of (as, label, ts, [F; 8]) + d_touched_blocks: &DeviceBuffer, // consists of (as, ptr, ts, [F; DIGEST_WIDTH]) empty_touched_blocks: bool, ) -> AirProvingContext { let mut public_values = self.top_roots.to_host().unwrap()[0].to_vec(); @@ -362,9 +365,10 @@ impl MemoryMerkleTree { } /// An auxiliary function to calculate the required number of rows for the merkle trace. - pub fn calculate_unpadded_height( + /// Generic over BLOCK_SIZE since only addresses are used, not values. + pub fn calculate_unpadded_height( &self, - touched_memory: &TimestampedEquipartition, + touched_memory: &TimestampedEquipartition, ) -> usize { let md = self.mem_config.memory_dimensions(); let tree_height = md.overall_height(); @@ -378,7 +382,12 @@ impl MemoryMerkleTree { .map(|i| { let x = md.label_to_index(shift_address(touched_memory[i].0)); let y = md.label_to_index(shift_address(touched_memory[i + 1].0)); - (x ^ y).ilog2() as usize + let xor = x ^ y; + if xor == 0 { + 0 + } else { + xor.ilog2() as usize + } }) .sum::() } @@ -398,6 +407,7 @@ mod tests { use openvm_circuit::{ arch::{vm_poseidon2_config, AddressSpaceHostLayout, MemoryCellType, MemoryConfig}, system::{ + cuda::merkle_tree::MERKLE_TOUCHED_BLOCK_WIDTH, memory::{ merkle::MerkleTree, online::{GuestMemory, LinearMemory}, @@ -568,7 +578,18 @@ mod tests { ) }) .collect::>(); - let d_touched_blocks = touched_blocks.to_device().unwrap().as_buffer::(); + let mut merkle_records = + Vec::::with_capacity(touched_blocks.len() * MERKLE_TOUCHED_BLOCK_WIDTH); + for (address, ts_values) in &touched_blocks { + let (address_space, ptr) = *address; + merkle_records.push(address_space); + merkle_records.push(ptr); + merkle_records.push(ts_values.timestamp); + for &v in &ts_values.values { + merkle_records.push(unsafe { std::mem::transmute::(v) }); + } + } + let d_touched_blocks = merkle_records.to_device().unwrap(); gpu_merkle_tree.update_with_touched_blocks( gpu_merkle_tree.calculate_unpadded_height(&touched_blocks), diff --git a/extensions/bigint/circuit/src/tests.rs b/extensions/bigint/circuit/src/tests.rs index d00b109e72..415f1f1ed0 100644 --- a/extensions/bigint/circuit/src/tests.rs +++ b/extensions/bigint/circuit/src/tests.rs @@ -10,7 +10,7 @@ use openvm_circuit::{ TestBuilder, TestChipHarness, VmChipTestBuilder, BITWISE_OP_LOOKUP_BUS, RANGE_TUPLE_CHECKER_BUS, }, - Arena, ExecutionBridge, PreflightExecutor, + Arena, ExecutionBridge, PreflightExecutor, CONST_BLOCK_SIZE, }, system::memory::{offline_checker::MemoryBridge, SharedMemoryHelper}, utils::generate_long_number, @@ -69,6 +69,7 @@ use crate::{ Rv32BranchLessThan256Executor, Rv32LessThan256Air, Rv32LessThan256Chip, Rv32LessThan256Executor, Rv32Multiplication256Air, Rv32Multiplication256Chip, Rv32Multiplication256Executor, Rv32Shift256Air, Rv32Shift256Chip, Rv32Shift256Executor, + INT256_NUM_BLOCKS, }; type F = BabyBear; From 8b4da75a3fd1c02f43887b82a3d7398bd00f9f4a Mon Sep 17 00:00:00 2001 From: Jonathan Wang <31040440+jonathanpwang@users.noreply.github.com> Date: Fri, 20 Feb 2026 17:30:45 -0800 Subject: [PATCH 28/78] fix(cuda): convert initial memory values to Montgomery form in PersistentBoundary (#2453) The read_initial_chunk function in inventory.cu was storing raw byte/u16 values from initial memory without converting them to BabyBear Montgomery form. These values end up in PersistentBoundaryAir records, where boundary.cu's final row reads them via from_raw_array (which expects Montgomery form). Meanwhile, the initial row correctly converts bytes via from_u8_array. This mismatch caused a bus balancing failure for untouched memory blocks in CUDA-only test_sha2. --------- Co-authored-by: Claude Opus 4.6 --- crates/vm/cuda/src/system/boundary.cu | 3 ++- crates/vm/cuda/src/system/inventory.cu | 31 ++++++++++++++++++++------ 2 files changed, 26 insertions(+), 8 deletions(-) diff --git a/crates/vm/cuda/src/system/boundary.cu b/crates/vm/cuda/src/system/boundary.cu index 17c9656a64..fa04e30212 100644 --- a/crates/vm/cuda/src/system/boundary.cu +++ b/crates/vm/cuda/src/system/boundary.cu @@ -13,7 +13,7 @@ template struct BoundaryRecord { uint32_t address_space; uint32_t ptr; uint32_t timestamps[BLOCKS]; - uint32_t values[CHUNK]; + uint32_t values[CHUNK]; // Montgomery-encoded Fp values stored as raw u32 }; template struct PersistentBoundaryCols { @@ -87,6 +87,7 @@ __global__ void cukernel_persistent_boundary_tracegen( ); row.fill_zero(COL_INDEX(PersistentBoundaryCols, timestamps), BLOCKS_PER_CHUNK); } else { + // record.values are already Montgomery-encoded (see read_initial_chunk in inventory.cu) FpArray<8> final_values = FpArray<8>::from_raw_array(record.values); FpArray<8> final_hash = poseidon2.hash_and_record(final_values); COL_WRITE_VALUE(row, PersistentBoundaryCols, expand_direction, Fp::neg_one()); diff --git a/crates/vm/cuda/src/system/inventory.cu b/crates/vm/cuda/src/system/inventory.cu index 16797c2abb..ad11d52aee 100644 --- a/crates/vm/cuda/src/system/inventory.cu +++ b/crates/vm/cuda/src/system/inventory.cu @@ -1,13 +1,20 @@ #include "launcher.cuh" +#include "primitives/trace_access.h" #include #include #include +/// Record representing a memory chunk with BLOCKS sub-blocks of cells. +/// Matches the Rust-side repr(C) `PersistentBoundaryRecord` layout. +/// +/// Note on uint32_t encoding: only `values` stores Montgomery-encoded BabyBear +/// field elements (Fp::asRaw()). All other fields (`address_space`, `ptr`, +/// `timestamps`) are plain integers. template struct MemoryInventoryRecord { - uint32_t address_space; - uint32_t ptr; - uint32_t timestamps[BLOCKS]; - uint32_t values[CHUNK]; + uint32_t address_space; // plain integer + uint32_t ptr; // plain integer (cell-level pointer) + uint32_t timestamps[BLOCKS]; // plain integers + uint32_t values[CHUNK]; // Montgomery-encoded Fp values (Fp::asRaw()) }; const uint32_t IN_BLOCK_SIZE = 4; @@ -36,8 +43,12 @@ __device__ inline uint32_t addr_space_cell_size( return addr_space_offsets[addr_space_idx + 1] - addr_space_offsets[addr_space_idx]; } +/// Read initial memory values for a chunk and convert them to Montgomery-encoded +/// field elements. The output values must be in Montgomery form because they are +/// stored directly into MemoryInventoryRecord.values, which boundary.cu later +/// reads via FpArray::from_raw_array (a raw copy that assumes Montgomery encoding). __device__ inline void read_initial_chunk( - uint32_t *out_values, + uint32_t *out_values, // Montgomery-encoded Fp values uint8_t const *const *initial_mem, uint32_t const *addr_space_offsets, uint32_t address_space, @@ -58,11 +69,14 @@ __device__ inline void read_initial_chunk( for (int i = 0; i < OUT_BLOCK_SIZE; ++i) { size_t off = byte_offset + static_cast(i) * cell_size; if (cell_size == 4) { + // Native32 values are already stored as field elements in Montgomery form out_values[i] = *reinterpret_cast(mem + off); } else if (cell_size == 2) { - out_values[i] = *reinterpret_cast(mem + off); + // Convert u16 value to field element in Montgomery form + out_values[i] = Fp(*reinterpret_cast(mem + off)).asRaw(); } else if (cell_size == 1) { - out_values[i] = mem[off]; + // Convert u8 value to field element in Montgomery form + out_values[i] = Fp(mem[off]).asRaw(); } else { out_values[i] = 0; } @@ -94,8 +108,10 @@ __global__ void cukernel_build_candidates( rec.timestamps[0] = 0; rec.timestamps[1] = 0; + // Fill all values with Montgomery-encoded initial memory read_initial_chunk(rec.values, initial_mem, addr_space_offsets, rec.address_space, chunk_ptr); + // Overwrite touched block's values (already Montgomery-encoded in input records) uint32_t block_idx = (in[row_idx].ptr % OUT_BLOCK_SIZE) / IN_BLOCK_SIZE; #pragma unroll for (int i = 0; i < IN_BLOCK_SIZE; ++i) { @@ -103,6 +119,7 @@ __global__ void cukernel_build_candidates( } rec.timestamps[block_idx] = in[row_idx].timestamps[0]; + // If two input records fall in the same chunk, overwrite the second block too if (row_idx + 1 < in_num_records && same_output_block(in, row_idx, row_idx + 1)) { uint32_t block_idx2 = (in[row_idx + 1].ptr % OUT_BLOCK_SIZE) / IN_BLOCK_SIZE; #pragma unroll From 177dbdaa0a77901f1c8160daf611b14e82803e22 Mon Sep 17 00:00:00 2001 From: Jonathan Wang <31040440+jonathanpwang@users.noreply.github.com> Date: Fri, 20 Feb 2026 21:33:38 -0800 Subject: [PATCH 29/78] fix(cuda): optional access adapter fix (#2454) --- Cargo.lock | 3 ++- crates/vm/src/system/cuda/memory.rs | 39 ++++++++++++++++++----------- 2 files changed, 26 insertions(+), 16 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 9ddeae1b66..74e4142e02 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6721,7 +6721,6 @@ name = "openvm-keccak256-guest" version = "2.0.0-alpha" dependencies = [ "openvm-platform", - "spin 0.10.0", ] [[package]] @@ -7135,10 +7134,12 @@ name = "openvm-sha2" version = "2.0.0-alpha" dependencies = [ "eyre", + "hex", "openvm", "openvm-circuit", "openvm-instructions", "openvm-rv32im-transpiler", + "openvm-sdk", "openvm-sha2-circuit", "openvm-sha2-guest", "openvm-sha2-transpiler", diff --git a/crates/vm/src/system/cuda/memory.rs b/crates/vm/src/system/cuda/memory.rs index c4b3bbaf0e..d35eae7956 100644 --- a/crates/vm/src/system/cuda/memory.rs +++ b/crates/vm/src/system/cuda/memory.rs @@ -26,7 +26,7 @@ use crate::{cuda_abi::inventory, system::memory::online::LinearMemory}; pub struct MemoryInventoryGPU { pub boundary: BoundaryChipGPU, - pub access_adapters: AccessAdapterInventoryGPU, + pub access_adapters: Option, pub persistent: Option, #[cfg(feature = "metrics")] pub(super) unpadded_merkle_height: usize, @@ -66,17 +66,22 @@ impl MemoryInventoryGPU { let addr_space_max_bits = log2_ceil_usize( (ADDR_SPACE_OFFSET + 2u32.pow(config.addr_space_height as u32)) as usize, ); + let access_adapters = if config.access_adapters_enabled() { + Some(AccessAdapterInventoryGPU::new( + range_checker.clone(), + config.max_access_adapter_n, + config.timestamp_max_bits, + )) + } else { + None + }; Self { boundary: BoundaryChipGPU::volatile( - range_checker.clone(), + range_checker, addr_space_max_bits, config.pointer_max_bits, ), - access_adapters: AccessAdapterInventoryGPU::new( - range_checker, - config.max_access_adapter_n, - config.timestamp_max_bits, - ), + access_adapters, persistent: None, #[cfg(feature = "metrics")] unpadded_merkle_height: 0, @@ -88,13 +93,18 @@ impl MemoryInventoryGPU { range_checker: Arc, hasher_chip: Arc, ) -> Self { - Self { - boundary: BoundaryChipGPU::persistent(hasher_chip.shared_buffer()), - access_adapters: AccessAdapterInventoryGPU::new( + let access_adapters = if config.access_adapters_enabled() { + Some(AccessAdapterInventoryGPU::new( range_checker, config.max_access_adapter_n, config.timestamp_max_bits, - ), + )) + } else { + None + }; + Self { + boundary: BoundaryChipGPU::persistent(hasher_chip.shared_buffer()), + access_adapters, persistent: Some(PersistentMemoryInventoryGPU { merkle_tree: MemoryMerkleTree::new(config.clone(), hasher_chip.clone()), initial_memory: Vec::new(), @@ -373,10 +383,9 @@ impl MemoryInventoryGPU { persistent.merkle_tree.drop_subtrees(); persistent.initial_memory = Vec::new(); } - ret.extend( - self.access_adapters - .generate_air_proving_ctxs(access_adapter_arena), - ); + if let Some(access_adapters) = &mut self.access_adapters { + ret.extend(access_adapters.generate_air_proving_ctxs(access_adapter_arena)); + } mem.emit_metrics(); ret } From 7ce0e0c149d37eac92dae97e819507ad3dbbf5cf Mon Sep 17 00:00:00 2001 From: Jonathan Wang <31040440+jonathanpwang@users.noreply.github.com> Date: Fri, 20 Feb 2026 21:53:09 -0800 Subject: [PATCH 30/78] feat: add on_height_change for SHA2 block hasher periphery chip (#2449) Metered execution now tracks the block hasher chip's height growth, matching the pattern used in keccak256 for its permutation chip. closes INT-5931 --------- Co-authored-by: Claude Opus 4.6 --- .../sha2/circuit/src/sha2_chips/execution.rs | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/extensions/sha2/circuit/src/sha2_chips/execution.rs b/extensions/sha2/circuit/src/sha2_chips/execution.rs index d0428ab33f..d11d404969 100644 --- a/extensions/sha2/circuit/src/sha2_chips/execution.rs +++ b/extensions/sha2/circuit/src/sha2_chips/execution.rs @@ -167,10 +167,22 @@ unsafe fn execute_e2_impl = std::slice::from_raw_parts(pre_compute, size_of::>()).borrow(); + + let main_air_idx = pre_compute.chip_idx as usize; + + // Update Sha2MainChip height (1 row per instruction) let height = execute_e12_impl::(&pre_compute.data, exec_state); + exec_state.ctx.on_height_change(main_air_idx, height); + + // HACK: Sha2BlockHasherVmAir is added right before Sha2MainAir in extend_circuit, + // and due to reverse ordering of AIR indices, block_hasher_air_idx = main_air_idx + 1. + // See extension/mod.rs extend_circuit for the ordering. + let block_hasher_air_idx = main_air_idx + 1; + + // Update Sha2BlockHasherChip height (ROWS_PER_BLOCK rows per block compression) exec_state .ctx - .on_height_change(pre_compute.chip_idx as usize, height); + .on_height_change(block_hasher_air_idx, C::ROWS_PER_BLOCK as u32); } #[cfg(feature = "aot")] From 417acd69651c02e9cf0158080eab8f9360cf10e7 Mon Sep 17 00:00:00 2001 From: Jonathan Wang <31040440+jonathanpwang@users.noreply.github.com> Date: Sat, 28 Feb 2026 09:09:38 +0000 Subject: [PATCH 31/78] fix: keccak cuda tests --- crates/vm/src/arch/testing/cpu.rs | 2 +- crates/vm/src/cuda_abi.rs | 1 + crates/vm/src/system/cuda/memory.rs | 114 +++++++++--------- extensions/bigint/circuit/src/tests.rs | 7 +- extensions/keccak256/circuit/src/cuda/mod.rs | 13 +- .../keccak256/circuit/src/keccakf_op/tests.rs | 2 +- .../keccak256/circuit/src/xorin/tests.rs | 4 +- extensions/rv32im/circuit/src/common/mod.rs | 2 +- guest-libs/keccak256/Cargo.toml | 4 +- guest-libs/keccak256/tests/lib.rs | 2 +- guest-libs/sha2/Cargo.toml | 4 +- guest-libs/sha2/tests/lib.rs | 2 +- 12 files changed, 77 insertions(+), 80 deletions(-) diff --git a/crates/vm/src/arch/testing/cpu.rs b/crates/vm/src/arch/testing/cpu.rs index 24c56e48ec..20119d3433 100644 --- a/crates/vm/src/arch/testing/cpu.rs +++ b/crates/vm/src/arch/testing/cpu.rs @@ -560,7 +560,7 @@ where pub fn test E>( self, // do no take ownership so it's easier to prank engine_provider: P, - ) -> Result, VerifierError> + ) -> Result, StarkTestError> where E: StarkEngine, PD = CpuDevice>, SC::EF: Ord, diff --git a/crates/vm/src/cuda_abi.rs b/crates/vm/src/cuda_abi.rs index a24e2db3f6..e597f26445 100644 --- a/crates/vm/src/cuda_abi.rs +++ b/crates/vm/src/cuda_abi.rs @@ -225,6 +225,7 @@ pub mod inventory { ) -> i32; } + #[allow(clippy::too_many_arguments)] pub unsafe fn merge_records( d_in_records: &DeviceBuffer, in_num_records: usize, diff --git a/crates/vm/src/system/cuda/memory.rs b/crates/vm/src/system/cuda/memory.rs index d35eae7956..ff1e32bfcf 100644 --- a/crates/vm/src/system/cuda/memory.rs +++ b/crates/vm/src/system/cuda/memory.rs @@ -245,7 +245,7 @@ impl MemoryInventoryGPU { address_space: addr_space, ptr, timestamps: [ts_values.timestamp], - values: ts_values.values.map(|x| Self::field_to_raw_u32(x)), + values: ts_values.values.map(Self::field_to_raw_u32), }) .collect(); let in_num_records = in_records.len(); @@ -317,7 +317,7 @@ impl MemoryInventoryGPU { } // Send records to boundary chip - let out_num_records = d_out_num_records.to_host().unwrap()[0] as usize; + let out_num_records = d_out_num_records.to_host().unwrap()[0]; self.boundary .finalize_records_persistent_device::( d_out_records, @@ -391,12 +391,21 @@ impl MemoryInventoryGPU { } } +impl Drop for PersistentMemoryInventoryGPU { + fn drop(&mut self) { + // WARNING: The merkle subtree events must be completed before dropping the initial memory + // buffers. This prevents buffers from dropping before build_async completes. + self.merkle_tree.drop_subtrees(); + self.initial_memory.clear(); + } +} + #[cfg(test)] mod tests { use std::sync::Arc; use openvm_circuit::{ - arch::{testing::POSEIDON2_DIRECT_BUS, vm_poseidon2_config, MemoryConfig}, + arch::{vm_poseidon2_config, MemoryConfig}, system::{ memory::{merkle::MerkleTree, online::GuestMemory, AddressMap, TimestampedValues}, poseidon2::Poseidon2PeripheryChip, @@ -410,6 +419,7 @@ mod tests { riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, NATIVE_AS, }; + use openvm_stark_backend::prover::MatrixDimensions; use super::*; use crate::arch::testing::default_var_range_checker_bus; @@ -430,28 +440,27 @@ mod tests { NATIVE_AS, 0, [ - F::from_canonical_u32(21), - F::from_canonical_u32(22), - F::from_canonical_u32(23), - F::from_canonical_u32(24), - F::from_canonical_u32(25), - F::from_canonical_u32(26), - F::from_canonical_u32(27), - F::from_canonical_u32(28), - F::from_canonical_u32(21), - F::from_canonical_u32(22), - F::from_canonical_u32(23), - F::from_canonical_u32(24), - F::from_canonical_u32(25), - F::from_canonical_u32(26), - F::from_canonical_u32(27), - F::from_canonical_u32(28), + F::from_u32(21), + F::from_u32(22), + F::from_u32(23), + F::from_u32(24), + F::from_u32(25), + F::from_u32(26), + F::from_u32(27), + F::from_u32(28), + F::from_u32(21), + F::from_u32(22), + F::from_u32(23), + F::from_u32(24), + F::from_u32(25), + F::from_u32(26), + F::from_u32(27), + F::from_u32(28), ], ); } - let cpu_hasher = - Poseidon2PeripheryChip::new(vm_poseidon2_config(), POSEIDON2_DIRECT_BUS, 3); + let cpu_hasher = Poseidon2PeripheryChip::new(vm_poseidon2_config(), 3); let cpu_merkle_tree = MerkleTree::::from_memory( &memory.memory, &mem_config.memory_dimensions(), @@ -481,8 +490,9 @@ mod tests { TouchedMemory::Persistent(Vec::new()), ); let boundary_ctx = ctxs.first().expect("missing boundary ctx"); - assert!( - boundary_ctx.common_main.is_none(), + assert_eq!( + boundary_ctx.common_main.height(), + 0, "boundary trace should be empty for empty touched memory" ); assert!( @@ -517,22 +527,22 @@ mod tests { NATIVE_AS, 0, [ - F::from_canonical_u32(21), - F::from_canonical_u32(22), - F::from_canonical_u32(23), - F::from_canonical_u32(24), - F::from_canonical_u32(25), - F::from_canonical_u32(26), - F::from_canonical_u32(27), - F::from_canonical_u32(28), - F::from_canonical_u32(21), - F::from_canonical_u32(22), - F::from_canonical_u32(23), - F::from_canonical_u32(24), - F::from_canonical_u32(25), - F::from_canonical_u32(26), - F::from_canonical_u32(27), - F::from_canonical_u32(28), + F::from_u32(21), + F::from_u32(22), + F::from_u32(23), + F::from_u32(24), + F::from_u32(25), + F::from_u32(26), + F::from_u32(27), + F::from_u32(28), + F::from_u32(21), + F::from_u32(22), + F::from_u32(23), + F::from_u32(24), + F::from_u32(25), + F::from_u32(26), + F::from_u32(27), + F::from_u32(28), ], ); } @@ -541,10 +551,10 @@ mod tests { let touched_bytes = [101u8, 102, 103, 104]; let touched_bytes_late = [111u8, 112, 113, 114]; let touched_native_values = [ - F::from_canonical_u32(201), - F::from_canonical_u32(202), - F::from_canonical_u32(203), - F::from_canonical_u32(204), + F::from_u32(201), + F::from_u32(202), + F::from_u32(203), + F::from_u32(204), ]; unsafe { final_memory.write::( @@ -564,8 +574,7 @@ mod tests { ); } - let cpu_hasher = - Poseidon2PeripheryChip::new(vm_poseidon2_config(), POSEIDON2_DIRECT_BUS, 3); + let cpu_hasher = Poseidon2PeripheryChip::new(vm_poseidon2_config(), 3); let cpu_merkle_tree = MerkleTree::::from_memory( &final_memory.memory, &mem_config.memory_dimensions(), @@ -595,14 +604,14 @@ mod tests { (RV32_MEMORY_AS, 0), TimestampedValues { timestamp: 1, - values: touched_bytes.map(F::from_canonical_u8), + values: touched_bytes.map(F::from_u8), }, ), ( (RV32_MEMORY_AS, crate::arch::CONST_BLOCK_SIZE as u32), TimestampedValues { timestamp: 3, - values: touched_bytes_late.map(F::from_canonical_u8), + values: touched_bytes_late.map(F::from_u8), }, ), ( @@ -619,7 +628,7 @@ mod tests { ); let boundary_ctx = ctxs.first().expect("missing boundary ctx"); assert!( - boundary_ctx.common_main.is_some(), + boundary_ctx.common_main.height() > 0, "boundary trace should be present when touched memory is non-empty" ); assert!( @@ -638,12 +647,3 @@ mod tests { assert_eq!(expected_root, gpu_root); } } - -impl Drop for PersistentMemoryInventoryGPU { - fn drop(&mut self) { - // WARNING: The merkle subtree events must be completed before dropping the initial memory - // buffers. This prevents buffers from dropping before build_async completes. - self.merkle_tree.drop_subtrees(); - self.initial_memory.clear(); - } -} diff --git a/extensions/bigint/circuit/src/tests.rs b/extensions/bigint/circuit/src/tests.rs index 415f1f1ed0..b4754cd494 100644 --- a/extensions/bigint/circuit/src/tests.rs +++ b/extensions/bigint/circuit/src/tests.rs @@ -10,7 +10,7 @@ use openvm_circuit::{ TestBuilder, TestChipHarness, VmChipTestBuilder, BITWISE_OP_LOOKUP_BUS, RANGE_TUPLE_CHECKER_BUS, }, - Arena, ExecutionBridge, PreflightExecutor, CONST_BLOCK_SIZE, + Arena, ExecutionBridge, PreflightExecutor, }, system::memory::{offline_checker::MemoryBridge, SharedMemoryHelper}, utils::generate_long_number, @@ -51,14 +51,14 @@ use { BranchLessThan256AdapterRecord, BranchLessThan256ChipGpu, BranchLessThan256CoreRecord, LessThan256AdapterRecord, LessThan256ChipGpu, LessThan256CoreRecord, Multiplication256AdapterRecord, Multiplication256ChipGpu, Multiplication256CoreRecord, - Shift256AdapterRecord, Shift256ChipGpu, Shift256CoreRecord, + Shift256AdapterRecord, Shift256ChipGpu, Shift256CoreRecord, INT256_NUM_BLOCKS, }, openvm_circuit::arch::{ testing::{ default_bitwise_lookup_bus, default_var_range_checker_bus, GpuChipTestBuilder, GpuTestChipHarness, }, - EmptyAdapterCoreLayout, + EmptyAdapterCoreLayout, CONST_BLOCK_SIZE, }, }; @@ -69,7 +69,6 @@ use crate::{ Rv32BranchLessThan256Executor, Rv32LessThan256Air, Rv32LessThan256Chip, Rv32LessThan256Executor, Rv32Multiplication256Air, Rv32Multiplication256Chip, Rv32Multiplication256Executor, Rv32Shift256Air, Rv32Shift256Chip, Rv32Shift256Executor, - INT256_NUM_BLOCKS, }; type F = BabyBear; diff --git a/extensions/keccak256/circuit/src/cuda/mod.rs b/extensions/keccak256/circuit/src/cuda/mod.rs index 1575d77b4c..d7dab02914 100644 --- a/extensions/keccak256/circuit/src/cuda/mod.rs +++ b/extensions/keccak256/circuit/src/cuda/mod.rs @@ -6,12 +6,9 @@ use std::{ use derive_new::new; use openvm_circuit::{arch::DenseRecordArena, utils::next_power_of_two_or_zero}; use openvm_circuit_primitives::{ - bitwise_op_lookup::BitwiseOperationLookupChipGPU, var_range::VariableRangeCheckerChipGPU, -}; -use openvm_cuda_backend::{ - base::DeviceMatrix, chip::get_empty_air_proving_ctx, prelude::F, prover_backend::GpuBackend, - GpuBackend, + bitwise_op_lookup::BitwiseOperationLookupChipGPU, var_range::VariableRangeCheckerChipGPU, Chip, }; +use openvm_cuda_backend::{base::DeviceMatrix, prelude::F, GpuBackend}; use openvm_cuda_common::{copy::MemCopyH2D, d_buffer::DeviceBuffer}; use openvm_instructions::riscv::RV32_CELL_BITS; use openvm_stark_backend::prover::AirProvingContext; @@ -102,7 +99,7 @@ impl Chip for KeccakfOpChipGpu { let mut shared = self.shared_records.lock().unwrap(); shared.d_records = None; shared.num_records = 0; - return get_empty_air_proving_ctx::(); + return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); } debug_assert_eq!(records.len() % RECORD_SIZE, 0); @@ -155,11 +152,11 @@ impl Chip for KeccakfPermChipGpu { }; let Some(d_records) = d_records else { - return get_empty_air_proving_ctx::(); + return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); }; if num_records == 0 { - return get_empty_air_proving_ctx::(); + return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); } let trace_width = NUM_KECCAKF_PERM_COLS; diff --git a/extensions/keccak256/circuit/src/keccakf_op/tests.rs b/extensions/keccak256/circuit/src/keccakf_op/tests.rs index fec08a3249..e3d1a35c81 100644 --- a/extensions/keccak256/circuit/src/keccakf_op/tests.rs +++ b/extensions/keccak256/circuit/src/keccakf_op/tests.rs @@ -263,7 +263,7 @@ fn cuda_set_and_execute( tester.write(1, buffer_reg, buffer_ptr.to_le_bytes().map(F::from_u8)); - let state_data: Vec = (0..KECCAK_STATE_BYTES).map(|_| rng.gen()).collect(); + let state_data: Vec = (0..KECCAK_STATE_BYTES).map(|_| rng.random()).collect(); for (i, chunk) in state_data.chunks(4).enumerate() { let mut word = [F::ZERO; 4]; for (j, &byte) in chunk.iter().enumerate() { diff --git a/extensions/keccak256/circuit/src/xorin/tests.rs b/extensions/keccak256/circuit/src/xorin/tests.rs index 3cd3b62392..920ca85f92 100644 --- a/extensions/keccak256/circuit/src/xorin/tests.rs +++ b/extensions/keccak256/circuit/src/xorin/tests.rs @@ -313,7 +313,7 @@ fn cuda_set_and_execute( tester.write(1, input_reg, input_ptr.to_le_bytes().map(F::from_u8)); tester.write(1, len_reg, (len as u32).to_le_bytes().map(F::from_u8)); - let buffer_data: Vec = (0..len).map(|_| rng.gen()).collect(); + let buffer_data: Vec = (0..len).map(|_| rng.random()).collect(); for (i, chunk) in buffer_data.chunks(4).enumerate() { let mut word = [F::ZERO; 4]; for (j, &byte) in chunk.iter().enumerate() { @@ -322,7 +322,7 @@ fn cuda_set_and_execute( tester.write(2, buffer_ptr + i * 4, word); } - let input_data: Vec = (0..len).map(|_| rng.gen()).collect(); + let input_data: Vec = (0..len).map(|_| rng.random()).collect(); for (i, chunk) in input_data.chunks(4).enumerate() { let mut word = [F::ZERO; 4]; for (j, &byte) in chunk.iter().enumerate() { diff --git a/extensions/rv32im/circuit/src/common/mod.rs b/extensions/rv32im/circuit/src/common/mod.rs index 4be873b4f3..2d52c0a303 100644 --- a/extensions/rv32im/circuit/src/common/mod.rs +++ b/extensions/rv32im/circuit/src/common/mod.rs @@ -11,7 +11,7 @@ mod aot { execution_mode::{metered::memory_ctx::MemoryCtx, MeteredCtx}, AotError, SystemConfig, VmExecState, ADDR_SPACE_OFFSET, CONST_BLOCK_SIZE, }, - system::memory::{merkle::public_values::PUBLIC_VALUES_AS, online::GuestMemory, CHUNK}, + system::memory::{merkle::public_values::PUBLIC_VALUES_AS, online::GuestMemory}, }; use openvm_instructions::riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}; diff --git a/guest-libs/keccak256/Cargo.toml b/guest-libs/keccak256/Cargo.toml index f26603781a..ef71bdfc88 100644 --- a/guest-libs/keccak256/Cargo.toml +++ b/guest-libs/keccak256/Cargo.toml @@ -19,7 +19,7 @@ spin = { workspace = true, features = ["mutex", "spin_mutex"] } [dev-dependencies] hex = { workspace = true } openvm-instructions = { workspace = true } -openvm-sdk = { workspace = true } +sdk-v2 = { workspace = true } openvm-stark-sdk = { workspace = true } openvm-circuit = { workspace = true, features = ["test-utils", "parallel"] } openvm-transpiler = { workspace = true } @@ -31,7 +31,7 @@ eyre = { workspace = true } [features] default = ["tiny_keccak"] -aot = ["openvm-sdk/aot"] +aot = ["sdk-v2/aot"] # Internal feature for testing only. cuda = ["openvm-keccak256-circuit/cuda"] # Enable tiny_keccak::Hasher trait implementation diff --git a/guest-libs/keccak256/tests/lib.rs b/guest-libs/keccak256/tests/lib.rs index ce89ab550b..14133b61e3 100644 --- a/guest-libs/keccak256/tests/lib.rs +++ b/guest-libs/keccak256/tests/lib.rs @@ -15,7 +15,7 @@ mod tests { use openvm_rv32im_transpiler::{ Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension, }; - use openvm_sdk::StdIn; + use sdk_v2::StdIn; use openvm_stark_sdk::p3_baby_bear::BabyBear; use openvm_toolchain_tests::{build_example_program_at_path, get_programs_dir}; use openvm_transpiler::{transpiler::Transpiler, FromElf}; diff --git a/guest-libs/sha2/Cargo.toml b/guest-libs/sha2/Cargo.toml index ca880f9118..7a92d13696 100644 --- a/guest-libs/sha2/Cargo.toml +++ b/guest-libs/sha2/Cargo.toml @@ -17,7 +17,7 @@ sha2 = { workspace = true, default-features = false, optional = true } [dev-dependencies] hex = { workspace = true } openvm-instructions = { workspace = true } -openvm-sdk = { workspace = true } +sdk-v2 = { workspace = true } openvm-stark-sdk = { workspace = true } openvm-circuit = { workspace = true, features = ["test-utils", "parallel"] } openvm-transpiler = { workspace = true } @@ -31,6 +31,6 @@ eyre = { workspace = true } default = ["import_sha2"] # Enable sha2::Digest trait implementation import_sha2 = ["dep:sha2"] -aot = ["openvm-sdk/aot"] +aot = ["sdk-v2/aot"] # Internal feature for testing only. cuda = ["openvm-sha2-circuit/cuda"] diff --git a/guest-libs/sha2/tests/lib.rs b/guest-libs/sha2/tests/lib.rs index aaf64382e0..c2045a1644 100644 --- a/guest-libs/sha2/tests/lib.rs +++ b/guest-libs/sha2/tests/lib.rs @@ -9,7 +9,7 @@ mod tests { use openvm_rv32im_transpiler::{ Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension, }; - use openvm_sdk::StdIn; + use sdk_v2::StdIn; use openvm_sha2_circuit::{Sha2Rv32Builder, Sha2Rv32Config}; use openvm_sha2_transpiler::Sha2TranspilerExtension; use openvm_stark_sdk::p3_baby_bear::BabyBear; From 4a5280499bf6118f1c885d00d5c89267323f2922 Mon Sep 17 00:00:00 2001 From: Tuanlinh12312 <136139181+Tuanlinh12312@users.noreply.github.com> Date: Tue, 3 Mar 2026 19:53:33 -0500 Subject: [PATCH 32/78] fix: set constant trace heights for lookup AIRs in metered execution (#2478) --- .../primitives/src/bitwise_op_lookup/cuda.rs | 4 ++++ .../primitives/src/bitwise_op_lookup/mod.rs | 4 ++++ crates/circuits/primitives/src/chip.rs | 11 +++++++++++ .../circuits/primitives/src/range_tuple/cuda.rs | 4 ++++ .../circuits/primitives/src/range_tuple/mod.rs | 4 ++++ crates/circuits/primitives/src/var_range/cuda.rs | 4 ++++ crates/circuits/primitives/src/var_range/mod.rs | 4 ++++ crates/vm/src/arch/extensions.rs | 16 ++++++++++++++++ crates/vm/src/arch/vm.rs | 14 ++++++++++++++ extensions/sha2/circuit/src/sha2_chips/tests.rs | 8 +++----- 10 files changed, 68 insertions(+), 5 deletions(-) diff --git a/crates/circuits/primitives/src/bitwise_op_lookup/cuda.rs b/crates/circuits/primitives/src/bitwise_op_lookup/cuda.rs index 51c164bf41..f18b417db0 100644 --- a/crates/circuits/primitives/src/bitwise_op_lookup/cuda.rs +++ b/crates/circuits/primitives/src/bitwise_op_lookup/cuda.rs @@ -81,4 +81,8 @@ impl Chip for BitwiseOperationLookupC self.count.fill_zero().unwrap(); AirProvingContext::simple_no_pis(trace) } + + fn constant_trace_height(&self) -> Option { + Some(Self::num_rows()) + } } diff --git a/crates/circuits/primitives/src/bitwise_op_lookup/mod.rs b/crates/circuits/primitives/src/bitwise_op_lookup/mod.rs index 74419be03d..0bc4981dd6 100644 --- a/crates/circuits/primitives/src/bitwise_op_lookup/mod.rs +++ b/crates/circuits/primitives/src/bitwise_op_lookup/mod.rs @@ -240,4 +240,8 @@ impl Chip> let trace_row_maj = self.generate_trace::>(); AirProvingContext::simple_no_pis(trace_row_maj) } + + fn constant_trace_height(&self) -> Option { + Some((1 << NUM_BITS) * (1 << NUM_BITS)) + } } diff --git a/crates/circuits/primitives/src/chip.rs b/crates/circuits/primitives/src/chip.rs index e76647f66e..3bf8166c82 100644 --- a/crates/circuits/primitives/src/chip.rs +++ b/crates/circuits/primitives/src/chip.rs @@ -10,6 +10,13 @@ use openvm_stark_backend::prover::{AirProvingContext, ProverBackend}; pub trait Chip { /// Generate all necessary context for proving a single AIR. fn generate_proving_ctx(&self, records: R) -> AirProvingContext; + + /// If this chip always produces a trace with a fixed number of rows (independent of execution), + /// return that height. Used by metered execution to avoid resetting constant-height chips + /// on segment boundaries. + fn constant_trace_height(&self) -> Option { + None + } } /// Auto-implemented trait for downcasting of trait objects. @@ -27,4 +34,8 @@ impl + ?Sized> Chip for std::sync::A fn generate_proving_ctx(&self, records: R) -> AirProvingContext { (**self).generate_proving_ctx(records) } + + fn constant_trace_height(&self) -> Option { + (**self).constant_trace_height() + } } diff --git a/crates/circuits/primitives/src/range_tuple/cuda.rs b/crates/circuits/primitives/src/range_tuple/cuda.rs index f76e25794b..c0f2f16cde 100644 --- a/crates/circuits/primitives/src/range_tuple/cuda.rs +++ b/crates/circuits/primitives/src/range_tuple/cuda.rs @@ -59,4 +59,8 @@ impl Chip for RangeTupleCheckerChipGPU { self.count.fill_zero().unwrap(); AirProvingContext::simple_no_pis(trace) } + + fn constant_trace_height(&self) -> Option { + Some(self.count.len()) + } } diff --git a/crates/circuits/primitives/src/range_tuple/mod.rs b/crates/circuits/primitives/src/range_tuple/mod.rs index fe80abed1c..70e760dc00 100644 --- a/crates/circuits/primitives/src/range_tuple/mod.rs +++ b/crates/circuits/primitives/src/range_tuple/mod.rs @@ -241,4 +241,8 @@ where let trace_row_maj = self.generate_trace::>(); AirProvingContext::simple_no_pis(trace_row_maj) } + + fn constant_trace_height(&self) -> Option { + Some(self.air.height() as usize) + } } diff --git a/crates/circuits/primitives/src/var_range/cuda.rs b/crates/circuits/primitives/src/var_range/cuda.rs index 3b051e343c..3d2b457d4a 100644 --- a/crates/circuits/primitives/src/var_range/cuda.rs +++ b/crates/circuits/primitives/src/var_range/cuda.rs @@ -60,4 +60,8 @@ impl Chip for VariableRangeCheckerChipGPU { self.count.fill_zero().unwrap(); AirProvingContext::simple_no_pis(trace) } + + fn constant_trace_height(&self) -> Option { + Some(self.count.len()) + } } diff --git a/crates/circuits/primitives/src/var_range/mod.rs b/crates/circuits/primitives/src/var_range/mod.rs index 9f7cd49e88..2182cd9ef2 100644 --- a/crates/circuits/primitives/src/var_range/mod.rs +++ b/crates/circuits/primitives/src/var_range/mod.rs @@ -234,4 +234,8 @@ where let trace_row_maj = self.generate_trace::>(); AirProvingContext::simple_no_pis(trace_row_maj) } + + fn constant_trace_height(&self) -> Option { + Some(1 << (self.air.range_max_bits() + 1)) + } } diff --git a/crates/vm/src/arch/extensions.rs b/crates/vm/src/arch/extensions.rs index a07a570913..29caac63d0 100644 --- a/crates/vm/src/arch/extensions.rs +++ b/crates/vm/src/arch/extensions.rs @@ -578,6 +578,22 @@ where pub fn timestamp_max_bits(&self) -> usize { self.airs.config().memory_config.timestamp_max_bits } + + /// Returns constant trace heights for all AIRs in verifying key order. + /// System AIRs get `None` (their constant heights are handled separately). + /// Extension chips follow in the same order as AIRs in the verifying key + /// (reversed insertion order). + pub fn constant_trace_heights(&self) -> Vec> { + let num_system = self.airs.config().num_airs(); + let mut heights = vec![None; num_system]; + heights.extend( + self.chips + .iter() + .rev() + .map(|chip| chip.constant_trace_height()), + ); + heights + } } // SharedVariableRangeCheckerChip is only used by the CPU backend. diff --git a/crates/vm/src/arch/vm.rs b/crates/vm/src/arch/vm.rs index 64c82ddcf5..440553e179 100644 --- a/crates/vm/src/arch/vm.rs +++ b/crates/vm/src/arch/vm.rs @@ -922,6 +922,20 @@ where // Program trace is the same for all segments constant_trace_heights[PROGRAM_AIR_ID] = Some(program_len); + // VmConnectorAir always has a constant trace height of 2 + constant_trace_heights[CONNECTOR_AIR_ID] = Some(2); + // Merge in constant heights reported by chips (e.g., lookup table chips). + for (air_id, chip_height) in self + .chip_complex + .inventory + .constant_trace_heights() + .into_iter() + .enumerate() + { + if constant_trace_heights[air_id].is_none() { + constant_trace_heights[air_id] = chip_height; + } + } self.executor().build_metered_ctx( &constant_trace_heights, diff --git a/extensions/sha2/circuit/src/sha2_chips/tests.rs b/extensions/sha2/circuit/src/sha2_chips/tests.rs index 40e46b414f..827f062c5e 100644 --- a/extensions/sha2/circuit/src/sha2_chips/tests.rs +++ b/extensions/sha2/circuit/src/sha2_chips/tests.rs @@ -541,24 +541,22 @@ fn negative_sha2_test_bad_final_hash() { .load_periphery_and_prank_trace(block_hasher, modify_trace) .load_periphery(bitwise) .finalize(); - let result = tester.simple_test(); - assert!(result.is_err(), "Expected verification to fail"); + tester + .simple_test() + .expect_err("Expected verification to fail, but it passed"); } #[test] -#[should_panic] fn negative_sha256_test_bad_final_hash() { negative_sha2_test_bad_final_hash::(); } #[test] -#[should_panic] fn negative_sha512_test_bad_final_hash() { negative_sha2_test_bad_final_hash::(); } #[test] -#[should_panic] fn negative_sha384_test_bad_final_hash() { negative_sha2_test_bad_final_hash::(); } From f379a96aa834b60e03a7544ad60cdd06bab988e5 Mon Sep 17 00:00:00 2001 From: Paul Chen <77174148+876pol@users.noreply.github.com> Date: Sat, 7 Mar 2026 00:47:49 -0500 Subject: [PATCH 33/78] refactor: remove access adapter completely (#2485) Resolves INT-6299. Tests should not pass here, but should pass after https://github.com/openvm-org/openvm/pull/2494. --------- Co-authored-by: claude[bot] <41898282+claude[bot]@users.noreply.github.com> Co-authored-by: Jonathan Wang Co-authored-by: Claude Opus 4.6 Co-authored-by: Jonathan Wang <31040440+jonathanpwang@users.noreply.github.com> --- crates/sdk/tests/integration.rs.disabled | 1 - crates/vm/Cargo.toml | 1 - crates/vm/cuda/src/system/access_adapters.cu | 256 -------- crates/vm/cuda/src/system/boundary.cu | 130 +--- crates/vm/cuda/src/system/inventory.cu | 32 +- crates/vm/src/arch/config.rs | 102 +--- .../vm/src/arch/execution_mode/metered/ctx.rs | 30 +- .../arch/execution_mode/metered/memory_ctx.rs | 133 +---- .../src/arch/execution_mode/metered_cost.rs | 65 +- crates/vm/src/arch/extensions.rs | 15 +- crates/vm/src/arch/testing/cpu.rs | 58 +- crates/vm/src/arch/testing/cuda.rs | 58 +- crates/vm/src/arch/testing/memory/cuda.rs | 62 +- crates/vm/src/arch/testing/memory/mod.rs | 26 +- crates/vm/src/arch/testing/utils.rs | 11 +- crates/vm/src/arch/vm.rs | 54 +- crates/vm/src/cuda_abi.rs | 85 --- crates/vm/src/metrics/mod.rs | 39 +- crates/vm/src/system/connector/tests.rs | 2 +- crates/vm/src/system/cuda/access_adapters.rs | 276 --------- crates/vm/src/system/cuda/boundary.rs | 279 ++------- crates/vm/src/system/cuda/extensions.rs | 56 +- crates/vm/src/system/cuda/memory.rs | 565 ++++++------------ crates/vm/src/system/cuda/merkle_tree/mod.rs | 2 +- crates/vm/src/system/cuda/mod.rs | 42 +- crates/vm/src/system/memory/adapter/air.rs | 97 --- .../vm/src/system/memory/adapter/columns.rs | 16 - crates/vm/src/system/memory/adapter/mod.rs | 416 ------------- .../vm/src/system/memory/adapter/records.rs | 150 ----- .../src/system/memory/controller/interface.rs | 35 +- crates/vm/src/system/memory/controller/mod.rs | 234 ++------ .../src/system/memory/merkle/public_values.rs | 2 +- .../vm/src/system/memory/merkle/tests/mod.rs | 3 - crates/vm/src/system/memory/mod.rs | 119 +--- crates/vm/src/system/memory/online.rs | 184 +----- crates/vm/src/system/memory/tests.rs | 98 +-- crates/vm/src/system/memory/volatile/mod.rs | 311 ---------- crates/vm/src/system/memory/volatile/tests.rs | 149 ----- crates/vm/src/system/mod.rs | 155 ++--- crates/vm/src/system/poseidon2/mod.rs | 6 +- crates/vm/src/utils/stark_utils.rs | 34 +- crates/vm/src/utils/test_utils.rs | 18 +- .../docs/pages/specs/architecture/memory.mdx | 201 ++----- .../ecc/circuit/src/weierstrass_chip/tests.rs | 11 +- .../keccak256/circuit/src/keccakf_op/tests.rs | 12 +- .../keccak256/circuit/src/xorin/tests.rs | 12 +- .../rv32-adapters/src/vec_heap_branch.rs | 5 +- extensions/rv32im/circuit/Cargo.toml | 1 - .../rv32im/circuit/src/adapters/loadstore.rs | 3 +- extensions/rv32im/circuit/src/adapters/mod.rs | 22 +- .../rv32im/circuit/src/base_alu/tests.rs | 41 -- .../rv32im/circuit/src/loadstore/aot.rs | 10 +- .../rv32im/circuit/src/loadstore/execution.rs | 3 +- .../rv32im/circuit/src/loadstore/tests.rs | 30 +- guest-libs/keccak256/src/lib.rs | 11 +- guest-libs/keccak256/tests/lib.rs | 2 +- guest-libs/sha2/src/lib.rs | 7 +- guest-libs/sha2/tests/lib.rs | 2 +- 58 files changed, 669 insertions(+), 4111 deletions(-) delete mode 100644 crates/vm/cuda/src/system/access_adapters.cu delete mode 100644 crates/vm/src/system/cuda/access_adapters.rs delete mode 100644 crates/vm/src/system/memory/adapter/air.rs delete mode 100644 crates/vm/src/system/memory/adapter/columns.rs delete mode 100644 crates/vm/src/system/memory/adapter/mod.rs delete mode 100644 crates/vm/src/system/memory/adapter/records.rs delete mode 100644 crates/vm/src/system/memory/volatile/mod.rs delete mode 100644 crates/vm/src/system/memory/volatile/tests.rs diff --git a/crates/sdk/tests/integration.rs.disabled b/crates/sdk/tests/integration.rs.disabled index f596c0b702..52ae6f223c 100644 --- a/crates/sdk/tests/integration.rs.disabled +++ b/crates/sdk/tests/integration.rs.disabled @@ -465,7 +465,6 @@ fn test_sdk_standard_with_p256() -> eyre::Result<()> { fn test_inner_proof_codec_roundtrip() -> eyre::Result<()> { // generate a proof let sdk = Sdk::new(small_test_app_config(1))?; - assert!(sdk.app_config().app_vm_config.as_ref().continuation_enabled); let (_, app_vk) = sdk.app_keygen(); let app_proof = sdk .app_prover(app_exe_for_test())? diff --git a/crates/vm/Cargo.toml b/crates/vm/Cargo.toml index 4d12e55831..1396e521c4 100644 --- a/crates/vm/Cargo.toml +++ b/crates/vm/Cargo.toml @@ -112,4 +112,3 @@ touchemall = [ "openvm-cuda-backend/touchemall", "openvm-cuda-common/touchemall", ] -legacy-v1-3-mem-align = [] diff --git a/crates/vm/cuda/src/system/access_adapters.cu b/crates/vm/cuda/src/system/access_adapters.cu deleted file mode 100644 index b7163b2e8c..0000000000 --- a/crates/vm/cuda/src/system/access_adapters.cu +++ /dev/null @@ -1,256 +0,0 @@ -#include "primitives/less_than.cuh" -#include "primitives/trace_access.h" -#include - -inline __device__ uint32_t next_power_of_two_or_zero(uint32_t x) { - return x ? (1u << (32 - __clz(x - 1))) : 0; -} - -template struct AccessAdapterCols { - T is_valid; - T is_split; - T address_space; - T pointer; - T values[N]; - T left_timestamp; - T right_timestamp; - T is_right_larger; - T lt_aux[AUX_LEN]; -}; - -auto constexpr MERGE_AND_NOT_SPLIT_FLAG = 1u << 31; - -struct AccessAdapterRecordHeader { - uint32_t timestamp_and_mask; - uint32_t address_space; - uint32_t pointer; - // TODO: these three are easily mergeable into a single u32 - // Sync these changes with the openvm ones - uint32_t block_size; - uint32_t lowest_block_size; - uint32_t type_size; -}; - -template struct Cols { - template using type = AccessAdapterCols; -}; - -template -__device__ void _fill_trace_row( - Fp *d_trace, - uint32_t row_idx, - bool is_split, - uint32_t address_space, - uint32_t pointer, - uint8_t const *data, - uint32_t left_timestamp, - uint32_t right_timestamp, - uint32_t type_size, - uint32_t unpadded_trace_height, - uint32_t *d_range_checker, - size_t range_checker_bins, - uint32_t timestamp_max_bits -) { - uint32_t const padded_height = next_power_of_two_or_zero(unpadded_trace_height); - if (auto back_idx = padded_height - 1 - row_idx; back_idx >= unpadded_trace_height) { - RowSlice row(d_trace + back_idx, padded_height); - row.fill_zero(0, sizeof(AccessAdapterCols)); - } - RowSlice row(d_trace + row_idx, padded_height); - - COL_WRITE_VALUE(row, typename Cols::template type, is_valid, Fp::one()); - COL_WRITE_VALUE(row, typename Cols::template type, is_split, is_split); - COL_WRITE_VALUE(row, typename Cols::template type, address_space, address_space); - COL_WRITE_VALUE(row, typename Cols::template type, pointer, pointer); - if (type_size == 1) { - COL_WRITE_ARRAY(row, typename Cols::template type, values, data); - } else if (type_size == 4) { - COL_WRITE_ARRAY( - row, typename Cols::template type, values, reinterpret_cast(data) - ); - } else { - assert(false); - } - COL_WRITE_VALUE(row, typename Cols::template type, left_timestamp, left_timestamp); - COL_WRITE_VALUE(row, typename Cols::template type, right_timestamp, right_timestamp); - COL_WRITE_VALUE( - row, typename Cols::template type, is_right_larger, right_timestamp > left_timestamp - ); - VariableRangeChecker range_checker(d_range_checker, range_checker_bins); - Fp *out = &row[COL_INDEX(typename Cols::template type, is_right_larger)]; - Fp *decomp = &row[COL_INDEX(typename Cols::template type, lt_aux)]; - - IsLessThan::generate_subrow( - range_checker, - timestamp_max_bits, - left_timestamp, - right_timestamp, - AUX_LEN, - RowSlice(decomp, padded_height), - out - ); -} - -template __device__ void fill_trace_row(size_t const n, Args &&...args) { - switch (n) { - case 2: - _fill_trace_row<2>(args...); - break; - case 4: - _fill_trace_row<4>(args...); - break; - case 8: - _fill_trace_row<8>(args...); - break; - case 16: - _fill_trace_row<16>(args...); - break; - case 32: - _fill_trace_row<32>(args...); - break; - default: - assert(false); - } -} - -__device__ void assert_widths(size_t const *const widths, size_t n) { - for (size_t i = 0; i < n; ++i) { - switch (i) { - case 0: - assert(widths[i] == sizeof(AccessAdapterCols)); - break; - case 1: - assert(widths[i] == sizeof(AccessAdapterCols)); - break; - case 2: - assert(widths[i] == sizeof(AccessAdapterCols)); - break; - case 3: - assert(widths[i] == sizeof(AccessAdapterCols)); - break; - case 4: - assert(widths[i] == sizeof(AccessAdapterCols)); - break; - default: - assert(false); - } - } -} - -__global__ void access_adapters_tracegen( - Fp **d_trace, - size_t num_adapters, - size_t const *d_unpadded_heights, - size_t const *d_widths, - size_t num_records, - uint8_t const *d_records, - uint32_t *d_record_offsets, - uint32_t *d_range_checker, - size_t range_checker_bins, - uint32_t timestamp_max_bits -) { - uint32_t const idx = blockIdx.x * blockDim.x + threadIdx.x; - if (idx >= num_records) { - return; - } -#ifdef CUDA_DEBUG - if (idx == 0) { - assert_widths(d_widths, num_adapters); - } -#endif - - uint32_t record_offset = d_record_offsets[idx * (num_adapters + 1)]; - uint32_t *const row_ids = d_record_offsets + idx * (num_adapters + 1) + 1; - - d_records += record_offset; - AccessAdapterRecordHeader const *header = - reinterpret_cast(d_records); - d_records += sizeof(AccessAdapterRecordHeader); - size_t const num_timestamps = header->block_size / header->lowest_block_size; - uint32_t const *timestamps = reinterpret_cast(d_records); - d_records += sizeof(uint32_t) * num_timestamps; - size_t const data_len = header->block_size * header->type_size; - uint8_t const *data = d_records; - - uint32_t const timestamp = header->timestamp_and_mask & ~MERGE_AND_NOT_SPLIT_FLAG; - size_t const log_min_block_size = __ffs(header->lowest_block_size) - 1; - size_t const log_max_block_size = __ffs(header->block_size) - 1; - if (header->timestamp_and_mask & MERGE_AND_NOT_SPLIT_FLAG) { - for (size_t i = log_min_block_size; i < log_max_block_size; ++i) { - size_t const seg_len = header->type_size << i; - size_t const ts_len = 1 << (i - log_min_block_size); - for (size_t j = 0; j < data_len / 2 / seg_len; ++j) { - fill_trace_row( - 2 << i, - d_trace[i], - row_ids[i]++, - false, - header->address_space, - header->pointer + j * (2 << i), - data + j * 2 * seg_len, - *std::max_element( - timestamps + 2 * j * ts_len, timestamps + (2 * j + 1) * ts_len - ), - *std::max_element( - timestamps + (2 * j + 1) * ts_len, timestamps + (2 * j + 2) * ts_len - ), - header->type_size, - d_unpadded_heights[i], - d_range_checker, - range_checker_bins, - timestamp_max_bits - ); - } - } - } else { - for (size_t i = log_min_block_size; i < log_max_block_size; ++i) { - size_t const seg_len = header->type_size << i; - for (size_t j = 0; j < data_len / 2 / seg_len; ++j) { - fill_trace_row( - 2 << i, - d_trace[i], - row_ids[i]++, - true, - header->address_space, - header->pointer + j * (2 << i), - data + j * 2 * seg_len, - timestamp, - timestamp, - header->type_size, - d_unpadded_heights[i], - d_range_checker, - range_checker_bins, - timestamp_max_bits - ); - } - } - } -} - -extern "C" int _access_adapters_tracegen( - Fp **d_trace, - size_t num_adapters, - size_t const *d_unpadded_heights, - size_t const *d_widths, - size_t num_records, - uint8_t const *d_records, - uint32_t *d_record_offsets, - uint32_t *d_range_checker, - uint32_t range_checker_bins, - uint32_t timestamp_max_bits -) { - auto [grid, block] = kernel_launch_params(num_records, 512); - access_adapters_tracegen<<>>( - d_trace, - num_adapters, - d_unpadded_heights, - d_widths, - num_records, - d_records, - d_record_offsets, - d_range_checker, - range_checker_bins, - timestamp_max_bits - ); - return CHECK_KERNEL(); -} \ No newline at end of file diff --git a/crates/vm/cuda/src/system/boundary.cu b/crates/vm/cuda/src/system/boundary.cu index fa04e30212..81ed9fdc56 100644 --- a/crates/vm/cuda/src/system/boundary.cu +++ b/crates/vm/cuda/src/system/boundary.cu @@ -1,13 +1,10 @@ #include "launcher.cuh" #include "primitives/fp_array.cuh" -#include "primitives/less_than.cuh" #include "primitives/shared_buffer.cuh" #include "primitives/trace_access.h" -#include inline constexpr size_t PERSISTENT_CHUNK = 8; inline constexpr size_t BLOCKS_PER_CHUNK = 2; -inline constexpr size_t VOLATILE_CHUNK = 1; template struct BoundaryRecord { uint32_t address_space; @@ -25,19 +22,6 @@ template struct PersistentBoundaryCols { T timestamps[BLOCKS_PER_CHUNK]; }; -inline constexpr size_t ADDR_ELTS = 2; -inline constexpr size_t NUM_AS_LIMBS = 1; - -template struct VolatileBoundaryCols { - T address_space_limbs[NUM_AS_LIMBS]; - T pointer_limbs[AUX_LEN]; - T initial_data; - T final_data; - T final_timestamp; - T is_valid; - LessThanArrayAuxCols addr_lt_aux; -}; - __global__ void cukernel_persistent_boundary_tracegen( Fp *trace, size_t height, @@ -62,15 +46,7 @@ __global__ void cukernel_persistent_boundary_tracegen( // TODO better address space handling FpArray<8> init_values; if (initial_mem[record.address_space - 1]) { - init_values = - record.address_space == 4 - ? FpArray<8>::from_raw_array( - reinterpret_cast( - initial_mem[record.address_space - 1] - ) + - record.ptr - ) - : FpArray<8>::from_u8_array(initial_mem[record.address_space - 1] + record.ptr); + init_values = FpArray<8>::from_u8_array(initial_mem[record.address_space - 1] + record.ptr); } else { #pragma unroll for (int i = 0; i < 8; ++i) { @@ -104,82 +80,6 @@ __global__ void cukernel_persistent_boundary_tracegen( } } -__global__ void cukernel_volatile_boundary_tracegen( - Fp *trace, - size_t height, - size_t width, - BoundaryRecord const *records, - size_t num_records, - uint32_t *range_checker, - size_t range_checker_num_bins, - size_t as_max_bits, - size_t ptr_max_bits -) { - size_t idx = blockIdx.x * blockDim.x + threadIdx.x; - RowSlice row = RowSlice(trace + idx, height); - VariableRangeChecker rc(range_checker, range_checker_num_bins); - assert(idx < height); - - if (idx < num_records) { - if (idx == num_records - 1) { - // For the sake of always filling `addr_lt_aux` - row.fill_zero(0, width); - } - BoundaryRecord record = records[idx]; - rc.decompose( - record.address_space, - as_max_bits, - row.slice_from(COL_INDEX(VolatileBoundaryCols, address_space_limbs)), - NUM_AS_LIMBS - ); - rc.decompose( - record.ptr, - ptr_max_bits, - row.slice_from(COL_INDEX(VolatileBoundaryCols, pointer_limbs)), - AUX_LEN - ); - COL_WRITE_VALUE(row, VolatileBoundaryCols, initial_data, Fp::zero()); - COL_WRITE_VALUE(row, VolatileBoundaryCols, final_data, record.values[0]); - COL_WRITE_VALUE(row, VolatileBoundaryCols, final_timestamp, record.timestamps[0]); - COL_WRITE_VALUE(row, VolatileBoundaryCols, is_valid, Fp::one()); - - if (idx != num_records - 1) { - BoundaryRecord next_record = records[idx + 1]; - uint32_t curr[ADDR_ELTS] = {record.address_space, record.ptr}; - uint32_t next[ADDR_ELTS] = {next_record.address_space, next_record.ptr}; - IsLessThanArray::generate_subrow( - rc, - max(as_max_bits, ptr_max_bits), - FpArray::from_u32_array(curr), - FpArray::from_u32_array(next), - AUX_LEN, - RowSlice(row.slice_from(COL_INDEX(VolatileBoundaryCols, addr_lt_aux.diff_marker))), - row.slice_from(COL_INDEX(VolatileBoundaryCols, addr_lt_aux.diff_inv)).ptr, - RowSlice(row.slice_from(COL_INDEX(VolatileBoundaryCols, addr_lt_aux.lt_decomp))), - nullptr - ); - } - } else { - row.fill_zero(0, width); - } - - if (idx == height - 1 && num_records > 0) { - uint32_t zeros[ADDR_ELTS] = {0, 0}; - FpArray zeros_fp = FpArray::from_raw_array(zeros); - IsLessThanArray::generate_subrow( - rc, - max(as_max_bits, ptr_max_bits), - zeros_fp, - zeros_fp, - AUX_LEN, - RowSlice(row.slice_from(COL_INDEX(VolatileBoundaryCols, addr_lt_aux.diff_marker))), - row.slice_from(COL_INDEX(VolatileBoundaryCols, addr_lt_aux.diff_inv)).ptr, - RowSlice(row.slice_from(COL_INDEX(VolatileBoundaryCols, addr_lt_aux.lt_decomp))), - nullptr - ); - } -} - extern "C" int _persistent_boundary_tracegen( Fp *d_trace, size_t height, @@ -208,31 +108,3 @@ extern "C" int _persistent_boundary_tracegen( ); return CHECK_KERNEL(); } - -extern "C" int _volatile_boundary_tracegen( - Fp *d_trace, - size_t height, - size_t width, - uint32_t const *d_raw_records, - size_t num_records, - uint32_t *d_range_checker, - size_t range_checker_num_bins, - size_t as_max_bits, - size_t ptr_max_bits -) { - auto [grid, block] = kernel_launch_params(height, 512); - auto d_records = - reinterpret_cast const *>(d_raw_records); - cukernel_volatile_boundary_tracegen<<>>( - d_trace, - height, - width, - d_records, - num_records, - d_range_checker, - range_checker_num_bins, - as_max_bits, - ptr_max_bits - ); - return CHECK_KERNEL(); -} diff --git a/crates/vm/cuda/src/system/inventory.cu b/crates/vm/cuda/src/system/inventory.cu index ad11d52aee..003125b6e8 100644 --- a/crates/vm/cuda/src/system/inventory.cu +++ b/crates/vm/cuda/src/system/inventory.cu @@ -36,13 +36,6 @@ __device__ inline bool same_output_block( return (in[lhs_idx].ptr / OUT_BLOCK_SIZE) == (in[rhs_idx].ptr / OUT_BLOCK_SIZE); } -__device__ inline uint32_t addr_space_cell_size( - uint32_t const *addr_space_offsets, - uint32_t addr_space_idx -) { - return addr_space_offsets[addr_space_idx + 1] - addr_space_offsets[addr_space_idx]; -} - /// Read initial memory values for a chunk and convert them to Montgomery-encoded /// field elements. The output values must be in Montgomery form because they are /// stored directly into MemoryInventoryRecord.values, which boundary.cu later @@ -50,7 +43,6 @@ __device__ inline uint32_t addr_space_cell_size( __device__ inline void read_initial_chunk( uint32_t *out_values, // Montgomery-encoded Fp values uint8_t const *const *initial_mem, - uint32_t const *addr_space_offsets, uint32_t address_space, uint32_t chunk_ptr ) { @@ -63,23 +55,12 @@ __device__ inline void read_initial_chunk( } return; } - uint32_t cell_size = addr_space_cell_size(addr_space_offsets, addr_space_idx); - size_t byte_offset = static_cast(chunk_ptr) * cell_size; + size_t byte_offset = static_cast(chunk_ptr); #pragma unroll for (int i = 0; i < OUT_BLOCK_SIZE; ++i) { - size_t off = byte_offset + static_cast(i) * cell_size; - if (cell_size == 4) { - // Native32 values are already stored as field elements in Montgomery form - out_values[i] = *reinterpret_cast(mem + off); - } else if (cell_size == 2) { - // Convert u16 value to field element in Montgomery form - out_values[i] = Fp(*reinterpret_cast(mem + off)).asRaw(); - } else if (cell_size == 1) { - // Convert u8 value to field element in Montgomery form - out_values[i] = Fp(mem[off]).asRaw(); - } else { - out_values[i] = 0; - } + size_t off = byte_offset + static_cast(i); + // Convert u8 value to field element in Montgomery form. + out_values[i] = Fp(mem[off]).asRaw(); } } @@ -87,7 +68,6 @@ __global__ void cukernel_build_candidates( InRec const *in, size_t in_num_records, uint8_t const *const *initial_mem, - uint32_t const *addr_space_offsets, OutRec *tmp_out, uint32_t *flags ) { @@ -109,7 +89,7 @@ __global__ void cukernel_build_candidates( rec.timestamps[1] = 0; // Fill all values with Montgomery-encoded initial memory - read_initial_chunk(rec.values, initial_mem, addr_space_offsets, rec.address_space, chunk_ptr); + read_initial_chunk(rec.values, initial_mem, rec.address_space, chunk_ptr); // Overwrite touched block's values (already Montgomery-encoded in input records) uint32_t block_idx = (in[row_idx].ptr % OUT_BLOCK_SIZE) / IN_BLOCK_SIZE; @@ -155,7 +135,6 @@ extern "C" int _inventory_merge_records( uint32_t const *d_in_records, size_t in_num_records, uint8_t const *const *d_initial_mem, - uint32_t const *d_addr_space_offsets, uint32_t *d_tmp_records, uint32_t *d_out_records, uint32_t *d_flags, @@ -173,7 +152,6 @@ extern "C" int _inventory_merge_records( in, in_num_records, d_initial_mem, - d_addr_space_offsets, tmp_out, d_flags ); diff --git a/crates/vm/src/arch/config.rs b/crates/vm/src/arch/config.rs index b249b56527..1f7005c461 100644 --- a/crates/vm/src/arch/config.rs +++ b/crates/vm/src/arch/config.rs @@ -178,8 +178,6 @@ pub struct MemoryConfig { pub timestamp_max_bits: usize, /// Limb size used by the range checker pub decomp: usize, - /// Maximum N AccessAdapter AIR to support. - pub max_access_adapter_n: usize, } impl Default for MemoryConfig { @@ -190,7 +188,7 @@ impl Default for MemoryConfig { addr_spaces[RV32_REGISTER_AS as usize].num_cells = 32 * size_of::(); addr_spaces[RV32_MEMORY_AS as usize].num_cells = MAX_CELLS; addr_spaces[PUBLIC_VALUES_AS as usize].num_cells = DEFAULT_MAX_NUM_PUBLIC_VALUES; - Self::new(3, addr_spaces, POINTER_MAX_BITS, 29, 17, 32) + Self::new(3, addr_spaces, POINTER_MAX_BITS, 29, 17) } } @@ -207,16 +205,8 @@ impl MemoryConfig { addr_spaces[RV32_REGISTER_AS as usize] = AddressSpaceHostConfig::new(0, DEFAULT_U8_BLOCK_SIZE, MemoryCellType::U8); - #[cfg(feature = "legacy-v1-3-mem-align")] - { - addr_spaces[RV32_MEMORY_AS as usize] = - AddressSpaceHostConfig::new(0, 1, MemoryCellType::U8); - } - #[cfg(not(feature = "legacy-v1-3-mem-align"))] - { - addr_spaces[RV32_MEMORY_AS as usize] = - AddressSpaceHostConfig::new(0, DEFAULT_U8_BLOCK_SIZE, MemoryCellType::U8); - } + addr_spaces[RV32_MEMORY_AS as usize] = + AddressSpaceHostConfig::new(0, DEFAULT_U8_BLOCK_SIZE, MemoryCellType::U8); addr_spaces[PUBLIC_VALUES_AS as usize] = AddressSpaceHostConfig::new(0, DEFAULT_U8_BLOCK_SIZE, MemoryCellType::U8); @@ -224,46 +214,30 @@ impl MemoryConfig { addr_spaces } + /// Config for aggregation usage with only native address space. + pub fn aggregation() -> Self { + let mut addr_spaces = + Self::empty_address_space_configs((1 << 3) + ADDR_SPACE_OFFSET as usize); + addr_spaces[openvm_instructions::DEFERRAL_AS as usize].num_cells = 1 << 29; + Self::new(3, addr_spaces, POINTER_MAX_BITS, 29, 17) + } + + pub fn min_block_size_bits(&self) -> Vec { self.addr_spaces .iter() .map(|addr_sp| log2_strict_usize(addr_sp.min_block_size) as u8) .collect() } - - /// Returns true if the Native address space (AS 4) is used. - /// Native AS is considered "used" if the host config allocates cells for it. - /// - /// When access adapters are disabled, all memory accesses must be of the - /// standard block size (i.e., 4 for address spaces 1-3). - pub fn access_adapters_enabled(&self) -> bool { - self.addr_spaces - .get(NATIVE_AS as usize) - .is_some_and(|config| config.num_cells > 0) - } - - pub fn num_access_adapters(&self) -> usize { - if self.access_adapters_enabled() { - log2_strict_usize(self.max_access_adapter_n) - } else { - 0 - } - } } /// System-level configuration for the virtual machine. Contains all configuration parameters that -/// are managed by the architecture, including configuration for continuations support. +/// are managed by the architecture. #[derive(Debug, Clone, Serialize, Deserialize, Setters, WithSetters)] pub struct SystemConfig { /// The maximum constraint degree any chip is allowed to use. #[getset(set_with = "pub")] pub max_constraint_degree: usize, - /// True if the VM is in continuation mode. In this mode, an execution could be segmented and - /// each segment is proved by a proof. Each proof commits the before and after state of the - /// corresponding segment. - /// False if the VM is in single segment mode. In this mode, an execution is proved by a single - /// proof. - pub continuation_enabled: bool, /// Memory configuration pub memory_config: MemoryConfig, /// Public values are stored in a special address space. @@ -293,7 +267,6 @@ impl SystemConfig { memory_config.addr_spaces[PUBLIC_VALUES_AS as usize].num_cells = num_public_values; Self { max_constraint_degree, - continuation_enabled: true, memory_config, num_public_values, profiling: false, @@ -309,16 +282,6 @@ impl SystemConfig { ) } - pub fn with_continuations(mut self) -> Self { - self.continuation_enabled = true; - self - } - - pub fn without_continuations(mut self) -> Self { - self.continuation_enabled = false; - self - } - pub fn with_public_values(mut self, num_public_values: usize) -> Self { self.num_public_values = num_public_values; self.memory_config.addr_spaces[PUBLIC_VALUES_AS as usize].num_cells = num_public_values; @@ -347,54 +310,27 @@ impl SystemConfig { BOUNDARY_AIR_ID } - /// Returns the AIR ID of the memory merkle AIR. Returns None if continuations are not enabled. - pub fn memory_merkle_air_id(&self) -> Option { - let boundary_idx = self.memory_boundary_air_id(); - if self.continuation_enabled { - Some(boundary_idx + 1) - } else { - None - } - } - - /// AIR ID for the first memory access adapter AIR. - pub fn access_adapter_air_id_offset(&self) -> usize { - let boundary_idx = self.memory_boundary_air_id(); - // boundary, (if persistent memory) merkle AIRs - boundary_idx + 1 + usize::from(self.continuation_enabled) + /// Returns the AIR ID of the memory merkle AIR. + pub fn memory_merkle_air_id(&self) -> usize { + self.memory_boundary_air_id() + 1 } /// Whether the AIR ID must be present in a valid v2 proof. pub fn is_required_air_id(&self, air_id: usize) -> bool { - if !self.continuation_enabled { - return false; - } air_id == PROGRAM_AIR_ID || air_id == CONNECTOR_AIR_ID || air_id == self.memory_boundary_air_id() - || Some(air_id) == self.memory_merkle_air_id() + || air_id == self.memory_merkle_air_id() } /// This is O(1) and returns the length of /// [`SystemAirInventory::into_airs`](crate::system::SystemAirInventory::into_airs). pub fn num_airs(&self) -> usize { - self.memory_boundary_air_id() - + num_memory_airs( - self.continuation_enabled, - self.memory_config.num_access_adapters(), - ) + self.memory_boundary_air_id() + num_memory_airs() } pub fn initial_block_size(&self) -> usize { - match self.continuation_enabled { - true => CONST_BLOCK_SIZE, - false => 1, - } - } - - /// Returns true if access adapters are enabled. - pub fn access_adapters_enabled(&self) -> bool { - self.memory_config.access_adapters_enabled() + CONST_BLOCK_SIZE } } diff --git a/crates/vm/src/arch/execution_mode/metered/ctx.rs b/crates/vm/src/arch/execution_mode/metered/ctx.rs index 10ac7164c0..2a7175c338 100644 --- a/crates/vm/src/arch/execution_mode/metered/ctx.rs +++ b/crates/vm/src/arch/execution_mode/metered/ctx.rs @@ -1,5 +1,3 @@ -use std::num::NonZero; - use getset::{Getters, Setters, WithSetters}; use itertools::Itertools; use openvm_instructions::riscv::{RV32_IMM_AS, RV32_REGISTER_AS}; @@ -63,22 +61,12 @@ impl MeteredCtx { "air_name={}", segmentation_ctx.air_names[memory_ctx.boundary_idx] ); - if let Some(merkle_tree_index) = memory_ctx.merkle_tree_index { - debug_assert!( - segmentation_ctx.air_names[merkle_tree_index].contains("Merkle"), - "air_name={}", - segmentation_ctx.air_names[merkle_tree_index] - ); - } - if memory_ctx.access_adapters_enabled { - debug_assert!( - segmentation_ctx.air_names[memory_ctx.adapter_offset] - .contains("AccessAdapterAir<2>"), - "air_name={}", - segmentation_ctx.air_names[memory_ctx.adapter_offset] - ); - } - + let merkle_tree_index = memory_ctx.merkle_tree_index; + debug_assert!( + segmentation_ctx.air_names[merkle_tree_index].contains("Merkle"), + "air_name={}", + segmentation_ctx.air_names[merkle_tree_index] + ); let mut ctx = Self { trace_heights, is_trace_height_constant, @@ -246,12 +234,6 @@ impl ExecutionCtxTrait for MeteredCtx { "size must be a power of 2, got {size}" ); - // Handle access adapter updates - // SAFETY: size passed is always a non-zero power of 2 - let size_bits = unsafe { NonZero::new_unchecked(size).ilog2() }; - self.memory_ctx - .update_adapter_heights(&mut self.trace_heights, address_space, size_bits); - // Handle merkle tree updates if address_space != RV32_REGISTER_AS { self.memory_ctx diff --git a/crates/vm/src/arch/execution_mode/metered/memory_ctx.rs b/crates/vm/src/arch/execution_mode/metered/memory_ctx.rs index 0a542adba1..88794f5996 100644 --- a/crates/vm/src/arch/execution_mode/metered/memory_ctx.rs +++ b/crates/vm/src/arch/execution_mode/metered/memory_ctx.rs @@ -103,12 +103,8 @@ impl BitSet { #[derive(Clone, Debug)] pub struct MemoryCtx { memory_dimensions: MemoryDimensions, - min_block_size_bits: Vec, pub boundary_idx: usize, - pub merkle_tree_index: Option, - pub adapter_offset: usize, - pub access_adapters_enabled: bool, - continuations_enabled: bool, + pub merkle_tree_index: usize, chunk: u32, chunk_bits: u32, pub page_indices: BitSet, @@ -131,15 +127,11 @@ impl MemoryCtx { Self::calculate_checkpoint_capacity(segment_check_insns); Self { - min_block_size_bits: config.memory_config.min_block_size_bits(), boundary_idx: config.memory_boundary_air_id(), merkle_tree_index: config.memory_merkle_air_id(), - adapter_offset: config.access_adapter_air_id_offset(), - access_adapters_enabled: config.access_adapters_enabled(), chunk, chunk_bits, memory_dimensions, - continuations_enabled: config.continuation_enabled, page_indices: BitSet::new(bitset_size), addr_space_access_count: vec![0; addr_space_size].into(), page_indices_since_checkpoint: vec![0; page_indices_since_checkpoint_cap] @@ -155,13 +147,11 @@ impl MemoryCtx { #[inline(always)] pub(crate) fn add_register_merkle_heights(&mut self) { - if self.continuations_enabled { - self.update_boundary_merkle_heights( - RV32_REGISTER_AS, - 0, - (RV32_NUM_REGISTERS * RV32_REGISTER_NUM_LIMBS) as u32, - ); - } + self.update_boundary_merkle_heights( + RV32_REGISTER_AS, + 0, + (RV32_NUM_REGISTERS * RV32_REGISTER_NUM_LIMBS) as u32, + ); } /// For each memory access, record the minimal necessary data to update heights of @@ -216,53 +206,6 @@ impl MemoryCtx { } } - #[inline(always)] - pub fn update_adapter_heights( - &mut self, - trace_heights: &mut [u32], - address_space: u32, - size_bits: u32, - ) { - self.update_adapter_heights_batch(trace_heights, address_space, size_bits, 1); - } - - #[inline(always)] - pub fn update_adapter_heights_batch( - &self, - trace_heights: &mut [u32], - address_space: u32, - size_bits: u32, - num: u32, - ) { - if !self.access_adapters_enabled { - return; - } - - debug_assert!((address_space as usize) < self.min_block_size_bits.len()); - - // SAFETY: address_space passed is usually a hardcoded constant or derived from an - // Instruction where it is bounds checked before passing - let align_bits = unsafe { - *self - .min_block_size_bits - .get_unchecked(address_space as usize) - }; - debug_assert!( - align_bits as u32 <= size_bits, - "align_bits ({align_bits}) must be <= size_bits ({size_bits})" - ); - - for adapter_bits in (align_bits as u32 + 1..=size_bits).rev() { - let adapter_idx = self.adapter_offset + adapter_bits as usize - 1; - debug_assert!(adapter_idx < trace_heights.len()); - // SAFETY: trace_heights is initialized taking access adapters into account - unsafe { - *trace_heights.get_unchecked_mut(adapter_idx) += - num << (size_bits - adapter_bits + 1); - } - } - } - /// Initialize state for a new segment #[inline(always)] pub(crate) fn initialize_segment(&mut self, trace_heights: &mut [u32]) { @@ -274,16 +217,14 @@ impl MemoryCtx { unsafe { *trace_heights.get_unchecked_mut(self.boundary_idx) = 0; } - if let Some(merkle_tree_idx) = self.merkle_tree_index { - // SAFETY: merkle_tree_idx is guaranteed to be in bounds - unsafe { - *trace_heights.get_unchecked_mut(merkle_tree_idx) = 0; - } - let poseidon2_idx = trace_heights.len() - 2; - // SAFETY: poseidon2_idx is trace_heights.len() - 2, guaranteed to be in bounds - unsafe { - *trace_heights.get_unchecked_mut(poseidon2_idx) = 0; - } + // SAFETY: merkle_tree_index is guaranteed to be in bounds + unsafe { + *trace_heights.get_unchecked_mut(self.merkle_tree_index) = 0; + } + let poseidon2_idx = trace_heights.len() - 2; + // SAFETY: poseidon2_idx is trace_heights.len() - 2, guaranteed to be in bounds + unsafe { + *trace_heights.get_unchecked_mut(poseidon2_idx) = 0; } // Apply height updates for all pages accessed since last checkpoint, and @@ -331,44 +272,26 @@ impl MemoryCtx { *trace_heights.get_unchecked_mut(self.boundary_idx) += leaves; } - if let Some(merkle_tree_idx) = self.merkle_tree_index { - debug_assert!(merkle_tree_idx < trace_heights.len()); - debug_assert!(trace_heights.len() >= 2); + debug_assert!(self.merkle_tree_index < trace_heights.len()); + debug_assert!(trace_heights.len() >= 2); - let poseidon2_idx = trace_heights.len() - 2; - // SAFETY: poseidon2_idx is trace_heights.len() - 2, guaranteed to be in bounds - unsafe { - *trace_heights.get_unchecked_mut(poseidon2_idx) += leaves * 2; - } - - let merkle_height = self.memory_dimensions.overall_height(); - let nodes = (((1 << PAGE_BITS) - 1) + (merkle_height - PAGE_BITS)) as u32; - // SAFETY: merkle_tree_idx is guaranteed to be in bounds - unsafe { - *trace_heights.get_unchecked_mut(poseidon2_idx) += nodes * page_access_count * 2; - *trace_heights.get_unchecked_mut(merkle_tree_idx) += nodes * page_access_count * 2; - } + let poseidon2_idx = trace_heights.len() - 2; + // SAFETY: poseidon2_idx is trace_heights.len() - 2, guaranteed to be in bounds + unsafe { + *trace_heights.get_unchecked_mut(poseidon2_idx) += leaves * 2; } - for address_space in 0..addr_space_access_count.len() { - // SAFETY: address_space is from 0 to len(), guaranteed to be in bounds - let x = unsafe { *addr_space_access_count.get_unchecked(address_space) }; - if x > 0 { - // Initial **and** final handling of touched pages requires send (resp. receive) in - // chunk-sized units for the merkle chip - // Corresponds to `handle_uninitialized_memory` and `handle_touched_blocks` in - // online.rs - self.update_adapter_heights_batch( - trace_heights, - address_space as u32, - self.chunk_bits, - x << (PAGE_BITS + 1), - ); - } + let merkle_height = self.memory_dimensions.overall_height(); + let nodes = (((1 << PAGE_BITS) - 1) + (merkle_height - PAGE_BITS)) as u32; + // SAFETY: merkle_tree_index is guaranteed to be in bounds + unsafe { + *trace_heights.get_unchecked_mut(poseidon2_idx) += nodes * page_access_count * 2; + *trace_heights.get_unchecked_mut(self.merkle_tree_index) += + nodes * page_access_count * 2; } } - /// Resolve all lazy updates of each memory access for memory adapters/poseidon2/merkle chip. + /// Resolve all lazy updates of each memory access for poseidon2/merkle chips. #[inline(always)] pub(crate) fn lazy_update_boundary_heights(&mut self, trace_heights: &mut [u32]) { self.apply_height_updates(trace_heights, &self.addr_space_access_count); diff --git a/crates/vm/src/arch/execution_mode/metered_cost.rs b/crates/vm/src/arch/execution_mode/metered_cost.rs index 21d41a5aa2..4bd8cc320b 100644 --- a/crates/vm/src/arch/execution_mode/metered_cost.rs +++ b/crates/vm/src/arch/execution_mode/metered_cost.rs @@ -1,12 +1,10 @@ -use std::num::NonZero; - use getset::WithSetters; use openvm_instructions::riscv::RV32_IMM_AS; use crate::{ arch::{ execution_mode::metered::segment_ctx::DEFAULT_MAX_MEMORY as DEFAULT_SEGMENT_MAX_MEMORY, - ExecutionCtxTrait, MeteredExecutionCtxTrait, SystemConfig, VmExecState, + ExecutionCtxTrait, MeteredExecutionCtxTrait, VmExecState, }, system::memory::online::GuestMemory, }; @@ -14,57 +12,9 @@ use crate::{ const DEFAULT_MAX_SEGMENTS: u64 = 100; pub const DEFAULT_MAX_COST: u64 = DEFAULT_MAX_SEGMENTS * DEFAULT_SEGMENT_MAX_MEMORY as u64; -#[derive(Clone, Debug)] -pub struct AccessAdapterCtx { - min_block_size_bits: Vec, - idx_offset: usize, -} - -impl AccessAdapterCtx { - pub fn new(config: &SystemConfig) -> Self { - Self { - min_block_size_bits: config.memory_config.min_block_size_bits(), - idx_offset: config.access_adapter_air_id_offset(), - } - } - - #[inline(always)] - pub fn update_cells( - &self, - cost: &mut u64, - address_space: u32, - size_bits: u32, - widths: &[usize], - ) { - debug_assert!((address_space as usize) < self.min_block_size_bits.len()); - - // SAFETY: address_space passed is usually a hardcoded constant or derived from an - // Instruction where it is bounds checked before passing - let align_bits = unsafe { - *self - .min_block_size_bits - .get_unchecked(address_space as usize) - }; - debug_assert!( - align_bits as u32 <= size_bits, - "align_bits ({align_bits}) must be <= size_bits ({size_bits})" - ); - - for adapter_bits in (align_bits as u32 + 1..=size_bits).rev() { - let adapter_idx = self.idx_offset + adapter_bits as usize - 1; - debug_assert!(adapter_idx < widths.len()); - // SAFETY: widths is initialized taking access adapters into account - let width = unsafe { *widths.get_unchecked(adapter_idx) }; - let height_delta = 1 << (size_bits - adapter_bits + 1); - *cost += (height_delta as u64) * (width as u64); - } - } -} - #[derive(Clone, Debug, WithSetters)] pub struct MeteredCostCtx { pub widths: Vec, - pub access_adapter_ctx: Option, #[getset(set_with = "pub")] pub max_execution_cost: u64, // Cost is number of trace cells (height * width) @@ -74,13 +24,9 @@ pub struct MeteredCostCtx { } impl MeteredCostCtx { - pub fn new(widths: Vec, config: &SystemConfig) -> Self { - let access_adapter_ctx = config - .access_adapters_enabled() - .then(|| AccessAdapterCtx::new(config)); + pub fn new(widths: Vec) -> Self { Self { widths, - access_adapter_ctx, max_execution_cost: DEFAULT_MAX_COST, cost: 0, instret: 0, @@ -113,13 +59,6 @@ impl ExecutionCtxTrait for MeteredCostCtx { if self.cost > 2 * std::cmp::max(self.max_execution_cost, DEFAULT_MAX_COST) { self.panic_cost_exceeded(); } - - // Handle access adapter updates - // SAFETY: size passed is always a non-zero power of 2 - let size_bits = unsafe { NonZero::new_unchecked(size).ilog2() }; - if let Some(ctx) = self.access_adapter_ctx.as_mut() { - ctx.update_cells(&mut self.cost, address_space, size_bits, &self.widths); - } } #[inline(always)] diff --git a/crates/vm/src/arch/extensions.rs b/crates/vm/src/arch/extensions.rs index 29caac63d0..0577287e86 100644 --- a/crates/vm/src/arch/extensions.rs +++ b/crates/vm/src/arch/extensions.rs @@ -131,7 +131,7 @@ pub struct AirInventory { config: SystemConfig, /// The system AIRs required by the circuit architecture. #[get = "pub"] - system: SystemAirInventory, + system: SystemAirInventory, /// List of all non-system AIRs in the circuit, in insertion order, which is the **reverse** of /// the order they appear in the verifying key. /// @@ -396,7 +396,7 @@ impl AirInventory { /// Outside of this crate, [AirInventory] must be constructed via [SystemConfig]. pub(crate) fn new( config: SystemConfig, - system: SystemAirInventory, + system: SystemAirInventory, bus_idx_mgr: BusIndexManager, ) -> Self { Self { @@ -769,7 +769,7 @@ mod tests { use openvm_stark_sdk::config::baby_bear_poseidon2::BabyBearPoseidon2Config; use super::*; - use crate::{arch::VmCircuitConfig, system::memory::interface::MemoryInterfaceAirs}; + use crate::arch::VmCircuitConfig; #[allow(dead_code)] #[derive(Copy, Clone)] @@ -850,12 +850,7 @@ mod tests { assert_eq!(port.memory_bridge.memory_bus().index(), 1); assert_eq!(port.program_bus.index(), 2); assert_eq!(port.memory_bridge.range_bus().index(), 3); - match &system.memory.interface { - MemoryInterfaceAirs::Persistent { boundary, .. } => { - assert_eq!(boundary.merkle_bus.index, 4); - assert_eq!(boundary.compression_bus.index, 5); - } - _ => unreachable!(), - }; + assert_eq!(system.memory.interface.boundary.merkle_bus.index, 4); + assert_eq!(system.memory.interface.boundary.compression_bus.index, 5); } } diff --git a/crates/vm/src/arch/testing/cpu.rs b/crates/vm/src/arch/testing/cpu.rs index 20119d3433..e8a0f4efb2 100644 --- a/crates/vm/src/arch/testing/cpu.rs +++ b/crates/vm/src/arch/testing/cpu.rs @@ -8,14 +8,19 @@ use openvm_circuit_primitives::{ Chip, }; use openvm_cpu_backend::{CpuBackend, CpuProverError}; -use openvm_instructions::{instruction::Instruction, riscv::RV32_REGISTER_AS}; +use openvm_instructions::{ + instruction::Instruction, + riscv::{RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS}, + DEFERRAL_AS, +}; use openvm_poseidon2_air::Poseidon2SubAir; use openvm_stark_backend::{ interaction::{LookupBus, PermutationCheckBus}, p3_matrix::dense::RowMajorMatrix, p3_util::log2_strict_usize, prover::AirProvingContext, - AirRef, AnyAir, StarkEngine, StarkProtocolConfig, SystemParams, Val, VerificationData, + AirRef, AnyAir, StarkEngine, StarkProtocolConfig, StarkTestError, SystemParams, Val, + VerificationData, }; use openvm_stark_sdk::{ config::baby_bear_poseidon2::{self, BabyBearPoseidon2Config}, @@ -39,7 +44,6 @@ use crate::{ }, system::{ memory::{ - adapter::records::arena_size_bound, offline_checker::{MemoryBridge, MemoryBus}, online::TracingMemory, MemoryAirInventory, MemoryController, SharedMemoryHelper, @@ -318,12 +322,6 @@ impl VmChipTestBuilder { } impl VmChipTestBuilder { - pub fn default_persistent() -> Self { - let mut mem_config = MemoryConfig::default(); - mem_config.addr_spaces[RV32_REGISTER_AS as usize].num_cells = 1 << 29; - Self::persistent(mem_config) - } - fn range_checker_and_memory( mem_config: &MemoryConfig, init_block_size: usize, @@ -332,14 +330,12 @@ impl VmChipTestBuilder { RANGE_CHECKER_BUS, mem_config.decomp, ))); - let max_access_adapter_n = log2_strict_usize(mem_config.max_access_adapter_n); - let arena_size_bound = arena_size_bound(&vec![1 << 16; max_access_adapter_n]); - let memory = TracingMemory::new(mem_config, init_block_size, arena_size_bound); + let memory = TracingMemory::new(mem_config, init_block_size); (range_checker, memory) } - pub fn persistent(mem_config: MemoryConfig) -> Self { + pub fn from_config(mem_config: MemoryConfig) -> Self { setup_tracing_with_log_level(Level::INFO); let (range_checker, memory) = Self::range_checker_and_memory(&mem_config, CONST_BLOCK_SIZE); let hasher_chip = Arc::new(Poseidon2PeripheryChip::new(vm_poseidon2_config(), 3)); @@ -362,26 +358,6 @@ impl VmChipTestBuilder { default_pointer: 0, } } - - pub fn volatile(mem_config: MemoryConfig) -> Self { - setup_tracing_with_log_level(Level::INFO); - let (range_checker, memory) = Self::range_checker_and_memory(&mem_config, 1); - let memory_controller = MemoryController::with_volatile_memory( - MemoryBus::new(MEMORY_BUS), - mem_config, - range_checker, - ); - Self { - memory: MemoryTester::new(memory_controller, memory), - streams: Default::default(), - rng: StdRng::seed_from_u64(0), - execution: ExecutionTester::new(ExecutionBus::new(EXECUTION_BUS)), - program: ProgramTester::new(ProgramBus::new(READ_INSTRUCTION_BUS)), - internal_rng: StdRng::seed_from_u64(0), - default_register: 0, - default_pointer: 0, - } - } } impl Default for VmChipTestBuilder { @@ -390,7 +366,8 @@ impl Default for VmChipTestBuilder { // TODO[jpw]: this is because old tests use `gen_pointer` on address space 1; this can be // removed when tests are updated. mem_config.addr_spaces[RV32_REGISTER_AS as usize].num_cells = 1 << 29; - Self::persistent(mem_config) + mem_config.addr_spaces[DEFERRAL_AS as usize].num_cells = 0; + Self::from_config(mem_config) } } @@ -463,9 +440,8 @@ where pub fn finalize(mut self) -> Self { if let Some(memory_tester) = self.memory.take() { let mut memory_controller = memory_tester.controller; - let is_persistent = memory_controller.continuation_enabled(); let mut memory = memory_tester.memory; - let touched_memory = memory.finalize::>(is_persistent); + let touched_memory = memory.finalize::>(); // Balance memory boundaries let range_checker = memory_controller.range_checker.clone(); for mem_chip in memory_tester.chip_for_block.into_values() { @@ -474,14 +450,10 @@ where let mem_inventory = MemoryAirInventory::new( memory_controller.memory_bridge(), memory_controller.memory_config(), - range_checker.bus(), - is_persistent.then_some(( - PermutationCheckBus::new(MEMORY_MERKLE_BUS), - PermutationCheckBus::new(POSEIDON2_DIRECT_BUS), - )), + PermutationCheckBus::new(MEMORY_MERKLE_BUS), + PermutationCheckBus::new(POSEIDON2_DIRECT_BUS), ); - let ctxs = memory_controller - .generate_proving_ctx(memory.access_adapter_records, touched_memory); + let ctxs = memory_controller.generate_proving_ctx(touched_memory); for (air, ctx) in zip_eq(mem_inventory.into_airs(), ctxs).filter(|(_, ctx)| ctx.height() > 0) { diff --git a/crates/vm/src/arch/testing/cuda.rs b/crates/vm/src/arch/testing/cuda.rs index 67dfabe03d..c96fbde378 100644 --- a/crates/vm/src/arch/testing/cuda.rs +++ b/crates/vm/src/arch/testing/cuda.rs @@ -250,57 +250,19 @@ impl Default for GpuChipTestBuilder { let mut mem_config = MemoryConfig::default(); // Currently tests still use gen_pointer for the full 1<<29 range of address space 1. mem_config.addr_spaces[RV32_REGISTER_AS as usize].num_cells = 1 << 29; - Self::volatile(mem_config, default_var_range_checker_bus()) + Self::new(mem_config, default_var_range_checker_bus()) } } impl GpuChipTestBuilder { - pub fn new() -> Self { - Self::default() - } - - pub fn new_persistent() -> Self { - let mut mem_config = MemoryConfig::default(); - // Currently tests still use gen_pointer for the full 1<<29 range of address space 1. - mem_config.addr_spaces[RV32_REGISTER_AS as usize].num_cells = 1 << 29; - Self::persistent(mem_config, default_var_range_checker_bus()) - } - - pub fn volatile(mem_config: MemoryConfig, bus: VariableRangeCheckerBus) -> Self { - setup_tracing_with_log_level(Level::INFO); - let mem_bus = MemoryBus::new(MEMORY_BUS); - let range_checker = Arc::new(VariableRangeCheckerChipGPU::hybrid(Arc::new( - VariableRangeCheckerChip::new(bus), - ))); - Self { - memory: DeviceMemoryTester::volatile( - default_tracing_memory(&mem_config, 1), - mem_bus, - mem_config, - range_checker.clone(), - ), - execution: DeviceExecutionTester::new(ExecutionBus::new(EXECUTION_BUS)), - program: DeviceProgramTester::new(ProgramBus::new(READ_INSTRUCTION_BUS)), - streams: Default::default(), - var_range_checker: range_checker, - bitwise_op_lookup: None, - range_tuple_checker: None, - rng: StdRng::seed_from_u64(0), - default_register: 0, - default_pointer: 0, - #[cfg(feature = "metrics")] - metrics: VmMetrics::default(), - } - } - - pub fn persistent(mem_config: MemoryConfig, bus: VariableRangeCheckerBus) -> Self { + pub fn new(mem_config: MemoryConfig, bus: VariableRangeCheckerBus) -> Self { setup_tracing_with_log_level(Level::INFO); let mem_bus = MemoryBus::new(MEMORY_BUS); let range_checker = Arc::new(VariableRangeCheckerChipGPU::hybrid(Arc::new( VariableRangeCheckerChip::new(bus), ))); Self { - memory: DeviceMemoryTester::persistent( + memory: DeviceMemoryTester::new( default_tracing_memory(&mem_config, CONST_BLOCK_SIZE), mem_bus, mem_config, @@ -605,27 +567,23 @@ impl GpuChipTester { pub fn finalize(mut self) -> Self { if let Some(mut memory_tester) = self.memory.take() { - let is_persistent = memory_tester.inventory.continuation_enabled(); - let touched_memory = memory_tester.memory.finalize::(is_persistent); + let touched_memory = memory_tester.memory.finalize::(); let memory_bridge = memory_tester.memory_bridge(); for chip in memory_tester.chip_for_block.into_values() { self = self.load_periphery(chip.0.air, chip); } - let airs = MemoryAirInventory::::new( + let airs = MemoryAirInventory::new( memory_bridge, &memory_tester.config, - memory_tester.range_bus, - is_persistent.then_some(( - PermutationCheckBus::new(MEMORY_MERKLE_BUS), - PermutationCheckBus::new(POSEIDON2_DIRECT_BUS), - )), + PermutationCheckBus::new(MEMORY_MERKLE_BUS), + PermutationCheckBus::new(POSEIDON2_DIRECT_BUS), ) .into_airs(); let ctxs = memory_tester .inventory - .generate_proving_ctxs(memory_tester.memory.access_adapter_records, touched_memory); + .generate_proving_ctxs(touched_memory); for (air, ctx) in airs .into_iter() .zip(ctxs) diff --git a/crates/vm/src/arch/testing/memory/cuda.rs b/crates/vm/src/arch/testing/memory/cuda.rs index 1bd7fbdd1e..a1f89b0b32 100644 --- a/crates/vm/src/arch/testing/memory/cuda.rs +++ b/crates/vm/src/arch/testing/memory/cuda.rs @@ -40,30 +40,7 @@ pub struct DeviceMemoryTester { } impl DeviceMemoryTester { - pub fn volatile( - memory: TracingMemory, - mem_bus: MemoryBus, - mem_config: MemoryConfig, - range_checker: Arc, - ) -> Self { - let mut chip_for_block = HashMap::new(); - for log_block_size in 0..6 { - let block_size = 1 << log_block_size; - chip_for_block.insert(block_size, FixedSizeMemoryTester::new(mem_bus, block_size)); - } - let range_bus = range_checker.cpu_chip.as_ref().unwrap().bus(); - Self { - chip_for_block, - memory, - inventory: MemoryInventoryGPU::volatile(mem_config.clone(), range_checker), - hasher_chip: None, - config: mem_config, - mem_bus, - range_bus, - } - } - - pub fn persistent( + pub fn new( memory: TracingMemory, mem_bus: MemoryBus, mem_config: MemoryConfig, @@ -80,11 +57,8 @@ impl DeviceMemoryTester { 1 << 20, // probably enough for our tests sbox_regs, )); - let mut inventory = MemoryInventoryGPU::persistent( - mem_config.clone(), - range_checker, - poseidon2_periphery.clone(), - ); + let mut inventory = + MemoryInventoryGPU::new(mem_config.clone(), poseidon2_periphery.clone()); inventory.set_initial_memory(&memory.data.memory); Self { chip_for_block, @@ -103,13 +77,8 @@ impl DeviceMemoryTester { pub fn read(&mut self, addr_space: usize, ptr: usize) -> [F; N] { let t = self.memory.timestamp(); - let (t_prev, data) = if addr_space <= 3 { - let (t_prev, data) = - unsafe { self.memory.read::(addr_space as u32, ptr as u32) }; - (t_prev, data.map(F::from_u8)) - } else { - unsafe { self.memory.read::(addr_space as u32, ptr as u32) } - }; + let (t_prev, data) = unsafe { self.memory.read::(addr_space as u32, ptr as u32) }; + let data = data.map(F::from_u8); self.chip_for_block.get_mut(&N).unwrap().receive( addr_space as u32, ptr as u32, @@ -125,21 +94,14 @@ impl DeviceMemoryTester { pub fn write(&mut self, addr_space: usize, ptr: usize, data: [F; N]) { let t = self.memory.timestamp(); - let (t_prev, data_prev) = if addr_space <= 3 { - let (t_prev, data_prev) = unsafe { - self.memory.write::( - addr_space as u32, - ptr as u32, - data.map(|x| x.as_canonical_u32() as u8), - ) - }; - (t_prev, data_prev.map(F::from_u8)) - } else { - unsafe { - self.memory - .write::(addr_space as u32, ptr as u32, data) - } + let (t_prev, data_prev) = unsafe { + self.memory.write::( + addr_space as u32, + ptr as u32, + data.map(|x| x.as_canonical_u32() as u8), + ) }; + let data_prev = data_prev.map(F::from_u8); self.chip_for_block.get_mut(&N).unwrap().receive( addr_space as u32, ptr as u32, diff --git a/crates/vm/src/arch/testing/memory/mod.rs b/crates/vm/src/arch/testing/memory/mod.rs index b622bc2f76..2538d3d912 100644 --- a/crates/vm/src/arch/testing/memory/mod.rs +++ b/crates/vm/src/arch/testing/memory/mod.rs @@ -46,12 +46,8 @@ impl MemoryTester { let memory = &mut self.memory; let t = memory.timestamp(); // TODO: this could be improved if we added a TracingMemory::get_f function - let (t_prev, data) = if addr_space <= 3 { - let (t_prev, data) = unsafe { memory.read::(addr_space as u32, ptr as u32) }; - (t_prev, data.map(F::from_u8)) - } else { - unsafe { memory.read::(addr_space as u32, ptr as u32) } - }; + let (t_prev, data) = unsafe { memory.read::(addr_space as u32, ptr as u32) }; + let data = data.map(F::from_u8); self.chip_for_block.get_mut(&N).unwrap().receive( addr_space as u32, ptr as u32, @@ -70,18 +66,14 @@ impl MemoryTester { let memory = &mut self.memory; let t = memory.timestamp(); // TODO: this could be improved if we added a TracingMemory::write_f function - let (t_prev, data_prev) = if addr_space <= 3 { - let (t_prev, data_prev) = unsafe { - memory.write::( - addr_space as u32, - ptr as u32, - data.map(|x| x.as_canonical_u32() as u8), - ) - }; - (t_prev, data_prev.map(F::from_u8)) - } else { - unsafe { memory.write::(addr_space as u32, ptr as u32, data) } + let (t_prev, data_prev) = unsafe { + memory.write::( + addr_space as u32, + ptr as u32, + data.map(|x| x.as_canonical_u32() as u8), + ) }; + let data_prev = data_prev.map(F::from_u8); self.chip_for_block.get_mut(&N).unwrap().receive( addr_space as u32, ptr as u32, diff --git a/crates/vm/src/arch/testing/utils.rs b/crates/vm/src/arch/testing/utils.rs index 73e66cbd30..ef7f89b6ec 100644 --- a/crates/vm/src/arch/testing/utils.rs +++ b/crates/vm/src/arch/testing/utils.rs @@ -11,12 +11,9 @@ use openvm_circuit_primitives::{ SharedVariableRangeCheckerChip, VariableRangeCheckerBus, VariableRangeCheckerChip, }, }; -use openvm_stark_backend::{p3_field::Field, p3_util::log2_strict_usize}; +use openvm_stark_backend::p3_field::Field; -use crate::{ - arch::MemoryConfig, - system::memory::{adapter::records::arena_size_bound, online::TracingMemory}, -}; +use crate::{arch::MemoryConfig, system::memory::online::TracingMemory}; pub fn default_var_range_checker_bus() -> VariableRangeCheckerBus { // setting default range_max_bits to 17 because that's the default decomp value in MemoryConfig @@ -49,7 +46,5 @@ pub fn dummy_memory_helper( } pub fn default_tracing_memory(mem_config: &MemoryConfig, init_block_size: usize) -> TracingMemory { - let max_access_adapter_n = log2_strict_usize(mem_config.max_access_adapter_n); - let arena_size_bound = arena_size_bound(&vec![1 << 16; max_access_adapter_n]); - TracingMemory::new(mem_config, init_block_size, arena_size_bound) + TracingMemory::new(mem_config, init_block_size) } diff --git a/crates/vm/src/arch/vm.rs b/crates/vm/src/arch/vm.rs index 440553e179..442f9fa409 100644 --- a/crates/vm/src/arch/vm.rs +++ b/crates/vm/src/arch/vm.rs @@ -56,7 +56,6 @@ use crate::{ system::{ connector::{VmConnectorPvs, DEFAULT_SUSPEND_EXIT_CODE}, memory::{ - adapter::records, merkle::{ public_values::{UserPublicValuesProof, UserPublicValuesProofError}, MemoryMerklePvs, @@ -208,7 +207,7 @@ where } pub fn build_metered_cost_ctx(&self, widths: &[usize]) -> MeteredCostCtx { - MeteredCostCtx::new(widths.to_vec(), self.config.as_ref()) + MeteredCostCtx::new(widths.to_vec()) } } @@ -617,21 +616,8 @@ where let ctx = PreflightCtx::new_with_capacity(&capacities, num_insns); let system_config: &SystemConfig = self.config().as_ref(); - let adapter_offset = system_config.access_adapter_air_id_offset(); - // ATTENTION: this must agree with `num_memory_airs` - - let num_adapters = system_config.memory_config.num_access_adapters(); - - assert_eq!(adapter_offset + num_adapters, system_config.num_airs()); - let access_adapter_arena_size_bound = records::arena_size_bound( - &trace_heights[adapter_offset..adapter_offset + num_adapters], - ); let pc = state.pc(); - let memory = TracingMemory::from_image( - state.memory, - system_config.initial_block_size(), - access_adapter_arena_size_bound, - ); + let memory = TracingMemory::from_image(state.memory, system_config.initial_block_size()); let from_state = ExecutionState::new(pc, memory.timestamp()); let vm_state = VmState::new( pc, @@ -645,10 +631,7 @@ where interpreter.reset_execution_frequencies(); execute_spanned!("execute_preflight", interpreter, &mut exec_state)?; let filtered_exec_frequencies = interpreter.filtered_execution_frequencies(); - let touched_memory = exec_state - .vm_state - .memory - .finalize::>(system_config.continuation_enabled); + let touched_memory = exec_state.vm_state.memory.finalize::>(); #[cfg(feature = "perf-metrics")] crate::metrics::end_segment_metrics(&mut exec_state); @@ -661,7 +644,6 @@ where to_state, exit_code, filtered_exec_frequencies, - access_adapter_records: memory.access_adapter_records, touched_memory, }; let record_arenas = exec_state.ctx.arenas; @@ -707,8 +689,6 @@ where { state.metrics.set_pk_info(&self.pk); state.metrics.num_sys_airs = self.config().as_ref().num_airs(); - state.metrics.access_adapter_offset = - self.config().as_ref().access_adapter_air_id_offset(); } state } @@ -825,28 +805,6 @@ where Ok((proof, final_memory)) } - /// Verify segment proofs, checking continuation boundary conditions between segments if VM - /// memory is persistent. The behavior of this function differs depending on whether - /// continuations is enabled or not. - pub fn verify( - &self, - vk: &MultiStarkVerifyingKey, - proofs: &[Proof], - ) -> Result<(), VmVerificationError> - where - Com: Into<[Val; CHUNK]> + From<[Val; CHUNK]>, - Val: PrimeField32, - { - if self.config().as_ref().continuation_enabled { - verify_segments(&self.engine, vk, proofs).map(|_| ()) - } else { - assert_eq!(proofs.len(), 1); - self.engine - .verify(vk, &proofs[0]) - .map_err(VmVerificationError::StarkError) - } - } - /// Transforms the program into a cached trace and commits it _on device_ using the proof system /// polynomial commitment scheme. /// @@ -986,10 +944,8 @@ mod tests { #[test] fn keygen_marks_required_airs_for_continuations() { let engine = test_cpu_engine(); - let config = SystemConfig::default().with_continuations(); - let merkle_air_id = config - .memory_merkle_air_id() - .expect("continuations should have a merkle AIR"); + let config = SystemConfig::default(); + let merkle_air_id = config.memory_merkle_air_id(); let boundary_air_id = config.memory_boundary_air_id(); let (_vm, pk) = VirtualMachine::new_with_keygen(engine, SystemCpuBuilder, config).unwrap(); diff --git a/crates/vm/src/cuda_abi.rs b/crates/vm/src/cuda_abi.rs index e597f26445..1a748135b8 100644 --- a/crates/vm/src/cuda_abi.rs +++ b/crates/vm/src/cuda_abi.rs @@ -6,8 +6,6 @@ use openvm_cuda_common::{ error::CudaError, }; -use crate::system::cuda::access_adapters::{OffsetInfo, NUM_ADAPTERS}; - pub mod boundary { use super::*; @@ -23,18 +21,6 @@ pub mod boundary { d_poseidon2_buffer_idx: *mut u32, poseidon2_capacity: usize, ) -> i32; - - fn _volatile_boundary_tracegen( - d_trace: *mut F, - height: usize, - width: usize, - d_raw_records: *const u32, - num_records: usize, - d_range_checker: *mut u32, - range_checker_num_bins: usize, - as_max_bits: usize, - ptr_max_bits: usize, - ) -> i32; } #[allow(clippy::too_many_arguments)] @@ -60,30 +46,6 @@ pub mod boundary { d_poseidon2_raw_buffer.len(), )) } - - #[allow(clippy::too_many_arguments)] - pub unsafe fn volatile_boundary_tracegen( - d_trace: &DeviceBuffer, - height: usize, - width: usize, - d_records: &DeviceBuffer, - num_records: usize, - d_range_checker: &DeviceBuffer, - as_max_bits: usize, - ptr_max_bits: usize, - ) -> Result<(), CudaError> { - CudaError::from_result(_volatile_boundary_tracegen( - d_trace.as_mut_ptr(), - height, - width, - d_records.as_ptr(), - num_records, - d_range_checker.as_mut_ptr() as *mut u32, - d_range_checker.len(), - as_max_bits, - ptr_max_bits, - )) - } } pub mod phantom { @@ -214,7 +176,6 @@ pub mod inventory { d_in_records: *const u32, in_num_records: usize, d_initial_mem: *const *const std::ffi::c_void, - d_addr_space_offsets: *const u32, d_tmp_records: *mut u32, d_out_records: *mut u32, d_flags: *mut u32, @@ -230,7 +191,6 @@ pub mod inventory { d_in_records: &DeviceBuffer, in_num_records: usize, d_initial_mem: &DeviceBuffer<*const std::ffi::c_void>, - d_addr_space_offsets: &DeviceBuffer, d_tmp_records: &DeviceBuffer, d_out_records: &DeviceBuffer, d_flags: &DeviceBuffer, @@ -243,7 +203,6 @@ pub mod inventory { d_in_records.as_ptr(), in_num_records, d_initial_mem.as_ptr(), - d_addr_space_offsets.as_ptr(), d_tmp_records.as_mut_ptr(), d_out_records.as_mut_ptr(), d_flags.as_mut_ptr(), @@ -304,50 +263,6 @@ pub mod program { } } -pub mod access_adapters { - use super::*; - - extern "C" { - fn _access_adapters_tracegen( - d_traces: *const *mut std::ffi::c_void, - num_adapters: usize, - d_unpadded_heights: *const usize, - d_widths: *const usize, - num_records: usize, - d_records: *const u8, - d_record_offsets: *mut u32, - d_range_checker: *mut u32, - range_checker_bins: u32, - timestamp_max_bits: u32, - ) -> i32; - } - - #[allow(clippy::too_many_arguments)] - pub unsafe fn tracegen( - d_trace_ptrs: &DeviceBuffer<*mut std::ffi::c_void>, - d_unpadded_heights: &DeviceBuffer, - d_widths: &DeviceBuffer, - num_records: usize, - d_records: &DeviceBuffer, - d_record_offsets: &DeviceBuffer, - d_range_checker: &DeviceBuffer, - timestamp_max_bits: usize, - ) -> Result<(), CudaError> { - CudaError::from_result(_access_adapters_tracegen( - d_trace_ptrs.as_ptr(), - NUM_ADAPTERS, - d_unpadded_heights.as_ptr(), - d_widths.as_ptr(), - num_records, - d_records.as_ptr(), - d_record_offsets.as_mut_ptr() as *mut u32, - d_range_checker.as_mut_ptr() as *mut u32, - d_range_checker.len() as u32, - timestamp_max_bits as u32, - )) - } -} - #[cfg(any(test, feature = "test-utils"))] pub use testing::*; diff --git a/crates/vm/src/metrics/mod.rs b/crates/vm/src/metrics/mod.rs index d5d9f3e9a1..e8b6965c26 100644 --- a/crates/vm/src/metrics/mod.rs +++ b/crates/vm/src/metrics/mod.rs @@ -27,8 +27,6 @@ pub struct VmMetrics { pub debug_infos: ProgramDebugInfo, #[cfg(feature = "perf-metrics")] pub(crate) num_sys_airs: usize, - #[cfg(feature = "perf-metrics")] - pub(crate) access_adapter_offset: usize, pub(crate) main_widths: Vec, pub(crate) total_widths: Vec, @@ -98,47 +96,14 @@ pub fn update_instruction_metrics( } } -// Memory access adapter height calculation is slow, so only do it if this is the end of -// execution. -// We also clear the current trace cell counts so there aren't negative diffs at the start of the -// next segment. +// We clear the current trace cell counts so there aren't negative diffs at the start of the next +// segment. #[cfg(feature = "perf-metrics")] pub fn end_segment_metrics(state: &mut VmExecState>) where F: Clone + Send + Sync, RA: Arena, { - use std::iter::zip; - - use crate::system::memory::adapter::AccessAdapterInventory; - - let access_adapter_offset = state.metrics.access_adapter_offset; - let num_sys_airs = state.metrics.num_sys_airs; - let mut now_heights = vec![0; num_sys_airs - access_adapter_offset]; - AccessAdapterInventory::::compute_heights_from_arena( - &state.memory.access_adapter_records, - &mut now_heights, - ); - let now_trace_cells = zip( - &state.metrics.main_widths[access_adapter_offset..], - &now_heights, - ) - .map(|(main_width, h)| main_width * h) - .collect_vec(); - for (air_name, &now_value) in itertools::izip!( - &state.metrics.air_names[access_adapter_offset..], - &now_trace_cells, - ) { - if now_value != 0 { - let labels = [ - ("air_name", air_name.clone()), - ("opcode", String::default()), - ("dsl_ir", String::default()), - ("cycle_tracker_span", "memory_access_adapters".to_owned()), - ]; - counter!("cells_used", &labels).increment(now_value as u64); - } - } state.metrics.current_trace_cells.fill(0); } diff --git a/crates/vm/src/system/connector/tests.rs b/crates/vm/src/system/connector/tests.rs index 6d3c6acbfe..22d2b8722b 100644 --- a/crates/vm/src/system/connector/tests.rs +++ b/crates/vm/src/system/connector/tests.rs @@ -57,7 +57,7 @@ fn test_vm_connector_wrong_is_terminate() { } fn test_impl(should_pass: bool, exit_code: u32, f: impl FnOnce(&mut AirProvingContext)) { - let vm_config = SystemConfig::default().without_continuations(); + let vm_config = SystemConfig::default(); let engine = test_cpu_engine(); let (mut vm, pk) = VirtualMachine::new_with_keygen(engine, SystemCpuBuilder, vm_config.clone()).unwrap(); diff --git a/crates/vm/src/system/cuda/access_adapters.rs b/crates/vm/src/system/cuda/access_adapters.rs deleted file mode 100644 index 0675110752..0000000000 --- a/crates/vm/src/system/cuda/access_adapters.rs +++ /dev/null @@ -1,276 +0,0 @@ -use std::{ptr::null_mut, sync::Arc}; - -use openvm_circuit::{ - arch::{CustomBorrow, DenseRecordArena, SizedRecord}, - system::memory::adapter::{ - records::{AccessLayout, AccessRecordMut}, - AccessAdapterCols, - }, - utils::next_power_of_two_or_zero, -}; -use openvm_circuit_primitives::var_range::VariableRangeCheckerChipGPU; -use openvm_cuda_backend::{base::DeviceMatrix, prelude::F, GpuBackend}; -use openvm_cuda_common::copy::MemCopyH2D; -use openvm_stark_backend::prover::AirProvingContext; - -use crate::cuda_abi::access_adapters::tracegen; - -pub(crate) const NUM_ADAPTERS: usize = 5; - -pub struct AccessAdapterInventoryGPU { - max_access_adapter_n: usize, - timestamp_max_bits: usize, - range_checker: Arc, - #[cfg(feature = "metrics")] - pub(super) unpadded_heights: Vec, -} - -#[repr(C)] -pub struct OffsetInfo { - pub record_offset: u32, - pub adapter_rows: [u32; NUM_ADAPTERS], -} - -impl AccessAdapterInventoryGPU { - pub(crate) fn generate_traces_from_records( - &mut self, - records: &mut [u8], - ) -> Vec>> { - let max_access_adapter_n = &self.max_access_adapter_n; - let timestamp_max_bits = self.timestamp_max_bits; - let range_checker = &self.range_checker; - - assert!(max_access_adapter_n.is_power_of_two()); - let cnt_adapters = max_access_adapter_n.ilog2() as usize; - if records.is_empty() { - return vec![Some(DeviceMatrix::::dummy()); cnt_adapters]; - } - - let mut offsets = Vec::new(); - let mut offset = 0; - let mut row_ids = [0; NUM_ADAPTERS]; - - while offset < records.len() { - offsets.push(OffsetInfo { - record_offset: offset as u32, - adapter_rows: row_ids, - }); - let layout: AccessLayout = unsafe { records[offset..].extract_layout() }; - let record: AccessRecordMut<'_> = records[offset..].custom_borrow(layout.clone()); - offset += as SizedRecord>::size(&layout); - let bs = record.header.block_size; - let lbs = record.header.lowest_block_size; - for logn in lbs.ilog2()..bs.ilog2() { - row_ids[logn as usize] += bs >> (1 + logn); - } - } - - let d_records = records.to_device().unwrap(); - let d_record_offsets = offsets.to_device().unwrap(); - let widths: [_; NUM_ADAPTERS] = std::array::from_fn(|i| match i { - 0 => size_of::>(), - 1 => size_of::>(), - 2 => size_of::>(), - 3 => size_of::>(), - 4 => size_of::>(), - _ => panic!(), - }); - let unpadded_heights = row_ids - .iter() - .take(cnt_adapters) - .map(|&x| x as usize) - .collect::>(); - let traces = unpadded_heights - .iter() - .enumerate() - .map(|(i, &h)| match h { - 0 => Some(DeviceMatrix::::dummy()), - h => Some(DeviceMatrix::::with_capacity( - next_power_of_two_or_zero(h), - widths[i], - )), - }) - .collect::>(); - let trace_ptrs = traces - .iter() - .map(|trace| { - trace - .as_ref() - .map_or_else(null_mut, |t| t.buffer().as_mut_raw_ptr()) - }) - .collect::>(); - let d_trace_ptrs = trace_ptrs.to_device().unwrap(); - let d_unpadded_heights = unpadded_heights.to_device().unwrap(); - let d_widths = widths.to_device().unwrap(); - - unsafe { - tracegen( - &d_trace_ptrs, - &d_unpadded_heights, - &d_widths, - offsets.len(), - &d_records, - &d_record_offsets, - &range_checker.count, - timestamp_max_bits, - ) - .unwrap(); - } - #[cfg(feature = "metrics")] - { - self.unpadded_heights = unpadded_heights; - } - - traces - } - - pub fn new( - range_checker: Arc, - max_access_adapter_n: usize, - timestamp_max_bits: usize, - ) -> Self { - Self { - range_checker, - max_access_adapter_n, - timestamp_max_bits, - #[cfg(feature = "metrics")] - unpadded_heights: Vec::new(), - } - } - - // @dev: mutable borrow is only to update `self.unpadded_heights` for metrics - pub fn generate_air_proving_ctxs( - &mut self, - mut arena: DenseRecordArena, - ) -> Vec> { - let records = arena.allocated_mut(); - self.generate_traces_from_records(records) - .into_iter() - .map(|trace| AirProvingContext { - cached_mains: vec![], - common_main: trace.unwrap_or_else(DeviceMatrix::dummy), - public_values: vec![], - }) - .collect() - } -} - -#[cfg(test)] -mod tests { - use std::array; - - use openvm_circuit::{ - arch::{ - testing::{MEMORY_BUS, RANGE_CHECKER_BUS}, - MemoryConfig, - }, - system::memory::{offline_checker::MemoryBus, MemoryController}, - }; - use openvm_circuit_primitives::var_range::VariableRangeCheckerBus; - use openvm_cuda_backend::{ - data_transporter::assert_eq_host_and_device_matrix_col_maj, prelude::SC, - }; - use openvm_stark_backend::{ - p3_field::PrimeCharacteristicRing, - prover::{ColMajorMatrix, MatrixDimensions}, - }; - use rand::{rngs::StdRng, Rng, SeedableRng}; - - use super::*; - use crate::arch::testing::{GpuChipTestBuilder, TestBuilder}; - - #[test] - fn test_cuda_access_adapters_cpu_gpu_equivalence() { - let mut mem_config = MemoryConfig::default(); - mem_config.addr_spaces[openvm_instructions::DEFERRAL_AS as usize].num_cells = 1 << 29; - - let mut rng = StdRng::seed_from_u64(42); - let decomp = mem_config.decomp; - let mut tester = GpuChipTestBuilder::volatile( - mem_config.clone(), - VariableRangeCheckerBus::new(RANGE_CHECKER_BUS, decomp), - ); - - let max_ptr = 20; - let aligns = [4, 4, 4, 1]; - let value_bounds = [256, 256, 256, (1 << 30)]; - let max_log_block_size = 4; - let its = 1000; - for _ in 0..its { - let addr_sp = rng.random_range(1..=aligns.len()); - let align: usize = aligns[addr_sp - 1]; - let value_bound: u32 = value_bounds[addr_sp - 1]; - let ptr = rng.random_range(0..max_ptr / align) * align; - let log_len = rng.random_range(align.trailing_zeros()..=max_log_block_size); - match log_len { - 0 => tester.write::<1>( - addr_sp, - ptr, - array::from_fn(|_| F::from_u32(rng.random_range(0..value_bound))), - ), - 1 => tester.write::<2>( - addr_sp, - ptr, - array::from_fn(|_| F::from_u32(rng.random_range(0..value_bound))), - ), - 2 => tester.write::<4>( - addr_sp, - ptr, - array::from_fn(|_| F::from_u32(rng.random_range(0..value_bound))), - ), - 3 => tester.write::<8>( - addr_sp, - ptr, - array::from_fn(|_| F::from_u32(rng.random_range(0..value_bound))), - ), - 4 => tester.write::<16>( - addr_sp, - ptr, - array::from_fn(|_| F::from_u32(rng.random_range(0..value_bound))), - ), - _ => unreachable!(), - } - } - - let touched = tester.memory.memory.finalize(false); - let mut access_adapter_inv = AccessAdapterInventoryGPU::new( - tester.range_checker(), - mem_config.max_access_adapter_n, - mem_config.timestamp_max_bits, - ); - let allocated = tester.memory.memory.access_adapter_records.allocated_mut(); - let gpu_traces = access_adapter_inv - .generate_traces_from_records(allocated) - .into_iter() - .map(|trace| trace.unwrap_or_else(DeviceMatrix::dummy)) - .collect::>(); - - let mut controller = MemoryController::with_volatile_memory( - MemoryBus::new(MEMORY_BUS), - mem_config, - tester.cpu_range_checker(), - ); - let all_memory_traces = controller - .generate_proving_ctx::(tester.memory.memory.access_adapter_records, touched) - .into_iter() - .map(|ctx| ctx.common_main) - .collect::>(); - let num_memory_traces = all_memory_traces.len(); - let cpu_traces: Vec<_> = all_memory_traces - .into_iter() - .skip(num_memory_traces - NUM_ADAPTERS) - .collect::>(); - - for (cpu_trace, gpu_trace) in cpu_traces.into_iter().zip(gpu_traces.iter()) { - assert_eq!( - cpu_trace.height() == 0, - gpu_trace.height() == 0, - "Exactly one of CPU and GPU traces is empty" - ); - if cpu_trace.height() != 0 { - let cpu_trace_cm = ColMajorMatrix::from_row_major(&cpu_trace); - assert_eq_host_and_device_matrix_col_maj(&cpu_trace_cm, gpu_trace); - } - } - } -} diff --git a/crates/vm/src/system/cuda/boundary.rs b/crates/vm/src/system/cuda/boundary.rs index 622c497155..3f27c0ce66 100644 --- a/crates/vm/src/system/cuda/boundary.rs +++ b/crates/vm/src/system/cuda/boundary.rs @@ -1,48 +1,22 @@ -use std::sync::Arc; - use openvm_circuit::{ - arch::CONST_BLOCK_SIZE, - system::memory::{ - persistent::PersistentBoundaryCols, volatile::VolatileBoundaryCols, - TimestampedEquipartition, TimestampedValues, - }, + arch::CONST_BLOCK_SIZE, system::memory::persistent::PersistentBoundaryCols, utils::next_power_of_two_or_zero, }; -use openvm_circuit_primitives::{var_range::VariableRangeCheckerChipGPU, Chip}; +use openvm_circuit_primitives::Chip; use openvm_cuda_backend::{base::DeviceMatrix, prelude::F, GpuBackend}; use openvm_cuda_common::{copy::MemCopyH2D, d_buffer::DeviceBuffer}; -use openvm_stark_backend::{ - p3_field::PrimeField32, - p3_maybe_rayon::prelude::{IntoParallelRefIterator, ParallelIterator}, - prover::{AirProvingContext, MatrixDimensions}, -}; +use openvm_stark_backend::prover::{AirProvingContext, MatrixDimensions}; use super::{poseidon2::SharedBuffer, DIGEST_WIDTH}; -use crate::cuda_abi::boundary::{persistent_boundary_tracegen, volatile_boundary_tracegen}; +use crate::cuda_abi::boundary::persistent_boundary_tracegen; -pub struct PersistentBoundary { +pub struct BoundaryChipGPU { pub poseidon2_buffer: SharedBuffer, /// A `Vec` of pointers to the copied guest memory on device. /// This struct cannot own the device memory, hence we take extra care not to use memory we /// don't own. TODO: use `Arc` instead? pub initial_leaves: Vec<*const std::ffi::c_void>, pub records: Option>, -} - -pub struct VolatileBoundary { - pub range_checker: Arc, - pub as_max_bits: usize, - pub ptr_max_bits: usize, - pub records: Option>, -} - -pub enum BoundaryFields { - Persistent(PersistentBoundary), - Volatile(VolatileBoundary), -} - -pub struct BoundaryChipGPU { - pub fields: BoundaryFields, pub num_records: Option, pub trace_width: Option, } @@ -59,107 +33,44 @@ pub struct PersistentBoundaryRecord { } impl BoundaryChipGPU { - pub fn persistent(poseidon2_buffer: SharedBuffer) -> Self { + pub fn new(poseidon2_buffer: SharedBuffer) -> Self { Self { - fields: BoundaryFields::Persistent(PersistentBoundary { - poseidon2_buffer, - initial_leaves: Vec::new(), - records: None, - }), + poseidon2_buffer, + initial_leaves: Vec::new(), + records: None, num_records: None, trace_width: None, } } - pub fn volatile( - range_checker: Arc, - as_max_bits: usize, - ptr_max_bits: usize, - ) -> Self { - Self { - fields: BoundaryFields::Volatile(VolatileBoundary { - range_checker, - as_max_bits, - ptr_max_bits, - records: None, - }), - num_records: None, - trace_width: None, - } - } - - // Records in the buffer are series of u32s. A single record consts - // of [as, ptr, timestamp, values[0], ..., values[CHUNK - 1]]. - pub fn finalize_records_volatile( - &mut self, - final_memory: TimestampedEquipartition, - ) { - match &mut self.fields { - BoundaryFields::Persistent(_) => panic!("call `finalize_records_persistent`"), - BoundaryFields::Volatile(fields) => { - self.num_records = Some(final_memory.len()); - self.trace_width = Some(VolatileBoundaryCols::::width()); - let records: Vec<_> = final_memory - .par_iter() - .flat_map(|&((addr_space, ptr), ts_values)| { - let TimestampedValues { timestamp, values } = ts_values; - let mut record = vec![addr_space, ptr, timestamp]; - record.extend_from_slice(&values.map(|x| x.as_canonical_u32())); - record - }) - .collect(); - fields.records = Some(records); - } - } - } - - pub fn finalize_records_persistent( - &mut self, - records: Vec, - ) { - match &mut self.fields { - BoundaryFields::Volatile(_) => panic!("call `finalize_records_volatile`"), - BoundaryFields::Persistent(fields) => { - self.num_records = Some(records.len()); - self.trace_width = Some(PersistentBoundaryCols::::width()); - fields.records = Some(if records.is_empty() { - DeviceBuffer::new() - } else { - records.to_device().unwrap().as_buffer::() - }); - } - } + pub fn finalize_records(&mut self, records: Vec) { + self.num_records = Some(records.len()); + self.trace_width = Some(PersistentBoundaryCols::::width()); + self.records = Some(if records.is_empty() { + DeviceBuffer::new() + } else { + records.to_device().unwrap().as_buffer::() + }); } - pub fn finalize_records_persistent_device( + pub fn finalize_records_device( &mut self, records: DeviceBuffer, num_records: usize, ) { - match &mut self.fields { - BoundaryFields::Volatile(_) => panic!("call `finalize_records_volatile`"), - BoundaryFields::Persistent(fields) => { - self.num_records = Some(num_records); - self.trace_width = Some(PersistentBoundaryCols::::width()); - fields.records = Some(records); - } - } + self.num_records = Some(num_records); + self.trace_width = Some(PersistentBoundaryCols::::width()); + self.records = Some(records); } pub fn trace_width(&self) -> usize { self.trace_width.expect("Finalize records to get width") } - pub fn persistent_records(&self) -> &DeviceBuffer { - match &self.fields { - BoundaryFields::Persistent(fields) => fields - .records - .as_ref() - .expect("Finalize records to get buffer"), - BoundaryFields::Volatile(_) => { - panic!("persistent_records called on volatile boundary") - } - } + pub fn records(&self) -> &DeviceBuffer { + self.records + .as_ref() + .expect("Finalize records to get buffer") } } @@ -169,135 +80,23 @@ impl Chip for BoundaryChipGPU { if num_records == 0 { return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); } - let unpadded_height = match &self.fields { - BoundaryFields::Persistent(_) => 2 * num_records, - BoundaryFields::Volatile(_) => num_records, - }; + let unpadded_height = 2 * num_records; let trace_height = next_power_of_two_or_zero(unpadded_height); let trace = DeviceMatrix::::with_capacity(trace_height, self.trace_width()); - match &self.fields { - BoundaryFields::Persistent(boundary) => { - let mem_ptrs = boundary.initial_leaves.to_device().unwrap(); - unsafe { - persistent_boundary_tracegen( - trace.buffer(), - trace.height(), - trace.width(), - &mem_ptrs, - boundary.records.as_ref().unwrap(), - num_records, - &boundary.poseidon2_buffer.buffer, - &boundary.poseidon2_buffer.idx, - ) - .expect("Failed to generate persistent boundary trace"); - } - } - BoundaryFields::Volatile(boundary) => unsafe { - let records = boundary - .records - .as_ref() - .expect("Records must be finalized before generating trace"); - let records = records.to_device().unwrap(); - volatile_boundary_tracegen( - trace.buffer(), - trace.height(), - trace.width(), - &records, - num_records, - &boundary.range_checker.count, - boundary.as_max_bits, - boundary.ptr_max_bits, - ) - .expect("Failed to generate volatile boundary trace"); - }, + let mem_ptrs = self.initial_leaves.to_device().unwrap(); + unsafe { + persistent_boundary_tracegen( + trace.buffer(), + trace.height(), + trace.width(), + &mem_ptrs, + self.records.as_ref().unwrap(), + num_records, + &self.poseidon2_buffer.buffer, + &self.poseidon2_buffer.idx, + ) + .expect("Failed to generate boundary trace"); } AirProvingContext::simple_no_pis(trace) } } - -#[cfg(test)] -mod tests { - use std::{collections::HashSet, sync::Arc}; - - use openvm_circuit::{ - arch::{testing::MEMORY_BUS, MemoryConfig, ADDR_SPACE_OFFSET}, - system::memory::{ - offline_checker::MemoryBus, volatile::VolatileBoundaryChip, TimestampedEquipartition, - TimestampedValues, - }, - }; - use openvm_circuit_primitives::{var_range::VariableRangeCheckerChip, Chip}; - use openvm_cpu_backend::CpuBackend; - use openvm_cuda_backend::{ - data_transporter::assert_eq_host_and_device_matrix_col_maj, - prelude::{F, SC}, - GpuBackend, - }; - use openvm_stark_backend::{ - p3_util::log2_ceil_usize, - prover::{AirProvingContext, ColMajorMatrix}, - }; - use openvm_stark_sdk::utils::create_seeded_rng; - use p3_field::PrimeCharacteristicRing; - use rand::Rng; - - use super::{BoundaryChipGPU, VariableRangeCheckerChipGPU}; - use crate::arch::testing::default_var_range_checker_bus; - - const MAX_ADDRESS_SPACE: u32 = 4; - const LIMB_BITS: usize = 15; - - #[test] - fn test_cuda_volatile_boundary_tracegen() { - const NUM_ADDRESSES: usize = 10; - let mut rng = create_seeded_rng(); - - let mut distinct_addresses = HashSet::new(); - while distinct_addresses.len() < NUM_ADDRESSES { - let addr_space = rng.random_range(0..MAX_ADDRESS_SPACE); - let pointer = rng.random_range(0..(1 << LIMB_BITS)); - distinct_addresses.insert((addr_space, pointer)); - } - - let mut final_memory = TimestampedEquipartition::::new(); - for (addr_space, pointer) in distinct_addresses.iter().cloned() { - let final_data = F::from_u32(rng.random_range(0..(1 << LIMB_BITS))); - let final_clk = rng.random_range(1..(1 << LIMB_BITS)) as u32; - - final_memory.push(( - (addr_space, pointer), - TimestampedValues { - values: [final_data], - timestamp: final_clk, - }, - )); - } - final_memory.sort_by_key(|(k, _)| *k); - - let mem_config = MemoryConfig::default(); - let addr_space_max_bits = log2_ceil_usize( - (ADDR_SPACE_OFFSET + 2u32.pow(mem_config.addr_space_height as u32)) as usize, - ); - let cpu_rc = Arc::new(VariableRangeCheckerChip::new( - default_var_range_checker_bus(), - )); - - let mut gpu_boundary = BoundaryChipGPU::volatile( - Arc::new(VariableRangeCheckerChipGPU::hybrid(cpu_rc.clone())), - addr_space_max_bits, - mem_config.pointer_max_bits, - ); - let mut cpu_boundary: VolatileBoundaryChip = VolatileBoundaryChip::new( - MemoryBus::new(MEMORY_BUS), - addr_space_max_bits, - mem_config.pointer_max_bits, - cpu_rc, - ); - gpu_boundary.finalize_records_volatile(final_memory.clone()); - cpu_boundary.finalize(final_memory); - let gpu_ctx: AirProvingContext = gpu_boundary.generate_proving_ctx(()); - let cpu_ctx: AirProvingContext> = cpu_boundary.generate_proving_ctx(()); - let cpu_cm = ColMajorMatrix::from_row_major(&cpu_ctx.common_main); - assert_eq_host_and_device_matrix_col_maj(&cpu_cm, &gpu_ctx.common_main); - } -} diff --git a/crates/vm/src/system/cuda/extensions.rs b/crates/vm/src/system/cuda/extensions.rs index 67007f4b37..fb12374b1b 100644 --- a/crates/vm/src/system/cuda/extensions.rs +++ b/crates/vm/src/system/cuda/extensions.rs @@ -92,41 +92,31 @@ impl VmBuilder for SystemGpuBuilder { inventory.next_air::()?; inventory.add_periphery_chip(range_checker.clone()); - let hasher_chip = if config.continuation_enabled { - let max_buffer_size = (config.segmentation_config.limits.max_trace_height as usize) - .next_power_of_two() * 2 // seems like a reliable estimate - * (DIGEST_WIDTH * 2); // size of one record - assert_eq!(inventory.chips().len(), POSEIDON2_INSERTION_IDX); - let sbox_registers = if config.max_constraint_degree >= 7 { - 0 - } else { - 1 - }; - // ATTENTION: The threshold 7 here must match the one in `new_poseidon2_periphery_air` - let _direct_bus = if sbox_registers == 0 { - inventory - .next_air::>()? - .bus - } else { - inventory - .next_air::>()? - .bus - }; - let chip = Arc::new(Poseidon2PeripheryChipGPU::new( - max_buffer_size, - sbox_registers, - )); - inventory.add_periphery_chip(chip.clone()); - Some(chip) + let max_buffer_size = (config.segmentation_config.limits.max_trace_height as usize) + .next_power_of_two() * 2 // seems like a reliable estimate + * (DIGEST_WIDTH * 2); // size of one record + assert_eq!(inventory.chips().len(), POSEIDON2_INSERTION_IDX); + let sbox_registers = if config.max_constraint_degree >= 7 { + 0 + } else { + 1 + }; + // ATTENTION: The threshold 7 here must match the one in `new_poseidon2_periphery_air` + let _direct_bus = if sbox_registers == 0 { + inventory + .next_air::>()? + .bus } else { - None + inventory + .next_air::>()? + .bus }; - let system = SystemChipInventoryGPU::new( - config, - &inventory.airs().system().memory, - range_checker, - hasher_chip, - ); + let hasher_chip = Arc::new(Poseidon2PeripheryChipGPU::new( + max_buffer_size, + sbox_registers, + )); + inventory.add_periphery_chip(hasher_chip.clone()); + let system = SystemChipInventoryGPU::new(config, range_checker, hasher_chip); let phantom_chip = PhantomChipGPU::new(); inventory.add_executor_chip(phantom_chip); diff --git a/crates/vm/src/system/cuda/memory.rs b/crates/vm/src/system/cuda/memory.rs index ff1e32bfcf..9f2afc67d3 100644 --- a/crates/vm/src/system/cuda/memory.rs +++ b/crates/vm/src/system/cuda/memory.rs @@ -1,24 +1,21 @@ use std::sync::Arc; use openvm_circuit::{ - arch::{AddressSpaceHostLayout, DenseRecordArena, MemoryConfig, ADDR_SPACE_OFFSET}, + arch::{AddressSpaceHostLayout, MemoryConfig, ADDR_SPACE_OFFSET}, system::{memory::AddressMap, TouchedMemory}, }; -use openvm_circuit_primitives::{var_range::VariableRangeCheckerChipGPU, Chip}; +use openvm_circuit_primitives::Chip; use openvm_cuda_backend::{prelude::F, GpuBackend}; use openvm_cuda_common::{ copy::{cuda_memcpy, MemCopyD2H, MemCopyH2D}, d_buffer::DeviceBuffer, memory_manager::MemTracker, }; -use openvm_stark_backend::{ - p3_field::PrimeCharacteristicRing, p3_util::log2_ceil_usize, prover::AirProvingContext, -}; +use openvm_stark_backend::{p3_field::PrimeCharacteristicRing, prover::AirProvingContext}; use tracing::instrument; use super::{ - access_adapters::AccessAdapterInventoryGPU, - boundary::{BoundaryChipGPU, BoundaryFields}, + boundary::BoundaryChipGPU, merkle_tree::{MemoryMerkleTree, MERKLE_TOUCHED_BLOCK_WIDTH}, Poseidon2PeripheryChipGPU, DIGEST_WIDTH, }; @@ -26,16 +23,11 @@ use crate::{cuda_abi::inventory, system::memory::online::LinearMemory}; pub struct MemoryInventoryGPU { pub boundary: BoundaryChipGPU, - pub access_adapters: Option, - pub persistent: Option, - #[cfg(feature = "metrics")] - pub(super) unpadded_merkle_height: usize, -} - -pub struct PersistentMemoryInventoryGPU { pub merkle_tree: MemoryMerkleTree, pub initial_memory: Vec>, pub merkle_records: Option>, + #[cfg(feature = "metrics")] + pub(super) unpadded_merkle_height: usize, } #[repr(C)] @@ -62,70 +54,20 @@ impl MemoryInventoryGPU { unsafe { std::mem::transmute::(value) } } - pub fn volatile(config: MemoryConfig, range_checker: Arc) -> Self { - let addr_space_max_bits = log2_ceil_usize( - (ADDR_SPACE_OFFSET + 2u32.pow(config.addr_space_height as u32)) as usize, - ); - let access_adapters = if config.access_adapters_enabled() { - Some(AccessAdapterInventoryGPU::new( - range_checker.clone(), - config.max_access_adapter_n, - config.timestamp_max_bits, - )) - } else { - None - }; - Self { - boundary: BoundaryChipGPU::volatile( - range_checker, - addr_space_max_bits, - config.pointer_max_bits, - ), - access_adapters, - persistent: None, - #[cfg(feature = "metrics")] - unpadded_merkle_height: 0, - } - } - - pub fn persistent( - config: MemoryConfig, - range_checker: Arc, - hasher_chip: Arc, - ) -> Self { - let access_adapters = if config.access_adapters_enabled() { - Some(AccessAdapterInventoryGPU::new( - range_checker, - config.max_access_adapter_n, - config.timestamp_max_bits, - )) - } else { - None - }; + pub fn new(config: MemoryConfig, hasher_chip: Arc) -> Self { Self { - boundary: BoundaryChipGPU::persistent(hasher_chip.shared_buffer()), - access_adapters, - persistent: Some(PersistentMemoryInventoryGPU { - merkle_tree: MemoryMerkleTree::new(config.clone(), hasher_chip.clone()), - initial_memory: Vec::new(), - merkle_records: None, - }), + boundary: BoundaryChipGPU::new(hasher_chip.shared_buffer()), + merkle_tree: MemoryMerkleTree::new(config.clone(), hasher_chip.clone()), + initial_memory: Vec::new(), + merkle_records: None, #[cfg(feature = "metrics")] unpadded_merkle_height: 0, } } - pub fn continuation_enabled(&self) -> bool { - self.persistent.is_some() - } - #[instrument(name = "set_initial_memory", skip_all)] pub fn set_initial_memory(&mut self, initial_memory: &AddressMap) { let mem = MemTracker::start("set initial memory"); - let persistent = self - .persistent - .as_mut() - .expect("`set_initial_memory` requires persistent memory"); for (addr_sp, raw_mem) in initial_memory .get_memory() .iter() @@ -137,261 +79,190 @@ impl MemoryInventoryGPU { addr_sp, raw_mem.len() ); - persistent.initial_memory.push(if raw_mem.is_empty() { + self.initial_memory.push(if raw_mem.is_empty() { DeviceBuffer::new() } else { raw_mem .to_device() .expect("failed to copy memory to device") }); - persistent - .merkle_tree - .build_async(&persistent.initial_memory[addr_sp], addr_sp); - } - match &mut self.boundary.fields { - BoundaryFields::Volatile(_) => { - panic!("`set_initial_memory` requires persistent memory") - } - BoundaryFields::Persistent(fields) => { - fields.initial_leaves = persistent - .initial_memory - .iter() - .skip(1) - .map(|per_as| per_as.as_raw_ptr()) - .collect(); - } + self.merkle_tree + .build_async(&self.initial_memory[addr_sp], addr_sp); } + self.boundary.initial_leaves = self + .initial_memory + .iter() + .skip(1) + .map(|per_as| per_as.as_raw_ptr()) + .collect(); mem.emit_metrics(); } #[instrument(name = "generate_proving_ctxs", skip_all)] pub fn generate_proving_ctxs( &mut self, - access_adapter_arena: DenseRecordArena, touched_memory: TouchedMemory, ) -> Vec> { let mem = MemTracker::start("generate mem proving ctxs"); - let merkle_proof_ctx = match touched_memory { - TouchedMemory::Persistent(partition) => { - let persistent = self - .persistent - .as_mut() - .expect("persistent touched memory requires persistent memory interface"); - // Edge case for when partition is empty - if partition.is_empty() { - let leftmost_values = 'left: { - let mut res = [F::ZERO; DIGEST_WIDTH]; - if persistent.initial_memory[ADDR_SPACE_OFFSET as usize].is_empty() { - break 'left res; - } - let layout = &persistent.merkle_tree.mem_config().addr_spaces - [ADDR_SPACE_OFFSET as usize] - .layout; - let one_cell_size = layout.size(); - let mut values = vec![0u8; one_cell_size * DIGEST_WIDTH]; - unsafe { - cuda_memcpy::( - values.as_mut_ptr() as *mut std::ffi::c_void, - persistent.initial_memory[ADDR_SPACE_OFFSET as usize].as_ptr() - as *const std::ffi::c_void, - values.len(), - ) - .unwrap(); - for i in 0..DIGEST_WIDTH { - res[i] = layout.to_field::(&values[i * one_cell_size..]); - } - } - res - }; - - let values_u32 = leftmost_values.map(Self::field_to_raw_u32); - let merkle_record = MemoryMerkleRecord { - address_space: ADDR_SPACE_OFFSET, - ptr: 0, - timestamp: 0, - values: values_u32, - }; - let merkle_records = [merkle_record]; - let merkle_words: &[u32] = unsafe { - std::slice::from_raw_parts( - merkle_records.as_ptr() as *const u32, - MERKLE_TOUCHED_BLOCK_WIDTH, - ) - }; - let d_merkle_touched_memory = merkle_words.to_device().unwrap(); - - let unpadded_merkle_height = - persistent.merkle_tree.calculate_unpadded_height(&partition); - #[cfg(feature = "metrics")] - { - self.unpadded_merkle_height = unpadded_merkle_height; - } - - self.boundary - .finalize_records_persistent::(Vec::new()); - mem.tracing_info("merkle update"); - persistent.merkle_tree.finalize(); - let merkle_tree_ctx = persistent.merkle_tree.update_with_touched_blocks( - unpadded_merkle_height, - &d_merkle_touched_memory, - true, - ); - Some(merkle_tree_ctx) - } else { - // Convert MemoryInventoryRecord<4, 1> to MemoryInventoryRecord<8, 2> - let in_records: Vec> = partition - .iter() - .map(|&((addr_space, ptr), ts_values)| MemoryInventoryRecord { - address_space: addr_space, - ptr, - timestamps: [ts_values.timestamp], - values: ts_values.values.map(Self::field_to_raw_u32), - }) - .collect(); - let in_num_records = in_records.len(); - let out_words = in_num_records - * (std::mem::size_of::>() - / std::mem::size_of::()); - let d_in_records = in_records.to_device().unwrap().as_buffer::(); - let d_tmp_records = DeviceBuffer::::with_capacity(out_words); - let d_out_records = DeviceBuffer::::with_capacity(out_words); - let d_out_num_records = DeviceBuffer::::with_capacity(1); - let d_flags = DeviceBuffer::::with_capacity(in_num_records); - let d_positions = DeviceBuffer::::with_capacity(in_num_records); - let d_initial_mem = match &self.boundary.fields { - BoundaryFields::Persistent(fields) => { - fields.initial_leaves.to_device().unwrap() - } - BoundaryFields::Volatile(_) => { - panic!("`merge_records` requires persistent memory") - } - }; - let addr_space_offsets: Vec = { - let mut offsets = Vec::new(); - let mut acc = 0u32; - for addr_sp in persistent - .merkle_tree - .mem_config() - .addr_spaces - .iter() - .skip(ADDR_SPACE_OFFSET as usize) - { - offsets.push(acc); - acc = acc - .checked_add(addr_sp.layout.size() as u32) - .expect("address space offset overflow"); - } - offsets.push(acc); - offsets - }; - let d_addr_space_offsets = addr_space_offsets.to_device().unwrap(); - let mut temp_bytes = 0usize; - unsafe { - inventory::merge_records_get_temp_bytes( - &d_flags, - in_num_records, - &mut temp_bytes, - ) - .expect("merge_records_get_temp_bytes failed"); - } - let d_temp_storage = if temp_bytes == 0 { - DeviceBuffer::::new() - } else { - DeviceBuffer::::with_capacity(temp_bytes) - }; - unsafe { - inventory::merge_records( - &d_in_records, - in_num_records, - &d_initial_mem, - &d_addr_space_offsets, - &d_tmp_records, - &d_out_records, - &d_flags, - &d_positions, - &d_temp_storage, - temp_bytes, - &d_out_num_records, - ) - .expect("merge_records failed"); + let partition = touched_memory; + let merkle_proof_ctx = if partition.is_empty() { + let leftmost_values = 'left: { + let mut res = [F::ZERO; DIGEST_WIDTH]; + if self.initial_memory[ADDR_SPACE_OFFSET as usize].is_empty() { + break 'left res; + } + let layout = + &self.merkle_tree.mem_config().addr_spaces[ADDR_SPACE_OFFSET as usize].layout; + let one_cell_size = layout.size(); + let mut values = vec![0u8; one_cell_size * DIGEST_WIDTH]; + unsafe { + cuda_memcpy::( + values.as_mut_ptr() as *mut std::ffi::c_void, + self.initial_memory[ADDR_SPACE_OFFSET as usize].as_ptr() + as *const std::ffi::c_void, + values.len(), + ) + .unwrap(); + for i in 0..DIGEST_WIDTH { + res[i] = layout.to_field::(&values[i * one_cell_size..]); } + } + res + }; + + let values_u32 = leftmost_values.map(Self::field_to_raw_u32); + let merkle_record = MemoryMerkleRecord { + address_space: ADDR_SPACE_OFFSET, + ptr: 0, + timestamp: 0, + values: values_u32, + }; + let merkle_records = [merkle_record]; + let merkle_words: &[u32] = unsafe { + std::slice::from_raw_parts( + merkle_records.as_ptr() as *const u32, + MERKLE_TOUCHED_BLOCK_WIDTH, + ) + }; + let d_merkle_touched_memory = merkle_words.to_device().unwrap(); + + let unpadded_merkle_height = self.merkle_tree.calculate_unpadded_height(&partition); + #[cfg(feature = "metrics")] + { + self.unpadded_merkle_height = unpadded_merkle_height; + } - // Send records to boundary chip - let out_num_records = d_out_num_records.to_host().unwrap()[0]; - self.boundary - .finalize_records_persistent_device::( - d_out_records, - out_num_records, - ); - - // Send records to memory merkle tree - let out_records = self.boundary.persistent_records().to_host().unwrap(); - let record_words = 4 + DIGEST_WIDTH; - let mut merkle_records = Vec::with_capacity(out_num_records); - for i in 0..out_num_records { - let base = i * record_words; - let mut values = [0u32; DIGEST_WIDTH]; - values.copy_from_slice(&out_records[base + 4..base + 4 + DIGEST_WIDTH]); - let record = MemoryMerkleRecord { - address_space: out_records[base], - ptr: out_records[base + 1], - timestamp: out_records[base + 2].max(out_records[base + 3]), - values, - }; - merkle_records.push(record); - } - let merkle_words: &[u32] = unsafe { - std::slice::from_raw_parts( - merkle_records.as_ptr() as *const u32, - merkle_records.len() * MERKLE_TOUCHED_BLOCK_WIDTH, - ) - }; - persistent.merkle_records = Some(merkle_words.to_device().unwrap()); - - let unpadded_merkle_height = - persistent.merkle_tree.calculate_unpadded_height(&partition); - #[cfg(feature = "metrics")] - { - self.unpadded_merkle_height = unpadded_merkle_height; - } + self.boundary.finalize_records::(Vec::new()); + mem.tracing_info("merkle update"); + self.merkle_tree.finalize(); + self.merkle_tree.update_with_touched_blocks( + unpadded_merkle_height, + &d_merkle_touched_memory, + true, + ) + } else { + // Convert MemoryInventoryRecord<4, 1> to MemoryInventoryRecord<8, 2> + let in_records: Vec> = partition + .iter() + .map(|&((addr_space, ptr), ts_values)| MemoryInventoryRecord { + address_space: addr_space, + ptr, + timestamps: [ts_values.timestamp], + values: ts_values.values.map(Self::field_to_raw_u32), + }) + .collect(); + let in_num_records = in_records.len(); + let out_words = in_num_records + * (std::mem::size_of::>() / std::mem::size_of::()); + let d_in_records = in_records.to_device().unwrap().as_buffer::(); + let d_tmp_records = DeviceBuffer::::with_capacity(out_words); + let d_out_records = DeviceBuffer::::with_capacity(out_words); + let d_out_num_records = DeviceBuffer::::with_capacity(1); + let d_flags = DeviceBuffer::::with_capacity(in_num_records); + let d_positions = DeviceBuffer::::with_capacity(in_num_records); + let d_initial_mem = self.boundary.initial_leaves.to_device().unwrap(); + let mut temp_bytes = 0usize; + unsafe { + inventory::merge_records_get_temp_bytes(&d_flags, in_num_records, &mut temp_bytes) + .expect("merge_records_get_temp_bytes failed"); + } + let d_temp_storage = if temp_bytes == 0 { + DeviceBuffer::::new() + } else { + DeviceBuffer::::with_capacity(temp_bytes) + }; + unsafe { + inventory::merge_records( + &d_in_records, + in_num_records, + &d_initial_mem, + &d_tmp_records, + &d_out_records, + &d_flags, + &d_positions, + &d_temp_storage, + temp_bytes, + &d_out_num_records, + ) + .expect("merge_records failed"); + } - mem.tracing_info("merkle update"); - persistent.merkle_tree.finalize(); - let merkle_tree_ctx = persistent.merkle_tree.update_with_touched_blocks( - unpadded_merkle_height, - persistent - .merkle_records - .as_ref() - .expect("missing merkle records"), - false, - ); - Some(merkle_tree_ctx) - } + // Send records to boundary chip + let out_num_records = d_out_num_records.to_host().unwrap()[0]; + self.boundary + .finalize_records_device::(d_out_records, out_num_records); + + // Send records to memory merkle tree + let out_records = self.boundary.records().to_host().unwrap(); + let record_words = 4 + DIGEST_WIDTH; + let mut merkle_records = Vec::with_capacity(out_num_records); + for i in 0..out_num_records { + let base = i * record_words; + let mut values = [0u32; DIGEST_WIDTH]; + values.copy_from_slice(&out_records[base + 4..base + 4 + DIGEST_WIDTH]); + let record = MemoryMerkleRecord { + address_space: out_records[base], + ptr: out_records[base + 1], + timestamp: out_records[base + 2].max(out_records[base + 3]), + values, + }; + merkle_records.push(record); } - TouchedMemory::Volatile(partition) => { - assert!(self.persistent.is_none(), "TouchedMemory enum mismatch"); - self.boundary.finalize_records_volatile(partition); - None + let merkle_words: &[u32] = unsafe { + std::slice::from_raw_parts( + merkle_records.as_ptr() as *const u32, + merkle_records.len() * MERKLE_TOUCHED_BLOCK_WIDTH, + ) + }; + self.merkle_records = Some(merkle_words.to_device().unwrap()); + + let unpadded_merkle_height = self.merkle_tree.calculate_unpadded_height(&partition); + #[cfg(feature = "metrics")] + { + self.unpadded_merkle_height = unpadded_merkle_height; } + + mem.tracing_info("merkle update"); + self.merkle_tree.finalize(); + self.merkle_tree.update_with_touched_blocks( + unpadded_merkle_height, + self.merkle_records + .as_ref() + .expect("missing merkle records"), + false, + ) }; mem.tracing_info("boundary tracegen"); - let mut ret = vec![self.boundary.generate_proving_ctx(())]; - if let Some(merkle_proof_ctx) = merkle_proof_ctx { - ret.push(merkle_proof_ctx); - mem.tracing_info("dropping merkle tree"); - let persistent = self.persistent.as_mut().unwrap(); - persistent.merkle_tree.drop_subtrees(); - persistent.initial_memory = Vec::new(); - } - if let Some(access_adapters) = &mut self.access_adapters { - ret.extend(access_adapters.generate_air_proving_ctxs(access_adapter_arena)); - } + let ret = vec![self.boundary.generate_proving_ctx(()), merkle_proof_ctx]; + mem.tracing_info("dropping merkle tree"); + self.merkle_tree.drop_subtrees(); + self.initial_memory = Vec::new(); mem.emit_metrics(); ret } } -impl Drop for PersistentMemoryInventoryGPU { +impl Drop for MemoryInventoryGPU { fn drop(&mut self) { // WARNING: The merkle subtree events must be completed before dropping the initial memory // buffers. This prevents buffers from dropping before build_async completes. @@ -411,53 +282,23 @@ mod tests { poseidon2::Poseidon2PeripheryChip, }, }; - use openvm_circuit_primitives::var_range::{ - VariableRangeCheckerChip, VariableRangeCheckerChipGPU, - }; use openvm_cuda_backend::prelude::F; - use openvm_instructions::{ - riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, - NATIVE_AS, - }; + use openvm_instructions::riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}; use openvm_stark_backend::prover::MatrixDimensions; use super::*; - use crate::arch::testing::default_var_range_checker_bus; - #[test] fn test_empty_touched_memory_uses_full_chunk_values() { let mut addr_spaces = MemoryConfig::empty_address_space_configs(5); - for addr_space in [RV32_REGISTER_AS, RV32_MEMORY_AS, NATIVE_AS] { + for addr_space in [RV32_REGISTER_AS, RV32_MEMORY_AS] { addr_spaces[addr_space as usize].num_cells = 2 * DIGEST_WIDTH; } - let mem_config = MemoryConfig::new(2, addr_spaces, 4, 29, 17, 32); + let mem_config = MemoryConfig::new(2, addr_spaces, 4, 29, 17); let mut memory = GuestMemory::new(AddressMap::from_mem_config(&mem_config)); unsafe { memory.write::(RV32_REGISTER_AS, 0, [1, 2, 3, 4, 5, 6, 7, 8]); memory.write::(RV32_MEMORY_AS, 0, [9, 10, 11, 12]); - memory.write::( - NATIVE_AS, - 0, - [ - F::from_u32(21), - F::from_u32(22), - F::from_u32(23), - F::from_u32(24), - F::from_u32(25), - F::from_u32(26), - F::from_u32(27), - F::from_u32(28), - F::from_u32(21), - F::from_u32(22), - F::from_u32(23), - F::from_u32(24), - F::from_u32(25), - F::from_u32(26), - F::from_u32(27), - F::from_u32(28), - ], - ); } let cpu_hasher = Poseidon2PeripheryChip::new(vm_poseidon2_config(), 3); @@ -468,9 +309,6 @@ mod tests { ); let expected_root = cpu_merkle_tree.root(); - let range_checker = Arc::new(VariableRangeCheckerChipGPU::hybrid(Arc::new( - VariableRangeCheckerChip::new(default_var_range_checker_bus()), - ))); let max_buffer_size = (mem_config .addr_spaces .iter() @@ -481,14 +319,10 @@ mod tests { * 2 * DIGEST_WIDTH; let hasher_chip = Arc::new(Poseidon2PeripheryChipGPU::new(max_buffer_size, 1)); - let mut inventory = - MemoryInventoryGPU::persistent(mem_config.clone(), range_checker, hasher_chip); + let mut inventory = MemoryInventoryGPU::new(mem_config.clone(), hasher_chip); inventory.set_initial_memory(&memory.memory); - let ctxs = inventory.generate_proving_ctxs( - DenseRecordArena::with_byte_capacity(0), - TouchedMemory::Persistent(Vec::new()), - ); + let ctxs = inventory.generate_proving_ctxs(Vec::new()); let boundary_ctx = ctxs.first().expect("missing boundary ctx"); assert_eq!( boundary_ctx.common_main.height(), @@ -514,48 +348,20 @@ mod tests { #[test] fn test_touched_memory_updates_memory_address_space() { let mut addr_spaces = MemoryConfig::empty_address_space_configs(5); - for addr_space in [RV32_REGISTER_AS, RV32_MEMORY_AS, NATIVE_AS] { + for addr_space in [RV32_REGISTER_AS, RV32_MEMORY_AS] { addr_spaces[addr_space as usize].num_cells = 2 * DIGEST_WIDTH; } - let mem_config = MemoryConfig::new(2, addr_spaces, 4, 29, 17, 32); + let mem_config = MemoryConfig::new(2, addr_spaces, 4, 29, 17); let mut memory = GuestMemory::new(AddressMap::from_mem_config(&mem_config)); unsafe { memory.write::(RV32_REGISTER_AS, 0, [1, 2, 3, 4, 5, 6, 7, 8]); memory.write::(RV32_MEMORY_AS, 0, [9, 10, 11, 12]); - memory.write::( - NATIVE_AS, - 0, - [ - F::from_u32(21), - F::from_u32(22), - F::from_u32(23), - F::from_u32(24), - F::from_u32(25), - F::from_u32(26), - F::from_u32(27), - F::from_u32(28), - F::from_u32(21), - F::from_u32(22), - F::from_u32(23), - F::from_u32(24), - F::from_u32(25), - F::from_u32(26), - F::from_u32(27), - F::from_u32(28), - ], - ); } let mut final_memory = memory.clone(); let touched_bytes = [101u8, 102, 103, 104]; let touched_bytes_late = [111u8, 112, 113, 114]; - let touched_native_values = [ - F::from_u32(201), - F::from_u32(202), - F::from_u32(203), - F::from_u32(204), - ]; unsafe { final_memory.write::( RV32_MEMORY_AS, @@ -567,11 +373,6 @@ mod tests { crate::arch::CONST_BLOCK_SIZE as u32, touched_bytes_late, ); - final_memory.write::( - NATIVE_AS, - DIGEST_WIDTH as u32, - touched_native_values, - ); } let cpu_hasher = Poseidon2PeripheryChip::new(vm_poseidon2_config(), 3); @@ -582,9 +383,6 @@ mod tests { ); let expected_root = cpu_merkle_tree.root(); - let range_checker = Arc::new(VariableRangeCheckerChipGPU::hybrid(Arc::new( - VariableRangeCheckerChip::new(default_var_range_checker_bus()), - ))); let max_buffer_size = (mem_config .addr_spaces .iter() @@ -595,8 +393,7 @@ mod tests { * 2 * DIGEST_WIDTH; let hasher_chip = Arc::new(Poseidon2PeripheryChipGPU::new(max_buffer_size, 1)); - let mut inventory = - MemoryInventoryGPU::persistent(mem_config.clone(), range_checker, hasher_chip); + let mut inventory = MemoryInventoryGPU::new(mem_config.clone(), hasher_chip); inventory.set_initial_memory(&memory.memory); let touched_memory = vec![ @@ -614,18 +411,8 @@ mod tests { values: touched_bytes_late.map(F::from_u8), }, ), - ( - (NATIVE_AS, DIGEST_WIDTH as u32), - TimestampedValues { - timestamp: 2, - values: touched_native_values, - }, - ), ]; - let ctxs = inventory.generate_proving_ctxs( - DenseRecordArena::with_byte_capacity(0), - TouchedMemory::Persistent(touched_memory), - ); + let ctxs = inventory.generate_proving_ctxs(touched_memory); let boundary_ctx = ctxs.first().expect("missing boundary ctx"); assert!( boundary_ctx.common_main.height() > 0, diff --git a/crates/vm/src/system/cuda/merkle_tree/mod.rs b/crates/vm/src/system/cuda/merkle_tree/mod.rs index 037b884d93..9b0d00878d 100644 --- a/crates/vm/src/system/cuda/merkle_tree/mod.rs +++ b/crates/vm/src/system/cuda/merkle_tree/mod.rs @@ -441,7 +441,7 @@ mod tests { addr_spaces[RV32_REGISTER_AS as usize].num_cells = 32 * size_of::(); addr_spaces[RV32_MEMORY_AS as usize].num_cells = max_cells; addr_spaces[DEFERRAL_AS as usize].num_cells = max_cells; - MemoryConfig::new(2, addr_spaces, max_cells.ilog2() as usize, 29, 17, 32) + MemoryConfig::new(2, addr_spaces, max_cells.ilog2() as usize, 29, 17) }; let mut initial_memory = GuestMemory::new(AddressMap::from_mem_config(&mem_config)); diff --git a/crates/vm/src/system/cuda/mod.rs b/crates/vm/src/system/cuda/mod.rs index 65b3c5c4a7..dbe819f911 100644 --- a/crates/vm/src/system/cuda/mod.rs +++ b/crates/vm/src/system/cuda/mod.rs @@ -5,15 +5,12 @@ use memory::MemoryInventoryGPU; use openvm_circuit::{ arch::{DenseRecordArena, SystemConfig}, system::{ - connector::VmConnectorChip, - memory::{interface::MemoryInterfaceAirs, online::GuestMemory, MemoryAirInventory}, - SystemChipComplex, SystemRecords, + connector::VmConnectorChip, memory::online::GuestMemory, SystemChipComplex, SystemRecords, }, }; use openvm_circuit_primitives::{var_range::VariableRangeCheckerChipGPU, Chip}; use openvm_cuda_backend::{prelude::F, GpuBackend}; use openvm_stark_backend::prover::{AirProvingContext, CommittedTraceData}; -use openvm_stark_sdk::config::baby_bear_poseidon2::BabyBearPoseidon2Config; use poseidon2::Poseidon2PeripheryChipGPU; use program::ProgramChipGPU; @@ -21,7 +18,6 @@ use crate::system::memory::CHUNK; pub(crate) const DIGEST_WIDTH: usize = 8; -pub mod access_adapters; pub mod boundary; pub mod connector; pub mod extensions; @@ -40,9 +36,8 @@ pub struct SystemChipInventoryGPU { impl SystemChipInventoryGPU { pub fn new( config: &SystemConfig, - mem_inventory: &MemoryAirInventory, range_checker: Arc, - hasher_chip: Option>, + hasher_chip: Arc, ) -> Self { let cpu_range_checker = range_checker.cpu_chip.clone().unwrap(); @@ -54,20 +49,7 @@ impl SystemChipInventoryGPU { config.memory_config.timestamp_max_bits, )); - let memory_inventory = match &mem_inventory.interface { - MemoryInterfaceAirs::Persistent { .. } => { - assert!(config.continuation_enabled); - MemoryInventoryGPU::persistent( - config.memory_config.clone(), - range_checker.clone(), - hasher_chip.unwrap(), - ) - } - MemoryInterfaceAirs::Volatile { .. } => { - assert!(!config.continuation_enabled); - MemoryInventoryGPU::volatile(config.memory_config.clone(), range_checker.clone()) - } - }; + let memory_inventory = MemoryInventoryGPU::new(config.memory_config.clone(), hasher_chip); Self { program: program_chip, @@ -83,9 +65,7 @@ impl SystemChipComplex for SystemChipInventoryGPU } fn transport_init_memory_to_device(&mut self, memory: &GuestMemory) { - if self.memory_inventory.persistent.is_some() { - self.memory_inventory.set_initial_memory(&memory.memory); - } + self.memory_inventory.set_initial_memory(&memory.memory); } fn generate_proving_ctx( @@ -98,7 +78,6 @@ impl SystemChipComplex for SystemChipInventoryGPU to_state, exit_code, filtered_exec_frequencies, - access_adapter_records, touched_memory, } = system_records; @@ -108,9 +87,7 @@ impl SystemChipComplex for SystemChipInventoryGPU self.connector.cpu_chip.end(to_state, exit_code); let connector_ctx = self.connector.generate_proving_ctx(()); - let memory_ctxs = self - .memory_inventory - .generate_proving_ctxs(access_adapter_records, touched_memory); + let memory_ctxs = self.memory_inventory.generate_proving_ctxs(touched_memory); [program_ctx, connector_ctx] .into_iter() @@ -119,12 +96,7 @@ impl SystemChipComplex for SystemChipInventoryGPU } fn memory_top_tree(&self) -> Option<&[[F; CHUNK]]> { - self.memory_inventory - .persistent - .as_ref() - .and_then(|persistent| { - let top_tree = &persistent.merkle_tree.top_roots_host; - (!top_tree.is_empty()).then_some(top_tree.as_slice()) - }) + let top_tree = &self.memory_inventory.merkle_tree.top_roots_host; + (!top_tree.is_empty()).then_some(top_tree.as_slice()) } } diff --git a/crates/vm/src/system/memory/adapter/air.rs b/crates/vm/src/system/memory/adapter/air.rs deleted file mode 100644 index d23f510ecd..0000000000 --- a/crates/vm/src/system/memory/adapter/air.rs +++ /dev/null @@ -1,97 +0,0 @@ -use std::{borrow::Borrow, mem::size_of}; - -use openvm_circuit_primitives::{ - is_less_than::{IsLessThanIo, IsLtSubAir}, - SubAir, -}; -use openvm_stark_backend::{ - interaction::InteractionBuilder, - p3_air::{Air, AirBuilder, BaseAir}, - p3_field::PrimeCharacteristicRing, - p3_matrix::Matrix, - BaseAirWithPublicValues, PartitionedBaseAir, -}; - -use crate::system::memory::{ - adapter::columns::AccessAdapterCols, offline_checker::MemoryBus, MemoryAddress, -}; - -#[derive(Clone, Debug)] -pub struct AccessAdapterAir { - pub memory_bus: MemoryBus, - pub lt_air: IsLtSubAir, -} - -impl BaseAirWithPublicValues for AccessAdapterAir {} -impl PartitionedBaseAir for AccessAdapterAir {} -impl BaseAir for AccessAdapterAir { - fn width(&self) -> usize { - size_of::>() - } -} - -impl Air for AccessAdapterAir { - fn eval(&self, builder: &mut AB) { - let main = builder.main(); - - let local = main.row_slice(0).expect("window should have two elements"); - let local: &AccessAdapterCols = (*local).borrow(); - - builder.assert_bool(local.is_split); - builder.assert_bool(local.is_valid); - builder.assert_bool(local.is_right_larger); - - // Timestamp constraints: - // - if `is_split`, then all timestamps are equal. - // - if `is_merge`, then parent_timestamp = max(left_timestamp, right_timestamp) - - builder - .when(local.is_split) - .assert_eq(local.left_timestamp, local.right_timestamp); - - self.lt_air.eval( - builder, - ( - IsLessThanIo { - x: local.left_timestamp.into(), - y: local.right_timestamp.into(), - out: local.is_right_larger.into(), - count: local.is_valid.into(), - }, - &local.lt_aux, - ), - ); - - let parent_timestamp = local.is_right_larger * local.right_timestamp - + (AB::Expr::ONE - local.is_right_larger) * local.left_timestamp; - - // assuming valid: - // Split = 1 => direction = 1 => receive parent with count 1, send left/right with count 1 - // Split = 0 => direction = -1 => receive parent with count -1, send left/right with count - // -1 - let direction = local.is_valid * (AB::Expr::TWO * local.is_split - AB::Expr::ONE); - - self.memory_bus - .receive(local.address, local.values.to_vec(), parent_timestamp) - .eval(builder, direction.clone()); - - self.memory_bus - .send( - local.address, - local.values[..N / 2].to_vec(), - local.left_timestamp, - ) - .eval(builder, direction.clone()); - - self.memory_bus - .send( - MemoryAddress::new( - local.address.address_space, - local.address.pointer + AB::Expr::from_usize(N / 2), - ), - local.values[N / 2..].to_vec(), - local.right_timestamp, - ) - .eval(builder, direction.clone()); - } -} diff --git a/crates/vm/src/system/memory/adapter/columns.rs b/crates/vm/src/system/memory/adapter/columns.rs deleted file mode 100644 index 1a1a7e7048..0000000000 --- a/crates/vm/src/system/memory/adapter/columns.rs +++ /dev/null @@ -1,16 +0,0 @@ -use openvm_circuit_primitives_derive::AlignedBorrow; - -use crate::system::memory::{offline_checker::AUX_LEN, MemoryAddress}; - -#[repr(C)] -#[derive(Debug, AlignedBorrow)] -pub struct AccessAdapterCols { - pub is_valid: T, - pub is_split: T, - pub address: MemoryAddress, - pub values: [T; N], - pub left_timestamp: T, - pub right_timestamp: T, - pub is_right_larger: T, - pub lt_aux: [T; AUX_LEN], -} diff --git a/crates/vm/src/system/memory/adapter/mod.rs b/crates/vm/src/system/memory/adapter/mod.rs deleted file mode 100644 index 7c687b63dd..0000000000 --- a/crates/vm/src/system/memory/adapter/mod.rs +++ /dev/null @@ -1,416 +0,0 @@ -use std::{ - borrow::{Borrow, BorrowMut}, - marker::PhantomData, - ptr::copy_nonoverlapping, -}; - -pub use air::*; -pub use columns::*; -use enum_dispatch::enum_dispatch; -use getset::Setters; -use openvm_circuit_primitives::{ - is_less_than::IsLtSubAir, utils::next_power_of_two_or_zero, - var_range::SharedVariableRangeCheckerChip, TraceSubRowGenerator, -}; -use openvm_cpu_backend::CpuBackend; -use openvm_stark_backend::{ - p3_air::BaseAir, p3_field::PrimeField32, p3_matrix::dense::RowMajorMatrix, - p3_util::log2_strict_usize, prover::AirProvingContext, StarkProtocolConfig, -}; - -use crate::{ - arch::{ - AddressSpaceHostConfig, AddressSpaceHostLayout, CustomBorrow, DenseRecordArena, - MemoryCellType, MemoryConfig, SizedRecord, - }, - system::memory::{ - adapter::records::{ - arena_size_bound, AccessLayout, AccessRecordHeader, AccessRecordMut, - MERGE_AND_NOT_SPLIT_FLAG, - }, - offline_checker::MemoryBus, - MemoryAddress, - }, -}; - -mod air; -mod columns; -pub mod records; - -#[derive(Setters)] -pub struct AccessAdapterInventory { - pub(super) memory_config: MemoryConfig, - chips: Vec>, - #[getset(set = "pub")] - arena: DenseRecordArena, - #[cfg(feature = "metrics")] - pub(crate) trace_heights: Vec, -} - -impl AccessAdapterInventory { - pub fn new( - range_checker: SharedVariableRangeCheckerChip, - memory_bus: MemoryBus, - memory_config: MemoryConfig, - ) -> Self { - // Only create adapter chips if access adapters are enabled - let chips: Vec<_> = if memory_config.access_adapters_enabled() { - let rc = range_checker; - let mb = memory_bus; - let tmb = memory_config.timestamp_max_bits; - let maan = memory_config.max_access_adapter_n; - assert!(matches!(maan, 2 | 4 | 8 | 16 | 32)); - [ - Self::create_access_adapter_chip::<2>(rc.clone(), mb, tmb, maan), - Self::create_access_adapter_chip::<4>(rc.clone(), mb, tmb, maan), - Self::create_access_adapter_chip::<8>(rc.clone(), mb, tmb, maan), - Self::create_access_adapter_chip::<16>(rc.clone(), mb, tmb, maan), - Self::create_access_adapter_chip::<32>(rc.clone(), mb, tmb, maan), - ] - .into_iter() - .flatten() - .collect() - } else { - Vec::new() - }; - Self { - memory_config, - chips, - arena: DenseRecordArena::with_byte_capacity(0), - #[cfg(feature = "metrics")] - trace_heights: Vec::new(), - } - } - - pub fn num_access_adapters(&self) -> usize { - self.chips.len() - } - - pub(super) fn set_override_trace_heights(&mut self, overridden_heights: Vec) { - self.set_arena_from_trace_heights( - &overridden_heights - .iter() - .map(|&h| h as u32) - .collect::>(), - ); - for (chip, oh) in self.chips.iter_mut().zip(overridden_heights) { - chip.set_override_trace_height(oh); - } - } - - pub(super) fn set_arena_from_trace_heights(&mut self, trace_heights: &[u32]) { - assert_eq!(trace_heights.len(), self.chips.len()); - let size_bound = arena_size_bound(trace_heights); - tracing::debug!( - "Allocating {} bytes for memory adapters arena from heights {:?}", - size_bound, - trace_heights - ); - self.arena.set_byte_capacity(size_bound); - } - - pub fn get_widths(&self) -> Vec { - self.chips - .iter() - .map(|chip: &GenericAccessAdapterChip| chip.trace_width()) - .collect() - } - - /// `heights` should have length equal to the number of access adapter chips. - pub(crate) fn compute_heights_from_arena(arena: &DenseRecordArena, heights: &mut [usize]) { - let bytes = arena.allocated(); - tracing::debug!( - "Computing heights from memory adapters arena: used {} bytes", - bytes.len() - ); - let mut ptr = 0; - while ptr < bytes.len() { - let bytes_slice = &bytes[ptr..]; - let header: &AccessRecordHeader = bytes_slice.borrow(); - // SAFETY: - // - bytes[ptr..] is a valid starting pointer to a previously allocated record - // - The record contains self-describing layout information - let layout: AccessLayout = unsafe { bytes_slice.extract_layout() }; - ptr += as SizedRecord>::size(&layout); - - let log_max_block_size = log2_strict_usize(header.block_size as usize); - for (i, h) in heights - .iter_mut() - .enumerate() - .take(log_max_block_size) - .skip(log2_strict_usize(header.lowest_block_size as usize)) - { - *h += 1 << (log_max_block_size - i - 1); - } - } - tracing::debug!("Computed heights from memory adapters arena: {:?}", heights); - } - - fn apply_overridden_heights(&mut self, heights: &mut [usize]) { - for (i, h) in heights.iter_mut().enumerate() { - if let Some(oh) = self.chips[i].overridden_trace_height() { - assert!( - oh >= *h, - "Overridden height {oh} is less than the required height {}", - *h - ); - *h = oh; - } - *h = next_power_of_two_or_zero(*h); - } - } - - pub fn generate_proving_ctx(&mut self) -> Vec>> - where - F: PrimeField32, - SC: StarkProtocolConfig, - { - let num_adapters = self.chips.len(); - - let mut heights = vec![0; num_adapters]; - Self::compute_heights_from_arena(&self.arena, &mut heights); - self.apply_overridden_heights(&mut heights); - - let widths = self - .chips - .iter() - .map(|chip| chip.trace_width()) - .collect::>(); - let mut traces = widths - .iter() - .zip(heights.iter()) - .map(|(&width, &height)| RowMajorMatrix::new(vec![F::ZERO; width * height], width)) - .collect::>(); - #[cfg(feature = "metrics")] - { - self.trace_heights = heights; - } - - let mut trace_ptrs = vec![0; num_adapters]; - - let bytes = self.arena.allocated_mut(); - let mut ptr = 0; - while ptr < bytes.len() { - let bytes_slice = &mut bytes[ptr..]; - // SAFETY: - // - bytes[ptr..] is a valid starting pointer to a previously allocated record - // - The record contains self-describing layout information - let layout: AccessLayout = unsafe { bytes_slice.extract_layout() }; - let record: AccessRecordMut<'_> = bytes_slice.custom_borrow(layout.clone()); - ptr += as SizedRecord>::size(&layout); - - let log_min_block_size = log2_strict_usize(record.header.lowest_block_size as usize); - let log_max_block_size = log2_strict_usize(record.header.block_size as usize); - - if record.header.timestamp_and_mask & MERGE_AND_NOT_SPLIT_FLAG != 0 { - for i in log_min_block_size..log_max_block_size { - let data_len = layout.type_size << i; - let ts_len = 1 << (i - log_min_block_size); - for j in 0..record.data.len() / (2 * data_len) { - let row_slice = - &mut traces[i].values[trace_ptrs[i]..trace_ptrs[i] + widths[i]]; - trace_ptrs[i] += widths[i]; - self.chips[i].fill_trace_row( - &self.memory_config.addr_spaces, - row_slice, - false, - MemoryAddress::new( - record.header.address_space, - record.header.pointer + (j << (i + 1)) as u32, - ), - &record.data[j * 2 * data_len..(j + 1) * 2 * data_len], - *record.timestamps[2 * j * ts_len..(2 * j + 1) * ts_len] - .iter() - .max() - .unwrap(), - *record.timestamps[(2 * j + 1) * ts_len..(2 * j + 2) * ts_len] - .iter() - .max() - .unwrap(), - ); - } - } - } else { - let timestamp = record.header.timestamp_and_mask; - for i in log_min_block_size..log_max_block_size { - let data_len = layout.type_size << i; - for j in 0..record.data.len() / (2 * data_len) { - let row_slice = - &mut traces[i].values[trace_ptrs[i]..trace_ptrs[i] + widths[i]]; - trace_ptrs[i] += widths[i]; - self.chips[i].fill_trace_row( - &self.memory_config.addr_spaces, - row_slice, - true, - MemoryAddress::new( - record.header.address_space, - record.header.pointer + (j << (i + 1)) as u32, - ), - &record.data[j * 2 * data_len..(j + 1) * 2 * data_len], - timestamp, - timestamp, - ); - } - } - } - } - traces - .into_iter() - .map(AirProvingContext::simple_no_pis) - .collect() - } - - fn create_access_adapter_chip( - range_checker: SharedVariableRangeCheckerChip, - memory_bus: MemoryBus, - timestamp_max_bits: usize, - max_access_adapter_n: usize, - ) -> Option> - where - F: Clone + Send + Sync, - { - if N <= max_access_adapter_n { - Some(GenericAccessAdapterChip::new::( - range_checker, - memory_bus, - timestamp_max_bits, - )) - } else { - None - } - } -} - -#[enum_dispatch] -pub(crate) trait GenericAccessAdapterChipTrait { - fn trace_width(&self) -> usize; - fn set_override_trace_height(&mut self, overridden_height: usize); - fn overridden_trace_height(&self) -> Option; - - #[allow(clippy::too_many_arguments)] - fn fill_trace_row( - &self, - addr_spaces: &[AddressSpaceHostConfig], - row: &mut [F], - is_split: bool, - address: MemoryAddress, - values: &[u8], - left_timestamp: u32, - right_timestamp: u32, - ) where - F: PrimeField32; -} - -#[enum_dispatch(GenericAccessAdapterChipTrait)] -enum GenericAccessAdapterChip { - N2(AccessAdapterChip), - N4(AccessAdapterChip), - N8(AccessAdapterChip), - N16(AccessAdapterChip), - N32(AccessAdapterChip), -} - -impl GenericAccessAdapterChip { - fn new( - range_checker: SharedVariableRangeCheckerChip, - memory_bus: MemoryBus, - timestamp_max_bits: usize, - ) -> Self { - let rc = range_checker; - let mb = memory_bus; - let cmb = timestamp_max_bits; - match N { - 2 => GenericAccessAdapterChip::N2(AccessAdapterChip::new(rc, mb, cmb)), - 4 => GenericAccessAdapterChip::N4(AccessAdapterChip::new(rc, mb, cmb)), - 8 => GenericAccessAdapterChip::N8(AccessAdapterChip::new(rc, mb, cmb)), - 16 => GenericAccessAdapterChip::N16(AccessAdapterChip::new(rc, mb, cmb)), - 32 => GenericAccessAdapterChip::N32(AccessAdapterChip::new(rc, mb, cmb)), - _ => panic!("Only supports N in (2, 4, 8, 16, 32)"), - } - } -} - -pub(crate) struct AccessAdapterChip { - air: AccessAdapterAir, - range_checker: SharedVariableRangeCheckerChip, - overridden_height: Option, - _marker: PhantomData, -} - -impl AccessAdapterChip { - pub fn new( - range_checker: SharedVariableRangeCheckerChip, - memory_bus: MemoryBus, - timestamp_max_bits: usize, - ) -> Self { - let lt_air = IsLtSubAir::new(range_checker.bus(), timestamp_max_bits); - Self { - air: AccessAdapterAir:: { memory_bus, lt_air }, - range_checker, - overridden_height: None, - _marker: PhantomData, - } - } -} -impl GenericAccessAdapterChipTrait for AccessAdapterChip { - fn trace_width(&self) -> usize { - BaseAir::::width(&self.air) - } - - fn set_override_trace_height(&mut self, overridden_height: usize) { - self.overridden_height = Some(overridden_height); - } - - fn overridden_trace_height(&self) -> Option { - self.overridden_height - } - - fn fill_trace_row( - &self, - addr_spaces: &[AddressSpaceHostConfig], - row: &mut [F], - is_split: bool, - address: MemoryAddress, - values: &[u8], - left_timestamp: u32, - right_timestamp: u32, - ) where - F: PrimeField32, - { - let row: &mut AccessAdapterCols = row.borrow_mut(); - row.is_valid = F::ONE; - row.is_split = F::from_bool(is_split); - row.address = MemoryAddress::new( - F::from_u32(address.address_space), - F::from_u32(address.pointer), - ); - let addr_space_layout = addr_spaces[address.address_space as usize].layout; - // SAFETY: values will be a slice of the cell type - unsafe { - match addr_space_layout { - MemoryCellType::F { .. } => { - copy_nonoverlapping( - values.as_ptr(), - row.values.as_mut_ptr() as *mut u8, - N * size_of::(), - ); - } - _ => { - for (dst, src) in row - .values - .iter_mut() - .zip(values.chunks_exact(addr_space_layout.size())) - { - *dst = addr_space_layout.to_field(src); - } - } - } - } - row.left_timestamp = F::from_u32(left_timestamp); - row.right_timestamp = F::from_u32(right_timestamp); - self.air.lt_air.generate_subrow( - (self.range_checker.as_ref(), left_timestamp, right_timestamp), - (&mut row.lt_aux, &mut row.is_right_larger), - ); - } -} diff --git a/crates/vm/src/system/memory/adapter/records.rs b/crates/vm/src/system/memory/adapter/records.rs deleted file mode 100644 index 8e919dd294..0000000000 --- a/crates/vm/src/system/memory/adapter/records.rs +++ /dev/null @@ -1,150 +0,0 @@ -use std::{ - borrow::{Borrow, BorrowMut}, - mem::{align_of, size_of}, -}; - -use openvm_circuit_primitives::AlignedBytesBorrow; - -use crate::arch::{CustomBorrow, DenseRecordArena, RecordArena, SizedRecord}; - -#[repr(C)] -#[derive(Debug, Clone, Copy, AlignedBytesBorrow, PartialEq, Eq, PartialOrd, Ord)] -pub struct AccessRecordHeader { - /// Iff we need to merge before, this has the `MERGE_AND_NOT_SPLIT_FLAG` bit set - pub timestamp_and_mask: u32, - pub address_space: u32, - pub pointer: u32, - // PERF: these three are easily mergeable into a single u32 - pub block_size: u32, - pub lowest_block_size: u32, - pub type_size: u32, -} - -#[repr(C)] -#[derive(Debug)] -pub struct AccessRecordMut<'a> { - pub header: &'a mut AccessRecordHeader, - // PERF(AG): optimize with some `Option` serialization stuff - pub timestamps: &'a mut [u32], // len is block_size / lowest_block_size - pub data: &'a mut [u8], // len is block_size * type_size -} - -#[derive(Debug, Clone)] -pub struct AccessLayout { - /// The size of the block in elements. - pub block_size: usize, - /// The size of the minimal block we may split into/merge from (usually 1 or 4) - pub lowest_block_size: usize, - /// The size of the type in bytes (1 for u8, 4 for F). - pub type_size: usize, -} - -impl AccessLayout { - pub(crate) fn from_record_header(header: &AccessRecordHeader) -> Self { - Self { - block_size: header.block_size as usize, - lowest_block_size: header.lowest_block_size as usize, - type_size: header.type_size as usize, - } - } -} - -pub(crate) const MERGE_AND_NOT_SPLIT_FLAG: u32 = 1 << 31; - -pub(crate) fn size_by_layout(layout: &AccessLayout) -> usize { - size_of::() // header struct - + (layout.block_size / layout.lowest_block_size) * size_of::() // timestamps - + (layout.block_size * layout.type_size).next_multiple_of(4) // data -} - -impl SizedRecord for AccessRecordMut<'_> { - fn size(layout: &AccessLayout) -> usize { - size_by_layout(layout) - } - - fn alignment(_: &AccessLayout) -> usize { - align_of::() - } -} - -impl<'a> CustomBorrow<'a, AccessRecordMut<'a>, AccessLayout> for [u8] { - fn custom_borrow(&'a mut self, layout: AccessLayout) -> AccessRecordMut<'a> { - // header: AccessRecordHeader - // SAFETY: self.len() >= size_of::() from size_by_layout() - let (header_buf, rest) = - unsafe { self.split_at_mut_unchecked(size_of::()) }; - let header = header_buf.borrow_mut(); - - let mut offset = 0; - - // timestamps: [u32] (block_size / cell_size * 4 bytes) - // SAFETY: - // - size: (layout.block_size / layout.lowest_block_size) * size_of::() from - // size_by_layout() - // - alignment: u32 aligned due to AccessRecordHeader alignment - let timestamps = unsafe { - std::slice::from_raw_parts_mut( - rest.as_mut_ptr().add(offset) as *mut u32, - layout.block_size / layout.lowest_block_size, - ) - }; - offset += layout.block_size / layout.lowest_block_size * size_of::(); - - // data: [u8] (block_size * type_size bytes) - // SAFETY: - // - size: layout.block_size * layout.type_size from size_by_layout() - // - offset points past timestamps section - let data = unsafe { - std::slice::from_raw_parts_mut( - rest.as_mut_ptr().add(offset), - layout.block_size * layout.type_size, - ) - }; - - AccessRecordMut { - header, - data, - timestamps, - } - } - - unsafe fn extract_layout(&self) -> AccessLayout { - let header: &AccessRecordHeader = self.borrow(); - AccessLayout { - block_size: header.block_size as usize, - lowest_block_size: header.lowest_block_size as usize, - type_size: header.type_size as usize, - } - } -} - -impl<'a> RecordArena<'a, AccessLayout, AccessRecordMut<'a>> for DenseRecordArena { - fn alloc(&'a mut self, layout: AccessLayout) -> AccessRecordMut<'a> { - let bytes = self.alloc_bytes( as SizedRecord>::size( - &layout, - )); - <[u8] as CustomBorrow, AccessLayout>>::custom_borrow(bytes, layout) - } -} - -/// `trace_heights[i]` is assumed to correspond to `Adapter< 2^(i+1) >`. -pub fn arena_size_bound(trace_heights: &[u32]) -> usize { - // At the very worst, each row in `Adapter` - // corresponds to a unique record of `block_size` being `2 * N`, - // and its `lowest_block_size` is at least 1 and `type_size` is at most 4. - let size_bound = trace_heights - .iter() - .enumerate() - .map(|(i, &h)| { - size_by_layout(&AccessLayout { - block_size: 1 << (i + 1), - lowest_block_size: 1, - type_size: 4, - }) * h as usize - }) - .sum::(); - tracing::debug!( - "Allocating {size_bound} bytes for memory adapters arena from heights {trace_heights:?}" - ); - size_bound -} diff --git a/crates/vm/src/system/memory/controller/interface.rs b/crates/vm/src/system/memory/controller/interface.rs index ff0a0b64a9..4a2b17b639 100644 --- a/crates/vm/src/system/memory/controller/interface.rs +++ b/crates/vm/src/system/memory/controller/interface.rs @@ -3,40 +3,23 @@ use openvm_stark_backend::{interaction::PermutationCheckBus, p3_field::PrimeFiel use crate::system::memory::{ merkle::{MemoryMerkleAir, MemoryMerkleChip}, persistent::{PersistentBoundaryAir, PersistentBoundaryChip}, - volatile::{VolatileBoundaryAir, VolatileBoundaryChip}, MemoryImage, CHUNK, }; #[derive(Clone)] -pub enum MemoryInterfaceAirs { - Volatile { - boundary: VolatileBoundaryAir, - }, - Persistent { - boundary: PersistentBoundaryAir, - merkle: MemoryMerkleAir, - }, +pub struct MemoryInterfaceAirs { + pub boundary: PersistentBoundaryAir, + pub merkle: MemoryMerkleAir, } -#[allow(clippy::large_enum_variant)] -pub enum MemoryInterface { - Volatile { - boundary_chip: VolatileBoundaryChip, - }, - Persistent { - boundary_chip: PersistentBoundaryChip, - merkle_chip: MemoryMerkleChip, - initial_memory: MemoryImage, - }, +pub struct MemoryInterface { + pub boundary_chip: PersistentBoundaryChip, + pub merkle_chip: MemoryMerkleChip, + pub initial_memory: MemoryImage, } impl MemoryInterface { - pub fn compression_bus(&self) -> Option { - match self { - MemoryInterface::Volatile { .. } => None, - MemoryInterface::Persistent { merkle_chip, .. } => { - Some(merkle_chip.air.compression_bus) - } - } + pub fn compression_bus(&self) -> PermutationCheckBus { + self.merkle_chip.air.compression_bus } } diff --git a/crates/vm/src/system/memory/controller/mod.rs b/crates/vm/src/system/memory/controller/mod.rs index e971d082f4..f7958e1cea 100644 --- a/crates/vm/src/system/memory/controller/mod.rs +++ b/crates/vm/src/system/memory/controller/mod.rs @@ -13,19 +13,18 @@ use openvm_cpu_backend::CpuBackend; use openvm_stark_backend::{ interaction::PermutationCheckBus, p3_field::PrimeField32, - p3_util::{log2_ceil_usize, log2_strict_usize}, + p3_util::log2_strict_usize, prover::AirProvingContext, StarkProtocolConfig, }; use serde::{Deserialize, Serialize}; use self::interface::MemoryInterface; -use super::{volatile::VolatileBoundaryChip, AddressMap}; +use super::AddressMap; use crate::{ - arch::{DenseRecordArena, MemoryConfig, VmField, ADDR_SPACE_OFFSET, CONST_BLOCK_SIZE}, + arch::{MemoryConfig, VmField, CONST_BLOCK_SIZE}, system::{ memory::{ - adapter::AccessAdapterInventory, dimensions::MemoryDimensions, merkle::MemoryMerkleChip, offline_checker::{MemoryBaseAuxCols, MemoryBridge, MemoryBus, AUX_LEN}, @@ -74,93 +73,28 @@ pub struct MemoryController { pub memory_bus: MemoryBus, pub interface_chip: MemoryInterface, pub range_checker: SharedVariableRangeCheckerChip, + pub(crate) memory_config: MemoryConfig, // Store separately to avoid smart pointer reference each time range_checker_bus: VariableRangeCheckerBus, - pub(crate) access_adapter_inventory: AccessAdapterInventory, pub(crate) hasher_chip: Option>>, } -#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] -pub struct VolatileMemoryTraceHeights { - pub boundary: usize, - pub access_adapters: Vec, -} - -impl VolatileMemoryTraceHeights { - /// `heights` must consist of only memory trace heights, in order of AIR IDs. - pub fn from_slice(heights: &[u32]) -> Self { - let boundary = heights[0] as usize; - let access_adapters = heights[1..].iter().map(|&h| h as usize).collect(); - Self { - boundary, - access_adapters, - } - } -} - #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] pub struct PersistentMemoryTraceHeights { boundary: usize, merkle: usize, - access_adapters: Vec, } impl PersistentMemoryTraceHeights { /// `heights` must consist of only memory trace heights, in order of AIR IDs. pub fn from_slice(heights: &[u32]) -> Self { - let boundary = heights[0] as usize; - let merkle = heights[1] as usize; - let access_adapters = heights[2..].iter().map(|&h| h as usize).collect(); Self { - boundary, - merkle, - access_adapters, + boundary: heights[0] as usize, + merkle: heights[1] as usize, } } } impl MemoryController { - pub(crate) fn continuation_enabled(&self) -> bool { - match &self.interface_chip { - MemoryInterface::Volatile { .. } => false, - MemoryInterface::Persistent { .. } => true, - } - } - pub fn with_volatile_memory( - memory_bus: MemoryBus, - mem_config: MemoryConfig, - range_checker: SharedVariableRangeCheckerChip, - ) -> Self { - let range_checker_bus = range_checker.bus(); - assert!(mem_config.pointer_max_bits <= F::bits() - 2); - assert!(mem_config - .addr_spaces - .iter() - .all(|&space| space.num_cells <= (1 << mem_config.pointer_max_bits))); - assert!(mem_config.addr_space_height < F::bits() - 2); - let addr_space_max_bits = log2_ceil_usize( - (ADDR_SPACE_OFFSET + 2u32.pow(mem_config.addr_space_height as u32)) as usize, - ); - Self { - memory_bus, - interface_chip: MemoryInterface::Volatile { - boundary_chip: VolatileBoundaryChip::new( - memory_bus, - addr_space_max_bits, - mem_config.pointer_max_bits, - range_checker.clone(), - ), - }, - access_adapter_inventory: AccessAdapterInventory::new( - range_checker.clone(), - memory_bus, - mem_config, - ), - range_checker, - range_checker_bus, - hasher_chip: None, - } - } - /// Creates a new memory controller for persistent memory. /// /// Call `set_initial_memory` to set the initial memory state after construction. @@ -177,7 +111,7 @@ impl MemoryController { address_height: mem_config.pointer_max_bits - log2_strict_usize(CHUNK), }; let range_checker_bus = range_checker.bus(); - let interface_chip = MemoryInterface::Persistent { + let interface_chip = MemoryInterface { boundary_chip: PersistentBoundaryChip::new( memory_dims, memory_bus, @@ -190,11 +124,7 @@ impl MemoryController { Self { memory_bus, interface_chip, - access_adapter_inventory: AccessAdapterInventory::new( - range_checker.clone(), - memory_bus, - mem_config, - ), + memory_config: mem_config, range_checker, range_checker_bus, hasher_chip: Some(hasher_chip), @@ -202,42 +132,23 @@ impl MemoryController { } pub fn memory_config(&self) -> &MemoryConfig { - &self.access_adapter_inventory.memory_config + &self.memory_config } pub(crate) fn set_override_trace_heights(&mut self, overridden_heights: &[u32]) { - match &mut self.interface_chip { - MemoryInterface::Volatile { boundary_chip } => { - let oh = VolatileMemoryTraceHeights::from_slice(overridden_heights); - boundary_chip.set_overridden_height(oh.boundary); - self.access_adapter_inventory - .set_override_trace_heights(oh.access_adapters); - } - MemoryInterface::Persistent { - boundary_chip, - merkle_chip, - .. - } => { - let oh = PersistentMemoryTraceHeights::from_slice(overridden_heights); - boundary_chip.set_overridden_height(oh.boundary); - merkle_chip.set_overridden_height(oh.merkle); - self.access_adapter_inventory - .set_override_trace_heights(oh.access_adapters); - } - } + let oh = PersistentMemoryTraceHeights::from_slice(overridden_heights); + self.interface_chip + .boundary_chip + .set_overridden_height(oh.boundary); + self.interface_chip + .merkle_chip + .set_overridden_height(oh.merkle); } - /// This only sets the initial memory image for the persistent boundary and merkle tree chips. + /// This only sets the initial memory image for the boundary and merkle tree chips. /// Tracing memory should be set separately. pub(crate) fn set_initial_memory(&mut self, memory: AddressMap) { - match &mut self.interface_chip { - MemoryInterface::Volatile { .. } => { - // Skip initialization for volatile memory - } - MemoryInterface::Persistent { initial_memory, .. } => { - *initial_memory = memory; - } - } + self.interface_chip.initial_memory = memory; } pub fn memory_bridge(&self) -> MemoryBridge { @@ -266,86 +177,51 @@ impl MemoryController { // _somehow_. pub fn generate_proving_ctx>( &mut self, - access_adapter_records: DenseRecordArena, touched_memory: TouchedMemory, ) -> Vec>> { - match (&mut self.interface_chip, touched_memory) { - ( - MemoryInterface::Volatile { boundary_chip }, - TouchedMemory::Volatile(final_memory), - ) => { - boundary_chip.finalize(final_memory); - } - ( - MemoryInterface::Persistent { - boundary_chip, - merkle_chip, - initial_memory, - }, - TouchedMemory::Persistent(final_memory), - ) => { - let hasher = self.hasher_chip.as_ref().unwrap(); - boundary_chip.finalize(initial_memory, &final_memory, hasher.as_ref()); - - // Rechunk CONST_BLOCK_SIZE blocks into CHUNK-sized blocks for merkle_chip - // Note: Equipartition key is (addr_space, ptr) where ptr is the starting pointer - let final_memory_values: Equipartition = { - use std::collections::BTreeMap; - let mut chunk_map: BTreeMap<(u32, u32), [F; CHUNK]> = BTreeMap::new(); - for ((addr_space, ptr), ts_values) in final_memory.into_iter() { - // Align to CHUNK boundary to get the chunk's starting pointer - let chunk_ptr = (ptr / CHUNK as u32) * CHUNK as u32; - let block_idx_in_chunk = - ((ptr % CHUNK as u32) / CONST_BLOCK_SIZE as u32) as usize; - let entry = chunk_map.entry((addr_space, chunk_ptr)).or_insert_with(|| { - // Initialize with values from initial memory - std::array::from_fn(|i| unsafe { - initial_memory.get_f::(addr_space, chunk_ptr + i as u32) - }) - }); - // Copy values for this block - for (i, val) in ts_values.values.into_iter().enumerate() { - entry[block_idx_in_chunk * CONST_BLOCK_SIZE + i] = val; - } - } - chunk_map - }; - merkle_chip.finalize(initial_memory, &final_memory_values, hasher.as_ref()); + let final_memory = touched_memory; + let MemoryInterface { + boundary_chip, + merkle_chip, + initial_memory, + } = &mut self.interface_chip; + + let hasher = self.hasher_chip.as_ref().unwrap(); + boundary_chip.finalize(initial_memory, &final_memory, hasher.as_ref()); + + // Rechunk CONST_BLOCK_SIZE blocks into CHUNK-sized blocks for merkle_chip + // Note: Equipartition key is (addr_space, ptr) where ptr is the starting pointer + let final_memory_values: Equipartition = { + use std::collections::BTreeMap; + let mut chunk_map: BTreeMap<(u32, u32), [F; CHUNK]> = BTreeMap::new(); + for ((addr_space, ptr), ts_values) in final_memory { + // Align to CHUNK boundary to get the chunk's starting pointer + let chunk_ptr = (ptr / CHUNK as u32) * CHUNK as u32; + let block_idx_in_chunk = ((ptr % CHUNK as u32) / CONST_BLOCK_SIZE as u32) as usize; + let entry = chunk_map.entry((addr_space, chunk_ptr)).or_insert_with(|| { + // Initialize with values from initial memory + std::array::from_fn(|i| unsafe { + initial_memory.get_f::(addr_space, chunk_ptr + i as u32) + }) + }); + // Copy values for this block + for (i, val) in ts_values.values.into_iter().enumerate() { + entry[block_idx_in_chunk * CONST_BLOCK_SIZE + i] = val; + } } - _ => panic!("TouchedMemory incorrect type"), - } - - let mut ret = Vec::new(); + chunk_map + }; + merkle_chip.finalize(initial_memory, &final_memory_values, hasher.as_ref()); - let access_adapters = &mut self.access_adapter_inventory; - access_adapters.set_arena(access_adapter_records); - match &mut self.interface_chip { - MemoryInterface::Volatile { boundary_chip } => { - ret.push(boundary_chip.generate_proving_ctx(())); - } - MemoryInterface::Persistent { - merkle_chip, - boundary_chip, - .. - } => { - debug_assert_eq!(ret.len(), BOUNDARY_AIR_OFFSET); - ret.push(boundary_chip.generate_proving_ctx(())); - debug_assert_eq!(ret.len(), MERKLE_AIR_OFFSET); - ret.push(merkle_chip.generate_proving_ctx()); - } - } - ret.extend(access_adapters.generate_proving_ctx()); - ret + vec![ + boundary_chip.generate_proving_ctx(()), + merkle_chip.generate_proving_ctx(), + ] } /// Return the number of AIRs in the memory controller. pub fn num_airs(&self) -> usize { - let mut num_airs = 1; - if self.continuation_enabled() { - num_airs += 1; - } - num_airs += self.access_adapter_inventory.num_access_adapters(); - num_airs + 2 } } diff --git a/crates/vm/src/system/memory/merkle/public_values.rs b/crates/vm/src/system/memory/merkle/public_values.rs index 0965dacf48..0edd43779a 100644 --- a/crates/vm/src/system/memory/merkle/public_values.rs +++ b/crates/vm/src/system/memory/merkle/public_values.rs @@ -243,7 +243,7 @@ mod tests { type F = BabyBear; #[test] fn test_public_value_happy_path() { - let mut vm_config = SystemConfig::default().without_continuations(); + let mut vm_config = SystemConfig::default(); let addr_space_height = 4; vm_config.memory_config.addr_space_height = addr_space_height; vm_config.memory_config.pointer_max_bits = 5; diff --git a/crates/vm/src/system/memory/merkle/tests/mod.rs b/crates/vm/src/system/memory/merkle/tests/mod.rs index d59c26146b..cb0b384977 100644 --- a/crates/vm/src/system/memory/merkle/tests/mod.rs +++ b/crates/vm/src/system/memory/merkle/tests/mod.rs @@ -208,7 +208,6 @@ fn random_test( height + 3, 20, 17, - 32, ); let mut initial_memory = GuestMemory::new(AddressMap::from_mem_config(&mem_config)); @@ -301,7 +300,6 @@ fn expand_test_no_accesses() { height + 3, 20, 17, - 32, ); let md = mem_config.memory_dimensions(); @@ -350,7 +348,6 @@ fn expand_test_negative() { height + 3, 20, 17, - 32, ); let md = mem_config.memory_dimensions(); diff --git a/crates/vm/src/system/memory/mod.rs b/crates/vm/src/system/memory/mod.rs index 82ec3b99e8..ad651eab9a 100644 --- a/crates/vm/src/system/memory/mod.rs +++ b/crates/vm/src/system/memory/mod.rs @@ -1,15 +1,10 @@ use std::sync::Arc; -use openvm_circuit_primitives::{is_less_than::IsLtSubAir, var_range::VariableRangeCheckerBus}; use openvm_circuit_primitives_derive::AlignedBorrow; use openvm_stark_backend::{ - interaction::PermutationCheckBus, - p3_field::Field, - p3_util::{log2_ceil_usize, log2_strict_usize}, - AirRef, StarkProtocolConfig, Val, + interaction::PermutationCheckBus, p3_util::log2_strict_usize, AirRef, StarkProtocolConfig, }; -pub mod adapter; mod controller; pub mod merkle; pub mod offline_checker; @@ -17,17 +12,15 @@ pub mod online; pub mod persistent; #[cfg(test)] mod tests; -pub mod volatile; pub use controller::*; pub use online::{Address, AddressMap, INITIAL_TIMESTAMP}; use crate::{ - arch::{MemoryConfig, ADDR_SPACE_OFFSET}, + arch::MemoryConfig, system::memory::{ - adapter::AccessAdapterAir, dimensions::MemoryDimensions, interface::MemoryInterfaceAirs, - merkle::MemoryMerkleAir, offline_checker::MemoryBridge, persistent::PersistentBoundaryAir, - volatile::VolatileBoundaryAir, + dimensions::MemoryDimensions, interface::MemoryInterfaceAirs, merkle::MemoryMerkleAir, + offline_checker::MemoryBridge, persistent::PersistentBoundaryAir, }, }; @@ -71,98 +64,50 @@ impl MemoryAddress { } #[derive(Clone)] -pub struct MemoryAirInventory { +pub struct MemoryAirInventory { pub bridge: MemoryBridge, pub interface: MemoryInterfaceAirs, - pub access_adapters: Vec>, } -impl MemoryAirInventory { +impl MemoryAirInventory { pub fn new( bridge: MemoryBridge, mem_config: &MemoryConfig, - range_bus: VariableRangeCheckerBus, - merkle_compression_buses: Option<(PermutationCheckBus, PermutationCheckBus)>, + merkle_bus: PermutationCheckBus, + compression_bus: PermutationCheckBus, ) -> Self { let memory_bus = bridge.memory_bus(); - let interface = if let Some((merkle_bus, compression_bus)) = merkle_compression_buses { - // Persistent memory - let memory_dims = MemoryDimensions { - addr_space_height: mem_config.addr_space_height, - address_height: mem_config.pointer_max_bits - log2_strict_usize(CHUNK), - }; - let boundary = PersistentBoundaryAir:: { - memory_dims, - memory_bus, - merkle_bus, - compression_bus, - }; - let merkle = MemoryMerkleAir:: { - memory_dimensions: memory_dims, - merkle_bus, - compression_bus, - }; - MemoryInterfaceAirs::Persistent { boundary, merkle } - } else { - // Volatile memory - let addr_space_height = mem_config.addr_space_height; - assert!(addr_space_height < Val::::bits() - 2); - let addr_space_max_bits = - log2_ceil_usize((ADDR_SPACE_OFFSET + 2u32.pow(addr_space_height as u32)) as usize); - let boundary = VolatileBoundaryAir::new( - memory_bus, - addr_space_max_bits, - mem_config.pointer_max_bits, - range_bus, - ); - MemoryInterfaceAirs::Volatile { boundary } + let memory_dims = MemoryDimensions { + addr_space_height: mem_config.addr_space_height, + address_height: mem_config.pointer_max_bits - log2_strict_usize(CHUNK), }; - // Memory access adapters - only create if enabled - let access_adapters: Vec> = if mem_config.access_adapters_enabled() { - let lt_air = IsLtSubAir::new(range_bus, mem_config.timestamp_max_bits); - let maan = mem_config.max_access_adapter_n; - assert!(matches!(maan, 2 | 4 | 8 | 16 | 32)); - [ - Arc::new(AccessAdapterAir::<2> { memory_bus, lt_air }) as AirRef, - Arc::new(AccessAdapterAir::<4> { memory_bus, lt_air }) as AirRef, - Arc::new(AccessAdapterAir::<8> { memory_bus, lt_air }) as AirRef, - Arc::new(AccessAdapterAir::<16> { memory_bus, lt_air }) as AirRef, - Arc::new(AccessAdapterAir::<32> { memory_bus, lt_air }) as AirRef, - ] - .into_iter() - .take(log2_strict_usize(maan)) - .collect() - } else { - Vec::new() + let boundary = PersistentBoundaryAir:: { + memory_dims, + memory_bus, + merkle_bus, + compression_bus, }; - - Self { - bridge, - interface, - access_adapters, - } + let merkle = MemoryMerkleAir:: { + memory_dimensions: memory_dims, + merkle_bus, + compression_bus, + }; + let interface = MemoryInterfaceAirs { boundary, merkle }; + Self { bridge, interface } } - /// The order of memory AIRs is boundary, merkle (if exists), access adapters - pub fn into_airs(self) -> Vec> { - let mut airs: Vec> = Vec::new(); - match self.interface { - MemoryInterfaceAirs::Volatile { boundary } => { - airs.push(Arc::new(boundary)); - } - MemoryInterfaceAirs::Persistent { boundary, merkle } => { - airs.push(Arc::new(boundary)); - airs.push(Arc::new(merkle)); - } - } - airs.extend(self.access_adapters); - airs + /// The order of memory AIRs is boundary, merkle (if exists) + pub fn into_airs(self) -> Vec> { + vec![ + Arc::new(self.interface.boundary), + Arc::new(self.interface.merkle), + ] } } /// This is O(1) and returns the length of /// [`MemoryAirInventory::into_airs`]. -pub fn num_memory_airs(is_persistent: bool, num_access_adapters: usize) -> usize { - // boundary + { merkle if is_persistent } + access_adapters (if enabled) - 1 + usize::from(is_persistent) + num_access_adapters +pub const fn num_memory_airs() -> usize { + // boundary + merkle + 2 } diff --git a/crates/vm/src/system/memory/online.rs b/crates/vm/src/system/memory/online.rs index fb66845c0b..89ba91c4d7 100644 --- a/crates/vm/src/system/memory/online.rs +++ b/crates/vm/src/system/memory/online.rs @@ -12,17 +12,13 @@ use tracing::instrument; use crate::{ arch::{ - AddressSpaceHostConfig, AddressSpaceHostLayout, DenseRecordArena, MemoryConfig, - RecordArena, CONST_BLOCK_SIZE, MAX_CELL_BYTE_SIZE, + AddressSpaceHostConfig, AddressSpaceHostLayout, MemoryConfig, CONST_BLOCK_SIZE, + MAX_CELL_BYTE_SIZE, }, system::{ - memory::{ - adapter::records::{AccessLayout, AccessRecordHeader, MERGE_AND_NOT_SPLIT_FLAG}, - MemoryAddress, TimestampedEquipartition, TimestampedValues, - }, + memory::{MemoryAddress, TimestampedEquipartition, TimestampedValues}, TouchedMemory, }, - utils::slice_as_bytes, }; mod basic; @@ -449,30 +445,16 @@ pub struct TracingMemory { /// For each `addr_space`, the minimum block size allowed for memory accesses. In other words, /// all memory accesses in `addr_space` must be aligned to this block size. pub min_block_size: Vec, - pub access_adapter_records: DenseRecordArena, } -// min_block_size * cell_size never exceeds 8 -const INITIAL_CELL_BUFFER: &[u8] = &[0u8; 8]; -// min_block_size never exceeds 8 -const INITIAL_TIMESTAMP_BUFFER: &[u32] = &[INITIAL_TIMESTAMP; 8]; - impl TracingMemory { - pub fn new( - mem_config: &MemoryConfig, - initial_block_size: usize, - access_adapter_arena_size_bound: usize, - ) -> Self { + pub fn new(mem_config: &MemoryConfig, initial_block_size: usize) -> Self { let image = GuestMemory::new(AddressMap::from_mem_config(mem_config)); - Self::from_image(image, initial_block_size, access_adapter_arena_size_bound) + Self::from_image(image, initial_block_size) } /// Constructor from pre-existing memory image. - pub fn from_image( - image: GuestMemory, - initial_block_size: usize, - access_adapter_arena_size_bound: usize, - ) -> Self { + pub fn from_image(image: GuestMemory, initial_block_size: usize) -> Self { let (meta, min_block_size): (Vec<_>, Vec<_>) = zip_eq(image.memory.get_memory(), &image.memory.config) .map(|(mem, addr_sp)| { @@ -482,15 +464,12 @@ impl TracingMemory { (PagedVec::new(total_metadata_len), min_block_size as u32) }) .unzip(); - let access_adapter_records = - DenseRecordArena::with_byte_capacity(access_adapter_arena_size_bound); Self { data: image, meta, min_block_size, timestamp: INITIAL_TIMESTAMP + 1, initial_block_size, - access_adapter_records, } } @@ -576,52 +555,6 @@ impl TracingMemory { } } - pub(crate) fn add_split_record(&mut self, header: AccessRecordHeader) { - if header.block_size == header.lowest_block_size { - return; - } - // SAFETY: - // - header.address_space is validated during instruction decoding and within bounds - // - header.pointer and header.type_size define valid memory bounds within the address space - // - The memory access range (header.pointer * header.type_size)..(header.pointer + - // header.block_size) * header.type_size is within the allocated size for the address - // space, preventing out of bounds access - let data_slice = unsafe { - self.data.memory.get_u8_slice( - header.address_space, - (header.pointer * header.type_size) as usize, - (header.block_size * header.type_size) as usize, - ) - }; - - let record_mut = self - .access_adapter_records - .alloc(AccessLayout::from_record_header(&header)); - *record_mut.header = header; - record_mut.data.copy_from_slice(data_slice); - // we don't mind garbage values in prev_* - } - - /// `data_slice` is the underlying data of the record in raw host memory format. - pub(crate) fn add_merge_record( - &mut self, - header: AccessRecordHeader, - data_slice: &[u8], - prev_ts: &[u32], - ) { - if header.block_size == header.lowest_block_size { - return; - } - - let record_mut = self - .access_adapter_records - .alloc(AccessLayout::from_record_header(&header)); - *record_mut.header = header; - record_mut.header.timestamp_and_mask |= MERGE_AND_NOT_SPLIT_FLAG; - record_mut.data.copy_from_slice(data_slice); - record_mut.timestamps.copy_from_slice(prev_ts); - } - /// Calculate splits and merges needed for a memory access. /// Returns Some((splits, merge)) or None if no operations needed. #[inline(always)] @@ -672,7 +605,7 @@ impl TracingMemory { } #[inline(always)] - fn split_by_meta( + fn split_by_meta( &mut self, start_ptr: u32, timestamp: u32, @@ -695,14 +628,6 @@ impl TracingMemory { AccessMetadata::new(timestamp, MIN_BLOCK_SIZE as u8, 0), ); } - self.add_split_record(AccessRecordHeader { - timestamp_and_mask: timestamp, - address_space: address_space as u32, - pointer: start_ptr, - block_size: block_size as u32, - lowest_block_size: MIN_BLOCK_SIZE as u32, - type_size: size_of::() as u32, - }); } /// Returns the timestamp of the previous access to `[pointer:BLOCK_SIZE]_{address_space}`. @@ -713,7 +638,6 @@ impl TracingMemory { &mut self, address_space: usize, pointer: usize, - prev_values: &[T; BLOCK_SIZE], ) -> u32 { debug_assert_eq!(ALIGN, self.data.memory.config[address_space].min_block_size); // SAFETY: @@ -739,7 +663,7 @@ impl TracingMemory { let (_, block_metadata) = self.get_block_metadata::(address_space, split_ptr); let timestamp = block_metadata.timestamp(); - self.split_by_meta::( + self.split_by_meta::( split_ptr as u32, timestamp, split_size as u8, @@ -761,7 +685,7 @@ impl TracingMemory { let timestamp = if block_metadata.block_size() > 0 { block_metadata.timestamp() } else { - self.handle_uninitialized_memory::(address_space, ptr); + self.handle_uninitialized_memory::(address_space, ptr); INITIAL_TIMESTAMP }; @@ -775,21 +699,6 @@ impl TracingMemory { seg_idx += 1; } - // Create the merge record - self.add_merge_record( - AccessRecordHeader { - timestamp_and_mask: max_timestamp, - address_space: address_space as u32, - pointer: merge_ptr as u32, - block_size: merge_size as u32, - lowest_block_size: ALIGN as u32, - type_size: size_of::() as u32, - }, - // SAFETY: T is plain old data - unsafe { slice_as_bytes(prev_values) }, - &prev_ts_buf[..seg_idx], - ); - max_timestamp } else { self.get_timestamp::(address_space, pointer) @@ -802,7 +711,7 @@ impl TracingMemory { /// Handle uninitialized memory by creating appropriate split or merge records. #[inline(always)] - fn handle_uninitialized_memory( + fn handle_uninitialized_memory( &mut self, address_space: usize, pointer: usize, @@ -812,27 +721,14 @@ impl TracingMemory { let segment_index = pointer / ALIGN; let block_start = segment_index & !(self.initial_block_size / ALIGN - 1); let start_ptr = (block_start * ALIGN) as u32; - self.split_by_meta::( + self.split_by_meta::( start_ptr, INITIAL_TIMESTAMP, self.initial_block_size as u8, address_space, ); } else { - // Create a merge record for single-byte initialization debug_assert_eq!(self.initial_block_size, 1); - self.add_merge_record( - AccessRecordHeader { - timestamp_and_mask: INITIAL_TIMESTAMP, - address_space: address_space as u32, - pointer: pointer as u32, - block_size: ALIGN as u32, - lowest_block_size: self.initial_block_size as u32, - type_size: size_of::() as u32, - }, - &INITIAL_CELL_BUFFER[..ALIGN], - &INITIAL_TIMESTAMP_BUFFER[..ALIGN], - ); } } @@ -868,11 +764,8 @@ impl TracingMemory { { self.assert_alignment(BLOCK_SIZE, ALIGN, address_space, pointer); let values = self.data.read(address_space, pointer); - let t_prev = self.prev_access_time::( - address_space as usize, - pointer as usize, - &values, - ); + let t_prev = + self.prev_access_time::(address_space as usize, pointer as usize); self.timestamp += 1; (t_prev, values) @@ -911,11 +804,8 @@ impl TracingMemory { { self.assert_alignment(BLOCK_SIZE, ALIGN, address_space, pointer); let values_prev = self.data.read(address_space, pointer); - let t_prev = self.prev_access_time::( - address_space as usize, - pointer as usize, - &values_prev, - ); + let t_prev = + self.prev_access_time::(address_space as usize, pointer as usize); self.data.write(address_space, pointer, values); self.timestamp += 1; @@ -936,17 +826,9 @@ impl TracingMemory { /// Finalize the boundary and merkle chips. #[instrument(name = "memory_finalize", skip_all)] - pub fn finalize(&mut self, is_persistent: bool) -> TouchedMemory { + pub fn finalize(&mut self) -> TouchedMemory { let touched_blocks = self.touched_blocks(); - - match is_persistent { - false => TouchedMemory::Volatile( - self.touched_blocks_to_equipartition::(touched_blocks), - ), - true => TouchedMemory::Persistent( - self.touched_blocks_to_equipartition::(touched_blocks), - ), - } + self.touched_blocks_to_equipartition::(touched_blocks) } /// Returns the list of all touched blocks. The list is sorted by address. @@ -1023,28 +905,8 @@ impl TracingMemory { current_address = MemoryAddress::new(addr_space, ptr); } - if block_size > min_block_size as u8 { - self.add_split_record(AccessRecordHeader { - timestamp_and_mask: timestamp, - address_space: addr_space, - pointer: ptr, - block_size: block_size as u32, - lowest_block_size: min_block_size as u32, - type_size: cell_size as u32, - }); - } if min_block_size > CHUNK { assert_eq!(current_cnt, 0); - for i in (0..block_size as u32).step_by(min_block_size) { - self.add_split_record(AccessRecordHeader { - timestamp_and_mask: timestamp, - address_space: addr_space, - pointer: ptr + i, - block_size: min_block_size as u32, - lowest_block_size: CHUNK as u32, - type_size: cell_size as u32, - }); - } // SAFETY: touched blocks are in bounds let values = unsafe { self.data.memory.get_u8_slice( @@ -1096,18 +958,6 @@ impl TracingMemory { .iter() .max() .unwrap(); - self.add_merge_record( - AccessRecordHeader { - timestamp_and_mask: timestamp, - address_space: addr_space, - pointer: current_address.pointer, - block_size: CHUNK as u32, - lowest_block_size: min_block_size as u32, - type_size: cell_size as u32, - }, - ¤t_values[..CHUNK * cell_size], - ¤t_timestamps[..CHUNK / min_block_size], - ); final_memory.push(( (current_address.address_space, current_address.pointer), TimestampedValues { diff --git a/crates/vm/src/system/memory/tests.rs b/crates/vm/src/system/memory/tests.rs index 04494b3b65..88b96974d9 100644 --- a/crates/vm/src/system/memory/tests.rs +++ b/crates/vm/src/system/memory/tests.rs @@ -1,20 +1,13 @@ -use std::{array, fmt::Debug}; +use std::array; -use openvm_instructions::{ - riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, - DEFERRAL_AS, -}; use openvm_stark_backend::p3_field::PrimeCharacteristicRing; use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng}; -use rand::{rngs::StdRng, Rng}; +use rand::Rng; use test_case::test_case; -use crate::{ - arch::{ - testing::{TestBuilder, VmChipTestBuilder}, - MemoryConfig, - }, - system::memory::{merkle::public_values::PUBLIC_VALUES_AS, online::TracingMemory}, +use crate::arch::{ + testing::{TestBuilder, VmChipTestBuilder}, + MemoryConfig, }; type F = BabyBear; @@ -26,15 +19,15 @@ fn test_memory_write_by_tester(tester: &mut impl TestBuilder, its: usize) { // and intersecting/overlapping blocks, // by limiting the space of valid pointers. let max_ptr = 20; - let aligns = [4, 4, 4, 1]; - let value_bounds = [256, 256, 256, (1 << 30)]; - let max_log_block_size = 4; + let aligns = [4, 4, 4]; + let value_bounds = [256, 256, 256]; for _ in 0..its { let addr_sp = rng.random_range(1..=aligns.len()); let align: usize = aligns[addr_sp - 1]; let value_bound: u32 = value_bounds[addr_sp - 1]; let ptr = rng.random_range(0..max_ptr / align) * align; - let log_len = rng.random_range(align.trailing_zeros()..=max_log_block_size); + // Access adapters are removed, so accesses use the address space minimum block size. + let log_len = align.trailing_zeros(); match log_len { 0 => tester.write::<1>( addr_sp, @@ -66,73 +59,10 @@ fn test_memory_write_by_tester(tester: &mut impl TestBuilder, its: usize) { } } -fn memory_config_for_test() -> MemoryConfig { - let mut memory_config = MemoryConfig::default(); - memory_config.addr_spaces[DEFERRAL_AS as usize].num_cells = 1 << 29; - memory_config -} - -#[test_case(1000)] -#[test_case(0)] -fn test_memory_write_volatile(its: usize) { - let mut tester = VmChipTestBuilder::::volatile(memory_config_for_test()); - test_memory_write_by_tester(&mut tester, its); - let tester = tester.build().finalize(); - tester.simple_test().expect("Verification failed"); -} - -#[test_case(1000)] -#[test_case(0)] -fn test_memory_write_persistent(its: usize) { - let mut tester = VmChipTestBuilder::::persistent(memory_config_for_test()); - test_memory_write_by_tester(&mut tester, its); - let tester = tester.build().finalize(); - tester.simple_test().expect("Verification failed"); -} - -fn test_no_adapter_records_for_singleton_accesses( - address_space: u32, - mut sample: impl FnMut(&mut StdRng) -> T, -) { - let memory_config = memory_config_for_test(); - let mut memory = TracingMemory::new(&memory_config, BLOCK_SIZE, 0); - let max_ptr = (memory_config.addr_spaces[address_space as usize].num_cells / BLOCK_SIZE) as u32; - - let mut rng = create_seeded_rng(); - for _ in 0..1000 { - let pointer = rng.random_range(0..max_ptr) * BLOCK_SIZE as u32; - - if rng.random_bool(0.5) { - let data: [T; BLOCK_SIZE] = array::from_fn(|_| sample(&mut rng)); - unsafe { - memory.write::(address_space, pointer, data); - } - } else { - unsafe { - memory.read::(address_space, pointer); - } - } - } - assert!(memory.access_adapter_records.allocated().is_empty()); -} - -#[test] -fn test_no_adapter_records() { - test_no_adapter_records_for_singleton_accesses::(RV32_REGISTER_AS, |rng| rng.random()); - test_no_adapter_records_for_singleton_accesses::(RV32_MEMORY_AS, |rng| rng.random()); - test_no_adapter_records_for_singleton_accesses::(PUBLIC_VALUES_AS, |rng| rng.random()); - test_no_adapter_records_for_singleton_accesses::(DEFERRAL_AS, |rng| { - F::from_u32(rng.random_range(0..(1 << 30))) - }); -} - -#[cfg(feature = "cuda")] #[test_case(1000)] #[test_case(0)] -fn test_cuda_memory_write_volatile(its: usize) { - use crate::arch::testing::{default_var_range_checker_bus, GpuChipTestBuilder}; - let memory_config = memory_config_for_test(); - let mut tester = GpuChipTestBuilder::volatile(memory_config, default_var_range_checker_bus()); +fn test_memory_write(its: usize) { + let mut tester = VmChipTestBuilder::::from_config(MemoryConfig::default()); test_memory_write_by_tester(&mut tester, its); let tester = tester.build().finalize(); tester.simple_test().expect("Verification failed"); @@ -141,10 +71,10 @@ fn test_cuda_memory_write_volatile(its: usize) { #[cfg(feature = "cuda")] #[test_case(1000)] #[test_case(0)] -fn test_cuda_memory_write_persistent(its: usize) { +fn test_cuda_memory_write(its: usize) { use crate::arch::testing::{default_var_range_checker_bus, GpuChipTestBuilder}; - let memory_config = memory_config_for_test(); - let mut tester = GpuChipTestBuilder::persistent(memory_config, default_var_range_checker_bus()); + let mut tester = + GpuChipTestBuilder::new(MemoryConfig::default(), default_var_range_checker_bus()); test_memory_write_by_tester(&mut tester, its); let tester = tester.build().finalize(); tester.simple_test().expect("Verification failed"); diff --git a/crates/vm/src/system/memory/volatile/mod.rs b/crates/vm/src/system/memory/volatile/mod.rs deleted file mode 100644 index 70418befb5..0000000000 --- a/crates/vm/src/system/memory/volatile/mod.rs +++ /dev/null @@ -1,311 +0,0 @@ -use std::{ - borrow::{Borrow, BorrowMut}, - cmp::min, -}; - -use itertools::zip_eq; -use openvm_circuit_primitives::{ - is_less_than_array::{ - IsLtArrayAuxCols, IsLtArrayIo, IsLtArraySubAir, IsLtArrayWhenTransitionAir, - }, - utils::{compose, implies}, - var_range::{SharedVariableRangeCheckerChip, VariableRangeCheckerBus}, - Chip, SubAir, TraceSubRowGenerator, -}; -use openvm_circuit_primitives_derive::AlignedBorrow; -use openvm_cpu_backend::CpuBackend; -use openvm_stark_backend::{ - interaction::InteractionBuilder, - p3_air::{Air, AirBuilder, BaseAir}, - p3_field::{Field, PrimeCharacteristicRing, PrimeField32}, - p3_matrix::{dense::RowMajorMatrix, Matrix}, - p3_maybe_rayon::prelude::*, - prover::AirProvingContext, - BaseAirWithPublicValues, PartitionedBaseAir, StarkProtocolConfig, Val, -}; -use static_assertions::const_assert; -use tracing::instrument; - -use super::TimestampedEquipartition; -use crate::system::memory::{ - offline_checker::{MemoryBus, AUX_LEN}, - MemoryAddress, -}; - -#[cfg(test)] -mod tests; - -/// Address stored as address space, pointer -const ADDR_ELTS: usize = 2; -const NUM_AS_LIMBS: usize = 1; -const_assert!(NUM_AS_LIMBS <= AUX_LEN); - -#[repr(C)] -#[derive(Clone, Copy, Debug, AlignedBorrow)] -pub struct VolatileBoundaryCols { - pub addr_space_limbs: [T; NUM_AS_LIMBS], - pub pointer_limbs: [T; AUX_LEN], - - pub initial_data: T, - pub final_data: T, - pub final_timestamp: T, - - /// Boolean. `1` if a non-padding row with a valid touched address, `0` if it is a padding row. - pub is_valid: T, - pub addr_lt_aux: IsLtArrayAuxCols, -} - -#[derive(Clone, Debug)] -pub struct VolatileBoundaryAir { - pub memory_bus: MemoryBus, - pub addr_lt_air: IsLtArrayWhenTransitionAir, - - addr_space_limb_bits: [usize; NUM_AS_LIMBS], - pointer_limb_bits: [usize; AUX_LEN], -} - -impl VolatileBoundaryAir { - pub fn new( - memory_bus: MemoryBus, - addr_space_max_bits: usize, - pointer_max_bits: usize, - range_bus: VariableRangeCheckerBus, - ) -> Self { - let addr_lt_air = - IsLtArraySubAir::::new(range_bus, addr_space_max_bits.max(pointer_max_bits)) - .when_transition(); - let range_max_bits = range_bus.range_max_bits; - let mut addr_space_limb_bits = [0; NUM_AS_LIMBS]; - let mut bits_remaining = addr_space_max_bits; - for limb_bits in &mut addr_space_limb_bits { - *limb_bits = min(bits_remaining, range_max_bits); - bits_remaining -= *limb_bits; - } - assert_eq!(bits_remaining, 0, "addr_space_max_bits={addr_space_max_bits} with {NUM_AS_LIMBS} limbs exceeds range_max_bits={range_max_bits}"); - let mut pointer_limb_bits = [0; AUX_LEN]; - let mut bits_remaining = pointer_max_bits; - for limb_bits in &mut pointer_limb_bits { - *limb_bits = min(bits_remaining, range_max_bits); - bits_remaining -= *limb_bits; - } - assert_eq!(bits_remaining, 0, "pointer_max_bits={pointer_max_bits} with {AUX_LEN} limbs exceeds range_max_bits={range_max_bits}"); - Self { - memory_bus, - addr_lt_air, - addr_space_limb_bits, - pointer_limb_bits, - } - } - - pub fn range_bus(&self) -> VariableRangeCheckerBus { - self.addr_lt_air.0.lt.bus - } -} - -impl BaseAirWithPublicValues for VolatileBoundaryAir {} -impl PartitionedBaseAir for VolatileBoundaryAir {} -impl BaseAir for VolatileBoundaryAir { - fn width(&self) -> usize { - VolatileBoundaryCols::::width() - } -} - -impl Air for VolatileBoundaryAir { - fn eval(&self, builder: &mut AB) { - let main = builder.main(); - - let [local, next] = [0, 1].map(|i| main.row_slice(i).expect("window row present")); - let local: &VolatileBoundaryCols<_> = (*local).borrow(); - let next: &VolatileBoundaryCols<_> = (*next).borrow(); - - builder.assert_bool(local.is_valid); - - // Ensuring all non-padding rows are at the bottom - builder - .when_transition() - .assert_one(implies(next.is_valid, local.is_valid)); - - // Range check local.addr_space_limbs to addr_space_max_bits - for (&limb, limb_bits) in zip_eq(&local.addr_space_limbs, self.addr_space_limb_bits) { - self.range_bus() - .range_check(limb, limb_bits) - .eval(builder, local.is_valid); - } - // Range check local.pointer_limbs to pointer_max_bits - for (&limb, limb_bits) in zip_eq(&local.pointer_limbs, self.pointer_limb_bits) { - self.range_bus() - .range_check(limb, limb_bits) - .eval(builder, local.is_valid); - } - let range_max_bits = self.range_bus().range_max_bits; - // Compose addr_space_limbs and pointer_limbs into addr_space, pointer for both local and - // next - let [addr_space, next_addr_space] = [&local.addr_space_limbs, &next.addr_space_limbs] - .map(|limbs| compose::(limbs, range_max_bits)); - let [pointer, next_pointer] = [&local.pointer_limbs, &next.pointer_limbs] - .map(|limbs| compose::(limbs, range_max_bits)); - - // Assert local addr < next addr when next.is_valid - // This ensures the addresses in non-padding rows are all sorted - let lt_io = IsLtArrayIo { - x: [addr_space.clone(), pointer.clone()], - y: [next_addr_space, next_pointer], - out: AB::Expr::ONE, - count: next.is_valid.into(), - }; - // N.B.: this will do range checks (but not other constraints) on the last row if the first - // row has is_valid = 1 due to wraparound - self.addr_lt_air - .eval(builder, (lt_io, (&local.addr_lt_aux).into())); - - // Write the initial memory values at initial timestamps - self.memory_bus - .send( - MemoryAddress::new(addr_space.clone(), pointer.clone()), - vec![local.initial_data], - AB::Expr::ZERO, - ) - .eval(builder, local.is_valid); - - // Read the final memory values at last timestamps when written to - self.memory_bus - .receive( - MemoryAddress::new(addr_space.clone(), pointer.clone()), - vec![local.final_data], - local.final_timestamp, - ) - .eval(builder, local.is_valid); - } -} - -pub struct VolatileBoundaryChip { - pub air: VolatileBoundaryAir, - range_checker: SharedVariableRangeCheckerChip, - overridden_height: Option, - pub final_memory: Option>, - addr_space_max_bits: usize, - pointer_max_bits: usize, -} - -impl VolatileBoundaryChip { - pub fn new( - memory_bus: MemoryBus, - addr_space_max_bits: usize, - pointer_max_bits: usize, - range_checker: SharedVariableRangeCheckerChip, - ) -> Self { - let range_bus = range_checker.bus(); - Self { - air: VolatileBoundaryAir::new( - memory_bus, - addr_space_max_bits, - pointer_max_bits, - range_bus, - ), - range_checker, - overridden_height: None, - final_memory: None, - addr_space_max_bits, - pointer_max_bits, - } - } -} - -impl VolatileBoundaryChip { - pub fn set_overridden_height(&mut self, overridden_height: usize) { - self.overridden_height = Some(overridden_height); - } - /// Volatile memory requires the starting and final memory to be in equipartition with block - /// size `1`. When block size is `1`, then the `label` is the same as the address pointer. - #[instrument(name = "boundary_finalize", level = "debug", skip_all)] - pub fn finalize(&mut self, final_memory: TimestampedEquipartition) { - self.final_memory = Some(final_memory); - } -} - -impl Chip> for VolatileBoundaryChip> -where - Val: PrimeField32, -{ - fn generate_proving_ctx(&self, _: RA) -> AirProvingContext> { - // Volatile memory requires the starting and final memory to be in equipartition with block - // size `1`. When block size is `1`, then the `label` is the same as the address - // pointer. - let width = VolatileBoundaryCols::>::width(); - let addr_lt_air = &self.air.addr_lt_air; - // TEMP[jpw]: clone - let final_memory = self - .final_memory - .clone() - .expect("Trace generation should be called after finalize"); - let trace_height = if let Some(height) = self.overridden_height { - assert!( - height >= final_memory.len(), - "Overridden height is less than the required height" - ); - height - } else { - final_memory.len() - }; - let trace_height = trace_height.next_power_of_two(); - - // Collect into Vec to sort from BTreeMap and also so we can look at adjacent entries - let sorted_final_memory: Vec<_> = final_memory.into_par_iter().collect(); - let memory_len = sorted_final_memory.len(); - - let range_checker = self.range_checker.as_ref(); - let mut rows = Val::::zero_vec(trace_height * width); - rows.par_chunks_mut(width) - .zip(sorted_final_memory.par_iter()) - .enumerate() - .for_each(|(i, (row, ((addr_space, ptr), timestamped_values)))| { - // `pointer` is the same as `label` since the equipartition has block size 1 - let [data] = timestamped_values.values; - let row: &mut VolatileBoundaryCols<_> = row.borrow_mut(); - range_checker.decompose( - *addr_space, - self.addr_space_max_bits, - &mut row.addr_space_limbs, - ); - range_checker.decompose(*ptr, self.pointer_max_bits, &mut row.pointer_limbs); - row.initial_data = Val::::ZERO; - row.final_data = data; - row.final_timestamp = Val::::from_u32(timestamped_values.timestamp); - row.is_valid = Val::::ONE; - - // If next.is_valid == 1: - if i != memory_len - 1 { - let (next_addr_space, next_ptr) = sorted_final_memory[i + 1].0; - let mut out = Val::::ZERO; - addr_lt_air.0.generate_subrow( - ( - self.range_checker.as_ref(), - &[Val::::from_u32(*addr_space), Val::::from_u32(*ptr)], - &[ - Val::::from_u32(next_addr_space), - Val::::from_u32(next_ptr), - ], - ), - ((&mut row.addr_lt_aux).into(), &mut out), - ); - debug_assert_eq!(out, Val::::ONE, "Addresses are not sorted"); - } - }); - // Always do a dummy range check on the last row due to wraparound - if memory_len > 0 { - let mut out = Val::::ZERO; - let row: &mut VolatileBoundaryCols<_> = rows[width * (trace_height - 1)..].borrow_mut(); - addr_lt_air.0.generate_subrow( - ( - self.range_checker.as_ref(), - &[Val::::ZERO, Val::::ZERO], - &[Val::::ZERO, Val::::ZERO], - ), - ((&mut row.addr_lt_aux).into(), &mut out), - ); - } - - let trace = RowMajorMatrix::new(rows, width); - AirProvingContext::simple_no_pis(trace) - } -} diff --git a/crates/vm/src/system/memory/volatile/tests.rs b/crates/vm/src/system/memory/volatile/tests.rs deleted file mode 100644 index 0ca6046cbb..0000000000 --- a/crates/vm/src/system/memory/volatile/tests.rs +++ /dev/null @@ -1,149 +0,0 @@ -use std::{collections::HashSet, iter, sync::Arc}; - -use openvm_circuit_primitives::{ - var_range::{VariableRangeCheckerBus, VariableRangeCheckerChip}, - Chip, -}; -use openvm_cpu_backend::CpuBackend; -use openvm_stark_backend::{ - interaction::BusIndex, p3_field::PrimeCharacteristicRing, p3_matrix::dense::RowMajorMatrix, - prover::AirProvingContext, - test_utils::dummy_airs::interaction::dummy_interaction_air::DummyInteractionAir, AirRef, - StarkEngine, -}; -use openvm_stark_sdk::{ - config::baby_bear_poseidon2::BabyBearPoseidon2Config, p3_baby_bear::BabyBear, - utils::create_seeded_rng, -}; -use rand::Rng; -use test_log::test; - -use crate::{ - system::memory::{ - offline_checker::MemoryBus, volatile::VolatileBoundaryChip, TimestampedEquipartition, - TimestampedValues, - }, - utils::test_cpu_engine, -}; - -type Val = BabyBear; - -#[test] -fn boundary_air_test() { - let mut rng = create_seeded_rng(); - - const MEMORY_BUS: BusIndex = 1; - const RANGE_CHECKER_BUS: BusIndex = 3; - const MAX_ADDRESS_SPACE: u32 = 4; - const LIMB_BITS: usize = 15; - const MAX_VAL: u32 = 1 << LIMB_BITS; - const DECOMP: usize = 8; - let memory_bus = MemoryBus::new(MEMORY_BUS); - - let num_addresses = 10; - let mut distinct_addresses = HashSet::new(); - while distinct_addresses.len() < num_addresses { - let addr_space = rng.random_range(0..MAX_ADDRESS_SPACE); - let pointer = rng.random_range(0..MAX_VAL); - distinct_addresses.insert((addr_space, pointer)); - } - - let range_bus = VariableRangeCheckerBus::new(RANGE_CHECKER_BUS, DECOMP); - let range_checker = Arc::new(VariableRangeCheckerChip::new(range_bus)); - let mut boundary_chip = - VolatileBoundaryChip::new(memory_bus, 2, LIMB_BITS, range_checker.clone()); - - let mut final_memory = TimestampedEquipartition::new(); - - for (addr_space, pointer) in distinct_addresses.iter().cloned() { - let final_data = Val::from_u32(rng.random_range(0..MAX_VAL)); - let final_clk = rng.random_range(1..MAX_VAL) as u32; - - final_memory.push(( - (addr_space, pointer), - TimestampedValues { - values: [final_data], - timestamp: final_clk, - }, - )); - } - final_memory.sort_by_key(|(key, _)| *key); - - let diff_height = num_addresses.next_power_of_two() - num_addresses; - - let init_memory_dummy_air = DummyInteractionAir::new(4, false, MEMORY_BUS); - let final_memory_dummy_air = DummyInteractionAir::new(4, true, MEMORY_BUS); - - let init_memory_trace = RowMajorMatrix::new( - distinct_addresses - .iter() - .flat_map(|(addr_space, pointer)| { - vec![ - Val::ONE, - Val::from_u32(*addr_space), - Val::from_u32(*pointer), - Val::ZERO, - Val::ZERO, - ] - }) - .chain(iter::repeat_n(Val::ZERO, 5 * diff_height)) - .collect(), - 5, - ); - - let final_memory_trace = RowMajorMatrix::new( - distinct_addresses - .iter() - .flat_map(|(addr_space, pointer)| { - let timestamped_value = final_memory[final_memory - .binary_search_by(|(key, _)| key.cmp(&(*addr_space, *pointer))) - .unwrap()] - .1; - - vec![ - Val::ONE, - Val::from_u32(*addr_space), - Val::from_u32(*pointer), - timestamped_value.values[0], - Val::from_u32(timestamped_value.timestamp), - ] - }) - .chain(iter::repeat_n(Val::ZERO, 5 * diff_height)) - .collect(), - 5, - ); - - boundary_chip.finalize(final_memory.clone()); - let boundary_air = Arc::new(boundary_chip.air.clone()) as AirRef<_>; - let boundary_ctx: AirProvingContext> = - boundary_chip.generate_proving_ctx(()); - // test trace height override - { - let overridden_height = boundary_ctx.height() * 2; - let range_checker = Arc::new(VariableRangeCheckerChip::new(range_bus)); - let mut boundary_chip = - VolatileBoundaryChip::new(memory_bus, 2, LIMB_BITS, range_checker.clone()); - boundary_chip.set_overridden_height(overridden_height); - boundary_chip.finalize(final_memory.clone()); - let boundary_ctx: AirProvingContext> = - boundary_chip.generate_proving_ctx(()); - assert_eq!(boundary_ctx.height(), overridden_height.next_power_of_two()); - } - - test_cpu_engine() - .run_test( - vec![ - boundary_air, - Arc::new(range_checker.air), - Arc::new(init_memory_dummy_air), - Arc::new(final_memory_dummy_air), - ], - vec![ - boundary_ctx, - range_checker.generate_proving_ctx(()), - AirProvingContext::simple_no_pis(init_memory_trace), - AirProvingContext::simple_no_pis(final_memory_trace), - ], - ) - .expect("Verification failed"); -} diff --git a/crates/vm/src/system/mod.rs b/crates/vm/src/system/mod.rs index f1f1ba5ded..d06ee2efac 100644 --- a/crates/vm/src/system/mod.rs +++ b/crates/vm/src/system/mod.rs @@ -25,15 +25,14 @@ use self::{connector::VmConnectorAir, program::ProgramAir}; use crate::{ arch::{ vm_poseidon2_config, AirInventory, AirInventoryError, BusIndexManager, ChipInventory, - ChipInventoryError, DenseRecordArena, ExecutionBridge, ExecutionBus, ExecutionState, - ExecutorInventory, ExecutorInventoryError, MatrixRecordArena, PhantomSubExecutor, - RowMajorMatrixArena, SystemConfig, VmBuilder, VmChipComplex, VmCircuitConfig, - VmExecutionConfig, VmField, CONNECTOR_AIR_ID, MEMORY_AIRS_START_IDX, PROGRAM_AIR_ID, + ChipInventoryError, ExecutionBridge, ExecutionBus, ExecutionState, ExecutorInventory, + ExecutorInventoryError, MatrixRecordArena, PhantomSubExecutor, RowMajorMatrixArena, + SystemConfig, VmBuilder, VmChipComplex, VmCircuitConfig, VmExecutionConfig, VmField, + BOUNDARY_AIR_ID, CONNECTOR_AIR_ID, CONST_BLOCK_SIZE, PROGRAM_AIR_ID, }, system::{ connector::VmConnectorChip, memory::{ - interface::{MemoryInterface, MemoryInterfaceAirs}, offline_checker::{MemoryBridge, MemoryBus}, online::GuestMemory, MemoryAirInventory, MemoryController, TimestampedEquipartition, CHUNK, @@ -66,7 +65,7 @@ const POSEIDON2_INSERTION_IDX: usize = 1; /// /// The [SystemChipComplex] is meant to be constructible once the VM configuration is known, and it /// can be loaded with arbitrary programs supported by the instruction set available to its -/// configuration. The [SystemChipComplex] is meant to persistent between instances of proof +/// configuration. The [SystemChipComplex] is meant to persist between instances of proof /// generation. pub trait SystemChipComplex { /// Loads the program in the form of a cached trace with prover data. @@ -84,8 +83,7 @@ pub trait SystemChipComplex { record_arenas: Vec, ) -> Vec>; - /// This function only returns `Some` when continuations is enabled. - /// When continuations is enabled, it returns the top merkle sub-tree of the memory merkle tree + /// Returns the top merkle sub-tree of the memory merkle tree /// as a segment tree with `2 * (2^addr_space_height) - 1` nodes, representing the Merkle /// tree formed from the roots of the sub-trees for each address space. /// @@ -109,17 +107,11 @@ pub struct SystemRecords { /// `i` -> frequency of instruction in `i`th row of trace matrix. This requires filtering /// `program.instructions_and_debug_infos` to remove gaps. pub filtered_exec_frequencies: Vec, - // We always use a [DenseRecordArena] here, regardless of the generic `RA` used for other - // execution records. - pub access_adapter_records: DenseRecordArena, // Perf[jpw]: this should be computed on-device and changed to just touched blocks pub touched_memory: TouchedMemory, } -pub enum TouchedMemory { - Persistent(TimestampedEquipartition), - Volatile(TimestampedEquipartition), -} +pub type TouchedMemory = TimestampedEquipartition; #[derive(Clone, AnyEnum, Executor, MeteredExecutor, PreflightExecutor, From)] #[cfg_attr(feature = "aot", derive(AotExecutor, AotMeteredExecutor))] @@ -136,17 +128,18 @@ pub struct SystemPort { } #[derive(Clone)] -pub struct SystemAirInventory { +pub struct SystemAirInventory { pub program: ProgramAir, pub connector: VmConnectorAir, - pub memory: MemoryAirInventory, + pub memory: MemoryAirInventory, } -impl SystemAirInventory { +impl SystemAirInventory { pub fn new( config: &SystemConfig, port: SystemPort, - merkle_compression_buses: Option<(PermutationCheckBus, PermutationCheckBus)>, + merkle_bus: PermutationCheckBus, + compression_bus: PermutationCheckBus, ) -> Self { let SystemPort { execution_bus, @@ -161,16 +154,11 @@ impl SystemAirInventory { range_bus, config.memory_config.timestamp_max_bits, ); - assert_eq!( - config.continuation_enabled, - merkle_compression_buses.is_some() - ); - let memory = MemoryAirInventory::new( memory_bridge, &config.memory_config, - range_bus, - merkle_compression_buses, + merkle_bus, + compression_bus, ); Self { @@ -188,7 +176,7 @@ impl SystemAirInventory { } } - pub fn into_airs(self) -> Vec> { + pub fn into_airs(self) -> Vec> { let mut airs: Vec> = Vec::new(); airs.push(Arc::new(self.program)); airs.push(Arc::new(self.connector)); @@ -248,13 +236,9 @@ where let range_bus = VariableRangeCheckerBus::new(bus_idx_mgr.new_bus_idx(), self.memory_config.decomp); - let merkle_compression_buses = if self.continuation_enabled { - let merkle_bus = PermutationCheckBus::new(bus_idx_mgr.new_bus_idx()); - let compression_bus = PermutationCheckBus::new(bus_idx_mgr.new_bus_idx()); - Some((merkle_bus, compression_bus)) - } else { - None - }; + let merkle_bus = PermutationCheckBus::new(bus_idx_mgr.new_bus_idx()); + let compression_bus = PermutationCheckBus::new(bus_idx_mgr.new_bus_idx()); + let direct_bus_idx = compression_bus.index; let memory_bridge = MemoryBridge::new(memory_bus, self.memory_config.timestamp_max_bits, range_bus); let system_port = SystemPort { @@ -262,7 +246,7 @@ where program_bus, memory_bridge, }; - let system = SystemAirInventory::new(self, system_port, merkle_compression_buses); + let system = SystemAirInventory::new(self, system_port, merkle_bus, compression_bus); let mut inventory = AirInventory::new(self.clone(), system, bus_idx_mgr); @@ -270,20 +254,16 @@ where // Range checker is always the first AIR in the inventory inventory.add_air(range_checker); - if self.continuation_enabled { - assert_eq!(inventory.ext_airs().len(), POSEIDON2_INSERTION_IDX); - // Add direct poseidon2 AIR for persistent memory. - // Currently we never use poseidon2 opcodes when continuations is enabled: we will need - // special handling when that happens - let (_, compression_bus) = merkle_compression_buses.unwrap(); - let direct_bus_idx = compression_bus.index; - let air = new_poseidon2_periphery_air( - vm_poseidon2_config(), - LookupBus::new(direct_bus_idx), - self.max_constraint_degree, - ); - inventory.add_air_ref(air); - } + assert_eq!(inventory.ext_airs().len(), POSEIDON2_INSERTION_IDX); + // Add direct poseidon2 AIR for memory merkle tree. + // Currently we never use poseidon2 opcodes directly: we will need + // special handling when that happens + let air = new_poseidon2_periphery_air( + vm_poseidon2_config(), + LookupBus::new(direct_bus_idx), + self.max_constraint_degree, + ); + inventory.add_air_ref(air); let execution_bridge = ExecutionBridge::new(execution_bus, program_bus); let phantom = PhantomAir { execution_bridge, @@ -317,9 +297,9 @@ where { pub fn new( config: &SystemConfig, - mem_inventory: &MemoryAirInventory, + mem_inventory: &MemoryAirInventory, range_checker: SharedVariableRangeCheckerChip, - hasher_chip: Option>>>, + hasher_chip: Arc>>, ) -> Self { // We create an empty program chip: the program should be loaded later (and can be swapped // out). The execution frequencies are supplied only after execution. @@ -329,30 +309,14 @@ where config.memory_config.timestamp_max_bits, ); let memory_bus = mem_inventory.bridge.memory_bus(); - let memory_controller = match &mem_inventory.interface { - MemoryInterfaceAirs::Persistent { - boundary: _, - merkle, - } => { - assert!(config.continuation_enabled); - MemoryController::>::with_persistent_memory( - memory_bus, - config.memory_config.clone(), - range_checker.clone(), - merkle.merkle_bus, - merkle.compression_bus, - hasher_chip.unwrap(), - ) - } - MemoryInterfaceAirs::Volatile { boundary: _ } => { - assert!(!config.continuation_enabled); - MemoryController::with_volatile_memory( - memory_bus, - config.memory_config.clone(), - range_checker.clone(), - ) - } - }; + let memory_controller = MemoryController::>::with_persistent_memory( + memory_bus, + config.memory_config.clone(), + range_checker.clone(), + mem_inventory.interface.merkle.merkle_bus, + mem_inventory.interface.merkle.compression_bus, + hasher_chip, + ); Self { program_chip, @@ -387,7 +351,6 @@ where to_state, exit_code, filtered_exec_frequencies, - access_adapter_records, touched_memory, } = system_records; @@ -397,9 +360,7 @@ where self.connector_chip.end(to_state, exit_code); let connector_ctx = self.connector_chip.generate_proving_ctx(()); - let memory_ctxs = self - .memory_controller - .generate_proving_ctx(access_adapter_records, touched_memory); + let memory_ctxs = self.memory_controller.generate_proving_ctx(touched_memory); [program_ctx, connector_ctx] .into_iter() @@ -408,13 +369,8 @@ where } fn memory_top_tree(&self) -> Option<&[[Val; CHUNK]]> { - match &self.memory_controller.interface_chip { - MemoryInterface::Persistent { merkle_chip, .. } => { - let top_tree = &merkle_chip.top_tree; - (!top_tree.is_empty()).then_some(top_tree.as_slice()) - } - MemoryInterface::Volatile { .. } => None, - } + let top_tree = &self.memory_controller.interface_chip.merkle_chip.top_tree; + (!top_tree.is_empty()).then_some(top_tree.as_slice()) } } @@ -447,23 +403,18 @@ where inventory.next_air::()?; inventory.add_periphery_chip(range_checker.clone()); - let hasher_chip = if config.continuation_enabled { - assert_eq!(inventory.chips().len(), POSEIDON2_INSERTION_IDX); - // ATTENTION: The threshold 7 here must match the one in `new_poseidon2_periphery_air` - if config.max_constraint_degree >= 7 { - inventory.next_air::, 0>>()?; - } else { - inventory.next_air::, 1>>()?; - }; - let chip = Arc::new(Poseidon2PeripheryChip::new( - vm_poseidon2_config(), - config.max_constraint_degree, - )); - inventory.add_periphery_chip(chip.clone()); - Some(chip) + assert_eq!(inventory.chips().len(), POSEIDON2_INSERTION_IDX); + // ATTENTION: The threshold 7 here must match the one in `new_poseidon2_periphery_air` + if config.max_constraint_degree >= 7 { + inventory.next_air::, 0>>()?; } else { - None + inventory.next_air::, 1>>()?; }; + let hasher_chip = Arc::new(Poseidon2PeripheryChip::new( + vm_poseidon2_config(), + config.max_constraint_degree, + )); + inventory.add_periphery_chip(hasher_chip.clone()); let system = SystemChipInventory::new( config, &inventory.airs().system().memory, @@ -495,6 +446,6 @@ where ); assert_eq!(heights[CONNECTOR_AIR_ID], 2); self.memory_controller - .set_override_trace_heights(&heights[MEMORY_AIRS_START_IDX..]); + .set_override_trace_heights(&heights[BOUNDARY_AIR_ID..]); } } diff --git a/crates/vm/src/system/poseidon2/mod.rs b/crates/vm/src/system/poseidon2/mod.rs index 519b7a04b5..b6522390ba 100644 --- a/crates/vm/src/system/poseidon2/mod.rs +++ b/crates/vm/src/system/poseidon2/mod.rs @@ -1,5 +1,7 @@ -//! Chip to handle Poseidon2 instructions `compress` and `permute`. It is used as a system chip -//! for persistent memory. +//! Chip to handle **native kernel** instructions for Poseidon2 `compress` and `permute`. +//! This chip is put in `intrinsics` for organizational convenience, but +//! it is used as a system chip for the memory merkle tree and as a native kernel chip for +//! aggregation. //! //! Note that neither `compress` nor `permute` on its own //! is a cryptographic hash. `permute` is a cryptographic permutation, which can be made diff --git a/crates/vm/src/utils/stark_utils.rs b/crates/vm/src/utils/stark_utils.rs index 468b5a5697..cb0213e8df 100644 --- a/crates/vm/src/utils/stark_utils.rs +++ b/crates/vm/src/utils/stark_utils.rs @@ -1,27 +1,24 @@ use openvm_circuit_primitives::utils::next_power_of_two_or_zero; use openvm_instructions::exe::VmExe; use openvm_stark_backend::{ - keygen::types::MultiStarkVerifyingKey, - p3_field::PrimeField32, - proof::Proof, - prover::ProvingContext, - Com, StarkEngine, SystemParams, Val, + keygen::types::MultiStarkVerifyingKey, p3_field::PrimeField32, proof::Proof, + prover::ProvingContext, Com, StarkEngine, SystemParams, Val, }; use openvm_stark_sdk::{ - config::baby_bear_poseidon2::*, - p3_baby_bear::BabyBear, - utils::setup_tracing, + config::baby_bear_poseidon2::*, p3_baby_bear::BabyBear, utils::setup_tracing, }; +#[cfg(feature = "aot")] +use crate::arch::SystemConfig; #[cfg(feature = "aot")] use crate::arch::VmState; #[cfg(feature = "aot")] use crate::system::memory::online::GuestMemory; use crate::{ arch::{ - debug_proving_ctx, execution_mode::Segment, vm::VirtualMachine, Executor, ExitCode, - MeteredExecutor, PreflightExecutionOutput, PreflightExecutor, Streams, SystemConfig, - VmBuilder, VmCircuitConfig, VmConfig, VmExecutionConfig, + debug_proving_ctx, execution_mode::Segment, verify_segments, vm::VirtualMachine, Executor, + ExitCode, MeteredExecutor, PreflightExecutionOutput, PreflightExecutor, Streams, VmBuilder, + VmCircuitConfig, VmConfig, VmExecutionConfig, }, system::memory::{MemoryImage, CHUNK}, }; @@ -86,7 +83,7 @@ where while config.as_ref().max_constraint_degree > (1 << log_blowup) + 1 { log_blowup += 1; } - let params = SystemParams::new_for_testing(20); // max log_trace_height=20 + let params = SystemParams::new_for_testing(22); // max log_trace_height=22 let debug = std::env::var("OPENVM_SKIP_DEBUG") != Result::Ok(String::from("1")); let (final_memory, _) = air_test_impl::( params, @@ -262,8 +259,8 @@ where proofs.push(proof); } assert!(proofs.len() >= min_segments); - match vm.verify(&vk, &proofs) { - Ok(()) => {} + match verify_segments(&vm.engine, &vk, &proofs) { + Ok(_) => {} Err(err) => { panic!("segment proofs should verify: {err}"); } @@ -283,8 +280,8 @@ where /// Note: Metered execution stores un-padded counts, so we pad them for comparison. /// The proving context trace height (realized) is already padded. /// For most AIRs, estimated_padded should exactly equal realized. -/// For MemoryMerkleAir, Poseidon2PeripheryAir, PersistentBoundaryAir, and AccessAdapterAir, it is -/// expected that estimated >> realized +/// For MemoryMerkleAir, Poseidon2PeripheryAir, and PersistentBoundaryAir, it is expected that +/// estimated >> realized. fn validate_metered_estimates( vm: &VirtualMachine, estimated_heights: &[u32], @@ -343,15 +340,10 @@ fn validate_metered_estimates( ); // For some airs, the overestimates are expected - let system_config: &SystemConfig = vm.config().as_ref(); - let skip_access_adapter = - system_config.access_adapters_enabled() && air_name.contains("AccessAdapterAir"); if air_name.contains("MemoryMerkleAir") || air_name.contains("Poseidon2PeripheryAir") - || air_name.contains("VolatileBoundaryAir") || air_name.contains("PersistentBoundaryAir") || air_name.contains("NativeAdapterAir") - || skip_access_adapter { continue; } diff --git a/crates/vm/src/utils/test_utils.rs b/crates/vm/src/utils/test_utils.rs index a0586bb6d4..2a37577751 100644 --- a/crates/vm/src/utils/test_utils.rs +++ b/crates/vm/src/utils/test_utils.rs @@ -1,10 +1,7 @@ use std::array; use openvm_circuit::arch::{MemoryConfig, SystemConfig}; -use openvm_instructions::{ - riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}, - DEFERRAL_AS, -}; +use openvm_instructions::riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}; use openvm_stark_backend::p3_field::PrimeField32; use rand::{rngs::StdRng, Rng}; @@ -39,21 +36,12 @@ pub fn u32_sign_extend(num: u32) -> u32 { } } -pub fn test_system_config_without_continuations() -> SystemConfig { +pub fn test_system_config() -> SystemConfig { let mut addr_spaces = MemoryConfig::empty_address_space_configs(5); addr_spaces[RV32_REGISTER_AS as usize].num_cells = PAGE_SIZE; addr_spaces[RV32_MEMORY_AS as usize].num_cells = 1 << 22; addr_spaces[PUBLIC_VALUES_AS as usize].num_cells = PAGE_SIZE; - addr_spaces[DEFERRAL_AS as usize].num_cells = 1 << 25; - SystemConfig::new(3, MemoryConfig::new(2, addr_spaces, 29, 29, 17, 32), 32) - .without_continuations() -} - -// Testing config when deferral address space is not needed, with continuations enabled -pub fn test_system_config() -> SystemConfig { - let mut config = test_system_config_without_continuations(); - config.memory_config.addr_spaces[DEFERRAL_AS as usize].num_cells = 0; - config.with_continuations() + SystemConfig::new(3, MemoryConfig::new(2, addr_spaces, 29, 29, 17), 32) } /// Generate a random message of a given length in bytes diff --git a/docs/vocs/docs/pages/specs/architecture/memory.mdx b/docs/vocs/docs/pages/specs/architecture/memory.mdx index cf156f3178..546ba17d1c 100644 --- a/docs/vocs/docs/pages/specs/architecture/memory.mdx +++ b/docs/vocs/docs/pages/specs/architecture/memory.mdx @@ -1,23 +1,20 @@ # Memory overview - [Basic performed interactions](#basic-performed-interactions) -- [Access adapters](#access-adapters) -- [Boundary chips](#boundary-chips) +- [Memory boundary chip](#memory-boundary-chip) - [Invariants](#invariants) - [Soundness proof](#soundness-proof) - [Time goes forward](#time-goes-forward) - [Memory consistency](#memory-consistency) -- [Volatile and persistent memory](#volatile-and-persistent-memory) - - [Volatile Memory: `VolatileBoundaryChip`](#volatile-memory-volatileboundarychip) - - [Persistent Memory: `PersistentBoundaryChip`](#persistent-memory-persistentboundarychip) +- [The `PersistentBoundaryChip`](#the-persistentboundarychip) - [Implementation details](#implementation-details) - [What to take into account when adding a new chip](#what-to-take-into-account-when-adding-a-new-chip) --- -Chips in the VM need to perform memory read and write operations. The goal of memory checking is to ensure memory consistency across all chips. Every memory operation consists of an operation type (Read or Write), address (`address_space` and `pointer`), data, and timestamp. All memory operations across all chips should happen at distinct timestamps between $1$ and $2^{29}$. We assume that memory is initialized at timestamp $0$. For simplicity, we assume that all memory operations are enabled (there is a way to disable them in the implementation). +Chips in the VM need to perform memory read and write operations. The goal of memory checking is to ensure memory consistency across all chips. Every memory operation consists of an operation type (Read or Write), address (`address_space` and `pointer`), data, and timestamp. All memory operations across all chips should happen at distinct timestamps between $1$ and $2^{\text{timestamp\_max\_bits}}$ (in the current implementation, `timestamp_max_bits <= 29`). We assume that memory is initialized at timestamp $0$. For simplicity, we assume that all memory operations are enabled (there is a way to disable them in the implementation). -Our memory is split into **online** and **offline** memory. Online memory provides actual data and generates access records during program execution, while offline memory uses those records to verify memory consistency. Below we describe how offline memory works. First, we look at the interactions on the memory bus and why they are sound in our ecosystem. Next, we discuss two different memory models, namely, **volatile** and **persistent** memory. +Our memory is split into **online** and **offline** memory. Online memory provides actual data and generates access records during program execution, while offline memory uses those records to verify memory consistency. Below we describe how offline memory works. First, we look at the interactions on the memory bus and why they are sound in our ecosystem. Next, we discuss how the boundary chip commits to both the initial and final memory state. We use the offline memory checking argument of [BEGKN92](https://www.cs.ubc.ca/~will/papers/memcheck.pdf). @@ -67,97 +64,15 @@ impl, const N: usize> MemoryWriteO } ``` -Every instruction executor does this via the **memory controller** API. The memory controller communicates with the memory bus via the **access adapter inventory**, which consists of **access adapters**. - -## Access adapters - -Consider an example: - -- We write `[1, 2, 3, 4]` to `[0, 4)` of address space `2`. -- We write `[5, 6, 7, 8]` to `[4, 8)` of address space `2`. -- We read `[3, 4, 5, 6]` from `[2, 6)` of address space `2`. - -Using only interactions above, we won't be able to balance out the `[/* address */ 2, /* data */ 2, 3, 4, 5, 6, /* timestamp */3]` interaction. Access adapters are used to fix this. - -Formally speaking, our memory model is as follows: - -- Call a set of power-of-two subsegments of $[0,2^{\text{max bits}})$ _nice_. More specifically, a set $S$ of disjoint subsets of $[0,2^{\text{max bits}})$ is nice if the following holds: - - Every element of $S$ consists of consecutive integers (or _is a subsegment_), - - Every element of $S$ has a power-of-two size (hence nonempty). -- At any point of time, for each valid address space, we store a nice set of _memory segments_, and for each of them we remember the actual values there. -- In our memory model, the chips are allowed to perform reads and writes from/to power-of-two subsegments of memory (more specifically, subsegments with length that is a power of two not exceeding 32). -- When we want to read from/write to a subsegment, **we transform the nice set for the corresponding address space,** so that our set contains the queried subsegment, using the following operations: - - _Create_ a new aligned subsegment of length `CHUNK` (which is a power of two). It must not overlap with any other subsegment. - - _Split_ an existing subsegment by replacing it with its halves. - - _Merge_ two adjacent subsegments of equal length into one. -- It is easy to see that the set remains nice after each operation. - -The _split_ and _merge_ operations for a subsegment of length `N` are handled by `AccessAdapterAir` (and we only have 5 of them, hence up to 32). More specifically: -- We have a `timestamp` associated with each subsegment from our nice set -- basically the timestamp of last read/write of any part in this subsegment. -- Of course, merging two halves creates a subsegment with the timestamp being the maximal of two timestamps for the halves. -- Splitting, however, just makes all child timestamps equal to the former timestamp of the segment being split. -- All these timestamp conditions are checked in the `AccessAdapterAir`. -- When merging two segments `[l, m)` and `[m, r)`, the `AccessAdapterAir` sends to **memory bus** the information about `[l, r)` and receives the information about `[l, m)` and about `[m, r)`, all with multiplicity 1. Splitting does the same, but with multiplicity -1 (or, in other words, receives about `[l, r)` and sends about `[l, m)` and `[m, r)`). -- The information about `[l, r)` sent to the bus is, in this order: - - address space, - - `l`, - - the values at `[l, r)`, - - the timestamp. - -In the example above, if, say, `CHUNK = 1`, then the following interactions are performed: -- Write `[1, 2, 3, 4]` to `[0, 4)` of address space `2`. - - We _create_ subsegments `[0, 1)`, `[1, 2)`, `[2, 3)`, `[3, 4)` at time `0`: - - ← `[(2, 0), (0), 0]`. - - ← `[(2, 1), (0), 0]`. - - ← `[(2, 2), (0), 0]`. - - ← `[(2, 3), (0), 0]`. - - We _merge_ the first pair together and also the second pair together: - - → `[(2, 0), (0), 0]`, → `[(2, 1), (0), 0]`, ← `[(2, 0), (0, 0), 0]`. - - → `[(2, 2), (0), 0]`, → `[(2, 3), (0), 0]`, ← `[(2, 2), (0, 0), 0]`. - - We _merge_ the two segments we have into one: - - → `[(2, 0), (0, 0), 0]`, → `[(2, 2), (0, 0), 0]`, ← `[(2, 0), (0, 0, 0, 0), 0]`. - - _Basic interaction_: we send the old data and receive the new data. - - → `[(2, 0), (0, 0, 0, 0), 0]`. - - ← `[(2, 0), (1, 2, 3, 4), 1]`. -- Write `[5, 6, 7, 8]` to `[4, 8)` of address space `2`. - - We do the same steps as above: - - ← `[(2, 4), (0), 0]`. - - ← `[(2, 5), (0), 0]`. - - ← `[(2, 6), (0), 0]`. - - ← `[(2, 7), (0), 0]`. - - → `[(2, 4), (0), 0]`, → `[(2, 5), (0), 0]`, ← `[(2, 4), (0, 0), 0]`. - - → `[(2, 6), (0), 0]`, → `[(2, 7), (0), 0]`, ← `[(2, 6), (0, 0), 0]`. - - → `[(2, 4), (0, 0), 0]`, → `[(2, 6), (0, 0), 0]`, ← `[(2, 4), (0, 0, 0, 0), 0]`. - - _Basic interaction_: we send the old data and receive the new data. Notice the new timestamp. - - → `[(2, 4), (0, 0, 0, 0), 0]`. - - ← `[(2, 4), (5, 6, 7, 8), 2]`. -- Read `[3, 4, 5, 6]` from `[2, 6)` of address space `2`. - - Now we have subsegments `[0, 4)` and `[4, 8)` in our nice set. We need to split each of them in two, and then merge the middle two parts. - First we _split_ the left. Notice that the timestamps of the new parts are the same as the timestamp of the original segment: - - → `[(2, 0), (1, 2, 3, 4), 1]`, ← `[(2, 0), (1, 2), 1]`, ← `[(2, 2), (3, 4), 1]`. - - Then we _split_ the right: - - → `[(2, 4), (5, 6, 7, 8), 2]`, ← `[(2, 4), (5, 6), 2]`, ← `[(2, 6), (7, 8), 2]`. - - Finally, we _merge_ the middle two segments, making the new timestamp the maximum of the previous two: - - → `[(2, 2), (3, 4), 1]`, → `[(2, 6), (7, 8), 2]`, ← `[(2, 2), (3, 4, 5, 6), 2]`. - - _Basic interaction_: we send the old data and receive it again, but with the new timestamp. - - → `[(2, 2), (3, 4, 5, 6), 2]`. - - ← `[(2, 2), (3, 4, 5, 6), 3]`. - -One can see that the splits and merges mostly balance each other out -- more formally, each subsegment in the nice set, be it born or annihilated by split or merge, corresponds to a receive (→) interaction on birth and a send (←) interaction on death. - -## Boundary chips - -However, the only unaccounted for interactions are the initial birth of a segment and the final memory state. We use **boundary chips** to handle them. - -In **volatile** memory, we use `VolatileBoundaryChip` to handle the initial memory state. It does the following: -- The chip assumes that all initial memory is filled with zeroes. -- However, **initial memory is unconstrained** -- so the result of such program's execution is going to be something along the lines of "there is some way to fill the initial memory that this program finishes correctly". - -In **persistent** memory, we use `PersistentBoundaryChip` to handle the final memory state. It does the following: -- There is some initial memory specified in the program. -- The chip _commits_ to the initial memory -- see below. - -Both boundary chips perform, for every subsegment ever existed in our nice set, a receive interaction on birth and a send interaction on death. +Every instruction executor does this via the **memory controller** API. + +## Memory boundary chip + +The only unaccounted for interactions are the initial birth of a segment and the final memory state. We use the **memory boundary chip** (`PersistentBoundaryChip`) to handle them. + +The `PersistentBoundaryChip` commits to both the initial and final memory state. The initial memory is provided as part of the program, and the chip produces commitments (Merkle roots) for both the initial and final states. These commitments become part of the public values used later in proof aggregation (see [Continuations](/specs/architecture/continuations)). + +The memory boundary chip performs, for every touched memory chunk, a send interaction on birth and a receive interaction on death. ## Invariants @@ -168,9 +83,7 @@ The following invariants **must** be maintained by the memory architecture: Invariant 1 is guaranteed by [time goes forward](#time-goes-forward) under the [assumption](/specs/architecture/circuit-architecture#instruction-executors) that the timestamp increase during instruction execution is bounded by the number of AIR interactions. -Invariant 2 and 3 are guaranteed at timestamp `0` in the MEMORY_BUS by the boundary chips: -- VolatileBoundaryChip constrains the range checks outright. -- PersistentBoundaryChip populates the MEMORY_BUS at timestamp `0` from the initial memory state, which is committed to in the public value `initial_memory_root`. PersistentBoundaryChip upholds Invariants 2 and 3 **assuming** that the initial memory state only contains addresses in the required range. This assumption needs to be checked outside the scope of the circuit. +Invariants 2 and 3 are guaranteed at timestamp `0` in the MEMORY_BUS by the memory boundary chip: `PersistentBoundaryChip` populates the MEMORY_BUS at timestamp `0` from the initial memory state, which is committed to in the public value `initial_memory_root`. The chip upholds Invariants 2 and 3 **assuming** that the initial memory state only contains addresses in the required range. This assumption needs to be checked outside the scope of the circuit. :::warning At all later timestamps, it is the responsibility of each chip to ensure their memory accesses maintain Invariants 2 and 3. @@ -183,87 +96,47 @@ We note an observation that may be useful in soundness analysis of instruction e Assume that the MEMORY_BUS interactions and the constraints mentioned above are satisfied. ### Time goes forward - + In the connector chip, we constrain that the final timestamp is less than $`2^\text{timestamp\_max\_bits}`$ and that the start timestamp is equal to `1`. It is [guaranteed](https://github.com/openvm-org/stark-backend/blob/main/docs/interactions.md) that the total number of interaction messages is less than $p$. In our current circuit set, all chips increase timestamp [less than they do interactions](/specs/architecture/circuit-architecture#inspection-of-vm-chip-timestamp-increments), which guarantees that the final timestamp cannot overflow: its actual (not mod $p$) value is less than $`2^\text{timestamp\_max\_bits}`$. Given that, our check that `timestamp - prev_timestamp - 1 < 2^timestamp_max_bits` guarantees that `prev_timestamp < timestamp` everywhere we check it. ### Memory consistency To show that memory is consistent, consider any interactions with segments containing some `address`. They can be done by: -- Boundary chip: one send with the initial timestamp and some value at this address, one receive with the final timestamp and some value at this address. The fact that there is only one send/receive is guaranteed by the fact that we ensure in the boundary chip that all the addresses are distinct. -- Access adapter: each row corresponds to a merge or a split, and therefore for each row, if its split/merged segment contains `address`, we have exactly one send and exactly one receive corresponding to this row. They have the same value at this address, and the send timestamp is at least the receive timestamp -- and strictly greater unless these operations are within one memory access. +- Memory boundary chip: one send with the initial timestamp and some value at this address, one receive with the final timestamp and some value at this address. The fact that there is only one send/receive is guaranteed by the fact that we ensure in the memory boundary chip that all the addresses are distinct. - Instruction executors via memory bridge: one receive with the previous timestamp and some value at this address, one send with the new timestamp and some value at this address. We also have `prev_timestamp < timestamp`. -To prove memory consistency, we need to show that, if we only consider basic interactions and boundary interactions, then accessing an address always gives us something that has the last value observed at this address (in a broad sense: for example, this includes "writing to `[3, 5)` generates a record where previous data at `4` is the last value written to or read from `4`, be it from `[4, 5)`, `[2, 10)` or any other segment containing `4`"). In other words, for every receive interaction with timestamp $t$ and value $v$ corresponding to this address, the value $v$ is the value from any _basic_ (not split/merge) send interaction with the greatest existing timestamp $t'$ less than $t$. - -For every row that gets handled by a memory bridge, draw a directed edge from the previous timestamp to the new timestamp with capacity $1$. We know that in the obtained network, where the source and the sink are defined by the boundary interactions, all edges go left to right, and the maximal flow is $1$ (because there is only one edge from the source, therefore the minimal cut is $1$). Since all edges go left to right, there are no circulation in this network. Hence, all edges represent exactly one path from the source to the sink. Therefore, for every vertex (which is a timestamp), the value for the edge going to this vertex (the last receive interaction) equals the value for the edge going from this vertex (the considered send instruction). +To prove memory consistency, we need to show that accessing an address always gives us the last value observed at that address. In other words, for every receive interaction with timestamp $t$ and value $v$ corresponding to this address, the value $v$ is the value from the send interaction with the greatest timestamp $t'$ less than $t$. -:::info -Technically, it is possible to add artificial rows in the access adapter AIRs that do nothing: for example, the one corresponding to splitting a segment `[7, 11)` into two and the one merging it back, all at the same timestamp and with the same data completely unrelated to the actual execution. However, this cannot be abused by memory accesses: informally, because this kind of happens at the same time and nobody gets to read these values, and formally, because even if a flow has a circulation, it still can be decomposed into paths and a circulation, and we only consider the path in the argument above. -::: +For every row that gets handled by a memory bridge, draw a directed edge from the previous timestamp to the new timestamp with capacity $1$. We know that in the obtained network, where the source and the sink are defined by the boundary interactions, all edges go left to right, and the maximal flow is $1$ (because there is only one edge from the source, therefore the minimal cut is $1$). Since all edges go left to right, there is no circulation in this network. Hence, all edges represent exactly one path from the source to the sink. Therefore, for every vertex (which is a timestamp), the value for the edge going to this vertex (the last receive interaction) equals the value for the edge going from this vertex (the considered send instruction). -## Volatile and persistent memory +## The `PersistentBoundaryChip` -There are two memory interfaces: **volatile** and **persistent**. From the memory POV, the difference is: -- In volatile memory, both initial and final memory are unconstrained. -- In persistent memory, we commit to the initial memory and to the final memory. These commitments are used for establishing memory consistency between segments. +The `PersistentBoundaryChip` commits to both the initial and final memory state, making these commitments available as public values for proof aggregation. -### Volatile Memory: `VolatileBoundaryChip` - -- **Purpose:** - In volatile memory, we assume that the initial memory is filled with zeros and that it is unconstrained. The `VolatileBoundaryChip` is used mainly for bookkeeping: it tracks the starting state of memory without enforcing a cryptographic commitment. This means that when a program begins execution, the chip simply "accepts" the initial (zeroed) memory without additional checks. - -- **Key Points:** - - **No Commitment:** - The chip does not compute a Merkle tree root for the initial memory state. Instead, any memory value that gets revealed later comes directly from the execution trace. - - **Distinctness Check:** - It ensures that the addresses used are distinct by enforcing a sort order across boundary records. - -For instance, this is how distinctness is enforced: - -```rust -// Assert local addr < next addr when next.is_valid -// This ensures the addresses in non-padding rows are all sorted -let lt_io = IsLtArrayIo { - x: [local.addr_space, local.pointer].map(Into::into), - y: [next.addr_space, next.pointer].map(Into::into), - out: AB::Expr::ONE, - count: next.is_valid.into(), -}; -// N.B.: this will do range checks (but not other constraints) on the last row if the first row has is_valid = 1 due to wraparound -self.addr_lt_air - .eval(builder, (lt_io, (&local.addr_lt_aux).into())); -``` +- **Commitments:** + The chip takes the initial memory (provided as part of the program) and computes a commitment over it by incorporating it into a Merkle tree. When the segment finishes, the chip produces a final commitment (Merkle root) that reflects every change made during execution. +- **Field: Expand Direction:** + Each memory chunk is tagged with an `expand_direction` field: + - `expand_direction = 1` indicates a boundary row representing the initial memory state. + - `expand_direction = -1` indicates a boundary row representing the final memory state. + - `expand_direction = 0` marks rows that are not relevant (padding rows where all interaction multiplicities are zero). +- **Multiple Buses:** + To enforce these commitments, the `PersistentBoundaryChip` interacts with three buses: + - **Merkle Bus:** + For initial memory rows, it sends a record with `expand_direction = 1`, and for final memory rows, it receives a record with `expand_direction = -1`. This allows the Merkle chip to build and later verify a full commitment over the memory. + - **Compression Bus:** + It sends the values and hash arrays for each chunk. The multiplicity of these interactions is determined by the square of the `expand_direction` (so that both initial and final rows are treated uniformly in the compression process). + - **Memory Bus:** + It performs the basic send/receive interactions that balance out each memory operation, similar to the ones described in the "Basic performed interactions" section. -### Persistent Memory: `PersistentBoundaryChip` - -- **Purpose:** - When operating in persistent memory mode, the final state of memory must be verifiable. The `PersistentBoundaryChip` commits not only to the final memory state but also to the initial state provided by the program. These commitments become part of the public values used later in proof aggregation, see [Continuations](/specs/architecture/continuations). - -- **Key Points:** - - **Commitments:** - The chip takes the initial memory (which is provided as part of the program) and computes a commitment over it—typically by incorporating it into a Merkle tree. Later, when the segment finishes, the chip produces a final commitment (Merkle root) that reflects every change made during execution. - - **Field: Expand Direction:** - Each memory chunk is tagged with an `expand_direction` field: - - `expand_direction = 1` indicates a boundary row representing the initial memory state. - - `expand_direction = -1` indicates a boundary row representing the final memory state. - - `expand_direction = 0` marks rows that are not relevant (for example, intermediary rows produced by splits/merges that cancel out). - - **Multiple Buses:** - To enforce these commitments, the PersistentBoundaryChip interacts with three buses: - - **Merkle Bus:** - For initial memory rows, it sends a record (for example, with a tag `0`), and for final memory rows, it receives a record (with a tag `1`). This allows the Merkle chip to build and later verify a full commitment over the memory. - - **Compression Bus:** - It sends the values and hash arrays for each chunk. The multiplicity of these interactions is determined by the square of the `expand_direction` (so that both initial and final rows are treated uniformly in the compression process). - - **Memory Bus:** - It performs the basic send/receive interactions that balance out each memory operation, similar to the ones described in the “Basic performed interactions” section. - -The uniqueness of the addresses is achieved by the interactions on the merkle bus. The other chip that does interactions there is the **merkle chip**, which build the merkle tree, and to balance everything out, the boundary chip's interactions must correspond to the leaves of the merkle tree, thus, all distinct. +The uniqueness of the addresses is achieved by the interactions on the merkle bus. The other chip that does interactions there is the **merkle chip**, which builds the merkle tree, and to balance everything out, the memory boundary chip's interactions must correspond to the leaves of the merkle tree, thus, all distinct. ## Implementation details In this model, there is no central memory/offline checker AIR. Every chip is responsible for doing the necessary interactions discussed above for its memory operations. For this, every chip's AIR must have some auxiliary columns for every memory operation. The auxiliary columns include `prev_timestamp` and, for Write operations, `prev_data`. -When we use Volatile Memory as the Memory Interface (PersistentBoundaryAir in the implementation), we do not, at the AIR level, constrain the initial memory. This means that if the first operation on an address is a Read, the corresponding data can be anything -- it's up to the program to read from addresses that have been written to. +The initial memory state is constrained at the AIR level by the `PersistentBoundaryChip`, which commits to it via the `initial_memory_root` Merkle root (a public value) and sends initial values on the memory bus at timestamp $0$. ## What to take into account when adding a new chip diff --git a/extensions/ecc/circuit/src/weierstrass_chip/tests.rs b/extensions/ecc/circuit/src/weierstrass_chip/tests.rs index 2f2aa1220b..32e09394a9 100644 --- a/extensions/ecc/circuit/src/weierstrass_chip/tests.rs +++ b/extensions/ecc/circuit/src/weierstrass_chip/tests.rs @@ -111,7 +111,6 @@ mod ec_addne_tests { WeierstrassChip, >; - fn create_harness( tester: &VmChipTestBuilder, config: ExprBuilderConfig, @@ -214,7 +213,6 @@ mod ec_addne_tests { GpuTestChipHarness::with_capacity(executor, air, hybrid_chip, cpu_chip, MAX_INS_CAPACITY) } - #[allow(clippy::too_many_arguments)] fn set_and_execute_ec_addne< const BLOCKS: usize, @@ -415,11 +413,7 @@ mod ec_addne_tests { } #[cfg(feature = "cuda")] - fn run_cuda_ec_addne< - const BLOCKS: usize, - const BLOCK_SIZE: usize, - const NUM_LIMBS: usize, - >( + fn run_cuda_ec_addne( offset: usize, modulus: BigUint, ) { @@ -560,8 +554,6 @@ mod ec_double_tests { MatrixRecordArena, >; - - fn create_harness( tester: &VmChipTestBuilder, config: ExprBuilderConfig, @@ -671,7 +663,6 @@ mod ec_double_tests { GpuTestChipHarness::with_capacity(executor, air, hybrid_chip, cpu_chip, MAX_INS_CAPACITY) } - #[allow(clippy::too_many_arguments)] fn set_and_execute_ec_double< const BLOCKS: usize, diff --git a/extensions/keccak256/circuit/src/keccakf_op/tests.rs b/extensions/keccak256/circuit/src/keccakf_op/tests.rs index e3d1a35c81..85dc26ec20 100644 --- a/extensions/keccak256/circuit/src/keccakf_op/tests.rs +++ b/extensions/keccak256/circuit/src/keccakf_op/tests.rs @@ -261,7 +261,11 @@ fn cuda_set_and_execute( let buffer_reg = gen_pointer(rng, 4); let buffer_ptr = gen_pointer(rng, KECCAK_STATE_BYTES); - tester.write(1, buffer_reg, buffer_ptr.to_le_bytes().map(F::from_u8)); + tester.write( + 1, + buffer_reg, + (buffer_ptr as u32).to_le_bytes().map(F::from_u8), + ); let state_data: Vec = (0..KECCAK_STATE_BYTES).map(|_| rng.random()).collect(); for (i, chunk) in state_data.chunks(4).enumerate() { @@ -367,7 +371,11 @@ fn test_keccakf_cuda_tracegen_zero_state() { let buffer_reg = gen_pointer(&mut rng, 4); let buffer_ptr = gen_pointer(&mut rng, KECCAK_STATE_BYTES); - tester.write(1, buffer_reg, buffer_ptr.to_le_bytes().map(F::from_u8)); + tester.write( + 1, + buffer_reg, + (buffer_ptr as u32).to_le_bytes().map(F::from_u8), + ); for i in 0..(KECCAK_STATE_BYTES / 4) { tester.write(2, buffer_ptr + i * 4, [F::ZERO; 4]); diff --git a/extensions/keccak256/circuit/src/xorin/tests.rs b/extensions/keccak256/circuit/src/xorin/tests.rs index 920ca85f92..1353601fcc 100644 --- a/extensions/keccak256/circuit/src/xorin/tests.rs +++ b/extensions/keccak256/circuit/src/xorin/tests.rs @@ -309,8 +309,16 @@ fn cuda_set_and_execute( let buffer_ptr = gen_pointer(rng, len); let input_ptr = gen_pointer(rng, len); - tester.write(1, buffer_reg, buffer_ptr.to_le_bytes().map(F::from_u8)); - tester.write(1, input_reg, input_ptr.to_le_bytes().map(F::from_u8)); + tester.write( + 1, + buffer_reg, + (buffer_ptr as u32).to_le_bytes().map(F::from_u8), + ); + tester.write( + 1, + input_reg, + (input_ptr as u32).to_le_bytes().map(F::from_u8), + ); tester.write(1, len_reg, (len as u32).to_le_bytes().map(F::from_u8)); let buffer_data: Vec = (0..len).map(|_| rng.random()).collect(); diff --git a/extensions/rv32-adapters/src/vec_heap_branch.rs b/extensions/rv32-adapters/src/vec_heap_branch.rs index 199eb888bf..aa30b28828 100644 --- a/extensions/rv32-adapters/src/vec_heap_branch.rs +++ b/extensions/rv32-adapters/src/vec_heap_branch.rs @@ -127,9 +127,8 @@ impl< // range checks constrain to RV32_CELL_BITS bits, so we need to shift the limbs to constrain // the correct amount of bits - let limb_shift = AB::F::from_usize( - 1 << (RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - self.address_bits), - ); + let limb_shift = + AB::F::from_usize(1 << (RV32_CELL_BITS * RV32_REGISTER_NUM_LIMBS - self.address_bits)); for pair in need_range_check.chunks(2) { self.bus diff --git a/extensions/rv32im/circuit/Cargo.toml b/extensions/rv32im/circuit/Cargo.toml index b3a0761eb5..32107f8cd4 100644 --- a/extensions/rv32im/circuit/Cargo.toml +++ b/extensions/rv32im/circuit/Cargo.toml @@ -65,4 +65,3 @@ touchemall = [ "openvm-cuda-backend/touchemall", "openvm-cuda-common/touchemall", ] -legacy-v1-3-mem-align = [] diff --git a/extensions/rv32im/circuit/src/adapters/loadstore.rs b/extensions/rv32im/circuit/src/adapters/loadstore.rs index ce57f36dd6..e7fac1552b 100644 --- a/extensions/rv32im/circuit/src/adapters/loadstore.rs +++ b/extensions/rv32im/circuit/src/adapters/loadstore.rs @@ -27,7 +27,7 @@ use openvm_instructions::{ instruction::Instruction, program::DEFAULT_PC_STEP, riscv::{RV32_IMM_AS, RV32_MEMORY_AS, RV32_REGISTER_AS}, - LocalOpcode, DEFERRAL_AS, + LocalOpcode, }; use openvm_rv32im_transpiler::Rv32LoadStoreOpcode::{self, *}; use openvm_stark_backend::{ @@ -456,6 +456,7 @@ where STOREW | STOREH | STOREB => { let imm_extended = record.imm as u32 + record.imm_sign as u32 * 0xffff0000; let ptr = record.rs1_val.wrapping_add(imm_extended) & !3; + timed_write(memory, record.mem_as as u32, ptr, data.map(|x| x as u8)).0 } LOADW | LOADB | LOADH | LOADBU | LOADHU => { diff --git a/extensions/rv32im/circuit/src/adapters/mod.rs b/extensions/rv32im/circuit/src/adapters/mod.rs index 36f3996118..cf370b3f0d 100644 --- a/extensions/rv32im/circuit/src/adapters/mod.rs +++ b/extensions/rv32im/circuit/src/adapters/mod.rs @@ -112,16 +112,7 @@ pub fn timed_read( // SAFETY: // - address space `RV32_REGISTER_AS` and `RV32_MEMORY_AS` will always have cell type `u8` and // minimum alignment of `RV32_REGISTER_NUM_LIMBS` - #[cfg(feature = "legacy-v1-3-mem-align")] - if address_space == RV32_MEMORY_AS { - unsafe { memory.read::(address_space, ptr) } - } else { - unsafe { memory.read::(address_space, ptr) } - } - #[cfg(not(feature = "legacy-v1-3-mem-align"))] - unsafe { - memory.read::(address_space, ptr) - } + unsafe { memory.read::(address_space, ptr) } } #[inline(always)] @@ -140,16 +131,7 @@ pub fn timed_write( // SAFETY: // - address space `RV32_REGISTER_AS` and `RV32_MEMORY_AS` will always have cell type `u8` and // minimum alignment of `RV32_REGISTER_NUM_LIMBS` - #[cfg(feature = "legacy-v1-3-mem-align")] - if address_space == RV32_MEMORY_AS { - unsafe { memory.write::(address_space, ptr, data) } - } else { - unsafe { memory.write::(address_space, ptr, data) } - } - #[cfg(not(feature = "legacy-v1-3-mem-align"))] - unsafe { - memory.write::(address_space, ptr, data) - } + unsafe { memory.write::(address_space, ptr, data) } } /// Reads register value at `reg_ptr` from memory and records the memory access in mutable buffer. diff --git a/extensions/rv32im/circuit/src/base_alu/tests.rs b/extensions/rv32im/circuit/src/base_alu/tests.rs index 611ca349c5..515e098425 100644 --- a/extensions/rv32im/circuit/src/base_alu/tests.rs +++ b/extensions/rv32im/circuit/src/base_alu/tests.rs @@ -187,47 +187,6 @@ fn rand_rv32_alu_test(opcode: BaseAluOpcode, num_ops: usize) { tester.simple_test().expect("Verification failed"); } -#[test_case(ADD, 100)] -#[test_case(SUB, 100)] -#[test_case(XOR, 100)] -#[test_case(OR, 100)] -#[test_case(AND, 100)] -fn rand_rv32_alu_test_persistent(opcode: BaseAluOpcode, num_ops: usize) { - let mut rng = create_seeded_rng(); - - let mut tester = VmChipTestBuilder::default_persistent(); - let (mut harness, bitwise) = create_harness(&tester); - - // TODO(AG): make a more meaningful test for memory accesses - tester.write(2, 1024, [F::ONE; 4]); - tester.write(2, 1028, [F::ONE; 4]); - // Avoid wider-than-min-block accesses when access adapters are disabled - let sm1 = tester.read(2, 1024); - let sm2 = tester.read(2, 1028); - assert_eq!(sm1, [F::ONE; 4]); - assert_eq!(sm2, [F::ONE; 4]); - - for _ in 0..num_ops { - set_and_execute( - &mut tester, - &mut harness.executor, - &mut harness.arena, - &mut rng, - opcode, - None, - None, - None, - ); - } - - let tester = tester - .build() - .load(harness) - .load_periphery(bitwise) - .finalize(); - tester.simple_test().expect("Verification failed"); -} - ////////////////////////////////////////////////////////////////////////////////////// // NEGATIVE TESTS // diff --git a/extensions/rv32im/circuit/src/loadstore/aot.rs b/extensions/rv32im/circuit/src/loadstore/aot.rs index d248d6506d..110f9e7c21 100644 --- a/extensions/rv32im/circuit/src/loadstore/aot.rs +++ b/extensions/rv32im/circuit/src/loadstore/aot.rs @@ -5,7 +5,7 @@ use openvm_circuit::arch::{ use openvm_instructions::{ instruction::Instruction, riscv::{RV32_IMM_AS, RV32_REGISTER_AS}, - LocalOpcode, DEFERRAL_AS, + LocalOpcode, }; use openvm_rv32im_transpiler::Rv32LoadStoreOpcode; use openvm_stark_backend::p3_field::PrimeField32; @@ -86,6 +86,13 @@ where } } +fn is_aot_supported_impl( + _inst: &openvm_instructions::instruction::Instruction, +) -> bool { + true +} + + // arguments of `update_boundary_merkle_heights_f`: // address_space: u32, // pc: u32, @@ -122,7 +129,6 @@ fn generate_x86_asm_impl( let imm = c.as_canonical_u32(); let imm_sign = g.as_canonical_u32(); let imm_extended = (imm + imm_sign * 0xffff0000) as i32; - let a = a.as_canonical_u32() as u8; let b = b.as_canonical_u32() as u8; let a_reg = a / 4; diff --git a/extensions/rv32im/circuit/src/loadstore/execution.rs b/extensions/rv32im/circuit/src/loadstore/execution.rs index 0dc1d218e5..e1f1284f8f 100644 --- a/extensions/rv32im/circuit/src/loadstore/execution.rs +++ b/extensions/rv32im/circuit/src/loadstore/execution.rs @@ -13,7 +13,7 @@ use openvm_instructions::{ instruction::Instruction, program::DEFAULT_PC_STEP, riscv::{RV32_IMM_AS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS}, - LocalOpcode, DEFERRAL_AS, + LocalOpcode, }; use openvm_rv32im_transpiler::Rv32LoadStoreOpcode::{self, *}; use openvm_stark_backend::p3_field::PrimeField32; @@ -72,7 +72,6 @@ impl LoadStoreExecutor { let imm = c.as_canonical_u32(); let imm_sign = g.as_canonical_u32(); let imm_extended = imm + imm_sign * 0xffff0000; - *data = LoadStorePreCompute { imm_extended, a: a.as_canonical_u32() as u8, diff --git a/extensions/rv32im/circuit/src/loadstore/tests.rs b/extensions/rv32im/circuit/src/loadstore/tests.rs index 9374d8c912..8aa91de439 100644 --- a/extensions/rv32im/circuit/src/loadstore/tests.rs +++ b/extensions/rv32im/circuit/src/loadstore/tests.rs @@ -2,7 +2,7 @@ use std::{array, borrow::BorrowMut, sync::Arc}; use openvm_circuit::{ arch::{ - testing::{memory::gen_pointer, TestBuilder, TestChipHarness, VmChipTestBuilder}, + testing::{TestBuilder, TestChipHarness, VmChipTestBuilder}, Arena, ExecutionBridge, MemoryConfig, PreflightExecutor, }, system::memory::{ @@ -34,6 +34,7 @@ use { }, EmptyAdapterCoreLayout, }, + openvm_instructions::riscv::RV32_MEMORY_AS, }; use super::{run_write_data, LoadStoreCoreAir, Rv32LoadStoreChip}; @@ -123,8 +124,9 @@ fn set_and_execute>( let ptr_val: u32 = rng.random_range(0..(1 << (tester.address_bits() - alignment))) << alignment; let rs1 = rs1.unwrap_or(ptr_val.wrapping_sub(imm_ext).to_le_bytes()); let ptr_val = imm_ext.wrapping_add(u32::from_le_bytes(rs1)); - let a = gen_pointer(rng, 4); - let b = gen_pointer(rng, 4); + let max_addr = 1usize << tester.address_bits(); + let a = rng.random_range(0..(max_addr - 4)) / 4 * 4; + let b = rng.random_range(0..(max_addr - 4)) / 4 * 4; let is_load = [LOADW, LOADHU, LOADBU].contains(&opcode); let mem_as = mem_as.unwrap_or(if is_load { @@ -214,9 +216,9 @@ fn rand_loadstore_test(opcode: Rv32LoadStoreOpcode, num_ops: usize) { if [STOREW, STOREB, STOREH].contains(&opcode) { mem_config.addr_spaces[PUBLIC_VALUES_AS as usize].num_cells = 1 << 29; } - // Use persistent memory so initial block size matches the 4-byte alignment and + // Use custom memory config so initial block size matches the 4-byte alignment and // avoids access-adapter split/merge paths when adapters are disabled. - let mut tester = VmChipTestBuilder::persistent(mem_config); + let mut tester = VmChipTestBuilder::from_config(mem_config); let mut harness = create_harness(&mut tester); for _ in 0..num_ops { @@ -267,8 +269,8 @@ fn run_negative_loadstore_test( if [STOREW, STOREB, STOREH].contains(&opcode) { mem_config.addr_spaces[PUBLIC_VALUES_AS as usize].num_cells = 1 << 29; } - // Use persistent memory so the min block size matches alignment without needing adapters. - let mut tester = VmChipTestBuilder::persistent(mem_config); + // Use custom memory config so the min block size matches alignment without needing adapters. + let mut tester = VmChipTestBuilder::from_config(mem_config); let mut harness = create_harness(&mut tester); set_and_execute( @@ -537,12 +539,18 @@ fn create_cuda_harness(tester: &GpuChipTestBuilder) -> GpuHarness { #[test_case(STOREH, 100)] fn test_cuda_rand_load_store_tracegen(opcode: Rv32LoadStoreOpcode, num_ops: usize) { let mut rng = create_seeded_rng(); - let mut mem_config = MemoryConfig::default(); - mem_config.addr_spaces[RV32_REGISTER_AS as usize].num_cells = 1 << 29; + let mut mem_config = MemoryConfig { + pointer_max_bits: 20, + ..Default::default() + }; + // Reduce pointer_max_bits and num_cells to avoid ~4GB Merkle tree GPU allocations. + // Merkle trees are now always built (volatile path was removed with access adapters). + mem_config.addr_spaces[RV32_REGISTER_AS as usize].num_cells = 1 << 20; + mem_config.addr_spaces[RV32_MEMORY_AS as usize].num_cells = 1 << 20; if [STOREW, STOREB, STOREH].contains(&opcode) { - mem_config.addr_spaces[PUBLIC_VALUES_AS as usize].num_cells = 1 << 29; + mem_config.addr_spaces[PUBLIC_VALUES_AS as usize].num_cells = 1 << 20; } - let mut tester = GpuChipTestBuilder::volatile(mem_config, default_var_range_checker_bus()); + let mut tester = GpuChipTestBuilder::new(mem_config, default_var_range_checker_bus()); let mut harness = create_cuda_harness(&tester); for _ in 0..num_ops { diff --git a/guest-libs/keccak256/src/lib.rs b/guest-libs/keccak256/src/lib.rs index da967389fc..9927dc0a04 100644 --- a/guest-libs/keccak256/src/lib.rs +++ b/guest-libs/keccak256/src/lib.rs @@ -1,21 +1,19 @@ #![no_std] +#[cfg(any(target_os = "zkvm", feature = "tiny_keccak"))] use openvm_keccak256_guest::KECCAK_OUTPUT_SIZE; -#[cfg(not(any(target_os = "zkvm", feature = "tiny_keccak")))] -compile_error!("Keccak256 requires the 'tiny_keccak' feature to be enabled on non-zkvm targets"); - -#[cfg(not(target_os = "zkvm"))] +#[cfg(all(not(target_os = "zkvm"), feature = "tiny_keccak"))] mod host_impl; #[cfg(target_os = "zkvm")] mod zkvm_impl; -#[cfg(not(target_os = "zkvm"))] +#[cfg(all(not(target_os = "zkvm"), feature = "tiny_keccak"))] pub use host_impl::{set_keccak256, Keccak256}; #[cfg(target_os = "zkvm")] pub use zkvm_impl::{native_keccak256, set_keccak256, Keccak256}; -#[cfg(feature = "tiny_keccak")] +#[cfg(all(not(target_os = "zkvm"), feature = "tiny_keccak"))] impl tiny_keccak::Hasher for Keccak256 { #[inline(always)] fn update(&mut self, input: &[u8]) { @@ -29,6 +27,7 @@ impl tiny_keccak::Hasher for Keccak256 { } /// Computes the keccak256 hash of the input. +#[cfg(any(target_os = "zkvm", feature = "tiny_keccak"))] #[inline(always)] pub fn keccak256(input: &[u8]) -> [u8; KECCAK_OUTPUT_SIZE] { let mut output = [0u8; KECCAK_OUTPUT_SIZE]; diff --git a/guest-libs/keccak256/tests/lib.rs b/guest-libs/keccak256/tests/lib.rs index 14133b61e3..fb242b88ef 100644 --- a/guest-libs/keccak256/tests/lib.rs +++ b/guest-libs/keccak256/tests/lib.rs @@ -15,10 +15,10 @@ mod tests { use openvm_rv32im_transpiler::{ Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension, }; - use sdk_v2::StdIn; use openvm_stark_sdk::p3_baby_bear::BabyBear; use openvm_toolchain_tests::{build_example_program_at_path, get_programs_dir}; use openvm_transpiler::{transpiler::Transpiler, FromElf}; + use sdk_v2::StdIn; type F = BabyBear; diff --git a/guest-libs/sha2/src/lib.rs b/guest-libs/sha2/src/lib.rs index d557e88c61..935cc808ed 100644 --- a/guest-libs/sha2/src/lib.rs +++ b/guest-libs/sha2/src/lib.rs @@ -1,17 +1,14 @@ #![no_std] -#[cfg(not(any(target_os = "zkvm", feature = "import_sha2")))] -compile_error!("openvm-sha2 requires the 'import_sha2' feature to be enabled on non-zkvm targets"); - #[cfg(feature = "import_sha2")] pub use sha2::Digest; -#[cfg(not(target_os = "zkvm"))] +#[cfg(all(not(target_os = "zkvm"), feature = "import_sha2"))] mod host_impl; #[cfg(target_os = "zkvm")] mod zkvm_impl; -#[cfg(not(target_os = "zkvm"))] +#[cfg(all(not(target_os = "zkvm"), feature = "import_sha2"))] pub use host_impl::*; #[cfg(target_os = "zkvm")] pub use zkvm_impl::*; diff --git a/guest-libs/sha2/tests/lib.rs b/guest-libs/sha2/tests/lib.rs index c2045a1644..690b903dae 100644 --- a/guest-libs/sha2/tests/lib.rs +++ b/guest-libs/sha2/tests/lib.rs @@ -9,12 +9,12 @@ mod tests { use openvm_rv32im_transpiler::{ Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension, }; - use sdk_v2::StdIn; use openvm_sha2_circuit::{Sha2Rv32Builder, Sha2Rv32Config}; use openvm_sha2_transpiler::Sha2TranspilerExtension; use openvm_stark_sdk::p3_baby_bear::BabyBear; use openvm_toolchain_tests::{build_example_program_at_path, get_programs_dir}; use openvm_transpiler::{transpiler::Transpiler, FromElf}; + use sdk_v2::StdIn; type F = BabyBear; From 04ee203fe6e41a27993d605b6ef8fffa8a254282 Mon Sep 17 00:00:00 2001 From: Jonathan Wang <31040440+jonathanpwang@users.noreply.github.com> Date: Mon, 9 Mar 2026 10:20:16 -0700 Subject: [PATCH 34/78] docs: update ISA docs for new keccak opcodes (#2515) closes INT-5911 --------- Co-authored-by: Claude Opus 4.6 --- .../acceleration-using-extensions/keccak.mdx | 9 ++++- .../pages/book/guest-libraries/keccak256.mdx | 18 +++++++-- .../architecture/circuit-architecture.mdx | 39 ++++++++++-------- docs/vocs/docs/pages/specs/openvm/isa.mdx | 40 +++++++++++++------ .../specs/reference/instruction-reference.mdx | 3 +- .../specs/reference/riscv-custom-code.mdx | 9 +++-- .../docs/pages/specs/reference/transpiler.mdx | 7 ++-- extensions/keccak256/guest/src/lib.rs | 2 +- extensions/sha2/guest/src/lib.rs | 4 +- 9 files changed, 86 insertions(+), 45 deletions(-) diff --git a/docs/vocs/docs/pages/book/acceleration-using-extensions/keccak.mdx b/docs/vocs/docs/pages/book/acceleration-using-extensions/keccak.mdx index a65a8939b2..d609000d69 100644 --- a/docs/vocs/docs/pages/book/acceleration-using-extensions/keccak.mdx +++ b/docs/vocs/docs/pages/book/acceleration-using-extensions/keccak.mdx @@ -1,8 +1,13 @@ # Keccak256 -The Keccak256 extension guest provides a function that is meant to be linked to other external libraries. The external libraries can use this function as a hook for the keccak-256 intrinsic. This is enabled only when the target is `zkvm`. +The Keccak256 extension guest provides functions that are meant to be linked to other external libraries. The external libraries can use these functions as hooks for the Keccak-256 intrinsics. This is enabled only when the target is `zkvm`. -- `native_keccak256(input: *const u8, len: usize, output: *mut u8)`: This function has `C` ABI. It takes in a pointer to the input, the length of the input, and a pointer to the output buffer. +We provide the following functions for the low-level Keccak sponge operations: +- `native_xorin(buffer: *mut u8, input: *const u8, len: usize)`: XORs `len` input bytes into a state buffer in-place. `len` must be a positive multiple of 4 and at most 136. +- `native_keccakf(buffer: *mut u8)`: Applies the keccak-f[1600] permutation in-place on a 200-byte state buffer. + +The `openvm-keccak256` guest library builds on these to provide `native_keccak256`, a C ABI function that implements the full Keccak-256 hash: +- `native_keccak256(input: *const u8, len: usize, output: *mut u8)`: Computes the Keccak-256 hash of `len` bytes at `input` and writes the 32-byte digest to `output`. In the external library, you can do the following: diff --git a/docs/vocs/docs/pages/book/guest-libraries/keccak256.mdx b/docs/vocs/docs/pages/book/guest-libraries/keccak256.mdx index 5964e9b260..38f168c779 100644 --- a/docs/vocs/docs/pages/book/guest-libraries/keccak256.mdx +++ b/docs/vocs/docs/pages/book/guest-libraries/keccak256.mdx @@ -1,13 +1,25 @@ # Keccak256 -The OpenVM Keccak256 guest library provides two functions for use in your guest code: +The OpenVM Keccak256 guest library (`openvm-keccak256`) provides access to an accelerated Keccak-256 hash function. +The library provides: - `keccak256(input: &[u8]) -> [u8; 32]`: Computes the Keccak-256 hash of the input data and returns it as an array of 32 bytes. -- `set_keccak256(input: &[u8], output: &mut [u8; 32])`: Sets the output to the Keccak-256 hash of the input data into the provided output buffer. +- `set_keccak256(input: &[u8], output: &mut [u8; 32])`: Computes the Keccak-256 hash of the input data into the provided output buffer. +- `Keccak256` struct: Implements the [`tiny_keccak::Hasher`](https://docs.rs/tiny-keccak/latest/tiny_keccak/trait.Hasher.html) trait for incremental hashing via `update` and `finalize` methods. + +The `Keccak256` struct can be used to incrementally hash a stream of bytes: +```rust +fn update(&mut self, data: &[u8]); +fn finalize(self, output: &mut [u8]); +``` See the full example [here](https://github.com/openvm-org/openvm/blob/main/examples/keccak/src/main.rs). -## Example +### Example + +The following example can be run as guest code or host code (i.e. run in the zkvm or natively). +To run with guest code, use `cargo openvm run`, and for host code use `cargo run`. +The implementation for `Keccak256` falls back to using `tiny_keccak` when running as host code. ```rust // [!include ~/snippets/examples/keccak/src/main.rs:imports] diff --git a/docs/vocs/docs/pages/specs/architecture/circuit-architecture.mdx b/docs/vocs/docs/pages/specs/architecture/circuit-architecture.mdx index f5cbde1e55..182277f732 100644 --- a/docs/vocs/docs/pages/specs/architecture/circuit-architecture.mdx +++ b/docs/vocs/docs/pages/specs/architecture/circuit-architecture.mdx @@ -103,7 +103,8 @@ The chips that fall into these categories are: | Name | timestamp_delta | # of interactions | Comment | | --------------------- | --------------- | ----------------- | ------------------------------------------------------------------------------------------------------------------------ | | PhantomChip | 1 | 3 | Case 2. No memory accesses, 3 interactions from program bus and execution bus. | -| KeccakVmChip | - | - | Case 2. Special timestamp jump. | +| XorinVmChip | - | - | Case 2. Special timestamp jump. | +| KeccakfOpChip | 51 | - | Case 2. 1 register read + 50 word writes. | | Rv32HintStoreChip | – | – | Case 1. | | Sha2VmChip | – | – | Case 1. | | DeferralOutputChip | – | – | Case 1. | @@ -113,23 +114,29 @@ The PhantomChip satisfies the condition because `1 < 3`. All the chips in Case 1 can use a variable number of trace rows to execute a single instruction, but the AIR constraints all maintain that the timestamp increments by 1 per memory access and this accounts for all increments of the timestamp. Therefore we have `timestamp_delta <= num_interactions * num_rows_per_execution / 4` in these cases. -##### KeccakVmChip +##### XorinVmChip -It remains to analyze KeccakVmChip. Here the `KeccakVmAir::timestamp_change` is `len + 45` where `len` -refers to the length of the input in bytes. This is an overestimate used to simplify AIR constraints -because the AIR cannot compute the non-algebraic expression `ceil(len / 136) * 20`. +The `XorinVmAir` timestamp change is `3 + 3 * num_words` where `num_words = len / 4` is the number +of non-padding 4-byte chunks (at most 34, since `len` is at most 136). The maximum timestamp change +is `3 + 3 * 34 = 105`. Each XORIN instruction uses 1 trace row. -In the AIR constraints : +In the AIR constraints: -- `constrain_absorb` adds at least `min(68, sponge.block_bytes.len())` interactions on the XOR bus. -- `eval_instruction` does an `execute_and_increment_pc` (3), 3 memory reads (12) and 2 lookups (2), giving a total of `17` interactions. -- `constrain_input_read` does 34 memory reads (136), -- `constrain_output_write` does 8 memory writes (32) +- `eval_instruction` does an `execute_and_increment_pc` (3), 3 register reads (12), and 2 range checks (2), giving 17 interactions. +- `constrain_input_read` does up to 34 input reads (136) and 34 buffer reads (136). +- `constrain_xor` does up to 136 XOR lookups on the bitwise lookup bus. +- `constrain_output_write` does up to 34 buffer writes (136). -In total, there are at least 253 interactions. +In total, there are at least `17 + 136 + 136 + 136 + 136 = 561` interactions per row when `num_words = 34`. +Since `timestamp_delta = 105 < 561 = num_interactions`, the condition is satisfied. -A single KECCAK256_RV32 instruction uses `ceil((len + 1) / 136) * 24` rows (where `NUM_ROUNDS = 24`). -We have shown that -``` -len + 45 < 253 * ceil((len + 1) / 136) * 24 <= num_interactions * num_rows_per_execution -``` +##### KeccakfOpChip + +The `KeccakfOpAir` timestamp delta is `51` (1 register read + 50 word writes). Each KECCAKF instruction uses +1 trace row in the `KeccakfOpAir` and 24 rows in the separate `KeccakfPermAir`. + +In the AIR constraints: + +- 1 `execute_and_increment_pc` (3), 1 register read (4), 1 pointer range check (1), 50 word writes (200), 100 byte range checks (50), and 2 keccakf state bus sends (2). + +In total, there are at least 260 interactions per row. Since `timestamp_delta = 51 < 260`, the condition is satisfied. diff --git a/docs/vocs/docs/pages/specs/openvm/isa.mdx b/docs/vocs/docs/pages/specs/openvm/isa.mdx index e6189e8ead..712a41afe3 100644 --- a/docs/vocs/docs/pages/specs/openvm/isa.mdx +++ b/docs/vocs/docs/pages/specs/openvm/isa.mdx @@ -4,8 +4,8 @@ OpenVM supports an extensible instruction set, with different groups of opcodes This specification describes the overall architecture and default VM extensions which ship with OpenVM, which are: - [RV32IM](#rv32im-extension): An extension supporting the 32-bit RISC-V ISA with multiplication. -- [Keccak-256](#keccak-extension): An extension implementing the Keccak-256 hash function compatibly with RISC-V memory. -- [SHA2](#sha-2-extension): An extension implementing the SHA-256 and SHA-512 hash functions compatibly with RISC-V memory. +- [Keccak-256](#keccak-extension): An extension implementing low-level Keccak sponge operations (XOR-in and keccak-f[1600] permutation) compatibly with RISC-V memory, used to implement the Keccak-256 hash function. +- [SHA2](#sha-2-extension): An extension implementing the SHA-256, SHA-384, and SHA-512 hash functions compatibly with RISC-V memory. - [BigInt](#bigint-extension): An extension supporting 256-bit signed and unsigned integer arithmetic, including multiplication. This extension respects the RISC-V memory format. - [Algebra](#algebra-extension): An extension supporting modular arithmetic over arbitrary fields and their complex @@ -134,10 +134,9 @@ to. Address space `0` is considered a read-only array with `[a]_0 = a` for any ` #### Memory Accesses and Block Accesses VM instructions can access (read or write) a contiguous list of cells (called a **block**) in a single address space. -The block size must be in the set `{1, 2, 4, 8, 16, 32}`, and each address space has a minimum block size that is -configurable. All block accesses must be at pointers that are a multiple of the minimum block size. For address -spaces `1`, `2`, `3`, and `4`, the minimum block size is 4, meaning all accesses must be at pointer addresses that are -divisible by 4. However, RISC-V instructions like `lb`, `lh`, `sb`, and `sh` still work despite having minimum +The block size is fixed to constant size `4` across all instructions in the ISA. +All block accesses must be at pointers that are a multiple of the block size (`4`). +However, RISC-V instructions like `lb`, `lh`, `sb`, and `sh` still work despite having minimum block size requirements equal to the size of the access (1 byte for `lb`/`sb`, 2 bytes for `lh`/`sh`) because these instructions are implemented by doing a block access of size 4. Block accesses are not supported for address space `0`. @@ -155,7 +154,7 @@ introduce additional address spaces: | `1` | Registers | Elements are constrained to lie in `[0, 2^LIMB_BITS)` for `LIMB_BITS = 8`. | | `2` | User Memory | Elements are constrained to lie in `[0, 2^LIMB_BITS)` for `LIMB_BITS = 8`. | | `3` | User IO | | -| `4` | Deferral | Elements are typically full field elements. | +| `4` | Deferral | Elements are typically full native field elements. | When adding a new user address space, the invariants of the memory cells in that address space must be declared, and all instructions must ensure that these invariants are preserved. @@ -171,7 +170,7 @@ structures during runtime execution: - `input_stream`: a private non-interactive queue of vectors of field elements which is provided at the start of runtime execution - `hint_stream`: a queue of values populated during runtime execution - via [phantom sub-instructions](#phantom-sub-instructions) such as `Rv32HintInput` + via [phantom sub-instructions](#phantom-sub-instructions) such as `Rv32HintInput`. - `hint_space`: a vector of vectors of field elements used to store hints during runtime execution via [phantom sub-instructions](#phantom-sub-instructions). The outer `hint_space` vector is append-only, but each internal `hint_space[hint_id]` vector may be mutated, including deletions, by the host. @@ -433,6 +432,7 @@ The RV32IM extension defines the following phantom sub-instructions. | Rv32HintInput | 0x20 | `_` | Pops a vector `hint` of field elements from the input stream and resets the hint stream to equal the vector `[(hint.len() as u32).to_le_bytes()), hint].concat()`. | | Rv32PrintStr | 0x21 | `a,b,_` | Peeks at `[r32{0}(a)..r32{0}(a) + r32{0}(b)]_2`, tries to convert to byte array and then UTF-8 string and prints to host stdout. Prints error message if conversion fails. Does not change any VM state. | | Rv32HintRandom | 0x22 | `a,_,_` | Resets the hint stream to `4 * r32{0}(a)` random bytes. The source of randomness is deterministic using a fixed-seed RNG (`rand::rngs::StdRng`). Its result is not constrained in any way. | +| Rv32HintLoadByKey | 0x23 | `a,b,_` | Look up the value by key `[r32{0}{a}:r32{0}{b}]_2` and prepend the value into `input_stream`. The logical value is `Vec>`. The serialization of `Vec` follows the format `[length, ]`. Both length and content encoded as little-endian bytes. | ### Deferral Extension @@ -449,12 +449,21 @@ The extension operates on address spaces `1` (registers) and `2` (user memory) a ### Keccak Extension -The Keccak extension supports the Keccak256 hash function. The extension operates on address spaces `1` and `2`, meaning -all memory cells are constrained to be bytes. +The Keccak extension supports the Keccak-256 hash function via two low-level opcodes that decompose the Keccak sponge +construction into its constituent operations: absorbing input (XOR-in) and permuting state (keccak-f[1600]). Together, +these opcodes can be used to implement the full Keccak-256 hash function, including incremental/streaming hashing. -| Name | Operands | Description | -| -------------- | ----------- | ----------------------------------------------------------------------------------------------------------------- | -| KECCAK256_RV32 | `a,b,c,1,2` | `[r32{0}(a):32]_2 = keccak256([r32{0}(b)..r32{0}(b)+r32{0}(c)]_2)`. Performs memory accesses with block size `4`. | +The extension operates on address spaces `1` and `2`, meaning all memory cells are constrained to be bytes. + +The Keccak-f[1600] state is a 200-byte buffer in address space `2`. The absorption rate is 136 bytes (1088 bits), +corresponding to a capacity of 512 bits for Keccak-256. + +In the instructions below, let `buf = r32{0}(a)`, `inp = r32{0}(b)`, and `len = r32{0}(c)`. + +| Name | Operands | Description | +| ------- | ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| XORIN | `a,b,c,1,2` | XORs input bytes into a state buffer in-place. For `i` in `0..len`, sets `[buf+i]_2 ^= [inp+i]_2`. Reads `len/4` four-byte words from both the buffer at `buf` and the input at `inp`, and writes `len/4` four-byte words back to `buf`. The instruction is only valid when `len` is a positive multiple of `4` and at most `136`. | +| KECCAKF | `a,_,_,1,2` | Applies the keccak-f[1600] permutation in-place on a 200-byte state buffer: `[buf:200]_2 = keccakf([buf:200]_2)`. Reads 50 four-byte words from `buf`, applies the permutation, and writes 50 four-byte words back. | ### SHA-2 Extension @@ -638,3 +647,8 @@ The pairing extension defines the following phantom sub-instructions. | Name | Discriminant | Operands | Description | | ------------ | ------------ | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | HintFinalExp | 0x30 | `a,b,c_upper` | Uses `c_upper = PAIRING_IDX` to determine the curve: `BN254 = 0, BLS12-381 = 1`. `a` is a pointer to `(p_ptr, p_len): (u32, u32)` in memory, and `b` is a pointer to `(q_ptr, q_len): (u32, u32)` in memory (e.g., `p_ptr = [r32{0}(a)..r32{0}(a) + 4]_2`). The sub-instruction peeks at `P = [p_ptr..p_ptr + p_len * size_of() * 2]_2` and `Q = [q_ptr..q_ptr + q_len * size_of() * 2]_2` and views `P` as a list of `G1Affine` elements and `Q` as a list of `G2Affine` elements. It computes the multi-Miller loop on `(P, Q)` and then the final exponentiation hint `(residue_witness, scaling_factor): (Fp12, Fp12)`. It resets the hint stream to equal `(residue_witness, scaling_factor)` as `NUM_LIMBS * 12 * 2` bytes. | + +## Acknowledgements + +The design of the (now deprecated) native extension was inspired by [Valida](https://github.com/valida-xyz/valida-compiler/issues/2) with +changes suggested by Max Gillet for compatibility with existing ISAs. diff --git a/docs/vocs/docs/pages/specs/reference/instruction-reference.mdx b/docs/vocs/docs/pages/specs/reference/instruction-reference.mdx index 1f069d827c..3e7efae1f3 100644 --- a/docs/vocs/docs/pages/specs/reference/instruction-reference.mdx +++ b/docs/vocs/docs/pages/specs/reference/instruction-reference.mdx @@ -95,7 +95,8 @@ In the tables below, we provide the mapping between the `LocalOpcode` and `Phant | VM Extension | `LocalOpcode` | ISA Instruction | | ------------- | ---------- | ------------- | -| Keccak | `Rv32KeccakOpcode::KECCAK256` | KECCAK256_RV32 | +| Keccak | `XorinOpcode::XORIN` | XORIN | +| Keccak | `KeccakfOpcode::KECCAKF` | KECCAKF | ## SHA-2 Extension diff --git a/docs/vocs/docs/pages/specs/reference/riscv-custom-code.mdx b/docs/vocs/docs/pages/specs/reference/riscv-custom-code.mdx index 362adadd07..f4e276ad68 100644 --- a/docs/vocs/docs/pages/specs/reference/riscv-custom-code.mdx +++ b/docs/vocs/docs/pages/specs/reference/riscv-custom-code.mdx @@ -4,7 +4,7 @@ VM extensions in OpenVM are supported in the Rust frontend by inserting custom R The default VM extensions that support transpilation are: - [RV32IM](#rv32im-extension): An extension supporting the 32-bit RISC-V ISA with multiplication. -- [Keccak-256](#keccak-extension): An extension implementing the Keccak-256 hash function compatibly with RISC-V memory. +- [Keccak-256](#keccak-extension): An extension implementing low-level Keccak sponge operations (XOR-in and keccak-f[1600] permutation) compatibly with RISC-V memory, used to implement the Keccak-256 hash function. - [SHA2](#sha-2-extension): An extension implementing the SHA-256 and SHA-512 hash functions compatibly with RISC-V memory. - [BigInt](#bigint-extension): An extension supporting 256-bit signed and unsigned integer arithmetic, including multiplication. This extension respects the RISC-V memory format. - [Algebra](#algebra-extension): An extension supporting modular arithmetic over arbitrary fields and their complex field extensions. This extension respects the RISC-V memory format. @@ -85,14 +85,15 @@ Deferral instructions use the _custom-1_ opcode prefix (`0101011`) and `funct3 = | RISC-V Inst | FMT | opcode[6:0] | funct3 | funct7 | RISC-V description and notes | | ----------- | --- | ----------- | ------ | ------ | ------------------------------------------- | -| keccak256 | R | 0001011 | 100 | 0x0 | `[rd:32]_2 = keccak256([rs1..rs1 + rs2]_2)` | +| keccakf | R | 0001011 | 100 | 0x0 | Applies keccak-f[1600] permutation in-place on 200-byte state buffer at `rd`: `[rd:200]_2 = keccakf([rd:200]_2)`. `rs1` and `rs2` must be `x0`. | +| xorin | R | 0001011 | 100 | 0x1 | XORs `rs2` input bytes into state buffer: for `i` in `0..rs2`, `[rd+i]_2 ^= [rs1+i]_2`. `rs2` must be a positive multiple of 4 and at most 136. | ## SHA-2 Extension | RISC-V Inst | FMT | opcode[6:0] | funct3 | funct7 | RISC-V description and notes | | ------------- | --- | ----------- | ------ | ------ | -------------------------------------------------- | -| sha256_update | R | 0001011 | 100 | 0x1 | `[rd:32]_2 = compress256([rs1:32]_2, [rs2:64]_2)` | -| sha512_update | R | 0001011 | 100 | 0x2 | `[rd:64]_2 = compress512([rs1:64]_2, [rs2:128]_2)` | +| sha256_update | R | 0001011 | 100 | 0x2 | `[rd:32]_2 = compress256([rs1:32]_2, [rs2:64]_2)` | +| sha512_update | R | 0001011 | 100 | 0x3 | `[rd:64]_2 = compress512([rs1:64]_2, [rs2:128]_2)` | ## BigInt Extension diff --git a/docs/vocs/docs/pages/specs/reference/transpiler.mdx b/docs/vocs/docs/pages/specs/reference/transpiler.mdx index 6fc1c6b479..3ae802d275 100644 --- a/docs/vocs/docs/pages/specs/reference/transpiler.mdx +++ b/docs/vocs/docs/pages/specs/reference/transpiler.mdx @@ -147,9 +147,10 @@ Each VM extension's behavior is specified below. ### Keccak Extension -| RISC-V Inst | OpenVM Instruction | -| ----------- | -------------------------------------------------- | -| keccak256 | KECCAK256_RV32 `ind(rd), ind(rs1), ind(rs2), 1, 2` | +| RISC-V Inst | OpenVM Instruction | +| ----------- | -------------------------------------------- | +| xorin | XORIN `ind(rd), ind(rs1), ind(rs2), 1, 2` | +| keccakf | KECCAKF `ind(rd), _, _, 1, 2` | ### SHA-2 Extension diff --git a/extensions/keccak256/guest/src/lib.rs b/extensions/keccak256/guest/src/lib.rs index 2f54b0fc5e..61da613942 100644 --- a/extensions/keccak256/guest/src/lib.rs +++ b/extensions/keccak256/guest/src/lib.rs @@ -7,7 +7,7 @@ pub const OPCODE: u8 = 0x0b; pub const KECCAKF_FUNCT3: u8 = 0b100; pub const KECCAKF_FUNCT7: u8 = 0; pub const XORIN_FUNCT3: u8 = 0b100; -pub const XORIN_FUNCT7: u8 = 3; +pub const XORIN_FUNCT7: u8 = 1; pub const KECCAK_WIDTH_BYTES: usize = 200; pub const KECCAK_RATE: usize = 136; diff --git a/extensions/sha2/guest/src/lib.rs b/extensions/sha2/guest/src/lib.rs index d2b9c1f585..61fe84d707 100644 --- a/extensions/sha2/guest/src/lib.rs +++ b/extensions/sha2/guest/src/lib.rs @@ -12,8 +12,8 @@ pub const SHA2_FUNCT3: u8 = 0b100; #[derive(Debug, Copy, Clone, PartialEq, Eq)] #[repr(u8)] pub enum Sha2BaseFunct7 { - Sha256 = 0x1, - Sha512 = 0x2, + Sha256 = 0x2, + Sha512 = 0x3, } /// zkvm native implementation of sha256 compression function From c2c937210a26c3118e5bb5e19c376411040d8267 Mon Sep 17 00:00:00 2001 From: Grigorii Alekseev Date: Wed, 11 Mar 2026 01:00:59 +0400 Subject: [PATCH 35/78] chore(cuda): stack usage reduce (#2524) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes INT-6529 1. Keccak256 — `p3_keccakf.cuh` - `generate_trace_row_for_round`: changed from inline to __noinline__ - Why: inline caused the compiler to inline a large function into callers, bloating their stack frames. Making it __noinline__ isolates its stack allocation. - Result: keccak kernel LMEM 7088 → 1056 B (−6032 B per thread, ~1.29 GiB total) 2. SHA2 — `sha2_hasher.cu` - `generate_carry_ae`: replaced pre-allocated arrays `a_bits[2×ROUNDS_PER_ROW][WORD_BITS]` / `e_bits[...]` (large stack arrays) with on-demand `get_a_bit()`/`get_e_bit()` helper functions that read one element at a time - `write_flags_round`, `write_flags_digest`, `generate_intermed_4`, `generate_intermed_12`, `generate_default_row`: added __noinline__ to give each its own stack frame instead of all spilling into the caller - `w_schedule[ROUNDS_PER_BLOCK]` (64 words): replaced with circular buffer `w_buf[BLOCK_WORDS]` (16 words) - Result: SHA-256 LMEM 776 → 600 B (−176 B), SHA-512 LMEM 2312 → 1816 B (−496 B), ~60 MiB total Total estimated reduction: ~1.35 GiB LMEM across both kernels. --- .../circuit/cuda/include/p3_keccakf.cuh | 2 +- .../sha2/circuit/cuda/src/sha2_hasher.cu | 251 ++++++++++++------ 2 files changed, 164 insertions(+), 89 deletions(-) diff --git a/extensions/keccak256/circuit/cuda/include/p3_keccakf.cuh b/extensions/keccak256/circuit/cuda/include/p3_keccakf.cuh index 8df6b2ca4f..77bf925d0f 100644 --- a/extensions/keccak256/circuit/cuda/include/p3_keccakf.cuh +++ b/extensions/keccak256/circuit/cuda/include/p3_keccakf.cuh @@ -71,7 +71,7 @@ inline constexpr size_t NUM_KECCAK_COLS = sizeof(KeccakCols); // tracegen matching plonky3 // `row` must have first NUM_KECCAK_COLS columns matching KeccakCols -__device__ inline void generate_trace_row_for_round( +static __device__ __noinline__ void generate_trace_row_for_round( RowSlice row, uint32_t round, uint64_t current_state[5][5] diff --git a/extensions/sha2/circuit/cuda/src/sha2_hasher.cu b/extensions/sha2/circuit/cuda/src/sha2_hasher.cu index fb37585362..e0a3cb90c0 100644 --- a/extensions/sha2/circuit/cuda/src/sha2_hasher.cu +++ b/extensions/sha2/circuit/cuda/src/sha2_hasher.cu @@ -102,6 +102,39 @@ template struct Sha2TraceHelper { read_word_bits(inner, SHA2_COL_INDEX(V, Sha2RoundCols, message_schedule.w[j]), dst_bits); } + // Helpers to get bits from either local or next inner row without pre-loading arrays + __device__ __forceinline__ Fp + get_a_bit(RowSlice local_inner, RowSlice next_inner, uint32_t round_idx, uint32_t bit) const { + if (round_idx < V::ROUNDS_PER_ROW) { + return local_inner[base_a(round_idx) + bit]; + } else { + return next_inner[base_a(round_idx - V::ROUNDS_PER_ROW) + bit]; + } + } + + __device__ __forceinline__ Fp + get_e_bit(RowSlice local_inner, RowSlice next_inner, uint32_t round_idx, uint32_t bit) const { + if (round_idx < V::ROUNDS_PER_ROW) { + return local_inner[base_e(round_idx) + bit]; + } else { + return next_inner[base_e(round_idx - V::ROUNDS_PER_ROW) + bit]; + } + } + + __device__ __forceinline__ Fp + get_w_bit(RowSlice local_inner, RowSlice next_inner, uint32_t round_idx, uint32_t bit) const { + size_t base; + if (round_idx < V::ROUNDS_PER_ROW) { + base = SHA2_COL_INDEX(V, Sha2RoundCols, message_schedule.w[round_idx]); + return local_inner[base + bit]; + } else { + base = SHA2_COL_INDEX( + V, Sha2RoundCols, message_schedule.w[round_idx - V::ROUNDS_PER_ROW] + ); + return next_inner[base + bit]; + } + } + __device__ __forceinline__ Fp xor_fp(Fp a, Fp b) const { return a + b - Fp(2) * a * b; } __device__ __forceinline__ Fp xor_fp(Fp a, Fp b, Fp c) const { return xor_fp(xor_fp(a, b), c); } @@ -223,7 +256,7 @@ template struct Sha2TraceHelper { return acc; } - __device__ void write_flags_round( + __device__ __noinline__ void write_flags_round( RowSlice inner_row, uint32_t row_idx, uint32_t global_block_idx @@ -242,7 +275,7 @@ template struct Sha2TraceHelper { SHA2INNER_WRITE_ROUND(V, inner_row, flags.global_block_idx, Fp(global_block_idx)); } - __device__ void write_flags_digest( + __device__ __noinline__ void write_flags_digest( RowSlice inner_row, uint32_t row_idx, uint32_t global_block_idx @@ -256,48 +289,70 @@ template struct Sha2TraceHelper { SHA2INNER_WRITE_DIGEST(V, inner_row, flags.global_block_idx, Fp(global_block_idx)); } - __device__ void generate_carry_ae(RowSlice local_inner, RowSlice next_inner) const { - Fp a_bits[2 * V::ROUNDS_PER_ROW][V::WORD_BITS]; - Fp e_bits[2 * V::ROUNDS_PER_ROW][V::WORD_BITS]; -#pragma unroll - for (uint32_t i = 0; i < V::ROUNDS_PER_ROW; i++) { - read_word_bits(local_inner, base_a(i), a_bits[i]); - read_word_bits(next_inner, base_a(i), a_bits[i + V::ROUNDS_PER_ROW]); - read_word_bits(local_inner, base_e(i), e_bits[i]); - read_word_bits(next_inner, base_e(i), e_bits[i + V::ROUNDS_PER_ROW]); - } - + __device__ __noinline__ void generate_carry_ae(RowSlice local_inner, RowSlice next_inner) + const { + // Process one round at a time instead of pre-loading all 2*ROUNDS_PER_ROW rows. + // This reduces per-function stack from ~2KB to ~512B for SHA-256. const Fp pow16_inv = inv(Fp(1u << 16)); for (uint32_t i = 0; i < V::ROUNDS_PER_ROW; i++) { + // Read a[i+3] and e[i+3] bits into small temp arrays for sig functions + Fp a3_bits[V::WORD_BITS]; + Fp e3_bits[V::WORD_BITS]; + for (uint32_t bit = 0; bit < V::WORD_BITS; bit++) { + a3_bits[bit] = get_a_bit(local_inner, next_inner, i + 3, bit); + e3_bits[bit] = get_e_bit(local_inner, next_inner, i + 3, bit); + } + Fp sig_a[V::WORD_BITS]; Fp sig_e[V::WORD_BITS]; Fp maj_abc[V::WORD_BITS]; Fp ch_efg[V::WORD_BITS]; - big_sig0_bits(a_bits[i + 3], sig_a); - big_sig1_bits(e_bits[i + 3], sig_e); + big_sig0_bits(a3_bits, sig_a); + big_sig1_bits(e3_bits, sig_e); for (uint32_t bit = 0; bit < V::WORD_BITS; bit++) { - maj_abc[bit] = maj_fp(a_bits[i + 3][bit], a_bits[i + 2][bit], a_bits[i + 1][bit]); - ch_efg[bit] = ch_fp(e_bits[i + 3][bit], e_bits[i + 2][bit], e_bits[i + 1][bit]); + maj_abc[bit] = maj_fp( + a3_bits[bit], + get_a_bit(local_inner, next_inner, i + 2, bit), + get_a_bit(local_inner, next_inner, i + 1, bit) + ); + ch_efg[bit] = ch_fp( + e3_bits[bit], + get_e_bit(local_inner, next_inner, i + 2, bit), + get_e_bit(local_inner, next_inner, i + 1, bit) + ); } Fp prev_carry_a = Fp::zero(); Fp prev_carry_e = Fp::zero(); for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { - Fp t1_sum = compose_u16_limb(e_bits[i], limb) + compose_u16_limb(sig_e, limb) + - compose_u16_limb(ch_efg, limb); + // Compute e[i], a[i], a[i+4], e[i+4] limbs on-the-fly + Fp e_i_limb = Fp::zero(); + Fp a_i_limb = Fp::zero(); + Fp a_i4_limb = Fp::zero(); + Fp e_i4_limb = Fp::zero(); +#pragma unroll 1 + for (uint32_t bit = 0; bit < 16; bit++) { + Fp scale(1u << bit); + e_i_limb += get_e_bit(local_inner, next_inner, i, limb * 16 + bit) * scale; + a_i_limb += get_a_bit(local_inner, next_inner, i, limb * 16 + bit) * scale; + a_i4_limb += + get_a_bit(local_inner, next_inner, i + 4, limb * 16 + bit) * scale; + e_i4_limb += + get_e_bit(local_inner, next_inner, i + 4, limb * 16 + bit) * scale; + } + + Fp t1_sum = + e_i_limb + compose_u16_limb(sig_e, limb) + compose_u16_limb(ch_efg, limb); Fp t2_sum = compose_u16_limb(sig_a, limb) + compose_u16_limb(maj_abc, limb); - Fp d_limb = compose_u16_limb(a_bits[i], limb); - Fp cur_a_limb = compose_u16_limb(a_bits[i + 4], limb); - Fp cur_e_limb = compose_u16_limb(e_bits[i + 4], limb); - Fp e_sum = d_limb + t1_sum + + Fp e_sum = a_i_limb + t1_sum + (limb == 0 ? Fp::zero() : next_inner[base_carry_e(i) + limb - 1]); Fp a_sum = t1_sum + t2_sum + (limb == 0 ? Fp::zero() : next_inner[base_carry_a(i) + limb - 1]); - Fp carry_e = (e_sum - cur_e_limb) * pow16_inv; - Fp carry_a = (a_sum - cur_a_limb) * pow16_inv; + Fp carry_e = (e_sum - e_i4_limb) * pow16_inv; + Fp carry_a = (a_sum - a_i4_limb) * pow16_inv; SHA2INNER_WRITE_ROUND(V, next_inner, work_vars.carry_e[i][limb], Fp(carry_e)); SHA2INNER_WRITE_ROUND(V, next_inner, work_vars.carry_a[i][limb], Fp(carry_a)); @@ -308,68 +363,80 @@ template struct Sha2TraceHelper { } } - __device__ void generate_intermed_4(RowSlice local_inner, RowSlice next_inner) const { - Fp w_bits[2 * V::ROUNDS_PER_ROW][V::WORD_BITS]; - Fp w_limbs[2 * V::ROUNDS_PER_ROW][V::WORD_U16S]; -#pragma unroll - for (uint32_t j = 0; j < V::ROUNDS_PER_ROW; j++) { - read_w_bits(local_inner, j, w_bits[j]); - read_w_bits(next_inner, j, w_bits[j + V::ROUNDS_PER_ROW]); - for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { - w_limbs[j][limb] = compose_u16_limb(w_bits[j], limb); - w_limbs[j + V::ROUNDS_PER_ROW][limb] = - compose_u16_limb(w_bits[j + V::ROUNDS_PER_ROW], limb); + __device__ __noinline__ void generate_intermed_4(RowSlice local_inner, RowSlice next_inner) + const { + // Process one round at a time instead of pre-loading all 2*ROUNDS_PER_ROW rows. + // This reduces per-function stack from ~1.2KB to ~256B for SHA-256. + for (uint32_t i = 0; i < V::ROUNDS_PER_ROW; i++) { + // Read w[i+1] bits on-the-fly for small_sig0_bits + Fp w_i1_bits[V::WORD_BITS]; + for (uint32_t bit = 0; bit < V::WORD_BITS; bit++) { + w_i1_bits[bit] = get_w_bit(local_inner, next_inner, i + 1, bit); } - } - for (uint32_t i = 0; i < V::ROUNDS_PER_ROW; i++) { Fp sig_bits[V::WORD_BITS]; - Fp sig_limbs[V::WORD_U16S]; + small_sig0_bits(w_i1_bits, sig_bits); - small_sig0_bits(w_bits[i + 1], sig_bits); - for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { - sig_limbs[limb] = compose_u16_limb(sig_bits, limb); - } -#pragma unroll for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { - Fp val = w_limbs[i][limb] + sig_limbs[limb]; + // Compute w[i] limb on-the-fly + Fp w_i_limb = Fp::zero(); +#pragma unroll 1 + for (uint32_t bit = 0; bit < 16; bit++) { + w_i_limb += get_w_bit(local_inner, next_inner, i, limb * 16 + bit) * + Fp(1u << bit); + } + Fp val = w_i_limb + compose_u16_limb(sig_bits, limb); SHA2INNER_WRITE_ROUND(V, next_inner, schedule_helper.intermed_4[i][limb], val); } } } - __device__ void generate_intermed_12(RowSlice local_inner, RowSlice next_inner) const { - Fp w_bits[2 * V::ROUNDS_PER_ROW][V::WORD_BITS]; - Fp w_limbs[2 * V::ROUNDS_PER_ROW][V::WORD_U16S]; -#pragma unroll - for (uint32_t j = 0; j < V::ROUNDS_PER_ROW; j++) { - read_w_bits(local_inner, j, w_bits[j]); - read_w_bits(next_inner, j, w_bits[j + V::ROUNDS_PER_ROW]); - for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { - w_limbs[j][limb] = compose_u16_limb(w_bits[j], limb); - w_limbs[j + V::ROUNDS_PER_ROW][limb] = - compose_u16_limb(w_bits[j + V::ROUNDS_PER_ROW], limb); + __device__ __noinline__ void generate_intermed_12(RowSlice local_inner, RowSlice next_inner) + const { + // Process one round at a time instead of pre-loading all 2*ROUNDS_PER_ROW rows. + // This reduces per-function stack from ~1.2KB to ~256B for SHA-256. + for (uint32_t i = 0; i < V::ROUNDS_PER_ROW; i++) { + // Read w[i+2] bits on-the-fly for small_sig1_bits + Fp w_i2_bits[V::WORD_BITS]; + for (uint32_t bit = 0; bit < V::WORD_BITS; bit++) { + w_i2_bits[bit] = get_w_bit(local_inner, next_inner, i + 2, bit); } - } - for (uint32_t i = 0; i < V::ROUNDS_PER_ROW; i++) { Fp sig_bits[V::WORD_BITS]; - Fp sig_limbs[V::WORD_U16S]; + small_sig1_bits(w_i2_bits, sig_bits); - small_sig1_bits(w_bits[i + 2], sig_bits); - for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { - sig_limbs[limb] = compose_u16_limb(sig_bits, limb); - } for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { Fp carry = read_carry_fp(next_inner, i, limb); Fp prev_carry = (limb > 0) ? read_carry_fp(next_inner, i, limb - 1) : Fp::zero(); - Fp w7_limb = (i < 3) - ? local_inner[SHA2_COL_INDEX( - V, Sha2RoundCols, schedule_helper.w_3[i][limb] - )] - : w_limbs[i - 3][limb]; - Fp w_cur = w_limbs[i + 4][limb]; - Fp sum = sig_limbs[limb] + w7_limb - carry * Fp(1u << 16) - w_cur + prev_carry; + + // w7_limb: use pre-stored w_3 helper for i<3, else compute w[i-3] on-the-fly + Fp w7_limb; + if (i < 3) { + w7_limb = local_inner[SHA2_COL_INDEX( + V, Sha2RoundCols, schedule_helper.w_3[i][limb] + )]; + } else { + // i-3 is in local_inner (i-3 < ROUNDS_PER_ROW since i= ROUNDS_PER_ROW, so from next_inner) + Fp w_cur = Fp::zero(); +#pragma unroll 1 + for (uint32_t bit = 0; bit < 16; bit++) { + w_cur += + get_w_bit(local_inner, next_inner, i + 4, limb * 16 + bit) * Fp(1u << bit); + } + + Fp sum = + compose_u16_limb(sig_bits, limb) + w7_limb - carry * Fp(1u << 16) - w_cur + + prev_carry; Fp intermed = -sum; SHA2INNER_WRITE_ROUND( V, local_inner, schedule_helper.intermed_12[i][limb], intermed @@ -378,7 +445,7 @@ template struct Sha2TraceHelper { } } - __device__ void generate_default_row( + __device__ __noinline__ void generate_default_row( RowSlice inner_row, const typename V::Word *first_block_prev_hash, Fp *carry_a, @@ -512,10 +579,14 @@ __global__ void sha2_first_pass_tracegen( BitwiseOperationLookup bitwise_lookup(bitwise_lookup_ptr, bitwise_num_bits); - typename V::Word w_schedule[V::ROUNDS_PER_BLOCK] = {}; + // Use a 16-entry circular buffer instead of w_schedule[ROUNDS_PER_BLOCK]. + // Each schedule word w[t] is stored at w_buf[t & (BLOCK_WORDS - 1)]. + // This reduces stack from ROUNDS_PER_BLOCK*sizeof(Word) to BLOCK_WORDS*sizeof(Word). + // Correctness: the maximum lookback is 16 entries (w[t-16]), so 16 slots suffice. + typename V::Word w_buf[V::BLOCK_WORDS] = {}; #pragma unroll for (int i = 0; i < static_cast(V::BLOCK_WORDS); i++) { - w_schedule[i] = word_from_bytes_be(record.message_bytes + i * V::WORD_U8S); + w_buf[i] = word_from_bytes_be(record.message_bytes + i * V::WORD_U8S); } typename V::Word a = prev_hash[0]; @@ -545,16 +616,16 @@ __global__ void sha2_first_pass_tracegen( uint32_t t = row_in_block * V::ROUNDS_PER_ROW + j; typename V::Word w_val; if (t < V::BLOCK_WORDS) { - w_val = w_schedule[t]; + w_val = w_buf[t & (V::BLOCK_WORDS - 1)]; } else { typename V::Word nums[4] = { - sha2::small_sig1(w_schedule[t - 2]), - w_schedule[t - 7], - sha2::small_sig0(w_schedule[t - 15]), - w_schedule[t - 16], + sha2::small_sig1(w_buf[(t - 2) & (V::BLOCK_WORDS - 1)]), + w_buf[(t - 7) & (V::BLOCK_WORDS - 1)], + sha2::small_sig0(w_buf[(t - 15) & (V::BLOCK_WORDS - 1)]), + w_buf[(t - 16) & (V::BLOCK_WORDS - 1)], }; w_val = nums[0] + nums[1] + nums[2] + nums[3]; - w_schedule[t] = w_val; + w_buf[t & (V::BLOCK_WORDS - 1)] = w_val; #pragma unroll for (int limb = 0; limb < static_cast(V::WORD_U16S); limb++) { @@ -630,8 +701,9 @@ __global__ void sha2_first_pass_tracegen( } if (row_in_block > 0) { - typename V::Word w_4 = w_schedule[t - 4]; - typename V::Word sig0_w3 = sha2::small_sig0(w_schedule[t - 3]); + typename V::Word w_4 = w_buf[(t - 4) & (V::BLOCK_WORDS - 1)]; + typename V::Word sig0_w3 = + sha2::small_sig0(w_buf[(t - 3) & (V::BLOCK_WORDS - 1)]); #pragma unroll for (int limb = 0; limb < static_cast(V::WORD_U16S); limb++) { uint32_t val = @@ -641,7 +713,7 @@ __global__ void sha2_first_pass_tracegen( ); } if (j < V::ROUNDS_PER_ROW - 1) { - typename V::Word w3 = w_schedule[t - 3]; + typename V::Word w3 = w_buf[(t - 3) & (V::BLOCK_WORDS - 1)]; #pragma unroll for (int limb = 0; limb < static_cast(V::WORD_U16S); limb++) { SHA2INNER_WRITE_ROUND( @@ -671,7 +743,8 @@ __global__ void sha2_first_pass_tracegen( helper.write_flags_digest(inner_row, digest_row_idx, global_block_idx + 1); for (uint32_t j = 0; j < V::ROUNDS_PER_ROW - 1; j++) { - typename V::Word val = w_schedule[row_in_block * V::ROUNDS_PER_ROW + j - 3]; + typename V::Word val = + w_buf[(row_in_block * V::ROUNDS_PER_ROW + j - 3) & (V::BLOCK_WORDS - 1)]; for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { SHA2INNER_WRITE_DIGEST( V, @@ -682,7 +755,9 @@ __global__ void sha2_first_pass_tracegen( } } - typename V::Word final_hash[V::HASH_WORDS]; + // Use a per-iteration scalar instead of final_hash[HASH_WORDS] array to + // avoid stack allocation. The column index in the macro uses struct field + // addressing (not the local variable), so this rename is correct. for (int i = 0; i < static_cast(V::HASH_WORDS); i++) { typename V::Word work_val = (i == 0) @@ -693,13 +768,13 @@ __global__ void sha2_first_pass_tracegen( ? c : (i == 3 ? d : (i == 4 ? e : (i == 5 ? f : (i == 6 ? g : h)))))); - final_hash[i] = prev_hash[i] + work_val; + typename V::Word fh_val = prev_hash[i] + work_val; for (uint32_t limb = 0; limb < V::WORD_U8S; limb++) { SHA2INNER_WRITE_DIGEST( V, inner_row, final_hash[i][limb], - Fp(word_to_u8_limb(final_hash[i], limb)) + Fp(word_to_u8_limb(fh_val, limb)) ); } for (uint32_t limb = 0; limb < V::WORD_U16S; limb++) { @@ -712,8 +787,8 @@ __global__ void sha2_first_pass_tracegen( } for (uint32_t limb = 0; limb < V::WORD_U8S; limb += 2) { - uint32_t b0 = word_to_u8_limb(final_hash[i], limb); - uint32_t b1 = word_to_u8_limb(final_hash[i], limb + 1); + uint32_t b0 = word_to_u8_limb(fh_val, limb); + uint32_t b1 = word_to_u8_limb(fh_val, limb + 1); bitwise_lookup.add_range(b0, b1); } } From dbf3fb3a0ae70e89238773e446dbd250d9566364 Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Fri, 13 Mar 2026 23:36:33 +0530 Subject: [PATCH 36/78] chore(v2): remove vestiges of access adapters (#2549) towards int-6630 --- crates/vm/src/arch/config.rs | 3 +- crates/vm/src/arch/testing/cpu.rs | 13 ++-- crates/vm/src/arch/testing/cuda.rs | 3 +- crates/vm/src/system/memory/online.rs | 10 +-- crates/vm/src/system/memory/tests.rs | 2 +- extensions/bigint/circuit/src/common.rs | 2 - .../rv32im/circuit/src/auipc/execution.rs | 2 - .../rv32im/circuit/src/base_alu/execution.rs | 8 --- .../rv32im/circuit/src/base_alu/tests.rs | 2 +- .../rv32im/circuit/src/branch_eq/execution.rs | 8 +-- .../rv32im/circuit/src/branch_lt/aot.rs | 6 +- extensions/rv32im/circuit/src/common/mod.rs | 71 +------------------ .../rv32im/circuit/src/divrem/execution.rs | 8 +-- .../rv32im/circuit/src/jal_lui/execution.rs | 7 +- .../rv32im/circuit/src/jalr/execution.rs | 7 -- .../rv32im/circuit/src/less_than/execution.rs | 8 --- .../circuit/src/load_sign_extend/aot.rs | 10 --- .../rv32im/circuit/src/loadstore/aot.rs | 29 -------- .../rv32im/circuit/src/loadstore/tests.rs | 5 +- .../rv32im/circuit/src/mul/execution.rs | 6 -- .../rv32im/circuit/src/mulh/execution.rs | 6 -- .../rv32im/circuit/src/shift/execution.rs | 9 --- 22 files changed, 17 insertions(+), 208 deletions(-) diff --git a/crates/vm/src/arch/config.rs b/crates/vm/src/arch/config.rs index 1f7005c461..639dc15802 100644 --- a/crates/vm/src/arch/config.rs +++ b/crates/vm/src/arch/config.rs @@ -115,8 +115,7 @@ pub const OPENVM_DEFAULT_INIT_FILE_NAME: &str = "openvm_init.rs"; const DEFAULT_U8_BLOCK_SIZE: usize = 4; const DEFAULT_FIELD_BLOCK_SIZE: usize = 1; -/// The constant block size used for memory accesses when access adapters are disabled. -/// All memory accesses for address spaces 1-3 must use this block size. +/// The constant block size used for all memory accesses. /// This is also the block size used by the Boundary AIR for memory bus interactions. pub const CONST_BLOCK_SIZE: usize = DEFAULT_U8_BLOCK_SIZE; diff --git a/crates/vm/src/arch/testing/cpu.rs b/crates/vm/src/arch/testing/cpu.rs index e8a0f4efb2..183d82d459 100644 --- a/crates/vm/src/arch/testing/cpu.rs +++ b/crates/vm/src/arch/testing/cpu.rs @@ -180,9 +180,8 @@ where ) -> (usize, usize) { let register = self.get_default_register(reg_increment); let pointer = self.get_default_pointer(pointer_increment); - // Write pointer in CONST_BLOCK_SIZE-byte chunks to avoid generating access adapter records - // when access adapters are disabled (min_block_size = CONST_BLOCK_SIZE for register address - // space). The pointer is RV32_REGISTER_NUM_LIMBS bytes (32-bit for RV32). + // Write pointer in CONST_BLOCK_SIZE-byte chunks to match the fixed block size. + // The pointer is RV32_REGISTER_NUM_LIMBS bytes (32-bit for RV32). let ptr_bytes = (pointer as u32).to_le_bytes(); for i in (0..RV32_REGISTER_NUM_LIMBS).step_by(CONST_BLOCK_SIZE) { let chunk: [u8; CONST_BLOCK_SIZE] = @@ -238,17 +237,15 @@ impl VmChipTestBuilder { pointer: usize, writes: Vec<[F; NUM_LIMBS]>, ) { - // Write pointer in CONST_BLOCK_SIZE-byte chunks to avoid generating access adapter records - // when access adapters are disabled (min_block_size = CONST_BLOCK_SIZE for register address - // space). The pointer is RV32_REGISTER_NUM_LIMBS bytes (32-bit for RV32). + // Write pointer in CONST_BLOCK_SIZE-byte chunks to match the fixed block size. + // The pointer is RV32_REGISTER_NUM_LIMBS bytes (32-bit for RV32). let ptr_bytes = (pointer as u32).to_le_bytes(); for i in (0..RV32_REGISTER_NUM_LIMBS).step_by(CONST_BLOCK_SIZE) { let chunk: [u8; CONST_BLOCK_SIZE] = ptr_bytes[i..i + CONST_BLOCK_SIZE].try_into().unwrap(); self.write::(1usize, register + i, chunk.map(F::from_u8)); } - // Always write in CONST_BLOCK_SIZE-byte chunks to avoid generating - // access adapter records when access adapters are disabled. + // Always write in CONST_BLOCK_SIZE-byte chunks to match the fixed block size. for (i, &write) in writes.iter().enumerate() { let ptr = pointer + i * NUM_LIMBS; for j in (0..NUM_LIMBS).step_by(CONST_BLOCK_SIZE) { diff --git a/crates/vm/src/arch/testing/cuda.rs b/crates/vm/src/arch/testing/cuda.rs index c96fbde378..4344caa20f 100644 --- a/crates/vm/src/arch/testing/cuda.rs +++ b/crates/vm/src/arch/testing/cuda.rs @@ -334,8 +334,7 @@ impl GpuChipTestBuilder { register, (pointer as u32).to_le_bytes().map(F::from_u8), ); - // Always write in CONST_BLOCK_SIZE-byte chunks to avoid generating - // access adapter records when access adapters are disabled. + // Always write in CONST_BLOCK_SIZE-byte chunks to match the fixed block size. for (i, &write) in writes.iter().enumerate() { let ptr = pointer + i * NUM_LIMBS; for j in (0..NUM_LIMBS).step_by(CONST_BLOCK_SIZE) { diff --git a/crates/vm/src/system/memory/online.rs b/crates/vm/src/system/memory/online.rs index 89ba91c4d7..a01e3d2f89 100644 --- a/crates/vm/src/system/memory/online.rs +++ b/crates/vm/src/system/memory/online.rs @@ -564,7 +564,7 @@ impl TracingMemory { address_space: usize, pointer: usize, ) -> Option<(Vec<(usize, usize)>, (usize, usize))> { - // Skip adapters if this is a repeated access to the same location with same size + // Skip metadata update if this is a repeated access to the same location with same size let (start_ptr, block_meta) = self.get_block_metadata::(address_space, pointer); if block_meta.block_size() == BLOCK_SIZE as u8 && start_ptr == pointer as u32 { return None; @@ -736,10 +736,6 @@ impl TracingMemory { /// Returns `(t_prev, [pointer:BLOCK_SIZE]_{address_space})` where `t_prev` is the /// timestamp of the last memory access. /// - /// The previous memory access is treated as atomic even if previous accesses were for - /// a smaller block size. This is made possible by internal memory access adapters - /// that split/merge memory blocks. More specifically, the last memory access corresponding - /// to `t_prev` may refer to an atomic access inserted by the memory access adapters. /// /// # Assumptions /// The `BLOCK_SIZE` is a multiple of `ALIGN`, which must equal the minimum block size @@ -775,10 +771,6 @@ impl TracingMemory { /// then increments the timestamp by 1. Returns `(t_prev, values_prev)` which equal the /// timestamp and value `[pointer:BLOCK_SIZE]_{address_space}` of the last memory access. /// - /// The previous memory access is treated as atomic even if previous accesses were for - /// a smaller block size. This is made possible by internal memory access adapters - /// that split/merge memory blocks. More specifically, the last memory access corresponding - /// to `t_prev` may refer to an atomic access inserted by the memory access adapters. /// /// # Assumptions /// The `BLOCK_SIZE` is a multiple of `ALIGN`, which must equal the minimum block size diff --git a/crates/vm/src/system/memory/tests.rs b/crates/vm/src/system/memory/tests.rs index 88b96974d9..ebe9d739f1 100644 --- a/crates/vm/src/system/memory/tests.rs +++ b/crates/vm/src/system/memory/tests.rs @@ -26,7 +26,7 @@ fn test_memory_write_by_tester(tester: &mut impl TestBuilder, its: usize) { let align: usize = aligns[addr_sp - 1]; let value_bound: u32 = value_bounds[addr_sp - 1]; let ptr = rng.random_range(0..max_ptr / align) * align; - // Access adapters are removed, so accesses use the address space minimum block size. + // Accesses use the address space minimum block size. let log_len = align.trailing_zeros(); match log_len { 0 => tester.write::<1>( diff --git a/extensions/bigint/circuit/src/common.rs b/extensions/bigint/circuit/src/common.rs index 0ec68e118f..29d6417b5d 100644 --- a/extensions/bigint/circuit/src/common.rs +++ b/extensions/bigint/circuit/src/common.rs @@ -7,7 +7,6 @@ use openvm_stark_backend::p3_field::PrimeField32; use crate::{INT256_NUM_BLOCKS, INT256_NUM_LIMBS, RV32_CELL_BITS}; /// Read a 256-bit integer as 8 separate 4-byte block reads. -/// This ensures correct access adapter cost accounting. #[inline(always)] pub fn read_int256( exec_state: &mut VmExecState, @@ -24,7 +23,6 @@ pub fn read_int256( } /// Write a 256-bit integer as 8 separate 4-byte block writes. -/// This ensures correct access adapter cost accounting. #[inline(always)] pub fn write_int256( exec_state: &mut VmExecState, diff --git a/extensions/rv32im/circuit/src/auipc/execution.rs b/extensions/rv32im/circuit/src/auipc/execution.rs index a92b697cf1..055a2170a1 100644 --- a/extensions/rv32im/circuit/src/auipc/execution.rs +++ b/extensions/rv32im/circuit/src/auipc/execution.rs @@ -179,8 +179,6 @@ where config: &SystemConfig, ) -> Result { let mut asm_str = update_height_change_asm(chip_idx, 1)?; - // read [a:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; asm_str += &self.generate_x86_asm(inst, pc)?; Ok(asm_str) } diff --git a/extensions/rv32im/circuit/src/base_alu/execution.rs b/extensions/rv32im/circuit/src/base_alu/execution.rs index 46ec8b5454..5db891f01b 100644 --- a/extensions/rv32im/circuit/src/base_alu/execution.rs +++ b/extensions/rv32im/circuit/src/base_alu/execution.rs @@ -254,14 +254,6 @@ where ) -> Result { let mut asm_str = self.generate_x86_asm(inst, pc)?; asm_str += &update_height_change_asm(chip_idx, 1)?; - // read [b:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - // read [c:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - if inst.e.as_canonical_u32() != RV32_IMM_AS { - // read [a:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - } Ok(asm_str) } } diff --git a/extensions/rv32im/circuit/src/base_alu/tests.rs b/extensions/rv32im/circuit/src/base_alu/tests.rs index 515e098425..c54467ac5a 100644 --- a/extensions/rv32im/circuit/src/base_alu/tests.rs +++ b/extensions/rv32im/circuit/src/base_alu/tests.rs @@ -160,7 +160,7 @@ fn rand_rv32_alu_test(opcode: BaseAluOpcode, num_ops: usize) { // TODO(AG): make a more meaningful test for memory accesses tester.write(2, 1024, [F::ONE; 4]); tester.write(2, 1028, [F::ONE; 4]); - // Avoid wider-than-min-block accesses when access adapters are disabled + // Use CONST_BLOCK_SIZE-aligned accesses matching the minimum block size let sm1 = tester.read(2, 1024); let sm2 = tester.read(2, 1028); assert_eq!(sm1, [F::ONE; 4]); diff --git a/extensions/rv32im/circuit/src/branch_eq/execution.rs b/extensions/rv32im/circuit/src/branch_eq/execution.rs index f18b8bce1c..8ac68c1acf 100644 --- a/extensions/rv32im/circuit/src/branch_eq/execution.rs +++ b/extensions/rv32im/circuit/src/branch_eq/execution.rs @@ -13,9 +13,7 @@ use openvm_stark_backend::p3_field::PrimeField32; use super::BranchEqualExecutor; #[cfg(feature = "aot")] -use crate::common::{ - update_adapter_heights_asm, update_height_change_asm, xmm_to_gpr, REG_A_W, REG_B_W, -}; +use crate::common::{update_height_change_asm, xmm_to_gpr, REG_A_W, REG_B_W}; #[derive(AlignedBytesBorrow, Clone)] #[repr(C)] @@ -221,10 +219,6 @@ where let mut asm_str = String::from(""); asm_str += &update_height_change_asm(chip_idx, 1)?; - // read [b:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - // read [c:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; asm_str += &self.generate_x86_asm(inst, pc)?; Ok(asm_str) diff --git a/extensions/rv32im/circuit/src/branch_lt/aot.rs b/extensions/rv32im/circuit/src/branch_lt/aot.rs index 25a355f1b1..a6ab73744f 100644 --- a/extensions/rv32im/circuit/src/branch_lt/aot.rs +++ b/extensions/rv32im/circuit/src/branch_lt/aot.rs @@ -4,7 +4,7 @@ use openvm_instructions::{instruction::Instruction, riscv::RV32_REGISTER_AS}; use openvm_stark_backend::p3_field::PrimeField32; use crate::{ - common::{update_adapter_heights_asm, update_height_change_asm, xmm_to_gpr, REG_A_W, REG_B_W}, + common::{update_height_change_asm, xmm_to_gpr, REG_A_W, REG_B_W}, BranchLessThanExecutor, }; @@ -95,10 +95,6 @@ where let mut asm_str = String::from(""); asm_str += &update_height_change_asm(chip_idx, 1)?; - // read [b:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - // read [c:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; asm_str += &self.generate_x86_asm(inst, pc)?; Ok(asm_str) diff --git a/extensions/rv32im/circuit/src/common/mod.rs b/extensions/rv32im/circuit/src/common/mod.rs index 2d52c0a303..d053351c6f 100644 --- a/extensions/rv32im/circuit/src/common/mod.rs +++ b/extensions/rv32im/circuit/src/common/mod.rs @@ -11,14 +11,8 @@ mod aot { execution_mode::{metered::memory_ctx::MemoryCtx, MeteredCtx}, AotError, SystemConfig, VmExecState, ADDR_SPACE_OFFSET, CONST_BLOCK_SIZE, }, - system::memory::{merkle::public_values::PUBLIC_VALUES_AS, online::GuestMemory}, + system::memory::online::GuestMemory, }; - use openvm_instructions::riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS}; - - /// The minimum block size is 4, but RISC-V `lb` only requires alignment of 1 and `lh` only - /// requires alignment of 2 because the instructions are implemented by doing an access of - /// block size 4. - const DEFAULT_U8_BLOCK_SIZE_BITS: u8 = 2; /// This is DIRTY because PAGE_BITS is a generic parameter of E2 context. const DEFAULT_PAGE_BITS: usize = 6; @@ -99,69 +93,6 @@ mod aot { format!(" pinsrd xmm{xmm_map_reg}, {gpr}, 1\n") } } - pub(crate) fn update_adapter_heights_asm( - config: &SystemConfig, - _address_space: u32, - ) -> Result { - let min_block_size_bits = config.memory_config.min_block_size_bits(); - if min_block_size_bits[RV32_REGISTER_AS as usize] != DEFAULT_U8_BLOCK_SIZE_BITS { - println!("RV32_REGISTER_AS must have a minimum block size of 4"); - return Err(AotError::Other(String::from( - "RV32_REGISTER_AS must have a minimum block size of 4", - ))); - } - if min_block_size_bits[RV32_MEMORY_AS as usize] != DEFAULT_U8_BLOCK_SIZE_BITS { - println!("RV32_MEMORY_AS must have a minimum block size of 4"); - return Err(AotError::Other(String::from( - "RV32_MEMORY_AS must have a minimum block size of 4", - ))); - } - if min_block_size_bits[PUBLIC_VALUES_AS as usize] != DEFAULT_U8_BLOCK_SIZE_BITS { - println!("PUBLIC_VALUES_AS must have a minimum block size of 4"); - return Err(AotError::Other(String::from( - "PUBLIC_VALUES_AS must have a minimum block size of 4", - ))); - } - - // `update_adapter_heights_asm` rewrites the following code in ASM for - // `on_memory_operation`: ``` - // pub fn update_adapter_heights_batch( - // &self, - // trace_heights: &mut [u32], - // address_space: u32, - // size_bits: u32, - // num: u32, - // ) { - // let align_bits = unsafe { - // *self - // .min_block_size_bits - // .get_unchecked(address_space as usize) - // }; - // - // for adapter_bits in (align_bits as u32 + 1..=size_bits).rev() { - // let adapter_idx = self.adapter_offset + adapter_bits as usize - 1; - // debug_assert!(adapter_idx < trace_heights.len()); - // unsafe { - // *trace_heights.get_unchecked_mut(adapter_idx) += - // num << (size_bits - adapter_bits + 1); - // } - // } - // } - // ``` - // - // For a specific RV32 instruction, the variables can be treated as constants at AOT - // compilation time: - // - `address_space`: always a constant because it is derived from an Instruction - // - `num`: always 1 in `on_memory_operation` - // - `align_bits`: always a constant because `address_space` is a constant - // - `size_bits`: RV32 instruction always read 4 bytes(in the AIR level). So `size` is - // always 4 bytes. So `size_bits` is always 2. - // - // If we ignore the deferral address space, `min_block_size_bits`` is always - // `DEFAULT_U8_BLOCK_SIZE=4`. Therefore, `align_bits` is always 2. So the loop will - // never be executed and we can leave the function empty. - Ok("".to_string()) - } /// Generate ASM code for updating the boundary merkle heights. /// diff --git a/extensions/rv32im/circuit/src/divrem/execution.rs b/extensions/rv32im/circuit/src/divrem/execution.rs index c1f6ed0aac..88cf74bb91 100644 --- a/extensions/rv32im/circuit/src/divrem/execution.rs +++ b/extensions/rv32im/circuit/src/divrem/execution.rs @@ -284,17 +284,11 @@ where chip_idx: usize, config: &SystemConfig, ) -> Result { - use crate::common::{update_adapter_heights_asm, update_height_change_asm}; + use crate::common::update_height_change_asm; let mut asm_str = self.generate_x86_asm(inst, pc)?; asm_str += &update_height_change_asm(chip_idx, 1)?; - // read [b:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - // read [c:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - // write [a:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; Ok(asm_str) } diff --git a/extensions/rv32im/circuit/src/jal_lui/execution.rs b/extensions/rv32im/circuit/src/jal_lui/execution.rs index 93a6ba50c9..a3e791f815 100644 --- a/extensions/rv32im/circuit/src/jal_lui/execution.rs +++ b/extensions/rv32im/circuit/src/jal_lui/execution.rs @@ -197,13 +197,8 @@ where chip_idx: usize, config: &SystemConfig, ) -> Result { - use crate::common::{update_adapter_heights_asm, update_height_change_asm}; - let enabled = !inst.f.is_zero(); + use crate::common::update_height_change_asm; let mut asm_str = update_height_change_asm(chip_idx, 1)?; - if enabled { - // write [a:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - } asm_str += &self.generate_x86_asm(inst, pc)?; Ok(asm_str) } diff --git a/extensions/rv32im/circuit/src/jalr/execution.rs b/extensions/rv32im/circuit/src/jalr/execution.rs index fb0d72de36..54531a5531 100644 --- a/extensions/rv32im/circuit/src/jalr/execution.rs +++ b/extensions/rv32im/circuit/src/jalr/execution.rs @@ -196,14 +196,7 @@ where chip_idx: usize, config: &SystemConfig, ) -> Result { - let enabled = !inst.f.is_zero(); let mut asm_str = update_height_change_asm(chip_idx, 1)?; - // read [b:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - if enabled { - // write [a:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - } asm_str += &self.generate_x86_asm(inst, pc)?; Ok(asm_str) } diff --git a/extensions/rv32im/circuit/src/less_than/execution.rs b/extensions/rv32im/circuit/src/less_than/execution.rs index 972f305d51..a9aebb435d 100644 --- a/extensions/rv32im/circuit/src/less_than/execution.rs +++ b/extensions/rv32im/circuit/src/less_than/execution.rs @@ -258,14 +258,6 @@ where ) -> Result { let mut asm_str = self.generate_x86_asm(inst, pc)?; asm_str += &update_height_change_asm(chip_idx, 1)?; - // read [b:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - if inst.e.as_canonical_u32() != RV32_IMM_AS { - // read [c:4]_e - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - } - // write [a:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; Ok(asm_str) } } diff --git a/extensions/rv32im/circuit/src/load_sign_extend/aot.rs b/extensions/rv32im/circuit/src/load_sign_extend/aot.rs index 34ef87c2e8..1ee81031e6 100644 --- a/extensions/rv32im/circuit/src/load_sign_extend/aot.rs +++ b/extensions/rv32im/circuit/src/load_sign_extend/aot.rs @@ -65,17 +65,7 @@ where ) })?; - let enabled = !inst.f.is_zero(); - let e_u32 = inst.e.as_canonical_u32(); asm_str += &update_height_change_asm(chip_idx, 1)?; - // [b:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - // read [[b:4]_1]_e - asm_str += &update_adapter_heights_asm(config, e_u32)?; - if enabled { - // write [a:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - } Ok(asm_str) } } diff --git a/extensions/rv32im/circuit/src/loadstore/aot.rs b/extensions/rv32im/circuit/src/loadstore/aot.rs index 110f9e7c21..8376a11c25 100644 --- a/extensions/rv32im/circuit/src/loadstore/aot.rs +++ b/extensions/rv32im/circuit/src/loadstore/aot.rs @@ -52,36 +52,7 @@ where ) })?; - let enabled = !inst.f.is_zero(); - let e_u32 = inst.e.as_canonical_u32(); - let local_opcode = Rv32LoadStoreOpcode::from_usize( - inst.opcode - .local_opcode_idx(Rv32LoadStoreOpcode::CLASS_OFFSET), - ); - let is_load = matches!( - local_opcode, - Rv32LoadStoreOpcode::LOADW | Rv32LoadStoreOpcode::LOADBU | Rv32LoadStoreOpcode::LOADHU - ); asm_str += &update_height_change_asm(chip_idx, 1)?; - // [b:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - // read or write [a:4]_1 - if is_load { - // read [[b:4]_1]_e - asm_str += &update_adapter_heights_asm(config, e_u32)?; - } else { - // read [a:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - } - if enabled { - if is_load { - // write [a:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - } else { - // write [[b:4]_1]_e - asm_str += &update_adapter_heights_asm(config, e_u32)?; - } - } Ok(asm_str) } } diff --git a/extensions/rv32im/circuit/src/loadstore/tests.rs b/extensions/rv32im/circuit/src/loadstore/tests.rs index 8aa91de439..3b3be8b9ca 100644 --- a/extensions/rv32im/circuit/src/loadstore/tests.rs +++ b/extensions/rv32im/circuit/src/loadstore/tests.rs @@ -216,8 +216,7 @@ fn rand_loadstore_test(opcode: Rv32LoadStoreOpcode, num_ops: usize) { if [STOREW, STOREB, STOREH].contains(&opcode) { mem_config.addr_spaces[PUBLIC_VALUES_AS as usize].num_cells = 1 << 29; } - // Use custom memory config so initial block size matches the 4-byte alignment and - // avoids access-adapter split/merge paths when adapters are disabled. + // Use custom memory config so initial block size matches the 4-byte alignment. let mut tester = VmChipTestBuilder::from_config(mem_config); let mut harness = create_harness(&mut tester); @@ -544,7 +543,7 @@ fn test_cuda_rand_load_store_tracegen(opcode: Rv32LoadStoreOpcode, num_ops: usiz ..Default::default() }; // Reduce pointer_max_bits and num_cells to avoid ~4GB Merkle tree GPU allocations. - // Merkle trees are now always built (volatile path was removed with access adapters). + // Merkle trees are now always built. mem_config.addr_spaces[RV32_REGISTER_AS as usize].num_cells = 1 << 20; mem_config.addr_spaces[RV32_MEMORY_AS as usize].num_cells = 1 << 20; if [STOREW, STOREB, STOREH].contains(&opcode) { diff --git a/extensions/rv32im/circuit/src/mul/execution.rs b/extensions/rv32im/circuit/src/mul/execution.rs index 53af909750..2db3306234 100644 --- a/extensions/rv32im/circuit/src/mul/execution.rs +++ b/extensions/rv32im/circuit/src/mul/execution.rs @@ -205,12 +205,6 @@ where let mut asm_str = self.generate_x86_asm(inst, pc)?; asm_str += &update_height_change_asm(chip_idx, 1)?; - // read [b:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - // read [c:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - // write [a:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; Ok(asm_str) } diff --git a/extensions/rv32im/circuit/src/mulh/execution.rs b/extensions/rv32im/circuit/src/mulh/execution.rs index fae4b357ee..bec98dc5cd 100644 --- a/extensions/rv32im/circuit/src/mulh/execution.rs +++ b/extensions/rv32im/circuit/src/mulh/execution.rs @@ -221,12 +221,6 @@ where let mut asm_str = self.generate_x86_asm(inst, pc)?; asm_str += &update_height_change_asm(chip_idx, 1)?; - // read [b:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - // read [c:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - // write [a:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; Ok(asm_str) } diff --git a/extensions/rv32im/circuit/src/shift/execution.rs b/extensions/rv32im/circuit/src/shift/execution.rs index d98451e46a..8a8766ab1e 100644 --- a/extensions/rv32im/circuit/src/shift/execution.rs +++ b/extensions/rv32im/circuit/src/shift/execution.rs @@ -245,17 +245,8 @@ where chip_idx: usize, config: &SystemConfig, ) -> Result { - let is_imm = inst.e.as_canonical_u32() == RV32_IMM_AS; let mut asm_str = self.generate_x86_asm(inst, pc)?; asm_str += &update_height_change_asm(chip_idx, 1)?; - // read [a:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - // read [b:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - if !is_imm { - // read [c:4]_1 - asm_str += &update_adapter_heights_asm(config, RV32_REGISTER_AS)?; - } Ok(asm_str) } } From 9accde8002a1894208f737e00e8c08a35155cee4 Mon Sep 17 00:00:00 2001 From: Paul Chen <77174148+876pol@users.noreply.github.com> Date: Mon, 16 Mar 2026 10:57:18 -0400 Subject: [PATCH 37/78] feat: change new SHA2 AIRs to have v2 max constraint degree <= 3 (#2550) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Resolves INT-6189. ### Summary Reduces the maximum v2 constraint degree of the SHA2 block hasher AIR from 4 to 3 by converting two degree-4 `when_transition()` constraints into unconditional (degree-3) constraints, and fixing the `global_block_idx` padding row constraint to be wrap-around safe. ### AIR Changes **1. Message schedule `intermed_4` constraint (line ~433):** Changed from `builder.when_transition().assert_eq(...)` to `builder.assert_eq(...)`. This removes one degree of multiplication (the transition selector), keeping the constraint at degree 3. The trace now fills dummy `intermed_4` values on the wrap-around edge (last row → first row) to satisfy the unconditional constraint. **2. Message schedule addition (`intermed_12`) constraint (line ~477):** Similarly changed `constraint_word_addition` from being called on `builder.when_transition()` to being called on `builder` directly. Dummy `intermed_12` and `carry_or_buffer` values are filled on wrap-around rows to compensate. **3. Global block index on padding rows (line ~276-283):** Previously constrained `global_block_idx == 0` on padding rows. Now constrains `global_block_idx` to be constant across padding rows (via a transition constraint). This removes the `when(is_digest_row) * when(is_round_row)` degree-4 interaction on the block boundary transition, since padding rows no longer need a different value from the last real block. **4. Global block index increment (line ~269-275):** Removed the extra `.when(*next_cols.flags.is_round_row)` condition from the block-boundary increment constraint, reducing its degree by 1. The padding row constancy constraint now handles the case where the next row after a digest row is a padding row (rather than needing to exclude it). --------- Co-authored-by: Golovanov399 --- crates/circuits/sha2-air/src/air.rs | 28 +++++------- crates/circuits/sha2-air/src/columns.rs | 3 +- crates/circuits/sha2-air/src/trace.rs | 2 + .../sha2/circuit/cuda/src/sha2_hasher.cu | 43 +++++++++++++++++- .../src/sha2_chips/block_hasher_chip/trace.rs | 45 ++++++++++++++++++- 5 files changed, 101 insertions(+), 20 deletions(-) diff --git a/crates/circuits/sha2-air/src/air.rs b/crates/circuits/sha2-air/src/air.rs index 803df2c688..af56fdeb7a 100644 --- a/crates/circuits/sha2-air/src/air.rs +++ b/crates/circuits/sha2-air/src/air.rs @@ -255,10 +255,6 @@ impl Sha2BlockHasherSubAir { .assert_eq(local_row_idx.clone() + delta, next_row_idx.clone()); builder.when_first_row().assert_zero(local_row_idx); - // Constrain the global block index starting with 1 so it is not the same as the padding - // rows. - // We set the global block index to 0 for padding rows - // Global block index is 1 on first row builder .when_first_row() @@ -273,15 +269,18 @@ impl Sha2BlockHasherSubAir { builder .when_transition() .when(*local_cols.flags.is_digest_row) - .when(*next_cols.flags.is_round_row) .assert_eq( *local_cols.flags.global_block_idx + AB::Expr::ONE, *next_cols.flags.global_block_idx, ); - // Global block index is 0 on padding rows + // Global block index is constant on padding rows builder + .when_transition() .when(local_is_padding_row.clone()) - .assert_zero(*local_cols.flags.global_block_idx); + .assert_eq( + *local_cols.flags.global_block_idx, + *next_cols.flags.global_block_idx, + ); // Constrain that all the padding rows have the same work vars as the last block's digest // row. We constrain elsewhere that the last block's digest row is equal to the first @@ -431,7 +430,7 @@ impl Sha2BlockHasherSubAir { // check because the degree is already 3. So we must fill in `intermed_4` with dummy // values on the first round row and the digest row (rows 0 and 16 for SHA-256) to // ensure the constraint holds on these rows. - builder.when_transition().assert_eq( + builder.assert_eq( next.schedule_helper.intermed_4[[i, j]], w_idx_limb + sig_w_limb, ); @@ -471,15 +470,12 @@ impl Sha2BlockHasherSubAir { .collect::>(); // Constrain `W_{idx} = sig_1(W_{idx-2}) + W_{idx-7} + sig_0(W_{idx-15}) + W_{idx-16}` - // We would like to constrain this only on rows 4..C::ROUND_ROWS, but we can't do a - // conditional check because the degree of sum is already 3 So we must fill - // in `intermed_12` with dummy values on rows 0..3 and C::ROUND_ROWS-1 and C::ROUND_ROWS - // to ensure the constraint holds on rows 0..4 and C::ROUND_ROWS. Note that - // the dummy value goes in the previous row to make the current row's constraint hold. + // We can't do a conditional check because the degree of the sum is already 3. + // Instead, we fill in dummy values on non-applicable rows: + // - `intermed_12` with dummy values on rows 0..3, C::ROUND_ROWS-1, and C::ROUND_ROWS + // - `carry_or_buffer` with dummy values on the first block's row 0 (wrap-around) constraint_word_addition::<_, C>( - // Note: here we can't do a conditional check because the degree of sum is already - // 3 - &mut builder.when_transition(), + builder, &[&small_sig1_field::( w.row(i + 2).as_slice().unwrap(), )], diff --git a/crates/circuits/sha2-air/src/columns.rs b/crates/circuits/sha2-air/src/columns.rs index 01088cbc54..69a22db864 100644 --- a/crates/circuits/sha2-air/src/columns.rs +++ b/crates/circuits/sha2-air/src/columns.rs @@ -143,7 +143,8 @@ pub struct Sha2FlagsCols { /// We will encode the row index [0..C::ROWS_PER_BLOCK] using ROW_VAR_CNT cells pub row_idx: [T; ROW_VAR_CNT], /// The global index of the current block, starts at 1 for the first block - /// and increments by 1 for each block. Set to 0 for padding rows. + /// and increments by 1 for each block. Padding rows use one more than the + /// last real block's index and remain constant across all padding rows. pub global_block_idx: T, } diff --git a/crates/circuits/sha2-air/src/trace.rs b/crates/circuits/sha2-air/src/trace.rs index 243f463687..0a3cb279aa 100644 --- a/crates/circuits/sha2-air/src/trace.rs +++ b/crates/circuits/sha2-air/src/trace.rs @@ -429,6 +429,7 @@ impl Sha2BlockHasherFillerHelper { first_block_prev_hash: &[C::Word], carry_a: Option<&[F]>, carry_e: Option<&[F]>, + global_block_idx: u32, ) { debug_assert!(first_block_prev_hash.len() == C::HASH_WORDS); debug_assert!(carry_a.is_some() == carry_e.is_some()); @@ -443,6 +444,7 @@ impl Sha2BlockHasherFillerHelper { &mut cols.flags.row_idx, get_flag_pt_array(&self.row_idx_encoder, C::ROWS_PER_BLOCK), ); + *cols.flags.global_block_idx = F::from_u32(global_block_idx); for i in 0..C::ROUNDS_PER_ROW { // The padding rows need to have the first block's prev_hash here, to satisfy the air diff --git a/extensions/sha2/circuit/cuda/src/sha2_hasher.cu b/extensions/sha2/circuit/cuda/src/sha2_hasher.cu index e0a3cb90c0..d1cdf9d672 100644 --- a/extensions/sha2/circuit/cuda/src/sha2_hasher.cu +++ b/extensions/sha2/circuit/cuda/src/sha2_hasher.cu @@ -450,11 +450,13 @@ template struct Sha2TraceHelper { const typename V::Word *first_block_prev_hash, Fp *carry_a, Fp *carry_e, + uint32_t global_block_idx, size_t trace_height ) const { RowSlice row_idx_flags = inner_row.slice_from(SHA2_COL_INDEX(V, Sha2RoundCols, flags.row_idx)); row_idx_encoder.write_flag_pt(row_idx_flags, V::ROWS_PER_BLOCK); + SHA2INNER_WRITE_ROUND(V, inner_row, flags.global_block_idx, Fp(global_block_idx)); for (uint32_t i = 0; i < V::ROUNDS_PER_ROW; i++) { uint32_t a_idx = V::ROUNDS_PER_ROW - i - 1; @@ -855,6 +857,8 @@ __global__ void sha2_first_pass_tracegen( template __global__ void sha2_fill_first_dummy_row(Fp *trace, size_t trace_height, size_t rows_used) { uint32_t row_idx = rows_used; + uint32_t total_blocks = rows_used / V::ROWS_PER_BLOCK; + uint32_t padding_global_block_idx = total_blocks + 1; uint32_t digest_row = V::ROUND_ROWS; if (digest_row >= trace_height) { @@ -886,7 +890,14 @@ __global__ void sha2_fill_first_dummy_row(Fp *trace, size_t trace_height, size_t RowSlice inner_row = row.slice_from(Sha2Layout::INNER_COLUMN_OFFSET); Sha2TraceHelper helper; - helper.generate_default_row(inner_row, prev_hash, nullptr, nullptr, trace_height); + helper.generate_default_row( + inner_row, + prev_hash, + nullptr, + nullptr, + padding_global_block_idx, + trace_height + ); helper.generate_carry_ae(inner_row, inner_row); } @@ -911,6 +922,8 @@ __global__ void sha2_fill_invalid_rows( ) { uint32_t thread_idx = blockIdx.x * blockDim.x + threadIdx.x; uint32_t first_dummy_row_idx = rows_used; + uint32_t total_blocks = rows_used / V::ROWS_PER_BLOCK; + uint32_t padding_global_block_idx = total_blocks + 1; // skip the first dummy row, since it is already filled uint32_t row_idx = first_dummy_row_idx + thread_idx + 1; if (row_idx >= trace_height) { @@ -931,10 +944,31 @@ __global__ void sha2_fill_invalid_rows( Sha2TraceHelper helper; helper.generate_default_row( - dst_inner, &d_prev_hashes[0], first_dummy_row_carry_a, first_dummy_row_carry_e, trace_height + dst_inner, + &d_prev_hashes[0], + first_dummy_row_carry_a, + first_dummy_row_carry_e, + padding_global_block_idx, + trace_height ); } +template +__global__ void sha2_fill_wraparound(Fp *trace, size_t trace_height) { + if (trace_height < 2) { + return; + } + + Sha2TraceHelper helper; + RowSlice first_row(trace, trace_height); + RowSlice first_inner = first_row.slice_from(Sha2Layout::INNER_COLUMN_OFFSET); + RowSlice last_row(trace + (trace_height - 1), trace_height); + RowSlice last_inner = last_row.slice_from(Sha2Layout::INNER_COLUMN_OFFSET); + + helper.generate_intermed_4(last_inner, first_inner); + helper.generate_intermed_12(last_inner, first_inner); +} + // ===== HOST LAUNCHER FUNCTIONS ===== template @@ -997,6 +1031,11 @@ int launch_sha2_second_pass_dependencies(Fp *d_trace, size_t trace_height, size_ auto [grid_size, block_size] = kernel_launch_params(total_blocks, 256); sha2_second_pass_dependencies <<>>(d_trace, trace_height, total_blocks); + if (auto err = CHECK_KERNEL() != 0) { + return err; + } + + sha2_fill_wraparound<<<1, 1>>>(d_trace, trace_height); return CHECK_KERNEL(); } diff --git a/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/trace.rs b/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/trace.rs index 1a55c1fc01..dd8dd78950 100644 --- a/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/trace.rs +++ b/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/trace.rs @@ -133,12 +133,15 @@ where // we need to do this first, so we can compute the carries that make the // constraint_word_addition constraints hold on dummy rows (or more precisely, on rows such // that the next row is a dummy row). + let num_blocks = rows_used / C::ROWS_PER_BLOCK; let first_dummy_row_cols_const = self.fill_first_dummy_row( &mut trace[rows_used * C::BLOCK_HASHER_WIDTH..(rows_used + 1) * C::BLOCK_HASHER_WIDTH], &prev_hashes[0], + num_blocks, ); // fill in the rest of the dummy rows + let padding_global_block_idx = (num_blocks + 1) as u32; trace[(rows_used + 1) * C::BLOCK_HASHER_WIDTH..] .par_chunks_exact_mut(C::BLOCK_HASHER_WIDTH) .for_each(|row| { @@ -162,6 +165,7 @@ where .as_slice() .unwrap(), ), + padding_global_block_idx, ); }); @@ -174,12 +178,50 @@ where self.inner .generate_missing_cells(chunk, C::BLOCK_HASHER_WIDTH, INNER_OFFSET); }); + + self.fill_wraparound(trace); + } + + /// Fill in dummy values for the wrap-around (last row → first row) so that + /// unconditional constraints hold: + /// - `intermed_4` on row 0 for the message schedule sigma constraint + /// - `intermed_12` on the last row for the message schedule addition constraint + fn fill_wraparound(&self, trace: &mut [F]) { + let height = trace.len() / C::BLOCK_HASHER_WIDTH; + let last_row_start = (height - 1) * C::BLOCK_HASHER_WIDTH; + + // Fill intermed_4 on the first row (needs first_row mut, last_row immut) + { + let (first_row, rest) = trace.split_at_mut(C::BLOCK_HASHER_WIDTH); + let last_row = &rest[(height - 2) * C::BLOCK_HASHER_WIDTH..]; + let local = Sha2RoundColsRef::from::( + &last_row[INNER_OFFSET..INNER_OFFSET + C::SUBAIR_ROUND_WIDTH], + ); + let mut next = Sha2RoundColsRefMut::from::( + &mut first_row[INNER_OFFSET..INNER_OFFSET + C::SUBAIR_ROUND_WIDTH], + ); + Sha2BlockHasherFillerHelper::::generate_intermed_4(local, &mut next); + } + + // Fill intermed_12 on the last row (needs last_row mut, first_row immut) + { + let (first_row, rest) = trace.split_at_mut(C::BLOCK_HASHER_WIDTH); + let next = Sha2RoundColsRef::from::( + &first_row[INNER_OFFSET..INNER_OFFSET + C::SUBAIR_ROUND_WIDTH], + ); + let last_row = &mut rest[last_row_start - C::BLOCK_HASHER_WIDTH..last_row_start]; + let mut local = Sha2RoundColsRefMut::from::( + &mut last_row[INNER_OFFSET..INNER_OFFSET + C::SUBAIR_ROUND_WIDTH], + ); + Sha2BlockHasherFillerHelper::::generate_intermed_12(&mut local, next); + } } fn fill_first_dummy_row( &self, first_dummy_row_mut: &mut [F], first_block_prev_hash: &[C::Word], + num_blocks: usize, ) -> Sha2RoundColsRef<'_, F> { let first_dummy_row_const = unsafe { slice::from_raw_parts(first_dummy_row_mut.as_ptr(), C::BLOCK_HASHER_WIDTH) }; @@ -195,12 +237,13 @@ where ); // first, fill in everything but the carries into the first dummy row (i.e. fill in the - // work vars and row_idx) + // work vars, row_idx, and global_block_idx) self.inner.generate_default_row( &mut first_dummy_row_cols_mut, first_block_prev_hash, None, None, + (num_blocks + 1) as u32, ); // Now, this will fill in the first dummy row with the correct carries. From f2ebc8de00a2335c4f0a537c2a657b38f404afde Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Mon, 16 Mar 2026 19:29:28 +0100 Subject: [PATCH 38/78] fix: rebase conflicts --- .github/workflows/benchmarks-execute.yml | 193 +++++++++--------- .github/workflows/pr-title.yml | 9 +- .github/workflows/primitives.yml | 7 + Cargo.lock | 6 + benchmarks/execute/benches/execute.rs | 5 +- benchmarks/utils/Cargo.toml | 15 ++ crates/sdk-config/src/lib.rs | 4 +- crates/sdk/src/prover/app.rs | 1 - crates/vm/src/arch/testing/cpu.rs | 8 +- crates/vm/src/system/memory/controller/mod.rs | 7 +- .../keccak256/circuit/src/extension/mod.rs | 6 +- .../keccak256/circuit/src/keccakf_op/trace.rs | 5 +- .../circuit/src/keccakf_perm/trace.rs | 5 +- extensions/sha2/circuit/src/extension/mod.rs | 6 +- .../src/sha2_chips/block_hasher_chip/trace.rs | 5 +- .../circuit/src/sha2_chips/main_chip/trace.rs | 5 +- guest-libs/keccak256/Cargo.toml | 4 +- guest-libs/keccak256/tests/lib.rs | 2 +- guest-libs/sha2/Cargo.toml | 4 +- guest-libs/sha2/tests/lib.rs | 2 +- 20 files changed, 163 insertions(+), 136 deletions(-) diff --git a/.github/workflows/benchmarks-execute.yml b/.github/workflows/benchmarks-execute.yml index d04e35f589..95fa25972b 100644 --- a/.github/workflows/benchmarks-execute.yml +++ b/.github/workflows/benchmarks-execute.yml @@ -2,8 +2,9 @@ name: "Execution benchmarks" on: workflow_call: - push: - branches: ["main"] + # TODO: re-enable after benchmarks are ported to v2 (native extensions removed) + # push: + # branches: ["main"] # pull_request: # types: [opened, synchronize, reopened, labeled] # branches: ["**"] @@ -29,97 +30,97 @@ env: JEMALLOC_SYS_WITH_MALLOC_CONF: "retain:true,background_thread:true,metadata_thp:always,thp:always,dirty_decay_ms:10000,muzzy_decay_ms:10000,abort_conf:true" TOOLCHAIN: "+nightly-2025-08-19" -jobs: {} - # codspeed-walltime-benchmarks: - # name: Run codspeed walltime benchmarks - # runs-on: - # - runs-on=${{ github.run_id }} - # - family=m5a.16xlarge # 2.5Ghz clock speed - # - image=ubuntu24-full-x64 - # - extras=s3-cache - # - # env: - # CODSPEED_RUNNER_MODE: walltime - # CODSPEED_PROFILING: "false" - # - # steps: - # - uses: runs-on/action@v2 - # - uses: actions/checkout@v5 - # - uses: dtolnay/rust-toolchain@stable - # - uses: Swatinem/rust-cache@v2 - # with: - # cache-on-failure: true - # - # - name: Install architecture specific tools - # run: | - # source ci/scripts/utils.sh - # install_s5cmd - # - # - name: Pull fixtures from S3 - # run: | - # mkdir -p benchmarks/fixtures - # s5cmd cp "${{ env.S3_FIXTURES_PATH }}/*" benchmarks/fixtures/ || echo "No fixtures found in S3" - # - # - name: Install cargo-binstall - # uses: cargo-bins/cargo-binstall@main - # - name: Install codspeed - # run: cargo binstall --no-confirm --force cargo-codspeed - # - # - name: Build benchmarks - # working-directory: benchmarks/execute - # run: cargo $TOOLCHAIN codspeed build --profile maxperf --features aot --bench execute - # - name: Run benchmarks - # uses: CodSpeedHQ/action@v3 - # with: - # working-directory: benchmarks/execute - # run: cargo $TOOLCHAIN codspeed run - # token: ${{ secrets.CODSPEED_TOKEN }} - # - # codspeed-instrumentation-benchmarks: - # name: Run codspeed instrumentation benchmarks - # runs-on: - # - runs-on=${{ github.run_id }}/family=m5a.xlarge/image=ubuntu24-full-x64/extras=s3-cache - # if: github.event_name != 'pull_request' - # - # env: - # CODSPEED_RUNNER_MODE: instrumentation - # - # steps: - # - uses: runs-on/action@v2 - # - uses: actions/checkout@v5 - # - uses: dtolnay/rust-toolchain@stable - # - uses: Swatinem/rust-cache@v2 - # with: - # cache-on-failure: true - # - # - name: Install architecture specific tools - # run: | - # source ci/scripts/utils.sh - # install_s5cmd - # - # - name: Pull fixtures from S3 - # run: | - # mkdir -p benchmarks/fixtures - # s5cmd cp "${{ env.S3_FIXTURES_PATH }}/*" benchmarks/fixtures/ || echo "No fixtures found in S3" - # - # - name: Install cargo-binstall - # uses: cargo-bins/cargo-binstall@main - # - name: Install codspeed - # run: cargo binstall --no-confirm --force cargo-codspeed - # - # - name: Create codspeed-post-bench symlink - # run: | - # # codspeed-post-bench is just a sym-link - # which codspeed-post-bench || echo "codspeed-post-bench not found" - # sudo ln -sf ~/.cargo/bin/cargo-codspeed /usr/local/bin/codspeed-post-bench - # ls -la /usr/local/bin/codspeed-post-bench - # - # - name: Build benchmarks - # working-directory: benchmarks/execute - # run: cargo $TOOLCHAIN codspeed build --features aot --bench execute - # - name: Run benchmarks - # uses: CodSpeedHQ/action@v3 - # with: - # working-directory: benchmarks/execute - # run: cargo $TOOLCHAIN codspeed run - # token: ${{ secrets.CODSPEED_TOKEN }} +jobs: + codspeed-walltime-benchmarks: + name: Run codspeed walltime benchmarks + runs-on: + - runs-on=${{ github.run_id }} + - family=m5a.16xlarge # 2.5Ghz clock speed + - image=ubuntu24-full-x64 + - extras=s3-cache + + env: + CODSPEED_RUNNER_MODE: walltime + CODSPEED_PROFILING: "false" + + steps: + - uses: runs-on/action@v2 + - uses: actions/checkout@v5 + - uses: dtolnay/rust-toolchain@stable + - uses: Swatinem/rust-cache@v2 + with: + cache-on-failure: true + + - name: Install architecture specific tools + run: | + source ci/scripts/utils.sh + install_s5cmd + + - name: Pull fixtures from S3 + run: | + mkdir -p benchmarks/fixtures + s5cmd cp "${{ env.S3_FIXTURES_PATH }}/*" benchmarks/fixtures/ || echo "No fixtures found in S3" + + - name: Install cargo-binstall + uses: cargo-bins/cargo-binstall@main + - name: Install codspeed + run: cargo binstall --no-confirm --force cargo-codspeed + + - name: Build benchmarks + working-directory: benchmarks/execute + run: cargo $TOOLCHAIN codspeed build --profile maxperf --features aot --bench execute + - name: Run benchmarks + uses: CodSpeedHQ/action@v3 + with: + working-directory: benchmarks/execute + run: cargo $TOOLCHAIN codspeed run + token: ${{ secrets.CODSPEED_TOKEN }} + + codspeed-instrumentation-benchmarks: + name: Run codspeed instrumentation benchmarks + runs-on: + - runs-on=${{ github.run_id }}/family=m5a.xlarge/image=ubuntu24-full-x64/extras=s3-cache + if: github.event_name != 'pull_request' + + env: + CODSPEED_RUNNER_MODE: instrumentation + + steps: + - uses: runs-on/action@v2 + - uses: actions/checkout@v5 + - uses: dtolnay/rust-toolchain@stable + - uses: Swatinem/rust-cache@v2 + with: + cache-on-failure: true + + - name: Install architecture specific tools + run: | + source ci/scripts/utils.sh + install_s5cmd + + - name: Pull fixtures from S3 + run: | + mkdir -p benchmarks/fixtures + s5cmd cp "${{ env.S3_FIXTURES_PATH }}/*" benchmarks/fixtures/ || echo "No fixtures found in S3" + + - name: Install cargo-binstall + uses: cargo-bins/cargo-binstall@main + - name: Install codspeed + run: cargo binstall --no-confirm --force cargo-codspeed + + - name: Create codspeed-post-bench symlink + run: | + # codspeed-post-bench is just a sym-link + which codspeed-post-bench || echo "codspeed-post-bench not found" + sudo ln -sf ~/.cargo/bin/cargo-codspeed /usr/local/bin/codspeed-post-bench + ls -la /usr/local/bin/codspeed-post-bench + + - name: Build benchmarks + working-directory: benchmarks/execute + run: cargo $TOOLCHAIN codspeed build --features aot --bench execute + - name: Run benchmarks + uses: CodSpeedHQ/action@v3 + with: + working-directory: benchmarks/execute + run: cargo $TOOLCHAIN codspeed run + token: ${{ secrets.CODSPEED_TOKEN }} diff --git a/.github/workflows/pr-title.yml b/.github/workflows/pr-title.yml index 8a6dd9b231..26989690ec 100644 --- a/.github/workflows/pr-title.yml +++ b/.github/workflows/pr-title.yml @@ -84,10 +84,11 @@ jobs: if: steps.lint_pr_title.outcome == 'failure' run: exit 1 - execute-benchmarks: - name: Execute benchmarks - uses: ./.github/workflows/benchmarks-execute.yml - secrets: inherit + # TODO: re-enable after benchmarks are ported to v2 (native extensions removed) + # execute-benchmarks: + # name: Execute benchmarks + # uses: ./.github/workflows/benchmarks-execute.yml + # secrets: inherit extension-tests: name: Extension tests diff --git a/.github/workflows/primitives.yml b/.github/workflows/primitives.yml index 1ee2f6efcb..84ed2b906f 100644 --- a/.github/workflows/primitives.yml +++ b/.github/workflows/primitives.yml @@ -64,6 +64,13 @@ jobs: run: | cargo nextest run ${{ env.NEXTEST_ARGS }} + # sha2-air has no tests; skipping to avoid upstream openvm-cpu-backend parallel compilation issue + # - name: Run tests for sha2-air + # if: ${{ !contains(matrix.platform.runner, 'gpu') }} + # working-directory: crates/circuits/sha2-air + # run: | + # cargo nextest run ${{ env.NEXTEST_ARGS }} + - name: Run tests for mod-builder if: ${{ !contains(matrix.platform.runner, 'gpu') }} working-directory: crates/circuits/mod-builder diff --git a/Cargo.lock b/Cargo.lock index 74e4142e02..4ae38ce59d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6149,11 +6149,17 @@ dependencies = [ name = "openvm-benchmarks-utils" version = "2.0.0-alpha" dependencies = [ + "bitcode", "cargo_metadata", "clap", "eyre", "openvm-build", + "openvm-circuit", + "openvm-continuations", + "openvm-sdk", + "openvm-stark-sdk", "openvm-transpiler", + "serde", "tempfile", "tracing", "tracing-subscriber 0.3.23", diff --git a/benchmarks/execute/benches/execute.rs b/benchmarks/execute/benches/execute.rs index a43060e174..a23bcf3fcf 100644 --- a/benchmarks/execute/benches/execute.rs +++ b/benchmarks/execute/benches/execute.rs @@ -49,11 +49,12 @@ use openvm_stark_sdk::{ config::baby_bear_poseidon2::BabyBearPoseidon2CpuEngine, openvm_cpu_backend::{CpuBackend, CpuDevice}, openvm_stark_backend::{ - self, keygen::types::MultiStarkProvingKey, prover::DeviceDataTransporter, StarkEngine, - StarkProtocolConfig, SystemParams, Val, + self, keygen::types::MultiStarkProvingKey, proof::Proof, + prover::DeviceDataTransporter, StarkEngine, StarkProtocolConfig, SystemParams, Val, }, p3_baby_bear::BabyBear, }; +use openvm_cpu_backend::{CpuBackend, CpuDevice}; use openvm_transpiler::{transpiler::Transpiler, FromElf}; use serde::{Deserialize, Serialize}; diff --git a/benchmarks/utils/Cargo.toml b/benchmarks/utils/Cargo.toml index 49df7d7309..8a613e7008 100644 --- a/benchmarks/utils/Cargo.toml +++ b/benchmarks/utils/Cargo.toml @@ -17,12 +17,27 @@ eyre.workspace = true tempfile.workspace = true tracing.workspace = true tracing-subscriber.workspace = true +bitcode = { workspace = true, optional = true } +serde = { workspace = true, optional = true } + +openvm-circuit = { workspace = true, optional = true } +openvm-continuations = { workspace = true, optional = true } +openvm-sdk = { workspace = true, optional = true } +openvm-stark-sdk = { workspace = true, optional = true } [dev-dependencies] [features] default = [] build-elfs = [] +generate-fixtures = [ + "dep:bitcode", + "dep:serde", + "dep:openvm-circuit", + "dep:openvm-continuations", + "dep:openvm-sdk", + "dep:openvm-stark-sdk", +] [[bin]] name = "build-elfs" diff --git a/crates/sdk-config/src/lib.rs b/crates/sdk-config/src/lib.rs index 2026ba23a1..c5d057b0d8 100644 --- a/crates/sdk-config/src/lib.rs +++ b/crates/sdk-config/src/lib.rs @@ -19,8 +19,8 @@ use openvm_pairing_circuit::*; use openvm_pairing_transpiler::*; use openvm_rv32im_circuit::*; use openvm_rv32im_transpiler::*; -use openvm_sha256_circuit::*; -use openvm_sha256_transpiler::*; +use openvm_sha2_circuit::*; +use openvm_sha2_transpiler::*; use openvm_stark_backend::{p3_field::Field, StarkEngine, StarkProtocolConfig, Val}; use openvm_stark_sdk::config::baby_bear_poseidon2::F; use openvm_transpiler::transpiler::Transpiler; diff --git a/crates/sdk/src/prover/app.rs b/crates/sdk/src/prover/app.rs index d5157c8b5c..3f54ba6aa7 100644 --- a/crates/sdk/src/prover/app.rs +++ b/crates/sdk/src/prover/app.rs @@ -123,7 +123,6 @@ where + MeteredExecutor> + PreflightExecutor, VB::RecordArena>, { - assert!(self.vm_config().as_ref().continuation_enabled); check_max_constraint_degrees( self.vm_config().as_ref(), self.app_vm_vk.inner.max_constraint_degree(), diff --git a/crates/vm/src/arch/testing/cpu.rs b/crates/vm/src/arch/testing/cpu.rs index 183d82d459..5c8f33552a 100644 --- a/crates/vm/src/arch/testing/cpu.rs +++ b/crates/vm/src/arch/testing/cpu.rs @@ -7,7 +7,7 @@ use openvm_circuit_primitives::{ }, Chip, }; -use openvm_cpu_backend::{CpuBackend, CpuProverError}; +use openvm_cpu_backend::{CpuBackend, CpuDevice, CpuProverError}; use openvm_instructions::{ instruction::Instruction, riscv::{RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS}, @@ -17,7 +17,6 @@ use openvm_poseidon2_air::Poseidon2SubAir; use openvm_stark_backend::{ interaction::{LookupBus, PermutationCheckBus}, p3_matrix::dense::RowMajorMatrix, - p3_util::log2_strict_usize, prover::AirProvingContext, AirRef, AnyAir, StarkEngine, StarkProtocolConfig, StarkTestError, SystemParams, Val, VerificationData, @@ -516,10 +515,7 @@ where P: Fn(&mut RowMajorMatrix>), { let mut ctx = chip.generate_proving_ctx(()); - let mut trace = - StridedColMajorMatrixView::from(ctx.common_main.as_view()).to_row_major_matrix(); - modify_trace(&mut trace); - ctx.common_main = ColMajorMatrix::from_row_major(&trace); + modify_trace(&mut ctx.common_main); self.air_ctxs.push((Arc::new(air), ctx)); self } diff --git a/crates/vm/src/system/memory/controller/mod.rs b/crates/vm/src/system/memory/controller/mod.rs index f7958e1cea..94f57dbc5f 100644 --- a/crates/vm/src/system/memory/controller/mod.rs +++ b/crates/vm/src/system/memory/controller/mod.rs @@ -11,11 +11,8 @@ use openvm_circuit_primitives::{ }; use openvm_cpu_backend::CpuBackend; use openvm_stark_backend::{ - interaction::PermutationCheckBus, - p3_field::PrimeField32, - p3_util::log2_strict_usize, - prover::AirProvingContext, - StarkProtocolConfig, + interaction::PermutationCheckBus, p3_field::PrimeField32, p3_util::log2_strict_usize, + prover::AirProvingContext, StarkProtocolConfig, }; use serde::{Deserialize, Serialize}; diff --git a/extensions/keccak256/circuit/src/extension/mod.rs b/extensions/keccak256/circuit/src/extension/mod.rs index 64a802f242..3d6f93ac9d 100644 --- a/extensions/keccak256/circuit/src/extension/mod.rs +++ b/extensions/keccak256/circuit/src/extension/mod.rs @@ -23,11 +23,13 @@ use openvm_circuit_primitives::bitwise_op_lookup::{ }; use openvm_cpu_backend::{CpuBackend, CpuDevice}; use openvm_instructions::*; -use openvm_keccak256_transpiler::{KeccakfOpcode, Rv32KeccakOpcode, XorinOpcode}; +use openvm_keccak256_transpiler::{KeccakfOpcode, XorinOpcode}; use openvm_rv32im_circuit::{ Rv32I, Rv32IExecutor, Rv32ImCpuProverExt, Rv32Io, Rv32IoExecutor, Rv32M, Rv32MExecutor, }; -use openvm_stark_backend::{p3_field::PrimeField32, StarkEngine, StarkProtocolConfig, Val}; +use openvm_stark_backend::{ + interaction::PermutationCheckBus, p3_field::PrimeField32, StarkEngine, StarkProtocolConfig, Val, +}; use serde::{Deserialize, Serialize}; use strum::IntoEnumIterator; diff --git a/extensions/keccak256/circuit/src/keccakf_op/trace.rs b/extensions/keccak256/circuit/src/keccakf_op/trace.rs index 2a0ad5fb48..7d26f51bbd 100644 --- a/extensions/keccak256/circuit/src/keccakf_op/trace.rs +++ b/extensions/keccak256/circuit/src/keccakf_op/trace.rs @@ -15,6 +15,7 @@ use openvm_circuit::{ use openvm_circuit_primitives::{ bitwise_op_lookup::SharedBitwiseOperationLookupChip, AlignedBytesBorrow, Chip, }; +use openvm_cpu_backend::CpuBackend; use openvm_instructions::{ instruction::Instruction, program::DEFAULT_PC_STEP, @@ -26,7 +27,7 @@ use openvm_stark_backend::{ p3_field::PrimeField32, p3_matrix::{dense::RowMajorMatrix, Matrix}, p3_maybe_rayon::prelude::*, - prover::{AirProvingContext, ColMajorMatrix, CpuBackend}, + prover::AirProvingContext, StarkProtocolConfig, Val, }; @@ -58,7 +59,7 @@ where let mut trace = arena.into_matrix(); let mem_helper = self.mem_helper.as_borrowed(); self.fill_trace(&mem_helper, &mut trace, rows_used); - AirProvingContext::simple_no_pis(ColMajorMatrix::from_row_major(&trace)) + AirProvingContext::simple_no_pis(trace) } } diff --git a/extensions/keccak256/circuit/src/keccakf_perm/trace.rs b/extensions/keccak256/circuit/src/keccakf_perm/trace.rs index ada5e73063..b05592c993 100644 --- a/extensions/keccak256/circuit/src/keccakf_perm/trace.rs +++ b/extensions/keccak256/circuit/src/keccakf_perm/trace.rs @@ -5,11 +5,12 @@ use std::{ }; use openvm_circuit_primitives::Chip; +use openvm_cpu_backend::CpuBackend; use openvm_stark_backend::{ p3_field::{PrimeCharacteristicRing, PrimeField32}, p3_matrix::{dense::RowMajorMatrix, Matrix}, p3_maybe_rayon::prelude::*, - prover::{AirProvingContext, ColMajorMatrix, CpuBackend}, + prover::AirProvingContext, StarkProtocolConfig, Val, }; use p3_keccak_air::{generate_trace_rows, NUM_KECCAK_COLS, NUM_ROUNDS}; @@ -69,6 +70,6 @@ where } }); let matrix = RowMajorMatrix::new(values, NUM_KECCAKF_PERM_COLS); - AirProvingContext::simple_no_pis(ColMajorMatrix::from_row_major(&matrix)) + AirProvingContext::simple_no_pis(matrix) } } diff --git a/extensions/sha2/circuit/src/extension/mod.rs b/extensions/sha2/circuit/src/extension/mod.rs index abab4cd3a8..b8d4b3c4c3 100644 --- a/extensions/sha2/circuit/src/extension/mod.rs +++ b/extensions/sha2/circuit/src/extension/mod.rs @@ -18,16 +18,14 @@ use openvm_circuit_primitives::bitwise_op_lookup::{ BitwiseOperationLookupAir, BitwiseOperationLookupBus, BitwiseOperationLookupChip, SharedBitwiseOperationLookupChip, }; +use openvm_cpu_backend::{CpuBackend, CpuDevice}; use openvm_instructions::LocalOpcode; use openvm_rv32im_circuit::{ Rv32I, Rv32IExecutor, Rv32ImCpuProverExt, Rv32Io, Rv32IoExecutor, Rv32M, Rv32MExecutor, }; use openvm_sha2_air::{Sha256Config, Sha512Config}; use openvm_sha2_transpiler::Rv32Sha2Opcode; -use openvm_stark_backend::{ - prover::{CpuBackend, CpuDevice}, - StarkEngine, StarkProtocolConfig, Val, -}; +use openvm_stark_backend::{StarkEngine, StarkProtocolConfig, Val}; use serde::{Deserialize, Serialize}; use crate::{Sha2BlockHasherChip, Sha2BlockHasherVmAir, Sha2MainAir, Sha2MainChip, Sha2VmExecutor}; diff --git a/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/trace.rs b/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/trace.rs index dd8dd78950..aab32e9166 100644 --- a/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/trace.rs +++ b/extensions/sha2/circuit/src/sha2_chips/block_hasher_chip/trace.rs @@ -2,6 +2,7 @@ use std::slice; use openvm_circuit::arch::get_record_from_slice; use openvm_circuit_primitives::{utils::next_power_of_two_or_zero, Chip}; +use openvm_cpu_backend::CpuBackend; use openvm_sha2_air::{ be_limbs_into_word, le_limbs_into_word, Sha2BlockHasherFillerHelper, Sha2RoundColsRef, Sha2RoundColsRefMut, @@ -10,7 +11,7 @@ use openvm_stark_backend::{ p3_field::{PrimeCharacteristicRing, PrimeField32}, p3_matrix::dense::RowMajorMatrix, p3_maybe_rayon::prelude::*, - prover::{AirProvingContext, ColMajorMatrix, CpuBackend}, + prover::AirProvingContext, StarkProtocolConfig, Val, }; @@ -39,7 +40,7 @@ where self.fill_trace(&mut trace_matrix, &mut records, rows_used); - AirProvingContext::simple_no_pis(ColMajorMatrix::from_row_major(&trace_matrix)) + AirProvingContext::simple_no_pis(trace_matrix) } } diff --git a/extensions/sha2/circuit/src/sha2_chips/main_chip/trace.rs b/extensions/sha2/circuit/src/sha2_chips/main_chip/trace.rs index 87a1e086ee..dffa0f0e28 100644 --- a/extensions/sha2/circuit/src/sha2_chips/main_chip/trace.rs +++ b/extensions/sha2/circuit/src/sha2_chips/main_chip/trace.rs @@ -7,13 +7,14 @@ use openvm_circuit::{ utils::next_power_of_two_or_zero, }; use openvm_circuit_primitives::Chip; +use openvm_cpu_backend::CpuBackend; use openvm_instructions::riscv::{RV32_CELL_BITS, RV32_REGISTER_NUM_LIMBS}; use openvm_sha2_air::set_arrayview_from_u8_slice; use openvm_stark_backend::{ p3_field::{PrimeCharacteristicRing, PrimeField32}, p3_matrix::{dense::RowMajorMatrix, Matrix}, p3_maybe_rayon::prelude::*, - prover::{AirProvingContext, ColMajorMatrix, CpuBackend}, + prover::AirProvingContext, StarkProtocolConfig, Val, }; @@ -55,7 +56,7 @@ where matrix: records, }); - AirProvingContext::simple_no_pis(ColMajorMatrix::from_row_major(&trace_matrix)) + AirProvingContext::simple_no_pis(trace_matrix) } } diff --git a/guest-libs/keccak256/Cargo.toml b/guest-libs/keccak256/Cargo.toml index ef71bdfc88..f26603781a 100644 --- a/guest-libs/keccak256/Cargo.toml +++ b/guest-libs/keccak256/Cargo.toml @@ -19,7 +19,7 @@ spin = { workspace = true, features = ["mutex", "spin_mutex"] } [dev-dependencies] hex = { workspace = true } openvm-instructions = { workspace = true } -sdk-v2 = { workspace = true } +openvm-sdk = { workspace = true } openvm-stark-sdk = { workspace = true } openvm-circuit = { workspace = true, features = ["test-utils", "parallel"] } openvm-transpiler = { workspace = true } @@ -31,7 +31,7 @@ eyre = { workspace = true } [features] default = ["tiny_keccak"] -aot = ["sdk-v2/aot"] +aot = ["openvm-sdk/aot"] # Internal feature for testing only. cuda = ["openvm-keccak256-circuit/cuda"] # Enable tiny_keccak::Hasher trait implementation diff --git a/guest-libs/keccak256/tests/lib.rs b/guest-libs/keccak256/tests/lib.rs index fb242b88ef..ce89ab550b 100644 --- a/guest-libs/keccak256/tests/lib.rs +++ b/guest-libs/keccak256/tests/lib.rs @@ -15,10 +15,10 @@ mod tests { use openvm_rv32im_transpiler::{ Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension, }; + use openvm_sdk::StdIn; use openvm_stark_sdk::p3_baby_bear::BabyBear; use openvm_toolchain_tests::{build_example_program_at_path, get_programs_dir}; use openvm_transpiler::{transpiler::Transpiler, FromElf}; - use sdk_v2::StdIn; type F = BabyBear; diff --git a/guest-libs/sha2/Cargo.toml b/guest-libs/sha2/Cargo.toml index 7a92d13696..ca880f9118 100644 --- a/guest-libs/sha2/Cargo.toml +++ b/guest-libs/sha2/Cargo.toml @@ -17,7 +17,7 @@ sha2 = { workspace = true, default-features = false, optional = true } [dev-dependencies] hex = { workspace = true } openvm-instructions = { workspace = true } -sdk-v2 = { workspace = true } +openvm-sdk = { workspace = true } openvm-stark-sdk = { workspace = true } openvm-circuit = { workspace = true, features = ["test-utils", "parallel"] } openvm-transpiler = { workspace = true } @@ -31,6 +31,6 @@ eyre = { workspace = true } default = ["import_sha2"] # Enable sha2::Digest trait implementation import_sha2 = ["dep:sha2"] -aot = ["sdk-v2/aot"] +aot = ["openvm-sdk/aot"] # Internal feature for testing only. cuda = ["openvm-sha2-circuit/cuda"] diff --git a/guest-libs/sha2/tests/lib.rs b/guest-libs/sha2/tests/lib.rs index 690b903dae..aaf64382e0 100644 --- a/guest-libs/sha2/tests/lib.rs +++ b/guest-libs/sha2/tests/lib.rs @@ -9,12 +9,12 @@ mod tests { use openvm_rv32im_transpiler::{ Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension, }; + use openvm_sdk::StdIn; use openvm_sha2_circuit::{Sha2Rv32Builder, Sha2Rv32Config}; use openvm_sha2_transpiler::Sha2TranspilerExtension; use openvm_stark_sdk::p3_baby_bear::BabyBear; use openvm_toolchain_tests::{build_example_program_at_path, get_programs_dir}; use openvm_transpiler::{transpiler::Transpiler, FromElf}; - use sdk_v2::StdIn; type F = BabyBear; From 93a64de1153b48201d1f63a3009b5008312a0f44 Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Tue, 17 Mar 2026 22:05:27 +0530 Subject: [PATCH 39/78] fix(v2-rc.1): simplify memory subsystem after access adapter removal (#2552) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This PR simplifies the memory subsystem now that access adapters (split/merge logic) have been removed. The key changes are: 1. **Remove `AccessMetadata` and all split/merge machinery** from `TracingMemory` — metadata is now a plain `u32` timestamp per block slot instead of a packed struct with block size and offset fields. 2. **Rename `min_block_size` → `block_size`** — without access adapters there is no "minimum" concept; each address space has a single fixed block size. 3. **Remove the `ALIGN` const generic** from `TracingMemory::read/write` — alignment is now looked up at runtime from `self.block_size[addr_space]`, eliminating a redundant generic parameter. 4. **Consolidate block size constants** — `DEFAULT_U8_BLOCK_SIZE`, `DEFAULT_NATIVE_BLOCK_SIZE`, `CONST_BLOCK_SIZE`, and `MEMORY_OP_SIZE` are all replaced by a single `DEFAULT_BLOCK_SIZE = 4`. 5. **Replace runtime state with compile-time constants** in `MemoryCtx` — `chunk`, `chunk_bits`, `boundary_idx`, `merkle_tree_index` fields are removed in favor of `CHUNK`, `CHUNK_BITS`, `BOUNDARY_AIR_ID`, `MERKLE_AIR_ID` constants. **No AIR changes.** This is purely a host-side simplification of execution and trace generation code. --- - **Removed**: `AccessMetadata` struct (packed timestamp + log2(block_size) + offset_to_start), along with all methods: `get_block_metadata`, `get_timestamp`, `set_meta_block`, `calculate_splits_and_merges`, `split_by_meta`, `handle_uninitialized_memory`. - **Removed**: Constants `MAX_BLOCK_SIZE`, `MIN_ALIGN`, `MAX_SEGMENTS`. - **Simplified `TracingMemory`**: - `meta` field: `Vec>` → `Vec>` (just timestamps). - `min_block_size` → `block_size` (renamed). - Removed `initial_block_size` field and constructor parameter. - `read`/`write` signatures: `` → ``. The alignment is now derived at runtime from `self.block_size[addr_space]`. - `prev_access_time`: iterates over `BLOCK_SIZE / block_size` metadata slots, takes max timestamp, and updates all slots to current timestamp. - `assert_alignment` → `assert_block_aligned` (renamed, simplified). - `address_space_alignment()` → `block_size_bits()` (renamed). - `touched_blocks` / `touched_blocks_to_equipartition`: simplified to use plain `u32` timestamps instead of `AccessMetadata`. - **Removed**: `DEFAULT_U8_BLOCK_SIZE`, `DEFAULT_NATIVE_BLOCK_SIZE`, `CONST_BLOCK_SIZE` constants. - **Added**: Single `pub const DEFAULT_BLOCK_SIZE: usize = 4`. - **Renamed**: `AddressSpaceHostConfig::min_block_size` → `block_size`. - **Renamed**: `MemoryConfig::min_block_size_bits()` → `block_size_bits()`. - **Removed**: `SystemConfig::initial_block_size()` method. - Default address space configs now all use `DEFAULT_BLOCK_SIZE` (including the fallback for unassigned address spaces, which previously used `DEFAULT_NATIVE_BLOCK_SIZE = 1`). - **Removed fields** from `MemoryCtx`: `chunk`, `chunk_bits`, `boundary_idx`, `merkle_tree_index`. - **Added module-level constants**: `CHUNK = DEFAULT_BLOCK_SIZE as u32`, `CHUNK_BITS = CHUNK.ilog2()`. - Uses `BOUNDARY_AIR_ID` and `MERKLE_AIR_ID` constants directly instead of storing copies. - Removed dead `if self.chunk == 1` branch in `update_boundary_merkle_heights`. - Debug assertions now use `BOUNDARY_AIR_ID` / `MERKLE_AIR_ID` constants directly. utils.rs) - `TracingMemory::new` / `from_image` no longer takes `initial_block_size` parameter. - `read`/`write` calls updated from 3 type params to 2 (dropped `ALIGN`). - `TracingMemory::from_image` call simplified (no block size arg). - Removed unused `system_config` variable. - Renamed `min_block_size` → `block_size` in `AddressSpaceHostConfig` construction. `system/mod.rs`, `system/cuda/` - `CONST_BLOCK_SIZE` → `DEFAULT_BLOCK_SIZE` rename only. --- - `timed_read` / `timed_write`: dropped `ALIGN` type parameter from `TracingMemory` calls. - Updated safety comments to reference `block_size` instead of "minimum alignment". - Same `ALIGN` removal for `timed_read_deferral` / `timed_write_deferral`. - Updated safety comments. - Removed dead `initial_block_size` validation check (the method no longer exists). - `CONST_BLOCK_SIZE` → `DEFAULT_BLOCK_SIZE`. - `CONST_BLOCK_SIZE` → `DEFAULT_BLOCK_SIZE` rename only. --- - **Removed**: `MEMORY_OP_SIZE` constant and its TODO comment. - Functions (`split_memory_ops`, `join_memory_ops`, `memory_op_chunk`, `num_memory_ops`) now use `DEFAULT_BLOCK_SIZE` imported from `openvm_circuit::arch`. `output/air.rs`, `output/trace.rs`, `output/execution.rs` - Import `DEFAULT_BLOCK_SIZE` from `openvm_circuit::arch` instead of from `crate::utils`. - All `MEMORY_OP_SIZE` usages replaced with `DEFAULT_BLOCK_SIZE`. --- `extensions/bigint/circuit` - Pure `CONST_BLOCK_SIZE` → `DEFAULT_BLOCK_SIZE` rename across all files (extension definitions, executor/filler enums, test files). No behavioral changes. --- - **If all address spaces converge to the same block size**, the per-AS `block_size` field in `AddressSpaceHostConfig` and `TracingMemory` can be removed entirely, replaced by the single `DEFAULT_BLOCK_SIZE` constant everywhere. - **Several const generics (e.g., `BLOCK_SIZE` on `timed_read`/`timed_write`, adapter helpers) are always instantiated with `DEFAULT_BLOCK_SIZE` (= 4).** If no extension ever needs a different value, these can be collapsed to non-generic functions, reducing monomorphization bloat and simplifying call sites. - **`touched_blocks_to_equipartition` and `handle_touched_blocks` take a `CHUNK` const generic** but it's always `DEFAULT_BLOCK_SIZE`. Can remove the generic and use the constant directly. - **`handle_touched_blocks` is over-complicated when `block_size == CHUNK`** (which is always true now). The accumulation loop, `current_timestamps` vec, and max logic all collapse to a single entry per touched block. Towards INT-6630 --- crates/vm/src/arch/config.rs | 36 +- .../vm/src/arch/execution_mode/metered/ctx.rs | 11 +- .../arch/execution_mode/metered/memory_ctx.rs | 61 +- crates/vm/src/arch/testing/cpu.rs | 35 +- crates/vm/src/arch/testing/cuda.rs | 12 +- crates/vm/src/arch/testing/memory/cuda.rs | 4 +- crates/vm/src/arch/testing/memory/mod.rs | 4 +- crates/vm/src/arch/testing/utils.rs | 4 +- crates/vm/src/arch/vm.rs | 3 +- crates/vm/src/system/cuda/boundary.rs | 4 +- crates/vm/src/system/cuda/memory.rs | 8 +- crates/vm/src/system/cuda/merkle_tree/mod.rs | 8 +- crates/vm/src/system/memory/controller/mod.rs | 9 +- .../vm/src/system/memory/merkle/tests/mod.rs | 18 +- crates/vm/src/system/memory/online.rs | 524 +++--------------- crates/vm/src/system/memory/persistent.rs | 29 +- crates/vm/src/system/mod.rs | 4 +- .../algebra/circuit/src/extension/fp2.rs | 34 +- .../algebra/circuit/src/extension/hybrid.rs | 42 +- .../algebra/circuit/src/extension/modular.rs | 114 ++-- .../algebra/circuit/src/fp2_chip/tests.rs | 50 +- extensions/algebra/circuit/src/lib.rs | 6 +- .../algebra/circuit/src/modular_chip/tests.rs | 64 +-- extensions/bigint/circuit/src/common.rs | 13 +- extensions/bigint/circuit/src/cuda/mod.rs | 42 +- extensions/bigint/circuit/src/lib.rs | 46 +- extensions/bigint/circuit/src/tests.rs | 6 +- extensions/deferral/circuit/src/call/air.rs | 27 +- .../deferral/circuit/src/call/execution.rs | 27 +- extensions/deferral/circuit/src/call/trace.rs | 27 +- extensions/deferral/circuit/src/output/air.rs | 11 +- .../deferral/circuit/src/output/execution.rs | 13 +- .../deferral/circuit/src/output/trace.rs | 21 +- extensions/deferral/circuit/src/utils.rs | 24 +- .../ecc/circuit/src/extension/hybrid.rs | 18 +- .../ecc/circuit/src/extension/weierstrass.rs | 34 +- extensions/ecc/circuit/src/lib.rs | 6 +- .../ecc/circuit/src/weierstrass_chip/tests.rs | 28 +- .../rv32im/circuit/src/adapters/deferral.rs | 199 +++++++ extensions/rv32im/circuit/src/adapters/mod.rs | 20 +- .../rv32im/circuit/src/base_alu/tests.rs | 2 +- extensions/rv32im/circuit/src/common/mod.rs | 10 +- 42 files changed, 739 insertions(+), 919 deletions(-) create mode 100644 extensions/rv32im/circuit/src/adapters/deferral.rs diff --git a/crates/vm/src/arch/config.rs b/crates/vm/src/arch/config.rs index 639dc15802..ee8e7b2ea9 100644 --- a/crates/vm/src/arch/config.rs +++ b/crates/vm/src/arch/config.rs @@ -110,14 +110,9 @@ where pub const OPENVM_DEFAULT_INIT_FILE_BASENAME: &str = "openvm_init"; pub const OPENVM_DEFAULT_INIT_FILE_NAME: &str = "openvm_init.rs"; -/// The minimum block size is 4, but RISC-V `lb` only requires alignment of 1 and `lh` only requires -/// alignment of 2 because the instructions are implemented by doing an access of block size 4. -const DEFAULT_U8_BLOCK_SIZE: usize = 4; -const DEFAULT_FIELD_BLOCK_SIZE: usize = 1; - -/// The constant block size used for all memory accesses. -/// This is also the block size used by the Boundary AIR for memory bus interactions. -pub const CONST_BLOCK_SIZE: usize = DEFAULT_U8_BLOCK_SIZE; +/// Default block size for memory bus interactions. RISC-V byte/halfword loads (`lb`/`lh`) need +/// fewer bytes, but the adapter always reads a full 4-byte block from memory. +pub const DEFAULT_BLOCK_SIZE: usize = 4; /// Trait for generating a init.rs file that contains a call to moduli_init!, /// complex_init!, sw_init! with the supported moduli and curves. @@ -193,22 +188,22 @@ impl Default for MemoryConfig { impl MemoryConfig { pub fn empty_address_space_configs(num_addr_spaces: usize) -> Vec { - // All except address spaces 0..4 default to native 32-bit field. // By default only address spaces 1..=4 have non-empty cell counts. + // Unassigned address spaces default to block_size=DEFAULT_BLOCK_SIZE with native32 cells. let mut addr_spaces = vec![ - AddressSpaceHostConfig::new(0, DEFAULT_FIELD_BLOCK_SIZE, MemoryCellType::field32()); + AddressSpaceHostConfig::new(0, DEFAULT_BLOCK_SIZE, MemoryCellType::field32()); num_addr_spaces ]; addr_spaces[RV32_IMM_AS as usize] = AddressSpaceHostConfig::new(0, 1, MemoryCellType::Null); addr_spaces[RV32_REGISTER_AS as usize] = - AddressSpaceHostConfig::new(0, DEFAULT_U8_BLOCK_SIZE, MemoryCellType::U8); + AddressSpaceHostConfig::new(0, DEFAULT_BLOCK_SIZE, MemoryCellType::U8); addr_spaces[RV32_MEMORY_AS as usize] = - AddressSpaceHostConfig::new(0, DEFAULT_U8_BLOCK_SIZE, MemoryCellType::U8); + AddressSpaceHostConfig::new(0, DEFAULT_BLOCK_SIZE, MemoryCellType::U8); addr_spaces[PUBLIC_VALUES_AS as usize] = - AddressSpaceHostConfig::new(0, DEFAULT_U8_BLOCK_SIZE, MemoryCellType::U8); + AddressSpaceHostConfig::new(0, DEFAULT_BLOCK_SIZE, MemoryCellType::U8); addr_spaces } @@ -221,11 +216,10 @@ impl MemoryConfig { Self::new(3, addr_spaces, POINTER_MAX_BITS, 29, 17) } - - pub fn min_block_size_bits(&self) -> Vec { + pub fn block_size_bits(&self) -> Vec { self.addr_spaces .iter() - .map(|addr_sp| log2_strict_usize(addr_sp.min_block_size) as u8) + .map(|addr_sp| log2_strict_usize(addr_sp.block_size) as u8) .collect() } } @@ -327,10 +321,6 @@ impl SystemConfig { pub fn num_airs(&self) -> usize { self.memory_boundary_air_id() + num_memory_airs() } - - pub fn initial_block_size(&self) -> usize { - CONST_BLOCK_SIZE - } } impl Default for SystemConfig { @@ -359,11 +349,11 @@ pub struct AddressSpaceHostConfig { /// The number of memory cells in each address space, where a memory cell refers to a single /// addressable unit of memory as defined by the ISA. pub num_cells: usize, - /// Minimum block size for memory accesses supported. This is a property of the address space - /// that is determined by the ISA. + /// Block size for memory accesses. Each address space has a fixed block size that determines + /// the granularity of memory bus interactions. /// /// **Note**: Block size is in terms of memory cells. - pub min_block_size: usize, + pub block_size: usize, pub layout: MemoryCellType, } diff --git a/crates/vm/src/arch/execution_mode/metered/ctx.rs b/crates/vm/src/arch/execution_mode/metered/ctx.rs index 2a7175c338..1c0981eabc 100644 --- a/crates/vm/src/arch/execution_mode/metered/ctx.rs +++ b/crates/vm/src/arch/execution_mode/metered/ctx.rs @@ -9,7 +9,7 @@ use super::{ use crate::{ arch::{ execution_mode::{ExecutionCtxTrait, MeteredExecutionCtxTrait}, - SystemConfig, VmExecState, + SystemConfig, VmExecState, BOUNDARY_AIR_ID, MERKLE_AIR_ID, }, system::memory::online::GuestMemory, }; @@ -57,15 +57,14 @@ impl MeteredCtx { // Assert that the indices are correct debug_assert!( - segmentation_ctx.air_names[memory_ctx.boundary_idx].contains("Boundary"), + segmentation_ctx.air_names[BOUNDARY_AIR_ID].contains("Boundary"), "air_name={}", - segmentation_ctx.air_names[memory_ctx.boundary_idx] + segmentation_ctx.air_names[BOUNDARY_AIR_ID] ); - let merkle_tree_index = memory_ctx.merkle_tree_index; debug_assert!( - segmentation_ctx.air_names[merkle_tree_index].contains("Merkle"), + segmentation_ctx.air_names[MERKLE_AIR_ID].contains("Merkle"), "air_name={}", - segmentation_ctx.air_names[merkle_tree_index] + segmentation_ctx.air_names[MERKLE_AIR_ID] ); let mut ctx = Self { trace_heights, diff --git a/crates/vm/src/arch/execution_mode/metered/memory_ctx.rs b/crates/vm/src/arch/execution_mode/metered/memory_ctx.rs index 88794f5996..fc2a09b1e1 100644 --- a/crates/vm/src/arch/execution_mode/metered/memory_ctx.rs +++ b/crates/vm/src/arch/execution_mode/metered/memory_ctx.rs @@ -1,7 +1,13 @@ use abi_stable::std_types::RVec; use openvm_instructions::riscv::{RV32_NUM_REGISTERS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS}; -use crate::{arch::SystemConfig, system::memory::dimensions::MemoryDimensions}; +use crate::{ + arch::{SystemConfig, BOUNDARY_AIR_ID, DEFAULT_BLOCK_SIZE, MERKLE_AIR_ID}, + system::memory::dimensions::MemoryDimensions, +}; + +const CHUNK: u32 = DEFAULT_BLOCK_SIZE as u32; +const CHUNK_BITS: u32 = CHUNK.ilog2(); /// Upper bound on number of memory pages accessed per instruction. Used for buffer allocation. pub const MAX_MEM_PAGE_OPS_PER_INSN: usize = 1 << 16; @@ -103,10 +109,6 @@ impl BitSet { #[derive(Clone, Debug)] pub struct MemoryCtx { memory_dimensions: MemoryDimensions, - pub boundary_idx: usize, - pub merkle_tree_index: usize, - chunk: u32, - chunk_bits: u32, pub page_indices: BitSet, pub addr_space_access_count: RVec, pub page_indices_since_checkpoint: Box<[u32]>, @@ -115,9 +117,6 @@ pub struct MemoryCtx { impl MemoryCtx { pub fn new(config: &SystemConfig, segment_check_insns: u64) -> Self { - let chunk = config.initial_block_size() as u32; - let chunk_bits = chunk.ilog2(); - let memory_dimensions = config.memory_config.memory_dimensions(); let merkle_height = memory_dimensions.overall_height(); @@ -127,10 +126,6 @@ impl MemoryCtx { Self::calculate_checkpoint_capacity(segment_check_insns); Self { - boundary_idx: config.memory_boundary_air_id(), - merkle_tree_index: config.memory_merkle_air_id(), - chunk, - chunk_bits, memory_dimensions, page_indices: BitSet::new(bitset_size), addr_space_access_count: vec![0; addr_space_size].into(), @@ -166,15 +161,11 @@ impl MemoryCtx { ) { debug_assert!((address_space as usize) < self.addr_space_access_count.len()); - let num_blocks = (size + self.chunk - 1) >> self.chunk_bits; - let start_chunk_id = ptr >> self.chunk_bits; - let start_block_id = if self.chunk == 1 { - start_chunk_id - } else { - self.memory_dimensions - .label_to_index((address_space, start_chunk_id)) as u32 - }; - // Because `self.chunk == 1 << self.chunk_bits` + let num_blocks = (size + CHUNK - 1) >> CHUNK_BITS; + let start_chunk_id = ptr >> CHUNK_BITS; + let start_block_id = self + .memory_dimensions + .label_to_index((address_space, start_chunk_id)) as u32; let end_block_id = start_block_id + num_blocks; let start_page_id = start_block_id >> PAGE_BITS; let end_page_id = ((end_block_id - 1) >> PAGE_BITS) + 1; @@ -213,13 +204,10 @@ impl MemoryCtx { self.page_indices.clear(); // Reset trace heights for memory chips as 0 - // SAFETY: boundary_idx is a compile time constant within bounds + // SAFETY: BOUNDARY_AIR_ID and MERKLE_AIR_ID are compile-time constants within bounds unsafe { - *trace_heights.get_unchecked_mut(self.boundary_idx) = 0; - } - // SAFETY: merkle_tree_index is guaranteed to be in bounds - unsafe { - *trace_heights.get_unchecked_mut(self.merkle_tree_index) = 0; + *trace_heights.get_unchecked_mut(BOUNDARY_AIR_ID) = 0; + *trace_heights.get_unchecked_mut(MERKLE_AIR_ID) = 0; } let poseidon2_idx = trace_heights.len() - 2; // SAFETY: poseidon2_idx is trace_heights.len() - 2, guaranteed to be in bounds @@ -267,27 +255,18 @@ impl MemoryCtx { // On page fault, assume we add all leaves in a page let leaves = page_access_count << PAGE_BITS; - // SAFETY: boundary_idx is a compile time constant within bounds - unsafe { - *trace_heights.get_unchecked_mut(self.boundary_idx) += leaves; - } - debug_assert!(self.merkle_tree_index < trace_heights.len()); debug_assert!(trace_heights.len() >= 2); - let poseidon2_idx = trace_heights.len() - 2; - // SAFETY: poseidon2_idx is trace_heights.len() - 2, guaranteed to be in bounds - unsafe { - *trace_heights.get_unchecked_mut(poseidon2_idx) += leaves * 2; - } let merkle_height = self.memory_dimensions.overall_height(); let nodes = (((1 << PAGE_BITS) - 1) + (merkle_height - PAGE_BITS)) as u32; - // SAFETY: merkle_tree_index is guaranteed to be in bounds + // SAFETY: BOUNDARY_AIR_ID, MERKLE_AIR_ID, and poseidon2_idx are all within bounds unsafe { - *trace_heights.get_unchecked_mut(poseidon2_idx) += nodes * page_access_count * 2; - *trace_heights.get_unchecked_mut(self.merkle_tree_index) += - nodes * page_access_count * 2; + *trace_heights.get_unchecked_mut(BOUNDARY_AIR_ID) += leaves; + *trace_heights.get_unchecked_mut(poseidon2_idx) += + leaves * 2 + nodes * page_access_count * 2; + *trace_heights.get_unchecked_mut(MERKLE_AIR_ID) += nodes * page_access_count * 2; } } diff --git a/crates/vm/src/arch/testing/cpu.rs b/crates/vm/src/arch/testing/cpu.rs index 5c8f33552a..a9da2dd12b 100644 --- a/crates/vm/src/arch/testing/cpu.rs +++ b/crates/vm/src/arch/testing/cpu.rs @@ -39,7 +39,7 @@ use crate::{ }, vm_poseidon2_config, Arena, ExecutionBridge, ExecutionBus, ExecutionState, MatrixRecordArena, MemoryConfig, PreflightExecutor, Streams, VmField, VmStateMut, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, }, system::{ memory::{ @@ -179,13 +179,13 @@ where ) -> (usize, usize) { let register = self.get_default_register(reg_increment); let pointer = self.get_default_pointer(pointer_increment); - // Write pointer in CONST_BLOCK_SIZE-byte chunks to match the fixed block size. + // Write pointer in DEFAULT_BLOCK_SIZE-byte chunks to match the fixed block size. // The pointer is RV32_REGISTER_NUM_LIMBS bytes (32-bit for RV32). let ptr_bytes = (pointer as u32).to_le_bytes(); - for i in (0..RV32_REGISTER_NUM_LIMBS).step_by(CONST_BLOCK_SIZE) { - let chunk: [u8; CONST_BLOCK_SIZE] = - ptr_bytes[i..i + CONST_BLOCK_SIZE].try_into().unwrap(); - self.write::(1, register + i, chunk.map(F::from_u8)); + for i in (0..RV32_REGISTER_NUM_LIMBS).step_by(DEFAULT_BLOCK_SIZE) { + let chunk: [u8; DEFAULT_BLOCK_SIZE] = + ptr_bytes[i..i + DEFAULT_BLOCK_SIZE].try_into().unwrap(); + self.write::(1, register + i, chunk.map(F::from_u8)); } (register, pointer) } @@ -236,22 +236,22 @@ impl VmChipTestBuilder { pointer: usize, writes: Vec<[F; NUM_LIMBS]>, ) { - // Write pointer in CONST_BLOCK_SIZE-byte chunks to match the fixed block size. + // Write pointer in DEFAULT_BLOCK_SIZE-byte chunks to match the fixed block size. // The pointer is RV32_REGISTER_NUM_LIMBS bytes (32-bit for RV32). let ptr_bytes = (pointer as u32).to_le_bytes(); - for i in (0..RV32_REGISTER_NUM_LIMBS).step_by(CONST_BLOCK_SIZE) { - let chunk: [u8; CONST_BLOCK_SIZE] = - ptr_bytes[i..i + CONST_BLOCK_SIZE].try_into().unwrap(); - self.write::(1usize, register + i, chunk.map(F::from_u8)); + for i in (0..RV32_REGISTER_NUM_LIMBS).step_by(DEFAULT_BLOCK_SIZE) { + let chunk: [u8; DEFAULT_BLOCK_SIZE] = + ptr_bytes[i..i + DEFAULT_BLOCK_SIZE].try_into().unwrap(); + self.write::(1usize, register + i, chunk.map(F::from_u8)); } - // Always write in CONST_BLOCK_SIZE-byte chunks to match the fixed block size. + // Always write in DEFAULT_BLOCK_SIZE-byte chunks to match the fixed block size. for (i, &write) in writes.iter().enumerate() { let ptr = pointer + i * NUM_LIMBS; - for j in (0..NUM_LIMBS).step_by(CONST_BLOCK_SIZE) { - self.write::( + for j in (0..NUM_LIMBS).step_by(DEFAULT_BLOCK_SIZE) { + self.write::( 2usize, ptr + j, - write[j..j + CONST_BLOCK_SIZE].try_into().unwrap(), + write[j..j + DEFAULT_BLOCK_SIZE].try_into().unwrap(), ); } } @@ -320,20 +320,19 @@ impl VmChipTestBuilder { impl VmChipTestBuilder { fn range_checker_and_memory( mem_config: &MemoryConfig, - init_block_size: usize, ) -> (SharedVariableRangeCheckerChip, TracingMemory) { let range_checker = Arc::new(VariableRangeCheckerChip::new(VariableRangeCheckerBus::new( RANGE_CHECKER_BUS, mem_config.decomp, ))); - let memory = TracingMemory::new(mem_config, init_block_size); + let memory = TracingMemory::new(mem_config); (range_checker, memory) } pub fn from_config(mem_config: MemoryConfig) -> Self { setup_tracing_with_log_level(Level::INFO); - let (range_checker, memory) = Self::range_checker_and_memory(&mem_config, CONST_BLOCK_SIZE); + let (range_checker, memory) = Self::range_checker_and_memory(&mem_config); let hasher_chip = Arc::new(Poseidon2PeripheryChip::new(vm_poseidon2_config(), 3)); let memory_controller = MemoryController::with_persistent_memory( MemoryBus::new(MEMORY_BUS), diff --git a/crates/vm/src/arch/testing/cuda.rs b/crates/vm/src/arch/testing/cuda.rs index 4344caa20f..08ca04c8ac 100644 --- a/crates/vm/src/arch/testing/cuda.rs +++ b/crates/vm/src/arch/testing/cuda.rs @@ -48,7 +48,7 @@ use crate::{ POSEIDON2_DIRECT_BUS, READ_INSTRUCTION_BUS, }, Arena, DenseRecordArena, ExecutionBridge, ExecutionBus, ExecutionState, MatrixRecordArena, - MemoryConfig, PreflightExecutor, Streams, VmStateMut, CONST_BLOCK_SIZE, + MemoryConfig, PreflightExecutor, Streams, VmStateMut, DEFAULT_BLOCK_SIZE, }, system::{ cuda::poseidon2::Poseidon2PeripheryChipGPU, @@ -263,7 +263,7 @@ impl GpuChipTestBuilder { ))); Self { memory: DeviceMemoryTester::new( - default_tracing_memory(&mem_config, CONST_BLOCK_SIZE), + default_tracing_memory(&mem_config), mem_bus, mem_config, range_checker.clone(), @@ -334,14 +334,14 @@ impl GpuChipTestBuilder { register, (pointer as u32).to_le_bytes().map(F::from_u8), ); - // Always write in CONST_BLOCK_SIZE-byte chunks to match the fixed block size. + // Always write in DEFAULT_BLOCK_SIZE-byte chunks to match the fixed block size. for (i, &write) in writes.iter().enumerate() { let ptr = pointer + i * NUM_LIMBS; - for j in (0..NUM_LIMBS).step_by(CONST_BLOCK_SIZE) { - self.write::( + for j in (0..NUM_LIMBS).step_by(DEFAULT_BLOCK_SIZE) { + self.write::( 2usize, ptr + j, - write[j..j + CONST_BLOCK_SIZE].try_into().unwrap(), + write[j..j + DEFAULT_BLOCK_SIZE].try_into().unwrap(), ); } } diff --git a/crates/vm/src/arch/testing/memory/cuda.rs b/crates/vm/src/arch/testing/memory/cuda.rs index a1f89b0b32..30dc33ff03 100644 --- a/crates/vm/src/arch/testing/memory/cuda.rs +++ b/crates/vm/src/arch/testing/memory/cuda.rs @@ -77,7 +77,7 @@ impl DeviceMemoryTester { pub fn read(&mut self, addr_space: usize, ptr: usize) -> [F; N] { let t = self.memory.timestamp(); - let (t_prev, data) = unsafe { self.memory.read::(addr_space as u32, ptr as u32) }; + let (t_prev, data) = unsafe { self.memory.read::(addr_space as u32, ptr as u32) }; let data = data.map(F::from_u8); self.chip_for_block.get_mut(&N).unwrap().receive( addr_space as u32, @@ -95,7 +95,7 @@ impl DeviceMemoryTester { pub fn write(&mut self, addr_space: usize, ptr: usize, data: [F; N]) { let t = self.memory.timestamp(); let (t_prev, data_prev) = unsafe { - self.memory.write::( + self.memory.write::( addr_space as u32, ptr as u32, data.map(|x| x.as_canonical_u32() as u8), diff --git a/crates/vm/src/arch/testing/memory/mod.rs b/crates/vm/src/arch/testing/memory/mod.rs index 2538d3d912..f9dce800b3 100644 --- a/crates/vm/src/arch/testing/memory/mod.rs +++ b/crates/vm/src/arch/testing/memory/mod.rs @@ -46,7 +46,7 @@ impl MemoryTester { let memory = &mut self.memory; let t = memory.timestamp(); // TODO: this could be improved if we added a TracingMemory::get_f function - let (t_prev, data) = unsafe { memory.read::(addr_space as u32, ptr as u32) }; + let (t_prev, data) = unsafe { memory.read::(addr_space as u32, ptr as u32) }; let data = data.map(F::from_u8); self.chip_for_block.get_mut(&N).unwrap().receive( addr_space as u32, @@ -67,7 +67,7 @@ impl MemoryTester { let t = memory.timestamp(); // TODO: this could be improved if we added a TracingMemory::write_f function let (t_prev, data_prev) = unsafe { - memory.write::( + memory.write::( addr_space as u32, ptr as u32, data.map(|x| x.as_canonical_u32() as u8), diff --git a/crates/vm/src/arch/testing/utils.rs b/crates/vm/src/arch/testing/utils.rs index ef7f89b6ec..16658e6a99 100644 --- a/crates/vm/src/arch/testing/utils.rs +++ b/crates/vm/src/arch/testing/utils.rs @@ -45,6 +45,6 @@ pub fn dummy_memory_helper( SharedMemoryHelper::new(dummy_range_checker(bus), timestamp_max_bits) } -pub fn default_tracing_memory(mem_config: &MemoryConfig, init_block_size: usize) -> TracingMemory { - TracingMemory::new(mem_config, init_block_size) +pub fn default_tracing_memory(mem_config: &MemoryConfig) -> TracingMemory { + TracingMemory::new(mem_config) } diff --git a/crates/vm/src/arch/vm.rs b/crates/vm/src/arch/vm.rs index 442f9fa409..bb65564d3d 100644 --- a/crates/vm/src/arch/vm.rs +++ b/crates/vm/src/arch/vm.rs @@ -615,9 +615,8 @@ where .collect::>(); let ctx = PreflightCtx::new_with_capacity(&capacities, num_insns); - let system_config: &SystemConfig = self.config().as_ref(); let pc = state.pc(); - let memory = TracingMemory::from_image(state.memory, system_config.initial_block_size()); + let memory = TracingMemory::from_image(state.memory); let from_state = ExecutionState::new(pc, memory.timestamp()); let vm_state = VmState::new( pc, diff --git a/crates/vm/src/system/cuda/boundary.rs b/crates/vm/src/system/cuda/boundary.rs index 3f27c0ce66..d22d543a31 100644 --- a/crates/vm/src/system/cuda/boundary.rs +++ b/crates/vm/src/system/cuda/boundary.rs @@ -1,5 +1,5 @@ use openvm_circuit::{ - arch::CONST_BLOCK_SIZE, system::memory::persistent::PersistentBoundaryCols, + arch::DEFAULT_BLOCK_SIZE, system::memory::persistent::PersistentBoundaryCols, utils::next_power_of_two_or_zero, }; use openvm_circuit_primitives::Chip; @@ -21,7 +21,7 @@ pub struct BoundaryChipGPU { pub trace_width: Option, } -const BLOCKS_PER_CHUNK: usize = DIGEST_WIDTH / CONST_BLOCK_SIZE; +const BLOCKS_PER_CHUNK: usize = DIGEST_WIDTH / DEFAULT_BLOCK_SIZE; #[repr(C)] #[derive(Clone, Copy)] diff --git a/crates/vm/src/system/cuda/memory.rs b/crates/vm/src/system/cuda/memory.rs index 9f2afc67d3..af99447cda 100644 --- a/crates/vm/src/system/cuda/memory.rs +++ b/crates/vm/src/system/cuda/memory.rs @@ -363,14 +363,14 @@ mod tests { let touched_bytes = [101u8, 102, 103, 104]; let touched_bytes_late = [111u8, 112, 113, 114]; unsafe { - final_memory.write::( + final_memory.write::( RV32_MEMORY_AS, 0, touched_bytes, ); - final_memory.write::( + final_memory.write::( RV32_MEMORY_AS, - crate::arch::CONST_BLOCK_SIZE as u32, + crate::arch::DEFAULT_BLOCK_SIZE as u32, touched_bytes_late, ); } @@ -405,7 +405,7 @@ mod tests { }, ), ( - (RV32_MEMORY_AS, crate::arch::CONST_BLOCK_SIZE as u32), + (RV32_MEMORY_AS, crate::arch::DEFAULT_BLOCK_SIZE as u32), TimestampedValues { timestamp: 3, values: touched_bytes_late.map(F::from_u8), diff --git a/crates/vm/src/system/cuda/merkle_tree/mod.rs b/crates/vm/src/system/cuda/merkle_tree/mod.rs index 9b0d00878d..ef0e882e7c 100644 --- a/crates/vm/src/system/cuda/merkle_tree/mod.rs +++ b/crates/vm/src/system/cuda/merkle_tree/mod.rs @@ -1,7 +1,7 @@ use std::{ffi::c_void, sync::Arc}; use openvm_circuit::{ - arch::{MemoryConfig, ADDR_SPACE_OFFSET, CONST_BLOCK_SIZE}, + arch::{MemoryConfig, ADDR_SPACE_OFFSET, DEFAULT_BLOCK_SIZE}, system::memory::{merkle::MemoryMerkleCols, TimestampedEquipartition}, utils::next_power_of_two_or_zero, }; @@ -24,9 +24,9 @@ pub mod cuda; use cuda::merkle_tree::*; type H = [F; DIGEST_WIDTH]; -/// Width of `((u32, u32), TimestampedValues)` in u32 units. -/// = 2 (key) + 1 (timestamp) + CONST_BLOCK_SIZE (values) -pub const TIMESTAMPED_BLOCK_WIDTH: usize = 3 + CONST_BLOCK_SIZE; +/// Width of `((u32, u32), TimestampedValues)` in u32 units. +/// = 2 (key) + 1 (timestamp) + DEFAULT_BLOCK_SIZE (values) +pub const TIMESTAMPED_BLOCK_WIDTH: usize = 3 + DEFAULT_BLOCK_SIZE; /// Width of `((u32, u32), TimestampedValues)` in u32 units. /// = 2 (key) + 1 (timestamp) + DIGEST_WIDTH (values) pub const MERKLE_TOUCHED_BLOCK_WIDTH: usize = 3 + DIGEST_WIDTH; diff --git a/crates/vm/src/system/memory/controller/mod.rs b/crates/vm/src/system/memory/controller/mod.rs index 94f57dbc5f..044b761438 100644 --- a/crates/vm/src/system/memory/controller/mod.rs +++ b/crates/vm/src/system/memory/controller/mod.rs @@ -19,7 +19,7 @@ use serde::{Deserialize, Serialize}; use self::interface::MemoryInterface; use super::AddressMap; use crate::{ - arch::{MemoryConfig, VmField, CONST_BLOCK_SIZE}, + arch::{MemoryConfig, VmField, DEFAULT_BLOCK_SIZE}, system::{ memory::{ dimensions::MemoryDimensions, @@ -186,7 +186,7 @@ impl MemoryController { let hasher = self.hasher_chip.as_ref().unwrap(); boundary_chip.finalize(initial_memory, &final_memory, hasher.as_ref()); - // Rechunk CONST_BLOCK_SIZE blocks into CHUNK-sized blocks for merkle_chip + // Rechunk DEFAULT_BLOCK_SIZE blocks into CHUNK-sized blocks for merkle_chip // Note: Equipartition key is (addr_space, ptr) where ptr is the starting pointer let final_memory_values: Equipartition = { use std::collections::BTreeMap; @@ -194,7 +194,8 @@ impl MemoryController { for ((addr_space, ptr), ts_values) in final_memory { // Align to CHUNK boundary to get the chunk's starting pointer let chunk_ptr = (ptr / CHUNK as u32) * CHUNK as u32; - let block_idx_in_chunk = ((ptr % CHUNK as u32) / CONST_BLOCK_SIZE as u32) as usize; + let block_idx_in_chunk = + ((ptr % CHUNK as u32) / DEFAULT_BLOCK_SIZE as u32) as usize; let entry = chunk_map.entry((addr_space, chunk_ptr)).or_insert_with(|| { // Initialize with values from initial memory std::array::from_fn(|i| unsafe { @@ -203,7 +204,7 @@ impl MemoryController { }); // Copy values for this block for (i, val) in ts_values.values.into_iter().enumerate() { - entry[block_idx_in_chunk * CONST_BLOCK_SIZE + i] = val; + entry[block_idx_in_chunk * DEFAULT_BLOCK_SIZE + i] = val; } } chunk_map diff --git a/crates/vm/src/system/memory/merkle/tests/mod.rs b/crates/vm/src/system/memory/merkle/tests/mod.rs index cb0b384977..e2d604e90b 100644 --- a/crates/vm/src/system/memory/merkle/tests/mod.rs +++ b/crates/vm/src/system/memory/merkle/tests/mod.rs @@ -191,17 +191,17 @@ fn random_test( vec![ AddressSpaceHostConfig { num_cells: 0, - min_block_size: 0, + block_size: 0, layout: MemoryCellType::Null, }, AddressSpaceHostConfig { num_cells: CHUNK << height, - min_block_size: 1, + block_size: 1, layout: MemoryCellType::F { size: 4 }, }, AddressSpaceHostConfig { num_cells: CHUNK << height, - min_block_size: 1, + block_size: 1, layout: MemoryCellType::F { size: 4 }, }, ], @@ -283,17 +283,17 @@ fn expand_test_no_accesses() { vec![ AddressSpaceHostConfig { num_cells: 0, - min_block_size: 0, + block_size: 0, layout: MemoryCellType::Null, }, AddressSpaceHostConfig { num_cells: CHUNK << height, - min_block_size: 1, + block_size: 1, layout: MemoryCellType::F { size: 4 }, }, AddressSpaceHostConfig { num_cells: CHUNK << height, - min_block_size: 1, + block_size: 1, layout: MemoryCellType::F { size: 4 }, }, ], @@ -331,17 +331,17 @@ fn expand_test_negative() { vec![ AddressSpaceHostConfig { num_cells: 0, - min_block_size: 0, + block_size: 0, layout: MemoryCellType::Null, }, AddressSpaceHostConfig { num_cells: CHUNK << height, - min_block_size: 1, + block_size: 1, layout: MemoryCellType::F { size: 4 }, }, AddressSpaceHostConfig { num_cells: CHUNK << height, - min_block_size: 1, + block_size: 1, layout: MemoryCellType::F { size: 4 }, }, ], diff --git a/crates/vm/src/system/memory/online.rs b/crates/vm/src/system/memory/online.rs index a01e3d2f89..77e9b4eae6 100644 --- a/crates/vm/src/system/memory/online.rs +++ b/crates/vm/src/system/memory/online.rs @@ -1,4 +1,4 @@ -use std::{array::from_fn, fmt::Debug, num::NonZero}; +use std::{array::from_fn, fmt::Debug}; use getset::Getters; use itertools::zip_eq; @@ -12,7 +12,7 @@ use tracing::instrument; use crate::{ arch::{ - AddressSpaceHostConfig, AddressSpaceHostLayout, MemoryConfig, CONST_BLOCK_SIZE, + AddressSpaceHostConfig, AddressSpaceHostLayout, MemoryConfig, DEFAULT_BLOCK_SIZE, MAX_CELL_BYTE_SIZE, }, system::{ @@ -41,11 +41,6 @@ pub const INITIAL_TIMESTAMP: u32 = 0; /// Default mmap page size. Change this if using THB. pub const PAGE_SIZE: usize = 4096; -// Memory access constraints -const MAX_BLOCK_SIZE: usize = 32; -const MIN_ALIGN: usize = 1; -const MAX_SEGMENTS: usize = MAX_BLOCK_SIZE / MIN_ALIGN; - /// (address_space, pointer) pub type Address = (u32, u32); @@ -379,378 +374,82 @@ impl GuestMemory { } } -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)] -pub struct AccessMetadata { - /// Packed timestamp (29 bits) and log2(block_size) (3 bits) - pub timestamp_and_log_block_size: u32, - /// Offset to block start (in ALIGN units). - pub offset_to_start: u8, -} - -impl AccessMetadata { - const TIMESTAMP_MASK: u32 = (1 << 29) - 1; - const LOG_BLOCK_SIZE_SHIFT: u32 = 29; - - pub fn new(timestamp: u32, block_size: u8, offset_to_start: u8) -> Self { - debug_assert!(timestamp < (1 << 29), "Timestamp must be less than 2^29"); - debug_assert!( - block_size == 0 || (block_size.is_power_of_two() && block_size <= MAX_BLOCK_SIZE as u8), - "Block size must be 0 or power of 2 and <= {MAX_BLOCK_SIZE}" - ); - - let encoded_block_size = if block_size == 0 { - 0 - } else { - // SAFETY: We already asserted that block_size is non-zero in this branch - unsafe { NonZero::new_unchecked(block_size) }.ilog2() + 1 - }; - let packed = timestamp | (encoded_block_size << Self::LOG_BLOCK_SIZE_SHIFT); - - Self { - timestamp_and_log_block_size: packed, - offset_to_start, - } - } - - pub fn timestamp(&self) -> u32 { - self.timestamp_and_log_block_size & Self::TIMESTAMP_MASK - } - - pub fn block_size(&self) -> u8 { - let encoded = self.timestamp_and_log_block_size >> Self::LOG_BLOCK_SIZE_SHIFT; - if encoded == 0 { - 0 - } else { - 1 << (encoded - 1) - } - } -} - /// Online memory that stores additional information for trace generation purposes. /// In particular, keeps track of timestamp. #[derive(Getters)] pub struct TracingMemory { pub timestamp: u32, - /// The initial block size -- this depends on the type of boundary chip. - initial_block_size: usize, /// The underlying data memory, with memory cells typed by address space: see [AddressMap]. #[getset(get = "pub")] pub data: GuestMemory, - /// Maps addr_space to (ptr / min_block_size[addr_space] -> AccessMetadata) for latest access - /// metadata. Uses paged storage for memory efficiency. AccessMetadata stores offset_to_start - /// (in ALIGN units), block_size, and timestamp (latter two only valid at offset_to_start == - /// 0). - pub(super) meta: Vec>, - /// For each `addr_space`, the minimum block size allowed for memory accesses. In other words, - /// all memory accesses in `addr_space` must be aligned to this block size. - pub min_block_size: Vec, + /// Maps (addr_space, ptr / block_size[addr_space]) → timestamp of last access. + /// A value of 0 means the slot has never been accessed. + pub(super) meta: Vec>, + /// For each `addr_space`, the block size for memory accesses. All memory accesses in + /// `addr_space` must be aligned to this block size. + pub block_size: Vec, } impl TracingMemory { - pub fn new(mem_config: &MemoryConfig, initial_block_size: usize) -> Self { + pub fn new(mem_config: &MemoryConfig) -> Self { let image = GuestMemory::new(AddressMap::from_mem_config(mem_config)); - Self::from_image(image, initial_block_size) + Self::from_image(image) } /// Constructor from pre-existing memory image. - pub fn from_image(image: GuestMemory, initial_block_size: usize) -> Self { - let (meta, min_block_size): (Vec<_>, Vec<_>) = + pub fn from_image(image: GuestMemory) -> Self { + let (meta, block_size): (Vec<_>, Vec<_>) = zip_eq(image.memory.get_memory(), &image.memory.config) .map(|(mem, addr_sp)| { let num_cells = mem.size() / addr_sp.layout.size(); - let min_block_size = addr_sp.min_block_size; - let total_metadata_len = num_cells.div_ceil(min_block_size); - (PagedVec::new(total_metadata_len), min_block_size as u32) + let block_size = addr_sp.block_size; + let total_metadata_len = num_cells.div_ceil(block_size); + (PagedVec::new(total_metadata_len), block_size as u32) }) .unzip(); Self { data: image, meta, - min_block_size, + block_size, timestamp: INITIAL_TIMESTAMP + 1, - initial_block_size, } } #[inline(always)] - fn assert_alignment(&self, block_size: usize, align: usize, addr_space: u32, ptr: u32) { - debug_assert!(block_size.is_power_of_two()); - debug_assert_eq!(block_size % align, 0); + fn assert_valid_access(&self, block_size: usize, addr_space: u32, ptr: u32) { debug_assert_ne!(addr_space, 0); - debug_assert_eq!(align as u32, self.min_block_size[addr_space as usize]); + debug_assert!(block_size.is_power_of_two()); + debug_assert_eq!(block_size, self.block_size[addr_space as usize] as usize); assert_eq!( - ptr % (align as u32), + ptr % block_size as u32, 0, - "pointer={ptr} not aligned to {align}" + "pointer={ptr} not aligned to block_size {block_size}" ); } - /// Get block metadata by jumping to the start of the block. - /// Returns (block_start_pointer, block_metadata). + /// Returns the previous access timestamp and updates metadata for this access. + /// Each read/write accesses exactly one metadata slot since callers always use + /// BLOCK_SIZE == block_size[addr_space]. #[inline(always)] - fn get_block_metadata( - &mut self, - address_space: usize, - pointer: usize, - ) -> (u32, AccessMetadata) { - let ptr_index = pointer / ALIGN; - // SAFETY: - // - address_space is validated during instruction decoding and guaranteed to be within - // bounds + fn prev_access_time(&mut self, address_space: usize, pointer: usize) -> u32 { + let bs = self.block_size[address_space] as usize; + let idx = pointer / bs; + // SAFETY: address_space is validated during instruction decoding let meta_page = unsafe { self.meta.get_unchecked_mut(address_space) }; - let current_meta = meta_page.get(ptr_index); - - let (block_start_index, block_metadata) = if current_meta.offset_to_start == 0 { - (ptr_index, current_meta) - } else { - let offset = current_meta.offset_to_start; - let start_idx = ptr_index - offset as usize; - let start_meta = meta_page.get(start_idx); - (start_idx, start_meta) - }; - - let block_start_pointer = (block_start_index * ALIGN) as u32; - - (block_start_pointer, block_metadata) - } - - #[inline(always)] - fn get_timestamp(&mut self, address_space: usize, pointer: usize) -> u32 { - let ptr_index = pointer / ALIGN; - // SAFETY: - // - address_space is validated during instruction decoding and guaranteed to be within - // bounds - let meta_page = unsafe { self.meta.get_unchecked_mut(address_space) }; - let current_meta = meta_page.get(ptr_index); - - if current_meta.offset_to_start == 0 { - current_meta.timestamp() - } else { - let offset = current_meta.offset_to_start; - let block_start_index = ptr_index - offset as usize; - meta_page.get(block_start_index).timestamp() - } - } - - /// Updates the metadata with the given block. - /// Stores timestamp and block_size only at block start, offsets elsewhere. - #[inline(always)] - fn set_meta_block( - &mut self, - address_space: usize, - pointer: usize, - timestamp: u32, - ) { - let ptr = pointer / ALIGN; - // SAFETY: address_space is assumed to be valid and within bounds - let meta_page = unsafe { self.meta.get_unchecked_mut(address_space) }; - - // Store full metadata at the block start - meta_page.set(ptr, AccessMetadata::new(timestamp, BLOCK_SIZE as u8, 0)); - - // Store offsets for other positions in the block - for i in 1..(BLOCK_SIZE / ALIGN) { - meta_page.set(ptr + i, AccessMetadata::new(0, 0, i as u8)); - } - } - - /// Calculate splits and merges needed for a memory access. - /// Returns Some((splits, merge)) or None if no operations needed. - #[inline(always)] - #[allow(clippy::type_complexity)] - fn calculate_splits_and_merges( - &mut self, - address_space: usize, - pointer: usize, - ) -> Option<(Vec<(usize, usize)>, (usize, usize))> { - // Skip metadata update if this is a repeated access to the same location with same size - let (start_ptr, block_meta) = self.get_block_metadata::(address_space, pointer); - if block_meta.block_size() == BLOCK_SIZE as u8 && start_ptr == pointer as u32 { - return None; - } - - // Split intersecting blocks to align bytes - let mut splits_buf = [(0usize, 0usize); MAX_SEGMENTS]; - let mut splits_count = 0; - let mut current_ptr = pointer; - let end_ptr = pointer + BLOCK_SIZE; - - while current_ptr < end_ptr { - let (start_ptr, block_metadata) = - self.get_block_metadata::(address_space, current_ptr); - - if block_metadata.block_size() == 0 { - current_ptr += ALIGN; - continue; - } - - if block_metadata.block_size() > ALIGN as u8 { - // SAFETY: splits_count < MAX_SEGMENTS by construction since we iterate over - // at most BLOCK_SIZE/ALIGN segments and BLOCK_SIZE <= MAX_BLOCK_SIZE - unsafe { - *splits_buf.get_unchecked_mut(splits_count) = - (start_ptr as usize, block_metadata.block_size() as usize); - } - splits_count += 1; - } - - // Skip to the next segment after this block ends - current_ptr = start_ptr as usize + block_metadata.block_size() as usize; - } - - let merge = (pointer, BLOCK_SIZE); - - Some((splits_buf[..splits_count].to_vec(), merge)) - } - - #[inline(always)] - fn split_by_meta( - &mut self, - start_ptr: u32, - timestamp: u32, - block_size: u8, - address_space: usize, - ) { - if block_size == MIN_BLOCK_SIZE as u8 { - return; - } - let begin = start_ptr as usize / MIN_BLOCK_SIZE; - // SAFETY: - // - address_space is validated during instruction decoding and guaranteed to be within - // bounds - let meta_page = unsafe { self.meta.get_unchecked_mut(address_space) }; - - for i in 0..(block_size as usize / MIN_BLOCK_SIZE) { - // Each split piece becomes its own block start - meta_page.set( - begin + i, - AccessMetadata::new(timestamp, MIN_BLOCK_SIZE as u8, 0), - ); - } - } - - /// Returns the timestamp of the previous access to `[pointer:BLOCK_SIZE]_{address_space}`. - /// - /// Caller must ensure alignment (e.g. via `assert_alignment`) prior to calling this function. - #[inline(always)] - fn prev_access_time( - &mut self, - address_space: usize, - pointer: usize, - ) -> u32 { - debug_assert_eq!(ALIGN, self.data.memory.config[address_space].min_block_size); - // SAFETY: - // - address_space is validated during instruction decoding and guaranteed to be within - // bounds - debug_assert_eq!( - unsafe { - self.data - .memory - .config - .get_unchecked(address_space) - .layout - .size() - }, - size_of::() - ); - // Calculate what splits and merges are needed for this memory access - let result = if let Some((splits, (merge_ptr, merge_size))) = - self.calculate_splits_and_merges::(address_space, pointer) - { - // Process all splits first - for (split_ptr, split_size) in splits { - let (_, block_metadata) = - self.get_block_metadata::(address_space, split_ptr); - let timestamp = block_metadata.timestamp(); - self.split_by_meta::( - split_ptr as u32, - timestamp, - split_size as u8, - address_space, - ); - } - - // Process merge - let mut prev_ts_buf = [0u32; MAX_SEGMENTS]; - - let mut max_timestamp = INITIAL_TIMESTAMP; - - let mut ptr = merge_ptr; - let end_ptr = merge_ptr + merge_size; - let mut seg_idx = 0; - while ptr < end_ptr { - let (_, block_metadata) = self.get_block_metadata::(address_space, ptr); - - let timestamp = if block_metadata.block_size() > 0 { - block_metadata.timestamp() - } else { - self.handle_uninitialized_memory::(address_space, ptr); - INITIAL_TIMESTAMP - }; - - // SAFETY: seg_idx < MAX_SEGMENTS since we iterate at most merge_size/ALIGN times - // and merge_size <= BLOCK_SIZE <= MAX_BLOCK_SIZE - unsafe { - *prev_ts_buf.get_unchecked_mut(seg_idx) = timestamp; - } - max_timestamp = max_timestamp.max(timestamp); - ptr += ALIGN; - seg_idx += 1; - } - - max_timestamp - } else { - self.get_timestamp::(address_space, pointer) - }; - - // Update the metadata for this access - self.set_meta_block::(address_space, pointer, self.timestamp); - result - } - - /// Handle uninitialized memory by creating appropriate split or merge records. - #[inline(always)] - fn handle_uninitialized_memory( - &mut self, - address_space: usize, - pointer: usize, - ) { - if self.initial_block_size >= ALIGN { - // Split the initial block into chunks - let segment_index = pointer / ALIGN; - let block_start = segment_index & !(self.initial_block_size / ALIGN - 1); - let start_ptr = (block_start * ALIGN) as u32; - self.split_by_meta::( - start_ptr, - INITIAL_TIMESTAMP, - self.initial_block_size as u8, - address_space, - ); - } else { - debug_assert_eq!(self.initial_block_size, 1); - } + let prev = meta_page.get(idx); + meta_page.set(idx, self.timestamp); + prev } /// Atomic read operation which increments the timestamp by 1. - /// Returns `(t_prev, [pointer:BLOCK_SIZE]_{address_space})` where `t_prev` is the - /// timestamp of the last memory access. - /// - /// - /// # Assumptions - /// The `BLOCK_SIZE` is a multiple of `ALIGN`, which must equal the minimum block size - /// of `address_space`. + /// Returns `(t_prev, [pointer:BLOCK_SIZE]_{address_space})`. /// /// # Safety - /// The type `T` must be stack-allocated `repr(C)` or `repr(transparent)`, - /// plain old data, and it must be the exact type used to represent a single memory cell in - /// address space `address_space`. For standard usage, - /// `T` is either `u8` or `F` where `F` is the base field of the ZK backend. - /// - /// In addition: + /// - `T` must be `repr(C)` or `repr(transparent)` and match the cell type for `address_space`. /// - `address_space` must be valid. + /// - `BLOCK_SIZE` must equal the address space's block size. #[inline(always)] - pub unsafe fn read( + pub unsafe fn read( &mut self, address_space: u32, pointer: u32, @@ -758,34 +457,22 @@ impl TracingMemory { where T: Copy + Debug, { - self.assert_alignment(BLOCK_SIZE, ALIGN, address_space, pointer); + self.assert_valid_access(BLOCK_SIZE, address_space, pointer); let values = self.data.read(address_space, pointer); - let t_prev = - self.prev_access_time::(address_space as usize, pointer as usize); + let t_prev = self.prev_access_time(address_space as usize, pointer as usize); self.timestamp += 1; (t_prev, values) } - /// Atomic write operation that writes `values` into `[pointer:BLOCK_SIZE]_{address_space}` and - /// then increments the timestamp by 1. Returns `(t_prev, values_prev)` which equal the - /// timestamp and value `[pointer:BLOCK_SIZE]_{address_space}` of the last memory access. - /// - /// - /// # Assumptions - /// The `BLOCK_SIZE` is a multiple of `ALIGN`, which must equal the minimum block size - /// of `address_space`. + /// Atomic write operation. Returns `(t_prev, values_prev)`. /// /// # Safety - /// The type `T` must be stack-allocated `repr(C)` or `repr(transparent)`, - /// and it must be the exact type used to represent a single memory cell in - /// address space `address_space`. For standard usage, - /// `T` is either `u8` or `F` where `F` is the base field of the ZK backend. - /// - /// In addition: + /// - `T` must be `repr(C)` or `repr(transparent)` and match the cell type for `address_space`. /// - `address_space` must be valid. + /// - `BLOCK_SIZE` must equal the address space's block size. #[inline(always)] - pub unsafe fn write( + pub unsafe fn write( &mut self, address_space: u32, pointer: u32, @@ -794,10 +481,9 @@ impl TracingMemory { where T: Copy + Debug, { - self.assert_alignment(BLOCK_SIZE, ALIGN, address_space, pointer); + self.assert_valid_access(BLOCK_SIZE, address_space, pointer); let values_prev = self.data.read(address_space, pointer); - let t_prev = - self.prev_access_time::(address_space as usize, pointer as usize); + let t_prev = self.prev_access_time(address_space as usize, pointer as usize); self.data.write(address_space, pointer, values); self.timestamp += 1; @@ -820,23 +506,23 @@ impl TracingMemory { #[instrument(name = "memory_finalize", skip_all)] pub fn finalize(&mut self) -> TouchedMemory { let touched_blocks = self.touched_blocks(); - self.touched_blocks_to_equipartition::(touched_blocks) + self.touched_blocks_to_equipartition::(touched_blocks) } - /// Returns the list of all touched blocks. The list is sorted by address. - fn touched_blocks(&self) -> Vec<(Address, AccessMetadata)> { - assert_eq!(self.meta.len(), self.min_block_size.len()); + /// Returns the list of all touched blocks (address, timestamp). Sorted by address. + fn touched_blocks(&self) -> Vec<(Address, u32)> { + assert_eq!(self.meta.len(), self.block_size.len()); self.meta .par_iter() - .zip(self.min_block_size.par_iter()) + .zip(self.block_size.par_iter()) .enumerate() - .flat_map(|(addr_space, (meta_page, &align))| { + .flat_map(|(addr_space, (meta_page, &bs))| { meta_page .par_iter() - .filter_map(move |(idx, metadata)| { - let ptr = idx as u32 * align; - if metadata.offset_to_start == 0 && metadata.block_size() != 0 { - Some(((addr_space as u32, ptr), metadata)) + .filter_map(move |(idx, timestamp)| { + if timestamp > INITIAL_TIMESTAMP { + let ptr = idx as u32 * bs; + Some(((addr_space as u32, ptr), timestamp)) } else { None } @@ -847,12 +533,10 @@ impl TracingMemory { } /// Returns the equipartition of the touched blocks. - /// Modifies records and adds new to account for the initial/final segments. fn touched_blocks_to_equipartition( &mut self, - touched_blocks: Vec<((u32, u32), AccessMetadata)>, + touched_blocks: Vec<((u32, u32), u32)>, ) -> TimestampedEquipartition { - // [perf] We can `.with_capacity()` if we keep track of the number of segments we initialize let mut final_memory = Vec::new(); debug_assert!(touched_blocks.is_sorted_by_key(|(addr, _)| addr)); @@ -865,28 +549,26 @@ impl TracingMemory { fn handle_touched_blocks( &mut self, final_memory: &mut Vec<((u32, u32), TimestampedValues)>, - touched_blocks: Vec<((u32, u32), AccessMetadata)>, + touched_blocks: Vec<((u32, u32), u32)>, ) { let mut current_values = vec![0u8; MAX_CELL_BYTE_SIZE * CHUNK]; let mut current_cnt = 0; let mut current_address = MemoryAddress::new(0, 0); - let mut current_timestamps = vec![0; CHUNK]; - for ((addr_space, ptr), access_metadata) in touched_blocks { + let mut current_timestamps = vec![0u32; CHUNK]; + for ((addr_space, ptr), timestamp) in touched_blocks { // SAFETY: addr_space of touched blocks are all in bounds let addr_space_config = unsafe { *self.data.memory.config.get_unchecked(addr_space as usize) }; - let min_block_size = addr_space_config.min_block_size; + let block_size = addr_space_config.block_size; let cell_size = addr_space_config.layout.size(); - let timestamp = access_metadata.timestamp(); - let block_size = access_metadata.block_size(); + debug_assert!(ptr % block_size as u32 == 0); + assert!( current_cnt == 0 || (current_address.address_space == addr_space && current_address.pointer + current_cnt as u32 == ptr), "The union of all touched blocks must consist of blocks with sizes divisible by `CHUNK`" ); - debug_assert!(block_size >= min_block_size as u8); - debug_assert!(ptr % min_block_size as u32 == 0); if current_cnt == 0 { assert_eq!( @@ -897,82 +579,48 @@ impl TracingMemory { current_address = MemoryAddress::new(addr_space, ptr); } - if min_block_size > CHUNK { - assert_eq!(current_cnt, 0); - // SAFETY: touched blocks are in bounds - let values = unsafe { + // SAFETY: current_cnt / block_size < CHUNK / block_size <= CHUNK + unsafe { + *current_timestamps.get_unchecked_mut(current_cnt / block_size) = timestamp; + } + + for i in 0..block_size as u32 { + let cell_data = unsafe { self.data.memory.get_u8_slice( addr_space, - ptr as usize * cell_size, - block_size as usize * cell_size, + (ptr + i) as usize * cell_size, + cell_size, ) }; - for i in (0..block_size as u32).step_by(CHUNK) { + current_values[current_cnt * cell_size..current_cnt * cell_size + cell_size] + .copy_from_slice(cell_data); + current_cnt += 1; + if current_cnt == CHUNK { + let timestamp = *current_timestamps[..CHUNK / block_size] + .iter() + .max() + .unwrap(); final_memory.push(( - (addr_space, ptr + i), + (current_address.address_space, current_address.pointer), TimestampedValues { timestamp, - values: from_fn(|j| { - let byte_idx = (i as usize + j) * cell_size; - // SAFETY: block_size is multiple of CHUNK and we are reading chunks - // of cells within bounds - unsafe { - addr_space_config - .layout - .to_field(&values[byte_idx..byte_idx + cell_size]) - } + values: from_fn(|i| unsafe { + addr_space_config.layout.to_field( + ¤t_values[i * cell_size..i * cell_size + cell_size], + ) }), }, )); - } - } else { - for i in 0..block_size as u32 { - // SAFETY: getting cell data - let cell_data = unsafe { - self.data.memory.get_u8_slice( - addr_space, - (ptr + i) as usize * cell_size, - cell_size, - ) - }; - current_values[current_cnt * cell_size..current_cnt * cell_size + cell_size] - .copy_from_slice(cell_data); - if current_cnt & (min_block_size - 1) == 0 { - // SAFETY: current_cnt / min_block_size < CHUNK / min_block_size <= CHUNK - unsafe { - *current_timestamps.get_unchecked_mut(current_cnt / min_block_size) = - timestamp; - } - } - current_cnt += 1; - if current_cnt == CHUNK { - let timestamp = *current_timestamps[..CHUNK / min_block_size] - .iter() - .max() - .unwrap(); - final_memory.push(( - (current_address.address_space, current_address.pointer), - TimestampedValues { - timestamp, - values: from_fn(|i| unsafe { - // SAFETY: cell_size is correct, and alignment is guaranteed - addr_space_config.layout.to_field( - ¤t_values[i * cell_size..i * cell_size + cell_size], - ) - }), - }, - )); - current_address.pointer += current_cnt as u32; - current_cnt = 0; - } + current_address.pointer += current_cnt as u32; + current_cnt = 0; } } } assert_eq!(current_cnt, 0, "The union of all touched blocks must consist of blocks with sizes divisible by `CHUNK`"); } - pub fn address_space_alignment(&self) -> Vec { - self.min_block_size + pub fn block_size_bits(&self) -> Vec { + self.block_size .iter() .map(|&x| log2_strict_usize(x as usize) as u8) .collect() diff --git a/crates/vm/src/system/memory/persistent.rs b/crates/vm/src/system/memory/persistent.rs index c50eec88ec..721977cd08 100644 --- a/crates/vm/src/system/memory/persistent.rs +++ b/crates/vm/src/system/memory/persistent.rs @@ -20,7 +20,7 @@ use tracing::instrument; use super::{merkle::SerialReceiver, online::INITIAL_TIMESTAMP}; use crate::{ - arch::{hasher::Hasher, ADDR_SPACE_OFFSET, CONST_BLOCK_SIZE}, + arch::{hasher::Hasher, ADDR_SPACE_OFFSET, DEFAULT_BLOCK_SIZE}, primitives::Chip, system::memory::{ controller::CHUNK, dimensions::MemoryDimensions, offline_checker::MemoryBus, MemoryAddress, @@ -28,10 +28,10 @@ use crate::{ }, }; -/// Number of CONST_BLOCK_SIZE blocks per CHUNK (e.g., 2 for 8/4). +/// Number of DEFAULT_BLOCK_SIZE blocks per CHUNK (e.g., 2 for 8/4). /// Blocks are on the same row only for Merkle tree hashing (8 bytes at a time). /// Memory bus interactions use per-block timestamps. -pub const BLOCKS_PER_CHUNK: usize = CHUNK / CONST_BLOCK_SIZE; +pub const BLOCKS_PER_CHUNK: usize = CHUNK / DEFAULT_BLOCK_SIZE; /// The values describe aligned chunk of memory of size `CHUNK`---the data together with the last /// accessed timestamp---in either the initial or final memory state. @@ -46,7 +46,7 @@ pub struct PersistentBoundaryCols { pub leaf_label: T, pub values: [T; CHUNK], pub hash: [T; CHUNK], - /// Per-block timestamps. Each CONST_BLOCK_SIZE block within the chunk has its own timestamp. + /// Per-block timestamps. Each DEFAULT_BLOCK_SIZE block within the chunk has its own timestamp. /// For untouched blocks, timestamp stays at 0 (balances: boundary sends at t=0 init, receives /// at t=0 final). pub timestamps: [T; BLOCKS_PER_CHUNK], @@ -120,8 +120,8 @@ impl Air for PersistentBoundaryA let chunk_size_f = AB::F::from_usize(CHUNK); for block_idx in 0..BLOCKS_PER_CHUNK { - let offset = AB::F::from_usize(block_idx * CONST_BLOCK_SIZE); - // Split the 1xCHUNK leaf into CONST_BLOCK_SIZE-sized bus messages. + let offset = AB::F::from_usize(block_idx * DEFAULT_BLOCK_SIZE); + // Split the 1xCHUNK leaf into DEFAULT_BLOCK_SIZE-sized bus messages. // Each block uses its own timestamp - untouched blocks stay at t=0. self.memory_bus .send( @@ -129,7 +129,8 @@ impl Air for PersistentBoundaryA local.address_space, local.leaf_label * chunk_size_f + offset, ), - local.values[block_idx * CONST_BLOCK_SIZE..(block_idx + 1) * CONST_BLOCK_SIZE] + local.values + [block_idx * DEFAULT_BLOCK_SIZE..(block_idx + 1) * DEFAULT_BLOCK_SIZE] .to_vec(), local.timestamps[block_idx], ) @@ -158,7 +159,7 @@ pub struct FinalTouchedLabel { final_values: [F; CHUNK], init_hash: [F; CHUNK], final_hash: [F; CHUNK], - /// Per-block timestamps. Each CONST_BLOCK_SIZE block has its own timestamp. + /// Per-block timestamps. Each DEFAULT_BLOCK_SIZE block has its own timestamp. final_timestamps: [u32; BLOCKS_PER_CHUNK], } @@ -226,7 +227,7 @@ impl PersistentBoundaryChip { /// Finalize the boundary chip with per-block timestamped memory. /// - /// `final_memory` is at CONST_BLOCK_SIZE granularity (4 bytes per entry, single timestamp + /// `final_memory` is at DEFAULT_BLOCK_SIZE granularity (4 bytes per entry, single timestamp /// each). This function rechunks into CHUNK-sized (8 bytes) groups with per-block /// timestamps. Untouched blocks within a touched chunk get values from initial_memory and /// timestamp 0. @@ -234,20 +235,20 @@ impl PersistentBoundaryChip { pub(crate) fn finalize( &mut self, initial_memory: &MemoryImage, - // Touched stuff at CONST_BLOCK_SIZE granularity - final_memory: &TimestampedEquipartition, + // Touched stuff at DEFAULT_BLOCK_SIZE granularity + final_memory: &TimestampedEquipartition, hasher: &H, ) where H: Hasher + Sync + for<'a> SerialReceiver<&'a [F]>, { - type BlockInfo = (usize, u32, [F; CONST_BLOCK_SIZE]); // (block_idx, timestamp, values) + type BlockInfo = (usize, u32, [F; DEFAULT_BLOCK_SIZE]); // (block_idx, timestamp, values) type EnrichedEntry = ((u32, u32), BlockInfo); // (chunk_key, block_info) let enriched: Vec> = final_memory .par_iter() .map(|&((addr_space, ptr), ts_values)| { let chunk_label = ptr / CHUNK as u32; - let block_idx = ((ptr % CHUNK as u32) / CONST_BLOCK_SIZE as u32) as usize; + let block_idx = ((ptr % CHUNK as u32) / DEFAULT_BLOCK_SIZE as u32) as usize; let key = (addr_space, chunk_label); let block_info = (block_idx, ts_values.timestamp, ts_values.values); (key, block_info) @@ -278,7 +279,7 @@ impl PersistentBoundaryChip { for (block_idx, ts, values) in blocks { timestamps[block_idx] = ts; for (i, &val) in values.iter().enumerate() { - final_values[block_idx * CONST_BLOCK_SIZE + i] = val; + final_values[block_idx * DEFAULT_BLOCK_SIZE + i] = val; } } diff --git a/crates/vm/src/system/mod.rs b/crates/vm/src/system/mod.rs index d06ee2efac..15bc6345f2 100644 --- a/crates/vm/src/system/mod.rs +++ b/crates/vm/src/system/mod.rs @@ -28,7 +28,7 @@ use crate::{ ChipInventoryError, ExecutionBridge, ExecutionBus, ExecutionState, ExecutorInventory, ExecutorInventoryError, MatrixRecordArena, PhantomSubExecutor, RowMajorMatrixArena, SystemConfig, VmBuilder, VmChipComplex, VmCircuitConfig, VmExecutionConfig, VmField, - BOUNDARY_AIR_ID, CONNECTOR_AIR_ID, CONST_BLOCK_SIZE, PROGRAM_AIR_ID, + BOUNDARY_AIR_ID, CONNECTOR_AIR_ID, DEFAULT_BLOCK_SIZE, PROGRAM_AIR_ID, }, system::{ connector::VmConnectorChip, @@ -111,7 +111,7 @@ pub struct SystemRecords { pub touched_memory: TouchedMemory, } -pub type TouchedMemory = TimestampedEquipartition; +pub type TouchedMemory = TimestampedEquipartition; #[derive(Clone, AnyEnum, Executor, MeteredExecutor, PreflightExecutor, From)] #[cfg_attr(feature = "aot", derive(AotExecutor, AotMeteredExecutor))] diff --git a/extensions/algebra/circuit/src/extension/fp2.rs b/extensions/algebra/circuit/src/extension/fp2.rs index 80698cb869..ce262c4b14 100644 --- a/extensions/algebra/circuit/src/extension/fp2.rs +++ b/extensions/algebra/circuit/src/extension/fp2.rs @@ -6,7 +6,7 @@ use openvm_circuit::{ arch::{ AirInventory, AirInventoryError, ChipInventory, ChipInventoryError, ExecutionBridge, ExecutorInventoryBuilder, ExecutorInventoryError, RowMajorMatrixArena, VmCircuitExtension, - VmExecutionExtension, VmProverExtension, CONST_BLOCK_SIZE, + VmExecutionExtension, VmProverExtension, DEFAULT_BLOCK_SIZE, }, system::{memory::SharedMemoryHelper, SystemPort}, }; @@ -81,11 +81,11 @@ impl Fp2Extension { )] pub enum Fp2ExtensionExecutor { // 32 limbs prime - Fp2AddSubRv32_32(Fp2Executor), // Fp2AddSub - Fp2MulDivRv32_32(Fp2Executor), // Fp2MulDiv + Fp2AddSubRv32_32(Fp2Executor), // Fp2AddSub + Fp2MulDivRv32_32(Fp2Executor), // Fp2MulDiv // 48 limbs prime - Fp2AddSubRv32_48(Fp2Executor), // Fp2AddSub - Fp2MulDivRv32_48(Fp2Executor), // Fp2MulDiv + Fp2AddSubRv32_48(Fp2Executor), // Fp2AddSub + Fp2MulDivRv32_48(Fp2Executor), // Fp2MulDiv } impl VmExecutionExtension for Fp2Extension { @@ -209,7 +209,7 @@ impl VmCircuitExtension for Fp2Extension { limb_bits: 8, }; - let addsub = get_fp2_addsub_air::( + let addsub = get_fp2_addsub_air::( exec_bridge, memory_bridge, config.clone(), @@ -220,7 +220,7 @@ impl VmCircuitExtension for Fp2Extension { ); inventory.add_air(addsub); - let muldiv = get_fp2_muldiv_air::( + let muldiv = get_fp2_muldiv_air::( exec_bridge, memory_bridge, config, @@ -237,7 +237,7 @@ impl VmCircuitExtension for Fp2Extension { limb_bits: 8, }; - let addsub = get_fp2_addsub_air::( + let addsub = get_fp2_addsub_air::( exec_bridge, memory_bridge, config.clone(), @@ -248,7 +248,7 @@ impl VmCircuitExtension for Fp2Extension { ); inventory.add_air(addsub); - let muldiv = get_fp2_muldiv_air::( + let muldiv = get_fp2_muldiv_air::( exec_bridge, memory_bridge, config, @@ -310,8 +310,8 @@ where limb_bits: 8, }; - inventory.next_air::>()?; - let addsub = get_fp2_addsub_chip::, FP2_BLOCKS_32, CONST_BLOCK_SIZE>( + inventory.next_air::>()?; + let addsub = get_fp2_addsub_chip::, FP2_BLOCKS_32, DEFAULT_BLOCK_SIZE>( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -320,8 +320,8 @@ where ); inventory.add_executor_chip(addsub); - inventory.next_air::>()?; - let muldiv = get_fp2_muldiv_chip::, FP2_BLOCKS_32, CONST_BLOCK_SIZE>( + inventory.next_air::>()?; + let muldiv = get_fp2_muldiv_chip::, FP2_BLOCKS_32, DEFAULT_BLOCK_SIZE>( config, mem_helper.clone(), range_checker.clone(), @@ -336,8 +336,8 @@ where limb_bits: 8, }; - inventory.next_air::>()?; - let addsub = get_fp2_addsub_chip::, FP2_BLOCKS_48, CONST_BLOCK_SIZE>( + inventory.next_air::>()?; + let addsub = get_fp2_addsub_chip::, FP2_BLOCKS_48, DEFAULT_BLOCK_SIZE>( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -346,8 +346,8 @@ where ); inventory.add_executor_chip(addsub); - inventory.next_air::>()?; - let muldiv = get_fp2_muldiv_chip::, FP2_BLOCKS_48, CONST_BLOCK_SIZE>( + inventory.next_air::>()?; + let muldiv = get_fp2_muldiv_chip::, FP2_BLOCKS_48, DEFAULT_BLOCK_SIZE>( config, mem_helper.clone(), range_checker.clone(), diff --git a/extensions/algebra/circuit/src/extension/hybrid.rs b/extensions/algebra/circuit/src/extension/hybrid.rs index 7da7dabdfb..af0a061e65 100644 --- a/extensions/algebra/circuit/src/extension/hybrid.rs +++ b/extensions/algebra/circuit/src/extension/hybrid.rs @@ -2,7 +2,7 @@ use openvm_algebra_transpiler::Rv32ModularArithmeticOpcode; use openvm_circuit::{ - arch::{CONST_BLOCK_SIZE, *}, + arch::{DEFAULT_BLOCK_SIZE, *}, system::{ cuda::{ extensions::{ @@ -166,8 +166,8 @@ impl VmProverExtension>()?; - let addsub = get_modular_addsub_chip::( + inventory.next_air::>()?; + let addsub = get_modular_addsub_chip::( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -176,8 +176,8 @@ impl VmProverExtension>()?; - let muldiv = get_modular_muldiv_chip::( + inventory.next_air::>()?; + let muldiv = get_modular_muldiv_chip::( config, mem_helper.clone(), range_checker.clone(), @@ -193,11 +193,11 @@ impl VmProverExtension>()?; + inventory.next_air::>()?; let is_eq = ModularIsEqualChip::< F, MODULAR_BLOCKS_32, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, NUM_LIMBS_32, >::new( ModularIsEqualFiller::new( @@ -216,8 +216,8 @@ impl VmProverExtension>()?; - let addsub = get_modular_addsub_chip::( + inventory.next_air::>()?; + let addsub = get_modular_addsub_chip::( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -226,8 +226,8 @@ impl VmProverExtension>()?; - let muldiv = get_modular_muldiv_chip::( + inventory.next_air::>()?; + let muldiv = get_modular_muldiv_chip::( config, mem_helper.clone(), range_checker.clone(), @@ -243,11 +243,11 @@ impl VmProverExtension>()?; + inventory.next_air::>()?; let is_eq = ModularIsEqualChip::< F, MODULAR_BLOCKS_48, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, NUM_LIMBS_48, >::new( ModularIsEqualFiller::new( @@ -342,8 +342,8 @@ impl VmProverExtension>()?; - let addsub = get_fp2_addsub_chip::( + inventory.next_air::>()?; + let addsub = get_fp2_addsub_chip::( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -352,8 +352,8 @@ impl VmProverExtension>()?; - let muldiv = get_fp2_muldiv_chip::( + inventory.next_air::>()?; + let muldiv = get_fp2_muldiv_chip::( config, mem_helper.clone(), range_checker.clone(), @@ -368,8 +368,8 @@ impl VmProverExtension>()?; - let addsub = get_fp2_addsub_chip::( + inventory.next_air::>()?; + let addsub = get_fp2_addsub_chip::( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -378,8 +378,8 @@ impl VmProverExtension>()?; - let muldiv = get_fp2_muldiv_chip::( + inventory.next_air::>()?; + let muldiv = get_fp2_muldiv_chip::( config, mem_helper.clone(), range_checker.clone(), diff --git a/extensions/algebra/circuit/src/extension/modular.rs b/extensions/algebra/circuit/src/extension/modular.rs index bb3602deab..5e95854fd3 100644 --- a/extensions/algebra/circuit/src/extension/modular.rs +++ b/extensions/algebra/circuit/src/extension/modular.rs @@ -8,7 +8,7 @@ use openvm_circuit::{ arch::{ AirInventory, AirInventoryError, ChipInventory, ChipInventoryError, ExecutionBridge, ExecutorInventoryBuilder, ExecutorInventoryError, RowMajorMatrixArena, VmCircuitExtension, - VmExecutionExtension, VmProverExtension, CONST_BLOCK_SIZE, + VmExecutionExtension, VmProverExtension, DEFAULT_BLOCK_SIZE, }, system::{memory::SharedMemoryHelper, SystemPort}, }; @@ -74,17 +74,17 @@ impl ModularExtension { )] pub enum ModularExtensionExecutor { // 32 limbs prime - ModularAddSubRv32_32(ModularExecutor), // ModularAddSub - ModularMulDivRv32_32(ModularExecutor), // ModularMulDiv + ModularAddSubRv32_32(ModularExecutor), // ModularAddSub + ModularMulDivRv32_32(ModularExecutor), // ModularMulDiv ModularIsEqualRv32_32( - VmModularIsEqualExecutor, - ), // ModularIsEqual + VmModularIsEqualExecutor, + ), /* ModularIsEqual */ // 48 limbs prime - ModularAddSubRv32_48(ModularExecutor), // ModularAddSub - ModularMulDivRv32_48(ModularExecutor), // ModularMulDiv + ModularAddSubRv32_48(ModularExecutor), // ModularAddSub + ModularMulDivRv32_48(ModularExecutor), // ModularMulDiv ModularIsEqualRv32_48( - VmModularIsEqualExecutor, - ), // ModularIsEqual + VmModularIsEqualExecutor, + ), /* ModularIsEqual */ } impl VmExecutionExtension for ModularExtension { @@ -109,7 +109,7 @@ impl VmExecutionExtension for ModularExtension { num_limbs: NUM_LIMBS_32, limb_bits: 8, }; - let addsub = get_modular_addsub_step::( + let addsub = get_modular_addsub_step::( config.clone(), dummy_range_checker_bus, pointer_max_bits, @@ -123,7 +123,7 @@ impl VmExecutionExtension for ModularExtension { .map(|x| VmOpcode::from_usize(x + start_offset)), )?; - let muldiv = get_modular_muldiv_step::( + let muldiv = get_modular_muldiv_step::( config, dummy_range_checker_bus, pointer_max_bits, @@ -163,7 +163,7 @@ impl VmExecutionExtension for ModularExtension { num_limbs: NUM_LIMBS_48, limb_bits: 8, }; - let addsub = get_modular_addsub_step::( + let addsub = get_modular_addsub_step::( config.clone(), dummy_range_checker_bus, pointer_max_bits, @@ -177,7 +177,7 @@ impl VmExecutionExtension for ModularExtension { .map(|x| VmOpcode::from_usize(x + start_offset)), )?; - let muldiv = get_modular_muldiv_step::( + let muldiv = get_modular_muldiv_step::( config, dummy_range_checker_bus, pointer_max_bits, @@ -269,7 +269,7 @@ impl VmCircuitExtension for ModularExtension { limb_bits: 8, }; - let addsub = get_modular_addsub_air::( + let addsub = get_modular_addsub_air::( exec_bridge, memory_bridge, config.clone(), @@ -280,7 +280,7 @@ impl VmCircuitExtension for ModularExtension { ); inventory.add_air(addsub); - let muldiv = get_modular_muldiv_air::( + let muldiv = get_modular_muldiv_air::( exec_bridge, memory_bridge, config, @@ -292,7 +292,7 @@ impl VmCircuitExtension for ModularExtension { inventory.add_air(muldiv); let is_eq = - ModularIsEqualAir::::new( + ModularIsEqualAir::::new( Rv32IsEqualModAdapterAir::new( exec_bridge, memory_bridge, @@ -309,7 +309,7 @@ impl VmCircuitExtension for ModularExtension { limb_bits: 8, }; - let addsub = get_modular_addsub_air::( + let addsub = get_modular_addsub_air::( exec_bridge, memory_bridge, config.clone(), @@ -320,7 +320,7 @@ impl VmCircuitExtension for ModularExtension { ); inventory.add_air(addsub); - let muldiv = get_modular_muldiv_air::( + let muldiv = get_modular_muldiv_air::( exec_bridge, memory_bridge, config, @@ -332,7 +332,7 @@ impl VmCircuitExtension for ModularExtension { inventory.add_air(muldiv); let is_eq = - ModularIsEqualAir::::new( + ModularIsEqualAir::::new( Rv32IsEqualModAdapterAir::new( exec_bridge, memory_bridge, @@ -398,24 +398,26 @@ where limb_bits: 8, }; - inventory.next_air::>()?; - let addsub = get_modular_addsub_chip::, MODULAR_BLOCKS_32, CONST_BLOCK_SIZE>( - config.clone(), - mem_helper.clone(), - range_checker.clone(), - bitwise_lu.clone(), - pointer_max_bits, - ); + inventory.next_air::>()?; + let addsub = + get_modular_addsub_chip::, MODULAR_BLOCKS_32, DEFAULT_BLOCK_SIZE>( + config.clone(), + mem_helper.clone(), + range_checker.clone(), + bitwise_lu.clone(), + pointer_max_bits, + ); inventory.add_executor_chip(addsub); - inventory.next_air::>()?; - let muldiv = get_modular_muldiv_chip::, MODULAR_BLOCKS_32, CONST_BLOCK_SIZE>( - config, - mem_helper.clone(), - range_checker.clone(), - bitwise_lu.clone(), - pointer_max_bits, - ); + inventory.next_air::>()?; + let muldiv = + get_modular_muldiv_chip::, MODULAR_BLOCKS_32, DEFAULT_BLOCK_SIZE>( + config, + mem_helper.clone(), + range_checker.clone(), + bitwise_lu.clone(), + pointer_max_bits, + ); inventory.add_executor_chip(muldiv); let modulus_limbs = array::from_fn(|i| { @@ -425,11 +427,11 @@ where 0 } }); - inventory.next_air::>()?; + inventory.next_air::>()?; let is_eq = ModularIsEqualChip::< Val, MODULAR_BLOCKS_32, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, NUM_LIMBS_32, >::new( ModularIsEqualFiller::new( @@ -448,24 +450,26 @@ where limb_bits: 8, }; - inventory.next_air::>()?; - let addsub = get_modular_addsub_chip::, MODULAR_BLOCKS_48, CONST_BLOCK_SIZE>( - config.clone(), - mem_helper.clone(), - range_checker.clone(), - bitwise_lu.clone(), - pointer_max_bits, - ); + inventory.next_air::>()?; + let addsub = + get_modular_addsub_chip::, MODULAR_BLOCKS_48, DEFAULT_BLOCK_SIZE>( + config.clone(), + mem_helper.clone(), + range_checker.clone(), + bitwise_lu.clone(), + pointer_max_bits, + ); inventory.add_executor_chip(addsub); - inventory.next_air::>()?; - let muldiv = get_modular_muldiv_chip::, MODULAR_BLOCKS_48, CONST_BLOCK_SIZE>( - config, - mem_helper.clone(), - range_checker.clone(), - bitwise_lu.clone(), - pointer_max_bits, - ); + inventory.next_air::>()?; + let muldiv = + get_modular_muldiv_chip::, MODULAR_BLOCKS_48, DEFAULT_BLOCK_SIZE>( + config, + mem_helper.clone(), + range_checker.clone(), + bitwise_lu.clone(), + pointer_max_bits, + ); inventory.add_executor_chip(muldiv); let modulus_limbs = array::from_fn(|i| { @@ -475,11 +479,11 @@ where 0 } }); - inventory.next_air::>()?; + inventory.next_air::>()?; let is_eq = ModularIsEqualChip::< Val, MODULAR_BLOCKS_48, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, NUM_LIMBS_48, >::new( ModularIsEqualFiller::new( diff --git a/extensions/algebra/circuit/src/fp2_chip/tests.rs b/extensions/algebra/circuit/src/fp2_chip/tests.rs index 93c6e64cd3..1d24c6a2a2 100644 --- a/extensions/algebra/circuit/src/fp2_chip/tests.rs +++ b/extensions/algebra/circuit/src/fp2_chip/tests.rs @@ -8,7 +8,7 @@ use openvm_circuit::arch::{ testing::{ memory::gen_pointer, TestBuilder, TestChipHarness, VmChipTestBuilder, BITWISE_OP_LOOKUP_BUS, }, - Arena, PreflightExecutor, CONST_BLOCK_SIZE, + Arena, PreflightExecutor, DEFAULT_BLOCK_SIZE, }; use openvm_circuit_primitives::{ bigint::utils::secp256k1_coord_prime, @@ -273,42 +273,42 @@ struct TestConfig::new( +#[test_case(TestConfig::<{FP2_BLOCKS_32}, {DEFAULT_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( BigUint::from_str("357686312646216567629137").unwrap(), true, 50, ))] -#[test_case(TestConfig::<{FP2_BLOCKS_32}, {CONST_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( +#[test_case(TestConfig::<{FP2_BLOCKS_32}, {DEFAULT_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( secp256k1_coord_prime(), true, 50, ))] -#[test_case(TestConfig::<{FP2_BLOCKS_32}, {CONST_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( +#[test_case(TestConfig::<{FP2_BLOCKS_32}, {DEFAULT_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( BN254_MODULUS.clone(), true, 50, ))] -#[test_case(TestConfig::<{FP2_BLOCKS_48}, {CONST_BLOCK_SIZE}, {NUM_LIMBS_48}>::new( +#[test_case(TestConfig::<{FP2_BLOCKS_48}, {DEFAULT_BLOCK_SIZE}, {NUM_LIMBS_48}>::new( BLS12_381_MODULUS.clone(), true, 50, ))] -#[test_case(TestConfig::<{FP2_BLOCKS_32}, {CONST_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( +#[test_case(TestConfig::<{FP2_BLOCKS_32}, {DEFAULT_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( BigUint::from_str("357686312646216567629137").unwrap(), false, 50, ))] -#[test_case(TestConfig::<{FP2_BLOCKS_32}, {CONST_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( +#[test_case(TestConfig::<{FP2_BLOCKS_32}, {DEFAULT_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( secp256k1_coord_prime(), false, 50, ))] -#[test_case(TestConfig::<{FP2_BLOCKS_32}, {CONST_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( +#[test_case(TestConfig::<{FP2_BLOCKS_32}, {DEFAULT_BLOCK_SIZE}, {NUM_LIMBS_32}>::new( BN254_MODULUS.clone(), false, 50, ))] -#[test_case(TestConfig::<{FP2_BLOCKS_48}, {CONST_BLOCK_SIZE}, {NUM_LIMBS_48}>::new( +#[test_case(TestConfig::<{FP2_BLOCKS_48}, {DEFAULT_BLOCK_SIZE}, {NUM_LIMBS_48}>::new( BLS12_381_MODULUS.clone(), false, 50, @@ -466,53 +466,53 @@ mod cuda_tests { GpuTestChipHarness::with_capacity(executor, air, hybrid_chip, cpu_chip, MAX_INS_CAPACITY) } - #[test_case(TestConfig::::new( + #[test_case(TestConfig::::new( BigUint::from_str("357686312646216567629137").unwrap(), true, 50), - create_addsub_cuda_test_harness:: + create_addsub_cuda_test_harness:: )] - #[test_case(TestConfig::::new( + #[test_case(TestConfig::::new( secp256k1_coord_prime(), true, 50), - create_addsub_cuda_test_harness:: + create_addsub_cuda_test_harness:: )] - #[test_case(TestConfig::::new( + #[test_case(TestConfig::::new( BN254_MODULUS.clone(), true, 50), - create_addsub_cuda_test_harness:: + create_addsub_cuda_test_harness:: )] - #[test_case(TestConfig::::new( + #[test_case(TestConfig::::new( BLS12_381_MODULUS.clone(), true, 50), - create_addsub_cuda_test_harness:: + create_addsub_cuda_test_harness:: )] - #[test_case(TestConfig::::new( + #[test_case(TestConfig::::new( BigUint::from_str("357686312646216567629137").unwrap(), false, 50), - create_muldiv_cuda_test_harness:: + create_muldiv_cuda_test_harness:: )] - #[test_case(TestConfig::::new( + #[test_case(TestConfig::::new( secp256k1_coord_prime(), false, 50), - create_muldiv_cuda_test_harness:: + create_muldiv_cuda_test_harness:: )] - #[test_case(TestConfig::::new( + #[test_case(TestConfig::::new( BN254_MODULUS.clone(), false, 50), - create_muldiv_cuda_test_harness:: + create_muldiv_cuda_test_harness:: )] - #[test_case(TestConfig::::new( + #[test_case(TestConfig::::new( BLS12_381_MODULUS.clone(), false, 50), - create_muldiv_cuda_test_harness:: + create_muldiv_cuda_test_harness:: )] fn run_cuda_test_with_config< const BLOCKS: usize, diff --git a/extensions/algebra/circuit/src/lib.rs b/extensions/algebra/circuit/src/lib.rs index 4229549d5d..208d58ff92 100644 --- a/extensions/algebra/circuit/src/lib.rs +++ b/extensions/algebra/circuit/src/lib.rs @@ -5,7 +5,7 @@ use std::ops::{Deref, DerefMut}; -use openvm_circuit::arch::CONST_BLOCK_SIZE; +use openvm_circuit::arch::DEFAULT_BLOCK_SIZE; use openvm_mod_circuit_builder::FieldExpressionExecutor; use openvm_rv32_adapters::Rv32VecHeapAdapterExecutor; #[cfg(feature = "cuda")] @@ -22,9 +22,9 @@ pub const NUM_LIMBS_48: usize = 48; // Blocks per operation for modular arithmetic (single field element) /// Blocks for 32-limb modular operations: 32 / 4 = 8 blocks -pub const MODULAR_BLOCKS_32: usize = NUM_LIMBS_32 / CONST_BLOCK_SIZE; +pub const MODULAR_BLOCKS_32: usize = NUM_LIMBS_32 / DEFAULT_BLOCK_SIZE; /// Blocks for 48-limb modular operations: 48 / 4 = 12 blocks -pub const MODULAR_BLOCKS_48: usize = NUM_LIMBS_48 / CONST_BLOCK_SIZE; +pub const MODULAR_BLOCKS_48: usize = NUM_LIMBS_48 / DEFAULT_BLOCK_SIZE; // Blocks per operation for Fp2 (two field elements) /// Blocks for Fp2 with 32-limb base field: 2 * 8 = 16 blocks diff --git a/extensions/algebra/circuit/src/modular_chip/tests.rs b/extensions/algebra/circuit/src/modular_chip/tests.rs index e2b039b637..51808e7b94 100644 --- a/extensions/algebra/circuit/src/modular_chip/tests.rs +++ b/extensions/algebra/circuit/src/modular_chip/tests.rs @@ -8,7 +8,7 @@ use openvm_circuit::arch::{ testing::{ memory::gen_pointer, TestBuilder, TestChipHarness, VmChipTestBuilder, BITWISE_OP_LOOKUP_BUS, }, - Arena, PreflightExecutor, CONST_BLOCK_SIZE, + Arena, PreflightExecutor, DEFAULT_BLOCK_SIZE, }; use openvm_circuit_primitives::{ bigint::utils::{secp256k1_coord_prime, secp256k1_scalar_prime}, @@ -304,7 +304,7 @@ mod addsub_tests { #[test] fn test_modular_addsub_32limb_small() { - run_addsub_test::( + run_addsub_test::( 0, BigUint::from_str("357686312646216567629137").unwrap(), 50, @@ -313,12 +313,12 @@ mod addsub_tests { #[test] fn test_modular_addsub_32limb_secp256k1() { - run_addsub_test::( + run_addsub_test::( 0, secp256k1_coord_prime(), 50, ); - run_addsub_test::( + run_addsub_test::( 4, secp256k1_scalar_prime(), 50, @@ -327,7 +327,7 @@ mod addsub_tests { #[test] fn test_modular_addsub_32limb_bn254() { - run_addsub_test::( + run_addsub_test::( 0, BN254_MODULUS.clone(), 50, @@ -336,7 +336,7 @@ mod addsub_tests { #[test] fn test_modular_addsub_48limb_bls12_381() { - run_addsub_test::( + run_addsub_test::( 0, BLS12_381_MODULUS.clone(), 50, @@ -400,27 +400,27 @@ mod addsub_tests { #[cfg(feature = "cuda")] #[test] fn cuda_test_modular_addsub() { - run_cuda_addsub_test_with_config::( + run_cuda_addsub_test_with_config::( 0, BigUint::from_str("357686312646216567629137").unwrap(), 50, ); - run_cuda_addsub_test_with_config::( + run_cuda_addsub_test_with_config::( 0, secp256k1_coord_prime(), 50, ); - run_cuda_addsub_test_with_config::( + run_cuda_addsub_test_with_config::( 4, secp256k1_scalar_prime(), 50, ); - run_cuda_addsub_test_with_config::( + run_cuda_addsub_test_with_config::( 0, BN254_MODULUS.clone(), 50, ); - run_cuda_addsub_test_with_config::( + run_cuda_addsub_test_with_config::( 0, BLS12_381_MODULUS.clone(), 50, @@ -677,7 +677,7 @@ mod muldiv_tests { #[test] fn test_modular_muldiv_32limb_small() { - run_test_muldiv::( + run_test_muldiv::( 0, BigUint::from_str("357686312646216567629137").unwrap(), 50, @@ -686,12 +686,12 @@ mod muldiv_tests { #[test] fn test_modular_muldiv_32limb_secp256k1() { - run_test_muldiv::( + run_test_muldiv::( 0, secp256k1_coord_prime(), 50, ); - run_test_muldiv::( + run_test_muldiv::( 4, secp256k1_scalar_prime(), 50, @@ -700,7 +700,7 @@ mod muldiv_tests { #[test] fn test_modular_muldiv_32limb_bn254() { - run_test_muldiv::( + run_test_muldiv::( 0, BN254_MODULUS.clone(), 50, @@ -709,7 +709,7 @@ mod muldiv_tests { #[test] fn test_modular_muldiv_48limb_bls12_381() { - run_test_muldiv::( + run_test_muldiv::( 0, BLS12_381_MODULUS.clone(), 50, @@ -773,27 +773,27 @@ mod muldiv_tests { #[cfg(feature = "cuda")] #[test] fn cuda_test_modular_muldiv() { - run_cuda_muldiv_test_with_config::( + run_cuda_muldiv_test_with_config::( 0, BigUint::from_str("357686312646216567629137").unwrap(), 50, ); - run_cuda_muldiv_test_with_config::( + run_cuda_muldiv_test_with_config::( 0, secp256k1_coord_prime(), 50, ); - run_cuda_muldiv_test_with_config::( + run_cuda_muldiv_test_with_config::( 4, secp256k1_scalar_prime(), 50, ); - run_cuda_muldiv_test_with_config::( + run_cuda_muldiv_test_with_config::( 0, BN254_MODULUS.clone(), 50, ); - run_cuda_muldiv_test_with_config::( + run_cuda_muldiv_test_with_config::( 0, BLS12_381_MODULUS.clone(), 50, @@ -981,7 +981,7 @@ mod is_equal_tests { #[test] fn test_modular_is_equal_32limb() { - test_is_equal::( + test_is_equal::( 17, secp256k1_coord_prime(), 100, @@ -990,7 +990,7 @@ mod is_equal_tests { #[test] fn test_modular_is_equal_48limb() { - test_is_equal::( + test_is_equal::( 17, BLS12_381_MODULUS.clone(), 100, @@ -1142,17 +1142,17 @@ mod is_equal_tests { #[cfg(feature = "cuda")] #[test] fn cuda_test_modular_is_equal() { - run_cuda_is_equal_test_with_config::( + run_cuda_is_equal_test_with_config::( 17, secp256k1_coord_prime(), 50, ); - run_cuda_is_equal_test_with_config::( + run_cuda_is_equal_test_with_config::( 17, secp256k1_scalar_prime(), 50, ); - run_cuda_is_equal_test_with_config::( + run_cuda_is_equal_test_with_config::( 17, BLS12_381_MODULUS.clone(), 50, @@ -1255,19 +1255,19 @@ mod is_equal_tests { #[test] fn negative_test_modular_is_equal_32limb() { - run_negative_is_equal_test::( + run_negative_is_equal_test::( secp256k1_coord_prime(), 17, 1, ); - run_negative_is_equal_test::( + run_negative_is_equal_test::( secp256k1_coord_prime(), 17, 2, ); - run_negative_is_equal_test::( + run_negative_is_equal_test::( secp256k1_coord_prime(), 17, 3, @@ -1276,19 +1276,19 @@ mod is_equal_tests { #[test] fn negative_test_modular_is_equal_48limb() { - run_negative_is_equal_test::( + run_negative_is_equal_test::( BLS12_381_MODULUS.clone(), 17, 1, ); - run_negative_is_equal_test::( + run_negative_is_equal_test::( BLS12_381_MODULUS.clone(), 17, 2, ); - run_negative_is_equal_test::( + run_negative_is_equal_test::( BLS12_381_MODULUS.clone(), 17, 3, diff --git a/extensions/bigint/circuit/src/common.rs b/extensions/bigint/circuit/src/common.rs index 29d6417b5d..13a2a699f5 100644 --- a/extensions/bigint/circuit/src/common.rs +++ b/extensions/bigint/circuit/src/common.rs @@ -1,5 +1,5 @@ use openvm_circuit::{ - arch::{ExecutionCtxTrait, VmExecState, CONST_BLOCK_SIZE}, + arch::{ExecutionCtxTrait, VmExecState, DEFAULT_BLOCK_SIZE}, system::memory::online::GuestMemory, }; use openvm_stark_backend::p3_field::PrimeField32; @@ -15,9 +15,9 @@ pub fn read_int256( ) -> [u8; INT256_NUM_LIMBS] { let mut result = [0u8; INT256_NUM_LIMBS]; for i in 0..INT256_NUM_BLOCKS { - let block: [u8; CONST_BLOCK_SIZE] = - exec_state.vm_read(addr_space, ptr + (i * CONST_BLOCK_SIZE) as u32); - result[i * CONST_BLOCK_SIZE..(i + 1) * CONST_BLOCK_SIZE].copy_from_slice(&block); + let block: [u8; DEFAULT_BLOCK_SIZE] = + exec_state.vm_read(addr_space, ptr + (i * DEFAULT_BLOCK_SIZE) as u32); + result[i * DEFAULT_BLOCK_SIZE..(i + 1) * DEFAULT_BLOCK_SIZE].copy_from_slice(&block); } result } @@ -31,10 +31,11 @@ pub fn write_int256( data: &[u8; INT256_NUM_LIMBS], ) { for i in 0..INT256_NUM_BLOCKS { - let block: [u8; CONST_BLOCK_SIZE] = data[i * CONST_BLOCK_SIZE..(i + 1) * CONST_BLOCK_SIZE] + let block: [u8; DEFAULT_BLOCK_SIZE] = data + [i * DEFAULT_BLOCK_SIZE..(i + 1) * DEFAULT_BLOCK_SIZE] .try_into() .unwrap(); - exec_state.vm_write(addr_space, ptr + (i * CONST_BLOCK_SIZE) as u32, &block); + exec_state.vm_write(addr_space, ptr + (i * DEFAULT_BLOCK_SIZE) as u32, &block); } } diff --git a/extensions/bigint/circuit/src/cuda/mod.rs b/extensions/bigint/circuit/src/cuda/mod.rs index b020f3f39d..84a7bf9495 100644 --- a/extensions/bigint/circuit/src/cuda/mod.rs +++ b/extensions/bigint/circuit/src/cuda/mod.rs @@ -2,7 +2,7 @@ use std::{mem::size_of, sync::Arc}; use derive_new::new; use openvm_circuit::{ - arch::{DenseRecordArena, CONST_BLOCK_SIZE}, + arch::{DenseRecordArena, DEFAULT_BLOCK_SIZE}, utils::next_power_of_two_or_zero, }; use openvm_circuit_primitives::{ @@ -34,8 +34,8 @@ pub type BaseAlu256AdapterRecord = Rv32VecHeapAdapterRecord< 2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, >; pub type BaseAlu256CoreRecord = BaseAluCoreRecord; @@ -62,8 +62,8 @@ impl Chip for BaseAlu256ChipGpu { 2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, >::width(); let trace_height = next_power_of_two_or_zero(records.len() / RECORD_SIZE); @@ -92,7 +92,7 @@ impl Chip for BaseAlu256ChipGpu { /// Branch Equal ////////////////////////////////////////////////////////////////////////////////////// pub type BranchEqual256AdapterRecord = - Rv32VecHeapBranchAdapterRecord<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>; + Rv32VecHeapBranchAdapterRecord<2, INT256_NUM_BLOCKS, DEFAULT_BLOCK_SIZE>; pub type BranchEqual256CoreRecord = BranchEqualCoreRecord; #[derive(new)] @@ -114,7 +114,7 @@ impl Chip for BranchEqual256ChipGpu { debug_assert_eq!(records.len() % RECORD_SIZE, 0); let trace_width = BranchEqualCoreCols::::width() - + Rv32VecHeapBranchAdapterCols::::width(); + + Rv32VecHeapBranchAdapterCols::::width(); let trace_height = next_power_of_two_or_zero(records.len() / RECORD_SIZE); let d_records = records.to_device().unwrap(); @@ -145,8 +145,8 @@ pub type LessThan256AdapterRecord = Rv32VecHeapAdapterRecord< 2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, >; pub type LessThan256CoreRecord = LessThanCoreRecord; @@ -173,8 +173,8 @@ impl Chip for LessThan256ChipGpu { 2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, >::width(); let trace_height = next_power_of_two_or_zero(records.len() / RECORD_SIZE); @@ -203,7 +203,7 @@ impl Chip for LessThan256ChipGpu { /// Branch Less Than ////////////////////////////////////////////////////////////////////////////////////// pub type BranchLessThan256AdapterRecord = - Rv32VecHeapBranchAdapterRecord<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>; + Rv32VecHeapBranchAdapterRecord<2, INT256_NUM_BLOCKS, DEFAULT_BLOCK_SIZE>; pub type BranchLessThan256CoreRecord = BranchLessThanCoreRecord; #[derive(new)] @@ -225,7 +225,7 @@ impl Chip for BranchLessThan256ChipGpu { debug_assert_eq!(records.len() % RECORD_SIZE, 0); let trace_width = BranchLessThanCoreCols::::width() - + Rv32VecHeapBranchAdapterCols::::width(); + + Rv32VecHeapBranchAdapterCols::::width(); let trace_height = next_power_of_two_or_zero(records.len() / RECORD_SIZE); let d_records = records.to_device().unwrap(); @@ -256,8 +256,8 @@ pub type Shift256AdapterRecord = Rv32VecHeapAdapterRecord< 2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, >; pub type Shift256CoreRecord = ShiftCoreRecord; @@ -284,8 +284,8 @@ impl Chip for Shift256ChipGpu { 2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, >::width(); let trace_height = next_power_of_two_or_zero(records.len() / RECORD_SIZE); @@ -317,8 +317,8 @@ pub type Multiplication256AdapterRecord = Rv32VecHeapAdapterRecord< 2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, >; pub type Multiplication256CoreRecord = MultiplicationCoreRecord; @@ -347,8 +347,8 @@ impl Chip for Multiplication256ChipGpu { 2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, >::width(); let trace_height = next_power_of_two_or_zero(records.len() / RECORD_SIZE); diff --git a/extensions/bigint/circuit/src/lib.rs b/extensions/bigint/circuit/src/lib.rs index 748feee5cd..f63bf59cfc 100644 --- a/extensions/bigint/circuit/src/lib.rs +++ b/extensions/bigint/circuit/src/lib.rs @@ -4,7 +4,7 @@ #![cfg_attr(feature = "tco", feature(core_intrinsics))] use openvm_circuit::{ self, - arch::{InitFileGenerator, SystemConfig, VmAirWrapper, VmChipWrapper, CONST_BLOCK_SIZE}, + arch::{InitFileGenerator, SystemConfig, VmAirWrapper, VmChipWrapper, DEFAULT_BLOCK_SIZE}, system::SystemExecutor, }; use openvm_circuit_derive::{PreflightExecutor, VmConfig}; @@ -43,8 +43,8 @@ pub use cuda::*; #[cfg(test)] mod tests; -/// Number of blocks for INT256 operations (INT256_NUM_LIMBS / CONST_BLOCK_SIZE) -pub const INT256_NUM_BLOCKS: usize = INT256_NUM_LIMBS / CONST_BLOCK_SIZE; +/// Number of blocks for INT256 operations (INT256_NUM_LIMBS / DEFAULT_BLOCK_SIZE) +pub const INT256_NUM_BLOCKS: usize = INT256_NUM_LIMBS / DEFAULT_BLOCK_SIZE; /// Type alias for the ALU adapter AIR wrapper type AluAdapterAir = VecToFlatAluAdapterAir< @@ -52,13 +52,13 @@ type AluAdapterAir = VecToFlatAluAdapterAir< 2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, >, 2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, INT256_NUM_LIMBS, INT256_NUM_LIMBS, >; @@ -69,32 +69,32 @@ type AluAdapterExecutor = VecToFlatAluAdapterExecutor< 2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, >, 2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, INT256_NUM_LIMBS, INT256_NUM_LIMBS, >; /// Type alias for the Branch adapter AIR wrapper type BranchAdapterAir = VecToFlatBranchAdapterAir< - Rv32VecHeapBranchAdapterAir<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>, + Rv32VecHeapBranchAdapterAir<2, INT256_NUM_BLOCKS, DEFAULT_BLOCK_SIZE>, 2, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, INT256_NUM_LIMBS, >; /// Type alias for the Branch adapter executor wrapper type BranchAdapterExecutor = VecToFlatBranchAdapterExecutor< - Rv32VecHeapBranchAdapterExecutor<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>, + Rv32VecHeapBranchAdapterExecutor<2, INT256_NUM_BLOCKS, DEFAULT_BLOCK_SIZE>, 2, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, INT256_NUM_LIMBS, >; @@ -112,8 +112,8 @@ pub type Rv32BaseAlu256Chip = VmChipWrapper< 2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, >, INT256_NUM_LIMBS, RV32_CELL_BITS, @@ -134,8 +134,8 @@ pub type Rv32LessThan256Chip = VmChipWrapper< 2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, >, INT256_NUM_LIMBS, RV32_CELL_BITS, @@ -156,8 +156,8 @@ pub type Rv32Multiplication256Chip = VmChipWrapper< 2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, >, INT256_NUM_LIMBS, RV32_CELL_BITS, @@ -178,8 +178,8 @@ pub type Rv32Shift256Chip = VmChipWrapper< 2, INT256_NUM_BLOCKS, INT256_NUM_BLOCKS, - CONST_BLOCK_SIZE, - CONST_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, + DEFAULT_BLOCK_SIZE, >, INT256_NUM_LIMBS, RV32_CELL_BITS, @@ -194,7 +194,7 @@ pub struct Rv32BranchEqual256Executor(BranchEqualExecutor = VmChipWrapper< F, BranchEqualFiller< - Rv32VecHeapBranchAdapterFiller<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>, + Rv32VecHeapBranchAdapterFiller<2, INT256_NUM_BLOCKS, DEFAULT_BLOCK_SIZE>, INT256_NUM_LIMBS, >, >; @@ -209,7 +209,7 @@ pub struct Rv32BranchLessThan256Executor( pub type Rv32BranchLessThan256Chip = VmChipWrapper< F, BranchLessThanFiller< - Rv32VecHeapBranchAdapterFiller<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>, + Rv32VecHeapBranchAdapterFiller<2, INT256_NUM_BLOCKS, DEFAULT_BLOCK_SIZE>, INT256_NUM_LIMBS, RV32_CELL_BITS, >, diff --git a/extensions/bigint/circuit/src/tests.rs b/extensions/bigint/circuit/src/tests.rs index b4754cd494..72f092723f 100644 --- a/extensions/bigint/circuit/src/tests.rs +++ b/extensions/bigint/circuit/src/tests.rs @@ -58,7 +58,7 @@ use { default_bitwise_lookup_bus, default_var_range_checker_bus, GpuChipTestBuilder, GpuTestChipHarness, }, - EmptyAdapterCoreLayout, CONST_BLOCK_SIZE, + EmptyAdapterCoreLayout, DEFAULT_BLOCK_SIZE, }, }; @@ -919,7 +919,7 @@ fn run_beq_256_rand_test_cuda(opcode: BranchEqualOpcode, num_ops: usize) { &mut harness.matrix_arena, EmptyAdapterCoreLayout::< F, - Rv32VecHeapBranchAdapterExecutor<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>, + Rv32VecHeapBranchAdapterExecutor<2, INT256_NUM_BLOCKS, DEFAULT_BLOCK_SIZE>, >::new(), ); @@ -985,7 +985,7 @@ fn run_blt_256_rand_test_cuda(opcode: BranchLessThanOpcode, num_ops: usize) { &mut harness.matrix_arena, EmptyAdapterCoreLayout::< F, - Rv32VecHeapBranchAdapterExecutor<2, INT256_NUM_BLOCKS, CONST_BLOCK_SIZE>, + Rv32VecHeapBranchAdapterExecutor<2, INT256_NUM_BLOCKS, DEFAULT_BLOCK_SIZE>, >::new(), ); diff --git a/extensions/deferral/circuit/src/call/air.rs b/extensions/deferral/circuit/src/call/air.rs index efbdbe78a3..e70c4d8746 100644 --- a/extensions/deferral/circuit/src/call/air.rs +++ b/extensions/deferral/circuit/src/call/air.rs @@ -4,7 +4,7 @@ use itertools::{izip, Itertools as _}; use openvm_circuit::{ arch::{ AdapterAirContext, ExecutionBridge, ExecutionState, ImmInstruction, VmAdapterAir, - VmAdapterInterface, VmCoreAir, + VmAdapterInterface, VmCoreAir, DEFAULT_BLOCK_SIZE, }, system::memory::{ offline_checker::{MemoryBridge, MemoryReadAuxCols, MemoryWriteAuxCols}, @@ -34,7 +34,7 @@ use crate::{ poseidon2::DeferralPoseidon2Bus, utils::{ byte_commit_to_f, bytes_to_f, combine_output, split_memory_ops, COMMIT_MEMORY_OPS, - COMMIT_NUM_BYTES, DIGEST_MEMORY_OPS, F_NUM_BYTES, MEMORY_OP_SIZE, OUTPUT_TOTAL_BYTES, + COMMIT_NUM_BYTES, DIGEST_MEMORY_OPS, F_NUM_BYTES, OUTPUT_TOTAL_BYTES, OUTPUT_TOTAL_MEMORY_OPS, }, }; @@ -238,9 +238,10 @@ pub struct DeferralCallAdapterCols { pub old_output_acc_aux: [MemoryReadAuxCols; DIGEST_MEMORY_OPS], // Write auxiliary columns - pub output_commit_and_len_aux: [MemoryWriteAuxCols; OUTPUT_TOTAL_MEMORY_OPS], - pub new_input_acc_aux: [MemoryWriteAuxCols; DIGEST_MEMORY_OPS], - pub new_output_acc_aux: [MemoryWriteAuxCols; DIGEST_MEMORY_OPS], + pub output_commit_and_len_aux: + [MemoryWriteAuxCols; OUTPUT_TOTAL_MEMORY_OPS], + pub new_input_acc_aux: [MemoryWriteAuxCols; DIGEST_MEMORY_OPS], + pub new_output_acc_aux: [MemoryWriteAuxCols; DIGEST_MEMORY_OPS], } #[derive(Clone, Copy, Debug, derive_new::new)] @@ -365,7 +366,7 @@ impl VmAdapterAir for DeferralCallAdapterAir { .read( MemoryAddress::new( e.clone(), - input_ptr.clone() + AB::Expr::from_usize(chunk_idx * MEMORY_OP_SIZE), + input_ptr.clone() + AB::Expr::from_usize(chunk_idx * DEFAULT_BLOCK_SIZE), ), data, timestamp_pp(), @@ -385,7 +386,8 @@ impl VmAdapterAir for DeferralCallAdapterAir { .read( MemoryAddress::new( deferral_as.clone(), - input_acc_ptr.clone() + AB::Expr::from_usize(chunk_idx * MEMORY_OP_SIZE), + input_acc_ptr.clone() + + AB::Expr::from_usize(chunk_idx * DEFAULT_BLOCK_SIZE), ), data, timestamp_pp(), @@ -405,7 +407,8 @@ impl VmAdapterAir for DeferralCallAdapterAir { .read( MemoryAddress::new( deferral_as.clone(), - output_acc_ptr.clone() + AB::Expr::from_usize(chunk_idx * MEMORY_OP_SIZE), + output_acc_ptr.clone() + + AB::Expr::from_usize(chunk_idx * DEFAULT_BLOCK_SIZE), ), data, timestamp_pp(), @@ -428,7 +431,7 @@ impl VmAdapterAir for DeferralCallAdapterAir { .write( MemoryAddress::new( e.clone(), - output_ptr.clone() + AB::Expr::from_usize(chunk_idx * MEMORY_OP_SIZE), + output_ptr.clone() + AB::Expr::from_usize(chunk_idx * DEFAULT_BLOCK_SIZE), ), data, timestamp_pp(), @@ -448,7 +451,8 @@ impl VmAdapterAir for DeferralCallAdapterAir { .write( MemoryAddress::new( deferral_as.clone(), - input_acc_ptr.clone() + AB::Expr::from_usize(chunk_idx * MEMORY_OP_SIZE), + input_acc_ptr.clone() + + AB::Expr::from_usize(chunk_idx * DEFAULT_BLOCK_SIZE), ), data, timestamp_pp(), @@ -468,7 +472,8 @@ impl VmAdapterAir for DeferralCallAdapterAir { .write( MemoryAddress::new( deferral_as.clone(), - output_acc_ptr.clone() + AB::Expr::from_usize(chunk_idx * MEMORY_OP_SIZE), + output_acc_ptr.clone() + + AB::Expr::from_usize(chunk_idx * DEFAULT_BLOCK_SIZE), ), data, timestamp_pp(), diff --git a/extensions/deferral/circuit/src/call/execution.rs b/extensions/deferral/circuit/src/call/execution.rs index 8f258385f4..f48912172a 100644 --- a/extensions/deferral/circuit/src/call/execution.rs +++ b/extensions/deferral/circuit/src/call/execution.rs @@ -21,7 +21,7 @@ use crate::{ poseidon2::deferral_poseidon2_chip, utils::{ byte_commit_to_f, combine_output, join_memory_ops, memory_op_chunk, COMMIT_MEMORY_OPS, - COMMIT_NUM_BYTES, DIGEST_MEMORY_OPS, MEMORY_OP_SIZE, OUTPUT_TOTAL_MEMORY_OPS, + COMMIT_NUM_BYTES, DIGEST_MEMORY_OPS, OUTPUT_TOTAL_MEMORY_OPS, }, DeferralFn, CALL_AIR_REL_IDX, POSEIDON2_AIR_REL_IDX, }; @@ -173,20 +173,21 @@ unsafe fn execute_e12_impl( let output_ptr = u32::from_le_bytes(exec_state.vm_read(RV32_REGISTER_AS, pre_compute.rd_ptr)); let input_ptr = u32::from_le_bytes(exec_state.vm_read(RV32_REGISTER_AS, pre_compute.rs_ptr)); - let input_commit_chunks: [[u8; MEMORY_OP_SIZE]; COMMIT_MEMORY_OPS] = - from_fn(|i| exec_state.vm_read(RV32_MEMORY_AS, input_ptr + (i * MEMORY_OP_SIZE) as u32)); + let input_commit_chunks: [[u8; DEFAULT_BLOCK_SIZE]; COMMIT_MEMORY_OPS] = from_fn(|i| { + exec_state.vm_read(RV32_MEMORY_AS, input_ptr + (i * DEFAULT_BLOCK_SIZE) as u32) + }); let input_commit_bytes: [_; COMMIT_NUM_BYTES] = join_memory_ops(input_commit_chunks); let input_commit: [F; _] = byte_commit_to_f(&input_commit_bytes.map(F::from_u8)); - let old_input_acc_chunks: [[F; MEMORY_OP_SIZE]; DIGEST_MEMORY_OPS] = from_fn(|i| { + let old_input_acc_chunks: [[F; DEFAULT_BLOCK_SIZE]; DIGEST_MEMORY_OPS] = from_fn(|i| { exec_state.vm_read( DEFERRAL_AS, - pre_compute.input_acc_ptr + (i * MEMORY_OP_SIZE) as u32, + pre_compute.input_acc_ptr + (i * DEFAULT_BLOCK_SIZE) as u32, ) }); - let old_output_acc_chunks: [[F; MEMORY_OP_SIZE]; DIGEST_MEMORY_OPS] = from_fn(|i| { + let old_output_acc_chunks: [[F; DEFAULT_BLOCK_SIZE]; DIGEST_MEMORY_OPS] = from_fn(|i| { exec_state.vm_read( DEFERRAL_AS, - pre_compute.output_acc_ptr + (i * MEMORY_OP_SIZE) as u32, + pre_compute.output_acc_ptr + (i * DEFAULT_BLOCK_SIZE) as u32, ) }); let old_input_acc = join_memory_ops(old_input_acc_chunks); @@ -209,23 +210,23 @@ unsafe fn execute_e12_impl( let new_output_acc = poseidon2_chip.perm(&old_output_acc, &output_f_commit, true); for chunk_idx in 0..OUTPUT_TOTAL_MEMORY_OPS { - exec_state.vm_write::( + exec_state.vm_write::( RV32_MEMORY_AS, - output_ptr + (chunk_idx * MEMORY_OP_SIZE) as u32, + output_ptr + (chunk_idx * DEFAULT_BLOCK_SIZE) as u32, &memory_op_chunk(&output_key, chunk_idx), ); } for chunk_idx in 0..DIGEST_MEMORY_OPS { - exec_state.vm_write::( + exec_state.vm_write::( DEFERRAL_AS, - pre_compute.input_acc_ptr + (chunk_idx * MEMORY_OP_SIZE) as u32, + pre_compute.input_acc_ptr + (chunk_idx * DEFAULT_BLOCK_SIZE) as u32, &memory_op_chunk(&new_input_acc, chunk_idx), ); } for chunk_idx in 0..DIGEST_MEMORY_OPS { - exec_state.vm_write::( + exec_state.vm_write::( DEFERRAL_AS, - pre_compute.output_acc_ptr + (chunk_idx * MEMORY_OP_SIZE) as u32, + pre_compute.output_acc_ptr + (chunk_idx * DEFAULT_BLOCK_SIZE) as u32, &memory_op_chunk(&new_output_acc, chunk_idx), ); } diff --git a/extensions/deferral/circuit/src/call/trace.rs b/extensions/deferral/circuit/src/call/trace.rs index 3588b6e9c0..6a51f8dc05 100644 --- a/extensions/deferral/circuit/src/call/trace.rs +++ b/extensions/deferral/circuit/src/call/trace.rs @@ -5,6 +5,7 @@ use openvm_circuit::{ arch::{ get_record_from_slice, AdapterTraceExecutor, AdapterTraceFiller, EmptyAdapterCoreLayout, ExecutionError, PreflightExecutor, RecordArena, TraceFiller, VmField, VmStateMut, + DEFAULT_BLOCK_SIZE, }, system::memory::{ offline_checker::{MemoryReadAuxRecord, MemoryWriteAuxRecord, MemoryWriteBytesAuxRecord}, @@ -33,7 +34,7 @@ use crate::{ poseidon2::{deferral_poseidon2_chip, DeferralPoseidon2Chip}, utils::{ byte_commit_to_f, combine_output, join_memory_ops, memory_op_chunk, COMMIT_MEMORY_OPS, - DIGEST_MEMORY_OPS, F_NUM_BYTES, MEMORY_OP_SIZE, OUTPUT_TOTAL_MEMORY_OPS, + DIGEST_MEMORY_OPS, F_NUM_BYTES, OUTPUT_TOTAL_MEMORY_OPS, }, DeferralFn, }; @@ -242,9 +243,9 @@ pub struct DeferralCallAdapterRecord { // Write auxiliary records pub output_commit_and_len_aux: - [MemoryWriteBytesAuxRecord; OUTPUT_TOTAL_MEMORY_OPS], - pub new_input_acc_aux: [MemoryWriteAuxRecord; DIGEST_MEMORY_OPS], - pub new_output_acc_aux: [MemoryWriteAuxRecord; DIGEST_MEMORY_OPS], + [MemoryWriteBytesAuxRecord; OUTPUT_TOTAL_MEMORY_OPS], + pub new_input_acc_aux: [MemoryWriteAuxRecord; DIGEST_MEMORY_OPS], + pub new_output_acc_aux: [MemoryWriteAuxRecord; DIGEST_MEMORY_OPS], } #[derive(Clone, Copy)] @@ -292,11 +293,11 @@ impl AdapterTraceExecutor for DeferralCallAdapterExecutor { &mut record.rs_aux.prev_timestamp, ); - let input_commit_chunks: [[u8; MEMORY_OP_SIZE]; COMMIT_MEMORY_OPS] = from_fn(|i| { + let input_commit_chunks: [[u8; DEFAULT_BLOCK_SIZE]; COMMIT_MEMORY_OPS] = from_fn(|i| { tracing_read( memory, e.as_canonical_u32(), - u32::from_le_bytes(record.rs_val) + (i * MEMORY_OP_SIZE) as u32, + u32::from_le_bytes(record.rs_val) + (i * DEFAULT_BLOCK_SIZE) as u32, &mut record.input_commit_aux[i].prev_timestamp, ) }); @@ -308,17 +309,17 @@ impl AdapterTraceExecutor for DeferralCallAdapterExecutor { let input_acc_ptr = 2 * deferral_idx * DIGEST_SIZE_U32; let output_acc_ptr = input_acc_ptr + DIGEST_SIZE_U32; - let old_input_acc_chunks: [[F; MEMORY_OP_SIZE]; DIGEST_MEMORY_OPS] = from_fn(|i| { + let old_input_acc_chunks: [[F; DEFAULT_BLOCK_SIZE]; DIGEST_MEMORY_OPS] = from_fn(|i| { tracing_read_deferral( memory, - input_acc_ptr + (i * MEMORY_OP_SIZE) as u32, + input_acc_ptr + (i * DEFAULT_BLOCK_SIZE) as u32, &mut record.old_input_acc_aux[i].prev_timestamp, ) }); - let old_output_acc_chunks: [[F; MEMORY_OP_SIZE]; DIGEST_MEMORY_OPS] = from_fn(|i| { + let old_output_acc_chunks: [[F; DEFAULT_BLOCK_SIZE]; DIGEST_MEMORY_OPS] = from_fn(|i| { tracing_read_deferral( memory, - output_acc_ptr + (i * MEMORY_OP_SIZE) as u32, + output_acc_ptr + (i * DEFAULT_BLOCK_SIZE) as u32, &mut record.old_output_acc_aux[i].prev_timestamp, ) }); @@ -355,7 +356,7 @@ impl AdapterTraceExecutor for DeferralCallAdapterExecutor { tracing_write( memory, e.as_canonical_u32(), - u32::from_le_bytes(record.rd_val) + (chunk_idx * MEMORY_OP_SIZE) as u32, + u32::from_le_bytes(record.rd_val) + (chunk_idx * DEFAULT_BLOCK_SIZE) as u32, memory_op_chunk(&output_commit_and_len, chunk_idx), &mut record.output_commit_and_len_aux[chunk_idx].prev_timestamp, &mut record.output_commit_and_len_aux[chunk_idx].prev_data, @@ -371,7 +372,7 @@ impl AdapterTraceExecutor for DeferralCallAdapterExecutor { for chunk_idx in 0..DIGEST_MEMORY_OPS { tracing_write_deferral( memory, - input_acc_ptr + (chunk_idx * MEMORY_OP_SIZE) as u32, + input_acc_ptr + (chunk_idx * DEFAULT_BLOCK_SIZE) as u32, memory_op_chunk(&data.new_input_acc, chunk_idx), &mut record.new_input_acc_aux[chunk_idx].prev_timestamp, &mut record.new_input_acc_aux[chunk_idx].prev_data, @@ -381,7 +382,7 @@ impl AdapterTraceExecutor for DeferralCallAdapterExecutor { for chunk_idx in 0..DIGEST_MEMORY_OPS { tracing_write_deferral( memory, - output_acc_ptr + (chunk_idx * MEMORY_OP_SIZE) as u32, + output_acc_ptr + (chunk_idx * DEFAULT_BLOCK_SIZE) as u32, memory_op_chunk(&data.new_output_acc, chunk_idx), &mut record.new_output_acc_aux[chunk_idx].prev_timestamp, &mut record.new_output_acc_aux[chunk_idx].prev_data, diff --git a/extensions/deferral/circuit/src/output/air.rs b/extensions/deferral/circuit/src/output/air.rs index e820681699..4de971f844 100644 --- a/extensions/deferral/circuit/src/output/air.rs +++ b/extensions/deferral/circuit/src/output/air.rs @@ -2,7 +2,7 @@ use std::{array::from_fn, borrow::Borrow}; use itertools::{izip, Itertools}; use openvm_circuit::{ - arch::{ExecutionBridge, ExecutionState}, + arch::{ExecutionBridge, ExecutionState, DEFAULT_BLOCK_SIZE}, system::memory::{ offline_checker::{MemoryBridge, MemoryReadAuxCols, MemoryWriteAuxCols}, MemoryAddress, @@ -35,8 +35,7 @@ use crate::{ poseidon2::DeferralPoseidon2Bus, utils::{ byte_commit_to_f, bytes_to_f, combine_output, split_memory_ops, COMMIT_NUM_BYTES, - DIGEST_MEMORY_OPS, F_NUM_BYTES, MEMORY_OP_SIZE, OUTPUT_TOTAL_BYTES, - OUTPUT_TOTAL_MEMORY_OPS, + DIGEST_MEMORY_OPS, F_NUM_BYTES, OUTPUT_TOTAL_BYTES, OUTPUT_TOTAL_MEMORY_OPS, }, }; @@ -78,7 +77,7 @@ pub struct DeferralOutputCols { // rows bytes raw_output[local_idx * DIGEST_SIZE..(local_idx + 1) * DIGEST_SIZE] // written to memory and auxiliary columns. pub sponge_inputs: [T; DIGEST_SIZE], - pub write_bytes_aux: [MemoryWriteAuxCols; DIGEST_MEMORY_OPS], + pub write_bytes_aux: [MemoryWriteAuxCols; DIGEST_MEMORY_OPS], // Capacity of the permutation of write_bytes and the previous row's capacity on // non-last rows, compression on the last row. @@ -304,7 +303,7 @@ where .read( MemoryAddress::new( e.clone(), - input_ptr.clone() + AB::Expr::from_usize(chunk_idx * MEMORY_OP_SIZE), + input_ptr.clone() + AB::Expr::from_usize(chunk_idx * DEFAULT_BLOCK_SIZE), ), data, local.from_state.timestamp + AB::Expr::from_usize(2 + chunk_idx), @@ -334,7 +333,7 @@ where e.clone(), output_ptr.clone() + (section_idx_minus_one.clone() * AB::Expr::from_usize(DIGEST_SIZE)) - + AB::Expr::from_usize(chunk_idx * MEMORY_OP_SIZE), + + AB::Expr::from_usize(chunk_idx * DEFAULT_BLOCK_SIZE), ), data, local.from_state.timestamp diff --git a/extensions/deferral/circuit/src/output/execution.rs b/extensions/deferral/circuit/src/output/execution.rs index da21694755..5c840128f8 100644 --- a/extensions/deferral/circuit/src/output/execution.rs +++ b/extensions/deferral/circuit/src/output/execution.rs @@ -19,8 +19,8 @@ use openvm_stark_sdk::config::baby_bear_poseidon2::DIGEST_SIZE; use super::DeferralOutputExecutor; use crate::{ utils::{ - join_memory_ops, memory_op_chunk, split_output, DIGEST_MEMORY_OPS, MEMORY_OP_SIZE, - OUTPUT_TOTAL_BYTES, OUTPUT_TOTAL_MEMORY_OPS, + join_memory_ops, memory_op_chunk, split_output, DIGEST_MEMORY_OPS, OUTPUT_TOTAL_BYTES, + OUTPUT_TOTAL_MEMORY_OPS, }, OUTPUT_AIR_REL_IDX, POSEIDON2_AIR_REL_IDX, }; @@ -156,8 +156,9 @@ unsafe fn execute_e12_impl( ) -> u32 { let output_ptr = u32::from_le_bytes(exec_state.vm_read(RV32_REGISTER_AS, pre_compute.rd_ptr)); let input_ptr = u32::from_le_bytes(exec_state.vm_read(RV32_REGISTER_AS, pre_compute.rs_ptr)); - let output_key_chunks: [[u8; MEMORY_OP_SIZE]; OUTPUT_TOTAL_MEMORY_OPS] = - from_fn(|i| exec_state.vm_read(RV32_MEMORY_AS, input_ptr + (i * MEMORY_OP_SIZE) as u32)); + let output_key_chunks: [[u8; DEFAULT_BLOCK_SIZE]; OUTPUT_TOTAL_MEMORY_OPS] = from_fn(|i| { + exec_state.vm_read(RV32_MEMORY_AS, input_ptr + (i * DEFAULT_BLOCK_SIZE) as u32) + }); let output_key: [u8; OUTPUT_TOTAL_BYTES] = join_memory_ops(output_key_chunks); let (output_commit, output_len) = split_output(output_key); @@ -176,9 +177,9 @@ unsafe fn execute_e12_impl( for (row_idx, output_chunk) in output_raw.chunks_exact(DIGEST_SIZE).enumerate() { let row_output_ptr = output_ptr + (row_idx * DIGEST_SIZE) as u32; for chunk_idx in 0..DIGEST_MEMORY_OPS { - exec_state.vm_write::( + exec_state.vm_write::( RV32_MEMORY_AS, - row_output_ptr + (chunk_idx * MEMORY_OP_SIZE) as u32, + row_output_ptr + (chunk_idx * DEFAULT_BLOCK_SIZE) as u32, &memory_op_chunk(output_chunk, chunk_idx), ); } diff --git a/extensions/deferral/circuit/src/output/trace.rs b/extensions/deferral/circuit/src/output/trace.rs index be782fb78a..5de9ede445 100644 --- a/extensions/deferral/circuit/src/output/trace.rs +++ b/extensions/deferral/circuit/src/output/trace.rs @@ -10,6 +10,7 @@ use openvm_circuit::{ arch::{ get_record_from_slice, CustomBorrow, ExecutionError, MultiRowLayout, MultiRowMetadata, PreflightExecutor, RecordArena, SizedRecord, TraceFiller, VmField, VmStateMut, + DEFAULT_BLOCK_SIZE, }, system::memory::{ offline_checker::{MemoryReadAuxRecord, MemoryWriteBytesAuxRecord}, @@ -39,7 +40,7 @@ use crate::{ poseidon2::DeferralPoseidon2Chip, utils::{ f_commit_to_bytes, join_memory_ops, memory_op_chunk, split_output, DIGEST_MEMORY_OPS, - F_NUM_BYTES, MEMORY_OP_SIZE, OUTPUT_TOTAL_BYTES, OUTPUT_TOTAL_MEMORY_OPS, + F_NUM_BYTES, OUTPUT_TOTAL_BYTES, OUTPUT_TOTAL_MEMORY_OPS, }, }; @@ -80,7 +81,7 @@ pub struct DeferralOutputRecordHeader { pub struct DeferralOutputRecordMut<'a> { pub header: &'a mut DeferralOutputRecordHeader, pub write_bytes: &'a mut [u8], - pub write_aux: &'a mut [MemoryWriteBytesAuxRecord], + pub write_aux: &'a mut [MemoryWriteBytesAuxRecord], } impl<'a> CustomBorrow<'a, DeferralOutputRecordMut<'a>, DeferralOutputLayout> for [u8] { @@ -103,7 +104,7 @@ impl<'a> CustomBorrow<'a, DeferralOutputRecordMut<'a>, DeferralOutputLayout> for // - Subslice operation [..layout.metadata.num_rows] validates sufficient capacity // - Layout calculation ensures space for alignment padding plus required aux records let (_, write_aux_buf, _) = - unsafe { rest.align_to_mut::>() }; + unsafe { rest.align_to_mut::>() }; DeferralOutputRecordMut { header: header_buf.borrow_mut(), @@ -128,10 +129,10 @@ impl<'a> SizedRecord for DeferralOutputRecordMut<'a> { let num_write_rows = layout.metadata.num_rows.saturating_sub(1); total_len += num_write_rows * DIGEST_SIZE; total_len = - total_len.next_multiple_of(align_of::>()); + total_len.next_multiple_of(align_of::>()); total_len += num_write_rows * DIGEST_MEMORY_OPS - * size_of::>(); + * size_of::>(); total_len } @@ -175,11 +176,11 @@ where // Do a non-tracing read to get the output_len and compute num_rows let read_ptr = read_rv32_register(state.memory.data(), rs_ptr); - let output_key_chunks: [[u8; MEMORY_OP_SIZE]; OUTPUT_TOTAL_MEMORY_OPS] = from_fn(|i| { + let output_key_chunks: [[u8; DEFAULT_BLOCK_SIZE]; OUTPUT_TOTAL_MEMORY_OPS] = from_fn(|i| { memory_read( state.memory.data(), RV32_MEMORY_AS, - read_ptr + (i * MEMORY_OP_SIZE) as u32, + read_ptr + (i * DEFAULT_BLOCK_SIZE) as u32, ) }); let output_key: [u8; OUTPUT_TOTAL_BYTES] = join_memory_ops(output_key_chunks); @@ -219,10 +220,10 @@ where let input_ptr = u32::from_le_bytes(record.header.rs_val); let output_ptr = u32::from_le_bytes(record.header.rd_val); for chunk_idx in 0..OUTPUT_TOTAL_MEMORY_OPS { - tracing_read::( + tracing_read::( state.memory, RV32_MEMORY_AS, - input_ptr + (chunk_idx * MEMORY_OP_SIZE) as u32, + input_ptr + (chunk_idx * DEFAULT_BLOCK_SIZE) as u32, &mut record.header.output_commit_and_len_aux[chunk_idx].prev_timestamp, ); } @@ -238,7 +239,7 @@ where tracing_write( state.memory, RV32_MEMORY_AS, - row_output_ptr + (chunk_idx * MEMORY_OP_SIZE) as u32, + row_output_ptr + (chunk_idx * DEFAULT_BLOCK_SIZE) as u32, memory_op_chunk(output_chunk, chunk_idx), &mut record.write_aux[aux_idx].prev_timestamp, &mut record.write_aux[aux_idx].prev_data, diff --git a/extensions/deferral/circuit/src/utils.rs b/extensions/deferral/circuit/src/utils.rs index decf903062..67e97aa862 100644 --- a/extensions/deferral/circuit/src/utils.rs +++ b/extensions/deferral/circuit/src/utils.rs @@ -1,6 +1,7 @@ use std::array::from_fn; use itertools::Itertools; +use openvm_circuit::arch::DEFAULT_BLOCK_SIZE; use openvm_instructions::riscv::RV32_CELL_BITS; use openvm_stark_sdk::config::baby_bear_poseidon2::DIGEST_SIZE; use p3_field::{PrimeCharacteristicRing, PrimeField32}; @@ -9,38 +10,35 @@ pub const F_NUM_BYTES: usize = 4; pub const COMMIT_NUM_BYTES: usize = DIGEST_SIZE * F_NUM_BYTES; pub const OUTPUT_LEN_NUM_BYTES: usize = 8; pub const OUTPUT_TOTAL_BYTES: usize = OUTPUT_LEN_NUM_BYTES + COMMIT_NUM_BYTES; - -// TODO: replace MEMORY_OP_SIZE with CONST_BLOCK_SIZE -pub const MEMORY_OP_SIZE: usize = 4; pub const DIGEST_MEMORY_OPS: usize = num_memory_ops(DIGEST_SIZE); pub const COMMIT_MEMORY_OPS: usize = num_memory_ops(COMMIT_NUM_BYTES); pub const OUTPUT_TOTAL_MEMORY_OPS: usize = num_memory_ops(OUTPUT_TOTAL_BYTES); #[inline(always)] pub const fn num_memory_ops(total_cells: usize) -> usize { - assert!(total_cells.is_multiple_of(MEMORY_OP_SIZE)); - total_cells / MEMORY_OP_SIZE + assert!(total_cells.is_multiple_of(DEFAULT_BLOCK_SIZE)); + total_cells / DEFAULT_BLOCK_SIZE } pub fn split_memory_ops( data: [T; TOTAL_CELLS], -) -> [[T; MEMORY_OP_SIZE]; NUM_OPS] { - assert_eq!(TOTAL_CELLS, NUM_OPS * MEMORY_OP_SIZE); +) -> [[T; DEFAULT_BLOCK_SIZE]; NUM_OPS] { + assert_eq!(TOTAL_CELLS, NUM_OPS * DEFAULT_BLOCK_SIZE); let mut it = data.into_iter(); from_fn(|_| from_fn(|_| it.next().unwrap())) } pub fn join_memory_ops( - chunks: [[T; MEMORY_OP_SIZE]; NUM_OPS], + chunks: [[T; DEFAULT_BLOCK_SIZE]; NUM_OPS], ) -> [T; TOTAL_CELLS] { - assert_eq!(TOTAL_CELLS, NUM_OPS * MEMORY_OP_SIZE); + assert_eq!(TOTAL_CELLS, NUM_OPS * DEFAULT_BLOCK_SIZE); chunks.into_iter().flatten().collect_array().unwrap() } -pub fn memory_op_chunk(data: &[T], chunk_idx: usize) -> [T; MEMORY_OP_SIZE] { - debug_assert!(data.len().is_multiple_of(MEMORY_OP_SIZE)); - let start = chunk_idx * MEMORY_OP_SIZE; - debug_assert!(start + MEMORY_OP_SIZE <= data.len()); +pub fn memory_op_chunk(data: &[T], chunk_idx: usize) -> [T; DEFAULT_BLOCK_SIZE] { + debug_assert!(data.len().is_multiple_of(DEFAULT_BLOCK_SIZE)); + let start = chunk_idx * DEFAULT_BLOCK_SIZE; + debug_assert!(start + DEFAULT_BLOCK_SIZE <= data.len()); from_fn(|i| data[start + i].clone()) } diff --git a/extensions/ecc/circuit/src/extension/hybrid.rs b/extensions/ecc/circuit/src/extension/hybrid.rs index 9c0aa367e4..e3ef38c9b8 100644 --- a/extensions/ecc/circuit/src/extension/hybrid.rs +++ b/extensions/ecc/circuit/src/extension/hybrid.rs @@ -2,7 +2,7 @@ use openvm_algebra_circuit::Rv32ModularHybridBuilder; use openvm_circuit::{ - arch::{CONST_BLOCK_SIZE, *}, + arch::{DEFAULT_BLOCK_SIZE, *}, system::{ cuda::{ extensions::{get_inventory_range_checker, get_or_create_bitwise_op_lookup}, @@ -112,8 +112,8 @@ impl VmProverExtension>()?; - let addne = get_ec_addne_chip::( + inventory.next_air::>()?; + let addne = get_ec_addne_chip::( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -122,8 +122,8 @@ impl VmProverExtension>()?; - let double = get_ec_double_chip::( + inventory.next_air::>()?; + let double = get_ec_double_chip::( config, mem_helper.clone(), range_checker.clone(), @@ -139,8 +139,8 @@ impl VmProverExtension>()?; - let addne = get_ec_addne_chip::( + inventory.next_air::>()?; + let addne = get_ec_addne_chip::( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -149,8 +149,8 @@ impl VmProverExtension>()?; - let double = get_ec_double_chip::( + inventory.next_air::>()?; + let double = get_ec_double_chip::( config, mem_helper.clone(), range_checker.clone(), diff --git a/extensions/ecc/circuit/src/extension/weierstrass.rs b/extensions/ecc/circuit/src/extension/weierstrass.rs index 85dcd0beaf..e1ce21e8e4 100644 --- a/extensions/ecc/circuit/src/extension/weierstrass.rs +++ b/extensions/ecc/circuit/src/extension/weierstrass.rs @@ -9,7 +9,7 @@ use openvm_circuit::{ arch::{ AirInventory, AirInventoryError, ChipInventory, ChipInventoryError, ExecutionBridge, ExecutorInventoryBuilder, ExecutorInventoryError, RowMajorMatrixArena, VmCircuitExtension, - VmExecutionExtension, VmProverExtension, CONST_BLOCK_SIZE, + VmExecutionExtension, VmProverExtension, DEFAULT_BLOCK_SIZE, }, system::{memory::SharedMemoryHelper, SystemPort}, }; @@ -99,11 +99,11 @@ impl WeierstrassExtension { )] pub enum WeierstrassExtensionExecutor { // 32 limbs prime - EcAddNeRv32_32(EcAddNeExecutor), - EcDoubleRv32_32(EcDoubleExecutor), + EcAddNeRv32_32(EcAddNeExecutor), + EcDoubleRv32_32(EcDoubleExecutor), // 48 limbs prime - EcAddNeRv32_48(EcAddNeExecutor), - EcDoubleRv32_48(EcDoubleExecutor), + EcAddNeRv32_48(EcAddNeExecutor), + EcDoubleRv32_48(EcDoubleExecutor), } impl VmExecutionExtension for WeierstrassExtension { @@ -234,7 +234,7 @@ impl VmCircuitExtension for WeierstrassExtension { limb_bits: 8, }; - let addne = get_ec_addne_air::( + let addne = get_ec_addne_air::( exec_bridge, memory_bridge, config.clone(), @@ -245,7 +245,7 @@ impl VmCircuitExtension for WeierstrassExtension { ); inventory.add_air(addne); - let double = get_ec_double_air::( + let double = get_ec_double_air::( exec_bridge, memory_bridge, config, @@ -263,7 +263,7 @@ impl VmCircuitExtension for WeierstrassExtension { limb_bits: 8, }; - let addne = get_ec_addne_air::( + let addne = get_ec_addne_air::( exec_bridge, memory_bridge, config.clone(), @@ -274,7 +274,7 @@ impl VmCircuitExtension for WeierstrassExtension { ); inventory.add_air(addne); - let double = get_ec_double_air::( + let double = get_ec_double_air::( exec_bridge, memory_bridge, config, @@ -336,8 +336,8 @@ where limb_bits: 8, }; - inventory.next_air::>()?; - let addne = get_ec_addne_chip::, ECC_BLOCKS_32, CONST_BLOCK_SIZE>( + inventory.next_air::>()?; + let addne = get_ec_addne_chip::, ECC_BLOCKS_32, DEFAULT_BLOCK_SIZE>( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -346,8 +346,8 @@ where ); inventory.add_executor_chip(addne); - inventory.next_air::>()?; - let double = get_ec_double_chip::, ECC_BLOCKS_32, CONST_BLOCK_SIZE>( + inventory.next_air::>()?; + let double = get_ec_double_chip::, ECC_BLOCKS_32, DEFAULT_BLOCK_SIZE>( config, mem_helper.clone(), range_checker.clone(), @@ -363,8 +363,8 @@ where limb_bits: 8, }; - inventory.next_air::>()?; - let addne = get_ec_addne_chip::, ECC_BLOCKS_48, CONST_BLOCK_SIZE>( + inventory.next_air::>()?; + let addne = get_ec_addne_chip::, ECC_BLOCKS_48, DEFAULT_BLOCK_SIZE>( config.clone(), mem_helper.clone(), range_checker.clone(), @@ -373,8 +373,8 @@ where ); inventory.add_executor_chip(addne); - inventory.next_air::>()?; - let double = get_ec_double_chip::, ECC_BLOCKS_48, CONST_BLOCK_SIZE>( + inventory.next_air::>()?; + let double = get_ec_double_chip::, ECC_BLOCKS_48, DEFAULT_BLOCK_SIZE>( config, mem_helper.clone(), range_checker.clone(), diff --git a/extensions/ecc/circuit/src/lib.rs b/extensions/ecc/circuit/src/lib.rs index 2ae211128d..b564699466 100644 --- a/extensions/ecc/circuit/src/lib.rs +++ b/extensions/ecc/circuit/src/lib.rs @@ -2,7 +2,7 @@ #![cfg_attr(feature = "tco", feature(explicit_tail_calls))] #![cfg_attr(feature = "tco", allow(internal_features))] #![cfg_attr(feature = "tco", feature(core_intrinsics))] -use openvm_circuit::arch::CONST_BLOCK_SIZE; +use openvm_circuit::arch::DEFAULT_BLOCK_SIZE; #[cfg(feature = "cuda")] use { openvm_mod_circuit_builder::FieldExpressionCoreRecordMut, @@ -19,9 +19,9 @@ pub use weierstrass_chip::*; // Blocks per ECC operation (2 coordinates per point) /// Blocks for ECC with 32-limb coordinates: 2 * (32 / 4) = 16 blocks -pub const ECC_BLOCKS_32: usize = 2 * (NUM_LIMBS_32 / CONST_BLOCK_SIZE); +pub const ECC_BLOCKS_32: usize = 2 * (NUM_LIMBS_32 / DEFAULT_BLOCK_SIZE); /// Blocks for ECC with 48-limb coordinates: 2 * (48 / 4) = 24 blocks -pub const ECC_BLOCKS_48: usize = 2 * (NUM_LIMBS_48 / CONST_BLOCK_SIZE); +pub const ECC_BLOCKS_48: usize = 2 * (NUM_LIMBS_48 / DEFAULT_BLOCK_SIZE); #[cfg(feature = "cuda")] pub(crate) type EccRecord< diff --git a/extensions/ecc/circuit/src/weierstrass_chip/tests.rs b/extensions/ecc/circuit/src/weierstrass_chip/tests.rs index 32e09394a9..6d2b518814 100644 --- a/extensions/ecc/circuit/src/weierstrass_chip/tests.rs +++ b/extensions/ecc/circuit/src/weierstrass_chip/tests.rs @@ -7,7 +7,7 @@ use openvm_circuit::arch::{ testing::{ memory::gen_pointer, TestBuilder, TestChipHarness, VmChipTestBuilder, BITWISE_OP_LOOKUP_BUS, }, - Arena, MatrixRecordArena, PreflightExecutor, CONST_BLOCK_SIZE, + Arena, MatrixRecordArena, PreflightExecutor, DEFAULT_BLOCK_SIZE, }; use openvm_circuit_primitives::{ bigint::utils::{secp256k1_coord_prime, secp256r1_coord_prime}, @@ -398,7 +398,7 @@ mod ec_addne_tests { #[test] fn test_ec_addne_32limb() { - run_ec_addne_test::<{ ECC_BLOCKS_32 }, { CONST_BLOCK_SIZE }, { NUM_LIMBS_32 }>( + run_ec_addne_test::<{ ECC_BLOCKS_32 }, { DEFAULT_BLOCK_SIZE }, { NUM_LIMBS_32 }>( Rv32WeierstrassOpcode::CLASS_OFFSET, secp256k1_coord_prime(), ); @@ -406,7 +406,7 @@ mod ec_addne_tests { #[test] fn test_ec_addne_48limb() { - run_ec_addne_test::<{ ECC_BLOCKS_48 }, { CONST_BLOCK_SIZE }, { NUM_LIMBS_48 }>( + run_ec_addne_test::<{ ECC_BLOCKS_48 }, { DEFAULT_BLOCK_SIZE }, { NUM_LIMBS_48 }>( Rv32WeierstrassOpcode::CLASS_OFFSET, BLS12_381_MODULUS.clone(), ); @@ -487,7 +487,7 @@ mod ec_addne_tests { #[cfg(feature = "cuda")] #[test] fn test_weierstrass_addne_cuda_2x32() { - run_cuda_ec_addne::( + run_cuda_ec_addne::( Rv32WeierstrassOpcode::CLASS_OFFSET, secp256k1_coord_prime(), ); @@ -496,7 +496,7 @@ mod ec_addne_tests { #[cfg(feature = "cuda")] #[test] fn test_weierstrass_addne_cuda_6x16() { - run_cuda_ec_addne::( + run_cuda_ec_addne::( Rv32WeierstrassOpcode::CLASS_OFFSET, BLS12_381_MODULUS.clone(), ); @@ -516,7 +516,7 @@ mod ec_addne_tests { limb_bits: LIMB_BITS, }; - let executor = get_ec_addne_step::<{ ECC_BLOCKS_32 }, { CONST_BLOCK_SIZE }>( + let executor = get_ec_addne_step::<{ ECC_BLOCKS_32 }, { DEFAULT_BLOCK_SIZE }>( config, tester.range_checker().bus(), tester.address_bits(), @@ -850,7 +850,7 @@ mod ec_double_tests { #[test] fn test_ec_double_32limb() { - run_ec_double_test::<{ ECC_BLOCKS_32 }, { CONST_BLOCK_SIZE }, { NUM_LIMBS_32 }>( + run_ec_double_test::<{ ECC_BLOCKS_32 }, { DEFAULT_BLOCK_SIZE }, { NUM_LIMBS_32 }>( Rv32WeierstrassOpcode::CLASS_OFFSET, secp256k1_coord_prime(), 50, @@ -863,7 +863,7 @@ mod ec_double_tests { let coeff_a = (-secp256r1::Fp::from(3)).to_bytes(); let a = BigUint::from_bytes_le(&coeff_a); - run_ec_double_test::<{ ECC_BLOCKS_32 }, { CONST_BLOCK_SIZE }, { NUM_LIMBS_32 }>( + run_ec_double_test::<{ ECC_BLOCKS_32 }, { DEFAULT_BLOCK_SIZE }, { NUM_LIMBS_32 }>( Rv32WeierstrassOpcode::CLASS_OFFSET, secp256r1_coord_prime(), 50, @@ -873,7 +873,7 @@ mod ec_double_tests { #[test] fn test_ec_double_48limb() { - run_ec_double_test::<{ ECC_BLOCKS_48 }, { CONST_BLOCK_SIZE }, { NUM_LIMBS_48 }>( + run_ec_double_test::<{ ECC_BLOCKS_48 }, { DEFAULT_BLOCK_SIZE }, { NUM_LIMBS_48 }>( Rv32WeierstrassOpcode::CLASS_OFFSET, BLS12_381_MODULUS.clone(), 50, @@ -994,7 +994,7 @@ mod ec_double_tests { #[cfg(feature = "cuda")] #[test] fn test_ec_double_cuda_2x32() { - run_ec_double_cuda_test::( + run_ec_double_cuda_test::( Rv32WeierstrassOpcode::CLASS_OFFSET, secp256k1_coord_prime(), 50, @@ -1008,7 +1008,7 @@ mod ec_double_tests { let coeff_a = (-secp256r1::Fp::from(3)).to_bytes(); let a = BigUint::from_bytes_le(&coeff_a); - run_ec_double_cuda_test::( + run_ec_double_cuda_test::( Rv32WeierstrassOpcode::CLASS_OFFSET, secp256r1_coord_prime(), 50, @@ -1019,7 +1019,7 @@ mod ec_double_tests { #[cfg(feature = "cuda")] #[test] fn test_ec_double_cuda_6x16() { - run_ec_double_cuda_test::( + run_ec_double_cuda_test::( Rv32WeierstrassOpcode::CLASS_OFFSET, BLS12_381_MODULUS.clone(), 50, @@ -1041,7 +1041,7 @@ mod ec_double_tests { limb_bits: LIMB_BITS, }; - let executor = get_ec_double_step::<{ ECC_BLOCKS_32 }, { CONST_BLOCK_SIZE }>( + let executor = get_ec_double_step::<{ ECC_BLOCKS_32 }, { DEFAULT_BLOCK_SIZE }>( config, tester.range_checker().bus(), tester.address_bits(), @@ -1073,7 +1073,7 @@ mod ec_double_tests { ) .unwrap(); - let executor = get_ec_double_step::<{ ECC_BLOCKS_32 }, { CONST_BLOCK_SIZE }>( + let executor = get_ec_double_step::<{ ECC_BLOCKS_32 }, { DEFAULT_BLOCK_SIZE }>( config.clone(), tester.range_checker().bus(), tester.address_bits(), diff --git a/extensions/rv32im/circuit/src/adapters/deferral.rs b/extensions/rv32im/circuit/src/adapters/deferral.rs new file mode 100644 index 0000000000..79f5552115 --- /dev/null +++ b/extensions/rv32im/circuit/src/adapters/deferral.rs @@ -0,0 +1,199 @@ +use openvm_circuit::{ + arch::{execution_mode::ExecutionCtxTrait, VmStateMut}, + system::memory::{ + offline_checker::MemoryWriteAuxCols, + online::{GuestMemory, TracingMemory}, + }, +}; +use openvm_instructions::{riscv::RV32_IMM_AS, DEFERRAL_AS}; +use openvm_stark_backend::p3_field::PrimeField32; + +#[inline(always)] +pub fn memory_read_deferral(memory: &GuestMemory, ptr: u32) -> [F; N] +where + F: PrimeField32, +{ + // SAFETY: + // - address space `DEFERRAL_AS` will always have cell type `F` and minimum alignment of `1` + unsafe { memory.read::(DEFERRAL_AS, ptr) } +} + +#[inline(always)] +pub fn memory_read_or_imm_deferral(memory: &GuestMemory, addr_space: u32, ptr_or_imm: F) -> F +where + F: PrimeField32, +{ + debug_assert!(addr_space == RV32_IMM_AS || addr_space == DEFERRAL_AS); + + if addr_space == DEFERRAL_AS { + let [result]: [F; 1] = memory_read_deferral(memory, ptr_or_imm.as_canonical_u32()); + result + } else { + ptr_or_imm + } +} + +#[inline(always)] +pub fn memory_write_deferral(memory: &mut GuestMemory, ptr: u32, data: [F; N]) +where + F: PrimeField32, +{ + // SAFETY: + // - address space `DEFERRAL_AS` will always have cell type `F` and minimum alignment of `1` + unsafe { memory.write::(DEFERRAL_AS, ptr, data) } +} + +#[inline(always)] +pub fn memory_read_deferral_from_state( + state: &mut VmStateMut, + ptr: u32, +) -> [F; N] +where + F: PrimeField32, + Ctx: ExecutionCtxTrait, +{ + state.ctx.on_memory_operation(DEFERRAL_AS, ptr, N as u32); + + memory_read_deferral(state.memory, ptr) +} + +#[inline(always)] +pub fn memory_read_or_imm_deferral_from_state( + state: &mut VmStateMut, + addr_space: u32, + ptr_or_imm: F, +) -> F +where + F: PrimeField32, + Ctx: ExecutionCtxTrait, +{ + debug_assert!(addr_space == RV32_IMM_AS || addr_space == DEFERRAL_AS); + + if addr_space == DEFERRAL_AS { + let [result]: [F; 1] = + memory_read_deferral_from_state(state, ptr_or_imm.as_canonical_u32()); + result + } else { + ptr_or_imm + } +} + +#[inline(always)] +pub fn memory_write_deferral_from_state( + state: &mut VmStateMut, + ptr: u32, + data: [F; N], +) where + F: PrimeField32, + Ctx: ExecutionCtxTrait, +{ + state.ctx.on_memory_operation(DEFERRAL_AS, ptr, N as u32); + + memory_write_deferral(state.memory, ptr, data) +} + +/// Atomic read operation which increments the timestamp by 1. +/// Returns `(t_prev, [ptr:BLOCK_SIZE]_4)` where `t_prev` is the timestamp of the last memory +/// access. +#[inline(always)] +pub fn timed_read_deferral( + memory: &mut TracingMemory, + ptr: u32, +) -> (u32, [F; BLOCK_SIZE]) +where + F: PrimeField32, +{ + // SAFETY: + // - address space `DEFERRAL_AS` has cell type `F` and block_size of `DEFAULT_BLOCK_SIZE` + unsafe { memory.read::(DEFERRAL_AS, ptr) } +} + +#[inline(always)] +pub fn timed_write_deferral( + memory: &mut TracingMemory, + ptr: u32, + vals: [F; BLOCK_SIZE], +) -> (u32, [F; BLOCK_SIZE]) +where + F: PrimeField32, +{ + // SAFETY: + // - address space `DEFERRAL_AS` has cell type `F` and block_size of `DEFAULT_BLOCK_SIZE` + unsafe { memory.write::(DEFERRAL_AS, ptr, vals) } +} + +/// Reads register value at `ptr` from memory and records the previous timestamp. +/// Reads are only done from address space [DEFERRAL_AS]. +#[inline(always)] +pub fn tracing_read_deferral( + memory: &mut TracingMemory, + ptr: u32, + prev_timestamp: &mut u32, +) -> [F; BLOCK_SIZE] +where + F: PrimeField32, +{ + let (t_prev, data) = timed_read_deferral(memory, ptr); + *prev_timestamp = t_prev; + data +} + +/// Writes `ptr, vals` into memory and records the previous timestamp and data. +/// Writes are only done to address space [DEFERRAL_AS]. +#[inline(always)] +pub fn tracing_write_deferral( + memory: &mut TracingMemory, + ptr: u32, + vals: [F; BLOCK_SIZE], + prev_timestamp: &mut u32, + prev_data: &mut [F; BLOCK_SIZE], +) where + F: PrimeField32, +{ + let (t_prev, data_prev) = timed_write_deferral(memory, ptr, vals); + *prev_timestamp = t_prev; + *prev_data = data_prev; +} + +/// Writes `ptr, vals` into memory and records the previous timestamp and data. +#[inline(always)] +pub fn tracing_write_deferral_inplace( + memory: &mut TracingMemory, + ptr: u32, + vals: [F; BLOCK_SIZE], + cols: &mut MemoryWriteAuxCols, +) where + F: PrimeField32, +{ + let (t_prev, data_prev) = timed_write_deferral(memory, ptr, vals); + cols.base.set_prev(F::from_u32(t_prev)); + cols.prev_data = data_prev; +} + +/// Reads value at `_ptr` from memory and records the previous timestamp. +/// If the read is an immediate, the previous timestamp will be set to `u32::MAX`. +#[inline(always)] +pub fn tracing_read_or_imm_deferral( + memory: &mut TracingMemory, + addr_space: F, + ptr_or_imm: F, + prev_timestamp: &mut u32, +) -> F +where + F: PrimeField32, +{ + debug_assert!( + addr_space == F::ZERO || addr_space == F::from_u32(DEFERRAL_AS), + "addr_space={addr_space} is not valid" + ); + + if addr_space == F::ZERO { + *prev_timestamp = u32::MAX; + memory.increment_timestamp(); + ptr_or_imm + } else { + let data: [F; 1] = + tracing_read_deferral(memory, ptr_or_imm.as_canonical_u32(), prev_timestamp); + data[0] + } +} diff --git a/extensions/rv32im/circuit/src/adapters/mod.rs b/extensions/rv32im/circuit/src/adapters/mod.rs index cf370b3f0d..dd3512787a 100644 --- a/extensions/rv32im/circuit/src/adapters/mod.rs +++ b/extensions/rv32im/circuit/src/adapters/mod.rs @@ -70,8 +70,8 @@ pub fn memory_read(memory: &GuestMemory, address_space: u32, ptr ); // SAFETY: - // - address space `RV32_REGISTER_AS` and `RV32_MEMORY_AS` will always have cell type `u8` and - // minimum alignment of `RV32_REGISTER_NUM_LIMBS` + // - address spaces `RV32_REGISTER_AS`, `RV32_MEMORY_AS`, `PUBLIC_VALUES_AS` have cell type `u8` + // and block_size of `DEFAULT_BLOCK_SIZE` unsafe { memory.read::(address_space, ptr) } } @@ -89,8 +89,8 @@ pub fn memory_write( ); // SAFETY: - // - address space `RV32_REGISTER_AS` and `RV32_MEMORY_AS` will always have cell type `u8` and - // minimum alignment of `RV32_REGISTER_NUM_LIMBS` + // - address spaces `RV32_REGISTER_AS`, `RV32_MEMORY_AS`, `PUBLIC_VALUES_AS` have cell type `u8` + // and block_size of `DEFAULT_BLOCK_SIZE` unsafe { memory.write::(address_space, ptr, data) } } @@ -110,9 +110,9 @@ pub fn timed_read( ); // SAFETY: - // - address space `RV32_REGISTER_AS` and `RV32_MEMORY_AS` will always have cell type `u8` and - // minimum alignment of `RV32_REGISTER_NUM_LIMBS` - unsafe { memory.read::(address_space, ptr) } + // - address spaces `RV32_REGISTER_AS`, `RV32_MEMORY_AS`, `PUBLIC_VALUES_AS` have cell type `u8` + // and block_size of `DEFAULT_BLOCK_SIZE` + unsafe { memory.read::(address_space, ptr) } } #[inline(always)] @@ -129,9 +129,9 @@ pub fn timed_write( ); // SAFETY: - // - address space `RV32_REGISTER_AS` and `RV32_MEMORY_AS` will always have cell type `u8` and - // minimum alignment of `RV32_REGISTER_NUM_LIMBS` - unsafe { memory.write::(address_space, ptr, data) } + // - address spaces `RV32_REGISTER_AS`, `RV32_MEMORY_AS`, `PUBLIC_VALUES_AS` have cell type `u8` + // and block_size of `DEFAULT_BLOCK_SIZE` + unsafe { memory.write::(address_space, ptr, data) } } /// Reads register value at `reg_ptr` from memory and records the memory access in mutable buffer. diff --git a/extensions/rv32im/circuit/src/base_alu/tests.rs b/extensions/rv32im/circuit/src/base_alu/tests.rs index c54467ac5a..0b7a2e64dc 100644 --- a/extensions/rv32im/circuit/src/base_alu/tests.rs +++ b/extensions/rv32im/circuit/src/base_alu/tests.rs @@ -160,7 +160,7 @@ fn rand_rv32_alu_test(opcode: BaseAluOpcode, num_ops: usize) { // TODO(AG): make a more meaningful test for memory accesses tester.write(2, 1024, [F::ONE; 4]); tester.write(2, 1028, [F::ONE; 4]); - // Use CONST_BLOCK_SIZE-aligned accesses matching the minimum block size + // Use DEFAULT_BLOCK_SIZE-aligned accesses matching the minimum block size let sm1 = tester.read(2, 1024); let sm2 = tester.read(2, 1028); assert_eq!(sm1, [F::ONE; 4]); diff --git a/extensions/rv32im/circuit/src/common/mod.rs b/extensions/rv32im/circuit/src/common/mod.rs index d053351c6f..3de6ac5ed4 100644 --- a/extensions/rv32im/circuit/src/common/mod.rs +++ b/extensions/rv32im/circuit/src/common/mod.rs @@ -9,7 +9,7 @@ mod aot { use openvm_circuit::{ arch::{ execution_mode::{metered::memory_ctx::MemoryCtx, MeteredCtx}, - AotError, SystemConfig, VmExecState, ADDR_SPACE_OFFSET, CONST_BLOCK_SIZE, + AotError, SystemConfig, VmExecState, ADDR_SPACE_OFFSET, DEFAULT_BLOCK_SIZE, }, system::memory::online::GuestMemory, }; @@ -181,13 +181,7 @@ mod aot { // // Therefore the loop only iterates once for `page_id = start_page_id`. - let initial_block_size: usize = config.initial_block_size(); - if initial_block_size != CONST_BLOCK_SIZE { - return Err(AotError::Other(format!( - "initial_block_size must be {CONST_BLOCK_SIZE}, got {initial_block_size}" - ))); - } - let chunk_bits = CONST_BLOCK_SIZE.ilog2(); + let chunk_bits = DEFAULT_BLOCK_SIZE.ilog2(); let as_offset = ((address_space - ADDR_SPACE_OFFSET) as u64) << (config.memory_config.memory_dimensions().address_height); From 2dd93e5671d207126e51a607e030b11db8cec627 Mon Sep 17 00:00:00 2001 From: Paul Chen <77174148+876pol@users.noreply.github.com> Date: Tue, 17 Mar 2026 13:44:13 -0400 Subject: [PATCH 40/78] fix: update sha tests to have new constraint degree (#2566) Resolves INT-6189. Co-authored-by: claude[bot] <41898282+claude[bot]@users.noreply.github.com> Co-authored-by: Jonathan Wang Co-authored-by: Claude Opus 4.6 --- crates/vm/src/utils/stark_utils.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/crates/vm/src/utils/stark_utils.rs b/crates/vm/src/utils/stark_utils.rs index cb0213e8df..51fbb90f4d 100644 --- a/crates/vm/src/utils/stark_utils.rs +++ b/crates/vm/src/utils/stark_utils.rs @@ -26,7 +26,9 @@ use crate::{ /// Supports `trace height <= 2^20`. pub fn test_cpu_engine() -> BabyBearPoseidon2CpuEngine { setup_tracing(); - BabyBearPoseidon2CpuEngine::new(SystemParams::new_for_testing(21)) + let mut params = SystemParams::new_for_testing(21); + params.max_constraint_degree = 3; + BabyBearPoseidon2CpuEngine::new(params) } cfg_if::cfg_if! { @@ -38,7 +40,9 @@ cfg_if::cfg_if! { pub fn test_gpu_engine() -> TestStarkEngine { setup_tracing(); - TestStarkEngine::new(SystemParams::new_for_testing(21)) + let mut params = SystemParams::new_for_testing(21); + params.max_constraint_degree = 3; + TestStarkEngine::new(params) } } else { pub use openvm_stark_sdk::config::baby_bear_poseidon2::BabyBearPoseidon2CpuEngine as TestStarkEngine; From 0fb6314ec3222968c53ed5bee43f73fb28e0692b Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Thu, 19 Mar 2026 04:16:51 +0530 Subject: [PATCH 41/78] fix(v2-rc1): remove `block_size` from config (#2572) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit With access adapters removed, every address space now uses a single fixed block size (`DEFAULT_BLOCK_SIZE = 4`). This PR removes the per-address-space `block_size` field and the associated dynamic block-size machinery, making the memory subsystem simpler and faster. **No AIR changes.** This is purely host-side (execution, trace generation, testing). **Bug fixes included:** 1. The metered execution path and AOT code path were using `DEFAULT_BLOCK_SIZE` (4) to compute merkle tree leaf indices, but `MemoryDimensions::address_height` is sized for `CHUNK` (8) leaves. This was introduced when `initial_block_size()` (which returned `CHUNK = 8` on `main`) was replaced with `CONST_BLOCK_SIZE = 4`. Both paths now correctly use `controller::CHUNK`. 2. The boundary AIR height estimate was `leaves` but the actual trace uses `2 * leaves` (one init + one final row per leaf). This caused segmentation underestimates that surfaced in ECC integration tests. Resolves int-6630. --- - Removed `AddressSpaceHostConfig::block_size` field. Constructor no longer takes a block size. - Removed `MemoryConfig::block_size_bits()`. - Removed `MAX_CELL_BYTE_SIZE` (unused after `handle_touched_blocks` simplification). - **Removed `TracingMemory::block_size`** field (per-AS `Vec`). Metadata slots are now always `DEFAULT_BLOCK_SIZE`-sized. - **Simplified `prev_access_time`**: no const generic, no loop. Single-slot get/set using `pointer / DEFAULT_BLOCK_SIZE`. - **Simplified `touched_blocks`**: uses `DEFAULT_BLOCK_SIZE` directly instead of zipping with per-AS block sizes. - **Replaced `handle_touched_blocks`** (accumulation loop with `current_timestamps`, `current_values` buffer, max-timestamp logic) with a direct parallel `.map()` in `touched_blocks_to_equipartition` — each touched block maps 1:1 to a `TimestampedValues` entry. - Extracted `group_touched_memory_by_chunk` as a `pub(crate)` function so the rechunking logic (grouping `DEFAULT_BLOCK_SIZE` blocks into `CHUNK`-sized merkle leaves) is shared between `PersistentBoundaryChip::finalize` and `MemoryController::generate_proving_ctx`. - Added early return in `touch_range` for `len == 0`. - Rechunking in `generate_proving_ctx` now uses `group_touched_memory_by_chunk` instead of inline `BTreeMap` logic. - **Fixed CHUNK mismatch**: `CHUNK` was aliased to `DEFAULT_BLOCK_SIZE` (4), but merkle tree addressing uses `controller::CHUNK` (8). Now imports and uses `controller::CHUNK` directly. - **Fixed boundary height underestimate**: `BOUNDARY_AIR_ID += leaves` → `leaves * 2` (init + final row per leaf). - **Fixed `num_blocks` for unaligned accesses**: uses `(ptr + size - 1) >> CHUNK_BITS - ptr >> CHUNK_BITS + 1` instead of `(size + CHUNK - 1) >> CHUNK_BITS`, which was incorrect when `ptr` is not chunk-aligned. - Removed `chunk`, `chunk_bits`, `boundary_idx`, `merkle_tree_index` struct fields — replaced with module-level constants and `BOUNDARY_AIR_ID` / `MERKLE_AIR_ID`. - Added doc comment on `apply_height_updates` explaining the paged overestimate strategy. - **`MemoryTester`**: Replaced `HashMap` with a single `chip` field. Added `into_parts()`. `read`/`write` assert `N == DEFAULT_BLOCK_SIZE`. - **`MemoryDummyAir`**: Removed runtime `block_size` field. Width hardcoded to `DEFAULT_BLOCK_SIZE + 4`. - **`DeviceMemoryTester`** (CUDA): Same pattern — single `chip`, `take_chip()`, assertions on `N`. - Simplified to use only `DEFAULT_BLOCK_SIZE`-aligned accesses (was exercising 1/2/4/8/16-byte widths that no longer exist). --- - Updated safety comments: "minimum alignment of 1" → "block_size of DEFAULT_BLOCK_SIZE". - Updated safety comments to reference the fixed 4-byte memory access granularity. - AOT code path: `chunk_bits` now uses `CHUNK.ilog2()` (= 3) instead of `DEFAULT_BLOCK_SIZE.ilog2()` (= 2), matching the merkle tree leaf size. - Comments updated to reflect `CHUNK = 8`. - Cleaned up stale comments referencing "min block size" and "alignment". --- crates/vm/src/arch/config.rs | 35 +--- .../arch/execution_mode/metered/memory_ctx.rs | 55 ++++-- crates/vm/src/arch/testing/cpu.rs | 19 +- crates/vm/src/arch/testing/cuda.rs | 36 ++-- crates/vm/src/arch/testing/memory/air.rs | 11 +- crates/vm/src/arch/testing/memory/cuda.rs | 47 ++--- crates/vm/src/arch/testing/memory/mod.rs | 53 ++--- crates/vm/src/arch/testing/mod.rs | 3 - crates/vm/src/system/memory/controller/mod.rs | 37 ++-- .../vm/src/system/memory/merkle/tests/mod.rs | 9 - crates/vm/src/system/memory/online.rs | 184 +++++------------- crates/vm/src/system/memory/persistent.rs | 57 +++--- crates/vm/src/system/memory/tests.rs | 43 +--- .../rv32im/circuit/src/adapters/deferral.rs | 8 +- extensions/rv32im/circuit/src/adapters/mod.rs | 8 +- .../rv32im/circuit/src/base_alu/tests.rs | 2 +- extensions/rv32im/circuit/src/common/mod.rs | 18 +- .../rv32im/circuit/src/loadstore/tests.rs | 4 +- 18 files changed, 235 insertions(+), 394 deletions(-) diff --git a/crates/vm/src/arch/config.rs b/crates/vm/src/arch/config.rs index ee8e7b2ea9..b0ee6d24cd 100644 --- a/crates/vm/src/arch/config.rs +++ b/crates/vm/src/arch/config.rs @@ -8,9 +8,7 @@ use derive_new::new; use getset::{Setters, WithSetters}; use openvm_instructions::riscv::{RV32_IMM_AS, RV32_MEMORY_AS, RV32_REGISTER_AS}; use openvm_poseidon2_air::Poseidon2Config; -use openvm_stark_backend::{ - p3_field::Field, p3_util::log2_strict_usize, StarkEngine, StarkProtocolConfig, Val, -}; +use openvm_stark_backend::{p3_field::Field, StarkEngine, StarkProtocolConfig, Val}; use serde::{de::DeserializeOwned, Deserialize, Serialize}; use super::{AnyEnum, VmChipComplex, BOUNDARY_AIR_ID, CONNECTOR_AIR_ID, PROGRAM_AIR_ID}; @@ -189,21 +187,14 @@ impl Default for MemoryConfig { impl MemoryConfig { pub fn empty_address_space_configs(num_addr_spaces: usize) -> Vec { // By default only address spaces 1..=4 have non-empty cell counts. - // Unassigned address spaces default to block_size=DEFAULT_BLOCK_SIZE with native32 cells. let mut addr_spaces = - vec![ - AddressSpaceHostConfig::new(0, DEFAULT_BLOCK_SIZE, MemoryCellType::field32()); - num_addr_spaces - ]; - addr_spaces[RV32_IMM_AS as usize] = AddressSpaceHostConfig::new(0, 1, MemoryCellType::Null); - addr_spaces[RV32_REGISTER_AS as usize] = - AddressSpaceHostConfig::new(0, DEFAULT_BLOCK_SIZE, MemoryCellType::U8); + vec![AddressSpaceHostConfig::new(0, MemoryCellType::field32()); num_addr_spaces]; + addr_spaces[RV32_IMM_AS as usize] = AddressSpaceHostConfig::new(0, MemoryCellType::Null); + addr_spaces[RV32_REGISTER_AS as usize] = AddressSpaceHostConfig::new(0, MemoryCellType::U8); - addr_spaces[RV32_MEMORY_AS as usize] = - AddressSpaceHostConfig::new(0, DEFAULT_BLOCK_SIZE, MemoryCellType::U8); + addr_spaces[RV32_MEMORY_AS as usize] = AddressSpaceHostConfig::new(0, MemoryCellType::U8); - addr_spaces[PUBLIC_VALUES_AS as usize] = - AddressSpaceHostConfig::new(0, DEFAULT_BLOCK_SIZE, MemoryCellType::U8); + addr_spaces[PUBLIC_VALUES_AS as usize] = AddressSpaceHostConfig::new(0, MemoryCellType::U8); addr_spaces } @@ -215,13 +206,6 @@ impl MemoryConfig { addr_spaces[openvm_instructions::DEFERRAL_AS as usize].num_cells = 1 << 29; Self::new(3, addr_spaces, POINTER_MAX_BITS, 29, 17) } - - pub fn block_size_bits(&self) -> Vec { - self.addr_spaces - .iter() - .map(|addr_sp| log2_strict_usize(addr_sp.block_size) as u8) - .collect() - } } /// System-level configuration for the virtual machine. Contains all configuration parameters that @@ -349,11 +333,6 @@ pub struct AddressSpaceHostConfig { /// The number of memory cells in each address space, where a memory cell refers to a single /// addressable unit of memory as defined by the ISA. pub num_cells: usize, - /// Block size for memory accesses. Each address space has a fixed block size that determines - /// the granularity of memory bus interactions. - /// - /// **Note**: Block size is in terms of memory cells. - pub block_size: usize, pub layout: MemoryCellType, } @@ -364,8 +343,6 @@ impl AddressSpaceHostConfig { } } -pub(crate) const MAX_CELL_BYTE_SIZE: usize = 8; - #[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq)] pub enum MemoryCellType { Null, diff --git a/crates/vm/src/arch/execution_mode/metered/memory_ctx.rs b/crates/vm/src/arch/execution_mode/metered/memory_ctx.rs index fc2a09b1e1..c79df73ec7 100644 --- a/crates/vm/src/arch/execution_mode/metered/memory_ctx.rs +++ b/crates/vm/src/arch/execution_mode/metered/memory_ctx.rs @@ -2,12 +2,14 @@ use abi_stable::std_types::RVec; use openvm_instructions::riscv::{RV32_NUM_REGISTERS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS}; use crate::{ - arch::{SystemConfig, BOUNDARY_AIR_ID, DEFAULT_BLOCK_SIZE, MERKLE_AIR_ID}, - system::memory::dimensions::MemoryDimensions, + arch::{SystemConfig, BOUNDARY_AIR_ID, MERKLE_AIR_ID}, + system::memory::{dimensions::MemoryDimensions, CHUNK}, }; -const CHUNK: u32 = DEFAULT_BLOCK_SIZE as u32; -const CHUNK_BITS: u32 = CHUNK.ilog2(); +/// CHUNK granularity (merkle leaf size) for page fault tracking. +/// Must match the CHUNK used to compute `MemoryDimensions::address_height`. +const CHUNK_U32: u32 = CHUNK as u32; +const CHUNK_BITS: u32 = CHUNK_U32.ilog2(); /// Upper bound on number of memory pages accessed per instruction. Used for buffer allocation. pub const MAX_MEM_PAGE_OPS_PER_INSN: usize = 1 << 16; @@ -161,11 +163,12 @@ impl MemoryCtx { ) { debug_assert!((address_space as usize) < self.addr_space_access_count.len()); - let num_blocks = (size + CHUNK - 1) >> CHUNK_BITS; - let start_chunk_id = ptr >> CHUNK_BITS; + let chunk_idx = ptr >> CHUNK_BITS; + let end_chunk_idx = (ptr + size - 1) >> CHUNK_BITS; + let num_blocks = end_chunk_idx - chunk_idx + 1; let start_block_id = self .memory_dimensions - .label_to_index((address_space, start_chunk_id)) as u32; + .label_to_index((address_space, chunk_idx)) as u32; let end_block_id = start_block_id + num_blocks; let start_page_id = start_block_id >> PAGE_BITS; let end_page_id = ((end_block_id - 1) >> PAGE_BITS) + 1; @@ -248,25 +251,48 @@ impl MemoryCtx { self.page_indices_since_checkpoint_len = 0; } - /// Apply height updates given page counts + /// Overestimates trace heights from page faults. + /// + /// Memory leaves (CHUNK-sized) form a sparse merkle tree of height `h`. Each segment + /// maintains an initial and final tree, so all counts are doubled. + /// + /// On each page fault, we conservatively assume all `2^PAGE_BITS` leaves in the page + /// are touched and no merkle nodes are shared across pages: + /// + /// ```text + /// [root] height h + /// / \ + /// ... ... + /// / \ + /// [page] [page] (h - PAGE_BITS) nodes above each page + /// / .. \ + /// L .. L 2^PAGE_BITS leaves, (2^PAGE_BITS - 1) internal nodes + /// ``` + /// + /// Per page fault: + /// - BOUNDARY_AIR: `2 * 2^PAGE_BITS` rows (one init + one final row per leaf) + /// - MERKLE_AIR: `2 * nodes_per_page` rows + /// - Poseidon2: `2 * 2^PAGE_BITS` (leaf compression) + `2 * nodes_per_page` (tree hashes) #[inline(always)] fn apply_height_updates(&self, trace_heights: &mut [u32], addr_space_access_count: &[u32]) { let page_access_count: u32 = addr_space_access_count.iter().sum(); - // On page fault, assume we add all leaves in a page + // Leaves touched: conservatively assume every leaf in each faulted page is touched. let leaves = page_access_count << PAGE_BITS; - debug_assert!(trace_heights.len() >= 2); let poseidon2_idx = trace_heights.len() - 2; let merkle_height = self.memory_dimensions.overall_height(); - let nodes = (((1 << PAGE_BITS) - 1) + (merkle_height - PAGE_BITS)) as u32; + let nodes_per_page = (((1 << PAGE_BITS) - 1) + (merkle_height - PAGE_BITS)) as u32; // SAFETY: BOUNDARY_AIR_ID, MERKLE_AIR_ID, and poseidon2_idx are all within bounds unsafe { - *trace_heights.get_unchecked_mut(BOUNDARY_AIR_ID) += leaves; + *trace_heights.get_unchecked_mut(BOUNDARY_AIR_ID) += leaves * 2; + // Poseidon2: 2 hashes per leaf (compression) + 2 per internal node (init + final tree) *trace_heights.get_unchecked_mut(poseidon2_idx) += - leaves * 2 + nodes * page_access_count * 2; - *trace_heights.get_unchecked_mut(MERKLE_AIR_ID) += nodes * page_access_count * 2; + leaves * 2 + nodes_per_page * page_access_count * 2; + // Merkle AIR: 2 rows per internal node (init + final tree) + *trace_heights.get_unchecked_mut(MERKLE_AIR_ID) += + nodes_per_page * page_access_count * 2; } } @@ -288,6 +314,7 @@ impl MemoryCtx { #[cfg(test)] mod tests { use super::*; + #[test] fn test_bitset_insert_range() { // 513 bits diff --git a/crates/vm/src/arch/testing/cpu.rs b/crates/vm/src/arch/testing/cpu.rs index a9da2dd12b..ce7eed01f9 100644 --- a/crates/vm/src/arch/testing/cpu.rs +++ b/crates/vm/src/arch/testing/cpu.rs @@ -134,14 +134,6 @@ where .write(address_space, pointer, value.map(F::from_usize)); } - fn write_cell(&mut self, address_space: usize, pointer: usize, value: F) { - self.write(address_space, pointer, [value]); - } - - fn read_cell(&mut self, address_space: usize, pointer: usize) -> F { - self.read::<1>(address_space, pointer)[0] - } - fn address_bits(&self) -> usize { self.memory.controller.memory_config().pointer_max_bits } @@ -434,14 +426,15 @@ where pub fn finalize(mut self) -> Self { if let Some(memory_tester) = self.memory.take() { - let mut memory_controller = memory_tester.controller; - let mut memory = memory_tester.memory; + let MemoryTester { + chip: mem_chip, + mut memory, + controller: mut memory_controller, + } = memory_tester; let touched_memory = memory.finalize::>(); // Balance memory boundaries let range_checker = memory_controller.range_checker.clone(); - for mem_chip in memory_tester.chip_for_block.into_values() { - self = self.load_periphery((mem_chip.air, mem_chip)); - } + self = self.load_periphery((mem_chip.air, mem_chip)); let mem_inventory = MemoryAirInventory::new( memory_controller.memory_bridge(), memory_controller.memory_config(), diff --git a/crates/vm/src/arch/testing/cuda.rs b/crates/vm/src/arch/testing/cuda.rs index 08ca04c8ac..45258786a5 100644 --- a/crates/vm/src/arch/testing/cuda.rs +++ b/crates/vm/src/arch/testing/cuda.rs @@ -148,14 +148,6 @@ impl TestBuilder for GpuChipTestBuilder { self.execution.execute(initial_state, final_state); } - fn read_cell(&mut self, address_space: usize, pointer: usize) -> F { - self.read::<1>(address_space, pointer)[0] - } - - fn write_cell(&mut self, address_space: usize, pointer: usize, value: F) { - self.write(address_space, pointer, [value]); - } - fn read(&mut self, address_space: usize, pointer: usize) -> [F; N] { self.memory.read(address_space, pointer) } @@ -565,24 +557,28 @@ impl GpuChipTester { } pub fn finalize(mut self) -> Self { - if let Some(mut memory_tester) = self.memory.take() { - let touched_memory = memory_tester.memory.finalize::(); - let memory_bridge = memory_tester.memory_bridge(); - - for chip in memory_tester.chip_for_block.into_values() { - self = self.load_periphery(chip.0.air, chip); - } + if let Some(memory_tester) = self.memory.take() { + let DeviceMemoryTester { + chip, + mut memory, + mut inventory, + hasher_chip, + config, + mem_bus, + range_bus, + } = memory_tester; + let touched_memory = memory.finalize::(); + let memory_bridge = MemoryBridge::new(mem_bus, config.timestamp_max_bits, range_bus); + self = self.load_periphery(chip.0.air, chip); let airs = MemoryAirInventory::new( memory_bridge, - &memory_tester.config, + &config, PermutationCheckBus::new(MEMORY_MERKLE_BUS), PermutationCheckBus::new(POSEIDON2_DIRECT_BUS), ) .into_airs(); - let ctxs = memory_tester - .inventory - .generate_proving_ctxs(touched_memory); + let ctxs = inventory.generate_proving_ctxs(touched_memory); for (air, ctx) in airs .into_iter() .zip(ctxs) @@ -591,7 +587,7 @@ impl GpuChipTester { self = self.load_air_proving_ctx(air, ctx); } - if let Some(hasher_chip) = memory_tester.hasher_chip { + if let Some(hasher_chip) = hasher_chip { let air: AirRef = match hasher_chip.as_ref() { Poseidon2PeripheryChipGPU::Register0(_) => { let config = Poseidon2Config::default(); diff --git a/crates/vm/src/arch/testing/memory/air.rs b/crates/vm/src/arch/testing/memory/air.rs index 6f4edc53ef..d01ad0a4e5 100644 --- a/crates/vm/src/arch/testing/memory/air.rs +++ b/crates/vm/src/arch/testing/memory/air.rs @@ -11,7 +11,10 @@ use openvm_stark_backend::{ BaseAirWithPublicValues, PartitionedBaseAir, StarkProtocolConfig, Val, }; -use crate::system::memory::{offline_checker::MemoryBus, MemoryAddress}; +use crate::{ + arch::DEFAULT_BLOCK_SIZE, + system::memory::{offline_checker::MemoryBus, MemoryAddress}, +}; #[repr(C)] #[derive(Clone, Copy)] @@ -61,17 +64,17 @@ impl<'a, T> DummyMemoryInteractionColsMut<'a, T> { } } +/// AIR width = DEFAULT_BLOCK_SIZE + 4 (addr_space, ptr, data[DEFAULT_BLOCK_SIZE], timestamp, count) #[derive(Clone, Copy, Debug, derive_new::new)] pub struct MemoryDummyAir { pub bus: MemoryBus, - pub block_size: usize, } impl BaseAirWithPublicValues for MemoryDummyAir {} impl PartitionedBaseAir for MemoryDummyAir {} impl BaseAir for MemoryDummyAir { fn width(&self) -> usize { - self.block_size + 4 + DEFAULT_BLOCK_SIZE + 4 } } @@ -116,7 +119,7 @@ impl MemoryDummyChip { } pub fn push(&mut self, addr_space: u32, ptr: u32, data: &[F], timestamp: u32, count: F) { - assert_eq!(data.len(), self.air.block_size); + assert_eq!(data.len(), DEFAULT_BLOCK_SIZE); self.trace.push(F::from_u32(addr_space)); self.trace.push(F::from_u32(ptr)); self.trace.extend_from_slice(data); diff --git a/crates/vm/src/arch/testing/memory/cuda.rs b/crates/vm/src/arch/testing/memory/cuda.rs index 30dc33ff03..9a55f6bd95 100644 --- a/crates/vm/src/arch/testing/memory/cuda.rs +++ b/crates/vm/src/arch/testing/memory/cuda.rs @@ -1,9 +1,9 @@ -use std::{collections::HashMap, sync::Arc}; +use std::sync::Arc; use openvm_circuit::{ arch::{ testing::memory::air::{MemoryDummyAir, MemoryDummyChip}, - MemoryConfig, + MemoryConfig, DEFAULT_BLOCK_SIZE, }, system::memory::{ offline_checker::{MemoryBridge, MemoryBus}, @@ -28,7 +28,7 @@ use crate::{ }; pub struct DeviceMemoryTester { - pub chip_for_block: HashMap, + pub(crate) chip: FixedSizeMemoryTester, pub memory: TracingMemory, pub inventory: MemoryInventoryGPU, pub hasher_chip: Option>, @@ -46,11 +46,6 @@ impl DeviceMemoryTester { mem_config: MemoryConfig, range_checker: Arc, ) -> Self { - let mut chip_for_block = HashMap::new(); - for log_block_size in 0..6 { - let block_size = 1 << log_block_size; - chip_for_block.insert(block_size, FixedSizeMemoryTester::new(mem_bus, block_size)); - } let range_bus = range_checker.cpu_chip.as_ref().unwrap().bus(); let sbox_regs = 1; let poseidon2_periphery = Arc::new(Poseidon2PeripheryChipGPU::new( @@ -61,7 +56,7 @@ impl DeviceMemoryTester { MemoryInventoryGPU::new(mem_config.clone(), poseidon2_periphery.clone()); inventory.set_initial_memory(&memory.data.memory); Self { - chip_for_block, + chip: FixedSizeMemoryTester::new(mem_bus), memory, inventory, hasher_chip: Some(poseidon2_periphery), @@ -76,23 +71,18 @@ impl DeviceMemoryTester { } pub fn read(&mut self, addr_space: usize, ptr: usize) -> [F; N] { + const { assert!(N == DEFAULT_BLOCK_SIZE) }; let t = self.memory.timestamp(); let (t_prev, data) = unsafe { self.memory.read::(addr_space as u32, ptr as u32) }; let data = data.map(F::from_u8); - self.chip_for_block.get_mut(&N).unwrap().receive( - addr_space as u32, - ptr as u32, - &data, - t_prev, - ); - self.chip_for_block - .get_mut(&N) - .unwrap() - .send(addr_space as u32, ptr as u32, &data, t); + self.chip + .receive(addr_space as u32, ptr as u32, &data, t_prev); + self.chip.send(addr_space as u32, ptr as u32, &data, t); data } pub fn write(&mut self, addr_space: usize, ptr: usize, data: [F; N]) { + const { assert!(N == DEFAULT_BLOCK_SIZE) }; let t = self.memory.timestamp(); let (t_prev, data_prev) = unsafe { self.memory.write::( @@ -102,24 +92,17 @@ impl DeviceMemoryTester { ) }; let data_prev = data_prev.map(F::from_u8); - self.chip_for_block.get_mut(&N).unwrap().receive( - addr_space as u32, - ptr as u32, - &data_prev, - t_prev, - ); - self.chip_for_block - .get_mut(&N) - .unwrap() - .send(addr_space as u32, ptr as u32, &data, t); + self.chip + .receive(addr_space as u32, ptr as u32, &data_prev, t_prev); + self.chip.send(addr_space as u32, ptr as u32, &data, t); } } pub struct FixedSizeMemoryTester(pub(crate) MemoryDummyChip); impl FixedSizeMemoryTester { - pub fn new(bus: MemoryBus, block_size: usize) -> Self { - Self(MemoryDummyChip::new(MemoryDummyAir::new(bus, block_size))) + pub fn new(bus: MemoryBus) -> Self { + Self(MemoryDummyChip::new(MemoryDummyAir::new(bus))) } pub fn send(&mut self, addr_space: u32, ptr: u32, data: &[F], timestamp: u32) { @@ -152,7 +135,7 @@ impl Chip for FixedSizeMemoryTester { width, &records.to_device().unwrap(), num_records, - self.0.air.block_size, + DEFAULT_BLOCK_SIZE, ) .unwrap(); } diff --git a/crates/vm/src/arch/testing/memory/mod.rs b/crates/vm/src/arch/testing/memory/mod.rs index f9dce800b3..95612ddfb9 100644 --- a/crates/vm/src/arch/testing/memory/mod.rs +++ b/crates/vm/src/arch/testing/memory/mod.rs @@ -1,10 +1,8 @@ -use std::collections::HashMap; - use air::{MemoryDummyAir, MemoryDummyChip}; use rand::Rng; use crate::{ - arch::VmField, + arch::{VmField, DEFAULT_BLOCK_SIZE}, system::memory::{online::TracingMemory, MemoryController}, }; @@ -15,57 +13,41 @@ mod cuda; #[cfg(feature = "cuda")] pub use cuda::*; -/// A dummy testing chip that will add unconstrained messages into the [MemoryBus]. -/// Stores a log of raw messages to send/receive to the [MemoryBus]. -/// -/// It will create a [air::MemoryDummyAir] to add messages to MemoryBus. +/// A dummy testing chip that sends/receives unconstrained messages on the [MemoryBus]. +/// All memory accesses use `DEFAULT_BLOCK_SIZE`. pub struct MemoryTester { - /// Map from `block_size` to [MemoryDummyChip] of that block size - pub chip_for_block: HashMap>, + pub(crate) chip: MemoryDummyChip, pub memory: TracingMemory, pub(super) controller: MemoryController, } impl MemoryTester { pub fn new(controller: MemoryController, memory: TracingMemory) -> Self { - let bus = controller.memory_bus; - let mut chip_for_block = HashMap::new(); - for log_block_size in 0..6 { - let block_size = 1 << log_block_size; - let chip = MemoryDummyChip::new(MemoryDummyAir::new(bus, block_size)); - chip_for_block.insert(block_size, chip); - } + let chip = MemoryDummyChip::new(MemoryDummyAir::new(controller.memory_bus)); Self { - chip_for_block, + chip, memory, controller, } } pub fn read(&mut self, addr_space: usize, ptr: usize) -> [F; N] { + const { assert!(N == DEFAULT_BLOCK_SIZE) }; let memory = &mut self.memory; let t = memory.timestamp(); - // TODO: this could be improved if we added a TracingMemory::get_f function let (t_prev, data) = unsafe { memory.read::(addr_space as u32, ptr as u32) }; let data = data.map(F::from_u8); - self.chip_for_block.get_mut(&N).unwrap().receive( - addr_space as u32, - ptr as u32, - &data, - t_prev, - ); - self.chip_for_block - .get_mut(&N) - .unwrap() - .send(addr_space as u32, ptr as u32, &data, t); + self.chip + .receive(addr_space as u32, ptr as u32, &data, t_prev); + self.chip.send(addr_space as u32, ptr as u32, &data, t); data } pub fn write(&mut self, addr_space: usize, ptr: usize, data: [F; N]) { + const { assert!(N == DEFAULT_BLOCK_SIZE) }; let memory = &mut self.memory; let t = memory.timestamp(); - // TODO: this could be improved if we added a TracingMemory::write_f function let (t_prev, data_prev) = unsafe { memory.write::( addr_space as u32, @@ -74,16 +56,9 @@ impl MemoryTester { ) }; let data_prev = data_prev.map(F::from_u8); - self.chip_for_block.get_mut(&N).unwrap().receive( - addr_space as u32, - ptr as u32, - &data_prev, - t_prev, - ); - self.chip_for_block - .get_mut(&N) - .unwrap() - .send(addr_space as u32, ptr as u32, &data, t); + self.chip + .receive(addr_space as u32, ptr as u32, &data_prev, t_prev); + self.chip.send(addr_space as u32, ptr as u32, &data, t); } } diff --git a/crates/vm/src/arch/testing/mod.rs b/crates/vm/src/arch/testing/mod.rs index 5293a0275a..c66cdfbe3c 100644 --- a/crates/vm/src/arch/testing/mod.rs +++ b/crates/vm/src/arch/testing/mod.rs @@ -78,9 +78,6 @@ pub trait TestBuilder { initial_pc: u32, ); - fn write_cell(&mut self, address_space: usize, pointer: usize, value: F); - fn read_cell(&mut self, address_space: usize, pointer: usize) -> F; - fn write(&mut self, address_space: usize, pointer: usize, value: [F; N]); fn read(&mut self, address_space: usize, pointer: usize) -> [F; N]; diff --git a/crates/vm/src/system/memory/controller/mod.rs b/crates/vm/src/system/memory/controller/mod.rs index 044b761438..e408ba72a4 100644 --- a/crates/vm/src/system/memory/controller/mod.rs +++ b/crates/vm/src/system/memory/controller/mod.rs @@ -25,7 +25,7 @@ use crate::{ dimensions::MemoryDimensions, merkle::MemoryMerkleChip, offline_checker::{MemoryBaseAuxCols, MemoryBridge, MemoryBus, AUX_LEN}, - persistent::PersistentBoundaryChip, + persistent::{group_touched_memory_by_chunk, PersistentBoundaryChip}, }, poseidon2::Poseidon2PeripheryChip, TouchedMemory, @@ -188,27 +188,22 @@ impl MemoryController { // Rechunk DEFAULT_BLOCK_SIZE blocks into CHUNK-sized blocks for merkle_chip // Note: Equipartition key is (addr_space, ptr) where ptr is the starting pointer - let final_memory_values: Equipartition = { - use std::collections::BTreeMap; - let mut chunk_map: BTreeMap<(u32, u32), [F; CHUNK]> = BTreeMap::new(); - for ((addr_space, ptr), ts_values) in final_memory { - // Align to CHUNK boundary to get the chunk's starting pointer - let chunk_ptr = (ptr / CHUNK as u32) * CHUNK as u32; - let block_idx_in_chunk = - ((ptr % CHUNK as u32) / DEFAULT_BLOCK_SIZE as u32) as usize; - let entry = chunk_map.entry((addr_space, chunk_ptr)).or_insert_with(|| { - // Initialize with values from initial memory - std::array::from_fn(|i| unsafe { + let final_memory_values: Equipartition = + group_touched_memory_by_chunk(&final_memory) + .into_iter() + .map(|((addr_space, chunk_label), blocks)| { + let chunk_ptr = chunk_label * CHUNK as u32; + let mut values = std::array::from_fn(|i| unsafe { initial_memory.get_f::(addr_space, chunk_ptr + i as u32) - }) - }); - // Copy values for this block - for (i, val) in ts_values.values.into_iter().enumerate() { - entry[block_idx_in_chunk * DEFAULT_BLOCK_SIZE + i] = val; - } - } - chunk_map - }; + }); + for (block_idx, _, block_values) in blocks { + for (i, val) in block_values.into_iter().enumerate() { + values[block_idx * DEFAULT_BLOCK_SIZE + i] = val; + } + } + ((addr_space, chunk_ptr), values) + }) + .collect(); merkle_chip.finalize(initial_memory, &final_memory_values, hasher.as_ref()); vec![ diff --git a/crates/vm/src/system/memory/merkle/tests/mod.rs b/crates/vm/src/system/memory/merkle/tests/mod.rs index e2d604e90b..033a4b4238 100644 --- a/crates/vm/src/system/memory/merkle/tests/mod.rs +++ b/crates/vm/src/system/memory/merkle/tests/mod.rs @@ -191,17 +191,14 @@ fn random_test( vec![ AddressSpaceHostConfig { num_cells: 0, - block_size: 0, layout: MemoryCellType::Null, }, AddressSpaceHostConfig { num_cells: CHUNK << height, - block_size: 1, layout: MemoryCellType::F { size: 4 }, }, AddressSpaceHostConfig { num_cells: CHUNK << height, - block_size: 1, layout: MemoryCellType::F { size: 4 }, }, ], @@ -283,17 +280,14 @@ fn expand_test_no_accesses() { vec![ AddressSpaceHostConfig { num_cells: 0, - block_size: 0, layout: MemoryCellType::Null, }, AddressSpaceHostConfig { num_cells: CHUNK << height, - block_size: 1, layout: MemoryCellType::F { size: 4 }, }, AddressSpaceHostConfig { num_cells: CHUNK << height, - block_size: 1, layout: MemoryCellType::F { size: 4 }, }, ], @@ -331,17 +325,14 @@ fn expand_test_negative() { vec![ AddressSpaceHostConfig { num_cells: 0, - block_size: 0, layout: MemoryCellType::Null, }, AddressSpaceHostConfig { num_cells: CHUNK << height, - block_size: 1, layout: MemoryCellType::F { size: 4 }, }, AddressSpaceHostConfig { num_cells: CHUNK << height, - block_size: 1, layout: MemoryCellType::F { size: 4 }, }, ], diff --git a/crates/vm/src/system/memory/online.rs b/crates/vm/src/system/memory/online.rs index 77e9b4eae6..6b460e3ae5 100644 --- a/crates/vm/src/system/memory/online.rs +++ b/crates/vm/src/system/memory/online.rs @@ -1,24 +1,16 @@ use std::{array::from_fn, fmt::Debug}; use getset::Getters; -use itertools::zip_eq; use openvm_instructions::exe::SparseMemoryImage; use openvm_stark_backend::{ p3_field::{Field, PrimeField32}, p3_maybe_rayon::prelude::*, - p3_util::log2_strict_usize, }; use tracing::instrument; use crate::{ - arch::{ - AddressSpaceHostConfig, AddressSpaceHostLayout, MemoryConfig, DEFAULT_BLOCK_SIZE, - MAX_CELL_BYTE_SIZE, - }, - system::{ - memory::{MemoryAddress, TimestampedEquipartition, TimestampedValues}, - TouchedMemory, - }, + arch::{AddressSpaceHostConfig, AddressSpaceHostLayout, MemoryConfig, DEFAULT_BLOCK_SIZE}, + system::{memory::TimestampedValues, TouchedMemory}, }; mod basic; @@ -382,12 +374,9 @@ pub struct TracingMemory { /// The underlying data memory, with memory cells typed by address space: see [AddressMap]. #[getset(get = "pub")] pub data: GuestMemory, - /// Maps (addr_space, ptr / block_size[addr_space]) → timestamp of last access. - /// A value of 0 means the slot has never been accessed. + /// Maps `(addr_space, ptr / DEFAULT_BLOCK_SIZE)` to the latest access timestamp. + /// A value of 0 means the 4-cell touched-memory slot has never been accessed. pub(super) meta: Vec>, - /// For each `addr_space`, the block size for memory accesses. All memory accesses in - /// `addr_space` must be aligned to this block size. - pub block_size: Vec, } impl TracingMemory { @@ -398,19 +387,15 @@ impl TracingMemory { /// Constructor from pre-existing memory image. pub fn from_image(image: GuestMemory) -> Self { - let (meta, block_size): (Vec<_>, Vec<_>) = - zip_eq(image.memory.get_memory(), &image.memory.config) - .map(|(mem, addr_sp)| { - let num_cells = mem.size() / addr_sp.layout.size(); - let block_size = addr_sp.block_size; - let total_metadata_len = num_cells.div_ceil(block_size); - (PagedVec::new(total_metadata_len), block_size as u32) - }) - .unzip(); + let meta = image + .memory + .config + .iter() + .map(|config| PagedVec::new(config.num_cells.div_ceil(DEFAULT_BLOCK_SIZE))) + .collect(); Self { data: image, meta, - block_size, timestamp: INITIAL_TIMESTAMP + 1, } } @@ -419,7 +404,10 @@ impl TracingMemory { fn assert_valid_access(&self, block_size: usize, addr_space: u32, ptr: u32) { debug_assert_ne!(addr_space, 0); debug_assert!(block_size.is_power_of_two()); - debug_assert_eq!(block_size, self.block_size[addr_space as usize] as usize); + debug_assert_eq!( + block_size, DEFAULT_BLOCK_SIZE, + "TracingMemory only supports {DEFAULT_BLOCK_SIZE}-cell accesses; got {block_size}" + ); assert_eq!( ptr % block_size as u32, 0, @@ -427,13 +415,11 @@ impl TracingMemory { ); } - /// Returns the previous access timestamp and updates metadata for this access. - /// Each read/write accesses exactly one metadata slot since callers always use - /// BLOCK_SIZE == block_size[addr_space]. + /// Returns the previous access timestamp and updates the metadata slot. + /// Block size is always `DEFAULT_BLOCK_SIZE`, so this is a single-slot read/write. #[inline(always)] fn prev_access_time(&mut self, address_space: usize, pointer: usize) -> u32 { - let bs = self.block_size[address_space] as usize; - let idx = pointer / bs; + let idx = pointer / DEFAULT_BLOCK_SIZE; // SAFETY: address_space is validated during instruction decoding let meta_page = unsafe { self.meta.get_unchecked_mut(address_space) }; let prev = meta_page.get(idx); @@ -447,7 +433,8 @@ impl TracingMemory { /// # Safety /// - `T` must be `repr(C)` or `repr(transparent)` and match the cell type for `address_space`. /// - `address_space` must be valid. - /// - `BLOCK_SIZE` must equal the address space's block size. + /// - `BLOCK_SIZE` is measured in memory cells and is tracked in fixed `DEFAULT_BLOCK_SIZE` + /// touched-memory slots. #[inline(always)] pub unsafe fn read( &mut self, @@ -470,7 +457,8 @@ impl TracingMemory { /// # Safety /// - `T` must be `repr(C)` or `repr(transparent)` and match the cell type for `address_space`. /// - `address_space` must be valid. - /// - `BLOCK_SIZE` must equal the address space's block size. + /// - `BLOCK_SIZE` is measured in memory cells and is tracked in fixed `DEFAULT_BLOCK_SIZE` + /// touched-memory slots. #[inline(always)] pub unsafe fn write( &mut self, @@ -505,23 +493,22 @@ impl TracingMemory { /// Finalize the boundary and merkle chips. #[instrument(name = "memory_finalize", skip_all)] pub fn finalize(&mut self) -> TouchedMemory { - let touched_blocks = self.touched_blocks(); - self.touched_blocks_to_equipartition::(touched_blocks) + self.touched_blocks_to_equipartition::(self.touched_blocks()) } - /// Returns the list of all touched blocks (address, timestamp). Sorted by address. + /// Returns the list of all touched blocks (address, timestamp), sorted by address. fn touched_blocks(&self) -> Vec<(Address, u32)> { - assert_eq!(self.meta.len(), self.block_size.len()); - self.meta + assert_eq!(self.meta.len(), self.data.memory.config.len()); + let mut touched_blocks: Vec<_> = self + .meta .par_iter() - .zip(self.block_size.par_iter()) .enumerate() - .flat_map(|(addr_space, (meta_page, &bs))| { + .flat_map_iter(|(addr_space, meta_page)| { meta_page .par_iter() .filter_map(move |(idx, timestamp)| { if timestamp > INITIAL_TIMESTAMP { - let ptr = idx as u32 * bs; + let ptr = idx as u32 * DEFAULT_BLOCK_SIZE as u32; Some(((addr_space as u32, ptr), timestamp)) } else { None @@ -529,100 +516,35 @@ impl TracingMemory { }) .collect::>() }) - .collect() + .collect(); + // This sort may not be strictly necessary, but it makes the finalize path independent of + // Rayon ordering. + touched_blocks.sort_unstable_by_key(|(addr, _)| *addr); + touched_blocks } - /// Returns the equipartition of the touched blocks. - fn touched_blocks_to_equipartition( - &mut self, + /// Returns the fixed 4-byte touched memory equipartition. + fn touched_blocks_to_equipartition( + &self, touched_blocks: Vec<((u32, u32), u32)>, - ) -> TimestampedEquipartition { - let mut final_memory = Vec::new(); - + ) -> TouchedMemory { debug_assert!(touched_blocks.is_sorted_by_key(|(addr, _)| addr)); - self.handle_touched_blocks::(&mut final_memory, touched_blocks); - - debug_assert!(final_memory.is_sorted_by_key(|(key, _)| *key)); - final_memory - } - - fn handle_touched_blocks( - &mut self, - final_memory: &mut Vec<((u32, u32), TimestampedValues)>, - touched_blocks: Vec<((u32, u32), u32)>, - ) { - let mut current_values = vec![0u8; MAX_CELL_BYTE_SIZE * CHUNK]; - let mut current_cnt = 0; - let mut current_address = MemoryAddress::new(0, 0); - let mut current_timestamps = vec![0u32; CHUNK]; - for ((addr_space, ptr), timestamp) in touched_blocks { - // SAFETY: addr_space of touched blocks are all in bounds - let addr_space_config = - unsafe { *self.data.memory.config.get_unchecked(addr_space as usize) }; - let block_size = addr_space_config.block_size; - let cell_size = addr_space_config.layout.size(); - debug_assert!(ptr % block_size as u32 == 0); - - assert!( - current_cnt == 0 - || (current_address.address_space == addr_space - && current_address.pointer + current_cnt as u32 == ptr), - "The union of all touched blocks must consist of blocks with sizes divisible by `CHUNK`" - ); - - if current_cnt == 0 { - assert_eq!( - ptr & (CHUNK as u32 - 1), - 0, - "The union of all touched blocks must consist of `CHUNK`-aligned blocks" - ); - current_address = MemoryAddress::new(addr_space, ptr); - } - - // SAFETY: current_cnt / block_size < CHUNK / block_size <= CHUNK - unsafe { - *current_timestamps.get_unchecked_mut(current_cnt / block_size) = timestamp; - } - - for i in 0..block_size as u32 { - let cell_data = unsafe { - self.data.memory.get_u8_slice( - addr_space, - (ptr + i) as usize * cell_size, - cell_size, - ) - }; - current_values[current_cnt * cell_size..current_cnt * cell_size + cell_size] - .copy_from_slice(cell_data); - current_cnt += 1; - if current_cnt == CHUNK { - let timestamp = *current_timestamps[..CHUNK / block_size] - .iter() - .max() - .unwrap(); - final_memory.push(( - (current_address.address_space, current_address.pointer), - TimestampedValues { - timestamp, - values: from_fn(|i| unsafe { - addr_space_config.layout.to_field( - ¤t_values[i * cell_size..i * cell_size + cell_size], - ) - }), - }, - )); - current_address.pointer += current_cnt as u32; - current_cnt = 0; - } - } - } - assert_eq!(current_cnt, 0, "The union of all touched blocks must consist of blocks with sizes divisible by `CHUNK`"); - } - - pub fn block_size_bits(&self) -> Vec { - self.block_size - .iter() - .map(|&x| log2_strict_usize(x as usize) as u8) + touched_blocks + .into_par_iter() + .map(|((addr_space, ptr), timestamp)| { + let addr_space_config = &self.data.memory.config[addr_space as usize]; + let cell_size = addr_space_config.layout.size(); + let values = from_fn(|i| unsafe { + addr_space_config + .layout + .to_field(self.data.memory.get_u8_slice( + addr_space, + (ptr as usize + i) * cell_size, + cell_size, + )) + }); + ((addr_space, ptr), TimestampedValues { timestamp, values }) + }) .collect() } } diff --git a/crates/vm/src/system/memory/persistent.rs b/crates/vm/src/system/memory/persistent.rs index 721977cd08..5911f8002f 100644 --- a/crates/vm/src/system/memory/persistent.rs +++ b/crates/vm/src/system/memory/persistent.rs @@ -163,6 +163,35 @@ pub struct FinalTouchedLabel { final_timestamps: [u32; BLOCKS_PER_CHUNK], } +type BlockInfo = (usize, u32, [F; DEFAULT_BLOCK_SIZE]); // (block_idx, timestamp, values) +type EnrichedEntry = ((u32, u32), BlockInfo); // (chunk_key, block_info) +pub(crate) type ChunkedTouchedMemory = Vec<((u32, u32), Vec>)>; + +pub(crate) fn group_touched_memory_by_chunk( + final_memory: &TimestampedEquipartition, +) -> ChunkedTouchedMemory { + let mut enriched: Vec> = final_memory + .par_iter() + .map(|&((addr_space, ptr), ts_values)| { + let chunk_label = ptr / CHUNK as u32; + let block_idx = ((ptr % CHUNK as u32) / DEFAULT_BLOCK_SIZE as u32) as usize; + let key = (addr_space, chunk_label); + let block_info = (block_idx, ts_values.timestamp, ts_values.values); + (key, block_info) + }) + .collect(); + enriched.sort_unstable_by_key(|(key, _)| *key); + + enriched + .chunk_by(|a, b| a.0 == b.0) + .map(|group| { + let key = group[0].0; + let blocks = group.iter().map(|&(_, info)| info).collect(); + (key, blocks) + }) + .collect() +} + impl Default for TouchedLabels { fn default() -> Self { Self::Running(FxHashSet::default()) @@ -218,6 +247,9 @@ impl PersistentBoundaryChip { } pub fn touch_range(&mut self, address_space: u32, pointer: u32, len: u32) { + if len == 0 { + return; + } let start_label = pointer / CHUNK as u32; let end_label = (pointer + len - 1) / CHUNK as u32; for label in start_label..=end_label { @@ -241,30 +273,7 @@ impl PersistentBoundaryChip { ) where H: Hasher + Sync + for<'a> SerialReceiver<&'a [F]>, { - type BlockInfo = (usize, u32, [F; DEFAULT_BLOCK_SIZE]); // (block_idx, timestamp, values) - type EnrichedEntry = ((u32, u32), BlockInfo); // (chunk_key, block_info) - - let enriched: Vec> = final_memory - .par_iter() - .map(|&((addr_space, ptr), ts_values)| { - let chunk_label = ptr / CHUNK as u32; - let block_idx = ((ptr % CHUNK as u32) / DEFAULT_BLOCK_SIZE as u32) as usize; - let key = (addr_space, chunk_label); - let block_info = (block_idx, ts_values.timestamp, ts_values.values); - (key, block_info) - }) - .collect(); - - let chunk_groups: Vec<_> = enriched - .chunk_by(|a, b| a.0 == b.0) - .map(|group| { - let key = group[0].0; - let blocks: Vec> = group.iter().map(|&(_, info)| info).collect(); - (key, blocks) - }) - .collect(); - - let final_touched_labels: Vec<_> = chunk_groups + let final_touched_labels: Vec<_> = group_touched_memory_by_chunk(final_memory) .into_par_iter() .map(|((addr_space, chunk_label), blocks)| { let chunk_ptr = chunk_label * CHUNK as u32; diff --git a/crates/vm/src/system/memory/tests.rs b/crates/vm/src/system/memory/tests.rs index ebe9d739f1..ccee9ca266 100644 --- a/crates/vm/src/system/memory/tests.rs +++ b/crates/vm/src/system/memory/tests.rs @@ -7,7 +7,7 @@ use test_case::test_case; use crate::arch::{ testing::{TestBuilder, VmChipTestBuilder}, - MemoryConfig, + MemoryConfig, DEFAULT_BLOCK_SIZE, }; type F = BabyBear; @@ -19,43 +19,16 @@ fn test_memory_write_by_tester(tester: &mut impl TestBuilder, its: usize) { // and intersecting/overlapping blocks, // by limiting the space of valid pointers. let max_ptr = 20; - let aligns = [4, 4, 4]; let value_bounds = [256, 256, 256]; for _ in 0..its { - let addr_sp = rng.random_range(1..=aligns.len()); - let align: usize = aligns[addr_sp - 1]; + let addr_sp = rng.random_range(1..=value_bounds.len()); let value_bound: u32 = value_bounds[addr_sp - 1]; - let ptr = rng.random_range(0..max_ptr / align) * align; - // Accesses use the address space minimum block size. - let log_len = align.trailing_zeros(); - match log_len { - 0 => tester.write::<1>( - addr_sp, - ptr, - array::from_fn(|_| F::from_u32(rng.random_range(0..value_bound))), - ), - 1 => tester.write::<2>( - addr_sp, - ptr, - array::from_fn(|_| F::from_u32(rng.random_range(0..value_bound))), - ), - 2 => tester.write::<4>( - addr_sp, - ptr, - array::from_fn(|_| F::from_u32(rng.random_range(0..value_bound))), - ), - 3 => tester.write::<8>( - addr_sp, - ptr, - array::from_fn(|_| F::from_u32(rng.random_range(0..value_bound))), - ), - 4 => tester.write::<16>( - addr_sp, - ptr, - array::from_fn(|_| F::from_u32(rng.random_range(0..value_bound))), - ), - _ => unreachable!(), - } + let ptr = rng.random_range(0..max_ptr / DEFAULT_BLOCK_SIZE) * DEFAULT_BLOCK_SIZE; + tester.write::( + addr_sp, + ptr, + array::from_fn(|_| F::from_u32(rng.random_range(0..value_bound))), + ); } } diff --git a/extensions/rv32im/circuit/src/adapters/deferral.rs b/extensions/rv32im/circuit/src/adapters/deferral.rs index 79f5552115..010dc4aa02 100644 --- a/extensions/rv32im/circuit/src/adapters/deferral.rs +++ b/extensions/rv32im/circuit/src/adapters/deferral.rs @@ -14,7 +14,7 @@ where F: PrimeField32, { // SAFETY: - // - address space `DEFERRAL_AS` will always have cell type `F` and minimum alignment of `1` + // - address space `DEFERRAL_AS` has cell type `F` with `DEFAULT_BLOCK_SIZE`-aligned accesses unsafe { memory.read::(DEFERRAL_AS, ptr) } } @@ -39,7 +39,7 @@ where F: PrimeField32, { // SAFETY: - // - address space `DEFERRAL_AS` will always have cell type `F` and minimum alignment of `1` + // - address space `DEFERRAL_AS` has cell type `F` with `DEFAULT_BLOCK_SIZE`-aligned accesses unsafe { memory.write::(DEFERRAL_AS, ptr, data) } } @@ -104,7 +104,7 @@ where F: PrimeField32, { // SAFETY: - // - address space `DEFERRAL_AS` has cell type `F` and block_size of `DEFAULT_BLOCK_SIZE` + // - address space `DEFERRAL_AS` has cell type `F` with `DEFAULT_BLOCK_SIZE`-aligned accesses unsafe { memory.read::(DEFERRAL_AS, ptr) } } @@ -118,7 +118,7 @@ where F: PrimeField32, { // SAFETY: - // - address space `DEFERRAL_AS` has cell type `F` and block_size of `DEFAULT_BLOCK_SIZE` + // - address space `DEFERRAL_AS` has cell type `F` with `DEFAULT_BLOCK_SIZE`-aligned accesses unsafe { memory.write::(DEFERRAL_AS, ptr, vals) } } diff --git a/extensions/rv32im/circuit/src/adapters/mod.rs b/extensions/rv32im/circuit/src/adapters/mod.rs index dd3512787a..ecacf1e29f 100644 --- a/extensions/rv32im/circuit/src/adapters/mod.rs +++ b/extensions/rv32im/circuit/src/adapters/mod.rs @@ -71,7 +71,7 @@ pub fn memory_read(memory: &GuestMemory, address_space: u32, ptr // SAFETY: // - address spaces `RV32_REGISTER_AS`, `RV32_MEMORY_AS`, `PUBLIC_VALUES_AS` have cell type `u8` - // and block_size of `DEFAULT_BLOCK_SIZE` + // and use the fixed 4-byte VM memory access granularity unsafe { memory.read::(address_space, ptr) } } @@ -90,7 +90,7 @@ pub fn memory_write( // SAFETY: // - address spaces `RV32_REGISTER_AS`, `RV32_MEMORY_AS`, `PUBLIC_VALUES_AS` have cell type `u8` - // and block_size of `DEFAULT_BLOCK_SIZE` + // and use the fixed 4-byte VM memory access granularity unsafe { memory.write::(address_space, ptr, data) } } @@ -111,7 +111,7 @@ pub fn timed_read( // SAFETY: // - address spaces `RV32_REGISTER_AS`, `RV32_MEMORY_AS`, `PUBLIC_VALUES_AS` have cell type `u8` - // and block_size of `DEFAULT_BLOCK_SIZE` + // and use the fixed 4-byte VM memory access granularity unsafe { memory.read::(address_space, ptr) } } @@ -130,7 +130,7 @@ pub fn timed_write( // SAFETY: // - address spaces `RV32_REGISTER_AS`, `RV32_MEMORY_AS`, `PUBLIC_VALUES_AS` have cell type `u8` - // and block_size of `DEFAULT_BLOCK_SIZE` + // and use the fixed 4-byte VM memory access granularity unsafe { memory.write::(address_space, ptr, data) } } diff --git a/extensions/rv32im/circuit/src/base_alu/tests.rs b/extensions/rv32im/circuit/src/base_alu/tests.rs index 0b7a2e64dc..b5a392d392 100644 --- a/extensions/rv32im/circuit/src/base_alu/tests.rs +++ b/extensions/rv32im/circuit/src/base_alu/tests.rs @@ -160,7 +160,7 @@ fn rand_rv32_alu_test(opcode: BaseAluOpcode, num_ops: usize) { // TODO(AG): make a more meaningful test for memory accesses tester.write(2, 1024, [F::ONE; 4]); tester.write(2, 1028, [F::ONE; 4]); - // Use DEFAULT_BLOCK_SIZE-aligned accesses matching the minimum block size + // Use fixed DEFAULT_BLOCK_SIZE-aligned accesses. let sm1 = tester.read(2, 1024); let sm2 = tester.read(2, 1028); assert_eq!(sm1, [F::ONE; 4]); diff --git a/extensions/rv32im/circuit/src/common/mod.rs b/extensions/rv32im/circuit/src/common/mod.rs index 3de6ac5ed4..3a6d091a6c 100644 --- a/extensions/rv32im/circuit/src/common/mod.rs +++ b/extensions/rv32im/circuit/src/common/mod.rs @@ -9,9 +9,9 @@ mod aot { use openvm_circuit::{ arch::{ execution_mode::{metered::memory_ctx::MemoryCtx, MeteredCtx}, - AotError, SystemConfig, VmExecState, ADDR_SPACE_OFFSET, DEFAULT_BLOCK_SIZE, + AotError, SystemConfig, VmExecState, ADDR_SPACE_OFFSET, }, - system::memory::online::GuestMemory, + system::memory::{online::GuestMemory, CHUNK}, }; /// This is DIRTY because PAGE_BITS is a generic parameter of E2 context. const DEFAULT_PAGE_BITS: usize = 6; @@ -166,29 +166,29 @@ mod aot { // // For a specific RV32 instruction, the variables can be treated as constants at AOT compilation time: // Inputs: - // - `chunk`: always 8(CHUNK) because we only support when continuation is enabled. + // - `chunk`: always CHUNK (8), the merkle leaf size. // - `address_space`: always a constant because it is derived from an Instruction // - `size`: RV32 instruction always read 4 bytes(in the AIR level). // - `self.memory_dimensions.address_height`: known at AOT compilation time because it is derived from the memory configuration. // Inside the function body: - // - `num_blocks`: `(size + self.chunk - 1) >> self.chunk_bits = (4 + 8 - 1) >> 3 = 1` + // - `num_blocks`: `(size + chunk - 1) >> chunk_bits = (4 + 8 - 1) >> 3 = 1` // - `as_offset = (addr_space - ADDR_SPACE_OFFSET) as u64) << self.address_height)`: constant because `address_space` and `address_height` constant - // - `start_chunk_id`: `ptr >> self.chunk_bits` - // - `start_block_id`: `start_chunk_id + as_offset` + // - `chunk_idx`: `ptr >> chunk_bits` + // - `start_block_id`: `chunk_idx + as_offset` // - `end_block_id`: `start_block_id + num_blocks = start_block_id +1` // - `start_page_id`: `start_block_id >> PAGE_BITS` // - `end_page_id`: ((end_block_id - 1) >> PAGE_BITS) + 1 = start_block_id >> PAGE_BITS + 1; // // Therefore the loop only iterates once for `page_id = start_page_id`. - let chunk_bits = DEFAULT_BLOCK_SIZE.ilog2(); + let chunk_bits = CHUNK.ilog2(); let as_offset = ((address_space - ADDR_SPACE_OFFSET) as u64) << (config.memory_config.memory_dimensions().address_height); let mut asm_str = String::new(); - // `start_chunk_id`: `ptr >> self.chunk_bits` + // `chunk_idx`: `ptr >> chunk_bits` asm_str += &format!(" shr {ptr_reg}, {chunk_bits}\n"); - // `start_block_id`: `start_chunk_id + as_offset` + // `start_block_id`: `chunk_idx + as_offset` asm_str += &format!(" add {ptr_reg}, {as_offset}\n"); // `start_page_id`: `start_block_id >> PAGE_BITS` // NOTE: This is DIRTY because PAGE_BITS is a generic parameter of E2 context. diff --git a/extensions/rv32im/circuit/src/loadstore/tests.rs b/extensions/rv32im/circuit/src/loadstore/tests.rs index 3b3be8b9ca..e7849a19e8 100644 --- a/extensions/rv32im/circuit/src/loadstore/tests.rs +++ b/extensions/rv32im/circuit/src/loadstore/tests.rs @@ -216,7 +216,7 @@ fn rand_loadstore_test(opcode: Rv32LoadStoreOpcode, num_ops: usize) { if [STOREW, STOREB, STOREH].contains(&opcode) { mem_config.addr_spaces[PUBLIC_VALUES_AS as usize].num_cells = 1 << 29; } - // Use custom memory config so initial block size matches the 4-byte alignment. + // Use a large register/public-values space for random access coverage. let mut tester = VmChipTestBuilder::from_config(mem_config); let mut harness = create_harness(&mut tester); @@ -268,7 +268,7 @@ fn run_negative_loadstore_test( if [STOREW, STOREB, STOREH].contains(&opcode) { mem_config.addr_spaces[PUBLIC_VALUES_AS as usize].num_cells = 1 << 29; } - // Use custom memory config so the min block size matches alignment without needing adapters. + // Use a large register/public-values space for random access coverage. let mut tester = VmChipTestBuilder::from_config(mem_config); let mut harness = create_harness(&mut tester); From 26448504f7982aa539550102ec076bcb5628d521 Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Thu, 19 Mar 2026 18:57:06 +0100 Subject: [PATCH 42/78] fix: rebase artifacts --- extensions/deferral/circuit/src/adapters.rs | 12 +- .../rv32im/circuit/src/adapters/deferral.rs | 199 ------------------ .../rv32im/circuit/src/adapters/loadstore.rs | 2 +- .../rv32im/circuit/src/loadstore/aot.rs | 3 +- .../rv32im/circuit/src/loadstore/execution.rs | 2 +- 5 files changed, 9 insertions(+), 209 deletions(-) delete mode 100644 extensions/rv32im/circuit/src/adapters/deferral.rs diff --git a/extensions/deferral/circuit/src/adapters.rs b/extensions/deferral/circuit/src/adapters.rs index bbd497981b..71433e2e72 100644 --- a/extensions/deferral/circuit/src/adapters.rs +++ b/extensions/deferral/circuit/src/adapters.rs @@ -8,7 +8,7 @@ where F: PrimeField32, { // SAFETY: - // - address space `DEFERRAL_AS` will always have cell type `F` and minimum alignment of `1` + // - address space `DEFERRAL_AS` has cell type `F` unsafe { memory.read::(DEFERRAL_AS, ptr) } } @@ -18,7 +18,7 @@ where F: PrimeField32, { // SAFETY: - // - address space `DEFERRAL_AS` will always have cell type `F` and minimum alignment of `1` + // - address space `DEFERRAL_AS` has cell type `F` unsafe { memory.write::(DEFERRAL_AS, ptr, data) } } @@ -34,8 +34,8 @@ where F: PrimeField32, { // SAFETY: - // - deferral address space will always have cell type `F` and minimum alignment of `1` - unsafe { memory.read::(DEFERRAL_AS, ptr) } + // - deferral address space has cell type `F` + unsafe { memory.read::(DEFERRAL_AS, ptr) } } #[inline(always)] @@ -48,8 +48,8 @@ where F: PrimeField32, { // SAFETY: - // - deferral address space will always have cell type `F` and minimum alignment of `1` - unsafe { memory.write::(DEFERRAL_AS, ptr, vals) } + // - deferral address space has cell type `F` + unsafe { memory.write::(DEFERRAL_AS, ptr, vals) } } /// Reads register value at `ptr` from memory and records the previous timestamp. diff --git a/extensions/rv32im/circuit/src/adapters/deferral.rs b/extensions/rv32im/circuit/src/adapters/deferral.rs deleted file mode 100644 index 010dc4aa02..0000000000 --- a/extensions/rv32im/circuit/src/adapters/deferral.rs +++ /dev/null @@ -1,199 +0,0 @@ -use openvm_circuit::{ - arch::{execution_mode::ExecutionCtxTrait, VmStateMut}, - system::memory::{ - offline_checker::MemoryWriteAuxCols, - online::{GuestMemory, TracingMemory}, - }, -}; -use openvm_instructions::{riscv::RV32_IMM_AS, DEFERRAL_AS}; -use openvm_stark_backend::p3_field::PrimeField32; - -#[inline(always)] -pub fn memory_read_deferral(memory: &GuestMemory, ptr: u32) -> [F; N] -where - F: PrimeField32, -{ - // SAFETY: - // - address space `DEFERRAL_AS` has cell type `F` with `DEFAULT_BLOCK_SIZE`-aligned accesses - unsafe { memory.read::(DEFERRAL_AS, ptr) } -} - -#[inline(always)] -pub fn memory_read_or_imm_deferral(memory: &GuestMemory, addr_space: u32, ptr_or_imm: F) -> F -where - F: PrimeField32, -{ - debug_assert!(addr_space == RV32_IMM_AS || addr_space == DEFERRAL_AS); - - if addr_space == DEFERRAL_AS { - let [result]: [F; 1] = memory_read_deferral(memory, ptr_or_imm.as_canonical_u32()); - result - } else { - ptr_or_imm - } -} - -#[inline(always)] -pub fn memory_write_deferral(memory: &mut GuestMemory, ptr: u32, data: [F; N]) -where - F: PrimeField32, -{ - // SAFETY: - // - address space `DEFERRAL_AS` has cell type `F` with `DEFAULT_BLOCK_SIZE`-aligned accesses - unsafe { memory.write::(DEFERRAL_AS, ptr, data) } -} - -#[inline(always)] -pub fn memory_read_deferral_from_state( - state: &mut VmStateMut, - ptr: u32, -) -> [F; N] -where - F: PrimeField32, - Ctx: ExecutionCtxTrait, -{ - state.ctx.on_memory_operation(DEFERRAL_AS, ptr, N as u32); - - memory_read_deferral(state.memory, ptr) -} - -#[inline(always)] -pub fn memory_read_or_imm_deferral_from_state( - state: &mut VmStateMut, - addr_space: u32, - ptr_or_imm: F, -) -> F -where - F: PrimeField32, - Ctx: ExecutionCtxTrait, -{ - debug_assert!(addr_space == RV32_IMM_AS || addr_space == DEFERRAL_AS); - - if addr_space == DEFERRAL_AS { - let [result]: [F; 1] = - memory_read_deferral_from_state(state, ptr_or_imm.as_canonical_u32()); - result - } else { - ptr_or_imm - } -} - -#[inline(always)] -pub fn memory_write_deferral_from_state( - state: &mut VmStateMut, - ptr: u32, - data: [F; N], -) where - F: PrimeField32, - Ctx: ExecutionCtxTrait, -{ - state.ctx.on_memory_operation(DEFERRAL_AS, ptr, N as u32); - - memory_write_deferral(state.memory, ptr, data) -} - -/// Atomic read operation which increments the timestamp by 1. -/// Returns `(t_prev, [ptr:BLOCK_SIZE]_4)` where `t_prev` is the timestamp of the last memory -/// access. -#[inline(always)] -pub fn timed_read_deferral( - memory: &mut TracingMemory, - ptr: u32, -) -> (u32, [F; BLOCK_SIZE]) -where - F: PrimeField32, -{ - // SAFETY: - // - address space `DEFERRAL_AS` has cell type `F` with `DEFAULT_BLOCK_SIZE`-aligned accesses - unsafe { memory.read::(DEFERRAL_AS, ptr) } -} - -#[inline(always)] -pub fn timed_write_deferral( - memory: &mut TracingMemory, - ptr: u32, - vals: [F; BLOCK_SIZE], -) -> (u32, [F; BLOCK_SIZE]) -where - F: PrimeField32, -{ - // SAFETY: - // - address space `DEFERRAL_AS` has cell type `F` with `DEFAULT_BLOCK_SIZE`-aligned accesses - unsafe { memory.write::(DEFERRAL_AS, ptr, vals) } -} - -/// Reads register value at `ptr` from memory and records the previous timestamp. -/// Reads are only done from address space [DEFERRAL_AS]. -#[inline(always)] -pub fn tracing_read_deferral( - memory: &mut TracingMemory, - ptr: u32, - prev_timestamp: &mut u32, -) -> [F; BLOCK_SIZE] -where - F: PrimeField32, -{ - let (t_prev, data) = timed_read_deferral(memory, ptr); - *prev_timestamp = t_prev; - data -} - -/// Writes `ptr, vals` into memory and records the previous timestamp and data. -/// Writes are only done to address space [DEFERRAL_AS]. -#[inline(always)] -pub fn tracing_write_deferral( - memory: &mut TracingMemory, - ptr: u32, - vals: [F; BLOCK_SIZE], - prev_timestamp: &mut u32, - prev_data: &mut [F; BLOCK_SIZE], -) where - F: PrimeField32, -{ - let (t_prev, data_prev) = timed_write_deferral(memory, ptr, vals); - *prev_timestamp = t_prev; - *prev_data = data_prev; -} - -/// Writes `ptr, vals` into memory and records the previous timestamp and data. -#[inline(always)] -pub fn tracing_write_deferral_inplace( - memory: &mut TracingMemory, - ptr: u32, - vals: [F; BLOCK_SIZE], - cols: &mut MemoryWriteAuxCols, -) where - F: PrimeField32, -{ - let (t_prev, data_prev) = timed_write_deferral(memory, ptr, vals); - cols.base.set_prev(F::from_u32(t_prev)); - cols.prev_data = data_prev; -} - -/// Reads value at `_ptr` from memory and records the previous timestamp. -/// If the read is an immediate, the previous timestamp will be set to `u32::MAX`. -#[inline(always)] -pub fn tracing_read_or_imm_deferral( - memory: &mut TracingMemory, - addr_space: F, - ptr_or_imm: F, - prev_timestamp: &mut u32, -) -> F -where - F: PrimeField32, -{ - debug_assert!( - addr_space == F::ZERO || addr_space == F::from_u32(DEFERRAL_AS), - "addr_space={addr_space} is not valid" - ); - - if addr_space == F::ZERO { - *prev_timestamp = u32::MAX; - memory.increment_timestamp(); - ptr_or_imm - } else { - let data: [F; 1] = - tracing_read_deferral(memory, ptr_or_imm.as_canonical_u32(), prev_timestamp); - data[0] - } -} diff --git a/extensions/rv32im/circuit/src/adapters/loadstore.rs b/extensions/rv32im/circuit/src/adapters/loadstore.rs index e7fac1552b..0747ab1df3 100644 --- a/extensions/rv32im/circuit/src/adapters/loadstore.rs +++ b/extensions/rv32im/circuit/src/adapters/loadstore.rs @@ -27,7 +27,7 @@ use openvm_instructions::{ instruction::Instruction, program::DEFAULT_PC_STEP, riscv::{RV32_IMM_AS, RV32_MEMORY_AS, RV32_REGISTER_AS}, - LocalOpcode, + LocalOpcode, DEFERRAL_AS, }; use openvm_rv32im_transpiler::Rv32LoadStoreOpcode::{self, *}; use openvm_stark_backend::{ diff --git a/extensions/rv32im/circuit/src/loadstore/aot.rs b/extensions/rv32im/circuit/src/loadstore/aot.rs index 8376a11c25..a0a564493c 100644 --- a/extensions/rv32im/circuit/src/loadstore/aot.rs +++ b/extensions/rv32im/circuit/src/loadstore/aot.rs @@ -5,7 +5,7 @@ use openvm_circuit::arch::{ use openvm_instructions::{ instruction::Instruction, riscv::{RV32_IMM_AS, RV32_REGISTER_AS}, - LocalOpcode, + LocalOpcode, DEFERRAL_AS, }; use openvm_rv32im_transpiler::Rv32LoadStoreOpcode; use openvm_stark_backend::p3_field::PrimeField32; @@ -63,7 +63,6 @@ fn is_aot_supported_impl( true } - // arguments of `update_boundary_merkle_heights_f`: // address_space: u32, // pc: u32, diff --git a/extensions/rv32im/circuit/src/loadstore/execution.rs b/extensions/rv32im/circuit/src/loadstore/execution.rs index e1f1284f8f..f1a9d39319 100644 --- a/extensions/rv32im/circuit/src/loadstore/execution.rs +++ b/extensions/rv32im/circuit/src/loadstore/execution.rs @@ -13,7 +13,7 @@ use openvm_instructions::{ instruction::Instruction, program::DEFAULT_PC_STEP, riscv::{RV32_IMM_AS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS}, - LocalOpcode, + LocalOpcode, DEFERRAL_AS, }; use openvm_rv32im_transpiler::Rv32LoadStoreOpcode::{self, *}; use openvm_stark_backend::p3_field::PrimeField32; From 7f7f610ba9f15978f653e6ac7844e1f54cab134a Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Thu, 19 Mar 2026 19:33:23 +0100 Subject: [PATCH 43/78] fix: implement constant_trace_height for DeferralCircuitCountChip --- extensions/deferral/circuit/src/count/trace.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/extensions/deferral/circuit/src/count/trace.rs b/extensions/deferral/circuit/src/count/trace.rs index c0396bd6dd..8ff6675186 100644 --- a/extensions/deferral/circuit/src/count/trace.rs +++ b/extensions/deferral/circuit/src/count/trace.rs @@ -38,6 +38,10 @@ impl Chip> for DeferralCircuitCo where Val: PrimeCharacteristicRing, { + fn constant_trace_height(&self) -> Option { + Some(next_power_of_two_or_zero(self.count.len())) + } + fn generate_proving_ctx(&self, _: RA) -> AirProvingContext> { let width = DeferralCircuitCountCols::::width(); let height = next_power_of_two_or_zero(self.count.len()); From 7a91450a201fb889bd0b3a5e259da510e2ddd5be Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Thu, 19 Mar 2026 23:48:44 +0100 Subject: [PATCH 44/78] chore: fix lock file --- Cargo.lock | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 4ae38ce59d..133eab6bd2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1399,9 +1399,9 @@ dependencies = [ [[package]] name = "aws-lc-rs" -version = "1.16.2" +version = "1.16.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a054912289d18629dc78375ba2c3726a3afe3ff71b4edba9dedfca0e3446d1fc" +checksum = "94bffc006df10ac2a68c83692d734a465f8ee6c5b384d8545a636f81d858f4bf" dependencies = [ "aws-lc-sys", "zeroize", @@ -1409,9 +1409,9 @@ dependencies = [ [[package]] name = "aws-lc-sys" -version = "0.39.0" +version = "0.38.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1fa7e52a4c5c547c741610a2c6f123f3881e409b714cd27e6798ef020c514f0a" +checksum = "4321e568ed89bb5a7d291a7f37997c2c0df89809d7b6d12062c81ddb54aa782e" dependencies = [ "cc", "cmake", From 6638d93952eb761a1410c396504b568ab41b387b Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Fri, 20 Mar 2026 13:16:58 +0100 Subject: [PATCH 45/78] fix: limit cuda threads in xorin --- extensions/keccak256/circuit/cuda/src/xorin.cu | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/extensions/keccak256/circuit/cuda/src/xorin.cu b/extensions/keccak256/circuit/cuda/src/xorin.cu index b169102e76..cda46a845d 100644 --- a/extensions/keccak256/circuit/cuda/src/xorin.cu +++ b/extensions/keccak256/circuit/cuda/src/xorin.cu @@ -187,7 +187,7 @@ extern "C" int _xorin_tracegen( assert(height >= d_records.len()); assert(width == sizeof(XorinVmCols)); - auto [grid, block] = kernel_launch_params(height); + auto [grid, block] = kernel_launch_params(height, 512); xorin_tracegen<<>>( d_trace, From fb8a5c163d83f49e685f952b5699fd9a9293e54c Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Sun, 22 Mar 2026 18:50:27 +0100 Subject: [PATCH 46/78] chore: bump aws crates --- Cargo.lock | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 133eab6bd2..4ae38ce59d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1399,9 +1399,9 @@ dependencies = [ [[package]] name = "aws-lc-rs" -version = "1.16.1" +version = "1.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "94bffc006df10ac2a68c83692d734a465f8ee6c5b384d8545a636f81d858f4bf" +checksum = "a054912289d18629dc78375ba2c3726a3afe3ff71b4edba9dedfca0e3446d1fc" dependencies = [ "aws-lc-sys", "zeroize", @@ -1409,9 +1409,9 @@ dependencies = [ [[package]] name = "aws-lc-sys" -version = "0.38.0" +version = "0.39.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4321e568ed89bb5a7d291a7f37997c2c0df89809d7b6d12062c81ddb54aa782e" +checksum = "1fa7e52a4c5c547c741610a2c6f123f3881e409b714cd27e6798ef020c514f0a" dependencies = [ "cc", "cmake", From 8fb4c5a8046c1b4c23b99e1232e6db43d8c0bc62 Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Mon, 23 Mar 2026 17:06:48 +0100 Subject: [PATCH 47/78] perf(v2-rc.1): optimize keccakf cuda kernel (#2599) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ### Summary Redesign `keccakf_perm_tracegen` as a two-phase kernel to fix a memory coalescing bottleneck. The original single-kernel design assigned 24 consecutive rows per thread, causing adjacent warp threads to store 24 rows apart in the column-major trace — wasting ~97% of memory bandwidth. The new design separates state computation (thread-per-permutation) from trace writing (thread-per-row), so adjacent threads write adjacent rows and stores coalesce. **~58x kernel speedup** (9.2s → 160ms total GPU time across 138 invocations on the reth benchmark). ### Changes **`p3_keccakf.cuh`:** - Add `apply_round_in_place`: keccak-f round function (theta/rho/pi/chi/iota) without trace column writes, used by phase 1 - Add `RHO_PI_CYCLE_IDX`/`RHO_PI_CYCLE_ROT` constants for in-place rho/pi permutation cycle - `generate_trace_row_for_round`: replace `state_b[5][5]` with in-place rho/pi, replace `state_c_prime[5]` with scalar `d`, in-place chi with 2 temps per row **`keccakf_perm.cu`:** - Phase 1 kernel (`keccakf_perm_phase1`): one thread per permutation computes all 24 keccak-f rounds, stores 25-lane u64 round-input state to a scratch buffer (~4.8 KB/permutation) - Phase 2 kernel (`keccakf_perm_phase2`): one thread per row loads round state from scratch, writes all 2634 trace columns with coalesced stores - Remove `initial_state[5][5]`, `fill_zero`, and prev-row global readback - Unify valid/dummy code paths (dummy rows use zero-initialized state) **`cuda_abi.rs` / `mod.rs`:** - Plumb scratch buffer (`DeviceBuffer`) through FFI to the CUDA kernels - Scratch overhead is ~1.9% of the trace matrix (4800 bytes/perm for scratch vs 252864 bytes/perm for the trace), freed after tracegen completes [Reth benchmark comparison](https://github.com/axiom-crypto/openvm-eth/actions/runs/23360309931) Resolves INT-6958 --- .../circuit/cuda/include/p3_keccakf.cuh | 118 +++++++--- .../circuit/cuda/src/keccakf_perm.cu | 214 ++++++++---------- .../keccak256/circuit/src/cuda/cuda_abi.rs | 5 + extensions/keccak256/circuit/src/cuda/mod.rs | 6 + 4 files changed, 195 insertions(+), 148 deletions(-) diff --git a/extensions/keccak256/circuit/cuda/include/p3_keccakf.cuh b/extensions/keccak256/circuit/cuda/include/p3_keccakf.cuh index 77bf925d0f..699d69a38f 100644 --- a/extensions/keccak256/circuit/cuda/include/p3_keccakf.cuh +++ b/extensions/keccak256/circuit/cuda/include/p3_keccakf.cuh @@ -25,11 +25,24 @@ __device__ __constant__ inline uint64_t RC[NUM_ROUNDS] = { 0x8000000000008002ULL, 0x8000000000000080ULL, 0x000000000000800AULL, 0x800000008000000AULL, 0x8000000080008081ULL, 0x8000000000008080ULL, 0x0000000080000001ULL, 0x8000000080008008ULL }; + +// In-place rho/pi permutation cycle (24 elements, flat index y*5+x). +// Follows (x,y) -> (y, 2x+3y mod 5); (0,0) is a fixed point. +// cycle[i] receives its value from cycle[(i+1) % 24] with the listed rotation. +__device__ __constant__ inline int RHO_PI_CYCLE_IDX[24] = {1, 6, 9, 22, 14, 20, 2, 12, + 13, 19, 23, 15, 4, 24, 21, 8, + 16, 5, 3, 18, 17, 11, 7, 10}; +__device__ __constant__ inline uint8_t RHO_PI_CYCLE_ROT[24] = {44, 20, 61, 39, 18, 62, 43, 25, + 8, 56, 41, 27, 14, 2, 55, 45, + 36, 28, 21, 15, 10, 6, 3, 1}; + } // namespace keccak256 namespace p3_keccak_air { using keccak256::R; using keccak256::RC; +using keccak256::RHO_PI_CYCLE_IDX; +using keccak256::RHO_PI_CYCLE_ROT; // Plonky3 KeccakCols structure (from p3_keccak_air) // Must match exactly for trace compatibility @@ -69,6 +82,54 @@ template struct KeccakCols { inline constexpr size_t NUM_KECCAK_COLS = sizeof(KeccakCols); +// Apply one keccak-f round in-place without trace writes. +// Used by phase 1 to advance state between rounds. +static __device__ __noinline__ void apply_round_in_place( + uint32_t round, + uint64_t current_state[5][5] +) { + // Theta: C[x] = xor(A[x, 0], A[x, 1], A[x, 2], A[x, 3], A[x, 4]) + uint64_t state_c[5]; +#pragma unroll 5 + for (auto x = 0; x < 5; x++) { + state_c[x] = current_state[0][x] ^ current_state[1][x] ^ current_state[2][x] ^ + current_state[3][x] ^ current_state[4][x]; + } + + // Theta: A'[x, y] = A[x, y] ^ D[x], where D[x] = C[x-1] ^ ROT(C[x+1], 1) + for (int x = 0; x < 5; x++) { + uint64_t d = state_c[(x + 4) % 5] ^ ROTL64(state_c[(x + 1) % 5], 1); +#pragma unroll 5 + for (int y = 0; y < 5; y++) { + current_state[y][x] ^= d; + } + } + + // Rho/Pi: B[x, y] = ROT(A'[x, y], R[x][y]) via 24-element permutation cycle + uint64_t *flat_state = ¤t_state[0][0]; + uint64_t temp = ROTL64(flat_state[RHO_PI_CYCLE_IDX[0]], RHO_PI_CYCLE_ROT[23]); +#pragma unroll 1 + for (int i = 0; i < 23; i++) { + flat_state[RHO_PI_CYCLE_IDX[i]] = + ROTL64(flat_state[RHO_PI_CYCLE_IDX[i + 1]], RHO_PI_CYCLE_ROT[i]); + } + flat_state[RHO_PI_CYCLE_IDX[23]] = temp; + + // Chi: A''[x, y] = B[x, y] ^ (~B[x+1, y] & B[x+2, y]), in-place with 2 temps per row + for (int y = 0; y < 5; y++) { + uint64_t t0 = current_state[y][0]; + uint64_t t1 = current_state[y][1]; + current_state[y][0] = t0 ^ ((~t1) & current_state[y][2]); + current_state[y][1] = t1 ^ ((~current_state[y][2]) & current_state[y][3]); + current_state[y][2] ^= (~current_state[y][3]) & current_state[y][4]; + current_state[y][3] ^= (~current_state[y][4]) & t0; + current_state[y][4] ^= (~t0) & t1; + } + + // Iota: A'''[0, 0] = A''[0, 0] ^ RC[round] + current_state[0][0] ^= RC[round]; +} + // tracegen matching plonky3 // `row` must have first NUM_KECCAK_COLS columns matching KeccakCols static __device__ __noinline__ void generate_trace_row_for_round( @@ -88,45 +149,42 @@ static __device__ __noinline__ void generate_trace_row_for_round( COL_WRITE_BITS(row, KeccakCols, c[x], state_c[x]); } - // Populate C'[x, z] = xor(C[x, z], C[x - 1, z], ROTL1(C[x + 1, z - 1])). - uint64_t state_c_prime[5]; -#pragma unroll 5 - for (auto x = 0; x < 5; x++) { - state_c_prime[x] = state_c[x] ^ state_c[(x + 4) % 5] ^ ROTL64(state_c[(x + 1) % 5], 1); - COL_WRITE_BITS(row, KeccakCols, c_prime[x], state_c_prime[x]); - } - - // Populate A'. To avoid shifting indices, we rewrite - // A'[x, y, z] = xor(A[x, y, z], C[x - 1, z], C[x + 1, z - 1]) - // as - // A'[x, y, z] = xor(A[x, y, z], C[x, z], C'[x, z]). + // Populate C'[x, z] and A'[x, y] using scalar d = C[x-1] ^ ROTL(C[x+1], 1). + // Avoids materializing state_c_prime[5] array (~10 regs saved). for (int x = 0; x < 5; x++) { + uint64_t d = state_c[(x + 4) % 5] ^ ROTL64(state_c[(x + 1) % 5], 1); + COL_WRITE_BITS(row, KeccakCols, c_prime[x], state_c[x] ^ d); + #pragma unroll 5 for (int y = 0; y < 5; y++) { - current_state[y][x] ^= state_c[x] ^ state_c_prime[x]; + current_state[y][x] ^= d; COL_WRITE_BITS(row, KeccakCols, a_prime[y][x], current_state[y][x]); } } - // Rotate the current state to get the B array. - uint64_t state_b[5][5]; - for (auto i = 0; i < 5; i++) { -#pragma unroll 5 - for (auto j = 0; j < 5; j++) { - auto new_i = (i + 3 * j) % 5; - auto new_j = i; - state_b[j][i] = ROTL64(current_state[new_j][new_i], R[new_i][new_j]); - } + // In-place rho/pi using the 24-element permutation cycle. + // Avoids allocating state_b[5][5] (~50 regs saved). + uint64_t *flat_state = ¤t_state[0][0]; + uint64_t temp = ROTL64(flat_state[RHO_PI_CYCLE_IDX[0]], RHO_PI_CYCLE_ROT[23]); + // Prevent unrolling to avoid code bloat and register pressure from 23 simultaneous rotations. +#pragma unroll 1 + for (int i = 0; i < 23; i++) { + flat_state[RHO_PI_CYCLE_IDX[i]] = + ROTL64(flat_state[RHO_PI_CYCLE_IDX[i + 1]], RHO_PI_CYCLE_ROT[i]); } - - // Populate A'' as A''[x, y] = xor(B[x, y], andn(B[x + 1, y], B[x + 2, y])). - for (int i = 0; i < 5; i++) { -#pragma unroll 5 - for (int j = 0; j < 5; j++) { - current_state[i][j] = - state_b[i][j] ^ ((~state_b[i][(j + 1) % 5]) & state_b[i][(j + 2) % 5]); - } + flat_state[RHO_PI_CYCLE_IDX[23]] = temp; + + // Populate A'' = B[x,y] ^ (~B[x+1,y] & B[x+2,y]), in-place chi with 2 temps per row. + for (int y = 0; y < 5; y++) { + uint64_t t0 = current_state[y][0]; + uint64_t t1 = current_state[y][1]; + current_state[y][0] = t0 ^ ((~t1) & current_state[y][2]); + current_state[y][1] = t1 ^ ((~current_state[y][2]) & current_state[y][3]); + current_state[y][2] ^= (~current_state[y][3]) & current_state[y][4]; + current_state[y][3] ^= (~current_state[y][4]) & t0; + current_state[y][4] ^= (~t0) & t1; } + uint16_t *state_limbs = reinterpret_cast(¤t_state[0][0]); COL_WRITE_ARRAY(row, KeccakCols, a_prime_prime, state_limbs); diff --git a/extensions/keccak256/circuit/cuda/src/keccakf_perm.cu b/extensions/keccak256/circuit/cuda/src/keccakf_perm.cu index 4c7dc58ff9..591346ca68 100644 --- a/extensions/keccak256/circuit/cuda/src/keccakf_perm.cu +++ b/extensions/keccak256/circuit/cuda/src/keccakf_perm.cu @@ -19,30 +19,38 @@ using p3_keccak_air::U64_LIMBS; #define KECCAKF_PERM_WRITE(FIELD, VALUE) COL_WRITE_VALUE(row, KeccakfPermCols, FIELD, VALUE) #define KECCAKF_PERM_WRITE_ARRAY(FIELD, VALUES) COL_WRITE_ARRAY(row, KeccakfPermCols, FIELD, VALUES) -// Main kernel for KeccakfPermChip trace generation -// Each thread processes one permutation (24 rows) -__global__ void keccakf_perm_tracegen( - Fp *d_trace, - size_t height, +static constexpr uint32_t KECCAK_STATE_WORDS = 25; + +// Two-phase keccak-f trace generation for coalesced column-major stores. +// Trace layout is trace[col * height + row]; threads writing adjacent rows coalesce. +// +// Phase 1 (1 thread per permutation): +// - runs 24 keccak-f rounds (theta/rho/pi/chi/iota) +// - stores the 25-lane u64 round-input state before each round +// into scratch: d_round_states[perm][round][lane] (~4.8 KB/perm) +// +// Phase 2 (1 thread per row = 1 round of 1 permutation): +// - loads round-input state from scratch +// - recomputes that round to materialize intermediates (c, c', a', a'', ...) +// - writes all 2634 trace columns + +// Phase 1: compute keccak-f, store round-input states to scratch +// each thread processes one permutation (24 rounds) +__global__ void keccakf_perm_phase1( + uint64_t *__restrict__ d_round_states, // [blocks_to_fill][24][25] uint32_t num_records, - uint32_t blocks_to_fill, // = ceil(height / 24) + uint32_t blocks_to_fill, DeviceBufferConstView d_records ) { - uint32_t block_idx = blockIdx.x * blockDim.x + threadIdx.x; - - if (block_idx >= blocks_to_fill) { + uint32_t perm_idx = blockIdx.x * blockDim.x + threadIdx.x; + if (perm_idx >= blocks_to_fill) { return; } - // Initialize state - will be transformed by generate_trace_row_for_round __align__(16) uint64_t current_state[5][5] = {0}; - __align__(16) uint64_t initial_state[5][5] = {0}; - - uint32_t timestamp = 0; - if (block_idx < num_records) { - auto const &rec = d_records[block_idx]; - timestamp = rec.timestamp; + if (perm_idx < num_records) { + auto const &rec = d_records[perm_idx]; // Convert preimage bytes to u64 state with coordinate transposition // generate_trace_row_for_round expects current_state[y][x] = A[x][y] (keccak notation) @@ -57,116 +65,70 @@ __global__ void keccakf_perm_tracegen( val |= static_cast(rec.preimage_buffer_bytes[keccak_offset * 8 + j]) << (j * 8); } - // Store as current_state[y][x] = A[x][y] for generate_trace_row_for_round current_state[y][x] = val; - initial_state[y][x] = val; } } } - // Convert initial state to u16 limbs for preimage columns - uint16_t *initial_state_limbs = reinterpret_cast(initial_state); - - // Calculate how many rows to fill for this block - size_t rows_for_this_block = NUM_ROUNDS; - if (block_idx == blocks_to_fill - 1) { - // Last block might have fewer rows - size_t remaining = height - block_idx * NUM_ROUNDS; - if (remaining < NUM_ROUNDS) { - rows_for_this_block = remaining; + // Store round-input state before each round, then advance + uint64_t *flat = ¤t_state[0][0]; + for (uint32_t round_idx = 0; round_idx < NUM_ROUNDS; round_idx++) { + size_t off = (static_cast(perm_idx) * NUM_ROUNDS + round_idx) * KECCAK_STATE_WORDS; +#pragma unroll + for (uint32_t i = 0; i < KECCAK_STATE_WORDS; i++) { + d_round_states[off + i] = flat[i]; } + p3_keccak_air::apply_round_in_place(round_idx, current_state); } +} - // Generate 24 round rows - for (uint32_t round_idx = 0; round_idx < rows_for_this_block; round_idx++) { - size_t row_idx = block_idx * NUM_ROUNDS + round_idx; - RowSlice row(d_trace + row_idx, height); - - // Fill zero first for safety - row.fill_zero(0, sizeof(KeccakfPermCols)); - - if (block_idx < num_records) { - // Valid record: fill preimage and compute keccak-f trace - - // Fill preimage columns (same for all rounds within a permutation) - COL_WRITE_ARRAY(row, KeccakfPermCols, inner.preimage, initial_state_limbs); - - // Fill 'a' input state - on first round, same as preimage - // On subsequent rounds, copy from previous row's output - if (round_idx == 0) { - COL_WRITE_ARRAY(row, KeccakfPermCols, inner.a, initial_state_limbs); - } else { - // Copy previous round's output to this round's input - // a[y][x] gets a_prime_prime_prime[0][0] for (x,y)=(0,0), else a_prime_prime[y][x] - RowSlice prev_row(d_trace + row_idx - 1, height); - for (int y = 0; y < 5; y++) { - for (int x = 0; x < 5; x++) { - for (int limb = 0; limb < U64_LIMBS; limb++) { - Fp val; - if (x == 0 && y == 0) { - val = prev_row[COL_INDEX( - KeccakfPermCols, inner.a_prime_prime_prime_0_0_limbs[limb] - )]; - } else { - val = prev_row[COL_INDEX( - KeccakfPermCols, inner.a_prime_prime[y][x][limb] - )]; - } - KECCAKF_PERM_WRITE(inner.a[y][x][limb], val); - } - } - } - } +// Phase 2: write column-major trace from cached round states +// Each thread writes one row; adjacent threads write adjacent rows (coalesced) +__global__ void keccakf_perm_phase2( + Fp *__restrict__ d_trace, + size_t height, + uint32_t num_records, + DeviceBufferConstView d_records, + uint64_t const *__restrict__ d_round_states // [blocks_to_fill][24][25] +) { + size_t row_idx = blockIdx.x * blockDim.x + threadIdx.x; + if (row_idx >= height) { + return; + } - // Generate trace row for this round (updates current_state in-place) - p3_keccak_air::generate_trace_row_for_round(row, round_idx, current_state); + uint32_t perm_idx = static_cast(row_idx / NUM_ROUNDS); + uint32_t round_idx = static_cast(row_idx % NUM_ROUNDS); - // Set export flag and timestamp on last round - if (round_idx == NUM_ROUNDS - 1) { - KECCAKF_PERM_WRITE(inner._export, 1); - KECCAKF_PERM_WRITE(timestamp, timestamp); - } else { - KECCAKF_PERM_WRITE(inner._export, 0); - KECCAKF_PERM_WRITE(timestamp, 0); - } - } else { - // Dummy block: generate valid keccak-f trace with zero state, export=0 - // The KeccakAir constraints require all intermediate columns (C, C', A', A'', etc.) - // to be properly computed, so we can't just zero them out. - - // Fill preimage with zeros (already zeroed) - // Fill 'a' input state - if (round_idx == 0) { - // a = preimage = zeros (already zeroed) - } else { - // Copy previous round's output to this round's input - RowSlice prev_row(d_trace + row_idx - 1, height); - for (int y = 0; y < 5; y++) { - for (int x = 0; x < 5; x++) { - for (int limb = 0; limb < U64_LIMBS; limb++) { - Fp val; - if (x == 0 && y == 0) { - val = prev_row[COL_INDEX( - KeccakfPermCols, inner.a_prime_prime_prime_0_0_limbs[limb] - )]; - } else { - val = prev_row[COL_INDEX( - KeccakfPermCols, inner.a_prime_prime[y][x][limb] - )]; - } - KECCAKF_PERM_WRITE(inner.a[y][x][limb], val); - } - } - } - } + // Load round-input state from scratch + __align__(16) uint64_t current_state[5][5]; + size_t off = (static_cast(perm_idx) * NUM_ROUNDS + round_idx) * KECCAK_STATE_WORDS; + uint64_t *flat = ¤t_state[0][0]; +#pragma unroll + for (uint32_t i = 0; i < KECCAK_STATE_WORDS; i++) { + flat[i] = d_round_states[off + i]; + } - // Generate trace row for this round (using current_state which is zero for dummy blocks) - p3_keccak_air::generate_trace_row_for_round(row, round_idx, current_state); + RowSlice row(d_trace + row_idx, height); - // Dummy rows: export must be 0, timestamp = 0 - KECCAKF_PERM_WRITE(inner._export, 0); - KECCAKF_PERM_WRITE(timestamp, 0); - } + // Fill preimage columns (invariant across rounds, read from round 0 of this permutation) + size_t preimage_off = static_cast(perm_idx) * NUM_ROUNDS * KECCAK_STATE_WORDS; + auto const *preimage_limbs = reinterpret_cast(&d_round_states[preimage_off]); + KECCAKF_PERM_WRITE_ARRAY(inner.preimage, preimage_limbs); + + // Fill 'a' input state from current round state + uint16_t *state_limbs = reinterpret_cast(¤t_state[0][0]); + COL_WRITE_ARRAY(row, KeccakfPermCols, inner.a, state_limbs); + + // Generate trace row for this round (writes c, c_prime, a_prime, a_prime_prime, etc.) + p3_keccak_air::generate_trace_row_for_round(row, round_idx, current_state); + + // Set export flag and timestamp on last round of valid records + if (perm_idx < num_records && round_idx == NUM_ROUNDS - 1) { + KECCAKF_PERM_WRITE(inner._export, 1); + KECCAKF_PERM_WRITE(timestamp, d_records[perm_idx].timestamp); + } else { + KECCAKF_PERM_WRITE(inner._export, 0); + KECCAKF_PERM_WRITE(timestamp, 0); } } @@ -178,16 +140,32 @@ extern "C" int _keccakf_perm_tracegen( size_t height, size_t width, DeviceBufferConstView d_records, - size_t num_records + size_t num_records, + uint64_t *d_round_states, + size_t round_state_words ) { assert((height & (height - 1)) == 0); assert(width == sizeof(KeccakfPermCols)); uint32_t blocks_to_fill = div_ceil(height, uint32_t(NUM_ROUNDS)); + assert( + round_state_words >= static_cast(blocks_to_fill) * NUM_ROUNDS * KECCAK_STATE_WORDS + ); + + // Phase 1: compute keccak-f, store round states to scratch + auto [p1_grid, p1_block] = kernel_launch_params(blocks_to_fill, 128); + keccakf_perm_phase1<<>>( + d_round_states, static_cast(num_records), blocks_to_fill, d_records + ); + int result = CHECK_KERNEL(); + if (result != 0) { + return result; + } - auto [grid, block] = kernel_launch_params(blocks_to_fill, 256); - keccakf_perm_tracegen<<>>( - d_trace, height, static_cast(num_records), blocks_to_fill, d_records + // Phase 2: write trace with coalesced stores (one thread per row) + auto [p2_grid, p2_block] = kernel_launch_params(height, 256); + keccakf_perm_phase2<<>>( + d_trace, height, static_cast(num_records), d_records, d_round_states ); return CHECK_KERNEL(); } diff --git a/extensions/keccak256/circuit/src/cuda/cuda_abi.rs b/extensions/keccak256/circuit/src/cuda/cuda_abi.rs index cb6869e014..3755148f4d 100644 --- a/extensions/keccak256/circuit/src/cuda/cuda_abi.rs +++ b/extensions/keccak256/circuit/src/cuda/cuda_abi.rs @@ -110,6 +110,8 @@ pub mod keccakf_perm { width: usize, d_records: DeviceBufferView, num_records: usize, + d_round_states: *mut u64, + round_state_words: usize, ) -> i32; } @@ -120,6 +122,7 @@ pub mod keccakf_perm { height: usize, d_records: &DeviceBuffer, num_records: usize, + d_round_states: &DeviceBuffer, ) -> Result<(), CudaError> { assert!(height.is_power_of_two() || height == 0); CudaError::from_result(_keccakf_perm_tracegen( @@ -128,6 +131,8 @@ pub mod keccakf_perm { d_trace.len() / height, d_records.view(), num_records, + d_round_states.as_mut_ptr(), + d_round_states.len(), )) } } diff --git a/extensions/keccak256/circuit/src/cuda/mod.rs b/extensions/keccak256/circuit/src/cuda/mod.rs index d7dab02914..e0566cebd7 100644 --- a/extensions/keccak256/circuit/src/cuda/mod.rs +++ b/extensions/keccak256/circuit/src/cuda/mod.rs @@ -163,6 +163,11 @@ impl Chip for KeccakfPermChipGpu { let trace_height = next_power_of_two_or_zero(num_records * NUM_ROUNDS); let d_trace = DeviceMatrix::::with_capacity(trace_height, trace_width); + // Scratch buffer for two-phase tracegen: 25 u64 lanes per round per permutation. + // 24 rounds * 25 lanes * 8 bytes = 4800 bytes/perm, vs 24 * 2634 * 4 = 252864 bytes/perm + // for the trace matrix (~1.9% overhead). + let blocks_to_fill = trace_height.div_ceil(NUM_ROUNDS); + let d_round_states = DeviceBuffer::::with_capacity(blocks_to_fill * NUM_ROUNDS * 25); unsafe { cuda_abi::keccakf_perm::tracegen( @@ -170,6 +175,7 @@ impl Chip for KeccakfPermChipGpu { trace_height, &d_records, num_records, + &d_round_states, ) .unwrap(); } From e629b6aa3dc1d1f0a659ed7a402161fbd77b1331 Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Mon, 23 Mar 2026 18:04:05 +0100 Subject: [PATCH 48/78] fix(deferral): remove volatile and MEMORY_OP_SIZE --- extensions/deferral/circuit/src/call/tests.rs | 33 +++++++++---------- .../deferral/circuit/src/output/tests.rs | 22 ++++++------- 2 files changed, 26 insertions(+), 29 deletions(-) diff --git a/extensions/deferral/circuit/src/call/tests.rs b/extensions/deferral/circuit/src/call/tests.rs index 57be70f668..6ca136e07e 100644 --- a/extensions/deferral/circuit/src/call/tests.rs +++ b/extensions/deferral/circuit/src/call/tests.rs @@ -5,7 +5,7 @@ use openvm_circuit::arch::{ testing::{ memory::gen_pointer, TestBuilder, TestChipHarness, VmChipTestBuilder, BITWISE_OP_LOOKUP_BUS, }, - Arena, MatrixRecordArena, MemoryConfig, PreflightExecutor, + Arena, MatrixRecordArena, MemoryConfig, PreflightExecutor, DEFAULT_BLOCK_SIZE, }; use openvm_circuit_primitives::bitwise_op_lookup::{ BitwiseOperationLookupAir, BitwiseOperationLookupBus, BitwiseOperationLookupChip, @@ -50,10 +50,7 @@ use crate::{ deferral_poseidon2_air, deferral_poseidon2_chip, DeferralPoseidon2Air, DeferralPoseidon2Bus, DeferralPoseidon2Chip, }, - utils::{ - byte_commit_to_f, COMMIT_NUM_BYTES, MEMORY_OP_SIZE, OUTPUT_TOTAL_BYTES, - OUTPUT_TOTAL_MEMORY_OPS, - }, + utils::{byte_commit_to_f, COMMIT_NUM_BYTES, OUTPUT_TOTAL_BYTES, OUTPUT_TOTAL_MEMORY_OPS}, DeferralFn, }; @@ -145,10 +142,10 @@ fn set_and_execute_call( RA: Arena, E: PreflightExecutor, { - let rd = gen_pointer(rng, MEMORY_OP_SIZE); - let rs = gen_pointer(rng, MEMORY_OP_SIZE); - let output_ptr = gen_pointer(rng, MEMORY_OP_SIZE); - let input_ptr = gen_pointer(rng, MEMORY_OP_SIZE); + let rd = gen_pointer(rng, DEFAULT_BLOCK_SIZE); + let rs = gen_pointer(rng, DEFAULT_BLOCK_SIZE); + let output_ptr = gen_pointer(rng, DEFAULT_BLOCK_SIZE); + let input_ptr = gen_pointer(rng, DEFAULT_BLOCK_SIZE); let deferral_idx = rng.random_range(0..num_deferrals); let input_commit_f: [F; DIGEST_SIZE] = @@ -175,11 +172,11 @@ fn set_and_execute_call( rs, input_ptr.to_le_bytes().map(F::from_u8), ); - for (chunk_idx, chunk) in input_commit.chunks_exact(MEMORY_OP_SIZE).enumerate() { - let chunk: [u8; MEMORY_OP_SIZE] = chunk.try_into().unwrap(); + for (chunk_idx, chunk) in input_commit.chunks_exact(DEFAULT_BLOCK_SIZE).enumerate() { + let chunk: [u8; DEFAULT_BLOCK_SIZE] = chunk.try_into().unwrap(); tester.write( RV32_MEMORY_AS as usize, - input_ptr + chunk_idx * MEMORY_OP_SIZE, + input_ptr + chunk_idx * DEFAULT_BLOCK_SIZE, chunk.map(F::from_u8), ); } @@ -216,12 +213,12 @@ fn set_and_execute_call( let mut output_key = [0u8; OUTPUT_TOTAL_BYTES]; for chunk_idx in 0..OUTPUT_TOTAL_MEMORY_OPS { - let chunk: [F; MEMORY_OP_SIZE] = tester.read( + let chunk: [F; DEFAULT_BLOCK_SIZE] = tester.read( RV32_MEMORY_AS as usize, - output_ptr + chunk_idx * MEMORY_OP_SIZE, + output_ptr + chunk_idx * DEFAULT_BLOCK_SIZE, ); - for i in 0..MEMORY_OP_SIZE { - output_key[chunk_idx * MEMORY_OP_SIZE + i] = chunk[i].as_canonical_u32() as u8; + for i in 0..DEFAULT_BLOCK_SIZE { + output_key[chunk_idx * DEFAULT_BLOCK_SIZE + i] = chunk[i].as_canonical_u32() as u8; } } let output_commit_expected: [u8; COMMIT_NUM_BYTES] = output_commit.clone().try_into().unwrap(); @@ -372,7 +369,7 @@ fn create_cuda_harness( #[test] fn rand_deferral_call_test() { let mut rng = create_seeded_rng(); - let mut tester = VmChipTestBuilder::::volatile(test_memory_config()); + let mut tester = VmChipTestBuilder::::from_config(test_memory_config()); let CpuHarnessBundle { mut harness, bitwise, @@ -407,7 +404,7 @@ fn rand_deferral_call_test() { #[test] fn test_cuda_rand_deferral_call_tracegen() { let mut rng = create_seeded_rng(); - let mut tester = GpuChipTestBuilder::volatile( + let mut tester = GpuChipTestBuilder::new( test_memory_config(), openvm_circuit::arch::testing::default_var_range_checker_bus(), ) diff --git a/extensions/deferral/circuit/src/output/tests.rs b/extensions/deferral/circuit/src/output/tests.rs index 2c5af69c3d..9deb8d86fe 100644 --- a/extensions/deferral/circuit/src/output/tests.rs +++ b/extensions/deferral/circuit/src/output/tests.rs @@ -5,7 +5,7 @@ use openvm_circuit::arch::{ testing::{ memory::gen_pointer, TestBuilder, TestChipHarness, VmChipTestBuilder, BITWISE_OP_LOOKUP_BUS, }, - Arena, MatrixRecordArena, MemoryConfig, PreflightExecutor, + Arena, MatrixRecordArena, MemoryConfig, PreflightExecutor, DEFAULT_BLOCK_SIZE, }; use openvm_circuit_primitives::bitwise_op_lookup::{ BitwiseOperationLookupAir, BitwiseOperationLookupBus, BitwiseOperationLookupChip, @@ -44,7 +44,7 @@ use crate::{ deferral_poseidon2_air, deferral_poseidon2_chip, DeferralPoseidon2Air, DeferralPoseidon2Bus, DeferralPoseidon2Chip, }, - utils::{combine_output, COMMIT_NUM_BYTES, MEMORY_OP_SIZE, OUTPUT_TOTAL_BYTES}, + utils::{combine_output, COMMIT_NUM_BYTES, OUTPUT_TOTAL_BYTES}, RawDeferralResult, }; @@ -114,11 +114,11 @@ fn write_output_key( input_ptr: usize, output_key: [u8; OUTPUT_TOTAL_BYTES], ) { - for (chunk_idx, chunk) in output_key.chunks_exact(MEMORY_OP_SIZE).enumerate() { - let chunk: [u8; MEMORY_OP_SIZE] = chunk.try_into().unwrap(); + for (chunk_idx, chunk) in output_key.chunks_exact(DEFAULT_BLOCK_SIZE).enumerate() { + let chunk: [u8; DEFAULT_BLOCK_SIZE] = chunk.try_into().unwrap(); tester.write( RV32_MEMORY_AS as usize, - input_ptr + chunk_idx * MEMORY_OP_SIZE, + input_ptr + chunk_idx * DEFAULT_BLOCK_SIZE, chunk.map(F::from_u8), ); } @@ -150,10 +150,10 @@ fn set_and_execute_output( RA: Arena, E: PreflightExecutor, { - let rd = gen_pointer(rng, MEMORY_OP_SIZE); - let rs = gen_pointer(rng, MEMORY_OP_SIZE); - let output_ptr = gen_pointer(rng, MEMORY_OP_SIZE); - let input_ptr = gen_pointer(rng, MEMORY_OP_SIZE); + let rd = gen_pointer(rng, DEFAULT_BLOCK_SIZE); + let rs = gen_pointer(rng, DEFAULT_BLOCK_SIZE); + let output_ptr = gen_pointer(rng, DEFAULT_BLOCK_SIZE); + let input_ptr = gen_pointer(rng, DEFAULT_BLOCK_SIZE); let deferral_idx = rng.random_range(0..num_deferrals); let mut input_commit = [0u8; COMMIT_NUM_BYTES]; @@ -310,7 +310,7 @@ fn create_cuda_harness(tester: &GpuChipTestBuilder, num_deferrals: usize) -> Cud #[test] fn rand_deferral_output_test() { let mut rng = create_seeded_rng(); - let mut tester = VmChipTestBuilder::::volatile(test_memory_config()); + let mut tester = VmChipTestBuilder::::from_config(test_memory_config()); let CpuHarnessBundle { mut harness, bitwise, @@ -345,7 +345,7 @@ fn rand_deferral_output_test() { #[test] fn test_cuda_rand_deferral_output_tracegen() { let mut rng = create_seeded_rng(); - let mut tester = GpuChipTestBuilder::volatile( + let mut tester = GpuChipTestBuilder::new( test_memory_config(), openvm_circuit::arch::testing::default_var_range_checker_bus(), ) From edf2ca9495a010abcc0d164baebf890419d269dc Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Mon, 23 Mar 2026 18:40:44 +0100 Subject: [PATCH 49/78] fix(deferral): read deferral as in block size of 4 in tests --- crates/vm/src/arch/testing/memory/cuda.rs | 10 ++++++-- crates/vm/src/arch/testing/memory/mod.rs | 9 +++++-- extensions/deferral/circuit/src/call/tests.rs | 25 +++++++++++++------ .../deferral/circuit/src/output/tests.rs | 4 +-- 4 files changed, 35 insertions(+), 13 deletions(-) diff --git a/crates/vm/src/arch/testing/memory/cuda.rs b/crates/vm/src/arch/testing/memory/cuda.rs index 9a55f6bd95..d0455bcf9f 100644 --- a/crates/vm/src/arch/testing/memory/cuda.rs +++ b/crates/vm/src/arch/testing/memory/cuda.rs @@ -16,6 +16,7 @@ use openvm_circuit_primitives::{ }; use openvm_cuda_backend::{base::DeviceMatrix, prelude::F, GpuBackend}; use openvm_cuda_common::copy::MemCopyH2D; +use openvm_instructions::DEFERRAL_AS; use openvm_stark_backend::{ p3_air::BaseAir, p3_field::{PrimeCharacteristicRing, PrimeField32}, @@ -73,8 +74,13 @@ impl DeviceMemoryTester { pub fn read(&mut self, addr_space: usize, ptr: usize) -> [F; N] { const { assert!(N == DEFAULT_BLOCK_SIZE) }; let t = self.memory.timestamp(); - let (t_prev, data) = unsafe { self.memory.read::(addr_space as u32, ptr as u32) }; - let data = data.map(F::from_u8); + let (t_prev, data) = if addr_space as u32 == DEFERRAL_AS { + unsafe { self.memory.read::(addr_space as u32, ptr as u32) } + } else { + let (t_prev, data) = + unsafe { self.memory.read::(addr_space as u32, ptr as u32) }; + (t_prev, data.map(F::from_u8)) + }; self.chip .receive(addr_space as u32, ptr as u32, &data, t_prev); self.chip.send(addr_space as u32, ptr as u32, &data, t); diff --git a/crates/vm/src/arch/testing/memory/mod.rs b/crates/vm/src/arch/testing/memory/mod.rs index 95612ddfb9..be7af4ac4f 100644 --- a/crates/vm/src/arch/testing/memory/mod.rs +++ b/crates/vm/src/arch/testing/memory/mod.rs @@ -1,4 +1,5 @@ use air::{MemoryDummyAir, MemoryDummyChip}; +use openvm_instructions::DEFERRAL_AS; use rand::Rng; use crate::{ @@ -35,8 +36,12 @@ impl MemoryTester { const { assert!(N == DEFAULT_BLOCK_SIZE) }; let memory = &mut self.memory; let t = memory.timestamp(); - let (t_prev, data) = unsafe { memory.read::(addr_space as u32, ptr as u32) }; - let data = data.map(F::from_u8); + let (t_prev, data) = if addr_space as u32 == DEFERRAL_AS { + unsafe { memory.read::(addr_space as u32, ptr as u32) } + } else { + let (t_prev, data) = unsafe { memory.read::(addr_space as u32, ptr as u32) }; + (t_prev, data.map(F::from_u8)) + }; self.chip .receive(addr_space as u32, ptr as u32, &data, t_prev); self.chip.send(addr_space as u32, ptr as u32, &data, t); diff --git a/extensions/deferral/circuit/src/call/tests.rs b/extensions/deferral/circuit/src/call/tests.rs index 6ca136e07e..f71f54f3e1 100644 --- a/extensions/deferral/circuit/src/call/tests.rs +++ b/extensions/deferral/circuit/src/call/tests.rs @@ -50,7 +50,10 @@ use crate::{ deferral_poseidon2_air, deferral_poseidon2_chip, DeferralPoseidon2Air, DeferralPoseidon2Bus, DeferralPoseidon2Chip, }, - utils::{byte_commit_to_f, COMMIT_NUM_BYTES, OUTPUT_TOTAL_BYTES, OUTPUT_TOTAL_MEMORY_OPS}, + utils::{ + byte_commit_to_f, join_memory_ops, COMMIT_NUM_BYTES, DIGEST_MEMORY_OPS, OUTPUT_TOTAL_BYTES, + OUTPUT_TOTAL_MEMORY_OPS, + }, DeferralFn, }; @@ -128,6 +131,14 @@ fn deferral_fns(num_deferrals: usize) -> Vec> { .collect() } +fn read_deferral_digest(tester: &mut impl TestBuilder, ptr: usize) -> [F; DIGEST_SIZE] { + let chunks = from_fn(|chunk_idx| { + tester + .read::(DEFERRAL_AS as usize, ptr + chunk_idx * DEFAULT_BLOCK_SIZE) + }); + join_memory_ops::<_, DIGEST_SIZE, DIGEST_MEMORY_OPS>(chunks) +} + fn init_streams(tester: &mut impl TestBuilder, num_deferrals: usize) { tester.streams_mut().deferrals = vec![DeferralState::new(vec![]); num_deferrals]; } @@ -165,12 +176,12 @@ fn set_and_execute_call( tester.write( RV32_REGISTER_AS as usize, rd, - output_ptr.to_le_bytes().map(F::from_u8), + (output_ptr as u32).to_le_bytes().map(F::from_u8), ); tester.write( RV32_REGISTER_AS as usize, rs, - input_ptr.to_le_bytes().map(F::from_u8), + (input_ptr as u32).to_le_bytes().map(F::from_u8), ); for (chunk_idx, chunk) in input_commit.chunks_exact(DEFAULT_BLOCK_SIZE).enumerate() { let chunk: [u8; DEFAULT_BLOCK_SIZE] = chunk.try_into().unwrap(); @@ -183,8 +194,8 @@ fn set_and_execute_call( let input_acc_ptr = 2 * deferral_idx * DIGEST_SIZE; let output_acc_ptr = input_acc_ptr + DIGEST_SIZE; - let old_input_acc: [F; DIGEST_SIZE] = tester.read(DEFERRAL_AS as usize, input_acc_ptr); - let old_output_acc: [F; DIGEST_SIZE] = tester.read(DEFERRAL_AS as usize, output_acc_ptr); + let old_input_acc = read_deferral_digest(tester, input_acc_ptr); + let old_output_acc = read_deferral_digest(tester, output_acc_ptr); tester.execute( executor, @@ -238,8 +249,8 @@ fn set_and_execute_call( let output_f_commit = byte_commit_to_f(&output_commit_expected.map(F::from_u8)); let expected_new_input_acc = poseidon2_chip.perm(&old_input_acc, &input_f_commit, true); let expected_new_output_acc = poseidon2_chip.perm(&old_output_acc, &output_f_commit, true); - let new_input_acc: [F; DIGEST_SIZE] = tester.read(DEFERRAL_AS as usize, input_acc_ptr); - let new_output_acc: [F; DIGEST_SIZE] = tester.read(DEFERRAL_AS as usize, output_acc_ptr); + let new_input_acc = read_deferral_digest(tester, input_acc_ptr); + let new_output_acc = read_deferral_digest(tester, output_acc_ptr); assert_eq!( new_input_acc, expected_new_input_acc, "input accumulator mismatch" diff --git a/extensions/deferral/circuit/src/output/tests.rs b/extensions/deferral/circuit/src/output/tests.rs index 9deb8d86fe..7791b49332 100644 --- a/extensions/deferral/circuit/src/output/tests.rs +++ b/extensions/deferral/circuit/src/output/tests.rs @@ -174,12 +174,12 @@ fn set_and_execute_output( tester.write( RV32_REGISTER_AS as usize, rd, - output_ptr.to_le_bytes().map(F::from_u8), + (output_ptr as u32).to_le_bytes().map(F::from_u8), ); tester.write( RV32_REGISTER_AS as usize, rs, - input_ptr.to_le_bytes().map(F::from_u8), + (input_ptr as u32).to_le_bytes().map(F::from_u8), ); let output_commit: [u8; COMMIT_NUM_BYTES] = result.output_commit.try_into().unwrap(); From ab7d7c6d91d59fbc64cb28b75e1c19e13558a7b3 Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Mon, 23 Mar 2026 18:10:32 +0000 Subject: [PATCH 50/78] fix: add constant_trace_height for gpu deferral count chip --- extensions/deferral/circuit/src/count/cuda.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/extensions/deferral/circuit/src/count/cuda.rs b/extensions/deferral/circuit/src/count/cuda.rs index df0306a3eb..227e787946 100644 --- a/extensions/deferral/circuit/src/count/cuda.rs +++ b/extensions/deferral/circuit/src/count/cuda.rs @@ -16,6 +16,10 @@ pub struct DeferralCircuitCountChipGpu { } impl Chip for DeferralCircuitCountChipGpu { + fn constant_trace_height(&self) -> Option { + Some(next_power_of_two_or_zero(self.num_deferral_circuits)) + } + fn generate_proving_ctx(&self, _: DenseRecordArena) -> AirProvingContext { if self.num_deferral_circuits == 0 { return AirProvingContext::simple_no_pis(DeviceMatrix::dummy()); From 68c8663616cc7349e13965e5a008f3657af4c6e1 Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Mon, 23 Mar 2026 20:58:51 +0100 Subject: [PATCH 51/78] fix(v2-rc.1): load deferral as elems as felts in memory kernels (#2607) Restore DEFERRAL_AS field-element handling in CUDA memory kernels (boundary.cu, inventory.cu). Without this, initial memory values are misread as individual bytes instead of 4-byte Montgomery-encoded field elements, breaking LogUp bus interactions --- crates/vm/cuda/src/system/boundary.cu | 17 +++++++++++++--- crates/vm/cuda/src/system/inventory.cu | 28 ++++++++++++++++++-------- 2 files changed, 34 insertions(+), 11 deletions(-) diff --git a/crates/vm/cuda/src/system/boundary.cu b/crates/vm/cuda/src/system/boundary.cu index 81ed9fdc56..dcb6e7553e 100644 --- a/crates/vm/cuda/src/system/boundary.cu +++ b/crates/vm/cuda/src/system/boundary.cu @@ -5,6 +5,8 @@ inline constexpr size_t PERSISTENT_CHUNK = 8; inline constexpr size_t BLOCKS_PER_CHUNK = 2; +// TODO better address space handling +inline constexpr uint32_t DEFERRAL_AS = 4; template struct BoundaryRecord { uint32_t address_space; @@ -43,10 +45,19 @@ __global__ void cukernel_persistent_boundary_tracegen( COL_WRITE_VALUE(row, PersistentBoundaryCols, address_space, record.address_space); COL_WRITE_VALUE(row, PersistentBoundaryCols, leaf_label, record.ptr / PERSISTENT_CHUNK); if (row_idx % 2 == 0) { - // TODO better address space handling FpArray<8> init_values; - if (initial_mem[record.address_space - 1]) { - init_values = FpArray<8>::from_u8_array(initial_mem[record.address_space - 1] + record.ptr); + uint32_t addr_space_idx = record.address_space - 1; + if (initial_mem[addr_space_idx]) { + init_values = + record.address_space == DEFERRAL_AS + ? FpArray<8>::from_raw_array( + reinterpret_cast( + initial_mem[addr_space_idx] + ) + record.ptr + ) + : FpArray<8>::from_u8_array( + initial_mem[addr_space_idx] + record.ptr + ); } else { #pragma unroll for (int i = 0; i < 8; ++i) { diff --git a/crates/vm/cuda/src/system/inventory.cu b/crates/vm/cuda/src/system/inventory.cu index 003125b6e8..6081a1209e 100644 --- a/crates/vm/cuda/src/system/inventory.cu +++ b/crates/vm/cuda/src/system/inventory.cu @@ -17,8 +17,10 @@ template struct MemoryInventoryRecord { uint32_t values[CHUNK]; // Montgomery-encoded Fp values (Fp::asRaw()) }; -const uint32_t IN_BLOCK_SIZE = 4; -const uint32_t OUT_BLOCK_SIZE = 8; +inline constexpr uint32_t IN_BLOCK_SIZE = 4; +inline constexpr uint32_t OUT_BLOCK_SIZE = 8; +// TODO better address space handling +inline constexpr uint32_t DEFERRAL_AS = 4; using InRec = MemoryInventoryRecord; using OutRec = MemoryInventoryRecord; @@ -40,6 +42,8 @@ __device__ inline bool same_output_block( /// field elements. The output values must be in Montgomery form because they are /// stored directly into MemoryInventoryRecord.values, which boundary.cu later /// reads via FpArray::from_raw_array (a raw copy that assumes Montgomery encoding). +/// DEFERRAL_AS stores field elements (4 bytes per cell, already Montgomery-encoded). +/// Other address spaces store u8 cells (1 byte per cell). __device__ inline void read_initial_chunk( uint32_t *out_values, // Montgomery-encoded Fp values uint8_t const *const *initial_mem, @@ -55,12 +59,20 @@ __device__ inline void read_initial_chunk( } return; } - size_t byte_offset = static_cast(chunk_ptr); - #pragma unroll - for (int i = 0; i < OUT_BLOCK_SIZE; ++i) { - size_t off = byte_offset + static_cast(i); - // Convert u8 value to field element in Montgomery form. - out_values[i] = Fp(mem[off]).asRaw(); + if (address_space == DEFERRAL_AS) { + // F-type cells: 4 bytes per cell, already raw Montgomery u32 + uint32_t const *cells = reinterpret_cast(mem) + chunk_ptr; + #pragma unroll + for (int i = 0; i < OUT_BLOCK_SIZE; ++i) { + out_values[i] = cells[i]; + } + } else { + // U8 cells: 1 byte per cell, convert to Montgomery form + size_t byte_offset = static_cast(chunk_ptr); + #pragma unroll + for (int i = 0; i < OUT_BLOCK_SIZE; ++i) { + out_values[i] = Fp(mem[byte_offset + i]).asRaw(); + } } } From 1c3ffcf90add1c8ac248ca1699fed91144e5be72 Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Wed, 25 Mar 2026 21:09:46 +0100 Subject: [PATCH 52/78] chore: rebase fixes --- Cargo.lock | 8 -------- benchmarks/execute/Cargo.toml | 2 -- benchmarks/execute/benches/execute.rs | 9 ++------- benchmarks/utils/Cargo.toml | 15 --------------- 4 files changed, 2 insertions(+), 32 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 4ae38ce59d..b54f5c68f1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6102,7 +6102,6 @@ dependencies = [ "openvm-bigint-circuit", "openvm-bigint-transpiler", "openvm-circuit", - "openvm-continuations", "openvm-ecc-circuit", "openvm-ecc-transpiler", "openvm-keccak256-circuit", @@ -6112,7 +6111,6 @@ dependencies = [ "openvm-pairing-transpiler", "openvm-rv32im-circuit", "openvm-rv32im-transpiler", - "openvm-sdk", "openvm-sha2-circuit", "openvm-sha2-transpiler", "openvm-stark-sdk", @@ -6149,17 +6147,11 @@ dependencies = [ name = "openvm-benchmarks-utils" version = "2.0.0-alpha" dependencies = [ - "bitcode", "cargo_metadata", "clap", "eyre", "openvm-build", - "openvm-circuit", - "openvm-continuations", - "openvm-sdk", - "openvm-stark-sdk", "openvm-transpiler", - "serde", "tempfile", "tracing", "tracing-subscriber 0.3.23", diff --git a/benchmarks/execute/Cargo.toml b/benchmarks/execute/Cargo.toml index a5a812c34e..d20997c385 100644 --- a/benchmarks/execute/Cargo.toml +++ b/benchmarks/execute/Cargo.toml @@ -27,8 +27,6 @@ openvm-rv32im-circuit.workspace = true openvm-rv32im-transpiler.workspace = true openvm-sha2-circuit.workspace = true openvm-sha2-transpiler.workspace = true -openvm-continuations = { workspace = true } -openvm-sdk = { workspace = true } clap.workspace = true eyre.workspace = true diff --git a/benchmarks/execute/benches/execute.rs b/benchmarks/execute/benches/execute.rs index a23bcf3fcf..a3838e9d23 100644 --- a/benchmarks/execute/benches/execute.rs +++ b/benchmarks/execute/benches/execute.rs @@ -39,22 +39,17 @@ use openvm_rv32im_circuit::{ use openvm_rv32im_transpiler::{ Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension, }; -use openvm_sdk::{ - commit::VmCommittedExe, - config::{AggregationConfig, DEFAULT_NUM_CHILDREN_INTERNAL, DEFAULT_NUM_CHILDREN_LEAF}, -}; use openvm_sha2_circuit::{Sha2, Sha2CpuProverExt, Sha2Executor}; use openvm_sha2_transpiler::Sha2TranspilerExtension; use openvm_stark_sdk::{ config::baby_bear_poseidon2::BabyBearPoseidon2CpuEngine, openvm_cpu_backend::{CpuBackend, CpuDevice}, openvm_stark_backend::{ - self, keygen::types::MultiStarkProvingKey, proof::Proof, - prover::DeviceDataTransporter, StarkEngine, StarkProtocolConfig, SystemParams, Val, + self, keygen::types::MultiStarkProvingKey, prover::DeviceDataTransporter, StarkEngine, + StarkProtocolConfig, SystemParams, Val, }, p3_baby_bear::BabyBear, }; -use openvm_cpu_backend::{CpuBackend, CpuDevice}; use openvm_transpiler::{transpiler::Transpiler, FromElf}; use serde::{Deserialize, Serialize}; diff --git a/benchmarks/utils/Cargo.toml b/benchmarks/utils/Cargo.toml index 8a613e7008..49df7d7309 100644 --- a/benchmarks/utils/Cargo.toml +++ b/benchmarks/utils/Cargo.toml @@ -17,27 +17,12 @@ eyre.workspace = true tempfile.workspace = true tracing.workspace = true tracing-subscriber.workspace = true -bitcode = { workspace = true, optional = true } -serde = { workspace = true, optional = true } - -openvm-circuit = { workspace = true, optional = true } -openvm-continuations = { workspace = true, optional = true } -openvm-sdk = { workspace = true, optional = true } -openvm-stark-sdk = { workspace = true, optional = true } [dev-dependencies] [features] default = [] build-elfs = [] -generate-fixtures = [ - "dep:bitcode", - "dep:serde", - "dep:openvm-circuit", - "dep:openvm-continuations", - "dep:openvm-sdk", - "dep:openvm-stark-sdk", -] [[bin]] name = "build-elfs" From 0d3cf06ee97195a30ff16639194ac37249e5ce08 Mon Sep 17 00:00:00 2001 From: Ayush Shukla Date: Wed, 25 Mar 2026 23:35:28 +0100 Subject: [PATCH 53/78] chore(v2-rc.1): update benchmark guest programs (#2623) - update guest programs to use new sha interface - update elfs resolves int-5895 --- .../elf/openvm-bubblesort-program.elf | Bin 65692 -> 59052 bytes .../elf/openvm-ecdsa-recover-key-program.elf | Bin 170272 -> 171228 bytes ...penvm-factorial-iterative-u256-program.elf | Bin 65404 -> 58664 bytes .../openvm-fibonacci-iterative-program.elf | Bin 63984 -> 56908 bytes .../openvm-fibonacci-recursive-program.elf | Bin 64148 -> 57076 bytes .../elf/openvm-keccak256-program.elf | Bin 61004 -> 61940 bytes .../elf/openvm-keccak256-iter-program.elf | Bin 60092 -> 60840 bytes .../elf/openvm-kitchen-sink-program.elf | Bin 95332 -> 99444 bytes benchmarks/guest/kitchen-sink/openvm.toml | 2 +- benchmarks/guest/kitchen-sink/src/main.rs | 4 ++-- .../guest/regex/elf/openvm-regex-program.elf | Bin 664372 -> 665252 bytes benchmarks/guest/revm_snailtracer/Cargo.toml | 2 ++ .../elf/openvm-revm-snailtracer.elf | Bin 1890536 -> 1949776 bytes benchmarks/guest/revm_snailtracer/openvm.toml | 14 ++++++++++++++ .../guest/revm_snailtracer/openvm_init.rs | 2 ++ benchmarks/guest/revm_snailtracer/src/main.rs | 1 + benchmarks/guest/revm_transfer/Cargo.toml | 2 ++ .../elf/openvm-revm-transfer.elf | Bin 1887384 -> 1943500 bytes benchmarks/guest/revm_transfer/openvm.toml | 14 ++++++++++++++ benchmarks/guest/revm_transfer/openvm_init.rs | 2 ++ benchmarks/guest/revm_transfer/src/main.rs | 1 + .../sha256/elf/openvm-sha256-program.elf | Bin 67056 -> 61060 bytes benchmarks/guest/sha256/src/main.rs | 2 +- .../elf/openvm-sha256-iter-program.elf | Bin 66764 -> 60720 bytes benchmarks/guest/sha256_iter/src/main.rs | 8 ++++---- 25 files changed, 46 insertions(+), 8 deletions(-) create mode 100644 benchmarks/guest/revm_snailtracer/openvm_init.rs create mode 100644 benchmarks/guest/revm_transfer/openvm_init.rs diff --git a/benchmarks/guest/bubblesort/elf/openvm-bubblesort-program.elf b/benchmarks/guest/bubblesort/elf/openvm-bubblesort-program.elf index cec789e279113c8257555bd5cbcf534493ec190d..13b8249428af81a59fb911d16087850995e9c99c 100755 GIT binary patch literal 59052 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 literal 65692 zcmeFa33yz^l|NdyZ}-(=V~pF_20U=>mgK$N`$B-Uuw`s;FpCX@VIp_m?zZ(umV_2B zBmvp&me&wSV;~7hAhr}BBom&n1p_mY6J!XJ<@C|{$Fr0%`Z(ymneMp`_ZoHn z89yHR@v-J#*uvPtTXp`SYHi*;GdR|9xOxBgKBlrb)*K%- z?|=0pwEq+I&xZEd&^{ZrORb?gC$QY<6PR(h+eYQ(sJ%zU(f z^OG3OnN6u-77*1IUAd?sI!Lnv6t>+ zEOchP-)(oz#y!V+B}2T~jxj{vb33X*7c=Flf0LC*>I}t}nXy+X@M=2f;Q%_z(6>zo z^3L*w=m%4r2PQ!#59SA%*)u5k+c`?z+*a|l9KBH0_ z<6^s6uhs)v58L_mJx7e?Z;jcBdoBeZU}sqi+j$G_C*K;q6Zdjuw=x&u#)Fl;+C4Gn z2O;Etllir`V$Rk3^0@;CP7RkS3V1QLH~Xf|b6RfSIt=stjcczY9M< z?)?hYQ7HH5a(=uAJkpNjx-{EhGq6jJvflxlI_SatF(7 z22b%jr%hrmHc4@62hpc6>ka;d`6K^*${KB*HF(3 z`J7e;zA;6;Z$Uoy;wB|GX*0`wzboJS_94uh11xv-X2p5e29~*RU%qz*?tT9N%GjXf zz5%))Xw3hPO>ymVD9)EQE4jNi0hcST9<(=$dzzL950t^glOH)Zh4PT&Gjfm}=O*YR zw14m$jz8xdOfeewK)3B@)K+!+MJzLY6U$6}67?TMeHzN2fHJQF-_cfC=I;j%=Q^OX zZvp?R%aHdX(9@WpuU%cB-NbSo3y4P(D4o)BT?=skBAO$oQ(d|21kM}IZ_Wo@@_~U5 z%29k^;Dd4$9~k(c9K{C)J}4*V!vyf5vs{jg^Ch%1Tf=sC(s;aOj>lND9T=-g=hHVCp+=6v3v7-u?c&gTb+ZVac}QKvYU zb;C}Xv}Qh68RhfPoUl8euU0^Rs-S<9mC#%A^E|R%o}X;RUbYSX4f!4D1NX^HTk;g| zzXN_%m&PW}<96V?+kz7~Esg!C-KQg7GnR#6N1TpG7JiL_GzB`H`aYK1 zb78~ko^m=KvcboZb}u)I>80hHcF^<>zCMbvquQg51DgaXJp79lKZ#?ec3qvD_xK>)?~jZ|_3eo@2)HtSziD-Kk;T-#EaiudbRN zyD`abgB;pTzVo(?LfZruZ6i!=Gnn0Gyg_=zf%@#i#z9U@{(g<_kskq{vLIJ|)!QBg zFZx_lceB2_o~v`&>_nH2-^>1Bc_c47Z|6lFN3g6$R*)lzK zTn=bG!2Mv1Dg4`)U04IScG-~@gI(TLXh){1w$K*v^hjo(gY8tG1C& zGCKOCC|nyS zYMlb!*K#>E{*%@q@H58jCSIr*6BWEr;lrwE8<$6Q#(dc03ap9j@JG=9tR1{08@-4b zTWL+RMXZT9kJ*bkN53g+@HP3p{^y}1KO&!=+H-=wygyuD#5@@I2>dYTa_np|7d3|y z?aDbI_cR|T@cDQd+Rx{P6ME|HPK~vVW&QFV%@>jxmp(D0*X&x=HS==S zH9fAnYHm=Gt|DCpAF-}_Na5?u8j0Ykxye!H|Jt{e z+}B3&`mKnd)s4dP`iJBru!1`Bsfa#83i34to3UltPy?*fAld% z{1`m5;yvg@o3&k{O%+n^SDWqGZ_zh)%rQI0-;VLOW1Xm~Gco68V$RJ{)Xc2CHWj)c zGrQKN&cQlz4qrz)NY|6T$y5)FSF5w*T~i+h4|egs3O%EpM&n_w?OrwSjdf<_z0OyJ zzN$L{`-$;`UL)HHUB%l*`eV8xZI4DaSCqxxDU_d;@r3@DA*;veEsA5%8roR_-D;nr zi23R`-AVJ6>mD}QV2CZ$t!GAgbp^#5GS!%e-$(rAo`)f8{R*Y2RePaxs}v(~|NpXX ziha#G7fpM#oph7njbpM4@e$4}Q%5OEUdUe{E`Ci;_|jQ%KsH?bGMha>7m&^@#^ z``O!?VaNRHa%hDgzrnA2@Y#hA^q1>Cd>+8( z!RMLl$N27a@cvU7sE6AeuA3(Pz%H>lrZZ_QdAkdC0Apaa2yNZVL|OaXIpVvv7yOg+hW*saU)X!}a|+go zteorc_XnUCpgXH!XTPz_X0|Cz{*rSG**BCUZ1~e$_adg}ckBSK;d3JH1s!<`ttW_I z6vI2wnj&Za%hnV*`~PfBL2*iThUlN)QC({+-vL>oK2$5T)^JjMR_OoV_u9V+e%_98 z$GX#$mrPZy0-afuCutABAL0kk&;5*Mj;RpaG0Q=O3ouN_o>ZO)FlxqP6| zo?=_rf1a!@(BFl*S+E1t9zI^yHn9mg=wi{XS3e|wU+o!i&vl=g(*FUcJcTz#t=4AH8$Jryj_T)ll|tlijQ^YtidxKhh0;v6dG^PA|Itg zM;;ZA$JiHqFek=)@a&31h<6@FyG!EiMtRwo-i-syc;jKj-?hVrwOyxw^MRPL{Hb#CNhu9|Q%K%>vv0xQhhEd++h@xPad@l^ z;766owE^PPdr=;EJWMQ}$`-n!tJbu$_fj5;VVB4F&~NPox`Waz@r0e0d@cv&J4$zO`ZtU5h@5<+ee)91RO zC=(XjW!0@*A08SIaTmMU&lf1}qS>4;q?j|UA?~sl@yi1$Vw{M(fFE|VpD#ENcOkj~ zqC?zeFZLVi6z5ev(Ayeli}_q-l+Wzv3)Kqf5qBYa^wUCb&F?BJ=HJQl$FRdBHh81=Z_~Vr)kRgWgmt%?FxylpB5Ybs>$db>cP`;yN zh|^nS=&1aZr%*4?5BoD~Bg@Ph1s-3*)Y-penc3UmuPV&H`*x)_*s1tau%%mIf3Y{1 z+k*ANJAu>uTLZO5@><2YwUYU>pM$M}Uf1MW1@k<+71{>UU# z&sUzEDaYLEVEYjv(uV!tf(+kr7S-ddgeem{T8 zV9*JL_=0ZoDAr4Pa3A9&>@t3Ts(FQSE2XU^yQR*`3VEGTlvn@mZx&?LxwS&L^SI3t5v)3I*Ru?I~8<#>>zi7&;{rIwab`Q64 ze~J7ZBil__(@>mcYd7p*QMO4JeL7iXKPik^L00>JO#ANzSw)tZ}5B zAfHery=(DLkLwe1KK94{$3CI(bK9*x;fdN6{wC&J#gIIcN{t=?s^z*Ej(l={o zy7Zn(*VH|gJmx#Sr<{M!+{3>S@2*s9x+;73A%4AJfceueFxW-hL+p=Y#iQ}Nx&rp$ z7w}yjW7N6|_)z=vuIY~=7ES)(BFqWI6hyywsdcqXty&Lzj+onP-J|*1aP)4pZIQxb ziq%_SU&l)N+gvlDbD{fOv+qYAP>&n&$ZFU=Rsoqj9qXw3F~$e-t}4`r{VL*ttHx33 zs&b&O*-Dqjd81?&`~vMoIU3s8i8%35YYVGC-v@rVc7Z27dkTFUv^(B6*PfS}y6ton<}&t>a0(nYl9pz=-MAx--qv^GV&jeKw(527`O+C89Tx-sTj7uLS};Lq>1 zg=@%eXdk$$_9B-5tSx*M$4gw(foHxBe;72Y>E6C2t{Ui2_=`w`Z>(SqT??9LG4^zS zFB4}GVjp1a3NdQbU+Ak^ExXP8IDU+1%8vVNNhHes5}^;c<_?4&ov0 z6FdZ&yce`F^zGh}?Gy0%!U|`JC$DkI2a@bj98dK5`74}Sr$f>XPR9Q5acnB_+gd-#Ds&CvWUvn_Um&>! z)`V{3X<7x%P4uh6zXE#b>@pkQ`>H9c%+y>|N%|;9XELxS+)L@Vl$E>mC!yP3tRyE+}T(YR&?vSlQL#>0#f>`oMpj zQ>b@pwS3K4m@h)-JxzR&{YQWKeyW(q{TFgs>dBTd7mXkc2dkreh zc@=!6yy_1Ylp|lcf5BVG2YY~ggI$ipG}ldf8lRUC7py^Cum(1>#x;G)G}z2(uBzH; zuBn$#bLsJEF82-9NUtVcfp{R-7o^K!lN6yd9dYA!+}Cb}pA7kjeCF)rE8(Lt-C4nO zu3z|EWskY0-=@1}PMHE7phJ#zbtd=+UF*ae(52s7)i)FT-dgzq>aRvSs>7edTp0Ds z$6Yn?YS(mcHP$WFeP0I6wo#3)svBH9E?qOlg|eoi&MM5osX5qF^oQ`&oI{y{xiQro zlNHz}n`(@!c4TVSPr>}wjUzpXy+47m!P;!v0JXcysVU0acsc>JRccjjRf#=2d-oXh zeUy>jVb4_6PE{X-ov0pttPftjSm>&n?dTi)6yE<%w5K1uiV52x^w$(wKjJvBdx8(L z|JHtwq`%Zx+83jKqU}?S&QKCuH=!)6}Z<)6nl}SffmX zU9C}PuCKuwr3P!18mv*Ou|}zeTurC>FLeKc28_S%%p%UI^S#O|4aC5qhcMUc7{$tS z*kdL;??3oF=^XHfmFNzN^N=s(w1ZxU&A|NRHcx*OzcC*+Xf|GEH`y-e|9iR__F3^8 zz6s-Xe*1XyGy~sC_$4SCx>eYLdF9l0O2eLcr?DO7L*5HllFd++KnA@Mjf^-J16a z>1W=aC1KY{jbEHpW*AZ8&B32tFM}~w#OQK=C&vH-sBjKRO$MRpGBDa0gD zCS*{dwqpL1EFQx@C*};bkC!RhyOZ`&GdzZW&WFe|qBS(PI~%k@teWpre>=qdqta*> z`MD14{RR~}b1U|$wIk}xEwrA1{9>>Arl6z9N5nVy{xbT>+r+*_v?PaAF21!A+HK?; zoBPp%{?1$$``scB;=WiP@EDAp*EN_}_KAwQT-f*Kyo~)l-}m0Q5%!VR1IbTZQv+x_ zc*;0WhmHGySLT^1aYhLExNF^E$2xhuv5sBt=VSf9HO~DTi{o7XA=yrvn_NGcdP-f8 z#X17|a{LP=ddpds#kqRvPd|kCdId;7^;j;Y;Md^F3~|y*M*Y=jUCB24~1s|Jqj3~2n z3fii7cOpF!QZ!Y(3w6=gQM;`^BE>pWP2kW3;7|yJsUk2L^9>EVjd$;g+_YIWu{&sbj z8{@U|zASvYY<7z%^Iq6>#6W8nfhUk3+PBwf-+nLpj(%rpokDg~!P$bnn70i4A$}m8 z^f&Z&4!R8U8S~7%Z{Bm3$+7I5o~d4s{DpDJxEN%_!XM~36*`XAQ<6`4(l=@i{1Esc zBtv5DC;g00k5wMIEP|f)jg0ZT%gN89vl+w>*KFj+I#@+|p-k)@(V8z)okbl3w7&%% zQwKea`!##9)_WFf=6h{|SB|aJH~6YH;oEkqYV}_151~(ZhJ)mYd;qqxkzxMsgjGHvoE_BQG*=r&$fO_r~@XkS-6o1xx-dJAz8TGwZ)P?wShzS^PXSQI81oEz*`%-gx`qBUIaXN9(%KL{ zIND}+Kt5y^)E%1Bj2l*^T%p?cGB5t8q5> zsy`TrZP_?o`j;=@IgJ-M-CNz9|0HX8jz&9f9olae(4Gs=dsQ>y68q|8-Z1)$Gtsxv zoS|pL%ci4;w|J! zHGMYlfct6q{>bIVnZ()a?cjwS`rhHH@j6^pwT@gx8P)?Rt5WEG;t`!KljmSaN0>Hl z$cgn&j&%B&yZJc)jL9j+6Nt@f*;6PEL1z?Qvv-fqbkBz#1~1Om#!@T>dIx$8x{1y} zj+vtF90Ob9P^2x(KyQzuxTrD4p=G)^^1PJKiP*N^fpJ6Zq_<;_&|k1Y++NdJ+92_5 z;BmAUwnE`LFkH=f`2l3bX7cr$kUfX^o$aQ!aJ>h;>e3av)3IKGJ;6R6=I=3O)`AZx zr;eBDE0&qfiE=#TKbYkxbRGa@>tw(1yF@twx-zX909vkyknJiq?&!qlxD{Mh-rUabf>~v!37sY+x2X24DXc`um+@`wRPu zcET1B&upb_jLpwf*V+(Ekp9DI=6PH0FPLTD2tJ50051#Y`N0R1$M>Rqq;o!if4m+# z=PLMaj#bX_kc!xa=_B=@hkC&q=xyOoR8YNShomn_ewrDZyNT>6`2|iqr?R5cRuVgq zanHZn9^*5#rels_*XsYy&zIRqUvXRE+J|#!Dz){9;8Wd0kS*{Dwh#QI7%%sI%$Rat zR>yb_JOnv1^>hCv$Xj9uxIWXm^0_-g6hnkv*hlh2@yq<+X8RF}55kAUx(_;-c!n|I zXQFr?`rmL(rL$SYW4yaDwH`(UY$>N2*I&Oy6i6X=-{v388Tc61q*{Kxe( zp?7fh`Er$)*{O}Cct#(^4Yzz~o_EIj4!UH7=bgv)ZtRH}+wGNf-q~N-!*bsWpq*P$ zRweC|SE@6hLvXGc{$_r#yaIe7J3w=Qq)N1QXxV!!`@S+{mEY@UW^JYL2*;g@54 zuWjqrJn?t%_DXTq_?=z+tg*lHpAci-h4oFv=-!RHVuQEZ4?(BFufx9lYt^IFno5*i zU5mJd;?kdne*GuL>F&1wS@I6!#C3;|ZD#Ve^XYJw=KR2OYIXKGd0rSgzTnfVrq8O* zTyH~MuHd_dyQqKrp5f;$d7P*J%;G)h34X8h4D;T<@tCEE2Th_nVUPYr%yY;m$s~MN z-d4;*lGQ%Y;GE4q(wm~J{wWyuW5zp2_QZOgSmb-&Npj6~6}uX12I!pipZ$4aJ`Z9~ zS?97D4|$TGCl-A8ozQ3C!|~1&^ZsOihyF;PlYEa6@*(>lMLu*c_xk) z&WHYE^s;lK#&rkD1fPEe9m4K*eSf2nug(+dqLLU0*-u)la-WlzXZm%plj=zPx^WJ> zT0M+k_ondcXm6J6tMsw3Ue_>R%hjGIaQ`^b?8;{vFvDQx|6;d)!9QI!Vm0{&!6qeuSQ_5p%olwUgN%E|Wq(yn*rx z>owR`_&QTm8b7MjSpgkA0UwNmvAU*=d{N_2b(wK-g~s<|yXV6{dWg>(Zs)jPu%6qZ z9NBNuzg!3OYic#-KjI!VCgNFwDg}D3BvyvDh`1QVDNxtoy90-u75Kik;t=WY;+eSE zDPn9D)FFK$Hd^w=1v@AG1a5;ydN!8pi_Ywb&&Kxi=U~?TPtV4Rm=5f%;MJh`?nHkv z23gDl*yB5SU5E+vV4s)o+mp-+J8jwj8_}~#PP;~a8}v4GzQ$-@pX>k3Ogs1qpO@{$ zy8B*=-C-Z5a-2GIzG9SDPRh)%^RqWj$47bR>C12~bQye)({Tn5@uM@ZrF}ldISO`T z)L6{h3i$i*S!&i}eN~Hf;V<%;o_##dgZVZ=?Lq8#-_uz0Z^gQ1YhLYsI?vm|5EF5~ zPJ5F!<69jHxA~6yVI#>uA$?GZ^CM_Gd@5sXT7|ETI7uCsIgti=q_i<<@af{bF?O}; z+yTEqmeB>iVLyueCcgefY(mBPI;y8vyC1*N=AH%M4R`|C&cTjRYzk-fN9VR|!8)q) z2>NLo99#K5))i$G1A@G0w4abW17%c171{%(cpa7LTo&X!a#mi9wJrP=D^IGQF7jj? z%0T>Ctyv`Mgr0+3*m0%^b#7&Yvrw7ld!ThsOtVw+C3SeTRkL z7^|N7=!?m7k|p?v@LTZBXdP*XKWNXKF2rhIL@Ks-0AG~ zIEQ*0#d#IPKe11NXD;xp4d0)@oHjOK{Wr5t$$fk#3s;`TjE$qvx1ZR0w{64T4}7WZ z4ttK?OVIMDhHpHFQ(^OW&A?s&_(EsIrO5> z132f2eKYu|Ih0FhQK=u!GN}_g&k=P}UYx~p{Ss}WGjNa{=roMa34K6ymSW4y+N-GG zcLryF)j8O^nX{Mdv7Oc+>TCzrrcBK&&f>hOXoqY1Zr*0+De%`u?-q3(w_R)kWL@)b z`D(4R;tbe;5A#NO#aOjw6fcw7NNZJ`u{we|q~?}QMxXJyZZeZ~WoDuN?a&L`59f{T zqwSPe^leljFUjIx+{aGXf)nzU;Y^m0^}$;mA7yGv`AT!yl76Vy-idzh&pYk=^Zx8c z%;jpw(d~8G$Fo733C)&F;YzGl5uTUsXPr9GlENlVEEaU}e-Hk5n3%Gt^l@|r`xnwU7 z_1Q=sXfBZ*0l$w=L;O5J+c3v*rulNLYvOp95QJ)4mi4~<7TOCwl3%d7Y`k;LMCi4$ zN_84yYF*HSGh!V4Bp{#YHl;mpW(bwZo?$Z+ec#boPBTh|BB@{+i)ha3^wMe z^2~;EHu#L~NbddjPc`0oA9@b&*4Th|@a#Y5liY^s`2ODE+=d80$Cle*$GY!lcC`!n zuL5sYA3W8Gx{Qsm8T+%)84oj+_T$UgVdGk~75d&dlg~?K@LSmA3;_YWR)Df&js(8p*>6g!F^bxJ{mI^o*|^Mny^Qs zx$msxHbrxM4kr`Bsaw$FSk% zI6JR86ZPP8?U}IC@Dpa@8K4;s*kru(0nZv6Y!uFEz(zyw(O#~c$HFf3J2E{_LkCit z&_UL@LT8kE?Xg@33Q5O)eAY-HP zym$w#N3+YFnmivh@A*EyHmm!iQ@hMO1EoGE&ZyJ;$M|FYVfse@_t9~hW8&Q^or71O zQLB*`J_3!M#jiTXM|R;|SuW__9LZVvJ&1vKUJw>*^4FYYX!DH+aPL-}_kMdc^yxVG zDdR8~a1VLPZ%}f!xZ+eVSHctfp3SLuc7&&44vs0iAv_T@WBM*~o*L7_cizQvr+%=4 z$|L>Y53jK~uYM7B{zHZz)q;Y!T>GCG(3jSnl@mO71zk(rdqisZZPC??si&6XThG3*IS2bX)K)A@)u5 z>#6+U8(%-4soh>g;Q~D;Motq!IsCUyuHTU8~^eLwGZl0+6%O=)3 zCr(tHSA(wnb>=U7i)AiE+cV{g3ft{0e<$C&8Rd6g!*-rJc*MC0&*EaeVc5!S$j6*( z-d6B_DeN^uX3GyD9)mJ84ejZ{nBK#B%N(`NGAg$Wwiq$5Ec6iOw;5OLfUK3QDX`xM ze{4PN!Kk#)fxRai?b)a4msr4sl+J!B7m<34fKZ7kE41>wNn1asHRe8BzHn24L2kCKe6;N4;eB^p7Z~Gqn=;Ui=Pvrq zvCU%Nh5DnzzTx~NAMXM4UJKSWcy17FhVN*HY~Vb+Y=8C(xKH|(Utj`1en z8GAUmFXZPFR=JnNB>O&p8 zzL}_RwyZCk7xiIW^m}oRL4iHoi+Jus8p^=l*Iq}_c6GkS{SpV(IUNJ}UfV#-IJgXP zPS{(V3G8*?y-(1OxgPCsZXf0|&ivB5bp|KwIYM)>w`*A}_ficT++2RR*LD@w0Elx> z7yv)XRx)0WS_b`U`u!q5{Qe17;azp81NPo|a9`fv^|O+C{ADk~R$%>w`UY=z9O=W} zk+bXcv3-s_-9Odu_yP1;jK)muwO!46H*2-dwg~ed>1DZp&#>M<^|Ic~&lTr)Ri#(G z3HMaRpWO)`LaiL!SpH|{CL3&hIo{=mm;>GmXS^{%fo>n28#kThU`GbuI`~oUknQum z<>oMd9r;^X0xod0r8DRJ0jwADrO)5I*Po zIq=E3_Nh~ylco!u`G_{!U(RZK4{A#8V2I`JsKLA6utqDph~*X@%I98M%beG&f@-QiGZjB|MJl|S3f_mQD?aOy&Qbo2e) z4Bu_7#@to$h9-Aw8(WC?cGLTtPQ~X8d?fxm{B~OKRQx^#A9*SG@yuyDdk60xe;D5l zP3@`Hrg)>CYHe+9Jy%Z=P9^n@rq)#4SQ$?=rgWn@nVP$-E!EmKH@>c;ZROnf+J@#; zbDLXIO{-VUHCp5CskXW8&CQLVZ)lSDskJTf#`<`o0S$fv?Tw-CtMGwnvUnTHYj0?7 z(w8@;((QWNy0-c?tqtudy}emaC(mz#YqdR<Mp*>zTT#T84gI9LAy zy1uGomA)#qs=0NYo?2_9Qpr?uw%*d(yrMO}N(c8=H8jQB8=6+QE5TiAdviy--kjDG z%^gk2wsZCNl_|Y3)ucDH=|;SX`q7#)I$GNrR;L=*>2c$Rj)vBhzN(`=wU)6nn{=k5 z9VPv7w|2C(ceE6F-Zr<1*weUfj?d!@&hhx>cms3d@m6DH2;VI&jj1`wc}B5dEf`t?|}%bKBaJ{3ZrtZri#hNEhC~% z3``X2TRgcs-eh1j^@e7>t+ByCpAxBc%@9nCV?!&A~Z9S`}x_9Q$zFIRn1A> z@OM%FYSjNaCKt{3&y;^8FKA0cb3NzK+>WN=%!I_Wx9Dse+B60q(p9ppucECwu$a>{ z@r4Fhv$7dlC()5kr&{$JbT%0@aOs&1pYwp*C+G|zBCaFXPS@FGQ=!kQbr#pt&8@5A z?KJuH_SSeqyWX%0vcC#SO~_?ys=cGN3F`N8%Uo+l$W< zkU@R6wL^ka`pS44v{Y(!Lvu$P^h_d!j*IeANygT;>iq9BG&iN@v^T7xd=2dl@y3Q5 z1?N`9*Kw7bNa-!9R^l_bXwh2_B7X#R(j{$I@*MrM;Sry|LUXmZlICq~JB;=~eX_4X z#?Hd`eUpnalRR5ze+J%;&u21*#rCzv*VM008A8|G-KMj3XxmH(_G$RmYl>}r1HZSs zboMLAwe`ML-mUi^2Yve#o!RmIne<883e0=_Y-mQ8TG|EAA4Px2Hk^wO`5SZ{LK^*+ z-|{|$)3{zw;6F@QBXw>iW?brA{mN#DU^3MXYu~2FVGf&DHMGOf&(>Qzn)Edd?JM== zS1h}7Y5j$@^DbF>MeV%0^V1!TjqneeTlKiUI@OwJZi5by<+>|BQ>L`G(+Fn~Z)ruJ zyYL~M+}_%eBLD5Yj;5wK=FbJ6X`5Q&O%2BNVs=0euNJa*76!tNwp9uXuTPt%3qn$o z?fSWuh`H?oE!n~!;hS{$WB4Xr{LlENar{iWQJh0i&!QKvp?>Qe|4iB;<(~UTrTTc~ z8ljI#|BlD!L0@q`uMO&KdPry2h2f`0be5#=i8_1y3>}o>B3@2jsI$g-uz8@l?n0gY zj(*QaISX_qrp5^;fOk3k<<$+X%}r$R^wsg!2JXJYt|lAWS{k9jH=G#p&b^Kq%@0^c5;qxneUc%=o^nEPSiT1VgbjI+^ zVimsIQTBz+YtKurYtn0*)?E-!z=0>Do9y7OKNmhz@+Pm-xxWy^H_2NV-^3%UfJ(V7 z+*`8}3j}h<;iCZL;fJXWxtMFPU{+Y)z|Cv9~wpK zjhrMjsgg~<5xO4vKU29EOfvn>VkcLmno_h7gdf##0}Ul#FzAcspQ|St+S^*7+p$_& z3D!c3qs_lT+r#)?j_(`sjn}n&_I@jD7cIP+TZKKI{bivOcR|R`M4LwH`#*ww(?I{3 zj)TSbe+TuiM*aU^^!;1DQtJE5wvNR2pZwLL?~m?r9T362jnIqI|F`-*e>MLfbzX(~ zW!t6yZ*7OwUo+wm_lEX$dNcfxbYt@x+|{izJM?23;Dvnh%f5*_`QCg-|r9jgZ_{|?2q`P0Z+gi z@CE#VKp+?h1;T+yAR6=py+L2l9}EP8!B8+9j0B@0Pskhch5VsFC>RQb!l6hg8uo;} zVPDuE4upf@P&gcpgrgBp#2fKN{Eh9_x$sxoR8(Bu@YK6*CZEWa0d zC!&m}@l8HbffTxRws>!nB;K&! z=MB2O!7!r$kWnnm9SONTbIfRxK0O``g?*lAGOiZ_Oa2*baYNJfDFh1_FP^V^qi(M| ztWRIr-rmx7?%cU6;G1_O+y(-KRP-Eb>)gi1)vM;fCjXz5(e4I?9!^D!sNaZ$jgZ%y z_IZ=hL^2xmdOX39-yij*1BN$}NTsR?& zJoPuOTGi3$ZSj+IQ`CvGVv_!JVETKGBtKOC=S?iqZR|o|87HRnMia~QW?-sM;#Od)PvQ<>YQMy5 zfs2>MzFdNb@;6y9@&7L1eoK45a}>S@nEu|Rxa@4FB|rV;$(|BCl)oQ%Qm3R>*@KpJ zs_*He@Jql?S?d3-C7sHD#eymSyTJXUW%&yGZ(t08d1>r@;9rd`rXM*9D=K5pS<+7d z?uRZQpP2X`0;V|puYhU%8%!)JP*@`{#poxS>EAK2Ouq+sBgR9H_tU@>+n4G83Vb)x zr{f0IcL?}*mh_K-?WS&`^crf|I9+5%4jffvNlW@t;LVowtAT%FNym{A-X2kajo}Cc zuU}#uVPSF~fa>ctu}t3sOzn~QQDCZH;>UqyY@YJJZDN`Jdthph#D4@PeoMR`c$tZ4 zy#EATyoT~S=Lq@W^Vg=Z2Y_k(M}y7=e9%Hq@^Lz1OT|lLc&ylR4du_WV4}YecroOg zic#?Yt-w#9eF2Vb?4N)S0h5eT|K0$8#KP~lfn!b`sdOpq_rUWl_>aI;p15pmKQNUi z@t=UHesS5^LEz%0u@6h|Q2ww5Q~S@r8G+)ZF+5&pxrXxRSTNC_XTikp&zE5E!-9#v z-hzofQG$o^DGMh04HiuFIL2VPhVs}}EL=q2ZNWr;UkM({|ImVo{wWJ4`d^mdq5Q8c znCSmt!9@RF2_DK1SuoL$DJwJ&KQwk)2_DLiw_u|8S}@TEO7KuVY{5jo)Pjlr>JmJZ zzt)0@evJha{f#AfDF0OpCi-t#FwuXf1P|r!v0$SAXA36!{t`Tt|G5Pd{c9FX^n)dM zDF2oP6FvTfoaNGRddvcmUSYvRUt_^k{)`ell%H+EM86PN#yx2MT>>04;~<1D1-{FI zF9*KNGT(0mwx6!E7$!LB`#mNWtyI{fgqw^0!5hF;7JO<2Vl@_gF7W&by4gvEoe%t> zWxmINY5!1MHZ~9VJPTex`7L-6@G};?7?|2GE<0NSEcfY1Kiz0zS^ign<^CR}-)CZ( z{zG8upTs`~miv7~|FVf?`tN|L{}R6nEcfS#o??@PW%?<=#2<;r0v9iwfhfU4`Bvz6 z;-3dZq~Bk;K#VWxW5QLRXMB9GF>yOEjc=og`+$j`7$&CJZ0sXo;y>5lz~{#VKgXKs zch?s8bBX>{V7Zq{c{}=F67W^(S?b%8C{|3IM zwTRybUTMJxfN7sj(jNleWx*c<(>|O`KLY%Q1uN9C!lf~L2_DKnIakQj-Jl`)zt#i( zL7vF3CY%GN@h>O+1^hE$>Oc2CA-}3u^jFS@`M}iQu_%w^I}1$hmFfF{slPJ43=1@B zuS{PEO!D=N*`Ce7#1BdT3t*DBC(QH;e{qkN>bn@2#)D!vgtr09JyOEI0+#!pgipc5 zm;0E6%Pjn%`Q`$aad46l{FxoThlt{-1~vnDV_VT5UkbeRRym*S>~Ub)hm`(&#VG>I z{G)-NK)S@I0>9g8_80OP1*Uz=7UDnZ`=*H{{oTOrsGsu(6i))vUgupPAo}Vt0!#Yo zz=x48@hsrQ=M=FU_!>fQdg6uLLIkh|A8d z2QFS3YbwD*dFST@|D}HZA~5aYa(+S{Z?MqQczq3+_MpY3uv>v!EI4POC;NX#2_DM- zYe?kBuyJ`mJuLE5i6sBuw9r$1yDgZ?d!z&pit03NYP|9imH zzq`!zTP*FP@q7Sy>*(CeZbo- z_=mugJH$Q)_2&iPIl$K-2VrHLC|?v{XLews7Z>a)Fwsj~30%B1c1j7x`ujY_nr=1Q zi}9F$zG&ZaWTO757hwH>@}$2o){>w4I~#bkTQ{pv*j&PMi`WPJpalnk$F3G}eCp3~ z;C^7rL3kVR?Z8}KfcF5?84qzmK7kKe@Z-R1(SC8+*-wE-Bfq#HKfqLR{_g28@^N?ZEQP4dFgZ{Ui_n4qWBaK~0y!Ua+K-J$<k|Z)^e$jJm+}+bpz^+DVwwIOU^=rB zFzY*eqQEkJ3NW2#DL3mb2TbQ&9yHTkP=thKdJQn0h2j1c>i>?3W%@n9bPh(A z|B{Ji`fq`&kS_5nz$-5-j>r4JEtd2Hz=zfddq(oCpMmxi%vE3m${nEo9zU6y|j z@OG(>pg)x}v0eu~wU5f14g9-vbwQ3hbAj0fMgDIl{JCQKHsE`ZAI;+V_W(ZvEcMIl zz;tFtTnc*wn4hKLHx%|ZFrB%P>Awel%98)|vtSR9F8O>Oa4ZxT-hrZZp?R|CIe!P9|XD%b-Dn*~hrDCyn6B!3cn zf#n%3s{c9@%k+9+l0S(Pz$BmIva=L0$(OinY$Y(sm&Dftle|dW1We;8@eRN^k+;g)Bhb$3Fv*w12CzKCMfA6rSf<|wO!6i1?ZEQP7SaFI#4`P7z$9-H4*<(E zT13C!#4`O)z$D)i9|SI5*pDf}L-~z$Lf-yuF3-%a4>Aa-46!t29 z-er;h{{*JJ zm=7esEhZj)sgU28i9ZKS^Wkn2zXwe6A=~F!BIHB1uN9d1HwpAKza9oAeo6X+z{D>} zAGu8MOVYm#EYCku{>55V$FBH`}=%QI+%Uk8?F#`7u@ z{{Yz9zxh{|;;&l9i}b@iz$-Doq<{3ECPr~oB6}0~)AV=$lJ0_J1sx=)VqppQS(F0Jh&$ z)K8BCzh+7QDe!|A7yJJ+;N&GmJOC`u{n32>Zxf4N+t~ZSRKCOqfQy&L4wc}c{H~>< zeGw3mJRbz6`X4dz#}<0(&m>o|H0u9ZC3q-*wgnUY=Pa1$FDSu7`C1Dm`Y!>0#nRun zC7tpoOYl&Bg#}aojTTJwn@aFdeyar&{SSagTln>WC7tsBs08DD!7@Sr6xcxX;U|`K zD(_!`Z?&}l8Q=#k_}_u;m+B@Hv0emTe0eb*_;*;?5f&HLSHSOBunV|xX)(P9_$wAX z1NbKvJRA5a3!V%7k_G#KpR@Eo2wc8emXG)maPiXE=SuKUegYH$(c3{p{P-d;mFF<= z-N01;SYVQ``B#hjNna7Zz)~LZ@9%;4TiW*}U^^Lkekm+&q37~Yf`{^NpgyAil_JW& z1@&3+3JX1#7YpX{Qi35b7R==Z_?fGU?RfzBW%PFp+DG&8dEj>~=`R5vMtZrKu2u_r z-W||u!16pR<@cIcrU!s2zrueV8P=9_6e3>QvS>S6d_&MO^7W^V`68TA9D8H?S zv3^Us1GwFi?g6Iy#ARcCV0mtr@_)(1GCdAl3wly(l)l}>GX3koRKLXE0H$-l67K+} z`X#;#xOi#o+a-7?|6L0vemw@PU!$8@5MKw5S@2%quUPOCz;~fO$&ddA{+%WLec%U> zZbOOGpTC<1eQv=Efgc1eGt=9Ep9ALp0_eXBdtlUN0&_DHM&)0t+8D}Z~EJ`p#lJpmKT^f0hI>rCkh6U+1z zF!fL3mB8|hG|}fwEYt4*rv6L(P2l3CvAav~Q2u)sOyl{u1=D=_X$c<6|IC7k{#9W8 zTHUNdVgG4Kr~Gf0;Gz6G7EJjaGm5Pv`tlMylpkfmL_ghviGEfI9?H8dnCLIDV4}aY z1P|pew_u|GvIP_UO(l3Jzutn0{)ZM!^gk}aL-~g+nCO3N!9@Q`2_DM7Zox!9YGx^a z#+2Zp{Am_U^q;d}D*u8K4FAM}iT-*ECibMy{B)Don3+vj|Zmn z?lGi}gT|==rt`=i6T5-wd^5~APmfT3q;EFyg_M47F?}g8ov)SYap0I!=l&6u-vUhM zYo9Xn-+UB(4tUY6Iwx+`@mo1_p-ej{=kbN%n|v6EN8`-NfGm zrt{*XP5cos*|+mdJZ-M<@5Y;WEASg=A6;YNHGUnK{C}B#S3vALe<|zB0MmYDr&(Uz z1$Z}!g`aDHn}NyxQu&=R;qOTP4*-+DBXN0cY5(uLQ20-h-@gSW`##?s&x!NI`tVm~ z{eKTk{yx~k`LPR_{LRHC{`P#xucg1g2ENsTSsnKKEcn+8#eRmYZ|NfV=SU}hoQCnZ z8JObjqs{j02IkM*n)ve z+265d`o?AOA1~F}LRHlN&%m^Pn{3wq?$yHImw3@N!e3o(rhgBZ{8NdU8*jI1XYSVK zB%a`9?$pZqG~VHpV(zv?TN`up|L`CaJx&cOdIrgjw~Mqk;90U1(%aUpYL6%Iy%LY4 zi(lfKiB}`lCpr>%e-fTAZLc@q59E%-gQ-X~<;PQfzH}&=nq#c!aC=z&wU_$wWVx@k z-Rq$zrt10QZ@x%J-tArSn_JLy)lJuG^{EqJrPR9LmqD+ zV1(l7us!zXHz!qD{#_C}j8}iD1ew0+G0Jf?Uxn;%lx- z8C8pyRxPcXhrcL$(bB326@kX3P>jb2M*V(I+80hF@hqe0ntO2^k7c{#5j@cth=&q! zFCKr4#J!PZDiQSI;YEMShsP(~0b+tLc*0=_&}$e_NjeZp;UUOKIOO%G!;v^|>qsl{ zv5`{xX;?-|>|s^O5fgif_^5yWmNfxSxZM*D#@pKe&#F+oJ<;Mr7aLHj2i9+GNe00q zcRJwncrec4XgcBzrK6@?uEM)w>hXT3wp6>@Ftf^gM$5XwJ@?`kqczo7zp??%r@l() zrI84UN}^XT#oIdSmoB-C#3Y#rq`cm!frnPphCf+Xl-u;G_Tbg@E-z~q!)gz>M*W%2jWRzG8zgd<7toKkDH<-h|DR8w^6jyON89XKsuBTdW?WC z6iB4}Qtlu$UO9awZAiRl%p0b6#c>sc{~K1|bxx6mb+wn(U$*2*3^<;64TXa~JWB1y zL(hpo9ki?2C+JF46UB4XzLY=ZPZ-`bSmQ~jqj+96Y((6_5mTb`m`37X=>){P)Kv%!&ej?mc%N5c&eiR65?#*lx}i{$`T;mCeo9 zBX=?#fG&-CQlUW5?=u2c#Tbd;-2-?wn>>_g*bAc&Nc+90CIBND@TJ^7e_^H!OIn;% z!;(T)&|}UP>;H244x68k?}(}8P>(o+9MutLkkezBk@lb^e5B2Sg8@&%Z+Jp*NCHMG znT!~5ZzvjycsyYrh64}Whb8-mCk>38v@oc{mKq&-p%y6~Y4@Z)5NsQ1uENwswh`yy zvv9=JrQ>N8(c}I;;nem(ommGwod_g7iIfL3Ero#(rsAn^BIHftg&jsX<&C>xpv{>b z6)!r%`+vM%{wU;iMS3hsbvP+kqeDUDFs&+B7fETY@fCq-R zj|3rKDY#UqNBC1M?X3Y{vbDLTzM-ieHW(`g`0Cv5y4~hGxZGFrcX5&Lj>3YG01SR8 zo%UhH5C{pE9UV3KJ8Un*RCy3s<>er19AEvw#M{B!7A`36it(hfrU&WfEQbMd0T`K(EkOI9ll-C&RIq7 z#FAEUR8DSeJhIdimo%)w@<{V~;xdGS=lv}-|HRbL1ALZ<|4k{vn{$G`a5NbW_#)|W zlHOM1hZzhf;7P{)!8q1_pdTqQIyG`)J_!qx!;4kt(X)g4;>NoWg-E*Hg_VfgU7L)z z;N`$1+XX7~|k1@F?&SPB@`O^u+6T)HWhP09PM}vq*c;W~}M19F{(C>jm zZDH?l#L~Qq)|{{faP*`uEWF+^dZB#LV>s1B!Hi_M?$X)|7uU@v9hdgU<9H(y9C5rD zDals^)M@_D6qE>FKoh}xjzS&}`T-P7M|>&xRi02F8BYb>fx>Ekcv9&g7T9{?zDUbo zWK+WMVeM(eLlGDQ59$u3yx?5ipGaec9`?Agax@z~EGd?aBPI16W7|fYQ!0iLXW&bM z5mQGj+Hu$(`}jg(q-Fc1)*DXbxX=$r#Dh)+_3*!8JFT`j96r9bDfk0!cOtcdOf|jd zvwmf~DcP86b-NevS0W2LeOY{6V{<%dn(GiOQZ$}6e2E|}1da-)!2CzN$5bh-ZfmLy zs|vUK3jWRY*5b>cyYQJ;)NXva;db+PgIRP}DvsBmB|WJ$;sa5SABXzHO#B~O+oNJd zC$s%=UpSfarh-N^>NBDNymKuaN+)4U(h0aiNldZ7zUenrn6IHZNbjg_3kSH{L%+H5 zCzVmOB>WcQCH&iT!RR%@ZZm=kD`AFEiP1rBcA)uu2={tZSVj2aSmT8dV*{)Inl*a^ z!s4NA?eNc%XhYDSNP02O-YBefC?cG&ziJ!84d$N`pf@ecW_S}xe=re%n~(@$Y3uu| zv%>WLFj!y$LjDPFJcVd>%HuQAiNAX7!E_`3Py=d)=}4wSAzvbaP^*y&9bGf`oxR6p z8D9Pe&ng;Ezz!zTVG;g^04-Uzbn&7~>*m)lSa#{WrHhtaS`Rf^@S=vFTs$O9;S9@K z#wQ~c6rDKv$_1SY!M-R2LbOqi#&6iqej2CJo zkPL&r-bBcN<53Ja4&NN^fgRhN=y6o}uw3y$vcsMP!k>{SVg_P~F=ECP!ZgD-y0E7B z6oby!cF`zTa$L6!XSc4TSN0pQTheG9v-aa9xZRhLy^}=He*P6H3j9NvJ!T(I!5Q?{92anc$h%oyTUL%QEoe$1>VG@0s2@@H)c=N!*NXNWnS7F#;_m8|8 z!9vJ=_)Rfy-xM z6~`^ARHt}jWfbpF4H|e$D_&74wv#@^Se81Rg$2S$M+|Y-LY`xPjIAo8UAoEVc>13c*Co|5OE!zv@lPHCoL=`hbOft{bMDsC{Du{B>5{! z88HLoz#q4A>rJu#;jeplBR&$u8;s%i1pHCFWZB$`gu#{3Q%)Bkh2Zni|Ml4E#-FUB zBO9ym0{Qp~I*SnYM5A6`G>sSG!lYQjEj(_*-=JHc#GiI(T7hE}KEHujJy!3iI2bq5 zyiPvj(8`g}$}rkUXr(?8Yl65x1RnsWK@tcM!P7OnThvbx1Q5dBP%7jL#IcnQ&)geG z2H+c~LY{aknQ(*4Qb5g-88%C4;NT<;k^MReiIk0#kZ_MljQ2^XWK4puSCd|B!KUI6 z0bdfY88+D>S%!4pVL;iN%SEUOXF^ZHuiNrcGTQ~3K|jb5Kv0O1eqq#M>k zbW)KpLi=fimAoDbmT@ArCf= z!xaYJD2^9MCk#4Q6G^-MeELg~7?#=^g&DqV9^olW;gd93irPs?q?$Mh392hNu7Qw0 z9!lZ}mElQw{o!N)%O%7B@uqW6G?$ zVZ-nDB|~u>@JrI#S9(O2Kw3n&-{Nnb;^1b=pu zF2ylcW{yOC{ffrs1pa0%{;n7O9o#D3L!TM6Dv1$rr6rCZ%ol%Li{b=+ap*K`z;TME z623GRb$%~`u98zkPzcXMb)^uZ4;lte_=Hmyh7wuP#Vk2UfOt~aoA8FQcY@PmA!3W^ zmlj7s{Hhm?F${kyfDpVt6-p-}krdAm4DwEyhkuJ34JYa&4--=lOWG0-V+#j^iVah& zc0!1;9ov>57YG_pPdJS~8(-vsib(Y|=vSLdcbnBorO5C3@aXLxYt4yRUq z{vh9%;?oA(Mj~<_5$g@qV%_aX`U4(p@8NF(;qMI@QE{xNB%?WwLPUZ|jG;Fe4Z^qc zheQ8Qb7#{dM^c1g-#}bI;sPf)a6-tc{Hn^7K*(NOyOwOPv1f!t63RDX=yUeQv|Oix!uWo2b%L`J-C1TmTjv)>5=18Kjhq5BEY z#i0V!p#l!R1#@5vfJtoXLGi-2->(5`a}Vq(AZ)yY{RC)zsDSEF0h@0@mdO+y7Ie^2 ziUHpM!QIqCu2zGiSXXTo-W~A4%Y`tGCRN@$U+3S181H{e#WGoxAZGNnlCoqJ8FOj9 z9@h{?<;k1!#nA(TfgD>}tsUrkV|ei002Db7=|I)7!c_`rAQUC%jkIA+NY%dT>(k3K zxuS!H;fK~1sz-T_1Gu#U8R!BQ1jYkq0hg&MnI_wGV)or#xBt~tpux|Mj}~9tdvlrqF~XbgIRg2vcE-_X?<~i6&;n- zMLWB^ShPUPpoYy| zP7e*5KWo#E8OBAxW;C_04IWEBpqwUsKAEc5C}_B{tf?82Zs;&OeePRTmJDWXl*9&g z=^2#?avF8?C`=cLnfBO#?H}P+U-frPz5DD1q=43f3YBdyM+IQ`Srpt+|53 z$pk4#b!ycb!)8g%T06nFgFrhB6&1^&7wvbmQEMl3wq;Q)qyQrxzn;h}C-`C+p`Idu zn{b>*(S*AZm!^FynB;uT6b)AR&K%VgJtY^74yhYH^ECq`Nnp@iw;70Brk?!F*KDa@ z3E+~I8nE-wWc#y>eLJJT>eDL#vZq(lpVh_HS-&_D=n!EE%3A80BqQjg+b1GLtVBsdg=wDeI=H8#uXk=qQ?*^rYyhm6KMn_WtA)u4DaH z*4qJ8X~{WZ=$O`mxuA(#&Q<=)$6w!H2kIlnmoD_IE#T%+LXg&Wi3y2w+vn}5(6aPfgozwVOrj4fR-l0smd3{VwUwEGzK>~zJEIb~ zfIaX6!c_7wqEy$LB0YwXm;^jXV*L{PpKjsq-8C_w0z}T;yV-`CzTDf?;>nfVa5a=H zS=>ZcySt&ndHb@Zzw-XszWD0v-MV)* zbvi*4U!I@CVPB-8%uFu#;P}atZ}zfNLTg&5>NZxFMMtDjaoed}8yq5vrNB0VomdV` z0Fb`99EKjWVBn9qojq6n{^bz0Rn)+LmW3fi3E_E+ zm)(J+@82s+f!hAPX!5vV$MGxuM`>Nw38L*4tMb5@iQ0B2_ifztDx3t2>ngAU1SLSqg?Gn?OjU%e8n5I=HR&oblv6Pd3*AqU$HB_#;evkZ7ijT zq54jXlpty2h*?we6>Rpw4RsCoyTu6F`yuE3+-&#m`H=IDZdOFr5^<{THCoF?HJVj! zu+W)0we;xhFTzVNz-}NI4eGmFQK#_pB}arZsVeh|YHS@IA*n=7(dZ_m$sb3>if#;R z3YBqz-OPw;NyX3vEFBPuIF@GZ_MJ%}6xa>lFxLkZ8;&v2BGyDZqIvTsL8WgJ!fx(` z73m~A1iKdVKymj;kc>STmakrEg7|`(&n2uEV+m_nX`C85j8QavV}_C@#K*rA=VG%< zp_KC7#=}{%7Vf5}j`E%o%oYiG{7i#h&HDkh?F|5gf%4!uX0q8W%Ve2U!KfLkFOHu- zfB00k^00VHV*Y^Q`@UvRGfl8-r|6T;JbF+_55ZII2GH~v9lk4;y8GrC_R#}I6DAi` z#9M>Ah#ixL-*WvT{^+ID5`Wa0)Bar*>5LDba~{K?ZMuQd&<2F7sYi2TrjJ)=SP;M2 zLhKe*iN{QAhe;o(g7hU9C!`Yi5c7^;t(dy9Ws7ZRTCl}gQoftDriK3f%bKuEM7kT> z;yv{SR+e}>n%#{P<3{PMm1$o6sw5h7aq^um9@ihPUI1PPfV8otWUpxH42P*l+4wX$ z?1VtQfYwhCfjV0 zu-<7(NyIDLANI+;M^9;xsn{4pZ7zDCCIE9LpUZ5M)&-6OSC!%lc}LChMK*E}TwrrH z*kZaah4{795i5(K& zq$>tzLN)CkfZ7FRnSIX4d}h{baCuByclPaDr41gF3H97sL` z`l`cuSHsgmx5&aDZZRNsGZr@7Kh_amU>jhxxWT&R#(O#CbP=Qf@hPO`E~oJzi4ycy z=xlA(HHA=NXmt*vu9Asoye=DBgG;(;yRIPVRtKpUQ)zkWF}#kJlALBTsgthQi6S3k zJhO8uO;UEf5kA*j-44xYd?E<46%K@J*=~z`{O0p!zJWc z(*bSBd;bF@U&qR zrxz=I&qtkOXLAkQQ^M#M`{?0j4wrEFqdvGF?7??ob9ia)S*)%#VFSH2hqK{ zky^C`x->>ZPSmafpMX1|-M&Sd7Q)ZfIKrnfgp*J>!rz2BDQ-%(>%|zv-r95M&?QdG zzyv^XIHO=-kdjk_?;@y>RB{!a7AxMai9xWz%N(6q(eW8IQsxul0|Eh3DB$|2CA%7X zBgEuVG9XKgGX51aC%&akX!M31b61xG$vSkh(68n3BA!TS*WC@CL}z$@eZA9&3@*>zP4y)#8c6HwY+h==>CxoskuniD3Yn zKlnj4mB)QYEVon^E$N9qhQ4dZz(3A+Z38Jm3HTc83tzby*G=PR?GasLYv82qaLWOLKwWw3f+ z`%YgFFHs@1q2Dv-$1hO8Dk9Ab>8R?p zJW=%T2;S4lGdF?vE=T9B%~(W3T&@@}r}V%U4;N&zDs-tFx$g+f143gc86P>~ABB2> z=!2g#^e~|ro^5hFP9tGzsfyEa+0uj~9NWoY8z6#Uk_HQtY7A>_XlI#jI}I0cClX(J zb51H-0uL$s#f^Povc0ciCL}+N(d48R{1g%Mr8T(bgWuxF_e}g~l~?B^1v_~y4y^!( zhmQ4@%t=G&SAwEzQa5_`=VUrpR;t4?XjsJ?!>rl&MJj4CM@x2hUO)adZ)$jv=Xrcd zZfJS^h_@UkwJeHPtCuYn1mZ{xKdWwWH;@-;W37@8siec*}JQ`M^t#`%n5a{*>?JEh*c% zCf}ylAO3dd&Tq#L{FY0y_$Nh`r{!RYt@iiXzKUTYBxBvhE diff --git a/benchmarks/guest/ecrecover/elf/openvm-ecdsa-recover-key-program.elf b/benchmarks/guest/ecrecover/elf/openvm-ecdsa-recover-key-program.elf index 62777bc03458096a56724860bf5c66325058002f..cb9db9c5b60cf875bc5e4bb8bf9eb40417988096 100755 GIT binary patch delta 49549 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 A6aWAK delta 48575 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 EU-o1NAOHXW diff --git a/benchmarks/guest/factorial_iterative_u256/elf/openvm-factorial-iterative-u256-program.elf b/benchmarks/guest/factorial_iterative_u256/elf/openvm-factorial-iterative-u256-program.elf index 572f71b1823a0f8cc61b781a9e35fa9714b845ae..4808b6dab2e98d1c426b4bf8a09b8f9be3474ea9 100755 GIT binary patch literal 58664 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 literal 65404 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 GasLC<)ehGH diff --git a/benchmarks/guest/fibonacci_iterative/elf/openvm-fibonacci-iterative-program.elf b/benchmarks/guest/fibonacci_iterative/elf/openvm-fibonacci-iterative-program.elf index 7c681ee3137d5144c42451cce5f699bdf6f816bc..e6872618c3a4b44de8a2370e2595e5ff4ff89311 100755 GIT binary patch literal 56908 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