From b6d754d594a41a148a9214eaeb67dde600e7c091 Mon Sep 17 00:00:00 2001 From: Dr Maxim Orlovsky Date: Mon, 30 Oct 2023 09:00:34 +0100 Subject: [PATCH] validation: validate anchors depending on layer1 chain --- src/contract/mod.rs | 5 +- src/contract/seal.rs | 9 +- src/lib.rs | 4 +- src/stl.rs | 8 +- src/validation/anchor.rs | 97 +++++++ src/validation/consignment.rs | 19 +- src/validation/mod.rs | 4 +- src/validation/status.rs | 6 +- src/validation/validator.rs | 56 ++-- stl/RGB@0.1.0.sta | 484 ++++++++++++++++++---------------- stl/RGB@0.1.0.stl | Bin 11270 -> 12154 bytes stl/RGB@0.1.0.sty | 27 +- 12 files changed, 437 insertions(+), 282 deletions(-) create mode 100644 src/validation/anchor.rs diff --git a/src/contract/mod.rs b/src/contract/mod.rs index eb230ee3..a09e70c0 100644 --- a/src/contract/mod.rs +++ b/src/contract/mod.rs @@ -71,11 +71,12 @@ pub use state::{ConfidentialState, ExposedState, StateCommitment, StateData, Sta serde(crate = "serde_crate", rename_all = "camelCase") )] #[repr(u8)] +#[non_exhaustive] pub enum AltLayer1 { #[strict_type(dumb)] Liquid = 1, - Abraxas = 0x10, - Prime = 0x11, + // Abraxas = 0x10, + // Prime = 0x11, } #[derive(Wrapper, Clone, PartialEq, Eq, Hash, Debug, From)] diff --git a/src/contract/seal.rs b/src/contract/seal.rs index 13685348..afcf7ec1 100644 --- a/src/contract/seal.rs +++ b/src/contract/seal.rs @@ -31,7 +31,7 @@ use bp::{Outpoint, Txid}; use commit_verify::{strategies, CommitEncode, Conceal}; use strict_encoding::{StrictDecode, StrictDumb, StrictEncode}; -use crate::LIB_NAME_RGB; +use crate::{Layer1, LIB_NAME_RGB}; pub trait ExposedSeal: Debug @@ -110,6 +110,13 @@ impl SealDefinition { } impl SealDefinition { + pub fn layer1(self) -> Layer1 { + match self { + SealDefinition::Bitcoin(_) => Layer1::Bitcoin, + SealDefinition::Liquid(_) => Layer1::Liquid, + } + } + #[inline] pub fn outpoint(self) -> Option { match self { diff --git a/src/lib.rs b/src/lib.rs index 22691685..cb9c9541 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -52,10 +52,10 @@ pub mod vm; pub mod stl; pub mod prelude { - pub use bp::dbc::{Anchor, AnchorId}; + pub use bp::dbc::AnchorId; pub use contract::*; pub use schema::*; - pub use validation::AnchoredBundle; + pub use validation::{Anchor, AnchoredBundle, Layer1}; use super::*; pub use super::{schema, vm}; diff --git a/src/stl.rs b/src/stl.rs index 9648dd7a..18889367 100644 --- a/src/stl.rs +++ b/src/stl.rs @@ -23,27 +23,29 @@ pub use aluvm::stl::aluvm_stl; pub use bp::bc::stl::bp_tx_stl; pub use bp::stl::bp_core_stl; +use commit_verify::stl::commit_verify_stl; use strict_types::stl::{std_stl, strict_types_stl}; use strict_types::typelib::LibBuilder; use strict_types::{CompileError, TypeLib}; -use crate::{Extension, Genesis, SubSchema, TransitionBundle, LIB_NAME_RGB}; +use crate::{AnchoredBundle, Extension, Genesis, SubSchema, LIB_NAME_RGB}; /// Strict types id for the library providing data types for RGB consensus. pub const LIB_ID_RGB: &str = - "urn:ubideco:stl:28ZcP9sj9SC5CC52qLWM9YxxRRhXAJjwRqD98nZLmx2y#radar-inca-valid"; + "urn:ubideco:stl:DmN8aZj1dPvAvx5JYfz22azHs5RRbECxmxWoo5LK7E5f#house-herman-poem"; fn _rgb_core_stl() -> Result { LibBuilder::new(libname!(LIB_NAME_RGB), tiny_bset! { std_stl().to_dependency(), strict_types_stl().to_dependency(), + commit_verify_stl().to_dependency(), bp_tx_stl().to_dependency(), bp_core_stl().to_dependency(), aluvm_stl().to_dependency() }) .transpile::() .transpile::() - .transpile::() + .transpile::() .transpile::() .compile() } diff --git a/src/validation/anchor.rs b/src/validation/anchor.rs new file mode 100644 index 00000000..8be96a2d --- /dev/null +++ b/src/validation/anchor.rs @@ -0,0 +1,97 @@ +// RGB Core Library: consensus layer for RGB smart contracts. +// +// SPDX-License-Identifier: Apache-2.0 +// +// Written in 2019-2023 by +// Dr Maxim Orlovsky +// +// Copyright (C) 2019-2023 LNP/BP Standards Association. All rights reserved. +// Copyright (C) 2019-2023 Dr Maxim Orlovsky. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use bp::dbc; +use commit_verify::mpc; +use commit_verify::mpc::{Message, ProtocolId}; + +use crate::{TransitionBundle, LIB_NAME_RGB}; + +#[derive(Clone, Eq, PartialEq, Debug)] +#[derive(StrictType, StrictDumb, StrictEncode, StrictDecode)] +#[strict_type(lib = LIB_NAME_RGB)] +#[cfg_attr( + feature = "serde", + derive(Serialize, Deserialize), + serde(crate = "serde_crate", rename_all = "camelCase") +)] +pub struct AnchoredBundle { + pub anchor: Anchor, + pub bundle: TransitionBundle, +} + +#[derive(Clone, Eq, PartialEq, Debug)] +#[derive(StrictType, StrictDumb, StrictEncode, StrictDecode)] +#[strict_type(lib = LIB_NAME_RGB, tags = custom, dumb = Self::Bitcoin(strict_dumb!()))] +#[cfg_attr( + feature = "serde", + derive(Serialize, Deserialize), + serde(crate = "serde_crate", rename_all = "camelCase") +)] +#[non_exhaustive] +pub enum Anchor { + #[strict_type(tag = 0x00)] + Bitcoin(dbc::Anchor), + + #[strict_type(tag = 0x01)] + Liquid(dbc::Anchor), +} + +impl Anchor { + pub fn layer1(&self) -> Layer1 { + match self { + Anchor::Bitcoin(_) => Layer1::Bitcoin, + Anchor::Liquid(_) => Layer1::Liquid, + } + } + + /// Verifies that the anchor commits to the given message under the given + /// protocol. + pub fn convolve( + &self, + protocol_id: impl Into, + message: Message, + ) -> Result { + match self { + Anchor::Bitcoin(anchor) | Anchor::Liquid(anchor) => { + anchor.mpc_proof.convolve(protocol_id.into(), message) + } + } + } +} + +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Display)] +#[display(lowercase)] +#[derive(StrictType, StrictDumb, StrictEncode, StrictDecode)] +#[strict_type(lib = LIB_NAME_RGB, tags = repr, into_u8, try_from_u8)] +#[cfg_attr( + feature = "serde", + derive(Serialize, Deserialize), + serde(crate = "serde_crate", rename_all = "camelCase") +)] +#[repr(u8)] +#[non_exhaustive] +pub enum Layer1 { + #[strict_type(dumb)] + Bitcoin = 0, + Liquid = 1, +} diff --git a/src/validation/consignment.rs b/src/validation/consignment.rs index 96d231d3..9939089e 100644 --- a/src/validation/consignment.rs +++ b/src/validation/consignment.rs @@ -26,26 +26,11 @@ use std::collections::BTreeSet; -use commit_verify::mpc; - use crate::{ - Anchor, BundleId, Extension, Genesis, OpId, OpRef, SecretSeal, SubSchema, Transition, - TransitionBundle, LIB_NAME_RGB, + AnchoredBundle, BundleId, Extension, Genesis, OpId, OpRef, SecretSeal, SubSchema, Transition, + TransitionBundle, }; -#[derive(Clone, Eq, PartialEq, Debug)] -#[derive(StrictType, StrictDumb, StrictEncode, StrictDecode)] -#[strict_type(lib = LIB_NAME_RGB)] -#[cfg_attr( - feature = "serde", - derive(Serialize, Deserialize), - serde(crate = "serde_crate", rename_all = "camelCase") -)] -pub struct AnchoredBundle { - pub anchor: Anchor, - pub bundle: TransitionBundle, -} - /// Trait defining common data access API for all storage-related RGB structures /// /// # Verification diff --git a/src/validation/mod.rs b/src/validation/mod.rs index 7f4408ba..7d78c133 100644 --- a/src/validation/mod.rs +++ b/src/validation/mod.rs @@ -26,9 +26,11 @@ mod model; mod state; mod validator; mod consignment; +mod anchor; mod status; -pub use consignment::{AnchoredBundle, ConsignmentApi}; +pub use anchor::{Anchor, AnchoredBundle, Layer1}; +pub use consignment::ConsignmentApi; pub(crate) use model::OpInfo; pub use script::VirtualMachine; pub use status::{Failure, Info, Status, Validity, Warning}; diff --git a/src/validation/status.rs b/src/validation/status.rs index 5d38dc94..e743a241 100644 --- a/src/validation/status.rs +++ b/src/validation/status.rs @@ -31,7 +31,7 @@ use strict_types::SemId; use crate::contract::Opout; use crate::schema::{self, SchemaId}; use crate::{ - AssignmentType, BundleId, OccurrencesMismatch, OpFullType, OpId, SecretSeal, StateType, + AssignmentType, BundleId, Layer1, OccurrencesMismatch, OpFullType, OpId, SecretSeal, StateType, }; #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Display)] @@ -298,7 +298,7 @@ pub enum Failure { /// transition {0} is not anchored. NotAnchored(OpId), /// anchor for transition {0} doesn't commit to the actual transition data. - NotInAnchor(OpId, Txid), + NotInAnchor(OpId), /// transition {opid} references state type {state_type} absent in the /// outputs of previous state transition {prev_id}. NoPrevState { @@ -316,6 +316,8 @@ pub enum Failure { MpcInvalid(OpId, Txid), /// witness transaction {0} is not known to the transaction resolver. SealNoWitnessTx(Txid), + /// witness layer 1 {anchor} doesn't match seal definition {seal}. + SealWitnessLayer1Mismatch { seal: Layer1, anchor: Layer1 }, /// transition {0} doesn't close seal with the witness transaction {1}. /// Details: {2} SealInvalid(OpId, Txid, seals::txout::VerifyError), diff --git a/src/validation/validator.rs b/src/validation/validator.rs index 59fce04a..d033e828 100644 --- a/src/validation/validator.rs +++ b/src/validation/validator.rs @@ -22,20 +22,18 @@ use std::collections::{BTreeMap, BTreeSet, VecDeque}; -use bp::dbc::Anchor; use bp::seals::txout::{TxPtr, Witness}; -use bp::{Tx, Txid}; +use bp::{dbc, Tx, Txid}; use commit_verify::mpc; use single_use_seals::SealWitness; use super::status::{Failure, Warning}; use super::{ConsignmentApi, Status, Validity, VirtualMachine}; -use crate::contract::Opout; -use crate::validation::AnchoredBundle; use crate::vm::AluRuntime; use crate::{ - BundleId, ContractId, GraphSeal, OpId, OpRef, Operation, Schema, SchemaId, SchemaRoot, Script, - SealDefinition, SubSchema, Transition, TransitionBundle, TypedAssigns, + Anchor, AnchoredBundle, BundleId, ContractId, GraphSeal, Layer1, OpId, OpRef, Operation, Opout, + Schema, SchemaId, SchemaRoot, Script, SealDefinition, SubSchema, Transition, TransitionBundle, + TypedAssigns, }; #[derive(Clone, Debug, Display, Error, From)] @@ -48,7 +46,7 @@ pub enum TxResolverError { } pub trait ResolveTx { - fn resolve_tx(&self, txid: Txid) -> Result; + fn resolve_tx(&self, layer1: Layer1, txid: Txid) -> Result; } pub struct Validator<'consignment, 'resolver, C: ConsignmentApi, R: ResolveTx> { @@ -59,7 +57,7 @@ pub struct Validator<'consignment, 'resolver, C: ConsignmentApi, R: ResolveTx> { schema_id: SchemaId, genesis_id: OpId, contract_id: ContractId, - anchor_index: BTreeMap>, + anchor_index: BTreeMap, end_transitions: Vec<(&'consignment Transition, BundleId)>, validation_index: BTreeSet, anchor_validation_index: BTreeSet, @@ -82,7 +80,7 @@ impl<'consignment, 'resolver, C: ConsignmentApi, R: ResolveTx> let schema_id = consignment.genesis().schema_id; // Create indexes - let mut anchor_index = BTreeMap::>::new(); + let mut anchor_index = BTreeMap::::new(); for AnchoredBundle { ref anchor, ref bundle, @@ -217,6 +215,10 @@ impl<'consignment, 'resolver, C: ConsignmentApi, R: ResolveTx> // with a dedicated type for (operation, _) in &self.end_transitions { if let Some(anchor) = self.anchor_index.get(&operation.id()) { + let anchor = match anchor { + Anchor::Bitcoin(anchor) | Anchor::Liquid(anchor) => anchor, + }; + if let Some(pos) = self .status .failures @@ -286,10 +288,9 @@ impl<'consignment, 'resolver, C: ConsignmentApi, R: ResolveTx> // [VALIDATION]: Check that transition is committed into the anchor. // This must be done with deterministic bitcoin - // commitments & LNPBP-4. + // commitments & LNPBP-4. if anchor.convolve(self.contract_id, bundle_id.into()).is_err() { - self.status - .add_failure(Failure::NotInAnchor(opid, anchor.txid)); + self.status.add_failure(Failure::NotInAnchor(opid)); } self.validate_transition(transition, bundle_id, anchor); @@ -346,13 +347,17 @@ impl<'consignment, 'resolver, C: ConsignmentApi, R: ResolveTx> &mut self, transition: &'consignment Transition, bundle_id: BundleId, - anchor: &'consignment Anchor, + anchor: &'consignment Anchor, ) { + let (layer1, anchor) = match anchor { + Anchor::Bitcoin(a) | Anchor::Liquid(a) => (anchor.layer1(), a), + }; + let txid = anchor.txid; // Check that the anchor is committed into a transaction spending all of the // transition inputs. - match self.resolver.resolve_tx(txid) { + match self.resolver.resolve_tx(layer1, txid) { Err(_) => { // We wre unable to retrieve corresponding transaction, so can't check. // Reporting this incident and continuing further. Why this happens? No @@ -379,7 +384,7 @@ impl<'consignment, 'resolver, C: ConsignmentApi, R: ResolveTx> transition: &'consignment Transition, witness: Witness, bundle_id: BundleId, - anchor: &'consignment Anchor, + anchor: &'consignment dbc::Anchor, ) { let opid = transition.id(); let txid = witness.txid; @@ -426,14 +431,17 @@ impl<'consignment, 'resolver, C: ConsignmentApi, R: ResolveTx> txid: TxPtr::WitnessTx, .. }, - ) | + ), + Some(Anchor::Bitcoin(anchor)), + ) | + ( SealDefinition::Liquid( seal @ GraphSeal { txid: TxPtr::WitnessTx, .. }, ), - Some(anchor), + Some(Anchor::Liquid(anchor)), ) => { let prev_witness_txid = anchor.txid; seal.resolve(prev_witness_txid) @@ -447,15 +455,25 @@ impl<'consignment, 'resolver, C: ConsignmentApi, R: ResolveTx> txid: TxPtr::Txid(txid), .. }, - ) | + ), + Some(Anchor::Bitcoin(_)), + ) | + ( SealDefinition::Liquid( seal @ GraphSeal { txid: TxPtr::Txid(txid), .. }, ), - _, + Some(Anchor::Liquid(_)), ) => seal.resolve(txid), + (SealDefinition::Bitcoin(_) | SealDefinition::Liquid(_), Some(anchor)) => { + self.status.add_failure(Failure::SealWitnessLayer1Mismatch { + seal: seal.layer1(), + anchor: anchor.layer1(), + }); + continue; + } }; seals.push(seal); } diff --git a/stl/RGB@0.1.0.sta b/stl/RGB@0.1.0.sta index 6f34bb81..380038fe 100644 --- a/stl/RGB@0.1.0.sta +++ b/stl/RGB@0.1.0.sta @@ -1,248 +1,268 @@ -----BEGIN STRICT TYPE LIB----- -Id: urn:ubideco:stl:28ZcP9sj9SC5CC52qLWM9YxxRRhXAJjwRqD98nZLmx2y +Id: urn:ubideco:stl:DmN8aZj1dPvAvx5JYfz22azHs5RRbECxmxWoo5LK7E5f Name: RGB Dependencies: + urn:ubideco:stl:ZtHaBzu9ojbDahaGKEXe5v9DfSDxLERbLkEB23R6Q6V, urn:ubideco:stl:2YsxMW6xygK2FxFSbbBLqmzaUSytmLHHNF9DRio5zNr2, urn:ubideco:stl:5XLKQ1sNryZm9bdFKU2kBY3MPYdZXhchVdQKBbHA3gby, urn:ubideco:stl:6GgF7biXPVNcus2FfQj2pQuRzau11rXApMQLfCZhojgi, urn:ubideco:stl:9KALDYR8Nyjq4FdMW6kYoL7vdkWnqPqNuFnmE9qHpNjZ, urn:ubideco:stl:DVtm25LRKU4TjbyZmVxPhvCmctZ6vKkPKqfpU2QsDNUo -A1JHQgUXBk5pibwA035ABMB1qXDVJA6Hx9E0fiwbbm7GLsChNwZCUENvcmVDNAOU -2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByAtTdHJpY3RUeXBlc05OhPRwFsnl -0mJ8v8P0NrLdbNTRubBEW/9e74J2cndXB0JpdGNvaW57hIA8nvriESWnfCw5vHDS -/ej5Q64N/Zz05oLtx2bKcANTdGS5swegWqdWSYZDQm66Fgs/j4xo+ehP/c0thUAK -ee0PYAVBbHVWTQUFQWx1Vk0CAG3voSbhvHXh/0hL+4XBNNEMMtyMHkDgaUsc1qfr -3NxhB0xpYlNpdGWnMFUCLflcyPCJo0WiP5beUSnAE7cO8SfYIZBBlftTCgVMaWJJ -ZAZCUENvcmUFAAxQbJJJnFjzLy7sLFS41xZrvJgU7D6ZAkU9cS66YQnhDUJsaW5k -U2VhbFR4aWRoGeu81bMYq5ezmKVLNmXd2qcGb+jpJOcDYKmUs70GTgpTZWNyZXRT -ZWFsfrX4M3yRqm+4vZW7u8v14cUliUXSEXbaHtTcjMUxJWUOQmxpbmRTZWFsVHhQ -dHKx5Tg5FAo4vvBvGs++HGClb+Hh9H14CCh5v9H60xAh3QVUeFB0ctJSMHx9cZA1 -9zB+6Cgl7BuBK6GH3Z2YSYtKjRb6btVDC0Nsb3NlTWV0aG9kB0JpdGNvaW4DACHj -PkPFqlzyKSdTozjBZ+07Y5xN2c69qY80aRe6yUN1BFZvdXRS2isFLayiTrJNkcIh -faCRfc9eTfyHZJ8nodoZFEUJkwVDaGFpbqOCQvPL19HQoRLajeFgL1bU+G8OxMR2 -xcBoWUxLBGVWBFR4aWQDU3RkAQByjqaKl950IPYqWWmwS4cmBL9F1t84lZx+Juen -JJDkrQ5BbHBoYU51bUxvZGFzaAtTdHJpY3RUeXBlcw4AJGPav3xK8eqRIO+/gMLH -iaFXktTx+6MsWJgjsQ9pIfoJUHJpbWl0aXZlKNW5WFDcLVWM0Cgl05Fu3W7c8hc9 -ykB5gdchtv8EB1sHVmFyaWFudC5HWz5zyeAibY4sJ7oUs6olvm0o90d+LP2MTShe -GOxWClR5cGVTeXN0ZW0xn1SGkTd0Y/zuX2R7hvvMeznjjLEkkTadT8MjzkVTlBBW -YXJpYW50SW5mb1NlbUlkPf7O9epejJlIc9v8I3FIjZc0RH4GjkUBmIyK4nlrCeES -VW5pb25WYXJpYW50c1NlbUlkUrbOCeSLVr1+2gjSU/4ipCdadp5fXqtpJ408YqoO -zeMMRW51bVZhcmlhbnRzZIzUD7BrhqmPZ6HASc0GpcX2indA8B7xBeR+WBKH/U8S -VW5uYW1lZEZpZWxkc1NlbUlkZjs3H8FYcj98sA45lBoVGkW2FHCHUV3lK+tUKfxt -YcEQTmFtZWRGaWVsZHNTZW1JZGdWkBgTHbcpmp/Yg0iXm2gsqcEeRaKpbeNhC7Tg -xE+ACkZpZWxkU2VtSWRrBKMUnqaVABZnn+8CtKsk9ea3imTI2dC9ZfzXo1hOjQVT -ZW1JZHnhi2InWK4TAbvqB8SGn6w9UNmQEi8JpEn9P7P6he9rB1R5U2VtSWR9djJJ -9Q+7qVWrJHLyb2mPxeAJGoLpFBTbolDWJ2TH6AVJZGVudIHTLCTXw+gy2cNi/cj0 -j5CdP4covDJOTeRMoeGJmxkGBlNpemluZ6gU7Ciw7VXt7q5ReaTn5Z9As/lVFhBu -m8Euchq/flYcCUZpZWxkTmFtZToACUFsdExheWVyMQMDBmxpcXVpZAEHYWJyYXhh -cxAFcHJpbWURDEFsdExheWVyMVNldAUBAAkBsCg2ZxB6frvN7t0BXHE1tteKvzew -M19b8Hk9EMcio8sAAAAAAAAAAP8AAAAAAAAACUFsdVNjcmlwdAYCBGxpYnMACgK5 -swegWqdWSYZDQm66Fgs/j4xo+ehP/c0thUAKee0PYKcwVQIt+VzI8ImjRaI/lt5R -KcATtw7xJ9ghkEGV+1MKAAgAAEAAAAAAAAAAAP//AAAAAAAAAAAAAAAAAAD/AAAA -AAAAAAtlbnRyeVBvaW50cwAKAAcAAEADAAK5swegWqdWSYZDQm66Fgs/j4xo+ehP -/c0thUAKee0PYG3voSbhvHXh/0hL+4XBNNEMMtyMHkDgaUsc1qfr3NxhAAAAAAAA -AAD//wAAAAAAACJBc3NpZ25SZXZlYWxlZEF0dGFjaEJsaW5kU2VhbFR4UHRyBAQA -DGNvbmZpZGVudGlhbAAGAgRzZWFsAhcGTmmJvADTfkAEwHWpcNUkDofH0TR+LBtu -bsYuwKE3aBnrvNWzGKuXs5ilSzZl3dqnBm/o6STnA2CplLO9Bk4Fc3RhdGUB/DRF -3V/PDQv/rBWkeroFIuBbiysbMGVSh4OPey3rjj0BEWNvbmZpZGVudGlhbFN0YXRl +A1JHQgYIbJMpP1Zo7NnfnUB1CNehMyMWREFWAosurAm/5d+NQgxDb21taXRWZXJp +ZnkXBk5pibwA035ABMB1qXDVJA6Hx9E0fiwbbm7GLsChNwZCUENvcmVDNAOU2Bsw +4lIokCYe82/5+Kg5UZH1C2leIyoes7dByAtTdHJpY3RUeXBlc05OhPRwFsnl0mJ8 +v8P0NrLdbNTRubBEW/9e74J2cndXB0JpdGNvaW57hIA8nvriESWnfCw5vHDS/ej5 +Q64N/Zz05oLtx2bKcANTdGS5swegWqdWSYZDQm66Fgs/j4xo+ehP/c0thUAKee0P +YAVBbHVWTQYFQWx1Vk0CAG3voSbhvHXh/0hL+4XBNNEMMtyMHkDgaUsc1qfr3Nxh +B0xpYlNpdGWnMFUCLflcyPCJo0WiP5beUSnAE7cO8SfYIZBBlftTCgVMaWJJZAZC +UENvcmULAAF8B10AQEsWlZgbF8NhLca46q4Nf3BZYpIWdVrlGZMREVRhcHJldE5v +ZGVQYXJ0bmVyDFBskkmcWPMvLuwsVLjXFmu8mBTsPpkCRT1xLrphCeENQmxpbmRT +ZWFsVHhpZBPEU1JmJ7tEJYw7Z/TMwn7+/OQnt89eD/2Bjy9+e9h8D1RhcHJldFBh +dGhQcm9vZhsnOTSuR1bh68edIv32xtKl2Uju/UGtqXMLhoUO93kwC1RhcHJldFBy +b29mOD9iLnFT0sghkTzLdx2fPWTfdvIoVVkt+EZDlBZNbQURVGFwcmV0UmlnaHRC +cmFuY2hoGeu81bMYq5ezmKVLNmXd2qcGb+jpJOcDYKmUs70GTgpTZWNyZXRTZWFs +frX4M3yRqm+4vZW7u8v14cUliUXSEXbaHtTcjMUxJWUOQmxpbmRTZWFsVHhQdHKq +SsRo4n6UttYDKpadulb7XWWBXAl6UARwJe2IswOUvwVQcm9vZrHlODkUCji+8G8a +z74cYKVv4eH0fXgIKHm/0frTECHdBVR4UHRy0lIwfH1xkDX3MH7oKCXsG4EroYfd +nZhJi0qNFvpu1UMLQ2xvc2VNZXRob2Th0W5XqD5OSJpAa5BMLe+pMQAZmEa0NmHO +OFai1y4aahFBbmNob3JNZXJrbGVQcm9vZgdCaXRjb2luCAAh4z5Dxapc8iknU6M4 +wWftO2OcTdnOvamPNGkXuslDdQRWb3V0Jav1uRIUF7qjOdRfexV1p3FL4Xp1GF3Q +MTV61Mkt6YYLU2NyaXB0Qnl0ZXMxu67ohIl3xbAHMXIxzZL2MLYpLc2Jf9y63sW6 +xOl/2QtUYXBOb2RlSGFzaFLaKwUtrKJOsk2RwiF9oJF9z15N/Idknyeh2hkURQmT +BUNoYWluX6zZbeU/TsUU2bGNZ4DaCqvrLSYL/Tcto8B6pF05n00KTGVhZlNjcmlw +dKOCQvPL19HQoRLajeFgL1bU+G8OxMR2xcBoWUxLBGVWBFR4aWS2MwmpGL+2kg1u +yFikJIcjRlppP3JDB7//Hdc6c4FOyQdMZWFmVmVy3/gAPIH+R/xUI7HSxuIPDd+q +Zr3M8310E8kfZdoAPIgKSW50ZXJuYWxQawxDb21taXRWZXJpZnkCAC/uzx5E0qEp +uYoUOEdLOXGVKygcogGS1RMm+LI2YF5nC01lcmtsZVByb29mVY03B/hFhlOA7sxB +VSTopJlgUdOUgkPxlPfxkVcj6eYKTWVya2xlTm9kZQNTdGQBAHKOpoqX3nQg9ipZ +abBLhyYEv0XW3ziVnH4m56ckkOStDkFscGhhTnVtTG9kYXNoC1N0cmljdFR5cGVz +DgAkY9q/fErx6pEg77+AwseJoVeS1PH7oyxYmCOxD2kh+glQcmltaXRpdmUo1blY +UNwtVYzQKCXTkW7dbtzyFz3KQHmB1yG2/wQHWwdWYXJpYW50LkdbPnPJ4CJtjiwn +uhSzqiW+bSj3R34s/YxNKF4Y7FYKVHlwZVN5c3RlbTGfVIaRN3Rj/O5fZHuG+8x7 +OeOMsSSRNp1PwyPORVOUEFZhcmlhbnRJbmZvU2VtSWQ9/s716l6MmUhz2/wjcUiN +lzREfgaORQGYjIrieWsJ4RJVbmlvblZhcmlhbnRzU2VtSWRSts4J5ItWvX7aCNJT +/iKkJ1p2nl9eq2knjTxiqg7N4wxFbnVtVmFyaWFudHNkjNQPsGuGqY9nocBJzQal +xfaKd0DwHvEF5H5YEof9TxJVbm5hbWVkRmllbGRzU2VtSWRmOzcfwVhyP3ywDjmU +GhUaRbYUcIdRXeUr61Qp/G1hwRBOYW1lZEZpZWxkc1NlbUlkZ1aQGBMdtyman9iD +SJebaCypwR5Foqlt42ELtODET4AKRmllbGRTZW1JZGsEoxSeppUAFmef7wK0qyT1 +5reKZMjZ0L1l/NejWE6NBVNlbUlkeeGLYidYrhMBu+oHxIafrD1Q2ZASLwmkSf0/ +s/qF72sHVHlTZW1JZH12Mkn1D7upVaskcvJvaY/F4AkagukUFNuiUNYnZMfoBUlk +ZW50gdMsJNfD6DLZw2L9yPSPkJ0/hyi8Mk5N5Eyh4YmbGQYGU2l6aW5nqBTsKLDt +Ve3urlF5pOfln0Cz+VUWEG6bwS5yGr9+VhwJRmllbGROYW1lPAAJQWx0TGF5ZXIx +AwEGbGlxdWlkAQxBbHRMYXllcjFTZXQFAQAJAchrgnsLWn3GkQQkcuUiJ4/Qz8Ua +V2igSz+qMUAbPH4jAAAAAAAAAAD/AAAAAAAAAAlBbHVTY3JpcHQGAgRsaWJzAAoC +ubMHoFqnVkmGQ0JuuhYLP4+MaPnoT/3NLYVACnntD2CnMFUCLflcyPCJo0WiP5be +USnAE7cO8SfYIZBBlftTCgAIAABAAAAAAAAAAAD//wAAAAAAAAAAAAAAAAAA/wAA +AAAAAAALZW50cnlQb2ludHMACgAHAABAAwACubMHoFqnVkmGQ0JuuhYLP4+MaPno +T/3NLYVACnntD2Bt76Em4bx14f9IS/uFwTTRDDLcjB5A4GlLHNan69zcYQAAAAAA +AAAA//8AAAAAAAAGQW5jaG9yBAIAB2JpdGNvaW4ABQECFwZOaYm8ANN+QATAdalw +1SQOh8fRNH4sG25uxi7AoTfh0W5XqD5OSJpAa5BMLe+pMQAZmEa0NmHOOFai1y4a +agEGbGlxdWlkAAUBAhcGTmmJvADTfkAEwHWpcNUkDofH0TR+LBtubsYuwKE34dFu +V6g+TkiaQGuQTC3vqTEAGZhGtDZhzjhWotcuGmoOQW5jaG9yZWRCdW5kbGUGAgZh +bmNob3IBdb3qhJMVeLEhjGiDlgRn3guHZg12SkTX/5sPXSEWsT4GYnVuZGxlAeLY +yqPJCUdMB3aQUXhN2onJPBUjFToCB5YGb/OPLggzIkFzc2lnblJldmVhbGVkQXR0 +YWNoQmxpbmRTZWFsVHhQdHIEBAAMY29uZmlkZW50aWFsAAYCBHNlYWwCFwZOaYm8 +ANN+QATAdalw1SQOh8fRNH4sG25uxi7AoTdoGeu81bMYq5ezmKVLNmXd2qcGb+jp +JOcDYKmUs70GTgVzdGF0ZQH8NEXdX88NC/+sFaR6ugUi4FuLKxswZVKHg497LeuO +PQERY29uZmlkZW50aWFsU3RhdGUABgIEc2VhbAFMDmYSVmFZhisBqKRS0o8UoIW6 +bnAbqEA9zGIP4nat6AVzdGF0ZQH8NEXdX88NC/+sFaR6ugUi4FuLKxswZVKHg497 +LeuOPQIQY29uZmlkZW50aWFsU2VhbAAGAgRzZWFsAhcGTmmJvADTfkAEwHWpcNUk +DofH0TR+LBtubsYuwKE3aBnrvNWzGKuXs5ilSzZl3dqnBm/o6STnA2CplLO9Bk4F +c3RhdGUBaFM0IAzcU8ZNduK2LqpmL9o62ZG/BqspDrzQ9noDSswDCHJldmVhbGVk AAYCBHNlYWwBTA5mElZhWYYrAaikUtKPFKCFum5wG6hAPcxiD+J2regFc3RhdGUB -/DRF3V/PDQv/rBWkeroFIuBbiysbMGVSh4OPey3rjj0CEGNvbmZpZGVudGlhbFNl -YWwABgIEc2VhbAIXBk5pibwA035ABMB1qXDVJA6Hx9E0fiwbbm7GLsChN2gZ67zV -sxirl7OYpUs2Zd3apwZv6Okk5wNgqZSzvQZOBXN0YXRlAWhTNCAM3FPGTXbiti6q -Zi/aOtmRvwarKQ680PZ6A0rMAwhyZXZlYWxlZAAGAgRzZWFsAUwOZhJWYVmGKwGo -pFLSjxSghbpucBuoQD3MYg/idq3oBXN0YXRlAWhTNCAM3FPGTXbiti6qZi/aOtmR -vwarKQ680PZ6A0rMIUFzc2lnblJldmVhbGVkQXR0YWNoQmxpbmRTZWFsVHhpZAQE -AAxjb25maWRlbnRpYWwABgIEc2VhbAIXBk5pibwA035ABMB1qXDVJA6Hx9E0fiwb -bm7GLsChN2gZ67zVsxirl7OYpUs2Zd3apwZv6Okk5wNgqZSzvQZOBXN0YXRlAfw0 -Rd1fzw0L/6wVpHq6BSLgW4srGzBlUoeDj3st6449ARFjb25maWRlbnRpYWxTdGF0 -ZQAGAgRzZWFsASIoIpxDdj3Is0Ka4QJrcuNQ2XcvbOMujCmKBV9nV/IlBXN0YXRl -Afw0Rd1fzw0L/6wVpHq6BSLgW4srGzBlUoeDj3st6449AhBjb25maWRlbnRpYWxT -ZWFsAAYCBHNlYWwCFwZOaYm8ANN+QATAdalw1SQOh8fRNH4sG25uxi7AoTdoGeu8 -1bMYq5ezmKVLNmXd2qcGb+jpJOcDYKmUs70GTgVzdGF0ZQFoUzQgDNxTxk124rYu -qmYv2jrZkb8GqykOvND2egNKzAMIcmV2ZWFsZWQABgIEc2VhbAEiKCKcQ3Y9yLNC -muECa3LjUNl3L2zjLowpigVfZ1fyJQVzdGF0ZQFoUzQgDNxTxk124rYuqmYv2jrZ -kb8GqykOvND2egNKzCBBc3NpZ25SZXZlYWxlZERhdGFCbGluZFNlYWxUeFB0cgQE -AAxjb25maWRlbnRpYWwABgIEc2VhbAIXBk5pibwA035ABMB1qXDVJA6Hx9E0fiwb -bm7GLsChN2gZ67zVsxirl7OYpUs2Zd3apwZv6Okk5wNgqZSzvQZOBXN0YXRlAXAN -ZRCygoFvH7c95RJjkwNXCKVSYa0C4NS+WsXPp+oJARFjb25maWRlbnRpYWxTdGF0 -ZQAGAgRzZWFsAUwOZhJWYVmGKwGopFLSjxSghbpucBuoQD3MYg/idq3oBXN0YXRl -AXANZRCygoFvH7c95RJjkwNXCKVSYa0C4NS+WsXPp+oJAhBjb25maWRlbnRpYWxT -ZWFsAAYCBHNlYWwCFwZOaYm8ANN+QATAdalw1SQOh8fRNH4sG25uxi7AoTdoGeu8 -1bMYq5ezmKVLNmXd2qcGb+jpJOcDYKmUs70GTgVzdGF0ZQEg8lBWIo9mzvyR+upn -vF/G8GlcPUd5c1k/rNE3ynJIZQMIcmV2ZWFsZWQABgIEc2VhbAFMDmYSVmFZhisB -qKRS0o8UoIW6bnAbqEA9zGIP4nat6AVzdGF0ZQEg8lBWIo9mzvyR+upnvF/G8Glc -PUd5c1k/rNE3ynJIZR9Bc3NpZ25SZXZlYWxlZERhdGFCbGluZFNlYWxUeGlkBAQA -DGNvbmZpZGVudGlhbAAGAgRzZWFsAhcGTmmJvADTfkAEwHWpcNUkDofH0TR+LBtu -bsYuwKE3aBnrvNWzGKuXs5ilSzZl3dqnBm/o6STnA2CplLO9Bk4Fc3RhdGUBcA1l -ELKCgW8ftz3lEmOTA1cIpVJhrQLg1L5axc+n6gkBEWNvbmZpZGVudGlhbFN0YXRl +aFM0IAzcU8ZNduK2LqpmL9o62ZG/BqspDrzQ9noDSswhQXNzaWduUmV2ZWFsZWRB +dHRhY2hCbGluZFNlYWxUeGlkBAQADGNvbmZpZGVudGlhbAAGAgRzZWFsAhcGTmmJ +vADTfkAEwHWpcNUkDofH0TR+LBtubsYuwKE3aBnrvNWzGKuXs5ilSzZl3dqnBm/o +6STnA2CplLO9Bk4Fc3RhdGUB/DRF3V/PDQv/rBWkeroFIuBbiysbMGVSh4OPey3r +jj0BEWNvbmZpZGVudGlhbFN0YXRlAAYCBHNlYWwBIiginEN2PcizQprhAmty41DZ +dy9s4y6MKYoFX2dX8iUFc3RhdGUB/DRF3V/PDQv/rBWkeroFIuBbiysbMGVSh4OP +ey3rjj0CEGNvbmZpZGVudGlhbFNlYWwABgIEc2VhbAIXBk5pibwA035ABMB1qXDV +JA6Hx9E0fiwbbm7GLsChN2gZ67zVsxirl7OYpUs2Zd3apwZv6Okk5wNgqZSzvQZO +BXN0YXRlAWhTNCAM3FPGTXbiti6qZi/aOtmRvwarKQ680PZ6A0rMAwhyZXZlYWxl +ZAAGAgRzZWFsASIoIpxDdj3Is0Ka4QJrcuNQ2XcvbOMujCmKBV9nV/IlBXN0YXRl +AWhTNCAM3FPGTXbiti6qZi/aOtmRvwarKQ680PZ6A0rMIEFzc2lnblJldmVhbGVk +RGF0YUJsaW5kU2VhbFR4UHRyBAQADGNvbmZpZGVudGlhbAAGAgRzZWFsAhcGTmmJ +vADTfkAEwHWpcNUkDofH0TR+LBtubsYuwKE3aBnrvNWzGKuXs5ilSzZl3dqnBm/o +6STnA2CplLO9Bk4Fc3RhdGUBcA1lELKCgW8ftz3lEmOTA1cIpVJhrQLg1L5axc+n +6gkBEWNvbmZpZGVudGlhbFN0YXRlAAYCBHNlYWwBTA5mElZhWYYrAaikUtKPFKCF +um5wG6hAPcxiD+J2regFc3RhdGUBcA1lELKCgW8ftz3lEmOTA1cIpVJhrQLg1L5a +xc+n6gkCEGNvbmZpZGVudGlhbFNlYWwABgIEc2VhbAIXBk5pibwA035ABMB1qXDV +JA6Hx9E0fiwbbm7GLsChN2gZ67zVsxirl7OYpUs2Zd3apwZv6Okk5wNgqZSzvQZO +BXN0YXRlASDyUFYij2bO/JH66me8X8bwaVw9R3lzWT+s0TfKckhlAwhyZXZlYWxl +ZAAGAgRzZWFsAUwOZhJWYVmGKwGopFLSjxSghbpucBuoQD3MYg/idq3oBXN0YXRl +ASDyUFYij2bO/JH66me8X8bwaVw9R3lzWT+s0TfKckhlH0Fzc2lnblJldmVhbGVk +RGF0YUJsaW5kU2VhbFR4aWQEBAAMY29uZmlkZW50aWFsAAYCBHNlYWwCFwZOaYm8 +ANN+QATAdalw1SQOh8fRNH4sG25uxi7AoTdoGeu81bMYq5ezmKVLNmXd2qcGb+jp +JOcDYKmUs70GTgVzdGF0ZQFwDWUQsoKBbx+3PeUSY5MDVwilUmGtAuDUvlrFz6fq +CQERY29uZmlkZW50aWFsU3RhdGUABgIEc2VhbAEiKCKcQ3Y9yLNCmuECa3LjUNl3 +L2zjLowpigVfZ1fyJQVzdGF0ZQFwDWUQsoKBbx+3PeUSY5MDVwilUmGtAuDUvlrF +z6fqCQIQY29uZmlkZW50aWFsU2VhbAAGAgRzZWFsAhcGTmmJvADTfkAEwHWpcNUk +DofH0TR+LBtubsYuwKE3aBnrvNWzGKuXs5ilSzZl3dqnBm/o6STnA2CplLO9Bk4F +c3RhdGUBIPJQViKPZs78kfrqZ7xfxvBpXD1HeXNZP6zRN8pySGUDCHJldmVhbGVk AAYCBHNlYWwBIiginEN2PcizQprhAmty41DZdy9s4y6MKYoFX2dX8iUFc3RhdGUB -cA1lELKCgW8ftz3lEmOTA1cIpVJhrQLg1L5axc+n6gkCEGNvbmZpZGVudGlhbFNl -YWwABgIEc2VhbAIXBk5pibwA035ABMB1qXDVJA6Hx9E0fiwbbm7GLsChN2gZ67zV -sxirl7OYpUs2Zd3apwZv6Okk5wNgqZSzvQZOBXN0YXRlASDyUFYij2bO/JH66me8 -X8bwaVw9R3lzWT+s0TfKckhlAwhyZXZlYWxlZAAGAgRzZWFsASIoIpxDdj3Is0Ka -4QJrcuNQ2XcvbOMujCmKBV9nV/IlBXN0YXRlASDyUFYij2bO/JH66me8X8bwaVw9 -R3lzWT+s0TfKckhlIUFzc2lnblJldmVhbGVkVmFsdWVCbGluZFNlYWxUeFB0cgQE -AAxjb25maWRlbnRpYWwABgIEc2VhbAIXBk5pibwA035ABMB1qXDVJA6Hx9E0fiwb -bm7GLsChN2gZ67zVsxirl7OYpUs2Zd3apwZv6Okk5wNgqZSzvQZOBXN0YXRlAcJR -rWXpdQ2smhJZzMCFJFzV97FvUthyNkYs8XWMn05dARFjb25maWRlbnRpYWxTdGF0 -ZQAGAgRzZWFsAUwOZhJWYVmGKwGopFLSjxSghbpucBuoQD3MYg/idq3oBXN0YXRl -AcJRrWXpdQ2smhJZzMCFJFzV97FvUthyNkYs8XWMn05dAhBjb25maWRlbnRpYWxT -ZWFsAAYCBHNlYWwCFwZOaYm8ANN+QATAdalw1SQOh8fRNH4sG25uxi7AoTdoGeu8 -1bMYq5ezmKVLNmXd2qcGb+jpJOcDYKmUs70GTgVzdGF0ZQHsz3qHnB+tbzh8HtJ4 -icDg/bTe1DoykxzsLMusu9KsLQMIcmV2ZWFsZWQABgIEc2VhbAFMDmYSVmFZhisB -qKRS0o8UoIW6bnAbqEA9zGIP4nat6AVzdGF0ZQHsz3qHnB+tbzh8HtJ4icDg/bTe -1DoykxzsLMusu9KsLSBBc3NpZ25SZXZlYWxlZFZhbHVlQmxpbmRTZWFsVHhpZAQE -AAxjb25maWRlbnRpYWwABgIEc2VhbAIXBk5pibwA035ABMB1qXDVJA6Hx9E0fiwb -bm7GLsChN2gZ67zVsxirl7OYpUs2Zd3apwZv6Okk5wNgqZSzvQZOBXN0YXRlAcJR -rWXpdQ2smhJZzMCFJFzV97FvUthyNkYs8XWMn05dARFjb25maWRlbnRpYWxTdGF0 -ZQAGAgRzZWFsASIoIpxDdj3Is0Ka4QJrcuNQ2XcvbOMujCmKBV9nV/IlBXN0YXRl -AcJRrWXpdQ2smhJZzMCFJFzV97FvUthyNkYs8XWMn05dAhBjb25maWRlbnRpYWxT -ZWFsAAYCBHNlYWwCFwZOaYm8ANN+QATAdalw1SQOh8fRNH4sG25uxi7AoTdoGeu8 -1bMYq5ezmKVLNmXd2qcGb+jpJOcDYKmUs70GTgVzdGF0ZQHsz3qHnB+tbzh8HtJ4 -icDg/bTe1DoykxzsLMusu9KsLQMIcmV2ZWFsZWQABgIEc2VhbAEiKCKcQ3Y9yLNC -muECa3LjUNl3L2zjLowpigVfZ1fyJQVzdGF0ZQHsz3qHnB+tbzh8HtJ4icDg/bTe -1DoykxzsLMusu9KsLR1Bc3NpZ25Wb2lkU3RhdGVCbGluZFNlYWxUeFB0cgQEAAxj -b25maWRlbnRpYWwABgIEc2VhbAIXBk5pibwA035ABMB1qXDVJA6Hx9E0fiwbbm7G -LsChN2gZ67zVsxirl7OYpUs2Zd3apwZv6Okk5wNgqZSzvQZOBXN0YXRlAS6ypf4X -wDBEMJjgXJsbWmzWHu12DWHey4Am02TzFuG7ARFjb25maWRlbnRpYWxTdGF0ZQAG +IPJQViKPZs78kfrqZ7xfxvBpXD1HeXNZP6zRN8pySGUhQXNzaWduUmV2ZWFsZWRW +YWx1ZUJsaW5kU2VhbFR4UHRyBAQADGNvbmZpZGVudGlhbAAGAgRzZWFsAhcGTmmJ +vADTfkAEwHWpcNUkDofH0TR+LBtubsYuwKE3aBnrvNWzGKuXs5ilSzZl3dqnBm/o +6STnA2CplLO9Bk4Fc3RhdGUBwlGtZel1DayaElnMwIUkXNX3sW9S2HI2RizxdYyf +Tl0BEWNvbmZpZGVudGlhbFN0YXRlAAYCBHNlYWwBTA5mElZhWYYrAaikUtKPFKCF +um5wG6hAPcxiD+J2regFc3RhdGUBwlGtZel1DayaElnMwIUkXNX3sW9S2HI2Rizx +dYyfTl0CEGNvbmZpZGVudGlhbFNlYWwABgIEc2VhbAIXBk5pibwA035ABMB1qXDV +JA6Hx9E0fiwbbm7GLsChN2gZ67zVsxirl7OYpUs2Zd3apwZv6Okk5wNgqZSzvQZO +BXN0YXRlAezPeoecH61vOHwe0niJwOD9tN7UOjKTHOwsy6y70qwtAwhyZXZlYWxl +ZAAGAgRzZWFsAUwOZhJWYVmGKwGopFLSjxSghbpucBuoQD3MYg/idq3oBXN0YXRl +AezPeoecH61vOHwe0niJwOD9tN7UOjKTHOwsy6y70qwtIEFzc2lnblJldmVhbGVk +VmFsdWVCbGluZFNlYWxUeGlkBAQADGNvbmZpZGVudGlhbAAGAgRzZWFsAhcGTmmJ +vADTfkAEwHWpcNUkDofH0TR+LBtubsYuwKE3aBnrvNWzGKuXs5ilSzZl3dqnBm/o +6STnA2CplLO9Bk4Fc3RhdGUBwlGtZel1DayaElnMwIUkXNX3sW9S2HI2RizxdYyf +Tl0BEWNvbmZpZGVudGlhbFN0YXRlAAYCBHNlYWwBIiginEN2PcizQprhAmty41DZ +dy9s4y6MKYoFX2dX8iUFc3RhdGUBwlGtZel1DayaElnMwIUkXNX3sW9S2HI2Rizx +dYyfTl0CEGNvbmZpZGVudGlhbFNlYWwABgIEc2VhbAIXBk5pibwA035ABMB1qXDV +JA6Hx9E0fiwbbm7GLsChN2gZ67zVsxirl7OYpUs2Zd3apwZv6Okk5wNgqZSzvQZO +BXN0YXRlAezPeoecH61vOHwe0niJwOD9tN7UOjKTHOwsy6y70qwtAwhyZXZlYWxl +ZAAGAgRzZWFsASIoIpxDdj3Is0Ka4QJrcuNQ2XcvbOMujCmKBV9nV/IlBXN0YXRl +AezPeoecH61vOHwe0niJwOD9tN7UOjKTHOwsy6y70qwtHUFzc2lnblZvaWRTdGF0 +ZUJsaW5kU2VhbFR4UHRyBAQADGNvbmZpZGVudGlhbAAGAgRzZWFsAhcGTmmJvADT +fkAEwHWpcNUkDofH0TR+LBtubsYuwKE3aBnrvNWzGKuXs5ilSzZl3dqnBm/o6STn +A2CplLO9Bk4Fc3RhdGUBLrKl/hfAMEQwmOBcmxtabNYe7XYNYd7LgCbTZPMW4bsB +EWNvbmZpZGVudGlhbFN0YXRlAAYCBHNlYWwBTA5mElZhWYYrAaikUtKPFKCFum5w +G6hAPcxiD+J2regFc3RhdGUBLrKl/hfAMEQwmOBcmxtabNYe7XYNYd7LgCbTZPMW +4bsCEGNvbmZpZGVudGlhbFNlYWwABgIEc2VhbAIXBk5pibwA035ABMB1qXDVJA6H +x9E0fiwbbm7GLsChN2gZ67zVsxirl7OYpUs2Zd3apwZv6Okk5wNgqZSzvQZOBXN0 +YXRlAS6ypf4XwDBEMJjgXJsbWmzWHu12DWHey4Am02TzFuG7AwhyZXZlYWxlZAAG AgRzZWFsAUwOZhJWYVmGKwGopFLSjxSghbpucBuoQD3MYg/idq3oBXN0YXRlAS6y -pf4XwDBEMJjgXJsbWmzWHu12DWHey4Am02TzFuG7AhBjb25maWRlbnRpYWxTZWFs -AAYCBHNlYWwCFwZOaYm8ANN+QATAdalw1SQOh8fRNH4sG25uxi7AoTdoGeu81bMY -q5ezmKVLNmXd2qcGb+jpJOcDYKmUs70GTgVzdGF0ZQEusqX+F8AwRDCY4FybG1ps -1h7tdg1h3suAJtNk8xbhuwMIcmV2ZWFsZWQABgIEc2VhbAFMDmYSVmFZhisBqKRS -0o8UoIW6bnAbqEA9zGIP4nat6AVzdGF0ZQEusqX+F8AwRDCY4FybG1ps1h7tdg1h -3suAJtNk8xbhuxxBc3NpZ25Wb2lkU3RhdGVCbGluZFNlYWxUeGlkBAQADGNvbmZp -ZGVudGlhbAAGAgRzZWFsAhcGTmmJvADTfkAEwHWpcNUkDofH0TR+LBtubsYuwKE3 -aBnrvNWzGKuXs5ilSzZl3dqnBm/o6STnA2CplLO9Bk4Fc3RhdGUBLrKl/hfAMEQw -mOBcmxtabNYe7XYNYd7LgCbTZPMW4bsBEWNvbmZpZGVudGlhbFN0YXRlAAYCBHNl +pf4XwDBEMJjgXJsbWmzWHu12DWHey4Am02TzFuG7HEFzc2lnblZvaWRTdGF0ZUJs +aW5kU2VhbFR4aWQEBAAMY29uZmlkZW50aWFsAAYCBHNlYWwCFwZOaYm8ANN+QATA +dalw1SQOh8fRNH4sG25uxi7AoTdoGeu81bMYq5ezmKVLNmXd2qcGb+jpJOcDYKmU +s70GTgVzdGF0ZQEusqX+F8AwRDCY4FybG1ps1h7tdg1h3suAJtNk8xbhuwERY29u +ZmlkZW50aWFsU3RhdGUABgIEc2VhbAEiKCKcQ3Y9yLNCmuECa3LjUNl3L2zjLowp +igVfZ1fyJQVzdGF0ZQEusqX+F8AwRDCY4FybG1ps1h7tdg1h3suAJtNk8xbhuwIQ +Y29uZmlkZW50aWFsU2VhbAAGAgRzZWFsAhcGTmmJvADTfkAEwHWpcNUkDofH0TR+ +LBtubsYuwKE3aBnrvNWzGKuXs5ilSzZl3dqnBm/o6STnA2CplLO9Bk4Fc3RhdGUB +LrKl/hfAMEQwmOBcmxtabNYe7XYNYd7LgCbTZPMW4bsDCHJldmVhbGVkAAYCBHNl YWwBIiginEN2PcizQprhAmty41DZdy9s4y6MKYoFX2dX8iUFc3RhdGUBLrKl/hfA -MEQwmOBcmxtabNYe7XYNYd7LgCbTZPMW4bsCEGNvbmZpZGVudGlhbFNlYWwABgIE -c2VhbAIXBk5pibwA035ABMB1qXDVJA6Hx9E0fiwbbm7GLsChN2gZ67zVsxirl7OY -pUs2Zd3apwZv6Okk5wNgqZSzvQZOBXN0YXRlAS6ypf4XwDBEMJjgXJsbWmzWHu12 -DWHey4Am02TzFuG7AwhyZXZlYWxlZAAGAgRzZWFsASIoIpxDdj3Is0Ka4QJrcuNQ -2XcvbOMujCmKBV9nV/IlBXN0YXRlAS6ypf4XwDBEMJjgXJsbWmzWHu12DWHey4Am -02TzFuG7GUFzc2lnbm1lbnRzQmxpbmRTZWFsVHhQdHIFAQAKAAACAXnrMHagYzXd -WTfXzI9eqDaCZaT2GUeP1YaqS4r25dPRAAAAAAAAAAD/AAAAAAAAABhBc3NpZ25t -ZW50c0JsaW5kU2VhbFR4aWQFAQAKAAACAczZPF7dYDyIiXmdJlXUp5vepvBgmQqY -bkZ4Bg1jFaPyAAAAAAAAAAD/AAAAAAAAAAhBdHRhY2hJZAUBAAcAAEAgAA5CbGlu -ZGluZ0ZhY3RvcgUBAAcAAEAgAApCdW5kbGVJdGVtBgIGaW5wdXRzAAkAAAIAAAAA -AAAAAP8AAAAAAAAACnRyYW5zaXRpb24ABAIABG5vbmUAAAABBHNvbWUABQEBcmr+ -7Ay8HZrJPtMwfmqqRth7cpvC6emZW8QSfgsMlRMPQ29uY2VhbGVkQXR0YWNoBQEA -BwAAQCAADUNvbmNlYWxlZERhdGEFAQAHAABAIAARQ29uY2VhbGVkRnVuZ2libGUG -Agpjb21taXRtZW50AUi9Gm4X+4Y7Fnx+JV41Z9uCQ+8qXrrrosUKzQmunlEaCnJh -bmdlUHJvb2YBqFhr+JFl2sIjEG29hcSGyTfmsGbrDGZB/xYvaKh3pZgKQ29udHJh -Y3RJZAUBAAcAAEAgAAlFeHRlbnNpb24GCANmZnYB2ptRE1gWVnaQh/uZ5VaUcjaA -1zkMBqHMJJgsBWT3zNUKY29udHJhY3RJZAGfCCxJOsgCorrF3dwLInwgr5TUaMRI -zxpaIeC9wvU6Mg1leHRlbnNpb25UeXBlAAACCG1ldGFkYXRhAAgAAEAAAAAAAAAA -AP//AAAAAAAAB2dsb2JhbHMB62+KkPa4xXkjBFZKvDL2fHjgUIU6pgieDE4dPteQ -V5ULYXNzaWdubWVudHMBaCKy8llRSOK9MgrA0zzDFssnIn4NrpMyh3YCculEwwsI -cmVkZWVtZWQBgQT0DBB8gi3nW4y4nz1Kuk5kbRnE3TlUnv8Fg3EDYaIJdmFsZW5j -aWVzAbDghaeHNvIG8cyvMVh4BgOJie/iUTwW/GRSklMPxAd/D0V4dGVuc2lvblNj -aGVtYQYFCG1ldGFkYXRhAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HI -awSjFJ6mlQAWZ5/vArSrJPXmt4pkyNnQvWX816NYTo0HZ2xvYmFscwAKAAACATbB -NKH6oIETp90wgDxesPLC/doUsNWj1pPDbp4PMqp5AAAAAAAAAAD/AAAAAAAAAAdy -ZWRlZW1zAAkAAAIAAAAAAAAAAP8AAAAAAAAAC2Fzc2lnbm1lbnRzAAoAAAIBNsE0 -ofqggROn3TCAPF6w8sL92hSw1aPWk8Nung8yqnkAAAAAAAAAAP8AAAAAAAAACXZh -bGVuY2llcwAJAAACAAAAAAAAAAD/AAAAAAAAAANGZnYFAQAAAg1GdW5naWJsZVN0 -YXRlBAEIBmJpdHM2NAAFAQAACAxGdW5naWJsZVR5cGUDAQ11bnNpZ25lZDY0Qml0 -CAdHZW5lc2lzBggDZmZ2AdqbURNYFlZ2kIf7meVWlHI2gNc5DAahzCSYLAVk98zV -CHNjaGVtYUlkAZRS09sDq6uoUZ+n9j7QFOvUTX0xP/z+APpdJHpUBJAQBWNoYWlu -Ak5OhPRwFsnl0mJ8v8P0NrLdbNTRubBEW/9e74J2cndXUtorBS2sok6yTZHCIX2g -kX3PXk38h2SfJ6HaGRRFCZMJYWx0TGF5ZXIxAdT1BLaZSaWJTxHCelHDvsjcFbpE -/lnXz1HKjzPpEJxmCG1ldGFkYXRhAAgAAEAAAAAAAAAAAP//AAAAAAAAB2dsb2Jh -bHMB62+KkPa4xXkjBFZKvDL2fHjgUIU6pgieDE4dPteQV5ULYXNzaWdubWVudHMB -aCKy8llRSOK9MgrA0zzDFssnIn4NrpMyh3YCculEwwsJdmFsZW5jaWVzAbDghaeH -NvIG8cyvMVh4BgOJie/iUTwW/GRSklMPxAd/DUdlbmVzaXNTY2hlbWEGBAhtZXRh -ZGF0YQJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByGsEoxSeppUAFmef -7wK0qyT15reKZMjZ0L1l/NejWE6NB2dsb2JhbHMACgAAAgE2wTSh+qCBE6fdMIA8 -XrDywv3aFLDVo9aTw26eDzKqeQAAAAAAAAAA/wAAAAAAAAALYXNzaWdubWVudHMA -CgAAAgE2wTSh+qCBE6fdMIA8XrDywv3aFLDVo9aTw26eDzKqeQAAAAAAAAAA/wAA -AAAAAAAJdmFsZW5jaWVzAAkAAAIAAAAAAAAAAP8AAAAAAAAAC0dsb2JhbFN0YXRl -BQEACgAAAgFGNH2lHu1oDF77by+mxG/p2cNS74mOKbKURqaNxqBepgAAAAAAAAAA -/wAAAAAAAAARR2xvYmFsU3RhdGVTY2hlbWEGAgVzZW1JZAJDNAOU2Bsw4lIokCYe -82/5+Kg5UZH1C2leIyoes7dByGsEoxSeppUAFmef7wK0qyT15reKZMjZ0L1l/Nej -WE6NCG1heEl0ZW1zAAACDEdsb2JhbFZhbHVlcwUBAAgBIPJQViKPZs78kfrqZ7xf -xvBpXD1HeXNZP6zRN8pySGUBAAAAAAAAAP//AAAAAAAABUlucHV0BgIHcHJldk91 -dAGmsI79/BtduyJQUvNpWWmN3agARvVayqNy5X6b3EVH1AhyZXNlcnZlZAFFKqVf -fdYBSouhbcRmMrYP8bVs3DpTLs+9a5PVZxmeiQZJbnB1dHMFAQAJAT5ap2Bt7Z28 -AxSnM5fEZAzBmv9RgIbdTnpq0AlwE1QrAAAAAAAAAAD/AAAAAAAAAAlNZWRpYVR5 -cGUDAQNhbnn/CU5vaXNlRHVtYgUBAAcAAEAAAgtPY2N1cnJlbmNlcwYCA21pbgAA -AgNtYXgAAAIET3BJZAUBAAcAAEAgAAVPcG91dAYDAm9wAZXI5noedWJf1JZVQmqR -635CkKFvWpjxvlD3tookEvfFAnR5AAACAm5vAAACElBlZGVyc2VuQ29tbWl0bWVu -dAUBAAcAAEAhAApSYW5nZVByb29mBAH/C3BsYWNlaG9sZGVyAAUBAR52F/Enfds+ -u+FqD3IRt23tVd9vQw1VEV8DeCelQlcnCFJlZGVlbWVkBQEACgAAAgGVyOZ6HnVi -X9SWVUJqket+QpChb1qY8b5Q97aKJBL3xQAAAAAAAAAA/wAAAAAAAAAMUmVzZXJ2 -ZWRCeXRlBQEAAAEOUmV2ZWFsZWRBdHRhY2gGAwJpZAGEcQ2TLE70w7cIS2mLsIdw -KX45ZCR/RZHY2oNt0X26OAltZWRpYVR5cGUBQjBhhYjI1KsUJkDH/ckXLM3Q/xD/ -DZOAAER8iJrdzHkEc2FsdAAACAxSZXZlYWxlZERhdGEFAQAIAABAAAAAAAAAAAD/ -/wAAAAAAABBSZXZlYWxlZEZ1bmdpYmxlBgIFdmFsdWUBpowwkUdLyjrCYozHlUSN -LN2qxRSfBTOVq/Y8VWEHFyYIYmxpbmRpbmcBhbj4K7v0pKYNs78/RbgPlG54g8Ot -Um2T9G+jAahuR9oGU2NoZW1hBgoDZmZ2AdqbURNYFlZ2kIf7meVWlHI2gNc5DAah -zCSYLAVk98zVCHN1YnNldE9mAAQCAARub25lAAAAAQRzb21lAAUBAAAAC2dsb2Jh -bFR5cGVzAAoAAAIBx5im2GM2eEQe2lFuLD6Lvw6osEqAwbcduely5j9x5iQAAAAA -AAAAAP8AAAAAAAAACm93bmVkVHlwZXMACgAAAgE4yhTghSLH4zmCRpSyw5lYdVOm -6MoMDuHolYm6iXcb8wAAAAAAAAAA/wAAAAAAAAAMdmFsZW5jeVR5cGVzAAkAAAIA -AAAAAAAAAP8AAAAAAAAAB2dlbmVzaXMBm5QN7zOQn58O7smhw3YQQhn+ZLZIpBLA -OnSvAEKc6OQKZXh0ZW5zaW9ucwAKAAACASOei7XZDLpQUzMkAyGW+6Qj8vPze9UG -FZPgE1iWMcr7AAAAAAAAAAD/AAAAAAAAAAt0cmFuc2l0aW9ucwAKAAACAXXHIeCG -P9woM6VBTC3sjyIxTvYyYDEtpwTmXO3YxGdMAAAAAAAAAAD/AAAAAAAAAAp0eXBl -U3lzdGVtAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HILkdbPnPJ4CJt -jiwnuhSzqiW+bSj3R34s/YxNKF4Y7FYGc2NyaXB0AcYYY3tnTQy0vKnAQ11/MmKD -mHhzdCdD0TflRPu6EtBMCFNjaGVtYUlkBQEABwAAQCAADFNjaGVtYVNjaGVtYQYK -A2ZmdgHam1ETWBZWdpCH+5nlVpRyNoDXOQwGocwkmCwFZPfM1QhzdWJzZXRPZgAE -AgAEbm9uZQAAAAEEc29tZQAFAQGwzkKTm4xhAgglqQno7zlFxAxDytpPPMus3NlY -cGE5hQtnbG9iYWxUeXBlcwAKAAACAceYpthjNnhEHtpRbiw+i78OqLBKgMG3Hbnp -cuY/ceYkAAAAAAAAAAD/AAAAAAAAAApvd25lZFR5cGVzAAoAAAIBOMoU4IUix+M5 -gkaUssOZWHVTpujKDA7h6JWJuol3G/MAAAAAAAAAAP8AAAAAAAAADHZhbGVuY3lU -eXBlcwAJAAACAAAAAAAAAAD/AAAAAAAAAAdnZW5lc2lzAZuUDe8zkJ+fDu7JocN2 -EEIZ/mS2SKQSwDp0rwBCnOjkCmV4dGVuc2lvbnMACgAAAgEjnou12Qy6UFMzJAMh -lvukI/Lz83vVBhWT4BNYljHK+wAAAAAAAAAA/wAAAAAAAAALdHJhbnNpdGlvbnMA -CgAAAgF1xyHghj/cKDOlQUwt7I8iMU72MmAxLacE5lzt2MRnTAAAAAAAAAAA/wAA -AAAAAAAKdHlwZVN5c3RlbQJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dB -yC5HWz5zyeAibY4sJ7oUs6olvm0o90d+LP2MTSheGOxWBnNjcmlwdAHGGGN7Z00M -tLypwENdfzJig5h4c3QnQ9E35UT7uhLQTAZTY3JpcHQEAQAFYWx1Vm0ABQEBovrq -nnBcnJHM291G7Y9w5Y71FIM+yD5cZLVqW8NTrbAcU2VhbERlZmluaXRpb25CbGlu -ZFNlYWxUeFB0cgQCAAdiaXRjb2luAAUBAhcGTmmJvADTfkAEwHWpcNUkDofH0TR+ -LBtubsYuwKE3frX4M3yRqm+4vZW7u8v14cUliUXSEXbaHtTcjMUxJWUBBmxpcXVp -ZAAFAQIXBk5pibwA035ABMB1qXDVJA6Hx9E0fiwbbm7GLsChN361+DN8kapvuL2V -u7vL9eHFJYlF0hF22h7U3IzFMSVlG1NlYWxEZWZpbml0aW9uQmxpbmRTZWFsVHhp -ZAQCAAdiaXRjb2luAAUBAhcGTmmJvADTfkAEwHWpcNUkDofH0TR+LBtubsYuwKE3 -DFBskkmcWPMvLuwsVLjXFmu8mBTsPpkCRT1xLrphCeEBBmxpcXVpZAAFAQIXBk5p -ibwA035ABMB1qXDVJA6Hx9E0fiwbbm7GLsChNwxQbJJJnFjzLy7sLFS41xZrvJgU -7D6ZAkU9cS66YQnhC1N0YXRlU2NoZW1hBAQAC2RlY2xhcmF0aXZlAAAAAQhmdW5n -aWJsZQAFAQH59KwIZq5Bd2bU/QwRfQSx2VT9DmdeEjtiBOtxT+nlRgIKc3RydWN0 -dXJlZAAFAQJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByGsEoxSeppUA -Fmef7wK0qyT15reKZMjZ0L1l/NejWE6NAwphdHRhY2htZW50AAUBAUIwYYWIyNSr -FCZAx/3JFyzN0P8Q/w2TgABEfIia3cx5ClRyYW5zaXRpb24GCANmZnYB2ptRE1gW -VnaQh/uZ5VaUcjaA1zkMBqHMJJgsBWT3zNUKY29udHJhY3RJZAGfCCxJOsgCorrF -3dwLInwgr5TUaMRIzxpaIeC9wvU6Mg50cmFuc2l0aW9uVHlwZQAAAghtZXRhZGF0 -YQAIAABAAAAAAAAAAAD//wAAAAAAAAdnbG9iYWxzAetvipD2uMV5IwRWSrwy9nx4 -4FCFOqYIngxOHT7XkFeVBmlucHV0cwFaX9oXbyoy58+YADITLy6YdgaX++L/qrjV -Q09cyFPGbAthc3NpZ25tZW50cwHCuvewCwgWKAedUG/QjybA6AOiuHPowUo6v7SP -Jbj9QQl2YWxlbmNpZXMBsOCFp4c28gbxzK8xWHgGA4mJ7+JRPBb8ZFKSUw/EB38Q -VHJhbnNpdGlvbkJ1bmRsZQUBAAoBlcjmeh51Yl/UllVCapHrfkKQoW9amPG+UPe2 -iiQS98UBZ5eezUsO3SmECPXJzF5TkmFk1s8xolN6Luc4CVzbCKAAAAAAAAAAAP8A -AAAAAAAAEFRyYW5zaXRpb25TY2hlbWEGBQhtZXRhZGF0YQJDNAOU2Bsw4lIokCYe -82/5+Kg5UZH1C2leIyoes7dByGsEoxSeppUAFmef7wK0qyT15reKZMjZ0L1l/Nej -WE6NB2dsb2JhbHMACgAAAgE2wTSh+qCBE6fdMIA8XrDywv3aFLDVo9aTw26eDzKq -eQAAAAAAAAAA/wAAAAAAAAAGaW5wdXRzAAoAAAIBNsE0ofqggROn3TCAPF6w8sL9 -2hSw1aPWk8Nung8yqnkAAAAAAAAAAP8AAAAAAAAAC2Fzc2lnbm1lbnRzAAoAAAIB -NsE0ofqggROn3TCAPF6w8sL92hSw1aPWk8Nung8yqnkAAAAAAAAAAP8AAAAAAAAA -CXZhbGVuY2llcwAJAAACAAAAAAAAAAD/AAAAAAAAABpUeXBlZEFzc2lnbnNCbGlu -ZFNlYWxUeFB0cgQEAAtkZWNsYXJhdGl2ZQAFAQAIASlmLu7+YHlscLtafG2Pcozo -6kvLU/N6TMuVk2gImp7uAAAAAAAAAAD//wAAAAAAAAEIZnVuZ2libGUABQEACAFL -SRG2x4jTs6qG/MVTVjz9mirxuAfG5sef6XtWmQ8QsQAAAAAAAAAA//8AAAAAAAAC -CnN0cnVjdHVyZWQABQEACAFZolHNjebLiSRE7c91W7GqpdwcP9rBNM1sJTbV9hOK -wgAAAAAAAAAA//8AAAAAAAD/CmF0dGFjaG1lbnQABQEACAH7zBd2FTkXpjSm4b7g -Ht0r3GK/r4la5XU5cv8qQZfYgAAAAAAAAAAA//8AAAAAAAAZVHlwZWRBc3NpZ25z -QmxpbmRTZWFsVHhpZAQEAAtkZWNsYXJhdGl2ZQAFAQAIAZjmCNUpvD8wzk9MqgCs -LOdH/s86QuxysgqCwL4CEwKJAAAAAAAAAAD//wAAAAAAAAEIZnVuZ2libGUABQEA -CAF/bNH54DeCyZUq/Co3RTZAa4Zaz3o4XneDyeDI1eOA/QAAAAAAAAAA//8AAAAA -AAACCnN0cnVjdHVyZWQABQEACAE+3J1wNEPkBuDqB11Dgy/Nr1/LVPO0gJ1pu+1/ -YKRBowAAAAAAAAAA//8AAAAAAAD/CmF0dGFjaG1lbnQABQEACAEP+aNjbGPkkqop -cG754NrtT7ZHuV77qjvpdbNGEwz2fAAAAAAAAAAA//8AAAAAAAAJVmFsZW5jaWVz -BQEACQAAAgAAAAAAAAAA/wAAAAAAAAAJVm9pZFN0YXRlBQEAAAA= +MEQwmOBcmxtabNYe7XYNYd7LgCbTZPMW4bsZQXNzaWdubWVudHNCbGluZFNlYWxU +eFB0cgUBAAoAAAIBeeswdqBjNd1ZN9fMj16oNoJlpPYZR4/VhqpLivbl09EAAAAA +AAAAAP8AAAAAAAAAGEFzc2lnbm1lbnRzQmxpbmRTZWFsVHhpZAUBAAoAAAIBzNk8 +Xt1gPIiJeZ0mVdSnm96m8GCZCphuRngGDWMVo/IAAAAAAAAAAP8AAAAAAAAACEF0 +dGFjaElkBQEABwAAQCAADkJsaW5kaW5nRmFjdG9yBQEABwAAQCAACkJ1bmRsZUl0 +ZW0GAgZpbnB1dHMACQAAAgAAAAAAAAAA/wAAAAAAAAAKdHJhbnNpdGlvbgAEAgAE +bm9uZQAAAAEEc29tZQAFAQFyav7sDLwdmsk+0zB+aqpG2Htym8Lp6ZlbxBJ+CwyV +Ew9Db25jZWFsZWRBdHRhY2gFAQAHAABAIAANQ29uY2VhbGVkRGF0YQUBAAcAAEAg +ABFDb25jZWFsZWRGdW5naWJsZQYCCmNvbW1pdG1lbnQBSL0abhf7hjsWfH4lXjVn +24JD7ypeuuuixQrNCa6eURoKcmFuZ2VQcm9vZgGoWGv4kWXawiMQbb2FxIbJN+aw +ZusMZkH/Fi9oqHelmApDb250cmFjdElkBQEABwAAQCAACUV4dGVuc2lvbgYIA2Zm +dgHam1ETWBZWdpCH+5nlVpRyNoDXOQwGocwkmCwFZPfM1Qpjb250cmFjdElkAZ8I +LEk6yAKiusXd3AsifCCvlNRoxEjPGloh4L3C9ToyDWV4dGVuc2lvblR5cGUAAAII +bWV0YWRhdGEACAAAQAAAAAAAAAAA//8AAAAAAAAHZ2xvYmFscwHrb4qQ9rjFeSME +Vkq8MvZ8eOBQhTqmCJ4MTh0+15BXlQthc3NpZ25tZW50cwFoIrLyWVFI4r0yCsDT +PMMWyycifg2ukzKHdgJy6UTDCwhyZWRlZW1lZAGBBPQMEHyCLedbjLifPUq6TmRt +GcTdOVSe/wWDcQNhogl2YWxlbmNpZXMBsOCFp4c28gbxzK8xWHgGA4mJ7+JRPBb8 +ZFKSUw/EB38PRXh0ZW5zaW9uU2NoZW1hBgUIbWV0YWRhdGECQzQDlNgbMOJSKJAm +HvNv+fioOVGR9QtpXiMqHrO3QchrBKMUnqaVABZnn+8CtKsk9ea3imTI2dC9ZfzX +o1hOjQdnbG9iYWxzAAoAAAIBNsE0ofqggROn3TCAPF6w8sL92hSw1aPWk8Nung8y +qnkAAAAAAAAAAP8AAAAAAAAAB3JlZGVlbXMACQAAAgAAAAAAAAAA/wAAAAAAAAAL +YXNzaWdubWVudHMACgAAAgE2wTSh+qCBE6fdMIA8XrDywv3aFLDVo9aTw26eDzKq +eQAAAAAAAAAA/wAAAAAAAAAJdmFsZW5jaWVzAAkAAAIAAAAAAAAAAP8AAAAAAAAA +A0ZmdgUBAAACDUZ1bmdpYmxlU3RhdGUEAQgGYml0czY0AAUBAAAIDEZ1bmdpYmxl +VHlwZQMBDXVuc2lnbmVkNjRCaXQIB0dlbmVzaXMGCANmZnYB2ptRE1gWVnaQh/uZ +5VaUcjaA1zkMBqHMJJgsBWT3zNUIc2NoZW1hSWQBlFLT2wOrq6hRn6f2PtAU69RN +fTE//P4A+l0kelQEkBAFY2hhaW4CTk6E9HAWyeXSYny/w/Q2st1s1NG5sERb/17v +gnZyd1dS2isFLayiTrJNkcIhfaCRfc9eTfyHZJ8nodoZFEUJkwlhbHRMYXllcjEB +JFdS2GWA8JzKaiM3VBJEIGB8oyx/7szxFBAAbwoJKowIbWV0YWRhdGEACAAAQAAA +AAAAAAAA//8AAAAAAAAHZ2xvYmFscwHrb4qQ9rjFeSMEVkq8MvZ8eOBQhTqmCJ4M +Th0+15BXlQthc3NpZ25tZW50cwFoIrLyWVFI4r0yCsDTPMMWyycifg2ukzKHdgJy +6UTDCwl2YWxlbmNpZXMBsOCFp4c28gbxzK8xWHgGA4mJ7+JRPBb8ZFKSUw/EB38N +R2VuZXNpc1NjaGVtYQYECG1ldGFkYXRhAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfUL +aV4jKh6zt0HIawSjFJ6mlQAWZ5/vArSrJPXmt4pkyNnQvWX816NYTo0HZ2xvYmFs +cwAKAAACATbBNKH6oIETp90wgDxesPLC/doUsNWj1pPDbp4PMqp5AAAAAAAAAAD/ +AAAAAAAAAAthc3NpZ25tZW50cwAKAAACATbBNKH6oIETp90wgDxesPLC/doUsNWj +1pPDbp4PMqp5AAAAAAAAAAD/AAAAAAAAAAl2YWxlbmNpZXMACQAAAgAAAAAAAAAA +/wAAAAAAAAALR2xvYmFsU3RhdGUFAQAKAAACAUY0faUe7WgMXvtvL6bEb+nZw1Lv +iY4pspRGpo3GoF6mAAAAAAAAAAD/AAAAAAAAABFHbG9iYWxTdGF0ZVNjaGVtYQYC +BXNlbUlkAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HIawSjFJ6mlQAW +Z5/vArSrJPXmt4pkyNnQvWX816NYTo0IbWF4SXRlbXMAAAIMR2xvYmFsVmFsdWVz +BQEACAEg8lBWIo9mzvyR+upnvF/G8GlcPUd5c1k/rNE3ynJIZQEAAAAAAAAA//8A +AAAAAAAFSW5wdXQGAgdwcmV2T3V0Aaawjv38G127IlBS82lZaY3dqABG9VrKo3Ll +fpvcRUfUCHJlc2VydmVkAUUqpV991gFKi6FtxGYytg/xtWzcOlMuz71rk9VnGZ6J +BklucHV0cwUBAAkBPlqnYG3tnbwDFKczl8RkDMGa/1GAht1OemrQCXATVCsAAAAA +AAAAAP8AAAAAAAAACU1lZGlhVHlwZQMBA2Fuef8JTm9pc2VEdW1iBQEABwAAQAAC +C09jY3VycmVuY2VzBgIDbWluAAACA21heAAAAgRPcElkBQEABwAAQCAABU9wb3V0 +BgMCb3ABlcjmeh51Yl/UllVCapHrfkKQoW9amPG+UPe2iiQS98UCdHkAAAICbm8A +AAISUGVkZXJzZW5Db21taXRtZW50BQEABwAAQCEAClJhbmdlUHJvb2YEAf8LcGxh +Y2Vob2xkZXIABQEBHnYX8Sd92z674WoPchG3be1V329DDVURXwN4J6VCVycIUmVk +ZWVtZWQFAQAKAAACAZXI5noedWJf1JZVQmqR635CkKFvWpjxvlD3tookEvfFAAAA +AAAAAAD/AAAAAAAAAAxSZXNlcnZlZEJ5dGUFAQAAAQ5SZXZlYWxlZEF0dGFjaAYD +AmlkAYRxDZMsTvTDtwhLaYuwh3ApfjlkJH9Fkdjag23Rfbo4CW1lZGlhVHlwZQFC +MGGFiMjUqxQmQMf9yRcszdD/EP8Nk4AARHyImt3MeQRzYWx0AAAIDFJldmVhbGVk +RGF0YQUBAAgAAEAAAAAAAAAAAP//AAAAAAAAEFJldmVhbGVkRnVuZ2libGUGAgV2 +YWx1ZQGmjDCRR0vKOsJijMeVRI0s3arFFJ8FM5Wr9jxVYQcXJghibGluZGluZwGF +uPgru/Skpg2zvz9FuA+UbniDw61SbZP0b6MBqG5H2gZTY2hlbWEGCgNmZnYB2ptR +E1gWVnaQh/uZ5VaUcjaA1zkMBqHMJJgsBWT3zNUIc3Vic2V0T2YABAIABG5vbmUA +AAABBHNvbWUABQEAAAALZ2xvYmFsVHlwZXMACgAAAgHHmKbYYzZ4RB7aUW4sPou/ +DqiwSoDBtx256XLmP3HmJAAAAAAAAAAA/wAAAAAAAAAKb3duZWRUeXBlcwAKAAAC +ATjKFOCFIsfjOYJGlLLDmVh1U6boygwO4eiVibqJdxvzAAAAAAAAAAD/AAAAAAAA +AAx2YWxlbmN5VHlwZXMACQAAAgAAAAAAAAAA/wAAAAAAAAAHZ2VuZXNpcwGblA3v +M5Cfnw7uyaHDdhBCGf5ktkikEsA6dK8AQpzo5ApleHRlbnNpb25zAAoAAAIBI56L +tdkMulBTMyQDIZb7pCPy8/N71QYVk+ATWJYxyvsAAAAAAAAAAP8AAAAAAAAAC3Ry +YW5zaXRpb25zAAoAAAIBdcch4IY/3CgzpUFMLeyPIjFO9jJgMS2nBOZc7djEZ0wA +AAAAAAAAAP8AAAAAAAAACnR5cGVTeXN0ZW0CQzQDlNgbMOJSKJAmHvNv+fioOVGR +9QtpXiMqHrO3QcguR1s+c8ngIm2OLCe6FLOqJb5tKPdHfiz9jE0oXhjsVgZzY3Jp +cHQBxhhje2dNDLS8qcBDXX8yYoOYeHN0J0PRN+VE+7oS0EwIU2NoZW1hSWQFAQAH +AABAIAAMU2NoZW1hU2NoZW1hBgoDZmZ2AdqbURNYFlZ2kIf7meVWlHI2gNc5DAah +zCSYLAVk98zVCHN1YnNldE9mAAQCAARub25lAAAAAQRzb21lAAUBAbDOQpObjGEC +CCWpCejvOUXEDEPK2k88y6zc2VhwYTmFC2dsb2JhbFR5cGVzAAoAAAIBx5im2GM2 +eEQe2lFuLD6Lvw6osEqAwbcduely5j9x5iQAAAAAAAAAAP8AAAAAAAAACm93bmVk +VHlwZXMACgAAAgE4yhTghSLH4zmCRpSyw5lYdVOm6MoMDuHolYm6iXcb8wAAAAAA +AAAA/wAAAAAAAAAMdmFsZW5jeVR5cGVzAAkAAAIAAAAAAAAAAP8AAAAAAAAAB2dl +bmVzaXMBm5QN7zOQn58O7smhw3YQQhn+ZLZIpBLAOnSvAEKc6OQKZXh0ZW5zaW9u +cwAKAAACASOei7XZDLpQUzMkAyGW+6Qj8vPze9UGFZPgE1iWMcr7AAAAAAAAAAD/ +AAAAAAAAAAt0cmFuc2l0aW9ucwAKAAACAXXHIeCGP9woM6VBTC3sjyIxTvYyYDEt +pwTmXO3YxGdMAAAAAAAAAAD/AAAAAAAAAAp0eXBlU3lzdGVtAkM0A5TYGzDiUiiQ +Jh7zb/n4qDlRkfULaV4jKh6zt0HILkdbPnPJ4CJtjiwnuhSzqiW+bSj3R34s/YxN +KF4Y7FYGc2NyaXB0AcYYY3tnTQy0vKnAQ11/MmKDmHhzdCdD0TflRPu6EtBMBlNj +cmlwdAQBAAVhbHVWbQAFAQGi+uqecFyckczb3Ubtj3DljvUUgz7IPlxktWpbw1Ot +sBxTZWFsRGVmaW5pdGlvbkJsaW5kU2VhbFR4UHRyBAIAB2JpdGNvaW4ABQECFwZO +aYm8ANN+QATAdalw1SQOh8fRNH4sG25uxi7AoTd+tfgzfJGqb7i9lbu7y/XhxSWJ +RdIRdtoe1NyMxTElZQEGbGlxdWlkAAUBAhcGTmmJvADTfkAEwHWpcNUkDofH0TR+ +LBtubsYuwKE3frX4M3yRqm+4vZW7u8v14cUliUXSEXbaHtTcjMUxJWUbU2VhbERl +ZmluaXRpb25CbGluZFNlYWxUeGlkBAIAB2JpdGNvaW4ABQECFwZOaYm8ANN+QATA +dalw1SQOh8fRNH4sG25uxi7AoTcMUGySSZxY8y8u7CxUuNcWa7yYFOw+mQJFPXEu +umEJ4QEGbGlxdWlkAAUBAhcGTmmJvADTfkAEwHWpcNUkDofH0TR+LBtubsYuwKE3 +DFBskkmcWPMvLuwsVLjXFmu8mBTsPpkCRT1xLrphCeELU3RhdGVTY2hlbWEEBAAL +ZGVjbGFyYXRpdmUAAAABCGZ1bmdpYmxlAAUBAfn0rAhmrkF3ZtT9DBF9BLHZVP0O +Z14SO2IE63FP6eVGAgpzdHJ1Y3R1cmVkAAUBAkM0A5TYGzDiUiiQJh7zb/n4qDlR +kfULaV4jKh6zt0HIawSjFJ6mlQAWZ5/vArSrJPXmt4pkyNnQvWX816NYTo0DCmF0 +dGFjaG1lbnQABQEBQjBhhYjI1KsUJkDH/ckXLM3Q/xD/DZOAAER8iJrdzHkKVHJh +bnNpdGlvbgYIA2ZmdgHam1ETWBZWdpCH+5nlVpRyNoDXOQwGocwkmCwFZPfM1Qpj +b250cmFjdElkAZ8ILEk6yAKiusXd3AsifCCvlNRoxEjPGloh4L3C9ToyDnRyYW5z +aXRpb25UeXBlAAACCG1ldGFkYXRhAAgAAEAAAAAAAAAAAP//AAAAAAAAB2dsb2Jh +bHMB62+KkPa4xXkjBFZKvDL2fHjgUIU6pgieDE4dPteQV5UGaW5wdXRzAVpf2hdv +KjLnz5gAMhMvLph2Bpf74v+quNVDT1zIU8ZsC2Fzc2lnbm1lbnRzAcK697ALCBYo +B51Qb9CPJsDoA6K4c+jBSjq/tI8luP1BCXZhbGVuY2llcwGw4IWnhzbyBvHMrzFY +eAYDiYnv4lE8FvxkUpJTD8QHfxBUcmFuc2l0aW9uQnVuZGxlBQEACgGVyOZ6HnVi +X9SWVUJqket+QpChb1qY8b5Q97aKJBL3xQFnl57NSw7dKYQI9cnMXlOSYWTWzzGi +U3ou5zgJXNsIoAAAAAAAAAAA/wAAAAAAAAAQVHJhbnNpdGlvblNjaGVtYQYFCG1l +dGFkYXRhAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HIawSjFJ6mlQAW +Z5/vArSrJPXmt4pkyNnQvWX816NYTo0HZ2xvYmFscwAKAAACATbBNKH6oIETp90w +gDxesPLC/doUsNWj1pPDbp4PMqp5AAAAAAAAAAD/AAAAAAAAAAZpbnB1dHMACgAA +AgE2wTSh+qCBE6fdMIA8XrDywv3aFLDVo9aTw26eDzKqeQAAAAAAAAAA/wAAAAAA +AAALYXNzaWdubWVudHMACgAAAgE2wTSh+qCBE6fdMIA8XrDywv3aFLDVo9aTw26e +DzKqeQAAAAAAAAAA/wAAAAAAAAAJdmFsZW5jaWVzAAkAAAIAAAAAAAAAAP8AAAAA +AAAAGlR5cGVkQXNzaWduc0JsaW5kU2VhbFR4UHRyBAQAC2RlY2xhcmF0aXZlAAUB +AAgBKWYu7v5geWxwu1p8bY9yjOjqS8tT83pMy5WTaAianu4AAAAAAAAAAP//AAAA +AAAAAQhmdW5naWJsZQAFAQAIAUtJEbbHiNOzqob8xVNWPP2aKvG4B8bmx5/pe1aZ +DxCxAAAAAAAAAAD//wAAAAAAAAIKc3RydWN0dXJlZAAFAQAIAVmiUc2N5suJJETt +z3Vbsaql3Bw/2sE0zWwlNtX2E4rCAAAAAAAAAAD//wAAAAAAAP8KYXR0YWNobWVu +dAAFAQAIAfvMF3YVORemNKbhvuAe3SvcYr+viVrldTly/ypBl9iAAAAAAAAAAAD/ +/wAAAAAAABlUeXBlZEFzc2lnbnNCbGluZFNlYWxUeGlkBAQAC2RlY2xhcmF0aXZl +AAUBAAgBmOYI1Sm8PzDOT0yqAKws50f+zzpC7HKyCoLAvgITAokAAAAAAAAAAP// +AAAAAAAAAQhmdW5naWJsZQAFAQAIAX9s0fngN4LJlSr8KjdFNkBrhlrPejhed4PJ +4MjV44D9AAAAAAAAAAD//wAAAAAAAAIKc3RydWN0dXJlZAAFAQAIAT7cnXA0Q+QG +4OoHXUODL82vX8tU87SAnWm77X9gpEGjAAAAAAAAAAD//wAAAAAAAP8KYXR0YWNo +bWVudAAFAQAIAQ/5o2NsY+SSqilwbvng2u1Ptke5XvuqO+l1s0YTDPZ8AAAAAAAA +AAD//wAAAAAAAAlWYWxlbmNpZXMFAQAJAAACAAAAAAAAAAD/AAAAAAAAAAlWb2lk +U3RhdGUFAQAAAA== -----END STRICT TYPE LIB----- diff --git a/stl/RGB@0.1.0.stl b/stl/RGB@0.1.0.stl index a35823237c5440be81a6d07f32001786a246aa14..2e793558103b06504e2e469feed4a1b7338a966c 100644 GIT binary patch delta 1043 zcmZpR_!Vcw9OUlA#*s5w(>^TY&CUCB9ZET_FEmybb8!q~>egGsx&P_?UMC*s{M_8k zlCadG%(TkM2ZR+SsxD<@n|M0bgqwk}hCPD*gR-?9$Sk9`F7-u3cHo z-PX$Yz0!aisve})!ahl_F!<65#fdhj%Vp==rra<4q!Aja`@_w7ikNRME6`c|Aa@02 zre~Bm6(!~+XH0$|tT4HP(MoNV*O81zbyK!oW7e8BcURc&*wn@t&Z+>G0@b%2o0+HV zX9c@v@+QV0>xUQf!dKY&dCYRip5UYVex)IU4#&R3i3*p=s5Xle#b4 zxPz06G7CzaDoav}4R^15(b8FdbOXC#k>S}%-wd{C>YnYazq9M!(OpMg*53qq9~8_U ziNzU{6QvXkS)DTyGxOrt+{}Gy?{`$>=EmOihFe^#U+b!I|25ZLe4uJctmS-PE}zuI zG>A2mBbij|w;6M;l-R#*5^vs#h$SlR%5G7a_C?O@`~S;cw<>P*JIM}G4@?U8e=yiI z{&W8mqP+3au}A#8_gAIuJ@dJ?MEIn9>MaJF4ld8UlGLKS#GHU^l=Q>Ip#Sc?oXe$! znmfBhEZn^<3#V#p$Sh)$HJ<@?8p;mR+caY59AJifV(X(^M34FjiRPKi%qWonTjGb3A0W?^Y&3L_6(EI74< zm63sy@kDl0HFs3)v571yMNgH~`!Ae7Dixlwz}tS6p@Xzdo$};r*7xjekocP%sH(3( zD6S_jP}Qj?q=*k@n-dxF(&vDpHe#ND}Ie^_pSV1K`=tgS8hdHORl+8ngToe*&7VFf%JM&RQfFYlY MQ>$n58mTBj07MS0cK`qY delta 213 zcmewr*A~Ib9OUlAI{71q!o;AZjI0xX#4@omOm@&zn7opaZxXM<Kms`|P{Bj4_3#+pc%*H{W0!AN`@yR^YhO z;?tAgu)k+intYI3e)B(0CJ}`zUs<-z^jzBMFL ^ ..0xff [Byte]}, entryPoints {[Byte ^ 3] -> AluVM.LibSite {- urn:ubideco:semid:8Q9NNyK2PCcjZ7U7rDGUJBhk8q37hAnWLgSizGLmr56g#mission-papa-mercy -}} +-- urn:ubideco:semid:8vcfUdinF6vyygbB4pZh1HLAvgWSWN27szLBnkV8jR5w#field-mama-summer +data Anchor :: bitcoin BPCore.AnchorMerkleProof {- urn:ubideco:semid:GCVxKmrRiHJHrv43cBf21L7gFdkQUX4iEo4DSuywJyv1#demand-symbol-korea -} + | liquid BPCore.AnchorMerkleProof {- urn:ubideco:semid:GCVxKmrRiHJHrv43cBf21L7gFdkQUX4iEo4DSuywJyv1#demand-symbol-korea -} +-- urn:ubideco:semid:3wnGtf3mZhoFh3zXkSppQCDFesMZzj8dxmXCcEf7EgPP#picture-service-index +data AnchoredBundle :: anchor Anchor, bundle TransitionBundle -- urn:ubideco:semid:8Ffm9AttRojBCspPTxazNdaPB3BcFD2cr9c2sES1T7ox#desert-bambino-size data AssignRevealedAttachBlindSealTxPtr :: confidential (seal BPCore.SecretSeal {- urn:ubideco:semid:81NKrdc9pBoBjsKaGBVN9wXLG4tKjkK4f8DLj7TNMZxh#santana-domingo-needle -}, state ConcealedAttach) | confidentialState (seal SealDefinitionBlindSealTxPtr, state ConcealedAttach)