From c2813b9a119eada505586160a936b6a84c86f809 Mon Sep 17 00:00:00 2001 From: xav-db Date: Fri, 5 Sep 2025 12:20:30 +0100 Subject: [PATCH 01/18] refactoring parser --- helix-cli/src/utils.rs | 12 +- helix-db/src/helixc/PLAN.md | 508 --- helix-db/src/helixc/analyzer/analyzer.rs | 2 +- helix-db/src/helixc/analyzer/errors.rs | 2 +- .../analyzer/methods/exclude_validation.rs | 2 +- .../analyzer/methods/graph_step_validation.rs | 4 +- .../analyzer/methods/infer_expr_type.rs | 117 +- .../analyzer/methods/migration_validation.rs | 2 +- .../analyzer/methods/object_validation.rs | 12 +- .../analyzer/methods/query_validation.rs | 8 +- .../helixc/analyzer/methods/schema_methods.rs | 2 +- .../analyzer/methods/statement_validation.rs | 2 +- .../analyzer/methods/traversal_validation.rs | 10 +- helix-db/src/helixc/analyzer/types.rs | 25 +- helix-db/src/helixc/analyzer/utils.rs | 4 +- helix-db/src/helixc/generator/migrations.rs | 2 +- .../src/helixc/generator/return_values.rs | 6 +- helix-db/src/helixc/generator/schemas.rs | 10 +- helix-db/src/helixc/generator/source_steps.rs | 48 +- helix-db/src/helixc/generator/utils.rs | 5 +- .../parser/creation_step_parse_methods.rs | 165 + .../helixc/parser/expression_parse_methods.rs | 502 +++ .../helixc/parser/graph_step_parse_methods.rs | 172 + helix-db/src/helixc/parser/helix_parser.rs | 3315 ----------------- helix-db/src/helixc/parser/location.rs | 12 +- .../helixc/parser/migration_parse_methods.rs | 0 helix-db/src/helixc/parser/mod.rs | 190 +- .../src/helixc/parser/object_parse_methods.rs | 223 ++ helix-db/src/helixc/parser/parser_methods.rs | 2 +- .../src/helixc/parser/query_parse_methods.rs | 142 + .../parser/return_value_parse_methods.rs | 107 + .../src/helixc/parser/schema_parse_methods.rs | 481 +++ .../helixc/parser/traversal_parse_methods.rs | 367 ++ helix-db/src/helixc/parser/types.rs | 958 +++++ helix-db/src/helixc/parser/utils.rs | 86 + helix-db/src/protocol/value.rs | 2 +- 36 files changed, 3578 insertions(+), 3929 deletions(-) delete mode 100644 helix-db/src/helixc/PLAN.md create mode 100644 helix-db/src/helixc/parser/creation_step_parse_methods.rs create mode 100644 helix-db/src/helixc/parser/expression_parse_methods.rs create mode 100644 helix-db/src/helixc/parser/graph_step_parse_methods.rs delete mode 100644 helix-db/src/helixc/parser/helix_parser.rs create mode 100644 helix-db/src/helixc/parser/migration_parse_methods.rs create mode 100644 helix-db/src/helixc/parser/object_parse_methods.rs create mode 100644 helix-db/src/helixc/parser/query_parse_methods.rs create mode 100644 helix-db/src/helixc/parser/return_value_parse_methods.rs create mode 100644 helix-db/src/helixc/parser/schema_parse_methods.rs create mode 100644 helix-db/src/helixc/parser/traversal_parse_methods.rs create mode 100644 helix-db/src/helixc/parser/types.rs create mode 100644 helix-db/src/helixc/parser/utils.rs diff --git a/helix-cli/src/utils.rs b/helix-cli/src/utils.rs index 19c98f8c..abec548f 100644 --- a/helix-cli/src/utils.rs +++ b/helix-cli/src/utils.rs @@ -9,7 +9,10 @@ use helix_db::{ helixc::{ analyzer::analyzer::analyze, generator::{Source as GeneratedSource, tsdisplay::ToTypeScript}, - parser::helix_parser::{Content, HelixParser, HxFile, Source}, + parser::{ + HelixParser, + types::{Content, HxFile, Source}, + }, }, utils::styled_string::StyledString, }; @@ -956,12 +959,7 @@ pub fn copy_repo_dir_for_build(src: &std::path::Path, dst: &std::path::Path) -> if let Some(file_name) = entry.file_name().to_str() && matches!( file_name, - ".git" - | ".gitignore" - | ".github" - | ".DS_Store" - | "target" - | "docs" + ".git" | ".gitignore" | ".github" | ".DS_Store" | "target" | "docs" ) { continue; diff --git a/helix-db/src/helixc/PLAN.md b/helix-db/src/helixc/PLAN.md deleted file mode 100644 index 082f1043..00000000 --- a/helix-db/src/helixc/PLAN.md +++ /dev/null @@ -1,508 +0,0 @@ -## db native functions - -## `add_e` - ---- - -#### deps - -```rs -self -label: &'a str -properties: Vec<(String, Value)> -from: &'a str -to: &'a str -secondary_indices: Option<&'a [String]> - -add_e(&label, properties, from, to, Some(idxs)) -``` - -#### query - -``` -QUERY addE({field1: value1, field2: value2, ...}) - e <- AddE({field1: value1, field2: value2, ...})::From(from_node_id)::To(to_node_id) -``` - -#### HQL rules - -- nothing can come before `AddE` - -## `add_n` - ---- - -#### deps - -```rs -self -label: &'a str -properties: Vec<(String, Value)> -secondary_indices: Option<&'a [String]> -// needs G::new_mut -add_n(&label, properties, Some(idxs)) -``` - -#### query - -``` -QUERY addN({field1: value1, field2: value2, ...}) - n <- AddN({field1: value1, field2: value2, ...}) -``` - -#### HQL rules - -- nothing can come before or after `AddN` - -## `add_v` - ---- - -#### deps - -```rs -query: Vec -vec_label: String -fields: Option> (HashMap::from(props! { ... })) -// needs G::new_mut -add_v(&query, &label, Some(fields)) -``` - -#### query - -``` -QUERY insertV(vec: [F64], label: String) - vec <- AddV(vec, {field1: value1, field2: value2, ...}) -``` - -#### HQL rules - -- nothing can come before or after `AddV` - -## `drop` - ---- - -#### deps - -```rs -query: Vec -vec_label: String -fields: Option> (HashMap::from(props! { ... })) -// needs G::new_mut -add_v(&query, &label, Some(fields)) -``` - -#### query - -``` -QUERY insertV(vec: [F64], label: String) - vec <- AddV(vec, {field1: value1, field2: value2, ...}) -``` - -#### HQL rules - -- nothing can come before or after `AddV` - -## `dedup` - ---- - -#### deps - -```rs -none - -.dedup() -``` - -#### query - -``` -QUERY dedup() => - nodes <- N::Out::Dedup() -``` - -#### HQL rules - -- anything that returns a collection of traversal items (nodes, edges, vectors) can be deduped -- it deduplicates in place -- for explicitness -- only object access can come after `Dedup` for explicitness (each source item is pushed through the entire traversal pipeline so the results are deduplicated instead any intermediate results) - - only objects because don't want to implicitly only deduplicate at the end if dedup is used in the middle of a traversal. - -## `filter_ref` - ---- - -#### deps - -```rs -f: Fn(&Result, &RoTxn) -> Result - -.filter_ref(|val: TraversalValue, txn: &'a RoTxn<'a>| -> Result { - // return true if val should be included - // return false if val should be excluded - // e.g. the following filters out all nodes with a name that is not "John" - if let Ok(TraversalValue::Node(node)) = val { - if let Some(value) = node.check_property("name") { - match value { - Value::String(name) => return Ok(name == "John"), - _ => return Ok(false), - } - } - } - false -}) -``` - -- Note that the Result is used because lmdb gets can be used and may fail thus returning an error. - -#### query - -``` -QUERY filter_ref() => - nodes <- N::WHERE(_::{name}::EQ("John")) -``` - -#### HQL rules - -- anything that returns a collection of traversal items (nodes, edges, vectors) can be filtered -- only an anonymous or an `EXISTS` traversal that evaluates to a boolean can be used in the `WHERE` clause - -## `for ... in ...` - ---- - -#### deps - -> instead of using a for loop as we are currently doing -> could use a `.iter()` that takes iterates through the parameter vec - -> QUESTION: do we allow the iterated value to be the result of a traversal? -> e.g. `FOR node in N::Out {...}` - -```rs -for data in data.nodes { - // do something with data -} -``` - -#### query - -``` -QUERY for_in(nodes: [Type]) => - FOR node IN nodes { - // do something with node - } -``` - -#### HQL rules - -- the iterated parameter must be a collection of items (nodes, edges, vectors) -- TODO: the iterated value can be the result of a traversal -- you can have nested for loops - -## `range` - ---- - -#### deps - -```rs -start: i32 -end: i32 - -.range(start, end) -``` - -#### query - -``` -QUERY range(start: Int, end: Int) => - nodes <- N::Range(start, end) -``` - -#### HQL rules - -- the start and end must be integers -- the start must be less than the end -- the start and end must be positive -- if the start is greater than the length of the collection, it will return an empty collection -- if the end is greater than the length of the collection, it will return the collection from the start index to the end of the collection - -## `update` - ---- - -#### deps - -```rs -// needs G::new_mut -.update(props: Vec<(String, Value)>) -``` - -#### query - -``` -QUERY update(node_id: ID, newNode: NodeType) => - N(node_id)::Update(newNode) - // assuming the node type has the fields `field1` and `field2` - N(node_id)::Update({field1: value1, field2: value2, ...}) -``` - -#### HQL rules - -- the value passed into Update must be of the corresponding node type -- or it can be a partial object that is on the node type - -## `out` - ---- - -#### deps - -```rs -edge_label: &'a str - -.out(edge_label: &'a str) -``` - -#### query - -``` -QUERY out() => - nodes <- N::Out -``` - -## `out_e` - ---- - -#### deps - -```rs -edge_label: &'a str - -.out_e(edge_label: &'a str) -``` - -#### query - -``` -QUERY out_e() => - edges <- N::OutE -``` - -## `in_` - ---- - -#### deps - -```rs -edge_label: &'a str - -.in(edge_label: &'a str) -``` - -#### query - -``` -QUERY in() => - nodes <- N::In -``` - -## `in_e` - ---- - -#### deps - -```rs -edge_label: &'a str - -.in_e(edge_label: &'a str) -``` - -#### query - -``` -QUERY in_e() => - edges <- N::InE -``` - -## `from_n` - ---- - -#### deps - -```rs -.from_n() -``` - -#### query - -``` -QUERY from_n(edge_id: ID) => - nodes <- E(edge_id)::FromN() -``` - -## `to_n` - ---- - -#### deps - -```rs -.to_n() -``` - -#### query - -``` -QUERY to_n(edge_id: ID) => - nodes <- E(edge_id)::ToN() -``` - - -## `search_v` - ---- - -#### deps - -```rs -query: Vec -k: usize -filter: Option<&[Fn(&HVector) -> bool]> - -.search_v(query: Vec, k: usize, filter: Option<&[Fn(&HVector) -> bool]>) -``` - -#### query - -``` -QUERY search_v(query: [F64], k: Int, doc_type: String) => - vectors <- SearchV(query, k)::PREFILTER(_::{doc_type}::EQ(docType)) -``` - -#### HQL rules - -- the prefilter must be an `EXISTS` traversal or an anonymous traversal that evaluates to a boolean -- the prefilter acts exactly like a `WHERE` clause -- the k must be an integer -- the query must be a vector - -## `e_from_id` - ---- - -#### deps - -```rs -edge_id: &u128 - -.e_from_id(edge_id: &u128) -``` - -#### query - -``` -QUERY e_from_id(edge_id: ID) => - edges <- E(edge_id) -``` - -#### HQL rules -- Type must exist in schema -- the ID type is a UUID String in HQL - - This will get converted to a u128 inside the query - -## `e_from_types` - ---- - -#### deps - -```rs -edge_label: &'a str - -.e_from_types(edge_label: &'a str) -``` - -#### query - -``` -QUERY e_from_types() => - edges <- E -``` - -#### HQL rules -- Type must exist in schema - -## `n_from_id` - ---- - -#### deps - -```rs -node_id: &u128 - -.n_from_id(node_id: &u128) -``` - -#### query - -``` -QUERY n_from_id(node_id: ID) => - nodes <- N(node_id) -``` - -#### HQL rules -- Type must exist in schema -- the ID type is a UUID String in HQL - - This will get converted to a u128 inside the query - -## `n_from_types` - ---- - -#### deps - -```rs -edge_label: &'a str - -.n_from_types(edge_label: &'a str) -``` - -#### query - -``` -QUERY n_from_types() => - nodes <- N -``` - -#### HQL rules -- Type must exist in schema - -# TODO - -## `bulk_add_e` - -## `bulk_add_n` - -## `insert_vs` - -## `filter_mut` - ---- - -#### deps - -```rs -self - -.filter_mut(filter) -``` diff --git a/helix-db/src/helixc/analyzer/analyzer.rs b/helix-db/src/helixc/analyzer/analyzer.rs index ddba9c80..f8c7dc8d 100644 --- a/helix-db/src/helixc/analyzer/analyzer.rs +++ b/helix-db/src/helixc/analyzer/analyzer.rs @@ -10,7 +10,7 @@ use crate::helixc::{ types::Type, }, generator::Source as GeneratedSource, - parser::helix_parser::{EdgeSchema, ExpressionType, Field, Query, ReturnType, Source}, + parser::types::{EdgeSchema, ExpressionType, Field, Query, ReturnType, Source}, }; use itertools::Itertools; use serde::Serialize; diff --git a/helix-db/src/helixc/analyzer/errors.rs b/helix-db/src/helixc/analyzer/errors.rs index e6ba8f4a..096645ff 100644 --- a/helix-db/src/helixc/analyzer/errors.rs +++ b/helix-db/src/helixc/analyzer/errors.rs @@ -5,7 +5,7 @@ use crate::helixc::{ error_codes::ErrorCode, fix::Fix, }, - parser::{helix_parser::Query, location::Loc}, + parser::{location::Loc, types::Query}, }; pub(crate) fn push_schema_err( diff --git a/helix-db/src/helixc/analyzer/methods/exclude_validation.rs b/helix-db/src/helixc/analyzer/methods/exclude_validation.rs index 9f013c38..2c61713c 100644 --- a/helix-db/src/helixc/analyzer/methods/exclude_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/exclude_validation.rs @@ -8,7 +8,7 @@ use crate::{ fix::Fix, types::Type, }, - parser::{helix_parser::*, location::Loc}, + parser::{types::*, location::Loc}, }, }; use paste::paste; diff --git a/helix-db/src/helixc/analyzer/methods/graph_step_validation.rs b/helix-db/src/helixc/analyzer/methods/graph_step_validation.rs index 4289451d..d6e7f0bf 100644 --- a/helix-db/src/helixc/analyzer/methods/graph_step_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/graph_step_validation.rs @@ -21,7 +21,7 @@ use crate::{ }, utils::{GenRef, GeneratedValue, Separator, VecData}, }, - parser::helix_parser::*, + parser::types::*, }, }; use paste::paste; @@ -322,12 +322,10 @@ pub(crate) fn apply_graph_step<'a>( } (ShortestPath(sp), Type::Nodes(_) | Type::Node(_)) => { let type_arg = sp.type_arg.clone().map(GenRef::Literal); - // check edge type is valid traversal .steps .push(Separator::Period(GeneratedStep::ShortestPath( match (sp.from.clone(), sp.to.clone()) { - // TODO: get rid of clone (Some(from), Some(to)) => GeneratedShortestPath { label: type_arg, from: Some(GenRef::from(from)), diff --git a/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs b/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs index 27b5d7bb..74233179 100644 --- a/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs +++ b/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs @@ -1,5 +1,6 @@ //! Semantic analyzer for Helix‑QL. use crate::helixc::analyzer::error_codes::ErrorCode; +use crate::helixc::analyzer::utils::DEFAULT_VAR_NAME; use crate::helixc::generator::utils::EmbedData; use crate::{ generate_error, @@ -26,7 +27,7 @@ use crate::{ }, utils::{GenRef, GeneratedValue, Separator, VecData}, }, - parser::helix_parser::*, + parser::types::*, }, protocol::date::Date, }; @@ -57,7 +58,6 @@ pub(crate) fn infer_expr_type<'a>( parent_ty: Option, gen_query: &mut GeneratedQuery, ) -> (Type, Option) { - // TODO: Look at returning statement as well or passing mut query to push to use ExpressionType::*; let expr: &ExpressionType = &expression.expr; match expr { @@ -98,32 +98,40 @@ pub(crate) fn infer_expr_type<'a>( Type::Boolean, Some(GeneratedStatement::Literal(GenRef::Literal(b.to_string()))), ), + // Gets expression type for each element in the array + // Checks if all elements are of the same type + // Returns the type of the array and the statements to generate from the array ArrayLiteral(a) => { let mut inner_array_ty = None; - let stmts = a - .iter() - .map(|e| { - let (ty, stmt) = infer_expr_type( - ctx, - e, - scope, - original_query, - parent_ty.clone(), - gen_query, - ); - if inner_array_ty.is_none() { - inner_array_ty = Some(ty); - } else { - // TODO handle type is same for all elements + let result = a.iter().try_fold(Vec::new(), |mut stmts, e| { + let (ty, stmt) = + infer_expr_type(ctx, e, scope, original_query, parent_ty.clone(), gen_query); + let type_str = ty.kind_str(); + if let Some(inner_array_ty) = &inner_array_ty { + if inner_array_ty != &ty { + generate_error!(ctx, original_query, e.loc.clone(), E306, type_str); } - // TODO handle none for stmt - stmt.unwrap() - }) - .collect::>(); - ( - inner_array_ty.unwrap(), - Some(GeneratedStatement::Array(stmts)), - ) + } else { + inner_array_ty = Some(ty); + } + match stmt { + Some(s) => { + stmts.push(s); + Ok(stmts) + } + None => { + generate_error!(ctx, original_query, e.loc.clone(), E306, type_str); + Err(()) + } + } + }); + match result { + Ok(stmts) => ( + Type::Array(Box::new(inner_array_ty.unwrap())), + Some(GeneratedStatement::Array(stmts)), + ), + Err(()) => (Type::Unknown, Some(GeneratedStatement::Empty)), + } } Traversal(tr) => { let mut gen_traversal = GeneratedTraversal::default(); @@ -136,7 +144,6 @@ pub(crate) fn infer_expr_type<'a>( &mut gen_traversal, gen_query, ); - // push query let stmt = GeneratedStatement::Traversal(gen_traversal); if matches!(expr, Exists(_)) { @@ -167,14 +174,13 @@ pub(crate) fn infer_expr_type<'a>( .filter_map(|p| p.default_value.clone().map(|v| (p.name.clone(), v))) .collect::>(); - // Validate fields if both type and fields are present + // Validate fields of add node by traversing the fields + // checking they exist in the schema, then checking their types let (properties, secondary_indices) = match &add.fields { - Some(fields) => { - // Get the field set before validation - // TODO: Check field types - let field_set = ctx.node_fields.get(ty.as_str()).cloned(); - if let Some(field_set) = field_set { - for (field_name, value) in fields { + Some(fields_to_add) => { + let field_set_from_schema = ctx.node_fields.get(ty.as_str()).cloned(); + if let Some(field_set) = field_set_from_schema { + for (field_name, field_value) in fields_to_add { if !field_set.contains_key(field_name.as_str()) { generate_error!( ctx, @@ -186,7 +192,7 @@ pub(crate) fn infer_expr_type<'a>( ty.as_str() ); } - match value { + match field_value { ValueType::Identifier { value, loc } => { if is_valid_identifier( ctx, @@ -202,10 +208,36 @@ pub(crate) fn infer_expr_type<'a>( E301, value.as_str() ); - }; + } else { + let variable_type = + scope.get(value.as_str()).unwrap(); + if variable_type + != &Type::from( + field_set + .get(field_name.as_str()) + .unwrap() + .field_type + .clone(), + ) + { + generate_error!( + ctx, + original_query, + loc.clone(), + E205, + value.as_str(), + &field_set + .get(field_name.as_str()) + .unwrap() + .field_type + .to_string(), + "node", + ty.as_str() + ); + } + } } ValueType::Literal { value, loc } => { - // check against type let field_type = ctx .node_fields .get(ty.as_str()) @@ -231,7 +263,7 @@ pub(crate) fn infer_expr_type<'a>( } } } - let mut properties = fields + let mut properties = fields_to_add .iter() .map(|(field_name, value)| { ( @@ -267,13 +299,7 @@ pub(crate) fn infer_expr_type<'a>( )), } } - ValueType::Identifier { value, loc } => { - is_valid_identifier( - ctx, - original_query, - loc.clone(), - value.as_str(), - ); + ValueType::Identifier { value, .. } => { gen_identifier_or_param( original_query, value, @@ -1056,10 +1082,9 @@ pub(crate) fn infer_expr_type<'a>( assert!(matches!(stmt, Some(GeneratedStatement::Traversal(_)))); let traversal = match stmt.unwrap() { GeneratedStatement::Traversal(mut tr) => { - // TODO: FIX VALUE HERE let source_variable = match tr.source_step.inner() { SourceStep::Identifier(id) => id.inner().clone(), - _ => "val".to_string(), + _ => DEFAULT_VAR_NAME.to_string(), }; tr.traversal_type = TraversalType::NestedFrom(GenRef::Std(source_variable)); tr.should_collect = ShouldCollect::No; diff --git a/helix-db/src/helixc/analyzer/methods/migration_validation.rs b/helix-db/src/helixc/analyzer/methods/migration_validation.rs index 3e9fb21c..39ed16f9 100644 --- a/helix-db/src/helixc/analyzer/methods/migration_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/migration_validation.rs @@ -8,7 +8,7 @@ use crate::{ }, utils::{GenRef, GeneratedValue, Separator}, }, - parser::helix_parser::{ + parser::types::{ FieldValueType, Migration, MigrationItem, MigrationPropertyMapping, }, }, diff --git a/helix-db/src/helixc/analyzer/methods/object_validation.rs b/helix-db/src/helixc/analyzer/methods/object_validation.rs index bae6ef3c..0f105d08 100644 --- a/helix-db/src/helixc/analyzer/methods/object_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/object_validation.rs @@ -1,6 +1,6 @@ //! Semantic analyzer for Helix‑QL. use crate::helixc::analyzer::error_codes::ErrorCode; -use crate::helixc::analyzer::utils::FieldLookup; +use crate::helixc::analyzer::utils::{FieldLookup, DEFAULT_VAR_NAME}; use crate::helixc::generator::object_remapping_generation::SingleFieldTraversalRemapping; use crate::{ generate_error, @@ -29,7 +29,7 @@ use crate::{ }, utils::{GenRef, Separator}, }, - parser::{helix_parser::*, location::Loc}, + parser::{types::*, location::Loc}, }, }; use paste::paste; @@ -191,13 +191,10 @@ pub(crate) fn parse_object_remapping<'a>( Some(parent_ty.clone()), gen_query, ); - assert!(stmt.is_some()); - assert!(matches!(stmt, Some(Statement::Traversal(_)))); let expr = match stmt.unwrap() { Statement::Traversal(mut tr) => { tr.traversal_type = - // TODO: FIX VALUE HERE - TraversalType::NestedFrom(GenRef::Std("val".to_string())); + TraversalType::NestedFrom(GenRef::Std(DEFAULT_VAR_NAME.to_string())); tr } _ => unreachable!(), @@ -267,7 +264,7 @@ pub(crate) fn parse_object_remapping<'a>( RemappingType::ValueRemapping(ValueRemapping { variable_name: closure_variable.get_variable_name(), field_name: key.clone(), - value: GenRef::from(lit.clone()), // TODO: Implement + value: GenRef::from(lit.clone()), should_spread, }) } @@ -476,7 +473,6 @@ fn parse_traversal_as_remapping_value<'a>( should_spread, }) } - // TODO: IF CLOSURE StepType::Object(ref object) if object.fields.len() == 1 && traversal.steps.len() == 1 => { diff --git a/helix-db/src/helixc/analyzer/methods/query_validation.rs b/helix-db/src/helixc/analyzer/methods/query_validation.rs index 77832ef4..eb70837e 100644 --- a/helix-db/src/helixc/analyzer/methods/query_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/query_validation.rs @@ -18,7 +18,7 @@ use crate::helixc::{ traversal_steps::ShouldCollect, utils::{GenRef, GeneratedValue}, }, - parser::{helix_parser::*, location::Loc}, + parser::{types::*, location::Loc}, }; use paste::paste; use std::collections::HashMap; @@ -41,8 +41,10 @@ pub(crate) fn validate_query<'a>(ctx: &mut Ctx<'a>, original_query: &'a Query) { if let FieldType::Identifier(ref id) = param.param_type.1 && is_valid_identifier(ctx, original_query, param.param_type.0.clone(), id.as_str()) { - // TODO: add support for edges - if !ctx.node_set.contains(id.as_str()) { + if !ctx.node_set.contains(id.as_str()) + && !ctx.edge_map.contains_key(id.as_str()) + && !ctx.vector_set.contains(id.as_str()) + { generate_error!( ctx, original_query, diff --git a/helix-db/src/helixc/analyzer/methods/schema_methods.rs b/helix-db/src/helixc/analyzer/methods/schema_methods.rs index d09454b0..c9c4b688 100644 --- a/helix-db/src/helixc/analyzer/methods/schema_methods.rs +++ b/helix-db/src/helixc/analyzer/methods/schema_methods.rs @@ -3,7 +3,7 @@ use std::{borrow::Cow, collections::HashMap}; use crate::helixc::{ analyzer::{analyzer::Ctx, error_codes::ErrorCode, errors::push_schema_err}, parser::{ - helix_parser::{Field, FieldPrefix, FieldType, Source}, + types::{Field, FieldPrefix, FieldType, Source}, location::Loc, }, }; diff --git a/helix-db/src/helixc/analyzer/methods/statement_validation.rs b/helix-db/src/helixc/analyzer/methods/statement_validation.rs index 69d90b96..14d1d0fc 100644 --- a/helix-db/src/helixc/analyzer/methods/statement_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/statement_validation.rs @@ -16,7 +16,7 @@ use crate::{ }, utils::GenRef, }, - parser::helix_parser::*, + parser::types::*, }, }; use paste::paste; diff --git a/helix-db/src/helixc/analyzer/methods/traversal_validation.rs b/helix-db/src/helixc/analyzer/methods/traversal_validation.rs index 4d06d8f6..d8664ecf 100644 --- a/helix-db/src/helixc/analyzer/methods/traversal_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/traversal_validation.rs @@ -1,4 +1,5 @@ use crate::helixc::analyzer::error_codes::*; +use crate::helixc::analyzer::utils::DEFAULT_VAR_NAME; use crate::helixc::generator::bool_op::{Contains, IsIn}; use crate::helixc::generator::source_steps::SearchVector; use crate::helixc::generator::utils::{EmbedData, VecData}; @@ -30,7 +31,7 @@ use crate::{ }, utils::{GenRef, GeneratedValue, Order, Separator}, }, - parser::{helix_parser::*, location::Loc}, + parser::{location::Loc, types::*}, }, protocol::value::Value, }; @@ -286,7 +287,7 @@ pub(crate) fn validate_traversal<'a>( // anonymous will be the traversal type rather than the start type StartNode::Anonymous => { let parent = parent_ty.unwrap(); - gen_traversal.traversal_type = TraversalType::FromVar(GenRef::Std("val".to_string())); // TODO: ensure this default is stable + gen_traversal.traversal_type = TraversalType::FromVar(GenRef::Std(DEFAULT_VAR_NAME.to_string())); gen_traversal.source_step = Separator::Empty(SourceStep::Anonymous); parent } @@ -515,11 +516,11 @@ pub(crate) fn validate_traversal<'a>( gen_traversal .steps .push(Separator::Period(GeneratedStep::Remapping(Remapping { - variable_name: "item".to_string(), // TODO: Change to start var + variable_name: DEFAULT_VAR_NAME.to_string(), is_inner: false, should_spread: false, remappings: vec![RemappingType::ExcludeField(ExcludeField { - variable_name: "item".to_string(), // TODO: Change to start var + variable_name: DEFAULT_VAR_NAME.to_string(), fields_to_exclude: ex .fields .iter() @@ -1044,7 +1045,6 @@ pub(crate) fn validate_traversal<'a>( ); } _ => { - // TODO: maybe use cur_ty instead of update.loc.span? generate_error!( ctx, original_query, diff --git a/helix-db/src/helixc/analyzer/types.rs b/helix-db/src/helixc/analyzer/types.rs index 77678eaa..1fa63a19 100644 --- a/helix-db/src/helixc/analyzer/types.rs +++ b/helix-db/src/helixc/analyzer/types.rs @@ -9,7 +9,7 @@ use crate::helixc::{ }, utils::{GenRef, GeneratedType, GeneratedValue, RustType as GeneratedRustType}, }, - parser::helix_parser::{ + parser::types::{ DefaultValue, EdgeSchema, FieldType, NodeSchema, Parameter, VectorSchema, }, }; @@ -240,6 +240,7 @@ pub(crate) enum Type { Vectors(Option), Scalar(FieldType), Object(HashMap), + Array(Box), Anonymous(Box), Boolean, Unknown, @@ -256,6 +257,7 @@ impl Type { Type::Vectors(_) => "vectors", Type::Scalar(_) => "scalar", Type::Object(_) => "object", + Type::Array(_) => "array", Type::Boolean => "boolean", Type::Unknown => "unknown", Type::Anonymous(ty) => ty.kind_str(), @@ -272,6 +274,7 @@ impl Type { Type::Vectors(Some(name)) => name.clone(), Type::Scalar(ft) => ft.to_string(), Type::Anonymous(ty) => ty.get_type_name(), + Type::Array(ty) => ty.get_type_name(), Type::Boolean => "boolean".to_string(), Type::Unknown => "unknown".to_string(), Type::Object(fields) => { @@ -293,7 +296,6 @@ impl Type { #[allow(dead_code)] /// Same, but returns an owned clone for convenience. pub fn cloned_base(&self) -> Type { - // TODO: never used? match self { Type::Anonymous(inner) => inner.cloned_base(), _ => self.clone(), @@ -338,6 +340,25 @@ impl Type { } } +impl PartialEq for Type { + fn eq(&self, other: &Self) -> bool { + match (self, other) { + (Type::Scalar(ft), Type::Scalar(other_ft)) => ft == other_ft, + (Type::Object(fields), Type::Object(other_fields)) => fields == other_fields, + (Type::Boolean, Type::Boolean) => true, + (Type::Unknown, Type::Unknown) => true, + (Type::Anonymous(inner), Type::Anonymous(other_inner)) => inner == other_inner, + (Type::Node(name), Type::Node(other_name)) => name == other_name, + (Type::Nodes(name), Type::Nodes(other_name)) => name == other_name, + (Type::Edge(name), Type::Edge(other_name)) => name == other_name, + (Type::Edges(name), Type::Edges(other_name)) => name == other_name, + (Type::Vector(name), Type::Vector(other_name)) => name == other_name, + (Type::Vectors(name), Type::Vectors(other_name)) => name == other_name, + _ => false, + } + } +} + impl From for Type { fn from(ft: FieldType) -> Self { use FieldType::*; diff --git a/helix-db/src/helixc/analyzer/utils.rs b/helix-db/src/helixc/analyzer/utils.rs index 1336a9d6..1b8f20b9 100644 --- a/helix-db/src/helixc/analyzer/utils.rs +++ b/helix-db/src/helixc/analyzer/utils.rs @@ -8,12 +8,14 @@ use crate::{ traversal_steps::Step, utils::{GenRef, GeneratedValue}, }, - parser::{helix_parser::*, location::Loc}, + parser::{location::Loc, types::*}, }, }; use paste::paste; use std::collections::HashMap; +pub(super) const DEFAULT_VAR_NAME: &str = "val"; + pub(super) fn is_valid_identifier( ctx: &mut Ctx, original_query: &Query, diff --git a/helix-db/src/helixc/generator/migrations.rs b/helix-db/src/helixc/generator/migrations.rs index d9655ca8..b138f46c 100644 --- a/helix-db/src/helixc/generator/migrations.rs +++ b/helix-db/src/helixc/generator/migrations.rs @@ -1,7 +1,7 @@ use crate::{ helixc::{ generator::utils::{GeneratedValue, Separator}, - parser::helix_parser::FieldType, + parser::types::FieldType, }, protocol::value::casting::CastType, }; diff --git a/helix-db/src/helixc/generator/return_values.rs b/helix-db/src/helixc/generator/return_values.rs index c92a419d..7dc03dff 100644 --- a/helix-db/src/helixc/generator/return_values.rs +++ b/helix-db/src/helixc/generator/return_values.rs @@ -70,9 +70,9 @@ impl ReturnValue { ReturnType::NamedLiteral(name) => name.inner().inner().to_string(), ReturnType::NamedExpr(name) => name.inner().inner().to_string(), ReturnType::SingleExpr(name) => name.inner().inner().to_string(), - ReturnType::UnnamedExpr => todo!(), - ReturnType::HashMap => todo!(), - ReturnType::Array => todo!(), + ReturnType::UnnamedExpr => unimplemented!(), + ReturnType::HashMap => unimplemented!(), + ReturnType::Array => unimplemented!(), } } diff --git a/helix-db/src/helixc/generator/schemas.rs b/helix-db/src/helixc/generator/schemas.rs index 6ffe0ebe..59bc23b6 100644 --- a/helix-db/src/helixc/generator/schemas.rs +++ b/helix-db/src/helixc/generator/schemas.rs @@ -1,7 +1,13 @@ use core::fmt; use std::fmt::Display; -use crate::helixc::{generator::{tsdisplay::ToTypeScript, utils::{GeneratedType, GeneratedValue}}, parser::helix_parser::FieldPrefix}; +use crate::helixc::{ + generator::{ + tsdisplay::ToTypeScript, + utils::{GeneratedType, GeneratedValue}, + }, + parser::types::FieldPrefix, +}; #[derive(Clone)] pub struct NodeSchema { @@ -123,4 +129,4 @@ pub struct SchemaProperty { pub default_value: Option, // pub is_optional: bool, pub is_index: FieldPrefix, -} \ No newline at end of file +} diff --git a/helix-db/src/helixc/generator/source_steps.rs b/helix-db/src/helixc/generator/source_steps.rs index daed5a28..f3efadec 100644 --- a/helix-db/src/helixc/generator/source_steps.rs +++ b/helix-db/src/helixc/generator/source_steps.rs @@ -10,25 +10,40 @@ use super::{ #[derive(Clone)] pub enum SourceStep { + /// Traversal starts from an identifier Identifier(GenRef), + /// Add a node AddN(AddN), + /// Add an edge AddE(AddE), + /// Insert a vector AddV(AddV), + /// Lookup a node by ID NFromID(NFromID), + /// Lookup a node by index NFromIndex(NFromIndex), + /// Lookup a node by type NFromType(NFromType), + /// Lookup an edge by ID EFromID(EFromID), + /// Lookup an edge by type EFromType(EFromType), + /// Search for vectors SearchVector(SearchVector), + /// Search for vectors using BM25 SearchBM25(SearchBM25), + /// Traversal starts from an anonymous node Anonymous, Empty, } #[derive(Clone)] pub struct AddN { + /// Label of node pub label: GenRef, + /// Properties of node pub properties: Option>, + /// Names of properties to index on pub secondary_indices: Option>, } impl Display for AddN { @@ -45,11 +60,14 @@ impl Display for AddN { #[derive(Clone)] pub struct AddE { + /// Label of edge pub label: GenRef, + /// Properties of edge pub properties: Option>, + /// From node ID pub from: GeneratedValue, + /// To node ID pub to: GeneratedValue, - // pub secondary_indices: Option>, } impl Display for AddE { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { @@ -65,8 +83,11 @@ impl Display for AddE { } #[derive(Clone)] pub struct AddV { + /// Vector to add pub vec: VecData, + /// Label of vector pub label: GenRef, + /// Properties of vector pub properties: Option>, } impl Display for AddV { @@ -84,18 +105,22 @@ impl Display for AddV { #[derive(Clone)] pub struct NFromID { + /// ID of node pub id: GenRef, - pub label: GenRef, // possible not needed, do we do runtime label checking? + /// Label of node + /// + /// - unused currently but kept in the case ID lookups need to be from specific table based on type + pub label: GenRef, } impl Display for NFromID { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - // TODO: possibly add label for runtime label checking? write!(f, "n_from_id({})", self.id) } } #[derive(Clone)] pub struct NFromType { + /// Label of nodes to lookup pub label: GenRef, } impl Display for NFromType { @@ -106,8 +131,12 @@ impl Display for NFromType { #[derive(Clone)] pub struct EFromID { + /// ID of edge pub id: GenRef, - pub label: GenRef, // possible not needed, do we do runtime label checking? + /// Label of edge + /// + /// - unused currently but kept in the case ID lookups need to be from specific table based on type + pub label: GenRef, } impl Display for EFromID { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { @@ -117,6 +146,7 @@ impl Display for EFromID { #[derive(Clone)] pub struct EFromType { + /// Label of edges to lookup pub label: GenRef, } impl Display for EFromType { @@ -127,8 +157,11 @@ impl Display for EFromType { #[derive(Clone)] pub struct SearchBM25 { + /// Type of node to search for pub type_arg: GenRef, + /// Query to search for pub query: GeneratedValue, + /// Number of results to return pub k: GeneratedValue, } @@ -160,9 +193,13 @@ impl Display for SourceStep { #[derive(Clone)] pub struct SearchVector { + /// Label of vector to search for pub label: GenRef, + /// Vector to search for pub vec: VecData, + /// Number of results to return pub k: GeneratedValue, + /// Pre-filter to apply to the search - currently not implemented in grammar pub pre_filter: Option>, } @@ -194,8 +231,11 @@ impl Display for SearchVector { #[derive(Clone)] pub struct NFromIndex { + /// Index to search against pub index: GenRef, + /// Key to search for in the index pub key: GeneratedValue, + /// Label of nodes to lookup - used for post filtering pub label: GenRef, } diff --git a/helix-db/src/helixc/generator/utils.rs b/helix-db/src/helixc/generator/utils.rs index 10b6c8e3..54dfc527 100644 --- a/helix-db/src/helixc/generator/utils.rs +++ b/helix-db/src/helixc/generator/utils.rs @@ -1,7 +1,6 @@ +use crate::helixc::parser::types::IdType; use std::fmt::{self, Debug, Display}; -use crate::helixc::parser::helix_parser::IdType; - #[derive(Clone)] pub enum GenRef where @@ -298,7 +297,7 @@ impl Display for RustType { RustType::F32 => write!(f, "f32"), RustType::F64 => write!(f, "f64"), RustType::Bool => write!(f, "bool"), - RustType::Uuid => write!(f, "ID"), // TODO: Change this for actual UUID + RustType::Uuid => write!(f, "ID"), RustType::Date => write!(f, "DateTime"), } } diff --git a/helix-db/src/helixc/parser/creation_step_parse_methods.rs b/helix-db/src/helixc/parser/creation_step_parse_methods.rs new file mode 100644 index 00000000..87d898a4 --- /dev/null +++ b/helix-db/src/helixc/parser/creation_step_parse_methods.rs @@ -0,0 +1,165 @@ +use crate::helixc::parser::{ + HelixParser, Rule, + location::HasLoc, + parser_methods::ParserError, + types::{AddEdge, AddNode, AddVector, Embed, EvaluatesToString, VectorData}, +}; +use pest::iterators::Pair; + +impl HelixParser { + pub(super) fn parse_add_vector(&self, pair: Pair) -> Result { + let mut vector_type = None; + let mut data = None; + let mut fields = None; + + for p in pair.clone().into_inner() { + match p.as_rule() { + Rule::identifier_upper => { + vector_type = Some(p.as_str().to_string()); + } + Rule::vector_data => match p.clone().into_inner().next() { + Some(vector_data) => match vector_data.as_rule() { + Rule::identifier => { + data = Some(VectorData::Identifier(p.as_str().to_string())); + } + Rule::vec_literal => { + data = Some(VectorData::Vector(self.parse_vec_literal(p)?)); + } + Rule::embed_method => { + data = Some(VectorData::Embed(Embed { + loc: vector_data.loc(), + value: match vector_data.clone().into_inner().next() { + Some(inner) => match inner.as_rule() { + Rule::identifier => EvaluatesToString::Identifier( + inner.as_str().to_string(), + ), + Rule::string_literal => EvaluatesToString::StringLiteral( + inner.as_str().to_string(), + ), + _ => { + return Err(ParserError::from(format!( + "Unexpected rule in AddV: {:?} => {:?}", + inner.as_rule(), + inner, + ))); + } + }, + None => { + return Err(ParserError::from(format!( + "Unexpected rule in AddV: {:?} => {:?}", + p.as_rule(), + p, + ))); + } + }, + })); + } + _ => { + return Err(ParserError::from(format!( + "Unexpected rule in AddV: {:?} => {:?}", + vector_data.as_rule(), + vector_data, + ))); + } + }, + None => { + return Err(ParserError::from(format!( + "Unexpected rule in AddV: {:?} => {:?}", + p.as_rule(), + p, + ))); + } + }, + Rule::create_field => { + fields = Some(self.parse_property_assignments(p)?); + } + _ => { + return Err(ParserError::from(format!( + "Unexpected rule in AddV: {:?} => {:?}", + p.as_rule(), + p, + ))); + } + } + } + + Ok(AddVector { + vector_type, + data, + fields, + loc: pair.loc(), + }) + } + + pub(super) fn parse_add_node(&self, pair: Pair) -> Result { + let mut node_type = None; + let mut fields = None; + + for p in pair.clone().into_inner() { + match p.as_rule() { + Rule::identifier_upper => { + node_type = Some(p.as_str().to_string()); + } + Rule::create_field => { + fields = Some(self.parse_property_assignments(p)?); + } + _ => { + return Err(ParserError::from(format!( + "Unexpected rule in AddV: {:?} => {:?}", + p.as_rule(), + p, + ))); + } + } + } + + Ok(AddNode { + node_type, + fields, + loc: pair.loc(), + }) + } + + pub(super) fn parse_add_edge( + &self, + pair: Pair, + from_identifier: bool, + ) -> Result { + let mut edge_type = None; + let mut fields = None; + let mut connection = None; + + for p in pair.clone().into_inner() { + match p.as_rule() { + Rule::identifier_upper => { + edge_type = Some(p.as_str().to_string()); + } + Rule::create_field => { + fields = Some(self.parse_property_assignments(p)?); + } + Rule::to_from => { + connection = Some(self.parse_to_from(p)?); + } + _ => { + return Err(ParserError::from(format!( + "Unexpected rule in AddE: {:?}", + p.as_rule() + ))); + } + } + } + if edge_type.is_none() { + return Err(ParserError::from("Missing edge type")); + } + if connection.is_none() { + return Err(ParserError::from("Missing edge connection")); + } + Ok(AddEdge { + edge_type, + fields, + connection: connection.ok_or_else(|| ParserError::from("Missing edge connection"))?, + from_identifier, + loc: pair.loc(), + }) + } +} diff --git a/helix-db/src/helixc/parser/expression_parse_methods.rs b/helix-db/src/helixc/parser/expression_parse_methods.rs new file mode 100644 index 00000000..cc18a736 --- /dev/null +++ b/helix-db/src/helixc/parser/expression_parse_methods.rs @@ -0,0 +1,502 @@ +use crate::{ + helixc::parser::{ + HelixParser, Rule, + location::{HasLoc, Loc}, + parser_methods::ParserError, + types::{ + Assignment, BM25Search, Embed, EvaluatesToNumber, EvaluatesToNumberType, + EvaluatesToString, ExistsExpression, Expression, ExpressionType, ForLoop, ForLoopVars, + SearchVector, ValueType, VectorData, + }, + }, + protocol::value::Value, +}; +use pest::iterators::{Pair, Pairs}; + +impl HelixParser { + pub(super) fn parse_assignment(&self, pair: Pair) -> Result { + let mut pairs = pair.clone().into_inner(); + let variable = pairs.next().unwrap().as_str().to_string(); + let value = self.parse_expression(pairs.next().unwrap())?; + + Ok(Assignment { + variable, + value, + loc: pair.loc(), + }) + } + + pub(super) fn parse_expression(&self, p: Pair) -> Result { + let pair = p + .into_inner() + .next() + .ok_or_else(|| ParserError::from("Empty expression"))?; + + match pair.as_rule() { + Rule::traversal => Ok(Expression { + loc: pair.loc(), + expr: ExpressionType::Traversal(Box::new(self.parse_traversal(pair)?)), + }), + Rule::id_traversal => Ok(Expression { + loc: pair.loc(), + expr: ExpressionType::Traversal(Box::new(self.parse_traversal(pair)?)), + }), + Rule::anonymous_traversal => Ok(Expression { + loc: pair.loc(), + expr: ExpressionType::Traversal(Box::new(self.parse_anon_traversal(pair)?)), + }), + Rule::identifier => Ok(Expression { + loc: pair.loc(), + expr: ExpressionType::Identifier(pair.as_str().to_string()), + }), + Rule::string_literal => Ok(Expression { + loc: pair.loc(), + expr: ExpressionType::StringLiteral(self.parse_string_literal(pair)?), + }), + Rule::exists => { + let loc = pair.loc(); + let mut inner = pair.into_inner(); + let negated = match inner.peek() { + Some(p) => p.as_rule() == Rule::negate, + None => false, + }; + if negated { + inner.next(); + } + let traversal = inner + .next() + .ok_or_else(|| ParserError::from("Missing traversal"))?; + let expr = ExpressionType::Exists(ExistsExpression { + loc: loc.clone(), + expr: Box::new(Expression { + loc: loc.clone(), + expr: ExpressionType::Traversal(Box::new(match traversal.as_rule() { + Rule::anonymous_traversal => self.parse_anon_traversal(traversal)?, + Rule::id_traversal => self.parse_traversal(traversal)?, + Rule::traversal => self.parse_traversal(traversal)?, + _ => unreachable!(), + })), + }), + }); + Ok(Expression { + loc: loc.clone(), + expr: match negated { + true => ExpressionType::Not(Box::new(Expression { + loc: loc.clone(), + expr, + })), + false => expr, + }, + }) + } + Rule::integer => pair + .as_str() + .parse() + .map(|i| Expression { + loc: pair.loc(), + expr: ExpressionType::IntegerLiteral(i), + }) + .map_err(|_| ParserError::from("Invalid integer literal")), + Rule::float => pair + .as_str() + .parse() + .map(|f| Expression { + loc: pair.loc(), + expr: ExpressionType::FloatLiteral(f), + }) + .map_err(|_| ParserError::from("Invalid float literal")), + Rule::boolean => Ok(Expression { + loc: pair.loc(), + expr: ExpressionType::BooleanLiteral(pair.as_str() == "true"), + }), + Rule::array_literal => Ok(Expression { + loc: pair.loc(), + expr: ExpressionType::ArrayLiteral(self.parse_array_literal(pair)?), + }), + Rule::evaluates_to_bool => Ok(self.parse_boolean_expression(pair)?), + Rule::AddN => Ok(Expression { + loc: pair.loc(), + expr: ExpressionType::AddNode(self.parse_add_node(pair)?), + }), + Rule::AddV => Ok(Expression { + loc: pair.loc(), + expr: ExpressionType::AddVector(self.parse_add_vector(pair)?), + }), + Rule::AddE => Ok(Expression { + loc: pair.loc(), + expr: ExpressionType::AddEdge(self.parse_add_edge(pair, false)?), + }), + Rule::search_vector => Ok(Expression { + loc: pair.loc(), + expr: ExpressionType::SearchVector(self.parse_search_vector(pair)?), + }), + Rule::none => Ok(Expression { + loc: pair.loc(), + expr: ExpressionType::Empty, + }), + Rule::bm25_search => Ok(Expression { + loc: pair.loc(), + expr: ExpressionType::BM25Search(self.parse_bm25_search(pair)?), + }), + _ => Err(ParserError::from(format!( + "Unexpected expression type: {:?}", + pair.as_rule() + ))), + } + } + + pub(super) fn parse_boolean_expression( + &self, + pair: Pair, + ) -> Result { + let expression = pair.into_inner().next().unwrap(); + match expression.as_rule() { + Rule::and => { + let loc: Loc = expression.loc(); + let mut inner = expression.into_inner(); + let negated = match inner.peek() { + Some(p) => p.as_rule() == Rule::negate, + None => false, + }; + if negated { + inner.next(); + } + let exprs = self.parse_expression_vec(inner)?; + Ok(Expression { + loc: loc.clone(), + expr: match negated { + true => ExpressionType::Not(Box::new(Expression { + loc, + expr: ExpressionType::And(exprs), + })), + false => ExpressionType::And(exprs), + }, + }) + } + Rule::or => { + let loc: Loc = expression.loc(); + let mut inner = expression.into_inner(); + let negated = match inner.peek() { + Some(p) => p.as_rule() == Rule::negate, + None => false, + }; + if negated { + inner.next(); + } + let exprs = self.parse_expression_vec(inner)?; + Ok(Expression { + loc: loc.clone(), + expr: match negated { + true => ExpressionType::Not(Box::new(Expression { + loc, + expr: ExpressionType::Or(exprs), + })), + false => ExpressionType::Or(exprs), + }, + }) + } + Rule::boolean => Ok(Expression { + loc: expression.loc(), + expr: ExpressionType::BooleanLiteral(expression.as_str() == "true"), + }), + Rule::exists => { + let loc = expression.loc(); + let mut inner = expression.into_inner(); + let negated = match inner.peek() { + Some(p) => p.as_rule() == Rule::negate, + None => false, + }; + if negated { + inner.next(); + } + let traversal = inner + .next() + .ok_or_else(|| ParserError::from("Missing traversal"))?; + let expr = ExpressionType::Exists(ExistsExpression { + loc: loc.clone(), + expr: Box::new(Expression { + loc: loc.clone(), + expr: ExpressionType::Traversal(Box::new( + self.parse_anon_traversal(traversal)?, + )), + }), + }); + Ok(Expression { + loc: loc.clone(), + expr: match negated { + true => ExpressionType::Not(Box::new(Expression { + loc: loc.clone(), + expr, + })), + false => expr, + }, + }) + } + + _ => unreachable!(), + } + } + pub(super) fn parse_expression_vec( + &self, + pairs: Pairs, + ) -> Result, ParserError> { + let mut expressions = Vec::new(); + for p in pairs { + match p.as_rule() { + Rule::anonymous_traversal => { + expressions.push(Expression { + loc: p.loc(), + expr: ExpressionType::Traversal(Box::new(self.parse_anon_traversal(p)?)), + }); + } + Rule::traversal => { + expressions.push(Expression { + loc: p.loc(), + expr: ExpressionType::Traversal(Box::new(self.parse_traversal(p)?)), + }); + } + Rule::id_traversal => { + expressions.push(Expression { + loc: p.loc(), + expr: ExpressionType::Traversal(Box::new(self.parse_traversal(p)?)), + }); + } + Rule::evaluates_to_bool => { + expressions.push(self.parse_boolean_expression(p)?); + } + _ => unreachable!(), + } + } + Ok(expressions) + } + + pub(super) fn parse_bm25_search(&self, pair: Pair) -> Result { + let mut pairs = pair.clone().into_inner(); + let vector_type = pairs.next().unwrap().as_str().to_string(); + let query = match pairs.next() { + Some(pair) => match pair.as_rule() { + Rule::identifier => ValueType::Identifier { + value: pair.as_str().to_string(), + loc: pair.loc(), + }, + Rule::string_literal => ValueType::Literal { + value: Value::String(pair.as_str().to_string()), + loc: pair.loc(), + }, + _ => { + return Err(ParserError::from(format!( + "Unexpected rule in BM25Search: {:?}", + pair.as_rule() + ))); + } + }, + None => { + return Err(ParserError::from(format!( + "Unexpected rule in BM25Search: {:?}", + pair.as_rule() + ))); + } + }; + let k = Some(match pairs.next() { + Some(pair) => match pair.as_rule() { + Rule::identifier => EvaluatesToNumber { + loc: pair.loc(), + value: EvaluatesToNumberType::Identifier(pair.as_str().to_string()), + }, + Rule::integer => EvaluatesToNumber { + loc: pair.loc(), + value: EvaluatesToNumberType::I32( + pair.as_str() + .to_string() + .parse::() + .map_err(|_| ParserError::from("Invalid integer value"))?, + ), + }, + _ => { + return Err(ParserError::from(format!( + "Unexpected rule in BM25Search: {:?}", + pair.as_rule() + ))); + } + }, + None => { + return Err(ParserError::from(format!( + "Unexpected rule in BM25Search: {:?}", + pair.as_rule() + ))); + } + }); + + Ok(BM25Search { + loc: pair.loc(), + type_arg: Some(vector_type), + data: Some(query), + k, + }) + } + + pub(super) fn parse_for_loop(&self, pair: Pair) -> Result { + let mut pairs = pair.clone().into_inner(); + // parse the arguments + let argument = pairs.next().unwrap().clone().into_inner().next().unwrap(); + let argument_loc = argument.loc(); + let variable = match argument.as_rule() { + Rule::object_destructuring => { + let fields = argument + .into_inner() + .map(|p| (p.loc(), p.as_str().to_string())) + .collect(); + ForLoopVars::ObjectDestructuring { + fields, + loc: argument_loc, + } + } + Rule::object_access => { + let mut inner = argument.clone().into_inner(); + let object_name = inner.next().unwrap().as_str().to_string(); + let field_name = inner.next().unwrap().as_str().to_string(); + ForLoopVars::ObjectAccess { + name: object_name, + field: field_name, + loc: argument_loc, + } + } + Rule::identifier => ForLoopVars::Identifier { + name: argument.as_str().to_string(), + loc: argument_loc, + }, + _ => { + return Err(ParserError::from(format!( + "Unexpected rule in ForLoop: {:?}", + argument.as_rule() + ))); + } + }; + + // parse the in + let in_ = pairs.next().unwrap().clone(); + let in_variable = match in_.as_rule() { + Rule::identifier => (in_.loc(), in_.as_str().to_string()), + _ => { + return Err(ParserError::from(format!( + "Unexpected rule in ForLoop: {:?}", + in_.as_rule() + ))); + } + }; + // parse the body + let statements = self.parse_query_body(pairs.next().unwrap())?; + + Ok(ForLoop { + variable, + in_variable, + statements, + loc: pair.loc(), + }) + } + + pub(super) fn parse_search_vector( + &self, + pair: Pair, + ) -> Result { + let mut vector_type = None; + let mut data = None; + let mut k: Option = None; + let mut pre_filter = None; + for p in pair.clone().into_inner() { + match p.as_rule() { + Rule::identifier_upper => { + vector_type = Some(p.as_str().to_string()); + } + Rule::vector_data => match p.clone().into_inner().next() { + Some(vector_data) => match vector_data.as_rule() { + Rule::identifier => { + data = Some(VectorData::Identifier(p.as_str().to_string())); + } + Rule::vec_literal => { + data = Some(VectorData::Vector(self.parse_vec_literal(p)?)); + } + Rule::embed_method => { + data = Some(VectorData::Embed(Embed { + loc: vector_data.loc(), + value: match vector_data.clone().into_inner().next() { + Some(inner) => match inner.as_rule() { + Rule::identifier => EvaluatesToString::Identifier( + inner.as_str().to_string(), + ), + Rule::string_literal => EvaluatesToString::StringLiteral( + inner.as_str().to_string(), + ), + _ => { + return Err(ParserError::from(format!( + "Unexpected rule in SearchV: {:?} => {:?}", + inner.as_rule(), + inner, + ))); + } + }, + None => { + return Err(ParserError::from(format!( + "Unexpected rule in SearchV: {:?} => {:?}", + p.as_rule(), + p, + ))); + } + }, + })); + } + _ => { + return Err(ParserError::from(format!( + "Unexpected rule in SearchV: {:?} => {:?}", + vector_data.as_rule(), + vector_data, + ))); + } + }, + None => { + return Err(ParserError::from(format!( + "Unexpected rule in SearchV: {:?} => {:?}", + p.as_rule(), + p, + ))); + } + }, + Rule::integer => { + k = Some(EvaluatesToNumber { + loc: p.loc(), + value: EvaluatesToNumberType::I32( + p.as_str() + .to_string() + .parse::() + .map_err(|_| ParserError::from("Invalid integer value"))?, + ), + }); + } + Rule::identifier => { + k = Some(EvaluatesToNumber { + loc: p.loc(), + value: EvaluatesToNumberType::Identifier(p.as_str().to_string()), + }); + } + Rule::pre_filter => { + pre_filter = Some(Box::new(self.parse_expression(p)?)); + } + _ => { + return Err(ParserError::from(format!( + "Unexpected rule in SearchV: {:?} => {:?}", + p.as_rule(), + p, + ))); + } + } + } + + Ok(SearchVector { + loc: pair.loc(), + vector_type, + data, + k, + pre_filter, + }) + } +} diff --git a/helix-db/src/helixc/parser/graph_step_parse_methods.rs b/helix-db/src/helixc/parser/graph_step_parse_methods.rs new file mode 100644 index 00000000..76470210 --- /dev/null +++ b/helix-db/src/helixc/parser/graph_step_parse_methods.rs @@ -0,0 +1,172 @@ +use crate::helixc::parser::{ + HelixParser, Rule, + location::HasLoc, + parser_methods::ParserError, + types::{ + BooleanOp, BooleanOpType, Closure, Exclude, Expression, FieldAddition, FieldValue, + FieldValueType, Object, OrderBy, OrderByType, Update, + }, +}; +use pest::iterators::Pair; + +impl HelixParser { + pub fn parse_order_by(&self, pair: Pair) -> Result { + let mut inner = pair.clone().into_inner(); + let order_by_type = match inner.next().unwrap().into_inner().next().unwrap().as_rule() { + Rule::asc => OrderByType::Asc, + Rule::desc => OrderByType::Desc, + _ => unreachable!(), + }; + let expression = self.parse_expression(inner.next().unwrap())?; + Ok(OrderBy { + loc: pair.loc(), + order_by_type, + expression: Box::new(expression), + }) + } + + pub fn parse_range(&self, pair: Pair) -> Result<(Expression, Expression), ParserError> { + let mut inner = pair.into_inner().next().unwrap().into_inner(); + // println!("inner: {:?}", inner); + let start = self.parse_expression(inner.next().unwrap())?; + let end = self.parse_expression(inner.next().unwrap())?; + + Ok((start, end)) + } + + pub fn parse_bool_operation(&self, pair: Pair) -> Result { + let inner = pair.clone().into_inner().next().unwrap(); + let expr = match inner.as_rule() { + Rule::GT => BooleanOp { + loc: pair.loc(), + op: BooleanOpType::GreaterThan(Box::new( + self.parse_expression(inner.into_inner().next().unwrap())?, + )), + }, + Rule::GTE => BooleanOp { + loc: pair.loc(), + op: BooleanOpType::GreaterThanOrEqual(Box::new( + self.parse_expression(inner.into_inner().next().unwrap())?, + )), + }, + Rule::LT => BooleanOp { + loc: pair.loc(), + op: BooleanOpType::LessThan(Box::new( + self.parse_expression(inner.into_inner().next().unwrap())?, + )), + }, + Rule::LTE => BooleanOp { + loc: pair.loc(), + op: BooleanOpType::LessThanOrEqual(Box::new( + self.parse_expression(inner.into_inner().next().unwrap())?, + )), + }, + Rule::EQ => BooleanOp { + loc: pair.loc(), + op: BooleanOpType::Equal(Box::new( + self.parse_expression(inner.into_inner().next().unwrap())?, + )), + }, + Rule::NEQ => BooleanOp { + loc: pair.loc(), + op: BooleanOpType::NotEqual(Box::new( + self.parse_expression(inner.into_inner().next().unwrap())?, + )), + }, + Rule::CONTAINS => BooleanOp { + loc: pair.loc(), + op: BooleanOpType::Contains(Box::new( + self.parse_expression(inner.into_inner().next().unwrap())?, + )), + }, + Rule::IS_IN => BooleanOp { + loc: pair.loc(), + op: BooleanOpType::IsIn(Box::new(self.parse_expression(inner)?)), + }, + _ => return Err(ParserError::from("Invalid boolean operation")), + }; + Ok(expr) + } + + pub fn parse_update(&self, pair: Pair) -> Result { + let fields = self.parse_object_fields(pair.clone())?; + Ok(Update { + fields, + loc: pair.loc(), + }) + } + + pub fn parse_object_step(&self, pair: Pair) -> Result { + let mut fields = Vec::new(); + let mut should_spread = false; + for p in pair.clone().into_inner() { + if p.as_rule() == Rule::spread_object { + should_spread = true; + continue; + } + let mut pairs = p.clone().into_inner(); + let prop_key = pairs.next().unwrap().as_str().to_string(); + let field_addition = match pairs.next() { + Some(p) => match p.as_rule() { + Rule::evaluates_to_anything => FieldValue { + loc: p.loc(), + value: FieldValueType::Expression(self.parse_expression(p)?), + }, + Rule::anonymous_traversal => FieldValue { + loc: p.loc(), + value: FieldValueType::Traversal(Box::new(self.parse_anon_traversal(p)?)), + }, + Rule::mapping_field => FieldValue { + loc: p.loc(), + value: FieldValueType::Fields(self.parse_object_fields(p)?), + }, + Rule::object_step => FieldValue { + loc: p.clone().loc(), + value: FieldValueType::Fields(self.parse_object_step(p.clone())?.fields), + }, + _ => self.parse_new_field_value(p)?, + }, + None if !prop_key.is_empty() => FieldValue { + loc: p.loc(), + value: FieldValueType::Identifier(prop_key.clone()), + }, + None => FieldValue { + loc: p.loc(), + value: FieldValueType::Empty, + }, + }; + fields.push(FieldAddition { + loc: p.loc(), + key: prop_key, + value: field_addition, + }); + } + Ok(Object { + loc: pair.loc(), + fields, + should_spread, + }) + } + + pub fn parse_closure(&self, pair: Pair) -> Result { + let mut pairs = pair.clone().into_inner(); + let identifier = pairs.next().unwrap().as_str().to_string(); + let object = self.parse_object_step(pairs.next().unwrap())?; + Ok(Closure { + loc: pair.loc(), + identifier, + object, + }) + } + + pub fn parse_exclude(&self, pair: Pair) -> Result { + let mut fields = Vec::new(); + for p in pair.clone().into_inner() { + fields.push((p.loc(), p.as_str().to_string())); + } + Ok(Exclude { + loc: pair.loc(), + fields, + }) + } +} diff --git a/helix-db/src/helixc/parser/helix_parser.rs b/helix-db/src/helixc/parser/helix_parser.rs deleted file mode 100644 index 74e775d6..00000000 --- a/helix-db/src/helixc/parser/helix_parser.rs +++ /dev/null @@ -1,3315 +0,0 @@ -use super::{ - location::{HasLoc, Loc}, - parser_methods::ParserError, -}; -use crate::protocol::value::Value; -use chrono::{DateTime, NaiveDate, Utc}; -use itertools::Itertools; -use pest::{ - Parser as PestParser, - iterators::{Pair, Pairs}, -}; -use pest_derive::Parser; -use serde::{Deserialize, Serialize}; -use std::{ - collections::{HashMap, HashSet}, - fmt::{Debug, Display}, - io::Write, -}; - -#[derive(Parser)] -#[grammar = "grammar.pest"] -pub struct HelixParser { - source: Source, -} - -pub struct Content { - /// Source code of the content - pub content: String, - /// Parsed source code - pub source: Source, - /// Files in the content - pub files: Vec, -} - -#[derive(Clone, Serialize, Deserialize)] -pub struct HxFile { - pub name: String, - pub content: String, -} - -impl Default for HelixParser { - fn default() -> Self { - HelixParser { - source: Source { - source: String::new(), - schema: HashMap::new(), - migrations: Vec::new(), - queries: Vec::new(), - }, - } - } -} - -// AST Structures -#[derive(Debug, Clone, Default)] -pub struct Source { - pub source: String, - pub schema: HashMap, - pub migrations: Vec, - pub queries: Vec, -} - -impl Source { - pub fn get_latest_schema(&self) -> &Schema { - let latest_schema = self - .schema - .iter() - .max_by(|a, b| a.1.version.1.cmp(&b.1.version.1)) - .map(|(_, schema)| schema); - assert!(latest_schema.is_some()); - latest_schema.unwrap() - } - - /// Gets the schemas in order of version, from oldest to newest. - pub fn get_schemas_in_order(&self) -> Vec<&Schema> { - self.schema - .iter() - .sorted_by(|a, b| a.1.version.1.cmp(&b.1.version.1)) - .map(|(_, schema)| schema) - .collect() - } -} - -#[derive(Debug, Clone)] -pub struct Schema { - pub loc: Loc, - pub version: (Loc, usize), - pub node_schemas: Vec, - pub edge_schemas: Vec, - pub vector_schemas: Vec, -} - -#[derive(Debug, Clone)] -pub struct NodeSchema { - pub name: (Loc, String), - pub fields: Vec, - pub loc: Loc, -} - -#[derive(Debug, Clone)] -pub struct VectorSchema { - pub name: String, - pub fields: Vec, - pub loc: Loc, -} - -#[derive(Debug, Clone)] -pub struct EdgeSchema { - pub name: (Loc, String), - pub from: (Loc, String), - pub to: (Loc, String), - pub properties: Option>, - pub loc: Loc, -} - -#[derive(Debug, Clone)] -pub struct Migration { - pub from_version: (Loc, usize), - pub to_version: (Loc, usize), - pub body: Vec, - pub loc: Loc, -} - -#[derive(Debug, Clone)] -pub enum MigrationItem { - Node(String), - Edge(String), - Vector(String), -} - -impl MigrationItem { - pub fn inner(&self) -> &str { - match self { - MigrationItem::Node(s) => s, - MigrationItem::Edge(s) => s, - MigrationItem::Vector(s) => s, - } - } -} - -impl PartialEq for MigrationItem { - fn eq(&self, other: &MigrationItem) -> bool { - match (self, other) { - (MigrationItem::Node(a), MigrationItem::Node(b)) => a == b, - (MigrationItem::Edge(a), MigrationItem::Edge(b)) => a == b, - (MigrationItem::Vector(a), MigrationItem::Vector(b)) => a == b, - _ => false, - } - } -} - -#[derive(Debug, Clone)] -pub struct MigrationItemMapping { - pub from_item: (Loc, MigrationItem), - pub to_item: (Loc, MigrationItem), - pub remappings: Vec, - pub loc: Loc, -} - -#[derive(Debug, Clone)] -pub struct MigrationPropertyMapping { - pub property_name: (Loc, String), - pub property_value: FieldValue, - pub default: Option, - pub cast: Option, - pub loc: Loc, -} - -#[derive(Debug, Clone)] -pub struct ValueCast { - pub loc: Loc, - pub cast_to: FieldType, -} - -#[derive(Debug, Clone)] -pub struct Field { - pub prefix: FieldPrefix, - pub defaults: Option, - pub name: String, - pub field_type: FieldType, - pub loc: Loc, -} -impl Field { - pub fn is_indexed(&self) -> bool { - self.prefix.is_indexed() - } -} - -#[derive(Debug, Clone)] -pub enum DefaultValue { - Now, - String(String), - F32(f32), - F64(f64), - I8(i8), - I16(i16), - I32(i32), - I64(i64), - U8(u8), - U16(u16), - U32(u32), - U64(u64), - U128(u128), - Boolean(bool), - Empty, -} - -#[derive(Debug, Clone)] -pub enum FieldPrefix { - Index, - Optional, - Empty, -} -impl FieldPrefix { - pub fn is_indexed(&self) -> bool { - matches!(self, FieldPrefix::Index) - } -} - -#[derive(Debug, Clone)] -pub enum FieldType { - String, - F32, - F64, - I8, - I16, - I32, - I64, - U8, - U16, - U32, - U64, - U128, - Boolean, - Uuid, - Date, - Array(Box), - Identifier(String), - Object(HashMap), - // Closure(String, HashMap), -} - -impl PartialEq for FieldType { - fn eq(&self, other: &Self) -> bool { - match (self, other) { - (FieldType::String, FieldType::String) => true, - (FieldType::F32 | FieldType::F64, FieldType::F32 | FieldType::F64) => true, - ( - FieldType::I8 - | FieldType::I16 - | FieldType::I32 - | FieldType::I64 - | FieldType::U8 - | FieldType::U16 - | FieldType::U32 - | FieldType::U64 - | FieldType::U128, - FieldType::I8 - | FieldType::I16 - | FieldType::I32 - | FieldType::I64 - | FieldType::U8 - | FieldType::U16 - | FieldType::U32 - | FieldType::U64 - | FieldType::U128, - ) => true, - - (FieldType::Boolean, FieldType::Boolean) => true, - (FieldType::Uuid, FieldType::Uuid) => true, - (FieldType::Date, FieldType::Date) => true, - (FieldType::Array(a), FieldType::Array(b)) => a == b, - (FieldType::Identifier(a), FieldType::Identifier(b)) => a == b, - (FieldType::Object(a), FieldType::Object(b)) => a == b, - // (FieldType::Closure(a, b), FieldType::Closure(c, d)) => a == c && b == d, - _ => false, - } - } -} - -impl Display for FieldType { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - FieldType::String => write!(f, "String"), - FieldType::F32 => write!(f, "F32"), - FieldType::F64 => write!(f, "F64"), - FieldType::I8 => write!(f, "I8"), - FieldType::I16 => write!(f, "I16"), - FieldType::I32 => write!(f, "I32"), - FieldType::I64 => write!(f, "I64"), - FieldType::U8 => write!(f, "U8"), - FieldType::U16 => write!(f, "U16"), - FieldType::U32 => write!(f, "U32"), - FieldType::U64 => write!(f, "U64"), - FieldType::U128 => write!(f, "U128"), - FieldType::Boolean => write!(f, "Boolean"), - FieldType::Uuid => write!(f, "ID"), - FieldType::Date => write!(f, "Date"), - FieldType::Array(t) => write!(f, "Array({t})"), - FieldType::Identifier(s) => write!(f, "{s}"), - FieldType::Object(m) => { - write!(f, "{{")?; - for (k, v) in m { - write!(f, "{k}: {v}")?; - } - write!(f, "}}") - } // FieldType::Closure(a, b) => write!(f, "Closure({})", a), - } - } -} - -impl PartialEq for FieldType { - fn eq(&self, other: &Value) -> bool { - match (self, other) { - (FieldType::String, Value::String(_)) => true, - (FieldType::F32 | FieldType::F64, Value::F32(_) | Value::F64(_)) => true, - ( - FieldType::I8 - | FieldType::I16 - | FieldType::I32 - | FieldType::I64 - | FieldType::U8 - | FieldType::U16 - | FieldType::U32 - | FieldType::U64 - | FieldType::U128, - Value::I8(_) - | Value::I16(_) - | Value::I32(_) - | Value::I64(_) - | Value::U8(_) - | Value::U16(_) - | Value::U32(_) - | Value::U64(_) - | Value::U128(_), - ) => true, - (FieldType::Boolean, Value::Boolean(_)) => true, - (FieldType::Array(inner_type), Value::Array(values)) => { - values.iter().all(|v| inner_type.as_ref().eq(v)) - } - (FieldType::Object(fields), Value::Object(values)) => { - fields.len() == values.len() - && fields.iter().all(|(k, field_type)| match values.get(k) { - Some(value) => field_type.eq(value), - None => false, - }) - } - (FieldType::Date, value) => match value { - Value::String(date) => { - println!("date: {}, {:?}", date, date.parse::()); - date.parse::().is_ok() || date.parse::>().is_ok() - } - Value::I64(timestamp) => DateTime::from_timestamp(*timestamp, 0).is_some(), - Value::U64(timestamp) => DateTime::from_timestamp(*timestamp as i64, 0).is_some(), - _ => false, - }, - l => { - println!("l: {l:?}"); - false - } - } - } -} - -impl PartialEq for FieldType { - fn eq(&self, other: &DefaultValue) -> bool { - match (self, other) { - (FieldType::String, DefaultValue::String(_)) => true, - (FieldType::F32 | FieldType::F64, DefaultValue::F32(_) | DefaultValue::F64(_)) => true, - ( - FieldType::I8 - | FieldType::I16 - | FieldType::I32 - | FieldType::I64 - | FieldType::U8 - | FieldType::U16 - | FieldType::U32 - | FieldType::U64 - | FieldType::U128, - DefaultValue::I8(_) - | DefaultValue::I16(_) - | DefaultValue::I32(_) - | DefaultValue::I64(_) - | DefaultValue::U8(_) - | DefaultValue::U16(_) - | DefaultValue::U32(_) - | DefaultValue::U64(_) - | DefaultValue::U128(_), - ) => true, - (FieldType::Boolean, DefaultValue::Boolean(_)) => true, - (FieldType::Date, DefaultValue::String(date)) => { - println!("date: {}, {:?}", date, date.parse::()); - date.parse::().is_ok() || date.parse::>().is_ok() - } - (FieldType::Date, DefaultValue::I64(timestamp)) => { - DateTime::from_timestamp(*timestamp, 0).is_some() - } - (FieldType::Date, DefaultValue::U64(timestamp)) => { - DateTime::from_timestamp(*timestamp as i64, 0).is_some() - } - (FieldType::Date, DefaultValue::Now) => true, - _ => false, - } - } -} - -#[derive(Debug, Clone)] -pub struct Query { - pub original_query: String, - pub built_in_macro: Option, - pub name: String, - pub parameters: Vec, - pub statements: Vec, - pub return_values: Vec, - pub loc: Loc, -} - -#[derive(Debug, Clone)] -pub struct Parameter { - pub name: (Loc, String), - pub param_type: (Loc, FieldType), - pub is_optional: bool, - pub loc: Loc, -} - -#[derive(Debug, Clone)] -pub struct Statement { - pub loc: Loc, - pub statement: StatementType, -} - -#[derive(Debug, Clone)] -pub enum StatementType { - Assignment(Assignment), - Expression(Expression), - Drop(Expression), - ForLoop(ForLoop), -} - -#[derive(Debug, Clone)] -pub struct Assignment { - pub variable: String, - pub value: Expression, - pub loc: Loc, -} - -#[derive(Debug, Clone)] -pub struct ForLoop { - pub variable: ForLoopVars, - pub in_variable: (Loc, String), - pub statements: Vec, - pub loc: Loc, -} - -#[derive(Debug, Clone)] -pub enum ForLoopVars { - Identifier { - name: String, - loc: Loc, - }, - ObjectAccess { - name: String, - field: String, - loc: Loc, - }, - ObjectDestructuring { - fields: Vec<(Loc, String)>, - loc: Loc, - }, -} - -#[derive(Debug, Clone)] -pub struct Expression { - pub loc: Loc, - pub expr: ExpressionType, -} - -#[derive(Debug, Clone)] -pub struct ExistsExpression { - pub loc: Loc, - pub expr: Box, -} - -#[derive(Clone)] -pub enum ExpressionType { - Traversal(Box), - Identifier(String), - StringLiteral(String), - IntegerLiteral(i32), - FloatLiteral(f64), - BooleanLiteral(bool), - ArrayLiteral(Vec), - Exists(ExistsExpression), - BatchAddVector(BatchAddVector), - AddVector(AddVector), - AddNode(AddNode), - AddEdge(AddEdge), - Not(Box), - And(Vec), - Or(Vec), - SearchVector(SearchVector), - BM25Search(BM25Search), - Empty, -} - -#[derive(Debug, Clone)] -pub enum ReturnType { - Array(Vec), - Object(HashMap), - Expression(Expression), - Empty, -} - -impl Debug for ExpressionType { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - ExpressionType::Traversal(traversal) => write!(f, "Traversal({traversal:?})"), - ExpressionType::Identifier(s) => write!(f, "{s}"), - ExpressionType::StringLiteral(s) => write!(f, "{s}"), - ExpressionType::IntegerLiteral(i) => write!(f, "{i}"), - ExpressionType::FloatLiteral(fl) => write!(f, "{fl}"), - ExpressionType::BooleanLiteral(b) => write!(f, "{b}"), - ExpressionType::ArrayLiteral(a) => write!(f, "Array({a:?})"), - ExpressionType::Exists(e) => write!(f, "Exists({e:?})"), - ExpressionType::BatchAddVector(bav) => write!(f, "BatchAddVector({bav:?})"), - ExpressionType::AddVector(av) => write!(f, "AddVector({av:?})"), - ExpressionType::AddNode(an) => write!(f, "AddNode({an:?})"), - ExpressionType::AddEdge(ae) => write!(f, "AddEdge({ae:?})"), - ExpressionType::Not(expr) => write!(f, "Not({expr:?})"), - ExpressionType::And(exprs) => write!(f, "And({exprs:?})"), - ExpressionType::Or(exprs) => write!(f, "Or({exprs:?})"), - ExpressionType::SearchVector(sv) => write!(f, "SearchVector({sv:?})"), - ExpressionType::BM25Search(bm25) => write!(f, "BM25Search({bm25:?})"), - ExpressionType::Empty => write!(f, "Empty"), - } - } -} -impl Display for ExpressionType { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - ExpressionType::Traversal(traversal) => write!(f, "Traversal({traversal:?})"), - ExpressionType::Identifier(s) => write!(f, "{s}"), - ExpressionType::StringLiteral(s) => write!(f, "{s}"), - ExpressionType::IntegerLiteral(i) => write!(f, "{i}"), - ExpressionType::FloatLiteral(fl) => write!(f, "{fl}"), - ExpressionType::BooleanLiteral(b) => write!(f, "{b}"), - ExpressionType::ArrayLiteral(a) => write!(f, "Array({a:?})"), - ExpressionType::Exists(e) => write!(f, "Exists({e:?})"), - ExpressionType::BatchAddVector(bav) => write!(f, "BatchAddVector({bav:?})"), - ExpressionType::AddVector(av) => write!(f, "AddVector({av:?})"), - ExpressionType::AddNode(an) => write!(f, "AddNode({an:?})"), - ExpressionType::AddEdge(ae) => write!(f, "AddEdge({ae:?})"), - ExpressionType::Not(expr) => write!(f, "Not({expr:?})"), - ExpressionType::And(exprs) => write!(f, "And({exprs:?})"), - ExpressionType::Or(exprs) => write!(f, "Or({exprs:?})"), - ExpressionType::SearchVector(sv) => write!(f, "SearchVector({sv:?})"), - ExpressionType::BM25Search(bm25) => write!(f, "BM25Search({bm25:?})"), - ExpressionType::Empty => write!(f, "Empty"), - } - } -} - -#[derive(Debug, Clone)] -pub struct Traversal { - pub start: StartNode, - pub steps: Vec, - pub loc: Loc, -} - -#[derive(Debug, Clone)] -pub struct BatchAddVector { - pub vector_type: Option, - pub vec_identifier: Option, - pub fields: Option>, - pub loc: Loc, -} - -#[derive(Debug, Clone)] -pub enum StartNode { - Node { - node_type: String, - ids: Option>, - }, - Edge { - edge_type: String, - ids: Option>, - }, - SearchVector(SearchVector), - Identifier(String), - Anonymous, -} - -#[derive(Debug, Clone)] -pub struct Step { - pub loc: Loc, - pub step: StepType, -} - -#[derive(Debug, Clone)] -pub enum OrderByType { - Asc, - Desc, -} - -#[derive(Debug, Clone)] -pub struct OrderBy { - pub loc: Loc, - pub order_by_type: OrderByType, - pub expression: Box, -} - -#[derive(Debug, Clone)] -pub enum StepType { - Node(GraphStep), - Edge(GraphStep), - Where(Box), - BooleanOperation(BooleanOp), - Count, - Update(Update), - Object(Object), - Exclude(Exclude), - Closure(Closure), - Range((Expression, Expression)), - OrderBy(OrderBy), - AddEdge(AddEdge), -} -impl PartialEq for StepType { - fn eq(&self, other: &StepType) -> bool { - matches!( - (self, other), - (&StepType::Node(_), &StepType::Node(_)) - | (&StepType::Edge(_), &StepType::Edge(_)) - | (&StepType::Where(_), &StepType::Where(_)) - | ( - &StepType::BooleanOperation(_), - &StepType::BooleanOperation(_) - ) - | (&StepType::Count, &StepType::Count) - | (&StepType::Update(_), &StepType::Update(_)) - | (&StepType::Object(_), &StepType::Object(_)) - | (&StepType::Exclude(_), &StepType::Exclude(_)) - | (&StepType::Closure(_), &StepType::Closure(_)) - | (&StepType::Range(_), &StepType::Range(_)) - | (&StepType::OrderBy(_), &StepType::OrderBy(_)) - | (&StepType::AddEdge(_), &StepType::AddEdge(_)) - ) - } -} -#[derive(Debug, Clone)] -pub struct FieldAddition { - pub key: String, - pub value: FieldValue, - pub loc: Loc, -} - -#[derive(Debug, Clone)] -pub struct FieldValue { - pub loc: Loc, - pub value: FieldValueType, -} - -#[derive(Debug, Clone)] -pub enum FieldValueType { - Traversal(Box), - Expression(Expression), - Fields(Vec), - Literal(Value), - Identifier(String), - Empty, -} - -#[derive(Debug, Clone)] -pub struct GraphStep { - pub loc: Loc, - pub step: GraphStepType, -} - -#[derive(Debug, Clone)] -pub enum GraphStepType { - Out(String), - In(String), - - FromN, - ToN, - FromV, - ToV, - - OutE(String), - InE(String), - - ShortestPath(ShortestPath), - SearchVector(SearchVector), -} -impl GraphStep { - pub fn get_item_type(&self) -> Option { - match &self.step { - GraphStepType::Out(s) => Some(s.clone()), - GraphStepType::In(s) => Some(s.clone()), - GraphStepType::OutE(s) => Some(s.clone()), - GraphStepType::InE(s) => Some(s.clone()), - GraphStepType::SearchVector(s) => Some(s.vector_type.clone().unwrap()), - _ => None, - } - } -} - -#[derive(Debug, Clone)] -pub struct ShortestPath { - pub loc: Loc, - pub from: Option, - pub to: Option, - pub type_arg: Option, -} - -#[derive(Debug, Clone)] -pub struct BooleanOp { - pub loc: Loc, - pub op: BooleanOpType, -} - -#[derive(Debug, Clone)] -pub enum BooleanOpType { - And(Vec), - Or(Vec), - GreaterThan(Box), - GreaterThanOrEqual(Box), - LessThan(Box), - LessThanOrEqual(Box), - Equal(Box), - NotEqual(Box), - Contains(Box), - IsIn(Box), -} - -#[derive(Debug, Clone)] -pub enum VectorData { - Vector(Vec), - Identifier(String), - Embed(Embed), -} - -#[derive(Debug, Clone)] -pub struct Embed { - pub loc: Loc, - pub value: EvaluatesToString, -} - -#[derive(Debug, Clone)] -pub enum EvaluatesToString { - Identifier(String), - StringLiteral(String), -} - -#[derive(Debug, Clone)] -pub struct SearchVector { - pub loc: Loc, - pub vector_type: Option, - pub data: Option, - pub k: Option, - pub pre_filter: Option>, -} - -#[derive(Debug, Clone)] -pub struct BM25Search { - pub loc: Loc, - pub type_arg: Option, - pub data: Option, - pub k: Option, -} - -#[derive(Debug, Clone)] -pub struct EvaluatesToNumber { - pub loc: Loc, - pub value: EvaluatesToNumberType, -} - -#[derive(Debug, Clone)] -pub enum EvaluatesToNumberType { - I8(i8), - I16(i16), - I32(i32), - I64(i64), - U8(u8), - U16(u16), - U32(u32), - U64(u64), - U128(u128), - F32(f32), - F64(f64), - Identifier(String), -} - -#[derive(Debug, Clone)] -pub struct AddVector { - pub loc: Loc, - pub vector_type: Option, - pub data: Option, - pub fields: Option>, -} - -#[derive(Debug, Clone)] -pub struct AddNode { - pub loc: Loc, - pub node_type: Option, - pub fields: Option>, -} - -#[derive(Debug, Clone)] -pub struct AddEdge { - pub loc: Loc, - pub edge_type: Option, - pub fields: Option>, - pub connection: EdgeConnection, - pub from_identifier: bool, -} - -#[derive(Debug, Clone)] -pub struct EdgeConnection { - pub loc: Loc, - pub from_id: Option, - pub to_id: Option, -} - -#[derive(Debug, Clone)] -pub enum IdType { - Literal { - value: String, - loc: Loc, - }, - Identifier { - value: String, - loc: Loc, - }, - ByIndex { - index: Box, - value: Box, - loc: Loc, - }, -} -impl Display for IdType { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - IdType::Literal { value, loc: _ } => write!(f, "{value}"), - IdType::Identifier { value, loc: _ } => write!(f, "{value}"), - IdType::ByIndex { - index, - value: _, - loc: _, - } => write!(f, "{index}"), - } - } -} - -#[derive(Debug, Clone)] -pub enum ValueType { - Literal { - value: Value, - loc: Loc, - }, - Identifier { - value: String, - loc: Loc, - }, - Object { - fields: HashMap, - loc: Loc, - }, -} -impl ValueType { - pub fn new(value: Value, loc: Loc) -> ValueType { - ValueType::Literal { value, loc } - } - pub fn to_string(&self) -> String { - match self { - ValueType::Literal { value, loc: _ } => value.to_string(), - ValueType::Identifier { value, loc: _ } => value.clone(), - ValueType::Object { fields, loc: _ } => { - fields.keys().cloned().collect::>().join(", ") - } - } - } -} - -impl From for ValueType { - fn from(value: Value) -> ValueType { - match value { - Value::String(s) => ValueType::Literal { - value: Value::String(s), - loc: Loc::empty(), - }, - Value::I32(i) => ValueType::Literal { - value: Value::I32(i), - loc: Loc::empty(), - }, - Value::F64(f) => ValueType::Literal { - value: Value::F64(f), - loc: Loc::empty(), - }, - Value::Boolean(b) => ValueType::Literal { - value: Value::Boolean(b), - loc: Loc::empty(), - }, - Value::Array(arr) => ValueType::Literal { - value: Value::Array(arr), - loc: Loc::empty(), - }, - Value::Empty => ValueType::Literal { - value: Value::Empty, - loc: Loc::empty(), - }, - _ => unreachable!(), - } - } -} - -impl From for String { - fn from(id_type: IdType) -> String { - match id_type { - IdType::Literal { mut value, loc: _ } => { - value.retain(|c| c != '"'); - value - } - IdType::Identifier { value, loc: _ } => value, - IdType::ByIndex { - index, - value: _, - loc: _, - } => String::from(*index), - } - } -} - -impl From for IdType { - fn from(mut s: String) -> IdType { - s.retain(|c| c != '"'); - IdType::Literal { - value: s, - loc: Loc::empty(), - } - } -} - -#[derive(Debug, Clone)] -pub struct Update { - pub fields: Vec, - pub loc: Loc, -} - -#[derive(Debug, Clone)] -pub struct Object { - pub loc: Loc, - // TODO: Change this to be a vec of structs where the enums holds the name and value - pub fields: Vec, - pub should_spread: bool, -} - -#[derive(Debug, Clone)] -pub struct Exclude { - pub fields: Vec<(Loc, String)>, - pub loc: Loc, -} - -#[derive(Debug, Clone)] -pub struct Closure { - pub identifier: String, - pub object: Object, - pub loc: Loc, -} - -#[derive(Debug, Clone)] -pub enum BuiltInMacro { - MCP, - Model(String), -} - -impl HelixParser { - pub fn parse_source(input: &Content) -> Result { - let mut source = Source { - source: String::new(), - schema: HashMap::new(), - migrations: Vec::new(), - queries: Vec::new(), - }; - - input.files.iter().try_for_each(|file| { - source.source.push_str(&file.content); - source.source.push('\n'); - let pair = match HelixParser::parse(Rule::source, &file.content) { - Ok(mut pairs) => pairs - .next() - .ok_or_else(|| ParserError::from("Empty input"))?, - Err(e) => { - return Err(ParserError::from(e)); - } - }; - let mut parser = HelixParser { - source: Source::default(), - }; - - let pairs = pair.into_inner(); - let mut remaining_queries = HashSet::new(); - let mut remaining_migrations = HashSet::new(); - for pair in pairs { - match pair.as_rule() { - Rule::schema_def => { - let mut schema_pairs = pair.into_inner(); - - let schema_version = match schema_pairs.peek() { - Some(pair) => { - if pair.as_rule() == Rule::schema_version { - schema_pairs - .next() - .unwrap() - .into_inner() - .next() - .unwrap() - .as_str() - .parse::() - .unwrap() - } else { - 1 - } - } - None => 1, - }; - - for pair in schema_pairs { - match pair.as_rule() { - Rule::node_def => { - let node_schema = - parser.parse_node_def(pair.clone(), file.name.clone())?; - parser - .source - .schema - .entry(schema_version) - .and_modify(|schema| { - schema.node_schemas.push(node_schema.clone()) - }) - .or_insert(Schema { - loc: pair.loc(), - version: (pair.loc(), schema_version), - node_schemas: vec![node_schema], - edge_schemas: vec![], - vector_schemas: vec![], - }); - } - Rule::edge_def => { - let edge_schema = - parser.parse_edge_def(pair.clone(), file.name.clone())?; - parser - .source - .schema - .entry(schema_version) - .and_modify(|schema| { - schema.edge_schemas.push(edge_schema.clone()) - }) - .or_insert(Schema { - loc: pair.loc(), - version: (pair.loc(), schema_version), - node_schemas: vec![], - edge_schemas: vec![edge_schema], - vector_schemas: vec![], - }); - } - Rule::vector_def => { - let vector_schema = - parser.parse_vector_def(pair.clone(), file.name.clone())?; - parser - .source - .schema - .entry(schema_version) - .and_modify(|schema| { - schema.vector_schemas.push(vector_schema.clone()) - }) - .or_insert(Schema { - loc: pair.loc(), - version: (pair.loc(), schema_version), - node_schemas: vec![], - edge_schemas: vec![], - vector_schemas: vec![vector_schema], - }); - } - _ => return Err(ParserError::from("Unexpected rule encountered")), - } - } - } - Rule::migration_def => { - remaining_migrations.insert(pair); - } - Rule::query_def => { - // parser.source.queries.push(parser.parse_query_def(pairs.next().unwrap())?), - remaining_queries.insert(pair); - } - Rule::EOI => (), - _ => return Err(ParserError::from("Unexpected rule encountered")), - } - } - - for pair in remaining_migrations { - let migration = parser.parse_migration_def(pair, file.name.clone())?; - parser.source.migrations.push(migration); - } - - for pair in remaining_queries { - parser - .source - .queries - .push(parser.parse_query_def(pair, file.name.clone())?); - } - - // parse all schemas first then parse queries using self - source.schema.extend(parser.source.schema); - source.queries.extend(parser.source.queries); - source.migrations.extend(parser.source.migrations); - Ok(()) - })?; - - Ok(source) - } - - fn parse_node_def( - &self, - pair: Pair, - filepath: String, - ) -> Result { - let mut pairs = pair.clone().into_inner(); - let name = pairs.next().unwrap().as_str().to_string(); - let fields = self.parse_node_body(pairs.next().unwrap())?; - Ok(NodeSchema { - name: (pair.loc(), name), - fields, - loc: pair.loc_with_filepath(filepath), - }) - } - - fn parse_vector_def( - &self, - pair: Pair, - filepath: String, - ) -> Result { - let mut pairs = pair.clone().into_inner(); - let name = pairs.next().unwrap().as_str().to_string(); - let fields = self.parse_node_body(pairs.next().unwrap())?; - Ok(VectorSchema { - name, - fields, - loc: pair.loc_with_filepath(filepath), - }) - } - - fn parse_node_body(&self, pair: Pair) -> Result, ParserError> { - let field_defs = pair - .into_inner() - .find(|p| p.as_rule() == Rule::field_defs) - .expect("Expected field_defs in properties"); - - // Now parse each individual field_def - field_defs - .into_inner() - .map(|p| self.parse_field_def(p)) - .collect::, _>>() - } - - fn parse_migration_def( - &self, - pair: Pair, - filepath: String, - ) -> Result { - let mut pairs = pair.clone().into_inner(); - let from_version = pairs.next().unwrap().into_inner().next().unwrap(); - let to_version = pairs.next().unwrap().into_inner().next().unwrap(); - - // migration body -> [migration-item-mapping, migration-item-mapping, ...] - let body = pairs - .next() - .unwrap() - .into_inner() - .map(|p| self.parse_migration_item_mapping(p)) - .collect::, _>>()?; - - Ok(Migration { - from_version: ( - from_version.loc(), - from_version.as_str().parse::().unwrap(), - ), - to_version: ( - to_version.loc(), - to_version.as_str().parse::().unwrap(), - ), - body, - loc: pair.loc_with_filepath(filepath), - }) - } - - fn parse_migration_item_mapping( - &self, - pair: Pair, - ) -> Result { - let mut pairs = pair.clone().into_inner(); - let from_item_type = match pairs.next() { - Some(item_def) => match item_def.into_inner().next() { - Some(item_decl) => match item_decl.as_rule() { - Rule::node_decl => ( - item_decl.loc(), - MigrationItem::Node( - item_decl.into_inner().next().unwrap().as_str().to_string(), - ), - ), - Rule::edge_decl => ( - item_decl.loc(), - MigrationItem::Edge( - item_decl.into_inner().next().unwrap().as_str().to_string(), - ), - ), - Rule::vec_decl => ( - item_decl.loc(), - MigrationItem::Vector( - item_decl.into_inner().next().unwrap().as_str().to_string(), - ), - ), - _ => { - return Err(ParserError::from(format!( - "Expected item declaration, got {:?}", - item_decl.as_rule() - ))); - } - }, - None => { - return Err(ParserError::from(format!( - "Expected item declaration, got {:?}", - pair.as_rule() - ))); - } - }, - _ => { - return Err(ParserError::from(format!( - "Expected item declaration, got {:?}", - pair.as_rule() - ))); - } - }; - - let to_item_type = match pairs.next() { - Some(pair) => match pair.as_rule() { - Rule::item_def => match pair.into_inner().next() { - Some(item_decl) => match item_decl.as_rule() { - Rule::node_decl => ( - item_decl.loc(), - MigrationItem::Node( - item_decl.into_inner().next().unwrap().as_str().to_string(), - ), - ), - Rule::edge_decl => ( - item_decl.loc(), - MigrationItem::Edge( - item_decl.into_inner().next().unwrap().as_str().to_string(), - ), - ), - Rule::vec_decl => ( - item_decl.loc(), - MigrationItem::Vector( - item_decl.into_inner().next().unwrap().as_str().to_string(), - ), - ), - _ => { - return Err(ParserError::from(format!( - "Expected item declaration, got {:?}", - item_decl.as_rule() - ))); - } - }, - None => { - return Err(ParserError::from(format!( - "Expected item, got {:?}", - pairs.peek() - ))); - } - }, - Rule::anon_decl => from_item_type.clone(), - _ => { - return Err(ParserError::from(format!( - "Invalid item declaration, got {:?}", - pair.as_rule() - ))); - } - }, - None => { - return Err(ParserError::from(format!( - "Expected item_def, got {:?}", - pairs.peek() - ))); - } - }; - let remappings = match pairs.next() { - Some(p) => match p.as_rule() { - Rule::node_migration => p - .into_inner() - .next() - .unwrap() - .into_inner() - .map(|p| self.parse_field_migration(p)) - .collect::, _>>()?, - Rule::edge_migration => p - .into_inner() - .next() - .unwrap() - .into_inner() - .map(|p| self.parse_field_migration(p)) - .collect::, _>>()?, - _ => { - return Err(ParserError::from( - "Expected node_migration or edge_migration", - )); - } - }, - None => { - return Err(ParserError::from( - "Expected node_migration or edge_migration", - )); - } - }; - // let remappings = Vec::new(); - // for pair in pairs { - // match pair.as_rule() { - // Rule::node_migration => { - // remappings.push(self.parse_field_migration(pair.into_inner().next().unwrap())?); - // } - // Rule::edge_migration => { - // remappings.push(self.parse_field_migration(pair.into_inner().next().unwrap())?); - // } - // } - // } - - Ok(MigrationItemMapping { - from_item: from_item_type, - to_item: to_item_type, - remappings, - loc: pair.loc(), - }) - } - - fn parse_default_value( - &self, - pairs: &mut Pairs, - field_type: &FieldType, - ) -> Option { - match pairs.peek() { - Some(pair) => { - if pair.as_rule() == Rule::default { - pairs.next(); - let default_value = match pair.into_inner().next() { - Some(pair) => match pair.as_rule() { - Rule::string_literal => DefaultValue::String(pair.as_str().to_string()), - Rule::float => { - match field_type { - FieldType::F32 => { - DefaultValue::F32(pair.as_str().parse::().unwrap()) - } - FieldType::F64 => { - DefaultValue::F64(pair.as_str().parse::().unwrap()) - } - _ => unreachable!(), // throw error - } - } - Rule::integer => { - match field_type { - FieldType::I8 => { - DefaultValue::I8(pair.as_str().parse::().unwrap()) - } - FieldType::I16 => { - DefaultValue::I16(pair.as_str().parse::().unwrap()) - } - FieldType::I32 => { - DefaultValue::I32(pair.as_str().parse::().unwrap()) - } - FieldType::I64 => { - DefaultValue::I64(pair.as_str().parse::().unwrap()) - } - FieldType::U8 => { - DefaultValue::U8(pair.as_str().parse::().unwrap()) - } - FieldType::U16 => { - DefaultValue::U16(pair.as_str().parse::().unwrap()) - } - FieldType::U32 => { - DefaultValue::U32(pair.as_str().parse::().unwrap()) - } - FieldType::U64 => { - DefaultValue::U64(pair.as_str().parse::().unwrap()) - } - FieldType::U128 => { - DefaultValue::U128(pair.as_str().parse::().unwrap()) - } - _ => unreachable!(), // throw error - } - } - Rule::now => DefaultValue::Now, - Rule::boolean => { - DefaultValue::Boolean(pair.as_str().parse::().unwrap()) - } - _ => unreachable!(), // throw error - }, - None => DefaultValue::Empty, - }; - Some(default_value) - } else { - None - } - } - None => None, - } - } - - fn parse_cast(&self, pair: Pair) -> Option { - match pair.as_rule() { - Rule::cast => Some(ValueCast { - loc: pair.loc(), - cast_to: self - .parse_field_type(pair.into_inner().next().unwrap(), None) - .ok()?, - }), - _ => None, - } - } - - fn parse_field_migration( - &self, - pair: Pair, - ) -> Result { - let mut pairs = pair.clone().into_inner(); - let property_name = pairs.next().unwrap(); - let property_value = pairs.next().unwrap(); - let cast = if let Some(cast_pair) = pairs.next() { - self.parse_cast(cast_pair) - } else { - None - }; - - Ok(MigrationPropertyMapping { - property_name: (property_name.loc(), property_name.as_str().to_string()), - property_value: self.parse_field_value(property_value)?, - default: None, - cast, - loc: pair.loc(), - }) - } - - fn parse_field_type( - &self, - field: Pair, - _schema: Option<&Source>, - ) -> Result { - match field.as_rule() { - Rule::named_type => { - let type_str = field.as_str(); - match type_str { - "String" => Ok(FieldType::String), - "Boolean" => Ok(FieldType::Boolean), - "F32" => Ok(FieldType::F32), - "F64" => Ok(FieldType::F64), - "I8" => Ok(FieldType::I8), - "I16" => Ok(FieldType::I16), - "I32" => Ok(FieldType::I32), - "I64" => Ok(FieldType::I64), - "U8" => Ok(FieldType::U8), - "U16" => Ok(FieldType::U16), - "U32" => Ok(FieldType::U32), - "U64" => Ok(FieldType::U64), - "U128" => Ok(FieldType::U128), - _ => unreachable!(), - } - } - Rule::array => { - Ok(FieldType::Array(Box::new( - self.parse_field_type( - // unwraps the array type because grammar type is - // { array { param_type { array | object | named_type } } } - field - .into_inner() - .next() - .unwrap() - .into_inner() - .next() - .unwrap(), - _schema, - )?, - ))) - } - Rule::object => { - let mut fields = HashMap::new(); - for field in field.into_inner().next().unwrap().into_inner() { - let (field_name, field_type) = { - let mut field_pair = field.clone().into_inner(); - ( - field_pair.next().unwrap().as_str().to_string(), - field_pair.next().unwrap().into_inner().next().unwrap(), - ) - }; - let field_type = self.parse_field_type(field_type, Some(&self.source))?; - fields.insert(field_name, field_type); - } - Ok(FieldType::Object(fields)) - } - Rule::identifier => Ok(FieldType::Identifier(field.as_str().to_string())), - Rule::ID_TYPE => Ok(FieldType::Uuid), - Rule::date_type => Ok(FieldType::Date), - _ => { - unreachable!() - } - } - } - - fn parse_field_def(&self, pair: Pair) -> Result { - let mut pairs = pair.clone().into_inner(); - // structure is index? ~ identifier ~ ":" ~ param_type - let prefix: FieldPrefix = match pairs.clone().next().unwrap().as_rule() { - Rule::index => { - pairs.next().unwrap(); - FieldPrefix::Index - } - // Rule::optional => { - // pairs.next().unwrap(); - // FieldPrefix::Optional - // } - _ => FieldPrefix::Empty, - }; - let name = pairs.next().unwrap().as_str().to_string(); - - let field_type = self.parse_field_type( - pairs.next().unwrap().into_inner().next().unwrap(), - Some(&self.source), - )?; - - let defaults = self.parse_default_value(&mut pairs, &field_type); - - Ok(Field { - prefix, - defaults, - name, - field_type, - loc: pair.loc(), - }) - } - - fn parse_edge_def( - &self, - pair: Pair, - filepath: String, - ) -> Result { - let mut pairs = pair.clone().into_inner(); - let name = pairs.next().unwrap().as_str().to_string(); - let body = pairs.next().unwrap(); - let mut body_pairs = body.into_inner(); - - let from = { - let pair = body_pairs.next().unwrap(); - (pair.loc(), pair.as_str().to_string()) - }; - let to = { - let pair = body_pairs.next().unwrap(); - (pair.loc(), pair.as_str().to_string()) - }; - let properties = match body_pairs.next() { - Some(pair) => Some(self.parse_properties(pair)?), - None => None, - }; - - Ok(EdgeSchema { - name: (pair.loc(), name), - from, - to, - properties, - loc: pair.loc_with_filepath(filepath), - }) - } - fn parse_properties(&self, pair: Pair) -> Result, ParserError> { - pair.into_inner() - .find(|p| p.as_rule() == Rule::field_defs) - .map_or(Ok(Vec::new()), |field_defs| { - field_defs - .into_inner() - .map(|p| self.parse_field_def(p)) - .collect::, _>>() - }) - } - - fn parse_query_def(&self, pair: Pair, filepath: String) -> Result { - let original_query = pair.clone().as_str().to_string(); - let mut pairs = pair.clone().into_inner(); - let built_in_macro = match pairs.peek() { - Some(pair) if pair.as_rule() == Rule::built_in_macro => { - let built_in_macro = match pair.into_inner().next() { - Some(pair) => match pair.as_rule() { - Rule::mcp_macro => Some(BuiltInMacro::MCP), - Rule::model_macro => Some(BuiltInMacro::Model( - pair.into_inner().next().unwrap().as_str().to_string(), - )), - _ => None, - }, - _ => None, - }; - pairs.next(); - built_in_macro - } - _ => None, - }; - let name = pairs.next().unwrap().as_str().to_string(); - let parameters = self.parse_parameters(pairs.next().unwrap())?; - let body = pairs.next().unwrap(); - let statements = self.parse_query_body(body)?; - let return_values = self.parse_return_statement(pairs.next().unwrap())?; - - Ok(Query { - built_in_macro, - name, - parameters, - statements, - return_values, - original_query, - loc: pair.loc_with_filepath(filepath), - }) - } - - fn parse_parameters(&self, pair: Pair) -> Result, ParserError> { - let mut seen = HashSet::new(); - pair.clone() - .into_inner() - .map(|p: Pair<'_, Rule>| -> Result { - let mut inner = p.into_inner(); - let name = { - let pair = inner.next().unwrap(); - (pair.loc(), pair.as_str().to_string()) - }; - - // gets optional param - let is_optional = inner - .peek() - .is_some_and(|p| p.as_rule() == Rule::optional_param); - if is_optional { - inner.next(); - } - - // gets param type - let param_type_pair = inner - .clone() - .next() - .unwrap() - .clone() - .into_inner() - .next() - .unwrap(); - let param_type_location = param_type_pair.loc(); - let param_type = self.parse_field_type( - // unwraps the param type to get the rule (array, object, named_type, etc) - param_type_pair, - Some(&self.source), - )?; - - if seen.insert(name.1.clone()) { - Ok(Parameter { - name, - param_type: (param_type_location, param_type), - is_optional, - loc: pair.loc(), - }) - } else { - Err(ParserError::from(format!( - r#"Duplicate parameter name: {} - Please use unique parameter names. - - Error happened at line {} column {} here: {} - "#, - name.1, - pair.line_col().0, - pair.line_col().1, - pair.as_str(), - ))) - } - }) - .collect::, _>>() - } - - fn parse_query_body(&self, pair: Pair) -> Result, ParserError> { - pair.into_inner() - .map(|p| match p.as_rule() { - Rule::get_stmt => Ok(Statement { - loc: p.loc(), - statement: StatementType::Assignment(self.parse_get_statement(p)?), - }), - Rule::creation_stmt => Ok(Statement { - loc: p.loc(), - statement: StatementType::Expression(self.parse_expression(p)?), - }), - - Rule::drop => { - let inner = p.into_inner().next().unwrap(); - Ok(Statement { - loc: inner.loc(), - statement: StatementType::Drop(self.parse_expression(inner)?), - }) - } - - Rule::for_loop => Ok(Statement { - loc: p.loc(), - statement: StatementType::ForLoop(self.parse_for_loop(p)?), - }), - _ => Err(ParserError::from(format!( - "Unexpected statement type in query body: {:?}", - p.as_rule() - ))), - }) - .collect() - } - - fn parse_bm25_search(&self, pair: Pair) -> Result { - let mut pairs = pair.clone().into_inner(); - let vector_type = pairs.next().unwrap().as_str().to_string(); - let query = match pairs.next() { - Some(pair) => match pair.as_rule() { - Rule::identifier => ValueType::Identifier { - value: pair.as_str().to_string(), - loc: pair.loc(), - }, - Rule::string_literal => ValueType::Literal { - value: Value::String(pair.as_str().to_string()), - loc: pair.loc(), - }, - _ => { - return Err(ParserError::from(format!( - "Unexpected rule in BM25Search: {:?}", - pair.as_rule() - ))); - } - }, - None => { - return Err(ParserError::from(format!( - "Unexpected rule in BM25Search: {:?}", - pair.as_rule() - ))); - } - }; - let k = Some(match pairs.next() { - Some(pair) => match pair.as_rule() { - Rule::identifier => { - EvaluatesToNumber { - loc: pair.loc(), - value: EvaluatesToNumberType::Identifier(pair.as_str().to_string()), - } - } - Rule::integer => { - EvaluatesToNumber { - loc: pair.loc(), - value: EvaluatesToNumberType::I32( - pair.as_str() - .to_string() - .parse::() - .map_err(|_| ParserError::from("Invalid integer value"))?, - ), - } - } - _ => { - return Err(ParserError::from(format!( - "Unexpected rule in BM25Search: {:?}", - pair.as_rule() - ))); - } - } - None => { - return Err(ParserError::from(format!( - "Unexpected rule in BM25Search: {:?}", - pair.as_rule() - ))); - } - }); - - - Ok(BM25Search { - loc: pair.loc(), - type_arg: Some(vector_type), - data: Some(query), - k, - }) - } - - fn parse_for_loop(&self, pair: Pair) -> Result { - let mut pairs = pair.clone().into_inner(); - // parse the arguments - let argument = pairs.next().unwrap().clone().into_inner().next().unwrap(); - let argument_loc = argument.loc(); - let variable = match argument.as_rule() { - Rule::object_destructuring => { - let fields = argument - .into_inner() - .map(|p| (p.loc(), p.as_str().to_string())) - .collect(); - ForLoopVars::ObjectDestructuring { - fields, - loc: argument_loc, - } - } - Rule::object_access => { - let mut inner = argument.clone().into_inner(); - let object_name = inner.next().unwrap().as_str().to_string(); - let field_name = inner.next().unwrap().as_str().to_string(); - ForLoopVars::ObjectAccess { - name: object_name, - field: field_name, - loc: argument_loc, - } - } - Rule::identifier => ForLoopVars::Identifier { - name: argument.as_str().to_string(), - loc: argument_loc, - }, - _ => { - return Err(ParserError::from(format!( - "Unexpected rule in ForLoop: {:?}", - argument.as_rule() - ))); - } - }; - - // parse the in - let in_ = pairs.next().unwrap().clone(); - let in_variable = match in_.as_rule() { - Rule::identifier => (in_.loc(), in_.as_str().to_string()), - _ => { - return Err(ParserError::from(format!( - "Unexpected rule in ForLoop: {:?}", - in_.as_rule() - ))); - } - }; - // parse the body - let statements = self.parse_query_body(pairs.next().unwrap())?; - - Ok(ForLoop { - variable, - in_variable, - statements, - loc: pair.loc(), - }) - } - - fn parse_batch_add_vector(&self, pair: Pair) -> Result { - let mut vector_type = None; - let mut vec_identifier = None; - let mut fields = None; - - for p in pair.clone().into_inner() { - match p.as_rule() { - Rule::identifier_upper => { - vector_type = Some(p.as_str().to_string()); - } - Rule::identifier => { - vec_identifier = Some(p.as_str().to_string()); - } - Rule::create_field => { - fields = Some(self.parse_property_assignments(p)?); - } - _ => { - return Err(ParserError::from(format!( - "Unexpected rule in AddV: {:?} => {:?}", - p.as_rule(), - p, - ))); - } - } - } - - Ok(BatchAddVector { - vector_type, - vec_identifier, - fields, - loc: pair.loc(), - }) - } - - fn parse_add_vector(&self, pair: Pair) -> Result { - let mut vector_type = None; - let mut data = None; - let mut fields = None; - - for p in pair.clone().into_inner() { - match p.as_rule() { - Rule::identifier_upper => { - vector_type = Some(p.as_str().to_string()); - } - Rule::vector_data => match p.clone().into_inner().next() { - Some(vector_data) => match vector_data.as_rule() { - Rule::identifier => { - data = Some(VectorData::Identifier(p.as_str().to_string())); - } - Rule::vec_literal => { - data = Some(VectorData::Vector(self.parse_vec_literal(p)?)); - } - Rule::embed_method => { - data = Some(VectorData::Embed(Embed { - loc: vector_data.loc(), - value: match vector_data.clone().into_inner().next() { - Some(inner) => match inner.as_rule() { - Rule::identifier => EvaluatesToString::Identifier( - inner.as_str().to_string(), - ), - Rule::string_literal => EvaluatesToString::StringLiteral( - inner.as_str().to_string(), - ), - _ => { - return Err(ParserError::from(format!( - "Unexpected rule in AddV: {:?} => {:?}", - inner.as_rule(), - inner, - ))); - } - }, - None => { - return Err(ParserError::from(format!( - "Unexpected rule in AddV: {:?} => {:?}", - p.as_rule(), - p, - ))); - } - }, - })); - } - _ => { - return Err(ParserError::from(format!( - "Unexpected rule in AddV: {:?} => {:?}", - vector_data.as_rule(), - vector_data, - ))); - } - }, - None => { - return Err(ParserError::from(format!( - "Unexpected rule in AddV: {:?} => {:?}", - p.as_rule(), - p, - ))); - } - }, - Rule::create_field => { - fields = Some(self.parse_property_assignments(p)?); - } - _ => { - return Err(ParserError::from(format!( - "Unexpected rule in AddV: {:?} => {:?}", - p.as_rule(), - p, - ))); - } - } - } - - Ok(AddVector { - vector_type, - data, - fields, - loc: pair.loc(), - }) - } - - fn parse_search_vector(&self, pair: Pair) -> Result { - let mut vector_type = None; - let mut data = None; - let mut k: Option = None; - let mut pre_filter = None; - for p in pair.clone().into_inner() { - match p.as_rule() { - Rule::identifier_upper => { - vector_type = Some(p.as_str().to_string()); - } - Rule::vector_data => match p.clone().into_inner().next() { - Some(vector_data) => match vector_data.as_rule() { - Rule::identifier => { - data = Some(VectorData::Identifier(p.as_str().to_string())); - } - Rule::vec_literal => { - data = Some(VectorData::Vector(self.parse_vec_literal(p)?)); - } - Rule::embed_method => { - data = Some(VectorData::Embed(Embed { - loc: vector_data.loc(), - value: match vector_data.clone().into_inner().next() { - Some(inner) => match inner.as_rule() { - Rule::identifier => EvaluatesToString::Identifier( - inner.as_str().to_string(), - ), - Rule::string_literal => EvaluatesToString::StringLiteral( - inner.as_str().to_string(), - ), - _ => { - return Err(ParserError::from(format!( - "Unexpected rule in SearchV: {:?} => {:?}", - inner.as_rule(), - inner, - ))); - } - }, - None => { - return Err(ParserError::from(format!( - "Unexpected rule in SearchV: {:?} => {:?}", - p.as_rule(), - p, - ))); - } - }, - })); - } - _ => { - return Err(ParserError::from(format!( - "Unexpected rule in SearchV: {:?} => {:?}", - vector_data.as_rule(), - vector_data, - ))); - } - }, - None => { - return Err(ParserError::from(format!( - "Unexpected rule in SearchV: {:?} => {:?}", - p.as_rule(), - p, - ))); - } - }, - Rule::integer => { - k = Some(EvaluatesToNumber { - loc: p.loc(), - value: EvaluatesToNumberType::I32( - p.as_str() - .to_string() - .parse::() - .map_err(|_| ParserError::from("Invalid integer value"))?, - ), - }); - } - Rule::identifier => { - k = Some(EvaluatesToNumber { - loc: p.loc(), - value: EvaluatesToNumberType::Identifier(p.as_str().to_string()), - }); - } - Rule::pre_filter => { - pre_filter = Some(Box::new(self.parse_expression(p)?)); - } - _ => { - return Err(ParserError::from(format!( - "Unexpected rule in SearchV: {:?} => {:?}", - p.as_rule(), - p, - ))); - } - } - } - - Ok(SearchVector { - loc: pair.loc(), - vector_type, - data, - k, - pre_filter, - }) - } - - fn parse_vec_literal(&self, pair: Pair) -> Result, ParserError> { - let pairs = pair.into_inner(); - let mut vec = Vec::new(); - for p in pairs { - vec.push( - p.as_str() - .parse::() - .map_err(|_| ParserError::from("Invalid float value"))?, - ); - } - Ok(vec) - } - - fn parse_add_node(&self, pair: Pair) -> Result { - let mut node_type = None; - let mut fields = None; - - for p in pair.clone().into_inner() { - match p.as_rule() { - Rule::identifier_upper => { - node_type = Some(p.as_str().to_string()); - } - Rule::create_field => { - fields = Some(self.parse_property_assignments(p)?); - } - _ => { - return Err(ParserError::from(format!( - "Unexpected rule in AddV: {:?} => {:?}", - p.as_rule(), - p, - ))); - } - } - } - - Ok(AddNode { - node_type, - fields, - loc: pair.loc(), - }) - } - - fn parse_property_assignments( - &self, - pair: Pair, - ) -> Result, ParserError> { - pair.into_inner() - .map(|p| { - let mut pairs = p.into_inner(); - let prop_key = pairs - .next() - .ok_or_else(|| ParserError::from("Missing property key"))? - .as_str() - .to_string(); - - let prop_val = match pairs.next() { - Some(p) => { - let value_pair = p - .into_inner() - .next() - .ok_or_else(|| ParserError::from("Empty property value"))?; - - match value_pair.as_rule() { - Rule::string_literal => Ok(ValueType::new( - Value::from(value_pair.as_str().to_string()), - value_pair.loc(), - )), - Rule::integer => value_pair - .as_str() - .parse() - .map(|i| ValueType::new(Value::I32(i), value_pair.loc())) - .map_err(|_| ParserError::from("Invalid integer value")), - Rule::float => value_pair - .as_str() - .parse() - .map(|f| ValueType::new(Value::F64(f), value_pair.loc())) - .map_err(|_| ParserError::from("Invalid float value")), - Rule::boolean => Ok(ValueType::new( - Value::Boolean(value_pair.as_str() == "true"), - value_pair.loc(), - )), - Rule::identifier => Ok(ValueType::Identifier { - value: value_pair.as_str().to_string(), - loc: value_pair.loc(), - }), - _ => Err(ParserError::from("Invalid property value type")), - }? - } - None => ValueType::new(Value::Empty, Loc::empty()), - }; - - Ok((prop_key, prop_val)) - }) - .collect() - } - - fn parse_add_edge( - &self, - pair: Pair, - from_identifier: bool, - ) -> Result { - let mut edge_type = None; - let mut fields = None; - let mut connection = None; - - for p in pair.clone().into_inner() { - match p.as_rule() { - Rule::identifier_upper => { - edge_type = Some(p.as_str().to_string()); - } - Rule::create_field => { - fields = Some(self.parse_property_assignments(p)?); - } - Rule::to_from => { - connection = Some(self.parse_to_from(p)?); - } - _ => { - return Err(ParserError::from(format!( - "Unexpected rule in AddE: {:?}", - p.as_rule() - ))); - } - } - } - if edge_type.is_none() { - return Err(ParserError::from("Missing edge type")); - } - if connection.is_none() { - return Err(ParserError::from("Missing edge connection")); - } - Ok(AddEdge { - edge_type, - fields, - connection: connection.ok_or_else(|| ParserError::from("Missing edge connection"))?, - from_identifier, - loc: pair.loc(), - }) - } - - fn parse_id_args(&self, pair: Pair) -> Result, ParserError> { - let p = pair - .into_inner() - .next() - .ok_or_else(|| ParserError::from("Missing ID"))?; - match p.as_rule() { - Rule::identifier => Ok(Some(IdType::Identifier { - value: p.as_str().to_string(), - loc: p.loc(), - })), - Rule::string_literal | Rule::inner_string => Ok(Some(IdType::Literal { - value: p.as_str().to_string(), - loc: p.loc(), - })), - _ => Err(ParserError::from(format!( - "Unexpected rule in parse_id_args: {:?}", - p.as_rule() - ))), - } - } - - fn parse_to_from(&self, pair: Pair) -> Result { - let pairs = pair.clone().into_inner(); - let mut from_id = None; - let mut to_id = None; - // println!("pairs: {:?}", pairs); - for p in pairs { - match p.as_rule() { - Rule::from => { - from_id = self.parse_id_args(p.into_inner().next().unwrap())?; - } - Rule::to => { - to_id = self.parse_id_args(p.into_inner().next().unwrap())?; - } - _ => unreachable!(), - } - } - Ok(EdgeConnection { - from_id, - to_id, - loc: pair.loc(), - }) - } - - fn parse_get_statement(&self, pair: Pair) -> Result { - let mut pairs = pair.clone().into_inner(); - let variable = pairs.next().unwrap().as_str().to_string(); - let value = self.parse_expression(pairs.next().unwrap())?; - - Ok(Assignment { - variable, - value, - loc: pair.loc(), - }) - } - - fn parse_return_statement(&self, pair: Pair) -> Result, ParserError> { - // println!("pair: {:?}", pair.clone().into_inner()); - let inner = pair.into_inner(); - let mut return_types = Vec::new(); - for pair in inner { - match pair.as_rule() { - Rule::array_creation => { - return_types.push(ReturnType::Array(self.parse_array_creation(pair)?)); - } - Rule::object_creation => { - return_types.push(ReturnType::Object(self.parse_object_creation(pair)?)); - } - Rule::evaluates_to_anything => { - return_types.push(ReturnType::Expression(self.parse_expression(pair)?)); - } - _ => { - return Err(ParserError::from(format!( - "Unexpected rule in return statement: {:?}", - pair.as_rule() - ))); - } - } - } - Ok(return_types) - } - - fn parse_array_creation(&self, pair: Pair) -> Result, ParserError> { - let pairs = pair.into_inner(); - let mut objects = Vec::new(); - for p in pairs { - match p.as_rule() { - Rule::identifier => { - objects.push(ReturnType::Expression(Expression { - loc: p.loc(), - expr: ExpressionType::Identifier(p.as_str().to_string()), - })); - } - _ => { - objects.push(ReturnType::Object(self.parse_object_creation(p)?)); - } - } - } - Ok(objects) - } - - fn parse_object_creation( - &self, - pair: Pair, - ) -> Result, ParserError> { - pair.into_inner() - .map(|p| { - let mut object_inner = p.into_inner(); - let key = object_inner - .next() - .ok_or_else(|| ParserError::from("Missing object inner"))?; - let value = object_inner - .next() - .ok_or_else(|| ParserError::from("Missing object inner"))?; - let value = self.parse_object_inner(value)?; - Ok((key.as_str().to_string(), value)) - }) - .collect::, _>>() - } - - fn parse_object_inner(&self, object_field: Pair) -> Result { - let object_field_inner = object_field - .into_inner() - .next() - .ok_or_else(|| ParserError::from("Missing object inner"))?; - - match object_field_inner.as_rule() { - Rule::evaluates_to_anything => Ok(ReturnType::Expression( - self.parse_expression(object_field_inner)?, - )), - Rule::object_creation => Ok(ReturnType::Object( - self.parse_object_creation(object_field_inner)?, - )), - Rule::array_creation => Ok(ReturnType::Array( - self.parse_array_creation(object_field_inner)?, - )), - _ => Err(ParserError::from(format!( - "Unexpected rule in parse_object_inner: {:?}", - object_field_inner.as_rule() - ))), - } - } - - fn parse_expression_vec(&self, pairs: Pairs) -> Result, ParserError> { - let mut expressions = Vec::new(); - for p in pairs { - match p.as_rule() { - Rule::anonymous_traversal => { - expressions.push(Expression { - loc: p.loc(), - expr: ExpressionType::Traversal(Box::new(self.parse_anon_traversal(p)?)), - }); - } - Rule::traversal => { - expressions.push(Expression { - loc: p.loc(), - expr: ExpressionType::Traversal(Box::new(self.parse_traversal(p)?)), - }); - } - Rule::id_traversal => { - expressions.push(Expression { - loc: p.loc(), - expr: ExpressionType::Traversal(Box::new(self.parse_traversal(p)?)), - }); - } - Rule::evaluates_to_bool => { - expressions.push(self.parse_boolean_expression(p)?); - } - _ => unreachable!(), - } - } - Ok(expressions) - } - - fn parse_boolean_expression(&self, pair: Pair) -> Result { - let expression = pair.into_inner().next().unwrap(); - match expression.as_rule() { - Rule::and => { - let loc: Loc = expression.loc(); - let mut inner = expression.into_inner(); - let negated = match inner.peek() { - Some(p) => p.as_rule() == Rule::negate, - None => false, - }; - if negated { - inner.next(); - } - let exprs = self.parse_expression_vec(inner)?; - Ok(Expression { - loc: loc.clone(), - expr: match negated { - true => ExpressionType::Not(Box::new(Expression { - loc, - expr: ExpressionType::And(exprs), - })), - false => ExpressionType::And(exprs), - }, - }) - } - Rule::or => { - let loc: Loc = expression.loc(); - let mut inner = expression.into_inner(); - let negated = match inner.peek() { - Some(p) => p.as_rule() == Rule::negate, - None => false, - }; - if negated { - inner.next(); - } - let exprs = self.parse_expression_vec(inner)?; - Ok(Expression { - loc: loc.clone(), - expr: match negated { - true => ExpressionType::Not(Box::new(Expression { - loc, - expr: ExpressionType::Or(exprs), - })), - false => ExpressionType::Or(exprs), - }, - }) - } - Rule::boolean => Ok(Expression { - loc: expression.loc(), - expr: ExpressionType::BooleanLiteral(expression.as_str() == "true"), - }), - Rule::exists => { - let loc = expression.loc(); - let mut inner = expression.into_inner(); - let negated = match inner.peek() { - Some(p) => p.as_rule() == Rule::negate, - None => false, - }; - if negated { - inner.next(); - } - let traversal = inner - .next() - .ok_or_else(|| ParserError::from("Missing traversal"))?; - let expr = ExpressionType::Exists(ExistsExpression { - loc: loc.clone(), - expr: Box::new(Expression { - loc: loc.clone(), - expr: ExpressionType::Traversal(Box::new( - self.parse_anon_traversal(traversal)?, - )), - }), - }); - Ok(Expression { - loc: loc.clone(), - expr: match negated { - true => ExpressionType::Not(Box::new(Expression { - loc: loc.clone(), - expr, - })), - false => expr, - }, - }) - } - - _ => unreachable!(), - } - } - - fn parse_expression(&self, p: Pair) -> Result { - let pair = p - .into_inner() - .next() - .ok_or_else(|| ParserError::from("Empty expression"))?; - - match pair.as_rule() { - Rule::traversal => Ok(Expression { - loc: pair.loc(), - expr: ExpressionType::Traversal(Box::new(self.parse_traversal(pair)?)), - }), - Rule::id_traversal => Ok(Expression { - loc: pair.loc(), - expr: ExpressionType::Traversal(Box::new(self.parse_traversal(pair)?)), - }), - Rule::anonymous_traversal => Ok(Expression { - loc: pair.loc(), - expr: ExpressionType::Traversal(Box::new(self.parse_anon_traversal(pair)?)), - }), - Rule::identifier => Ok(Expression { - loc: pair.loc(), - expr: ExpressionType::Identifier(pair.as_str().to_string()), - }), - Rule::string_literal => Ok(Expression { - loc: pair.loc(), - expr: ExpressionType::StringLiteral(self.parse_string_literal(pair)?), - }), - Rule::exists => { - let loc = pair.loc(); - let mut inner = pair.into_inner(); - let negated = match inner.peek() { - Some(p) => p.as_rule() == Rule::negate, - None => false, - }; - if negated { - inner.next(); - } - let traversal = inner - .next() - .ok_or_else(|| ParserError::from("Missing traversal"))?; - let expr = ExpressionType::Exists(ExistsExpression { - loc: loc.clone(), - expr: Box::new(Expression { - loc: loc.clone(), - expr: ExpressionType::Traversal(Box::new(match traversal.as_rule() { - Rule::anonymous_traversal => self.parse_anon_traversal(traversal)?, - Rule::id_traversal => self.parse_traversal(traversal)?, - Rule::traversal => self.parse_traversal(traversal)?, - _ => unreachable!(), - })), - }), - }); - Ok(Expression { - loc: loc.clone(), - expr: match negated { - true => ExpressionType::Not(Box::new(Expression { - loc: loc.clone(), - expr, - })), - false => expr, - }, - }) - } - Rule::integer => pair - .as_str() - .parse() - .map(|i| Expression { - loc: pair.loc(), - expr: ExpressionType::IntegerLiteral(i), - }) - .map_err(|_| ParserError::from("Invalid integer literal")), - Rule::float => pair - .as_str() - .parse() - .map(|f| Expression { - loc: pair.loc(), - expr: ExpressionType::FloatLiteral(f), - }) - .map_err(|_| ParserError::from("Invalid float literal")), - Rule::boolean => Ok(Expression { - loc: pair.loc(), - expr: ExpressionType::BooleanLiteral(pair.as_str() == "true"), - }), - Rule::array_literal => Ok(Expression { - loc: pair.loc(), - expr: ExpressionType::ArrayLiteral(self.parse_array_literal(pair)?), - }), - Rule::evaluates_to_bool => Ok(self.parse_boolean_expression(pair)?), - Rule::AddN => Ok(Expression { - loc: pair.loc(), - expr: ExpressionType::AddNode(self.parse_add_node(pair)?), - }), - Rule::AddV => Ok(Expression { - loc: pair.loc(), - expr: ExpressionType::AddVector(self.parse_add_vector(pair)?), - }), - Rule::BatchAddV => Ok(Expression { - loc: pair.loc(), - expr: ExpressionType::BatchAddVector(self.parse_batch_add_vector(pair)?), - }), - Rule::AddE => Ok(Expression { - loc: pair.loc(), - expr: ExpressionType::AddEdge(self.parse_add_edge(pair, false)?), - }), - Rule::search_vector => Ok(Expression { - loc: pair.loc(), - expr: ExpressionType::SearchVector(self.parse_search_vector(pair)?), - }), - Rule::none => Ok(Expression { - loc: pair.loc(), - expr: ExpressionType::Empty, - }), - Rule::bm25_search => Ok(Expression { - loc: pair.loc(), - expr: ExpressionType::BM25Search(self.parse_bm25_search(pair)?), - }), - _ => Err(ParserError::from(format!( - "Unexpected expression type: {:?}", - pair.as_rule() - ))), - } - } - - fn parse_array_literal(&self, pair: Pair) -> Result, ParserError> { - println!("pair: {pair:?}"); - pair.into_inner() - .map(|p| self.parse_expression(p)) - .collect() - } - - fn parse_string_literal(&self, pair: Pair) -> Result { - let inner = pair - .into_inner() - .next() - .ok_or_else(|| ParserError::from("Empty string literal"))?; - - let mut literal = inner.as_str().to_string(); - literal.retain(|c| c != '"'); - Ok(literal) - } - - fn parse_traversal(&self, pair: Pair) -> Result { - let mut pairs = pair.clone().into_inner(); - let start = self.parse_start_node(pairs.next().unwrap())?; - let steps = pairs - .map(|p| self.parse_step(p)) - .collect::, _>>()?; - - Ok(Traversal { - start, - steps, - loc: pair.loc(), - }) - } - - fn parse_anon_traversal(&self, pair: Pair) -> Result { - let pairs = pair.clone().into_inner(); - let start = StartNode::Anonymous; - let steps = pairs - .map(|p| self.parse_step(p)) - .collect::, _>>()?; - - Ok(Traversal { - start, - steps, - loc: pair.loc(), - }) - } - - fn parse_start_node(&self, pair: Pair) -> Result { - match pair.as_rule() { - Rule::start_node => { - let pairs = pair.into_inner(); - let mut node_type = String::new(); - let mut ids = None; - for p in pairs { - match p.as_rule() { - Rule::type_args => { - node_type = p.into_inner().next().unwrap().as_str().to_string(); - // WATCH - } - Rule::id_args => { - ids = Some( - p.into_inner() - .map(|id| { - let id = id.into_inner().next().unwrap(); - match id.as_rule() { - Rule::identifier => IdType::Identifier { - value: id.as_str().to_string(), - loc: id.loc(), - }, - Rule::string_literal => IdType::Literal { - value: id.as_str().to_string(), - loc: id.loc(), - }, - _ => { - panic!("Should be identifier or string literal") - } - } - }) - .collect::>(), - ); - } - Rule::by_index => { - ids = Some({ - let mut pairs: Pairs<'_, Rule> = p.clone().into_inner(); - let index = match pairs.next().unwrap().clone().into_inner().next() - { - Some(id) => match id.as_rule() { - Rule::identifier => IdType::Identifier { - value: id.as_str().to_string(), - loc: id.loc(), - }, - Rule::string_literal => IdType::Literal { - value: id.as_str().to_string(), - loc: id.loc(), - }, - other => { - panic!( - "Should be identifier or string literal: {other:?}" - ) - } - }, - None => return Err(ParserError::from("Missing index")), - }; - let value = match pairs.next().unwrap().into_inner().next() { - Some(val) => match val.as_rule() { - Rule::identifier => ValueType::Identifier { - value: val.as_str().to_string(), - loc: val.loc(), - }, - Rule::string_literal => ValueType::Literal { - value: Value::from(val.as_str()), - loc: val.loc(), - }, - Rule::integer => ValueType::Literal { - value: Value::from( - val.as_str().parse::().unwrap(), - ), - loc: val.loc(), - }, - Rule::float => ValueType::Literal { - value: Value::from( - val.as_str().parse::().unwrap(), - ), - loc: val.loc(), - }, - Rule::boolean => ValueType::Literal { - value: Value::from( - val.as_str().parse::().unwrap(), - ), - loc: val.loc(), - }, - _ => { - panic!("Should be identifier or string literal") - } - }, - _ => unreachable!(), - }; - vec![IdType::ByIndex { - index: Box::new(index), - value: Box::new(value), - loc: p.loc(), - }] - }) - } - _ => unreachable!(), - } - } - Ok(StartNode::Node { node_type, ids }) - } - Rule::start_edge => { - let pairs = pair.into_inner(); - let mut edge_type = String::new(); - let mut ids = None; - for p in pairs { - match p.as_rule() { - Rule::type_args => { - edge_type = p.into_inner().next().unwrap().as_str().to_string(); - } - Rule::id_args => { - ids = Some( - p.into_inner() - .map(|id| { - let id = id.into_inner().next().unwrap(); - match id.as_rule() { - Rule::identifier => IdType::Identifier { - value: id.as_str().to_string(), - loc: id.loc(), - }, - Rule::string_literal => IdType::Literal { - value: id.as_str().to_string(), - loc: id.loc(), - }, - other => { - println!("{other:?}"); - panic!("Should be identifier or string literal") - } - } - }) - .collect::>(), - ); - } - _ => unreachable!(), - } - } - Ok(StartNode::Edge { edge_type, ids }) - } - Rule::identifier => Ok(StartNode::Identifier(pair.as_str().to_string())), - Rule::search_vector => Ok(StartNode::SearchVector(self.parse_search_vector(pair)?)), - _ => Ok(StartNode::Anonymous), - } - } - - fn parse_step(&self, pair: Pair) -> Result { - let inner = pair.clone().into_inner().next().unwrap(); - match inner.as_rule() { - Rule::graph_step => Ok(Step { - loc: inner.loc(), - step: StepType::Node(self.parse_graph_step(inner)), - }), - Rule::object_step => Ok(Step { - loc: inner.loc(), - step: StepType::Object(self.parse_object_step(inner)?), - }), - Rule::closure_step => Ok(Step { - loc: inner.loc(), - step: StepType::Closure(self.parse_closure(inner)?), - }), - Rule::where_step => Ok(Step { - loc: inner.loc(), - step: StepType::Where(Box::new(self.parse_expression(inner)?)), - }), - Rule::range_step => Ok(Step { - loc: inner.loc(), - step: StepType::Range(self.parse_range(pair)?), - }), - - Rule::bool_operations => Ok(Step { - loc: inner.loc(), - step: StepType::BooleanOperation(self.parse_bool_operation(inner)?), - }), - Rule::count => Ok(Step { - loc: inner.loc(), - step: StepType::Count, - }), - Rule::ID => Ok(Step { - loc: inner.loc(), - step: StepType::Object(Object { - fields: vec![FieldAddition { - key: "id".to_string(), - value: FieldValue { - loc: pair.loc(), - value: FieldValueType::Identifier("id".to_string()), - }, - loc: pair.loc(), - }], - should_spread: false, - loc: pair.loc(), - }), - }), - Rule::update => Ok(Step { - loc: inner.loc(), - step: StepType::Update(self.parse_update(inner)?), - }), - Rule::exclude_field => Ok(Step { - loc: inner.loc(), - step: StepType::Exclude(self.parse_exclude(inner)?), - }), - Rule::AddE => Ok(Step { - loc: inner.loc(), - step: StepType::AddEdge(self.parse_add_edge(inner, true)?), - }), - Rule::order_by => Ok(Step { - loc: inner.loc(), - step: StepType::OrderBy(self.parse_order_by(inner)?), - }), - _ => Err(ParserError::from(format!( - "Unexpected step type: {:?}", - inner.as_rule() - ))), - } - } - - fn parse_order_by(&self, pair: Pair) -> Result { - let mut inner = pair.clone().into_inner(); - let order_by_type = match inner.next().unwrap().into_inner().next().unwrap().as_rule() { - Rule::asc => OrderByType::Asc, - Rule::desc => OrderByType::Desc, - _ => unreachable!(), - }; - let expression = self.parse_expression(inner.next().unwrap())?; - Ok(OrderBy { - loc: pair.loc(), - order_by_type, - expression: Box::new(expression), - }) - } - - fn parse_range(&self, pair: Pair) -> Result<(Expression, Expression), ParserError> { - let mut inner = pair.into_inner().next().unwrap().into_inner(); - // println!("inner: {:?}", inner); - let start = self.parse_expression(inner.next().unwrap())?; - let end = self.parse_expression(inner.next().unwrap())?; - - Ok((start, end)) - } - - fn parse_graph_step(&self, pair: Pair) -> GraphStep { - let types = |pair: &Pair| { - pair.clone() - .into_inner() - .next() - .map(|p| p.as_str().to_string()) - .ok_or_else(|| ParserError::from("Expected type".to_string())) - .unwrap() - }; // TODO: change to error - let pair = pair.into_inner().next().unwrap(); // TODO: change to error - match pair.as_rule() { - // s if s.starts_with("OutE") => GraphStep { - // loc: pair.loc(), - // step: GraphStepType::OutE(types), - // }, - // s if s.starts_with("InE") => GraphStep { - // loc: pair.loc(), - // step: GraphStepType::InE(types), - // }, - // s if s.starts_with("FromN") => GraphStep { - // loc: pair.loc(), - // step: GraphStepType::FromN, - // }, - // s if s.starts_with("ToN") => GraphStep { - // loc: pair.loc(), - // step: GraphStepType::ToN, - // }, - // s if s.starts_with("Out") => GraphStep { - // loc: pair.loc(), - // step: GraphStepType::Out(types), - // }, - // s if s.starts_with("In") => GraphStep { - // loc: pair.loc(), - // step: GraphStepType::In(types), - // }, - // _ => { - // println!("rule_str: {:?}", rule_str); - // unreachable!() - // } - Rule::out_e => { - let types = types(&pair); - GraphStep { - loc: pair.loc(), - step: GraphStepType::OutE(types), - } - } - Rule::in_e => { - let types = types(&pair); - GraphStep { - loc: pair.loc(), - step: GraphStepType::InE(types), - } - } - Rule::from_n => GraphStep { - loc: pair.loc(), - step: GraphStepType::FromN, - }, - Rule::to_n => GraphStep { - loc: pair.loc(), - step: GraphStepType::ToN, - }, - Rule::from_v => GraphStep { - loc: pair.loc(), - step: GraphStepType::FromV, - }, - Rule::to_v => GraphStep { - loc: pair.loc(), - step: GraphStepType::ToV, - }, - Rule::out => { - let types = types(&pair); - GraphStep { - loc: pair.loc(), - step: GraphStepType::Out(types), - } - } - Rule::in_nodes => { - let types = types(&pair); - GraphStep { - loc: pair.loc(), - step: GraphStepType::In(types), - } - } - Rule::shortest_path => { - let (type_arg, from, to) = pair.clone().into_inner().fold( - (None, None, None), - |(type_arg, from, to), p| match p.as_rule() { - Rule::type_args => ( - Some(p.into_inner().next().unwrap().as_str().to_string()), - from, - to, - ), - Rule::to_from => match p.into_inner().next() { - Some(p) => match p.as_rule() { - Rule::to => ( - type_arg, - from, - Some(p.into_inner().next().unwrap().as_str().to_string()), - ), - Rule::from => ( - type_arg, - Some(p.into_inner().next().unwrap().as_str().to_string()), - to, - ), - _ => unreachable!(), - }, - None => (type_arg, from, to), - }, - _ => (type_arg, from, to), - }, - ); - - // TODO: add error handling and check about IdType as might not always be data. - // possibly use stack to keep track of variables and use them via precedence and then check on type - // e.g. if valid variable and is param then use data. otherwise use plain identifier - GraphStep { - loc: pair.loc(), - step: GraphStepType::ShortestPath(ShortestPath { - loc: pair.loc(), - from: from.map(|id| IdType::Identifier { - value: id, - loc: pair.loc(), - }), - to: to.map(|id| IdType::Identifier { - value: id, - loc: pair.loc(), - }), - type_arg, - }), - } - } - Rule::search_vector => GraphStep { - loc: pair.loc(), - step: GraphStepType::SearchVector(self.parse_search_vector(pair).unwrap()), - }, - _ => { - unreachable!() - } - } - } - - fn parse_bool_operation(&self, pair: Pair) -> Result { - let inner = pair.clone().into_inner().next().unwrap(); - let expr = match inner.as_rule() { - Rule::GT => BooleanOp { - loc: pair.loc(), - op: BooleanOpType::GreaterThan(Box::new( - self.parse_expression(inner.into_inner().next().unwrap())?, - )), - }, - Rule::GTE => BooleanOp { - loc: pair.loc(), - op: BooleanOpType::GreaterThanOrEqual(Box::new( - self.parse_expression(inner.into_inner().next().unwrap())?, - )), - }, - Rule::LT => BooleanOp { - loc: pair.loc(), - op: BooleanOpType::LessThan(Box::new( - self.parse_expression(inner.into_inner().next().unwrap())?, - )), - }, - Rule::LTE => BooleanOp { - loc: pair.loc(), - op: BooleanOpType::LessThanOrEqual(Box::new( - self.parse_expression(inner.into_inner().next().unwrap())?, - )), - }, - Rule::EQ => BooleanOp { - loc: pair.loc(), - op: BooleanOpType::Equal(Box::new( - self.parse_expression(inner.into_inner().next().unwrap())?, - )), - }, - Rule::NEQ => BooleanOp { - loc: pair.loc(), - op: BooleanOpType::NotEqual(Box::new( - self.parse_expression(inner.into_inner().next().unwrap())?, - )), - }, - Rule::CONTAINS => BooleanOp { - loc: pair.loc(), - op: BooleanOpType::Contains(Box::new( - self.parse_expression(inner.into_inner().next().unwrap())?, - )), - }, - Rule::IS_IN => BooleanOp { - loc: pair.loc(), - op: BooleanOpType::IsIn(Box::new(self.parse_expression(inner)?)), - }, - _ => return Err(ParserError::from("Invalid boolean operation")), - }; - Ok(expr) - } - - fn parse_field_additions(&self, pair: Pair) -> Result, ParserError> { - pair.into_inner() - .map(|p| self.parse_new_field_pair(p)) - .collect() - } - - fn parse_field_value(&self, value_pair: Pair) -> Result { - Ok(match value_pair.as_rule() { - Rule::evaluates_to_anything => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Expression(self.parse_expression(value_pair)?), - }, - Rule::anonymous_traversal => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Traversal(Box::new(self.parse_traversal(value_pair)?)), - }, - Rule::object_step => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Fields(self.parse_field_additions(value_pair)?), - }, - Rule::string_literal => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Literal(Value::String( - self.parse_string_literal(value_pair)?, - )), - }, - Rule::integer => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Literal(Value::I32( - value_pair - .as_str() - .parse() - .map_err(|_| ParserError::from("Invalid integer literal"))?, - )), - }, - Rule::float => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Literal(Value::F64( - value_pair - .as_str() - .parse() - .map_err(|_| ParserError::from("Invalid float literal"))?, - )), - }, - Rule::boolean => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Literal(Value::Boolean(value_pair.as_str() == "true")), - }, - Rule::none => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Empty, - }, - Rule::mapping_field => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Fields(self.parse_field_additions(value_pair)?), - }, - Rule::identifier => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Identifier(value_pair.as_str().to_string()), - }, - _ => { - return Err(ParserError::from(format!( - "Unexpected field pair type: {:?} \n {:?}", - value_pair.as_rule(), - value_pair - ))); - } - }) - } - - fn parse_new_field_pair(&self, pair: Pair) -> Result { - let mut pairs = pair.clone().into_inner(); - let key = pairs.next().unwrap().as_str().to_string(); - let value_pair = pairs.next().unwrap(); - let value = self.parse_field_value(value_pair)?; - - Ok(FieldAddition { - loc: pair.loc(), - key, - value, - }) - } - - fn parse_new_field_value(&self, pair: Pair) -> Result { - let value_pair = pair.into_inner().next().unwrap(); - let value: FieldValue = match value_pair.as_rule() { - Rule::evaluates_to_anything => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Expression(self.parse_expression(value_pair)?), - }, - Rule::anonymous_traversal => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Traversal(Box::new(self.parse_traversal(value_pair)?)), - }, - Rule::object_step => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Fields(self.parse_field_additions(value_pair)?), - }, - Rule::string_literal => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Literal(Value::String( - self.parse_string_literal(value_pair)?, - )), - }, - Rule::integer => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Literal(Value::I32( - value_pair - .as_str() - .parse() - .map_err(|_| ParserError::from("Invalid integer literal"))?, - )), - }, - Rule::float => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Literal(Value::F64( - value_pair - .as_str() - .parse() - .map_err(|_| ParserError::from("Invalid float literal"))?, - )), - }, - Rule::boolean => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Literal(Value::Boolean(value_pair.as_str() == "true")), - }, - Rule::none => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Empty, - }, - Rule::mapping_field => FieldValue { - loc: value_pair.loc(), - value: FieldValueType::Fields(self.parse_field_additions(value_pair)?), - }, - _ => { - return Err(ParserError::from(format!( - "Unexpected field value type: {:?} \n {:?}", - value_pair.as_rule(), - value_pair, - ))); - } - }; - - Ok(value) - } - - fn parse_update(&self, pair: Pair) -> Result { - let fields = self.parse_field_additions(pair.clone())?; - Ok(Update { - fields, - loc: pair.loc(), - }) - } - - fn parse_object_step(&self, pair: Pair) -> Result { - let mut fields = Vec::new(); - let mut should_spread = false; - for p in pair.clone().into_inner() { - if p.as_rule() == Rule::spread_object { - should_spread = true; - continue; - } - let mut pairs = p.clone().into_inner(); - let prop_key = pairs.next().unwrap().as_str().to_string(); - let field_addition = match pairs.next() { - Some(p) => match p.as_rule() { - Rule::evaluates_to_anything => FieldValue { - loc: p.loc(), - value: FieldValueType::Expression(self.parse_expression(p)?), - }, - Rule::anonymous_traversal => FieldValue { - loc: p.loc(), - value: FieldValueType::Traversal(Box::new(self.parse_anon_traversal(p)?)), - }, - Rule::mapping_field => FieldValue { - loc: p.loc(), - value: FieldValueType::Fields(self.parse_field_additions(p)?), - }, - Rule::object_step => FieldValue { - loc: p.clone().loc(), - value: FieldValueType::Fields(self.parse_object_step(p.clone())?.fields), - }, - _ => self.parse_new_field_value(p)?, - }, - None if !prop_key.is_empty() => FieldValue { - loc: p.loc(), - value: FieldValueType::Identifier(prop_key.clone()), - }, - None => FieldValue { - loc: p.loc(), - value: FieldValueType::Empty, - }, - }; - fields.push(FieldAddition { - loc: p.loc(), - key: prop_key, - value: field_addition, - }); - } - Ok(Object { - loc: pair.loc(), - fields, - should_spread, - }) - } - - fn parse_closure(&self, pair: Pair) -> Result { - let mut pairs = pair.clone().into_inner(); - let identifier = pairs.next().unwrap().as_str().to_string(); - let object = self.parse_object_step(pairs.next().unwrap())?; - Ok(Closure { - loc: pair.loc(), - identifier, - object, - }) - } - - fn parse_exclude(&self, pair: Pair) -> Result { - let mut fields = Vec::new(); - for p in pair.clone().into_inner() { - fields.push((p.loc(), p.as_str().to_string())); - } - Ok(Exclude { - loc: pair.loc(), - fields, - }) - } -} - -pub fn write_to_temp_file(content: Vec<&str>) -> Content { - let mut files = Vec::new(); - for c in content { - let mut file = tempfile::NamedTempFile::new().unwrap(); - file.write_all(c.as_bytes()).unwrap(); - let path = file.path().to_string_lossy().into_owned(); - files.push(HxFile { - name: path, - content: c.to_string(), - }); - } - Content { - content: String::new(), - files, - source: Source::default(), - } -} diff --git a/helix-db/src/helixc/parser/location.rs b/helix-db/src/helixc/parser/location.rs index 2be1d768..a6d74264 100644 --- a/helix-db/src/helixc/parser/location.rs +++ b/helix-db/src/helixc/parser/location.rs @@ -1,6 +1,5 @@ -use pest::{iterators::Pair, Position}; - -use super::helix_parser::Rule; +use crate::helixc::parser::Rule; +use pest::{Position, iterators::Pair}; #[derive(Debug, Clone)] pub struct Loc { @@ -44,12 +43,7 @@ impl Loc { } pub fn empty() -> Self { - Self::new( - None, - Span::new(1, 1), - Span::new(1, 1), - "".to_string(), - ) + Self::new(None, Span::new(1, 1), Span::new(1, 1), "".to_string()) } } diff --git a/helix-db/src/helixc/parser/migration_parse_methods.rs b/helix-db/src/helixc/parser/migration_parse_methods.rs new file mode 100644 index 00000000..e69de29b diff --git a/helix-db/src/helixc/parser/mod.rs b/helix-db/src/helixc/parser/mod.rs index 692c1a3c..b660358a 100644 --- a/helix-db/src/helixc/parser/mod.rs +++ b/helix-db/src/helixc/parser/mod.rs @@ -1,5 +1,193 @@ -pub mod helix_parser; +pub mod creation_step_parse_methods; +pub mod expression_parse_methods; +pub mod graph_step_parse_methods; pub mod location; +pub mod object_parse_methods; pub mod parser_methods; +pub mod query_parse_methods; +pub mod return_value_parse_methods; +pub mod schema_parse_methods; +pub mod traversal_parse_methods; +pub mod types; +pub mod utils; +use crate::helixc::parser::types::{Content, HxFile, Schema, Source}; +use location::HasLoc; +use parser_methods::ParserError; +use pest::Parser as PestParser; +use pest_derive::Parser; +use std::{ + collections::{HashMap, HashSet}, + fmt::Debug, + io::Write, +}; +#[derive(Parser)] +#[grammar = "grammar.pest"] +pub struct HelixParser { + pub(super) source: Source, +} + +impl HelixParser { + pub fn parse_source(input: &Content) -> Result { + let mut source = Source { + source: String::new(), + schema: HashMap::new(), + migrations: Vec::new(), + queries: Vec::new(), + }; + + input.files.iter().try_for_each(|file| { + source.source.push_str(&file.content); + source.source.push('\n'); + let pair = match HelixParser::parse(Rule::source, &file.content) { + Ok(mut pairs) => pairs + .next() + .ok_or_else(|| ParserError::from("Empty input"))?, + Err(e) => { + return Err(ParserError::from(e)); + } + }; + let mut parser = HelixParser { + source: Source::default(), + }; + + let pairs = pair.into_inner(); + let mut remaining_queries = HashSet::new(); + let mut remaining_migrations = HashSet::new(); + for pair in pairs { + match pair.as_rule() { + Rule::schema_def => { + let mut schema_pairs = pair.into_inner(); + + let schema_version = match schema_pairs.peek() { + Some(pair) => { + if pair.as_rule() == Rule::schema_version { + schema_pairs + .next() + .unwrap() + .into_inner() + .next() + .unwrap() + .as_str() + .parse::() + .unwrap() + } else { + 1 + } + } + None => 1, + }; + + for pair in schema_pairs { + match pair.as_rule() { + Rule::node_def => { + let node_schema = + parser.parse_node_def(pair.clone(), file.name.clone())?; + parser + .source + .schema + .entry(schema_version) + .and_modify(|schema| { + schema.node_schemas.push(node_schema.clone()) + }) + .or_insert(Schema { + loc: pair.loc(), + version: (pair.loc(), schema_version), + node_schemas: vec![node_schema], + edge_schemas: vec![], + vector_schemas: vec![], + }); + } + Rule::edge_def => { + let edge_schema = + parser.parse_edge_def(pair.clone(), file.name.clone())?; + parser + .source + .schema + .entry(schema_version) + .and_modify(|schema| { + schema.edge_schemas.push(edge_schema.clone()) + }) + .or_insert(Schema { + loc: pair.loc(), + version: (pair.loc(), schema_version), + node_schemas: vec![], + edge_schemas: vec![edge_schema], + vector_schemas: vec![], + }); + } + Rule::vector_def => { + let vector_schema = + parser.parse_vector_def(pair.clone(), file.name.clone())?; + parser + .source + .schema + .entry(schema_version) + .and_modify(|schema| { + schema.vector_schemas.push(vector_schema.clone()) + }) + .or_insert(Schema { + loc: pair.loc(), + version: (pair.loc(), schema_version), + node_schemas: vec![], + edge_schemas: vec![], + vector_schemas: vec![vector_schema], + }); + } + _ => return Err(ParserError::from("Unexpected rule encountered")), + } + } + } + Rule::migration_def => { + remaining_migrations.insert(pair); + } + Rule::query_def => { + // parser.source.queries.push(parser.parse_query_def(pairs.next().unwrap())?), + remaining_queries.insert(pair); + } + Rule::EOI => (), + _ => return Err(ParserError::from("Unexpected rule encountered")), + } + } + + for pair in remaining_migrations { + let migration = parser.parse_migration_def(pair, file.name.clone())?; + parser.source.migrations.push(migration); + } + + for pair in remaining_queries { + parser + .source + .queries + .push(parser.parse_query_def(pair, file.name.clone())?); + } + + // parse all schemas first then parse queries using self + source.schema.extend(parser.source.schema); + source.queries.extend(parser.source.queries); + source.migrations.extend(parser.source.migrations); + Ok(()) + })?; + + Ok(source) + } +} + +pub fn write_to_temp_file(content: Vec<&str>) -> Content { + let mut files = Vec::new(); + for c in content { + let mut file = tempfile::NamedTempFile::new().unwrap(); + file.write_all(c.as_bytes()).unwrap(); + let path = file.path().to_string_lossy().into_owned(); + files.push(HxFile { + name: path, + content: c.to_string(), + }); + } + Content { + content: String::new(), + files, + source: Source::default(), + } +} diff --git a/helix-db/src/helixc/parser/object_parse_methods.rs b/helix-db/src/helixc/parser/object_parse_methods.rs new file mode 100644 index 00000000..af89472e --- /dev/null +++ b/helix-db/src/helixc/parser/object_parse_methods.rs @@ -0,0 +1,223 @@ +use crate::{ + helixc::parser::{ + location::{HasLoc, Loc}, parser_methods::ParserError, types::{FieldAddition, FieldValue, FieldValueType, ValueType}, HelixParser, Rule + }, + protocol::value::Value, +}; +use std::collections::HashMap; + +use pest::iterators::Pair; + +impl HelixParser { + pub(super) fn parse_property_assignments( + &self, + pair: Pair, + ) -> Result, ParserError> { + pair.into_inner() + .map(|p| { + let mut pairs = p.into_inner(); + let prop_key = pairs + .next() + .ok_or_else(|| ParserError::from("Missing property key"))? + .as_str() + .to_string(); + + let prop_val = match pairs.next() { + Some(p) => { + let value_pair = p + .into_inner() + .next() + .ok_or_else(|| ParserError::from("Empty property value"))?; + + match value_pair.as_rule() { + Rule::string_literal => Ok(ValueType::new( + Value::from(value_pair.as_str().to_string()), + value_pair.loc(), + )), + Rule::integer => value_pair + .as_str() + .parse() + .map(|i| ValueType::new(Value::I32(i), value_pair.loc())) + .map_err(|_| ParserError::from("Invalid integer value")), + Rule::float => value_pair + .as_str() + .parse() + .map(|f| ValueType::new(Value::F64(f), value_pair.loc())) + .map_err(|_| ParserError::from("Invalid float value")), + Rule::boolean => Ok(ValueType::new( + Value::Boolean(value_pair.as_str() == "true"), + value_pair.loc(), + )), + Rule::identifier => Ok(ValueType::Identifier { + value: value_pair.as_str().to_string(), + loc: value_pair.loc(), + }), + _ => Err(ParserError::from("Invalid property value type")), + }? + } + None => ValueType::new(Value::Empty, Loc::empty()), + }; + + Ok((prop_key, prop_val)) + }) + .collect() + } + + pub(super) fn parse_object_fields( + &self, + pair: Pair, + ) -> Result, ParserError> { + pair.into_inner() + .map(|p| self.parse_new_field_pair(p)) + .collect() + } + + pub(super) fn parse_field_value( + &self, + value_pair: Pair, + ) -> Result { + Ok(match value_pair.as_rule() { + Rule::evaluates_to_anything => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Expression(self.parse_expression(value_pair)?), + }, + Rule::anonymous_traversal => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Traversal(Box::new(self.parse_traversal(value_pair)?)), + }, + Rule::object_step => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Fields(self.parse_object_fields(value_pair)?), + }, + Rule::string_literal => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Literal(Value::String( + self.parse_string_literal(value_pair)?, + )), + }, + Rule::integer => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Literal(Value::I32( + value_pair + .as_str() + .parse() + .map_err(|_| ParserError::from("Invalid integer literal"))?, + )), + }, + Rule::float => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Literal(Value::F64( + value_pair + .as_str() + .parse() + .map_err(|_| ParserError::from("Invalid float literal"))?, + )), + }, + Rule::boolean => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Literal(Value::Boolean(value_pair.as_str() == "true")), + }, + Rule::none => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Empty, + }, + Rule::mapping_field => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Fields(self.parse_object_fields(value_pair)?), + }, + Rule::identifier => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Identifier(value_pair.as_str().to_string()), + }, + _ => { + return Err(ParserError::from(format!( + "Unexpected field pair type: {:?} \n {:?}", + value_pair.as_rule(), + value_pair + ))); + } + }) + } + + pub(super) fn parse_new_field_pair( + &self, + pair: Pair, + ) -> Result { + let mut pairs = pair.clone().into_inner(); + let key = pairs.next().unwrap().as_str().to_string(); + let value_pair = pairs.next().unwrap(); + let value = self.parse_field_value(value_pair)?; + + Ok(FieldAddition { + loc: pair.loc(), + key, + value, + }) + } + + pub(super) fn parse_new_field_value( + &self, + pair: Pair, + ) -> Result { + let value_pair = pair.into_inner().next().unwrap(); + let value: FieldValue = match value_pair.as_rule() { + Rule::evaluates_to_anything => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Expression(self.parse_expression(value_pair)?), + }, + Rule::anonymous_traversal => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Traversal(Box::new(self.parse_traversal(value_pair)?)), + }, + Rule::object_step => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Fields(self.parse_object_fields(value_pair)?), + }, + Rule::string_literal => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Literal(Value::String( + self.parse_string_literal(value_pair)?, + )), + }, + Rule::integer => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Literal(Value::I32( + value_pair + .as_str() + .parse() + .map_err(|_| ParserError::from("Invalid integer literal"))?, + )), + }, + Rule::float => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Literal(Value::F64( + value_pair + .as_str() + .parse() + .map_err(|_| ParserError::from("Invalid float literal"))?, + )), + }, + Rule::boolean => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Literal(Value::Boolean(value_pair.as_str() == "true")), + }, + Rule::none => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Empty, + }, + Rule::mapping_field => FieldValue { + loc: value_pair.loc(), + value: FieldValueType::Fields(self.parse_object_fields(value_pair)?), + }, + _ => { + return Err(ParserError::from(format!( + "Unexpected field value type: {:?} \n {:?}", + value_pair.as_rule(), + value_pair, + ))); + } + }; + + Ok(value) + } +} diff --git a/helix-db/src/helixc/parser/parser_methods.rs b/helix-db/src/helixc/parser/parser_methods.rs index 8505a228..144ead18 100644 --- a/helix-db/src/helixc/parser/parser_methods.rs +++ b/helix-db/src/helixc/parser/parser_methods.rs @@ -1,4 +1,4 @@ -use super::helix_parser::Rule; +use crate::helixc::parser::Rule; use core::fmt; pub trait Parser { diff --git a/helix-db/src/helixc/parser/query_parse_methods.rs b/helix-db/src/helixc/parser/query_parse_methods.rs new file mode 100644 index 00000000..3c2df550 --- /dev/null +++ b/helix-db/src/helixc/parser/query_parse_methods.rs @@ -0,0 +1,142 @@ +use crate::helixc::parser::{ + HelixParser, Rule, + location::HasLoc, + parser_methods::ParserError, + types::{BuiltInMacro, Parameter, Query, Statement, StatementType}, +}; +use pest::iterators::Pair; +use std::collections::HashSet; + +impl HelixParser { + pub(super) fn parse_query_def( + &self, + pair: Pair, + filepath: String, + ) -> Result { + let original_query = pair.clone().as_str().to_string(); + let mut pairs = pair.clone().into_inner(); + let built_in_macro = match pairs.peek() { + Some(pair) if pair.as_rule() == Rule::built_in_macro => { + let built_in_macro = match pair.into_inner().next() { + Some(pair) => match pair.as_rule() { + Rule::mcp_macro => Some(BuiltInMacro::MCP), + Rule::model_macro => Some(BuiltInMacro::Model( + pair.into_inner().next().unwrap().as_str().to_string(), + )), + _ => None, + }, + _ => None, + }; + pairs.next(); + built_in_macro + } + _ => None, + }; + let name = pairs.next().unwrap().as_str().to_string(); + let parameters = self.parse_parameters(pairs.next().unwrap())?; + let body = pairs.next().unwrap(); + let statements = self.parse_query_body(body)?; + let return_values = self.parse_return_statement(pairs.next().unwrap())?; + + Ok(Query { + built_in_macro, + name, + parameters, + statements, + return_values, + original_query, + loc: pair.loc_with_filepath(filepath), + }) + } + + pub(super) fn parse_parameters(&self, pair: Pair) -> Result, ParserError> { + let mut seen = HashSet::new(); + pair.clone() + .into_inner() + .map(|p: Pair<'_, Rule>| -> Result { + let mut inner = p.into_inner(); + let name = { + let pair = inner.next().unwrap(); + (pair.loc(), pair.as_str().to_string()) + }; + + // gets optional param + let is_optional = inner + .peek() + .is_some_and(|p| p.as_rule() == Rule::optional_param); + if is_optional { + inner.next(); + } + + // gets param type + let param_type_pair = inner + .clone() + .next() + .unwrap() + .clone() + .into_inner() + .next() + .unwrap(); + let param_type_location = param_type_pair.loc(); + let param_type = self.parse_field_type( + // unwraps the param type to get the rule (array, object, named_type, etc) + param_type_pair, + Some(&self.source), + )?; + + if seen.insert(name.1.clone()) { + Ok(Parameter { + name, + param_type: (param_type_location, param_type), + is_optional, + loc: pair.loc(), + }) + } else { + Err(ParserError::from(format!( + r#"Duplicate parameter name: {} + Please use unique parameter names. + + Error happened at line {} column {} here: {} + "#, + name.1, + pair.line_col().0, + pair.line_col().1, + pair.as_str(), + ))) + } + }) + .collect::, _>>() + } + + pub(super) fn parse_query_body(&self, pair: Pair) -> Result, ParserError> { + pair.into_inner() + .map(|p| match p.as_rule() { + Rule::get_stmt => Ok(Statement { + loc: p.loc(), + statement: StatementType::Assignment(self.parse_assignment(p)?), + }), + Rule::creation_stmt => Ok(Statement { + loc: p.loc(), + statement: StatementType::Expression(self.parse_expression(p)?), + }), + + Rule::drop => { + let inner = p.into_inner().next().unwrap(); + Ok(Statement { + loc: inner.loc(), + statement: StatementType::Drop(self.parse_expression(inner)?), + }) + } + + Rule::for_loop => Ok(Statement { + loc: p.loc(), + statement: StatementType::ForLoop(self.parse_for_loop(p)?), + }), + _ => Err(ParserError::from(format!( + "Unexpected statement type in query body: {:?}", + p.as_rule() + ))), + }) + .collect() + } +} diff --git a/helix-db/src/helixc/parser/return_value_parse_methods.rs b/helix-db/src/helixc/parser/return_value_parse_methods.rs new file mode 100644 index 00000000..8a9dcf7f --- /dev/null +++ b/helix-db/src/helixc/parser/return_value_parse_methods.rs @@ -0,0 +1,107 @@ +use std::collections::HashMap; + +use crate::helixc::parser::{ + HelixParser, Rule, + location::HasLoc, + parser_methods::ParserError, + types::{Expression, ExpressionType, ReturnType}, +}; +use pest::iterators::Pair; + +impl HelixParser { + pub(super) fn parse_return_statement( + &self, + pair: Pair, + ) -> Result, ParserError> { + // println!("pair: {:?}", pair.clone().into_inner()); + let inner = pair.into_inner(); + let mut return_types = Vec::new(); + for pair in inner { + match pair.as_rule() { + Rule::array_creation => { + return_types.push(ReturnType::Array(self.parse_array_creation(pair)?)); + } + Rule::object_creation => { + return_types.push(ReturnType::Object(self.parse_object_creation(pair)?)); + } + Rule::evaluates_to_anything => { + return_types.push(ReturnType::Expression(self.parse_expression(pair)?)); + } + _ => { + return Err(ParserError::from(format!( + "Unexpected rule in return statement: {:?}", + pair.as_rule() + ))); + } + } + } + Ok(return_types) + } + + pub(super) fn parse_array_creation( + &self, + pair: Pair, + ) -> Result, ParserError> { + let pairs = pair.into_inner(); + let mut objects = Vec::new(); + for p in pairs { + match p.as_rule() { + Rule::identifier => { + objects.push(ReturnType::Expression(Expression { + loc: p.loc(), + expr: ExpressionType::Identifier(p.as_str().to_string()), + })); + } + _ => { + objects.push(ReturnType::Object(self.parse_object_creation(p)?)); + } + } + } + Ok(objects) + } + + pub(super) fn parse_object_creation( + &self, + pair: Pair, + ) -> Result, ParserError> { + pair.into_inner() + .map(|p| { + let mut object_inner = p.into_inner(); + let key = object_inner + .next() + .ok_or_else(|| ParserError::from("Missing object inner"))?; + let value = object_inner + .next() + .ok_or_else(|| ParserError::from("Missing object inner"))?; + let value = self.parse_object_inner(value)?; + Ok((key.as_str().to_string(), value)) + }) + .collect::, _>>() + } + + pub(super) fn parse_object_inner( + &self, + object_field: Pair, + ) -> Result { + let object_field_inner = object_field + .into_inner() + .next() + .ok_or_else(|| ParserError::from("Missing object inner"))?; + + match object_field_inner.as_rule() { + Rule::evaluates_to_anything => Ok(ReturnType::Expression( + self.parse_expression(object_field_inner)?, + )), + Rule::object_creation => Ok(ReturnType::Object( + self.parse_object_creation(object_field_inner)?, + )), + Rule::array_creation => Ok(ReturnType::Array( + self.parse_array_creation(object_field_inner)?, + )), + _ => Err(ParserError::from(format!( + "Unexpected rule in parse_object_inner: {:?}", + object_field_inner.as_rule() + ))), + } + } +} diff --git a/helix-db/src/helixc/parser/schema_parse_methods.rs b/helix-db/src/helixc/parser/schema_parse_methods.rs new file mode 100644 index 00000000..6fb33a67 --- /dev/null +++ b/helix-db/src/helixc/parser/schema_parse_methods.rs @@ -0,0 +1,481 @@ +use std::collections::HashMap; + +use crate::helixc::parser::{ + HelixParser, Rule, + location::HasLoc, + parser_methods::ParserError, + types::{ + DefaultValue, EdgeSchema, Field, FieldPrefix, FieldType, Migration, MigrationItem, + MigrationItemMapping, MigrationPropertyMapping, NodeSchema, Source, ValueCast, + VectorSchema, + }, +}; +use pest::iterators::{Pair, Pairs}; + +impl HelixParser { + pub(super) fn parse_node_def( + &self, + pair: Pair, + filepath: String, + ) -> Result { + let mut pairs = pair.clone().into_inner(); + let name = pairs.next().unwrap().as_str().to_string(); + let fields = self.parse_node_body(pairs.next().unwrap())?; + Ok(NodeSchema { + name: (pair.loc(), name), + fields, + loc: pair.loc_with_filepath(filepath), + }) + } + + pub(super) fn parse_vector_def( + &self, + pair: Pair, + filepath: String, + ) -> Result { + let mut pairs = pair.clone().into_inner(); + let name = pairs.next().unwrap().as_str().to_string(); + let fields = self.parse_node_body(pairs.next().unwrap())?; + Ok(VectorSchema { + name, + fields, + loc: pair.loc_with_filepath(filepath), + }) + } + + pub(super) fn parse_node_body(&self, pair: Pair) -> Result, ParserError> { + let field_defs = pair + .into_inner() + .find(|p| p.as_rule() == Rule::field_defs) + .expect("Expected field_defs in properties"); + + // Now parse each individual field_def + field_defs + .into_inner() + .map(|p| self.parse_field_def(p)) + .collect::, _>>() + } + + pub(super) fn parse_migration_def( + &self, + pair: Pair, + filepath: String, + ) -> Result { + let mut pairs = pair.clone().into_inner(); + let from_version = pairs.next().unwrap().into_inner().next().unwrap(); + let to_version = pairs.next().unwrap().into_inner().next().unwrap(); + + // migration body -> [migration-item-mapping, migration-item-mapping, ...] + let body = pairs + .next() + .unwrap() + .into_inner() + .map(|p| self.parse_migration_item_mapping(p)) + .collect::, _>>()?; + + Ok(Migration { + from_version: ( + from_version.loc(), + from_version.as_str().parse::().unwrap(), + ), + to_version: ( + to_version.loc(), + to_version.as_str().parse::().unwrap(), + ), + body, + loc: pair.loc_with_filepath(filepath), + }) + } + + pub(super) fn parse_migration_item_mapping( + &self, + pair: Pair, + ) -> Result { + let mut pairs = pair.clone().into_inner(); + let from_item_type = match pairs.next() { + Some(item_def) => match item_def.into_inner().next() { + Some(item_decl) => match item_decl.as_rule() { + Rule::node_decl => ( + item_decl.loc(), + MigrationItem::Node( + item_decl.into_inner().next().unwrap().as_str().to_string(), + ), + ), + Rule::edge_decl => ( + item_decl.loc(), + MigrationItem::Edge( + item_decl.into_inner().next().unwrap().as_str().to_string(), + ), + ), + Rule::vec_decl => ( + item_decl.loc(), + MigrationItem::Vector( + item_decl.into_inner().next().unwrap().as_str().to_string(), + ), + ), + _ => { + return Err(ParserError::from(format!( + "Expected item declaration, got {:?}", + item_decl.as_rule() + ))); + } + }, + None => { + return Err(ParserError::from(format!( + "Expected item declaration, got {:?}", + pair.as_rule() + ))); + } + }, + _ => { + return Err(ParserError::from(format!( + "Expected item declaration, got {:?}", + pair.as_rule() + ))); + } + }; + + let to_item_type = match pairs.next() { + Some(pair) => match pair.as_rule() { + Rule::item_def => match pair.into_inner().next() { + Some(item_decl) => match item_decl.as_rule() { + Rule::node_decl => ( + item_decl.loc(), + MigrationItem::Node( + item_decl.into_inner().next().unwrap().as_str().to_string(), + ), + ), + Rule::edge_decl => ( + item_decl.loc(), + MigrationItem::Edge( + item_decl.into_inner().next().unwrap().as_str().to_string(), + ), + ), + Rule::vec_decl => ( + item_decl.loc(), + MigrationItem::Vector( + item_decl.into_inner().next().unwrap().as_str().to_string(), + ), + ), + _ => { + return Err(ParserError::from(format!( + "Expected item declaration, got {:?}", + item_decl.as_rule() + ))); + } + }, + None => { + return Err(ParserError::from(format!( + "Expected item, got {:?}", + pairs.peek() + ))); + } + }, + Rule::anon_decl => from_item_type.clone(), + _ => { + return Err(ParserError::from(format!( + "Invalid item declaration, got {:?}", + pair.as_rule() + ))); + } + }, + None => { + return Err(ParserError::from(format!( + "Expected item_def, got {:?}", + pairs.peek() + ))); + } + }; + let remappings = match pairs.next() { + Some(p) => match p.as_rule() { + Rule::node_migration => p + .into_inner() + .next() + .unwrap() + .into_inner() + .map(|p| self.parse_field_migration(p)) + .collect::, _>>()?, + Rule::edge_migration => p + .into_inner() + .next() + .unwrap() + .into_inner() + .map(|p| self.parse_field_migration(p)) + .collect::, _>>()?, + _ => { + return Err(ParserError::from( + "Expected node_migration or edge_migration", + )); + } + }, + None => { + return Err(ParserError::from( + "Expected node_migration or edge_migration", + )); + } + }; + // let remappings = Vec::new(); + // for pair in pairs { + // match pair.as_rule() { + // Rule::node_migration => { + // remappings.push(self.parse_field_migration(pair.into_inner().next().unwrap())?); + // } + // Rule::edge_migration => { + // remappings.push(self.parse_field_migration(pair.into_inner().next().unwrap())?); + // } + // } + // } + + Ok(MigrationItemMapping { + from_item: from_item_type, + to_item: to_item_type, + remappings, + loc: pair.loc(), + }) + } + + pub(super) fn parse_default_value( + &self, + pairs: &mut Pairs, + field_type: &FieldType, + ) -> Option { + match pairs.peek() { + Some(pair) => { + if pair.as_rule() == Rule::default { + pairs.next(); + let default_value = match pair.into_inner().next() { + Some(pair) => match pair.as_rule() { + Rule::string_literal => DefaultValue::String(pair.as_str().to_string()), + Rule::float => { + match field_type { + FieldType::F32 => { + DefaultValue::F32(pair.as_str().parse::().unwrap()) + } + FieldType::F64 => { + DefaultValue::F64(pair.as_str().parse::().unwrap()) + } + _ => unreachable!(), // throw error + } + } + Rule::integer => { + match field_type { + FieldType::I8 => { + DefaultValue::I8(pair.as_str().parse::().unwrap()) + } + FieldType::I16 => { + DefaultValue::I16(pair.as_str().parse::().unwrap()) + } + FieldType::I32 => { + DefaultValue::I32(pair.as_str().parse::().unwrap()) + } + FieldType::I64 => { + DefaultValue::I64(pair.as_str().parse::().unwrap()) + } + FieldType::U8 => { + DefaultValue::U8(pair.as_str().parse::().unwrap()) + } + FieldType::U16 => { + DefaultValue::U16(pair.as_str().parse::().unwrap()) + } + FieldType::U32 => { + DefaultValue::U32(pair.as_str().parse::().unwrap()) + } + FieldType::U64 => { + DefaultValue::U64(pair.as_str().parse::().unwrap()) + } + FieldType::U128 => { + DefaultValue::U128(pair.as_str().parse::().unwrap()) + } + _ => unreachable!(), // throw error + } + } + Rule::now => DefaultValue::Now, + Rule::boolean => { + DefaultValue::Boolean(pair.as_str().parse::().unwrap()) + } + _ => unreachable!(), // throw error + }, + None => DefaultValue::Empty, + }; + Some(default_value) + } else { + None + } + } + None => None, + } + } + + pub(super) fn parse_cast(&self, pair: Pair) -> Option { + match pair.as_rule() { + Rule::cast => Some(ValueCast { + loc: pair.loc(), + cast_to: self + .parse_field_type(pair.into_inner().next().unwrap(), None) + .ok()?, + }), + _ => None, + } + } + + pub(super) fn parse_field_migration( + &self, + pair: Pair, + ) -> Result { + let mut pairs = pair.clone().into_inner(); + let property_name = pairs.next().unwrap(); + let property_value = pairs.next().unwrap(); + let cast = if let Some(cast_pair) = pairs.next() { + self.parse_cast(cast_pair) + } else { + None + }; + + Ok(MigrationPropertyMapping { + property_name: (property_name.loc(), property_name.as_str().to_string()), + property_value: self.parse_field_value(property_value)?, + default: None, + cast, + loc: pair.loc(), + }) + } + + pub(super) fn parse_field_type( + &self, + field: Pair, + _schema: Option<&Source>, + ) -> Result { + match field.as_rule() { + Rule::named_type => { + let type_str = field.as_str(); + match type_str { + "String" => Ok(FieldType::String), + "Boolean" => Ok(FieldType::Boolean), + "F32" => Ok(FieldType::F32), + "F64" => Ok(FieldType::F64), + "I8" => Ok(FieldType::I8), + "I16" => Ok(FieldType::I16), + "I32" => Ok(FieldType::I32), + "I64" => Ok(FieldType::I64), + "U8" => Ok(FieldType::U8), + "U16" => Ok(FieldType::U16), + "U32" => Ok(FieldType::U32), + "U64" => Ok(FieldType::U64), + "U128" => Ok(FieldType::U128), + _ => unreachable!(), + } + } + Rule::array => { + Ok(FieldType::Array(Box::new( + self.parse_field_type( + // unwraps the array type because grammar type is + // { array { param_type { array | object | named_type } } } + field + .into_inner() + .next() + .unwrap() + .into_inner() + .next() + .unwrap(), + _schema, + )?, + ))) + } + Rule::object => { + let mut fields = HashMap::new(); + for field in field.into_inner().next().unwrap().into_inner() { + let (field_name, field_type) = { + let mut field_pair = field.clone().into_inner(); + ( + field_pair.next().unwrap().as_str().to_string(), + field_pair.next().unwrap().into_inner().next().unwrap(), + ) + }; + let field_type = self.parse_field_type(field_type, Some(&self.source))?; + fields.insert(field_name, field_type); + } + Ok(FieldType::Object(fields)) + } + Rule::identifier => Ok(FieldType::Identifier(field.as_str().to_string())), + Rule::ID_TYPE => Ok(FieldType::Uuid), + Rule::date_type => Ok(FieldType::Date), + _ => { + unreachable!() + } + } + } + + pub(super) fn parse_field_def(&self, pair: Pair) -> Result { + let mut pairs = pair.clone().into_inner(); + // structure is index? ~ identifier ~ ":" ~ param_type + let prefix: FieldPrefix = match pairs.clone().next().unwrap().as_rule() { + Rule::index => { + pairs.next().unwrap(); + FieldPrefix::Index + } + // Rule::optional => { + // pairs.next().unwrap(); + // FieldPrefix::Optional + // } + _ => FieldPrefix::Empty, + }; + let name = pairs.next().unwrap().as_str().to_string(); + + let field_type = self.parse_field_type( + pairs.next().unwrap().into_inner().next().unwrap(), + Some(&self.source), + )?; + + let defaults = self.parse_default_value(&mut pairs, &field_type); + + Ok(Field { + prefix, + defaults, + name, + field_type, + loc: pair.loc(), + }) + } + + pub(super) fn parse_edge_def( + &self, + pair: Pair, + filepath: String, + ) -> Result { + let mut pairs = pair.clone().into_inner(); + let name = pairs.next().unwrap().as_str().to_string(); + let body = pairs.next().unwrap(); + let mut body_pairs = body.into_inner(); + + let from = { + let pair = body_pairs.next().unwrap(); + (pair.loc(), pair.as_str().to_string()) + }; + let to = { + let pair = body_pairs.next().unwrap(); + (pair.loc(), pair.as_str().to_string()) + }; + let properties = match body_pairs.next() { + Some(pair) => Some(self.parse_properties(pair)?), + None => None, + }; + + Ok(EdgeSchema { + name: (pair.loc(), name), + from, + to, + properties, + loc: pair.loc_with_filepath(filepath), + }) + } + pub(super) fn parse_properties(&self, pair: Pair) -> Result, ParserError> { + pair.into_inner() + .find(|p| p.as_rule() == Rule::field_defs) + .map_or(Ok(Vec::new()), |field_defs| { + field_defs + .into_inner() + .map(|p| self.parse_field_def(p)) + .collect::, _>>() + }) + } +} diff --git a/helix-db/src/helixc/parser/traversal_parse_methods.rs b/helix-db/src/helixc/parser/traversal_parse_methods.rs new file mode 100644 index 00000000..000310a3 --- /dev/null +++ b/helix-db/src/helixc/parser/traversal_parse_methods.rs @@ -0,0 +1,367 @@ +use crate::{ + helixc::parser::{ + HelixParser, Rule, + location::HasLoc, + parser_methods::ParserError, + types::{ + FieldAddition, FieldValue, FieldValueType, GraphStep, GraphStepType, IdType, Object, + ShortestPath, StartNode, Step, StepType, Traversal, ValueType, + }, + }, + protocol::value::Value, +}; +use pest::iterators::{Pair, Pairs}; + +impl HelixParser { + pub(super) fn parse_traversal(&self, pair: Pair) -> Result { + let mut pairs = pair.clone().into_inner(); + let start = self.parse_start_node(pairs.next().unwrap())?; + let steps = pairs + .map(|p| self.parse_step(p)) + .collect::, _>>()?; + + Ok(Traversal { + start, + steps, + loc: pair.loc(), + }) + } + + pub(super) fn parse_anon_traversal(&self, pair: Pair) -> Result { + let pairs = pair.clone().into_inner(); + let start = StartNode::Anonymous; + let steps = pairs + .map(|p| self.parse_step(p)) + .collect::, _>>()?; + + Ok(Traversal { + start, + steps, + loc: pair.loc(), + }) + } + + pub(super) fn parse_start_node(&self, pair: Pair) -> Result { + match pair.as_rule() { + Rule::start_node => { + let pairs = pair.into_inner(); + let mut node_type = String::new(); + let mut ids = None; + for p in pairs { + match p.as_rule() { + Rule::type_args => { + node_type = p.into_inner().next().unwrap().as_str().to_string(); + // WATCH + } + Rule::id_args => { + ids = Some( + p.into_inner() + .map(|id| { + let id = id.into_inner().next().unwrap(); + match id.as_rule() { + Rule::identifier => IdType::Identifier { + value: id.as_str().to_string(), + loc: id.loc(), + }, + Rule::string_literal => IdType::Literal { + value: id.as_str().to_string(), + loc: id.loc(), + }, + _ => { + panic!("Should be identifier or string literal") + } + } + }) + .collect::>(), + ); + } + Rule::by_index => { + ids = Some({ + let mut pairs: Pairs<'_, Rule> = p.clone().into_inner(); + let index = match pairs.next().unwrap().clone().into_inner().next() + { + Some(id) => match id.as_rule() { + Rule::identifier => IdType::Identifier { + value: id.as_str().to_string(), + loc: id.loc(), + }, + Rule::string_literal => IdType::Literal { + value: id.as_str().to_string(), + loc: id.loc(), + }, + other => { + panic!( + "Should be identifier or string literal: {other:?}" + ) + } + }, + None => return Err(ParserError::from("Missing index")), + }; + let value = match pairs.next().unwrap().into_inner().next() { + Some(val) => match val.as_rule() { + Rule::identifier => ValueType::Identifier { + value: val.as_str().to_string(), + loc: val.loc(), + }, + Rule::string_literal => ValueType::Literal { + value: Value::from(val.as_str()), + loc: val.loc(), + }, + Rule::integer => ValueType::Literal { + value: Value::from( + val.as_str().parse::().unwrap(), + ), + loc: val.loc(), + }, + Rule::float => ValueType::Literal { + value: Value::from( + val.as_str().parse::().unwrap(), + ), + loc: val.loc(), + }, + Rule::boolean => ValueType::Literal { + value: Value::from( + val.as_str().parse::().unwrap(), + ), + loc: val.loc(), + }, + _ => { + panic!("Should be identifier or string literal") + } + }, + _ => unreachable!(), + }; + vec![IdType::ByIndex { + index: Box::new(index), + value: Box::new(value), + loc: p.loc(), + }] + }) + } + _ => unreachable!(), + } + } + Ok(StartNode::Node { node_type, ids }) + } + Rule::start_edge => { + let pairs = pair.into_inner(); + let mut edge_type = String::new(); + let mut ids = None; + for p in pairs { + match p.as_rule() { + Rule::type_args => { + edge_type = p.into_inner().next().unwrap().as_str().to_string(); + } + Rule::id_args => { + ids = Some( + p.into_inner() + .map(|id| { + let id = id.into_inner().next().unwrap(); + match id.as_rule() { + Rule::identifier => IdType::Identifier { + value: id.as_str().to_string(), + loc: id.loc(), + }, + Rule::string_literal => IdType::Literal { + value: id.as_str().to_string(), + loc: id.loc(), + }, + other => { + println!("{other:?}"); + panic!("Should be identifier or string literal") + } + } + }) + .collect::>(), + ); + } + _ => unreachable!(), + } + } + Ok(StartNode::Edge { edge_type, ids }) + } + Rule::identifier => Ok(StartNode::Identifier(pair.as_str().to_string())), + Rule::search_vector => Ok(StartNode::SearchVector(self.parse_search_vector(pair)?)), + _ => Ok(StartNode::Anonymous), + } + } + + pub(super) fn parse_step(&self, pair: Pair) -> Result { + let inner = pair.clone().into_inner().next().unwrap(); + match inner.as_rule() { + Rule::graph_step => Ok(Step { + loc: inner.loc(), + step: StepType::Node(self.parse_graph_step(inner)), + }), + Rule::object_step => Ok(Step { + loc: inner.loc(), + step: StepType::Object(self.parse_object_step(inner)?), + }), + Rule::closure_step => Ok(Step { + loc: inner.loc(), + step: StepType::Closure(self.parse_closure(inner)?), + }), + Rule::where_step => Ok(Step { + loc: inner.loc(), + step: StepType::Where(Box::new(self.parse_expression(inner)?)), + }), + Rule::range_step => Ok(Step { + loc: inner.loc(), + step: StepType::Range(self.parse_range(pair)?), + }), + + Rule::bool_operations => Ok(Step { + loc: inner.loc(), + step: StepType::BooleanOperation(self.parse_bool_operation(inner)?), + }), + Rule::count => Ok(Step { + loc: inner.loc(), + step: StepType::Count, + }), + Rule::ID => Ok(Step { + loc: inner.loc(), + step: StepType::Object(Object { + fields: vec![FieldAddition { + key: "id".to_string(), + value: FieldValue { + loc: pair.loc(), + value: FieldValueType::Identifier("id".to_string()), + }, + loc: pair.loc(), + }], + should_spread: false, + loc: pair.loc(), + }), + }), + Rule::update => Ok(Step { + loc: inner.loc(), + step: StepType::Update(self.parse_update(inner)?), + }), + Rule::exclude_field => Ok(Step { + loc: inner.loc(), + step: StepType::Exclude(self.parse_exclude(inner)?), + }), + Rule::AddE => Ok(Step { + loc: inner.loc(), + step: StepType::AddEdge(self.parse_add_edge(inner, true)?), + }), + Rule::order_by => Ok(Step { + loc: inner.loc(), + step: StepType::OrderBy(self.parse_order_by(inner)?), + }), + _ => Err(ParserError::from(format!( + "Unexpected step type: {:?}", + inner.as_rule() + ))), + } + } + + pub(super) fn parse_graph_step(&self, pair: Pair) -> GraphStep { + let types = |pair: &Pair| { + pair.clone() + .into_inner() + .next() + .map(|p| p.as_str().to_string()) + .ok_or_else(|| ParserError::from("Expected type".to_string())) + .unwrap() + }; + let pair = pair.into_inner().next().unwrap(); + match pair.as_rule() { + Rule::out_e => { + let types = types(&pair); + GraphStep { + loc: pair.loc(), + step: GraphStepType::OutE(types), + } + } + Rule::in_e => { + let types = types(&pair); + GraphStep { + loc: pair.loc(), + step: GraphStepType::InE(types), + } + } + Rule::from_n => GraphStep { + loc: pair.loc(), + step: GraphStepType::FromN, + }, + Rule::to_n => GraphStep { + loc: pair.loc(), + step: GraphStepType::ToN, + }, + Rule::from_v => GraphStep { + loc: pair.loc(), + step: GraphStepType::FromV, + }, + Rule::to_v => GraphStep { + loc: pair.loc(), + step: GraphStepType::ToV, + }, + Rule::out => { + let types = types(&pair); + GraphStep { + loc: pair.loc(), + step: GraphStepType::Out(types), + } + } + Rule::in_nodes => { + let types = types(&pair); + GraphStep { + loc: pair.loc(), + step: GraphStepType::In(types), + } + } + Rule::shortest_path => { + let (type_arg, from, to) = pair.clone().into_inner().fold( + (None, None, None), + |(type_arg, from, to), p| match p.as_rule() { + Rule::type_args => ( + Some(p.into_inner().next().unwrap().as_str().to_string()), + from, + to, + ), + Rule::to_from => match p.into_inner().next() { + Some(p) => match p.as_rule() { + Rule::to => ( + type_arg, + from, + Some(p.into_inner().next().unwrap().as_str().to_string()), + ), + Rule::from => ( + type_arg, + Some(p.into_inner().next().unwrap().as_str().to_string()), + to, + ), + _ => unreachable!(), + }, + None => (type_arg, from, to), + }, + _ => (type_arg, from, to), + }, + ); + GraphStep { + loc: pair.loc(), + step: GraphStepType::ShortestPath(ShortestPath { + loc: pair.loc(), + from: from.map(|id| IdType::Identifier { + value: id, + loc: pair.loc(), + }), + to: to.map(|id| IdType::Identifier { + value: id, + loc: pair.loc(), + }), + type_arg, + }), + } + } + Rule::search_vector => GraphStep { + loc: pair.loc(), + step: GraphStepType::SearchVector(self.parse_search_vector(pair).unwrap()), + }, + _ => { + unreachable!() + } + } + } +} diff --git a/helix-db/src/helixc/parser/types.rs b/helix-db/src/helixc/parser/types.rs new file mode 100644 index 00000000..649a7f66 --- /dev/null +++ b/helix-db/src/helixc/parser/types.rs @@ -0,0 +1,958 @@ +use super::location::Loc; +use crate::{helixc::parser::HelixParser, protocol::value::Value}; +use chrono::{DateTime, NaiveDate, Utc}; +use itertools::Itertools; +use serde::{Deserialize, Serialize}; +use std::{ + collections::HashMap, + fmt::{Debug, Display}, +}; + +pub struct Content { + /// Source code of the content + pub content: String, + /// Parsed source code + pub source: Source, + /// Files in the content + pub files: Vec, +} + +#[derive(Clone, Serialize, Deserialize)] +pub struct HxFile { + pub name: String, + pub content: String, +} + +impl Default for HelixParser { + fn default() -> Self { + HelixParser { + source: Source { + source: String::new(), + schema: HashMap::new(), + migrations: Vec::new(), + queries: Vec::new(), + }, + } + } +} + +// AST Structures +#[derive(Debug, Clone, Default)] +pub struct Source { + pub source: String, + pub schema: HashMap, + pub migrations: Vec, + pub queries: Vec, +} + +impl Source { + pub fn get_latest_schema(&self) -> &Schema { + let latest_schema = self + .schema + .iter() + .max_by(|a, b| a.1.version.1.cmp(&b.1.version.1)) + .map(|(_, schema)| schema); + assert!(latest_schema.is_some()); + latest_schema.unwrap() + } + + /// Gets the schemas in order of version, from oldest to newest. + pub fn get_schemas_in_order(&self) -> Vec<&Schema> { + self.schema + .iter() + .sorted_by(|a, b| a.1.version.1.cmp(&b.1.version.1)) + .map(|(_, schema)| schema) + .collect() + } +} + +#[derive(Debug, Clone)] +pub struct Schema { + pub loc: Loc, + pub version: (Loc, usize), + pub node_schemas: Vec, + pub edge_schemas: Vec, + pub vector_schemas: Vec, +} + +#[derive(Debug, Clone)] +pub struct NodeSchema { + pub name: (Loc, String), + pub fields: Vec, + pub loc: Loc, +} + +#[derive(Debug, Clone)] +pub struct VectorSchema { + pub name: String, + pub fields: Vec, + pub loc: Loc, +} + +#[derive(Debug, Clone)] +pub struct EdgeSchema { + pub name: (Loc, String), + pub from: (Loc, String), + pub to: (Loc, String), + pub properties: Option>, + pub loc: Loc, +} + +#[derive(Debug, Clone)] +pub struct Migration { + pub from_version: (Loc, usize), + pub to_version: (Loc, usize), + pub body: Vec, + pub loc: Loc, +} + +#[derive(Debug, Clone)] +pub enum MigrationItem { + Node(String), + Edge(String), + Vector(String), +} + +impl MigrationItem { + pub fn inner(&self) -> &str { + match self { + MigrationItem::Node(s) => s, + MigrationItem::Edge(s) => s, + MigrationItem::Vector(s) => s, + } + } +} + +impl PartialEq for MigrationItem { + fn eq(&self, other: &MigrationItem) -> bool { + match (self, other) { + (MigrationItem::Node(a), MigrationItem::Node(b)) => a == b, + (MigrationItem::Edge(a), MigrationItem::Edge(b)) => a == b, + (MigrationItem::Vector(a), MigrationItem::Vector(b)) => a == b, + _ => false, + } + } +} + +#[derive(Debug, Clone)] +pub struct MigrationItemMapping { + pub from_item: (Loc, MigrationItem), + pub to_item: (Loc, MigrationItem), + pub remappings: Vec, + pub loc: Loc, +} + +#[derive(Debug, Clone)] +pub struct MigrationPropertyMapping { + pub property_name: (Loc, String), + pub property_value: FieldValue, + pub default: Option, + pub cast: Option, + pub loc: Loc, +} + +#[derive(Debug, Clone)] +pub struct ValueCast { + pub loc: Loc, + pub cast_to: FieldType, +} + +#[derive(Debug, Clone)] +pub struct Field { + pub prefix: FieldPrefix, + pub defaults: Option, + pub name: String, + pub field_type: FieldType, + pub loc: Loc, +} +impl Field { + pub fn is_indexed(&self) -> bool { + self.prefix.is_indexed() + } +} + +#[derive(Debug, Clone)] +pub enum DefaultValue { + Now, + String(String), + F32(f32), + F64(f64), + I8(i8), + I16(i16), + I32(i32), + I64(i64), + U8(u8), + U16(u16), + U32(u32), + U64(u64), + U128(u128), + Boolean(bool), + Empty, +} + +#[derive(Debug, Clone)] +pub enum FieldPrefix { + Index, + Optional, + Empty, +} +impl FieldPrefix { + pub fn is_indexed(&self) -> bool { + matches!(self, FieldPrefix::Index) + } +} + +#[derive(Debug, Clone)] +pub enum FieldType { + String, + F32, + F64, + I8, + I16, + I32, + I64, + U8, + U16, + U32, + U64, + U128, + Boolean, + Uuid, + Date, + Array(Box), + Identifier(String), + Object(HashMap), + // Closure(String, HashMap), +} + +impl PartialEq for FieldType { + fn eq(&self, other: &Self) -> bool { + match (self, other) { + (FieldType::String, FieldType::String) => true, + (FieldType::F32 | FieldType::F64, FieldType::F32 | FieldType::F64) => true, + ( + FieldType::I8 + | FieldType::I16 + | FieldType::I32 + | FieldType::I64 + | FieldType::U8 + | FieldType::U16 + | FieldType::U32 + | FieldType::U64 + | FieldType::U128, + FieldType::I8 + | FieldType::I16 + | FieldType::I32 + | FieldType::I64 + | FieldType::U8 + | FieldType::U16 + | FieldType::U32 + | FieldType::U64 + | FieldType::U128, + ) => true, + + (FieldType::Boolean, FieldType::Boolean) => true, + (FieldType::Uuid, FieldType::Uuid) => true, + (FieldType::Date, FieldType::Date) => true, + (FieldType::Array(a), FieldType::Array(b)) => a == b, + (FieldType::Identifier(a), FieldType::Identifier(b)) => a == b, + (FieldType::Object(a), FieldType::Object(b)) => a == b, + // (FieldType::Closure(a, b), FieldType::Closure(c, d)) => a == c && b == d, + _ => false, + } + } +} + +impl Display for FieldType { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + FieldType::String => write!(f, "String"), + FieldType::F32 => write!(f, "F32"), + FieldType::F64 => write!(f, "F64"), + FieldType::I8 => write!(f, "I8"), + FieldType::I16 => write!(f, "I16"), + FieldType::I32 => write!(f, "I32"), + FieldType::I64 => write!(f, "I64"), + FieldType::U8 => write!(f, "U8"), + FieldType::U16 => write!(f, "U16"), + FieldType::U32 => write!(f, "U32"), + FieldType::U64 => write!(f, "U64"), + FieldType::U128 => write!(f, "U128"), + FieldType::Boolean => write!(f, "Boolean"), + FieldType::Uuid => write!(f, "ID"), + FieldType::Date => write!(f, "Date"), + FieldType::Array(t) => write!(f, "Array({t})"), + FieldType::Identifier(s) => write!(f, "{s}"), + FieldType::Object(m) => { + write!(f, "{{")?; + for (k, v) in m { + write!(f, "{k}: {v}")?; + } + write!(f, "}}") + } // FieldType::Closure(a, b) => write!(f, "Closure({})", a), + } + } +} + +impl PartialEq for FieldType { + fn eq(&self, other: &Value) -> bool { + match (self, other) { + (FieldType::String, Value::String(_)) => true, + (FieldType::F32 | FieldType::F64, Value::F32(_) | Value::F64(_)) => true, + ( + FieldType::I8 + | FieldType::I16 + | FieldType::I32 + | FieldType::I64 + | FieldType::U8 + | FieldType::U16 + | FieldType::U32 + | FieldType::U64 + | FieldType::U128, + Value::I8(_) + | Value::I16(_) + | Value::I32(_) + | Value::I64(_) + | Value::U8(_) + | Value::U16(_) + | Value::U32(_) + | Value::U64(_) + | Value::U128(_), + ) => true, + (FieldType::Boolean, Value::Boolean(_)) => true, + (FieldType::Array(inner_type), Value::Array(values)) => { + values.iter().all(|v| inner_type.as_ref().eq(v)) + } + (FieldType::Object(fields), Value::Object(values)) => { + fields.len() == values.len() + && fields.iter().all(|(k, field_type)| match values.get(k) { + Some(value) => field_type.eq(value), + None => false, + }) + } + (FieldType::Date, value) => match value { + Value::String(date) => { + println!("date: {}, {:?}", date, date.parse::()); + date.parse::().is_ok() || date.parse::>().is_ok() + } + Value::I64(timestamp) => DateTime::from_timestamp(*timestamp, 0).is_some(), + Value::U64(timestamp) => DateTime::from_timestamp(*timestamp as i64, 0).is_some(), + _ => false, + }, + l => { + println!("l: {l:?}"); + false + } + } + } +} + +impl PartialEq for FieldType { + fn eq(&self, other: &DefaultValue) -> bool { + match (self, other) { + (FieldType::String, DefaultValue::String(_)) => true, + (FieldType::F32 | FieldType::F64, DefaultValue::F32(_) | DefaultValue::F64(_)) => true, + ( + FieldType::I8 + | FieldType::I16 + | FieldType::I32 + | FieldType::I64 + | FieldType::U8 + | FieldType::U16 + | FieldType::U32 + | FieldType::U64 + | FieldType::U128, + DefaultValue::I8(_) + | DefaultValue::I16(_) + | DefaultValue::I32(_) + | DefaultValue::I64(_) + | DefaultValue::U8(_) + | DefaultValue::U16(_) + | DefaultValue::U32(_) + | DefaultValue::U64(_) + | DefaultValue::U128(_), + ) => true, + (FieldType::Boolean, DefaultValue::Boolean(_)) => true, + (FieldType::Date, DefaultValue::String(date)) => { + println!("date: {}, {:?}", date, date.parse::()); + date.parse::().is_ok() || date.parse::>().is_ok() + } + (FieldType::Date, DefaultValue::I64(timestamp)) => { + DateTime::from_timestamp(*timestamp, 0).is_some() + } + (FieldType::Date, DefaultValue::U64(timestamp)) => { + DateTime::from_timestamp(*timestamp as i64, 0).is_some() + } + (FieldType::Date, DefaultValue::Now) => true, + _ => false, + } + } +} + +#[derive(Debug, Clone)] +pub struct Query { + pub original_query: String, + pub built_in_macro: Option, + pub name: String, + pub parameters: Vec, + pub statements: Vec, + pub return_values: Vec, + pub loc: Loc, +} + +#[derive(Debug, Clone)] +pub struct Parameter { + pub name: (Loc, String), + pub param_type: (Loc, FieldType), + pub is_optional: bool, + pub loc: Loc, +} + +#[derive(Debug, Clone)] +pub struct Statement { + pub loc: Loc, + pub statement: StatementType, +} + +#[derive(Debug, Clone)] +pub enum StatementType { + Assignment(Assignment), + Expression(Expression), + Drop(Expression), + ForLoop(ForLoop), +} + +#[derive(Debug, Clone)] +pub struct Assignment { + pub variable: String, + pub value: Expression, + pub loc: Loc, +} + +#[derive(Debug, Clone)] +pub struct ForLoop { + pub variable: ForLoopVars, + pub in_variable: (Loc, String), + pub statements: Vec, + pub loc: Loc, +} + +#[derive(Debug, Clone)] +pub enum ForLoopVars { + Identifier { + name: String, + loc: Loc, + }, + ObjectAccess { + name: String, + field: String, + loc: Loc, + }, + ObjectDestructuring { + fields: Vec<(Loc, String)>, + loc: Loc, + }, +} + +#[derive(Debug, Clone)] +pub struct Expression { + pub loc: Loc, + pub expr: ExpressionType, +} + +#[derive(Debug, Clone)] +pub struct ExistsExpression { + pub loc: Loc, + pub expr: Box, +} + +#[derive(Clone)] +pub enum ExpressionType { + Traversal(Box), + Identifier(String), + StringLiteral(String), + IntegerLiteral(i32), + FloatLiteral(f64), + BooleanLiteral(bool), + ArrayLiteral(Vec), + Exists(ExistsExpression), + BatchAddVector(BatchAddVector), + AddVector(AddVector), + AddNode(AddNode), + AddEdge(AddEdge), + Not(Box), + And(Vec), + Or(Vec), + SearchVector(SearchVector), + BM25Search(BM25Search), + Empty, +} + +#[derive(Debug, Clone)] +pub enum ReturnType { + Array(Vec), + Object(HashMap), + Expression(Expression), + Empty, +} + +impl Debug for ExpressionType { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + ExpressionType::Traversal(traversal) => write!(f, "Traversal({traversal:?})"), + ExpressionType::Identifier(s) => write!(f, "{s}"), + ExpressionType::StringLiteral(s) => write!(f, "{s}"), + ExpressionType::IntegerLiteral(i) => write!(f, "{i}"), + ExpressionType::FloatLiteral(fl) => write!(f, "{fl}"), + ExpressionType::BooleanLiteral(b) => write!(f, "{b}"), + ExpressionType::ArrayLiteral(a) => write!(f, "Array({a:?})"), + ExpressionType::Exists(e) => write!(f, "Exists({e:?})"), + ExpressionType::BatchAddVector(bav) => write!(f, "BatchAddVector({bav:?})"), + ExpressionType::AddVector(av) => write!(f, "AddVector({av:?})"), + ExpressionType::AddNode(an) => write!(f, "AddNode({an:?})"), + ExpressionType::AddEdge(ae) => write!(f, "AddEdge({ae:?})"), + ExpressionType::Not(expr) => write!(f, "Not({expr:?})"), + ExpressionType::And(exprs) => write!(f, "And({exprs:?})"), + ExpressionType::Or(exprs) => write!(f, "Or({exprs:?})"), + ExpressionType::SearchVector(sv) => write!(f, "SearchVector({sv:?})"), + ExpressionType::BM25Search(bm25) => write!(f, "BM25Search({bm25:?})"), + ExpressionType::Empty => write!(f, "Empty"), + } + } +} +impl Display for ExpressionType { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + ExpressionType::Traversal(traversal) => write!(f, "Traversal({traversal:?})"), + ExpressionType::Identifier(s) => write!(f, "{s}"), + ExpressionType::StringLiteral(s) => write!(f, "{s}"), + ExpressionType::IntegerLiteral(i) => write!(f, "{i}"), + ExpressionType::FloatLiteral(fl) => write!(f, "{fl}"), + ExpressionType::BooleanLiteral(b) => write!(f, "{b}"), + ExpressionType::ArrayLiteral(a) => write!(f, "Array({a:?})"), + ExpressionType::Exists(e) => write!(f, "Exists({e:?})"), + ExpressionType::BatchAddVector(bav) => write!(f, "BatchAddVector({bav:?})"), + ExpressionType::AddVector(av) => write!(f, "AddVector({av:?})"), + ExpressionType::AddNode(an) => write!(f, "AddNode({an:?})"), + ExpressionType::AddEdge(ae) => write!(f, "AddEdge({ae:?})"), + ExpressionType::Not(expr) => write!(f, "Not({expr:?})"), + ExpressionType::And(exprs) => write!(f, "And({exprs:?})"), + ExpressionType::Or(exprs) => write!(f, "Or({exprs:?})"), + ExpressionType::SearchVector(sv) => write!(f, "SearchVector({sv:?})"), + ExpressionType::BM25Search(bm25) => write!(f, "BM25Search({bm25:?})"), + ExpressionType::Empty => write!(f, "Empty"), + } + } +} + +#[derive(Debug, Clone)] +pub struct Traversal { + pub start: StartNode, + pub steps: Vec, + pub loc: Loc, +} + +#[derive(Debug, Clone)] +pub struct BatchAddVector { + pub vector_type: Option, + pub vec_identifier: Option, + pub fields: Option>, + pub loc: Loc, +} + +#[derive(Debug, Clone)] +pub enum StartNode { + Node { + node_type: String, + ids: Option>, + }, + Edge { + edge_type: String, + ids: Option>, + }, + SearchVector(SearchVector), + Identifier(String), + Anonymous, +} + +#[derive(Debug, Clone)] +pub struct Step { + pub loc: Loc, + pub step: StepType, +} + +#[derive(Debug, Clone)] +pub enum OrderByType { + Asc, + Desc, +} + +#[derive(Debug, Clone)] +pub struct OrderBy { + pub loc: Loc, + pub order_by_type: OrderByType, + pub expression: Box, +} + +#[derive(Debug, Clone)] +pub enum StepType { + Node(GraphStep), + Edge(GraphStep), + Where(Box), + BooleanOperation(BooleanOp), + Count, + Update(Update), + Object(Object), + Exclude(Exclude), + Closure(Closure), + Range((Expression, Expression)), + OrderBy(OrderBy), + AddEdge(AddEdge), +} +impl PartialEq for StepType { + fn eq(&self, other: &StepType) -> bool { + matches!( + (self, other), + (&StepType::Node(_), &StepType::Node(_)) + | (&StepType::Edge(_), &StepType::Edge(_)) + | (&StepType::Where(_), &StepType::Where(_)) + | ( + &StepType::BooleanOperation(_), + &StepType::BooleanOperation(_) + ) + | (&StepType::Count, &StepType::Count) + | (&StepType::Update(_), &StepType::Update(_)) + | (&StepType::Object(_), &StepType::Object(_)) + | (&StepType::Exclude(_), &StepType::Exclude(_)) + | (&StepType::Closure(_), &StepType::Closure(_)) + | (&StepType::Range(_), &StepType::Range(_)) + | (&StepType::OrderBy(_), &StepType::OrderBy(_)) + | (&StepType::AddEdge(_), &StepType::AddEdge(_)) + ) + } +} +#[derive(Debug, Clone)] +pub struct FieldAddition { + pub key: String, + pub value: FieldValue, + pub loc: Loc, +} + +#[derive(Debug, Clone)] +pub struct FieldValue { + pub loc: Loc, + pub value: FieldValueType, +} + +#[derive(Debug, Clone)] +pub enum FieldValueType { + Traversal(Box), + Expression(Expression), + Fields(Vec), + Literal(Value), + Identifier(String), + Empty, +} + +#[derive(Debug, Clone)] +pub struct GraphStep { + pub loc: Loc, + pub step: GraphStepType, +} + +#[derive(Debug, Clone)] +pub enum GraphStepType { + Out(String), + In(String), + + FromN, + ToN, + FromV, + ToV, + + OutE(String), + InE(String), + + ShortestPath(ShortestPath), + SearchVector(SearchVector), +} +impl GraphStep { + pub fn get_item_type(&self) -> Option { + match &self.step { + GraphStepType::Out(s) => Some(s.clone()), + GraphStepType::In(s) => Some(s.clone()), + GraphStepType::OutE(s) => Some(s.clone()), + GraphStepType::InE(s) => Some(s.clone()), + GraphStepType::SearchVector(s) => Some(s.vector_type.clone().unwrap()), + _ => None, + } + } +} + +#[derive(Debug, Clone)] +pub struct ShortestPath { + pub loc: Loc, + pub from: Option, + pub to: Option, + pub type_arg: Option, +} + +#[derive(Debug, Clone)] +pub struct BooleanOp { + pub loc: Loc, + pub op: BooleanOpType, +} + +#[derive(Debug, Clone)] +pub enum BooleanOpType { + And(Vec), + Or(Vec), + GreaterThan(Box), + GreaterThanOrEqual(Box), + LessThan(Box), + LessThanOrEqual(Box), + Equal(Box), + NotEqual(Box), + Contains(Box), + IsIn(Box), +} + +#[derive(Debug, Clone)] +pub enum VectorData { + Vector(Vec), + Identifier(String), + Embed(Embed), +} + +#[derive(Debug, Clone)] +pub struct Embed { + pub loc: Loc, + pub value: EvaluatesToString, +} + +#[derive(Debug, Clone)] +pub enum EvaluatesToString { + Identifier(String), + StringLiteral(String), +} + +#[derive(Debug, Clone)] +pub struct SearchVector { + pub loc: Loc, + pub vector_type: Option, + pub data: Option, + pub k: Option, + pub pre_filter: Option>, +} + +#[derive(Debug, Clone)] +pub struct BM25Search { + pub loc: Loc, + pub type_arg: Option, + pub data: Option, + pub k: Option, +} + +#[derive(Debug, Clone)] +pub struct EvaluatesToNumber { + pub loc: Loc, + pub value: EvaluatesToNumberType, +} + +#[derive(Debug, Clone)] +pub enum EvaluatesToNumberType { + I8(i8), + I16(i16), + I32(i32), + I64(i64), + U8(u8), + U16(u16), + U32(u32), + U64(u64), + U128(u128), + F32(f32), + F64(f64), + Identifier(String), +} + +#[derive(Debug, Clone)] +pub struct AddVector { + pub loc: Loc, + pub vector_type: Option, + pub data: Option, + pub fields: Option>, +} + +#[derive(Debug, Clone)] +pub struct AddNode { + pub loc: Loc, + pub node_type: Option, + pub fields: Option>, +} + +#[derive(Debug, Clone)] +pub struct AddEdge { + pub loc: Loc, + pub edge_type: Option, + pub fields: Option>, + pub connection: EdgeConnection, + pub from_identifier: bool, +} + +#[derive(Debug, Clone)] +pub struct EdgeConnection { + pub loc: Loc, + pub from_id: Option, + pub to_id: Option, +} + +#[derive(Debug, Clone)] +pub enum IdType { + Literal { + value: String, + loc: Loc, + }, + Identifier { + value: String, + loc: Loc, + }, + ByIndex { + index: Box, + value: Box, + loc: Loc, + }, +} +impl Display for IdType { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + IdType::Literal { value, loc: _ } => write!(f, "{value}"), + IdType::Identifier { value, loc: _ } => write!(f, "{value}"), + IdType::ByIndex { + index, + value: _, + loc: _, + } => write!(f, "{index}"), + } + } +} + +#[derive(Debug, Clone)] +pub enum ValueType { + Literal { + value: Value, + loc: Loc, + }, + Identifier { + value: String, + loc: Loc, + }, + Object { + fields: HashMap, + loc: Loc, + }, +} +impl ValueType { + pub fn new(value: Value, loc: Loc) -> ValueType { + ValueType::Literal { value, loc } + } + pub fn to_string(&self) -> String { + match self { + ValueType::Literal { value, loc: _ } => value.to_string(), + ValueType::Identifier { value, loc: _ } => value.clone(), + ValueType::Object { fields, loc: _ } => { + fields.keys().cloned().collect::>().join(", ") + } + } + } +} + +impl From for ValueType { + fn from(value: Value) -> ValueType { + match value { + Value::String(s) => ValueType::Literal { + value: Value::String(s), + loc: Loc::empty(), + }, + Value::I32(i) => ValueType::Literal { + value: Value::I32(i), + loc: Loc::empty(), + }, + Value::F64(f) => ValueType::Literal { + value: Value::F64(f), + loc: Loc::empty(), + }, + Value::Boolean(b) => ValueType::Literal { + value: Value::Boolean(b), + loc: Loc::empty(), + }, + Value::Array(arr) => ValueType::Literal { + value: Value::Array(arr), + loc: Loc::empty(), + }, + Value::Empty => ValueType::Literal { + value: Value::Empty, + loc: Loc::empty(), + }, + _ => unreachable!(), + } + } +} + +impl From for String { + fn from(id_type: IdType) -> String { + match id_type { + IdType::Literal { mut value, loc: _ } => { + value.retain(|c| c != '"'); + value + } + IdType::Identifier { value, loc: _ } => value, + IdType::ByIndex { + index, + value: _, + loc: _, + } => String::from(*index), + } + } +} + +impl From for IdType { + fn from(mut s: String) -> IdType { + s.retain(|c| c != '"'); + IdType::Literal { + value: s, + loc: Loc::empty(), + } + } +} + +#[derive(Debug, Clone)] +pub struct Update { + pub fields: Vec, + pub loc: Loc, +} + +#[derive(Debug, Clone)] +pub struct Object { + pub loc: Loc, + pub fields: Vec, + pub should_spread: bool, +} + +#[derive(Debug, Clone)] +pub struct Exclude { + pub fields: Vec<(Loc, String)>, + pub loc: Loc, +} + +#[derive(Debug, Clone)] +pub struct Closure { + pub identifier: String, + pub object: Object, + pub loc: Loc, +} + +#[derive(Debug, Clone)] +pub enum BuiltInMacro { + MCP, + Model(String), +} diff --git a/helix-db/src/helixc/parser/utils.rs b/helix-db/src/helixc/parser/utils.rs new file mode 100644 index 00000000..33714682 --- /dev/null +++ b/helix-db/src/helixc/parser/utils.rs @@ -0,0 +1,86 @@ +use crate::helixc::parser::{ + HelixParser, Rule, + location::HasLoc, + parser_methods::ParserError, + types::{EdgeConnection, Expression, IdType}, +}; +use pest::iterators::Pair; + +impl HelixParser { + pub(super) fn parse_id_args(&self, pair: Pair) -> Result, ParserError> { + let p = pair + .into_inner() + .next() + .ok_or_else(|| ParserError::from("Missing ID"))?; + match p.as_rule() { + Rule::identifier => Ok(Some(IdType::Identifier { + value: p.as_str().to_string(), + loc: p.loc(), + })), + Rule::string_literal | Rule::inner_string => Ok(Some(IdType::Literal { + value: p.as_str().to_string(), + loc: p.loc(), + })), + _ => Err(ParserError::from(format!( + "Unexpected rule in parse_id_args: {:?}", + p.as_rule() + ))), + } + } + pub(super) fn parse_vec_literal(&self, pair: Pair) -> Result, ParserError> { + let pairs = pair.into_inner(); + let mut vec = Vec::new(); + for p in pairs { + vec.push( + p.as_str() + .parse::() + .map_err(|_| ParserError::from("Invalid float value"))?, + ); + } + Ok(vec) + } + + pub(super) fn parse_array_literal( + &self, + pair: Pair, + ) -> Result, ParserError> { + println!("pair: {pair:?}"); + pair.into_inner() + .map(|p| self.parse_expression(p)) + .collect() + } + + pub(super) fn parse_string_literal(&self, pair: Pair) -> Result { + let inner = pair + .into_inner() + .next() + .ok_or_else(|| ParserError::from("Empty string literal"))?; + + let mut literal = inner.as_str().to_string(); + literal.retain(|c| c != '"'); + Ok(literal) + } + + pub(super) fn parse_to_from(&self, pair: Pair) -> Result { + let pairs = pair.clone().into_inner(); + let mut from_id = None; + let mut to_id = None; + // println!("pairs: {:?}", pairs); + for p in pairs { + match p.as_rule() { + Rule::from => { + from_id = self.parse_id_args(p.into_inner().next().unwrap())?; + } + Rule::to => { + to_id = self.parse_id_args(p.into_inner().next().unwrap())?; + } + _ => unreachable!(), + } + } + Ok(EdgeConnection { + from_id, + to_id, + loc: pair.loc(), + }) + } +} diff --git a/helix-db/src/protocol/value.rs b/helix-db/src/protocol/value.rs index c4bba151..e33d7def 100644 --- a/helix-db/src/protocol/value.rs +++ b/helix-db/src/protocol/value.rs @@ -1362,7 +1362,7 @@ impl From for f64 { } pub mod casting { - use crate::helixc::parser::helix_parser::FieldType; + use crate::helixc::parser::types::FieldType; use super::*; From fe7326913a95737b72c45d8904aaba4916907429 Mon Sep 17 00:00:00 2001 From: xav-db Date: Fri, 5 Sep 2025 12:23:51 +0100 Subject: [PATCH 02/18] removing old photos and readmes --- helix-db/src/helix_engine/README.md | 19 --- helix-db/src/helix_engine/bm25/README.md | 150 ------------------ helix-db/src/helix_engine/queryProcess.png | Bin 1008009 -> 0 bytes .../src/helix_engine/traversal_core/README.md | 3 - helix-db/src/helix_gateway/README.md | 14 -- helix-db/src/helix_gateway/gateway.png | Bin 90530 -> 0 bytes 6 files changed, 186 deletions(-) delete mode 100644 helix-db/src/helix_engine/README.md delete mode 100644 helix-db/src/helix_engine/bm25/README.md delete mode 100644 helix-db/src/helix_engine/queryProcess.png delete mode 100644 helix-db/src/helix_engine/traversal_core/README.md delete mode 100644 helix-db/src/helix_gateway/README.md delete mode 100644 helix-db/src/helix_gateway/gateway.png diff --git a/helix-db/src/helix_engine/README.md b/helix-db/src/helix_engine/README.md deleted file mode 100644 index 9461b44a..00000000 --- a/helix-db/src/helix_engine/README.md +++ /dev/null @@ -1,19 +0,0 @@ -### Overview - -##### Router -- Parse request -- Verify request -- Route request to api handler - -##### API -- Pull thread from thread pool -- Transfer request to thread with corresponding handler -- Execute request - -##### Graph Engine -- Core graph implementation -- Interface with rocks db -- Handles calls from API via internal UNIX socket - -#### Process of Uploading Queries -![Query Process](queryProcess.png) \ No newline at end of file diff --git a/helix-db/src/helix_engine/bm25/README.md b/helix-db/src/helix_engine/bm25/README.md deleted file mode 100644 index fd2b3700..00000000 --- a/helix-db/src/helix_engine/bm25/README.md +++ /dev/null @@ -1,150 +0,0 @@ -# BM25 Implementation for HelixDB - -This module provides a complete BM25 (Best Matching 25) implementation for full-text search in your graph vector database. BM25 is a probabilistic ranking function used by search engines to estimate the relevance of documents to a given search query. - -## Features - -- **Disk-based storage**: Uses LMDB for persistent inverted index storage -- **Full BM25 scoring**: Implements the complete BM25 algorithm with configurable parameters -- **CRUD operations**: Support for inserting, updating, and deleting documents -- **Hybrid search ready**: Designed to work alongside vector similarity search -- **Efficient tokenization**: Includes text preprocessing and tokenization -- **Scalable**: Handles large document collections efficiently - -## Architecture - -The BM25 implementation uses four LMDB databases: - -1. **Inverted Index** (`bm25_inverted_index`): Maps terms to posting lists containing document IDs and term frequencies -2. **Document Lengths** (`bm25_doc_lengths`): Stores the length of each indexed document -3. **Term Frequencies** (`bm25_term_frequencies`): Stores document frequency for each term -4. **Metadata** (`bm25_metadata`): Stores global statistics like total documents and average document length - -## Usage - -### Basic Text Search - -```rust -use helixdb::helix_engine::{ - bm25::BM25, - storage_core::HelixGraphStorage, -}; - -// Assuming you have a HelixGraphStorage instance -let storage = HelixGraphStorage::new(db_path, config)?; - -// Index a document -let doc_id = node.id; -let text = "The quick brown fox jumps over the lazy dog"; -storage.insert_doc(doc_id, text)?; - -// Search for documents -let results = storage.search("quick fox", 10)?; -for (doc_id, score) in results { - println!("Document {}: Score {:.4}", doc_id, score); -} -``` - -### Document Management - -```rust -// Update a document (deletes old and re-indexes) -storage.update_doc(doc_id, "Updated text content")?; - -// Delete a document from the index -storage.delete_doc(doc_id)?; -``` - -### Hybrid Search (BM25 + Vector Similarity) - -```rust -use helixdb::helix_engine::bm25::HybridSearch; - -// Combine BM25 text search with vector similarity -let query_text = "machine learning"; -let query_vector = Some(&[0.1, 0.2, 0.3, ...]); // Your query vector -let alpha = 0.7; // Weight for BM25 vs vector similarity (0.7 = 70% BM25, 30% vector) -let limit = 10; - -let results = storage.hybrid_search(query_text, query_vector, alpha, limit)?; -``` - -### Automatic Node Indexing - -The implementation automatically extracts text from nodes by combining: -- Node label -- All property keys and values - -```rust -// This node will be indexed as: "Person name John Doe age 30" -let node = Node { - id: uuid, - label: "Person".to_string(), - properties: Some(hashmap!{ - "name".to_string() => Value::String("John Doe".to_string()), - "age".to_string() => Value::Integer(30), - }), -}; -``` - -## BM25 Algorithm Details - -The implementation uses the standard BM25 formula: - -``` -score(D,Q) = Σ IDF(qi) * (f(qi,D) * (k1 + 1)) / (f(qi,D) + k1 * (1 - b + b * |D| / avgdl)) -``` - -Where: -- `D` is a document -- `Q` is a query -- `qi` is the i-th query term -- `f(qi,D)` is the term frequency of qi in document D -- `|D|` is the length of document D -- `avgdl` is the average document length -- `k1` and `b` are tuning parameters (default: k1=1.2, b=0.75) -- `IDF(qi)` is the inverse document frequency of qi - -## Configuration - -Default BM25 parameters: -- `k1 = 1.2`: Controls term frequency saturation -- `b = 0.75`: Controls length normalization - -These can be adjusted based on your specific use case: -- Higher `k1` values give more weight to term frequency -- Higher `b` values give more weight to document length normalization - -## Performance Considerations - -1. **Indexing**: O(n) where n is the number of unique terms in the document -2. **Search**: O(m * k) where m is the number of query terms and k is the average posting list length -3. **Storage**: Efficient disk-based storage with LMDB's memory-mapped files -4. **Memory**: Minimal memory usage as data is stored on disk - -## Integration with Vector Search - -The BM25 implementation is designed to work seamlessly with your existing vector similarity search: - -1. **Complementary**: BM25 handles exact term matching while vectors handle semantic similarity -2. **Hybrid scoring**: Combine scores using weighted averages -3. **Fallback**: Use BM25 when vector search returns insufficient results -4. **Filtering**: Use BM25 to pre-filter candidates for vector search - -## Example Use Cases - -1. **Document Search**: Full-text search across node properties -2. **Hybrid Retrieval**: Combine keyword and semantic search -3. **Query Expansion**: Use BM25 to find related terms for vector queries -4. **Faceted Search**: Filter by text criteria before vector similarity -5. **Autocomplete**: Fast prefix matching for search suggestions - -## Error Handling - -The implementation provides comprehensive error handling: -- Database connection errors -- Serialization/deserialization errors -- Missing document errors -- Invalid query errors - -All errors are wrapped in the `GraphError` type for consistent error handling across the system. \ No newline at end of file diff --git a/helix-db/src/helix_engine/queryProcess.png b/helix-db/src/helix_engine/queryProcess.png deleted file mode 100644 index 68e766d41a321550190662ec7f91b3d995205338..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1008009 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

1-;vvsrF#3xn*d%KtmfI6F{PX)2 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 &E3bA z4n8WbE>PD9VtXsP$kVRXy{V=6JY-p%%Hz%|{w>;gN`ALxn*p`|<$fy6kXdn7&8@+f z{Zw#J2v@4zOLoMesGK{5x$sX(IqRP zTjd73zP1Y>9IaBwa3v)$_qh&8pDj`9po+#tVDA9;pF{9|4>q`tWyq?V$d9AQ$orcP zO1r@zWdhQ*&1YY?C`R7m3YXwMvB2<1?Ck_clLyn7`5JUUDEZf;T$u3%GYh ztGvToD(l8K)XU(uDrW7i4?JO@gCbNg~tit;Uis?USZsM(Ms+_OvnWD&2PO1=JY@Roz88_c>?|$9mm-cS8I9WRa8&Gb_A9K zfwBRPABRZ08^-z~UlUrDEKNClaGv7lPw)>^hpNS=Hm1(J_-s?+Sv^6oXOMeht6h4wi2 z=qOC_90x((D1)rgAt7tdGt^@IRjrA~M6QzJZh*HwxW&Zb6^iMd9BLxD!qFqNRtmfb*AW`q> zdo%p!Q&1xKK%`xvy^X!ia}gj%{T_S$hQRm$bf)1s#+^?HP|x+-fDOoA7DBrwMF)UR zVI(BfXl*8fscisMc{J;3%Mgs~1<}=Yu+Kr}KH#D%HW7jEc9Fj8p za^Jbw3^EL2sLk=6Ge!c}MJ2*gye`;Fc3AvLv7&$Y&09om6O-Qx^z09r094L9Uz zE;_jpT1VaE^o~4TGuV&PYgRVBJ}LpH{XqzEzIlBJ5kxpx@CpT<1sWCO7^!<8$)0#X z<{2$BNU4}TZ$MddtOet8Xn=;9-$jMZEw)LZdYi)?zWNB`ykF&SVg+&y*(&e~A=j{H z(Yz?jRMnnOy?|K;qk~mJoG{e%*^?94Nx}f%EsRQ7eB(;D{Ovv{ZUXZj{_Rym(WECF z>c_uqVh#)s9`2J~W&ZGesOV{lMfoTStT1?SbNbc`cibzPzvz=R&eh(?%t9~e7|p<_ zjttZI%M#Q!uwM3~1YHyj+?;$HOJFNU`66B8i0FLBv+*Nvoe@@&{N?_C<^7-k=(rM6 zH_?os*(n9GruZr6I`Nt?l+`Pa7K({{Cr^U8E&3E--94{6_hW(h9dZ4yKU#}(%_M+0 zSAaSc-KWv;CRH@Vgj&&Bh^aDHzHHc51=xMgm*QZ0ay)Jwe*g9J|3>sH_pup%5B7W_ zH%Od0CBG`!u25G!W*r|)QnfR$Pt`GHm2qod)7dQe5e^qVo``h2!ibGH07*NQOM{#s z!oUs{1ywFfQPHVj{(=EB4p6;?8Z_wz-@dsuG%1lII4b7(n~Tg?-+zRpo=F93Pc+~k zt$cgz3$`u$TLAc*IR9z7Lx!!yg3-odqH{!!q&^A5 z#sUMS$p*t$5=uwbkVKb_oKUYSI6fO8iz&mRdjb-7(r?4B;2xjNE9yW%fnW~R>k?yaM839`679;hoQ7BJ&$ z%S@#*7v=kK(ImNHXSmT?L2AynWSM>)7AiOdW)cpBE}?KXtlM#fyT4fkf!m=v7&Bpt zfn(qI~%qQ4o zMRYklI737IXiti{wyKcwb*rxhbC;=CLg$Z=iTM1pZUo>C;Y zO7S$i!AG_h1BF*)cYglK|Lt@rAp+`=vMzM05KZ+V1rdXnPpYEDb6i&+)GGxP)nB?e z4}sdMbNa5+gIL4<>;E#(H7_M3^$%&SQ~%6+Wv z@*~gtx$k5#C0pwz_M%hmcFxj!Ak(O69sPCYsMhj&gFv`7-u`j`gDR-5k7jUvU7yL* zn+{(eYI0!9opD8TRd=CUuwAAPyAhxa_mOED15G&ZT5+vxHZn~H)ChI?92A7l=1zKM zzQcWM2MUH9z9L{=HR6_J>|Zc||JA=Jl0T2&_AjAfEwd*$4f^q~Xt7hmL4Gizz)N%f zsWa)RcWci74)YF_4|FRKteB2SC)JhCN|J1uMHgcX*JAo#>BFnqx zyg{_Y;EHd>oe%fqlM~@bEE=V8ZZV>Qt#i7nr#Bakd}Vg=Ge)^;3 z?-7!mtC3gj8_m6ivB1QEk6N58b2f|o5vCwcoI$fNNH4_~PJxdmA}99l*o@L8o@wq= z5f;KVOME;OuA&+;?!7;*cT|8d=vjcR$Qo8F$&+PlH+gx&9@hnc<_=01R@kqnOSm~w zS|gqR3jPYN7=fP##Dm6(6SMPrlXYENYfot3So7ljD3WC^o^3o1qbHr{%m_iGgDLy$ zdu%TRIva#%cpGWL1Rl(Prn>t{Jh%2OT+xIh)5+@+h-Np97hanLwMt(+|0aMPyg@x5 z`$hsxWcUJc{YcdMct_rW@NEHCaV6KV_o4H=S)ppvos)AmvS@^sM6LO##M-0;{#0??L46Y}OVWTmPA;$lZk@KpeI5r7!3vq=6)0WS@}>7h{0l~1 z#9V7DdSnxBI$TJXJ8&3t78C){T3>G!?S>uJo9GV2lI3O78yn%5_&Lq=9S=?U3{+m| zE`QCdA3vffbdRIbcR|;d-xj;D31&y-Q^0`B6W(>idbvJ#tDZ{i z5#y$=MauK1xc2j%mBoL^aEqIc;>`J1Gg?S|0xGdHcp@fm-+CRsx$$`TT{pLIx=myZ z8|hefGDLQgxe-q!o-CYmvWS<T>I81-1b0UwfVy)>hfD6H`TQS(@UMV5SK>ba!&^${#5rfi^$NAD3~2u zChcY)<-AUHIP&c9kpiPt8NbJHWr7oA1p&dPWqNU=lO zQXKEy$eqrwYdr&8QlKp3v4eErL7G;5j0TE|xmlT8Gx16Q({7JGN=;4}T0+wrgJqy! zgdFDQ=LAruoYcHS&LJim;AC^v)@y|Z0o{mal@i=KGrdCPt}Zng)Pe5_3U@Qy@ntQNT^?B|JUYO6pvDy#3Fst&> z%d)tg2fV@b;CdL$Wcb~8!1;`T1ZwIH(#F6TCf8rT;KGP&ZM*YKr7aAFL2OEAPp*Oo z^_4n+&rGM1-a%)W{>8WLL?1=;NSDu4bsrpUh1J%tUZBpCp1XV5G;%n7bCmPVPAj>N zBmBgx@Y38uG!uN3P<9A5zBPqOAGsay7ow5r^{L{+Kot)WNe+Yyy93AGVvYpZi-6hb zmoL!xR6C|Gn?7^a-TqNDvpX57&nE83>-u3RboK26C|3#b{=C?1|z0^71ifx@Ti!gN_|6b_Nbh7A0RE4~eP*e(99X!(^I(ZAbwLLq9+U5pvZExIZKQ z91%p54s$wRDQUbGjNCLdqt^y5m8IOQlt?|Nd-|JCJx79P+9qN8*c_(VZ}Zc?fFU}7 z=)T>HtP8JF5A$socuawiv1_b}dTn!jjahD@2Z^A4Te@apKDOd)7~x4CAPmvl<#%$u z2mvb0p;3F+Oq;az;C2!LT7NpmR8UE!jUIe^Gd{JjJqPWyIw}TY0OG&up8Vt|v z1W$juliS`r>HPz*AT&LRP-YGhF|90zsn~s4}AIH08tvdh>&ZCW}9n5r_%0y zl3K)2|NUHm-!Ia`H(?Z+sf1I~usLvqmNuJPV*rSU&^{N&)xj z4n#XMQ!}+UsOB!2O`@N5TA8Jv-hwHy4WL_$zRKrDRKUS( z&Hs)L*Xv5aMO1QZL!62M3kRC=*%s0z}XQbf8CsevFm>I4upNQYpdSLr>m zP((@;2%&{YXp#^jC4>+H-#)%G%)Hn2eC2u{zkkO)0dHk1BAZ+$b7lWFPz@C2G5^dhxd)FUC)#n{-_&v+HLjmr z7Y>)d5+PwYYvLcg{+PQjKVJwk7Y*G1>%X#pcnCjU2%+qu@-Dy9S9`#Q?r~E7^Owka zei!!EBUecH7~D>B)S)}NCj9D>&Iyefsi-$kSe^z3$x*92V<{qci2 zZ&HP>_&9X-56mAIz*2wxdCd90zWMsVR*;@O6&i%rk(YJ2@zp2@d~F+R{2P3wLMRv2 znY&O^?IO8t{Z;*O7m0TSBAN_p^^_|#WVw_cJihbK=H}icu)0T(rR#E`{}v6T@=xcg zmQvfK8Kl$`eEG*u)sQgMkE)Q@H%VeQxVaA38$6cG!4gaR{R)4saJS9#1vS_2r4#q{ z?d3lgI2Nb}R8fiufSy{~wM*Guix_tY1?|LaT;JwD z>>}&;@1@;te4-%M(4j}5`CU${$DgrEU+BLQaWnrF@8oCy^XSsfQp_>=$vt ze;+`OyKdAaBoGrv!bTFyMXt51N1q>do7)c^?C$$b)oz_OI(S@VgD&FU?#Pq_=I<2O zzpz;k1mi03?CO_C|7PqrOqBom>{4eQ@&9^-f7s3acJTP*Myc~9s#}N?D-UpgTmnh% z9~_s|z5hxkLbO-B^Itx1{wsBa!;c=ksJT%g&t(0#+G~6rcwTB1^KAaPr+(N@35Op# zKC@d|_klvz?-{Y{LGs}7ivrjUF}pG->+g`h+fOB9h*0jGbzFLVFN9k6ooMEVjqJ@z zu=~NG23m~kvKyTCAJ}$*mna!-JXdEq@bvLtYhB7>UtioU#~`S1rY_I=?=QV5_Z^UVuGkHqQz{f$GCWzRK#2V-fv-RO|Lh_w5!|E6 z^gZ=;3(@dag@cH1V}ysD|GpqPx8>Q^@D6DA?)}*A{`c+vsK+Oje^=izmi^Hn9G!rr zf)z7L5pbCh{_Eq*q^~Te!Vur4lLppL?Yr)AS(~MUE>$l^m@crSXEkk?b%%wMb zr|t&+XsntDgRl&CTV~4o*LGieeofX;pl=GvPlK<&d20$_b=&_|&%C*|>%TC`Xz zf3|*qJ(l%502g~@pIZ!F-%0%Y-`f4clTNrSE}Z%AQ90`gpaxC8I;j6$ZSLCg3_zgo ztGf#q_xC6KsJqlx3g7b7RsZl8gtFVj^?=6@)c(-8;Gd?b#Hyb+YyS8_{_BZ!Zo95= z>r+chcls}5tKX(wbn1eayVJG(3_m6T!q6CdofX>cwO94VpS$NxxyVsa^L;!@3~WA; zx6+-3J55UhKB>eW4Mmre4&gRoJ_Eaume7Ps_r>oKbMn}Z|9=tF^jennJt|yLSE?V8 zq54VBe!0sHIF%LQLgrfO$?iqDkTIpATBNDDZACD!_Oz8=Yyf7FdBDlKe0h+%sw~CB zk34H2rF}>NV|oX%Ty$8KJ{3u5Ykoxy);4xo?fATO}ovn z5%^5+eBhOYM|+y_2t&SYrYRn!h*Q9o$~3{&-_lceU1XA6H-@WuIR+Q=4DQok+<);9Xzxv6@J2e}w7r zC8GMog+gbw#LhL;vKAZ|$18!(NK5rTui@-N8^G1Ogw=KoD zO^!V`+u$3m{Oq(tREt=EO~uD!`8`yQP`7^jGDaGgv&QGM!iv{!T8dAisP}hjTeQR` z(-gVr#IPV-SjYT?cXT@67C4rXi0H+#W25I%Gz2hHvcSld9b)JB_|zs^Ib`mX-&l@( zECHOJ>3H5u{%E-l@K<7}^3wu_)o7}o(NCAW9VTj|ZEnBaNMfNmbv4L$v0rnzo-V*& zvoLMG&d}j^$a+co^S-Zii!Cs8{pvEqJc!uA`wE$IEo%i7Eb1ilowTJZDJwIO-%Kxy z@v8rkpETk0FtN@+v|5Jt<4?s8&jom)iI%k~r3~2Df|Oj+=Z(!kPdiHF$6GjH)MqCl z!(=yLm7G{8;4oz#aas(#ihjFlHP?W*kcHUoH$Rbp3C^fyn!DVE9&KPv*Zbg|L-I=> zU^4D#6lSbC1=*s3O=CZ~p2xI=C1$#SjJlvIj`@d3yPY0awj zmFuD7M9ukYz&;!aKGxb4Q#Kw@Dm*^~9{1!&u5=L}V-)gISMh!OBxK)4(ionNuIUol zoQ4uG@agm4*%&^!U;M{|^+a`n6Iq?PszL&$?1gNd2Hlcs=XlF3bn5Q~l;7*i=+DLq zw<*+rdozJJUfaCieL?QZ$=5Vd^y?*BBpLGpnF!ly<6c;iH>t%6(z;~p+bX#^!eYG1 zqG2wsxL_hZY!&A>*?SMB2R(#*VAYy!_(u&bLdGoftWV~u^B}Bu$d7EB4{d7Gt(}i6 zGr!qjeU%Y=9b?DvCCRtsLiKOFf$S;$N~#lpzhD#iDYVPrgFRL`1HhCw5Avm~uy)mI zyD0snCh?vVTsR?KF-fiRjli}juS>n+W(Se%XC{WZEFr`bF~-x%Aqlb#vcnBH(ig9C z!q%#STlMUex(p`22Fnz@KFc4DyYCcza~d{FP!8P)+k(TBhm-z#;#v8pg<_I+Or|4k zf%z8W>{Z9BCuK|WLkI>o%#2vWyvja@$f-A~@J>aa$XPdxbJp!dWxN1pW0u8WZZ^(J zMXYMe3WWz-}Tjy%6j%J1+u4B`%@ZcT)ma|(o z#YIGBe(jsCH2xe9!-^U_ec8`E=gJFPoliGit*{o<_qWbHIs{pY(m_!BTBL4{%U&98 z(OxW}f4RR?+((Im77Oigw=)p~X5BwuSXeG3+iHXDa!17A!{mI2ihad=r-pfpC{mvd zvT9)E@=|F+LxK9jr*oSHv7No0S={Ctc}hI@)YS=#D(~3Ypy4CNduM+aGR)Z~-Z`V@ zw37YB0sEE6$D4aK0-@Z)avYFD^fRl@zubn!z4rTj52oi~5?waTv7ChJIQPz>? zqB*+HaX5S$nI5{BI}B{>%pI@(;nl98+TkDgcB9BO5byh{)7ZdoSlO#3d1kY&sPu!8 zXz-VG$WhKT;@9ZrTj3k`)}3DM^~gdXc{l4gS*$ zecPY*O=ithq{X|$-}B0Rrw{CDmpo7zudS*iTfYt&_9dXTK-|AyyIA0&<^E}2bE+tI z>^^50wA;2H-IACm6*q%Zem)A={+o|YR6c7o(6aisswP%omZ%Qk>g5j>wlwTW9!iOwK$ zhLA>n)KHG;PMww84R#Z!>vcDl*v&?mUjv@?VHJ}&lvx;Xux)1AWDSJZB4sBN)F5MB zzq~ZMjYc}K#pIGehBA|@n=WnA9@F{)GF72?$hWuZyHHq~OUjV+Tvg8=fJf->C01{< zs|ftUW#Ij0VdZQSKaP(J+aG@M`L&GRy{>mw)>+v^d4WvYK9i9lfL(`c6ZJVZ#$Oo_ z03J<&un~i10zVzcs={c%wBxIdaMBmc8wK@*9bGY&Gu5NfB*^(4BpzqV`#|kz0m$dN zf`#Xq$rRW7#=-a<0r*@x^A-*H&Eo#^cP*CP9Ez z#ZeZtu1(wX>E`B;J7E59bDI){^App|Dym(}FD56ClS5xT*pnA;c{9mvl{?Amm!HiC z-82=Vu8V}u3imBNhVKbmN|l?eTi*(MQlMnRcj=zjRt#mC+uuMAHP zX%)|g;6YNj#+xoPvOQXKXUL`-azIxfe`XT#pxt-_9i%TKC@cS3y9bf6lxNfDsqI%L@HQ`E2?Y%KTp}_MzchdX!kiV#LNQ)qD7)>J-ieq!67{{z z2H@@*f!pC-s}R$M#Nb;V1R0BEEDU$!1B~)wKmTJ=@5pb7h8Gk;#Ux^inJ*s<0A8W= z*z^@A)aTbRWicuZQwF5XI!kZq8x;cIK4&ANWT`hEiEWbOIE8GSqsVU@dMHDye7otu zH3$lx0s(qE{W`7ck$CW}lGmpABNO%xJ@AvU@0DD#UP7Q4LNP%cP%YGJ)H=)t zJxuuM9OT_N0N#vz1Lgh<`P4fACw7bs|4QJ2g|D>&>y9!DnJ#I`JJG57Y5>AW_jjo0 zSR9omBLS#s5&HF-Z%OLNmyIu<-dwn&l>{U6-Eqs$((LcDH_!p4~|DTgUO1pcx{M%M>$s{TKo@ zIB^iO2y{#3p?i@3vfr6J&&vL+W#GX(AS7Z7oW=7So69i@x7j3f^8|ZzkkO^G0_(mU zOL&`53`8VkU9q{Zv?DA51U7n~V~pIMh&m8J^J0y(Yoaf?qyemTXBIrc?}_&qQf1>v zZAqT+uPfgk>DY)Q(Q(+m)8B|vSe8$8@jW#88V z3;iAkAGN9(uH>29xsoGazL)PvqE==?OK3mHGM1j8x-+dxv=_9M@cnRzwCj@SRq0MK zL<^eRX5V{Z6nm?Rf&)bxsp+$sUC{UKk7Akk|`=>Sbu~1ZAp2W(R%_Mt}W6l)+%7&3?b8QO608u2+Tcy)Q z%jpm?MhBe2w9o$XE)%2L=pe1ubCdq1oi4yQnxxH}Hfi{>QDJY-xbX2I5FzrQl(-B) ztLoQ^7r3zyz{^lg)0Y~hgA07Md<%@b=3XqSncAf&I$lhht~t3U>!X@s@4N*deS&Lo zhkZb4Wk8&Ju?N<=48GpR7T8Z~<#&K`mjt<%mxXBV(f^$jJF9BcvbW~+RGHq))&2k2 zAhGtKRTbt>q(8kRp4+K98bzONk&r0QH#M_#{)9A=$~x`vgs{eEF)Wc~p%D#X%BM*vOIHoVN3RGvE1Eym6xWQRE z&d}i7MoOUW%0y#m;Jp)HhfM@($e>VJOLg31q&a(@=q-Ov%t${l+BO1FG1{fofTAW} zlg=n}l)tk7h$H$pjUTPM{%x;Fcy>(NRngzysBV2G`1SDx8nFuDq29S#QoD(H`GnVC7JRo>@zN9tkwp?bwMqLl64Z@;x5Q`K^L z{?oagZ0ib_AnH+Lt-sC!==1~tvdH+(RJ^rUt``U;xW;_=SI&eAp+@&@wSOB|!l!W; z32?Y1JI%ZnvVB-+Lre^M;T5S21eI`45vyA-+)_L%a}70^<#=)dBk}PG|C{6ccZvoo zOEl7{YkVqWwrkiF8;uL3VMrH5YC+jQ92e9p9GDvC*-aI$vIcODQS)B2^HM-u32 zU4f~UwB2Pk#qAHKHO!LkLrfL}Rs&Z}oJaU_fiHCSe!6xSeWqHoUCSMm-uv$qq^<$7 z$J$vwsuEOojwFP1+BMd^q(V^Zn~5X_Vy`APzT`j~_%+M%7pENKou{2c#_XeG8K%=<^bm8hK-(xvau&B2wkd@b!<`un$&M!7a!fB9NO}l~%iJF*Y z8Z~_a)D6`QqBSSo%RFf(_w8f`ntJfk9Gin^nV2c3PUm5jlK94e<~-+mx%zMK*o5{n zn@Iod@RFver(F$R8KEDvQy6K;Rz;+I5~0HzuGV?kfiPuV=RCA_he~KmDkJqxh zRLi$0PFNjNPnf}EIy?HUw38RLG8F=n#oEI z9C%x_sjy2p!c{@^n4&wXVZujHUh2g(#4(4TJ&DLl&Ip?dz@|yP@D!ZM%7NI|UX`m( zWki_ow3J2%TGul-J3=n=7Yi&$s(*5yOX^h-(o|6$#MKXa6GCmT&>tS~%86E+NL0`D z4ru6_j|mw&LV`$9>AekrYW)s&<@b~AR37BnacaqISTDax0ezJ}Catq?F?Eo4OiLTo z{rR9w&HflvE_BQb&z&G`6tVfF;^XZ)?X=dxhKsoyD(Id4^s92;bHlqs+Gbnn5UW;} zc55CaIm_L}a)6lo#QrcZYxFr2E!XM<3aJ)1zz!F*Fca_#nTN>UEa|NLqFT2&ckFoz z)P-V0v`yn=EX_Dc5453{PnT3L+UOb&z<7pl-xY&a4kU-Y^GW`@~c*#3kBUJ0_zE z*3!__Oqu+Y>afY8KR(*c=s1$sh)g zj9KLp!|Yf(Z7!KjK2U?^J0qT{5bA1MFXwoq#i$Ks+bM}41Gb13Y$&;F`LflFP;n^J zouLRoyg8ZWUeY=z{42jIj8~;z5;)_h=pmSBk78DkcA~%CuMNC4D2J$|&PE6HuwEII zRA;3lcHq!_kcn~))yAJ4!}MP2HqKDww>BK)+>NS}vh*M7#(q(4qWOBSfcn9TT6a@= zmV1RS(;(f^nJ7WGuv-_n0}(~YM%|K+PlYv;d=0Ux!x3#t~af?7H{L* zs=f)!deOmYnLbQq8n3`h`Wh`ki-z@U#B9`;L)K$seMeyA5(MGU~ z9Er7A2@*(n%D)|H?Q?6krEO6e4s>LLQ2ILhROiPEV!%k_MW`F-1`5Ue$lH=$pI3`; z?m=YR08+&}U7C0U^7u8$RerubKd;{a^hUFHn_1jAxM@&065#x)b2J}kdGUBFaH!PEii-wn)ReBvYIrCAZ z1)bvY;n0dN1N)>$hHc^*u9Dmy0ND#dX#oz zElzETn)l{sZ%vcToq%ct^;uWf6j?n%qF2`&H3E+q1tkpv_*tWn^44CVJvC-}!#M>f&J>xF(dfIO01@Yr+T@aWi{gnRb@LPjMUX5TN>%RFC%kX>En5D3eFcJCWa z_hGZvR#_y7B0F|rS9h{n?}7|cHnb10Ru2uj8os`aG=qpQ+tbCN^30Yg>mt2XNel-B zM-!ID1Bpj&i2bXrM(9#Qd5xaH&Q-v1ttpug&&5|=Ymo>GNn1hX@MBusGf|$M&Jf!l zyI)#u;geC5?Yj?vav;0VJ2Zb-yJ-h9I`dt4 zztPMYZdDKX^@3u!UoYucQG8m&GS4l@wxPUc>=6Rm*T6-QCpKRCCqL}BbO8L%c`CIP z`w3lexkOP^Y161Wv<_0jw;YAQXaq_BO;Jp(9>v00dyT`xt0t!@l(j3dIm?U6nEQS) z3FLWOUr-_Jw>U-J30e)TUAy)5MzR`j#@hu?1@l5K>F&aLedY>J_dCXD(FGPQ6-%(f z$=qfYyyESlMnmHb9+1LhG#>672U;;lZGqsxG$J8xS?Bfr&ilfDXncF~GsD3$En$;Z z2Zy<$H}Y*khw5iCog-{6Rz4ycf^`gN2>}s&<{eZmw}d1+V@7eo^xTf_8*39QJ5|5j zt^H(eW*8+;9Tl?owA#8y((GCM($yl%<~MoyMFT3s6k%M156uok%=}yVAYtKBy?LMaBQgKJ=c=A%21V?Zd7}NAUerlWeN^FQiICR=VQc*SbpEu97V_wz zf3fw1C48n!R66X0ztEcQp{AR>My_wYahujjLIn(c%4WOrZ1#%Y?0diy)#E3Cp2#dLa2o=5&AKA3`#1EWxBOc$V5Vy%mL~ODXYOtVP&7?*h#aZk!N0k!o^9 zZWUCoE?UZhuR4|~Jo_@ji`AR$g@Djur+N>^)-tmHx(0dI0XCem*J(8?Zel*k1!oyE8~i|f%@V{VhI=psJ!ZRRyl;mpAFxOb zDsPjoySBzzTczShPgQa~53L!0@Ga|5&Tk3a`qK`Q5(~N0%c@9knVgDjzK&Mt;ISbY z4}s&-IW~W$Q<}x&YG{x%)E1q%*0mC+IBBiEJC^@GcIbz7Sl@iua5Ku|l>4qkO#wvS zfI$H{R9nWyME7OV`KI?w4b1V_5VaB`F~b-eEjz zqP$6n3zVhGHMi);E|gQScS}-IgYye3^Mt%A$?iIxvnHxC4}u1m;K>$>1BuGw%Vi(I z;{jT+|58F^w&Y2wu>tw4aw`DgkP53n1X{Uex~o+QDM?MaR2}a!LeIt00VF+^_D)u= zZnpVA{&X2dX*J#+&Be`rwsQe0Di58)$U@LEylf??ukwIaiWY2)-}*}>XZItB@HfN_ z3Ol(IhFLyEH=1v6b?|FJp;C&F*!I=QuvHhuAdkwn>KK!5tg!OhfSfoYL-U%RLyxeo zz7peeIjBG?)#*8}+^W!{C%43!Jd;6?>o}OFq70^Y7|Ql_ekkrpzgGbnv8z=F1a_@D z11uMI#IS3&on`5|Zw-zQY}|DzD(8yL3=;0pORTq-@J%xU492qfwE<;Lx|hJvi)MF@ zDq;fX#PdcC4sP1rI$cCY<9`1Jby+H!_E?vT?BuDkoDnv-F^a()2YtX<{M2NMVj_c0 zDn?g$zo=eBV}H|Og-_WFE=sHU1>h>l-a4IHQV7i8#&d(kDlzluC$PCoKqL410WH}x znV?n->o+`eU+r`4=%JRxxFAjG<(vN)$Ni-pcUomroQ2)iOroLQNJgVhZBvt1^~gh- zmq|!H1x%I~+=j_Dp$9GmCDUjWPm}9eb;L%EGTDuZf(rc30KADvfhC~m@`MxG+%d%& z2TdXp0r!4^)TzN55+YBF%P95<<3Wk$`0#PlovMy`;Y&ulUI>e&SQiQ(_-aS=rwSG$ z2!nD>Y0FL8gN$(>JUQ!MR;w6UW)24pLS9YjIedixLvps`qRPff<4=X4wXhlfIQDbn z6F~RH(HFXniif$K0nw_RSPPG>=any1T?{TwY6EnU2)%FY_NWs180SIb)I;kk)Jpqc zWA*ULgo=oxG-b(jdmU$FQ5&SZlRmKq%KPq6gc9hTF&+uL8xF7GS*K)5QiP`mfc)pt z^OYS(tU}Q=kmYrO<$RK z!g(m%rl%RgV^$SACa141WapDW-?nj6QVix1ltxXrGApRD1EH=uhHq<44AnB_LwfCS zEt#q|0cmKW2~7UMhDYuglL?h4jR`4gDWm=|l!nP271U`KP-xw>RrSj7>29BdT0qg= z(KqWSI8CE5I(Yd%RC`1_w6Z93Tv*A#irG`D^&CE(izUj!&nA>SQQY;u{ejJ^M%;YL z=#>^%3CB{MndtCT;;o_%C!H|<57tuysCqo@&vPRB?+64GA?>~Z@Gy;7NP2mV^852w zOa%5|fOSOEucxw*?J%ysVv;3dI$=XDBC(omhhoe9{wyPra=s$-d^RF+$TJh~(ytK4 zZKFel^&2`uw;r@`dbgx(-cuS5(WveBIb zo>-SfnPaANUk7#!^s8zj?oImZ&3zNL+Run@Y^FHa?3>>vUwxf=&M)$KQ?Zl9z?o+K zx+b+I;&Mg%1K}tL>8a`=;qwX`@z^J|clgMaF3~A+y6hT=C)N}+kNI={f?l)wvsNe> zaB}a2?dzNUZKp##?;JMQ-x{kZ0VD+P_lz*SK#ObTzi|!=3o-);wN}AVP;!W-FLwR$bsfiZ!KT=Q0UmxOPeT@bNGbc2Q$@F$HFgtbC?=dlp(uq zcvQN6QtrRPx5z+B{Tmt@5z*r)uR2Lwzilr%w7Lau_iX7jN5g8RQ**wZHbG&zTLxqd zQ(kIvi@I#%?`zLC3b6_Pn+4l0E9NxrH+k(o_bD)PJ9Ox|)c3{C_60udyZ`%hT^PrF*t}1VM=F-}&9jU69BaTCn^SxL6?6W@W?Kj7*#w;+0{KAC3imR670d({t`-^ix1K6ow z`Wm#giv z*VQ~xM4@_h5rpB8j@BL$50gOFGP4Ds#1x(HTGgnCOy5hldlqO}H?H!aad3ym^y}KA zBUcEDPIXaFg@5T-PVuUBjX|NPL8-`opx0$^ut0U;-p3vsbVgxN|70pwlOQ zhdv9AP9HX2gnq`$Q+^AD&a+V7$MO(pcQAO+$X zmO<&I^twLic-QaYe8KC=J33b9R4xpE?`Z)jH1LK7+i&PF0mWLw!|LDOnd~&yr#ma4 zEKyh4pqWf+m5>NqnLX1MdtP;Nz)Q_cW$HGMZ5bK@7(z1wDE8^+Uv+5v$|1FCFO1Cv zPgzCxRQ0b}tQy?=Jd=3Yr&MQUWT#_LVzB+JQRyIn$syONa1Zu75&Y{2$6U!Ru63v8 za~cY$qsG4d?GQT}Gg3fnzpot2C6!#>~bI~J+C-(Enif>GxL4Vv3^|4^mZh6QbqJ%eg-O1|Q*Gj4Q!A~PPH-Nx!q#|xb9|c^ z;d4;yCLiWtcQeU(lVnE+W7a@vrHrVJx*}4Vz8JWFfo5Xl+hN@Ey03M-YpADCt`E%&Xi?GO{hZ*(4m@-d6`E0rFtxMsrlyG*II#hE8fwEu~{;$Q&=< zFEiS6nur{ejD=-Jaq+hLajiP$kiwzc!)-=DsvInuoxaAlUo({}|8(}}M<0S_fSi}4 zHkoQtPjJ~G)$bQzH?BPgnCB98W_fpT#I1>jZ;e7m1rWy^#gpX|dr;@+8K?vL@D z>LjzC-7}!jE;0QkdPZleKltcUe@z*ktZ1w=xAi04yvi3-nf;^jw?}T=;WPm|<~{Fz zd)iUVnR4s)0lC3SLX}E!lk99Xqo}SZnvj(kT6NpJIjHCc?Fl9*&Z-wNvV?A$5OTjf zM1vaW+eQI_7`@pky(Yc!(CA@aa$0<70_`y7k~XN9%gPv*1OC-D$$={nx2FCu^{|=2 zc304z+q@Oj-jTvXdB7<}?=y?U_M(ZClFTTl348*Q6$rs=@Iy z{F$Bo0YyX{YNlUET71e!m+`A#v0Nclw#{E{O*MKUbmhe(@jPhqBUt2p$7FrXM6i>% zlXmgzcU##Y3ZFQ!7yvZN!P=Y@M{c1aVYY&LB6gQ z(x^SeP_|qHUHT4e@)NgGY|79`r%w@S(gwSl8kZ&)y@k?>9&@|9mSh@;(cEz6pH6N6 zllc3;qZ-4(nJm9G(XdAij~q7>$aL^QJmkh#)n~4%n6pe79-)Tzlq`7){?#sUN@R81-*FxCWjY=c@P5vdr z@Ql?WZixtI8#N{-$gD(*5 zkvVJrR3#OtJx4;^HMw4-wOCpV+tHbNtOE8{9JE;>1WbxEx3er>geqXev$%J6GdYC? z&&~t5;&V}pGswaqKH)MbOjt8en~CGz{XqfH9DZ=XYwA+7rQq=dE3BBy3>qlg@*+1o zrNOL;JPuS1&_WcLF0eLTPBdETNPoKDKi=F#RRId?75u}qzzY$(#x;!Q)9T@eV<)-M z>3b3Q`RvR3c%h=o0XM%FFS|HnqDPuKcoqE^M#hK0syGmR4g2``A&NY4UhE{bYEFS# zfsE$LQ{=|J>l)n)N-pyG`3>p9FI>Yoo$i=)K8Qb{HI)6tl%rurE5-PM@h1Dd!m(DM zie@+%a-&stS;5Ud&6wj^S&8P|4has|;LXZCmGIZ`tWu^wXu*&a|Cm|QuMf?MA58_~ z0+M2js7dB8rrmQCHEJuA$;sqwjP#f{o+ANhKCRGp&T!*fp>tkUHiSl`V0s&R&?mBS z6>9Gsn=KJebdQc@3LO9yFG20MfLknNMvM@0YR~2NSs|ALoi{UD_I3o%%G(ag>RoND zR(_C^%$G0yaM*9VYnxn^sIZK|c1iM4#WLeI@1NiWeV+SdYIeYN$;y|vyYjOmHe@}y zR&;}Bm7!|YY&&I<6aX|e%;)dNLX4f{2qhU;Z0bTs4^VSPUr7MwnXzQ8VTYYfw=k{y zYQGItUWM`2u6iEAswHw`5<5&@C# zPKDB|>Vvex9C50{(1f1IXnW9P)uYB)KvQfw;T;3!sTOJBEttv7FP6hQ2jzG~)mHCY z7)+LtrF5uKlrl?*!fCk4^GFFR8}KDOwj56HT5G&INH{gdc>@;cz&<_rr$kO|xoDNf zo-)lgd4QJOfP|d|x7%M;)xh*50d8LFmiA;{5-~|7Gd^fnItE|IEDQ!*SOaE zfA(bM`rDe`Er(+7mQqSr zp_wD~Ek3zl%(sS%`So1&dz;+=N`@;hKf%NdN?ZJIq)wwUw*0Kuy6KVby`=Nc5comE zuH+3J-?hl^ED;__jgKj4sT+c3u4*k4{{Qw$@D7Ae|&LvjGkXSQxZHpk0S@{q>Saw>PcMc z!YLQxT3VHK9l5Xw@ z9@az%j0%_06HZrI7N0~fca*?x8O}B>R=1;->>x48F+@;ZJR&)HLwk)OqBL#(mX)BO zbkaA_IW$vEw9s;)VIR;&B zD5cru=pz0d0T5t2ys=8z$E_l)caX8S_|O!Z(b*B$Vux14vm9m42bjH~?@)Esq%qb^ z+7hWT8$#g5mZaXhLxEAJkl1Y!09UXrS{rJ$a7uV^ZYV8bLmlES#S1YU_UX)K(w4Yx zj(?k<&SWZ*u2u#%De1v4$tcH(UWm!UH_>W&ZY&i{6W{=d>NUY-nk^qum$7H1xyani zJ~!;WfELFIgXYVEd#mKIQT5kk<+uD18&&UGQzZ_Rq@mlIPBF&qp14;5Xhw=uS}RSr zC>P35VG!xmF0D+TbW-TRx?#uNH|O_&QExFik8xf*VPx5CxjtRM62t%1R92qak-}QR zcvp;yQ5@~S(A2p-V#k{Nbould6=L0NtE{_7bL)J02wAkq!UjK>bvuxD614wQ9q}sJ zPmJ;Bs;u#m6$GQnirrwKp+T3wl&!;eniw;l7K||p7`&qREh;JGl2KHV zaNXtbbm6fuXI#g)<3qf zLboNDh#Ed|bWf6_3woxCiVjUPc_Q~<3@T4*FJG@jw6S#$bqIfRTTXDSvR)Z@2*=m( zX6nfEFH!a#D`37x+ce!9l`^d`S}t}D%-&jDkHGtpz3qrp;eOrEjs92L+arh8bZ2K4 zD~|-FqRvD}-wZR*dqI4$6}$+N{>fC2xs+>Gi%&V(XaaY;h<%6OWe-KiBcmrd5eo{O zyNzyCpe)%DF`gL+)s)RM*1!WaK8SuP)GK%2UhH{=jE~io%1EU(8MRXGl zQl5l!B5tO4gaENgU#4h1ytOd zF`>)%8jYdQ8w+E(V;}o-(#A>k!RUV;0kl`#Hd_rwH{wIa8d9n zCVwW*Ybji~HJ7G5Tk!&aABG3o$B-;}=1sxZ6E zpyNI0W_pE94E9{}8CnG2suHwz@ZCZ#x<0wadfWX#pJpluet~CvH=pW#r2k-3fgvDm za1M9j+R!BL_5qg(7GNdRZ&@}wM*OzJ{E5PaEQmEdGdO`jzrRHl8E|Z{tWj*|pB$Cp z49AadroCZxb zV6Cz#1IFQ(7^ZV48axCBXu7x?ANwT%IRI2n zsOa=}j@%A9gjg`!Ce+6gFG+;n@dGCkEPAADw3G&WE8eF|Oy-+!!gJ{4iHcs?{d7eai0Bw`_vm6y3gt78~cEAJnC=c{Z>(zaN zQR7jJ2O@UWcF&yZ5Cy}YP zoSJeJL}VYIl-8cbsF!@3%1*bFjy3X~h9xuYI9_W?_!HW`Mk(HSZmq&j%`ghXjvTwB zwvksm?|l7!@BJupqiA33RRFQBE;5)#Vc8&SAf|DVs_Ch`JIGeRCYPaYhPn z_){fB#ZoAH(xov-!M6c}ZFY;LGcT8eIte`x2TqdD3`$_f%2p53<{_0~UErsA*zV4T z9Ez`J9jCh&?5@KZVwpQ4Q$XS~4 z;d$z0C&V}v+!;k+G9|NmivgqWMgm8%sC^w5o(Kk1;$}H_+(OxhfYtPsF=?%){$yq{ z!N4OU2uFZ_FsD1hH^mAV!Npav@%MZIqT)R_HM#2!1kPgR9w&_iW4`Vm;{^rmcziRx ztjsG{XP-1&p7dDGFDBN)MI~!M;bA!to^TqUpuxE=WX1Lwv>wqLh{5R}Ws0YRat|Z` zLe>pgPbJqDUfJv%_8vr8OMUtc_0Z2T?7@$sVfgzfNVL1{w(uUhDd z%eQ&0)!)xofauu!W@2>hihEkh=ck_l7x@Kqe|T2*0Lr#cB5n>`b0@bD$p?xq;Nu0&-x_A+D-~bF)GochZxSOlK`G`D(j2ySi5T8At$vH>x$G8WCm;m2CGyM|{Ir+)6!0mp}57HsztY!VJf7=MHf>(8~q`t@GYR`irA zx(Ef`D|!OmRrTX?_anAQ2H6ufV8MWUV8xev+jgk4VLJ@&wZL@se|o;)lk@u@h`GeD ze)DcfWi~PLoIv^gc4p(fOh><}1LfWSi?=rqhw^X##tW6m7TK3jBzwfzWlfgSA|lI- zHR~8l!bsU^6tWHyQCTOl@5=~duW9W2z8m}cd(Ztlp6_#izJEXWeH`y`#Xt%-9zRU_^cMVC5QNrL}WI*Z=;HiQz|DeU*QOhnfqm3HqvNSODPCdj^BM-EePT{F4>6;13}TspNQ!G zbQkDiR28mwb?=>K)$P9u;qg+d?zpWl(rLxdu{sg79;UO8M`2a@zV{u>@AFMEZ7uzE zsoua=o^en(yG61jZ~>h}%OKi`)FN|$gU@PYlwQ|5e^47ItQ)J$I&|2Fl^C*K0+ZJ7!8dl0eU zMVHQJMY1-2CnZiHh33*eJANV4GvS4=?)Y_VD*_*TWfj-UQFCw0iAQvo5mn>g8khJN zrbvPak}sH@pg46MUgwwY;#&x0bL30YcWOCKfhIJsZf@?`j79u*iaJ}ue(ji;NF40C z*5jLIGV_-HY0_}qobql3x#Km1A?^fn@u;S^eP-|49>C+XO*a;>?>C=OEdmOQ1j43t zo<_;jz*kvFWba2`-Gi~h>jDX^i|09<9{gMj4F854C+GP( zx|J=v-E7Ioc)tS)Bq6}Wdh-#5lqBJZqr(fh-2Ut?g4wthb(($Ewl3Z=jtm8cLH&Q3 z_T|%^`fJuocl%KrWeIlGGtXq_hLQO`=%tT|7AK{Jj}|JYYw<3UdQmdFdml=ea0(<> z$qKkbdJ=KS!6}<-hl^zf4#?70E$=GMDqoe3AGp+sXJ*>+=~a>w%L>G62$j{O{x7w% z{`Rv7yn{u~k!@1qi>jY093=^J8zcn3(#^`-=g?=g8=>-|>LcLiQ`%0-70$aWuN=-= ztEl`3R5+^R7QjS$+|igR#P{Id_g#RsJ`p05&TW$+rD!}YeAy!Won)R=6}re#b@4F~ zdU;P2;J|OG{#g554$6iYlzpkwcmE^63)@M(_HHCALWh0OnO~pP*uAZ^$vM4IRS@l_ zma0+iag?n>N{hGmpUvn)sJ_#`X&AdnsW2ypLCj zQQM@rC|#W^2}2}F zazN*+{h_ED+oKuR6PqKCR&)IQz}knxBTtFS?{_2n9D#^{3qj|^vvdku!%gLAXU{+EcEdnezc0^a`H2pXI6-Q-(Zv${bs580!x2xUo!QnlS4 zUW&Hp-u_t%0szu$R1VSpD1<@b_RD2r5`NFDX|8y5ZsTR0E%U@rHmSm-k43eqqe%Q z<|>zTr980y@eMD{v?IFlT}oVCPe`*TI|ec-YEi40J17yNv~!1Lo@G{#wM+TXsi~W; zKzyFOPNj&~3PJ76mO=B)yylf$Y2~*^IkQpE>u~FS)4x98W$+l7w(xpLYHVfsc%&(u zE(KACJRY7xPXQylrSj2w6Z&w1=HSiGpnc{+-z3?v!i}ZjiemkUa!$`CmnEn7d0!?@ z^%~vVU+JfB)`=o9^}c7|hRs(LJQuCU6H07b@h=nX$_1(p zRbMSucFGJ{+i3E1qviV7Rq~_*_rf~17y4VBN_w?SbYf2I;;sm_1e-=4ecdOt%t|>h z=m|3o`_0aGOO3`(_|ZByPLI?D1RN4Ogrw7(Dw>aI-X8L3zD%!XSQ2J>`Sd|RKt5%w zdWPcnAp{|acVUDB+rOQB=c$nWo>)VhdHQ$^CqhkUzlHJ@gNjEN`f;7H4yALDB>FM-O}fku+7}{Ov))ME z`JPw(7W6UFOe5Cq7y5B2k1UgP0m@myBdkKh(`Tfi zI^9DT^%10dG|L-`eI!0q2{_>M$X-U@KHPxhh#ei(vqnm8O_d|ipC;`Gyf@k8^@IIy zFwOO~qGnQcF_kREE2%~(4BM49(#NFDdSr8)KeT1M-jQF_%TLwVW&V!l+K$pucg z*T)mnzPLn5JY2G?KNkDi!pjEDPY6**;Q7%XLLJ>Rw@%DwsH(&Xk`^y!CQ1|IpB(o&*PA=uqRkx9^hM9SjFTKVCFC-@#o8bzYxTQs1 zCo#L5EkB@#4|nbra3N=k%CZ==1!+n(EL5WuVZOI1?Cquae8S#eKSwBa=*ONEoxRGr z1@b}%VD@Et?U~<4wCy91*psPQ2AQ8OBb96#B}Z;R9(j=9Wu~8|D5vYBEZn#lnN?%Y z-piA~GDTfmyYiu?T*bxD>S}`6!d-<}tXg8okA4DgqsJ<{!UOxzH#)Hb`gsulJ=~Yv zuly?$a~Ec1T@=*?M`S| zC9cBWcG_vfMo8g{E3OT1&arVU10?BjhK%tZKHv1Ov?Cr@^5Rc>!4>DB(x0XKB~EGz zFV5F5#$JOLRUqcF59)>i)N4QY)wPbAXuU$YR9~%iqd4)kgn$>Z#~^v<_~};>EOZY= z*Re?q>$FP?-J;Lf_&-?ypHWEm(_stsk>mB6NMl<_tJ(1Sd}01R_J=M@@rO|Vxyj9d zQ0d07En!$=fZ!giY36AxY9iTSsBgzafAUl5KkCB2*NFeb&-KZwpZZ!R@f2TQz~srU z%*>UKfXER3zZE|O6Af<4>P8LwpmMy@w@kVESd*W*oeCDu6Dp#lrP z)fG$!@I!Pfsmknw{5kj4R+r|v< zXKHqV(s|lCQ0ggKX{x8>_gSM1@&`c`F=W+88%>^3Rw7DW;_AGmJs2S$7JgYznO1vsNJs=jWXCt_G>%AS(OY04Nn1o9IbK(+q8S7|DbI%Sqa-?0 zWV>H+SJgYL14xx+spMr}md-2?Zpr|F*GJ^Vml5@nr5_z)#i(Jn*i7wc8B(ai;>PUF zh~m+Wsn!%WDO=;5Zi$Un#hI(g-hkt@Lm%7{`)gvyl@P3SD+D@qUHIV#7R-KA;^w(C zL>o5zhjObyKU6qz=J`Autslcwp#=)tc})m0;{V%v{83i?np_?$zpMCCY{my&-W)M`SWQs4apBmLNtV*7D!XN zeYt2QM=(({rQWw(I2yL{JY$x^cIOCM$BGS>`lKBN&r)~JxG;N8`J{;ceBEk@~UBZVJ1&BEc5hJ<$vN#q|6z_sMNvxLs*VffRe3&@-xb)Lz1C zm4XPY;4F4%Sc^Y^jdjwu(RUm+_b&;M>pxF!ZYQeXM1&037f#f z>Y3vcohN9O9_m$}Xv{e!vxDq-$~tL_sfa1`-`}K8#~1~Xz1Uv*OP6U=kW@7xdj~_5 z^Sd9kBCI7M_6Wly7$@a2T#ioEfx;y>2GPyAt`f{@hc4d^1dYs}l(YC=Xsz}9uJ-)N zg?~G;|L5%f&;1a%$*`xsACn;9IsdCby5eTS?T@N`FC*lJbUP>+5_>Xk><80QKS%0# zx^;KBH}`G;+{ReKVg7Od^}Cg8X*qIO&bAnro#laWkw!lTRcbEsHSm1+1p75AMpU3K zB1Dagt|n{F$Hm^=veDeKD1ZU>6xq*`v61OAowX^ndvDz?GOU_x}-Rn~B1CMB* z7<}M$qM#m+{88SG9ZKd}&>qMUppF`n{yZr#%$5V&%wvgennfg#_h_b0O>X(_txw>s z_UZ%4JGU145u80CCXZaPO#t|Q5pszQ+T8^C=u-nmC^m{3H>awF?385EP?fD7N^4U< z28|@;yP=(+g2ZMsvQCqiJdTCwe-yMWaPLEJaDOCczK@U+U~1q#=>u5d)} zZ|V`F+zVl_ zbHRl_qy0R4r2cVz_i8RS*G2}c$v=6#FIlCQ{DYwICL*26cmT-aJ&uigJLNY0QWl+5@tPj&V24J5~ zfalwtzr<>}#Fg8z1{ZfeWKgGGVF8DnENOnv9t3Kg%!`_lMX~-MoiGW4iR}?H;B2Pp zFWM$jpNq3k8B;zTzW+20fv2aao9#?_I_vb66ylN?TdNt#oDHAC%I$U_$g6nw`RsY7 z3`TKdJza+891rtc+xt<*&ko+m?SLd9JMMmz+wf))sMAT1FOW9bQslvc;7}c}x|1eh zvOi>|BOygF-LEgAB^4;NjLL5<=SYYz1}lBPpRR1XKHgvp%mj3qafj@OVm@miH!C|& z4gQ!fU0^Z|l$Fva2O%ZLa_1jWV52-eBs=IZwlWO(2uz z=!hPrd1~^KJJ;K0Ajrhjt_#g(B-HDYX06iIX1V>Y=oAKj(N{xwhRK%vs&oA9zgt;V zmB|(!%Wlqmvg3Q8MwaoY`G++Z;u8y^+*ofEVt0v4B*qTsz>i90;G=2+n7JdD%+&Np zp03;9a!(NsZkO&VhdE3rvW36WvA0otC+_7Lg@da2HPZHXq;FX4El(>It3Fd5ppv~ZT%a-SE( zrT1KXHNX6E4l+QajzNTbjY~6Mz;7Kl(W!89%1U_S(@G{-Bjj>Uz%ADKSu=9E zQZ?ylcyN5vZNDD%!%a~)CDHr7(srEBTFow%k>~HPhPGSty|$5}rA1Ij$|5+5+?Jxp zj18&PnS8tW4V)yHEKxZszXGR?1dPVb*0yEv#;&OopTR4_(&ZL!$-`WOg#xKB^SYz)65w@$z$UicUcB55s#ES^m0`cMnt^SXTwo#9g zcM`t)&G7$Y1pKIPsedqPb9yDj?UYGb+@tg4T*hZ`BzCT@nfWzO79|AxUYc|TY`9o5 z$-;{WdU=cPE#u}*>%Y7g4A*ggLYjc1IL#*^>Y70;`K3Ez2Sv+YLCC3`% zJDyrN`K1T+cEI~DzwYCGR?R1Pp65Rmg=Ps+k%Kh1CzSf!I#gKHbG-F_2yPx-F4ZA{1B zFLl&{Lf7t;7nEybPVFk}PCisjcZ;S4^SR}*Oq|ZMN|EZ)LBRWT*Fj>I&j*$Q|x+v8z#7_tIYc@~1mCh@0A;D?W3G%;E{%-Jj=7=C65}r^vWJT}0 zio?;k0%3ctmGiRzX0soTs_%V$mi%%mBWdiUY9q0O%jDbI|-^$`{ zzVGhp`OrTg*>0f6S}#Cv5<8|A^*e+T_2K$ zC}S#KzaIW{=dDvpD#9oMm3hdJ?!Gti>yI2!e@Qid%k7IIvRnBuufaqV6~RC~3_cYO z$RV^#@_N2M5niG{1cIbrl@@F)zh$xD|I2P4ktW+)Php@-lXHN_@yKT$gPZP0^JJL% z03_XjG0~B<8~`hH0Ahw+TF(#(=LT5|h!Z~}Ik?%RCXRUP*8Rsdx)XE7Bw9(}U+VlJ ztoxmu_qEz3YC&dgWCjtIP^b{%99ARye0V(!VZ*6hMPJ%GLKmH(4jm2PrS2n*S6;)R z3v7>Et2aXS!9Vkg9a`UcV|)`HCPXktM!xesP`^W=q55yHPX~-)EANJpnR)sA$0ZK^ z%gR`mY^(bbkjFQ=c7UtP*!Q(Coq~ROx_fsczb|8eYa3#Wc5$-GKfB6Hd*`DAKn0J( zj-L;f#D&t>HU?eX3H8qd4T~*MVoQ@s+RxzN70d2`--g;rPtAQ=2F=Y<0}5f1rEOsJ z|7|Jj;j6vOK_DZIeU71xJ5y=B+(Ewd*Mym%zKhV7YWiPlmpbVP_Q$o&_+LsE&Fi2o zmH-~x{3~wWQ{gf}Dx02O;LB-6rV&97hPsq3uIRG`5~<|7Q^NO-GUB5w8d#RIALSS% zDXR@fpO}`|8yevYQcpU2P9{}|-BzrFPm5Icj#d2x`DTY~=F@?bU}R9YZ%31z!M%F9v!22pAz{>6G_AS*2c; zz|s#jYe~QOeZ#jfQ6&yz*+6!vUX9vVb1IsSd~eDMMk5E1ooj2_hciE1O9n7}ITCr$#8Q4orpl~ameIG0ZrB7F)4x@2yqc^4J2D#^@ zF<4ZS);o5Ss%)Mz0^&ga8%@jX6-MeNI&taF7>T3| z`I(=%zl;y@lbHZd*5BM2*Bpmdau{z(cj(kanVBQj#OV?f@uZNA={MDX_qdXxyes0; zIX`!E;2x)hkw(}|B!7ormq`C_eh-cC%-U-?p%C+ChWxeh%Xg%jlOn!dumSE686%tn zC?35pLTJg=TMNVtaRXQLpw(vVD9~_7<)poOVQ!ZManT67l#}DYS&rQ5)wZ2z48}_q z3sc*nDeGuBAw2-1rd#zI1;B*kpYI>T-#*f9E^zDe1;9c|!Skx*Z2c75G{h}X9W(?R zFttL>g2F_q@?2hCSbDJ1j_!Ld*|b*aF#(_@F6O*hJUR@L zqD_v~s*UXlMOJv{!H?N4CgD_OLC4x#(7h|a%%e5`aXPg#g!w;et&PkzYw389K`8Ub z6+Cdl>&A;? z7ibr&T80K6(~nReUb+LqlD{U_RNQ%c-YCmqq3=u5kIhs|-%E24hhun~U+ejxnuc@j z4d+erM#wm>%SZ){_m}j3Oz^Nq(())Pc4VuW&Ei0{(F3T7`?7?NPs?h*ENMFto`2Q^ zhky2h<1$gw%(3DG1lQzSCgw6BK2$t)vM8dJ$hjNZ^OzMB7ypz(75qd4MC+@lzUtMk zcj73Vb30(0%55cf=xY&b@VJJ`*DHwn*JqRXFp?yN&Q1VTN4#jqu=q~U1`+(h1Ee5p zJMLHWya*E73?j0-BPRFvSAa%v7WmLR9bJi2f~oule*t(PV%oPk)6oftcxbj>QcN6f z)O(Fa_Hq`LJqj{c|mQGsHh3#5Z~d9oV&WLnug)nIinU7$Rx@&OQc9_0{F>^i8y*$3I=-|D%Ga8>cRQwfKvV;S!&_R8b8(|c>d z967Y-gD-eK1Xgp2;`fWd1B)_dK$$lo1Me4_*SH^u$6wf`FK@hf%Ruzl4JX-}2vXj# zX24c|;=IHe|4Km+V?y`TB4~ddjTCDZ!sW#M6*kH%>dI}Bmo*ig^adxI-9@e$VHUe& z*P8A4i>V4E!`du}IFuk|1sk~^cpYpl;Mov(^0hbc@e3L`tYr>ryQ?GlneHlL2CC}# zE%=Rlp|SRyXL4ww^eHyLnll|DI7O04trI@UGjWusd)4Gu$4E36Y$|jo$eB-+>^1Te z3aEn;1BBP)puQmPtC~&eRf*?gC0iV;@X4HDW0FU@vOf-V5KgJ={AsMYk?A1_4IYw) zjMGq)b2fx_u&LyVXJ_^CWTg0yA33623SK49WD~lF=0#qO*DgWyY5)3Ch&64X2xGvV zKrhf;VM}9mOvgprovxxH=u$2)t8ury;U(qRIV%pcz8;@jOMX#rBYC)!a>CpV(2!om zgZWG^f71GtCi|o%H}ePG(o^p*HOge^v&cWRa|tzQASM1T?TtN&yUqNemo)B-+*9QH z^x8OwXMU_?o7g|25dALnVZw((KPAS0Ht1g=WXo5Y=!a;-Dg6>Zo^LN>jkU0baC+v=s=S#x`hJ%zn7k z0{rlKtVbZlAce>}WNH%%CXAV7Q5abLMm>~J$I?3M0cPFgSOa+>-Ir1R>wq!ZwE5^0 zZ_UHs-NXGsXFAnVycxA{f#MxK$L3NyBBOM(yvzfh<?RCMW$zeyc-eg*?|0X}{A-rUJc!mmKt2A|pF9q?hiVuQd2a-~69B zhyMLne5VOCD=hhwz4+Z;|JwU$jiSU-Ea!Z1muh5NcMDC+*bPA)5fUOClFs9HGvbrM z{5TyUl0 zmAv@#IK`FFjtupYC%HyRfYgy{wJJ_$jYrlu-01p19Srm>eQ5V~A-P^wJ6=aliGa;E zK@+$G=_X8jmWYB!A*^PpY?c8y*(=G6_{D}$PJ6<(#^-?YF}#&S!UP(GN_h;FwjVEr z{jE#z0Ld#=DS%N>lKQ*&C)duc>mE;e5s^UoV_H0_!Ue@*8cD7nAG6)JRl{z_oE%l6ZF~pGqmiwOQGs?L26jBQ7s{QuV zgpAgs$@@+WY#ani3uxowZePt$bSVDQwMh!y!W~9?v(t9Qj)qQDyAdVy6=Db9i;M2( zFhn{I{IFq`YX7_jTY7E5jmQf)Jvon2RjKD)CO`Et>1x{0;TW!fSc5(U~ZDrzDrXei79^&7g=MIBI8WOJXGTFs7joQ|Di$o?iYO>XZ?Qj zO$~b-9pQyq%DHZkv+pNNAgvcj1{*n=I6(x6-1Y_$KKGlvw_IXRCVt&S^Ep41>6Qpq zMze-A(sG(Qkcx#fu29x%q$hh(Ww#qv?K28mgs(M&_dDcd65V*-tz5U|xRWQ$6yA6~ z89RH|q`ApuA}GCx5y8b6%7>H;Jf#D?BQEHTcGO2k0|@WO5m6C3j`L6?X;<9duN|8` zmGgX(;(H&jH#dK2+$s0NTn{~EZ0KUm&DEU(!wr=BZA~m(zursD6eg1euB*6RzG~u4 z{W^XP)~=`6(mHGqjFp2{q;VYx=mwQ(ogW^#&Vmf~ut6mKa3#pGT;^1m|MV6|GUh&( z@m*H_%~(~#19kj%s<TjvByH+o3FBb`i z>Q&G5IHR_C%^2DEx9%jXrV~#K)&qDYydAZY{is?lo~~UfetO^&XQvzrQ*ls+G14xz zobq@N*s#>y44>0amc|eVYGN7aI3+AqQC#ttVh)rRkj6KTnM#HI#Dg5ZA9^mEwx!qo zsqz0__iq}c{{+AMzuvRnmEz{}vqA!X8>XHf0%S9S^oTs;2sn$pR*Rtp4kIL5zcBIZ z1Aj5QdW~Cc*r#V1ucr((!u;%BL$ssh@-C$&hjiT{e!K#kne<-hYmqm?8s<<#M5@7q z*7^I}qfVex%6pLFJBtE|aMm|3!~zmW8c3qt+iq!ddOkegW!+D)2nQ#8R``n$Iv#G% zljX~yA{EiU9w}>o6?4|)hClQLnYeRIhIL4P1VE{Bm|2_HM7mz|QyBZNH(c<^G)Pxg z>R1r_z>wO`vWU-jJgfmNdar#3^5OwFty*qD#o-&)U)4vjCRqa+lFn zX`OwDDiR@nlw9)0Di~e?a6S|s6(7z00sn3CY?9@fl3IP*GCX`vX z+#F|dn?TCTikAEE@s)0W=){)nY?f@Ay2IL!5EamJ$kD!I6NjXZ0(o4-O?ts{0KhuX zQll3P5+!(B7i6c_fr?EEENIm?l5=ZhdkJwlz8ls5AS+r9SS?)-dp}QI6IM&3Zm0WO z*z@hDE($gu&L~)^>ubFXw8=DbWGN;ekTsT3E?{yoiFP~SieKXkGI;G%IH3p859@4G zTlgBOLKhZ|SnqN0G``U14Dz3S4g>u_6JRV{%ZewTBkp7Gu&Q)=E)QKVP0MQ2h5z%A zsk|KK&+_zd>E1T&xoMw}=bx(2-pP8v6z*?~D-HJVW_k2^8GKN2*DHiWGq9Rej!#X@ z&|cTlf@NsP&}F%{qm_$6lxp`S;RSSuedoZXyZK}}5r)zceQ|}c&Gd(Lc&^qLu7UI_ znQ}Flvu8I{dpQ75&yh;)m7!nFo+;da$Wgab zp{cN!)amIHSzH@ol_ywQY@squ#t@0c>Uwk`;8%fq;ef~ zr`_Pd!otW(NF4gcSx08SXhbNos5c_18~8o)*<@YJjCP_v01pj*-364o?un{f4$k_E zyFCWz#{&KgsGo$Fckfwnt+m#AtDpaadH%ilzkBkiiUr=<{f5TOiey8cyRnnQZVlXaq0&yV5u7XM5zlNvlu!4j$3I^5tyw^x>DgG5r{6J zItpz=6foGZ%QzXwPZ{wwECAZ)HmEMHD9a}X0=ceNr=R}ny{2{_L@Zg0_{^IBin#!h zt_97#KEN~d6aJ9B0#s^_XM98$XP4&gprg338UCl^(_&JSA@99}@035kI#8T*C7g=O z#*Rv4avDsFk|4@W#hoJBE$bDqC?t>8_}a;R(QjuL?9t(SDAt*!6Pst5US%LZX}JY> zINU3}Ivx;KAUAdSJgAk$U}>7;ru-u6-6QnnDM~yYq*rqfg|x!$2l@mOpDZ>QUn1vo zhGfyIJEa-}&W}}eL*B@nua(n(viuOh`yD=5Ry7Stj~DvNd2C?hk_Mox4GLzI#{Ydz z!TSWvV(#eLGW*^}Qi?~mO-H<37ru?$Yh|cRmK2uUHJsU{gNjHJ1W;&^!3Rr2I>llwWCp(%q*T_q=KJnXa1ZsM7Drakgrx!R7g!zK>MTCMD2!ES*WS0AnluRBXG5)*`uttpxuK0~D zu%3HlYw?e;VOSy1-{B435Mp_XZikfKIQ7v?1N^0LKx&r6Qd(8Lm(FpMzapO| z;g9-R-@XQCU_SowS)1^sah)`~_muKrb$n_5g5-ows&By#Mcr4cHBvCK!7@}Ytr!C@ zH0nwaK-_+#Q(kI{osP`+O~U)c%n8L#StD!|TdY)kQ57_klrHbSh{|Uly6pcG-1T#c z0VL2vRAsJVkwfzEa&=;BSXb~GB_0QGdBRRzIuLO6*m9k82W_yquM_J-xFXn~r_J2& z!cuu^k2X8dr>;)GX`OWXAxK7{uaDWu`6&GcQ)E+i2m9ku`U0yh{g~&GKS+A#!+>vK zUx45<=_v&n^Keen97}G~(vR>5uESJZ-qG%K$bZK7532V+t^9SA2~^1+ z=zO}A%N|%_Ku`RmFsn+Z9W+BDnNtqYZRUlE1fWMJH8udu^UM8iRHiyb9=(4us9FvC zg3zbns^=e1#L0Q+>70PU=oM;@)0ryO6uYQXo%sFX5VH$9wamEle>`C9GakTFgJZik+X`F zuy$TBdxi$m-y-Qg*Oe-j*H#QTqf#X0qltPJOd0sV^0^S~MHp#`Xos--T|O)inK1|} z#CS$f4|KVa?N zE?s77#=V`_gGSu0UgDo+oC!gMD}&;QPLg#sH@K~q)3D_U6$CL`d@!mgNC|06J@G`by|J zP8i69OWCx;zL9p%l~(8Bj4UMRV8rtms>618CA3G}Ad%|xMaou4n+mO>7%yI9tRLcR zXdQ_sxMFt*Y-vuXd@kCjt{_y)OAl<|WR7>d@q1zODi`WgtVXw6DN2HW*-ugh9}kuQ z4#@xZ2l9{3<$>ZANa*z?=sbaYq8s!>6;LT{tj-?orB-VJcQ>`V5LAwOYaR0PL8|AQ zgZ;A^s;m+_U~d??f|%P5ss~1JNkGZD1G=NC0}aF7!KerzF29t8BHDd9m4eIaxEU^@ zGGZsM>&6?mo}L^vwe15M$u70F>UNyuyUYc3TDj%|&;8Nc7q~p$Kle=#HMOk;p%>_r zC?iOBr<)@EAD&&Gn8gqO>@8HU2-b7Q`bUVrXsZ3m#5=5ui4GgMTy(BT)>?di?KW7t zC2d*=TlyNP~C_+sL4ae*cp*A=^&t!Hs#kEw;Cc}-DNXNnE z^~_0waDkqY-xAi49h4ePEGi6t%e4hGbUzxON~Z9^p)y&1{u=Bo5kGlrKqF#%w6|fz z)HBn-z|juyduQjnIN|otx?V~azEeP)ZN3lp>Ty{Obf$}-uL+okL(JmK) zN>atCHIJ7tXRpBLT#_QW)JnHBTNmAA*J9p8petdpQaurDs2mR^_@Qd1fT#owkmq}o zTI?r05?;&3ho@&rf7r~aI3b9w&_$WQv8|ZkXN%(PVWCEjuF9<)C+7Dn?M7p~18TkY z0lnZ8rSD|^Z%v+e3!UNLE5=$68Zt+;Cc3J8V~^tWfQqVE9X|jVvW&Dlg780b{aDf0Q_B{ zvwIJD+|n!Qd@TU|jjtp@zyl~=*7?V?$^iZ(w_;M^ZUZ$c62n{FaB#!YbOZMEW=G%) z=p7&Kan1vvcPK)osb5H?w4BgL;xPz@2UWXGsJ(q;guXq+^vByNC5Ls%l1;FK0`#3FhG@z=y5D9pYOXVc8crQCy9Ix#q4vA z!W6GvoM~x~_>;Q-QCbkr9!b7Kg4J{%ToU{QDW6RcxC&`|iESw4aT|>6p9K=FKXuN3 zTWxbw9}*RSY^*r#`g4h0?I>0T|0tpnXRE?l2`t~rcS;Nd9|OFvEnR1^B|P*O)#p(b zn81B^5Xn0v7b`Bh0picps?7J7&d!~%$HrZNon_F(|B#S4Y21da?7^0U*WUQidYI^f zwn2U=ZqWNhS8_`wJK`}HKEd&T-0Fc~9&=>VE2fadyLVVam$E7tBbQb;kYBivuN`k_ zsE$JDwC~oR!!vUZPhC9(aOBS=StyMaQVjW$q$#27@ZSUhW{JycXhi6xX+wkqC^9g)V|u_@)G9UhOkVK z4G|d`o;qE8<-jJSR4uJR5KF0`0ZOudmDkFVh|`dQ*RuT{fWMy7w^OfZIP}HK(vHRQ z76L6PORA{aQxdH}3g69iz_YIMAQb zAatK2SiYT15U?yP2Qip>$|Qwb;cnb-v z-Wxv5gYVUu@+WV@DoCA`224qnb74ocjLhMm+LwScD<2Bip1mS-??6U~-tO0X zUfaT&om)U%-l35>h9N(YLF1anDR}DuQKe|-7wmNlpWPGBY;AK|CIy5V!YA6k7dbK8 z{93abbwv&Qwz4nR$MZzOBA|{#^Dzfc7{Z;aB{ zUB(081k4gXKgDM{`pH4rgHM-c7yG{GW*QERg#=1Fu(dW%#$eTr4Loa5184iXIu-|Q z|Cs)p*yle_THqg(1sFf#DDe7gMg}RQ;aZwOyibg$fIi7!G-_|38-Kq?l2oxNcsUJ1 ze@ya9Z-6l46tI+4>gF@e0jnW;bXYLKA8inVvi2AJGu=c4l*6;u<ao(APsGtHBiK zT*9@kkGhH}0;;&02VBc}rY2u(=M&IbV9v;7+Uj7aE zm)2QU=cu3kUl0gEks&2<4{OEoJzs$J_kIO8Wb&1BnWFpn@Ai{_WObxmM-@rpUBT?u z4N*iZ9VBU&tLvb<-4~TP1p@u+{dNZI!aeVqo?j9)NQb|^uh36{JtA$qFUf?DUf8;@ z7G!LB6a!D5 zGVO7?M1BD{mTo4TA#z_hqBOk9Y;yM+Iox8@20)wN2EAZO>%v8u) zKEOVWrY3e*=|75-@vT=~Hjb_JW(YCCKsA|NgC0cuEVQ;MI(XyX3@m(Xqg@PF5e!Ab zmaZ3_(^h?IVdbIMUF`pcuRQ$*)6-BgVt!*_Wf{OCoZ`h#khW=$HDZ#{=rz7BTE@O;0IcW@#)^s4}nYfF%xW1HeH)$R;89>O$h)Qn(`%D&dk zNMr7OOGHz4I9CoI8EgjVMcafE<4Vo;_=Y{feivg?^&6a5X5XgrmuP2Qc?i`DmWcuV zZ;+<-^J1e^upUXS^fd3TkJx+@$%>AbNfAu;531)Wbv?QN0Qc(Gp2nvo5Y-Zn`qLwG z???^CZV(Op!(EDMeo{v~RHsc9i{Eo`lP!_dvnkDI6bK;x&v16js+Mqtiz`!ctcah(_N^jbyO=^Y4KU|^VZzKYf{`ew44;Nx<}_mjE*10lUTAPKA8=_Q+}`w z%%e_Zts$#AF&)gs-d(I%fqy|vz#}UX8&__V+Kt(@%BzzK&R4cVZLf`~$cr7l)S27b z2GS*Q$2o&!bWLjogdk1sVmZ570W&T?6bnyQds^}y!&4D&j$W~u?YXq|5<+u z`X;oN+DATmMA%cObMR}6k<;VT3^}b}a{Q|~-+B(sh~iOEZmsz4yNZI`Z+6fz?&V3asgpOmX_5 zvn7fCH3d5Udn?9hNZ-`zI*&fsmjK;XtyC zW#Z&)?gPHH|32;yGHKP` zkRMu{SDh{M{x!Lb*9XR{XY8`CY|1sf@s!tp&9=mJRvTO0LH$wt=)oB}t1<$FcN9>* zG2VWm+tx}}E70Mho$H;s#y(c&!38klEB(veH=4D(H9y^CAlRlj=M|Gue8xC|xMe2= z@(oG3{$q#Ri(r)vOmALFD}bJU=rK|_L9zJz8w@PLI4{f|c0>@=YpU_YTq9^(hHmaME@u)>TgYZGtqm?QUOeiG8bL+pf*)3cg{S2OhTeG1#bZFQS7v7^-`f2a5R)q8sdYzVQ!}XNG{A)Z`rPFYa`*;b^$=sj zqOAS7?tIX|3wGFE5O*4NAe*A+)d@JUJQRIwH=2Q~fzHXPAu?9pzdBgad9Hd+%q{M~kP%JFiepQ)@R1xxI|Y#Adw$QAE#XgBT4YD8Ed+W*7XHQGBo65qRGhKx^p9 z9{F~mrx#Hxe;XL8w^m1nvTe*m4Kj&eX4tw`K($n9GPVaUos9XUxv=38faKuWiV%6_ z0BkVL$UWFzvYV`64Ve1Y0#1WmwB<8e!2?a&7EMifx}nb zhlwfywVrYBVA~}=RnE!0M86s{N9zXv@Kz_mUH`E|2KB`#$nUd8@vtB2a?B4TY5+?6+n zumrYGTw#N9X}z z6mlmA$cdGz&}tuT0L(alL#M}b3xN6dr{|khyzuHAwZtdAKHkk|^Bl4Ad|e3OSGGV%og#X1IR1>hQD9TCpE#%uIBCyuwj%K1}ttfP`iJYtE`O zhZkxq9HI5x?m)T59t0bxT7UO?+)IdT=bf_ufiZ?_XD3*r5uM1Tc1@@wv^0 zg12EWfr@2Wmfjae_W1!pqp`tYnG0TwYL)9}Y zAgJ?)m#b6BN3LgOF3u}w2`1F%%6sa7|KO@}Ubmp@6gxF{Cnw=?ddR zn*FR(RgdJ;X~Ju3XW~t9prk&XMcNJD3XKMv>GEpg$0YD%c*t_1&M6~&1H*z5gXZ#g z(y1Jc|9`w)bySt<)>j5cKt(!~?ve&UMOqN)P7x50l9G@T6r@YKOS)4UMM_$_L6DG? zZus`=y)$?2{rj6)%QXv=Gv~a|e)j&=Cd0p1l96cJ&Cg4w-;+{D*LmTXwSuk%bvo^# z2Zuky&3Gox-rp1h(LqXj0Fv_A9WU1%E!Cdf% z6|NObDjySzmG_8LAzz2g|=(_de8q+~0W|p^U3MBd&)=sO7TK(PD%D&r*BssH7IM4Zf znqTsC8y$W-!P(@9SD-$@v-R}-DF?K6J{r;Cj3cgbEkN%{AaGC({P^}W;=&p?2d#tvN8(<>DuQ_PCvg)&H58e)hQuN>HWsci%KCk~YQ5 zExahkAUFuJTmFHXWEEZm%gHpqQOBpu5hdK0x%rHGmIW9)TlB@0PFj-jma*81fc78> z^4?%RiWc-cu0p3jL_Kqs?s~4aQx(mrb**Z4dvn&V00Fpv(A# zvRw@@BIz6P%CmVToG9^tXjrzQ7=$>@%tRKy-G{ivZ^0qxsc_RE^n?=zUy?1wu2X4f>W#2G=>*ZJ&Ua_?_WwrB=UtoO{ukonK)yd+NlRC-KDT#}N^A zNpLwOn_|z@bxpl3@ArDY{{)2AdE2gp!E+$HH3ps0`gG2Y?Ub>P-1aS>XDE&MdCnO4 zk1kM#%3tucyo~CJ7#(d0WgDozf7+*Yrtn-E5ggq4=nS4+G65%bYfMz-8F)CUts6c0Vp3U3TTMe`tOgjou(Cj@v{rl0lJU{>Zu*-GKgq zr@sx6+{mq^j!RbvMozh$m&#_9-KNs-WhNpaEA~vD6C>0`4XqX4YZkx(5C}>-D=J>`Du$%;vPt(qaO{j9rYDCd?2w_-UB{kjtQ{d{iDMIUWFuYqg=|D$QKF{j4p zbB~{bxY4EbX{;)Y2%DVIVH(HKn0)5)xa8?Wqx;)}iTb~xq`64oQFp4F6Z6pC7l}+^ zCz*9o`yIuGC%w*8ViOgMLOi_xI*$Lg$&&Uz2an}k_YhP`%E`A_+=W4Os(2}HOq zU(c{oKWWg+a`B}r9|T^QMdK5tnNjDVBe?v?GhpiyiNb7NEO|Gh^^Nwr=oz_smz*uG z_(Fu`IkT$wrB-&d4x-j~<6FEnV3gPZBB4F+IZe-mwzwUW-!MJM-466_CTw=yYc;WD znQ0vKuGDm!CR=M)94!JMQWeyqcmud=%#NP+8f@JAFjOUt&Y}^d%!CGWNRPO=XY&TeGeT9+6flj!f%wp*7fQYmJstyl7&RVaPpjjIG^n7WP5cV(}2bcNW-tIcPndSeQ_3 zjD$K4S*+R{Vh5!ciauU<_A)Lt?x|?VYm{;kK7>scp{HMiUAQ*$+u15!v086tm!>76 znQT(?X<=_?F%5Fry}_ZPDrpOrH@&H-PD2%*_vraqBX*pw%Jn?1?(RoA%*&7qCW1e842rU1w&!w@qi`vIh zqeW{=7F0<4R4!*`sCZBZF~UQ7^O#xA)k;>QpHz94;^lmM#GV?NDxdtdge-zMUBjS_ zc9vXqOvAunrJ;7B!f>Uj`U0&F1^5rQ$E%-y!8tEc?9t#lP_eg?ZD+2T@M9?CY=(xPsVW@$*f=+lOB<;{^CXaaM#=Au#+I z_G@D?oHuz)pWfhp_5>?H0h}Ei#eAsZQsq-0%ttw?@g$gGAp=(_EP+;w#u8}`WnwiR zYdf&>upEQ|^&U0G%K8ceiW#Q|$hhJ#N$(JOrjflmvEGJeOhtpFcw?4HYxIU{@w9=i z&Q~;Ix%qMr@ReP$0!K=W1))>-^R?oL;X+&h_Rnmuuju#**3C9DybDZ!`R zwKUunw@YeBFZx8cD-7VBucWrjwIbFXi_f>Q8rm_~3o%nl7HsXFD8$$WjD|=V5@vPU zXR-XFu1zeDM${Znb?tAaOb=veC?p(siq!_`u(3RN0zX0?nZ;O{i2+}=d(l;tV5E67 z1a&c0zGY^~wz3p<)-#lE@iI0=L0J=5DNsBYjNr5_UJ!8%WntT^hCtz5@ z^{_gZnk>G?@Q)^cxuXr-Ly1_Yy|?f)Z$VGRzg?pbCjlr8fixhA9^8`ry8$B+31@9cvYMpvUlxdh>H^Z>gzhHX4a_6Sjs1hhSx^ zC0I<1{z&xzNr1*C(_Ct}*%QM7HA5dE724iZ@hhe9p&6@K0?na{#aS`j=|@yWA#?D2 z@Pj^T_;ZAuMEFT!v?A|oZ|eO;sj3P7s<->QzxId~M$*(wf9EY1`Qx&`fP(h@0J9PH zIG)EM8FW_g_DTs|@II+GcyeBgI?8+n9$*~o837^;t7fr}Qp(z1PeoltzlB7*YkT35 zeF@)X&6A_iEN|Ea3F=~5O8DAY&#SYruveYvuCnj(ZXf*qz92oXkU8?q!62FCkop~A z(Dcu-i1ajgA9y`1Dn?s=u1q&H#BdnAeF@@rBQB$OY-qTGcemHyi?SsA#RCuS+vV9`u?+PNMPA zAsQ?eFW0}F)PiO#L!;El2;RXD7U^|maeIC1K+;6RamUvo9}~NemT@|DERA{zTOEBx zA=Fi>;bY(R@Zcg#4V2ehw=~PxAw}%=P4glTy{qRi7#jh|ZUni6sxAvaFEc+Hs!05< z1M2fq1iQIow@h>tT+MDt3^$nsxvxL48A+$R9enfV9F*}DOQyqd1jAB3k#E1=_+2i|hA(x)Te! zxh(JF>AOwVINU~(Oh-Xln|Fb9`}I+c`!h-rO9=TZTP1^boLP1;@mRvK&qyrb^q!CC z{eo_{8wvg&V1$i;)v{=Wi?|NlSh?#F=GhFh3xW7i_ zVt03B*QN>Ygq7%VCHM;$KvT|%SXWecfN_sIJ3WpAOCl?-<=M$00!^x-KAp51E}zwe z>cW9YjJhv3kaeaSzr&u^N1vYl6mhfwD25BBWgbFpD-R?}b1UP`C=!APIu!G{ z&~?N$giv9tGoC`Et4}V}AYi{=pDPR@s;lM@&$)NQ<3riSPvKBPqCwF=K>~9An61;D z9Tjj$=UEZE-naQKd0s34)CPa()`ZYgE6}fG020k#{Df1l5p}#US2dp#O<)p&CXAZ> z@cFH=ZN>pV{FjGw*oG>vUiej?1pD{l0-d`ZF^H$Gu-2%uu=2-1pYke>Jq z=V@^DSJ@idf^jAqp>UYdZ5Kd%aT~Jf42E1CIFP)Ob`m{SB-qKGB_irWhpq&6)^pUy zj^8eQE`+2f)go)ir2K#qXENsTkwkDxiOaaV%fru@F98h}3L3@lH;)(Q z&JfNJ%Qpc1>-&5Rlg}ID`t@Obk!gqtnrUWpukHbI1@Xeh@Be+X{rv|+XTqqTbMpS`#^l(r4sbU ziR4`vD7#BvsdHI1u-)pC-JqE8>eSemQwf2~$Xocu`@9smzEl|sT#xs}jW1>be%GyS z-Hg8gS&DM{PP3Fx7Q9{eCx;PxT?X(>Z|#veC9?-BRJ1Lq0%2_yVCN1mY~=Gigpc<$ zFLlvppVVn7kmykJESl6;PkHS<>Oeni^r*PZs)EwJ7otI9jUNc@JVWx-)Y&s!rjn2>M`G!gYxg-}*gmbT3nUMfO^1THE)YNY7B6}8pLwlqv{<+=1|6(f=_mio@bULI zphC$~KFwdgX~+;sHGdF3eSD8A{m<+#bz8JHg`ctg!=@&?bRX;KCdQi<*zyB>4Vpba zok4%P;NwJ5#_Ra=3G<8cDW?^D&j<0aAFmHdN=6_OBWSu~xP4v@g8n{pDh4eSS8NF@ zlQ~$O1jPh7+GW~eG7#)y={3WU25)l4%k2eK$AIOJmGH^%p28v~;_PqdlOmF=c?RB? zq@B=!nQE3j3;n{z@n-NkmdjnBrDQ;H_A3Sina!G((3&Y9zisP-hbxJQZSR6!4P<+Z z64C#-fnCk5Z|8OdAw~yLkv&N6Ve_g8c2k}YI^lcakl;=4HDVVLxiO&g=EC{ z&yNtI@L;q14wxSNQJ9k3alw_@T%VNVBC0Hmo%IdXFD8nEqga0Asy3Q4 z#nHFR?ZVIUqundDj`!BO5V82B>iFMmnwAJy)Sq;yo8^~Zm2EQ!YMZ>XgS2jlyleq_ zAI6M>yh?~E4dh1zw4SqBtzg>CN1FnrWIXlOP^qz;Ei8>P6dM5+&4(pP9kJX*DaloS zFzKhuz3;_3^w`;=AN2XQNI(T*HRQ8*tA@U%6-oM0ZR&2==>DNK5*k@A^gh_2ekOX+ zKWyh}3YdZyV&GvLi&V`b7+h$V0nP(UHd0~SmY!p z_7FXXC!z#_);4rEm*2Q+BM{&|AEjl>NoJCpDUwD35jFy)E{8T9W?&WLk|4DU#~0XX zWtek9(#XIoU)6O*I3D`Ep& zv#l~4EtowNG5!T6R;Va$6e?MdYdeZ*>{|?3>?3Kg$VC7gV$?Ra|gB;=iyn>L| zLaQ}dL<%{0;tYN;l=`B1+H&!}Vq{uay-O$ZcBB=KihPkhS}2T3Z5R!%aPzA&iUFGet+Am!4hIA?amhP z$jNhX=JJZu?y`n3r)TJi`x6qotKx%C>^@$+tX|A5cpp~iosSY8~yZq0v$h<-Y8JVZUQ?kiSdWb9NQv$GPJtG)O7mSsUOR-Mnx|-@xbD{1tyfHeO_Y!go1_G~K-9Vem|uHCG}F zb4U~lfNG0|G-E^0daSE+vE(AQXqJci*3i6W;wyHjd6)G7qHBnixBc6!85~PVNQhz8 zcSMW*ghI(BGFfdWllCC6^W<=Q&F;Xv0@NUE-_|;LY8h|Z12C4YQSVZP?=TKyLSE4r zY&v{~WpA4zn{Y?zHRg_1B0wo7f-gU%Z$Ft-PUtekT=<1017q zj>uiB-Ak{X;aQ6^gpen-Si#dDx4D!M84!}>u5ayA>2;B^5&Y|Mh~zYwb6D5yF#QlN zw9=;8Xov5?45V|Yn>9cBGsmZqi_j}?BAPM{o_KJ?g=Hf#HGXtOHuF;3@SKm5H(G;& zC0O`E*uF$;5vT%)-F$>FA&LW|HT@x>vs}i*OuqkmSma4z>5YTyv9#T@H_HrvT#Wy~ zQv}~4B2jaKrF%G(}wsz#M}>psGt(t@)c;o`AWn zFc$HpFk3dY!B$4*H!}(3yrWOUST;EmzZyfIQiv~i#cS44_Pi(I?y$D&?%?mCW$MXn zTf43-GJOK51C2jh1&H$fw!MwSy>d{$Z_EfkM!0DBM5LC`h~+7Kn}G^_tl%5!K`4*bGnPX4Q5( zoL7BO0N1F=JBFY?z<^(1?0`DTx5rU$3C5_0)rm}_|LgbutE&9Ji+TazwnB+uB~W9^ zT;!?M9U56Mamg#zDSQj4*uTCrDxlfoHh3gLed%b*7g0Jpte&?lu&D&{UkLWqp8r?9X&g z;;!A~0{}#a&FGMzZNXhmGSL{m|^&g0wgeO!}?t(^oEu%^^3A zEg~I;9QKi=Z^vcwWKOJqoSR<8n8ZY- zG|z})g4Prt-Apo@{$If($r+IKi1fFnnl*!D2=ovg_3L<#;bT-nR>Hcaf>4Ocz)+J>(~lI#xKH55bG z9{Q>*xRk1(-n|tP8alys)1|6q5wROx&k&(bqHn1uxjYP$Pc*3U_?YiBTEe0Jz(Q0r z;IG?v@EDe1=&kZtjB$rur+UHKnIt%kQFn-9)0qHvjwy;8w;k5C5jV))`$Wu5-pn3z zFyI?EuSDPUQSxehQ9!c1)K}&FaQlnEumT_~+^9&Gv0l3^dpr*Pb|*ZV&tT_Rz8vsQvT~)4~U^~+!T7JlSWseYw_m={pT3^cYWb;-ZK^BZoxnQ>O}io zSdocQ^O>Afq*x>iqo3lJNURLKk`3<2r@DZvL?uG=_XU9|0XT|Yjo8{Rz@xqyQ2dqLkC-=yNvsJf`I zm*S8>^=}u^gf5_9xnDr7VDgA23O+wo1}vXifszylwGSINbu8yivNf9W1(Y*ejb1B* zo@aTrsCD|Ys$+zR*PWX(uSf^o5b1sgAniFKT!uyV6k|VL{W!ZF!@3ysUfXcd&`X)F z+PD{pzBWhL1Oy}eHFGHV7b{#s@U(W0R z2x%VZ$;(zW*8H@Dg-_9mjkLHf4NBZWrI6=Cf#o&acc6w^%JR?SA!)E>#?yn^HTD+F z?DPsf?4BE$>oE~14S0!B6&t&_$Q99l2>ulE`G^?$$Rf5(^SlHv`ez6&au(;sx~M`=R~;()>XWIj?vdF#FwlCQ4^CigP2NbLn)1&WR?Sp0#TJ*!w{ zGcOkZoSPSYcK(KPFs7~$o6@M2MHloD6HY7n3$L%R7MW2f@$Y6s$khULcsu|U@*sWV zM#FjiA>1|jR@$o?Hg*r2WWC909!R9HX~f@c8f8$ zW|dhq7e4Mq(kgFVF+ontA0Hiq1FA@|?KO6zVFriajD`OCTYvde|F2(WxuatF=embI zj`h}#588aR&G+Nxe_oFdOstZ#{4t)h%1I>XYB|bZ$Sw^w@buA6&0YE8wJ*iY&@C6N zQ&Xwk-9EQ?rEv0e=!tlop|?95m8yJUc}63a?S;gLBNnGeyU5*&nd>vfTu443n|Eto z0~i>j%1G2DnxG*-GfJUTj$u;CIne1myc0JQ(x-2W>?RTy-_#F;^+Fuj`G-GO z5Jr+p=Qd8-6|b*-oR_d?$$sAz?7!#r@=En}@eO55X;gM47vWvP@B$tly+%(l-nwzb zGl(=L!@|L20@4AQx{@2^zg@rATLye#XQIG(EszHb;46^RDlG_Dpp5q)D>tio+C3lb zK2$O;Xt!6G;I3K0H*fvpo1Oa9q;Y%HquNA=;lzT|I|jq^j?0RoVbKg1e^tGIe~$RR zLUcE+#PvU_Q~tfj^Vb6+uYg8Dpr&9{jThAKP_a=>XzR1s$MIPb1mys!s!db#iY+GKc^zpYBB3S z`&ZDMPV>&jF#0$Xos_V4`ChJacIcL1VI}`m47>9JZ}4cBHrv;OUbzz#Ad26QN&;`i zsZSt_h~meB1~+1lxidI6iVXSpFQ5eLEwQJ<@N}@n$xhZ26DY zzAV)p2sbX~v;Lam`kD07WQ|L+wSDTd;_Ak-pN|c-`zVFe zqTpy=|E4TxWo&(vVgjgpz{o=hy-;HPnWP9%E>$~c`oK(wJ zq{Y4^%=u~^41O_^!+}SPDb>;e{TNSu+6K~*0+xJw$jN$5x~`Z+`RI#S3LnO zy0UtD^G=QE1~aLCnf2U*yRRU+l)Xn_Ki<_iyFgla?LN4Aer39k!gv-SHiHQMk%&RC zXxt8as9grNcLB*}LfoCP?D3wnQi{+gtU%qdlS~~$wiyJ?WZ;Nw(op7 zHvhMf$~&Pi-F``QkU)s@jqI-{_kaK3|JU)IeroL!Plyo6 zr()X8xfK2~J7b~quI{!jiLkz9tbppPhgU!jEz$Y63 z7qw1L?923aTOJheVu`5}S-N%3`>ay<;a(R|IkD6s(a`nm^t;O*P6NsCUq3d6D=^H~ zoNcU?u>XF9_BS5l|1@CVA6zJ|oZt)1MMdMgyzMr~;qB;l=RYqhITZ_rtRKfFvrWFL z6cQqLaQ5C6gh9C89^wM-{m|6@xme%o|A%sa7woZ;f*+ z3`>=j63<_0JcS}YSAt46SFMm2nwT(uP8flubqIG;0sYDV9L?91=Bhow?$KUX2BnLXZKoxQWebv`M zLB!gx*`#}roIae66*LUHYACL8w=HFTw#p%*4w<8xrX*rovUp>8Elh`l+X?7=_JLVg zrR4YoxhcPR(+oiHeV36li@?6z#e7|ZFf8G`{Ja|_`Tcj4`Ed6{oweW2Quc)k_T8pN z>{w*&Y8=m5ns6MEq(CK@^%AEn_GTUYL7Ug@elfIwDsK%OO$IDcYUydwF!1eDZ zk;IZWV|`i-d^R)DVz7?BIkF$>5P;jy&mU~4*uzwt0j#C{n&iX|$YV-ftuE1sIQBiH zkAcfugR&a5V;wGlu(I;6v8-#xLA-mNYm!efx&5S_+BvUXol#fpKshUt1U>wu;I)Tu zto}1 zNf1qC9`3wBb>{R^*IccN6p9q{Y7Ak#-R7DhWcs5XY|(?nYO6VNt1uLY zilV^q;RLM74Z}6jy(fzzRlPsgxH3}59M&^hP8#Xkd~989zrUV$XQKR7_lvbHW`R!J z8i&IdtOXPbJg@{!+f8%z&YpIMf@7yfrPw?DO}#oCk}Kk6G=AavmMK1wo{cnoYRXVy zLyzXX32tesU#v7g4J{f*He}p@H2{R=!-#hc`@_h6#s|fYfr13&ss+}$J#Id}%`!>% zCt1{sK60D%(L|KPc}8N>cwt5^27#vx)BV~kq&I+cen9kH8)-V2%mr^LkzwEDHJAK8 z6mJ?p>D;vq8cP|_Fen~2A7rHkaUzHxBG*#fEcR#Bsg4Fg((O;OJrCd^#vKKS<9U*b zc+S}`K^9PvzlN^w{*#jNY**n@!%SN}1*Z8O0o!JdRYIm=JLN18;$_l1EY-$+3ATZ@ zhcJtM-g48dSYf{vU2_05iDWI z{8^|x6eXbj!#j3kvLnqD)$(#jefz=_MP4hN%kaH|E}!f$4lc7an)oP9eK?~e4NKI_ z0#|2T?u-UQZ@SY!q4~-j%+|8pYWbQx)Ykd<%&IiA+jXI6qcFzeHs`1nK1b9;kKr=l z-n_eMj+{~8U1Y$FjXOUPcvJza5@Vv})dNEJ`n4B7z}-<0GjIrny!=EFyFo|t>T{?U z8F2E@_3G>P#ySwbb^+ouxFAz}$6r0P3=V$`vTl)#?vfW@_X!hH?1}-{8185EteME+XBH%T@Rt-WPSYw&nBWXnYo_$h{*vCWF zldtIaHoSU8txyAIs8|^N(|wOj1dxzlL@ZwrEnxN-p(K24Z>LBm&Vq;86cC-o61<}m zuz3-YqM`}Syh7ax*n>I;e&L#eVb&R;+N_DdH>-5cGn@zFF2 z{PoxWdhh&yO$10?YQKE3X|}!fUgQ^rCX&f!F@^T;Gk+Nb8K^u)928cMvwgbcNl@@3 zh3JGUTs%DWtw+Va(4Z2$H9!1Zi__Xpi}+UQCfEjKd5bII0J18Si#5wac=9$P$C0;U z2`zTNxvPPqXF6?c2i$)wf{3{QE2qjXYl5S=GF4Z@zc*r#kEWH8Ln}}Btq4wk3;kAbM|YoL+2=#?2lHgoYG=IM{y~2S>M0l3fnP z9OvE2NO79UWOX@ykbj^hfU;fD1Rc8a+6+UWtL3^|2pZ8cApLZ4nr~Z-Jq6x})fQ&` zo9J6r6m&Qnzjg*7ct0W~y|f4~?K+a}9QOy(&RQeje+cToCyOI;AwE-p%wmBDs(LiP?}1%N&Qw3Xjw9Zl>pfpL*UxZn5kY|2`d#c z(y=dIMEfq6jNGJ%Haw*A8LM#58nXEtY^#Zn?6>|rt1wU`PvH8Dx__Q-m?uN|&GRpX zgBgbIkT42n&W28`j`LRVu4auX6!KRtP?i#I3&6~e6TXk!I4(@Ln z0@i?fyYUKJGzgUG7lgOLAFpN$!E_@V&p5j2%x@dCT%{JiQ@s5deC+z-J2dR`m%GL( zy-D=pl^b^~Y3W!nJT~KqSK?67C47qI-(USsGU;gT^|ERb5<9pJm|)GbZY+19L{uce z0&pokh^+V-|454a1wt1hc~_crE<>e8bl89GIp*Cj@Xpw<`(FJoRPgWVL@uE4;|Q^^ zO2|KDc0=K~+zYd3^E4+9G(qVJACYjoJ1>@=AS?p`xSWwlB4#SZ5w}Nev%u1E!3_Qg zJ^5rs_q-(48mH*zb$S|lYhO?t5zj02o_)vkRr4G!u!PNT95AVu8tRZ3BR!56CG`;;nBn zD@=o)@)k8V+lS#SGT-V+pxYNx{aKlI_D7K2&#)<^AqMO{g1fgecxk@VDwLb+fvN-% zf|RG)Axv^tPKm5zA` z0po~JK>;Yev89mlRcIf8v#ivMgq#?G#C!qLmAM4Z4h$-cB;Q;>y@!I>9KgWv!P~8H z@kSZBBn9F+s3KsDILuMWHA2?nAi?K|z%FfHlh=Ag`?3NwXElPif&B(=&wvX!VIJ^$ zANeuVO1AbZYdYT+3W&)Jicy3l{M00rR+OE62jW? zqYb9Io{0~^Q;@yhciYQc;HbsM8Yk}*9(DY0bS_ePWc2k| zW`mNngzJYq`A&g045JphuIg1b>G&VJRK8afoxYfdc&N*1`_{mZAbUtUky6cH^`cvx zS{^tWY7d#w+aSJpP7|BE(Z{|to(FV}DxccQ6If*WfGQ5I><)`z94Hdz@olvX=M9p<<2N6%Q{>*5 zp(#tF*ett#^CCpHj%yTOXsw8QQcw1tjHd0v7ssS_H2ZAOBwo5yrPMl7Es*EUKR+uSHN6;7wfK@b_L z87?ymr?#ST4+ppZjO|k-b3tXQzI*fv;7fR z1NTK6Y#I-!a#aHz*mLhWNw-h;mn4#QF}xFg1Lmamw5%YD6t}1wdQ<8;|e$ z{Ef1fL3;EtaE>?DPlKA%I-=;rqZZjp%n8d3cu}U|Jyk!p(^U1ujZeNUCrvm0^a!Z zs76f8{W};QIMfthG0@X01w=3-YT!P-G=ednCB}|nL-cs0`m+sAKObz1QaruhU*-Mp zPAb_2JH&k)XmkrG23*YVXu%i)J=(Qj1-P(w%a0i7A^bLE<#S)jqgpX46EKyPr0UyD zoMj50e!=KUHw+TX(`}d<5qnp3|CjoKp+vgI^WDxeh|sD+;6fk>lU^j(L7L*Q7H6mSL+-%k{518QFugmu-0^9lu7=4@LC9Gw{1^L#q|hUaT!qBuHFa{(yE{!Kmu9$ zL1y1Cwn~E+CKJu7RaeZtt7W#mFzp#d`+D*9Y1 z8o=>E#rkpLKax;qkr*@P_6#TG52!!z8hAwER#kMBPl8aP%B;3rvG0KQ#+A6XMW$8e z<5%0S#fD8TIy4+7bg891xOO)xU$dOko6ISTA7tM72a^z7)CH+9Q8%T5wS2)7>9=!j@t7CCL9fh#V*-9yQx6fYbO*7Wt0;#4K+QAkohny6 z5Vxe1KSProSw$Km3D&eQ$w4Ht_Q??R>D@12R`%EJVH! z;-(GGU~$0sCJ*eD_v?~8keCZoPhKXwYo8~OTLS8DB6QDzJdOS!QG+NxUF+X>Wp*Li zVRNtdLjr0)jd`?8v~1^K!!Oafph-Pan46z+lld0^7?-!}iQ%H(uoN4lRH%lIqZhFg zsM0*_B)Pt;MdgL#+rQ0jJ=;{fsJOBOA+g1&%t+IPG7w9?n*dW24LY~Q*uc)(_;9@A ztnU|3ly#c613<&Z>hj(53^_F#ygnDfsaF5Qv9=amsY)(wj|2nGtT|vvMMS=1Qu?VX)WMSsUx*p233k80dH;#zU!%cV%2dw++r$2}5wd!;Em( z;;LI>iOnqn#2RXc$>RM3WQaVV3^t0f-_ceb>6ZhA?ysYPdJ9gO3$8lUT>|oCRA!ox zRLdJ)BW}v!ve{>VSd5EK6Cvz2{;e?fhZPk&feZ>%q?az07xRdj4ZK2MM#!iN|D*13 zYB%(G3xKO+;$=kM;7Ip7EW!MUAPs?HV^UOEQ{O&&#{n#&-aV>*y!J?a4d%jP@A@Pj z;~T+5glbrEaED~%Ks&c)PAt(`W zbx}Qvx;ao}jL+uOHx5%fKZV;>iR7u=0QT;^cwfPHVD*C(dwtxS-=}|&o z9NBNx&7~Ws`v`UV5_i)*`ilA$AI%(OAW!|#;b+J5M(ZlIZdlgB@8RUV30+& zq^h!X2M?F;aq>GwZp-c}V7@Roz1|Vw<;*Ysd?+u5H0}sI3_2^{HD5czAd~$4-_m*7 zXlnoi3Kl?WyC=wtmy;? zceZXry~)>9FMepk@&F5byAQydEr55#zTc3EGNxqIv9A9!JJ|TN+yJ9(se5I3x9`Tg zYf>mycFO}C$Wk_w@rwNNPfbmSG&6LYbfe`6rc)FnG7UPA93Kb66zdH9fK8c>9W75> z|Ly+v*?W>KvLeX^J&obFHBx4f zjVZI__nw*W(ko~oSnuG-oJUumKxSVl3b@r%uPO5X=Nt%C(e=V5oCmk%0mRYhJqRK( z0X!#~$5H{;V7mI7WnXGVsO4d_WCrS-fooUh^FU@gD>{YJd}0x2=?pgz&wbtb(cg+- zp$IUrHxhdqR2&|dL9uyvG?wPVAaqsz^{&n^vEO8VJ|8Upa=rfeIoFeq7q;R3CmPMy z|1|pcqznlb0Rs%ZIrDOE(;`jeN+RRDQpmGkuG2dX>*mdKBAY^>^3kqyDxa24Dg0dg ztp0PQh??xD@VefVwx`mj zlR-fmRbMtjG&8Gt0B;aJBtsu}k}ItwN|ua^(V*ik3vxf*`;J;i^*cY~wMBh6H2FRZ zL|mv982>`>O>$oZJ^0Jq)qcr?-*!Q)brX8^SlEZ%6##zf*vAS~2Gi4i{>_V@#ioxq zJWBIVCazw zR;6-AbMQuqyKY1XU!AY-I7(`TJ6dbKRfFJnqGQ#W80ITn66AmRU;o>VV~C)~c}D{p zErt9&pyJo{F*p4(c}zWkWx=?}pN>ho*|O*V?nV!Sqoi3ixbYJe`UuPBflp<)saJHf zQjF?0oZDiYnVKwhYenM!JX}JaACX}NlFpSFA()&KiH{ES%wejQk56t|z1X~&P;f_t zgRDI2VYG~i7L{_2GGl&B{$yqurZ|vRdh--Zo59V=x5Ndvoi5+xJ1Ew8!N8i)@bIf!6D#faAiy^89HoZ zh@|}yXg^~rcEMC zaPu(}(;VuK3j$OjxiSxe;^yIziqlN$r*vixoEZ z#I`p`{5yCvW@VL*5ktx-a6?Keme9v!ucT`G)GZHAwClZqO*Hw`2Vg-`mzV(zyLd6$ zw)gee;KX`K2P+cwkpT#m5k$;zBMN^T^V;W=cUGRbKz&>QfQ=h8PpnyY;tKftVz)&L z3{@T&t^kUT$m*7rKt8n^YvVNp&uOQ%jR#fg%D>6FvYjZmzs#0E(ZJslIJhLox|V%~JI7BzpIhEgx9hA`abcAGsd30i4>EQ^ zhFHD@McoT0X$FGKVxyI?re3^~Q4AVS+Hv=z^j(n6XY9PC=D48+eH)SpoKLC;P8B1d zbwcCmOqG1Pbjqx-s$kDHvc)+L@zzRGbYI$Cgy^N)i2t{|w9?Tb@|5=F0C!!wpzPqshqUS#qd0EbUBnuc++tU$#9 zOyPw^KD0CFm5)f^n|vg@Y~v}=j&|B-xNIE2`eXD;EGy5v^rJP;fPCG z;GVe7DWK#Oq%2Xt{ryP(opDzLc^M{#!3ORXfn%IcHhW#bBaHD6X=+wl=?w|AZip%r z@UW%maJ$giX6x=gI~~eZ>!~+3EF2u`+fK1#uE`2&?9N`c?MX6ktR@uA*V=sNleB!j z`J`l50PkIAnSJS?LOAyt^YWXPR1OnT-?||W%zYBZe8g1%mm+VHCvT=qoKY*8nQl+; zf@qK0{hpHCN2iJm(i-`+`4{sqo$3miX>Gr^ORmy@JWKGhzI@!%>3;DyMD(mb-G3Am zc2Kw{k~Zl{%dvQF9ru4X={>500+?Bih9iZy40_Jo6uX4Pw>BgV4UuXfu@`r+B9x^08ST5Jn?*5YXiIj1B8Wp46nGb2vPOdFJ7JrP2`PC; zb^(dc^M?|#HceyDO{{#^dTnC!G0#;@Gbm(=OmiL>$PF>ZmR;hvVO0+isovnxwEJCZFUPk`Fwz=~#gIy4*;!!rUYX z@`;cXJS~ZKn?xpw!tRu;WkO?qv_wdF%Rh$(_sfV~#5mX%&2^SD$-i5v&VAt}k2TAm zLzF47hd8roRyit8D_?K-;fgxMd>&XKdj}gB3n=Bkp*JOR?O#=KK(uAq>@Bx*!^?cYaY_R}V=;-W z-z2{0Sd>INX9o=2uh@AD(h|zH$DGf4lb49}x4)ZH5#MZkN8uq*z6&U*rpJvam04@V z<%lfX^p{F7h>us-W>O*}MDlX7K|zt~iRwVpsH9Da$A#Ofy{54I#?uE$fJm!fhsw)X zERz1PQ-VqoY6;?c;(!pMu9vR4wIX13>V(Aw#uo2QAFXI@FMFoNJBBZqfu^-0&}EM! z-(mF0^}DO=W`#S=v)WotQwi!5ASJYHj<&I&F3ZlIE-q&}PBu4j>y6!ibCk0va~kn6 zS}X-l-n=p6PtA%(5GfOn($a&GKZ$WSJ4<+O;4IDQG`V=W*DbW8p7Hk*i}trnHI)mZ zyG)Ny2gV4G!KgKcV6v)sotA}_1qnLJJ-P=0OT?Xa_u7XmEVS;Djm|@giWyB-W}U9d zjj%*)^eP$XDv^H4&v}6pGa_nfgrk+jV7L%>#b!4bv)Do8DS{vOr0f+)Zx9b=Z^g=u zdY#S;`EGsZjB*=wDQK=o!WN=S!60uh_w`1v`VL98u{97^3!pyYK$KHIe#X`5fa;xD z;HF>yjms^n>1Rhcu0<8Sv!De3(Rrw^+egk`5 z)5BNHw||YIq9kvKT(Bk${vU5|85ZT*w*9LM1MERXCDkDW zBqXE}L1|EtE~Q~Wa_BHH0HwP{>5^thgKmi#U?&OVS zn)fY|2h)cx|5#&Rse~;NaZiC9)`VS@qgz76S_sQy`+}X3{r)Zg8v8nBBm2QPXsT?; zwV{fmipGf-X$#Q*xXJzpznlz$Luk@grM2y?(J2q(Q!6cP&t}*t{N<9NFrA9jeOeI6 zb39Aol)@y1#wp=R^d{WkeBk!%)KXGWhxL}HBQ%6WF=W1s9oz-|Sz1fe!Kbj$$z6Ns zhs%_7c*bEq<}f7=%&+-peCkY%$A$ky^h|Q(S9ObQygM%n1QDBJI#DpJ_>`*L{qCvj z;1gVADY+Rax3{U6H_1r?swpoB%3K;29A?e`B{=;d z%Wy4QI#5ql=oiHrT(P?8(@)a*mmS`6$u1R$OqOd&1-_y|oJcvf>yK*bYFnSXmnIA3 zNE=70X_Mp^YoJmX@DDlioJy5xT~EW6?VpFwv)hzsgAYXes(Fg0Ed^M8>~g90&VD21 z9R1>jZ)%6o_zBE($Y)i~j9RE>ir&chqbnRhmm7C$#PwRF_<5Ql9}|>RB_#MNLs?{_ zJ&=YTMBzu1rT%h+PrT!&~tqMqkNCaLp|?~sW(oE@F6+|Uqbz=kK97l(s@)g5HjA!n5h7pQ2>3)NfvQg`sI2 zbTh<39%IZm+xst+=Yr}k6de}NcJDxIIU(R1L=c3i(KM3TbcIu2dDaW!^TChAHpA@k z3skA0?o;SQCwO}<^uCg*u+AIHVu~xISV6C9g(p`}0=A|E`-)^S!m1o=k~9FSxo9N# zmP)hXV#WeO!{RFc`GWtsV5()ua3cQm6KM_yW{+~2T7SMKt}L&6^( z)}uI)TtOU=2R`o1AQ;^vCoVoNX87I(qq~pN7+1hdO#xQnbEkH6KHCP0Hrz&Q%=GZ$ zDC*oUpbSFHYzdbsUoG{rE@pz-sbn(QgR-%CX&)#=v!!2>v0DJLl88_hJFj`aYsdg_ zW*YqhY6iJ~4QyhIA#j#z(vnONWz+2<)9uaMOd;K~7QYNSyOt-L z@c3c&|D;Q5uLuikM;3L0qqJVcDe`4EOy6|On?SnZC(^3?XrK5#aRuJ2&J#c%kqcK* zi8xL**9s~YTl$F$;brI^>FIcfM7?OcE~%q2K)&T~x3`hPHv47K-Ds7vw$6X#Hu+%K zAu{p0YN<2QlV5Ah`>>|pz6`S$y~hbUYM@&CtP(QWrXdxGn`EnE`cSS_TkJjgM<)lFS`rab$CXFWsJLeuC{;oaCs;d|$KhTWgSgYp@3EgbnuZ|i)wzIpf^ zMp8$bE->ldPdh`^W|0F<56Wes4?=yZD{|#5Cs4IJgxdXxw_wPd&lSINc6K=9G|br3 z&U>$fx!<|kA8MOuJR(Q-|q>lq6Z0M?jvr~+7IX{ zjb2HO-2)fF$&bgq82#_~84DRcnJhe-0BQ3Yoa|xu?`z%L@Y(#%nA7w`N>FemGqd^*9fBbJOlC&T=9;8e%*O+DgQe*RGw4Ci;Cb^ z*R;z-o9p{oFW5Dn``qLhUxFxhE*$0W=!QmXhbQBzK(+qyj=gvF<+$y9uWYD?yhE!I z)Okp7LfwAhqUsYVKXrLDy9v!y>$HKO@_^&*F+1FmJL z>?IiiK6BmYT1?{b=UkYpioPq{D5%yN3*Hx1yadDpvc(q9!_EYmt9!{_OuL2wNqO_I z{~jKK(yM`n?&MnC5=rcD%AdPgQM+t8d5%73Lw1v4gZO*Ha4)}svi^Dy-c!os#bEfC zAs~{(K49yx?bOHQBKltqJHDO@b;IH#jG#s-#yOBoL=`vJ;BG58lrpdyfiLbaGtKL~ zV@XfF_u_wUruL5s&=^H&xt3lPZJh>y65hmtcI|w~N#i_MiitX{4jtppda&-c1N+Pz zvduZxK++oxV>2|}t?YL)_=!*aYQcPCUAPju%9baY@g6N#FoM$`vor(60MTf(*6M~W zO|DQ8Taj^u);b278B^@T%lKKX~$< zidBBaT-JfUX8S_JE1J`mi19LJ9N7mwj)OJ^6L zz#QRrW2vh#p{3G0_a%Vgxwl4(A(VW; zUI~H05*2lw-XbiOZ|LYbb5gPkz>?~QzOiAYb1nkbh81;I$#*Wja-J*qGHQ~5jQK<0 zjK;-4HB#fIzw)Nio6a5(o}wJ{?G+wzMl260h zX8X@9rM(a-9S&&?PNhKU^N8J(V{;v@p#GiTL39fFx@BBvbJu}OIwPYeb&DOkj~%VE zMM{CUNY<^hh)|ODycb8t`|jYxc3vy4y|Dga7#&#O9X8sEx}j^9pwbz4t5fdW64d4@ z)UT);;p8KV{ERHJlWh8hg{Esaqqihp2SbnO(#;UaF!Z0LCn@(b=_TcwRMs-9xH4=} z7s89i^}fMevwd~4wH+E}YnbNJ+_*aZ+u6_f3xVza zCxAFgrcPfy^3TmTSaK~tpP#!`$cT>q8&3?e$FY6cnzWQL%}Zl1C}vDGyFTpC+Yt(B z@+S66j9s59X+52u1#09TF9|*=>haGMp7*?+D;{9b@VBN z+r-&5AbR`$xLeVQtj1o8*UIjKIg*8g>sZ!@0Hv$_-9} z%wcl1@YvgHZBj?+!y`Z8&b$OwyiUPAKL`1Xa)+d^Ncu6!+ue6&BekAJFiNK1rsb@` zA>e&YH=#E1(Z*pKz2GxKp|0T+`$!N+?OgG^-qvd``RtjpV}2K`IBS|dZS%kqN^4yv ze*I;s4UuK6*c_n*`IURxdhc(Uiw5DS8Z5bchjygCc?=T2B@1uD_%~N>0+A%z8ocWRYjR>*;v!-{88kF@%yOv*{jRae8sW0Y&u4$V zvo3lP%=33;4H62Iy8gqtZq=ejMmmLLg`f8YpHMo@4Wq9pP_~j52Kb(QBqV-c znA4%9-ENy!W8uwJvpF^+YCvj@%)@O1`t)5LC5h`T<>ajR$7y32^%OjvM2E6@v%~0W znP}cj*7zZE>}3)|nq|A3(?hXuOiOTJ-6TW#Y~2m?X>)S^*{L4ytmT8%Jusk*l#4uO zsU)M}^>Fy|cW~+0AmO?L8162zXmQ70^2VETc0+BdeUC6GXCdI8>aiE zl;Knb<%REqM`$7uhm)n<0sa1!`=<`QVrG&p+h1dPQ!M@ZM8T;@K4HqJ-+07W@v1If zdIF3jx{X-{HyyIB%YHh1Sa==OP_MM%7905d&i5+%dz+G5fT%=LsQ}}2f=gn^ zUxt!zbLrx0px44*Dq5D&4|JVe&^)DCPjq1$N>^p%bC_rfr*;sgj=Z+g#hV>(S_@(f zWG1I1bVZYK;*s{Lzvm1+wLWB-0W}q2<|`LiWosSUxEix!6@{(W=}WBkCn&V{qKZZk zWru^vJXd~M=x+5I)}Ox2-$X^fZG0i%D1+;l{6G*9%Yj|vDp@-- z`2NNJMnF8fjbpyAQ;TJONc|d-!T?<7HN4ePi&w(#2Q1tK{FX+nTo(vxbJ~9*fy;Zj zOCn67VHD%YKHp zHm@_CrS*G;W1@YvJ$-b5p8=rN;Ta)GQ+dWVjoUM;)9#V)xy)3m#udr@hc-?0`By;z? zbOorBsSiCus7>^u&c$2$1}=~X3X>eivh^HNI@STMqBsD;qr1U#^K?EE&<;JGAyVxj zzJ+z|hTnCJ_eG+-9vZ3h(xzYTsRCuakHB1+?}A>}MI>eMU1!efWQ*qB%Fd@k?<8!k z(`+{w&;69-%O401DM@+Fz`*y#`$U@e+B>ojUd)9IKlFH4mxrva7pwAAC?n<1DVAD^ z%c3U2#JgT0beN?FO9tlebv+tjv}buZH9k2?Cc}h?^bhZ?XKT9D0sOvr`9yvCuDfG( z0^P2c6v8~9hz`n~qy2Qqv=e{+k5em|S>k`PEo zC_X<*wb*X81FAh9M9ZoTpgN;r*messGqHZSYiOcUYPxtAyf8(i)((y*H!1DpJrywx zG%Szw3op&P1wTu$t|(liVYb-S)U&@Edp~|kPtbIroSA)UFom*$sBytvmPxsaK7Jpb~n?nRgEA?B(A!?k0Qf zmZWc_tW)`27C8j~6Mk5wsYPTaSCAxm-b;6yma{52fdm~Fge+8jx3vR3CiOJ1tp_b&FqSKA zE6hSl(iIMl2pjp069;w;D)6~_**9>sy`$^tNE8?S_300iUjXXNJnSELKthvQ9e-=u z2u**G>b`($pI{Tfm($I@4(yLmJ*C9_E^X`NOFExc`N}D$FV7C*KV-IEGtYA1_k=Qj zfDQf_zEK`AAa75-JS`y?cUm$j{!@!z(Q>ceylRKd_4%Qaf@bWbo` zd!OM?W{Iz1R}KvBGZ*%5KR3aotr9u;X@rIf{OU_Z;(x`=p&1TM`rR(CjZ81#z3@*d zP5AjkyuV^XXFLQe8xiDZee|v~^W$q@SqC0LPK%~wGgT?v%IO+T@>d-T%Y>d>Okgez z&(_jQ86%I>)eRKxc_W(b5W9E2Z}mXGFWx3V&@)CribTVKL;NZP)yc5jIUv$<+z)5N zGuAQ?%xcVePYq<98qFJ0EBqO{X^48yJZAp>dL3AJ91)#p4>Z*IqKo8gkzUADviH7$C?^3F7J%Mzm zDY&Rrs9{cEqNc|9sDsAhVN%HyT4>TbrO;8qy5(>#?SLS&Q231|GZx)w?hC9xxCV@v zBcra@Z8ogF-ZFASM>GGD@iW0Oc>uH_H|5SlE>%zqpo}%Dti5&A>d&H&u{Kb_E?TMI zm-z&%ZU%So)F9H-+vu=KFh9rv9pW{S(O7Q3rp%nWG`d^j^9W+>*07V>Beu4Zm{#H9 z04u}Q`mxt1E*T-o4;Jc3>Io`q^<`oJsJD9Z3VvVuk@$hc>hT+@vBw*xWw!EKY93|W z7t(PjUiucJBhM56(jS4Uy)BP^U{k+KZ#Kr>$lgDS>4VJlx#B!eu#mR`zfC=7C)iiY zRBipG_3z7T@b6=Wo|rkhmw(6Oy{mk=(jD)>sMhr9x`A^2_>QqlQ|-m(JCjbip1+1H z7q?!#%6m8Xp!S=%;pkad#mAkmIWbDQ9F-_b$zg!)Q=fuV9+lihB#24Rp_$p)t5R@C zI8198R}FZ{C8n+)iyU5^&J*eDH#( zpUs@MgNHO5D%*2ADMaRu@mi+SVM;}-`2Dh1`$1QJ3GW4Q^tkS;RXFXvC-p7br)H=B z`M28t-=>BC$-0P*{W+P#>Tvj*+fOL}ukQ7HsdtN1GUu6KwazZL47wB%)`o$GB5 zTS12F1T~8i4|u+7VkErWV-G}cvosbvEbM|N`}JM54V;Lb@_Dv~0PBTsW)sE2Q$HV# z2T;~;O-`QEQ1O;dFF=HP=aH9kNI^K-)Ozpd|z3oc~y5h3^#Ou`hXA3C_zsf?+h`2W20#Rp36 zyGphUKKJAmWcJULnM7ZVy3yo)J~KVo)CbNO9o2)03#!+<4VV_?7pf;j}ZF>G0 z|B8`+^y$-EPluvehSIALVh(nQUA7W+<=x?2ZsB(cP%L9_iTON*3OQZP*|(BVg>C({CtsE3RlV#3=aI;Ughq+grfc`ck#+4X3?Efzac@ES_K(@4 zf50<}R3oWcV8mdDE3oUFD_8dfBlqsS;3;HgQXN#5=%shC-2kAV zXJqf@lXj7Wops?AK01htrCh;*I)K@?AYAjCDx7$1_fIIg^(8^~A{UjJOj^iqMbhpd zd@QYj&7N!6{5bn4(gZ?Atc+majTM~r6~c7$^2cnT-2+RiM6uMo5AnyEox5k%|M|l# zQ~)XOC`thb5%ZQKFAjc-z=Mc}^R#ikef;DP!STL_&D&!mGOjrnJ^p%#OLOsGr+ zziPoc>e5>Ij~bM}M?D4cQEJ`tx8h5DX3@~~P4|ug_$DV>t2}BE1oD}ymt8Iv`?Tz5 znLB}bmMTnb1NAY?O9$f()3$p?9}73ksebKb2(7DuU@rGJNNKjm3H7&hzBswcGBE!0k}%I#A>26=msN{PbHFn1y-RE4Zz8 zL9-#>N*i#D5WDKz`DqNTL9?GPMLyo;PL*_eGU%{){x7ogADi(P4fIQHgO!N!K2T(i zZD*R19_);bjGV>S_kO!q5}S+qlp#LIgf-jk2DR8$~oE36>Q z;Z6lSKXFLx105(KELBvb8x!)b3P+xx$5#|175$r*B?)JZq>1E#(+&)mMLsO{W`-rz zOZ0&7(oN%vNbR%1;J?;DoslN|{X|0H_N2nL2;+1LTtBKQqOs$U+%h1d-d?Z03p2>v z@ezRR2&;F(=-7hZto8cm?#W(Fm0_==c@F-bh%I<&xRQ1FCxvOE z#(zVdL@O+NkB#ejNF0^Yv*i>jv8@yI|2@)7?mhFCva>026%c%bqkY@MIioGx@40pY zL``;_2qKj`@Qe(OEUWGJi{DS*J3@0sn=K>3if{Lv zTdFTRmlFqYE0V=rt^@XVAf^kCE9GNJi#B}8~&p_t3$c-F&Ig&Zr)>G0uc zn6)VlxTRcLd)pQfVy&$6ovW$i57a{GlxHgb{N4qP^kvEt*wo#KK!3=9p+_uSqyyzJ zsn6p#qQd*Ee6a?uy__LS=eZL%Pher|qv_f`|6*3l}hi|re*{vtvCHF!P zCJ=IcACIp9-ss^~t}4nTzkU%ccFXfTO)G~K^9o9o#_7h{ufWi&$mrERWVTP2-GNkP zOGh)6>Rrz+J+UI%jtZno+yW2V@L*Bm^#N7BMPt9V+F=Wy8K}w?q7@xK2#2z1TKiD7 zPCMk+_+E|Ut<0DUO^`UD63r9krQ?MkvQqs`h!AQv%VHvCFQmcStRlc%!y0e*0vW?D z6s^L}Put`3paI~Z*^^p^fo|fQYmw-b^ggVJxss|^rTm`0&XbP8wO#DO+(oc=RC4|n z13!@?v|g;M%}*KD^)DG=cnM?yHbd*qpuK$N_1d!oVfq*8fC%rvEAhGABh~E(N);G|>HVL%0EA z0zXyet}hxZbhIuu zy^FUzo}zUt>&0p{(EFx9?yV#&g^j?dT!tjwDeDc z6TS{y9x7Qy*!Gr!*I0AL2qE*!CkGBvQKQQp5ivX1H9t|l+#)pxuENT3=Ye*%q%9k~2u7imhO>KV2+z_icb}T$u6{s1pTI_-1B{nmB$-qYjaIPK@-*-H(q9z6pcI zPykRImRx=3qgkW2BHvqqa!Iw9nV7KPhdW}w2|EhZp(mG#fHMh21%w61cdB50U~b|z z@K;~Hd?|7wTD*N{GtD?T`6?oIfcD>7Yk@j8W+t1}6 zbJ5Xl-f5z2K8)WN&qCy*BLk7Gb{x zn)^-tLK_2wQt*bcS9T-N8FPDM&V1A7U_?Om8>8`X9&64KTcUpBNZgfc?Unn4vl5M{ z%02_s>;C9)Su)|+s5uJfBsH&m=o5yD2xn=_eF>Y40WyPz0$tsS6OS6ErUez>;qSw;BDDPnL>A8fEj zu-DRy=qwc5+GtYLzUJa2>*BEuN3O9Fa7R|c)CRf=taGXwxXiP;-l~%K_u3Ku!bH5l z#M0_)j@vANv&1LtHo&!gi_!D>M`_>OTKw=jfb zuR_9IAP#;CHn}GPOsj)Pe1v_IY%M`y!>)$O1U~b?N~L&dE>uCtZG$|iN%f6nsh2qk z6KQcz6^^mX^JE}du%Kj8?e}xYm29KA>2Dvt8J?u-Ok0vK5U(07;Z-3FFcG!8{2OEQ zFML1Vp^fnkTBR&ZvfP_tW6Q`zbcM#t)f=VGT9j~5M7AzJH7B&<13Pc%O7u;ZU5Y!Z z=?!7qQ?S)}IRMKpn{Xj#XhxOdg?^Y8OhfsvOz{t_C6lIV^BrbAO2uM*%3kZ&L^H)H1|)o!$WrkO zwOsf`K6`FDU$~EEu*%q`yu4pjawz{B*|fZ{plCZ~RRlByTHZeN<$wAm&Qb|hR24XG z);vtK3+yYiOEkjbgvv@Cw~kQmWQha0fuV@Z_xmnNe|U-0c{?d4@Hkib7bSr6?AuB$ zGyBOkl$RH#Zqd!Vl$$9!lK(;C|7T14Z;jo5;8G111q_{o`P~j9mNSmYmmJ?}wzWT` zr%+%%C`^w0ZX)b%)0HfxVV*y5B)Iu(dSY3$qk(XYKKLI>+0_vKl7jyHoep-dqbUf| z%kdu9(Qb$C7}em9UH5sEY$nHq1d^Orn`w#pMw7q=rVrq97)rSt&;}wh6iIG#5!fbW zr#_T8Bb#oypke-}L;WJ*OQ4GcQLbtmqM}20MP6^Rd@8gIxMzH_%2>%0|Hh>oYj+7u|kQtC%c*MM?&cNqe%0hf97R`(;VWByUivO zwyb4ZOS#DZ!Onj!{I@cTu4;|V_LixOpC8|=Z|E5BFkffdzD45O-O_KEzAeCC=z82k zsEN%Od`^Lp++jZ=E7hJebzG3%4mEyqw6%lUAD^R#>o!609>@7QE)WtHb;jM`>2EuD zlp2~_MvhiUQ)YE*dqL8f!Q;@|ni?5tdB^mVK-5J2qcDHE zh4%r^cjY!NcBu*;InF$x^|;Rlxnv}^`0R}zg^-MG-_mw(KBprhY(~Q0%ul+9RSshbLj@JRo?1%8lO^%U}?<6`Qz#nwIx+Le56@3 z-O~cTyOnHTcI3+0ym5Bd-VDP{O|~|rQV4VGfvJ+1h-$2;@MeVLPfQ-JK}79F)1|D2 zhu|$oB#&_*bZ=^sa!yMoo%OGOrP94u7;Eb{*t}J|?F5$3xcUH^9qkmtTv*-G_QtX; z1DtiaB7`5OP?XOf$}kc3GR|RR^8W3jQKEjkhv&{ZSp;2~Wy(F?g7VPq{V1kZU>x*J zF-fR<7|RXydwV@@^vO_ z(Qehf`ert;O`Uy3&rckJ2Dbp zZzF=*r6jOv*qhRIy0+D(kg)o__>s6H5;2GaDcj%S7GN+{X6ud80L@IhDV(a-IEW}z ztzQp(SEByVzMz^zkde7hg7m*ZH$HGkH}H#~Zr*jB7q>%iw>3Y8scGRkmoscW6e{3s znBToAcvJXnq_h$}=+}#;p;L}U%s7wo^aiNfUY&9_CN&j&icftlr6OhAq4M3cB1%n5 za>k96P>49u{X4hZCc?|1G=TeEz}snrFvxAx@oFtEBlxfbwoTY)f4BI;#De>el)HGT zBFEQxE9K%{wHMUdaq;_B9T2qs)WB`>{59E$!>>Sx9Si?L1Vqk;@LkCRmDH{~Ep9$P z=XcBX9$BCwj#x59u*su8+m=7f>#^H(hxX{#D;2Aujj)fZXE)6oWN1CHk#@b*bw!-F|l9 z;30}*XP9_w4-ewuzhtYX{5pOcr96yKQRM*!&Zp9MPiYqd(gZm~hSKtxmIH|EW z#A_|;li1cRXZ&RtvQ&*h)0v~fyRJnqTKa3BwcSLb&!d_pCUZSs(#*>WR(2c=AUh)5 zis~#%D`*!ahBv>f7>R!@O>`}OPoz+Hs*WfLzfszsV(hW)^^KC%$vV5%g5{cmL+Y!o zTY4x8(|8(P>wfeQO-mhoedx1=Phl$TT)=!QkTIEE%QoDbyBVURTdf{9H~$%y4A_{@ z7)bBr8d)zbdryxSoNgGYBFj7OD^K8u%7laFNM^&o0q=8tECP2w0?Y=k={r>f?2q^|VY6Aa z&}mcsavX!+FeV$r<9Ka6b}MSfX-;%Lr^tWVd!sT;P<+h;=(`++20P*DVyRkSClAoW zX#40t#ZBrgpWjk`0iDMFG`VVl~UZp3VQ*7s<7U(E;yDvr29?PwAR65h)yUqk4rSLIs)a?DuaTf*IMcRpTWcxb`{b2=JLW(kkRVuIsLdh zPTw8DlVx+`>Cj8vkqo?_&WO&8GKrLtRah#Jfo92x`eW(G9GPJ|H|xfytvBT(enlO1 z!?cD#AS37DRlm+y`KAWZUmON2{#VB%3p(Rn+l(31=rJEdHCT*t^1o{kzI1x87X_Nw>qqbl7VE3p5R^}0mPALq`>y9zt+qHU z0$mHAEqERfjz&2AdRWr#r+%O;iG&uLF5X&9S`6iFtG=<38lIz1Xe<)(!K=Ouy?J3nY*HSc+{hk3A&+V^r59KeBABDBn6FGj)2zcHYt6E#>pWl@0K>ZK zT}<{i^bOp^N5is3_~G?Sea_b0#O_hE!ZHKz@eIPSpt*xj)|8>w=#cH0Zc+a^FeX5Fy)#5zJ~tm z`TT$Um1z2d&0}Vb>bc^_iVs&{j@$K1t2DJ(&G+_XOB~VF2dQ4DBkZfdyJopo-!6cs57E?pw+#woMPLW<$~e?Jo>O=^4P2E zIK$qTI4&jq9${xOf|)+A{No9VqC5rEM}#|UdVA1Hmph0uJU+PwQP5$26PoAb&fqEj zbc}+#-OzJZ(U2Wjwr`B!N?oFIPIPmHnSsmU+bTY&Pvs0V!e4#Uby4BBE^HwdvKGN= zkR);=lh2#aoYa?%0&ZyJz$VJ{=T7q>6U|0fG!N$?o6)4#smt5)|8 zX@h=&wp|ZVd9AtTu~pk&X3gGZLk^0KQ|OH5*!!V9s;MS6#=}^`jnIo67@GD_9}GXa z`hnp_=JIHyNt&Cr7kO^0C~0rO2yUAkgHnlxUvIAkvQf8~=4M8r(#>YEH`3ko3|J4g z1BGHWuMCE-Ie{ggr%owHp^w}IJ z!a3mYe{=K}MCXhFz|(SNjHb4{#shci)_{m(<3W&v?wjgmqXV>Cy_%#My48swekBIl zKrXF&%ukG1QeXmk>ngzluaX^#x!O#Z{!kXX;2LzP2)&>%+~+DdEfv`Atv%l+@>Jcy zwo_*p-WN@qxmn(g4LI&9%YVJ5Z9(gc(?23!w`sQ38cB+{r-RPQks9QIptaXHn`GhF8_~j??3+c$FYZwr@6&{ zKgL;nTleQzitlR2P6XUO1d-@w;$2oRKGn=B+p_-^pfV9`49|6I%BAE|s-J^mf&>jB zDZ++we^4>=s9MLq@H)58mSW?F+Rb`y5rb(FRd}IYmP#hXPJ91;DeA2HxDBUtfgq+C zr!V^#hMNm;$Aj4^C$fkas!EO12LsyPfI%}=XtB7b<#E4xy#2iplc%K6XWuDz5lA-8 zvd8F-KZWixv+E2cYy5pgVxVuFxX)Ekha#!H6VHEfRg?DSG^)H@+re`%VS99|!zJ=y zHY-N$MUBtIHOA{TEAMUjvpN2fAmqQ#qqk<_p*W<5+c59(xwX9snJigbW_R|xvPtn-aQ(XY)&)Ss32f-PxozPN-hh`D(^+FB(l1B4G!pq z$=%Gz`Joj4E`9c9OtY&^(>j`B2-H)R&WN)(0EuDLC#F|i!34Bps+ZFl55J9h0B^ zZRb{<1ysrl?%9iCAT4>?=#5)O7d**l#!A4a&J7y4_%R^pURMz(^%}vF-B!Fxf;*dj zuvC3nfRVUvv(wh%Rfw}iiRFQNu${fp3t0`)7;b)}@dxo%#b$>~jT(z(xd~k%D*J_s<_)) z;f)<_1YWwEHCit-AFv*sjj!@WCkvD9iR)=_!R5T&9mq6^RA>QU zzRo|v5ckO*ASZU0GCT^m`9>&H1{YKheJwrwQrU|#P4_g!n#M{Da36d}Z7p%o4$&J% z9c=fYyc}1-4L$m!9}gT7w@ZGkq|s2k*7}0wt$Ue2|F6$5Kqh&MzG~lgVpfn1yF07u zGbbe0oHwX|zw{KU=)f|(fybgzQM=%Lzu-tf4mbLTdI?tuDPp&>ddqePooShOvN!BO z-@I)e$3%6Snish@Zo*c+Lyfx@(l}ZsG!Ua<uhC;fkVQ>jQ_i83 zP&FlBii$H6bsWiYLsm-T0w0D(oGx|Rep6WTK@6Z=1g%)Vu)uzGvE_vE)pIp*ToHMlB`SW=&hh2jN5 zJY(NJHqM&Xw$_R)w!clN<)T*TD`U>=16_>P=p%QQ5N*ekWya~3JVPd|)cuB$o;S}e za?1&PIU1D_K?qiZccjAEtFadc-3bV&KHu?jw1*hOaQPJx!HzEh286qgJ{hbnt(jp} z+>}4vug`icg|u=ODd9YZRx4^4k~Ux$oP<#KZU~Ngu8rl|dSO;VqpChd%>^La;atkU z;vDm{IBTy>L}%4`rED2266THb){xG66S6M`?d7~_EEKI?iORL{P1*Qe zCwk9Y5(P)x;PqZ-ZJgTwp(Ge1V?C=Ghb3;U(wo5N%Tayv9=H3C0Dn)xUd1WcS}*I3 zVEAf)My^Y+H6-n2PtVE{&DUHVD@C44NC--jyBkV*V}fi5EPu~{{-bX-g*#0!XPyg( zN5|*ey1|vDk6rmZb^6Xm-#SDoICz2%Ii{U$FoHr~je>;6-WD*8k~SFkW@LkCZx`O^ zvdeECL+KR_;OU4b_&wnnb3V+j;z8ZZFD1ju5ocW}f9YJYTiy_N7E@+eA20PX;jfjn zn$n+{;|bH?4dM>{lW%~s6Fcb5I{#gPBli)yK+m!EBK~DQgs)W4?|j;)P*>quX;ygg z{gxMBAnCvtlE|vT+DN<`o|7^@PFO#pZ8EBQ!BqcwMfS#gkgC_5+B|pbH04jCpn0Wp z@$)YSj!#Hr|Kk+=Y;kywjL+36{5;yXw!FaZr>;Kj>gO8T#!hK5$4vPX3A8JyyF=QD z?F@5b_M4o;6llA+{(i|gRDjvm9%Z!^BzTFOivAX$Sv{w&?`OJdyML?d*U5UMjEu+P zwd+T5sbivl48+6w^pNS^-42i7FZ~QK%tOwy>9?NZQUxOR+MDZJl36V z3w1etpV(?h5GMoy1j~oXnw~()zN?hMbCd85?_wO1Kr8=Q2ofLWDkJ4XM|MUwRLZAH zp!7P=?KP_?8mL&wjm+3g>~Lmt7|g(ypQ@*kEUGe)YJcl0=JB%Uv}nK|oI!WlRO$9k zdqJz1MMuy=60gM)QScP0Voi+XHN}@?`EFM;3z#hW@J8MEu=l=pn`+k77~Cbg2ju zUTzmmgep2)+j@lT{839>4G+ZJoc~G^7|J2%6*OEnhQ|Wk57U;C!K{V;$cjPyRM_XD zT$2(0Wpa>PoAID?!g?ue5i;NER*P*lt0wZuTjc!$D{__Vl4BAPE1sU{Dv-Zstvc3Z zcC&VfI&{+^C3M|HxpvDf#@HcoYFcUP@sv^Zgv)E`)8fTVo63(IxSPZ*SU6xBx0UEV zxWuZqb@F5GjrLC8g)q!E%w6XD#TVtf2hbVuIbhxAGF>H9sEfs=$>(V$NRp-Lzy2V!lcl&R5c$Q*hF+J!7FaP8>|J9z4z8KH2sIeuXf z(=|u2Y+ZVtfZ?;Sz8vv$00!+YvOC>*5R!l+U* zKF2uCfc1d+pe{EI7!BvSSv|c0JxEi#JIP&nh?4c~BDh`+(a*3&XeQ4WJuJ_hUohNi z1xT9){05&(#9iX(ekn%GQSU`8tA(9oj>F^ah~)1`{Uw|Ht14<6DIWWksho5tOb##*c=m>cX8AfUvrIyy+8sDp|ikV2&_92NZx~}gnDxxyno87yi znVk*ved3nzNdr5IPT7L*q{|8Y3+a1h;w{3B!tY3PaJ6~1D6$md&>}HcX>E!h#F((j zKSi##F{pJO+QU~-^StsJeVmya5XRrI2 zp}2NPu!c*8!%G5=igTlI2>74&{Q1|Uh(gg)TNJt%3DJtPRi4MJv(JwXw~#b#ytzo!X&t=%bb=oa@McTziG!YG@|b*j-^fEx&zzt zBQ$g}H54D@;SlT(12M9s1?fAC^ViVwwS@+7)Op|-!ZO$vEfqr}j0=y%?F}l3H*1o- z9lakB`7V&UBPp`>y-8w}giu%86bInOoOg`jzdjE08IPgyiY1Kp>CS%seBzC=p~8On zFknuNT`c%$DsY%VY7#yx-vQ6)@L?WJEUk{XtFQZnN(+ioXM>P9i#|>HJD$PDkVow zJTWA16Ihjg3mO!b|4H|jl#_Je9zYr`y;TDVNoV*wuGa942rv+*s;^BqPh)zxHe#;@ zi4|&jES9Kw$u`?E;0&imlGgbZC8mk^MdA```)F(|w$HF^_~YC%A<1W6ca+^Bp--^^ zN$I$5@cRXgQ+steTKE@($HIdu=vH$WH6)-*T5ByKZ_~DSM)%qSfhZ#B!#ML)+j`rg zXChv)3aobxfRl4IAn&UQlnXazEi(M;&G^r?5Hp6)JJ`bah^KEXOFu7Va%n&C!K?p< zGD}y{?L$0o6{JI~XHXO)6qnatZUxX#be_VJhxXc`)$0vt9 zbdgnPE8m-xUBI;TcMqs6IPmG(S^XEYfa6}8#Bl?WtWY_Vdk^*m6mBDS-%pBehd8o4 zbE#gkhJnjRDBylRaq2Sv?UWI{*s%k_dO&tc^I# z(Se#4_Uv=uBQqz&J{*iK`RMM~h_t3R3m)M8vqI}OY(0p?78#Lt6M;SnoAHp6$iJ6M zEm7Fi9AVQ%H0JzxuB19iJxD%u{nu%qa=q_arOJP_a=-U&xV7qzJY+}`D7Ny-8;LAV zw`tEakZrg^nI5Y2G)=)VftyrXB1tUzKfHZ+Jk{<0f4M255~U(h9WyI?I~7Th%HFcK z?CegG3JtPnBzuo+N=SA>_TGDMe%D*hIr`l0Z}(mL{r7&H$2sTyx?bb?n%8xCdvbXS zDvKCMdcpX)!Cstln5f9C4?pDvDFXH40>7{4d(1(%?}l&ZD2VCk2TH)?=$GV@SG_J^ zdgQ7J*ihv?qUUEUlIE43#LGTl)Gsp}b1fk@PLo1TMe2(W*aw*|Dr-?IblfX|<(=m@ zMtv2LLN5)K91X>rjvn(*95$>f&Cri-ez)$smZIegQ?8tmTItKb z;1l5&N;Be+XxDeXd`Uw5#Zu6OU8JILD=0jd`uj{>JzE<0QY%=)p63Zos<*$5DWeYM z_|x|;{IjnU-l(g4G4y&)H3)%IXZ#b=%fUH?DWWId0VbNa&M;f0QU>e8M#8ghq)-O0 z!%Q?9)&eLNvY~>3x>>^)$7#=yS0m+fwpYe|q6PG$v)(C#c7*1aY}l7;4~pY(O4A%f zX{*v%+xhrg0v1~0diuGSz@01t<0hmBgL{P%%39UyGHgU{SI$z6G%t;HpE+!OHOn&a zq5j;8_?qvq^|*ee?Zr9eh62yW3F}KVcDC ze>#J-!?IeZL5|et%@dK<<%W0p={>|1#wVez3tXkl95W=>`jtvpJ1#PF1Pq8MWv!1a zI0X)nbSz%+`GqnymL_A`Co?e) z48x@v9i;*G3SSM)9ne;TO8bBJfk?R%fve(7j4di2O0T1yh`@`qx*~kUR|Ugw0w>Hb z^dm@OD`a~J=-4kB8H4gO6dO}J={0yha3A|Nt&vw%)g^>y{tKu5~u*+V0o5`XeOoK^*jlR-1)V*^sNGhB&WN*6Y0K7*+ z`@zIweBx-p5pb4$D)zQ5GqBWam%L#|^}I7+JUtZ8L@*+?bSWLm3Y0vsV}b+Em%d>H zC+P}i_1DMse7Vj@-}n(!4y(;`z25N1S#b_Wg>z@fFgBOKdb|Z$>S#o?WC?i&zash4Yr?7 zGwUj+KMQ1QfZ5uWums=A9Z{MfzMkuwUIGighVe1ZS%w0H#r2}(;P@0r(G5?$2^WFY zJN7ef{MEz;&His>r9>Vi$GJlH6>6Gh>e+f&tS>ljSozVJfVqnVcArK$j~5hs@2pdv z&+>V@4to>p^ED)kxI9~KUc{qDF=S~Z0yd@CFj0D5_i{qGB1gTpDu2kA0T^F7U$p;7 zPkn9qJnXeyrM`0A%R>6nK1C5uu6mD*et*65BC9^tFXEbHC}s>j#n@>!Vhr>6pIId+ zT0!AhxuC~f$B8cqF#ZY^0_q#mrW4i1f;|*``VRg5R{qg$A}xHhW(K()n8sNQo|*AR zfyp-Sag}ebyIUF9LnlKiuLswxwpQ`6;&7WyB>KP}i(-6PoxAwpMC(L1fY>->_D;gJyaFy`jKLe}t>$%Nn#}Jq$S3l?dXd-T6!IvCWdp^H=Y;&F z#{ImnjjdD*El`kJoYS#3j`LRt)m1BuA@(&wP9B6Y;fWktDCxGdja+8N`qjpf7*TEfNIyH698pkV9l6Kkkc{w_nnP>(X2*jVgbnWuk*VTa9wh|!Sr zXi(TS{=mQ5OC>`yxLwU_3wGD(xLLLLqk=#NavtJ2ADnD|iylsp#%eBZ4WHd8_hCQlyXDZH` zY0^?WgGP)t%QK^m8l_qec>{bCG^OE9C1uaVy3-V?3`>>nzQ-!|$)Al#uny*KlvQ_U z=4!k5q#KO;cz1_79ijz+MoI#uhBD;^HGB6sYxj?#mGmtE`WcnBHyUyDNtnewm=fYE zEW$F=&Xjd0WOhGI=!ezTxvH#oKhx)&p&#+^Baz5!NO2^n>~m=Fev=%#x2~0`He07b zQzn7Jxtzw74CI6MPr)THCi2=9+;{s2-{sH6H*nd39XVbLrJzldImh2#F2d4b`mADT z>RLhwGzC)(4J$oUO3})Prn*G(xZ8dEU0ZVwgX+=Q5OE0_T@?qJvN>hOETYntz)ub$ zf_`t_NCX)h7PN_)C(P=DeTmd>SNvXdoCQIixZ6sO`0|(4yt5rgn)zK)jTLlrIy%4x zHNzb57PZMTafg&y601m@_Nyz?a`TA8cA;~p1G5~V4jk||4QYu(6|S(S3P%_6akATI z6bxrf!&*Aew5&_5oz8$CG2bRh8V2b|(k{`usv zlY;loy28$0SFMB%T)W$-wP$Sj+pzz&7hPcL_U*Y(2G2xpwkcnGV4(~KyGU~=Yg_LP zR6fJW_3vzt1cwg2deBH&tH|;~4?~l|fPDU0iTLE%0q%+1nUXlQpgrStG#wl33*`?T zDnqLY>%APHTjw?Rj6+cg;l9MRevSgUebqO}`=h-vJ@~<9*7Exmo}>W|b|4xb)4Ps= z+30kZihK<68_f4CTi@O$u;W_e2gjN{t=Q|l2VsfGm=GVcZ3ZX5BH^k~6uY-0W)5Z~ z@`XiN4V(ku(|bkaqeQ)D`hD0weM(2&2A?+*VDiq`Pc%Y)Mt8h!p1YKy%hn_H9YtQ* zg{I(-5>jQ$S3MHapw30`8!8+ve|mWxbRCVg2cA6&DJI; zJLbaJ(Ea8cB42$3Z&C%B-}W0FH8i$Wm`bq9ixu^iZZRwg){3W{38PI8qI-XXKsaw9 zZ-Sn1*q!5f%yLYrB9ENJHIKsRxI|4-ma-veek!;T(=(K&X8{;e7`J_64^)XYO-Q3K z0wL`BK@$;s5oI4tWx4ByBewIg)zz?qn8b*ZGiBHT6pbbxmQqgwZVMAo&dZxld}=nG zad@%B>SbfY*P*e}2Ab@}KA?7$pdl_-E(`S~<0u-gH~Xd+!lp;kHQE-z_0V*UijlT? zb2bU1J{PK0?CnzXvKaggY5WF69xQ-?iB@5}eVWVW5_^h0FGYEU= z1V+m38Z9Kpd`c@4Z3L!IDi%aGE*RPdR~OiXm>Ljp+>m5;G-a&To|W`q?N2>7!|;SR z)>f&-+H}43FceOSav@Zgr<SDs_!m^|rzRosO7qMj&4AY-+6X;BUa-V!DJL5hT^1bklv5xil@NjX5X;0fj z>&+&i$1#@`$uE+zY!G5Xn<>fOao}hKhSuWP_?1c7bP{UQ&x32@Z4Oh&0(Uh#R2k_@omK&Zfe4}^zxEjD6z|2=oA6U*49A#}> z0!P!!!9LA_kyE+El#!+9;Bp}5$HRwsMsGrqHi@kOaHOxe-m4FU(Pey7D+Wb5CEoeu z=ky@Z&wQpjRL8Z!Tuvu(3ItollmP}`jvdWXRyk(JzPG34fm6eRA%BNKYUSstvQ3w9?o-pg!D4w3YzyDQab*4e~(A)UEvSiaQT#kZ@pkXpF@Z;C%(lAmBjz{s0`b#rHXeLM?= z1w0v*bFQ!u>kov%Hw~a@ocKBcOFdy6ov3Y!bSgNo^4Pm}8+|{6cpnSzK*o)Jho*96 zY0wZc9+X#!e@C@pwDDOc|F#_%c{E;oXKUZVTTNUCT08QagD(EHP)ECe?O2gI@+<%b z^+Zp)L4oxifzNZ%aTj_!<_+~viraM)x@z-{$O(BgP-TfF+Pkf=1W&n5GvY*4flGl! z8r{ieL-%_X@V!}E*ciX1VNW$8Cl_$dBh*b{J%z#BQASE%Up>elK_&NB8F3}Ce%viO z(D~?-S8CApkfe4z=?T*-S0NapxTxYW-+Q5@KjmZJ=4`+sO_?K@Iw702TaG)d)pkK& zsh<1ROlQRtSb;w^P<-G1k%~De5a?UJU6K<2an6mUin@`{GxKhW$2>rvYWnu6XI4k$ zQb`guc=N$Pi?_%j&m^Y4*N5$Onj(+qPdcl+Xtq=N$vOy^V7C}g#77q{84of3{tM5`>QXfLHR;($id@5b{T)F)mm`DH_X2nCi_4!s zS{g1qNi&I!&!C+Lr)sHzSpD?7vXcXGx-uheJ>#53#=NUthZ!4%RA$4DyH_qeX%I47 zcH02MlG0G6jA0_ahmGb*7yn$exL3i;8?Ua$jxDY>`0FonRa;j*9Js15)8y50^sP-u znYIdnu9hJug~*o_BY}21BYkbgmi4ucjXcHc?I1yV3br#ODy;D0-L!0AiI?@h0@1^ zUGwz(^cu`;z}?tRJsE_8;+$7RE?I+#JTH+wvFmL9U*}9CyrgLbT+9xa4XjG$2lSfJ zG{}vJhkcL`=Sv^xnUTwZ;+>hZ3m>Ph@lVWbVA_GpyFyH--&G(Kd6t5r)&pc(vOJjB zaZG0X>Z&Q$WWgcXJlRRLS4hNsRTI^<8TZMPhdf`3^=WmP;R;9F$}UY-%=+BdFj-?$ z{;R$j^NHA=ZW}q^X%(CfG%id97Lwz_WT#j{mMWNU>SC-?V(UN9qugWkK$faZ4MU#8 zX_%5+=YcCYo}pQ@a|m;>Lgj%Q`*nvG@O+MR1>IArq4ujDPo)7mnl5 z1zgAmU5U^4hoI`~i0_=UIdM}4NQ zy@0wDOPbT~>%;}}@JiZ}C3=J&WKl*9L34y>dxGIZG`g3YUnPs*EYHYlj{1BZ<1$qZ zC?WjgQI!1|0=5 zTn#>EeJgR>=DN>wQE~cOV>J4F;9d$bD08j)wyfT8_1!l$*J)m^GMO8@~48eVhVt5a~i54)jl_ zp`9P1(lP?j#!|UaaMTNF*~sujb@7Za=(KE(gfpL!^0-HV)2^ZKAtz8pY~>+a%<-sk!xvwm8>zaJxm_xO8*+ z^jcYU3S};|SL8{9$6Z>HuI}KaQ#q?_juL}&Z?gDPP6w`2=_+`(FlfY zI>hF|F~cIB#Sx@gj+&J=;2=uI#@d+xk%SG!nXHgNu&a+$1Shp581_=m`1yOtZ<*5B zj@9*$Z7iyR1MKM=Kba-yoz`%hwhnq2BO%t?IFhBUUm(oeeWZ_%wcxm<{<>d_NP>^8 z&aye^u8G>VN3=yl2kg;#oM4<`YP?xOGpA)V&>k?NlWk_3VenSM*rQuoDPWY24#5I^w2^c(7BC-lheK5)E50Wu&o7Tz_$#cCD_c_9@hHg&&|5a9&>d|(rh}klPVb*1^i6=bSTwAzv$kcE3Zu2EP!*@5n7c^z$xx-} z0gXIuh6cOoiQcBGSA8-TdbkY;SPem#M0(k8t`M4xS8oZkdpR!}Sy93%9!Y9gnik)f zHrCk6etcml%`l^ir7hWjyW;Bzg|}>2cubt1m{prWMneq`@nZGyR5pIY0smM-vn~#W zg^es`|50AU1+Ss1fwHPTdt{*mnXT=Dt`h|nJ`l3f(>|?*$Ov^eL`*(vy4rzk--+$L z_#oh{GT{%>LUbLK1;Z0h!K77u_zcwRH35|a3xk;lh2#f7h4G*o*_`e@%w~@Z^7~H* zPc=&HHr0r(BQNNT?v>am&!y29Dk+fXTG#8ipV?Bair4oAv&|llNuu!|YC?uS$ArS& zqY6e@n#o|w!ZK|cnstWmlD9&UuGzj4WP&ej!@2x5<526o!t!06L5f{u_V;cm;{CCE zot>6q)%~f353t&-542!(RSxj$ko@DDR1+{gP8oq22u3hA5UU0n$RnI%;6Ot8K=Usm zq%FDROi>unc&%_F*!9#o8CH$i>~PM9E}?qgEi1U0| z*kctQ9?s%;mJK<;yzgr07|+)|7UD9f*6$H-=VL!w9xKIDs3lY8WdUZ|t@z0fKCf`X0Yk z(u@&0_st<^E*h?IpQo&Q*_??j;5%o0kL~SvsqHKk@goC68L_}!cR3A$CPQF`Ohp;G z+1tK}(VY?i&&!uD)j;QEgmV;lQ2OTu`WzePdJS z3Rg(s#JOejGWGC3DHM|d#s(+jw7-hbmvnRp9^M^aA+ZFzGx~4WB z=DGrk4_}fiaWU4;*36S+fl!m#rWw8W4&VsnL>;=Hf|M&-?^ff5?b3Kj z3j?WK18fLMFFeM;C88S~mIi>85M=NJrf$7Sl^XNPl`D_JLbw5s5z3fQDOe5M;78*P zwk4b`ONK^AxyJfe<6A&+J59aHvS1>5Su*GiW-m+Zoz1!$c(;({Kn*AFrV?>;D1yaxQ$QT z@1fl`)5e@wv;Ktzm_|^;5?nIB(YUV~do~%~!hN^Jc*wq0NDLJL{ToXD-FG@25LidC z=?);UaI+(WHB4O9V1b_BO?;3F__-C`v^1|B!H^IaSXT0LtKCOZyr*!hl7x#xehwA- zhzt!A;C}lps92xvNX9n&5tRrXaExkr6=6+!>#<_Fnlz7syK8!S%?b{Mb zAwF)Jy$iA0AtjVPpCI3>@AMa|Z#K$W!2D9ng6c>i-%Jy@Xl9p%3GcwZO4P`4nN9Yf zQc|exu=}%Thoq_I9&NoS2_M7o;)CO1+%8D>{iD$q@)GJO?DwWK3O?x3ze`fw_6Fa* zh;cV1mYdPE*rJpmZ%?4dZ`YW+7qUeilPJam%)@m$BjvC ztOen}x%MdWN9EzVTtaAH2NAY$JDZ{tnx36is1Oeu_$datR=mQP2fJeE__{awRUIYBO^fhSx&=Yf2)sxMY^{{H7~Zg?zD@^?RGIdK)TOV`i< z!@V^`7g+*L4`DTX6#MNr7W>TtDgVF9o?xV4bNpH@tqv2*lD^;6Ut7;*9+P!_0vUGa<3L^vH>m zCx>i=Q!*I{NOo8yUOc>oxVuJekQ2$5Lihm?U%V)ak@yv6ApZra8b9h!Hc+vVv&nZD zFhS%QYy(Ji&NbVz!ZkW_xhn$CgEMyITc`wtWCN#_{{)I*W3-*j+4ovznP~#jES!fN z6E0$ZA#L&>*r56d%4*3@p7eX&EOq(Eb?(6Eov~(THf{dA&<-jqD#N$REe+dF>YKQm`L-&`djO#Cd6OJ$6EmxG&|JD1$%#!uFG znF1{2=D~MWI|mxu|NcKR5ic3Us+V~eT~kK3qC%p+$DAC0mm6Y(Ygd5<%BpBWz3jdDs=!DV&H{o0Hz}J0id9e5aM-;hhX|kN_xs zZMx?{G@l;93pXS#U^>OQqCeXu5-(FR4U}~^Kg7Z?k~leP=uv!desP%eyG)ZNG4jtb z=DsH0@m)+I;CL$p1?cviV}EC;A3$c-f}wqGx4pM74Z`{*ozYwF@Zj|$I-6F|EI?Yb zqp@j8g&H0-krt0KMVq1-U5z(h#X=|7Y0Su7CytzHKje(|rbw9MZbcR&mMP9Zv9Wy+ z;J2#IOD68f*WcnG-a9DI?V7Jy;R0$zM1|jes*C5~-%a#~Pv}e$86BU5uUsLr&SCut zy!?s+BK(d4yw~EZZvfjKQZj36YfnGV*s%ud1db1dslQl`WJJHm2K+cdhGu2=-Qyq` zD6A}N$L))W0LeGZl_cs+!^thoAOZ)sU9S9~E4gFxy%)obyvCcgiF@)?ArICM%=|6D z-&!?-iwH36+54bzGGz8qfy_RBP%hfNBFwZn&r!^Bq6NvF(an_@71T$&_V7q9lt;ah zNq=x95GReol@QywYBA{X59Dm>b73w)5<6$&qs!_j_3j6yYTKkYWo8d2Sa*#c^uON( zUXtshWsD<47YQlpTH~SMpJ@x?43w;V+NZet#imD>RI5CTaSYgx&ggx)agB(B<|QeL zSo8y4`u+6Y*QXtVkR=N|=R(j&<~X|cRRoP+yTz^|1_f&h<~)c2yX^mj15IFYgbQ+2-$e9kFi zB#FC7)jn}xeeX%?@&{jPnAl$sCEfurp#;3l7bM`w)*=4jUr_IcUnhcc*TYnB@a8dq z>uG-PKx#fra`UhlgFBzN&tJ^x@GXpTxG z(vzE$nF|sA>^+6AuvV||YclWO4Nr$$=66O6UWdYX`=*2L;~ZP%hP8%+V<;HIs+E`pzKz;ppYwVFX515dkJS6G!+&n6s~< z8%`&f_I5b!H-KBX{4Nzg@(J*vkQ2i!nC`~?4wEZtpV;43I)SL_j6{vnPb~a|G{n~; zz1JN-U-{qO`IANLlY{);LFTvla}1jhPKcdoC1AT{;7*J+-ilU}w(%~gHy6>?WUvqN zOeIzATSFdAiudmR#QP$?bsO>DGP@l#g~@lb7Lpob!v?zc9>t(SUzIAYcj#x!^d&`P zyeUgHqfGw;P?batj!#v1wS3vm2zcjvlNLdLXEOXU+{10(V;>aX{>TFp6G&waR@|JI z0g1qsY+~LYfePV>b2W5|5f@$a25<$ktse!-&}loFRJ~^n8Pe<;M4S+W(!d*ETrUR7 z6E5h!e=r_RCD-~6eS)+<5%#Z0ShWhXUkH?D?hhE`4pctbEZ#yr zsJHgSI|O_83&W1RfT`Cm^Y9>FRyc~g=t!Z}@$KXei}_9cuh_p?)_N_~%rpsE=PLdP z`S-9f6q`O<&V#Y4^?&eqOm&Nn-7e_s2lt11gqgk~Xkx zsd3>^EKJPcv%YQrAK5hnrKQ%K)I~LKGJ2_i^ol->ocsIY5JsD!gT8tTv0CE|b~N_~ z)xoB*_x7!%e_}>M^%Mw^OAyJ{mRQJsMM75dPq?G%fP2-Sx1dy;K|!0LA|k`=XIaPJ zSNnf|q9p^B7)FD|$1tw}`b062;`@pPZv4)VChNsUBKWN{MZg3Z9 z-ivBTsMHs)*cIq}|NEPGc{g^51qMOgxATP7rqf( z1W?-CAC-86`5Bs2HI*~%zRgh0l`1r8+oB*i14jE& zf6DFt9g_TC;LUa#RV^@dOB3qdtv5DnJIi zj}?gmh_jeslqdDN&w5J}{E?^_x%RSB z4@~)5IwPhNuQX_Vj$zNP424I^wI1jU+#yy8g(C(@O%fZ=GfB{(fm&7>PMVwhJbd@L zWqR}~k7b{)GnY0MKAWp6`@<@R3xvoZPE>@v8DBP!l|r!ywZ^m?@c5Q&iVJ6u(nJF1 zfAai4{j#qIB)YJ-$0a@&Go8c{tiGt!cv4d}W+x6*+$Ohi;VfS{xiyjui~wGT;ZMmy zKkl&8_fc#4rHB4=HTP08sl`Y_g=jTPm)B-%XHLD!>rX)iOlTWqx>1<(-h{b(_lel9 zvM+Mr&B^B%+$scc5z2`^6{!g$Fr)xpjJlz<^^q6bx5z*k9S~$Q;h@miVVGto z_5D==bK&X``OFM!@-8?C*w3;Gl-;{1wnL&^NQ)U}<>X%+kMZ??X2^Gw7-;P^#E3L? z8U43fXDM(6E4u-#b7^KFjf|3@=7joL2C6?Bm;9jj@-)E7ocD=X6%ncwXLUXA*rtgb zL__NkoSXpoJrPbD7vI2b2RMW>?X|dj2bY#~_swwQe5hPtsVW1;n#1y-5Xq%#O;aPJ zpV5iFZxbDXt1gdH=~$whBMJUBdr%+zk%yYwKy;06RLvuET6X)32FUUG_FE_oFj<%( zdBS=Yzy7*=>o+m9X`~6l#aca_nGWtgkG3yT)@u{0nhx!AqNbBhf)|AF+xQnB%k8|q z10*E5!DpYzre9OVR+vq6EYUOywy0Ie_1xkp8Fn^_ zZOcUd#Sez{@5w?iV6(QSmwUV3ZNrFv%a9{vw@r~}0sP`$ z9Z~^dXwf^fK3YthJY~~#EfXAMZLH=FB1(Cf$>l359zSp#!mdYp-4Fj^e)JcK_`86a zkJivJ6bYTb^LY!kd|t$!LVm4|;3lKk^)H;Lw{c+u*HlF7hsx{=)39>)2mcX+s8Asv z`^L7x<#%yEW|({MNcK3q|27h};zY?~e55TSQjw%$V)s&op1I zfclvWsb%vZh?i-cs~Fc--9iC44u=1TchXZ+lwCf?43lrn>AiZ*?HADrwZi}V!ITh+ z;k^+{S~U2Ev!@KPgEUPkk-?qs0}ud;-I2YF3S8ZlTI zYF^nwvBB*7^6y5(@2{d@NiW3kKu+91^Gy$=+(0BBcO= z!G${EYO|VG`72u*nsp$`$5e@H1{Gs)zPc~JaP!hL6eoYK%KuimP*?^s(FCYMqR4V# zA`Wtx%qk?8s9;FQaDn2UqEoj~Wj$&|avP2)N(Q^y2;_b;a{L2==_dEW$al{oQOjuB zihi1SNmzn(pyKDN-JpWUwZnA3#-7d#OYFD^2Pv{C+`X zNCeoK@nF*!;9ObhT`a^CEPxuU0)D==Sl?-fzsIDHR5T4QOq2#Ztedyg$sxbWe zl5lnYKVYt(Bp~Xh->{6-Zx))g>vHNJXM2Aa4z(Cu-R+CCBtMG0a-4e{nSsyLQ6Kz~ zhZm`!LZM&Mq+@eIy;Jnj^I)g!1Qx$MU8E9eF@oHUSf`@B4Lx$#e-6Js`<57QNK+Pi ze;c9+JIY$SM^6$BF}p>uA)!t#*qXMdLYp6>_N^7j0%rVza*z}@(}XJP4P=AO?npTs zfU3pg)GW_iXd$Kv7ut5t$2t4$tk1t=AimxZxHXL$$d~(7bJkv|4tBC@s22VHZbTC< zK;F@bVKmHQ0`}#RND@|S)3@%tYj?N!hWYk<%~LItIB+~Cu;rgzThFzfy#oj%(&7%e-g?@NseEUIx zQ)5bWYh$yHAc($+vyubQ0`qm+gb`jB=eyv1NED5K;K4T=DjU2FM(j;J`k3A38K8`r z%MY~DjlD0lE*w@5iNR!CerQL z&6#HrCjT}^{r60V-@=I3A(D9&r6CQ&H?#ra_|pUng01z3;sOux)j78hsfgq?Vu<&u zFJK9jH?E@J!A%aJnDnZ`Q}jo>CF`d|08s)DI=DInO9v{>p87UxRBU%+D~#i&4OJc< z{BRvvvaZ<+(ku7&GnV%+p-CYnc&yhR#XgSzL=w$Tw61QG(l0RgC=FD{K6{LUE&0CK z1SO@}-tU~Nxv+Qcb}5l!_7+DF&u|3~UI_Eg>=FHfj0<*)h9Cb2frkZDjiDKv^YV3x zU^sd6V3Qfs-q5Y~9-iWXDQbNjBgPn(T1t)Q%e3+GaC6KCxFDv~Wf6EVblOxI7 zgQ&p#n(IgJJGA?P<`jkMGdvYpIdtj>ow^*I%Y$wbtQN@dBL?&9_1JDRbO}`pqc-P# z6lE11eI2q?31+Gx_aM&u7EJ?z_O~Zk5al5CBs>53<7@ep; zvOjG|X~gFf=2lEc1e)dwnbdDlg;S)n=V?xOJ?JdhS9r|7hlEp;8L zS%x2ct-!2Qhg>)-0|vNagHnS3 z^uS6Bxh22?vNX1 z*h1l-Ny4aw3ypI6;xwiG1OwVZ=SAD=RT&Z?-a>{UajN|$I^d9}*o@WR={*re?V48I zhjFWtq`rhDGyTl&GZA0sCX^-`ST=M%eYYqb>_o))EPAUG8jpXIF$5hLU^BC+lRSq~vNP~)9J_ZE5 z>gGkLvP}ilkqP&|XGCbOj<#GD{LR=Y_y?lVjtQx$zxWB<3B#QOj7#w7GpW4Og90e| zT+X*!6--tJ{QAn_h!UUoXcHj@p+igV zw{HPoE?HQSpMBa;TbEl8a-S1C8iWRKj2JA^(Iu13T7c+N)IY&RzMBU{AKh`Z%>S-P zzxIjJQK(|g@S&XRSkjP^-r21=9dnsN%J*$bwtgtpTa^LXP7@lxsFex}I2i4nWr9N- zDdn@gSax7G`rE$%goekVoT4(WdHpIYi$L{7ma6eB;(E^mTw%wlvf`@@M6yZM8j+pg zNf_qO$%QuD`|uLLyAi&-CAfOSzs8^c>sKXENztf+_aTlXd)^E_a<%I!fOi|lU8oJj z@TKno3xmof#w`E$g$o0XT_?LOD=W$7S?Tl{VzHWn(3DW$(a9v(qX z@OYRa08{w38cHE3utB*~l5l(T6%!kHT8KX3ffZ!i^LKfMk`y_dTpYqUp@5)15$%RL zqNJg=G$Hq`+IcVCCJ+b8d~HQB#+z^xh?R}-O3@PQrNpn#y=54vpxpmIQ>W1jO`~+TkDwyS!Ib-A4{~ysO_5oKxj4CvaO=do?m3GEqRZ$GusaUunw&@{ zK@KbJ236lR-!~S1-m=A=9V0mQX+X82>d;%OV1%D%&Q>wtg zYiH({HUol8!V?}Sg&TDHPMkIzhMZ;ErbNH#*wB7f>cF>2Bd_}mTLOJbm?U!7w z00U-oeWd?qHrMLo|IFr=V{c|bj4Tf?qbz;*9yG`yTt3O^ht?Xz6)XdSR_b>FC>~YF zg(i$>?7JlvxP1zaTpbbBUr)!-gT;o-jCYZL>X@K*aoo_7UCZbLdb!-d(N?nKjF0w^ zn{0^{J_SX{^&g8bUqu#Q;Gq)VBb1;^FX?vO8W0#zSw$xF^(!D6yKe!emzU=Ck<~Sn}L%$58JlV zE`%GVcf<9f=vY5ydAI~JrpNca3hZ@dO*%I}nELRx0Zd;(&`%Lb3*%1sNQ07K*CFw|9Sp zuZCvJompH{OhGH%AqgN{7n}iRq{t8rxPs{kR%P)j?1U(glZ^l%*I<$N`Igep4xB>& zHClsy;^E*ekUccA@0mfDA8M{3bUZtw5LZYBjBcR+lk(VOVl_dwsW&~`$kQr8Cp-Wv z%)imLlReQFHFf*1U;b0o65^hAky+kbC^`Cl;NBt3-mXa#T@kPRw z>Sv5w_HT@WnNzw@B+7s9%C`FB1Yo0Hh@koIAH=()QA0hu$-ie?xpsj1x)C4MUXs>I zoOZ+S0Uelf4a=50=v6uGhdQ*Q@F4~mE|mc@?xx$eEF#>#YoFWkuju(i)VhB6!R-jt zJ!U-|5F|vahEgmgBA|UfGAiR+pCHC@1ScMEBHehq+9#B+54`|HOcHK+4r$#e*8cW` z*|DUSamA%JR8DvwP6uW>z6qf+pHNX~4-<&l{qo{aY{;es7-ykm<#idkYv8vjL2(81 zDVPLK_!ePktXBKTYAh(;59#Im&n2a4J@wbF(AFA9M`^0d7`HCFMX*iHPUs1uIW%(& zjQDJ56y?MD_?;_unFy*&1U5-I9J zUQF-&{imzW#JCS!;8@sw{DG_5U|6;U1xLK3#Q&D6Ep9qLRZ14}5k;5MQP~_zLyviu zYFL>V^t%xcaaHyASW#2*YR#8sYr02>1r`_iEe4;!Ca2#Pz{s;DVctkDp4;(*{m zkML$+X%4Kgf$#u=6x1K>lJ@p8LgDxl%V*Wwh?R)~fvny>Mn`K4aQ`)>3DV5rjhN5) z=D)%E)>anKO7dMD4qjlrLak}hhl*U7pj34v`?OUy>VRHkpt1{G_B-%B$ETCvsZ(|? zOlm57M#|%Hq>5`Ga2t>P3&CBuK5ufZCfd=Tf-7u}LJefAvWU0@G%A$ffbEu!DM#3D zpSH^T6C_(>zu|dad8eJ7C*Us|TqEmhz6Dq+C%B>31BC*i`WPha23K#l1BgQ-20r;s z&=7sbsTX+bTK+Uz-b_ay6T^hvU+Eq>fg`vv%F5lpHLZmH3R)w7jpw0xP(`3o`7}#F zL}AFr>VU@LOtpXjT3@p%?|u=XqM(^*PCt+SbW@A<9v|6Ji`o8~F+eN!ZqZ6DzF8by zq@Os$-RcIe$V=$`(wIM=UjI_~wBJW8B={>4aQ3~D@GvK{8GQXOR032pzFxI%o$KB; z977TUwr`w)oG`C!MG6jLtmU1|bKdDsVG8kbsc*sMeXc~st4P+Ei*?S{iHqM}2X~LX z{9o_(ad06opFz_eZFu;&n^be<%cCN|lmgS977xkA&iJ&$#-1g@*XSJ-YQ(K|IIN%K_@_0n|COam4FYm?D}VFv!)h-M+za z6uIzS)DrUZTiG%g`__)oNpYc{1lQfrX3c{OUlM~CatA2TD0dvQ3S3eLs{}&%0p%!g zzmtwJEhV**%(0qK zW*xkHIrn^GuIaY0QUwj~#%69gw-V&h_n1OjPtop&IC=^X>U`Ji=C@8)#6`r!KrFL#6TXHk1D&p+1+Ls zvd}w>Ko|r|O6zwY?jGd6u+6QbRp<8Vzx4&%dpJD1`1h9|pH-U9Ym+Sn1dnCsW|&4v86G z`;xQJZX4T{V?~A1dZ4HjIJ^T~)goW4SEovUkjiaLWpGt3MfAPnfiIA++eJX6z63#c zo^m2Kr--ObX9hZ zxWJk@TE`%-S-3nm;wd>l-WISOHj#h$+e`VR0ug?sNtNmG2Q^ZHZ`l_5bKssY=CZ|b zvNauxX5GkbsG^IZ9c-;N7bBBLD{?;OrHAJ>4r(yeOhhKe96rVQ!dm(*`nWLF+(I0x zz!#@lzsCbfHwztAQg0R^6UW~L7o^p~`7wqL<+23YCN>6i4L+(;>dfg_GxGS*oUR`W zUF0pIh;#)v{R?y2=MrEM&|P5JK#4pv(L{hPviCw-ou#~yn*N~ZOJgKKMXFYg!MEQtk2a$cfi6JkguZ_>P)M< z5gVpuqL5)gLm{*+yq1;jEJXZOHpQmj@S|#B2j1&`B0`&EId*M(M)BLKgTxec*e#FI zvD(iOyZ`h(@{{Akv55)Loz*aueS%GcWQ&FSJy_?*T4dVH>%`DP0r>a?1JoNNJsNHa zlX`7e^;c)_LJ3{;XloYB_V5h(`rkH%7X|R}%5LCb*43DOqX7^1$0Rz;#dh&Q*KSK0 zTbC<*P=Bzc=?FzEcH?%%JaGH8*jq<%L9Jv_^CvPipey0u1E3oVnaQn~k%su#h6JS? z>i+#mHHA{-8=$NL^KvzS!TxOf2{+ALcPUl)Q~&AWybI+mr=O?pZu zGs(BKC3Fm)TdMc}RiW{BPfw`LOl;O<(ns(5EAV9wCZ znds^QlC`^FItXS=Vnd?Fk-5(|J%!XU$X33U#;B}zAMaX&?*AU95?B(k05`!pmtr9c za)w90CEd9^mp5Ubn7!ET>N&)>I$2cjQ?S~HhBuJc;$rYvjf;Nao%<^BzboQj8HG86 zaEo!fBL2IzXpZe2MxF(Lg5H0AxcLZzgwN!jLUkC>mEUu9A?vKUW3|F$N=o3`?s|8Q zc3E%>qh=Qu3K%l54cc>;RNG8}v>r+E0ZGyw@}b0_^%eEkZw1y-7dmq!xGc-EV=LzL{n9jl2(*+XxK z`6jHz=T-*<97nSbA+_G0=w4H~vb6n}zDjKVl)JIyNMqt*H^<~ zAIBUA*O$X8Q>(atNTol?b!JuD8(EBJ4N%gwf+OU&FCXoFQ7HLq4?rgy*!`{~HtJ7X zj!XF#TIJ6K4TD=(;}gKO_QP*HZyZP^VOLxF8p&@lIRV|6ySCg|kT9M*Q>8c2p4YVm zWNEITx>#^MykN~?qiN!@*DX7Wkn*5{*>9!=$4`^kli42{xUih>Q9T&woZPig8&dl% zyrZbvtAt3IWz`{SUlQ(f#?}1EX6LEeg+Bgp^`dVd7Qak{_rxy6jVyQaJyLgD$^Tk9 zF^;2nugkgKOGa4^QlfIo4S;L8%S+Xc`J-Hi&_h?$N~(+F#zP@u0qjyBaSB|py?$pE zRW$n~-N}|{Eylb6bSepiIWp)dA1S(BaPgsdo8ieh61KZ1trPeTmI_F3 z8pgO)f$h;l0vy089^5#z(Q4IUU$3%0?K7O{xTc>D%JRdA{imaXK?E|%{oWFn&R~#j zIlsC3jznBviR}2dOns^>Ee|u{1)i^L;WN@RSswb~W<({@EB5!+zFd%=wl#12Q2ny$ zgKSQSWoo&S>Ya1hw^*_U&F&ZsEp$zoB-bVn&OjbJQQ@A!9lB-yr$QmP>O~Xb1w~WB z9aKwp{eIfPc}BDLvs|aNXYCicmidVb#;S`!7lu2#D+&AHluMx=)@jGpsbNWowT7*u7^(US_=~$ zDhEfNQH9t|cUl*%9Nw@RdVKC#6e!cn-iIP~u3 zlDC3UbpEtgqT~iJTcStyR4Crn=pycTx_xf+a*i+jIWa>*UFi4r{|y}wkYjnq`+GAa*YeWWZt+%Vr)Y8aLjO+ zD}%qz)s6mwy!>ZLp zc&>dR->UYTkFt&KoHL`{Ya1X)qT)5Q1AGxs*k2hCtNxtNvNjDcw`>^Ls>;zBr(Hu> z6fPrDAotHCr zgd`T+E`3L;ClggMz7H?MDA-t=fRcF`s=&J+Qgsh?oL8~#^QwRDFdMF|o{yH&r(2zd z#~0jcF`YMBa%1iHf%hx9RrLs0$hDJsV z@{GpnoW`$5&N3Re#D-vKR|g+-IYfE@^rjd;03;uAIP1%X7XAe+2Vm1K&+SLm2kM*i zY~QJx3_Qt1DWXn5A+Y75^hRYK=1~x@8NK3ioxMPc;MJ+mG8^dsOVQmn zPQfa(Eqm@!`N4M*1KBtHx*Q%Q`ZSl^<>?!lww78+X6{Ri2xOF`swSyo{PMX}Ew?YN z+m1WrT0DLf<4sI=SJHCbqJbp~DfySjc@kuk)$*0O5(A|J8@as8@j?a~i+LtuIm!4F z6thfWiGf5s(0{Dv4i!+%bl!a~uzv5}Y^`unSCLE6<->eO*H=0=8a9%sx6iLHg4lqU zfX)cu;f(Ie{Mfl|v^%Z1FS&khf@Eos+$&K|@vhKN&fJ(;%$ z=3A<}!(XE(0hn5@D;Zg|Wm|O3B|6$?f`Gm#R(USwZmrO9XO4oU%C3)32xkyc(<#=f z(J|_DiGl2P`QI#R#g!TQa%e*v?k=k}F8P*g0)|Yxs%JUS89JO<1wBlJ_krGx#J)t{ z7ru=e7}htld36+*g7!zAS83!@N!P2tZt;1*x^0!?Qoi((u~WK!<0DY+sPL&=scM|A z@MGz6KCX-n3Wo)k*LiwCXnT-KJQz=$e@TPWW_Iv;0U2dLbTiteFQ1=$SFlD8#VlQa zfy#t6_PbWo>zw9;HLJ!GGt7!;*wM)>1lkOMtLxFrTkD9)PcN(!7a*N}cl^8A)tpA~%C-#EMGka~olJj;4id?k5(@L}SFSuL?n4BFxW4)k zRPO3wkK{$$s~=9BVit3&%}D&YH8KGQ-qlGLfm0$ryGJ<6s=*5SvpFbOcAgbPu;ZTM zGKGzH6gX-e0Cg^0+xgLx+vy06#!y-OaQs6+`|R77U2PyyIHyani^z^#@!(td7gZCd z_n`q#wf>XD;;z6h-pSMZbLATVS>@-p1p>fI!J`*B%h#2Ve(@I8NYY zpV!sekyvsjDFnpfuK!2ecgIt`|Bsg_Bc&2TrLqa7ki_ZUXvnDSj1$=_m096k-Imaz zBAnZ>lNni^1}-wPXDX{mgCvT6ulG5ebDa0_;(or}$L}AH_rrOQ=j*xG>-Chf7~Yj$ z7VeTQ(c)fjc3^a5@a6II)JJSY4mCSx{{nMA#xs%`!SwAjU(NTTr9Y8ad> z$oN`q)i4?KaX#E3^ckq_y!H4N5I8>T%WPW#BJ;>YAfGAB7bru0=`GpMC5HJV&G80= zS#RPKl9bg3{0zOhI&wZ{ONEL37o*l(I1+bn%8SRlNfZ%esi{@kh1f;mR>*yiC$6p88`10@ng)9V0)9?Z4?acX4m)ESE{a}-7Qa4U4n8jY;Z@#d(?d^KLbQB; zG`B4Pp`fjG{(QzC`#+H*do78btRd{=Ps}BbjsAF+Vpa6CTkY3yG6+RuOMsuZ2u(o$ z)$Ee9_GgdbV|LUbTd49G=k=w4_fDq>)dcWu$Crg|e1j%$ygnUk6G#HIQBUxFuW7-K z3K#F%nBOMS6q_=esdXuEzrZ=)M-8i9P&tN{i}8&tzC$@}e=R)m?$0;!QNz2xzuT^6 z(%5!ksnk>8>5L6~n!f{H%Yw5DS1tgZ13O5*P-B{{RBs6t=ej&zrTbqkP6FZW=W@?{ zd8g)wYiov^&!Rm?$A?QTB7gN6yOeIC0gRSWsPCCj{WJg1=n}BNqzj6rB#)f&5?`wz zycWmTwSXR-Hz1X1P13Ard1;{EiWg0g{L?nv+w$nhs)errZ|a<0vpwkao$bMAtcrsE z>W=bLHPGjufE=g8Z1BK*xlG>Iszbw_*Uy%PE1m`U-qRoxafU-SH~As)ro8P_MUaB~ zeBbp%g2!@7X7zV17`*4*L)@B^1@7Su9~iF}zlj-SN7VlMnFmrk$&U3&$zUZWtuM;T z{>seja~}9~_%9GGSiC6~i<&Q{eTx+>=_q;kAM^r=7?7OE9+KK_I@~H z+_}LKDws|^5$gE#Gqd5d_hkdY(#{L%Z?kmGBi4J50tfGOfNZ`}?i)^5R!~ym0PRJr z*G&)aY{+tJzj9stm)3WXQE46vEd( z1VZp7jkakvje0{g4PyTR)SHp>T0jSuD95eue=RO$ka)u{re~j;ChtF|{^6W=CBV!uM5?N^ zXf>a?YW!iJ)`57RXYZfYd;jQ6cPkG_El6oGxNOj!rF-+Rxo_m-3%)$cE6c$%_d4Gf zB(xY_R_JU0p3>8HUb-=L%l;bGW02tNH&$Pm4B}C>wZuw`&cEnefcL=SHB<4&p?iOS=|GR zHhIqK<%R^-t__NciZ1${WUmA40J^2@F8LEAo=N)m`?Hl}Txd>lL3tI;UMpIaKAC!q zb;OkS7|EdCYk!%3-V_hwb|I*8{CNUYvWHzPhO+DbLNy@Bf0xa>lJg<8^y$6p=KKct zO+pSEjZi`iI|327xxt4%G^7l-1#b@$yt#0`C-4vF2G#r*tsZs(XzZXbZXBv_y_1@Q zoNQnAEk!lnA7lBy#(q>ddV*Zon=6_!Y^dr&%O|KBL*pM*S3U#gP~+8+BS+TQKkF>9 z?msf&^WfT;`ybEyr>(m@B4EY!FvIlBYa`)`t_v2bet-Sb^=V9$uktMw@AVy9-)i4d zTBIGN+L|e{{=Yb;JJeXnJ~`_NKKVuUOKMa(VYkS>g;5x8g^;kHY`xUu?dHtEQbFE_ z9=*-&Q8E=Za7js5d2AY;B@?8+vS4s;aDiaJ2oP7Fi1gdLYg1aZAMJKC@8GTHSU!+@ z*mwB&BUO$juv?C}m-&MK{($8J4|%2JclvI^)$eUGP8{1ikkG>!v(TdZh!Ie9et-Ag z>nbSR5 ziU5*1Tl!KPhZ+cRf98}9e5h(ELE0}64i}^dUP{`rKgjB%ajlEAtCI8Iy@$;|_YfJBddm#g7D|mBcMk-1}EcD;EhsN#8FPDE1zh3{n_v4h@H|hQE@dLM` z>{swQB-}DomAzPEKRo=|{ZWgOcYA2ypxND!;Aid2KE{|n{HL_nYhuUA6jJv;JBNK} z0xqfC=2qWZd6TIyOh{nzJ`}A&L>1?6bX4fwxKK&C%$f_;iPv2p_Dn^P-@ShNZd-DebgAS#@&6$2KeJUhqh>#eeMfTER9Omo^3g2dH~o~Z zPgYu$24d}$nknqva`K3DsZCvG&~FdPLuE)Ixtz0&zQ`H|Lt*}B0sI#{hCCe4#WeLC zZ21?@&5YnPd?BAEN|X4@*2V@QBLANdF`MZ=$tjiNOJ7_}`0ccwAtTErk(`KArKyRM zn&U^cP4*yWh*B6wPy0d>iRAU2vGY!CE&2ErrZfqjOkf8fCny@(=rMY#^g=N0pLeo8)49x*2W7(c9V})KdM9Y^ckwFxi~{v znwHJU??HUYE}O&Dx$|+zMVEY*c3H2M@t-M&tK+B)@TtES z88m9WRGMU+Or3O%;noRvV)m1_J^LkSs*}Iha_v}!LgI9!g!^g@wPThB)NvFcs;ti= zi>!_7&c=mL^l48SbWW(0e=Bi>%V^P4pRIwAx=RD5p+R*t1@AWKDD|J=MM%yW4V;~{ zH}!Q^ufXDi@*m_ni)BT7s`Rl({**HyC_nzL3*;_SAS>7&Tyobj3Gx*rh@F+E{^egA z*ZxOtKOuueAPF`eLpa|O4>Cm-Xm!OXkT3vtx=YXcAYJ&k&hLf`DQ3AcHz4hDZ3jm* z3+(0kOex)NCkyoLr%WF((gpvDfu$dl{EO<8t=1tIkHUZ%WMK|SaJ?r?LXKUy|KkVt z%@>x*{w{7Af6wb*C~g9rwe43y71@m-+z0Pl#P!uFwd}tc1d4{hOOP0cvvO{T{`x6O zeB_&Jc+ar}Bv|a<2}9ujiB_O_3Rp?oBPI5-QQu&g$(1Hq$;MKaTmMx!&&(=}mUNOF zY!qS>uUwugWs5>d$oB^-@BX#_;FJV1=I?R=NMs&vvc9mh2NuTSELc*ddwXljCXSY$ zp))XZ-jX{)D!JP@o+_CpnC;=1Kljw-r;!DLmv;QGR)@l*Q(Xw7MJW_9sW*GhLCi0% z2sH)F0lnXEhr>+9%n^abY^5CuHNrFS91x@AtdWe6aefI~{d#krgwz4S|C8)sL7%Y( zZf8Actf1{?{hxVw%+cZ`uPV!Vdanu$YLMI8ke0P*G23s(2L(gOK~&`xD8%em*tZ;} zKi*~ece^dOz*kd_ZT!ugY(lD|g=oX-;bgXsmEhvw={7diQYnBb#(!lN>2EF-NvVO`&fp+W4FH?;X&-_DT23 z-6Tqxf4OjZZe60W{1wsP(=GKbl;ouy{g?Jui|5>l7)9^g!igb*Lb^J{Pq{wYyI`UX zp~|G6kR&vVZJ6-{!MmCLFuJ*r4ihwXfGEujjEqV^c)_lBm~%ViBwxQOi#^Xh8ILqi z)1w&jQ{_AmdX6NQPzEhcf_R*JIFN=j?Rht{c2YZI#%}{XQP#$q+g%tpLos+41Qf7S z)eIc7ACR!wsBGkYasPBFbt6Kc@WZADLY?1ev8;ElcS=4Yz(H2ijv=WoseRLBul{7!CU=)2i^Q}KBT0_p-aBV;KVjxdS(My zsa!d`qJ1Q-&W3u19+?>FIzk?wL`ze@X+1xOq38bsA(FxjV%P-!n_3Iv58lQ205r-V zRu=#4%ZR})j3V00k>z>S#Pqiyh_H<8(<#}_J++4spG^pi-D40_n}%BVMcr72xlb8r zX|3(Nb?G$VGr;o1yWl_Jb`lnWJk?=clSMHw3`dK<2E%IBZN$_ZZs728d>3mxKG~e! zMs2i)Xp!lDdUp%8uo2brt6+l0xfpQtDV}G#7$p43^s#k5lJ#5S+%1bpq1%(KA8%P3 z>ttzREG7+-iT!MPTY~rJugIVr4M+J^*AR$(_TG};BK0n8AWL_DaD%|q_(4{1JXa8` zNKGtS9gRr}*aZRGQD)4shI&jc1<-$gA%SLz62fk9N+!T1?8a_lT2}GT8ggYfjq4oC zqMHRuUnwbAIWwf;lgf}wv}59LnYL894OK>#0)iVB72LpZ2@S8O?*Tq!`I&ZS)16lI zW#^IAK-Me_npA#+IszS&XcqSBDOEq_GDs;EZ-Qp0s~z@lCId-yV)=QZ%xQFRf|57R z;6A(xZ1b+ZR6BP%X@W~X*%sP8B>A-53Y%i5%^`6X^)e_Y>{tuXH1IUGY|QU>_#WCASvMt=MPW|2>Cm5+0#erSUc4(MskukR$-fsNBN4^;sCo zqpL*5*q#IDBnCe*#{rbvvOKGU-4%YvWYKq-#1|x}+E(JyAOZD_NSt)?#csFif!c}D zm=wAOQ{d%$> z;&gyZ`TqUWaB^8){9sXHtvr2l|zd}vzx)TvP4UGp(4OGPGODN|%ohULxqG-p?nl+e34pp~?ABz8j{ zrcid;i?6#-kNbvGsCCLgdnh6=N^mtFY8l8{w`eJb&7`ja$uDJ2FrL~}&Rl_39-1&H zEk&PU7*5wflM=~Ub<$A?J!zKn9{LpB&f(+(UDFgaqKB362PrJ!bJAY6?=mH`K&2H0 z%Xno#G_9gNQuJR%I=K#gve~4UK{3M&o~FEJx{ELokU?$1%h}a^2&7DkWAG5}ESiLH zQhN0_i^5Vm(hzEa|Ca7EJb&Uifd30XtkTB#F0>5$s3T(^Y~vHr8x^z)sn?XLaul%f zHcTnU6vsk+Y)b#8ncqf_NqX8)p2u8V+6@%Z!5U>sH#7qcaLF9#q4#CjD2flHC@z$i zW_ij>cm9@r!(gNj5H!9h&IOi|RWPo;D9hD+6v)|^<+Wsh)6kq&h0pF0ir4`c&o!6g z;{ER!B9Yvg2iVzi(Rt2ev3#4S#xAa!MJ3pAgnijcx_c@Ok@z19#-W2D&vSo+_vVjt zMPtc;xTe=a(W|NRO0cGh_?;<5t7uEGK-(Tp5_4B>o89(a%XF#L1jRv-vNf~V@kfMV zo9=HZR8|_GswrM!lbuwg8`e}%)rs8|v{=ho6rTP^;rL)S%8y_5g*@6sGl7135XCw` z?+L?LgYt^W7l5A+(Zn z0-KUIS?8$XG#G9cAwOLy2=XRjX*?Qa%84!l@~2Zp14h}>&zUu4W&$uTkb$z9Lc>-s zzTpkrRIP2}amWP3G?W8yjmU6uNLxMolJ6(^f;vlue6QU}+=qNERhc1|uw>=JDL(V> z)I_Ku$>ixd9pakC|~)38)pivRaSuB)Z#lOYfokrfVIkbBoB(95OXnZ z2P9GvlFP@{Mz^dqUvJTjjhDqQ9k*(nT^Y zH=Cz5E%Yt|4IyxnXr*aqFTHA*x#Ff_mlxV3b=h?-Ej&9ChVi2oz~OAQu#%_Gn}*5i z4tmynY~A43caeH*;3VGocapf9blQPavVzjNX_bIewOd7dp{E|Ep9r*9Hk=60T?o>J zYwvIQExJjCq?^J88(tHQXLlBwwrknmWfN1Uge19gT(9ze-7H%o0tN%OC8w*o3(W>0A_>?b_}dcfDwT!VCf2F2p14QX8*d zZEuQ6zR>cKk1*PN_M&#~ymd>V`L040unl=j703&(5gy<3LJJp_H>Js^)QHXt2-?f|jtO`|g@H#Rk`hNg_KaT)bPl>{ zTH?kr25PcDmk%15Vq3DP-*-9LpL+NMc!}2o=E=-Xram^R_Cc4+~s>tmh3S;Hr6?>fN zSHPHT@k<+8TIMTXla>*J$v-&4j8JuuERAyRfqD#pqhL1Kd3IEhb9nh*^m2iOfX0xt z!BEtj<4~>Dk0+*L8Ew>;TB(HbSyRNN{R%WH5Z^Pryv+LM^~SI4a5t~D9a@Q zM`=-(%?w%Y0#4c(loO10HS@!I6)HuL46%T;CtI(-a_NFNamkX%ZO$UY+9(h5_mNt* z?|J#k``1qRRdph$DzS~L&saS|nf?r;Dh|(syg9_D2eb(*?Sujbmh2jbUKp@W+ya8n z^`0~Mox(;h#DMi2&K>WQprN6j1V{^oG*M4cfkS4@6doSFb>Ec&7GZi~Op=~xb`-FO z#mGUoef2w_yP)>5SVk4x;~iFUk&Ixcfs6$EzZD23pdJnU<01KPM4LTvi?OL#tro1( zLA=7^q?CV9w~Qq6NEq9WS^Lvi)=hM95^pi754m(XY0Pv0yPl+wvFW`QWk`O?E(Le5 z_^oA-Lh6OMb1+R~6y#sg9@-vDU*z&9u4Ym%ehY+QTWtnCA{mQmq6w;h&A@&YAy{$| zu*~AdvAG2(+z(+*i6(yy?*KM|pPG8Vi0iN=p^ZyyaT;6nTMO=!Ouxx@;GsG|EGxd|XP4fpcXpmK0y1Lf`#mJ4Hr1Jdq~ z!r|zrJWwYk#~*m*i`Vgggyx=lvg$z|6zTYE67!*n3jE0GIGA^V&tXyxZce(@OZn8q zMd^}rTee3${P?P@|6&I9cw!1c8C(z@n9n?Wvx+mO;?JFYo~-A2Av9!;X5Yc17y{QO zgS?=HZ?yg&RyyVb`yN0WN^6GV5h(XgEJceKHTuy&XyJ|%K@Z{WXO&m_n&b7W5=TahRU1{B;p9_1wI0LL24bLtzsHF|3nIm%p}8O)W>!#CJaq<48JSKx zj7ZXPUgWyhccU<5gR8mrBuAN$uq!a4Ut-Q?$(?y(t{4I856yBP*LsyugV#y+73C4apG=NAJoT#__rctXE&R)OTWf=!ibdz^(@8 znA52h%p1rrH!{T^IU;X&P>yeAJSI?BS7#tC4YLsbL_sEXU?X0hjwiD!E|5jVYF~T7 zx((w(O`MM!vY!!(b0T2@Hw~jF>Z77CsySWwCB8IvgR!a8)j0x!*OG$&fGH7qw&$t= znzCQLTXr9p#CS0Vl0eJZ+>3Cy1t9|MPnukpq+Qs~h0zd_LiO>Bce!Zn>h8-j3ud&9 z{sy6v)brX6^c2HuAV#TKU-JWxDatd&Ln%N3jM&619I#&?4|YV9iE#3_gKi2+b}w^^ z^&l#}P84*S9d|zU603}et3cP1;L|s-?K3pX;ap5kLD*H!pC3Yj6?;J(VFA$p;^&)9 z^DqrpkkAM+o4{nXH8q)JIdhI97HG0j^9LT>J`^w3C>r;{Rb|LIR3dRLj4P;bHxS{{ zKrF!X^2l1oAE0NJUNnIN zj`Qgiypj(S@(tQ3V4x|c<;OFB$c_A~xqe8?EYCjZ#%YXuMqdCk0ZCQQ_I#~`>n$A+ z=AizRt^vaMI_Z1o>EWiLmNjt?xM$DBApK++rD>1dj$L zc#6P}ytLy!x`A*0N$M1ri61A)X#r}g3{^IW(142t;DscR1(m$I==L=Bc(O_8S^L`4 zC$GNf-2^JCLCEj&Gf+`WYlde%yL0g^IQv9SIDlgZ^yAmixbT+Nf?f67S3y_?`HT7Z zicGGk01WLl7Xe)*aS@tTpxSdhCu-$Kef>DsycB_buZt8)7alxPa^nIY?8ae~vN3Cc z6Q{bJd}a}DIr9bI2lWS>sBJRITaX4&v1xXysM3d`gF+oWDIl@n{HFNjr(aDFfzgv2 zNU;tOjPE%GpE1axKH(q*1S9F;sf}{<8Ut5^(pEU2w;`N(6!Hct6dUyL8~9n)T%RsC zr;CQ)5^&2^#&ynFDKe-fy1mRu?GC-bHjN8xPJPQ1M`BOncV^afb=0=*yF5K;sGYcX zXCEaLpz;XymBc@o6qZ|@t0yizQoPnWJFOSN_ zI75~*&ko29KEZQM8?#=LPHNC#W6UBXVjzXAU^|-Yi`Sf(^mpZ9q#;iL6iV{nMPnih zMy@15gz3&p@f$lIw=J9|fZAAoS$y@ELfOCRpqkCJ7I@l8ECF_y6f8p$C`*Fu z(#e}cKSrlZ9Hs!jyFdY&)YzaQ^ze+iENCY`M?8b_vYs@_ zX)-McAZ(ryIhh}hyTF;Xp#h8)4EfVX^+_@G;mX>~NN-G1hWe!RJ`{aT`5-AAhjqh= z{md zD<&#E$41g2ORg@agkm%wp{FTG6}h0v4`+2uYcS1Ig!80y(zXp&Fz3ILdvIt z^t+br(tw~lo0}b(5k!?PAUJEv%eR53XWc+@Q93p3uR0EfT8PBbxEvPL@0I`NZJJZx zN^;HsmVIM9ZSR+jTL!eZ4%Hq_kLsox^EH{m1ZQ#zj^JFqfo7`vso{s^XQ@UE zUp($s7U$VPyhVS&@WKI(LnC3!r(O$gJL-dY9_)$6?7<_O(t~ap77BA|C+ctGq%krDs;__(ny<$9p+>ZNYva-5eVSIYC}bYLK!iO$6`l}qo#FJYFd?}W z!KV&<`#m0rIWf9D(Bcma|C$OJCHIW1=TTBPD*tKn71w z0v%07*j&-TOlesF=Wp-esgLbkZ#1D9RsW6=oHz?$YNpUlTiqV5d(1x9l=v1`1Uf5xG$GnR(%FoO~Y(Wa?rM&FeuSAl=MDUxS76k*e z7g|eVzb<(=`eSIGDgZrVv*%nl=>5z#pwC=M^+&D4xL~_4@+y!rUo_vkE&s%1sKMT# ze*<-4`xg?_ZJ(wSDN<2?2+U{{QNFT7TWJ+PFVqRbuS4$NzhA(AXuLI8H;yO~b8GQe zPjGZ5jVvHGY=Ac(xmG7`+%V+`q)EJIwv;bW<4Mi2yj_{8^GA4Lybtzv?ovCD^C|zw zm9r~-mE?Rnr7V`ws8~jZ`i2>r6!6K=Dza77Bgblq`(Jll)zS9oYg#(L9n9v|qG`{t z3q@Ut9|~nAf8Lpqw_2%>eDM<8ZI+tl5AF29#i5NwRhNH$%Y4i^_h^%S3=P&8G7E-B zxV-utEd=JbKmIl9y4u*3Na+c%yM+RM&@FJk#vGV&r6`fgooKDs_i@`!j;pW-lFg8k zs|Bsz-4RcWEC#~rnWs^DJiH)Kd3(l$OhkP)(um6J5inYJISrY@#DFh3Q1@aQJum^S z*Dll!a_5&h zArZnTlbBMpB0RT8{{j0Mw;z3(G@=AHqLQlyU6;47*y#esw`VVC%%UjFE^g3}sx4Owx6BiijSV3l z1g#=BV;hd_$>2|i4)2M*OfHF>W4HVlE8$WnZxd$unR zIS%HSE}%geJ*X%*z7R{!$k^D%GLiWTVMnKd7w;5{;Qs23jzLEUywkj+4CMQg9y!`} zFnSqQl7!D6bbG}DyO(E)(SD##8qkxt4}&SZbLG9dH@Drqb>ds&bePTpOx`YYoAh=< z5|gaoaOqV|nMcBaS6D_IALJ>}$o7W);H*fS2T?CE84gBl_%0jda?Ska-B6>I*vWSi zZ!gU1!s_Xe1Ohh3u7#QdIH<|=mc>m4#alg7^NU2PY^!vf5 z+dcF9LmmhZwfXr)oN=^x+v zG?N~6h0&_><4A-2OLV)tSs7G%CeV#D1Px}rCA-4KCjK)CcG9wl@yuW+nM_0jIxD{8 z@3Sk|yS{_*@XEt)c^~slqi2-#fOq))?~S?RzEqFU=lr2O*-gKG4&3?k%dOql)F=9x zE7`|OsVV6*+;g@BwM3RTwdjv>qahIfFQ$wgJVV4e3x%VGU)bKRR_RSlTOfKhfQKC# z@#~6%T`Yg_lLZRDmgy51D}Ockc*mNT`H#V_a#8fpZR?X1)+yr!(mL#DH<$7s*hRK9 zu>RK#+gc#jAas>(z(Ke7+k8i=qeKnO-1U!YgKgp3NxA(c9p}~roeSlFEdaoxXd5e{h5?Xu4|u{{4M72{*AClF@%E z9l%*O+Ii;pAEr5FJTAs`ky4ku!Ghosm2?6SL)-W3ot5g=!D?gQJHQAA9ht1xC*kXu z%~ZkqJl}t4cbq)gF5zpL#3H>c`^#K?Yr9euAWgq|S?`Uot^LTSyM{V?L zM|N+Lrs~k63K6lWg3C%-^{4SF2mm@?tH;)@v<3z4wceIrG?i zrJ!_Miqg&cUKuG!uUmVlL?T8Q)hVyWzGaGm^Cl#hmsj|HOY7(_mDO1R5@}UF>=e{D ziEuS@7w3h0+)rs_BuO+sThJR?zeDHZ(H&d}X$!;~R2KxJ9 z;$3ePR@@R&maXINRqb8cTLx=RRV3tgh{)cwZ!k3Xw(ie(aKbq{o7zI2t_eICkNYt* zTj#qlqL<2o=xH}T6LbmR(DXzbi1mweUJWL7ybX}mR{e}DsQ&>J&VKT<%Vvz?u{DvJTFw}%TDc2O-+B0+HZYb>!D(w`>WLnIgcLQR2lo;UVKPN zB`fm1ya>u|SGz%&Rm@@W{b|PytDsHaZ|(fH;znnd=ciX4nieBfPi*lvaSy;yb+XF9 z{a~(oyhY3}wOdxK-F!wa<_voh?3n_0@Ld1f+^t|~v5s&5)sCkevb)PSb>EUU^*LUb z78!EO>+Sh@zd{W3cKCx0=&77qRaP&(mHmxNtOiq!Uao7i-4h|bB0(S^q_(0&G&se> zCQ$2PNM4Ycnx?UV?W=Z=9|2~(0cD#by?bTvRP?2%L^yUuG^dX=@MF``@rBp_tn7*Bm2`|#V19@v^u$@wBOxn z5F>70NL$$%jDPG{N;K4_B(jKD+qjUl{ z+;aWUWNek9%5#3{;C}Vo#9(`Cd+%@Zy+6}Nt`_x~uFSDXZT;Y0-DA@pw7mPK=7*8v zPB)!9nn#77nT+Ir_D{a6$5ZF9w7LhNS8aQ#}To*41Sd__y^6r-^ddU`7YbP7c+ zx|<{1RZa@MK4c|0$|F|<`9KkxQ{ci|>SffS!%Bjc!HAN`1;k@E$jMG>_U z$~?6dMFB}=Z&R{|jR5P|)LD7-9UPT5zux|G`^ty~otL6O?p@T-;>2L}uaz4%o$bq& z$q}^(RnwWL|4rE-G`O=utU1hpM@sfWXFI@r#cd;1^P{Sb8Y4|4#!WYT{Qv~{Png}_ z53Kd2TD-eVjayFTYDB12{1aR~!)|+KP-^tA>>ZqLLx3AnC=yT_?baRPDf<4gR8rRJ zO+zh5t{y4hB(~{eR(q-?Wg-d^%5hM@&bla6r~WGywsC9MyqItP+~Qt~Un9A#?;R?UVmg56u#m+Ofp&%*L<&U%N(DdW4ZZ5jzfK788n$T z@x(0TAuC#zlFT!gohBX4#cOvwHS1@36=znJAHZ|{!ZSLc($w+2Jy<7bQ`e0Sby=T1 z{h)rT)|laFmHnVY~{Y_}+6^f%ub!5ZVf{w>uHCwKx zd~i25Hi=2hjZGBKZ&e-W>#RuomTHygWM#Fc@zD|6^?WLWMrFVsTcB##|H<#yX7A5W z=3ND~D>1-#I){f^Jy+gx-25F?e!i@`m+VlpD_3O7#%!Egw;?vyoP4G*8q9 zYO^)o+%@J?eA4-{O##lf^BXf7*Ey~^*4ky&*iyBAidE^#A|C?o7_W}`a3g5_=8B-J zDaG~bgAbQPW%i{9-*!wL8z?erHInwzdg=YrUH!{#kNz*}Nv+zOQ<%-|H<$8n_uXyX zt==x4V-uOG-W=6AV%#HmdXV;8iF!i6UKrHv8EIQcqivx6Yb7%|Bz(a3r=kYTGG%bt zxu<5CunKHj!<VcS5ipM}o@kq6K z_k*>{QFVo>r339ZGW&`ht?FY^zKU5W`l%XwB=>I{HF7c$xZ0Vbkj9BHr$)_V0dTJheWCq}waY0m%A`f0`SyoJ$6r(zA zkKMh`dkQSyZ=~Y@Tr;y})Di1nW-SjNg<;()S|@}eihWDaQqx@!y0MV!6cc(I6aFZP z3mM;19G@suX^c3f-TTmB%(`Tv`SPeK;oa=7x4kYpwz?bE`Z*;HJnvdouhOSocONzJ z*9U#fercs9`r10%*7?NsCb}miDLVR<`ncMmZutN^DQ%mYRkYGiWw`(PV-?qZJy>s8 z+F0nD_n9B%ni_S26om}EkV5^kn%+T!x~Mah*bie1fnn1EU3d@g#|~p<=>?ctDZa&- zAg*fIE;#{{Bsd~l$^5`jHl?IWiB!cGfvoEnZ#}jf<5qP_oQ^-@AcFSeeR&=kz%B`c zkxS^1E};mP%b$gKus0majp%hSppck+fg3;#-6PNHnO7l~j(fBTs$G~iQp#e5aQHBg z@vc67Z2~h4kjrJ~kNXhdo+A5tBVH1F?5kY_myg*yR~P1%mSBU|jI#g2;gQ z_6GPlX3If_I^mfl-y8_%B1_Q>TjoiZ4VW%ep=3^QBJD$@3wk646)$zGQTFnkww%lj zs*r{|?o8krqX7Ud(C#jaL@-Z}K}#Cq!SU7Sja4(47ICbs4AzB9p%E?|%$?X=kY8OF zy(t{hr#=g@W zFj}5JQ4eiusd+!>WV?)j6(ySgh;w~@Z!-I$9E|xz(FRG^s_%iA&G?lzpr{fK`ic~E z8e3@I$`B~>QtU2|dzNd%QsWpAa00nT@j#PlcGf_*3Xh<2X&Ci#8D@hW*gBD-bs0<~ zDjx}-S?gmo$MZV>lqee~E6N#j14UmUAT7PX=gY8>(1Ku=P|B2VRNq;vNZ%6+sz#tFlu~xJM|ENQ zj5ZA6z+`E%CUf6cln8S$c7vjyOZH`cs_np{g&&+T%4EJq%(9aHF60b2Lt6dtr|35U z4&Uj2WXK-M!d%B*Nr1B3*&Vwvl0G4ofb>LDfUvTHdr&6xVF$IfE%gPl7???eu$%^j zO=biXI3EfOeISLR?t(e%VAdk`6i^uM@NwNj$>5}F-p>Y=fub1H|0;SFQP`v(5ViTnOSY+VAXPldx<1XLKOT$@nOAJ`jM#kZ*qJRVViH5Ztv2s9t2m~*w$4Nr zabwInfLZa?Crgs4NkShFe1&$^t5m(S@G62Ua*^f z8VY61UP!4GP)s!L7Ym7w@BLO#4-}_?f^s9}0%yxqx7od`O9G>QY3T5b=|Tag=6Be9 z3c_=y1%k3}{io@D9X)emi&p18Cx4nXPOZ=-*Itt3xo*O%Z_j)Rro-e|W*5AT_V3;U z16zGja!Qi;O|E$~OCdplPscfY6m|EidM9Q!Gv~@5w~hr6@4~V;tQMhJ*nD$9yeHi_ zW}5$D78@;nsmZ9D_(dYkfrh8ZFjg*|eMHghKn*KB$e24xRGqVUN1wjt{Q!PluWVS0 zv91?D7kkv|*)Tuh-EP2C57I(aFr$Noob7*Tha_ZGYb1k~8_4nF(% zk-w#zFDs0El0tYZGnOlM^f%$GS@s@LjC*!fk^_&2y?`p%dfKR}I(%w_5R8q@7VAnU zXe^Za-C1vj77A-SB&O%tQPC*;tI8X>7vbL+~F-`@WOFR@{ zsi5Sn9nJqR3iPP(CFMi8ch0C_d)X`9k(!pkXIHb!6Su-vPQ~Jg_$3qG+ME;Ye3{V$ZsWrPdB0DY)a!ePZ z%r4GjSd=IrKef2vI+^#*3o>-MG#7&@@i?HU3g7G$(TYySI0^I%AbsH!zstHg#`bmSqdW{Ugs@{3kI;YVj+rjyD}a{)Wm3Ke6MJ2ZIQ z2NZ!%NrD^Q$0#pBFGd#~dhO+RYY=mA&bw{Ez=%0S(sMrTk|{a|NBD;+&V7%1kf9Sp z^o;{GSAt;FBE(>qG!0gAbU?qD8TXn)_R0;#>lOdKw&z}4^9te?p zL5XlV?BBC{~~!0!F9=lCe~I%So6`r9sjhq$WFdLD(0V83G-efVBfQ z2na)1yOzZ%F~R3dApMa(;%TS_E=^s(aOVel{4suA%?_eZ48KUTE(AqBs{x91j5b1! z7RTW~Gbz00RGqh)hLmJR+XlGs=K{uTGl>Fxrey6dLGR+ydUvjD#Mm%tW` znR<5?tY%cV4igqIh9z%tvf+Kh)Fy~i5gP#B=w6)e263})y{NIBg2@T3 zfYU)k`xC;?24w%vK>>&_gmY&RR5EXE;a^7gB3)k)s&!WU4V4_mf=Blz01~1NEJm+h z`4Jc{*<~(S8$VgYJ$@`8btT}4hzkX^YbrFbB_ZlfR1Ts9|BNs8f|uRXGleNN-Swy* z5)n9g2xE;ymXg$vLE{&281C;7_RnfS*vD+&Ku%_vh3sMj{_5WM8~EtH2+|TDBvA7H zV`khUBmu&VkldH*bg!9=yOSV9ghu#NhKTo>Q>7DXy*OvKb9@@~)#w8Smu>SZ3qu1c z6G_UxCVnZ2X_!TK4|0WdcesMH9&l7OE@%A@OoCNDlE7y+6{&X6rG6cAllv0j#J8?@ zq4y+kH$jT;n#6ufh?1SDD9vVSMcsp(ND~+b%WI9FEI6WQ92%Hi0Ufe} zeQ=8Z5PSd=>dVGxVB$NPH3{(^dY!crlbj&%foGSlS$Lb~*2&z6LGlz(piiCR(v^1M z>KTEBC6(4FX3ReR!9W)+XTOp2o~xXEKGU>da2p7framnc#T-gYt9R6w0AkrKTLkM% z0Y%FOr+SecWf+4HEe`U9wjXUS#IBf`giiys2p{ z8z{dqA4pbf=CnM;4G4B=WCW6o5vu$XWHg4j3^Dm}WG9Hw6xpORA#Mo^Ubax-&qta*0aMyB^W!G-fWu?6CH$!U~73MIv1YoYmII=j)FTFJMNeB>;o7>K&!CRtBd zcqJYPGV_{OB@ucdT*`Y$cW=QGCoh_hQrP6*Uf|~gN)-~nV0ss5^f;2rdKc85G(Wt> zm^D2!p^ctbt&MBXIv@WX;D8fwfw?NLp!qsRPvO*2CHV3=|M*E76k_TsqfzVi^|N7U zohcI`Nq|Q68+UPH!Z#X5;=6_GA%1zHe#aKW9Eb);!E1$D2WEQdz*a-i?X!@lfOGU4 zYFIHHL6jBZ2*Nl`^an8`7!Z;g&M*btJ^g$ymX-yHXa2$B4*%=njP~+{ukeXS2dE{?Jz((4#8|4l@F1 z7Lv~fw4kEHa)|Wkp>Jdte#u26P#E~{GCMugjLX8b!o7P;Ot-JraCi70czc*5W8*m=SAP3ZAEIO{YRiVM<~aQ{0@Qq7(mcV)1Zd5h+_xcRk;Irb$b4RzNxq zeP?>RL-TSyG%}92siPiBL&fsMN*rYIX=Z(XO!SF!XyyNdvOYl!E<%2dEjuCdAK57NLKg@QP+flyuWn%;du0Zzv3GZ|b&66AJq z`rf&P7~Z5IE}${#Q3m$IwT*h(JOcu!WT5_pUw2w(&V}E z$#IJy2}ay(R8Qjfo`&UI2m*j??tktPpa&d@W4p^!w7T&1%f_uK_JcO=Zo1dM}Qjzc5K2=%_|{HS!V^yLIbu zfgXqHtBf>Cz#q36sHUdkEJ$32BXj^%g{UA;>C-Hdt1c-E$1R>C&q@z3V-OwI;(wXk zuXg=Rk8=vtvze};y%Ba;qlm9!>g#eAytcu9 z*Fub*rClAx$jS*J9=(LQ+(9m|PhQgo2CwSgZXyJ!%%Y+|Yo6cq2;*KUA( zznA?G_7y6`@1k)I%dc(JZRM_`k8&uGgRX{JRC6+@{?jlYfd_R}GWfE#Vze2%Or^`K z!mT@5bZ&iSh#Q(uk$H`8A4o#1^FB_mg{gppBNBE3REaKF345d7cA`yAPe;`bx|@)G zw43Ku%Xvs$pGHw3zhp0&%(MO#W&tZT&P<&r;vCY<4xCzwQF#OnGE3>*S&96O!6DrO zNPH^(2$$ooE3z^aHc^cAE82&ezo!@4Me7Gb-B%W_c^EfZbPfKa&3coMGmGT#mzd%# z-Rf|h>({_Co#Nr3%xYbF!wbfw!pwWa`xa+D!s`7>Tf}2PVZpARBdd?Xy6~wK#1)bC zr~8ZdTc_3{2tUdd&+ZC9y3lc3K%kJYJrWZzi9f{kT)NAb@+jQ0Tk9xHe5s_oxE9Y@ z)1aCULvE!w$d}zYGX#6%F3HM|m0zwb*pBJcKuTC|WXA25{fT;IX zJRw48ql`x6b2bFiiX#=-)3Dc*Vz zG8UBZ$DS14PVZAsycGS+JrrHs_KP9?RUlQz(cq-$Ew6*YK{iP43QK%D@G-i%s);_E zO64Wm=Lm*OeRW$0X*iTp?#DNEj4?A0yT+lCD2oGG3tH3?O=1u&w(Afg;C2BDUc2B(#WI;^(4L_#=ea9GSQ+yW z1~R#gz`2a>>b8df&+s zEa`Dv38r5iEu{+4TIqa23)oA=15mSUY{`o`Q<4zGv|v}fRb3#q6$*nQ!0DS2GFvJkWvC;)q za%FKx0{ay~SUTj|AHY}Gdw1t0C_Z_1I6oBl!PbU#QojC4=Jb)jA1s`jO=yXey^2gj z#e*4`{x0gm!Td2$=DT9w4oOGHrUQc$qW$0rJ)K2(c9b<=^HQ2&>j)S)31Tf!;QD+P z{|^KY%Q;?r_`Y)?76~*I(X|6rF!qQQ7??IL^7>N1`)r=t_a}Sqv}U{a#yZN-JV&7$ zgA2kr5Tq|%Cxr=?XgEOpD(YaBgc{MQZCcE;rY{0?bUc#4Ajfion~$HLT}S21ww1?f zU?m&c7iLRcYI+=MZS1-EB`hZa5*NE4d~TQ@2vb`3S%8voAK{#7A^}S$GqeFf3OaB& zHU(g5qjvt^utffL)L&4(BR|8f_%uYIurJ>=oWn1ZQ0r6d+aF^ArT%A^7;yF8?-j+v zL}$s8+e5XxU-r0HIG^1DpN)v{JJAJNG=NVg&P!Q=n?+a_E~6rffhXJeB)^&`q}s z0rCxI)*4g|n%r#^f{2d~>X$Ec+X&I}ID!Ql6OZ=nr#;|@22uvnjj<`ZW=PFghIDEC zX8anM_g85RRAl!2_)Re80UPNW8E&M*e0D0(N~A!aj_2psPyQcoZyguq+J%iODxzRu zfHdkhDMblELfIG~2Hh#3q%@MwRzX3)BDSPKOEYu{5`u&%H3N)*fOIo7XWhQo*!Aj7==+XM*emxtAxgD4*1`V0M ztxxY=ZLETdwGr$PTkaS>i4_<^O$o%7Cxmse7W!8!^X;sPpFriPXG8wPKrSw;!%lew zGCf-EsFp55Kq3SrEqB;#SFoO8Yj6z54DR%NeqKL`3-g-^UItGLiCUdSlzd{WUj24>aY*)a!Egb0eiiH8qzt zHh5vRXkO|!!ncFzAw&fXXfa8)V`A-T;5G5#BkO+nwm+UM+$a^q@V*Be9xZq3lJxhA zNmU}`<{L2A!Clgm&SuA8Z(ZzIx9w0X3#-G|=Qp5LpBtKbp#!rRSn%Duv2NkgE&J*N zzJc)O_WIe6nVKui-IBljO%^kmQ(D7zg=;->2xnhbjb<#M{=kXaZ~i(j5}0)&Ey z-4a&=vrVX-S}r^acu}C^&O%oouffz+9V%Ar_l(U)vV%K!y!Hlk*u4uALgJ^TLm`?8 z5OsDCocJVHRPM`B^nl?Qp}7+S$XWV$Ej#Y@*{W*60r8l^%sq1p-cM>xuh4ugH3>+> z0@8_nwkv7~is_WoOjHEt$3IH+%@uJZ2Geo(Se4-3X3Gk$wucg%8E*dJLcV{=Y0n&VPu|3nH`QKdV@`E^ zi8h0s2-FwK-$SmMQ0#Mhv{Jq!nJ}?R;mHzH`0r8v&mZDZUA1Bl z|M!8FKbWZHfBpT9o@~FjE=yHQj!SkCrUtq>4rU%mO>^%0+c3?x^B9g62kkF?4$}#Y zh6{Xu3FZ&u7qn-_Kb%#%Xv3mX{Z}1k`y+~t4;IAC*3rnG!+gsJTt`d^sY&L;D*%-+ z3Eb`VTWqJU&X!IN5b62NTbZHHIMMne?OA48gQ}n=Yg1mfuBu?B%_8G9m+xdgR!K3C z**}gWF;&uWtMBT1|M$ly$}dXWi#?0xrpL0Mg-)rB{$5G}`yS1w0^EMRdLPEa*KPYc z_s3nM6T7ff4!CmAgDYh|W&GZ*^*?5L*FDhuHpeF933V#l_BYbHxw$aDqQfnRc zOT7B-@o+=_0-saYvCs|GVvA13DbwA`C%H=IVID!}(GvdsGaix?n}z!mx3ZuSa+)sF zoe#?uVsfuJmF;%FgGTA8JM@I#%sIBpY)!0gDuMswXI>B5{DI` z6ESwKgxE01Y4qK6{ubx25^eF>gB!)B-(4y^R(Q@2-8?3 zIQ#t^23m84=LYTasbMX(G8DN1_atm_ohoW8=SX-@-6aA6s}A5WZ4k6Fkv}MFn^ivJ%OpW0adxMc=iM*u z$~-y4h0OwVUY<$wFs-lB^NUyAo5H))MbK`2`?tst!YDkST9);77p)ut@4a;6p3W!1 z*S~z`b9bgncqk`FnbfCA&e}RwJC*h2v9x81vI#fcb7IcTu~(i%zO-&EA;A)Z_Htc& z){A=odE>Y}qF8%(jR!oOBNOSD<`0g>K`$h&zy25f!6hGnj?Cq2IOVd}BY1OC-d1WW zna-WmImLTSth%dAjSL{zkO`Gz zhQ32%s?}r zBu$vzu-p5@L{@K1>}Z8Wb5c#~%tYUqtAvC^G*RRCvOvhkJ~19HZWp>Wj!^^+)LKM? z?HBA0g6)ugDx7@dwk&6!`J+atG!gn+-+;W^+tJ6JQp3LO?#(Mn^=t01x=gjD4U`n# zpx1J;n1Z&d%(@>^?(gtmGBc@vtvI9Qqy~@ z9E?xG)t|N)$^N<{S2jWUkGPSYrN<1bf=Z-KNo;n_7BcIa+EbE-n{SL{e7Y^|$GHJU z9?%!UGzfv`r!Blp-<~!No%?dY>PdZ2@vQEZOt7S5Z7{Hh>6lvyKNG2RN-04zn0~@I zht>0I@oAfZjm7v@rZJnDo=A5=MV@8h#4iwttOE~K1&;gLTy62ZApKKo_TONkeD{$Q zW*rYq*(fUb2^=WNBCQam;qGr_7Q7MGQ?IM)McdNgY^n)>{Q{ z0Uikqc#@6vrcW;dW3^HP6ZViI>9SG>2i;+0F$y8-Wa9Ce7Nyg1EER60)jgVsMgj7q z*3T3`fB8UqF5_HQF*djz$imaOvpQV+*kG~H0j-*;;AEe*hd6Ik_bM2j+HmP20^WGc z74j~IoBLUnt>3Jpzq5&n{|=X0+5>eq7pvl(N`Fwt8l+WdRW0IA@9DX& zM^_DYL5FzSfG2lcmRP6{`iFsy6`M*0<^*g=%Ej%iv#n$|m@H&JHS#DwNw5VuonhFT zlRPyLAm^PFK;wSCMHyg2J^d5mCj@B7scV>*wUzjO5TL=>{|E3o)4l=y&{I>muK=Ta=dl(k` zY|w|zWx7JE>!{O+r`G$@W``m$1D5{veIr)jIb&^lGwlaD{k2#p6gWNTsXOs`x>vH% z%(a&@p6i;;@}|3n14(lc6OVFMkx*LXCD6L7bu5H@9PbE|jP9gV330I5IUPx3^PJ|( z(|w+i;5=ZA;+}HX?Ovo}vLku0lDceus#I(rb0W9%9Lv`f6iNpVIT^;tbXS)a>hv`vY^gpub|E=e z`6@S^u(7iUOcO(q*mL}4^$zEJh|G&@8Z_w5vIo+(dcNJ1-#T4o=ccS~3PZ7r{0kWj zgJ|ivRF99I$h&V^+I|(q@PY9HF89`TY(DYjVUB$(WH(It8&S+I$L6J#Mpx}=bpqVG zS9+>*zHvkR6;kn}?(X~&rITTYylr}F!@c~+bWOim2pB<+-l{Rz(Jo_tl4$irAy(1L zX=iDMWoP;D=i6J{ril0S%($ZO>! z-7l&q%f5PohGT*(X1s#o-#~!qRCieunFKH_v&|A#hKk|S^ONC zReqBSOqPB;7gYg#HiekBrN34G77--{2-a)9QMBo(%iL7JF~f_rZc4eOG%vGZ zNNxvYb%!awqF@*C<{Tf7&sJT|>g`LpotR;8fe~vVzq>IL3!K<|&!rFW)oL@$CsXvp z-^pXW(4>>1Q-H>#Gcd^sYkPwg!leDVgKhdImotGm?R_s* zc+X2SP$RL$G_6R~dFCyk?TiepiW|08Y)w)(9yq|$3SP})vKQyJg{@V7peeU~}e`Tz8t#*v&o_ z7Q8j4?ku(kH~l>ZNcesI=Z9W#k?n!eD1{(#8-BI@ z&Cn{b#W|Q*DN5Tj_DSwi@t1c`^hzEu6dzbaVI{IfbV~cW7nj0e<2cdK-8VNbcLz)C z&XQl5#}~kK^DXXy^r+*~&*NnG){+E(j~ZWmhS{C&)@ ze~DI0m}Pcy-rFxI+|is7t`)I(OdWElnDbPzr*;~UBb2|WUb*|cc&O%LDapn z!~lK2H^2UY;9daAm1kUE@@5A;&0+LkB|+d*;y@a)1mX1v>N?cOxh7u}Zk+(NXN7or z@8#r8UZHOc@VM(-8pmvUKSjtf{Nax?sM80opssEcYXfCPrx5Qg?$UU^_i2RTESgiX z0}X^%<~bv0daQF3GaODihI_^wX43PwN>I;C?&+nul|7i%w}%M+eXeY_sn+>iH_hhv z)hJDZ8K>0kF#h-E+_1aYgJMs50WXyy_U`uu8NIwWJ{R=H=wY45-(88C!L@1E?KqM# z8-K3lR}BmIH#Z*_=l*xq|GN*Vr^5IXV>kKl&_IFz;`pV-9SHP#k(88V-L!f=^VZp+ zeAj5M+r>r_by6(+NxU~lzo2kLEjP>7InH*0_^x+2Rf?qUnwywSb2pa7Rj-g>Ik%3Q zPCnvLUbanNJ!cqK(PWzSJM9dFj7T0)pJ<#m-y=ang96)UffMwBgj+|v?VgsL=#6@*+y3^xj49*^J~WC% z*?rwEaDm#N8OPrT@`Z1c8c$9f;1V+3M9W0oVh@8B)s5K|`9x05oQzLm5+A`rTro0^ zONKDDwudG>HdhIf4$g_DW+^xPJU~-kfaD!hoe@B|e4*W^s4GcDn}y%LSa9E@-*a*RSA~@wath)1U0kF@Il#QPVxMlW&q&W%o<^+*jAj6UoQB7Bv?$x%IP*e`D@+nP+MmA$NNn(x;O*s7;Hn~PwHHw#ls)_lX>N(NQ{ z#~LKvqV?Y;rj(SF)E?nbihlrkr7+M749+v-_gixv>Gi${9lODm&tY6;W00ZjeN4an zsr_JPw=RHBm48(wlVTKNrN+hwi0SgA%lmE*7)iV3gC+GPBxYD&yLK(A0dJ-@n4R@y z0&mr+`7wFM{47eN=eh*)@6!}jh!})v6vq>I5~Q=oFZG>&vcGt&T8u5Tx_mx5B!5P* zh^%?D)3^Nz`9wF{5pD4tn84%>DOD`kNeyGoP-o=KbmQMWIiR#fh1pP9!&JE$?EABc zk4q2Z5?A%Rcm6*wCp;-|%~g3W5?8K@d5#-RaGP>d9a9b*SxPyh&#F1JHs*H8VW!sR z#0=&Gw}}ApE3UnxP*ORZ?lM19{CJ;*pK`adZjDfnM`c}5b2uXPIKXwg<@a!YJ%v4ydY1@Iz=C#q}Gbc)=3 zA%N%yNId)_L!P2z0z#=yR2SgZ1kOYZ_(1Ly;h?sKSDkxJ5C5e3#U?Q^Ao%X7ndkDM z?5h#dunxcz4;OZ%kz8gYZse;=x4zu#b26EVTv3zR`0@TArWuDLZ~?c@D2j>q7B_* z`HmldN{F}^tQun&*4*ki#L|*&$AeE-WH^59vJ=d>_gb9DUr?GG6I-@A95G1{`gWey5&+;>~AjLvUU3LRk%sc%Zrt325uJDV-*$Og6Tbo zb&qfnS|L?Z-5y0Ro4>EH9q4Ih2r$=zM`StyBYfV0A(kA5+R4| zzA;faEyc2^2%gI71sLt{uAoTU_>547kdgLy_8`?JM_7inVdY$FI;b~7U3LWC*j0=CP#{zS+M__<3uLHox zuhqa}WJVJ5N&P^b9))vm&>_#rOEai3boV_9Si0PgIx2dr|WHg{QBITPR9_ByPA+QDwVPd-yP~I>c^=f%V_Mc zVS672w?>+6Z60nb@+`=b=Fa@XZ8M8%R=n&xZ9I*AtP+T@cEU7x%N}{R;?BtM$FtKg zF_ffxOT*@tn*IZ^#p&v!c7x4Q_^GO`8JB<*O9EospAgHzP%t^-<9gCts5h#&t8BOc z&bLTRQM1vS!I|-%?J&sRtRLT?8E$OM(PInJx(5DINZJGEiBZ;wQR_^cs&YMsC#Qcp zg;i6$+-d#Ncji>n5&5LX@J;3DE9yNGylEsj&Fd?wPB)!G<1KzlyRu`I1|G9S1|2 zZG(ng@j80-8fzhmdc<)ec*L_Hwfz3^X_OZu3cioBL1Ctj+A|P9ie~V$Bc#Py*92>h z`lpUF05r29maKiGl+9eozs)u?AHe^NjB5O>TB7!;lYpLt59a|LaS$Rc;_)-A{aJnS z7V{GgrLa{@=_D6NT3)4=-D|pdrv^bE6m7|m3v4o;weD^ zGwk>$kd$9L`gZ{63(pR<=Dq~N;Zb$dYe=2!&+H5Bc=yeAAH(DU*WYdKPwPiwE%NzXFEXX0qL;)3;UxVYo1GV z01Ru!Z>yPV){?bn7gtfGk@R3Ecx;Z-)iI0pk9ph}15a^gIj(tbaAfR0x&ANL9l~okCK6_Z|+sT=?v*+bHf&w;oFTcBDozDLfo1L zzRp$}FeLYZ>wJT&7u@kYs*b+8SS8x6=^rl&^G#Ib`98)uWv0>8#d4>&Iv59m;VowN zon#i18060U@_5fD^TInDMu3po(b2_E_6V6=SjQw%v-RqdqVrJo0xE({yaJz`R4vLr9G!&3Z1X zhk?HSmZMaO&i1#jllOIDh?wl;am|!99kYWS%@GVv$eZci#e4M}^NoVl;UlBZzJV=I zFMg6AEmm6WUYrZv^ESRqo>L?1ICuWs=v1##zUsyY6)u^JC{zQSQpHgv#bLp*{De`_ z*BIe0&-DE=&*W9j^WH+p#=}jB2e!A&HDv`#^|OEs2fC&yNVl0HLmZ68`ZV?Ekbp5xc;wo)Kb##jwDoW@Tfp4KYBzfUvH-2tDrwz$KmDWH3E3S zK@?s&L<%(eSp~Z;Odkb!qPI%%-8MhKslbZwhhG!bJvdZeVL43xF>X3MjKqPiN+e~5;!w&xjqzN${S*KJjI%}eC z{XuesZE=K+i7|d~dXD_`luQ0}rFm~i!f}KA)Qe-iwYiRDK?DPUBs<>B7E90j&z{uW zUk6q`RIu}@9RIG34RkN&<`vyaJI4lRY4~#KI7J($vbx)(6pl#?Qi$c#PbKmTk250?F$(HEcHjzYpO)DegGksl3!I4AZv-)z;i++N1^;Ls8~`pux@1SHsRH@N`m{1z~HPk*Ld&?1gNNN)BhIs~p+29P3p$a~Sq zR3sg{6Ni7yqc{V>p!%H<6wV(tYtCr2C}nwxkS>3H~CCl0^l7LCos@z?=`05IseewSm&2d{NfZk+uYsW zGUQ@60z&2sG|YmDRH_w6wOr>Xbj5(`yP6cLqY@4&SV_{kc2q;lIeeUP=jE4ff!-OFl)*A^yq-fVkK8xLOFv8us6I z&@=iS`PNruis|NyqWQ9FyswPGHy0n{genNn)oUnsRO82cJ|0j^&}5l5DF+zq1&~!o zA*XF;c;RFlrTNa#4#k)mJrRK~CYzo+%;Rk?;^xRtPFcVe(*1Hwf4aZ^=^;4}!%?Bg zdl=mZg(AiM0XIk(3Q|j7IXZJmcEWP@bEMe(b!O|DQ{kI5z(k^`(VwuA!(urfrj~9d z`B1I1_`-BD(v5!xo3`3 zYg_7#w!-#(@|pf~ueBDnd|VCl`$P4oM>{3+72SA(%l&oq3pA@9@#L0USU#XBtf1HI zRG-!m(Yk(%U;ePw_}346M>Qt^^P8&DF33@uen)Stzls#$S3WbgPwIqOyc%}2@!#7r zoKEH}fz4F<%O05cju)QX9+3GzC8))IvEo5`9w*@Xd0g^+tNZ2sy`0ZP&8U_JOK8`G zof^pJz|q<8@1Lq?j(BfXBYp!%Ny1~ZQVDemMVc|D}v>;tu(*1oG9*J-q*L0 zuol9Y?GUYT`-woNmhL>wkfo@>%gH5X$^{w&QwQ2QkRb@ztGLDKixVQA&JnLr7Ij8) zS(y$p-<$_cSkj@QR0kRTEpfJ%m;$zcp7-O12fL2GXbOqE7|aN$tVw;Vs)Xpv@v^-> z2pMVL%Qk(^3FSpVY4K?!Ly1fYl7*v?R4#B0MIFWT>v~{rVgg_ATPIq}V#NDl5`e<( zw$qneZlIPN%(X&)7nI~!=REn)$i4KxQF`*3Yda*)2P^TF{HzV!xTxPs@$Eg=_KIYu zfV!pZbG*zU5FXxVgE|+B3a<3y*>iv)nb$|)#3k7mE8{e>(`32w?!sh%mG|KLBL|-@ zAg&iGHcdPK>;1)59ZZZCQ}2JEIJqKXXxv5t$QH;uh}()7Z(|tqe}9GZ+7U(Wzqrt9 zWaVPzt7Ek|X}(C8Vpz=`X8>N;69~hn1pbJ}4fWLN#DJq|@}$b9Qa{zA67MIr<`JYW z@6g3A#dviULOtLQQZ_p=p4*$JCa%N$!)B~-5X1m+BWLYd7ULUtFWaG-rnTVUl?ax3 zHIc2-ky61J>-c>^;fKa{iir?nQ&3n&IfXx$8eNJ(r3Yjk^3PsCj`;z&Nt8><5#2VQ z@n&XV;1vMF2?yaG;#eV?)g5UsMi~esw)Ff)ISyl;=2Zx@xJ|j~u&9a_h^UX2zL50X zQ#6$PWrhqlS@%+t09g=dS_EMAZBk3^bg{}&AB)H^Sf!?!eyE|V8F)Zrll=L~yBdoN z^PUy}zH9@%vKK^fhY(+ZuA#*|S8$n)7b9QHE@3W8nq6B@xGXrvJP5VA5G;g`N$k!cX+2_;roQ|Mpoy9t(ufukn{LUHZL%i0%D#a4$vC{=s|2`^>*bIO~#F1=uE$@6#HSIYv2;S8L zmNNFM9q8F5MHfH8p)H$t>J}#5M~QM}SJnJt`r;(X<5D~s@-)N_;JMUzX09G-F%%v9 zd(Xik5XJf!$7k*bI4216x4%kcYLL z{=kYjZP{)5Z%~LlpG z;@sA51|1PMR6(HPUNydokuip(xd+TActO}mzql~8$ckci+Crt=5RkU)u<8~`xKpVR zx(KxyYVyZ&%;B&i)UI@KK7TP?!M(SS1*3ey#F>I<;w+t}yW;jNU2(#mhho}4F<7mP zI49c637WZ5PqN1|Od8jslA{e28a$ZcC(1s5POO`~f*lVOC8}c* z82F6j<<}Q0RD~<$k|MoWMY2>Db0-P0mMXC%h9iLd&HBz%Up&_T7i)Y@(RfeT9ND0~ZLyk!0Z~iR(W= zH*gmf12NHT zj#ZbNZvnJcuM<#d}P3IWvlTaNtMQF&Q0~z2YYmjeRo9S^}#{;pS1vG{mVZ=C2 z?U^~UCaW|jrosE*86W%Um_eqZpOnzsM{qa^j%g}%am=*@;eP#(pG&xx_~(s>8?3gi z6iTbD0rNKnu*EKvpHGx)=Kv6ZNYqz-fHD$Q>ANv7*fdL=ncDOWSLnZC!P3L~pI74Y zH+)(s*u2u$6sU1L8I8X>M@S}n&3~-MJ#M@B@nfLC#!|V9O9zYavHo3VqF&( ziiZ+`%hPg>Dejo7R0KVw$B`6jo}43K#4`-?JDvenej!LOsrV>Leg$DUU-EzDYDmBK z;Y9$izSMnm#K5F%2rH1DGl=;E2v?Imb?RiIQ(A#y#4- zhh=0)u}TTtf03ZtQ0~2e)6{U;Dtyq(aMCONC{58t`Gha3F%5ps1ja)DhWe_%O*8!* z!XbLF=n3~PnIxK%`mI5Gm;*xa5zxN9g)~nOXlPG~%_sgqgzCmu71N_LPVs#eS__tk zRt*goZSgstz;zwbu1LG>Q4KCb7mh>{ihq&PZs=yUqmzs zHSa1ts~gN69Xhhe#i^Xg{;hm6cg?R&56=4l(0Uy$a>7`&-eoFz7f!d8@#5z=+9~jJ z-_W!X%jdv%a4$gN&Qne9aS%sxE{!05dUw7Zr`Hhq-g&5_fmBvVnfqw9x$oy>n%?qD z^~ZL_UkVkKj8b=V@&W>G5(w@+QKpTFI^iS9VC=&h!Kpk8t^g>=ZK~EkZwDlO+`(E< znmz}GZCu(bvGkdnEp>4=cXtc-^rteFFK@GKlPnj+^<6 z9EFB$Q+QT1l>iE}=+m1mrCa)VsRoFo1=}1@e2*0KxFk^}Rjjsj9&%{N-XqZwQ`C;a zWY7iKTLXP`yc!i`pgKC*2TCkw(t)?!b7K$$4aO*draB(GS)}3=?Mo%btccrm33dLQZBjDKiZEk@ad{owtAr@nX;iY)oesCQpGU z%{au#o!h%^6{^p(7|JF4QOp@NOu`MPUvxv#SnFQk2{;!j0i{m`m@mS@g>nn4`kls2 z47{(RT`4O-=$3CBBmC>@v-Rr~MPa+pf=C)h&X2oz`11VTyo*xW#HIU>@vbX=Wqle) zxSae)Sy&2?J$jzk;M(%X0|5~rXrbFO!h2&d$g1j4a0SUxe`{0z;%t7yCXZNaO}LBA z2qSH?MQ~&I3Em(RP@0Vpj1&0q`u0e%(js4do5nmFA`s88jN1D#Qf|*$01W$P>OexQ zXw$XmUaTLcnJde~$-U+)L6(=38>HH9#dVY|ozv(Tkurw*-)C+0irbye1l?y zOdwtUR56cksPp8Z!imG(WcWaow9)uh4Ce-Ar(Hd#k=78OlBMM~p&y{-R@o`2QX3ww z{U&D!e`aD*UBvy@G59JlnKg5Z7j1Gx2((L1_40MaZRWW=eMQBc6t!u^rNMBuKm1C2 z4Mp5tXVcHM{J|l@c4j9bT;-Z<0R&X~lzx*1$~-}Ii_%li28Gb6x&)Vjr9-?TBxdf#HuJ@4GyiSITRScYVC5;1lkfq0WU&Bc#uWZkl5&MRw7E<#( zxV>2@ipnomROv)jVrE}Lz9_5xXB=|5Cr8Wnj>MTeb3oSrS+A4$pC-yQQ5($hFgWv3w|OmI*nFh=<~14EQw0#$g@ z#+AbvG=Ih_A%Bpeu7*HYkAj@uJO(;{y?Q^Wd-r`dnr;bVqDx?ZOdB3+4eAh5uO}@o z%nEpY1X=$sQ78M85V=SyHzO46socdw10uJ{s5)D4VXDJ35e~W|H>%)3*H11=GajJo zX=yNCd_Z~ZKsq^5neBDVRGzV`ul%|vueI!I9gE=c5+eVv53+dawlcQjIyyKgdwQ22 z@?XE~$4Jqd66dg6ciJ)5VF1tSOVU?xNdX*<_-AKE*3gCnL0f&q7VMj0z3VC;&4bZr z5pkU4#1Ex@yeRouC3?i%S6y!3Dz5yL5aX}FQIA9qiUHK$Yh(gJRJa4BKQz#h4o|B; z%&^hlO3}ZZF@|`!G;ljC_0?6HHs>46TFMiOFQkLndYPrxwg?9?_LHBlb$LzhoIK5# zVCnnM>AjClH*MM^DW_=%iuF>&#jaQ zZ@qSkeNB;31&B3vkro%odH_>NvMcXfYX-#w9~v8#XRaPp4Hb3P1*w?@6jtsG1tvB# zBc9hRq`Dvj={fwkHB_&2|5ZM!t|lE1r;*jPH^exB8;`p-QAmoJZD2K|QZ>D$34U}h zS<5&eU#9|J?>BC2{I`I)X0);Q-&P9#$IXqS?^NnfshSFE4eVkdDCX9KZv9(z2C5$D zU>UMMo1&f9+h^5};;JdsPz&@ZVsD`?c^9I0X#Y@ZNuLz#mg(-T1#uFl#vON&9fH{H z%~#bh9-KD22u#wT+J!9XbG8pMIVjgc(-zw zYJi878Jejh^!1Tv7URact9gRs@8l{7m|aj-pRi#P(gdvyN@qTqLhdo*o8Yw1TXg2@ zRKa@Dt+RvK<~>fiL4bQY3^E#csngp-agwf3k zW9X}Ej;>4V2_PnOV1;nO((JA~{x8IB;(z9n)J!i#so-@q$q3G&&l|p5b|a~`Hu6%a z!D`F8?({DsNS8DP?S`}%lOYY4Pe>nDu%ut4(XIM5T};8x59wRTXfRM;-XeE63a5qEKSO`KeR?S4$e`ZR8C zb>K=kZYgVvVMcLP`!6$z`^{F@q*qQ?Dp1DiA8CYOxbiDV*0=XSFNB?dHky8HWcaMe zR=>}hvnipKwOc!lxy=vOTA zVM6a;Cl}Mu5}QZo#;Vb2(ghLZb;iR*Z)c$I#*SvcHf_M951y`wX|Mp#L60+MuvKKC zQ`#UDd*`JB#I3uUL8$1NWGvBQxf;LwYNj_~7$0%B{zTM!73aeZ>MU+b&SuCy!(E?7 z(s;Y;6ZRkq3?Dn;I^e)DYYIVYuP~UL42W)}bsX!=d^>X3gGV(D6E)n5^>1iVmg4bW zCO|60Dayd>Z(JoZ2x=<}INv3Zk~Nz|L6E|Qx;M~2x4<8;;<_1X+3Z0MJ9XPAI~oJC zw7vmx0m~dEam85gf0s$c}jiIC0fy}d^( zS)-CtWy6S=_L9$UZc7_lRsk~olyKNrN?AQTgv9W)zTUFt)Oz2nuAz3LA%%UfxyTxa zB-}T1UC?qGDVCB8%sY0{95j<&Ic9nk9fxlxK!Std9;Xm!Xhg2e084{bL*P;F2isGiQ|yUa`Z=Rkl}Ie8oqO4(4q!wj5c(1wa3biKD$Rk;~D zZ+ULb>7}-9z1bbrtJ#lUlQshIbA1@C^4iakaLz;pBaMs#(nel5VTgH z=2jg@jnR`#GYSx1M>{kcFhFXa;%W6u()$(%uG%-FnmlO!l6Ph8lmfYuJ%jK$w|pA( z0KUzLCi)7JuFh193c}xu5T+>N=BeWRWuzJZ=>^a+)Vh+698mg<5IR&0HJ-UJ(?=Zo zD-L4-<&rD2erws~1j1t-i$FEYX2RACW~-^;w(#c%WS;FnYU^mOHHF{!rH9FBPf-r- z1DS&4f-UFmVgwhV>Pl(op3B&X?7SrU?knrycuyH;BEbr8V zO3#CcEAZ{#0<8x!pvO}?^xE(y=aF+QraS#hfr7vCEG4`g3LqF6Rw-#%ZsEGy)u{;{ z;^QX~FD6FDXT6)hXL2il5X!rinBnc}Gq7?R(f7p)d$RGhR({@-!RD3oe+JHmP3}80 zV5qOS@|yg_twQMiS`{DD)CGr7ZtW93;UwBk43L5LgTbL$pADF*)Lz4fjVS6z0YG%F zW+$Mu4`|L-TuzdDSAdtAQVBN&kBMkrBwZf?@!+_un$5n_xkCE9t%%Tg{MXVcCMa5X*S?1AAuzWKvbIt{7Nj~L+)90BU-^zCYQgaYlhYoVB`PQFy7l_YK0_=zMl}Hnbsxcm|)@86)%pFuW zbVKF1`Nni-{APmyj>sYB4slf;g_NW0X5@vxw;|RZnH8J`L$V^1rDEShN8pq@l@z?$ z#6(d)xyPNr)iZv>kxIoDEUsQdc8ebIU_sWk=YbE1%WN2Xe2 z$_Gqu@+^X+cIRvb>4O&ti2}Nz)ZmbJAoo=DZD?Ft3i!Lckqbx#I#BT;N_3+|O2xp* zpg`{a$we@0B^5mR%nXx$r(8}fpqeZA6uXanzPD*!BJMO?btVMTTId<^;*%{12~Z<} zZwVfqsB&);{XjBR@vk_3s(@ZuvkWF}d#{&jHyL*Z8M5+x-+|gi4X-LV){fcIb;s0!p*Dt9|OjSvD_-%imrU9*`GmfJ7Ws_eIBX`8MlG z_m%Y-z7L>99cB=@V$R4dg9v%St^hrc`Kw=5Dc|Dhwkc%_&eppPb!O67&Xz0XZ4)3l zSwY+pS(~e@Mp*{znOjQdnDU7;Gj&V{ilz|ZM)&-t%_sIp6#xeI zy2UAwn`$iF+OsrTbZq7D3f?`cull{d){KtTw$l&$c*K zihQvy$QLV1%G{tbeh1EQI``;4^5auRAX_rBRmsK63w7F{rcXd6<<`nOb-O^O!i2!B z3^kD_IqUKJx{Z2H!~%0skO3Sc1HrG&wa4G8j!6$nax6f-UIINTW}edOu&ib!Kz;fsi}f#)6qGc+!Oi~u-eb)GlPRw4QMmYJia|Tzlr8?0 ztFLGtMqVJ~jY0q`o`Ge}mVekT@$+GmrPsrs{3HW64}^u!F&*EJ!ESwD{jYygpvLTn zR&lN&Lg(%)A!xJ>76=A6r+}WH91EhtxT6HJGdn!h_>Emv&-?V1i8OWQdMz-`rKn6>HgM&h|FfG*e9>x(|0t0yM&BJMZA{YB zg9QE28xscQG|*G*InG(s3}jn<#HwVj-L@c9MhI{1ae23A8qhb`0vg#0;PJLddLjtX zLkCh4L2blYK%YItQ^Bw7n7ujtX1yMSOEMDULnN`PlVk6930Yq|2_(k|!~#i`j+GBH zXaXy`6Ko-8(T%5pv?q<`iz8A+e9mhwitvMaxt-)Li1QwR|9cCu@?LTVkX!a}p*?Rd zK=~>C8^=K2v#mo&QwSb}yt9J@t`JFZP0BCFV^Bwp9&58qC5`d&zrJAr+^KFYW4rg0 z*lXZY0m+m=5=p}BO8(t#m`4^sky1O<3UP{}-d=u>bqpDHk!_zs|0%zSO2ZKTuFObi z+g3c}Le6e~(x9KHirQJNMyY@|lUc^|eeU z)9RJ^n)x$itgok1{*JL`PgK}&byX8l19F`PlMM{IX@~ZOdO5^SKHY7MB#2M-%|7ul zoFN-j?mcMs((G>4_a$8Z11?Tg`{TlvX2o26PfQE=!*T!5yA-JHt%35Lbb~!9Ke(iy z-jHuE(cZq65fWdG&df-IKQQ}vnfQV4t8BMAiUs>l?!G)!Y6sn&%%LWD3V;UJpTIwA?}vHcREo`PY3I-Fjvi#T&Rv?{-S6Mk^_!#w6wv1uk?BvCt z+}{=VG;E&gwOTs&{!1b1sx<&EcRGf*Yhhz*S^ac=GHR8N zV!=#q&5Pw##7j5e--j2^-Zs?$_1I-K8DOGIkvo74=RVBfNRQ=HrCGAp%TEz5P6IAT zz03MIEQO{xH3hOKZ4V4qnv--n@K&uCovkpx>-SrKnd=CEVThD?2?9MJm3M&~iWeOS zSh4Q^e!W#VE}&`6sM#5p&&64KT?&X?-wdzghOYm&Hv8Yt#>HLMh9v0`8z$Y06F93K zC}61kaz$FVbbr5p=OsUg`*Uls|9lhweF%*GTJo!4W$1l%Aa6Pi;}q8>|Z7bk(* ze5#e6j{CiWo&U9A_HuA$au2 zh2OoxynX))P#cG=ive-6c4TFghFdIc4PK=t>+8NojNB6@zUwLj?b;p8;`=zmKmSP) z#eVuP#^d)7w*YU<*S$nGBl(_zR?Z%yt zXx(IT$e}LNp^YD%v&>24K^IpIK3g(M8m(N&R|<3ToT+Fu*eA&R5}|iiW4XbfuisCW z2KQ(~Bd6Kb@!yNI|2_NKbnAqIt2nud&;Gx7jDiar;VJfu*?M9G`~mzp#aKR5>15Vl zZ`b#I`#<`j;4SsZo9#;4tCwGaAKvW`_~sXRxz8E*^4SKhCz{O6CA*V`2}Ovnb0YjzQpoW1#hYBd#2tx$?sngNKge| zbjND0z4WW@KaHHC4pbJZ8OB2w6V>iktcgaefx)qws8q!~5dre6d00X}U8>4i_Gh^3 z+pghNKc+GpV`SJ%F1mKfTG?uGJaK?QE>Rt8!92Gosx-IHjbj`w_9Ju@(LBvw#cwaH z3^l_3sOhnm!pgmtt{K&Xmj%u0(|BKgPo~mK^kX zHOi2tFv*?A$fcLR^Rf@c-GPCcf+P)T@eNp?6h)h;qQ1#{Kh|PC*;8YL->)CjwY=%} z)__B+UCoclv85OPR&*2~g!^P*F<|T1TYvo&)_tQqq@9v+sy7BJC(*t`5q#0`&P%4{ z<>|nbNfnTY^6&2bUYL5sj3Q1k_V~WQVqfg(WS_ub#rvIIF`;zH_5R^h{I)^<@2j-= z*L8K3C&ZO%^KI1ZxkQ#-s2@Ln*CX-RI>rxWZY!N`)b?RAzl{)K z*{S*Q_1}-!E<3bwu-wg&rY=|;S0YtlV4*i*5rCP9ENqx6)L7(Hz^W$tsrCHl@d`LM zzT)>ZPA8_E)2YOI9y(4qNb5fKtTf!1@4pJyiVXfx@c8#7!2Y3tYOM*K0EM*##yz+Y ze5X6fq%U({kPPQ)eHtdHcsRev*i z$9k`ypCj!L6joN94T=O#vk$K~V%&%K0pio?X2&SCGqFA-LLuy9&xO9)*PhFxnj=Ty z4jb!s8NI-I{gQ_~hz`(L3;xAp%n6zk6#SmCXOr-y=QHXwbLHa{ZCdH>-W_5 zS01yi#j>scKJI==cD#yuc1y_9p1=eD9Q5Vi6Lub#v=w}tvJ=gIEXFu&kwR0b)m3gM zrh!=UHC7n0Bhv8Q1H&&7v3xt_K4hq&{9(n*|2?DH_t4(ld&z*+7wRWpbm^*WS_2vUPr z=^T(w#Q|xg8v&(;M!LRr2<2XNxX$Gm7HG%F62how`%iuc%lx?pc>E-~O)Q7_B&;C6D>!06Gq8_X4 zd{6nOmqKCp_1XyNb5R}mZ&BM_ksy)&OcT(g1Jys}-|Jp21Tof$j|tXqBlnI}jYdvW zv;G{j5fH(De0Ac$%9NeD|~>4aEfJR5BLvvDjZ^m>l5y138(7lsC-@G@Nci#f6QSr;_YASTPFjHb%K-X+ z-%2-wWInsh#x+No0Ljdcaq2dGPe0ze_SX@(rqUcWX5Kn0c+cVgF$o(i=z&vDnpol> z+-nh#B;+#lPD5#gSKL{jkoBbwxy#-$i3BZwl) zI-3S3WqWiv{(Z0Y5ra1yxH7RN;xa;8EqP0%Z`E0M|3Bt1B%Ua8IIfW;F8%|WfT1Y8 z3z>((=Zh(qem`bZBRM$rq;!jDLJIOjTE5T8x(}!v($X>?9Sx(Tw46#N0>>UXE+U?_ ztg@4pP*peYEzD1>ks8|ehuitps;nEqzg6IFo*yX$`gjOe&YY_zbTP+4MD^V(idYDl z>TfKc$!-gJ_Yt0lpGL7>H27C)Am@BL2v*inW-uN+!<(S>*ZxaX@`#ZM+U^(1NWkE4 zFn4(;w?npQ0Ma^3Tt;9ubdMk*%5Ka({ta$OV7wcARUoNr7B}A{9)R;`d~{vlUoX4< zVtsbm#n|QsnMPtli?#RWad7nhZ;Jk7n7aN6-ybf9ELTqEi#PiT1VePPNWn_{&@VQ3 zzu)Np^#Rogtm8=hV@UO(n9w`3h(NqSCQ?nXQk=FO#Ktn<+06gGlzD%Wt%%L`C0Qu~ zMozaE#Q3m4I>DWbomU{Q-)Ttq`u{N=#T{#=CvrZ5l|ZVgdl#`iyDT_D3C-jGJ`zNV z7%n2Ye0cRs_oAQO@;Y;c;)L>Ri=WfpFhaS!?s9R1vvuOXIjME`UuTHuQ8l;gn+EL| z32X?0RYM_Ry;Ac{LMp@Y3CW-T?lB+x-({LZ9hIIwX2NVr$=g)%p_jmoyiXyz{w4OE zJE8R|&4N;=|D7$H2;6CduOQ@JE^>zF-j5)Zrs@_W5yw~Bgs+5LZX84$WkZJMUpIK_ z?>$NHBX}hyAEVUfP(lF^$XhKECZ>EM;BbHc6hc06?J7UD?~9cryql6h+LR!IM23{A zSAT|qTqldfqNgA)6y;5ON@z(5tDr6u38bmE0zr|Q(U%D<#9r#>5d3VVkNyd(b)BA| z_K{7$Z~aSnQ$C?6lHgS7zDLR>MkIrFndF3T5~2uGSLn>(2ZrGmQ85&QEz|1hDl%rBk!j|VbnuEZMcS^*<_YQGVfqlawB994!x zhW+Dm0&nm?e1)<+u;SedP5rws5?Ec`7{v6{(RvjTlK7hppk4m-#RLlz1fGI?wTnc) zT?@kIU5*lj>I5QmP;Uvu5Io7FzyvX~!t6VB%Kuq>9-ds5=o^`>N2_`t67)?p%Qd^g zj2J=%!aPYN0(z+)|KIj4f2oXlpOLk&*FQnPPD$qGd560`RwkIh^B|`xZn3pQ{Un5f zJ7APgX1#sHaQZQEf+-7i<_pSp>E&2pYfPwB)}S{re5^DvZmK4|DC9~rM`ewknh~18 zhuy)-obQlT3dMw~;o3errL5%q;irjRugIz@V2<$) zX@ta_<0*1fKxu157n6qh%`j?L#5l3I(wKDX zE7fOzp)~pCfT3l^2lUf+DVatd!pbOVD4m~-J~!3GJNGCwN?SQPF1x{8=+0kDNzid^ z0Uf=2EH7RBq2&=&f3c63mS<}l`rv16O)9+Vhg+NmU9@>4eRL$0T(qRIGNUif3hY}0o!?Afj?5!+XWZc=^SN78I2B~oq86~-_A|hQ)`o@2b9#m z2|vA$?Zp(LlT1^aN2>_#h@c)q2x3A?PoRDE-v);|TO{S3!erG`GuPm6Z%)~k^(pID z4z|`MKAF_RbULSm>BaOp3&r;f=m>Xzu)cM8LFVbff2f*>9NnCG>cC$;dYQ-`-Zu?8 zGalbsk9wSS6f1?>LR3>!CsxNUuDI{4whFVb_GpH2pxH#!tP*a#i>IiM$0erzjk0&3 zDtj<~wk8?3C{-?n|8_3k%uK4VxL)-t#%Za>R=N5Y6GJz*AUAsZDr_HGuY8O8qS&>D z1@LR@A95R_>It*39|DUKC7OBEGFFeZPF2kjbZvdRq&J4{vdye0VCt4sU{Noy&aFR$ zSANNQGN)3Atj~AsV?Vi9MwX%mlXA?Gb?EVE zfhp@YCH+$4^N!fO1Wy;w+PBKpSqxiWN7a_3Nm)|`)W^D}PG;S%Zi&i@vgaxIqp5%P z!<}#|d8}XVlXRPCDwFUr$^+5<_|qnAcG8iHxQQ>rL`7W)SQR4wq`Y7h2{R9x({dP_@gv5l=J_!cno56jxI^|*OvzI zzqIIUAwvi+vRd8rjt@yXeLcr?M2ZW~_+Mz-lW14la)r~tlC8B{wzOg>>2;irmPV90 z6Hn=($Wa9>UwBkX!_kV!EX5c$;S}3*;r%=wxF)G_g*&e!uzsB5CO56Lc$K4K#mbzd zWA;_dq|DoT$Xybj(-bR>@SP zNlA~A7S&w%kQ+8EIcjWdRBy1xnNztw*EdD4wbNNEmWB76|Cf35u%&;bi6}|BC6W-Z z2(k5ZPOxEyc?W?7y+dS;_S z7+>>}!T`;lxk-nhC=B{+WI(^lydyfMTm$f#M;^IOKPqyalt1h59#qk%e4@6EyUsLF z^;B@?*PdoraM#hm3L`76`dl#$7k7pk&Tz~^zcFq!BWV0=R9v+2m+@#Ty(}>4;q}(u zoU=aOWwCs@49RZJv(CAd{NEgpy2bj&=3mf#MFhY^WC5lrY7Nkpm;dmv8Fd}tu+NnF zB~oPy&i20UfX?t8Q|+#M!80gqcVfOx!znV|_DbvHbz(@EjF{iU#qmf;6AjU2%ObdRF+vaO*p>CvCTH)z{R ze+|=H7{VMnL0h7u;z83j(=u;+OQ)A#DVn;(_%{#KwImuH)=pxY!Q+%_12%z|MbNpF zq&mT+`fW!IkX#-8tKPN;?9_|e0s7!#DcqQKtg#GE0UKsL5NfV9l+fHcE8o?PjNnvo zbW@@)y(s|n9doQZ**qWFH(HHZ9>ma&etZEAdqKf9*i(9B!C)k=OaQng!! zBHoy}n`&5L!T$^S+}F7;@osk-o$bC@N5utnf1RtJP`j#;W7jW0QR2nbJ2|g9gXc4= z<;Q5)w!Se}lCHLQ83=RM)7EOwNO4+XsaS8sP(}wnE@l?G&Pg_h8w=hi|G3Cz^UBr# zmZ*w~BX;4D+_~~mMwvU}2nI|(PxGwpx?-l@E@#i*Lr-blB z&kQfp%{8j$IL*wDOH?>@bM^4jmj)Z61NO%Ob;@`}%MIZ513R?&SCJ_EOR+6i^zRu}^I=8@wOo6Ca>uSolYe z{D4N5mu**il%Sj86`^>0o%%Y7p|sjQo+&*?I}A;B%n2W1oj0=K8f8%eIG4z#$Q+yt zZcY&srK)sZ$@)pU+MvCnM^JKjlYfEUg1z)av`KV{*FvJTk~RcUgLOy8`wKqye89`q z(@ac%dexlnd#6C%a=ZiFPLe>ttwb@Qx4rlWrKX?mGl5Z9Sj>DbSBLLuScvgipyQ6M z=Z^RF&;C;0Kdpq1LmP&T-h8Iut5KgD$6Dv!lhG2D5@jFrGAPQ<$Ysl9pV@TIbv2Bog+qXQBB3bo2U z7`SNSjB>SqWY(=f`x=;qSsJ(TkC-{Z0=<6Q0F_%Z9#4})J8`O`IT~dR+Df@hIhB?U zeJVZy7;EN-i#*0&T;RWViX_czlE<`tJFZ8QC0`MRg-fgP*XHQ%YVI~}cH!=j_$29--ST7E*+A__b*5uE-=^Rqi4_ z_aU%jZ`z6yM**A*_x#ZCqM0gI4>wQtBBjYVx>ytTW_DhoYpyZIx+a#rq?A8V%MRHt zTME^1Qj1>9P)-yp5(aruSaO0G7y;YI=C=1l0Y?hF3k32ozDSP;1Zf%XkS_Yw$E*U0`L%5 zeJ8`W}L86x3fbumGrIO8b9vGTw zIeh+G^`DZ>0(jdVA*2=^nSj>v-VFi_A{ob~>h~A6(U5BcFc460`;@GH9CT1}T=cx+WVFl;r z7^6gylUUGE@$T_~nd)~@g%56f5w`pHDmi057QhDe5Sp!7{;ulHl>TC1sc{Q? z`J=Y~6G7c?HQ_?G-_Qnd9P27^qOUIQgmxife`c%~Gnh`%R_H+8pnFdgIDondspL>S zOXt>dTW1ARDSgY93tu7gpt0t39@qbZ{}MmW58*D=Gv8qa+w6wfnG7kD8_tQZja-=G z8*=T1BZRPK=X(mv3dcsn>ZQiVy1v8*Oje8~zHUgRE=g6<;vG~dm1w2XSJLn9!U;vr z>D_8ra6B0ArxA!a?uBCJx<0$y2CTw@o4x^m<5Tq1xyjrUp@r%LM>1-MLS14gDx_%o z$M8+^6Z$TTEv)R|5hmohy6vL5BC=wJA_~j|%rqTa(~V-o?%3+%Qe5iLXQ`}@rp~Y! zuzEvjByoz5MyjWpJHDvNA+lD&EEVe*S<9Vjq|KAM;+c(OrK~f*DkZDn#;wJ`qqWX{ zm{e?6Wa%!nW;#XTHq)3MCs_LetyC-amB)iMrTg?8Rei&tP=JXY`M7_<*uq%-_+{pP zN)xI%iea}IrDV5-v8frnVs^%4Mv7jnw$)r?DkizVuJSD_hAO^`AFf04VKP&6pGjsE{N*Y4p&5+s6Q%hMTwPPr}5EAtcL*V0fN)z)i<8N)s zEaRVK4<29e*Q}rLGQA(?eJGrbXCP&MwyR+@&{zVe=TdE*BMLP-8Jz!HsM(~)X>+F5 z&t){tqzp7&xSKaXiZEbw0J2L!yI-G}jDtK9njx7*0^MCet>8tNC{$&2g2FE9RtQe* zM92gAfPE@l|AJu5@n(1C=7i`W84#lqox-wQ^u!oHys=A8cC&5uq#sqqj3r(V%X*F~ z-cfgj*;tJ8p@7l3 z@J9ECtRnzB{O7i#_PQ?CsfDzzPK%jdKy|krJi@i*yiOr_?0Inbb3xzvcY9nooB&y6 zC_R367h?h#w}*%eMW`UV_%9^=r@HpY5=r9JLkwaelQ0Xn5NOU*RX6_TaVz0@=vboB zw!aOKBH5_tdVp_!o{ZBKqK`kP_s0)}3N$`Cs6&hquE!;bky|6hOd-hT-M&IXYrCMY zF&a3G$z|)N7*l=X;CD$IYKbBZ z@Tern8;5Ii02Rx(6Kn^IHl5=;>GPeoqk+j(`nFS$vAf*=IIL2Z7A7VT-tCV*d)Bxr z)$f2wq5Y^(L6Y^NKsW0*O%;<@rj~5^{g^}HMl9tMfK9d?;kiXT!g~Zj58HM9!^#rAjCn z0())@BNw@D{Kh77yd!EHKeMpNwL745m)>r-$aKFPDPc^Q{`JFokmX5rAi$RS{k75g z;KCGUN)_fmwO#j?>c%)WU3*0H9`N9fXph{Z`V(jigm~(Mg{RUh9snd&63>;cX|h18 zVn#9tuj-~`lO7B<69BM#FgnHN;(mhO&lg$@D(XxV-fg`G9k|zErUI54OD}bfJI&y! z-5_lhdXektjHJr&fo;-bDl*Uv>*QE#TRp3^Fg~gn>*TnYp<$LI*d7l#rPo5|N=oCM z#lUZyj5dV?b3spIG>7f>D^nb2Mr*x?cYgqy^^IthG^O=Am%yPxG#d1FMk!oR%`tw| z?5x6se?fnDb!=>0w(lsuzb5%CjXvic+b%=X(W}eBeWWTA7`-TS$`VgS55*YY7R9A7 z?2H)2Vz_UPl(oX0$g@0UZVJ+0*%>JD-4#;!vsx8;{hSafG=f!G8XqoDb8 zKb5SC9)tSUrtz7`7R4A^+pe@osNk2f!`4FG*Edb_*az;1=eQ&5CCsWFq{b7mb3x4# z*=dte*464#<52}gg#mTO{=V@+8AB>Tii1wKRJ*vswMT`&w2qno?j2Ow?Y5{YV>k5{`t zcV5;7G^0HTEx^a%+mViReaj&~#%XMx%>UsT&in3?pVKRx&Fq_-+bFeXt9&QVKN@HZ zAK;HbsArCBi^DAbOuj$P)Y2t`fZ!4q>!lThDs+Mr+bHM#v{ z5{3q$wz2@|q(^`bQ7`?qm^nUhiKYSJm<uxhQ5d;T55L; zM8LTlzDVB9bKhQ*{e``qQcWHk!%D$k;E)}EI7v0yc(>B1;*!f3pyR8E#L8o}3oE>^ zemP3kkx^_yj#a;?bbjK_ z?UGpIcr;bv&1Wh;3KU-YHOVT;N;v(p`E(7lsB9w^Pw!$c)6qa=zsTjh%2!2Pl8db= zHjZm8&ixUKp)Qb~2hNf`fcU8e3D9?6=9fPyg2`Q$oPUpqtbU4Z;-Py;29@C1C5 z`81Cd`g9MG@U&RuTL53cqtvXgtVL8B*G+PO^(h~iSZD!teKgPrUOjjdt> zEC`deS#Y#UD#{v;lR*L55 zXvUcl`l+Ldu7);*-n%zkBt@;o4Tv2QhI8i1myG1kIo__`COrKP+3n&Lqctj5HK&{c zhA!?v%YuW~z)wYA&H%Tak5m|!V`Zdl#iK%~{}Kvh5fH0*E%ti72k61GrX|TMo#Pyq zLBVYP9su4hf zW^ZKRdr8C&#hv_c0E@0PeVqnrI^7Z58o6W5BHdtVlH^*hyR;Y(I`FYtQ-DVz41Px( zdS7(_FNAcQC3LEH#3YrAr)>B1%0uw#;62!K=f^An+rB)vq)61VYdrns_T^=vra}%e zF*BbFDo>NFIRCrQ41OD?_!+hBC@E&9)bKrCdn#k3n>Ux=2>=yiwE6(lniGQ&tmclp zGQ(@G&ryAAOWJ@;EkfG$5JA2kXBSsbx4NO^&-YJRSkt|KY6x^vO;&{9+tsN`-0Z(UV+0pcubBLSf+ z(Z7BMGLF)yJRnwn4@_A+OOlespC7P0UHiy$!rDDtWU`UQWxB)1d#)sRzQh7Ba329) zcgC43TUN%;(Tubz5LcR|N)YabzrR0iAhF~nr`_F zs#>3;iCiIp?Q&f|B7{`VzB-_dybbVbA0lKoMXz|9ZoVG*)VDR=W0$F#8RbpdLaJG|CZIqG^|Dn~`qj4Y7jhv*)OvuU|LdiIF9_Y}gol~_E zL?HO{VV}#}^jsX}2#Y z&jm>@`;RL^V^6;?I{3lH+&z2*%n7NaTOPdkCktTx^Ldd}#1H@!5qz)6si<@EfSU3> zW}y*7ziqMncFut|h$9{X=PN@q$=Vj+r64i|$UP3~MY%z|y8uN{D9E$!(9$d`|9oq(VzoxbrGxF+ku77_J4-=QkD zzgGf`Bg99c3~I5g9#%DSSLnO$bun8M95nnBAzEPYb1pY`s1A4!-c#QA7hC$j&~T1O zBE#T22FTv6c(rRQUYja-Jh10^Cs97dbhYq8bpp^?zSxT3w&nxS^Q64ynyAYnr%1)i zHav03u>*y$9UXJj?uI?rtGkyF{51V>$?A{1Zp~IDtQRK}-_%$FKPjy(aZtnBmke!FhO~*h|g*02&E_3^fXW00Tpn3#{ z?;xg#W!EIc6OX2{dIUQlQ)f+HlN#cFVgyPeX23?kR_iUHccG5Ts|Wn%Wgmy^k%U?< z+aciY$R($}95Nq}daR;TYuG^rsnJNhMi?rW0~!E2j+Y?N@Qj#58>*4e%puVgq{qAn z5}}zQ8HVr?aB~a?sgAItAT4=x>tb5XC;-Esa~gJRmpJ=)b*x+rpNDT63~WjLJ|n={tldfKyJSdZ6#rxMV%3YS zi6Ms~YQR}KJlMh5suaPszSizMC6%&^S#`0j`H85udG^G6%zP2%U&V8`N?M7a=2m)`jr=6ip}GJJHMn1Oc985ZE)vj>EA9n~!+}D+X)xPi%1E^WSc4 zI{SpNm=^~BXlG>#pcR1mznkLr~=peK%#_C+-&?BxCcy(>&8`)^;59aVOg?`WYxL z?=%3uwge6eyA{5AtBSt~rA-VcngKE<`}q@sXcfIg2nadC{wCgq=a*p-|`rF;jQ?zjvB`F~+@g98yF`g+RQd5jmj);jt>3%w794m@EnD zPGCW^|A8z9xFp&kilvqWT)l|yeqtceIe;WORfDaC5q#xtu2;GY*UZqG;I4}tpi?<6trK0fADmJB^2-C}^Jxl%SXCSSU2Ytfu{jV) z&t@tnuujwu@?cB>PNyoN2*iW#`*X~^ZR>dtWK;4Q7&T^(vBnCQl#QA?GQl$S2cKNs z5T`alL9M2S%-ar(CN_AAMS2L5H)*!Hami{eLtGKotMds_or4awvOsAKaW zb5`}wLxARyy6O)xe6k&y=J&2G@b{Ho_aRLEGm;)yIU^(;XV@BamcyK)d&nuUA5+$Q z8EM=o7O%K8as0IJrhoaYwQ)gJ?Ku%bhmenuhgFelkD^tc>)qe|+;yDi^FH7b8?GYt z)wB{r=#Z5*c-I6AM3~cpg4cu@;ZiheU`=f~a|;S*U~q2|L)abuWP$Oh4%Bqf$JU@o zQR)B=sMH+y^!LNO3;nkUNp=fVWkVUwq39LrC$dDc908*j;ZWQ5Wl{>ZwHNDEqML|O z$ZQ=-c6VAgcRwxjiG3ekQhgkRD@(K|6JJ#rMg-sl;nduY$ZcskGiBzxojbM?>StYh z936)=5yBH=!5w#N?Y^xbO)eyobIPFtXpi!>^vZllT$~I zz^I|Of779xkPe63BXns?V19n8-4Z!Aa=Ka?fn6MXwDdjgJ9<2kww*wlVB^64HU ziZl!YB!NG~`+m8by7~a!lSByhWg4(UN$BT}JYZ+RZ9PccZ(xZes79>Il}cdBP~S*~ z`2bENDUHZsH6^=9mG@#?Iq==O2pp$cKdk5&(V{0qe8)fg z9{#b^y6Pkdhj&#K!U&A4t**Be4Qm1wFRW?}f=NUoZadTTk9YZDc$ZbyJu?qB5hWBfVSinM6SYWo3v62G-+P3nbs4|M zpsIhZ2rl3n9t-_OFrq$#0{*W!?#bm4VAmO0h@>}NaqQ;8s6_=kyi;QQ2_|Qq(}Uhz z@y+a1@ozq@C?|uoE}WAK~m4T23F6-yldB`lMT%bMX zVI`$S%lYf#oe$|qPtzrmp8iXhQQS&vnc1s{5(m>mmDz5DiW;+heWvbj5@+;O zulrv5VY63sr`=)_x0@{u3{N%C3j01Q~_v2Mjn}|s1?!rHBMRk3Yo-r~b?0I$EIH8rlE`Rl_e-x#3fykvBd(Ng; zH;%oq_=|U{)se5&Jk|Fe2|=af49!!6eIlDS6Yu@)KR0)yDx8O`%Q$64A1@C=^ zJ)p&qDtqq@3-b$ho#30d%g)wI#^{r*T~>K$GaP)%U0N_V@zh3Mk#z<|kXnNZ|?>Qo(;Xl*bbRX$r| z<}`Bx5@|NLz3nkw93QK8RvO!^_Hd9U@TKdK!q%pX9u4!_G^6TBRk70ZnaOom6Za6j zok%iCOpj*Wc!JeLk{+&;`!3Wz=?gvq*Wd>M<=;xyzrU!AAp*8a@tr}`0mNdLRbUNI zS!UJixC&xDDc0okF1;>^yGAp1_u3o(X8Ii{6VTpjmrMKaxF_aCS|BsO`0pn^rDh#)$yH4Pr%0KPc+@4s=Klx&)Q)K_}SgAS}y{eQpE+RDz5 zsV;qHTgq-+(>-G;-J)mokJ)0A$^{+1T!r4&ZKv5$Mwug#n)bm?s6X5 zHc{_yc{{_iYmZoy#D7iZ*<(*AC6a);6g?3SLLKwSp)Nlc?Ge1?*l#Xao6Jo_=dDfd zdVk!zvaWwE+r~FNKs)!?^j)*~jyH`OJ(15AI#pLMkZmWLp9-86a{ab!&3>zHbi$j1 z-M;oH4k&-%qhS8HxO({$i9B>b%9wb!@%`a7>+~A~5TS$;FW{r+lJJqkIYg)wy?bGK zliTCxwfVLDi--}&xJqJPl!l+&_U36Ik%S$L!^3#Drb$9+q=9qxA2=$ zh=hD0GUAl}V#maPcGt?qmCuRl%+YV#X{EM*2qAoV{~sZgi><=A&VIe9O0l(d{mrE9 zpo(~~?b(AVf5Fw6$z%GXKsYSEE$eDhYPrIML($XKr-i&AiCGfWrw|UCj?dPlD?jxY0a*%D)jSYr|L`wDa>4yrgkJyFY0CPO-so$q0zl~Z%VVo~ zba%q5ulm_cP2petnZ8DkcgBn>wx0-{T2llz)Z6w0Uj>d1Zg59gW+ETSH;T;qaiYRi z!D9Qn6g`sOajvZ7&GVb_yfmYO9=C%J?jxk)mAxQ^JU&Nwah*(&W!Q~WCq#tx{F9i^ z7X0KZH{EqYm%g`ywpwNQTNt9y4%uHmuDwSIQJw2+?EcfWW7NHe35@~KoSHZhb@u}m z^d?h*pSV_*puZUWF%7Fm-zO&5TjH= z#-Gbt%+ztsXveCy9@5Mc52^Wl(ZK%46~Fqli$w(cq(8WY+f^?x%2At7VCDH9$8~W6 zp$m&QpL25U-a!6fM+uu|6;ZX(&?(3h7T;-+?5TLQx=0}(h?MUIzrA;ZUWmKw;PNY+ zu`{Gtn}N?)-9McCb?o!QB%!Q!yutD9Gt`#0Z4zBJA0c;$W73TD{`T*g=aMHh^pH;^ zOb7KZV$(!1Qto?x-0~NnLX1eJuiTb$>_5ndj7}s7q8&dW)|WCtdy?6X7mkLkVF6@d z49tVVGpP3lU0ShaC^Y=kBkbAcE(%(XZL5F$#S@l){n?f1JXLh5VnVQ3|Hlt}N(GqL zE7kynyv{rW46BFPyXg%?{Iuv@Jxg3KmVIp=3Hv$tmYyZc=1p!= ztL8M1Ji(8v^;uB@sv>Mf-ipf-Qor_RuSIjwaeCx|48`EXU4C{&)-cXETp z7YX4fuF?y%XKOstgOOXAMp-j3rI%s!R#Oiq2~Wb_)5&)y&c}dZZ;E!nrit(7Im8{m zZjn|;^baZEzJJ%}udIUwWz;M8j<~%!n)KjOrgnCc|BH`#0y4FD`YS7{xe29C`8idS z6+<(-<^+Fzb6M%lR%AX3w{J8XRh)cmsc!V)-0EcB%)UDjz&1E_1@HAf_}3S&Ej;OS zl~s|->hY`F=*2VdPV5;fc9Gq^cKMA1pcQW@SeP|V-Q<(V8-qoulXm)Uj}}kql6Z`_ zTl*c|U=(z+Oq-c=#7xIE6BXaTy}vwnBGzQ8xr{M>5#7pq-!{1ZEm-KZ7ak4Y6X5Sd z_>C-}(A!lnf2?{oqZp$gd(SDQZAV-^Iojb+vtm(3fg$NMUabf$vz2WyV#_@{X z>v>kjPfNX;G=x%uc^a9EuPJ`}=pQouZ#kDWL#f*rTn0CXxzTjxAG-USML-4>vI#Un zP5lgp$p1$5abgx%{CNsXQoB_Hg4#-%aIYYiSbUdcUL}FMth|OhyoMN!Cw2IlzpJ@d zEW6anRUdtv@*$ew@b8MeBLchb=T5W1b0Sy~!&Snk8YaG|itRr;v{)pVVy-OCa`U-bBp`ERXlvP;@CPA@C`gWW_$`~mgr1Fv;f}ot z!4eRbZlViVeM6C`yA=5AIF)doJgN=!w&w0#3LS+$GjM5Doks}A7waSnb%bbMfA$EU z(rodLZ^xg?`$%tnv?4JfyGdf&_t%-{2pl=2wQ5j*_Xc#~n<{WtW6!@yMC+0*($j}= zuBe~C@=8d0mUZuz4dj?kW-}W1bvw>rqxTHhwA35dR!+UJGR)6hAoVYOK5mOI-mbb> zcPC2Ii*Ntx($!?%^%03|E4;L{fjJflaUfD2;Nz68Jx6=w;PP9dME57?1;w-<_24!r zxVM44^An$@RN1Z6v_Zi2W8Oo2AQn9ut*XWxV3?{*iVWQNa`nL4bEN2W=|vOwpFX>p zNcN*sqorY=jhwTy3)2+t}%@k(fVR~~7a0@{_5-}nE3v1+| zj-SK^OQ>US#+n3WuZ|$(B?zERow=6*kKO>`@soZz0ba}LdBfJw~h|%;JdBXi*b-{O?goWtL?cuK6Zg6^oF(4X)4#kISj{etosmvov9&vZmv)pz59rYo?Q)W$8^L|TFx6qcALiQ$99pZsw zE(sx%r+z|rAuh38!KBGxZQJ0c(`J0?pP&h&^wh@)-}?0qs8JlUjY$?@!ynn(r5J7K z=CU$V%R#C4MDyz$(aYu=s8d816e*a@%lB>YyC1T2l>(w4Sr#^*=;J!eT71=zk919o zgYNoJ7m0@`-rn*$|JSqkV{T=+h?JM};_h#i`&J~eUwt(%o}lYHPx$qr7*&y9{NTcW zasU+jBfe}Y*s<$z{%Y1#11a(u=BF|WCzR|*UI^#DV{+QhcVy*>wk(K7yNuV4?(JJm zdVl*WVVgL47$nq`$21dJVz}3QEhFS)UeBe}HmJObNRigO=VC+SYCkB39Qf@sR=#+y z9YT5Z>I)aew<~oUkuEaT2N$Q?C;EeLN2>1cvupbC zoBNA6Lsd`uyl+f}wOIU$5Ja4XwBP~70VR`#FyY@^wq|8({6T(56^WJaLz{#sDEGoT+cvI`gYY!^4s4GI^ZjC|o4YEMFm z1Wd_9(Qz43UBON2f|Joypd`dtmkF!M-cy97Lcr+-IxKZF(e#O;QpK$`kG$(p+~2G#dWF!8HK%Ooen znKq{&2Z1e5T=BFKAFzeS(+oI05r0yv84i)P!2V-@o6DT(RNj_7eE1{Jzldi zFt=fADa!ZNCz%yB``K@xlu1WQV<~Q~x;2qqWKe+wN7;J7UnJZTj#3+-}xi6N%#~T9jf+fOf=;#f7=dJ;L*q z*>HMy2*g81>S}}z8Xq9!oDm@G>SBzs!Spq!#^+L!lPNMU$P8K>)j16?3xlb*vmGYJ zEM?Hn#_c)T)l2bOIZo-ka;4Sq*j^i*8EEhryXhmfH^O-{bC~y1u)KO_>#Q z6Xa!jydW~zz-oNLhdR9JT+au-+BW`IS8AzN96;?bqu>u~_sdUoS}W-z+rqr!m%|iJ zO#s){3J45%=uKpw)`#X}VOugv77H1nnd{MWm0?nckv6AHx!0mMny3YABF-(%j~_mM zP0~P?-s$xR0j&%h%N@a=<|vqz(_pji3yX;I`+Ta_=R3k_fE{*dB!ACsd`yyOCbSQ< zz*)LJ-_NeaXf8vRHZ1yBRXHafDHt0rOh$xrep30J60bfk>R5s}{T^e%nxvzPN{KSHLdtWKgRRJkxT`K_ zoTf+q&fvLONtX)nRyUHd`Mb~Y(JSa-NyuewpbKd3xQRH2HDL725ucr`OHNI(?kOLF zMw=AaQ1r&gfM#N3$Q5tNWZoVgvV-Gwl3XS+*oW*{%7eNh6qk@QEzYm_Y^8B~=ca}+ zeTLseAB;cemMrpqd-`+_98j?lXrD;A1&~?@fXL&_&-ch$?rz>9PlkKYRh8ZZ2l!ej zR5Uvj-K`oDuC*O&@vQi*_whKTD~K`4k~?#JWi}4UXis}TMNSu!yR}9Ez zmxw+cek8*&{-qmbyTqBuYD)fYn77*Y~YCZ>^*g8 z4a}@=NBSpjYlz^HMM-UpkTcpe zrFQ{2MOr$|y@=H>G|&s_^q9ieSHJ-!yByiTx;3gznYGjG~|I}a;g)cg(c zY|Q{t5sM0XDems=%=VXMq83y33+ixjH|s11sMadHf>A>0U0v9uw+M5LeOvfy7na zjd457P2YYJeH`mU9Of4a+V}Vk6P)oi(4r7#HkglXROxQbupNJlve_5at1d|I+XpA) zloMGg6q@ziSk*5+P4+^^M8-}hLci9jZk72t@vM6Osz6Ul`hD_N2^MN#41(g4rvJWY zxuY^N{4#D+1%J;G%-g8sr4z3>&7mD)2-;O{1G?39!Cjb~4GcWk9VvQUiepLpXSgZE zeYTmFmim7b9-cGm95aVM-rK)I&1OSG zdST{pd@RRqCX@Sz=0p7AIQ3!wb*@SG{x0>_{Gry&Ii9$jSz}&{&w0wJ`JSYT3VE}v zuNL3(98K`o?`YUyS?Od0i0Z7x^aB5~jPhwjmX%?7S<{haHMWj{a~_?6koQiU7oA-T z{eFGR%IVddMJd>jsqKxPa>p37H~tyDV>Zia#%juSY06b??({xc){~h<{fZvW5f9uF zlTXsR&RgoKMDM+(_nJ}}dP3sdd4jUE$GoV0@mfDEMZxBv2z z@lnj~-z~1~aovUcnF4(Rt!vr!#XJX|z{#Br4M9pb_9n~+%<%ek-$V|hRH3yJ^i=mB z?pDQGbiDtNs(dW=gQ!&2ad(f%Q#)|ke=eweddH@fK`yuxNBY2R|D2-Z9dJ8|86l33 zm5AAFJ~`hk59C*ys~g+qfe*RA+X{SxMVQ~UhITmOnOCF_hgKG4Ms zDP6v=>yo>IQ2mZ(?v%R}J&F}mlLbN=?u5_#z|OXEtX)scBiGs?1$wV|BC{9o=4Zy; z`U_gpt%LSQexRZ$VUnb34}00p{8@@5MKMpt?Vima`RbE$?*lCuFI$RG(Coaw`K+Oe zhH3JM1;s)P9V!7b3f4%ACijC}nz=3uPD?hP!_eS#i4%vm%ei|$*|fQi$~Ng)a3n_y zz)uWlJM_^{0UXero+YjGx2GD`WoMBPRue+mRhawGBbS7kBeD6ujr60; zvi7O}(p^^@l~bqCW-Ai0mlSf%O_3BScTTZki(esd6u4yQfs} z`9{Pis|DQduVKV<(I%37IjW<0Qi@Y}BH?r${Xlg0i%uQ1R!l>@`e{n4V0Mq{jNmZo zpnghL^)GPxW|*u$d$vDXNHjv#SA4KNR)hEUhkaMlDm9mcmGlF+jh=Zq%kO-?qo6P6 zZ+l*xm?;)VY4-8SvABzmc0V4P9Bi%+f&>3U&}ME0*uCOT6+4KHmFNa@KdIKc#(JVw zbMk*?66^AeClYjnFID55r{mrd)$!l#HhlJh&&SS%qFJ4q>!N$L;ooo;6D2H9n|{I$2gR`u^sB4?BRq-R-oQ4rsu(~%$1F8F*vlsC3^{y&33s?E8|i?uj?WrHJN8G0cj}B1 zJ}a{=ff>B+uPXxyWRbm<0fzkG06h-`rCW z-}~Vixhytz`tORmKo4^T=3$B@ecXIZhVketk8AUR1ubDx0a1He#Ye7d@iOh^H7KR# z)y><)>$>Q~d!v|~_x4ar)Rb`hZs?+H=XA?%b->3C0feOm85P?%PKRrbv+a4ALm4HE zX8nNiVF__G8LuVCh^;U*y0-LwdR;c--GHJXt+^}G=Uu9&rQ%# zu46M6CB9$1=Pfx&EBBR>T02gmjN3Qa3Vjpo19PgK4coHrEVAdA3TCOur|&xGx!UhITKU$r{n7nn-%-DsyRT*6-Zh+S-X25y$jAQ)W>& z@>HIS{dgZTRDPLjk_yx5b`JgnkGtjVo%eNpdwGCU`U4+*Jarv+)Fw-54+n#TRD{F2 zP!i?HFPro4ZllR;q+MiecqcCYT2B_o2JyWV_p45I53{(@NIK>JBuJYPVPxb8;;-BnZId4zhwNFr-Wo65LHTq_(QeBCiDH$xp=sn3@?-soleb0y-R zIa3HHag5(Ke514e|1tK~VNvGmAMommu3!QKEP^PCG>Cu#A{c;_bk|5p2{^Pc0~RVn zNjJ#QE!~3x1EPd9k^)MHLpSgJc;Y?3_u6yz{bSj^bk}Pcp6C0$?@#)bNXQtI&CD=+1A$Ih(GhW|LseO zDY1gFui5Y|*m*$&mXD!)yB(qZpf*^J(Xw-7IE2`Hx|i{zb+6bf_WNz}%E3G?nlI6d z|5NZm8I7`d`@IB-8~ITaE#E#orDt`O^tVjLd(c5tHQ?-==e6#VGd-|*uX-r;q<&*qYNVq{-$}P@Y zEfAbMn=K{GJ0G*S?tZGON6%*Sw*BS;ja^!@3bNu=&SYi{f>%zV6vB_aW0F0!YU3d0 z&zz`DodO_*nZ)FFDz%mtnpPIYXVoNKJMVzgI@8l4?^BM~bs`Qx(w-LVIa5_OqPk;gVC_8>`4=3)R z;4wLTT$VL5@cDdrfnoJI?uWvUt6=f*KO(NAUJwuM*P4?OXhe*~Ll6cqF-`%=)$e|u z5|ylhJx6yWi$goncfye^yVjF)LCR}XZBAUxLu<5Fjn-Tpt0O=@Z+tAiK@acg{n8uT zv&sMChAjl6$usRiPK1M&qNz#UeQ(MJLs%4%pkyi{=GUa*?47L=bS>_)Nw}fQR}#7u z+I=7$OG8mzbKn|&-}+wur}WMOCcy`Ol>odAf`@gs!gcX1jx@V}sAIvV=fp%)^WCs>8jQn6nhC2I5 zczmsRtpr#JsoIMjOqegwp|F(Bns# z_TUD2eCR@;_?QqK_c>n6j*O{pxN;36_zZWnYpEf6GnLe842g%2Y?KTd)O?M*#3@kH<*vG zr;E}OJo^gdg-`NT{k+{<>1yv~8w+@x=Ws(Q=Sua&+^_pHCf6Tu*2^}AL>6SKh5JXu zwe#M!a?5z@5pYRN#--m2mwzJ!xR2zb<{Q=Cm>wHq(;7gQju1bVQ1cS90e9&t(>5{S z!LEQD&0+gW@MvulTqfQ>=L2jI&fG-g&jvjaWdz1(4|hKooBOG-N*T9imx!g)f@ z3jv$Sw^hj(iZck-?uYjwyQQT@JN8zh?^Yti?4}85Y+8Yv^peG`0LO=z`(?-tKNbyHf0wC&Y#!2=B%` zYWw{9)Ube6NAk~8x(TQY7qZ~N?rF67D337+3L86Rma@UCo3V>Exmj=`c=Cw&U!mPnVs7Z|f$+#msBGRUtdzz0|5;2HeVK zh~6MLW_rlVZ%%kX-hAmQNLj!%WT=fZn|%E z2^VeZw3r)#`SM@MkbjOK9fvyNeNt@OwmJY3`%zcs*TGU;qJOc$hapX^S;g?~XmPSf zymJf6UECyAkM08eIy?LWQHd*G+Kr`4U~^ad=;MHYyRiOprd2umOU4oqbN#uJPar_H zS>Nv~h{pyCr5(DZHJTP4?EKyFQP$<4VEN=I?$e(Dti(D{v;BA%++m4EnRkr9AU$_N za_5mN7?!srx#dE-l_}61x*dDli;E$#>GyTYIIQs0Z!NE*g4EjiP|oW4Sq8rNAZhQh zqPXF#pP|&b9A95k2TA!-Vs;@|;HR9O##_bZWe92`H)(aTv#HA~I3&Md!*JUiD^R0m z+s$|#Mm@vP{u%OB*%LM{&D_l}5)Kr4xv|MBeKUyKK(|SDiI*AZEfjEzTtx;{W56A0#D9OeS~{ z`A;#d_r~r`D|^i}a$jd_{{`j~;x}AIJ>te8Kdg(Ms?(M675-4>Yi$AFxmq?Z%TyDW z9No}2ir#aO40g&3XBm%%r~I*S$}ui-YlEjiPrCQc%7#Yoy(_ z=juq^_MRxA?0_*vS3*E_r?1_^HV-2sS3+2A&!WE7BVFRI2<`at$*P~x1#anMH%LBaZq?dY{P%?3W=c;kg+kJ*xt<)W{_U`B&!$N|o!CIP5ZEeU&h}DR7M} zO;Je8o+Lugi^r(7^PqCoZ*ie67t*aNk83CLkkmO3H|x39dcM&xiQf#7`EpoQy1}SS=8N-ZEQco<&P)~c=VvajO zBW{(gRYQBmxm9#>V>!hX<|m9KfAxx*mIs%-3uLC5n<#1Ukb!h@?Mzc{>*w2f>k-+y z2;~9a$KTQZ?hLu5C_^44(uZsY0TL1bwgw|9Xd>HxA>oY($k64>E0Fww7ywOSanwZtk-IsmtLU^g032%*u}u* ziz5VIR#oVi(93&q7V1o%sUP5GGqti(CB(oq*1`UpYH(6G-3=zKE6i+%VVkfWghr2f z#Ld|?RC^WD#V(+K%E?7$OYgQb5Tsn&Id6lH2Obd zTFo>Qmv<4yj7iN~^I0o5g=vWM=n2`^5v4~^OJa!MZsLmAxSwEER+tlS{`36XO|3?c zf1vCWuYx_&@?luDeD5eShKGLRP}B*l{$Y_2Y9>co57m%eHuUl9ptH@Y*;sMViiH+V5UArwAtD(Y-ynaEH{p=&L~~R-pD0>0`?7p?s;K0{zIV;yM_s#^ zG{;iU-f;i!d{RX~jxDAi_NJkXwD=h#NGEvL)NH|KM)}+%^ojg3k3>WBi3H+TmjPR5 z(%2Yl)nBUn-ilJx?w9n%Qu_Tvq5rhu)a!WtS4oLF1{`W%+rquz$a&b7=~{$XB2O6M zBiW0MNmV*EkBb-5lLD6VWw}0?*@jGgPvc&}8d1Eb_4Mj3ch1mw3S6j;{F&@ zHV%a*!zMRmTmB=Qm>y%I(m_X}dx4Sd*S0OP>1`dnN0Bl18FHXzO*vqYw^O`&mkINN z|5y*44^=s|9!U%*{Ly4;ewc)J-bvT=ZkCvMW{av!efZAE7k;nIUn1-0+c9w@Kv`-o zw7A;jI&v4VG$y)bOp8($dt#cw;XTLCgr>!jnN9yC$MuJOfS#WDK^O0 z=2{STU$I1+@i3}$n#5}yTY!<~b#!wTSAcBqbCU?Y!t_T2z%Vb;hNNzayDk_Au3dSk zkGYQ5?W$_C2uc|Hpz&l0;6HMs+yG>v^?csq!bi+@r1(De&luryp-1_4I-^JvO`cH2 zu(Eyub+*|;b#5HioCQL8?&I{UNQ|e{!`O)?$R?ax#F1-ltr}HpoD$l_zrx5pM50H} zIgqlvDNw>CNKWVj<9p2N-m4ln-ZvH>%jD@<+4PGJc;H z`3L08wyiO5nu7A>mcGK76&VpgAAf}Hmgsy@CzdswBVX}6pS+L*Lb_hOP`;)>v5uL-wyuwVXef95;63R^WTSG_ zU)7$s#Bx2PLu>qYh3h5*8a=hmrVw8CczJ@&MSZj$DUPBa?TpnpDCjRZvYaEp_0F=t z$jWYSXH(ZyiD|AAMOn6q3^gI1(|SB+st1!np7D7EUAv4bPI5dQe{v`y^wdW^pZLEGK|Oa#xEEwmeEDno-+Wo_ER#XM;*;l4I_ThA3B$->w>CPi*oei< z8Fur^MbGuhsN4EJ{(3s?z`~#{xkjGp^9n_*7HjHczbW&}ZZKh~)wzN*N2U7CkL75* zorknX=Ns-Tvat~xC8Hjz<@O`Q1=xo%Tr1%vI_sN{JZ;c`Ecfih2wDULQs7yXrHL~B zjA5vgH2X#Zckz;HK_tue;)twt<03`T zS0lJxmSHv0elqQ^_NCJ6y@MG5or$l4;8huY$~d60)mTQ zG~Lh`oP{W*E897{AketEK5y?ea4cMnnjV$YLGH@MU*K$##j3vT21sP#(!J>KNVwvL zcGSAn(cmj*uv;?2T<=pb$Sj7C3Q>8&4cxh9tjnU<3t33G_^35H-5N+|;=N*KUCt)I zY>j4aVtO2Tyzx5sTOOj}`9)`9XfubWQ7G2(`^O-=rSDA=q5%zO6MlDR*`3yD_h?~e zi*Fb0gM@7ACWoT9u(upDd25;uQIKmUtQWSLiOJFdF8edqgs~;#olc|#_pLC>4S>8I zb+_-bEFG2AxNh8Wao(OnWJaV-Vmq7vFaz@)in`DzcbkH01?&;|3rM%tNXL@q&9h%9 zr*M2r8Mlh(XjgK(0YZhYX@2?KWWp<$Z(Ri~TAcu)UzH15A*K*KRcktpocYy)8bDXa zel;kuH8Iza`L0ip)BH={iJ%>)z{o4+@*Bm#6Mup?<8=AN zMMx1j!cAoJ6mPjjva&SbqFo0JN@A~AeeN}-zOJu{frBpR**o*rJOygl=O&!A9;eZ? zcRTaYHNo_5l)j`UlZ~IF3y>bOL}r*#7q`1h*Dn00SGNZ#gVRV>fCn-G^{ck`s!>_= zBeKi#BvSUQ{rKUHnk!m4IBLrV!0x_f4QrVUP=h{#^XkcYJTmlRqC zrj#9395HaUNL)?rKCE+1s zKb#r=m(2MW#Sf&R~8a_7sB|(%Q!Ey~c3uQL;BQUA+kEw`VY=@?!8Bva?+u+ zmkdHLe+RLEBV>q4Uh%mZdQSSlVR^b`NDBRm17erlbc=wibebMJe2n2f-I^NVT-LX+ zt!2m!ses+!1G_;-WEeK(Zs1uW8c8PXs`AogO=wTLyM0h^#RkeQ!z?aHbES`Nx z5yqOSnra%BI#X(%liUfv!Gde9A_5pebc^fP8jItwQZp-tf)TeYw^0tZLyRJi-YPeQ zSfwAb4^?C%TAtuI8XDZfp&K+2-CA>SlkoU{^^C_VS`H1G;b@M*G@JvQl3EbxjgHdC zErQ~>Z3qg#B+mOkdmDODMlM-HQ3b?Kj<=d30w9w(ZJ8e3)rdVv9kwBBdX%2~y{e)ZzVmOEMLvDBJ|K(tAmj@e3ioZ-<9K-eG%?&hgj8wT3NM_~8C1?Ns}`4Z8l{=yEe zHYnvP5FQKxK0CS?Rq*bhdeYi|J)~;)Px$=Xzd!`2MZdZv-m!Pjk}>U7xR(Tm%KyR} zCLh#w!sLE*UAT6E_lhun{f`JYzc3RMje5?rfl2eugY-sjACRgl;%{MN$7mf1I8N12;kGTrH){_fqgc)-cg?vMl%KqPO{hSTDTWZp+pG#=C1Vt{+{tB8m+5XL zXjUPZzFfU;#>t+@B-2*7JsXvzNS(C&Z|omN^)p|6s6)6Mxpm#Doh}Ee!}Y3#{hho%e$(JVf-Ay-&QX!{p!npo6la2(n{vy ziqW#Nsn+SdpG=l9m+hoy3DT3Jpg@$Z|9#p6CDd82-u!YaSz?9(5w?Q@HcfI}_4<}l z{`u#Jk6+2j_PC2>QoW9kqm0;aKDDoe;lqE$w`p#22HZvdq{d;WW!;Sp?3vc&tAUis z9g%T38jUE9d#zWFh_;-!X@9IH9>4eU1oOnNJeLG1USyE`^ECZ@F4k`MYM z7RN%>#bZ~vrMCOd#3>AwUhTX8dnrV2ZZ7}1n71H||5KwXV2h5A%ux9AI%(+!sO1-w zy|&aZ8L0{wkR5LTiZF7LglUM7z-<*V45V+iFLy>3Jo3w{*{k4hpes(Z(aMh*C3w6C z?d3IBpgy;CBnNYTrE) zR(OC~a-E!?w!7wQU+3{ZaTHVb-+KR*1%Moj=U4!!F)Kur9RMg}bK|fj=NqOAH?qIr z5gfTz^z^=>pSnTP-pH$b>s3isnSW1Ve~Bc2@jIx6y_doaq^}kEn_KiD`HItg@~mnP zuN-5WKT6NcFF_9NyP()1;5eb^3NrpOkYWiA4tZ%20->Oz4hPLJt4;m{e+>@npWiN?@JYc)`_P;;wmxmQ7KOI_`3!Z}8jnjp*QRKj!N_?2JBZnkL~$H0EzzSH>;P%zGn#q_)4zmhP%!C*0)zOQ9(J2*=OL@>C|M2aG^Cy*s&2Z<3kVpe zJmOX+zgFtakM_7({an|@;V9b`nWncwX*tVpij5DjKzg*WD>O?~ChX2x5Z{=HOuWnB z_!<_hn&BmH=hCBVv03iYt*O0vNPcrI&trYT4z9}4^Rd)#n7ww$6E|+lcS?M~;7yQX;lXzo#L`??s5JX6Z-4Q&FStt%q8-c}Wt)f|tAaNZkl?5*ZeEK8M= z1?RxWhpD$C<@@OPqAQ_BhXCt~(ngs2v#UdmeAO!*+25VG{zzkW7;g+zrZp^D7_inc zRWT-pD2Z_fUFHK+@h_i{|9F0G8dB9Kcr+X_xiJ~w)waC^R;u{UR?WvAYS(l0eL`0T z_1nJXEH2HL8=&lI`N*ugTSl1UqoOJwcu)-m0eNOOxX!MBM(=gdv-&n3;MDs5jEYaT zo`J*YBUgbCZp(?~IzV-P?_wl+ZjlexK$#1|on0B>J}ZM^ni-$_S|~WXdI_k{3FNw( zq_WdB{bYUd$Mb*z2-cE%_+pH%RUG;l2F$y;l-3td= zze)`x(bn|{MN|YXB#|G}+NJlEy7_6ZR8yYvgpa=s&*nq)fFB|b`w__m|B>v*iyBnR zfA`3WbC11$xMER%wy1int5szD74R0gA;4)8 zc3fgE`FYWKP{)+Q-$+2P zZW!DK)ad!iY|134fv8zBBJ-oTGaOTF*1_?xw)>i>9VACO!nww4&;fd*1jZW53Elne z)5S?5awHaS(pc9z#O+<_Z^mlYR5;Iuuf_$WFf?&UC@w#O9O+ez1^KwSclHu#ztGxc*Ru!S4*Ltd1LG`d2L0)Q`z4uje%##MvqY$n;?TrxazfB z%`TKlHGca)2D87K*q(xUsx3WcH!2zBc*idUEDERyW&x$E(WsNgIi17xA~{084zaMp zM9*PeNG||IvLLJbzua*DWn{bQda1VaJ+a za3~I&z0S-YVV;Yl+U1kKWIBJ%X-Xw6`7+EMX}jTpJSYTXI!^aoP5!!?$yaQuJ@Mnd7@kX_Sg&LFuYEtf00RW|1B3T zm21v3UD>-~ALW`FYo&J!TVE~Q;R=n&QZeZ2K_s}Lk=#TMtKbE>ayqv6Y9_fG1T%{Y zN$GX@mRl$*Dta~>HML}eNi)O{27s;nL%~PiZVKKC9^|D$^{ICx8yx*yyGQ;nQ+u?+ z`z?Fl7Pj}6|1bzzGCeKodo}gvgK@tiqKwIAT3pr^qwcJS4Jl(v6w7d3W9l^Rb2AjP zJ2+po2tB8CxXg~!)SS6| z|K^0_iVP-deZ5=8X zdjqSfzPtArE}CW)@6n8hieIP~X^|!D*dG^A$`G2MuNNtoV)A+W8si`l$RMCJVLtwg zIdaZ{m=)ejnMRGWHGg9oPJeL|;sbRLNJFrm{IM#nfW-SpxKAb19(4|lWH)fic6;KD zXZ7|C?wSLk(*r{EMhRjx19zbNgD`4N&~=Mu;c%NN{J17th+2-CUwHsz$O4pjHb=Qh z4`j%OQonoQU8zx)1LSf4MVtJyOxzhk)Dhp+A8}>ne|v5&?Dq41DflHT02Do}Z{bx1 zn^z&;CZjK!`e;Qt#h$@DobbBo*xatWPIs{v82OfKXhjT zux6ar{WlAzhbmo_i!#Q&<d2-t>t68ItT}?=?$G!d&;}W2s7Cy+@fge37RMBfwUaR+CFlHVz|gZ z_cPcFQ*0M{ZT#e4qR>t(>g00E>FzA;S`#S7L$*0(+NZv2J~h@7)1H5_qy>+2W~i6d zm--Mp_gw;5B!`hcU_H`*OCx(z3c)JO%fnH}|M@e2%XQGItuUu7Ce!Ji+(~QX40v#! z(wEa}kZUP*%#6f?m(&Hr743g&`(~(kv5832K|qQf8>G^iNssHt(Hi$Tv3z-b z$(LPjlkdXksBA<&h7YU&F@E6~g~m=3*C4Gw_g?1664&iD&S?9ViAkPjD|R=7vW}LRyNS zsV~dTm-u{9XpF?QS1a(9*Ei~9xFLGB@t6s0-bOrlGh26;B5Is~GH>~FJH<^J^}vrG zZ>|>9xPiO4huhhe+#{c4Ir1mE6vp36l!enCvrJa;861Yhd@K?n-m@z^&()9#$bx%J z#T+7=5|C{t5dF?v~&{!Kp_x{sl`p(B;|V<@M!; zI>qFeKo;3lXu!jU`0-q?^Uy;XKl;DA(f{+;@H7x*a&=n}Y(@@kobYA4zJ{%VGdF(; zm$=Sss|@6^=-1bnt%qk%j~6YuXRf;T*i&-bW%o4R+W#B*?mN&j8~3=R=#*M>GIFN+ z%bzHT^bEH_Q}F9NJqIEK{;fC00^Bz=y7R|QYHQXj_=t?jMLW%fC`)|JIM-wExqJrM zwGs^E21x610;VsoLk;2(qIn7ZI0c-U3rKvGS3CfMQ@B{DGMWr4$F=;NViV{?SwM^k zpnGb@=8SXpomYHGyNE8zU(-bU8iFcZ4iox@OE2`$L~@AIk`~nOd6%laiEOnIeSvx<@!Mz18Jn{EXms zFx^tWI+LLf`0a3!5qUmSiZ;@^|8SN_WUIFL*L$F5ip!4R(WSPXK-X=*a^5R$)nf_Z z%ok*^bG1oQkWJCe4NNWT~eq zMdfXQ8}l)XmucJultxi-7-`+Nrg!%tL~rYQUvv)az%|QTvc-U$j8mW{0f5Nt@=IwO z&UvOt?<`U|D>$iDr40I(to-_rueR`cFMx8;_bNFr{CRLY(#7_eg*)rkf0gb3YXH1C zbTs)!TR`LauA#S#Z|i!N2a6oLf2(V;`9rInjl}(;t#8?yrzB`h8BB!q`s3J#cf^fu z38=_xBrj73`l~d*pj781j!wkbyKv!?`~KXO_8q&PTfL@-er*dzJ{P3%B^FQe#<1Y; zsa45i+XZ(ZlzY*~c6^|IgnQ2nENFaZsZyVr0sEwY6_gBk6p$f__kK-Z{JEdA?WFZx z0jZoTG|v_dcUBVw*hH`qKSt(DvF3*HJTH z-OJ;Szz#f|C>(y#*k18-$0p8sq_+$PfbMe83Jt*%JQY`zV{ihJ(Ch82_Ypldq0GRf zj#c}kLB7qFy0|JfsGCmz;V2LaXV$~=u%yOaOTX}-*0d6Y78&}}B6gH^+>{q@;nzlC zoAm6V*2ARYnq!(f{5*6SW$Yx@2Kw155VjBf8cKCr*SVt8+-d>n<1LIc`QX035GP_( z^fdSP$0T~vHLhVUqK@}!ZuvxX6@DUv*&=9BpY;mv$+kUMF z+j#6hPnf?vB`p1)tQr)2O@MIEt|diqi<1`-i2jbjBb+>`Mc);71gRHFcP{Btglwlf-eV;DA z@;Q-hqKe@1*MEenW7U!o{EmHJ@L8OgPMCD`@wt(I4!!~`B)g6Ns)C~xpd7lB*Tvf0{acG&x-fMZDT;*x#=Vh}(TbmrPO*=03hQTE z6i~t%YVX_%V%{;c9jILCP*_$vNVkB-x6Nb)FHJ4NEsA6bD5XA%#jkT>R3dle8_V4ah8+tSfm?1NM~4w>P5(X~27MriI3qrj?$}K+Ra9MRQkr{hcM>-4pKJ zghLMP+v#M8jkxR{v&v|f_P!Ibe zW^*Szi9hm6p>Y4Odb3m+N5cibtfQq?(~hv07vOEJJW$7c`Q3^8pnfX{Ms>()d!qx= z7)oIdtb|O8&zx)D;COT7(n*GgKlQdsMZCsEB`+%laE4P0D2PpR5kWHjHrwq$F@3|a zbVJfL?|d43(?<){>^7LzLfTSAOWVnavKQLZm3tv#J=+$w|8^DH(Ov~Q28Wp>uyUh% zJNk?~H_i7WiXD$i>X0U#ngIyzY<%|JgCmY*=#KCa+Fr~D3VJh?G2TSHcC9F()e5W| zGg;`}%s{H(q`lf@9+q7zRfBsg64sybC!5xXjY%Fq3iBujIUmfy1$M>sC4tCEMC!Pf zOz}OMTbdY4M5w-h=9*n>ph7>Ou(-L9u`jeWv;n#Twg4#<0OB`JP4U@j4@HCG!>4If z5n7FfPG&o1IE%#xoaO_8p&PL{a6!)a8$o1G<0x-CyO$~;4ch1p zj#WuLC;qdro~*RjSYP+QlaCGZ?jiAxE&lj300Xe?y7!qv#=Vt0WpTt_=jH;n_g6Yf zN14#&NB%C!8YrS##0m8eW++TlRY-CSbD$l2zJar5){lXG;FsDK7Lq)F83V|vdA(Pf ze7f;-vH}4J=tb~P zEYN({Ioha^ZVMdXo-!`(x@#^XP*-MMfl!V~9+Tu37h#MEbgg4A5!v}!SJ)%XvhwX3 zB~OP~b%a8sl>F|oMtWP8VpMhJIirklgh0{<0gO^qJrB7g?5A~%Z3)>cs2ghB^AQB~FQOsaQ~SOO5E~sdg~5L_i^G0|F-KPTrJ0m?I6u;#`_U9Ng1A6Ayli zDmh6N!}(ObOzF7Z`0Roa&ZwRih=xuf_&k7T`QhR2)oVi|R9J&Md*=NSITd(x$@fw2D&m!eHutD`!ZpnEscK@#9g#_mk9-D2%4Ji-aawN$2E+e*;=@0u2$lVV zqlF|(sZqf;%Nu!Nr$MXIs%h@7v70m{T8-x;nTmyq$YRctc-$|s@NrqA_}m-3U{~6j zT<4lW@rg;QK72BELF1y`+T2$nLq7r=nI7x%vT1kpBvI8jrq0uzS%wwuT)qPBg;QSL zGBbA=uAgq`vAoW0bQ5E)RlsG7o?3zu3->IRy`QfhG>2`Kx67Q_tU=nLl*n2IYC$)2 zr;ERAB;DR(XfU@#lhRsZMGN0Ns7e~7wMguXf>HlmR(e=#De)wI3rp6iKI8&lq30tn zGgbFq-E4UEV*SMIPS%aAyisC*tDarWt_w?DYMG=>``{LckLTKoS8>HX_oA+lrWZkz z^ypVkjtzJ-y~gx3#Jd7LS1zE1l=6k!2^%+N4Xll3`3(rm^j_WAV|n`Xr45WWFDhet z?Ggo)tu@vKTU=2Yesm~b^=wUsthDV8kYq5zi0Ulq3CL;TRv~OE6_+LCOt(SXpHOVS za_g{awxJMvG0u%eLp;nmA#ly7zcb6^o~{<9P7T{ij`K-_a{B)tZ}tupX8h~TUS>bb za=N;=6hRR`t+rN#zXsXrub10l=o;hv^;ro^lD}|&*`NR0Q+Lzx4>O z&)L)rxdsWP-M~x6QuA6Rz$z}vEvhLJ(1Q(Eol15IT}h8*6JsY|)%c@L4@w^_bCe9} zDSY8o78@BoA^+BtSx~}gb})-Mr9nh$_vqh{PJ1@4ibc>50vyN(QbaO*~PmhfxYKT|IUP+_H$4h!Nw?`GeyTN zMI;a5qB&iX*tkg{#~^)$KDh!u9e~Qm4PX~*=}T5yX{!kDnlxGPz?c3pUL<6ZbMPU) zklSoHHO}6Ksb}!`q(T4YyDe+xIHEuq)X3u>c9HLPpVJ0ai6Cks{ z>N=egA%=3{c2ceC1CnCV6F%Qc5IA4M z-rSh9<2^6jY4KThyluV0?h<#y{|5O~5&)*DpK%mg{c1DIB=l>|*J?HAR=Qp8i5UGt zXXBiCPmgOD_yZkSLjE=(S_VnQ(yZ1o z5P0HWut<>hr6!GqP9?p0aR)t zZ6k{Uj!~k^&BH?;uIqN2vAwes3(fFYPU2c0hF=ey#J~h)mPt9AT0qw#7pL?71jRv) zr@ejorbEecA%oyhTrLPEA#!WJ^6%6&KSNQ!Y1|ZSz9YP5Y}HDT%T)Hg}__Ce1sYmO&wiJOaGcJ`}vdGv^~tWvq*Y|c)#LKK!ap{;p;PZnVmxiK#^{M zSjK7}G%`6VTA$9s@~3&bBHpnLBF7gVqoT41y3_cG%U{iQs#A$QtheNe^mH~@Cq?y% z1%yyrY}ycZUz?i-1)^lUDUV=gfRluM#_MPdB<3uw?Pmz}= z+9M7S}D+sv^6ge&j$Q zX1(oom#Kk!pS?AxI_wd**c5mtFo>@h!Afxs8QxU%(fO?HKfO}cn@=7i?+5)$rdv>!6#hgT@qAyTu_CqOz7vERZ&{p^2&iy5fyMPxG>VmTgN{SjjAeFDxi8tb5|yEv@s@YyXv zXs?2$?(t7x{={&^dWDU0I?A<$-9Xj5P5hBUgaykCd9Gp z(gMO6RR423e;ZGsC$7tMaz9qRpp2im!76YvEIk8=ZXevHon?CpXemV4MDY<&{G>tzf6;;pq(phypzVq^!Tvx_LClU{+Im#;$Wsa^z z+>g*5J|3+vdSz3}Zc6H<#qU1>Yo~9ISa=W{#s~Hc>t<{4u&z!XXBI2Uh-ejWt4QDp zX{PkMmc7jD5tmtR&`daFfpD_ui`)h~9LL_OUFY?fFI;;yX;EAWxEGR~cWvaXkfjP2 zXVT;QG%nWULS(%@ZejhfxJ(sVrx@2zTen}rHV z2yY<=iF^mxgv=KgEC(`x8qj@O<-ETP}|#Ehs` zI2dmEN?0Xc+?~SO7@sa~>PLT~xNEiw^VT*CFJ;o2>wJIlhfIYCKDsbvHRmt4j)=1P zb4?IFg5K~K`gxAOjpm(W%a{l*m}H8dwa~*ub*Yl2tz^*!2ugf$6APA zL(0Jy@Z7oYhV6PJh8mHg!>;y13+1$n&tX22o#QvV4eIjU-tGwIXrvBOvWU$OTOBHr_;D7A z!Rbv;9oi%La9vg+7y&0yUb<~HC-Q9fHb8QhKvD>S^i=65NJGuBqMeOYALRuOX|=Df z{j98$M3`xFh#K^ZPJs|MPMIqTBT?2RpwT_x2XWh=N8acYAd&yg-mJ!^(BJmE07LSFV zZX{vR26s5C8qC3ZW1$coQ+iZ;D6o90GYef>T&Hl4dWh!-po7Wx#Taqd40kp zZg^KJGa?C7?qU)=WSduuKl*!i)5~%}hH-H$nznTF%bk;=q-#j`pi_2YwjCSbIqNobXG?WoIL$nOX(_#TVWS<}dlDtQt^zP4?cVy!(_P?FTOQ#hChQ45h`ZYFp9^ zGm>hbaPm4elKm#cjqJai(Nx`QmE{S~yL-_6|GE?Y`q@(1Js9@WFDsi{K!^F#+mE8W z?-Ql*AQ$SnoK<}46*aTfQyQCFK`(#zr$=HOW>=lnlHJ-(t|CR^SZ$*`;RjofVUig{ zoMn8Kb608@np|tP4HF*9Q&rac(s4}>S6BK5lQ_>!A*S$c!gy%*3?vMsp--{*N3_}V zN>QV$8pRqZ^$OQ?C$GAq%~GT+pky6A2zb^Yq~#czp)P$@zb(l-Y{JXa-36{3b;s>I zfi9*{FO4y(IjQXxeX1Xps&NpSacxd3I6L*Cx;{{~y9A-0$(LLwe^2jHp6$!t9o;;B zd~bwGccI`jpB+4?M@Ovtw3r#uyd9>zo;{E5(-?hJU2jLCFhulikzKEuluUhut}L-F z)~%gYhjPMqQ9A})z)Ks(kE?rdS)_sjx)S_C+`EE_W<$1QaiFHLOLE;=`CH=dv>7zN&#PzW3M}n}HW?%KCYnyP2I^!wSV()5P{c1*&c1TIDD)~(Z z1e~x0(n{XV{~b=dM|erjWU29#@ACMX=qu)U#8L>y*8CvChHil3xEr-#{<)0uYYvZZZ6jjbkJ98UHn6MX>1!@x3UM>o=yRc?+_m<@5ZCn9HGegXE zVNNE1X*vhob=9HWu;*0UXn8ppes*uGi0De?q0c&DgO21;GPPpM3toonIU@abZ_iG= z2*$+3%k+#Y_O(e)_Qt7dmT;cCv)IpE*~%De7?hsE1Yo$KRkwEd%)@VpfT!G-uOj{1 zM*T~9KY9msp5!fB8u+;<-3(&J25D#ezzO`a&WU9Ngf0^2&FWgk zjV!Zi+1Zz~J=**2=Rc1-?7aa9z7vs_?+FTtrJ-v)m8iNnRa3?Up|ST&^^e7%?6!;k zPsifNFuoP+p-dgo`p3f<`JEQ093^`DbQe*K+tvmZsV=%QGxsIdo$uZH^5@^}KO9lO zSp{1Jw>Cb3{6>#{AgTuLF6ylZFNn?(ZK_Jl@1BBpIOM_a0!nd=c9bTuj2v7G-l%;Y zjDPa2zj-_~p1xn=9g;b_CtCBf0ciuhllbio03(|u8ESi>fK%6l+otCiBDmKfr4!Ih&&U1b3;v_xGlrP@*n(_Ok>f?lqo&~{C#cnE2 z#M~^5W{i1C@?$dLkY1wZ&hBmWtP$m6n#mzrtMUL={)3+YwWk8{^>|$4Y z?f*=8JP|dl=Q9Alt-EUR!ukjU6X*=c8xl{eVT=ZKAox|r+ zj_G*1u#h^0D+PWxz5=bO?G|U5AY8g!eYNqQ#S{N|od2Jn;!WqHFWLl?fXKcaY#B8Y z?q!;PgtxO}$!HZs(N3^l%Nb}02;k{Cl0Q25@|MV66zQzsK!~T5~VfbeH+6WQYU!nxJk7v$2gpZPOG>`*iLBkn52J z!_qLn6itniCCV$0GcU)Z37^POWXH=$!!Pd=hFTPcq{EFwi348|TPIgmc5q*U&7FKl z{53J42XNT~aICApniZ7TiS4~Dsg-YH!IQO7Ua=n_GWJJrjo1E$o!3e4)p-cnu$%gl z=rfMbPi%W}SxaeNt63eAsAI4`kkpdg+HD~fskj7wP&uYF8?K4WHw1!;afVnGG-QTgl6b!SEV z3JDvJ50Kp3kSeHf8w!`!Vy)kJyt>kVMQ#5~W!`Ml>%R>VzPXIhPU0a>(5N)HjE650 z?Ug;%@LCI+Zu4Y)RITyBIKc0j3qFG{bYXj+DoTCHqB_&NssC;I`{(nsdL9X2)NK14 z%@gp1FlUUQ$m;fXz}_qQlu&Z&y=PNAv%9FTn#gIKTeT!#bFLkUHv{v2sSJI> z28?Bcl9iIeMP;s`H`ApCU~O#IG3BPO9g{))Qbr*?Ta5GG}bn zrq%G#2MQ%BeUfhjxpHJTSHJ9$ah)CSa1kO%F1b3#)8UJ_r4jr;bfBZykSkRT8fCjPevxTIglIktIYTy^f|Du(IRc zOc8$B!xXL@u1f6ve;B*&Kq}il9Hl}U#vv-LlTFH&QJE)uuk38f3fYQYE7@hw>`gW$ zBiXx*ghGU5@9+1N*7x=1>#x%}&N$=7`{_Fsf9bG@qL=_C`+}W1in8Ld! zdM_?YrG+Sd>1%#oY}&09T)`S_>AnTn2Q!#bOxZgHWh^sjfl5xb^v3Fn05zyFEpwX zU$Dko+c7AgW-u4ZQbn?oJY7@ueZjPSq<_$ZIVg#-09*gSxX4*p@gzwV(^8)8t5pY&C@r13m}Or1>?+~ z!)JW8jxJNg+#IHoZNSy$`7z`BDQdiMuDpTvUW4OU)gkLSI=nAg9Zl3xFe1pzfy`6j zk1P|PNqh}812}l%jvMfIB{2EOW?eFDY9+~%NNpHByzd3zq-(rMscsJfWXjX@F#rhP z(kxY9&LOA~Id0j=%=-YckU}d&+h9rZ(?gF?1qWHnnLb>ib7zO2vSgBXh_k&pOG2>< z^&RdSD!pJ}hdB4Peb{VO3~x+xIOerSfEaCvWRIduGt#6(%0Pa{b3P?@-E7c*b97;e zcG9wG^*}n`@jE{MYTCD7s6lkTM%R3b$a=CmxeyAK3tzbs-WEj7s4l5lIaGi-SQYvT z*@?3U#sm?!ow(XhN~K}n5J&0bupgG1Z|b}Qm0=n032OgVT&jqN7^NHHLYzj-!5fQx zOa%|`qr}3X=WHD|$Zpopk>swC|BoM3)Z9)ut}QlQ;@uQ_L?$ugjzx{hPOO%ljXQY? zZQ6c!MNM!9hF+&DZnl|Er1ci|8l?%Ak~^t-dnX$v*SY>x(v@`G=nAT_d>MXP;H1A*CSCjE_<;@A0`_Ya9^dzB-!$WIb-gj zvNYy$f$}t^T1BOdM!i#U@?vdo(%hA_WJcdfL<}QHjzK+t`4I|b4+F85mAYEm)(f2AMZFXMX>x+ezkzC@U#|I% zG10%pYyWfF3+NtBuH2YfEXlp2=X+VFr z18bDecE8}8EK(Uvx~B$6rmLypDgvW08e*yP60P|0OTA4DKSOcnst;EGwOc&1umJUtT0*J07IL z{Sb5cZrt_F!s(h@v!}{q?Tnhbma$Ddy}tBIxmAL{V7ZfzQZzF0e}VupSS$0XI}yTh zm@m~=zdDjo{YXF3I%JZ>!K1+*Mp;tks_Zg%ce0@*Fw!}@|JozjzLS~7#$b@hh>DQfy+?*VG$4n@ z?4&yIdj^$wyzSXI-po9unyV|iK7Xzv7F|RY!ajkP&wV{jCk@AK`n4E8GXvnvX7sUsm}r#M z(*XAC7WHU}I(Kg&>f$ai!%-^LdT-<-OQGI7624i0;*qvU*LvZRIMMmY@KikD3;Y{YBvzO#t_qAiK_k3@yXPm6Kk``>JJo=bG%$ zN*zTt-suaEW2=q2wQo*%qb%^fH!Gj7ZtZJI97PR;7xV7U=jZ?!F-3VJGPkk2VR)a> z<$Q!@?ySSm2161uA$r|*$UP;&F7;~WkhW%TmaciMd#_SsLTJfBoIe|g3E`9L;W``h z5mDc$-lfW6UTrIxs{7*XIFD1P`ZMU7pNO5$Fn&W<20oFOS@yLTH1od3^L2Oci4It$ zYxBX(w?lJZ8BT<1Zw>g|y zZfj`_F91u0&{=h>b?A1E1g1mNk8v|ZHupu21{GHsBJczUG}=~@!i!zzlUkX=QcX9yly~T%OpFdJnL2SkDbivA_Qc+P<;5NOF;d{A~ivstmW3v zTQ7iY<^xh1W4Cz!vijrd7HbXnCX)1mid~DW=$uvdsI|kU0ErUHw}6SOP~GYN$l-i?5Ps<$UJ?z*bPZOqSHzZ!9;t0!D;_Q#&F=nfS}AlF)Sf%!gdopaoV9 zGYAKmB^p>@U`J27KFbTr4fPxGrhkuZ_6J?jbeE9}lTTWZ@)JB5Vn`F~Pk5f@jhury z(NRRy$;sdMYb6Lf4#z*J6@&XY|CtmtX+!1bD-|i7mSZXSoE&IRp1t%La=1nBwCcdz zk71bCPjKXkKP9+(0m<(S>0X(*B48p*%1m*mhv0J54?inbR}tcwyKBg>BJp|RV0p#s zT}&+Tf{&u?r#UOBJu}nXjniw)^51y{&>KEKm39w5*MM7X{3RFDpd*6BnX!kOF@=P` ze4*LEdKDL@YyrmI?05Tm5+=~(C=@LRP2(^y&I2(NTc@lK>Ci?{L6OL*p7tt6EuNAG ztNFIG+Igu+5siwlqu&QR((1uzI%-zBJsX((mjw&+i^M>&i*W9As@!uiWOSgzO9}wyv(Kl5%W&kK)uvs3uUkYupB?3{R zt{xamd(PCEh|`dZvheB|d~LiSidz>%EaQE$rcTMUJ5Cg7sUf;~5u?$B4{7Wo)L@Dt za>9Q74yD6qR|N0Zcs7_zLINX~g7Xk+|A8LHX#|+`q?|U#v;+&#*?K|&j4;JY0Tb=| z-Qw&6?*nm-xYg4+pNzb~85kaWzoueMr~KA+--*|)o6E(}!2f3rYKtSKjXk-oRq9Ax zP^~43hvI>M4Kihlkk>BjTBvA>dJoj60qBFEu0~`0;sQifEMvwTEml#}dFQj4)G4=R zK!1T+{Fngx_FT-@03erJ^^@rMFxBJcOmdz+T@{ukkGNVuBa|fy> z15h*=)gecqErp;@fPT>9p$(JrhfxLcqH$IdFds#+`h=JE?G12Qyn97NQ-Vaq_G*0+ zl}jSDLCPIsxlefSTZ%EC^ophyl6K36vQs0BehgldOIi*G3)usakJ($y?4?{O=it^f zfZchH6r5_9%q(RrsO02Mx2Ksmz-%addO#R|gJfX?Q6vrVQln_nUcQ4AZXudmxeoUA0PtTSll`-@6G^;*EMw75tA^3L zBywEt?mHw=b2Zfr%`cnFI>4uZTL+~bv%F$K%W*hJi%UrX$5aHTa(Ecoe$T>0a`Q>`{chGSMIe{jR7Q)Tl19A!Ia*2-3a0ahDY`;GUyM~* z6E5A+^nE}ke`l4VLT+j`6!5nUBOJ9UoEKZ~R7ie}q~7E~#r38d%=M267fcsa$P$lO zW~=ZRu>X}Lncox$3SMBkuG*7$5?*h*ldRa>9FnXmn5KZGh$#ALaEwE^AZmoQAKl9Z z@Xi6OeaGIB63E1{ZYT-jdI#;n)W?(4VX6}~pFq{2muk+7GV3G>!)9!Btye(q02HG} zPYX`KobV!hlDmBVxQJ4a15K0*je|yC>d5nbl=Gf>=}QHY-bZS@1L&2#H>>?<-Ya9!_U%4~*?Q^4dQAF+7+A1PRWP)=5Z<3g;rwo2XPp?vq!CxJxiazZJXRG_V z!)%QcR+`$__~r^=5IUj(a<{W|HTW@TyN1DX_fi%Y9W8rY!<_gq2ONVbaPy!&wCy z&X8f@AcJenhjTkE7wIdZx6?cTdK_lZOqw;4$s$>c6%h7HA?J0lr8N^0Ed$oa56&`F zb+?mw5XpxQ>x>J|o9iBXw7uLtNv~h^EFq`+!U-A81tJL=v(phem^k@#02w<|zZIP# z(D6}FzCi+kfXG(hWSCJrp)ZZzlSgP1zlno9VHV|36G@PeExVR^!L*mf2Fh3^pcun! z{b(JAmhX3N-nvh?+sI61mT5xqH9MWUfVIagOE2kL(h@%y(0u5%W)BGN^|Ge{o-~gi zYvXrO4sc6DJ=eM)Cd-ubb?WF!Q69crM}DvNs>d^U?r5Vt?5=qC6f3HhX=R*+LXTQJxg z%Ng^U!O@9EOHb*Gr=47SR6z4}t2V)*j|6>Mm!gJ6UlhN+bt|$Wdzehne_`vs^(%qG zzaMWSsb^mJ$)hLD_LgQf`uaEBlil=+|Xo&;zp zN8b(ZSMT-spW4iCn}k0Rk6xqM1E>TptzUcKg2I!QVMX7}b0f3LN2Py+ezjg42gCk& z90fBV-PQeYR8@r^X(RFu1-so2lgTH03Fyg&M!`V2B-E9*(--~tHf?1YhXT1Gp+m{2 zIGphKqW-yw?wlGG2SE~Jv9D9z;Fnfv(g;Z#EU&)BtS^9L9kUa1x}RdI@{&qD|Fe{3 z1N6#2e8m#5Vm1>K6pLR$i*Ef2Cs$?b=`-jL?UxP)RtZ{vT%BzpE}&66AX@hdT^34g zkhoZLtw_oDK^rzZLS4I_U2S}Q3!ogIMW=>uj$1OkeY$Kf?wH|Tw+Re&CBSu+ks`l5 z*O>|O2O87&h$KEcHY7!=91zFfcyDR)nuF8$R1qkAB-NhcQi$dr()UAg(JDv>6n^YT zN=ohESqA7^;-dakYgtg_=nYx=e31@Vtqs;Zw~hQ()#bM^J(w3(?eyoy2Y<|E7kx7V z;<9bGKY^2r8pDl7D>w?LrSI;x)ULRT-Y0F&jS&e7elMnuAxzpMuRN#LvRvm&F_w;V zD?o8gZxVdEH9`X9;3G^%sePPsx}ykqFv@w=8_0EzXW2`NK86|UfO9qYFGqmEY&J(y z*;Gy@@%*$Ps)imK15uK%6RT~#T&eS4j)AGQf)PK1fUB94?#vPvcq1_ukd4mk{Ab-TxBgY{VeZ9 zIWoY70I5=JBbMz-Y>4?1?&&7d8}%WvRx{t$x}2C;Y)>Qz!f=0id1j-Wtky}{x?WOr z&B~8GkvdZ(nn|I(GPwfcNc5eL&P*!#$!$d?)wrB&EE*(CsOB>@TC_kVYq5elp2lno zLCqWw+Poiumg!)@xqp8ecqd$1{Hy+moz)7gK#9s>P#)o z$0MdkMuj1BCJY9kW{j8|Z3((13z9$QTlaRV+()?kK`oi9)rjtZ(Gjdi8L7|8xfmDj_ zc0p|+B#*M>0ZQ#Ln`xMARVn0s`N^g-8!Bf-y(bZ2=|VyLRqBs1gmSD&0&|$9tXfrX zbC^=*wbaU5F39KbM>Vw-ht<(#m07G$bsD1=JKR`QIMQ?6Q;4ZMVboM3Yc#la1gX6? z*)wD&*yTg~Z%2u)2#28;TEp0Y;E%6COq7G6H(sy;k>&|CcBQc9=S2u#H5${QLF43~ z2%LF!RKj$N_sdXw5#b;QiVtsIZxCS_n;Gy@bB0aJFH}CPaqB#UPLYihc06Y|^pr$F z=~OE3f@)oZ6mG8*9QjgcZjDCFgcarvf~f5J45CQZA<0)Rz1Hb|@wUN%1F_J6=#}3DIyUsL4rknngmNIpdd1}!axy~>PG18T&o@Sbgu$EP9sc?wR zomV?cZ+)8kdwu%%l19ul&b-YC(uw+T3v`-RD`%44YVORN{(CPC=>zRB%vtoQ=~&jhi3YPEq}>+r z^<`B?#8=}i7gRmRiKBDdF?87Mp;3zCBCv&X%1q>s60A_Xog!pIL?e1l8x)7fZvFPk$0E_YEU zh;H$+f)`!shY(eVT2nx*!ll-YtX=8N8zs!&K6z86}y6tstLBcdv7 zu)5?DnxWbscvZGDsfVv{QHzglr`@R8cFWPDbX)*(}P}ajw;O6 ztd}X!Kj=*`Z{18D@9l-bmV)wV-cV>o^1TnfB|UeU`Er;IMj^3hmHj;kwZ>0)e^E7+ zbLawF>?r1Q$#Q_NP0%_@y95$4`5Gb`l*CBjP5&HTN|rQ>(wKdV{GfEq-oL@<2Zq>h$ zX_wK0Zo)L+$;253T1++EPz7hvUWF#Nn5HWH)VK zN~)SeInNz|DvUwIuO~b;wFZ5oDFl!@{;2zEhYbPVUyau;?5@)>YTWmaS%{<-tF&BY zMt`7gaEv7TSoxvoVJ0&KY|)?ToOl@Ia=R2%Yiwp$ov~G1ZUDcb86vLLXOibT39W$9 z;bSTW0^UvIV}MhkF}NIbSk2qoU^Wt*K&NSL{W&Ms5U4$Jq6IompTm3Bp?v~#hXsfw zD_#CU#nU8EKa*SldZa1tuo^EQieW(pY0B0T+6R@a;sX?`KGHH*jiR*o7n9k(-y8I> z^%lT+ammL<5s}jEJt@!0O-{lAY0uYzGLC65P`BZ3t7%hG4DP3XoTD8D9Paj%&OyOs zn3m5Z9Wi^Zshqzu%h*KYW&9dZ6GTcS(I4m(_;dD`R0Qy*IMw)4KOKUQWnp%=yPD)I z!RmB|5@XE)YBNE{E+>-fSDA5BHOz@%IJ<#c;p!~5*HsxuuceplPEQ^#*7*gC>n2Xp z@}@)c9I6c`{JXrFD#kO2Ur4=*{R2j@$TM9Q;JcJ8f-Y~18BR0;8} zl`z*KXJ6>>^3BbRElzt>m^C7@QF)vsFL0(4GTSNtCHDPR^KvCewdOg05W;If=s$Xj_AiBMm!{Vb=NDBY(>3GwQA}-B zL_sE4403TbYWd@hfY=x(jckj%im_t3`Suc@XZ~^!3ad??gz)bgNE0*c%>|9d z)zyMze^f!6q$Mev^kBZr1GBy8NSU>+tYovU!3aThuN!SjJh8#pN}czUnWUY`(~?34 zd$iA!>u*q}gb+>`YSA=NG3X`abk7)(&0vmF4TOH_bWB*2TS{KfKOBte_1B-573(pm zpc4^Z%E-)mZ$N%^;KgcN1k)%hUCkwv`}8cKFw<_xpq;eFYw-}*`-HoZ$-kUGnmvGa zq~R2lDkGZ5p-_MH$v|qrcinI#ogYp6)DUy=+Lt8iebzSWR zEFM`!H7P_5JXt#4;dDNPbv<=l^lC+|OxREEnc~GDfCVp zTjmyy@vWAp7r2*utv)eE6k@29WIqX9Qs>Vh3RWLhz$7OrG1o-XD`h{ci%34yRFGfEL_qs_`Jn@m_Xo>z6+WRkiI7$4#=z0Y;d`=0#bs>NUtVev|q4mlFstb*rVMwdwldnaDXSl}DX`XcDB4d63c;w$!Jd|N8r9-mwb&@o{q??rBvPC*id zxhshuvT4ch;L9hhX?WLrqBK?I2OCsN$~o+3hrlp>pLS$wrMy zH~Ny;$R-Iew3{;E5u+;Zx}W}jcKI2xCfDvQ3@|AkFWXTrWWO#HPS1LpziQX!+ac2W zX`Bc52VJc7&^2$|meKul^6=XarxkdHA=73UmOa&!5w53HznY$tN^zL$J9HffUup2; zGOzUcGgQBBmOpJJeve(u5=YN}+8)z#)x%fv)=?Sc33EI}`|k~luNMCP;}WE&vdGbiu!5}<+5BBDBD#%1yc*}cfGMNJ^4F_ zaE$!t8vW@J0}a2A_{w~Se!y~QOElfz&+#wo(E4as{V+Mvu;X7H71kbFHJ7b_Dy#PW zGy3hLrCeNs&sVEdC%Mpa=I_T=AXGO__qs)sy1h)Ux;oI&`Ei;c3{B}p=;&%R^H=dZy2;BZ1Hx5z=*edLc<`KP@`odXO09ysT2dS+o3d~t!5yZK~RZExM$_I8k3 z!S1f|>9(nSHG|8r(|WjKh_kgLY|klso)HZHf3IOe-bL4Zf$PgoT3tVkRLt<6^cuVL z>eD1WpUH0?#;568-qpeLZKu6Dsp*(>X2s;_yW%~6UoPc6z{HlT_Q;zBgw1nZ-AMnm z|Nr=0!XDaFwTA9;X_%rH6SsI6EzavTk`-3r-AH5_N|v!^-lI}zHg#uyd`LmX5M6j{ z=*kkbE8okT0;6~Y%2PGpz~3I=YhSqT-+e`Q*te~Y()rV9b7Xi=4JgD+BgLlq$1BJH z+Mr$J%gfdb=b=Q;4#12OwwSp;UeC#gsO+egL_h8CbTe|GK{!ln$P!ZE?j95&d!QO7 z&eV8n?HR&x%kXdz3TgyAWkc6oQ=(X93F+h*fbT|iw29}S7d`y>@KaSKO{kJtK~MTA zWjrW_tt{u)hIK+*(F0gk=SQ{j%%;S9$cdD4bv?s@0!8P3SL0f@e!{{)mL8Xw@J=^A zCLLShlWjQ<$OxpQ%Vrue3i-%(9gx3FfUZqB$#~GrgTK6n0PgbUk@m>V%xDFVa-|inE)@7{s~IwJ?Ot$6sHHZa(9} zKZFew_{nR!<{2slw8tJ?+-VJVVO@RZb&+oDih@w!s|s(jq})Ko0US^B)RI&2&-dpS zAxlue!9nn+GyBVP;2%Pm^taLl11A__k|W-#{hcP^rzJz+`%2`-N1`VtTFD*#NH=!glHqH#fI4go0^h3dQq>559Qp6p^>tZk1zon@Wy%P--Tr1^ zTOF|Io>XJ#+t=x&ub#qI=nrI7aPL$$t&@PJx_Bg4L2sD2{a33`tMm@??$mePB$bBU zHYHG)BiXvr`3)iQa|8U>BYqs*!((a{&$FX|_fd}5IrAR!2U6kK3#bvf@OY7|9q#qA z&@+{*$^C3+z3B>a`L^y z4i4Msy5@?-?N(@4-}F8g+!1cPgBSjO&-crPx&+fVW9VhBm#1!atLX6e%P#oQ@qF9M zF%jD?lC!V6V29=8kGZ`ky&w{t4EM-2$!~vbAPO5#RVLc_&&lBT8`>Gb?@i@RbnehD zV?#_E>0f`Us|Eh&vW)&=wL@PwA)+Vn)hJ+ku#KMXQ4*<_(W2Zw9K@%==j2takwCNd z?|1d26wO!3ll%fhxNElO9{2g! z{5_ER`IZUcXI@z}HZuSsV@!KNA0aobHFoEhi~A*R{Qg@PPCi_4$ULzsLHX@Vk`=Iw z%}>zfh!iYlsq~pTX64qV{xZA~Gmj0d58~JF%@ENLZd--#AN9Xq#7~5i&T+BZ+UWGT zr0wm?9}oA%I-bh>`&RkGHGTacYexRuBChCNRy*WOKP*>_#h&zgr@Bw`26qgv8h92w z!h(3E?sdntZ)@*`-rhTtcRKIx^yLd^ejiy!U-ojr-|XSfmHzKX)DQSMdybq|Rx_{l zQTgu|e{mzff1JV7?I8ROX`Gwep7i&O9}aw>P0l&?9ePAUqv;r(U9l#wJ7P$@gNG0& zK3V(3^OiVAlh?(O$GSu(Ilm8~%3wPrUGv|eP#=Sb5awFg+=XlfwbQQIPppi1hLU`3LUkAJUqUdlV zh3v>qS!{4k> z7z*+q<-rXja@XdaEH8iko^&#*DA5p~aIgROs2-+Pf?ymc&>VY*+xqiVB_7Epe5mXx zh_SRbY9h?8eMX-4Ys^M}y@bX6S(VTKcP{@iH#&Xn$Ds_|lP*vop88MV&jtPCBLgj0 zi_9|uxkacGCX72piz$1S{iZQLf|MYM?KHmxC6xz<5iH9quFxN_SeHHNGgc7OVek9( zCjIYKxP~3h9yT_L(~uhsdf$gQOEob?=c8?2FXTG!d#dI zVf}DeTrKC%%lhLZxrh9ml;;(s3Jtg0kE}GB8(UoU!zxb68O+(WsUK7^_}kkyMg~eD zM6jt-J4f3Yci0_Xu+-wxWOJ$2cg}e_t6LrW8vXvebN#VLUHFyvKB>qcVsZTZvdZoUm zk1A7q8{2WY>nKtv$ zUre^+D~Z}>% znM_U~Y9qYaA5p@=PIIzHUO~BrMr&~_+BvF&J!~@Caq%%9uQHM9_aF1)JEW3bHhE5< zHdG`3?-RTWJNT5;k^15Nw5dMz{B*x;2G>W7yPDsbI2`nD5dP&feVgfgVcCvL}|Deg-RerL;G;IO<7#Wja^j*aU^fMT2m z)mj^bEozg5WaVXZBzGw&L^Lf-5A-oW*KGrlFM-i9BmXR!)d>YPb3tTGmK{3BN$+i7 z%CZPpK-L`Ei`q5H7qd(4hrx~8Wu|>kr(Jd*yaoKQHV7qY zkA`!3^yKLCPybUPbuIfAg^dcyW3x4ar;|+` ziQtcsjOIlo+bk@)`^i`g9`*qgAaY^m)NyvGlt$-E&KO@}EE$iB5n}tFz%=GC*5u&3 zY7UaqFLVCiU%x;t)l3%tp#e8yfzmlR@5P5tOgqvi{xBf$g>(;Uq2=(9i}UFUQauWO zowcGEw|CnyCd<2m*x8d3sH_v?{;+wjC8*ZH@Y)B*!$pXx4sSGNUoX9F23ziPR)cS6 ziM27Pecz0xW;AL6KAP*m+WBfANKXRlR>kJq%UMI$8Lz`Y9Vzy7x|{MKgNVAu(~oT(W;3 z#r(cuAw9B25*HCv&lerT8lEF_onJ<-YzG|4=dkF2hjSn+Y*j$@=MDFwYlUiZ^m)3p zZe*4RAsc|>d2;e$z*ONT?~?@0n}Fc2&s6sE3O>e259ltfqO{?{U|W^?-3XT^ib?$w zf^I7Ydd8fZz6|H3ds~arGS3k{g082Md>bq|lAbd`nkEQW(}sy$C_k_f48UyUB+E1+ zrwWDZT<8lgrKS<(qkilL#Cs)cV@=-VxD=Q^jFtFt$CcY&0#+o`3!{+X+95uA#ty9G zpZy57-MQRTmjaGMNSM}`&U{i?t-%kU;hU+93ENY357(%a@Y44ZA98K~>|qi=Q*vkwHTuKRqVX;&xHQ#s`)E{+oaO1gO8Ey&JrWX%f^Qm`1s`i4@;2^ym5dmq&7u{K{Jm=jmcZw4tzOJ?F9a?pG|#(87vR$ddErD<=z zIdV9gb-Y)eY_ctas$gPjdhPo<*h*F-wZ4{LfWg6k4bGE z^q(d0>ll2V;q;g)FHak%idoL$+GMeC&21Nt--9Q4M$MYXvopE0lyYG^B=|oTN=nZ4 zbEP4T(FZ%Zrw%9Tg4Pead0`|Paef9Me|lu31VIVwr6MZ=#3sZ{Z&&ZE_jObqf9h7Y ze6YLfZq-F$)^i8eO7cKsxue`oKdN%6LYgq8Yr}JAUL=1Be5^TGBP;Fb2MC?8 zwnhs3{8Bx_QEmO$Xk+cs>IL8mOBE+ha$Sa?jc6n`C;6VUMlyjGH=vXA1XSaF;a$Q^ z8#gz?>sM`LhflK6s-Ij>Z@uVew2_`{YeN2e(SQtF!6%T!PcP!tPMO^=zn=OoKf>>U zB{*?rD@XXKP}sGf`{eJBw+;q)bRQvux|TahKahrnzE+$d*l_#;hK6?G241R$ zvv9#?h>8?i-r?3GmyAa`3C>9@3pb;=6fIfQdAHW*mi1mt!t{Q@P=UHZv#Rrb@nbeb13D+Z=UB5LGt!pilN<;&Jp&6@u4co@yq}r6>~}8?hv&x zIJfOb@?D_itFkNdXIn}BbWF9Ns!5JuTmd2*0%U|%n6i9G1bU#^>#+o(-9AJyoRr5k zJV55-P4yug#SPQO)itH7ckvu@VA!t&Nd8&?8{fP%3B&u=2(ATsR~~D?Y2Vn}nQ1mq zvQn)EA&NN!!wa4@C`Pq$2p+|kkmOzUF%<=OU%uhU+C1PX$YvP(67Ol|YLwZU2NFGI zNXxLz8lF3qx&TT7KI*7>)u`Qj58Q$X%Gx+R$3vEo9c{Y?2>c4jEaGwR_51c_Rkaaw@3U>`8jn=L{OnT2g`QIVEN_oi7ne| zQ$1p4zkQ;dzY9u@z`NidN!tT`i7;%V7<}<%T7G%_?d_ugqeBJBSk(zU-?;#s;B+6G zdiTp5Q83l{JM#w7F?4Tp5$0?vK3O+vblC(%yDt!(h^Lc1S<&`G?xf_4tP3>&xE=t> z@nMken*vU_`KbB}wMO;BicSo-QGZbK+)*@(AIHEM2vUXtj7YG@3U=vy8F3NnIM$L&}P^N>Huhs8mC5^Kqj!e=uD0$MGS&V>_md_fut<@}N z*dgGgwaGNzfvcG1<(Fstie4P#ZbVSo61ccsymk{&2xlUqL}IC~KDItC%x3|-N}oMH z#}#LC>Bd*kcn_Q>#r?n04>Qhs8RUXxcB_F zfBEJ2D{U?2Zf44oM8^7Wza%w_z1qk0y;t;$uln6a;t@g6tfhYJd)V^Z2mc5Ke#x4V zt_Tbd2|8f9chR!pq%&)}?hf>d{Pw=i^k*&td$y}gY;Z+@g8JMDJ!jB zOg_K6Z*57#eu_2v7{)WGN_(S8tnL#qLr((_NTOswVg-$VH;C4a0$}#+7FW7(A0{AC zK(k~T0o%iFzZ6Yoi~vB8fC{AMvn4DsQBMT)L7zQm4S_-f(WO9iE5@@f9U)j#YZ?9Ee)ROP)({ z#E>D}OQk^ckM@rd$Ne&|vq7@J`kPNqg@hh@)A~lUX;H6-XOeIS#-%7ot z!-aYS=k-F~H6RLiU2Qv736622oDaa*%dwt4VHbzW-XJiyjk8PH)JJ0o)dT1mgS04q zb?m8^A+~2_mgqWfk$>dZ7yfl$L+Gi7t-K{JSDY!CTVx?>dHmN{!yUIfi{B}|qDAWIg`Z>C=a3&_9 zTB|A(G;c}}!4xVTnc*zJ=B^1`#{>`uBN!tp-}bc?)CSKr&%T3TN1`8LJd?=jkmw1a z*pgHuJzi4!nSm7PL@<D`T9 zr?s|jUr)mh$lJf)>#QgqUZ$J&-rb}3PJ7vjmu4xO4|G{yuSqYZ-5aEd{hahR1b{_0#K|Gq)FMk|MO>!0-XF)I@c+xxUpzXMI0Vk&c2VVWVI(xus9_ zghY?*gq4~xPs)`ow^ck@L=f(-CGWXQJ4aHHoLvk83fyTUGCk+t$R|rZN8Zn-cG2MCdh&Te_LmZ4mZ?Kf=oDuSxBJ!1 z9zJt;N&T{zwU;;lv%*9DJ=ucUDq+9pw*R$5fBUcN0i4Z;TICUPbB?hh1apaT5ue-l zZ%4I%&pn{%6op^J-rhBO7*#lDlR9HBS>aePXOB6w{RJm`un8#G#PGai*YKkE?-SF_ zmCzV>wa;4>>y175<16?-9%;Qf0nsCwomsJVjaS0S#5Z~R;XpQnHZ8)gCw?FFF=iT~&0;f)5=h=+ZF$(#21nZZFdruG&7JAW7Xwp0xy<&*K45n@huSr_=^&BsJ)!(^yiI%X(1`67pOWe}YStyY) zQkK-iY&dQ!y$2@}?B$-lf%;E$rb_LcwU2&BbhPv48$?pBuj1(x*uNH9C`1@;0KH5) zfrjPXr7F7imG=kD$1+v3oHka?{HKy0)M+NG73WGz>9E~Z*WY({HR;yvNV>--h@R)( z>AV2+qZbho8d2^W6e{h#er zc|W07x4Dn?uq(pnbnlFGH+J)9xb0uASgN+nb`!}x@a+OtsHD;qGDMP$JCn5#VD}tE zLqel9B=1ktOAJ|nw>=LpU+_jTc&UbU{>0D5n7LBZ#rBYLlbXxOqpfuLVOi~rq{ zJI?a128bwkfL3cJ)BFmYPy#)w6CZNG8dv8F5oh;+I!!{Z712cK;w%swm;w*?-Vs&B z5{E0Vr^_^POMZ4OxM-rK!wr z&O{{k>2+)C#?H*^+$j|fkmKpVsIwMGf?1Dn?`=QM{=CF-#(m$Mo3JVH8}ghvrD@U0 zJP+YU7+hoH_%Z2cp>DV&&ujtvcGP{%eJySy=3z}Ro#Ngm(q-vM+`=ig1WTa!ce()O zBNm7>Sb_i1f9hsYR0!XA%-u$Y!hUUHnDfXld$0gPzYT~=%n9$_6UY0YpN&aZ^*~JW zV<_z&h1l4}x#+URb7n$yjegr(>h5E7{S0cEJxS28VfH0w&0Q0{Y%yIy@PG*C{3euM zMC(R@mdfDnaQ}#M5BjJBlyDYbcjn?520d0!y1#oepLc2rB&Mny07rFX-|;!KwIS2? z;>?j@p#Eb9y^HL%Nf>86q^Nc5HxK`k0&8%oQKsCZDV!iaetY{!oyM_^l0I#NANjMF z^(Ut;a^~=Q^C|Iy)8XPuYW{8Q=XW?VKX>OF++`=0nNm;5+Zi&Y+1M41@A?$ouODjI zPA~cEiKLcY%%lb(-c4vmh;>E*6_d`NV?G2 zOZ~Gi`*NQvIO{j>l5S~`xUs?>xaCjah0t4z1FV$j1D=VDZ4h=~zf_(;;-GMPAi!b`JfcrJF~?i(m>Fi;s%+*n<> zwr7B*`XeAv&m$x_(i)C;u^RzwZ2)C#J%udw$mF<~3|RKTy@ELIcqNk{{X!6o|H@5x z(EbisUH2Ls(|eR8nn};N-Q6-YD&O*IC@yyat=rK|J)q$|Okt6zndf$3^~eM;P8wcK zpYIhIx&w-aa&a`}Z^?l8^G&waUFqbID_IB+@gt@{(5GlA(z5GqW*>CuH~@M^4$w9e zJ*CRUi}15p0=3FxV6#2b79xa1iIdB$>`;J=4JhyMTH0QG*{ZOSp z#xe~m&;E{aQymq@xU7;1p5ccay3(<_IAy$h|6Pm79>hEYjaCZewJ(OP%GT7Q_fEM} zl5mY5ELps_6xoYN&4__L@hxL289xm!f9)(v_F+H35KQh8c12aac5{rW7z9QHwq49Q z&u*UKdQh+dtr(ATA$LD~_x4C&Ib;(!?;tMg68%6iQiqH5#oemmDlD5JyNL$q^XV^z zV())3iPxj^U*~`nYj85Gs3&_RSA3r6w^Xy9v#I8K;U} znV|RcKsv{xI-S}5x6ULEo9i)rI~+j*SUjW%4?`o*Qa{nhC^NS#O)s&%gH6jMUj83H zkMV7B9wAP;0XOI$2jD+>%yxMjS^`0ZE8)3T;PM{v$e|Gt$5NU;Z`4U``Q}C_nxxRM zqjs-&BEB~_@P#))mnl3y{T%UOgpZ;3S=KEIXpa^=m&LP|IWMo~67JUSa2I=Kc&|J2 zN6!52BL`Bmret@$0jii|#8f=A)Z#;B>BCOnyj0e|^fnrM zrs~|~(&zCZkAdXH4%o9ylp?NV6SqI%g{o6kiANL3MAEY&H;)>_@`*s~ck@}`qeQjL zFF1haYoiwlog3ph9$F>Fe#)jG_bbVemE+7jO=WP;rP)6NHlBT`hp8!?ogK1w&wDlK zjQJ(p=q$Y(7V&qKOYSZfu0~97APAPnK=j`}n{YA@_%{1a^qD(a^pLP;>|)c{B9XZb zN1~6v+G?_O_7)I`2=&@Q?WGYy(6Iq3Jf99uP6($HjO&gFAJYnBHP!<@6_Ss+56VBs zIIT3_y%nk1Pl`&?>EAeZHP#j{zw;K58ll~5Qd*!!_)kP>s{NOGs_JW>CrLH*++U8;9$ks`Mlbk)}mJyv9JXev6i z>ScKszmfzBvVXPJ{7(C;9eG13%acO4_oX=2V3XZ)c*UF_&LHpSskF#J**o7qMDWz- z#lD;25SI#vAti5dFc4=xRA9rdwRv-cRHIAeG4@5P4tpC|T36L-mLFfuAGLqHIHszt zsxqy^Ug~D~LI``l$a4|1eUv>IBm51TGc7D-DQJa2_%%LLGeN4aj*I zB9@l;Kb*aHJk|aGKOUDu9Z6RiNk+>mBZ@LIDpK}HHWg(Zdpm?s*(pLeWh*1u;}{jP zvyLrf&+HMtk5}cYuJ?6)uHWtV*LAv*bk6hjcs?HY^}tQicYn&k1#o|oo?m#j0&Aml z56g@9e6oZQ%}$4h!Sxy3w-lW7sq$Sfb_|^{X}d>zDl=InSxG6J#idIrXnB>Y8gv3` zbc?d$>fnD>PEo^KcvRTnKf^I zDdtkvwL0TRFHjG=Z&~dkJs0ojE<(l*+q;tovQlC0$#R5vu}5nRwUmss+&ZR=0Bpr& z6rrg(o+5Kl(xZg~IzEPX+-{9$z^oaUbNWx(A{rH&3pCj=JvSw6U#cYEkP}&K(L1%C zglDJHCNM4^pj2xSJiqek4-;xGf@QyVgOO|ZsiaTuAr7aao-()Yhsf&3Nebd7#uJ+G z1cTK~k-rL})luBCv5@_=sYZ@zcqFNtxz`BYxuLjIzxCC>NUXlqQFq=WV%N3kIzF0i z(*gfEIDMd<-MG_hzdzSPbmE)pA-g2V1-F(6~(z+(~cYPA^h2;hAQ$RLzN*LcD1PJ z2(qHETPsQ>ZATKc#jUTj3;C0~1&|fFojm+~!l<}a@4O)B{MJ4c!7cmxumUs)fu|D{ zUc$S7sroI-*d7{-{v-5vkeJmtUfGpilSQup_Szb?G=9JeZe#L?Xx=z28p}HQz-}1H z>TD+HIu5dPUv{Ujisv8D(Pg{UNs%A=7G~g^p3}VQB@%yV4}t~g5>2af!t{Cqe)(E9 zZsMgArYF5*Q&0&>!V8CGf2GeL5y=p6<_E91M_XW9dM!ld>A#)M5~X^_uU~%eva|Sx zDPxbTvAP%C_*Z|S&9_r0_96nI{v&Vn%7~qHSg0#xWWsshSFs2~Hud{SxE%VA2H$M? z!EBcXzGoaV|3O#X6(c1sG*n={tvYai)Y@&w<2Tezd;cme|95=@?d7pgh35iiNGlw( zq~l+_#A8eCqp!SAGdTKvIKmM-brOyhPuwDH8e z>w_Gm%h@0gL5jk~YWAOfL>Shgpe{>P~p|lM`eiOP0tCHTU^L@N8V%l@fWjl`B)C0A2^v``)If`JT&;U$4(S zsF`CkrZf-q)YF4!jE{}K(#mf_8odWbefLAvOI)!{CyN`#F}WNo63?(RAI9^Yv{oWK zDw{;M2-dbJUDafz;~&$nJmCn3Vsb2joNs{qnD4|4w4Fw<Ec+vA(-OY` zk0$oP{VrV-w0NKMZ=10huM86+16U1b^HCAS!Z&&y3Ypc3#zc80WsvV(j9v3HhS}B-hUo{qlD~mO z|JyFIT_wiPv{Q{NC6>Gu+vB`H_q9thn@`ngumAH{Dh!jX6s6WqS@9o0z9o)|d<7Fk zzZ?~*RI4z+&xv6gb-dnPv@iEho1H)YN;D@<;jF+(Isc{c)*7g9f3SBg_k23fReQL* z@uL*e6vbo2t@yU}z|SYL>Zm(R3lVTniZq8^R!z|^_~|*cB5c_y z$p_NXzwo?z+e@{E&58EcvH7rQsSa>kQ;Tj$uDj(qh?L!h^t0ZanmM@vgN>-|Hm|M)m!IgW&&PD%b%4{|OZwBF@2qfp&~q_1m1 zWO&c}S{SSM?%Hu*<;BlC9d{AUc1+sc0?+)$!!8d%l#1nUrNfG z7dgJ6@Fk}<5J}O?geAjq+H%it^^5D^mu24Co=ywOpT!NiRN#Y7#zYaPxeTEhm1nhC z-j27v3`t3rT|7bS>G7f5(~nAWWDf@=88&~u$7oT$(x15MbK;;>jn5w+JPcsL50xJa zV>W(v^P#h@DtR7_B@*U;a~^oer$aSitZjqzADtpk8{I&*fI*CZ!&4t7*Y*HFNPDHR zbDWW8;pypuIlSj8TBQU&nQnevRgbv|-yqiV!XMP7G>o?n^)f{y;&0D~d(tN*%$J+- z70GFHmwV>4iiDk>5)yq|<5f8raFw7~^Gdhmd{Gj^@)Y-z{4%>>)Gv1c@-fUQlrA5v z!cs*0L|zK}aq;2y5(B{Ce-b8P6YI6HM5$`uLL6u>hvDfu1M-g7GgGw7YwFwn&3|i_ z+{IG*u8`PTEk2FZr8Q`$@1uQ~b;lB8;jJBi@IMaJ&tc&`7u`D zgE?RyO*feRP(J2a@)NrrO?V$qZ`r!kFT^Mk&`n@_&&5N#0&No zV4l-oNl-|Z>GiaZF@H&k(bNdze%C>8)yn9CAlWtIOK9{pEYi8p{_(}k`{VM!rlI6|N9tNx4jqFrmi(Kz;r$3P7y0$ic z!g`%fW($zGvLtLvey}l9;o%2pFKgX(LwfiT+^O~#>_H^hy$7fHO$0+WhRpmV{(5V^ zRdW*Zymac;R+aR@E3*lWXMX%s2rs9#5h#NB6D77D~&Q^XG+LGQQp zf$czfmwp*wKR+miq(%eyv}nhs0vLp9q3D~kMMev8EL`5Q@tnz9PVkU~mgD9g!BJe5 zf61cD8?AgR@$7f8^fyAE1`pkrz`1xjD_fa$0W{~Ldei`uq*9=lf^!Ebnk@E#RG+nl zZupFdI%;Y)I{n1itB1A2cTeZs5l!d{3(tBfh)%Wk$x}Gn$6r`u$d|gb5b+uAJo&<> z^aHdyrC9Sbs@ip$Fvd6n;aCSr)ighsPpbOq2KNpi)sXB&B?4PRL|O zLFBEq5>}hF+cm|*IqI@T(vJOtdjN-H_y)c;S&nF@Ox-^%LG;@b8^j8;msru}hma^K zf$tw7n}jG9qf9p2fGg&?rp0Z3ckI-n7v3^}_xqf#>WJn^6 z|3}9x>JEX2;jn*(CwZ`76${y9bw>k*AE_|Ptawm%&)&yjX4^rlu6O!NlEQtX=7i%3 zbU&Os@a?O(-ERhpwBr;TxQ;2 zRjxK>i!XVQYcMhmRskMckR|N1zn+WHRtjEP1u`{SCDgclquxD~@cK`IJbgwv%byMtdS%3MeBcu5HL4JJ69X1U;1#Q(+=nsyW;W4;4=KR)|YOGI8%4uD2 zV%{njKyP>S4XbPf6?^Q@zk*qmq&ke-T<-kp=gYU(muJi+{SN4R<{#m^fO6u#Ql^7& zJc#&6!rJc~WTD9-kKlZZUPX>sSCP96FtKL}*zf53$h;l!V9u0j1F)3^sG+Efs+^G@ zDC+nqeCI{Dm$R8jRF4bJtye);THG+z;}l_cfykPUCf9Ytsf!Y2Z`AnuPe2wGxKQ0= z?Yl@(3Vm=zwq5IDDr%q;CN(3S@f}w*yR*J{;4#@0DzJY@m4-H8q)l1753lIhjl;XF z4uvhn6U{hs*ZoPZY_<7?F%TN!wp$c`z$>P@*!P@ol;uZi4{ZZsTU(@?k>K>et zhpdBohF$6~gssLX4R!ID+t1uKSA!Q3v5X;PV+UKI|8|1@{>!TD()vyRGA65H@#Ie5 zu67UC_Aq1Z+6zBF-2eL(b03KZeUkS&0}NRf3>CiDm@!PV#fdL$6K%iWdsi~=O7wS& z3*@WmJu{#6I+iC;OUa!Wc?xjElUlbbMOQzET&6?)tfZ@lEt;fR!;!h%)^2rfi2p0+ z^hTnEL8~HL)4g5$kLa7DuNHoObafw*tcF~_rnrT2UKCRJ*mkF8To|f;QY@P%aGcWT zyd&*SYD{BtKbT)lnJc-T9a{UlejL62); zb0;2%N|uKPpBXjFYC&1>6o7I76%_kDIGVq_Hg4sZhosmpH)Fn)Wf&d??gL;fTmvWK4T zjPYYjLJ80_?F#Q_Gf{NQQRy7kfmq$HIlI8Ouzu^9SHfy2c^G@?ROug-GM!|C_E{U# zIE9>9<_iKlxP(Q8(|80IIfdhdVhqw6EA<-j^TkW8uM_9lg(pk4HYK})$1IbvY1SnG z$|XR020t@T$b?s0_}C_TIneUA#)_EuUByhrXA~SlSxx(BJg{|9eudc<#`*jMwMRr1<#(|I;f2jk`==!p3?U zD!!rjk9mpuWUct}%S_pCvROv%xA**`ZQqUu2Cr;Me4`Ov^ z-DkX4#XX~h?Dt59Fz)ibI-p0qT|nXqq1c|hc6rvzlxSI z2Cl5>5zx_oBwmnN{VoeW=wzLg2hbxq#|&OeQTb5#blugkz#`e=Xnzpz9K;im7ecOFL5BZ7*CMEV`G=7A1*DIZ1o5O{V@#b ztvo=kWlV_ZK97L}MDL|g~Q9~8h$ZtOmx^if$MXygEpXF755A7iB=VXdg- zujt=DUSzn_=)E**2bVdz{=1(S84)vpD4*8qjZm6VnBi-C+H zM-JOWP}9G)X6Z@k%{bfV?1B!SE9RzGn@+oI z1})UN&mX|hUQCt15UG~m~R-r30?j$aME=#iE!S}!~=W4;rYPQNuTx^)xTLi^6u z6tG0a(r}@?!xolZ6K%>umbQR?JHbNh%65y>i>pmnxn%__dd`zHce?e972||y1MxR6 zR6a}Z*6u^*Mu{VDJtdj~fb;gtxmsDcn@Wssx5hGP=^15MMCv2XoG{W@$0M+|HA`}n z`F<#xSre8uwx&Mmr>0$|DxrX~J_PhhuB8^ztUySy%AzQL6hNOdiP28RpSz_~s3P)! zudW40uX$f0!OnKF{UiMiHl_`7%JAv*Szf) z{d24iD1CO$y7uX*n@8wffYG>E-A%lVy=L#q((F{?25XvqRj_cuA2p!**`EL7D+LYI zPTv!$&Y@HPH$=q7N8IPOReWyZ)te(*Xe++=yq*=_-|=<@36zU~Z2kMdiL0Z-!?L+~ z!AiZ896yppK_2CI=v>n%%a!Ry@Q@l8=wM zb`Rd z3br+Jb!a?g58EQ|`I^RracM`WTnpM&tUHM*spjn{(ZEy%9hSBo`Ura?nt^4jvfMwd z3(*R-Ftgl_5HM%t;zx-0eiLc05_v?>Q?b!2=JTB!c4;+Jhkp|Y?zJF%95b0ZSjb31 zJ@kq63_q~?Poo@ElAaMymj?(|1PG3^Sp$WAkipr~(_@b6sr}b4m8=02t*V;+OCCem znVFY5T4MSchXQ}Qy2Q?-S9EBNgu0j6=PbKMx6?a6OMWYL-VuPE$q7wmU3M(+n7vIl zHg4>S=%rd&WFu}N%VOCR|M$B5tvPcapsHGWlU}~ypOIHS`ugN=1MbgqwEgP1m>yhY zOT*^#BMtISwVw@bj^oyCwi75Mi1GCEE0|jcHST@9vG;yqu#%TzIa>8L<^rwmSy?*!_8g50hlb=FEj1z1|*&U0vx*Y zOU$VG0~vc#7cXptz(5huMbmq+quv6&S_`c>txTsB>K-`t%_PMuH7Xd4L5}zKL*oqsODvc+V_Rkv1nE2GN2nD zI&1IMu}>HTRQpOw0Z1JWFqq)=JF|@V6;2Av(*OaPjjRwerP@QoxPVV2#-|m{U71IA zvKDsUEICg`*b`=1Gbhlp{QxRY=znvHoy8?3gy|X`LSUKFL=BBSRo&{*Uz+TYtV|FBGG^w> zM7vflCQ9?k?>!mw4Ae~ZY{lt`*`huL{_Qh|KFI_9H=o^Pd(|9tqvCNVwLak+4n~K4 zSV2GmL@k@V22h<;HQPVl#oONpIF{4olN!(HX_v*BblEuSi%ScB9+dz4)s>XHGtQ?i z1-`H+cPSiPf4>}kWl+c9N3Lv@e<>96TA=o2!PgyfP#EM+bzm=HH2 z$R6~cintwr{PkprZSI=PCg>O<_1?w>w3NX+VlT&2p^%aZ*Iq&X=Gw&m?1jw%MJWb@ zXtzzrH$Vew;;n|R%zyHv>~sSxK&C|%1iz&VU+2LH%mdF-uKrD+KTfkoJG`JEC-*T@uWPspNnm1_N#?j%!{DNCiEg$cJ6AB% zIxZrC@-X1N7v;GoWH-rU*>5BsWy%P{bfii#P{I7&Q;5zRS`GP#L^GAr&bvf^AOe?t z^I2{U;100{?4fIxx7bzD0as38dnhT*JjM_9VxQD0I{Q(MXP~Wa*j7QS2Z+=zywCFM za0rv7lH zAq8D}eJ(CUj<`D)h2_=eY*FA*Rb1zKf9282U%6ov$d}OmH zd3w7Mjy0nsU7P^DKu(!0tklXNasziFKfDW>hUiN+>$n_8zes+W-yD6pd)34?)W#P2ZPgq-+h+)Q$$fM}~1vEkv(M zE4I2a_SX~a)1WYars4aY()^zmK`a>k4qKUUS?!?lvy8mGq}zhe?JE4+4e?hWiu~@R z3{juIqaEPGb_r6_>h|5B0ZM<=bbD<(^yNM4Ed1Lg%LlUTdb;sYcXEzemXS?UOsjU# z(p35fpFFztmucFOy%Fq%gWhR%(IQ=W`nnyMXT5KnpuzF?c!>D#u4_HN3X4geLLz|L zJ_G1t-v}%VgLUJPL?~5Of(7SBjop3n#5t6qDm0O?!&oBoF`91h|MTtvsAX#@Re5GT zU*PPMWl&)@*;dx8wLcMJJIOU|>#ivfG6qau`zG62Slt2A*%G%2w*$Lfi!MnWCls9ENVPtD*3tJIP5V0n5 z2eVA=M{Th)%Wv6eCDKzJSpx2#e#)nO51yau+6d{Rc#Q@`qg=WIw|a;TwlP~mAG;QY zQPBI0EW$Jw({NDNHla#MG*PtBn$Q}B_Gg1OE%HO&j4(R1d36EIR_z;fEzSIh(?7v> zqHP#B`%@-uuXd%-Ym+ZVK;%X`e?N~@6ak?ZxAr}`DQPo_s8#rdn{z2o_hAFK;OVF~ zc6NEdv;|4`NN>F6n7TOn@#vpNXc45(XSNZT>}D8^EP@%fz^waQ=lt1648c1D zQ=O!omyZva9M1@oeMKky5)F`IsTajE~stBO`8-Ky)? z{O@rdgMr-s_72-)J7gd6zs# zKneUiYwWJ)Sv>znii1VCnJZ-pT1#U^_OwFcP-wSbU^7*4#Q z?6J8n9@;OS{-n=gkOFFEl7(f(pdh7=)7bH5`0?B4uU3XSPa8Sc3K*70}_gSA7k0Bi??%{}rqlthOA?j)PIKtE>G z_tx~kDADboN33@z$jg~PKUUO{q|~U`N3kbM9lxQ9<`0wo(GR#2?-T~5VsAWRsnBGk zjqC5dg{l#lCo0HI-ydKn|*7Ma0$SP?Aukfd5EnkES*<)VpDh@ky zyZ+fb8=e=l3CNmsVZeubnX_@x>q)rd*)!)8{mIWO?`;S5_0v0&H3kQ3<9IT`tJY-z z!g3=48;*~&Ge_Zizke?et`X?nsW-o=r}hzW#% z&%U^>Lo*hVqwankT@F37rc$I=_)g+RJjfp|^8pWk3i<%Q$0oV}XNL>}Yf+QJjqU{X zpwFbJSH*jZISS$rHizV(E8d4rG*D%AsT~)YRY`ZGdS?fw^e(XsQ_t2crmZzXNoU4c z-Mf0-IdL2WJL4`7eFzyDp33dp!@}pG@TO;SXaeaXVP5efgMz{7fPtUAIsB2}Mow=0=0t z=Kfu_zAAgD*+##_Y<*2!1^md2YA>C@=)pNyMs(b8Vnx}3`Dd$y)E0$}JlRP&ob|Y;eJoY7^K{{e!i3)cKbb^1F0H~B@;vRrwkp0);^!FmQeGeLl>k$UJ ztMa(14CX*_u@qwa*WI;!#{T&a?qts3BXJQJK70~$d-B0&+qvSzTa*bu8cAl3Suj3D zQl4KaJp^84X}&_6u^Y%8#0NDzZceY9!WY?!>8bue%FAu`8BbZ+Urw_id*YdrExb`j zX1o#jcPTC@F+Y+BusXwbQnpOy+eTAh-apP)0tM?3sfKHUb7TDWGnHvKq~a?B`>qTZ z<^E0onDRQRHbB@;)AK-T%z8MOt83aQ4qju9FkgWm&CCrv69((^pd9M3bFuBoMC6WI z5DSn1vjk%Bp+iZr-<8$Z1fMPsoCZFiOHU)J-L9-CoowSLt2MftH)3*4n5wF2B@_8! zrxc?#I9{GYq(kSYT#)d0LqRR;O4CeI$OO!(y$S~qAAgeZ!sy4|Pp9oWOcSWf?Yqo! z!x3*h?0V{UGI2z`HWFPSMLkBuGsA$~@PlPI{v*Ei6pp}Bb_$2%L3yyNn80RQL_}CU z`c##f0QaQnLV={a@k|jfBbnHC7QlRfedOYrq(GzyJou^U7|EABcoolp9!T9d$RLm8 zg^htfBU$xjD7!AcNW>M9E*Em4x{S7xH$lf%2krq{lVD?P^6&?#!^UX8m&%C&AJ3%? zW;1)%pFs^F0dCI#rA+`6g!Rdv#!bXV-&3ZQN)rbA2#@pcOls+Ae_r=m^( zwaEj?B9T2aPLx_0w0AS!0hAE_IwLTfwt6440|RB6(sQ5A++@<#Q3rx+o2_Ab@ls~L zm$Bx^GjoNKtaSX>xvO0zK%cN$YLPCsrUmGtNCRMmMMQ;v${lF=B4V5mj=7GB=rm5y zYCL~X=(-x3xO*E`{#FR9Sc&k1kL8_x@!!FpjCm9(#X+iFR^T=Z-f+2z02mB@&e6dt zANZaxm-O^QXYIRjvNE;ir-=KXpM>{^_kK-CxZaix)9qKc_pe{*F|3`sFQjGl;rJ5S zQOvpDTHo#G?jIj6&?$jytf#j{pr{V0))Gf>3Y1^+qkU5fE9A_2!HZU<5eOhiEWHfh zUroq9g&p_H$-Bjg_P`ULTzt4#Xr@J3{!9VUBX4+vJ3j5nt%p*E0s2_`S6`sJ@IHm0 zClZxZ3JISQUmT!Xi)$3{axt)aD~D1!WXK;9c@5_BWdoQS&Z# zneR2b8&V#e&51-EBHA=%yg`EoSz4(eA+aN2L#a6JZ5xm`A7ubh{TP2m)k>EbfYsQQb?!-x9pjX9MUZ+gI7j#~z(c+JD&gG_E06 zci>g+s~*fk#jb5Y$Y?!k_#lH#`ehB0n9=@5lTm1&CHb%F_oICb*__;II5nOkvgm6q z(B{)KGlq+Aqk)ed-Qh@v1Gd6?4&dcZn~AnMSHr!vd1DEYwJ2Jxy)v-d1x!puU*~G1 z4f=Os?GOdFx9{W%vN|2a_Kg4CE)48lfsBAj^XT%40>s7q?!o@ImoD++O@gxzHD|cC zt3ESwIMsvuCb9ep1pNCe_kCca(4i0z?pZBlpEhj6Z-9&U>b8ql@Aj_RNP&hTC{GEX zhLhG-nDx-4QBgQ>frriEEyIHFt*jg@YTjrz51<;n90W6eU?SbD*EJ|T$9yc;L=8<}(d}(Z@ zsct0^ykDwkLEsD43+r|Hb)EHV>p(g-KFUZHXQC=v0ly+?2>&}C-L>e^tlJm6kjufnW_r>x7- zsG2{iX!T})>hu4p0w}Pc9&SVm z-EtJaoMpXCZt`7hfIEgpJkFyPOVbuGbrxQ-6FfviD0W`H90jWrow|Hg;(j>}?h-pk zH_~B3=+Zmw^?ubG2>)=Xr)3CwVW#lR+_Czh4)Zj&R;KOM@^k6~*Pin8s>>_3ei*^8 z%VaSA20^Cfd*lBU!5a=$Fqi-Gp@qYpwiU&iU!63dRjTQb6rM$uo5+&@?lLbLp8DIpYYGmni~#jiW+Qx(@Yd#TdSAJko(sf5CE3yLHyOIq)&cq zru7WN4KXtm3Dy&T6L0@j_qT5lF(Vr0lWC`Cv~#wl+`d2EG#1uP~ym6_ly4C24?Ufx8yB64BUPNd+)tR7M=&M!6V8C zVwr$n*|vW=*2w?MBX+6$K&`)ho_YU7mKA|aQ7mp89#;&4bZJgINB_AjV$6x~3l}@* zQ;#Y=_-iQn<#_&jpFg}_y4<1mXF6}PWBI_Nvrqr^F=4x3inxiRoyOVuZoJ!R4P0gf zL^n{yg;((+f)?b`%!lW=4l$#Km%Kq66VlA!3vO|!rewV-2qH|RD#m&PM|YtXk@yX` z?tM(4zfLNYPOmZHqYL)s8!@3}8!_CGMX+==9EMK%jXGqA!P|6oHGtAL5)=YYfw*-V zQNCYVPm`pU9xWni+Y2Cq*b*^*r0U*#gPErj#|QAAhq`q0bp)n<^xtBxXkkFC>1?&q zqkuud1c1fv@&*#B`QJ_bPUcVh@2>|mGi@qN=02UX4dmS>QOk%C|0>|*vT;5HEo<4h zlWeotK#h`)0tj32;CN68*IPvJQ7M*R6>I(&+am} zLaN3Y=qQ(;!bxhcM*DVxXxb5mG?{L&DCZj2g5A;-!4@yhcJE?+rU!wvN8T9Jgv!ux zX9_|s5|9`Eau2}zl#U#;$b2}6b&uJVADUw0ll8HT2)Z^8GgUJikDRNZoDO!ewJ9sy z0HaB@Zy6!xN#Ae4f6gF|8|XQ7pVx2k`c#q9=HDfz*!mLa_7tH$dM5SY*&YT903XON zIOl9ftWe|Y;0?fV;a6@bKbJtgxmmgATYIkL&zS>l*7-e?181{yG&`tw z9RbXhF+sh#qdkSWx%I%kj&UY_Uo-LRf&cqMZGqbC+gf+S1V;@E$?4E+r+hLW!}XCM zJ3J9WtM{%{*eQ(43YgjcoXIy%&hl{7MQT9s{SVW*|vH)*->%{orv~u}W7U8BGohr%L2B2i9D~Zhp$T8l<<8*7fHqN#7d@0dpl_4cs#F*cm?} za*yIt0IQI*AH;23c*3D71H}Gh-`A+#bAorp7&=cGKc1PY@KQuu0YY$}$5Yv0FMbA>K(HVpl~d2q6OViLU!`iVSSf3%{WBMi$J>u~ z0x=9Y5v$Pe9ce{a{uy(zo*6}ZXi7KhKbU=rvhO_wQ6c%7wf{AG7%1J%$m7lL>bUb; ztMc-673)CL=IdlVr&DU-SrevJ8SGaD<6-{3-#p@4O z*UDR_7rG+=B8<#fV&byqmx+F?qGD!3<(T(jkYwTb$u-#7JP{=dnRDjnytXgCf1bwR zckjwGPYcQ6XX1Vx0v&)WKDu*_p$&0&vr}$eyUJ%?FqUvR3Tzus-L}^I{#$~__LBHx z;Z^F__hznMn)bn7>PAKUtE96k_^yX&w}QYK=w`+x()9s`4d!IF#b78ZTxBt?uerZejU;?T&%Qa#4FgGDV8@pdA;AEIJF`l#bKJbOxZ zjX#bSLW1cpE(FRkBhFV~o9okEI-;AJ8uG9T2czX5hhpFT*yy03gaT-7|2(v{6?XFd zv(vzCF+F8hPRM)zi}?M2I+7nB%xmJcI&bq&LO)Sbco2{!ihQ@Kf~sBtWg%Hz-f#*D zOaPNDUGh8-P~l){k@`=85lkZQdZd!_)|4TV;GxM)_3ed=|MR1WVNg^ww435mjRo{c zG>>o3=iT}E;_{-%ayOsSwQf`i01LOCocFwZ9PQ`oPy}X``xm{?)JF`cKKtA)--2js zQx9gYsXjz)3s=!dCF$fn9r*NGk?A;1U7QEIwr~ncO6M*ScFmXFpn1OKNxcwmPMCqy z9u5+4mYhrCme49Kky^5FoKoUIA@DFrW*G|2(C39gk5~&;xu7|B5g?<}YqYxo9yAr(!td8$pKA!I4d_MRDW#{%Lh)EJepgIqvq+wPgGEgzP zef{D$uC(j_x;wsI);mc6Q~bOxr;)MyFTKRw6SI&tLf1Fr+~ZWXob-*+1f59U8|2Qd zMf6ug|EbFfg;54$38M^(Y3a!jLs`zR%AjAL*;O`NWE)48*mKMNGTJ1X=$H>HkhpWC z73va(YWfYIXA)KIeh>u+lu_shuUMWNdumCxyka@Rr)`DG5=9_>!-i@f%LA|(=X;4!OIV?tjil~RKklSqt;pLZ#H9DnmExSOP{njKP zsw5KI=cttKvTic69J(F-E+$Qt2i6#~_FRb)WeT|21N#?UIS&8Ws{3y}^7oSEYzUol z;-&30rgytWmzlqzKtOT~rnFm$RGvjLEkIUyFgbBXXL*9att7V%H~i1Z|M5;6Xu}PW z=}MBZ@h@dl>@dl~g(jfb!r@|N$$pWUM?c1@Ds$?!VckLclL^f6dX0fnR4G|d#&AjP zOw`wC8E@g3N_gUEgPw4|^Ulayusfb#0l~h=5t%G`)ZOr?NuY1>h)dK7_KlNf8|`2M zxD_&Y>ZF{TCUr%;+in9*Js=XLcdTh@>IjB^=wJR(KaZK%E3s~nW%o(@n%$$@{_0Y5 z;t*DOek6Ig7OZFt6P9qfN5aMCJkkf9s$rQ2s@IX~zedd_5}Wj{frFbfdkWuYN%n<3 zgun@3BR=)*Ncq2iBnpNkRNceg@6FmXo;P-tK={-f$9Y497>moXv&(2lJP$2Q$TXuQ zS5-}sE1kcC&sSC~rWHAwYzim1NMhRsm8;d_Od^G5)x%FbS~uDd(Fa|}E(@8k$>QXa zptdDhxelndTA=RcjI2jb{H53U`F{TP>M=85swy6Kq}t!h5sqpna^nCdb$iO* z*~Y4`7tT-nT7~&b0$Hwn<1=7nCD(a(| zrtP`bUhtoeGZttS?#r|^z+2^-=|-7WXC_CE6|^Rh>TYaBg*fRba?!sM{d)bWt9RE2 zJK|$u45AYpdl0c0FeV%*`f>D?CWJR>}v^ zg~d*LV)vfWy|0pk85<|lci!5VacfqsTXhkc>7tvcv%3Jjb8gYD?B@AiXaze)+9UbR zs_m4`uu;kgZEy|-i>djc+cDTS5d0*HnGG2~2l+KURx$&`G4D(ww6as}s0Ly;UYW>P zk{uWqwje9E`|uuT@*pkBtC(fz1viFX@S5#LhdQ?A$?HOGR8*)}y*9%jYE@IEadEiI zN)Th?&k-=MLSRUJi6b-(gT13ED|+HOn>N!D+0o~|T4u(!hb zBwXg!hM*`znLQk;&bS+J!M^JKx#^q_Hg?3**#g%)b4xrNg^%pr$+j~|r`Rb0L=H>Y z_XAirn)9Q^PYE|@R|qtyv9kF(?_T>9nZCJR?aABs)yANIwaj5Q$!QpJF>`e2&=Yp3 zy`te^5RA0F7iL}QS+ap~EEuz? zp|-)BpUZv4)7)?1YbAU~Xj&0(Ij<6Jtdn6XKCuG!1g}c$1iHb#()v^?zspn{2jwzf z(ulK+Dw0ZM`2HdF5}z-?{+(Z7dX@I&`Frj9d2XdCUr0SVJv zQ1^26#my+2G}`Ab7P~E5@2|V6c1^|B!|v?_W%U5#n`C-|q<%H|8&m!DY0cd9lh@@f z>*iCX40Z#(nTf&_FJ5zQC;=S!bZh_~Ofd;y6Q*m8M>gT@ExPtaWUcyG!kktud2Vpc z7n!arstr+LzDC)9ZqnxL4)dveYYPPabLrUilcSEG!K_pZ`5ZSwxpgs!l}!k9V)kG8 zbTJM0?rueaDdWv_i4}5U@#NmUhGJsGYXb`49FhfZlT4xAlnf;E-Tmp{L!LM*j#;21 zoIi)Ya;cg&zM8>KS};+`&@;A3@)O+| zcLS$F-Kok$H=$@7_K~$_xjuf$eetCz)Nwu#TjUCO$q-^JbUiFnFX*$beM}&}3Y*Z) zJZ(KKw2QgZgI)o_+KX8Sg3II&S#)NaUX*xVSX-(k>aY-C@)sdd$x?i~62xvTJLK z>eTC36Ydzjl))3t;_K2ZQjCsqBCJ_4S(Ghl_5Fauhl9tzu?YC8r9&Tv*Ir#W|)U)qU=z3|=gUI^6nactUtoP(?w4D$2N)s{G#q$Owr->BoF>KIVsy~%jKOby?)hf%teVUw!R0sF_+YdMg&Q9AqCR; znTcS}8O5%HdE-twm>$8I^P&D}>&{zta$}Nj1qE6OkAz2^8i6&p1{+t$pj4%Qj@r6d zMdu!`vOrKQ>da_O$mGhdUvy*Y%rP^OgUuQ1hr|hIQ?C+EZE$Xa40F<%tdq5WgD!Uu zgR}94hI8O~HcT(Gv?W(gyQ#iGa4Ppq`w*^E=y6ktP>$p^MyErUnO*5yOP!FMlf@9@ zGWWo7IQ;g$hRE^>KYD`WixG_inmcan4t4fX%}zGwfd#D6$ptq>_)6D4f*n_lt%bdKS>mkM;jOG6J=@5y4e;O6AvN9X0LbJ1xLHj2VhNiDIwpMD z;s@-tb~eP*%S;|?fLx&F9Zm`n zubKJd2`vzGw;pBY_3jk2!akC6LK<8wDqAjt;i2z2nYfm-pVWP|=#i;}7J`tgQd2me z8MP;!ugkzU7T@-~Z0fd_dWuzDbC7S2i`iH6iOnTXN6U$Zp|7}973}WucOv7?&TCPj z>s=bTcvt7=eT8H8Z2ix9Cidhi@2enRXQ(g@lUEgO6;_Xr(AAoEnUGc+u9p{JI7B-( z?ln^BzurAC?p@O}R6gJ2e_OCmtwD{35C-n&18HF?C!eadSL$IgLL9f*7>N6}>>7wS zFxN}SVuT&7#@g9(wqGOo80G^yp^IUvaJ~ z0V1ypqkWKyXxd|8d6SA7kuy3&(L&Zip#yZGhJUnV z%~10u8KK@7@Q${t-0=$#LcJG(xEy{zww}yRmJQ}*sB4H=cWyJ|%3-^RL?;pFrL2Bs zwDb~6(3_CREaKHh;#p4-r7Xx*U_TT6InmX`dFX}S8H&ucuD(sfKRU7+46K@E1v+q1 zIN83~02D*4pePc$N#8iwraT(p(YpZQ*7baEeJBMG#f(T=cfs^RZwcxa14!eSoN#x& zXIE)jRGB;oJJBJLXG}tEk(GCz9OoQc&OOJER$|cQXv*=okS`y)Q&puga_w+Up7>z{ zw1CQJ(E3p!h7(q;qEjV6Umh%;R!q9CxJM&Bz&ur%a4&COZe5%pYW8LvvIyoSd+{a5 zlh^*w`v+!71?)CG}ke|bgAh$g}n6#00}TJpr@v&?6-)Cl4z(eba>W}ir?z=D*gJExjf<4foS)2V~v zv26P{rdrOW?G^H;CEx}Jz}c2r7EloFMYfnK9m28{Q{8ZOaQAxdP;8&aDeBMh3h(kZ z=rB@)RzhGo^k0ha?!msexs3DNleuNX*=qd-ZmNnzU2gEovOEL7b7ICH0D z?5QGKL^S#6*(W6u7i>*AN>7KFHTHF+X%}`5QG3ucQXNR1@CZ=fz((@jmb}&2G6H3XeTZ_lNoui zHnvA_SVd~fqa+#4DZ9L^9CA}%)x+=tuV(5PAzEOy*~m#Ffuy{Tf;=#c zorIspUFis}PiLIzn`BR{V}JX4ZlBFWACj|y-{L$gSMnMQeM&VWiRSj&_H7vA$1Lr5 zLg87A8f%|_#(^pqT@H?V3NCNiTh!`1M-u{oqw_C5tWV>s_&u3o8`Z0NaM$C)g1msR z8?=sAO)UQ38+HX6lnaq4e%a$qw&DSa1oxc)mFOw8`$~vXwIJRs`sn!5Kow7q8&m_9 zNFpk81g(z4VSbm3L`VC@v9-re%3+K8z3ENwMA6Ia$H)(YO`8wtUWnMyW#r|C-A>b4 zN?Jl_Nu~CH-icP(6FuV7=!zy$R2*C02Q_Zm z%BvX|6w?P8s9~Yfi*)zO?^ET(-#wG7t5KgDLp4tIRqUF$022K&g|9xQC8JM-u(H|L z+^Ct`Ksy|paTIm#Jq4T*dEKBu@=s{)m-rK}hTS$t+)RVoko^{q`}r}E=;2+&3FT9y zgM#O&ug5`Tul@%Ock6>${({j|^=H8&t@r0ltj8NFjzkj|vsKyJ666l({7-{i~6K550 zp~R(GrYYh?GJ;aJT(F>Ega7(T)eVn&<@Eyf)V1O0tI3@zcbWiUG6U80oeMkoifKj< zCh~Bgbbu!o$PCN|_54_jNA_n?z>zPj4YVbK$d8Ydh)FPd@xmo-T^ow~g=u$+(M-*& zxY;usoQSQ+FYSq7!$7EVW!9@S&Q5tj`@ytz^dTWAc>C)+E0HXD5gqU!250$enC~S? z#>O#=qPVIx4?A~CZltQvcV62N33?#$k!l|pws`4_QtrMw`!bH2=7z+^*L8CO2VI;M z`r2XcDe?{M$JI1z1PUvgY?qn}13_XhqG8H&x50ZY3?AE%4fc`PF-XdA6ph-wmIjZm z`Z{Fx8oe!}!X(~QBw)2`Zl#)p)H`~mj};O6sz7rd*Bt=tX2)jFuD1Qtfzg$tF-xrw zmSZXw7x2X5Q%t?QS&4@YmdL1oseI7M^|{G7#1TH@Z;|P0FSMU|H@`P3cC8Rr8jZ#& zT;AYR3N|WI-vMVaNF7(hK}Uq!`8-s z4FQF93Gc8Celur>Rs%TomKTK*z%bPYI=Sa}IWrFYhPnk6-*pXhtl`XU@5?|OY=)54 z*db8<%M!QWs)-moA_k$F>3)Paf_wcmxH~kZXIM7A52mH)JOMYGL{;_>-dwqYF`2IH zsM-w5)x0h*Im|Oyy>^pQ`J48SmFI|aCPt#-jAkE62QlPNss|FP@pR zN0>j4^j4-;f-RLq0<)-qjB?F{R?{Nu_4GqoOrGKd(y1CmcI{k`T3kpPlp)eDkQu86`kFh=!;nrK2IAhkGtja+H0D~V@wRI_| zPczC0a;|0ntoU4Q%}?&I_Ov7Y$wZT9ZAZx%3Z=f%IKAM>0mO(@)oLwi>Z2`JGcIqo z+Tf)Hjkdha?t%uga@%ai4Ox-tyutGKMwPbyg%fFowU7Wb>G)X);}VL-ia-Z5b?#+` zcpq-?|M7L*@l>$wKO#rMK~^?N_R7lMBby|9hRj3umT_!lmMtLPSKiW0gI! z*Y7^h`##V6jQ96`KK?ij4$isn>$<+zcc`9gr{#n^a^GA#ZU@l|#4D;58Rhubj~@sX zao@k@&cSM=!{B(!svzNB7^ESv`<~=%v#`n6Y-jqoZbNnXbhSwJ`Q*3Dl#8v) z;^hKE!6|i~tn#KDlbU#JfAvhK`nqEPF>_2;)gUU|+xrTs4gn}=ZLe{DM)JjX)hBQb z`2F2O?~@+axtL!#Vu}AJ0N`)bo4b6$b%SnT3E{S_cTGXmPa;TaLPX2y>h7NgdRlP26*v(TK9gOtSnawT zobi>i*UGn_+z(vKAEJ!O3Be$NT+a*2qkjU`(z;+7iV_bRR3TT7A_D zDEnJzqlCPAsT^|vr8 z`kT?*5~;POlST{A91V8ry=G4ghvMujISNoAv8q^dQdrtp?dSQ^sIi8yg+{k|KZN6| z(Yl^P%S*R!+}-o!yL53IH6z|@l3Qu<8oL9JJi5pcGnNPgi7!7FDXMtpyg z?hPXj#n$dZ9ddBQK_Y(p%HWI3*xb?{?pSNO|(tVXX*w07Ym zNKNj=6WS>yk`~TZ zdZDRm6&B(Hnufzb@K7hEUlyiRAtoDA7xV4H>nhVUAA)8gYQ1{{| zIcypgu^?tHID89O5{d%%FMd1X19Z!F_Q7>C_>qAfbHq0FP5 z)|3ssJvN0fuwxO}T}_JE;iT}VeX)*>M^*>+!%V_sJ!A;!PF@F5skxUPn9j@IbNG0x ziSiD1IJx-r1Yus^fu(U)df}H8aC`p>sa(2tcR_AuT-Ic706BEA;T*V^7qY!%K#XTK zA0AX7fI44JclI;ZG);G?jI?i39bu<^1Q>>k6!AniK3rRA<;-9jND6}f>{Q4;0lE_H zgux@f8Hr17rkfG;RAXhYYXC%F5A^tDK^S%}fjfYMAuQaHf*^hiaejP_N3Ii(S9o>s z*2c~G{v=K6^}0<4=qHNMBewkzGZUWSW&zY3JH~_QI zCYo)B_FE>$S}?epXkn27yD}lqvE5yV4n4G4&GyX%D$=9o>sOE3LU&SqfF#GC)ENs0 zCaWnls6BRXx1C#XxFW>Vgcj zHT9G?P3u}Y{}i{rY$$0Q`Z^O|iq{$ASbI^)@5C>m4w4F+!20}Kbew!n$t?1&gJjg8 zU5gWBaa8)LQE@soYx2qMAY0b<8}P^!z6KNY}25B0IIFi(XKs@zuZ$Y!k1phP^#YT1XM% zDrjFmR;xFxT@s1w(5uYeHSFii_+Y57U+WsD6HsahpKK_Mdr)665OK62cwqQ50M1U3 z>iTX`EWq;8LsCM$AlWs#<6h`_LU%>%-p#3YK?(A$M=O48s=T$X1K5%UHN}mSJZ zKqe-(SF?HFDFf>QbWA6Q#?i@fhv$IQztJK)=Wo&62iY3h+Z5c|x5(YduVEFUx^qCX zMZRY<7`9+B|2+Hkgq~1YLIA`$zRXwH^poI{&=T1&TQw((L$3yF?U7%j^PbMn`tiV- z0HrrC_h4y_E_Ie|&f{H9I|0ReN66kC@>7I4`rc(9%shIYysNX`D6W|C?KAC4LHhOd zm6Vk%751eR^5!(rm5Rorlog}milvNhjV#hWHwejD{-$Vq{ah`tqs|g%t=}lVp42YctWYzMF^Vi}Mv71a5xMVE{2Y*@}TBM*jaV09;CzNi)^Wm^j+r zwt5z8w}UYjXj7z|lmV!>fR^I6@X+EdeL@$4KR$98NZ_Vkc0I=qz225Pqrk_w0r(mF z-e|OX2Hc~L$s;*ZfrIscvB!67lYV5@SH$n{04a&!q#Qkth9tVmBTBNnD>j_WGGPg- ztW4RU9yO6K&M_&_cI{cX0>hIgGY5|55TzT3H-L!o!5xG2LKls+ow|MuExJy7U^9^> zA`X&ZJpsGZH~2MLEf=U137vdwleq+C#O=aK0a}*#=rotc**RKgqEsL-^BwI@%UEDi z>x~|VqPSD2ywfH88_=PSC7})>QtG@2VYyroH*1`r*MqkoR7b|`o4AFaiaX2TbrbI{ zcFRr;MaQ@);vDP*M>gsf;wZV{E%Z(YKzHnm;2(ZE(^x+V+-3Yl9Q?x}cOR5EGM!km zxRy$3!aJP2mmT|5PFT%p+J~J$EaJARPv_n@L+9gz=SP$%wJKArS}1^6p*=%g1eZ@s0z5vCmX{7@q%W)dnpQhlJD?ND_lA zuhpgLQ}2JytMx{O18)pZw50OA=>$fIJ?l_w30CxaYlQ1f{?2Oj-j(}6T5<;L{hJ^b zM|UN-Ijr-Wk4%$K@@BOk0d=C?Luk1gh=krBW1mcgXCF{f`RN?To<7~qUVT4rG?Q|V zD0A`hX}Ph0T@tpm>WREVj5r#!B3G4lcp>KEEPc*oq7Wz_!zp-Cs8|}d!z;Lo^Fnx{ zMBwBQP`=mDsx)q5129a){8R zU3kdT<(&1{1^=z%Ui4ms3mfgT&KY_QzDZI=4}@yHgFoOqnkM$;Sh2 zflNM#x6_J9(>GeBO*o+JRx_$YT6i#A=pMOnIrmkE5q1IYe|=1l3q+Pq6marhp09xK z%?)UiYgaxCB#VK%#l1;x@rILtTKJ1wG*abxb|Y`pUd#@}gAv~C9(f{vZ=ezvW;a=d zJC2~eRg7r1(-><#e0$UOV-83+ih_y+v0T&8cYH;(gvRFx9>9~V6Mr+WsN z-fmbv-Ni$C-fzv2p(roU)I)us)|2PHnTpGS^PeaD*OM3B2?nGHk!EwNOu(_9d}1*# zUIfGppV0|ZuiRY!{2l)NaqwFODGQidS=U;9BibpfTyqLI;iAYvNb|e*t0Ji?CV#rd z(7i1$iBwPs_R3=^>Rc=`_gD}G77)O@4@_GaJ-#*nacvP{vgVfRj}$9?$t#5FODA*~ zsN7~qju579rvtX(J9+#FQJMRY8w|Vc$NF+OJG`OqAXJ8{Oy5Uvs*hynu4CkmLv29c z5<_k(eebrQL?bn@_WrmKC)xtGVtY7ij$q1~!a3jRv=|zSV?u>^7-Lj5F zqUu^|#n6$avjdKSct5{f{&cI#1v4SP@M&|aOlcoGnPMn}f42j=iH^-Wmk6XFDYD0U zuB{N5PspH4O11wS{uMZB(ukh!+|ZJ2*9=Tzpzsg7^hN{XR!!J}OHMz(c9K&yI)g~V z*-MK}FA3#-eqGY|>sXRO6CB5>_d zCkpyf6;~`=c)_uRI>xf#hPguM@X?R#hUWqnX7Kx!UtDiNK{Ra^v+(PE zW6i6l(RGhK<8;o&^E=2S;cH*W%%mk{^`Yjv61SpH1-H=rk0vc&x>-u97a(n#enDkfl#;Hw}ctCSoI%6|f)rSoF|%++g^G zI=xolWaE9M(MRV?+N@)O7#FomSC@_gBZSrD5|4K-i~bl#fA2z4B3gl~cQ!ZaI5TJcuLb(DWnJzJYP-K)5n7r7?D81+&A}{h zb1}%Xf_AMfNWzdp>1c|+5l6`pr|a)t0A_NpUF0bSZea$Y_q+pfVraKz%G|o~1u(;I z0xOmmKiMIK$oBgTswU~Qz@^X^G_ib`k_<-UWNU$KgoeXtcMVIHmcgcDu+vJs8HJZc z6qt9;uuWkIY_agVa8E)68D~`Q z+WN4)0pgi|o`#V+2NQ)j#nkFyvB@QkaYfvZQ9q`?Nsh9ds&-6r8xgT^`Bj*t z^{D0?tq_k+etenl+!vKS;%EQV0dI$B5Nt6v!<5h~)k9FAd>Hu4ad~8Ized3sHi4N? z67K__<4mSu-NF-)>F)gmTXz1{Q=HHhTJsJi zmzRQ(U*482=o-L9yA-l^J7L>6A6;WS&`J>TF?O-;SgIAYUxv`LADY~lJ=NZuQ}rg0 zMBXn4j#xfAgKp4^Nzf6|WyLTO-nf%PB&KX$; z^7K%p{T0{KM{wE6*DMJQ*Ai7qnx9IzBgdf-7d7cn26s-meCpr@u!N{7J)IBNq+OE! zYuPqKGPHhBxmZDi0*S9KzGh!68i4RYF&4%Dbrhk&Z)K&ngatAiYM7UdottB84!~xl z?oGVJ1Or*>NlM$v*dLS1?*kJDcQ9apoqA>-1xy)$74mP^_nGb-f4v<3dRMrs&~MSC zH}uM7Mk5QZm&zxumNcw!(~z-PwaME9x7Pxyd$tMaoV#^an&{u3=-(}rR2hjGuM3&= zCBQ)Nh7BC6N2h>3>fzkmtH1wb!G4%%-^AtH7JPlD>p~hFT+9K9J_po%0?spH++Xzi z2}5iE;Xz&D2lf!9J*#<{?i6q-aszS^ZpZ~Fn%*$JPW7nopp31f1Ik0r61duLvp!em za0(65j!MLjrXZsW?WzI7MiwLr^c`zuwQ)@+XCTo|#{{c5O^IMhy6*G!$% zEeiJcle4|SrfsR>h5{o<(~g$20|cW6YydrWPgxZ@VE}|n+UIp)^DD^)RtEN~FL@pGqzc_CBa1O?o^O{*kf z_))PnG||3cZpD7QapN%DOIBD9l#nqBy*vg?#lx2<6Ue*43=w{>L&Neu)}dxh4N~e- z02EUa3CWGx$`*8qyaevvx=%6;fg$Aeavb;=x}m|Y&zolKJppE0WOb8Q%hf#mLiWIb zVAtfMB{Z33sR0saKaf+ZMt*=1?t*rtYsTNd97G_?Bahbwk^_=capb;RnCqQzI@Txg z3Vyejv~zi%V8hD$u2Jx{&;ijQa7(1dGh!07pA@&_X>sVb4MjnJedrPxjr0BW0E^kq z4H;8Kq>}-1J%fd^Xn3;>K6o#QSzd2%=yPka{5k|%U`bdVEWQ{$QodJ8{PsjxMAbNg zN^c-J{Warux8wz{+ojCZlpAfegL?4gW2--k*uNiWremSQB|Sk5r1i@=$`jy3kpN45 z{(I;Bx6|>jKT3UNOgN0wS`pheQ)s{`VH)Ux>vm;$RSy z)&Sl<1HhtFJdyKT!P2SntN-;B_a0&bJfuXxw0lWnK9pptVXfRSfsH#Y6L2hFh3#J# z`}x)R&F*|{Eva))cWFypv5?wozE!JtTD>J14R0KH(6a+F8r^%gM;7@Y1gjBYoRxbM4p1P!0H z5AcAb$&*>4*l3NKWB8?8esnWW7`+1!QMQ)zgIJy7JArBZb5$A0AWgmLz{sJ{;srn% z8h0|Fa+)q7umOoaKf57|XfEU?u#IsC*0zb{X3y&#`C~B9R)ZgbQ^*v!hu1+$q?Dqc zfTQ;YTQUJk;aAf*G|C%jY^K55om!OTkWzO2QuNn(Qkphj2ytAM4Hkb9N$)-&ex_s` z<~sfYF>HI)mTEKAOrvy8KuK9SaW^Cs*ylZni(C{D2><#`TS3I`LGk@gNlXvDe4;~S zG&zg>qA+=X)X97nv1dQY^~#M`+rN&Jv3yw7YSgB&3**58@`<_@WyunFZQRpzQ0xAzrFu+enNYEyFWE6et!nP7yEMe zTpRRa{9z#Tsc6Rhv*wGx9cU?IqB&99(0OQOT&!~;I{sr^`SkBs!=H=lmwd>Xp>e9< zzV-`~yCrJ|MU%hu^^d>~vj4UZlJrp>fFPetE&cg3etYb$c7=hA%tyYFks`WsFBmHi zlkfMRHW-DaZ2@~%TB))lWu0McUslb>$jCZ>E3emgAf^X0cH-)Q?s4Rp$+&W<(Yse`n7Z?Lcbc$Qpx32G-WqjCE;)h?#6#%rbIA2}euNedfCFIgBYN8qGcAYh`Ny1x z!tiAWU=VjVMt~d zloMtz=`yTeKxN3f6l#_FxA&t3^voYc5mNGjezC!UEf4H{5C@{3#R1X3f5!hVSx6z|8oHoivX zTVv|YweH_-UM9Y&cW_IOqZbXMPVkROVr>HBLu2L=Wg6go_J&?~ECNldSie_95_%ih z1si^muuFtdg&Qpz(a3(db{hj)IVGmP!3w_0$wFqkuOiLV?F-QT=;uQ9m4|BJ&A7qEr3VY(*H!;tV{NB zxr_w=uaXCsN@Pel%z8Bgdpf0tPKkMi8Arj}u9kUUV1etO5ZwbzKetn0i~R}h%Z>eM z_w({qLb17)Sq|acKRVUlFO)xz!$mBZ?#BUY&!N%pSO!#T;(in8l~oO^U>EQ34FRl9 z`%kUz?_Z!u12bOyKwlx@YA|jja@3~muH$dVIG8l772OdMB_cv@jk5NEo;e#gg~f>k z?|Wx3G?wkrvuisHojyQFsz-|5&MG#WAJYcC!DSf4-Wr|*i)_~0ecb=^96f{P5o#j0>q;)*ZK^QXEY^@?dMoE=g?^4Ewm0$ReDql9W1O$;6dTCWAGi z<8XwAb}b4^{8xiak1Ep7bsI-aRm9jHM!?eFtK79=$*0P$aSXdJ!_hyXXXvkZF-qSk^C zJXLnX)ouz5)Q0T_vSNMV(v9rMp>X_eY5H{_rG%&lL`&(GoRfQggp^u7%qcRJP^@n&@Ylvlk zz(79I#p~!E7L@r2hJvrG9G761*(SaN4KiT;0=VX`uH7jo45ha0BZ-!E*qrv9jcr=q zbR#5=Mh=m2WD8f2Mt8iYp|iY95^281%f+ug{7C4#6-i*GjTityi>t=ILCGD<^qVm+ z=dwA?9jKOs1rA1?ZX`CJ&r5FNw0)pSchT4% za_uEXjp$*~Cyb@qrB|LXCp^N5A*t+An*-y>-lax&ft=s|%LiPMnN{3>9|_%6f{sIg z3cPu)o^g;1kf6*Cfywchok>#K|2~Kv^yv0>#@7y?X{;By3;h8iRxds7#w`G|d3QMS zue&%W-alKndO zeq50G*F8XSwMs||!lCts)e(QNpoORDBWO-lMIS0i)Wn=KT)77fT=RpJ5NGHccJ5v~ zrydsbfz)gG1CS)sgJ(`k;uhI~JPnQ98xRrBA1+W$rU+51BDEj=WCMTRP#Yo$xqN7$ zrysY=G~9tRg!qBCSsb5Fq{B95p~cw_E#wU3P|{Uz?0k`0D=g+u%FAe9EU0RnY|jf^ zArF*Kv{Y{1J*u75yt9^dKMOd@Ci7b#gI;n9jCwzunvb8<0#jF;3Af}GYf%W(j{Rg! z*(8|ZX!0}xoL>J<7s4C&VMHQC?;G@U<+bO)>%5}%I8j3acE%=PxP?fwE`Ti^7v8vf z?S>1mdFz8bTM9#L77JE_6gNZXI0P@VQt}RkNWNT;ZJ`TSw;8<1j8*ntf7dJGwhud+ zwCq7P@=Un0fgk)+emT58sb+Qhr4a{)s{Eh8HMnnW zy22m)&*n@(D#)e|olZa{;pZjo0Fnoj^o{=an-(th_4gvx=$He{j9;|_thu4o6ULA6 z&nKvsn*#&KXE<`l_z>6u6>M!ijjYcj{k^LExh(zbv27jJg{iR(XSK`Ae|4E3f9dzv zgMJMgcOYAG7U7?rNW9U3ZPxYyXrsuK;^k{G< z9;m%0HDV(@l)Tu9k0F=ybodw|9%5fZ;E>)UM<$}rAiAtns&AyW2l>PlbTA;g71~i! z#!1NHF!^rR!2@EC%-^Mx_pc;+Zjvy__$ItIX-AyDFVN)#aubdnIRw%9>R@~_b#yuCmB3`fU zxu#*`9P-H^M$M1vrW)#Fa^&4L#8w zqZoMn!Sd!#!Ky&$heJ}MLPziCrZpqzHWa-#nA+*4Gv&;!gPI~d%=)C$8eQ{G=pBI1 z)2)|m4b}TWHim@7r>S`_QoLP3B;F?A&3``PDr~aC{3MNa17k9-Tfnt-W_(O;p{ zKM!s>cEn(6ds}X+#8FVb)u}wo{32mE?2|$Pgvt@D*^qMrNK#gh(mUxF?C8ZFd-}cpYMmw7U)|rlnNd!Gr<1eS zhx5e0KZ6#OD8Few9zO)fRJEo1^FnB%8v1xH}IttWp5^H z*Wn690aKvm0r5j4^ll4yKKTy#?;y$B9=Ja6N8=5~E^XN50L@gE>|03db^h?=^Ghv* zL)~#Jsf9XlPHxue3T1^T1&EGYC8|w@k(>Mgt^kSmGhv3na?tnUcx4)75BJ@AlUnQl zgbymhqc_f*`8D5eQXnsTsmi?ldj%4!QO3j8Q;&n2neWNM9lzCyP~RDSC7LA5#mU{s z_mNATFIFO4TSwvw(;aIbnj@2@b zBbhXZJv^AX#XhQ}UEjzZwD)P+C&XO1HA~CT5nA|^e4Su0^I?dZ;{3@4;%;JTM8BbD zfHBimxspNDU=4HJaa!LkyHrDs;_aI3iM4XI_rsPat-w_JN4GdTpQ=%f+QO4b1}8qE zy9)FIS#y%_14*MFtUOJTnyJfpWFwH?VDXL{6O2HncYdC3wMZ`9`R8!Kjfu7@zw=YV z|HSG)4G9v$GmHF4<)L1vpXNG9!~&Z<{^Huvm;K+GDXC+uUvWCerMI4IG<%M_bl~Gf z@d2l&+Gjt9F@^ro7D>s{^MJ@lRYC2w(I;ZybpP$W|K~rh21z;k=_ICZ1onw)8EzJ* zMy*!1RzKuIrr!bPe=GfwpqJwOFF%wm1Pj;$Wq!KWj`JT3Vi-$1#B#d9-3?5WtTe*& zmSFCpd=zS2c13ABiCA6gUIDRXaG>voBJ?(yx3c)4I_`@84lh|F+nu?WsT%CBWlgm6 zSm3=IfC^i0aeIWY-2iPjy^v)C5U4n@-To{>>G#0Tsgc9WvvXV<^9e-LAHaF?9Vu>= z#0UW@x;zfZ3#6W%A1gykk`l39YwW!R`TkO2vkdZ&&XdfJY;ky(erXTVbllsoNyaLp>tL3ET(bw~GU0d{_@vLLIf+g&DXza+uX;Ke-Lp-`I5*U0Zpivo68w3{GIaXZhlLb`4VtiiT- zh-+h4z-r8&?RB0LTDuuTqURFd@Szl*B%wJV95yR?Hc#kK5_6G#%k()8`v_In7Z-_{ zmqMZZtPgrA3>{6+!Gta*+0LVvYF{j-Q+Q^vAk2KAVESNst<$`tnTDiz>!=w&(1mfJ zF5t&icoCyMg{e-5djzLs%*h+hHp_twkpM9~m=EEy#?w;xSHT(gyO_$DH7!^g#RsGV zc7{S&>+a0?uOHdWH`cIo1!sx-Hh_4ek2zP)2mxy@>AxKTe_}HU4`4cuJ(vc>$d4{# z*!LUDCH6|H{)J=Tx)TiUg$c0jR}bL&3D!vad#fH?B@H5I%fq$Ncd4dT8Q!aCxAo82 zk}VBGtQr6HSmI(fE_4nyf3=E#Aou1gJ0uwBt)94^fDYtO2mOz7i64Ar?aS`8)tRw5 zx+=?jOZvxM@#ki&NC%+y?{ucrxDkM(bo1ux_=e?yOvC>IDA?Y`LW`GF^}d1H6O;a* zT33k$Y)zTC^NH}LD~j&t87E)wtI)h@ZYf)|0QTR5q}M7#z`GpSb!kYtbH$0SGrbMv zQFnkhc7`w)6I$so^5{w7GZ2TqVB?juEcK$X-~wOY{myGJXP43k>~^9IAh~G2Y67iv zG4reJbIFl@udbpLAtm~gu6>;7a!}@m?ABW^cnP`t&e3v2oI5Jj@DKpZpKdE3CDlEE zMn_-GZ|`1N@b?W=PQM; zb#<;i)EUyU6yUlp!0_ke{ z?12{XBXCDHmc9pJ+iB|>M_7ulB+XG`K%Z55E5#zJyeBlK=!B-9eSJC_D6No6vlxji zn0Urv`(z<9UdIBq6Tyy{^~#p8{Hla_u!Qf#>T&RzYC-?0W%e?VQz+S{wG znode~%Z5fgSP~hPz$MwGjbL$Jdi$y&u)+eixB~Wmhx-)6!5bi?ph?Qah27>sU{2Qf z+Y?4u{*;c>Qa+2MT51rD?^Rsi=^L99-)Mpx@Apuxta90?6xTr3fy3*oA|msIKjwws zcfhiYt^5d}gl*$3B#NzYpC?#Ach%z4t&rIz1@D_rC3v6K$RAI>SV% z9LMAaIHdTydplyM%am&X*F^zOlohtjwLxW>fj%>HmZRz=7Nw0-MY%K*!rCsYC~=j{%dxOEuf%Hy(ekl7D}klY+Zg#-!W#Nl*Ur zvgBYDrU=+DOlJnF4S>Sz6f5xUt`a(v4!irmOjmM2$iz~LtK6jj0X|en^c$YpEi)T+ z4gk1H`@YNKb7bxTa9oHnBWQmNaEC}gvQ5Sl^H}*pXb@YsmwMAzbx~_MJ?P_T`Qg$l zWUxZA3YjY`f@H%erhc*ch;ip}8!eyHm}D=@o%?6REYafEEK&17kKh4%zH(o{X>F8J zL41M(5^+RMK=hXwf2a5_*AJCzN*)E4c$ku^`1z@ z*J8Ej2Kq6DyKU0bzP=YbmZ(qv0p-yVu9lDEL7oyLJgfM+~yre&(g@=CU+ieQG<_G{XN$`K` z4l!cj4BcP9w1bR1WIG{6Mb}m{kaee7bx&D1@+{&=>iu9x#$P;HC?r7nKwv<(Gq!R1FSFW$)qQmF+dM)qDk zXt2oKNfY3%k-N-g;p`yB=aNdU4r@dfBF#G_77QIAZKQa8_4-Hgt_3I1;|XBOvryz; zhvv6&pM45}rs%9wYW0l6xtVv#&hpD~VNFhTflzdpX5|~?=6!G z^Dd|OW*8rL;P*9yP4>aVmKJ#3SKC$7!O9F>~!Fs)+*X zn0h@~C)qsaG7B7~D$IXH0V`xkyub_0cf17@)?I1@;NY=e!^jdk-}G#GAaQ8QtCH}U zdC#ohdhs*9m26KzIfSQhU`p9*;1fT{TQ(%m)al^fyN6tk=?MhW#cz9PfiZi%myo|{u$+G5GFe{F1Yh=`8>BFSG+ z61f$||DyMQ_PuO?LR41FqhH-PRu72FVR;Q4F4cEgHLD@p=4k?C{z?D5#qOBNL$veo z@kK6s)BoKKjF4ks#g-Nkd4C7EJv(v8gzcMHBVa;RLY8}dX&yOiF-Q&yK`5GRLetJ) zPzqiZ6D1^M_sjhtVOdLggjB9^tPD)Fy8ar z(K90uR0<2{nL%I`o?sVp98ly#~x+40eslS=2ErGxj-%ZcZ{ zz0Oh7?7;8geNf-QT~WN`w-TCM+eecaF!Z--!a>kh*zAAW(8t}<*vigb0Qh`0j98S6IIE@8aR2nw8^@~wE?BTOiqIBxud%-FP`{KCz!7`B$gD3$V7g>UBU?%Fv=Ax{9^hm{<@PWE5V7JX8=~uLCtUZDh%OALi@w=-w<*#P$@V*~# zpmjLqW+qc?LC+Z=tIA=b(>nVnNQC&uZS-c|wa7z}PsOoZv%V6u}GNK98+gF#-3wsmf ze?wz}PZ)W;cNbNMm->^f(Lj(~&J6DMjdbs_Xs(7HG&j--%;Lp|Vw}#`(x}jm`P1M| zKc}YKBdiRUr5BiO&nWcgW?W1=7F+g-0O-Ps2C&?Ls$19eo9=u#031jImVc1KextpN z&lh8b!~+RVSz1DUdgFPMt;u+PbB@Xor+}r=?vx{Ug(R^*`r>sNan1uhS(%V?T9nV(?xIf;A z)rsZmT*z@ldeT`sZbiCPgBhF%qo5L5MAkUe9- zT%%;5m$TNMN2|nuJYP4V@S)ygB#mni0|BB*8)$O*g#gePqkn5YDsmtxDs>N->AUMu zztzZ=h?8I0y`c^vM%*=4=_KSWxrrlJ698bJ5L?zsGD8QgxhI4GJpcK4e(aX_JUNw& z#KEhRC+UvMlWrw6UFIV3Icga!C`El%3eXuV4K%U$K1;fV*pa>*cUZ&6+N3dMqZAoW*( zTd8{5F=KHuN|yK-q}nY4$7iDif*TYXrSM0=h1NK~2GOaHUu&SVRj`SQCF-v!0l+Gp z+)FJvx3#14>MAx-2YO7)QrYd+QAx5KGxpryN%~4h;fn^aRDE1({RuUy0w>E^4Oy2% zt zlHL%3GBTOOpC5loxJyChZnlLZJSafA^LhO4m@-Rd5|LfZd4=vxno5$FK=o!o;z2xb3nu5;RmfG-p`pEsLLW{4{N{}kc0 zURMRW7fnTMCv<-oP^nouv+50!_Op1iXEKIWX1@VY2Doxk#-+*)v)C^V#^nEs= z+E5aar6ipx5Ko?jOCnkd*7lnq+shqjP&A%s@nA_Dk@A1^dbkeEJ@u71HJ)J%6#$%D zgegCSBIaC^k69&&7@Of7os>6}lR!Q!3D5-UV`b!X$tfbO_H0rQZ_sG-FJI2AuO!@oRbM^Yn7uZ@&ITkDd4Tg+^~Mx=0H_yt$e(?P{y=oc z-IThU^x%_ciSzeetV@88J1Yp=0rxadu($Rp&!K{$G1c>*8iB4r0DoQUn3E2>(>>nQ z(CI{0Bm|a^SV}P@>x}>Lf>fDfTl4ePzEr^^Vw$`G==bPY7z((|xdP^HbSB<`-65LZ zxCWTW!J;@Zj>xWl)gWpdRK*T`Lu8R@)(cOv5Gx`j_FXxOt|;AXV-N%Jc6L6S4=n$gs!2yLoe4$sTmz_yq}?tC6WQG-lmA@w zvBZ}=FbUf&I18`%MSenV0jt^ia*gO`)g}YSzUAkX*uBNsIEK28$_zo3lVUObI}GYr zL5{{>x(I~lf~-WDsIBE&$+bk-4;ozN+w*yh*|wxx6NIf9H3@=svl)yKytx@(ONCD$ zyZ37R20)UsIPep2LQB7eK*E<0@P3`L*v(QFi>L)# zfFti2-5`)E`%N4ilYjtxjQh(IUXPgfGXzLY{-HAYtul`?C7jHDeCe6+F118vQ~+aj zB%pf_5FbX}1(UM=4y)=7paV-*jaN!}#6iHo%Kih1vVv=CwZN4f0cX^y&^k{GPRytuE=Aw2>)j=uQ)Yk0 zILr%{10iNSLG{KiiT5`rYu{6exaO0ysNnv95}midl}`^B@TV7?!1YIg+8&d6E)l&7 zc3=-p=HT*I%g|~k$~O8leIkY_@bj<>TEBAa!|F}HVwsT!h)L3o6$$`;s4yQG;M9zV z%uWL!P?@L_?G`J=5qV)tE*r+_e-4N~u5gIKb4ireHsa?XK%7UraK3U>kyByD#Uy__ zy0ij(wr}6@kZqwgG*s5s2>EvUU8`>0&X+SjYh}Vp)rUmOl@`eyt6u%Q-M7O?h*EEX zxMI3X6gJnw4IYyPVArq%?zMrchZASOon{sLrXxjfT&s?X70*$bE=PIBCH@}jhTXEG z4&4W^+tnV+Z4}nYdl>2z5L1pP$Dq%- zS?88O>=NSk)bBHv$+B5r2;C~6M=^-4tVd`;QYY4M$B5YV6ij7ra|#5wX>|HezEGrn zMKpWE&Mj6M*T_|(y3XDt{Q->KLxX&n@aOnhVjL%XfHDq-p0A^9KH-j9@6%X5;Mjo7 z!nTa924WLIR*%#M?!{*9JDAB(rSn0#qsC@k<*D6|XIR?%X5BMO8uGmNurLoy=0N)j zJGd1Gq^wi`8z8!m0vNL#Q3>O%^ppE_o6tCBb3s~ z;+2`i8ek6XY^`t45Nv7tfx1t=KW>P9W%_C<->1Q6C;e}R$^P}L0Kb7C`7G#?G_^yb znjkBb-F&AKkE^Z~kB`Bp3kS|oGz$W<###a|WAyQ?;^uzhWj-bKPx}{)9X!{gB08$#-@#+||WSfcdCcvdJ z4PeX^4#kIa)}p{HvyNQ*6f{&*Xi*l@LwGRH6!OENZa$m<_Reg?8f+l^ywSkfAvh@a zLv5kUGIei9&ULfk2Jn`Vl==uX0jsu9zbM$1>8&+(wFAO``LXEzhe;37(0#d-AL%0`n2|NqzZ|iM z?Jb?6e-+pAT%bdMqlp==2mzM`@<8w&_1!uS=+5&qe<5B+axDd-Lrk|3vU6>yeUAHy zY>QRQo$1#+6S(beF|4`NoqfX3kA?v#etrb8?7T%8xBz2Hj=&cjZ;gJ=35>djE+oO0 zMN&Z<2c7=b5}sh<@T&-?57jxQkZ6bmG=sWV;?fap&VfUpN*hyuE8aZP({ToD~mMHZ! zpgzOdGyM){vcX?*$-huk5X81n3z$!C5lry?h@!c7FPv5{!)O(Ls0hhKsS z>mS%fFeWA>m0`jSV7b1CtfSj`w4l_yBPYIY0YktI)>HjEA9Tf1r9OsyK3N#&;!4?l zj-LMK1HD&ZidV4A%SLc2^?qPovIf&mApo$`jaPGnR%{#%-JTXMI0qV5KV7LI9$UFel*9w&u}-u+bNodq}^#A+deb}8q9DG zEQ*HlHp0Bnnhow%AT3(4l52#%za{Kqwry}ASe>T-JveX=ZaWS{{)sn)Q27qL@|TcM5Or@fmmIJQ;_tlM zdVxB!L8|jcd=;#7{wTQ;sC+(x%~Wnu?bA$~HoeYC=-7?$o@KCIUIPsw*C5L#`Q`cS z<;MBJ&#x>@aiKXxEf&`bfqtUIfv6Sqohx_LGk&0zKHNN{Q$&yM1GDNz`a9M+rum(3 zwk6$Hbxq6ZJA=*iY}bH0;eH-mI_WtgMMBXJ68Qb1{P_~e4*?X^y?2&|!O)|<}$&AQIAsN|z$9X@`{XBGk zpWo}%ALlDv7uWeYKcC}xAMdd%DnK8w_bbFs1b9XGMlCV6J)Cx5W!a}M1iMbhZ zTNsFKe%c|tM5o;RkjReVa6H;~*K>-=;@gV=5x-r&iZ7S^T5>?qsK=fWba;E0=~V?l z=T<&4A?4J@dL`S8-Dn4&6Rf`t@?A(VrzxD|FQ5oFJGsG~CWmiFNq@)Ani}(m0EN61 zRs2U$uiH1ie$?5Y*A&cS^SYfvAI0*|B1CZtV9%a=J>8l2gx@0w&i;ynT7x5- z&#$aG*9V!&w#hMx)e2ooEeAr_w*P z@yB)&)ey0}^#+$qD$%^@_8n5R`Y{|g8A>X}B>oZ~E?*~9f0==2rJh%=wu|&p>pXkFT6R!sUBd!d!$oPT@pk$BXzNLmU z{q#9PenbpYu$S!!t+}JW4e7M0rfOI<#IkC6X;V-00u5+2Lmly}+3h*p>$zP!3&o zvSWKcY<(8t5eY%Vy5HoPPcZVW0paOB6ZNPkFH#KT$es?J2$%uE`lfmFGH-b}1OjLoER!dup$vyF+ebl$>Xtc{gS17dPSGUH}lcpr6Nz zRqxB=op)QHVhlF%0R%!{ULR2Tjn>!{b|W@=MN0;C)LgOAyK$PsEg3M79n%CwAo_Q8S z_|P&iD}v11YP}A)>a1FZy>lrK8TU^cDRnSzwd}*G?Ub8r7ewBDldzoF1*S=^H1dHR z{*R}uoz?suUGWZ<_;}}C<+>dilUhMb_k@P$9+wW@TasR-Si~tVev%aVN+CwuAdv9Buc~__I^%;-e{z8=-JsejL}M zcWKS3Q|_m0s&f`t)eL^%wh%Jt;66b22&r8E#^3~lnBA&0P(-)%sQ=tcGtKQ>qh*kB zeyrIxJ`VCL`DxFGkW91Za?*80I(6$UWqqg1uaLB@TRkV%h-pMN;d@s_ja%HDG)n|X9P zX|@^GK~{Y=pXKP5-M|^y_}{h(xS2P!xZ>qp%T7;g_oeRly?HZ?#zlC@+x3K_w5a;6 zX3lM=!LyG6^qWlEO;UIF8D zaZMQ7SZyIRq9V!4Ryqkp>7?!UkbvWSl3f2@1#YcxLpzU%$Sp|c#&n0=cQzO}M?drgQb{R67U)KP+ zLl33~bxxyagVo;h^k_HY*(SYxdbS4e&E1yzpxN+Bk^OabgIow&V5v&DxD?7)4U2ZW zrNImrrb%5L%3ea-xhV)g3XIE!)+AJ@b8i+*dwwNy-!e`YZ6ae;U&w8~0WseV!@AUI z6Q)G3AsXg0`=S$|Ft@K!Xru6^v2dRvPkm~7=$o9dt33!WoLpZrf>U3WfG_{_T_P$8 zLZbVKoH97E<%`86So z=|GYjC^}u?NA(HI=at!Ol&7}ED#qhm?nT&VFFuNR2tGp^G5G{v-^uNq#7IUF%hf}V ze0ONt8>Qz21#=BJ;kNrrc76vO0=I9@D*pu>auenH6^)Ebzk$juixbb~NM|G0;Khrp zC9>WtDc2BSMaLHK^OA|-xCbOe+OH9&O}Mdu-ZY4uZkEvHv)aRjZzqX6BwonfqW9x~D_H#K&> z?@&H!(>hYDmG5HJBSCBWBr)GfgC7&8x{`432u@c6`}So+1J)uuab|nT*cXr8{B>sgB9mw>MD0nqrJ7z?-uSysp8qGO4;o)lkj?^w`5waMSLy z5p59yP&h1)kL=O_2AWpG{3ewv@!FRY?3gQ$Um3&bdzJceSWB{s8F!5Dy!Kwg!4L=5u2RZ z2{>?y(1Q^@9{PxNcJ1N%uJOxjcRI=EFBlb7FS4`=-TnFevk`I6?yN7~a#@2UzF;## zpBBOYe9DmR*>Ce-=iWBJ6#g^a&sGX?>h-o>_dJ!k-GmOrt_?wk^dJ4W`~x9L&c_8l zby9hpHVv(xJ<_b$AB4PI*V^mXO!y55#CL^m*11^mn_&b2=$UuK zA|g?|Y#1oJc8s@gwXtkq5{&0R`p2RR5PQnd=uI48)68eqOWTHV_+PNU9lKbTr0GEb z9UVOhSzak;iRyXW4O;Y58(GF+0^dr)(Le)2X^yWj4gJ}3RW9vxHQ%t|skSCH)cOYO zwL2{tmE9^S*FU;{f>Wx`Im3#+BYw{d?dbr>)45_O7Ip*3}Y7|4~uu| zz)(SjNC^@?$*>3*>Fd@W#IwEF-pr0l4*W?ntpK0a_vZ5|ia{EuMJjqB>Z|?Lx zRMeSIw6fs#z{5Uz+GX^!a!2zoLKHm;w~&rj=1F#lR4GW{c`dO{=Fx6Sj+n^|UijAM zN65}nj&(;i`t%OpsM+PT1_)%^I$hdSbxRk#FGEmeZF(oZ-RiarsYZXsx`Jw!zLfXc z5Vb6mc)v5@%Y~*F`yir>SzdVwQ?mCP;Mn=?3O1$+yU*|T7ZK4*(neR@D&kyLJwW4r zX|YxNy?%Lah?(2+hDt){;|tactRcon7-L}7isFY=>V*2MG9xglA z5JxIhjI3`&rfoWERO;p4KnJ7oDUM^v*Y~8kBtmK=H+xam&=l&+14ZZJE|FWnPDaR= z(ZY2ZlrG&i%yo2?y&5Riy98%I+TLRln~ikmgPXI_C4Y+BfYs# z4Mv$aS}U6!_)XTiTkp4?!`!BL^V6Uxl4&uV%f`T;*|KWsSqsMkjg8@t48`=6ND*As zete2Il{rm3XrG`PBc&UVvzWub9F2J=*+CwH!5L=7#>mnrG&6C1jQtZ03}qaQ_S zvpy8Y+-eAJi7}RZjwlAg{tuNgUeF2qc;WbvQ0H*i#)KUE0qPSw#n8Cd2;p)I^PhrD z!ktA^eGQYjLxb_S~Ix`jC8h+MXu= z=jL7YxqjJjXZqHAa|a1$zqAQsZZo-m9(aC`@SXnLIr$4~Z;=LT3}(i-bKLU2Gs576Z z(0al2YelSp)uz!SC|5K?c?Xvezna~M4O}fBD(H@~LOioJsKOF+v;H!!t=jkDa|ZwG zs#Ev^w3uu5@q?uFj#o45zp2D_D&$N@{!NDbdor7J;`g`w6^`vRzr&{{FmiD+)Y37D z^=^i2_RgTwu`>UjBF3h$@c5r*-F$c zKY>fm;^P4Z4%fco5v4%B=}x6i8BPg`EMEf4fA^yMrt=MIB*caPekVnPA=UO<1HwSL z*+2n8=F8_C-n*Tjm52#zOb>4(jM zHn}URrdcgLL)Q6QM87_qU%N^gSLWS#>uSTMu!C;|zQYF0gdh8r>5N}JzfTu)^}gB6 zRmYHCatUdhrx%vOo_JrJ51?^O?;;O=k<-I@MHrZ`?&t{LWkb1VEWB6f?yP^~vaLY^ zj&T(@M`VREgkw%wwd`0a#Xog@y+CJTgz{uxyNSw>xxsbt_2cD@AVa247)@%M9Asn< z+hXk7W3IXjOWQ;iqt+>Wx(ElvU2)j9S_rqEPnIOm(Z@lyg2zX}4xha+NZ2&smjCFF z*I`?=f8B=>@8``_~~d2zvMoatUWb6xr% ze}IFHV^gC|doYSKfv@of4z5CJCB3ns8GDwRdEJ21w^MqeEO-inuxxAIe=;h)T$@kjB0$wYZUa=IkfS%Kn3;1cf@34bE-=*>ZlPq?KX(`5?>Acq>2wVMg`YW_2 z)=7&5yau&nwM<)#`$zl~J->UGFMf6ze*DjYX1SE-yvb0LYrX^G11R>6PD~VO&A4gE zbL`%)Sv0>Ol&S^^_&)d2FwKflG642P&@+|Te{j1wk?`iGVShJ4%(>*BjpOe?D6M&$ zIn1y#zs#(!2@j?Q!FRcsT9Q>QVw{0^5}LxbYsAKpJasVyVyFbj#7rBAXLM-1HBtIK z!Wx`oAQ#0^zRXeq?2*T|oWDAg?*aK6XV0c_7ZXOywn#U)W)t8HDY$IvX>_z1`jBnt zgitDN3e19gFX8%JUTkrVC%c+Y*~Lg_-nmb|M<23_#-rc0wiRFQM1&#p+X!MW zO3)^J+ampQVm!yHkS809vyfXmKYzxVrl2D2qE%U+^uf~^=%Cw1*s4?}=jsXp0~6%-_)v3x zvn~N3{7!_j5q_HSvca5JN$_KDBAO*UuQ$Vw&wd4C5u1SZ5gua?$FvF=1A4rh*YdR< zHj~eLt*zIgTU`|vbv#Nqt~31!aIsQ)4IbWz-BYQ^h<%ek7ysnGmFHpl)77w7|8R|^ z?MiV%cE{dEj)WDLv91Bfh>CNY3(q}T@r5m7ypoH=dohs zOHtjzeK(}x9uxNWmUspOb*0r?9UQ+m8%9~8@18&%B*YTXQnd#+xkdyMVv9E4eDKbY z=q6fwD__r8JZsS=LlH&XN+2o5*7Kff+HQ|BY9ziRv4+{{pec^Vs}_A`evsaxrKx#d zV)reccwwudQL?83qh&=@>6q<_ldt^@%V>N8w=~c`#>>724!#F0a9y4y!;etHVRtVFZdcH|u@hLKFRK>|hN>1;!IkX${5BXE^oeySbG5C4 z4;abgzZ7&tGSrbIK{MN*AvwlXU`}`{T$X~~`ime3+#UGpnO>P<$HOxgso?~FxHe(vOpgQpvyf;&tlc;JXL>8 z7BqEf`$aRM!BZv^MeNP&A|1X1q+x`q+pCOvaq27=APx%7`58bhQDE1+I#w-d5hBu9 z)5O7U!Xc%-gwXnc4QK}{>xVC~Tj|QAuV-WS-g3ULCjeg8Zj*j87Faj$r0a}w?9(x_ zk^AHAf^{cBjfSr7o8pT+W~wb29&{4gD}c-B6IvmH&6!K?0@e*ict+~F?TR(bjG75J ztpDg4wIi{74!_R``!m@z{!XcSF@G*Zg(xFV4W z(osP2_;p+~GJjE@M@F<}g1T)uB;!F>voOgupHDNt_@nn#@)29~Am2SyIxn7%{&y?d zh$GX;hHmy21HE{>=iNs|Y)lW^yE6BVs!4dR=Rmm`lQ(d{i+xaB_n_l)D z<}LfPyeUP~|5#F3;fM1YfkSV={YQoYdDq+Uo2;NNb^zLG5pjs*PrSY=aC0Qv z3MHrq@N%nnMSV^lucQKrqELFq_cBN_z!-u2wz1lb6oj5D1~jZnVx7YWf%GGAsSYOB zkz__u%tAbs!Yvd&C;LMVT!-~=kG*%e+hE(!9c)K;5O?R1un!##w`uqKm$gy*lKF|U zSU8$05qRW&NBk=IN7^7`9f)HMlN>)s#JdNIoWgcd6B&zTnAogZ<}5Z_3&DWN*WuR> zt}sRbfn*JmK&ImY{QiQ3SS-!WZ@q88A1x94=`hu7ruF5dfcJM7#!4QKf@#+ZB6nl= zBX7`>8k++_;aWjuVw%`qm>pe?cBk1{thpBHI{H!yU67U{-Ui&3e!FD9ly3aGYz@cZ z>QYQ;Z~W7@MgTt9+C1;^ulV4MNuzEl;KQh|-Df~y`krP?AZ+TtmPLP;!)A(@w+>zA z>*9wJ+9yalhz}c7wzt#n{R(-+POJ2u-<{Kj`L<4EsA21!}in;L!c|pkt*zSz~6$ z?76IRDsX2aXHopnX~;TdP#WgBUdX`xWoQ;j?w^E=K?<+I>4whuc6fj(`9O9?hxR)$ z1XA{e>rTr*K-#NYoVNzIcHwmQVx!F!D)#QbLWs+q`Yxh=zU8!>hLvEraF{wG>=8z=d(U2pJh^k zj%~^h2qXImfB(S@8@efo1DOExGQ^?GwGyIP5Rcs+4o76#hG?bc;!rxoLRw3gFSR-U z3RWd+T}ubU5f{3m!L6XQ7;Wn15;X#>leZeM>^a%2fw75y^5rn$k5RB@!fl@Zsc?x| z-6BAL0$AhA04&-=8kV|id#*3x5R7Y=tUwcm@%CkkIYDKs#0#rJA7#9G`~=zE7KlHPuZ zp9lVWPXN)awt!c$#KGUe5jLlRO}n^po{mA{5~%2f*|{jjhv}JR>ySo5pM$N8x0}vN z#y|k%&$yT;zMVyC#~A|@;fG{-u;M?sg`5%kJ7@`&uu`rjp8Y#Q#4*0*@Vr!-1c_ zKJ$aG*B0MQul7Z|c`-9q_VSqJ#r)^N_}2w1F^sleX`XYDVhR7n^6w`?DNsxvRdhAh zz~rt7hNBnnXf#>S9g!TIYyW*>=v4*1gi8b_o@sWM7D<@VWmnVRb@~QQH_O_rjK?8W zucXV3Z>|fA2BckU-sO#tLKB}P$}`7swdS>-Q#_Qs`NC=C^J%m#7(qB<`D9x_df}r( zQJ49XR#LXV51l`I+!lMXLQ9Xu!hGuox)_bh%L^p^K^c0jwdfU^pQY7|htilI{faqH zTb0DZ^R{`vkSvi>>hJB{ixbf!g0JUO?N_RPgSCul>ip-4l$4#sk%`we4f}3~KmA21 zCR^1o%mKVjA!S}$`=&=1nFq!8GsMynC*f*n_XRj5%F!xC6wzs-&z53YwQ_v&H(^qf zppDQ43m0@3gt!}M)b6rs7IMVv*##zo(-{e=9v{%uHRCZ~F>u5)kdTvR9Dpl;|6GD` zScw`M21B^466Lltt;{+WRj%8=hASHAWF{a%KFj19;Xm;waO!J0Q86ej0s z3GC&ok$mOpV1?seGFMcyT12-h2KFtT!ybs{RDODHZJKzzsnC zAO1EMsZK8}iLQGOo-=010?w>mY*BwTtxYt_R_;F)qxV zNvT2dfHIAFagyejsc+W~1E`aNq<6|=Pe^?$AFNWQj|bv92a-?~^t$ymEEDN@;Wq?9 zlNPVL#_4}lk7jblh@nN=7+=!U)1EkqC3XUX(DMW)a!JDM)w^H0On}`Y(|8!x{(IxL z>x~?lzrXs|H;O4SO?mXZI$)@afA!5Rd;i!M|Me>W`o1s3SR>6m9>p|hEgC^-<#74P({9}_ZJ%1%9hY)MzhVSQ#gE0ra z%18f1vFDGlwt5I`4s@>@tEdF~d;YkzXR4ZRO1fB*ssO5J{T%27IZqHT?R+;lq$CLn zCYH}z0{=bP^XbvW>W~4JdCysAr$^&nM`Q;#?`i~vj*f)wgTmzYstS6j&pxoEb;sjT z@r7(?WthS6I;h2@ro?gSjy;qdNusbj-v<{Q&2f2SRv}F6wtP|INA^z_!TQUEMSg#? z=lf_CaCAo9@1vR13)$wDK9at2Dmpph1;K%KjAICiu7K1pY=&Q$#VL z##J+z98sCvA-QG)r$s>a8b2`0jlt1@JU9%KK2wls6U-ihvej&(tQDj z)um`_wdA-^N?xu-89s624S0Solf>hp`j0F?xRjD>tosyvJ>ik)r6p4xZtR=Cr`5hk zrw-iQ)sZ-I=ixHX3IlYFat|@kw&t<{|6an!Ukq8DLCIp`0WGA0Gf_YE7bKe%X;xzx z7_Q?TU-%3sCpiNt1GV+U@kv9y|Fw>@h<>(AODGrha}k~NGQiqG+j60P&yy4%eP~oi zFr$`@CGcHYYOckkDbw=c3*3^Qzdc|qv4UCbQt&NPewXgZGp0(3xwositfOE&{>{Xe z2&*nr+3u&_8>_pli(he*La7D&fjCvA$k7pZjT<57p;FpoD0KSm+qI`r{I1UwV^bcv z|LQR=K!YujIlZBrhC+f8hAqyM)HPt1Yui?2tp|PLw?Ssp1>%S_6e|iihD%pqE$J{%wGG_EWv_O$yuf@_P`ikP{I%80^y8bDfwF5RD38r zLpnrUhZKtgx#6p0?WvnaKRxI3{{Am{s{1UzZ{{=Eo{Fc@R6*egnSAl4Um?)@$ux#x3S9dh64 zkvNz<-1TS~)z~?Gd|_aF_0~8xPY2zz`F7@Cd(-hn2n+0ifLB4;t8ER9*EnvjYOxoK z77yYcxE;vco}Qwjh-HDG*5fb9hpe?bRK(3}KlFRA|7&v+GbjG}YDTU*TRs}UuKT7K zP4f=^`cTo`hbe6)?QJ4Qcd)O|#QNP7-+QUlf6u8c#rFA;+TJY{lq5~Nu1xzCvnFRF zc=Py!(xM_ZEw+3^so&mjnn|31PSqZJVT|?g!tJQ1rr5rqd2%f2UcB)e#4X91(x}MS zt9xrb&%oM(oiQk<8j5m@$+Y>73u6SLdsBmEg;*N>Z+zS*V{M@{m)>u`!aMHJ01^;xN06%GSvGl6g|oIhCqKHdZD@HDBFqL8y!!P1eR{yYOd~O?wwbBqqpv zD%WO4@Hmc&0+z$o(n*HWHf$RqJ#PVQ%iFHL@zAyMf|@uuHq-ehNFPo+w-O(e(xsOJ zrpmdMLMTAoU6ftX~B%H+NvX-EP{@vIb6i*j4MwecE|lUwR9E)C{Kr?{vk z-jPRHf#RD_e@)h&o#!w^_=V<6E>^7~o@Lt-AnZuhaI-o5xW^)7eBbf-{UW80cqFQm zF7Y9m8;)ZE<7nlBh57(>M$IjtAVGKGMvLZ?U_7{m!f4@Z@vloa%5-#0%k`)v= z@Vr;1C?B&>Y>FHsi3w&Y+#8D@6*wc`H1)qw{@qindlJ81KZwHo05G z!VonZA9=g{7rS0%?}3#0dgwFE0kAN6c>435@&_gie&vv(`wWrOGUkwGhsU+Y4=QIv zo`rG@Pen}Q2xvu&ZPW2am@UBTs)BWN5+F*mk8B#*Y6_@%&f8( zKL=5j2g%_}kZ0Y$zBI=Fk(zVpwTc!>8N&*|T|S_G={^WE|4akE1JV*c2V40)h@Ge6 zpbC8`F)GCS*LQ&d=Vm<6@p4<&ZNyQTeA+mWT;tdos94l+Z#WlU#l@O3Dc#bOBBX_j zaeUMBieeXvaRVju?OK5kG$nKo(scMPy|6ZDmGE?Boz$dg) z``WxeD^Le$c+Rj@yu6$qbxPdd{>pQLdoU|C^25LQV6D9*o_czJYbIPUUh2%z-{!WD zSd@C|A|FSAY+BG&YcuMo*209HyARy3>&|1<2{H4st&<;Hq|B}u2X3st3w=fJml0x! zoWyq7#!qE*B*iho=JWmKGYw+YOXq_h_CEKLBR<5LWoPXsPl?`AU#Q`Zok?pW$^E@K zyM0AT;sIc26&W@_D=U$>M?8gdV^{5lyDF7r#(lNxlU{d8MBzNW{I;^x+h=;uRJlGN zF?kw~Mr2%8dl@oxUuT%g%@))VpBb10j`qv0cYrgPN{3R$mfSdi*wIC&Ta%JuI}EMl zIFvoA+v(qXe0Y}Nm$~2}UYhmzu96FsX}!+xL|1M)l=vLkCg4() z1ykbpjNI>??4~U3-EX4&xHp`x4%H8^AH7jx&+ilW3hD80t>{m<9qRy&pT>Fe7#ijV zPqpvCXOxZ6PQs*CsJvuL@yz#A0_Vt5(^tR zE6}T@(W(b}??%fX8tZTcR<#h{uPQ;e1Zm3$K41*&^G$8|=2E8WTBvHB38vF?KzAuw zIb^(}afxYUhmTFYp24;lGVh&VVp}gd4|p7`r44uY+UG+%e&=l^!v8-9wyHmXCsrby zj@Ok4z-q!>r-_f$fbbyQG8ba75n;UGB6?Res)+8uRc#-J2?V_FaO!+p*_z9t$1maH zv4+Z#B)H?gF)XK&dr1#PJ_UuPBy9KK?q5fTzPHUZ>4+<#CZq8Wewu{4$uk>W(9mz(L;|9RrICu4+ri1j=t~Ki6 zv5!v7ff#FoM$^{Wm+& z*mmRE^{&n+|C?D7Jq9t%>q|Op^IX}nVxyo?2?!)k6)>9~Y2wb@x-I41qn&S(BhQeFi7cGYE3N@+*e< z4uB?I&FZ=>7P}iz;apLHTsGYx`r`%9v8Qjn8Cs) zY^nG0_u4f$Qs5ZjyWfi#7^vD~`IU86)=oab7i(i`4E-_hZZGIS-ak zayBiQ7NxNY``;zjkyk=4RVOf`k_mQ|?-tagWZ&_4zsYFcDIcrGxh}M>{9L#@A=vA* z+wmWHKz8!5KGtO@iPyc144_6^ltE`ckVwP@wuvPd0opFygNaIGUJxE6*07c`XryBn!E)a*C0x_qBHNVLL7<{M*Cd$^WD4%0a*|bLT727;lg^v0{`?*MlV?W<9uJMmwSTs)?~iH4Dvga zS)U4ZqM5J%2JLeaGRZ819KKjn030}wYHJ`@<&7=a5!|zI|E9-l)P#AtM3DbIz7UTJ z0}H>$folg_(qW%oaG1U2_unDyL);^P0*=gRtT_(mshMMV%Tp!2+eR;J20I+PKPNDF z13eE5wJixI!arq+^bK*G^eDVA&%uN~cC);i=u}~U);2}}%3(gL|Fx@}z?Anofws-& zXg}RAGufCYmL$b}bcMk>Y{v4TuAl3`mMWy@`{PST7TjaZuY|lL#Z_2p`8xuw>5GY4 zGNI{C80k)DKlbr0{&AjybEn5-kovG<+3;DfCWd17{U>Yi0k%@cGmy;(MOwdA-87c==*VIoTs>s)%EFz#;cnv65`%^BR-HgARPL1G{TbbQ@F^^dslFQl(x(_ zXsC}A7zR(GPB>uGG!?-Rwi6^thQK5#9Inqhw91;3>gT=b?LvIYzNMd%$874p%FAG* zygf6vEaHQ*Qn31W8rYPxXZ$o3+>&2cZ=(~Xtyf{3JMT{^%Kw$i(W<_;I!v5@VYpjk zPjTi`zB;~N{q$4ecGt)L#lvU65>N~_8bKvt4dQ8Oi^``8nb;q zH|r_9nE;g=CxP%!&lKHAfn=OV^GQRQ#wzwQOCL)LOh{-RHmgv{t-4>YIJOXAA0b8n zQ-sDjvhv!H~?cW`PU{}ja$ zgZYkOD#nrmOtB&fHAvQ}?EuTX54*YAZQuCP4>1vOqdBUOub0r9pew$x{cMyZ$Z1XL zJ4}($ik?c|PhcMjN37K{7y>(>qio*%c0sLw?G9rhJe(-EvdEWH2|sQzUY|RI{cKx& zDPTA-(|U%5kBZ-_%mdkz0M#t_c1EJHMxf9{yDfm{N#uzHpScWLady##oybRceUD{3 z3!#nAw~+JplQSltz7Esf+s=2?gf!Y<^nhMX9jYgA~DLwdsm zo3^;jMgA(Re#ES;#8`Jm7=mCzBqAWaB1aGjMKX4Qr~Mi1InCfkJG3R3AX; zE1$l*dTZuZ$o@v#^>2yFoSP{kM+-~XlcJ%QLeQDP&amDG|NFL+(*6`BegEuDAw|+x zJjT<@>CyHRcw+AdB|tkw2F4k-Y{J+sDG}t7^O|1*Yr#^#>Yeoj950Wf`@Y z0BB0A;J53FZ2z%Q-6jJl?V-s>sVaDrSt6toDYOZ^@7uftu4N|UrvCE30ZP9f$3Nib zlg3a4w^tDHTQo;2S|#ayV!SmQ^!#JKdRryNEh}fbFQp7`Ir-CuAdQyrd{zHiGTiUJ zS|GT&_m^2>hag#(C65L3aBnaL5&Mo7xJ`ncQw+ll*X?@tGgp+M?=C|S^iJ@yc;I*L z0`Ykdg@P%l9gt~AaHMJy)jCRjTGt9|BeT#n)xCkJm3!>=?%@3Cfu>B+uIolw3D# z^vwEdzDhZRSc{RpGFC;~is14`wmQIhQ)1i8X#;fK1V|3hPM6`Y3wz06B)4Jo&JWMZ zj@5hQh1M%=y&Sy2)1SeV$MHa6eHAEdW%S-wsab-pYkKj--;X@o@DX2y+V{|RxlJJw z&&}^h5sO@UEnc2#Fx60Shn;uvAtCS4I`l}l0+%*ex3k@pVuM?ZRKJGs9B;UhGQ{3&;iq63!>nG*3LxkE_e=&SD~>8#m;GQyiRpp6e>TF9Kd6g z3po+s4C!23G#*LzXy_5KeY^`6t%fBw?MI`RJbY=2=_=&t7i( zQS)3KI#z!D49C%Uk|^q-eQ=hQ(?PG=dCym93Aw#30TcQp@Qt4U5arYQ_fI`V3c_s9 zXl*&-U1HiiS`*jDSqFIUwFHr>**fNLUqEM9@9o6U-QEN?NGGzN%w7U>m>ejSpq>py z;6Ui0cr`2Lx^+6g}=%holeV8U_#bvN} zj_|8x-HS70E6;>atKW>^70K_4Tk3{wFP2>oP5*a2Z zo;kj*=#Vko{_f-<+t(`te1H7(k#CKaI8jn5|5iR7rghxH>D9*)qrJKHbu$TV6?pk$#!kcmC!feE2`VPGXOWIY+cRgW;~)n;lB4i zf`_OY%Hc%Nv&+b>l@6{c8Th<_fymoZ$tIJaj=8-#(cI|hD$9zI)_bLgF;ky_YGR5n z_%)(zbMU1ue`cPBEJ}H4eK$$-rwY-7hd`6-Pj=e%Hl~ybH76O&1tNJbj+r?%_vyd~ zydcDhyJ`F-m}qAleSw&d;pY6Al70i`d%E?bd|>J@BSN5+2)x)gO#tCA*TcCt2YD2{ zz?lu>6>lF@Bg@FGduW#;iL9psN)!Q6^FE_XivvUEtmhPW{= z=Zok9iga-}!ZWiOW5QPDIzgrV6&5D*kj#D5A4da;5DZmgT*5Ve?B{wMSp|Px zswP09$!CJvv9-YB<3o-ki{kcauLw6KjX|o9k=rkxGizLmPscY_jge_QeT!s9kM@-K z@uJu(8GFIK)rmUdgN|%BX~ZAH;v@T=7=~BG)5!=tX$i*+R_LlxFmJoJ@KM!O7RB~8 zua+`NI`+@s7wP;?cmV{``s8Y4PDJG>@ZqdMVtC^J2{u{%$ z-aJMHH#UdgS%3!jZ8bzvS)R^kkY`+lN=3&qS2<;GVbC#8Y4PF01vJY5JL{7iih==h zBi$0T?>2Do&?AhO9)mk-B4XO(L;Wp(0zBP0z|84E()%e`;Qh_h5+=m(Pb`v|?E?;i$|1 zOsB#k5plRg+xE30;JO)ad8gx#81aoAx-_)y^_;el3&!vwBrkFRmY#!=Ek8Utp)C(H z<)W|5!H|R(p@H;`J3ejQhl!&@CRb7L7$6Mi2Le8VcT!ZP=;$hfsv#L*qh$(RyNJ4{ zTSW^?O~^qHa&KCa!A5f~MqN2@cEAsF9g;Dqf(b@kS;b`;IN~Dl{@8@1lxf#p>Em72 z>D$x?CvZdE)SME!kJmZ8L1GL0j~4bVLl;RxeUGe`pTqm>r1kPYbmej7XK#p3Jc z6Nsrax8o1(hu^7T2pxOw;uzqiHGQj*mc6Sx;2)3(a{RNe7qk&mPMb8UeB)iPLgWJA zR7SB<)!X)Z?hm-5zV_0DJDZR;G3r!3<&t2yq52DS82#&RK zN0uQ8x7VW{zS!}x2(>`#$G1KxJ>O!XZ4}Ttd9MK8lqJPe1miO#_qe(dKULn zMW}j(JQ%I8e28pV2o9JTekg9<1a?HFKTnu)=tZ0?a zZuL1hKKnefW5=q{e$9$=(u?i6F-9q2>@}fYvHn2$`Xo`w9ew6a3|@cwYw&>E(LH}C zw?G-KaKZf!_9a;g!^OdTbMz_q(Sq?f3U5qSO~5r$Hkmeb74Okxiy(swoRhargw{0T zF){H)_iV=I0lU)Py%H#zcSvm4%iC7&615+lU^WRukuD$X^S3exwjZ3IJ^HDNoZLSX zmr{Fknq*MR>mo>ZH!I{4 z{2FccY&6H(isZK6%}$0*hdwFtL^vHsIM2@qWb3|SC0uBIq1@F1mN#8-q_Y}=*Do>r z%56{-ce}`aKZG7mp&@xZbWD&v#-z3e{j%k^Y$5fq^EF>4V|7H zwggt>O$R0{S|-Ba+&u>fRd)=kas_y7Tn*b@)*(I<-(4iB+OqFX9`h`POblF#G>$p|H0c zDVFP9UtK1Px6X($#r6@&2@;XVAVL~3SK{8bmx$5Mexn1xBy+$GD986^xg*mScCiZ_ zKxlc$0Ce)Hv!!G|jq|CZA#Hwwed9tkDNsZK8MjctkDJt-jx( z_y1iw5v6|k%Lm3(f6c2#1?1LOfJjt%7{pq;aIl$xtbRR4 zEancoOv;YiA;>GnCO@c!$LKfQV6U9QU}cF9uFG`St^e7CI|u$v{%V4;M7RB$3&I5F zC|C!{KBiB0fy-35GfWv?hBi#cU(+R9s!#|NyM`27@#Zt|+i+i&3F850h+21DT- z7~7Qye#uoDJ%D=hd;{Y)lu84o=4=eu)mKZF?;_HaPAjj97f%ziOHHwn-<9ZpWc zjWyre7y}GXIdKfr9ckI$6-bka9k|Fi`%!Pewf~JMU7T7yh%=;L38!895R=)D?p+rGF_3(blCJ>NmQK$4 zwDQLNjK}LbS)K{a#ax6WJ~rbAiZ?)NbP215?$z5~ZdPHT2XCh$;aEBdxAq&Wby zkS>2dd6wGHclvh3IfLJ0)}pM{nqR!vR2#vi!~*^|CYc$b4J~D=toHg35C^IE3T|aZ zE6eYijVz;jJ*M5;ujURD=x!LfNJ#?P*|p;STWAe*SqXrPck#eRogo!P^Vcd2O7Qeh zdAF}fM8J3V>5+<4ERwMIY=WK0@*$o6ErwHy{QvrR?!h?dm*GQofp;{NxbD`Z-CJK@ zFdhh%sR%G7<+AA#G+`{k=RfYxUVu61$` zSOjP6Yg8d>g+lwsAFrAclunMIgRk``_13$&*bf`|>!b@TS@dQ2mQUaa2FP~k(Gopa zgH$ICt8{@kRHdh)-NxZLu|`s+FMFN%H|v8|7bAUl*kUaTAJ~@q7>L;B0>72soy+UW zFjv?yUj=PWS%df_cv+XZ$q@niQbBJI}?H03bWBiaT;CmQTE;q2WXgPtFzn8ymhM{;sDo7tJq}!$H|{^ErrSav;&Dgw4DL zTDuYgVq@&maWm*2QQ0DzFJX&96;<<%hu6$zDbvVUSB%^*AqXwMW_rs?_0ERz_ODs1 zM{kQ1_Etb?&$rDdJT%-s5?A@bs~^V2IC0`8yo!p5rcg)*AqI*z6%|%9Ba9j`CB`W# z;_Wb_hYuRe_>Y6)wV3O|e=)BAA757;S7o}b2L=_eC`H{M;igeU2{#}e64D)_bR(&> z3W{`tbV-+N8WbF*k?spD?(;?|s)=&w643vFX-pKi5q{ zg!8}GfuIm@W>KdHACf7jO221MW@oWMb5`%cnF;*kiojd@-*8VzCIPIXioRhMC)(`@ zJkU3uhbFo=qz6y#1d;*0Fw#gXTsnG3N~_Azaw0+B@OQdLcYHLbwNWhk zS^A0_XsQ;s=kLDzku&M4;!*je%Z@dmaF^kn+}(|EC&U+8ud7dG22n;h&7tCvUEtS@ ztbphj1Cq6i2vJ3NP%oWJCYI|uXF<~nv(NZ8 zh|R4QD#vm}dhB*5egShR>xKtgqPx{h_7>**SD${v0obsMP^G|GrH?5iPR|hzu#12I zm@TitOd6S^?X#1m16VT$Vq_NLX?k?|)ie^iytwrc)HYl&EZcK{CS8yg05cK8(+kH0A6{v?{8eP_56NN|Mo6>2XwdRzO!j|Zwm%4 zB;$45d`g?1HJRn6RE~ebaDS_d!2c~B3!bd{n#or?PD{eNCPi()N9KGdv0sV__JxcX zT%P`Iaz%`+8SwI7YRq~*5NMo}r@?bWL(D;ovXZNWROh+GR$v5CAz-x0lRwy|erutU z-jJlqSeP)pj9wU`{k?DYO6q|^%>}kjzJnbho84#HRDtKI`1vLzdfmUqR9{ccM&v$7 z7qglA6T(y8AffIU4^iE2Ovf?l!I1dpS)Ua1`x-j~zno76lW1Ydbe);S`A8+iwkehh zH@Wa*h@$(zMMb7Vn@dI!3M(^dxkGji` zbhNG#ptk?8t|?W^(=c&=3cKX9$*0EClH-1v^Pz=d-*V5Q=X= zuJ>->#USovYf&}(bwj_C>uH&i;t{@lhG$DxdrT)q(xC{WkZ3^q^*qnvX$Yy&Qn)dy zZvh8A9U4UOEkY8f&}ZSIZD>AK%I^pYVj1=`YKVcDT~|<(_R)od_>4m-S4*frk@0bZ z^TT*W5(u zRaDjw4fL(_npHf4KeB2_4uG!{3+|GZi*Di5h0{fWq3{jwqJO!hg`Ax@;3M_+ z%Q@^Fg<1Od_46@tOLiJ*Ie{yU9V(9hiRBSxIzszla5So4!X0{Y^5rvu{K2nsGikPj zz%-V6@oeus_xw#RS%I*h1!Y6^^>fBt19u)xkj1kdkAOc3wzqB$6>Po6``7*ak3#z! zZkjlBoraCt(k$X)1;Bcee-5-U?oc z=bioivD;531`*qLZAI?*oL})D{(Omy-Lk~8q**8 zS{(E~BjdR`5w(uhJJYCZGy#eP$J3ICya(r#ljpBmKxE5_mSW{g9dgLurUG`F4bz(9 zV%^dMGvJ(1JhL==wbFX5T6K0B;J;jxl}T^GPSTF$J=nO%0QNjsZRDc8@KrEHZ`aTL z$=()W?+H1_1roAu49)Oicv&8aGwQB$aqA6U`GdJ9Pc&H3+H{ZdErj!h^#{W>RIikH zfbG<#oN3*yc`Xg6wGX_B8= z@*&5xUc&i{DuY3=vq`TV?KyQ~BN;m_r?MGP`H!_Y87NHds;;}1$`9S+T@|5r-XxDu z?M@&ST`~gh1=$T8i#YeIs3X@Lb&I%nHc~vcg*H;OB78_Mq(5e}OW`UIdg%U7zRBOp z0NJ(Y<+#$E8$_NdX1KaOy|1oTN>D8;>y?nfCMNt6j+^oVibb5NLX}L6#;>mFQ83EB zZR4!tM&~@Zr<>IWQCYwI2-vMDY!0T3SY{nCnV}uAN2u>GgO;(H~C?JkS5WEe@czIt}_fGd{oZI%<>{zQj|vHY5|s2|O5&xO%MSfxSmN@W>Q z#sq8?sPPm?KFh5Xxz{Lb;~u=`F}QtCUEEQTL{zK%adKkr!!i((#7=+FgTVD^80|Q0 zUng1ykA{m*Agd0$x(jOR-^&>bHjhPqAjT9ojFQTPtwwGRj}f|jX1KeKq!8&dlWOs| z9m{$L4-nI?Ggmko7s1-&4elFNVjIX2Q8k@8#NI-y{(~LOplD%5o(3<)r z|IlF#On~jf1{?}Q1mh0P^afzN)gAKzkO@-TD-n?$K1ALiM2m(B9E&XZ_a~^15cZ&4 zTCioWwfkCZD2d-%9UGycRmRDe$0~&r_o&xnQ*XsGt&~Ax>6b$wu%>*;7Tz2(G@`}% zk16GEr9}Q6-u~9}6T=;}*6NLYFAJI4gtltj&h5A`wsc#t4Mx)(s8kuva(Nf536$sGzU}3H3cipquQWosExg8IS~4vHiFmdd?Z)5E#6P}dyo{T? z6?RxP6#86Yl5)fHyzpUyF9pshz&6a$&pZ+o9FiAg@>@UFGpXtA$OQ!`9Y%}O>HUQf zQ^yN7mNMDjmuibuy8b-z5HZq_;K;A2jB9w zE4o}kmYEJR^sKA%yTCBI#v9e#q7dlbb0o~wC+V=AaiJ!0=kfbAeT7dh%q|Ge$U&oE zYp%Ni>DR^Wc9F{wfIF)`CrNy`@IXYpzd%IwX)^Za)IT~f1e*KvRj0u{+>=XNNmP5a zO032SZ@fh|V8SZhSIn}2-iXZK&9wI`h!`z#4=cnu;87DqBrm9mEjinN0D@CONPwi% zl8nLasjaH_hEwL7qDureEY_4etSy$G!stloAS#XCc$$M3fCtl2kW4r*HY?%e>=|q=gS=iB4;jt zcmXiv!amh(8LsaIu6wz6f{-ZbF}`Rir}zBP?ig}Exd$gI{3OuMO=qu`a+q{T|FSsp5GZdIK}fjY>AS^wZ9>UE_KAXV zLd=yX^Jg+n0;L#FDqgT_;~G^xV>NZG`pkUXJwp!DuG%xOMqPwOWjgr&BCu!QTnNQF ze3IOVe3Bi)wkkC$?X#Lx{bgU+S#|7i^%!5)=7fF|K^VnpO1OgR6P<%!iBVeb0Cil`Fwgx2W#LH4R{O!7kq(eN;67)L#6cj z4p&pi?Jx!UWb|E^QjH>``;WB`HchlFqaMcB4snpH7CfMglQXNLux^qJN7=>?H|JCW z;lTLhISLbGknaXv6Dq^aHjcw-)c{%St|9ybxC0{w$xD`i25}oUBC5oFHjTiHZw05- zC7WXK=Z*#sx#6d+JFu}CL;{kh932f=z9Vh~&(GlPo11qn2c8jocluwuhJV~9&jj1> zgk>*a-NwT03=J9)Hp)}?xZCwF+W));t4TS4(8Tx@H`%=UC=kmR|Jvf=$a|iksc|A% z%P`7j=q=38-CdVACr4Ki4aQ~$VA*yj!{ojIUBV0k1N?Hu3Jr?J6ZOL^R1GA$OD(m` z{Z?Uei~&hb#)gn#6W0O+-C{TC5w@zO8kcNpt>h;zpa&%^b&nlxaw8IolS`J`k%PJ3 z^$M1Rb;e4d!gf@`GT4e3oDL6Ak9*piuQO~*39!!~*h%EwjjdNH<;QmKfM_mnv>R{( zTRoaWjzQw4X_-x>ST0N3*k~IaeHs+^V6AB!9d^1%ahQ|Muwe3JT8p6-OTl#V^phI* zgWM%G#AD+_q`FyL&mlySwhz%aonti(6kn1b21^iKbCEPB7IuNbb|hRqvJ7w1K$mWh zZ}8=Pz*$EiWKCRHa=-pHBNm8ctCE5>)YH)~UInuUL8 zbA?TbVLII}%QT$p@I=Ac!FNad<@;%2MZx&9cQa5}C*2?E#+1mMuL1DtZnS*p0X~=P z+--amgGF4I@d83PUo#qG3Dr>NO}q-Hp$@VGzq zP9*aE%)){*m&e%sAM8#|)FrYtraKz3DARjNVcakf4v=>*F0N%;NY=6P$+FdvJ2-J^ z&YVL0gfG;ucJB_m57*N47-QBefB=?P-iJ_@;&-$`9c9|~6zr1BAp`gU%Zv2No*PqP z-_+BolgmN<@|Ceh7|_$)-{}b4r>fKz=6hvn>{ruF`dvsA@*8;*e`wMi(e7n*d4~uEP^ZF2qv!d4gq}PIU8hhl<=7dlV5Xr{^0YA2+TNMB%## zg4a#;(BK5rAvn+stR{FII&sGw%Qu{^ebXfue)YvE$N$BzAI`q;N4Fy~At+$tE37#Q z&yLP1UB?g5=q>ZVvL^YFs=K3nrii~85IU(a!FwYtRIh^2_4dxBFgc$eUxNwL#>Brf3Nvdwk37Z{328lVa zeL}Ok`o46!+2Ld8JXDEUnOllbnMWr%YAv30xc2h^KPdn2&G>L(BtU^&_?i@}2$MwUGbhfBw4k!s9jGlodP+L35>UEN7)v%NF)pBV4sD7*d~vSsqTKTE$IM z3=Le-6R6gg5T7Gj^+Fmm#PjXh?=omS#!e0lrdga-w!a^E1^uPc=Sny>NfKOOL!dP7 zOtM)u87iGit(}QO!m3PUhmj4v#+KG!iQ))C{4cM0KQyz`5LybExY=sn8Uf7)9S>%; zC5$xtb~|4;&kI{hdNGIjtyDZ>Vn4sv?~vR3{>PegJF=(Obf|vaV-gWP?EZp;Du*#H;AUg$2L3C?pQ$!r6AE3G7wr&UvcC( z@aU8s_cae$>TeAR*lTPh(CkEe1E;Sq1)`s4Ut?|ZnW(wW~?)2b}`};Y5Wyy_noFP83}D~79-9du|CofG&5o(^$P%?v&IiSMW`K0vKTs+ z<7ejB9X!mec;~V+ESmToGX7U7Mv7>Gi5Ut^E+SY zKY*owUzbz#M9vrIP6vipJ-($1h~yg;DKRolL%e+zt@IDgD5(kt3(=#cnhDvszpl?`AsWpZ)dn53l zP{0yiKNzzbx*`4ey3)(}GOxB96_cUG?vk$=lse*gfQ8eFED@2tZT(HAf~R17xZ=pa zJ#xUu+|5x;Z$pYn#g{=Ch=*O^o%J`<|uDc1J+?2 zExA46lVXRbvYfJg^|GU%EjQLa`Kr*`n(7S405aca>hG1e|1Gh9nxvAd{2RcWC|Mr-_3O5Hptm;gKui>_~f^7fLn{s zdF+eYPI7?NAwW5{ydKJOfKx4Ak}xfCn~pY)LF~*dM#|ZJ1Fv%$yGrOp1N8^f^hYRf z4QO&tEj(l$HZPpcS$Heufb7^+S#NOEL^y(ur_VGp&dk(Z+P>{nrj<^mRut%p|1B~Pie0JBv{qG=yx)aSeU2kl~;dGiFvVHoG2mHU>1ZW*& z1ZOo2oW2G{aMVgIx|*;GFGBzy0h!JTIB!tHE^v4lAiP_*c~ZCDGylx5ApAra^#;Tzairj+4NPy(VXNg7|S63(vFJ)aBdlSEa%E{a(AXL z5?wJLq!6p|aX7QR`P}NTqmpemW5@aXOY)O-!yKwoY%b_l_Kg~VBTehF@;lmZZJ#tGX_E{JB9`C3bmx_ayd_Zok@Un@S!j$rpLt&76oh!F~L z0zfuPYakmp+HVc9bb9-D9@ak|+;d-IIGLM?RBE{=ZOI97j@&Fu`I!mR4iNhxuzDG| zLl>mb_~QgBLps325~w$P-tTM(?Px&5%jk|f5_|FJQn$!2V4NNUT$PN`x1qDq!wCY?1vEox;JoK3lOjG+R0?(*VQj5zPqO~0X3T%k0%RFm4g#KQ_q?BGR zmezO8_)gaAkG{Jop5@)P*D1N@@2&^Wb*6fog1r@);W?gJ>f7%7PuGAmkv49SX%GB~ zW8waI@hWgDhxlLlN9qw2jS!WY#HFy>))zsXv=+@r#{As0)kdGlI8|hoZF*9y`3PhP zmwd8bzK9cTx*QpIW9K`<_&x#(XRhZB0#Y+=WY6Blzh_|weqL`w&EJhO`%! z^G)7|x1AllGVZJNx@uutdfW#Fpv1Ycni^B+j3|xA%B40;-S53dh(NC~Tp;9&&z)c_ z={}o{C}BCk2jI;G;c%sE7=iiiu%x88`%7SkZDreX1Wx9+pl0Voi=bnXIQ(@WFp;Y# zA3+6?yb4yZrA5TLJo8d9?e2fB*TTJ@c~GvlKc8X>aqX{ucvG;1ssZ!B#THm(3F`f@pb}TT@}y)EZ{<8RUe>_96ZXL(w&@gHXXFFWgb;lUTns z&*@@|8iO!2FMWyDn%1T)7{!&QytYaJC1fm^aCu$*p5E}S8LysO!806+raLG<#J_o}>gHa53 z*HY-8mHuCafLb0OFMH3)P$=`sBY9dzX1YGxISmkWv76)B5yWVe(l+a?)#KrXdcS@cHuVwzZ2yL&Snp#jXonig z^er8^RRyX)WitP`@&9~6$e7vKu}5d3avtYs(5CB+irhlxpB7POBse-_ZZ4-w;5qDW zvL(8OP^-;eN#{WeJ9bGjXt=PH$qr6y1F=~3TXR7FF5+k0@n(|>+8_2 zKq-AR&Yc6M#v9VY&lH014}*z!qERgQQq#Tj)4f}59gHqWB%G?>@zlDs>=LIhvu)E zn|aW0*`|{A)0wdl%joC>t3L8gAmy)bTxxkYSS`Lfcv8~a&tuj`j&r1w*Bs&Y8^W{` z2DmFc@M$>e7mcFDZ!- zgL+@A7=dz-*L(h*$uLG{wwAY>VAee9e~F!z&4CsCc(frOO(>aDg*romL^7-+76m>` z#y`p@0y&b)83WX%ev>~JSLwKPMJyIkny%0Hw#dA>Nppcb&qT&eLFI_&O4>%$m6;B{ z5YjApBCWAT?rzRX*o5?b57X@fyZct4@DbZ*9N|L7ONy=NtpF3dZsh^+;KHBJh#ZN*~tyU{{I~?bhlk-B4^{2Encrr)I?WKCs2{s4@?$a z@Hgc*RlEozkEoy{(csW4bVP`ytKwarF+?ht4uqb<6f~nF2rf{A7U&Z`u97m+o3bP% zexD+>tW1{-4M?YSxr^@BG;h|Qk6z8!D5@WUG(p6zmJ0xmB8`Ycgc6G#3%xl2or00U zlgU>Aw#L*PELmGAKj;(Tx`CYljP!7o7`?a&-$g&6n_lH^SlBx2kqEN=xgyDbp_;P!i>OoX;y(0>RK(1{6I;Wu81yn`{gN2CCo8&l?WvBCx{c*3cG1E*__&OX$cG6798TT=N zng2+y3a+0F3@P|)M(nI59$6H#vH+o<+-Py2u+YF(dy+7qg4a!C!`K2U$|0``iH-OSo2d>dy4JA zH!1t$^L}+Z!VU_W*MZ4xiM}**5_7*22%Dbgl1A+3k02<)NHtgeyLc>cqcqs>a^K?k zIzJ2}f8_LRQ|q6wS2OLm#He!XJl3x8)Bi5}|G7IZKW0X}xMp>=FDFXS(aKSnXixYak8G=>x zS9S*QF)x}WDikhbr9%%CLv>;XkO&6_+bZQ)gU?9eRexWT%mRq6YeXqy0?*7eW@$f{TEr9gV7iJ)9<5--~*FrT2$OggjEbMV%ODO zO+?N>;@$Uw{fk<<_VP|5YwC6j(5;{Oak^K60%qptuEamvlauXwpjS5s{a!?_*Esqj zGfp4uD9iBcrp$vG|E=cwXA3S!_rD#Rnk^|~H6bt^%~T9wT+2>!QU;0<8No53uCb%! z0xIK67zHZh4wXgRINt!W(uoqBjcGnGn`=AejI?)ucJ%*ogFRQIf2OX@6y#0^a|l_e zd%Sm6~CCgSbCya3>N5rad9!JOf@^!u?0VZq;P08vSUXx$v#=S(Q~L5x3=`{2V+ zp`(Ur?$ul()39O386k?w|ezl9FnP|SUzKESB!t)%Izs1ME?gwtDM zb;3Ti)a!~IO^?yc`T&njgSq?bsfYY)aWay64b05;Ya|-5mH? zF9NetIH0oL0;W>{*U~D&?O2;`^#e0)4sQ@Qk8*@?1Z3%^uPzvt2ynr`HSf%FO4a=y ziC;J0W z3tMDdhwvcj+ko@j2HUoxrz?602vKDX)+a`A3y5<`gnS5#WM;F^3$;{cY>KOuc_=?*9&5kH(yy43piyz_SLdm$ z07IM>kA=ht^nL9ckx96yZK5jis}3ct;3rKI2g(Kt71A&@)Scn zckOs@KMW;IAk-8ItVAm^PNXq5601Ta?-y{c1Djeh<1rgW6RU<>7!(P=vh$W^Ec#-` z&P@B+nje`at>hl=EH!v|K>+S*$#Rs9?kwf!oS{5#CC}?-EW_M?9w>wHd^@HCh#!Q! z3SMZwkBW-GuX$!^Le%U0Z0lFkI84YMuwC~1gd)|%gHw}~PSU|yS2iZEizx089kcOu zqcpzVgQTr!z(LuOT$GX>1y{0LK2WOI&D6ZlQObaIfTE*ZKIQAG{8g2*vGapo)I5HvZowFr%-5$M27cU)0)8v-1!OfP%*$`4Jo zM4|d+Wyh^0Czg1rlqx%xjq9E)4zS-ZmN(s7pVRLlFHzW7kXz%|G}G}Qgw;XeisM9- z2a@~6z2qGJb(9@kke-Ack83L89|gR{XBgwn9S(+}al2J2mJ$Q{ns+Up$3FxKwa3bt1{D(Cl~WOEj%6<>k@odef-YtHYcJgLjlhqL`?M`2tY1Cw zrYrO6k=%-{?F4Ur7I5Mm(_YFa9*8PXy1Q~YP0h~e9_>cW4HjjX0^LB@Ycv6zS)BkT z%@x$RDRkmm*pL8>eQO}n%!t$WiLDnC&)E%o_a^cdN7&Cq3aX|%Cf<~e_ek}-9p?OR zx81b0pb=r_2AL>k+Uwqu0*_CWAu4FKJ=Z$`uwmm$;8f!f@EncF3>xj06T==uKO{!oZzb0L-;?T)`%~g9YHnt0?W5N z%dj_da&Dn#gUr{^!x_2<^JcIWa47hE*lnjAXY6uAWl z=FCvF*v@{MMF`RWK%zj%5FNX)K<4>Fb#rZzGyCs5H-R>#=cqaF(e>0X2vys;WL_+{ zGCot52OYpP%!PiTX_1E`fz#>DD=j}?ZY#cg$^x>~pLzp`ZI=8Fp8er^dooXkB;yYt z)ZEmvEK$+BX3yWZ{2Jt%8dd#JZwAf1+vaxjlGCd4%NhBL&(w+SjJiel*^NdGU>yJ6 z<|Gl~&z6-Z(22H_?x!WNi`qCtOM|96$>~$WSimV+d=kV3P3r3=QA&h|uU8ms)R1$dQ(;%xWuK-dm*OPc-7DW( zVy^vsnL8QIupVmDa=lE3lt!9aZN-@>ddaT|KFSk*t9umlIpe}hz24e}C#DdSw^qap z2PlDWBDMEm`(>mwNagl&myWm!z?U0&_YKAD7Y8~=V0{UE+ftvEes2pT0=!~6##~R# zexdJrBw|v$DZ<_Asr~82iPL&bQ*oI>o+k_MSbF7$RL`1e(lZFtdb{ri+Z13;+;ar1 z@Jl53M1)^k@q65j89Sud=x(wJTP9-S_$t{DuX}a)7k~f1s&A4yP{fP8zNV5%d-x?& z4OSmre^uRe>bO&FqETp0jDMa&q@;vo+1qZL{lxkZYgo~nlP7^E!GW!?P9h^S73f%ii~nYeZFz7dt5Swc+bxcE^b?Hw5V_e zNY8GWzZOcmf-13{Y96?;aa}o`1RBmKrltT}Q~GtkvM4m@kFsnubcgLLZ{9$Mwk*$& zu3MytAb>gunn=0$Fz>UdNCigO`@whSkY#d1pR$|6e9qAfVNbu`?V?zOIw+t+s0UGk%n*z4qS=hxD#^pde(i{p*5PL@$+M7W=AqbV1fv<`c8V`NDI zT`r45AmzU&lIL9vM4IN^Pb`HEiG!C31tu5He{OGQN6KKLAbl*MMcgMno650WE=7JN zN_{wTVbeHVvMGY_BF&?ocP#g6|A^lRAU*h{^Oaempved9rul*OSuwR`LWegehK|nN zqg&e1vzd=Q6Ck`2(PO=f3)MABu#r(^E2iUszCW_bH1NTQ?u$G&8xGXX1@9 zeazhDyUzAEwf3u{^9rIV7*3o%D~fn-3l)}wUra^R2V4!pD;KVa=n`G;C#(Vd5Hctx z;uuFD#gSB>enuW;@lI$wtpxOCXx|4FwuWD2!;}S0+Pua&YB(OOI7PL;SKQlQX+vLR zcm>>Kx%C1#>pl~+)KnRg3JKb!NOA?T{qT94yb?$ujwZ4FzxT^u=j+c4i204+zQ)6z z){eEbS&HFt68yW}gaH~hT4I(j>AwZt*4H-q6b_<#Q9R-PsF;y0Lvva!`kE1$6cw-< z^p8<|mpAVW(|Na7z4G&+3)Zn79|EorW6%4}_;nc$-Owy<{0d&A&;h8^`gqkJ%iC(N zg_M6hgfq{4=Rf5hLbwP?krKj}2ynRFFRs zuY@sG)q=URQ0K^jA{5;5fxf@gH2yS-;kHFwXsJ0EUF{NN^H6fhs@$eM0e|WV_&?ID zk3ReLGft`|h90dt;3@GQisYpTYyRus1yzVL8SsE3;Y?gbPh;Cg%BIy{EMH-JRry}S z4QA;!-~5W{D_U3sNlosa^ruzf)ayTQJ6|4Uqwe=k0c_rpjbV4k0jwNQT3}57e0cW_oW;cT^0Q<$T2U@FSCRCrPI-WjXSL zS+e8jv)penUkO_$X2tp_{1`6(mu?s-n~W~F$umyLGvS6~owt^NKquVJ*;4Gn!TUQ- z{hi-0A%w*%&}QihZ^dY{D1Hq-5Tmy#79Ku?y<;f`l>5ptlzzM4w))E)e0DF-d#>*8 zq^=*90z;v%%vx7q2#mQO#`8EJjFRgE)x~Fe{qfxrl@hagOPlvV6{Zfe#3D@GGR0=# z1tdcX(yDIP=Ov;zm(KwlJ1p0lC?IgXWEV|b{Z#(w_TcrpZn3>;$}qfdw*oex#HLtS zu{^2>4v3gmO?OIUqz>|gb;2;H%Fn}|yq%{oinz(mp+g4qL#gI5fKNnQ9R4;GeT-D#Ur;Vd9yt_r=S zN}5B&;lFyM=f2cL&h8O&m$k+0%M%=hg{9pES=$&s!PP5|kDKgrZ}vf$xlS_*d%oFV z;dy{kzQLL_xih_YfRfQGkark;zKp!=J4EnuDbW7Qwxo#(S00hyIhI59R~^?XcCg=F5GKLU}&0KOGD8~dPdd8DG~1E>$O zQqX1>&zng%s&ggK7cbX*yBtuGsCv*9=f`W_+#uvl!MgMQ7Dh)A<@%j>tU{@Wzg4U? z_35B($^9oJ@uxdc^tC$K(zVjv6bqRYH>?L1VT+JCGe^~ z)#Df+{!6i0j{q(WDyG9Od{-i!!}*J*jj6wgW!Vdxe9KSBH@$xLW9Mb{^1?3N9_d)$ zHG`HcuErapPUB14FikGOUes|@7JEA6gN(r%+9kMATy)34la`ms$E0amk_!U{!)J!n zU+%^>N$NE6Gkz5>xvLaR*@2)laC~K?X|-YyGtNN=1ROJ+Ieme6u(h@&XYPZTK9BRd z36e|333PB3d)OSt#mla{DQE>q^C?R-icVBRqCuTsAu#W`Y$zy!mxZNl&X67KtMgnn zzOo#wu08UVnOWitlBGhKUW$M~b8-%5?k(wz|LYpb zd<++cS~BM(VT1h2=;@uX#&wG7@kbp(@HG1HXAg-hy+uozd$ZKHm=KNf>eA!YLT=w_ zxRnR)h}k`dA0*F@+{?m_WmDbPGzsA;{=cohGI$jhbq>wz!fSt%F*`4r^@Ht!ccEEw z9P{z8K^7`FOQQ=X%sReWJ0^Hm|_TKarX2_V23Tl zF~5wvnuUKP{bDzU$XQmS?xKd5H5 zPOqNU%zrvJRa8!tFpp$LEm+$x!yKrZaxcJxf84T}RYDYHRsJZ20z*WIkyWhWm>K_r zJjO3^ZHsPm8ntFbV$%Cwz0^YE6T3PftOvBCg>hF~p#sBJI*f;n<^zCFUsfGr(w2X- z#fCF^O`Fs3w?xlhyNc{9RiMfxXRkg+{^b`K!+ip;1j*GeZ_|}eM+tCT%w-@Cw9X2j zL>d$3Ya+bV@*tw@CqKFpZe1|7eV^;n$}$-Z`}GJGtqTNhb#)C0fgYfJiRxaSmFqtG zhUPV6V=}akG<(z=4eiU^iU;LzlDkFQ#^(^Z6xf#)!|D>l{%*TMc&TAf!q7|xTj~zJQL4Ihqx3boTR+gej7;aNEsxn&1y)6YoX2Tyn zW@>yOX`^1aRNHM<0}kFknHKsV5S@qhwda`DijI9%7jm`-i?yTUT*_DiKp=)mHdGvv zocck$XnaI57+JTLncp$+YTAa6Y7hB@%sd5Wuc9CI2P=JmQKSbJ72m6G&pKznPqt*d zk-$}*$YjZPUuA1;=$ml#-#<}CHC#>Ij>^!|PTl=G)l@uGb*3mOlt2Mz_}m&*JZ-OuRpw{4fBP9F!qn^gQsyOIu;bZ_l3!leKJGe_I$)i%4Ykwt zSXcn+pf7_IpwDiP@PxZwkdCNhjZmO*`t^V9P#7z1)n;j|XCFOwL%o(-v~FY)9+?xS z+l)p$|LYitZb_XTHD9%iW*ebn;EKM==)Tdb_9HDl^Bg7>9$U^`fbQD9%aA2nvJ_&G zq$;jadnH&eE-xmy{9woE{q*#pRMFkgi=-l>a%Q|TexZFBjLst`*U)JJGy(^+sl^d+@!)+Ak?C{osB{Dv7oQmvU|ZVf$?z z$x7g3i=mLI^PKkex8J9pQ6mZU^VY5#=U@Q%{Pv7JOM*bRtI8G3reb^u&QH*VEI;+; z=QXp_W|iFo$z7W?Yd&})T{n1sAc*z2{Eap*hf(6ll6GN1cgS(^y=@Xqb}6Msn25IuV)A=rQM zXg6gc$m8rPR>g^NnEa^9b5T!NXj2fYcBnwaY=HzK8s5!pbqqTdDuN4ptRmIhx}?E4nS}sNZr>g9Y}oiPU*SzC`f3G z$ll+SMST8Pdp(}GX)zAI0odF5=zg%FoF$S9O#5=%5Vd^b^hNc(%_W_yCG7kj6DLfq z%mW+tk}H^b@7A=gxURSjs+v|W!U8-$w@|-f2sn6gMgkYF49n=fURfPPh{p0J(86?p z*pU=BNgph6=7gos_`c;0 zQ=ofq(FlAM$hYDV&@G*inaSqOpZtqendDB?u{>rHa81)LYbmeKCp-JITv)qJIM+~i zeusN$`KruoCtbosw26;RN)07QUf=txAnk;>hmHjyWWAlHFK23 z+rQCkGwF~5rAdy4jEP1y(f4Z3Ml#1Q$vxakkL@iYP+0u!Ji71If}`NS&tuUgfkwwy z|Mfg>7i@XbZt$%K_j_E@ew!|T|2io?hUYb}PUh4+6WrA>KJ2^PqdDX2C99{oLXA@{ zbDk{G6Kp{5@-NA7E44T?T`ytd-@ut^;PR^RtH%FOf5S!M+vHht4} zExCV`-(#1`iTb>swCzge+pG}upm|lSnSXEbHZOGgONf84PZLvS(6DvQhqGXBg?YNV zz*bu*P|AF}r{8rU^fR?UBU9uLg^+vSV2g48)w_`Axp6#*x%ehH5x(__+cBIg2OUo7 zLVi`H<^DbhN3U=^4b!JBk#6Hop*Fr})(;Ee)XZ zj>6Hz9G!FKYHE_L+@0@uEWuzDM&6C zr9X!p(jHpK|H!5CK>Ee8;q+Jp=WTQ8CFVEc~7y_@)eO6at#X9eTE(O(oibD*k;a9!qah| z{N-r8j&Z}uDym)nnIOq(L*@_V5PrpaJ;%a7g?gB3FlX+;MRxO^%n(FNvb93J~@XC{rxJBtc7|5B8mBbhsxhjcR`2i*7w?P3x#07oJ%S z@ayU~KsBR+a^|WN#{}9`UYGq44~zM8B+AEs59PuU4CtzsRd>Ipj?H#*Ra4c~m94l5 zSk7wm-RO5q^E*u8NtrN-y^~ci z0-KT3@(Me*LcuyZ3?dwQkcESC^pH<&OUk_s&h?*4Gi%?e8SX-a!aKN=CB&-oD5e{6 zY9X5D5n{Oqp#c~A-b#`_kzES^78OU2cz-$dMrEQO2WROfubeYzze1PH5kbW*?pHgW z;x7fu-Sz?SV@_pca4ZE+%>fXm%*C;#$v)*}egb&3q+QJ0!ti$w8AStQ#%Gk0JXIQgnrdz;|XjivaypQ zdXJKmim^M0raYcfBHZZXGn_uqy14-Uj2*J%uo@ZgX|AiAHPEM{Vbf)laSO0WO>q|H zO6Q64@oZ;dmiS}7J(g2%saRyDpab27!K<|niD;5vhb_mwGYAr ze5TrlYZKn8d75b{wN~H)R0_{A!{WWYqT?eh4j?R=ee4%nz_yQmFq2t>C_bM4A>w`;CuldF0o&?<@tM4ei=n6L*w{@vXG!D+^&vBEYw0 zeu?1dNJcqg7Ko^un3C_%Ap}3tPkw%NrujQ#l;K?6`+XS1NA>v-Em7sz?3IlSfrBQX zt6mH%c*|Ljh0KwgY{BChY4DBL757zJ;^ zU@l=$bU9CkaGmg%^UJgU;p@HQsqX*(@sf&$aflK!j*;0wHleH>gvyqYt!&B2D4j&g z%pPTr?CgeJ_9oP^clPG@c)6~tx32H!`u%ZrJD1`duh;YSd_Erc$9?qdlAo2RjZN;h zj4j8JtO5DBjZK1s>m(s5l*cDQID3sPlVp{utd^YEJhSLt_?P&#b=WsAWDFqeMSqc% zJLcW*?+Tlm=~@ngkxx_`TA&wu6l)7vWDK+;E3RG&%N>rt-g>hM4KLAG%1@MlS{~VV z>+Yaw5$FG*nwO5Qo8Uug0oHjG73J)pz>741=Sf{y({FWI{L1hJ>BhHaRE9sO=Dg|y z+t_w#mw`FXOwEB!^6o*uW+u&3QaXcjA|n$Bf9?Z8U+4te^ZC-AE(q=->}yIS%X48* z%M5i&Dzv0-acx#ahRy_BM|LD_3CW*+hD5N)T-IG%d#LP+D7Rd!l+WOhxILu6X&vo= zgrl|-en5&6mY7$ju|PKDcIJb-(G$8y&2z2l{~hJ@yX2kZ_GrE=+Q}ksEb3kTSyz!O zs$ajYhwc9;VNvfDGMaeTf%n4<)`!(aP>IR9C-wHSD3w8Qq3>Sw6 zlUzzJV+*UQzNx-!jdbWWz4|IPnFiqi6v%+8)-V41EzkSNV6HdpIu>2O0tdRZk5wOZ z8*RFYbkaY8?csdAB>6^xI@^8NtFZb^KbZT!uEc8exK$YK!Z@g1e=d73AU?!egg9NyQYQfc3z?9<_LM%>(l7Q--TWiYgK_M%1PJ*Gq=KFn^F zhhLk!`g<5SKye$O`zfIRfzfjK!2gY)AYYYXQ9|ik?|k{ObPuKCk1ydnU!MEYW}4Cx zR*szS-hMhrKAg48C(dnr?RG|XTchygNWM1f!4l41Bi zA+q5+&3Gs^AS`4yBkpJ{Js*m1nEO1J|Y-oSbi(<|VAefbTr>e2&E7{L8~6W`PQP=Veaqh@=9%U}_--74D-UzbmL^ zY_N_=U~W8k=?Yn6j7-wGAs`fn^vkF*gaH=#OD8dQ2Ls?ELM4)6AT2Lj>1DU%7zvty zRlc(13D?X6 zKPwR=9a|!#4{C+;*5{e3ljMiyV= zvlUz-ExYjov(U(f@35blVj_)vTY+I_+=ny?iC8;XC#$Wsc~eWJH|3mx-c1sp3SZu& zTCST5?PVwlhH8;s`9)>rEci49mSM<|Fb;%OOt!*?WB5tEoDlG-P)Mc6#_;V1Y-uc` zw!dbAfV6rSaa)dO%YH512V0aCa0}&xSd9A-Pi|-{&GV6NwS&?z=nlDprWyej(ERa*7&Oj1^wyB!m4Q03FB$yT?;} zzjoy|Lkg<(8-?LnXDEG3HrL?;#i$AMX$nOC(^UQiBCk zEH|_*DQMZwdc~6j*S|Q9E%&BUBhHiy^sTooWu$2p)kaYly#y8;xAx z{pQstkj+xGF|@5Dq^3K*DV1r@S~2G$%kW^{Sv6!bbcmHO7b;;vwNj}A#DIUaeYJpY zHJq%?ye-iWbRtc|&9%h1d0~b?Wb3t(sa=2RPisZS$eP9>MM`z8#I9Px$voxRL)ZO2z45^u0*a$&yQ& zwrRWLY|~%(jG{g0@qJs84Xw^Rq6Or3g82b0PS-tEQr02DO(17EAmfEpgE~wk$N|3bPpHA+s!W+GTMS)L@yv?LoHUiBUP3d z@-sOX)m&;tz%C=c5|)AO8 z31PKpDI73uQ+OiSJAU?EnaF()gXrWldzA~h-(z>q+f_TOo?p32zV(zNUG=O+Sc-Kq z#W~1CoSj23`+^umubVhr`OovD^b>!n|Ksj<2ABMW{#^ytpRD7w_;f!=o5K@2N%D`_ z!4$mMv8fcD@&)m0%s8p-^z%syzr(&g+05s01z);Gys=Tf3gf%Z!ye7|mjhygicQWU z=9C;n@* z+4mO6%VEjbaeeE!>U9{=nLc9|!z&;6bq;9okX&C5pn%^7_5nu=x-s^RG}Exl#uyD! z8>gW2$ryp2iM6!LkR2g-o>Lvf2o}G7d@`MPs|51|QzR(O_VjQ}TeiF9Nr4Du!785@ zX)g3v1PWgTMmPn;Mx8JPl$-P=W=0XruL$e3?OLuCd^&RWEzS`lYsY@cVjPc=LJ7O= zHz)$$hs8qP+n zo9Zd`Iua3Us10Cg`cd)91*a9%y?MQ}K!^*PpkD(iioy`uSXNm{1m!g~P*xIUQ-7ZD z=w0WJTo)^$r+Onb0;n%$<12+~HK?CVK&dTxp(j->4K+{o2wSx`jcPx&cdC|a+_p^6 z`5zSUyOiC#%CR=csXBRnD)8Oq0hm^UiGLJD+v`b^y^5CT+5+s=YNXBiReOEpxt_kt zsZfO%(}ofVrV+084aIe$LF)`ZitX`sAF@^$UI@}}g~63Fg%3CUl-9aGu8 z93kW0GIu3IdYpSnQ-rN%aI$a;WZ=^q%g}=st?Ht`Vc@iv3w@k<2r}FJHp?EsDc=Xy zj+7SDpjWhn&ObT|3dRC(=+vWP*!KvUVLleRDr4z&kMU+y$JOBC8~3n7Jc4>f-~hMg58pviW4m+YSTND$trTUY#!^<7!c(JzRl zq=XR)1_^-9W%}xb`D_SQF`jiTm~pq17dFCVVo459s25ljO1G8Yl@mm_R(@3}hHktA z&_3%i0=D|G`y+QI;HYdIm#SCPjWQ^!ov1h=2;&Fu%Q2HdX`6vME`CP|ho8)9UQ$91 zL!?f>K$t#4R=ErhN9tMO(#PE(s|%n6pu^0pn6CT)_75HZ&a zLb*4$%1&!TJ&>54g>eF^5@L7wmDPI1knd#-CbQ%1@U~azcB+*mBVinW z7QKI8xMT~MwNoKo=eIMyt!I3DEwFR7-k~qe1Nn?3V|P#i@JNc_J{5XBkNIl93md`( z0p*uRdosMIeQ~D4GQb4NYBK2}Rh*jpnmCNedHaDHc*au4FqCm@emY_Hr^|jX`48`Adq&#nT9L$`CLq{Rc;}EiORWbbN6G|Dd=n}=2&cbCx z+Ftc>=jp-{Fsg8Xh0rHSEHXU137DV^8E$Fu!HK`uoA?Y0(t5l$72FyH#=29IqRpU} zEhcLX`C+eBSt^*(JeLMs;;#N(sN%>uBnHKTGNHY~Jaz**Q33qScC0w)4=tHlDmF6d zm6PG3brDJ(KEA*JOv%xKnxY?`$G<<~Kpkj8hs+v{fJ<7k0iFhB%jPRMV;)wAEX@rL zmfi1yk?jjp{(a8NN|*8C@_z4)5XLZLzY?jW<)OdO852t$~D=k(DAAKPo+|J(6uGGypgE0I)Vg%8bB};>9 z(SWtwKM3R?s0(OqF$Srq`Pa5@pn~oa7%}b2jGA~-YwTj?m znyd|zM&7a$OkSx_ZZ?BK;s8(F1&B$Bha5(sPZ!Pvz(6$vdsKiJb)}5177#lVwk23f`Vrd3g3!{y(;o4;2Ld_Z}iTpUlB0%5j)XtOa4q%48 zrP@R8(qEou2LtBQHrSHHfI4hD&CA^hE)Xw<*k-}ADErZ;l~>ZVvS%Ywd%2Rd!;KLb z7U(+~X9Cl-QSE_?Y-I=7S*Rg(M)qCTDtm)w!xNn&Qrzx2m{y8Say z_x*VFC{56V*RhYHBG01!wLb>2c|hAXC~$kRZxz~QUtWrH$7=rC89Y$TbV5i)$k6f` zOyt6*ISK3)_24EIp5*JMYY6~D{$7|c2R<8$EhRj0PV~FL6@TZrv1kCu9@*7`RSG13 z6G-u~rZ6IxY9Nov((^u<|oJyzp3YyoiJ!fT|*oW_M z={${&bAz)36Fc+9IJ&NQCstI>#TK9h2Tj7>l!`cql<&Hh5m5~R7HW{)W-$&Har)yo zrsjyGrJ{Nqv2kn3T7Er99$z`XwyM9yTSLlsZuJ8M+7+>+b&INJ4wg_7w zoXnjLThhL@$P&?=I-3FcPT>Bv85s6><1O7IzMk0icpqg=L;1JauPuWs32@7ZvJ=RW zYdnuQ8?fN07!etK|HIFxY6XfDj3pd|s9FjR6{Sb*_j)YrcI38;!R#}QsWdEw2!|Yz z!*b$XH?c)kUKYCcmft8uH^v!_ebYA|NAuSD=cdM*zaKa$xG|p4?|8Id+K^lBpDjK1 z13ucSY$QaJnXTh~APnyV8~xQ z7_+e*GPAk~puI6-m#)VCvjkwoc^$Lo1VSXNu6QbmH?m>7=_y-H;S~l_r%z{7p2I1d z^x32_klyUQxyJ&1tnrHt&YwQO#LuG>#oMwGAR=qt$k^hk^orh{*rbfJApl&I2vaID zz__l_l54kzl}nI*L|hvuzcC^Fiq^YBs!=_X(7wmE5}NdjuUwyx9ZUlU8GYgBuKzz< z66Oay&kl2uHSDb=Va_bMr+@BlcEk#n-1f#Rl;Ac)6!yxg6vl|kT8jGUh~f{#{uEFU zmX=otG6t>&`SA5U*g{Smr){&tP{V!cbpT_e1ipxB(3e937Xo7Mh&DO{N5H<%u1&!b zP#+BcWg9MX7`GaNdCH{Dt)SZQNU9Nya{S7r__z39gSZ0?sLOtwmww`0r$R)H?tGI% zR3?>T6P(Bv_aT|MxBg)>bA$!1asy4vQgh|W3EW_k;yE(K<$NW~8#Gt4KtgE4u$>$c z1T&Q2_Y5~D!{{@SQkS>-7@MSj!ti@}?zTyt+hoc@eor>ape6g@Jgh2-iCDUnUM)?; zJ8XB8s2Cl7MR*%b!I>-n8uzfN zn|YdGmFm?P%IttZG?p0nXcvQVX~)=ZFUroejxoj*-BIg_+_N#`K8Q`1v*SHh+&NXe zH=o~Ed?}^kBeu5AMSa8?6`xXGD?a&qMkqdk;)kTf>1T}oGCaRPM3{}VO{6tf`$^Wu z#C9j5cdN}qpM_Og5d=&A0IbrcNjZUbLVW>vBQ!KQ2*F+H0$z^&>o0aa+A=>B9E6Ix zZx6Q~z}h1PJ?6cfr};X5PYq&<4e&F|*c}W}593uXfyb{;hfGVLKdeAKHacyBDY)T$ zByFdDK-T}~<(^A*TylKq9EH~+jZlu9oA%u3&eRst1lw!_)}NVLlF-scS_V^(r1(o@ z-`>tic(r(qFt83YjaU+4Q%*6+EGbx2&O(pn;BZ$hIBh;KBM2YgPBC!iO?^xFtLa2^ zB})m1Uy?=4B|mw!IkI_g@X5to&pxpzU{gWMzlBe@9BYiCHk8jAGKBXu8f>xv#NEkRL)!@wy+V?Px z{9tYoj5Q#%t8fEjZVQm@&kj%uRdK=PmcrYxil6h%dD!JB;#zpVee=|{=_6_|e-Ho; zh#)q`80FkCwhN))4HMdLlamQL zoe^$#q&vNIss@ITO0<9vNX6)Ct4Lfme?foojgkiLpOcD}7!T#wX-gqSjo=IY)?(2^ zz4Sn&r|brGR2Zw)R1K05%i!;|z#Kc+39XcFJelOv6V^@cWUr`^79yD*%AEJssg2~H zt0%6QLF}vX3gYFHY={?Ue~2(*N}KKP*u%e@g?+0S@+DDD;F8f_@@rmjnJaOij^jFO z@tyBrUNNOJ`O=Xn`vbpUeNX7muoJbopO9yc?2iJpRie;{csysOs}V!x2CAGrlU@7D zU#B1hMBT4n)!r7xJZGc2b;cf}e-Hd!a_RgssI^RPz&$lC3{KXh_pHAq5-x31`c8oH zs7}jwW!L%Gqd(0eaEsPUOm{26BP_fCA``v}+;4{>wJuwwy?kwpi`>^q>@UvG2|OF- zW*`Kqs@aT#zj(kug5#AsMg^qO!>|k5 zOa6dIr2r;Ie9G%ca4i5C+IyGz0m6U>&!U@A&9+L|3uMThYG=W-!Er>K>hVUL>1O0* z9KKDu?WVE0+R9;}dU=JFM zB`1)1uOeYN{|iVTy~)Z6IAwu3`2c&sG;@#vBerZba=yzOMX#nA{c!XQ%Xqk=PAinS zyo|BNPZ8TW0PP2hkQSl@Y?)Dm6=t^%6#-@bCjA8j@E*R-Oj`Vp7r<-z@Aos6BGBz_ zaHtD?nr&WB#eq;)*1{EnvS%Hm-FC0dDNGc;aXU0w7L@AgW{cRHJ3yb!f6z&+tn)h) z3GLx+3FwXU3=feaGQ~*Lf zDRi*M5(7Rl9#_jvM-oEzukt^8=GZWNz+9ZAhoJgqm%HqCJ4i!6xKelaW&HBTV1$i| zlXhPBLB2m$lr(@W9MF$qF77+;V@2)D;x|(%RhB9JEG_N%Y%TT$MxQ}ib9~o&S?nUBoVwv&nngUHicTx>hZUz?DX+FZYd+A%vOR4#GvOsF(3o2fv z)@Y}eNM7Rp`jKU0@MxRmjwzjY0VBh2EbOL8trf)MA(3@n27eS_4Lf%mE+GK3`@r|i zM!)%;JZ0M;I4oG$jHB;{f`{x_P^c8_rVRuqz^9q8DurB|5|pD;mG%j9#=PuN-{J34 zNCN0I;VFrvb4uis<;ej<*A+x=T`~IRyrQs9#mpA3by==Wo5B^yJsFC8R+@QvqfIE` z)dMZCh_Hm3EEgP3t2dUXC@m7CzA#;1h4=4K$%`)quTuEHFI)o@V%f zLjVsi z?24l%<_Z9x+L~{^vIO8XSfC48HH-(>4VMn>n7T4h|AXfKKPzY1L%b!p1Q_1LZIgwf zPbr3$TZ#Ws%>BKzAQ$l$O~up7_wr@LdB{ohe}WIJK=e-%rq_&Em{K>&yO{Q3 zpmR_M>_f91Q!8veqW6D@*hm6zx0t7HHMf!!5#RiYEMP1%(;wXiPYlkacn4rbx5ZTA z(6rLc`;nzV5JR~;P72Ur&}rV=t#BG*knIYOT) zOz2%nz7W_;LxYrJVI0oHvb7I?n&f)$!fZ>BoJ_YnW<(9XF6yutV9aMkbqsF=-)j`V;6v=0yDRSX?;e5 zMu1J@$R#Taw6ONakLONknBOk_s&**W@QFAUH4er%;27pC8OLG$##fTgaFHCP&5AKkKK#dh zeJpN;FHxZ>QDI=qo-wHkGVgo@KnLCwrO;1rvS|RQE)Bj3)RhC8;TEeuoOgI+cVN`2 zfz5x&DUfiJY|_vvk4oIuluzfEMf=X= zOYl70LtF+MC_UO%K@wK{me&-ra!sw{<^)Z#$VOD}`4O?fhk(@^=4tq7MTnHhbK1kP z|K9qM-|@htdY@1hNW0I$fSJfzbh=*nhpjM1!s)@^Q(`uS&xhqXE7Qs=JlGTsk4^PYRVtq_bHK=Ti5B9bTHX&HKm~YOstUS zE^B{!;*35>CGr8hO+48EPeCXJvLz_p!81?Kz8){GebhzT9E-0`lt&9jL1dcHlt!_3 zAcS0~`f>p@>;ao*%evQ0*VMUNmK7R*BEm4Utl-oaE}bitNb+_*q`bGqyAm1#h3Yf9 zb`=J<#WR421w7HSN%5S4Dt(yOUb3-!Hl4W}055vxwPL zh~VSJhG0vaxWSRm()NsEMxi+^Wnj$dPClWAH!!H=^{@hZJKx>U_ z-7kk>#lpr3)~wN@LCT8_w>h}XYJdSX1L54+Fg=k{wkiRPn8n{d)?7hYs>{QP8gw7x z56Mo0y`%{EewlU!8TboSBVk^fVCGw2;+6M5?M(Yc&^q7SE?`ilIH;=>cgLJA_}Z&~ zQD>@{fAn2YU0pZG?o-&aLi^Vp`TNEnlZ6OSiPpF2_#Oda5?j|2r1bX)BKy`w5X_DX zLF}$T$Qzot@9TfQJS9Ol98}|2twFEN`PJ%&ObUk&=iGIlXhQO~6uW_w%!mHj?f(Wy zbP2sX$>F&)Ckv5s0sh*|4tSI6fAJwM{N#01C_4e#r#=$jG=+^I?LorYi+Ppbk%6&z z+|=VvK|8DG;BQYC0PUhr6X1dk5Fby@*<6g|l? z?1BFU><5XbK-7n*ma6?}%n`S9j9PM2F$Gd+V4S9bXLDuyNvB&p9+Q6;01#6^hP0pQ z?SPu?=LVNG*Wru~F0BvE$f=09MF0b~h0sp6n{zNWyBEgP>EK_8NJawnLcrOp`d#*G zrATiZB>EePj)#@RId<_|A*b9RAe4>`v#_~0yt!P{aelPw7*!UMzy!^`B_a_Z6A3hl z94&B?`EbM5vOehi3Y51!0NlT}=RoF;EIO$I=%-X^76!U)Zj-t3MF~w!&~;nE34K?= z_gk1d;4xM@)nw0nXTOBUY`hq^J$typ2wN+g&KX03I@!LpMAI^+ktoU%C%}{~CAMau z7U;a4gHR6SydKY5Bewp)$$e;g61V^eJ%vK?_gOu1l`apXPRp5E*k-d--#{6mddwqQ z3v0*;&psk)e*_^*QNL~pYv*w*=Oy?H*28>C%zU8qVQ+XXm3jJIh&-`z2hvdvOagj9 zgJ%*0WI9!;tA&80S406vpa3j3dSNDjn*@HBc@*m{wNtVtH!K5{LM$Z2fZ~Mc3!<8} zS+npzAo(!}6@|?5_`4RWS5h5IEFM=zUYSI%joCJ+MIa2tEK=`1D zn=v$d1`a^J;wKdlb5(e$Hc0P7tqY5*Dyfiak}s`qg(@UtBy>3+h5sF0 z&3y0*A>l0+8CFGugayV=rA`87F{6q2KOl435cr#3h|_=rM2Pa=EpgJANwcK-3Oip% zR4-f}Z9&3RwNpX2Ki@a=k-``^gsZ7h^qD01A>)Y7VtaFzZyyknH)2!;7Ur3k?w1o* zO2qg&HGhu)zvc{x^K-qo{O|?vhIh;}caRtc<1`yxJlCDgxQ!Fzf=W@b1)D29Y|=6J z#n#O8>ZgQ0uI`PSg3bZ(;q(zQ?u{M${R-Uxl6UM%@7-`C&GP*pII5HabtHLrx$1z) zrspw@H2ObxEfQ9Hyq)`$(T74dp0$Yn*AW`aM-b$FCsL=AP8GTbBf4dhq3rsz#?FY7 z)j#XhLk|5zi1Akxk*a>o1lj){gMAARS@5g)5)P+erP>d+ZuEFI-_cuDeP~N>xHv3y zJGE4&jq!g!5b5T=6TVMWnq`#Pq*oHb+nAPzm7>5$NI|E}f;GQ(RRTD#^G}e0p|Yx3 zU%L8bmP}^l6fMvCkntX1R~y3il+CI2;X4D{zSnklcE2KV5xf7!%JA zVO8o%JnTX01{@c8^A%5k&DO0=Xc;7A(`b?e(KjdseyWJ*yTc)@4$fT`&?z8B?Z)JU zeK4S(1_3}G;(?6bT7;?j2uE~M(WCjSMQPllB7Eymk{?7B$Epz_0%%_F5Kjh%H1AoS zxrBU8!hUSbs97Ri$xp=n2g;~nDZ*eYpygr$tN^MrjW<;mNR`xgLn*(QtpbwK14wGE z#32Vuc;Ebckjg}W^xAv~jEO9uIOcos<6|ZD*$aA)$^4gSxU0X;uktoQJ8FH5kb2{x zWX(o8Ht^ii`n;rxA0L&X7$;1G;Dr7F^Muw)TzkSHBL0tDWlOCKv(y;~4*XX+YcKP0 zS0pL%S4k?-(YGO~{+%}QxW)DUb0c^EWt17)jgM3;Qo%d-BPwP8edzvPSI`!qJOW%5 zIMq&Zthjq-=bt_^dEv;le1cLUU!t-gva%&rpN4p|Kh_NpNKjw~At#02zwiD2h{$e; z@DZOf8@ekWS5q-0f<>t)V8|%@hIFk00ZPLvU|zJd&Gn>r>89Y;(~&@Bd4V34_7r_Xlz>YKEBEoGr7(-LMq^YM|A zcG$iuuTGbh@3x9UU{Q)|c{n!*M?K~OhvxM%6&B^aF$6s>m{V~pvey~VpdRq}REf8m zU*zqf>^jAM3;o;#PWm)?Pivs48wL-Rz&_ds1NKKOnIW>J7nDC`9fhHdBi@rZfr+G( zG>D@xV!^*R{Z3-C89jasJl4Cgn@p%`qJr->@_VFG03f5enThW?e*b@I51_}HF*jhHC$`*G~ditw=_V%8q z<%61up*UDgX!Y;NYA&|akbvUeBZu)9=u~^bFtDu`=CO|=q?q@75dU5^9gHLzlD{#D zgYF`D5X^q&Oz)p}z>pD4I{5_uMHJn4C{7-S2)@a$GF?~2B&!WT9`s3EiRqt}xpxQ# zTsgSQL`Z#N*e~G3AE)BJ)gjJH;62SIu|nCw8qRSTu`#ATf9ik*_7tfz^AE8rtl7+M z)c;yHf3RVCmRp+;ma=0N7hW4TQi zmkzVTJ#H_cuhC>D$-G#iofs6J${n2c1E0sj{aW^(cj%@Rguo{=)5#(=l2Uw@7`oY+j0Rb~s>@vdGh zf)VjYu;DsgKZ*kzDWeFhVpH4}FeqmL#8j+2g%gkIKqkuy9EfRVE=;!HrG{NHdJg3V zk9|4~w$~EeSFj&ai2#S(D7`JsVFkj(LZE4gaAsA@%`AIKO>8~>@+gL&h9sF950txl z8pd|_X)YPcXbA7Ij*+Di#O)E#ps>D@xTHy|A@->{WvPa9kYZ!y27N@5%U86>AIk&O zI*1XhC0U}&zwYqw#S&YL)NFw}ol^Fi+FmYI(+^ID%XSJA>IsLiTzLH_0>UKu(ect_ zFOSz}sHnhIY2T*y`z4GAprt45(N*Q~zBHu;wOjgeo-RfbSZYGI7jhmT3BCWEvB)0O zNcd|ruhHl65%E|IfeDQyo*^`m_MU1Yk5=;F$xiBJ$W8*Mq&EdfpewLjdO%VdC72Zj z4{<#bkm{S|UhA<5V1BS z{pLJxk8&BnY4yI3MplQ_vU-SetR})M%rlh_j(^^#*7wHkXB`dJz zcquJJ{}EVh-LPIQiG_bXCTsCU$pp>7obf$WrRrei6K`^R5O&q5<^iD44&gek`+0SC z4!L#%eq@O-@(qfCL{RjQq&Sq#3ej4@2%AR@VutYS$`8ciA0CQ%Md_ z7S1o_>tw9=CCK>G=L?jy&`4a6%Om|01NyzS1uG(4oo_n3E7xz4nxC*g?G?{JBu<*9 zpYBT#k-Bdmg$>)2wE2Gf2U~(u-{et;zsO(xz5e$tM&zY91!BqqWclIg}+>_FaN3E#`p7e8YQqhO53XN{}OTk*X+KJZo!y@ilW6Qe>u_93z~ zI05fVuwovfC7htE=!Phd*VS%*yqyp5oaHDF`^8i=7J{UL*?T5FkE$>rK;2G<;YE3K zY-5T$%rvpDi!$)Hkm0YCRvZzUe5~mr_9O-*P8r7m$V5f{X-fCHPc+tcMp)o>NYo=QbvF4Bm^Q@D#HYvC=O_`QP2 zL&QxiyWNco-t*qn&<2ujyYBH6Uq0o3d9!+?5g0+?&CFTIHZ?@ z6}49*vXiGsSuxx6HL_3aY;+=Zl#c)TQwPCe@#{}V3)hIlOO$x`5KSMRSLVr{PTrM4 zclRlX17~OgF8(wCyNYC9zAPI64o^dXSvFY0(4XS`#Dy(JaySc2TH;k*6dYVUP6I*H z*-{h1N;?p2v{JUYo*3-xWy#Jgwk4lLxVjPt>1qZH?DR z%|Hwc{%mAtc}$eZEs+UR2vM^An zvD1s@t9a_U1w6YWlRO8iz8nDbE=--4PtF2-1v7l1JUa6dlOcuc5riak#eZHP4{$ai zWie|%AINm=(J;?A^-^xye83K1ong6lPWf=(Iq;vZ+D!KZnsVI_ zm*B@SqCQYc$af3^u5(3NQsQ}vR5p!(X}d8OZRHwp%pd4mi*5b#8e%RnZ&(DVCk&sJ z$%N%<(RDwnq7MPu1)X|KCQ0V9tZQAIuA>rD1#zWF8s&(rc-JZb$roFkw2vcYC`)QM z|9&i8JQ(^`7VsuwJI-)bmh4v-p~R3*D^0BRz7++VPZ=6c>oRHw!T&JI_Q;`Ay0IB< zN4%E*g4OWO&2L0qHmj_n*XejVv)iT-hU2~tfmIg9PWU~MdO?OPCggvtpTByWy??9} zf-k|xQ+~NKXZp_JD}p@tPJQopZpm-H49Ws8=Yw9DKYyx`B;C?xkfUJzy)_e7{A1UD zK+z``^v>LiyO^9QAh`|9t4V2!GrS9`Uz{-jM}C>g&7;NTGU#bgP!vFy_YNa3oCc)R z!(_gJ2h@a3`kA|yTLbi>bO!)V9jYqXMo6QU=fDCxLdY>wmV}+$3gr0a;P3??+OuG( z6$zXrBrVE6t54xrmW+2+v%aO_R|jmr`-s=XHFH%Pe6F8aK!wN19z(hCDaYY5%F99Z zr>xq$0+p6M&J#u8>)FeC^+Uj&?|{$Ec=yNW^_Ig%y8`0N$^_3%eNG3k6SC7cRAwM- zOWA?qqlmRb2;$fK%+fOA(VYPHAwie=kxOSt`%*peN6;aZhew3QW4%x@+}W+h45)P9 zRtkM~<(f5P1*6GDQLFDC^yY2eufe-P^2V2&V@v~x1>Gaiv8q`2I4lXQj#X@AG_4~( zz!vJc(QR9|OPE5&b#voiOr_^y@}>&Rj_X?!qN&AWaRf5L3-F8Ddj`%oE|0ey0-^@V zo;(z`6C)tNp9MA}T^`@J?)L2uC??-Ly!ff3XXZNGXNP3I#XE(B`~YQ=osoz!ag zpqc}d?|WDrQ#3+5jO;?s6^+rdh@R?bff8z}H$Tl4+~2S^X^-ARKfsbx|I>r$eRJ3o|x-1Oi4R4|NuZFc{7hjj_fk z%Z^mF6=0knzV;b>f^9qb5jzCT1qHl2lehVd2Y~gSjrbS$6cQO3s)6Yf@eRjb;jfbA~m+isADBJ+r$7C`w_FM`QQ<`6ZuYN8TS z3j#@eRnGB>ff_ghMeB>dd-L#iF%l*axTeLEWuFNVADDD*4WS@b9HK&K8a?d->qx!k z(kuFxhZ^df9tEk{USCwjlW$plyrzXvj@!&mLkH2QZ(Uys#&g4KXaBhK$f7%l?=r?Pi6T0}rl&XYU-YH= z$Kti;75P{`88yFqZpPpr#Ae2S+2ML)^7eZeSgkAnd!obO6 z>+z8Fl{m9a;1!Nk{=`M*Vfp|MMUqqyVHER49>OYF0*LXnUV;80Oe%|f7i#}|mKc~t z-jKLAPdDohskADdCN0Yv=AR}FmXZvjG(m_?wymUY?NQ>?)6svMChiwF^!0*JltwW4 zxymD^_oGL3(TZbgFS+el2A~d)n=0HmJKxNwA7_d7UO|%2`5>7<${rQISk;0++9klK z=MbGmrK-3EC%p%El#-$33mxZQ6(R6er@Cy!rYhw(oX100`wu4>PF_qr(#I z>9NrhSx~U^!QBC8$v8i-%D_ICz0fp9yR0x1Iv!l{G}$RwO^&|ZG57;nz`h)S2SV!tRz)z`O6d2rWEx$C-a{Rswi#LF)G=d*6+S;l5qt*{(9N;DTnH(7 z1Yo;1E#cQ|ad0wQMaz(2hKkllBUq%ygAlcWEuN=xw1kD)ZAhrdfZFO4ZfTv!wb~2o z?$_=TLNWj%_=q;+^JuPslxdl7iZLPrHbJrRqyD0dsCXApNL?~g@LjFKEfv*-2%QA| zbTU64y>%-%(cjV%n;`jpvsjOKG;d%lM3rASC`r%!sB5@d_E&S3nd`X_P=J3{SG^V*9Rer)uY ze}9;N?{FRm4i2tozXq-do;sEd?_hO2L4bVhb10Jrw=>7@IWUQP?x~Uf_kAN$bW1x& zDh$4w;+wMLACnYkxHlim>xVc7fd2>63Fi4+r?3lmB?k0wpq?zy6hM1NaF zg=WmzQl$_5n39-Yne$@Fc)YI#WQ4v)hBVGA({GsZD7Ymz8zQb0BGnQ?jsmxkLO8=( z!POwFlP|vv+zQ-QsLuI*0)S3^$R-}Iy^-W>$7OJ4VpZ?V5F-xa&r77BocpSw7tK=>I2E{kTPH7f0C|jskFseC z@VIK?<2hNy?E^RT-8xbXfvZ}GOmfgJx7B`4bwq{%My~)G&^&)OWq!iB3B}EgHmy5( zCa;iTDG%4q*!xsL`vFSdK$56>Gj$7VJM)H8!1Kc;iud zx}e%;zmxMsJs!)-FEuI4q$B6U?TwAjDG=-531Y@b6$lz=(yzbfPXZ_Nth_lzfz zu_(xDGWjM~n4iZ%iASIP0pij*L(}(r!u|7`9l*1f(*tG+c4I_|6D-4o>VOf;+=^gX z*dZ;VVZ&0W9I$WcTi#1~QWK+BR)D09?#<#2*XkO|%PfYIUCQze^|zD;Bpi1e80XoD z>Y1=cHkQ4TOD7h86$uRjzufokTSMnCk2%Vt(+WDPi(8Q<5ecQe@~(Qbob`_C4}dch z`qTTGKX~IV`CaY&oW`HBdJ1fPGGo_zplUFL(@gGL8_bh?{DLcgxJ3L!R5X>((bZRM zhHF(DaBZMYxe|>ufD*PTffchdc1rfA1oO-~>YZ0-wVU<#N;zt;)MG1SPpGe$&5G=- z4PmI27ezMMhaV;EEXx}CL|(tu;f8eHBiHnx6#I09k%F>P0{#2htd*l%I?K5vBw|h< z$?*_x-kz1WfUh%7ju!9apG>2Af4KdFFv(SR*pB_Q{|5cmC`=8y}u*75I3q?u{VE?^0R#_s{Ggt04Am3mYEVICmh?!xPJOMk}iMghw96;Xm5LVVN9`z-D_xhzam?M*=uTtv>ReFr8n^GHHiH?y%TJPH1p4IsOY+F%}WDx zln4=n?zveNJH6Zm*K2lMl+YWpntQNbe((Q_q#7z_~FaTz5X!O)>1kConC0giv`lf$b0{=30=DamP$6SWI-a zBMF%mBHU6sgHj9k!5B)EwHDCj4CazJhv%W33ueU_cyc=85gsK;mce^d?z`3%|9o0F z>VISgFqGeZ>Q8xgyVJiWTXz785)s;X`@}uY&c0Rz=o5aAcc~#YL9B@*f29?4JAWK7 zzt>aj4hd_bs{-PJ{pHR#BA-c?Oa}t*7tfaTiT=$OJr9PAE>)kz&%Zov`5(MQ@evY& zo@Q7=fg7$neWgVOxZ>HQJu}YF{&| zXSRVFq$RE|6QtqD4uT%QjYV8ExXz_+D~Fu<$i~iQ3Gi{N)a*@`G8*hXSs8X(iIuqd z#d+6kY7yr=zcZJsfhltr#vCbRlv5zG>f6AX;2uD8Ak^|9nc5E!;o%ROGgwdjx>@l3 zVi8W{n~3aunjq#EvyxAnQo0d%p&MYBNPZ2=^fSgb+bUvAd83Q3e`&;d@dMr^YFZ@<&_BfHbQLu@_txF< z{$M&w3(j#4->qw^8p9Bh&}=T#N{=UZ^V_1^CnC(;MJIAeY^dI3%pfzl`j_H~V-M!d z?bnx|BQ6QZ{hmB`aJK*5#nHI@L)D2q)rkQa%^TN*E4yNF^V9!=3Rw}iPq&@LuA64u zmj99}>?j^*e+Sv42O}XR$y3<<_V(~cnwExMSKD?EG z{oU`C>9HY4XJ}5Elb@31GFdzrmrdZOu3Z?oVGfMF8^|tqk?G3sjTG4hl{WF$8Z5f{gFgm7t_q105G!>@mNda^A%(++jc*9Vw1)x@^Fp#hz65JbqaAMJn~QRT@G zi9!fONKXHgT~~_j6`cc}W-|V2jfi*MCiI_}gGTE;SO92(1?)^-8%CbJ z0=#uPOCQ>@j8mLSnGZ10aG~xkur!CR;>GLXybeJ_AQ?o~hF3Nnqj6DwpS%TgVyP1K zLV9Hh?C15Xa};vJoT7YSzm*5W!!b^Y#B5}SEc=VY?wo4B*)C#ac<3n64J<308!)E| zem*^GcI6b0BXsi-g3(ZMNpNIBo!eRV$Pr2D0@EkPs~;!Yl2~xZtm&>^sqhO|L~LDx zC9G4$^tVAj`V~6uD_7j(9kA<2)Fbez)X0Mig1aLtxKb}6j?sB}PyBz0jZx_i$aC@- z)q9CgK#*2V+^wh4eL*@?rlh|wI4dW#qIKQ;!JVg1#q(BxQ&fByfD0mjv`NSoCd0kG=V0-B zS-{-zl1KA#(o#LGddBO0|FL?M1n`GlI*92t&%*gm*(Oe?Ft$CIHRX@DC(m_F#qbRY>FXwjj=9jZ! z81gnaBI8ABqpT_iExNJ*xKEV{mu6SNqzBDKNnHLbxVIdvLb@Tt`99)90mX(u+Ucmu zRCLZ2@T3=7YL<+WQ7?6w2g;p+a6R^$><@NYbP#L-T~4Z<+d%K_2AbP_U`1yGI@z09 zx*!+$K>ebG%r8#WEbiHNJgB=DY=dn;f&rN{b`V*V)@L4~V||+TP_YZXS7dN5~6e#tuipS_FH zOTxF0!cvV+(|g6Q$=}V_5~-qm1@PZBZw0kKZm0Ms0&ksX1ZSvDrAr+9k97yP{MRml zw}r`r$9DwV4wWSBnJLKD_GHh=l=4j_S^VpegriHtm{qkW2#Mz9@<3+dR7q2hrAoIP zOVI~_agpau5^{+KOa}KNWEPBjm5YGRLE_%zjL_^t1Ix6K4r5pW!d}Gh z6bzO>Na@fd_ghm;P9e%(!~q^!)jnYG+(bx8tqV^W&_pZ1VM>fzSa$_x&ZuvK?3RLr zcG0oH8JKM*isfs&p5`$L02q}qV>VpMyR%YNC()@Q)1?xp<2>;$ugJ0bjPV^PQMUEH zYBa5i-XR_~iR-a+pDs7_-!ONg@&azn?(vXQ*SItbz99jykiUH#Fw~jG>)2!_Tlg=Q_ly=?{bnlU3?)S zxN6;@55@EGs-X+I+eh38wFan=C(TzoS7K&n)c-*Kk038jal3)PyK0+v>!z5qBKQ9F zalpfd>Bnw}vX~Raoy-K;|MUm)m_*n`#ly9?nLO6M+A8Bxb<&@=X8$>irBk{M(KAx? zk_p9T=a&BylnIs>CsN!du^AXj`uTw$|FkdeLFSZ(1kwAE({J`2dV6(p5Xd)1T|Gi? zT8SaG&@pMfs^_P$pTl`fUo*$Qv**HMIMs8|uN;tu5=g|xLFe5}|H z79-vXw=%WfJj<&41dr#pit>{*f;{H0Cg%X?GNKW3IFaakyiw*yI>?L9U*#YyLpYnA zfbr@LIK8c(fGL@9{fxXG2W{mL@B>~*7i~akAPtqyZ3a=h_h4Ls@a}?6OZF7)>`wO| z4Ldbb^l^Sw-C=^G?D#Ws)90RtrNjyKeXn0LkbOUpe3ALnbHZvHGT!V;iZbls;|@#? zjC7ul89en^Z&C&@%lJGwj6d5TRFwN>p~3V~{WpQ#htWfC9*#w1ZH?B>zS+JvP;5UH z{yd5LxLmVA@vTuysX2Nckr!HGWQo@Tk2wdv=QZ#ACbxDkwMJbUy0GEYw9Ex2-gI5? z1|^MM41*-g8U^PhEMeKM7@&~KaA79W>kBh$ICM(8R|S?&-MAFH`|@ERp;h<$tM{6s zIa9QfbPBDaf=@I(x<3XnR)@sqHqNZ>aJ|Yfv>s^k-2JBB6t9O#_{r%s6cxVxZMgOc^ zeWMk1viBPDjr;%hum4RF=Ns!AcRS_yNB(>{H10FQv~@&EJ38S)DXR12af1iTtl?5Piqic}q}5A07|R}g;2uZZFL zvhM@Xy*#|u7+%8?8b=@S_9HmbYDt4NP-|FiT6+2o$jcsKORGzP)|o53_6AwXLrOnW zR2pmr*I<$2dVv{i2H`Jea@cgOQv!TE0wK&e8!l*)^G?tTcZW7($U;mP3c#Va9x^;4 zeLi$Xbv<0_HGlZ9$lTr3H03*ptZX395o;=%LUAhz*c`IpbgW%trq8cplMP&#x)4rH zEhFBPeuTu_VyK;XbkOvyGp(I)cx7Wza(;A$9arMR94h(Yjl6I{?HM;URn_jaOh?{u zn4GaEo&^DMh!)u5-^|hx85HGhT}+D+**@VE3bhY*_27iV89&G%s~%V?n>uX_ffVwr zNxR&pD1rN)yvBzk_$)6)+Zw+y?1Bg|*0M*d4on2?f+viF1pI z4^7p_k0}@`eT=Zs&U!h&E#UP-)o=fuG$p;jF^u+wW%$wHkm}?=KY~o)%A|#s<|nYsl4@Z- zHzS|846cqcP;$O=-CPN-F+t^mVoZ7fGS%4EBbZlGH48KI008xeU|x3R2Ahlb{>zzZC#lG|GW1nbs*Lm-@)jHzN6!!KR1$_V(mF@at-U%47%%-uOg~TQ&WF<*|Q4>fKSn>wS?x)pk19nqe)n zqUgR6_#JS9kayK~EtPh_0qN6e&9xrX2MRk=3nChR3czGCy5HDQ3 zsf+_1%SD4Z-*<5*9$jKAUl?qP4)n3Dww+1@f4KK+O((yiZ|>|`;b$ zHQ;chWhW?5=|{x@7IZ|ikI`P4lUJy|pkPLDEm-83E?iqpT8R9XJ;4?69RtF?S^D)H zjPyd^xPIr$QZF{AwDFa2fv=%C8Gu%4AV%cNu^Y=&$$)&1u;(=o8$~cRx_&8ioo=f! z%Q$2XcOF6{z~m^Xd)>McR0Bg0>)%{UlRzP}d8b)fS%Z+lJS%@k93FGz)0XEAmgThv zpu?NN+?IW1BZc8wT5bGB=K4aWTQJZF`W80cF+7+AVyO%8;4>x`ik&{?1hdI)4A`>M zdE4B1<14;?c&t&QRe$BA0nEbs9gn_u_hcm*l7Hp>L-h|AWqm4iSL~M zxK7wNf$(n^jf$w+{PyiXy0dyku6jic{xZ=ot{m_%Ih>}JbqPdOqZ7ppR6q#w*8-EX z(gYo#gS-j!o9fE?VCS=b8o8EC`-=;MUw?X$CLL5%48)$tL z=@jv@AAk{0j8G|Lt&GarqdRA1P_sIt&2+aQ{VPb*ey38r5pqX3;*8u8-teeW%)x?^ zjnX^9h(RJyN*M2TIei+3^f{j>$dSO*T0YMLW@QD_)xThpOV7)MVIYaY)Soo3DHnh{ z@OUb1$Ni{Bd;y_6STQAyN=YU1jg9akNMIIVC~a-jgmN@3lvyaYBL}Qzn{l3kb~iiq zh>LEvq1V{P>HaIDhoH|m=Yc;k&%*_!>VWa()iRf5>yyIvX$7?`mhc|k3nyFikz%1- zl%e$tz#{35FFQ;*R+bTy$`bYE3d#B9S&nJilju7s9_233wIu8@WM*#VD}3g5_u{4 z-!H?&i-lrJb>I>yuF`xw)rF{{fz_H+ElsbWAlA~NF9oe#vDRp{w|z6 zYkt;U+#UyRIYat;JR)ow#4+u!Z+vJ!9!(_#qv=@3J3uL_y{d0+5}#ol<9Ky_v7oFb zL;IaRX?lyO?3p>Zc-15eZAAjE5Py;Z3vQ{|5!v$wMFp}!&1-|?W&ZfY4A-;gt_WE6 zvw`F;*`s?w0;N(W(;4^RXon~upjVNo(G7img{&7tD?AcG$wH`w zs5_BfY%A)TIk%suny9OXj~R3I&w>%XHn7Bkm9V*|M(4*{M;yvlqv1+!4sEJ$L;Kzc zdT$OaChG!*>uqyn9NoR3oF4&;$`qLn^px3PDWI&(DF|IT^e%!>$Fuv!O(OXf~o zYQJ^<;m+3jBf~Znj}ts-SD6-we}&6&_D<3`jU*5QYErqlPwZXMYB40k4Zekn9E4Q{fRP|gA=u?~>u;k2BFK%g|MKA>bv zuj$Bjl_g192oKCuPTW8n@Cmhp!^m0CgoZ+XU3D{6<(wjyS$#x;46!?sXte-C5HUJP zfJ|J)QPwuGrccJ3(g7fzTHtlCgRfrcJf>4#Uz@na&4G`m52V1R^jT82G06{!_hZZrvUg6xe^;c`& z*hayf*Bhd3sjBi|u&;Ph%(XbviDC)b&Gex0%U>^RYK&u8s;k_XbFx5+A<$^V2Y;CX z--p_+(E)*bu%P~mSh8fJC9$s(66lgp@mAYg;kw@e8;h2qFq3l(maWCP5|~$7g1GsX z1Jf9_CO#3}i~F`8;^QRarYRs&z<;gpmHOV@w0rT1Q?p{L%aa+OA|-w%!_w>*&R)c5 z9i%#ctpRUukfN@|?vM1gV?%pgy+L^vb!|7k?fJ>$-r+FH2WF6C2|DYBmFV{?u17nx ze(-f9G+mE2zUsMq0>n%4O{|$_^ott4ocjQWW;n@RXW%~EF^03lH7bJzVD=>m0gDcq zc4=6(T!Dt+b3m65EPG!x;KjYp+{+VfH4 z#?rdsI#AIvKwlvUq&YPc?WyS-8!g@F^@i^d?dkx`O$1eeN=r#xV-|y|3nYRq-7YXa zv+NdJ<10ScUG)ZWkSG6FDd-=I-5sSHv|wl@!&KXNEZtNIjYEL;oG_oqhDs-pf~0@En|G%@JMc+(;LUHBk^rDUtjAJK zqi2#kmF#?zOz)m*^)y?Ny4^g4G;vDi1=p5x0mD#f;chJ}sA-#GOFcGE35~slmX$n; zk|p-jHD9CF?qx($a!>ch*4R9nF}QLKPApLW@o-r-N<>1V1zJI~rV6%0g% z&#A>{_dULsB%C52YUb0D6zpT<_CML(g)t?fR@aK4POjvL69DYRf_nDZn|;si7V(#N zGF=ULYrpF_qy$UByJz60JTFMLnRREp_IvW=K-V^_K(P#=LrjCY*p5{r^-bfrg@UYI=RiK zEdtIVPr!o{&m>!B=B8HE!Zn)v@5+DQs)RyViY<2E1g}i z8dXeJRA^9jRCgSxbE?WfU}Bu()j86e{KVRH*EAWU-ucKj#&Fx43;r*K~ql( zK%RbjQ0$kU_+40SMs;c#Y{1@U?ULZi{`0@>hJETjZ1j`aFe25&ciI!uGVYG@UP4z& zUW~td1p(7<<;|Gb-X$0=6o*X7(i4)dg^GR85R!3H*q~~Sf3IEIdUcQ2_+j4!!@nh7 zG1r>!JO^a&zZ|~kYNCxrmjAs@P2hr}iva@hk3U~__g$9R2%l|*B0n`4?5TaQr_8Mk z67Nn@gM<6NI$mTsG+t5KDT+zH9LNdXa~I+PZh>CsT<|O1UQ}^?Y_t&XuPFI?cGX0g zQ8rc7%f5NMum} zezBZ)^u225igz+)C7G z*yyrm5_0k4c3vDW{eVr>CFeUW{aJ8pzMHt)o)T;pd1UWOh(mY*@5=9XrZ5HS z&sW`DH0oH~>=?EN&zj3YNQMJ)hdMqykwySi>?*qUWJ2&4?-}%p!tVpi<`#xwUliQ= zR1lmlkZ^u_DFl|`l)k(Xm$^l*Ge?|#*_nmI!ouS64t!Ro{v#YY9Y|ZE$+|Vcf!Z5d zv2co^Hk{iNg%cR`A}nu5gobELogroLfX>OgqSm;J2Tgn5X0cZOwf7)V6Eb+f?enuJ z$9DYYpL=Qda_~3zxZ99fTEz(x=>xGCib9)HxrhU74bDO=vff3VVfn6oe2+q>+ub`7t z4sK5_eP`99{C0BX01~}*MSJQXH656_IQWwqnM_ z-r_*$L1~8zSjPP8&2!wD)wQgwtis;O4D9Sdz{bPAMZ)d)D0|M9g&COuRSQ#mwX5bQ zyA?kdSk65AW0i(AkVOoJdZ(}`%VtzAob%R$KZDBdK7oi$=gsPw6ZMKqMMO~wIvALr09c;8sh=wc@ z=0K1Av&cZI^b4!R?juBgs`h}9pa)&j8-Q>5uPvz#@Wm}r;rS!mu{oX&VrS) z$+VDGR}HusjbR>-U&Ys@`R{`PK=dh``SXc85Z)x-J@)LOGmllEbv%W+3Rez_YyV%0 zXW-6bl>rMqJM%Qe>$yLl>n$?Kmckm3qAqVfG-@s^qCom@FUD`8h2)|lWl~2o*1_L* zSvVJyJ_YQHL>nH5_AL}OGfRim$R=MGseCBWA$b$|4 zd_P=N1O8XnpdK0JM#foaf#N>n#Qva*e0t|+OW&R#?F6Wrf-xD*qWiv}fA#^lC(_}* z2e(pgr2lQac^8B%#y+T`lCh2ul^8CEwsE}+pcZIV0jT-^Te1dBRs($sxCYo9^ZiKvYj-^ftJ3gT^JT*8mYx_j1+&+`2$U^9AG;hJ zB@GMfb6TL`r2f9&Abje1pk|QPDq@Uo>tiwFbB;35=f60{?HKtjF|qf+p~rI6W3FQ` z52+4VFK3F@TWIz!bG4fX_*_m}2Mm<6IP zsNj{{C@5P?A4>(3lx4qiyuBqVwGuYO{g8pRX$NlW;p@6(^Q+!+Z2J4N%$*wp3n!Zy znxHnoYrkvnksnCH8J$Cy8h8IXE*Xc;U70s=H7B6N5S?OAkh1-qha(GUP5&JkhmDx3 z>CQo8FZa)&`t*VOxaj=g;2@K2wCHdA<|Pqu4h%A+U(4ONdj8dtM5b<8zv>duS55k) zwM(4r2KEO8cX0+B5Z|yMU4%2%)ik9O;8ASk2vE(Rn{Us#pusm>OXfr4U%9}`ydh?d zG>`({hhKF9>-TCHJaQJyARe0vaP3_Yaq4vJ6^eOAv1PAfm;r6w?>KrA(}82XLa4UC zzq5PFsUtUQT-a7Q^0^CCSPd0!Y=@0Ly)b+Uo%C6dhZHK{onYL%Z#`w=fLL!0=c5j} zZZO>+y@*FP4+uF5972)?BGmTX=fMPrQ1HjyB&Mjslm#nHN4m;QLB(@U9C@NW z<3PjapJI5t`~Bgkge!3{w|o|8lrYZ)vsZuMRx+2GW==3=S`69N=qxA{q|`TQ<2y9 zgL;Vsx-t11mFJPc({-`}eTHde&;^QLk}m_Mtu@^1(jYE=K7#jq?`~d(HHX2uTY(aM zBQccT&__LeYy(DzV3%c{I7a<+-y-a;si8V`WFsL_d*v+HFVz5FpBa3R=Y#3@hqI4FO{YnZ0(}}8_A@`#qYAxS z^3=C4LPP7o+LHmHjn`XG{*gBQj=9|QdJ(*a5oSTji^&4{2S#c0dha?AcZ(4e(DF2^8F>J&LdVZq4 zZbg(E2o(sbZgmf^v}{WBJXrUfTq558o#Uxt$(f?)SGJZ#{H}-ATJ%}_%)^$MYXyf! ztAzyQp8wLJg1+(Cz!79>ZZd#gmT#Og7ruY}kRB@9Dj7S)3)54>d5nF*Dr-PB23cOh z+gNMMw>Nz1DvLBe-eK%tk1ItxX{9WLf6g)JcQ8KPk6N@(<4&H=!8BAjr|}c_8MBP~ zIChrw;ES!>tiHxcg7f=BtW*yuriv{kE9 zHrG3sG>2Bv=R!ltY0iFG7#~vke4h}pdtcn!RY$Y3It+rBrU^dVS5Dcj_H{D~qi5K% za8pz>*{jaj_?&^J7dLnVnS#-7{Xt}W0a9!kgxuN}kal+{wZiqyme2dV4K;($*Vs02 zKwnP{I;1?J_l{KY!)MGP8@-}iG)9+D;Z0sQJ5px^H8%8gX<*l+vt_uM{9yO0oPR4( z8&TV3UisNL6#oum_?msUL{Cm#WPj_8C&@a(A$1#>#HPYJ;c;s-WyCl+#%BmH@*k<%pC9t9wx;Tvc8dgd$_RC6x z{RWe<9{u^z=5$3Cog-|qcj_IrXffce5CZ+zI%u>SK@`h2Zlt6j+7GWQG+{6Dond^i zR?>9RKtup4ynrdQ3xy|z(tS^GT|$Tjl1tNls1wNLGKLt#c03G%4Bv3AqbIRbze*I@9l*6=K4+v6O!A00d; zV(p^n7LHafh)ip|6hpnRRf6*j`j;g9q;sRR%aUEv;G3#02)6z}FGg{V7NLsQD9vIa zpa}pgDdaANSBO9!6{bsRDg3ilWih7c6G8_Yj&xrW5Tgh!v2gRVvgpC|TmKkbT(>O| z-awyFN=lX~4l5aO?JOEfk6i4@vMn~FXmE5wn6H8r^G4*^#MhDbfgFrWLyH;~$sy&j0mzKw1rG zB?AfRr12-d?{Ilu1=Uw<9SqZ9Md(Ef)O4y?jaLE19YIXnbYisc?!UB|2~2KIAPv7m zR4)G36lYF|V#yvx?5f8>atF!92Pw)Er8+HVHy?GTyWCY4~vVtiFG_O zYfFxu1bT%IcnNVOzkYqagvfXQ<+=0dv2eKQ{4t|KkDzz@_--;kHnwH)kH=#egmMTr zE%GqSozO$4^~#?2AbeU>4gqi&T*O}>R#Ov~Uv6x0D8M0JZuWDfLjZ>P>AutC$e(!N z9p<&{*P6G3;j>DMuAl_r1|#xtQB;vk%mwvQFzT&ErR}+|{BOC&oZqm=2yR{lL zY%2>!V4c!oHe4MLFV@J{jRE!*BV_FTln^l3~nroKN0oes7KY?H`JGe8@MI|G|=M;mj z(OlhJGw+h!`nl0lN`5@;!FSmDhu7oQ#-Ev$McWB=8cf-QNZ;;L;#aBf53P4j%l4X- zUeL0R()HFgPyNfUR`jqpoMg<-inI1O=8^f<<3Z0F`vuUvXlw zld(4zi`FvMayzFSAcjWQ7io96cCJhs|fw(GRFtVdBCG2RR_{19a8N(?!{uw41Nz-QOam@dqsGfS3)UslhX0of`e{n+H_ zl#lug%}SOjBg7)?6y_?4M_aQR!fg6@8Ae@4ooJ1sM;>-WFW>}A@>8ZZsM*oyG-`I_ zQjicltHL*vk(qgyJ+-au%T#bk$X8~;F0Wt^H78Nlz}M6ie(Kr zNG1Rcgp5s%8hBbEpkW=I^WPs?sHy3^hc5rF(Gsqe&o8k66Kg*A>bV=l$Y?_5l_EG8 zp!ornM+mq|Xn_ie;R&UaN!#PgZpZNw-PeWhZfM?hlIKM~BuJ@Kzm|;&PZ4-cg7-@%qtNDx_38!FofRbBq?xs%BK*YOA~O|A4o#&JLk-r* zW?(p-Q&;6AFy&3&y4Jvbu_w85YN%y-I*N5Tt@ETqhFN%=xp8l{w;ZB2Bo{VDR$--Bq$oAJZ~sG9^{zx(Hu+x^L%*ErkQtt5QA`HWp5&gFL-3#-z}e zawx4%r(hs@jjJMRl_$%hz_d)bhqEH3Xh126`P*H_06RqrugV7#^7HoKfhDJ z3HD%lU0dJgna3cTd;xL|c8jEi$5yhZULR|0d135*-9EV9K(n@ESru>4tT1tnZiO_=d;cjj=zSrN1b;s_oaj0FBM-K(0;zGqsi!WmZ#g zAYaHZ@Gelw)X`=y{(cFQC^;14GApV6&fdKELl;6oCrNN$e^<8?VVjS0u1$7e&a-_b z1(fjnVn|G)rnsf`dY$gNe#t5RyC(EL$V?Glvkn<3X|8168p{T%Wp^p+9g>F@9W`J2 zu)N{WR1|XL^QaG_279o9emjL(Y)-mNhHBz;+ax~wjuP0V($|m0|(|I5o zmA52h(6At})H5>a02^vj8ttRa-{A~J$I9y}dYiknMh3w@rdvz1eqUGPFcH)G{J`rJ zjy3H8%_joidim2kK|Hdu{sx>Rm^nD)tG>V9-zNPH=@2rhAuR?TNuHP0376_w3k9Q<1L@F8r~`#J3y*O_ZeTI+x_}^$XL#8?cE*d<47(6u?CVgzB?8)L z4c7Bsq9!68+_qy1LaUQG=})r7zyLMtS@uqgWh<$~D{=348P`5~M)1p#tmv~?83Utu zqO_kNa9lxVL6y+97;T|+{%1X)R;mN5TUrn(1%e&<=xcIbZ}S>DOkf7d zU*TK^m2UQLHsMr%J}hV77vn3A9p^7z{^MPC|F0=IQkwviB23}M;+)i@t^YDyQVx(J z9S|{dDht8I8tIp$d&WD8-TP}Bj=~~{a{LxP3#cWHf;iRt)mqlfY5)li*1g$WX6jyS zVTb7#$TW1PZjmXdQxMz{(P0UJ59Z_>jCK(7uL;$%K)@jD5SBGSg|<`1`?tu`XYQs) zpPOdLDpe}tt?@?ZTsk3OumdW$LGN)9=k4=!I)h2rpT8SGt2m%5DClE2Fcz7CE zk-gBTSr$;(%liHO2EXr5Y6bsIKAI;}?QMh4A*SU(6J1n~6WK~W;?F5)XlR5p$z6*l z_HKahZF1~c|8|NjF5|(|Ab6JZMlWzf48c#{x?Nc{fQcPVD-8V+5Y5zsEiI+X_lrW{ zkum()EHfCAXq=)&|U zx2;R2%qF}+J>jn_#@me->Qro}=pH$eq$3VfpOrNr;}Y9!Bjj z+L)kcFE}n3HcC>FBN@Bh`F!p!T2%wDCvpNt`i{-TsO=VH|NT?k1a^gTCT-!V2Mi?i zssxGKA1uxv!33vIyFUEu$Zj{#p9;H*!Xc^`rs`GxV{$1j4pn(@3+I;5&;z=4JO}Fj zbYiFuOHzzeisc2Txe4fuGsCQ&z$!}T`hwW~s|Jv0>p{mbGvXMY%0j%x!Z^mQO(UTk z2PEXu49vsejx_ZlZ{ppE1pEB-dQwu-((_VMQk&~_l;V7Kl#q=fOf$=Nn9}>t7#GHL+w15ry-R=eD_Ms6E#s#}^cDJ7&sC*U>q01~--kw-GzIo=VEjQa5&>tBF zUVotO#!4rmfEaMkESg|xj+BRS7oz`aaj40#Ei9oYX@aKIe3$piJd(p_SZ0@HB6X& z>Po%>VvZ45?m)y;PW3C;jh{v4+m4}VRw%|BglAq947m2FB9R}m4OgJG28CxNjTB(N z+HMkK;iRw=!tr;MQ!Yr{UnT5+j(ax%{1M9+xA#iQWrk9Qfc@4&8o!(wHEo^8) zSeaw~su^^l+g`J30uK;+OM#z~i$U`t4}YeHs?8(BB#6{^HDCl!4bg_%7uEIVmNhsM zo!olthp)JoeITt3zrCe(S*F!n=|(}j)8(YjaMeG>N!78J{@Oa5;tjYm#|m!uD>ldz zQ0#uxYDEv2a4Z8zhu(9!%n}F!3c#xmO?q`?;LSv5CI@O|K8vWrbOza)0E=)p;IIAg zbJKE^f65Sk`ojG;%Azi>;;(HUiExrG;DTj3treF4PO8W`KNWhdzkVkm$IK0b^_>56sPS?XwU}Nx?^Vx0-#@)lEbQ+^M$))cZMoEGoDK!9N zXuTEmIkUIqr$xF*AD=IL6?zoq{XL4nX&VGoLg1=9ZLg2Fe{HhdUN_`PUOE?7W+qHr zKQ=Q21jb`_v2)2b6I1h@S*GvbLJU}btgbX%`bnAiQ*cPgO6_(Gw8WZOdvIQ3rZMmr znV#*=_Z4@-d4Mp0(TPb{?rb-;ftC7Qr=ar(h2TBvfyXuX|2stf-iyF1S!Iuivc2e8 zBO&x4X+bk|x4zM>mxC}GL$4^&**A6o>mTsqm>VdT4t-*~S zq2Z%W2=w27g`^SxBGmxl{WRtwWj}F#Dfu0@uqCC}#xYh~cb0#I`?$lQK;?wnHG5&C zkHk%wbo9VKLljl(^LQrjsT5mcq06^=sw>wti1oGx)QHGSJ2RkXS_3ksksX4KyP_UMdutGj*8;8)eaj35&=VrV)r~>| zh(8A~d;b}!>pHOwu{{Eg*5wb4%imqF1_YF?l7tW*MQDh7E$W} z%X3`(?O-YX4}nsu$|qyJBKslM{{?{VZl=M*Kow;_j=TLY)IQk#hE~XaHV_ym-u{RQ z)J-7yISIG+Of{g*3P7F2?A(0i%$&vzX9{5yPBe{K36PDgKO7PG`6mO26F-cynt1+u z4Clf-|5g3-#*Zfd*;zSiM=T;WI?KxAJEs92DIING=k#0G(5FhbYjNnkc|`O&oZX)4 zkdMC12^ZpMLuwvR^-T%EbhxX<&)+n8k0!kDA{Wji4Z3YCxjm=&`s;-HPOlp{=C-nx zwo{e&m}vH#;@u~)=clJ<5dyu{O0~t#ZwaCryGoR$zc`u<7m5Ld&IIW~+Bq*}EVt?O%Fv`AXIZ>Md2f5WTg z^Q$;DgWLwP>3g1t$$PHWnJ?9b*TjQL!YR*~tsGSX^jS3t6cmG-TvMhK9&r*cD=I2* z4a&uL4uyv;9**`gu1~Vk*PPpSF8O6fy&_73qHnQoXN~_`WBI#;!!y*OCaD<=lX$B3>ULLLkz&TbQRri|_0EHeJCVNz@B2G#ZVk|d|BldccMySbgs!q*ho{&@ zNw;D0#R6gee2_P=8>8B^KUJ*}TI!@o_}%MY%nZ)%duzv`<40xSg$= zUOqf~J4VsI@nHJaokVEl5g16MyYw)l@8@Bn-8=F>f1-W>N-s^tD08Y-&-lAX1$%}P zx3hS{Y9Dwm+(S~^s|GYw0Onr+Lh-hU%Wgs`95}bXX{cU!n-KIvs$b>G^9bb+hK^K& zv{&2e50Qfw0nVpbu1|S2cDe+4sD>*qV;n2D#7yEVI5K7OVfy1{0TFw)E|ZprTFoHR zGY3BM3!tc9hqg&@+axg0L!Ui6{G&frf%Kwz5=_BR5r)m8(!%w8eCdF>B_PxYcmtLW zs_#FIc1@+v4E8y{#3%)llTFU7-I>&e`B zJW&?3r-|f+kAqsuEBnBxLXf!qM4(hadQCH@_WatOL$$llsTJ&?H>up`e`@y1j`+@WErOC@pj;s;{l{Z$G7>4yMTU(ZZ^TdXFB|joP1T@?b zLf>z?Fx}bjh)D(Hos&+lm4JAX2m{M*s;Gp>DDMq&5bn5H2j16AVPlVh&350YwHRMOPG+IV%3ZOpV~QP_9g zLfB@SQ=h$N<~_2`UtP0!CD{s`Wf}x@BT5RdoEBl!DB-b+u)q{b(`DJimKy<+(44>x zBwMC*%A88AfswVe5#JGeVs7WfyUVSy>vXBAnH^|sa@ohDlc5Zb!U!Vw1LI`%!_DGT zdp@7n0GR(70U+jiT}7qxFf66Q z0ql#NHBlSi$POI5{5xMtVbfcgP7jVKO;Ro7V%ga*#U$TFt4u+^;3y>b*Q3qa@qhh~ zLKybNIkW7nAC!A#Rd9q7f-DG}&7!MH7k5kzUR=_|HkFu&f$*os@fc0b~ z0~Q2v-Fkym>no+l|w zmgH4!oA!ATw)$QAWF87P#N4XUZQTaRl7``Q1i{5b_rhNmbLVqzvXTS}i=*JOZvO&`*Aj^7y_FS_w zZw53`L@3;I5ic4VcezT2h>sd|{RQTtvYjbSwv-kgOa%8cdxF^5YmI|Sx6!zrC%rea!@qgTmj8N@ z{P$uD@5`q(5+`wz?rc5vS*7wwHn}G!ZCkBkh&b7{|4}YZx6HMa3kBv_ztuW{r1!zE z5cLFcfcsMcGJKQTWZeecX2$%QPZA@Q zJx>O1cG(qq(yO3<7_C7p2B39nqZco@N`fiWQDXjpcgS&F^^*dvZVzdjj(J4AjW z=7_LWRA2sD23dba&#_hq#!)V?ZOTg{mL(azpwfwqr*<@@dPpYxL$k@%(gmn|D%oPs zQ@fQ_wS#Tr1&yQaXT^+t?BMHB58(2uzc&3Eb1~@fZ(cLC8ugg7UDL1JFA-fkP9u+4 zzN~2;su?`I5LEtlC-MEAHtr^nNNlB1i1Ly$Xg7^e_-GifrVr-JTfYceR~kv66zfaT z8lR8Z0XaS8TKfTx3F1bT;&NSak#0q_411d3S`pI^1qFnBg?wgq`kF-gw=uWrj&eh(b=Bz zJiDn0E+Zj_dM{j`!!V6L6hbtxkYzVJHjueV0wF>h*mZecQf^_`SMU%2;&z>c~g<}mKUdXvfOPSXgLhML@tQ8c@s(L;(Q)>gv z6j(d$uJ|<%Th{0#-EEG4^lLV>>;=?<-V8zn8oZMI2o*P7v*0L8pl$Db$#oGTZQk&H zfY}e#)!No0d^wmzkPU)EQ|Oo}%Mt$&A~y#vysI@rQU_tc*IwnqnCsbZA(|olQx`BV z;kKVtW2K2xxd({Dbs&eZVzO0v@xfrCF0CyJ;xN`C8`D=;WPnHlL3B2C~ zt_z7dIe>lJ+FIaY{dXVb1YQcbs)rP zJ^cA=u2H*ZJL^**^^g}`{s`t?nDbBoO2Sk?CEtBlcJ5&u5g$gtKuyh~YKe$AqrKzi zLKGg6Y(wZ+IP3J~A71=Cu_xAmyOylrE3fWiZ=KOqNT7#9G%W%k8!WVUm}rx9T}aiH z1n{?FnOaHqTcTGlFISi;!c7al+fXPUPhwnc;bnK`MS(43pzL!zVH=-CMHH+_OA>*S| zbost^BO`R%lWG?9`+9B_HQbRRBUhRRe0ZMzS?gReG@l%yN=8^ixq-9E&)Fx0U^I=; zkPlA+$n!RiuEVqZ28K7L^nU~BENj%OlNI!{8yM5k-=}~G7X-s>%iBXj#=Ej!1^@cQ zo;kBpVu@stFt<`OR%B+>8Yp)0nPB|e)m{ZsRLzX~B)dD=0O~HY=@scJR6$SPMHJ(+ z8PKT*aAXE<%$fV#IN`VCoYZIB;CJpHBxOWu&X2_R)}Kq%O$<={|C$oj#vn9KXRhT> z7-xw7vjB7-|HfhQtJa4vZ>wVPKjLxLSMYsjJ%~4di=Gl#z5^A0`Dptg$K77(=Et~o zoKxg))z#Y(X2c<)YlY(4b?(Z$W30#joY?keuhvbU}+V8O( zH=^#aK`T(|JB&NKKad4fDV_)8B>~7VYlu& zM(~>#-=)1};BNh>zv<=(o>zpjY4*)m$ZL)W^y<-{ofBnShZrxw5ZPL5s|)oaY6?aa zD?VZThuuC? z%{Z{h)+UXvLgXPoH>x#%s{one`J{wSrt~|CQ!9*NqcJph-Y?Z% z+A!ne?~g(fNPKw`+m~X>qDHFzn=4wR=KgAGW3I2alnP0t?q1Wwte19+!ym zB7^}gyyr&rph5Gkv+T@H4Jw0u@z_5{6{*H|8@~szZ;*i8s1=hA;W7xwCAddTp<6u* ztv@dTt{$r@3gZh`GmrCwgcUGEmZd7Q5A3hknir#_K{FH;nXv$6+1vc+(@uUBphaOu zvI78lFCzj(a9YSlt=c0hwGpr-D`C@m+vNBZX0S+sHxTC8_*JA*1P170g`LhQV)GLr zBac~RkN7nWy_N!>lGVv6AOn3)4W7Aj#jEezXXpcgmR)+pYOxk3gRukGXp#PB&Jt!7 z@i2o^|AYR1>vAgJowj>qc^wZk){rsbTw-D%^jd7s1L3aM61DakTYVVU2fMVGC*WUY zHIpv=2vBS|gK-$cl^L4d$09xm>Gr1wr5FYs9{TMhAWi|NxMonMbCICpfz|(Kjr}b= zK2FC=I;1{c2~#i>r`Zvvdtjp@%ijKA_4lUOiWHtYafmot6sl$A5Dwkx-${Wo?zhI+ znUqUZ8SQUwUH+GJSQY!Cjq$ukCEHg*JSYE~f=<^sc2@Z?RCUWTb8+#UWZSxq&7COT zg*)$HKEo#>o6m3Ae?j*>=ZsoyZLJ}!d&WHo+i7%nGQO1Y&!3tG{J{vounu;V-UQ&Y zU(S8&=~$)Wy`c_mNUhZfe)EaX_7-gb-xQ8(bQ+pK=!Zfz|7T@7F4Wi|R_qZ8Q;0kL z<21XePyy3u$_>cDtD%DRS?CEiAu2?uZ}183KGB*%AF6el!EK)VCgPwW33i<>UVXMQ z;B}GH@GzC8@v$rAd@(}y$-73p#%I~zOWJxwan)%O835F4tQr@KJA6a4!@72^Y{|KA`^?hyy}FsF2_@=s;=;Gg0oes-6pe|y_dAIEC_ zq}%&5_~{v=ttG;X6^B-H0(1p3e9wU`LEfiri;8hVHMk4UKz)&s0?YtQ5xP23!~JxH zY7gboPE}|PRf_lpN`8$J76YK!5s^7LFHOhKDI%7*qZR{23`|IiP78(v zmJSF{&&?H0k zFt+@i!I7u^2e4|TiVqDo#EK29_y~IT{f9@l;r;YOq^_cz8yuj1N0ZHU!$ziS(h<>y6t)6|5h9_ zXw;)nHub?BTpNro2VCZ!XFfyxl)=($3-|{}@}8nwX_RE;Cdv-30vC^cI067aO_;D4EPwGKSBO>7I^w z-6%Yu)K~*O{X34BJlj>LqEd{|8(k;Sg~X*O+p(s9l=C{wtn)C|WI6yp+O)ncg@ApM z@6HP!82r7&*$0QY7CgR(4~hNs2=0;>;Vb+CR{NW_cMmSD{d&!Zgl>hW2my!ZsHPkL zo=k|2U2jD$^%_qjv(@G8s~Ng|=rYByj4AT$;|Bk2%J;kAi(|o7kENjCefgT@;TN^- z9G~d|*373?79di*Up>RQ>22Wgi%<|~;HZPltgOE!;|j_ifKL2OX*y)N=My0*;w=c< zCyv>ezrSa{-gl_s%KZjhk*%;poq~oAemY)BktdQ%kT7*r8Hjr&6*GNS_Cq-$&--&|95qc!i=#O3&! zS;RKH*%f9Rv>7L_wKhH|8k4R&0sw>5$0Y=Y)wC=zqW5P78eXTuYsB{GsSj8ac-o6L z$G!|W$wcwHTHyvPOfFUSuTS!I_Z(hRZa-;S26&oJqdAKZOl41zveUxZ{x^RzBwxmt z&3=3L==pQTUQ#=^UJ`QJiUsgSb06|<(J&5R;}e8Ywq?OoN>9He>aADxI()b5%|EJ2 zRCE>l&I_LBMQW32A5pz9`eN*hqvwi6(8fD&DGesa46XxpBPU<(a0Vcxx{x8up%#xH z2{_mIVDq8$D&c(4HCu!Ec{PXu&LJ`birBHMEH#6`jrLbqfUp`20k~heW3@>Yd@3p4 zQN97dz0>Lkzx_-5v)V6!8w|^LE|~xP$@;86 zcokm!V0h_<|KB^Nn@Eo~@Z)n`24?-O2kEIB2f#zATn4azcR(p|W!(I`-Gix@sB%9d z>oNRLyh(O#nUlYAYu&|P;^BOX{yOS%Uli-#EDD*d*S>zPd%!d>cUoIr@?I)Ehzc`} z?_B0Jjd1W<;A}(MVTj86`DuZWlwUDa7&XP%Tt6?E7T|lWprjKGGu~*>hyJnX$^T?~ zzlBS&g?A>bWK{MvGrQbI`kNK?`+zMVO0-fdx)q@x6hAkxWZ9sqnNjx|C~}x#2li)C z6b$u%ZhuMK<+QgeQ84Gd1p%^vFE|1=;$D#noVOos3XW+R;=I&Lyc7$KIrSL>rZ@9Q zl3e#C;oBDthVOm9IAB^bP-fG0C1Tq@&4Und!%x4coR_c|uQ-ai{#t!7G(EOC;jWG&CE+1EimsdTU)~P++9+uZv_f@(xxQ^2 z=b?soM%1M%=(#C2OXEel{l^}k@Oz|Bm1UYNc8bLD<9M9kn6c@O?xbdK#KG6+zDVv( zB_$G#k>BG$kZr2Z6o*yS+o{UR9d2rGpZ|(KB6MIG5$S`mfg+N<3Nq&2xOtOyrCYa* zcl{P z!iDd9rrjOTW@)FGs!L#k;HPNAg=?;^rKI2GGPBHdUjCYFeA($CYS#am9HMd%2-VdQ z%&$h3SfBKb9Hv0;A8gDGV37;KiA{^M0uYUeulUoha?dxOjvW266N2qdky;F6z-@ja3rAga! zM1KF(o`>z+25;`^c;v$3+{lpn#zBudq9k4pLbXLjBP({+WGBz`5ydQxRoc|4LK7 zsm`gN4ZL5?U$dk2tXw;PTpoR~l=lA^yY4`$`}U2H5y>noQMOW%%~51zg=7>8A<0h2 zI8-XKNwShiGAc64YM9v~TShh|qX@tI!#Sm%=Y8MbUyp~=_nh;Y_kG>heO(sb&_3S! z05A#1*W^6PkU%{|asf~=O#_<^t^laqR|31x0tygG^1~>lz&g`3lzf=FX6kV9xBe&g z8OhH~Z{2wh+xCagm~fY)FDF=H6S@IRF$7R-PE2xJ3s?_kB#H!I+Axj(HnmzqL@IQG znbmt9;jh)?2#m3D{3(#nK_}FBN*icFr|2%H3F5BZpGp`z;qxF*?{|c!)D#z!94CSm zs;YZD0tL>{6el)!l3eQAdJ;?%>C?OP!uoK>BZ|IcRm$(`$-1L~Rrtub>1ZG7as>0d zO4Pb#kav-dj_;v*eY4iDDaJmg5he);$YE!`{GKg3B{^9^t&L3day#_wvdVv?W|!uz zmsyBK%w*?odUK8Oq_%6K9MPT*cWinsw?>@P3>MKp#hVzj+~w;_w3NaSQX7{7zE{sv zk;Iw91re61L(!SH@4d>Ab2;1rQTEk<4_{Lk+0vgR+I{k~6+q&`zP;Aj5+ycYQi>0e zJbi9qbpJ%$1y?90JcGsp0p+eLo&-VQcfK5X?uh`<6DNJ&wVwc@AeMtN+V`Ecuok{J ztZYlz?E0kT;&I2ep8C#NHt7PR!;`q}l=zsK-TSA*xEOU2wVdnJDTyoJ?N6Mz=J^_qToCF>$%}>6x^D6tXpb#fW74Dp%aD%6k933&l!CuK*fgjKi??@0;l3m zd@*|MfixzBMK72q=T7Kk=f8e^*zB6r{lz> z%{tGgXJ4|rjWq09I#WCzN*thbkWJGG0DSS8QSf~q930dq>|~X?a!Ac$^#0U*d&SqQ z&km4KGH+SO&HaVlY!SDF}=Zi1b~HDkPb3<~#ci?lW*l z5$!c~-zp3ZmiDAEzj|JERZFMcZ}hrcQ)MWx!i_SGJ{B^k1KG9@&ftFYZ<`MNE}w)} z;zdf#%P*JhVDfri5B}*^0hq%WnfbYM?)>R=53|=dG0i^01qBUBa{Avm6xy^QTZp`R zHGh_O>^>6LoIyRSSU4v>`74_KHDh26l`isGRxLEf4jf`?9#c*-TP#&lzN|3BkWScewJPNZsxFg9Kqw@98eMWa2mp% z1R=S_#$f5C?y~-tx^7L#8{)r-d;+X*+rsu{bfY43R_UI&kAPJok}LzS#=_9&&(#3( zaxjO~7UfrLA6-%QduL5hh(vP07I8NMjF5!9n*7%;i^m1lGu=Q#DcEX(n9XEQe3q7# zSk8MVP+fRqjjNmyZnO6;p;UgZow>uyEOsOzVqBFU&vp49)4)N4!CtNRt?@}BD86My zi#y|f9h%1}Xax7FifgPD?rs>C%7l`I-%wDmy1DVOG-iY)RhMA`-sWF^7NA|4)tmG_ zsCmP{<2MbQXdFk0A`32AQZSy>)ir-&0EsZ`DDy-HRM~<=7Os=>yaay{#7>zy-IQak zqxmJLL4FEjeSa24$imVR`l#xRRMpG+K?Xz00PHJyJ;n<_jeG|B$FxDMU{qPm7BG@` zlCAWE@7V5mYMlcmPeaj?L;~H($Idw(`C^*2iv^ zJpBDbO?*No_=f*DW68!Nb@nY;BgQ3E5P35XXG2T2N0T!8D!%-ti%T`)^@;O`Ch;8@ zm&w217E6Dh8+Q3a^vbt=iWIRQl%_`N7o~W&y_}JT7Z5RLJ^%gZu6UF!2ai2V8-3kMX zmE(&Ox&MCd+AK%#Xx$xmgM0egwQJ>^dA6OOmD^0Mj$Gfet)%o2)Rb!fO^HOV!$% zqRxUioro#5K-|9swZ3=sWDVwvP@e6)*Z;B@8tp4&sbUs@|6;5u*+}k*g`&U|0+E!~v5)0Ix0JY4uqpN0 zrSlwF07R((mU~#m5!H-9HE$3Uj3VFoZ#5c)>+BAASO$b$?xA=TwN5$2hHlJ@6Dfx+P5WrqTZV>DW9f_|uUy=pC6}?UbTQP4(yR!*0 z?$OS?Ea>=<+eX#!InPQ-!qcJ5?0#L2){1d`dCc1ME4vs#;&Xq+WFIfH3~6zH2`;wcCU(PMZ^)?o^B*5pAVC}DRGk%iMnV#%J z%ILJ&Ux1JA=A#VB7maM7pFLX}R|bBX7Epf$6{f^5du3KnmMlhY0ZjvR_z8rZf&x=A zbUW#p=6=D-3LtB4my3{L{RBOnNZ7arO6M#r-0Hqi&VQEp;!o_Fct|ECF|pM75rY-- zdJbvUkW!a)oth9o>i29JF%PzJ9larGQz}+#e58umLdt2tSacEGb33%7&(;bH(%0gQ|h^b1UwK9t)n6F z?&&d4q`}8@${x#*thtGE^y5Rg(^Md6md5r2Tf!U`i{oJBHYM4$g1$VXeTl1$QTKF} zJlKw|vqm^R01i{4U8J6-@4etUt;I5u5JFu4_x$|2x&HoxZX708fvMIfNg+Uo9lv4m z!AX^XDSXjzliz`c@4I)$qW(C@6Q7~{?ECH9v<~D$pL=OxS}Z=Da0DnmY$$g%DcL`7e%6P7fhdE>FBL^{QLmM-AIhO)-`__Z?2;!C>#7526=!CXpqNj0oAi zQRXQ)E-WCGLv#|?Imq2Pt}vgfJH7CwER(@g2nkqH%nW<6S$pOfpND|5!eIG{{GfH_qx*} z!zw!q`gYVrOrzuT&ebv_d6{WGRG5$kK}2+{_L_A`i8Qp!t^Uwlqh~>Ro{7rzoZ++Q z&)-xr?^fT`evOgp@ge9*YdCke-rds)MI;0^s6iJvK2dHxsC0X$ zUbgZPUFfGK($&)HBg;vh)2*M0g6cvw^!UD`zfd=QicKuJ?8nhyb|GZF!b1?h{0b`6 z2DS|%8Q+o=1CpO`T$*=sIbB~e`JxklJG^wgQ;>0KvEwpO29lqcdRd%%jmVH3iX>gr zbRApD-BPS9wecXyqXUEso(J#W`hHuJa&q_&6zN}w?$;pp?+e+s${D-oyL!x9AI?-d zBm8XP@5*F9%+c!$O; z%YB3eBS`^+OeNp1fe>cmdna%J=0p6xSg*xV)XZ~ZS#k`tdsv6h6TCorQ*c)E!j{%! z<05BFm2W{}Dgrk;p;ENgS^NF8WgC$wL0`hkEYA-JmMnmg6eJma2-y~;%eAO(8Y=>6 zCv8K+^O7xM>V98kR=yADC6*oASEReRFum{Y-MhsV<3UJG2KkVJMJfZu)syE^)}UBz zhJt873`6_zz@h#V* z^9qp@{QiWBdua~+eJd+(BJ_RtP@bn*0WHZY;x4+I5uz%(VJG6o(7v~z(47kovd{~P z!yhZ5KD{4z^bB+LAFGs~RXiNc_ooFcZare7$pL~?2N%noC%l+1T!fN-D_7VSXSG|T z*q2alN5-WGz2HwA-viBbWXnu<8Q6J>2y-m>@|yA?h+fakwVBks zzD9{?0H69r_1h7*0}0GVrno$*3`E6spbb<)SC7o-&>qk?F)I6T zvG~V1q}j>vUZXZw!!Ulz1gxnLj`M5_$!CFmCf!-X=cNwY-W+6Y-p~9+b5s535t9IB zVFc;f2 z-*=H>vf6&vi(m&29eSE1-(OvuO|;pHAivGnqt<<7djk|qZv~Y=EF6;W_Y@q=6_7Wn zKz6M0cq@k+oD5kQ>rgh(Q{+U}YV3yK<0N?8Cd1~yX|uLcZxGLV%KR{kDkHVEQ6`@6 znVu6piU!rdmrtQtW^>sEnT%g?-dV1`h11av8c)COS(7WnZ-`$<<-ctqelARQe)WjM z-oFDCGF?>+55{5Nkoxt0*?8PB&Ci)g=h)5!pc}qB7niF%rbiWmWtkNI@#rawCH3Tp zsl7QHF2s$WGV{_*Mmae3pfg9t9IjM(M+jpY zP+Y5jZ_vvDpgYI5n2!Ikf}NLl}Ot%#m|3Wk3{TOsji6R3+_PEDoGSOXnz`1?rd$Bq{9vJZv*DX*#( z?_(ltQ&QzoT@$?glqqrFSv%FB|M4NN5_g$Ni^e&`?_&Fv_h2iDf0m2y&(ksYV*T%( z6dSe|Mw*0{U9c`|{}$ev@LhO~8~lRB_EDIdn_p&D$`;>BPQLb;_S4&!)PE;2yKyGe z{Lgn$*xe^~soZWR{>Fi!#C(LNc2TAfY~1qyvLT4L``8E4YPs}Jl}g_Iyf)Oy4+#bm zXgeppdIFtPFUV;z|G(E5H}>l005eQz8jCWXhK_%G4jB?PLU*-4CS)C7d6BZfSwXm# zlkjo&EwG%rrJHabcMO$oMF~NENrlg!U-jRX1o81w=Y52bpMGr4A;)dIe!f1j%r3ht zhSKAQd;Z6iZg^%NJ%@g5v!4+D!>{jkc&2iq&uF=AGgS}y6I#W!#ZG*xl+C8h>DWv-{);OUf@Gbimq|Rp>YS{c*=pPZdXBMk75m<$vJpA7_ zew&TIY}#r-a07U{&&(7au}Tg-SStoA4%wbP)dY&aZNEC3`J28x8_uf zYX45ogH_BIz5oaN4yZ>}1FOpd8r8M6v}oK&S$E`O&YerivFkN{_UxI$>du{#&dLZL z;De@jNzJ93;A0hXY;S=AQWTjAcqmDJHOdLn?5g_uJHQ<^-0EqIjGo=2xo>3;+Znbw zBJ+iUf`Vrb14jkynjMlK7W*vCopIl%x~$hk1k>8*O*FO8v^sePU;PeKFP--6gd+5_ z4{~f{M@*8B>}x*yU*{kD7>#kFS-Amjyf|`6wmXG?T>18Go+TmbW5@CT|DJ|Z_6t-P zyZ+Pp6iqZ6eenx*CdNHy;+8;W2q5eNUHVi9E`f=#im|b=xKK_$vb}9$4ZxF&0t_N z7>^rm951q4D5PCjh)&EA7S}Ja|wC^?oTm03BYw zw$rY0D0K=o4!sR{oe}oaVE{9_Q1c8}&+~^-RUF;b0IWj@bb|-fiVU(55oq+`9mytv z!u#P8s1GU>>GC-nRSket2Sp z$Pn&m!n`Me&5CqhW{4l(aFaL3YyLaX36qRCZ2o%F=#zOY4I$Oy2?%GE3_7NfJHaW> zxev6H>gP~rpvd`_%FwKfNS!zQ=-~QyLmU`>#QY<()Hn3 zYlaO;kO%aS48?m)ZCj@PlqX`{^!8~wteB*^Gvx6wbl1J8jdwP45;vV#Dc5vP~<#-c{b}5HH zq~Tw+@jNCVa$vF#{@Oyc?4@+u!-DtMm?@tjY>qxyF7eRbUmG=}!5f3 zC{$CFH*S%CSVA9FLAD{27rT2j0umtl7JcZt`@^0YCA4&<|&VrqoxG)OU zb93|PeFDJKKD9VMDS#XkT1d*x4(n18r-o-70{udiP)J;wh)(tLr)CR-y57}h(aK$7 z^4BGZa{Ij!_7^dcJT4O<-MB5akCsk*@S53%rBaRt431KsUq=@){1j_CP~Q?(yL9FR zGV>1u=CBKP(A)$UA>sY!&$aPd0RJ*dSZ7+{+g}lcFS)HjZ~X;Ce5KL%-nypuNDZv8 z4neT~HTMC^xY2wlU&2C1Nw6c7HjO@|CO4A8~yAOVUG`kdSJYhJrrz0~_>2|NK$!jbz_bF_USWxb<|E7=o~$ znQT|2ePK!n z`I!Xnlrs)umFTys0HGt+G6YD!)n%$sxsaUfeXhT#N_{Hu% zaV>2N?jal@$wVppEg{5hs!K9lKZthUErnK4Mr!)h6XQU#*upHLyaJ=hZJ?gE*7b-_ zrT*M-YyUQl57Nn&39<9IZQVhMc*|yeOf;{ZIMyR~IQT>$9tjkop+9C%OubX~)HyRG zF$?viJC^ZoDenimr1F3l4NaR#gu@e*3FMQ^Pfg@t^wuAFx<18?2)Z~nwo^XNRYhA!kBtH#5~A06(-NcgWC^)ytLkWK>hNqqj8 zhiZE-q@rWZcv$#^`n(c$>7P<{<%tA72^q0kLIIcf?IXCAmqxJNr>;KnThC7|GBgBstT@5Gd&ti^G zs8_A)*dRiTtW-YF&#jJ2);Mi(`EA18`L>1I_;@GPD=x7@x8?hDZI6y0fu?yrW|2(J zV<0UFN~AST6lML=yZ5VunxB5b4=9G$?68bIKIM?IX?E2cL`N*!d`T#;Y#s=&w&R6q?{encsYoxE^A-O-VQ{vO5 zBIVCvj^*tRP5w%|&h9lWwK}pB*`_`7&R2VAn3fjc4LN#~Ax)Eh`m? zR<^14NqV#tLbo2KC<71Ka&t-j4r_9S2e@BBZ;3}CBoOr0)E`91BA5gkcT;- zc-L9qt1PzL!NC$A2Lak_awrW87OGW>9XZwml@p-V70P6Mxhym)G;|kKs=`1%OR9;h z8`=TpS((*KE`H3GXNPki7+72%ADa9KU!`tNFZuTE+rylkoUWtb zJ@0@}(lnqO7F1lP=H=xj%ebBZb*eYxjhW__mP%|Rf*l8RKD`2bTk>%lVIFjJ?L{0) z%YL{-JC8vKGw@yc5Ul4XKpS&2@m|hF?PxkVt+mSw!+m9bK?7&M8akR+9&JMV_HMBm zxB9g-G8jRc`veIOxUTjKuMbw3e(Cb*6Y13+S7=>7dZ(Wo%NxuR6~%S@U==8kC7(_g z7|Ttlz@;C}bNg4&ykU?bJWzqv8(vk}Jj#GET3b=R{H5C;ytwDOm*~7_m-$k*_?I#LagpK;iA-g z7Zp?^=e0Dme7ug<)YN>NvVS;Y^9fp!qo7{*a{jv=BO{~xrK1OTAh**YXe7J?!v2-O z?Xy7SJj9`OYf4r@f%Z}Qw;DAU!R**7yFfwkd@GP^R1`u4getnl;7ET4LdEUSyK!J4>hsFk;(3PlFM`>mK3l7CuIzN9*z@NC zwI{dFcu(>g-^9&9Lx2UY*>MPe2Cb{WYXlhrxg-w*0SakUC^7$O?})#{lEVqiq?^<7 ztOanV`CFY*=in4;gq2|MSV>3>5ztnkpHaECT+8NPcFD$_!%43^_%SA#obgWOQKgSt zS@9fQ6+zRO%3cvGiJSK@A8>Qjx0$ecj)16?bo${_;O=TZKom>=tvfFz1Ke+fq?N22 z60uy}c5mnf>t-byoxNb*(G7Uu-23f!C7e>ayjPczEGKl(AOG$GRa|uxF#i0s)qAb^ z6R_uVlVU?{C^!{&NK(6ZNF8w{^13hGQ=q+|wz?GvGFouh@JJF`CC{}LA`go-`vh39 zf>1)2e>)sAW@6ldXqQkK3VH*v3vK+{S&)dapJ*<1L-#e8P#D#+nu)INphOOYukks` zbVw~(qNPP_szk=Xz~EDxFV7}gZNt*;wvK4!)#-=MZ_=c}_ASF_^q_0U*#>*uPC8XO zTU^U0b1shX%0P_dUNl94+`|uW`5o{g=zgvlTwhl=pB(?c{ig;#bhBeiCrzW_1BJUDDAt9HE=0tPUs=Yhx z-XgHeI3+YG(M2o`Bp9@LRN?ezbrH7Bx!B$DxDE6X`pIKbDiVNr*#xXUf&6HVJ~z;w zJqA&yy1}((2wis}FQOsgi(TSwKw}vK2ejZvlc@6&jyWU3OvG`4tL45`cF|=)NuO2V zNQA;ADe(-IbFLB*o-dVgHHr6}Z$D0A1p0-SA|9|n@Vbz!7?X(o-W4$V@(p;fvid77 z8al?lJ*r9;y_jI?z}M)aOG`*xy{*s5SpqY$KAs#T#QAzrL~-VilG1v&_=n;fZLN9j z!7-*9GMs7aAJ8D20c?$wDhO>@msrFu3g-2=r*qx@b>IIn2Th8lGVv!nYq!@sk9v0C zf&Z_Jrm;G&u2rp<7l68yKh4ypH!Ab>4~p!+tqizy0h#@F?@<_`;?q$rN8AcKO{^y7 z_QSJInTZbfCXff&%WyDwWc0fnB3W&^xzB~@J@D9j!#@EN`bnQQc!n9TmaJ&^A+$egelBBP2|UHt&NAR5X?*j*gDiRE)0Rr&^6fS5V%AbfSM+s+a(mL_wPZ_9(hco>sg?(tVTVQ9^kqKx zN)anE7U3`!3GlMZ2NMqI)bj*K78W)yys&;ou6cBKax!Mb#U|_3s8oul9O6pg4?L*B zal%E-*VTKH?)cW~FHDJYKW%?Wu4oVzOhFJ_u1%UgrVgWR!#Ug614Rs3G%43TQlZUBPeq8s~C7!*nE?2bHv$=Tw zrACMwM0hrb-vfiNJ!nO5PBBW%A~mP|%4>9$VL zPqT_s`(eW-Vjt65FZ;C=%rquGgahm|3TB4@HAprcVL>cK#GUPu|LnYqq~0w^lwLyR z??}6T{aAYVt;G**4)*jc%(IiwXzd(Z0BnuBQmz-p)i=F@%HQr+Y=#BU3V$Shn;a7Z zgIf^zs6OS%ctt$9DOVEI(OCT--ys!n_V&(RNR3a-+8kv{k-y4qEl{)AxlN745U~Hz z-KL9O;Tn^vI4Q#9FrU$vH!t6TnmE5BTujtPt&q7^IAz%Wkpb!$*4`QEvEn z@vKVryYv(nIOo36vog~cgLBjmFee#p_lA~^N>HVi9-SwS(`qit-{jT4kawY78)Y5> zA@^iXn>Y#RJqbaMvU&u0U=Lt4`*o>z)mV0Mgv-IZuH^uNkKi)lM~jWphAp9M+1(@vHSy;Rg^-{oy7($Ed4w{%&* zNPev6am^L>c17Rk7Z*#;E(Yz0Wo)M1xb&47fX1YsA=axNp1v>=JUF)XJg!sv83iQd zmEWb>p4ZC?xVgE-pSLOWupUjZJ;X`atiE)=R1GktNaVi?g$7nP>%L5c zH6bY=r9#hv%22L(bsL$8EX#_m{G{{tU3M^Awveub_eJWB3pNws}P560~MHjnJvq z=;JW2xGAH+Z)tP|ky${_dD7p|R(vQzht=A`cEoZK`Yh^qF^^A%v%rk30nQe0UYBFQE8x&LROoto_nzcSBTx z9|>t{ZVs@3npAvj%tl)}a~RN+b37tSsk*Gzd&ak8Mc0Zcp+Niookuu``UFn{@WjSl zc@{*6;Yb!JdJ>}^D}EeVpTH**oPxs9m;V&g(vZMX{%jpJDtq{Me)nqQFu{yB66poX993~)(15VZdB(KUdK+3{At=4@aIi~XH$>VfRU1u>!*(CDj=kF#lAFrtKDkz#8u_J+n}CB4G|Vp+m^C z0xTI+ojKK)lEMi`-gv$06-{B6alb*z^n4%C6GNfZum%$JiK_BBxRk1(knj*>**+~( zF^gpTMr9a0FIR0|RtjPbU8~465}fn?QDgGDvoNWwd7?u6(u(U5zjq%%w}RpZQ%Ba2 zb*YGl#|KAfw7!4j?BbJ63!ArW@2k|QF#@D;aA-)P$>qqBlHW9tI|N>7ZpwC<>S{k9 z@N)I_<^nx%0LtL-nZJaD2V)fGAph6X+Si@Bm8vxrB=eEK!_P&NfQDkX#nIG^KKD${ z4E2TE6jN=FMp>J*bwH1-amD>ut={oJazirk6n{zHRvlJiSyRX!`ZG86I)2v*AT-&a z$h_#2B3lV4(bQ%dijSRm=Orp>_oHEJpO}O@xJRM-}PXKdo zh*9yt?_+E}<@#+sH9^0AGh;Z2Zv_O%OjcG`&m@Qb_uCr&+DNV&Fa=tx2dKE4y0&Z4 z7x7uHQxQUfh*IjQQ|^^DHC{i2i{n&@QWj=)AIrJiR>Szkw=+?F`MffbV$Cdg5h|AR zM>1@VGH0u8dQ!kt`z9{9*PH(0r zMlUXQGxxMcf+vRxaFbtKFUCxF7CTnjMFb$DSFOTCN-(> z#M=8>$xH;ePj?kGZ+lx;><#s6xJs6l+l$GuZ4}xs!vTcuj=Rv+19uGK z(a-&4f4CVOxt0+zb9+4(UX2_-rR!H~BAIacL0%aZsr6smQwV=99}T@B6kY&;1?Sk| z9k>q@Vo2m(U$P`S{r>&?mh;59|JI|nAwuA|NpgVpv{nXN{Mr6HTd-Huz+C}bQ>6LYCYo8^mA5pyL+pP=SZ#qRqJQt3Hb(R zB28Q1CO+SX+~*+etx!D=X1ck(UP5Z$yvH;02A|dJrA*K(@$wYV>IBi(*VfRGxNX7I zohq9tSg{r~04|c8eLkGEjNC#hM^h6nk_0widK9^6ErnXA<+=>*np18^7F*OX*30S~ z2E^MABi8)Y;vt)a<62Y!)1S+I_Jic2(4yq?eSlcatG902-M8}czWTxCNiwZ)YY?$X zF7R1)Qi{=OxUwFzg&6~Oak|yDJ=u_S!Nq2Kz_{HuRLYo{QjmQK#C0rtgk)#-r zY2C47^?sIUc>baL@EgZVQtBqf9(EY6D7pgAi7a2$C zfeQ^GXrSGNyit|*-!Huo^mg?kYKuqsQvoR0vcB{H6C9M!i?*K|Sq$UbsYCM!PHs2f zcQYOs4sfOMl3rOFPMflUrtxMonA_$ar%AI4>m!VK3i@NhJdkdb-In6v+CmSLc z;SC^4GMIebuXRkwUH$O3C+eAowyTa@luM9@$(b|v1r2kQXXj?28M+d{O(E|Ehk08_ z3L9){p{*copQ*d&{!rzy1p!=2vKA_FkP%IdQ+IGTyGC>5h$`C(&l!buC>h~KtJK7_ z)Q4~eqBvEkNe?H2LZkwaBOG(V#bLNED`J4ESNEJdIpA@JqbGv$rzc!`u+!R9$QVh zTRmHxl>S8V!K(H5MMc~0K?~-bSPky=00wqKt=w32;tvUwiP99o5p1TsUKERj*aoy*!7Agf8-KZJmEZ=^Z#)M8B7B$AJ4PSt;1t|azrU#H9zX! z_OXtoTh@iOYGwl6BD`@NL_HyBrf{G@5NvL%fUwiJ%171hkwc7OA|IL ztiXL-UE{y}dslyDvfoP3MqnaY@US;&iAOD(1BC6L`X*lsYOeP|9*+QIRILd!+=2nr zx5}HlP#9Xv_N30?@SZ~=!m%1H)+QiMW<#O?6483%2AkgHS~r(dOtgZ`uYF;rm651^ zEU9#Jsnfiv10sF_=w1ndT(VtnagdMeV*ANWNo=4d5^D0~kh5cRVBp8ol1~6_Kz_%_ z)HuROQ78{k$e;lcnyyF3A3SNh-D9eyuWu#OvQH1m*s>Z}OQf`g4{#jP)<)6QEZf07 zEJ|P##*smCxmR_3D)sBymnGaLtX}@cjg2EQOU4cj7ZggI()T{Lv5y6CR3cDQ!x&I z5@Ho_Ay#7%#tk=-nHVUJKA4#*Ai_1u{$u_&WL;Paa^3WXMhEF=LPdwSdvK8>5ihPt z;G>?Zf}c-JHF>^YuC>oT*AOv}2eVGyVDmi$jUUf=jK-lF6Mp}Qzu|a{zsF&Mg%|9X zp~HXtyZ-V6>=c6fp?7yWgTrqAis(ouH11hz(o!+DftXZdefE^81CZ0=F7y_6KOO*L z8SC)qTTNejdWXX#hY({Awbc!8vF!xrmEw2-9KHg)@uca^ zgsUB?+#Vj>sKtz1J?3M0;CRQyg<(&sG6);93jAD`Cc(Sj!yhe5e*>b;1p(A_b$)42EMa3hAj^&fk+ zeuYcEJU{^A1_F>Z8<4I?;uEFUV*qWVQjyRS1ZG{_llx1`%y(BGoJVD?v&UPL${GM@ zHxRHgfJuAf56Udn`@FtVf{EjGhS>MZI~s~Ic&6H)S5RoA%2yr^AeDs%yqJmZmnU<) zK%bMgdnbi1qhXtkp5aLUWK^fw@k?HXaUWEr4#_rstNLz*=+T zZFe^Y5pXM`+$~hBC!xi_{fZUh#X-Jcs3HF8s#e(C6_BMt^?EKLJr>XdjzX2^XU+3H zmpW~qfg%?4uOBG_GXO!Tx)g0;Iiv;^hi$S7exFe=Hv>V;^=37JT^>ut`kQ|~A7(Rj z1?84vQ}PsOg}yo}bxznwGyRXLy$hX{>OV8(b~{P=o)TN+sw_Izx&DG1YJH%|62EEA zH5oY(fuxg6eX;&-s1u$*`~)~T?jYgAAi=qXJ-_QZzfMNjSs=|a@o~SVj#|kBcWTbx z*J|l5Q|95fT^iJ!cng-qEdV`7V&CjtpSg{naN`b*U=qHap<@03mW8ryHNJuxO^yI) z?w`R1SaW=h1IogYK3*4{Hh*d&Kd3G?^O6$zH~m~}D~SRYoi+$~F!f}VwTOgtLB&)? zzE+K?Ge(mD_eh5`@P(Rh?f%Nzn3CD0YjOy7Sx$96d0Ba=&0 z6iB3*4DainzRA8{alV@y?gMls1LWZ!+*IlS?-vfG!<(cpzZo4ST$)%)2YP3*hJi1i z>7rDb0%zHT4FaE6w+WwCdV{Btg+ba|Y`aJu9-FJ#Yj}52$Wzn`=WAHT^bxs{#7i4w z7B8Mpf4XSYY!)oT4aOq2T`XB8cSonSkW>h;mKqo1Y<_agz)(Z5cDa)i(53Wm+- zJ-+!hO=ztup72*y`~=CYm+MlJ6AAErIQK5R=&U(|-|GMRTtF$EX%KKZ>Z8tr$2~6* zrQH0f?iXctl2hV$2ZsVzNMz)mDVA9-D#p|yPe9RUKHsye&TTUuuTn z&kD6kJ#CMT3tw50u-RPt{y1scNA|HbF%KG6EV87jlN=X>bT|l#ABJtYb1@FkC+af! zah5$LBd;X*TI*c<^!>ITaPMVz&4&m;-(n>9@X`RJ%}HCEMc?M1yhX$>n3$zl6qQvX zFjBZ=&^&v;f#k#%zAtd>FB_F+?Q!E#`$oY?LQ{8IYnQ+A0U$nLu$y(kOwTW8RYQ^8_ zzYh~EKb`RD1dBk+NSDnd_$!D47*!`D=Zv%|#3CQ#e;G*PtQOJZKW%*Oee^EK_9DTO zH{bQ?I_~|e0P;`3g@MMt&gT@C?tx5;ms5evR#N)kEmhbVRFK@$`S!?AE*2lv^~GM@ zJ6I;_8=@c_-z{I4bAn;itZ2Ww-@9cHQ;34Dz=BisB{rINufAS~&V7z6#a{8RCZ5#{ z!a@z;C5zF>cZ2M?y5atjH*?cX4+B6;OguK#)8gGNhO=84Et%;P?%c5?380KiC2Wim zG~fgXb;};4`tU?a{8Nd*&MRNAQfW<{l8u9Dsqy^xRUD7(7&9-SWE3Q`J^J&B-^z#g z>{m2+SWX-)F?Cq%Ky`H=m#@ao+BzQX9m9fU^nKUcOy>oDH>&|qN(NX7w^y5_Z$ppn zg-y$$w~CHJcm>VxJn@&4e$HiiGc?bwRDZUWTm?z#P*C>k$PwVS9;gVu15tWj*Q;5{ zB-z7d16|`&wo49$cE}x}LT=@FYnF-0MT186hL^5(=|YS5{EL;^cgCc8O3kt}x(DT` zEnj&CRExU@EL4+I6Q-&arp9AamxB}8H`Kf%FAbE5=;pkqNA z26@FA6gWN4-R&+*A(6%=DvBcyYW zWyM5$v7~r6jf-Mz)>rxsJyY--E?$@&_nb#=PogQp9X}=hJL#4HYre*7LG|-Zn&uCd z$1sw(l0$Nk&**bM6!=(g6a9rW!Q~MneMmr{W?Mx1tElOZPmdr2DxiYra+3>&_n#Niq%{)BOG*8;mEMZeO!-1|=fYhnLR zkACPm2ct%=`Q2y>qk35A=bna}7A_o~Pnf6%L0jMQ^0Vc(l9fFqBqZ^(Gqkhce&jn0 z41zkU>ujC|aa#EDVs06I@+5>DLkuTJmw`nZPQmcX6cBbRR zXb$94)plOr?x_ybS(7qHBZuR#%dg5gGmac!TY#>GCruDc%P@b`+-V^M_xlT?u+x`6 zU9(_goGWIzn7```{51^mK&rxdJiMj@3JG7(xttYho__M;$l1cjS$@!it_MUNn&vB_ z&rxRzIDnfErI(QdFu!B(Kzdej81#zkqN-^-C<}|n{UHRnzVJ+-_>^MT+w6$eB-WHt zn3P{)@s5K=RpZtcTy5T*slkn)+R%BT0yzjjqdv3qU#SE5R0mGXh+SG4fu0WSLt;Jw zkQ#mB)>&WiL;?^=J3w}`zk3U#J^?eHS4Eb5!^fKT2;1(96l8jO;h^nktNud2b$?;K zuJK4LB)KMCZ7G00a085<0b1z-&d~z~Sq5=X>2(CA1JX!iTLO{Y5vd;!Nb?2w`5jrO zdm2=>cCWQv112?PUh%^4t(nA+!EnUc2zruBWmo(og)4)T1FzwUI78|Y{(Alz{2wXBeYRZzp zN%cTZJNdyQAho^KE%lrfNx8dZu4i1zm(X0Tei0)2f{M2@1Vx|Y@7-gm5q#qYRGodV z;%_hr?c?F$*{e7=(#W;1{NE}cu{@!+#78h7?d>{s& zn!T{3zh%q=AbVxu>7P33zY-^WB!<0sb?`W>Nz|B*=8y7PzZ7_U>#lE}b+)h$Ci@wMIP|tlum1cNUurhxlp|fz z7D9Tqv(P1dfIhC&0a$S$LY{ZSW2PP8ni}M2gQ}_{ZzHFM;2xtbQK1WFmEhdGmEAdk zwxMOg9UR+SouR?b^vIO5dG%7l+ zuy^s^TYxPGvSICo1tzQ-}CEJFUqB_VjOLhbGW#hGv4%%V&lTh6u` z*;PTXPuCg<(d667)puP5PIRr*LL;E#bi1=xV7c=pl*F&*4zHat%j}km>Mbq8RP+lI z&+Bi!@C0Zx<;Xu;S)tHR0~jT!XuM86qP)pEX1!*Nxk9{MiEd|`mE%xxtyPOS(w|04 zKo?W-bWB(6=0Y67y>~aAS&ry#@08oE^=aXfnh`Xz>v-IDA z?}lWW9O2|N^a})5e^fk84h%FpkO(O3Z*%C!fwIsYATyAwGODDza5f=Fg4HGORZXZ- z-cB9a?^T1q48JX_P=#U0IAYbv;eZ;APQhXN%z0FskB=`D%KWNOm{Qo(S-?bfN(`Vu zWXL*Xd1DBVrs zM}AOsum-j6rKoaNk@eID8$mC8nrT2rwxBRrFL5c_2z^D*sKPY#b2K4O3Q* zCf48g?|orX*z4vlw2EYtjd)O{8kJY(j&)HywU7qFVg1~d&MDQ5VyKp*+uMdUq?miw zb^CIWQbKnyG7GaJBSKBcIXn)%;d@ z9!4>lS-U7cnTT^8J5?!V#%-)&e>&LI0Qu1Z;-%JU*A7OZlT4n}8J(1358D^~TXT1I z1&}5LS~ir!eE=#e)@PSj(pKAQjAq5&0o4)N&aY{=fEH_%E5*`=gL?fS z>Yr@*-e9#7hCj%q+ZvVzUEWt@c`w^2g(KB7&^2~Wev0?%{l{sG&k-2tlrLwCmyGRC ztkk^jyuNv8zR-OH(ln~Jc)e7?flF9=8sTo|2%--uw-|uQx13|c*&>2aIXUedO4wt1h*A>xp8zG`(i%Gz+EVH&x3Zu``WZF$oF# zfTT{Q*=JRM#4ptod>-d_R}^YQqz%uHG`BKCt#ahKVpJaB~3NF4Wb0n|BBh*eO5*;C{?b%2k4j1n^ zYcMuscydfmDVn{buE8>}VMVL+$mspahUd%Q{4>Yj$}PTBl4hbhnz}XW@wSE)s_N~6 z%j&8-<@IO9K1euyCce)%1DL--FaogoQe!z6JCjLyFF=LRZb^jWGs@V}RX?|IKRdf& zLI0l;zZiSs?E^bvi<9@P&*w*yi4ysaW`p1apQ^5DvHtHLd}DD-h$E5&0ck*p4&ok> z8Tg-MRV@j^>Gw5}HCbKH)%|YH?k1&=JXS&Y&t(JXFw#wqmz)Nu5C}HXqoKPaA|jCK zaE1!8I<^}kqSNONxvv0U#*QQq97OEzR>WNL0zq`W#6k#Y?q2e5b`ER(@ol)q;?8Mq zNT;b&cS1E3UF#Mkaykj1*`sfpvpKutmD_VLkzWmgK*HYZsiDK>xn`ToNSf*j*w01o zJ^albd0E1djGEuBe``*(M}FgWpl_?h0nrO1=6P&Vm$po!q~A*J8L=h+ zr(|uZer@$RppLl0Q`(!qYLLAi-+|;xbWh%LdHZe;qoy>k6t82c^UZo|$NOUjdlQ|k zjt(u9h-keig@9SXyZ%E3!kQ2)j-=)x-+c%?gYxjXg;ux$Yk*PB2?jNy>__mufWIlM z#7YR~myMSc7kY@BP9V!(AyG?6-#$!l;^er#?>MZ8pj`V+5 zik*S2s)s3pIPezf!V=U&r7I*fZZ(!eI>GNU))ESFxFO*<2mo`WuyC2_vbG~SQIY>m zg~!=Pc-OCO+~@#hbecP5TKE&4zDhp9a;Uu{#jnCT4Ow<6kcAX?A~h@UB{`h=YDTrH zs_JV_K9WoV3C|iJN7^i(8Y93pZ@(AjI4f+DzvUCHtbmrT-t zn)-UC+GdfPSgC_DmjHRy1|mhe#%5~PM>%(2ZdrQqVp6Q+$L(1-?F%pEIS#2J57Ffi z)hur~+w~gqkTVW!qaoC=1{_PxV&+Fvp-SxA;%1L88H`8W0Gc0gnvVnC%>yEYn#w+f z3ONA>K&y1sPi=R<3+L}U69$8JpDDAHS)o_d_n6~n4Tw^_1jaAV{{~)>I~&IP;7<_T zuqtOE3aAP)2K z#WnGC*xbUzK+Kn>`T;@gju*6@>aPVT@L51k#{(blcl3)9n0K1(c`l95mGxO$= zyNTSJi%AIr<{W{9-Y7rRNG-TeNGK8lZ~b5>z_rKNX9Mq5&j+YgmN6F+lWZH>zC(P; z?{4`0yRu*JHO)tFRV$Nd4IC~uS+_ZEof2|O%s6|A+YuD&@CYwEnZLyA*pOWg zRkjKA)5FahdYu-%a#0}997{_6!-%8g$#s^89$%dM{r3?YBG`QttFxM`^uWZ{i3p*8 zi`N1eS>(QVfwoS3An`!u)`YcI&n#r5RrY3eLU z>_}*3=E~T$_DwSO3PXg?6vL~33adc$*LeN$T{S4l7~8B5u>Agf>tDEgPl)@-qnFis z)NB7*nLOEecmEzvK0a$$wv2>Z=N6(uTehN)I6_G@-|2ZKVlEU0RYt(nr0IFFDi6E~ zwwzKLlnXzF9HAx$35UJ9#kGezuZC+#riJYNdjfc~Fh#?ZUBd=F`#(71mWTvV+5rCo zy@;h?i|X1aRPzgi(UDp+^sg~90R}*&#Ok1M8SZlmY9NPffgHhl*Xh3}KuZG)P2Surd-YF+ zDXy<(-rGJNiH2s6x`tbr2ND_9mRq7A5ePJ!q@)4cu~N|JkA?Wxmuzjfwy|+^Io8pf%!%<50py#Qo_ww0fF}i4G}Tq2XyA?J4PF?H#zHz)Hxh; z<F(a5cFT!rT#D9-n~t!d)T1vYs-1uRJ#$SdDQ$LW8WQ*b^rZ;CnQuV zQMO9iLUy>)QbuL(RrZ#ZeO0KG+!aDbWn}LW8JQ)a%m^V7*?a%a>$)zj`*Yvl-#_=G z+qk^n@7H;s^E}V++%1I<%#TE^akOM z9{)UldnYk(DJacOQ*>QurgU<``LrKDi*4O)7Z@{JeKG)fg-#Ns~dsXx8# zOMcW^X*?b>_q$KrM6^!zoR+)ZGpb}i;o`xA#*RtIbw#(nP#Ped=hE#mAXCbHHholA zQ4BwtnC_@Az4f;{{Qc%D*Im@#?iY^Fb>8jbF`gD8>q zmZ)@B$EA2DVlqd07ALE&Or8Po(C9<8;C1e-lqyj@o!}**)UPI;j{@zG9#+@+Bb(LB z$!cF2ZxGtv06_=s2R7U_VY^vyulYjst=}(;YRD70VRD+b;6fRiBpUmz;a}n>G`|HhU^2E;nhVc6H#q z9Jmg@GRX6F%}`cMVg4ro`NiJQBYueimvrUC#lbBNG`~N9nBQG+P{+LME!oBDive4y zh6;Qv?HKd#KfqnYQEiso9vJ^)?kv#~y+`)0wy-}Nn8M7RGFYokN26_(Dc=i{Jk;H! zcIe%o&Sv9g*#n^W(Rd%n=t109%s0)ykJSzTd$=Uq$9H%y4)3>A7bdE~iC`n(h*-(f)3! zEEn`yoB|gUdQ!%_9*JEs$$9~Y_2$m59}bX{C~>)- zL3z=E@bip&9$g9)BiAGe;0lucx6eYS+Q^2p#N6h92TGhDeltWL%s7p#q~jNcCK?V{%&MbUH@@6xe;UU59|u;sW9MvxewjL3uT*w>bw(p*&N1G&luCc`@I@NqP@JkUyK+<1&(hpiZ&wnD6jibJa_{yM?)WfQiD6=thS_)6FZBQ65S6=2#{8bv?|8`b$6?u0 zLl74UOp-!ABNt9e%iSXvCZq%`>4h56d^n&Iz zzklYBU&ibs8P;Wnu}U22C)p1?5yk}=YzX!9{Cl=7lPtWCob~QN$cX%4`RB586VDZ`9cAnpF6i%Xz3L35NHYg2DAOHZ0b2zDp$AitsA3`(uVHWryS12ZrvVyYs>9BUV~w z8ccY5#Gymh2cu51Lf@t;)`<%a*j6f8h~9TY%ulJ7O{%Gu1M?xta|F6PGG39=Urt(t zDrPy55aIux&DC;VfPFQll(phdI}~t_eoehh^1|KqL$P&TgUt)}7Y^W#ls&l&+LxKf zfZNUcigpS10`@WgaUg%XVuD4sk&rriHl^8q^Lv`s`SCv92p9CRD91U$51VJ}vPkf! z7Q;Z4=>I~}Q6(_5=^T9Np=#OUx2(X&&bwKTaABKEZL>S7-3ULLOAP$R_kL~5J9o}l z-t}*#g0vsjVk+L;)Nhdhi{%RbJ*i>O#T1X&L#TGs5Zd4~u3?4?IGwz;c8ABKzYMn$ zbC5`S;nj}vQ?$C&eakFsXoE~_OZZQU<;Uyv;~z1zBw4oG%`dnsi%<(aw`d_ekm8dp z-hx^E0eS)%g~!nkdn&Tz?wDtBiC(4~Is#9YjuYV7(VR^%;rz#E`Cu5ape%dz&i0YG z2G7ICbon$EQStCP2N1VvT)Hb`3r#xjH?pQ*ehvS4SuUtyAqmudz%_EyLWJ->a$}qA zgTb-h^>ZUQRubs^(e19b6vO|-KR*V(f~DCr)ON@D#gpgzh6zp|-Yn*mhnzg#7rCW~ z;2)L?dF)&-llXAtrBrqJirF4O&}#d(j>2=iNEDb(&z8!Bd#p#6i4s?xhehhXx5eTz zKK5s27RjkBtB~@h~{Lf2(s{?8R*27`o;Al-haR2<3-|z)ifTFpG2^d6W zy;~Pd&ROHJg2GPOuJz`Je$S7_1}5LR$4B}fC-UQ4*sl~v2kOnh*t|dI;w|T)F4&sG z@WRvYp3Ppk8*QW|R@$ULy}VfRIp!WZtVYpIrOfoEsfWPuxIXvfSGy(O#aYeF4S*_- zJU!0Ky4Z#RW7tji@HCu16^)MFE8zAhF0<>oeT)0?w*EBL4V!buHcyjeo=GSe%FJ; zpr_yRm&b+SBKwl=T_qehmTB&rXR#Um&{3RB(w7|hY026aM8g2xpFop&;5^nDNfa zw$JbB$3rUkFAq%fQb9L_qM?6Y#EW)g9N>_;qvq@LM;{PNjp8`q}qp>{72In7- zXo3Q%0=DGQ!Fa|FfmLp~6Md7@kf-hIqwpPsL~FZH5wvL;h8c%!v%o^*~Ko*}Cm*;$*0PJTJph={4-+Z&DX?22A^%=QepVu!pj{g9{RV<}Jw&m&a zefBZl9<^{T)o(z_|la|e{Y3nb<&XQW9h zU0bRZmR|nYP#(m3qNA&N1CYERO1w1kHBWYwa0I3#Q*EVvbF+GW?H{uSa1{XuiaP1_ z72oZ5eyPID7-LCjG-4W8VF*ycKT9)ax>&b)%+=}`ryBXUxW|JzLp(g%FOijcOn0|z zSi;!(5v^}|1gh`9pC7ynxJs6SGHfgoAM$(p@b*!HAx2@=+Mj&fqB`5b5lJ{MeU{m* zkrl6!)mrV6iJ_0XU8{Sp|?R)f36^a zLj=T2FEN}2!vOl1UQ+z^#|wCf0J@skE%59L3y?Omfyr7=tULbA+J1YYF?#0k7^LQ6@`IO`lfiQ@=Rm(CpZy>F{ z4mJ-Of_>FmF>Q{i@^OsUq~IQ;sX>o@H&k=}&a885hE|oR;fyCvru9@;Yw6& z3D=c6{u-;$E?RPEZ{Q>Ey7Q`slydI{+4Msv$AOwuq2-DOdQFgP1Hkb>sHd^K{u%HwvuO2Ff^m#F3CV{q{J1_kZxMGHzU* zYE?w0;pyMm*&W+XWj{03#+?#WabbKPFE_j@y-=1&Uug^Oj@=%jR70!F(J4$g`AbmS zm}o93$xKz!Rwscr2#t0}SUl{TQ-27ifJnmN*=HGHK)2t&EF(3fU3V1TvBqw>-9{M& zun3S_Sr0Vmf^YvMNw8ykpxh-FDLvAy6%2@S6VY9&oAYPoBgKVYf^*bOvT2Mt9yY2p z=qb1l|Io4b$x^avISpaJNXqvEwnd|PA1$1QJ7z!y^x>Pp`fAU*rM+(?xsbjh6(eEs*x>>MDAap^Q@|mSsl|zke zAJog6g7;hD85R>c0|1W{gVEkz+WRb1bJav=o0U65BqRh;(tZfZV;6vR7BtV+y186! z5mR8%jk-WuG^77Kht0%&LLXLy3RWC8hd&`FI896<9)EGp23h=f{gGgtd^;f#^(y!! z5q(G74h>dy<6%8|jrkaP&Pd_^Zp<{I zuehzKuWN+Wax^M$>M{z-isCGK{2|iPX_(~Z9bIh)Fl9^H6D}`3M3rMmh!l1` zitM?kV3B2ka0x5mRi~S0@$Rqj15x%;YWIh`;|K0uscShyswJ}3@mX1*#8^8GJ1>np zD1ZE%+H~`qgiz5TTY=I`P@+kCwMp6+CdutzsqtPpQvlsW6)=QKQljc(2+n*R&$5gi zwoH(mYd??zFd_GBWH{)m><+ERo_!$jmQl0aI=_qjBWwfl-2g^E<4epSu~OTYW0xAQ zbf3c~wp|>b*Am8>9~WmS)u>dP&dFQjX`bI=&rhhk@dCw25Qk6AIf+m^)iiQk$9?tT zd4uvBTf*a(r^$9J;7e;L^>BsRSiTN) zkyM>RK#eyDH0nOFco!M9FJ>r7Z$a|K%=R1<_49?AiDs3a=0Y{N&U<1wEcA?4l+ICtd zfHzBV&O9*3WS%-4=xZD>imykXPhRCe+$64e*^{*OnC_xMl~ zu~nFFQz||As&BYcgFtLLW|zT=XB~EXkgD>b;4y2buD&B_yXa>h87Cz4_>rl)odzQ5 z{OE{#ymOp$J_byd;#B=(vFxDMk2f?<4;P_T(T;h~<<}Ojb*cCi$;azu1Ua0$+UhK{ z#`yJml|qDYs<2$b;InxEnli)gAO0>!5No^GmmoWs|LO;)5=H) zI4{}HuwnPo>*&Khj!g;`oXII441JqR1+%lgZw{&};7kQ{86c0Wl@S!~w93wa6`iyn zB<>$+)45`tr4S~-mVGSQ7tB7-ZW|i>ybV@M_N54KD3X5o@1fJ!m8-KFj>9@vMbr}6 z2`{}riOC?H%MOv$HX5AYxAfPp`Tseha|e&aoV0FHA$-giBDflbyAzG zV={WdxsZkGxtTxWzjV6Ti2NI>RiK=s0={s6(<7t8g2Q*lQ3(Ohe)^v0!~yj17PXr_ zyUW>Kx;kph6~PM#(h%0}Z0%Y3DstknH;joYhxPTl0S$%~o~r2~0&V_z4fD9*a-{8` z(J;WC>t5*GzsBndds9w${5=hmgmm&Lx!mqy)V-AFqPj=6{sLf9_XjO)8=pUye5Zar zufjE_)zxepR)DPXN{zaX{V7qH7%KR#3k1{U&=$rLlM+Tg-gT98+9Sf zd5V{_t=hdX^?e7T1LBih@AX1Y?B8ccUdz0+(Uz#POo$9a>4D4~faVwfOoxV`xF+=F`Tvszu}34Q@ZxNdhdwnA!T+)yfoT*IAV?Qg)}ds2 z4-hKs?s{gBc!}&lvO*`+BP?mTrY8pk34l7ro+uGx#3XL<*xRKIh7je*{Jr5YX=vBq zo^MJx-*DJC1T?i{8C5jeHx{Nk;jZ}r*D{37w)if5DBGj1lR4EBA7MjR52?TeEW*yE zU$KUuNCAjoogoj@f9Lr5if5D-y5~#Ox6;w>?wfaogWMXxoh5to>ZOdrc7L-OXb8Ts zLu!G=W9I#t(bkLB`fGxu^#Pk6!AtP&oL!D6^XBNPrKj^~3;I^aInZqT!B7@X`NyLC z`X`NF6ki(BIMdBV+A{K*dh?Lyh;|S8q^ks}fBpIQtfY~$Yd1gx^xMx40^AbK7#d7-0t_q8=}PX#ok^k zshb$J^)3qH=|22E*yot^v+H|=yFP`T$z2>JUik>Qf-+= zZ=G||WER#6m&3B+|51{ec?m%!(b7S3JdG6Ra~c_m=00{kX_qt>jUQ$@vq2O7fv`3r zHa>>WY{Q=JUOuRy)3c!XjScUX_hCWUF3#Y!&};a_m&U@f353^7t|)*U~DGYUV+@frps-L%jiPE z-v`e4X?S}W8m{^JzvuXRYrTr)Dl}!fO|g|GmKJvu_VK%nidH)@UJdJ0FI{S}gOT&< zdfj_Be|cwd8@ptL$wOGR7rv!h0H1n4qH>OMpTNOvUebFK{dWXqQUryn%IqdfEiwvV zE`bCCB#nkGs_NTdZjik7effZ%TLU55X-eLd7N&ToV7yy4QjSZTIVTi%7&ChSle?>x z_AcL6NS*NZ z%GcSv^!S=9Zx^Q%A*bE}Z@P_8zOPRum9xeutKf=JaJ1~HK9`a{Y>)K&^N0VJ zmCZO{y;46&i)&{eEu+Kc!LZ=hVODw`Y{ByNKea@*xcB><$T)%2ZORDF*U z6j~UZ5#{npjDGA0?(QP8KL&Esa1LRo?;&p*vEaKpn*(e|ia+s@a-jJn75OEzsfr}G zlZDwxwU%MGQ#TD+TDacwzUw&y%X#o9{g9C26Dmf6kUN?9B&tz#UaP7K-CbSgguK~8 zwMfZM9HxPAOsiL~t$luU1$yTy0L<*`3)l%#_eGhQf{vH=QsGq|2*P@)%C3$M2o9{% zB%F_qYPhedXA)-2IU0cN5#Pn0R%q{d2RrTs^Ig?Cv=th>zg}Ofit$*arEjwlwC}5= zS`SdBoSQ?L7b~gP+tPzs&Jk|YFrUqq?dIpx^wuhT0W-U{epz?E)Fd$_a`7pz1?MkO zkZsR|dtB`1gpcs(hkVMQ(_Q8Dp6gXkj``8{tX*6+^@`{)e${6oRQLN4W51Hej(w8{bFkrR z!51aS9062%kJrsjIqTsn0n>qbc+&ym=YfLoR>W_%gIib@_x*!r|K&c=T@J5AUR)5B;K&bIo>{u<+$-oPl8s4k3T(9awAh*686(#$_{F=xuk8JU$e7)LFPIu?8V=xxZn*Oz;^EVoN7d_GrJ zu;QF)4VyL3vUyW-(_Uw+4&~+pxX!9oGp;|H13p8oWOpXhZhQa`!VXWWB6&5?`BL(phyI0a-Qx;>=)_BABj~8KwY+@Hy9B*rXP7;6cv8FTX!Sk* z7Sk64*2hir!8iU3I%_Y#Lp_2)>DATyB(iv7Pm-M~eOtAqJCHWo@gb1d@;!DNP7KR& zqgce)^Xsp<*%Vv%7Y8hkyob?~mtA3#$guT(0ww$t#2*I~_5q1(4es716lck1q_EBW z!OM@`dPGNd;vLVOGDs@=Yb9av)`HOjOeoR3T2fd%x&u>M8|zJ*ANKl zcaClVfwv>3Ucfxjckd%sQqo(;8IqbHM^DPmUik!bE6A@J#T4u=0VyEL^uZgMl9&(H75%MN}kWd&_YU>KBnGTxYsTXe%w_) zVtvhdmW>z%Rng(+&p0>r!w|2gyrpD87=dkp#*UXm%+^z=^(aBu8P=cdfN{ta2wg37 zw3W~x4d`wALzmvkqS0SN}UmOrKkRvwgt ze-(^?DQw)|p(N4^y9(aiv9*$;Jfv=WyL1Z*fD?@;cBm4SdQQCB65Q}eI@~I^Ma@^? zQc%G{(ZQ0NVqY7!1az82Sj%`|9Y)6kjYBjKA+cO9jL_qGco?sf$w|VP&V5Vm*fNTb zz|d8Y+mjY0_>GG+wflVk`{4tzp2S+(pMf6V4ug7(;{TpJW_|`j!(%95B`Op2oM|y5bv7b)gruY^dt}}!OlWes+dNvy703oO%V65?nmHr;4W6r+n zQ<|_@IG0E$pBJmM?BTY7J-d_$MzFm;kf+DktY^{z7gD0De2aPe=6n%AmZPN3ZS6FsVK4V=$z4`}(Z@`X1P| zGu_Ui;wVIn5y!?x5q@2=RN5c|uFT^R)1RK~x8v+T;kUm@@6a zFVs6|@531q<{7cx)q!9;u$3E#%~v*l8Ses<-c3J<7dHMqB0Z@!2-Y6OA)t5S&ayS$ z^ZzuKMh0kyTY}v7YmQokxWU=%FAVHeBJvzoa@<{9%}1jk;)Zn|j-ew!TNU*sUY9dP`ZJpQ6F z{m|S-HYKuMq(s%?dlH7B0roUGIZZ2C!}=3n8ZCD2ymljN(Oni{zQzfeF0y4Q5$nmWW((4}D^!@Ub6L~=J z(CD=nz1|-{eXXZz#eNxth-p;pylD|f&6O6a_`EJIrt2NanY%VxCD8W}>~4Hq$mz~1 z5LCY2%lY1Nq_>xQKAdociDnS`A5+1Kq)`i{0l~l?1FUI|CBV*~$tSj& zEOzYr@ayrF>KsKL!eOa{^kzQo;iU*b9CeJ!PM^+0s~1>vV<$227cXQ&5txzDvX(I& z(`JBdXf!@}ae?8*e+m|`Pf_Com#_jk9&ds$*casdpRT-LiQqs^~FNlkWuKk?l{S(>s;#@i&lU1yFhoy^Q>;)p9 z8V=TA%=k5QC{L?NqynYsTV@WNg!#g}_xk(27e3@E&g7+|qhmQ$oe;hZ`CagLaBY#>L2kVWMS6hzYt$&o7{m5g}-hj?PIOpPqnpXTE2n|@{CunciJOt0=L0OZ4cy0&hleV!_EKMS4PJkRH**~ z+v30JZc2)ldQy`Od(!X%K9G9KeFlncI}jr#@lD_gedIl)9}r zuxI6Pyy{yq^AK!|v#JCx*%iRa@gdY*89HGDt20?kj*6^z1-wm+XuX7;^qX@V%r?p> z)KtLbj2e2@F}X;Dt=xm8N2K&tK^((K?E*D<+e4|vzL35Mzl1l;5JU_0mm^d&3flAC zR+D+mfJZrB^2i?HGyT1!w-1wo<4XstCgWC^uu9N-3}O)!f+OzTM{eyZ*G{*>TA zp7qRtygS@n*$Wl@ehPPHx1lE;M#J?rB`u@@Xv)vm0bhQD4k$tjbk>yFE=CLq?sK4s z_FlU>KvDr6O^KzY9q*=B-wxiB;(ycw({n6EC^DJXm(th6&jwJ~FRys>OAhEP#~iQQ zo#3&`&qL}s^4hW2m)37@yA5!*3MTikODHKqewp>0{es9>9}F_Le(a z9>ImAvtbQxe7cD)X&xX*Gel7OAwLY>vx6Z<8=`Qm8a1MP1>lL$U&<%|P{j>3lT4cj z{UyAlA<2rHNt?Y@_LJJ^+7{0yX>vs)2H0NO`p@E1IP^fD9uC*JQgae72{dp9`Of@D zo~F4`9MsCSHQ~XzyP;8{2Zt2MC!_8l&>NOE2E6f;XRrET8)sVGl`%j#ZYYTn9JtFQ zDUN2B{h<7RVmsUiZ3OX^XiVvPg!LyF;y{N}l0)!?Hc8+Ck{auPUC9q>ZMgwE%0y$Y zRl#_zq~uc_goc-)Lz@Q43b$tY-aadNG{o(ewQ0oT9s4!LNeXfYwu9$d89F0P&W`~X zqt6fs@`nsyPW@q`im1oxh<-Zpj**^H@6khHiz-yv7Jdu&U#aNV+}XDqX!AgM)W&}~ zfR8H$7Ub1@O@OMJ2+|lue;NZsR;r`HysWFO&U%8EbvB>Q6P2=c>X!mCOOnjLTT%+p zuFKth1qfN0oxQ~`&|`)i-5cEZ*2FYJ(I6AV5?Wg`MQc`_iIHwc^!* zw>h7*h!V%WhL>BkQd{XDK04~M%#Q1|$z|i~FD#7@h!&@rGkGBmRMJ80u32CiC~KH( zpgme<03xe9Yif9q`1mo9JE*IhO7)MI9S9WN|A2;;x8U=&2`JFgY``wH-H4>CfB{kW z&0E1!?Lz=sUdyW&Sg_Xzt1SPXjfV&KEMpk>LiQh8fgkXQjt`j))AQri3ZF;-s@&ko(pgDu#Jxg4s0b}hj2Wlc!H>Iw}zJ~D!ssHb0 z0x*5K^iUW<$iEa`24afcFsk*LeEy}0K;VA`9<;Xjf=hg!@eK@zHVVkXAFa4CnJ`Df zBE{u^gQe4epeX47md{G(0ad4dx^0V9wia_IT}^yZ z0vbU8OmfKutKpu2mCajy?^^7FJskAgVR5A$fJc9ny1oQffOWn6b@+GdY(xVrz#M4C zdf1SMk}8wx=R6O>l(sgnMXJ(AEqST7Eh1@(Ch>~4TFBoY2pN#rrsakDtFw+a{qLK~ zYY)S~5ibbywBq#FTbm^Y!^ICrd4D^XTQ=@7D1jzHB=f3C^}iTF`$9Kf(3oHnUXbF* zOryIMYPP6e$t`tja|Fv;gY}52?+7CG4LocniK}iGN2j(q@DTjT_iXJ!i6HTKi^x`U zLP5Tf8;iL2y+?SZs|Kg0m4{2J0Q*Zku!a!$mb=Cm-jnQqmd-bv1M-}hWQwCx-3cLE zY1&>Z<}cA=mT~rn(Wfq$s^y~SVuECWH8p!HjN8K%>J78u6@B^RGtEF`d-Ks1;=9cL zV=4SXUfIibno`fTtZau#r!A!OKAJ?>HD5gAyZ5M#nz9v4t(nWG(yxUpHGNQJ;i#8^}^VP*xdbMiBtx1{eDFe;A1V!d5LX{B*dh$Iw`}{IfQ9#o^ zt*%yyu}4d<%fY$pwZCkQFLZ#JqAee{drJW`-+Nek@hohk*v%OYy5cK{vK5$HEPvVp zOr_eJQsAw=sB80vVTQ-qA<5FrKZ>sf;z9{lk0oeblBwv+{5ih88oKBi$$UmdZz$#& zm?(JMs)a=ok!O>6gFf73?a;<%F-ETrkEW{1=QD=;+*8da|LP|N$=FcN@1yMIjSjaz@8tjfb6Iqi__hs z09qz_l<_@&ERCwz=C$HvTdmgEB z7-&(Ac5u;u8-2)|-O;^Ff+q6+-pY(O5>0G_`%9?R+PsX z!nCsBm;8+rAc+q9#2dYLb8*}f-P?1X>C>Gx10F|;Kzw7O*SZX+v`08VI>s?UL44#E7L2uHR33)@F9xQ!!^?aH@Wn@?(fUs0jwwgH&?I(<7#?mF}D?Y$cY2=gUiaE3D#H{o(vE6eus z8+>wsqAF$0@hyza0|xepXK9C8q`*LxZ*xEkdDzC(ifu4->%h%TaqaUf+*FZ>}3?XlPLDSV_00Rzn=+DU8eX=C9~jnAD()?eiWxmM{`fa!Ye z5VN`Xq8UKg6@MEP2;7f7=RO8wu7>TQId>pv-K)kgp+rCKTaX`AyFN1$t?^8&;vd%l zEtI8aYa030NACSivy1&f8H&}=J<6yCd~}`((&8DydSf19mjG<9k=rq8G3ePrWKoW_ za^y!a<`XM?((q}Z<*9Y_TKX_zflZHb;IVEoZAh1A1W)piLLVOL3$umhC4S&JVnUk%Izys`=#; z5mR%sDhXY&U9Sz*@v|??6tD={SJHc1B%s8|3KFo~vy4&Fh)lZ*ZftA<6jK|hZWGbF zoiLw3Y)n$qQtB^FhW=(zm-ub`1=><&ogUNg)Y%&klcd_fHCNe6-GZU!E-d$4Fk=! zVnn}ZRFIozpTo&6Hyxf@L{&PE`^Mne0Yt>yB1-&x9uRS#kK>7!#Ywrl_NK|VUKLFp zf29Puq)!%_1ali=&T<75Z-dUt@omD-K zn1D6Zf^B5LGEF}ejaZo~Y@r^9G&mH=sd-w44^&nc$4?nP^FCM^DplP>lo_=Uaq0Rt z;pd^bJf2fu-t_W$FUk!V-?zTC{zwyo{M6YHxr0GVW8i?;hVP@vOEJ3Gl}XK_u#Li0 zICRO|y38Cqp-i8K8(}w;RR)RSUQ|-4o165Qg}So<^dgADOuPyxXh*%7gW|s*sA3Oq z2uL0(dQ~-{B{Ozj8PA$r@#;|WiJ*zgX%P8|it@|6MPj>V? z%WUIC&YS0_wVr>iC;!qg>3HU^_`N4VI%*yk|K)mlRj~eIt-8R~J{iin5L;!bCLoX* z`X(<)VYEIuLtv^mP3LZ-P-=Z|V4s<`HzU>g_G+Db7d#mNlljiKvGskE_9ex+SNl9b zWL}ZiX%j*Dlwl-rWJF;xuZ1Fzc5_vgk40`1A`*e6rG*=Q(edTW3PdJ4)UhXjp#;i@ zhq<#}@AqA~8u5tL&E;|jWNw{H63}0S$MQNE2b721g`B^)2U>BS4NjU;x z$Ri8?{y_U5=%h;gAt zu&QuWsQ-HJxJy2Zci>^6>c~_<(%WyhkOXWhol+i-p9TR%aaW81Kg%anjuh^8?U%Xm zV(%Sm=n-X)t#N}4-=n9`p_s*CF>m`mf!GT+oEo1X+okW@HnqsnZN_XHZ_D?&69PJI zAY}1DS+`$(?x3h^M|Ptt((QWb=BqCj3413Np=w15f~I0~U~+(8?cGrUOxxo(K-@=D z6Uo+40l;M06apmx{8Kg6i`0n_lQIB?r8s`(q^Evogq#7!lVZ({vB$lOqksrl~(DZ=H-P zclFG2c7u8apyN*${s{-nE@B~e&{!v#Yyev=nKDmB9)3zXyueaR?=!pyoX6-9|Ll)u z;(0*H$#<^Cz#b5qI;*6VrOlt*-p>>bh&2;;EVO@&Eca|EC$KH`+$zYs?NG4{xk4B7|AytpJFkz14b_MX1Q9SQ9- zlqW-WoEC;W#TQDNmv7TS0>>JoK{=NTiZhcbRa&G9seS8ksWI2XF6YtVIb&$#K1+J} zZT{h}_Xb}oeY4l~I#--?1ZFlzi$okTlo=rL1-h}8nje@%f9Cat8pCMMxi_&jzQ?bV z`tFq<1I}uz9Pf+EhMw{_k56?_9Hren(4uJ1FmiVQ#vtxQ6m!S-;H+ov$MW={oq&7< z%J~6Q%q%yf7rz09rhp!p`oo8<`vX`d1SEk<^0n$&YR%`g*09cPAs^{$Pe-(RsA4_% z`LNl^xWB!$FUy|G2R`JRpZxW$RM2?0GWpSp#`FrohF%dZULo0*rU#=9p)AdUbuBq6 z?Kxl6vyFl$=Yo`2wg(8Asfl_jJ!{gvW|QTm@N#IFus69@3dIt>rn|21W?(^LLu?!k zj18v=6z#iNo&^;NK^BDv z%p?vrO`KjunyvC2^Cp-E3UVU~)QES;6UJp9&nTe0MW|)}Z=^9we!1s)mrd)Kb{LE- zSU#t|3s2%U(i5YpcN5V1C*Bkc>PJc7wKn%Qc&}YKRP5Xv`#_O=k#>C@B<>WD9UEE; zZ*+16kil>%SN4=sqzM7l-2AL?r$rQF|lpi*VAK1qhl!p4=5eb3G~& zGBj4w7056{IX8XA%@P6H*$-+P;<4BAa;;Ye>fj}3LK3!fl1Q)N3Uwt;=*o*JTyb$) zn)&vIzQ^)ya(zwSV1jFtN9_nudOKiRv0OV4yn+#^kkacfy<*r7ni&~NKbp=L5Hp~=3G7%*yo;g8bn4mao5)4Kqc+zR>jFD zH*jFThY}ReRySWQ_O(}HuJLa>icvHZ39#q(6m zoQP9y!{{ng`q#;i9#~Q5>ZHZ~7!u-IZmI^uF{n}nPbai^)d72o!&uU5llPLL)KIZq zg4+s}WFUJ79gsiT9JNu=d8o;vmwpUTez`Yv8D1{jInIGbl<$I_Bx9iIDTlJ5?h8_l zh&cdDeo#b96n^t(A7ZQxwjw0%}=w zG@6(H&YS96fqiG4A<2T1iz6%4(G(&Ze(_hQw!uiUG}_}wJvMARwK3{3W}JKlMt!Bc zEMp^`cphnV8=NTZkFkV6B0PE4y4Qcq>eL#;dF0l5 zU=JS}W31C|1q2{>tS;0f4FQ3Yq4sxBN5*_dJ56z=PzB@ms@JmOt|e4`HqHzTl+WC@$YB#bb$e4SafS#*Wm+NWukc8lW%6cNBRL9Z;k(Mr5)^-1-xENKvS4Mj6C5vxkLFX3^d{z zZ#ReOO;GO%JkZfoP8i|}%;40Zs?jpc$FhEy;}1!P@SxQb$1HXYCLhFkV3@AlC)hM8Hn(uc zWi$sA_-(vuUum_>p2&BA;&^9T;c$|C_UW+%=Al34 zAnIlCbyHq64W?P2Q}Xt188vDw>X^+ehMk?MX}liQFZo%tbJDxgf-)6lR-!6>y!g!= zyM=6az4btRv^HeN-VNOO`Ba-Ht6*<7aN`vqNbY#6<)TZeHqW;{#n%gI)ANX$+aUeB zR^>F{t{vEIfyz`eU6+_QCIO7VK=SJT`E!6L#apZum~F!SpqVPF{3ptd zn-&7Xs{lQRR<3r(FS)`Gl4j!{F>JVj<#NMj)c8NusDj-~^#z2W>^X+OwWbi8KTm51 zuAl-EM?GDuWe?Q4X`T?-nrB7mUNDo~w1Y9X`%#@@K%d+q>b5x7n1L_=LifG-&?xzx zTJxhY>5c%A0BJ;lpnMaSn|O_!iI~F^kD$s*xgOdeTA+EmZ4y_OPsEZ+r}GlwR;cpkVd&9 zH4|{5L6i^Gtj|z7(A=}-gS7vg1;#PxN7@FRGx zik1?U@%BUvFS$j7`pI1sF1Z5qv^0nY;?ri6EJOnBUhwVYHB9bSRWaS9{I(49W=y5p zlkQa4mz|v50H$zl>NoN>ns_lsnPlvZ2uW}ZlnB}mNT@2zYwBTDG717cXlpw!@%%FM z0>-byJlo2iN?g<9kOUF`U-bnrOOa6uN}v@;M1JdV)LyT(>1f*4nj7A$ZQipVf@AOC zCQc415KVR%4@Z@OU_CwK-kswrp&-YVpYOL#an)@ni0yGm3LSJ#8XNv`>0$)$a@O62 zjL<03#@8RTa4f|pqST#s_hN*`?$!$BnKDd#$8KSI{!%?)N6y{r*lm?Z!9PuWJMS%i zhe1rB@^};KrYcO(Ep~G<{+tKg(G3W9g1GDxN`VxB*6m+=HPdW45wJNBHfLA|zv_#E z89wS;wiiL}AoD$jiTS0()u}I3TPOm|`!UA$LAjz;^I`TF=m03CF$=ckP7(^GL z#Wm^SI0(IAS)TmR6iX%eWzotjEfGjPj6@gefwzqBe(NuDD-L_Q+yk>i{LxSa28Y+I zsFyjh-E^}fkABIqlgW_f770Ap@hGl5KJON8w6D*7WkHN3?>xiNG->6!Wk^~QbF5cV zb}}=FL7NvM7BT?ms_Si;oTbt~Fg@6?15LYqBxI>}^EzvIEo)FQO|oTE=Xy~~jRu%K z<~^~}cxr&!=>hx{AL2sV*HWG82@ZGDTiM6ltR$>eKh0efAR0Z01fpuBg}1I(tDc{f znu3f+n{hbHt5ws~7cghCTpb>a!8A^&i#64{1fiV>p`3~^pv4MtaDed~(5Mcso;c^T z6W;XtD}A&T*GMQVD)R94{vQU7CE6NW;v(l6sui=Jiy)=N#MlvaEAL4=OMMe(=hS+i zQL+qSV;#3RLoaw1ve~4Suchj@*!~RqzahNOs@M=v*jS9Ia*3O(8*1Q(7ZVqfRbmaI?L_DTgcSO|$Kiea(8t59TvUnw1h}w;_ZP8rmwayT+Cmd>J-O;?OoHfZjmPeS zRc&ev-?{2hQ}{rT=<`lk;(fxS-G;#`rJH)osUlESa$YGu%Fnb#d-#5_Q#PuoH7G z8@I_Qcr<>WO^)+Q5@lD_Q%|dPMEwfX1R?|}c-V#dAc2?Cw^^4MnR5Vj5dP2rqMBRd=Ut-*9it?k4b zax)n=M97|S-HTFlnfGRgPXeRwRR9>%Em&jPh94D7|JidaO7y~ z%EUOd*cfKN6P7!iblYpx^8e9w-GNlL@4pU8lvGB8Xvn5lMiEZ+w#dkq*^m**78$3d zQj(19(?Is#Gm;{stZb2;RSq(L*ZrJB>i2&CdcDGVp8LM;>%PY4^SKP@VW5|h`dbPG zQdw>F6zzj%ksbj}Hn#Yv)t{S_d&d{gvaJ%XB1InD-v;fXU*)>O3VXV(I3m5sNcYrP7*)Y6Y$V6#5d4k|&j1b8FH!sT4{$34)m>x;knfvoa0W@w z6mjIb!E(|~dE&CL9D9g69E}J%>O(GOFb$fP@!q zrlAtpVzFI{g6io4F#aYuMpn%yPm`D7$gLllrQL=EbmOMw;s^8XavM+oB3~s@FjB%Z z`<+8`EZzmaGZs_?WJxBOpMll4p#(jb-WlF_6{wjA{<4Edh?@-P3EhiLad>>=+aBpj z-WxE?q8P#@7Swi8>^iIY=Q`D7z%rdu?TE;*pkbzH>uD8<5;%i!n0V7c)F+%YdNhvN2{w8QPJPFwwy*{U*vDu`Z@O!RWM)u^HUy)1TlMY z@-aC!AzkvZv$_mB4^P*dp}xUaosJm|q|j&ZNSor89|(8uJTl&LY8@K=^XQ^9jHpG0aANq%7 z%6K+~G-#x&WMMpRzKwoMqjPH9-k4uelev!vhwGdkszZ&wY4UqhD*vrcM3O_d(K@BW zP*%}tvsSv9`g9j-;noX% z&n5D{Za`8a=NIOF?UI=&r37ec;qDyl=?1~P2$bEd$0??zd*fOLIub_AV=os{GUA+2 z=>WvlRT_uu=2Jx)^g;nRmxpKj*8;JGVIFp@6!2%$QWBlEHLCuEB%W^^mVET8*OXBg zTkWL^t%PQhfS&H<*=`Y%L&~^y=#yi4?P?o^SR1eO2`E_PwND0#U9s+a|G8l#w#{oG z=Hk5G=%`ituc@@qo~MGTPLcl6q6t%>6R)l2Z7nr?Fy%m;N02f`kPF@hTr+`uT#RReP&~L*tMVo!f?rK}V?= z@dOaJPQ1;wHtExe9d`h2Quw3j#q>4ew6fnpV$F}93e;HN>Mx|XJn4|moqqujQRpy4 zDCa-;aIr6#@fna*!;f`cq1eTCE=CR!fIvIn{|`U4il96YUiADRuHA+?O0YS9uT@b7 zswJAE8byH;y3i+FnhkGl;G@bhniB4k_GISQxD6HZ?9Yq531t_%iI#vl8%=qbED#p) zVU34p#X)@VeY`Yby6wzlPHe!5JS$xCMnlV9NA|%hIfECS&Q(u3WX83#Hl}9ha9m^= zsuYRQh>C4jj5ki6me@bZ{=kj9oAa#IJoInrD*OfMJz0elCbm545DwnX&p11J*~Jms zBHc+44i_{(mY5CRY_MZ|M%~hDIH2+$g^Zm6$sPENhePA(7k1Z#7KI$LIU3Sp_n@)c zylSR(!ai3&C#}M6?-}UaKQaf-DmMGT|P_WNxWf>T2%Q6fqNt4-kOtyFRZ2@?R6f? zo97YDe_Wz#JXkq&i%-FoivQUQ^m=HdTvcPjWJI%hw`VflGB!YROkn z6&@7`lT_l<&MC)nJ}l8*N|Lls zBRDd5c+dsTc7>I8v$?ijlz_jW>a0q#zSO7v@i^x|}hSW{wrS$fw|t-0ae1@8;je{ zJvK9}KCyja>toe?+w|F)RQAUoA_s4zXlVzu<*z+GJY*R+lXW5?s;aF~%U?$4T}E|- zYK2-{`#;fXRLnyIhwEo^brRcHGgXu0yqXr&f(qWI{G6D~)1IjlvGY>PY1UFI+wkp{ z+l+HUJ6nKUZHtzuc0gKs+2xi`4Wj#TR{OJQ=vi)O+w|RSN;THpnKDsCwQ>E&51|oU zxacYN@x>S9Ku1)Lv*2WG=z11S{tLmY2qNno-Si?G)Uc@yJP?rNgyy(u*n8N=8N>`X zC+{q8JxG{Ve)VOPcaqQy6^jz^ZQBC^4{YJAvB!;v84VT~wWz-`r16>`MpRj$4&iE0 zKikZ&b++ZjK}*My9mN2SRT(JBh1^tqjr5~iPsME>P`xX?4ujAAjLf7*Jg4TmMS@d@ zv*Pp~Cq5Mji`NwHb`md}>TPn;z1(7@of}q~Vq_bmSAC(rBC9=s*O?9 zLxS-@Ou#r>eT$2B^~?t~4%Hp8?Fssi%hW726E#O;y&82!d0p&vGvX8t^23@9*kcuQ z6Nbj84+b~ubiz!A5f#FhGE*2ri}fN?FIUo`GEvWSIlawIf5bP05PaTa6{%mXx@gVN zjn1TsqNd?4X?3gS7wfsUNjuph+IR_c+L-`G<$iT)<`=jOq?*k7krBA?|KR4s+niz`Dkc0AMf5>&W~LpFfnHzrXU1R$)0!UFRhQ5OHEVtLrh;|>c4;Bx(0AL%U0t{cw@497(LKYJT0-<2BVPt1H8Jy7!12qgj ziWRWys06N?JI(1DHD2XVZ~zT-@;lO%g`OX8L(}E12rcHgkMN?Sv4OH6Ci8WwaM1-5 zTSRp<#H7}o(!Q<$w}m(@Vn&oeNXXj$!#@+r7LBEc3Z6q6X!lZ)@ec3aj|v%m(^I0s zy;Y$*x~P0p3KXpj<^N<^PY8I=2&MPEd_~#A2b{!3)lKKVDjAK1#T>Nw#J~l>NWG(T z2`<2SVt|sag~x7w3iK9pBvgA*X@Rj1CT$d2ze6`=D+uO&1;TXv#2a>^c?hKv`G<|H z#uTJ$nYiLwkhkb(`K_{3I zf1vyZpg`^-z};5}BClsbeWv;OG`qpOy2tr>mi^NKG)U}NR1Lzs4Lx>%zoFyloVQ!O zIH+*;99UxDJcd?Pm6SbGCI0i8sB zjYPP^?d{?+Nj_e9DS7})@5%!ioP>|#mgR^J_si=SND)}{nQhQ&>VV|=E@DySb+eB; zk}T`pLtF2o$K^Z|C=wyU0WRZwPr2V$@XiX;C^NkV1fI{72o`&-RRmf3x3d#ig%T|| z!EOuOnGfcv&rs)V!79bjU*Cy}Z>Vr(8&F3P8O2gV$y0_PnEMsZdcwz4<7x&7LarN) zaN^V{g%I*5EQRPr?sQDOrlOKe8%%ODhCg(z+6Wk{bN50$D5Q6C9^W5}zwxXG$k+To zIe@7;20G$NKa?X1!cNZgu6yNbTbI|`gB|Bk9>b(8MRPm5eKp%~?K%!8q+&59imwi5 zy~8`Pf>w(J`<~7Bs7hQWUUF#j^uH>x#SH2a&hpuLEd-h2yq7W)+QcCG;-uwi(}^f)-wWx$#JA z_Ib!4QSyTc#G_G=S}B)KI|4L@f1}8Qjq4t49KR<^)Ca|&65#A?MW~!4q)7oi7BPWy zX*_Qg?~W7r)8W3(G&QTOZyDiz>{M3j=rEh|GxGBU7fWr>vMn_zaJr5}hj!1_ja;ao zolVgfw)hy^UZ9qjtK~2o^Yg=JlJT~V!ZMGi@1}krj$U2>2T(D3^5>wAhI%N72U;_9 zw+ZmQAn^zksJqa#eEnnFi^jF`UqlJhGtr?p_C+%%V*;{Nyo?;J5UH>A4~7R&)>u87 zSkas^i1lEMm`>?ss!mmxYdP5Mt{K6B7q&bIx-%s}lXlkgyF<@<7ljM}Du3~L$`oe4 zqf3A;G4F?*(Y18P7mgfzT-`Poa@?N}?+S^yKhQPB*Cdi)+|uNJ%}Pq=aYx%T+KIj1 z`HEeuTqAqw-cGGfUNms)txHZ%M%gvo&y)7~;(D!$mD-E%cyw|LCH>D;UuY6pkbXFS zJhkxYo)ZsW&&9LB&AAoOE?Xt8>P8froatym?4}KiV;dKhx9uMWvrwEyl4C8$S|r<0 zB@7kf?f~y6v6|!vwPpUshyDL6r*FHu1?U(Zt7&&|P9bwD*4{?TiyC#yNF zzVAars?nJpQ6m|_`H2~a=PL_ye~Na6wDmLwxD5GZOn#}e=W7T(d4?mZS(J)>NB>Vv zy7@jgmAzUwHE!6)7qAu+Y;ax@1!m4lJ9s}JUvk& zxmgsgYV={Vsm93Y_V9S)ih{^^#qiKQI^q`$>_-X&a^-dM6D5YUL!F*xh${@+=i8Lp zHtB{&=4uURr>2enQh0p$$Eltvy7AFt-@~`fetWl&X=U(zDh;|&Q!$0TDC=Gr2w&i3 zLtu7PhDWj1#qmEp_;0sSLr<7fwQ{zq$=Ube>Q2q@s6vB%>ft3$(9~g&LBN}P8x;nT zXh3i=!nvYB<#OE5M?TwUCaUi2{1kdbX|`*z?4a>R<7j=Q(j0k%+{DbX#+{8V!*&Xq zqtgQIZ7Dfd+aiW43chH#oHhu}kSL4%yk0GC@^F32Bi-t%whklF? zvuhq{m`xFme57jE?)D&W(sH<}89BFn` zYN;=?4G?b$5R831ROvLBr4~1%+q7UFI2_wn)s?Aipq|)a)W{ zq1o4=+FZBbl)N=DGf})+z=D(_VH#6AWiK6;Idfh%y(M2-$*oqsPj8fs^tsNn>}Op| zz=NrM4Z)(Hszj4;pP;(pc`Da`rAH*Af_(PYp9v=1xlX?sO5CS{rC+> z#F*QGWCzPj_!mI;!=aN-J?X%FWyhQXYR)*T#~j?Mn|BvsY_Zz`-4aj^$(OVzZZ4Gx zvZ~1%Jkx=0pp2xJO)y0?P`PzraPjtvkl+?=z6HNVaxrOAPJ}}s$>3k#K zmekcWo<6JE^3P?yaC{zv1ytyFF_izxY0OXfTs;89MwiFTkKESEj1e~8p33W!_H$K4 zLfTG;PyA5}x4ns1no^K_gJ;KTg;2oG+NdAm{}V;NXK(ww9evR4@Gd_Tid$QdyvgON zkZoNvbH9F;KwZt*Im>oMxhw4n{`=^}U5UJ1-(exY##_2vF~avdmAcgiw==myugC-R z%s62J2p7rc{*qr?z6H@2#4%jucb!^PBNMFoC>QmE^~xjs+@=YXizmTt)F_CbBm4vl zVhMBXx}RhEeXADXOOuH6);C3AO-;Z5R9tWo;&OGdt$k7zdC;&G@Mi|swL0LwOucsX zIzR)}cIMdv7D=<}i9DzBR_I{R)iTjRdxfAv_tqo7K`~Y{F=0a!lm+oE>m0q0wulAd z$ZUcT_t^`Fd@|NSz-Jn>TDTuo7QH}6EvL@~LW2^}@ZE%DChv-D6jx&{Vu1KNO&OyM zLNo~lU%*!IaoxZ5pwvSJI)*Y|0k7wbZnCz`BOqD2tIA-yn3c~(YiOT&2|IAG=)z}P z`}jIi9W>_<92u$Dkt1J-A#3zLM}GIbWf`xP{6a*6>sTPHpCLPSmt8+<4}U}wcYMZ3 z;H5{BDNz{7^7bc$tIma%qG~?^N{xXMQnE9XXJT} zAC&f!QKYem+sDe!FnJBdNg!I2P(}_mke0*S9w=lvoe?I(JjnjChY`8bVWg5%v$TZ1`kW*^vjP72o7l1tH_+&&de)jm zyBaq~9UQKW@tFfvHoNJ!+%lgmCXu!yg2NXB-rT}H>uSXJ-zy3U$(4q<=n3veE^?s# zx*d5HwXjj&n0a6~jO@SKnpNKCg)q&2|Nh;*q&&-llA$s`lM4HTb7vW@XJ~YCEPUnQ zlf9cA?C-2%wISVak0;&Dh15L#jiHuv$_c3!{4C;S;gyLcYIeC z9`3M!^2yp_1ddgd9C)=K_UMxK6x1EYEEgv&5pwd>2}^DXEr}ZfO9ON+4ve@;{oWVIhc1KKRR zI=k9M=+4A4kA4Q*bDd`~l1IbwvNv|r&~GJAdp8NiD7`?k%tFe!oZ9yg$r|yFKDdw_KH1$Y`yED;2z<<A<*)uiCwy!ur&d`8XUi#YiQl~q>XD)mb{ukN{u;5~ChmW8}S#C&jK#=6}t zFE^-KH16cmEH9wF(SMAC4r;WO?A8#FA@GX;D=Tumgh`frx7-_c?43Zq5dqWcS(pz4 zv9|~=+W-& ztA>5a--h8xc~N|JKPO|X0mklxWTBs$Vp5gqi7tZKN|-BJayBl^C_E@GgX+Y$^BnX2 zCrfmoi2Y6G$RD=1bYU=^CI-&?>4<3Q(&YyFDfS3Aun|y=E&Cyhus&PY#y|>4fV=@F zuZmE)9>sZR;;^pxcq%4T;Ylxgk~ryca%7WenVt|lbiW#*`ArwpxwbSU=(R+%4X*I? zcmj1RE5Gu^I$pWq{Ew0!Zp-uR2eFQ8pHFl5nAsyS=ENI4{MlL9NBSP?L|T+co;@(` zOg`b8&wU-HR;bYzbIXk1*BwECknuO}Rz(M~$~%(|CxiY>w2}*-_WLg#ykeXtBFWep z_-(0_H$S(RSg3HNQ*~q}Dm_y0+>@cRC)t_X0RqpRy6}x#b{j(T{>3R$wtgUyG(2g%o??D5;5j$o?^0roX# zq-0J8m>e5z?W-u$R+*FyL0MN%F5QVVDAXbjTdXX;T6R!a$1`Rl`b;2o*tLmg*#+w8 zwl$ybL=*<-XIC@-g3tI^iWv`47pH09VmA$}|G-$a?^~Q9NBP!uoDNlq&O=2ydv_?1 zV!uLU|Gt#m7kGw4TsXjI9q_s1c`HZ}@MM3Pn9=4_fD(+HiKeH#I1#GKs$$2oN!MY5 zgSegBNf#7`Bhehv9krE7p&T#9GkR-W(Vz%=j_bmP)M6=ptUq^%pvZ!bd1xzbsLB+o z+H2N>?zpHfAW$imvGnuXx%NY!AKe4r6bk|HhYg1(A53_AUd6 zi!=)zi?eR*Iu6X_vuLzwY=79K#c7Mi0*l6ApT`h$%=H*77zqs^kA>nMU0uxCm2)$4 z=vqNVu!qkcm?3vT7O1D|I4$ZqynUm1B?`%21Gcj8^@bJ%`XJn-hq)+X9~Kk=m_i>u zQx`?2?^H@rK3Y1fki?f?`j0>Fj^`%_WM0bwnb>s&fQJT*L%Qql`A5V+{Debd zp{Ofn)AZKsI3k6Y(ro8fcD8vdee<1@loYI~q#pErLKoU1cm!6I-Ocly5?@aj~XvF+T ziwI)m^kzLZ|5`R&?l#%A^2DG_Fk!UROmO&Y+@y(yX(WuBs2EJC5TZwv0Ez|lFh7&9 z)JNF9;Mh)QNDude4uo!=A7R(AySHC@N%CplUYvfsNDGA3Gn8K$-h;7y03z5&hscZH zF8t?Bz{qpceL+0llx8H}%F-?Y#R&{@s6XQhZpr7~!-7r1Ze(jan^oWXt3)bpMp`B%0N9_=^@9*7yqEln z%C3Y_NVv|IK48}4lLRpjG$7XDe!3It0G|8;3OBh-7g5g-0{4NFiVn*-p^c?A@(>cjS!=Qo>B=9%tim=3FTci9-j4Ir^VhAy`G6Va z)_jA~57yr$1o$OTAatEB;pk0ifuTsnZ`N{zc+yigqlXbf^h3>O1!);i(Z7QAi(;ZQ z9Gj09k@BU_$rVOTnnW%5{&1&ac+Wlwpm>>&p;8i*$mR#VfL@NME+9CwA0TnwvqjS7`z}m*tH*Q%P7bV& zuXKo7ql*d7B8g-1#K5ilP+YhfyD)CIo7%aQ>}bc> z>_YXfz%)HN_ax;HXl*nzEqvxCXWO7sFc! z_tTrAxPi}Co}4yV>={E-Pc$2l()|>mH~%uRW(7#(hZ`=G1H&CYJBRg}#b|p}ptI_H zZBSrg-ga(e${x`7=@Y@6!C!7%8;9b5N3cYjCU&d0o3fW+UVp{ZlBbFLZZXR9~$0XCb3UULb9cG#EAWVcOauvI!HaHa$CFtccQ|gkq?EI|wyAC<=!B zUpIrERcJlZ>7#@tE;JB9v$~?w&4(zMJ%73}lz8UWiPXunW9|pvM2!kkFQQ!)Q9lINbbgzT^*|Lj*FKXlnNSZ49yK4A(>-*T1{C9T4seA#Y30YR2D(Rpu-}B%H zIwyY}LVjwv-xjz9w30XjNKh9JU*3~p;r$?NA>^l(ZEX}_u>(HB#F$X`c%~&=rkp%y zM^b^4w0~#gl%g~9Ys)9p2r8y)b-6N#87UxA0uV|0P9zOi+do@g0dk54Fjc&!aLECS9!Q3uQw7I))1%fU}$bclf|wngNzSeqtXej@j>ex)GM#Z*Z_O%t5EcKrlR4+Acl4@VnMBT7xQv+;#KMg zdy`-QZqI}6U2=yozQ64&eBMp~bi9ynLjq5zgDjM+Vg4OruxxXr=}mc+@?B$|26MYL zH*HiYCxd#(Vao3ZuGvdaTa4OgBpAG%pjLQbSoM~gPbErlvV(L1yYQFCImd;V^T-9> z2&K5dHK@|UFRV-`o1~! z(^dkIKO7E??+Z5nY}7*LL~T7qXkI&=01QW}>rQ=$2_jFUB0FelO1MOsZWWj6J~S)2 zMZAZ4=c_uV-biDg?dIIB;fCa<;91UkR(tT|S9q&{GkbJcdK8IZqhe`9j}P#y0Rg4R zDRXK7bQ?!}-t>QZiKYHrm&uk)+1ug0ol>9e%><3e*RC{uR>qWhT^!TQK{5H9>%ZQP zdZ-rODu5<_kS6V+l?RNtmH?9IVglMJujFGkh=1XHwWe^y=RJjczic<;FM@b#J{E`x zZUecPC$WKkS1;(;-_SsU`P)!U^RHtai%CN3Zi2itQ}>KvCruX>U2GIEoYzdPi#Z;L zF5eRDS|z51S^Wc1AG_-;VS=3 z2MQ6AFRxMQNS1+`e5Jt6JmeE##B}sp-h5CVy?W&IrT;Ng<@lzW(KsH#PhYIjof_~4 zH5&dtEG(!LWPRKb+N8dJ`r_pqj<^ML-`qtp-Qm>GzxI8JVk4VB1Jbl}hEOoh-u=pz z=ZXB@q$(Wh=!~$%yLw+pz+<dul zIY1#p{9XI}^>^Xe#=%UW?&oKW_obss#Q*zyT}2Im_#aYvh(vhmsLto^O-Zi8K@jsX z^dd-{E%`$&O#%qB-GOSl!=Xy3r`M3ZRkJn}{dA=oPc~usI35UCJKuHB=*MXiCV4cR zMN>p!?$+^-Yyy3v-h_4WbRI8hz zOYwh1fI)TLto^ff4#u9uA$i+DPOUx%tV*{T3!JoeYGofAYwcdRP%k3Ag6zYK2q z)ETiN)}PTy^+MToZ#@(d6IJgZfTDJ)Y<%DUmlHd;cfa%Gcik%Fu1cxbXcz+JC3{Px z>noq7i(-anKL~-fZrbS^ya!w)@ecX$ zFAn%#-3SCa_-ieXZ+a%>a5aHvjbO!-^^S&s4bQe2Nh)Dj+7U1$NKd~hCYyYELH^ZY zKJOWZ1ihgbt>k?u3a8fXXzBJNcBne1sT#-~f@Z3&^%SEuCbZFSLg=Xo=o^$p1%$Xj z0$5~UiZkd`P!@qF9Q6PKV(aRnRsUKS%GCzR$H6r7Tu5p(G%eZ-C>YcL?9(SzAQ9N6HyHQDugZj=ODq(*_g|oi@dTZ z>$sc%^t6vgnYII;|DVlkB^e$;V<2;wj3@d(od;zUy$h)By|jD!y*~SVajS|e6A|zy?*(L-^U354|Q*K zcsT!in1=hmJeRLFDt!2D%T^r{hvt)ReSm;AgnTOvjmU!ozU>AC&`vlA4JOr#SOsDy zw26fRF_P}epm2s<4PwX#t^|3f(^3I8l4&!q1cZ`zy+M zLLCM*NL?!k2A^W_F&ugysR7j7qO2WZftC%BBiSXWH}ThlVrBxvk7CaqD+m?X5A|4G z5{z5!q5PPn4)NYC&&V|r>@f7nSi-j%E?p=tATF1#1^1a}-hXb-@_rKoaWk@Fs6z z0y2xuRvs2!Y5=SU#d;JZ{CUqTzp9)Nxro8{D|WEDzP2j#QA{sN$t{flbf_tnaj zUJWnszl!d#V>g7o{|Ly4hPddC%dcEZ&L&;pXZU}A1O3%CYDBKWxrt7~YKxNMFoF6i zNiXJ%Y^If1GFkfdFtXV=8HEmKi2vY#a$jx3Edy8MlIN+>A)us%4TR{kzZJreNV0eE zJzL~(z{p(P4#ft96x7X#E?_l^FLc_(^PmVp{`kvbD&*2%QRc51oVwbs)R1w{0=$W> zKYmcsH%Hvo|3UL_@Xd<-Cmx__Js{+kyF(yh&LZyaZ^JD|R3MRz7|H(%PHQv?&?M|T z`P#)Irz=Xyj%|nNYcApJu8X|8RxHq+O^9-nAOM?QUP`@v52ENCM5Ai-6lFj^`WpB~ zN}F#rE}!`zQ0gNDI0|BKg_yBdPLxtz4#xIcshZ zfTjISL}8xuPymK{q?VK;P8QglRM$7cZd-3$v@>mj<{fjsJ1Zh9A_p$I`tbb0N5{yf zOJJeR^2%H_znJo^ef!kq-XOD!)pll=>EDwlSYUn-+|{eFp)}aNg^==pey`H9@k6Or zhfw^mwddq(i`nflI%7ar>zy?1Bi9v|evD=d(uz#@SCYBs)OMD8;aqM2oB39?cwgzp zZZxxEskq;-Xb59C=ti$sJ6oSd;}Vt(oZ^&^Go6yIiMZFJ2K124(6|Xar>X~^QKOBE zmdR;XvTwM8w^+y6Z%(M|n5#>Fp6XZk-*WV!yE?2kv*SJ+nn8zF+vMaV|^ z`MWRMhN3A`GyXb3{lHyDO@TVSr@qeN96JJXUFs|;6&ZtVn15k;oNy#I_`cY~v z>CT~&*>lkx+oN2)TR)r_#A?t~HEV0Z}suFes10CXZ?$pe=3psdXVxTR)Goe?3+`+q0C6 zlk!&xyJ;P_Ds4JUp9k2+ANkB;;DI|Nafetvsu% z?Y8rr?)$F`&`=K{1sZy8xJYN9wvhSf#z=nGnL1A$Db~U^-xWp_g}J?x;7Zs|mrzNx zUOR@6iZ;KHa^%;vTEz--)5aa2UW6c|h*LVKY&0)#Fr$K%moS)??{VY;O;3~1(i0S! zPm!We>2*lepUht;D$mKlqB-j(OuF^$vfoJ=v}DR4mE@eM5s-Gz$SnQ-9K2M`X`43;g$bKs0O^TpcgpmV3rsUh(tmv+#qN z+r}l>mdTwf{2jPkAN+YI$Nn+(f`Cx3i#=CV#eVypnsvA}p8SgZZlF!K@qlsFN9KNv zA_!ghXOuQ9fd^Aj%Y$Zg#d!?m3hg7;zv`E}A$r$m%FZ(q4xZ$3rZ3beZ06Weww5=d zK-O`X_6qi}z}by1_|jgOR-osLjI?s|srgDJy&Xa7JAW;`@{&&?za4%En9~n+G`Am; zI10hxBV{|XoDn%d*e>WjqjzF>RARf{n!XjMW5rb(O9S1V5QgLNS0{VFC58rf3t;?w z%4u1n!C4<|0^L8V;QOg0IZoFEBmlVsixOvEK9(W7hjL%uY!?&*bJhgn#*cV_GNt}O z2oSATp<#EDjpWwoV>Q3qPkt+i$>;x8>s7FnA0IkUI51#>-Lw0OK`F<3f z9_EOcjv3Yvk02d$J-SqY5_r$tsO5U{=^}A+1L?#AHPI2QuzZ+O z7v79U$(KNbXFEcF#7=jWdLsGBo&JJ4{up==#>7v5SIJ;e$J9LfMG0yh+bC_rv(%89 z1@b?5(?u@ua4PSi#0;YM6j03Yj1n_!^&I@Kn4#w1)l++e@3kG%7}++pO6_JFnDvo8 zF}UTGBrq_+owQawhi|DIw$j$Tx1f?=w#u9V-Xqah&biE%?aJt+suQ;Fn7M`W5RaYx zN5=)Shp!-?!QjavD93_=2gj_L!PpXz?F(!b#xDFG=6h3qfTdg%$0h(Ky3G&SFze;m znj*4P3Fx9&&tlfZ3y6>*Uw;iW>EP1fRG9d6WczxoaKO_0Egb`H41f60UC{cN1I zSQ=n)>%+``Q;UhJ)Q4N5RnMK1Ug2n$uM^5``o11+Q{!-ZAtjxd-(t@M#Z6m9E}cq< zA;(fd!q=elduNN{!CjE9OMm#ttrW%vdc`5vkcJzAsKaQ;e*zUTPh7rdEWqto01^Y( zfY3TADyUM2HLP(Fcf+GO>5tZyTEn$l%=2JTbzBWYy_zHg zf?mhdlS#$shigiG{BAc`RWwUNLe|d0MF0M`|ExNIgyiOH)miF4Dk~ZdttwOfS7L>z zxS^kV74$Wz0tnz94R({-N~7^5}Cr9y6Tvk<_t^-8aP_URV*FDsQTJ{`!kB z(jChaF>D1**@0_-FX5t>g34*Rp_Nrp*1@D!1U^A2C+hQFayo+S!9VUYtZN+7U^Twfe8feVVU}Q3C)rIcv%nejDH6>wPbP?LDtE`30sxDy<49vK`KgL7W zROdiDe<<@JX6<2Wy{Gk^X&xZ2b{O=p<(%L{_Pcbrg!!vKgT-2wtr3J9sTN-DfZm zylH8j(VYFEGv#-Y6i-ybNivb{#~R&7dB$C&3>^aaf%AiP(RLNd@V|Esx^-;{f4!bX z6hS5z=chb?1LFZQn2Q_Gl>4@e!|+C8xbgP0BsTf8Kpt#-m)lY`sV=v-BM}S4eSEC`3(Yo16L|g>$YVl`^!U(} zYM*qgmeS3q()E(%UW>XgpPK*T_$BGQi}a%jw2C$7aq+IB{!U7t2Sx0@$m8wMZLdNJ zdn4}nV%^uJ8_#K1XX+VY@4ZVQ%>*YzzZ>yfUo4WcHjBRCTlzVG6XH<~s@E(Z{PJI+ z_wwEuVSdzD@m zx)j%dHlxuiaGp(I1nH0>jF%(KxhO$$Ofap931OnUHX3zNgk}=kyuv+FZJR_qBmC== z5r?xPJOcR7l48z*^Ng}Wv5glGrD)mZNj5Z+U|@pXA!Cxg(ooZaowf#tPX5lJO_{M5 zo9r#(a?|Q(%^t_LB`CH8lLos}Cz?{63`kBHvO=k(=6UTrr=~WiR?S>lPj%todC9Ap zb1939GriBk^yJg3q=F7z4=m@SSNwKR!DRy16UYB84gxC|nDJ#dYHgl}%2NK-7XTiR!st3kywlm`;cZw_o?v{Qc%9<7Pt0yUrwM_}+VNk9YS0p8w`vo226p z%r<-*^%Z|U8SSN88E3mChR0J9*POis{34&iJB;9o7%OX{jsjdrcAb?g)O(l_#&thT z*3suE{IDKPtom&B;Y9&+ugRu6w#Rd+K?gu&WCYMVfU##=;R zKn1gofQa&M^YX@piuGZu2vwALP*VOlZuQRl97qaVzaW zL+Al9t&oo3^aSZ|E9zzVQFNy{D5|XR#N?O}7FPKxq7wz|u7A!Gv3o@=2}Pt#r|fv- zq!}{;jeImmsk>Gku|k+Y4n)#~QPXR0e|XA0HPX5HRZKymO1}Qhm}nGV4AQki-18L; zX@S8b3T>kH@bJW1YCvm@ic*otq1mv2cTQsWOna4J%=cjdtXVVe!N4B0RB_wA?p3=| z11NJ-O;mT@|MP_}lnIwecP=_T7@;%+*f44DJ_^ z$&ib5{2AQA1}*=`$aeOd)xBQxtsjdbYtCRe*jAuDeTB2O5u}7IFE^kHIlhI?vHxg` zc<4Lzfo<;)->ioff#C@)*(Nj<3g;X~@L7^X`2_P4-e7R`%K{3kJ ziyfpj{}vesu0C%|nV{p2S1g*1V>_+0c0EgDLuJ(1?{g%nflv?GIUv=u@6WO@7WSgW zg$}$*VVU_Q*YrLijH6R8{^*aR$Y_!QOr{{g_AhgY_T4oH>hy&^pMaIK1C1d_0$`X& zmJBE>B|)p5W@_*D7KSQ)Ho`PjlH&mp@P(;b`9>gjXA8Oww)L|h&Sh+xI@~Vw@^XG! zQ-Ko@-AM(_q&oW^cl`y``OLkb5M-aJpDTQ|>^g+xpz$Tu!WvLN)MTZd7iIMQ%#PYu z{@QT?)Kp>Spg3|KI;`hGf)lmO5%iy<7>M4|oxcwLaV8%Kc)NrNT5t1v1VWU6On#@K z&J7C;h1T}b#L&F(I7|!$x?`^vddo&1|G}O?5XA#Z+Xf?m9g6IG3$<>UPHj1_10-m* zEFi(XAd_e>2ehN$cNBIK`NW+=as?=giWl(7TXC$H&o^g{Ep{MdA{bz7#y=~aAEQYm zTJh+%xx6m-V^$0GFto<3cii0}#i@lz`KM&hefGi1Z~ zJ?n*Hr;LU$-7}|i@8~X>nl+}Dm(JI#4%?Fo21#`r-=t_+`q!IwIhjd$PT2=;*NPL@ z$PWc+6&G!dsNqVdIHfZIl}+{;AG`7oY5HdrmT7PV#A{}z+TmO_yRPF!5u4$Wx~G>#P&7QaSEg~iM%jL08~K)!$=yCJ5WKsGxQ z147+=@O0n@wHpMr7Use_xi6vc#yPd%ZNboA;5Q{MMvIh=hLBl@+feBc!Zl-)*O&ql z#U~64KnNj~8J0rHY>sa_)pkHguF3bJA+<^eO&QD%`hBLs0bU|Z>po~UtqcqJO)d;v9P^O%&3s{|agG4P1oxf^ z66Hln0Mgs%vyfJgOUEVK#4}{XTTo@gQ$nrg#@b9FCoi&dtYp5{b~PchmDZLUiZUa% z-_hq0UeF>OB?z5h6<=4XgIj8Ft7%7s45Kc^*gTk-ttP7b9%ecxo$D@8&s~l zZEi#cFfRXV4)duEECDlb{>|i0Mm0Qz&DcaqAk_afy9$G96wz>KgSHGxh2J*JeY8_D zv9cZmvXl#V&gd_QYm{7|17gOr;TNbX$diMQ?Z}PTIoCKS!kk~}i!1=RO7oRdogE_S zNjZO90A%xlg>0j4J)kd9_<}v(ez;lpiAo2jOw9QuEr4x(oBud*#5+*!xw5Mu?vL+M zViKN*MMMqXw~v)|o(o|q>GBEfKh0VH+ysuWH2Y;)Fv}pJu{RrClPd65$*VYKzmydt z+~P#adrFCoCj(lCthp|}#WrF*pNrD5v4OBGwNj+GjZ=U&7e)t(_ z&ZNRV2R7u~fdxkj6tlD7u@|KL1HbO!eP3zO|O|P|iRYt?plu{>xpDLN{zXMG&32vM0mDWNGN9zD&uz|iN zwm%~t$_+`FWJ2{1$Qy<~MAcEgNxo^7_YvxD>D%$}snW;N16dTCQjcgQ`=MKs!@LcY zG!DYVK%_jbCh>@!{JVH#1VS)Q&xHQY*kV)e78C85AIe3}*8_zEwh6sI+-5n%bF}XT&MXCGL8paz*LQ9e)cylEdZTQk(Q3;Ez=#n=OER zBngCvWBZ9F{gZpJ!Z&%50kf)13-MKfAdrZLFd5y%|dUY|(eeGAn4ZGeuxhSJn87IQL`8^HDb+qf=iHUxVz2+rc zHb>1hnM0Qz#UYV_XRq+Nvm2g%eAl(|Ik#rH&+1ZH;%LZrr^-_ESSc`Jh(E`;)$TLF zSZi*D%hI^&+sa#M`6u@5+V5>>bx51)fi>Uf6^jfe9S#rW z9S#9bTbjm!DZt!Q`sF2S-GG~hs-z^GB&utOBOy+iT?*E1hd$Zv>RqRf*a_b-A zb7fi{bE&_)-;!=1CYR`Yh|ro!fZnof=4(-GSpeJFdgwk!4UfW49$NSvCn4`#5AUHJ zPWp^HR-7*PB2gOMiZfek2C?ThbjQt%ukKTy|wrmxF zj_zB6wsoU8b6n8w|EekiW0OFj_N>^zGnn<3h0L8+xEo(BoG4#}n23%u!?1#|UN_<8)ssFkk*7SJ;Uv0+uX=BelSaD@Ey`a` zX<|+24#YFlSj*ZT>bH@QC7vynJ{<_&uSS}nE9*Oyn3H+@PpGyVF8fN@f<>D@#jgy| z_LoJylpxtFyLElVr)Kz#6wdyyga0;-nA!=z)u9fiMogLOWmkthCX zr=~v|%RFU)K~&!lQ@AZfWAu*t2bQ|R``K{AGv>0*2iS&VS?agEm)^lBkl-}@`Yo*T zRxv{BMw5f#Z0Y&f7=Rjqni1DyKULaSJ~0rC6O791cgj%;qH3y~Qz13iHN;x1^Hloa z9l~}z4)D0XylL=7e-wTsh|6I^OSMQ7%Ze5G{WCLy$l$Yslh-hjatGF?=Igd>jNF?c zx0L*&z1AS;CS`$?f4UIQ9k3`DMo=E2`iv$GrbHmXunP=UGCz$5!_`7^+315t7DoZ# zDVa-;Qq$gl0~c1Z-XJ(;6MBe;UhY;0Ue-34o!hYbO;^k(ML9q@5RTCKj?W2dMz%ht zV)$H%=`Ii*aM{Mx*#*xXxV#Une0(Qv@7&&jwuYrd`iwd>A*0Jl#?r&J9DS}=xuy;u zWOaNVZj>U39W07VdkDWKUa8me@ULZBK3lJI@TNCQ)!9{k{c!~oXK?V{!VUHAMM<=A zX`kf=fBbH=e>=o=PlRj ztT>Z~GhhmlmONycVYv2M^D9LBEVU|%U9@yEvh~q9Rh;h5ZMEt4zq5Dc{c4DZ6U5S( zL}j)OqejY%5qDV5 zy^bhyn{sdqKm%Vy+g$=sa~8r6eKYN;E#cGup1W|L>l|gc9h}EKorgY-VccA}O#0V- zOCTLPvMA#;dvklhF?>>%b=oa#d`HnYYHL~IF0IyY>jfeHBJk0F8`+hX+o9a!#7BmD zkvHxoFIdAig>~smfwt{FZz(tH>Z}8~e1d+?J42j7XYy~CfLTHbL*~u@^a?P%q;Ul+K`U zUQ@!wsnvQdJ*pW#$WRSdVn)-=Rg`bdAUZ5(S+0HL=xNY&_-)=LT%An=l%IDmGFjJO zR#DrY?fkAe>hN%Fybs)Yf~QyZE^CAdt?8yC+cOM$k|{oW#i2*1ZT(TAD710UUT^tc z=)PloULy1O?~kLFWCcfF;iCQGCz~L8qz~)fTJ^u=m^Z1ALwb!fQEoF)$rJb2;Pv5+ z2ap!gmmeh7+0jC`X256;TFz72pm)y{**x2IMY*0_Rd!>lDQww5yZ!_xtANnd`t$oE zQq|F?LQX%TT}iC)qi5;6K1I|iokaJ9ETL8Uw#cOB{FY>{70-6}G^a!5fioo4r4}l_ zkh)c3B*4}!=eVBN^SaOk2)$=Y zO8c?>Tq@R@TbDhY-mK#`bI$T9ZDFe8DypP<;Y(CbLV>Ck`T`b4xQen#No}aBb3>29 zd716o`K#m?8*`pgzacE~XxP>!o})a6%S@i0TSH1Y=7P%@cKUs~*ccN2(DRS+u<6YU zr6hZdG+|fc`_5TC^iSm>{d)iB`FL6tKO_I!A3FNk`}ZGzm$uKSJKkmGGrcAk+4m^n z4P8HUnXvnMDPGYH(pkK~OMvi`5b(2DWU?s;mL86vQ594k!i@JYuUQvB^AS`^K5GvU zWwUxIEe_IIdOu@F8#7Pr0gXyoi>;6@dxgU#OG>;TM@ccpRx>3lS+51`hhK5iRu5sX zk^&z_+PHaaFMg~K&%T?Fp+}GO+z#QSmoHuVH@BKUR$&t2O9LZQS~=txP1ef9F8lGwN8)|D=lTN5sOqT};`xI-4z}<@%3wpY2#O zIps>;n&WoTlIm#6?K(RC3I&WAeV)EwMa86Ei^H-3mTAr8UnmjdvMV>%B6P1Db<%hS zYkBe|+po!Zg;HF?mZjoZ1}U>1Wch99FyFnzqiqT9kUDqaZ_~78JUxWUnJOWOp1Vf9 zkKB2({}V}{=^2&1*QNPG|E)1RQH{}YTyARwDbCm&;&QTWeY891LaS_f(aac=ebe0_ zyNTPho#gdIA85tz?+Gd!CI9n&CT!g4yLz>c3r2(dw&vvu zAK>zAa=(HQbI-syfWPo6vNDuEhqStqz%MkFTf$`^sc*+y{g-&|2pvwZ5iWM~dhP83 zL&X~BJhrPXJA5lq;XXo{KY8W-;!NVl4GUdK96A(9D&AMq{=SU9LKYj}x7x#@dU591 ziwbK5^2}1;J!nj)a;OE9KyLJB#tbvyaN&Pk`i0j+f&_BFf35gHxotna2k($&AFg74 zoGWx4It~2X&2Ra9KmTO-z@2xnBtNp`+mEF5^LxSv@h2&=D*XoTKN_R9$D8-;UO8mN z*|EgU6T$hP&pIBu{=5SUua6KKF-=sGpg&SzH4I}gWe{NK&}-@8&M%#@2Mf&?NJ*SO zgIHtqT?PyK`oHcAWQD^&vWRchEOeari>%u+pP|zMy^PVhQ;DP=TIe*iH^c^_*x*~= zR5ZkwRp1c4RYkl<*Rx0C7gAq!kai^7?Ot(7`j6iHNg<|m{={-nilScnJ~$i>O+oUS zW4JKE zZdCeCYL;%FHd5@-WVpkxUZbUcixli;Hz^l}N4w~$iBowO54|>c)a!Bp9>sk<>FHmm ziTvgMCziGyV!8TKY?ps}!DEGje7v-0w|Dxpb}}RrD3^Fa>5&S)k0E)Tu$h|3MS``G z@__7mMI4sV^jhlVS!OC4K!xjR1?)2xW>yS%uP4E-Mg9wUl;PkZ+`GcDTz1RVBIP*g zgd4k3b}x1f8_XO~o^JaKvq}l2j8PO1DUc}e4Z1DAk&XBfI8fOo)cD)PkGBs0j#;F# z?>G(Z*hGiMe$wAqWd_|?L)(X6H-l|B%){p5(~JCD;tK!YPXhS6r~%ciH%^F_D`>U1 zwm4{1(4#T_>(uNkMJr#}bRHdj+J_JUOL&l?Y>J{t*9-2tGatkfxwC|ShbUp^O;|)Z zEd_}^nYJ5!uQAGhac%o4r1K7*S2)+Bm`3`(7#f99Y#e}j<@9ffp=yM~f6mBp+(xey zRuT_44cL2ykM)@jJSN@#KKj|fc#jBsa@-CArrWQ8X-{G5c`xGB7|)A>3qCEfuiMrj zdHB`r*JjJukB;I0^#q{*f-VWw-fSv2g+9(s>*Gb<7Z7LL^n=L0Dm5KLkUxkQl-DTm zey0faC*^Oj>KpNAAJ}<}gMy9awK$&Z3F`s~PkKl7JiylpR))JScSUVEc+hBQz!6AJ z(A=sYID{Ti&>PHz{PAwbsVoWV2Loe@v`ihh??l1Ls|uyrx29h`Px!s-9}UFbP-l3% zcqx`nfv(kp?C;p8u@xW>oBeLRWiEH{s}4r0UszL{d8A+SL(8p*^^JLWYjS#qRAdL* z7p~L#kEY{4cY#vvq~c4lAYo4m>fr-FT1L`y!(C^d9d>(-50&!<2;65F9sskL1}-BZTINqAbP%eFBAB=J__QmQk5IEn0>%mrQ4 zm@;)N`bzh^`whZEvydMNPbY zcH~wY_MznzBiTJjVO}Y@J(ighl3q=<+^*MGdz3ytaAWc|E zKf+iC)!if)k?U!(?to%*;y^uI!un-3H9xmF5FYhfN@9>-hfp81XZ&5qyjMQ|IuRCo zTz^x~T2k9GaBqI-yHQTh-Ei=01%}XtLQP5K@8?N#8l1r1k+pRFxb_;wcmC*Y$U#n0 zx>6sI=}LAP4qnAu9&S>cW+DAsJSzp>yNs2ay+TdghqXfFeH#zJ63e|}McG?$-&Ry6 zyWQIniu5m4seAXiTPXq@ad`HeCp#R5-`wxBOPZ1qVlnYifF3xhs~ZBQa^emM+ZHxf zfap^T(#wcg(Ek(K4I8|(Iig`TWFm?d^6&d~5-eyHmdl=Z7ie$gT9u zWban};2r)mRA)1`4#FX*J`Ey@i!Z6?I}<(>+)I9F$yg8lqlD9x0l9MRs|=kcA4ykiywL`alz?* zD_zXrKi)L`-jNRl$Mx$el1Lh3@?G{#L3&J&$d3c`qs3bMs{fbWRWI}i#CGMaw-oLg zxJpPaEo66n#X}w>hG|B!O}@MKiy7ad;}GITbIup0tIX(R_u_j$F_a96Hf?rO%gxStC>)g)6HIzE4K?r@G6w)&0{wBs^nOg z1M7w|S1qUb?sRGzYuj%It zehny{;d=?@UtJCPy+D8E#vcf@^y&T{XNZ?xKM`=XTlKcAzD7YVyH zib(ZVY=hS$y{BwGW<~)DM7M@7m5W)n1uquGKexyWDk6d0hFi#R_s96f7jusC;{7z) z3%px%g137{YIWY&uPsMMoTVsdMxl~waNO&f)z-Oj6bSX`kD>MLb_>@@uYp`dFu20kkc$x&2kEw0FZFtBF!*|V35boN|ENeNCx`%ZGfgbWg0doP@yJ$hcV@em3e&O;z|44{H zER=Hed^RjXZO?T%Tv{bW-=@0p&-}P-=m!aj?d%Y~`>M#4B9Y@IC|4%aywQsO016~G z)CT%DJA8=RC7=s~Ep!?A=StzvLh+qo==!6}tMXZhUk5+0$`zW1Imbq><_pN!w%{hj zgC8J6Jtc|^Y6*}bwjmT2EUs54^?6pNKUoa`y$&fu+)sAX+?FH!`WX7BlwQ16od3-; z5(nQBgC7ekN%%&PkEaai-x|~vYfZD}1d{(*KMq6c1JVe?s&^|Qin^xu8RuDakXOzJ zS(xAvyl#0kAq^K23Cqb>bE@=!*TKg}{Y`(NTEW!8)}yDV1%y`z9tmtmL!KfG;e6oj zJEJydlD6K76XXczY@eK*VVJH%&Fr=FJhN}g4}4w&hL#W#P^qB#Q439SFvd3!)>KsxChLRWVZS2z|g^c0FrG^U-DAB7nf406KPcus760_ksk zEf~r+Jc4yv=`q+(cFupE1v93t3lYV3U1wm_reuuz@P13;_BI0PUO)|49Gqqd-nY1u zd-(F+a`M+m00RQslKd>RbgccFAu`4;0h0U$-A|{teqjt16gB4=Gw*GU&2Z0|n{OZR zqR%j{p|m%N{vN7U!>Vcrzm1R|1-`-p5+)bV^LOy2EQ+|^Cp(wfWF3rDEPq7-P3E@- z4bVfU8!C_fD4iD6s#etnof;my5Zvw%@OEx;nSYQyt-ult!M)9?F?EJJaZw`OlGvssXG7E1KVR zpGV@x&f;I>8f5r zV0`;qNia0eX1sr9D_iPbC3VUBvM_M_pVw%Sv!qInhn7an_2yfao!;u9yqKFqmSf5a ztDOnZHCBf;YnA>U3Z>$DtfOcl_Yc)aQf70!#Nl#u7+b)W_wDBkC;K2?j$%GM>7`9` zL=tz2c5v_Db4UmTYgHw(2YK*GEQZjX-xql!xrp16o5ZF$ z`J>n1$oI0O!0mtNkVi>6zEC`5=R5-`rOmy@^5_>5QrWqDkoukNFxhXn0IuB1Avn|R zR~#6KDYdiU+9h<8@m#I>TUHIHUw1#y7ef%QEtsG=TXvFEsE}O}^c|Z?36lDzXhC&z zMLjB;FZJ}E{MEc0^HAD%2;-$?FRAK=!wKS`(AKw;@vl6sgxoO2!7r>q=d9^=n=8&R zdnEZ1PXH;7;STK`At*+?eByuE_$H-&6Sb$(mE=`T!7H~n1kEl184?GgMcMFl(OEa=Ix0k_#C!mw?{TkbTZHKYg z-Ib&KwuiIj(#d=0OWaT%I2}Esp_sXSLrE{>=Z$dW5DNWx6wj7VP4CoND@q(&U1t%E!PIj!WcP0F=XgS2mn zi-m}vp`psLY~|Lx_?D=1&)Dv+4I^5J!faCZUiunWz)zOW0I}&U7wx!MelBur9``i@ zlg&P()&Ffg*jHpC*hJS}xHgTC|M`)he-&&;orIn*j%~Bs+&hBo$^UAufe=7_h)=-f zZlS;HyNl3@C41O}eq6ynAqSCg8+%47z7DY#`fL|FCNaGa{HVuj#YSuY9BmKZx(?JNRqJF$T854{pV2wHXUHL1TfaEb zELytv*WF@~gK3!p;n{7TQ#sqk%MP5tp8N|w?_w;S%pd0+_VpE3+Jz~)_Uq|WCUe8% z$9ii0kJc7r47#TDd>@Pxe(y?TP5;NT)%k8ctJeG@^259f<^6q`LLy|7rX9FzdtHA! zb4@7V$G!PFaH{#LzgQRrzA4t&?o!vMlh7aIvY}xO$+j_$ZuG|u-T2shz#{PR-@52M z2>nG-`{(}aiRoKi3_2J%I>5^t_I>N`p$X04Bpt%9X};cNDP`7Y#`+^}rQRBe-NQC~ z_P=-To>G-lWAnMRy<|t?$N7W-NH5D5Lrt3sL(_|0o-jbIk9hx0os^CGqT{fHb}|sn z7qbjGHo1bK)$2C&+d^JD>ypRWwuz^K{t)YKYfNOvk`58Xd7x1&?@0gT|4tnGJYl72 z$&}X`GtwR0wNax}yPH`(A}@?N@y*g6A+WG+op|h|LwTu+^$LkGB)S z=kC_bj5ew`LT0#Ld_j}Bi=Ju4 z>KA!7+cG;WbownY4~UG=z4i30!kJy((iN!vxfPn&Y>l5IRjn*tvoAY2I#i^)vQeB3}#jt?(W%}sZEoM zKGj3+{Jk;XnL%f50rYqUK}pJe9GY;Fw^CN1^Wv-aVO%h4c%gi5VoJ@RT> ze~<-KO6pUPbPkV{7gbwyif{i%d?^JK9t0a{8zRHOo6qCA3x9!2z8FzT`{8l>O1+*S z>-ztQP5z8$ri?Hb7Q6fKT}gmKxjsIM0BD5zfZsW?^Tg5YvD4@zp*)u#67$iW%N-@d zJX>>VAuEaxboa7kwsvsuX>OGec&xrhScZhV?lXP8vD!Zu^Y*=dwtPsQ@1Ng50JYnQ z@?|47aE$foDFXQUzv=vF{wNnEhMu#e9=gW$f9c zO(Y5*yHU5f!mf@L4c2t&bJ8vWBM%E7P$Dv_TfK})Log~+s<74?bVMBsNF9E7kzYp= zpuX_+>s8;vJ@e%pL9#G~E99bmW{aKYDr_L@(bAlc5UXbfTR7u2@QrzfHqaTWbxca8 z@)}y|q&DWReYrU|PV?rr(3(G}O1khxt?WYR;Px738+f92KJ))rh!kf8Oy#{q>G)ZxhV9sM7bcYlYU9?8d)Ld` zdS}E&V~>Koav>R4V+Ra-@jT6O+kp>4U3s#Myq16RBbsBB8_ zd2>5wWwk-#5{t%adSTxRUHZ9p9j>ELX^syC2xb#!{!r2X_@--o#MRI-W zF%#U5bWJ0-`aP-%l>{J`xFA9_qA* zoIqdylcW*dgOlH4zCKw5Rg4>aD*6l@e(mR|#h%$e&lD5Fp#sfH?`1L5Bi!-JDn&G3 z+r_3q-gg`Xdk@ooYZuFD?XWx24SJ5xzI6gD)B^UJZRSi7lYW?d={YghxQ0syB+goc z++%C^pQ394iycOlX_aDAFJFsK2nI`StVC?wh;eFvs^yj0s|P)2`C>RZSBFUVwr_yX zaAqOpj~{$<1uc$_5M_}A4a-^>w#D|M0sNSE-L;p+-bH@o__@$wT(6UY&AzGsbI|%T z(54?p6%qAKZEMk|ST~2e_w$LL__E0EbJZX$g6#XyA3=6I;VlX-C=aM?uZpl!tWA0I z^iTtxg(2?1O0?34oC?R{qoA}j9;U8z4Y@z39GS9)^_6jCZ{xp18?Y0736IVD8phB6 zW=f}$)&t(pZo}6oVj|DRE_=R$Pip4ySzQt zYng>Yd~#-DAE(&}?9xb$n$&}|MdXl4j?n8$+Qw$xBhY?fqt}_|IFJ8vpWTarep=oJw=XXh1$grFAMV4wy#S$ zlbOp#*oBS>C*6^O3poAIzvpWAE@b~6S)P zkU|z1*gxI?2SY9c@Ix?%y;{QPm*b5dU;-`&qG7Ji_|7`u4$SAny}UK19L6%~vR-@| z{vipx9xohqXcRVwxr;^ACVX$ z^P>DQCM1T3NbjB3Q{NvRG9mVkoQY8%SHx0&(KAm9@4i(5QrpQ8Arhy*KfJ~FvWjAu zdPj^IvG;rJ#tl$lj@Iy@+bOHqM#rP)qj~f^_pdSm^Z(ywcpQ&jFHf;(lQSnf|17r< zFw|Qz@vA!|E5%bN=ABB6b0Qn|_YxLGMhBqaCpFgn5r6)e@oZI#`p`~I$P34;>pt26 zwYiwcVpI1PNf*zx|`Qwaq?#PtvoWEmGgvx7<64+ICpBXn*ŸYmXAD=Plk=|6o3r{ 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%0D4`Zsm4 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

>5p4oO6sDO7L*S|c;`)Ha({KLuq`2km> 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 diff --git a/helix-db/src/helix_engine/traversal_core/README.md b/helix-db/src/helix_engine/traversal_core/README.md deleted file mode 100644 index 70b7bb31..00000000 --- a/helix-db/src/helix_engine/traversal_core/README.md +++ /dev/null @@ -1,3 +0,0 @@ -## Graph Core - -This will be the core graph traversals. Actual storage of data will be done through the storage layer. The code in Graph Core will be responsible for using the storage layer to perform graph traversals. \ No newline at end of file diff --git a/helix-db/src/helix_gateway/README.md b/helix-db/src/helix_gateway/README.md deleted file mode 100644 index 7c494c5d..00000000 --- a/helix-db/src/helix_gateway/README.md +++ /dev/null @@ -1,14 +0,0 @@ -## Plan - -- Have thread pool with N number of threads that will be instanciated with arc mutex instances of the graph storage -- These instances will be pavssed to router which will lock the mutex and pass the graph reference to the handler to perform the operation, dropping the lock after. - -- The API Router is a general purpose bit of code that parses the incoming request, and then calls the appropriate handler function. The handler function is responsible for performing the actual work of the API call. -- The connection will just be a tcp stream that will run in the fetched thread from the thread pool. - -#### Process -1. DB connection is tcp stream -2. When connection is made, get thread from pool and move tcp stream into thread. Stream will receive request on thread and read into router passing thread's storage instance. -3. Router uses thread's storage instance to process job - -![Plan](./gateway.png) \ No newline at end of file diff --git a/helix-db/src/helix_gateway/gateway.png b/helix-db/src/helix_gateway/gateway.png deleted file mode 100644 index ee73361b317d12f3cdb46d8ab337a6cb06693d18..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 90530 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�dnnf2leEC&O7^_{G{JwiPs4Mb)$g7=X#Cl1u^n_ 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 Date: Fri, 5 Sep 2025 12:24:57 +0100 Subject: [PATCH 03/18] changing folder name to assets instead of docs --- README.md | 2 +- {docs => assets}/full_logo.png | Bin {docs => assets}/icon-1.png | Bin 3 files changed, 1 insertion(+), 1 deletion(-) rename {docs => assets}/full_logo.png (100%) rename {docs => assets}/icon-1.png (100%) diff --git a/README.md b/README.md index 7bbab6b7..b4e210a0 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@

- HelixDB Logo + HelixDB Logo HelixDB: a database built from scratch to be the storage backend for any AI application. diff --git a/docs/full_logo.png b/assets/full_logo.png similarity index 100% rename from docs/full_logo.png rename to assets/full_logo.png diff --git a/docs/icon-1.png b/assets/icon-1.png similarity index 100% rename from docs/icon-1.png rename to assets/icon-1.png From 594942ae866b02012b6930a8d8db69c236cabc3c Mon Sep 17 00:00:00 2001 From: xav-db Date: Fri, 5 Sep 2025 12:26:08 +0100 Subject: [PATCH 04/18] removing misplaced test file --- test_simple.hx | 1 - 1 file changed, 1 deletion(-) delete mode 100644 test_simple.hx diff --git a/test_simple.hx b/test_simple.hx deleted file mode 100644 index 0519ecba..00000000 --- a/test_simple.hx +++ /dev/null @@ -1 +0,0 @@ - \ No newline at end of file From b2a749d184288f48fe2e5d894694a4b84c641389 Mon Sep 17 00:00:00 2001 From: xav-db Date: Fri, 5 Sep 2025 12:27:45 +0100 Subject: [PATCH 05/18] removing random mod.rs file --- helix-db/mod.rs | 2 -- 1 file changed, 2 deletions(-) delete mode 100644 helix-db/mod.rs diff --git a/helix-db/mod.rs b/helix-db/mod.rs deleted file mode 100644 index 3f359453..00000000 --- a/helix-db/mod.rs +++ /dev/null @@ -1,2 +0,0 @@ -pub mod bm25_benches; - From fc62790ceed0b5dc0418e2627fff3d3de449d587 Mon Sep 17 00:00:00 2001 From: xav-db Date: Fri, 5 Sep 2025 12:30:20 +0100 Subject: [PATCH 06/18] replacing collect to val with collect to obj --- .../tests/traversal_tests/drop_tests.rs | 48 +++++++-------- .../traversal_tests/edge_traversal_tests.rs | 20 +++--- .../tests/traversal_tests/filter_tests.rs | 6 +- .../traversal_tests/node_traversal_tests.rs | 8 +-- .../tests/traversal_tests/remapping_tests.rs | 50 +++++++-------- .../traversal_tests/secondary_index_tests.rs | 8 +-- .../traversal_tests/shortest_path_tests.rs | 14 ++--- .../tests/traversal_tests/update_tests.rs | 4 +- .../tests/traversal_tests/util_tests.rs | 54 ++++++++-------- .../traversal_tests/vector_traversal_tests.rs | 44 ++++++------- .../traversal_core/traversal_iter.rs | 61 +++++++++++-------- helix-db/src/helix_gateway/mcp/tools_tests.rs | 6 +- 12 files changed, 167 insertions(+), 156 deletions(-) diff --git a/helix-db/src/helix_engine/tests/traversal_tests/drop_tests.rs b/helix-db/src/helix_engine/tests/traversal_tests/drop_tests.rs index b83b5457..2ccde09f 100644 --- a/helix-db/src/helix_engine/tests/traversal_tests/drop_tests.rs +++ b/helix-db/src/helix_engine/tests/traversal_tests/drop_tests.rs @@ -49,10 +49,10 @@ fn test_drop_edge() { let node1 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props!()), None) - .collect_to_val(); + .collect_to_obj(); let node2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props!()), None) - .collect_to_val(); + .collect_to_obj(); let edge = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( "knows", @@ -62,7 +62,7 @@ fn test_drop_edge() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); let mut txn = storage.graph_env.write_txn().unwrap(); @@ -99,10 +99,10 @@ fn test_drop_node() { let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props!("name" => "test")), None) - .collect_to_val(); + .collect_to_obj(); let node2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props!("name" => "test2")), None) - .collect_to_val(); + .collect_to_obj(); let _ = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( "knows", @@ -112,7 +112,7 @@ fn test_drop_node() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); let mut txn = storage.graph_env.write_txn().unwrap(); let traversal = G::new(Arc::clone(&storage), &txn) @@ -142,12 +142,12 @@ fn test_drop_traversal() { let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", None, None) - .collect_to_val(); + .collect_to_obj(); for _ in 0..10 { let new_node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", None, None) - .collect_to_val(); + .collect_to_obj(); let _ = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( "knows", @@ -157,7 +157,7 @@ fn test_drop_traversal() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); } txn.commit().unwrap(); @@ -211,14 +211,14 @@ fn test_node_deletion_in_existing_graph() { let source_node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", None, None) - .collect_to_val(); + .collect_to_obj(); let mut other_nodes = Vec::new(); for _ in 0..10 { let other_node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", None, None) - .collect_to_val(); + .collect_to_obj(); other_nodes.push(other_node); } @@ -233,7 +233,7 @@ fn test_node_deletion_in_existing_graph() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); // 20 edges from source to other nodes let _ = G::new_mut(Arc::clone(&storage), &mut txn) @@ -245,7 +245,7 @@ fn test_node_deletion_in_existing_graph() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); let _ = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( "knows", @@ -255,7 +255,7 @@ fn test_node_deletion_in_existing_graph() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); } let edges = G::new(Arc::clone(&storage), &txn) @@ -307,19 +307,19 @@ fn test_edge_deletion_in_existing_graph() { let node1 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", None, None) - .collect_to_val(); + .collect_to_obj(); let node2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", None, None) - .collect_to_val(); + .collect_to_obj(); let edge = G::new_mut(Arc::clone(&storage), &mut txn) .add_e("knows", None, node1.id(), node2.id(), false, EdgeType::Node) - .collect_to_val(); + .collect_to_obj(); let edge2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_e("knows", None, node2.id(), node1.id(), false, EdgeType::Node) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); @@ -352,7 +352,7 @@ fn test_vector_deletion_in_existing_graph() { let node: TraversalValue = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", None, None) - .collect_to_val(); + .collect_to_obj(); let mut other_vectors = Vec::new(); @@ -363,13 +363,13 @@ fn test_vector_deletion_in_existing_graph() { "vector", None, ) - .collect_to_val(); + .collect_to_obj(); other_vectors.push(other_vector); } let vector = G::new_mut(Arc::clone(&storage), &mut txn) .insert_v:: bool>(&[1.0, 1.0, 1.0, 1.0, 1.0, 1.0], "vector", None) - .collect_to_val(); + .collect_to_obj(); for other_vector in &other_vectors { let random_vector = other_vectors[rand::rng().random_range(0..other_vectors.len())].id(); @@ -382,13 +382,13 @@ fn test_vector_deletion_in_existing_graph() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); let _ = G::new_mut(Arc::clone(&storage), &mut txn) .add_e("knows", None, node.id(), vector.id(), false, EdgeType::Vec) - .collect_to_val(); + .collect_to_obj(); let _ = G::new_mut(Arc::clone(&storage), &mut txn) .add_e("knows", None, vector.id(), node.id(), false, EdgeType::Node) - .collect_to_val(); + .collect_to_obj(); } let edges = G::new(Arc::clone(&storage), &txn) diff --git a/helix-db/src/helix_engine/tests/traversal_tests/edge_traversal_tests.rs b/helix-db/src/helix_engine/tests/traversal_tests/edge_traversal_tests.rs index 953f86ed..80ca286e 100644 --- a/helix-db/src/helix_engine/tests/traversal_tests/edge_traversal_tests.rs +++ b/helix-db/src/helix_engine/tests/traversal_tests/edge_traversal_tests.rs @@ -185,10 +185,10 @@ fn test_in_n() { let person1 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("per son", Some(props!()), None) - .collect_to_val(); + .collect_to_obj(); let person2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props!()), None) - .collect_to_val(); + .collect_to_obj(); let edge = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( @@ -199,7 +199,7 @@ fn test_in_n() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); let txn = storage.graph_env.read_txn().unwrap(); let traversal = G::new(Arc::clone(&storage), &txn) @@ -218,10 +218,10 @@ fn test_out_n() { let person1 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props!()), None) - .collect_to_val(); + .collect_to_obj(); let person2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props!()), None) - .collect_to_val(); + .collect_to_obj(); let edge = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( @@ -232,7 +232,7 @@ fn test_out_n() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); let txn = storage.graph_env.read_txn().unwrap(); let traversal = G::new(Arc::clone(&storage), &txn) @@ -254,7 +254,7 @@ fn test_edge_properties() { let node1 = node1.first().unwrap().clone(); let node2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props!()), None) - .collect_to_val(); + .collect_to_obj(); let props = props! { "since" => 2020, "date" => 1744965900, "name" => "hello"}; let _ = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( @@ -405,15 +405,15 @@ fn test_add_e_between_node_and_vector() { let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", None, None) - .collect_to_val(); + .collect_to_obj(); let vector = G::new_mut(Arc::clone(&storage), &mut txn) .insert_v:: bool>(&[1.0, 2.0, 3.0], "vector", None) - .collect_to_val(); + .collect_to_obj(); let _ = G::new_mut(Arc::clone(&storage), &mut txn) .add_e("knows", None, node.id(), vector.id(), false, EdgeType::Vec) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); diff --git a/helix-db/src/helix_engine/tests/traversal_tests/filter_tests.rs b/helix-db/src/helix_engine/tests/traversal_tests/filter_tests.rs index a71e870a..cec83c06 100644 --- a/helix-db/src/helix_engine/tests/traversal_tests/filter_tests.rs +++ b/helix-db/src/helix_engine/tests/traversal_tests/filter_tests.rs @@ -259,17 +259,17 @@ fn test_filter_chain() { Some(props! { "age" => 25, "name" => "Alice" }), None, ) - .collect_to_val(); + .collect_to_obj(); let person2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n( "person", Some(props! { "age" => 30, "name" => "Bob" }), None, ) - .collect_to_val(); + .collect_to_obj(); let _ = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 35 }), None) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); let txn = storage.graph_env.read_txn().unwrap(); diff --git a/helix-db/src/helix_engine/tests/traversal_tests/node_traversal_tests.rs b/helix-db/src/helix_engine/tests/traversal_tests/node_traversal_tests.rs index 76ecad8b..1a265c57 100644 --- a/helix-db/src/helix_engine/tests/traversal_tests/node_traversal_tests.rs +++ b/helix-db/src/helix_engine/tests/traversal_tests/node_traversal_tests.rs @@ -375,7 +375,7 @@ fn test_with_id_type() { let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "name" => "test" }), None) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); #[derive(Serialize, Deserialize, Debug)] struct Input { @@ -407,11 +407,11 @@ fn test_double_add_and_double_fetch() { let original_node1 = G::new_mut(Arc::clone(&db), &mut txn) .add_n("person", Some(props! { "entity_name" => "person1" }), None) - .collect_to_val(); + .collect_to_obj(); let original_node2 = G::new_mut(Arc::clone(&db), &mut txn) .add_n("person", Some(props! { "entity_name" => "person2" }), None) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); @@ -449,7 +449,7 @@ fn test_double_add_and_double_fetch() { let _e = G::new_mut(Arc::clone(&db), &mut txn) .add_e("knows", None, node1.id(), node2.id(), false, EdgeType::Node) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); diff --git a/helix-db/src/helix_engine/tests/traversal_tests/remapping_tests.rs b/helix-db/src/helix_engine/tests/traversal_tests/remapping_tests.rs index 0b190912..e63d2b6d 100644 --- a/helix-db/src/helix_engine/tests/traversal_tests/remapping_tests.rs +++ b/helix-db/src/helix_engine/tests/traversal_tests/remapping_tests.rs @@ -61,7 +61,7 @@ fn test_exclude_field_remapping() { Some(props! { "text" => "test", "other" => "other" }), None, ) - .collect_to_val(); + .collect_to_obj(); let traversal = G::new(Arc::clone(&storage), &txn) .n_from_type("person") @@ -127,7 +127,7 @@ fn test_field_remapping() { Some(props! { "text" => original.new_name.clone(), "other" => "other" }), None, ) - .collect_to_val(); + .collect_to_obj(); let traversal = G::new(Arc::clone(&storage), &txn) .n_from_type("person") @@ -180,7 +180,7 @@ fn test_identifier_remapping() { Some(props! { "field" => original.new_value.clone(), "other" => "other" }), None, ) - .collect_to_val(); + .collect_to_obj(); let traversal = G::new(Arc::clone(&storage), &txn) .n_from_type("person") @@ -231,14 +231,14 @@ fn test_traversal_remapping() { Some(props! { "text" => "test", "other" => "other" }), None, ) - .collect_to_val(); + .collect_to_obj(); let _other_node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n( "friemd", Some(props! { "text" => "test", "other" => "other" }), None, ) - .collect_to_val(); + .collect_to_obj(); let _edge = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( "knows", @@ -248,7 +248,7 @@ fn test_traversal_remapping() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); let txn = storage.graph_env.read_txn().unwrap(); @@ -316,7 +316,7 @@ fn test_value_remapping() { Some(props! { "text" => "test", "other" => "other" }), None, ) - .collect_to_val(); + .collect_to_obj(); let traversal = G::new(Arc::clone(&storage), &txn) .n_from_type("person") @@ -366,14 +366,14 @@ fn test_exists_remapping() { Some(props! { "text" => "test", "other" => "other" }), None, ) - .collect_to_val(); + .collect_to_obj(); let _other_node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n( "person", Some(props! { "text" => "test", "other" => "other" }), None, ) - .collect_to_val(); + .collect_to_obj(); let _edge = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( "knows", @@ -383,7 +383,7 @@ fn test_exists_remapping() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); let traversal = G::new(Arc::clone(&storage), &txn) .n_from_type("person") @@ -426,10 +426,10 @@ fn test_one_of_each_remapping() { let _node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "old_name" => "test" }), None) - .collect_to_val(); + .collect_to_obj(); let _other_node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! {}), None) - .collect_to_val(); + .collect_to_obj(); let _edge = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( "knows", @@ -439,7 +439,7 @@ fn test_one_of_each_remapping() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); let traversal = G::new(Arc::clone(&storage), &txn) .n_from_type("person") @@ -508,10 +508,10 @@ fn test_nested_remapping() { let _node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "old_name" => "test" }), None) - .collect_to_val(); + .collect_to_obj(); let _other_node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("thing", Some(props! {}), None) - .collect_to_val(); + .collect_to_obj(); let _edge = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( "knows", @@ -521,7 +521,7 @@ fn test_nested_remapping() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); let user = G::new(Arc::clone(&storage), &txn) .n_from_id(&_node.id()) @@ -577,10 +577,10 @@ fn test_double_nested_remapping() { let _node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! {}), None) - .collect_to_val(); + .collect_to_obj(); let _other_node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("thing", Some(props! {}), None) - .collect_to_val(); + .collect_to_obj(); let _edge = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( "knows", @@ -590,7 +590,7 @@ fn test_double_nested_remapping() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); let user = G::new(Arc::clone(&storage), &txn) .n_from_id(&_node.id()) @@ -655,10 +655,10 @@ fn test_nested_with_other_remapping() { let _node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "old_name" => "test" }), None) - .collect_to_val(); + .collect_to_obj(); let _other_node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! {}), None) - .collect_to_val(); + .collect_to_obj(); let _edge = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( "knows", @@ -668,7 +668,7 @@ fn test_nested_with_other_remapping() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); let traversal = G::new(Arc::clone(&storage), &txn) .n_from_type("person") @@ -756,10 +756,10 @@ fn test_remapping_with_traversal_from_source() { let _node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "old_name" => "test" }), None) - .collect_to_val(); + .collect_to_obj(); let _other_node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "other_name" => "other" }), None) - .collect_to_val(); + .collect_to_obj(); let _edge = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( "knows", @@ -769,7 +769,7 @@ fn test_remapping_with_traversal_from_source() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); let remapping_vals = RemappingMap::new(); diff --git a/helix-db/src/helix_engine/tests/traversal_tests/secondary_index_tests.rs b/helix-db/src/helix_engine/tests/traversal_tests/secondary_index_tests.rs index 2b361b6e..15d61461 100644 --- a/helix-db/src/helix_engine/tests/traversal_tests/secondary_index_tests.rs +++ b/helix-db/src/helix_engine/tests/traversal_tests/secondary_index_tests.rs @@ -47,12 +47,12 @@ fn test_delete_node_with_secondary_index() { let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "name" => "John" }), Some(&["name"])) - .collect_to_val(); + .collect_to_obj(); let node_id = node.id(); // Save the ID before moving let _ = G::new_mut_from(Arc::clone(&storage), &mut txn, node) .update(Some(props! { "name" => "Jane" })) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); @@ -105,11 +105,11 @@ fn test_update_of_secondary_indices() { let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "name" => "John" }), Some(&["name"])) - .collect_to_val(); + .collect_to_obj(); let _ = G::new_mut_from(Arc::clone(&storage), &mut txn, node) .update(Some(props! { "name" => "Jane" })) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); diff --git a/helix-db/src/helix_engine/tests/traversal_tests/shortest_path_tests.rs b/helix-db/src/helix_engine/tests/traversal_tests/shortest_path_tests.rs index fc1c8a0e..70cc82e5 100644 --- a/helix-db/src/helix_engine/tests/traversal_tests/shortest_path_tests.rs +++ b/helix-db/src/helix_engine/tests/traversal_tests/shortest_path_tests.rs @@ -29,16 +29,16 @@ fn test_shortest_path() { let node1 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props!("name" => "node1")), None) - .collect_to_val(); + .collect_to_obj(); let node2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props!("name" => "node2")), None) - .collect_to_val(); + .collect_to_obj(); let node3 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props!("name" => "node3")), None) - .collect_to_val(); + .collect_to_obj(); let node4 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props!("name" => "node4")), None) - .collect_to_val(); + .collect_to_obj(); let edge1 = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( @@ -49,7 +49,7 @@ fn test_shortest_path() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); let edge2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( "knows", @@ -59,7 +59,7 @@ fn test_shortest_path() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); let edge3 = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( "knows", @@ -69,7 +69,7 @@ fn test_shortest_path() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); let txn = storage.graph_env.read_txn().unwrap(); diff --git a/helix-db/src/helix_engine/tests/traversal_tests/update_tests.rs b/helix-db/src/helix_engine/tests/traversal_tests/update_tests.rs index 2bbcac4a..19d524b7 100644 --- a/helix-db/src/helix_engine/tests/traversal_tests/update_tests.rs +++ b/helix-db/src/helix_engine/tests/traversal_tests/update_tests.rs @@ -36,10 +36,10 @@ fn test_update_node() { let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props!("name" => "test")), None) - .collect_to_val(); + .collect_to_obj(); let _ = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props!("name" => "test2")), None) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); let mut txn = storage.graph_env.write_txn().unwrap(); diff --git a/helix-db/src/helix_engine/tests/traversal_tests/util_tests.rs b/helix-db/src/helix_engine/tests/traversal_tests/util_tests.rs index be48f359..9598fc61 100644 --- a/helix-db/src/helix_engine/tests/traversal_tests/util_tests.rs +++ b/helix-db/src/helix_engine/tests/traversal_tests/util_tests.rs @@ -44,15 +44,15 @@ fn test_order_node_by_asc() { let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 30 }), None) - .collect_to_val(); + .collect_to_obj(); let node2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 20 }), None) - .collect_to_val(); + .collect_to_obj(); let node3 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 10 }), None) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); @@ -75,15 +75,15 @@ fn test_order_node_by_desc() { let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 30 }), None) - .collect_to_val(); + .collect_to_obj(); let node2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 20 }), None) - .collect_to_val(); + .collect_to_obj(); let node3 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 10 }), None) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); @@ -106,15 +106,15 @@ fn test_order_edge_by_asc() { let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 30 }), None) - .collect_to_val(); + .collect_to_obj(); let node2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 20 }), None) - .collect_to_val(); + .collect_to_obj(); let node3 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 10 }), None) - .collect_to_val(); + .collect_to_obj(); let edge = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( @@ -125,7 +125,7 @@ fn test_order_edge_by_asc() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); let edge2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( @@ -136,7 +136,7 @@ fn test_order_edge_by_asc() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); @@ -159,15 +159,15 @@ fn test_order_edge_by_desc() { let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 30 }), None) - .collect_to_val(); + .collect_to_obj(); let node2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 20 }), None) - .collect_to_val(); + .collect_to_obj(); let node3 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 10 }), None) - .collect_to_val(); + .collect_to_obj(); let edge = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( @@ -178,7 +178,7 @@ fn test_order_edge_by_desc() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); let edge2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( @@ -189,7 +189,7 @@ fn test_order_edge_by_desc() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); @@ -213,15 +213,15 @@ fn test_order_vector_by_asc() { let vector = G::new_mut(Arc::clone(&storage), &mut txn) .insert_v::(&[1.0, 2.0, 3.0], "vector", Some(props! { "age" => 30 })) - .collect_to_val(); + .collect_to_obj(); let vector2 = G::new_mut(Arc::clone(&storage), &mut txn) .insert_v::(&[1.0, 2.0, 3.0], "vector", Some(props! { "age" => 20 })) - .collect_to_val(); + .collect_to_obj(); let vector3 = G::new_mut(Arc::clone(&storage), &mut txn) .insert_v::(&[1.0, 2.0, 3.0], "vector", Some(props! { "age" => 10 })) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); @@ -245,15 +245,15 @@ fn test_order_vector_by_desc() { let vector = G::new_mut(Arc::clone(&storage), &mut txn) .insert_v::(&[1.0, 2.0, 3.0], "vector", Some(props! { "age" => 30 })) - .collect_to_val(); + .collect_to_obj(); let vector2 = G::new_mut(Arc::clone(&storage), &mut txn) .insert_v::(&[1.0, 2.0, 3.0], "vector", Some(props! { "age" => 20 })) - .collect_to_val(); + .collect_to_obj(); let vector3 = G::new_mut(Arc::clone(&storage), &mut txn) .insert_v::(&[1.0, 2.0, 3.0], "vector", Some(props! { "age" => 10 })) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); @@ -276,15 +276,15 @@ fn test_dedup() { let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 30 }), None) - .collect_to_val(); + .collect_to_obj(); let node2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 20 }), None) - .collect_to_val(); + .collect_to_obj(); let node3 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 10 }), None) - .collect_to_val(); + .collect_to_obj(); let _edge = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( @@ -295,7 +295,7 @@ fn test_dedup() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); let _edge2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( @@ -306,7 +306,7 @@ fn test_dedup() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); diff --git a/helix-db/src/helix_engine/tests/traversal_tests/vector_traversal_tests.rs b/helix-db/src/helix_engine/tests/traversal_tests/vector_traversal_tests.rs index 1461b760..cd8751b3 100644 --- a/helix-db/src/helix_engine/tests/traversal_tests/vector_traversal_tests.rs +++ b/helix-db/src/helix_engine/tests/traversal_tests/vector_traversal_tests.rs @@ -52,15 +52,15 @@ fn test_from_v() { let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", None, None) - .collect_to_val(); + .collect_to_obj(); let vector = G::new_mut(Arc::clone(&storage), &mut txn) .insert_v:: bool>(&[1.0, 2.0, 3.0], "vector", None) - .collect_to_val(); + .collect_to_obj(); let _ = G::new_mut(Arc::clone(&storage), &mut txn) .add_e("knows", None, vector.id(), node.id(), false, EdgeType::Vec) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); @@ -83,15 +83,15 @@ fn test_to_v() { let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", None, None) - .collect_to_val(); + .collect_to_obj(); let vector = G::new_mut(Arc::clone(&storage), &mut txn) .insert_v:: bool>(&[1.0, 2.0, 3.0], "vector", None) - .collect_to_val(); + .collect_to_obj(); let _ = G::new_mut(Arc::clone(&storage), &mut txn) .add_e("knows", None, node.id(), vector.id(), false, EdgeType::Vec) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); println!("node: {node:?}"); @@ -116,7 +116,7 @@ fn test_brute_force_vector_search() { let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", None, None) - .collect_to_val(); + .collect_to_obj(); let vectors = vec![ vec![1.0, 2.0, 3.0], @@ -128,7 +128,7 @@ fn test_brute_force_vector_search() { for vector in vectors { let vector_id = G::new_mut(Arc::clone(&storage), &mut txn) .insert_v:: bool>(&vector, "vector", None) - .collect_to_val() + .collect_to_obj() .id(); let _ = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( @@ -139,7 +139,7 @@ fn test_brute_force_vector_search() { false, EdgeType::Vec, ) - .collect_to_val() + .collect_to_obj() .id(); vector_ids.push(vector_id); } @@ -169,15 +169,15 @@ fn test_order_by_desc() { let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 10 }), None) - .collect_to_val(); + .collect_to_obj(); let node2 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 20 }), None) - .collect_to_val(); + .collect_to_obj(); let node3 = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", Some(props! { "age" => 30 }), None) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); @@ -214,7 +214,7 @@ fn test_vector_search() { ]; let _ = G::new_mut(Arc::clone(&storage), &mut txn) .insert_v:: bool>(&random_vector, "vector", None) - .collect_to_val(); + .collect_to_obj(); println!("inserted vector: {i:?}"); i += 1; } @@ -235,7 +235,7 @@ fn test_vector_search() { for vector in vectors { let node = G::new_mut(Arc::clone(&storage), &mut txn) .insert_v:: bool>(&vector, "vector", None) - .collect_to_val(); + .collect_to_obj(); inserted_vectors.push(node.id()); println!("inserted vector: {i:?}"); i += 1; @@ -269,13 +269,13 @@ fn test_delete_vector() { let vector = G::new_mut(Arc::clone(&storage), &mut txn) .insert_v:: bool>(&[1.0, 1.0, 1.0, 1.0, 1.0, 1.0], "vector", None) - .collect_to_val(); + .collect_to_obj(); let node = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("person", None, None) - .collect_to_val(); + .collect_to_obj(); let _ = G::new_mut(Arc::clone(&storage), &mut txn) .add_e("knows", None, node.id(), vector.id(), false, EdgeType::Vec) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); @@ -349,11 +349,11 @@ fn test_drop_vectors_then_add_them_back() { let entity = G::new_mut(Arc::clone(&storage), &mut txn) .add_n("Entity", Some(props! { "name" => "entity1" }), None) - .collect_to_val(); + .collect_to_obj(); let embedding = G::new_mut(Arc::clone(&storage), &mut txn) .insert_v:: bool>(&[1.0, 1.0, 1.0, 1.0, 1.0, 1.0], "vector", None) - .collect_to_val(); + .collect_to_obj(); let _ = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( @@ -364,7 +364,7 @@ fn test_drop_vectors_then_add_them_back() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); @@ -451,7 +451,7 @@ fn test_drop_vectors_then_add_them_back() { let embedding = G::new_mut(Arc::clone(&storage), &mut txn) .insert_v:: bool>(&[1.0, 1.0, 1.0, 1.0, 1.0, 1.0], "vector", None) - .collect_to_val(); + .collect_to_obj(); let _ = G::new_mut(Arc::clone(&storage), &mut txn) .add_e( @@ -462,7 +462,7 @@ fn test_drop_vectors_then_add_them_back() { false, EdgeType::Node, ) - .collect_to_val(); + .collect_to_obj(); txn.commit().unwrap(); diff --git a/helix-db/src/helix_engine/traversal_core/traversal_iter.rs b/helix-db/src/helix_engine/traversal_core/traversal_iter.rs index 7afb54a1..06818313 100644 --- a/helix-db/src/helix_engine/traversal_core/traversal_iter.rs +++ b/helix-db/src/helix_engine/traversal_core/traversal_iter.rs @@ -108,41 +108,52 @@ impl<'scope, 'env, I: Iterator>> } } - pub fn collect_to>(self) -> B - where - I: Iterator>, - { + pub fn take_and_collect_to>(self, n: usize) -> B { + self.inner + .filter_map(|item| item.ok()) + .take(n) + .collect::() + } + + pub fn collect_to>(self) -> B { self.inner.filter_map(|item| item.ok()).collect::() } - pub fn collect_to_val(self) -> TraversalValue - where - I: Iterator>, - { - match self - .inner + pub fn collect_dedup>(self) -> B { + self.inner .filter_map(|item| item.ok()) - .collect::>() - .first() - { - Some(val) => val.clone(), // TODO: Remove clone - None => TraversalValue::Empty, - } + .unique() + .collect::() } + pub fn collect_to_obj(self) -> TraversalValue { match self.inner.filter_map(|item| item.ok()).next() { Some(val) => val, None => TraversalValue::Empty, } } -} -// pub trait TraversalIteratorMut<'a> { -// type Inner: Iterator>; -// fn next<'b>( -// &mut self, -// storage: Arc, -// txn: &'b mut RwTxn<'a>, -// ) -> Option>; + pub fn count_to_val(self) -> Value { + Value::from(self.inner.count()) + } -// } + pub fn map_value_or( + mut self, + default: bool, + f: impl Fn(&Value) -> bool, + ) -> Result { + let val = match &self.inner.next() { + Some(Ok(TraversalValue::Value(val))) => { + println!("value : {val:?}"); + Ok(f(val)) + } + Some(Ok(_)) => Err(GraphError::ConversionError( + "Expected value, got something else".to_string(), + )), + Some(Err(err)) => Err(GraphError::from(err.to_string())), + None => Ok(default), + }; + println!("result: {val:?}"); + val + } +} diff --git a/helix-db/src/helix_gateway/mcp/tools_tests.rs b/helix-db/src/helix_gateway/mcp/tools_tests.rs index f02a73f0..2c17b2f6 100644 --- a/helix-db/src/helix_gateway/mcp/tools_tests.rs +++ b/helix-db/src/helix_gateway/mcp/tools_tests.rs @@ -75,7 +75,7 @@ fn test_mcp_tool_search_vector() { // creates nodes and vectors let node = G::new_mut(Arc::clone(&engine.storage), &mut txn) .add_n("person", None, None) - .collect_to_val(); + .collect_to_obj(); let mut vectors = vec![ vec![1.0, 1.0, 1.0], vec![0.0, 0.0, 0.0], @@ -95,11 +95,11 @@ fn test_mcp_tool_search_vector() { for vector in vectors { let vector = G::new_mut(Arc::clone(&engine.storage), &mut txn) .insert_v:: bool>(&vector, "vector", None) - .collect_to_val(); + .collect_to_obj(); let _ = G::new_mut(Arc::clone(&engine.storage), &mut txn) .add_e("knows", None, node.id(), vector.id(), false, EdgeType::Vec) - .collect_to_val(); + .collect_to_obj(); } txn.commit().unwrap(); let txn = engine.storage.graph_env.read_txn().unwrap(); From 05a29caab8730b28f083d0fd6c28d54ca2732bdf Mon Sep 17 00:00:00 2001 From: xav-db Date: Fri, 5 Sep 2025 12:42:21 +0100 Subject: [PATCH 07/18] refactoring analyzer and adding file headers --- helix-cli/src/utils.rs | 2 +- .../src/helix_engine/traversal_core/config.rs | 2 +- helix-db/src/helixc/analyzer/analyzer.rs | 271 ----------------- helix-db/src/helixc/analyzer/errors.rs | 2 +- .../analyzer/methods/exclude_validation.rs | 2 +- .../analyzer/methods/graph_step_validation.rs | 2 +- .../analyzer/methods/infer_expr_type.rs | 2 +- .../analyzer/methods/migration_validation.rs | 2 +- .../analyzer/methods/object_validation.rs | 2 +- .../analyzer/methods/query_validation.rs | 2 +- .../helixc/analyzer/methods/schema_methods.rs | 2 +- .../analyzer/methods/statement_validation.rs | 2 +- .../analyzer/methods/traversal_validation.rs | 2 +- helix-db/src/helixc/analyzer/mod.rs | 281 +++++++++++++++++- helix-db/src/helixc/analyzer/utils.rs | 2 +- helix-db/src/helixc/generator/mod.rs | 10 +- helix-db/src/helixc/mod.rs | 5 + .../helixc/parser/graph_step_parse_methods.rs | 43 ++- helix-db/src/helixc/parser/mod.rs | 29 +- 19 files changed, 366 insertions(+), 299 deletions(-) delete mode 100644 helix-db/src/helixc/analyzer/analyzer.rs diff --git a/helix-cli/src/utils.rs b/helix-cli/src/utils.rs index abec548f..3b8bee92 100644 --- a/helix-cli/src/utils.rs +++ b/helix-cli/src/utils.rs @@ -7,7 +7,7 @@ use futures_util::StreamExt; use helix_db::{ helix_engine::traversal_core::config::Config, helixc::{ - analyzer::analyzer::analyze, + analyzer::analyze, generator::{Source as GeneratedSource, tsdisplay::ToTypeScript}, parser::{ HelixParser, diff --git a/helix-db/src/helix_engine/traversal_core/config.rs b/helix-db/src/helix_engine/traversal_core/config.rs index 84080761..390b3eed 100644 --- a/helix-db/src/helix_engine/traversal_core/config.rs +++ b/helix-db/src/helix_engine/traversal_core/config.rs @@ -1,6 +1,6 @@ use crate::{ helix_engine::types::GraphError, - helixc::analyzer::analyzer::{INTROSPECTION_DATA, SECONDARY_INDICES}, + helixc::analyzer::{INTROSPECTION_DATA, SECONDARY_INDICES}, }; use serde::{Deserialize, Serialize}; use std::{fmt, path::PathBuf}; diff --git a/helix-db/src/helixc/analyzer/analyzer.rs b/helix-db/src/helixc/analyzer/analyzer.rs deleted file mode 100644 index f8c7dc8d..00000000 --- a/helix-db/src/helixc/analyzer/analyzer.rs +++ /dev/null @@ -1,271 +0,0 @@ -//! Semantic analyzer for Helix‑QL. -use crate::helixc::{ - analyzer::{ - diagnostic::Diagnostic, - methods::{ - migration_validation::validate_migration, - query_validation::validate_query, - schema_methods::{build_field_lookups, check_schema, SchemaVersionMap}, - }, - types::Type, - }, - generator::Source as GeneratedSource, - parser::types::{EdgeSchema, ExpressionType, Field, Query, ReturnType, Source}, -}; -use itertools::Itertools; -use serde::Serialize; -use std::{ - borrow::Cow, - collections::{HashMap, HashSet}, - sync::OnceLock, -}; - -pub fn analyze(src: &Source) -> (Vec, GeneratedSource) { - let mut ctx = Ctx::new(src); - ctx.check_schema(); - ctx.check_schema_migrations(); - ctx.check_queries(); - (ctx.diagnostics, ctx.output) -} - -/// Internal working context shared by all passes. -pub(crate) struct Ctx<'a> { - pub(super) src: &'a Source, - /// Quick look‑ups - pub(super) node_set: HashSet<&'a str>, - pub(super) vector_set: HashSet<&'a str>, - pub(super) edge_map: HashMap<&'a str, &'a EdgeSchema>, - pub(super) node_fields: HashMap<&'a str, HashMap<&'a str, Cow<'a, Field>>>, - pub(super) edge_fields: HashMap<&'a str, HashMap<&'a str, Cow<'a, Field>>>, - pub(super) vector_fields: HashMap<&'a str, HashMap<&'a str, Cow<'a, Field>>>, - pub(super) all_schemas: SchemaVersionMap<'a>, - pub(super) diagnostics: Vec, - pub(super) output: GeneratedSource, -} - -pub static INTROSPECTION_DATA: OnceLock = OnceLock::new(); -pub static SECONDARY_INDICES: OnceLock> = OnceLock::new(); - -impl<'a> Ctx<'a> { - pub(super) fn new(src: &'a Source) -> Self { - // Build field look‑ups once - let all_schemas = build_field_lookups(src); - let (node_fields, edge_fields, vector_fields) = all_schemas.get_latest(); - - let output = GeneratedSource { - src: src.source.clone(), - ..Default::default() - }; - - let ctx = Self { - node_set: src - .get_latest_schema() - .node_schemas - .iter() - .map(|n| n.name.1.as_str()) - .collect(), - vector_set: src - .get_latest_schema() - .vector_schemas - .iter() - .map(|v| v.name.as_str()) - .collect(), - edge_map: src - .get_latest_schema() - .edge_schemas - .iter() - .map(|e| (e.name.1.as_str(), e)) - .collect(), - node_fields, - edge_fields, - vector_fields, - all_schemas, - src, - diagnostics: Vec::new(), - output, - }; - - INTROSPECTION_DATA - .set(IntrospectionData::from_schema(&ctx)) - .ok(); - - SECONDARY_INDICES - .set( - src.get_latest_schema() - .node_schemas - .iter() - .flat_map(|schema| { - schema - .fields - .iter() - .filter(|f| f.is_indexed()) - .map(|f| f.name.clone()) - }) - .dedup() - .collect(), - ) - .ok(); - ctx - } - - #[allow(unused)] - pub(super) fn get_item_fields( - &self, - item_type: &Type, - ) -> Option<&HashMap<&str, Cow<'_, Field>>> { - match item_type { - Type::Node(Some(node_type)) | Type::Nodes(Some(node_type)) => { - self.node_fields.get(node_type.as_str()) - } - Type::Edge(Some(edge_type)) | Type::Edges(Some(edge_type)) => { - self.edge_fields.get(edge_type.as_str()) - } - Type::Vector(Some(vector_type)) | Type::Vectors(Some(vector_type)) => { - self.vector_fields.get(vector_type.as_str()) - } - _ => None, - } - } - - // ---------- Pass #1: schema -------------------------- - /// Validate that every edge references declared node types. - pub(super) fn check_schema(&mut self) { - check_schema(self); - } - - // ---------- Pass #1.5: schema migrations -------------------------- - pub(super) fn check_schema_migrations(&mut self) { - for m in &self.src.migrations { - validate_migration(self, m); - } - } - - // ---------- Pass #2: queries ------------------------- - pub(super) fn check_queries(&mut self) { - for q in &self.src.queries { - validate_query(self, q); - } - } -} - -#[derive(Serialize)] -pub struct IntrospectionData { - schema: SchemaData, - queries: Vec, -} - -impl IntrospectionData { - fn from_schema(ctx: &Ctx) -> Self { - let queries = ctx.src.queries.iter().map(QueryData::from_query).collect(); - Self { - schema: SchemaData::from_ctx(ctx), - queries, - } - } -} - -#[derive(Serialize)] -pub struct SchemaData { - nodes: Vec, - vectors: Vec, - edges: Vec, -} - -impl SchemaData { - fn from_ctx(ctx: &Ctx) -> Self { - let nodes = ctx.node_fields.iter().map(NodeData::from_entry).collect(); - let vectors = ctx.vector_fields.iter().map(NodeData::from_entry).collect(); - let edges = ctx.edge_map.iter().map(EdgeData::from_entry).collect(); - - SchemaData { - nodes, - vectors, - edges, - } - } -} - -#[derive(Serialize)] -pub struct NodeData { - name: String, - properties: HashMap, -} - -impl NodeData { - fn from_entry(val: (&&str, &HashMap<&str, Cow>)) -> Self { - let properties = val - .1 - .iter() - .map(|(n, f)| (n.to_string(), f.field_type.to_string())) - .collect(); - NodeData { - name: val.0.to_string(), - properties, - } - } -} - -#[derive(Serialize)] -pub struct EdgeData { - name: String, - from: String, - to: String, - properties: HashMap, -} - -impl EdgeData { - fn from_entry((name, es): (&&str, &&EdgeSchema)) -> Self { - let properties = es - .properties - .iter() - .flatten() - .map(|f| (f.name.to_string(), f.field_type.to_string())) - .collect(); - - EdgeData { - name: name.to_string(), - from: es.from.1.clone(), - to: es.to.1.clone(), - properties, - } - } -} - -#[derive(Serialize)] -pub struct QueryData { - name: String, - parameters: HashMap, - returns: Vec, -} - -impl QueryData { - fn from_query(query: &Query) -> Self { - let parameters = query - .parameters - .iter() - .map(|p| (p.name.1.clone(), p.param_type.1.to_string())) - .collect(); - - let returns = query - .return_values - .iter() - .flat_map(|e| { - if let ReturnType::Expression(expr) = e { - if let ExpressionType::Identifier(ident) = &expr.expr { - Some(ident.clone()) - } else { - None - } - } else { - None - } - }) - .collect(); - - QueryData { - name: query.name.to_string(), - parameters, - returns, - } - } -} diff --git a/helix-db/src/helixc/analyzer/errors.rs b/helix-db/src/helixc/analyzer/errors.rs index 096645ff..7dcee21e 100644 --- a/helix-db/src/helixc/analyzer/errors.rs +++ b/helix-db/src/helixc/analyzer/errors.rs @@ -1,6 +1,6 @@ use crate::helixc::{ analyzer::{ - analyzer::Ctx, + Ctx, diagnostic::{Diagnostic, DiagnosticSeverity}, error_codes::ErrorCode, fix::Fix, diff --git a/helix-db/src/helixc/analyzer/methods/exclude_validation.rs b/helix-db/src/helixc/analyzer/methods/exclude_validation.rs index 2c61713c..9a84cd46 100644 --- a/helix-db/src/helixc/analyzer/methods/exclude_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/exclude_validation.rs @@ -3,7 +3,7 @@ use crate::{ generate_error, helixc::{ analyzer::{ - analyzer::Ctx, + Ctx, errors::{push_query_err, push_query_err_with_fix}, fix::Fix, types::Type, diff --git a/helix-db/src/helixc/analyzer/methods/graph_step_validation.rs b/helix-db/src/helixc/analyzer/methods/graph_step_validation.rs index d6e7f0bf..c3f55c13 100644 --- a/helix-db/src/helixc/analyzer/methods/graph_step_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/graph_step_validation.rs @@ -7,7 +7,7 @@ use crate::{ helix_engine::traversal_core::ops::source::add_e::EdgeType, helixc::{ analyzer::{ - analyzer::Ctx, + Ctx, errors::push_query_err, types::Type, utils::{gen_identifier_or_param, is_valid_identifier}, diff --git a/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs b/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs index 74233179..3cf913e5 100644 --- a/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs +++ b/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs @@ -6,7 +6,7 @@ use crate::{ generate_error, helixc::{ analyzer::{ - analyzer::Ctx, + Ctx, errors::push_query_err, methods::traversal_validation::validate_traversal, types::Type, diff --git a/helix-db/src/helixc/analyzer/methods/migration_validation.rs b/helix-db/src/helixc/analyzer/methods/migration_validation.rs index 39ed16f9..97d663cd 100644 --- a/helix-db/src/helixc/analyzer/methods/migration_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/migration_validation.rs @@ -1,6 +1,6 @@ use crate::{ helixc::{ - analyzer::analyzer::Ctx, + analyzer::Ctx, generator::{ migrations::{ GeneratedMigration, GeneratedMigrationItemMapping, diff --git a/helix-db/src/helixc/analyzer/methods/object_validation.rs b/helix-db/src/helixc/analyzer/methods/object_validation.rs index 0f105d08..831bc0d6 100644 --- a/helix-db/src/helixc/analyzer/methods/object_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/object_validation.rs @@ -6,7 +6,7 @@ use crate::{ generate_error, helixc::{ analyzer::{ - analyzer::Ctx, + Ctx, errors::push_query_err, methods::{infer_expr_type::infer_expr_type, traversal_validation::validate_traversal}, types::Type, diff --git a/helix-db/src/helixc/analyzer/methods/query_validation.rs b/helix-db/src/helixc/analyzer/methods/query_validation.rs index eb70837e..7ee22d9c 100644 --- a/helix-db/src/helixc/analyzer/methods/query_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/query_validation.rs @@ -4,7 +4,7 @@ use crate::generate_error; use crate::helixc::analyzer::error_codes::ErrorCode; use crate::helixc::{ analyzer::{ - analyzer::Ctx, + Ctx, errors::{push_query_err, push_query_warn}, methods::{infer_expr_type::infer_expr_type, statement_validation::validate_statements}, types::Type, diff --git a/helix-db/src/helixc/analyzer/methods/schema_methods.rs b/helix-db/src/helixc/analyzer/methods/schema_methods.rs index c9c4b688..7e80398d 100644 --- a/helix-db/src/helixc/analyzer/methods/schema_methods.rs +++ b/helix-db/src/helixc/analyzer/methods/schema_methods.rs @@ -1,7 +1,7 @@ use std::{borrow::Cow, collections::HashMap}; use crate::helixc::{ - analyzer::{analyzer::Ctx, error_codes::ErrorCode, errors::push_schema_err}, + analyzer::{Ctx, error_codes::ErrorCode, errors::push_schema_err}, parser::{ types::{Field, FieldPrefix, FieldType, Source}, location::Loc, diff --git a/helix-db/src/helixc/analyzer/methods/statement_validation.rs b/helix-db/src/helixc/analyzer/methods/statement_validation.rs index 14d1d0fc..a3c46b69 100644 --- a/helix-db/src/helixc/analyzer/methods/statement_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/statement_validation.rs @@ -5,7 +5,7 @@ use crate::{ generate_error, helixc::{ analyzer::{ - analyzer::Ctx, errors::push_query_err, methods::infer_expr_type::infer_expr_type, + Ctx, errors::push_query_err, methods::infer_expr_type::infer_expr_type, types::Type, utils::is_valid_identifier, }, generator::{ diff --git a/helix-db/src/helixc/analyzer/methods/traversal_validation.rs b/helix-db/src/helixc/analyzer/methods/traversal_validation.rs index d8664ecf..bef97b72 100644 --- a/helix-db/src/helixc/analyzer/methods/traversal_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/traversal_validation.rs @@ -7,7 +7,7 @@ use crate::{ generate_error, helixc::{ analyzer::{ - analyzer::Ctx, + Ctx, errors::push_query_err, methods::{ exclude_validation::validate_exclude, graph_step_validation::apply_graph_step, diff --git a/helix-db/src/helixc/analyzer/mod.rs b/helix-db/src/helixc/analyzer/mod.rs index 6bca9538..7bcd3018 100644 --- a/helix-db/src/helixc/analyzer/mod.rs +++ b/helix-db/src/helixc/analyzer/mod.rs @@ -1,4 +1,40 @@ -pub mod analyzer; +// Copyright 2025 HelixDB Inc. +// SPDX-License-Identifier: AGPL-3.0 + +//! This is the static analyzer for HelixQL. +//! It type checks the queries for grammatical and semantic correctness. +//! The analyzer methods are broken up into separate files within /methods, grouped by general functionality. +//! File names should be self-explanatory as to what is included in the file. + +use crate::helixc::{ + analyzer::{ + diagnostic::Diagnostic, + methods::{ + migration_validation::validate_migration, + query_validation::validate_query, + schema_methods::{build_field_lookups, check_schema, SchemaVersionMap}, + }, + types::Type, + }, + generator::Source as GeneratedSource, + parser::types::{EdgeSchema, ExpressionType, Field, Query, ReturnType, Source}, +}; +use itertools::Itertools; +use serde::Serialize; +use std::{ + borrow::Cow, + collections::{HashMap, HashSet}, + sync::OnceLock, +}; + +pub fn analyze(src: &Source) -> (Vec, GeneratedSource) { + let mut ctx = Ctx::new(src); + ctx.check_schema(); + ctx.check_schema_migrations(); + ctx.check_queries(); + (ctx.diagnostics, ctx.output) +} + pub mod diagnostic; pub mod error_codes; pub mod errors; @@ -7,3 +43,246 @@ pub mod methods; pub mod pretty; pub mod types; pub mod utils; + + +/// Internal working context shared by all passes. +pub(crate) struct Ctx<'a> { + pub(super) src: &'a Source, + /// Quick look‑ups + pub(super) node_set: HashSet<&'a str>, + pub(super) vector_set: HashSet<&'a str>, + pub(super) edge_map: HashMap<&'a str, &'a EdgeSchema>, + pub(super) node_fields: HashMap<&'a str, HashMap<&'a str, Cow<'a, Field>>>, + pub(super) edge_fields: HashMap<&'a str, HashMap<&'a str, Cow<'a, Field>>>, + pub(super) vector_fields: HashMap<&'a str, HashMap<&'a str, Cow<'a, Field>>>, + pub(super) all_schemas: SchemaVersionMap<'a>, + pub(super) diagnostics: Vec, + pub(super) output: GeneratedSource, +} + +pub static INTROSPECTION_DATA: OnceLock = OnceLock::new(); +pub static SECONDARY_INDICES: OnceLock> = OnceLock::new(); + +impl<'a> Ctx<'a> { + pub(super) fn new(src: &'a Source) -> Self { + // Build field look‑ups once + let all_schemas = build_field_lookups(src); + let (node_fields, edge_fields, vector_fields) = all_schemas.get_latest(); + + let output = GeneratedSource { + src: src.source.clone(), + ..Default::default() + }; + + let ctx = Self { + node_set: src + .get_latest_schema() + .node_schemas + .iter() + .map(|n| n.name.1.as_str()) + .collect(), + vector_set: src + .get_latest_schema() + .vector_schemas + .iter() + .map(|v| v.name.as_str()) + .collect(), + edge_map: src + .get_latest_schema() + .edge_schemas + .iter() + .map(|e| (e.name.1.as_str(), e)) + .collect(), + node_fields, + edge_fields, + vector_fields, + all_schemas, + src, + diagnostics: Vec::new(), + output, + }; + + INTROSPECTION_DATA + .set(IntrospectionData::from_schema(&ctx)) + .ok(); + + SECONDARY_INDICES + .set( + src.get_latest_schema() + .node_schemas + .iter() + .flat_map(|schema| { + schema + .fields + .iter() + .filter(|f| f.is_indexed()) + .map(|f| f.name.clone()) + }) + .dedup() + .collect(), + ) + .ok(); + ctx + } + + #[allow(unused)] + pub(super) fn get_item_fields( + &self, + item_type: &Type, + ) -> Option<&HashMap<&str, Cow<'_, Field>>> { + match item_type { + Type::Node(Some(node_type)) | Type::Nodes(Some(node_type)) => { + self.node_fields.get(node_type.as_str()) + } + Type::Edge(Some(edge_type)) | Type::Edges(Some(edge_type)) => { + self.edge_fields.get(edge_type.as_str()) + } + Type::Vector(Some(vector_type)) | Type::Vectors(Some(vector_type)) => { + self.vector_fields.get(vector_type.as_str()) + } + _ => None, + } + } + + // ---------- Pass #1: schema -------------------------- + /// Validate that every edge references declared node types. + pub(super) fn check_schema(&mut self) { + check_schema(self); + } + + // ---------- Pass #1.5: schema migrations -------------------------- + pub(super) fn check_schema_migrations(&mut self) { + for m in &self.src.migrations { + validate_migration(self, m); + } + } + + // ---------- Pass #2: queries ------------------------- + pub(super) fn check_queries(&mut self) { + for q in &self.src.queries { + validate_query(self, q); + } + } +} + +#[derive(Serialize)] +pub struct IntrospectionData { + schema: SchemaData, + queries: Vec, +} + +impl IntrospectionData { + fn from_schema(ctx: &Ctx) -> Self { + let queries = ctx.src.queries.iter().map(QueryData::from_query).collect(); + Self { + schema: SchemaData::from_ctx(ctx), + queries, + } + } +} + +#[derive(Serialize)] +pub struct SchemaData { + nodes: Vec, + vectors: Vec, + edges: Vec, +} + +impl SchemaData { + fn from_ctx(ctx: &Ctx) -> Self { + let nodes = ctx.node_fields.iter().map(NodeData::from_entry).collect(); + let vectors = ctx.vector_fields.iter().map(NodeData::from_entry).collect(); + let edges = ctx.edge_map.iter().map(EdgeData::from_entry).collect(); + + SchemaData { + nodes, + vectors, + edges, + } + } +} + +#[derive(Serialize)] +pub struct NodeData { + name: String, + properties: HashMap, +} + +impl NodeData { + fn from_entry(val: (&&str, &HashMap<&str, Cow>)) -> Self { + let properties = val + .1 + .iter() + .map(|(n, f)| (n.to_string(), f.field_type.to_string())) + .collect(); + NodeData { + name: val.0.to_string(), + properties, + } + } +} + +#[derive(Serialize)] +pub struct EdgeData { + name: String, + from: String, + to: String, + properties: HashMap, +} + +impl EdgeData { + fn from_entry((name, es): (&&str, &&EdgeSchema)) -> Self { + let properties = es + .properties + .iter() + .flatten() + .map(|f| (f.name.to_string(), f.field_type.to_string())) + .collect(); + + EdgeData { + name: name.to_string(), + from: es.from.1.clone(), + to: es.to.1.clone(), + properties, + } + } +} + +#[derive(Serialize)] +pub struct QueryData { + name: String, + parameters: HashMap, + returns: Vec, +} + +impl QueryData { + fn from_query(query: &Query) -> Self { + let parameters = query + .parameters + .iter() + .map(|p| (p.name.1.clone(), p.param_type.1.to_string())) + .collect(); + + let returns = query + .return_values + .iter() + .flat_map(|e| { + if let ReturnType::Expression(expr) = e { + if let ExpressionType::Identifier(ident) = &expr.expr { + Some(ident.clone()) + } else { + None + } + } else { + None + } + }) + .collect(); + + QueryData { + name: query.name.to_string(), + parameters, + returns, + } + } +} diff --git a/helix-db/src/helixc/analyzer/utils.rs b/helix-db/src/helixc/analyzer/utils.rs index 1b8f20b9..090139b1 100644 --- a/helix-db/src/helixc/analyzer/utils.rs +++ b/helix-db/src/helixc/analyzer/utils.rs @@ -3,7 +3,7 @@ use crate::helixc::analyzer::error_codes::ErrorCode; use crate::{ generate_error, helixc::{ - analyzer::{analyzer::Ctx, errors::push_query_err, types::Type}, + analyzer::{Ctx, errors::push_query_err, types::Type}, generator::{ traversal_steps::Step, utils::{GenRef, GeneratedValue}, diff --git a/helix-db/src/helixc/generator/mod.rs b/helix-db/src/helixc/generator/mod.rs index bdf8c655..35e82013 100644 --- a/helix-db/src/helixc/generator/mod.rs +++ b/helix-db/src/helixc/generator/mod.rs @@ -1,5 +1,9 @@ -use core::fmt; -use std::fmt::Display; +// Copyright 2025 HelixDB Inc. +// SPDX-License-Identifier: AGPL-3.0 + +//! This is the generator for HelixQL. It transforms the AST into Rust code. +//! The generator methods are broken up into separate files, grouped by general functionality. +//! File names should be self-explanatory as to what is included in the file. use crate::{ helix_engine::traversal_core::config::Config, @@ -10,6 +14,8 @@ use crate::{ utils::write_headers, }, }; +use core::fmt; +use std::fmt::Display; pub mod bool_op; pub mod migrations; diff --git a/helix-db/src/helixc/mod.rs b/helix-db/src/helixc/mod.rs index a4a92f94..1f965ed6 100644 --- a/helix-db/src/helixc/mod.rs +++ b/helix-db/src/helixc/mod.rs @@ -1,3 +1,8 @@ +// Copyright 2025 HelixDB Inc. +// SPDX-License-Identifier: AGPL-3.0 + +//! HelixQL compiler, analyzer, and transpiler. + pub mod analyzer; pub mod generator; pub mod parser; diff --git a/helix-db/src/helixc/parser/graph_step_parse_methods.rs b/helix-db/src/helixc/parser/graph_step_parse_methods.rs index 76470210..e4e60233 100644 --- a/helix-db/src/helixc/parser/graph_step_parse_methods.rs +++ b/helix-db/src/helixc/parser/graph_step_parse_methods.rs @@ -10,6 +10,12 @@ use crate::helixc::parser::{ use pest::iterators::Pair; impl HelixParser { + /// Parses an order by step + /// + /// #### Example + /// ```rs + /// ::ORDER(_::{age}) + /// ``` pub fn parse_order_by(&self, pair: Pair) -> Result { let mut inner = pair.clone().into_inner(); let order_by_type = match inner.next().unwrap().into_inner().next().unwrap().as_rule() { @@ -25,15 +31,26 @@ impl HelixParser { }) } + /// Parses a range step + /// + /// #### Example + /// ```rs + /// ::RANGE(1, 10) + /// ``` pub fn parse_range(&self, pair: Pair) -> Result<(Expression, Expression), ParserError> { let mut inner = pair.into_inner().next().unwrap().into_inner(); - // println!("inner: {:?}", inner); let start = self.parse_expression(inner.next().unwrap())?; let end = self.parse_expression(inner.next().unwrap())?; Ok((start, end)) } + /// Parses a boolean operation + /// + /// #### Example + /// ```rs + /// ::GT(1) + /// ``` pub fn parse_bool_operation(&self, pair: Pair) -> Result { let inner = pair.clone().into_inner().next().unwrap(); let expr = match inner.as_rule() { @@ -88,6 +105,12 @@ impl HelixParser { Ok(expr) } + /// Parses an update step + /// + /// #### Example + /// ```rs + /// ::UPDATE({age: 1}) + /// ``` pub fn parse_update(&self, pair: Pair) -> Result { let fields = self.parse_object_fields(pair.clone())?; Ok(Update { @@ -96,6 +119,12 @@ impl HelixParser { }) } + /// Parses an object step + /// + /// #### Example + /// ```rs + /// ::{username: name} + /// ``` pub fn parse_object_step(&self, pair: Pair) -> Result { let mut fields = Vec::new(); let mut should_spread = false; @@ -148,6 +177,12 @@ impl HelixParser { }) } + /// Parses a closure step + /// + /// #### Example + /// ```rs + /// ::|user|{user_age: user::{age}} + /// ``` pub fn parse_closure(&self, pair: Pair) -> Result { let mut pairs = pair.clone().into_inner(); let identifier = pairs.next().unwrap().as_str().to_string(); @@ -159,6 +194,12 @@ impl HelixParser { }) } + /// Parses an exclude step + /// + /// #### Example + /// ```rs + /// ::!{age, name} + /// ``` pub fn parse_exclude(&self, pair: Pair) -> Result { let mut fields = Vec::new(); for p in pair.clone().into_inner() { diff --git a/helix-db/src/helixc/parser/mod.rs b/helix-db/src/helixc/parser/mod.rs index b660358a..17414e63 100644 --- a/helix-db/src/helixc/parser/mod.rs +++ b/helix-db/src/helixc/parser/mod.rs @@ -1,3 +1,21 @@ +// Copyright 2025 HelixDB Inc. +// SPDX-License-Identifier: AGPL-3.0 + +//! This is the parser for HelixQL. +//! The parsing methods are broken up into separate files, grouped by general functionality. +//! File names should be self-explanatory as to what is included in the file. + +use crate::helixc::parser::types::{Content, HxFile, Schema, Source}; +use location::HasLoc; +use parser_methods::ParserError; +use pest::Parser as PestParser; +use pest_derive::Parser; +use std::{ + collections::{HashMap, HashSet}, + fmt::Debug, + io::Write, +}; + pub mod creation_step_parse_methods; pub mod expression_parse_methods; pub mod graph_step_parse_methods; @@ -11,17 +29,6 @@ pub mod traversal_parse_methods; pub mod types; pub mod utils; -use crate::helixc::parser::types::{Content, HxFile, Schema, Source}; -use location::HasLoc; -use parser_methods::ParserError; -use pest::Parser as PestParser; -use pest_derive::Parser; -use std::{ - collections::{HashMap, HashSet}, - fmt::Debug, - io::Write, -}; - #[derive(Parser)] #[grammar = "grammar.pest"] pub struct HelixParser { From 10cb87ab137ebaf38ef11b877e66550acd55a58e Mon Sep 17 00:00:00 2001 From: xav-db Date: Fri, 5 Sep 2025 13:00:02 +0100 Subject: [PATCH 08/18] doing small refactoring fixing more todos --- .../analyzer/methods/infer_expr_type.rs | 20 +++-------- .../analyzer/methods/query_validation.rs | 26 +++++++------- .../analyzer/methods/statement_validation.rs | 35 +++++++------------ helix-db/src/helixc/analyzer/utils.rs | 4 +++ .../src/helixc/generator/traversal_steps.rs | 28 +++------------ helix-db/src/protocol/date.rs | 2 -- 6 files changed, 38 insertions(+), 77 deletions(-) diff --git a/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs b/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs index 3cf913e5..92533492 100644 --- a/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs +++ b/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs @@ -1,6 +1,6 @@ //! Semantic analyzer for Helix‑QL. use crate::helixc::analyzer::error_codes::ErrorCode; -use crate::helixc::analyzer::utils::DEFAULT_VAR_NAME; +use crate::helixc::analyzer::utils::{DEFAULT_VAR_NAME, is_in_scope}; use crate::helixc::generator::utils::EmbedData; use crate::{ generate_error, @@ -209,8 +209,7 @@ pub(crate) fn infer_expr_type<'a>( value.as_str() ); } else { - let variable_type = - scope.get(value.as_str()).unwrap(); + let variable_type = scope.get(value.as_str()).unwrap(); if variable_type != &Type::from( field_set @@ -221,7 +220,7 @@ pub(crate) fn infer_expr_type<'a>( ) { generate_error!( - ctx, + ctx, original_query, loc.clone(), E205, @@ -1099,7 +1098,6 @@ pub(crate) fn infer_expr_type<'a>( } Empty => (Type::Unknown, Some(GeneratedStatement::Empty)), BM25Search(bm25_search) => { - // TODO: look into how best do type checking for type passed in if let Some(ref ty) = bm25_search.type_arg && !ctx.node_set.contains(ty.as_str()) { @@ -1117,18 +1115,8 @@ pub(crate) fn infer_expr_type<'a>( } Some(ValueType::Identifier { value: i, loc: _ }) => { is_valid_identifier(ctx, original_query, bm25_search.loc.clone(), i.as_str()); - // if is in params then use data. - let _ = type_in_scope( - ctx, - original_query, - bm25_search.loc.clone(), - scope, - i.as_str(), - ); - if original_query.parameters.iter().any(|p| p.name.1 == *i) - || scope.get(i.as_str()).is_some() - { + if is_in_scope(scope, i.as_str()) { gen_identifier_or_param(original_query, i, true, false) } else { generate_error!( diff --git a/helix-db/src/helixc/analyzer/methods/query_validation.rs b/helix-db/src/helixc/analyzer/methods/query_validation.rs index 7ee22d9c..d77afa21 100644 --- a/helix-db/src/helixc/analyzer/methods/query_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/query_validation.rs @@ -18,7 +18,7 @@ use crate::helixc::{ traversal_steps::ShouldCollect, utils::{GenRef, GeneratedValue}, }, - parser::{types::*, location::Loc}, + parser::{location::Loc, types::*}, }; use paste::paste; use std::collections::HashMap; @@ -40,20 +40,18 @@ pub(crate) fn validate_query<'a>(ctx: &mut Ctx<'a>, original_query: &'a Query) { for param in &original_query.parameters { if let FieldType::Identifier(ref id) = param.param_type.1 && is_valid_identifier(ctx, original_query, param.param_type.0.clone(), id.as_str()) + && !ctx.node_set.contains(id.as_str()) + && !ctx.edge_map.contains_key(id.as_str()) + && !ctx.vector_set.contains(id.as_str()) { - if !ctx.node_set.contains(id.as_str()) - && !ctx.edge_map.contains_key(id.as_str()) - && !ctx.vector_set.contains(id.as_str()) - { - generate_error!( - ctx, - original_query, - param.param_type.0.clone(), - E209, - &id, - ¶m.name.1 - ); - } + generate_error!( + ctx, + original_query, + param.param_type.0.clone(), + E209, + &id, + ¶m.name.1 + ); } // constructs parameters and sub‑parameters for generator GeneratedParameter::unwrap_param( diff --git a/helix-db/src/helixc/analyzer/methods/statement_validation.rs b/helix-db/src/helixc/analyzer/methods/statement_validation.rs index a3c46b69..db521554 100644 --- a/helix-db/src/helixc/analyzer/methods/statement_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/statement_validation.rs @@ -5,11 +5,12 @@ use crate::{ generate_error, helixc::{ analyzer::{ - Ctx, errors::push_query_err, methods::infer_expr_type::infer_expr_type, - types::Type, utils::is_valid_identifier, + Ctx, errors::push_query_err, methods::infer_expr_type::infer_expr_type, types::Type, + utils::is_valid_identifier, }, generator::{ - queries::Query as GeneratedQuery, statements::Statement as GeneratedStatement, + queries::Query as GeneratedQuery, + statements::Statement as GeneratedStatement, statements::{ Assignment as GeneratedAssignment, Drop as GeneratedDrop, ForEach as GeneratedForEach, ForLoopInVariable, ForVariable, @@ -84,19 +85,20 @@ pub(crate) fn validate_statements<'a>( } ForLoop(fl) => { - // Ensure the collection exists if !scope.contains_key(fl.in_variable.1.as_str()) { generate_error!(ctx, original_query, fl.loc.clone(), E301, &fl.in_variable.1); } - // Add loop vars to new child scope and walk the body + let mut body_scope = HashMap::new(); let mut for_loop_in_variable: ForLoopInVariable = ForLoopInVariable::Empty; - // check if fl.in_variable is a valid parameter + // Check if the in variable is a parameter let param = original_query .parameters .iter() .find(|p| p.name.1 == fl.in_variable.1); + // if it is a parameter, add it to the body scope + // else assume variable in scope and add it to the body scope let _ = match param { Some(param) => { for_loop_in_variable = @@ -138,18 +140,10 @@ pub(crate) fn validate_statements<'a>( scope.insert(name.as_str(), Type::Unknown); for_variable = ForVariable::Identifier(GenRef::Std(name.clone())); } - ForLoopVars::ObjectAccess { - name: _, - field: _, - loc: _, - } => { - // body_scope.insert(name.as_str(), Type::Unknown); - // for_variable = - // ForVariable::ObjectDestructure(vec![GenRef::Std(name.clone())]); - unreachable!() + ForLoopVars::ObjectAccess { .. } => { + todo!() } ForLoopVars::ObjectDestructuring { fields, loc: _ } => { - // TODO: check if fields are valid match ¶m { Some(p) => { for_loop_in_variable = @@ -203,7 +197,6 @@ pub(crate) fn validate_statements<'a>( } None => match scope.contains_key(fl.in_variable.1.as_str()) { true => { - // TODO: Check fields for_variable = ForVariable::ObjectDestructure( fields .iter() @@ -233,16 +226,14 @@ pub(crate) fn validate_statements<'a>( } let mut statements = Vec::new(); for body_stmt in &fl.statements { - // Recursive walk (but without infinite nesting for now) - let stmt = validate_statements(ctx, scope, original_query, query, body_stmt); if let Some(s) = stmt { statements.push(s); } } - // body_scope.iter().for_each(|(k, _)| { - // scope.remove(k); - // }); + body_scope.iter().for_each(|(k, _)| { + scope.remove(k); + }); let stmt = GeneratedStatement::ForEach(GeneratedForEach { for_variables: for_variable, diff --git a/helix-db/src/helixc/analyzer/utils.rs b/helix-db/src/helixc/analyzer/utils.rs index 090139b1..57a5f5f7 100644 --- a/helix-db/src/helixc/analyzer/utils.rs +++ b/helix-db/src/helixc/analyzer/utils.rs @@ -76,6 +76,10 @@ pub(super) fn gen_id_access_or_param(original_query: &Query, name: &str) -> Gene } } +pub(super) fn is_in_scope(scope: &HashMap<&str, Type>, name: &str) -> bool { + scope.contains_key(name) +} + pub(super) fn type_in_scope( ctx: &mut Ctx, original_query: &Query, diff --git a/helix-db/src/helixc/generator/traversal_steps.rs b/helix-db/src/helixc/generator/traversal_steps.rs index 24352e41..cc3a3242 100644 --- a/helix-db/src/helixc/generator/traversal_steps.rs +++ b/helix-db/src/helixc/generator/traversal_steps.rs @@ -1,7 +1,7 @@ -use crate::helixc::generator::utils::{write_properties, VecData}; +use crate::helixc::generator::utils::{VecData, write_properties}; use super::{ - bool_op::{BoolOp, BoExp}, + bool_op::{BoExp, BoolOp}, object_remapping_generation::Remapping, source_steps::SourceStep, utils::{GenRef, GeneratedValue, Order, Separator}, @@ -123,12 +123,7 @@ impl Display for Traversal { write!(f, "\n{step}")?; } write!(f, "\n .collect_to::>();")?; - write!( - f, - "G::new_mut_from(Arc::clone(&db), &mut txn, update_tr)", // TODO: make - // this less - // scrappy - )?; + write!(f, "G::new_mut_from(Arc::clone(&db), &mut txn, update_tr)",)?; write!(f, "\n .update({})", write_properties(properties))?; write!(f, "\n .collect_to_obj()")?; write!(f, "}}")?; @@ -279,14 +274,11 @@ impl Display for InE { #[derive(Clone)] pub enum Where { Ref(WhereRef), - Mut(WhereMut), } impl Display for Where { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - Where::Ref(wr) => write!(f, "{wr}"), - Where::Mut(wm) => write!(f, "{wm}"), - } + let Where::Ref(wr) = self; + write!(f, "{wr}") } } @@ -310,16 +302,6 @@ impl Display for WhereRef { } } -#[derive(Clone)] -pub struct WhereMut { - pub expr: BoExp, -} -impl Display for WhereMut { - fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result { - todo!() - } -} - #[derive(Clone)] pub struct Range { pub start: GeneratedValue, diff --git a/helix-db/src/protocol/date.rs b/helix-db/src/protocol/date.rs index e6839499..a587da8c 100644 --- a/helix-db/src/protocol/date.rs +++ b/helix-db/src/protocol/date.rs @@ -85,8 +85,6 @@ impl<'de> Visitor<'de> for DateVisitor { } /// Visits a string and parses it into a chrono DateTime. - /// - /// TODO: check if this is correct -> is the same as implementation above so should be fine. fn visit_str(self, v: &str) -> Result where E: serde::de::Error, From 380af69437d7a36a2e6941123e6200b446ea52b6 Mon Sep 17 00:00:00 2001 From: xav-db Date: Fri, 5 Sep 2025 13:08:27 +0100 Subject: [PATCH 09/18] more refactoring and removing todos --- helix-db/src/helix_engine/macros.rs | 3 -- .../traversal_core/ops/source/n_from_index.rs | 1 - .../traversal_core/ops/vectors/insert.rs | 37 ------------------- .../helix_engine/vector_core/vector_core.rs | 10 ----- .../embedding_providers.rs | 3 -- helix-db/src/helix_gateway/worker_pool/mod.rs | 4 +- .../analyzer/methods/infer_expr_type.rs | 1 - .../analyzer/methods/traversal_validation.rs | 13 +------ 8 files changed, 4 insertions(+), 68 deletions(-) diff --git a/helix-db/src/helix_engine/macros.rs b/helix-db/src/helix_engine/macros.rs index 77d9bfa5..e3ce0775 100644 --- a/helix-db/src/helix_engine/macros.rs +++ b/helix-db/src/helix_engine/macros.rs @@ -178,9 +178,6 @@ pub mod macros { #[macro_export] macro_rules! traversal_remapping { ($remapping_vals:expr, $var_name:expr, $should_spread:expr, $new_name:expr => $traversal:expr) => {{ - // TODO: ref? - // Apply remappings to the nested traversal result - let nested_return_value = ReturnValue::from_traversal_value_array_with_mixin( $traversal, $remapping_vals.borrow_mut(), diff --git a/helix-db/src/helix_engine/traversal_core/ops/source/n_from_index.rs b/helix-db/src/helix_engine/traversal_core/ops/source/n_from_index.rs index 409ba2c3..d1f56896 100644 --- a/helix-db/src/helix_engine/traversal_core/ops/source/n_from_index.rs +++ b/helix-db/src/helix_engine/traversal_core/ops/source/n_from_index.rs @@ -81,7 +81,6 @@ impl<'a, I: Iterator>, K: Into .storage .secondary_indices .get(index) - // TODO: this .ok_or(GraphError::New(format!( "Secondary Index {index} not found" ))) diff --git a/helix-db/src/helix_engine/traversal_core/ops/vectors/insert.rs b/helix-db/src/helix_engine/traversal_core/ops/vectors/insert.rs index 3be0dbc3..383cbc47 100644 --- a/helix-db/src/helix_engine/traversal_core/ops/vectors/insert.rs +++ b/helix-db/src/helix_engine/traversal_core/ops/vectors/insert.rs @@ -8,7 +8,6 @@ use crate::{ }, protocol::value::Value, }; -use std::sync::Arc; pub struct InsertVIterator { inner: std::iter::Once>, @@ -31,14 +30,6 @@ pub trait InsertVAdapter<'a, 'b>: Iterator RwTraversalIterator<'a, 'b, impl Iterator>> where F: Fn(&HVector, &RoTxn) -> bool; - - fn insert_vs( - self, - queries: &[Vec], - fields: Option>, - ) -> RwTraversalIterator<'a, 'b, impl Iterator>> - where - F: Fn(&HVector, &RoTxn) -> bool; } impl<'a, 'b, I: Iterator>> InsertVAdapter<'a, 'b> @@ -77,32 +68,4 @@ impl<'a, 'b, I: Iterator>> InsertVAdap txn: self.txn, } } - - fn insert_vs( - self, - queries: &[Vec], - fields: Option>, - ) -> RwTraversalIterator<'a, 'b, impl Iterator>> - where - F: Fn(&HVector, &RoTxn) -> bool, - { - let txn = self.txn; - let storage = Arc::clone(&self.storage); - let iter = queries - .iter() - .map(|vec| { - let vector = storage.vectors.insert::(txn, vec, fields.clone()); // TODO: remove clone - match vector { - Ok(vector) => Ok(TraversalValue::Vector(vector)), - Err(e) => Err(GraphError::from(e)), - } - }) - .collect::>(); - - RwTraversalIterator { - inner: iter.into_iter(), - storage: self.storage, - txn, - } - } } diff --git a/helix-db/src/helix_engine/vector_core/vector_core.rs b/helix-db/src/helix_engine/vector_core/vector_core.rs index cc2fd2b3..83fe8603 100644 --- a/helix-db/src/helix_engine/vector_core/vector_core.rs +++ b/helix-db/src/helix_engine/vector_core/vector_core.rs @@ -106,8 +106,6 @@ impl VectorCore { #[inline] fn get_new_level(&self) -> usize { - // TODO: look at using the XOR shift algorithm for random number generation - // Should instead using an atomic mutable seed and the XOR shift algorithm let mut rng = rand::rng(); let r: f64 = rng.random::(); (-r.ln() * self.config.m_l).floor() as usize @@ -175,7 +173,6 @@ impl VectorCore { for result in iter { let (key, _) = result?; - // TODO: fix here because not working at all let mut arr = [0u8; 16]; let len = std::cmp::min(key.len(), 16); arr[..len].copy_from_slice(&key[prefix_len..(prefix_len + len)]); @@ -188,7 +185,6 @@ impl VectorCore { let vector = self.get_vector(txn, neighbor_id, level, false)?; let passes_filters = match filter { - // TODO: look at implementing a macro that actually just runs each function rather than iterating through Some(filter_slice) => filter_slice.iter().all(|f| f(&vector, txn)), None => true, }; @@ -196,12 +192,6 @@ impl VectorCore { if passes_filters { neighbors.push(vector); } - - //if let Ok(vector) = self.get_vector(txn, neighbor_id, level, true) { - // if filter.is_none() || filter.unwrap().iter().all(|f| f(&vector, txn)) { - // neighbors.push(vector); - // } - //} } neighbors.shrink_to_fit(); diff --git a/helix-db/src/helix_gateway/embedding_providers/embedding_providers.rs b/helix-db/src/helix_gateway/embedding_providers/embedding_providers.rs index ee36d90e..d092db08 100644 --- a/helix-db/src/helix_gateway/embedding_providers/embedding_providers.rs +++ b/helix-db/src/helix_gateway/embedding_providers/embedding_providers.rs @@ -5,9 +5,6 @@ use sonic_rs::{JsonContainerTrait, json}; use std::env; use url::Url; -// TODO: add support for rust native embedding model libs as well so it runs fully built in -// in case we have a gpu or something on the server we're running it on - /// Trait for embedding models to fetch text embeddings. #[allow(async_fn_in_trait)] pub trait EmbeddingModel { diff --git a/helix-db/src/helix_gateway/worker_pool/mod.rs b/helix-db/src/helix_gateway/worker_pool/mod.rs index 3f7c430b..e64adb14 100644 --- a/helix-db/src/helix_gateway/worker_pool/mod.rs +++ b/helix-db/src/helix_gateway/worker_pool/mod.rs @@ -33,8 +33,8 @@ impl WorkerPool { "Expected number of threads in thread pool to be more than 0, got {size}" ); - let (req_tx, req_rx) = flume::bounded::(1000); // TODO: make this configurable - let (cont_tx, cont_rx) = flume::bounded::(1000); // TODO: make this configurable + let (req_tx, req_rx) = flume::bounded::(1000); + let (cont_tx, cont_rx) = flume::bounded::(1000); let workers = (0..size) .map(|_| { diff --git a/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs b/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs index 92533492..c7396202 100644 --- a/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs +++ b/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs @@ -558,7 +558,6 @@ pub(crate) fn infer_expr_type<'a>( from, label, properties, - // secondary_indices: None, // TODO: Add secondary indices by checking against labeled `INDEX` fields in schema }; let stmt = GeneratedStatement::Traversal(GeneratedTraversal { source_step: Separator::Period(SourceStep::AddE(add_e)), diff --git a/helix-db/src/helixc/analyzer/methods/traversal_validation.rs b/helix-db/src/helixc/analyzer/methods/traversal_validation.rs index bef97b72..751b0367 100644 --- a/helix-db/src/helixc/analyzer/methods/traversal_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/traversal_validation.rs @@ -287,7 +287,8 @@ pub(crate) fn validate_traversal<'a>( // anonymous will be the traversal type rather than the start type StartNode::Anonymous => { let parent = parent_ty.unwrap(); - gen_traversal.traversal_type = TraversalType::FromVar(GenRef::Std(DEFAULT_VAR_NAME.to_string())); + gen_traversal.traversal_type = + TraversalType::FromVar(GenRef::Std(DEFAULT_VAR_NAME.to_string())); gen_traversal.source_step = Separator::Empty(SourceStep::Anonymous); parent } @@ -531,16 +532,6 @@ pub(crate) fn validate_traversal<'a>( } StepType::Object(obj) => { - // TODO: Fix issue with step count being incorrect (i think its counting each field as a step) - // if i != number_of_steps { - // println!("{} {}", i, number_of_steps); - // push_query_err(ctx, - // original_query, - // obj.loc.clone(), - // "object is only valid as the last step in a traversal".to_string(), - // "move the object to the end of the traversal", - // ); - // } validate_object( ctx, &cur_ty, From 6e2008594f6c6b58840682843fd95e1adeb9b626 Mon Sep 17 00:00:00 2001 From: xav-db Date: Fri, 5 Sep 2025 13:19:08 +0100 Subject: [PATCH 10/18] fix for issue with for loops? --- .../src/helixc/analyzer/methods/statement_validation.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/helix-db/src/helixc/analyzer/methods/statement_validation.rs b/helix-db/src/helixc/analyzer/methods/statement_validation.rs index db521554..889138a9 100644 --- a/helix-db/src/helixc/analyzer/methods/statement_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/statement_validation.rs @@ -231,9 +231,9 @@ pub(crate) fn validate_statements<'a>( statements.push(s); } } - body_scope.iter().for_each(|(k, _)| { - scope.remove(k); - }); + // body_scope.iter().for_each(|(k, _)| { + // scope.remove(k); + // }); let stmt = GeneratedStatement::ForEach(GeneratedForEach { for_variables: for_variable, From 81575b38dc6ed83fb995d7de21ee9667836bd609 Mon Sep 17 00:00:00 2001 From: xav-db Date: Fri, 5 Sep 2025 23:37:15 +0100 Subject: [PATCH 11/18] fixing issues with for loops --- .../analyzer/methods/statement_validation.rs | 60 +++++++++++++------ helix-db/src/helixc/analyzer/types.rs | 9 ++- 2 files changed, 45 insertions(+), 24 deletions(-) diff --git a/helix-db/src/helixc/analyzer/methods/statement_validation.rs b/helix-db/src/helixc/analyzer/methods/statement_validation.rs index 889138a9..180f3120 100644 --- a/helix-db/src/helixc/analyzer/methods/statement_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/statement_validation.rs @@ -84,6 +84,7 @@ pub(crate) fn validate_statements<'a>( stmt } + // PARAMS DONT GET PARSED TO TYPE::ARRAY ForLoop(fl) => { if !scope.contains_key(fl.in_variable.1.as_str()) { generate_error!(ctx, original_query, fl.loc.clone(), E301, &fl.in_variable.1); @@ -136,8 +137,9 @@ pub(crate) fn validate_statements<'a>( match &fl.variable { ForLoopVars::Identifier { name, loc: _ } => { is_valid_identifier(ctx, original_query, fl.loc.clone(), name.as_str()); - body_scope.insert(name.as_str(), Type::Unknown); - scope.insert(name.as_str(), Type::Unknown); + let field_type = scope.get(name.as_str()).unwrap().clone(); + body_scope.insert(name.as_str(), field_type.clone()); + scope.insert(name.as_str(), field_type); for_variable = ForVariable::Identifier(GenRef::Std(name.clone())); } ForLoopVars::ObjectAccess { .. } => { @@ -162,8 +164,14 @@ pub(crate) fn validate_statements<'a>( [field_name, &fl.in_variable.1] ); } - body_scope.insert(field_name.as_str(), Type::Unknown); - scope.insert(field_name.as_str(), Type::Unknown); + let field_type = Type::from( + param_fields + .get(field_name.as_str()) + .unwrap() + .clone(), + ); + body_scope.insert(field_name.as_str(), field_type.clone()); + scope.insert(field_name.as_str(), field_type); } for_variable = ForVariable::ObjectDestructure( fields @@ -195,23 +203,37 @@ pub(crate) fn validate_statements<'a>( } } } - None => match scope.contains_key(fl.in_variable.1.as_str()) { - true => { - for_variable = ForVariable::ObjectDestructure( - fields - .iter() - .map(|(_, f)| { - let name = f.as_str(); + None => match scope.get(fl.in_variable.1.as_str()) { + Some(Type::Array(object_arr)) => { + match object_arr.as_ref() { + Type::Object(object) => { + let mut obj_dest_fields = Vec::with_capacity(fields.len()); + let object = object.clone(); + for (_, field_name) in fields { + let name = field_name.as_str(); // adds non-param fields to scope - body_scope.insert(name, Type::Unknown); - scope.insert(name, Type::Unknown); - - GenRef::Std(name.to_string()) - }) - .collect(), - ); + let field_type = object.get(name).unwrap().clone(); + let field_type = Type::from(field_type.clone()); + body_scope.insert(name, field_type.clone()); + scope.insert(name, field_type); + obj_dest_fields.push(GenRef::Std(name.to_string())); + } + for_variable = + ForVariable::ObjectDestructure(obj_dest_fields); + } + _ => { + generate_error!( + ctx, + original_query, + fl.in_variable.0.clone(), + E653, + [&fl.in_variable.1], + [&fl.in_variable.1] + ); + } + } } - false => { + _ => { generate_error!( ctx, original_query, diff --git a/helix-db/src/helixc/analyzer/types.rs b/helix-db/src/helixc/analyzer/types.rs index 1fa63a19..e4eb9186 100644 --- a/helix-db/src/helixc/analyzer/types.rs +++ b/helix-db/src/helixc/analyzer/types.rs @@ -9,9 +9,7 @@ use crate::helixc::{ }, utils::{GenRef, GeneratedType, GeneratedValue, RustType as GeneratedRustType}, }, - parser::types::{ - DefaultValue, EdgeSchema, FieldType, NodeSchema, Parameter, VectorSchema, - }, + parser::types::{DefaultValue, EdgeSchema, FieldType, NodeSchema, Parameter, VectorSchema}, }; impl From for GeneratedNodeSchema { @@ -365,8 +363,9 @@ impl From for Type { match ft { String | Boolean | F32 | F64 | I8 | I16 | I32 | I64 | U8 | U16 | U32 | U64 | U128 | Uuid | Date => Type::Scalar(ft.clone()), - Array(inner_ft) => Type::from(*inner_ft), - _ => Type::Unknown, + Array(inner_ft) => Type::Array(Box::new(Type::from(*inner_ft))), + Object(obj) => Type::Object(obj.into_iter().map(|(k, v)| (k, Type::from(v))).collect()), + Identifier(id) => Type::Scalar(FieldType::Identifier(id)), } } } From 77f41578b1194ca1835c72ba4020f226813ddf08 Mon Sep 17 00:00:00 2001 From: xav-db Date: Sat, 6 Sep 2025 09:49:28 +0100 Subject: [PATCH 12/18] fixing issue with array types not being implemented in partial eq --- helix-db/src/helixc/analyzer/error_codes.rs | 2 +- .../analyzer/methods/infer_expr_type.rs | 4 ++++ .../helixc/analyzer/methods/schema_methods.rs | 8 ++++--- .../analyzer/methods/statement_validation.rs | 1 - .../analyzer/methods/traversal_validation.rs | 1 + helix-db/src/helixc/analyzer/types.rs | 23 ++++++++++++++----- helix-db/src/helixc/generator/utils.rs | 10 ++++---- helix-db/src/protocol/value.rs | 2 +- 8 files changed, 34 insertions(+), 17 deletions(-) diff --git a/helix-db/src/helixc/analyzer/error_codes.rs b/helix-db/src/helixc/analyzer/error_codes.rs index 03e2a1e5..cae647ed 100644 --- a/helix-db/src/helixc/analyzer/error_codes.rs +++ b/helix-db/src/helixc/analyzer/error_codes.rs @@ -209,7 +209,7 @@ implement_error_code!(E202, implement_error_code!(E203, "cannot access properties on the type `{}`" => { type_name }, "ensure the type is a node, edge, or vector" => {}); implement_error_code!(E204, "field `{}` is a reserved field name" => { field_name }, "rename the field" => {}); implement_error_code!(E205, - "type of value `{}` does not match field type `{}` for {} type `{}`" => { value, field_type, item_type, item_type_name }, + "type of value `{}` is `{}`, which does not match field type `{}` for {} type `{}`" => { value, value_type, field_type, item_type, item_type_name }, "change the value type to match the field type defined in the schema" => {}); implement_error_code!(E206, "invalid value type `{}`" => { value_type }, "use a literal or an identifier" => {}); implement_error_code!(E207, "edge type `{}` exists but it is not a valid edge type for the given {} type `{}`" => { edge_type, item_type, item_type_name }, "check the schema field names" => {}); diff --git a/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs b/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs index c7396202..8a45aa35 100644 --- a/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs +++ b/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs @@ -225,6 +225,7 @@ pub(crate) fn infer_expr_type<'a>( loc.clone(), E205, value.as_str(), + &variable_type.to_string(), &field_set .get(field_name.as_str()) .unwrap() @@ -252,6 +253,7 @@ pub(crate) fn infer_expr_type<'a>( loc.clone(), E205, value.as_str(), + &value.to_string(), &field_type.to_string(), "node", ty.as_str() @@ -441,6 +443,7 @@ pub(crate) fn infer_expr_type<'a>( loc.clone(), E205, value.as_str(), + &value.to_string(), &field_type.to_string(), "edge", ty.as_str() @@ -635,6 +638,7 @@ pub(crate) fn infer_expr_type<'a>( loc.clone(), E205, value.as_str(), + &value.to_string(), &field_type.to_string(), "vector", ty.as_str() diff --git a/helix-db/src/helixc/analyzer/methods/schema_methods.rs b/helix-db/src/helixc/analyzer/methods/schema_methods.rs index 7e80398d..f4f0200d 100644 --- a/helix-db/src/helixc/analyzer/methods/schema_methods.rs +++ b/helix-db/src/helixc/analyzer/methods/schema_methods.rs @@ -149,7 +149,7 @@ pub(crate) fn check_schema(ctx: &mut Ctx) { } if let Some(v) = edge.properties.as_ref() { v.iter().for_each(|f| { - if f.name.to_lowercase() == "id" { + if RESERVED_FIELD_NAMES.contains(&f.name.to_lowercase().as_str()) { push_schema_err( ctx, f.loc.clone(), @@ -164,7 +164,7 @@ pub(crate) fn check_schema(ctx: &mut Ctx) { } for node in &ctx.src.get_latest_schema().node_schemas { node.fields.iter().for_each(|f| { - if f.name.to_lowercase() == "id" { + if RESERVED_FIELD_NAMES.contains(&f.name.to_lowercase().as_str()) { push_schema_err( ctx, f.loc.clone(), @@ -178,7 +178,7 @@ pub(crate) fn check_schema(ctx: &mut Ctx) { } for vector in &ctx.src.get_latest_schema().vector_schemas { vector.fields.iter().for_each(|f: &Field| { - if f.name.to_lowercase() == "id" { + if RESERVED_FIELD_NAMES.contains(&f.name.to_lowercase().as_str()) { push_schema_err( ctx, f.loc.clone(), @@ -191,3 +191,5 @@ pub(crate) fn check_schema(ctx: &mut Ctx) { ctx.output.vectors.push(vector.clone().into()); } } + +const RESERVED_FIELD_NAMES: &[&str] = &["id", "label", "to_node", "from_node", "data", "score"]; \ No newline at end of file diff --git a/helix-db/src/helixc/analyzer/methods/statement_validation.rs b/helix-db/src/helixc/analyzer/methods/statement_validation.rs index 180f3120..8e12d330 100644 --- a/helix-db/src/helixc/analyzer/methods/statement_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/statement_validation.rs @@ -213,7 +213,6 @@ pub(crate) fn validate_statements<'a>( let name = field_name.as_str(); // adds non-param fields to scope let field_type = object.get(name).unwrap().clone(); - let field_type = Type::from(field_type.clone()); body_scope.insert(name, field_type.clone()); scope.insert(name, field_type); obj_dest_fields.push(GenRef::Std(name.to_string())); diff --git a/helix-db/src/helixc/analyzer/methods/traversal_validation.rs b/helix-db/src/helixc/analyzer/methods/traversal_validation.rs index 751b0367..6fb0bcc2 100644 --- a/helix-db/src/helixc/analyzer/methods/traversal_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/traversal_validation.rs @@ -98,6 +98,7 @@ pub(crate) fn validate_traversal<'a>( original_query, loc.clone(), E205, + &value.stringify(), &value.to_string(), &field.field_type.to_string(), "node", diff --git a/helix-db/src/helixc/analyzer/types.rs b/helix-db/src/helixc/analyzer/types.rs index e4eb9186..7a1e0bbd 100644 --- a/helix-db/src/helixc/analyzer/types.rs +++ b/helix-db/src/helixc/analyzer/types.rs @@ -19,11 +19,14 @@ impl From for GeneratedNodeSchema { properties: generated .fields .into_iter() - .map(|f| SchemaProperty { - name: f.name, - field_type: f.field_type.into(), - default_value: f.defaults.map(|d| d.into()), - is_index: f.prefix, + .map(|f| { + // println!("into: {:?}", f.field_type.into()); + SchemaProperty { + name: f.name, + field_type: f.field_type.into(), + default_value: f.defaults.map(|d| d.into()), + is_index: f.prefix, + } }) .collect(), } @@ -352,7 +355,9 @@ impl PartialEq for Type { (Type::Edges(name), Type::Edges(other_name)) => name == other_name, (Type::Vector(name), Type::Vector(other_name)) => name == other_name, (Type::Vectors(name), Type::Vectors(other_name)) => name == other_name, - _ => false, + (Type::Array(inner), Type::Array(other_inner)) => inner == other_inner, + (Type::Vector(name), Type::Vectors(other_name)) => name == other_name, + _ => unreachable!(), } } } @@ -369,3 +374,9 @@ impl From for Type { } } } + +impl std::fmt::Display for Type { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self) + } +} diff --git a/helix-db/src/helixc/generator/utils.rs b/helix-db/src/helixc/generator/utils.rs index 54dfc527..8ca8e6a1 100644 --- a/helix-db/src/helixc/generator/utils.rs +++ b/helix-db/src/helixc/generator/utils.rs @@ -234,11 +234,11 @@ impl Display for GeneratedValue { impl Debug for GeneratedValue { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { - GeneratedValue::Literal(value) => write!(f, "Literal({value})"), - GeneratedValue::Primitive(value) => write!(f, "Primitive({value})"), - GeneratedValue::Identifier(value) => write!(f, "Identifier({value})"), - GeneratedValue::Parameter(value) => write!(f, "Parameter({value})"), - GeneratedValue::Array(value) => write!(f, "Array({value:?})"), + GeneratedValue::Literal(value) => write!(f, "GV: Literal({value})"), + GeneratedValue::Primitive(value) => write!(f, "GV: Primitive({value})"), + GeneratedValue::Identifier(value) => write!(f, "GV: Identifier({value})"), + GeneratedValue::Parameter(value) => write!(f, "GV: Parameter({value})"), + GeneratedValue::Array(value) => write!(f, "GV: Array({value:?})"), GeneratedValue::Unknown => write!(f, "Unknown"), } } diff --git a/helix-db/src/protocol/value.rs b/helix-db/src/protocol/value.rs index e33d7def..d24349dd 100644 --- a/helix-db/src/protocol/value.rs +++ b/helix-db/src/protocol/value.rs @@ -40,7 +40,7 @@ pub enum Value { } impl Value { - pub fn to_string(&self) -> String { + pub fn stringify(&self) -> String { match self { Value::String(s) => s.to_string(), Value::F32(f) => f.to_string(), From 232f7e1902df0a33bd679316f41c14c4e6d558b9 Mon Sep 17 00:00:00 2001 From: xav-db Date: Sat, 6 Sep 2025 09:54:35 +0100 Subject: [PATCH 13/18] renamings and adding more strict type checking to vectors and nodes --- .../analyzer/methods/infer_expr_type.rs | 60 ++++++++++++++++++- .../analyzer/methods/object_validation.rs | 4 +- .../analyzer/methods/traversal_validation.rs | 6 +- .../generator/{bool_op.rs => bool_ops.rs} | 0 helix-db/src/helixc/generator/mod.rs | 4 +- ...ing_generation.rs => object_remappings.rs} | 0 helix-db/src/helixc/generator/source_steps.rs | 2 +- helix-db/src/helixc/generator/statements.rs | 2 +- .../src/helixc/generator/traversal_steps.rs | 4 +- 9 files changed, 68 insertions(+), 14 deletions(-) rename helix-db/src/helixc/generator/{bool_op.rs => bool_ops.rs} (100%) rename helix-db/src/helixc/generator/{object_remapping_generation.rs => object_remappings.rs} (100%) diff --git a/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs b/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs index 8a45aa35..45b50d34 100644 --- a/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs +++ b/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs @@ -15,7 +15,7 @@ use crate::{ }, }, generator::{ - bool_op::BoExp, + bool_ops::BoExp, queries::Query as GeneratedQuery, source_steps::{ AddE, AddN, AddV, SearchBM25, SearchVector as GeneratedSearchVector, SourceStep, @@ -424,7 +424,34 @@ pub(crate) fn infer_expr_type<'a>( E301, value.as_str() ); - }; + } else { + let variable_type = scope.get(value.as_str()).unwrap(); + if variable_type + != &Type::from( + field_set + .get(field_name.as_str()) + .unwrap() + .field_type + .clone(), + ) + { + generate_error!( + ctx, + original_query, + loc.clone(), + E205, + value.as_str(), + &variable_type.to_string(), + &field_set + .get(field_name.as_str()) + .unwrap() + .field_type + .to_string(), + "edge", + ty.as_str() + ); + } + } } ValueType::Literal { value, loc } => { // check against type @@ -619,7 +646,34 @@ pub(crate) fn infer_expr_type<'a>( E301, value.as_str() ); - }; + } else { + let variable_type = scope.get(value.as_str()).unwrap(); + if variable_type + != &Type::from( + field_set + .get(field_name.as_str()) + .unwrap() + .field_type + .clone(), + ) + { + generate_error!( + ctx, + original_query, + loc.clone(), + E205, + value.as_str(), + &variable_type.to_string(), + &field_set + .get(field_name.as_str()) + .unwrap() + .field_type + .to_string(), + "vector", + ty.as_str() + ); + } + } } ValueType::Literal { value, loc } => { // check against type diff --git a/helix-db/src/helixc/analyzer/methods/object_validation.rs b/helix-db/src/helixc/analyzer/methods/object_validation.rs index 831bc0d6..a8e9d01b 100644 --- a/helix-db/src/helixc/analyzer/methods/object_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/object_validation.rs @@ -1,7 +1,7 @@ //! Semantic analyzer for Helix‑QL. use crate::helixc::analyzer::error_codes::ErrorCode; use crate::helixc::analyzer::utils::{FieldLookup, DEFAULT_VAR_NAME}; -use crate::helixc::generator::object_remapping_generation::SingleFieldTraversalRemapping; +use crate::helixc::generator::object_remappings::SingleFieldTraversalRemapping; use crate::{ generate_error, helixc::{ @@ -16,7 +16,7 @@ use crate::{ }, }, generator::{ - object_remapping_generation::{ + object_remappings::{ ExistsRemapping, IdentifierRemapping, ObjectRemapping, Remapping, RemappingType, TraversalRemapping, ValueRemapping, }, diff --git a/helix-db/src/helixc/analyzer/methods/traversal_validation.rs b/helix-db/src/helixc/analyzer/methods/traversal_validation.rs index 6fb0bcc2..d4bb8aee 100644 --- a/helix-db/src/helixc/analyzer/methods/traversal_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/traversal_validation.rs @@ -1,6 +1,6 @@ use crate::helixc::analyzer::error_codes::*; use crate::helixc::analyzer::utils::DEFAULT_VAR_NAME; -use crate::helixc::generator::bool_op::{Contains, IsIn}; +use crate::helixc::generator::bool_ops::{Contains, IsIn}; use crate::helixc::generator::source_steps::SearchVector; use crate::helixc::generator::utils::{EmbedData, VecData}; use crate::{ @@ -20,8 +20,8 @@ use crate::{ }, }, generator::{ - bool_op::{BoExp, BoolOp, Eq, Gt, Gte, Lt, Lte, Neq}, - object_remapping_generation::{ExcludeField, Remapping, RemappingType}, + bool_ops::{BoExp, BoolOp, Eq, Gt, Gte, Lt, Lte, Neq}, + object_remappings::{ExcludeField, Remapping, RemappingType}, queries::Query as GeneratedQuery, source_steps::{EFromID, EFromType, NFromID, NFromIndex, NFromType, SourceStep}, statements::Statement as GeneratedStatement, diff --git a/helix-db/src/helixc/generator/bool_op.rs b/helix-db/src/helixc/generator/bool_ops.rs similarity index 100% rename from helix-db/src/helixc/generator/bool_op.rs rename to helix-db/src/helixc/generator/bool_ops.rs diff --git a/helix-db/src/helixc/generator/mod.rs b/helix-db/src/helixc/generator/mod.rs index 35e82013..06256876 100644 --- a/helix-db/src/helixc/generator/mod.rs +++ b/helix-db/src/helixc/generator/mod.rs @@ -17,9 +17,9 @@ use crate::{ use core::fmt; use std::fmt::Display; -pub mod bool_op; +pub mod bool_ops; pub mod migrations; -pub mod object_remapping_generation; +pub mod object_remappings; pub mod queries; pub mod return_values; pub mod schemas; diff --git a/helix-db/src/helixc/generator/object_remapping_generation.rs b/helix-db/src/helixc/generator/object_remappings.rs similarity index 100% rename from helix-db/src/helixc/generator/object_remapping_generation.rs rename to helix-db/src/helixc/generator/object_remappings.rs diff --git a/helix-db/src/helixc/generator/source_steps.rs b/helix-db/src/helixc/generator/source_steps.rs index f3efadec..3d4f981c 100644 --- a/helix-db/src/helixc/generator/source_steps.rs +++ b/helix-db/src/helixc/generator/source_steps.rs @@ -4,7 +4,7 @@ use std::fmt::Display; use crate::helixc::generator::utils::{write_properties, write_secondary_indices, VecData}; use super::{ - bool_op::BoExp, + bool_ops::BoExp, utils::{GenRef, GeneratedValue}, }; diff --git a/helix-db/src/helixc/generator/statements.rs b/helix-db/src/helixc/generator/statements.rs index eb4ab8a3..89fd88ee 100644 --- a/helix-db/src/helixc/generator/statements.rs +++ b/helix-db/src/helixc/generator/statements.rs @@ -1,7 +1,7 @@ use core::fmt; use std::fmt::Display; -use crate::helixc::generator::{bool_op::BoExp, traversal_steps::Traversal, utils::GenRef}; +use crate::helixc::generator::{bool_ops::BoExp, traversal_steps::Traversal, utils::GenRef}; diff --git a/helix-db/src/helixc/generator/traversal_steps.rs b/helix-db/src/helixc/generator/traversal_steps.rs index cc3a3242..9513b855 100644 --- a/helix-db/src/helixc/generator/traversal_steps.rs +++ b/helix-db/src/helixc/generator/traversal_steps.rs @@ -1,8 +1,8 @@ use crate::helixc::generator::utils::{VecData, write_properties}; use super::{ - bool_op::{BoExp, BoolOp}, - object_remapping_generation::Remapping, + bool_ops::{BoExp, BoolOp}, + object_remappings::Remapping, source_steps::SourceStep, utils::{GenRef, GeneratedValue, Order, Separator}, }; From 73bab4a9ff14bf03dbcea37ed3a4d5f47ccbb1f1 Mon Sep 17 00:00:00 2001 From: xav-db Date: Sat, 6 Sep 2025 09:56:07 +0100 Subject: [PATCH 14/18] fixing clippy --- helix-db/src/protocol/value.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/helix-db/src/protocol/value.rs b/helix-db/src/protocol/value.rs index d24349dd..2f22e407 100644 --- a/helix-db/src/protocol/value.rs +++ b/helix-db/src/protocol/value.rs @@ -64,7 +64,7 @@ impl Value { .join(" "), Value::Object(obj) => obj .iter() - .map(|(k, v)| format!("{} {}", k, v.to_string())) + .map(|(k, v)| format!("{k} {v}")) .collect::>() .join(" "), _ => panic!("Not primitive"), From 15957c75245e6e7831e060ef110844837845618a Mon Sep 17 00:00:00 2001 From: xav-db Date: Sat, 6 Sep 2025 10:36:26 +0100 Subject: [PATCH 15/18] fixing bm25 and clippy --- helix-db/src/helix_engine/bm25/bm25.rs | 2 +- .../src/helix_engine/tests/traversal_tests/update_tests.rs | 2 +- helix-db/src/helixc/analyzer/methods/traversal_validation.rs | 2 +- helix-db/src/protocol/value.rs | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/helix-db/src/helix_engine/bm25/bm25.rs b/helix-db/src/helix_engine/bm25/bm25.rs index 4b17d754..06ea3e45 100644 --- a/helix-db/src/helix_engine/bm25/bm25.rs +++ b/helix-db/src/helix_engine/bm25/bm25.rs @@ -431,7 +431,7 @@ impl BM25Flatten for HashMap { .fold(String::with_capacity(self.len() * 4), |mut s, (k, v)| { s.push_str(k); s.push(' '); - s.push_str(&v.to_string()); + s.push_str(&v.inner_stringify()); s.push(' '); s }) diff --git a/helix-db/src/helix_engine/tests/traversal_tests/update_tests.rs b/helix-db/src/helix_engine/tests/traversal_tests/update_tests.rs index 19d524b7..12b8e5a3 100644 --- a/helix-db/src/helix_engine/tests/traversal_tests/update_tests.rs +++ b/helix-db/src/helix_engine/tests/traversal_tests/update_tests.rs @@ -62,7 +62,7 @@ fn test_update_node() { .check_property("name") .unwrap() .into_owned() - .to_string(), + .inner_stringify(), "john" ); } diff --git a/helix-db/src/helixc/analyzer/methods/traversal_validation.rs b/helix-db/src/helixc/analyzer/methods/traversal_validation.rs index d4bb8aee..f0a0b992 100644 --- a/helix-db/src/helixc/analyzer/methods/traversal_validation.rs +++ b/helix-db/src/helixc/analyzer/methods/traversal_validation.rs @@ -98,7 +98,7 @@ pub(crate) fn validate_traversal<'a>( original_query, loc.clone(), E205, - &value.stringify(), + &value.inner_stringify(), &value.to_string(), &field.field_type.to_string(), "node", diff --git a/helix-db/src/protocol/value.rs b/helix-db/src/protocol/value.rs index 2f22e407..17b66128 100644 --- a/helix-db/src/protocol/value.rs +++ b/helix-db/src/protocol/value.rs @@ -40,7 +40,7 @@ pub enum Value { } impl Value { - pub fn stringify(&self) -> String { + pub fn inner_stringify(&self) -> String { match self { Value::String(s) => s.to_string(), Value::F32(f) => f.to_string(), @@ -59,7 +59,7 @@ impl Value { Value::Id(id) => id.stringify(), Value::Array(arr) => arr .iter() - .map(|v| v.to_string()) + .map(|v| v.inner_stringify()) .collect::>() .join(" "), Value::Object(obj) => obj From 4093e1fd8965d2ae7d9f7fa83c81f4c6197321e6 Mon Sep 17 00:00:00 2001 From: xav-db Date: Sat, 6 Sep 2025 13:06:23 +0100 Subject: [PATCH 16/18] further clear up and refactor --- helix-db/src/helix_engine/types.rs | 2 +- .../analyzer/methods/infer_expr_type.rs | 4 -- .../parser/creation_step_parse_methods.rs | 2 +- .../helixc/parser/expression_parse_methods.rs | 2 +- .../helixc/parser/graph_step_parse_methods.rs | 2 +- helix-db/src/helixc/parser/mod.rs | 52 +++++++++++++++++-- .../src/helixc/parser/object_parse_methods.rs | 2 +- helix-db/src/helixc/parser/parser_methods.rs | 52 ------------------- .../src/helixc/parser/query_parse_methods.rs | 2 +- .../parser/return_value_parse_methods.rs | 2 +- .../src/helixc/parser/schema_parse_methods.rs | 2 +- .../helixc/parser/traversal_parse_methods.rs | 2 +- helix-db/src/helixc/parser/types.rs | 3 -- helix-db/src/helixc/parser/utils.rs | 2 +- 14 files changed, 59 insertions(+), 72 deletions(-) delete mode 100644 helix-db/src/helixc/parser/parser_methods.rs diff --git a/helix-db/src/helix_engine/types.rs b/helix-db/src/helix_engine/types.rs index bdba418a..be21efc4 100644 --- a/helix-db/src/helix_engine/types.rs +++ b/helix-db/src/helix_engine/types.rs @@ -1,4 +1,4 @@ -use crate::{helix_gateway::router::router::IoContFn, helixc::parser::parser_methods::ParserError}; +use crate::{helix_gateway::router::router::IoContFn, helixc::parser::ParserError}; use core::fmt; use heed3::Error as HeedError; use sonic_rs::Error as SonicError; diff --git a/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs b/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs index 45b50d34..ee6ea33b 100644 --- a/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs +++ b/helix-db/src/helixc/analyzer/methods/infer_expr_type.rs @@ -1276,9 +1276,5 @@ pub(crate) fn infer_expr_type<'a>( })), ) } - _ => { - println!("Unknown expression: {expr:?}"); - todo!() - } } } diff --git a/helix-db/src/helixc/parser/creation_step_parse_methods.rs b/helix-db/src/helixc/parser/creation_step_parse_methods.rs index 87d898a4..b02173f4 100644 --- a/helix-db/src/helixc/parser/creation_step_parse_methods.rs +++ b/helix-db/src/helixc/parser/creation_step_parse_methods.rs @@ -1,7 +1,7 @@ use crate::helixc::parser::{ HelixParser, Rule, location::HasLoc, - parser_methods::ParserError, + ParserError, types::{AddEdge, AddNode, AddVector, Embed, EvaluatesToString, VectorData}, }; use pest::iterators::Pair; diff --git a/helix-db/src/helixc/parser/expression_parse_methods.rs b/helix-db/src/helixc/parser/expression_parse_methods.rs index cc18a736..c5cded0a 100644 --- a/helix-db/src/helixc/parser/expression_parse_methods.rs +++ b/helix-db/src/helixc/parser/expression_parse_methods.rs @@ -2,7 +2,7 @@ use crate::{ helixc::parser::{ HelixParser, Rule, location::{HasLoc, Loc}, - parser_methods::ParserError, + ParserError, types::{ Assignment, BM25Search, Embed, EvaluatesToNumber, EvaluatesToNumberType, EvaluatesToString, ExistsExpression, Expression, ExpressionType, ForLoop, ForLoopVars, diff --git a/helix-db/src/helixc/parser/graph_step_parse_methods.rs b/helix-db/src/helixc/parser/graph_step_parse_methods.rs index e4e60233..7478649c 100644 --- a/helix-db/src/helixc/parser/graph_step_parse_methods.rs +++ b/helix-db/src/helixc/parser/graph_step_parse_methods.rs @@ -1,7 +1,7 @@ use crate::helixc::parser::{ HelixParser, Rule, location::HasLoc, - parser_methods::ParserError, + ParserError, types::{ BooleanOp, BooleanOpType, Closure, Exclude, Expression, FieldAddition, FieldValue, FieldValueType, Object, OrderBy, OrderByType, Update, diff --git a/helix-db/src/helixc/parser/mod.rs b/helix-db/src/helixc/parser/mod.rs index 17414e63..ed3268b2 100644 --- a/helix-db/src/helixc/parser/mod.rs +++ b/helix-db/src/helixc/parser/mod.rs @@ -7,12 +7,11 @@ use crate::helixc::parser::types::{Content, HxFile, Schema, Source}; use location::HasLoc; -use parser_methods::ParserError; use pest::Parser as PestParser; use pest_derive::Parser; use std::{ collections::{HashMap, HashSet}, - fmt::Debug, + fmt::{Debug, Display, Formatter}, io::Write, }; @@ -21,7 +20,6 @@ pub mod expression_parse_methods; pub mod graph_step_parse_methods; pub mod location; pub mod object_parse_methods; -pub mod parser_methods; pub mod query_parse_methods; pub mod return_value_parse_methods; pub mod schema_parse_methods; @@ -198,3 +196,51 @@ pub fn write_to_temp_file(content: Vec<&str>) -> Content { source: Source::default(), } } + +pub enum ParserError { + ParseError(String), + LexError(String), + ParamDoesNotMatchSchema(String), +} + +impl Display for ParserError { + fn fmt(&self, f: &mut Formatter) -> std::fmt::Result { + match self { + ParserError::ParseError(e) => write!(f, "Parse error: {e}"), + ParserError::LexError(e) => write!(f, "Lex error: {e}"), + ParserError::ParamDoesNotMatchSchema(p) => { + write!(f, "Parameter with name: {p} does not exist in the schema") + } + } + } +} + +impl From> for ParserError { + fn from(e: pest::error::Error) -> Self { + ParserError::ParseError(e.to_string()) + } +} + +impl From for ParserError { + fn from(e: String) -> Self { + ParserError::LexError(e) + } +} + +impl From<&'static str> for ParserError { + fn from(e: &'static str) -> Self { + ParserError::LexError(e.to_string()) + } +} + +impl std::fmt::Debug for ParserError { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + match self { + ParserError::ParseError(e) => write!(f, "Parse error: {e}"), + ParserError::LexError(e) => write!(f, "Lex error: {e}"), + ParserError::ParamDoesNotMatchSchema(p) => { + write!(f, "Parameter with name: {p} does not exist in the schema") + } + } + } +} diff --git a/helix-db/src/helixc/parser/object_parse_methods.rs b/helix-db/src/helixc/parser/object_parse_methods.rs index af89472e..5f107261 100644 --- a/helix-db/src/helixc/parser/object_parse_methods.rs +++ b/helix-db/src/helixc/parser/object_parse_methods.rs @@ -1,6 +1,6 @@ use crate::{ helixc::parser::{ - location::{HasLoc, Loc}, parser_methods::ParserError, types::{FieldAddition, FieldValue, FieldValueType, ValueType}, HelixParser, Rule + location::{HasLoc, Loc}, types::{FieldAddition, FieldValue, FieldValueType, ValueType}, HelixParser, Rule, ParserError }, protocol::value::Value, }; diff --git a/helix-db/src/helixc/parser/parser_methods.rs b/helix-db/src/helixc/parser/parser_methods.rs deleted file mode 100644 index 144ead18..00000000 --- a/helix-db/src/helixc/parser/parser_methods.rs +++ /dev/null @@ -1,52 +0,0 @@ -use crate::helixc::parser::Rule; -use core::fmt; - -pub trait Parser { - fn parse(&self, input: &str) -> Result<(), String>; -} - - -pub enum ParserError { - ParseError(String), - LexError(String), - ParamDoesNotMatchSchema(String) -} - -impl fmt::Display for ParserError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self { - ParserError::ParseError(e) => write!(f, "Parse error: {e}"), - ParserError::LexError(e) => write!(f, "Lex error: {e}"), - ParserError::ParamDoesNotMatchSchema(p) => write!(f, "Parameter with name: {p} does not exist in the schema"), - } - } -} - -impl From> for ParserError { - fn from(e: pest::error::Error) -> Self { - ParserError::ParseError(e.to_string()) - } -} - -impl From for ParserError { - fn from(e: String) -> Self { - ParserError::LexError(e) - } -} - -impl From<&'static str> for ParserError { - fn from(e: &'static str) -> Self { - ParserError::LexError(e.to_string()) - } -} - - -impl std::fmt::Debug for ParserError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self { - ParserError::ParseError(e) => write!(f, "Parse error: {e}"), - ParserError::LexError(e) => write!(f, "Lex error: {e}"), - ParserError::ParamDoesNotMatchSchema(p) => write!(f, "Parameter with name: {p} does not exist in the schema"), - } - } -} \ No newline at end of file diff --git a/helix-db/src/helixc/parser/query_parse_methods.rs b/helix-db/src/helixc/parser/query_parse_methods.rs index 3c2df550..a0a80836 100644 --- a/helix-db/src/helixc/parser/query_parse_methods.rs +++ b/helix-db/src/helixc/parser/query_parse_methods.rs @@ -1,7 +1,7 @@ use crate::helixc::parser::{ HelixParser, Rule, location::HasLoc, - parser_methods::ParserError, + ParserError, types::{BuiltInMacro, Parameter, Query, Statement, StatementType}, }; use pest::iterators::Pair; diff --git a/helix-db/src/helixc/parser/return_value_parse_methods.rs b/helix-db/src/helixc/parser/return_value_parse_methods.rs index 8a9dcf7f..45d9cd81 100644 --- a/helix-db/src/helixc/parser/return_value_parse_methods.rs +++ b/helix-db/src/helixc/parser/return_value_parse_methods.rs @@ -3,7 +3,7 @@ use std::collections::HashMap; use crate::helixc::parser::{ HelixParser, Rule, location::HasLoc, - parser_methods::ParserError, + ParserError, types::{Expression, ExpressionType, ReturnType}, }; use pest::iterators::Pair; diff --git a/helix-db/src/helixc/parser/schema_parse_methods.rs b/helix-db/src/helixc/parser/schema_parse_methods.rs index 6fb33a67..fbe1603b 100644 --- a/helix-db/src/helixc/parser/schema_parse_methods.rs +++ b/helix-db/src/helixc/parser/schema_parse_methods.rs @@ -3,7 +3,7 @@ use std::collections::HashMap; use crate::helixc::parser::{ HelixParser, Rule, location::HasLoc, - parser_methods::ParserError, + ParserError, types::{ DefaultValue, EdgeSchema, Field, FieldPrefix, FieldType, Migration, MigrationItem, MigrationItemMapping, MigrationPropertyMapping, NodeSchema, Source, ValueCast, diff --git a/helix-db/src/helixc/parser/traversal_parse_methods.rs b/helix-db/src/helixc/parser/traversal_parse_methods.rs index 000310a3..cecb16a3 100644 --- a/helix-db/src/helixc/parser/traversal_parse_methods.rs +++ b/helix-db/src/helixc/parser/traversal_parse_methods.rs @@ -2,7 +2,7 @@ use crate::{ helixc::parser::{ HelixParser, Rule, location::HasLoc, - parser_methods::ParserError, + ParserError, types::{ FieldAddition, FieldValue, FieldValueType, GraphStep, GraphStepType, IdType, Object, ShortestPath, StartNode, Step, StepType, Traversal, ValueType, diff --git a/helix-db/src/helixc/parser/types.rs b/helix-db/src/helixc/parser/types.rs index 649a7f66..26a1f8a8 100644 --- a/helix-db/src/helixc/parser/types.rs +++ b/helix-db/src/helixc/parser/types.rs @@ -476,7 +476,6 @@ pub enum ExpressionType { BooleanLiteral(bool), ArrayLiteral(Vec), Exists(ExistsExpression), - BatchAddVector(BatchAddVector), AddVector(AddVector), AddNode(AddNode), AddEdge(AddEdge), @@ -507,7 +506,6 @@ impl Debug for ExpressionType { ExpressionType::BooleanLiteral(b) => write!(f, "{b}"), ExpressionType::ArrayLiteral(a) => write!(f, "Array({a:?})"), ExpressionType::Exists(e) => write!(f, "Exists({e:?})"), - ExpressionType::BatchAddVector(bav) => write!(f, "BatchAddVector({bav:?})"), ExpressionType::AddVector(av) => write!(f, "AddVector({av:?})"), ExpressionType::AddNode(an) => write!(f, "AddNode({an:?})"), ExpressionType::AddEdge(ae) => write!(f, "AddEdge({ae:?})"), @@ -531,7 +529,6 @@ impl Display for ExpressionType { ExpressionType::BooleanLiteral(b) => write!(f, "{b}"), ExpressionType::ArrayLiteral(a) => write!(f, "Array({a:?})"), ExpressionType::Exists(e) => write!(f, "Exists({e:?})"), - ExpressionType::BatchAddVector(bav) => write!(f, "BatchAddVector({bav:?})"), ExpressionType::AddVector(av) => write!(f, "AddVector({av:?})"), ExpressionType::AddNode(an) => write!(f, "AddNode({an:?})"), ExpressionType::AddEdge(ae) => write!(f, "AddEdge({ae:?})"), diff --git a/helix-db/src/helixc/parser/utils.rs b/helix-db/src/helixc/parser/utils.rs index 33714682..473529f7 100644 --- a/helix-db/src/helixc/parser/utils.rs +++ b/helix-db/src/helixc/parser/utils.rs @@ -1,7 +1,7 @@ use crate::helixc::parser::{ HelixParser, Rule, location::HasLoc, - parser_methods::ParserError, + ParserError, types::{EdgeConnection, Expression, IdType}, }; use pest::iterators::Pair; From 524afe76b2276ec0fb5a27b4f382d8bc17e64fd3 Mon Sep 17 00:00:00 2001 From: xav-db Date: Sat, 6 Sep 2025 13:50:30 +0100 Subject: [PATCH 17/18] moving graph step stuff from traversal to graph step and adding module readme --- helix-db/src/helixc/parser/README.md | 44 ++++ .../helixc/parser/graph_step_parse_methods.rs | 204 ++++++++++++++++-- .../helixc/parser/traversal_parse_methods.rs | 187 +--------------- 3 files changed, 236 insertions(+), 199 deletions(-) create mode 100644 helix-db/src/helixc/parser/README.md diff --git a/helix-db/src/helixc/parser/README.md b/helix-db/src/helixc/parser/README.md new file mode 100644 index 00000000..797ff9a0 --- /dev/null +++ b/helix-db/src/helixc/parser/README.md @@ -0,0 +1,44 @@ +# Parser Module + +## Overview +The parser module transforms HelixQL (HQL) source code into an Abstract Syntax Tree (AST) using the Pest parser generator framework. + +## Structure + +### Core Components +- **`mod.rs`** - Main parser entry point, orchestrates parsing of schemas, queries, and migrations +- **`grammar.pest`** - Pest grammar defining HQL syntax rules +- **`types.rs`** - AST node definitions and data structures +- **`location.rs`** - Location tracking for error reporting + +### Parse Methods (by domain) +- **`schema_parse_methods.rs`** - Parses node, edge, and vector schema definitions +- **`query_parse_methods.rs`** - Parses query definitions with parameters and statements +- **`migration_parse_methods.rs`** - Parses schema migration definitions +- **`traversal_parse_methods.rs`** - Parses traversal (anonymous/id/starting node, vector or edge etc) +- **`graph_step_parse_methods.rs`** - Parses graph step operations (object remapping/order by/where/range etc) +- **`creation_step_parse_methods.rs`** - Parses node/edge/vector creation operations +- **`expression_parse_methods.rs`** - Parses expressions e.g. assignment, for loop, boolean expressions etc +- **`object_parse_methods.rs`** - Parses object fields for remappings/parameters/item creations etc +- **`return_value_parse_methods.rs`** - Parses return statements and remappings + +## Parsing Flow + +1. **Input**: HQL files containing schemas, queries, and migrations +2. **Lexing**: Pest tokenizes input according to `grammar.pest` rules +3. **AST Construction**: + - Schemas parsed first (establishing type definitions) + - Migrations parsed second (for schema evolution) + - Queries parsed last (can reference schema types) +4. **Output**: `Source` struct containing parsed schemas, migrations, and queries + +## Key Types + +- `Source` - Top-level container for all parsed content +- `Schema` - Contains node, edge, and vector type definitions +- `Query` - Parsed query with parameters, statements, and return values +- `Migration` - Schema version transition definitions + +## Error Handling +- `ParserError` enum handles parse errors, lex errors, and schema validation +- Location tracking enables precise error reporting with file/line/column info diff --git a/helix-db/src/helixc/parser/graph_step_parse_methods.rs b/helix-db/src/helixc/parser/graph_step_parse_methods.rs index 7478649c..1a4e71a8 100644 --- a/helix-db/src/helixc/parser/graph_step_parse_methods.rs +++ b/helix-db/src/helixc/parser/graph_step_parse_methods.rs @@ -1,11 +1,7 @@ use crate::helixc::parser::{ - HelixParser, Rule, - location::HasLoc, - ParserError, - types::{ - BooleanOp, BooleanOpType, Closure, Exclude, Expression, FieldAddition, FieldValue, - FieldValueType, Object, OrderBy, OrderByType, Update, - }, + location::HasLoc, types::{ + BooleanOp, BooleanOpType, Closure, Exclude, Expression, FieldAddition, FieldValue, FieldValueType, GraphStep, GraphStepType, IdType, Object, OrderBy, OrderByType, ShortestPath, Step, StepType, Update + }, HelixParser, ParserError, Rule }; use pest::iterators::Pair; @@ -16,7 +12,7 @@ impl HelixParser { /// ```rs /// ::ORDER(_::{age}) /// ``` - pub fn parse_order_by(&self, pair: Pair) -> Result { + pub(super) fn parse_order_by(&self, pair: Pair) -> Result { let mut inner = pair.clone().into_inner(); let order_by_type = match inner.next().unwrap().into_inner().next().unwrap().as_rule() { Rule::asc => OrderByType::Asc, @@ -37,7 +33,7 @@ impl HelixParser { /// ```rs /// ::RANGE(1, 10) /// ``` - pub fn parse_range(&self, pair: Pair) -> Result<(Expression, Expression), ParserError> { + pub(super) fn parse_range(&self, pair: Pair) -> Result<(Expression, Expression), ParserError> { let mut inner = pair.into_inner().next().unwrap().into_inner(); let start = self.parse_expression(inner.next().unwrap())?; let end = self.parse_expression(inner.next().unwrap())?; @@ -51,7 +47,7 @@ impl HelixParser { /// ```rs /// ::GT(1) /// ``` - pub fn parse_bool_operation(&self, pair: Pair) -> Result { + pub(super) fn parse_bool_operation(&self, pair: Pair) -> Result { let inner = pair.clone().into_inner().next().unwrap(); let expr = match inner.as_rule() { Rule::GT => BooleanOp { @@ -111,7 +107,7 @@ impl HelixParser { /// ```rs /// ::UPDATE({age: 1}) /// ``` - pub fn parse_update(&self, pair: Pair) -> Result { + pub(super) fn parse_update(&self, pair: Pair) -> Result { let fields = self.parse_object_fields(pair.clone())?; Ok(Update { fields, @@ -125,7 +121,7 @@ impl HelixParser { /// ```rs /// ::{username: name} /// ``` - pub fn parse_object_step(&self, pair: Pair) -> Result { + pub(super) fn parse_object_step(&self, pair: Pair) -> Result { let mut fields = Vec::new(); let mut should_spread = false; for p in pair.clone().into_inner() { @@ -183,7 +179,7 @@ impl HelixParser { /// ```rs /// ::|user|{user_age: user::{age}} /// ``` - pub fn parse_closure(&self, pair: Pair) -> Result { + pub(super) fn parse_closure(&self, pair: Pair) -> Result { let mut pairs = pair.clone().into_inner(); let identifier = pairs.next().unwrap().as_str().to_string(); let object = self.parse_object_step(pairs.next().unwrap())?; @@ -200,7 +196,7 @@ impl HelixParser { /// ```rs /// ::!{age, name} /// ``` - pub fn parse_exclude(&self, pair: Pair) -> Result { + pub(super) fn parse_exclude(&self, pair: Pair) -> Result { let mut fields = Vec::new(); for p in pair.clone().into_inner() { fields.push((p.loc(), p.as_str().to_string())); @@ -210,4 +206,184 @@ impl HelixParser { fields, }) } + + + pub(super) fn parse_step(&self, pair: Pair) -> Result { + let inner = pair.clone().into_inner().next().unwrap(); + match inner.as_rule() { + Rule::graph_step => Ok(Step { + loc: inner.loc(), + step: StepType::Node(self.parse_graph_step(inner)), + }), + Rule::object_step => Ok(Step { + loc: inner.loc(), + step: StepType::Object(self.parse_object_step(inner)?), + }), + Rule::closure_step => Ok(Step { + loc: inner.loc(), + step: StepType::Closure(self.parse_closure(inner)?), + }), + Rule::where_step => Ok(Step { + loc: inner.loc(), + step: StepType::Where(Box::new(self.parse_expression(inner)?)), + }), + Rule::range_step => Ok(Step { + loc: inner.loc(), + step: StepType::Range(self.parse_range(pair)?), + }), + + Rule::bool_operations => Ok(Step { + loc: inner.loc(), + step: StepType::BooleanOperation(self.parse_bool_operation(inner)?), + }), + Rule::count => Ok(Step { + loc: inner.loc(), + step: StepType::Count, + }), + Rule::ID => Ok(Step { + loc: inner.loc(), + step: StepType::Object(Object { + fields: vec![FieldAddition { + key: "id".to_string(), + value: FieldValue { + loc: pair.loc(), + value: FieldValueType::Identifier("id".to_string()), + }, + loc: pair.loc(), + }], + should_spread: false, + loc: pair.loc(), + }), + }), + Rule::update => Ok(Step { + loc: inner.loc(), + step: StepType::Update(self.parse_update(inner)?), + }), + Rule::exclude_field => Ok(Step { + loc: inner.loc(), + step: StepType::Exclude(self.parse_exclude(inner)?), + }), + Rule::AddE => Ok(Step { + loc: inner.loc(), + step: StepType::AddEdge(self.parse_add_edge(inner, true)?), + }), + Rule::order_by => Ok(Step { + loc: inner.loc(), + step: StepType::OrderBy(self.parse_order_by(inner)?), + }), + _ => Err(ParserError::from(format!( + "Unexpected step type: {:?}", + inner.as_rule() + ))), + } + } + + pub(super) fn parse_graph_step(&self, pair: Pair) -> GraphStep { + let types = |pair: &Pair| { + pair.clone() + .into_inner() + .next() + .map(|p| p.as_str().to_string()) + .ok_or_else(|| ParserError::from("Expected type".to_string())) + .unwrap() + }; + let pair = pair.into_inner().next().unwrap(); + match pair.as_rule() { + Rule::out_e => { + let types = types(&pair); + GraphStep { + loc: pair.loc(), + step: GraphStepType::OutE(types), + } + } + Rule::in_e => { + let types = types(&pair); + GraphStep { + loc: pair.loc(), + step: GraphStepType::InE(types), + } + } + Rule::from_n => GraphStep { + loc: pair.loc(), + step: GraphStepType::FromN, + }, + Rule::to_n => GraphStep { + loc: pair.loc(), + step: GraphStepType::ToN, + }, + Rule::from_v => GraphStep { + loc: pair.loc(), + step: GraphStepType::FromV, + }, + Rule::to_v => GraphStep { + loc: pair.loc(), + step: GraphStepType::ToV, + }, + Rule::out => { + let types = types(&pair); + GraphStep { + loc: pair.loc(), + step: GraphStepType::Out(types), + } + } + Rule::in_nodes => { + let types = types(&pair); + GraphStep { + loc: pair.loc(), + step: GraphStepType::In(types), + } + } + Rule::shortest_path => { + let (type_arg, from, to) = pair.clone().into_inner().fold( + (None, None, None), + |(type_arg, from, to), p| match p.as_rule() { + Rule::type_args => ( + Some(p.into_inner().next().unwrap().as_str().to_string()), + from, + to, + ), + Rule::to_from => match p.into_inner().next() { + Some(p) => match p.as_rule() { + Rule::to => ( + type_arg, + from, + Some(p.into_inner().next().unwrap().as_str().to_string()), + ), + Rule::from => ( + type_arg, + Some(p.into_inner().next().unwrap().as_str().to_string()), + to, + ), + _ => unreachable!(), + }, + None => (type_arg, from, to), + }, + _ => (type_arg, from, to), + }, + ); + GraphStep { + loc: pair.loc(), + step: GraphStepType::ShortestPath(ShortestPath { + loc: pair.loc(), + from: from.map(|id| IdType::Identifier { + value: id, + loc: pair.loc(), + }), + to: to.map(|id| IdType::Identifier { + value: id, + loc: pair.loc(), + }), + type_arg, + }), + } + } + Rule::search_vector => GraphStep { + loc: pair.loc(), + step: GraphStepType::SearchVector(self.parse_search_vector(pair).unwrap()), + }, + _ => { + unreachable!() + } + } + } } diff --git a/helix-db/src/helixc/parser/traversal_parse_methods.rs b/helix-db/src/helixc/parser/traversal_parse_methods.rs index cecb16a3..b4c6d70b 100644 --- a/helix-db/src/helixc/parser/traversal_parse_methods.rs +++ b/helix-db/src/helixc/parser/traversal_parse_methods.rs @@ -1,12 +1,8 @@ use crate::{ helixc::parser::{ - HelixParser, Rule, + HelixParser, ParserError, Rule, location::HasLoc, - ParserError, - types::{ - FieldAddition, FieldValue, FieldValueType, GraphStep, GraphStepType, IdType, Object, - ShortestPath, StartNode, Step, StepType, Traversal, ValueType, - }, + types::{IdType, StartNode, Traversal, ValueType}, }, protocol::value::Value, }; @@ -185,183 +181,4 @@ impl HelixParser { _ => Ok(StartNode::Anonymous), } } - - pub(super) fn parse_step(&self, pair: Pair) -> Result { - let inner = pair.clone().into_inner().next().unwrap(); - match inner.as_rule() { - Rule::graph_step => Ok(Step { - loc: inner.loc(), - step: StepType::Node(self.parse_graph_step(inner)), - }), - Rule::object_step => Ok(Step { - loc: inner.loc(), - step: StepType::Object(self.parse_object_step(inner)?), - }), - Rule::closure_step => Ok(Step { - loc: inner.loc(), - step: StepType::Closure(self.parse_closure(inner)?), - }), - Rule::where_step => Ok(Step { - loc: inner.loc(), - step: StepType::Where(Box::new(self.parse_expression(inner)?)), - }), - Rule::range_step => Ok(Step { - loc: inner.loc(), - step: StepType::Range(self.parse_range(pair)?), - }), - - Rule::bool_operations => Ok(Step { - loc: inner.loc(), - step: StepType::BooleanOperation(self.parse_bool_operation(inner)?), - }), - Rule::count => Ok(Step { - loc: inner.loc(), - step: StepType::Count, - }), - Rule::ID => Ok(Step { - loc: inner.loc(), - step: StepType::Object(Object { - fields: vec![FieldAddition { - key: "id".to_string(), - value: FieldValue { - loc: pair.loc(), - value: FieldValueType::Identifier("id".to_string()), - }, - loc: pair.loc(), - }], - should_spread: false, - loc: pair.loc(), - }), - }), - Rule::update => Ok(Step { - loc: inner.loc(), - step: StepType::Update(self.parse_update(inner)?), - }), - Rule::exclude_field => Ok(Step { - loc: inner.loc(), - step: StepType::Exclude(self.parse_exclude(inner)?), - }), - Rule::AddE => Ok(Step { - loc: inner.loc(), - step: StepType::AddEdge(self.parse_add_edge(inner, true)?), - }), - Rule::order_by => Ok(Step { - loc: inner.loc(), - step: StepType::OrderBy(self.parse_order_by(inner)?), - }), - _ => Err(ParserError::from(format!( - "Unexpected step type: {:?}", - inner.as_rule() - ))), - } - } - - pub(super) fn parse_graph_step(&self, pair: Pair) -> GraphStep { - let types = |pair: &Pair| { - pair.clone() - .into_inner() - .next() - .map(|p| p.as_str().to_string()) - .ok_or_else(|| ParserError::from("Expected type".to_string())) - .unwrap() - }; - let pair = pair.into_inner().next().unwrap(); - match pair.as_rule() { - Rule::out_e => { - let types = types(&pair); - GraphStep { - loc: pair.loc(), - step: GraphStepType::OutE(types), - } - } - Rule::in_e => { - let types = types(&pair); - GraphStep { - loc: pair.loc(), - step: GraphStepType::InE(types), - } - } - Rule::from_n => GraphStep { - loc: pair.loc(), - step: GraphStepType::FromN, - }, - Rule::to_n => GraphStep { - loc: pair.loc(), - step: GraphStepType::ToN, - }, - Rule::from_v => GraphStep { - loc: pair.loc(), - step: GraphStepType::FromV, - }, - Rule::to_v => GraphStep { - loc: pair.loc(), - step: GraphStepType::ToV, - }, - Rule::out => { - let types = types(&pair); - GraphStep { - loc: pair.loc(), - step: GraphStepType::Out(types), - } - } - Rule::in_nodes => { - let types = types(&pair); - GraphStep { - loc: pair.loc(), - step: GraphStepType::In(types), - } - } - Rule::shortest_path => { - let (type_arg, from, to) = pair.clone().into_inner().fold( - (None, None, None), - |(type_arg, from, to), p| match p.as_rule() { - Rule::type_args => ( - Some(p.into_inner().next().unwrap().as_str().to_string()), - from, - to, - ), - Rule::to_from => match p.into_inner().next() { - Some(p) => match p.as_rule() { - Rule::to => ( - type_arg, - from, - Some(p.into_inner().next().unwrap().as_str().to_string()), - ), - Rule::from => ( - type_arg, - Some(p.into_inner().next().unwrap().as_str().to_string()), - to, - ), - _ => unreachable!(), - }, - None => (type_arg, from, to), - }, - _ => (type_arg, from, to), - }, - ); - GraphStep { - loc: pair.loc(), - step: GraphStepType::ShortestPath(ShortestPath { - loc: pair.loc(), - from: from.map(|id| IdType::Identifier { - value: id, - loc: pair.loc(), - }), - to: to.map(|id| IdType::Identifier { - value: id, - loc: pair.loc(), - }), - type_arg, - }), - } - } - Rule::search_vector => GraphStep { - loc: pair.loc(), - step: GraphStepType::SearchVector(self.parse_search_vector(pair).unwrap()), - }, - _ => { - unreachable!() - } - } - } } From 96ed12d69bf9d375c4bf85834ab1f99db26d8405 Mon Sep 17 00:00:00 2001 From: xav-db Date: Sat, 6 Sep 2025 14:49:27 +0100 Subject: [PATCH 18/18] adding readmes --- helix-db/src/helixc/analyzer/README.md | 42 +++++++++++++++++++++++-- helix-db/src/helixc/generator/README.md | 35 +++++++++++++++++++++ 2 files changed, 75 insertions(+), 2 deletions(-) create mode 100644 helix-db/src/helixc/generator/README.md diff --git a/helix-db/src/helixc/analyzer/README.md b/helix-db/src/helixc/analyzer/README.md index 2768540a..7592f4fc 100644 --- a/helix-db/src/helixc/analyzer/README.md +++ b/helix-db/src/helixc/analyzer/README.md @@ -1,3 +1,41 @@ -# Interpreter +# Analyzer Module -The Interpreter takes in the AST and \ No newline at end of file +## Overview +The analyzer module performs static analysis and type checking on the HelixQL AST, ensuring queries are grammatically and semantically correct before code generation. + +## Structure + +### Core Components +- **`mod.rs`** - Main analyzer entry point, orchestrates validation passes +- **`types.rs`** - Type system definitions and type inference structures +- **`diagnostic.rs`** - Diagnostic messages and error reporting +- **`error_codes.rs`** - Error code definitions and messages +- **`errors.rs`** - Error handling utilities +- **`fix.rs`** - Auto-fix suggestions for common errors +- **`pretty.rs`** - Pretty printing utilities for diagnostics +- **`utils.rs`** - Helper functions for analysis + +### Validation Methods (in `methods/`) +- **`schema_methods.rs`** - Schema validation and field lookup building +- **`query_validation.rs`** - Query structure and parameter validation +- **`migration_validation.rs`** - Schema migration consistency checks +- **`statement_validation.rs`** - Statement-level validation +- **`traversal_validation.rs`** - Graph traversal operation validation +- **`graph_step_validation.rs`** - Individual graph step validation +- **`object_validation.rs`** - Object literal and remapping validation +- **`infer_expr_type.rs`** - Expression type inference +- **`exclude_validation.rs`** - Field exclusion validation + +## Analysis Flow + +1. **Input**: Parsed AST from the parser module +2. **Schema Validation**: Verifies schema definitions are valid +3. **Migration Validation**: Ensures migrations are consistent across versions +4. **Query Validation**: Type-checks queries against schemas +5. **Output**: Diagnostics (errors/warnings) and validated AST for code generation + + +## Error Handling +- Error codes provide consistent, searchable error identification +- Diagnostics include source location for precise error reporting +- Fix suggestions help users resolve common issues \ No newline at end of file diff --git a/helix-db/src/helixc/generator/README.md b/helix-db/src/helixc/generator/README.md new file mode 100644 index 00000000..987147c6 --- /dev/null +++ b/helix-db/src/helixc/generator/README.md @@ -0,0 +1,35 @@ +# Generator Module + +## Overview +The generator module transforms the validated HelixQL AST into executable Rust code, creating type-safe graph database operations. + +## Structure + +### Core Components +- **`mod.rs`** - Main generator entry point, defines output structure +- **`utils.rs`** - Helper functions and code generation utilities + +### Code Generation Methods (by domain) +- **`schemas.rs`** - Generates Rust structs for nodes, edges, and vectors +- **`queries.rs`** - Generates query functions with proper signatures +- **`migrations.rs`** - Generates migration code for schema evolution +- **`statements.rs`** - Generates statement execution code +- **`traversal_steps.rs`** - Generates graph traversal operations +- **`source_steps.rs`** - Generates source operations (add_n, add_e, n_from_id, n_from_type, etc.) +- **`bool_ops.rs`** - Generates boolean expression evaluators +- **`object_remappings.rs`** - Generates object transformation code +- **`return_values.rs`** - Generates return value processing +- **`tsdisplay.rs`** - TypeScript display utilities + +## Generation Flow + +1. **Input**: Validated AST from the analyzer module +2. **Schema Generation**: Creates Rust structs for all schema types +3. **Query Generation**: Transforms queries into Rust functions +4. **Migration Generation**: Creates migration execution code +5. **Output**: Complete Rust source code ready for compilation + +## Code Generation Patterns +- Uses Rust's `Display` trait for code generation +- Maintains proper indentation and formatting +- Generates idiomatic Rust code with appropriate error handling