From 0d23201fc08d3204198131149dc57649d663711f Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Tue, 8 Aug 2023 19:03:34 +0100
Subject: [PATCH 01/28] feature: Added versioned macro

---
 sbor/src/lib.rs       |   3 +
 sbor/src/versioned.rs | 166 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 169 insertions(+)
 create mode 100644 sbor/src/versioned.rs

diff --git a/sbor/src/lib.rs b/sbor/src/lib.rs
index 4858e4aca96..c2b4217a870 100644
--- a/sbor/src/lib.rs
+++ b/sbor/src/lib.rs
@@ -42,6 +42,8 @@ pub mod traversal;
 pub mod value;
 /// SBOR value kinds - ie the types of value that are supported.
 pub mod value_kind;
+/// Data model versioning helper macro
+pub mod versioned;
 
 pub use basic::*;
 pub(crate) use categorize::{categorize_generic, categorize_simple};
@@ -59,6 +61,7 @@ pub use payload_validation::*;
 pub use schema::*;
 pub use value::*;
 pub use value_kind::*;
+pub use versioned::*;
 
 // Re-export derives
 extern crate sbor_derive;
diff --git a/sbor/src/versioned.rs b/sbor/src/versioned.rs
new file mode 100644
index 00000000000..6b7a3813bc8
--- /dev/null
+++ b/sbor/src/versioned.rs
@@ -0,0 +1,166 @@
+pub enum UpdateResult<T> {
+    Updated(T),
+    AtLatest(T),
+}
+
+/// A marker trait to indicate that the type is versioned.
+/// This can be used for type bounds for requiring that types are versioned.
+pub trait IsVersioned {}
+
+/// This macro is intended for creating a data model which supports versioning.
+/// This is useful for creating an SBOR data model which can be updated in future.
+/// In future, enum variants can be added, and automatically mapped to.
+///
+/// In the future, this may become a programmatic macro to support better error handling /
+/// edge case detection, and opting into SBOR handling.
+#[macro_export]
+macro_rules! versioned {
+    (
+        $(#[$attributes:meta])*
+        $vis:vis enum $name:ident {
+            previous_versions: [
+                $($version_num:expr => $version_ident:ident -> { updates_to: $update_to_version_num:expr }),*
+                $(,)? // Optional trailing comma
+            ],
+            latest_version: {
+                $latest_version:expr => $latest_version_ident:ident,
+            }$(,)?
+        }
+    ) => {
+        paste::paste! {
+            $(#[$attributes])*
+            // We include the repr(u8) so that the SBOR discriminants are assigned
+            // to match the version numbers if SBOR is used on the versioned enum
+            #[repr(u8)]
+            $vis enum $name {
+                $(
+                    [<V $version_num>]($version_ident) = $version_num,
+                )*
+                [<V $latest_version>]($latest_version_ident) = $latest_version,
+            }
+
+            impl $name {
+                pub fn update_once(self) -> UpdateResult<Self> {
+                    match self {
+                    $(
+                        Self::[<V $version_num>](value) => crate::UpdateResult::Updated(Self::[<V $update_to_version_num>](value.into())),
+                    )*
+                        Self::[<V $latest_version>](value) => crate::UpdateResult::AtLatest(Self::[<V $latest_version>](value)),
+                    }
+                }
+
+                pub fn update_to_latest(mut self) -> Self {
+                    loop {
+                        match self.update_once() {
+                            UpdateResult::Updated(new) => {
+                                self = new;
+                            }
+                            UpdateResult::AtLatest(latest) => {
+                                return latest;
+                            }
+                        }
+                    }
+                }
+            }
+
+            impl crate::IsVersioned for $name {}
+
+            $(
+                impl From<$version_ident> for $name {
+                    fn from(value: $version_ident) -> Self {
+                        Self::[<V $version_num>](value)
+                    }
+                }
+            )*
+
+            impl From<$latest_version_ident> for $name {
+                fn from(value: $latest_version_ident) -> Self {
+                    Self::[<V $latest_version>](value)
+                }
+            }
+        }
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::*;
+
+    crate::versioned!(
+        #[derive(Debug, Clone, PartialEq, Eq, Sbor)]
+        enum VersionedExample {
+            previous_versions: [
+                1 => ExampleV1 -> { updates_to: 2 },
+                2 => ExampleV2 -> { updates_to: 4 },
+                3 => ExampleV3 -> { updates_to: 4 },
+            ],
+            latest_version: {
+                4 => ExampleV4,
+            },
+        }
+    );
+
+    // Define the concrete versions
+    type ExampleV1 = u8;
+    type ExampleV2 = u16;
+
+    #[derive(Debug, Clone, PartialEq, Eq, Sbor)]
+    struct ExampleV3(u16);
+
+    #[derive(Debug, Clone, PartialEq, Eq, Sbor)]
+    struct ExampleV4 {
+        the_value: u16,
+    }
+
+    impl ExampleV4 {
+        pub fn of(value: u16) -> Self {
+            Self {
+                the_value: value,
+            }
+        }
+    }
+
+    // And explicit updates between them, which are needed
+    // for the versioned type
+    impl From<ExampleV2> for ExampleV4 {
+        fn from(value: ExampleV2) -> Self {
+            Self {
+                the_value: value,
+            }
+        }
+    }
+
+    impl From<ExampleV3> for ExampleV4 {
+        fn from(value: ExampleV3) -> Self {
+            Self {
+                the_value: value.0,
+            }
+        }
+    }
+
+    #[test]
+    pub fn updates_to_latest_work() {
+        let expected_latest = VersionedExample::V4(ExampleV4::of(5));
+        let v1: ExampleV1 = 5;
+        assert_eq!(
+            VersionedExample::from(v1).update_to_latest(),
+            expected_latest.clone(),
+        );
+        let v2: ExampleV2 = 5;
+        assert_eq!(
+            VersionedExample::from(v2).update_to_latest(),
+            expected_latest.clone(),
+        );
+        let v3 = ExampleV3(5);
+        assert_eq!(
+            VersionedExample::from(v3).update_to_latest(),
+            expected_latest.clone(),
+        );
+        let v4 = ExampleV4::of(5);
+        assert_eq!(
+            VersionedExample::from(v4).update_to_latest(),
+            expected_latest.clone(),
+        );
+    }
+}
\ No newline at end of file

From fe5d5da329ce954d1f30b4c6b19805e614e5143c Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Tue, 8 Aug 2023 19:18:37 +0100
Subject: [PATCH 02/28] tweak: Update versioned macro

---
 sbor/src/versioned.rs | 55 ++++++++++++++++++++++++++++---------------
 1 file changed, 36 insertions(+), 19 deletions(-)

diff --git a/sbor/src/versioned.rs b/sbor/src/versioned.rs
index 6b7a3813bc8..245802bf16e 100644
--- a/sbor/src/versioned.rs
+++ b/sbor/src/versioned.rs
@@ -5,16 +5,21 @@ pub enum UpdateResult<T> {
 
 /// A marker trait to indicate that the type is versioned.
 /// This can be used for type bounds for requiring that types are versioned.
-pub trait IsVersioned {}
+pub trait HasLatestVersion {
+    type Latest;
+    fn into_latest(self) -> Self::Latest;
+}
 
 /// This macro is intended for creating a data model which supports versioning.
 /// This is useful for creating an SBOR data model which can be updated in future.
 /// In future, enum variants can be added, and automatically mapped to.
+/// 
+/// NOTE: A circular version update chain will be an infinite loop at runtime. Be careful.
 ///
 /// In the future, this may become a programmatic macro to support better error handling /
-/// edge case detection, and opting into SBOR handling.
+/// edge case detection, and opting into more explicit SBOR handling.
 #[macro_export]
-macro_rules! versioned {
+macro_rules! define_versioned {
     (
         $(#[$attributes:meta])*
         $vis:vis enum $name:ident {
@@ -63,7 +68,16 @@ macro_rules! versioned {
                 }
             }
 
-            impl crate::IsVersioned for $name {}
+            impl crate::HasLatestVersion for $name {
+                type Latest = $latest_version_ident;
+
+                fn into_latest(self) -> Self::Latest {
+                    let Self::[<V $latest_version>](latest) = self.update_to_latest() else {
+                        panic!("Invalid resolved latest version not equal to latest type")
+                    };
+                    return latest;
+                }
+            }
 
             $(
                 impl From<$version_ident> for $name {
@@ -87,7 +101,7 @@ mod tests {
     use super::*;
     use crate::*;
 
-    crate::versioned!(
+    crate::define_versioned!(
         #[derive(Debug, Clone, PartialEq, Eq, Sbor)]
         enum VersionedExample {
             previous_versions: [
@@ -141,26 +155,29 @@ mod tests {
 
     #[test]
     pub fn updates_to_latest_work() {
-        let expected_latest = VersionedExample::V4(ExampleV4::of(5));
+        let expected_latest = ExampleV4::of(5);
         let v1: ExampleV1 = 5;
-        assert_eq!(
-            VersionedExample::from(v1).update_to_latest(),
-            expected_latest.clone(),
-        );
+        validate_latest(v1, expected_latest.clone());
         let v2: ExampleV2 = 5;
-        assert_eq!(
-            VersionedExample::from(v2).update_to_latest(),
-            expected_latest.clone(),
-        );
+        validate_latest(v2, expected_latest.clone());
         let v3 = ExampleV3(5);
+        validate_latest(v3, expected_latest.clone());
+        let v4 = ExampleV4::of(5);
+        validate_latest(v4, expected_latest.clone());
+    }
+
+    fn validate_latest(actual: impl Into<VersionedExample>, expected: <VersionedExample as HasLatestVersion>::Latest) {
+        let versioned_actual = actual.into();
+        let versioned_expected = VersionedExample::from(expected.clone());
+        // Check update_to_latest (which returns a VersionedExample)
         assert_eq!(
-            VersionedExample::from(v3).update_to_latest(),
-            expected_latest.clone(),
+            versioned_actual.clone().update_to_latest(),
+            versioned_expected,
         );
-        let v4 = ExampleV4::of(5);
+        // Check into_latest (which returns an ExampleV4)
         assert_eq!(
-            VersionedExample::from(v4).update_to_latest(),
-            expected_latest.clone(),
+            versioned_actual.into_latest(),
+            expected,
         );
     }
 }
\ No newline at end of file

From f487591580c3b2b4656e6db51611720d563a178f Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Wed, 9 Aug 2023 11:58:49 +0100
Subject: [PATCH 03/28] feature: Updates to defined_versioned

Generics are now supported, as is a simplified define_single_versioned
---
 sbor/src/versioned.rs | 169 +++++++++++++++++++++++++++++++-----------
 1 file changed, 126 insertions(+), 43 deletions(-)

diff --git a/sbor/src/versioned.rs b/sbor/src/versioned.rs
index 245802bf16e..050984d599a 100644
--- a/sbor/src/versioned.rs
+++ b/sbor/src/versioned.rs
@@ -13,7 +13,36 @@ pub trait HasLatestVersion {
 /// This macro is intended for creating a data model which supports versioning.
 /// This is useful for creating an SBOR data model which can be updated in future.
 /// In future, enum variants can be added, and automatically mapped to.
-/// 
+///
+/// This macro is just a simpler wrapper around the [`define_versioned`] macro,
+/// for use when there's just a single version.
+#[macro_export]
+macro_rules! define_single_versioned {
+    (
+        $(#[$attributes:meta])*
+        $vis:vis enum $name:ident
+        $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)?
+        =>
+        $latest_version_type:ty
+    ) => {
+        $crate::define_versioned!(
+            $(#[$attributes])*
+            $vis enum $name
+            $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            {
+                previous_versions: [],
+                latest_version: {
+                    1 => $latest_version_type
+                },
+            }
+        );
+    };
+}
+
+/// This macro is intended for creating a data model which supports versioning.
+/// This is useful for creating an SBOR data model which can be updated in future.
+/// In future, enum variants can be added, and automatically mapped to.
+///
 /// NOTE: A circular version update chain will be an infinite loop at runtime. Be careful.
 ///
 /// In the future, this may become a programmatic macro to support better error handling /
@@ -22,35 +51,68 @@ pub trait HasLatestVersion {
 macro_rules! define_versioned {
     (
         $(#[$attributes:meta])*
-        $vis:vis enum $name:ident {
+        $vis:vis enum $name:ident
+        // Now match the optional type parameters
+        // See https://stackoverflow.com/questions/41603424/rust-macro-accepting-type-with-generic-parameters
+        $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)?
+        {
             previous_versions: [
-                $($version_num:expr => $version_ident:ident -> { updates_to: $update_to_version_num:expr }),*
+                $($version_num:expr => $version_type:ty: { updates_to: $update_to_version_num:expr }),*
                 $(,)? // Optional trailing comma
             ],
             latest_version: {
-                $latest_version:expr => $latest_version_ident:ident,
-            }$(,)?
+                $latest_version:expr => $latest_version_type:ty
+                $(,)? // Optional trailing comma
+            }
+            $(,)? // Optional trailing comma
         }
     ) => {
         paste::paste! {
+            // Create inline sub-macros to handle the type generics nested inside
+            // iteration over previous_versions
+            // See eg https://stackoverflow.com/a/73543948
+            macro_rules! [<$name _trait_impl>] {
+                (
+                    $trait:ty,
+                    $impl_block:tt
+                ) => {
+                    #[allow(dead_code)]
+                    impl
+                    $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+                    $trait
+                    for $name $(< $( $lt ),+ >)?
+                    $impl_block
+                };
+            }
+
             $(#[$attributes])*
             // We include the repr(u8) so that the SBOR discriminants are assigned
             // to match the version numbers if SBOR is used on the versioned enum
             #[repr(u8)]
-            $vis enum $name {
+            $vis enum $name $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            {
                 $(
-                    [<V $version_num>]($version_ident) = $version_num,
+                    [<V $version_num>]($version_type) = $version_num,
                 )*
-                [<V $latest_version>]($latest_version_ident) = $latest_version,
+                [<V $latest_version>]($latest_version_type) = $latest_version,
             }
 
-            impl $name {
+            #[allow(dead_code)]
+            impl
+            $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            $name
+            $(< $( $lt ),+ >)?
+            {
+                pub fn new_latest(value: $latest_version_type) -> Self {
+                    Self::[<V $latest_version>](value)
+                }
+
                 pub fn update_once(self) -> UpdateResult<Self> {
                     match self {
                     $(
-                        Self::[<V $version_num>](value) => crate::UpdateResult::Updated(Self::[<V $update_to_version_num>](value.into())),
+                        Self::[<V $version_num>](value) => $crate::UpdateResult::Updated(Self::[<V $update_to_version_num>](value.into())),
                     )*
-                        Self::[<V $latest_version>](value) => crate::UpdateResult::AtLatest(Self::[<V $latest_version>](value)),
+                        Self::[<V $latest_version>](value) => $crate::UpdateResult::AtLatest(Self::[<V $latest_version>](value)),
                     }
                 }
 
@@ -68,30 +130,38 @@ macro_rules! define_versioned {
                 }
             }
 
-            impl crate::HasLatestVersion for $name {
-                type Latest = $latest_version_ident;
+            [<$name _trait_impl>]!(
+                $crate::HasLatestVersion,
+                {
+                    type Latest = $latest_version_type;
 
-                fn into_latest(self) -> Self::Latest {
-                    let Self::[<V $latest_version>](latest) = self.update_to_latest() else {
-                        panic!("Invalid resolved latest version not equal to latest type")
-                    };
-                    return latest;
+                    #[allow(irrefutable_let_patterns)]
+                    fn into_latest(self) -> Self::Latest {
+                        let Self::[<V $latest_version>](latest) = self.update_to_latest() else {
+                            panic!("Invalid resolved latest version not equal to latest type")
+                        };
+                        return latest;
+                    }
                 }
-            }
+            );
 
-            $(
-                impl From<$version_ident> for $name {
-                    fn from(value: $version_ident) -> Self {
+            $([<$name _trait_impl>]!(
+                From<$version_type>,
+                {
+                    fn from(value: $version_type) -> Self {
                         Self::[<V $version_num>](value)
                     }
                 }
-            )*
+            );)*
 
-            impl From<$latest_version_ident> for $name {
-                fn from(value: $latest_version_ident) -> Self {
-                    Self::[<V $latest_version>](value)
+            [<$name _trait_impl>]!(
+                From<$latest_version_type>,
+                {
+                    fn from(value: $latest_version_type) -> Self {
+                        Self::[<V $latest_version>](value)
+                    }
                 }
-            }
+            );
         }
     };
 }
@@ -105,9 +175,9 @@ mod tests {
         #[derive(Debug, Clone, PartialEq, Eq, Sbor)]
         enum VersionedExample {
             previous_versions: [
-                1 => ExampleV1 -> { updates_to: 2 },
-                2 => ExampleV2 -> { updates_to: 4 },
-                3 => ExampleV3 -> { updates_to: 4 },
+                1 => ExampleV1: { updates_to: 2 },
+                2 => ExampleV2: { updates_to: 4 },
+                3 => ExampleV3: { updates_to: 4 },
             ],
             latest_version: {
                 4 => ExampleV4,
@@ -129,9 +199,7 @@ mod tests {
 
     impl ExampleV4 {
         pub fn of(value: u16) -> Self {
-            Self {
-                the_value: value,
-            }
+            Self { the_value: value }
         }
     }
 
@@ -139,17 +207,13 @@ mod tests {
     // for the versioned type
     impl From<ExampleV2> for ExampleV4 {
         fn from(value: ExampleV2) -> Self {
-            Self {
-                the_value: value,
-            }
+            Self { the_value: value }
         }
     }
 
     impl From<ExampleV3> for ExampleV4 {
         fn from(value: ExampleV3) -> Self {
-            Self {
-                the_value: value.0,
-            }
+            Self { the_value: value.0 }
         }
     }
 
@@ -166,7 +230,10 @@ mod tests {
         validate_latest(v4, expected_latest.clone());
     }
 
-    fn validate_latest(actual: impl Into<VersionedExample>, expected: <VersionedExample as HasLatestVersion>::Latest) {
+    fn validate_latest(
+        actual: impl Into<VersionedExample>,
+        expected: <VersionedExample as HasLatestVersion>::Latest,
+    ) {
         let versioned_actual = actual.into();
         let versioned_expected = VersionedExample::from(expected.clone());
         // Check update_to_latest (which returns a VersionedExample)
@@ -175,9 +242,25 @@ mod tests {
             versioned_expected,
         );
         // Check into_latest (which returns an ExampleV4)
+        assert_eq!(versioned_actual.into_latest(), expected,);
+    }
+
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    struct GenericModelV1<T>(T);
+
+    define_single_versioned!(
+        /// This is some rust doc as an example annotation
+        #[derive(Debug, Clone, PartialEq, Eq)]
+        enum GenericModel<T> => GenericModelV1<T>
+    );
+
+    #[test]
+    pub fn generated_single_versioned_works() {
+        let v1_model = GenericModelV1(51u64);
+        let versioned = GenericModel::from(v1_model.clone());
         assert_eq!(
-            versioned_actual.into_latest(),
-            expected,
+            versioned.into_latest(),
+            v1_model
         );
     }
-}
\ No newline at end of file
+}

From b13160b076fa1af2250fd11533301766447e8704 Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Wed, 9 Aug 2023 15:02:21 +0100
Subject: [PATCH 04/28] feature: Add additional traits to `Versioned`

---
 sbor/src/versioned.rs | 95 ++++++++++++++++++++++++++++++++++---------
 1 file changed, 76 insertions(+), 19 deletions(-)

diff --git a/sbor/src/versioned.rs b/sbor/src/versioned.rs
index 050984d599a..22719740ceb 100644
--- a/sbor/src/versioned.rs
+++ b/sbor/src/versioned.rs
@@ -8,6 +8,20 @@ pub enum UpdateResult<T> {
 pub trait HasLatestVersion {
     type Latest;
     fn into_latest(self) -> Self::Latest;
+    fn as_latest_ref(&self) -> Option<&Self::Latest>;
+}
+
+pub trait CloneIntoLatest {
+    type Latest;
+    fn clone_into_latest(&self) -> Self::Latest;
+}
+
+impl<T: HasLatestVersion<Latest = Latest> + Clone, Latest> CloneIntoLatest for T {
+    type Latest = Latest;
+
+    fn clone_into_latest(&self) -> Self::Latest {
+        self.clone().into_latest()
+    }
 }
 
 /// This macro is intended for creating a data model which supports versioning.
@@ -23,7 +37,7 @@ macro_rules! define_single_versioned {
         $vis:vis enum $name:ident
         $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)?
         =>
-        $latest_version_type:ty
+        $latest_version_alias:ty = $latest_version_type:ty
     ) => {
         $crate::define_versioned!(
             $(#[$attributes])*
@@ -32,7 +46,7 @@ macro_rules! define_single_versioned {
             {
                 previous_versions: [],
                 latest_version: {
-                    1 => $latest_version_type
+                    1 => $latest_version_alias = $latest_version_type
                 },
             }
         );
@@ -56,12 +70,14 @@ macro_rules! define_versioned {
         // See https://stackoverflow.com/questions/41603424/rust-macro-accepting-type-with-generic-parameters
         $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)?
         {
-            previous_versions: [
-                $($version_num:expr => $version_type:ty: { updates_to: $update_to_version_num:expr }),*
-                $(,)? // Optional trailing comma
-            ],
+            $(
+                previous_versions: [
+                    $($version_num:expr => $version_type:ty: { updates_to: $update_to_version_num:expr }),*
+                    $(,)? // Optional trailing comma
+                ],
+            )?
             latest_version: {
-                $latest_version:expr => $latest_version_type:ty
+                $latest_version:expr => $latest_version_alias:ty = $latest_version_type:ty
                 $(,)? // Optional trailing comma
             }
             $(,)? // Optional trailing comma
@@ -85,15 +101,18 @@ macro_rules! define_versioned {
                 };
             }
 
+            #[allow(dead_code)]
+            $vis type $latest_version_alias = $latest_version_type;
+
             $(#[$attributes])*
             // We include the repr(u8) so that the SBOR discriminants are assigned
             // to match the version numbers if SBOR is used on the versioned enum
             #[repr(u8)]
             $vis enum $name $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
             {
-                $(
+                $($(
                     [<V $version_num>]($version_type) = $version_num,
-                )*
+                )*)?
                 [<V $latest_version>]($latest_version_type) = $latest_version,
             }
 
@@ -109,9 +128,9 @@ macro_rules! define_versioned {
 
                 pub fn update_once(self) -> UpdateResult<Self> {
                     match self {
-                    $(
+                    $($(
                         Self::[<V $version_num>](value) => $crate::UpdateResult::Updated(Self::[<V $update_to_version_num>](value.into())),
-                    )*
+                    )*)?
                         Self::[<V $latest_version>](value) => $crate::UpdateResult::AtLatest(Self::[<V $latest_version>](value)),
                     }
                 }
@@ -142,17 +161,25 @@ macro_rules! define_versioned {
                         };
                         return latest;
                     }
+
+                    #[allow(unreachable_patterns)]
+                    fn as_latest_ref(&self) -> Option<&Self::Latest> {
+                        match self {
+                            Self::[<V $latest_version>](latest) => Some(latest),
+                            _ => None,
+                        }
+                    }
                 }
             );
 
-            $([<$name _trait_impl>]!(
+            $($([<$name _trait_impl>]!(
                 From<$version_type>,
                 {
                     fn from(value: $version_type) -> Self {
                         Self::[<V $version_num>](value)
                     }
                 }
-            );)*
+            );)*)?
 
             [<$name _trait_impl>]!(
                 From<$latest_version_type>,
@@ -162,6 +189,31 @@ macro_rules! define_versioned {
                     }
                 }
             );
+
+            #[allow(dead_code)]
+            $vis trait [<$name Version>] {
+                // Note - we have an explicit Versioned associated type so that
+                // different generic parameters can each create their own specific concrete type
+                type Versioned;
+
+                fn into_versioned(self) -> Self::Versioned;
+            }
+
+            macro_rules! [<$name _versionable_impl>] {
+                ($inner_type:ty) => {
+                    impl$(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? [<$name Version>] for $inner_type
+                    {
+                        type Versioned = $name $(< $( $lt ),+ >)?;
+        
+                        fn into_versioned(self) -> Self::Versioned {
+                            self.into()
+                        }
+                    }
+                };
+            }
+
+            $($([<$name _versionable_impl>]!($version_type);)*)?
+            [<$name _versionable_impl>]!($latest_version_type);
         }
     };
 }
@@ -180,7 +232,7 @@ mod tests {
                 3 => ExampleV3: { updates_to: 4 },
             ],
             latest_version: {
-                4 => ExampleV4,
+                4 => Example = ExampleV4,
             },
         }
     );
@@ -251,16 +303,21 @@ mod tests {
     define_single_versioned!(
         /// This is some rust doc as an example annotation
         #[derive(Debug, Clone, PartialEq, Eq)]
-        enum GenericModel<T> => GenericModelV1<T>
+        enum VersionedGenericModel<T> => GenericModel<T> = GenericModelV1<T>
     );
 
     #[test]
     pub fn generated_single_versioned_works() {
-        let v1_model = GenericModelV1(51u64);
-        let versioned = GenericModel::from(v1_model.clone());
+        let v1_model: GenericModel<_> = GenericModelV1(51u64);
+        let versioned = VersionedGenericModel::from(v1_model.clone());
+        let versioned_2 = v1_model.clone().into_versioned();
+        assert_eq!(
+            versioned.clone().into_latest(),
+            v1_model.clone()
+        );
         assert_eq!(
-            versioned.into_latest(),
-            v1_model
+            versioned,
+            versioned_2
         );
     }
 }

From ed0a7753977607496931474a90432570ccf6c9f6 Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Thu, 10 Aug 2023 13:31:51 +0100
Subject: [PATCH 05/28] feature: `declare_native_blueprint_state!` macro

---
 radix-engine/src/blueprints/macros.rs | 476 ++++++++++++++++++++++++++
 radix-engine/src/blueprints/mod.rs    |   1 +
 radix-engine/src/system/system.rs     |   7 +
 sbor/src/versioned.rs                 |  18 +-
 4 files changed, 490 insertions(+), 12 deletions(-)
 create mode 100644 radix-engine/src/blueprints/macros.rs

diff --git a/radix-engine/src/blueprints/macros.rs b/radix-engine/src/blueprints/macros.rs
new file mode 100644
index 00000000000..2b8873d35d2
--- /dev/null
+++ b/radix-engine/src/blueprints/macros.rs
@@ -0,0 +1,476 @@
+use crate::types::*;
+use crate::system::system::*;
+
+pub trait FieldContent: Sized {
+    type VersionedContent: From<Self>;
+
+    fn into_locked_substate(self) -> FieldSubstate<Self::VersionedContent> {
+        FieldSubstate::new_locked_field(self.into())
+    }
+
+    fn into_mutable_substate(self) -> FieldSubstate<Self::VersionedContent> {
+        FieldSubstate::new_field(self.into())
+    }
+}
+
+pub trait KVEntryContent: Sized {
+    type VersionedContent: From<Self>;
+
+    fn into_locked_substate(self) -> KeyValueEntrySubstate<Self::VersionedContent> {
+        KeyValueEntrySubstate::entry(self.into())
+    }
+
+    fn into_mutable_substate(self) -> KeyValueEntrySubstate<Self::VersionedContent> {
+        KeyValueEntrySubstate::locked_entry(self.into())
+    }
+}
+
+pub trait IndexEntryContent: Sized {
+    type VersionedContent: From<Self>;
+
+    fn into_substate(self) -> Self::VersionedContent {
+        self.into()
+    }
+}
+
+pub trait SortedIndexEntryContent: Sized {
+    type VersionedContent: From<Self>;
+
+    fn into_substate(self) -> Self::VersionedContent {
+        self.into()
+    }
+}
+
+macro_rules! generate_wrapped_substate_type_alias {
+    (SystemField, $module_ident:ident, $field_ident:ident) => {
+        paste::paste! {
+            pub type [<$module_ident $field_ident FieldSubstate>] = [<Versioned $module_ident $field_ident Field>];
+        }
+    };
+    (Field, $blueprint_ident:ident, $field_ident:ident) => {
+        paste::paste! {
+            pub type [<$blueprint_ident $field_ident FieldSubstate>] = $crate::system::system::FieldSubstate<[<Versioned $blueprint_ident $field_ident Field>]>;
+        }
+    };
+    (KeyValue, $blueprint_ident:ident, $collection_ident:ident) => {
+        paste::paste! {
+            pub type [<$blueprint_ident $collection_ident EntrySubstate>] = $crate::system::system::KeyValueEntrySubstate<[<Versioned $blueprint_ident $collection_ident Value>]>;
+        }
+    };
+    (Index, $blueprint_ident:ident, $collection_ident:ident) => {
+        // No wrapper around Index substates
+        paste::paste! {
+            pub type [<$blueprint_ident $collection_ident EntrySubstate>] = [<Versioned $blueprint_ident $collection_ident Value>];
+        }
+    };
+    (SortedIndex, $blueprint_ident:ident, $collection_ident:ident) => {
+        // There is no wrapper around Index substates
+        paste::paste! {
+            pub type [<$blueprint_ident $collection_ident EntrySubstate>] = [<Versioned $blueprint_ident $collection_ident Value>];
+        }
+    };
+    ($unknown_system_substate_type:ident, $blueprint_ident:ident, $collection_ident:ident) => {
+        paste::paste! {
+            compile_error!(concat!(
+                "Unrecognized system substate type: `",
+                stringify!($unknown_system_substate_type),
+                "` - expected `Field`, `SystemField`, `KeyValue`, `Index` or `SortedIndex`"
+            ));
+        }
+    };
+}
+
+macro_rules! generate_collection_substate_content_trait {
+    (KeyValue, $type:ident, $versioned:ident) => {
+        impl KVEntryContent for $type {
+            type VersionedContent = $versioned;
+        }
+    };
+    (Index, $type:ident, $versioned:ident) => {
+        impl IndexEntryContent for $type {
+            type VersionedContent = $versioned;
+        }
+    };
+    (SortedIndex, $type:ident, $versioned:ident) => {
+        impl SortedIndexEntryContent for $type {
+            type VersionedContent = $versioned;
+        }
+    };
+    ($unknown_system_substate_type:ident, $type:ident, $versioned:ident) => {
+        paste::paste! {
+            compile_error!(concat!(
+                "Unrecognized system collection substate type: `",
+                stringify!($unknown_system_substate_type),
+                "` - expected `KeyValue`, `Index` or `SortedIndex`"
+            ));
+        }
+    };
+}
+
+macro_rules! map_entry_substate_to_kv_entry {
+    (KeyValue, $entry_substate:ident) => {
+        paste::paste! {
+            KVEntry {
+                value: $entry_substate.value.map(|v| scrypto_encode(&v).unwrap()),
+                locked: match $entry_substate.mutability {
+                    SubstateMutability::Mutable => true,
+                    SubstateMutability::Immutable => false,
+                },
+            }
+        }
+    };
+    (Index, $entry_substate:ident) => {
+        // This code still needs to compile, but it shouldn't be possible to execute
+        panic!("Not possible to map an Index entry to a KVEntry")
+    };
+    (SortedIndex, $entry_substate:ident) => {
+        // This code still needs to compile, but it shouldn't be possible to execute
+        panic!("Not possible to map a SortedIndex entry to a KVEntry")
+    };
+    ($unknown_system_substate_type:ident, $entry_substate:ident) => {
+        paste::paste! {
+            compile_error!(concat!(
+                "Unrecognized system collection substate type: `",
+                stringify!($unknown_system_substate_type),
+                "` - expected `KeyValue`, `Index` or `SortedIndex`"
+            ));
+        }
+    };
+}
+
+/// Generates types and typed-interfaces for native blueprints and their
+/// interaction with the substate store.
+///
+/// * For fields, assumes the existence of a type called:
+///    `<BlueprintIdent><FieldIdent>FieldV1`
+/// * For collections, assumes the existence of types called:
+///    `<BlueprintIdent><CollectionIdent>Key`
+///    `<BlueprintIdent><CollectionIdent>ValueV1`
+macro_rules! declare_native_blueprint_state {
+    (
+        blueprint_ident: $blueprint_ident:ident,
+        fields: {
+            $(
+                $field_property_name:ident: {
+                    ident: $field_ident:ident,
+                    condition: $field_condition:expr
+                    $(,)? // Optional trialing comma
+                }
+            ),*
+            $(,)? // Optional trialing comma
+        },
+        collections: {
+            $(
+                $collection_property_name:ident: $collection_type:ident {
+                    entry_ident: $collection_ident:ident,
+                    key_type: $collection_key_type:ty,
+                    can_own: $collection_can_own:expr
+                    // Collection options for (eg) passing in a property name
+                    // of the sorted index parameter for SortedIndex
+                    $(, options: $collection_options:tt)?
+                    $(,)? // Optional trialing comma
+                }
+            ),*
+            $(,)? // Optional trialing comma
+        }
+        $(,)?
+    ) => {
+        paste::paste! {
+            #[allow(unused_imports)]
+            mod [<$blueprint_ident _models>] {
+                use super::*;
+                use sbor::*;
+                use $crate::types::*;
+                use $crate::errors::RuntimeError;
+                use $crate::system::system::*;
+                use radix_engine_interface::api::*;
+                //--------------------------------------------------------
+                // MODELS
+                //--------------------------------------------------------
+
+                // Generate models for each field
+                $(
+                    // TODO: In future, expand this macro to support multi-versioned fields
+                    sbor::define_single_versioned!(
+                        #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
+                        pub enum [<Versioned $blueprint_ident $field_ident Field>] => [<$blueprint_ident $field_ident Field>] = [<$blueprint_ident $field_ident FieldV1>]
+                    );
+                    generate_wrapped_substate_type_alias!(Field, $blueprint_ident, $field_ident);
+                    impl FieldContent for [<Versioned $blueprint_ident $field_ident Field>] {
+                        type VersionedContent = Self;
+                    }
+                    impl FieldContent for [<$blueprint_ident $field_ident Field>] {
+                        type VersionedContent = [<Versioned $blueprint_ident $field_ident Field>];
+                    }
+                );*
+
+                // Generate models for each collection
+                $(
+                    pub type [<$blueprint_ident $collection_ident Key>] = $collection_key_type;
+                    // TODO: In future, expand this macro to support multi-versioned collection values
+                    sbor::define_single_versioned!(
+                        #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
+                        pub enum [<Versioned $blueprint_ident $collection_ident Value>] => [<$blueprint_ident $collection_ident Value>] = [<$blueprint_ident $collection_ident ValueV1>]
+                    );
+                    generate_wrapped_substate_type_alias!($collection_type, $blueprint_ident, $collection_ident);
+                    generate_collection_substate_content_trait!($collection_type, [<Versioned $blueprint_ident $collection_ident Value>], Self);
+                    generate_collection_substate_content_trait!($collection_type, [<$blueprint_ident $collection_ident Value>], [<Versioned $blueprint_ident $collection_ident Value>]);
+                )*
+
+                //--------------------------------------------------------
+                // Node Layout
+                // (to replace node_layout.rs)
+                //--------------------------------------------------------
+                #[repr(u8)]
+                #[derive(Debug, Clone, Sbor, PartialEq, Eq, Hash, PartialOrd, Ord, FromRepr)]
+                pub enum [<$blueprint_ident Field>] {
+                    $($field_ident,)*
+                }
+
+                impl From<[<$blueprint_ident Field>]> for SubstateKey {
+                    fn from(value: [<$blueprint_ident Field>]) -> Self {
+                        SubstateKey::Field(value as u8)
+                    }
+                }
+
+                impl From<[<$blueprint_ident Field>]> for u8 {
+                    fn from(value: [<$blueprint_ident Field>]) -> Self {
+                        value as u8
+                    }
+                }
+
+                impl TryFrom<&SubstateKey> for [<$blueprint_ident Field>] {
+                    type Error = ();
+        
+                    fn try_from(key: &SubstateKey) -> Result<Self, Self::Error> {
+                        match key {
+                            SubstateKey::Field(x) => Self::from_repr(*x).ok_or(()),
+                            _ => Err(()),
+                        }
+                    }
+                }
+
+                impl TryFrom<u8> for [<$blueprint_ident Field>] {
+                    type Error = ();
+                
+                    fn try_from(offset: u8) -> Result<Self, Self::Error> {
+                        Self::from_repr(offset).ok_or(())
+                    }
+                }
+
+                #[repr(u8)]
+                #[derive(Debug, Clone, Sbor, PartialEq, Eq, Hash, PartialOrd, Ord, FromRepr)]
+                pub enum [<$blueprint_ident Partition>] {
+                    Field,
+                    $([<$collection_ident $collection_type>],)*
+                }
+
+                impl [<$blueprint_ident Partition>] {
+                    pub const fn offset(&self) -> PartitionOffset {
+                        PartitionOffset(*self as u8)
+                    }
+
+                    pub const fn main_partition(&self) -> PartitionNumber {
+                        MAIN_BASE_PARTITION.at_offset(self.offset()).unwrap()
+                    }
+                }
+
+                impl From<[<$blueprint_ident Partition>]> for PartitionOffset {
+                    fn from(value: [<$blueprint_ident Partition>]) -> Self {
+                        PartitionOffset(value as u8)
+                    }
+                }
+
+                //---------------------------------
+                // Typed Substate - Keys and Values
+                //---------------------------------
+                #[derive(Debug, Clone)]
+                pub enum [<$blueprint_ident TypedSubstateKey>] {
+                    Fields([<$blueprint_ident Field>]),
+                    $([<$collection_ident $collection_type Entries>]([<$blueprint_ident $collection_ident Key>]),)*
+                }
+
+                #[derive(Debug)]
+                pub enum [<$blueprint_ident TypedFieldSubstateValue>] {
+                    $($field_ident([<$blueprint_ident $field_ident FieldSubstate>]),)*
+                }
+
+                #[derive(Debug)]
+                pub enum [<$blueprint_ident TypedSubstateValue>] {
+                    Field([<$blueprint_ident TypedFieldSubstateValue>]),
+                    $([<$collection_ident $collection_type>]([<$blueprint_ident $collection_ident EntrySubstate>]),)*
+                }
+
+                //----------------------
+                // Object Initialization
+                //----------------------
+
+                /// This doesn't support:
+                /// * Features
+                /// * Instance schemas
+                /// * Feature-dependent fields
+                /// * IndexEntries (because the underlying new_object API doesn't support them)
+                pub struct [<$blueprint_ident StateInit>] {
+                    $(
+                        pub $field_property_name: [<$blueprint_ident $field_ident FieldSubstate>],
+                    )*
+                    $(
+                        pub $collection_property_name: IndexMap<
+                            [<$blueprint_ident $collection_ident Key>],
+                            [<$blueprint_ident $collection_ident EntrySubstate>]
+                        >,
+                    )*
+                }
+
+                impl [<$blueprint_ident StateInit>] {
+                    pub fn into_system_substates(self) -> (Vec<FieldValue>, BTreeMap<u8, BTreeMap<Vec<u8>, KVEntry>>) {
+                        let mut field_values = vec![];
+                        $(
+                            let field_content = scrypto_encode(&self.$field_property_name.value).unwrap();
+                            let locked = match &self.$field_property_name.mutability {
+                                SubstateMutability::Mutable => true,
+                                SubstateMutability::Immutable => false,
+                            };
+                            field_values.push(FieldValue {
+                                value: field_content,
+                                locked,
+                            });
+                        )*
+                        let mut all_collection_entries = BTreeMap::new();
+                        let mut collection_index: u8 = 0;
+                        $(
+                            #[allow(unreachable_code)]
+                            let this_collection_entries = self.$collection_property_name
+                                .into_iter()
+                                .map(|(key, entry_substate)| {
+                                    let key = scrypto_encode(&key).unwrap();
+                                    let value = map_entry_substate_to_kv_entry!($collection_type, entry_substate);
+                                    (key, value)
+                                })
+                                .collect();
+                            all_collection_entries.insert(collection_index, this_collection_entries);
+                            collection_index += 1;
+                        )*
+                        (field_values, all_collection_entries)
+                    }
+
+                    pub fn into_new_object<E, Y: ClientObjectApi<E>>(self, api: &mut Y) -> Result<NodeId, E> {
+                        let (field_values, all_collection_entries) = self.into_system_substates();
+                        api.new_object(
+                            stringify!($blueprint_ident),
+                            vec![], // Features
+                            None, // Instance schema
+                            field_values,
+                            all_collection_entries,
+                        )
+                    }
+                }
+
+                //-------------
+                // State API (TODO!)
+                //-------------
+
+                pub struct [<$blueprint_ident StateApi>]<'a, Y: ClientApi<RuntimeError>> {
+                    api: &'a mut Y,
+                }
+    
+                impl<'a, Y: ClientApi<RuntimeError>> [<$blueprint_ident StateApi>]<'a, Y> {
+                    pub fn with(client_api: &'a mut Y) -> Self {
+                        Self {
+                            api: client_api,
+                        }
+                    }
+                }
+    
+                impl<'a, Y: ClientApi<$crate::errors::RuntimeError>> From<&'a mut Y> for [<$blueprint_ident StateApi>]<'a, Y> {
+                    fn from(value: &'a mut Y) -> Self {
+                        Self::with(value)
+                    }
+                }
+            }
+            #[allow(unused)]
+            pub(crate) use [<$blueprint_ident _models>]::*;
+        }
+    }
+}
+
+// See PackageNativePackage "definition()"
+// See "create_bootstrap_package_partitions" in package.rs
+// See "globalize_package" in package.rs
+
+// This macro should:
+// * Able to create:
+//   - VersionedSubstateType
+//   - LatestSubstateType
+//
+// * Generate node_layout.rs
+//
+// And future, it would be cool to support:
+//
+// * Able to create BlueprintStateSchemaInit
+//  -> ie FieldSchema (field's type, and Condition)
+//  -> ie BlueprintCollectionSchema (one of three options, plus: key / value / can_own)
+//
+// * Able to create APIs for reading/writing individual fields
+
+// Fields:
+//
+
+pub(crate) use declare_native_blueprint_state;
+use radix_engine_common::types::PartitionNumber;
+
+#[derive(Debug, PartialEq, Eq, Sbor)]
+struct PackageRoyaltyFieldV1;
+
+#[derive(Debug, PartialEq, Eq, Sbor)]
+struct PackageBlueprintDefinitionValueV1;
+
+#[derive(Debug, PartialEq, Eq, Sbor)]
+struct PackageMyCoolIndexValueV1;
+
+#[derive(Debug, PartialEq, Eq, Sbor)]
+struct PackageMyCoolSortedIndexValueV1;
+
+use radix_engine_interface::blueprints::package::*;
+
+declare_native_blueprint_state!{
+    blueprint_ident: Package,
+    fields: {
+        royalty:  {
+            // Generates:
+            // - PackageRoyaltyField
+            // - VersionedPackageRoyaltyField
+            // Must find type called:
+            // - PackageRoyaltyFieldV1
+            ident: Royalty,
+            condition: Condition::Xyz (
+
+            ),
+        }
+    },
+    // Generates static colletion offsets + collection
+    // Eg PackageCollections::BlueprintDefinition.collection_offset()
+    // EG PackageCollections::BlueprintDefinition.partition_number()
+    collections: {
+        blueprint_definitions: KeyValue {
+            entry_ident: BlueprintDefinition,
+            key_type: BlueprintVersion,
+            can_own: true,
+        },
+        abc: Index {
+            entry_ident: MyCoolIndex,
+            key_type: BlueprintVersion,
+            can_own: true,
+        },
+        def: SortedIndex {
+            entry_ident: MyCoolSortedIndex,
+            key_type: BlueprintVersion,
+            can_own: true,
+        },
+    }
+}
+
+fn xyz() {
+    PackageField::Royalty;
+    PackagePartitionOffset::Fields;
+}
\ No newline at end of file
diff --git a/radix-engine/src/blueprints/mod.rs b/radix-engine/src/blueprints/mod.rs
index 7829195a341..cc70088cc2a 100644
--- a/radix-engine/src/blueprints/mod.rs
+++ b/radix-engine/src/blueprints/mod.rs
@@ -1,3 +1,4 @@
+pub mod macros;
 pub mod access_controller;
 pub mod account;
 pub mod consensus_manager;
diff --git a/radix-engine/src/system/system.rs b/radix-engine/src/system/system.rs
index 0274be4aa15..b2bfc95b033 100644
--- a/radix-engine/src/system/system.rs
+++ b/radix-engine/src/system/system.rs
@@ -71,6 +71,13 @@ impl<V> FieldSubstate<V> {
             mutability: SubstateMutability::Mutable,
         }
     }
+
+    pub fn new_locked_field(value: V) -> Self {
+        Self {
+            value: (value,),
+            mutability: SubstateMutability::Immutable,
+        }
+    }
 }
 
 pub type KeyValueEntrySubstate<V> = DynSubstate<Option<V>>;
diff --git a/sbor/src/versioned.rs b/sbor/src/versioned.rs
index 22719740ceb..74ce00d2032 100644
--- a/sbor/src/versioned.rs
+++ b/sbor/src/versioned.rs
@@ -126,7 +126,7 @@ macro_rules! define_versioned {
                     Self::[<V $latest_version>](value)
                 }
 
-                pub fn update_once(self) -> UpdateResult<Self> {
+                pub fn update_once(self) -> $crate::UpdateResult<Self> {
                     match self {
                     $($(
                         Self::[<V $version_num>](value) => $crate::UpdateResult::Updated(Self::[<V $update_to_version_num>](value.into())),
@@ -138,10 +138,10 @@ macro_rules! define_versioned {
                 pub fn update_to_latest(mut self) -> Self {
                     loop {
                         match self.update_once() {
-                            UpdateResult::Updated(new) => {
+                            $crate::UpdateResult::Updated(new) => {
                                 self = new;
                             }
-                            UpdateResult::AtLatest(latest) => {
+                            $crate::UpdateResult::AtLatest(latest) => {
                                 return latest;
                             }
                         }
@@ -204,7 +204,7 @@ macro_rules! define_versioned {
                     impl$(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? [<$name Version>] for $inner_type
                     {
                         type Versioned = $name $(< $( $lt ),+ >)?;
-        
+
                         fn into_versioned(self) -> Self::Versioned {
                             self.into()
                         }
@@ -311,13 +311,7 @@ mod tests {
         let v1_model: GenericModel<_> = GenericModelV1(51u64);
         let versioned = VersionedGenericModel::from(v1_model.clone());
         let versioned_2 = v1_model.clone().into_versioned();
-        assert_eq!(
-            versioned.clone().into_latest(),
-            v1_model.clone()
-        );
-        assert_eq!(
-            versioned,
-            versioned_2
-        );
+        assert_eq!(versioned.clone().into_latest(), v1_model.clone());
+        assert_eq!(versioned, versioned_2);
     }
 }

From 258b5690fc661cec05b7ddb72a81f373e135edd6 Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Thu, 10 Aug 2023 13:38:55 +0100
Subject: [PATCH 06/28] example: Add versioned schema

---
 .../src/data/scrypto/custom_schema.rs         |  4 +-
 radix-engine/src/blueprints/macros.rs         | 14 +++----
 radix-engine/src/blueprints/mod.rs            |  2 +-
 sbor/src/basic.rs                             |  1 +
 sbor/src/schema/schema.rs                     | 38 ++++++++++++++++---
 5 files changed, 45 insertions(+), 14 deletions(-)

diff --git a/radix-engine-common/src/data/scrypto/custom_schema.rs b/radix-engine-common/src/data/scrypto/custom_schema.rs
index 81418d373ea..64b5b74d18e 100644
--- a/radix-engine-common/src/data/scrypto/custom_schema.rs
+++ b/radix-engine-common/src/data/scrypto/custom_schema.rs
@@ -2,6 +2,7 @@ use crate::internal_prelude::*;
 
 pub type ScryptoTypeKind<L> = TypeKind<ScryptoCustomTypeKind, L>;
 pub type ScryptoSchema = Schema<ScryptoCustomSchema>;
+pub type VersionedScryptoSchema = VersionedSchema<ScryptoCustomSchema>;
 pub type ScryptoTypeData<L> = TypeData<ScryptoCustomTypeKind, L>;
 
 /// A schema for the values that a codec can decode / views as valid
@@ -205,7 +206,8 @@ pub trait HasSchemaHash {
     fn generate_schema_hash(&self) -> Hash;
 }
 
-impl HasSchemaHash for Schema<ScryptoCustomSchema> {
+// TODO - change to VersionedScryptoSchema when we use that in substates
+impl HasSchemaHash for ScryptoSchema {
     fn generate_schema_hash(&self) -> Hash {
         hash(scrypto_encode(self).unwrap())
     }
diff --git a/radix-engine/src/blueprints/macros.rs b/radix-engine/src/blueprints/macros.rs
index 2b8873d35d2..d866fc049ab 100644
--- a/radix-engine/src/blueprints/macros.rs
+++ b/radix-engine/src/blueprints/macros.rs
@@ -1,5 +1,5 @@
-use crate::types::*;
 use crate::system::system::*;
+use crate::types::*;
 
 pub trait FieldContent: Sized {
     type VersionedContent: From<Self>;
@@ -241,7 +241,7 @@ macro_rules! declare_native_blueprint_state {
 
                 impl TryFrom<&SubstateKey> for [<$blueprint_ident Field>] {
                     type Error = ();
-        
+
                     fn try_from(key: &SubstateKey) -> Result<Self, Self::Error> {
                         match key {
                             SubstateKey::Field(x) => Self::from_repr(*x).ok_or(()),
@@ -252,7 +252,7 @@ macro_rules! declare_native_blueprint_state {
 
                 impl TryFrom<u8> for [<$blueprint_ident Field>] {
                     type Error = ();
-                
+
                     fn try_from(offset: u8) -> Result<Self, Self::Error> {
                         Self::from_repr(offset).ok_or(())
                     }
@@ -373,7 +373,7 @@ macro_rules! declare_native_blueprint_state {
                 pub struct [<$blueprint_ident StateApi>]<'a, Y: ClientApi<RuntimeError>> {
                     api: &'a mut Y,
                 }
-    
+
                 impl<'a, Y: ClientApi<RuntimeError>> [<$blueprint_ident StateApi>]<'a, Y> {
                     pub fn with(client_api: &'a mut Y) -> Self {
                         Self {
@@ -381,7 +381,7 @@ macro_rules! declare_native_blueprint_state {
                         }
                     }
                 }
-    
+
                 impl<'a, Y: ClientApi<$crate::errors::RuntimeError>> From<&'a mut Y> for [<$blueprint_ident StateApi>]<'a, Y> {
                     fn from(value: &'a mut Y) -> Self {
                         Self::with(value)
@@ -433,7 +433,7 @@ struct PackageMyCoolSortedIndexValueV1;
 
 use radix_engine_interface::blueprints::package::*;
 
-declare_native_blueprint_state!{
+declare_native_blueprint_state! {
     blueprint_ident: Package,
     fields: {
         royalty:  {
@@ -473,4 +473,4 @@ declare_native_blueprint_state!{
 fn xyz() {
     PackageField::Royalty;
     PackagePartitionOffset::Fields;
-}
\ No newline at end of file
+}
diff --git a/radix-engine/src/blueprints/mod.rs b/radix-engine/src/blueprints/mod.rs
index cc70088cc2a..b5c80e63043 100644
--- a/radix-engine/src/blueprints/mod.rs
+++ b/radix-engine/src/blueprints/mod.rs
@@ -1,8 +1,8 @@
-pub mod macros;
 pub mod access_controller;
 pub mod account;
 pub mod consensus_manager;
 pub mod identity;
+pub mod macros;
 pub mod native_schema;
 pub mod package;
 pub mod pool;
diff --git a/sbor/src/basic.rs b/sbor/src/basic.rs
index adaba70de00..eb78e8329a6 100644
--- a/sbor/src/basic.rs
+++ b/sbor/src/basic.rs
@@ -259,6 +259,7 @@ pub type BasicRawValue<'a> = RawValue<'a, NoCustomExtension>;
 pub type BasicOwnedRawValue = RawValue<'static, NoCustomExtension>;
 pub type BasicTypeKind<L> = TypeKind<NoCustomTypeKind, L>;
 pub type BasicSchema = Schema<NoCustomSchema>;
+pub type BasicVersionedSchema = VersionedSchema<NoCustomSchema>;
 pub type BasicTypeData<L> = TypeData<NoCustomTypeKind, L>;
 
 impl<'a> CustomDisplayContext<'a> for () {
diff --git a/sbor/src/schema/schema.rs b/sbor/src/schema/schema.rs
index bef5157f8f9..39ea12673f5 100644
--- a/sbor/src/schema/schema.rs
+++ b/sbor/src/schema/schema.rs
@@ -1,14 +1,36 @@
 use crate::rust::prelude::*;
 use crate::*;
 
+define_versioned!(
+    #[derive(Debug, Clone, PartialEq, Eq, Sbor)]
+    #[sbor(child_types = "S::CustomTypeKind<LocalTypeIndex>, S::CustomTypeValidation")]
+    pub enum VersionedSchema<S: CustomSchema> {
+        latest_version: {
+            1 => Schema<S> = SchemaV1::<S>,
+        }
+    }
+);
+
+impl<S: CustomSchema> VersionedSchema<S> {
+    pub fn empty() -> Self {
+        Schema::empty().into()
+    }
+}
+
+impl<S: CustomSchema> Default for VersionedSchema<S> {
+    fn default() -> Self {
+        Self::empty()
+    }
+}
+
 /// An array of custom type kinds, and associated extra information which can attach to the type kinds
-#[derive(Default, Debug, Clone, PartialEq, Eq, Sbor)]
+#[derive(Debug, Clone, PartialEq, Eq, Sbor)]
 // NB - the generic parameter E isn't embedded in the value model itself - instead:
-// * Via TypeKind, E::CustomTypeKind<LocalTypeIndex> gets embedded
-// * Via TypeValidation, E::CustomTypeValidation gets embedded
+// * Via TypeKind, S::CustomTypeKind<LocalTypeIndex> gets embedded
+// * Via TypeValidation, S::CustomTypeValidation gets embedded
 // So theses are the child types which need to be registered with the sbor macro for it to compile
 #[sbor(child_types = "S::CustomTypeKind<LocalTypeIndex>, S::CustomTypeValidation")]
-pub struct Schema<S: CustomSchema> {
+pub struct SchemaV1<S: CustomSchema> {
     pub type_kinds: Vec<SchemaTypeKind<S>>,
     pub type_metadata: Vec<TypeMetadata>, // TODO: reconsider adding type hash when it's ready!
     pub type_validations: Vec<TypeValidation<S::CustomTypeValidation>>,
@@ -17,7 +39,7 @@ pub struct Schema<S: CustomSchema> {
 pub type SchemaTypeKind<S> =
     TypeKind<<S as CustomSchema>::CustomTypeKind<LocalTypeIndex>, LocalTypeIndex>;
 
-impl<S: CustomSchema> Schema<S> {
+impl<S: CustomSchema> SchemaV1<S> {
     pub fn empty() -> Self {
         Self {
             type_kinds: vec![],
@@ -121,6 +143,12 @@ impl<S: CustomSchema> Schema<S> {
     }
 }
 
+impl<S: CustomSchema> Default for SchemaV1<S> {
+    fn default() -> Self {
+        Self::empty()
+    }
+}
+
 #[derive(Debug, Default)]
 pub struct ArrayData<'m> {
     pub array_name: Option<&'m str>,

From 70e10b598e80c4d7d2988cbc21bc0e1f41534c5d Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Thu, 10 Aug 2023 14:34:19 +0100
Subject: [PATCH 07/28] feature: Started implementing Package state

---
 radix-engine/src/blueprints/macros.rs         | 482 +++++++++++-------
 radix-engine/src/blueprints/package/mod.rs    |   2 +
 .../src/blueprints/package/substates.rs       |  42 ++
 3 files changed, 345 insertions(+), 181 deletions(-)
 create mode 100644 radix-engine/src/blueprints/package/substates.rs

diff --git a/radix-engine/src/blueprints/macros.rs b/radix-engine/src/blueprints/macros.rs
index d866fc049ab..a4948c022a3 100644
--- a/radix-engine/src/blueprints/macros.rs
+++ b/radix-engine/src/blueprints/macros.rs
@@ -41,102 +41,6 @@ pub trait SortedIndexEntryContent: Sized {
     }
 }
 
-macro_rules! generate_wrapped_substate_type_alias {
-    (SystemField, $module_ident:ident, $field_ident:ident) => {
-        paste::paste! {
-            pub type [<$module_ident $field_ident FieldSubstate>] = [<Versioned $module_ident $field_ident Field>];
-        }
-    };
-    (Field, $blueprint_ident:ident, $field_ident:ident) => {
-        paste::paste! {
-            pub type [<$blueprint_ident $field_ident FieldSubstate>] = $crate::system::system::FieldSubstate<[<Versioned $blueprint_ident $field_ident Field>]>;
-        }
-    };
-    (KeyValue, $blueprint_ident:ident, $collection_ident:ident) => {
-        paste::paste! {
-            pub type [<$blueprint_ident $collection_ident EntrySubstate>] = $crate::system::system::KeyValueEntrySubstate<[<Versioned $blueprint_ident $collection_ident Value>]>;
-        }
-    };
-    (Index, $blueprint_ident:ident, $collection_ident:ident) => {
-        // No wrapper around Index substates
-        paste::paste! {
-            pub type [<$blueprint_ident $collection_ident EntrySubstate>] = [<Versioned $blueprint_ident $collection_ident Value>];
-        }
-    };
-    (SortedIndex, $blueprint_ident:ident, $collection_ident:ident) => {
-        // There is no wrapper around Index substates
-        paste::paste! {
-            pub type [<$blueprint_ident $collection_ident EntrySubstate>] = [<Versioned $blueprint_ident $collection_ident Value>];
-        }
-    };
-    ($unknown_system_substate_type:ident, $blueprint_ident:ident, $collection_ident:ident) => {
-        paste::paste! {
-            compile_error!(concat!(
-                "Unrecognized system substate type: `",
-                stringify!($unknown_system_substate_type),
-                "` - expected `Field`, `SystemField`, `KeyValue`, `Index` or `SortedIndex`"
-            ));
-        }
-    };
-}
-
-macro_rules! generate_collection_substate_content_trait {
-    (KeyValue, $type:ident, $versioned:ident) => {
-        impl KVEntryContent for $type {
-            type VersionedContent = $versioned;
-        }
-    };
-    (Index, $type:ident, $versioned:ident) => {
-        impl IndexEntryContent for $type {
-            type VersionedContent = $versioned;
-        }
-    };
-    (SortedIndex, $type:ident, $versioned:ident) => {
-        impl SortedIndexEntryContent for $type {
-            type VersionedContent = $versioned;
-        }
-    };
-    ($unknown_system_substate_type:ident, $type:ident, $versioned:ident) => {
-        paste::paste! {
-            compile_error!(concat!(
-                "Unrecognized system collection substate type: `",
-                stringify!($unknown_system_substate_type),
-                "` - expected `KeyValue`, `Index` or `SortedIndex`"
-            ));
-        }
-    };
-}
-
-macro_rules! map_entry_substate_to_kv_entry {
-    (KeyValue, $entry_substate:ident) => {
-        paste::paste! {
-            KVEntry {
-                value: $entry_substate.value.map(|v| scrypto_encode(&v).unwrap()),
-                locked: match $entry_substate.mutability {
-                    SubstateMutability::Mutable => true,
-                    SubstateMutability::Immutable => false,
-                },
-            }
-        }
-    };
-    (Index, $entry_substate:ident) => {
-        // This code still needs to compile, but it shouldn't be possible to execute
-        panic!("Not possible to map an Index entry to a KVEntry")
-    };
-    (SortedIndex, $entry_substate:ident) => {
-        // This code still needs to compile, but it shouldn't be possible to execute
-        panic!("Not possible to map a SortedIndex entry to a KVEntry")
-    };
-    ($unknown_system_substate_type:ident, $entry_substate:ident) => {
-        paste::paste! {
-            compile_error!(concat!(
-                "Unrecognized system collection substate type: `",
-                stringify!($unknown_system_substate_type),
-                "` - expected `KeyValue`, `Index` or `SortedIndex`"
-            ));
-        }
-    };
-}
 
 /// Generates types and typed-interfaces for native blueprints and their
 /// interaction with the substate store.
@@ -146,13 +50,38 @@ macro_rules! map_entry_substate_to_kv_entry {
 /// * For collections, assumes the existence of types called:
 ///    `<BlueprintIdent><CollectionIdent>Key`
 ///    `<BlueprintIdent><CollectionIdent>ValueV1`
+/// 
+/// In future, resolve the `x_type` fields as a $x:tt and then
+/// map in other macros into:
+/// ```
+///     StaticSingleVersioned,
+///     Static {
+///         the_type: x,
+///     },
+///     Instance {
+///         ident: 
+///     },
+///     StaticMultiVersioned(V1, V2),
+/// ```
+#[allow(unused)]
 macro_rules! declare_native_blueprint_state {
     (
         blueprint_ident: $blueprint_ident:ident,
+        blueprint_snake_case: $blueprint_property_name:ident,
+        instance_schema_types: [
+            // If no types => instance schema disabled
+            $(
+                $instance_type_property_name:ident: {
+                    ident: $instance_type_ident:ident,
+                }
+            ),*
+            $(,)?
+        ],
         fields: {
             $(
                 $field_property_name:ident: {
                     ident: $field_ident:ident,
+                    field_type: StaticSingleVersioned,
                     condition: $field_condition:expr
                     $(,)? // Optional trialing comma
                 }
@@ -163,7 +92,10 @@ macro_rules! declare_native_blueprint_state {
             $(
                 $collection_property_name:ident: $collection_type:ident {
                     entry_ident: $collection_ident:ident,
-                    key_type: $collection_key_type:ty,
+                    key_type: Static { // Will be Static { type: X } or Instance { index: X }
+                        the_type: $collection_key_type:ty,
+                    },
+                    value_type: StaticSingleVersioned,
                     can_own: $collection_can_own:expr
                     // Collection options for (eg) passing in a property name
                     // of the sorted index parameter for SortedIndex
@@ -176,8 +108,10 @@ macro_rules! declare_native_blueprint_state {
         $(,)?
     ) => {
         paste::paste! {
-            #[allow(unused_imports)]
-            mod [<$blueprint_ident _models>] {
+            pub use [<$blueprint_property_name _models>]::*;
+
+            #[allow(unused_imports, dead_code, unused_mut, unused_assignments, unused_variables, unreachable_code)]
+            mod [<$blueprint_property_name _models>] {
                 use super::*;
                 use sbor::*;
                 use $crate::types::*;
@@ -218,11 +152,10 @@ macro_rules! declare_native_blueprint_state {
                 )*
 
                 //--------------------------------------------------------
-                // Node Layout
-                // (to replace node_layout.rs)
+                // Node Layout (to replace node_layout.rs)
                 //--------------------------------------------------------
                 #[repr(u8)]
-                #[derive(Debug, Clone, Sbor, PartialEq, Eq, Hash, PartialOrd, Ord, FromRepr)]
+                #[derive(Debug, Clone, Copy, Sbor, PartialEq, Eq, Hash, PartialOrd, Ord, FromRepr)]
                 pub enum [<$blueprint_ident Field>] {
                     $($field_ident,)*
                 }
@@ -259,7 +192,7 @@ macro_rules! declare_native_blueprint_state {
                 }
 
                 #[repr(u8)]
-                #[derive(Debug, Clone, Sbor, PartialEq, Eq, Hash, PartialOrd, Ord, FromRepr)]
+                #[derive(Debug, Clone, Copy, Sbor, PartialEq, Eq, Hash, PartialOrd, Ord, FromRepr)]
                 pub enum [<$blueprint_ident Partition>] {
                     Field,
                     $([<$collection_ident $collection_type>],)*
@@ -271,7 +204,11 @@ macro_rules! declare_native_blueprint_state {
                     }
 
                     pub const fn main_partition(&self) -> PartitionNumber {
-                        MAIN_BASE_PARTITION.at_offset(self.offset()).unwrap()
+                        match MAIN_BASE_PARTITION.at_offset(self.offset()) {
+                            // Work around .unwrap() on Option not being const
+                            Some(x) => x,
+                            None => panic!("Offset larger than allowed value")
+                        }
                     }
                 }
 
@@ -301,11 +238,50 @@ macro_rules! declare_native_blueprint_state {
                     $([<$collection_ident $collection_type>]([<$blueprint_ident $collection_ident EntrySubstate>]),)*
                 }
 
+                //----------------------
+                // Schema
+                //----------------------
+                pub struct [<$blueprint_ident StateSchemaInit>];
+
+                impl [<$blueprint_ident StateSchemaInit>] {
+                    pub fn create_schema_init(
+                        type_aggregator: &mut TypeAggregator<ScryptoCustomTypeKind>,
+                    ) -> BlueprintStateSchemaInit {
+                        let mut fields = vec![];
+                        $(
+                            // TODO - Implement instance schema
+                            fields.push(FieldSchema {
+                                field: TypeRef::Static(
+                                    type_aggregator.add_child_type_and_descendents::<[<Versioned $blueprint_ident $field_ident Field>]>()
+                                ),
+                                condition: $field_condition,
+                            });
+                        )*
+                        let mut collections = vec![];
+                        $(
+                            // TODO - Implement instance schema
+                            collections.push(map_collection_schema!(
+                                $collection_type,
+                                type_aggregator,
+                                $collection_key_type,
+                                [<Versioned $blueprint_ident $collection_ident Value>],
+                                $collection_can_own
+                            ));
+                        )*
+                        BlueprintStateSchemaInit {
+                            fields,
+                            collections,
+                        }
+                    }
+                }
+
                 //----------------------
                 // Object Initialization
                 //----------------------
 
-                /// This doesn't support:
+                /// Used for initializing blueprint state.
+                ///
+                /// Note - this doesn't support:
                 /// * Features
                 /// * Instance schemas
                 /// * Feature-dependent fields
@@ -339,7 +315,6 @@ macro_rules! declare_native_blueprint_state {
                         let mut all_collection_entries = BTreeMap::new();
                         let mut collection_index: u8 = 0;
                         $(
-                            #[allow(unreachable_code)]
                             let this_collection_entries = self.$collection_property_name
                                 .into_iter()
                                 .map(|(key, entry_substate)| {
@@ -388,89 +363,234 @@ macro_rules! declare_native_blueprint_state {
                     }
                 }
             }
-            #[allow(unused)]
-            pub(crate) use [<$blueprint_ident _models>]::*;
         }
     }
 }
 
-// See PackageNativePackage "definition()"
-// See "create_bootstrap_package_partitions" in package.rs
-// See "globalize_package" in package.rs
-
-// This macro should:
-// * Able to create:
-//   - VersionedSubstateType
-//   - LatestSubstateType
-//
-// * Generate node_layout.rs
-//
-// And future, it would be cool to support:
-//
-// * Able to create BlueprintStateSchemaInit
-//  -> ie FieldSchema (field's type, and Condition)
-//  -> ie BlueprintCollectionSchema (one of three options, plus: key / value / can_own)
-//
-// * Able to create APIs for reading/writing individual fields
-
-// Fields:
-//
-
+#[allow(unused)]
 pub(crate) use declare_native_blueprint_state;
-use radix_engine_common::types::PartitionNumber;
-
-#[derive(Debug, PartialEq, Eq, Sbor)]
-struct PackageRoyaltyFieldV1;
-
-#[derive(Debug, PartialEq, Eq, Sbor)]
-struct PackageBlueprintDefinitionValueV1;
 
-#[derive(Debug, PartialEq, Eq, Sbor)]
-struct PackageMyCoolIndexValueV1;
+pub(crate) use helper_macros::*;
 
-#[derive(Debug, PartialEq, Eq, Sbor)]
-struct PackageMyCoolSortedIndexValueV1;
-
-use radix_engine_interface::blueprints::package::*;
-
-declare_native_blueprint_state! {
-    blueprint_ident: Package,
-    fields: {
-        royalty:  {
-            // Generates:
-            // - PackageRoyaltyField
-            // - VersionedPackageRoyaltyField
-            // Must find type called:
-            // - PackageRoyaltyFieldV1
-            ident: Royalty,
-            condition: Condition::Xyz (
-
-            ),
-        }
-    },
-    // Generates static colletion offsets + collection
-    // Eg PackageCollections::BlueprintDefinition.collection_offset()
-    // EG PackageCollections::BlueprintDefinition.partition_number()
-    collections: {
-        blueprint_definitions: KeyValue {
-            entry_ident: BlueprintDefinition,
-            key_type: BlueprintVersion,
-            can_own: true,
-        },
-        abc: Index {
-            entry_ident: MyCoolIndex,
-            key_type: BlueprintVersion,
-            can_own: true,
-        },
-        def: SortedIndex {
-            entry_ident: MyCoolSortedIndex,
-            key_type: BlueprintVersion,
-            can_own: true,
-        },
+mod helper_macros {
+    macro_rules! generate_wrapped_substate_type_alias {
+        (SystemField, $module_ident:ident, $field_ident:ident) => {
+            paste::paste! {
+                pub type [<$module_ident $field_ident FieldSubstate>] = [<Versioned $module_ident $field_ident Field>];
+            }
+        };
+        (Field, $blueprint_ident:ident, $field_ident:ident) => {
+            paste::paste! {
+                pub type [<$blueprint_ident $field_ident FieldSubstate>] = $crate::system::system::FieldSubstate<[<Versioned $blueprint_ident $field_ident Field>]>;
+            }
+        };
+        (KeyValue, $blueprint_ident:ident, $collection_ident:ident) => {
+            paste::paste! {
+                pub type [<$blueprint_ident $collection_ident EntrySubstate>] = $crate::system::system::KeyValueEntrySubstate<[<Versioned $blueprint_ident $collection_ident Value>]>;
+            }
+        };
+        (Index, $blueprint_ident:ident, $collection_ident:ident) => {
+            // No wrapper around Index substates
+            paste::paste! {
+                pub type [<$blueprint_ident $collection_ident EntrySubstate>] = [<Versioned $blueprint_ident $collection_ident Value>];
+            }
+        };
+        (SortedIndex, $blueprint_ident:ident, $collection_ident:ident) => {
+            // There is no wrapper around Index substates
+            paste::paste! {
+                pub type [<$blueprint_ident $collection_ident EntrySubstate>] = [<Versioned $blueprint_ident $collection_ident Value>];
+            }
+        };
+        ($unknown_system_substate_type:ident, $blueprint_ident:ident, $collection_ident:ident) => {
+            paste::paste! {
+                compile_error!(concat!(
+                    "Unrecognized system substate type: `",
+                    stringify!($unknown_system_substate_type),
+                    "` - expected `Field`, `SystemField`, `KeyValue`, `Index` or `SortedIndex`"
+                ));
+            }
+        };
     }
+    
+    #[allow(unused)]
+    pub(crate) use generate_wrapped_substate_type_alias;
+    
+    macro_rules! generate_collection_substate_content_trait {
+        (KeyValue, $type:ident, $versioned:ident) => {
+            impl KVEntryContent for $type {
+                type VersionedContent = $versioned;
+            }
+        };
+        (Index, $type:ident, $versioned:ident) => {
+            impl IndexEntryContent for $type {
+                type VersionedContent = $versioned;
+            }
+        };
+        (SortedIndex, $type:ident, $versioned:ident) => {
+            impl SortedIndexEntryContent for $type {
+                type VersionedContent = $versioned;
+            }
+        };
+        ($unknown_system_substate_type:ident, $type:ident, $versioned:ident) => {
+            paste::paste! {
+                compile_error!(concat!(
+                    "Unrecognized system collection substate type: `",
+                    stringify!($unknown_system_substate_type),
+                    "` - expected `KeyValue`, `Index` or `SortedIndex`"
+                ));
+            }
+        };
+    }
+    
+    #[allow(unused)]
+    pub(crate) use generate_collection_substate_content_trait;
+    
+    macro_rules! map_collection_schema {
+        (KeyValue, $aggregator:ident, $collection_key_type:ty, $collection_value_type:ty, $collection_can_own:expr$(,)?) => {
+            paste::paste! {
+                BlueprintCollectionSchema::KeyValueStore(
+                    BlueprintKeyValueSchema {
+                        key: TypeRef::Static(
+                            $aggregator.add_child_type_and_descendents::<$collection_key_type>(),
+                        ),
+                        value: TypeRef::Static(
+                            $aggregator.add_child_type_and_descendents::<$collection_value_type>()
+                        ),
+                        can_own: $collection_can_own,
+                    },
+                )
+            }
+        };
+        (Index, $aggregator:ident, $collection_key_type:ty, $collection_value_type:ty, $collection_can_own:expr$(,)?) => {
+            BlueprintCollectionSchema::Index(
+                BlueprintKeyValueSchema {
+                    key: TypeRef::Static(
+                        $aggregator.add_child_type_and_descendents::<$collection_key_type>(),
+                    ),
+                    value: TypeRef::Static(
+                        $aggregator.add_child_type_and_descendents::<$collection_value_type>()
+                    ),
+                    can_own: $collection_can_own,
+                },
+            )
+        };
+        (SortedIndex, $aggregator:ident, $collection_key_type:ty, $collection_value_type:ty, $collection_can_own:expr$(,)?) => {
+            BlueprintCollectionSchema::SortedIndex(
+                BlueprintKeyValueSchema {
+                    key: TypeRef::Static(
+                        $aggregator.add_child_type_and_descendents::<$collection_key_type>(),
+                    ),
+                    value: TypeRef::Static(
+                        $aggregator.add_child_type_and_descendents::<$collection_value_type>()
+                    ),
+                    can_own: $collection_can_own,
+                },
+            )
+        };
+        ($unknown_system_substate_type:ident, $aggregator:ident, $collection_key_type:ty, $collection_value_type:ty, $collection_can_own:expr$(,)?) => {
+            paste::paste! {
+                compile_error!(concat!(
+                    "Unrecognized system collection substate type: `",
+                    stringify!($unknown_system_substate_type),
+                    "` - expected `KeyValue`, `Index` or `SortedIndex`"
+                ));
+            }
+        };
+    }
+    
+    #[allow(unused)]
+    pub(crate) use map_collection_schema;
+    
+    macro_rules! map_entry_substate_to_kv_entry {
+        (KeyValue, $entry_substate:ident) => {
+            paste::paste! {
+                KVEntry {
+                    value: $entry_substate.value.map(|v| scrypto_encode(&v).unwrap()),
+                    locked: match $entry_substate.mutability {
+                        SubstateMutability::Mutable => true,
+                        SubstateMutability::Immutable => false,
+                    },
+                }
+            }
+        };
+        (Index, $entry_substate:ident) => {
+            // This code still needs to compile, but it shouldn't be possible to execute
+            panic!("Not possible to map an Index entry to a KVEntry")
+        };
+        (SortedIndex, $entry_substate:ident) => {
+            // This code still needs to compile, but it shouldn't be possible to execute
+            panic!("Not possible to map a SortedIndex entry to a KVEntry")
+        };
+        ($unknown_system_substate_type:ident, $entry_substate:ident) => {
+            paste::paste! {
+                compile_error!(concat!(
+                    "Unrecognized system collection substate type: `",
+                    stringify!($unknown_system_substate_type),
+                    "` - expected `KeyValue`, `Index` or `SortedIndex`"
+                ));
+            }
+        };
+    }
+    
+    #[allow(unused)]
+    pub(crate) use map_entry_substate_to_kv_entry;
 }
 
-fn xyz() {
-    PackageField::Royalty;
-    PackagePartitionOffset::Fields;
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Check that the below compiles
+    #[derive(Debug, PartialEq, Eq, Sbor)]
+    pub struct PackageRoyaltyFieldV1;
+    
+    #[derive(Debug, PartialEq, Eq, Sbor)]
+    pub struct PackageBlueprintDefinitionValueV1;
+    
+    #[derive(Debug, PartialEq, Eq, Sbor)]
+    pub struct PackageMyCoolIndexValueV1;
+    
+    #[derive(Debug, PartialEq, Eq, Sbor)]
+    pub struct PackageMyCoolSortedIndexValueV1;
+    
+    use radix_engine_interface::blueprints::package::*;
+    
+    declare_native_blueprint_state! {
+        blueprint_ident: Package,
+        blueprint_snake_case: package,
+        instance_schema_types: [],
+        fields: {
+            royalty:  {
+                ident: Royalty,
+                field_type: StaticSingleVersioned,
+                condition: Condition::Always,
+            }
+        },
+        collections: {
+            blueprint_definitions: KeyValue {
+                entry_ident: BlueprintDefinition,
+                key_type: Static {
+                    the_type: BlueprintVersion,
+                },
+                value_type: StaticSingleVersioned,
+                can_own: true,
+            },
+            abc: Index {
+                entry_ident: MyCoolIndex,
+                key_type: Static {
+                    the_type: BlueprintVersion,
+                },
+                value_type: StaticSingleVersioned,
+                can_own: true,
+            },
+            def: SortedIndex {
+                entry_ident: MyCoolSortedIndex,
+                key_type: Static {
+                    the_type: BlueprintVersion,
+                },
+                value_type: StaticSingleVersioned,
+                can_own: true,
+            },
+        }
+    }    
 }
diff --git a/radix-engine/src/blueprints/package/mod.rs b/radix-engine/src/blueprints/package/mod.rs
index cdc10407e57..dd0fdfe9188 100644
--- a/radix-engine/src/blueprints/package/mod.rs
+++ b/radix-engine/src/blueprints/package/mod.rs
@@ -1,3 +1,5 @@
 mod package;
+mod substates;
 
+pub use substates::*;
 pub use package::*;
diff --git a/radix-engine/src/blueprints/package/substates.rs b/radix-engine/src/blueprints/package/substates.rs
new file mode 100644
index 00000000000..fc6a36dca61
--- /dev/null
+++ b/radix-engine/src/blueprints/package/substates.rs
@@ -0,0 +1,42 @@
+use crate::blueprints::macros::*;
+use super::*;
+use crate::types::*;
+
+declare_native_blueprint_state!{
+    blueprint_ident: Package,
+    blueprint_snake_case: package,
+    instance_schema_types: [],
+    fields: {
+        royalty:  {
+            ident: RoyaltyAccumulator,
+            field_type: StaticSingleVersioned,
+            condition: Condition::Always,
+        }
+    },
+    collections: {
+        blueprint_definitions: KeyValue {
+            entry_ident: BlueprintDefinition,
+            key_type: Static {
+                the_type: BlueprintVersionKey,
+            },
+            value_type: StaticSingleVersioned,
+            can_own: false,
+        },
+    }
+}
+
+//-------------
+// Field models
+//-------------
+
+#[derive(Debug, PartialEq, Eq, ScryptoSbor)]
+pub struct PackageRoyaltyAccumulatorFieldV1 {
+    /// The vault for collecting package royalties.
+    pub royalty_vault: Vault,
+}
+
+//-------------
+// Collection models
+//-------------
+
+pub type PackageBlueprintDefinitionValueV1 = BlueprintDefinition;
\ No newline at end of file

From 69bddd60b071c2f9baaf5b48225f6c8b2226ca3c Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Thu, 10 Aug 2023 17:46:36 +0100
Subject: [PATCH 08/28] tweak: Add support for different type refs

---
 radix-engine/src/blueprints/macros.rs         | 349 +++++++++++-------
 .../src/blueprints/package/substates.rs       | 143 ++++++-
 2 files changed, 346 insertions(+), 146 deletions(-)

diff --git a/radix-engine/src/blueprints/macros.rs b/radix-engine/src/blueprints/macros.rs
index a4948c022a3..c2aedf14de0 100644
--- a/radix-engine/src/blueprints/macros.rs
+++ b/radix-engine/src/blueprints/macros.rs
@@ -2,41 +2,49 @@ use crate::system::system::*;
 use crate::types::*;
 
 pub trait FieldContent: Sized {
-    type VersionedContent: From<Self>;
+    type ActualContent: From<Self>;
 
-    fn into_locked_substate(self) -> FieldSubstate<Self::VersionedContent> {
+    fn into_locked_substate(self) -> FieldSubstate<Self::ActualContent> {
         FieldSubstate::new_locked_field(self.into())
     }
 
-    fn into_mutable_substate(self) -> FieldSubstate<Self::VersionedContent> {
+    fn into_mutable_substate(self) -> FieldSubstate<Self::ActualContent> {
         FieldSubstate::new_field(self.into())
     }
 }
 
-pub trait KVEntryContent: Sized {
-    type VersionedContent: From<Self>;
+pub trait KeyContent: Sized {
+    type ActualContent: From<Self>;
 
-    fn into_locked_substate(self) -> KeyValueEntrySubstate<Self::VersionedContent> {
+    fn into_key(self) -> Self::ActualContent {
+        self.into()
+    }
+}
+
+pub trait KeyValueEntryContent: Sized {
+    type ActualContent: From<Self>;
+
+    fn into_locked_substate(self) -> KeyValueEntrySubstate<Self::ActualContent> {
         KeyValueEntrySubstate::entry(self.into())
     }
 
-    fn into_mutable_substate(self) -> KeyValueEntrySubstate<Self::VersionedContent> {
+    fn into_mutable_substate(self) -> KeyValueEntrySubstate<Self::ActualContent> {
         KeyValueEntrySubstate::locked_entry(self.into())
     }
 }
 
 pub trait IndexEntryContent: Sized {
-    type VersionedContent: From<Self>;
+    type ActualContent: From<Self>;
 
-    fn into_substate(self) -> Self::VersionedContent {
+    fn into_substate(self) -> Self::ActualContent {
         self.into()
     }
 }
 
 pub trait SortedIndexEntryContent: Sized {
-    type VersionedContent: From<Self>;
+    type ActualContent: From<Self>;
 
-    fn into_substate(self) -> Self::VersionedContent {
+    fn into_substate(self) -> Self::ActualContent {
         self.into()
     }
 }
@@ -46,10 +54,9 @@ pub trait SortedIndexEntryContent: Sized {
 /// interaction with the substate store.
 ///
 /// * For fields, assumes the existence of a type called:
-///    `<BlueprintIdent><FieldIdent>FieldV1`
+///    * `<BlueprintIdent><FieldIdent>FieldV1`
 /// * For collections, assumes the existence of types called:
-///    `<BlueprintIdent><CollectionIdent>Key`
-///    `<BlueprintIdent><CollectionIdent>ValueV1`
+///    * `<BlueprintIdent><CollectionIdent>ValueV1`
 /// 
 /// In future, resolve the `x_type` fields as a $x:tt and then
 /// map in other macros into:
@@ -81,7 +88,7 @@ macro_rules! declare_native_blueprint_state {
             $(
                 $field_property_name:ident: {
                     ident: $field_ident:ident,
-                    field_type: StaticSingleVersioned,
+                    field_type: $field_type:tt,
                     condition: $field_condition:expr
                     $(,)? // Optional trialing comma
                 }
@@ -92,10 +99,8 @@ macro_rules! declare_native_blueprint_state {
             $(
                 $collection_property_name:ident: $collection_type:ident {
                     entry_ident: $collection_ident:ident,
-                    key_type: Static { // Will be Static { type: X } or Instance { index: X }
-                        the_type: $collection_key_type:ty,
-                    },
-                    value_type: StaticSingleVersioned,
+                    key_type: $collection_key_type:tt,
+                    value_type: $collection_value_type:tt,
                     can_own: $collection_can_own:expr
                     // Collection options for (eg) passing in a property name
                     // of the sorted index parameter for SortedIndex
@@ -124,31 +129,44 @@ macro_rules! declare_native_blueprint_state {
 
                 // Generate models for each field
                 $(
-                    // TODO: In future, expand this macro to support multi-versioned fields
-                    sbor::define_single_versioned!(
-                        #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
-                        pub enum [<Versioned $blueprint_ident $field_ident Field>] => [<$blueprint_ident $field_ident Field>] = [<$blueprint_ident $field_ident FieldV1>]
+                    generate_content_type_aliases!(
+                        content_trait: FieldContent,
+                        ident_core: [<$blueprint_ident $field_ident Field>],
+                        type [<$blueprint_ident $field_ident FieldContent>] = $field_type
+                    );
+                    // Part 2 - Generate the common Substate type aliases for FieldContent
+                    generate_system_substate_type_alias!(
+                        Field,
+                        type [<$blueprint_ident $field_ident FieldSubstate>] = WRAPPED [<$blueprint_ident $field_ident FieldContent>]
                     );
-                    generate_wrapped_substate_type_alias!(Field, $blueprint_ident, $field_ident);
-                    impl FieldContent for [<Versioned $blueprint_ident $field_ident Field>] {
-                        type VersionedContent = Self;
-                    }
-                    impl FieldContent for [<$blueprint_ident $field_ident Field>] {
-                        type VersionedContent = [<Versioned $blueprint_ident $field_ident Field>];
-                    }
                 );*
 
                 // Generate models for each collection
                 $(
-                    pub type [<$blueprint_ident $collection_ident Key>] = $collection_key_type;
-                    // TODO: In future, expand this macro to support multi-versioned collection values
-                    sbor::define_single_versioned!(
-                        #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
-                        pub enum [<Versioned $blueprint_ident $collection_ident Value>] => [<$blueprint_ident $collection_ident Value>] = [<$blueprint_ident $collection_ident ValueV1>]
+                    // Key
+                    // > Set up any Versioned types
+                    // > Set up the _KeyContent alias
+                    // > Set up the KeyContent traits
+                    generate_content_type_aliases!(
+                        content_trait: KeyContent,
+                        ident_core: [<$blueprint_ident $collection_ident KeyInner>],
+                        type [<$blueprint_ident $collection_ident Key>] = $collection_key_type
+                    );
+
+                    // Values
+                    // > Set up any Versioned types
+                    // > Set up the _ValueContent alias
+                    // > Set up the _EntryContent traits
+                    generate_content_type_aliases!(
+                        content_trait: [<$collection_type EntryContent>],
+                        ident_core: [<$blueprint_ident $collection_ident Value>],
+                        type [<$blueprint_ident $collection_ident ValueContent>] = $collection_value_type
+                    );
+                    // > Set up the _EntrySubstate alias
+                    generate_system_substate_type_alias!(
+                        $collection_type,
+                        type [<$blueprint_ident $collection_ident EntrySubstate>] = WRAPPED [<$blueprint_ident $collection_ident ValueContent>]
                     );
-                    generate_wrapped_substate_type_alias!($collection_type, $blueprint_ident, $collection_ident);
-                    generate_collection_substate_content_trait!($collection_type, [<Versioned $blueprint_ident $collection_ident Value>], Self);
-                    generate_collection_substate_content_trait!($collection_type, [<$blueprint_ident $collection_ident Value>], [<Versioned $blueprint_ident $collection_ident Value>]);
                 )*
 
                 //--------------------------------------------------------
@@ -264,7 +282,9 @@ macro_rules! declare_native_blueprint_state {
                                 $collection_type,
                                 type_aggregator,
                                 $collection_key_type,
-                                [<Versioned $blueprint_ident $collection_ident Value>],
+                                [<$blueprint_ident $collection_ident Key>],
+                                $collection_value_type,
+                                [<$blueprint_ident $collection_ident ValueContent>],
                                 $collection_can_own
                             ));
                         )*
@@ -373,133 +393,177 @@ pub(crate) use declare_native_blueprint_state;
 pub(crate) use helper_macros::*;
 
 mod helper_macros {
-    macro_rules! generate_wrapped_substate_type_alias {
-        (SystemField, $module_ident:ident, $field_ident:ident) => {
-            paste::paste! {
-                pub type [<$module_ident $field_ident FieldSubstate>] = [<Versioned $module_ident $field_ident Field>];
-            }
-        };
-        (Field, $blueprint_ident:ident, $field_ident:ident) => {
-            paste::paste! {
-                pub type [<$blueprint_ident $field_ident FieldSubstate>] = $crate::system::system::FieldSubstate<[<Versioned $blueprint_ident $field_ident Field>]>;
-            }
-        };
-        (KeyValue, $blueprint_ident:ident, $collection_ident:ident) => {
+    macro_rules! generate_content_type_aliases {
+        (
+            content_trait: $content_trait:ident,
+            ident_core: $ident_core:ident,
+            type $alias:ident = {
+                kind: StaticSingleVersioned
+                $(,)?
+            }$(,)?
+        ) => {
             paste::paste! {
-                pub type [<$blueprint_ident $collection_ident EntrySubstate>] = $crate::system::system::KeyValueEntrySubstate<[<Versioned $blueprint_ident $collection_ident Value>]>;
-            }
-        };
-        (Index, $blueprint_ident:ident, $collection_ident:ident) => {
-            // No wrapper around Index substates
-            paste::paste! {
-                pub type [<$blueprint_ident $collection_ident EntrySubstate>] = [<Versioned $blueprint_ident $collection_ident Value>];
+                sbor::define_single_versioned!(
+                    #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
+                    pub enum [<Versioned $ident_core>] => $ident_core = [<$ident_core V1>]
+                );
+                pub type $alias = [<Versioned $ident_core>];
+                impl $content_trait for $ident_core {
+                    type ActualContent = $alias;
+                }
+                impl $content_trait for $alias {
+                    type ActualContent = Self;
+                }
             }
         };
-        (SortedIndex, $blueprint_ident:ident, $collection_ident:ident) => {
-            // There is no wrapper around Index substates
+        (
+            content_trait: $content_trait:ident,
+            ident_core: $ident_core:ident,
+            type $alias:ident = {
+                kind: Static,
+                the_type: $static_type:ty
+                $(,)?
+            }$(,)?
+        ) => {
             paste::paste! {
-                pub type [<$blueprint_ident $collection_ident EntrySubstate>] = [<Versioned $blueprint_ident $collection_ident Value>];
+                pub type $alias = $static_type;
+                // TODO(David) - Fix this for eg BlueprintVersion being used in multiple keys
+                // Maybe by making these aliases actually new-types(?)
+                // impl $content_trait for $alias {
+                //     type ActualContent = Self;
+                // }
             }
         };
-        ($unknown_system_substate_type:ident, $blueprint_ident:ident, $collection_ident:ident) => {
-            paste::paste! {
-                compile_error!(concat!(
-                    "Unrecognized system substate type: `",
-                    stringify!($unknown_system_substate_type),
-                    "` - expected `Field`, `SystemField`, `KeyValue`, `Index` or `SortedIndex`"
-                ));
+        (
+            content_trait: $content_trait:ident,
+            ident_core: $ident_core:ident,
+            type $alias:ident = {
+                kind: Instance,
+                ident: $instance_ident:ident
+                $(,)?
             }
+        ) => {
+            // Don't output any types for an instance schema
         };
+        // TODO - Add support for some kind of StaticMultiVersioned type here
     }
     
     #[allow(unused)]
-    pub(crate) use generate_wrapped_substate_type_alias;
-    
-    macro_rules! generate_collection_substate_content_trait {
-        (KeyValue, $type:ident, $versioned:ident) => {
-            impl KVEntryContent for $type {
-                type VersionedContent = $versioned;
-            }
+    pub(crate) use generate_content_type_aliases;
+
+    macro_rules! generate_system_substate_type_alias {
+        (SystemField, type $alias:ident = WRAPPED $content:ty$(,)?) => {
+            // There is no system wrapper around SystemField substates
+            pub type $alias = $content;
         };
-        (Index, $type:ident, $versioned:ident) => {
-            impl IndexEntryContent for $type {
-                type VersionedContent = $versioned;
-            }
+        (Field, type $alias:ident = WRAPPED $content:ty$(,)?) => {
+            pub type $alias = FieldSubstate<$content>;
         };
-        (SortedIndex, $type:ident, $versioned:ident) => {
-            impl SortedIndexEntryContent for $type {
-                type VersionedContent = $versioned;
-            }
+        (KeyValue, type $alias:ident = WRAPPED $content:ty$(,)?) => {
+            pub type $alias = KeyValueEntrySubstate<$content>;
         };
-        ($unknown_system_substate_type:ident, $type:ident, $versioned:ident) => {
-            paste::paste! {
-                compile_error!(concat!(
-                    "Unrecognized system collection substate type: `",
-                    stringify!($unknown_system_substate_type),
-                    "` - expected `KeyValue`, `Index` or `SortedIndex`"
-                ));
-            }
+        (Index, type $alias:ident = WRAPPED $content:ty$(,)?) => {
+            // There is no system wrapper around Index substates
+            pub type $alias = $content;
+        };
+        (SortedIndex, type $alias:ident = WRAPPED $content:ty$(,)?) => {
+            // There is no system wrapper around SortedIndex substates
+            pub type $alias = $content;
+        };
+        ($unknown_system_substate_type:ident, type $alias:ident = WRAPPED $content:ty$(,)?) => {
+            compile_error!(concat!(
+                "Unrecognized system substate type: `",
+                stringify!($unknown_system_substate_type),
+                "` - expected `Field`, `SystemField`, `KeyValue`, `Index` or `SortedIndex`"
+            ));
         };
     }
     
     #[allow(unused)]
-    pub(crate) use generate_collection_substate_content_trait;
+    pub(crate) use generate_system_substate_type_alias;
     
     macro_rules! map_collection_schema {
-        (KeyValue, $aggregator:ident, $collection_key_type:ty, $collection_value_type:ty, $collection_can_own:expr$(,)?) => {
-            paste::paste! {
-                BlueprintCollectionSchema::KeyValueStore(
-                    BlueprintKeyValueSchema {
-                        key: TypeRef::Static(
-                            $aggregator.add_child_type_and_descendents::<$collection_key_type>(),
-                        ),
-                        value: TypeRef::Static(
-                            $aggregator.add_child_type_and_descendents::<$collection_value_type>()
-                        ),
-                        can_own: $collection_can_own,
-                    },
-                )
-            }
+        (KeyValue, $aggregator:ident, $key_type:tt, $key_content_alias:ident, $value_type:tt, $value_content_alias:ident, $can_own:expr$(,)?) => {
+            BlueprintCollectionSchema::KeyValueStore(
+                BlueprintKeyValueSchema {
+                    key: map_type_ref!($aggregator, $key_type, $key_content_alias),
+                    value: map_type_ref!($aggregator, $value_type, $value_content_alias),
+                    can_own: $can_own,
+                },
+            )
         };
-        (Index, $aggregator:ident, $collection_key_type:ty, $collection_value_type:ty, $collection_can_own:expr$(,)?) => {
+        (Index, $aggregator:ident, $key_type:tt, $key_content_alias:ident, $value_type:tt, $value_content_alias:ident, $can_own:expr$(,)?) => {
             BlueprintCollectionSchema::Index(
                 BlueprintKeyValueSchema {
-                    key: TypeRef::Static(
-                        $aggregator.add_child_type_and_descendents::<$collection_key_type>(),
-                    ),
-                    value: TypeRef::Static(
-                        $aggregator.add_child_type_and_descendents::<$collection_value_type>()
-                    ),
-                    can_own: $collection_can_own,
+                    key: map_type_ref!($aggregator, $key_type, $key_content_alias),
+                    value: map_type_ref!($aggregator, $value_type, $value_content_alias),
+                    can_own: $can_own,
                 },
             )
         };
-        (SortedIndex, $aggregator:ident, $collection_key_type:ty, $collection_value_type:ty, $collection_can_own:expr$(,)?) => {
+        (SortedIndex, $aggregator:ident, $key_type:tt, $key_content_alias:ident, $value_type:tt, $value_content_alias:ident, $can_own:expr$(,)?) => {
             BlueprintCollectionSchema::SortedIndex(
                 BlueprintKeyValueSchema {
-                    key: TypeRef::Static(
-                        $aggregator.add_child_type_and_descendents::<$collection_key_type>(),
-                    ),
-                    value: TypeRef::Static(
-                        $aggregator.add_child_type_and_descendents::<$collection_value_type>()
-                    ),
-                    can_own: $collection_can_own,
+                    key: map_type_ref!($aggregator, $key_type, $key_content_alias),
+                    value: map_type_ref!($aggregator, $value_type, $value_content_alias),
+                    can_own: $can_own,
                 },
             )
         };
-        ($unknown_system_substate_type:ident, $aggregator:ident, $collection_key_type:ty, $collection_value_type:ty, $collection_can_own:expr$(,)?) => {
-            paste::paste! {
-                compile_error!(concat!(
-                    "Unrecognized system collection substate type: `",
-                    stringify!($unknown_system_substate_type),
-                    "` - expected `KeyValue`, `Index` or `SortedIndex`"
-                ));
-            }
+        ($unknown_system_substate_type:ident, $aggregator:ident, $collection_key_type:tt, $collection_value_type:tt, $collection_can_own:expr$(,)?) => {
+            compile_error!(concat!(
+                "Unrecognized system collection substate type: `",
+                stringify!($unknown_system_substate_type),
+                "` - expected `KeyValue`, `Index` or `SortedIndex`"
+            ));
         };
     }
     
     #[allow(unused)]
     pub(crate) use map_collection_schema;
+
+    macro_rules! map_type_ref {
+        (
+            $aggregator:ident,
+            {
+                kind: StaticSingleVersioned
+                $(,)?
+            },
+            $content_alias:ident$(,)?
+        ) => {
+            TypeRef::Static(
+                $aggregator.add_child_type_and_descendents::<$content_alias>(),
+            )
+        };
+        (
+            $aggregator:ident,
+            {
+                kind: Static,
+                the_type: $static_type:ty
+                $(,)?
+            },
+            $content_alias:ident$(,)?
+        ) => {
+            TypeRef::Static(
+                $aggregator.add_child_type_and_descendents::<$content_alias>(),
+            )
+        };
+        (
+            $aggregator:ident,
+            {
+                kind: Instance,
+                ident: $instance_ident:ident
+                $(,)?
+            },
+            $content_alias:ident$(,)?
+        ) => {
+            compile_error!("Instance schemas not yet supported - close though!")
+        };
+        // TODO - Add support for some kind of StaticMultiVersioned type here
+    }
+
+    #[allow(unused)]
+    pub(crate) use map_type_ref;
     
     macro_rules! map_entry_substate_to_kv_entry {
         (KeyValue, $entry_substate:ident) => {
@@ -562,33 +626,44 @@ mod tests {
         fields: {
             royalty:  {
                 ident: Royalty,
-                field_type: StaticSingleVersioned,
+                field_type: {
+                    kind: StaticSingleVersioned,
+                },
                 condition: Condition::Always,
             }
         },
         collections: {
             blueprint_definitions: KeyValue {
                 entry_ident: BlueprintDefinition,
-                key_type: Static {
+                key_type: {
+                    kind: Static,
                     the_type: BlueprintVersion,
                 },
-                value_type: StaticSingleVersioned,
+                value_type: {
+                    kind: StaticSingleVersioned,
+                },
                 can_own: true,
             },
             abc: Index {
                 entry_ident: MyCoolIndex,
-                key_type: Static {
+                key_type: {
+                    kind: Static,
                     the_type: BlueprintVersion,
                 },
-                value_type: StaticSingleVersioned,
+                value_type: {
+                    kind: StaticSingleVersioned,
+                },
                 can_own: true,
             },
             def: SortedIndex {
                 entry_ident: MyCoolSortedIndex,
-                key_type: Static {
+                key_type: {
+                    kind: Static,
                     the_type: BlueprintVersion,
                 },
-                value_type: StaticSingleVersioned,
+                value_type: {
+                    kind: StaticSingleVersioned,
+                },
                 can_own: true,
             },
         }
diff --git a/radix-engine/src/blueprints/package/substates.rs b/radix-engine/src/blueprints/package/substates.rs
index fc6a36dca61..34f9dff8301 100644
--- a/radix-engine/src/blueprints/package/substates.rs
+++ b/radix-engine/src/blueprints/package/substates.rs
@@ -9,17 +9,99 @@ declare_native_blueprint_state!{
     fields: {
         royalty:  {
             ident: RoyaltyAccumulator,
-            field_type: StaticSingleVersioned,
+            field_type: {
+                kind: StaticSingleVersioned,
+            },
             condition: Condition::Always,
         }
     },
     collections: {
-        blueprint_definitions: KeyValue {
-            entry_ident: BlueprintDefinition,
-            key_type: Static {
+        blueprint_version_definitions: KeyValue {
+            entry_ident: BlueprintVersionDefinition,
+            key_type: {
+                kind: Static,
+                the_type: BlueprintVersionKey,
+            },
+            value_type: {
+                kind: StaticSingleVersioned,
+            },
+            can_own: false,
+        },
+        blueprint_version_dependencies: KeyValue {
+            entry_ident: BlueprintVersionDependencies,
+            key_type: {
+                kind: Static,
+                the_type: BlueprintVersionKey,
+            },
+            value_type: {
+                kind: StaticSingleVersioned,
+            },
+            can_own: false,
+        },
+        schemas: KeyValue {
+            entry_ident: Schema,
+            key_type: {
+                kind: Static,
+                the_type: SchemaHash,
+            },
+            value_type: {
+                kind: StaticSingleVersioned,
+            },
+            can_own: false,
+        },
+        blueprint_version_royalty_configs: KeyValue {
+            entry_ident: BlueprintVersionRoyaltyConfig,
+            key_type: {
+                kind: Static,
+                the_type: BlueprintVersionKey,
+            },
+            value_type: {
+                kind: StaticSingleVersioned,
+            },
+            can_own: false,
+        },
+        blueprint_version_auth_configs: KeyValue {
+            entry_ident: BlueprintVersionAuthConfig,
+            key_type: {
+                kind: Static,
                 the_type: BlueprintVersionKey,
             },
-            value_type: StaticSingleVersioned,
+            value_type: {
+                kind: StaticSingleVersioned,
+            },
+            can_own: false,
+        },
+        code_vm_type: KeyValue {
+            entry_ident: CodeVmType,
+            key_type: {
+                kind: Static,
+                the_type: CodeHash,
+            },
+            value_type: {
+                kind: StaticSingleVersioned,
+            },
+            can_own: false,
+        },
+        code_original_code: KeyValue {
+            entry_ident: CodeOriginalCode,
+            key_type: {
+                kind: Static,
+                the_type: CodeHash,
+            },
+            value_type: {
+                kind: StaticSingleVersioned,
+            },
+            can_own: false,
+        },
+        code_instrumented_code: KeyValue {
+            entry_ident: CodeInstrumentedCode,
+            key_type: {
+                kind: Static,
+                the_type: CodeHash,
+            },
+            value_type: {
+                kind: StaticSingleVersioned,
+            },
             can_own: false,
         },
     }
@@ -35,8 +117,51 @@ pub struct PackageRoyaltyAccumulatorFieldV1 {
     pub royalty_vault: Vault,
 }
 
-//-------------
-// Collection models
-//-------------
+//---------------------------------------
+// Collection models - Schemas
+//---------------------------------------
+
+define_wrapped_hash!(
+    /// Represents a particular schema under a package
+    SchemaHash
+);
 
-pub type PackageBlueprintDefinitionValueV1 = BlueprintDefinition;
\ No newline at end of file
+// TODO(David): Change to VersionedSchema when can define a type as not-implicitly-versioned
+// TODO: Move to Schema partition when we have it
+pub type PackageSchemaValueV1 = ScryptoSchema;
+
+//---------------------------------------
+// Collection models - By BlueprintVersion
+//---------------------------------------
+
+pub type PackageBlueprintVersionDefinitionValueV1 = BlueprintDefinition;
+pub type PackageBlueprintVersionDependenciesValueV1 = BlueprintDependencies;
+pub type PackageBlueprintVersionRoyaltyConfigValueV1 = PackageRoyaltyConfig;
+pub type PackageBlueprintVersionAuthConfigValueV1 = AuthConfig;
+
+//---------------------------------------
+// Collection models - By Code
+//---------------------------------------
+
+define_wrapped_hash!(
+    /// Represents a particular instance of code under a package
+    CodeHash
+);
+
+#[derive(Debug, PartialEq, Eq, ScryptoSbor)]
+#[sbor(transparent)]
+pub struct PackageCodeVmTypeValueV1 {
+    pub vm_type: VmType,
+}
+
+#[derive(Debug, PartialEq, Eq, ScryptoSbor)]
+#[sbor(transparent)]
+pub struct PackageCodeOriginalCodeValueV1 {
+    pub code: Vec<u8>,
+}
+
+#[derive(Debug, PartialEq, Eq, ScryptoSbor)]
+#[sbor(transparent)]
+pub struct PackageCodeInstrumentedCodeValueV1 {
+    pub code: Vec<u8>,
+}
\ No newline at end of file

From 24aaef813fa627bd2f17908270ba0ca7b42e6f16 Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Thu, 10 Aug 2023 17:54:30 +0100
Subject: [PATCH 09/28] feature: Partial implementation for Package state

---
 radix-engine/src/blueprints/macros.rs         |  79 ++++++--------
 radix-engine/src/blueprints/package/mod.rs    |   2 +-
 .../src/blueprints/package/package.rs         | 103 +-----------------
 .../src/blueprints/package/substates.rs       |   6 +-
 4 files changed, 43 insertions(+), 147 deletions(-)

diff --git a/radix-engine/src/blueprints/macros.rs b/radix-engine/src/blueprints/macros.rs
index c2aedf14de0..d4790fadc29 100644
--- a/radix-engine/src/blueprints/macros.rs
+++ b/radix-engine/src/blueprints/macros.rs
@@ -49,7 +49,6 @@ pub trait SortedIndexEntryContent: Sized {
     }
 }
 
-
 /// Generates types and typed-interfaces for native blueprints and their
 /// interaction with the substate store.
 ///
@@ -57,7 +56,7 @@ pub trait SortedIndexEntryContent: Sized {
 ///    * `<BlueprintIdent><FieldIdent>FieldV1`
 /// * For collections, assumes the existence of types called:
 ///    * `<BlueprintIdent><CollectionIdent>ValueV1`
-/// 
+///
 /// In future, resolve the `x_type` fields as a $x:tt and then
 /// map in other macros into:
 /// ```
@@ -66,7 +65,7 @@ pub trait SortedIndexEntryContent: Sized {
 ///         the_type: x,
 ///     },
 ///     Instance {
-///         ident: 
+///         ident:
 ///     },
 ///     StaticMultiVersioned(V1, V2),
 /// ```
@@ -444,10 +443,9 @@ mod helper_macros {
             }
         ) => {
             // Don't output any types for an instance schema
-        };
-        // TODO - Add support for some kind of StaticMultiVersioned type here
+        }; // TODO - Add support for some kind of StaticMultiVersioned type here
     }
-    
+
     #[allow(unused)]
     pub(crate) use generate_content_type_aliases;
 
@@ -478,37 +476,31 @@ mod helper_macros {
             ));
         };
     }
-    
+
     #[allow(unused)]
     pub(crate) use generate_system_substate_type_alias;
-    
+
     macro_rules! map_collection_schema {
         (KeyValue, $aggregator:ident, $key_type:tt, $key_content_alias:ident, $value_type:tt, $value_content_alias:ident, $can_own:expr$(,)?) => {
-            BlueprintCollectionSchema::KeyValueStore(
-                BlueprintKeyValueSchema {
-                    key: map_type_ref!($aggregator, $key_type, $key_content_alias),
-                    value: map_type_ref!($aggregator, $value_type, $value_content_alias),
-                    can_own: $can_own,
-                },
-            )
+            BlueprintCollectionSchema::KeyValueStore(BlueprintKeyValueSchema {
+                key: map_type_ref!($aggregator, $key_type, $key_content_alias),
+                value: map_type_ref!($aggregator, $value_type, $value_content_alias),
+                can_own: $can_own,
+            })
         };
         (Index, $aggregator:ident, $key_type:tt, $key_content_alias:ident, $value_type:tt, $value_content_alias:ident, $can_own:expr$(,)?) => {
-            BlueprintCollectionSchema::Index(
-                BlueprintKeyValueSchema {
-                    key: map_type_ref!($aggregator, $key_type, $key_content_alias),
-                    value: map_type_ref!($aggregator, $value_type, $value_content_alias),
-                    can_own: $can_own,
-                },
-            )
+            BlueprintCollectionSchema::Index(BlueprintKeyValueSchema {
+                key: map_type_ref!($aggregator, $key_type, $key_content_alias),
+                value: map_type_ref!($aggregator, $value_type, $value_content_alias),
+                can_own: $can_own,
+            })
         };
         (SortedIndex, $aggregator:ident, $key_type:tt, $key_content_alias:ident, $value_type:tt, $value_content_alias:ident, $can_own:expr$(,)?) => {
-            BlueprintCollectionSchema::SortedIndex(
-                BlueprintKeyValueSchema {
-                    key: map_type_ref!($aggregator, $key_type, $key_content_alias),
-                    value: map_type_ref!($aggregator, $value_type, $value_content_alias),
-                    can_own: $can_own,
-                },
-            )
+            BlueprintCollectionSchema::SortedIndex(BlueprintKeyValueSchema {
+                key: map_type_ref!($aggregator, $key_type, $key_content_alias),
+                value: map_type_ref!($aggregator, $value_type, $value_content_alias),
+                can_own: $can_own,
+            })
         };
         ($unknown_system_substate_type:ident, $aggregator:ident, $collection_key_type:tt, $collection_value_type:tt, $collection_can_own:expr$(,)?) => {
             compile_error!(concat!(
@@ -518,7 +510,7 @@ mod helper_macros {
             ));
         };
     }
-    
+
     #[allow(unused)]
     pub(crate) use map_collection_schema;
 
@@ -531,9 +523,7 @@ mod helper_macros {
             },
             $content_alias:ident$(,)?
         ) => {
-            TypeRef::Static(
-                $aggregator.add_child_type_and_descendents::<$content_alias>(),
-            )
+            TypeRef::Static($aggregator.add_child_type_and_descendents::<$content_alias>())
         };
         (
             $aggregator:ident,
@@ -544,9 +534,7 @@ mod helper_macros {
             },
             $content_alias:ident$(,)?
         ) => {
-            TypeRef::Static(
-                $aggregator.add_child_type_and_descendents::<$content_alias>(),
-            )
+            TypeRef::Static($aggregator.add_child_type_and_descendents::<$content_alias>())
         };
         (
             $aggregator:ident,
@@ -558,13 +546,12 @@ mod helper_macros {
             $content_alias:ident$(,)?
         ) => {
             compile_error!("Instance schemas not yet supported - close though!")
-        };
-        // TODO - Add support for some kind of StaticMultiVersioned type here
+        }; // TODO - Add support for some kind of StaticMultiVersioned type here
     }
 
     #[allow(unused)]
     pub(crate) use map_type_ref;
-    
+
     macro_rules! map_entry_substate_to_kv_entry {
         (KeyValue, $entry_substate:ident) => {
             paste::paste! {
@@ -595,7 +582,7 @@ mod helper_macros {
             }
         };
     }
-    
+
     #[allow(unused)]
     pub(crate) use map_entry_substate_to_kv_entry;
 }
@@ -607,18 +594,18 @@ mod tests {
     // Check that the below compiles
     #[derive(Debug, PartialEq, Eq, Sbor)]
     pub struct PackageRoyaltyFieldV1;
-    
+
     #[derive(Debug, PartialEq, Eq, Sbor)]
     pub struct PackageBlueprintDefinitionValueV1;
-    
+
     #[derive(Debug, PartialEq, Eq, Sbor)]
     pub struct PackageMyCoolIndexValueV1;
-    
+
     #[derive(Debug, PartialEq, Eq, Sbor)]
     pub struct PackageMyCoolSortedIndexValueV1;
-    
+
     use radix_engine_interface::blueprints::package::*;
-    
+
     declare_native_blueprint_state! {
         blueprint_ident: Package,
         blueprint_snake_case: package,
@@ -667,5 +654,5 @@ mod tests {
                 can_own: true,
             },
         }
-    }    
+    }
 }
diff --git a/radix-engine/src/blueprints/package/mod.rs b/radix-engine/src/blueprints/package/mod.rs
index dd0fdfe9188..043ea1854da 100644
--- a/radix-engine/src/blueprints/package/mod.rs
+++ b/radix-engine/src/blueprints/package/mod.rs
@@ -1,5 +1,5 @@
 mod package;
 mod substates;
 
-pub use substates::*;
 pub use package::*;
+pub use substates::*;
diff --git a/radix-engine/src/blueprints/package/package.rs b/radix-engine/src/blueprints/package/package.rs
index b5077bd8f9c..ef882b7c94b 100644
--- a/radix-engine/src/blueprints/package/package.rs
+++ b/radix-engine/src/blueprints/package/package.rs
@@ -14,16 +14,10 @@ use native_sdk::resource::NativeVault;
 use native_sdk::resource::ResourceManager;
 use radix_engine_interface::api::node_modules::auth::AuthAddresses;
 use radix_engine_interface::api::node_modules::metadata::MetadataInit;
-use radix_engine_interface::api::{
-    ClientApi, FieldValue, KVEntry, LockFlags, ObjectModuleId, OBJECT_HANDLE_SELF,
-};
+use radix_engine_interface::api::*;
 pub use radix_engine_interface::blueprints::package::*;
 use radix_engine_interface::blueprints::resource::{require, Bucket};
-use radix_engine_interface::schema::{
-    BlueprintCollectionSchema, BlueprintEventSchemaInit, BlueprintFunctionsSchemaInit,
-    BlueprintKeyValueSchema, BlueprintSchemaInit, BlueprintStateSchemaInit, FieldSchema,
-    FunctionSchemaInit, TypeRef,
-};
+use radix_engine_interface::schema::*;
 use sbor::LocalTypeIndex;
 use syn::Ident;
 
@@ -42,6 +36,8 @@ pub use radix_engine_interface::blueprints::package::{
     PackageInstrumentedCodeSubstate, PackageOriginalCodeSubstate, PackageRoyaltyAccumulatorSubstate,
 };
 
+use super::*;
+
 pub const PACKAGE_ROYALTY_FEATURE: &str = "package_royalty";
 
 #[derive(Debug, Clone, PartialEq, Eq, ScryptoSbor)]
@@ -843,91 +839,7 @@ impl PackageNativePackage {
     pub fn definition() -> PackageDefinition {
         let mut aggregator = TypeAggregator::<ScryptoCustomTypeKind>::new();
 
-        let mut fields = Vec::new();
-        fields.push(FieldSchema::if_feature(
-            aggregator.add_child_type_and_descendents::<PackageRoyaltyAccumulatorSubstate>(),
-            PACKAGE_ROYALTY_FEATURE,
-        ));
-
-        let mut collections = Vec::new();
-        collections.push(BlueprintCollectionSchema::KeyValueStore(
-            BlueprintKeyValueSchema {
-                key: TypeRef::Static(
-                    aggregator.add_child_type_and_descendents::<BlueprintVersionKey>(),
-                ),
-                value: TypeRef::Static(
-                    aggregator.add_child_type_and_descendents::<BlueprintDefinition>(),
-                ),
-                can_own: false,
-            },
-        ));
-        collections.push(BlueprintCollectionSchema::KeyValueStore(
-            BlueprintKeyValueSchema {
-                key: TypeRef::Static(
-                    aggregator.add_child_type_and_descendents::<BlueprintVersionKey>(),
-                ),
-                value: TypeRef::Static(
-                    aggregator.add_child_type_and_descendents::<BlueprintDependencies>(),
-                ),
-                can_own: false,
-            },
-        ));
-        collections.push(BlueprintCollectionSchema::KeyValueStore(
-            BlueprintKeyValueSchema {
-                key: TypeRef::Static(aggregator.add_child_type_and_descendents::<Hash>()),
-                value: TypeRef::Static(
-                    aggregator.add_child_type_and_descendents::<ScryptoSchema>(),
-                ),
-                can_own: false,
-            },
-        ));
-        collections.push(BlueprintCollectionSchema::KeyValueStore(
-            BlueprintKeyValueSchema {
-                key: TypeRef::Static(
-                    aggregator.add_child_type_and_descendents::<BlueprintVersionKey>(),
-                ),
-                value: TypeRef::Static(
-                    aggregator.add_child_type_and_descendents::<PackageRoyaltyConfig>(),
-                ),
-                can_own: false,
-            },
-        ));
-        collections.push(BlueprintCollectionSchema::KeyValueStore(
-            BlueprintKeyValueSchema {
-                key: TypeRef::Static(
-                    aggregator.add_child_type_and_descendents::<BlueprintVersionKey>(),
-                ),
-                value: TypeRef::Static(aggregator.add_child_type_and_descendents::<AuthConfig>()),
-                can_own: false,
-            },
-        ));
-        collections.push(BlueprintCollectionSchema::KeyValueStore(
-            BlueprintKeyValueSchema {
-                key: TypeRef::Static(aggregator.add_child_type_and_descendents::<Hash>()),
-                value: TypeRef::Static(
-                    aggregator.add_child_type_and_descendents::<PackageVmTypeSubstate>(),
-                ),
-                can_own: false,
-            },
-        ));
-        collections.push(BlueprintCollectionSchema::KeyValueStore(
-            BlueprintKeyValueSchema {
-                key: TypeRef::Static(aggregator.add_child_type_and_descendents::<Hash>()),
-                value: TypeRef::Static(
-                    aggregator.add_child_type_and_descendents::<PackageOriginalCodeSubstate>(),
-                ),
-                can_own: false,
-            },
-        ));
-        collections.push(BlueprintCollectionSchema::KeyValueStore(
-            BlueprintKeyValueSchema {
-                key: TypeRef::Static(aggregator.add_child_type_and_descendents::<Hash>()),
-                value: TypeRef::Static(
-                    aggregator.add_child_type_and_descendents::<PackageInstrumentedCodeSubstate>(),
-                ),
-                can_own: false,
-            },
-        ));
+        let state = PackageStateSchemaInit::create_schema_init(&mut aggregator);
 
         let mut functions = BTreeMap::new();
         functions.insert(
@@ -999,10 +911,7 @@ impl PackageNativePackage {
                 schema: BlueprintSchemaInit {
                     generics: vec![],
                     schema,
-                    state: BlueprintStateSchemaInit {
-                        fields,
-                        collections,
-                    },
+                    state,
                     events: BlueprintEventSchemaInit::default(),
                     functions: BlueprintFunctionsSchemaInit {
                         functions,
diff --git a/radix-engine/src/blueprints/package/substates.rs b/radix-engine/src/blueprints/package/substates.rs
index 34f9dff8301..7e7dec5e79b 100644
--- a/radix-engine/src/blueprints/package/substates.rs
+++ b/radix-engine/src/blueprints/package/substates.rs
@@ -1,8 +1,8 @@
-use crate::blueprints::macros::*;
 use super::*;
+use crate::blueprints::macros::*;
 use crate::types::*;
 
-declare_native_blueprint_state!{
+declare_native_blueprint_state! {
     blueprint_ident: Package,
     blueprint_snake_case: package,
     instance_schema_types: [],
@@ -164,4 +164,4 @@ pub struct PackageCodeOriginalCodeValueV1 {
 #[sbor(transparent)]
 pub struct PackageCodeInstrumentedCodeValueV1 {
     pub code: Vec<u8>,
-}
\ No newline at end of file
+}

From b04288bbbce494bbec4abcedb4cdbb45d23fc382 Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Thu, 10 Aug 2023 18:08:08 +0100
Subject: [PATCH 10/28] tweak: Add some clearer TODOs

---
 radix-engine-common/src/data/scrypto/custom_schema.rs | 2 +-
 radix-engine/src/blueprints/macros.rs                 | 7 ++++---
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/radix-engine-common/src/data/scrypto/custom_schema.rs b/radix-engine-common/src/data/scrypto/custom_schema.rs
index 64b5b74d18e..518524b944a 100644
--- a/radix-engine-common/src/data/scrypto/custom_schema.rs
+++ b/radix-engine-common/src/data/scrypto/custom_schema.rs
@@ -206,7 +206,7 @@ pub trait HasSchemaHash {
     fn generate_schema_hash(&self) -> Hash;
 }
 
-// TODO - change to VersionedScryptoSchema when we use that in substates
+// TODO(David) - change to hash the VersionedScryptoSchema when we use that in substates
 impl HasSchemaHash for ScryptoSchema {
     fn generate_schema_hash(&self) -> Hash {
         hash(scrypto_encode(self).unwrap())
diff --git a/radix-engine/src/blueprints/macros.rs b/radix-engine/src/blueprints/macros.rs
index d4790fadc29..949f7a672d7 100644
--- a/radix-engine/src/blueprints/macros.rs
+++ b/radix-engine/src/blueprints/macros.rs
@@ -266,7 +266,7 @@ macro_rules! declare_native_blueprint_state {
                     ) -> BlueprintStateSchemaInit {
                         let mut fields = vec![];
                         $(
-                            // TODO - Implement instance schema
+                            // TODO(David) - Implement instance schema
                             fields.push(FieldSchema {
                                 field: TypeRef::Static(
                                     type_aggregator.add_child_type_and_descendents::<[<Versioned $blueprint_ident $field_ident Field>]>()
@@ -276,7 +276,7 @@ macro_rules! declare_native_blueprint_state {
                         )*
                         let mut collections = vec![];
                         $(
-                            // TODO - Implement instance schema
+                            // TODO(David) - Implement instance schema
                             collections.push(map_collection_schema!(
                                 $collection_type,
                                 type_aggregator,
@@ -427,7 +427,8 @@ mod helper_macros {
             paste::paste! {
                 pub type $alias = $static_type;
                 // TODO(David) - Fix this for eg BlueprintVersion being used in multiple keys
-                // Maybe by making these aliases actually new-types(?)
+                // - Maybe by making these aliases actually new-types(?)
+                // - Or by removing these traits completely perhaps...
                 // impl $content_trait for $alias {
                 //     type ActualContent = Self;
                 // }

From c0adfeb9adea20d6f959a3e71401394f2469a761 Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Fri, 11 Aug 2023 11:46:46 +0100
Subject: [PATCH 11/28] impl: Continue package impl of new types

---
 radix-engine/src/blueprints/macros.rs         | 157 +++++--
 .../src/blueprints/package/package.rs         | 406 ++++++------------
 radix-engine/src/system/bootstrap.rs          |   4 +-
 3 files changed, 252 insertions(+), 315 deletions(-)

diff --git a/radix-engine/src/blueprints/macros.rs b/radix-engine/src/blueprints/macros.rs
index 949f7a672d7..a9980df5232 100644
--- a/radix-engine/src/blueprints/macros.rs
+++ b/radix-engine/src/blueprints/macros.rs
@@ -57,17 +57,25 @@ pub trait SortedIndexEntryContent: Sized {
 /// * For collections, assumes the existence of types called:
 ///    * `<BlueprintIdent><CollectionIdent>ValueV1`
 ///
-/// In future, resolve the `x_type` fields as a $x:tt and then
-/// map in other macros into:
+/// The types should look something like
 /// ```
-///     StaticSingleVersioned,
-///     Static {
+///     {
+///         kind: StaticSingleVersioned,
+///     }
+///     {
+///         kind: Static,
 ///         the_type: x,
 ///     },
-///     Instance {
-///         ident:
+///     {
+///         kind: Instance,
+///         ident: GenericTypeParameterName,
 ///     },
-///     StaticMultiVersioned(V1, V2),
+///     // In future
+///     {
+///         kind: StaticMultiVersioned,
+///         previous_versions: [V1, V2],
+///         latest: V3,
+///     }
 /// ```
 #[allow(unused)]
 macro_rules! declare_native_blueprint_state {
@@ -119,6 +127,7 @@ macro_rules! declare_native_blueprint_state {
                 use super::*;
                 use sbor::*;
                 use $crate::types::*;
+                use $crate::track::interface::*;
                 use $crate::errors::RuntimeError;
                 use $crate::system::system::*;
                 use radix_engine_interface::api::*;
@@ -220,7 +229,7 @@ macro_rules! declare_native_blueprint_state {
                         PartitionOffset(*self as u8)
                     }
 
-                    pub const fn main_partition(&self) -> PartitionNumber {
+                    pub const fn as_main_partition(&self) -> PartitionNumber {
                         match MAIN_BASE_PARTITION.at_offset(self.offset()) {
                             // Work around .unwrap() on Option not being const
                             Some(x) => x,
@@ -307,7 +316,7 @@ macro_rules! declare_native_blueprint_state {
                 /// * IndexEntries (because the underlying new_object API doesn't support them)
                 pub struct [<$blueprint_ident StateInit>] {
                     $(
-                        pub $field_property_name: [<$blueprint_ident $field_ident FieldSubstate>],
+                        pub $field_property_name: Option<[<$blueprint_ident $field_ident FieldSubstate>]>,
                     )*
                     $(
                         pub $collection_property_name: IndexMap<
@@ -321,31 +330,111 @@ macro_rules! declare_native_blueprint_state {
                     pub fn into_system_substates(self) -> (Vec<FieldValue>, BTreeMap<u8, BTreeMap<Vec<u8>, KVEntry>>) {
                         let mut field_values = vec![];
                         $(
-                            let field_content = scrypto_encode(&self.$field_property_name.value).unwrap();
-                            let locked = match &self.$field_property_name.mutability {
-                                SubstateMutability::Mutable => true,
-                                SubstateMutability::Immutable => false,
-                            };
-                            field_values.push(FieldValue {
-                                value: field_content,
-                                locked,
-                            });
+                            {
+                                let field = self.$field_property_name.expect(
+                                    concat!(
+                                        "The field `",
+                                        stringify!($field_property_name),
+                                        "` was None. Until the system and macro supports feature-based optional fields, all fields need to be present"
+                                    )
+                                );
+                                let field_content = scrypto_encode(&field.value).unwrap();
+                                let locked = match &field.mutability {
+                                    SubstateMutability::Mutable => true,
+                                    SubstateMutability::Immutable => false,
+                                };
+                                field_values.push(FieldValue {
+                                    value: field_content,
+                                    locked,
+                                });
+                            }
                         )*
                         let mut all_collection_entries = BTreeMap::new();
                         let mut collection_index: u8 = 0;
                         $(
-                            let this_collection_entries = self.$collection_property_name
+                            {
+                                let this_collection_entries = self.$collection_property_name
+                                    .into_iter()
+                                    .map(|(key, entry_substate)| {
+                                        let key = scrypto_encode(&key).unwrap();
+                                        let value = map_entry_substate_to_kv_entry!($collection_type, entry_substate);
+                                        (key, value)
+                                    })
+                                    .collect();
+                                all_collection_entries.insert(collection_index, this_collection_entries);
+                                collection_index += 1;
+                            }
+                        )*
+                        (field_values, all_collection_entries)
+                    }
+
+                    /// This is used mostly for flashing
+                    pub fn into_kernel_main_partitions(self) -> NodeSubstates {
+                        // PartitionNumber => SubstateKey => IndexedScryptoValue
+                        let mut partitions: NodeSubstates = BTreeMap::new();
+                        let (field_values, mut kv_entries) = self.into_system_substates();
+
+                        // Fields
+                        {
+                            let mut field_index = 0u8;
+                            let mut field_partition_substates = BTreeMap::new();
+                            $({
+                                let key = SubstateKey::from([<$blueprint_ident Field>]::$field_ident);
+                                let expected_field_index = u8::from([<$blueprint_ident Field>]::$field_ident);
+                                // Double-check they agree
+                                assert_eq!(field_index, expected_field_index);
+                                field_partition_substates.insert(
+                                    key,
+                                    IndexedScryptoValue::from_typed(&field_values[field_index as usize]),
+                                );
+                                field_index += 1;
+                            })*
+                            partitions.insert(
+                                [<$blueprint_ident Partition>]::Field.as_main_partition(),
+                                field_partition_substates,
+                            );
+                        }
+
+                        // Each Collection
+                        $({
+                            let mut collection_index = 0u8;
+                            let collection_kv_entries = kv_entries.remove(&collection_index).unwrap();
+                            let collection_partition = [<$blueprint_ident Partition>]::[<$collection_ident $collection_type>];
+                            let collection_partition_substates = collection_kv_entries
                                 .into_iter()
-                                .map(|(key, entry_substate)| {
-                                    let key = scrypto_encode(&key).unwrap();
-                                    let value = map_entry_substate_to_kv_entry!($collection_type, entry_substate);
-                                    (key, value)
+                                .filter_map(|(key_bytes, kv_entry)| {
+                                    let substate = match kv_entry {
+                                        KVEntry { value: Some(value_bytes), locked: false } => {
+                                            KeyValueEntrySubstate::entry(
+                                                scrypto_decode::<ScryptoValue>(&value_bytes).unwrap()
+                                            )
+                                        }
+                                        KVEntry { value: Some(value_bytes), locked: true } => {
+                                            KeyValueEntrySubstate::locked_entry(
+                                                scrypto_decode::<ScryptoValue>(&value_bytes).unwrap()
+                                            )
+                                        }
+                                        KVEntry { value: None, locked: true } => {
+                                            KeyValueEntrySubstate::locked_empty_entry()
+                                        }
+                                        KVEntry { value: None, locked: false } => {
+                                            return None;
+                                        }
+                                    };
+
+                                    Some((
+                                        SubstateKey::Map(key_bytes),
+                                        IndexedScryptoValue::from_typed(&substate)
+                                    ))
                                 })
                                 .collect();
-                            all_collection_entries.insert(collection_index, this_collection_entries);
-                            collection_index += 1;
-                        )*
-                        (field_values, all_collection_entries)
+                            partitions.insert(
+                                collection_partition.as_main_partition(),
+                                collection_partition_substates,
+                            );
+                        })*
+
+                        partitions
                     }
 
                     pub fn into_new_object<E, Y: ClientObjectApi<E>>(self, api: &mut Y) -> Result<NodeId, E> {
@@ -594,21 +683,21 @@ mod tests {
 
     // Check that the below compiles
     #[derive(Debug, PartialEq, Eq, Sbor)]
-    pub struct PackageRoyaltyFieldV1;
+    pub struct TestBlueprintRoyaltyFieldV1;
 
     #[derive(Debug, PartialEq, Eq, Sbor)]
-    pub struct PackageBlueprintDefinitionValueV1;
+    pub struct TestBlueprintMyCoolKeyValueStoreValueV1;
 
     #[derive(Debug, PartialEq, Eq, Sbor)]
-    pub struct PackageMyCoolIndexValueV1;
+    pub struct TestBlueprintMyCoolIndexValueV1;
 
     #[derive(Debug, PartialEq, Eq, Sbor)]
-    pub struct PackageMyCoolSortedIndexValueV1;
+    pub struct TestBlueprintMyCoolSortedIndexValueV1;
 
     use radix_engine_interface::blueprints::package::*;
 
     declare_native_blueprint_state! {
-        blueprint_ident: Package,
+        blueprint_ident: TestBlueprint,
         blueprint_snake_case: package,
         instance_schema_types: [],
         fields: {
@@ -621,8 +710,8 @@ mod tests {
             }
         },
         collections: {
-            blueprint_definitions: KeyValue {
-                entry_ident: BlueprintDefinition,
+            some_key_value_store: KeyValue {
+                entry_ident: MyCoolKeyValueStore,
                 key_type: {
                     kind: Static,
                     the_type: BlueprintVersion,
diff --git a/radix-engine/src/blueprints/package/package.rs b/radix-engine/src/blueprints/package/package.rs
index ef882b7c94b..d8859421d67 100644
--- a/radix-engine/src/blueprints/package/package.rs
+++ b/radix-engine/src/blueprints/package/package.rs
@@ -1,3 +1,4 @@
+use crate::blueprints::macros::*;
 use crate::blueprints::util::SecurifiedRoleAssignment;
 use crate::errors::*;
 use crate::kernel::kernel_api::{KernelApi, KernelSubstateApi};
@@ -474,172 +475,44 @@ impl SecurifiedRoleAssignment for SecurifiedPackage {
 }
 
 pub fn create_bootstrap_package_partitions(
-    package_structure: PackageStructure,
+    mut package_state_init: PackageStateInit,
     metadata: MetadataInit,
 ) -> NodeSubstates {
-    let mut partitions: NodeSubstates = BTreeMap::new();
-
-    {
-        let blueprints_partition = package_structure
-            .definitions
-            .into_iter()
-            .map(|(blueprint, definition)| {
-                let key = BlueprintVersionKey {
-                    blueprint,
-                    version: BlueprintVersion::default(),
-                };
-                let value = KeyValueEntrySubstate::locked_entry(definition);
-                (
-                    SubstateKey::Map(scrypto_encode(&key).unwrap()),
-                    IndexedScryptoValue::from_typed(&value),
-                )
-            })
-            .collect();
-
-        partitions.insert(
-            MAIN_BASE_PARTITION
-                .at_offset(PACKAGE_BLUEPRINTS_PARTITION_OFFSET)
-                .unwrap(),
-            blueprints_partition,
-        );
-    };
-
-    {
-        let minor_version_configs = package_structure
-            .dependencies
-            .into_iter()
-            .map(|(blueprint, minor_version_config)| {
-                let key = BlueprintVersionKey {
-                    blueprint,
-                    version: BlueprintVersion::default(),
-                };
-
-                let value = KeyValueEntrySubstate::locked_entry(minor_version_config);
-                (
-                    SubstateKey::Map(scrypto_encode(&key).unwrap()),
-                    IndexedScryptoValue::from_typed(&value),
-                )
-            })
-            .collect();
-
-        partitions.insert(
-            MAIN_BASE_PARTITION
-                .at_offset(PACKAGE_BLUEPRINT_DEPENDENCIES_PARTITION_OFFSET)
-                .unwrap(),
-            minor_version_configs,
-        );
-    };
-
-    {
-        let schemas_partition = package_structure
-            .schemas
-            .into_iter()
-            .map(|(hash, schema)| {
-                let value = KeyValueEntrySubstate::locked_entry(schema);
-
-                (
-                    SubstateKey::Map(scrypto_encode(&hash).unwrap()),
-                    IndexedScryptoValue::from_typed(&value),
-                )
-            })
-            .collect();
-
-        partitions.insert(
-            MAIN_BASE_PARTITION
-                .at_offset(PACKAGE_SCHEMAS_PARTITION_OFFSET)
-                .unwrap(),
-            schemas_partition,
-        );
-    }
-
+    //-----------------
+    // MAIN PARTITIONS:
+    //-----------------
+
+    // TODO:
+    // - Improve the System ObjectAPI to take field indices (and so support optional) fields
+    // - Improve the declare_native_blueprint_state! macro to support features
+    //   and so optional field substates, if/when that feature is disabled
     {
-        let vm_type_partition = package_structure
-            .vm_type
-            .into_iter()
-            .map(|(hash, code_substate)| {
-                let value = KeyValueEntrySubstate::locked_entry(code_substate);
-                (
-                    SubstateKey::Map(scrypto_encode(&hash).unwrap()),
-                    IndexedScryptoValue::from_typed(&value),
-                )
-            })
-            .collect();
-
-        partitions.insert(
-            MAIN_BASE_PARTITION
-                .at_offset(PACKAGE_VM_TYPE_PARTITION_OFFSET)
-                .unwrap(),
-            vm_type_partition,
+        // Native packages disable the package royalty feature
+        // Due to (current) restrictions on the into_kernel_main_partitions() method, we need to
+        // temporarily add in a faked royalty substate - to be removed a few lines later
+        package_state_init.royalty = Some(
+            PackageRoyaltyAccumulatorField {
+                royalty_vault: Vault(Own(NodeId([0; NodeId::LENGTH]))),
+            }
+            .into_locked_substate(),
         );
     }
 
-    {
-        let original_code_partition = package_structure
-            .original_code
-            .into_iter()
-            .map(|(hash, code_substate)| {
-                let value = KeyValueEntrySubstate::locked_entry(code_substate);
-                (
-                    SubstateKey::Map(scrypto_encode(&hash).unwrap()),
-                    IndexedScryptoValue::from_typed(&value),
-                )
-            })
-            .collect();
-
-        partitions.insert(
-            MAIN_BASE_PARTITION
-                .at_offset(PACKAGE_ORIGINAL_CODE_PARTITION_OFFSET)
-                .unwrap(),
-            original_code_partition,
-        );
-    }
+    let mut partitions = package_state_init.into_kernel_main_partitions();
 
     {
-        let instrumented_code_partition = package_structure
-            .instrumented_code
-            .into_iter()
-            .map(|(hash, code_substate)| {
-                let value = KeyValueEntrySubstate::locked_entry(code_substate);
-                (
-                    SubstateKey::Map(scrypto_encode(&hash).unwrap()),
-                    IndexedScryptoValue::from_typed(&value),
-                )
-            })
-            .collect();
-
-        partitions.insert(
-            MAIN_BASE_PARTITION
-                .at_offset(PACKAGE_INSTRUMENTED_CODE_PARTITION_OFFSET)
-                .unwrap(),
-            instrumented_code_partition,
-        );
-    }
-
-    {
-        let auth_partition = package_structure
-            .auth_configs
-            .into_iter()
-            .map(|(blueprint, auth_template)| {
-                let key = BlueprintVersionKey {
-                    blueprint,
-                    version: BlueprintVersion::default(),
-                };
-                let value = KeyValueEntrySubstate::locked_entry(auth_template);
-                (
-                    SubstateKey::Map(scrypto_encode(&key).unwrap()),
-                    IndexedScryptoValue::from_typed(&value),
-                )
-            })
-            .collect();
-
-        partitions.insert(
-            MAIN_BASE_PARTITION
-                .at_offset(PACKAGE_AUTH_TEMPLATE_PARTITION_OFFSET)
-                .unwrap(),
-            auth_partition,
-        );
+        // Remove the Royalty field because that feature is turned off
+        let field_partition = partitions
+            .get_mut(&PackagePartition::Field.as_main_partition())
+            .unwrap();
+        field_partition
+            .remove_entry(&PackageField::Royalty.into())
+            .unwrap();
     }
 
+    //-------------------
+    // MODULE PARTITIONS:
+    //-------------------
     {
         let mut metadata_partition = BTreeMap::new();
         for (key, value) in metadata.data {
@@ -661,6 +534,9 @@ pub fn create_bootstrap_package_partitions(
         partitions.insert(METADATA_BASE_PARTITION, metadata_partition);
     }
 
+    //-------------------
+    // SYSTEM PARTITIONS:
+    //-------------------
     {
         partitions.insert(
             TYPE_INFO_FIELD_PARTITION,
@@ -687,7 +563,7 @@ pub fn create_bootstrap_package_partitions(
 
 fn globalize_package<Y>(
     package_address_reservation: Option<GlobalAddressReservation>,
-    package_structure: PackageStructure,
+    mut package_state_init: PackageStateInit,
     metadata: Own,
     role_assignment: RoleAssignment,
     api: &mut Y,
@@ -695,118 +571,19 @@ fn globalize_package<Y>(
 where
     Y: ClientApi<RuntimeError>,
 {
-    let mut kv_entries: BTreeMap<u8, BTreeMap<Vec<u8>, KVEntry>> = BTreeMap::new();
-
-    let vault = ResourceManager(XRD).new_empty_vault(api)?;
-    let royalty = PackageRoyaltyAccumulatorSubstate {
-        royalty_vault: Vault(vault),
-    };
-
-    {
-        let mut definition_partition = BTreeMap::new();
-        for (blueprint, definition) in package_structure.definitions {
-            let key = BlueprintVersionKey::new_default(blueprint);
-            let entry = KVEntry {
-                value: Some(scrypto_encode(&definition).unwrap()),
-                locked: true,
-            };
-            definition_partition.insert(scrypto_encode(&key).unwrap(), entry);
+    package_state_init.royalty = Some(
+        PackageRoyaltyAccumulatorField {
+            royalty_vault: Vault(ResourceManager(XRD).new_empty_vault(api)?),
         }
-        kv_entries.insert(0u8, definition_partition);
-    }
-
-    {
-        let mut dependency_partition = BTreeMap::new();
-        for (blueprint, dependencies) in package_structure.dependencies {
-            let key = BlueprintVersionKey::new_default(blueprint);
-            let entry = KVEntry {
-                value: Some(scrypto_encode(&dependencies).unwrap()),
-                locked: true,
-            };
-            dependency_partition.insert(scrypto_encode(&key).unwrap(), entry);
-        }
-        kv_entries.insert(1u8, dependency_partition);
-    }
-
-    {
-        let mut schemas_partition = BTreeMap::new();
-        for (hash, schema) in package_structure.schemas {
-            let entry = KVEntry {
-                value: Some(scrypto_encode(&schema).unwrap()),
-                locked: true,
-            };
-            schemas_partition.insert(scrypto_encode(&hash).unwrap(), entry);
-        }
-        kv_entries.insert(2u8, schemas_partition);
-    }
-
-    {
-        let mut package_royalties_partition = BTreeMap::new();
-        for (blueprint, package_royalty) in package_structure.package_royalties {
-            let key = BlueprintVersionKey::new_default(blueprint);
-            let entry = KVEntry {
-                value: Some(scrypto_encode(&package_royalty).unwrap()),
-                locked: true,
-            };
-            package_royalties_partition.insert(scrypto_encode(&key).unwrap(), entry);
-        }
-        kv_entries.insert(3u8, package_royalties_partition);
-    }
-
-    {
-        let mut auth_partition = BTreeMap::new();
-        for (blueprint, auth_config) in package_structure.auth_configs {
-            let key = BlueprintVersionKey::new_default(blueprint);
-            let entry = KVEntry {
-                value: Some(scrypto_encode(&auth_config).unwrap()),
-                locked: true,
-            };
-            auth_partition.insert(scrypto_encode(&key).unwrap(), entry);
-        }
-        kv_entries.insert(4u8, auth_partition);
-    }
-
-    {
-        let mut vm_type_partition = BTreeMap::new();
-        for (hash, code_substate) in package_structure.vm_type {
-            let entry = KVEntry {
-                value: Some(scrypto_encode(&code_substate).unwrap()),
-                locked: true,
-            };
-            vm_type_partition.insert(scrypto_encode(&hash).unwrap(), entry);
-        }
-        kv_entries.insert(5u8, vm_type_partition);
-    }
-
-    {
-        let mut original_code_partition = BTreeMap::new();
-        for (hash, code_substate) in package_structure.original_code {
-            let entry = KVEntry {
-                value: Some(scrypto_encode(&code_substate).unwrap()),
-                locked: true,
-            };
-            original_code_partition.insert(scrypto_encode(&hash).unwrap(), entry);
-        }
-        kv_entries.insert(6u8, original_code_partition);
-    }
-
-    {
-        let mut instrumented_code_partition = BTreeMap::new();
-        for (hash, code_substate) in package_structure.instrumented_code {
-            let entry = KVEntry {
-                value: Some(scrypto_encode(&code_substate).unwrap()),
-                locked: true,
-            };
-            instrumented_code_partition.insert(scrypto_encode(&hash).unwrap(), entry);
-        }
-        kv_entries.insert(7u8, instrumented_code_partition);
-    }
+        .into_locked_substate(),
+    );
+    let (fields, kv_entries) = package_state_init.into_system_substates();
 
     let package_object = api.new_object(
         PACKAGE_BLUEPRINT,
         vec![PACKAGE_ROYALTY_FEATURE],
         None,
-        vec![FieldValue::immutable(&royalty)],
+        fields,
         kv_entries,
     )?;
 
@@ -1007,11 +784,11 @@ impl PackageNativePackage {
         }
     }
 
-    pub fn validate_and_build_package_structure(
+    pub fn validate_and_build_package_state_init(
         definition: PackageDefinition,
         vm_type: VmType,
         original_code: Vec<u8>,
-    ) -> Result<PackageStructure, RuntimeError> {
+    ) -> Result<PackageStateInit, RuntimeError> {
         // Validate schema
         validate_package_schema(definition.blueprints.values().map(|s| &s.schema))
             .map_err(|e| RuntimeError::ApplicationError(ApplicationError::PackageError(e)))?;
@@ -1149,18 +926,89 @@ impl PackageNativePackage {
             }
         };
 
-        let package_structure = PackageStructure {
-            definitions,
-            dependencies,
-            schemas,
-            vm_type: vm_type_substates,
-            original_code: original_code_substates,
-            instrumented_code: instrumented_code_substates,
-            auth_configs,
-            package_royalties,
+        let package_state_init = PackageStateInit {
+            royalty: None, // This is added later, for globalized packages,
+            blueprint_version_definitions: definitions
+                .into_iter()
+                .map(|(blueprint_name, blueprint_definition)| {
+                    (
+                        BlueprintVersionKey::new_default(blueprint_name),
+                        blueprint_definition.into_locked_substate(),
+                    )
+                })
+                .collect(),
+            blueprint_version_dependencies: dependencies
+                .into_iter()
+                .map(|(blueprint_name, blueprint_dependencies)| {
+                    (
+                        BlueprintVersionKey::new_default(blueprint_name),
+                        blueprint_dependencies.into_locked_substate(),
+                    )
+                })
+                .collect(),
+            schemas: schemas
+                .into_iter()
+                .map(|(schema_hash, schema)| {
+                    (SchemaHash::from(schema_hash), schema.into_locked_substate())
+                })
+                .collect(),
+            blueprint_version_royalty_configs: package_royalties
+                .into_iter()
+                .map(|(blueprint_name, royalty_config)| {
+                    (
+                        BlueprintVersionKey::new_default(blueprint_name),
+                        royalty_config.into_locked_substate(),
+                    )
+                })
+                .collect(),
+            blueprint_version_auth_configs: auth_configs
+                .into_iter()
+                .map(|(blueprint_name, auth_config)| {
+                    (
+                        BlueprintVersionKey::new_default(blueprint_name),
+                        auth_config.into_locked_substate(),
+                    )
+                })
+                .collect(),
+            code_vm_type: vm_type_substates
+                .into_iter()
+                .map(|(code_hash, vm_type)| {
+                    (
+                        CodeHash::from(code_hash),
+                        PackageCodeVmTypeValue {
+                            vm_type: vm_type.vm_type,
+                        }
+                        .into_locked_substate(),
+                    )
+                })
+                .collect(),
+            code_original_code: original_code_substates
+                .into_iter()
+                .map(|(code_hash, original_code)| {
+                    (
+                        CodeHash::from(code_hash),
+                        PackageCodeOriginalCodeValue {
+                            code: original_code.code,
+                        }
+                        .into_locked_substate(),
+                    )
+                })
+                .collect(),
+            code_instrumented_code: instrumented_code_substates
+                .into_iter()
+                .map(|(code_hash, instrumented_code)| {
+                    (
+                        CodeHash::from(code_hash),
+                        PackageCodeInstrumentedCodeValue {
+                            code: instrumented_code.code,
+                        }
+                        .into_locked_substate(),
+                    )
+                })
+                .collect(),
         };
 
-        Ok(package_structure)
+        Ok(package_state_init)
     }
 
     pub(crate) fn publish_native<Y>(
@@ -1174,7 +1022,7 @@ impl PackageNativePackage {
         Y: ClientApi<RuntimeError>,
     {
         validate_royalties(&definition, api)?;
-        let package_structure = Self::validate_and_build_package_structure(
+        let package_state_init = Self::validate_and_build_package_state_init(
             definition,
             VmType::Native,
             native_package_code_id.to_be_bytes().to_vec(),
@@ -1184,7 +1032,7 @@ impl PackageNativePackage {
 
         globalize_package(
             package_address,
-            package_structure,
+            package_state_init,
             metadata,
             role_assignment,
             api,
@@ -1202,7 +1050,7 @@ impl PackageNativePackage {
     {
         validate_royalties(&definition, api)?;
         let package_structure =
-            Self::validate_and_build_package_structure(definition, VmType::ScryptoV1, code)?;
+            Self::validate_and_build_package_state_init(definition, VmType::ScryptoV1, code)?;
 
         let (address_reservation, address) = api.allocate_global_address(BlueprintId {
             package_address: PACKAGE_PACKAGE,
@@ -1243,7 +1091,7 @@ impl PackageNativePackage {
     {
         validate_royalties(&definition, api)?;
         let package_structure =
-            Self::validate_and_build_package_structure(definition, VmType::ScryptoV1, code)?;
+            Self::validate_and_build_package_state_init(definition, VmType::ScryptoV1, code)?;
         let metadata = Metadata::create_with_data(metadata_init, api)?;
         let role_assignment = SecurifiedPackage::create_advanced(owner_role, api)?;
 
diff --git a/radix-engine/src/system/bootstrap.rs b/radix-engine/src/system/bootstrap.rs
index b3738cb7fad..c87b1b6f6b3 100644
--- a/radix-engine/src/system/bootstrap.rs
+++ b/radix-engine/src/system/bootstrap.rs
@@ -470,14 +470,14 @@ pub fn create_system_bootstrap_flash(
 
     for (address, definition, native_code_id, metadata_init) in package_flashes {
         let partitions = {
-            let package_structure = PackageNativePackage::validate_and_build_package_structure(
+            let package_state_init = PackageNativePackage::validate_and_build_package_state_init(
                 definition,
                 VmType::Native,
                 native_code_id.to_be_bytes().to_vec(),
             )
             .expect("Invalid Package Package definition");
 
-            create_bootstrap_package_partitions(package_structure, metadata_init)
+            create_bootstrap_package_partitions(package_state_init, metadata_init)
         };
 
         for (partition_num, partition_substates) in partitions {

From f6b11f2d231d48b218c4088ddc52ecb0baa7fd5a Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Fri, 11 Aug 2023 12:14:30 +0100
Subject: [PATCH 12/28] tweak: Change to using new types for keys and content

---
 radix-engine/src/blueprints/macros.rs         | 132 ++++++++++--------
 .../src/blueprints/package/package.rs         |  19 +--
 2 files changed, 86 insertions(+), 65 deletions(-)

diff --git a/radix-engine/src/blueprints/macros.rs b/radix-engine/src/blueprints/macros.rs
index a9980df5232..37698dbebe2 100644
--- a/radix-engine/src/blueprints/macros.rs
+++ b/radix-engine/src/blueprints/macros.rs
@@ -1,50 +1,40 @@
 use crate::system::system::*;
 use crate::types::*;
 
-pub trait FieldContent: Sized {
-    type ActualContent: From<Self>;
-
-    fn into_locked_substate(self) -> FieldSubstate<Self::ActualContent> {
+pub trait FieldContent<ActualContent: From<Self>>: Sized {
+    fn into_locked_substate(self) -> FieldSubstate<ActualContent> {
         FieldSubstate::new_locked_field(self.into())
     }
 
-    fn into_mutable_substate(self) -> FieldSubstate<Self::ActualContent> {
+    fn into_mutable_substate(self) -> FieldSubstate<ActualContent> {
         FieldSubstate::new_field(self.into())
     }
 }
 
-pub trait KeyContent: Sized {
-    type ActualContent: From<Self>;
-
-    fn into_key(self) -> Self::ActualContent {
+pub trait KeyContent<ActualContent: From<Self>>: Sized {
+    fn into_key(self) -> ActualContent {
         self.into()
     }
 }
 
-pub trait KeyValueEntryContent: Sized {
-    type ActualContent: From<Self>;
-
-    fn into_locked_substate(self) -> KeyValueEntrySubstate<Self::ActualContent> {
+pub trait KeyValueEntryContent<ActualContent: From<Self>>: Sized {
+    fn into_locked_substate(self) -> KeyValueEntrySubstate<ActualContent> {
         KeyValueEntrySubstate::entry(self.into())
     }
 
-    fn into_mutable_substate(self) -> KeyValueEntrySubstate<Self::ActualContent> {
+    fn into_mutable_substate(self) -> KeyValueEntrySubstate<ActualContent> {
         KeyValueEntrySubstate::locked_entry(self.into())
     }
 }
 
-pub trait IndexEntryContent: Sized {
-    type ActualContent: From<Self>;
-
-    fn into_substate(self) -> Self::ActualContent {
+pub trait IndexEntryContent<ActualContent: From<Self>>: Sized {
+    fn into_substate(self) -> ActualContent {
         self.into()
     }
 }
 
-pub trait SortedIndexEntryContent: Sized {
-    type ActualContent: From<Self>;
-
-    fn into_substate(self) -> Self::ActualContent {
+pub trait SortedIndexEntryContent<ActualContent: From<Self>>: Sized {
+    fn into_substate(self) -> ActualContent {
         self.into()
     }
 }
@@ -97,10 +87,10 @@ macro_rules! declare_native_blueprint_state {
                     ident: $field_ident:ident,
                     field_type: $field_type:tt,
                     condition: $field_condition:expr
-                    $(,)? // Optional trialing comma
+                    $(,)? // Optional trailing comma
                 }
             ),*
-            $(,)? // Optional trialing comma
+            $(,)? // Optional trailing comma
         },
         collections: {
             $(
@@ -112,10 +102,10 @@ macro_rules! declare_native_blueprint_state {
                     // Collection options for (eg) passing in a property name
                     // of the sorted index parameter for SortedIndex
                     $(, options: $collection_options:tt)?
-                    $(,)? // Optional trialing comma
+                    $(,)? // Optional trailing comma
                 }
             ),*
-            $(,)? // Optional trialing comma
+            $(,)? // Optional trailing comma
         }
         $(,)?
     ) => {
@@ -137,12 +127,19 @@ macro_rules! declare_native_blueprint_state {
 
                 // Generate models for each field
                 $(
-                    generate_content_type_aliases!(
+                    // Value
+                    // > Set up Versioned types (if relevant). Assumes __FieldV1 exists and then creates
+                    //   - Versioned__Field
+                    //   - __Field (alias for __FieldV1)
+                    // > Set up the (transparent) _FieldContent new type for the content of the field
+                    // > Set up the FieldContent trait for anything which can be resolved into the field content
+                    generate_content_type!(
                         content_trait: FieldContent,
                         ident_core: [<$blueprint_ident $field_ident Field>],
-                        type [<$blueprint_ident $field_ident FieldContent>] = $field_type
+                        #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
+                        struct [<$blueprint_ident $field_ident FieldContent>] = $field_type
                     );
-                    // Part 2 - Generate the common Substate type aliases for FieldContent
+                    // > Set up the _FieldSubstate alias for the system-wrapped substate
                     generate_system_substate_type_alias!(
                         Field,
                         type [<$blueprint_ident $field_ident FieldSubstate>] = WRAPPED [<$blueprint_ident $field_ident FieldContent>]
@@ -152,25 +149,32 @@ macro_rules! declare_native_blueprint_state {
                 // Generate models for each collection
                 $(
                     // Key
-                    // > Set up any Versioned types
-                    // > Set up the _KeyContent alias
-                    // > Set up the KeyContent traits
-                    generate_content_type_aliases!(
+                    // > Set up Versioned types (if relevant). Assumes __KeyInnerV1 exists and then creates
+                    //   - Versioned__KeyInner
+                    //   - __KeyInner (alias for __KeyInnerV1)
+                    // > Create the (transparent) _Key new type for the key
+                    // > Set up the KeyContent traits for anything which can be resolved into a key
+                    generate_content_type!(
                         content_trait: KeyContent,
                         ident_core: [<$blueprint_ident $collection_ident KeyInner>],
-                        type [<$blueprint_ident $collection_ident Key>] = $collection_key_type
+                        #[derive(Debug, Clone, Hash, PartialEq, Eq, ScryptoSbor)]
+                        #[sbor(transparent_name)]
+                        struct [<$blueprint_ident $collection_ident Key>] = $collection_key_type
                     );
 
                     // Values
-                    // > Set up any Versioned types
-                    // > Set up the _ValueContent alias
+                    // > Set up Versioned types (if relevant). Assumes __ValueV1 exists and then creates
+                    //   - Versioned__Value
+                    //   - __Value (alias for __ValueV1)
+                    // > Set up the (transparent) _ValueContent new type for the value content
                     // > Set up the _EntryContent traits
-                    generate_content_type_aliases!(
+                    generate_content_type!(
                         content_trait: [<$collection_type EntryContent>],
                         ident_core: [<$blueprint_ident $collection_ident Value>],
-                        type [<$blueprint_ident $collection_ident ValueContent>] = $collection_value_type
+                        #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
+                        struct [<$blueprint_ident $collection_ident ValueContent>] = $collection_value_type
                     );
-                    // > Set up the _EntrySubstate alias
+                    // > Set up the _EntrySubstate alias for the system-wrapped substate
                     generate_system_substate_type_alias!(
                         $collection_type,
                         type [<$blueprint_ident $collection_ident EntrySubstate>] = WRAPPED [<$blueprint_ident $collection_ident ValueContent>]
@@ -481,52 +485,66 @@ pub(crate) use declare_native_blueprint_state;
 pub(crate) use helper_macros::*;
 
 mod helper_macros {
-    macro_rules! generate_content_type_aliases {
+    macro_rules! generate_content_type {
         (
             content_trait: $content_trait:ident,
             ident_core: $ident_core:ident,
-            type $alias:ident = {
+            $(#[$attributes:meta])*
+            struct $content_type_name:ident = {
                 kind: StaticSingleVersioned
                 $(,)?
             }$(,)?
         ) => {
             paste::paste! {
                 sbor::define_single_versioned!(
-                    #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
+                    $(#[$attributes])*
                     pub enum [<Versioned $ident_core>] => $ident_core = [<$ident_core V1>]
                 );
-                pub type $alias = [<Versioned $ident_core>];
-                impl $content_trait for $ident_core {
-                    type ActualContent = $alias;
+                $(#[$attributes])*
+                #[sbor(transparent)]
+                pub struct $content_type_name(pub [<Versioned $ident_core>]);
+                impl From<[<Versioned $ident_core>]> for $content_type_name {
+                    fn from(value: [<Versioned $ident_core>]) -> Self {
+                        Self(value)
+                    }
                 }
-                impl $content_trait for $alias {
-                    type ActualContent = Self;
+                impl $content_trait<$content_type_name> for [<Versioned $ident_core>] {}
+                // Also add impls from the "latest" type
+                impl From<$ident_core> for $content_type_name {
+                    fn from(value: $ident_core) -> Self {
+                        Self(value.into())
+                    }
                 }
+                impl $content_trait<$content_type_name> for $ident_core {}
             }
         };
         (
             content_trait: $content_trait:ident,
             ident_core: $ident_core:ident,
-            type $alias:ident = {
+            $(#[$attributes:meta])*
+            struct $content_type_name:ident = {
                 kind: Static,
                 the_type: $static_type:ty
                 $(,)?
             }$(,)?
         ) => {
             paste::paste! {
-                pub type $alias = $static_type;
-                // TODO(David) - Fix this for eg BlueprintVersion being used in multiple keys
-                // - Maybe by making these aliases actually new-types(?)
-                // - Or by removing these traits completely perhaps...
-                // impl $content_trait for $alias {
-                //     type ActualContent = Self;
-                // }
+                $(#[$attributes])*
+                #[sbor(transparent)]
+                pub struct $content_type_name(pub $static_type);
+                impl From<$static_type> for $content_type_name {
+                    fn from(value: $static_type) -> Self {
+                        Self(value)
+                    }
+                }
+                impl $content_trait<$content_type_name> for $static_type {}
             }
         };
         (
             content_trait: $content_trait:ident,
             ident_core: $ident_core:ident,
-            type $alias:ident = {
+            $(#[$attributes:meta])*
+            struct $alias:ident = {
                 kind: Instance,
                 ident: $instance_ident:ident
                 $(,)?
@@ -537,7 +555,7 @@ mod helper_macros {
     }
 
     #[allow(unused)]
-    pub(crate) use generate_content_type_aliases;
+    pub(crate) use generate_content_type;
 
     macro_rules! generate_system_substate_type_alias {
         (SystemField, type $alias:ident = WRAPPED $content:ty$(,)?) => {
diff --git a/radix-engine/src/blueprints/package/package.rs b/radix-engine/src/blueprints/package/package.rs
index d8859421d67..61f03089cfd 100644
--- a/radix-engine/src/blueprints/package/package.rs
+++ b/radix-engine/src/blueprints/package/package.rs
@@ -932,7 +932,7 @@ impl PackageNativePackage {
                 .into_iter()
                 .map(|(blueprint_name, blueprint_definition)| {
                     (
-                        BlueprintVersionKey::new_default(blueprint_name),
+                        BlueprintVersionKey::new_default(blueprint_name).into_key(),
                         blueprint_definition.into_locked_substate(),
                     )
                 })
@@ -941,7 +941,7 @@ impl PackageNativePackage {
                 .into_iter()
                 .map(|(blueprint_name, blueprint_dependencies)| {
                     (
-                        BlueprintVersionKey::new_default(blueprint_name),
+                        BlueprintVersionKey::new_default(blueprint_name).into_key(),
                         blueprint_dependencies.into_locked_substate(),
                     )
                 })
@@ -949,14 +949,17 @@ impl PackageNativePackage {
             schemas: schemas
                 .into_iter()
                 .map(|(schema_hash, schema)| {
-                    (SchemaHash::from(schema_hash), schema.into_locked_substate())
+                    (
+                        SchemaHash::from(schema_hash).into_key(),
+                        schema.into_locked_substate(),
+                    )
                 })
                 .collect(),
             blueprint_version_royalty_configs: package_royalties
                 .into_iter()
                 .map(|(blueprint_name, royalty_config)| {
                     (
-                        BlueprintVersionKey::new_default(blueprint_name),
+                        BlueprintVersionKey::new_default(blueprint_name).into_key(),
                         royalty_config.into_locked_substate(),
                     )
                 })
@@ -965,7 +968,7 @@ impl PackageNativePackage {
                 .into_iter()
                 .map(|(blueprint_name, auth_config)| {
                     (
-                        BlueprintVersionKey::new_default(blueprint_name),
+                        BlueprintVersionKey::new_default(blueprint_name).into_key(),
                         auth_config.into_locked_substate(),
                     )
                 })
@@ -974,7 +977,7 @@ impl PackageNativePackage {
                 .into_iter()
                 .map(|(code_hash, vm_type)| {
                     (
-                        CodeHash::from(code_hash),
+                        CodeHash::from(code_hash).into_key(),
                         PackageCodeVmTypeValue {
                             vm_type: vm_type.vm_type,
                         }
@@ -986,7 +989,7 @@ impl PackageNativePackage {
                 .into_iter()
                 .map(|(code_hash, original_code)| {
                     (
-                        CodeHash::from(code_hash),
+                        CodeHash::from(code_hash).into_key(),
                         PackageCodeOriginalCodeValue {
                             code: original_code.code,
                         }
@@ -998,7 +1001,7 @@ impl PackageNativePackage {
                 .into_iter()
                 .map(|(code_hash, instrumented_code)| {
                     (
-                        CodeHash::from(code_hash),
+                        CodeHash::from(code_hash).into_key(),
                         PackageCodeInstrumentedCodeValue {
                             code: instrumented_code.code,
                         }

From a615c68a588f3eed4f07a2d648829246ffd40078 Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Sat, 12 Aug 2023 01:33:42 +0100
Subject: [PATCH 13/28] wip: Continue fixing for package

---
 .../src/data/scrypto/custom_schema.rs         |   6 +-
 .../src/types/type_identifier.rs              |  11 +-
 .../src/blueprints/package/substates.rs       |  59 ++-------
 .../src/types/node_layout.rs                  |  29 -----
 .../src/typed_substate_layout.rs              | 115 ++----------------
 .../tests/schema_sanity_check.rs              |   2 +-
 radix-engine/src/blueprints/macros.rs         |  74 ++++++++++-
 .../src/blueprints/package/package.rs         |  65 +++-------
 .../src/blueprints/package/substates.rs       |  30 +++--
 radix-engine/src/system/system.rs             |   2 +-
 radix-engine/src/system/system_callback.rs    |   2 +-
 .../src/transaction/system_structure.rs       |   8 +-
 radix-engine/src/utils/package_extractor.rs   |   6 +-
 radix-engine/src/vm/scrypto_vm.rs             |   3 +-
 radix-engine/src/vm/vm.rs                     |  17 ++-
 radix-engine/src/vm/wasm/traits.rs            |   3 +-
 radix-engine/src/vm/wasm/wasmer.rs            |   9 +-
 radix-engine/src/vm/wasm/wasmi.rs             |   9 +-
 scrypto-unit/src/test_runner.rs               |  22 ++--
 simulator/src/ledger/dumper.rs                |   5 +-
 simulator/src/resim/cmd_publish.rs            |   2 -
 simulator/src/resim/error.rs                  |   3 +-
 simulator/src/resim/mod.rs                    |   9 +-
 23 files changed, 189 insertions(+), 302 deletions(-)

diff --git a/radix-engine-common/src/data/scrypto/custom_schema.rs b/radix-engine-common/src/data/scrypto/custom_schema.rs
index 518524b944a..e5db12a388b 100644
--- a/radix-engine-common/src/data/scrypto/custom_schema.rs
+++ b/radix-engine-common/src/data/scrypto/custom_schema.rs
@@ -203,13 +203,13 @@ impl CustomSchema for ScryptoCustomSchema {
 }
 
 pub trait HasSchemaHash {
-    fn generate_schema_hash(&self) -> Hash;
+    fn generate_schema_hash(&self) -> SchemaHash;
 }
 
 // TODO(David) - change to hash the VersionedScryptoSchema when we use that in substates
 impl HasSchemaHash for ScryptoSchema {
-    fn generate_schema_hash(&self) -> Hash {
-        hash(scrypto_encode(self).unwrap())
+    fn generate_schema_hash(&self) -> SchemaHash {
+        SchemaHash::from(hash(scrypto_encode(self).unwrap()))
     }
 }
 
diff --git a/radix-engine-common/src/types/type_identifier.rs b/radix-engine-common/src/types/type_identifier.rs
index 34b58ddea0e..86aa8296530 100644
--- a/radix-engine-common/src/types/type_identifier.rs
+++ b/radix-engine-common/src/types/type_identifier.rs
@@ -1,6 +1,9 @@
-use crate::crypto::Hash;
-use crate::Sbor;
-use sbor::LocalTypeIndex;
+use crate::internal_prelude::*;
+
+define_wrapped_hash!(
+    /// Represents a particular schema under a package
+    SchemaHash
+);
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Sbor)]
-pub struct TypeIdentifier(pub Hash, pub LocalTypeIndex);
+pub struct TypeIdentifier(pub SchemaHash, pub LocalTypeIndex);
diff --git a/radix-engine-interface/src/blueprints/package/substates.rs b/radix-engine-interface/src/blueprints/package/substates.rs
index 8de3fb951a9..206985fc522 100644
--- a/radix-engine-interface/src/blueprints/package/substates.rs
+++ b/radix-engine-interface/src/blueprints/package/substates.rs
@@ -1,12 +1,9 @@
 use crate::blueprints::package::BlueprintType;
+use crate::prelude::*;
 use crate::schema::*;
 use crate::types::*;
 use crate::*;
 use radix_engine_common::crypto::Hash;
-use radix_engine_interface::blueprints::resource::Vault;
-use sbor::rust::fmt;
-use sbor::rust::fmt::{Debug, Formatter};
-use sbor::rust::prelude::*;
 
 pub const PACKAGE_CODE_ID: u64 = 0u64;
 pub const RESOURCE_CODE_ID: u64 = 1u64;
@@ -32,57 +29,17 @@ pub const PACKAGE_VM_TYPE_PARTITION_OFFSET: PartitionOffset = PartitionOffset(6u
 pub const PACKAGE_ORIGINAL_CODE_PARTITION_OFFSET: PartitionOffset = PartitionOffset(7u8);
 pub const PACKAGE_INSTRUMENTED_CODE_PARTITION_OFFSET: PartitionOffset = PartitionOffset(8u8);
 
+define_wrapped_hash!(
+    /// Represents a particular instance of code under a package
+    CodeHash
+);
+
 #[derive(Copy, Debug, Clone, PartialEq, Eq, Sbor)]
 pub enum VmType {
     Native,
     ScryptoV1,
 }
 
-#[derive(Debug, Clone, Sbor, PartialEq, Eq)]
-pub struct PackageVmTypeSubstate {
-    pub vm_type: VmType,
-}
-
-#[derive(Clone, Sbor, PartialEq, Eq)]
-pub struct PackageOriginalCodeSubstate {
-    pub code: Vec<u8>,
-}
-
-#[derive(Clone, Sbor, PartialEq, Eq)]
-pub struct PackageInstrumentedCodeSubstate {
-    pub code: Vec<u8>,
-}
-
-impl Debug for PackageOriginalCodeSubstate {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.debug_struct("PackageOriginalCodeSubstate")
-            .field("len", &self.code.len())
-            .finish()
-    }
-}
-
-impl Debug for PackageInstrumentedCodeSubstate {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.debug_struct("PackageInstrumentedCodeSubstate")
-            .field("len", &self.code.len())
-            .finish()
-    }
-}
-
-#[derive(Debug, PartialEq, Eq, ScryptoSbor)]
-pub struct PackageRoyaltyAccumulatorSubstate {
-    /// The vault for collecting package royalties.
-    pub royalty_vault: Vault,
-}
-
-impl Clone for PackageRoyaltyAccumulatorSubstate {
-    fn clone(&self) -> Self {
-        Self {
-            royalty_vault: Vault(self.royalty_vault.0.clone()),
-        }
-    }
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Sbor)]
 pub enum TypePointer {
     Package(TypeIdentifier), // For static types
@@ -143,7 +100,7 @@ pub struct BlueprintDependencies {
 
 #[derive(Debug, Clone, PartialEq, Eq, ScryptoSbor)]
 pub struct PackageExport {
-    pub code_hash: Hash,
+    pub code_hash: CodeHash,
     pub export_name: String,
 }
 
@@ -226,7 +183,7 @@ pub struct IndexedStateSchema {
 }
 
 impl IndexedStateSchema {
-    pub fn from_schema(schema_hash: Hash, schema: BlueprintStateSchemaInit) -> Self {
+    pub fn from_schema(schema_hash: SchemaHash, schema: BlueprintStateSchemaInit) -> Self {
         let mut partition_offset = 0u8;
 
         let mut fields = None;
diff --git a/radix-engine-interface/src/types/node_layout.rs b/radix-engine-interface/src/types/node_layout.rs
index 728778a0017..d03c8a01b43 100644
--- a/radix-engine-interface/src/types/node_layout.rs
+++ b/radix-engine-interface/src/types/node_layout.rs
@@ -60,12 +60,6 @@ pub enum ComponentField {
     State0,
 }
 
-#[repr(u8)]
-#[derive(Debug, Clone, Sbor, PartialEq, Eq, Hash, PartialOrd, Ord, FromRepr)]
-pub enum PackageField {
-    Royalty,
-}
-
 #[repr(u8)]
 #[derive(Debug, Clone, Sbor, PartialEq, Eq, Hash, PartialOrd, Ord, FromRepr)]
 pub enum FungibleResourceManagerField {
@@ -73,28 +67,6 @@ pub enum FungibleResourceManagerField {
     TotalSupply,
 }
 
-#[repr(u8)]
-#[derive(Debug, Clone, Sbor, PartialEq, Eq, Hash, PartialOrd, Ord, FromRepr)]
-pub enum PackagePartitionOffset {
-    Fields,
-    Blueprints,
-    BlueprintDependencies,
-    Schemas,
-    RoyaltyConfig,
-    AuthConfig,
-    VmType,
-    OriginalCode,
-    InstrumentedCode,
-}
-
-impl TryFrom<u8> for PackagePartitionOffset {
-    type Error = ();
-
-    fn try_from(offset: u8) -> Result<Self, Self::Error> {
-        Self::from_repr(offset).ok_or(())
-    }
-}
-
 #[repr(u8)]
 #[derive(Debug, Clone, Sbor, PartialEq, Eq, Hash, PartialOrd, Ord, FromRepr)]
 pub enum NonFungibleResourceManagerPartitionOffset {
@@ -321,7 +293,6 @@ substate_key!(TypeInfoField);
 substate_key!(RoyaltyField);
 substate_key!(RoleAssignmentField);
 substate_key!(ComponentField);
-substate_key!(PackageField);
 substate_key!(FungibleResourceManagerField);
 substate_key!(FungibleVaultField);
 substate_key!(FungibleBucketField);
diff --git a/radix-engine-queries/src/typed_substate_layout.rs b/radix-engine-queries/src/typed_substate_layout.rs
index def1cc930ad..3540870a5ab 100644
--- a/radix-engine-queries/src/typed_substate_layout.rs
+++ b/radix-engine-queries/src/typed_substate_layout.rs
@@ -118,15 +118,7 @@ pub enum TypedMetadataModuleSubstateKey {
 #[derive(Debug, Clone)]
 pub enum TypedMainModuleSubstateKey {
     // Objects
-    PackageField(PackageField),
-    PackageBlueprintKey(BlueprintVersionKey),
-    PackageBlueprintDependenciesKey(BlueprintVersionKey),
-    PackageSchemaKey(Hash),
-    PackageRoyaltyKey(BlueprintVersionKey),
-    PackageAuthTemplateKey(BlueprintVersionKey),
-    PackageVmTypeKey(Hash),
-    PackageOriginalCodeKey(Hash),
-    PackageInstrumentedCodeKey(Hash),
+    Package(PackageTypedSubstateKey),
     FungibleResourceField(FungibleResourceManagerField),
     NonFungibleResourceField(NonFungibleResourceManagerField),
     NonFungibleResourceData(NonFungibleLocalId),
@@ -262,60 +254,10 @@ fn to_typed_object_substate_key_internal(
             )?)
         }
         EntityType::GlobalPackage => {
-            let partition_offset = PackagePartitionOffset::try_from(partition_offset)?;
-            match partition_offset {
-                PackagePartitionOffset::Fields => {
-                    TypedMainModuleSubstateKey::PackageField(PackageField::try_from(substate_key)?)
-                }
-                PackagePartitionOffset::Blueprints => {
-                    let key = substate_key.for_map().ok_or(())?;
-                    TypedMainModuleSubstateKey::PackageBlueprintKey(
-                        scrypto_decode(&key).map_err(|_| ())?,
-                    )
-                }
-                PackagePartitionOffset::BlueprintDependencies => {
-                    let key = substate_key.for_map().ok_or(())?;
-                    TypedMainModuleSubstateKey::PackageBlueprintDependenciesKey(
-                        scrypto_decode(&key).map_err(|_| ())?,
-                    )
-                }
-                PackagePartitionOffset::Schemas => {
-                    let key = substate_key.for_map().ok_or(())?;
-                    TypedMainModuleSubstateKey::PackageSchemaKey(
-                        scrypto_decode(&key).map_err(|_| ())?,
-                    )
-                }
-                PackagePartitionOffset::RoyaltyConfig => {
-                    let key = substate_key.for_map().ok_or(())?;
-                    TypedMainModuleSubstateKey::PackageRoyaltyKey(
-                        scrypto_decode(&key).map_err(|_| ())?,
-                    )
-                }
-                PackagePartitionOffset::AuthConfig => {
-                    let key = substate_key.for_map().ok_or(())?;
-                    TypedMainModuleSubstateKey::PackageAuthTemplateKey(
-                        scrypto_decode(&key).map_err(|_| ())?,
-                    )
-                }
-                PackagePartitionOffset::VmType => {
-                    let key = substate_key.for_map().ok_or(())?;
-                    TypedMainModuleSubstateKey::PackageVmTypeKey(
-                        scrypto_decode(&key).map_err(|_| ())?,
-                    )
-                }
-                PackagePartitionOffset::OriginalCode => {
-                    let key = substate_key.for_map().ok_or(())?;
-                    TypedMainModuleSubstateKey::PackageOriginalCodeKey(
-                        scrypto_decode(&key).map_err(|_| ())?,
-                    )
-                }
-                PackagePartitionOffset::InstrumentedCode => {
-                    let key = substate_key.for_map().ok_or(())?;
-                    TypedMainModuleSubstateKey::PackageInstrumentedCodeKey(
-                        scrypto_decode(&key).map_err(|_| ())?,
-                    )
-                }
-            }
+            TypedMainModuleSubstateKey::Package(PackageTypedSubstateKey::for_key_in_partition(
+                &PackagePartition::try_from(PartitionOffset(partition_offset))?,
+                substate_key,
+            )?)
         }
         EntityType::GlobalFungibleResourceManager => {
             TypedMainModuleSubstateKey::FungibleResourceField(
@@ -482,15 +424,7 @@ pub enum TypedMetadataModuleSubstateValue {
 #[derive(Debug)]
 pub enum TypedMainModuleSubstateValue {
     // Objects
-    Package(TypedPackageFieldValue),
-    PackageBlueprint(KeyValueEntrySubstate<BlueprintDefinition>),
-    PackageBlueprintDependencies(KeyValueEntrySubstate<BlueprintDependencies>),
-    PackageSchema(KeyValueEntrySubstate<ScryptoSchema>),
-    PackageAuthTemplate(KeyValueEntrySubstate<AuthConfig>),
-    PackageRoyalty(KeyValueEntrySubstate<PackageRoyaltyConfig>),
-    PackageVmType(KeyValueEntrySubstate<PackageVmTypeSubstate>),
-    PackageOriginalCode(KeyValueEntrySubstate<PackageOriginalCodeSubstate>),
-    PackageInstrumentedCode(KeyValueEntrySubstate<PackageInstrumentedCodeSubstate>),
+    Package(PackageTypedSubstateValue),
     FungibleResource(TypedFungibleResourceManagerFieldValue),
     NonFungibleResource(TypedNonFungibleResourceManagerFieldValue),
     NonFungibleResourceData(KeyValueEntrySubstate<ScryptoOwnedRawValue>),
@@ -515,11 +449,6 @@ pub enum TypedMainModuleSubstateValue {
     GenericKeyValueStoreEntry(KeyValueEntrySubstate<ScryptoOwnedRawValue>),
 }
 
-#[derive(Debug)]
-pub enum TypedPackageFieldValue {
-    Royalty(FieldSubstate<PackageRoyaltyAccumulatorSubstate>),
-}
-
 #[derive(Debug)]
 pub enum TypedFungibleResourceManagerFieldValue {
     Divisibility(FieldSubstate<FungibleResourceManagerDivisibilitySubstate>),
@@ -662,35 +591,9 @@ fn to_typed_object_substate_value(
     data: &[u8],
 ) -> Result<TypedMainModuleSubstateValue, DecodeError> {
     let substate_value = match substate_key {
-        TypedMainModuleSubstateKey::PackageField(offset) => {
-            TypedMainModuleSubstateValue::Package(match offset {
-                PackageField::Royalty => TypedPackageFieldValue::Royalty(scrypto_decode(data)?),
-            })
-        }
-        TypedMainModuleSubstateKey::PackageBlueprintKey(_key) => {
-            TypedMainModuleSubstateValue::PackageBlueprint(scrypto_decode(data)?)
-        }
-        TypedMainModuleSubstateKey::PackageBlueprintDependenciesKey(..) => {
-            TypedMainModuleSubstateValue::PackageBlueprintDependencies(scrypto_decode(data)?)
-        }
-        TypedMainModuleSubstateKey::PackageSchemaKey(..) => {
-            TypedMainModuleSubstateValue::PackageSchema(scrypto_decode(data)?)
-        }
-        TypedMainModuleSubstateKey::PackageRoyaltyKey(_fn_key) => {
-            TypedMainModuleSubstateValue::PackageRoyalty(scrypto_decode(data)?)
-        }
-        TypedMainModuleSubstateKey::PackageAuthTemplateKey(_fn_key) => {
-            TypedMainModuleSubstateValue::PackageAuthTemplate(scrypto_decode(data)?)
-        }
-        TypedMainModuleSubstateKey::PackageVmTypeKey(..) => {
-            TypedMainModuleSubstateValue::PackageVmType(scrypto_decode(data)?)
-        }
-        TypedMainModuleSubstateKey::PackageOriginalCodeKey(..) => {
-            TypedMainModuleSubstateValue::PackageOriginalCode(scrypto_decode(data)?)
-        }
-        TypedMainModuleSubstateKey::PackageInstrumentedCodeKey(..) => {
-            TypedMainModuleSubstateValue::PackageInstrumentedCode(scrypto_decode(data)?)
-        }
+        TypedMainModuleSubstateKey::Package(key) => TypedMainModuleSubstateValue::Package(
+            PackageTypedSubstateValue::from_key_and_data(key, data)?,
+        ),
         TypedMainModuleSubstateKey::FungibleResourceField(offset) => {
             TypedMainModuleSubstateValue::FungibleResource(match offset {
                 FungibleResourceManagerField::Divisibility => {
diff --git a/radix-engine-tests/tests/schema_sanity_check.rs b/radix-engine-tests/tests/schema_sanity_check.rs
index c113d0f65fe..f71f28c007b 100644
--- a/radix-engine-tests/tests/schema_sanity_check.rs
+++ b/radix-engine-tests/tests/schema_sanity_check.rs
@@ -159,7 +159,7 @@ fn check_type_pointers(
 }
 
 fn check_type_pointer(
-    schemas_by_hash: &IndexMap<Hash, ScryptoSchema>,
+    schemas_by_hash: &IndexMap<SchemaHash, ScryptoSchema>,
     type_pointer: &TypePointer,
 ) -> CheckResult {
     match type_pointer {
diff --git a/radix-engine/src/blueprints/macros.rs b/radix-engine/src/blueprints/macros.rs
index 37698dbebe2..3c43da4d22c 100644
--- a/radix-engine/src/blueprints/macros.rs
+++ b/radix-engine/src/blueprints/macros.rs
@@ -139,6 +139,7 @@ macro_rules! declare_native_blueprint_state {
                         #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
                         struct [<$blueprint_ident $field_ident FieldContent>] = $field_type
                     );
+
                     // > Set up the _FieldSubstate alias for the system-wrapped substate
                     generate_system_substate_type_alias!(
                         Field,
@@ -162,6 +163,18 @@ macro_rules! declare_native_blueprint_state {
                         struct [<$blueprint_ident $collection_ident Key>] = $collection_key_type
                     );
 
+                    // TODO(David) - Properly handle SortedIndex:
+                    // Fix Key types for SortedIndex to have a named u16 part of the key,
+                    // use a different key trait, and use .for_sorted_key in the below.
+                    impl TryFrom<&SubstateKey> for [<$blueprint_ident $collection_ident Key>] {
+                        type Error = ();
+
+                        fn try_from(substate_key: &SubstateKey) -> Result<Self, Self::Error> {
+                            let key = substate_key.for_map().ok_or(())?;
+                            scrypto_decode(&key).map_err(|_| ())?
+                        }
+                    }
+
                     // Values
                     // > Set up Versioned types (if relevant). Assumes __ValueV1 exists and then creates
                     //   - Versioned__Value
@@ -248,6 +261,14 @@ macro_rules! declare_native_blueprint_state {
                     }
                 }
 
+                impl TryFrom<PartitionOffset> for [<$blueprint_ident Partition>] {
+                    type Error = ();
+
+                    fn try_from(offset: PartitionOffset) -> Result<Self, Self::Error> {
+                        Self::from_repr(offset.0).ok_or(())
+                    }
+                }
+
                 //---------------------------------
                 // Typed Substate - Keys and Values
                 //---------------------------------
@@ -257,6 +278,26 @@ macro_rules! declare_native_blueprint_state {
                     $([<$collection_ident $collection_type Entries>]([<$blueprint_ident $collection_ident Key>]),)*
                 }
 
+                impl [<$blueprint_ident TypedSubstateKey>] {
+                    pub fn for_key_in_partition(partition: &[<$blueprint_ident Partition>], substate_key: &SubstateKey) -> Result<Self, ()> {
+                        let key = match partition {
+                            [<$blueprint_ident Partition>]::Field => {
+                                [<$blueprint_ident TypedSubstateKey>]::Fields(
+                                    [<$blueprint_ident Field>]::try_from(substate_key)?
+                                )
+                            }
+                            $(
+                                [<$blueprint_ident Partition>]::[<$collection_ident $collection_type>] => {
+                                    [<$blueprint_ident TypedSubstateKey>]::[<$collection_ident $collection_type Entries>](
+                                        [<$blueprint_ident $collection_ident Key>]::try_from(substate_key)?,
+                                    )
+                                }
+                            )*
+                        };
+                        Ok(key)
+                    }
+                }
+
                 #[derive(Debug)]
                 pub enum [<$blueprint_ident TypedFieldSubstateValue>] {
                     $($field_ident([<$blueprint_ident $field_ident FieldSubstate>]),)*
@@ -268,6 +309,30 @@ macro_rules! declare_native_blueprint_state {
                     $([<$collection_ident $collection_type>]([<$blueprint_ident $collection_ident EntrySubstate>]),)*
                 }
 
+                impl [<$blueprint_ident TypedSubstateValue>] {
+                    pub fn from_key_and_data(key: &[<$blueprint_ident TypedSubstateKey>], data: &[u8]) -> Result<Self, DecodeError> {
+                        let substate_value = match key {
+                            // Fields
+                            $(
+                                [<$blueprint_ident TypedSubstateKey>]::Fields([<$blueprint_ident Field>]::$field_ident) => {
+                                    [<$blueprint_ident TypedSubstateValue>]::Field(
+                                        [<$blueprint_ident TypedFieldSubstateValue>]::$field_ident(scrypto_decode(data)?)
+                                    )
+                                }
+                            )*
+                            // Collections
+                            $(
+                                [<$blueprint_ident TypedSubstateKey>]::[<$collection_ident $collection_type Entries>](_) => {
+                                    [<$blueprint_ident TypedSubstateValue>]::[<$collection_ident $collection_type>](
+                                        scrypto_decode(data)?
+                                    )
+                                }
+                            )*
+                        };
+                        Ok(substate_value)
+                    }
+                }
+
                 //----------------------
                 // Schema
                 //----------------------
@@ -544,14 +609,17 @@ mod helper_macros {
             content_trait: $content_trait:ident,
             ident_core: $ident_core:ident,
             $(#[$attributes:meta])*
-            struct $alias:ident = {
+            struct $content_type_name:ident = {
                 kind: Instance,
                 ident: $instance_ident:ident
                 $(,)?
             }
         ) => {
-            // Don't output any types for an instance schema
-        }; // TODO - Add support for some kind of StaticMultiVersioned type here
+            $(#[$attributes])*
+            #[sbor(transparent)]
+            pub struct $content_type_name<$instance_ident = ScryptoValue>(pub $instance_ident);
+        };
+        // TODO - Add support for some kind of StaticMultiVersioned type here
     }
 
     #[allow(unused)]
diff --git a/radix-engine/src/blueprints/package/package.rs b/radix-engine/src/blueprints/package/package.rs
index 61f03089cfd..6ad8765ffd2 100644
--- a/radix-engine/src/blueprints/package/package.rs
+++ b/radix-engine/src/blueprints/package/package.rs
@@ -26,16 +26,11 @@ use syn::Ident;
 use crate::roles_template;
 use crate::system::node_modules::role_assignment::RoleAssignmentNativePackage;
 use crate::system::node_modules::royalty::RoyaltyUtil;
-use crate::system::system::{
-    FieldSubstate, KeyValueEntrySubstate, SubstateMutability, SystemService,
-};
+use crate::system::system::*;
 use crate::system::system_callback::{SystemConfig, SystemLockData};
 use crate::system::system_callback_api::SystemCallbackObject;
 use crate::system::system_modules::auth::{AuthError, ResolvedPermission};
 use crate::vm::VmPackageValidation;
-pub use radix_engine_interface::blueprints::package::{
-    PackageInstrumentedCodeSubstate, PackageOriginalCodeSubstate, PackageRoyaltyAccumulatorSubstate,
-};
 
 use super::*;
 
@@ -506,7 +501,7 @@ pub fn create_bootstrap_package_partitions(
             .get_mut(&PackagePartition::Field.as_main_partition())
             .unwrap();
         field_partition
-            .remove_entry(&PackageField::Royalty.into())
+            .remove_entry(&PackageField::RoyaltyAccumulator.into())
             .unwrap();
     }
 
@@ -599,17 +594,6 @@ where
     Ok(PackageAddress::new_or_panic(address.into_node_id().0))
 }
 
-pub struct PackageStructure {
-    pub definitions: BTreeMap<String, BlueprintDefinition>,
-    pub dependencies: BTreeMap<String, BlueprintDependencies>,
-    pub schemas: BTreeMap<Hash, ScryptoSchema>,
-    pub vm_type: BTreeMap<Hash, PackageVmTypeSubstate>,
-    pub original_code: BTreeMap<Hash, PackageOriginalCodeSubstate>,
-    pub instrumented_code: BTreeMap<Hash, PackageInstrumentedCodeSubstate>,
-    pub auth_configs: BTreeMap<String, AuthConfig>,
-    pub package_royalties: BTreeMap<String, PackageRoyaltyConfig>,
-}
-
 pub struct PackageNativePackage;
 
 impl PackageNativePackage {
@@ -813,17 +797,17 @@ impl PackageNativePackage {
         let mut original_code_substates = BTreeMap::new();
         let mut instrumented_code_substates = BTreeMap::new();
 
-        let code_hash = hash(&original_code);
-        vm_type_substates.insert(code_hash, PackageVmTypeSubstate { vm_type });
+        let code_hash = CodeHash::from(hash(&original_code));
+        vm_type_substates.insert(code_hash, PackageCodeVmTypeValue { vm_type });
         original_code_substates.insert(
             code_hash,
-            PackageOriginalCodeSubstate {
+            PackageCodeOriginalCodeValue {
                 code: original_code,
             },
         );
         if let Some(code) = instrumented_code {
             instrumented_code_substates
-                .insert(code_hash, PackageInstrumentedCodeSubstate { code: code });
+                .insert(code_hash, PackageCodeInstrumentedCodeValue { code });
         };
 
         {
@@ -975,37 +959,20 @@ impl PackageNativePackage {
                 .collect(),
             code_vm_type: vm_type_substates
                 .into_iter()
-                .map(|(code_hash, vm_type)| {
-                    (
-                        CodeHash::from(code_hash).into_key(),
-                        PackageCodeVmTypeValue {
-                            vm_type: vm_type.vm_type,
-                        }
-                        .into_locked_substate(),
-                    )
-                })
+                .map(|(code_hash, vm_type)| (code_hash.into_key(), vm_type.into_locked_substate()))
                 .collect(),
             code_original_code: original_code_substates
                 .into_iter()
                 .map(|(code_hash, original_code)| {
-                    (
-                        CodeHash::from(code_hash).into_key(),
-                        PackageCodeOriginalCodeValue {
-                            code: original_code.code,
-                        }
-                        .into_locked_substate(),
-                    )
+                    (code_hash.into_key(), original_code.into_locked_substate())
                 })
                 .collect(),
             code_instrumented_code: instrumented_code_substates
                 .into_iter()
                 .map(|(code_hash, instrumented_code)| {
                     (
-                        CodeHash::from(code_hash).into_key(),
-                        PackageCodeInstrumentedCodeValue {
-                            code: instrumented_code.code,
-                        }
-                        .into_locked_substate(),
+                        code_hash.into_key(),
+                        instrumented_code.into_locked_substate(),
                     )
                 })
                 .collect(),
@@ -1164,15 +1131,15 @@ impl PackageRoyaltyNativeBlueprint {
             let handle = api.kernel_open_substate(
                 receiver,
                 MAIN_BASE_PARTITION,
-                &PackageField::Royalty.into(),
+                &PackageField::RoyaltyAccumulator.into(),
                 LockFlags::MUTABLE,
                 SystemLockData::default(),
             )?;
 
-            let substate: FieldSubstate<PackageRoyaltyAccumulatorSubstate> =
+            let substate: PackageRoyaltyAccumulatorFieldSubstate =
                 api.kernel_read_substate(handle)?.as_typed().unwrap();
 
-            let vault_id = substate.value.0.royalty_vault.0;
+            let vault_id = substate.value.0 .0.into_latest().royalty_vault.0;
             let package_address = PackageAddress::new_or_panic(receiver.0);
             apply_royalty_cost(
                 api,
@@ -1199,12 +1166,12 @@ impl PackageRoyaltyNativeBlueprint {
 
         let handle = api.actor_open_field(
             OBJECT_HANDLE_SELF,
-            PackageField::Royalty.into(),
+            PackageField::RoyaltyAccumulator.into(),
             LockFlags::read_only(),
         )?;
 
-        let mut substate: PackageRoyaltyAccumulatorSubstate = api.field_read_typed(handle)?;
-        let bucket = substate.royalty_vault.take_all(api)?;
+        let mut substate: PackageRoyaltyAccumulatorFieldContent = api.field_read_typed(handle)?;
+        let bucket = substate.0.into_latest().royalty_vault.take_all(api)?;
 
         Ok(bucket)
     }
diff --git a/radix-engine/src/blueprints/package/substates.rs b/radix-engine/src/blueprints/package/substates.rs
index 7e7dec5e79b..bcf9b4aacb8 100644
--- a/radix-engine/src/blueprints/package/substates.rs
+++ b/radix-engine/src/blueprints/package/substates.rs
@@ -121,11 +121,6 @@ pub struct PackageRoyaltyAccumulatorFieldV1 {
 // Collection models - Schemas
 //---------------------------------------
 
-define_wrapped_hash!(
-    /// Represents a particular schema under a package
-    SchemaHash
-);
-
 // TODO(David): Change to VersionedSchema when can define a type as not-implicitly-versioned
 // TODO: Move to Schema partition when we have it
 pub type PackageSchemaValueV1 = ScryptoSchema;
@@ -143,25 +138,36 @@ pub type PackageBlueprintVersionAuthConfigValueV1 = AuthConfig;
 // Collection models - By Code
 //---------------------------------------
 
-define_wrapped_hash!(
-    /// Represents a particular instance of code under a package
-    CodeHash
-);
-
 #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
 #[sbor(transparent)]
 pub struct PackageCodeVmTypeValueV1 {
     pub vm_type: VmType,
 }
 
-#[derive(Debug, PartialEq, Eq, ScryptoSbor)]
+#[derive(PartialEq, Eq, ScryptoSbor)]
 #[sbor(transparent)]
 pub struct PackageCodeOriginalCodeValueV1 {
     pub code: Vec<u8>,
 }
 
-#[derive(Debug, PartialEq, Eq, ScryptoSbor)]
+impl Debug for PackageCodeOriginalCodeValueV1 {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("PackageCodeOriginalCodeValueV1")
+            .field("len", &self.code.len())
+            .finish()
+    }
+}
+
+#[derive(PartialEq, Eq, ScryptoSbor)]
 #[sbor(transparent)]
 pub struct PackageCodeInstrumentedCodeValueV1 {
     pub code: Vec<u8>,
 }
+
+impl Debug for PackageCodeInstrumentedCodeValueV1 {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("PackageCodeInstrumentedCodeValueV1")
+            .field("len", &self.code.len())
+            .finish()
+    }
+}
diff --git a/radix-engine/src/system/system.rs b/radix-engine/src/system/system.rs
index b2bfc95b033..bbb5cd25a43 100644
--- a/radix-engine/src/system/system.rs
+++ b/radix-engine/src/system/system.rs
@@ -498,7 +498,7 @@ where
     pub fn get_schema(
         &mut self,
         package_address: PackageAddress,
-        schema_hash: &Hash,
+        schema_hash: &SchemaHash,
     ) -> Result<ScryptoSchema, RuntimeError> {
         let def = self
             .api
diff --git a/radix-engine/src/system/system_callback.rs b/radix-engine/src/system/system_callback.rs
index 546586d2cc4..7a6cf4c5538 100644
--- a/radix-engine/src/system/system_callback.rs
+++ b/radix-engine/src/system/system_callback.rs
@@ -85,7 +85,7 @@ impl SystemLockData {
 pub struct SystemConfig<C: SystemCallbackObject> {
     pub callback_obj: C,
     pub blueprint_cache: NonIterMap<CanonicalBlueprintId, BlueprintDefinition>,
-    pub schema_cache: NonIterMap<Hash, ScryptoSchema>,
+    pub schema_cache: NonIterMap<SchemaHash, ScryptoSchema>,
     pub auth_cache: NonIterMap<CanonicalBlueprintId, AuthConfig>,
     pub modules: SystemModuleMixer,
 }
diff --git a/radix-engine/src/transaction/system_structure.rs b/radix-engine/src/transaction/system_structure.rs
index c5e3c778314..129adde8c10 100644
--- a/radix-engine/src/transaction/system_structure.rs
+++ b/radix-engine/src/transaction/system_structure.rs
@@ -35,9 +35,9 @@ pub enum SystemFieldKind {
 #[derive(Debug, Clone, ScryptoSbor, PartialEq, Eq)]
 pub struct KeyValueStoreEntryStructure {
     key_value_store_address: InternalAddress,
-    key_schema_hash: Hash,
+    key_schema_hash: SchemaHash,
     key_local_type_index: LocalTypeIndex,
-    value_schema_hash: Hash,
+    value_schema_hash: SchemaHash,
     value_local_type_index: LocalTypeIndex,
 }
 
@@ -73,14 +73,14 @@ pub enum ObjectSubstateTypeReference {
 #[derive(Debug, Clone, ScryptoSbor, PartialEq, Eq)]
 pub struct PackageTypeReference {
     package_address: PackageAddress,
-    schema_hash: Hash,
+    schema_hash: SchemaHash,
     local_type_index: LocalTypeIndex,
 }
 
 #[derive(Debug, Clone, ScryptoSbor, PartialEq, Eq)]
 pub struct ObjectInstanceTypeReference {
     entity_address: NodeId,
-    schema_hash: Hash,
+    schema_hash: SchemaHash,
     instance_type_index: u8,
     local_type_index: LocalTypeIndex,
 }
diff --git a/radix-engine/src/utils/package_extractor.rs b/radix-engine/src/utils/package_extractor.rs
index f3577016763..94e910ec26e 100644
--- a/radix-engine/src/utils/package_extractor.rs
+++ b/radix-engine/src/utils/package_extractor.rs
@@ -3,7 +3,9 @@ use crate::system::system_modules::costing::SystemLoanFeeReserve;
 use crate::types::*;
 use crate::vm::wasm::*;
 use crate::vm::wasm_runtime::NoOpWasmRuntime;
-use radix_engine_interface::blueprints::package::{BlueprintDefinitionInit, PackageDefinition};
+use radix_engine_interface::blueprints::package::{
+    BlueprintDefinitionInit, CodeHash, PackageDefinition,
+};
 use sbor::rust::iter;
 
 #[derive(Debug)]
@@ -28,7 +30,7 @@ pub fn extract_definition(code: &[u8]) -> Result<PackageDefinition, ExtractSchem
 
     // Validate WASM
     let validator = WasmValidator::default();
-    let code_hash = Hash([0u8; 32]);
+    let code_hash = CodeHash(Hash([0u8; 32]));
     let instrumented_code = validator
         .validate(&code, iter::empty())
         .map_err(|e| ExtractSchemaError::InvalidWasm(e))?
diff --git a/radix-engine/src/vm/scrypto_vm.rs b/radix-engine/src/vm/scrypto_vm.rs
index 1d8e4102abc..ce1e9e4d94a 100644
--- a/radix-engine/src/vm/scrypto_vm.rs
+++ b/radix-engine/src/vm/scrypto_vm.rs
@@ -4,6 +4,7 @@ use crate::vm::vm::VmInvoke;
 use crate::vm::wasm::*;
 use crate::vm::wasm_runtime::ScryptoRuntime;
 use radix_engine_interface::api::ClientApi;
+use radix_engine_interface::blueprints::package::CodeHash;
 use resources_tracker_macro::trace_resources;
 
 pub struct ScryptoVm<W: WasmEngine> {
@@ -24,7 +25,7 @@ impl<W: WasmEngine> ScryptoVm<W> {
     pub fn create_instance(
         &self,
         package_address: &PackageAddress,
-        code_hash: Hash,
+        code_hash: CodeHash,
         instrumented_code: &[u8],
     ) -> ScryptoVmInstance<W::WasmInstance> {
         ScryptoVmInstance {
diff --git a/radix-engine/src/vm/vm.rs b/radix-engine/src/vm/vm.rs
index d8a0888742a..da707ef91ba 100644
--- a/radix-engine/src/vm/vm.rs
+++ b/radix-engine/src/vm/vm.rs
@@ -1,4 +1,7 @@
-use crate::blueprints::package::{PackageError, VmType};
+use crate::blueprints::package::{
+    PackageCodeInstrumentedCodeEntrySubstate, PackageCodeOriginalCodeEntrySubstate,
+    PackageCodeVmTypeEntrySubstate, PackageError, VmType,
+};
 use crate::errors::{ApplicationError, RuntimeError};
 use crate::kernel::kernel_api::{KernelInternalApi, KernelNodeApi, KernelSubstateApi};
 use crate::system::system::KeyValueEntrySubstate;
@@ -63,14 +66,14 @@ impl<'g, W: WasmEngine + 'g, E: NativeVmExtension> SystemCallbackObject for Vm<'
                 SystemLockData::default(),
             )?;
             let vm_type = api.kernel_read_substate(handle)?;
-            let vm_type: KeyValueEntrySubstate<PackageVmTypeSubstate> = vm_type.as_typed().unwrap();
+            let vm_type: PackageCodeVmTypeEntrySubstate = vm_type.as_typed().unwrap();
             api.kernel_close_substate(handle)?;
             vm_type
                 .value
                 .expect(&format!("Vm type not found: {:?}", export))
         };
 
-        let output = match vm_type.vm_type {
+        let output = match vm_type.0.into_latest().vm_type {
             VmType::Native => {
                 let original_code = {
                     let handle = api.kernel_open_substate_with_default(
@@ -87,7 +90,7 @@ impl<'g, W: WasmEngine + 'g, E: NativeVmExtension> SystemCallbackObject for Vm<'
                         SystemLockData::default(),
                     )?;
                     let original_code = api.kernel_read_substate(handle)?;
-                    let original_code: KeyValueEntrySubstate<PackageOriginalCodeSubstate> =
+                    let original_code: PackageCodeOriginalCodeEntrySubstate =
                         original_code.as_typed().unwrap();
                     api.kernel_close_substate(handle)?;
                     original_code
@@ -99,7 +102,7 @@ impl<'g, W: WasmEngine + 'g, E: NativeVmExtension> SystemCallbackObject for Vm<'
                     .kernel_get_system()
                     .callback_obj
                     .native_vm
-                    .create_instance(address, &original_code.code)?;
+                    .create_instance(address, &original_code.0.into_latest().code)?;
                 let output = { vm_instance.invoke(export.export_name.as_str(), input, api)? };
 
                 output
@@ -120,12 +123,14 @@ impl<'g, W: WasmEngine + 'g, E: NativeVmExtension> SystemCallbackObject for Vm<'
                         SystemLockData::default(),
                     )?;
                     let instrumented_code = api.kernel_read_substate(handle)?;
-                    let instrumented_code: KeyValueEntrySubstate<PackageInstrumentedCodeSubstate> =
+                    let instrumented_code: PackageCodeInstrumentedCodeEntrySubstate =
                         instrumented_code.as_typed().unwrap();
                     api.kernel_close_substate(handle)?;
                     instrumented_code
                         .value
                         .expect(&format!("Instrumented code not found: {:?}", export))
+                        .0
+                        .into_latest()
                 };
 
                 let mut scrypto_vm_instance = {
diff --git a/radix-engine/src/vm/wasm/traits.rs b/radix-engine/src/vm/wasm/traits.rs
index 35cf8fd3d43..09701765ac3 100644
--- a/radix-engine/src/vm/wasm/traits.rs
+++ b/radix-engine/src/vm/wasm/traits.rs
@@ -1,6 +1,7 @@
 use crate::errors::InvokeError;
 use crate::types::*;
 use crate::vm::wasm::errors::*;
+use radix_engine_interface::blueprints::package::CodeHash;
 use sbor::rust::boxed::Box;
 use sbor::rust::vec::Vec;
 
@@ -190,5 +191,5 @@ pub trait WasmEngine {
     /// Instantiate a Scrypto module.
     ///
     /// The code must have been validated and instrumented!!!
-    fn instantiate(&self, code_hash: Hash, instrumented_code: &[u8]) -> Self::WasmInstance;
+    fn instantiate(&self, code_hash: CodeHash, instrumented_code: &[u8]) -> Self::WasmInstance;
 }
diff --git a/radix-engine/src/vm/wasm/wasmer.rs b/radix-engine/src/vm/wasm/wasmer.rs
index 581511d2a23..8d6af139b71 100644
--- a/radix-engine/src/vm/wasm/wasmer.rs
+++ b/radix-engine/src/vm/wasm/wasmer.rs
@@ -3,6 +3,7 @@ use crate::types::*;
 use crate::vm::wasm::constants::*;
 use crate::vm::wasm::errors::*;
 use crate::vm::wasm::traits::*;
+use radix_engine_interface::blueprints::package::CodeHash;
 use sbor::rust::sync::{Arc, Mutex};
 use wasmer::{
     imports, Function, HostEnvInitError, Instance, LazyInit, Module, RuntimeError, Store,
@@ -76,9 +77,9 @@ pub struct WasmerEngine {
     store: Store,
     // This flag disables cache in wasm_instrumenter/wasmi/wasmer to prevent non-determinism when fuzzing
     #[cfg(all(not(feature = "radix_engine_fuzzing"), not(feature = "moka")))]
-    modules_cache: RefCell<lru::LruCache<Hash, Arc<WasmerModule>>>,
+    modules_cache: RefCell<lru::LruCache<CodeHash, Arc<WasmerModule>>>,
     #[cfg(all(not(feature = "radix_engine_fuzzing"), feature = "moka"))]
-    modules_cache: moka::sync::Cache<Hash, Arc<WasmerModule>>,
+    modules_cache: moka::sync::Cache<CodeHash, Arc<WasmerModule>>,
     #[cfg(feature = "radix_engine_fuzzing")]
     modules_cache: usize,
 }
@@ -803,7 +804,7 @@ impl WasmerEngine {
         #[cfg(all(not(feature = "radix_engine_fuzzing"), feature = "moka"))]
         let modules_cache = moka::sync::Cache::builder()
             .weigher(
-                |_metered_code_key: &Hash, _value: &Arc<WasmerModule>| -> u32 {
+                |_metered_code_key: &CodeHash, _value: &Arc<WasmerModule>| -> u32 {
                     // No sophisticated weighing mechanism, just keep a fixed size cache
                     1u32
                 },
@@ -823,7 +824,7 @@ impl WasmerEngine {
 impl WasmEngine for WasmerEngine {
     type WasmInstance = WasmerInstance;
 
-    fn instantiate(&self, code_hash: Hash, instrumented_code: &[u8]) -> WasmerInstance {
+    fn instantiate(&self, code_hash: CodeHash, instrumented_code: &[u8]) -> WasmerInstance {
         #[cfg(not(feature = "radix_engine_fuzzing"))]
         {
             #[cfg(not(feature = "moka"))]
diff --git a/radix-engine/src/vm/wasm/wasmi.rs b/radix-engine/src/vm/wasm/wasmi.rs
index 5b444a567e2..15f9392e6b4 100644
--- a/radix-engine/src/vm/wasm/wasmi.rs
+++ b/radix-engine/src/vm/wasm/wasmi.rs
@@ -1,3 +1,4 @@
+use radix_engine_interface::blueprints::package::CodeHash;
 use sbor::rust::mem::transmute;
 use sbor::rust::mem::MaybeUninit;
 #[cfg(not(feature = "radix_engine_fuzzing"))]
@@ -1230,9 +1231,9 @@ pub struct WasmiEngineOptions {
 pub struct WasmiEngine {
     // This flag disables cache in wasm_instrumenter/wasmi/wasmer to prevent non-determinism when fuzzing
     #[cfg(all(not(feature = "radix_engine_fuzzing"), not(feature = "moka")))]
-    modules_cache: RefCell<lru::LruCache<Hash, Arc<WasmiModule>>>,
+    modules_cache: RefCell<lru::LruCache<CodeHash, Arc<WasmiModule>>>,
     #[cfg(all(not(feature = "radix_engine_fuzzing"), feature = "moka"))]
-    modules_cache: moka::sync::Cache<Hash, Arc<WasmiModule>>,
+    modules_cache: moka::sync::Cache<CodeHash, Arc<WasmiModule>>,
     #[cfg(feature = "radix_engine_fuzzing")]
     #[allow(dead_code)]
     modules_cache: usize,
@@ -1254,7 +1255,7 @@ impl WasmiEngine {
         ));
         #[cfg(all(not(feature = "radix_engine_fuzzing"), feature = "moka"))]
         let modules_cache = moka::sync::Cache::builder()
-            .weigher(|_key: &Hash, _value: &Arc<WasmiModule>| -> u32 {
+            .weigher(|_key: &CodeHash, _value: &Arc<WasmiModule>| -> u32 {
                 // No sophisticated weighing mechanism, just keep a fixed size cache
                 1u32
             })
@@ -1271,7 +1272,7 @@ impl WasmEngine for WasmiEngine {
     type WasmInstance = WasmiInstance;
 
     #[allow(unused_variables)]
-    fn instantiate(&self, code_hash: Hash, instrumented_code: &[u8]) -> WasmiInstance {
+    fn instantiate(&self, code_hash: CodeHash, instrumented_code: &[u8]) -> WasmiInstance {
         #[cfg(not(feature = "radix_engine_fuzzing"))]
         {
             #[cfg(not(feature = "moka"))]
diff --git a/scrypto-unit/src/test_runner.rs b/scrypto-unit/src/test_runner.rs
index fd148c090c3..f8f19eb9ce8 100644
--- a/scrypto-unit/src/test_runner.rs
+++ b/scrypto-unit/src/test_runner.rs
@@ -28,8 +28,8 @@ use radix_engine_interface::blueprints::consensus_manager::{
 };
 use radix_engine_interface::blueprints::package::{
     BlueprintDefinitionInit, PackageDefinition, PackagePublishNativeManifestInput,
-    PackagePublishWasmAdvancedManifestInput, PackageRoyaltyAccumulatorSubstate, TypePointer,
-    PACKAGE_BLUEPRINT, PACKAGE_PUBLISH_NATIVE_IDENT, PACKAGE_PUBLISH_WASM_ADVANCED_IDENT,
+    PackagePublishWasmAdvancedManifestInput, TypePointer, PACKAGE_BLUEPRINT,
+    PACKAGE_PUBLISH_NATIVE_IDENT, PACKAGE_PUBLISH_WASM_ADVANCED_IDENT,
     PACKAGE_SCHEMAS_PARTITION_OFFSET,
 };
 use radix_engine_interface::constants::CONSENSUS_MANAGER;
@@ -38,9 +38,7 @@ use radix_engine_interface::network::NetworkDefinition;
 use radix_engine_interface::time::Instant;
 use radix_engine_interface::{dec, freeze_roles, rule};
 use radix_engine_queries::query::{ResourceAccounter, StateTreeTraverser, VaultFinder};
-use radix_engine_queries::typed_substate_layout::{
-    BlueprintDefinition, BlueprintVersionKey, PACKAGE_BLUEPRINTS_PARTITION_OFFSET,
-};
+use radix_engine_queries::typed_substate_layout::*;
 use radix_engine_store_interface::db_key_mapper::DatabaseKeyMapper;
 use radix_engine_store_interface::db_key_mapper::{
     MappedCommittableSubstateDatabase, MappedSubstateDatabase, SpreadPrefixKeyMapper,
@@ -550,17 +548,17 @@ impl<E: NativeVmExtension, D: TestDatabase> TestRunner<E, D> {
     pub fn inspect_package_royalty(&mut self, package_address: PackageAddress) -> Option<Decimal> {
         let output = self
             .database
-            .get_mapped::<SpreadPrefixKeyMapper, FieldSubstate<PackageRoyaltyAccumulatorSubstate>>(
+            .get_mapped::<SpreadPrefixKeyMapper, PackageRoyaltyAccumulatorFieldSubstate>(
                 package_address.as_node_id(),
                 MAIN_BASE_PARTITION,
-                &PackageField::Royalty.into(),
+                &PackageField::RoyaltyAccumulator.into(),
             )?
             .value
             .0;
 
         self.database
             .get_mapped::<SpreadPrefixKeyMapper, FieldSubstate<LiquidFungibleResource>>(
-                output.royalty_vault.0.as_node_id(),
+                output.0.into_latest().royalty_vault.0.as_node_id(),
                 MAIN_BASE_PARTITION,
                 &FungibleVaultField::LiquidFungible.into(),
             )
@@ -609,7 +607,7 @@ impl<E: NativeVmExtension, D: TestDatabase> TestRunner<E, D> {
     pub fn get_package_scrypto_schemas(
         &self,
         package_address: &PackageAddress,
-    ) -> IndexMap<Hash, ScryptoSchema> {
+    ) -> IndexMap<SchemaHash, ScryptoSchema> {
         let mut schemas = index_map_new();
         for entry in self
             .substate_db()
@@ -620,12 +618,12 @@ impl<E: NativeVmExtension, D: TestDatabase> TestRunner<E, D> {
                     .unwrap(),
             ))
         {
-            let hash: Hash =
+            let hash: SchemaHash =
                 scrypto_decode(&SpreadPrefixKeyMapper::map_from_db_sort_key(&entry.0)).unwrap();
-            let value: KeyValueEntrySubstate<ScryptoSchema> = scrypto_decode(&entry.1).unwrap();
+            let value: PackageSchemaEntrySubstate = scrypto_decode(&entry.1).unwrap();
             match value.value {
                 Some(schema) => {
-                    schemas.insert(hash, schema);
+                    schemas.insert(hash, schema.0.into_latest());
                 }
                 None => {}
             }
diff --git a/simulator/src/ledger/dumper.rs b/simulator/src/ledger/dumper.rs
index 6d7e1e0673a..1a1e18e5a65 100644
--- a/simulator/src/ledger/dumper.rs
+++ b/simulator/src/ledger/dumper.rs
@@ -8,6 +8,7 @@ use radix_engine::types::*;
 use radix_engine_interface::blueprints::package::*;
 use radix_engine_interface::network::NetworkDefinition;
 use radix_engine_queries::query::ResourceAccounter;
+use radix_engine_queries::typed_substate_layout::PackageCodeOriginalCodeEntrySubstate;
 use radix_engine_store_interface::{
     db_key_mapper::{MappedSubstateDatabase, SpreadPrefixKeyMapper},
     interface::SubstateDatabase,
@@ -31,7 +32,7 @@ pub fn dump_package<T: SubstateDatabase, O: std::io::Write>(
 ) -> Result<(), EntityDumpError> {
     let address_bech32_encoder = AddressBech32Encoder::new(&NetworkDefinition::simulator());
     let (_, substate) = substate_db
-        .list_mapped::<SpreadPrefixKeyMapper, KeyValueEntrySubstate<PackageOriginalCodeSubstate>, MapKey>(
+        .list_mapped::<SpreadPrefixKeyMapper, PackageCodeOriginalCodeEntrySubstate, MapKey>(
             package_address.as_node_id(),
             MAIN_BASE_PARTITION
                 .at_offset(PACKAGE_ORIGINAL_CODE_PARTITION_OFFSET)
@@ -50,7 +51,7 @@ pub fn dump_package<T: SubstateDatabase, O: std::io::Write>(
         output,
         "{}: {} bytes",
         "Code size".green().bold(),
-        substate.value.unwrap().code.len()
+        substate.value.unwrap().0.into_latest().code.len()
     );
     Ok(())
 }
diff --git a/simulator/src/resim/cmd_publish.rs b/simulator/src/resim/cmd_publish.rs
index d9650af9f22..6240ee35bad 100644
--- a/simulator/src/resim/cmd_publish.rs
+++ b/simulator/src/resim/cmd_publish.rs
@@ -5,9 +5,7 @@ use radix_engine_interface::blueprints::package::{
     BlueprintDefinition, BlueprintDependencies, FunctionSchema, IndexedStateSchema, PackageExport,
     TypePointer, VmType, *,
 };
-use radix_engine_interface::blueprints::package::{PackageDefinition, PackageOriginalCodeSubstate};
 use radix_engine_interface::schema::TypeRef;
-use radix_engine_queries::typed_substate_layout::PackageVmTypeSubstate;
 use radix_engine_store_interface::{
     db_key_mapper::{DatabaseKeyMapper, SpreadPrefixKeyMapper},
     interface::{CommittableSubstateDatabase, DatabaseUpdate},
diff --git a/simulator/src/resim/error.rs b/simulator/src/resim/error.rs
index 0216117efbb..88613757008 100644
--- a/simulator/src/resim/error.rs
+++ b/simulator/src/resim/error.rs
@@ -8,6 +8,7 @@ use radix_engine::utils::ExtractSchemaError;
 use radix_engine::vm::wasm::PrepareError;
 use radix_engine_interface::blueprints::resource::ParseNonFungibleGlobalIdError;
 use radix_engine_interface::network::ParseNetworkError;
+use radix_engine_interface::types::SchemaHash;
 use sbor::*;
 use transaction::errors::*;
 use transaction::model::PrepareError as TransactionPrepareError;
@@ -25,7 +26,7 @@ pub enum Error {
     HomeDirUnknown,
 
     PackageNotFound(PackageAddress),
-    SchemaNotFound(PackageAddress, Hash),
+    SchemaNotFound(PackageAddress, SchemaHash),
     BlueprintNotFound(PackageAddress, String),
     ComponentNotFound(ComponentAddress),
     InstanceSchemaNot(ComponentAddress, u8),
diff --git a/simulator/src/resim/mod.rs b/simulator/src/resim/mod.rs
index 74a48581c47..d6eaaa1f494 100644
--- a/simulator/src/resim/mod.rs
+++ b/simulator/src/resim/mod.rs
@@ -76,6 +76,7 @@ use radix_engine_interface::blueprints::package::{
 use radix_engine_interface::blueprints::resource::FromPublicKey;
 use radix_engine_interface::crypto::hash;
 use radix_engine_interface::network::NetworkDefinition;
+use radix_engine_queries::typed_substate_layout::PackageSchemaEntrySubstate;
 use radix_engine_store_interface::{
     db_key_mapper::{
         MappedCommittableSubstateDatabase, MappedSubstateDatabase, SpreadPrefixKeyMapper,
@@ -377,7 +378,7 @@ pub fn export_object_info(component_address: ComponentAddress) -> Result<ObjectI
 
 pub fn export_schema(
     package_address: PackageAddress,
-    schema_hash: Hash,
+    schema_hash: SchemaHash,
 ) -> Result<ScryptoSchema, Error> {
     let scrypto_vm = ScryptoVm::<DefaultWasmEngine>::default();
     let native_vm = DefaultNativeVm::new();
@@ -386,7 +387,7 @@ pub fn export_schema(
     Bootstrapper::new(&mut substate_db, vm, false).bootstrap_test_default();
 
     let schema = substate_db
-        .get_mapped::<SpreadPrefixKeyMapper, KeyValueEntrySubstate<ScryptoSchema>>(
+        .get_mapped::<SpreadPrefixKeyMapper, PackageSchemaEntrySubstate>(
             package_address.as_node_id(),
             MAIN_BASE_PARTITION
                 .at_offset(PACKAGE_SCHEMAS_PARTITION_OFFSET)
@@ -395,7 +396,9 @@ pub fn export_schema(
         )
         .ok_or(Error::SchemaNotFound(package_address, schema_hash))?
         .value
-        .unwrap();
+        .unwrap()
+        .0
+        .into_latest();
 
     Ok(schema)
 }

From 3284bc1cbf2e3cc52e450e3ba668cc8b55938daa Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Mon, 14 Aug 2023 03:14:09 +0100
Subject: [PATCH 14/28] feature: Further updates to
 `declare_native_blueprint_state`

---
 radix-engine-tests/benches/costing.rs         |   7 +-
 .../tests/schema_sanity_check.rs              |   2 +-
 radix-engine/src/blueprints/macros.rs         | 404 +++++++++++++++---
 .../src/blueprints/package/package.rs         | 208 ++++-----
 .../src/blueprints/package/substates.rs       |  36 +-
 radix-engine/src/errors.rs                    |   1 +
 radix-engine/src/track/interface.rs           |  32 ++
 radix-engine/src/track/mod.rs                 |   1 +
 radix-engine/src/vm/vm.rs                     |   8 +-
 scrypto-schema/src/lib.rs                     |  14 +
 simulator/src/ledger/dumper.rs                |   2 +-
 simulator/src/resim/cmd_publish.rs            | 171 +++-----
 simulator/src/resim/error.rs                  |   2 +-
 13 files changed, 567 insertions(+), 321 deletions(-)

diff --git a/radix-engine-tests/benches/costing.rs b/radix-engine-tests/benches/costing.rs
index e6c60b4475d..5f7c56b2f8f 100644
--- a/radix-engine-tests/benches/costing.rs
+++ b/radix-engine-tests/benches/costing.rs
@@ -11,7 +11,7 @@ use radix_engine::{
         wasm_runtime::NoOpWasmRuntime,
     },
 };
-use radix_engine_queries::typed_substate_layout::PackageDefinition;
+use radix_engine_queries::typed_substate_layout::{CodeHash, PackageDefinition};
 use sbor::rust::iter;
 use scrypto_unit::TestRunnerBuilder;
 use transaction::{
@@ -87,7 +87,8 @@ fn bench_spin_loop(c: &mut Criterion) {
                 fee_reserve,
                 &mut wasm_execution_units_consumed,
             ));
-            let mut instance = wasm_engine.instantiate(Hash([0u8; 32]), &instrumented_code);
+            let mut instance =
+                wasm_engine.instantiate(CodeHash(Hash([0u8; 32])), &instrumented_code);
             instance
                 .invoke_export("Test_f", vec![Buffer(0)], &mut runtime)
                 .unwrap();
@@ -118,7 +119,7 @@ macro_rules! bench_instantiate {
             c.bench_function(concat!("costing::instantiate_", $what), |b| {
                 b.iter(|| {
                     let wasm_engine = DefaultWasmEngine::default();
-                    wasm_engine.instantiate(Hash([0u8; 32]), &instrumented_code);
+                    wasm_engine.instantiate(CodeHash(Hash([0u8; 32])), &instrumented_code);
                 })
             });
 
diff --git a/radix-engine-tests/tests/schema_sanity_check.rs b/radix-engine-tests/tests/schema_sanity_check.rs
index f71f28c007b..0dc5d5666d4 100644
--- a/radix-engine-tests/tests/schema_sanity_check.rs
+++ b/radix-engine-tests/tests/schema_sanity_check.rs
@@ -146,7 +146,7 @@ fn scan_native_blueprint_schemas_and_highlight_unsafe_types() {
 }
 
 fn check_type_pointers(
-    schemas_by_hash: &IndexMap<Hash, ScryptoSchema>,
+    schemas_by_hash: &IndexMap<SchemaHash, ScryptoSchema>,
     type_pointers: &[TypePointer],
 ) -> CheckResult {
     for ty in type_pointers {
diff --git a/radix-engine/src/blueprints/macros.rs b/radix-engine/src/blueprints/macros.rs
index 3c43da4d22c..3246df698f4 100644
--- a/radix-engine/src/blueprints/macros.rs
+++ b/radix-engine/src/blueprints/macros.rs
@@ -1,6 +1,165 @@
+use crate::errors::*;
 use crate::system::system::*;
 use crate::types::*;
 
+// TODO(David) - Move this, features and content stuff under a `models` module?
+// TODO(David) - Create an internal_prelude in `blueprints`
+// and an internal_prelude and prelud in engine
+pub trait FeatureSetResolver {
+    fn feature_names_str(&self) -> Vec<&'static str>;
+
+    fn feature_names_str_set(&self) -> BTreeSet<&'static str> {
+        self.feature_names_str().into_iter().collect()
+    }
+
+    fn feature_names_string(&self) -> Vec<String> {
+        self.feature_names_str()
+            .into_iter()
+            .map(|s| s.to_owned())
+            .collect()
+    }
+
+    fn feature_names_string_set(&self) -> BTreeSet<String> {
+        self.feature_names_str()
+            .into_iter()
+            .map(|s| s.to_owned())
+            .collect()
+    }
+}
+
+/// For feature checks against a non-inner object
+pub enum FeatureChecks<TOwn: FeatureSetResolver> {
+    None,
+    RequireAllSubstates,
+    ForFeatures { own_features: TOwn },
+}
+
+impl<T: FeatureSetResolver> From<T> for FeatureChecks<T> {
+    fn from(value: T) -> Self {
+        FeatureChecks::ForFeatures {
+            own_features: value,
+        }
+    }
+}
+
+impl<TOwn: FeatureSetResolver> FeatureChecks<TOwn> {
+    pub fn assert_valid(
+        &self,
+        substate_name: &'static str,
+        condition: &Condition,
+        is_present: bool,
+    ) -> Result<(), RuntimeError> {
+        let is_valid = match self {
+            FeatureChecks::None => Ok(()),
+            FeatureChecks::RequireAllSubstates => {
+                if is_present {
+                    Ok(())
+                } else {
+                    Err(format!("Required all substates to be present, but {} was not present", substate_name))
+                }
+            },
+            FeatureChecks::ForFeatures { own_features } => {
+                match condition {
+                    Condition::Always => {
+                        if is_present {
+                            Ok(())
+                        } else {
+                            Err(format!("Substate condition for {} required it to be always present, but it was not", substate_name))
+                        }
+                    }
+                    Condition::IfFeature(feature) => {
+                        let feature_enabled = own_features.feature_names_str().contains(&feature.as_str());
+                        if feature_enabled && !is_present {
+                            Err(format!("Substate condition for {} required it to be present when the feature {} was enabled, but it was absent", substate_name, feature))
+                        } else if !feature_enabled && is_present {
+                            Err(format!("Substate condition for {} required it to be absent when the feature {} was disabled, but it was present", substate_name, feature))
+                        } else {
+                            Ok(())
+                        }
+                    },
+                    Condition::IfOuterFeature(_) => {
+                        Err(format!("Substate condition for {} required an outer object feature, but the blueprint does not have an outer blueprint defined", substate_name))
+                    }
+                }
+            },
+        };
+        is_valid.map_err(|error_message| {
+            RuntimeError::SystemError(SystemError::InvalidNativeSubstatesForFeature(error_message))
+        })
+    }
+}
+
+/// For feature checks against an inner object
+pub enum InnerObjectFeatureChecks<TOwn, TOuter> {
+    None,
+    RequireAllSubstates,
+    ForFeatures {
+        own_features: TOwn,
+        outer_object_features: TOuter,
+    },
+}
+
+impl<TOwn: FeatureSetResolver, TOuter: FeatureSetResolver> InnerObjectFeatureChecks<TOwn, TOuter> {
+    pub fn assert_valid(
+        &self,
+        substate_name: &'static str,
+        condition: &Condition,
+        is_present: bool,
+    ) -> Result<(), RuntimeError> {
+        let is_valid = match self {
+            Self::None => Ok(()),
+            Self::RequireAllSubstates => {
+                if is_present {
+                    Ok(())
+                } else {
+                    Err(format!(
+                        "Required all substates to be present, but {} was not present",
+                        substate_name
+                    ))
+                }
+            }
+            Self::ForFeatures {
+                own_features,
+                outer_object_features,
+            } => match condition {
+                Condition::Always => {
+                    if is_present {
+                        Ok(())
+                    } else {
+                        Err(format!("Substate condition for {} required it to be always present, but it was not", substate_name))
+                    }
+                }
+                Condition::IfFeature(feature) => {
+                    let feature_enabled =
+                        own_features.feature_names_str().contains(&feature.as_str());
+                    if feature_enabled && !is_present {
+                        Err(format!("Substate condition for {} required it to be present when the feature {} was enabled, but it was absent", substate_name, feature))
+                    } else if !feature_enabled && is_present {
+                        Err(format!("Substate condition for {} required it to be absent when the feature {} was disabled, but it was present", substate_name, feature))
+                    } else {
+                        Ok(())
+                    }
+                }
+                Condition::IfOuterFeature(feature) => {
+                    let feature_enabled = outer_object_features
+                        .feature_names_str()
+                        .contains(&feature.as_str());
+                    if feature_enabled && !is_present {
+                        Err(format!("Substate condition for {} required it to be present when the outer object feature {} was enabled, but it was absent", substate_name, feature))
+                    } else if !feature_enabled && is_present {
+                        Err(format!("Substate condition for {} required it to be absent when the outer object feature {} was disabled, but it was present", substate_name, feature))
+                    } else {
+                        Ok(())
+                    }
+                }
+            },
+        };
+        is_valid.map_err(|error_message| {
+            RuntimeError::SystemError(SystemError::InvalidNativeSubstatesForFeature(error_message))
+        })
+    }
+}
+
 pub trait FieldContent<ActualContent: From<Self>>: Sized {
     fn into_locked_substate(self) -> FieldSubstate<ActualContent> {
         FieldSubstate::new_locked_field(self.into())
@@ -39,15 +198,14 @@ pub trait SortedIndexEntryContent<ActualContent: From<Self>>: Sized {
     }
 }
 
-/// Generates types and typed-interfaces for native blueprints and their
-/// interaction with the substate store.
+/// Generates types and typed-interfaces for native blueprints, their
+/// state models, features, partitions, and their interaction with
+/// the substate store.
 ///
-/// * For fields, assumes the existence of a type called:
-///    * `<BlueprintIdent><FieldIdent>FieldV1`
-/// * For collections, assumes the existence of types called:
-///    * `<BlueprintIdent><CollectionIdent>ValueV1`
+/// See the below structure for detail on how it should look - or check
+/// out [../package/substates.rs](the package substates definition).
 ///
-/// The types should look something like
+/// Each type token-tree should look something like the following.
 /// ```
 ///     {
 ///         kind: StaticSingleVersioned,
@@ -67,12 +225,50 @@ pub trait SortedIndexEntryContent<ActualContent: From<Self>>: Sized {
 ///         latest: V3,
 ///     }
 /// ```
+///
+/// By default, choose  `StaticSingleVersioned`, which will create a
+/// forward-compatible enum wrapper with a single version.
+/// For Fields, it will assume the existence of a type called
+/// `<BlueprintIdent><FieldIdent>V1` and will generate the following types:
+/// * `<BlueprintIdent><FieldIdent>` - a type alias for the latest version (V1).
+/// * `Versioned<BlueprintIdent><FieldIdent>` - the enum wrapper with a single version.
+/// * `<BlueprintIdent><FieldIdent>FieldContent` - a transparent new type for the full content (wrapping the versioned enum)
+/// * `<BlueprintIdent><FieldIdent>FieldSubstate` - a type for the full system-wrapped substate
+///
+/// For collection values, it will assume the existence of `<BlueprintIdent><CollectionIdent>V1`
+/// and generate the following types:
+/// * `<BlueprintIdent><CollectionIdent>` - a type alias for the latest version (V1).
+/// * `Versioned<BlueprintIdent><CollectionIdent>` - the enum wrapper with a single version.
+/// * `<BlueprintIdent><CollectionIdent>EntryContent` - a transparent new type for the full content (wrapping the versioned enum)
+/// * `<BlueprintIdent><CollectionIdent>EntrySubstate` - a type for the full system-wrapped substate
+///
+/// For collection keys, it will assume the existence of `<BlueprintIdent><CollectionIdent>KeyInnerV1`
+/// and generate the following types:
+/// * `<BlueprintIdent><CollectionIdent>KeyInner` - a type alias for the latest version (V1)
+/// * `Versioned<BlueprintIdent><CollectionIdent>KeyInner` - the enum wrapper with a single version.
+/// * `<BlueprintIdent><CollectionIdent>KeyContent` - a transparent new type for the full key content (wrapping the versioned enum)
+/// * `<BlueprintIdent><CollectionIdent>Key` - a type for the full key (eg includes the u16 for a sorted index key)
 #[allow(unused)]
 macro_rules! declare_native_blueprint_state {
     (
         blueprint_ident: $blueprint_ident:ident,
         blueprint_snake_case: $blueprint_property_name:ident,
-        instance_schema_types: [
+        $(
+            outer_blueprint: {
+                ident: $outer_blueprint_ident:ident
+                $(,)?
+            },
+        )?
+        features: {
+            $(
+                $feature_property_name:ident: {
+                    ident: $feature_ident:ident,
+                    description: $feature_description:expr,
+                }
+            ),*
+            $(,)?
+        },
+        instance_schema_types: {
             // If no types => instance schema disabled
             $(
                 $instance_type_property_name:ident: {
@@ -80,7 +276,7 @@ macro_rules! declare_native_blueprint_state {
                 }
             ),*
             $(,)?
-        ],
+        },
         fields: {
             $(
                 $field_property_name:ident: {
@@ -118,7 +314,7 @@ macro_rules! declare_native_blueprint_state {
                 use sbor::*;
                 use $crate::types::*;
                 use $crate::track::interface::*;
-                use $crate::errors::RuntimeError;
+                use $crate::errors::*;
                 use $crate::system::system::*;
                 use radix_engine_interface::api::*;
                 //--------------------------------------------------------
@@ -135,7 +331,7 @@ macro_rules! declare_native_blueprint_state {
                     // > Set up the FieldContent trait for anything which can be resolved into the field content
                     generate_content_type!(
                         content_trait: FieldContent,
-                        ident_core: [<$blueprint_ident $field_ident Field>],
+                        ident_core: [<$blueprint_ident $field_ident>],
                         #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
                         struct [<$blueprint_ident $field_ident FieldContent>] = $field_type
                     );
@@ -158,15 +354,19 @@ macro_rules! declare_native_blueprint_state {
                     generate_content_type!(
                         content_trait: KeyContent,
                         ident_core: [<$blueprint_ident $collection_ident KeyInner>],
-                        #[derive(Debug, Clone, Hash, PartialEq, Eq, ScryptoSbor)]
+                        #[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, ScryptoSbor)]
                         #[sbor(transparent_name)]
-                        struct [<$blueprint_ident $collection_ident Key>] = $collection_key_type
+                        struct [<$blueprint_ident $collection_ident KeyContent>] = $collection_key_type
                     );
 
+                    // TODO(David): Tweak when I work out the right strategy for keys. Probably just want a single new-type.
+                    // So probably just don't use generate_content_type but use generate_key_type or something instead?
+                    pub type [<$blueprint_ident $collection_ident Key>] = [<$blueprint_ident $collection_ident KeyContent>];
+
                     // TODO(David) - Properly handle SortedIndex:
                     // Fix Key types for SortedIndex to have a named u16 part of the key,
                     // use a different key trait, and use .for_sorted_key in the below.
-                    impl TryFrom<&SubstateKey> for [<$blueprint_ident $collection_ident Key>] {
+                    impl TryFrom<&SubstateKey> for [<$blueprint_ident $collection_ident KeyContent>] {
                         type Error = ();
 
                         fn try_from(substate_key: &SubstateKey) -> Result<Self, Self::Error> {
@@ -183,14 +383,14 @@ macro_rules! declare_native_blueprint_state {
                     // > Set up the _EntryContent traits
                     generate_content_type!(
                         content_trait: [<$collection_type EntryContent>],
-                        ident_core: [<$blueprint_ident $collection_ident Value>],
+                        ident_core: [<$blueprint_ident $collection_ident>],
                         #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
-                        struct [<$blueprint_ident $collection_ident ValueContent>] = $collection_value_type
+                        struct [<$blueprint_ident $collection_ident EntryContent>] = $collection_value_type
                     );
                     // > Set up the _EntrySubstate alias for the system-wrapped substate
                     generate_system_substate_type_alias!(
                         $collection_type,
-                        type [<$blueprint_ident $collection_ident EntrySubstate>] = WRAPPED [<$blueprint_ident $collection_ident ValueContent>]
+                        type [<$blueprint_ident $collection_ident EntrySubstate>] = WRAPPED [<$blueprint_ident $collection_ident EntryContent>]
                     );
                 )*
 
@@ -269,6 +469,38 @@ macro_rules! declare_native_blueprint_state {
                     }
                 }
 
+                #[derive(Debug, Clone, Copy, Sbor, PartialEq, Eq, Hash)]
+                pub struct [<$blueprint_ident FeatureSet>] {
+                    $(pub [<$feature_property_name>]: bool,)*
+                }
+
+                impl FeatureSetResolver for [<$blueprint_ident FeatureSet>] {
+                    fn feature_names_str(&self) -> Vec<&'static str> {
+                        let mut names = vec![];
+                        $(
+                            if self.[<$feature_property_name>] {
+                                names.push(stringify!($feature_property_name));
+                            }
+                        )*
+                        names
+                    }
+                }
+
+                #[derive(Debug, Clone, Copy, Sbor, PartialEq, Eq, Hash)]
+                pub enum [<$blueprint_ident Feature>] {
+                    $($feature_ident,)*
+                }
+
+                impl BlueprintFeature for [<$blueprint_ident Feature>] {
+                    fn feature_name(&self) -> &'static str {
+                        match *self {
+                            $(
+                                Self::$feature_ident => stringify!(Self::$feature_property_name),
+                            )*
+                        }
+                    }
+                }
+
                 //---------------------------------
                 // Typed Substate - Keys and Values
                 //---------------------------------
@@ -347,7 +579,7 @@ macro_rules! declare_native_blueprint_state {
                             // TODO(David) - Implement instance schema
                             fields.push(FieldSchema {
                                 field: TypeRef::Static(
-                                    type_aggregator.add_child_type_and_descendents::<[<Versioned $blueprint_ident $field_ident Field>]>()
+                                    type_aggregator.add_child_type_and_descendents::<[<$blueprint_ident $field_ident FieldContent>]>()
                                 ),
                                 condition: $field_condition,
                             });
@@ -359,9 +591,9 @@ macro_rules! declare_native_blueprint_state {
                                 $collection_type,
                                 type_aggregator,
                                 $collection_key_type,
-                                [<$blueprint_ident $collection_ident Key>],
+                                [<$blueprint_ident $collection_ident KeyContent>],
                                 $collection_value_type,
-                                [<$blueprint_ident $collection_ident ValueContent>],
+                                [<$blueprint_ident $collection_ident EntryContent>],
                                 $collection_can_own
                             ));
                         )*
@@ -383,6 +615,7 @@ macro_rules! declare_native_blueprint_state {
                 /// * Instance schemas
                 /// * Feature-dependent fields
                 /// * IndexEntries (because the underlying new_object API doesn't support them)
+                #[derive(Debug, Default)]
                 pub struct [<$blueprint_ident StateInit>] {
                     $(
                         pub $field_property_name: Option<[<$blueprint_ident $field_ident FieldSubstate>]>,
@@ -395,27 +628,35 @@ macro_rules! declare_native_blueprint_state {
                     )*
                 }
 
+                type [<$blueprint_ident FeatureChecks>] = [<$(ignore_arg!($outer_blueprint_ident) InnerObject)? FeatureChecks>]::<
+                    [<$blueprint_ident FeatureSet>],
+                    $([<$outer_blueprint_ident FeatureSet>],)?
+                >;
+
                 impl [<$blueprint_ident StateInit>] {
-                    pub fn into_system_substates(self) -> (Vec<FieldValue>, BTreeMap<u8, BTreeMap<Vec<u8>, KVEntry>>) {
-                        let mut field_values = vec![];
+                    pub fn into_system_substates(self, feature_checks: [<$blueprint_ident FeatureChecks>]) -> Result<(BTreeMap<u8, FieldValue>, BTreeMap<u8, BTreeMap<Vec<u8>, KVEntry>>), RuntimeError> {
+                        let mut field_values = BTreeMap::new();
                         $(
                             {
-                                let field = self.$field_property_name.expect(
-                                    concat!(
-                                        "The field `",
-                                        stringify!($field_property_name),
-                                        "` was None. Until the system and macro supports feature-based optional fields, all fields need to be present"
-                                    )
-                                );
-                                let field_content = scrypto_encode(&field.value).unwrap();
-                                let locked = match &field.mutability {
-                                    SubstateMutability::Mutable => true,
-                                    SubstateMutability::Immutable => false,
-                                };
-                                field_values.push(FieldValue {
-                                    value: field_content,
-                                    locked,
-                                });
+                                feature_checks.assert_valid(
+                                    stringify!($field_ident),
+                                    &$field_condition,
+                                    self.$field_property_name.is_some(),
+                                )?;
+                                if let Some(field) = self.$field_property_name {
+                                    let field_content = scrypto_encode(&field.value).unwrap();
+                                    let locked = match &field.mutability {
+                                        SubstateMutability::Mutable => true,
+                                        SubstateMutability::Immutable => false,
+                                    };
+                                    field_values.insert(
+                                        [<$blueprint_ident Field>]::$field_ident.into(),
+                                        FieldValue {
+                                            value: field_content,
+                                            locked,
+                                        }
+                                    );
+                                }
                             }
                         )*
                         let mut all_collection_entries = BTreeMap::new();
@@ -434,30 +675,45 @@ macro_rules! declare_native_blueprint_state {
                                 collection_index += 1;
                             }
                         )*
-                        (field_values, all_collection_entries)
+                        Ok((field_values, all_collection_entries))
+                    }
+
+                    // TODO: Remove this when the new object api supports non-vec field values
+                    pub fn into_system_substates_legacy(self, feature_checks: [<$blueprint_ident FeatureChecks>]) -> Result<(Vec<FieldValue>, BTreeMap<u8, BTreeMap<Vec<u8>, KVEntry>>), RuntimeError> {
+                        let (mut field_values, collection_entries) = self.into_system_substates(feature_checks)?;
+                        let mut field_values_vec = vec![];
+                        let mut field_index = 0;
+                        $(
+                            {
+                                let field_value = field_values.remove(&field_index).expect(
+                                    concat!(
+                                        "The field `",
+                                        stringify!($field_property_name),
+                                        "` was None. Until the system and macro supports feature-based optional fields, all fields need to be present"
+                                    )
+                                );
+                                field_values_vec.push(field_value);
+                                field_index += 1;
+                            }
+                        )*
+                        Ok((field_values_vec, collection_entries))
                     }
 
                     /// This is used mostly for flashing
-                    pub fn into_kernel_main_partitions(self) -> NodeSubstates {
+                    pub fn into_kernel_main_partitions(self, feature_checks: [<$blueprint_ident FeatureChecks>]) -> Result<NodeSubstates, RuntimeError> {
                         // PartitionNumber => SubstateKey => IndexedScryptoValue
                         let mut partitions: NodeSubstates = BTreeMap::new();
-                        let (field_values, mut kv_entries) = self.into_system_substates();
+                        let (mut field_values, mut kv_entries) = self.into_system_substates(feature_checks)?;
 
                         // Fields
                         {
-                            let mut field_index = 0u8;
                             let mut field_partition_substates = BTreeMap::new();
-                            $({
-                                let key = SubstateKey::from([<$blueprint_ident Field>]::$field_ident);
-                                let expected_field_index = u8::from([<$blueprint_ident Field>]::$field_ident);
-                                // Double-check they agree
-                                assert_eq!(field_index, expected_field_index);
+                            for (field_index, field_value) in field_values {
                                 field_partition_substates.insert(
-                                    key,
-                                    IndexedScryptoValue::from_typed(&field_values[field_index as usize]),
+                                    SubstateKey::Field(field_index),
+                                    IndexedScryptoValue::from_typed(&field_value),
                                 );
-                                field_index += 1;
-                            })*
+                            }
                             partitions.insert(
                                 [<$blueprint_ident Partition>]::Field.as_main_partition(),
                                 field_partition_substates,
@@ -465,8 +721,8 @@ macro_rules! declare_native_blueprint_state {
                         }
 
                         // Each Collection
+                        let mut collection_index = 0u8;
                         $({
-                            let mut collection_index = 0u8;
                             let collection_kv_entries = kv_entries.remove(&collection_index).unwrap();
                             let collection_partition = [<$blueprint_ident Partition>]::[<$collection_ident $collection_type>];
                             let collection_partition_substates = collection_kv_entries
@@ -501,19 +757,31 @@ macro_rules! declare_native_blueprint_state {
                                 collection_partition.as_main_partition(),
                                 collection_partition_substates,
                             );
+                            collection_index += 1;
                         })*
 
-                        partitions
+                        Ok(partitions)
                     }
 
-                    pub fn into_new_object<E, Y: ClientObjectApi<E>>(self, api: &mut Y) -> Result<NodeId, E> {
-                        let (field_values, all_collection_entries) = self.into_system_substates();
+                    pub fn into_new_object<Y: ClientObjectApi<RuntimeError>>(
+                        self,
+                        api: &mut Y,
+                        own_features: [<$blueprint_ident FeatureSet>],
+                        $(outer_object_features: [<$outer_blueprint_ident FeatureSet>],)?
+                        instance_schema: Option<InstanceSchemaInit>,
+                    ) -> Result<NodeId, RuntimeError> {
+                        let (field_values, all_collection_entries) = self.into_system_substates_legacy(
+                            [<$blueprint_ident FeatureChecks>]::ForFeatures {
+                                own_features,
+                                $(ignore_arg!($outer_blueprint_ident) outer_object_features,)?
+                            }
+                        )?;
                         api.new_object(
                             stringify!($blueprint_ident),
-                            vec![], // Features
-                            None, // Instance schema
-                            field_values,
-                            all_collection_entries,
+                            own_features.feature_names_str(),
+                            instance_schema,
+                            field_values, // TODO: Change to take the IndexMap and get rid of into_system_substates_legacy
+                            all_collection_entries, // TODO: Change to take other collections, not just KVEntry
                         )
                     }
                 }
@@ -549,7 +817,14 @@ pub(crate) use declare_native_blueprint_state;
 
 pub(crate) use helper_macros::*;
 
+#[allow(unused_macros)]
 mod helper_macros {
+    macro_rules! ignore_arg {
+        ($($ignored:tt)*) => {};
+    }
+    #[allow(unused)]
+    pub(crate) use ignore_arg;
+
     macro_rules! generate_content_type {
         (
             content_trait: $content_trait:ident,
@@ -769,23 +1044,24 @@ mod tests {
 
     // Check that the below compiles
     #[derive(Debug, PartialEq, Eq, Sbor)]
-    pub struct TestBlueprintRoyaltyFieldV1;
+    pub struct TestBlueprintRoyaltyV1;
 
     #[derive(Debug, PartialEq, Eq, Sbor)]
-    pub struct TestBlueprintMyCoolKeyValueStoreValueV1;
+    pub struct TestBlueprintMyCoolKeyValueStoreV1;
 
     #[derive(Debug, PartialEq, Eq, Sbor)]
-    pub struct TestBlueprintMyCoolIndexValueV1;
+    pub struct TestBlueprintMyCoolIndexV1;
 
     #[derive(Debug, PartialEq, Eq, Sbor)]
-    pub struct TestBlueprintMyCoolSortedIndexValueV1;
+    pub struct TestBlueprintMyCoolSortedIndexV1;
 
     use radix_engine_interface::blueprints::package::*;
 
     declare_native_blueprint_state! {
         blueprint_ident: TestBlueprint,
         blueprint_snake_case: package,
-        instance_schema_types: [],
+        features: {},
+        instance_schema_types: {},
         fields: {
             royalty:  {
                 ident: Royalty,
diff --git a/radix-engine/src/blueprints/package/package.rs b/radix-engine/src/blueprints/package/package.rs
index 6ad8765ffd2..d479145c2f6 100644
--- a/radix-engine/src/blueprints/package/package.rs
+++ b/radix-engine/src/blueprints/package/package.rs
@@ -470,40 +470,21 @@ impl SecurifiedRoleAssignment for SecurifiedPackage {
 }
 
 pub fn create_bootstrap_package_partitions(
-    mut package_state_init: PackageStateInit,
+    package_state_init: PackageStateInit,
     metadata: MetadataInit,
 ) -> NodeSubstates {
+    // No features necessary
+    let own_features = PackageFeatureSet {
+        package_royalty: false,
+    };
+
     //-----------------
     // MAIN PARTITIONS:
     //-----------------
 
-    // TODO:
-    // - Improve the System ObjectAPI to take field indices (and so support optional) fields
-    // - Improve the declare_native_blueprint_state! macro to support features
-    //   and so optional field substates, if/when that feature is disabled
-    {
-        // Native packages disable the package royalty feature
-        // Due to (current) restrictions on the into_kernel_main_partitions() method, we need to
-        // temporarily add in a faked royalty substate - to be removed a few lines later
-        package_state_init.royalty = Some(
-            PackageRoyaltyAccumulatorField {
-                royalty_vault: Vault(Own(NodeId([0; NodeId::LENGTH]))),
-            }
-            .into_locked_substate(),
-        );
-    }
-
-    let mut partitions = package_state_init.into_kernel_main_partitions();
-
-    {
-        // Remove the Royalty field because that feature is turned off
-        let field_partition = partitions
-            .get_mut(&PackagePartition::Field.as_main_partition())
-            .unwrap();
-        field_partition
-            .remove_entry(&PackageField::RoyaltyAccumulator.into())
-            .unwrap();
-    }
+    let mut partitions = package_state_init
+        .into_kernel_main_partitions(own_features.into())
+        .expect("Expected that correct substates are present for given features");
 
     //-------------------
     // MODULE PARTITIONS:
@@ -546,7 +527,7 @@ pub fn create_bootstrap_package_partitions(
                 blueprint_info: BlueprintInfo {
                     blueprint_id: BlueprintId::new(&PACKAGE_PACKAGE, PACKAGE_BLUEPRINT),
                     outer_obj_info: OuterObjectInfo::default(),
-                    features: btreeset!(),
+                    features: own_features.feature_names_string_set(),
                     instance_schema: None,
                 },
             })),
@@ -567,19 +548,17 @@ where
     Y: ClientApi<RuntimeError>,
 {
     package_state_init.royalty = Some(
-        PackageRoyaltyAccumulatorField {
+        PackageRoyaltyAccumulator {
             royalty_vault: Vault(ResourceManager(XRD).new_empty_vault(api)?),
         }
         .into_locked_substate(),
     );
-    let (fields, kv_entries) = package_state_init.into_system_substates();
-
-    let package_object = api.new_object(
-        PACKAGE_BLUEPRINT,
-        vec![PACKAGE_ROYALTY_FEATURE],
+    let package_object = package_state_init.into_new_object(
+        api,
+        PackageFeatureSet {
+            package_royalty: true,
+        },
         None,
-        fields,
-        kv_entries,
     )?;
 
     let address = api.globalize(
@@ -788,35 +767,49 @@ impl PackageNativePackage {
             VmPackageValidation::validate(&definition, vm_type, &original_code)?;
 
         // Build Package structure
-        let mut definitions = BTreeMap::new();
-        let mut dependencies = BTreeMap::new();
-        let mut schemas = BTreeMap::new();
-        let mut package_royalties = BTreeMap::new();
-        let mut auth_configs = BTreeMap::new();
-        let mut vm_type_substates = BTreeMap::new();
-        let mut original_code_substates = BTreeMap::new();
-        let mut instrumented_code_substates = BTreeMap::new();
+        let mut blueprint_version_definitions = IndexMap::default();
+        let mut blueprint_version_dependencies = IndexMap::default();
+        let mut schemas = IndexMap::default();
+        let mut blueprint_version_royalty_configs = IndexMap::default();
+        let mut blueprint_version_auth_configs = IndexMap::default();
+        let mut vm_type_substates = IndexMap::default();
+        let mut original_code_substates = IndexMap::default();
+        let mut instrumented_code_substates = IndexMap::default();
 
         let code_hash = CodeHash::from(hash(&original_code));
-        vm_type_substates.insert(code_hash, PackageCodeVmTypeValue { vm_type });
+        vm_type_substates.insert(
+            code_hash.into_key(),
+            PackageCodeVmType { vm_type }.into_locked_substate(),
+        );
         original_code_substates.insert(
-            code_hash,
-            PackageCodeOriginalCodeValue {
+            code_hash.into_key(),
+            PackageCodeOriginalCode {
                 code: original_code,
-            },
+            }
+            .into_locked_substate(),
         );
-        if let Some(code) = instrumented_code {
-            instrumented_code_substates
-                .insert(code_hash, PackageCodeInstrumentedCodeValue { code });
+        if let Some(instrumented_code) = instrumented_code {
+            instrumented_code_substates.insert(
+                code_hash.into_key(),
+                PackageCodeInstrumentedCode { instrumented_code }.into_locked_substate(),
+            );
         };
 
         {
-            for (blueprint, definition_init) in definition.blueprints {
-                auth_configs.insert(blueprint.clone(), definition_init.auth_config);
+            for (blueprint_name, definition_init) in definition.blueprints {
+                let blueprint_version_key = BlueprintVersionKey::new_default(blueprint_name);
+
+                blueprint_version_auth_configs.insert(
+                    blueprint_version_key.clone().into_key(),
+                    definition_init.auth_config.into_locked_substate(),
+                );
 
                 let blueprint_schema = definition_init.schema.schema.clone();
                 let schema_hash = blueprint_schema.generate_schema_hash();
-                schemas.insert(schema_hash, blueprint_schema);
+                schemas.insert(
+                    schema_hash.into_key(),
+                    blueprint_schema.into_locked_substate(),
+                );
 
                 let mut functions = BTreeMap::new();
                 let mut function_exports = BTreeMap::new();
@@ -899,86 +892,37 @@ impl PackageNativePackage {
                             .collect()
                     },
                 };
-                definitions.insert(blueprint.clone(), definition);
-
-                let minor_version_config = BlueprintDependencies {
-                    dependencies: definition_init.dependencies,
-                };
-                dependencies.insert(blueprint.clone(), minor_version_config);
+                blueprint_version_definitions.insert(
+                    blueprint_version_key.clone().into_key(),
+                    definition.into_locked_substate(),
+                );
+
+                blueprint_version_dependencies.insert(
+                    blueprint_version_key.clone().into_key(),
+                    BlueprintDependencies {
+                        dependencies: definition_init.dependencies,
+                    }
+                    .into_locked_substate(),
+                );
 
-                package_royalties.insert(blueprint.clone(), definition_init.royalty_config);
+                blueprint_version_royalty_configs.insert(
+                    blueprint_version_key.into_key(),
+                    definition_init.royalty_config.into_locked_substate(),
+                );
             }
         };
 
-        let package_state_init = PackageStateInit {
-            royalty: None, // This is added later, for globalized packages,
-            blueprint_version_definitions: definitions
-                .into_iter()
-                .map(|(blueprint_name, blueprint_definition)| {
-                    (
-                        BlueprintVersionKey::new_default(blueprint_name).into_key(),
-                        blueprint_definition.into_locked_substate(),
-                    )
-                })
-                .collect(),
-            blueprint_version_dependencies: dependencies
-                .into_iter()
-                .map(|(blueprint_name, blueprint_dependencies)| {
-                    (
-                        BlueprintVersionKey::new_default(blueprint_name).into_key(),
-                        blueprint_dependencies.into_locked_substate(),
-                    )
-                })
-                .collect(),
-            schemas: schemas
-                .into_iter()
-                .map(|(schema_hash, schema)| {
-                    (
-                        SchemaHash::from(schema_hash).into_key(),
-                        schema.into_locked_substate(),
-                    )
-                })
-                .collect(),
-            blueprint_version_royalty_configs: package_royalties
-                .into_iter()
-                .map(|(blueprint_name, royalty_config)| {
-                    (
-                        BlueprintVersionKey::new_default(blueprint_name).into_key(),
-                        royalty_config.into_locked_substate(),
-                    )
-                })
-                .collect(),
-            blueprint_version_auth_configs: auth_configs
-                .into_iter()
-                .map(|(blueprint_name, auth_config)| {
-                    (
-                        BlueprintVersionKey::new_default(blueprint_name).into_key(),
-                        auth_config.into_locked_substate(),
-                    )
-                })
-                .collect(),
-            code_vm_type: vm_type_substates
-                .into_iter()
-                .map(|(code_hash, vm_type)| (code_hash.into_key(), vm_type.into_locked_substate()))
-                .collect(),
-            code_original_code: original_code_substates
-                .into_iter()
-                .map(|(code_hash, original_code)| {
-                    (code_hash.into_key(), original_code.into_locked_substate())
-                })
-                .collect(),
-            code_instrumented_code: instrumented_code_substates
-                .into_iter()
-                .map(|(code_hash, instrumented_code)| {
-                    (
-                        code_hash.into_key(),
-                        instrumented_code.into_locked_substate(),
-                    )
-                })
-                .collect(),
-        };
-
-        Ok(package_state_init)
+        Ok(PackageStateInit {
+            royalty: None, // This is added later, if the feature is turned on
+            blueprint_version_definitions,
+            blueprint_version_dependencies,
+            schemas,
+            blueprint_version_royalty_configs,
+            blueprint_version_auth_configs,
+            code_vm_type: vm_type_substates,
+            code_original_code: original_code_substates,
+            code_instrumented_code: instrumented_code_substates,
+        })
     }
 
     pub(crate) fn publish_native<Y>(
@@ -1170,7 +1114,7 @@ impl PackageRoyaltyNativeBlueprint {
             LockFlags::read_only(),
         )?;
 
-        let mut substate: PackageRoyaltyAccumulatorFieldContent = api.field_read_typed(handle)?;
+        let substate: PackageRoyaltyAccumulatorFieldContent = api.field_read_typed(handle)?;
         let bucket = substate.0.into_latest().royalty_vault.take_all(api)?;
 
         Ok(bucket)
diff --git a/radix-engine/src/blueprints/package/substates.rs b/radix-engine/src/blueprints/package/substates.rs
index bcf9b4aacb8..c92f10db24f 100644
--- a/radix-engine/src/blueprints/package/substates.rs
+++ b/radix-engine/src/blueprints/package/substates.rs
@@ -5,14 +5,20 @@ use crate::types::*;
 declare_native_blueprint_state! {
     blueprint_ident: Package,
     blueprint_snake_case: package,
-    instance_schema_types: [],
+    features: {
+        package_royalty: {
+            ident: PackageRoyalty,
+            description: "Enables the package royalty substate",
+        }
+    },
+    instance_schema_types: {},
     fields: {
         royalty:  {
             ident: RoyaltyAccumulator,
             field_type: {
                 kind: StaticSingleVersioned,
             },
-            condition: Condition::Always,
+            condition: Condition::if_feature(PackageFeature::PackageRoyalty),
         }
     },
     collections: {
@@ -112,7 +118,7 @@ declare_native_blueprint_state! {
 //-------------
 
 #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
-pub struct PackageRoyaltyAccumulatorFieldV1 {
+pub struct PackageRoyaltyAccumulatorV1 {
     /// The vault for collecting package royalties.
     pub royalty_vault: Vault,
 }
@@ -123,16 +129,16 @@ pub struct PackageRoyaltyAccumulatorFieldV1 {
 
 // TODO(David): Change to VersionedSchema when can define a type as not-implicitly-versioned
 // TODO: Move to Schema partition when we have it
-pub type PackageSchemaValueV1 = ScryptoSchema;
+pub type PackageSchemaV1 = ScryptoSchema;
 
 //---------------------------------------
 // Collection models - By BlueprintVersion
 //---------------------------------------
 
-pub type PackageBlueprintVersionDefinitionValueV1 = BlueprintDefinition;
-pub type PackageBlueprintVersionDependenciesValueV1 = BlueprintDependencies;
-pub type PackageBlueprintVersionRoyaltyConfigValueV1 = PackageRoyaltyConfig;
-pub type PackageBlueprintVersionAuthConfigValueV1 = AuthConfig;
+pub type PackageBlueprintVersionDefinitionV1 = BlueprintDefinition;
+pub type PackageBlueprintVersionDependenciesV1 = BlueprintDependencies;
+pub type PackageBlueprintVersionRoyaltyConfigV1 = PackageRoyaltyConfig;
+pub type PackageBlueprintVersionAuthConfigV1 = AuthConfig;
 
 //---------------------------------------
 // Collection models - By Code
@@ -140,17 +146,17 @@ pub type PackageBlueprintVersionAuthConfigValueV1 = AuthConfig;
 
 #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
 #[sbor(transparent)]
-pub struct PackageCodeVmTypeValueV1 {
+pub struct PackageCodeVmTypeV1 {
     pub vm_type: VmType,
 }
 
 #[derive(PartialEq, Eq, ScryptoSbor)]
 #[sbor(transparent)]
-pub struct PackageCodeOriginalCodeValueV1 {
+pub struct PackageCodeOriginalCodeV1 {
     pub code: Vec<u8>,
 }
 
-impl Debug for PackageCodeOriginalCodeValueV1 {
+impl Debug for PackageCodeOriginalCodeV1 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("PackageCodeOriginalCodeValueV1")
             .field("len", &self.code.len())
@@ -160,14 +166,14 @@ impl Debug for PackageCodeOriginalCodeValueV1 {
 
 #[derive(PartialEq, Eq, ScryptoSbor)]
 #[sbor(transparent)]
-pub struct PackageCodeInstrumentedCodeValueV1 {
-    pub code: Vec<u8>,
+pub struct PackageCodeInstrumentedCodeV1 {
+    pub instrumented_code: Vec<u8>,
 }
 
-impl Debug for PackageCodeInstrumentedCodeValueV1 {
+impl Debug for PackageCodeInstrumentedCodeV1 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("PackageCodeInstrumentedCodeValueV1")
-            .field("len", &self.code.len())
+            .field("len", &self.instrumented_code.len())
             .finish()
     }
 }
diff --git a/radix-engine/src/errors.rs b/radix-engine/src/errors.rs
index f56534c285d..1326aa3ebe3 100644
--- a/radix-engine/src/errors.rs
+++ b/radix-engine/src/errors.rs
@@ -254,6 +254,7 @@ pub enum SystemError {
     TransactionRuntimeModuleNotEnabled,
     PayloadValidationAgainstSchemaError(PayloadValidationAgainstSchemaError),
     EventError(EventError),
+    InvalidNativeSubstatesForFeature(String),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, ScryptoSbor)]
diff --git a/radix-engine/src/track/interface.rs b/radix-engine/src/track/interface.rs
index dd2b95e89f1..6e3f5ed0118 100644
--- a/radix-engine/src/track/interface.rs
+++ b/radix-engine/src/track/interface.rs
@@ -29,6 +29,38 @@ impl<E, C> CallbackError<E, C> {
 
 pub type NodeSubstates = BTreeMap<PartitionNumber, BTreeMap<SubstateKey, IndexedScryptoValue>>;
 
+pub use database_update_conversion::*;
+
+mod database_update_conversion {
+    // This is for resim, but it makes sense to put it here alongside NodeSubstates
+    use super::*;
+    use radix_engine_store_interface::db_key_mapper::*;
+    use radix_engine_store_interface::interface::*;
+
+    pub trait IntoDatabaseUpdates {
+        fn into_database_updates<M: DatabaseKeyMapper>(self, node_id: &NodeId) -> DatabaseUpdates;
+    }
+
+    impl IntoDatabaseUpdates for NodeSubstates {
+        fn into_database_updates<M: DatabaseKeyMapper>(self, node_id: &NodeId) -> DatabaseUpdates {
+            self.into_iter()
+                .map(|(partition_number, substates)| {
+                    let db_partition_key = M::to_db_partition_key(node_id, partition_number);
+                    let partition_updates = substates
+                        .into_iter()
+                        .map(|(substate_key, value)| {
+                            let db_sort_key = M::to_db_sort_key(&substate_key);
+                            let update = DatabaseUpdate::Set(value.as_vec_ref().clone());
+                            (db_sort_key, update)
+                        })
+                        .collect();
+                    (db_partition_key, partition_updates)
+                })
+                .collect()
+        }
+    }
+}
+
 pub enum TrackedSubstateInfo {
     New,
     Updated,
diff --git a/radix-engine/src/track/mod.rs b/radix-engine/src/track/mod.rs
index 23f761ceb61..439640a1a6d 100644
--- a/radix-engine/src/track/mod.rs
+++ b/radix-engine/src/track/mod.rs
@@ -5,4 +5,5 @@ pub mod utils;
 #[cfg(test)]
 mod test;
 
+pub use interface::*;
 pub use track::*;
diff --git a/radix-engine/src/vm/vm.rs b/radix-engine/src/vm/vm.rs
index da707ef91ba..bffff2533ac 100644
--- a/radix-engine/src/vm/vm.rs
+++ b/radix-engine/src/vm/vm.rs
@@ -137,11 +137,15 @@ impl<'g, W: WasmEngine + 'g, E: NativeVmExtension> SystemCallbackObject for Vm<'
                     api.kernel_get_system()
                         .callback_obj
                         .scrypto_vm
-                        .create_instance(address, export.code_hash, &instrumented_code.code)
+                        .create_instance(
+                            address,
+                            export.code_hash,
+                            &instrumented_code.instrumented_code,
+                        )
                 };
 
                 api.consume_cost_units(ClientCostingEntry::PrepareWasmCode {
-                    size: instrumented_code.code.len(),
+                    size: instrumented_code.instrumented_code.len(),
                 })?;
 
                 let output =
diff --git a/scrypto-schema/src/lib.rs b/scrypto-schema/src/lib.rs
index 9f5f3255c57..26e6c8c4cf1 100644
--- a/scrypto-schema/src/lib.rs
+++ b/scrypto-schema/src/lib.rs
@@ -183,6 +183,10 @@ impl<T> BlueprintCollectionSchema<T> {
     }
 }
 
+pub trait BlueprintFeature {
+    fn feature_name(&self) -> &'static str;
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Sbor)]
 pub enum Condition {
     Always,
@@ -190,6 +194,16 @@ pub enum Condition {
     IfOuterFeature(String),
 }
 
+impl Condition {
+    pub fn if_feature(feature: impl BlueprintFeature) -> Self {
+        Self::IfFeature(feature.feature_name().into())
+    }
+
+    pub fn if_outer_feature(feature: impl BlueprintFeature) -> Self {
+        Self::IfOuterFeature(feature.feature_name().into())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, ScryptoSbor, ManifestSbor)]
 pub struct FieldSchema<V> {
     pub field: V,
diff --git a/simulator/src/ledger/dumper.rs b/simulator/src/ledger/dumper.rs
index 1a1e18e5a65..734eb13f42e 100644
--- a/simulator/src/ledger/dumper.rs
+++ b/simulator/src/ledger/dumper.rs
@@ -3,7 +3,7 @@ use crate::utils::*;
 use colored::*;
 use radix_engine::blueprints::resource::*;
 use radix_engine::system::node_modules::type_info::TypeInfoSubstate;
-use radix_engine::system::system::{FieldSubstate, KeyValueEntrySubstate};
+use radix_engine::system::system::FieldSubstate;
 use radix_engine::types::*;
 use radix_engine_interface::blueprints::package::*;
 use radix_engine_interface::network::NetworkDefinition;
diff --git a/simulator/src/resim/cmd_publish.rs b/simulator/src/resim/cmd_publish.rs
index 6240ee35bad..ea861a55a88 100644
--- a/simulator/src/resim/cmd_publish.rs
+++ b/simulator/src/resim/cmd_publish.rs
@@ -1,15 +1,15 @@
 use clap::Parser;
 use colored::*;
+use radix_engine::blueprints::macros::*;
+use radix_engine::track::IntoDatabaseUpdates;
 use radix_engine::types::*;
 use radix_engine_interface::blueprints::package::{
     BlueprintDefinition, BlueprintDependencies, FunctionSchema, IndexedStateSchema, PackageExport,
     TypePointer, VmType, *,
 };
 use radix_engine_interface::schema::TypeRef;
-use radix_engine_store_interface::{
-    db_key_mapper::{DatabaseKeyMapper, SpreadPrefixKeyMapper},
-    interface::{CommittableSubstateDatabase, DatabaseUpdate},
-};
+use radix_engine_queries::typed_substate_layout::*;
+use radix_engine_store_interface::interface::CommittableSubstateDatabase;
 use std::ffi::OsStr;
 use std::fs;
 use std::path::PathBuf;
@@ -72,91 +72,51 @@ impl Publish {
 
             let node_id: NodeId = package_address.0.into();
 
-            let blueprints_partition_key = SpreadPrefixKeyMapper::to_db_partition_key(
-                &node_id,
-                MAIN_BASE_PARTITION
-                    .at_offset(PACKAGE_BLUEPRINTS_PARTITION_OFFSET)
-                    .unwrap(),
-            );
-            let schemas_partition_key = SpreadPrefixKeyMapper::to_db_partition_key(
-                &node_id,
-                MAIN_BASE_PARTITION
-                    .at_offset(PACKAGE_SCHEMAS_PARTITION_OFFSET)
-                    .unwrap(),
-            );
-            let dependencies_partition_key = SpreadPrefixKeyMapper::to_db_partition_key(
-                &node_id,
-                MAIN_BASE_PARTITION
-                    .at_offset(PACKAGE_BLUEPRINT_DEPENDENCIES_PARTITION_OFFSET)
-                    .unwrap(),
-            );
-            let vm_type_partition_key = SpreadPrefixKeyMapper::to_db_partition_key(
-                &node_id,
-                MAIN_BASE_PARTITION
-                    .at_offset(PACKAGE_VM_TYPE_PARTITION_OFFSET)
-                    .unwrap(),
-            );
-            let original_code_partition_key = SpreadPrefixKeyMapper::to_db_partition_key(
-                &node_id,
-                MAIN_BASE_PARTITION
-                    .at_offset(PACKAGE_ORIGINAL_CODE_PARTITION_OFFSET)
-                    .unwrap(),
-            );
-            let instrumented_code_partition_key = SpreadPrefixKeyMapper::to_db_partition_key(
-                &node_id,
-                MAIN_BASE_PARTITION
-                    .at_offset(PACKAGE_INSTRUMENTED_CODE_PARTITION_OFFSET)
-                    .unwrap(),
-            );
-            let mut blueprint_updates = index_map_new();
-            let mut dependency_updates = index_map_new();
-            let mut schema_updates = index_map_new();
-            let mut vm_type_updates = index_map_new();
-            let mut original_code_updates = index_map_new();
-            let mut instrumented_code_updates = index_map_new();
-
-            let code_hash = hash(&code);
+            let code_hash = CodeHash::from(hash(&code));
             let instrumented_code = WasmValidator::default()
                 .validate(&code, package_definition.blueprints.values())
                 .map_err(Error::InvalidPackage)?
                 .0;
-            let vm_type = PackageVmTypeSubstate {
-                vm_type: VmType::ScryptoV1,
-            };
-            let original_code = PackageOriginalCodeSubstate { code };
-            let instrumented_code = PackageOriginalCodeSubstate {
-                code: instrumented_code,
-            };
-            {
-                let key =
-                    SpreadPrefixKeyMapper::map_to_db_sort_key(&scrypto_encode(&code_hash).unwrap());
-                let update = DatabaseUpdate::Set(scrypto_encode(&vm_type).unwrap());
-                vm_type_updates.insert(key, update);
 
-                let key =
-                    SpreadPrefixKeyMapper::map_to_db_sort_key(&scrypto_encode(&code_hash).unwrap());
-                let update = DatabaseUpdate::Set(scrypto_encode(&original_code).unwrap());
-                original_code_updates.insert(key, update);
-
-                let key =
-                    SpreadPrefixKeyMapper::map_to_db_sort_key(&scrypto_encode(&code_hash).unwrap());
-                let update = DatabaseUpdate::Set(scrypto_encode(&instrumented_code).unwrap());
-                instrumented_code_updates.insert(key, update);
-            }
+            let mut package_state_to_set = PackageStateInit {
+                royalty: None, // No change
+                // To be set later in this function
+                blueprint_version_definitions: indexmap!(),
+                blueprint_version_dependencies: indexmap!(),
+                schemas: indexmap!(),
+                blueprint_version_royalty_configs: indexmap!(),
+                blueprint_version_auth_configs: indexmap!(),
+                // Code set now
+                code_vm_type: indexmap! {
+                    code_hash.into_key() => PackageCodeVmType {
+                        vm_type: VmType::ScryptoV1
+                    }.into_locked_substate()
+                },
+                code_original_code: indexmap! {
+                    code_hash.into_key() => PackageCodeOriginalCode {
+                        code
+                    }.into_locked_substate()
+                },
+                code_instrumented_code: indexmap! {
+                    code_hash.into_key() => PackageCodeInstrumentedCode {
+                        instrumented_code
+                    }.into_locked_substate()
+                },
+            };
 
-            for (b, s) in package_definition.blueprints {
+            for (blueprint_name, blueprint_definition) in package_definition.blueprints {
                 let mut functions = BTreeMap::new();
                 let mut function_exports = BTreeMap::new();
 
-                let blueprint_schema = s.schema.clone();
+                let blueprint_version_key = BlueprintVersionKey::new_default(blueprint_name);
+                let blueprint_schema = blueprint_definition.schema.clone();
                 let schema_hash = blueprint_schema.schema.generate_schema_hash();
-                let key = SpreadPrefixKeyMapper::map_to_db_sort_key(
-                    &scrypto_encode(&schema_hash).unwrap(),
+                package_state_to_set.schemas.insert(
+                    schema_hash.into_key(),
+                    blueprint_schema.schema.into_locked_substate(),
                 );
-                let update = DatabaseUpdate::Set(scrypto_encode(&blueprint_schema).unwrap());
-                schema_updates.insert(key, update);
 
-                for (function, setup) in s.schema.functions.functions {
+                for (function, setup) in blueprint_definition.schema.functions.functions {
                     functions.insert(
                         function.clone(),
                         FunctionSchema {
@@ -182,7 +142,7 @@ impl Publish {
                     function_exports.insert(function, export);
                 }
 
-                let events = s
+                let events = blueprint_definition
                     .schema
                     .events
                     .event_schema
@@ -202,40 +162,47 @@ impl Publish {
 
                 let def = BlueprintDefinition {
                     interface: BlueprintInterface {
-                        generics: s.schema.generics,
-                        blueprint_type: s.blueprint_type,
+                        generics: blueprint_definition.schema.generics,
+                        blueprint_type: blueprint_definition.blueprint_type,
                         is_transient: false,
-                        feature_set: s.feature_set,
+                        feature_set: blueprint_definition.feature_set,
                         functions,
                         events,
-                        state: IndexedStateSchema::from_schema(schema_hash, s.schema.state),
+                        state: IndexedStateSchema::from_schema(
+                            schema_hash,
+                            blueprint_definition.schema.state,
+                        ),
                     },
                     function_exports,
                     hook_exports: BTreeMap::new(),
                 };
-                let key = SpreadPrefixKeyMapper::map_to_db_sort_key(&scrypto_encode(&b).unwrap());
-                let update = DatabaseUpdate::Set(scrypto_encode(&def).unwrap());
-                blueprint_updates.insert(key, update);
-
-                let config = BlueprintDependencies {
-                    dependencies: s.dependencies,
-                };
-                let key = SpreadPrefixKeyMapper::map_to_db_sort_key(&scrypto_encode(&b).unwrap());
-                let update = DatabaseUpdate::Set(
-                    scrypto_encode(&KeyValueEntrySubstate::entry(config)).unwrap(),
+                package_state_to_set.blueprint_version_definitions.insert(
+                    blueprint_version_key.clone().into_key(),
+                    def.into_locked_substate(),
+                );
+                package_state_to_set.blueprint_version_dependencies.insert(
+                    blueprint_version_key.clone().into_key(),
+                    BlueprintDependencies {
+                        dependencies: blueprint_definition.dependencies,
+                    }
+                    .into_locked_substate(),
                 );
-                dependency_updates.insert(key, update);
+                package_state_to_set.blueprint_version_auth_configs.insert(
+                    blueprint_version_key.clone().into_key(),
+                    blueprint_definition.auth_config.into_locked_substate(),
+                );
+                package_state_to_set
+                    .blueprint_version_royalty_configs
+                    .insert(
+                        blueprint_version_key.clone().into_key(),
+                        blueprint_definition.royalty_config.into_locked_substate(),
+                    );
             }
 
-            let database_updates = indexmap!(
-                blueprints_partition_key => blueprint_updates,
-                dependencies_partition_key => dependency_updates,
-                schemas_partition_key => schema_updates,
-                vm_type_partition_key => vm_type_updates,
-                original_code_partition_key => original_code_updates,
-                instrumented_code_partition_key => instrumented_code_updates,
-            );
-
+            let database_updates = package_state_to_set
+                .into_kernel_main_partitions(FeatureChecks::None)
+                .unwrap()
+                .into_database_updates::<SpreadPrefixKeyMapper>(&node_id);
             substate_db.commit(&database_updates);
 
             writeln!(out, "Package updated!").map_err(Error::IOError)?;
diff --git a/simulator/src/resim/error.rs b/simulator/src/resim/error.rs
index 88613757008..430e4c88db6 100644
--- a/simulator/src/resim/error.rs
+++ b/simulator/src/resim/error.rs
@@ -3,7 +3,7 @@ use std::path::PathBuf;
 
 use radix_engine::errors::{RejectionError, RuntimeError};
 use radix_engine::transaction::AbortReason;
-use radix_engine::types::{ComponentAddress, Hash, PackageAddress};
+use radix_engine::types::{ComponentAddress, PackageAddress};
 use radix_engine::utils::ExtractSchemaError;
 use radix_engine::vm::wasm::PrepareError;
 use radix_engine_interface::blueprints::resource::ParseNonFungibleGlobalIdError;

From 534681e734be43b49b663f6a7cca65b9af40f000 Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Mon, 14 Aug 2023 04:15:22 +0100
Subject: [PATCH 15/28] fix: Misc fixes

---
 assets/faucet.wasm                            | Bin 241330 -> 241393 bytes
 assets/flash_loan.wasm                        | Bin 313614 -> 313761 bytes
 assets/genesis_helper.wasm                    | Bin 350536 -> 350577 bytes
 assets/metadata.wasm                          | Bin 186661 -> 186758 bytes
 assets/radiswap.wasm                          | Bin 224107 -> 224188 bytes
 .../src/blueprints/package/substates.rs       |  11 ------
 .../tests/kernel_open_substate.rs             |   8 +---
 radix-engine/src/blueprints/macros.rs         |  37 +++++++++++-------
 .../src/blueprints/package/package.rs         |  18 ++++-----
 radix-engine/src/system/system.rs             |  19 +++++----
 radix-engine/src/system/system_callback.rs    |   5 +--
 radix-engine/src/transaction/system_reader.rs |  18 ++++-----
 .../src/transaction/transaction_executor.rs   |  16 ++++----
 radix-engine/src/vm/vm.rs                     |  14 ++-----
 sbor-derive-common/src/utils.rs               |   7 +++-
 scrypto-unit/src/test_runner.rs               |  23 +++++------
 simulator/src/ledger/dumper.rs                |   6 +--
 simulator/src/resim/mod.rs                    |  17 ++++----
 18 files changed, 88 insertions(+), 111 deletions(-)

diff --git a/assets/faucet.wasm b/assets/faucet.wasm
index 75c69c209052dd4e3bc0ea9533b2b342f35d5149..7124b18754e00d698ecdd9cc3b47f0d25ece336b 100644
GIT binary patch
delta 83709
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%0Accu
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
Tb+1$Ei9?U@X=2(6-tGSZ<Ft}y

delta 84225
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%0D@&jm%NJs-<|wX!_~(gwW%`?TScz3
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

diff --git a/assets/flash_loan.wasm b/assets/flash_loan.wasm
index b181ac1db436297d9c3941c37e728e35bb355e4f..f03dba9000cd8984b73646d1321584dd2ffb4bec 100644
GIT binary patch
delta 47088
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
UagXxnPyg|Y;%DW-yTpqB2l+`4F#rGn

delta 47477
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

diff --git a/assets/genesis_helper.wasm b/assets/genesis_helper.wasm
index 7edbe9a44e17dca7b887b6c218a65c05673db01a..af7b39af7e201541ff4b4d556c6cc0bb925a3fdc 100644
GIT binary patch
literal 350577
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

literal 350536
zcmeFa3$$M6S>L%Y-|d|5`_9>tj-(??w)VGmlpMuUtOQ3=Y$wq+zDP|{r_(iUC;`hC
z#rBb6JGNqIS68GYCU?Mq0n=vIGAw4{4loHFrjs(15ljjJ0ys=a0%WGjWwn`UW+pAP
zWICC8e*for_vJem`AB36YZg{=_T}6Ay*|(XxxVj??s@!eaTG=IPsKY=rRUF|k4`1}
z6Z=Vg-fnV;&-16l1N;#A^*c{>b<GVw>h3$^cb<wOe~{CGJ-{E%?PZ>!d_Bbf!)xz6
z)$_-qQ~mIKbZS_=sh4@_o%~I{oNP%?Km5e(!>7OJ?nmxjIep)`XsjDE51f7E-h0kI
z^!HBt_3*xX&Yr#dZKuyY_{jayoSqn+dE)NV51)JN@812u>2uLw`qtyzigYWhpL*={
z+0*wtemY93Cm%oe$YZDPrs62mt!+H%w;p-)^uu0sG^=06R`*-q@$h};9(v?quYLZl
z51l@H|J`RFx$n%~kDb2fes4h5y8AtkJ#_B0H)3n+_Ea;nd+wtVcUy(_Ow_Ro>CxTy
zo_)vZM<09W;d7CV(4s%;!|=%c?>Kw98jY=brTgeT4?lEY6zhEMzDFK@{2gyQefPcZ
zc<WnFKgP|^rk_cZ2&#yqB#HSS2QGRE|HUyk^k2kT%oF;nXZ^pl)9>}-xZCf~^!xoN
z>T$)-am-ErOI6x%I85i`uHDy9ls&UerRYE1wSRuO{$E~B7P=~w6O|e#TyfFW!T(cB
ztxW3xKc?Pp{Z$R!u4+@WXlgIwpLZ;tNs=^)(=?gyMrml(`pxjWY1-+<{k}cP5UI}z
z?TD-aaW75dE+wjV4Hgwf{FJ1O3wKjBVU(sbgTWx`>$y%ZRj2w%8jsY4nY8Qw=^{$Q
z70=ONJz!1jKslXR=x>IGrycuWl+Jd#-R-kn?cj#~>&B19x8L67l`Xwp>G`<4aN%M!
zJRg<cc+aoe@xqfF`;Yf}Z#(_AM;`mTNwnq8(+{71{GrEBoId;L>Bo%x&+eVR_t3)+
zoPPY=-S^*f?w-5vd+;3(pNZbKefo*-dF-A??|#Rl(ZjQM`(vjczCVqJci;WsX@0mD
zHcOM4zaK|sJiP6J8&011;bi}%^q<B5KKZlc2a;b)Ur2Ow|GVOM$3K+p|8o2vlP|^l
z|5@_iC%>HhakBr9l1s_{A4$KFd^!GNvj6FH{|D3eryoe)o4z}JSNgv6$I>59pGkir
zeNVdoAEzHne<A&)^i%0?rTgEL{!aS4>F=e_r=L!LKb`%;&u;ll`k_udIKM9{kFON*
zQk2K#V5Pj!$^JvaX>=r6%;P*hkPeQf88;5E@F!czp5fQ!<XDj`CxfDsbBONfoX?ZI
zlYKMM<)E8)hC1o2lwXK$is<HK!0-C0j8~2%0}9GlCaUG|%A`XBvNJ`G2K35pH%0Rt
z=2x;GO(y-kqdHRk>E;})qBQTSBHiug-Jwo8D|w%K^3?8n9bRg>6eY)#<0`1b{i569
zJntS!I^3k4lv(uO$jvnGlu`B*lzS+Oif-AxV;s}w^gt9JjW}ay@{~WzQFMfwlDtcW
zBlR=yQyLGbr=xUeRTbUa^?Ip?R9_jN;h|A7ET4Ms#i-m<e(kA?QFbwnhUKLn<i@1@
zLUn^$vK1Q(9cX2ID9Q_px`S3SM+egEDD_3<Nb|9{LJy84Q5j7Jqj<>eF1HUvlcQ7|
zo>{IMO|x%`I=sa!ektMMe88(*A3w7c4L{dQW|32j+okAC!N4&lJbxDrI<~?DrseNN
zOq!ERm!G>0xpbXen2$g%U6D&SkV{wOVpG|(5f{01@}6c<ce{DdN39{35x?uFKrUU8
z%M9f~E<K;vSsF0w<T4w`WtjIwDOQn@j*&|z?>80oLq++}C#I=`Qu8xKCy)yT8M*Ws
z^PWwxQBhwtM8!}9)1h-vYAl-R9E!4{Uv}>tb8h$ZB>Snjz7H)i_xVgd6sgQOsX#lb
zrbuq*tr;hk9yH^mB0|bL2cj)UQ&CVyGcD5VQ%dJR8i^=pM3kN7s4t3~F&5YyiFFuH
z8^1te-4=-rG>1lF1Cdy_O=2UF*gz!K4I~zxsYwhz7m3--i^K-`NF>%Z5)*eGyPdI1
z%g;w*r%yzIe8ss3l3R|ZZ{qH<2>a*W4O?8x)$`Fxc0S>q<z(64&GqVydb5aCxELn)
zGnI0%7#~d+DUpMyb|7Mh7v{yEv_GZus|skn7HLeau!sVZNY7u27_E7oZP@JcxgVgt
z*YgPNEx)3RPtk+yld$;z(4eewRl_!^vyD3MD4U9H)E}X&M$4($fy&v&z|YwR@Z+R~
zvXDlbZPe2Vz}Z6C0n<KkwiyJrF`gVaocCLBZfxUl4%--<=RL7a8_At*l2s@xwt?>q
zWtlo>#-b;-Ni<pTme?i{+w`1m{C*y1|0TE??gzF3AH+6bjAjtFQKySoYy(a^BgYNf
zP;Ouw&KkDqa@*NPxJ7@QZ75u&ZVH(bXPW_CFl0tl<V9Q|GjrG=bJ}K`nHrf9Ck---
z(t|hwgvB;C^N!3jPT7XczlA2{$o%yRnaj_@KuNh{<v<i2jl~1doei#T02yidNxLzy
zCv-!@!cWJI9{6+oOtwulcG$V<t2~~Tw@fkQjYrc{+|0$0A9)Wn-RBB!s2DQ$R~Pl>
z!8SuyJY;OWRCJ_4AYrXxtGRK_+v3LXPMaG$fg8VGbK^!$ZkUm_Ix~Ki)*CZ^GF>~C
z;%ZTf=);Dt9?R-RJ(l5y)6&#f?r@CS<Y<0Fqp1mBJDQB$^k~|6c*BmL(TpL&vv){Q
zIX+HvX7)f-N*qMxPQCiM$fi7!{NJJ*pKjfl(T(41-4IXZDRbh`c=^eY$|1T$BDoF%
z)fz%x)tr3l$uK80>6qH}scCU=+tKuJGnI!|%FhT^zfisPSFkD|j5Z0YKlfL#DuuTV
zt3Qt!E$ip`8dMR!Q#i03Ahm)4fKY}&g%be<&^07c1o;^#kbto0p$?5=*m7Y-(p74@
z>p7#N=`nu?J?Fgv2#$fO_9BLZz}X~mP;i6*;UzKXa&k+B0E-AgLx5eb@b6GNZfF1i
zVVjl*nrmz4q`DU0364#A1QjQ=cy)UlMm!cE^-pQJL2A?7sUA+f@r+pa$@evHSi_d4
zq|F}mwdN&EQRDZgtCy|=cZ7ZX8Ds}^h|ni=EBoPeI6S~)+EoD(@<<+^L0x-z>dBEk
z`6rm-n)i>zX9_eIvxg=<4igy}GEFf7(VMVxI}^kvC_0(tkgZIHx;dB(lH*{1T<*UK
zZRj`?o|JzWtt98sNA}B1OY^}UOpGQH*-~_*z9i*yu_mJ?9~qY-tY>))g~t@NEh~ay
zf3(+rv{yem!GIW+zY%3$Nw1;4r8~#G5tU0fMVV}jM5Jg16#YP_Qi!NU5=7mgrPb?Z
z#b&g>LxVfV%Ox5yn51e0#*4K*RohYE+Kn;$L+zH`!z)%Mk8G(5#<FSZR6p{nEi=;%
zh-F6S>V{jl33aMt))NgsqHZ}^n3!HVC`P(kbUnDAkFqbNSk^;vS|TzYX1i&+*t{x7
z<MFW=ZEg5{c&9KUF8?o&nEA4E2BmJ6>3t!7dzqiyt>fI@2-lPUCr8yN?sP}vx$#_Y
z*dNTy&CjdavSW5NmO_;6)n9rZPC6?^l)V>T%`V3F3y*#vxy%`lf1e(&AL7RQsvF2$
ztE~Q!-e10~e-&F<!)uI*jB(W3|Bc(SHvV^p?b$f)$j}nm7pW0?k=zAU#1lD7AlEy_
zjBK9XWu%?BZC>_$j`&4vQ*^U`YXgVJV!NJ)y_lTWsC9WqIxgNIsT>-cTVqr@&SXz=
zZ@zYhJdaPryd$cveD0^X`eh8MFU}?d*Ml#>x|J<u75r)3%&Y)%RPg3<k`;02fu3@n
zOzslGGQDy|Wo1J9h1Yp(?eF8Vk{NHBnL19_#k56V!-BJiN2@}+{AR^kCp9enQ0#zV
z>FQa2v0{7GuncTiK%Zyn0!}xpfCoqNP9;z>q<$nBQL@#Q6<t|PI4)yMIbKuG1zM_W
zko_SH1ngiiMaBieEZAuPAM;c&3%1w|03Zow!AyMvM#aSioF(NEA;)oCagAM(U^^BA
z{2W>R0#-{g!=2i)Nb;Up7CCRD&hmQv7^nG4F`IoxHW(9r3h3!&|CHt;CAoFfih~Zi
z(oqLOD!V{GovAJaAvua|X=c0Zx5U)WuKW@Se_Td^03xVFLnJgm6kWhJj2W}*Ww(4d
zHp3*5kA#~Ck|*P0cr@AvUa1(}?&RE%k42Pe24*=Dsrn5L02nSq^X|pvpV39RE}x03
zKEx&ZZ-Kxlf5`7K(6L6o=*gL4Mnx>WoM+4kQ&TjID&_;NSA4ANH;#G%SZ$&0(Yu(b
zoR@a0C>wPvD$|2Dh*mSyiXWybMlQo#;4dnZw+Y<VJ#!&-%%~R8nE{R8tz-(S`4FU2
zjZcnTQ1bhzH7$Gj>8Ap(R-Vi!s~fcQSxt#KMaAJ$BkIiG5%UKNe1w|;c53)ta`6-<
zj@dMb^|bs(ZMm4rA|@~Yjo+h#<~mBt|Fv~P8eJHO6r!WwKAJL2qkA-%1{Rbput-jh
znMHsCmZLZ)KLE;%q)7c&A)$z1T^%-ckZFiCa%zH)*9h;7y*UMWDjip_s7!=5-QA55
zvKJiO!b<n4ySet;X0(6J>?U+YT45IV{i5)1r+PEk)HbJZ$6h(Ij91nH+~p`ao|v38
zSvZ$QX`H&WQH_#1Lxjz6_)$VoEqQ8B%NKG+(h~5`n8@tp?zyaznj8}%GQc==(K#v6
z0AFQ$hn3)}MOY!7&UCo!|A=*rG#%WN_7<Kl5<LYHho2@92o_~u;CUh3L<}Z?9Y+Y}
z1SvXv2<ZlX5^2E63z;*g^Bg?VfcB@-BnMzD4ws2Em=BC$=Gow$rZVcdmD1!G8va>Q
zSLJSU3u<)NsmdfzsLG-zD%7GUoDkGlQxzS^P4Y2I{4-fC!O>wDVC%}^27l9qU>R~I
z5l7n?lO%*Vpmq1V`F&zH6VpQdwtR+qoE}}bl9lx@a>$9S-67|Ep&O<$m>(Mg6&N!f
z!665oZ_2l33~A18&fv6VcXk^W8d8Z`7<BjA0rylRLN-UX+|3O9*9i`WaF&Tk-Y7ks
zmAIqTG+_&8Nv?@P&C!Z+cFgDgMJA*UXYpK{01}!(X%vZHGiF{8$Suzx2-J86%_UjI
zY&y<VU?6g#@eC$wJcHI$_Y5-2l6K}9{6NP|*h|p5k+mrg!gr!<PVKQkKpKpVs3;$4
zk(B6SnkG<?(ZxCuGRAeJOOZf_IU_Ua`L3eFH%F4^AdFit@Ly)uOGhd;@Z1sHm!J6n
z^5B0;xnjQJ?1f~kkdbUH4>2NRPe6#+E7Wf`k-bNgXrdd*P|tzHEh7`7xt^qKiu;B}
z7ZLvqq%8H4(>KvFok`$kyM->M@oQwwgs~n23T7}}P5VR7Ec8|P!^`$!!M)HcnRwso
zj;I@#Bu9bkuQ9mgQPs^z|MUmBxbPu{TTzBIiif|3Ef^Reb=6YSXH#gF&GtLNi4=&$
z({?0TFh;}jm4{+7%Pbv-GNfBF6`N-qLrzB=S!Rru;%&NXNG5D(0(%m9`Y9l10^=w)
z+=@{2X+Xc+B6RKt$Rw=6D}_~rd=BW0F4<HRKnU&8>AI=IAv0*&5RZZfg3K;MQAL8e
z9b&;V(za)*LF%*urHply{R8@=m;~X5JIC@Ag!{xWs{7a$Bf^;Br+E4m9`jc$>`}dP
zr<4u5pU-ARt0V*2fqYfi<sS8*e-`y1uAC?Wr(QO3<;{XDV;@2zoHZbe?PEGiOvz%}
z0J1~^sYZP=knPh{5!Dp9nVoOo)-!clg;wA;6blmGX}~Q!Q-?hmN@;~Pxb+kut-wtH
zi+f9jNFYF`Mz<BAI-1mk8au+Phu@Nf1+)fv;3`7Z7(l4)goSlvdmvQ3SG-s#%?Pz!
zhZ8FN7dW;e)b)dDMyMJ%2-JkS1<gVX+V4YE6OX0YZETM~Y%bKR7lKe<pWgaY^wz&Z
zp)Psr5p2%d^kzDF6zHuA#SJWiEtgG8s6%h?OPv4##ROq$v^13f(a;-IZo)J?)1tTO
z1c*Ryo&XW(P1J^jL^PIb-IG#7Pms7Gy`yl<6TwP(5!J~Pyevx96N?lA)(Ec#8P=}_
zp!3-Lt%suJa^BqxJRe)JnK(^BYN=cHvos-zd07e}GQ6fq%Z<l$IXGs&@smL$T**sc
ztzVL^c(@Y9*0W`L)>N~&QkpmS{c_7l^6)(B&*olwrhcgrNKuwIHo)-ZQ66Q>@cL8n
ziXER#{P?ldj~DS<>G$Wm9C^Gg;Kpa>64L8XQL~rx=TLN_9Ge$PMgg~mFGW%495-9x
zOL)_m>1;O#ytGp$!|+CXj$fAeL63uKNCeqGoXHU3oNN>xtL=>DC9q<{mkzFaY09nr
zvbrKD$DGwuKVQG*=bx<1u*v`%ngLc~$yNgsmot@7hSDH(O|Z+tFwq|zi|?--i>4~H
zthn$(hZi~|+{H3k%Z~hL=HZl^RzuPhQQK!x_EpGQhF4z`it2hCgHi1#)j%UDG0Zr{
z3~ro}X(k`aB&Kz8aGBXwjd?W`uUS(->uofe%fJ1*NjxL%L>0VV!aYwoq{o3><vR(@
z`AMqr=cBVZz8d-N(W<Gv7`Os51CdJslyPS2fA(}@PU070c?@_oB2XY>1W+EWpk=wv
z$!qS`<~QUk6L2Q`e3GDaXf%d8jEde}D6zdzxvHM@85&SI?-v~>J4!Vjxv3WCKj0%Z
zH)yx^Uaqi(L@#aaK?p-MDN#5?n@X!7D@K`LGGb;8z9hQU?9gIbBu5@2!XVwLxj^;&
z{P$ms%9oe#|AC9{nteA0eK4p^XJi(?7$?W+6@rD#oN``cf+!?aqm0$ikb)zc$&(wR
z_~uCWQU>HulnVE_9bA0W%ndV+%#`6dEE;)ITqTht!{Gae?hvL<A#LGUTRE*$Zj+8B
z_UEwLX`Sj7ewp^pcH7?BDjAFiYws)rQh8^&ofWC4g5ge?q-A8uX|)o)m5>Zo)8fM#
z7aJQiNM}ZdTSHECVXSeo_M=~jAi5{vuQWMdqTwo#6cOji2X~F>9<NveWr?F%&F{L;
zdfK^s4HSk;RCN!iTk7KKI(uT_1OQW-rIOCTK_y(4DKAO@X!tn{f{#8e@j$sZLi(JN
zEhUty5?r<Lvg}dQPt(e`M?uVQRjk~Bs<0v$b6-oh7QvL=Ntd)Q$YudQ^0knSdSgrj
zd0v~nhY1k3P@{&bk3j>Ms2vQ>AbXOZ4@Iv~mkvdTix~-7)MRhE#*P>JM$yndx=ALB
zmx=S<5<E@H{gr<&mGd(JqudbYG5mWL9(ETfDtS`A(x?{)kBAJS-g0w%SWR106X?Wn
zqLdk_z&FH)Z?-Y*tCUx2;=ERPkNhSdZRJdH=FU=|1r3*tX>uTbrKkGLsf3$WZiu6s
zW4%Z5!Bd1%Sr0RAmylc9gj1lSmU}fZ?LtvJ_n3F&G4E6!b8{!+vNezStUTsze<C+3
z$EGNOpHww$s!qADhOU_FxBPdYDJ)q2SnV<In8#em)p*Q1<}t_h6#TWF@(+Z<nkKoN
zdDcAUotDSE!@ReA?49yen&7m0LHU#KGLLzu+^(X6_nM;6@Z>;u-@IUzVk$?m`s^Na
zcr19#sXmxUky8tV2E2j=bQZd(oaE*dHlM!@gTnFNnwA&rG9Ghtg;*e-d0jQ2t!SBM
zdmZO3B-m-D_c#7=oLo=1Ot`b&KgXQyjyXdQlL<42xdrYxIA#tj$U&$W=nM^X>OkMn
zFca`g5v3OqIr9jPC^(Tdf?~VvCULhLcB(PC)f=K)^CeK3=kv<S&GKOdS3@9@{|h1|
zJ}9b#u;ef(wx1l&Q)AZ}>mkZAo+KhS+Wp2ctgf(RzTMmI?cQ$f9#&wvop$qT-(Q<o
zQl#3jU2WLDwheRgoy-TIOgYO9GKXba6@U^f8JN$zy)thvkhMxP=a-Wu8pJRA00s^P
zgUMks8LG|m5a6WCsOY(3PkCXG>(9yEg@W7VVA4YrYD5{2AOEFK4_`lKtfVRwVAlz|
zc!t|2%k-R#liLw_@J;rJ1ZXlWdg1!Nm9h@mOOi5lf*M9qdH(aN8B~>1$j(tq2#zvS
z=kq;sg)k3K(DGq9ctW~Gx%h<2o-bdqGPy3*xS+~y$+u5v&!orymDK+%v@ovC*|-=6
zT9D_3b~Lm=TP*q_SvuA{yg46>{7=wf&~3Hwnv=jBOQRv;&v=gyMQ@h)0P2b6lJ~ou
zyahE5{~(&|q&pf6d0P5E60YMfny6ytx{5hfMSXyxmXkN*l^LtdyNkUyMX&es?=JG2
zqQB<n-&IU*icb3ZTZ%&NOr9^l0$A-sCKpRbk~i5MRH$OV?!4qk@&>PEvW>AxZjB~~
zIQIGf4F8|y|GW7A?utt_9323O12G9WliBQvRv~H=2RX`O%owIMYZAhgK9CxTrxl4?
zusNY<O@}mB7FlRctBNjjJYPT6JYAhtN2W1MX=+nSt_Xo^QK_aAAXd|R^5vZ(Ap~9I
zqj95*U}e*Oara1ua8DX1^LZ)0Ort3K#sB5KL(wT1L+S)=;p(1ZFo!E-?{(Mi*?rBf
z#hp90FKpWyLCX-!pu7;Dnai^Ix$$T?J2U9_x}7wMu^xK|lKYE8KZEjp;hk@Xtq$Fq
zzyD`O2c=hgQ@^dQ>CW*!zl-t`O$HhPGZJtDVJl$pgd_xhAa3s(Y5%VAS#fD=3V9Ya
z!lrOgO<})6*8x+gOf@On#QbfXdBM<C;U9!)!%_T@5v1>E0urGsN{O_#MJ$29Psl*Y
z!3te@qr)2<SV3`e{5bs}>nERavYUbQW=)vqGj|!f@+hzSY93xfK3cmwRl7xchOYJ+
zIaJ;Th+wgyfu;>3fu)oyai%+jja}i<PyiZUDsDH$jwK)V0)ZQviK2BQnOpqwZOkZ#
zSE>l<fnpbtKfTvOD1<<({+!&MouWR#Piiv1bqY+Ok)N|92qTFRKA+DB{QAHhCH4h=
zm}5Yp0V~P}nGTj3cKl2+D*G#wIk3=_Q3xwLYHc+|`{gS|#&Q*#Th|q5Z-~&|4pQMr
z3IeX9B%d=?VXt1hak5p1S4|dlI5OFx!_mo3HTBqphsgn)pc-qQZ2*+NMb&7^{p^0b
zKk=;n5e>fXth`mIpa-RbcJgbEAP747qL!0%@|`zDtO3Y(+!Wyi&ljY2baH5h36@T@
zcr;R=G+D{BL$0%S$PbZPwpVHybOjkG$1P)I!I&8toHT5tkvS9%eJ*Bvf(DwdL(%MT
zG7_zgin(!T^q4(=i_hdSfAFZ!<Pm@SRhmML3PsXK+zN6%kO-p2no+I9PK6>jpdrb<
zS$`OP+qCTZH3~o{Hw&~YI|mwt#iUg$NG7UBZN7=2>gLo(N{50BEOin?sdfsqn4A^p
z26aB?$|0#M>2UNm4faf<nUS#~*=xx;c=yy3&y7ND(GM!fwLNQv+5^Fj9s+unlT)Hd
zj`ss`gy6nc(8L)KrKFs%lKYTGf-PM6PcUkRT8Nr`Xd!yx@4tO?!phP6khSh2+U45d
zd1d-EMNA>zq`v|7sX6OH<@F6z-sCMG-(I!+3Tti^)k573Ykt|<n!o)jYi<>_nVJtY
zHNP(OxxC7nTSaZA=H*bcCF=$8!{oNa&rAYB<Sc9y({}F~L-WvJ@F$1@8u8PwV7zvS
z$VVp8(=jzvtShb`Fa_pIGPzIrxRwl(q{^A#$yJwB>e}<c@);z+wBQMHa&U6|FmMfL
zc|K|k;l`60u^@NeIDV8X9_96x;2BH{%$Z8?*lQN(RvTbh;Zw)ujJrDoCa%Q~kTc<V
zxw3<t$<2YFp12mzVaf4ppQBUZ5I14%rO6oyF8L~?#rGv@^aoLMH}_4?Hc>Mw04s1^
z&*AN<^z6PEoAkIRC=}1o6VwC{)S^bPNNY{vn3PdN%TD%#CK7YxkNIU2f;+|Bl&mqk
zTAgoFkEJ{pTe(GApWDDm?h<K_#>(!U5aKSm0NU>Y=p_<BhoYCd09tkdbZ}z+n#F?N
zGxsisaPJJVx9Y~?1pS-i0<*S^9Kv&RL%c`6KZ8@yPD18{RtR<F44ex>#&Gpor8F6?
zBC>P_P%k<>1JnpE-2<qRT{<IW2JxjcQnj+svo52SZ>_tjCK>6<?omLi=m&wdpdmgK
zZSzUp>N9Qm&4;2bQvwS>r<j8fDu-o%@TE=?FY&kcyWCo`S;N^dQu6L7$Ss`1CS*k`
z5=HJxTbCwHa`?mY(Mmd4VueYtPA#`Ol3U0({mO8d#6YZcbWb84NhJ|awG#30BO+dM
z%hvx|fs&taRwK8P;pjn3{~)Q*cwJH<$oy@SRC=|Q$Y*{*B-LrKNRn!77<d(urUEkz
zg3VyxODpUnT5fjqwE8VI803)0ouLr^ad7+#Dy+N!j(@Jk*3OMu{Z{U+3|eK`3|6V%
zie~_&Yt(P4{fx6YH*5|v2rj7KctGLjX%r0VH?bR`Ad1o&^_x45`W>*ljoV2Zw;T1l
z<IWA6`4$p4Z7}DCykb(iA&~%!Nu_@4hQlJx!n_FTHvtb3KL^n{zX%pN6e>c_4LM}!
ziQH0<x}KYY#ZM`-#&8jGlro6&w7}eOJ`hH_|G{u^#&s1iOt=Vc87|8I2fwLx!o?YI
z(OXJt$PZDt+8S_CnQY+VOrwKC$)<zv(Q``^tf52Ee$;LbF9G#9ycE=<Ez6)Dhl8MA
zN7@nKdd$NuK#3fi0rfO~cwJ8G#^OZmC)7)DJpg-fzu1$f1Nt$x4cIB0S?V|sXry-f
z8DM9?mWaCz*hty~%d8-QUFK(0YYnTKWepI<L6U8ZQ+qUA!Z@3uEt);8;jr1;x*Fqn
z{-DqAvOgh=v*EF~_iJJ`beaLfI94oF7{|hJ;e;iWRJ!>F1g2HurknFl(9P@DD4^2K
z2O0$nEZ7QkB>+k>uq+j{1J}(hhX8fmQOXKr5MWsi>w3ERgFrb{@toq)T4N9pFF0bQ
zn<Lh|Cx&<`$Pv%i!K)P@-u)Hgz2+*ly$ZrMiFhxm5O0;k0q=iH<LiTX%#mw+guu=S
zrd)Rd@l5H0;->W{T;)6u*A76uO6yzgaOfN2A%rTu&$K>l<J#eHOcl$cia>G)9(FVE
zw=UxKPmbS4jbP*&#N$qbc(ODtd?`(}Z|$x%)pZ;WY6GG$XZF{$Avhd@`p2lS63!!F
zmBZm!qX-_W5D#&GoMv*kMUwqcbhAtSn_S$#8Y9UN59}7f={a7#0DZe6_&mzmhMJ&E
zXmdKuN)sgAUiKKsDTNT$37Q~|Ot4Dr736I-RZvYu-+HZDbj%zMM^=g*`PK&P5(Q6o
z<{7OrcY}cDhLvKGJM&d$Xp(O=K)jJ*%j~IK1)87XQ1lw9d55CcPF||R>n6+U-SNo*
z9d4VvOov4|8CojfWCRJ3a6Pvaagw8HAw1`3LUBFO%}7Wul$v?HLYyP!6kl6>u2>-E
zJ(Dls{YGDhH#@K2T`ZKJc;63RcalM0D2ua`gAlfyUJ!&q90e6;B|KOahA)SKl!pcf
zE5FKiIH)kX#M>X@uHXU6(c&B{!9wbKe3UN;Dn^!gSH4TeHQG-nzus4k_K`AjpXPHC
zRULmo=0xZA@uQ>f9nv!erAO}lSez(6DgmITv3y8s?~QW5^z)a={nF15$o<mKm!+Ha
z^Os6D>*v=BYx?;$a=-A7EkRHwWP&URnsHz2ymv~WRcXkzd~vzjmBt1XzFdUj&{k$w
ztG0j{$}9xMArmDZil$-zthM?!C-UP?<gargf2|YwYXA;jyG4a)NH6D$S(m-0eKC#e
z#8l7?eKDq6uH%bAa>y40)&yUSsm5kAtkG%l#XO*qUyJt%P!}}Z+OKmtU(9_K-rszc
zcwYhdCh>lMh4&pHGeo$qh3|OZSojZY0`F@Jzj7{{g-;EexAEm%MldhR7IUnh1?&0$
zlyf=Q_+&Snr4QJ+sN$xV%f^=htvinOvhhQvgKM{*=TK|qHP+i}i6XLU16Yr98IG)+
zfHIj6yH1NH8y=o=B(n)h?MQ~6<w!Q_t{usS@~<FJMEimhxoz2>qK38;8H1{JB4e#F
zQ#g?u%U*jJnFcEZUznrznd-{fS|>88$L}@s{&3|*o^5NeC@wGNMMhG{i)_y1BW}wd
zl`StXvN@A)aa&&D8g4dT<Zk6fmQNMHqv7%*gCD_*JdnOB?FeO6>KB?SF&?R@Qoqnq
zQU0W$BA99~@<1>)8(?fO?M1fi3^X(;2`!_1<e)QjB%1Nr8OZWp?L|Ig4K-K_VF7u}
zEgo>h-+q<9cB6_!3T<SKx4g)!2uKz+L>7!^Qzy-`S<f2BOh&><Uzg4*@-fp{);OB6
ztZ@(x+-h0lO@U^Yx2<uI>#fEhYc$oC7ukw5p<4L~TDCduHcj>33b|f=mB>{=(I$~=
zsX{Krw*zWTYpH^>wwC(P6l$4AF$!90t?jv%`kz2U4XA}@@=VZBZKXV3N%<l*t>&40
z8&{a`Xqqhzb(LpQz67($?KJ|_H$~D=A%k23-aV5pF(q1EA(dw`JU^w7vNj?B*9Hoy
ziTGEq^-SI}WrF|SrW8^GFjGjSi5h@SE2JLxQUggwe;;MSfd*M<om)-ivjsg&BY1~`
zCsnDsL)c4;eR92Yn`6^)$EG#<q}HgQPmU^mQoC7=q)#rc)hB0beG=Cv{}4tkeKIS%
z=a{feA(Y(mCa!@BrBY(xNqv&$-90Cj66L*7DRD5FN~yfeYk1aG%7Lqt93n4ag)_nX
zY@Ue~L2VStmP)zkD&?S3DN$NitCSB*lcg1zWo?W$(k;8^1j;+4rwWRx%-}XZ%DZZw
zdp>nrKG6kfja<NP(!8ywQ*b-&1C@UOoLyH@Trs%aKv6W}dyPZ4#q~5$FRm!AB6|b8
zTCcmjqG-;~CR}FPggHOW%dDWC!EIYnG?3j;Q9M1YodHwIq2d4ffjU!BaR%H|LG011
zgxCr*Hwm%(0>tuo6?A&lRo2`pYBP@4q6YVAwKSmS26+$nP650Lg9_l+&wDt0C20>p
zRPBWTR5b4`zbm)}?XRnulJ@YBX{N|g*Gz@+mT|+KyKqrB#*1}oFNFJxYq?ZwruG_I
zhQQr4(+nVoM=K4v@rI-h{4hvJeQ*&FK)>?4!iG6UX9fDpvcBB!$}e>|3f`CBRqvX#
zs=N@>e%If;9Oz30OKPok*1Zt34*IC{(pt^upoZadct2%TO%vj)O=z2&a0bj)&VYrr
z;N3U_)(7vT2JZ{W$&#xb0ljBSU;^WpIZh0{XWI?|GOY}~!Q*^~3>0$+2;Pwe5*VO2
zU9Hf2<mkP|A%KIzP`yI$bsPd`N9Qi%5J=8}%PPVK%)(LD?De78CbfoQgVt%AT|P{?
zsV_?sh~9NESW2fSPOPCoQLHeyv8_!*Z6NcCjrD-R=IvdTII*6weqS4d57+j2XwT*B
z^Sdhu2E{yA;tDekDrDOv1Wzg;+|V}fn3mhv=J#z3f;F1dws`=+)q$t=^S&@KrT`H8
zqZRaNEj+N*BM?7sJM$W2nm>4JJUJwz!~rmXUzdzpntM5uyjE@l@Xa~!O@nV!_e>k~
zP%>a83q6VC%+%&aD-K@)9~(o`yf)&Qf-(vAIjn041W;a(0%yVZ-&uurYhv$G`x;2=
zXCLB)<s=uH9Y~i|pU}+g<0iV@&F-`N6St2S7@QQYKBSFSYOWR(AuWg+20t9pWU@9*
z*(2`>Ulc{N)ulj|$O`C+!et6JwS~GHu5E`@WO25+cGVDKmuoBzN!QaruqOwq`Qkb3
z3~g$aoqLS->TGcCvB%IIZO9K09XiD0_$?%;s`u3}%XIf-ChSKLVI4EH;!o-`<KJ_c
zR>eyy73sSx{(Qw%@@K_xo8-^D;?Gs_lFKV9r#9x%zhFh>fy*f>XRbm~88?bbqog#-
z(xA<+a-Rex<wf}QMWxc^6_wAyNhY$LrKS^Su250={=ZUG){9)MDEo55$i=r<QNe}v
z|4&8bo~u?=zN-Sl8?F)vD`eXw5bmvjaQ#%74J@|1HwMDmDetK=9_VX!F{q*lT~uo{
zh&p17He}g}S<$I;1#wo(THA}13UP!+VPFZ6W$1Je#HOrZtv%2vDySw{J!q?_E_aPt
z`HCPl!L_o=QmYfxrCXUduIuSnVZ|iM(q3fan)-VVfO}0%Q54;^<qiNC3c%M=B@WtZ
zMtgx&3&gH#=8N(|D+R-JmaXoZ-h#eEv*}V>4YQt+N^Q><{gW0av3e};n3$=pJ5_9)
zAOPa{lgeNC73D944@`VqH!f<yPg`w}4@KLQRLg)dd2IO!fk4UozCQgy6D>>Ioc{SN
zTdL$;)<<VwBt_D7msxh@xDQq?*BuS3k+)>um=<B)aqYzKsz*Nim}?|bKJsp*evrB0
zdPkM#X72{8K*3B%2Wc@nWpmutKV+n!bf`YbCC^j4tQKM(c^oxwshIE3RWe`2O`BxC
z>ni5M7Y+jiZ@785S1l6JvR}A?RliU@-7=2@IU7^XlG;v?*I}#}`v#7ZzA+!;TcvB5
z+S6veT$RaASjRzOtM80JgSLb-{H^9*!1diYO3Yzl&hQ6={&6{H_-w^~!Oy{zs0~<#
ziX5&^*P#6s$6@3K<)h^qpE4F2*Z8uBu`LU;<s~r_da~9vE=|0#8$P|tZkWp2Wh~uG
z(owDk&K%|1+X9hU4z@b3F)3!VA2#KKD&1M47RtPkT><D>$^^@x!IX_tCfrMs;j*4i
znc(`IQhE8e)m+?K;4&a(VrzN+@p3Pz{ZLwFjSRUGxTH5slu$vNNR%+=#YTRS=|qWs
zlPJMvG7m`yfz{osJ*{_ibGAScK!zn4wHf7p>M27i_^G#Qf?Ej<hOFC$?ZqXhgU(^8
zDeF)|V_&tGlNeCSv<o=Dit7Hno@pY0T26wYB+oQNKfRpf@}B8aYm^Q1c3;LTVpbOk
zz2F^e-e9Ltk1XBmuM+(#INK!pU0b1F2k=m290Ziuv*n+@&=KHJmM)5d@Q;J=4{=rF
zA6Lk%u+Fiz!P<V36t`lP!cZ+wRDv#DZ}86+D8h{Llcb)YOJ!4j5@uerU!^cuO9!eQ
zq&_)5O&74yEBpiL!ukP0wv-Vb<#l%y^Accg>1uU?ZdT!+EjvgRDYx~If<b~)o<`BM
zVJK}v8xzS(GRv9UUrNyR0=U66us$x8H&z=T=mptdrY|kgAb!~=wMYrN6fu>c%jzH0
z7da#51cCa)x`p4e%@O3qU>_iPEg(#GjnjE+;lf<KaKTqBz<nXT0SHt}8Hz0XAZ2;Z
zJcng(&P%;H%9*D*$|vO@9_11FUpOolwouF*FX}%DruW+Y$;h;(1p<I05)-IXn%>Aa
zHeu15G7m;#Epk$o!5J&DOEGzCzWH1&Jysd-tU`;tG;h~7Z`T&#h{9hCq2)>O0Vj>Z
zEWVrjMU|HH%C6occJ)@OXgjfAJS-2*29p-j0YWMPZCA1Yb6~7*iTz?)?oB23S4poH
z>Bm*19<7_$Z%MCBfkYzPJ{-KGQ#cTkUbTf2+7oC3SbCa+`B+uX>P!OA<U8pcGhL_7
z1~fTvm1t7I!zR&WPlYC_qlsgQt%I(0DWx2=GYjr%m=ayeaHnF-8cV{y<=Q|e$&PAP
z4H;0p)^3VYEww<E{0^FPC<08gtL%Q&pG|h3jV^o2S>y3zVc=hKl{L4D+Dy#vnzc1A
zU1iO!qBc|WuBPU{7y6uEWzDUkHd8Z6q}6EuK<vxD2fmi9r`1*b_zhclDetfLaMB(2
z1PY6edfFc3(WB{!ymv!%k6yn|E?9II?mvjnRUwKAO5sR6a8==oRs%QFpPfyAo(lb8
z^^`<L)t^@DLx0}i^oQIO9@GZtzId!h?ix3qZEmP%-)lYA*;8!7a=7Z*nnkOO!P*6@
zHe?!_8{&H>yESI_Om@M8wu1HBu6CGO{oc$l?Fhp(xdM#&&MU>3*KQhP{wB>ajM-C-
z<rN0Cs{U*eW44Fx^Z4VT=4-C9=2lUg8Tf^!=I>FB;Ofq+thrUxW@_Hn)LdcA_N%P9
zRn%r`-WqC_2E49vEJ5Vvwq>JowR#tjAkkLs0-_bMC{t3TXNcF!iSjBJ-QWBuP9m*(
z$rH(Uq`sEH#~kD#p*>I=%f#pJ7;hV4n^h3Fnci%vdJ|X&No*?g<ps3bnAFPtCIs|{
z)SZ@umL4Tt*3}g@kEs_!jsOj%JvDuHx|+Mn*{wRbNnUCV--iR@+Q5!Rb5}O7Y?W#A
zpmmN7nasLn5;lvObuzJ?GuY#AHJRAMjFVX;^=2`<oJ<(>d>0$3iA-Lpp`C3FS=Y$~
zeOP2-mg^Lmum!=oTLD~QA6t+A-4+q@`PFqxA79xBwjTcgQ(@@Bu1HrUcPVR|uXNj1
zE=ghECM90#{77q9nJN?m%)cWE!k?@En=7r=czsph8fn<te*q6@YYPY7W{XTD?rN!6
zYBgVwjJB-cqwJiDnW+6B&=4)H2s<$y%??Mm(WrIDu+I-Z0-JA9*=Z^+c;94n*;V3W
zIPVQ@M;tI<Bv<LW6__R-nlF#Sy6QkVp!HrrwJQasJ*e&VsOmo2!QozYS&bNIR+{PX
z_;>Qy&*%N0zcqjFlZuM-=}U`>&s1J%){Nth9!y2Wr5Uf^=9#AFQYF`K^Q`Q@brdS@
zRq7&CvF^LA$u5UBh>8;YC!(iO(>clQ>E?3vLLlP1HW(cqX*LnrED?{JN+q(_9hEY(
zp%_jQY(5c{KzQ8=x=a(wElo{A<tu)FYxBOq_=?|OXx<mlUGe+doA(7}SN#5t=6!r9
zSN{Ia=6yb{a^>$YHt$zFE%x8^RyMnu_h+uA{%e}|0g5Yc|L*4ft3u5^&HIGnuDt$h
zoA-q;S3LjMHSY^kuK4}E&HLzHSN?w9ypMO~%HJp3s}gsTG*{eyZBO9xW{Bglr<JiI
z4p{BAIh$**07LHj7OM<!?O^%Vckupg<<9Xl)g7T08<{K$G7qGO<qR-?;ll0X>kv5H
zThy<1#)^l-oRKe<aoBxxoN(ABt!kSo-)LbA?y^Ia;X<7Ym29KAY#HWu_cj^g)jlWN
zWQ14yoHXL?!hcNPjt+O>!Z-VG&y&Y2-HSQ~KY!~B@q6+PhZkPxzvtG$d!MYNV=Ar)
zA5r1U63Aq>A8fh#wt0eAOTxOgy-nJ-w$VZXC@=o}#i*Q=&vEcDwC&QE+V?8+eTq9L
zxi&{63a-5tN$2A5-4pg_JQRHwJ56$U3-ja~H}Z92IAx1OdX{gIBfrCyHdN64arx`)
zW@E2>r&KU@W4s~yj+^7#ybwIeDw4A53hqX2V5`SdczZeAkJ>Pn+BTNh3Y#bdM{hjB
zX0}HuhJ7Wyx!>u{{X5>=?_hgQ7-0+5#<$%ZZDHzyx0Ob2!&4F#ylv4us-jTE7RAW-
z@E$(jMGiQ8cXA+(vx5T`*me&1VHY?stm^raeB4`dHk4!la`vZ8Ij}Wl!hu~WV-AHz
z1>GGXYMWB}P>-bvzUXjIkFjd9&wtV*uZgCqCbpkdO>QHO<@O=w!Um!*veT(;jLNjL
z@2R$CUXoGDTL&j&_7DBP@R?m#eV3HGi>#RDAiuva`tdK<GfUcol^A85-GfcZlA93=
zn%*VxA@>y_#;v+phZwa6#usI)Q0<Awk?<$%ZmY6!ptCw49}^qmU@-*z>Kb1(OZA$7
ziF)1F7{napg6DPihPFo6O;))URUkCH$o8#774|5qpz0t#I=$7me%%5Mag{+s90*q0
zR=DglOjH4Vz_yrOluxMMQ@OGzK>H0gpygrr*xMG(7EQ1{m@O%S&$dH^YIdY(f;f~j
zc$FTRw?ERRw|$D>p&kdG=yKrajv5j6<gfy*XdDFXXaYibdp>LcB19AB*$kMW*QXs+
zqKdL;g358guttcA=7-XhDW)kT8fO0l$3(S-^^;Ep9I5hK)@-8OY;w(HHRX^Q(!Rp8
z(fUmx`zCy0k?FABN}huHm*@HH85?eD7va@kM)e58Mqftl`o_Z^`l~aKQW@G2RQ>g^
zr&?6)wW`PK4L#YvrU_WGnK8`Z9|N_0)fCuZRC6R*2o^TUn$32})&SekQ+cl>MAaT7
zLX?(yQRhqXD1G*TC3O*cGWS5;>Uv+bkg&lvy=nvelap|;rVX~EPy*t)C7K|dbf$c%
zPyo`(wo4{{e;gLBR<@j=nIr++2G8)zw@)CpL(#23G>5Xap{D>_&rL07T)oj6<XUgE
z29&iHw%F!}1R8x|3qiWD92;-`WSr778VtYA(Bf#K#WW)(EPN?EI9}pHA8ugCY#TgQ
zJvY-u61AplR#{r9Z@$Ff-xS@&5Qm`xn6Ne#U!JqnHVFrktU>@+>(YrMYr|rKpi68b
zqV=I{XFSl3#i>7xBZ;_V&Q_0l*dEmL{^R%PI@i}e)AFD}KS5TM2MGZl((XpQqP>nN
zPr+A<brL6*Nae#h;#l(N<WRFOINLfAeo{QMP*JreWS_cGepjst5n?5jXiAEW#HbjK
z<29_zL%-+l3Gb2UV+4KJI(-_yOq2LH84^O^+{;H2em&&_v%?#J<J+(6)3o99J8J3j
zif4lLwA^vF(#$j@;rpn_#x)qCO0;~2gSP2rIQIGA6h1f;1)FUL<JOpfi?$rbM#q4*
zC!iIc(GGxC@X8rLD@{dxgt(BDQ0;N~W2Jba{XodoQdljHMUSCJ^_^oH>@l6G?&RZU
zx$GNIU?}Ybt>m!I8ilX}AK=RGTBD#H_(<-Te8Ur~k;LhHfZgsHS^&gG(pHGFCIO+L
z@zXOJKO0Og1fkG8J#OzUrShF+w>huY3zlGK3!d}orVu<|O9{OF2Iu<|UdWx!_jh<%
zw=*deavN$JPiFcimFnXIIqS+vsB{D5kt{;Z3StdJh>%J_ymH3$h3^+IeU>a>A_~T}
zJ^D-*29a956xX^QQqDX|zQjVgjd)7JVhgq}JEufPTo#?R<X4SHBf>!CM*IYMn#lbZ
z<S9h9kvvsn*Z(#^>r2{S>Ls)OCG9ClGk@}WGAKwNUs%M4F|^+X^J+PJ6`(cphYh`j
zI)}9%{w2ex!(`ThQJ}4VQX63klf9zo&m~ce{tzDiV*6ob(HN-RSR`evuap_`S*cSG
zBDGo%>H~eDxEoc;VX{*!<yFv-mamgk6Jvr=2co0J_-LBzu_J&zhgW&#$BjaP<;X0}
zWlKyM|4aqF)_|sHcuTPQ=PeqVt@XX;8yZr#yzwqby=wwWKGkBG!|P(%F|=&3>_!cX
zHpRBwpI3ShUxEBZxt!`gjStvO4iXpGQwQScXuPB9m4o6D6{|6_VzrHil}@8>V6Sb<
z+R<ik43(E3?>HLsqtKZzg+|W*Bj%$b_*$!Twu~79o12)V9!Gco$g*IFDT}o6QF<Wm
z`2}btV%N9{itP-x9Qql&Y^u8Hyavj~%i0EmH>!{8M%s~NhHaS`6QnEt5YR3#S6#Lx
z)2zaYP!2c|G;3g989Sl|gZbgJF`ofWj;q(JwMJhHxRKUqx*j-d`d6J^AM#QdMe<T!
zZCZ8J&<e)ZXw}s?H^9OKHo)@UUeaq&z`qS(?KP!Fd-}tVrqnQrbi)&d(St}cR+^n5
zz)ngec@3urG*ncXcS(f`trRv)Ii5wVnA!*Fuz8|li_$xpEpF`AkfR}SaYMAr_9_=T
zrw5WfCWg$$G3td9#0Bb(?-{Q(X-tMqxs_m3j=ITYDj;FAU|&u0>>yckX9_5IIoVTm
z$pd7j6eI1jL#?zn_6v9;E#q*x+<G36QbOU8xWPn;%IzwVo}!gVZ(ZhG`vTFKE?Y;k
z8)P^8=la+R_ZKxR^stz@6)X0_*Z021j`@Ga$6S%lmKATCwVLf^Ib9-16D3Rmcb7F2
zN0KEDJe_lxk)J6=YU^u*ol@&<HEbZIXnWPxuPV1x{@NOHnaT^3r|r1(NmH$Q`i3ms
z=BwifQ8~O&#i=%Pc63XRcA#ibIL|14(IA{&GLDismG?wi6vI*#+Z0*@2cI<oAc9V!
zQcV$*psAn&7(gx1ZFMFrgji!JHlSk;zNKjR{eyV6=2X7bs_e$FXRPL^$sl_pibriF
z5w|j~fMTaPwceX1WaF<j@7k<Y$=v#b8TGc=u($Rq2=)S8Mpx^6RHNr$-lcrD9t#DL
zwZ^=&Bmpglk$J~R*>V_>>+0yQzT#ucVca^C@@o0767e9T=c6`luzXZ_+oOxMx|Jf8
zf_aC=SebWu%e-5bDknAD%)5QA-xbnhm5-WAJC~uFh?Vr*)b@$L1@=v?2ZVHM`wmKS
z`>xqOQ7dBzp^_mvy>UTI(Eimb{-C!;jw|Yaski1O-kSYthSE_@>9pm*(y{HkUd=k-
z9_gqQ#P_~}j*aPrj!l(jt%yCb8Kg|&MAZ@tXk3OnY-I8R>eB1dsDauw+xA(zYK@w@
z+q<zCoRO5vcW=U%z8c!r+!S&4uVQAwH(sfkPaq^7F*SMJ8I%-k)Z|qfuc^sFIR<fq
zAQWbU-p1wXt=vfzA$Jl2QtqT6tzgnsdUuQ+Y%IK4?HHnNgjlT|D|dBs&ZcU#8nFmX
zHYI*^z*n>r6NDWg$>2bV6>!nC;C46&Tm>8i!R>h!wcvJl4^*u!q=U;xOz$;Z*4@)A
zjnhU^jPEIUcnvQ$?jAF-$fR%ZAbd6mcd0w6A;M~T+~x70ULI$@ZTq00+JIC&#pthT
zLs%Yn$?bWl7WaSzv;ZNLK&V21K(`^{V|?AuzW2vwC1QYEFc2pG!KR*Qh+Fl(Ry?4M
zR^k0a(M`^&uQsF*?@&)U;j@4$*4NN+-~%prOU#Qyi$K0^_%h%<&eNw<ySy$yrmGw>
zXsa&++7|kPpqnaN!I()jg1_Q`zSa_P&i8%Q&(B3Gwh14%*c&f8c5|#P^!Yl<okvsC
z4EVI?x(rJCf};<qpX%Cu-otxYPuO<;HpYO7N@Lpfhgn<;ubIGAuS_p)m>1PR_oi&z
zMlY_I*M{2KbBn{^YaA3`i(=1*nqOzG2HbKZDyuf~M-;0*X$F-jMmNW;FmOd3mLIL7
zo}-nhK~tu7qn=Bd=GPRsIOG;vB;C<J!>3;mFkO8D5ztx3rL&gDr-N8+Yr4{-y~cIC
z)9V%10*q&7;<*|yOea{CfxeNZZ}OXQH2tCWwATJ%+2;D@###lUW4bwWTP^5Y;~zc@
z5i+OJ0t2%)I}SB~F|9zLtF{#g+ZAHd3WT&CQy{|r9gu|Dz}T_}2F<PZ<V1$y8K|%!
zJX{&|P@lUB^g`Ih(d}4%`L>Bcfb3YVUQt7UKJ3)hsulfN=fh4KCb6V&0nsx6de7%w
zEm}b}mv&%IU~Jmj3G91vs->7T+JW4*mRGy^PH~jIM)lWQauO%PhzvA}bg#GM92itA
zQuU0^SXazz_6Z}|&|sXr4zx_$RF1v7b2{8Inb(1j%j(c<$(dGLa-uHt1OD1IA9kAe
z4?E5Ihn?8dp|v=~!a4Ru2*m;5&gR2T{m}YVA9j*t)2Fbsdko>MZrH?RB-lC>4SgPz
z3B{GZrN)5|I|b02*#PwF&pg>{M}1D^ec|m_c_H$?sOQ1YH@d8!&&|J8R3#{E^o@Xg
zLGM|OfsOrMVW0tL^O8YmOpqgh8{>{&k1+`wsDz|3ZK{H4bVYu?^)(suADAiwK3Db=
z&7MLgy7%IKzCRvRe!lRHYiQpTn++}eo*BQ;y?xFT3kJ6U-GZC(z0175K}A?G_U&u2
zk=Y`Z-E?vcA><u4`!283hm2)z^67<v%EbWIf<Bb}%Nf-@b|!b@UPhtLWJFiSJ$UAx
z7Va@&NN`)1BO4M$(nAD%P1Bkq(`+(>+Lhbh<8&P_H%^N3I{6~{Y(QJg-Wutnx?1yE
z3^_-%vy7LFkZ@kzx{mq3u6+KF2t!_=gGu=GwMC_K@lW=9NrB!wkD{kd%S9XiAw~<)
z=4M)hTm6Gt<{j_LkH#7l_Js_`&qaRy>FA6;;NC?;M<vGV*(u*0+buYkWfy1W^eJ{a
z+_CSi@`Vvx6=+QnF_FA;u6*Ib;@jaJt|s_aXOxZsx1v>fFq{p`H5cv+z){0+I{)JY
zz~w;r)ckERkKk{cl_wBU%qRTttp!h9qHo?>7D|NhSD?e*6q!g(GM&XtIPnf!q#~^4
zF9LT-h8P(1V#r4`{`qBU>9Lo9fh13<qF%YHxz_h}x#_<%A~Z5B*<cEHhE*+hruW8a
zfh$xFV_>;t%Ijq9FbHcthuj0vX;+sBq?`*~egC-II5y}t>vHAT7_a{PF*hnbYud3<
z=@9l!XAxz$WG{ZjOi&cn1Bk6lwfY)y`RQ7n)ShY>jotD$Tel!dC|^SkRdz+KP@bkk
zW$0tZW$heE+&SW39*)6^pphjNXs!83u}?C}MR2NWk~ilz=_;25x5+o=lR0-E%Btxs
zMHPu}1To-5?d9kwh;RaQ08%h4DkY`yFjx?QjV+|VD~iCEMotu@%zG38zl{Fr?#W^p
zq6pQ~Uu-|^VFW&9@&>$(RTyF2Cq0f(J*hZ?J?4q_d0Zfp^i@_#Ci^NY?A50U=#_-?
zbr816BUx?MfEwL+T4t(G^YkqIFHi{fAg<KV8y+`cwmr<J<H`KQmmY-=wqDt)l`Tem
z(S0+-LAj{?Lp<NXy~$xv^xPgqQK{A|lb_^aR_?exh<4BG?jPbMFyBC`SGBqh|9f;+
zADCAgK)h2;_`hj`*@LMFMfj~ayT|`~*n^>j<7aSWn>~nve_TOq>5sXGVHMWT-5wl>
z!SIuwkQh*6z^p8SZ}(V)5(Bs@gLMlRSyg53CLzz09%P=_V%AMUYZRTGkx9s__ecRe
z#5xy?qAStI6ap+}ao_BnC_RFgmxw*n^4FqD)010QMOS<ci>APwzM)$Fi{>eLvX9>!
z%Qu@Ii0+bul;PdLX+v`#^j_ZYy}ZwRNn*Qf!g_-O!&lpeQ6T35qV<Pb8x>$vDV`W!
zs*urMw*a>7;%JU@`~0Q3c5EkI4TKH8hTBH{HqR2c9etHCyJIrP&_;KnuX1?(1U-@N
z#!L2bH%A~XGj_F!CE?7CB0+*x0dyvt(3*kTsxwSeP+eyTdz4q5A)ORG=ZuhzS&a6T
zxGJa4zVuc>S(ow8XIz$T&L)KX8@~?|XAxFIZTElGqgJV2)*y|LpmL2onKm(nSQ2#|
zg$Hrbf$R?D`fL?9NHz>@#i;MVApAi{_&t!3uh-vIY&n`96UzN{$dtnyu^TujSl(HV
zUXAX};WbdnmY>1#YN~=G=FNKS#j2P29NQ}OZ%OrZqjoYjZi~v-*a<G70IR|UeLOvd
z!q)ie^#!Xp(JO(m`gjQHA}#Mw^w)eCPELkmh^aAR^r{rzydFuFp}}LgG<a6j8@voF
z@rFp>l%X1VJCyT4wuPq0M}|{m@QA~5J$Ldz<h5&O%mi0-&^TW$cP?(E@VJ)3s5ZPG
z{30-fv7Ol)gW5x~<+aeeIcj8(a0WLtj+$VuzzxAel6U}<=XTXP85a}SCAdc*)$RmU
z1cVY45RdV4;lcGno1t84ZA>HSSt3$nkl~;9k`9tT39A3J%VXL{Dw!BdB~;|0@sX|y
zZq_c34MQetJRU)rnBMA?{wYeb#y#11Jj_wzF49}^i2}<ViJh>|GgpX18XSbUOdCec
zL}9&9u6B(E=LK+(BT$&4);6n+A~W^LQH)+dO0+M}Xea>Gik10=1>EfMtgTMXDBd@*
zUzD}Z10Exx6eJyjWO~b@-_b}D|B}x^Ql=Fh!SO+Kq`lRtyrSR73%=EcZ8vJl&7%7q
znh-}?ZFLF>@iZHN*jA@KbA#%Rq8F+Z1**N(DUUOJ>}$V)Cm?Kms(>2XCn<nStVSAc
zx~!hVdYgz`tQt@u5F^u5xHzIj8R{`cIr2jmnQV05hpgK8RK8|ye5ybNV<hgV-dDq}
zFfP$b8eJQgsN9V1hpi-vWhIEcUo>gw>0aCqW~V-+MGi9NCWm>Wr{Ky1%Ajr`T69O}
zJP4U)-!vQ@Ae-S})WU!!fG5v7W4ei4tMF#gO983_l`u8bV~ie!EL7xFIVU?>AZdQF
ze_&vX->U4o_8jj2M01~<Z>cNcl{lMvg~z<8IBUJ4)JEO6_(_I8j=m3+Q#sGU`#z%v
z(`{3BrR`bYk;dw~?y@}4bV&Mc>J7@+s=hZ$I7Kn<sC#q`mo_wEeYe<3<Qwn7-0E?n
zW}*jWgcInoRDaz^t-ZZ<+Z>B_TgFW5C#5uzJ;dk4MR!DSAp+e{1Byh>FSHFIH6<D$
zYNx=KiT1Upa7J8gB}spwy5Y(ussl7lqZWP5sdk()Yci6l3zeg^^-c3KpqG|wW_sl%
zP{)|c&`eY?XOFebgoLlInI^xjnVdDvgmHrh!k7^a$C^oJs7AzN&6LXqEA%0<Y#?6<
z1M=lJWSc%$?}SkW#6%c$z9x)rLm0~6GNv$L*Cq@QL34R4rCCiMjN>#^Wz<r0NiCZ^
z07y-plMs)O7>1th4Fs@dpLQpiRj5CM?AIY0<!Dq`L%5&E@l}NEg?f(F7!9&Wj9&jE
z96)M|+<G<XCJ<~O-lj?149&7=BJbZ6kuZWrBPkRH$WVi3*Qj9wq`UYTD%7w6YNH0F
z0731-uDYCMV-Ssqv(z$9I#^1Am@HX9KKnDB!(QF&6ES^a^hifylsQ?LBq=Ah6AJ^G
zeZ&mAH+d1V+Hk1aRNf)B4EM#Y;sFiBCwKu#C1XpJqTRY1HtZr2R?)W-5oON(4NJ43
z3>430E$iMZ{)GysImMnmP(6FNdbEjJHM6`?v5ohtVRDGUocOWJEVy~E>5%e#TOJw~
z2c+`Zv=$rg%QfgE0NNHC-fwk3Kxe1n5I4UovC-xb7aKMGtxJ6k{aId>Lu3m&ZJt}u
z`O`Le%&q3%u@lul!C<s6lGc3AhsGK{4*~#PM10P{dI5l{7rJX?%t<8x{H_Z>O#YZJ
zS$uoobBAuK|Njv9Y?{~Nv&|@uxMoHJ@KrNvz^9D&b%4*bfo~=7-BAJG?<TSNyYZrL
zcCI~hK`O#nDngj`Nb=qUrp>Ncvr!SM`$0trKbeY9{nW_V(o}@zej{YFch)u36S#^W
z8v(n9v;Uj|c2g5L{GZcWW_9I$c4el!j?6-RyDUepky%&9krwO;1Kq2YnbjQ0^hp(H
zF(mwwluxnC#0Eb-n{4>g$I=ady4cz9r{}xvpXzy)at8Q)3pJ8I7h}rB1!MkLU>Bgu
z_Q6I|e8D0+k>DxKIT$=aEP^N9g?y1422XCA+g*nzg*y^ibt5E;aF8fUTwchucO}OQ
zZUJ-py0@1X;>QGw=o4k{iTVanWp0d`8$_GAvGs|v|Mv3hdWDaq%b%jVRVnpLm+XPn
zWsb|#8rFKlOQqh6USu*vy;0jWDnyBJlDkIr>vU(hCyvjT&k<|O9w{PeOV~elsqdYA
zcp=&4p@rjkRIAUu8MDY`GM~7nQ~0;xbxYp~BF&UN9yL^!@~i2<Z3(wWCOUvGQxO#z
z;-l~Kughiyfo!ph_^%jd-z6;wdypzPVdGp>3yWCITEQ&$z-<EI@l`kJ4|2ek@nlX;
zLt8V-cZXKAH5#=lc5W5PE)KQviq#e>8liznX)=vt))(fiQ-i)FH>Wy-?yJ>haxJno
zH^!@sT|SdMH3-zxE%&Guyr!9IJ-TYVrXH1-*`y3fC-S9czAfAg&O7SJLV=tf)-_9)
z+@;C(!*;gp02D7pjNgoOw^^uKP34G!mA$E8xNeR=C=sWo<%}b>+!V2xP3W1h;7B~p
zAWJ{<_CrI=EzyizbL-q-or*ODnuqWlt8r8Uc2BIypR=-2>ola31=<!ORW=7^P#!*0
zMAldn3hXxb!MGfXwJ3sl$^JX|)yqc<5r^V{b&BE%akA2{iIyn+I@0{*JfEYh(9>Rt
zdzGGY^qvwz&;Ay_@39>R?4EvF)SK3GEk%aSOSV8B?xt{x_%NoZbRX`L{)C|uewu7a
z6vF0LlBd<|V*GlV%^;!uX~OxSHQAZ0hVS#mM0RiIbA|RB&FLs2IaH!5L)y2ac2U(s
zTIXhW3PH{E9H2b;1R=BXNb}A7b@MIibeFj{X5efoFo+qM8olaKHC{caudPR{ZS$hE
z^etY|kg5GPA${+^%|+2;80fUZRCKz3*-rOXb-F*@Y0J{Jtz*5@O5#!8?qxe|)67Ju
zpU|k$fhLjV<DuPjUaFdp2GjvPG-Jh#uyg_}g!+!3VRl*h-6?Mo?M`+G1^6Uya$Nu9
ztX?eGVN!ubGm>}7<18aN_b@oB?{acjK5?Z-nZM_t0+f+qDL3Up(^`QteT-m@AcxNk
z7mLbe+6AJ~{3FR5IFQ5let7FmoO<|=n5-fbbP2A)rlA9D%Am+~ddkYNf-x;@MQqJJ
zv_$R=Z-df>Q2XeJRPMrNs^ThX;}usG*QoEiov*g!ZH8iq#ZdSha@ZD8Dwmfyt6;f?
z3f-pZpUh|fIdkT0#?fa(=HlN{&tM9YAXX;I3qLM`msy_W^IDxdDCW-;TV-M<f@@aR
zC+G5QE9FNx-^w}5G>B{QU^L0F;k&7d;D+#B<GeNR-ptVDeC*CAd3YC-g`JTPPs(B)
zl9PcI33UYOj`TG-u{sB>lGsyw-{JOcD#N@T%03BixQ9c6IV(ry*Ph1R^DA=q{4{6f
za``FUxX2C4-0d)Ar5b!}5q$U<3OL|*F&^y-Kjiry@PHh$>^qov_z<_N@w2Q8q)K%G
zzFt#ZR6Os3zj@oO6Q^x{E5E7sy{i1hAFbNgkTWj6e9?$W<h)B~GUEchZbZ^19gPp>
zl}4vCVkj(eS<p-vjdhg(AqJTAAPFO!XJY#7q`^@GT*(iI5T7?a!88JBdcyePEgbmq
z&4Cj-<-Ud!2+HktP7n)pp$Snw_J1K^;B;^FTtr5HNjVE4l%M=zh9obauBNQ~%#U#6
zaQS3)gE>UV5m9#8NKUAbFJ#yAQw>f6RhwG9Afwy_2gCzx2i3z9>{$$CJwt%eGd}W@
zZ<h?6^N+>O`Nv{IL`Sps?1yR5_2tKDsZ-UgocG3)!AmT_ThO0HH3v}<!;ez!L=ZDD
zrT*}_5pXm%xTR^6YZ>)QYM_MjlO_pGvn^Yq{MuUVYg&Tyd<L9Ep?+>5x#oQGPH+IY
z!TswxhWWrH(Q0kb^b8YnEUkBK(7xAe+Mt-J(gs6Hn7KpbtYJS@IbpSi4dOR;kXs#X
z@GV;P#KLCgnG@FrXH1<DMUhP@A*l$bYlBL6LK_@Q8w7tHEy_!YAx2e^w82mt+-0?e
zinQ?>)l}M``Gwc1LE0c2mLQI7{PTX$2HEN&XoH9jX@m73P)~nK8*Dx5+Ti++)~Q?4
z1_!k^IFPWHn>Y~SfOc?QYlDNZ*nZJx%2pQgyAmd#5)B{6(Im?L2806t;e~Vt<wP+n
zQ<%_&sBjX#`RtaI<|jy$9y!0Zzk)WMm)2n4_+2S~pLnR{2_&?KUXwxibwdW_2kR5|
z<ZKx1h+%d}!`V?~nu$cXMn4fO>32$y78<VIk`b>2cK!rR91z$QRCEGU4Xiif3fmk&
z<%E$!xe5xZx`Jf(K2jAr-cE+=DTpIR)QPnw2{)7k?iwnT!N(GAh<lYN6{*yslnsj_
z1QsaNApwz}NH78vgi6|c(h%`B4iMGxJc6+%GYmgb2OBvbe$y^76tcg~6R@gns!tjE
zb)a_x)<{L|@D(4)7)VwE$j^b#e157rh+fql##(@C)9lS^(P3K1LAlTzjw$G;XArs9
zXwV?+@GJ-?I_4qe7jx+NE96+pTBUGu%w?L`lA@%%k+~ORXxOA^#pao%k&B#u#&<y4
zB?NoZ<QnM&v@KT3`K+s2{BV$ZIA}!}hg?AAn?l6OzniC+-|!5*SfwLTw{ZB?I%!V^
z393O{zS@W;<)J)25WPYs2~y70v$%YPXOzc+=KFc1b3;sD9^@>6mX9Q-DB-<QN<y|D
zc0N~IB#2d{wvVj0`cehD|0wsNnQa`1(wnt|@$95SXUa>JcBZIiOFL^*)Rb~&v%AMf
zeLIuF@YCF5oB?<@a?tQQhubOzCb_t_pqHIu2UI#4Wq)%OeM$O@xKyQUW^*<NK{J~}
zAK~>uF*;LZ(#*&-gqugw%yz7lU*S9pnwdQqP3F+dI;NQ^Nh4@xESkJI?x5!xF0;*r
z6f<-NQ_T2VDQ2eeh`MB2i@fbC>UJdxs(?KzUy61_mSjKyDWP1u6%*-6X-`54W`XO3
z-~Ag@b1$Z~?eXEXx{RZ?yVj<`MJvw3<>CBV_<^{4_IKF1t;Hx9w$*K86j;Y3rXXsK
z64nrUg3@ZXyOjEfoxEh&t9M+?bK!s}0{4{*BDsw?L-P$)n})Vir>2c{YHe%=A}~t1
zBo;TYF*sqIMEodPREXYV%2-DaXr}l@wR1Sff!{>jM+oAmZJq!d3sb~_HB%sy#D3Lv
zV2hla0ZOqVEX0knXFRf=%I0EalNy@@Pcb6^g(q5~#};Wzo0sSjMF-J?VG@W)*}PCn
zEqW|F&WOrIkD1O!RDLZ7kF-1SgJB)1ml`Tp?x211JYwuGij>FsE)DHCzsAN<u39K^
zJsnSSnE4UF8t~wukdDWnMF~s$KtrSBv9TI%Gd(LoYFMWZO|D}W(~3Rv>lDB+Y;1ni
zyo8=86PZVtU#$xWkC3B5fhub+6W)@+iVW4GWV=D^)w`CptWrD$9OXiW_3*z=lGHUt
z<~qbG49AJ5qjdo7*<Y7Sy;H=xgkA+7dcssv7Md`W7>tl*5gSb#vHA`I%$L$ZAgJsv
z#ph$N4}`6xH9v#>Vh1N)(n{bc2_7R%)~S5Au@McabnTBlQ|S*HE}pFSR5HhwNE~V|
zx(529=jFn(Za~r3!XRYqdY(&sAQ{;iEufTzO52ECf41?|;@GO*i&eevR!G~sPms7Y
zCS))MF7`T;RPdY}*Pxu4OOi;!S;|0%)hXnLFm$l{Gkmm(Do|X~X2=FP?Q3))Tg^hr
zwue*oi&66My9q9d03*#wsj0=Pp)Ggp)=TtAlN0L+vLdWb%ArnhL3Jigov0<!zo@#}
z38S;(e&%PeM_PVnyOf{VoY0rhGFm^{rGEUaCf<+dnNcteB%)G<w5&bYct6!I(#_j=
z3=^3pH}e*dz+^?`M|y@5@<=d<vYiM=20hCZP?16)DjcLZS>(0jAZ>{bv-k{Lc#hmz
z#IfWYr9X>JD)4+pD+&x5tfNn*QysO-dK5lSWvx-L%lgMpPLH2m>c>Bc>)0~f20=14
z<j9-l3qjE*G=TGu!z5<bTEyMlk3vN2YtuRGRacD}X$(cVYGgn$UY#>}EOo%0p^TjJ
z@z8D)Gm-JSLoYTOW)LfnlcH6|*)T?y^TSvK+uD*~K(f_dX2FiFA;$$=enFP`y6%?G
zC-FeJ7Z{_{o$hJsrur<Kq$iW47=$*5Apj|6B^;ETBOIzEgd~T65|Nuq&k(TJ*Duj^
zEu4WW`vvD#HC}EC)#H_zF$7{)<HKhDRw?8}Nnp5ujvD=w6HK2#;5r*Mq=h+_nxV4{
zIm_RM83p2Md(e4&n;sfmUu&lxlIFwWq150Re!l$3J{`wBjV$0T+uVq$t4`qPw1E{k
z7Z@ngA8kchKc^u^0ZjWD_vPB9yx?wqiO<w)Sxd+X3Q#}O>;*Y}5*OaE4yYl85vovC
zhT$^N5Gp^L#9c!uzR+s!Xdcxpqhxm(djLUe15n{{H}>U&N4=nSSu*68;~v08gb_C|
zAH4s@=;MPIMH{7x5}{bRPO2{09YiczsAed%NNyG7E1IWHOTkuv!HDIj^a=M5{ynjc
zkP%SeXy9PgbHj_SZkiUsP|<p03kX$h*EMiXndewMCvWH^4iZwKOZ62U4Tl-z=gI|3
z>}W%t*h-1v`;vMJm8fSZ*|8}ky-3q0FEhLgHQ5-dz`o)wj1q7NZ|kQplXhtVQ8^bF
zG@nV^-&MwKqDkyXDQbp6i*Z*EgL%fR+}1Go%`gn6#L)x|fwiz10?dx}hCsU4dLzIr
z8rA&vG&Gu3iP|B&XR=}w9EO4P;{Rkg84Zb1@RPonX2Mh`44E9)_~(71-puQH?V2l*
z0PBhx2n>lxcqg%$D=+-aMKZ>vrNQI;$)2`#nvgDwpJ3_E?YB>qT^pa7Sgul_d5dUP
z09a+8ee?T*e)11vG8T+4u5qrU{XJ`en6rl!M*RY1@Y=z|+D!Z+rg`3GRusv$Rx7#1
ze5brnq<1ooT|QTeWVH5KdM<5LFKHuoKK*dMlzM^^6H?>q#(iX+#t|CO_~1hQi*DT?
z#X=83iUvj}B$(BM_`%p1mQ@h(ux2x{u);Fxf>ctU**q<{`#}g^t34BCsOiV3(#K43
z6(G5)YiWcUTR}kxNHg&A*J$#K-tFVaYcyR7qUWCLQX20Ch8^CJb<D7jI6x@E$d-d^
zcoyw3p|MhF+1Zai_)fNr{D1Q=Keg-i*xhKqXN#naPT2V`a`z<J;}C)rXe3UWJwjh>
zuU~Q?lzL}3rCd;1n0V@phWEBAV`$oy{qy(#P;pW!x$3*_EVN|x*^W`lyKJgRyb9f1
zr;6VR8ehm1!0B09b8O+|$#G=FkBO^K?n1vBT|T*sR+aOAXt;~J=`4Ngme2gsr-#;2
z7&u336?R#=0fWyo8eb;@hFF54qgmu5ZbB6W?#O-rL&TKO0GNSzya>qwJ&x!y@YNKt
zewb~;zL(8BCA%EY%mp$0V1vcjy~tJiB~OiTwCGvq#GW8<%2c6DQaT8=VdqBPx1ark
z|LPB-laSS<Pv>MvB_$K3MF-Nke9?h`KlCjLePgl_MM>zJ`~)Hc?^}>@>YGto<Xvg^
zjchUXIkCP`F{6U%+HCzDiJ-U%k^0=aQ9SR&^{pNYqhU6j;J?@=x)}?bXpKdB?l0$9
zy!Ts77sh@@_Sc<l(F9!UG;!VKXaaZqUldJz=vzDvm}WK#|Mue_ncIjac;+uBQGDQA
zJQ&M97B%9p!yn6kNrz$!=mR>LhKi8=<8=7b65<VjBE%JB5oozU@99&?K$%4;bTZPu
zh!q|KR)`{*BOoY=1Z+Md*#{7kto~1>6H$)##{ml+)^SZ|mRwVgP}2mf((trzBh{iQ
z)vgvL9ue_$y#MsJWRGXfUBce*HA3WMpp>B`lyNpP>YSHlg!H0)$#I%S1nPvXy+-#(
ztpuaB=yKl8FdQE|JD;($qudjUH}g>Ti>RnVb$&E$SMLnylZEvN+^L{h4i+IS^u>cd
zUa4ZM1kAQcOxe%V2QQrdXMY;2Db+t^U7#v^mPXiljmTimHcG&1o}&M#0|+iU&mQSm
z*%Ta>=_TbCBIOBp<@KB(SA%i8PMHIGZ>6F(s8n96OYNgrw@a<o!TaicI&gsw#BvMq
zPfAc%%a3gJzQjG4hSuaAl0rj-)(zHJ$-bwkkJR16yjHK@ha5x_+7DjtC5zXf9epuY
zgz6MJ2Rk1S;-Iro-~9#sM!9CSNHSuN4|xiGp}oDQQ|+XljQEsGRnoOq5GnO>`M(ef
zB9PCXW1<CW;Ip(h$8XV@Vn@Yx^P!)x>p$aq#{v0n@8VZ7gNhM@J=w{{*SO%L2^L*D
z6y4AFSt;`L1TE=M^j6Y(I6N@f!-JO~LbGJdzA2z2X~FvXdKpiKi~`HVQT}z%dQl04
zYQ3nf&fyoiPl|dEg>m%>g=d)s3k_39HU8Q?Aq~4H5CXTcpRw&{m^9oH`8fN0EOX^T
z?0m?sALdFDb=opqRtFqNo{WoYk4F2%wV38wS<xd)A+kIvnfF*G{G<i7=*}8Pi}ey-
zwf#(!^4~K$V$C1ttGEnbEY(GWE5Fqb`8~Wmi6WI`vw8ZYu0Lzf3__SA!Fz1Qe4zCT
zfwr;l#bPC}!H5d*xQN;wy^9a-=9ERql5dt*zrc<>IJU`EO=yAR5UJ;q_tM-PPl7Kt
zUxG$;kC~UxKuOjbR=`L0Ku;bZE6RG_+8d^)4MnUq3{p~?YnR!FH7TF90EHz@u+n&H
zMBSBZ+vv*|r4rYyyN7OC%lIL?Q)<1DCRs{MtFJk<$-+!hPox8jMr?l_i{Li=P`-R6
zUx429T<pvdy^b?y3k>eu8G>lA47Io193Qk=uvx86SXAu5gJK8rlEn@q9UdShm3Ooe
zM0C{7^uegZu*k9;mdDS8b>}gF&UF(Gkn^7pO0k`rCTHERDF6!(s!n~-$Xak8uuGk6
z9-+fMlaWXktK)|Fpmu0TNr>~gl%lK(*bqzuL+`n;HR_%6Rl0~syV5T&Q(~u`;fhTB
zY=79ap`)}<+p3{MzLYPs?34wA?86NcE&3Y_{7yf^<Fm(qWwCj)`SUe?4`IUxu~cuW
z!FahKz_0O{YJ`HbvEzfaY>W2oc|Er7wgQG(LM+BfSjMTgF|(Pm!FsC?)@h%v`zPey
zA?HPsHQg8*Aa0C;%x&V^S9{awh`CHzE#bo<00wr5zgdR3ZN^cTH3(nAv8OF@HyPSC
z_q_DnPvLy|W!b^(PxMqgmRU&(170{2ZKQLSx0rw1_P|K13yDr15x~am`vQ@rk|*r=
zBH2wEsJ}!uy9Nmtkew-$$@s#O+8GL%Ttg_5;i}b`SxK&`$DKoG>m9mg={iDK#beHO
zwHpe5@gxdgQ_Z|KFG`*^eEr*0%!u0US;tpziQas^id(MXc$Ag_k|NS(O{Q)%!@;*b
z-C;pqvK$tqTcU`SeBubT&a+ecl1S$1x0Ij0Fqp<kpXn=K6P^T6egH?>^<MZhI{(y1
zn2=9uLhJ=oX<Ba)f=f>{Z=raV_SzR#y(T57s%f2fKBKC>R=xADKO83q&Zo+Klc?K|
zI<{ZR)iO7fDl{>>9)CHi2zu1NKtF;jCf6GWPhOT!q@^wAlUuP<FI+IGFeyLwyBE2;
z$A4VpN8$}xKFMDuC2x{nFCj1?mxlX{h(ePTK2ge$lChp=fAjgE_#7`k{7V-j_)^i;
z+4B4Sg58ZZ^Yid!`Co8rIkFDVi~4?)Yl%aun78Ncf}C98@q`1Oj~_$)gI#<%3u&Xk
z&#cZz%%d{jv<O(mPh4RpG%#O&5>;<R+b%IALmE3Q|4F=3{z9mWi654~z>S~N4V>q8
z<EN{Of5djsCELwBrz2mv$5a3B5>A!WspE6p>XiqL*M?%7oSTHJB@BsxP#&W+lyHr?
zL%gQCgM4N89XeLsLD*Kmfs|I?FUBjk%761z$4aTse=a8Pg%%*Dz2=dsL^ld0j8q?-
zSzl5aT5)xW(D#}~0!Kbu7+TNX6F;avT@q(8a9fWgACEbHhQT<Jpw`ceU_Pefvah(u
zXXML9mF1#BnK?_7w3gTfGiUA41-rueGxPd_;3Sp`tk6p|m&Q>H?<oAoif6?}^iuIM
z^?L;EaWD-^)==|<$ig3?!&b4%*DH(%*YyN+x$}Mx1BSFn`vBQA0e&1JSf2vv@(B84
z2(#a@&(aa&OxZDtfq=NO--qBTgtYX3k@xcng9z0T2;9PGZqbw^?FzTh`XX)DxTT?a
zy$R!XjkgX%VrKN<X15$r_%7d){Yp~G#IpF0nIpTg<%SblNnN}s&nxvVGc^HK>?4B~
z;AA$ogp@J9F33Pl3UM!%;m)engfD$|u(njvPMMQ=zSA6bToq!@DB=cVU+_nqY}d?6
zp?R|3#f`WvX#tHcXtcBxgM^);SEFnzlcH6_hyp2qXm>zeD*!@;f~#66E9JXYt%vH?
zd9!%HN~xNm7eZ}I-e4i2C}pQ8C1sHOnzmXrGACUrSEu;}J$PriBpzXip!j_@F#7CL
z=m_6_%qMYnF=0B1Wq%2&>h>?zgbjksa^#qO&B+HX#p30<9yA=Q5=gu$ffU>8>i9m5
z#kkJS&G%6vYr2@eeY}i5GG=5ZLmH;VOBu7CX)*`gIF2!9E!`*DA?*GocB%91&=I8;
zvpGLlim1Z{odGUUh_%$6pCTw}q-zx6W1KNJH*%nzhvBBfu&;V-IimEKqvY1Ch(Ubv
zKl-{VcSYOkxB>9oAQIgtukx`xQBoTSO0Y^!^I5+Ez$@0sl!tc9LPK3C7tUJ9)Q&_o
z&v4?AOTu%y$s0c8P@9@EHN-ZQ6<x}Hp$eNW>;Oi@<`@?@gr$Xh6tE14*qNqfN%LV1
z#RRpnqw{K`0+dpN)Hdl~I^r#8+7@nJLEAht9q~Y0%$aXV)z+4Q&5agsG#y|ymnHKs
z`JeDS))A+^jA%B`Yy+#{Zs1~1VGbwG^q~a~Ia)4<MJ7CB(2DIGj#WBOCR$nKj-?xk
z@-lr@c3EfQ<YE`y&lsx7LduDf%ih3&t==v{DsSQx+Qt`if`?G5^X<H&G0miAvD`!1
zsi92H-pqaIcMk{T+e91(9dC6g;wFlduOfoe+Igz6$lHl~s~Wsy4magLZ&i<QJ+by9
zN4pwLc9Y=9iBUDlxT5N<n%|JEx)&bWN@qP+k%dHGilOvhO^O}LKZMdbs{MPZhH2g*
zN++Wg=DL=CPFQaMYF_IpDzX9P_$yL$FzG5g%CE@DKzKx}iN4A?xlFd22%1tGk+52V
zMG<Mfi=Q+L(9N!!8BGc!2{p=h<<}}{b(c<9O~hYMT3yQbnq`*dOVVTq98h*Ueih|Q
zf*>nkNn(Gm<ChS7iBqmoPCQ9<FTZ1wAcp5jQhoOGXtuwCW?O##b7-H-<ptfi$PLB~
zl02sI6r3%IpLbVDs$0>Pm#Rx`_I(Yg@QH+#MN1B*VyEV=1{Do%tI;t(l^>%P)(L&J
zuB@WmBxh+4gCA6h?Od2A(TFNv2)EazZl_m^V=5!wr`Q64HuyHpgdC0}U%^`$rkkTm
z25dBzirk3jbqkQUX#uOeZVqn|y=!%lID$V-%QWWVrBwtk&Vt|*W*jCowGtyea_W}7
zUO{*4d1N2{EW?tQpJXa*4$AjwQVy3NuWm?nQWH}nR$Uk@YJ%_}Rzg}%W3Fp347npN
zoV4`<q-V5h=mRoaPf<STsg?_)Zx58TuQ8c1R|$>Bfd$zxcR%@Q+H`&S%|ECJMG_J+
zraLI@a?A?E7Dyo7XQVbnz+z=-wUDj5l@(#@Lc~nvZ#-XH5k>h)zX(=@l)3Wr+zM8N
zRKD_gt|fMXm7YCs7uo<7j-7C*tO(Pkf)!CnMR6;lunqM@o|P4W{!+5>-7*JoPJ5xE
zz80}80b4}CNV*;#y9GeCEYX^3*F|ou->{G4T(f3<ob=sT3Z{tB^vi(Rcq89j&XHpo
z#qgwj*tYqZ_{YwFB*9Gz0qMO;lP2nFnsikJKIXZU_w6OT?Q!;H8m~Rn!kz3ZR<_vy
zLo_Wj_zTlVB=$_5)hD12OSPN`h<yc$K4>L)*1z(}AFQV;DZkGz!c=uNRX@tDFjeMm
z_<pVr_*8Z6dAra~c{Wv2WZmE++0ST4Ac}0QrV1TxmBA-jYm=jVRmmPKeED;J?u)Wv
zD%FY`%PXa&fyKC{oW)~p8=dphmYd@@Q;g<ts==DW^;^swYK?QzVIsR_HIYn-qVuJ`
z@DS#K#g471?6juR&#S4_d(~7b9ZW`1RYYqlJFxZiRO*gRB{k*c9C-=&qL$?ylexwD
zQl+)R^4fx(Fad)qu;=WgeO649YgSm|RDjBE;Ec~jMh&wsxAYQ6_*;pl%gobcAF}!q
z)G)^rk|^{5{dA6LpCE(0UNB&Z)@V?kjma<!@_mt47B$znD9{KNCkJ)NCf9qH^*4|6
zYviix+zMms%U8^w0ka%@=D@gU9N$4#4n7R^95~QZBJxGGq(>vMt7aW)fSX<1K&K}i
zt*OiEBT#XMMm}7S!i)J+e)V5pj3#5=5XaCSay3oyD_`J0?a@x!Qc6_6>^}^6Kk$Sw
zI2kA9r7wepd&*D!%YcR1|ARvsS_VcqjL;!1LxcDY<(BvjDW!9A_k;<NzkpnnKd~n>
ze_>BC_P7MaBe|3kqO4IRY2Z$f5@&}6;w@u#H6%#%Wv$zv^^cg(dZNy(EdkJ+^9BnT
z&Ce&(%YHXUiqffQKu`p#Ui>11;9@6qtG)q5z_M}>O2F|htF*$IYyz8LTvI6{r+qof
z4qviSMi6qAjFFeU9uH=}Ts(^<5a}ZU{qnQiJ&70++%oSdyJYGJtA<4vqSmz~>A>*f
z>mY<7o5AE|xMexXj{*Q90j7SrYSuL2nD;<lTytx6@`G}6)ia+mhh_W(Wvdj3c6UWT
zvdcXa#}+MGUZ?u6U9=U<<XMF~7qbtEZFQRAp3xoK99*r>(=(P*$*vC{WFp*V7YTeF
zZ%a8TzxLZ<s9gnKphj3gP6v79C)c8EFEBk6OWGjrQ+J~+&`^1P%BSmy5V1U^x&>tI
zn7Wkxn*=?0L5t%gG&I)>AUh_qtK$pkQTi<BGPjvE*_SZM9@?;n<wklFuw&2DgwE}u
z03t#(Y>&n|rFEe(dqlsY&H(XyC|_Vd;7LlIhndEx$_^DNXEtz?zVoOVuWhExuQh(5
zdQPxA{$J+a1<JDPtnWPM-g@48^sTN(S69EzJ^fI%q?X#YP`4h~eH7csu@eh$g0jYI
zjhHduQ8QqB2`w=r>;{C>3<_yK0EID=juE&Cb`W5g1~jY!1hj}SVo*Q^1sX;Jf~62;
z#fxZWG%&ya|J(cATcv7SGG3XiUR~$hefE2Q@BQs>zqjtF=G)GE`*%EW_T2f6GavZQ
z`szEzPBAlc06$1E_f`m;{>@=Q5s1O@t1FbVRH(dH{|}#Ny7#(3M=im6a;a+zsj9`_
zw;e{u;78kbF}eh)r2yL}@2z`pdLIE}rCTyML`tyndt4`Ip9WFwxzaE+JDY|wJ~9;h
zj=!3rDE2@aJELfDfuoA;MgV=I^Dq3Isn#REmGM0#Y-~-q{F_^Hyow^Gv)J`5<VwTe
zM;Ci+E^zoC(PrxOdzo#P5v&rag~zfH)a<^uc4RC21pAE&Bv#66k=d1u%Jw`JbnZFb
za6AC!C5xbl5Zf$yXy-oDc03U7g{>nwlXIwt!e8%|u#h0ElSHHa#^u`LP5XqHi!Jm9
z(kz2Cwzq^&9T29j0-5;KEeejY9Nt6a3Xn91n;?Q4S>!M%dI&WiC550{kA{}RrEVE|
zyJ|O?WmT13>Xyawa2H(GB#;-rin}0s_Za9V_1iVrY$$@d80yQSIK*a`Iv*onHV^Pp
z$u>m)f?sJt#EE1e%CtC5a+zE<nKszbjOI$$i?3py!FnnZz#dUYVJXn7q=?AA?_~W(
zQIVlvG^F6@ze=YV!s=}z7gPk@VKa+)gg$qgCqyp2A%+Q06^nfqU!mQoy&eHnkd0&n
zkhO@~zZ4de)p*Q9g?xdZ&hNvV%;br2)cola|Lk?5BGaf**oMFxz5f}hW=@b=CPHl1
z%&9x0BS&Ja3{Y^4cBIa56je&$d^N9))b1T504ifF=hpTRCJsb<<M#~PV-KKu)$P4I
z+JlVWMSBq3wmpOo<`U*R-F*1*hj&JMCr8Hj5mN1>_G-p=U$jT;jrY*rIgA^J;@CF7
z5S{spU=GQ_s*h?mFZr6kSlxvM)~NaAG;ONDfGp5?&d#$r^#~j2&0~(1fIvxQ#F2Y}
zH2DEP$c8?1ttI|O)XTH}d1L1RJ+FR!=Zr*O{5jO>Co$42^TZG{ScSe)PJrRelDg}?
zlGiEd5lHrK9*CU-Hwgf(CS`BFc?kdZJ~<IAJ7BvUtM+ddBu6>e=)3lnrRL8sl%4L_
z_{8MYbZ=&MZhl990S%j|GE!_7^d?Pgwy!sD0&`HNugi^!*?GNL0h-gB;*ieH>P=K}
z79a4wwANy_r#J1i%NwZQ*i!=EpT4gCwTnYvH+I+$f><(o18Mg+`(&M(&xpBS%)P|1
zLx{@y?Z=o~uq=IYN{rwEq4`{gYJEEc=|{UK3EZJwVwoG5TlpLSh<anOM374A0Z}R*
zEaTpIEU9v7ZzLi=ENe++Ct=Uujr{A9AG!=eyXO0;FxM|sQ@_|%P!H)4D1=dJzXHU%
zA#9gaGuQ`n)s36j7HjBp&DgMqqZC@5sf8?3O|+n~d2{Nt%+=7Z{%3$CplN|SM`{VC
z3&)C6jE3KDWOzK@#-J7y(F~Md=M8prNDr#_NUBKN%L78C-50be^-|j~ea5yRrS=Y0
zbtf+G(7ZKK59HFU=7?<eKV!|EOz%{)N4s|nuBKbP(6hv1bdI9jqY0p8^OI51=0QwK
zd3l3K=wvf?k3<`J;!nzPd807B!2ln=KIMp?d}%7D5rqi85VUR~7zte}GzB8h=;!J=
zLX}hk>yfjJlXZb%YqeaIB(3+9XMivYy|fP6A@fBz+Lu~komK>cJG2fnUWaN$b|nS+
zU6DRG_P)U+7`;M#EVKr`?PY3s9HKib+9hThZ|99Zy-|<6A{0^DtvpzflgMc+fV7rk
zMO~fXVdHlYt`)g_tdn=eR`99n>Q6}SP;{Gmj~>Kt6ok;;q2W3VO5h32b20nc%g(&W
z0Cg*RqZ9pQwFmgJT%by7+y&tPOd9`@28QbhAnJ@nZ*-YxZ<c8|;7B_{odY2v96<IM
zlc%|O=Yb>`9Drk%Huy>~I3PUqLxO?K+O)3hHt%t^+^ZX0-{%O-+GGHia!A979(c44
z#R5Cdk%-wP;A4?lv|-REIj|-{+ELON<rwnZ*gfLPOy-ne#O|(!mTA6)t<cM^6;JDJ
zQQc;EsNxD8?*BQv^I!x&Y(@lQAPVTVEO>!F2YRS-nXfL(%t)teiF6ALn3vhXib;UA
zJHcA)H!L*E5<3@A0XZPW)oD5iY+JyGegWzDn&yfBEs2n^$&fei1WW88NVA^QqrcXi
zVfD5Yex@x9ke$Xaa;Jz;d7E8(UDXt@tj&zU6u>rKBNQ@IbAuAvrKm=r4j~H~?t)`H
z{Dz<CR!FfGb(=3?*J%iZreAT~3RcCw!l0z?F2dz_wVV8PSJHRMxfy8nZdMEHfv`hV
zMAA}NhptdmTC9pfi&N1kSdF<T8g0kd%T@RmbKJC@9Ys6U={dT-^H>42b1j`#25?vZ
zp&)OC4R<v_2nUM*%%hrX7JM$BjnHCn4RZ6CO#aNcRX#a609%|VWajGZ@*oAD9OFTU
zP@p+GMt%m$T}3cqA5PaOrA<GmmH8#@Z_tPMrR@(d(4dFZL=WHM{=E;18gpMQXiJ6<
zRMqtK-f4P*YbaZ_z&Rk5VK@*E4Zu0ovi`qyPyauFZnnXx{Y$@?+HW4@t+}?jsDur=
zfY#Vi&sje)7#zx(FJ5$+ml%$$16|8@SaP7SAij(^33PSzt4W~yd<%U&p|?o1JXX5e
zi&{gP{V=QPDqy{m)%D4S1^vVxk|4Zt4}fvZQY|EQPIWyio*6>H-h=Zs^nQvxFwr&m
zEIlS*jhuQhaVgj#jDkpLT0*X;#sa1n0XL26E0b6C?v`iwoQ#$_savU-rcufAWOh;J
zb92#wCbsI?u1ODlWRR8DxjF?t6oAXMTXKm8Xp&^=3oY(xpiWkY>jSb&^#qk1j0F}w
zn8g})bPv<N0zDLd21K(gu(9d@4o4M{1ZRaKlrS;IgXq~Vm4n!GFtg%qq!w>`AA`gE
zcMk&+bSexZ9@D(S4*^tFG;^%LD~CUCsb}}p*;{D0NgaPO7F6s8?@`ri&w!^9f|}Gy
zpXQ(!Ga~O`AA!xEW!c+~&{=n+<E~(#p%>ymK~?BNm)7gqx7591`{?PA+F|=0VU=c-
zZoJ)7!ji;AKVn?Mi5<BMWoXc3z#3-Ao0gDwK+rXfV!8+DE8v?|GSEVlOeL{dq55eN
zdDD@8tzF4<(G{&3K?O*XV*uS3ehX@oF_V!`p<^}{Kc-|YHj|iYp0Jk_anYIw*g%qG
z=3RIJ8@>TA31NQ0WI!9{>?;S*mk=q$Wl;yV-lNu?ay*P`d3Cj-<WcSIyiq&5rpOr0
z$A;B@QRP3`mOp?%@Th*7asj9D%an`2j+%1yc{Q-RngqoK1q()7z!x@WGPE<X&>Hq$
z)hs4>ruC@ttZ`h$5S!-?6$G(`7x{cRPvx1bnAKU}m0tv!(PJqd>wIH_4Ob#b!_K!i
zlE|~F1br5%V#%u{dRK@@ChBa~QgQ%TiW+oH<={_)j^Wd>JiTGbk#{nX56p&qSWcK@
zu?M}X5}BK=s_0t9xN30#_6O|QWAX`pRMKU}`oCLN)q3X?4Jko_rI>N0sWCXDIjO>D
zuX}q{aclixRuoVFBD`q0BLJb0HzdTSw8@)Vw09=$1FW93Fj4_w8e)o#5uxj3UrxvG
zbz}wuJ62r9D!_~k%qM?p<x;E+9sj|`V&P3oA;q=z_>&`R?98716*x-OJn&fJC~$2C
z7Be^_Mk|*V<bvq6CQva{wX6?8Ytw4;R1<JZ;gw+kjhpY03c|s8^)5a&uFJ(d`|spI
z@}0oVSgMI9`8;Jb%yht^5LddVXqAz<RkRYr7*EydqBO@j0R7ZKbIu^CNzT9k<CPsF
zwbD#8qWnbv|D_YL!?o#KLtT9H_|pt@hKHd&6Kri7hTQ!OJYtNy)gGQM1<e330;dc!
zQ9$s8w}B2S@jw#B5_xa`-}slrY!Y>IHQj}p@Vi29LyAp?cI3|h^$wo|{3*gLp)LNW
zQju_QxnQ#UdT82spNgb{2Xnlnht73-FMweQ2uYtM9q9~CEUd%rg<tViE19Zq#^3Jn
zMbdup2Gr{4Uo*}qEHdv5ZC-)g=nmpFbKlHB2)&RCA~Uc{e{>v<14w-fr|UglMienW
z<ynWk4osuW0o6F%tutGk6~RPj(!C-@ZxX_!@E4QF^br69UjZo70hgReB`W~Uo_wwf
zO-k#th@7ZuS1qJWRf|N{6q#f6vev>VxaSjb2Qv6_*Os!H)(s<*V(a29i|)lVe~Fh(
z^xq!svAdBw(1%yS8xhra0TA?BeGpzIdxt=UQ&Hm4-Q$pc?{om-VrN>Lt|PkE65i=_
z8RsJ8hoL&;Jc#VXCsb~szY&3LLQ=8D46Y`1myUp_5p5}h8im@s`b6;#Qa}XY!04j1
zuG|_SD0$j(<bdX3P64phkiG$*Zp0OzQpGIl6tm2um;>40G&hO7+<flWpeI)~AN%!0
zPpWc`8yi2#&t|=ODyKFNDBGUqJdfBud_)PaYo2Wro_)+k9{kl@(Tc%$LJSHum>~fG
z9dxj}4I2}vx{I0Sqi0HL6%iP88zztu!c7X6jbMK!P4;`T^B$9G!dhEBk>`n3LIJ_E
z>h|vD%%$9ij*)pM@CHIwkr9hD-YiSPINp-hI+xv+s(tKFgGzPi#D!3vcMeP;tQz6#
zFgW)c9krCovA_9MR&0}{?bK<0zs%BhlB~AL9o%A*+rP;sw-Povu__tmFl1nq+aK=Y
zJhPFGsQPld!$^0BI_$SQPjqG_6aa?hpu|+hwK2+s1(MYLX#zOLgkegjneGrC&5JAM
zO*@X;welLY2^B21J$yt4D71M)5Dbse_O@-(`faKP)6%?(r!29rA@e!kq->~HW9Hq6
zZ(>q1jYy*IZZeIi9EG!a9s-Yn13Q3%3CJ8kcO}j7rV7DQ;iWykHt&3R2O$JTu|lpX
z9GW)>UpS^CV-j=$3(bb~Tb}Qri{XQcng5}Vu*S$V-<)TsGPcF-l{(*CupL{i%l<4g
z2fG8D(TaJ!E9Moz{F2Y>I6C1MGq2;sT9m=5l3DOS)4aYr&Fj0EqH#<3^G7@9N`Y%x
z5gt?1i`0W1o_&R|0RR9>z@XnI5K3K<z+<j8$DVFBN7g&{#dN<Xru&62-E`wz8en|#
ziv;770^__3^Pg$D?@QCo@-`=7xy$KbNQO}Mch=cbi8(uK!;s_^q*%E_%r|G?xgd+}
zI+6g8dGMbxJJVqah;qqM3C6|hKwU;;bjzDK-w{$c`6En4#bbwx4vycVBjQMjNVK!d
zZcjinAGc5miYeTO=q^ui*3ZHuIAVWLtr7U3Hszp!Mdi1<pn>uBo)gGO2gMENMLiP?
z9SjJ2ZX^M5WL{BsGn8R1_RbWPo+OjVaLZQf4D2|%2?P6p_QyOh=1R7i0^6Rg`oOpL
zMEt;oCH$;O(tR;J2+VJ0+!Qm=H7Bhrmt;CW((H9v7BM?!uk8O{mOZhRvknl>{M#H(
zJ{#oK-Ns(Y%Xafx*Ur-o6$iw0=na7On}vaaHpjf39>IC2J50S=f56qAIfunB274H=
zBuNGQnxX+4S=o2-Nv!^ym=&fCI#BOW<N!;%7!N!^is~Gjd|%{;;(m`t0}x_kde);K
zfx-}vK;}lOmbRU$Ng0in*wPS*WdjYiLuLY;OIoWZ5thCJtIm>px*T$@o2pk0!4(gp
z6ox%gd;HYAC`%_Qg=$_EE23syUc9Kx*ce^&cn%3Lsl({n9Mt&?E-OlHkk#P;B+C;8
zlr<fG=*vW=CZ`n+;0`Py?BbmSpeOU)#V`@js0{}&ZM}3=;Q+Xl=Z<<YhXWu09$X0z
zgA@*6QHC<z)}t5zSMdht*6Wd`%doh(&?yo9TBDKr;u%PB7LL#fmRg289x^L&=D3}J
zBQXJ8Pry}q0><)bd;tL-MAi}V@TJOAg@@1TlHA82N8(;^$F3CM3XVWBk=<PAQVHbL
z>(f*@R=j)Zl0?pW%iMkeJOX~RU&^ec4#LQ~#?)aR&Bq==z_UmDxgSH~+uJ;-gbf*Y
zW}E9hBVFFuS72@=`g3kq8?L<JfuikL-bfhZp<j~Xyohm*1l@pMflloixzO?<dG49G
zjiSrf9c0B4`9r{Ozec@_)RErhJw2NJK-vE0$=|1wXD~s^X-?2v_J7OK+nPDqeQ_g+
zqqnJxjgMLObYc~M3v8e|dEe1#f4bjm;;!-ZL-87&t$?IxKnO=Y&G@FHyq1>Qp#O_>
zW0r%q5H2irvqy_*wX&#IW}5?9LS0ltvs^x&+&dN(8DN&g_}#dvMQ!H74sz3;)jYXW
z36BRuH0c=P_VcE7GO60j=BxH6_cnxSz{%1y80D5B?ydG7?YxmKyW*f!M^!=UnslNu
z61;AZ2tH|;k-!5gqqc<OdkHFy#eHw{du>qny&~9Z?zh{Z?s8?rLbA7cd?ZN=inbRX
z412ZK_@1Rm3+h<WXn}<VP=5NqMp`Trd%c1$MFx)Z_iLK5h_pcWN7rplbKQ*<l`fWm
z`E#F2z}#%`)(o0wa{`?VU5CM~RY$grJ5Fk^3B<1opq^cnmAGtP`Uz^ZZ;i+cS}_-T
ztr!15o2k6{%t9CK^v2??{!JSm`APr!vzV6R4dg^MMUO@J*LG>~m28h?()HbtF7ye_
zg-O<8vwH8~C@aq8-&bkj?;RYm#U135Bruqi2)?Yvo8p0VH>O_^;a{KV*!AVxZYgij
zn;a3kmEVdtoG74tH2j%DgzDzv#$?Igu0{HCdup+k-0#l8b18qUxbfy<zuvAdZ@8u0
z>)N}Oyc^YGah2|_i4`Uk%gdI6n(w4$4OY`|toZ7|Q9Zs&bom%_b3`DxtlIb9QZDID
zx@NJ5H-and;?a`@Xjz-?vpkO83|cH}>3Td^+-V;052i<kG^R&%b`-LfflIZuUjVn<
z)clBG4z&C-VA7yi^ZLlhs^>M=x@t`r&avVhFhU-GH-_^T4QIW0>j35=Pqes!!7JrM
zGt14)-RinJ&<nuh4Txs|q@@9PeZ`#+(Jgg|k714)fy_-=sbV$-PjF@OjF}PRf0xj$
z1BbsArJ#8U(CnbDOS(Wn<L?8l-e7mwB{j&%G;eZ=?c8&M(_(gxeYc%sRp(t2)o`+v
zVVj?`pgIru*hqkd9n{V72OkoVbIp!mXFRkrI|R5On!+kLBhL4TFOpzTQAY;3WGz1T
zN=CfsSNGj=O}K-Km|>^x&`#%++MxlFb1tV6ER3`m_`XBaE-xWIO{d5VOjXEt9a|rl
zpzsqG(b52@j^FZRqlt+agHL_WFvyrLL^=jRA>Gj<)%ynV3F+Sau~@9W`zjbvvuHl@
z<B+Or__m>!7ynlX&L#2VJ%Ukf!5oj-gR|E;ZtxzDmK_`|A_LfC;*EHoe?x(Zp}?0?
zeQ~5AI-|o1bvJryg`ykBYavPmRguS~DhA2bwl>O{1%)qd=CLo^roj)}E!fJ{a5XY4
z7pFO|(J2uHd>1NnM4@SyfY;zeQSC9$W52c8DL>W`m&Y~Hak)jRezb`)e#pjfQk!Yx
z&B<(v-b4T6y#8T{Nb;4=!nAs=^9}qCkqK^jW~~2zci@(Q!79?zthaFbW}p1Q7W5Eb
zxn)J_6){0fTi=X(vor**A5|)N1{**aOwfS{3=Q_D5dEmA(w>121y9idG(z+n=E0Xq
z=Uay{YO0N)hKQfc2bdP$bE;HMnK5ED6fzdBvZO{E)LON{oLCUqbok=EAohy^a?6!r
z<q3hW!|(u{F<o8DQuGmvIq4$*TcvxE`=1*9G~Ryd>r7T#WSGvHUGdWmclSSDwxw{k
z5S}x4LU0a8gJDWgzk>#i$Gzb?o8<jTA^ebuKk=`&F!4uo0yEY*TKIZsjRo_uI4{Ay
zlaPRBB0T7<7rq{PTqG1k5?pyrr0Fq%h;9|gWWQy_Wl%^tg;s(RDR@F)F&b%4#KQrW
z5b*|r(3EFAd+1`5mLy?liqH)(CQ0l<eOf}5^L3;%>edXnmQ;CVf=s02?7T5GKpl4&
zpb>)arZ@<>D1}xFZ%~et{d=lOBv1CjUFjqhFc}4!o}{4}u474vG$~POrWp)>!&PQl
zNi-x+71tH13Uw_SoQ7>ll+5VyB4YX@n!t&NOM=($)~2#7<^8{eX2ehV?(`o|KZERP
z=4L=({^Yw>+W{ZX6i<ybmqqj*{>e=A4kOh<Qx5yQ^x-7cYPt?rhmmPdbnnWMWUOLG
zB$<onb8+%Xz+|ZkQP0C!esuz{e>h98PGC_EXW5m6!?MmO`b`#DE@bKPhd$ovocKUb
z(PlOdj^JWwW1Ih4qynzz$Huyy67U;w0A-o635nR+5L*K+@8Bmi1#Zi3$3dMM=eN$0
z+kf!(Tz3RYEKuomah$Av+L=AU>lwTzcs<GM#Wi-}-#55kse1_g!t()kf)qdRPj}uu
z(2m((VwRAD1&x3Luz2<1ZL)fwuCKMOtp2YL*7Z0f1D3Y@30Eq!Eqh4n`O%Q=J90y2
zA4g{0HVG$YgaF-I(k5M|k?Tmh!ORKSzoW&ikCSw3PLjXJFC&uVP;H?<oCnLr$T*sG
zr@Hu!gV(5V2O`=025tre?|pdOKBpr!TlTndLGS&VIvtlhE+(Z2#M&hGt)hY_hg!Np
zl7mlY{`C(7hR;91pG6X68*uDG1|OvXm2n~xfFvP$xcDJyGHOiC2!X#vA*qgIRe}8J
zaw~9iMz}eiFUJDPW`vyMO}ZM(31H`Vx){s9tp<&QdO{;dvD&8X`lg^3;I74<nd&AX
z^NiIy6=U8J7-7m+9(%?mkGOgEdl~+j@5;F3n`^h3v1(Wfxz1sk&gDV@u3`lj*EDgR
z<}+}r*H+hqjUrB{{2j%Osb5DDU=#k-oo0ii8%PSlKrm8W?~fNt3Vc5+E_`llIOl|s
z@@E0NFC))L`NHMTh*3OkcQivz3o{$F1dj~K7i$F*lyjz*6v*Z`4z2mO_{;guiSC7(
zZ(!NrMxG!Zk`jnfD;Npsn06(DJc8M-0t&0<uK~F-wHW*F(?i4vj|$%~6|Kguz3-pO
z3E&AlryW!!ge9RJc%@*9B(zh5qUS!JswzgK*}aQ?V0qlZ1DQ!CSY)JZRZKF{QpiXa
z?m5EHM+OF_6<a_u5)%E%S{^FMNZMMI=mOSDMpCL}Bwj{jq^tO@Pf13S{EwoiN(T#c
z02v8uAS#Vzq-idc3}X{+(-<7}CjytMAx>_oA*JeMnGr3?NT6Wb2DKt1f%`^!`Cm&y
zng9argdP$S8>+@%8QEk2XMeRT2??C-*ZV_4igd8(^>_FG8S+H?Ns^3;z!E>XeLAD;
z|H$x@#Gue(BnA;mL1GXIb`D1sTP01(ncO6k7}S+>+Uzo;6#1~6!`o2KLDJFcn&XQg
zB{^rZk{T;Kx11x8vh+cy#wyD>XkkgtvBssdlFS8!5IN^6k(nJbek>(9C*^779Q^4d
z=NKX+=j^Di5)EBSa!v<uOLP|Ez=m}-q_Y6x(GGO>d`W5r&asmQnd$QjZfhzlKM)ZM
zxdQPgsI0f_UD#CC(0h%VVLwxS7NX&CS^`Lj?m$U4j*DaAPNWChG1!t3+832WPQX0g
zJ|}<kZonp1aqb0VCh*flwW+VNRlH<Ho&=k58XsKE|NVxlGQ3(+&C{u7#?Bq7G7Iwv
zf6D1px9s8)tMD;U-B)L`@KrVot8NVfYJo$U38z>N1#BG`?Amc5TgTbFmukHz=$#Yl
zoWmtlHV<Tk>Z)uWhd78p<Y>8bKFQ-~xpNAZSTBWryo+sut$acaV$Ee@h?l#h6Ebr?
z|BmVRYF^pr5Mu6cx_q>oDJjT+?EO3N;y8IkfB5wg;6pxebJrIiDsL(8(W}<C4svvt
ze}6(KDWX(-17GE#0|FNVeByM9w?@R};zHH-(Q>e&=l7NB=CR`YOZDei@dG8tm-3MA
zRmwSs=bCH2myYpsOE(_W3`Gy_<1N~Trl_H#5~+*9F%_e|BYM)_VLfRN4?VXxcv*X>
zQSPrwb8t}O;8i;at`PA-KOt2I!n}IG44Gd5w{Ejm&N-RpYc-L2-2566(Js=NPhe%!
zWXf64lWEGXOYG(vrqUCMgDi7i-g8U&MpC0I_|vx?#0AmAThNo?k>A7PW_AycB~;L;
zZ%`0py>;&*RwKnft7X-!j&!Dcu)L-CnkeuASrT2~K3Ny#15#^P2wB&c_^bg7NdL%-
zbCRXpagx-)?Q#MVkaMX<IeUmgzO;;)6gb9ue?(CZ>EMUcx__t~>=)@gps~I&VzlaB
z4q5*cyGQjNm(YJeF<SXi#Sdb%GB~V}`ts%ckU`Nux`bLyLsKxI01|(JM9pXj{_zIf
zK-+Ar-yzx2Sywha<Lw9*ym%u7?6G*0Ic+Uo@jj}S;`LW}HMu_^K{w1!2P6gRY=9~~
zb-J?4$${qZ-PIt{4y8D-2bzPZDv^fVVgum;uB@*dyz_uIX|9g1$%0LNm=abZ?RRK|
zd2p=S0}c$z6giA71dc3HzrA`9igX03XJS3TJFiE^LjY;N)`#_4(yA<pIka%j?D*Dp
zL%jKfyXsw}EnN-1H3t!tsEP>$&!$avO(j$20dXe{5qWl&m=4^NG!l9h)!@kzyex%2
zRzINL3Vize5u-!u2oyj68s!gffe(u}Kvb`RY*Phpu_@y<d3N~3JaLdBQ2836GUQk`
zOFBKfYo@v;`aO~%OpMoPX|$z4+0o#y92s(B&%_DPu3!YNbF}kRiCkZNE7_%!EBPAa
z`nGLplW1L%E>V<GG;UO<#T-Y5d!zeZRY`%UH2P{(c?q@}3dD_S$O^=bp+Hb0{gpFm
ztP1S@^Dy<S3z(aS2Jt-nJuH~XK{U3eBrv#Pl=$PrVweD|LcG+Lvhpw|x&IQz!t3*D
zAil#S@M>?K+?gp#r+I<2CDNWAN&73(I3d*hA!(sd66S0uMZb<8tpxpAezel_9^AfK
zVS9=nZMIJHi{M><m=(3+X!p|26Wz;nlq-iNYD-rkKAc`JNKrsB=>NRN@tHN<ki0u<
zx6LJfPgchhS?n|${2s5a%fD6iom8i>qPp-Gl|z5w$Bgw@@pMmIyi>jAO+dg7j(Ei=
z5wTMh<JH<|WtTatnrpMlA{C}Y_|So`34mz=(Y(LVL6k{i98sJg8WTe?4uRfc99bmA
zmCXa+i4-Rj_^Hzt;wWh$&eyh2j6$2EqZq<m$)SL|37`#CYeEL5Za4%Yg>F+?4W}|)
zA)agM3RVG9f-_mmb<rzzIRl&e8X)>0oevOAv-xHw(tyR^%e^ETvzn~L)4dZcbgsid
z8CIt!9&RfUNK*2#wb7EDN7t@U@?#?<X>I$GEOLspY$%8}KRHq|+I*$GeY7q4DglPx
z3H+`lqCg)D(h&M=pyHUhd=1v&`~<MM`^L^0C*0V%pLFiry$_&T#{;R0EdZ-H@`3Cp
z_g7<5tY(@+63RQ0G?5kLt%K|&LP1^w@L7F@3_#S!u$y2;33u052lF*HHw~iRWuZyt
zd5nX*5;j9)<rT&6KzIKJ(Bvqb@;i(P`<3n+X0@Z;v!Il^$-X_9bv+=Qy4JB>U;uKV
zXCDE#j!;d~vyX(HeWW^)_9Bi*&ptxC(zB1WdlBLF6nhb4!@US3AOxooJ^L`Mi<GQq
z9|1E5HT9uq@1+CV>)8Z_kY<FiDsMH(tZIm=)sRxX7r_exggv7z*lya3z<;T8iiK4e
z3iywAA_#CZ+=*~poH1!C@@``9y(2wahU@xh=-H9Z9D}s|9~=E96PC(UyZS$f`7D(I
zP9y==v7cMFoY|2u*q+uYR*P5oiEYxR*~jN!(x!QX8Lr2!K}~XK(>nCd&|}x2_MWVA
zZq}xcNSkJVOQOO+E9hN=f!OB}RhqTw!_uY)l2?u#ja`G3r`4thn%A*dcWKju>abw`
z2;>QPVdLja2S)>pP_Xusqd0L=yL;UW!U;ru{=yxavN`)PNU<$ZFbLtFBx+*Zd|7p3
zwDbv=J_At`h>Gsc>W?v_k4}uScLD^>x7~H**4I}s8extw2*Yb@KKo0^R^~f=;aBE8
zCZI3pKTr3lf&QBBTt?}|F$fEY3|eFTg94}FzY5Ri_sAlUqR_Khop4W4=-G+J(O^<%
zDE9FHyUPC0vI%mmSQlI5O?R?SN9Eb#6=vZU6WNv0uAuBJI@qPCdtjn0Ji<gYxMcBS
zN)m!_Bxh*x0uo6d!9+wzrDRN$B_^sYiCu=ZX~YtPohHG~j9|y+oeVoZmNp~U!T#eN
zr<A9K9RxtZj(aND0dEC6;{iLGH{^mzH9x66{<wwSEHh7?>`u)3fDLv<36RBdgXQo9
zIm*Hr&WjVXMvPWYsTg9Wv^0*XjV;A}#Pu(H3K=*G65$i%O{jhVH2h_=@DFSXyAK1@
zvV62`()!jD-FNG)Ig|9)Z|2<-e-?o~_IAVUe6;vxscrN^aS6Rn?><osv^4TE;DMJx
z_$E3uQCPpACgKmG6f+^R&&2%(-hj()23no|Go@TTQoyluzXU7a=ps;zH~-NCz#D>v
z4|giH-nn0L`Dv=PxJ=h%Z)YW<0pUDLp`{sVF?4_#=>QYR)O^Z1fEvQ)EfhFbyhrvR
z#eG{Bo_TecwRDj+o^$;_G)%uohi_$<;_u5b;u3jmf-X^xCL7t<<@{?;;68g37O|)c
zjHk(q{Pr0iW#lN(&lrCQ?M|w~xUJuffsP<dCKJLjmuoItPs4yQsa4yq8|ztUQ5_*{
zT{@rTq)9`E%8sD3!YRLJSPIY#QRnHAVz0ch=Qfv8R2$((2L8?6v*PjMNQo;??y!SQ
zSd8oJzt}o1R&=C2^nvY1_Rz};((Y)%OIIj(p)J^}4uWnRy+t~b$}47GSURZ7)1bFp
z&(SD_cqPy-R}L)p@~ji;Z*oAVY(X|2K9wi))T@<*pJ`>w&Xt)~o<a1YJcG}Vlw${H
zdv?{lM6RZyQ`+hD%^@HAkv#LV^<vb@`>6~W{A56gmJ`HEn63)*o7fwm3bC?@{_k{{
zoM}@fKzz^x8Sx*1ssQLdLDi$4_KqQKXCBWQr!Z+f|A0C%xk=Mv&!Yc}B`KJ~z`<Ca
zalVVEH}K2mqYOj>WvK*MX7jx%!COuU^34ZF6SO6%>}Vk5mo6OY;6xv9Z3*I+cE%Q)
zRMSrLM`*jba<;Qb`D~=*4J}fBdzgX{TRe{bdI2$r<=1?1#EuqF4HuZUF(AhCg*?S<
z>yTNe`D?b>CM`X;O}$8xB2J8`$}f;4SD;pvmNc({JSS=6G6PY#pEPZ>h<LBViPRAL
zUIxFqM-nxpB*ihIhD+MR)^=Xnc;lC}gR;MiH}rkPgV2S!3q2L>g_vh)9l`xMw((rc
zc>s=mfY7MV`x-eZ8EleC4nlaJFoNx1a^mQO^>~_Lx<@s6Qkd@CPwDccuz#3Sq%B;i
zlL8L>VG@uxjJ1CLKD9HWzO>EG6D-NawdVW<VE%}zW=r2Ne~FZ&vPwhc(}ngNl}dVl
za$BA8>9%C{L^uqTTGhhLErS;b1N0l0h%y3e9RQ(xiIbXmP=1mYDzuX3TAUO(|98Q^
zZ|pp*Cj|C<2Z(fJeXoa{5ROP@5DYP=*V@Z~%#h<lbs?(-ZxwLnnc4y@noetjBOt|`
zv!x@oEdyQxsS7ozOl9kc=IdN=tc}JN=edn1rm!9loSy{e>60$p@xap>h40`H0Db4q
zh^GStCgs$Xk4AD>H7qlbe8&iq*8}Vo$%{caj+MXNMb^4u<hRz5!BLR01;5ApxVa9o
zTR67^<zP7UMmRTV{lRFZK?>)_NgBa9)Q`Y91&IoTKJ0l{+>fzpfQqF{p&7`q?wX`_
z+Bvj4TAw}hqO(r|<cbTMVcZriq5KFA%cvDPea@A1dRwA|wIVm@6lsY9hcT5^gEWDt
zd#UKO&iFDIfhC|WlT5Z}fx{D{Rx#0{b)A0hHtYE|P{leL#o-<83So(hQvxQE!re?Z
z+>nTc8w$L|XNFBsg%%n!>kVAr9)lnI1Q>ixj4d$u1yTZoOI(f42rD0z$oXoy?YS18
zI}JokUgcvje;!j+ak{zooBG#yOOrv97Dw&Z<odgpGg$Hm$z&j*ye2g>P;mWSLRn_-
z2{|NT$iGX!72V&Me&>jmmJt4DQR=wlpm`7%qZ@dh<#`oPtYK{1!M1Tl0-~F9xFQ|p
ziQQ^&jOR<c?;d;^&lh=$)O{L1io-lFQ!e@W)P-D|_Ed!^%4_+?Iz-x`NP8V=Vh7G}
ztqRkb>-a{o^+bIzKi6v-05+$q*#Pax<|M&z;D^q~@@r}!G(x}yer7pp5fM}*QIl{@
ztN3DZDP-%y(zW3TD>q{1(*$x~RQmmxI3@b|U<K6*$>ShY=pe{qn{*5SER`ltdgXh!
zy8STMBnJkF=|NCQHX4rK$|ys~7l|t}&#><R#y(wq6Kl@z0?&o=UZNIQdVvaB-W?B3
z&PFO1avi97>ijpsTT!6Ut|T^2C>HamwFp~?;^p@GUu(4wvlklI@C>l;j3AMY#96oS
zH$Vf5^KhzkkUTYPQ20ji*^nSmk{F8)h@w-eiXQVgg-gY5228tJ6^ZKy0}Z{sk_WAh
zvql;+yMgFi04Xvpfo`};K}?8?6~a1nu!@5+lImosst#(L`<Opo#s=i$!(eYyST;Pv
ztl%?DwtW%wj3~GFGGG?DnIdqRj#@S6AKU<&n<seW!&0mdoJYPLMd;x85-%Zf@)$-v
z8!h}yTX>4fPb0Sa>arrjp1H0mKvuR!Jc@CSMTixo)%ynpeO*-#D>~b4+PG&$I(|?y
z!Odk`Nr0DvQR>fB|D$n8>Tj$FP_B)Nrn76tgTgxFJbn-bZO`M%Es&bfan}Mck@mT%
zk^=o7?b@e8*{ttLSOSl_w2#Iq8-OFGy_#xeP*b&R|81={Dy_P%wp27VGL2WOHi5LW
zF2|&qy9ZiATziMn)BqM)2neLBXlk4<jhO#LQ(I-%B+z)!^^{xlR-gb2x}2noSC33q
zYm)hUdLUf@8#ddY#N|C*ucqP7X!^eg*!U$8bQ+9b4nU+u=91qJkUaAiccu-UMn;88
z<AYGzq0?p*I*oK?By^g}(05RTW<exnr3)I3VyC^9#zfK8{-uAC+HW4@ts!)p5;o|N
zrbk_ufy&PNvR$#bJRCM{Y~Z74pnM9O)*}{?gZ338u>bsn8TKav+kjX~q_AmYK3(i8
zKxyHGK4~a3n^6R3(hlpS2vYl7K$fJK84Ix%y7yF&O9JXcuL2we(wO_+%xn=--!KZ`
zDQp_K6%}n&FTxEPRS|V=!eP_)N7%F;q?iwMY%GUOb5R{+-Bfho6`XL`G<wLyVc4nm
zE8>>mLQo#3Ke4$oz=4pBKb)wQ)+5C7xHZLGL4k!`;K%7HFvWve)k=b4Q-*fX8;%9&
zGAXO%ohR;0wTd}TVbe5?a^56607&f<icYwyxM>(L9j<JbK0`)%oE}U7%PfxGkvn($
zxeFV+k7{^7Lo-mP-?Do1dx+m}uE+OKhNjR2cUQZr@jWyr0ef7K*we6WA?7my4|60l
zpa2n!U~0qOF$DLnN27vUU+&)1+z*M9h<!3o1%-j!{Z0AidLs3Kf>O<8P=kKCnwsF~
z3a7@lVf?0Nxfi(WD>{+Fr;kNEwSin9=EY71)g%DLTQFpHJUgf>L4JE$s4=ZBZ}7BO
zJtk4?h@T_z)TlkS7HD2-y_nDhN>W5Vo50gOnD0b$@gHx%kmQN=(Qnt=DsSdc+6!%7
z5+*sG8fYNr>Vyq#Jhj>8hE(Y+JFrpdY^qcj&_$(OOs7xlJTSGrAo3HHei5b5v|XBK
zzR&5GNtuF<`<F>s2~C3HslTgh)hZ~D=`doc?K3U|)QS-gS(=rJ7r|$t5@QF<f~_C4
z7%yo@Y<C}l)c!6a2@XRaM{Uz+9^x)>k(XI2;-UI@Eb+ko<s{#{;X~4)$fr9QwA-XP
z7SZHg+*R^fMJsX<)PbOVbfUKB<=B8gOBARTOujb&BnKsE14X@_PB^U2g-Laoe6SxV
zkj((Pph4$+!Yb~G*NJBf0gB6xOFJmQJzpxxirUgy^w-3Z&X&y~NpHG`6T3UDaf2yx
zrRT_fFQ}MvDELx6S&}R%bS4>qTe2AaGe<+Le`vx-X_|5{Auyb^zoPD2pzNR<;+!v|
zB}wx?R!?et^>hSS<JcvX%+qdVce44|gafP*xtBwn4!s1HNlFEOj0^(Z)LE6jBzDxz
zR%&U`Mu_Iphc}9*Y99MY;uf%VO|K`{QPyzWf*(pX(HJzj{dd5jkfbh5!qx&7cp4TQ
z92qL1<nvgbH2r`GF{VX`?IY@aD<Qwv21|vnYrN0_vbw1@o+@S{E5EUN+FqgiiM95Q
z+R__MZv{garp>Ovkv0o)P*?@+?w35m#A1PonU8tL@Lu%4s*+zDJo#mx8(Qjrm1ko+
zU~|X9=CldQEbypRcGH0q1C|dQ4Pna=>a^WtI1Yz8Rus+a-<!dX?GDWTMSqXnztKo^
z=a6wgmH}afq#%(*gGfOl!8Am_cxbvTu{%j;XxVUD(xU-SShzws17L82HCVgKZy}BF
z5p#3<RYE|jKF3%SZtfN-j(^QK+G{<f#<LCA-Puurx`SbiHF&+ic|O2dd(87pJfcEv
zaArHz&)tw{kO;7@Clx7eH>8%eo)Tz7CkB+@)momSVj7&~1<i{ScZ1Y$Xq9)MGs>?H
zxOosjuUw%RDXX$e6~d?Z-XD}qBDM;GJy4~lL9%TLTiUC(v@?Ye`|M*IMYG;K_^Sy+
zM76XR1M~NOIQ`qJZeX;66EDyttSI`RwS_ecM{BhU?QD^9cTy$SDS+#xYO6gg{+Kka
zCVSpA6KtCw5|--V4jl$5J#=srec7$h-auN}JWMiZS}^SJ{1*W37NwyRtS~?1#B+(s
zH9aF}wi~2IH|cVjj*$m+Nm6H&r6uijoL7WaxP@UU^>ug5F(YMiVx;OAXD~=GIqD@^
zM0`)#^70s&8k$uM3dCkCjgHjz>F;O8aqZ?2+FPMWZO<!pz4_=5q}1lI?;~MPbD4*;
zH7_XPb<M-MT=VcpUE~QKQPF~t0AUU!sM$E20D?v%wP{5`59O+26$Sv!px3}&x(I9Z
zvu1Wp+`vf_niQ%H<xB7tv4)r-yZs4%9;U<1?q(zRyBah8uZ9(JHu(px`05dHP~No3
z&BW~srYwfBavPL=tUB1|vXp}^iH5R-xPP0VKyZo?L+5UMf+rhYn{!TK3#>Ifo^{H`
zFa-l0+lwc<XRx5rNEi%l_Mk3oHT_3f7;VlzF-d~9HHzkiNkeF-!JgHBuoLX7gi6_v
zQcL=WU!y`XUxNuIPdCj#$O^I`m?}CD+)6YDuNPIw#^ryd+)Ivs$V=ab-wAD)n76=5
zw3F-2a~Z#UIKN2|Zm1ISmex&6lv@x^r)DTJY-SeTKqFIL2yjKzZkzfsy@hKmorhgE
ztbE|FGt-dKN35}k`>a)q7;A-xOE(kBFa9YD7<<|%`4EmC{r{Wty-meg0X;dfc%a;R
z9mmearR9}ftGn0s?A^Ej08DQkjzAp3pVR&eUMx@dW)BEbaJ`WgTMe*b|JmN`ex<VM
zy*YKCQaN!SsjTXaoo9NpdzH!^9g%8>jLW^*Jxb-ij?H;7_H=Z2$L74dXR7ODUB;E8
zsIC*`9%F`+$@n^f#E7-}IxY7mQ#DRp3<ONLR=WzN91pI=CQhbZ*#qp_s3Zq(;kzq|
zK!xPzE+1EdFEEvWxJ{ivnj1l=d}U_1Y%D61&53y#3-*vZPbf(7Tt{}0j(l*R)8<MH
z>IGsXwOJn^UDu(I6)b&i+vV5BxZ8L$uiet+*S@UF_$xd|y{}O#?7|n-Yhu)|&l_B?
zi7MKy(APv2$Me)CgDm~Qj-PI>Fp>jXL6JGlG%|3&Lwqrh{SafHO~Az1FRry?w=K0@
zqm4BUKjqHDCpW`?T?~4V*Xec9<8~5W7d>v*?R7LcvS`e}ML_C0MgWOwM}SK{Yld%o
zry*A4W>~|aY!nIb*(dAH&51jm$PG4s8-T(So|^kJkUI(VkURP42wF@K2VwCw-KnSh
zzrjy2KXrr`?8YKO>oUK{hyV((DJ@Ql&Gg@wc}=RBH_2;9gwi%)L>Po@ey>6yB-l*A
zr4V3bGDm#Hr=<A+F}=t$^LA_-uD2&@Ankyk*$)mz7+y|N)n_H|BWp-Z!j>YgW{aM>
z$`w(HX=!!3gXa0c4F#oo>ANz6mHL0_L;OlxB^)(iQn&{wIg1WJJwuVm^jQD5OL@N)
zjDm;ECu5SKoQIo@MWK*eF6)UR@eEJ72T>u{38h6fcyVxo#5sw}I8pXCO}mU<BK}M^
zhvI*agVdV#lJdOFO7hjTQ+=W4%|}cL*2QeFc(WAL*J*aS4el%&8A$+Zcrc9hf77E-
z-3(?{wPBq2LgT?UO4r$*8m-m@FjxDy>(fe8?UJjFd$>Q}H0^e^Xj!Axn$G5Gqqn+9
zoodC8UrBG*TrCIBMyo||7hQ-I{Vms5MYV@q?f4g*ggvg7BWt78u8&rGmwLG#wO;F5
z_e((kyr8nzwc;N$TI=!ATAy@hk4LpPxZ3&)R=dyDP6*g!6j|E>ZH~)jXq)UmQC4e$
zwk{CH%dGa|1#J>zI_PggW_-UmD8EQ23Bsnx!PwD2W;Vn)6(G%E0U{5Xki!Mr6~1Ul
zvOxJhB3WaqF1rLZQ!pwJ72{{;RQ^}7%Xq9HV@tnvI2YV^+^#!CyB$jGP6BL6hBf=W
zOO#vrz$=0n-(1`&s*Q-$EN7DK-S>%RZulGYQrHd2m<7Rk_|ZL`eyl0@+?_M#FWTi@
zK<f$KrL>lDp@}opBmii1Ez4SC*mXf)n3hEE7nw04?$HdsR7@E-A@23ZvTocxSgN`f
z>(&)*ikqldq(EQ}FM(;}nLZzP#Bfi0rq8>AO6=(W*A=n23#wYz3-cJu#_AO|%Q7K5
za9`L$o0qhl<ez2bc!;+9cONSbnW3g~QIEBi{el&gV~u7-Ym1y~^3Ck)+{}z<I0icv
zFbyxNCDCw5^W6iWC;zL~HZQWGkB5M=OH%uk)_IrY6XJdIDY@wMwazIkOO4i}tSq(S
z%eCAX@WqQiEu|oj-z_&@;74)`)vU12AaKkN3&lPk3&hU8)(6lW;UPP;F1uJ_EKu9=
z5C*!5haB+2v5Pf|$0tYe_%}<Dhm(QFx6+AMLdz;w%j_gh@@|Oyz-dg)NLuYQO$`$u
zun;#mb()`<=9xI1iq_xg*1s@uI;dJDupo)02u<1;FSVFsGDDzC=yEt9PVHum0|+!i
zI@=btV59lOlN&ydN*BjuL&FkR0R!T=801i2`u`{6V5*+)C_-Gv9xi)%;*P?|1m3M5
zg`_B1$~hRK`^mja{=$!LkVzZq`tpRH{I>9y_VqbIqAFzdy0LRf85mzZ&r>Sp!Tv=Q
zukd0=b!`6W4{tEqYQBGn42t2PJBKc8?n{c}a2P$aI?~^ZmwY&A(bq52#Bdvzjh<fy
z4yhSxAqcFK+{+i)t0r9zEK@_pRY4%wnDL$3=aCuuP;qvfADLw84r)-3Om<FTkYFMD
zYMILhrRi$!b<B)Bk4<K$03AXj;n86NzdoIRsld~qeUHS;6L)g}%HqYrV<^-xhJJGa
z6qizeS(`HXD!=f5hxC=w$t4kra-{d11W6ovI_YGUh-+j|elfRK<2W^UPg&F(OgF_q
zdny~SE!_E=vzIqiVDROg_mklio0<elt6zUx@sAj`9rj0J#Y`gf0fnuLAI4udwpzVj
zvodK<(oOmC8{J&s^?2vtg_R1Pr!qELPtiMEm~oqv_2f2ylxn|Cht7)XraQC%MZ;Bd
z9kNX}=c!W0FAwy#4}6z0NtDH*y~=yp`VG~AzKV2Oa#eg%`3+qxzfE0GZ`Uyks>^A@
zJi1A_y5<DsKhNCZf3JcwgPWP9FVAzs$+R;ud+Nd@%&U3vk35_4`-S}Dc=hG&^lUCd
zTbs&MUmnxbv}Ktg7VQ7eS%S=Mo+ZfcwzG6R&(ckN$7h+p>+MuJIFx31bZ%EqbngNd
zZa&eykId&-*hxSz=g`&*39U>Zhj7k}ch3lZfQ^TE$`v9|!F|lH%xikp<GeBgHiJdx
zvNRA~7TRdvkj4gYs7kwQOx#usZta?@0y@5AZc>0XR=wdiZl3&`9p72sLQM!003ZeH
zn{)C_@2{Kcmg?r)s<ZWN?<dzy6yg2m_upTix~=-4P9gv!W286l_*8Xsb=&*Ne(E27
zif<Je&OUJe{W>8tQ7x)D#yM5rT-|y<HR(`YDt=RS3x##ShBPX<<sW|P{`&{F3bx*G
zhsDUYYy51=!ESvL5)4LBq(swDY+A&pTW>4As@nZNwv5AY+4z<TnvejhLj_<*tsVqK
zLtbjlCDV)XIi;$%LXz7xdjSIANz5X2<g0}+U#-0~cK1`6KycTo0=LH!2@W{qkieZ~
z`hp~ZodmDu7a|El_JFQYY!C2aEL%r%hA|4?2RBJ@+Lo3i*wjP>2^0Znn|S%;oDo%X
zrS&Zkw(1rL*FTyoE6pae+Rlq-ezZR^H#cM8<r1Iw&e<983ryth>gM_;=KOuWqtF{$
zUdZTSu3U>q3X_mi)W0(<<ass+0OhDa7rJsdC6-v*jBo(Mvce)!emJ4>DI=ks&)dqu
zttxwKz|Mw6a4Za~+<D)egK#zv{~s6$9+yR}FR>kf<8!6#K2uB>$=o->qsUazY6Qu2
z(UO<(284!v_nXJfho6P>h9=T)e%UGiHd0FE`FW@On_)_I@M!UylPAib(gE^I*!_E%
zMfY_;=n*9&J^!Sh&p|n6f>94@eqW$6pE?h8=r`w`(DF#G@bv^gGzHf^g~u=56en-a
zIM(GWIMs%2c?xzX6SIzemPk(=`&261ZzyJHC&O5m+$Zc$AbmE|$V|l4`D$9koNZ!V
z77FZ(X+(ceI8sA$)uSP$a%uuAkQ$OKiB-v|(FVi9&ee@wK~*GEYF&cxgq}nG6e*xn
zd?;|kA-Su?oNgv{zO<{eqD7o9jda%j%;equAEh7dH<@HqhHrn)w~t@p+jD&T;n6yW
z<rDyF+xpmN{fh0sJV|YD-2T&F@afyyPbg{fuR~>(w9P&dGo%Dfg*@jMN%J{ZX}A$Q
zGonUu9V`=>&bjg?Q(WQbnCxW;XbQ}DfC`fx=Ui!mx@C`(@ePSyb}44pXBC-6=?tju
zS3Ij|AIvXsR*@DqomG@yrX@qS)L-vh&>irA{AI)Wr>C>lAVBYYa+=*Ep$Wp!=YB{y
z{=e{NSM!n{YosFv_kXIS&(w4>Dmur~_M5nJLOar+sH%c)oYno;$i~D^B>RK?!I-%N
z&ZIn-0K6xWVzuWa3uw0uClwH<*|*Qa6+%kkD$hh3O>k1&6jDk)nmUzQilh(l92sbq
zg=kx9+)Xm-xP07rynT+N7;T-C;;H~WCRjAJy2zoV7V`}QvK;y9UizyrQVv$-KvIRU
zMBtPINl^*=VfAjI&rSuBx{KS;cpRq~abizvHwZN917K|&shy&U%*r2g3)ZpXE<STm
zkc)L0Dz{?2tL9!^Ah#JG6pA9X6AIzTQM^%3uS-prZz%M+rvK3uvF*LH`9sKcPe1=#
zk%OJp&g+Y>y`_Ao-X!`ZnSskA`Td{xU6>rdonO#T-CJ4=cJbqReoW{G_X!^>-i5V=
z$Jeoe&g1Lxw&n2+oDRtyxK{~x$<XCOyG>LSw`n%wHZghXj@)M|U3aI0aXTHbhjP(V
zMH}j|9wXf**85J2S(3nZqE?7=&^CiA-+4=Uty{sK<2I>K9i7(W>rgRxd_4q~$2VZa
zq0G_Z?I(&8ev80KJEdprM6OLymUe=?{BC)h%1ErmJ;TOms0sUXEYZ6GAgz=ZjP9c-
z^7wD?W99L+g!h8Pa6#Vn<+TxADQF8$Ng|b0xhg~4tj5a^hYp%;h^|Bj9aU(yxf({M
zXf?A9A(6)8?Jy>ln8HKMQ@kBS+>N&y8XRxz!#ZA)r+QbEg>O1C_pA=jIzrN{jzv2{
z64!cj+&s#5HT>&xm@4_&@;ej*_r}w+?x0luo#^Q-JCTMM!3#4ZNaA%Srso@CdcHoU
z=j#HJ-X+J-SrJVI{7tYy*L@YDyY8q*vkJ=upVw5-bqAPt*VSP)idbzs6?I`$AE|39
z#X53s_mg0NoD?e^Yz-#eJSE@{LV~fcxz&olgBun3hsX++9x>nIEtq5=>>}iN<w-}u
zPb~`JRY!NU>V6wj2K8Bfa*)3whc-fF-4~&aMl!^)=6xETYN1d*)+`mFZ2kyRfm2DG
zpoRsBq+)yes6!il4cVDBC+~|R)KRrcKIyr^$Kmong~Sh<CwYXUMgLd<uK-y;FR#dF
zOwAf1uF%DQP8F9zE(G{m-rx=dZ_vqZh5mVjIIPe~u?(cr3)92eU>k9U=R#ZC!RC=k
znPB_PLufy;yTFb3tE}zX^Z`Ydqu=~BA{?i}kVgApFmh49`5=bRoOGSmwck7#Ns=pJ
zTIFA{oxMu(S)vmB3DH!vIa{a<GrB6ow6@?MS~W9yIcOmx8ee%{nzY5E-$($tjssQw
ztDxe4q4pn!dHy?O0!(1YnPUE0y;m{4&wej!^iVq?^Eib5LKy;F_+{ufo-sgP(SM4&
z=mNx$@Mx<6i8)+>M1$PfT=)c4jraeZEPaT1m$gC1N_c~g-!>g$@5{j)kPqRE%*Isz
zr%QNIdo)gx9rG<G5D{LcTOos(Zj2snN)Tm#V|B=)&cVEIE?zH2+5b7*<$b-#aQEL4
zN%90cmO!3*<fk<6U8pksvfXmfV;)Xr`J9ok$LSL}ef7z^rsFBl#Hw7ZUZF@XJR)<*
z8B`;tZE;*2mU^{qtD{T|SSM*D;6n=}cPrI$x16q751}o_+|kOQl<Js6wMgiRe-;Nr
z7}PE;OiGzHi~nqq??8TxFs^@F@gJqa;=d(cM!HG(X97k<f8>5gxJMQ*B=>8BgRpG&
z;Lr{eNTKDo7>pX|QCkTYY@zoC4a7K4om0)H1cPJ!U(@|8A#3j<%NAKX!m|p@Sn3d&
z(+o+(8`q_gU-}g}Q}%z*QEICkqc*QqnZnolgSO+-2eA4F=+3diA0&cfXOp4`R9FO0
z=3MoaMO8_3I)wsZ7i&7SuM7ctDhv<jD6~INf=hB2>JHt8IwhQw#bCZ?axj{S{s%m*
zVPuGJQA>(eGoeT|ns{=^EI{c2h{saeq?~n2TFV7k6^Tt#{dvh&crj_m1|p^)`LeLH
z#3GYvRibJsMbo+ogRg=G+VP=g<(_8D5ItDjwB~K}OO)xZW)2|xL@<D7e{dtQlUGsb
zsV}C`V{M_XhSlqTP=7WAWg;|^4AQc$Z(3Gt9>;UPwX6}W;^P0D`~4~kUHW1QJ^jTL
zdhUxU^kQ4c@f9GwI4p`k!a&(4@*#N~7Db<-y4sdH+y3&l)ESQVnztxGpUP}K+CNBT
zJ3iL$ogr#++4e|3`%V>pEu(P+AT?CR!R@v)I%mu#*0A{$CxCsj+=RBF+VjR#DnC7u
z>5_tWpR_7b0_ze}fMx%dIEVvm=6K34-j#V`QD8Z{Njr3RA=>hI=M0)fNAe9p5OfMx
z+h%svf(k@KYEZjdGxF4&>Hm{XbyR=YNMkEZm*JfAox?#NB%Kz`-0Ars0;Plul5TJ2
zq{qrH*K!Am5K|Y-duF97UDh8I>r^L=uxW`xq(+dgQX5c(bLFs+o*LmmoD9cqT}>5A
z?Bzz*u<sDvC)`RkFs!<X_IdRl!Zb-xKaOhfzYE>FjQ%WZnzqNFGn_IFk5gXA;4`So
zJKl6=#Ay}U4nHe-jaED`H0<R85mHPk5(y}!M8!`cQ65gmg8=uRGF?6uuK7acL9cs?
z?~K>@JW8Qa<jxA;wUfo=cd<^KF_EFQ4K*LKRyv6Rfrhu=&iczDD;AjQgE$`TfCuMG
zzF{P0Jqk?<^Y&s1foCEgDy76TlU#JBz<j(Zr?+?&r&=s;yK%@nf*FKjJCr1O5V?B&
z-?3uN!DZXkv1mZL=^jpHK5GI=L)c<S->4RVfsqpSw~(3EEnarZS8LbwDuh*zm}5_0
z6Ggv46y3NfBys{$G0?katRkT!aq_H!hG^SZH2*h~tMPj0v7Ia|2iK2wE|(%1$D_9A
zFk&-PPH=56j3gj)b{gV~wup_?_%l5aip73PLf;GAv>w-evNy~4_?ykY%&T{3r<{!L
zR`+h}p6I?X3D}}A;ttIUqdYPxK7b@1)oV7K!rw$Edd)?r@HeL*&~_i0Ji&iz!s3AS
zng5i<Dot(4HVtX$HCV1mN%m`}VBIFAwQ&c=0T5G1>Dg`FuS9vA${lC&r1DH@RD(j9
zw8JgK+f;LLTKn0&JmweibWT-3sz{-$g1v(G4W|sZwspT%-rBy1>4+SVGnY)mqiUy6
zGN-6>7cmY#vOvzuERq1#$}k7`ZZ0k<nT2^=&oekdOe&jq!+H5*YSV>~iF{5qzwd<5
z7+CeG=6`oW5LhKtJ>@NbL)Bd(h`~7PjBvjIbjpV%8Q&KqgRJ6^M5G!Nw?5y%d3oYU
z(&v;-x@ZbP1e}cEjyAsYGmP)Nj2Pbm3gyhw{(=NGd2J!6?HEC~xI|&1mA-X=OExhD
zcjV!QrqOXw0+j0Dj=W?gKv&!4HmDWjdlLUDDzfoi_mu7se24L!fV0#Z#&_@1>}Vz=
zg>vs*YkZG%_HTd_8Q+KBI0wswP~T+pI2!54ukZ~7knw%Ha#+~6OO`f{g?-ykzrm+(
zYd<9mJA0W@0%lr6h{h{@lmIOu_3McEsD&MOVBc=&dl`5eTG;s@&@7}lO2$kUcA9{J
zhj<CB1VIC97LIXtNcsvh%kh<DVIP-SME+YrvEfU;e~P=ZNKVlJQyv7q!uAWei%duc
zGDQP4?-5j56$LvlEzSuipElM#wV1hqE}!c>vB+^lPEIv1V6qssum9mg8%3itEl+~V
zwy#su3%1mQo{K`ymu#u8nL^<Qm3<C$ytv305JY6*(M34Revyt#b|(D1eaPafTMV<!
zGuZgUY%|sTfqUOJ3E4_b%5d{L8o`q^n))KiW^q^{-3h_{iIEB)S&$+-)%+QrGCiJ`
z7l+i~GHG4XJ{xH!T1+3jW2*V>VH#sD9?uhaanS}EOJ1fGbWxrwt!=<3OuWghFCt%0
za%C)49_?Q4+d?zdJO`mbgfYd!N;4rV%~bQ~f~+(_O<xG=OWgHoIM-D3eQaiE7#pZg
zi5kD?J83^JHI|WSGc|r-m_ltYLHP7NsIh_!Z>GjNv12;El^SpCB>e@`&P<I(g+ByT
zh$^2GbP($ctcpO7L7R7}Q1Ilb=EqpaiBa18aVLz><{xyz2yOPI4&{dv=ndrW1Z^IG
zZ-XIi9t3S3R0#B@%>&WqL88rrS52F-GK|vZfoSs*^+B8GgEkW)7h-^cW(SXK86l{~
zRNV{O%)_)9GB4V!RMTc&GHvcTHLN{Bn^%UaxgvD5^m%@iK09=WH%C_lgY&UDx-vqa
zBORAXAWHOk_-(AxH+D&OHRpgXNyf-^ums2*wv8P;HVp=o6C;x4$%BFZXfR6U6?!xr
zOay!x9Sq`jhr^p`7(Iv~@kBD4=|uz*4WkuFWaqK>ai=WM+HFRg=L(-NjwJ3wJ2C1a
z*+!iH=DD#@m^~q#%|&91l8M?<#F0)?ZP^5qT1iJAURK1XciIkY>KN0qZO6i=BDhhy
zC5XXkTEvYM;np^&`IZ}*&cC|*fy9TPA-Xw11|Kh{rR%LL?<1%mg6zYYw|-+Mjc5+g
z8p*jWR2am!g9@gog$jdsK!q0W^Fc)&Al|}-#E&b0cOCQTJDlnf@Q!qZyrsK!%jNLX
zSd~BND$A|uY!PaM+~OU>>oH5chLb!>-URfMfx$cs^pk<XN;L-ak}()BGg4ciSGav&
z1OG}!w^v7xRyqC3Sw@?80g0(v^}(NbyqdOM3)8425L$3|xDNPmC#Wv;Ce{i!O9|kR
z@^DY|!il#p@lF!KmJ@iof(8k8kMv$XzKMu2%Gr-BLg>l<FO_v+rB656(`wQGmu~V@
zG|9Whq+C|?GN>QH2Yw5vW8=zKhEM5D<^+pAJLGPTfF==cM~H9$mh<kGbx?V$lvNqI
zVw_z|dD$bM?OiW+Xjh8z2`?($c#f{?B{yPZ;7HOU#|+dIGQLW%ZI(N|pR_HV4u1@e
zFV@7bi(9;SlVDdMv`wNR)Ja;j2Yj8RMVhd*Sbtsw-3*;ZzAexxdH!!J`)hQvy?-9$
zvmBpz%TVe@W;aq2y!})wapNh_Cd<xorB9fmuJq}V?iD|6a5&)#Z9O@D#ZS^qhNaRf
z+gKxR@bXnoSJn=xaJ$M^&<VIHKCQCsA+1heiG8ROq|;zqNv+8+VjUXIwx2!>h5oko
zQ|dj(Rs^G5=C=h#S4rCzM!9Kj1%LN|QQn3yx)g5kV9b(wzmi~-CJdu10i)U$GZP<-
zXf$gTLY8CWuSugBsL~ESE6`{ht7J_Y%^+zsDNn1>tc6Bn(M%c*hd!iZ48rDJ&M<Ya
zTCI8MW9Tz$&3_4M&GRE#$d^Q|`RGW6|0Sq1FDxW==0y}2t1}yfdz2>gJSJsSIyQE7
zYw%R_qJMLXaQe+nwS0d(ej{NVw>^=l1n6gEm2m`t2zO8Hv5gN-U}hH^@`G4QwyTI4
z?Tw^ai|Ax7WU}S6Ot#KUI3^XH3OUA%-nLTO|9{vKHzza$!{`b%wapSLgUPZ-Z`&;9
zUI~LIkp1Bvp}np1JU4T9U(fTL^U(8=xp;2O$MZ=<iuGjQMoYfjAKJGWaMlGcEHEjX
zZQNxjhEMF2Vkmv_g+*ExKYSHBw)gHI9f6(CV<8wS)7S%IH|g0Q+DO{@Shc8g5;}M!
zH*XoNYTVYmSf`00It)bK#mGzq@<JDou^#Xj+(%uM+{g<m6cNZdQg{AAQ1+VU>?dev
zL(Usm?T;0I(Yd+!dCmY;o$JfzI=7SrN^Y;n(edrieJ`aRQW-gX*u~&yTsZBvY;zK5
zYZZ>Q{OMc;TD;F>IZm=|>4O1jrf7)6DMB(kDs0R5@#^9+Hc%*Ppz9e~oq0aRQ_*yu
z@Dp+2I5Agh4m0Vy_gTD~4!9o%fMN?~N#TlN<V)!HJo<>HJZ7=Iio2uy^H3lw9tFzU
zVJ?|tuc7xQ)Y9IY6<(0ZJ}g(U9(@%X!i;ekn$2%?>HHgCDG9v!H)c+K;r3VZ0)W3L
zhf$nW&`@KE<%WBh3CYLNby5|dbGhSd2?x`(T1p4T**9GPC9STc5`A`coJ=Lx8r>qj
z?VAo|^1JPu&%BPD4Z;;N^>Vse%K@0FaIqoA?_vNEV3*=CubDgHZ2u<ke8;BwkS};1
zujWHGx%M}G(vC^~olY2x&W8>lvIU0kqd@*};QZe@xVw=@H>hk4?9ScE0K{lu_e)M0
z4eY+*lx+gLUn~ReFv_FrunVFmaHs?Bc<6P`V3d|amG2bS!8&g;;=APFya1+-3?Jb$
zk0sVjJL`lW0-~t_&yjTpAk*8mKt7K{U__kS>ymZ!Zf?}t!79Y|3=yAVa|E|ew5Eeu
zwa;{LJ+6J35;$OqvQJ)XV)V5yQ-bO>K4Nz-bnOeYGhO=vC4{nI7^6ou+nl4+eXP$;
z3uY)e4G8AtG|&}xO2@OnPbpoUG9{>R(=yZ);X-V4Bh9b!MQtprjlFgtmh&)H03U@r
z%JVR->NwmXaN`gS;bk-QC9V$1DRWE@E^<|DQphJ(;6_p0&|moV_gIlbz_nb7`%MS@
zC-W31d0+zdqFsqQRLpV6!AhDnHB;MqjV>hmI}tVOQbTIKDrzQJCh89W9!|=WgR5-F
zuO?jc#3qMg1>li4^d1X$)M-az1q;K^r*$M&^Qxm?Usa8%$vrX=ohhq5@)+dYe(Ow(
zONQJs@EDo>3QipFY0dz&JNlPPSFz_9g*b30tctT~)Jx*Gm-W^2oub5PIG6ZiDj(+N
z$9m@huCV3oDXzy8O#fB#(%n9Hp}EK<ni8Q|W#sTnEoXH{uxnGEW5sut1h?h+9lGh#
zeHmOW15&Q~4{}Fvz!v@6<Ga3H5CNGP*mFJozoooig&#<jd{;TRTE9P-D*wkNJKfRv
zQ9U0l2ZyN%oq3Pcq%f0e_4YImdiz>^)ZVYCsk=!H?j|+5o4EyAoRF5f60XcEjc)>7
z5j^TbP6pj94+vzkhZFPYitarCmb+fwe@l6*20>rk3&2oN0Ke`iF3+Ckx6tBrH88KN
zrCzVb!JE0H#dQ5=+Zt)?G0v;<mDVM8MM{A0EM1X9u<VZNqr?~zt}kzuAF{m4;+EHy
zrVGJHU9|afB3Y4Fba~b+g^tQlu_B-1Nggye!GjjYdEkXh3j#}<!HD#;C;6J9#<8!X
zs|7B69J%39i3=;bu`~CGj!h-UT=!Yt%QFDzp<~5;0PTua|4?=4Xz{JO+lV(!i1!x1
znfK#&^M@5nojoM#MPA=+bVviQT)6AIjZ7W7K^?~4!ch<Cs4O(g)KMibjWt2xAzxB-
zs7aR;jmemyKIBV^mbC~@T@DZ1<(OO`Vp-bZ7!O0lvLJ$1<n9Y;@HIqgt6u?jgr2Ds
zMq)TI%du1=g~JtiS<9-)rQYlctX{&KAcIio_tf2HMRy#Te4B_WTESSlG>_@*(l|58
z&IP1lM)wg>EN&^%(LqsaZ-Qti;XT!uE6P{yMIqO!tCFD27j^v^Vl;KJ{fr@F3oU;X
z_m8K^>EPGoT<<(X7)fy`s9spRw~%hSC<zSW&7(hhulSha;V_2^!Oli&OSu=76P9E8
zx|%5WbaNTbCucWq(Z+0Y7jrV*{H`Qto*ZuQPIJLK)+jaB{D(+GfSVTZOgDc%k^p$+
z1C`UwjVxvIOR!DiYfp5m=(Od<K2dH1rZmyWl}EdkOk$8tt(>-9sQpH}HuyI?IdYMc
zION~#!l?`KTVUvt@}p#zM->cV3EHEONRk7F(8GCDf!;{=fSw6K4`FLmMTQ=&^>p*E
zJy)FT5GOV~YhWBVVc+lXkUK-U?h<WlRzXlO01rUG2CJU2U-xsR1~SRr+pIhkEO`Lv
znky0>A4#zI@k=8Kc#%*tVp*eRLGn-r1L7(vUU5;Dq>}h>MtAgz7fp!-Y$wXJH&F>C
z(nVRVFE!dRLswZwuBIh{Y`Q2baLC%q(<8-RQDZLk+~!h3klc_i*xTH_xF~C+M05}Q
z9x28l*OB|KMml)meA37m5zaLH1tmucc7%@4m06c#D-?oh4fX7nlAC(DT`70;p<K%1
z1x{}l*MN8{TbQ#B*-@m^{49QZn{HKk#0lsF;W^%EP#4J&dyU{9;UfI$JOXrsI}zGg
zr@>}v!XeW>ArOGB<Gx9^b4oV)<MNGBKpq`ty)}<nXU{t~oIs|Ygw}#14}Uv)>n?t!
zyL2g8MM(g6GO1FSFQ{Hc4@sR<QN#zbj=2NqkFn=Skx`k`bAT6{NEeU(7U^(NhzwFn
zIuu4{xpUDjZ&^At^^&s$-Ia?&|6Ap$tLrck+Uy;tOZi+qM8@P$M20+rfryw7@NgN-
z%|$7JYdS~{)Y7a+TXW6Er<j95bAd-_{Nl+k{Y2u)FaL~x-_f!@QOe?s?li**q;w{V
zFSJWjkYjmJnwE&v&=WB*m3Ri4r|)7~@+GwKW|ASrfOu2Kv8;<M_1tkbHvYtBC)10(
zDu}~*RiH{J&(ba=B&%55QS3w6VWGJ)C}iLl3<T^y_#GK*6t;l%wicb6gLV(yd<Asj
zHu15x5ayESe5q9_%gLX2>K&|$;WnVQDdRR@WfBML3_Vg4YLb>cQgiRDB!)l5*&j{a
z%eI>5ek8BltF7uqm6XLsuxfZ62YAMbaU@HEZzAJXS8$?s2ztBevST%1u62D;Z+QNL
z{^6s_*0a?5jK+!sgKOw0BKQ39Ld~eRy~;@U7PW=}4+pJZ&gRKBfCB6{MXC`gs1Ng$
z<Puu+QC~+U(qNZBNW(IuVOe}0qd|LGWm!z#wwBb_WmAg7!=5fzhyCdkg(2<BA`pw7
zq2)wemVJhNc}QHAt7Q|HyT}c;_L^q^iDsN%m+|G)(NKz-x>)#I&W0KRmdl#Ds3m0t
z2m0SqEgvg%*ZfhcE*i-UM<pyQH@_F62q<z?PRPs6Z;vD(E-W{Xk0e;kSWZZ^ET+3n
z<AFp+#oF-&pkg7>81+lWkob!J9k_Jmk!NW2kdwi(#fxPj)3S_^3Cum{(L3oi)qzc)
zYfFJb7uT2qdv#aGhHGf2ZW2b|4WDijM%czNui<mTF<o!<@+<0as%`-boNHanCBGV?
z_zRSUi}__=(#hc+2m&;!D-&4P_9$I*Rr(%|9quYcC<qv0DZ$tn1R-uZkDIIL=_|tZ
zOBvUpX?vT8^vjA;M{%BLVw-!<AuFwEmVTtub8S7jB%FS<2RPz(w=H=wmqbQ~)0Lo;
zeX7jVsX+<@Zs${wZ%u+AU*^PAH{a~{)1K$>NyreMKAva~`OO3nG^<+nJ+X~U$+o}Z
z>yyx}Mwd>>_8hfkN=70gU@d!aO;@D|6sMcx-_*ZaKMM5`mh834*9v0nYrTr&xWFY+
z!d9F6fxwkh>;=tqnFP@Rt`)3yDPY_n)w*#IMA^ZH*~<=7=7a~%C5oNHZhkZ;z?dh7
zl6(IAeEys(cqS+O)xBl)0jW=1!D1<-lF7OMeaHlYKNLFbZ8P#?hoU1UJS@W&&kG$>
z$PMg*a=!OYsXW0yXUou#9Y}oP<e9`5TbdA9!noCum4jct{|c1I;!F4-an;K)%w}U2
zU*xg_iEa-S*iGFFG~orRJF;PM8X;<)l;MS6s<~u2v)OFY3s`krb0?e4#-uxUFhET*
z3+EY*?-*eKK8sKHDPMQA>=m)k@=1IL-ssm;I5{!j$Rg;Z@R^&74aU!C(pmft<}?0d
zKAX4dCjA3M#~3zoj3Tw!JQ3=k1~}P2Q`S>WH_TfdoyMP#9xfA&LS9f*uao5N=s3Pp
zsO;XTYmSrY%`Z|tHUB}Vby#DH&tl5rFbH>COE#~G;KKS|h=hMn!jdRl@e?FS=hhj-
zVn6_*=2?weKWO?`fsTy@;aKr+%K>*Z94r2?9L(wYN9ABAnPXJ@l=5^b@pq#6-EDiq
z5ejSq?!$&&qxD~pLyt^?TV(0n;-sFmxTGg766Vn@$`l$co}&)WBe!3D1(J}vokzfM
zc=e^Yk)*Lnh9#b@wAo%9(y`Px1;bL#iRMpH-r13S*&M!0X-va{o^%RRmpjESw>!m&
z!}ZSPk_$w5K3fj<P!}iD>)m>`R-}pM<C+((6W}cg6+6`3HQSz=u$&|-+M}%7c})?)
zk}g0jwDF0<<WHaoAJFUd<x}KfYLsDv3{<5IzfJ}w4h~c8Zf=QV=EA|<7){gB?3Q?>
zF0<TWMbS|Hpd5Hoe_s|(et)(cObSzbYVut&?di^dFzs<q6z8T>uO+y--PCFibSd6T
zIkf-(o(J+cw;f4rKh1+9^@s@y6!72in7)ztP`zsE#^UWfaNPR)Jcz#i_js^YZ{tC*
z-?#F>dx_mLo#DZ^zakK?4o(n?7SdB;7ejtjpaB*)td>1RsL-?=ko|x$_<Z%(=<WJ)
z>6Y^AfdW=ZUR7QV=KvqRg>?2XRFV@JavRE&bVz8o0XCh`3UKfo0<)e&z{Ri(_+TVu
zVm5&v@{+)h7F+d0R#&5NPX-ppS|D}|@`oj<2@z%_DeQcZ0YUxHQsXJz1lwV$adFy3
z5aVp=MH%gF{n7>LvaX0E$p2DoDiMTqU<g)*NyC7IT+d0T076K97(rEoAhZ~W%D2S6
z_ZAT(_B5deqTg6S&-(D0v{v?SGzHzjK%ed;t4*28**_pFRIrDUv5hxB4f2d969m!x
zSyHu*5u#?zeq8%POs3Pju(7rU$pZ+0TbhiC>1u|3TCdxhu;gmF;VIrGo<XoSDXN^h
z8k5W-UmAFvnIxA~#xR3@);$@OW}4p>CvE-`kvh&e&NNRt1=vec0kN{3f~cQUBwF5i
zqPw9A{>mTOOK2;Q{5I2kFjBz&8EZ2Kc>Z-XqcmyS_nzop?yxhg7`a|XG<NhG%mmG4
zo;nh98RqX3U^*aWH2zD^bgS=}hA}IxtZZ&ULMtmPXcvGZ+w4Sx&sXLPuKyIg<WQlR
zYx)izFgbQ=L>$zfCKu;WJNTo0dvB{#C`%TvJV+M1*;6&9TS$GJ)0vW2vr@+^kcF3#
zb2{Ynr;rdBO(pO`Tbu6JaB+uI0xAT;xRxc?D8+gu*NAIW1j`kEG6e$>nv|z?jRMpK
ze40PtL1K?FK8^!RD(TaNHrx5LcU1K4EMW=G;<#kv(1{-V?kxHu(;Oue<in=Yk>Ykp
z)~s4K?&vffC*~9hS#mGG)_LGFJH<k@Q_TuYlZ<+@9LZ%8*V77=GUw}ZppeS@uAV=P
zi<43e<YYuKz&eyxfT3#z_{j<&m+>;P0t-xqKBX1V2oW&siI6sd=jp(F`0~ytU*0(v
z35S)*k)@s-E;X#&OD!f+Y+7Z8#Yw4%Q=q;`x&s>N2QxFqs&iEpU9aaP*`Y>HA?Qe(
z#*d>bIgdzi8ZCm@N^}D=-V_o8kL1?dS2vV8Ua<|s3mezovcUp49I9%e(K-3_cI5$$
zv$%GQ=4f_~OB@F)7#WpmFc)3ML@5MPqwcgohWI4zG|6n!s@rSown9S!gB{h4J*;2%
zBl<w3vwiz7akyyH8F}<&2aqlA@%$+{C(aS#2R(kymOoQvdQkV@G}kB1&WQ?>GJ4!<
zj$tF^g>xcrLYBe~v~wZ+6^v8dZZbJ1&Q&-}!<u9nWxa><!I3ph!49_a`lss^>&lvd
zdh$(khz7a&$+r1wwwhCK3D!l8+LHvuw+pR?i<#&wJ#he_99nJGJQju_L9rX%nWqby
ze5t82oSGm^3kB>e$<++P+Yy4WV7sLVLYW9c%F_}An>R)45<wuCyF`Ez+l^b2z9c!?
zYSlP2LHa1_kTRL&K^J&yF8&Mj*f}v?@Td>@<@B-$m?#Z*DxkVSb=EsK=+DXiJ=GLW
zd5|^N&CzB}3^On#o6vZ3Rj_`xEMyWIZwABPScJygSl~_C&x7+qd9<OY37~)Ut|_^Z
zMLj$2?UZq`KVeZV7X;%`30#*-Hod2VtX=XZ<9m^^Srbm-65!q`@<B@*^Bf#+KJw$t
zz%_2LxvclkJ(6i7W|Ju}3j4{?f-_sZX`G$rKpxjljkD8^i|>rHL!w0>;+ci9yW>>>
zmdw18TN;zx83v?~!Ie-I!@U>L&@e1qVu?1HNCBj!V+AwS2IEH-dmq~y5vqM6AQw`Z
zx7*N?bo6OT&^*kFE6;>NwR<rp7z8!6(b^|8vZdijCN#38VZe66@@tu_fFZgu!xIe=
z7|7Db;pfc16WRb}6U|vC9M1xZN^589jCz7XhV>S`!y<-a%_M09>C`tv@$EaiNN3Hj
zck}#CG%ryjO0I4v5jFzd6V2zGc9ArDjw$UnMSDof&?DUw#4INt`W=7UR#47Atz@9^
zNj)E=u|+MUEB&Z`C27S8A9F&;Gfw!p6GkK+1n}>{n8HY&mf%`r^Tm}NpR8pMcB1+A
z9|qj!75d1Z>hT=Je1ah66U|5T`EsG}<IR864`!J!cm*_1cQcol4YT_sE>4ehNq;oA
zz%CsJ=9jI6kU@jS$Sb!2(H#$JS*|5v&Gt7~`h9d)z0(@NHF9Kx@!KdsKm$DpcF@Q<
zjr&az^?te}Rz*8z)=c$7J1oixjnM~c(WzF>8y8K3&|Fk>19r!1J>}8G<DzT^{kK7L
zfQQyf3sfBK+~E?+OE?xb<oa(FNxI!6j#@wfyTqc1-Y5N2t9YL%ZV<tB&-*yHqo%;?
zrU$Gs(r<^(1i_&g^OF<!g$Cze>mndB*o!O$oiY^_@ZKK%wiu+Hzz}$_aL4Gxrcw!b
zmTQyH;|)9$FdgVde2QqQ%tM589Sb=LqMS}G$^j2j7jhCD?4*n<I_x2fha^>`0LcwX
zwVcGuh@8ZIYyOnvq_L2bRB1lwM+8ae6#@zo3zMA0*(<f-h8#g8HMBTv2uC6}6x#A=
z8zFQgshyROI3-zWktOTuDl}vzlJRt50QJ1Y4h&uRF*J^B1ntF7F2s&VN9=gGlquWk
zk}V)-v%2NC<<`(VH6yPu-Oy^;g0>QKC%edONEN&drHWZuRENC0lcb7S?-7cZqjGkF
zm+z#H=CEVp<=lQI;T~>0%FA`(Sgg6Mf-NuSelZL8=H)WsTc*LeBQ#4du7rDbcEzU0
z5-;~O!5zJE<ESdY&$U2I3sy+*?A!qCbg}uqpMp?4_LKaXYJOVp0yp-KeyS9Ut>9-u
z#@Z6K7%t=_%JU}h;^?vJQRXnG_3yLXf_03@OKAvG;5^w*WI}AO&9ZsT@HfI)*&H4I
zMnfi~aIkGK$<_yQfV%v>c8DTrESW8<>%o>EV=QqhJW9Q6_?wDsh?76HrN|d-=t-4&
zwk<W@{42=WR3B@{CL(uXE0H^YB_j6_I1eEJtwp&WB3o(lHa^_6vm}B?K*|brV*##2
z-LPigO^j2h+&k;4>Bx8>8OKi5LL>XCn6}BS8ft@GBM~>Kuy1Th<gQu^%0_ueblh1r
zj?JT`%Y2|OVm(mhEA%IbV(f=PLZ#x4P()qS*iyEZAns!>VFu9+I71?df_{@CN=!qF
z<R_JAAua>b8Rh>IC%EOBM24V+cv_v5a0{KX3@KU&nGlIm>Uaf436_VUt>*;td`h%%
zTC`B7o1ujzT}DsPCAq6X3s(~@1om562r*@{gXmgk6onkG&>4dka-X4GMwA+D1TA!o
zUiU?Gu-y>|IvAa=Cq)NEW55d2L1MHf)vn|8e8?RCTpSsFE_=_Hu8VkRi`-<AV}kv8
zIx5mF2Aj~o(AjEy_fm&3n8ZMQwmPS?S0ZwnKKX2Q{v->0n~v%^OqY%Td`NfZW~<p)
zB`y%gl8hmE2ah<Vi#4NNr7yr5BgX8ORk{oVAF?cgjh0GBA+ZgbWx=~hE@GizOg9%Y
zgCJj^&~qw8turee)-_)X6Vi5e1y&9{Rhcpzb_8&vm3`6m$PA>5+I`*^hPj??1L`Ou
z!)*UQfgxI(ZvR(Gm@tsanlVaVmIk|EB{)ZjGUNEd`CY2GBdVB)4}*n(=-B`l4f|yi
zMYW?-<!HiXm=w4dy@hF|4_0D9IUmg)vtfE~T2Oe#E1puv+Z~<K=%h_G^d@&w<78l2
z05QlE^?nd90Y3L_S-I+z1+>F<7Ihrh9@-UTdmbX`FrA}jPUpBhu2MNzJf<1;-oql0
zN^PnQfo<E`a{4y48HrLU<K3_iZQqP{IXxL;aEO+`w9*=5G%d1*93jmD6LZsALnQkg
zyrKzYr8R-r;X9i^R?;>@HzXzwv&$wkTy%+RngvD$-e51vpHdeWyf`BVuH8j0xU2Gk
zYZ>ZC?L|a%CSG-t>=e1WwHGar9Fm<6T+b%SjwZlAN<|lk04}i*(M5;?Y6u@@b*Rf2
zZR1hyi(=5H>B@b<;6w4F#aC*xO%+Lnk=aVS5!lxRa+I=Ni3I08n)9MpMAps>_oiN{
zB2|N^N{HW*n$*$t;()d>sNDnV$koSm(UYDjXqwsi=mUpV$gECzG~C~{fQdAXrn6~g
z=b_Z{pLO6P-i9+fFSk_7%=7BVRGL|ua7T2QhJNhv;sZuZc4lQsbSDs$CS*rzuE?F4
zCT&Y+z(a>bcQ<$&b^~oCb;IZTccyMoxrP{KI7J1gFN&LN(H-aO3MnMn<&i3EhO^Dx
zk)6U2RSf1Nx?`?G*ci3TPXioDbVq)XUEZ=t*yS-EN_Yt~ocX8(RWZpic^|0}o8m0t
zqc(6YTlYB0kA51_^XZ@FPrrFW(z~3_uz?}As{+J!muHSFv`aBeMZ@?n`AJIfPrA#X
z7o~2{pOeV%=qi19D<1te*cGTm$nRrAgWaMKa;#|$cCvKvyEO+bYNKsGDfH-1P#ruz
zc}cW`+S;!yjjKoq@SkLaA;51xl1(Knzdtil!u@H@cOJe>n8QMr-JfqugzUcfiez_W
zt(Tc65Xbi+`yzx&1V(c2zfDE}87y#MfIHeuHQq?{-@}J0t1y;=xsZwq!s%o&$`5wJ
zj?Q7K%m#vbP97o#5qNdtI34h0PVNN-MpB@D4iZHl!blZ%)6GdTm)_0*@Qnj4Mr;i`
zEm*(XV{_Cv1nW3}*9z8CAz0hN9Q$A&^ga$I0}I-W;bcVGj0s&)vJ4ub1Z%)51Z!SK
z1nb>=*QX>{iv(~+NtNakc?2<n&DhAW(u!;<@`|h(#%YnpwvFKM=nFBC8Q)sDmHuWv
zAA_iU8<zuBr2P#Cu<+iAoP#A~QYkvXF1oray1MI2*VV0?FcPk>(8-r=!myJl2{~=H
z%=O<N8!b+bJs2d=If3Y4Z;T=I7z<QckJ;xHdS%ni?X<-<(`^A+)wD7n5=Wlq*to0r
z4aF(BM!-{u5-V}aVyC7a0m!zT)curhktL@~W)h<e;$&4Jf0FC@_C?Yq>ZWHFjD|(T
zlT$j{MNUubXrbCCc9g=rh_p#CLh4X7N3$czRUvg~9NSxxI0ic^Z)8i-g7$CCj@a7j
zjIyJ44HJt-#ZfngVuHH?i-z^*Zfs`J>`Gr@vkajib;hzn-YoN7RM45US+<Kg0oI3j
z5c~{fYfegl-P*v1Ir7Yfwl$aVfz8)fjJno$n6y#U-K=eG2T-UGBp3BUm<Oq3s37f%
z)~zKmzhnz-Ye5uBsl-<dd*I#j^Ld%Jh2l6`*%w{UI-JrQv)U~MsMc$Pbjdnf+nOBF
zwtl(Qwxm-s8B2r7R@(x;`X8m3v@KVWv@KQN|2re;Gy|n~{rz92fP_@rB+xyFJDh;-
z{19d`=zbv~_5Wk<ZJ_MBt~$^A@!qRf^<I^pzO1q(OZPp=R+Xi)lrKqGS)eQMhuU%5
zfpp`ZVZboywTvuCY&^yxA*sYp;y@s72oS(CaXtX&3p_L(0%U>G6Ci-sjMFqjfUr<{
zGPGxsp5=znq%)bx{Qi5NbMJkxUP-bn8PkKkRQJC7aqc<$?6dcO@3YT7Od~eA&)9q_
zNF}<^ZmvbUX91}i1sVWn45ZGFb6y2fZ3NUHHI9IG1gQwjF_6k|TqhIHf_z3bNR8P!
zBS@9&$23v^hQQ@&es+WKtpP(#Ydi9dz|i(X1f+5~0K@Q11q@lfDqv{3RKO4yg%DrY
zffF-<55EPBx1(G?u2#CttyatHn3k*Nb=)%H_+`!z|Ew^=>7S;=CzZc*A?CYDwU#V+
zel?S6h2Wadn5taAp#(C4bqCj?HxAm?Zp`zh7JmqLNeo)@mCTc`n7A)sOFD|M0WqMh
zmS?4gF5yjQ^bNBz=@Ig4+Knxcb!X8JUDr<N5m-n|D@L<}Tl5kiviue1x~X!n{0CT^
zh?@9>akvCIuM1srFz4LsGzb&-RxcXb#an&3qG=56rsaX?jW)E~@J<`rO`GV~z12oN
z;I3`o6+PCm8zxCu2iZV#kFt539*Hh%y|#wz<L_7)`I*K$=&H2b6M-e&x18-@8n=Fn
zUbj_mPggIUC+yu$!P6iwb9`bYc8J1FEm&K{(HpD<BpR$`0VNpt_n9kWCJzGpykDpM
zpZtn>oKFLcwTs4Y)YlXZ`7af>p27f{EAvS&P@*^jeCn&{Dtu~df0dLDHD>s9M)*|t
zNBET9es+#u=|7^CROnD?4^VR2x_RJAZV;5*2IFS;FuOxbY6cHP?O_Hi$aW2zRnbqA
zN)E^$hO?MFx)jk;hMG`vHi9-t$&u1udMT9y0+%AYT~nC56bT@L>0HTesFmD?sN`&!
zebfI%DTKl{3o|8mA?2Xt@IR|63sQ3gvQ%o0s|o(|6zR+iq77n#Y;O{Y4oQF&?9u*G
z|8>xR?bk0$AIK9&{FZ8I{7$>?)@yP}n&VYUa-+>|$t9_2PLw1SsFWmoM*&kpVr&o0
ziez4pmbEEDiZog#qsv6*yu@x&M3(!F@z+?}^oIljfy@iVWg;^_!4j8w;=iz5dBLs*
zLq||_XNbdMDpSrrB`_dtNTCsUGf>uz-Do!0WT~uY!jhzJg9}8cl1~9QcWNsdwPCa%
z{2AOK)Fh}q+!{D$<o$zRYf?y3@hRh-yG6l%<&t)xX`OTZd>=!{5G}+EB?1d1U)*=a
z*|_ftkBsW+Yd6hrq-PBl=-H<4ib;@l3X+m0^uT;qn%$v-?z>_wsKJ6Xzyj@pYJM8x
z$SOY#i710QwrC*>35)93{4`yuV`9c^iZwh_spGEuX-srT9d{MvrI5$yr;%*730A2i
z)C%*f(k7Lc##YAJthpowqROrKN>rt8N~`HEszen?<D!bL2pQndH?nkod~U#JWL4zm
z!4GP5h%#VAO+M4>fil^eKr*8YlhjltP$oQ6Q3e(eP_dedGRzPgGBC;*Rp4b!Xq$HR
z2}bk2KoRMFfiwN->d%%U9U$L<2E5LnLg5_0Vjiq-0-^H6O+%axHqW<Oxk4Z~S^CEo
z{uuL)=rx;|U~x{V^&&i_<*FQfWe$GokSd2MJyl`GR_5fk=0}48n91Mn$-(!DVt0^>
zG7SkA(ni7slOLd>w2^Q@V~7iN!UgM3UwFchYbIPUcK=SbS|g6>6|eLOEL4)URy|Zm
z6lCV?<Ukym3Q;h20t!;JmA+tLRlkY0QWgBSCJyXP1HLk44F6NQ?bSDJ1vNCPS5T`{
z)ybJ>YtYLcyPhd_U4xHX?Jz;AFts%cvQx{)kZPYzMg^IXcqN6W$j3kfuua5yb~R%T
zx%w2cK(G}d)dx>1VnUA4zTA)uQyl-IL#qxW=!*`mI*gz%I<%@V0{4IEb>bahJ9g{z
zvFal=gbs@L+)2scle3aPj9Fl<)bJZzMP*}vmX1+2K|2sGp+}Mtmv;CicE^OfhID}d
ztv!XhazJZ`F+eMZ8|8z?d5*DRcvfOvx$CN{O$@7khe9oBF<;)=vakpVp$QRmtaf+C
zu!slo6-TeCf+;4Y)|6M?S-nCe=S}L7IYn}wP>*PL4B#BwI0k4pr!Hxif6}->pR^mx
zedl5h5ZM|#vSUR-V8VP-Tp=PdadrdeN*_nS9S_Jq-4P#IxK_J7BleJ|a~p-S$z^D<
zMMb<!P%)xibEbx+mN6m{TXM@_7ZGb`a!PT*?8^`;!Q64dY^$6MLn>P%HE_X9AjOdp
zab!wd$icuB0cz6vy2>d|UwW|)9+)kt8n=S#?+8OGTn!AFI)*f}M&lghSUC<Qp8P}S
z%8jjgi?MG|Dgo!LWPr33Q^7~$Jc0*wk@@H%*BZvTl|*v|Z6Zq*qAzH^gLpYVd*ZF9
zIa7r1JKv}?HZ0ODZBYch9(f2(`VA#P!rvfu-}0Fm`bPKp0zG|l@M#1qjS&&B7Ld=v
zD$0+*^I_H|f(jPDOq#hAWhS@VZ&aSuP6f;OO_Q<2BxtfN8re$N=j?#WnAKbixoo){
zG+B72(qvn-&#bz_hCL6nDhvX2T$8cl^j#^G(fXG6S1XUTz9oAEm32mIWKcx5q-F4{
zsg}-khguY~D%L7kP0Kl2aO&G^{rRKV-TS!9ER1JNc`T00b-!4@#4;MU7{46fDj)uU
z`3Ii(MT$91r$m|j@p$25uTKwZ-K~<f71Xd$@Q$s!Efld+6jHne^%)*0iY1mfk*Sa4
z>D2gC+V^VSQjQb2EgjRo*|GS4akW%hTZh3Y6@$TBsI-!0oQ?zAQpHyz=c6j_>tQsv
zsp2#&zrETZ`ZZpxeN=;?<)f}U>U+t3FS#XXjB-$3k~Ts<F2A)%bX19z+>gs|)42Rr
z>pc+iSJ^-jck<$>Pn9X7T6YV_IoFOdnE_YH!9OUj5<EPhp%mBMGDFRmt97?mLC2!4
zWw%!;cA>9SAq>PJzd=1C6f2OwY(o@6Tdu;>Alt2N`5knYm$}nR<qWS4WN1=gt5ZOU
zuqZZAV5?JL>m&uX8U?nFQ^3Upt6gH>)nBPn_>rs8C}HDvgpW#JU694u#X5opyJ`wB
zp~#31iTh;SiBSe;I3p^4bcH2LA!Xkc<Db(nJuy4V7TQUg<t==$;a#X#zuTjk7(!w%
zc;|-snLZ<I+JkdsLaZJ{v0!<5RbFZ)7{<&3!frG~QV<!Zr52;zI^SxAv-Vey59g_t
z(c72^aZk&s!9ab^Hpx;^O5?RpW1%89l9G}FE9a5iw%$7lDE4W*7@HYKVJ=TE7`3JF
zD5~N+r#KtAi{hJQmMioXH<Pe(SnCZ2=i{RIyzMBe0kT0aQr#2tFXoH9Pf}B>`DN68
z&IihdTj$&Sx~#5yv)&t;_2$(Xe{Hik|7>+wP;lX9q_r_HXP_!rc>}C$-_->l5}Q|&
zV~B7|zpz;l|MG&vH&G$(d?SehIUEN#aVUoys531YP$1osLVrCwS}Iq&h5nq_KI#jb
zwT5!C0@wQG2mk1UTW_9!A!i3qG1QWq?EFJqJyB-&QgB911+HEt9g+7~stlmzx2?2b
zwXu{L@<iHTv%`VS`YLOhwa<Z_cSl&ba04G)5+Y*N(0$Y#)BQd^u%TSMPi1em1jhSw
z5r*CSuz7|Ue#6W8r(~cCV|o<93Iv%Ld~#$E%rn6bbFQ;(`M)CX8GuK`kdYxU@C*Lc
zi~m7bPI9#7{i6*og)*cNIOcV90a!~?XoIirKVn^{_2WWj^xaPSZiBB<_mYlE{oZd2
z|38x`GEDn4R;x3F*O1U1&3=dcO147$2bJxRGX={tk*KhhSK04}!n?Pr*w@kj99|1I
zaQFd;$>B8&WvdR&IHX$NuQaq)d(oIzjPRE`;dcr_vlkYxU`6QEQb^gf^-{t5ZFMZB
zK8Q&s68=Z%6Zd59xXGf5C!hd9i`xz-v{;s%KtTvW4R{dj94}~T_p6VlN32bMl}OlL
zmt1E>WJhG@QQteA=%*T$8<B#;ec?m4aH2zoTEu}{UGV~L+Tj=#JQ-<ui5qviqN){2
zQ7hrW3{Kj=j>arytBi0j2oi~sM$jK{g1%<BQ=^}y_i{J@#kxxGxu3%}t<3Bedk$rL
zI6x!j_a%uSm6j3a9N2t5<3PY%%E1y{Db&mt<#!RMK8wkC=>i`;go^wItQS8*&4j>y
z5W6q0xFGU?dYuklO70SQR`AMMmA_k6UP@j?bCO>e?o{w6uru`F`P5E*`>5HG=aw%L
zGspN6Pu@A|T(5}$0&hm$Vt)lExpGj>>HYLY=ybA4pB(Mw3SMy!P2ODWx3fYeouV%}
zEV53M!vGOX8L0AujCkC}YzOG-SBoeVXg0#$Eftl;y2g{ET{q7sR}=?f;1S7;?qy7&
zXNz4oZ%6eZnaUPt<RLpX6bP;4nq=cLAKFx+v=@ngTILZ6tW7G4YXgZSmY8u@;Zfjn
zegS^}#5}dF;V!ddt%R;dj~+j$JcbE}T`)xX#?{r;`?-KAtqWQJV(6S53#FFrw$wm+
z{rpR`jUjyGLRGuY(NvLSs8peH{R}L-xrtkzbI)cf9+Sz8lR@=^)lv=s^@PJ_@ja}Y
zidp3pX1|9e=mG!jmFI&BX+3hWt@^Qt88=#DlH9&7^0I_=5#52{UBa%m%18yRB%56K
zY;@hDOzK?RtQ-qA(o!~tdZC0mG}~{%HlEkRR+ehIPGD{w4XDT*GdBp<AyI}ZWUt}R
z)fwp*EE;vba<H({)#nE^YFU7+#1r#+sKWv3v^hW>Et91{niLAOq79Vb>tRu<2H}d}
z@rF9F0gewnzqwA3W$R&8mf3)+nLB)}7IOH&3;k=%quoXP8+h7K7;f6>xQP@UWQif_
zU>YWy<z|J+(i`XJ9c1l82X2LHp>At54zzMEH-XkQHCO?WxJ?{@R)uRTprxhckJG&h
zXW8dLQ`Up({OLdoASIx+=s=5U$8!QLH~0m#UPLS81j^O`t?aBoYb+s94YX_>0aaPI
z4hFOq1JK$^ogHXp5oqaxYyHIr&{`DG8WbD^w7Bz)KwS>U0lpkcI?sSsPJsbv>De)$
zwa0;$_L>Cu>?yzS<j3c4o__&nPb8->azI-8@kK5h(#i^%Q%vtV(#m?HIgplq2c%^R
z*+#RXEhU&}H=pfmj8Z+F6Y4dFwD1JnN7Zpk-bdA0lx0Y3(U8_WrF;P`BE%&!3`YTR
zvC+-2!#_Eb36&WF>xNhGZyW#i@^26S`T>p21~m2t=S+j=Yw(zH;K1jGW(AE`Q%zS~
zm)tJKT?dd^vRUsMqGwi9R(P6Sn4|qzmhxaaB6qbzvaQO-G^<$^0kHw6AR3)+rkl44
zuf@XdQzXu6%BY-Gz7PF+fO=?|*sLcOKc&+OsNHVAe#&QAlkeaTFiaDM$?zaQSm9{#
zrpyFU(u3)6sN<W{;cgw@k`9-3d}}(aYw!|Pe$`e^@*&+Eks#;$^c}r1V$H)n{^QLg
zV84zWJ$8rYl4Ix9{J=lNG@DkFGPR>~q|m+8g(eR-2^qVDFq*>-Zi>xu8PG0MjKi(y
z?Ka#HZT~sF!X2}Gw?va>mu&xpzTQG#YeLzx)=RoeHpniZkP3C%7r4p9qKtoAK69|x
zUhI-|*tNEk$ylH96#haPzE*KkxF0lIhtGCBpP16RzW{SLOHwAk!sDN_B=O-<OIH8l
z(Js$bKPRj@?Xd)@x<$$0c{Dl{=A?tTbOdd#J9=Oxc@d@uhZmAbO&@2h6DAjmyi%7e
z`7BA?my^Q+Y6XqlF35{gW!6SNem6LDw{iXrqN+Zyk{t36yu?57V*kL42!SW5{R_ag
z)L{=;2pHFw#@sG29SRVSj(t+4Sp{DLu%YZ1gUYrqB|~duaupw>n6C8UCRe<h+>@*@
zR@q9Xf33uAN=c<N0&+mi>R)hj*1thDa0`_W(NP*vCO8F%Og~p;qE!RLp>+045!gXZ
z+ghznQq#)r&NbAuEsCdgU@GC2u!_G%$hPdC$|Rb*Q7pO$tu#;kz)u7_>5LEV(L9MY
zr|)Nckgzjd<AdSTa%uWCA_y!{ZBv<nfG}I6rN2>a^r-<+YNAz9v0J@WG`-S4u4%ly
z#s?a=jAxkH<bgy3$?_#9bc(Dp0dR#6ZwV(85F{}-fw7fGpGIyiN=j*H^Rh;@*m$G_
z0@oBHM|&eT#TW&%g4{}Lj_GJjXX2}pSqLVCS$gVd`U;&%&Y6+*PdP_m=^G>|j}`2O
z3T_J(+#4#mCsdH>>;vhWfGhg_MkSP^%;n@e4kzpvtpG4`ARU9`SjQ5o^pM$zFcNoH
zl7D(#a;?q|q^~%d?)Nv2X<3Gqa--6vSt$o6O*EwBLvp*AsCP0xkm7@)Olo6fq&Ay1
zHb*Lc|IxIsGn)h7?q}>w_;s9-a_S`<$Y1sX4luz%4tw!Qa@eE#jg-c0g+q2U*~b9~
zlE}XCP_m7~!9&Sr4umvp;;?*OvXR4Xc{WGIP!kc>L0t}J2ac5REaw-JJmY{2PdOmH
z8C#VdI4T!R`&_HbqjF@cAS?~qsQiQ!6O{BZKnrCUR()49SMS{1HO@rmQ%8NttwG?#
zIY5xGkgP!t*nnbz3?y+#*5ADH7I-$TMcIRUxl-AKi?RpzaHX;b7sKlPg7@Ene|>-H
z+uTrxMOdAKnT1+pGTe<i!Yo{lX5kRvx=c~QEM#I>>dDPQfo`n7b<Dz!pcwd=DYJ;e
z((G8#Lwyb1E*xSr@{I7+PzXL6hQnYO4vV}<dDsm@kiHB<0e&l@G7NY7W_!EWF${-p
z7%s0h3}0Muu`&#o`3{X0QHF>sj$3Ff^^+$F5ZJH`kyff1Tqn!WByD9GE>@NyLh>3n
z3HONE5Zh)F*7hNMxh-^KTJ9q}N4*pK#wsFOqfVMOqUyy6g)26pjW}#{*gP1*9+NiW
z3uuSP_X26WeXgqZNk_>_lYU;D4&Hg#r8Vyalg?f<8*!hMkLiMa(gim5_EpLU((Q8_
zai1RQ@QWwf9H3K6m2eHoS*QmC7sqvNBkq@tnAJKU*occ5Qgo2DL}sVTG8<6^xs7PG
zP<^C*mV=F$W8rNv!R$VEiRkEI$3dU<`_nB&hFonaW;dF*o*K6Y!FxYz<+{f{c<*7S
zx@>M^y#N{=GL9RSlivGfCjv1cU5v_ec<*I4<cw1Vp)0n1)42>wn;{;IE*Es1mtlF(
z?RYG^2p#d>(+lf)@L$LmpOpt+Q(d)TIWIFsbx5^W@H87muA6z_iBM6_nd76%gRcv2
zz05~cs}}?|FW2G4=r-=W2rmkU7pe$>O?mL?4?QquO<G7ri^&1ACbRMvzx3X1H_wwY
zuH1iW)RHl&^Izg>aN8@R6Jf!X+g`?`ew#6gdqsY!dBOLDx?@bTAVFVk$!$-TE}bWG
z+jl|cXLZ}plWk!*1OuqWVA*t-t1I{yz4n?8t=7I9zLd~V1>=+%-!L8=jOKjWtSj>0
zf%}wEw4ZxKW8GDLExntj#)&ga*~?Zm(Q8k5`5m>_9!KmF@iXII`z}Er>aNT2k@B8S
zE3bVl>9txIe+O6w*XeTd&kyIf=}a*d!5jar_8ZJ*(Ce7}3j50diFo;y^el(}R-ai(
zzKag#@SP0Q_=!WR+a2=FTOH5ln`g@oi`p34`eqDp`JK0U?`?BH2vF=QVv5=VrxL4o
ze(W&lMoYx-6m?0=6Wp#{SrpwmJq9g1klrp}rZ)a*0E*XI8QFfpG-`MoyvgAeDEe5P
z(ca1%j~g69lNM0X`1s!S30OybrCnPHCz4qds>RAZK#<g23r9SthIj8&xhjIMh-yZ>
z?{eaOr~BczX|(|AsZY~!W-f8S9WO#K?Nm5DaLvoCX>l+={5JQ)Z*xEVw&;gvURh$C
z#b@|IRl%V5w#gN$2@z=>ynu(On=ybayov?P6%PZblj+Z;<XgPf-|V%1xoW+Xd@C(-
zSA4U>&ZmNWRCYW9li_y`K_Pi@kT3D%D@I+}AM=7$+YF6_{+<^H?Bz-YwC0PU-2-qf
zWw#FjVY1j6{J;!3-i685INtYDp|d*P4Pmu#yz>utdke=q|2XR)p3wT8S~4l7MgVKS
z1FZc3to??s_BS2x`vbn(kFC|RsRTLR_dCAgAbh3i1kR9%#X-kc>p9-{Lk2a$7_WA`
zx2~Umkvra7V~%%`M2>fkeH`!mfmbbgp_!3%Q>^8Vcf_gS6(Pog_@wm}mPe|}1mVq=
z^C|;SyxM9y-djz_yUALc$^h~V8oqXYAC97*=Uhw7x|Zm|dtB^|`PvUsUkEZ-5&Ec1
zeg>d?+`>`o=&FX*3+yq6xY^W(qs)jmU%T1VG*{Mj!`HsaanvUFwQmwZ+L+PiYd0fZ
zD2`V`JtlF~zUjX9c}Zu-QJZ8&wJ5=GlnQbjWwlU!grmqHrZ92@s_;J4F_csJ+H(*T
zyNXWpwG-sZ<1tX;#^8}34qYM1w<lja2M?p+=?wm5Mn|4B4!1Du(nb^wzo<coqN#!!
zwnR^wAd%*<nbInT0TS^-6+!|RRsJ-Uq>*W1BpU^ZZfA#k@M@t*tx0WYK@Gf7RW~~^
zFGz&%mk11S4K_3XEVzIx?rS$kJi6E{2i1Eb`F=hIi8e|ns}7L8n5vNli8eCU91?Ae
z4%sX^+wDqW3HCRxB)6NZPp_a2sVIkU8?qjBCHb#0Y&rZ_user;7QOB4t4jY5B|-Eo
zc~e)rj86+|*eh>)ceu^*(cbcFU;Eky;iJ7}=ibpC$47fhX5<DZ%KTo`)gC^)hh!}l
z*3j>bw$Y*bZTJW+B306|O&$3vT49lfn*aehQCFRJM|iqCtie)tZqX!rPVeAsXLDOz
z?~+X$rNW0@0FpHy-wXUm&&Zp;1V1Rqg{>XLaWpJd<}u?3%?7|>H9sIx#1UHrk$dWk
zn+jY}pj2KX!q_=tBD9LU)!?I+Vyj4reG{%v^Pyu?XqSkWkq<jWHSCiAiD^>nyKS8D
zp1N^~zT2g!hFH>-RuK4zOH0WuT7;sT_|QgsOg(<1{Z_<-B?rlw6y<)5c|FWIfv8#{
z4GC1l2^^oX@b6cxZW1!G`&+bSW1_mQB)2lL$l)LBrIqBC;gSw7qi*0IHmsA7AS0)w
zjqR5wAEa*eBzlND3~(*s92XVYxa$i(0}n9a=>zFE9Ze}(5sJ8^7VRuKEH{<P`kjD~
zu2EO?M|&K^Q0Lp=UlG*ndb8K{A9-C*4434FwWs<z9Fs=W$tyH5+YysVwd@JdL_rLy
z$<onOjoHMHmE;<UUfW8Lnz715KiF=s7joxYoCSBxhPNOL7)Q@+#(<Z1)b{i<w9o#Y
zB0z<F6s=)Ysorj2AXPiLWwg}j=Ge(0o>&dHj?m$_H@x(o{l+1xs3VVUqi;|$<{!3R
z3KhawXAV)7#8@{ctu`zymbfOWgSB0I-;T6p+`STx;c&-r4@0UDj5}iaBDl5)0_9-N
zB2A+Yml<I=ix^;>6nBkwQ<54VoJA}Ik}YzD#SlnqfLL%Ak<E<`xnc~;Y(tXJaocJk
zB0<z)FzznV@QVdb9v+c&*ewMVT}8VCl-X@iW;c}*l#wq9Z>IE>mk^=MvP2IKElcY>
z7DGUu=Y($=l!1A`&=XLGi|~<4FtNE4ZBe}dO*9MGxmQpIev@niNu$FwK19VxLnjCw
zv#9V27VT-)U#|l-5yqQcCU0~>J&@SO&C^p_aH|rt{vZ*af2B+GJN&`#aEboy{`P+Z
z9eM5BR3x1x?5Z!2RaoF<=%ZPnwQ>Tjr&V~`y+FJa7^`}Zf?zD{_k=ST%h1cP=>@Wv
zj0f!{BzuB3k0!zp5st|T8Teav@4W{-ud@MXdAWG+J&@5u27oc>)HUv)jqXU*;2*kc
zY3LG4Uvn5^)iD^u%mOe58DAG;phod>XYmfT0=5zH+5BB$btEUe57<aP!uz0ed{;rH
zw%!yMgWO5$zF-iFoya74Hxyfx8)2(@MhI%%m!^GX?rbj%ReXil_{yw*g^65qO0AUV
z9qq7Z%rSM2Xa^y%r(tVlLt8mdr_@$y+#Nz-t7*Y9Y{8$idZp@c2WtjAb&<jyc1Z1?
zwGtNZu!HgJ7;J~kNu5?0%&xd&irgWqX#`<AY`$e{!SO-OyKwUX&6sjzz9rZ3ji6sK
z^A6Z|m?He_*)cbjMVB&l>oBZe{@(k4Z1!dXfBOjW5MHVuzt3gEVQa%n=X{FVr5G-2
z$tn=GhUN~(VLSBQ{%ETtt(~7O=z$M}poblr{2I=J!;Az&a<vR|xJ=OwiY-+POh_O@
z)7rxR)jT&HSmQ9m_;{+s6*KCP`wP~G$X!)=sj`wxVjf%SNo5ofD%_hLqwE>Qms&If
ziKrkgtBMp~+5tWjUuwY&Gm0wZjidIkWWY?Ry>fW<wGwEy^(BAnfYKSEZLZYeq^#^d
zki6z-`fXHiM$>&#@cB)g!xI{QTR0`kRHtN>Q+OfE!B>(W9B$X)^~_{&c*AhSV_uur
z=t8KvZA9>z;l8uoBt=Si^ZV7v`^g(TBjm+j(pv`~#f<bjS01sNsGqeYojuzR=XY>9
z%%g5r0WjuP9ak}AxaF04i5IPvi>j`oDc(ortO+Al=Dj!k_`wka_&wpr>qh&pOCGf!
z7HFG8gwer6*<*gm2{a;I$NRYuK6ItEUXCw4Z8ZplqzgqT9u?UjtB4p#N`=cu8H0<&
zs0c?_)mIFwz4%&x@dy0H*9<S?F&XSvYWnvs5@p#KxU%y0%`mk#8d59_VH3MXF=LEt
z)o$zb{W_~U-In=l>c-Zc(XTv}ew#L^s+eK7w`y6Hf8CIJstxQ0rWVm{YM(aJ#mBdo
z1H7i#-&C9knA*bu3&0r6`!Byqu0AaR9<gbIx)_>S=W6nr&T1fVYO|c*p-gRtArzzg
zA|=o{<0gnINmomX5%I(LKm^ej0_b>IIJ3#${eBH-eAKV8f7Cxha^wM3Us+xYm#ri=
z;d*8Huf=l#JYOl-jAa&r`L48>+)&vo6)05<1C{9sjXe&iR=Iq1HsCC?vqjEw&fu(q
z1Kc*`00)jZz?Hi>Fo}GC10e|qIWYb90uCVF7jj^y?pru)*Zx{p3N_!#VRT(`8;5<)
z33yXZ@$0ff$v@$+<xui+4$Fs<!yI-WN?ybPCSKwI>+az|Ch#r?WMzw%vEa7YtA0}}
z%Fpr3rv0o<&@(xl{4<E#XG*RT3>s(W!{y`bs&ASz_DbO|5e2`6sDx`)WYYwgK4Q~l
z66Z|ypHuZn1=+~w_=R+|t;{svEM3Qx^<Q|(IEwmWI^3%w6;8~-OaW!dT;CMfvo@T#
zHU*}I6Kf0ZQ|9un6j_?Bu?2YMEXIHWbH|K<T~mz#+lgp-a^854N89YC?XqX24#xwE
zuhqqB-Z&ToB8vQ)92HPZ{WNb3Z>*g+MxDvAg#b!97~7{p*rIl%bt*&R6u05uyId15
z%9w&lo3p|CnmX5KgE=T-n1g16IgCdPgQV40gM%^zR@@L+ks&}W&5OAnwBczt1bE4x
zwyk32uLbB;)4?m1A+XXk1XkRQx#H8oEAGZzam;Q7(k2xXDl+NDyn6a{@D6Rt?ruyg
zvPB8zp-@4N|E(5rI(WAMW=lvE@${7WVEiG{BhL(r<J`H{sd;V5c3ug;XbaPOiTpkb
zY`P-xdbwfm2p6xwf6^!UD_<I*qVz%eN^v}6WN?_%^DIWAJ_O-Bv-%*ypV<qrgUuTe
zXth{etD5UTw%sip@LCTzU?BH77(-txFGGu8X5O{q^gV0^#JWP%2xNd;tWPR}s35cZ
zE)UjTu~Wt#crKWMvin3cjXjCWZ5T+D|JZw3O#1O0xpu9%iEqbG#Lnh|$0D$b5t<^w
zY)`4H&^Q7V87mrXO)kV{A>=lEDI6}-O2?ICD}#o^79s<o-8J5q*Z3E%QD3T^LJe2(
z0~LK$Jq>pidtI{>0Cj8>+(T#|s{yG2o&j57>EGMz-`nKhW03M0#YMIFn$e1n`e(Sn
z2aRgiXk?l1<{FJGTcXV4Zft7|+h_XT9=@jbShK43q<n>kcBt?8o`lgg8hA4tD7eD`
zVbtb;CZR6w9^oBxR}qF#`OU6Ttl(bP+?o}@%DoDQrgsuQkhqObveFxEi=AY(r`h!5
z)%f+0t0bJsimRDA<_|jr1ZZ%z+-O$|#l#E6)yvr{4x@Hiu&ZgwtGVE?hJpyG4C{PP
zVCn)(G}(4QPZSEfIiR|$$WYh;gdo3tVUyj5;#bqB)@tkM16n}d;!W$E1L_hYewf@$
zWMstud5I}Na8<I<(t=T%#Sdn_u&Q{4>$2_PXBNsx?9%JHPvz>{x`|A-RUG!%3*^^c
z@39r_4QbJgEJv>g#ntACjuiA%C!!FOmslmxLfmCMb%3?j3|()SzI4FZu+dT%o(IHo
z=HKB~NFqS539r!U?cU&{jK($Fs>W6G^;V&B`BW8+&p-K&ur?gU&dP4>(FRcpK^Fd2
zbKGqIXBUbHehZ;}o>;6d6op0BlH1GHj%zW$R*nz8n*;pBUu?EfI=Bma@6UNCtfeo?
z(^gQup1z<YTTlNn6-9r0dB3V(ly|j0)Ey@LdeY{QwX8l?r%LW?g^=8r?J>i$di(z5
zy85$zy?*m!>Ezn_5A@QWR?eTsoc0`abg!+P&(uzqGq7?#6V)&)@bW*BB7QhN%ED}3
zV~u$Zq{&Uf;LM!Zuo}w?s3TJ)Y*<a-`RrC|OkA|IsynAc<BEBE7`LcQB|N5|O_ba;
zXHX2=K1S?Y%15NBGY-CdnIReqp0zPiFlB~)$4H1l^W-*T^b}z!ehixT{i<mQzGhpg
zs;A74ptUr-U-=O-hL~;+MziuH*g92~_etn2Omi=VEvk_VGn&p}0U${OG@V2IA`olD
zm}VAenBvZ`ErB~km`ati$}uF$=#@EZJQ?8x>Pk7brA17ZsE(tQ_s_uf<*<D4;lTVV
zdJ&1OFAQy$+|9me?k1HhEQedrqIg(f>4_~UT#%o=euW{KClZE40qaxJ;w6*AvJpc-
z9Rqyri0o9#6?8H-JlQ5Im2|KIRj#(*WnJ=0QaCk;&2I9D_PO=0WST%<mX2g$i|QcQ
z+d^QrB(M;H5{Z=@;BLO`iF7QECD)kOYFv9y1tFQbUK!X+ZSBHcYAoe?rCj^az(Cff
zOvzS~$LKz(0UH>jjsycvBLoBNqxBX(5HMRa$qAZQZ3U*vP+0<M6OAt8XMQuM6Mh$|
zoh=%3(|`D@VfavP$^cVdoWVx%;8JGm8RBk1FO4cFrHqWNb9jW_px@q3T9XoLV$%<_
z+=n+U<B&F2<f`S<8JRLtO|)w)pHU%uB;hsJY;{dNn~C*>)X3Vm8}Hckgq75iR*?1z
z;rjL}layRoTjeOAR9Daap`0w9$p=<}6C})Y&3xrhF(_T+g5?)G5?{|z$etAEshB#1
z=W%pEz>Z`!a?A3bWTqCfM(z{3(q%OsrI1e+k*C}z*2P!L-ym6?Ny<~4WVQCp;tv`o
zR7i#7+Fra$fuffuMfF)f9-CqkcOnhSET2W^ygl#z%uL#OgL}j2SQ2DueIKq<?u}+x
z^=?~iGYkeliv%f|;MNIs@sn1`9Gjh%*}WvwVTSB=8cc)}oV=_2{<}-|FHZT{zIl6*
zBcE}OYNwg_PMc1+d3z|cNCqFu_4MG~`KUd3EZ1~@^MCHVR|!)KWQ$}yBK?6+BoIs}
ztyO*|{y+x|9?j>;i>8v;Cs3=D35p<hSCQQX$Yt3(KbZ&{yd#%T&=(mgnO#N<^Az)I
z-4k44=}7CAyCq5Z&IoZw-B02i(`J=4wk2vngb|6Pxu{Q3ucCd|2)ZzgC2LVbG^U*K
z^Q7$GrJs1jTICt4Y=0=6*E)Bd9LZBweo@!;M<1m#_#Zmy&gXSUe{?6K6XBy1x}$Y)
ztjQwxXCST`NI!^<l7rdceUi+rc=%C4zw+ODNvbz5-%`Kg@A8V|Ev05<YLi}i!3++g
zy<%2m2$fHcl|za)cxk*gbQ^5I*HKasY}hs+Y4sCXRn1Pbnm><jlkRDiufH2o^{jhM
zve?J`%P19X{2*G)a%P}*WLtleR8eLHS1~K3Xg);^?GF!^uZIQl`@WxoL5a@4u#{EN
z2-a-92nG=b5KMxHgnI82Ql95eKKPMbJr8y12XRq(fB8CN)9qpeKzWg$*v<^~FonB+
zjNj71GkUmj^9sAib^8E3eg#E*Fz@yLAWLTisNf_A6q38FzEhf1It2Yy@Z>$x|DXbz
z53V9Qf%xm}nEuxfvSaB$N}vO2=Y*Pw(Vq5lPK<>#1Dk_vFfw_f1+UO=_VBGt|4M0d
zZ-%mb<bfiff}FV7z3e}ciS`aWR0<q_{e0qOpUG&nU$cTN`4#mO4r1tO07#!|%#{Bo
zJ6ZiIcb+;)Q+S9kl}~*T&9kq3;+K%&r)6Qo5`BzU4qcLLX&sF5BRaxO2!&AWL8Qhv
zzZl>A_LN{|8#chPl7XYKo#IK{j{IfOp|?a&w6wsn(Fl=xlvyJZRlD!s>K2I`BPyx)
zo-}O*)kwBw5w}`_i5R1q%@vr|eKb+w^biCZA~07#sqF|RGm9J3hZrJnNmWH54Vvj|
z`BdTfb!=`~-?aJkN1)cQe2jxrOMUxQQ9#~_zwBjmZ%AJcLn$n~jp|YUG5bOjYrC(2
zei1+o`Fw0ZNX$|lp<!Wx2(uX+G&Z2&m?N?+7yd9cF0?FX=u6Rs16vOJ%G3^YVQk&N
zv>yk>(@Bg+kc~JMT^zm7M7mUK*Jo&kmKfxF5`9D@4rsdrlfxht+D49WYcT3)fakuz
zfbYq>UQOlJvE>#`$MY@e467_SveddcqB-5(&?<dfUdfeP=ZPB8*6gw7&04o&t!H91
zoxPSTNA5w|OiH@j7)fg)`ZOI#O+gz%@ysv^v2oTabN{d|z!#r`zQVr;S%GEgi*`~I
zFz|~BW!dTLqq{=4TslGnbVm<p=>d$Pr3aL)r3cE3r8Z{AV0-&84VoD|$N*kRUM>)+
zw7|kn^u2u?^BW3+h3GGR?M8+NcXlesBrjhWXQza#l5fyLSy^7hP%VQ}lfC+NAUSw6
z-JvscQGvPj?B2sl?<W}FArV;M=g(LCOcQSRmb}7S@-5zyZ^rOJ8Q`ea7=brcH^ZXv
zfklI@M@|#zV=v*1&`bWhrMgSy>cTOlYc$+43E~`b5*UF+QlsUI5y24aC0@Hjm`d#4
zb$F;gNRBF0hK8p*jwUHZnI)nKX^%@6sCO7@A0l5Q^w^+yFY~|KN>^)APnL+)DR}3p
zlWZZbQ72pdDql^kC)+2JAygkzFNgehUy3A+G_GX^TwTiydX0f>jx_4d<kc8;T>{x>
zMHIR~{%LVQC3Li_`5hRlZA%b~<S4_6iB#eT76-+&8wq0DvTxdr1hKYlx=qnx?X<Pr
zAzk*>h00}_Sb|stkbDCsu|Rf)cVu4if|v_xCr<6e({NS^ViV88>CQGNm?$x-s$f%M
zW-;2EV{#WlWOBCA^XhzlHJZD=n5LH$?!z~t$4aWSUH$=<Ogm<PP1U!Sr1O=dd1ZhF
zFVbRNWo3Xez`6p^i>opprbzw&lxKM@=Mj+f$22+5VCqAC4(rN!6j?*g^JJ9sZF8qc
zy}%w;{@^|_zH$NQp{w&oSKIK@#~NL2rflBmY8PuFJzbqQyV_)fb+uKRQKU-K)l|?T
zY@m+GktBscHn6O#RfxDn<WpDc3*NQ-rmIzj(A7kYo~5g&<pO>N9dF+8M#nQ35oB9E
z?sDUVe2f#+Zq_n&COLr%H7DfG3B8ZBvNrvm9TTDe#5f31`qB~)8<!!!lr0AjUI(3x
zgOGe2geVAnJ_&dMk6w1n%QmN$If_HjIzygM4n~HdaV5z%2OWO~3c(TvkhO#~8*7`{
z$*&yE9A<jF$>m&#ZPW1L)&%Y`D?mUx3rVN52BT#rQ)JBjN7pv6Qbw-}1_#c{U<#?J
zAVy@P3z;++F+&u~aI9V+>_YFm+)>3PcM!N5L59Bhi1AUyelky8t~;YSm(d!ykkn#<
zC6yG|`4ic>u57OLUls>_vA&!+3mjA{E6IE*5$jvW5v$bc1tHd%taE{q%yj^m5*`#{
zZAvoM;@6VQ9m7GA1;i?OsW^4{g$)F@Ys3oN)ga>Fh*buXBl&<>+ct<Q#M+L7NNBYc
z29XesA*TjbjW~5iIMoupqZu`Z(B8*1hFTg!Eybmn<tCkgA+=2Mp;?U~LkXE-gMteT
zNrOSAqSoRf+!4Y9l*eFzx642F;euM$<}Yx6E9Rnx(PdkYaHy2OR}Cs4v-~Q?%k~6g
zL_@~Mh$@zp8Y2eg+NwV-2xBCT*azaFNi{u(F!neU!5GGfZ-S{GjFHYW86&t=o+)Bc
z`>S!`Y7EKy9ICMfVtJNo40qO9)Yx>yf_91$cWjt~SPbMh6c>o)EP4vI8%He0hY_&^
zJv9Zf{A8Nu7|*U<#>{8aS*E~pllaPDBu>hzQOCfp?dP#vVGMrw2j9|<A&u7RTMhZT
z)6JHL3Lf|ZngFU@QltLO7e_??LD!7>NV;*Q-{$iAN*|^Z<y`4^qOIx{_PBLzicazh
z$B2k;wlyW!N<YV;Zkzoui|3vNK$s?mU?37e`~QqG0x9Id<;7~b+Kf;f-XWY^<<1jy
zn!*<`B)cXDWnweG!mE!wjvwPUHLn|Nn78Y~X*q@3Au}{W89^me8Cfh-&DfW@F+_-<
zH=)pCb(lxi3eqpt3QelXThS3SL!>aRuO{(`fFwE?dzxx@6n{B$JUNV%w1lHw&XIBQ
zy^ZF=dAzif*tDJHlYdGjS7{*LCuYrXR1W?ZizgZN%0EwTD0=13q&M6nnt&HnIeZds
z&XwkB!z&zwW=oQA#w8(7HDqK<(sRy11wJvgjd9wNkX3nR4BK>ygud2HDSoBMs1e4Q
z1s$PjmJ<f629_`h-fgqgMKV6ru6L|uhCshJhWpG9@Tsh1k0d^1pT-V10!KRYE1J}T
zS|yP?dTH%|l%*$QC8)bx>P|UMOx>9YWN`SKM*T_1$b~4t&H))^5SSTKt2@~QXu!Oo
z?o9v7kg3(3CW{)7Fc&A_DGln*>=RRWa5hGj)SX!*;5^P;-HEsjNa)Hi7$z4E34?)d
z9>VnmdEozPQg93s{%|Yp%Hezr?=?LkZ$rr($5$BXa(t2v1LJ$WeRvEg8D6sO9`J~1
zy9ZrG3cwQ#`FgttIevA^#W=+?E3dDRM?$dx?(v3GiLqB^W8Y26cDf0hb{U4V58+#=
zH|;|Gf$gI6gKnw5;icvQfXO8;f!5Z*lR+W-h<XZH831F%mT{kV{IUuKqW|QQvAw6n
z$?ykWW1kpi0BP8%ojw<yS)UuilB_cTgdma>l9Uo3v>KRy{rw2|imm5z$2PT0HQ`NB
z?%;@f6uAY(G$JivfZ@&4v<Iw5-={X4El!g!0h2dWn$ax@VIe-+qX>UIuku^FH}yV}
z<I#4ixkM+OJ!#WJUocq%X?+7VMhai`4b-gDMRn_R?+cT?6Mcbv4Sk^|h2E%aN_vCK
zW>vB-Pl^CTGLe)NHK<{teQuEy#DXZ44(DdP{?qk!9M)P08gAJ>xAiML=C7n-hp|wU
zB!NDm!FqD=b65`HD=>g23z7Dk!0<6`vxn+mMm%UEZq&i6*1y25+N?WU7mKfK4|b@e
zJ`_{U@F~DxkRW2WrDR6%9u9(y)Gm|b+Dwq{`m<JZvWPKb-4%z9>H72RE@RRQ?=Cq3
z)P0$ETG@*W*5xB-vJ%>aJ&QvJ*q+6a%IyC@!>o@dI!1nQ=3cw&vLwNEVo96yGEreH
z39^uQ&{e`zP>Xa|@Ry<-xf(<eo-JJJ@0N$s##^kAHcRHUs!q?C?<QC^@>eBYjPEMu
zk|=r}F_%l7-bQg9qfQbKxxSkAPBEQEPdH41+tg!&KeCCr0j_Xc<Lei|bDFf%%YuI@
zK%QFr(;Z}5YHf3I%IU5MF-Df8P+P$w4pn+{e4OInlqS8WI_Bi!(+|fmGynD%vdDDu
zM76HxD=3&PBYk^gH#z=^zx~foJ@Mne{OR(W4Q*xm3LJWz!~m;gzdS<ii0B-tmV|zM
zm~CPPf2gV^gRf;0{Y%*~p~|J~rOc6XIHE9FQv>PX3$D!cGGFr#+N5bht7ne?@|S<^
z58nLm-}-NV_6;xJE*WOuKIOnkYoe0DuThp%5wD-J2e?f8^#Q8+>bjbDB2e_ytGzC#
zye@Y#d%NbzqOEEpBluG<!jbbTzZ0TMGJTR(mWR2|qMq`r`tcd&TRm9DrqBvH9FE+f
zewY3?8mVHC&X7)Gwf!WobD!oH$#MoHzFlXGtwY&uI`)U$D!<B8wwf<1zf_-o{9~uR
zCrUQRJEivyWv}31l{%E&X{XE+7#X-q3IS!n%>)d?M@1w0k86-kTV!UML{L8tK4!D_
z`dvQGhsxQ(e=w@50u~?c)e5I-$AYz^{ESr#%ByfHq3bWTZyfRO+eeIrI9uczH82iR
zx);=;Pr`Ez+K$o@JEUdDpjwDmP*z*|oMfwL>cl3i#SbiiGMOa3+Jb1(tEe0*ZOWXX
z_p!X^!!8j((=d|I8*E_MSahAmSS2V+n-R>9^^=}TpoaXhNp7`||D{=oF8c8goo0fa
zdqfwV*7-v;+&Eyfjd>GCj6R#8?|nGKP<H_wk(Ag#NUGA^ecBmj!tn?bJqe50lqWlP
z3UIJpXq@uI&&m(wb?azmQO)5EHAudFP!a@J47T=oYs*aJ(6reNxKZ~Q%$SG3N9lHl
zj7*tYjDTjU7|Z%T93};ta)@SNq#eBz{83cP+<JP5KJe*zUTWy`vrM5$S)h{N(n{Ow
zP)mayRTCzuL7sfYr>LE}I0~r@vwCbMWJDA5=>KWNQ@E-VFQ76rsae6NxSeh^sWDN_
zKTrIVJeLZCI*Uo&3Z#@D&`BwxVp2Pp6Rflu(cDdHrV`*QH>qhA%2Y!Dwd>X})+c?(
zEGjDauJZJUVX;*~9mW<+?ta0%E7?Xt!lYgv2N0_bPGM~&TbOP-${8usk&jwHi$+fh
zV+4>cUN^2+?1{tTFsZ-;n(QTumB+_Y?WXz0&US_ioGlotXJvrePY>5v%bXA1Ka+Lc
zjotJC>r)yyxv>J`lYs**j1jD(<O8-;ijzJS2w(eDOsPt%@M1OTV+;Vnr}|WIr?^ig
zI~xN;pNfWD^r;vFgl-QuC0%4b73;S(J{5Bjp#m?BPemS#&frNUNYr>0-?*;_@drY7
z2MT&DfM|1VL<frbHKLQ*oEmE!D49D@tYjpBm}$&`k~bVE7@@&|l215L@(Bk@KFxuG
z;2LwF7&UDa$Y8WlU@-|c3eM#~nLb}&4ipft<_mh04iqj3b(%ap`<$E27YNDM4iuX&
zU=TMPC^lb!>~A<wY`y?H&Ge3h8x9l%`kMKI<_L`Q1<6zgicQZ!p0#so`31}u^!_X(
zvd+Szl$Ysj>J5=>qqHT%G`H0)XsW><+qAUhFbY%KU=<{iuXsV+Et7U>M!_&{h)Y5+
zHcT<O_#7j>-4@e@AWOcaSt$-6ia<pvnvwYAOyd$;Bgx1B3&p2I_1mfmOE&L8Hin)c
zip{04A_${*3NRldE(|%unN#pSBHT+on<lIUVJ_&2D*W55awfz%Fm<%#U&rJh>@DCR
z4QI3^{8PXIMyhon;ZJbPTJVrp;KAe#X0BpDpp+t#TLe8K-EI0nDyJ3HAad<iY)zg!
zn-qjhZjeQY5%r>`<6JK)a6p<|l%%VKG8jif8K_DlG-G&*W)#`w*G8`)w{XK#m;A2s
z@t_<TA_k!0wMNfa?0oH0I12`Gm3T>~Fn;LbOkupK6K8o*bYYJ-F~PdpQR5Dn#M6vY
z2bE+1ElC%+XcprLXZw0ssVA%?9}D*6=ghf7;wZ2(L!zZHFU)?H;Y&WD;0RK?Tr1|)
zNgBR8gdz-&$#+LF+ibEyW74w$OXPu(OhsA=?(j1eDcnJ;TFj$z@aRx%V}h#*8Dkmb
zNR!MNnvDMyk1gQ>T=KmtNs^)2j^CU*{b4{dKrYHsWnpWWU!Gfv?qZNzlR0NsnL_so
zN=BBn2fv;3Nv<!7EVOVmYZmd-yB@G(@y+v8+hTV$l>i!p(*r?-%WQoBUBJ~P^@MT{
z5ZI{5WVR`gZJ#4EeBB4pYDPAjkqD)k!_mmAa?#lE_Gx0%%0?7xNU<$HJ>88xUr2z-
zUBDk-dtzuy8>q43gs%?9B<$>YOIVx7k=LQxA==BVL?_|R8qtO*G}5E!L|@xHwh4C3
zbK%<a6Oc;Zb}>u^@Wc6-3bTLDOocQ5KQk3B@l5!ST<A>rU)TD35*dw|vX$YFW_81#
zEGTC){JWLz4z_DB{BgBuElUgQRo1^&;*1P$F(ImTDjd!x5)o13dONxXgp7hc8(agn
zM5NZ;NNnkDM7Tz}A!3^-)<O~qZo;G~!gRNxap`W&G*jR5$x3%i>Z$^ACr8n6{<=H(
z58iia!y?{sKFpv%2njlyNuP+}lA7zS<`Fi_xSeE<rdJ3WK|g%64x5kIB+KAWO$i@C
z3Aa4D{6(nR5>K2X=OjUqpqO5&K*4=cu5(q$xvJUNtZ!A-apWwRj2|&#Vj*WSLjz3n
zo#g8d=Tc;fXRsOY1NM2(X{3teOQzKH=mF&hrA5T5SBRP<L}DAaa!^AK1)2!XkVInp
zy*z7d4eCdCTw*r)7Z-(1{$eKGAYYig_JK*Fm(XzDm=rmd3Hlhb7!1la4}2#*0mt3O
zy~+jv<bq17oqWycses*`$d4-LEd%lt)&Plv2v=vp1Iy*AB>@`Ha=2@;1vW-YDGXv!
zuN5M^6LTUj|I&ih`FWQBBFu0g`R=3XD~(&e92o01`}H+`X`#cn@)q`wrleT$#t+=i
znvh_fwu(LFiv_;N7Ylr^77MJfn``~?AGNV@=cw;v!`=j9Qh??)&F?ujHVvHlY!z#V
ztD52nABp=37_Yeh7*Lx_4>d0RK2s5zW^J}^zuL2$->(#1YH|9?qv=gvccA4;@;yU#
z*<4A!cetR#tH=@qp<g{@ndcH)NRu#H1La$_&6t&AMrdB{)evW=v@j1Xi0GIqhpxhP
z(crX~$i~YOVvRGl4v6TmVPfio5SI?d;iyIrjci(`$*=GBHSrXzWMOf1GUKDsY2%a}
zT8Z*ZNT$GGGT=~JZ4Q8{4hICcCS$Qg5kOjMv7ZBIc7+2WFV}KlV)jKG+J_QySSSTo
zp986b<UNc|<)r+2+P&;Mnk6L$UruJSKyZ@<YJ2D*GqpvS>bDVXZ=e|hFNQ%?HXy~p
zUy;?|J5GB}l2<uNzSl|eJ(2z7Z;&s%!9)?^oA1;-uZhee=|LDS`hP8~KubQvs}E}(
zLhsksObuja%G>B}s)0D{8<PX*+_PYW`Bc4smYD$-VL|3Bc<gzWezYLmjQQqy9Bwk!
z%tlv3&62mU0MC-3kui=4;$#7onS=sHF~<gBz9n`q7XF$ZiOgCD`OBMH2OS1I|AnlY
zOpT(^NM{i$73s!eB20&#XH3MzJi3N`9pLca+gJ&6(9b$tVyv_fE)js3#LDv^T%z}Q
zK1pojE_tHXC$)Q~U}%vXK(~-*X`=Z%qhy&^(I{x98%<eQ1VaoUVyTJ(h+1lYc%=?{
z&?~KDjaw6MS&p9YRvp6<-hv;)t%<iRU2AnK1}%iQ>Y7iyCHtF^((E$6V54t(go{d&
zOnU~wD?*J8+xTo@F^E4T%M&>%3Vd1&?-013{EBr@*u{%%naT$aT8RJ?XvMPc5+}+*
z3#IYwYb!tzS<u0(1Kc|D?cmly3MnFrNtikejyMv%8y4wd)$nYPTHaMm@W%Khbrq6N
zJlVp<d}`RrkA=R*ZS(FhZ0#xBFLFXtB|VARWNVdUujR-*b3>Vk3~@=dIJ9y39CRc7
zW|N}-(3@*}^B4Z!_U7+BZ^tIy;OAy+_9uqs2MvUp$XA9YQZ4z&>_5*3=9}eha4~Br
zWQsV{CCh@ML=q0D%Eacx(E>hW<WdkprRn;??=T?~021zSo+R!&MDJH}pMnfsN&+J7
z|8rIaO<V$LPhfF?SW}vpA!<Vt-9-Vo2bTtP7~J-nl^MAaCi#w^s}3(jy>mN8ALFEI
z$ali$hC#S18=1uu%K-6s;wn_33eA-l!`vD&>V#XPpr#K9rl2qpSGX9>oUWDe^(0Y6
z=?F(Z{)<c{oYuk#r+F03Up<!21`c4?43;KX2x%|0KPXyjKeN3-zk#0X_M=9;{XXr{
zXg_>aRLkFNZbnrX=&HgW9N*@32Sm_yp+^U6Eqc71qovB>SrBTZBM5HS&MS9pzvA-6
zZI^A`vU$_S!G?wTes6BJJJV^mgzk3H7DspQFx17YI{TYTDG%cf1J?ER-F6+@O3q3P
z+<@EI{gCzahFHj-5Z0!s3mqs}C}98!#z=w$tpAQc!I!NxfPxd!X2~iJu2$thLI4M)
z2fTt!+;!8K%_8V!!z<Fm!YgxnFoXpAe)1l{J*)oIn`BsnLyVs-(Evb?s{yZg#3#%T
zUa^F9MjG6mNQO2!T!wAnN_Z$6{5T%4ihi2I-KlVYo@0_~46IzEd>C-P+j9n1V5%7(
z12aAbfT)_5am>jXMzf6?)(yEAAtAe-Cc!!(U>fIx1`~-vudY_VXwO2rCidP9^F@Dm
z)#E=p(c`0adOTjY9v}P<h`P|o8|HWQM^$k@GEv-m3>2?VDQ;&Uw@~26w@(yT#2XX*
z=+~dm{D>=MU`%qU`H_9U#`uwpoa6k+`Y-Wgcak5K@%|F>BP`c3BL^8V!H-w=i>k+e
zc%sMIZP7*3M34LR=W~yv)t;LkUz(6W?`?`HNuVX~@ukTgzxvYlI8tG~9^cWgb<Ph>
z^!Uzodfcx+pL-n7{d3dfvXRFI`3EKkxol*Oa@ok^YUip;+v&*e^*Vife`ht!-!{?d
z>{By!nEUnTbEiLNKw~t~=O3Ev^O1M?XtKxmT-qK-cCXjtS17Z7=-7uQdYmn$ruMjB
ze?Ip(*2!}-%qOAcdnS8)J!rZ6()KvAd%YgNyuYLB@wZO&`1W;r+^;{MdmKORbJOGP
z3Gnuj$sV`0!)+Ou<5GQeX?q;Oy<U$m_P19({+5XzXMf45W8AMlpL_i846gseBzRj7
zt`9G5k0ZF(>+x-UwiXE;`{s!rzdYWUfa`w!`P}17c|SK}oM3@5?DngZJ&s33&<$_S
z_!uuPZI2_k*X!}i`j=Nd{@_H9FRs($eqC!f8!n<5{17wlBAN*<qUK!Exm-k+@Uc0U
zgo}vKXx8lG4T@g2X)Yp5uwpKvuDN*#u5W7{O2L7c-P%PYpA-p}IRsCYxrp3Tg^P$2
zT%P74YF5Ka!H?6Gi-<%cmb5@qT3Sz}bqsQAa=`S>?`8cY{$#~?Pzimm%bX}4B-Mm6
z@&O{CE(1@L%HY)-$Gk_o=&ZHYdPivu6fbBVRJ=!)IC7{65Y8|J&3m*BrxHsW1`6P^
z)ywUr#P?6O7%q8_km(^uiFU&q^B!&OFILR(zyvdFTZb9^`tz9?2!na<nSsR8=VAt=
z!#Fb#9J+=Xc3xU$K-{m#3|q7@RL}))nqY>@;*AMi5U;!M?}JTO;^zKkRdH{eC~oUI
z#rgFK-kRczj%yJ#<jy5%Ebnb|gu5^L+=9jvs_+R^o&3or$r-1NKgLl*&`1~|XgHXl
zVFkf?`Jz<{LSiNen&77ALJ%Py?J{^DqG!wrO=feZ=a~!`&5VhW9qVuo%No{*5es~f
z7^$4lA#Y?uj9AtV!ft{S8c89shWuFL^xM?mT6Oj6L|1QFr>o<2=bWEva?Zy7ma4c7
zicyLF=^N)auTz>|H^x!oce>c8%#gS?8x&{5o|T3|)T+Cf6$lehv0gXK5Bi&{Dld#z
zdDA*oj@O+4Kiee0hW@6iwE6MUHm*}zygsG0h5p8>wElQ$7KREFmJ`F;uNyhRtYhS~
z#oZT^oH(`DkaNDzu8%<!^~S5ra*?TaNW2aKSoiy$nrUvB?`!+G@YdXTY1+8RVxA@l
z5U;a7^08*m^!f``QM2Pk&976GUw>{`6F<@#TF&*^5IwZAJ6>gN-af7M@jA35nb4z6
z0?cZcy71P_cxl!330lVM-ZLL=me$oK?V+^JcxiL-`b25*x|jB$W<SsL*}*-O)*dfS
z`)o{WX}nHp>?Zf?&C)swwhnK##!J)s$7!X->t45?Z<f|pbar^l;_jmCxN%+yN~e_;
zuY27-+AOVQ3CsO03(2cXQ|5zdrN!%%MxVZ~Sz4~J?CPyCd8^p0X{E*MUfO$`eVQpI
zFuY|+gzCC!_1v`5;&pH72by)WUDCkVjbMUCXkUA600H}3f_Z_<6dER5ReYuAm^@W%
zGJ4K}7g|+zD(N{@+*F)zKuhMi$*_+#!3ZatD}>cP1z%K)Y#Wo+7V8}V!nD+HYtoGs
zHk~|p1mZ$9Vod(54s~g)MqU$+fNf%P>3N9#W7l{Eh}dlWC==SCN2=s-qDLc`LyH>C
zupn-_N)AWBM}z*%Y-<W$u`?GVm?Jdqzu*9xD@Ai+`Y%cV&6O8}=0Qm)&;h>shiJHR
zG8&FSM~D6Wi-!BPIgf>sQ(2xA{jbrwMo4fuhzZ5yhX*Z8eAW}+u{QW*$-p1aedjhy
zX*#F2N{A+F$o2X<0Wfym<@!(5hD^v#SG|SKso%m9nOa)BKBY8U0TA9Yol}=4Bd69m
zlh-4*bsN)6g^744Gwui%tBku#lq%A@!1~L&q1s-@x<N}yEd`+kdDY?b226}oiOp*y
zlr+#(U&lCYbi_{v=C*LYwy!BO64eU=tTaS?gLHLi@w#`!SZQGqnw3_s6|mAUqP;Xz
zL3L^II;CM%15Bpg0-cS0=zOvpPJF1bf&>cz99n;<acju{Z@e|0i*vo4h!fOSj6EqI
z=iCbQa8P5dnAXx2sHc1cfd<xM^S3%CQP|TQluAx4EQ7`kF>FM@p?QBn{yuZ()pfO{
zD@2n?S%;`Iu$YFwqAle#m~b;b%S@kiUBFTnxE3>g0$dGC<zw!GIP|KVk<H~AW7V7z
z_<w#YFU&)_*0lkUX+l0cq#+@xLq7Lv^d^BEZr6(o<e2geSm%doAa`Lg%Y#o_yret8
zC7Uc}Iak68eMC#Q8FS|qxIEcxIOO6s8~;^k_D`$Xl{TuEE$NarjI^A45`F}K3SoMz
zDKIk(5JZCph<orsq3*#qmabSPG#(GV9`g}nNv0bJb_%Tjzh|o$;#oXgv*i|%VfG@$
z5NnBfK<q)&PE*NIA%`q#7!pfR4td0sMsRqVGCG$bVGhr+sMnSjA~y@W;BuDau@q&4
z8L{NC#p>cEON=%6TkmeV>UUB=2679>rd9)KL*|URk(QRTQ%XKy$pMzgZC-@zQ*M|-
zuF*@yEz{$zZ7wM2ca!!}$lRz@ffB-97s7LN>YTd*=R&6jA#9{T{#W|FQ#)_9+_DzJ
zO_I6~c`_!y$_dpnJ#MKXl2Om>Fxa}><5_%6JJz~{$)Bl<@3=1YgJ`VOFgVGiy}iOY
zEsV~)`npzz>N-l|XM&QmqRf=;7CmVP-%whC`lcPo1h9o`K|6RxE$yx+QyS+XEuXel
z4)GJ@s&6<Q<SM(XG{yg%YpJ?tB3eY@6WTVwc@XbOHBcpXylrT(SVuJ2!deaHb+kRb
zNoBWI_5(qiDk{o;G?&#ec(iLage9?njh$g&ajo|4l=dCvW8QY<&6?1r@}kI^ez|fj
z$mu|m2D7Ditz8j8tL)k3`0T;>D7(=i+tw=x7X@%&IroeWR@J3s*C8+hSlyb`QdTvS
zVL}H}WZgMk7_4i#xGJF5d~a@5?h@=1hN$79zoYEzK^7y<5-qJ@^#pFCFs3HJYaCPM
z1k`JQS1{%4D@b{M>9;2eYoO4H!kR0bYr$c#+QBALpk5Qp^$KJe7EF8&`Qm`Ab%X)z
z*92J+3&N~TVIY}|$Kn5c7E8xTDuFr)-84arNWsZ&ir3wpUjybQU2Wbf-je<ZpP1;R
zNN=Q<`^Mud70E9?u6;HnUxRCHZ;FfQpd?^90KA{Lz-|qcp0L+q4?yX0qpa4J^d~bt
z&-Wg9>m^-n`b^da3c1CV;1XS9D+Qn3+$i3pY8g0tyq|lepe?9J4URkaqjMP>^5Q!>
zAL#f-G2qJzj#mh?O6B9=%}fxik_g_e7lw7bWkSbhHP~Q9PM2`qB*oh6E-8K*^2noT
zd$O3^sosh+E>@ZVNR8^^D`I(F$1;-K8FyQ)yG-v~rqeph^cs6+uJId2BgJ<&0e^tr
z3!ybjpP0xt=qof(j7IF0ILwlzuZfp97vx^Mc2E8xn9SlOuo5j^0-;MZR3_w?a3(yY
zwDw^J16hso5%?l)xGKq(*t!szY?i{}a#YKaNDpwIk9cOp^W5qt8}oC-F01rG!}1iE
zH^6P~m^A?MeBChy4h`!HWuAL#ON|0jS~b_`1IFRSMSCBq^ue?DbNsIt&Cl^rn;qve
zZ6lAsY)qdOqg+FqUNN_WZ?C|wF0*Fps$u3ZF*^qL2qk7oDq50C&(eYtqKHw8nfPei
z()?<B4>J_(5oUya?#zDKu4A@Vn++xETb3%GGUcaBsS770p{G>7|FCB7(!q~u?Ux1q
z<fGJz2h*tr)FpCj!E?Wqj=HR?rj^GCRs>;-H?iy(r#(tlgc^xdZL^C-?y;Io0)^De
z*8Yx}t!g}}K-BnAdLaFowwBE+6>-{&b@JuU2hw-7<(W|Juo*3LmA_Fa|0_N_DyN$a
zyHHocmPo1&EjuE5ZXPN`$81UXT={6*(m(-a5gjr@M|0QDC;m;Sn_|K1nl+ykvxl-R
zjB7@h0wR@&nFAZ2Yx_PW%=fRt_sF9Ce9d;NDEE~g|E0K$Jd;4tej5U=<nXdw=^2?#
z`OR)^x}x*|OKfS)d9UbyJ>=`MpEU>WEoXf@bD?9qXBd5bA1V{qW`8~P!PD$jQGPal
z_uI+jQ?R`V8MdhvMG<-ce$Q^$E=Lumsryqsf!o%&i>|Qt!vc}J5|Ok|HE3$LNR<1@
zOX|JpQZxFQ>{2j#@{IWWo{P@rok=c7_lxfjq^)T@&NdYn!s2JL^;sOc{+Ghy9}Ny}
z0=fkzjNK6?8imO)DQ#OAB)jr0+X09WMuhL$!yR~ALKr^pK^AT+RkJ;e;4-dvQJx^=
zeCUqy!7qkk!@!c*up*e-Jz2h!`6Ha;7^(F$L5$iQibg$l=}(5u;{b?+x4RVesX_9B
ztlE}>c+Rw?P*+?1vd_i<;d)RKmbt5UAzImCX*4SVI#+P8aF5wyPA)}VZ5Ko+anjgQ
zkmu|cf>9&6>++f+)4?yIdWx<>&`JI%*CCEEg?b~~W|Y&qE7c$O&6|@dV1kFsVc)#)
zOb8SwSYHWC<octk+N5cwn3KHfn!GAzC`q57Oe@_B=AoJ8tVKKHmOF|eFVB1kk@hS9
zBZBl(%E!@s$+r!tUQ+>he(4MBG?XEdn&#_IcL4cZW&y+M9klcT^;JiIW*oCz#&ava
zlU@R$OirdJd$&~1Bv*ByKj|?T;VbU{$JT*26rb+_M3!3BG#e=(ER&*WE<Hf!&m&9+
ziYQXX+uqAP-<pF3gt^MrPGNEdqBPOs`o)Qw!zb(y9?`)J>>76FG3hLbX60`cqoyz6
zgZyb7FW&MX?eBd@nksn-9G8ldSCXBjZ;WFtFL2<Y8@8OZofbIT!KA!;EiJ$L%i4j8
z6qBadY@18nqIBw7e(GP+Iln>qFSV~OE3YSK+T|nVPxV`nn(9@*)lA;^-@U)-q;smB
zCNNYzS~mENlqY@%7k<KC7<w*MZI0c=Z!d>VO;M`+_Hy)_jhlFqY@8|0f_%1RrY1;%
zDK>&tXCGjUcr}K~h5^R95EbSF452{MT@A2v7&ql-1@+5RR*0D+VSqtu0TmTG%&7n!
z>?>K!FH)~$v3UXekoByMWO~1zfWoR!w=>>kGBm&8-5ISY%^>h?OVh^)0GSxd0vC!^
zZ3aUOD3e2zDrVW3XODBcj`;XFhL0?s;MrsFj;{`(F8U1n$Kkia*{>S$E#QK17v>IS
z1@E{@tt<vs^aQ7!tsTjN2Oo=;63%bVHFG}or6t)had5TICxa=-E2Wcy<_&o@D|v;z
z#pNKc!ZVe;0-1V_&mgZ1-HC^_&nI7Es22v^<!6VZ_QOg+YQdu9)IXfxX8gvVr2Nf)
zb($SlIAxNFodE6ac@FmSwD<HJ5-4?dx(&nloyo66*=U8kaD0-_xo}+P3*+ycmOwod
z-}&=uYl#ZQLxa~D-@tPNwOY7!1ZyG@wC$P+1@&^aMZ?TEN6mg(&ECTAgVt)jO{+78
zoAV$1Xv}NxaR$c;-N8)5HhjDa;Ix6S7Z7%XFQux5|1TOMS#^Ll$(zn-!*64IpXuOx
zo{RaBQ)QgQELxW2w8H?Em(}RYUp(Hg)h4lbkR?5}J?wS-TTe-BB8Cpp$IAcc*G$YT
zspJ2T#sx%0*y)8Ehm?{xbqS^IWWV!pUU;P`Ta~um*;HW&ikY>X7jh%y<|W`@!t&5b
z-<F5p>?tk5WkZGmrY(_DY$*Tjd$uBUG*=K(gF!S(XAmlfXq<Pc)2ec>nO3!6=6395
zNA=_Tm$_Wi*qq#Og1Y>H4TLXR4&6~pvqGsx!YfBzZE>G#5ZYB%9VrXB*Ha3H9Lq8m
zkuh`$C+1MmSi4LX(%xD>AgHo(SpTMlS!0`RjhM^^C<8_;%AXwpq?iyg_KdtQuJqyZ
z;78+dak<#!%7bH%+emq5_4xUH<4Fy#_s5rRQ^U@X6j<Yx9YwC-C*$Yw8ICL@d{P*I
z<7uTY<M?>)$48-zem|W0QKf7;nm#epdx`6CREgmbVbwl`KgFJerO41fS$>K0!Jp<s
zA7aw<y}!=0+&vN+WsYD-$jysYI%V4elM5);Xrhwwn+s^xa6w#)X1#;YNIXf###=Vg
zZdy6M%zP_PG+y@o6p!)p!IQq{T?RvkGaU*5dz$M3G`wZqCINRQndrY>$B^v20-Oae
z-R+6xj;CC_?H;5>&kV&vj}~o#JyjeqyQuY#Qa$&N+Q*Y`(b?_VrQ8bpmhT&;k}rkK
zFX^hHtr9zW-{h8RST)i3(TAk&tEj@hgtY4X6V`1qQbH-uumIdBz4F0dqYFRFpTX}5
z=<<c|WlMam+Eu@;CRIm?%2wT~rmL23dKW}6<0R2g(Z(yV1nX}Qv$98ecT}(wu?rET
zndAlF8ALVUjzasV<labiPvYBrKnDGKyntN814NnJ495f?j0U-(&@X0Hq>D$UvB0P6
zI4F9>C>N81&h(neN<){WILc5RLc+@YPQ9XQOh2>^&mc&0ApN1#5-pl@2iCDBq(UYc
zs({&a9(gDQ1R~5w_V}&t($U=+nqWKQr9*ERCV+fHZ%@r|W}u>CD2D+<>%8>0^K7_g
z1(_=vD6VlR#x&i?Hp}|O0ii3Cu%-2y(60O!zd;}GD_4JyUOuf}2GaM3w3Jrix$03k
zbl1yWmB@^yQL^#sqt&ajYj{3H<|V!VIcsijP21=e;1RS{M+%-5MLM`uz|Gh14si>L
zw7G@=&#MxUmV-ItoV4js7Ibc<!5y}Dq=<(Kt4N#46Zb>u1ZmCJiJw6{BkM|}eV3Cq
zHPSMS$vo(!rLONvA%tHu(%P0v@?07{T25MRlG(N{5_RlXMPYd;*HRcVDXc=&G76^!
z9ViOJaVo><N9;oAn~K0so)<mwf}Sryqj$3==))mcl2!+b;^h>x8byBwRKqxhhXS)s
zqiDmCITNT?QPdoH=S9)-;3-&CT&Gy3;Kf*vXD^tdpFS^&{`UD(^u06gNvkRPuFfQn
zJ~~rV^u06ZLD9!%Z1_**(Z^(QpC3g@wlzW0M>^|@feR+-1vz-F6`2V(V=yG$Iu73R
z>#^TG{~r6wnjU+4O^<!K(PLjZpB`Hce(chA4H=gztKIYNu_xE`*q5F!J!Y*quO7P~
zhCr*ijtKKf>odgn5>_kKBKK;GePGgF*hnxfzs7&*&4L4n`cYOUH`)0r|79n*B!DK>
zgL7{1DxlKfqf&r*Ps!Nr;=gj(Bez8m&b_mI?t_2y!9Pm;bNy5G=RTy%7y7yXr<3&^
zCgURu8Ds?`<*+oAb62_bdq-_=yo63@eA^mtwP};8V+0O3L8IEG8lPHi00(M3o{~o6
zTRjonE?VP(yJ|e})HD-#j$LD{Gk^odg63UpQ$OJ=sub0i{HEY%Zps4VOdtz?cpL0*
z8}>=Fn_jp2qXE?({t)(j*Uh$5q`RhgjfUsErXc%KH+w^=uA$F>($E^~MS#JVc#P%*
z${cd_3_lxc%!(c)P%}VZHEM((z?6#boGnw>gF-3x#C9M$8oq4Zyq!MG?**w;G{YJ7
zCol_TXbAIRKBBB9oC#By8mAeC56U<4+Wj7H>UuplXHj;HD$;#@zGIIlpbLP=+`ed%
z4vg;ZQKC@iNl|79mRI%pv@#bM5aYulxdj0Wn+B=_nVjlEnVLF~QP)M*?~x`4c0tzQ
zdsGal)?#R$heKkeLup#q2ac(cHf5<sLn97&_iqr3;6fN0T$Iz5Y%q+b1mmPk@3CzU
zFsGSEEVX$P*Qu{|ZzeQhG_M-VFyqRsZ0XU0I0fP@C+TQ|cJFQ#8|1Jxzw?5h@%X$4
zda@VH67OSJK@UDS_>!FK*m8xqQQaXZD1<_HmRps!X3kU2Fb81Y)<h{qDA0Dl7x6Y(
zBl4_4O3j79q_&O4_cVkHu|xIv!V&YaM;3grqgU(E{#RT+0Xd$nY?=6)L|Kq6jOMH<
z${5WT_PGy?%~NSq4Sq}GNB%E4*%BKdV(bhuk3>ylb<xmlO<BlX+@YQ<7z8cc(!k~f
z&IYjIukFWJ6vg$l+;6f4!ZUabF~cHq)>_wF3`;N^F)YnxuP>`RdZ*U!2MDvv`=LEf
znBqd|@?DLOrQ@Cc$+x~^=Ls{u;IPptiB;*8AV{-@AkAEhpkaJK!_5sXQex;rX;WHm
z&rn|SkA2cr+6XC}icI!$kO562q4(=4ZWqZCioxrAd$~Y#Mv_WK;3PXac$<_#IREhs
z+gQ)hHw$^1q%!8U<e!PKSOlYaA?JO2X$!qQ_}|13v6w9<2cOr&=HV_Eq)RmR=s@`^
zINu{7D6T<rvi~Cog2T-Jz}X3HNSj!|JD==b@@N#`B!sWwWXm`iv0~9k_R9n|avm`!
z&qBN<8oLp^HX7w!9SN56jz+<1xY*Gs(YmOkQLrw;L_Jo;lxURqG6Q)bQ}qp#V@))Q
zf%Rt>jS?)|r#}_F4w>tNBhjNIQDcK2#BmX$QNnj0jxLM01QDp+<Lg<}!5@mJ5rgPx
z7leBV<a0qNf1YkB0MCWo`#TZ&NXlVSnd<cbBc9b>^Eg~S6@0BUYVjn_N_k!--k#QS
zh2GW3M8=K=<uJjukudQ1#dHKW#K-O*`|GR`#-;kE$X#_iG8kp8sZyX2JPi=0?AASD
z!vLoIxH!08julEr)G#MuBmWK5FTGohRH&8ac4v8YMr{T4Nq2iZ+bE12lq=u@!QLC<
z29T_8``8wilDAR7W2g<QJ>p7dKu1~eiYYQNM7)%y9IO^QIG~h`xPE3NW1mkGmypi}
zXrZfu9+br^MBDRaLXn7pvd_C`61_C$c?6YFqy8^w`-o!R4*KvM#4T|$(MY7ydatT;
z%xC!XGg;3eIFLz56wz{B!q$o<hpx-d40f?iDl%)CR3Sb`Ral$Z0aR>b+(Lqp|LL^2
zFK+J^F0}xtk37Lp_)YAM@@X8d<&N_0x^P+sh&IvIGB}#esL+{sLmqrno|;9ZCTcqY
zpK{v^<ye@fbPgC!kO&}1ZvmT!sY7uhJE%2m0_T^7Kxq58@aSp7?H)|3a^M6-&<*?k
znlBLKx8|=w^qM|S%Uvh;gX8AQng8y?!wqnlZ{=_j7?%gY51=x?_l!7JK@${#mKe6^
ziB5KmcUU`wapCj?f90x@8r^Y)vQTVbUvo7}Au;nP-eLjwIV{>M=8mh<-eiGE^_`V(
z{#xb#VhWmatOj!!CkkHa@>;6;%~2&PRBhWhC$y@l4rGtt2Yd>U`)^fVpakm8QqXN0
zJbj(AKV`S*tFT#AV|cl*!e;Bj`x11sb>V%VZkx3tA$IwmPt*PT%6I;|*!^uHh=_yf
z>N{<Zf#EyC?Q~4_9Wx2K^>@r9P>hV%gFWA&6En_$5Z{|!-D*%*5lR|cCh4?}#oA#2
zJFm+(2%p#G8-TC(zVz~Q&3WZWArpZbDGXG`y#~ucFhva!JP5~TltO(pRAJqkgZX7M
zc41VPg>z&1^shspVfpYUB7t&4?pju3dm+J;)hJ~rU==wzO4DkT+OP<t6w`>{*m7qa
zr8}!p+V)Y}KKm#=@C-+(q6{=OQIFC%Mr~LQ{td%ieG~c~axN#cp1X&+*_=V=C>cUA
zH=EZJk%{JJHDT-by>BX7>$79DcG)pT>z(V<+VJ>O6SNi+Yt8{VbYNT}imT}N=1!ow
zjL?6eG~Gtn&$%f5o-L^SG(>Kj@D-645FtdVY(NIN-ci&P0$HI-#{7~F>EKKnJ7e-F
zu3{>t+@O)b`Ea2%leKbWglU$1IUOmq38oPzU32n4njE#?C>uR)JfoUO-&nj1o)kaR
zOI%lyF6(#$*=X()^JIG<9)PcQr4*S}fB>V+)|eEnTjq1Jgeg(j#9IRA_EtfV1r64F
zDA4-7lq4R?<B<xygMy^z+9!uCS5PSm3Jg+dxfD~S1oKO6F*Pl`&lxdh;q1XbJ1s23
zH4gTWL5}jBc74&mvY&%ysx1VKv;CYE9N)!57I+5HR7dnu!smHXbG?2Jw&}!k+CLM|
z3vg9YKKZAVu$ohr3uozc`a#YS-cKR!<qGmJ^OzqDe0Ei`l5Nz__z&M|ItWvB505gy
zt%=5VCQNN{wK2-)z!s4q=o;HTm<zl8P4)SKWO&qy0hc4x_sG{mtr`qK7}hy^KpBE*
z+Sz;Hk>8)*10S~Q=jegQd1zV>z(r-Zd`iH-rY_2^7|kC)@|I%$`0D?gKX82MEf4B+
z^{X=v9AC7ntE*q$@WAozTOQPn?nB(u1<n_B&U3oH#5u2XcI2T4AAFGgwM~<WLPXDZ
zCFLvCHmx^sM43#^eb_d7L-e|!-Y{c*Y$P#yd?eZ8qdh{VX{O<%`OC54)ai+T8l8##
zfNa+wN)=oRT1YJDK@k=FV0;#Wqu4Yf6zbr&@hO+x`^*{3?VBWGma~^ZX?aqg-t~YT
z3*el*ub|aM4j_{)93T%{Ko;52L>rL<!SA~+*=(a}*kM5971n^ZPzoVq29uy36|%v~
zFv*13{7Eb%KbhebgQRg82qu$1h+KRFZrD$9Uua#y16Sbh{Uq&!Hr?{HIo-OtiwXk;
z=g0I)(cTZ<ZQ-&JQHA`Whh{|$WvwJ>`3-ktd$r14cWX|&{0<4ZZrQoFn8Q2DlUaN+
z<4F)`=U&-rt@72HKAhvxJ{R<0ZV$2>-Mv)n>Ev#u3&^W??x7B<tqe61tz(t7sdfus
zUe2B1_=)7M@`@Ap;H_z)8&ru_`4@Ux%fedaS7;r)*)IC{YI?o$O%$aTFbmMKAJPt>
zbkU0OZbo?^p&rX5BIQ-b%z%J$CmBwb#5ES7E^;Q0+7!b~0u(-!^ldT$v_PEYp+wkR
zK0p-*K$pDH^-S@lW`5Dt136?Ro_z5$=M0l_Nfxx0l#Od01%sA<2w#eIMj@>r-1Ks|
z2~NA61Dy5>4t(r34h+zncqIfp+E}x<Sf55AF7ptbvZ?qK(vR15CLI^P&G`0;tP!{@
z%n5Hv^s13#LsDvxPG)9D!-yft7=>n2h9ryQ#^tMxKlw=NQK>TeBR=#pn#DO%<tB9w
z!<#{=NG~G+jfQ@v9-E^{bM=hp^BGQU`oj!FMny8RHZttvfHH<O?x9B+KihqLb+%)H
ziNU7ul*$S8sd&nZHJ<Wy^UhP^Z{w+sn7QI9_~;NkMO(#FEt%%d$<9-{e%?G~;5dkB
zLo#&R6!AUYw_>|9^5v+XAo^KMg|!yUEHKM0{Frp-92UN6$65*-8ol?)iG@@`vud!>
z$r5GaB`T6b?o#X580Y-*sMHKe1;#1mCgov<t30`+$NVcMP1Cy>{98%BQXprU9Q>P<
zP?R-B7iE>7m#+P|%x%V`4~MN9!5SuUO_m0cD*NutT;8f?{lC1)nk@+F-WakPwkNhP
z3_A6HX_mLze8U{eZ7Y1RD-3*@k+vR!nFd%<p<?<t=ff12LOS?t%6qW&Fr{S0O?h|$
zbh;kANmmIMJ@Z#>r}hhb)wgSx_x%fLPj#oW6r%RSEnl8}3_F?eB@GwW1Q-$(>>=3E
z7TpLNnq1VP8~QJ-39!+yeyD!6CP2<O$zo>$3PKvlVb7WXVP=Ga$Hv*3fS9$-W(UL0
zqZaIDA3~Vc34;VDAuPTUF@cL9|Av=}VWO_LX<x3JR`7wzMT_!EMxJ(_;S&>jRH<5F
zxMfe(YHG-)U6Vvpf`~vq=;O}Py=Sgc;CPE1Yin|qHTkL)--8X11(?9m)ArE6hK)~~
z>&;yYUv9V-O!;_37PTZqTUL{WOw&gpzTdF5%mEk)F@{I0D^YJ6Bn|QX;hCj4BSy6~
zVx-+n#@TG7x?Qu7y{Cg;8fJ)Y>A(!MO?ZhO49t*;85lLT0*h`vqN&^NhzSj9<GaI7
zN!nO31J9YR2+WYd43sAR8vI2{i<!nPG(sh{sdKZ%GHa?9+hSbTnavhwc#xR%^_g2!
zk5*M71v*38G4mGxaKG9@8ue0(h_j!mdVJKAcG62|9K;7byf84a(V6Ma&h`593mXPV
z5L@8Bfy3CIzUM<OOX@U6DdlKymmr0URUV?CT{3bmR(YgqM@L`0^2np!E-nB4#i1XW
z)Y~O_4lY)EEiBPedR(0Pu~w0|!;4ox92D)6%~>v1dvTQ5&OaBcJlr)9?&8%C3liLR
z@ybKHT+D=7QWtIC!0F=fi|i<68oXHjfrM;(BF2kTzqD6rVFa1vrs^8^vakt45+Atg
z5FVH6K<P`p>ni#g<IdE(nMWa6h%Io9NJ8egOap;BOVTGLSfG0c|H)#mxfN8n8&X1Q
zQ8%biwOA$e?hjZ|;ASnLl{OcW6-L%-Red3-FV3mD!`bVSsle5;1;}zk8)<#%7?3@k
z0>Z2e&8pID0VC=lvl=`J(zw~a?&?q&my)C$(z-ye%?RsDKx@X4b@??+cY?{7k_D!n
zhCJpvU}CDsw;O7;mY7a#8KPC{TTb$F>j~y`Rgt`$QE1aF5SFj`{WZY+htn*>UtGRx
z^%Gj&a$Ah015=idaV>j&h9bw!A>f%%YJ&ffNiZnL?3lu+l>38&Pstw7G^v&PM41-b
z$YS7`9`BToQeKhkOkWGncn{jW-u{G-rGr2ABqM{*<PeW88vJgqCUWxU@#M34Z*|;4
zh_*q<$W8r}kvmgHZj#k0NMn8c{rMCiwGQg1#q=wPdxHnXG^~&C1(HoKw33`;eP(o+
zB{bNz!S+?Sux}c%4dq+cvh!6kcnVU`11)+329pKQ``vtsjg%c*|9_*A_SZ|xIa-YA
zRu;e?jtjfeP4T}h-?Vx2rdE4%0}X8y{rK+n^S0j*J`}-Ffto~3g|^Hz#}f^y(D1=;
zQEfeZn!y!HupMUX;@iv^vtsA8Rf>PXc1`iqt~M$0Q`@h^Pi?aiKee4gRMv>!7_oso
z!J6B(PPaCxSW$SL_m|e%f|IXX12VS`Y3g5EQ`P9dbc@Z26{rMpjG2sN{-d`IdJX>l
z+74bJW=qZQj?&n$1hKNtYN#XYJdJn_p0EKM*jiZCkik@kiEQHYd_<p6Ro_O))u&U>
z7Qo~v1_cgGk^4EwN%0jUg2htNQ2T*xV(U2wWryXsrqs8D3u0R(<sO?L82s<1Iml!X
zUk|GSOuxuHK}oQfOpUOn4*oBDu-TEluV*mX%}Fj=*C#Oc`e*)*DE5c3$&D-?fnvlK
zMT#k=$SKw{<EPB!?!n6!2v?Odg>cI-OIU>mDLgFCP97#^c8rn4$FeuO2y6U`(slBK
z_6E9cq0QmKN3(2(7@5L!p8~jb#vwlj=pcYw9z#iRZ0FX!1ztv=0yDt$_(<_73i0M#
zzHjZvB2Tzx49w}Q5RQ?>hG5R~tOq$Gkw_=v+d=jYC)+>{7BH6GHTX=H;ZD#XoAuo(
zJ1nu0b6Fqev%?uU5s$uoUj8tAu;E)O9d@if!CE&SFBBRTqTo72KDv{82;d`P3N6hc
zZbE4V0CKi5)h9HgAYzfi;*W8oedae$C*`%}L%(&}Jr4I-5GTY`h?mLl-M1e9+Pj%!
z;<b-FbUc0FwtKD@HBXlhK6yIvcuRZ><<=oRcN!2epOjm9e>MHSvUOj%;cm`b_ugY(
zJPc!gwOt{M)MahUvXu6IDrIaaMf&=x#qYR+nRL&YeVt%ncU$dRr}WAWEu7(Bmw&VT
z!@X6q`&c>8zXkqn;NO6M8~L}1f1CNYMPih`AHuk)jcI(wnpPDqS;KgrD6>s($Tb`O
zG+Hk>l&VIAc-ZPU6E&Q#y$U_?l#3m!H0*tNhKmE(QEU09y=28sDXj6iV>*Y?tL-an
zD>;@F5aS}3#1)q>Zp*fA*}N%VX!Y71SR|KQ>M=QCa0i`%6X&-Z;3Q~W@N>jW`E{Vk
zuDrO+NtLNKqUZN5^CS2w0B^fvaesJ`3~zSJ?AG}mSJ1`n{vmw@h}!&$z}}Vqp)ftq
zY~a^XaO;No7wT|g{&F1}E?&!*IaY>8@kx)YR|csUCdxRIS3xq5p_+ceqZhjO2J|w3
zb@O}rFI1JW9mhV`yK%nHWnM$heGb;uoX}$|O7I{C!F1+PjB3^xCY%s4a&CRN1s%-|
zo)HTJ#!(cWq>4?56&;W6>C`U!{t+s$ls&F6N_(G4JU;e8>;N4<(9(qHO7bDn58kUi
z@j?g>-%j)-a!Q}Brb>C(s!dVc;mep+OqD_#O_g%>F>n}PTvkoD9$)3ZYLfKjx*<>5
z$Bao1Wxt{$a}ST}xb<)@8kLVj%YT=Zb3-+dH;fp8h3Lye>Ia_)==Kk&{e)X6juM6n
z69IsH!8}h-(TWoRte?1H{@MoB1I@{xtF7B)@I?ZbtIFTB+C8y-@B}hdYU3#yr`uZ&
zWuFhH15Fp5L2e?{^73PZy9VND*@$+N4jqim_&1bd9Xz8-%yH*;SoDKTXYv$*5d`mn
zgus+fVjQWPQ5;O^(`{RM`k{>2i1LU}d@WHKXNEJH5#ctR2>t)LUVJJa0`)nemM!cC
ztzB>@HncrJ=|>ZhiWg?XhovJRegeTjSfrA&GZ90djUV;0jl__G!Ft!IEA_#b&g4Vo
z*I(w7!^_G|4AU2_>9v<Mdu`>J_S$~x!dTHfc4o4z3c>0MDiBF1sKr6tpGHyQTo8mv
z<bpOGz_TpIm7&{`m(twraDjROpE}ny!PIh#7_QP2<Z?eulp!5fPZW8N8v9uHGL*!>
zaZraIXBQ&RL9JL(YHyuO@>p0*e-Nn3pjdW?eRQGAYP$MkkNoJ&&8F%fPEU>40!B+S
zI_0l%*_MLL6*IQXiU8nxwclKC)aNnMf%!TO;)Mltn2nZm+SvF>xJy;ob0~WvoEBo^
zPvH(QRuUU8cq_!ll2T9SCx`N`z-78LJDsz;;%q{$i@w+xQqIELgpk7Loyg+G*9^75
z*Bgq3ioF>9HpH0pu<=FrFtp+b(#&0;=Rn`lK>Nx3<Y;42mF?e6-)YTb_-v{^lb4^N
zCe^3PcftJLnh?kiJ)X=2-j<*P+<{64(aiyOm_{bbSl%XJoo15e7%ZdBwsKD*0=27d
zy22vFNBq8bG!Ok}ih25Vrc`=2t-YHs=|#ZTeBFUtU<C;dRuF0qge*{cMsXt@6^4*B
zr$xu6NR%aNrr;JbN~`u*(5y9X91<@=a~GPX>9Mekt_Ic7@r_k`n{`19BoJqVXioF%
z-FnrYmUk3fq*cy5zS{$ZhLxnE(NIeam&7?%TagiBB4wlkx&>P9Chib^;PRwfKEdfG
z2^5HXfWG<v*n1l&%dV@w^M1UldR4Eg>vgMJYO95G-@}BKZ6T2imd0kFZm%WDjQ~3{
zNrntFiC5OF39HMCxZ7HdCremuBpC@jg9wJ0!6X_mNC6v!QLqULv_S#ImWj*=TQ<UO
z+XBQOu!02^L7@5l|NET#-m7}m-Ll$_%vilt_r81Y`PyfHpMCaud2yHzl-y=_!im0<
zop_2mT=0CD)qt*A;~Fm{R&#%qSj__!tY$B)#^P1HVVOy~gHOHQCk=#v!pT1rnSEhg
ze7cmR3|WmL)6<G9kjra>r1#S@JNYGIk&R2N`f8O{@JG5A!;eU0gL+QjggTwl7B4H&
z(BdS^&az|L+Ahn^vVvI`yWm#Mm<p3h2Qpn&RNG>gWCwi*H#UilgF&^*$duYIhYx>&
z+ph=C`jpzQh97qO+J<5LBe@fOi{vd#_G0^KKZt;CKllSbh_G}$VAMMK;vX|=Qpzj}
z3EHoecsqNTu;^JQm^h$c@uH&H6@?kTDlP;|hyGxdAO#ZO%0#0<HJ5S>Du4_dJO~8}
z5rS9%Nl&whfe&OyiWk5ut!uy~`XJzg^kH2TMin$t(TF6|uBqJ!yCiON1kJjt*pmtl
z>HJU+cBcnxJm|My@BIkpc|XGW@ZL35FgVhjFIOi93JHPLj3{J{fuPpu3vWh1-cW!v
zlEr9W&;kXP)FYjNPFaPA?`zIan-Laxc%C*R?8}=GcH5yE@fL7snvk}DnDaIYj-U|-
zq#n1vTOCu|bjO;?Zo5&{Em(q~GQ{2LO$K}P?GSRx-|mUM1H<?fEXbP&-u}sCUpBk&
zfvl$hazk-_Qa<9scg^exSdY4zRmzF830GIuu2@@YH_EM;39U?m{a2b5g8jz~`Blxn
zJ5_K+m9Yy6)fBPnh^g3np!jp_FR=_R;<BqEWH3Z`1_rkp(6+dfm58zdTj1o0ls;}k
zVOv##;S_!RhM{`)1VWRR5*{28C&P~>uJJA5a$5{;CDL;MTBb#SbNLJ@{?AkF=~1U7
zV?@*ZNu2QxCmsu(hy@iPS;+bGL*<cje0ho4!Txre9f*WW>-Y3V7a&EH@TzW4l1=pr
zW6lMKhPR^lUO<%UonYGqcakT^oF3yqj(c=s>k_3b09V&yclC}%6D_9K2z@~|$Y|f{
zSNRhgIK0Q=;oD<PfBF+N(yWx^iobH(BYG&4?~!u#Z}D!co`)WI&DsmqnXN6cPBQ7t
zi{^G_=95czYWeYU_28uCQ&}UzXf(71Re_<J4+a%A;I;a)MM-t%n=^JEm{jj<dhb-q
zQ{?Xu`Rfh|ENtb%pj5@WWzUoBw*ez3eFMJyA!hM0&_wqFe<h&wyUO;hzA%l<aXV;R
za<h367d=_x{F21LI*&w^BdppLY4kP|SvioW0h{?HM4rNd+3J+Hzz|;Rh#b^onF(Ab
zJbv}X@^D?^u1n>Jt!a46v^9;!F$|;!I2Z`yNyLs}Ai9S7$#x)dAUS~1re(kJAQqw&
zC-41DumNR8UZDzl)!u&+>OLU@4a-t>qgD*SYjJce5J$r}?8eqdZj0|=ELP;ih1(%z
zJI5SoE6e);Q?QLjzC43gi6GHzmjLaOSlGI{!w!tCpoKw-N#bo=?m$Z(Jb`xQ@Y;);
z)n;W=Y+s;-RnnO_8x2k<(25~;;&T;@r!j*TtED@$jerw4u|NyAVEA!o(4z8npv5zr
zK)c##djSw4`k7V%1)JqI+q)7hNk1i6l1|=$H2A1UQx)}bQ5k<E@F`F|+@F9Wf$s(L
zz&Fm|OA%#(nGyal7km@Ul&>o=GnQb5nJ+R9XbWG)Ojd||3WrmXqun#Y3Haa!#71<O
znZte1FJ4yQ`-lZw<77fcthod+o!SdfWN0#8xoeitwS<6g?GP|qz09p5$<Rm@eo7gf
z0Wu!L{#75mUI7P5ZmKo-`gUGtvd)ZmG#79YhjIqMEzJSkr2#nX$_zO9P^7jkHOpE;
zM_HZ%9Gq!8;IwTg0gm_|dqSjNn~HtpfT`GkdwIz@1fWbS4;z3Z{qSac>o&k$Uar2p
zbb<m@_yC-j7j_05TL8|$s=@3Mtuzvet49$9FzUAi#rqsT@!45U2`QbKQ+lnR3VUQV
zH#q~!uY7i#6500!<dpB};C-$+r92wjIOW9|V`n&}BgM|dDdm$4QlD_jzxC`m<yU-u
zIptGYsX^+T6Hd7{4}AFZtpViN+u)QDxOWDEw<pt>IpLIF@$5Jy8pL*jX9q?mc!#z;
zTTb~{0@}ns`0P0)P&osqyl5`qB7*V^fSc^np8)QK&yG`~A8ZHQbLEr|Zv))3=ak7*
zIE_+!U`I~52&W`$BXst(HZ!~)W1`bh`)w`#w4ZcR>8HJ8s~0E?0U5;taog<xP<o|e
z^}<PY(&&?}+Z9iGu2+5bbrIQjzc<^jAmWtwc=i`QiK%zVP->UtbP9t6KcVwd+jV+=
zyPV|!{#x{%@fL$ATV67pSV>u6p-2mBTHncauOdpk*hb)#mRWK$YtzpOL`_w-yQqbL
z7cX?2sl|1^B}UXM$gUSpBmV9kmQ-+3=OvYXEU91-pJ`EL_&eGB@sf&cnm0)u0F$>Z
zsoc!lZA&Wm+wXJ^mQ-$jR!b^0JMHIuthSVY?6gZNyAwE*+dRf11eD!{QK;1y;@4x4
zIGq5s{>)jux@ZFG{T-+km=x<*$$*oWzd!NvPe8pW-@8El>vDWEpHraj$LbZ`GN>Wl
z+}-w8WsT0Ge)g+Z3a5mNgShvV-Rjj+@*m3*np(YDo?gA$3DlKb%GKP}tMdSLKO=qT
zWnjb!)S^eN39#WsF;(6!DfZMqCLMD6C*GG5_Hw8k?Gs0FFHz(QMV(~cLK#Sqf;C$U
z_#;<LI6#nutK%gcPuXj9N5@7mH|f7qih9y1nhF(4^1km-bL)Rss-b;fSMK40H+wf1
zv|gQ)g4a+HFsS&7fLTU$<>Iw4Y$pJ%zC6*xTSq*@*6c00FI~EdPwcJMyNr&#SXl^L
zGXJ$kBqyOWJ2_{SUa<(p2-y#V_MSi8`8u;Rf^}ND*zJrMuJ7V#?ZL`&f2m&d-YUX@
zOI#75-pXVp9)Y$L0}Sd;j{RVbPn+*RP2m?xKHrAQz4`)PJ@;DnpOadUM~DiY8Nw_%
z2E(>s67~>VO4yzD$DGw3CJ<E%8E}c%Ft(5mf%i#_*RJhr*k*J-Z^_w&xd`q8KYYXe
z91Mb21teq+aON#&k=e`L)$lX1<&HoQxd(9dj5|+4vwSU+-oFNy@$m4mt0}&I-O*!f
z=XG5nuDT(JDs@4vE9h0unEP?6YXNBW{0<aMnYP#MR;DP8#V)6qazkWETqr?gX|k(}
z1r?q%<z^{fDNIuijLA#Go~>yZI}9c56T^Gi)j029d29r{2>Ph2aTdmlvoK~c?`i;T
z80&aV!<aCNMJ)qHR-qJmlM#Nra)9MnoF!X!2sud+DAGY+DK$I=Yo3B#OcwtiKG3Xd
z3Kp)xAMYt($xBn9Ga~~VW~X4E@J^G!UdlYN5oXWqZmoJ%RWGHg*%*HHv9;Yh)|+Z=
zh=O5OVUOy7S6OjRZ4HECfrg2J<L&Bc8<ZFn-QvXN4?3!K@&kI-4_tR2s$i^X4Mm53
z>7myLPiRes2Rb=xyxtaavVW>3#Q{AcUXV;Am)2K}&O`JqwTs6`L*8>&A0IQ~-F!sm
zf09MPzRo*T{6nNB>pQSE5+)_##`4LP^;0DtF_<Yedo^q4kDkFfs;}S^sv4Vos3fg;
zsdn27juZ8Ird%1H5*?1^mkXVR?Q8ETM=YDb>vl1et5g%F{4l>ibmNuvNoc&;b0uHW
z#KvYG@r8^~zqOm%-QxzGF1iu-H_6i`zY(DdX?00pjB4Bi@oR0Od;NG1%SFT;L{0iC
zcR@`*#qLkK$cHECt{Vnu(a5W`=seSi)=6%C=w#8pII3&!(U1GI26VrcpFA2ywc4!V
z!Asxt<AW1mpccTiP8usxfVD!DG2irwD#-W1xo+Nnpqq4<7+4dY!*zY*z2)4<mE*N+
zwn5_+(;PAUa`=AxdL&)UOHA=Pdv=fxYw`k-f{AE1^RsK#_O6~6XucEIy@ufRJ(Evh
zgu{HAFtmK_6gAD`+1ISC%PpiXid8GE-3){Gf!vecEGuvf>b9d9nL@#o5sa<58kvf>
zLxwf`;pAOk?+ACKC=Au9W4dxW?^%`x?=CN^mzSJu*1fCr4r}A=8pnQ{d^oAZjbobZ
z*f@5|j*VlNfY_mfIa>o2xoU7!om<kfGBL8TpwY{_+4Vf>Lz6wW&NG-l49{%oIDz!c
zOnF+Olq{ort2P2w>&{uSc0v@A%2UUl)eeDRlzcra5T$?)gqmqj@N=t+EgJw$DBf!i
z<d`(vzn2!UG-L7}Y+g`E#t4l9GQt%_zpMmG_KCyf-N-<=Cog=#?wgjSYSjx9*Jpev
zzqOT3%Er0Q5Pe!4oorX`IaX!xt%@r4HYPQPK8zyLMm|`P?S87@B9)dNv1?utG=9|c
ztnzVz79NipedT!E2>t%(-tqz+ipS1mvQcq!1z`ZvVq<j5L=J0*6Zo_dHHM^ic(qvm
zUNJ)hUA_T8qEWH{q<%QR3yWA@X%V(vghvLQdp{fs!t^nV)$qIUD-%&TQj`KW!`=q$
z(dX$RK-B7rRxIRt@EVKiK@bushN#0u4ST9M_2Y#55ZNTf`V<2bEisuhEh!1M_P-%@
zSvm<DU``Wy=cH0g5%bN)b6Mk>5RASa180QlRF7OyQ!oHJ1fTmTT{I_kLBv}T`usw`
zrOpT^D5qQx6prwafZbG44Sh&m)F3b$BfBOmvsaSBL_7f}Z~`^HB3GXh5vGnQ1EE_{
zgJ7?681jc$`1D(Xo;OX*IVu4&pu~pb70}wt{RgZ4BQ(d7Q1<fW<$polR==JgDA%C@
zS5{AQ+di!|tO-D5llvelFb*S4cu7IcBoTZGODsmTWS08M3YuU<FDvzOsy4qN<6y%Z
z^rJmoh#}Ov<^Ch1y>$H)>J0b_C?7*rUge3-pDH~XvE}jN<@CHAcsqsdo8h}LyrS(e
zk$O^ogs?0b8FOD+y`DP|i1k{b-fQ{(32N^P7K<$bs=$J4f(5B>h9`)*Y&oiobu!99
zVtV^+D(->38rfO4#0@lS2WW{(*e%1iJ_$wbs`vaomA@G6W;R%}J3=g-M=;){T^PX9
z$Q0rnh-MImcwW;+96s8mBr?S6zh?Le^dU+9sZXaWS#($mMK}+DN#kaqi%Kz${4CAq
zg*@3sk34$(`+x*RVO+OQ(P@z-6aOT)9)I2J25#z=Ct)Ftmmj#d)Jqe*v^oa3pecHm
z16(|-0V)p2<07HewgGm}x&cayOat`%3n45fVeAQ23FdrR@hvRwYSfaM8aU7}ExlH=
zj23HrJQXJqVM4Tz#O?XYU-57`x<G0p^NS=oi8NI9{Umk30&u|k7oR@l69@@9EI|=|
zKftL~2cf^nv_YU|iAqe&`jOFom?mqyFRdO&KFLe;6ieh!=w2Wua+}*$0n`$#X(SSC
z%0B|?_S)O=8?H9{fl)MWYFgt3%HwF)3{^=pdW?CKEr?=VZnEgZVEDO(*klJz6Wa>}
zuigk4=?40kqB6SvT2V7*uB;W)+xWsU+kSfE-9nGi`tYwAej+}uCO)n9)gnHI3<}vw
za3W;Jy{hd;!-oCaLb~<M@p&Z00!NV*%{o$}*?pwFnfvp&XV8TA@?n9&gYH;sMB4d{
zaM3W&YZhJ(OdFOh-7cu3O-MROY4NZQa%9hevJXS=F@FFCZlJIA6;TS`MrERZ$Ra&?
zwZ8>d<TV?%tL;1f1FE-E20wZq3je|O&3bTBDu3C$Ai!lN19()`K&&K~)HMG{k6+td
z2p=F|VED$WSu;d6wIa!S>V?s{LtEaq_tI+nHSLpK;~km`Q2>}(?P<_7&~h4GEo@!P
zHRQ5;1zO{c)i)v3Xi?K_s>6c|7oCwiFm4GF_DhIy1aS2UGlR3sGlR<W(&}kb!AmR5
z(6d4No``vZ`a<~y=3j{Z6zvFE1I>-VI*JTjt6M^7%J$Y@16ob{5Hl7zXWpW@yP~}>
zKVa@^^>#5v!Vjex?^|rj?DHIopCb_ndy%RD{_~mn)@tsS@+K!uC&FKlKpwb->l3)Y
z_cZ$?Z1*(h3r2gI3xsJs1f)=mc}=;}pZe8|R4d5$v1u{8YhZG0@!_!>w@of3qbY<X
zuMp~>M?jKs#<w~+R=lTKhS-1HDv_15-h6yvD!qAfjS7U#I5v=LzL~d_sS_&IW^}QL
zDi|blApWwestTI!iRP8(r>U$Yf-aAe2n&rMd9u?dOxtri7r=Ys*#oSa<$bFoTRTv2
z2k45Y6!&uzS~*B8rJRxAR;yv?2L!6DV|d#RSr6Q4fJ>*fd_bpb(}h(9BuMD+rM6r|
zRfBVW-oPh)mZ7qTO%B|%Q~L7qlw^$$LogG?)h9gvBs$#Za@@e9lT-N8M$46}*9wFb
z)64kf9b)_|9zW4aGFV{b(s^N}(s_M6vbehmK340kOT0w(&-3NDfzSKF7bip#pkXZ4
zoGS!>;@KU1@f+niN5p(c+XNBOY7!=LINKadMC1OPFcE1lHUp92rw6scx(*Y8?%xzl
zeADNf)pCH_=K&L+1*?TQacb+iK7l14K{`Q1GxK!x=o~!!p3jjZrXyeH;-L@6`<uZL
zFTz!YhTZl#@~A-n))K0J>J+s5O17z^<+H*;R20&^ZpiqMbt@%*h!b?rUbm9c5xN!g
zB5evG4Wx&dKGOP|8XGM<ZlQK5ML7Jl)4D9N!#{(TlT<8@kd3ViSWhqKa9{KZ1V36k
zwi9_OJjA<ahv=Ug;xXm;K$NRjJz4Bh!7j$ImTN=Ts=e`b4U6&@Co4NWA2SlRsAvbO
zSFmfAvAf@RisVf1eltvkmBjDC_f+Mgpeoymg`+0v8$D~O2vAu+i?oU&YZcTHDLotH
z@?wNG+ChZ%$>fSrlQtlw=OxvyLV|~3g`CzH7d9KVo@>BTUllVd4}{JOvr?$w+~ir%
z@#OK)V1=J+$l;4}Xn^{alwnXLhMbkln$ZD!ob6@H*(y64O7E-4Iw+)K54%UWs2_c_
zRJk0a)PrsI;2Ao7%@80;TDK7>sclTSlsLs9YeYC28{jK&*{8DQ)2T}2=d$V!*2IlH
z58+dhqOFyQ{Hn?W#L&iZTJju2T&v7n7G=N+wCMd@eZH}~A%oQ}n*7j~5Rmr#(q+4f
z)KsMk*%V?+H<IoEVxj>IhOnFn!MEikT2K#~$Zj$C!IIOSt&fkxK_f^YNN+?C*q=ij
z8R~2w-vk%-w6wS*stqZ5@*XasWumL&w$RcS7j3r^wNf1X*rX}N@>2=fut3^{;aj{R
zaSZL?5kc7_6$bX8Y!1c;$n04f+*`)6Ab6I;Pp!~ow!zjKbWI!=vqmJ)Yuwt0e(JYh
zbQlPD>Y)TYZ+zvjZh2-o>eAay?I+g?jtcjr<`cKT=$KYHOtjrJ4S<W-n(Sci(lS7p
z`Bvc5hSL!-GBAwjwpZ4A_$^@`e?QXpzyY-eYhy=Z6^b^UIvu-#s_}A@mgnFi;Wq$w
z$=X6O*4m$0(vEqEE@7gzVnS0=eM%|ZgZ07`V#*-@)8HlIStgT`p^11#1+z%vC`upP
zQuwQO`uI^H@3yugb&(|j^*SpS{Hix21>Cen0h<7rOSx*RmQz+=lrBoRLFIOBYxjU!
z!Wmpwpqi!$Oc1Haf4~nCe(;3}6ws0r;3nn~NX9;2Wmc!b{UfiAGY^F%5jEw~I%J&s
z#bYU5sx;qsr+dm-=hHpaYhL?wPj$yecI*=lK`{v)y8Q#$IgnO(9(jLyaR07q*aZ)*
zL{HS4>3@M49K40sppjE+_*ZzvgPyqHwiebJxtGIomYZKd)V{e`pQ>2EZ<nA6?cayM
zjw|gQaVc66;G12;-*c7wN345zHAa^qB(!o_anaQ>(gDF}v3AFRZ5%NMp90jj$N|-W
zw%7;G9eZNR0U%v&m(&g1#(0H8TA8N`xI9d5X7Zhl)}eIbJ`{0BIpS@`)Hb}VDDb9g
z-H$*T{;M_1oF&T7>iW&`9tKa7Zef6c<KYnpE{LM`zvhTuuQkg@$4e83f@@!r=sa}d
zjo)?it+(HC^2CidjrWmPk1k+}jw(<;9c4mtKrt84hh6q$)~933&F-V)YEF5Zvif%4
zKfe=TBN<f~AG$hFY5Qu*5QxZ|ZrWcnFLaERuuawpmNs8UnV3PQ3TbsUIR%yi0@tnS
zAiDmhY88qTlEFbN%I(5>f)X{3WJ#~JFCbn+iq9fm&Is<>OCXGpU%^a3Z?x3j;IT4Y
zsU(hg^&x(#Fcs<IPQZ<QiUd2J+&G<(9EBS9<79P%_=waX+eCDy;MbXtsr>NT1$a82
zu}X#laU|VJ$kL_eyo1gjN$_D_X1@DBb(HgqCv}S2$*m7gO=v5=xFbJk0zZ`dMr(a?
zUOxSPs#Ah<EzN7+E=boG{`HwyN8;cxU1kx$)FLv1^$5fA((Hp><s}ua;sVMH-+?%u
z1+DOr_2rqr{;R+I?598eE6)@+kIyF}@y1&YE!}!3<6L>u4P!PP|4$(AlCr)akHJ1c
z+7he-z#Uu1d&h4kh*WY=#?;UicQoUSXhl2xTcZ64pJ|uA9p?W}j|-RjYaCG+fO^Nh
zsiwqFB*>w9P8>)X5r`?oZHTC&7IG*m@qt-JfA|@5i{YqGCn$2!c)&QM+lbqUZ3cG8
zKbji5y8|5G?+qy(ccN|d7{wrgPB1vr9QuKGm9KK-F!M8nDD9V$Mz%VkCMAdlbIb_D
z_n{N9?Fsew=TmD?`wXQsO8!CV>(_Cx5rMtU`uwu<C|zrusE9L^E<Bh==>pECzBT=_
z$Z(ig5bv&<knK{lp2(KnqT+n7Bw<cW_SN(bMM)2@;~_9J?W_h<3<?sImahT12a1`(
z-+_FPmrY*AT~bO)uc*g7^Vu?=2=l3lP=)sOM>i#@8%RGin6&&Z4Q3+Mx+%@Xak87^
z8CvU5U@Iy=3tDbZ{u1OrYCGc2mENAoVHu&#)<_P8(47)97lR|{Dq(JFbsHTA{wUSd
zS~06)fTMkwUbVa0-`9oMU~srS`9ALd+|L0no8KPf!SEw;5m4Ykz32}=#J&l!MhX6=
z7+gbB5QAFCr|CM}V^r!X!dmU3VGFy-P`d3X-Gj>aG#LC)pX1^4>0nEAnnLoIR|M|D
zaUkP3?3*Bs7?Q>Qg3wvDgEMXNKC5Rc%Ur{$A&}wY;CBwNz~tQvfmKp<4+0MkS#0=)
zT&~blhySlAnDWv@t%c^of%{Ro^ILOjyjnpajZUz6g5p;QFkaX3*^r7wj9&BZpgP)F
zdr+NC&gj9YjxS5;$L@}fGe-f|SoqT){-Hp4P&u76w6QY4xaqVA+wfRp*Fb(1byE3+
z1c?YODP`^L)o}Fzb&d&wE5=X&wHnx<fJ~ChvHaB(R>J8UP}PPDx_L@tg0n##xJYoP
zYpqR5y{;Qz6*&`lFA&i;LD^_Yx7C+E+EdQ_@YqKZllC;=!qm(-5@bwxilz?Qd?6RM
zT_*Txhc3}Ph95QNW0vF^5NnJ8529%pyQY<Ep8$wO=tC;7I)d~6(yFJPCL1{aEC&KK
zQ3Il#i0@0VRWatn<7ck&;DIG(iU}tn&CHvt06D041rI?z0Ys>$iP21;UL%gwN3M;R
zPiWwU5)8uIN#SiJ!JITYmGtB=78y+LqYgV0Df@tUM9v&Q8a!ikWV$h~eYm-XE*!BZ
z30f0tBzlme_KeJcwp&^U|FyJEfq}+HxgZAuk5*x~ia%mWV=yWkUImLa^(ZjPEH)h)
zdh18i?5`GLA`ENz=as|3m}3lJ*^n?Z_XP8ZA>k#;fi$K8yhQ1@CWjCk=$XE^Z~1>t
zs#gRG|5|N6Cf*JodtG?wpj7ZjEK?LR8*>Ix`fxm52y1l56mzEhb6i&Sfbdd{j}Gh6
zL4BoIC||U!OS`|Ri53M6UR0o{Xdu8=|FdW3ll53->&>P(fb*uf7S3F};((6EA@5Wv
zu6m|_=EaoVG1=vGu1mItk?Oc5hjdG}?skFyw<f<_;aN_AIp)6M{}KOxIZi3%=xk5i
z__~oK#Nh9BVn;NW&Jlru+wm5>iJ-`T2_+B7A_dV2C%DYVi6FDVZ`al08|*!WwiP1L
zC*Etke8^E#eO<0VWl_5CF)6+e#yy@MaXRMw&}ZKF!S~<!=8wGV$>NqP>-~Q8#~=It
z&-~B>kG%U)JsR?;KJ<x4fABLOdi*2zKCVZ^{_^P0-uHo<KKzc~dG}}Zr~vQ6W@gN!
z0bJ!1Ws)Yb%J0L980=o%ggvaYZROzSB2#ktYp_+x@pWl^1x_C>`;ik|`sjWAphbDc
z7CFA}=JDb!<KCg+ZTw!kVcffg(-!yLhK2>4ZWz~xn%iy|FWfR-(icSIF}$_gn);S;
z6)z7xQ{LiIODbiJ@X+qtcuft9yom~EVnG$K@aPKkzL#H4n$*iEyqI53N_GuTmsF!F
z;~uGJm<2abyQ<-yHY)ZfaeK?1gZ&VlIFtMvC%N)dOP>7!>55Y#yioRh*c;qTOIAGL
zptsUIGQ4bs6++509ili@Co4-1Q<bUf4c#CCv;_#l(tZ%VVetM0)u94|k5Pu#dLwNf
zznl2Qi4)~vIs4ir&H!x4upxWujMb?s$Zw`bjqF-^kko<#E3`97HJzqgJJs|4l+YPI
z2%S|PAhH#`09k}z2q?ruqLiEjHVCj9emba)q1eR@G$6sT_y5$|d=p0<xQk5J0s+yJ
zanOK_K1H8q|6UwUgl7flrW|O=pN+%H1}$&2*+$mXsRvK`F!0~bV!cM#!2^G=hqE<^
zD-LVgt!*YbAzSj|i$|dKa7o*G<{ShR#{TpsoDdZTQMC~eF__RA0h4@`dK@n}1F>1K
z|1GJ?0U@%z5r}W#kOQX66p9$uhMxTV8cyKS?jnQ`jG&w?LXYzEsUp`piy=yi%ouFn
zet;kXI)Rz?<wQ(5v9KDwbS0*fi$S320h9F<pN#_qz+~@3il?D~zynHh`n?_GwS=AO
zvUiT6u>{RH7#^21ZINCRTUNY1p|C<xH1!<aS8boj_QVI7*-`s6do?0vixCSQkp3Eb
z!i6Pc39BAONzEud^}%9E`!(qTC?e=t5-ZEx^ARmLH(09P7ZNRq#+pG3X9PHxXz{aO
zbZGG>X~}OJ>zk!%q49*Gp%Hllz-)6q7>qZOdfy<DTZAR^3a6gzEiq(-uc%8;ajbYP
z2kK%ArZjv#P1F_GKos;eW%oA3B-!An$TjwG5mTAa2EFGOCtTxNIgFqLI)zP`(p(1p
z;Xc|%RkNfzk3QkVp9|@ojyvC7cS{z}5AMtaeF4c3<|(6L_zRO+(~+}Yn)?#t6s}6`
zn5DhS`pAU(o(GK6NvHn*%{Y&AbQ~%MGIye4q-68fve1hY6RbnU&{L}z+`t64Z=Nnh
zCBq-fvSjd+X`LE#>1@?gv`y`;ly<_xmc4`%_2Z11XF1U+V5gnt>9v^onx|EatswD{
zdl^g41xPxrYw*JYiFGT{%S25NIYk^o);uu`Esw12As*6H0GWxl2kVzCOK$Q`OG{t^
zlqwtoN)~#GA+WNJ)xK2^|I?X8X(Z9PJNa!V{d+QgYu|XL7-l5FOX`((tY+;x5~xeH
z2F?EUgcD!OqDK<I5~I_v#H1aFKuE1DLTk4?uykcvV9KtkzL3go3Z&YKc}~W7E-~-U
zju>w_GcgAEu@tq)9JU=R!d~451My_YAtI~<+U%s({#&LZp&N-{bt2w2w4x#}c4~r9
z=fCfqbVCM(rh2wd+Nu1kJG6BQe7@tkoPwX~rr?*8xqkNiP~;6KkWWywObUk3FSUJ6
zD=0A=7=zEwLf?T;p2k9-%O{->?_7dvf~{XtH?3~|y9twfzN?#$|J`zTa^IYXZ}z+p
zALk|C#W`@_?2?Bo{+WGCfI42@a!oHpClVme;ZCj-`Cw{M%&sn>4EH?G*7P1ax+hLd
z-E;0bx|}=Ob#u*rCYFrsXNpeN&6;IBWUa+Q5xSP2ZIfzev~mZm=+l&W=1fj6=g`IK
zqd<s!Dzm7xSC3O(hGRRfurVXu#@^SA)-Xu*)o5u(LU;Y1FQ3mYTNBf<iV}xV-L+fU
znIbvU;zF;k%7P>nNx<)(^^vi=(7kTU8B3ZJIeHF2bjH<aJ$z(y3{gw=WW^)MlGcPr
zZ(_wG{dtbo<XpqkR(t><LMo*o2*VWCQ7T>V)YL6B+Do00k%5wq-UId6oDa;n*Xwe3
zC=)t<zR2kiF2kN?gy)==A~Q0*s%MKZgaC)VjFTcgDK+U;HCu!M%`M`56X}&5leso|
zALbXS<i6-$;r^Ty37H0cZRwbmg_Q{VBzu8ezSJ?edhJpIXOb6@s3Ut36&kC|5_S-(
z+ns}OCFPA!fF2IQUUCppZ}^avc|D>@ajZx*O?fl-D3ee^A}3FoXpejI^DIUaN#y4s
z7bgCDCOr4rwW(LDGq04WWpCHe`q^P|U^m-r)zD}quy{A!-yO#y@9xrKo9^XblH>ka
zW3l4kjmGARXGUd!2{9bxLJ$UgCsMU&>oIZj-V-ce7%NAjB0c4no%^OD^d*JK>8a=i
zJzJYb_smwuTNVJ68h5G^1vaY=qTqC9%v3E=2O$!%`Ycue>KzohU<0rwtCf4aKZ;k3
zEFi|xmEj+y#e4&8ueOFOh7&{_FebRbORHCKp^qC}R$f|tEf;nsUlk9ph=(tUhXRL?
zPcXTi4tO%eI=NdN4XO>8r_T9QFBj}szpQvwbWxNZF9ySZ<-VsEiq)N}P&>gjyK%6M
z=4m`2<m@GhF#fKVDOG@kfHr0?5!n+iC0mAgQ4xb4Y$YslAQ9H3x%?HmIOkW1bo6q2
z<*J(f@SMj|QfJWJC34KuB27`QJynR<c5kJ*q0$;9n%gx?3Y@<b>}U%^kLQfvq_7yI
z5Q&1p9ql`hMUV9mfrdV8p(BNr2}4(!AERPQVy<tK2t*u!v`oPyZ@Fn+iIPaOl)APy
z+vVN)`Iau{=iAuCHEX*f8@IXs>TGS{Va}W~Gox$P)|68zbzm@CL^-Kl)t0p-pGurw
zt;`lts<(MX9Oju`EzcHF>gIVxR-6VlUiD{-M8wPXvG_RTRNK;Qk#3Az#?oJ90W}p_
zoGr4FpKmGR<CRm9h1nvc8J#;8AH$qpSsG{fU%MtFcHZzK@n^iUG@cY;8GUY%-qf0(
zrSYT)aYS>A)RC>#9oVu=n0*;rR~9SLdRN=bVkElZ+*X{Nl(0<k3sTRBU%(s8XIR4K
zG_cG$CZ07+cq8Wgl{+9HlN$!1h_-I!j`b2Vh_rGyQ8sI6WiL5th>qS%wm??RqxCi1
zGQ=M<2kKhCQxr%oNktIt+C)cKCQDD~2;5C{1mcxbSDf5sIq3)p9}SaH5PZEHD~Wpm
zj`t?e{KORKg(-mUtvxu)!GTs`Z>wPutR@ab;s~*RDc0jNDd7$lpH{*{rQF&3i6EkO
z1?k)KM`i&<qA9@ux^68SYO+F=Jdyfl%-9kuBx+l%P*2fI{X9Eoffr8`D+~;2);hg<
z*}}A0lSo@@7s!b{S)N)MzAtG({;Ea~Bj*tOS0PuuZW?<`BgxqalGij6&n3{K?;)pS
z8Z%z)ydVX(r)g9;WQS4g8A#LU<#aCyuX-A{&!EDBNdQyF407%k(#tYreb%P42Zb1p
z1UTff0H>#@3p1|NY0qiQAb7FG^qgnY5ojlyPN+h#h}`6aE3Sr3r`|_CIHQw0b5?%c
z>CRA@SOz^uCBnQ)X;K-A6_fU=u<7(wKCVzfvKxVBHfVM>nI{I#ygMHhDr;_wDF+!l
zP_}F>`JJM+7HTOoYvONocJf>atmq!$*;0aKdEyTXOWYA3=g<=O7TdELy8;ruo+w4Z
z0uBbtW|CwfXgADcEL)$mYk&hDyRn2q@3CZsJ}J~^#Y3zL@4!Q*#xmbFAF}6RcJ>;j
z$kx0i(;KBb35zXaw-bn4tfMTB86(?@@1C}frd|<g{BI_&u37s$3F|F=%YB~Hx2acK
z`}Q|Z#B=86lpLKB@n3~(-NK4%C5zNSS35)q0JmwmnuBvft_pX|i<1eEDS>qG(oQ-e
znIWFgz9A~>)49mCYmyi+f<!zz?GQ!~ryrVlhKYR>xdcN!I|1yYxz0>HOZMup9b`-3
zmp1E7laJ3Q74d}IYNCK`(LXb?wOjDBBaq!Y)6Q-nI!il?al(Qb&K9lpY!uxsT5H$0
zE$Z|%6>QO3&qmSRqP3olqPr!8?zD<7_%?;o03ICZX&>NMp*Cimjtuw;MHEiI=sDuF
z&Y?tk$OtNjJEVjyuZ}Fvs?YV+9GJu!OsF|^(pIA%FO){KkaSi_j?S-zFD20ysfk&(
zO*$)0P>;yRv=!=VCoz+)nuMus)rl}wI_imF+Wy=^cK8z$`I~IjRLZvMq|{C#J3pUO
zo6Xo%o6XosZR<PqEkB=An=RZ_n=RZ)ZQ80cZ=~@Y7y2?F&5r%>40{1P2auivE|Oeo
zMn&j(ht&t4E||QgW(W3~S|vhH^B4%k{CT^DlKv(ikH!XO?>{pAD&ZiZXTrgxU}ydg
z4t_b$=Hg(Jygb`|tLVDZ3U~IcLX5`2S+{Bi|21oNB%~RzBO$-Kc1?NH=gmw!|Dv0j
zf4jrXpuSJNI@8RIcbb_?&h^aLUz29Q{+h|muw#Di%;e{DDA2B)RLZWLNo}2?Z#lm8
zx#xKjsQUb;z&m!BXO;k_UY%*4o1NyFL(uGJJ!ceXk6D@-tL~E-kOe%C0^_-7W)fNc
z{GXY3?JzT(w=?zXOfz%IPBX(PYv*=mZ0n>Muwpow8EsUaH#714i;g$`+zvB?)S7yA
zrkS~Tr<vgxw{tr)_W!0CuqHj38SUzsH#714i*9D_*<ogoT2rsiG&5he)69?v_1w;k
zt&cPVHdrPzqm3~0W+t9{W^lIj!(M#;bF+8sFf#-yPQ5zQ%v`k7%y3B6xt$rWW~3Rg
zT{xK;B~F<)Gx6Lr^TnhA{OArdg9b45>P$0pV5gaJ0<F364WFY9?nR?+2Jo>=W=5+R
z^JXTVduG0vG=R75Ff(WXQ?Jf6GZ*eOGd@i1T+WQWUug#H<(SNjHjR2_?0(75Q`ezg
z8Fn21r`3)r!|ptu%{A;;G-lqDbAh{wbAcDhup{RXds&ln0jG!!yDFRulSKm#w_*P@
z3lwYZRdd$n&>hvaNf1vLzcaNqx7w_xu5dT$3SnBQD~{h;?c#UTm9#du8vR)ZI9u1|
z5^!esIc4Aww7ozecLGi|<9T73X;-r=^@zJkj|v`7Z8_YPdPLxmfwL<*bDldhCpLcD
zCajNc4VGsDCqWC-dj`(5WVme`MJzaZ$#AZ_A9n90!$qb2BC1BSlmgpXdUIs<#X923
zUeMJs2u2W-*QAuJ0Cc=Gl59G<#X;2hH)twc?cQ^YWHm{`S+^HEfdRf)+!Yrq;#dm_
zBy9=b91~M+pO|WUMEEvfW~Z{;!GwrE=SX!n8oj)9?j-p>cX4$4=MotHybD2Q9p?+Z
z<BbKMpP63O`O=QJSRLqGfT!Q_2FoF<p2;MyDNaH|c5<>mw;kjYA82gvA}n~az3W`;
zAioRIY&xBaxqN=3#g_=V((2QXe~FNZE1i+9Q}XqBPsju}eu<E~y{lpNdzm;d@SKA!
zCQ0dfo}vZoL*Cx_(_cJ<{JdkmUs#EpXY41xcxG(tc1R)`Cv0chu3^D21=2mc?cwjv
z`onYA^J(81EM<`>-ykWtFiM{7j?}FqHd8s5yBdG78}a?UIHw>dEs-+Wsgm;py0qEK
zM_=!(`gfrhTjJI8bGXJ<@n7v6ehjLj-sNbWiMkrm8qQKQ@xF$RId9jp;~Vilb-|YN
zvJ~0&#fiZL(#4R@!~i*Dv4hJ*GV2jLUr84WOgOj!%U3%<BKvlq+-lwaWbw(oKRG2W
zVt=wutlhppnfPdY0JeOI{+OfN5`02b$ds9#qfxMU|10euC$DQxARkjeMw-tTnf_SS
z9a*Aei%P;cDulPBU=wmG*P)J6NHdK~MPapi3d#UFZ_P+Ykmza5G*bb{O}|RANSd3W
zLT9<2h#Uyqe*Mw*L`gn20!H|?c)WW+%m)uvCl3fU;K3deydQ0!P!V>O1X@gL=?b0l
z2V3i0Yn|Oz_2hP=R@yxoRpMS!toWEMKgIAb{7ViCb{GAV$ae@`Pe8=CXPu8yxgq5!
zJWX24^8)k|DNrZP)9i1i&GZV&7VgSrcai)<K6O`QtW9-H$bWzZDe3eA^Ttie11pw7
z?*p?**9wl)h@FSrwVY+)4S+z(r$DxGq*)}oq!C<i<J1!V#+jB@@i=Q6j??57ae|qW
zByMR!gas9g>J<4j_?fDz<1B!@MV|gb^kn}v`(xbS?6B%_N!KNR9JDUBK<*?T-KH34
zCF+}VU>$6beTNO-y^{LYN=$(+Ni6ABD+ca7yXp{7cCJtob}Ch`GFT4(k-Fl;*HUiM
zhr7(QDc$Z>`DEcPnJfCnctHu!N~OL%I9}8}kvv~V8{|Y(epKG2<B|<}@<$$FJnlrC
zA!vp?ofGw`+^)~zd6cZjQ%4Q?r;cRsOAZv7e(9fjsRW&k2~X4u?4Z)i%kL>ggYJ;>
zNP`Pb;+xYHw@UE9L-rR4<Ss<&fj_K3MfyAVqjFljiNF-I$JxD~EJ>-w4|X%=Q+Pf}
z&OssQBDIY<<*wb!Ns4kw%KHe6lrGN9SR3DHi#@7-(-%g>`8zslhbXMxW<Gz1e#tdS
zO?<L9PTE0QyqxwK6k)CXI9v#9Rol!>{H7buP6yNrwJcmr=j`16FuCl08GyA9fA}Ov
zfwU*|;3N;ex9ZN>Sy1q|Ibfe`tJ(yq^L!b!H=^sPPIZY7d<CqV>Yb0TNe`6*GPzxo
z^d*sQBu-2zQ}bCzj2SW<F(93fqn*24mLw1bP>z4#>SHp&GTNCOlM@eN5ZY%cDlu3%
zcR*!LHIikVl(TR|XWNcSc7te^$3g?fgiH05wlA7VDABh1kPphiWy_&Mo^H@c)6EEd
zP>$N-TN;=>8OKsv^9QG3vNoxW10uCqsHdF$jAgG<;MPif%b!;q;5H7$sY#Z9baF6G
z2xha9!LEWXbqsPqzKvQb34%RV8&pfhKuw<WI-iqsM;Qm@eBg(Fe(|u=wDF}!9tY)+
zT{;fR;Y0b-?S99r{`o&Cr$aF|9*HiYrcqIERQ{I|t#dSJQ6h>&mBZU~Tmb{VA`&h^
z;XGB2(Jp~;8QW#qcp^^d3mc4LxE3CML{@l+RVM}xlqgU9`(S*$KQ3~kz@kfpj?fOq
zxiEYz(R<a~0CoJMuY;r11*w6IfQt{nq0rR#kxLbVq_#TpA=7a%L2>~Z)6)lo9S`{V
zKH)73S#-q`$zOkBZ@HePemOS42x`VqA@k0gU|1Bh_Up(^Z)8i6o6eJv_NlJW(-m#&
zS?3b_RL`CFq3h&C@l7*sq=W*+qy^Eo(vIrHFt!9&XXStEF2d7nJY<n5#=gal$eMr5
zx%cS8^+_SidW}FZZ>uf~n{+TTD0+XIv;pr=;|4yxeXA}4f?9thHVX(7(&ig22BL7!
zhGAz7oKzO<KkMSKbAHl@!{)FKhLlzVHMprb?7YXpaoBl}Lyp6)V>M7GebA8!5^zoz
zkJtuR=~4weV!xSjA@4VvHj_Wc<v;veGYC6t9A*Xu`=7-HWkY}rj0=n1_OL}Dl%BH_
zD?eARS~dfvR}SaTuapv^dp=b}iMI6Id&{8zIh!@k0Ue;q2ExxkU_Qx)c?_yaKa3#i
z82u#ZS`x^kH(GCfj`)$<o%f;5+5edmgUU!n-iq#o*09CN?m^5Pv9^>Lbc;b7M#0X^
z$5f32Lo=zg_}UOdWo!cl&9whh*ruI>yUmry`ewY#8`jj3B~FpT-qO>BhRt{?%Ngr3
zX*n;Jr|>)FQ&26CSYJB_9fiQ=UnNx2aiYYX_pWz_?DW-|2yyZixoR})-Z747fy0_f
zahLXgA|t!-^y&Sdd1HiZrTI|{fZuu;62XQ?T9_x|eG)2A1wE$ypLqt;o}+GZiHFIr
zG_LMB<DEPwR7xXJC>fK!79<>#zE`{~Z~9GWd{&bl?gL@K#EWsNNN$W79G>Oqf+6YY
z6F-j(997D|5v$j+=Ly_MNJk=h&9$}>k~bdq=DEiG0=x86$u{Ofv(4s*gIpq^2k8N*
zqUj4^&Zd&6LWWPXMq>$Q4x)n@XH+d6UmJe547{p`j~MIO&meRH6t*>`2c$$8wK8OY
zQLl<R6fu@lXRy_H@<J7&pS$Bxr)<fXhYs%+*lwnMr$Q;`vEXhtNd}9nLdmr09dXfZ
zb<Z+_coLU)k_?rfPLe@Ni5)7ZCSk0TWOxreaW+npL5s`-<x-N2ZP@DFL~Qa=zqSPY
zV2$e8+?W=~X@~eeUL?|Sz)#-Ekpq6xPL9~sq<r056A5p3g=PMqWbR4;F@*qSnafsV
zWNsG?Bo&Pzr9D_6CDJCzT*;kI=C1HKB5)iNv^WzJBr)W@PZ18($=v4>3A97r00esK
zht2JrHvkIq^hL^mvk3vZtB129A5_$>90k1-ssUJb)m2$Ae@G4TkinnOX|SiDAy_>P
zURumc#HTPY;k(q?BW;6A8`q`N?W>-=Q|~P5iI%BmRStzNyZ_mhOg*sakFuUR0UuW<
z^4`C*sLCa9eUM0qQ!O~!;>2IqHyt|orkizp;_0QE4(<2T6DOWpzv)o_O*iXB|5o1V
z0r&fL&v$x$kb8=Ach#*o-+Z(D1nwsmNbVsH3iU8+!)MXMDDk;~NiNKos97+{t)(4(
z)~9i6{Zd`kZ&;Q&g3iQ|Rt=1Qb-bce-6Z5+aQvN<L-F3g#(2vG>OLx`mMEwyNTHD&
zL!({zyi1{(t*jL}Ovb2XIxXbJTbkaas_(pM`s_8FVm^fm2a5mQNb#PcQ`n(+sC?7R
zx3603aqf|Yb}yaf$c6<S+(mARW^i=8j-$Xw&XL~WmGG|Kq4GPM-c3q+Km^`$i>d4b
zgKWf$ZNo#Fb-5!j2R8>ki=MF|jWpH~7?lnKLUM^eg8Xt+puVh*N}wq{Mh^g8uytwX
z6C%Cucau{FdF2DK$~d;N^ogN5wz5yJZSa#I10jFn5enQZw@%7}`@qLj4f(+%`N1t0
zRtLf-c{jGG@)S@jN7szbBX!_i9F!%MNxmAow}*j;BQbfg$aUbmx0bvkH0ONgPId!2
zq3s5GJJcDHs*5wX$0f(%#QZet07gpfx*TEpEVUsH=|QF@NRZ?^4(n437ck3qAdX(Z
zUEt0zFz>>NUTw&NHKc$MYgjxw?g@{k@nw7o$YB(-W0Z4E(W8)xawrI*Xh_Wt<z#_N
zXf>B4<k56g)^5=fb2-if9b>9|Gf1HAvU5%fq*E|V3Xn1G==i|Z$2g+zLJjgFz$jB3
zFiu(b0k~+VKi(@{sA~4&-qPugWJ2kIO3IoNM;3eF_&8Jw{nw|(N`D*sXj>9T`m|V)
zIM9yMV(l96H~V#3EOqTy8Vf5sx(wBTPm8r0zAERmt5^RumngaEv{>*|$CUyY;S=W{
z`n1@7oEF<_<ondDI$9Q$6^)38;WEUZwmI4-CeV-@RxR+Z98=quN$kXFvFXf2`Sym*
zKBO!3IworxAeZw?`<c^evAdb$7cfMT?7`~Ra(uB5ain(5^*p4YX`o^Uq0cuZN#b=R
z%F~cIvUc@4k~NBgSC5X%IpvKU`Zgm61>{sq1;C0pC04r4G(N^Du>zApO7}KVH7ZVu
z?WdDsB`?RMvw=(H!y)&GQhd^+k(ec*!=ya|aG(ajf~!`|#X2e02e*<D2<jE%Ud6|V
z?jgVma`4<6!Xc{DF}sqS+!nu7gnTTzxDzFV)Y1vw1vhS<1Rfn;+tYkmH0T8}LD<=m
z!w{e9DZ@Lww!8VVbUdtjoNjxJjxII3#Sg%bg^q{a({aI==w=wlzLp#~dv|7dO1tG_
zL}hS+NJx&Rf2~;bUZ!AwI`$QM;MiB8O4b^m>?)U|X0KGfbatlo+5jn2Hoj!$*w?1H
zWX`d#mo$xzeXW{H5aDeJItgqeEiZJVxi>T5%#rW=SYpv2ylE2hp(~X-8sy80B>$yj
zU!mZcV_&fua!pTh@|%75i7_YvE9Bc9aE<v$Pkihvj&6>9MfEl9FX-4;6Z!(3;N~KZ
zr9^@X@lcC#$Cy^frH*|~lI5WeaD2blV^qn#TBKr1n^MQVlKu%!We$rgoFh%un|+!e
zk*DVi$4#?ua_sAFo+cU0{OZ`(wOKOeNWS?5$ecpJR68MFQe5#5;_Y3xwu_43((}u1
zBVG!uO$v0xyS4-I202o>SlW112NNUeo3$gv>O+NAnn)G~w-YUO2fu=Hi8G@dW!he%
zT~jCg4ZRqB!~_9)W9N!}Nt3!-n9Y}p6IoKmN3<X>VPxc$|D&LWJ~d1q{K`>&`j~B3
z66|3WK&9JeHPgqV-89dTTmHVI&Gw1kI$5-%cJd(M$vqjpvuqB@+?=<QY?cII7MVH0
z(lQx#W!83`a;rcjr<c!}0aNDiv_SVPz5=Ms70RO?EVwzKUiLtA&|eJUfEWUhXI?i!
z9rXwrl}n4B93dMtvzu5RKYd39S>EEl61Z6gqylCV#8*ZeNqZ@JQ*iH~l;QrC47LpE
zw{Ly0vuc-%+?<POP#k{N4DqXn&XoPI>MZO=gYHIFwGXgl1n%jgQ?j$dHHOhELmrMM
z^2>->;S6d+@FIfw*;MEO;J4*Es5<-&CJUMmtd!)TrTv_x7`<>n3^mE8uEkEIO)82h
zMp3Mgj(J@pjUqW=psk@+d->dOEC<71&`<er0qbOM#@jRYX0YBNd2v$T3M9(Z%1R+!
z8kbsf@X%7i9@28tNi?w)RO4Nm_#Wp|LcFvBTjUJ*;zEQKng^+yuLp)w02i(k)0TAY
zaknVt16yaY?bhH*M!QN&_zJZAro7K-`E5m&<>fcb3SMJg2*`Ylqx2(A0gGm&B(X(Q
zfnuX=M-5C<SjB<yo%mwmTAHe<e8oP9YJ;|SO+i%Fx*^KL4x&mU?tM!E(KKCx5t@*d
zDXc$^&waFJ$mhKj#flDIV4d#G+_rDQP`ChSg_g&IxA{T0>}%icejupfpWpfz!t+fO
z8c5RYsTwnZ#XaN=AAwCt`DenV&jDk1;X>L@y}7VCUnUk4yYA7dHc8Xlvx3mbj2Rxu
z1^2Xfmkf0954s?r(k4(b{1uA1@v~a*oBBS4h~YQ*u`-?UD5wK>PH{xlFWa9rXDQn^
zrt1ggPi<GPYay2F+nYv5F$SCjyKKL!#I8IH$15?R@VWFBdW@-TPnzoXq$1Cp*sn6B
z)UvXD6WX1#TbB&)8Xi35O7tG9w`|uqTLCK`3-iB}gP&6$J3<6n#bre?{7;n_+B#eq
zdQ-3Y6ik^to0WN3mkmQ$K#ZtJBP!YtbADyr#?Fb!7z&S}s!N<eg@;hI9zt<_n}(o%
zGkpaPPxVq_fG%^=Y$o%j82s<C@Qu4c@knA8Y}jH?nA{a89y}6$+eKPv3nH$H#%5$8
zrv-Q<4xUgmEedw~!fLjJ@&5e$zR<p~SYH57esr?tj!&#nh)LC69P5<l!#X*pwG77y
z{)!ao0nb=S_xaJqv~Y3zpbq~%Q8U&HP|PnaQ@qA*Sw}f|W0|0${3E9>!+D|UvoE17
zo#(wawhz9NE=3y!#&NzIc6a@_8~lAHb@-r^J8lvnifse8CEfuhh3{m*fjn<Lb+Tx`
zqJ7&Z5;Gmrx}c>Qkb`6JZx=c2eBlis*A))o;^u_V7RYIxVywe$nG&Tv&3EprpSiEx
zRqbPi!zgr~?5<kudGR<&uN!Xa<KudBEX>&0B<ErUXFF8<LxxqgPbhOWjR<%+(iURQ
z<A;w!f4vxk-@Y2w%%q{IUTA*tY|EnNx^VP^wolRa3JN+&_~DQjqJ42Z-U=720HM-;
z#n5<#V62te@w#1of{3cPzd(1?<DnnRAHOjs&k7|kt-oco2ZcP(s1}uCmNSMmu4}c4
zvWITGvVJw=q%<&T_FP$i3k_VA%2X^0j8~(4r8SSWbgxST<<%+$W)W4wRiml}PwqE1
z<Mt+X(Ge10pzW+dBkfp^7h{{OzE{s1Mqnn${Z-@jL&g7KL9cnT>%0cR2s83@^S7Hh
z7w!ufucjh~_j>oL>&>gA4NP}|Ic#s`kk0nS(dqUc{kZ3oVCntV76hDE<0xAph&FxF
zkM|Jc5@TZljU_`5rvhUU5H@_;ModOa{YY~jS%?O@OXeVj@M;W&(c&)@*`Jw+1L%4{
zvXh4n|2mj|7i}XZ(~IzsBe1t>1EGv9)5AB8SAgGoLip&36V+kG_o<QU`f*M0kl|Qe
zPp7;*1q_G(3`QTKyBa9M1O`}zu4IPTQK(2ZOo2kWMlpCtnL_7iP@RBBsA)HjGi$@^
zaB@OuagLhHrevWV3sUUCRmj-)a-7_0<?yxM_e}}7c<R`s$y|h&^iyl#^wba)0L4SX
zQQP&Arxx$9J@uA|sItB1Q%r9){FQp}H4&$p<wC=V<XHX%eW0{##L(Z*{qUppNJuOd
z2Wj$wYWieejnpBT^4{`M4yyd!N;Yt4wGgp%)lr>5Bb311$OW6>^78j9Ii^ZGWWiOc
zJ5_1Q0Gc=evgq>i(Fzp~BPPCorIiL5+M^{pP|KTEg)uF)TYlvyE2(*QEwdJ<P#`9|
zi0Yr@+w{y8VFenUVrF}u7Tg~SK3TXPl}qj@eh>*)@k`RAeOfSjar@w7faj!@Xs}yK
zD?>}pYd|*P?McZ-3Z#-x<dXjgb)q4d3tyaUaS%gZptic^fX`9)S_0iwxR=}uQzH<t
z$CXE5Y+P-aUJax;R63NDng;(Pb8LK66T9lND6K6J9`?y9d(U_^+*KE4B{7M=7{~Lc
ztj-mhL5W7n4*vy*!Ta^_(P}XGUpaUoFLxoJ+M+%6zLRQW_ku?PGDupC>qF%Y;%;<J
z5tndfP}Ypv_yj=ieDq||{<;th^nOA=9{jz;dw#fAEp-vVifL8@BXJiWwcZoPiVdJL
z_zkH50F#};Aay|jkf~_j{uGtcAKo!byL*NBk&-O%y*zx>W8!HR4PT_62tnbl4g`s?
z;I<V0O4}2E;Ih!+v)Wcr+x{_Z(5_vDLTJGa#}CD%Ulr}Y{|onm`_v1pY!w>yg;3pR
zKc~;Eo2Ac~1KDQ!fZASGT)^daK2mTu6z9NXxlKycBJJttNuN9pTsZ4OUtCr+FDtIn
z9WJVuR{srmm{C`7S-G-4$YmMv#YJ3L_J#Z_`;W9IKNIs=7a#$!+u#0dbdCFq5*!^Q
zukeY<$0NoKv;(-TqDm9r*kme9u8J4}YZn7+fo1PTR(m|JicBopUk)f?3JU3>nZc-}
zO0ys7L7LXVOA02V9DdleUk)Dz)SAWNuNq6ad4In7cs=-EI+Y!BMU&_W6Vqu;Fn~s+
zN)1d-P&luIT=H(vFS~`f!qRAj(olme19fI_l|_Jf8Wij*Mg?T5M)aGJh}Jv;aF-?t
zmDKnL?@HP++8!hnYygfZIR=(TY$kN5*i2uT+vqxvE{aE>DGl>+At3Quv6=pOe_Z+~
zk%<<9#K!gT4_pl`1v_yS;&j80@dDkfd!KlVL0*Nhy|{?krQu+gG!4XfC>}a^uvaa<
z0a3t%gB+wHetA`8(a7HoJ^b47fB{NKzX7~qB@SN!U0uOtvf9>okPex_Dpz{>H3h@s
z)Bsf8@|adCz||vvr;rL<U;oZGHTBKBU2dymBhvfR<fZi$TF^V(dxO9H>gg}N{bV3F
z@Ks0O`KFu4Frh2lt`Uc#1hcYgs!IAdpl@>JM5aS)w;^`8FK!qw+%jIeVN5*Mq20IL
za%DZF#r~n@w%}<vyABO+)3WQn+vGvu#SP;gpY7)}T*2JQBx_cfYxbpxK-<?J#Y?oJ
zaj8*RVzkMKxM(R!t@@N`xzZq3X+PtoTgHo2OqC1tsHy4TE#q3<s?{w@^Y!+gEZjnc
z>MgAhO?8VLB4V3>UdsaNV~mI`3F>h#My1UP@^;tPt(Aum;GterIEP2ewvFi(lf;YO
zfN_<_nq|v!4fKd-s+yXqN;4%&;5FZAlKh?Ksrydz#MJ1kWsc+-+`3S$Ov?b{5hU0k
z(1j6D8G}J!3JduqrI-t6dh1Jn4d)>+x+)NFJz;BX1~T%ad7%x!h((nlOZ^E_B{VDl
zvH=NyfE`)jq*tL^B|V0|z_1Z5kUk%tQmx*DLe)CUyPmTLMS4l>K|x(o=pDq0v<WL6
zJ3?n!j0e=Ju@Rh?Hlb7)AB@?C5lylBnSr9i$~E|DwMslX_sKeAs8f6h6B9dD_I-LM
zMXXuEcf`cP+w>AmM$iIoOZsfN+Ti?h23m)%W!jt7wU&dwugvOND}wHdxrvk4?ga<Y
zTZde5!L4#(s^#y6v4NlFC=g59Uz0SZlUZY8;F#L7%OH?YC8X!VpZGmq^%Gf82ghr=
z=TIT-ujw~yR*EDTS3^B=scwHwWicfb5x<*gYNv9$Uo88Pw!zEhR5^i{&8;%QOC$~<
zqMbe0{Ya_Z4qg|)ku}Xy`KDCi!KHdGyfyZxAEquXyBtyIgHgUWSoKR|eKB}3KeRVc
z2v`^~vtvhC6BbUi)E^w~JYI4;*@sm*3zGPQ)II2abu7Ox_x5;!dzf4DKDe{6(-7`E
zZZwdr#6lf06k&Hr^uKLoo+l2n;%fC>iyw?=Tpx%A{S*Ge&tmX(NqexaV4$FXGsgDR
zr%o2_MeRd>luZnTr_3`vo=ZoN9h=fY1|O&qxOPZBh*PxBX#3!?T}8}mU#^L(z<mjr
zaV3%Gd-@{P53}abXWsY0_uu*EkG$*20uj~t(I0>8`#<wT4?ObjNA+kwkLp98c=QK9
z^P$H-a_{4MH1wlCd*26c`tUn`=iQ&tqdv`|lYe8dEOp|6g5aJZEJXm?tDC-r9Kkn|
zZU_K&=t?Hx-C#zzG_W)-Lwgg529?TaVRjYL+5t^NNmfK~?-m3zVip$IAo^;{T1jW*
z9@;C0w8S>jyo#5Ho+)o}sU?+Kl5sCt$+Rd^Dpx=g3#tIt<O=k@mtRhroD@b5N7Iv%
zUBlBQ)u<YDkJK~F#2ctxec+xpszc4K+}?8M;4$_*zG2aUP$?!1KDa|n7_&DW6NbK&
zVtrOC%RQLB#OtNSSw@6)rFISkt5Hm=Rl+*yc8=ze2ElSM^h4-Hw+OxbN-cm-1%e56
z_j~_O4g+gT>e3==Ao|-oL|0_mm_;uwfkP__+allyz|#VlQ;wDpNosJpefSTdjtJd~
zTAs+Y<Z4em-qBA|SVL_8Nm=ze3wCOgK~ui-Q1zzqB2#iF%KqY==rv1<Z<eCO80Z>Z
z&=P4a1&-%>Q0ryYK1IZVMCd@V1oBEtjT5h0g$%U6Q?eATmmQi5urb>UdMy@-xJ6sm
zhh`|&XQ-234nE?#d{_)b#^4hSyB)Rn<-xj6ukCfxD?#<<{K;o0#s)l5b1lozL1naZ
zS%Jl-hzlmg1c1EP*51`HA7p!{*h7?iM<9hzfoJ|_CTaMm3>Wsq>~P5*5MU#QhaM#T
zC7EvWb=j?8ml*G*={eT9wuOO{p>8iaBEw9a`-R=zgMTcW7cE@?(>Yk9msT&K@)~U@
zwy)K&UGGhUb+>o?3G@C-sIPXj(-HJ_D~W@jTI|e0n_YqTJN@<g4jg{huCih^X>qB)
zyfRo_+l5{%3DEPLmF@35!HnoIBb;VW{2onzw2q*3Ir=oMW&2C|WW9Z#E=)K@+s8i5
z{cq`k?15bLBef3QQ|+>!RP^oo<bw9!>2nn&6!<>fKcqkMjZ^fLTBRuA*waP7Uq#P5
zyP^=4ifWlLO?;t=msEO6EfE=pa>+c)hk~6VAIh3gmo4_fTO%^#-QKTXuSXV*mlZ5D
zX%{CB6oRvg3tK#KS`)T_EH5keCl87neRt<@NR5ho{N@*uo1p8?l#ig)fhihC2K-0W
z_gxbZWWY~D&vOR!FeIm;_v0#hmVh@~OweP_en3UFUnkEE7{T#n9f0}d8E~}SJNpUl
z;OS4E)F(Weu0^r;?H~HZ@IyYyw`@Pw{lqb$3Nm8;re36OWW<znx&2kWSXBiAYJ0bS
z?%^kEhcsuKzZkr?n)VTgUp*+Lql=#CVhc6QYt&mTCX;gWpQ`zcDHCeAUC+~i^Q5F9
zWor1X|I8;%`=`3>X$0}0h9A}goq>`e&V0&M&L_F(PwA5j+xv9c#q-k@1uWA=|5$`{
zQG1(;ikF<G=nM$|HhL=*1XQQpRn}s8()p`Cp8ZwtuLrl5B9^kLSO#=q{lUGoiLW3S
za;Mf(E9bxcWu-|8t(IkSRy|(d#VNpWyEuhVYMJm@>`<*EhRGHE8ykwMLIqaj5Y#;Q
zdb^KfZAIeRsN#hUgcMS&S}Vbwh$~5T&glAVy0&skM2P*j4hBJ7W`UXrzfv%W<PJg*
zM-U1-Y`sq~h%yAUmmIh2wUUV~xu6Z$F!UWaU#lWX8%2M>IC`)uE>f^1xw!K%BFY2y
zgA59gIr;-`7SgJbZ|}Nk^aryr8G$$h7Q|(tu8vv6&+xWj<6*xkrXy|E1Ki&bbpZ--
zRXN&2$bnU{6vVUlfc+t=-sU@eF-boVTYWn&S<AH3<J50tRC*-e{BAwi9cY;5diXoS
zG9gc`)p#f#Tx9Ck6=Q@y(mgb2G+qJ3{WWOZU*NB2FFDfU64Bkmf0cXA004lVzmURE
zDwrgn63-9%fl#aA1;FfiIIG2>_kQ*-9(&*i-u1zDuvQ#;*Hb_7{#*XwyC3?I8!-V7
zeew_f<A40!w|(lw+Tei+Hf0?K^pghW&}oqw+8U@NU#<e#91O~Q36;u(O1+ASW6U^T
ztWE?f)%3?MXP__is0DUniBMj^Hqp)Sd%dd;$CB6U5&?VgMtQLsS(@rZ!U=_LffIsm
zAViQz4M@PPLD4>W(|gtFs|Wi44>y{M=!T8EQBYrcq*(O$OjkK*27`amBh|u$C8&;3
z!2pphlXN_^&U5CO4}%cREh<>p*h`~&4XFV*bP4`BehnG~-vL~e0Ed^Uk=EMLAojCp
za29aA1UN_(x24Gtz?lra<d-$h0Gv#40WJ|HZJC$^IQI+_&y*B^(~_`AM{J8iz?C5w
z+r+>s*3AeM?PhOPJalU&A?CBo=)=j%{F=!mqz5yZg!Ev0CZXwC*i9LQQYIn&nyNEp
z5}Gc-&e`~;%Oo@sx@s0Yws9p!ui-JvH-njZylIrubAw#@M(8h2Z5%z<>4)xv;Rp+k
z41cXgfK>_pgI9o<^v-xQ>2{sEjo#mNTdP6pHX#x8G&@-MNuOD?_~|lG9D>Zs1)$k+
z<-Do1JTA^5Ec1EivL_@D0LW{FNjPHoN^*+k{@MIha%xa<t!Ik435DegRE?5`lV|=+
z4T=R0{$&lZRU7e-ZY~qi+77YieuVkNL$2nF;r~$+gMf_|FA%RSZd^VY)$QK6sq#BK
zo#|GFGm(!cPTUY)jUz`k+wVBq60IYdxOm+Gg^3p5B)YfqfeIV-w+lSK?tm*E*ZHaT
zRnd{4?rQkcOkTA?Q5;o(%1e|*UN5IAYTZ1luezQAlHtE*9`#BSz1a|&37h2(?34>_
z_+#OJhlT$*C<?IC<^QxoDXaivV4i|6<&37Ni6sT4G*JCGHwQW>W)WdDyi0hdo2ac3
z1meCPM$J8@tsMT8zoRZ3c7xB3s`bv6AB1(=%~R3-nL>~AERcRDW`VGvxB=fXFf|L6
zXF-vvi<4PU=PG7_DUd}E%si#N_JPE~*O<$O2>sd`POm*7cfp12C2%(R1RVF;!&HOO
z9sj4}V)HngfP`0sH-Fuc0aK4#@9q=tEi67t){TK4|0^-h&J(VHV*fK%w)aP0n5AAz
zs8_*8mbUg}_u2>J-8adwr1sS9G15sm`=j-@&2~VOuh9VMchqC#QVl<fhw^rS5;b8p
z2V?{aG6!H_g}=0upAKju@u?2K57B8@HLM}Y$=VzK1WFzg{F8O=lzJf=eEre(<QoCO
zXsLZTx;t9z1_i6<llu7e<Kn1dLx`>Iv&LR+fTZY%f+k8Ot4#>s`&CQGwCsQ-d{Pg`
zh4f+&T6Q%!2^WIo-3a9IhNk|GqoQ<mkgA4nr>jD>nvF8mhI??y(Q$G8@NEJ?as5$2
zPEej{HERLt@Kme(j8<VLU8{L~v|XjPfxKX(%Uv~Ev8rb>#?=hSBp~KO3<T^DVG3q^
zZ;<8DGH=HiYO^F`#px4K+G06|;BIvkM3-RkTv%E5e3?x$eTK?P0v(Y2+$xho8O)mD
z9s%A#+v9p|L7bko%;CQx7;q_*L%qR-2k+261==-a$d@732*y<u72$xnBcDE=oT6Z@
zK2{+9mmSB)0H+L6yB4Ar0s{o75$Cf#`8-=VhKeT=1c-~8@k}%zfOhw6qnZ(T!yB)*
z$#*S!5iP!wRyBQ)48hFoAEF<0&%`sK8Isq)Kqe&dO?)Gc@=CH>QJD#fOkxleh?q%A
z8!q$?bYTq-`~YoFRN82vpSRomm76lr6)`(AxB-rvp7>r?OGgPAH!2&lLW(KefMzmo
zXy$Be#mtFR06$Cn%+loF^r+Bl+J_RGVsz{TO?;WzPmFmY!%m#&AvdAt;qi@PgpXO`
zn23S40QC`-M<Ll8uNfC!R?$;r<MoYxvg#-D@0*X-IIKH{A~aw!_|ja7)oQ=8pwGaE
z^NL;inaEshpbCT!*SDoqP=geMpb+{-zd%lAL54JQk_zGVp*#K2YI}-mb>ADW_?}K8
zR8_^JYEXaFZ)#CZ*J&gH$M%tUMR)IpkBy3YgMR%it0{!8OT+4q3s|qD#pAh>tEr=Z
z-7zSM4iv+8LKs|rrfycXXT%Lvx!y66^+}^s_}O&}Z81<dxhk8~$hr?z$_vefr3J$4
zqBrU!J)+liUmP~|DAtl^+D5e><W@(^U3p3`yR?wkBU=VJ=yx6(ln8zC4WmX}h7cdK
zi~Is+Q;3HSCq)cZ1+#|nWg=NVf*H7`>C<Mm^_aV@Dp{ut1Vk8JUv*+RTDemb@M72^
zK372E;0crQ!V$oA1SLf<VQGmN2>BCI{UkDU4WlacW&{I*GVg-^DNa1{<`FdEUi+Bf
zj2l6?;9mYjZP2jxIT|+FNYlQDdDl`XAM7F|m!90qlSbxudyno`bf@`Hco(h&-R<J8
z2B0j(A&{9Lh3TM=jitk2=PCAsGk-XtU6*DV%il1*s~+A7EE6*k)L|wd|CGqt%1p9w
zJ_9rHO21<}2<wqB(M5D^ECqe6Q>6X<%sz(>2|_U+08E-R{BtrpBjF;j+*Fjfhlw-`
z`V$8&c@D{=%%Qes#A^acGglz_l@JZB>1fM_s)Y)OiFq%i@fUDi@j8VBiawz@W<+<|
z<e{n5Fpw@9MiQ`@(IVIvV6#cK6WySMq;PcOq4w*FvL$c>vod#tACApYmT1d3g(w7v
z?L#iy+W<^gz~q?N1S2j4p^hfTh1#nFc|n6sEq)i#wow;FXBKs<jJlas0%vJMpe{f~
zDVc}58jtBCm~3t$gB`$Gr^&1`4Q!TMQiZg?0Ezi<(p{%PA|{*Q(F-nRq}L>A0k{zM
zN(mP?;Q`p2KS#sp?JN<cI7`Dk0}?Y`Vuf6^k<_!#Jn3QT6nyvzk@Pc{2nMGo)CV9`
z3uxnjen@}S4_&)AkLbsP>5Z=4XOHT~!|9E#-Di*M$Eoy2*Y2|?_2aShM%V7Mr}g8B
z^hVe2vzxz*A5Wz>x^|zvS#M78N4?gy`|Q@~H*e7oJ<(^kPycwEe&~tbymk7=+x0_F
z^yZG~AMel)J<*%HrhnX{A9|uUcTfMgS3mSbZ{9Qg<39b+6TLY({o?`s&=b9RNI&jR
zKXmQhJfa^DrZ>8FpFOG{52rV}cAq`2AE(kAUAxbo)Q`u~8(q84p4N{i(i>g7&u$jR
zJ(b?*+I{wBy*a@j4MErLv$yESt?7-f-DhvpkK5B5UAxcTt{-nrZ*=WGdxw79k>2Rq
zeRhw2+?C$w+I@Dfe%zhj=-PdDpMJb2z0tM%?Bw*Don>wCw<ODFd7%Y%@G1pDilf1r
z@$Mtb#Tv!y&H+P2D@|Ni(gLoC3+K6VNbS`3@?1T5xTmZ+@MCfJs@l*$nBV_xRgV@U
zWW96M)M#vcT@U|_M8m@Xk#E>GDDB_EuO`{SM6XrF=&*Nc6#<uwOeSn9l(KAOY?X^L
z;zKSvsTG!q7$h=pzFd^~k>p}Eyd$==M1wR^ZDgs@RJPft`Wphm$o!x%L4O#D6hA9a
z0?1F&>zMzbTYV?dwB@@bf~KJ{QU2XdtMWjgl16~u1`Gjm20@in11&mI^|&X=7)nBT
z8WISQ5%W}oDG)@bf#76bCQ~uc6l86L(cSJjnJ>rCLHSm4tlTEYm_{4wSav`<L>4Ha
zX~GJQi?o=*y_Iq}1FikB&4JhaSoLBNnt>KTwNb=FJ`m%zu@z2GDeX2(Ry83+FsN>g
zpF0$D)_o2*SGzW5S7_N(h4!QuU?TbzZ~3Was$998GM)-BLmRgWF7DGso#)Dlg#~r_
zoH*u?Z7of4%>js81kLJ+{lZq$_z59CAf(VA8bwdza*^>d@ZGCcN&!%19gps)E|!Hf
zdi4~0pQ`vF7}A}1J^1m;bV>A`x?q=}W-qw}owOocf-DtKTrR;XT!K~S5(Hud`FDeh
zX{a`;jojlg3o-0}9xrH?<pxJ{u5g!FJ;r~BCd+iQXp1tUL5dJP`Dk!-)_b2R?}?DM
z)cHlm3!Vgd*=T|f<W-ULPss)pBckbLA~mxKhh~rm=<seoP{avBOMpvDiD?Z`ij#^C
zUR|!<Xe-67Wy^N4#u*{R(yl=+TD=vT86!+%tQiwl1$TB3w0dM+izm<Ml=o*YvE58Y
z%y%srhjDC=Y0}=9FLFLv0h=wHGJ9J-CvFLj32Eh7JT14(-)-fV81s?`UwGCyC8faQ
zc^rFSn;OJvlwBhm<k0OFgS>9DrvOsJ&bRkpHcmD1{tHHUWAN=|DC;)q9owsv^S*{o
zlej@9K&KFeET*v+aS)W7tP3Dg<;H@LadmBuI&aLBUj=G_(ileP7h$DoyI&-`SV9V2
zxJuaD_cJn<PhbMMBN-yBwS>drMy5Xr7R7KfNCZn5E>9$`$cm9jxWT(bjl>7|`?(&)
zvy?mXj!`8M9>GC?bjTf8M1SzBX^DS&|K4{$c~T)kVg^&OX9~oOO?<cmw9hOUJBz-s
z4|bM~8UMA4Y?Nn}I5V+DE!vBjjCtHenpx(wDb`GyP&A^14$PeKn<8xrIh%Z-C1@tr
zO;3lP4UQFG?jVYi<=Cg5IZ3Enp>~lHX_rbD-^gxU#-@M|a7Hj;^;uyP%!Ps*CC4Lr
zLU%9057KbO7xW0F967<yD-=ucQ3)Jcjo=bXiQ7+vTvHaTB}ByV7HxMX@oPK>$8^^U
z2M~tkoHFu%zq$KbckNr>qwZn~q{o%-S_xRBJ58YNo_!I?ae6e{Q)Y{Lkj^)&L9OUV
zpDp~Wjfe}dXef58>k%&za@d;Jh43S7&jT8O27HyUb{DyugxcKkX90P<Agpp*JjEPH
zhi&iUtsz_tK1P6BtS$mw?adJ)CQMqD%vFMdp1apnN>zG-4f9eJDioR!;<W0e^qO^a
z#1{=XBFUiFRu#GPKqh(nSR+eyh;{L$bWUA_w=R%cY8I}n6+x#HUA$pHw~he@DYY}k
zz@a6n1}aFniH8jH35}>SfCm4(+bl76a5TMjaC9t))}eN%9hthJ8Q9jeESSO7j&qZc
zj|l~P*g~5Jq}x0odo3e03(WX)O;{esK!+i1efH@|sL%prC=|<hhWA)eBZV-&S#&}G
z2jb*t9EHU=GZ2fitlMgV<z>ZwEp#Z}1%*}gy3pS1POy0?;ZHwPme>+W2K<v5bX!4d
ziE1#}P>h5|!`-Focgm8wpQ(x}!N5dDq!8kxTsJHDbU>T=>A8cR$SFVqm<V&mIN<}>
zKFj%obwP!Yo`T=S=CQ#_+%(0}!5(f2=H>PAP5xeT%>mv@%E&WD09FIbBJ~!|(Bs{U
z^5|fYUa+R@)G1MdmDlnZJNwdv*!QlQ?6e$czbN=CtHblP<#p`viPwYk<J<6dQYsX8
zBGQCzs`3pi&bpSYhjia8x#*EWTsM6Mi0QgHc!2^|7~pX1G_!y|6!<|JAK9pmPHvAI
z29S+McqF2%bYG0b+L2B53qc>o^*oBQx(6LzlmxocQSm3>X1bUC{iP@?o4loGQGYN{
zr=qNW9%aNP2fPX(DwgaE7iIMToW!jDSw~srZcEy!+dD*A{nw3~1Thgo=PqvY-KA&`
zqg)KUOZC#ljG@Suc(D|%%nriHt`a96O~RN7EpYs@lskz>v1ydw*V;qT64*Q#6Mm=_
zACV9&2VN2~6V3@uNvY89c$0MtX+hl^z7Q8rl2@+=FEEp8pGGC5O&Ie*7OP?I#o%m0
zgWvMmtgk$3$%8qq+A*iq&f9ovedSvbsieWF08!bJN|=6zXHY-24Z4)3(JpPG0G7zx
zMMrhFMf$lQt=8tc7;W&6Jov#wbsXtNfG|SU@-yd?&zTYWnC9?)SvMqKWrMq<X{{aa
zBmxA?I$(^(SdI~_7u&D(-e}Zhtf8Zh^QdbkH|C_j8P{RD?oZbyT@R+~73q4Ful14i
zpLH|R6DcQ5pIqx&?5x_aCF3}b4fvx^{it$tI7g++kx<%h4<hC4?2y_{FX%OJq~{6-
zM!Y-KOYdra3=bdWS1m^gWSBfteB<mt!X=|pQ#)&a4gijb`CO%NC8jc=TiTO~e#TUh
z+KFY~8btv`li#EiOTVo#O4qcXMXCrpAIwdZ^9pW4uipV;w10<J2iYQ|`&*v^Q=Hjp
zA#8^uR>DG!&R!-rBP6wEDO!^6P6IEwq(Olx3>><76fYCl0+P$Q6BJ`|Ns;d^B27+5
zvQg`W^#&HIcbDYd0a87|6)9S_<Jc9`01|Cnxr+|l)zrS#cl{8-g+;I?Oser}c<IE~
zWmH5r)SIAEYmQN_q$SfIE1a5H57_~9v}FgA4pGxo!bJ+^T;_p>udqcBlLjW-OzA0j
zDo%i}P13e(?-Dx~JGK`~ci43tzcl>6luQ92#@7_WG1|W6bYHve_Qma^vPMo)JU@6S
zKllz58^#4iqLOGbR5`*-U8!aFn1sEfF5Tsj{knbJ;M7(+KG%*5+n$Oc3Zs*|IO>h`
z4z@kf&hgNi%{-TO?|C{n*=gE!g9jN1J!t6AIcfKy=g{t-FP8m463r)hGq`ZR%`r(K
z6TQ%Y6bVqWu?n`QSh7g^-pGkbco{rMb}D%jh}wZ2)-Nd(cW+jK<FY)8@&+S0Vr;vt
zP^9`ur(s?K_vG@A74Ah4>Ge(jn7^#@mla>K=X&w_WB&fNO2VPUNUJ<hm9;<YwR^6|
zka(gv+SHd7bywz?0v%4=S11fZQ#}|f<4CO(fwZbOIFS&Qkbrv50Mzdu{icamA3nz4
z*B(~195+gRxvdpiQxDa1ZXJM6&yF2St%eJe)Dlz;UuBfgo!mr=;a~JGWyq)5b^{g!
z6^YksvqF6U)*~9^hUX-nfNumDJHa6~xIAY}&hR0zV7}4mu~ZrNgnalMTx3B=CJ31z
z3w_q!5CX|hY6j<Vx4&}ZH=rE8gkj{ns=KRwXBokPQkrvO%_Mhlg)_R@O8gmU;*~}u
zsy_qrnmmLk0w@xDRP<IBS%W8lsl3LAU#62D83&(6hY`DMlwuBK1s+$H-db1)Gf2E0
ziOvcK2*ITo71aj);S*R#a7<ec!`-zOHP{G@M;K5f3~-p4z$oiN`#;SbYt_Is37}{`
zxjp0&U*($I2E$rcc$(XGJ#->fWw|NEiEeFqHTds?zu|c?f0KZdE=8U2w#4N^EF?b0
zD>1=~xbRvhRO+Zd^S5)rx^7Looa&uf=8mjOw(i$xgu{>3gTL&RE7Od-#f1sKv+L&s
z*>@Vc9sSqEr*cYOcu@VM^h!$_uZZrFDARHjQv~QoC9_W8tPI^w851@TtpfiV2^AAs
z_%u;O8p2ZW2g{k@G{@4D_0SABdD_4a_=MCDH^N1l3Hp@~*n}g|Cmf=Mh3iLBZlVit
zfcZTr8N#Fo(DI}QlEa|Wikwgv9l5Mv$Fal$8Q?+-YPfYIFLdC6v#W%#!eUfb8~Vp<
z%XGScSg)Y#MTJwNG~h0i_-|jPWikeAq97eXDLw*H%h_X88d8THi&J$*(XLJ$9IjL6
z7k71%3($4q;VhM)s>4e{;FMKEW;*4<vzI^&=mcN!FauVLo(&0c)52SfrCHMUAOlR3
z371hVo<07|OdxGbcWFyGsAGdY$<uyo0bzz(A=a*0-%mIyy86NaCd(0O+Um6uJFx{y
zYT&^vEA?uw_h?n(q09b2JQV)9FyWv21+F2*#JtThxl6p0yTm)WOT1I^4&F(gpb76>
z2AO6nv6usy$Q&dFwrt)>HW5S?U8OIKsxLlI^TzA3;^;g%<Dvnp;RU~qLI+0*JfVm-
zcElpSPeCRu<S5$`2qt7_4wgw7JQ#1Cc`)mbU=*%l&F<;iP-1F;NId};{C3AFASa~m
zh|Nt)nVC(~53%W>$Hb=9+87Z+Cx9iGm6>Z|)1*$x!jvx-r$)$6$i?~O#kEmCk#{=o
ziIWeSB?Rn+UHh{&>+vSxbcdtc?h|THdxe;*#1Zk#9=WvkCV)(z6OcI=Dg&7~IbbN#
zU$DrTjHTa_uWjB~+-2Ta(14;kO@$^D;>u}1h>8XNCy<tb(Jy^9cx<6uMnUuPKwE&U
zONb092%OlV)F`aADPWvDRK$#rG$RPFJol3;ovy`Z#!Dy1uo4+@N+@4%g5)Fwr^#i~
zk|?5_MQHx-O^U`Hc>4rGLUpti3CN4G;&8&6;g9j$9$s6d<sSJRbm<<yat%{}_#<cp
z)L3dy(NCvO?X|?_IyX5ZQ5`x&+%=Hqfo%m*V$w1=xlk5GA*XwvY~$9)NC*#=xK$>V
z48neT#o@JOo&U1Xe&3DXu(qP;-i7wnN83AYyp|V8>IH7Uc};W<So`fIQEXM}R3BGt
z`|Ti)t0mpSf=Jun>IpwLD4EAtdFZbs#yE|UkH3)(Q+(N0qeTV&PF{RN?EKJR9qbCG
zYD&iDmM7l$T{pk}C|j^}jJVim_h1?Dz|`4fgb;$@x?Uha1UmZAfsRKBbm}$mq!TKj
zmE@Qe+GDa_2_K$x>>F|E*Xct;#~n2JYfqvq6|k`-1NkCrR@`B;_}~)69~uh?OFszz
zN&^x*v^kw7me4E5@9QfKLRH$Bb49k@C_qJn@2)GhAu3Jy2Hj+FgM>KMhDfr@Oo|x-
zbjI+BNlsFUqt@9)fBr8{5`cZ6g>iEcYe<S1_^q!PbhtMX0mjqzY0SlT%M0XWD1<c}
zPF#Ok>WG_q2d&V+*4oK;Ds+KoT)-tKGKC-7si7or3n`H)Px@pq<uXJr@dZ3biA=eJ
zKPr(aTu+Hi7aB4K9^^tk(}s(dPjv99ge*fDet^|PKTJc22hwbnR$7BZ<njg3$~jKC
z&pA%Dc|zTV$LkncBe(LIGF$xl>H=^{p}VyVO*Q6(UNCveY{!&oP+-T@+R+P>UA~|V
z^q$)VJYnt2rP*R}0Xdnyj(1|=sr}j*to$`H$TdQ(ED97Ft6|`=*fjs&I+s8=Re(en
zr&D!H&s9q&gqX0(x7iVZ=OuJad}LaE)&gdv*3q4sImlI6?%fOt1xllt{`8bj`UlEb
zNjw4flC~}!92MX@C=K&~?_9w_2S9UOArEBygnx-tDg=!jNbUM{@D3!%@ez6`G{Bn^
z@VugZqYsaP+zG${IKzJ*o|MOhVsuW`^I=O>o5TBRO4s`BN!lCzh`y%D9(>nAxt6xg
zD`lDn0H(RW%(fKd)eu#&E=~(1qtZy&zM;hV+A4#5K`#t$h~BXlOgR2Z$&|bqBa3A)
zbJ5NU2Ir&%auUL6M7dIqcx!R7at)kK=9<PVb|3*K&6>j@?10k`N+G%i^+vV9YtDJ&
z9Fn5_p10ifVDUQa_#0mbO28#KcqcPQc7Y^rdHSz{foh9u3HPCCwls?&g1k)+UQbWe
zpak2B;sEOyfcELt>M~!Mhgp5@wNLzIo~Yi4p{$7#IIb+xZuFtL5vmNJhHDrWfCjMO
z8f-zUt{v$o!if$fRMyHmb#x^>M<ykc0+PUw%?HJ}1@bbwN}oK4CG2Sjy)ku8ATH<=
zD*`JVGrUStZk54F;<tARv)Fo)IiMuQvTbSh$Y5%$QvdR`EaVCzpl<*Lg7xtdN?t1n
zF6IhQ+=x;uM+kvF6a>nx5B{JGI%PF6=oI*<S~(#>Fv2s8^jyP(fqoa~yYmW5>O^@=
zM^q!Brn3!jrX3GvG8pK=mJ9}#iIZBoLZ?)xc*RVe%3uJL^)$E3L8bA{NtbAIU?rt7
zHQ=wztyqOA@LM|*-s22BP|yTbbiVCiEO43R+ot{`5Gs(jeGkY)joT6tB!@DyBQ`(y
zlUbMs1ESpDRM7sD8PImaJ!{bBxi}4kzZz1KbD|-wJfSTh;gyQy3`yY&O8>OafAHIj
zovSo)L3lgNvMH~V-o}nZXjA?ztYxiF!7IbjR#qFTN(@uc=yJ@1XM`xd?nqn9vMgd9
zq9@NBt&S>K5;HGV%9bT}$+F}wS(e--%aSiaB?Jv|C8Wx<jwMb!TggbD!Ah)_A;*#`
zM!|ya*ng`o-*A-hv(&IvcFqt&cB?bd1wZsy{4jc>vjd4LIgXf<V(Ak@3R;BoY0>E<
zcl=?$A~xnxdtZsq?bGf;`!ojnk}TQ;1np$5uE*o72Mi%xKbB!*?}%SI&OjEAAG0(#
zdIUIz`Mbl*6tu3r^xI2@Sv;?#<u)g=h#eYK=tr9#p8Xe)?D6)QH$J^|l+O5igbXje
z*RZ7*p^bM@PG8RJXh8{af575lIob)H9=##QT^<Jwp{oOH@;*2aYu-od4q%>q)t~#-
zfT!->MMr_ow%)<4z4|599s7~glS~9oFfdV?ZYeA*fjkns!$9s526C4$kh_F|lI=ny
z)k3JL;UyQ!Y$ZU&!VFT7)nECudhp+Ze_lehLtd^8AOM>T`x!Zj#F2Tg2+e{{fnp)O
z99NUodU!-q_6OiAHpBjQcodDR`_&w67mg23P8ccqG>lbD4aC?LAC-tn=l=r~k{Yxs
zRoAD_t98`$;jiNYM+xWb7;Zt80r~$%vD`>(CcknHKwv@G9-SP!OL2;V_*st2oHQ)h
z`%MbSoV*zT*|asL7<_M!6&71b2w1En`lC`?M)9&j%DFWY$n@%$70ZwsKZ~%g3Y7!s
z3zrpr_>bb^M@)*k5chl?R0XW}i=ipq1~bFYWNiHsngqKTT8eQo%4VhFLS_ky*U#E3
zj9Qt9qQ4lLE!Cvi3c{ypB(d6(dmk*36-8hhU)w9w2~DOfSy715KF%jDL-9<lMB0kt
zE?H5~iYy4UF<DV4Q?jB|fmD7DofCr3SW1xIl&QphGL_JM1WiUtK~)gvKEOBwf&^DH
z>zakJuwJ<zJ@0@L)vVf3NtlSBEstMdXOH{`e5g|Gy@HDG6I6`#ex)^lnO8yvnMqbb
z2224%DrKd-Wvi8f?l!96q6K6K;bcqYO1iVfP@x6%Z*)e)*m2Oghs6SQGE$i-RWeg5
ze$6veTz8l$#WpkL2hXxs*iT=`Zv94uufgZMu)^HK*YK6*g2kcRf3x^|mdLXD0bEax
z51cGDoDC@YgA?N=efNg%yc2n*_>T6`;@cH{d42mQ%;b^Fi{j-4P{B_oZo%8vI4YiH
zg4r*S+cppnJ@eiVU;Yo^k4wx#Nam$GY4THr9O4!Au#HGP;pju2Q*+m9y<_dt`|EZ^
zhTKdI^_E_U=qoei)P&sWn6Huq|6hA&0wCE{*85(vkOeYq5)`G0Lr5g4x%(0cW|k9(
zWHXtB1jXX6)8%wmHC5HKAS%cXL6A*A6huHkQ4vHz*<9G<DZ8McZ1P<2$#Z$ib9=w<
z+<U5Tbyv?+_slTE(}A11r@GF*earv*KE3*cYSDwR`yn+SD%ZIsD{%IL7p$LOIZ9?2
zxCU<=vXIuTIH^!yv8RGH29KoAsjmS@+Ks?sbl6<*5>XIv-Dr4~taqkVd!JmOOQII0
zuN6*)4Zwz!Q;E$W`f2u(SQgFfW)X<clu+c5Lg!R}SwNv!^_fj4tUrS+Q~=#%|KR&k
z-*spYg<lpj?-JPUxw&ho7EV_P#Y@CY@Z8-q*Hf)fVF+ny2?q;B;f3eCgS#(&Jghv7
z<&3UMnAh_T>3*^x&L3(6DA8m+2m*|cN+???u5_`Sh7X#hje0!fCXmZ|{ja6B5Cozo
zr-AxV*6QMU+9B$YOMq9Qm!YXLUNVPgQzX5V1<LWJ`;HJyB5tz)<Pgyuw+I!^m0oFU
z5C$1iir$N2qw4+H6nPe6=|=Ab$R$VJ`rb>8vK#3(lCfbm1n5f+nIRyfR4!vKYg-pf
zZ|RY2x7oGqvPkNIXylQg5cE{c>SVrTRX~jZu7aqOo=E|9kGXSnj}aHw1xSx|rE<=b
zzaoXnzxGQRbMni&&~0Q*U9cAc6XQ|SOppp<a4C5%IlHn<WHrfz@u4#d^(3=H?}RL6
zUCv+dE3*``0PimanKi4g^tCk$X^L>3v7XW0V5!Jrm2xj(LaS9O1}AtYlX=JS8uiWZ
zo<W$*Ob7--L@-Nw1yYa<o=B{vu~lZRGZUto478L*&S;HSBi4c<1-{@d5^zl#%Z?ar
zF(z!RxvX>DT!!#L=g7#5xKs~1lcDEE8b7whX#CyAwwQQjl_?c$T)oBS<p-kG)QgNo
zZ?>4$C;>j8Dt7m1iy;l3W{b`1VLi?kyIZxzIPIyO8KhOyuapbE^rIJXEkEf!GZ#Gl
zqO4ye!=imCS?c7;u-D(U*jp}k{m@Fkvt0ChyZZT&UHv5Q9Lbl4R}QlN(UoCuS2r1U
z4i#4p@`Jku{cKm(>kf+UV0F-5PP)l~qQCK*R(~)vGqZ#L-O1;7^4z15zLfU|@eGDZ
zf7tlm;{9PfNtP8W!$CVQmWl(kHgEIGgT+Z{>Zs#1@waH-_fa1=?~LLx>4)<!?OR=8
zh>CXAob|0~{QjZ5OaF8$8{c2gyY$DDdlT<cZofFt84QcQ`Tl-<7xCo9N^j5^Zlj+x
zvA5bC?y5iO+t1JL(0#f$<zCIR+~Ln#pX+`x=&km%VwZU_b1pOdZ`2`udOy$i@|g68
zc$a?GYpqyb86It?tJ%R~IQq>cvokY~Xyn;RTJr4buMURUuGq?a&yK91blk*tLd$aU
z!cRTRjnX1??KH7HKgyC_OP#cz^pCOx`-NVe9R_w+k|!&C4t5pYRn|4LDD8dK+>V*=
zrw$YqGw1QhzhpR+_ALy13rU_Y9PSJk7kY<^e!0{;Jnf=0`$RT}8K+%Uf2G<PYktSf
z9_o4z&%Jm|`geGjbz{=M%lmimT-VKuBMZIN;X<!mNSWAtF!LJ9kh#3ATO3&_GByR}
z@!k1+H_f~@+nDv1S9;xo1u=Tl?feAgT}yd)pR3xr{c;Z;V#_ik6gy2J`oy`i=pN{F
ziz`{E41dC!lkrSeI=g!557FZ`uezDIq}efZGwqbKMfM)eow<<bES~xL^K3qog?*jD
z%2IN4p|iZQR4mhDPO@Hip<fJF``sd6NV*F}zu)UGtd53t>FCTk<duIc$(eI`w!0>i
zrKMh`dodXHJKY1)dhhHVGmoOo&#?ey?zda^XuS`XIx<wf{!kCj^C|yE%6%V$ad$pV
z`s1W8Zlpg!`u>gdCrR%lozZ9p=5aTz$Vgpv)oS-}KUul#^2aSOZpp&qZe-y+Zh=#D
zwHTFse+K)SMp@rOTH0XhzJc`ZjdVi#o}`n(py=xfDU%MhUbRqk^M!|By`V3Kg-b8h
z>4#mtuvBzSS#KvV{~wk8ArhBOEUQ<RgJQVwpsN=wDXLCZrLE=vY4S>WGUsLu-HmrM
z4!0D8)urM3ap*2QPWAg{9GZFMTxq6de@a@`rL3n5cxIkDv-@Sw<2wH8{ioR-gOqDp
z_Cj7{y}al%&o4W7hs3|0`41kcv2ltGR?}fW$%f-c8NV@kE~FWf$E4@$^p=`ZbWKxc
zcHXUO%Zux_nDkwBdb=yUv3q2R>(%{4>XMu01w68XPQ2`_$9m6X5e{}Sa7D3eIa%S_
z81|1+<EN?ban!TI7zKQ8T(O<}$il-G_U^uU_ulLF-+3z9(`C-3^NZ(Ix7YJH?)02*
z+&%e$qP19b4lE8Au4We%OQlI(xnP_8uc-5z^s6>4k2Tj~>s@xal$H;MRl?+Z07s+j
z9Fu+pC&;%n(x0u<8^^4e&`#aUy6rT!QO@VsI+OdWX`Y3LFIb~Cyq5+|{%vn5Z}(+n
z+Vp7Qp$k=BP6IP_qcT278FF%NY`2uLRFqW_98<cCQ9e0|B%i*&y2(;?v&fmoea4Zx
z+J*Ga7L#<TAZK2far-*?WZX8^CoPrUt&MSE_UbmNq_sV@aou;5Lmi>EWvzXLP(f|#
zy_2;e^_#R%dJo~brMFb<9t=7Mx^k&jblz0wN6k^lX|~+USC@*xu0Cb8>3m(7-sky+
z)jpTHg<`t<^RtWJXW!L*-YY+Rp?>@4H|~1V@YO$iseKnoDChe34!@OK)udhCW1j7{
zt!krg5{=jan>jP{13WTcCVl(5w46`!_ifi%3?W~KiPSoz&b^fNeLN53G3i@)mw7Ph
z{k+S4VA8ko-u%6^ae;>majVVh!&kr??lMina%soR_fXbzcx0?iTF!gnVodtEyazl`
z4A-tg+Oh7rOf@%gL(Ml%!H+cQ))8%OUSKLZOVy1yGxHMKbv^Z+%bNXGKI=7;d}aQ9
z*H>%iT|aqs_Qro@9qBb=et$l{m-*VHk)v||n!P9GntXptTJo9nS4qoSGwJgvSJE{X
zB%DRN)9nm9$x?f;y0QYHIr{B&{8rYv$$K+t8C#RSp>E?9P`--qWv&q!&zLkK8U1^c
z7LHcxHfiB#uWO|D@Gf&@{w`^GOj_!Yy<^fX-la^F&Uu%;Y0?LHm-d?UBJW-!{X@Jr
z%Rfl^%EsT9d6zTa<nQwSP@YE=-D1!gJhE6?Df*-hhw>QSr9PA1&)7@atUX!(!kL=1
z?2kt`((>*%(s%GK^%<Jzf%V*)^i8B&jlWA;=H9gTv%E`r2dehA7j=U*(FTLcPOdw$
zQ1zsnEEl`E1Zp;{BGnEh{Z4Onu&_GpEOmxQ;Z5>|s+@)8Vz}7L`O|=Vq|;p(E^>v4
zAV-)PctlC>Nz$WBB<q@5dBN7{Xe$1(uhZ*4`KQ-?TfGxr^v362-oDRQ^iEj3=MK#Y
zJc0Jh8Z_yr@GgBc>1VI|`}5ZQ{YC5k{xhWIEWB3J_QGHbIX;rVNT>8UXUczNUEUqH
z>{}3N#X<>RRu8Cf1P6-+eSKBEt~dsh_t)0d{p+M};4y!H2k(z;q~FE+w>HvTAu~=R
z{XyR4EHU{%%zN|qAFtEqKwG%!aJT3)2T(Q(mt8({$GvyxvFq~5QkfYXT~2#TYvuh7
z-^rRZ<$sm;OL<Z$V3-^jH2(H=-en#}b!`}&4Z|`j*Q{ex&!sd**11W47isC&#4+Dk
z>?of{zUErFiga_W>|OWwfI4PT&c5M2GZ(z}tOmETLFRH1zr2tK;t}awMdd>v&1{#K
zmsZL@8g$Zm`3vtm&dVE~aSGnq{FF&OE_<m*+Kh?trqU;q7HYSdKA-edSG-{=g%r(p
z3DJrqx1w~uM!!U6_%t3FH<Nz)y7aTwrR9W>-*2h@HKulE<y)Fu?e6!yiPiFz3mdCt
zQ{L9(G`y`zpD1s8*8RqLTa&(vUdqUy5`M2ihyMWex2ea_;U;~*x$6Em>G$&+p$AR+
z)x7WIG2>v)0h2cOSu-vBcdD6d(D0SWZdXmDwTtedY6V?!aYd)xPMIPBH|ZbcUDFNq
z-+zp>oXh6#=dgU_o;B$`q^}`;Lw#4A7^h)w9NJhDhs$qzXS==<KYH6Iul|e0*Xb*<
zNwNvuJM%HxD|EQD<q<q4y@z+9J4{-B<M4F4`ktE^-hW4R>THqHHM~)i|9C28?WXJp
z@a*H+YsiONdPkF`;nA(movEW=W!Dq;m((GBk~tHe!_d$#eD|FfRy6eQ{nM3KU;I<o
z)-<&Fz0j934kmpK??TUQwM~YwUz48a{oYD@OoQ;mZ>`#Rg!1L&GwCPrE^XifZJTo1
z+%LQj%x_-G-(`+W`sH;VlNM><ckpcF#q-Xg&Y+W4q#0rZJKA>NMvYtJUhep|ig$VN
zTz#%=alIHOt^U+=`Buu5xfD8IXl;}3^ZuPYGIsJ$PV9U0+^2pXw%R?|?H%qu{3_@K
zZUXriKcJ#x%;&;23!}g7=Wp};W}lW$A{OoSb=h)*%X43zn`({9G-EcV41h*n?sYXG
zy_^gecctia;G)cBbr*HtO!<8}A^nhljr(E)busH-{+_q}NmRb`H=ppLOP_Mz2k+hS
zj8A=3GMziK`|a=Gy18<K?j`>AO7(JUk*zp>aL~SaHAN!%sNyJI#U;~c?%Swy@*QRF
z`zc6+b$wWdKIp(Kj>~hmd-06a28^RfU|1<%pnH#^(w|_mgwi_UqSt989`+sM8VQp&
z8VQp&8VQp&8VQp&S_YFgS_YFgS_YHej+VjXHChIf-maFx<TqM|Y1aQp+&_Ubd+7r!
z%IvAkldN}>Hk6u48%oWjpSkY$hH^81H<X)6KV#kRpHru|)cyu#cgI4LvV-5K(}rF%
z=@X^b-cy(RV%jV8nMt2YdabE1xcEV5j=tdawB`F5gYD`IOn##;FzK!83rs$vFEDAN
zFEHs7)fbp@rqLIe-=2uRz?897eSyihRegcUH;ul){Pr8AFW9kjoKG=n!>5?E;Zscd
z)vV8*Jky*jA{QG}+Vqh=@K>o<WDDo=h~(h9itZML@qytYx|bR&v2eu#D$!MxGBY#(
zLZ18c+j~BEhdv{Oqc-IT_blgz@IrFF%5%RuEwqe07xPGdb7mRdYF!^%S<*ky+jRgu
zPqtWO2Z3`8V6#DXa9~_n*q&XawjKGlAEa@*t0?j$O)9j2oG5ZpYcg(TNIP$%K8MDL
zOxC17#=Er5q(8vBw9BL~;a$eWwA1i>&GZDGuWomRQ36;asv6zwRwg)_L95fdGAQjZ
zcbpUyj&E6Zxoa^QET(;k#w)Fs?Y119tDhXMNsO5*F5NMc(U#XhD9ZSn^p_Y=p+imj
zP6&|Z-}~#*4?SmQ=Gz;;zl;3RPm}+=b-%x0UHU50(r5GgFY+#PE*|>i-{d(wNn;_h
z%zh`6S&bgDW99($3O^!qWZLr<-kbe@Yn{HaH@sGGKx^oq{YO^{v%1?u5^eB&dWoCV
z+2@>lxAV@w;KIA#<DwmBZ~S+!d*AauGqZE^XElC@3xTIR^=VIk#xtMw?C0F|+@E-!
zkj0<>2o&y8gTUQDRMW;L(S70s@b0gDlsX@OGA2X#1=eKPvh<QnVI5HJ=bfZmZLY6f
zwqqut{a@fgK>4+gQSsNCBB#mZH@_CKsW}q9jdx+oWoe!;`MgG%&-~Km<D|LaB5s*N
zYAEfKe{zHgOS^6~Cjvc3q-O)(vG2RaMPMfVjUuUDLH&=T{bv9KW201H5|W_-Vz}a=
z6$xfYD3jhQ31#vb63V0v31!kJN<x`(3<<T}wLC4%;K&u@WP?c?vcaSc*<jKqN;X`4
z<<`lD$B{>_*Q0#O5xu};$}wcax;=K%NPyQ<r;q^O#q*s!CT&OplQtxQNgEPia=T8_
zwN^<HX0B<CU-2ewu6UDvGl!;}lO}Dhe3Ld;zDb)a-=xizZ_?(<H)(U_o3y#|P1;=f
zr*upjSN;B7<5#_Dhq>xay1MFj|NWnH1D%uq!du?<d5ry@|9MisKX1fm8xJ6XO>y(L
zI)nCsrCypWU3U4pj!iu1H<PgmAu#|wt%at%Rb?6}s=hL>wsy=smiZIXQ})3~486O`
zbt2Vo5b=p+0ir{Jw*EHt-a&mI<wBD?&7?oRF8!Hx=|8R0C$(L)XTLozdc5rN{r#iY
z_Iu0Mb%&J@w1VIm8UY)X&wq*8eA+q3qNU6YKZTqyOS;|O5WXfuz`c+x>|X>CkS|={
zql|@HL0@B<Q2})q@>PK!FQ89PO2B9fU;~EzRgHRNB;}Nle=@3ax@`B<9}II%WDRvg
zc7c6PmSo91$*If)zD(Idl}LSNRD_vorgxIwZv7Kvn{Z6y6x7BYgdxU?1__^Vwd0lt
zQf@mH5b0ssa3}o|LAdOg?N&7Ht@?TDYbp&*+T5xpZEjVQel=~=<3Fx^IBB=olf33F
zw)<;;#cp`g@kQtBHtwn5Pw(khcbAACJx0N#&mt{w36s7XX<=7Q+T3L(ZSFFYzJp~h
zE8e89tJzV$8nK+_Z{|KQX~X(mi~h03k{alboYD))fdgFN6&Plv-_wV{l^}sSg9ZM-
z)Hzt7Gsss9ZP~J*vxpT0&>EnY90m!ezzVDo_|5vS;QRBu%__sxsrpOSf#2s~DZt`j
z%Wzoo>5_!sUpSl$x)0$1%JT}9G%5F03p;`xGw-3l>!xwywKU>C28c|SlU-6*+jO*7
zp%Xq$dDl{&K*nS@)gqt0m<{!oZx_3SeXA=7h>%sFp}8SBvJYFbMRg=Y!cye*uW#)<
zp{QSP8<tW1x~JD$x~)=vVK@SM3Z#wL$kpHJ!XJe!WQ_|S`<Y?Ks}oI5Q+XcDQ!(ai
z*`)gBsdp*AS^I0FE913IXu!=0psysqxnGo>BYRfMvY@pfBE@{EUp#)b1M;}fPy#&c
z9#BWH4A|cXk40k7QG_`+bOzkH*&^v1k`-P4sFFi6mSQN#e-F~@TDq|I#du~0dzAHH
zakP=K@w?sqesWY*rZ}TtW926(;zkY`pZ&ew^+?cY`w>}_y~9{MJyMq4utHELD@i6W
zIb*E#fOv=I!Pl*`Q*m6(Tti(MbM_dX%Xl8b)4b6xZ={80mowxFo-N$&yY;oM35n%m
zxz`5|DAq(H$lpRL^S4mJ;O=$R4t={kgwMNEk1>ifH?q#kO|*}{%Z+;*3sd$^O+rAy
zcgmw0MYxi5JK4fwuXk{vgqGoy(BCls?0kK%FHwe^k?ZRi{f>HG&u>H?@(doS$E0`9
zRk8?^zJ~Mz`Map6FXWLi6!?dXpNM58y^BX6Bch0ww7?1+p5|{vEGli1@8qBCJD(@u
zG4m4g9`VFHrtNxMjI6SKs1Vs)wtivp`zL+(4sC9d^C|thkalyF&m@9TWCIQL@UXFl
z$F(%mZ6d2~<GFlpY)iQ;^zPTFOXe!4t_41&Zx=tTQpby0=V~7LCw&$8g_hBd8x3Bi
zr&O#6xDggo><I-ZTK$l37!S(hW9AM%<zBmrgsJ0+d`H!~9y2%JL;4z?-8>8O?}yL7
z;`}T4Soo2JAGz%O%dR;8v8FpCVvOGGLZn5HW@g?^nIbDIc<#ev9kCD}TaM*gp5<GC
z6<U!M+m>zHj_o2M_wB$A?Z}QD%ds8DaUIX`oxlm5$cbIcwOz+`UC;I1zzyBVjXle=
zJ;!rB&-1;&3%$sTeG4JG<Ga4+`+neue&ol271)6jxPce=K@fyN6vUww+MyG=p%?mL
z5QbqC#*r1-krTO*7x_^Tg;5m6F-?rAKBnlHY%yO|<7C#_9{RSIXCKdo0jbpEZ0c-L
zZnTeFUCqJc`K_EI{iF-sURl6ZQ)MQ#`ir1qbrAymt@IoVGY_xk?_PXfGAcui>8cX;
z@x81Z^Y<!$^*3D;{KK$XA!O2tnVdW#Dt`i>a;8+s{krP9UMz$19;cA-A^INCoP}JP
z0!*%IF+Y7N<p>4*CO+jnlyxR+clI>@o7w$q{|O=L&K>jL{JMW<$v@=9lJ)G0-TTnL
z&z&W}?%5~*+uUEw&z#>a4!0}I)!FkZKAKx??gF_3+7+OC{zB|zx%v7>+klqNT1x?x
zK6}ULZ+$MvWKf(Vf7e#EZHhkk-lJ3xVy!CXZg<zEm#baP+nsk&*(t<ksh1rD5|!lV
z?`V8+xDUf}!Mz&a)D>O0gR8#RZ|idPpYMKm0ac|?0{98&4)1Ys^@FM_+Ki{}(M4zL
zYhcGc#76*@*BEFBNpjEI+mE@?j<wW*mWr8gyF&JO0<Q~e{Ge^;kTGH+L2lctza@hp
zA?$F`lXJihlO&0X+;ekvua1;!RsIRu_$RQ#4bBN-2$ss#K@7!Fy*cqQP5Y_J_X<0U
ziqtPX&n^Q`-TUNpA&d(zq4AdE`c|37>OOndbs?;6_(z{m0%F@A*4_bVoa2{PT$Fy`
zICkv0uDb6Jt}7%m7&ALCZ^m%n_R$_Rt#E8t0Of5KjkeK|&O01)mcuz47pdz9>RV1u
z=UoVJJIh=SR@*9lTix%av(j+KZtuK)|IV@HL6a&g@K$TI?gp)v=?&j%e*&%69{ss<
z)v<Oa1N~92n@K;uwZg8}c^<KUrzds=bU80+R~)BFk;G~26zbx4Nz**J#@v-*-}Zft
zMC^3i7?fv)w6~(FT0%CoZZ9(VYUlMgo3Cq=@7Ar_^n2&tO}i&%?JX_Gs}Y&4)(EKD
z>U0m)L?4|uC|FH7@4V&aojd7)Jaiz89h9;`=2^MpWv->}KcxLpphvdZQU<oy7Ewj3
zbsewQ@g^<bPYZYJ@){$lmC&u;3Uy2GTdjTkSAOJ4l3Gi*u((#k#CH<M%>(tVuh%o`
zhRu2#wua1`7}-)@k*}__#cUn-9#wPp$yc}PZ%nHmMXPS-xo&dHs(dgtogqz>l(1`b
ztbWr?#j<}WO%;;DD&x{B{5VT(^=;1>pJB_|FvFXz$n8#9HC0KNF<@bA7kS|NeySeu
z-nr&lbE05FOUz8j(b#HL(!pcxnF%etK_Aq6d)=~g;8<CO>1H%X*NYs;t(IZ$M6d|!
z+!;y{^}0IcOTAv^dJ$A(=oD@So#@1A?z_3=sc&~>2t|OvK`Hk|Kdb<${h&&-1R&!A
zhxO|EiI;nst-j-g&b3jwLGA~h0|}c$U|L?L9(dQfrM2<!7+YG^UC5>ov(MJ({Ng+)
zmgH>cj!tK}%dsCs;@@i6RbDS&UYE=G&`mG5Jt*45O`|M`yi_fGWxP4@#^%VtwOU-2
ztL)9{d|`g4X=J7aFAe6s)v8a~b#jdLN8l!%Zk9KxsKz1)tg>`13s%4{3dar9gVq*7
zt-%ge<)|PS5fO=(IB}N8L0Lwjn`Y{gDKh1*6J%~4CrJt?l7{L#PiW<g8dC&OR;H0v
zCh#|9n5&&{mZQLN#zua07rJa~+iBhvk+~{tyKz-OC+YK71b+HToLpS1b>{AM$A$=Q
zV*^=HucK~;i&hz=nUe>JZTSvFkb3Yp@*vl=e!bBgC>hI-^Rf*5lntjYect#+v!V?L
z`Dk++sD8ca_p$YFDaspG^}$-3J=S)lt=9VVBbs)xjU5rg>Uvogg;t)z!@BAruNrTW
zvvKQhwl*e{U4~3-wanX^u|@3;tkt@9oxQiX3mDXc7KK@4C!WUvUbvy1sLTFgtclKq
zLEGx>H@WG1@cC1<grn``6p7%ySGN23F=(|aiQO%{n+Y+WoXKHQ792T#RAymrr;)n+
z&11brXt80b>|FKJZ#YG{>gR@}EUYwixiHyoNl;js`mR43Z*zEzHjk|;bJSPVcdNCc
z4Jg_oCLS203eI}-I<l|e%4m|VHIco^X1G;I`Q0NSsUCcxksCeo@~m`nEATBh37srg
z5B=o29&OyPqgj~Pqxt|v^#Nxx5W2~5C?lnL%kW#fs~>HtQ=`1c?3W*=3D+6dQwTwx
zmg<Vnj`u6txa}tltZ*+AdwE*sttR?}boV05i}E=4>>!M|=db+Yc=uv^!{*sa_fF#^
zu5~hYkZFc-YUhq0BIQ)AA8s-QQM{pxV^cMv5jNwOH$SQvVIR&YwXMKSf{;Cus$JJN
zE1z&U)#JO4^sfj|H_J*tw0#b`EGmOYS>0x7;YRjm!fb7_%SSSt#^IVF3ijeGvXabU
zi~Gu69;<Jv#lJ~?W&<{=3(7dLWA6MQaP2Y;l(WZF=WCg#Cv2_bcW{%b-J5APw>?<w
zXxBldaHBLc^hzst3pY<)<PGj_DPt1<g50b~(91#!X&`xffE-bZux!^&%OXsQkj?Ka
zZ;g=Mlm)WV+(ohzT8ZsOdFU#CicEGEARB?w@pCIr5=RA7WOAY;55hDrt)xi3C|2PM
zWz*IYiHhH-o2kVo`zo$Y*vdQfU^nCt>wdlArz|_ys|rJRjq<wRPJ8*$w)VNAnHsIZ
zWY7@pM1BITU4}llTA-pSy5hMd3I&UO0lgj+rHapluGj_o3BL$ar-;1_*~?W^bOlB!
zb-cn#!Uz!@qQmc=B2!Q%PMLUc+l5``k*6LuMW)d8{3MPN%TI&QWzk%HCJdUJ`Wc!b
zY%g5jE<8&;{7h(7U`M6xL7L=tV!2_czGsR7h6l1jAHlfo7dEfznzc-ua=%XC6=CMG
z2|~Ep*ipNu$b{S$j@h;m@a1uoI%>~THf-g(M!l6)#d9BHE02D?;iqzgMAe_0TUp;x
zk>kc8>#xYN+=<lQ)6ojg4U3{gl2o#e&<?77Qw*SActuqBVU}7@o^GVn6q#Z#j7yj9
zMrCeWS*ET%9sNZYn{v5Y$W5KVa!U1xDVm;mR#AFRSRj4!(W9tGwmJI!s3{a)M>#Z3
z`-(LaEqLqEqN9@Az_zryiW@NLvlh5nGS~4l2G&VSuFvZpdx90jRr$1v;yGE}AWn)n
zjiNC1V)ecIq<BrG_-XG5YK&k{?}#k$k=)#NMd7y!&ZaZOLY-2|)P>V6^0>?}?Ly-G
zC=nV}rPy{uDDG>SxQp4B<L}vzcpNN_lx?KnS}q?{<OJo0rR`^kzH($<4$Dwoe{#x2
zr4+Npd<%UyLeoIq@cqYcZ&Qab)?VAnj{=K8SE<GCXwLoE!gI41mazo`eB%q`4B2!v
zBIAxQ^si5zaP;~jDQ^+YxQt6pEjC7Qq*l;wBwNc#|DY&1_DKuix2lHeWh6{u8)!>c
zs4&08n{);h#>tzdrLArfLiPA<a^nqc+S9}F!QuVL&d2N1%fZwaWkP;Ls5$Ml0KA}X
z-qyN`K^%BR3at(}A&=GfZKo8$TVx(&5Eu#ybkr?xJ?4aXGPJfG-^d4osx8ffNVUu?
zj9B{PPakWm=;KLK4ghaub+E{kiKYp<B~M(0?vUW>*6nnjlPnLc%!^&LoRL+i{o5(U
zw?me)!(_zVOogRx+fFH7kVh#<l8Ei$2c@NM|HmmNBD5a~M}Vwpn*DI%b0#I|#m!VO
zl~eD)N8PSZZyz_@9E;!>%C;yum`J+_EROKJ@Ukdz3ST|?zeKkK8!z@wY=>!_fK_tT
z9WN1y|E6b--gb^{eM4t^>gknZSu<-}SP}{sch!|%-DvHyBWJPemOf}M2Vy4<vN%+C
zzI>X2@y^VFX&zl$*)N+6j)l;;jEewv4^@L*s>l5I;Pk<)=#^8XA;NXk_mS(DLE@?J
zf6Xxu&|pv`{cJI=P$wfD*>M+r;}o56+wa{uIv<75@BlL9TEeYib}aDJLLH0jD-2@S
z&mjkY;EZf07i{D>WehwaMA(z5$DWbRbYtHanO_7DtSD1Y{otpLd0dR>NkE_Dy3ym#
z`zbzQ#);G|9Hb|5`04`~q=fD~aLqMBJuQkXEK`s@4iXYKRP9HM?xzr!4g!<5<6Dx$
zwKisr0kZ4DFh~^k$F{5z<|lCx0oj0h)#J8X5JVbKh9p7Ikrhs+lJA|eMcx5u@^%7z
zeu&I8r%_o+P#HTz9_19sv|N>npu4(#kKH=~(iQzfFb_Z@Yhn})bebX>wUMf!D~nZj
zBBj9)6d@{Yr2n9gvqa@5Qksv(F3s&cE|ByUMWl)oDJ?+a9Ojgn5PJu=AF4c&($H2V
zQBvAAkeSG`5_RBCW+AY)EFY-jyU1#G5g5oR>!4oF0B<|s1Kd1Ui>VYnhDT!sj}UvK
z<=aFMRuYH|cgpB>_sWOV;Oj4_BM%EVMvt4t83<9!R-OISVNk4Lt=ZSmR@d5V+%%$}
z92PhCw4z3+c1;<F0<2wLm6m5A5*Fl=K^(cZQ-tb=ZfTSnqeHEN_CyAm<pg7(EGcuu
z=!!6cGC?hdz=4W53hXpwG!Du@+updcV?)|~L=#_Nha3-BjB3gq2@L)LDVo(~#V*t6
zL`8@$LoMBNESG?kmmfI()rNAq_Z|PiVPeg+S66x$wo$56qdrkq?op@EgNPdR@z0U#
z-L}TWNt3uq1S%C4aBOHcPV`n_glHl&z@i*%1v;Q8QT<aZGO$y`CPjb{4d`Ns8fCC1
zf2%Ye6M$~$>%1VqS0TQ6;O<>DJR!JJRS$FSIS~|Aitx#I<J|Yu>d7e=!;K)%A&)T4
zND|*tho<OcfD{%8S7-sD^cWm<c#2Fun$^g2xWYUSkyN0LoSYuSDDl{{u8ZzAcl}r$
zouV;$z#<N;IL+MD3+TZUrpN@J#LVVM|C1b<nyY?zicC3ou*c0(<Y|cHFjP-Gp>9|5
zc{v24FhS2#+NI}4PMWJ9S!+x!<KKwD^Pn(YmuPNfp5;XpsUMvp6N@9xGCx81USP_T
zsUH)G?=gXL)>_;!+uys?!P4R;9Z76AC_1|`UeJ#9>4@tEZt9j9<hk#rajc#+`x$-8
z1hKx9MzF2QdSL|8#5m#52&JgHhnk1WX8L)J&0TAo+%RKplhf+h^;H?@#t4lj_mg8a
z`UL#sP}1d`qH_gd^gKj-UWus_|5Z<(eGG$Ff!jfMM?kr>!ANjz_a^e7>g1qp_juj8
z8iGNR{~XeGmo2o|%cKDb$$uz3vy!B+0}QNUFmQgUeth<33OBc*9SV*QsJAu@X^Ul{
z!@)f&mOFK@+LwCPiWD7H5qc?Vx(H0Wr=Bvag~htTwTfNN?ARZt<g06Y{4}rcg*C9d
zAjI`7LC5LOowr=OlN-2t7s%EA5o9RlvaZ1LbTsC0vXjj7f+Wo|TJ_Y~GeLKVGRzI&
zgVHRF5ijTJX=g;UvNB0ZA~+)KDy<YG;?vKFX4wD|Y{b3=f=B*isb`!K%>wj@{K86*
z1*0rN82ZdJqFJ2mNSru%tptfVGP!5Xt{v5zQXhy95(hxD=$NfIN!7E@h|XkXf&2wN
zGQjM@u_N`IGoo2;02<cC^<#-D$Fov(*EC}cA536W3+Iu35@l(jo_j`ghD!hr7S1Qj
zh0My-PfXL99Dc{iGKWQmYTXIc^UjFQz?!Duq<l2Yt}C#g=TFrc58J#HYBt6^*$XrE
zlV?O{*oOtAJ0f<rr41+ef-|C7Vd3RI;#&+kKvOXFFPuFcC<ktI=uv^uLjHMqsa|wi
znh^w^jV=sIHz~k21nR|&6}KrpZKvQLF)7QT_A+eO)k~(y#j1wo2*CiAj+1k?|I{?O
zTqlVGKa1@sDg_;`UV2&v%C%z8i&MuzF_J}TqFy#l<2^{EB!@XJfLdW?r(Ql)uCh$*
z%w~yzJ<fo^|MWDukhg%ELIjm%iC?m!UU6Cm3Zf!Sqcl%~1T(2PRX;OT<K=|Fq%HJ)
z?3DrV{_Hfl0A}Gq!NZM$m#4rJ)GJR*m#LpUlm(WLL6zm@>Q&P;J`MwfCJ_kpBF}R;
z<exh&jYquX;CsTstSv17i>X&n)%eKDy%@$ghX=I%ME(3}X?)_vp6?>42l?b<45?l-
zRpYaaWrHF)Lm;04Nqp@zxe^;P&IiE@)*O*ss9rZst_*?})Pc)ciS{V9)GwTtfdaM0
zQ7!g_G5Bw!MX#Tx@ffZ|2;Xxwh<Gt^OZA4+(|9fopuiz!=2?Q-t9s*9jfc3!5eo+}
zW>B0C>K9K-<AVr&l<ffMcG1}siTb5!8V~r{DjEJTu(2Hmditi*(s-x>L}u7k;5b5T
z=hQFHo<xKmW+#>tme?_Zsl+xw{mSgA6>Y~DK(L7LuMuNA4Z!tRPiA+(MB5l>L_wHv
zlw$1t=GiBUL@%xcdRmjvYHg}E*c6A^l<*lN!cF}n<oFXp5R%2YlVFbNs$ZM^v=%Fd
zmFVi&V!m4|yQ{5;6-SnjZ7pT21ciHy;}#@_+Z8U_oa@L0jieBH7&C^X0(vUNJOIpq
zdduvM4Z+`<!YZg_opw-3UvC|*rj<(Fwvs`+3$hG*b_$FH&YL6G=7=i;+`GJW_F;_z
zG2s@+F%fPDm!)?Cp<Ovzdzc}+4Fe$}Wn4RjfYeL%>$88Y$2vMiW4-3(uJYm27;&SR
zQ{vp`1V-Jl*H<F)QnCKQz!zk)K*&7Q#T;aBoBg|QP;V<AL=$?eeM6i`Z-ceoR+X%|
zHloX@T``jLEU=sCcae1d#_V?=YkgQqctyR6x|iGqC%%oK8ryM@uVtWqbM}#q++po}
zC8$1ar*fAud7&1l!0@$#1D-TW{7Aih_L+L@t;*fXXjj)|VidYA#(7KZkav$_o;S~w
zjhU-bFfbkt>-h0n-(6{VJtv7Gj9C%0f+)nK^&PXX)NMJ9PIZ8OkD~T5@;=_&9B?2-
z5&?V40`*(7uRZNeT=R=m+wRg(Tsy!j!3`&cgXq&$zdbAJa-+(a<W#8+;b;5CPH;~Z
zksL1#SOXXndCIn2fUfv-1a<=RY?bPr`gV;f5ZY+cC#sj$se2}yO6)7r)dNi+1X>iZ
zDPa!Y9s@i}y=(T_)grB67Gv5eW1uY#xWzY5)>+1Pb8BDq(p;X6E01{9@@veRtCcKQ
z%YJErJe=*~Oja*(x*rzEU4a!PiG}<f*H7=B6%FLbzmmU+DS3TOuQwK1Gg24(l(=vL
z-%Bx5@<a8W*@H4?V}Oquw$y4(fGus(Ia$FQ{T<=zA<8^Z_fe8!vX!d$&T8iqw&gXk
zE0d@S)L?61gld>JOys!gN>ZEqGxBU;9k8pmN3VmRP`@*KI&l$*{DDIRXfIF~<Uyu>
z_p~+#>NqMq)XW$MVey)(-#e|%K~iR63W;Y9eB9weM*aRNrmb;K8O5lyVRyxmTcqB1
zTKk`PQ4(Nvi@6P&7eqtvKgIpWBoZT$2!IZ5ketX?A2`Jo#<q_|mV@XiEik9a)CXs`
z33tqKIhwFe0Iwn21XTE;?UsZiRL@Jn(qpEQM8I|appyCHUbT5zjl<#O{B9gf^#QDZ
zGgv7yv7I6UD@PLmFMQnNi0W3pzE%Ps@a2vAyXqz|Zrdm^9_12x0O?BxHWA(rFbbXy
zKD^xyVqoZk2tkhRrIruI@qcW$Bo|^Dqc@C$Ej#i+B>tfpsxc3GlMeO@W!7+|H)aOc
z9Lq`ggkvA_r6Y0TqD;i9fWTb!N89Zn>?hjg62nYzuU3?*k8HQ36#H9r=P5pT(H&%t
z`sj8`ijl;lSGJLO+64y2>SMDX6%u7c71&6Ug_3M~U95ZoR1V@R2UZ%F*lG#<Uc4yD
z;+sg^h~d!)xC857IW99L)y#I~v`oqp-|LueOsEg{=?7b_N9cGf^2^Henx=X**an0k
z?t=YX5O}Hj_{o%NcnR1ibUmp96vYAd{)sbUo#KHa#4;MsXrfbsb^qk-bH``W+UWFS
z<XLAmS~HPp9!8rEz4mvfM;>4IM>NT~&eIQW8bk(wlc@lG73$7U&7QHIDLsf{F$i;f
zux&BA{6C)kvZmC-%2HwCVm>~l-gKIwNqGb<TihFKt}{j$w`zZA4}tXt*=I<8r}n(K
znePqsPpsSA$MKTo24So|J^NMN&zcFE*w1yF7G79fA`)p5FPMkB&C~Ua>o4fk6lcZA
zA#s}$;D_-uv;U&|8y{m{C-;}|4n-dYFmQBiZ>!fcy6;|`r<RNV0y~I(;A!elW}hqe
zIoxNO^w`2&Pw)P+LAIQ6i@^cTn2FbVz*MNNL-nT(#lxmhD$od4R)kjSM=pBFSbcW(
z|5IO{5uhQc3J~BH)-+bEKBol)C+;*HhgzVjtQhYGxb*gH^=BumVAQQ8Dsn4KMa!P4
zKX1(FreKW>pAvY~0ET0`yjtq>v)2g8BMWxD=UN+y6P};)W-J=$=NQJuf|KOG4&v@i
zePK4(tcc2YRP8Y;j05rC6KcZ%tj^UJXKx~-OPG)`e-xgC_Yrp#wvEq)ytk}PSHz^m
zdz8BK*03$^>b2>mS9)3MbAe$hCPr22OPbiJ2sjLKTp~YsmBM9YXIW9f+Pz05vyyFV
zz_^eCunV;<4|I5faXk`SHvkNrt1r*~m~>Q15U1P>#Cqy*>|D{NHt3W&HAi}phKD}<
z5KeU8D0ZGTF^5K*3ky4c%fgkB@2kJ4<UOM%VB|J+8??k+t2;(=VdK^m=hd4#`W9&#
z+7VPDFtZ4-(>U^yQhjCiMdKtE9OL@oXmW427urSnW+OCx>u&37j|}w?VYZzSkOT51
z56YZd{eRBpOj0;z%+;jo_CxG#-P5?A;VL@`3E>gLr#Y_r%TrPfzM&o9%0P?oPLR8a
z`m0KuzBb{Y8`qDrk%_K%&Mp2FPZn(}Y<aa12)C8Gu1&0zI6zMutG_-CicJhpJU=Ut
zYGW-Se#HJ}_HFacz3DN0>&I!rYLp?W?rKeIelz%<HZ0*cO@qe+1;B8_nie931495J
z?5nf?K6Z{EpqpmqzR6~7ZU10Tm!b*`&|c>NK3(;<r(yqqfWdAZ=k<6U!mV1O{@3gq
z#`cdJZ@gGW4D&bH*nd;*n1<Wnh)b6MAn1)9+YX{q{oSlsKkGZe69FEsE|V2L2XO(x
zBU&5wmol%ybn5^XwNb8}Cpg7S@FSOa7%(R4Yis6Mej*X_yz25CkxY8xF-vmA77J?W
z#*u}R?Es;`da11)k3uHcCAugym;i`DeM0X3@7X=3ty6m^jVxEZ<2xw^_a&C3>hEX8
zvymoJZEH;`U`K0$06MAtc7|HiyNcn~A}S$#0NA)WMI{8XQT@a0wWb(fmr@rXBXkF3
z!JYbw!#cSc3{Yqv(0Z6KTJQz<r?o8gkF!^sf(+4Y#}GIuEFs=>Koi}Vdc+}n9Ym->
z3OxsGIa2?0Mu6YZ+@q&J;)4u3!$+$6Kc@v&1_0mp!1Re<@<eoH|2!-9?3=nII*y|{
zy(5@3C}vDl)7UOEOy|N>{flP2wp;9)|2rGJ3yKk7ra6{xo~OQkG9|2ph(RKqSw2vJ
zs3;2ce@|xVA^cZXa^}YnZ#Xei|9Ub@kKyA8RDq|49Ddg>)W7L{TMha2jtkKkVv&?$
zmkiV&FEHxgXTK?Y!-4$53!96JP`_}kBv${it?q-;2vZ^f;;$2NRgtOxoRuJ5n=ahS
zGoGVQU{n?2^qJ)!W6e^=uASk!1aF~<deYo~4F_id);z>%BP0&I8uaCp=l<JQ)tav=
z%qdu1Zir$Y%|xJneC~{NuViz)ro`GS0N0mz`A|=pldHSh1IKohV`-;5#Svlz%GFJH
z6tF<ChxH7wnLs^t?&LdUaS`(2TNLo9&{kl5pEh?YWDwW@rHlx1@nFB%*6Qh}q#C@&
zqWdRCRfgl;91Fr{oRVrh0udsB1exccp}-U2Gfzo1zK}Q>{*MvD;^rb#&zd`h04=b;
zD3Y<J=JxZ&^U1U4Ze!g>+6fyHO`%;h-R}6;iSF=*WMwbXL?J*&zH@BfxOx&?FCoxb
z#x5>mabymN5s<Q#S?W1+;+-cJNok6csjdsg43GcaqVFIyJ-lCnR7<HNX_xJpQu~GE
z5(-HyI{YAlnn5&M7V56K3Zgz8=3pa4U6|a45~Pw#VeOWzE&)E<SG@?04biN>q!IZ1
z#o!3P1_<$d%;VH^=l)*g0Yuu|sHtg4R42#_lU2b3Zos;Zi8ilA2(-V4>JBQs(bO$S
zC8w!ne@_6m8hx!<3KusHx?LKnEklou6?jas(M#e|43+1!iwXF<t@ipjGTh2VN29CN
ztTg1`%ttNo7I!unR|5ASlm)VN^}M<Fjmc(gVDamvYLzg+z!-+$5o$n$eud4Fn5Q~y
zplHlt*y^;b&aq)PAkcLx$m8K88YQj?S#Vx%B|gD45f20RN!9b`PA59iP4JBor$K;Y
z0$h*z>L=#}o#j<w(!>J@+%=4K9YORMQw0Bs%fXO|2s0oCu6n_oB_&A~nMGf_EU&$Z
zlV+{q;Fb{5KsDi~C4h~3VZF`2k(Ma7s8Srf=fLe1fPvJD^l7i#UC9O9Y<b16R{u!w
zPz?lsK-=EW^$;0Njgd*zP+ZAPUp35|)$0(mClbrH7td+&gDleHNe+BO8Cq`OfNTXZ
zjuS!xh!AjFy=3kN#(3-yUpv3o&hEWCZ`Hfq5dnfe@!LIuqAp^*U!)d}QrPt_cZ2$=
zIT2?}Tb@>j$vooi5B5srrhe&w5qs&}niQf|_-QGGS{MJImO{8-hFuF6Jot>pPSaH{
zn~P-W$k>GI6o$s%eXY66h<53uSy6JkrGzh0FQ41JY1Vr2tydcso}Ch@t}MiUg27ck
zJ$E`x?L7~E2-jQq7$tlONbpz8t@#vLHwtS}8;NrqFm(X*@ImeXI{TSvaybz|LkV|+
ztqk7$9rd%PrOUX|%(2UbBe%<fnDpwE(=^`Yw2C;k#F7?YiN1Q(G`T>00=36UQI1D7
z98jpAn<kg<MX0?Taqb8QojdB)r)8iVq=X4bnGo)~kU&E}KUL#{Ji!1ujXZ4B0w~Pa
zoR-GZ1jH^`AsZYLF;lOds_|fjOA9>=7AH2IIn?W>$win3@#BFZE#cKeJkS5aY3XtZ
zg`K2CM#X6hD2qtF{<Jg$G#QTMaDU;au0_Bp^@eH25Wyrn3xzMxL|o9v>W!zR@%Zfs
z@GB;fOeCmGqJD9j#^YY8z{9CSU>S+g?x<gyDi_WYQ%gdfGgPpb>P^$-;uOW*X%PtI
z)C$xuPm_xuia!WQY&Y|<{ZhYjT80<rq<C4x{0R02*LR8f)oB`^*~spq$R^O6k1E7b
zZ=NcbM?eaj#RwXP@CI1>PL-=bVj<zEaxaO*ZN^)s%7t?aZZ|w#6e%Q0tlm0JE@EcD
z?K35L6d;VjMs}K9#4bvl5Eu@IRu;ia)Z3=Yg~M}h70g`{=#H{fzj0a?Ku{tM4~S=j
zs+G{e*nLjbcsw!3nE<?8k%A@a?Wd*jcznefFu)p!rb6J}@0h0XWda^8OfarM5RSV~
z^;>g~hFbJ1tzy&P;iEU<dNzx@6ajVPzzH2tohWw__1jv!vYnF0SR~L0$f8gcrqG0u
zo2qx7Xt`JnLb78sQJ}bmV6<s4UMJo)rz5^@D$B290}zf^ivdQAPz_y~Wd9+EE{VoI
z3X3x_IKXiWFfoh7tNTs;>l&eNG*4q!K?~YL!b8!qphT|bz|EAAjj^h$-aU5`T|uyD
zJfcnDAR}^0x6IXhG{dx2JraKT@wSVBCUmchhf4L{Z50Dt(oQ{u<{$wfl(2N1`>;qw
zHl4&uA>+o|bKF01`eb@Vd?Is!qI&AtH1Ry5e&@jAuzm25%pK$*Az+*sizAG3EcLtp
zH8ev+EpxqsO-}G-4{U(?z5mt>p)0JTm>{1)u0&Mo*zp34Hr4N+nVKPdfM=zPET2#S
z9v~|9zJ_MVJ%q1?03gP==sP3^TtPS#4Gl3!6>u0HL=vQEW^=n)>ivy^wxVK^2)GU?
zR3E3K0T-qEz$sB=z$U=P6R^OJag>7%?*~swHDy$KIX*oiG=%W~f%?#Cp*%bc%f+ZG
zLJ1!FfRz4V?ngOukB`UqwTX^nPc+-GqZ@nOYgcjPf_g+-ab1^>!hPzHy_FD}Qxeyk
zV7?(^d~g!juc{AgjmwzO?zozq^^!ojKoG$AzJ&`z#CYm|=ruQ1=rJUVYZw$9CKh;K
zNkuNj>h;whZb_!g_1+V6*{1Ar>zHT{w}gnGV?u4mxKhVDR8vh8=g1drzyO~CU6A`n
z+ma$Ai%!VBRvGB_ixr`oaCVhukQF%0O=Bx?)JNtvbr)Zk8){s;#Hb#urUQv|5y+K!
zT^@G^?E~6Ul7dS&a7whO1T?VtU!XoZCoY2~Hdu$xFs?VMMdgZ~4b@SAHb)K`+)99;
z5;sK5Dj`8}HT<!;mkDWL+f{IgY4jV%Fe$6W-@Wc3&S@-6`$xsjStd=0Xe|K;-))eB
zLK{T*`_ac7jk5_6&i{e?;AAtw{QBd1u}$u+*z*aLO&o88z}V!|dqUCgQ4n74avzN*
z;&2Zq8ln2cTxYXktL6heUXHqPz>Is<=;IGwe`C9q-RkZ-sr{5lM4P1BkrB19&9*p#
zi1><q3$n^j&S@{_#A?~77&96py|!Ad4Qrqxi!qPgpj*kznC>3b!6YY*W`ITj(>Iyu
zq7*O*A`hJ12p-{6b+h6LQ|!rLA}<Gki5g&794Pu>U11#vW<=Ld$lW4*sOT}9*;}nW
z6m}hkGcw6*>yHSMsfWK<<d4|0<9hXvwO(l&n8dnhNg-DH7#y&V1FSnx4t#n}+XcxI
z9LJct{o;`A+)^B>?pWGW>lYB}6TKC07x)|1K^{Ic=deuHHO3||S!b}=7L*19i*+mk
zG$cX*zB1FSRDZHv%@}qGE*{-VL>NT9MX>*;bBk18dpeWRY_$r4r1mkvVV4LkFxpa_
zhg;E;5+A@KwlGd$;~WW1q&|CEwTq~_B!YL~igQDJrmD})om$U%4sZeJ1N^Kwc%uQM
z_-7hZQ7IuYjAA8iO-sC{!<Nh7hGGbBk0m{8izR~A%8l?kiI?FV<2+0Kxn7!LHWmyQ
z#YD{~Do?Uxhx$gx_t|J=dWUflB&#ee%alOKiIWk5f{W+#+g)Xlo(Xn9H~<b%r8=ql
z!rTwC%0~KEu{iVBG4Ite-q5(qab)zEtD<6)p4K|}m{6>o*C89)gY|XQ7f&T#1uyPc
z(x5WHeF!#gk^0gpAu0)DjYk5A*TBm&hE9EXOXSK%q{((nxUgcye9a|<5C=H&0QDEu
zBG`Dug*X;jX{SeR|5jf1==Ib@&=-Xt;YBNSv84o#m8!4Im2%Wnh?Q!(1!IG^hYqUi
zNAg<HT3SE6@iwY{TmOuu;Ok)EtXtwT<S{_d1oSv0zoY)=$rQ6>_-4TgCZ0W#SlrU8
zzdV_xvvxU!qtK3l$CZFd{%Y<6(}+#NGeB%og$)kGhng0dIGLX%Fa%hWrx+wS>aV8~
znMB(Rn>$eiG_}lUOm?>oSrKI5AcI|I{o%!eHI6G&r%2I=7V2;GoqBA^muCs-U6WN4
zyCR3YrdIn!s^gZ+Quo~iEf3CpMRH6ir?1Yv^!UpqwvSiW)Wfz>@ac0#qwj~3W&jX1
z5FrATC#EgxZyOhEg<c6N@^nPl)zwzrgU-;9vtuGyBDe||3>`5E>lMNvA*IUEYoahw
z|Lc?-%TQ_((ih_v#vFIG>hGH8*t#z4?H!hTb&pKk#v_a{PU5%^YFU7Oe8|rbc~|5!
zxJA!pL81O5z#90GugwiPFry0YBgdZxF#_I84vQ@^=sfK#ZzGIxvznndHoD8p(5>3G
z4*&}2Z^T{tzqbXv5hr)t8b~5C5SUJ){{AG00y08PBf|=FL`OIib<{s-CU+vD(=mw7
z>ttkP7BsVNhjKuzb|I*T9dLD3h*2D}7Dxuri{l181n%{Zn#t8LpP+*2*_umhCkGDn
ziv!}~&k=BFZ;9xlnv&A&d4*tN^%H1OBI%?!fWUX8m#BZz-ES5c3kOz3R(JKQA?R$U
zNzjF>-EOk1S2&?TOAiSPvK16BuBZOb+z+rK>fpE)rVw_NgM^g;Kg!EiD0DE=s9gwV
znMWQn`&|9=#^P(RPpehorM6N$D?&{2@PPolT!20QvR!%-j2ZgfydYLXi31~BeSPj1
zwFJSfh{$>qB5pW#$k68Rw4by}<XL$~Q(F8f>!yMl?%i3@C|VTCenS$p-Z!Ldavs}m
z6vkTcB<duhfGCz2R=COdzq;e=c)V%C^MXB2v5LcyuE+i?Gxe`?+YhTtTs~ZNmAG!k
z4Xy3u>fh#0C_XHjrxN9HhUc@=L;v*ebB|(iPTHHcEr{Yy+F3%Z#i^aFB$)`fdWdYw
zCC%dEc+}1;L|lNkGqh{!KeoGAi1y1;f#>wY5GQJ-`p>!RXqQ*rJ;#KRb_Od;$x)fo
zn$JM^jgeA@|K89cQc$3tG%twq1|ZW}=Qu-4NY;YWp-vJ1*JCnu3w{tMz_>Y~i5X&&
zC(kPib*poJ0>(Az9>s%eS2rxwCx>>$4K^A-r)h@wbnN&EL-FI=D+gy~cvIm2#6UsD
zkgBI_uN*uv5V%VsN^zi;5wZ8?#WU{|%Ra18_gIDi0k1<ii=1+i|11e{;bdYfRu&QX
zJY0np>S<LQVQ*tC6+1}STHCJT7iPWHE|^|~nj)LS>X!J@D<W+YYgb}_a^Dew2N5Uk
zsh>VSvJw_=CD0M;nezJ3Sm)hVwmqtA^!-JIF`o+=0&l3EF)!kjH6DMXeRy@K^j6mU
zq1dz<eZnvTfLXJWu!ex*Eew9uGv`kdUVw8I&@E~i!fgUP4%D;e#T?^=@d9v<8OFRs
zvjP{(wpPzR(Q<3NfQtcaq#YyJIJgMZbLNjPLc{ndLkN=wY(16{W*qZZ(a9)ZLWawI
zZioBow-MzKn7<&w#(};Eln0BelwgVKx$|OdILbVFIc6!2jZZZ|fk^Wl!iqTRC+6kA
z9AzH8Oeh6oBMv9L%8x=j$2K5&;)MdY#mNWG^PV>^Aw5Thj9w;{7Oi&0KVo|+!TI{A
zNHMaAu`zb>*GWvZSUrC$MOH?Y>x%R^m$(i+gu)(XOr`osy#_{&8@)_urGpT4sYvMa
zYIk)|ptUFtETb9`Qy-WOg3#e!+2>ls=v=*Ee)qJ!_sR;M;T1U!yI{OAOGB4usTa;C
zlo3=~2~HM7pjvX)YH5OxGnlJsFxUzWgtvDzV-ETS^u`5Pt{2UVJA4t#Rp%m}YAP$A
zDvWl!5aFwiz)CN%?k6}jr?Q`<D8wT5;`vscd+pSVBzCKWY$ZbgmIF4TWT_(?1BLOD
z`6rSgu0Tb)OQX{g;dw!<1{3pDpR`aoH;azp=H%#7FPWec(76$`_m139+_oY|Q#4Et
z7I+gpLiHXX!T<&a9HJi-IMe&7`NOBUdKWVSYDNi4yl)(C0p7Rp{jFX)FJ7o>Cw^0P
z{MKRrMEZ`CDF;w7nmFu6Ga_2OZ2k$Sz6Evn!Tu%44e=w-Y8J;!FCQ(lwT0qXI$XP+
z!nVkK&8ms~Gz4@9W&qZuz{v2Y^?^Ftn`<xdPY1dL3TDJ5xP!z-BFZ(jBIA9<yqE~A
z{nnhU@lsI^+i6Gd+kgN=8K6xNhZuGd1nXxu&y^5co@~_R%6U&rAbb_#*w(hy&u()5
zI-XQU_+x5BE}?-~BNmOQKxJ5BU_&g9xa8h=<-9ks#s1#K)$T#hm~{{h0XSC_h?8>k
z2kKSx;>m4eN2_c>){)bSR%brop(qgKC%8;9{@k%Mu9%E=fCL4B11Dwzq$*Rdo)3>v
zW4MgH<cek(Er(cYT;<#i9?UJ+{Q3A8Ib%6GOs$~#3k=$d)E23F5~|l|5^J-5I@Tz2
zTS&E0>xrd<FF5S#u`aVj-S*n~TaVEO*OPK&tQ*B(5>&NobT^?rb_2JhPadJk153S5
zQ{tPo&UH5_RnGoVp&+^O(uFT26k-B_Q@=1pmvsqx`;58_#f#p=kHH0jtRdjy>*pmX
z&Ss5+PF-3Z(8rQSvQQ$9EgQ2ZZ~`Gg01Neod9hjAG`q7bbGDX04RQ(oOBYg0d_t%<
z9($o7Lt8GEskn5a0=IocM**T9#)bODc`<g{tl~(sF;!O1IV_*?+MW~<K1sl~Z?Yxh
z{fxNYP`2Kj%RRPrw%Az`(J9P4BJ~3QBM@>vZqnYQ&#jFO2yd<KenBb-)86lr+sEz<
zrWkoM&JEEqs$V`{?!nPPyIe{R2nhk7;yEDffo7mILqGQ`^Zvxno4T=2m4na9B{&)Z
zXTf%24M0S!lSPOVt;Y2Oe2-cLx95CSZ$43ixw37{W03WjL*hqE&iPdR+KHB15#lA5
zVQ9uuf@czc8VK`SP9DRTxMd6i9zli0F^ZMZTc;rMORNZp9gYnFKE1_P`LFAPv!b-B
z|JqT-Q#Q#hSq!BIpr+v1!Ym78F7-CO6V~yr6D1dHICz{e^-E%FcsNk{4NZ#H)e-+{
zX{pGB+Z*`lkiAd=UoAupo#9Fk=mXUw-OE6bBhhxzG2#&FH}wv#$`DyZz-<QN!FH-o
z4o761WJKM7VGn%`@$wGcuHHT`5aVFXvEw?{btBGWsn-P^y;nYjr1Obi)s-6zubeR+
z9f^I7X&%mY)H^iORI#@Rvm+B}EV#CN6ONAwiA(sg9&coJVYu+=1UgwvzC0od&5w+5
z*NBqptz9it@PW8x2Xu>-MMBs`_1kOpt!1&JiiAmF^YZ~`Ns$Td3sa0bfI~R2&_WUF
z?49%4AC@rOmHGkGf4m7eLFEJn02H{+$^vz%=(fwGgLZroIFQF>ot1Isaz7A~XMUY;
zuDTenDn=la8w$}^0VKa0Vd}>vqu#9v_mKiTzE)2s=a{>a$U&%uICvPxrDcKcod`Me
zS1^w{!&=XM-En?SbO13F4HzU`&>?$!@B9deGS=6T!y7u@?)4EAkNTNfmXAz<g8?rv
z&{V%OFFrp;O%xryi>BsSdiq*kHm0d}9a%y~PY<o-W<aP*6lB<-so$Nyv{}hWhYL{5
zCti<6v*C6;P`{`5->5Zf17<sn7$Xj1s4s8^q^&?KK$m9RL$*T%@ZZ-YWtEksAJwR$
zK?R>%9fHPZ<HP_HIAXj2TxyX7>V5jk9#t6CL8Cz9X$QD)2dml8FFS?4xE$B@iQHjx
z{`;2a=j#2McN}FOjb5eg9%;NP=}(1nm^6A#&$@Bw#*rTrKh<`8@%`}ueFW+{Br+EM
zB5ZfHd$^yh=t<QSAcmoN27PP62;mL4R3B_)s-#Y~TO1)82oy3aUT4an0Rrf&07)}k
zRH{BSzkQJ@o)S@52o35d9Ny{==G)CF*VvEBxB8?}xxRO}=s%Kp0nJ6#8Cz5=+Z35B
z5eO~zIdF^*&u`OD00fMX*=dX)StO~1CYe7#TWbkGW3J3%5cW9VUHK8*sASXAI<m^C
zZD*>h()EaFDwsG6sSSZy)gP`+i|m!kBY`m}&lZyk;;Efni3A~uL2ju(T0244GL6~j
z5aR(kDd8P54GRv{M^4UFA9^^vV6br9Rr*Lz)kjYj(IdwCC_W*=Vr)>j=s$L%Ew1ho
zSN1><0Aooqtcz^*@lB6l6ohgFqY%Ub2Dlpj8b!DM34I5T&JiT}B3AYgQR_D@o}@2?
zBrGW%KzqT_?Ftw1$$9NTQPz)4)23&aqY*6a71X~S5uc>U4hSocn2d3V@i+P@&7h7B
zm9>J#)>c3?99(B0X~M2Kf;IYMO$JZMMpRk}K!^U4P1as4q*BbuQPlaEq64S`!m2)f
zyxglWn<h6xo*27*EF<9sB#_EyHtRcO>$=$w9HiJ&aF9BD2+omaKspiCrxdz3P0QF<
zf1+8j37z09)CCP!SC)#Z9DA)CxxG1j&`1T01ra3ww0SsC`6k<T-v-?eLF-fEjI$`v
zIY8^H&(3cJ#CDsE(uRYqdA{S?Hcr_~@a$MU2DbX#mMWNhQjS%S!j5V>CMgRBP5s&U
z`C%@pkVV>Fg$R(#v_w~{;~yeS!_M{3w{&_>?)2E{4JZ^?sN;aAC<)M+sn2Uh-mk8N
z#+kbnF)P<FfFt}t0`cThw$vBq&xKE2M#1>S`Ez)~@yVC;3mo^Ct8Z40o_nv^nTy(O
z2*K=NTa)5N|GYQMUNmzq{*eS*IeT9H(z549ug?7F)jezU>YY7$_0Ji-2Ir1m!@G@M
zqw_|u@%iVEs<19td$%uKdw1@>_U_(e?cJNX;v#5R@uN}}$#4~tVD6z8;b&IdT3uNo
Q$_Ed<+W?W>mGI2}5BQf4WdHyG

diff --git a/assets/metadata.wasm b/assets/metadata.wasm
index 22bdd407dc7e9b25ef0b19059f540d267610554e..507581faaa033925073d9b08413c6ccc2a199cdf 100644
GIT binary patch
delta 39194
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

delta 38568
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
N)3Bg8_h)?A{{yNjZ)^Yn

diff --git a/assets/radiswap.wasm b/assets/radiswap.wasm
index 67b0c1da626f8e369f3537fda437f7ca2208634c..3cb9342772d2d93c9d4cec8ab92170144a72fc7c 100644
GIT binary patch
delta 53935
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
O^Hy?SJo9bj^#21VzK_`e

delta 53495
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
N&tL0&<Lk-t{|D^(axnk^

diff --git a/radix-engine-interface/src/blueprints/package/substates.rs b/radix-engine-interface/src/blueprints/package/substates.rs
index 206985fc522..cca211f6494 100644
--- a/radix-engine-interface/src/blueprints/package/substates.rs
+++ b/radix-engine-interface/src/blueprints/package/substates.rs
@@ -18,17 +18,6 @@ pub const ROLE_ASSIGNMENT_CODE_ID: u64 = 12u64;
 pub const POOL_CODE_ID: u64 = 13u64;
 pub const TRANSACTION_TRACKER_CODE_ID: u64 = 14u64;
 
-pub const PACKAGE_FIELDS_PARTITION_OFFSET: PartitionOffset = PartitionOffset(0u8);
-pub const PACKAGE_BLUEPRINTS_PARTITION_OFFSET: PartitionOffset = PartitionOffset(1u8);
-pub const PACKAGE_BLUEPRINT_DEPENDENCIES_PARTITION_OFFSET: PartitionOffset = PartitionOffset(2u8);
-pub const PACKAGE_SCHEMAS_PARTITION_OFFSET: PartitionOffset = PartitionOffset(3u8);
-pub const PACKAGE_ROYALTY_PARTITION_OFFSET: PartitionOffset = PartitionOffset(4u8);
-pub const PACKAGE_AUTH_TEMPLATE_PARTITION_OFFSET: PartitionOffset = PartitionOffset(5u8);
-
-pub const PACKAGE_VM_TYPE_PARTITION_OFFSET: PartitionOffset = PartitionOffset(6u8);
-pub const PACKAGE_ORIGINAL_CODE_PARTITION_OFFSET: PartitionOffset = PartitionOffset(7u8);
-pub const PACKAGE_INSTRUMENTED_CODE_PARTITION_OFFSET: PartitionOffset = PartitionOffset(8u8);
-
 define_wrapped_hash!(
     /// Represents a particular instance of code under a package
     CodeHash
diff --git a/radix-engine-tests/tests/kernel_open_substate.rs b/radix-engine-tests/tests/kernel_open_substate.rs
index 83b6304fa85..e62a2e642d4 100644
--- a/radix-engine-tests/tests/kernel_open_substate.rs
+++ b/radix-engine-tests/tests/kernel_open_substate.rs
@@ -13,9 +13,7 @@ use radix_engine::types::*;
 use radix_engine::vm::wasm::DefaultWasmEngine;
 use radix_engine::vm::{DefaultNativeVm, ScryptoVm, Vm};
 use radix_engine_interface::api::LockFlags;
-use radix_engine_queries::typed_substate_layout::{
-    BlueprintVersionKey, PACKAGE_AUTH_TEMPLATE_PARTITION_OFFSET,
-};
+use radix_engine_queries::typed_substate_layout::{BlueprintVersionKey, PackagePartition};
 use radix_engine_store_interface::db_key_mapper::SpreadPrefixKeyMapper;
 use radix_engine_stores::memory_db::InMemorySubstateDatabase;
 use transaction::prelude::*;
@@ -72,9 +70,7 @@ pub fn test_open_substate_of_invisible_package_address() {
     // Lock package substate
     let result = kernel.kernel_open_substate(
         PACKAGE_PACKAGE.as_node_id(),
-        MAIN_BASE_PARTITION
-            .at_offset(PACKAGE_AUTH_TEMPLATE_PARTITION_OFFSET)
-            .unwrap(),
+        PackagePartition::BlueprintVersionAuthConfigKeyValue.as_main_partition(),
         &SubstateKey::Map(scrypto_encode(&BlueprintVersionKey::new_default("Test")).unwrap()),
         LockFlags::read_only(),
         SystemLockData::default(),
diff --git a/radix-engine/src/blueprints/macros.rs b/radix-engine/src/blueprints/macros.rs
index 3246df698f4..9b5447ce7b7 100644
--- a/radix-engine/src/blueprints/macros.rs
+++ b/radix-engine/src/blueprints/macros.rs
@@ -5,7 +5,7 @@ use crate::types::*;
 // TODO(David) - Move this, features and content stuff under a `models` module?
 // TODO(David) - Create an internal_prelude in `blueprints`
 // and an internal_prelude and prelud in engine
-pub trait FeatureSetResolver {
+pub trait FeatureSetResolver: Debug {
     fn feature_names_str(&self) -> Vec<&'static str>;
 
     fn feature_names_str_set(&self) -> BTreeSet<&'static str> {
@@ -28,6 +28,7 @@ pub trait FeatureSetResolver {
 }
 
 /// For feature checks against a non-inner object
+#[derive(Debug)]
 pub enum FeatureChecks<TOwn: FeatureSetResolver> {
     None,
     RequireAllSubstates,
@@ -205,7 +206,21 @@ pub trait SortedIndexEntryContent<ActualContent: From<Self>>: Sized {
 /// See the below structure for detail on how it should look - or check
 /// out [../package/substates.rs](the package substates definition).
 ///
-/// Each type token-tree should look something like the following.
+/// For each field, the following types will be created:
+/// * `<BlueprintIdent><FieldIdent>FieldContent` - a transparent new type for the full content
+/// * `<BlueprintIdent><FieldIdent>FieldSubstate` - a type for the full system-wrapped substate
+///
+/// For each collection value, the following types will be created:
+/// * `<BlueprintIdent><CollectionIdent>EntryContent` - a transparent new type for the full content
+/// * `<BlueprintIdent><CollectionIdent>EntrySubstate` - a type for the full system-wrapped substate
+///
+/// For each collection key, the following types will be created:
+/// * `<BlueprintIdent><CollectionIdent>KeyContent` - a transparent new type for the full key content
+/// * `<BlueprintIdent><CollectionIdent>Key` - a type for the full key (eg includes the u16 for a sorted index key)
+///
+/// The content of each of the above can take a number of forms.
+/// This is configured via specifying the type as one of the following.
+/// By default, choose StaticSingleVersioned for fields and collection values.
 /// ```
 ///     {
 ///         kind: StaticSingleVersioned,
@@ -226,28 +241,22 @@ pub trait SortedIndexEntryContent<ActualContent: From<Self>>: Sized {
 ///     }
 /// ```
 ///
-/// By default, choose  `StaticSingleVersioned`, which will create a
-/// forward-compatible enum wrapper with a single version.
+/// Choosing  `StaticSingleVersioned`, which will create a
+/// forward-compatible enum wrapper with a single version for the content.
 /// For Fields, it will assume the existence of a type called
 /// `<BlueprintIdent><FieldIdent>V1` and will generate the following types:
 /// * `<BlueprintIdent><FieldIdent>` - a type alias for the latest version (V1).
-/// * `Versioned<BlueprintIdent><FieldIdent>` - the enum wrapper with a single version.
-/// * `<BlueprintIdent><FieldIdent>FieldContent` - a transparent new type for the full content (wrapping the versioned enum)
-/// * `<BlueprintIdent><FieldIdent>FieldSubstate` - a type for the full system-wrapped substate
+/// * `Versioned<BlueprintIdent><FieldIdent>` - the enum wrapper with a single version. This will be the content of `<BlueprintIdent><FieldIdent>FieldContent`.
 ///
 /// For collection values, it will assume the existence of `<BlueprintIdent><CollectionIdent>V1`
 /// and generate the following types:
 /// * `<BlueprintIdent><CollectionIdent>` - a type alias for the latest version (V1).
-/// * `Versioned<BlueprintIdent><CollectionIdent>` - the enum wrapper with a single version.
-/// * `<BlueprintIdent><CollectionIdent>EntryContent` - a transparent new type for the full content (wrapping the versioned enum)
-/// * `<BlueprintIdent><CollectionIdent>EntrySubstate` - a type for the full system-wrapped substate
+/// * `Versioned<BlueprintIdent><CollectionIdent>` - the enum wrapper with a single version. This will be the content of `<BlueprintIdent><CollectionIdent>EntryContent`.
 ///
 /// For collection keys, it will assume the existence of `<BlueprintIdent><CollectionIdent>KeyInnerV1`
 /// and generate the following types:
 /// * `<BlueprintIdent><CollectionIdent>KeyInner` - a type alias for the latest version (V1)
-/// * `Versioned<BlueprintIdent><CollectionIdent>KeyInner` - the enum wrapper with a single version.
-/// * `<BlueprintIdent><CollectionIdent>KeyContent` - a transparent new type for the full key content (wrapping the versioned enum)
-/// * `<BlueprintIdent><CollectionIdent>Key` - a type for the full key (eg includes the u16 for a sorted index key)
+/// * `Versioned<BlueprintIdent><CollectionIdent>KeyInner` - the enum wrapper with a single version. This will be the content of `<BlueprintIdent><CollectionIdent>KeyContent`.
 #[allow(unused)]
 macro_rules! declare_native_blueprint_state {
     (
@@ -495,7 +504,7 @@ macro_rules! declare_native_blueprint_state {
                     fn feature_name(&self) -> &'static str {
                         match *self {
                             $(
-                                Self::$feature_ident => stringify!(Self::$feature_property_name),
+                                Self::$feature_ident => stringify!($feature_property_name),
                             )*
                         }
                     }
diff --git a/radix-engine/src/blueprints/package/package.rs b/radix-engine/src/blueprints/package/package.rs
index d479145c2f6..25f2b06d660 100644
--- a/radix-engine/src/blueprints/package/package.rs
+++ b/radix-engine/src/blueprints/package/package.rs
@@ -1045,9 +1045,7 @@ impl PackageRoyaltyNativeBlueprint {
 
         let handle = api.kernel_open_substate_with_default(
             receiver,
-            MAIN_BASE_PARTITION
-                .at_offset(PACKAGE_ROYALTY_PARTITION_OFFSET)
-                .unwrap(),
+            PackagePartition::BlueprintVersionRoyaltyConfigKeyValue.as_main_partition(),
             &SubstateKey::Map(scrypto_encode(&bp_version_key).unwrap()),
             LockFlags::read_only(),
             Some(|| {
@@ -1057,13 +1055,13 @@ impl PackageRoyaltyNativeBlueprint {
             SystemLockData::default(),
         )?;
 
-        let substate: KeyValueEntrySubstate<PackageRoyaltyConfig> =
+        let substate: PackageBlueprintVersionRoyaltyConfigEntrySubstate =
             api.kernel_read_substate(handle)?.as_typed().unwrap();
         api.kernel_close_substate(handle)?;
 
         let royalty_charge = substate
             .value
-            .and_then(|royalty_config| match royalty_config {
+            .and_then(|royalty_config| match royalty_config.0.into_latest() {
                 PackageRoyaltyConfig::Enabled(royalty_amounts) => {
                     royalty_amounts.get(ident).cloned()
                 }
@@ -1074,7 +1072,7 @@ impl PackageRoyaltyNativeBlueprint {
         if royalty_charge.is_non_zero() {
             let handle = api.kernel_open_substate(
                 receiver,
-                MAIN_BASE_PARTITION,
+                PackagePartition::Field.as_main_partition(),
                 &PackageField::RoyaltyAccumulator.into(),
                 LockFlags::MUTABLE,
                 SystemLockData::default(),
@@ -1189,9 +1187,7 @@ impl PackageAuthNativeBlueprint {
 
         let handle = api.kernel_open_substate_with_default(
             receiver,
-            MAIN_BASE_PARTITION
-                .at_offset(PACKAGE_AUTH_TEMPLATE_PARTITION_OFFSET)
-                .unwrap(),
+            PackagePartition::BlueprintVersionAuthConfigKeyValue.as_main_partition(),
             &SubstateKey::Map(scrypto_encode(&bp_version_key).unwrap()),
             LockFlags::read_only(),
             Some(|| {
@@ -1201,12 +1197,12 @@ impl PackageAuthNativeBlueprint {
             SystemLockData::default(),
         )?;
 
-        let auth_template: KeyValueEntrySubstate<AuthConfig> =
+        let auth_template: PackageBlueprintVersionAuthConfigEntrySubstate =
             api.kernel_read_substate(handle)?.as_typed().unwrap();
         api.kernel_close_substate(handle)?;
 
         let template = match auth_template.value {
-            Some(template) => template,
+            Some(template) => template.0.into_latest(),
             None => {
                 return Err(RuntimeError::SystemError(
                     SystemError::AuthTemplateDoesNotExist(package_bp_version_id),
diff --git a/radix-engine/src/system/system.rs b/radix-engine/src/system/system.rs
index bbb5cd25a43..8a681bcdb33 100644
--- a/radix-engine/src/system/system.rs
+++ b/radix-engine/src/system/system.rs
@@ -1,6 +1,9 @@
 use super::id_allocation::IDAllocation;
 use super::payload_validation::*;
 use super::system_modules::costing::CostingEntry;
+use crate::blueprints::package::{
+    PackageBlueprintVersionDefinitionEntrySubstate, PackagePartition, PackageSchemaEntrySubstate,
+};
 use crate::errors::{
     ApplicationError, CannotGlobalizeError, CreateObjectError, InvalidDropAccess,
     InvalidGlobalizeAccess, InvalidModuleType, PayloadValidationAgainstSchemaError, RuntimeError,
@@ -512,9 +515,7 @@ where
 
         let handle = self.api.kernel_open_substate_with_default(
             package_address.as_node_id(),
-            MAIN_BASE_PARTITION
-                .at_offset(PACKAGE_SCHEMAS_PARTITION_OFFSET)
-                .unwrap(),
+            PackagePartition::SchemaKeyValue.as_main_partition(),
             &SubstateKey::Map(scrypto_encode(schema_hash).unwrap()),
             LockFlags::read_only(),
             Some(|| {
@@ -524,11 +525,11 @@ where
             SystemLockData::default(),
         )?;
 
-        let substate: KeyValueEntrySubstate<ScryptoSchema> =
+        let substate: PackageSchemaEntrySubstate =
             self.api.kernel_read_substate(handle)?.as_typed().unwrap();
         self.api.kernel_close_substate(handle)?;
 
-        let schema = substate.value.unwrap();
+        let schema = substate.value.unwrap().0.into_latest();
 
         self.api
             .kernel_get_system_state()
@@ -572,9 +573,7 @@ where
 
         let handle = self.api.kernel_open_substate_with_default(
             package_address.as_node_id(),
-            MAIN_BASE_PARTITION
-                .at_offset(PACKAGE_BLUEPRINTS_PARTITION_OFFSET)
-                .unwrap(),
+            PackagePartition::BlueprintVersionDefinitionKeyValue.as_main_partition(),
             &SubstateKey::Map(scrypto_encode(bp_version_key).unwrap()),
             LockFlags::read_only(),
             Some(|| {
@@ -584,12 +583,12 @@ where
             SystemLockData::default(),
         )?;
 
-        let substate: KeyValueEntrySubstate<BlueprintDefinition> =
+        let substate: PackageBlueprintVersionDefinitionEntrySubstate =
             self.api.kernel_read_substate(handle)?.as_typed().unwrap();
         self.api.kernel_close_substate(handle)?;
 
         let definition = match substate.value {
-            Some(definition) => definition,
+            Some(definition) => definition.0.into_latest(),
             None => {
                 return Err(RuntimeError::SystemError(
                     SystemError::BlueprintDoesNotExist(canonical_bp_id),
diff --git a/radix-engine/src/system/system_callback.rs b/radix-engine/src/system/system_callback.rs
index 7a6cf4c5538..89c453d609d 100644
--- a/radix-engine/src/system/system_callback.rs
+++ b/radix-engine/src/system/system_callback.rs
@@ -3,6 +3,7 @@ use crate::blueprints::account::ACCOUNT_CREATE_VIRTUAL_ED25519_ID;
 use crate::blueprints::account::ACCOUNT_CREATE_VIRTUAL_SECP256K1_ID;
 use crate::blueprints::identity::IDENTITY_CREATE_VIRTUAL_ED25519_ID;
 use crate::blueprints::identity::IDENTITY_CREATE_VIRTUAL_SECP256K1_ID;
+use crate::blueprints::package::PackagePartition;
 use crate::errors::SystemUpstreamError;
 use crate::errors::{RuntimeError, SystemError};
 use crate::kernel::actor::Actor;
@@ -271,9 +272,7 @@ impl<C: SystemCallbackObject> KernelCallbackObject for SystemConfig<C> {
 
             let handle = system.kernel_open_substate_with_default(
                 blueprint_id.package_address.as_node_id(),
-                MAIN_BASE_PARTITION
-                    .at_offset(PACKAGE_BLUEPRINT_DEPENDENCIES_PARTITION_OFFSET)
-                    .unwrap(),
+                PackagePartition::BlueprintVersionDependenciesKeyValue.as_main_partition(),
                 &SubstateKey::Map(scrypto_encode(&key).unwrap()),
                 LockFlags::read_only(),
                 Some(|| {
diff --git a/radix-engine/src/transaction/system_reader.rs b/radix-engine/src/transaction/system_reader.rs
index 0f90bd4d347..4b5be6548fb 100644
--- a/radix-engine/src/transaction/system_reader.rs
+++ b/radix-engine/src/transaction/system_reader.rs
@@ -1,9 +1,7 @@
 use radix_engine_common::data::scrypto::ScryptoDecode;
 use radix_engine_common::prelude::scrypto_encode;
 use radix_engine_interface::api::ObjectModuleId;
-use radix_engine_interface::blueprints::package::{
-    BlueprintDefinition, BlueprintVersionKey, PACKAGE_BLUEPRINTS_PARTITION_OFFSET,
-};
+use radix_engine_interface::blueprints::package::{BlueprintDefinition, BlueprintVersionKey};
 use radix_engine_interface::types::*;
 use radix_engine_interface::*;
 use radix_engine_store_interface::{
@@ -11,9 +9,12 @@ use radix_engine_store_interface::{
     interface::SubstateDatabase,
 };
 use sbor::rust::prelude::*;
+use sbor::HasLatestVersion;
 
+use crate::blueprints::package::{
+    PackageBlueprintVersionDefinitionEntrySubstate, PackagePartition,
+};
 use crate::system::node_modules::type_info::TypeInfoSubstate;
-use crate::system::system::KeyValueEntrySubstate;
 use crate::track::TrackedNode;
 
 pub enum SystemPartitionDescription {
@@ -72,15 +73,14 @@ impl<'a, S: SubstateDatabase> SystemReader<'a, S> {
     ) -> Option<BlueprintDefinition> {
         let bp_version_key = BlueprintVersionKey::new_default(blueprint_id.blueprint_name.clone());
         let definition = self
-            .fetch_substate::<SpreadPrefixKeyMapper, KeyValueEntrySubstate<BlueprintDefinition>>(
+            .fetch_substate::<SpreadPrefixKeyMapper, PackageBlueprintVersionDefinitionEntrySubstate>(
                 blueprint_id.package_address.as_node_id(),
-                MAIN_BASE_PARTITION
-                    .at_offset(PACKAGE_BLUEPRINTS_PARTITION_OFFSET)
-                    .unwrap(),
+                PackagePartition::BlueprintVersionDefinitionKeyValue
+                    .as_main_partition(),
                 &SubstateKey::Map(scrypto_encode(&bp_version_key).unwrap()),
             )?;
 
-        definition.value
+        definition.value.map(|v| v.0.into_latest())
     }
 
     pub fn fetch_substate<M: DatabaseKeyMapper, D: ScryptoDecode>(
diff --git a/radix-engine/src/transaction/transaction_executor.rs b/radix-engine/src/transaction/transaction_executor.rs
index 1a51107b028..0dd343882f1 100644
--- a/radix-engine/src/transaction/transaction_executor.rs
+++ b/radix-engine/src/transaction/transaction_executor.rs
@@ -1,4 +1,7 @@
 use crate::blueprints::consensus_manager::{ConsensusManagerSubstate, ValidatorRewardsSubstate};
+use crate::blueprints::package::{
+    PackageBlueprintVersionDefinitionEntrySubstate, PackagePartition,
+};
 use crate::blueprints::resource::BurnFungibleResourceEvent;
 use crate::blueprints::transaction_processor::TransactionProcessorError;
 use crate::blueprints::transaction_tracker::{TransactionStatus, TransactionTrackerSubstate};
@@ -18,9 +21,7 @@ use crate::transaction::*;
 use crate::types::*;
 use radix_engine_common::constants::*;
 use radix_engine_interface::api::ObjectModuleId;
-use radix_engine_interface::blueprints::package::{
-    BlueprintDefinition, BlueprintVersionKey, PACKAGE_BLUEPRINTS_PARTITION_OFFSET,
-};
+use radix_engine_interface::blueprints::package::BlueprintVersionKey;
 use radix_engine_interface::blueprints::resource::LiquidFungibleResource;
 use radix_engine_interface::blueprints::transaction_processor::InstructionOutput;
 use radix_engine_store_interface::{db_key_mapper::SpreadPrefixKeyMapper, interface::*};
@@ -311,9 +312,8 @@ where
                         let substate = track
                             .read_substate(
                                 RESOURCE_PACKAGE.as_node_id(),
-                                MAIN_BASE_PARTITION
-                                    .at_offset(PACKAGE_BLUEPRINTS_PARTITION_OFFSET)
-                                    .unwrap(),
+                                PackagePartition::BlueprintVersionDefinitionKeyValue
+                                    .as_main_partition(),
                                 &SubstateKey::Map(
                                     scrypto_encode(&BlueprintVersionKey::new_default(
                                         FUNGIBLE_RESOURCE_MANAGER_BLUEPRINT,
@@ -322,11 +322,13 @@ where
                                 ),
                             )
                             .unwrap();
-                        let substate: KeyValueEntrySubstate<BlueprintDefinition> =
+                        let substate: PackageBlueprintVersionDefinitionEntrySubstate =
                             substate.as_typed().unwrap();
                         let type_pointer = substate
                             .value
                             .unwrap()
+                            .0
+                            .into_latest()
                             .interface
                             .get_event_type_pointer("BurnFungibleResourceEvent")
                             .unwrap();
diff --git a/radix-engine/src/vm/vm.rs b/radix-engine/src/vm/vm.rs
index bffff2533ac..31711c7e2bf 100644
--- a/radix-engine/src/vm/vm.rs
+++ b/radix-engine/src/vm/vm.rs
@@ -1,6 +1,6 @@
 use crate::blueprints::package::{
     PackageCodeInstrumentedCodeEntrySubstate, PackageCodeOriginalCodeEntrySubstate,
-    PackageCodeVmTypeEntrySubstate, PackageError, VmType,
+    PackageCodeVmTypeEntrySubstate, PackageError, PackagePartition, VmType,
 };
 use crate::errors::{ApplicationError, RuntimeError};
 use crate::kernel::kernel_api::{KernelInternalApi, KernelNodeApi, KernelSubstateApi};
@@ -54,9 +54,7 @@ impl<'g, W: WasmEngine + 'g, E: NativeVmExtension> SystemCallbackObject for Vm<'
         let vm_type = {
             let handle = api.kernel_open_substate_with_default(
                 address.as_node_id(),
-                MAIN_BASE_PARTITION
-                    .at_offset(PACKAGE_VM_TYPE_PARTITION_OFFSET)
-                    .unwrap(),
+                PackagePartition::CodeVmTypeKeyValue.as_main_partition(),
                 &SubstateKey::Map(scrypto_encode(&export.code_hash).unwrap()),
                 LockFlags::read_only(),
                 Some(|| {
@@ -78,9 +76,7 @@ impl<'g, W: WasmEngine + 'g, E: NativeVmExtension> SystemCallbackObject for Vm<'
                 let original_code = {
                     let handle = api.kernel_open_substate_with_default(
                         address.as_node_id(),
-                        MAIN_BASE_PARTITION
-                            .at_offset(PACKAGE_ORIGINAL_CODE_PARTITION_OFFSET)
-                            .unwrap(),
+                        PackagePartition::CodeOriginalCodeKeyValue.as_main_partition(),
                         &SubstateKey::Map(scrypto_encode(&export.code_hash).unwrap()),
                         LockFlags::read_only(),
                         Some(|| {
@@ -111,9 +107,7 @@ impl<'g, W: WasmEngine + 'g, E: NativeVmExtension> SystemCallbackObject for Vm<'
                 let instrumented_code = {
                     let handle = api.kernel_open_substate_with_default(
                         address.as_node_id(),
-                        MAIN_BASE_PARTITION
-                            .at_offset(PACKAGE_INSTRUMENTED_CODE_PARTITION_OFFSET)
-                            .unwrap(),
+                        PackagePartition::CodeInstrumentedCodeKeyValue.as_main_partition(),
                         &SubstateKey::Map(scrypto_encode(&export.code_hash).unwrap()),
                         LockFlags::read_only(),
                         Some(|| {
diff --git a/sbor-derive-common/src/utils.rs b/sbor-derive-common/src/utils.rs
index a9d58470466..c58781ca1e7 100644
--- a/sbor-derive-common/src/utils.rs
+++ b/sbor-derive-common/src/utils.rs
@@ -187,7 +187,6 @@ pub fn extract_typed_attributes(
                 }
             }
         }
-        return Ok(fields);
     }
 
     Ok(fields)
@@ -827,9 +826,13 @@ mod tests {
         let attr: Attribute = parse_quote! {
             #[sbor(skip, custom_value_kind = "NoCustomValueKind")]
         };
-        let extracted = extract_typed_attributes(&[attr], "sbor").unwrap();
+        let attr2: Attribute = parse_quote! {
+            #[sbor(skip3)]
+        };
+        let extracted = extract_typed_attributes(&[attr, attr2], "sbor").unwrap();
         assert_eq!(extracted.get_bool_value("skip").unwrap(), true);
         assert_eq!(extracted.get_bool_value("skip2").unwrap(), false);
+        assert_eq!(extracted.get_bool_value("skip3").unwrap(), true);
         assert!(matches!(
             extracted.get_bool_value("custom_value_kind"),
             Err(_)
diff --git a/scrypto-unit/src/test_runner.rs b/scrypto-unit/src/test_runner.rs
index f8f19eb9ce8..72b99362615 100644
--- a/scrypto-unit/src/test_runner.rs
+++ b/scrypto-unit/src/test_runner.rs
@@ -30,7 +30,6 @@ use radix_engine_interface::blueprints::package::{
     BlueprintDefinitionInit, PackageDefinition, PackagePublishNativeManifestInput,
     PackagePublishWasmAdvancedManifestInput, TypePointer, PACKAGE_BLUEPRINT,
     PACKAGE_PUBLISH_NATIVE_IDENT, PACKAGE_PUBLISH_WASM_ADVANCED_IDENT,
-    PACKAGE_SCHEMAS_PARTITION_OFFSET,
 };
 use radix_engine_interface::constants::CONSENSUS_MANAGER;
 use radix_engine_interface::math::Decimal;
@@ -613,9 +612,7 @@ impl<E: NativeVmExtension, D: TestDatabase> TestRunner<E, D> {
             .substate_db()
             .list_entries(&SpreadPrefixKeyMapper::to_db_partition_key(
                 package_address.as_node_id(),
-                MAIN_BASE_PARTITION
-                    .at_offset(PACKAGE_SCHEMAS_PARTITION_OFFSET)
-                    .unwrap(),
+                PackagePartition::SchemaKeyValue.as_main_partition(),
             ))
         {
             let hash: SchemaHash =
@@ -641,18 +638,16 @@ impl<E: NativeVmExtension, D: TestDatabase> TestRunner<E, D> {
             .substate_db()
             .list_entries(&SpreadPrefixKeyMapper::to_db_partition_key(
                 package_address.as_node_id(),
-                MAIN_BASE_PARTITION
-                    .at_offset(PACKAGE_BLUEPRINTS_PARTITION_OFFSET)
-                    .unwrap(),
+                PackagePartition::BlueprintVersionDefinitionKeyValue.as_main_partition(),
             ))
         {
             let key: BlueprintVersionKey =
                 scrypto_decode(&SpreadPrefixKeyMapper::map_from_db_sort_key(&entry.0)).unwrap();
-            let value: KeyValueEntrySubstate<BlueprintDefinition> =
+            let value: PackageBlueprintVersionDefinitionEntrySubstate =
                 scrypto_decode(&entry.1).unwrap();
             match value.value {
                 Some(definition) => {
-                    definitions.insert(key, definition);
+                    definitions.insert(key, definition.0.into_latest());
                 }
                 None => {}
             }
@@ -1936,16 +1931,16 @@ impl<E: NativeVmExtension, D: TestDatabase> TestRunner<E, D> {
             TypePointer::Package(type_identifier) => {
                 let schema = self
                     .substate_db()
-                    .get_mapped::<SpreadPrefixKeyMapper, KeyValueEntrySubstate<ScryptoSchema>>(
+                    .get_mapped::<SpreadPrefixKeyMapper, PackageSchemaEntrySubstate>(
                         package_address.as_node_id(),
-                        MAIN_BASE_PARTITION
-                            .at_offset(PACKAGE_SCHEMAS_PARTITION_OFFSET)
-                            .unwrap(),
+                        PackagePartition::SchemaKeyValue.as_main_partition(),
                         &SubstateKey::Map(scrypto_encode(&type_identifier.0).unwrap()),
                     )
                     .unwrap()
                     .value
-                    .unwrap();
+                    .unwrap()
+                    .0
+                    .into_latest();
 
                 (type_identifier.1, schema)
             }
diff --git a/simulator/src/ledger/dumper.rs b/simulator/src/ledger/dumper.rs
index 734eb13f42e..69ffad1a241 100644
--- a/simulator/src/ledger/dumper.rs
+++ b/simulator/src/ledger/dumper.rs
@@ -7,8 +7,8 @@ use radix_engine::system::system::FieldSubstate;
 use radix_engine::types::*;
 use radix_engine_interface::blueprints::package::*;
 use radix_engine_interface::network::NetworkDefinition;
-use radix_engine_queries::query::ResourceAccounter;
 use radix_engine_queries::typed_substate_layout::PackageCodeOriginalCodeEntrySubstate;
+use radix_engine_queries::{query::ResourceAccounter, typed_substate_layout::PackagePartition};
 use radix_engine_store_interface::{
     db_key_mapper::{MappedSubstateDatabase, SpreadPrefixKeyMapper},
     interface::SubstateDatabase,
@@ -34,9 +34,7 @@ pub fn dump_package<T: SubstateDatabase, O: std::io::Write>(
     let (_, substate) = substate_db
         .list_mapped::<SpreadPrefixKeyMapper, PackageCodeOriginalCodeEntrySubstate, MapKey>(
             package_address.as_node_id(),
-            MAIN_BASE_PARTITION
-                .at_offset(PACKAGE_ORIGINAL_CODE_PARTITION_OFFSET)
-                .unwrap(),
+            PackagePartition::CodeOriginalCodeKeyValue.as_main_partition(),
         )
         .next()
         .ok_or(EntityDumpError::PackageNotFound)?;
diff --git a/simulator/src/resim/mod.rs b/simulator/src/resim/mod.rs
index d6eaaa1f494..5266009b4cf 100644
--- a/simulator/src/resim/mod.rs
+++ b/simulator/src/resim/mod.rs
@@ -71,12 +71,11 @@ use radix_engine::vm::{DefaultNativeVm, ScryptoVm, Vm};
 use radix_engine_interface::api::ObjectModuleId;
 use radix_engine_interface::blueprints::package::{
     BlueprintDefinition, BlueprintInterface, BlueprintVersionKey, TypePointer,
-    PACKAGE_SCHEMAS_PARTITION_OFFSET,
 };
 use radix_engine_interface::blueprints::resource::FromPublicKey;
 use radix_engine_interface::crypto::hash;
 use radix_engine_interface::network::NetworkDefinition;
-use radix_engine_queries::typed_substate_layout::PackageSchemaEntrySubstate;
+use radix_engine_queries::typed_substate_layout::{PackagePartition, PackageSchemaEntrySubstate};
 use radix_engine_store_interface::{
     db_key_mapper::{
         MappedCommittableSubstateDatabase, MappedSubstateDatabase, SpreadPrefixKeyMapper,
@@ -389,9 +388,7 @@ pub fn export_schema(
     let schema = substate_db
         .get_mapped::<SpreadPrefixKeyMapper, PackageSchemaEntrySubstate>(
             package_address.as_node_id(),
-            MAIN_BASE_PARTITION
-                .at_offset(PACKAGE_SCHEMAS_PARTITION_OFFSET)
-                .unwrap(),
+            PackagePartition::SchemaKeyValue.as_main_partition(),
             &SubstateKey::Map(scrypto_encode(&schema_hash).unwrap()),
         )
         .ok_or(Error::SchemaNotFound(package_address, schema_hash))?
@@ -478,16 +475,16 @@ pub fn get_event_schema<S: SubstateDatabase>(
     match schema_pointer {
         TypePointer::Package(TypeIdentifier(schema_hash, index)) => {
             let schema = substate_db
-                .get_mapped::<SpreadPrefixKeyMapper, KeyValueEntrySubstate<ScryptoSchema>>(
+                .get_mapped::<SpreadPrefixKeyMapper, PackageSchemaEntrySubstate>(
                     package_address.as_node_id(),
-                    MAIN_BASE_PARTITION
-                        .at_offset(PACKAGE_SCHEMAS_PARTITION_OFFSET)
-                        .unwrap(),
+                    PackagePartition::SchemaKeyValue.as_main_partition(),
                     &SubstateKey::Map(scrypto_encode(&schema_hash).unwrap()),
                 )
                 .unwrap()
                 .value
-                .unwrap();
+                .unwrap()
+                .0
+                .into_latest();
 
             Some((index, schema))
         }

From f0267186c0e1e8550c1c3ccfa05bcd0db713018a Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Tue, 15 Aug 2023 15:14:55 +0100
Subject: [PATCH 16/28] fix: Further tweaks and fixes

---
 radix-engine-tests/assets/cost_flash_loan.csv | 16 +++++++--------
 ...ost_mint_large_size_nfts_from_manifest.csv | 14 ++++++-------
 ...ost_mint_small_size_nfts_from_manifest.csv | 14 ++++++-------
 .../assets/cost_publish_large_package.csv     | 20 +++++++++----------
 radix-engine-tests/assets/cost_radiswap.csv   | 14 ++++++-------
 radix-engine-tests/assets/cost_transfer.csv   | 12 +++++------
 .../cost_transfer_to_virtual_account.csv      | 12 +++++------
 radix-engine/src/blueprints/macros.rs         | 12 +++++------
 radix-engine/src/system/system.rs             |  4 ++++
 9 files changed, 61 insertions(+), 57 deletions(-)

diff --git a/radix-engine-tests/assets/cost_flash_loan.csv b/radix-engine-tests/assets/cost_flash_loan.csv
index 05ff7a49782..882746c808e 100644
--- a/radix-engine-tests/assets/cost_flash_loan.csv
+++ b/radix-engine-tests/assets/cost_flash_loan.csv
@@ -1,9 +1,9 @@
-Total Cost (XRD)                                                           ,     0.11974838,    100.0%
-+ Execution Cost (XRD)                                                     ,     0.11965838,     99.9%
+Total Cost (XRD)                                                           ,     0.11979272,    100.0%
++ Execution Cost (XRD)                                                     ,     0.11970272,     99.9%
 + Tipping Cost (XRD)                                                       ,              0,      0.0%
 + State Expansion Cost (XRD)                                               ,        0.00009,      0.1%
 + Royalty Cost (XRD)                                                       ,              0,      0.0%
-Total Cost Units Consumed                                                  ,       11965838,    100.0%
+Total Cost Units Consumed                                                  ,       11970272,    100.0%
 AllocateNodeId                                                             ,           5304,      0.0%
 BeforeInvoke                                                               ,           9320,      0.1%
 CloseSubstate                                                              ,          85680,      0.7%
@@ -15,18 +15,18 @@ DropNode                                                                   ,
 EmitEvent                                                                  ,           4548,      0.0%
 GenerateRuid                                                               ,            500,      0.0%
 LockFee                                                                    ,            500,      0.0%
-OpenSubstate                                                               ,        3925939,     32.8%
+OpenSubstate                                                               ,        3925976,     32.8%
 OpenSubstate::GlobalAccount                                                ,          13397,      0.1%
 OpenSubstate::GlobalFungibleResourceManager                                ,          15014,      0.1%
 OpenSubstate::GlobalGenericComponent                                       ,           6052,      0.1%
 OpenSubstate::GlobalNonFungibleResourceManager                             ,          31635,      0.3%
-OpenSubstate::GlobalPackage                                                ,        1841986,     15.4%
+OpenSubstate::GlobalPackage                                                ,        1843594,     15.4%
 OpenSubstate::InternalFungibleVault                                        ,          38110,      0.3%
 OpenSubstate::InternalGenericComponent                                     ,         146790,      1.2%
-PrepareWasmCode                                                            ,        1621116,     13.5%
+PrepareWasmCode                                                            ,        1621964,     13.5%
 QueryActor                                                                 ,           9500,      0.1%
 QueryAuthZone                                                              ,           2000,      0.0%
-ReadSubstate                                                               ,        1953498,     16.3%
+ReadSubstate                                                               ,        1955106,     16.3%
 RunNativeCode::AuthZone_pop                                                ,          37132,      0.3%
 RunNativeCode::AuthZone_push                                               ,          50694,      0.4%
 RunNativeCode::Worktop_drain                                               ,          13505,      0.1%
@@ -55,7 +55,7 @@ RunNativeCode::try_deposit_batch_or_abort                                  ,
 RunNativeCode::unlock_amount_FungibleVault                                 ,          51728,      0.4%
 RunNativeCode::withdraw                                                    ,          30320,      0.3%
 RunWasmCode::BasicFlashLoan_repay_loan                                     ,          70268,      0.6%
-RunWasmCode::BasicFlashLoan_take_loan                                      ,         118886,      1.0%
+RunWasmCode::BasicFlashLoan_take_loan                                      ,         119219,      1.0%
 TxBaseCost                                                                 ,          50000,      0.4%
 TxPayloadCost                                                              ,          20680,      0.2%
 TxSignatureVerification                                                    ,           7000,      0.1%
diff --git a/radix-engine-tests/assets/cost_mint_large_size_nfts_from_manifest.csv b/radix-engine-tests/assets/cost_mint_large_size_nfts_from_manifest.csv
index d4ad9fcc2f8..afbe7eaf497 100644
--- a/radix-engine-tests/assets/cost_mint_large_size_nfts_from_manifest.csv
+++ b/radix-engine-tests/assets/cost_mint_large_size_nfts_from_manifest.csv
@@ -1,9 +1,9 @@
-Total Cost (XRD)                                                           ,    11.19575797,    100.0%
-+ Execution Cost (XRD)                                                     ,     0.99634797,      8.9%
+Total Cost (XRD)                                                           ,    11.19579647,    100.0%
++ Execution Cost (XRD)                                                     ,     0.99638647,      8.9%
 + Tipping Cost (XRD)                                                       ,              0,      0.0%
 + State Expansion Cost (XRD)                                               ,       10.19941,     91.1%
 + Royalty Cost (XRD)                                                       ,              0,      0.0%
-Total Cost Units Consumed                                                  ,       99634797,    100.0%
+Total Cost Units Consumed                                                  ,       99638647,    100.0%
 AllocateNodeId                                                             ,           2184,      0.0%
 BeforeInvoke                                                               ,        2040526,      2.0%
 CloseSubstate                                                              ,          48195,      0.0%
@@ -17,19 +17,19 @@ DropNode                                                                   ,
 EmitEvent                                                                  ,          18764,      0.0%
 LockFee                                                                    ,            500,      0.0%
 MoveModule                                                                 ,          20335,      0.0%
-OpenSubstate                                                               ,        3157411,      3.2%
+OpenSubstate                                                               ,        3157477,      3.2%
 OpenSubstate::GlobalAccount                                                ,           5855,      0.0%
 OpenSubstate::GlobalFungibleResourceManager                                ,           1452,      0.0%
 OpenSubstate::GlobalGenericComponent                                       ,           2884,      0.0%
 OpenSubstate::GlobalNonFungibleResourceManager                             ,          14195,      0.0%
-OpenSubstate::GlobalPackage                                                ,         783282,      0.8%
+OpenSubstate::GlobalPackage                                                ,         784656,      0.8%
 OpenSubstate::InternalFungibleVault                                        ,           4803,      0.0%
 OpenSubstate::InternalGenericComponent                                     ,          36522,      0.0%
 OpenSubstate::InternalKeyValueStore                                        ,            877,      0.0%
 OpenSubstate::InternalNonFungibleVault                                     ,         125864,      0.1%
-PrepareWasmCode                                                            ,         627948,      0.6%
+PrepareWasmCode                                                            ,         628984,      0.6%
 QueryActor                                                                 ,           2000,      0.0%
-ReadSubstate                                                               ,         889484,      0.9%
+ReadSubstate                                                               ,         890858,      0.9%
 RunNativeCode::Worktop_drain                                               ,          13505,      0.0%
 RunNativeCode::Worktop_drop                                                ,          15385,      0.0%
 RunNativeCode::Worktop_put                                                 ,          18262,      0.0%
diff --git a/radix-engine-tests/assets/cost_mint_small_size_nfts_from_manifest.csv b/radix-engine-tests/assets/cost_mint_small_size_nfts_from_manifest.csv
index 376edb8a5a2..5deec10119f 100644
--- a/radix-engine-tests/assets/cost_mint_small_size_nfts_from_manifest.csv
+++ b/radix-engine-tests/assets/cost_mint_small_size_nfts_from_manifest.csv
@@ -1,9 +1,9 @@
-Total Cost (XRD)                                                           ,      1.0121173,    100.0%
-+ Execution Cost (XRD)                                                     ,      0.9292473,     91.8%
+Total Cost (XRD)                                                           ,      1.0121558,    100.0%
++ Execution Cost (XRD)                                                     ,      0.9292858,     91.8%
 + Tipping Cost (XRD)                                                       ,              0,      0.0%
 + State Expansion Cost (XRD)                                               ,        0.08287,      8.2%
 + Royalty Cost (XRD)                                                       ,              0,      0.0%
-Total Cost Units Consumed                                                  ,       92924730,    100.0%
+Total Cost Units Consumed                                                  ,       92928580,    100.0%
 AllocateNodeId                                                             ,           2184,      0.0%
 BeforeInvoke                                                               ,          16462,      0.0%
 CloseSubstate                                                              ,          68040,      0.1%
@@ -17,19 +17,19 @@ DropNode                                                                   ,
 EmitEvent                                                                  ,          32372,      0.0%
 LockFee                                                                    ,            500,      0.0%
 MoveModule                                                                 ,          36022,      0.0%
-OpenSubstate                                                               ,        3157411,      3.4%
+OpenSubstate                                                               ,        3157477,      3.4%
 OpenSubstate::GlobalAccount                                                ,           5855,      0.0%
 OpenSubstate::GlobalFungibleResourceManager                                ,           1452,      0.0%
 OpenSubstate::GlobalGenericComponent                                       ,           2884,      0.0%
 OpenSubstate::GlobalNonFungibleResourceManager                             ,          14195,      0.0%
-OpenSubstate::GlobalPackage                                                ,         783282,      0.8%
+OpenSubstate::GlobalPackage                                                ,         784656,      0.8%
 OpenSubstate::InternalFungibleVault                                        ,           4803,      0.0%
 OpenSubstate::InternalGenericComponent                                     ,          39924,      0.0%
 OpenSubstate::InternalKeyValueStore                                        ,            877,      0.0%
 OpenSubstate::InternalNonFungibleVault                                     ,         225278,      0.2%
-PrepareWasmCode                                                            ,         627948,      0.7%
+PrepareWasmCode                                                            ,         628984,      0.7%
 QueryActor                                                                 ,           2000,      0.0%
-ReadSubstate                                                               ,         957902,      1.0%
+ReadSubstate                                                               ,         959276,      1.0%
 RunNativeCode::Worktop_drain                                               ,          13505,      0.0%
 RunNativeCode::Worktop_drop                                                ,          15385,      0.0%
 RunNativeCode::Worktop_put                                                 ,          18262,      0.0%
diff --git a/radix-engine-tests/assets/cost_publish_large_package.csv b/radix-engine-tests/assets/cost_publish_large_package.csv
index 05478c89bb9..033cead832d 100644
--- a/radix-engine-tests/assets/cost_publish_large_package.csv
+++ b/radix-engine-tests/assets/cost_publish_large_package.csv
@@ -1,30 +1,30 @@
-Total Cost (XRD)                                                           ,    21.84127372,    100.0%
-+ Execution Cost (XRD)                                                     ,     0.88498372,      4.1%
+Total Cost (XRD)                                                           ,    21.84140173,    100.0%
++ Execution Cost (XRD)                                                     ,     0.88505173,      4.1%
 + Tipping Cost (XRD)                                                       ,              0,      0.0%
-+ State Expansion Cost (XRD)                                               ,       20.95629,     95.9%
++ State Expansion Cost (XRD)                                               ,       20.95635,     95.9%
 + Royalty Cost (XRD)                                                       ,              0,      0.0%
-Total Cost Units Consumed                                                  ,       88498372,    100.0%
+Total Cost Units Consumed                                                  ,       88505173,    100.0%
 AllocateNodeId                                                             ,           1560,      0.0%
 BeforeInvoke                                                               ,        2096382,      2.4%
 CloseSubstate                                                              ,          12915,      0.0%
 Commit::GlobalGenericComponent                                             ,         100018,      0.1%
-Commit::GlobalPackage                                                      ,        1123861,      1.3%
+Commit::GlobalPackage                                                      ,        1123863,      1.3%
 Commit::InternalFungibleVault                                              ,         400053,      0.5%
-CreateNode                                                                 ,        4198824,      4.7%
+CreateNode                                                                 ,        4198836,      4.7%
 DropNode                                                                   ,          15857,      0.0%
 EmitEvent                                                                  ,           1288,      0.0%
 LockFee                                                                    ,            500,      0.0%
 MoveModule                                                                 ,            664,      0.0%
-OpenSubstate                                                               ,        2355811,      2.7%
+OpenSubstate                                                               ,        2355950,      2.7%
 OpenSubstate::GlobalFungibleResourceManager                                ,           4434,      0.0%
 OpenSubstate::GlobalGenericComponent                                       ,           2884,      0.0%
-OpenSubstate::GlobalPackage                                                ,         739772,      0.8%
+OpenSubstate::GlobalPackage                                                ,         742578,      0.8%
 OpenSubstate::InternalFungibleVault                                        ,           6156,      0.0%
 OpenSubstate::InternalGenericComponent                                     ,          12556,      0.0%
 OpenSubstate::InternalKeyValueStore                                        ,            877,      0.0%
-PrepareWasmCode                                                            ,         627948,      0.7%
+PrepareWasmCode                                                            ,         628984,      0.7%
 QueryActor                                                                 ,           1500,      0.0%
-ReadSubstate                                                               ,         741434,      0.8%
+ReadSubstate                                                               ,         744240,      0.8%
 RunNativeCode::Worktop_drop                                                ,          15385,      0.0%
 RunNativeCode::create                                                      ,          31390,      0.0%
 RunNativeCode::create_empty_vault_FungibleResourceManager                  ,          29769,      0.0%
diff --git a/radix-engine-tests/assets/cost_radiswap.csv b/radix-engine-tests/assets/cost_radiswap.csv
index 36cadb55704..3c18573b7f3 100644
--- a/radix-engine-tests/assets/cost_radiswap.csv
+++ b/radix-engine-tests/assets/cost_radiswap.csv
@@ -1,9 +1,9 @@
-Total Cost (XRD)                                                           ,     0.07988852,    100.0%
-+ Execution Cost (XRD)                                                     ,     0.07773852,     97.3%
+Total Cost (XRD)                                                           ,     0.07990518,    100.0%
++ Execution Cost (XRD)                                                     ,     0.07775518,     97.3%
 + Tipping Cost (XRD)                                                       ,              0,      0.0%
 + State Expansion Cost (XRD)                                               ,        0.00215,      2.7%
 + Royalty Cost (XRD)                                                       ,              0,      0.0%
-Total Cost Units Consumed                                                  ,        7773852,    100.0%
+Total Cost Units Consumed                                                  ,        7775518,    100.0%
 AllocateNodeId                                                             ,           3224,      0.0%
 BeforeInvoke                                                               ,           4226,      0.1%
 CloseSubstate                                                              ,          51765,      0.7%
@@ -14,17 +14,17 @@ CreateNode                                                                 ,
 DropNode                                                                   ,          39446,      0.5%
 EmitEvent                                                                  ,           5416,      0.1%
 LockFee                                                                    ,            500,      0.0%
-OpenSubstate                                                               ,        3712849,     47.8%
+OpenSubstate                                                               ,        3712871,     47.8%
 OpenSubstate::GlobalAccount                                                ,          14165,      0.2%
 OpenSubstate::GlobalFungibleResourceManager                                ,          17747,      0.2%
 OpenSubstate::GlobalGenericComponent                                       ,           2842,      0.0%
-OpenSubstate::GlobalPackage                                                ,         716668,      9.2%
+OpenSubstate::GlobalPackage                                                ,         717370,      9.2%
 OpenSubstate::GlobalTwoResourcePool                                        ,          13912,      0.2%
 OpenSubstate::InternalFungibleVault                                        ,          26432,      0.3%
 OpenSubstate::InternalGenericComponent                                     ,          75364,      1.0%
-PrepareWasmCode                                                            ,         573122,      7.4%
+PrepareWasmCode                                                            ,         573362,      7.4%
 QueryActor                                                                 ,           4000,      0.1%
-ReadSubstate                                                               ,         781984,     10.1%
+ReadSubstate                                                               ,         782686,     10.1%
 RunNativeCode::Worktop_drain                                               ,          13505,      0.2%
 RunNativeCode::Worktop_drop                                                ,          15385,      0.2%
 RunNativeCode::Worktop_put                                                 ,          36524,      0.5%
diff --git a/radix-engine-tests/assets/cost_transfer.csv b/radix-engine-tests/assets/cost_transfer.csv
index c99f3b535e9..03bf48269a4 100644
--- a/radix-engine-tests/assets/cost_transfer.csv
+++ b/radix-engine-tests/assets/cost_transfer.csv
@@ -1,9 +1,9 @@
-Total Cost (XRD)                                                           ,     0.03028743,    100.0%
-+ Execution Cost (XRD)                                                     ,     0.03028743,    100.0%
+Total Cost (XRD)                                                           ,     0.03029209,    100.0%
++ Execution Cost (XRD)                                                     ,     0.03029209,    100.0%
 + Tipping Cost (XRD)                                                       ,              0,      0.0%
 + State Expansion Cost (XRD)                                               ,              0,      0.0%
 + Royalty Cost (XRD)                                                       ,              0,      0.0%
-Total Cost Units Consumed                                                  ,        3028743,    100.0%
+Total Cost Units Consumed                                                  ,        3029209,    100.0%
 AllocateNodeId                                                             ,           1352,      0.0%
 BeforeInvoke                                                               ,           1768,      0.1%
 CloseSubstate                                                              ,          22155,      0.7%
@@ -12,14 +12,14 @@ CreateNode                                                                 ,
 DropNode                                                                   ,          16925,      0.6%
 EmitEvent                                                                  ,           1940,      0.1%
 LockFee                                                                    ,            500,      0.0%
-OpenSubstate                                                               ,        2122724,     70.1%
+OpenSubstate                                                               ,        2122730,     70.1%
 OpenSubstate::GlobalAccount                                                ,          13397,      0.4%
 OpenSubstate::GlobalFungibleResourceManager                                ,           7111,      0.2%
-OpenSubstate::GlobalPackage                                                ,          81258,      2.7%
+OpenSubstate::GlobalPackage                                                ,          81488,      2.7%
 OpenSubstate::InternalFungibleVault                                        ,          11703,      0.4%
 OpenSubstate::InternalGenericComponent                                     ,          29520,      1.0%
 QueryActor                                                                 ,           2500,      0.1%
-ReadSubstate                                                               ,         105820,      3.5%
+ReadSubstate                                                               ,         106050,      3.5%
 RunNativeCode::Worktop_drain                                               ,          13505,      0.4%
 RunNativeCode::Worktop_drop                                                ,          15385,      0.5%
 RunNativeCode::Worktop_put                                                 ,          18262,      0.6%
diff --git a/radix-engine-tests/assets/cost_transfer_to_virtual_account.csv b/radix-engine-tests/assets/cost_transfer_to_virtual_account.csv
index 4b7f213388f..d1844b26a20 100644
--- a/radix-engine-tests/assets/cost_transfer_to_virtual_account.csv
+++ b/radix-engine-tests/assets/cost_transfer_to_virtual_account.csv
@@ -1,9 +1,9 @@
-Total Cost (XRD)                                                           ,     0.06613517,    100.0%
-+ Execution Cost (XRD)                                                     ,     0.05760517,     87.1%
+Total Cost (XRD)                                                           ,      0.0661424,    100.0%
++ Execution Cost (XRD)                                                     ,      0.0576124,     87.1%
 + Tipping Cost (XRD)                                                       ,              0,      0.0%
 + State Expansion Cost (XRD)                                               ,        0.00853,     12.9%
 + Royalty Cost (XRD)                                                       ,              0,      0.0%
-Total Cost Units Consumed                                                  ,        5760517,    100.0%
+Total Cost Units Consumed                                                  ,        5761240,    100.0%
 AllocateNodeId                                                             ,           2600,      0.0%
 BeforeInvoke                                                               ,           3288,      0.1%
 CloseSubstate                                                              ,          30870,      0.5%
@@ -14,17 +14,17 @@ DropNode                                                                   ,
 EmitEvent                                                                  ,           3228,      0.1%
 LockFee                                                                    ,            500,      0.0%
 MoveModule                                                                 ,            747,      0.0%
-OpenSubstate                                                               ,        3244380,     56.3%
+OpenSubstate                                                               ,        3244391,     56.3%
 OpenSubstate::GlobalAccount                                                ,           8310,      0.1%
 OpenSubstate::GlobalFungibleResourceManager                                ,          13572,      0.2%
 OpenSubstate::GlobalNonFungibleResourceManager                             ,           2604,      0.0%
-OpenSubstate::GlobalPackage                                                ,         129096,      2.2%
+OpenSubstate::GlobalPackage                                                ,         129452,      2.2%
 OpenSubstate::GlobalVirtualSecp256k1Account                                ,           6108,      0.1%
 OpenSubstate::InternalAccount                                              ,            692,      0.0%
 OpenSubstate::InternalFungibleVault                                        ,          13958,      0.2%
 OpenSubstate::InternalGenericComponent                                     ,          37112,      0.6%
 QueryActor                                                                 ,           2500,      0.0%
-ReadSubstate                                                               ,         158030,      2.7%
+ReadSubstate                                                               ,         158386,      2.7%
 RunNativeCode::Worktop_drain                                               ,          13505,      0.2%
 RunNativeCode::Worktop_drop                                                ,          15385,      0.3%
 RunNativeCode::Worktop_put                                                 ,          18262,      0.3%
diff --git a/radix-engine/src/blueprints/macros.rs b/radix-engine/src/blueprints/macros.rs
index 9b5447ce7b7..c6a195b0a4d 100644
--- a/radix-engine/src/blueprints/macros.rs
+++ b/radix-engine/src/blueprints/macros.rs
@@ -216,7 +216,7 @@ pub trait SortedIndexEntryContent<ActualContent: From<Self>>: Sized {
 ///
 /// For each collection key, the following types will be created:
 /// * `<BlueprintIdent><CollectionIdent>KeyContent` - a transparent new type for the full key content
-/// * `<BlueprintIdent><CollectionIdent>Key` - a type for the full key (eg includes the u16 for a sorted index key)
+/// * `<BlueprintIdent><CollectionIdent>SubstateKey` - a type for the full key (eg includes the u16 for a sorted index key)
 ///
 /// The content of each of the above can take a number of forms.
 /// This is configured via specifying the type as one of the following.
@@ -370,7 +370,7 @@ macro_rules! declare_native_blueprint_state {
 
                     // TODO(David): Tweak when I work out the right strategy for keys. Probably just want a single new-type.
                     // So probably just don't use generate_content_type but use generate_key_type or something instead?
-                    pub type [<$blueprint_ident $collection_ident Key>] = [<$blueprint_ident $collection_ident KeyContent>];
+                    pub type [<$blueprint_ident $collection_ident SubstateKey>] = [<$blueprint_ident $collection_ident KeyContent>];
 
                     // TODO(David) - Properly handle SortedIndex:
                     // Fix Key types for SortedIndex to have a named u16 part of the key,
@@ -516,7 +516,7 @@ macro_rules! declare_native_blueprint_state {
                 #[derive(Debug, Clone)]
                 pub enum [<$blueprint_ident TypedSubstateKey>] {
                     Fields([<$blueprint_ident Field>]),
-                    $([<$collection_ident $collection_type Entries>]([<$blueprint_ident $collection_ident Key>]),)*
+                    $([<$collection_ident $collection_type Entries>]([<$blueprint_ident $collection_ident SubstateKey>]),)*
                 }
 
                 impl [<$blueprint_ident TypedSubstateKey>] {
@@ -530,7 +530,7 @@ macro_rules! declare_native_blueprint_state {
                             $(
                                 [<$blueprint_ident Partition>]::[<$collection_ident $collection_type>] => {
                                     [<$blueprint_ident TypedSubstateKey>]::[<$collection_ident $collection_type Entries>](
-                                        [<$blueprint_ident $collection_ident Key>]::try_from(substate_key)?,
+                                        [<$blueprint_ident $collection_ident SubstateKey>]::try_from(substate_key)?,
                                     )
                                 }
                             )*
@@ -631,7 +631,7 @@ macro_rules! declare_native_blueprint_state {
                     )*
                     $(
                         pub $collection_property_name: IndexMap<
-                            [<$blueprint_ident $collection_ident Key>],
+                            [<$blueprint_ident $collection_ident SubstateKey>],
                             [<$blueprint_ident $collection_ident EntrySubstate>]
                         >,
                     )*
@@ -653,7 +653,7 @@ macro_rules! declare_native_blueprint_state {
                                     self.$field_property_name.is_some(),
                                 )?;
                                 if let Some(field) = self.$field_property_name {
-                                    let field_content = scrypto_encode(&field.value).unwrap();
+                                    let field_content = scrypto_encode(&field.field_content()).unwrap();
                                     let locked = match &field.mutability {
                                         SubstateMutability::Mutable => true,
                                         SubstateMutability::Immutable => false,
diff --git a/radix-engine/src/system/system.rs b/radix-engine/src/system/system.rs
index 8a681bcdb33..03b48d99acd 100644
--- a/radix-engine/src/system/system.rs
+++ b/radix-engine/src/system/system.rs
@@ -81,6 +81,10 @@ impl<V> FieldSubstate<V> {
             mutability: SubstateMutability::Immutable,
         }
     }
+
+    pub fn field_content(&self) -> &V {
+        &self.value.0
+    }
 }
 
 pub type KeyValueEntrySubstate<V> = DynSubstate<Option<V>>;

From b8141a265e97d203f072b81008c4dd539a70b14b Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Tue, 15 Aug 2023 15:58:29 +0100
Subject: [PATCH 17/28] fix: Various fixes

---
 radix-engine-queries/src/typed_substate_layout.rs |  4 ++--
 radix-engine/src/blueprints/macros.rs             |  4 ++--
 simulator/src/ledger/dumper.rs                    |  1 -
 simulator/src/resim/mod.rs                        | 10 +++++-----
 4 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/radix-engine-queries/src/typed_substate_layout.rs b/radix-engine-queries/src/typed_substate_layout.rs
index 3540870a5ab..cddd8dc462d 100644
--- a/radix-engine-queries/src/typed_substate_layout.rs
+++ b/radix-engine-queries/src/typed_substate_layout.rs
@@ -236,8 +236,8 @@ pub fn to_typed_object_module_substate_key(
     return to_typed_object_substate_key_internal(entity_type, partition_offset, substate_key)
         .map_err(|_| {
             format!(
-                "Could not convert {:?} {:?} key to TypedObjectSubstateKey",
-                entity_type, substate_key
+                "Could not convert {:?} (partition offset {}) {:?} key to TypedObjectSubstateKey",
+                entity_type, partition_offset, substate_key
             )
         });
 }
diff --git a/radix-engine/src/blueprints/macros.rs b/radix-engine/src/blueprints/macros.rs
index c6a195b0a4d..17c20848a39 100644
--- a/radix-engine/src/blueprints/macros.rs
+++ b/radix-engine/src/blueprints/macros.rs
@@ -375,12 +375,12 @@ macro_rules! declare_native_blueprint_state {
                     // TODO(David) - Properly handle SortedIndex:
                     // Fix Key types for SortedIndex to have a named u16 part of the key,
                     // use a different key trait, and use .for_sorted_key in the below.
-                    impl TryFrom<&SubstateKey> for [<$blueprint_ident $collection_ident KeyContent>] {
+                    impl TryFrom<&SubstateKey> for [<$blueprint_ident $collection_ident SubstateKey>] {
                         type Error = ();
 
                         fn try_from(substate_key: &SubstateKey) -> Result<Self, Self::Error> {
                             let key = substate_key.for_map().ok_or(())?;
-                            scrypto_decode(&key).map_err(|_| ())?
+                            scrypto_decode::<Self>(&key).map_err(|_| ())
                         }
                     }
 
diff --git a/simulator/src/ledger/dumper.rs b/simulator/src/ledger/dumper.rs
index 69ffad1a241..0f22c320154 100644
--- a/simulator/src/ledger/dumper.rs
+++ b/simulator/src/ledger/dumper.rs
@@ -5,7 +5,6 @@ use radix_engine::blueprints::resource::*;
 use radix_engine::system::node_modules::type_info::TypeInfoSubstate;
 use radix_engine::system::system::FieldSubstate;
 use radix_engine::types::*;
-use radix_engine_interface::blueprints::package::*;
 use radix_engine_interface::network::NetworkDefinition;
 use radix_engine_queries::typed_substate_layout::PackageCodeOriginalCodeEntrySubstate;
 use radix_engine_queries::{query::ResourceAccounter, typed_substate_layout::PackagePartition};
diff --git a/simulator/src/resim/mod.rs b/simulator/src/resim/mod.rs
index 5266009b4cf..5482052a86c 100644
--- a/simulator/src/resim/mod.rs
+++ b/simulator/src/resim/mod.rs
@@ -58,7 +58,7 @@ use radix_engine::blueprints::consensus_manager::{
 };
 use radix_engine::system::bootstrap::Bootstrapper;
 use radix_engine::system::node_modules::type_info::TypeInfoSubstate;
-use radix_engine::system::system::{FieldSubstate, KeyValueEntrySubstate};
+use radix_engine::system::system::FieldSubstate;
 use radix_engine::transaction::execute_and_commit_transaction;
 use radix_engine::transaction::TransactionOutcome;
 use radix_engine::transaction::TransactionReceipt;
@@ -75,7 +75,7 @@ use radix_engine_interface::blueprints::package::{
 use radix_engine_interface::blueprints::resource::FromPublicKey;
 use radix_engine_interface::crypto::hash;
 use radix_engine_interface::network::NetworkDefinition;
-use radix_engine_queries::typed_substate_layout::{PackagePartition, PackageSchemaEntrySubstate};
+use radix_engine_queries::typed_substate_layout::*;
 use radix_engine_store_interface::{
     db_key_mapper::{
         MappedCommittableSubstateDatabase, MappedSubstateDatabase, SpreadPrefixKeyMapper,
@@ -337,9 +337,9 @@ pub fn export_package_schema(
     Bootstrapper::new(&mut substate_db, vm, false).bootstrap_test_default();
 
     let entries = substate_db
-        .list_mapped::<SpreadPrefixKeyMapper, KeyValueEntrySubstate<BlueprintDefinition>, MapKey>(
+        .list_mapped::<SpreadPrefixKeyMapper, PackageBlueprintVersionDefinitionEntrySubstate, MapKey>(
             package_address.as_node_id(),
-            MAIN_BASE_PARTITION.at_offset(PartitionOffset(1u8)).unwrap(),
+            PackagePartition::BlueprintVersionDefinitionKeyValue.as_main_partition(),
         );
 
     let mut blueprints = BTreeMap::new();
@@ -349,7 +349,7 @@ pub fn export_package_schema(
             _ => panic!("Unexpected"),
         };
 
-        blueprints.insert(bp_version_key, blueprint_definition.value.unwrap());
+        blueprints.insert(bp_version_key, blueprint_definition.value.unwrap().0.into_latest());
     }
 
     Ok(blueprints)

From e081804c4c9b7fcc51a79b67f2bf24f36eea5347 Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Tue, 15 Aug 2023 16:46:12 +0100
Subject: [PATCH 18/28] tweak: Update names of new-types to XPayload not
 XContent

---
 radix-engine/src/blueprints/macros.rs         | 58 +++++++++----------
 .../src/blueprints/package/package.rs         |  2 +-
 simulator/src/resim/mod.rs                    |  5 +-
 3 files changed, 34 insertions(+), 31 deletions(-)

diff --git a/radix-engine/src/blueprints/macros.rs b/radix-engine/src/blueprints/macros.rs
index 17c20848a39..25deb351f1c 100644
--- a/radix-engine/src/blueprints/macros.rs
+++ b/radix-engine/src/blueprints/macros.rs
@@ -161,40 +161,40 @@ impl<TOwn: FeatureSetResolver, TOuter: FeatureSetResolver> InnerObjectFeatureChe
     }
 }
 
-pub trait FieldContent<ActualContent: From<Self>>: Sized {
-    fn into_locked_substate(self) -> FieldSubstate<ActualContent> {
+pub trait FieldContent<FieldPayload: From<Self>>: Sized {
+    fn into_locked_substate(self) -> FieldSubstate<FieldPayload> {
         FieldSubstate::new_locked_field(self.into())
     }
 
-    fn into_mutable_substate(self) -> FieldSubstate<ActualContent> {
+    fn into_mutable_substate(self) -> FieldSubstate<FieldPayload> {
         FieldSubstate::new_field(self.into())
     }
 }
 
-pub trait KeyContent<ActualContent: From<Self>>: Sized {
-    fn into_key(self) -> ActualContent {
+pub trait KeyContent<KeyPayload: From<Self>>: Sized {
+    fn into_key(self) -> KeyPayload {
         self.into()
     }
 }
 
-pub trait KeyValueEntryContent<ActualContent: From<Self>>: Sized {
-    fn into_locked_substate(self) -> KeyValueEntrySubstate<ActualContent> {
+pub trait KeyValueEntryContent<EntryPayload: From<Self>>: Sized {
+    fn into_locked_substate(self) -> KeyValueEntrySubstate<EntryPayload> {
         KeyValueEntrySubstate::entry(self.into())
     }
 
-    fn into_mutable_substate(self) -> KeyValueEntrySubstate<ActualContent> {
+    fn into_mutable_substate(self) -> KeyValueEntrySubstate<EntryPayload> {
         KeyValueEntrySubstate::locked_entry(self.into())
     }
 }
 
-pub trait IndexEntryContent<ActualContent: From<Self>>: Sized {
-    fn into_substate(self) -> ActualContent {
+pub trait IndexEntryContent<EntryPayload: From<Self>>: Sized {
+    fn into_substate(self) -> EntryPayload {
         self.into()
     }
 }
 
-pub trait SortedIndexEntryContent<ActualContent: From<Self>>: Sized {
-    fn into_substate(self) -> ActualContent {
+pub trait SortedIndexEntryContent<EntryPayload: From<Self>>: Sized {
+    fn into_substate(self) -> EntryPayload {
         self.into()
     }
 }
@@ -207,15 +207,15 @@ pub trait SortedIndexEntryContent<ActualContent: From<Self>>: Sized {
 /// out [../package/substates.rs](the package substates definition).
 ///
 /// For each field, the following types will be created:
-/// * `<BlueprintIdent><FieldIdent>FieldContent` - a transparent new type for the full content
+/// * `<BlueprintIdent><FieldIdent>FieldPayload` - a transparent new type for the field content
 /// * `<BlueprintIdent><FieldIdent>FieldSubstate` - a type for the full system-wrapped substate
 ///
 /// For each collection value, the following types will be created:
-/// * `<BlueprintIdent><CollectionIdent>EntryContent` - a transparent new type for the full content
+/// * `<BlueprintIdent><CollectionIdent>EntryPayload` - a transparent new type for the entry content
 /// * `<BlueprintIdent><CollectionIdent>EntrySubstate` - a type for the full system-wrapped substate
 ///
 /// For each collection key, the following types will be created:
-/// * `<BlueprintIdent><CollectionIdent>KeyContent` - a transparent new type for the full key content
+/// * `<BlueprintIdent><CollectionIdent>KeyPayload` - a transparent new type for the key content
 /// * `<BlueprintIdent><CollectionIdent>SubstateKey` - a type for the full key (eg includes the u16 for a sorted index key)
 ///
 /// The content of each of the above can take a number of forms.
@@ -246,17 +246,17 @@ pub trait SortedIndexEntryContent<ActualContent: From<Self>>: Sized {
 /// For Fields, it will assume the existence of a type called
 /// `<BlueprintIdent><FieldIdent>V1` and will generate the following types:
 /// * `<BlueprintIdent><FieldIdent>` - a type alias for the latest version (V1).
-/// * `Versioned<BlueprintIdent><FieldIdent>` - the enum wrapper with a single version. This will be the content of `<BlueprintIdent><FieldIdent>FieldContent`.
+/// * `Versioned<BlueprintIdent><FieldIdent>` - the enum wrapper with a single version. This will be the content of `<BlueprintIdent><FieldIdent>FieldPayload`.
 ///
 /// For collection values, it will assume the existence of `<BlueprintIdent><CollectionIdent>V1`
 /// and generate the following types:
 /// * `<BlueprintIdent><CollectionIdent>` - a type alias for the latest version (V1).
-/// * `Versioned<BlueprintIdent><CollectionIdent>` - the enum wrapper with a single version. This will be the content of `<BlueprintIdent><CollectionIdent>EntryContent`.
+/// * `Versioned<BlueprintIdent><CollectionIdent>` - the enum wrapper with a single version. This will be the content of `<BlueprintIdent><CollectionIdent>EntryPayload`.
 ///
 /// For collection keys, it will assume the existence of `<BlueprintIdent><CollectionIdent>KeyInnerV1`
 /// and generate the following types:
 /// * `<BlueprintIdent><CollectionIdent>KeyInner` - a type alias for the latest version (V1)
-/// * `Versioned<BlueprintIdent><CollectionIdent>KeyInner` - the enum wrapper with a single version. This will be the content of `<BlueprintIdent><CollectionIdent>KeyContent`.
+/// * `Versioned<BlueprintIdent><CollectionIdent>KeyInner` - the enum wrapper with a single version. This will be the content of `<BlueprintIdent><CollectionIdent>KeyPayload`.
 #[allow(unused)]
 macro_rules! declare_native_blueprint_state {
     (
@@ -336,19 +336,19 @@ macro_rules! declare_native_blueprint_state {
                     // > Set up Versioned types (if relevant). Assumes __FieldV1 exists and then creates
                     //   - Versioned__Field
                     //   - __Field (alias for __FieldV1)
-                    // > Set up the (transparent) _FieldContent new type for the content of the field
-                    // > Set up the FieldContent trait for anything which can be resolved into the field content
+                    // > Set up the (transparent) _FieldPayload new type for the content of the field
+                    // > Set up the FieldContent trait for anything which can be resolved into the field payload
                     generate_content_type!(
                         content_trait: FieldContent,
                         ident_core: [<$blueprint_ident $field_ident>],
                         #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
-                        struct [<$blueprint_ident $field_ident FieldContent>] = $field_type
+                        struct [<$blueprint_ident $field_ident FieldPayload>] = $field_type
                     );
 
                     // > Set up the _FieldSubstate alias for the system-wrapped substate
                     generate_system_substate_type_alias!(
                         Field,
-                        type [<$blueprint_ident $field_ident FieldSubstate>] = WRAPPED [<$blueprint_ident $field_ident FieldContent>]
+                        type [<$blueprint_ident $field_ident FieldSubstate>] = WRAPPED [<$blueprint_ident $field_ident FieldPayload>]
                     );
                 );*
 
@@ -365,12 +365,12 @@ macro_rules! declare_native_blueprint_state {
                         ident_core: [<$blueprint_ident $collection_ident KeyInner>],
                         #[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, ScryptoSbor)]
                         #[sbor(transparent_name)]
-                        struct [<$blueprint_ident $collection_ident KeyContent>] = $collection_key_type
+                        struct [<$blueprint_ident $collection_ident KeyPayload>] = $collection_key_type
                     );
 
                     // TODO(David): Tweak when I work out the right strategy for keys. Probably just want a single new-type.
                     // So probably just don't use generate_content_type but use generate_key_type or something instead?
-                    pub type [<$blueprint_ident $collection_ident SubstateKey>] = [<$blueprint_ident $collection_ident KeyContent>];
+                    pub type [<$blueprint_ident $collection_ident SubstateKey>] = [<$blueprint_ident $collection_ident KeyPayload>];
 
                     // TODO(David) - Properly handle SortedIndex:
                     // Fix Key types for SortedIndex to have a named u16 part of the key,
@@ -394,12 +394,12 @@ macro_rules! declare_native_blueprint_state {
                         content_trait: [<$collection_type EntryContent>],
                         ident_core: [<$blueprint_ident $collection_ident>],
                         #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
-                        struct [<$blueprint_ident $collection_ident EntryContent>] = $collection_value_type
+                        struct [<$blueprint_ident $collection_ident EntryPayload>] = $collection_value_type
                     );
                     // > Set up the _EntrySubstate alias for the system-wrapped substate
                     generate_system_substate_type_alias!(
                         $collection_type,
-                        type [<$blueprint_ident $collection_ident EntrySubstate>] = WRAPPED [<$blueprint_ident $collection_ident EntryContent>]
+                        type [<$blueprint_ident $collection_ident EntrySubstate>] = WRAPPED [<$blueprint_ident $collection_ident EntryPayload>]
                     );
                 )*
 
@@ -588,7 +588,7 @@ macro_rules! declare_native_blueprint_state {
                             // TODO(David) - Implement instance schema
                             fields.push(FieldSchema {
                                 field: TypeRef::Static(
-                                    type_aggregator.add_child_type_and_descendents::<[<$blueprint_ident $field_ident FieldContent>]>()
+                                    type_aggregator.add_child_type_and_descendents::<[<$blueprint_ident $field_ident FieldPayload>]>()
                                 ),
                                 condition: $field_condition,
                             });
@@ -600,9 +600,9 @@ macro_rules! declare_native_blueprint_state {
                                 $collection_type,
                                 type_aggregator,
                                 $collection_key_type,
-                                [<$blueprint_ident $collection_ident KeyContent>],
+                                [<$blueprint_ident $collection_ident KeyPayload>],
                                 $collection_value_type,
-                                [<$blueprint_ident $collection_ident EntryContent>],
+                                [<$blueprint_ident $collection_ident EntryPayload>],
                                 $collection_can_own
                             ));
                         )*
diff --git a/radix-engine/src/blueprints/package/package.rs b/radix-engine/src/blueprints/package/package.rs
index 25f2b06d660..b55dde62c13 100644
--- a/radix-engine/src/blueprints/package/package.rs
+++ b/radix-engine/src/blueprints/package/package.rs
@@ -1112,7 +1112,7 @@ impl PackageRoyaltyNativeBlueprint {
             LockFlags::read_only(),
         )?;
 
-        let substate: PackageRoyaltyAccumulatorFieldContent = api.field_read_typed(handle)?;
+        let substate: PackageRoyaltyAccumulatorFieldPayload = api.field_read_typed(handle)?;
         let bucket = substate.0.into_latest().royalty_vault.take_all(api)?;
 
         Ok(bucket)
diff --git a/simulator/src/resim/mod.rs b/simulator/src/resim/mod.rs
index 5482052a86c..cccb1bb1cf5 100644
--- a/simulator/src/resim/mod.rs
+++ b/simulator/src/resim/mod.rs
@@ -349,7 +349,10 @@ pub fn export_package_schema(
             _ => panic!("Unexpected"),
         };
 
-        blueprints.insert(bp_version_key, blueprint_definition.value.unwrap().0.into_latest());
+        blueprints.insert(
+            bp_version_key,
+            blueprint_definition.value.unwrap().0.into_latest(),
+        );
     }
 
     Ok(blueprints)

From 5fa5b54c4d7cc50ecc94e0c1b27645a48d03c759 Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Thu, 17 Aug 2023 02:43:29 +0100
Subject: [PATCH 19/28] tidy: Remove unused model

---
 radix-engine/src/blueprints/package/substates.rs | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/radix-engine/src/blueprints/package/substates.rs b/radix-engine/src/blueprints/package/substates.rs
index 6c533a3fc19..786b2c289b8 100644
--- a/radix-engine/src/blueprints/package/substates.rs
+++ b/radix-engine/src/blueprints/package/substates.rs
@@ -52,6 +52,7 @@ declare_native_blueprint_state! {
             },
             value_type: {
                 kind: Static,
+                // TODO(David): Change to VersionedSchema in this substate in the SCHEMAS_PARTITION
                 the_type: ScryptoSchema,
             },
             allow_ownership: false,
@@ -127,14 +128,6 @@ pub struct PackageRoyaltyAccumulatorV1 {
     pub royalty_vault: Vault,
 }
 
-//---------------------------------------
-// Collection models - Schemas
-//---------------------------------------
-
-// TODO(David): Change to VersionedSchema when can define a type as not-implicitly-versioned
-// TODO: Move to Schema partition when we have it
-pub type PackageSchemaV1 = ScryptoSchema;
-
 //---------------------------------------
 // Collection models - By BlueprintVersion
 //---------------------------------------

From 9baed9a69271babc78256c16468bf5390126d9dd Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Thu, 17 Aug 2023 11:42:11 +0100
Subject: [PATCH 20/28] tweak: Minor refactor to macros

---
 radix-engine/src/blueprints/macros.rs | 76 +++++++++++++++++++--------
 1 file changed, 53 insertions(+), 23 deletions(-)

diff --git a/radix-engine/src/blueprints/macros.rs b/radix-engine/src/blueprints/macros.rs
index b5f128e683c..dad0d836fdc 100644
--- a/radix-engine/src/blueprints/macros.rs
+++ b/radix-engine/src/blueprints/macros.rs
@@ -444,6 +444,13 @@ macro_rules! declare_native_blueprint_state {
                     }
                 }
 
+                /// A list of all logical (real) and physical (mapped) partitions for the
+                /// $blueprint_ident blueprint.
+                ///
+                /// Note: In future, we could add a separate LogicalPartition enum, to
+                /// not include physical partitions - however it's very hard to do in
+                /// declarative macro land, because enum variants can't be
+                /// macro invocations (to eg filter out the physical partition types)
                 #[repr(u8)]
                 #[derive(Debug, Clone, Copy, Sbor, PartialEq, Eq, Hash, PartialOrd, Ord)]
                 pub enum [<$blueprint_ident Partition>] {
@@ -460,12 +467,19 @@ macro_rules! declare_native_blueprint_state {
                             return PartitionDescription::Logical(PartitionOffset(module_partition_offset));
                         }
                         $(
-                            generate_next_partition_description!(
-                                let current_partition_description,
-                                module_partition_offset,
+                            let mapped_physical_partition = extract_collection_option!(
+                                mapped_physical_partition,
                                 $($collection_options)?
                             );
-
+                            let current_partition_description = match mapped_physical_partition {
+                                Some(physical_partition) => {
+                                    PartitionDescription::Physical(physical_partition)
+                                },
+                                None => {
+                                    module_partition_offset += 1;
+                                    PartitionDescription::Logical(PartitionOffset(module_partition_offset))
+                                },
+                            };
                             if (*self as u8) == (Self::[<$collection_ident $collection_type>] as u8) {
                                 return current_partition_description;
                             }
@@ -565,6 +579,13 @@ macro_rules! declare_native_blueprint_state {
                 // Typed Substate - Keys and Values
                 //---------------------------------
                 #[derive(Debug, Clone)]
+                /// All the SubstateKeys for all logical (real) and physical (mapped)
+                /// partitions for the $blueprint_ident blueprint.
+                ///
+                /// Note: In future, we could remove keys for physical partitions from this,
+                /// as they can't be persisted as-is - however it's very hard to do in
+                /// declarative macro land, because enum variants can't be
+                /// macro invocations (to eg filter out the physical partition types)
                 pub enum [<$blueprint_ident TypedSubstateKey>] {
                     Fields([<$blueprint_ident Field>]),
                     $([<$collection_ident $collection_type Entries>]([<$blueprint_ident $collection_ident SubstateKey>]),)*
@@ -596,6 +617,13 @@ macro_rules! declare_native_blueprint_state {
                 }
 
                 #[derive(Debug)]
+                /// All the Substate values for all logical (real) and physical (mapped)
+                /// partitions for the $blueprint_ident blueprint.
+                ///
+                /// Note: In future, we could remove values for physical partitions from this,
+                /// as they can't be persisted as-is - however it's very hard to do in
+                /// declarative macro land, because enum variants can't be
+                /// macro invocations (to eg filter out the physical partition types)
                 pub enum [<$blueprint_ident TypedSubstateValue>] {
                     Field([<$blueprint_ident TypedFieldSubstateValue>]),
                     $([<$collection_ident $collection_type>]([<$blueprint_ident $collection_ident EntrySubstate>]),)*
@@ -671,10 +699,9 @@ macro_rules! declare_native_blueprint_state {
                 /// Used for initializing blueprint state.
                 ///
                 /// Note - this doesn't support:
-                /// * Features
-                /// * Instance schemas
-                /// * Feature-dependent fields
+                /// * Instance schemas / generics (yet)
                 /// * IndexEntries (because the underlying new_object API doesn't support them)
+                ///   > these panic at create time
                 #[derive(Debug, Default)]
                 pub struct [<$blueprint_ident StateInit>] {
                     $(
@@ -1097,32 +1124,35 @@ mod helper_macros {
     #[allow(unused)]
     pub(crate) use map_entry_substate_to_kv_entry;
 
-    macro_rules! generate_next_partition_description {
+    macro_rules! extract_collection_option {
         (
-            let $current_partition_description:ident,
-            $module_partition_offset:ident,
+            mapped_physical_partition, // Name of field
             {
-                mapped_physical_partition: $physical_partition:expr$(,)?
-                // When other options are added, need to explicitly add
-                // an ordering of optional other key / values
-            }
+                mapped_physical_partition: $value:tt$(,)?
+                $(sorted_index_key_property: $ignored:tt$(,)?)?
+            }$(,)?
+        ) => {
+            Some($value)
+        };
+        (
+            sorted_index_key_property, // Name of field
+            {
+                $(mapped_physical_partition: $ignored:tt$(,)?)?
+                sorted_index_key_property: $value:tt$(,)?
+            }$(,)?
         ) => {
-            let $current_partition_description =
-                PartitionDescription::Physical($physical_partition);
+            Some($value)
         };
         (
-            let $current_partition_description:ident,
-            $module_partition_offset:ident,
-            $($non_matching_stuff:tt)?
+            $option_field_name:ident,
+            $($non_matching_stuff:tt)?$(,)?
         ) => {
-            $module_partition_offset += 1;
-            let $current_partition_description =
-                PartitionDescription::Logical(PartitionOffset($module_partition_offset));
+            None
         };
     }
 
     #[allow(unused)]
-    pub(crate) use generate_next_partition_description;
+    pub(crate) use extract_collection_option;
 }
 
 #[cfg(test)]

From e50cbf589237c5ba23fba72b7a1c6ec37a6ece72 Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Thu, 17 Aug 2023 12:22:29 +0100
Subject: [PATCH 21/28] refactor: Move blueprint model/macros around

---
 radix-engine/src/blueprints/mod.rs            |   6 +-
 radix-engine/src/blueprints/models/content.rs |  39 ++++
 .../src/blueprints/models/feature_set.rs      | 157 +++++++++++++
 radix-engine/src/blueprints/models/mod.rs     |   7 +
 .../native_blueprint_state_macro.rs}          | 215 ++----------------
 .../src/blueprints/package/package.rs         |  21 +-
 .../src/blueprints/package/substates.rs       |   3 +-
 radix-engine/src/lib.rs                       |  14 ++
 8 files changed, 245 insertions(+), 217 deletions(-)
 create mode 100644 radix-engine/src/blueprints/models/content.rs
 create mode 100644 radix-engine/src/blueprints/models/feature_set.rs
 create mode 100644 radix-engine/src/blueprints/models/mod.rs
 rename radix-engine/src/blueprints/{macros.rs => models/native_blueprint_state_macro.rs} (86%)

diff --git a/radix-engine/src/blueprints/mod.rs b/radix-engine/src/blueprints/mod.rs
index b5c80e63043..d5a31b99224 100644
--- a/radix-engine/src/blueprints/mod.rs
+++ b/radix-engine/src/blueprints/mod.rs
@@ -2,7 +2,7 @@ pub mod access_controller;
 pub mod account;
 pub mod consensus_manager;
 pub mod identity;
-pub mod macros;
+pub mod models;
 pub mod native_schema;
 pub mod package;
 pub mod pool;
@@ -10,3 +10,7 @@ pub mod resource;
 pub mod transaction_processor;
 pub mod transaction_tracker;
 pub mod util;
+
+pub(crate) mod internal_prelude {
+    pub use super::models::*;
+}
diff --git a/radix-engine/src/blueprints/models/content.rs b/radix-engine/src/blueprints/models/content.rs
new file mode 100644
index 00000000000..77b92681910
--- /dev/null
+++ b/radix-engine/src/blueprints/models/content.rs
@@ -0,0 +1,39 @@
+use crate::internal_prelude::*;
+
+pub trait FieldContent<FieldPayload: From<Self>>: Sized {
+    fn into_locked_substate(self) -> FieldSubstate<FieldPayload> {
+        FieldSubstate::new_locked_field(self.into())
+    }
+
+    fn into_mutable_substate(self) -> FieldSubstate<FieldPayload> {
+        FieldSubstate::new_field(self.into())
+    }
+}
+
+pub trait KeyContent<KeyPayload: From<Self>>: Sized {
+    fn into_key(self) -> KeyPayload {
+        self.into()
+    }
+}
+
+pub trait KeyValueEntryContent<EntryPayload: From<Self>>: Sized {
+    fn into_locked_substate(self) -> KeyValueEntrySubstate<EntryPayload> {
+        KeyValueEntrySubstate::entry(self.into())
+    }
+
+    fn into_mutable_substate(self) -> KeyValueEntrySubstate<EntryPayload> {
+        KeyValueEntrySubstate::locked_entry(self.into())
+    }
+}
+
+pub trait IndexEntryContent<EntryPayload: From<Self>>: Sized {
+    fn into_substate(self) -> EntryPayload {
+        self.into()
+    }
+}
+
+pub trait SortedIndexEntryContent<EntryPayload: From<Self>>: Sized {
+    fn into_substate(self) -> EntryPayload {
+        self.into()
+    }
+}
diff --git a/radix-engine/src/blueprints/models/feature_set.rs b/radix-engine/src/blueprints/models/feature_set.rs
new file mode 100644
index 00000000000..36739df44df
--- /dev/null
+++ b/radix-engine/src/blueprints/models/feature_set.rs
@@ -0,0 +1,157 @@
+use crate::internal_prelude::*;
+
+pub trait FeatureSetResolver: Debug {
+    fn feature_names_str(&self) -> Vec<&'static str>;
+
+    fn feature_names_str_set(&self) -> BTreeSet<&'static str> {
+        self.feature_names_str().into_iter().collect()
+    }
+
+    fn feature_names_string(&self) -> Vec<String> {
+        self.feature_names_str()
+            .into_iter()
+            .map(|s| s.to_owned())
+            .collect()
+    }
+
+    fn feature_names_string_set(&self) -> BTreeSet<String> {
+        self.feature_names_str()
+            .into_iter()
+            .map(|s| s.to_owned())
+            .collect()
+    }
+}
+
+/// For feature checks against a non-inner object
+#[derive(Debug)]
+pub enum FeatureChecks<TOwn: FeatureSetResolver> {
+    None,
+    RequireAllSubstates,
+    ForFeatures { own_features: TOwn },
+}
+
+impl<T: FeatureSetResolver> From<T> for FeatureChecks<T> {
+    fn from(value: T) -> Self {
+        FeatureChecks::ForFeatures {
+            own_features: value,
+        }
+    }
+}
+
+impl<TOwn: FeatureSetResolver> FeatureChecks<TOwn> {
+    pub fn assert_valid(
+        &self,
+        substate_name: &'static str,
+        condition: &Condition,
+        is_present: bool,
+    ) -> Result<(), RuntimeError> {
+        let is_valid = match self {
+            FeatureChecks::None => Ok(()),
+            FeatureChecks::RequireAllSubstates => {
+                if is_present {
+                    Ok(())
+                } else {
+                    Err(format!("Required all substates to be present, but {} was not present", substate_name))
+                }
+            },
+            FeatureChecks::ForFeatures { own_features } => {
+                match condition {
+                    Condition::Always => {
+                        if is_present {
+                            Ok(())
+                        } else {
+                            Err(format!("Substate condition for {} required it to be always present, but it was not", substate_name))
+                        }
+                    }
+                    Condition::IfFeature(feature) => {
+                        let feature_enabled = own_features.feature_names_str().contains(&feature.as_str());
+                        if feature_enabled && !is_present {
+                            Err(format!("Substate condition for {} required it to be present when the feature {} was enabled, but it was absent", substate_name, feature))
+                        } else if !feature_enabled && is_present {
+                            Err(format!("Substate condition for {} required it to be absent when the feature {} was disabled, but it was present", substate_name, feature))
+                        } else {
+                            Ok(())
+                        }
+                    },
+                    Condition::IfOuterFeature(_) => {
+                        Err(format!("Substate condition for {} required an outer object feature, but the blueprint does not have an outer blueprint defined", substate_name))
+                    }
+                }
+            },
+        };
+        is_valid.map_err(|error_message| {
+            RuntimeError::SystemError(SystemError::InvalidNativeSubstatesForFeature(error_message))
+        })
+    }
+}
+
+/// For feature checks against an inner object
+pub enum InnerObjectFeatureChecks<TOwn, TOuter> {
+    None,
+    RequireAllSubstates,
+    ForFeatures {
+        own_features: TOwn,
+        outer_object_features: TOuter,
+    },
+}
+
+impl<TOwn: FeatureSetResolver, TOuter: FeatureSetResolver> InnerObjectFeatureChecks<TOwn, TOuter> {
+    pub fn assert_valid(
+        &self,
+        substate_name: &'static str,
+        condition: &Condition,
+        is_present: bool,
+    ) -> Result<(), RuntimeError> {
+        let is_valid = match self {
+            Self::None => Ok(()),
+            Self::RequireAllSubstates => {
+                if is_present {
+                    Ok(())
+                } else {
+                    Err(format!(
+                        "Required all substates to be present, but {} was not present",
+                        substate_name
+                    ))
+                }
+            }
+            Self::ForFeatures {
+                own_features,
+                outer_object_features,
+            } => match condition {
+                Condition::Always => {
+                    if is_present {
+                        Ok(())
+                    } else {
+                        Err(format!("Substate condition for {} required it to be always present, but it was not", substate_name))
+                    }
+                }
+                Condition::IfFeature(feature) => {
+                    let feature_enabled =
+                        own_features.feature_names_str().contains(&feature.as_str());
+                    if feature_enabled && !is_present {
+                        Err(format!("Substate condition for {} required it to be present when the feature {} was enabled, but it was absent", substate_name, feature))
+                    } else if !feature_enabled && is_present {
+                        Err(format!("Substate condition for {} required it to be absent when the feature {} was disabled, but it was present", substate_name, feature))
+                    } else {
+                        Ok(())
+                    }
+                }
+                Condition::IfOuterFeature(feature) => {
+                    let feature_enabled = outer_object_features
+                        .feature_names_str()
+                        .contains(&feature.as_str());
+                    if feature_enabled && !is_present {
+                        Err(format!("Substate condition for {} required it to be present when the outer object feature {} was enabled, but it was absent", substate_name, feature))
+                    } else if !feature_enabled && is_present {
+                        Err(format!("Substate condition for {} required it to be absent when the outer object feature {} was disabled, but it was present", substate_name, feature))
+                    } else {
+                        Ok(())
+                    }
+                }
+            },
+        };
+        is_valid.map_err(|error_message| {
+            RuntimeError::SystemError(SystemError::InvalidNativeSubstatesForFeature(error_message))
+        })
+    }
+}
diff --git a/radix-engine/src/blueprints/models/mod.rs b/radix-engine/src/blueprints/models/mod.rs
new file mode 100644
index 00000000000..45f493c3c57
--- /dev/null
+++ b/radix-engine/src/blueprints/models/mod.rs
@@ -0,0 +1,7 @@
+mod content;
+mod feature_set;
+mod native_blueprint_state_macro;
+
+pub use content::*;
+pub use feature_set::*;
+pub(crate) use native_blueprint_state_macro::*;
diff --git a/radix-engine/src/blueprints/macros.rs b/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
similarity index 86%
rename from radix-engine/src/blueprints/macros.rs
rename to radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
index dad0d836fdc..35b17bdb9b0 100644
--- a/radix-engine/src/blueprints/macros.rs
+++ b/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
@@ -1,203 +1,4 @@
-use crate::errors::*;
-use crate::system::system::*;
-use crate::types::*;
-
-// TODO(David) - Move this, features and content stuff under a `models` module?
-// TODO(David) - Create an internal_prelude in `blueprints`
-// and an internal_prelude and prelud in engine
-pub trait FeatureSetResolver: Debug {
-    fn feature_names_str(&self) -> Vec<&'static str>;
-
-    fn feature_names_str_set(&self) -> BTreeSet<&'static str> {
-        self.feature_names_str().into_iter().collect()
-    }
-
-    fn feature_names_string(&self) -> Vec<String> {
-        self.feature_names_str()
-            .into_iter()
-            .map(|s| s.to_owned())
-            .collect()
-    }
-
-    fn feature_names_string_set(&self) -> BTreeSet<String> {
-        self.feature_names_str()
-            .into_iter()
-            .map(|s| s.to_owned())
-            .collect()
-    }
-}
-
-/// For feature checks against a non-inner object
-#[derive(Debug)]
-pub enum FeatureChecks<TOwn: FeatureSetResolver> {
-    None,
-    RequireAllSubstates,
-    ForFeatures { own_features: TOwn },
-}
-
-impl<T: FeatureSetResolver> From<T> for FeatureChecks<T> {
-    fn from(value: T) -> Self {
-        FeatureChecks::ForFeatures {
-            own_features: value,
-        }
-    }
-}
-
-impl<TOwn: FeatureSetResolver> FeatureChecks<TOwn> {
-    pub fn assert_valid(
-        &self,
-        substate_name: &'static str,
-        condition: &Condition,
-        is_present: bool,
-    ) -> Result<(), RuntimeError> {
-        let is_valid = match self {
-            FeatureChecks::None => Ok(()),
-            FeatureChecks::RequireAllSubstates => {
-                if is_present {
-                    Ok(())
-                } else {
-                    Err(format!("Required all substates to be present, but {} was not present", substate_name))
-                }
-            },
-            FeatureChecks::ForFeatures { own_features } => {
-                match condition {
-                    Condition::Always => {
-                        if is_present {
-                            Ok(())
-                        } else {
-                            Err(format!("Substate condition for {} required it to be always present, but it was not", substate_name))
-                        }
-                    }
-                    Condition::IfFeature(feature) => {
-                        let feature_enabled = own_features.feature_names_str().contains(&feature.as_str());
-                        if feature_enabled && !is_present {
-                            Err(format!("Substate condition for {} required it to be present when the feature {} was enabled, but it was absent", substate_name, feature))
-                        } else if !feature_enabled && is_present {
-                            Err(format!("Substate condition for {} required it to be absent when the feature {} was disabled, but it was present", substate_name, feature))
-                        } else {
-                            Ok(())
-                        }
-                    },
-                    Condition::IfOuterFeature(_) => {
-                        Err(format!("Substate condition for {} required an outer object feature, but the blueprint does not have an outer blueprint defined", substate_name))
-                    }
-                }
-            },
-        };
-        is_valid.map_err(|error_message| {
-            RuntimeError::SystemError(SystemError::InvalidNativeSubstatesForFeature(error_message))
-        })
-    }
-}
-
-/// For feature checks against an inner object
-pub enum InnerObjectFeatureChecks<TOwn, TOuter> {
-    None,
-    RequireAllSubstates,
-    ForFeatures {
-        own_features: TOwn,
-        outer_object_features: TOuter,
-    },
-}
-
-impl<TOwn: FeatureSetResolver, TOuter: FeatureSetResolver> InnerObjectFeatureChecks<TOwn, TOuter> {
-    pub fn assert_valid(
-        &self,
-        substate_name: &'static str,
-        condition: &Condition,
-        is_present: bool,
-    ) -> Result<(), RuntimeError> {
-        let is_valid = match self {
-            Self::None => Ok(()),
-            Self::RequireAllSubstates => {
-                if is_present {
-                    Ok(())
-                } else {
-                    Err(format!(
-                        "Required all substates to be present, but {} was not present",
-                        substate_name
-                    ))
-                }
-            }
-            Self::ForFeatures {
-                own_features,
-                outer_object_features,
-            } => match condition {
-                Condition::Always => {
-                    if is_present {
-                        Ok(())
-                    } else {
-                        Err(format!("Substate condition for {} required it to be always present, but it was not", substate_name))
-                    }
-                }
-                Condition::IfFeature(feature) => {
-                    let feature_enabled =
-                        own_features.feature_names_str().contains(&feature.as_str());
-                    if feature_enabled && !is_present {
-                        Err(format!("Substate condition for {} required it to be present when the feature {} was enabled, but it was absent", substate_name, feature))
-                    } else if !feature_enabled && is_present {
-                        Err(format!("Substate condition for {} required it to be absent when the feature {} was disabled, but it was present", substate_name, feature))
-                    } else {
-                        Ok(())
-                    }
-                }
-                Condition::IfOuterFeature(feature) => {
-                    let feature_enabled = outer_object_features
-                        .feature_names_str()
-                        .contains(&feature.as_str());
-                    if feature_enabled && !is_present {
-                        Err(format!("Substate condition for {} required it to be present when the outer object feature {} was enabled, but it was absent", substate_name, feature))
-                    } else if !feature_enabled && is_present {
-                        Err(format!("Substate condition for {} required it to be absent when the outer object feature {} was disabled, but it was present", substate_name, feature))
-                    } else {
-                        Ok(())
-                    }
-                }
-            },
-        };
-        is_valid.map_err(|error_message| {
-            RuntimeError::SystemError(SystemError::InvalidNativeSubstatesForFeature(error_message))
-        })
-    }
-}
-
-pub trait FieldContent<FieldPayload: From<Self>>: Sized {
-    fn into_locked_substate(self) -> FieldSubstate<FieldPayload> {
-        FieldSubstate::new_locked_field(self.into())
-    }
-
-    fn into_mutable_substate(self) -> FieldSubstate<FieldPayload> {
-        FieldSubstate::new_field(self.into())
-    }
-}
-
-pub trait KeyContent<KeyPayload: From<Self>>: Sized {
-    fn into_key(self) -> KeyPayload {
-        self.into()
-    }
-}
-
-pub trait KeyValueEntryContent<EntryPayload: From<Self>>: Sized {
-    fn into_locked_substate(self) -> KeyValueEntrySubstate<EntryPayload> {
-        KeyValueEntrySubstate::entry(self.into())
-    }
-
-    fn into_mutable_substate(self) -> KeyValueEntrySubstate<EntryPayload> {
-        KeyValueEntrySubstate::locked_entry(self.into())
-    }
-}
-
-pub trait IndexEntryContent<EntryPayload: From<Self>>: Sized {
-    fn into_substate(self) -> EntryPayload {
-        self.into()
-    }
-}
-
-pub trait SortedIndexEntryContent<EntryPayload: From<Self>>: Sized {
-    fn into_substate(self) -> EntryPayload {
-        self.into()
-    }
-}
+use crate::internal_prelude::*;
 
 /// Generates types and typed-interfaces for native blueprints, their
 /// state models, features, partitions, and their interaction with
@@ -548,12 +349,24 @@ macro_rules! declare_native_blueprint_state {
                     $(pub [<$feature_property_name>]: bool,)*
                 }
 
+                impl [<$blueprint_ident FeatureSet>] {
+                    pub fn all_features() -> BTreeSet<String> {
+                        let mut features = BTreeSet::new();
+                        $(
+                            features.insert(
+                                [<$blueprint_ident Feature>]::$feature_ident.feature_name().to_string()
+                            );
+                        )*
+                        features
+                    }
+                }
+
                 impl FeatureSetResolver for [<$blueprint_ident FeatureSet>] {
                     fn feature_names_str(&self) -> Vec<&'static str> {
                         let mut names = vec![];
                         $(
                             if self.[<$feature_property_name>] {
-                                names.push(stringify!($feature_property_name));
+                                names.push([<$blueprint_ident Feature>]::$feature_ident.feature_name());
                             }
                         )*
                         names
diff --git a/radix-engine/src/blueprints/package/package.rs b/radix-engine/src/blueprints/package/package.rs
index 2feabdf1920..6ea27062b76 100644
--- a/radix-engine/src/blueprints/package/package.rs
+++ b/radix-engine/src/blueprints/package/package.rs
@@ -1,6 +1,6 @@
-use crate::blueprints::macros::*;
+use super::substates::*;
 use crate::blueprints::util::SecurifiedRoleAssignment;
-use crate::errors::*;
+use crate::internal_prelude::*;
 use crate::kernel::kernel_api::{KernelApi, KernelSubstateApi};
 use crate::system::node_init::type_info_partition;
 use crate::system::node_modules::metadata::MetadataEntrySubstate;
@@ -34,10 +34,6 @@ use crate::system::system_callback_api::SystemCallbackObject;
 use crate::system::system_modules::auth::{AuthError, ResolvedPermission};
 use crate::vm::VmPackageValidation;
 
-use super::*;
-
-pub const PACKAGE_ROYALTY_FEATURE: &str = "package_royalty";
-
 #[derive(Debug, Clone, PartialEq, Eq, ScryptoSbor)]
 pub enum PackageError {
     InvalidWasm(PrepareError),
@@ -690,14 +686,11 @@ impl PackageNativePackage {
             PACKAGE_BLUEPRINT.to_string() => BlueprintDefinitionInit {
                 blueprint_type: BlueprintType::default(),
                 is_transient: false,
-                feature_set: btreeset!(
-                    PACKAGE_ROYALTY_FEATURE.to_string(),
-                ),
+                feature_set: PackageFeatureSet::all_features(),
                 dependencies: btreeset!(
                     PACKAGE_OF_DIRECT_CALLER_VIRTUAL_BADGE.into(),
                     PACKAGE_OWNER_BADGE.into(),
                 ),
-
                 schema: BlueprintSchemaInit {
                     generics: vec![],
                     schema,
@@ -708,7 +701,6 @@ impl PackageNativePackage {
                     },
                     hooks: BlueprintHooksInit::default(),
                 },
-
                 royalty_config: PackageRoyaltyConfig::default(),
                 auth_config: AuthConfig {
                     function_auth: FunctionAuth::AccessRules(
@@ -1119,7 +1111,7 @@ impl PackageRoyaltyNativeBlueprint {
             if !service.is_feature_enabled(
                 receiver,
                 ObjectModuleId::Main,
-                PACKAGE_ROYALTY_FEATURE,
+                PackageFeature::PackageRoyalty.feature_name(),
             )? {
                 return Ok(());
             }
@@ -1181,7 +1173,10 @@ impl PackageRoyaltyNativeBlueprint {
     where
         Y: ClientApi<RuntimeError>,
     {
-        if !api.actor_is_feature_enabled(OBJECT_HANDLE_SELF, PACKAGE_ROYALTY_FEATURE)? {
+        if !api.actor_is_feature_enabled(
+            OBJECT_HANDLE_SELF,
+            PackageFeature::PackageRoyalty.feature_name(),
+        )? {
             return Err(RuntimeError::ApplicationError(
                 ApplicationError::PackageError(PackageError::RoyaltiesNotEnabled),
             ));
diff --git a/radix-engine/src/blueprints/package/substates.rs b/radix-engine/src/blueprints/package/substates.rs
index 786b2c289b8..c88f27ea26d 100644
--- a/radix-engine/src/blueprints/package/substates.rs
+++ b/radix-engine/src/blueprints/package/substates.rs
@@ -1,6 +1,5 @@
 use super::*;
-use crate::blueprints::macros::*;
-use crate::types::*;
+use crate::internal_prelude::*;
 
 declare_native_blueprint_state! {
     blueprint_ident: Package,
diff --git a/radix-engine/src/lib.rs b/radix-engine/src/lib.rs
index 25a5d360d3c..51a4119595c 100644
--- a/radix-engine/src/lib.rs
+++ b/radix-engine/src/lib.rs
@@ -30,3 +30,17 @@ pub mod errors;
 
 pub mod utils;
 pub mod vm;
+
+pub mod prelude {
+    // Note - radix_engine::types was previously something like an internal/
+    // external prelude, but let's normalize radix-engine to have a prelude
+    // like everything else, and add to it where needed
+    pub use crate::types::*;
+}
+
+pub(crate) mod internal_prelude {
+    pub use super::prelude::*;
+    pub use crate::blueprints::internal_prelude::*;
+    pub use crate::errors::*;
+    pub use crate::system::system::*;
+}

From dc4b02fb59e8633db0fc0877f526b9cede38b1cf Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Thu, 17 Aug 2023 14:07:50 +0100
Subject: [PATCH 22/28] refactor: Further minor moves / refactors

---
 .../src/blueprints/package/substates.rs       | 41 ++++++++-----------
 radix-engine-interface/src/lib.rs             |  4 ++
 .../src/blueprints/package/package.rs         | 11 ++---
 sbor/src/lib.rs                               |  1 +
 sbor/src/schema/mod.rs                        |  7 ++++
 scrypto-schema/src/lib.rs                     |  1 -
 simulator/src/resim/cmd_publish.rs            | 26 +++---------
 7 files changed, 38 insertions(+), 53 deletions(-)

diff --git a/radix-engine-interface/src/blueprints/package/substates.rs b/radix-engine-interface/src/blueprints/package/substates.rs
index 6993e55b4b2..c1e10630f8a 100644
--- a/radix-engine-interface/src/blueprints/package/substates.rs
+++ b/radix-engine-interface/src/blueprints/package/substates.rs
@@ -1,9 +1,5 @@
 use crate::blueprints::package::BlueprintType;
-use crate::prelude::*;
-use crate::schema::*;
-use crate::types::*;
-use crate::*;
-use radix_engine_common::crypto::Hash;
+use crate::internal_prelude::*;
 
 pub const PACKAGE_CODE_ID: u64 = 0u64;
 pub const RESOURCE_CODE_ID: u64 = 1u64;
@@ -36,6 +32,17 @@ pub enum BlueprintPayloadDef {
                  // TODO: How to represent a structure containing a generic?
 }
 
+impl BlueprintPayloadDef {
+    pub fn from_type_ref(type_ref: TypeRef<LocalTypeIndex>, schema_hash: SchemaHash) -> Self {
+        match type_ref {
+            TypeRef::Static(type_index) => {
+                BlueprintPayloadDef::Static(TypeIdentifier(schema_hash, type_index))
+            }
+            TypeRef::Generic(index) => BlueprintPayloadDef::Generic(index),
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Sbor)]
 pub struct FunctionSchema {
     pub receiver: Option<ReceiverInfo>,
@@ -280,19 +287,9 @@ impl IndexedStateSchema {
             let schema_fields = schema
                 .fields
                 .into_iter()
-                .map(|field_schema| {
-                    let pointer = match field_schema.field {
-                        TypeRef::Static(type_index) => {
-                            BlueprintPayloadDef::Static(TypeIdentifier(schema_hash, type_index))
-                        }
-                        TypeRef::Generic(instance_index) => {
-                            BlueprintPayloadDef::Generic(instance_index)
-                        }
-                    };
-                    FieldSchema {
-                        field: pointer,
-                        condition: field_schema.condition,
-                    }
+                .map(|field_schema| FieldSchema {
+                    field: BlueprintPayloadDef::from_type_ref(field_schema.field, schema_hash),
+                    condition: field_schema.condition,
                 })
                 .collect();
             fields = Some((
@@ -304,12 +301,8 @@ impl IndexedStateSchema {
 
         let mut collections = Vec::new();
         for (collection_index, collection_schema) in schema.collections.into_iter().enumerate() {
-            let schema = collection_schema.map(|type_ref| match type_ref {
-                TypeRef::Static(type_index) => {
-                    BlueprintPayloadDef::Static(TypeIdentifier(schema_hash, type_index))
-                }
-                TypeRef::Generic(generic_index) => BlueprintPayloadDef::Generic(generic_index),
-            });
+            let schema = collection_schema
+                .map(|type_ref| BlueprintPayloadDef::from_type_ref(type_ref, schema_hash));
 
             if let Some(partition_num) = system_mappings.get(&collection_index) {
                 collections.push((PartitionDescription::Physical(*partition_num), schema));
diff --git a/radix-engine-interface/src/lib.rs b/radix-engine-interface/src/lib.rs
index d89a9d48e67..f200e646796 100644
--- a/radix-engine-interface/src/lib.rs
+++ b/radix-engine-interface/src/lib.rs
@@ -60,3 +60,7 @@ pub mod prelude {
         non_fungible_data_update_roles, recall_roles, role_entry, roles2, rule, withdraw_roles,
     };
 }
+
+pub(crate) mod internal_prelude {
+    pub use crate::prelude::*;
+}
diff --git a/radix-engine/src/blueprints/package/package.rs b/radix-engine/src/blueprints/package/package.rs
index 6ea27062b76..1519fbf78f3 100644
--- a/radix-engine/src/blueprints/package/package.rs
+++ b/radix-engine/src/blueprints/package/package.rs
@@ -898,13 +898,10 @@ impl PackageNativePackage {
 
                 let mut events = BTreeMap::new();
                 for (key, type_ref) in definition_init.schema.events.event_schema {
-                    let index = match type_ref {
-                        TypeRef::Static(index) => {
-                            BlueprintPayloadDef::Static(TypeIdentifier(schema_hash, index))
-                        }
-                        TypeRef::Generic(index) => BlueprintPayloadDef::Generic(index),
-                    };
-                    events.insert(key, index);
+                    events.insert(
+                        key,
+                        BlueprintPayloadDef::from_type_ref(type_ref, schema_hash),
+                    );
                 }
 
                 let system_instructions = system_instructions
diff --git a/sbor/src/lib.rs b/sbor/src/lib.rs
index c2b4217a870..b600c7e043c 100644
--- a/sbor/src/lib.rs
+++ b/sbor/src/lib.rs
@@ -91,6 +91,7 @@ pub mod prelude {
     pub use crate::enum_variant::FixedEnumVariant as SborFixedEnumVariant;
     pub use crate::path::{SborPath, SborPathBuf};
     pub use crate::representations;
+    pub use crate::schema::prelude::*;
     pub use crate::value::{CustomValue as SborCustomValue, Value as SborValue};
     pub use crate::value_kind::*;
     pub use crate::{
diff --git a/sbor/src/schema/mod.rs b/sbor/src/schema/mod.rs
index 81e8fb97503..137dfe56cb1 100644
--- a/sbor/src/schema/mod.rs
+++ b/sbor/src/schema/mod.rs
@@ -17,3 +17,10 @@ pub use type_aggregator::*;
 pub use type_data::*;
 pub use type_link::*;
 pub use well_known_types::*;
+
+pub mod prelude {
+    pub use super::schema::*;
+    pub use super::type_aggregator::*;
+    pub use super::type_data::*;
+    pub use super::type_link::*;
+}
diff --git a/scrypto-schema/src/lib.rs b/scrypto-schema/src/lib.rs
index 788460be8ed..4318b79588f 100644
--- a/scrypto-schema/src/lib.rs
+++ b/scrypto-schema/src/lib.rs
@@ -7,7 +7,6 @@ compile_error!("Feature `std` and `alloc` can't be enabled at the same time.");
 
 use bitflags::bitflags;
 use radix_engine_common::prelude::*;
-use sbor::*;
 
 #[derive(Debug, Clone, PartialEq, Eq, ScryptoSbor, ManifestSbor)]
 pub struct KeyValueStoreGenericSubstitutions {
diff --git a/simulator/src/resim/cmd_publish.rs b/simulator/src/resim/cmd_publish.rs
index 4c8f7b98331..d3d85ab6ae5 100644
--- a/simulator/src/resim/cmd_publish.rs
+++ b/simulator/src/resim/cmd_publish.rs
@@ -1,13 +1,12 @@
 use clap::Parser;
 use colored::*;
-use radix_engine::blueprints::macros::*;
+use radix_engine::blueprints::models::*;
 use radix_engine::track::IntoDatabaseUpdates;
 use radix_engine::types::*;
 use radix_engine_interface::blueprints::package::{
     BlueprintDefinition, BlueprintDependencies, BlueprintPayloadDef, FunctionSchema,
     IndexedStateSchema, PackageExport, VmType, *,
 };
-use radix_engine_interface::schema::TypeRef;
 use radix_engine_queries::typed_substate_layout::*;
 use radix_engine_store_interface::interface::CommittableSubstateDatabase;
 use std::ffi::OsStr;
@@ -121,18 +120,8 @@ impl Publish {
                         function.clone(),
                         FunctionSchema {
                             receiver: setup.receiver,
-                            input: match setup.input {
-                                TypeRef::Static(type_index) => BlueprintPayloadDef::Static(
-                                    TypeIdentifier(schema_hash, type_index),
-                                ),
-                                TypeRef::Generic(index) => BlueprintPayloadDef::Generic(index),
-                            },
-                            output: match setup.output {
-                                TypeRef::Static(type_index) => BlueprintPayloadDef::Static(
-                                    TypeIdentifier(schema_hash, type_index),
-                                ),
-                                TypeRef::Generic(index) => BlueprintPayloadDef::Generic(index),
-                            },
+                            input: BlueprintPayloadDef::from_type_ref(setup.input, schema_hash),
+                            output: BlueprintPayloadDef::from_type_ref(setup.output, schema_hash),
                         },
                     );
                     let export = PackageExport {
@@ -147,15 +136,10 @@ impl Publish {
                     .events
                     .event_schema
                     .into_iter()
-                    .map(|(key, index)| {
+                    .map(|(key, type_ref)| {
                         (
                             key,
-                            match index {
-                                TypeRef::Static(index) => {
-                                    BlueprintPayloadDef::Static(TypeIdentifier(schema_hash, index))
-                                }
-                                TypeRef::Generic(index) => BlueprintPayloadDef::Generic(index),
-                            },
+                            BlueprintPayloadDef::from_type_ref(type_ref, schema_hash),
                         )
                     })
                     .collect();

From fd78605b77791cd130544ebe2f81db2a788f8b92 Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Thu, 17 Aug 2023 15:17:12 +0100
Subject: [PATCH 23/28] tweak: Add support for generics in
 declare_native_blueprint_state

---
 .../models/native_blueprint_state_macro.rs    | 161 ++++++++++++------
 .../src/blueprints/package/substates.rs       |   1 -
 sbor-derive-common/src/utils.rs               |  13 +-
 3 files changed, 116 insertions(+), 59 deletions(-)

diff --git a/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs b/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
index 35b17bdb9b0..516d94760bb 100644
--- a/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
+++ b/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
@@ -31,8 +31,8 @@ use crate::internal_prelude::*;
 ///         the_type: x,
 ///     },
 ///     {
-///         kind: Instance,
-///         ident: GenericTypeParameterName,
+///         kind: Generic,
+///         ident: BlueprintGenericParameterIdent,
 ///     },
 ///     // In future
 ///     {
@@ -69,6 +69,18 @@ macro_rules! declare_native_blueprint_state {
                 $(,)?
             },
         )?
+        $(
+            generics: {
+                $(
+                    $generic_property_name:ident: {
+                        ident: $generic_ident:ident,
+                        description: $generic_description:expr
+                        $(,)?
+                    }
+                ),*
+                $(,)?
+            },
+        )?
         features: {
             $(
                 $feature_property_name:ident: {
@@ -78,15 +90,6 @@ macro_rules! declare_native_blueprint_state {
             ),*
             $(,)?
         },
-        instance_schema_types: {
-            // If no types => instance schema disabled
-            $(
-                $instance_type_property_name:ident: {
-                    ident: $instance_type_ident:ident,
-                }
-            ),*
-            $(,)?
-        },
         fields: {
             $(
                 $field_property_name:ident: {
@@ -152,7 +155,7 @@ macro_rules! declare_native_blueprint_state {
                         Field,
                         type [<$blueprint_ident $field_ident FieldSubstate>] = WRAPPED [<$blueprint_ident $field_ident FieldPayload>]
                     );
-                );*
+                )*
 
                 // Generate models for each collection
                 $(
@@ -344,6 +347,35 @@ macro_rules! declare_native_blueprint_state {
                     }
                 }
 
+                $(
+                    #[repr(u8)]
+                    #[derive(Debug, Clone, Copy, Sbor, PartialEq, Eq, Hash, FromRepr)]
+                    pub enum [<$blueprint_ident Generic>] {
+                        $($generic_ident,)*
+                    }
+
+                    impl [<$blueprint_ident Generic>] {
+                        pub const fn generic_index(&self) -> u8 {
+                            *self as u8
+                        }
+                    }
+                )?
+
+                #[derive(Debug, Clone, Copy, Sbor, PartialEq, Eq, Hash)]
+                pub enum [<$blueprint_ident Feature>] {
+                    $($feature_ident,)*
+                }
+
+                impl BlueprintFeature for [<$blueprint_ident Feature>] {
+                    fn feature_name(&self) -> &'static str {
+                        match *self {
+                            $(
+                                Self::$feature_ident => stringify!($feature_property_name),
+                            )*
+                        }
+                    }
+                }
+
                 #[derive(Debug, Clone, Copy, Sbor, PartialEq, Eq, Hash)]
                 pub struct [<$blueprint_ident FeatureSet>] {
                     $(pub [<$feature_property_name>]: bool,)*
@@ -373,21 +405,6 @@ macro_rules! declare_native_blueprint_state {
                     }
                 }
 
-                #[derive(Debug, Clone, Copy, Sbor, PartialEq, Eq, Hash)]
-                pub enum [<$blueprint_ident Feature>] {
-                    $($feature_ident,)*
-                }
-
-                impl BlueprintFeature for [<$blueprint_ident Feature>] {
-                    fn feature_name(&self) -> &'static str {
-                        match *self {
-                            $(
-                                Self::$feature_ident => stringify!($feature_property_name),
-                            )*
-                        }
-                    }
-                }
-
                 //---------------------------------
                 // Typed Substate - Keys and Values
                 //---------------------------------
@@ -477,19 +494,21 @@ macro_rules! declare_native_blueprint_state {
                     ) -> BlueprintStateSchemaInit {
                         let mut fields = vec![];
                         $(
-                            // TODO(David) - Implement instance schema
                             fields.push(FieldSchema {
-                                field: TypeRef::Static(
-                                    type_aggregator.add_child_type_and_descendents::<[<$blueprint_ident $field_ident FieldPayload>]>()
+                                field: map_type_ref!(
+                                    $blueprint_ident,
+                                    type_aggregator,
+                                    $field_type,
+                                    [<$blueprint_ident $field_ident FieldPayload>],
                                 ),
                                 condition: $field_condition,
                             });
                         )*
                         let mut collections = vec![];
                         $(
-                            // TODO(David) - Implement instance schema
                             collections.push(map_collection_schema!(
                                 $collection_type,
+                                $blueprint_ident,
                                 type_aggregator,
                                 $collection_key_type,
                                 [<$blueprint_ident $collection_ident KeyPayload>],
@@ -512,7 +531,6 @@ macro_rules! declare_native_blueprint_state {
                 /// Used for initializing blueprint state.
                 ///
                 /// Note - this doesn't support:
-                /// * Instance schemas / generics (yet)
                 /// * IndexEntries (because the underlying new_object API doesn't support them)
                 ///   > these panic at create time
                 #[derive(Debug, Default)]
@@ -785,14 +803,14 @@ mod helper_macros {
             ident_core: $ident_core:ident,
             $(#[$attributes:meta])*
             struct $content_type_name:ident = {
-                kind: Instance,
-                ident: $instance_ident:ident
+                kind: Generic,
+                ident: $generic_ident:ident
                 $(,)?
             }
         ) => {
             $(#[$attributes])*
-            #[sbor(transparent)]
-            pub struct $content_type_name<$instance_ident = ScryptoValue>(pub $instance_ident);
+            #[sbor(transparent, categorize_types = "")]
+            pub struct $content_type_name<$generic_ident: ScryptoEncode + ScryptoDecode = ScryptoValue>(pub $generic_ident);
         };
         // TODO - Add support for some kind of StaticMultiVersioned type here
     }
@@ -832,28 +850,43 @@ mod helper_macros {
     pub(crate) use generate_system_substate_type_alias;
 
     macro_rules! map_collection_schema {
-        (KeyValue, $aggregator:ident, $key_type:tt, $key_content_alias:ident, $value_type:tt, $value_content_alias:ident, $allow_ownership:expr$(,)?) => {
+        (KeyValue, $blueprint_ident:ident, $aggregator:ident, $key_type:tt, $key_payload_alias:ident, $value_type:tt, $value_payload_alias:ident, $allow_ownership:expr$(,)?) => {
             BlueprintCollectionSchema::KeyValueStore(BlueprintKeyValueSchema {
-                key: map_type_ref!($aggregator, $key_type, $key_content_alias),
-                value: map_type_ref!($aggregator, $value_type, $value_content_alias),
+                key: map_type_ref!($blueprint_ident, $aggregator, $key_type, $key_payload_alias),
+                value: map_type_ref!(
+                    $blueprint_ident,
+                    $aggregator,
+                    $value_type,
+                    $value_payload_alias
+                ),
                 allow_ownership: $allow_ownership,
             })
         };
-        (Index, $aggregator:ident, $key_type:tt, $key_content_alias:ident, $value_type:tt, $value_content_alias:ident, $allow_ownership:expr$(,)?) => {
+        (Index, $blueprint_ident:ident, $aggregator:ident, $key_type:tt, $key_payload_alias:ident, $value_type:tt, $value_payload_alias:ident, $allow_ownership:expr$(,)?) => {
             BlueprintCollectionSchema::Index(BlueprintKeyValueSchema {
-                key: map_type_ref!($aggregator, $key_type, $key_content_alias),
-                value: map_type_ref!($aggregator, $value_type, $value_content_alias),
+                key: map_type_ref!($blueprint_ident, $aggregator, $key_type, $key_payload_alias),
+                value: map_type_ref!(
+                    $blueprint_ident,
+                    $aggregator,
+                    $value_type,
+                    $value_payload_alias
+                ),
                 allow_ownership: $allow_ownership,
             })
         };
-        (SortedIndex, $aggregator:ident, $key_type:tt, $key_content_alias:ident, $value_type:tt, $value_content_alias:ident, $allow_ownership:expr$(,)?) => {
+        (SortedIndex, $blueprint_ident:ident, $aggregator:ident, $key_type:tt, $key_payload_alias:ident, $value_type:tt, $value_payload_alias:ident, $allow_ownership:expr$(,)?) => {
             BlueprintCollectionSchema::SortedIndex(BlueprintKeyValueSchema {
-                key: map_type_ref!($aggregator, $key_type, $key_content_alias),
-                value: map_type_ref!($aggregator, $value_type, $value_content_alias),
+                key: map_type_ref!($blueprint_ident, $aggregator, $key_type, $key_payload_alias),
+                value: map_type_ref!(
+                    $blueprint_ident,
+                    $aggregator,
+                    $value_type,
+                    $value_payload_alias
+                ),
                 allow_ownership: $allow_ownership,
             })
         };
-        ($unknown_system_substate_type:ident, $aggregator:ident, $collection_key_type:tt, $collection_value_type:tt, $collection_allow_ownership:expr$(,)?) => {
+        ($unknown_system_substate_type:ident, $blueprint_ident:ident, $aggregator:ident, $key_type:tt, $key_payload_alias:ident, $value_type:tt, $value_payload_alias:ident, $allow_ownership:expr$(,)?) => {
             compile_error!(concat!(
                 "Unrecognized system collection substate type: `",
                 stringify!($unknown_system_substate_type),
@@ -867,36 +900,41 @@ mod helper_macros {
 
     macro_rules! map_type_ref {
         (
+            $blueprint_ident:ident,
             $aggregator:ident,
             {
                 kind: StaticSingleVersioned
                 $(,)?
             },
-            $content_alias:ident$(,)?
+            $payload_alias:ident$(,)?
         ) => {
-            TypeRef::Static($aggregator.add_child_type_and_descendents::<$content_alias>())
+            TypeRef::Static($aggregator.add_child_type_and_descendents::<$payload_alias>())
         };
         (
+            $blueprint_ident:ident,
             $aggregator:ident,
             {
                 kind: Static,
                 the_type: $static_type:ty
                 $(,)?
             },
-            $content_alias:ident$(,)?
+            $payload_alias:ident$(,)?
         ) => {
-            TypeRef::Static($aggregator.add_child_type_and_descendents::<$content_alias>())
+            TypeRef::Static($aggregator.add_child_type_and_descendents::<$payload_alias>())
         };
         (
+            $blueprint_ident:ident,
             $aggregator:ident,
             {
-                kind: Instance,
-                ident: $instance_ident:ident
+                kind: Generic,
+                ident: $generic_ident:ident
                 $(,)?
             },
-            $content_alias:ident$(,)?
+            $payload_alias:ident$(,)?
         ) => {
-            compile_error!("Instance schemas not yet supported - close though!")
+            paste::paste! {
+                TypeRef::Generic([<$blueprint_ident Generic>]::$generic_ident.generic_index())
+            }
         }; // TODO - Add support for some kind of StaticMultiVersioned type here
     }
 
@@ -990,8 +1028,13 @@ mod tests {
     declare_native_blueprint_state! {
         blueprint_ident: TestBlueprint,
         blueprint_snake_case: package,
+        generics: {
+            abc: {
+                ident: Abc,
+                description: "Some generic parameter called Abc",
+            }
+        },
         features: {},
-        instance_schema_types: {},
         fields: {
             royalty:  {
                 ident: Royalty,
@@ -999,6 +1042,14 @@ mod tests {
                     kind: StaticSingleVersioned,
                 },
                 condition: Condition::Always,
+            },
+            some_generic_field:  {
+                ident: GenericField,
+                field_type: {
+                    kind: Generic,
+                    ident: Abc,
+                },
+                condition: Condition::Always,
             }
         },
         collections: {
diff --git a/radix-engine/src/blueprints/package/substates.rs b/radix-engine/src/blueprints/package/substates.rs
index c88f27ea26d..edab0488f87 100644
--- a/radix-engine/src/blueprints/package/substates.rs
+++ b/radix-engine/src/blueprints/package/substates.rs
@@ -10,7 +10,6 @@ declare_native_blueprint_state! {
             description: "Enables the package royalty substate",
         }
     },
-    instance_schema_types: {},
     fields: {
         royalty:  {
             ident: RoyaltyAccumulator,
diff --git a/sbor-derive-common/src/utils.rs b/sbor-derive-common/src/utils.rs
index c58781ca1e7..82d7bcce2d5 100644
--- a/sbor-derive-common/src/utils.rs
+++ b/sbor-derive-common/src/utils.rs
@@ -371,13 +371,18 @@ fn get_child_types(attributes: &[Attribute], existing_generics: &Generics) -> Re
     parse_comma_separated_types(&comma_separated_types)
 }
 
-fn get_types_requiring_categorize_bound(
+fn get_types_requiring_categorize_bound_for_encode_and_decode(
     attributes: &[Attribute],
     child_types: &[Type],
 ) -> Result<Vec<Type>> {
     let Some(comma_separated_types) = get_sbor_attribute_string_value(attributes, "categorize_types")? else {
         // A categorize bound is only needed for child types when you have a collection, eg Vec<T>
         // But if no explicit "categorize_types" is set, we assume all are needed.
+        // > Note as of Aug 2023:
+        //   This is perhaps the wrong call.
+        //   In future, I'd suggest:
+        //   - Change this to assume none, and add categorize_child_types_for_encode if needed.
+        //   - Add separate categorize_child_types_for_categorize - and also default to not needed.
         // These can be removed / overriden with the "categorize_types" field
         return Ok(child_types.to_owned());
     };
@@ -572,7 +577,8 @@ pub fn build_decode_generics<'a>(
     let decoder_generic: Path = parse_str(&decoder_label)?;
 
     let child_types = get_child_types(&attributes, &impl_generics)?;
-    let categorize_types = get_types_requiring_categorize_bound(&attributes, &child_types)?;
+    let categorize_types =
+        get_types_requiring_categorize_bound_for_encode_and_decode(&attributes, &child_types)?;
 
     let mut where_clause = where_clause.cloned();
     if child_types.len() > 0 || categorize_types.len() > 0 {
@@ -637,7 +643,8 @@ pub fn build_encode_generics<'a>(
     let encoder_generic: Path = parse_str(&encoder_label)?;
 
     let child_types = get_child_types(&attributes, &impl_generics)?;
-    let categorize_types = get_types_requiring_categorize_bound(&attributes, &child_types)?;
+    let categorize_types =
+        get_types_requiring_categorize_bound_for_encode_and_decode(&attributes, &child_types)?;
 
     let mut where_clause = where_clause.cloned();
     if child_types.len() > 0 || categorize_types.len() > 0 {

From 6c6c0772316f2f1155eecee5462307bdff4c6d6a Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Thu, 17 Aug 2023 16:28:45 +0100
Subject: [PATCH 24/28] tweak: Output separate method for substate flashing

---
 .../models/native_blueprint_state_macro.rs    | 143 ++++++++++--------
 .../src/blueprints/package/package.rs         |   8 +-
 simulator/src/resim/cmd_publish.rs            |  10 +-
 3 files changed, 90 insertions(+), 71 deletions(-)

diff --git a/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs b/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
index 516d94760bb..6ce385465cb 100644
--- a/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
+++ b/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
@@ -617,70 +617,6 @@ macro_rules! declare_native_blueprint_state {
                         Ok((field_values_vec, collection_entries))
                     }
 
-                    /// This is used mostly for flashing
-                    pub fn into_kernel_main_partitions(self, feature_checks: [<$blueprint_ident FeatureChecks>]) -> Result<NodeSubstates, RuntimeError> {
-                        // PartitionNumber => SubstateKey => IndexedScryptoValue
-                        let mut partitions: NodeSubstates = BTreeMap::new();
-                        let (mut field_values, mut kv_entries) = self.into_system_substates(feature_checks)?;
-
-                        // Fields
-                        {
-                            let mut field_partition_substates = BTreeMap::new();
-                            for (field_index, field_value) in field_values {
-                                field_partition_substates.insert(
-                                    SubstateKey::Field(field_index),
-                                    IndexedScryptoValue::from_typed(&field_value),
-                                );
-                            }
-                            partitions.insert(
-                                [<$blueprint_ident Partition>]::Field.as_main_partition(),
-                                field_partition_substates,
-                            );
-                        }
-
-                        // Each Collection
-                        let mut collection_index = 0u8;
-                        $({
-                            let collection_kv_entries = kv_entries.remove(&collection_index).unwrap();
-                            let collection_partition = [<$blueprint_ident Partition>]::[<$collection_ident $collection_type>];
-                            let collection_partition_substates = collection_kv_entries
-                                .into_iter()
-                                .filter_map(|(key_bytes, kv_entry)| {
-                                    let substate = match kv_entry {
-                                        KVEntry { value: Some(value_bytes), locked: false } => {
-                                            KeyValueEntrySubstate::entry(
-                                                scrypto_decode::<ScryptoValue>(&value_bytes).unwrap()
-                                            )
-                                        }
-                                        KVEntry { value: Some(value_bytes), locked: true } => {
-                                            KeyValueEntrySubstate::locked_entry(
-                                                scrypto_decode::<ScryptoValue>(&value_bytes).unwrap()
-                                            )
-                                        }
-                                        KVEntry { value: None, locked: true } => {
-                                            KeyValueEntrySubstate::locked_empty_entry()
-                                        }
-                                        KVEntry { value: None, locked: false } => {
-                                            return None;
-                                        }
-                                    };
-
-                                    Some((
-                                        SubstateKey::Map(key_bytes),
-                                        IndexedScryptoValue::from_typed(&substate)
-                                    ))
-                                })
-                                .collect();
-                            partitions.insert(
-                                collection_partition.as_main_partition(),
-                                collection_partition_substates,
-                            );
-                            collection_index += 1;
-                        })*
-
-                        Ok(partitions)
-                    }
-
                     pub fn into_new_object<Y: ClientObjectApi<RuntimeError>>(
                         self,
                         api: &mut Y,
@@ -704,6 +640,85 @@ macro_rules! declare_native_blueprint_state {
                     }
                 }
 
+                //-------------
+                // Flashing
+                //-------------
+
+                /// This method converts the state init into the node substates,
+                /// at a kernel / flash level of abstraction.
+                ///
+                /// This can further be mapped to level 0 with a call to:
+                /// `.into_database_updates::<SpreadPrefixKeyMapper>(&node_id)`
+                ///
+                /// We decided to have this as a separate function away from
+                /// the impl of [<$blueprint_ident StateInit>], as it's conceptually
+                /// a helper method at a different abstraction level.
+                pub fn [<map_ $blueprint_property_name _state_into_main_partition_node_substate_flash>](
+                    state_init: [<$blueprint_ident StateInit>],
+                    feature_checks: [<$blueprint_ident FeatureChecks>],
+                ) -> Result<NodeSubstates, RuntimeError> {
+                    // PartitionNumber => SubstateKey => IndexedScryptoValue
+                    let mut partitions: NodeSubstates = BTreeMap::new();
+                    let (mut field_values, mut kv_entries) = state_init.into_system_substates(feature_checks)?;
+
+                    // Fields
+                    {
+                        let mut field_partition_substates = BTreeMap::new();
+                        for (field_index, field_value) in field_values {
+                            field_partition_substates.insert(
+                                SubstateKey::Field(field_index),
+                                IndexedScryptoValue::from_typed(&field_value),
+                            );
+                        }
+                        partitions.insert(
+                            [<$blueprint_ident Partition>]::Field.as_main_partition(),
+                            field_partition_substates,
+                        );
+                    }
+
+                    // Each Collection
+                    let mut collection_index = 0u8;
+                    $({
+                        let collection_kv_entries = kv_entries.remove(&collection_index).unwrap();
+                        let collection_partition = [<$blueprint_ident Partition>]::[<$collection_ident $collection_type>];
+                        let collection_partition_substates = collection_kv_entries
+                            .into_iter()
+                            .filter_map(|(key_bytes, kv_entry)| {
+                                let substate = match kv_entry {
+                                    KVEntry { value: Some(value_bytes), locked: false } => {
+                                        KeyValueEntrySubstate::entry(
+                                            scrypto_decode::<ScryptoValue>(&value_bytes).unwrap()
+                                        )
+                                    }
+                                    KVEntry { value: Some(value_bytes), locked: true } => {
+                                        KeyValueEntrySubstate::locked_entry(
+                                            scrypto_decode::<ScryptoValue>(&value_bytes).unwrap()
+                                        )
+                                    }
+                                    KVEntry { value: None, locked: true } => {
+                                        KeyValueEntrySubstate::locked_empty_entry()
+                                    }
+                                    KVEntry { value: None, locked: false } => {
+                                        return None;
+                                    }
+                                };
+
+                                Some((
+                                    SubstateKey::Map(key_bytes),
+                                    IndexedScryptoValue::from_typed(&substate)
+                                ))
+                            })
+                            .collect();
+                        partitions.insert(
+                            collection_partition.as_main_partition(),
+                            collection_partition_substates,
+                        );
+                        collection_index += 1;
+                    })*
+
+                    Ok(partitions)
+                }
+
                 //-------------
                 // State API (TODO!)
                 //-------------
diff --git a/radix-engine/src/blueprints/package/package.rs b/radix-engine/src/blueprints/package/package.rs
index 1519fbf78f3..43fc2376edd 100644
--- a/radix-engine/src/blueprints/package/package.rs
+++ b/radix-engine/src/blueprints/package/package.rs
@@ -509,9 +509,11 @@ pub fn create_bootstrap_package_partitions(
     // MAIN PARTITIONS:
     //-----------------
 
-    let mut partitions = package_state_init
-        .into_kernel_main_partitions(own_features.into())
-        .expect("Expected that correct substates are present for given features");
+    let mut partitions = map_package_state_into_main_partition_node_substate_flash(
+        package_state_init,
+        own_features.into(),
+    )
+    .expect("Expected that correct substates are present for given features");
 
     //-------------------
     // MODULE PARTITIONS:
diff --git a/simulator/src/resim/cmd_publish.rs b/simulator/src/resim/cmd_publish.rs
index d3d85ab6ae5..7eaff50a57d 100644
--- a/simulator/src/resim/cmd_publish.rs
+++ b/simulator/src/resim/cmd_publish.rs
@@ -186,10 +186,12 @@ impl Publish {
                     );
             }
 
-            let database_updates = package_state_to_set
-                .into_kernel_main_partitions(FeatureChecks::None)
-                .unwrap()
-                .into_database_updates::<SpreadPrefixKeyMapper>(&node_id);
+            let database_updates = map_package_state_into_main_partition_node_substate_flash(
+                package_state_to_set,
+                FeatureChecks::None,
+            )
+            .unwrap()
+            .into_database_updates::<SpreadPrefixKeyMapper>(&node_id);
             substate_db.commit(&database_updates);
 
             writeln!(out, "Package updated!").map_err(Error::IOError)?;

From c407711f3d0999173f9f5109e79854d0bb534222 Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Fri, 18 Aug 2023 21:57:18 +0100
Subject: [PATCH 25/28] tweak: Updates to the content traits

---
 .../src/data/scrypto/definitions.rs           |   2 +
 radix-engine/src/blueprints/models/content.rs | 194 +++++-
 .../models/native_blueprint_state_macro.rs    | 550 ++++++++++--------
 .../src/blueprints/package/package.rs         |   8 +-
 radix-engine/src/system/system.rs             |   8 +-
 radix-engine/src/system/system_db_reader.rs   |   4 +-
 radix-engine/src/vm/vm.rs                     |   5 +-
 sbor/src/versioned.rs                         |   8 +-
 scrypto-unit/src/test_runner.rs               |   4 +-
 simulator/src/ledger/dumper.rs                |   2 +-
 simulator/src/resim/mod.rs                    |   2 +-
 11 files changed, 492 insertions(+), 295 deletions(-)

diff --git a/radix-engine-common/src/data/scrypto/definitions.rs b/radix-engine-common/src/data/scrypto/definitions.rs
index 6290d825057..7b1cc61e672 100644
--- a/radix-engine-common/src/data/scrypto/definitions.rs
+++ b/radix-engine-common/src/data/scrypto/definitions.rs
@@ -8,6 +8,8 @@ pub type ScryptoDecoder<'a> = VecDecoder<'a, ScryptoCustomValueKind>;
 pub type ScryptoTraverser<'a> = VecTraverser<'a, ScryptoCustomTraversal>;
 pub type ScryptoValueKind = ValueKind<ScryptoCustomValueKind>;
 pub type ScryptoValue = Value<ScryptoCustomValueKind, ScryptoCustomValue>;
+pub type RawScryptoValue<'a> = RawValue<'a, ScryptoCustomExtension>;
+pub type RawScryptoPayload<'a> = RawPayload<'a, ScryptoCustomExtension>;
 
 // The following trait "aliases" are to be used in parameters.
 //
diff --git a/radix-engine/src/blueprints/models/content.rs b/radix-engine/src/blueprints/models/content.rs
index 77b92681910..bfd2fd8f07a 100644
--- a/radix-engine/src/blueprints/models/content.rs
+++ b/radix-engine/src/blueprints/models/content.rs
@@ -1,39 +1,195 @@
 use crate::internal_prelude::*;
 
-pub trait FieldContent<FieldPayload: From<Self>>: Sized {
-    fn into_locked_substate(self) -> FieldSubstate<FieldPayload> {
-        FieldSubstate::new_locked_field(self.into())
+macro_rules! declare_payload_new_type {
+    (
+        content_trait: $content_trait:ident,
+        payload_trait: $payload_trait:ident,
+        $(#[$attributes:meta])*
+        $vis:vis struct $payload_type_name:ident
+        $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? $( = $deflt:tt)? ),+ >)?
+        ($content_type:ty)$(;)?
+    ) => {
+        $(#[$attributes])*
+        #[sbor(transparent, categorize_types = "")]
+        $vis struct $payload_type_name
+            $(< $( $lt $( : $clt $(+ $dlt )* )? $( = $deflt)? ),+ >)?
+            (pub $content_type);
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            core::convert::From<$content_type>
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            fn from(value: $content_type) -> Self {
+                Self(value)
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            core::convert::AsRef<$content_type>
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            fn as_ref(&self) -> &$content_type {
+                &self.0
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            core::convert::AsMut<$content_type>
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            fn as_mut(&mut self) -> &mut $content_type {
+                &mut self.0
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            $payload_trait
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            type Content = $content_type;
+
+            fn into_content(self) -> Self::Content {
+                self.0
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            $content_trait<$payload_type_name$(< $( $lt ),+ >)?>
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            fn into_payload(self) -> $payload_type_name$(< $( $lt ),+ >)? {
+                self
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            $content_trait<$payload_type_name$(< $( $lt ),+ >)?>
+            for $content_type
+        {
+            fn into_payload(self) -> $payload_type_name$(< $( $lt ),+ >)? {
+                $payload_type_name(self)
+            }
+        }
+    }
+}
+#[allow(unused)]
+pub(crate) use declare_payload_new_type;
+
+pub trait FieldPayload: AsRef<Self::Content> + AsMut<Self::Content> + From<Self::Content> {
+    type Content: FieldContent<Self>;
+
+    fn into_content(self) -> Self::Content;
+
+    fn from_content<T: FieldContent<Self>>(content: T) -> Self
+    where
+        Self: From<T>,
+    {
+        content.into_payload()
+    }
+}
+
+pub trait FieldContent<Payload: FieldPayload>: Sized {
+    fn into_payload(self) -> Payload;
+
+    fn into_locked_substate(self) -> FieldSubstate<Payload> {
+        FieldSubstate::new_locked_field(self.into_payload())
+    }
+
+    fn into_mutable_substate(self) -> FieldSubstate<Payload> {
+        FieldSubstate::new_field(self.into_payload())
+    }
+}
+
+pub trait KeyPayload: AsRef<Self::Content> + AsMut<Self::Content> + From<Self::Content> {
+    type Content: KeyContent<Self>;
+
+    fn into_content(self) -> Self::Content;
+
+    fn from_content<T: KeyContent<Self>>(content: T) -> Self
+    where
+        Self: From<T>,
+    {
+        content.into_key()
+    }
+}
+
+pub trait KeyContent<Payload: KeyPayload>: Sized {
+    fn into_payload(self) -> Payload;
+
+    fn into_key(self) -> Payload {
+        self.into_payload()
     }
+}
+
+pub trait KeyValueEntryPayload:
+    AsRef<Self::Content> + AsMut<Self::Content> + From<Self::Content>
+{
+    type Content: KeyValueEntryContent<Self>;
+
+    fn into_content(self) -> Self::Content;
 
-    fn into_mutable_substate(self) -> FieldSubstate<FieldPayload> {
-        FieldSubstate::new_field(self.into())
+    fn from_content<T: KeyValueEntryContent<Self>>(content: T) -> Self
+    where
+        Self: From<T>,
+    {
+        content.into_payload()
     }
 }
 
-pub trait KeyContent<KeyPayload: From<Self>>: Sized {
-    fn into_key(self) -> KeyPayload {
-        self.into()
+pub trait KeyValueEntryContent<Payload: KeyValueEntryPayload>: Sized {
+    fn into_payload(self) -> Payload;
+
+    fn into_locked_substate(self) -> KeyValueEntrySubstate<Payload> {
+        KeyValueEntrySubstate::entry(self.into_payload())
+    }
+
+    fn into_mutable_substate(self) -> KeyValueEntrySubstate<Payload> {
+        KeyValueEntrySubstate::locked_entry(self.into_payload())
     }
 }
 
-pub trait KeyValueEntryContent<EntryPayload: From<Self>>: Sized {
-    fn into_locked_substate(self) -> KeyValueEntrySubstate<EntryPayload> {
-        KeyValueEntrySubstate::entry(self.into())
+pub trait IndexEntryPayload:
+    AsRef<Self::Content> + AsMut<Self::Content> + From<Self::Content>
+{
+    type Content: IndexEntryContent<Self>;
+
+    fn into_content(self) -> Self::Content;
+
+    fn from_content<T: IndexEntryContent<Self>>(content: T) -> Self
+    where
+        Self: From<T>,
+    {
+        content.into_payload()
     }
+}
+
+pub trait IndexEntryContent<Payload: IndexEntryPayload>: Sized {
+    fn into_payload(self) -> Payload;
 
-    fn into_mutable_substate(self) -> KeyValueEntrySubstate<EntryPayload> {
-        KeyValueEntrySubstate::locked_entry(self.into())
+    fn into_substate(self) -> Payload {
+        self.into_payload()
     }
 }
 
-pub trait IndexEntryContent<EntryPayload: From<Self>>: Sized {
-    fn into_substate(self) -> EntryPayload {
-        self.into()
+pub trait SortedIndexEntryPayload:
+    AsRef<Self::Content> + AsMut<Self::Content> + From<Self::Content>
+{
+    type Content: SortedIndexEntryContent<Self>;
+
+    fn into_content(self) -> Self::Content;
+
+    fn from_content<T: SortedIndexEntryContent<Self>>(content: T) -> Self
+    where
+        Self: From<T>,
+    {
+        content.into_payload()
     }
 }
 
-pub trait SortedIndexEntryContent<EntryPayload: From<Self>>: Sized {
-    fn into_substate(self) -> EntryPayload {
-        self.into()
+pub trait SortedIndexEntryContent<Payload: SortedIndexEntryPayload>: Sized {
+    fn into_payload(self) -> Payload;
+
+    fn into_substate(self) -> Payload {
+        self.into_payload()
     }
 }
diff --git a/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs b/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
index 6ce385465cb..a1e50bd613d 100644
--- a/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
+++ b/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
@@ -145,6 +145,7 @@ macro_rules! declare_native_blueprint_state {
                     // > Set up the FieldContent trait for anything which can be resolved into the field payload
                     generate_content_type!(
                         content_trait: FieldContent,
+                        payload_trait: FieldPayload,
                         ident_core: [<$blueprint_ident $field_ident>],
                         #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
                         struct [<$blueprint_ident $field_ident FieldPayload>] = $field_type
@@ -167,6 +168,7 @@ macro_rules! declare_native_blueprint_state {
                     // > Set up the KeyContent traits for anything which can be resolved into a key
                     generate_content_type!(
                         content_trait: KeyContent,
+                        payload_trait: KeyPayload,
                         ident_core: [<$blueprint_ident $collection_ident KeyInner>],
                         #[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, ScryptoSbor)]
                         #[sbor(transparent_name)]
@@ -190,13 +192,18 @@ macro_rules! declare_native_blueprint_state {
                     }
 
                     // Values
-                    // > Set up Versioned types (if relevant). Assumes __ValueV1 exists and then creates
-                    //   - Versioned__Value
-                    //   - __Value (alias for __ValueV1)
-                    // > Set up the (transparent) _ValueContent new type for the value content
-                    // > Set up the _EntryContent traits
+                    // > If relevant, set up Versioned types, which:
+                    //   - Assumes [BlueprintCollection]V1 exists
+                    //   - Creates Versioned[BlueprintCollection] enum
+                    //   - Creates [BlueprintCollection] as a "latest" type alias for [BlueprintCollection]V1
+                    // > Set up the [BlueprintCollection]EntryPayload transparent new type for the value content
+                    // > Set up the [Collectiontype]EntryContent::<[BlueprintCollection]EntryPayload> trait for:
+                    //   - The [BlueprintCollection] if it exists
+                    //   - The Versioned[BlueprintCollection] if it exists
+                    //   - The static content type, if it exists
                     generate_content_type!(
                         content_trait: [<$collection_type EntryContent>],
+                        payload_trait: [<$collection_type EntryPayload>],
                         ident_core: [<$blueprint_ident $collection_ident>],
                         #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
                         struct [<$blueprint_ident $collection_ident EntryPayload>] = $collection_value_type
@@ -208,8 +215,49 @@ macro_rules! declare_native_blueprint_state {
                     );
                 )*
 
+                //-------------------------------------
+                // System - Generate schema definitions
+                //-------------------------------------
+                pub struct [<$blueprint_ident StateSchemaInit>];
+
+                impl [<$blueprint_ident StateSchemaInit>] {
+                    pub fn create_schema_init(
+                        type_aggregator: &mut TypeAggregator<ScryptoCustomTypeKind>,
+                    ) -> BlueprintStateSchemaInit {
+                        let mut fields = vec![];
+                        $(
+                            fields.push(FieldSchema {
+                                field: map_type_ref!(
+                                    $blueprint_ident,
+                                    type_aggregator,
+                                    $field_type,
+                                    [<$blueprint_ident $field_ident FieldPayload>],
+                                ),
+                                condition: $field_condition,
+                            });
+                        )*
+                        let mut collections = vec![];
+                        $(
+                            collections.push(map_collection_schema!(
+                                $collection_type,
+                                $blueprint_ident,
+                                type_aggregator,
+                                $collection_key_type,
+                                [<$blueprint_ident $collection_ident KeyPayload>],
+                                $collection_value_type,
+                                [<$blueprint_ident $collection_ident EntryPayload>],
+                                $collection_allow_ownership
+                            ));
+                        )*
+                        BlueprintStateSchemaInit {
+                            fields,
+                            collections,
+                        }
+                    }
+                }
+
                 //--------------------------------------------------------
-                // Node Layout (to replace node_layout.rs)
+                // System - Fields, Collections, Features and Generics
                 //--------------------------------------------------------
                 #[repr(u8)]
                 #[derive(Debug, Clone, Copy, Sbor, PartialEq, Eq, Hash, PartialOrd, Ord, FromRepr)]
@@ -248,93 +296,6 @@ macro_rules! declare_native_blueprint_state {
                     }
                 }
 
-                /// A list of all logical (real) and physical (mapped) partitions for the
-                /// $blueprint_ident blueprint.
-                ///
-                /// Note: In future, we could add a separate LogicalPartition enum, to
-                /// not include physical partitions - however it's very hard to do in
-                /// declarative macro land, because enum variants can't be
-                /// macro invocations (to eg filter out the physical partition types)
-                #[repr(u8)]
-                #[derive(Debug, Clone, Copy, Sbor, PartialEq, Eq, Hash, PartialOrd, Ord)]
-                pub enum [<$blueprint_ident Partition>] {
-                    Field,
-                    $([<$collection_ident $collection_type>],)*
-                }
-
-                impl [<$blueprint_ident Partition>] {
-                    pub const fn description(&self) -> PartitionDescription {
-                        // NOTE: This should really be a fixed mapping - but it's hard to do with declarative macros
-                        // It's a const function, so might hopefully be compiled away
-                        let mut module_partition_offset = 0;
-                        if (*self as u8) == (Self::Field as u8) {
-                            return PartitionDescription::Logical(PartitionOffset(module_partition_offset));
-                        }
-                        $(
-                            let mapped_physical_partition = extract_collection_option!(
-                                mapped_physical_partition,
-                                $($collection_options)?
-                            );
-                            let current_partition_description = match mapped_physical_partition {
-                                Some(physical_partition) => {
-                                    PartitionDescription::Physical(physical_partition)
-                                },
-                                None => {
-                                    module_partition_offset += 1;
-                                    PartitionDescription::Logical(PartitionOffset(module_partition_offset))
-                                },
-                            };
-                            if (*self as u8) == (Self::[<$collection_ident $collection_type>] as u8) {
-                                return current_partition_description;
-                            }
-                        )*
-                        panic!("Partition somehow did not match for calculating its description")
-                    }
-
-                    pub const fn as_main_partition(&self) -> PartitionNumber {
-                        match self.description() {
-                            PartitionDescription::Physical(partition_num) => partition_num,
-                            PartitionDescription::Logical(offset) => {
-                                match MAIN_BASE_PARTITION.at_offset(offset) {
-                                    // This map works around unwrap/expect on Option not being const
-                                    Some(x) => x,
-                                    None => panic!("Offset larger than allowed value")
-                                }
-                            }
-                        }
-                    }
-                }
-
-                impl TryFrom<[<$blueprint_ident Partition>]> for PartitionOffset {
-                    type Error = ();
-
-                    fn try_from(value: [<$blueprint_ident Partition>]) -> Result<Self, Self::Error> {
-                        match value.description() {
-                            PartitionDescription::Logical(offset) => Ok(offset),
-                            PartitionDescription::Physical(partition_num) => Err(()),
-                        }
-                    }
-                }
-
-                impl TryFrom<PartitionOffset> for [<$blueprint_ident Partition>] {
-                    type Error = ();
-
-                    fn try_from(offset: PartitionOffset) -> Result<Self, Self::Error> {
-                        // NOTE: This should really be a fixed mapping - but it's hard to do with declarative macros
-                        // Hopefully this will be compiled away because Partition::description is const
-                        let description = PartitionDescription::Logical(offset);
-                        if description == Self::Field.description() {
-                            return Ok(Self::Field);
-                        }
-                        $(
-                            if description == Self::[<$collection_ident $collection_type>].description() {
-                                return Ok(Self::[<$collection_ident $collection_type>]);
-                            }
-                        )*
-                        Err(())
-                    }
-                }
-
                 #[repr(u8)]
                 #[derive(Debug, Clone, Copy, Sbor, PartialEq, Eq, Hash, PartialOrd, Ord, FromRepr)]
                 pub enum [<$blueprint_ident Collection>] {
@@ -405,128 +366,31 @@ macro_rules! declare_native_blueprint_state {
                     }
                 }
 
-                //---------------------------------
-                // Typed Substate - Keys and Values
-                //---------------------------------
-                #[derive(Debug, Clone)]
-                /// All the SubstateKeys for all logical (real) and physical (mapped)
-                /// partitions for the $blueprint_ident blueprint.
-                ///
-                /// Note: In future, we could remove keys for physical partitions from this,
-                /// as they can't be persisted as-is - however it's very hard to do in
-                /// declarative macro land, because enum variants can't be
-                /// macro invocations (to eg filter out the physical partition types)
-                pub enum [<$blueprint_ident TypedSubstateKey>] {
-                    Fields([<$blueprint_ident Field>]),
-                    $([<$collection_ident $collection_type Entries>]([<$blueprint_ident $collection_ident SubstateKey>]),)*
-                }
-
-                impl [<$blueprint_ident TypedSubstateKey>] {
-                    pub fn for_key_in_partition(partition: &[<$blueprint_ident Partition>], substate_key: &SubstateKey) -> Result<Self, ()> {
-                        let key = match partition {
-                            [<$blueprint_ident Partition>]::Field => {
-                                [<$blueprint_ident TypedSubstateKey>]::Fields(
-                                    [<$blueprint_ident Field>]::try_from(substate_key)?
-                                )
-                            }
-                            $(
-                                [<$blueprint_ident Partition>]::[<$collection_ident $collection_type>] => {
-                                    [<$blueprint_ident TypedSubstateKey>]::[<$collection_ident $collection_type Entries>](
-                                        [<$blueprint_ident $collection_ident SubstateKey>]::try_from(substate_key)?,
-                                    )
-                                }
-                            )*
-                        };
-                        Ok(key)
-                    }
-                }
-
-                #[derive(Debug)]
-                pub enum [<$blueprint_ident TypedFieldSubstateValue>] {
-                    $($field_ident([<$blueprint_ident $field_ident FieldSubstate>]),)*
-                }
+                //--------------------------------------
+                // Application - Typed State API (TODO!)
+                //--------------------------------------
 
-                #[derive(Debug)]
-                /// All the Substate values for all logical (real) and physical (mapped)
-                /// partitions for the $blueprint_ident blueprint.
-                ///
-                /// Note: In future, we could remove values for physical partitions from this,
-                /// as they can't be persisted as-is - however it's very hard to do in
-                /// declarative macro land, because enum variants can't be
-                /// macro invocations (to eg filter out the physical partition types)
-                pub enum [<$blueprint_ident TypedSubstateValue>] {
-                    Field([<$blueprint_ident TypedFieldSubstateValue>]),
-                    $([<$collection_ident $collection_type>]([<$blueprint_ident $collection_ident EntrySubstate>]),)*
+                pub struct [<$blueprint_ident StateApi>]<'a, Y: ClientApi<RuntimeError>> {
+                    api: &'a mut Y,
                 }
 
-                impl [<$blueprint_ident TypedSubstateValue>] {
-                    pub fn from_key_and_data(key: &[<$blueprint_ident TypedSubstateKey>], data: &[u8]) -> Result<Self, DecodeError> {
-                        let substate_value = match key {
-                            // Fields
-                            $(
-                                [<$blueprint_ident TypedSubstateKey>]::Fields([<$blueprint_ident Field>]::$field_ident) => {
-                                    [<$blueprint_ident TypedSubstateValue>]::Field(
-                                        [<$blueprint_ident TypedFieldSubstateValue>]::$field_ident(scrypto_decode(data)?)
-                                    )
-                                }
-                            )*
-                            // Collections
-                            $(
-                                [<$blueprint_ident TypedSubstateKey>]::[<$collection_ident $collection_type Entries>](_) => {
-                                    [<$blueprint_ident TypedSubstateValue>]::[<$collection_ident $collection_type>](
-                                        scrypto_decode(data)?
-                                    )
-                                }
-                            )*
-                        };
-                        Ok(substate_value)
+                impl<'a, Y: ClientApi<RuntimeError>> [<$blueprint_ident StateApi>]<'a, Y> {
+                    pub fn with(client_api: &'a mut Y) -> Self {
+                        Self {
+                            api: client_api,
+                        }
                     }
                 }
 
-                //----------------------
-                // Schema
-                //----------------------
-                pub struct [<$blueprint_ident StateSchemaInit>];
-
-                impl [<$blueprint_ident StateSchemaInit>] {
-                    pub fn create_schema_init(
-                        type_aggregator: &mut TypeAggregator<ScryptoCustomTypeKind>,
-                    ) -> BlueprintStateSchemaInit {
-                        let mut fields = vec![];
-                        $(
-                            fields.push(FieldSchema {
-                                field: map_type_ref!(
-                                    $blueprint_ident,
-                                    type_aggregator,
-                                    $field_type,
-                                    [<$blueprint_ident $field_ident FieldPayload>],
-                                ),
-                                condition: $field_condition,
-                            });
-                        )*
-                        let mut collections = vec![];
-                        $(
-                            collections.push(map_collection_schema!(
-                                $collection_type,
-                                $blueprint_ident,
-                                type_aggregator,
-                                $collection_key_type,
-                                [<$blueprint_ident $collection_ident KeyPayload>],
-                                $collection_value_type,
-                                [<$blueprint_ident $collection_ident EntryPayload>],
-                                $collection_allow_ownership
-                            ));
-                        )*
-                        BlueprintStateSchemaInit {
-                            fields,
-                            collections,
-                        }
+                impl<'a, Y: ClientApi<$crate::errors::RuntimeError>> From<&'a mut Y> for [<$blueprint_ident StateApi>]<'a, Y> {
+                    fn from(value: &'a mut Y) -> Self {
+                        Self::with(value)
                     }
                 }
 
-                //----------------------
-                // Object Initialization
-                //----------------------
+                //--------------------------------
+                // System - Object Initialization
+                //--------------------------------
 
                 /// Used for initializing blueprint state.
                 ///
@@ -562,7 +426,7 @@ macro_rules! declare_native_blueprint_state {
                                     self.$field_property_name.is_some(),
                                 )?;
                                 if let Some(field) = self.$field_property_name {
-                                    let field_content = scrypto_encode(&field.field_content()).unwrap();
+                                    let payload = scrypto_encode(&field.payload()).unwrap();
                                     let locked = match &field.mutability {
                                         SubstateMutability::Mutable => true,
                                         SubstateMutability::Immutable => false,
@@ -570,7 +434,7 @@ macro_rules! declare_native_blueprint_state {
                                     field_values.insert(
                                         [<$blueprint_ident Field>]::$field_ident.into(),
                                         FieldValue {
-                                            value: field_content,
+                                            value: payload,
                                             locked,
                                         }
                                     );
@@ -640,6 +504,177 @@ macro_rules! declare_native_blueprint_state {
                     }
                 }
 
+
+                //--------------------------------------------------------
+                // System/DB - Node Partitions & Layout
+                //--------------------------------------------------------
+
+                /// A list of all logical (real) and physical (mapped) partitions for the
+                /// $blueprint_ident blueprint.
+                ///
+                /// Note: In future, we could add a separate LogicalPartition enum, to
+                /// not include physical partitions - however it's very hard to do in
+                /// declarative macro land, because enum variants can't be
+                /// macro invocations (to eg filter out the physical partition types)
+                #[repr(u8)]
+                #[derive(Debug, Clone, Copy, Sbor, PartialEq, Eq, Hash, PartialOrd, Ord)]
+                pub enum [<$blueprint_ident Partition>] {
+                    Field,
+                    $([<$collection_ident $collection_type>],)*
+                }
+
+                impl [<$blueprint_ident Partition>] {
+                    pub const fn description(&self) -> PartitionDescription {
+                        // NOTE: This should really be a fixed mapping - but it's hard to do with declarative macros
+                        // It's a const function, so might hopefully be compiled away
+                        let mut module_partition_offset = 0;
+                        if (*self as u8) == (Self::Field as u8) {
+                            return PartitionDescription::Logical(PartitionOffset(module_partition_offset));
+                        }
+                        $(
+                            let mapped_physical_partition = extract_collection_option!(
+                                mapped_physical_partition,
+                                $($collection_options)?
+                            );
+                            let current_partition_description = match mapped_physical_partition {
+                                Some(physical_partition) => {
+                                    PartitionDescription::Physical(physical_partition)
+                                },
+                                None => {
+                                    module_partition_offset += 1;
+                                    PartitionDescription::Logical(PartitionOffset(module_partition_offset))
+                                },
+                            };
+                            if (*self as u8) == (Self::[<$collection_ident $collection_type>] as u8) {
+                                return current_partition_description;
+                            }
+                        )*
+                        panic!("Partition somehow did not match for calculating its description")
+                    }
+
+                    pub const fn as_main_partition(&self) -> PartitionNumber {
+                        match self.description() {
+                            PartitionDescription::Physical(partition_num) => partition_num,
+                            PartitionDescription::Logical(offset) => {
+                                match MAIN_BASE_PARTITION.at_offset(offset) {
+                                    // This map works around unwrap/expect on Option not being const
+                                    Some(x) => x,
+                                    None => panic!("Offset larger than allowed value")
+                                }
+                            }
+                        }
+                    }
+                }
+
+                impl TryFrom<[<$blueprint_ident Partition>]> for PartitionOffset {
+                    type Error = ();
+
+                    fn try_from(value: [<$blueprint_ident Partition>]) -> Result<Self, Self::Error> {
+                        match value.description() {
+                            PartitionDescription::Logical(offset) => Ok(offset),
+                            PartitionDescription::Physical(partition_num) => Err(()),
+                        }
+                    }
+                }
+
+                impl TryFrom<PartitionOffset> for [<$blueprint_ident Partition>] {
+                    type Error = ();
+
+                    fn try_from(offset: PartitionOffset) -> Result<Self, Self::Error> {
+                        // NOTE: This should really be a fixed mapping - but it's hard to do with declarative macros
+                        // Hopefully this will be compiled away because Partition::description is const
+                        let description = PartitionDescription::Logical(offset);
+                        if description == Self::Field.description() {
+                            return Ok(Self::Field);
+                        }
+                        $(
+                            if description == Self::[<$collection_ident $collection_type>].description() {
+                                return Ok(Self::[<$collection_ident $collection_type>]);
+                            }
+                        )*
+                        Err(())
+                    }
+                }
+
+                //---------------------------------
+                // Typed - Substate Keys and Values
+                //---------------------------------
+
+                /// All the SubstateKeys for all logical (real) and physical (mapped)
+                /// partitions for the $blueprint_ident blueprint.
+                ///
+                /// Note: In future, we could remove keys for physical partitions from this,
+                /// as they can't be persisted as-is - however it's very hard to do in
+                /// declarative macro land, because enum variants can't be
+                /// macro invocations (to eg filter out the physical partition types)
+                #[derive(Debug, Clone)]
+                pub enum [<$blueprint_ident TypedSubstateKey>] {
+                    Fields([<$blueprint_ident Field>]),
+                    $([<$collection_ident $collection_type Entries>]([<$blueprint_ident $collection_ident SubstateKey>]),)*
+                }
+
+                impl [<$blueprint_ident TypedSubstateKey>] {
+                    pub fn for_key_in_partition(partition: &[<$blueprint_ident Partition>], substate_key: &SubstateKey) -> Result<Self, ()> {
+                        let key = match partition {
+                            [<$blueprint_ident Partition>]::Field => {
+                                [<$blueprint_ident TypedSubstateKey>]::Fields(
+                                    [<$blueprint_ident Field>]::try_from(substate_key)?
+                                )
+                            }
+                            $(
+                                [<$blueprint_ident Partition>]::[<$collection_ident $collection_type>] => {
+                                    [<$blueprint_ident TypedSubstateKey>]::[<$collection_ident $collection_type Entries>](
+                                        [<$blueprint_ident $collection_ident SubstateKey>]::try_from(substate_key)?,
+                                    )
+                                }
+                            )*
+                        };
+                        Ok(key)
+                    }
+                }
+
+                #[derive(Debug)]
+                pub enum [<$blueprint_ident TypedFieldSubstateValue>] {
+                    $($field_ident([<$blueprint_ident $field_ident FieldSubstate>]),)*
+                }
+
+                #[derive(Debug)]
+                /// All the Substate values for all logical (real) and physical (mapped)
+                /// partitions for the $blueprint_ident blueprint.
+                ///
+                /// Note: In future, we could remove values for physical partitions from this,
+                /// as they can't be persisted as-is - however it's very hard to do in
+                /// declarative macro land, because enum variants can't be
+                /// macro invocations (to eg filter out the physical partition types)
+                pub enum [<$blueprint_ident TypedSubstateValue>] {
+                    Field([<$blueprint_ident TypedFieldSubstateValue>]),
+                    $([<$collection_ident $collection_type>]([<$blueprint_ident $collection_ident EntrySubstate>]),)*
+                }
+
+                impl [<$blueprint_ident TypedSubstateValue>] {
+                    pub fn from_key_and_data(key: &[<$blueprint_ident TypedSubstateKey>], data: &[u8]) -> Result<Self, DecodeError> {
+                        let substate_value = match key {
+                            // Fields
+                            $(
+                                [<$blueprint_ident TypedSubstateKey>]::Fields([<$blueprint_ident Field>]::$field_ident) => {
+                                    [<$blueprint_ident TypedSubstateValue>]::Field(
+                                        [<$blueprint_ident TypedFieldSubstateValue>]::$field_ident(scrypto_decode(data)?)
+                                    )
+                                }
+                            )*
+                            // Collections
+                            $(
+                                [<$blueprint_ident TypedSubstateKey>]::[<$collection_ident $collection_type Entries>](_) => {
+                                    [<$blueprint_ident TypedSubstateValue>]::[<$collection_ident $collection_type>](
+                                        scrypto_decode(data)?
+                                    )
+                                }
+                            )*
+                        };
+                        Ok(substate_value)
+                    }
+                }
+
                 //-------------
                 // Flashing
                 //-------------
@@ -718,28 +753,6 @@ macro_rules! declare_native_blueprint_state {
 
                     Ok(partitions)
                 }
-
-                //-------------
-                // State API (TODO!)
-                //-------------
-
-                pub struct [<$blueprint_ident StateApi>]<'a, Y: ClientApi<RuntimeError>> {
-                    api: &'a mut Y,
-                }
-
-                impl<'a, Y: ClientApi<RuntimeError>> [<$blueprint_ident StateApi>]<'a, Y> {
-                    pub fn with(client_api: &'a mut Y) -> Self {
-                        Self {
-                            api: client_api,
-                        }
-                    }
-                }
-
-                impl<'a, Y: ClientApi<$crate::errors::RuntimeError>> From<&'a mut Y> for [<$blueprint_ident StateApi>]<'a, Y> {
-                    fn from(value: &'a mut Y) -> Self {
-                        Self::with(value)
-                    }
-                }
             }
         }
     }
@@ -761,9 +774,10 @@ mod helper_macros {
     macro_rules! generate_content_type {
         (
             content_trait: $content_trait:ident,
+            payload_trait: $payload_trait:ident,
             ident_core: $ident_core:ident,
             $(#[$attributes:meta])*
-            struct $content_type_name:ident = {
+            struct $payload_type_name:ident = {
                 kind: StaticSingleVersioned
                 $(,)?
             }$(,)?
@@ -773,59 +787,81 @@ mod helper_macros {
                     $(#[$attributes])*
                     pub enum [<Versioned $ident_core>] => $ident_core = [<$ident_core V1>]
                 );
-                $(#[$attributes])*
-                #[sbor(transparent)]
-                pub struct $content_type_name(pub [<Versioned $ident_core>]);
-                impl From<[<Versioned $ident_core>]> for $content_type_name {
-                    fn from(value: [<Versioned $ident_core>]) -> Self {
-                        Self(value)
+                declare_payload_new_type!(
+                    content_trait: $content_trait,
+                    payload_trait: $payload_trait,
+                    $(#[$attributes])*
+                    pub struct $payload_type_name([<Versioned $ident_core>]);
+                );
+
+                impl HasLatestVersion for $payload_type_name
+                {
+                    type Latest = <[<Versioned $ident_core>] as HasLatestVersion>::Latest;
+                    fn into_latest(self) -> Self::Latest {
+                        self.into_content().into_latest()
+                    }
+
+                    fn as_latest_ref(&self) -> Option<&Self::Latest> {
+                        self.as_ref().as_latest_ref()
                     }
                 }
-                impl $content_trait<$content_type_name> for [<Versioned $ident_core>] {}
-                // Also add impls from the "latest" type
-                impl From<$ident_core> for $content_type_name {
-                    fn from(value: $ident_core) -> Self {
-                        Self(value.into())
+
+                // Now implement other relevant content traits, for:
+                // > The "latest" type: $ident_core
+                impl $content_trait<$payload_type_name> for $ident_core {
+                    fn into_payload(self) -> $payload_type_name {
+                        $payload_type_name(self.into())
                     }
                 }
-                impl $content_trait<$content_type_name> for $ident_core {}
             }
         };
         (
             content_trait: $content_trait:ident,
+            payload_trait: $payload_trait:ident,
             ident_core: $ident_core:ident,
             $(#[$attributes:meta])*
-            struct $content_type_name:ident = {
+            struct $payload_type_name:ident = {
                 kind: Static,
                 the_type: $static_type:ty
                 $(,)?
             }$(,)?
         ) => {
             paste::paste! {
-                $(#[$attributes])*
-                #[sbor(transparent)]
-                pub struct $content_type_name(pub $static_type);
-                impl From<$static_type> for $content_type_name {
-                    fn from(value: $static_type) -> Self {
-                        Self(value)
-                    }
-                }
-                impl $content_trait<$content_type_name> for $static_type {}
+                declare_payload_new_type!(
+                    content_trait: $content_trait,
+                    payload_trait: $payload_trait,
+                    $(#[$attributes])*
+                    pub struct $payload_type_name($static_type);
+                );
             }
         };
         (
             content_trait: $content_trait:ident,
+            payload_trait: $payload_trait:ident,
             ident_core: $ident_core:ident,
             $(#[$attributes:meta])*
-            struct $content_type_name:ident = {
+            struct $payload_type_name:ident = {
                 kind: Generic,
                 ident: $generic_ident:ident
                 $(,)?
             }
         ) => {
-            $(#[$attributes])*
-            #[sbor(transparent, categorize_types = "")]
-            pub struct $content_type_name<$generic_ident: ScryptoEncode + ScryptoDecode = ScryptoValue>(pub $generic_ident);
+            paste::paste! {
+                declare_payload_new_type!(
+                    content_trait: $content_trait,
+                    payload_trait: $payload_trait,
+                    $(#[$attributes])*
+                    pub struct $payload_type_name<$generic_ident: [<$ident_core ContentMarker>] = ScryptoValue>($generic_ident);
+                );
+                // We choose to create an explicit marker trait, as an alternative to a blanket impl
+                // over ScryptoEncode + ScryptoDecode. Any explicit types can implement this trait.
+                // This avoids every type getting implementations for every such generic type,
+                // which would require disambiguation everywhere `to_substate()` is used.
+                // Anyone needing a type implementing content can use the payload type itself
+                pub trait [<$ident_core ContentMarker>]: ScryptoEncode + ScryptoDecode {}
+                impl [<$ident_core ContentMarker>] for ScryptoValue {}
+                impl [<$ident_core ContentMarker>] for RawScryptoValue<'_> {}
+            }
         };
         // TODO - Add support for some kind of StaticMultiVersioned type here
     }
diff --git a/radix-engine/src/blueprints/package/package.rs b/radix-engine/src/blueprints/package/package.rs
index 43fc2376edd..2b95ebe0300 100644
--- a/radix-engine/src/blueprints/package/package.rs
+++ b/radix-engine/src/blueprints/package/package.rs
@@ -1134,7 +1134,7 @@ impl PackageRoyaltyNativeBlueprint {
 
         let royalty_charge = substate
             .value
-            .and_then(|royalty_config| match royalty_config.0.into_latest() {
+            .and_then(|royalty_config| match royalty_config.into_latest() {
                 PackageRoyaltyConfig::Enabled(royalty_amounts) => {
                     royalty_amounts.get(ident).cloned()
                 }
@@ -1154,7 +1154,7 @@ impl PackageRoyaltyNativeBlueprint {
             let substate: PackageRoyaltyAccumulatorFieldSubstate =
                 api.kernel_read_substate(handle)?.as_typed().unwrap();
 
-            let vault_id = substate.value.0 .0.into_latest().royalty_vault.0;
+            let vault_id = substate.into_payload().into_latest().royalty_vault.0;
             let package_address = PackageAddress::new_or_panic(receiver.0);
             apply_royalty_cost(
                 api,
@@ -1188,7 +1188,7 @@ impl PackageRoyaltyNativeBlueprint {
         )?;
 
         let substate: PackageRoyaltyAccumulatorFieldPayload = api.field_read_typed(handle)?;
-        let bucket = substate.0.into_latest().royalty_vault.take_all(api)?;
+        let bucket = substate.into_latest().royalty_vault.take_all(api)?;
 
         Ok(bucket)
     }
@@ -1277,7 +1277,7 @@ impl PackageAuthNativeBlueprint {
         api.kernel_close_substate(handle)?;
 
         let template = match auth_template.value {
-            Some(template) => template.0.into_latest(),
+            Some(template) => template.into_latest(),
             None => {
                 return Err(RuntimeError::SystemError(
                     SystemError::AuthTemplateDoesNotExist(package_bp_version_id),
diff --git a/radix-engine/src/system/system.rs b/radix-engine/src/system/system.rs
index ef6180070e6..dd047197338 100644
--- a/radix-engine/src/system/system.rs
+++ b/radix-engine/src/system/system.rs
@@ -83,9 +83,13 @@ impl<V> FieldSubstate<V> {
         }
     }
 
-    pub fn field_content(&self) -> &V {
+    pub fn payload(&self) -> &V {
         &self.value.0
     }
+
+    pub fn into_payload(self) -> V {
+        self.value.0
+    }
 }
 
 pub type KeyValueEntrySubstate<V> = DynSubstate<Option<V>>;
@@ -391,7 +395,7 @@ where
         self.api.kernel_close_substate(handle)?;
 
         let definition = match substate.value {
-            Some(definition) => definition.0.into_latest(),
+            Some(definition) => definition.into_latest(),
             None => {
                 return Err(RuntimeError::SystemError(
                     SystemError::BlueprintDoesNotExist(canonical_bp_id),
diff --git a/radix-engine/src/system/system_db_reader.rs b/radix-engine/src/system/system_db_reader.rs
index 0d8f452fc15..90f663b99de 100644
--- a/radix-engine/src/system/system_db_reader.rs
+++ b/radix-engine/src/system/system_db_reader.rs
@@ -101,7 +101,7 @@ impl<'a, S: SubstateDatabase> SystemDatabaseReader<'a, S> {
 
             blueprints.insert(
                 bp_version_key,
-                blueprint_definition.value.unwrap().0.into_latest(),
+                blueprint_definition.value.unwrap().into_latest(),
             );
         }
 
@@ -137,7 +137,7 @@ impl<'a, S: SubstateDatabase> SystemDatabaseReader<'a, S> {
                 &SubstateKey::Map(scrypto_encode(&bp_version_key).unwrap()),
             )?;
 
-        definition.value.map(|v| v.0.into_latest())
+        definition.value.map(|v| v.into_latest())
     }
 
     pub fn fetch_substate<M: DatabaseKeyMapper, D: ScryptoDecode>(
diff --git a/radix-engine/src/vm/vm.rs b/radix-engine/src/vm/vm.rs
index 31711c7e2bf..5c1782861a6 100644
--- a/radix-engine/src/vm/vm.rs
+++ b/radix-engine/src/vm/vm.rs
@@ -71,7 +71,7 @@ impl<'g, W: WasmEngine + 'g, E: NativeVmExtension> SystemCallbackObject for Vm<'
                 .expect(&format!("Vm type not found: {:?}", export))
         };
 
-        let output = match vm_type.0.into_latest().vm_type {
+        let output = match vm_type.into_latest().vm_type {
             VmType::Native => {
                 let original_code = {
                     let handle = api.kernel_open_substate_with_default(
@@ -98,7 +98,7 @@ impl<'g, W: WasmEngine + 'g, E: NativeVmExtension> SystemCallbackObject for Vm<'
                     .kernel_get_system()
                     .callback_obj
                     .native_vm
-                    .create_instance(address, &original_code.0.into_latest().code)?;
+                    .create_instance(address, &original_code.into_latest().code)?;
                 let output = { vm_instance.invoke(export.export_name.as_str(), input, api)? };
 
                 output
@@ -123,7 +123,6 @@ impl<'g, W: WasmEngine + 'g, E: NativeVmExtension> SystemCallbackObject for Vm<'
                     instrumented_code
                         .value
                         .expect(&format!("Instrumented code not found: {:?}", export))
-                        .0
                         .into_latest()
                 };
 
diff --git a/sbor/src/versioned.rs b/sbor/src/versioned.rs
index 74ce00d2032..efeb426cf88 100644
--- a/sbor/src/versioned.rs
+++ b/sbor/src/versioned.rs
@@ -35,14 +35,14 @@ macro_rules! define_single_versioned {
     (
         $(#[$attributes:meta])*
         $vis:vis enum $name:ident
-        $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)?
+        $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? $( = $deflt:tt)? ),+ >)?
         =>
         $latest_version_alias:ty = $latest_version_type:ty
     ) => {
         $crate::define_versioned!(
             $(#[$attributes])*
             $vis enum $name
-            $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            $(< $( $lt $( : $clt $(+ $dlt )* )? $( = $deflt)? ),+ >)?
             {
                 previous_versions: [],
                 latest_version: {
@@ -68,7 +68,7 @@ macro_rules! define_versioned {
         $vis:vis enum $name:ident
         // Now match the optional type parameters
         // See https://stackoverflow.com/questions/41603424/rust-macro-accepting-type-with-generic-parameters
-        $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)?
+        $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? $( = $deflt:tt)? ),+ >)?
         {
             $(
                 previous_versions: [
@@ -108,7 +108,7 @@ macro_rules! define_versioned {
             // We include the repr(u8) so that the SBOR discriminants are assigned
             // to match the version numbers if SBOR is used on the versioned enum
             #[repr(u8)]
-            $vis enum $name $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            $vis enum $name $(< $( $lt $( : $clt $(+ $dlt )* )? $( = $deflt)? ),+ >)?
             {
                 $($(
                     [<V $version_num>]($version_type) = $version_num,
diff --git a/scrypto-unit/src/test_runner.rs b/scrypto-unit/src/test_runner.rs
index e0eee8f5c6c..502cda15a13 100644
--- a/scrypto-unit/src/test_runner.rs
+++ b/scrypto-unit/src/test_runner.rs
@@ -540,7 +540,7 @@ impl<E: NativeVmExtension, D: TestDatabase> TestRunner<E, D> {
 
         self.database
             .get_mapped::<SpreadPrefixKeyMapper, FieldSubstate<LiquidFungibleResource>>(
-                output.0.into_latest().royalty_vault.0.as_node_id(),
+                output.into_latest().royalty_vault.0.as_node_id(),
                 MAIN_BASE_PARTITION,
                 &FungibleVaultField::LiquidFungible.into(),
             )
@@ -630,7 +630,7 @@ impl<E: NativeVmExtension, D: TestDatabase> TestRunner<E, D> {
                 scrypto_decode(&entry.1).unwrap();
             match value.value {
                 Some(definition) => {
-                    definitions.insert(key, definition.0.into_latest());
+                    definitions.insert(key, definition.into_latest());
                 }
                 None => {}
             }
diff --git a/simulator/src/ledger/dumper.rs b/simulator/src/ledger/dumper.rs
index 6f59096128a..f4ffb0c4d24 100644
--- a/simulator/src/ledger/dumper.rs
+++ b/simulator/src/ledger/dumper.rs
@@ -48,7 +48,7 @@ pub fn dump_package<T: SubstateDatabase, O: std::io::Write>(
         output,
         "{}: {} bytes",
         "Code size".green().bold(),
-        substate.value.unwrap().0.into_latest().code.len()
+        substate.value.unwrap().into_latest().code.len()
     );
 
     let metadata = get_entity_metadata(package_address.as_node_id(), substate_db);
diff --git a/simulator/src/resim/mod.rs b/simulator/src/resim/mod.rs
index e6b203f841c..0ac7a2098e3 100644
--- a/simulator/src/resim/mod.rs
+++ b/simulator/src/resim/mod.rs
@@ -456,7 +456,7 @@ pub fn get_event_schema<S: SubstateDatabase>(
             ),
         )
         .unwrap();
-    let bp_interface = bp_definition.value.unwrap().0.into_latest().interface;
+    let bp_interface = bp_definition.value.unwrap().into_latest().interface;
 
     let event_def = bp_interface.events.get(event_name)?;
     match event_def {

From 62449126fa90004ff3834ab778275e6468383ecf Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Mon, 21 Aug 2023 01:39:24 +0100
Subject: [PATCH 26/28] feature: Improvements to key and content traits and
 models

---
 radix-engine/src/blueprints/models/content.rs | 195 -----------
 radix-engine/src/blueprints/models/keys.rs    | 312 ++++++++++++++++++
 radix-engine/src/blueprints/models/mod.rs     |   6 +-
 .../models/native_blueprint_state_macro.rs    | 136 +++++---
 .../src/blueprints/models/payloads.rs         | 230 +++++++++++++
 .../src/blueprints/package/substates.rs       |  18 +-
 scrypto-unit/src/test_runner.rs               |   2 +-
 7 files changed, 653 insertions(+), 246 deletions(-)
 delete mode 100644 radix-engine/src/blueprints/models/content.rs
 create mode 100644 radix-engine/src/blueprints/models/keys.rs
 create mode 100644 radix-engine/src/blueprints/models/payloads.rs

diff --git a/radix-engine/src/blueprints/models/content.rs b/radix-engine/src/blueprints/models/content.rs
deleted file mode 100644
index bfd2fd8f07a..00000000000
--- a/radix-engine/src/blueprints/models/content.rs
+++ /dev/null
@@ -1,195 +0,0 @@
-use crate::internal_prelude::*;
-
-macro_rules! declare_payload_new_type {
-    (
-        content_trait: $content_trait:ident,
-        payload_trait: $payload_trait:ident,
-        $(#[$attributes:meta])*
-        $vis:vis struct $payload_type_name:ident
-        $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? $( = $deflt:tt)? ),+ >)?
-        ($content_type:ty)$(;)?
-    ) => {
-        $(#[$attributes])*
-        #[sbor(transparent, categorize_types = "")]
-        $vis struct $payload_type_name
-            $(< $( $lt $( : $clt $(+ $dlt )* )? $( = $deflt)? ),+ >)?
-            (pub $content_type);
-
-        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
-            core::convert::From<$content_type>
-            for $payload_type_name $(< $( $lt ),+ >)?
-        {
-            fn from(value: $content_type) -> Self {
-                Self(value)
-            }
-        }
-
-        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
-            core::convert::AsRef<$content_type>
-            for $payload_type_name $(< $( $lt ),+ >)?
-        {
-            fn as_ref(&self) -> &$content_type {
-                &self.0
-            }
-        }
-
-        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
-            core::convert::AsMut<$content_type>
-            for $payload_type_name $(< $( $lt ),+ >)?
-        {
-            fn as_mut(&mut self) -> &mut $content_type {
-                &mut self.0
-            }
-        }
-
-        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
-            $payload_trait
-            for $payload_type_name $(< $( $lt ),+ >)?
-        {
-            type Content = $content_type;
-
-            fn into_content(self) -> Self::Content {
-                self.0
-            }
-        }
-
-        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
-            $content_trait<$payload_type_name$(< $( $lt ),+ >)?>
-            for $payload_type_name $(< $( $lt ),+ >)?
-        {
-            fn into_payload(self) -> $payload_type_name$(< $( $lt ),+ >)? {
-                self
-            }
-        }
-
-        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
-            $content_trait<$payload_type_name$(< $( $lt ),+ >)?>
-            for $content_type
-        {
-            fn into_payload(self) -> $payload_type_name$(< $( $lt ),+ >)? {
-                $payload_type_name(self)
-            }
-        }
-    }
-}
-#[allow(unused)]
-pub(crate) use declare_payload_new_type;
-
-pub trait FieldPayload: AsRef<Self::Content> + AsMut<Self::Content> + From<Self::Content> {
-    type Content: FieldContent<Self>;
-
-    fn into_content(self) -> Self::Content;
-
-    fn from_content<T: FieldContent<Self>>(content: T) -> Self
-    where
-        Self: From<T>,
-    {
-        content.into_payload()
-    }
-}
-
-pub trait FieldContent<Payload: FieldPayload>: Sized {
-    fn into_payload(self) -> Payload;
-
-    fn into_locked_substate(self) -> FieldSubstate<Payload> {
-        FieldSubstate::new_locked_field(self.into_payload())
-    }
-
-    fn into_mutable_substate(self) -> FieldSubstate<Payload> {
-        FieldSubstate::new_field(self.into_payload())
-    }
-}
-
-pub trait KeyPayload: AsRef<Self::Content> + AsMut<Self::Content> + From<Self::Content> {
-    type Content: KeyContent<Self>;
-
-    fn into_content(self) -> Self::Content;
-
-    fn from_content<T: KeyContent<Self>>(content: T) -> Self
-    where
-        Self: From<T>,
-    {
-        content.into_key()
-    }
-}
-
-pub trait KeyContent<Payload: KeyPayload>: Sized {
-    fn into_payload(self) -> Payload;
-
-    fn into_key(self) -> Payload {
-        self.into_payload()
-    }
-}
-
-pub trait KeyValueEntryPayload:
-    AsRef<Self::Content> + AsMut<Self::Content> + From<Self::Content>
-{
-    type Content: KeyValueEntryContent<Self>;
-
-    fn into_content(self) -> Self::Content;
-
-    fn from_content<T: KeyValueEntryContent<Self>>(content: T) -> Self
-    where
-        Self: From<T>,
-    {
-        content.into_payload()
-    }
-}
-
-pub trait KeyValueEntryContent<Payload: KeyValueEntryPayload>: Sized {
-    fn into_payload(self) -> Payload;
-
-    fn into_locked_substate(self) -> KeyValueEntrySubstate<Payload> {
-        KeyValueEntrySubstate::entry(self.into_payload())
-    }
-
-    fn into_mutable_substate(self) -> KeyValueEntrySubstate<Payload> {
-        KeyValueEntrySubstate::locked_entry(self.into_payload())
-    }
-}
-
-pub trait IndexEntryPayload:
-    AsRef<Self::Content> + AsMut<Self::Content> + From<Self::Content>
-{
-    type Content: IndexEntryContent<Self>;
-
-    fn into_content(self) -> Self::Content;
-
-    fn from_content<T: IndexEntryContent<Self>>(content: T) -> Self
-    where
-        Self: From<T>,
-    {
-        content.into_payload()
-    }
-}
-
-pub trait IndexEntryContent<Payload: IndexEntryPayload>: Sized {
-    fn into_payload(self) -> Payload;
-
-    fn into_substate(self) -> Payload {
-        self.into_payload()
-    }
-}
-
-pub trait SortedIndexEntryPayload:
-    AsRef<Self::Content> + AsMut<Self::Content> + From<Self::Content>
-{
-    type Content: SortedIndexEntryContent<Self>;
-
-    fn into_content(self) -> Self::Content;
-
-    fn from_content<T: SortedIndexEntryContent<Self>>(content: T) -> Self
-    where
-        Self: From<T>,
-    {
-        content.into_payload()
-    }
-}
-
-pub trait SortedIndexEntryContent<Payload: SortedIndexEntryPayload>: Sized {
-    fn into_payload(self) -> Payload;
-
-    fn into_substate(self) -> Payload {
-        self.into_payload()
-    }
-}
diff --git a/radix-engine/src/blueprints/models/keys.rs b/radix-engine/src/blueprints/models/keys.rs
new file mode 100644
index 00000000000..f48a747db7d
--- /dev/null
+++ b/radix-engine/src/blueprints/models/keys.rs
@@ -0,0 +1,312 @@
+use crate::internal_prelude::*;
+
+macro_rules! declare_key_new_type {
+    // First - explicitly support SortedIndex
+    (
+        content_trait: SortedIndexKeyContentSource,
+        payload_trait: SortedIndexKeyPayload,
+        full_key_content: {
+            full_content_type: $full_content_type:ty,
+            sort_prefix_property_name: $sort_prefix_property_name:ident
+            $(,)?
+        },
+        $(#[$attributes:meta])*
+        $vis:vis struct $payload_type_name:ident
+            $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? $( = $deflt:tt)? ),+ >)?
+            ($content_type:ty)$(;)?
+    ) => {
+        $(#[$attributes])*
+        #[sbor(categorize_types = "")]
+        /// This type represents the payload of the key of a particular sorted index collection.
+        $vis struct $payload_type_name
+            $(< $( $lt $( : $clt $(+ $dlt )* )? $( = $deflt)? ),+ >)?
+            {
+                pub $sort_prefix_property_name: u16,
+                pub content: $content_type,
+            }
+
+        impl $payload_type_name {
+            pub fn new($sort_prefix_property_name: u16, content: $content_type) -> Self {
+                Self {
+                    $sort_prefix_property_name,
+                    content,
+                }
+            }
+
+            pub fn sort_prefix(&self) -> u16 {
+                self.$sort_prefix_property_name
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            core::convert::AsRef<$content_type>
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            fn as_ref(&self) -> &$content_type {
+                &self.content
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            core::convert::AsMut<$content_type>
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            fn as_mut(&mut self) -> &mut $content_type {
+                &mut self.content
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            SortedIndexKeyPayload
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            type Content = $content_type;
+            type FullContent = $full_content_type;
+
+            fn into_sort_key_and_content(self) -> (u16, Self::Content) {
+                (self.sort_prefix(), self.content)
+            }
+
+            fn from_sort_key_and_content(sort_prefix: u16, content: Self::Content) -> Self {
+                Self {
+                    $sort_prefix_property_name: sort_prefix,
+                    content,
+                }
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            TryFrom<&SubstateKey>
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            type Error = ();
+
+            fn try_from(substate_key: &SubstateKey) -> Result<Self, Self::Error> {
+                let (sort_prefix, payload_bytes) = substate_key.for_sorted().ok_or(())?;
+                let content = scrypto_decode(payload_bytes).map_err(|_| ())?;
+                Ok(Self::from_sort_key_and_content(*sort_prefix, content))
+            }
+        }
+
+        // Note - we assume that both:
+        // * SortedIndexKeyContentSource<_Payload>
+        // * SortedIndexKeyContentSource<_Payload>
+        // are already/manually implemented for $content_type
+    };
+    (
+        content_trait: SortedIndexKeyContentSource,
+        payload_trait: SortedIndexKeyPayload,
+        $(#[$attributes:meta])*
+        $vis:vis struct $payload_type_name:ident
+            $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? $( = $deflt:tt)? ),+ >)?
+            ($content_type:ty)$(;)?
+    ) => {
+        compile_error!(
+            "Make sure to add a `full_key_content: { full_content_type: <ident>, sort_prefix_property_name: <..>}` property after the `key_type` property for SortedIndex collection definitions"
+        )
+    };
+    (
+        content_trait: $content_trait:ident,
+        payload_trait: $payload_trait:ident,
+        full_key_content: $full_key_content:tt,
+        $(#[$attributes:meta])*
+        $vis:vis struct $payload_type_name:ident
+            $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? $( = $deflt:tt)? ),+ >)?
+            ($content_type:ty)$(;)?
+    ) => {
+        compile_error!(
+            "Only add a `full_key_content` property for SortedIndex collection definitions"
+        )
+    };
+    // Then - support the other collection types
+    (
+        content_trait: $content_trait:ident,
+        payload_trait: $payload_trait:ident,
+        $(#[$attributes:meta])*
+        $vis:vis struct $payload_type_name:ident
+        $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? $( = $deflt:tt)? ),+ >)?
+        ($content_type:ty)$(;)?
+    ) => {
+        $(#[$attributes])*
+        #[sbor(transparent, categorize_types = "", transparent_name)]
+        /// This new type represents the payload of the key of a particular collection.
+        $vis struct $payload_type_name
+            $(< $( $lt $( : $clt $(+ $dlt )* )? $( = $deflt)? ),+ >)?
+            {
+                pub content: $content_type,
+            }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            core::convert::From<$content_type>
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            fn from(value: $content_type) -> Self {
+                Self {
+                    content: value,
+                }
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            core::convert::AsRef<$content_type>
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            fn as_ref(&self) -> &$content_type {
+                &self.content
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            core::convert::AsMut<$content_type>
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            fn as_mut(&mut self) -> &mut $content_type {
+                &mut self.content
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            TryFrom<&SubstateKey>
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            type Error = ();
+
+            fn try_from(substate_key: &SubstateKey) -> Result<Self, Self::Error> {
+                let key = substate_key.for_map().ok_or(())?;
+                scrypto_decode::<Self>(&key).map_err(|_| ())
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            $payload_trait
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            type Content = $content_type;
+
+            fn into_content(self) -> Self::Content {
+                self.content
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            $content_trait<$payload_type_name$(< $( $lt ),+ >)?>
+            for $content_type
+        {
+            fn into_content(self) -> $content_type {
+                self
+            }
+        }
+    }
+}
+#[allow(unused)]
+pub(crate) use declare_key_new_type;
+
+/// This trait is intended to be implemented by an explicit new type for for the given
+/// `{ content: T }` key of a particular key value collection.
+pub trait KeyValueKeyPayload:
+    Sized + AsRef<Self::Content> + AsMut<Self::Content> + From<Self::Content>
+{
+    type Content: KeyValueKeyContentSource<Self>;
+
+    fn into_content(self) -> Self::Content;
+    fn from_content(inner_content: Self::Content) -> Self {
+        Self::from(inner_content)
+    }
+
+    fn from_content_source<T: KeyValueKeyContentSource<Self>>(content: T) -> Self {
+        Self::from_content(content.into_content())
+    }
+}
+
+/// This trait is intended to be implemented by types which embody the content
+/// of a key for a particular key value collection.
+///
+/// Note:
+/// * Multiple types might be mappable into the key payload, and so implement this trait
+/// * This trait is only one way - from value into content
+/// * This trait uses a generic, because the same type might be usable as a key for multiple
+///   substates
+pub trait KeyValueKeyContentSource<Payload: KeyValueKeyPayload>: Sized {
+    fn into_content(self) -> Payload::Content;
+
+    fn into_key(self) -> Payload {
+        Payload::from_content_source(self)
+    }
+}
+
+/// This trait is intended to be implemented by an explicit new type for the given
+/// `{ content: T }` key of a particular index collection.
+pub trait IndexKeyPayload:
+    Sized + AsRef<Self::Content> + AsMut<Self::Content> + From<Self::Content>
+{
+    type Content: IndexKeyContentSource<Self>;
+
+    fn into_content(self) -> Self::Content;
+    fn from_content(content: Self::Content) -> Self {
+        Self::from(content)
+    }
+
+    fn from_content_source<T: IndexKeyContentSource<Self>>(content: T) -> Self {
+        Self::from_content(content.into_content())
+    }
+}
+
+/// This trait is intended to be implemented by types which embody the content
+/// of a key for a particular index collection.
+///
+/// Note:
+/// * Multiple types might be mappable into the key payload, and so implement this trait
+/// * This trait is only one way - from value into content
+/// * This trait uses a generic, because the same type might be usable as a key for multiple
+///   substates
+pub trait IndexKeyContentSource<Payload: IndexKeyPayload>: Sized {
+    fn into_content(self) -> Payload::Content;
+
+    fn into_key(self) -> Payload {
+        Payload::from_content_source(self)
+    }
+}
+
+/// This trait is intended to be implemented by an explicit new type for the given
+/// `{ sort_index: u16, content: T }` key for a particular sorted index collection.
+pub trait SortedIndexKeyPayload: Sized + AsRef<Self::Content> + AsMut<Self::Content> {
+    type Content;
+    type FullContent: SortedIndexKeyFullContent<Self>;
+
+    fn from_sort_key_and_content(sort_key: u16, content: Self::Content) -> Self;
+    fn into_sort_key_and_content(self) -> (u16, Self::Content);
+
+    fn into_full_content(self) -> Self::FullContent {
+        let (sort_key, content) = self.into_sort_key_and_content();
+        Self::FullContent::from_sort_key_and_content(sort_key, content)
+    }
+
+    fn from_content_source<T: SortedIndexKeyContentSource<Self>>(content: T) -> Self {
+        let (sort_key, content) = content.into_sort_key_and_content();
+        Self::from_sort_key_and_content(sort_key, content)
+    }
+}
+
+/// This trait is intended to be implemented by types which embody the content
+/// of a key for a particular sorted index collection.
+///
+/// Note:
+/// * Multiple types might be mappable into the key payload, and so implement this trait
+/// * This trait is only one way - from value into content
+/// * This trait uses a generic, because the same type might be usable as a key for multiple
+///   explicit substates
+pub trait SortedIndexKeyContentSource<Payload: SortedIndexKeyPayload>: Sized {
+    fn into_sort_key_and_content(self) -> (u16, Payload::Content);
+
+    fn into_key(self) -> Payload {
+        Payload::from_content_source(self)
+    }
+}
+
+/// This trait is intended to be implemented by the canonical content
+/// of a key for a particular sorted index collection.
+pub trait SortedIndexKeyFullContent<Payload: SortedIndexKeyPayload>:
+    SortedIndexKeyContentSource<Payload>
+{
+    fn from_sort_key_and_content(sort_key: u16, content: Payload::Content) -> Self;
+}
diff --git a/radix-engine/src/blueprints/models/mod.rs b/radix-engine/src/blueprints/models/mod.rs
index 45f493c3c57..8dcc077b2fb 100644
--- a/radix-engine/src/blueprints/models/mod.rs
+++ b/radix-engine/src/blueprints/models/mod.rs
@@ -1,7 +1,9 @@
-mod content;
 mod feature_set;
+mod keys;
 mod native_blueprint_state_macro;
+mod payloads;
 
-pub use content::*;
 pub use feature_set::*;
+pub use keys::*;
 pub(crate) use native_blueprint_state_macro::*;
+pub use payloads::*;
diff --git a/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs b/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
index a1e50bd613d..d97e9f42a71 100644
--- a/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
+++ b/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
@@ -28,7 +28,7 @@ use crate::internal_prelude::*;
 ///     }
 ///     {
 ///         kind: Static,
-///         the_type: x,
+///         content_type: x,
 ///     },
 ///     {
 ///         kind: Generic,
@@ -106,6 +106,8 @@ macro_rules! declare_native_blueprint_state {
                 $collection_property_name:ident: $collection_type:ident {
                     entry_ident: $collection_ident:ident,
                     key_type: $collection_key_type:tt,
+                    // The full_key_content is required if it's a sorted index
+                    $(full_key_content: $full_key_content:tt,)?
                     value_type: $collection_value_type:tt,
                     allow_ownership: $collection_allow_ownership:expr
                     // Advanced collection options for (eg):
@@ -144,7 +146,7 @@ macro_rules! declare_native_blueprint_state {
                     // > Set up the (transparent) _FieldPayload new type for the content of the field
                     // > Set up the FieldContent trait for anything which can be resolved into the field payload
                     generate_content_type!(
-                        content_trait: FieldContent,
+                        content_trait: FieldContentSource,
                         payload_trait: FieldPayload,
                         ident_core: [<$blueprint_ident $field_ident>],
                         #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
@@ -161,36 +163,14 @@ macro_rules! declare_native_blueprint_state {
                 // Generate models for each collection
                 $(
                     // Key
-                    // > Set up Versioned types (if relevant). Assumes __KeyInnerV1 exists and then creates
-                    //   - Versioned__KeyInner
-                    //   - __KeyInner (alias for __KeyInnerV1)
-                    // > Create the (transparent) _Key new type for the key
-                    // > Set up the KeyContent traits for anything which can be resolved into a key
-                    generate_content_type!(
-                        content_trait: KeyContent,
-                        payload_trait: KeyPayload,
-                        ident_core: [<$blueprint_ident $collection_ident KeyInner>],
+                    generate_key_type!(
+                        content_trait: [<$collection_type KeyContentSource>],
+                        payload_trait: [<$collection_type KeyPayload>],
+                        $(full_key_content: $full_key_content,)?
                         #[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, ScryptoSbor)]
-                        #[sbor(transparent_name)]
                         struct [<$blueprint_ident $collection_ident KeyPayload>] = $collection_key_type
                     );
 
-                    // TODO(David): Tweak when I work out the right strategy for keys. Probably just want a single new-type.
-                    // So probably just don't use generate_content_type but use generate_key_type or something instead?
-                    pub type [<$blueprint_ident $collection_ident SubstateKey>] = [<$blueprint_ident $collection_ident KeyPayload>];
-
-                    // TODO(David) - Properly handle SortedIndex:
-                    // Fix Key types for SortedIndex to have a named u16 part of the key,
-                    // use a different key trait, and use .for_sorted_key in the below.
-                    impl TryFrom<&SubstateKey> for [<$blueprint_ident $collection_ident SubstateKey>] {
-                        type Error = ();
-
-                        fn try_from(substate_key: &SubstateKey) -> Result<Self, Self::Error> {
-                            let key = substate_key.for_map().ok_or(())?;
-                            scrypto_decode::<Self>(&key).map_err(|_| ())
-                        }
-                    }
-
                     // Values
                     // > If relevant, set up Versioned types, which:
                     //   - Assumes [BlueprintCollection]V1 exists
@@ -202,7 +182,7 @@ macro_rules! declare_native_blueprint_state {
                     //   - The Versioned[BlueprintCollection] if it exists
                     //   - The static content type, if it exists
                     generate_content_type!(
-                        content_trait: [<$collection_type EntryContent>],
+                        content_trait: [<$collection_type EntryContentSource>],
                         payload_trait: [<$collection_type EntryPayload>],
                         ident_core: [<$blueprint_ident $collection_ident>],
                         #[derive(Debug, PartialEq, Eq, ScryptoSbor)]
@@ -404,7 +384,7 @@ macro_rules! declare_native_blueprint_state {
                     )*
                     $(
                         pub $collection_property_name: IndexMap<
-                            [<$blueprint_ident $collection_ident SubstateKey>],
+                            [<$blueprint_ident $collection_ident KeyPayload>],
                             [<$blueprint_ident $collection_ident EntrySubstate>]
                         >,
                     )*
@@ -610,7 +590,7 @@ macro_rules! declare_native_blueprint_state {
                 #[derive(Debug, Clone)]
                 pub enum [<$blueprint_ident TypedSubstateKey>] {
                     Fields([<$blueprint_ident Field>]),
-                    $([<$collection_ident $collection_type Entries>]([<$blueprint_ident $collection_ident SubstateKey>]),)*
+                    $([<$collection_ident $collection_type Entries>]([<$blueprint_ident $collection_ident KeyPayload>]),)*
                 }
 
                 impl [<$blueprint_ident TypedSubstateKey>] {
@@ -624,7 +604,7 @@ macro_rules! declare_native_blueprint_state {
                             $(
                                 [<$blueprint_ident Partition>]::[<$collection_ident $collection_type>] => {
                                     [<$blueprint_ident TypedSubstateKey>]::[<$collection_ident $collection_type Entries>](
-                                        [<$blueprint_ident $collection_ident SubstateKey>]::try_from(substate_key)?,
+                                        [<$blueprint_ident $collection_ident KeyPayload>]::try_from(substate_key)?,
                                     )
                                 }
                             )*
@@ -809,8 +789,8 @@ mod helper_macros {
                 // Now implement other relevant content traits, for:
                 // > The "latest" type: $ident_core
                 impl $content_trait<$payload_type_name> for $ident_core {
-                    fn into_payload(self) -> $payload_type_name {
-                        $payload_type_name(self.into())
+                    fn into_content(self) -> [<Versioned $ident_core>] {
+                        self.into()
                     }
                 }
             }
@@ -822,7 +802,7 @@ mod helper_macros {
             $(#[$attributes:meta])*
             struct $payload_type_name:ident = {
                 kind: Static,
-                the_type: $static_type:ty
+                content_type: $static_type:ty
                 $(,)?
             }$(,)?
         ) => {
@@ -869,6 +849,64 @@ mod helper_macros {
     #[allow(unused)]
     pub(crate) use generate_content_type;
 
+    macro_rules! generate_key_type {
+        (
+            content_trait: $content_trait:ident,
+            payload_trait: $payload_trait:ident,
+            $(full_key_content: $full_key_content:tt,)?
+            $(#[$attributes:meta])*
+            struct $payload_type_name:ident = {
+                kind: StaticSingleVersioned
+                $(,)?
+            }$(,)?
+        ) => {
+            compile_error!(
+                "A StaticSingleVersioned key is not supported, because keys cannot be lazily updated, because they need to be static"
+            );
+        };
+        (
+            content_trait: $content_trait:ident,
+            payload_trait: $payload_trait:ident,
+            $(full_key_content: $full_key_content:tt,)?
+            $(#[$attributes:meta])*
+            struct $payload_type_name:ident = {
+                kind: Static,
+                content_type: $static_type:ty
+                $(,)?
+            }$(,)?
+        ) => {
+            paste::paste! {
+                declare_key_new_type!(
+                    content_trait: $content_trait,
+                    payload_trait: $payload_trait,
+                    $(full_key_content: $full_key_content,)?
+                    $(#[$attributes])*
+                    pub struct $payload_type_name($static_type);
+                );
+            }
+        };
+        (
+            content_trait: $content_trait:ident,
+            payload_trait: $payload_trait:ident,
+            $(full_key_content: $full_key_content:tt,)?
+            $(#[$attributes:meta])*
+            struct $payload_type_name:ident = {
+                kind: Generic,
+                ident: $generic_ident:ident
+                $(,)?
+            }
+        ) => {
+            paste::paste! {
+                compile_error!(
+                    "A Generic key is not currently supported by these macros"
+                );
+            }
+        };
+    }
+
+    #[allow(unused)]
+    pub(crate) use generate_key_type;
+
     macro_rules! generate_system_substate_type_alias {
         (SystemField, type $alias:ident = WRAPPED $content:ty$(,)?) => {
             // There is no system wrapper around SystemField substates
@@ -966,7 +1004,7 @@ mod helper_macros {
             $aggregator:ident,
             {
                 kind: Static,
-                the_type: $static_type:ty
+                content_type: $static_type:ty
                 $(,)?
             },
             $payload_alias:ident$(,)?
@@ -1108,7 +1146,7 @@ mod tests {
                 entry_ident: MyCoolKeyValueStore,
                 key_type: {
                     kind: Static,
-                    the_type: BlueprintVersion,
+                    content_type: BlueprintVersion,
                 },
                 value_type: {
                     kind: StaticSingleVersioned,
@@ -1119,7 +1157,7 @@ mod tests {
                 entry_ident: MyCoolIndex,
                 key_type: {
                     kind: Static,
-                    the_type: BlueprintVersion,
+                    content_type: BlueprintVersion,
                 },
                 value_type: {
                     kind: StaticSingleVersioned,
@@ -1130,7 +1168,11 @@ mod tests {
                 entry_ident: MyCoolSortedIndex,
                 key_type: {
                     kind: Static,
-                    the_type: BlueprintVersion,
+                    content_type: BlueprintVersion,
+                },
+                full_key_content: {
+                    full_content_type: ExampleSortedIndexKey,
+                    sort_prefix_property_name: sort_prefix,
                 },
                 value_type: {
                     kind: StaticSingleVersioned,
@@ -1139,4 +1181,20 @@ mod tests {
             },
         }
     }
+
+    pub struct ExampleSortedIndexKey(u16, BlueprintVersion);
+
+    impl SortedIndexKeyFullContent<TestBlueprintMyCoolSortedIndexKeyPayload> for ExampleSortedIndexKey {
+        fn from_sort_key_and_content(sort_key: u16, content: BlueprintVersion) -> Self {
+            ExampleSortedIndexKey(sort_key, content)
+        }
+    }
+
+    impl SortedIndexKeyContentSource<TestBlueprintMyCoolSortedIndexKeyPayload>
+        for ExampleSortedIndexKey
+    {
+        fn into_sort_key_and_content(self) -> (u16, BlueprintVersion) {
+            (self.0, self.1)
+        }
+    }
 }
diff --git a/radix-engine/src/blueprints/models/payloads.rs b/radix-engine/src/blueprints/models/payloads.rs
new file mode 100644
index 00000000000..d2b1d714e46
--- /dev/null
+++ b/radix-engine/src/blueprints/models/payloads.rs
@@ -0,0 +1,230 @@
+use crate::internal_prelude::*;
+
+macro_rules! declare_payload_new_type {
+    (
+        content_trait: $content_trait:ident,
+        payload_trait: $payload_trait:ident,
+        $(#[$attributes:meta])*
+        $vis:vis struct $payload_type_name:ident
+            $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? $( = $deflt:tt)? ),+ >)?
+            ($content_type:ty)$(;)?
+    ) => {
+        $(#[$attributes])*
+        #[sbor(transparent, categorize_types = "")]
+        /// This new type represents the payload of a particular field or collection.
+        /// It is unique to this particular field/collection.
+        $vis struct $payload_type_name
+            $(< $( $lt $( : $clt $(+ $dlt )* )? $( = $deflt)? ),+ >)?
+            {
+                pub content: $content_type
+            }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            core::convert::From<$content_type>
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            fn from(value: $content_type) -> Self {
+                Self {
+                    content: value,
+                }
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            core::convert::AsRef<$content_type>
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            fn as_ref(&self) -> &$content_type {
+                &self.content
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            core::convert::AsMut<$content_type>
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            fn as_mut(&mut self) -> &mut $content_type {
+                &mut self.content
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            $payload_trait
+            for $payload_type_name $(< $( $lt ),+ >)?
+        {
+            type Content = $content_type;
+
+            fn into_content(self) -> Self::Content {
+                self.content
+            }
+        }
+
+        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
+            $content_trait<$payload_type_name$(< $( $lt ),+ >)?>
+            for $content_type
+        {
+            fn into_content(self) -> $content_type {
+                self
+            }
+        }
+    }
+}
+#[allow(unused)]
+pub(crate) use declare_payload_new_type;
+
+/// This trait is intended to be implemented by an explicit new type for for the given
+/// `{ content: T }` payload of a particular field.
+pub trait FieldPayload:
+    Sized + AsRef<Self::Content> + AsMut<Self::Content> + From<Self::Content>
+{
+    type Content: FieldContentSource<Self>;
+
+    fn into_content(self) -> Self::Content;
+    fn from_content(inner_content: Self::Content) -> Self {
+        Self::from(inner_content)
+    }
+
+    fn from_content_source<T: FieldContentSource<Self>>(content: T) -> Self {
+        Self::from_content(content.into_content())
+    }
+}
+
+/// This trait is intended to be implemented by types which embody the content
+/// of a particular field payload.
+///
+/// Note:
+/// * Multiple types might be mappable into the payload, and so implement this trait
+/// * This trait is only one way - from value into content
+/// * This trait uses a generic, because the same type might be usable as a payload for multiple
+///   substates
+pub trait FieldContentSource<Payload: FieldPayload>: Sized {
+    fn into_content(self) -> Payload::Content;
+
+    fn into_payload(self) -> Payload {
+        Payload::from_content_source(self)
+    }
+
+    fn into_locked_substate(self) -> FieldSubstate<Payload> {
+        FieldSubstate::new_locked_field(self.into_payload())
+    }
+
+    fn into_mutable_substate(self) -> FieldSubstate<Payload> {
+        FieldSubstate::new_field(self.into_payload())
+    }
+}
+
+/// This trait is intended to be implemented by an explicit new type for for the given
+/// `{ content: T }` payload of a particular key value collection.
+pub trait KeyValueEntryPayload:
+    Sized + AsRef<Self::Content> + AsMut<Self::Content> + From<Self::Content>
+{
+    type Content: KeyValueEntryContentSource<Self>;
+
+    fn into_content(self) -> Self::Content;
+    fn from_content(inner_content: Self::Content) -> Self {
+        Self::from(inner_content)
+    }
+
+    fn from_content_source<T: KeyValueEntryContentSource<Self>>(content: T) -> Self {
+        Self::from_content(content.into_content())
+    }
+}
+
+/// This trait is intended to be implemented by types which embody the content
+/// of a particular key value entry payload.
+///
+/// Note:
+/// * Multiple types might be mappable into the payload, and so implement this trait
+/// * This trait is only one way - from value into content
+/// * This trait uses a generic, because the same type might be usable as a payload for multiple
+///   substates
+pub trait KeyValueEntryContentSource<Payload: KeyValueEntryPayload>: Sized {
+    fn into_content(self) -> Payload::Content;
+
+    fn into_payload(self) -> Payload {
+        Payload::from_content_source(self)
+    }
+
+    fn into_locked_substate(self) -> KeyValueEntrySubstate<Payload> {
+        KeyValueEntrySubstate::entry(self.into_payload())
+    }
+
+    fn into_mutable_substate(self) -> KeyValueEntrySubstate<Payload> {
+        KeyValueEntrySubstate::locked_entry(self.into_payload())
+    }
+}
+
+/// This trait is intended to be implemented by an explicit new type for for the given
+/// `{ content: T }` payload of a particular index collection.
+pub trait IndexEntryPayload:
+    Sized + AsRef<Self::Content> + AsMut<Self::Content> + From<Self::Content>
+{
+    type Content: IndexEntryContentSource<Self>;
+
+    fn into_content(self) -> Self::Content;
+    fn from_content(inner_content: Self::Content) -> Self {
+        Self::from(inner_content)
+    }
+
+    fn from_content_source<T: IndexEntryContentSource<Self>>(content: T) -> Self {
+        Self::from_content(content.into_content())
+    }
+}
+
+/// This trait is intended to be implemented by types which embody the content
+/// of a particular index entry payload.
+///
+/// Note:
+/// * Multiple types might be mappable into the payload, and so implement this trait
+/// * This trait is only one way - from value into content
+/// * This trait uses a generic, because the same type might be usable as a payload for multiple
+///   substates
+pub trait IndexEntryContentSource<Payload: IndexEntryPayload>: Sized {
+    fn into_content(self) -> Payload::Content;
+
+    fn into_payload(self) -> Payload {
+        Payload::from_content_source(self)
+    }
+
+    fn into_substate(self) -> Payload {
+        self.into_payload()
+    }
+}
+
+/// This trait is intended to be implemented by an explicit new type for for the given
+/// `{ content: T }` payload of a particular sorted index collection.
+pub trait SortedIndexEntryPayload:
+    Sized + AsRef<Self::Content> + AsMut<Self::Content> + From<Self::Content>
+{
+    type Content: SortedIndexEntryContentSource<Self>;
+
+    fn into_content(self) -> Self::Content;
+
+    fn from_content(inner_content: Self::Content) -> Self {
+        Self::from(inner_content)
+    }
+
+    fn from_content_source<T: SortedIndexEntryContentSource<Self>>(content: T) -> Self {
+        Self::from_content(content.into_content())
+    }
+}
+
+/// This trait is intended to be implemented by types which embody the content
+/// of a particular sorted index entry payload.
+///
+/// Note:
+/// * Multiple types might be mappable into the payload, and so implement this trait
+/// * This trait is only one way - from value into content
+/// * This trait uses a generic, because the same type might be usable as a payload for multiple
+///   substates
+pub trait SortedIndexEntryContentSource<Payload: SortedIndexEntryPayload>: Sized {
+    fn into_content(self) -> Payload::Content;
+
+    fn into_payload(self) -> Payload {
+        Payload::from_content_source(self)
+    }
+
+    fn into_substate(self) -> Payload {
+        self.into_payload()
+    }
+}
diff --git a/radix-engine/src/blueprints/package/substates.rs b/radix-engine/src/blueprints/package/substates.rs
index edab0488f87..7783146cd56 100644
--- a/radix-engine/src/blueprints/package/substates.rs
+++ b/radix-engine/src/blueprints/package/substates.rs
@@ -24,7 +24,7 @@ declare_native_blueprint_state! {
             entry_ident: BlueprintVersionDefinition,
             key_type: {
                 kind: Static,
-                the_type: BlueprintVersionKey,
+                content_type: BlueprintVersionKey,
             },
             value_type: {
                 kind: StaticSingleVersioned,
@@ -35,7 +35,7 @@ declare_native_blueprint_state! {
             entry_ident: BlueprintVersionDependencies,
             key_type: {
                 kind: Static,
-                the_type: BlueprintVersionKey,
+                content_type: BlueprintVersionKey,
             },
             value_type: {
                 kind: StaticSingleVersioned,
@@ -46,12 +46,12 @@ declare_native_blueprint_state! {
             entry_ident: Schema,
             key_type: {
                 kind: Static,
-                the_type: SchemaHash,
+                content_type: SchemaHash,
             },
             value_type: {
                 kind: Static,
                 // TODO(David): Change to VersionedSchema in this substate in the SCHEMAS_PARTITION
-                the_type: ScryptoSchema,
+                content_type: ScryptoSchema,
             },
             allow_ownership: false,
             options: {
@@ -62,7 +62,7 @@ declare_native_blueprint_state! {
             entry_ident: BlueprintVersionRoyaltyConfig,
             key_type: {
                 kind: Static,
-                the_type: BlueprintVersionKey,
+                content_type: BlueprintVersionKey,
             },
             value_type: {
                 kind: StaticSingleVersioned,
@@ -73,7 +73,7 @@ declare_native_blueprint_state! {
             entry_ident: BlueprintVersionAuthConfig,
             key_type: {
                 kind: Static,
-                the_type: BlueprintVersionKey,
+                content_type: BlueprintVersionKey,
             },
             value_type: {
                 kind: StaticSingleVersioned,
@@ -84,7 +84,7 @@ declare_native_blueprint_state! {
             entry_ident: CodeVmType,
             key_type: {
                 kind: Static,
-                the_type: CodeHash,
+                content_type: CodeHash,
             },
             value_type: {
                 kind: StaticSingleVersioned,
@@ -95,7 +95,7 @@ declare_native_blueprint_state! {
             entry_ident: CodeOriginalCode,
             key_type: {
                 kind: Static,
-                the_type: CodeHash,
+                content_type: CodeHash,
             },
             value_type: {
                 kind: StaticSingleVersioned,
@@ -106,7 +106,7 @@ declare_native_blueprint_state! {
             entry_ident: CodeInstrumentedCode,
             key_type: {
                 kind: Static,
-                the_type: CodeHash,
+                content_type: CodeHash,
             },
             value_type: {
                 kind: StaticSingleVersioned,
diff --git a/scrypto-unit/src/test_runner.rs b/scrypto-unit/src/test_runner.rs
index 502cda15a13..e0da08bc88b 100644
--- a/scrypto-unit/src/test_runner.rs
+++ b/scrypto-unit/src/test_runner.rs
@@ -603,7 +603,7 @@ impl<E: NativeVmExtension, D: TestDatabase> TestRunner<E, D> {
             let value: PackageSchemaEntrySubstate = scrypto_decode(&entry.1).unwrap();
             match value.value {
                 Some(schema) => {
-                    schemas.insert(hash, schema.0);
+                    schemas.insert(hash, schema.content);
                 }
                 None => {}
             }

From 97b8cad0b8a895c62adae6b17d41730382c41107 Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Mon, 21 Aug 2023 02:15:44 +0100
Subject: [PATCH 27/28] tweak: Minor tweaks to mapped physical partition
 definition

---
 .../models/native_blueprint_state_macro.rs    | 67 +++++--------------
 .../src/blueprints/package/substates.rs       |  4 +-
 2 files changed, 18 insertions(+), 53 deletions(-)

diff --git a/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs b/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
index 416588e59a2..021825f2620 100644
--- a/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
+++ b/radix-engine/src/blueprints/models/native_blueprint_state_macro.rs
@@ -106,15 +106,12 @@ macro_rules! declare_native_blueprint_state {
             $(
                 $collection_property_name:ident: $collection_type:ident {
                     entry_ident: $collection_ident:ident,
+                    $(mapped_physical_partition: $mapped_physical_partition:expr,)?
                     key_type: $collection_key_type:tt,
                     // The full_key_content is required if it's a sorted index
                     $(full_key_content: $full_key_content:tt,)?
                     value_type: $collection_value_type:tt,
                     allow_ownership: $collection_allow_ownership:expr
-                    // Advanced collection options for (eg):
-                    // - Passing in a property name of the sorted index parameter for SortedIndex
-                    // - Specifying a Logical partition mapping
-                    $(, options: $collection_options:tt)?
                     $(,)? // Optional trailing comma
                 }
             ),*
@@ -214,8 +211,8 @@ macro_rules! declare_native_blueprint_state {
                                     $field_type,
                                     [<$blueprint_ident $field_ident FieldPayload>],
                                 ),
-                                condition: optional_expression_to_option!($($field_condition)?).unwrap_or(Condition::Always),
-                                transience: optional_expression_to_option!($($field_transience)?).unwrap_or(FieldTransience::NotTransient),
+                                condition: optional_or_fallback!($({ $field_condition })?, { Condition::Always }),
+                                transience: optional_or_fallback!($({ $field_transience})?, { FieldTransience::NotTransient }),
                             });
                         )*
                         let mut collections = vec![];
@@ -404,7 +401,7 @@ macro_rules! declare_native_blueprint_state {
                             {
                                 feature_checks.assert_valid(
                                     stringify!($field_ident),
-                                    &optional_expression_to_option!($($field_condition)?).unwrap_or(Condition::Always),
+                                    &optional_or_fallback!($({ $field_condition })?, { Condition::Always }),
                                     self.$field_property_name.is_some(),
                                 )?;
                                 if let Some(field) = self.$field_property_name {
@@ -514,19 +511,15 @@ macro_rules! declare_native_blueprint_state {
                             return PartitionDescription::Logical(PartitionOffset(module_partition_offset));
                         }
                         $(
-                            let mapped_physical_partition = extract_collection_option!(
-                                mapped_physical_partition,
-                                $($collection_options)?
-                            );
-                            let current_partition_description = match mapped_physical_partition {
-                                Some(physical_partition) => {
-                                    PartitionDescription::Physical(physical_partition)
-                                },
-                                None => {
+                            let current_partition_description = optional_or_fallback!(
+                                $({
+                                    PartitionDescription::Physical($mapped_physical_partition)
+                                })?,
+                                {
                                     module_partition_offset += 1;
                                     PartitionDescription::Logical(PartitionOffset(module_partition_offset))
-                                },
-                            };
+                                }
+                            );
                             if (*self as u8) == (Self::[<$collection_ident $collection_type>] as u8) {
                                 return current_partition_description;
                             }
@@ -1066,43 +1059,17 @@ mod helper_macros {
     #[allow(unused)]
     pub(crate) use map_entry_substate_to_kv_entry;
 
-    macro_rules! optional_expression_to_option {
-        ($expression:expr$(,)?) => { Some($expression) };
-        () => { None };
-    }
-
-    #[allow(unused)]
-    pub(crate) use optional_expression_to_option;
-
-    macro_rules! extract_collection_option {
-        (
-            mapped_physical_partition, // Name of field
-            {
-                mapped_physical_partition: $value:tt$(,)?
-                $(sorted_index_key_property: $ignored:tt$(,)?)?
-            }$(,)?
-        ) => {
-            Some($value)
+    macro_rules! optional_or_fallback {
+        ($value:tt, $fallback:tt$(,)?) => {
+            $value
         };
-        (
-            sorted_index_key_property, // Name of field
-            {
-                $(mapped_physical_partition: $ignored:tt$(,)?)?
-                sorted_index_key_property: $value:tt$(,)?
-            }$(,)?
-        ) => {
-            Some($value)
-        };
-        (
-            $option_field_name:ident,
-            $($non_matching_stuff:tt)?$(,)?
-        ) => {
-            None
+        (, $fallback:tt$(,)?) => {
+            $fallback
         };
     }
 
     #[allow(unused)]
-    pub(crate) use extract_collection_option;
+    pub(crate) use optional_or_fallback;
 }
 
 #[cfg(test)]
diff --git a/radix-engine/src/blueprints/package/substates.rs b/radix-engine/src/blueprints/package/substates.rs
index 7783146cd56..8cecb50621c 100644
--- a/radix-engine/src/blueprints/package/substates.rs
+++ b/radix-engine/src/blueprints/package/substates.rs
@@ -44,6 +44,7 @@ declare_native_blueprint_state! {
         },
         schemas: KeyValue {
             entry_ident: Schema,
+            mapped_physical_partition: SCHEMAS_PARTITION,
             key_type: {
                 kind: Static,
                 content_type: SchemaHash,
@@ -54,9 +55,6 @@ declare_native_blueprint_state! {
                 content_type: ScryptoSchema,
             },
             allow_ownership: false,
-            options: {
-                mapped_physical_partition: SCHEMAS_PARTITION,
-            },
         },
         blueprint_version_royalty_configs: KeyValue {
             entry_ident: BlueprintVersionRoyaltyConfig,

From 792a283300d350e34179c9cecd73be42dfaa98d8 Mon Sep 17 00:00:00 2001
From: David Edey <david.edey@rdx.works>
Date: Mon, 21 Aug 2023 02:21:46 +0100
Subject: [PATCH 28/28] fix: Minor fix

---
 radix-engine/src/blueprints/models/keys.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/radix-engine/src/blueprints/models/keys.rs b/radix-engine/src/blueprints/models/keys.rs
index f48a747db7d..54570203cd5 100644
--- a/radix-engine/src/blueprints/models/keys.rs
+++ b/radix-engine/src/blueprints/models/keys.rs
@@ -84,7 +84,7 @@ macro_rules! declare_key_new_type {
             fn try_from(substate_key: &SubstateKey) -> Result<Self, Self::Error> {
                 let (sort_prefix, payload_bytes) = substate_key.for_sorted().ok_or(())?;
                 let content = scrypto_decode(payload_bytes).map_err(|_| ())?;
-                Ok(Self::from_sort_key_and_content(*sort_prefix, content))
+                Ok(Self::from_sort_key_and_content(u16::from_be_bytes(*sort_prefix), content))
             }
         }