diff --git a/dptb/data/AtomicData.py b/dptb/data/AtomicData.py index 0017070b..451f953b 100644 --- a/dptb/data/AtomicData.py +++ b/dptb/data/AtomicData.py @@ -23,6 +23,9 @@ from .util import _TORCH_INTEGER_DTYPES from dptb.utils.torch_geometric.data import Data from dptb.utils.constants import atomic_num_dict +import logging + +log = logging.getLogger(__name__) # A type representing ASE-style periodic boundary condtions, which can be partial (the tuple case) PBC = Union[bool, Tuple[bool, bool, bool]] @@ -874,11 +877,10 @@ def without_nodes(self, which_nodes): return type(self)(**new_dict) -_ERROR_ON_NO_EDGES: bool = os.environ.get("NEQUIP_ERROR_ON_NO_EDGES", "true").lower() -assert _ERROR_ON_NO_EDGES in ("true", "false") +_ERROR_ON_NO_EDGES = os.environ.get("NEQUIP_ERROR_ON_NO_EDGES", "true").lower() +assert _ERROR_ON_NO_EDGES in ("true", "false"), "NEQUIP_ERROR_ON_NO_EDGES must be 'true' or 'false'" _ERROR_ON_NO_EDGES = _ERROR_ON_NO_EDGES == "true" - def neighbor_list_and_relative_vec( pos, r_max, @@ -1026,6 +1028,13 @@ def neighbor_list_and_relative_vec( # so, only when key_rev is not in the dict, we keep the bond. that is when rev_dict.get(key_rev, False) is False, we set o_mast = True. if not (rev_dict.get(key_rev, False) and rev_dict.get(key, False)): o_mask[i] = True + + if self_interaction: + log.warning("self_interaction is True, but usually we do not want the self-interaction, please check if it is correct.") + # for self-interaction, the above will remove the self-interaction, i.e. i == j, shift == [0, 0, 0]. since -0 = 0. + if (o_shift[i] == np.array([0, 0, 0])).all(): + o_mask[i] = True + del rev_dict del o_first_idex del o_second_idex @@ -1038,6 +1047,7 @@ def neighbor_list_and_relative_vec( shifts = torch.as_tensor(shifts[mask], dtype=out_dtype, device=out_device) if not reduce: + assert self_interaction == False, "for self_interaction = True, i i 0 0 0 will be duplicated." first_idex, second_idex = torch.cat((first_idex, second_idex), dim=0), torch.cat((second_idex, first_idex), dim=0) shifts = torch.cat((shifts, -shifts), dim=0) @@ -1049,7 +1059,7 @@ def neighbor_list_and_relative_vec( # TODO: mask the edges that is larger than r_max if mask_r: edge_vec = pos[edge_index[1]] - pos[edge_index[0]] - if cell is not None: + if cell is not None : edge_vec = edge_vec + torch.einsum( "ni,ij->nj", shifts, @@ -1058,17 +1068,36 @@ def neighbor_list_and_relative_vec( edge_length = torch.linalg.norm(edge_vec, dim=-1) - atom_species_num = [atomic_num_dict[k] for k in r_max.keys()] - for i in set(atomic_numbers): - assert i in atom_species_num - r_map = torch.zeros(max(atom_species_num)) - for k, v in r_max.items(): - r_map[atomic_num_dict[k]-1] = v - edge_length_max = 0.5 * (r_map[atomic_numbers[edge_index[0]]-1] + r_map[atomic_numbers[edge_index[1]]-1]) + # atom_species_num = [atomic_num_dict[k] for k in r_max.keys()] + # for i in set(atomic_numbers): + # assert i in atom_species_num + # r_map = torch.zeros(max(atom_species_num)) + # for k, v in r_max.items(): + # r_map[atomic_num_dict[k]-1] = v + + first_key = next(iter(r_max.keys())) + key_parts = first_key.split("-") + + if len(key_parts)==1: + r_map = get_r_map(r_max, atomic_numbers) + edge_length_max = 0.5 * (r_map[atomic_numbers[edge_index[0]]-1] + r_map[atomic_numbers[edge_index[1]]-1]) + + elif len(key_parts)==2: + r_map = get_r_map_bondwise(r_max, atomic_numbers) + edge_length_max = r_map[atomic_numbers[edge_index[0]]-1,atomic_numbers[edge_index[1]]-1] + else: + raise ValueError("The r_max keys should be either atomic number or atomic number pair.") + r_mask = edge_length <= edge_length_max if any(~r_mask): edge_index = edge_index[:, r_mask] shifts = shifts[r_mask] + # 收集不同类型的边及其对应的最大截断半径 + #edge_types = {} + #for i in range(edge_index.shape[1]): + # atom_type_pair = (atomic_numbers[edge_index[0, i]], atomic_numbers[edge_index[1, i]]) + # if atom_type_pair not in edge_types: + # edge_types[atom_type_pair] = edge_length_max[i].item() del edge_length del edge_vec @@ -1077,3 +1106,62 @@ def neighbor_list_and_relative_vec( del r_mask return edge_index, shifts, cell_tensor + +def get_r_map(r_max: dict, atomic_numbers=None): + """ + Returns a torch tensor representing the mapping of atomic species to their maximum distances. + + Args: + r_max (dict): A dictionary mapping atomic species to their maximum distances. + atomic_numbers (list, optional): A list of atomic numbers to validate against the atomic species. Defaults to None. + + Returns: + torch.Tensor: A torch tensor representing the mapping of atomic species to their maximum distances. + """ + atom_species_num = [atomic_num_dict[k] for k in r_max.keys()] + if atomic_numbers is not None: + for i in atomic_numbers: + assert i in atom_species_num + r_map = torch.zeros(max(atom_species_num)) + for k, v in r_max.items(): + r_map[atomic_num_dict[k]-1] = v + return r_map + +def get_r_map_bondwise(r_max:dict, atomic_numbers=None): + """ + Calculate the bondwise distance map based on the maximum bond length dictionary. + + Args: + r_max (dict): A dictionary containing the maximum bond lengths for different atom pairs. + atomic_numbers (list, optional): A list of atomic numbers. Defaults to None. + + Returns: + torch.Tensor: A torch tensor representing the bondwise distance map. + """ + atom_species_num = [] + for k in r_max.keys(): + assert len(k.split('-')) == 2 + atom_a, atom_b = k.split('-') + if atomic_num_dict[atom_a] not in atom_species_num: + atom_species_num.append(atomic_num_dict[atom_a]) + if atomic_num_dict[atom_b] not in atom_species_num: + atom_species_num.append(atomic_num_dict[atom_b]) + + if atomic_numbers is not None: + for i in atomic_numbers: + assert i in atom_species_num + + r_map = torch.zeros(max(atom_species_num), max(atom_species_num)) + for k, v in r_max.items(): + atom_a, atom_b = k.split('-') + + inv_value = r_map[atomic_num_dict[atom_b]-1, atomic_num_dict[atom_a]-1] + if inv_value == 0: + r_map[atomic_num_dict[atom_a]-1, atomic_num_dict[atom_b]-1] = v + r_map[atomic_num_dict[atom_b]-1, atomic_num_dict[atom_a]-1] = v + else: + mean_val = (v + inv_value) / 2 + r_map[atomic_num_dict[atom_a]-1, atomic_num_dict[atom_b]-1] = mean_val + r_map[atomic_num_dict[atom_b]-1, atomic_num_dict[atom_a]-1] = mean_val + + return r_map \ No newline at end of file diff --git a/dptb/data/transforms.py b/dptb/data/transforms.py index 1a138379..8caac908 100644 --- a/dptb/data/transforms.py +++ b/dptb/data/transforms.py @@ -560,7 +560,7 @@ def __init__( for ib in self.basis.keys(): self.basis[ib] = sorted( self.basis[ib], - key=lambda s: (anglrMId[re.findall(r"[a-z]",s)[0]], re.findall(r"[1-9*]",s)[0]) + key=lambda s: (anglrMId[re.findall(r"[a-z]",s)[0]], re.findall(r"[1-9*]",s)[0] if re.findall(r"[1-9*]",s) else '0') ) # TODO: get full basis set diff --git a/dptb/entrypoints/collectskf.py b/dptb/entrypoints/collectskf.py index b6e2ff50..ffd0eb53 100644 --- a/dptb/entrypoints/collectskf.py +++ b/dptb/entrypoints/collectskf.py @@ -1,14 +1,18 @@ -from typing import Dict, List, Optional, Any +from typing import Dict, List, Optional, Any, Union import json from pathlib import Path import os import torch import glob from dptb.nn.dftb.sk_param import SKParam - +from dptb.nn.dftb2nnsk import DFTB2NNSK import logging +from dptb.utils.loggers import set_log_handles +from dptb.utils.tools import j_loader, setup_seed, j_must_have +from dptb.utils.argcheck import normalize, collect_cutoffs, normalize_skf2nnsk + -__all__ = ["skf2pth"] +__all__ = ["skf2pth", "skf2nnsk"] log = logging.getLogger(__name__) @@ -45,3 +49,80 @@ def skf2pth( torch.save(skdict, output) +def skf2nnsk( + INPUT:str, + init_model: Optional[str], + output:str, + log_level: int, + log_path: Optional[str] = None, + **kwargs +): + run_opt = { + "init_model": init_model, + "log_path": log_path, + "log_level": log_level + } + + # setup output path + if output: + Path(output).parent.mkdir(exist_ok=True, parents=True) + Path(output).mkdir(exist_ok=True, parents=True) + if not log_path: + log_path = os.path.join(str(output), "log.txt") + Path(log_path).parent.mkdir(exist_ok=True, parents=True) + + run_opt.update({ + "output": str(Path(output).absolute()), + "log_path": str(Path(log_path).absolute()) + }) + set_log_handles(log_level, Path(log_path) if log_path else None) + + jdata = j_loader(INPUT) + jdata = normalize_skf2nnsk(jdata) + + common_options = jdata['common_options'] + model_options = jdata['model_options'] + train_options = jdata['train_options'] + + basis = j_must_have(common_options, "basis") + skdata_file = j_must_have(common_options, "skdata") + + if skdata_file.split('.')[-1] != 'pth': + log.error("The skdata file should be a pth file.") + raise ValueError("The skdata file should be a pth file.") + log.info(f"Loading skdata from {skdata_file}") + skdata = torch.load(skdata_file) + + if isinstance(basis, str) and basis == "auto": + log.info("Automatically determining basis") + basis = dict(zip(skdata['OnsiteE'], [['s', 'p', 'd']] * len(skdata['OnsiteE']))) + else: + assert isinstance(basis, dict), "basis must be a dict or 'auto'" + + train_options = jdata['train_options'] + + if init_model: + dftb2nn = DFTB2NNSK.load(ckpt=init_model, + skdata=skdata, + train_options=train_options, + output=run_opt.get('output', './') + ) + + else: + dftb2nn = DFTB2NNSK( + basis = basis, + skdata = skdata, + method=j_must_have(model_options, "method"), + rs=model_options.get('rs', None), + w = j_must_have(model_options, "w"), + cal_rcuts= model_options.get('rs', None) is None, + atomic_radius= model_options.get('atomic_radius', 'cov'), + train_options=train_options, + output=run_opt.get('output', './') + ) + + dftb2nn.optimize() + + + + diff --git a/dptb/entrypoints/main.py b/dptb/entrypoints/main.py index 296d7583..0bf34160 100644 --- a/dptb/entrypoints/main.py +++ b/dptb/entrypoints/main.py @@ -12,7 +12,7 @@ from dptb.entrypoints.data import data from dptb.utils.loggers import set_log_handles from dptb.utils.config_check import check_config_train -from dptb.entrypoints.collectskf import skf2pth +from dptb.entrypoints.collectskf import skf2pth, skf2nnsk from dptb import __version__ @@ -364,6 +364,37 @@ def main_parser() -> argparse.ArgumentParser: help="The output pth files of sk params from skfiles." ) + # neighbour + parser_skf2nn = subparsers.add_parser( + "skf2nn", + parents=[parser_log], + help="Convert the sk files to nn-sk TB model", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + + parser_skf2nn.add_argument( + "INPUT", help="the input parameter file in json or yaml format", + type=str, + default=None + ) + + parser_skf2nn.add_argument( + "-i", + "--init-model", + type=str, + default=None, + help="Initialize the model by the provided checkpoint.", + ) + + parser_skf2nn.add_argument( + "-o", + "--output", + type=str, + default="./", + help="The output files in training.", + ) + + return parser def parse_args(args: Optional[List[str]] = None) -> argparse.Namespace: @@ -424,3 +455,6 @@ def main(): elif args.command == 'cskf': skf2pth(**dict_args) + + elif args.command == 'skf2nn': + skf2nnsk(**dict_args) diff --git a/dptb/nn/build.py b/dptb/nn/build.py index c5c6035f..51aa8730 100644 --- a/dptb/nn/build.py +++ b/dptb/nn/build.py @@ -11,7 +11,8 @@ def build_model( checkpoint: str=None, model_options: dict={}, - common_options: dict={} + common_options: dict={}, + no_check: bool=False ): """ The build model method should composed of the following steps: @@ -161,12 +162,12 @@ def build_model( model = DFTBSK.from_reference(checkpoint, **model_options["dftbsk"], **common_options) else: model = None - - for k, v in model.model_options.items(): - if k not in model_options: - log.warning(f"The model options {k} is not defined in input model_options, set to {v}.") - else: - deep_dict_difference(k, v, model_options) + if not no_check: + for k, v in model.model_options.items(): + if k not in model_options: + log.warning(f"The model options {k} is not defined in input model_options, set to {v}.") + else: + deep_dict_difference(k, v, model_options) model.to(model.device) return model diff --git a/dptb/nn/dftb/hopping_dftb.py b/dptb/nn/dftb/hopping_dftb.py index f7c3eb4e..e0b819ac 100644 --- a/dptb/nn/dftb/hopping_dftb.py +++ b/dptb/nn/dftb/hopping_dftb.py @@ -1,7 +1,8 @@ from dptb.nn.sktb.hopping import BaseHopping import torch from dptb.utils._xitorch.interpolate import Interp1D - +import logging +log = logging.getLogger(__name__) class HoppingIntp(BaseHopping): def __init__( @@ -36,7 +37,19 @@ def dftb(self, rij:torch.Tensor, xx:torch.Tensor, yy:torch.Tensor, **kwargs): assert rij.shape[0] == self.num_ingrls, "the bond distance shape rij is not correct." else: raise ValueError("The shape of rij is not correct.") + # 检查 rij 是否在 xx 的范围内 + min_x, max_x = self.xx.min(), self.xx.max() + mask_in_range = (rij >= min_x) & (rij <= max_x) + mask_out_range = ~mask_in_range + if mask_out_range.any(): + # log.warning("Some rij values are outside the interpolation range and will be set to 0.") + # 创建 rij 的副本,并将范围外的值替换为范围内的值(例如,使用 min_x) + rij_modified = rij.clone() + rij_modified[mask_out_range] = (min_x + max_x) / 2 + yyintp = self.intpfunc(xq=rij_modified, y=yy) + yyintp[mask_out_range] = 0.0 + else: + yyintp = self.intpfunc(xq=rij, y=yy) - yyintp = self.intpfunc(xq=rij,y=yy) return yyintp.T \ No newline at end of file diff --git a/dptb/nn/dftb/sk_param.py b/dptb/nn/dftb/sk_param.py index 30a4f2a5..fe24072c 100644 --- a/dptb/nn/dftb/sk_param.py +++ b/dptb/nn/dftb/sk_param.py @@ -7,6 +7,8 @@ from typing import Tuple, Union, Dict from dptb.data.transforms import OrbitalMapper from dptb.utils._xitorch.interpolate import Interp1D +import numpy as np +from dptb.nn.sktb.cov_radiiDB import Covalent_radii log = logging.getLogger(__name__) @@ -26,8 +28,16 @@ class SKParam: def __init__(self, basis: Dict[str, Union[str, list]]=None, idp_sk: Union[OrbitalMapper, None]=None, - skdata: Union[str,dict] = None) -> None: - + skdata: Union[str,dict] = None, + cal_rcuts: bool = False, + device='cpu', + dtype=torch.float32) -> None: + + self.device = device + if isinstance(dtype, str): + dtype = getattr(torch, dtype) + self.dtype = dtype + if basis is not None: self.idp_sk = OrbitalMapper(basis, method="sktb") if idp_sk is not None: @@ -79,7 +89,13 @@ def __init__(self, else: log.error("The skdata should be a dict or string for a file path.") raise ValueError("The skdata should be a dict or string for a file path.") - + + if cal_rcuts: + self.bond_r_min, self.bond_r_max = cal_rmin_rmax_bondwise(skdata=skdict) + else: + self.bond_r_min = None + self.bond_r_max = None + self.skdict = self.format_skparams(skdict) @classmethod @@ -217,9 +233,9 @@ def format_skparams(self, skdict): assert len(skdict["Distance"][ibtype].shape) == 1 x_num.append(len(skdict["Distance"][ibtype])) - x_min = torch.tensor(x_min).max() - x_max = torch.tensor(x_max).min() - x_num = torch.tensor(x_num).min() + x_min = torch.tensor(x_min).min() + x_max = torch.tensor(x_max).max() + x_num = torch.tensor(x_num).max() xlist_all = torch.linspace(x_min, x_max, x_num) format_skdict = {} @@ -248,21 +264,153 @@ def format_skparams(self, skdict): xx = xx.reshape(1, -1).repeat(10, 1) xx_int = xlist_all.reshape([1,-1]).repeat(10, 1) - intp = Interp1D(x=xx, method='linear') - hh_intp = intp(xq=xx_int, y=hh) - ss_intp = intp(xq=xx_int, y=ss) + + x_min = xx.min().item() + x_max = xx.max().item() + mask_in_range = (xx_int >= x_min) & (xx_int <= x_max) + mask_out_range = ~mask_in_range + if mask_out_range.any(): + xx_tmp = xx_int.clone() + xx_tmp[mask_out_range] = (x_min + x_max) / 2 + hh_intp = intp(xq=xx_tmp, y=hh) + ss_intp = intp(xq=xx_tmp, y=ss) + hh_intp[mask_out_range] = 0.0 + ss_intp[mask_out_range] = 0.0 + else: + hh_intp = intp(xq=xx_int, y=hh) + ss_intp = intp(xq=xx_int, y=ss) for ipt in self.idp_sk.orbpairtype_maps.keys(): slc = self.idp_sk.orbpairtype_maps[ipt] hopping_params[idx][slc] = hh_intp[self.intgl_order[ipt]] overlap_params[idx][slc] = ss_intp[self.intgl_order[ipt]] - - format_skdict['Hopping'] = hopping_params format_skdict['Overlap'] = overlap_params format_skdict['OnsiteE'] = onsiteE_params return format_skdict - + +def find_first_false(arr): + """ + Find the index of the first occurrence of False in each row of a 2D array, counting from the end of the row. + + Parameters: + arr (numpy.ndarray): The input 2D array. + + Returns: + numpy.ndarray: An array containing the indices of the first occurrence of False in each row. + If a row does not contain any False, the corresponding index is set to -1. + """ + assert arr.ndim == 2 + reversed_arr = np.flip(arr, axis=1) + reversed_indices = np.argmax(reversed_arr == False, axis=1) + original_indices = arr.shape[1] - 1 - reversed_indices + no_false_rows = np.all(reversed_arr, axis=1) + original_indices[no_false_rows] = -1 + return original_indices + + +def cal_rmin_rmax_bondwise(skdata): + """ + Calculate the minimum and maximum bond distances for each pair of atomic symbols. + + This function computes the minimum and maximum bond distances (rmin and rmax) for each + pair of atomic symbols based on the provided Slater-Koster data. The minimum bond distance + is calculated using the covalent radii of the atoms, and the maximum bond distance is + determined from the hopping integrals and distances. + + Parameters: + skdata (dict): A dictionary containing Slater-Koster data with the following keys: + - 'OnsiteE': A dictionary where keys are atomic symbols and values are onsite energies. + - 'Hopping': A dictionary where keys are bond types (e.g., 'C-H') and values are + tensors of hopping integrals. + - 'Distance': A dictionary where keys are bond types and values are tensors of distances. + + Returns: + tuple: A tuple containing two dictionaries: + - atomic_r_min_dict (dict): A dictionary where keys are bond types and values are the + minimum bond distances. + - atomic_r_max_dict (dict): A dictionary where keys are bond types and values are the + maximum bond distances. + """ + atomic_symbols = list(skdata['OnsiteE'].keys()) + + bond_r_max_dict = {} + bond_r_min_dict = {} + for isym in atomic_symbols: + for jsym in atomic_symbols: + bondtype = isym + '-' + jsym + inv_bondtype = jsym + '-' + isym + + hopp = skdata['Hopping'][bondtype].numpy() + dist = skdata['Distance'][bondtype].numpy() + assert len(dist) == hopp.shape[1] + # ind = find_first_false(np.abs(hopp)<1e-3*np.abs(hopp).max()) + ind = find_first_false(np.abs(hopp)<1e-2) + rmax = dist[np.max(ind)].item() + if inv_bondtype in bond_r_max_dict: + rmax = max(rmax, bond_r_max_dict[inv_bondtype]) + bond_r_max_dict[bondtype] = round(rmax,2) + bond_r_max_dict[inv_bondtype] = round(rmax,2) + + + bond_r_min_dict[bondtype] = round(0.5 * Covalent_radii[isym] + 0.5 * Covalent_radii[jsym],2) + return bond_r_min_dict, bond_r_max_dict + + +def cal_rmin_rmax(skdata): + """ + Calculate the minimum and maximum atomic radii based on the given skdata. + + Args: + skdata (dict): Dictionary containing the skdata. + + Returns: + tuple: A tuple containing two dictionaries. The first dictionary contains the minimum atomic radii + for each atomic symbol, and the second dictionary contains the maximum atomic radii for each + atomic symbol. + """ + + atomic_symbols = list(skdata['OnsiteE'].keys()) + + # using homo param to determine the rmax + atomic_r_max_dict = {} + + for isym in atomic_symbols: + bondtype = isym + '-' + isym + hopp = skdata['Hopping'][bondtype].numpy() + dist = skdata['Distance'][bondtype].numpy() + assert len(dist) == hopp.shape[1] + ind = find_first_false(np.abs(hopp)<1e-2) + rmax = dist[np.max(ind)] + # rmx 保留两位小数 + atomic_r_max_dict[isym] = round(rmax / 2,2) + + # update rmax based on the homo rmax and hetero param. + for isym in atomic_symbols: + for jsym in atomic_symbols: + if isym != jsym: + bondtype = isym + '-' + jsym + hopp = skdata['Hopping'][bondtype].numpy() + dist = skdata['Distance'][bondtype].numpy() + assert len(dist) == hopp.shape[1] + ind = find_first_false(np.abs(hopp)<1e-2) + rmax = dist[np.max(ind)] + + # 按照共价半径比例拆分 + rario = atomic_r_max_dict[isym] / (atomic_r_max_dict[isym] + atomic_r_max_dict[jsym]) + rmax_isym = rmax * rario + rmax_jsym = rmax * (1-rario) + if rmax_isym > atomic_r_max_dict[isym]: + atomic_r_max_dict[isym] = round(rmax_isym,2) + if rmax_jsym > atomic_r_max_dict[jsym]: + atomic_r_max_dict[jsym] = round(rmax_jsym,2) + + atomic_r_min_dict = {} + for isym in atomic_symbols: + atomic_r_min_dict[isym] = round(0.5 * Covalent_radii[isym],2) + + return atomic_r_min_dict, atomic_r_max_dict + \ No newline at end of file diff --git a/dptb/nn/dftb2nnsk.py b/dptb/nn/dftb2nnsk.py index f4655749..2f8f5ba5 100644 --- a/dptb/nn/dftb2nnsk.py +++ b/dptb/nn/dftb2nnsk.py @@ -1,48 +1,134 @@ from dptb.nn.dftb.sk_param import SKParam from dptb.nn.dftb.hopping_dftb import HoppingIntp import torch +from torch import nn from dptb.nn.sktb.hopping import HoppingFormula from dptb.nn.sktb import OnsiteFormula, bond_length_list +from dptb.nn.sktb.cov_radiiDB import Covalent_radii +from dptb.nn.sktb.bondlengthDB import atomic_radius_v1 +from dptb.utils.constants import atomic_num_dict from functorch import vmap import matplotlib.pyplot as plt from torch.optim import Adam, LBFGS, RMSprop, SGD -from torch.optim.lr_scheduler import ExponentialLR +from torch.optim.lr_scheduler import ExponentialLR, CosineAnnealingLR from dptb.nn.nnsk import NNSK from dptb.nn.sktb.onsite import onsite_energy_database +from dptb.data.AtomicData import get_r_map, get_r_map_bondwise import numpy as np +from typing import Union +import logging +import os, sys +from dptb.utils.tools import get_lr_scheduler, get_optimizer, setup_seed + +log = logging.getLogger(__name__) class dftb: - def __init__(self, basis, skdata): - self.param = SKParam(basis=basis, skdata=skdata) + def __init__(self, basis, skdata, cal_rcuts=False, device='cpu', dtype=torch.float32): + self.device = device + if isinstance(dtype, str): + dtype = getattr(torch, dtype) + self.dtype = dtype + self.param = SKParam(basis=basis, skdata=skdata, cal_rcuts=cal_rcuts) + self.bond_r_min = self.param.bond_r_min + self.bond_r_max = self.param.bond_r_max self.idp_sk = self.param.idp_sk + self.param = self.param.format_skparams(self.param.skdict) self.hopping = HoppingIntp(num_ingrls=self.param["Hopping"].shape[1]) self.overlap = HoppingIntp(num_ingrls=self.param["Overlap"].shape[1]) - - def __call__(self, r, mode="hopping"): + self.bond_types = self.idp_sk.bond_types + self.bond_type_to_index = {bt: i for i, bt in enumerate(self.idp_sk.bond_types)} + + def __call__(self, r, bond_indices = None, mode="hopping"): out = [] - for i in range(len(self.idp_sk.bond_types)): - out.append(self.hopping.get_skhij(rij=r, xx=self.param["Distance"], yy=self.param[mode[0].upper()+mode[1:]][i])) + if bond_indices is None: + bond_indices = torch.arange(len(self.idp_sk.bond_types), device=self.device) + + assert len(bond_indices) == len(r), "The bond_indices and r should have the same length." + + for i, ind in enumerate(bond_indices): + out.append(self.hopping.get_skhij(rij=r[i], xx=self.param["Distance"].to(device=self.device, dtype=self.dtype), + yy=self.param[mode[0].upper()+mode[1:]][ind].to(device=self.device, dtype=self.dtype))) + return torch.stack(out) -class DFTB2NNSK: - def __init__(self, basis, skdata, functype, rs, w): - self.dftb = dftb(basis=basis, skdata=skdata) - self.functype = functype - self.idp_sk = self.dftb.idp_sk - self.rs = rs - self.w = w +class DFTB2NNSK(nn.Module): + def __init__(self, basis, skdata, train_options, output='./', method='poly2pow', rs=None, w=0.2, cal_rcuts=False, atomic_radius='cov',seed=3982377700, device='cpu', dtype=torch.float32): + if rs is None: + assert cal_rcuts, "If rs is not provided, cal_rcuts should be False." + super(DFTB2NNSK, self).__init__() + self.device = device + if isinstance(dtype, str): + dtype = getattr(torch, dtype) + self.dtype = dtype + + self.dftb = dftb(basis=basis, skdata=skdata, cal_rcuts=cal_rcuts, device=self.device, dtype=self.dtype) + self.basis = basis + self.functype = method + self.idp_sk = self.dftb.idp_sk + # self.rs = rs + self.w = w self.nnsk_hopping = HoppingFormula(functype=self.functype) self.nnsk_overlap = HoppingFormula(functype=self.functype, overlap=True) - self.hopping_params = torch.nn.Parameter(torch.randn(len(self.idp_sk.bond_types), self.dftb.hopping.num_ingrls, self.nnsk_hopping.num_paras)) - self.overlap_params = torch.nn.Parameter(torch.randn(len(self.idp_sk.bond_types), self.dftb.hopping.num_ingrls, self.nnsk_hopping.num_paras)) - self.E_base = torch.zeros(self.idp_sk.num_types, self.idp_sk.n_onsite_Es) - for asym, idx in self.idp_sk.chemical_symbol_to_type.items(): - self.E_base[idx] = torch.zeros(self.idp_sk.n_onsite_Es) - for ot in self.idp_sk.basis[asym]: - fot = self.idp_sk.basis_to_full_basis[asym][ot] - self.E_base[idx][self.idp_sk.skonsite_maps[fot+"-"+fot]] = onsite_energy_database[asym][ot] + self.hopping_params = torch.nn.Parameter(torch.randn(len(self.idp_sk.bond_types), self.dftb.hopping.num_ingrls, self.nnsk_hopping.num_paras, device=self.device, dtype=self.dtype)) + self.overlap_params = torch.nn.Parameter(torch.randn(len(self.idp_sk.bond_types), self.dftb.hopping.num_ingrls, self.nnsk_hopping.num_paras, device=self.device, dtype=self.dtype)) + self.atomic_radius = atomic_radius + self.initialize_atomic_radius(basis, atomic_radius) + self.initialize_rs_and_cutoffs(rs, cal_rcuts) + + self.mae_loss = torch.nn.L1Loss() + self.mse_loss = torch.nn.MSELoss() + self.best_loss = float("inf") + self.train_options = train_options + self.output = output + self.seed = seed + setup_seed(seed) + + def initialize_atomic_radius(self, basis, atomic_radius): + if isinstance(atomic_radius, str): + if atomic_radius == 'cov': + atomic_radius_dict = Covalent_radii + elif atomic_radius == 'v1': + atomic_radius_dict = atomic_radius_v1 + else: + raise ValueError("The atomic_radius should be either str of 'cov' or 'v1' or a dict.") + else: + assert isinstance(atomic_radius, dict), "The atomic_radius should be either str of 'cov' or 'v1' or a dict." + atomic_radius_dict = atomic_radius + + atomic_numbers = [atomic_num_dict[key] for key in basis.keys()] + self.atomic_radius_list = torch.zeros(int(max(atomic_numbers)),device= self.device, dtype=self.dtype) - 100 + for at in basis.keys(): + assert at in atomic_radius_dict and atomic_radius_dict[at] is not None, f"The atomic radius for {at} is not provided." + radii = atomic_radius_dict[at] + self.atomic_radius_list[atomic_num_dict[at]-1] = radii + + def initialize_rs_and_cutoffs(self, rs, cal_rcuts): + if not cal_rcuts: + assert isinstance(rs, (float,int)), "If cal_rcuts is False, the rs should be a float" + self.rs = rs + self.r_max = None + self.r_min = None + else: + if rs is None: + self.rs = self.dftb.bond_r_max + else: + assert isinstance(rs, dict) + for k, v in self.dftb.bond_r_max.items(): + assert k in rs, f"The bond type {k} is not in the rs dict." + assert rs[k] == v, f"The bond type rmax in {k} is not equal to the dftb bond_r_max." + self.rs = rs + + self.r_map = get_r_map_bondwise(self.dftb.bond_r_max).to(device=self.device, dtype=self.dtype) + self.r_max = [] + self.r_min = [] + for ibt in self.idp_sk.bond_types: + self.r_max.append(self.dftb.bond_r_max[ibt]) + self.r_min.append(self.dftb.bond_r_min[ibt]) + self.r_max = torch.tensor(self.r_max, device=self.device, dtype=self.dtype).reshape(-1,1) + self.r_min = torch.tensor(self.r_min, device=self.device, dtype=self.dtype).reshape(-1,1) + def symmetrize(self): reflective_bonds = np.array([self.idp_sk.bond_to_type["-".join(self.idp_sk.type_to_bond[i].split("-")[::-1])] for i in range(len(self.idp_sk.bond_types))]) @@ -64,122 +150,388 @@ def symmetrize(self): self.overlap_params.data[:,self.idp_sk.orbpair_maps[k],:] = 0.5 * (params[:,self.idp_sk.orbpair_maps[k],:] + reflect_params[:,self.idp_sk.orbpair_maps[k],:]) return True + + def save(self,filepath): + state = {} + config = { + 'basis': self.basis, + 'method': self.functype, + 'rs': self.rs, + 'w': self.w, + 'cal_rcuts': self.r_max is not None, + 'atomic_radius': self.atomic_radius, + 'device': self.device, + 'dtype': self.dtype, + 'seed': self.seed + } + state.update({"config": config}) + state.update({"model_state_dict": self.state_dict()}) + + torch.save(state, f"{filepath}") + log.info(f"The model is saved to {filepath}") + + def get_config(self): + config = { + 'basis': self.basis, + 'method': self.functype, + 'rs': self.rs, + 'w': self.w, + 'cal_rcuts': self.r_max is not None, + 'atomic_radius': self.atomic_radius, + 'device': self.device, + 'dtype': self.dtype, + 'seed': self.seed + } + return config + + @classmethod + def load(cls, ckpt, skdata, train_options, output='./'): + if not os.path.exists(ckpt): + raise FileNotFoundError(f"No file found at {ckpt}") + + state = torch.load(ckpt) + config = state['config'] + model = cls(skdata=skdata, train_options=train_options, output=output, **config) + model.load_state_dict(state['model_state_dict']) + return model + def step(self, r): - - if r.reshape(-1).shape[0] == 1: - r = r.reshape(-1) - r = r.repeat(len(self.idp_sk.bond_types)) - edge_number = self.idp_sk.untransform_bond(torch.arange(len(self.idp_sk.bond_types))).T - r0 = 0.5*bond_length_list[edge_number-1].sum(0) + assert r.shape[0] == len(self.curr_bond_indices) + r = r.reshape(-1) + bond_ind_r_shp = self.curr_bond_indices.reshape(-1) + + edge_number = self.idp_sk.untransform_bond(bond_ind_r_shp).T + r0 = self.atomic_radius_list[edge_number-1].sum(0).to(device=self.device, dtype=self.dtype) # bond length r0 = r1 + r2. (r1, r2 are atomic radii of the two atoms) + if isinstance(self.rs, dict): + assert hasattr(self, "r_map") + # r_cutoffs = self.r_map[edge_number-1].sum(0) + r_cutoffs = self.r_map[edge_number[0]-1, edge_number[1]-1] + assert torch.allclose(r_cutoffs,self.r_max[bond_ind_r_shp].reshape(-1)) + else: + assert isinstance(self.rs, (int,float)) + r_cutoffs = self.rs + hopping = self.nnsk_hopping.get_skhij( rij=r, - paraArray=self.hopping_params, # [N_edge, n_pairs, n_paras], - rs=self.rs, + paraArray=self.hopping_params[bond_ind_r_shp], # [N_edge, n_pairs, n_paras], + rs=r_cutoffs, w=self.w, r0=r0 ) # [N_edge, n_pairs] overlap = self.nnsk_overlap.get_skhij( rij=r, - paraArray=self.overlap_params, # [N_edge, n_pairs, n_paras], - rs=self.rs, + paraArray=self.overlap_params[bond_ind_r_shp], # [N_edge, n_pairs, n_paras], + rs=r_cutoffs, w=self.w, r0=r0 ) - return hopping, overlap - def viz(self, r_min=1.5, r_max=5.0): - with torch.no_grad(): - r = torch.linspace(r_min,r_max, steps=100) - hops = vmap(self.step)(r.reshape(-1,1)) + def forward(self, r, bond_indices): + self.curr_bond_indices = bond_indices + hopping, overlap = vmap(self.step,in_dims=1)(r) + + dftb_hopping = self.dftb(r, bond_indices = self.curr_bond_indices, mode="hopping").permute(1,0,2) + dftb_overlap = self.dftb(r, bond_indices = self.curr_bond_indices, mode="overlap").permute(1,0,2) + return hopping, overlap, dftb_hopping, dftb_overlap + - dftb_hopping = self.dftb(r, mode="hopping").permute(1,0,2) - dftb_overlap = self.dftb(r, mode="overlap").permute(1,0,2) + def optimize(self, r_min=None, r_max=None, nstep=None, nsample=None, lr=None, dis_freq=None, viz=False): + """ + Optimize the parameters of the neural network model. - r = r.numpy() - fig = plt.figure(figsize=(6,4)) - # hops[0] shape - [n_r, n_edge, n_skintegrals] + Args: + r_min (float): The minimum value for the random range of r. + r_max (float): The maximum value for the random range of r. + nsample (int): The number of samples to generate for r. + nstep (int): The number of optimization steps to perform. + lr (float): The learning rate for the optimizer. + Freq (int): The frequency using in the function : + 1. frequency to display the loss during optimization. + 2. frequency to save the model. + 3. for CosineAnnealingLR, it is the T_max = 5*Freq. + method (str): The optimization method to use. Supported methods are "RMSprop" and "LBFGS". + viz (bool): Whether to visualize the optimized results. + max_elmt_batch (int): max_elmt_batch^2 defines The maximum number of bond types to optimize in each batch. + ie. if max_elmt_batch=4, we will optimize 16 bond types in each batch. - for i in range(hops[0].shape[1]): - plt.plot(r, hops[0][:,i, :-1].detach().numpy(), c="C"+str(i)) - plt.plot(r, hops[0][:,i, -1].detach().numpy(), c="C"+str(i)) - plt.plot(r, dftb_hopping[:,i, :-1].numpy(), c="C"+str(i), linestyle="--") - plt.plot(r, dftb_hopping[:,i, -1].numpy(), c="C"+str(i), linestyle="--") - plt.title("hoppings") - plt.xlabel("r(angstrom)") - plt.tight_layout() - # plt.legend() - plt.show() + Returns: + bool: True if the optimization is successful. - fig = plt.figure(figsize=(6,4)) - for i in range(hops[1].shape[1]): - plt.plot(r, hops[1][:,i, :-1].detach().numpy(), c="C"+str(i)) - plt.plot(r, hops[1][:,i, -1].detach().numpy(), c="C"+str(i)) - plt.plot(r, dftb_overlap[:,i, :-1].numpy(), c="C"+str(i), linestyle="--") - plt.plot(r, dftb_overlap[:,i, -1].numpy(), c="C"+str(i), linestyle="--") - plt.title("overlaps") - plt.xlabel("r(angstrom)") - plt.tight_layout() - # plt.legend() - plt.show() - - def optimize(self, r_min=1.5, r_max=5.0, nsample=256, nstep=40000, lr=1e-1, dis_freq=1000, method="RMSprop", viz=False): - if method=="RMSprop": - optimizer = RMSprop([self.hopping_params, self.overlap_params], lr=lr, momentum=0.2) - elif method=="LBFGS": - optimizer = LBFGS([self.hopping_params, self.overlap_params], lr=lr) - else: - raise NotImplementedError + Raises: + NotImplementedError: If the specified optimization method is not supported. + """ + if lr is not None: + self.train_options["optimizer"]["lr"] = lr + max_elmt_batch = self.train_options.get("max_elmt_batch", 4) + if nstep is None: + nstep = int(self.train_options["nstep"]) + if dis_freq is None: + dis_freq = int(self.train_options["dis_freq"]) + if nsample is None: + nsample = int(self.train_options.get("n_samples",256)) - lrscheduler = ExponentialLR(optimizer, gamma=0.9998) - self.loss = torch.tensor(0.) + save_freq = self.train_options.get("save_freq", 1) + + optimizer = get_optimizer(model_param=[self.hopping_params, self.overlap_params], **self.train_options["optimizer"]) + lrscheduler = get_lr_scheduler(optimizer=optimizer, **self.train_options["lr_scheduler"]) # add optmizer + self.loss = torch.tensor(0., device=self.device, dtype=self.dtype) def closure(): optimizer.zero_grad() - r = torch.rand(nsample) * (r_max - r_min) + r_min - hopping, overlap = vmap(self.step)(r.reshape(-1,1)) + if r_min is None and r_max is None: + assert self.r_min is not None and self.r_max is not None, "When both r_min and r_max are None. cal_rcuts=True when initializing the DFTB2NNSK object." + r_min_ = self.r_min[self.curr_bond_indices] + r_max_ = self.r_max[self.curr_bond_indices] + else: + assert r_min is not None and r_max is not None, "bothr_min and r_max should be provided or both None." + r_min_ = torch.tensor(r_min) + r_max_ = r_max + + # 用 gauss 分布的随机数,重点采样在 r_min 和 r_max范围中心区域的值 + r = self.truncated_normal(shape=[len(self.curr_bond_indices),nsample], min_val=r_min_, max_val=r_max_, stdsigma=0.5, device=self.device, dtype=self.dtype) + + hopping, overlap, dftb_hopping, dftb_overlap = self(r, bond_indices=self.curr_bond_indices) - dftb_hopping = self.dftb(r, mode="hopping").permute(1,0,2) - dftb_overlap = self.dftb(r, mode="overlap").permute(1,0,2) + # self.loss = (hopping - dftb_hopping).abs().mean() + \ + # torch.nn.functional.mse_loss(hopping, dftb_hopping).sqrt() + \ + # 15*torch.nn.functional.mse_loss(overlap, dftb_overlap).sqrt() + \ + # 15*(overlap - dftb_overlap).abs().mean() + + self.loss_hop_mae = self.mae_loss(hopping, dftb_hopping) + self.loss_hop_rmse = torch.sqrt(self.mse_loss(hopping, dftb_hopping)) + self.loss_ovl_mae = self.mae_loss(overlap, dftb_overlap) + self.loss_ovl_rmse = torch.sqrt(self.mse_loss(overlap, dftb_overlap)) + self.loss = self.loss_hop_mae + self.loss_hop_rmse + 15*self.loss_ovl_mae + 15*self.loss_ovl_rmse - self.loss = (hopping - dftb_hopping).abs().mean() + \ - torch.nn.functional.mse_loss(hopping, dftb_hopping).sqrt() + \ - 15*torch.nn.functional.mse_loss(overlap, dftb_overlap).sqrt() + \ - 15*(overlap - dftb_overlap).abs().mean() self.loss.backward() return self.loss + total_bond_types = len(self.idp_sk.bond_types) + for istep in range(nstep): - if istep % dis_freq == 0: - print(f"step {istep}, loss {self.loss.item()}, lr {lrscheduler.get_last_lr()[0]}") - - optimizer.step(closure) + # 如果 total_bond_types 太大, 会导致内存不够, 可以考虑分批次优化, 每次优化一部分的bond_types + # 我们定义一次优化最大的bond_types数量为 max_elmt_batch^2 + bond_indices_all = torch.randperm(total_bond_types, device=self.device) + total_loss = 0 + total_hop_mae = 0 + total_hop_rmse = 0 + total_ovl_mae = 0 + total_ovl_rmse = 0 + + for i in range(0, total_bond_types, max_elmt_batch**2): + curr_indices = torch.arange(i, min(i+max_elmt_batch**2, total_bond_types),device=self.device) + self.curr_bond_indices = bond_indices_all[curr_indices] + optimizer.step(closure) + total_loss += self.loss.item() + total_hop_mae += self.loss_hop_mae.item() + total_hop_rmse += self.loss_hop_rmse.item() + total_ovl_mae += self.loss_ovl_mae.item() + total_ovl_rmse += self.loss_ovl_rmse.item() + + if istep % dis_freq == 0: + loginfo = (f"Batch {istep:6d}, subset [{i:3d}{min(i+max_elmt_batch**2, total_bond_types):3d}]: " + f"Loss {self.loss.item():7.4f}, " + f"Hop MAE {self.loss_hop_mae.item():7.4f}, " + f"Hop RMSE {self.loss_hop_rmse.item():7.4f}, " + f"Ovl MAE {self.loss_ovl_mae.item():7.4f}, " + f"Ovl RMSE {self.loss_ovl_rmse.item():7.4f}, " + f"LR {lrscheduler.get_last_lr()[0]:8.6f}") + log.info(loginfo) + + if istep % dis_freq == 0 and total_bond_types > max_elmt_batch**2: + total_loss = total_loss / ((total_bond_types + max_elmt_batch**2 - 1) // max_elmt_batch**2) + total_hop_mae = total_hop_mae / ((total_bond_types + max_elmt_batch**2 - 1) // max_elmt_batch**2) + total_hop_rmse = total_hop_rmse / ((total_bond_types + max_elmt_batch**2 - 1) // max_elmt_batch**2) + total_ovl_mae = total_ovl_mae / ((total_bond_types + max_elmt_batch**2 - 1) // max_elmt_batch**2) + total_ovl_rmse = total_ovl_rmse / ((total_bond_types + max_elmt_batch**2 - 1) // max_elmt_batch**2) + + loginfo=(f"Batch {istep} Summary: " + f"Loss {total_loss:.4f}, " + f"Hop MAE {total_hop_mae:.4f}, " + f"Hop RMSE {total_hop_rmse:.4f}, " + f"Ovl MAE {total_ovl_mae:.4f}, " + f"Ovl RMSE {total_ovl_rmse:.4f}, " + f"LR {lrscheduler.get_last_lr()[0]:.6f}") + + log.info('--'*15) + log.info(loginfo) + lrscheduler.step() self.symmetrize() + + if total_loss < min(self.best_loss, 1): + self.best_loss = total_loss + self.save(f'{self.output}/best_df2sk.pth') + if istep % save_freq == 0 or istep == nstep-1: + self.save(f'{self.output}/lastest_df2sk.pth') if viz: self.viz(r_min=r_min, r_max=r_max) return True - def to_nnsk(self): - nnsk = NNSK( + + def viz(self, atom_a:str, atom_b:str=None, show_int=True, r_min:Union[float, int]=None, r_max:Union[float, int]=None, nsample=100): + with torch.no_grad(): + if atom_b is None: + atom_b = atom_a + bond_type = f"{atom_a}-{atom_b}" + bond_index = torch.tensor([self.idp_sk.bond_types.index(bond_type)]) + self.curr_bond_indices = bond_index + if r_min is None and r_max is None: + assert self.r_min is not None and self.r_max is not None, "When both r_min and r_max are None. cal_rcuts=True when initializing the DFTB2NNSK object." + r_min_ = self.r_min[bond_index] + r_max_ = self.r_max[bond_index] + else: + assert r_min is not None and r_max is not None, "bothr_min and r_max should be provided or both None." + r_min_ = r_min + r_max_ = r_max + + r = torch.linspace(0, 1, steps=100).reshape(1,-1).repeat(len(self.curr_bond_indices),1) * (r_max_ - r_min_) + r_min_ + + hops = vmap(self.step,in_dims=1)(r) + + dftb_hopping = self.dftb(r, bond_indices = self.curr_bond_indices, mode="hopping").permute(1,0,2) + dftb_overlap = self.dftb(r, bond_indices = self.curr_bond_indices, mode="overlap").permute(1,0,2) + + r = r.numpy() + fig = plt.figure(figsize=(6,4)) + # hops[0] shape - [n_r, n_edge, n_skintegrals] + + if not show_int: + # hops[0].shape[1] == 1, since we only plot one bond type. + for i in range(hops[0].shape[1]): + plt.plot(r[i], hops[0][:,i, :-1].detach().numpy(), c="C"+str(i)) + plt.plot(r[i], hops[0][:,i, -1].detach().numpy(), c="C"+str(i),label="nn:"+bond_type) + plt.plot(r[i], dftb_hopping[:,i, :-1].numpy(), c="C"+str(i), linestyle="--") + plt.plot(r[i], dftb_hopping[:,i, -1].numpy(), c="C"+str(i), linestyle="--",label="skf:"+bond_type) + plt.title("hoppings") + plt.xlabel("r(angstrom)") + plt.tight_layout() + plt.legend() + plt.savefig(f"{self.output}/hopping_{bond_type}.png") + plt.show() + + fig = plt.figure(figsize=(6,4)) + for i in range(hops[1].shape[1]): + plt.plot(r[i], hops[1][:,i, :-1].detach().numpy(), c="C"+str(i)) + plt.plot(r[i], hops[1][:,i, -1].detach().numpy(), c="C"+str(i),label="nn:"+bond_type) + plt.plot(r[i], dftb_overlap[:,i, :-1].numpy(), c="C"+str(i), linestyle="--") + plt.plot(r[i], dftb_overlap[:,i, -1].numpy(), c="C"+str(i), linestyle="--",label="skf:"+bond_type) + plt.title("overlaps") + plt.xlabel("r(angstrom)") + plt.tight_layout() + plt.legend() + plt.savefig(f"{self.output}/overlap_{bond_type}.png") + plt.show() + else: + assert hops[0].shape[1] ==1 + hopps = hops[0][:,0,:].detach().numpy() + dftb_hopps = dftb_hopping[:,0,:].numpy() + fig = plt.figure(figsize=(6,4)) + ic=-1 + for k, v in self.idp_sk.orbpairtype_maps.items(): + hopps_ibt = hopps[:, v] + dftb_hopps_ibt = dftb_hopps[:, v] + for ii in range(hopps_ibt.shape[1]): + ic+=1 + plt.plot(r[0], hopps_ibt[:,ii], c="C"+str(ic), label=f"nn:{k}-{ii}") + plt.plot(r[0], dftb_hopps_ibt[:,ii], c="C"+str(ic), linestyle="--") + + plt.title("hoppings") + plt.xlabel("r(angstrom)") + plt.tight_layout() + plt.legend(ncol=2) + plt.savefig(f"{self.output}/hopping_{bond_type}.png") + plt.show() + + ovlps = hops[1][:,0,:].detach().numpy() + dftb_ovlps = dftb_overlap[:,0,:].numpy() + fig = plt.figure(figsize=(6,4)) + ic=-1 + for k, v in self.idp_sk.orbpairtype_maps.items(): + ovlps_ibt = ovlps[:, v] + dftb_ovlps_ibt = dftb_ovlps[:, v] + for ii in range(ovlps_ibt.shape[1]): + ic+=1 + plt.plot(r[0], ovlps_ibt[:,ii], c="C"+str(ic), label=f"nn:{k}-{ii}") + plt.plot(r[0], dftb_ovlps_ibt[:,ii], c="C"+str(ic), linestyle="--") + + plt.title("overlaps") + plt.xlabel("r(angstrom)") + plt.tight_layout() + plt.legend(ncol=2) + plt.savefig(f"{self.output}/overlap_{bond_type}.png") + plt.show() + return True + + + def to_nnsk(self, ebase=False): + if ebase: + self.nnsk = NNSK( idp_sk=self.dftb.idp_sk, onsite={"method": "uniform"}, hopping={"method": self.functype, "rs":self.rs, "w": self.w}, overlap=True, + atomic_radius = self.atomic_radius, + device=self.device, + dtype=self.dtype ) - - nnsk.hopping_param.data = self.hopping_params.data - nnsk.overlap_param.data = self.overlap_params.data - nnsk.onsite_param.data = self.dftb.param["OnsiteE"] - self.E_base[torch.arange(len(self.idp_sk.type_names))].unsqueeze(-1) + self.nnsk.hopping_param.data = self.hopping_params.data + self.nnsk.overlap_param.data = self.overlap_params.data - return nnsk - + self.E_base = torch.zeros(self.idp_sk.num_types, self.idp_sk.n_onsite_Es) + for asym, idx in self.idp_sk.chemical_symbol_to_type.items(): + self.E_base[idx] = torch.zeros(self.idp_sk.n_onsite_Es) + for ot in self.idp_sk.basis[asym]: + fot = self.idp_sk.basis_to_full_basis[asym][ot] + self.E_base[idx][self.idp_sk.skonsite_maps[fot+"-"+fot]] = onsite_energy_database[asym][ot] + + self.nnsk.onsite_param.data = self.dftb.param["OnsiteE"] - self.E_base[torch.arange(len(self.idp_sk.type_names))].unsqueeze(-1) + + else: + self.nnsk = NNSK( + idp_sk=self.dftb.idp_sk, + onsite={"method": "uniform_noref"}, + hopping={"method": self.functype, "rs":self.rs, "w": self.w}, + overlap=True, + atomic_radius = self.atomic_radius, + device=self.device, + dtype=self.dtype + ) + + self.nnsk.hopping_param.data = self.hopping_params.data + self.nnsk.overlap_param.data = self.overlap_params.data + self.nnsk.onsite_param.data = self.dftb.param["OnsiteE"] + + return self.nnsk + + def to_pth(self): + if not hasattr(self, "nnsk"): + self.to_nnsk() + self.nnsk.save(f"{self.output}/nnsk_from_skf.pth") + + return True + def to_json(self): - nnsk = self.to_nnsk() - return nnsk.to_json() \ No newline at end of file + if not hasattr(self, "nnsk"): + self.to_nnsk() + return self.nnsk.to_json() + + @staticmethod + def truncated_normal(shape, min_val, max_val, stdsigma=2,device='cpu', dtype=torch.float32): + min_val = torch.as_tensor(min_val, device=device, dtype=dtype) + max_val = torch.as_tensor(max_val, device=device, dtype=dtype) + + mean = (min_val + max_val) / 2 + #mean = (2 * min_val + mean) / 2 + std = (max_val - min_val) / (2 * stdsigma) + u = torch.rand(shape, device=device, dtype=dtype) + cdf_low = torch.erf((min_val - mean) / (std * 2.0**0.5)) / 2.0 + 0.5 + cdf_high = torch.erf((max_val - mean) / (std * 2.0**0.5)) / 2.0 + 0.5 + return torch.erfinv(2 * (cdf_low + u * (cdf_high - cdf_low)) - 1) * (2**0.5) * std + mean \ No newline at end of file diff --git a/dptb/nn/dftb2nnsk_bak.py b/dptb/nn/dftb2nnsk_bak.py new file mode 100644 index 00000000..f4655749 --- /dev/null +++ b/dptb/nn/dftb2nnsk_bak.py @@ -0,0 +1,185 @@ +from dptb.nn.dftb.sk_param import SKParam +from dptb.nn.dftb.hopping_dftb import HoppingIntp +import torch +from dptb.nn.sktb.hopping import HoppingFormula +from dptb.nn.sktb import OnsiteFormula, bond_length_list +from functorch import vmap +import matplotlib.pyplot as plt +from torch.optim import Adam, LBFGS, RMSprop, SGD +from torch.optim.lr_scheduler import ExponentialLR +from dptb.nn.nnsk import NNSK +from dptb.nn.sktb.onsite import onsite_energy_database +import numpy as np + +class dftb: + def __init__(self, basis, skdata): + self.param = SKParam(basis=basis, skdata=skdata) + self.idp_sk = self.param.idp_sk + self.param = self.param.format_skparams(self.param.skdict) + self.hopping = HoppingIntp(num_ingrls=self.param["Hopping"].shape[1]) + self.overlap = HoppingIntp(num_ingrls=self.param["Overlap"].shape[1]) + + def __call__(self, r, mode="hopping"): + out = [] + for i in range(len(self.idp_sk.bond_types)): + out.append(self.hopping.get_skhij(rij=r, xx=self.param["Distance"], yy=self.param[mode[0].upper()+mode[1:]][i])) + return torch.stack(out) + +class DFTB2NNSK: + def __init__(self, basis, skdata, functype, rs, w): + self.dftb = dftb(basis=basis, skdata=skdata) + self.functype = functype + self.idp_sk = self.dftb.idp_sk + self.rs = rs + self.w = w + + self.nnsk_hopping = HoppingFormula(functype=self.functype) + self.nnsk_overlap = HoppingFormula(functype=self.functype, overlap=True) + self.hopping_params = torch.nn.Parameter(torch.randn(len(self.idp_sk.bond_types), self.dftb.hopping.num_ingrls, self.nnsk_hopping.num_paras)) + self.overlap_params = torch.nn.Parameter(torch.randn(len(self.idp_sk.bond_types), self.dftb.hopping.num_ingrls, self.nnsk_hopping.num_paras)) + self.E_base = torch.zeros(self.idp_sk.num_types, self.idp_sk.n_onsite_Es) + for asym, idx in self.idp_sk.chemical_symbol_to_type.items(): + self.E_base[idx] = torch.zeros(self.idp_sk.n_onsite_Es) + for ot in self.idp_sk.basis[asym]: + fot = self.idp_sk.basis_to_full_basis[asym][ot] + self.E_base[idx][self.idp_sk.skonsite_maps[fot+"-"+fot]] = onsite_energy_database[asym][ot] + + def symmetrize(self): + reflective_bonds = np.array([self.idp_sk.bond_to_type["-".join(self.idp_sk.type_to_bond[i].split("-")[::-1])] for i in range(len(self.idp_sk.bond_types))]) + params = self.hopping_params.data + reflect_params = params[reflective_bonds] + for k in self.idp_sk.orbpair_maps.keys(): + iorb, jorb = k.split("-") + if iorb == jorb: + # This is to keep the symmetry of the hopping parameters for the same orbital pairs + # As-Bs = Bs-As; we need to do this because for different orbital pairs, we only have one set of parameters, + # eg. we only have As-Bp and Bs-Ap, but not Ap-Bs and Bp-As; and we will use Ap-Bs = Bs-Ap and Bp-As = As-Bp to calculate the hopping integral + self.hopping_params.data[:,self.idp_sk.orbpair_maps[k],:] = 0.5 * (params[:,self.idp_sk.orbpair_maps[k],:] + reflect_params[:,self.idp_sk.orbpair_maps[k],:]) + + params = self.overlap_params.data + reflect_params = params[reflective_bonds] + for k in self.idp_sk.orbpair_maps.keys(): + iorb, jorb = k.split("-") + if iorb == jorb: + self.overlap_params.data[:,self.idp_sk.orbpair_maps[k],:] = 0.5 * (params[:,self.idp_sk.orbpair_maps[k],:] + reflect_params[:,self.idp_sk.orbpair_maps[k],:]) + + return True + + def step(self, r): + + if r.reshape(-1).shape[0] == 1: + r = r.reshape(-1) + r = r.repeat(len(self.idp_sk.bond_types)) + edge_number = self.idp_sk.untransform_bond(torch.arange(len(self.idp_sk.bond_types))).T + r0 = 0.5*bond_length_list[edge_number-1].sum(0) + + hopping = self.nnsk_hopping.get_skhij( + rij=r, + paraArray=self.hopping_params, # [N_edge, n_pairs, n_paras], + rs=self.rs, + w=self.w, + r0=r0 + ) # [N_edge, n_pairs] + + overlap = self.nnsk_overlap.get_skhij( + rij=r, + paraArray=self.overlap_params, # [N_edge, n_pairs, n_paras], + rs=self.rs, + w=self.w, + r0=r0 + ) + + return hopping, overlap + + def viz(self, r_min=1.5, r_max=5.0): + with torch.no_grad(): + r = torch.linspace(r_min,r_max, steps=100) + hops = vmap(self.step)(r.reshape(-1,1)) + + + dftb_hopping = self.dftb(r, mode="hopping").permute(1,0,2) + dftb_overlap = self.dftb(r, mode="overlap").permute(1,0,2) + + r = r.numpy() + fig = plt.figure(figsize=(6,4)) + # hops[0] shape - [n_r, n_edge, n_skintegrals] + + for i in range(hops[0].shape[1]): + plt.plot(r, hops[0][:,i, :-1].detach().numpy(), c="C"+str(i)) + plt.plot(r, hops[0][:,i, -1].detach().numpy(), c="C"+str(i)) + plt.plot(r, dftb_hopping[:,i, :-1].numpy(), c="C"+str(i), linestyle="--") + plt.plot(r, dftb_hopping[:,i, -1].numpy(), c="C"+str(i), linestyle="--") + plt.title("hoppings") + plt.xlabel("r(angstrom)") + plt.tight_layout() + # plt.legend() + plt.show() + + fig = plt.figure(figsize=(6,4)) + for i in range(hops[1].shape[1]): + plt.plot(r, hops[1][:,i, :-1].detach().numpy(), c="C"+str(i)) + plt.plot(r, hops[1][:,i, -1].detach().numpy(), c="C"+str(i)) + plt.plot(r, dftb_overlap[:,i, :-1].numpy(), c="C"+str(i), linestyle="--") + plt.plot(r, dftb_overlap[:,i, -1].numpy(), c="C"+str(i), linestyle="--") + plt.title("overlaps") + plt.xlabel("r(angstrom)") + plt.tight_layout() + # plt.legend() + plt.show() + + def optimize(self, r_min=1.5, r_max=5.0, nsample=256, nstep=40000, lr=1e-1, dis_freq=1000, method="RMSprop", viz=False): + if method=="RMSprop": + optimizer = RMSprop([self.hopping_params, self.overlap_params], lr=lr, momentum=0.2) + elif method=="LBFGS": + optimizer = LBFGS([self.hopping_params, self.overlap_params], lr=lr) + else: + raise NotImplementedError + + lrscheduler = ExponentialLR(optimizer, gamma=0.9998) + self.loss = torch.tensor(0.) + + def closure(): + optimizer.zero_grad() + r = torch.rand(nsample) * (r_max - r_min) + r_min + hopping, overlap = vmap(self.step)(r.reshape(-1,1)) + + dftb_hopping = self.dftb(r, mode="hopping").permute(1,0,2) + dftb_overlap = self.dftb(r, mode="overlap").permute(1,0,2) + + + self.loss = (hopping - dftb_hopping).abs().mean() + \ + torch.nn.functional.mse_loss(hopping, dftb_hopping).sqrt() + \ + 15*torch.nn.functional.mse_loss(overlap, dftb_overlap).sqrt() + \ + 15*(overlap - dftb_overlap).abs().mean() + self.loss.backward() + return self.loss + + for istep in range(nstep): + if istep % dis_freq == 0: + print(f"step {istep}, loss {self.loss.item()}, lr {lrscheduler.get_last_lr()[0]}") + + optimizer.step(closure) + lrscheduler.step() + self.symmetrize() + if viz: + self.viz(r_min=r_min, r_max=r_max) + return True + + def to_nnsk(self): + nnsk = NNSK( + idp_sk=self.dftb.idp_sk, + onsite={"method": "uniform"}, + hopping={"method": self.functype, "rs":self.rs, "w": self.w}, + overlap=True, + ) + + + nnsk.hopping_param.data = self.hopping_params.data + nnsk.overlap_param.data = self.overlap_params.data + nnsk.onsite_param.data = self.dftb.param["OnsiteE"] - self.E_base[torch.arange(len(self.idp_sk.type_names))].unsqueeze(-1) + + return nnsk + + def to_json(self): + nnsk = self.to_nnsk() + return nnsk.to_json() \ No newline at end of file diff --git a/dptb/nn/dftbsk.py b/dptb/nn/dftbsk.py index ad812c28..958eaa24 100644 --- a/dptb/nn/dftbsk.py +++ b/dptb/nn/dftbsk.py @@ -88,8 +88,11 @@ def __init__( strain=False,soc=False) if overlap: self.overlap = SKHamiltonian(idp_sk=self.idp_sk, onsite=True, edge_field=AtomicDataDict.EDGE_OVERLAP_KEY, node_field=AtomicDataDict.NODE_OVERLAP_KEY, dtype=self.dtype, device=self.device) + # 这里是为了解决当轨道中包含多个相同 l 的轨道时,overlap 也具有数值。比如 1s-2s之间的overlap. 一般对于 dftb的参数spd 轨道没有这一项,此时all(self.idp_sk.mask_diag) 为True。 + # 当 not all(self.idp_sk.mask_diag) 时。其实这里变成可训练参数也不合适,毕竟这里是直接对接DFTB参数,是不会进行训练的。不过这里这么暂时放着吧。遇到再说。 overlaponsite_param = torch.ones([len(self.idp_sk.type_names), self.idp_sk.n_onsite_Es, 1], dtype=self.dtype, device=self.device) if not all(self.idp_sk.mask_diag): + log.warning('In dftbsk model, there are multi-orbital with the same angular momentum l, hence there will be overlap between the orbitals. but the implementation is not full supported!') self.overlaponsite_param = torch.nn.Parameter(overlaponsite_param) else: self.overlaponsite_param = overlaponsite_param diff --git a/dptb/nn/nnsk.py b/dptb/nn/nnsk.py index 52207fe9..4069c0b5 100644 --- a/dptb/nn/nnsk.py +++ b/dptb/nn/nnsk.py @@ -13,12 +13,14 @@ import numpy as np import torch.nn as nn from .sktb import OnsiteFormula, bond_length_list, HoppingFormula +from dptb.nn.sktb.cov_radiiDB import Covalent_radii +from dptb.nn.sktb.bondlengthDB import atomic_radius_v1 from dptb.utils.constants import atomic_num_dict_r, atomic_num_dict from dptb.nn.hamiltonian import SKHamiltonian from dptb.utils.tools import j_loader from dptb.utils.constants import ALLOWED_VERSIONS from dptb.nn.sktb.soc import SOCFormula - +from dptb.data.AtomicData import get_r_map, get_r_map_bondwise import logging log = logging.getLogger(__name__) @@ -39,6 +41,7 @@ def __init__( freeze: Union[bool,str,list] = False, push: Union[bool,dict]=False, std: float = 0.01, + atomic_radius: Union[str, Dict] = "v1", **kwargs, ) -> None: @@ -65,6 +68,7 @@ def __init__( self.hopping_options = hopping self.soc_options = soc self.push = push + self.atomic_radius = atomic_radius self.model_options = { "nnsk":{ "onsite": onsite, @@ -72,10 +76,25 @@ def __init__( "soc": soc, "freeze": freeze, "push": push, - "std": std + "std": std, + "atomic_radius":atomic_radius } } + if atomic_radius == "v1": + atomic_radius_dict = atomic_radius_v1 + elif atomic_radius == "cov": + atomic_radius_dict = Covalent_radii + else: + raise ValueError(f"The atomic radius {atomic_radius} is not recognized.") + + + atomic_numbers = [atomic_num_dict[key] for key in self.basis.keys()] + self.atomic_radius_list = torch.zeros(int(max(atomic_numbers))) - 100 + for at in self.basis.keys(): + assert atomic_radius_dict[at] is not None, f"The atomic radius for {at} is not provided." + self.atomic_radius_list[atomic_num_dict[at]-1] = atomic_radius_dict[at] + if self.soc_options.get("method", None) is not None: self.idp_sk.get_sksoc_maps() @@ -108,7 +127,7 @@ def __init__( if self.soc_options.get("method", None) is not None: if self.soc_options.get("method", None) == 'none': self.soc_param = None - elif self.soc_options.get("method", None) == 'uniform': + elif self.soc_options.get("method", None) in ['uniform', 'uniform_noref']: soc_param = torch.empty([len(self.idp_sk.type_names), self.idp_sk.n_onsite_socLs, self.soc_fn.num_paras], dtype=self.dtype, device=self.device) nn.init.normal_(soc_param, mean=0.0, std=std) self.soc_param = torch.nn.Parameter(soc_param) @@ -119,7 +138,7 @@ def __init__( self.onsite_param = None elif self.onsite_options["method"] == "none": self.onsite_param = None - elif self.onsite_options["method"] in ["NRL", "uniform"]: + elif self.onsite_options["method"] in ["NRL", "uniform", "uniform_noref"]: onsite_param = torch.empty([len(self.idp_sk.type_names), self.idp_sk.n_onsite_Es, self.onsite_fn.num_paras], dtype=self.dtype, device=self.device) nn.init.normal_(onsite_param, mean=0.0, std=std) self.onsite_param = torch.nn.Parameter(onsite_param) @@ -145,7 +164,21 @@ def __init__( if freeze: self.freezefunc(freeze) - + + self.check_push(push) + + if isinstance (self.hopping_options['rs'], dict): + first_key = next(iter(self.hopping_options['rs'].keys())) + key_parts = first_key.split("-") + if len(key_parts) == 1: # atom-wise rs eg. {'A': 3.0,...} + self.r_map = get_r_map(self.hopping_options['rs']) + self.r_map_type = 1 # 1 for atom-wise + elif len(key_parts) == 2: # bond-wise rs eg. {'A-B': 3.0,...} + self.r_map = get_r_map_bondwise(self.hopping_options['rs']) + self.r_map_type = 2 # 2 for bond-wise + else: + raise ValueError("The rs tag is not recognized. Please check the rs tag.") + def freezefunc(self, freeze: Union[bool,str,list]): if freeze is False: return 0 @@ -194,6 +227,29 @@ def freezefunc(self, freeze: Union[bool,str,list]): if len(frozen_params)!=len(dict(self.named_parameters()).keys()): raise ValueError("freeze is True, all parameters should frozen. But the frozen_params != all model.named_parameters. Please check the freeze tag.") log.info(f'The {frozen_params} are frozen!') + + # add check for push: + def check_push(self, push: Dict): + self.if_push = False + if push is not None and push is not False: + if abs(push.get("rs_thr")) + abs(push.get("rc_thr")) + abs(push.get("w_thr")) + abs(push.get("ovp_thr",0)) > 0: + self.if_push = True + + if self.if_push: + if abs(push.get("rs_thr")) >0: + if isinstance(self.hopping_options["rs"], dict): + log.error(f"rs is a dict, so cannot be decayed. Please provide a float or int for rs.") + + if abs(push.get("rc_thr")) >0: + if isinstance(self.hopping_options["rc"], dict): + log.error(f"rc is a dict, so cannot be decayed. Please provide a float or int for rc.") + raise ValueError("rc is a dict, so cannot be decayed. Please provide a float or int for rc.") + + if abs(push.get("ovp_thr",0)) > 0: + if push.get("ovp_thr",0) > 0: + log.error(f"ovp_thr is positive, which means the ovp_factor will be increased. This is not allowed in the push mode.") + raise ValueError("ovp_thr is positive, which means the ovp_factor will be increased. This is not allowed in the push mode.") + def push_decay(self, rs_thr: float=0., rc_thr: float=0., w_thr: float=0., ovp_thr: float=0., period:int=100): """Push the soft cutoff function @@ -214,9 +270,13 @@ def push_decay(self, rs_thr: float=0., rc_thr: float=0., w_thr: float=0., ovp_th self.hopping_options["w"] += w_thr if abs(rc_thr) > 0: self.hopping_options["rc"] += rc_thr - if abs(ovp_thr) > 0 and self.ovp_factor >= abs(ovp_thr): - self.ovp_factor += ovp_thr - log.info(f"ovp_factor is decreased to {self.ovp_factor}") + if abs(ovp_thr) > 0 : + if self.ovp_factor >= abs(ovp_thr): + self.ovp_factor += ovp_thr + log.info(f"ovp_factor is decreased to {self.ovp_factor}") + else: + log.info(f"ovp_factor is already less than {abs(ovp_thr)}, so not decreased.") + self.model_options["nnsk"]["hopping"] = self.hopping_options def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type: @@ -228,9 +288,9 @@ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type: # return the data with updated edge/node features # map the parameters to the edge/node/env features # compute integrals from parameters using hopping and onsite clas - if self.push is not None and self.push is not False: - if abs(self.push.get("rs_thr")) + abs(self.push.get("rc_thr")) + abs(self.push.get("w_thr")) + abs(self.push.get("ovp_thr",0)) > 0: - self.push_decay(**self.push) + + if self.if_push: + self.push_decay(**self.push) reflective_bonds = np.array([self.idp_sk.bond_to_type["-".join(self.idp_sk.type_to_bond[i].split("-")[::-1])] for i in range(len(self.idp_sk.bond_types))]) params = self.hopping_param.data @@ -265,13 +325,27 @@ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type: # The bond length list is actually the nucli radius (unit of angstrom) at the atomic number. # now this bond length list is only available for the first 83 elements. # assert (edge_number <= 83).all(), "The bond length list is only available for the first 83 elements." - r0 = 0.5*bond_length_list.type(self.dtype).to(self.device)[edge_number-1].sum(0) + # r0 = 0.5*bond_length_list.type(self.dtype).to(self.device)[edge_number-1].sum(0) + # r0 = self.atomic_radius_list[edge_number-1].sum(0) # bond length r0 = r1 + r2. (r1, r2 are atomic radii of the two atoms) + r0 = self.atomic_radius_list.type(self.dtype).to(self.device)[edge_number-1].sum(0) assert (r0 > 0).all(), "The bond length list is only available for atomic numbers < 84 and excluding the lanthanides." + + hopping_options = self.hopping_options.copy() + if isinstance (self.hopping_options['rs'], dict): + if self.r_map_type == 1: + rs_edgewise = 0.5*self.r_map[edge_number-1].sum(0) + elif self.r_map_type == 2: + rs_edgewise = self.r_map[edge_number[0]-1, edge_number[1]-1] + else: + raise ValueError(f"r_map_type {self.r_map_type} is not recognized.") + + hopping_options['rs'] = rs_edgewise + data[AtomicDataDict.EDGE_FEATURES_KEY] = self.hopping_fn.get_skhij( rij=data[AtomicDataDict.EDGE_LENGTH_KEY], paraArray=self.hopping_param[edge_index], # [N_edge, n_pairs, n_paras], - **self.hopping_options, + **hopping_options, r0=r0 ) # [N_edge, n_pairs] @@ -289,7 +363,7 @@ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type: rij=data[AtomicDataDict.EDGE_LENGTH_KEY], paraArray=self.overlap_param[edge_index], paraconst=paraconst, - **self.hopping_options, + **hopping_options, r0=r0, ) @@ -329,7 +403,8 @@ def forward(self, data: AtomicDataDict.Type) -> AtomicDataDict.Type: # onsitenv_params = torch.cat([self.strain_param, # reflect_params], dim=0) - r0 = 0.5*bond_length_list.type(self.dtype).to(self.device)[onsitenv_number-1].sum(0) + # r0 = 0.5*bond_length_list.type(self.dtype).to(self.device)[onsitenv_number-1].sum(0) + r0 = self.atomic_radius_list.type(self.dtype).to(self.device)[onsitenv_number-1].sum(0) # bond length r0 = r1 + r2. (r1, r2 are atomic radii of the two atoms) assert (r0 > 0).all(), "The bond length list is only available for atomic numbers < 84 and excluding the lanthanides." onsitenv_params = self.hopping_fn.get_skhij( rij=data[AtomicDataDict.ONSITENV_LENGTH_KEY], @@ -378,6 +453,7 @@ def from_reference( freeze: Union[bool,str,list] = False, std: float = 0.01, transform: bool = True, + atomic_radius: Union[str, Dict] = None, **kwargs, ): # the mapping from the parameters of the ref_model and the current model can be found using @@ -396,7 +472,8 @@ def from_reference( "soc": soc, "freeze": freeze, "push": push, - "std": std + "std": std, + "atomic_radius": atomic_radius } @@ -428,7 +505,10 @@ def from_reference( for k,v in nnsk.items(): if k != 'push' and v is None: if json_model.get("model_options",{}).get("nnsk",{}).get(k, None) is None: - raise ValueError(f"{k} is not provided in both the json model file and the input json.") + if k=='atomic_radius': + nnsk[k] = 'v1' + else: + raise ValueError(f"{k} is not provided in both the json model file and the input json.") else: nnsk[k] = json_model["model_options"]["nnsk"][k] log.info(f"{k} is not provided in the input json, set to the value {nnsk[k]}in the json model file.") @@ -527,7 +607,10 @@ def from_reference( log.info(f"{k} is not provided in the input json, set to the value {common_options[k]} in model ckpt.") for k,v in nnsk.items(): if v is None and k != "push" : - nnsk[k] = f["config"]["model_options"]["nnsk"][k] + if k=='atomic_radius' and f["config"]["model_options"]["nnsk"].get(k, None) is None: + nnsk[k] = 'v1' + else: + nnsk[k] = f["config"]["model_options"]["nnsk"][k] log.info(f"{k} is not provided in the input json, set to the value {nnsk[k]} in model ckpt.") model = cls(**common_options, **nnsk, transform=transform) @@ -669,6 +752,7 @@ def _from_model_v1( freeze: Union[bool,str,list] = False, push: Union[bool,None,dict] = False, transform: bool = True, + atomic_radius: Union[str, Dict] = None, **kwargs ): # could support json file and .pth file checkpoint of nnsk @@ -697,7 +781,8 @@ def _from_model_v1( log.warning("CUDA is not available. The model will be loaded on CPU.") nnsk_model = cls(basis=basis, idp_sk=idp_sk, onsite=onsite, - hopping=hopping, overlap=overlap, soc=soc, std=std,freeze=freeze, push=push, dtype=dtype, device=device) + hopping=hopping, overlap=overlap, soc=soc, std=std,freeze=freeze, push=push, dtype=dtype, device=device, + atomic_radius=atomic_radius, transform=transform) onsite_param = v1_model["onsite"] hopping_param = v1_model["hopping"] @@ -844,6 +929,19 @@ def _from_model_v1( return nnsk_model + def save(self,filepath): + obj = {} + model_options=self.model_options + common_options={ + "basis":self.basis, + "overlap":hasattr(self, "overlap_param"), + "dtype":self.dtype, + "device":self.device + } + obj.update({"config": {"model_options": model_options, "common_options": common_options}}) + obj.update({"model_state_dict": self.state_dict()}) + torch.save(obj, f=filepath) + def to_json(self,version=2): ckpt = {} # load hopping params diff --git a/dptb/nn/sktb/bondlengthDB.py b/dptb/nn/sktb/bondlengthDB.py index 996ab3cd..a9316412 100644 --- a/dptb/nn/sktb/bondlengthDB.py +++ b/dptb/nn/sktb/bondlengthDB.py @@ -27,7 +27,7 @@ 5.2,5.2,6.2,5.2,10.6,7.7,7.4,5.9,5.2,4.8,4.2,4.2,4.0,3.9,3.8,4.8,6.7, 7.3,5.7,5.8]) -bond_length_list = torch.tensor([1.6, 1.4, 5.0, 3.4, 3.0, 3.2, 3.4, 3.1, 2.7, 3.2, 5.9, 5.0, 5.9, 4.4, 4.0, 3.9, +bond_length_list_bohr = torch.tensor([1.6, 1.4, 5.0, 3.4, 3.0, 3.2, 3.4, 3.1, 2.7, 3.2, 5.9, 5.0, 5.9, 4.4, 4.0, 3.9, 3.8, 4.5, 6.5, 4.9, 5.1, 4.2, 4.3, 4.7, 3.6, 3.7, 3.3, 3.7, 5.2, 4.6, 5.9, 4.5, 4.4, 4.5, 4.3, 4.8, 9.1, 6.9, 5.7, 5.2, 5.2, 4.3, 4.1, 4.1, 4.0, 4.4, 6.5, 5.4, 4.8, 4.7, 5.2, 5.2, 6.2, 5.2, 10.6, 7.7, 7.4, -100, -100, -100, -100, -100, -100, @@ -45,6 +45,7 @@ 'W': 4.2, 'Re': 4.2, 'Os': 4.0, 'Ir': 3.9, 'Pt': 3.8, 'Au': 4.8, 'Hg': 6.7, 'Tl': 7.3, 'Pb': 5.7, 'Bi': 5.8, 'Po': 5.5, 'Ra': 7.0, 'Th': 6.2} +# unit bohr bond_length_full_dict = { 'H': 1.6, 'He': 1.4, 'Li': 5.0, 'Be': 3.4, 'B': 3.0, 'C': 3.2, 'N': 3.4, 'O': 3.1, 'F': 2.7, 'Ne': 3.2, @@ -54,3 +55,18 @@ 'Cs': 10.6, 'Ba': 7.7, 'La': 7.4, 'Ce': None, 'Pr': None, 'Nd': None, 'Pm': None, 'Sm': None, 'Eu': None, 'Gd': None, 'Tb': None, 'Dy': None, 'Ho': None, 'Er': None, 'Tm': None, 'Yb': None, 'Lu': 5.9, 'Hf': 5.2, 'Ta': 4.8, 'W': 4.2, 'Re': 4.2, 'Os': 4.0, 'Ir': 3.9, 'Pt': 3.8, 'Au': 4.8, 'Hg': 6.7, 'Tl': 7.3, 'Pb': 5.7, 'Bi': 5.8, 'Po': 5.5, 'At': None, 'Rn': None, 'Fr': None, 'Ra': 7.0, 'Ac': None, 'Th': 6.2, 'Pa': None, 'U': None, 'Np': None, 'Pu': None, 'Am': None, 'Cm': None, 'Bk': None, 'Cf': None, 'Es': None, 'Fm': None, 'Md': None, 'No': None, 'Lr': None, 'Rf': None, 'Db': None, 'Sg': None, 'Bh': None, 'Hs': None, 'Mt': None, 'Ds': None, 'Rg': None, 'Cn': None, 'Nh': None, 'Fl': None, 'Mc': None, 'Lv': None, 'Ts': None, 'Og': None } + +from dptb.utils.constants import atomic_num_dict +import torch + +# unit \AA +atomic_radius_v1 = {} +for k, v in bond_length_full_dict.items(): + if v is not None: + atomic_radius_v1[k] = v / 1.8897259886 / 2 + +# unit. \AA. +bond_length_list = torch.zeros(int(max(atomic_num_dict.values()))) - 100 +for k, v in bond_length_full_dict.items(): + if v is not None: + bond_length_list[atomic_num_dict[k]-1] = v / 1.8897259886 \ No newline at end of file diff --git a/dptb/nn/sktb/cov_radiiDB.py b/dptb/nn/sktb/cov_radiiDB.py new file mode 100644 index 00000000..e98a8948 --- /dev/null +++ b/dptb/nn/sktb/cov_radiiDB.py @@ -0,0 +1,37 @@ +# Covalent radii in pm from analysis of the Cambridge Structural Database, which contains about 1,030,000 crystal structures[4] +# The data is from the https://en.wikipedia.org/wiki/Covalent_radius +# For homonuclear A–A bonds, Linus Pauling took the covalent radius to be half the single-bond length in the element, e.g. R(H–H, in H2) = 74.14 pm so rcov(H) = 37.07 pm: +# in practice, it is usual to obtain an average value from a variety of covalent compounds, although the difference is usually small. +# Therefore the bandlength A-B we can use the sum of the covalent radii of A and B. + +# unit pm. +Covalent_radii_pm = { + 'H': 31, 'He': 28, + 'Li': 128, 'Be': 96, 'B': 84, 'C': 76, 'N': 71, 'O': 66, 'F': 57, 'Ne': 58, + 'Na': 166, 'Mg': 141, 'Al': 121, 'Si': 111, 'P': 107, 'S': 105, 'Cl': 102, 'Ar': 106, + 'K': 203, 'Ca': 176, 'Sc': 170, 'Ti': 160, 'V': 153, 'Cr': 139, 'Mn': 139, 'Fe': 132, 'Co': 126, 'Ni': 124, 'Cu': 132, 'Zn': 122, 'Ga': 122, 'Ge': 120, 'As': 119, 'Se': 120, 'Br': 120, 'Kr': 116, + 'Rb': 220, 'Sr': 195, 'Y': 190, 'Zr': 175, 'Nb': 164, 'Mo': 154, 'Tc': 147, 'Ru': 146, 'Rh': 142, 'Pd': 139, 'Ag': 145, 'Cd': 144, 'In': 142, 'Sn': 139, 'Sb': 139, 'Te': 138, 'I': 139, 'Xe': 140, + 'Cs': 244, 'Ba': 215, 'Lu': 187, 'Hf': 175, 'Ta': 170, 'W': 162, 'Re': 151, 'Os': 144, 'Ir': 141, 'Pt': 136, 'Au': 136, 'Hg': 132, 'Tl': 145, 'Pb': 146, 'Bi': 148, 'Po': 140, 'At': 150, 'Rn': 150, + 'Fr': 260, 'Ra': 221, + 'La': 207, 'Ce': 204, 'Pr': 203, 'Nd': 201, 'Pm': 199, 'Sm': 198, 'Eu': 198, 'Gd': 196, 'Tb': 194, 'Dy': 192, 'Ho': 192, 'Er': 189, 'Tm': 190, 'Yb': 187, + 'Ac': 215, 'Th': 206, 'Pa': 200, 'U': 196, 'Np': 190, 'Pu': 187, 'Am': 180, 'Cm': 169 +} + +# unit AA +Covalent_radii = {} +for k, v in Covalent_radii_pm.items(): + if v is not None: + Covalent_radii[k] = v * 0.01 + else: + Covalent_radii[k] = v + +# To constract the bond length, we can use the sum of the covalent radii of A and B. + + +from dptb.utils.constants import atomic_num_dict +import torch + +# unit. \AA. +R_cov_list = torch.zeros(int(max(atomic_num_dict.values()))) - 100 +for k, v in Covalent_radii_pm.items(): + R_cov_list[atomic_num_dict[k]-1] = v * 0.01 \ No newline at end of file diff --git a/dptb/nn/sktb/hopping.py b/dptb/nn/sktb/hopping.py index c18eaec6..885a05cc 100644 --- a/dptb/nn/sktb/hopping.py +++ b/dptb/nn/sktb/hopping.py @@ -29,6 +29,9 @@ class HoppingFormula(BaseHopping): 'poly2exp': 4, 'NRL0': 4, "NRL1": 4, + 'poly4pow':6, + 'poly3exp':5, + 'poly4exp':6, 'custom': None, } @@ -36,36 +39,16 @@ def __init__(self, functype='varTang96',overlap=False) -> None: super(HoppingFormula, self).__init__() # one can modify this by add his own formula with the name functype to deifine num of pars. self.overlap = overlap - if functype == 'varTang96': - assert hasattr(self, 'varTang96') - - elif functype == 'poly2exp': - assert hasattr(self, 'poly2exp') - - elif functype == 'poly1pow': - assert hasattr(self, 'poly1pow') - - elif functype == 'poly2pow': - assert hasattr(self, 'poly3pow') - - elif functype == 'poly3pow': - assert hasattr(self, 'poly3pow') - - elif functype == 'powerlaw': - assert hasattr(self, 'powerlaw') - - elif functype in ['NRL0', "NRL1"]: - assert hasattr(self, 'NRL_HOP') - if overlap: - assert hasattr(self, 'NRL_OVERLAP0') and hasattr(self, 'NRL_OVERLAP1') - - elif functype =='custom': - # the functype custom, is for user to define their own formula. - # just modify custom to the name of your formula. - # and define the funnction self.custom(rij, paraArray, **kwargs) - assert hasattr(self, 'custom') + if functype in self.num_paras_dict.keys(): + if functype in ['NRL0', 'NRL1']: + assert hasattr(self, 'NRL_HOP') + if overlap: + assert hasattr(self, 'NRL_OVERLAP0') and hasattr(self, 'NRL_OVERLAP1') + else: + assert hasattr(self, functype) else: - raise ValueError('No such formula') + raise ValueError(f'No such formula: {functype}') + self.functype = functype self.num_paras = self.num_paras_dict[functype] @@ -79,23 +62,16 @@ def get_skhij(self, rij, **kwargs): The function defined by functype is called to cal skhij and returned. ''' - - if self.functype == 'varTang96': - return self.varTang96(rij=rij, **kwargs) - elif self.functype == 'powerlaw': - return self.powerlaw(rij=rij, **kwargs) - elif self.functype == 'poly1pow': - return self.poly1pow(rij=rij, **kwargs) - elif self.functype == 'poly2pow': - return self.poly2pow(rij=rij, **kwargs) - elif self.functype == 'poly3pow': - return self.poly3pow(rij=rij, **kwargs) - elif self.functype == 'poly2exp': - return self.poly2exp(rij=rij, **kwargs) - elif self.functype.startswith('NRL'): - return self.NRL_HOP(rij=rij, **kwargs) + if self.functype.startswith('NRL'): + method_name = 'NRL_HOP' else: - raise ValueError('No such formula') + method_name = self.functype + + try: + method = getattr(self, method_name) + return method(rij=rij, **kwargs) + except AttributeError: + raise ValueError(f'No such formula: {self.functype}') def get_sksij(self,rij,**kwargs): '''This is a wrap function for a self-defined formula of sk overlap. one can easily modify it into whatever form they want. @@ -107,25 +83,16 @@ def get_sksij(self,rij,**kwargs): ''' assert self.overlap, 'overlap is False, no overlap function is defined.' - if self.functype == 'NRL0': - return self.NRL_OVERLAP0(rij=rij, **kwargs) - if self.functype == 'NRL1': - return self.NRL_OVERLAP1(rij=rij, **kwargs) - elif self.functype == "powerlaw": - return self.powerlaw(rij=rij, **kwargs) - elif self.functype == 'poly1pow': - return self.poly1pow(rij=rij, **kwargs) - elif self.functype == 'poly2pow': - return self.poly2pow(rij=rij, **kwargs) - elif self.functype == 'poly3pow': - return self.poly3pow(rij=rij, **kwargs) - elif self.functype == 'poly2exp': - return self.poly2exp(rij=rij, **kwargs) - elif self.functype == "varTang96": - return self.varTang96(rij=rij, **kwargs) + if self.functype in ['NRL0', 'NRL1']: + method_name = f'NRL_OVERLAP{self.functype[-1]}' else: - raise ValueError('No such formula') + method_name = self.functype + try: + method = getattr(self, method_name) + return method(rij=rij, **kwargs) + except AttributeError: + raise ValueError(f'No such formula: {self.functype}') def varTang96(self, rij: torch.Tensor, paraArray: torch.Tensor, rs:torch.Tensor = torch.tensor(6), w:torch.Tensor = 0.1, **kwargs): """> This function calculates the value of the variational form of Tang et al 1996. without the @@ -157,6 +124,10 @@ def varTang96(self, rij: torch.Tensor, paraArray: torch.Tensor, rs:torch.Tensor alpha1, alpha2, alpha3, alpha4 = paraArray[..., 0], paraArray[..., 1].abs(), paraArray[..., 2].abs(), paraArray[..., 3].abs() shape = [-1]+[1] * (len(alpha1.shape)-1) rij = rij.reshape(shape) + if isinstance(rs, torch.Tensor): + rs = rs.reshape(shape) + else: + assert isinstance(rs, (float, int)), 'rs should be a tensor or a float or int.' return alpha1 * rij**(-alpha2) * torch.exp(-alpha3 * rij**alpha4)/(1+torch.exp((rij-rs)/w)) def powerlaw(self, rij, paraArray, r0:torch.Tensor, rs:torch.Tensor = torch.tensor(6), w:torch.Tensor = 0.1, **kwargs): @@ -173,8 +144,11 @@ def powerlaw(self, rij, paraArray, r0:torch.Tensor, rs:torch.Tensor = torch.tens rij = rij.reshape(shape) r0 = r0.reshape(shape) - r0 = r0 / 1.8897259886 - + # r0 = r0 / 1.8897259886 + if isinstance(rs, torch.Tensor): + rs = rs.reshape(shape) + else: + assert isinstance(rs, (float, int)), 'rs should be a tensor or a float or int.' return alpha1 * (r0/rij)**(1 + alpha2) / (1+torch.exp((rij-rs)/w)) def poly1pow(self, rij, paraArray, r0:torch.Tensor, rs:torch.Tensor = torch.tensor(6), w:torch.Tensor = 0.1, **kwargs): @@ -191,8 +165,11 @@ def poly1pow(self, rij, paraArray, r0:torch.Tensor, rs:torch.Tensor = torch.tens rij = rij.reshape(shape) r0 = r0.reshape(shape) - r0 = r0 / 1.8897259886 - + # r0 = r0 / 1.8897259886 + if isinstance(rs, torch.Tensor): + rs = rs.reshape(shape) + else: + assert isinstance(rs, (float, int)), 'rs should be a tensor or a float or int.' # r_decay = w * rc # evlp = 0.5 * (torch.cos((torch.pi / (rc - r_decay)) * (rij.clamp(r_decay, rc) - r_decay)) + 1.0) f_rij = 1/(1+torch.exp((rij-rs+5*w)/w)) @@ -213,8 +190,11 @@ def poly2pow(self, rij, paraArray, r0:torch.Tensor, rs:torch.Tensor = torch.tens rij = rij.reshape(shape) r0 = r0.reshape(shape) - r0 = r0 / 1.8897259886 - + # r0 = r0 / 1.8897259886 + if isinstance(rs, torch.Tensor): + rs = rs.reshape(shape) + else: + assert isinstance(rs, (float, int)), 'rs should be a tensor or a float or int.' # r_decay = w * rc f_rij = 1/(1+torch.exp((rij-rs+5*w)/w)) @@ -234,14 +214,43 @@ def poly3pow(self, rij, paraArray, r0:torch.Tensor, rs:torch.Tensor = torch.tens rij = rij.reshape(shape) r0 = r0.reshape(shape) - r0 = r0 / 1.8897259886 - + # r0 = r0 / 1.8897259886 + if isinstance(rs, torch.Tensor): + rs = rs.reshape(shape) + else: + assert isinstance(rs, (float, int)), 'rs should be a tensor or a float or int.' # r_decay = w * rc # evlp = 0.5 * (torch.cos((torch.pi / (rc - r_decay)) * (rij.clamp(r_decay, rc) - r_decay)) + 1.0) f_rij = 1/(1+torch.exp((rij-rs+5*w)/w)) return (alpha1 + alpha2 * (rij-r0) + 0.5 * alpha3 * (rij - r0)**2 + 1/6 * alpha4 * (rij-r0)**3) * (r0/rij)**(1 + alpha5) * f_rij + + def poly4pow(self, rij, paraArray, r0:torch.Tensor, rs:torch.Tensor = torch.tensor(6), w:torch.Tensor = 0.1, **kwargs): + """> This function calculates SK integrals without the environment dependence of the form of powerlaw + + $$ h(rij) = alpha_1 * (rij / r_ij0)^(lambda + alpha_2) $$ + """ + + #alpha1, alpha2, alpha3, alpha4 = paraArray[:, 0], paraArray[:, 1]**2, paraArray[:, 2]**2, paraArray[:, 3]**2 + alpha1, alpha2, alpha3, alpha4, alpha5, alpha6 = paraArray[..., 0], paraArray[..., 1], paraArray[..., 2], paraArray[..., 3], paraArray[..., 4], paraArray[..., 5].abs() + #[N, n_op] + shape = [-1]+[1] * (len(alpha1.shape)-1) + # [-1, 1] + rij = rij.reshape(shape) + r0 = r0.reshape(shape) + + # r0 = r0 / 1.8897259886 + if isinstance(rs, torch.Tensor): + rs = rs.reshape(shape) + else: + assert isinstance(rs, (float, int)), 'rs should be a tensor or a float or int.' + # r_decay = w * rc + # evlp = 0.5 * (torch.cos((torch.pi / (rc - r_decay)) * (rij.clamp(r_decay, rc) - r_decay)) + 1.0) + f_rij = 1/(1+torch.exp((rij-rs+5*w)/w)) + + return (alpha1 + alpha2 * (rij-r0) + 0.5 * alpha3 * (rij - r0)**2 + 1/6 * alpha4 * (rij-r0)**3 + 1/8 * alpha5 * (rij-r0)**4) * (r0/rij)**(1 + alpha6) * f_rij + def poly2exp(self, rij, paraArray, r0:torch.Tensor, rs:torch.Tensor = torch.tensor(6), w:torch.Tensor = 0.1, **kwargs): """> This function calculates SK integrals without the environment dependence of the form of powerlaw @@ -256,12 +265,68 @@ def poly2exp(self, rij, paraArray, r0:torch.Tensor, rs:torch.Tensor = torch.tens rij = rij.reshape(shape) r0 = r0.reshape(shape) - r0 = r0 / 1.8897259886 + # r0 = r0 / 1.8897259886 + + if isinstance(rs, torch.Tensor): + rs = rs.reshape(shape) + else: + assert isinstance(rs, (float, int)), 'rs should be a tensor or a float or int.' f_rij = 1/(1+torch.exp((rij-rs+5*w)/w)) - return (alpha1 + alpha2 * (rij-r0) + alpha3 * (rij-r0)**2) * torch.exp(-rij * alpha4) * f_rij + return (alpha1 + alpha2 * (rij-r0) + 0.5 * alpha3 * (rij-r0)**2) * torch.exp(-rij * alpha4) * f_rij + + def poly3exp(self, rij, paraArray, r0:torch.Tensor, rs:torch.Tensor = torch.tensor(6), w:torch.Tensor = 0.1, **kwargs): + """> This function calculates SK integrals without the environment dependence of the form of powerlaw + $$ h(rij) = alpha_1 * (rij / r_ij0)^(lambda + alpha_2) $$ + """ + + #alpha1, alpha2, alpha3, alpha4 = paraArray[:, 0], paraArray[:, 1]**2, paraArray[:, 2]**2, paraArray[:, 3]**2 + alpha1, alpha2, alpha3, alpha4, alpha5 = paraArray[..., 0], paraArray[..., 1], paraArray[..., 2],paraArray[..., 3], paraArray[..., 4].abs() + #[N, n_op] + shape = [-1]+[1] * (len(alpha1.shape)-1) + # [-1, 1] + rij = rij.reshape(shape) + r0 = r0.reshape(shape) + + # r0 = r0 / 1.8897259886 + + if isinstance(rs, torch.Tensor): + rs = rs.reshape(shape) + else: + assert isinstance(rs, (float, int)), 'rs should be a tensor or a float or int.' + + f_rij = 1/(1+torch.exp((rij-rs+5*w)/w)) + + return (alpha1 + alpha2 * (rij-r0) + 0.5 * alpha3 * (rij-r0)**2 + 1/6 * alpha4 * (rij-r0)**3) * torch.exp(-rij * alpha5) * f_rij + + + def poly4exp(self, rij, paraArray, r0:torch.Tensor, rs:torch.Tensor = torch.tensor(6), w:torch.Tensor = 0.1, **kwargs): + """> This function calculates SK integrals without the environment dependence of the form of powerlaw + + $$ h(rij) = alpha_1 * (rij / r_ij0)^(lambda + alpha_2) $$ + """ + + #alpha1, alpha2, alpha3, alpha4 = paraArray[:, 0], paraArray[:, 1]**2, paraArray[:, 2]**2, paraArray[:, 3]**2 + alpha1, alpha2, alpha3, alpha4, alpha5, alpha6 = paraArray[..., 0], paraArray[..., 1], paraArray[..., 2], paraArray[..., 3], paraArray[..., 4], paraArray[..., 5].abs() + #[N, n_op] + shape = [-1]+[1] * (len(alpha1.shape)-1) + # [-1, 1] + rij = rij.reshape(shape) + r0 = r0.reshape(shape) + + # r0 = r0 / 1.8897259886 + if isinstance(rs, torch.Tensor): + rs = rs.reshape(shape) + else: + assert isinstance(rs, (float, int)), 'rs should be a tensor or a float or int.' + # r_decay = w * rc + # evlp = 0.5 * (torch.cos((torch.pi / (rc - r_decay)) * (rij.clamp(r_decay, rc) - r_decay)) + 1.0) + f_rij = 1/(1+torch.exp((rij-rs+5*w)/w)) + + return (alpha1 + alpha2 * (rij-r0) + 0.5 * alpha3 * (rij - r0)**2 + 1/6 * alpha4 * (rij-r0)**3 + 1/8 * alpha5 * (rij-r0)**4) * torch.exp(-rij * alpha6) * f_rij + def NRL_HOP(self, rij, paraArray, rs:torch.Tensor = torch.tensor(6), w:torch.Tensor = 0.1, **kwargs): """ This function calculates the SK integral value of the form of NRL-TB @@ -277,12 +342,18 @@ def NRL_HOP(self, rij, paraArray, rs:torch.Tensor = torch.tensor(6), w:torch.Ten a, b, c, d = paraArray[..., 0], paraArray[..., 1], paraArray[..., 2], paraArray[..., 3] shape = [-1]+[1] * (len(a.shape)-1) rij = rij.reshape(shape) + + if isinstance(rs, torch.Tensor): + rs = rs.reshape(shape) + else: + assert isinstance(rs, (float, int)), 'rs should be a tensor or a float or int.' + f_rij = 1/(1+torch.exp((rij-rs+5*w)/w)) # f_rij[rij>=rs] = 0.0 return (a + b * rij + c * rij**2) * torch.exp(-d**2 * rij)*f_rij - def NRL_OVERLAP0(self, rij, paraArray, paraconst, rs:torch.float32 = torch.tensor(6), w:torch.float32 = 0.1, **kwargs): + def NRL_OVERLAP0(self, rij, paraArray, paraconst, rs:torch.Tensor = torch.tensor(6), w:torch.Tensor = 0.1, **kwargs): """ This function calculates the Overlap value of the form of NRL-TB @@ -301,12 +372,15 @@ def NRL_OVERLAP0(self, rij, paraArray, paraconst, rs:torch.float32 = torch.tenso a, b, c, d = paraArray[..., 0], paraArray[..., 1], paraArray[..., 2], paraArray[..., 3] shape = [-1]+[1] * (len(a.shape)-1) rij = rij.reshape(shape) - + if isinstance(rs, torch.Tensor): + rs = rs.reshape(shape) + else: + assert isinstance(rs, (float, int)), 'rs should be a tensor or a float or int.' f_rij = 1/(1+torch.exp((rij-rs+5*w)/w)) return (a + b * rij + c * rij**2) * torch.exp(-d**2 * rij)*f_rij - def NRL_OVERLAP1(self, rij, paraArray, paraconst, rs:torch.float32 = torch.tensor(6), w:torch.float32 = 0.1, **kwargs): + def NRL_OVERLAP1(self, rij, paraArray, paraconst, rs:torch.Tensor = torch.tensor(6), w:torch.Tensor = 0.1, **kwargs): """ This function calculates the Overlap value of the form of NRL-TB @@ -326,7 +400,10 @@ def NRL_OVERLAP1(self, rij, paraArray, paraconst, rs:torch.float32 = torch.tenso delta_ll = paraconst shape = [-1]+[1] * (len(a.shape)-1) rij = rij.reshape(shape) - + if isinstance(rs, torch.Tensor): + rs = rs.reshape(shape) + else: + assert isinstance(rs, (float, int)), 'rs should be a tensor or a float or int.' f_rij = 1/(1+torch.exp((rij-rs+5*w)/w)) # f_rij[rij>=rc] = 0.0 diff --git a/dptb/nn/sktb/onsite.py b/dptb/nn/sktb/onsite.py index 08ca2273..30b9a10e 100644 --- a/dptb/nn/sktb/onsite.py +++ b/dptb/nn/sktb/onsite.py @@ -27,6 +27,7 @@ def get_skEs(self, **kwargs): class OnsiteFormula(BaseOnsite): num_paras_dict = { 'uniform': 1, + 'uniform_noref': 1, 'none': 0, 'strain': 0, "NRL": 4, @@ -47,7 +48,8 @@ def __init__( assert hasattr(self, 'none') elif functype == 'uniform': assert hasattr(self, 'uniform') - + elif functype == 'uniform_noref': + assert hasattr(self, 'uniform_noref') elif functype == 'NRL': assert hasattr(self, 'NRL') @@ -73,6 +75,8 @@ def __init__( def get_skEs(self, **kwargs): if self.functype == 'uniform': return self.uniform(**kwargs) + if self.functype == 'uniform_noref': + return self.uniform_noref(**kwargs) if self.functype == 'NRL': return self.NRL(**kwargs) if self.functype in ['none', 'strain']: @@ -142,7 +146,30 @@ def uniform(self, atomic_numbers: torch.Tensor, nn_onsite_paras: torch.Tensor, * idx = self.idp.transform_atom(atomic_numbers) return nn_onsite_paras[idx] + self.none(atomic_numbers=atomic_numbers) - + + def uniform_noref(self, atomic_numbers: torch.Tensor, nn_onsite_paras: torch.Tensor, **kwargs): + """The uniform onsite function, that have the same onsite energies for one specific orbital of a atom type. + + Parameters + ---------- + atomic_numbers : torch.Tensor(N) or torch.Tensor(N,1) + The atomic number list. + nn_onsite_paras : torch.Tensor(N_atom_type, n_orb) + The nn fitted parameters for onsite energies. + + Returns + ------- + torch.Tensor(N, n_orb) + the onsite energies by composing results from nn and ones from database. + """ + atomic_numbers = atomic_numbers.reshape(-1) + if nn_onsite_paras.shape[-1] == 1: + nn_onsite_paras = nn_onsite_paras.squeeze(-1) + + idx = self.idp.transform_atom(atomic_numbers) + + return nn_onsite_paras[idx] + def NRL(self, atomic_numbers, onsitenv_index, onsitenv_length, nn_onsite_paras, rs:th.float32 = th.tensor(6), w:th.float32 = 0.1, lda=1.0, **kwargs): """ This is NRL-TB formula for onsite energies. diff --git a/dptb/postprocess/elec_struc_cal.py b/dptb/postprocess/elec_struc_cal.py index 42f3d2ee..381ed804 100644 --- a/dptb/postprocess/elec_struc_cal.py +++ b/dptb/postprocess/elec_struc_cal.py @@ -89,6 +89,11 @@ def get_data(self,data: Union[AtomicData, ase.Atoms, str],pbc:Union[bool,list]=N ''' atomic_options = deepcopy(self.cutoffs) if pbc is not None: + # 这一句要结合后面AtomicData.from_ase(structase, **atomic_options) 看。在from_ase中 + # pbc = kwargs.pop("pbc", atoms.pbc), 所以当默认 调用get_dat 传入 pbc = None 时, + # atomic_options 中并没有 pbc 这个key,所以在from_ase中,pbc = atoms.pbc 默认采用atoms的pbc + # 当传入pbc 非None时,atomic_options中会有pbc这个key,所以from_ase中的pbc 将不会采用atoms的pbc。 + # 逻辑线埋的比较深,需要注意。 atomic_options.update({'pbc': pbc}) if AtomicData_options is not None: @@ -107,7 +112,12 @@ def get_data(self,data: Union[AtomicData, ase.Atoms, str],pbc:Union[bool,list]=N atomic_options['oer_max'] = AtomicData_options.get('oer_max') log.warning(f'Overwrite the oer_max setting in the model with the oer_max setting in the AtomicData_options: {AtomicData_options.get("oer_max")}') log.warning(f'This is very dangerous, please make sure you know what you are doing.') - + + else: + if atomic_options['r_max'] is None: + log.error('The r_max is not provided in model_options, please provide it in AtomicData_options.') + raise RuntimeError('The r_max is not provided in model_options, please provide it in AtomicData_options.') + if isinstance(data, str): structase = read(data) data = AtomicData.from_ase(structase, **atomic_options) diff --git a/dptb/tests/data/hBN/hBN_2_2.vasp b/dptb/tests/data/hBN/hBN_2_2.vasp new file mode 100644 index 00000000..0a7730bf --- /dev/null +++ b/dptb/tests/data/hBN/hBN_2_2.vasp @@ -0,0 +1,16 @@ +h-BN +1.0 + 5.0079998970 0.0000000000 0.0000000000 + -2.5039999485 4.3370551330 0.0000000000 + 0.0000000000 0.0000000000 30.0000000000 + N B + 4 4 +Direct + 0.166666672 0.333333343 0.500000000 + 0.166666672 0.833333373 0.500000000 + 0.666666687 0.333333343 0.500000000 + 0.666666687 0.833333373 0.500000000 + 0.333333313 0.166666657 0.500000000 + 0.333333313 0.666666627 0.500000000 + 0.833333313 0.166666657 0.500000000 + 0.833333313 0.666666627 0.500000000 diff --git a/dptb/tests/test_HoppingFormula.py b/dptb/tests/test_HoppingFormula.py index e76db9fd..ed938dae 100644 --- a/dptb/tests/test_HoppingFormula.py +++ b/dptb/tests/test_HoppingFormula.py @@ -73,7 +73,7 @@ def test_hopping_fn_powerlaw(self): rij = torch.tensor([2.5039999485, 1.4456850290, 2.5039999485, 2.8913702965, 4.3370552063, 5.2124915123, 5.0079998970, 2.8913698196, 3.8249230385, 1.4456851482]) r0 = torch.tensor([3.4000000954, 3.2000000477, 3.4000000954, 3.2000000477, 3.4000000954, - 3.2000000477, 3.4000000954, 3.2000000477, 3.2000000477, 3.2000000477]) + 3.2000000477, 3.4000000954, 3.2000000477, 3.2000000477, 3.2000000477])/1.8897259886 edge_index = torch.tensor([3, 2, 3, 2, 3, 2, 3, 2, 2, 2]) skints=hop.get_skhij( diff --git a/dptb/tests/test_SKHamiltonian.py b/dptb/tests/test_SKHamiltonian.py index 40607943..c8aa658d 100644 --- a/dptb/tests/test_SKHamiltonian.py +++ b/dptb/tests/test_SKHamiltonian.py @@ -222,6 +222,6 @@ def test_onsite_stain(self): 0.0000000000e+00, 2.6077032089e-08, 0.0000000000e+00, -3.7709136009e+00]]) - assert torch.allclose(data[AtomicDataDict.NODE_FEATURES_KEY], expected_strainonsite) + assert torch.allclose(data[AtomicDataDict.NODE_FEATURES_KEY], expected_strainonsite, atol=1e-6, rtol=1e-4) diff --git a/dptb/tests/test_atomicdata_rmaxdict.py b/dptb/tests/test_atomicdata_rmaxdict.py new file mode 100644 index 00000000..9281b203 --- /dev/null +++ b/dptb/tests/test_atomicdata_rmaxdict.py @@ -0,0 +1,92 @@ +from ase.io import read, write +import numpy as np +from dptb.data import AtomicData, AtomicDataDict +import torch +from dptb.utils.constants import atomic_num_dict, atomic_num_dict_r +import os +from pathlib import Path + +rootdir = os.path.join(Path(os.path.abspath(__file__)).parent, "data") + + +def test_rmax_float(): + strfile = os.path.join(rootdir, "hBN", "hBN.vasp") + atoms = read(strfile) + atomic_options = {} + atomic_options['pbc'] = True + atomic_options['r_max'] = 2.6 + + data = AtomicData.from_ase(atoms, **atomic_options) + assert (data.edge_index == torch.tensor([[0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1], + [0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1]])).all() + + assert (data.edge_cell_shift == torch.tensor([[-1., 0., 0.], + [-1., 0., 0.], + [ 0., 1., 0.], + [ 0., 1., 0.], + [ 1., 1., 0.], + [ 0., 0., 0.], + [ 1., 1., 0.], + [ 0., -1., 0.], + [-1., 0., 0.], + [ 1., -0., -0.], + [ 1., -0., -0.], + [-0., -1., -0.], + [-0., -1., -0.], + [-1., -1., -0.], + [-0., -0., -0.], + [-1., -1., -0.], + [-0., 1., -0.], + [ 1., -0., -0.]])).all() + +def test_rmax_dict_eq(): + strfile = os.path.join(rootdir, "hBN", "hBN.vasp") + atoms = read(strfile) + atomic_options = {} + atomic_options['pbc'] = True + atomic_options['r_max'] = {'B': 2.6, 'N': 2.6} + data = AtomicData.from_ase(atoms, **atomic_options) + assert (data.edge_index == torch.tensor([[0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1], + [0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1]])).all() + + assert (data.edge_cell_shift == torch.tensor([[-1., 0., 0.], + [-1., 0., 0.], + [ 0., 1., 0.], + [ 0., 1., 0.], + [ 1., 1., 0.], + [ 0., 0., 0.], + [ 1., 1., 0.], + [ 0., -1., 0.], + [-1., 0., 0.], + [ 1., -0., -0.], + [ 1., -0., -0.], + [-0., -1., -0.], + [-0., -1., -0.], + [-1., -1., -0.], + [-0., -0., -0.], + [-1., -1., -0.], + [-0., 1., -0.], + [ 1., -0., -0.]])).all() + +def test_rmax_dict_neq(): + strfile = os.path.join(rootdir, "hBN", "hBN.vasp") + atoms = read(strfile) + atomic_options = {} + atomic_options['pbc'] = True + atomic_options['r_max'] = {'B':1.5,'N':2.6} + data = AtomicData.from_ase(atoms, **atomic_options) + assert (data.edge_index == torch.tensor([[0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1], + [0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0]])).all() + + assert (data.edge_cell_shift == torch.tensor([[-1., 0., 0.], + [-1., 0., 0.], + [ 0., 1., 0.], + [ 0., 1., 0.], + [ 1., 1., 0.], + [ 0., 0., 0.], + [ 1., -0., -0.], + [ 1., -0., -0.], + [-0., -1., -0.], + [-0., -1., -0.], + [-1., -1., -0.], + [-0., -0., -0.]])).all() \ No newline at end of file diff --git a/dptb/tests/test_bondlength.py b/dptb/tests/test_bondlength.py index 9417c91d..f9ce0bae 100644 --- a/dptb/tests/test_bondlength.py +++ b/dptb/tests/test_bondlength.py @@ -9,8 +9,17 @@ def test_bond_length_list(): atom_symbol = atomic_num_dict_r[atomic_number] if atom_symbol in bond_length: assert bond_length_full_dict[atom_symbol] == bond_length[atom_symbol] - assert bond_length_list[ii-1] == bond_length[atom_symbol] + assert bond_length_list[ii-1] == bond_length[atom_symbol] / 1.8897259886 else: assert bond_length_full_dict[atom_symbol] is None assert bond_length_list[ii-1] == -100 - \ No newline at end of file + +from dptb.nn.sktb.cov_radiiDB import Covalent_radii, R_cov_list +from dptb.utils.constants import atomic_num_dict + +def test_Covalent_radii(): + for key, val in atomic_num_dict.items(): + if key in Covalent_radii: + assert Covalent_radii[key] == R_cov_list[val-1] + else: + assert R_cov_list[val-1] == -100 diff --git a/dptb/tests/test_build_dataset.py b/dptb/tests/test_build_dataset.py index ca1f3ed9..62c972ba 100644 --- a/dptb/tests/test_build_dataset.py +++ b/dptb/tests/test_build_dataset.py @@ -52,6 +52,34 @@ def test_build_dataset_success(root_directory): assert isinstance(dataset.info_files["kpath_spk.0"]["bandinfo"], dict) +def test_build_dataset_rmax_dict(root_directory): + set_options = { + "r_max": {'Si':5.0}, + "er_max": 5.0, + "oer_max": 2.5, + "root": f"{root_directory}/dptb/tests/data/test_sktb/dataset", + "prefix": "kpath_spk", + "get_eigenvalues": True, + "get_Hamiltonian": False, + } + common_options={"basis": {"Si": ["3s", "3p"]}} + + + dataset = build_dataset(**set_options, **common_options) + +def test_build_dataset_rmax_dict_bondwise(root_directory): + set_options = { + "r_max": {'Si-Si':5.0}, + "er_max": 5.0, + "oer_max": 2.5, + "root": f"{root_directory}/dptb/tests/data/test_sktb/dataset", + "prefix": "kpath_spk", + "get_eigenvalues": True, + "get_Hamiltonian": False, + } + common_options={"basis": {"Si": ["3s", "3p"]}} + + dataset = build_dataset(**set_options, **common_options) def test_build_dataset_fail(root_directory): @@ -70,4 +98,6 @@ def test_build_dataset_fail(root_directory): dataset = build_dataset(**set_options, **common_options) assert "Hamiltonian file not found" in str(excinfo.value) + + #TODO: Add failure test cases for build_dataset. when get_eigenvalues is True and get_Hamiltonian is False; 当我们补充E3的测试案例时,会有一个数据集,只有Hamiltonian,没有eigenvalues。我们需要测试这种情况。 \ No newline at end of file diff --git a/dptb/tests/test_dftb2nnsk.py b/dptb/tests/test_dftb2nnsk.py index 6b3e02f4..7627b7c0 100644 --- a/dptb/tests/test_dftb2nnsk.py +++ b/dptb/tests/test_dftb2nnsk.py @@ -3,51 +3,54 @@ from pathlib import Path from dptb.nn.dftb2nnsk import DFTB2NNSK from dptb.nn.nnsk import NNSK +from dptb.entrypoints.collectskf import skf2nnsk -rootdir = os.path.join(Path(os.path.abspath(__file__)).parent, "data/") + +rootdir = os.path.join(Path(os.path.abspath(__file__)).parent, "data") +exampledir = os.path.join(Path(os.path.abspath(__file__)).parent, "..", "..", "examples") class TestDFTB2NNSK: rootdir = f"{rootdir}" - def test_init(self): - dftb2nnsk = DFTB2NNSK( + train_ops = { + 'nstep':10, + 'dis_freq':1, + 'nsample':256, + 'save_freq':1, + 'max_elmt_batch':4, + "optimizer": { + "lr": 0.05, + "type": "RMSprop" + }, + "lr_scheduler": { + "type": "cos", + "T_max": 4 + } + } + + dftb2nnsk = DFTB2NNSK( basis={"B":["2s"], "N": ["2s"]}, skdata=os.path.join(rootdir, "slakos"), + train_options=train_ops, rs=6.0, w=1.0, - functype="powerlaw" + method="powerlaw" ) def test_optimize(self): - dftb2nnsk = DFTB2NNSK( - basis={"B":["2s"], "N": ["2s"]}, - skdata=os.path.join(rootdir, "slakos"), - rs=6.0, - w=1.0, - functype="powerlaw" - ) - dftb2nnsk.optimize(nstep=10) + self.dftb2nnsk.optimize(r_min=1,r_max=6,nstep=10) def test_tonnsk(self): - dftb2nnsk = DFTB2NNSK( - basis={"B":["2s"], "N": ["2s"]}, - skdata=os.path.join(rootdir, "slakos"), - rs=6.0, - w=1.0, - functype="powerlaw" - ) - nnsk = dftb2nnsk.to_nnsk() - + nnsk = self.dftb2nnsk.to_nnsk() assert isinstance(nnsk, NNSK) - def test_tojson(self): - dftb2nnsk = DFTB2NNSK( - basis={"B":["2s"], "N": ["2s"]}, - skdata=os.path.join(rootdir, "slakos"), - rs=6.0, - w=1.0, - functype="powerlaw" - ) - jdata = dftb2nnsk.to_json() + jdata = self.dftb2nnsk.to_json() assert isinstance(jdata, dict) - \ No newline at end of file + +def test_skf2nnsk_run(): + input_file = os.path.join(exampledir, "skf2nnsk", "input_test.json") + skf2nnsk(INPUT = input_file, + init_model = None, + output = os.path.join(rootdir, "..","test_temp"), + log_level = 2 + ) \ No newline at end of file diff --git a/dptb/tests/test_get_fermi.py b/dptb/tests/test_get_fermi.py index 61aeec89..ab5a521a 100644 --- a/dptb/tests/test_get_fermi.py +++ b/dptb/tests/test_get_fermi.py @@ -17,7 +17,11 @@ def test_get_fermi(): elec_cal = ElecStruCal(model=model,device='cpu') _, efermi =elec_cal.get_fermi_level(data=stru_data, - nel_atom = nel_atom, + nel_atom = nel_atom,smearing_method='FD', meshgrid=[30,30,30]) - assert abs(efermi + 3.2257686853408813) < 1e-5 + assert abs(efermi + 2.896199107170105) < 1e-5 + _, efermi =elec_cal.get_fermi_level(data=stru_data, + nel_atom = nel_atom,smearing_method='Gaussian', + meshgrid=[30,30,30]) + assert abs(efermi + 2.8937143087387085) < 1e-5 diff --git a/dptb/tests/test_get_rmap.py b/dptb/tests/test_get_rmap.py new file mode 100644 index 00000000..1824e1d9 --- /dev/null +++ b/dptb/tests/test_get_rmap.py @@ -0,0 +1,35 @@ +from dptb.data.AtomicData import get_r_map +from dptb.data.AtomicData import get_r_map_bondwise +import pytest +import torch + +def test_get_rmap(): + r_max = {'Si': 1, 'H': 2, 'O': 4, 'C': 5} + atomic_numbe = [1,6,8,14] + r_map = get_r_map(r_max) + + assert r_map[1-1] == 2 + assert r_map[6-1] == 5 + assert r_map[8-1] == 4 + assert r_map[14-1] == 1 + + assert isinstance(r_map, torch.Tensor) + assert r_map.shape == (14,) + +def test_get_rmap_bondwise(): + with pytest.raises(AssertionError): + r_max = {'Si': 1, 'H': 2, 'O': 4, 'C': 5} + get_r_map_bondwise(r_max) + + r_max = r_max = {'He-He': 5.5, + 'He-H':2, + 'H-He':3, + "Li-Li": 4, + "Li-H": 5, + 'H-H': 5.5} + r_map = get_r_map_bondwise(r_max) + + except_rmap = torch.tensor([[5.5000, 2.5000, 5.0000], + [2.5000, 5.5000, 0.0000], + [5.0000, 0.0000, 4.0000]]) + assert torch.allclose(r_map, except_rmap) diff --git a/dptb/tests/test_nnsk.py b/dptb/tests/test_nnsk.py index ca5ded30..c1961e7c 100644 --- a/dptb/tests/test_nnsk.py +++ b/dptb/tests/test_nnsk.py @@ -7,7 +7,7 @@ from pathlib import Path from dptb.data import AtomicDataset, DataLoader, AtomicDataDict, AtomicData import numpy as np - +from dptb.utils.constants import atomic_num_dict_r rootdir = os.path.join(Path(os.path.abspath(__file__)).parent, "data") @@ -254,4 +254,164 @@ def test_nnsk_onsite_strain(self): [-0.0045243134, 0.0416939184, 0.0698706284, 0.0414667316], [-0.0045243134, 0.0416939184, 0.0698706284, 0.0414667316]]) - assert torch.allclose(data[AtomicDataDict.ONSITENV_FEATURES_KEY], expected_onsiteskints, atol=1e-10) \ No newline at end of file + assert torch.allclose(data[AtomicDataDict.ONSITENV_FEATURES_KEY], expected_onsiteskints, atol=1e-10) + +class TestNNSK_rmax_dict: + common_options = { + "basis": { + "B": ["2s", "2p"], + "N": ["2s", "2p"] + }, + "device": "cpu", + "dtype": "float32", + "overlap": False, + "seed": 3982377700 + } + model_options = { + "nnsk": { + "onsite": { + "method": "uniform" + }, + "hopping": { + "method": "powerlaw", + "rs": 2.6, + "w": 0.35 + }, + "freeze": False, + "std": 0.1, + "push": None} + } + data_options = { + "r_max": 2.6, + "er_max": 2.6, + "oer_max":1.6, + "train": { + "root": f"{rootdir}/hBN/dataset", + "prefix": "kpath", + "get_eigenvalues": True + } + } + train_datasets = build_dataset(**data_options, **data_options["train"], **common_options) + train_loader = DataLoader(dataset=train_datasets, batch_size=1, shuffle=True) + + batch = next(iter(train_loader)) + batch = AtomicData.to_AtomicDataDict(batch) + + hopping_formula = ['varTang96', 'powerlaw','poly1pow','poly2pow','poly3pow','poly2exp'] + + + def test_nnsk_rmax_dict_samevalue(self): + model_options = self.model_options.copy() + rs_old = 2.6 + rs_new_dict = {'B':2.6, 'N':2.6} + for formula in self.hopping_formula: + model_options["nnsk"]["hopping"]["method"] = formula + model_options["nnsk"]["hopping"]["rs"] = rs_old + model = NNSK(**model_options['nnsk'], **self.common_options,transform=False) + data = model(self.batch) + hopping_old = data[AtomicDataDict.EDGE_FEATURES_KEY].clone() + + model_options["nnsk"]["hopping"]["rs"] = rs_new_dict + model2 = NNSK(**model_options['nnsk'], **self.common_options,transform=False) + model2.hopping_param = model.hopping_param + data = model2(self.batch) + hopping_new = data[AtomicDataDict.EDGE_FEATURES_KEY].clone() + assert torch.allclose(hopping_old, hopping_new, atol=1e-5) + + + def test_nnsk_rmax_dict_diffvalue(self): + model_options = self.model_options.copy() + rs_old = 2.6 + rs_new_dict = {'B':3.6, 'N':2.0} + for formula in self.hopping_formula: + model_options["nnsk"]["hopping"]["method"] = formula + model_options["nnsk"]["hopping"]["rs"] = 2.6 + model = NNSK(**model_options['nnsk'], **self.common_options,transform=False) + data = model(self.batch) + hopping_old = data[AtomicDataDict.EDGE_FEATURES_KEY].clone() + + model_options["nnsk"]["hopping"]["rs"] = rs_new_dict + model3 = NNSK(**model_options['nnsk'], **self.common_options,transform=False) + model3.hopping_param = model.hopping_param + data = model3(self.batch) + hopping_new = data[AtomicDataDict.EDGE_FEATURES_KEY].clone() + assert not torch.allclose(hopping_old, hopping_new, atol=1e-5) + + edge_index = data[AtomicDataDict.EDGE_TYPE_KEY].flatten() # it is bond_type index, transform it to reduced bond index + edge_number = model.idp_sk.untransform_bond(edge_index).T + + assert edge_number.shape[1] == hopping_old.shape[0] + + for i in range(edge_number.shape[1]): + isymbol = atomic_num_dict_r[int(edge_number[0,i])] + jsymbol = atomic_num_dict_r[int(edge_number[1,i])] + rs = 0.5 * (rs_new_dict[isymbol] + rs_new_dict[jsymbol]) + rij = data[AtomicDataDict.EDGE_LENGTH_KEY][i] + w = model_options["nnsk"]["hopping"]["w"] + if formula in ['varTang96', 'powerlaw']: + fij_old = 1/(1+torch.exp((rij-rs_old)/w)) + fij_new = 1/(1+torch.exp((rij-rs)/w)) + + else: + fij_old = 1/(1+torch.exp((rij-rs_old+5*w)/w)) + fij_new = 1/(1+torch.exp((rij-rs+5*w)/w)) + + assert torch.allclose(hopping_new[i] / fij_new, hopping_old[i] / fij_old, atol=1e-5) + + def test_nnsk_rmax_bondwise_dict_samevalue(self): + model_options = self.model_options.copy() + rs_old = 2.6 + rs_new_dict = {'B-B':2.6, 'N-N':2.6,'B-N':2.6} + for formula in self.hopping_formula: + model_options["nnsk"]["hopping"]["method"] = formula + model_options["nnsk"]["hopping"]["rs"] = rs_old + model = NNSK(**model_options['nnsk'], **self.common_options,transform=False) + data = model(self.batch) + hopping_old = data[AtomicDataDict.EDGE_FEATURES_KEY].clone() + + model_options["nnsk"]["hopping"]["rs"] = rs_new_dict + model2 = NNSK(**model_options['nnsk'], **self.common_options,transform=False) + model2.hopping_param = model.hopping_param + data = model2(self.batch) + hopping_new = data[AtomicDataDict.EDGE_FEATURES_KEY].clone() + assert torch.allclose(hopping_old, hopping_new, atol=1e-5) + + def test_nnsk_rmax_bondwise_dict_diffvalue(self): + model_options = self.model_options.copy() + rs_old = 2.6 + rs_new_dict = {'B-B':3.6, 'B-N':2.8, 'N-B':2.8, 'N-N':2.0} + for formula in self.hopping_formula: + model_options["nnsk"]["hopping"]["method"] = formula + model_options["nnsk"]["hopping"]["rs"] = 2.6 + model = NNSK(**model_options['nnsk'], **self.common_options,transform=False) + data = model(self.batch) + hopping_old = data[AtomicDataDict.EDGE_FEATURES_KEY].clone() + + model_options["nnsk"]["hopping"]["rs"] = rs_new_dict + model3 = NNSK(**model_options['nnsk'], **self.common_options,transform=False) + model3.hopping_param = model.hopping_param + data = model3(self.batch) + hopping_new = data[AtomicDataDict.EDGE_FEATURES_KEY].clone() + assert not torch.allclose(hopping_old, hopping_new, atol=1e-5) + + edge_index = data[AtomicDataDict.EDGE_TYPE_KEY].flatten() # it is bond_type index, transform it to reduced bond index + edge_number = model.idp_sk.untransform_bond(edge_index).T + + assert edge_number.shape[1] == hopping_old.shape[0] + + for i in range(edge_number.shape[1]): + isymbol = atomic_num_dict_r[int(edge_number[0,i])] + jsymbol = atomic_num_dict_r[int(edge_number[1,i])] + # rs = 0.5 * (rs_new_dict[isymbol] + rs_new_dict[jsymbol]) + rs = rs_new_dict[f"{isymbol}-{jsymbol}"] + rij = data[AtomicDataDict.EDGE_LENGTH_KEY][i] + w = model_options["nnsk"]["hopping"]["w"] + if formula in ['varTang96', 'powerlaw']: + fij_old = 1/(1+torch.exp((rij-rs_old)/w)) + fij_new = 1/(1+torch.exp((rij-rs)/w)) + + else: + fij_old = 1/(1+torch.exp((rij-rs_old+5*w)/w)) + fij_new = 1/(1+torch.exp((rij-rs+5*w)/w)) + + assert torch.allclose(hopping_new[i] / fij_new, hopping_old[i] / fij_old, atol=1e-5) \ No newline at end of file diff --git a/dptb/tests/test_skparam.py b/dptb/tests/test_skparam.py index cc0776dd..f771b2e2 100644 --- a/dptb/tests/test_skparam.py +++ b/dptb/tests/test_skparam.py @@ -39,8 +39,9 @@ def check_skdict(self, skparams): assert skdict['OnsiteE'].shape[2] == 1 def test_init_path(self): - with pytest.raises(IndexError): - SKParam(basis={"C": ["s", "p"], "H": ["s"]}, skdata=self.skdatapath) + # with pytest.raises(IndexError): + SKParam(basis={"C": ["s", "p"], "H": ["s"]}, skdata=self.skdatapath) + with pytest.raises(FileNotFoundError): skparams = SKParam(basis={"C": ["2s", "2p"], "O": ["2s"]}, skdata=self.skdatapath) diff --git a/dptb/utils/argcheck.py b/dptb/utils/argcheck.py index f4fb1708..f081a57e 100644 --- a/dptb/utils/argcheck.py +++ b/dptb/utils/argcheck.py @@ -182,12 +182,48 @@ def SGD(): Argument("nesterov", bool, optional=True, default=False, doc=doc_nesterov) ] + +def RMSprop(): + doc_lr = "learning rate. Default: 1e-2" + doc_alpha = "smoothing constant, Default: 0.99" + doc_eps = "term added to the denominator to improve numerical stability, Default: 1e-8" + doc_weight_decay = "weight decay (L2 penalty), Default: 0" + doc_momentum = "momentum factor, Default: 0" + doc_centered = "if True, compute the centered RMSProp, the gradient is normalized by an estimation of its variance, Default: False" + + return [ + Argument("lr", float, optional=True, default=1e-2, doc=doc_lr), + Argument("alpha", float, optional=True, default=0.99, doc=doc_alpha), + Argument("eps", float, optional=True, default=1e-8, doc=doc_eps), + Argument("weight_decay", float, optional=True, default=0, doc=doc_weight_decay), + Argument("momentum", float, optional=True, default=0, doc=doc_momentum), + Argument("centered", bool, optional=True, default=False, doc=doc_centered) + ] + + +def LBFGS(): + doc_lr = "learning rate. Default: 1" + doc_max_iter = "maximal number of iterations per optimization step. Default: 20" + doc_max_eval = "maximal number of function evaluations per optimization step. Default: None -> max_iter*1.25" + # doc_tolerance_grad = "termination tolerance on first order optimality (default: 1e-7)." + # doc_line_search_fn = "either 'strong_wolfe' or None (default: None)." + # doc_history_size = "update history size. Default: 100" + # doc_tolerance_change = "termination tolerance on function value/parameter changes (default: 1e-9)." + + return [ + Argument("lr", float, optional=True, default=1, doc=doc_lr), + Argument("max_iter", int, optional=True, default=20, doc=doc_max_iter), + Argument("max_eval", int, optional=True, default=None, doc=doc_max_eval) + ] + def optimizer(): doc_type = "select type of optimizer, support type includes: `Adam`, `SGD` and `LBFGS`. Default: `Adam`" return Variant("type", [ Argument("Adam", dict, Adam()), - Argument("SGD", dict, SGD()) + Argument("SGD", dict, SGD()), + Argument("RMSprop", dict, RMSprop()), + Argument("LBFGS", dict, LBFGS()), ],optional=True, default_tag="Adam", doc=doc_type) def ExponentialLR(): @@ -270,6 +306,15 @@ def CyclicLR(): ] +def CosineAnnealingLR(): + doc_T_max = "Maximum number of iterations. Default: 100." + doc_eta_min = "Minimum learning rate. Default: 0." + + return [ + Argument("T_max", int, optional=True, default=100, doc=doc_T_max), + Argument("eta_min", float, optional=True, default=0, doc=doc_eta_min), + ] + def lr_scheduler(): doc_type = "select type of lr_scheduler, support type includes `exp`, `linear`" @@ -277,6 +322,7 @@ def lr_scheduler(): Argument("exp", dict, ExponentialLR()), Argument("linear", dict, LinearLR()), Argument("rop", dict, ReduceOnPlateau(), doc="rop: reduce on plateau"), + Argument("cos", dict, CosineAnnealingLR(), doc="cos: cosine annealing"), Argument("cyclic", dict, CyclicLR(), doc="Cyclic learning rate") ],optional=True, default_tag="exp", doc=doc_type) @@ -723,53 +769,45 @@ def hopping(): - `NRL0`: the old version of NRL formula for overlap, we set overlap and hopping share same options. - `NRL1`: the new version of NRL formula for overlap. """ - doc_rs = "The cut-off for smooth function fc for powerlaw and varTang96, fc(rs)=0.5" + doc_rs_soft = "The cut-off for smooth function fc for powerlaw and varTang96, fc(rs)=0.5" doc_w = " The decay w in fc" - doc_rc = "The cut-off for smooth function fc for NRL, fc(rc) = 0." + doc_rs_hard = "The cut-off for smooth function fc, fc(rs) = 0." powerlaw = [ - Argument("rs", float, optional=True, default=6.0, doc=doc_rs), - Argument("w", float, optional=True, default=0.1, doc=doc_w), - ] - poly1pow = [ - Argument("rs", float, optional=True, default=6.0, doc=doc_rs), - Argument("w", float, optional=True, default=0.1, doc=doc_w), - ] - poly2pow = [ - Argument("rs", float, optional=True, default=6.0, doc=doc_rs), - Argument("w", float, optional=True, default=0.1, doc=doc_w), - ] - poly3pow = [ - Argument("rs", float, optional=True, default=6.0, doc=doc_rs), - Argument("w", float, optional=True, default=0.1, doc=doc_w), - ] - poly2exp = [ - Argument("rs", float, optional=True, default=6.0, doc=doc_rs), + Argument("rs", float, optional=True, default=6.0, doc=doc_rs_soft), Argument("w", float, optional=True, default=0.1, doc=doc_w), ] varTang96 = [ - Argument("rs", float, optional=True, default=6.0, doc=doc_rs), + Argument("rs", float, optional=True, default=6.0, doc=doc_rs_soft), Argument("w", float, optional=True, default=0.1, doc=doc_w), ] - - NRL = [ - Argument("rs", float, optional=True, default=6.0, doc=doc_rc), + common_params = [ + Argument("rs", float, optional=True, default=6.0, doc=doc_rs_hard), Argument("w", float, optional=True, default=0.1, doc=doc_w), ] + formulas = [ + 'poly1pow', + 'poly2pow', + 'poly3pow', + 'poly4pow', + 'poly2exp', + 'poly3exp', + 'poly4exp', + 'NRL0', + "NRL1"] - return Variant("method", [ - Argument("powerlaw", dict, powerlaw), - Argument("poly1pow", dict, poly1pow), - Argument("poly2pow", dict, poly2pow), - Argument("poly3pow", dict, poly3pow), - Argument("poly2exp", dict, poly2exp), - Argument("varTang96", dict, varTang96), - Argument("NRL0", dict, NRL), - Argument("NRL1", dict, NRL), - Argument("custom", dict, []), - ],optional=False, doc=doc_method) + args = [ + Argument("powerlaw", dict, powerlaw), + Argument("varTang96", dict, varTang96), + Argument("custom", dict, []) + ] + + for ii in formulas: + args.append(Argument(ii, dict, common_params)) + return Variant("method", args,optional=False, doc=doc_method) + def loss_options(): doc_method = """The loss function type, defined by a string like `_`, Default: `eigs_l2dsf`. supported loss functions includes:\n\n\ @@ -1571,7 +1609,7 @@ def get_cutoffs_from_model_options(model_options): elif model_options.get("dftbsk", None) is not None: assert r_max is None, "r_max should not be provided in outside the dftbsk for training dftbsk model." - r_max = model_options["dftbsk"]["r_max"] + r_max = model_options["dftbsk"].get("r_max") else: # not nnsk not dftbsk, must be only env or E3. the embedding should be provided. @@ -1635,3 +1673,75 @@ def collect_cutoffs(jdata): log.info("-"*66) return cutoff_options + + +def normalize(data): + + co = common_options() + tr = train_options() + da = data_options() + mo = model_options() + + base = Argument("base", dict, [co, tr, da, mo]) + data = base.normalize_value(data) + # data = base.normalize_value(data, trim_pattern="_*") + base.check_value(data, strict=True) + + # add check loss and use wannier: + + # if data['data_options']['use_wannier']: + # if not data['loss_options']['losstype'] .startswith("block"): + # log.info(msg='\n Warning! set data_options use_wannier true, but the loss type is not block_l2! The the wannier TB will not be used when training!\n') + + # if data['loss_options']['losstype'] .startswith("block"): + # if not data['data_options']['use_wannier']: + # log.error(msg="\n ERROR! for block loss type, must set data_options:use_wannier True\n") + # raise ValueError + + return data + +def normalize_skf2nnsk(data): + common_ops = [ + Argument("basis", [dict,str], optional=False, default='auto', doc="The basis set for the model, can be a dict or a string, default is 'auto'."), + Argument("skdata",str, optional=False, doc="The path to the skf file."), + Argument("device",str, optional=True, default='cpu', doc="The device to run the calculation, choose among `cpu` and `cuda[:int]`, Default: 'cpu'."), + Argument("dtype",str, optional=True, default='float32', doc="The digital number's precison, choose among: 'float32', 'float64', Default: 'float32'."), + Argument("seed", int, optional=True, default=3982377700, doc="The random seed used to initialize the parameters and determine the shuffling order of datasets. Default: `3982377700`") + ] + + model_ops = [ + Argument('method',str, optional=False, default='poly2pow', doc="The method for the hopping term, default is 'powerlaw'."), + Argument('rs',[float,None,int], optional=True, default=None, doc="The rs value for the hopping term."), + Argument('w', [float,int], optional=True, default=0.2, doc="The w value for the hopping term."), + Argument('atomic_radius',[str,dict], optional=True, default='cov', doc="The atomic radius for the hopping term, default is 'cov'.") + ] + + doc_lr_scheduler = "The learning rate scheduler tools settings, the lr scheduler is used to scales down the learning rate during the training process. Proper setting can make the training more stable and efficient. The supported lr schedular includes: `Exponential Decaying (exp)`, `Linear multiplication (linear)`" + doc_optimizer = "\ + The optimizer setting for selecting the gradient optimizer of model training. Optimizer supported includes `Adam`, `SGD` and `LBFGS` \n\n\ + For more information about these optmization algorithm, we refer to:\n\n\ + - `Adam`: [Adam: A Method for Stochastic Optimization.](https://arxiv.org/abs/1412.6980)\n\n\ + - `SGD`: [Stochastic Gradient Descent.](https://pytorch.org/docs/stable/generated/torch.optim.SGD.html)\n\n\ + - `LBFGS`: [On the limited memory BFGS method for large scale optimization.](http://users.iems.northwestern.edu/~nocedal/PDFfiles/limited-memory.pdf) \n\n\ + " + + train_ops = [ + Argument('nstep', int, optional=False, doc="The number of steps for the training."), + Argument('nsample', int, optional=True, default=256, doc="The number of steps for the training."), + Argument('max_elmt_batch', int, optional=True, default=4, doc="The max number of elements in a batch."), + Argument('dis_freq', int, optional=True, default=1, doc="The frequency of the display."), + Argument('save_freq', int, optional=True, default=1, doc="The frequency of the save."), + Argument("optimizer", dict, sub_fields=[], optional=True, default={}, sub_variants=[optimizer()], doc = doc_optimizer), + Argument("lr_scheduler", dict, sub_fields=[], optional=True, default={}, sub_variants=[lr_scheduler()], doc = doc_lr_scheduler) + ] + co = Argument("common_options", dict, optional=False, sub_fields=common_ops, sub_variants=[], doc='The common options.') + mo = Argument("model_options", dict, optional=False, sub_fields=model_ops, sub_variants=[], doc='The model options.') + tr = Argument("train_options", dict, sub_fields=train_ops, sub_variants=[], optional=False, doc='The training options.') + + base = Argument("base", dict, [co, mo, tr]) + data = base.normalize_value(data) + # data = base.normalize_value(data, trim_pattern="_*") + base.check_value(data, strict=True) + + return data + \ No newline at end of file diff --git a/dptb/utils/tools.py b/dptb/utils/tools.py index 3434f4e4..8c8e5f1b 100644 --- a/dptb/utils/tools.py +++ b/dptb/utils/tools.py @@ -155,6 +155,8 @@ def get_lr_scheduler(type: str, optimizer: optim.Optimizer, **sch_options): scheduler = optim.lr_scheduler.LinearLR(optimizer=optimizer, **sch_options) elif type == "rop": scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer=optimizer, **sch_options) + elif type == 'cos': + scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer=optimizer, **sch_options) elif type == "cyclic": scheduler = optim.lr_scheduler.CyclicLR(optimizer=optimizer, **sch_options) else: diff --git a/examples/base_model/dptb_base_poly2.pth b/examples/base_model/dptb_base_poly2.pth new file mode 100644 index 00000000..99093f51 Binary files /dev/null and b/examples/base_model/dptb_base_poly2.pth differ diff --git a/examples/base_model/dptb_base_poly4.pth b/examples/base_model/dptb_base_poly4.pth new file mode 100644 index 00000000..381d58d0 Binary files /dev/null and b/examples/base_model/dptb_base_poly4.pth differ diff --git a/examples/base_model/usage.ipynb b/examples/base_model/usage.ipynb new file mode 100644 index 00000000..4a57e940 --- /dev/null +++ b/examples/base_model/usage.ipynb @@ -0,0 +1,141 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "from dptb.nn.dftb2nnsk import DFTB2NNSK\n", + "import matplotlib.pyplot as plt\n", + "from dptb.entrypoints.collectskf import skf2nnsk\n", + "from dptb.nn.build import build_model\n", + "from dptb.utils.tools import j_loader\n", + "from dptb.postprocess.bandstructure.band import Band" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = build_model('./dptb_base_poly4.pth',no_check=True)\n", + "# not the no_check=True, which is used to skip the check of the model options. \n", + "\n", + "stru_data = '../hBN_dftb/data/struct.vasp'\n", + "kpath_kwargs = {\n", + " \"task\": \"band\",\n", + " \"kline_type\":\"abacus\",\n", + " \"kpath\":[\n", + " [0, 0, 0, 50],\n", + " [0.5, 0, 0, 50],\n", + " [0.3333333, 0.3333333, 0, 50],\n", + " [0, 0, 0, 1]\n", + " ],\n", + " \"nel_atom\":{\"N\":5,\"B\":3},\n", + " \"klabels\":[\"G\", \"M\", \"K\", \"G\"],\n", + " \"E_fermi\":-12.798759460449219,\n", + " \"emin\":-25,\n", + " \"emax\":15,\n", + " \"ref_band\": \"../hBN_dftb/data/kpath.0/eigenvalues.npy\"\n", + " }\n", + "bcal = Band(model=model, \n", + " use_gui=False, \n", + " results_path='./', \n", + " device=model.device)\n", + "eigenstatus = bcal.get_bands(data=stru_data, \n", + " kpath_kwargs=kpath_kwargs)\n", + "\n", + "bcal.band_plot(ref_band = kpath_kwargs[\"ref_band\"],\n", + " E_fermi = -5,\n", + " emin = -18,\n", + " emax = 15)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 你会发现上面的能带怎么 在 5 eV 附近有一个平的带呢?这是因为我们默认的采用的轨道是spd。 对于 h-BN d orbital 全部为的所有hopping, onside 全部0 是无效信息。 \n", + "## 我们可以手动指定 轨道信息" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "common_options = {\n", + " \"basis\": {\n", + " \"B\": [\"s\", \"p\"],\n", + " \"N\": [\"s\", \"p\"],\n", + " },\n", + " \"device\": \"cpu\",\n", + " \"dtype\": \"float32\",\n", + " \"overlap\": True,\n", + " \"seed\": 3982377700\n", + "}\n", + "model = build_model('./dptb_base_poly4.pth',common_options=common_options, no_check=True)\n", + "# not the no_check=True, which is used to skip the check of the model options. \n", + "# AtomicData_options = {\"r_max\": 5.0,\"er_max\": 3.5, \"oer_max\":1.6, \"pbc\": True}\n", + "stru_data = '../hBN_dftb/data/struct.vasp'\n", + "kpath_kwargs = {\n", + " \"task\": \"band\",\n", + " \"kline_type\":\"abacus\",\n", + " \"kpath\":[\n", + " [0, 0, 0, 50],\n", + " [0.5, 0, 0, 50],\n", + " [0.3333333, 0.3333333, 0, 50],\n", + " [0, 0, 0, 1]\n", + " ],\n", + " \"nel_atom\":{\"N\":5,\"B\":3},\n", + " \"klabels\":[\"G\", \"M\", \"K\", \"G\"],\n", + " \"E_fermi\":-12.798759460449219,\n", + " \"emin\":-25,\n", + " \"emax\":15,\n", + " \"ref_band\": \"../hBN_dftb/data/kpath.0/eigenvalues.npy\"\n", + " }\n", + "bcal = Band(model=model, \n", + " use_gui=False, \n", + " results_path='./', \n", + " device=model.device)\n", + "eigenstatus = bcal.get_bands(data=stru_data, \n", + " kpath_kwargs=kpath_kwargs)\n", + "\n", + "bcal.band_plot(ref_band = kpath_kwargs[\"ref_band\"],\n", + " E_fermi = -5,\n", + " emin = -18,\n", + " emax = 15)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/skf2nnsk/HBCNOSi.nnsk.model/best_df2sk.pth b/examples/skf2nnsk/HBCNOSi.nnsk.model/best_df2sk.pth new file mode 100644 index 00000000..f2263787 Binary files /dev/null and b/examples/skf2nnsk/HBCNOSi.nnsk.model/best_df2sk.pth differ diff --git a/examples/skf2nnsk/H_B_C_N_O_Si.pth b/examples/skf2nnsk/H_B_C_N_O_Si.pth new file mode 100644 index 00000000..af7dcd7f Binary files /dev/null and b/examples/skf2nnsk/H_B_C_N_O_Si.pth differ diff --git a/examples/skf2nnsk/dftb2nnsk.ipynb b/examples/skf2nnsk/dftb2nnsk.ipynb new file mode 100644 index 00000000..d9c912fc --- /dev/null +++ b/examples/skf2nnsk/dftb2nnsk.ipynb @@ -0,0 +1,513 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "from dptb.nn.dftb2nnsk import DFTB2NNSK\n", + "import matplotlib.pyplot as plt\n", + "from dptb.entrypoints.collectskf import skf2nnsk" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEEPTB INFO Loading skdata from ./H_B_C_N_O_Si.pth\n", + "DEEPTB INFO Automatically determining basis\n", + "/Users/aisiqg/Software/venv/pydptb/lib/python3.9/site-packages/torch/_functorch/deprecated.py:61: UserWarning: We've integrated functorch into PyTorch. As the final step of the integration, functorch.vmap is deprecated as of PyTorch 2.0 and will be deleted in a future version of PyTorch >= 2.3. Please use torch.vmap instead; see the PyTorch 2.0 release notes and/or the torch.func migration guide for more details https://pytorch.org/docs/master/func.migrating.html\n", + " warn_deprecated('vmap', 'torch.vmap')\n", + "DEEPTB INFO Batch 0, subset [ 0 16]: Loss 30.5737, Hop MAE 1.3657, Hop RMSE 2.9285, Ovl MAE 0.6059, Ovl RMSE 1.1461, LR 0.010000\n", + "DEEPTB INFO Batch 0, subset [ 16 32]: Loss 29.2320, Hop MAE 1.2162, Hop RMSE 2.7151, Ovl MAE 0.5685, Ovl RMSE 1.1182, LR 0.010000\n", + "DEEPTB INFO Batch 0, subset [ 32 36]: Loss 29.7914, Hop MAE 1.2224, Hop RMSE 2.6013, Ovl MAE 0.5832, Ovl RMSE 1.1479, LR 0.010000\n", + "DEEPTB INFO ------------------------------\n", + "DEEPTB INFO Batch 0 Summary: Loss 29.8657, Hop MAE 1.2681, Hop RMSE 2.7483, Ovl MAE 0.5859, Ovl RMSE 1.1374, LR 0.010000\n", + "DEEPTB INFO The model is saved to /Users/aisiqg/Desktop/work/github/DeePTB/examples/skf2nnsk/out/lastest_df2sk.pth\n", + "DEEPTB INFO The model is saved to /Users/aisiqg/Desktop/work/github/DeePTB/examples/skf2nnsk/out/lastest_df2sk.pth\n" + ] + } + ], + "source": [ + "skf2nnsk(INPUT = './input.json',\n", + "init_model = None,\n", + "output = './out',\n", + "log_level = 2\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEEPTB INFO Loading the skdict from the file: ./H_B_C_N_O_Si.pth ......\n" + ] + } + ], + "source": [ + "dft2nn = DFTB2NNSK.load(ckpt='./HBCNOSi.nnsk.model/best_df2sk.pth', skdata='./H_B_C_N_O_Si.pth',train_options=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dft2nn.viz(atom_a='C',atom_b='C')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "nnskf = dft2nn.to_nnsk(ebase=False)\n", + "nnskf.save('./HBCNOSi.nnsk.model/nnsk_skf.pth')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEEPTB ERROR TBPLaS is not installed. Thus the TBPLaS is not available, Please install it first.\n" + ] + } + ], + "source": [ + "from dptb.nn.build import build_model\n", + "from dptb.utils.tools import j_loader\n", + "from dptb.postprocess.bandstructure.band import Band\n", + "\n", + "# model = build_model('./HBCNOSi.nnsk.model/nnsk_skf.pth')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEEPTB INFO KPOINTS klist: 151 kpoints\n", + "DEEPTB INFO The eigenvalues are already in data. will use them.\n", + "DEEPTB INFO Calculating Fermi energy in the case of spin-degeneracy.\n", + "DEEPTB INFO Estimated E_fermi: -4.694225549697876 based on the valence electrons setting nel_atom : {'N': 5, 'B': 3} .\n", + "DEEPTB INFO use input fermi energy: -5, While the estimated value in line-mode is -4.694225549697876\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# AtomicData_options = {\"r_max\": 5.0,\"er_max\": 3.5, \"oer_max\":1.6, \"pbc\": True}\n", + "stru_data = '/Users/aisiqg/Desktop/work/github/DeePTB/examples/hBN_dftb/data/struct.vasp'\n", + "kpath_kwargs = {\n", + " \"task\": \"band\",\n", + " \"kline_type\":\"abacus\",\n", + " \"kpath\":[\n", + " [0, 0, 0, 50],\n", + " [0.5, 0, 0, 50],\n", + " [0.3333333, 0.3333333, 0, 50],\n", + " [0, 0, 0, 1]\n", + " ],\n", + " \"nel_atom\":{\"N\":5,\"B\":3},\n", + " \"klabels\":[\"G\", \"M\", \"K\", \"G\"],\n", + " \"E_fermi\":-12.798759460449219,\n", + " \"emin\":-25,\n", + " \"emax\":15,\n", + " \"ref_band\": \"/Users/aisiqg/Desktop/work/github/DeePTB/examples/hBN_dftb/data/kpath.0/eigenvalues.npy\"\n", + " }\n", + "bcal = Band(model=nnskf, \n", + " use_gui=False, \n", + " results_path='./', \n", + " device=nnskf.device)\n", + "eigenstatus = bcal.get_bands(data=stru_data, \n", + " kpath_kwargs=kpath_kwargs)\n", + "bcal.band_plot(ref_band = kpath_kwargs[\"ref_band\"],\n", + " E_fermi = -5,\n", + " emin = -18,\n", + " emax = 15)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEEPTB INFO KPOINTS klist: 302 kpoints\n", + "DEEPTB INFO The eigenvalues are already in data. will use them.\n", + "DEEPTB INFO Calculating Fermi energy in the case of spin-degeneracy.\n", + "DEEPTB INFO Estimated E_fermi: -3.838781952857971 based on the valence electrons setting nel_atom : {'Si': 4} .\n", + "DEEPTB INFO use input fermi energy: -5, While the estimated value in line-mode is -3.838781952857971\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAn4AAAIuCAYAAAAhXgWXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOydd3gU1deA363Z9N4LhF4VqWpsICKiSJVepYMgvSNFWkC6NOkEQRARFRUQBfEXFQUUIfQWSNv0vsmWme+PQD5KErLJbhJg3ufJA9m5c++Zm7szZ+5pMlEURSQkJCQkJCQkJJ545OUtgISEhISEhISERNkgKX4SEhISEhISEk8JkuInISEhISEhIfGUICl+EhISEhISEhJPCZLiJyEhISEhISHxlCApfhISEhISEhISTwmS4ichISEhISEh8ZQgKX4SEhISEhISEk8JkuInISEhISEhIfGUICl+EhISEhISEhJPCZLiJyEhISEhISHxlCApfhISEhISEhISTwmS4ichISEhISEh8ZQgKX4SEhISEhISEk8JkuInISEhISEhIfGUICl+EhISEhISEhJPCZLiJyEhISEhISHxlCApfhISEhISEhISTwmS4ichISEhISEh8ZQgKX6P4NKlS6xatYp+/fpRv359lEolMpmMuXPnPvLcI0eO0KZNGzw8PLC1taVWrVpMmzaNzMzMEstz9epV+vXrR0BAADY2NgQEBNCvXz+uX79e4j4lJCQkJCQkng5koiiK5S1ERWb06NGsWLHioc8//vhjpk+fXuh5y5YtY+zYschkMl5++WW8vb357bffiIuLo2bNmvzvf//Dw8PDLFnCw8Np1aoV2dnZ1K1bl3r16nHu3DkiIiKwt7fnyJEjPP/882Zfo4SEhISEhMTTgbTj9wjq1avH+PHj+fzzz7lw4QK9e/d+5Dn//PMP48aNQ6FQ8P333/Prr7+yZ88erl27xuuvv86lS5cYOnSoWXJkZ2fTpUsXsrOzmTJlCufOneOLL77g3LlzTJkyhaysLLp06YJOpyvppUpISEhISEg84SjLW4CKzsCBA+/7XS5/tK68YMECRFGkf//+vPXWW/mf29nZsWnTJqpUqcJXX33FxYsXqVWrVrHk2Lp1KzExMdSoUeMhM/PcuXP56quvuHz5Mtu3b2fIkCHF6lNCQkJCQkLi6ULa8bMwer2e77//HoAePXo8dLxSpUqEhIQA8PXXXxe737ttu3Xr9pDyKZfL6dq1KwD79u0rkdwSEhISEhISTz6S4mdhLl++THZ2NgCNGzcusM3dz//5559i93u3rSX7lJCQkJCQkHi6kBQ/C3Pjxg0AXFxccHR0LLBNYGDgfW0fRUZGBklJSQAEBQUV2WdCQgJZWVlmySwhISEhISHxdCD5+FmYjIwMAOzt7Qtt4+DgAEB6erpZfRbV790+7/Zb1Pj3kpiYyKFDh6hcuTK2trbFOkdCQkJCQkKi9Oh0Om7evMmbb75pdqaPkiIpfk85hw4dolevXuUthoSEhISExFPLjh076NmzZ5mMJSl+Fuauebcoc+vdBM5OTk5m9VlUv/cmhS5uvwCVK1cG8hZd7dq1i3WOKIqkHzhAyu7d2D73HB7DhqOws85uoT4mBt1//6G/eRNjXBzGxCSEjAyEHB0YTVDcNJQyQKlEbu+A0s0Npa8PNlWrYh8SgsrTs1hdfPvtt/z999/USk6hkVbL91WCSbWxoUmTJrz77rtFnpt7MxLtgvmovLzxmjIZhZ1d8eR+gD179tClS5cSnXsX0WAgcfNmso7/hnP7drh06oRMLkfIySF++QpyL1zAY8Rw7Js2LXafGzduzI+AF41GMo4cIe2bbzFlZeHw6iu4tGuHsozeZsubpKQk1q1bh1qnwy81Fd/MTLyzs1EKIgaFAueGz+H83HPY1q+P0scHmUxmsbHTDx8meft27J9/AfdBA5Hb2Jh1fmnWV8bx4ySuWQsGPfYhL+ExaiRyZfk8Yvbt28e5c+cwGAyoVCpsBIFXr13HxmDgSLWqVG3YkI4dOz6yn7QffyR540aUvn74r1xRrKwO5mKJ77SlMGXryPzlZ9IP/4QpKQlF1apEVQoi1sUFF1dXnn32Wdzd3ctUJt2FCyR8sgSVvz9eE8bz1Y8/Vpj5sgQXLlygV69e+c/iskBS/CzM3T9eamoqGRkZBfr53b59+762j8LR0RE3NzeSk5O5desWzz77bKF9enh4FNvMC+Sbd2vXrk3Dhg0f2d6UmYl23nwcDh+m3ogReAwbhswCN0MhJ4fM334jKzycnHMRGGJiMKWlYWsy4Xy3kVKJ3N4ehb8/Sg8PlK6uKNzdUHp4oHB3z3vIKZTIVEqQyTClpWNKSsKUkowpJRVDXCyG2DhMKSmIsbFw6jTs+RKZrS3qoCBsGzfGtXs3NNWqFShjw4YNiThxgpxhw7lRsyZ1Xgqhffv21K1b99EX2LAhOXVqc3voMGw2byZg1SrkZvyd7vLHH38U6+9UGMaUFGImTsLx7Fl8lnyCU5s2AJjS0oj6cDROsTH4b9poltIH4Ofnd79cTZsijBlD6pdfkrxtO8KpmTi3a4dL1y7YVKmS30yr1RIeHk5SUhLu7u6EhITg7e1d4usrirIcy87OjrCwMDICAkgTBK4CPlnZtA0OxlOrRff1fvhyLwp3d2wbPIvts89i26ABmho1kKlUJR+4YUMyGjcm9qOZqD9djf+iUFT+/sU+vSTry5iaSvSYMdj+8Sc+Tk74LVuK48svmyu5Rbl58ybx8fHk5OSgATpevoyrQsGe2rVwdHOjYcOGxbvOhg3RKpQkb92K/dp1BG3aaHFZS/udtgSmzCxSd39B8o7PcdbpqNX6TSJr1WLrsWMIBgOCVkt8QgJXr16ld+/e+ZkpyoSGDclp1IioER8gWxiKb9Mm+Hy9H5lKhUypRKZUIFOrkSmVyG00KFxdULi5ofTwROHpgdLdHblaXXbylpCydLWSFD8LU7NmTezs7MjOzubkyZM0b978oTYnT54EMOvL3rBhQ44cOcLJkydp27atRfo0F91//xE7bRqmtHR8Fy7A6Y03StTPfUre2XPob99GyMjI372TaWxQenhgU6sWmtq1sGvcBNtGDVGasZP5SBmMRnQnT5J++Cd0p0+jv3WL3EuXSP38c+TOztg3bYpr714PKUCe//sfqfZ2tN8RhtLMN19NrVoErP6UqGHDifpwNAGrViI388vepEkTs9rfS+6NG0SPHoOQmUngurXYNmgAgCE+nqiRIzElJBK4bh22xVFkH6BmzZoPfSa3tcWtTx9cOncmZfceUnbuJHXvXmwbNsSlUyfOamwI++ILBEFAEATkcjmHDx+2yoMlPDycsLCwMhkLICQkhGrVqhWqaApZWWT/+y+6f/9F9+8ZElevQczNRabRYFuvXp4y2KABmvrPoHAw7wXBsWVLVIGBxIyfwM1evfGZMR3HFi2Kda4560sQBBI//ZTkjZsQDQbsQ0Ly1nQJd7MtSUhICIcPH8ZeJuPti5dwy85mb/XqpDo7o5LLzfqbe0+eRO61q2T99j/ily/Ha/Roi8pamu90aRH1elL2fEnS5k2I2TqcO3TArV8/khHZOnMmBoMBg8GQ316lUhEWFka1atWs9tJUEDZVq2LXpAlp335LsFJB2pWr5nUgk+Upira2KBwdUbi6ovT0RB0UhObZZ7Bv2tTs+/njjKT4WRi1Ws3bb7/Nl19+yc6dOx9S/CIjI/n9998B6NChQ7H77dChA0eOHOGLL75g5syZ95kcBEFg9+7dAMUyX5iLkJ1N4po1pOzeg6ZeXQLXrSv2LoKQnZ2n5P3+OznnIgpQ8jQofXywf/FF7Jo1xallS5TFNL2WBrlSif3zz2N/T4m73Js3Sd62jcxjv5Jx5AgZP/2E3MEBhxYtcOncGSE7i5Q9X+IxZEiJbxK2desS8Okqbo8YQfToMfivWI5coyn2+dUK2Y18FNmnTxM9dhxKT0+Ctm1DHZD399Pfvk3U8OGIJoHATRuxCQ4uUf+NGjUq9Jjczg73/v1w69mDjKPHSN33FdFTp6IQBF5wd+OyoxNRjg6IMplVHixarZawsLAyf4h5e3vToV07cq9dQ3fmDPrNW7h9+zZGrRZTZgZCZlbe90AmQ2Znh8LFBYCcK1fIPnkS0WAAuRx1UCCaZ57F7rkGaOrWxaZq1UfuCmpq1qTS5zuIm/MxMRMm4tj6TbwnTkTh7FzkecVdXxm//krcjBkY4xNQennitzAU+xdfKNa5ZYG3tzd93n0X3azZOObk8F3t2qS65Cl9vXv3NvvvHbB+PdffbE3S+s/Q1K6D05utLCZrSb/TpUEURTKPHiNhxQoMMTE4t2+P+8ABqO7MS/i+fQiCgMFgQKFQoFAoMJlM+b+Hh4db5VlTEPqoKGKnTSf34kV858/D+5VXcHFyAr0eQa8HgwFBr0fIyUHMysaYkowpORlTSkreT3o6prR0jImJeRagjAyMV6+SExEBgvD/A6lUKJydsalaBdvGjXF68000NWqUyTWWNVKtXjPp168f27ZtK7JW7+nTp2ncuDFyuZwDBw7QunVrIK/s2rvvvsvPP/9Mp06d2Lt3733n/fXXX/Tp0weAixcv3ncsOzub6tWrExMTw9SpU5k3b17+sWnTpjF//nwCAgK4fPmyWVvGp0+fplGjRpw6deqh3ULRaCT9hx9IXP8ZptRUPIYOxbV7N2SF+O0YU1PJ+uMPsv4XTs758xiiohAyM/9fybO1ReXjg02tWtg1a4bT6y3KRMkrCcbkZJK3bSPt2+8wxsaCTAYKBUpvL6p+/71ZylpBZJ/+h6iRI7F99ln8ly0tti/W6tWrGTFihFljZRw9SuzUadg+8wx+Sz5BcScCPOfSZaJGjkTh4EDAmtWofHzMvo67zJ07t8ja1Q9y4LPPSP7yS6okJOJgMJCrVHLd2Zmrzk4keHjwWtu2Fnuw7Nu3j4MHD5KTk3PfQ8xkMqHRaGjdurVFH2KiIJD990kyfvqJzF9+wZSWBgoF6uDKqAMCUfn5Ind0Qu5gj0wuRxQExOxsTKmpmNLSMKWmYkhKxhAZiZCRgSgIeQ8oUQS5HJlSmeejWr0Gts8+g12TJmhq1ixwTYqiSMaPP6INXQQKOR6DBuX5dBZi+nrU+kr78UcSlq/AEBmJTK3GffAg3IcPt4rvW2nQnT1LzKTJGA0GrnTsQKxSWWrzvjE5mWut3kTU5xL8zTclfkl6kJJ8p0uD/vZttAsWkn3iBPYvvoDn6NHYVK16X5sNGzZw4sQJ9Ho9arUauVyOIAj5vzdr1oxBgwZZVc48X/Lv0S4KRenmju/cudjWr2fR+dLHxpJ94i90Z8+iv3oF/a3bGBMSwGjMa6BSoa4UhMNLL+PSrSs2VvDDK+oZbC2kHb9HcPr0aYYPH57/+7Vr1wBYv349Bw4cyP/866+/xtfXF8gzty5ZsoSxY8fSpk0bXn31Vby8vPjtt9+IjY2lZs2arFu37qGxsrOzuXTpUoFy2NnZsWfPHlq1asX8+fP59ttvqVevHufOnePcuXPY29vz5ZdfWsRPwJSeTvqPB0ndvRt9ZCSOLVviMXIk6gD/vC//jRvoTp0i+8x/6K9exRAdjSk1FVGvz+9DZmuLytcXzSuvYPd8Mxxffx2lm1upZSsrlG5ueI0Zg9eYMeRcvkLql1+S8uWXGKNjuNq8BW59++I2eFCJH3h2DZ8jYMVyoj4cTcz4Cfgt+cQqfiip+/ejnTcfxxbN8fn44/wxsk//Q/SYMagCAwhYtQqlq6vFxy6KWJmME5UqccTHhwCDgaopqQQnJVE7MRGu30B//QZxEeexbfAsmrr1UAcFFvrC8SiSkpIQ7rzZKxSK/L+ZyWRCEIT8HJmlRdDrSf/hB1J2fI7+xg1U/v44t2+P/YsvoKlb12yzviiKCOnp6KOiMNyOIvf6NXRnz6G/fh1jnBbDrdtk/vRTXmO5HLm9PUpvL9SVg9HUrYvts8+gqV8fpzZtsGvalMR164lfuoyUnTtx6dwZp3ffLdbfPefaNZI+20DmsaMIaemgUuHcoQM+06eVyE/VmohGIyk7d5K4eg02dWoTtHAhNS20m6t0cyNo82Zudu9OZPceVPv5SIW7/qIQ9XqSw8JI2rgJpYc7/suX4/DySwW2dXd3v+97cu+/crnc6gEeuVeukLByJVm//4HTu23xHj/eKnOt9vVF3b4dLu3b5X8mCAK55yLI+Okw2X+fJOfyZZK3biV561bkzs44vPQSbgMGYFuneMGQFRFJ8XsE6enpnDhx4qHPo6KiiIqKyv89Nzf3vuNjxoyhfv36LFmyhL/++ousrCyCgoKYMmUKU6ZMKTS5c1GEhIRw5swZPv74Y44cOcJXX32Fp6cnffr04aOPPqLqA29t5hC/chW3lAr0UdEYY2MRBQGFqwtKfz90//3Hza5dETIz85S7ezaJZWo1CldXNPXqYlO9OrbPPovDa689Vkreo9DUqI46MACZQoFTp05k/PQTCcuXk/jZZ7h07IDX+PEl2gG0a9wY/yVLiB4zhphJk/APDS10J+YuxVXsRVEkectWElevxqVzJ7wmTkSmUACQ8ctRYqdPx7Z+ffyXLrHIDVVxp+/ikv9gkcmItbUl3sGB//n5YpedTbBez/NubujOnSVt/34gb52pq1TBpmpVbKpVQx0cjDq4Mipf3/zreuRYWOchJooiWf/7H/FLlmKIisLh1VfxnjYV2wYNShWxK5PJUDg7Y+vs/JDfpSiKmJKTybl8Gd3JU+ScP38n8l2L/tp1Mo8cudsJKBTI7exQODqi9PLClJ5B/JKlxC9ZitLTE1WlSqi8vZC7uKDQ64mbMwdDbFyewhkdhZitA0Dh4YH70KF4DB1S6h1va6A7exZtaCi5Fy/h2rMnniOGP/L7ZC62z9THZ9ZM4j6ayc0ePan89b5S73aWhVN/7vXrxE6fQe7Vq7j16oX74EFF/g3v+kiqVCoMBkP+90WlUiE300fSHAzR0SRu3Ej6dwdQBQbit+QTHF977b421p4vuVyO7TP1sX2mfv5nuvMXSN2zm8xjv5L+ww+kf/89Cnd3nDu0x3PYsMfqBQAkU+9Tz91t5r2VKlPnwRuBUpnnEKtWo3ByQunhgcrPD1VgIJratbFr1hTlHb+kJ5mcS5e51acPLj264/XhhwiCQOru3SStXYcxPh6ZRoNrr554jh5dovQVWb//TvTYcdi//DJ+8+eVLqqTPFNjwtKlpOz6AvfBg3EfPChfAUneuZOEpctwfP11fObMNjvdh6XQarXMLMR5XKVSMXv2bLy9vTGlp5N76RK5V6+Se+Vq3r/XriHm5AB5CqEqKBCbypVR3/tTqVJ+kEFxxyoJxpQUtB9/TOavx7Fr1gyvcWMfMpuVNYJeT+6lS+jOnCHnwkUM0dEYE+IxpaUjZGfnvbzdNWU9ijuKIyoVCnt7FM7OeT9OTnkO8t5eqLy9Ud75UXl7o3Bzs0ikf3EQRRHdP/+SsiOMzF+PY1O9Ot7TpmFbv55Vx42dOZPU3XtwatsW/8WLrDpWaRAFgdQ9X5KwciUqPz98536MplatYp0bHh7O9u3b0ev1iKKITCZDrVbTp08fiyp+otFIVng4qXu/IuuPP1A4O+M+eDAuHTuU+l5oDfTR0SRt2EDGwUOYUlNBqcSucSO8Z8xAU4LvfnmYeiXF7ynn7qL7bfNmGjZpisLBHoW9PfJ7dkmeZkRR5Fb/9xF02VQKC3vIHJv244/EL1iAMT4BuYMDHkOG4DrgfbPnLvP4cWImTMShRQt8P55TqFlz//79tG/fvnB59XpiZ88m49BhvCZOwPVOvivRZCJ+6VJSv9iNa5/eeI4cadGH88qVKxk1apRZ5xQUaSu/43xf1INFFASM8fHob95EfzPyzr95P8aEhPx2qqAgNLVrY/vss1xUKth2+DCCKJo1VlFk/XmC2JkfgdGE97SpODRvbtGcfNYmz+k9Lf/HGB/PochIWteoicLDAxkiGI15jvMZmZjS0xDuOMqb0tIwJidh1MZj1Grvd/NQKlF6eaL08UXl44PS1weVtw8qP1+U3j6ofH3MNnvfi2g0knv1Kpm/HifjyBH016+jqhSEx6BBOLZq9cgdYEtxo2tXcs78h/f06bj1Knni3Ud9p0uKIT6euNlzyP7zT1y6dcVz5EizdmrDw8PZtm0bBoMhX/FTqVT07du31IqfKTWVrBN/kfnbcbJ+/x0hLR1N3bq4dO6EY6tWRcpprfkqCRm//ELi6jXkXDgPImjq1sXno4/u2y18FJKPn0S5Yffss9jVMz+Nx5NO1v/CyTl7loDVqwv0wXN+6y2c33qL5F27SFyxkvglS0jatAmP0aNx69a12OM4vPIKvgsWEDN5Mijk+M6eXeADLDo6utA+BJ2O6AkT0P19Et/583BqlRd5aMrMIu6jGWT+9j+8Jk/C9b33ii1XcSlu+cF7eVTKk8KQyeWofHxQ+fjcF5UNedeqj7yJ/voNci5eICfiPJk//4yb0cgYd3fiK1cmqlIlbOrUIeSll0q805eyaxfxS5Zi17QpvrNnVdggpaJQODmhcHKCO3W+ARJXr8a5zVtm9SOKIqbUVIxaLUatFkPcnX+1cRiio8k+fRpjfPx9EZQKZ2eUvncUQx9vFM4uKBwdkDs45O3UiiKiSQBRQNDlYEpOyjM/37xJzqWLiNk65Pb22L/8El7jxmHXtEmZ7TLepdK2bVx9vSXaBQuwfeYZsx7291LUd7qkZP35J7FTpyFTqQhY/elD35NHcTcS/m4Q1F3kcrlZkfCCTochOhpDdDT66GhyL18m57+z6CMjAbCpUQOXzp1xbNGi2DuR1pivkuLYogWOLVqgv32buNlzyPrjD2527YqmXj38Fi+ySjCIJZAUPwmJQhAFgcR167Bt2BC7ZkUnNHbr3h2Xrl1J3riRpPWfoZ01i6Q1a/CeMb3Y+Q4dWzTHd+7HxE6bjkyuwGfmR8XevTClphL14Whyr1/Df8UK7J9vBkDu9RvEjB+PMTER/6VLC3XmflJQONhjW7cutnXr4tz2HSDv4aM7c4bMX4+j+OVnvE6dwubSJWzt7RFbtjQraEQ0mYhfspTU3dbZOX0ckclkKF1d8wJFCnl4iwYDxsREDLFxGO8kUjdo4zDGxpL91995u4mZWfkm/AcGyFMUfXxQV6qEe0hIXsLrenUt7sNnDnKNhkqf7+DGu+9y6/33qXrkp3J3fREFgeQtW0hcuw77F17A9+M5+WmCzCE8PLxY6VxEkwljQkK+cmeIjr7jGxqTl4T/nsApmY0N6uBg7Jo2xX3QQGyfe65UmQQqEurAQII2bsCYlETstOlkHj/O9TZv573QL1xQ7uviQSRT71NOeWwzPy5k/PwzMRMnEbjhM+zMmBvBaCRh2TJSdnyOmJuLumpV/BYsKPaOQPrBQ8TOmIHjm63wnTXrPsXk6tWrD+X9MsTFETXiA0xpaQSsXIGmTp18+WNnzULl44v/J4tRV6pU7Gswl+PHj/PKK6+YdU5JTb2lQTSZyD5xguQdn5N94gQ21arhNXkSds89V6xz42bNIv3gIbwnT8KlUyeryFieFLS+yhJRr0fQ6fJyGyoUoFDcqc5Qcfco0g8dInr0GNSVKxP8/QGz3TwsNeemjAziZs4k89fjeb69gwaW+KXk3nQu9nI5rno9jjod9lnZuBqNBNvZ4qdSY4yJQbzHX1Tp5YXK3z//Rx3w//9XuLtbxBWivNdocci9eZOYCRPJOXcOmVqN54ejcH///QLbSqZeCYkKgigIJK7/DLtmzcxS+iAvObT3hAl4jhhB7KxZpH//Aze7dsX2uQb4hYaivse0VhBOrd8EuYzY6TNAEPGdM7vQB1/u9etEfTAS5DKCNm1EXakSpswsEpYuIe2bb3F84w18PppRIaop3Et5JVWWKRTYv/gi9i++SM7582gXhnJ74CCcO3bEa/y4QoNd8pS+2aQfOozv3LkWTeAr8f/I1GoUj0F5rXtxevNNdH37krx1KzFjxxGwfFmZy5B79SrR4ydgSk0tMk1LYYiiiDEmhtzrN9BHRlLn9z/wv3gR5+xs7O9R7AxyOem2GpQeHjg8/3yeUhfgj9rfH6Wvb7kFi1U0bCpXJvjLPWSGhxMzYSLxixaTsnsPAatWVoik0JLiJyFRABlHjqC/dg2f6dNK3Ifczg7/RYvwnjSJmImTyPr9d6692RqHV1/Fd87sIv3CnO44qcdMnQYmE75zP0amUnHo0KH8t13df/8RNXo0Sk/PvFx8np5k/vYb8YsWYUxNxXvGdJzbtSuTgANzd/yKa0qyJpo6dQjauoW0ffuIX7KU3MuX8Vu8CJWX133tRFFEuzCU9IMHn3il7971JVF8vCdPQnfuLBkHD5K05Vnc+/cr9rmlnfOs338nZtJkVP7+BOwIQx0Q8MhzDPHx6M6cIffCRXIuXCDn4kWEO366Mo0GLz9f4mzURDk6kqhSkaqxIU1tg9FWg0qtZvbs2XiVYcm2e3mc1qhDSAjV/vcb8fPnk7LrC26074Dzu23xmTu3RBkgLMXT7ZwiIVEAoiCQtHETdi88j+0zz5S6P6W7O0GbNhL83bdoatcm89gxrrzWnFuDBqGPjS30PMfXX8dv4QIyjx0jZuq0+yInM8PDuT1sODbBVQjasAFTUhJRH4wkevQYVIFBBH/xBS7t21fYKNOCkirfzQVoyaTKj0Iml+PSuTNBmzZiTEjgVp++6G/duq9N8patpO3bh89HM55opU+idARt3ozCw4P4Tz4h+/TpMhkzZfceoj4cjW3jRgRt3lSo0mdKTSXjyBG0C0O50akz199qQ+zkKaQfPJhXU7tnD/xXrqDK9weo/ttxqn/5JT7z5nG6SjA3/f1IdnVFdHRApVaXqOTd04xcLsdn+nSqHvwRm2rVSNv/DVdCXiLjl1/KTSZpx09C4gEyfv651Lt9BaGpVo3gr/ai++8scbNnk/W/cK693hK7xo3xmjy5wEzwjs2bI1u8iJiJk4iZPAW/kBdJ+fJL4j9Zgl2TJji1eoPoMWPR/fsvqsBA/Jcuwf6VV8pc4XNycjKrfXlXBngQTZ06VNq+jdtDhnJ72HCCNm1E6e5O2jffkLh6Ne6DB+Pctm2ZylQe+BezBrfEw8jVairv2sn1t9/h9qDBVP3pcLES2Zdkzu9Lz9SjO56jRz8UCGaIjyfz6DEyfvkZ3el/QBBQBQVh16Qx7oMHY9eoIUoPj0LHKGnUvbV5XNeoOjCQKt9+Q/KuXcSHLiJqxAfYNWmCcUDBvn/WRArueMqRgjvuRxQEbnbrjtLTk8DVn1p1rJzLl4mbPRvdP/+AIOaV+OrQHtd+/VDeqad7l8z/hRM9diyiXo9oNKJ0dcWUk4NMELB97jlce3TH4ZVXKrQT/L1YM6lyaTBo47k9cCCiyYSYm4spNRXndu/iPWNGhd09lahYZBz5maiRI1EFBlLl4I8Wz4cqZGURM3UaWX/8gdeE8felZzJlZpL+449kHDyE7swZUCiwa9IYxxavYx/yIippp65CYMzMJGb0GLLCwzlvMND52tUyfQZLpl4JiXu4u9vnMdi6BcgBNDVqUPnzz6n6yy84tW2LMSWFxE9Xc6VpM66+0YroSZNJP3QIY2oqQlYWAEdeeQVNrVo4vtUan8mTqfL9AYI2bsCxRYtyVfoWLFhgVntvb2969+6NSqVCo9GgVqvRaDSoVKpyNSWpvL0IXLcWdWAgTm3fodLOz58qpW/z5s3lLcJjj2PL13EfNAjDrVtEj3x0UnNz5twQF8etAQPRnT5NwIrl+Uqf7lwEsR/N5NqbrYlf/Alye3t8Zs6k2k+HCfz0U1w6dnhilL4nYY0qHRwI2riBwI0bUAcFlf34ZT6ihEQFRRQEkjZsxO7557F99tkyG1ft45Nf9inj6DFSduxAd+4s6d9+S/o33+S3k6nVGGzUyO3skClVyO3tkFWQKLp7k7wWl4pqSlL6+uLc7l00detaNQVORUSn05W3CE8EXmPHoDvzL5k//0zSpk24DxhQaNvizrkuIoLosWORKVUEbdmMukoVMo8fJ3l7GLp//kHl74/7gAE4vfP2QwFKTxJP0hoV70lqXpZIip+ExB0yf/klz7dv2tRyk8Gx+Ws4Nn8NAGNSEslhYSRv3YZMoUDu7g4yGdmnTpF7/Tqpu3eDUonDK6/g1qeP1euTWgNvb2+rR++aS8rnO0lYvhwA20YN8Ro9Oj83ooREcQncsIFrLd8gfslSNPXrY9+06CTwRZFx5AixM2dhU60afqELyT5xgpjJU9DfuIHmmfr4fbIYh1dffeqTiT8uCFlZ3B4+nOy//kZ/j6tLWSH5+D3lSD5+eYiCwM3u3VG6exC4ZnV5iwPk1YKNHjcOTb26BCxditzenqSkJOSHDxO/ZCmOrd5AU/8Z0vbuRX/zJg7Nm+M1YQIq77J/279+/TpVqlQp83EtTc6lS9zq2w/nTh2xrV+fpM1bEHXZVN6zp1T1ZR8XkpOTcStGQIJE8dDHxnK99Vsgl1PtyE8oCwhaKmrORVEkectWElevxvGNN7B//nmSNm/GEB2Nw6uv4tanN7YNGlj5KioWj/sazfjlF2ImTETIzsb+pRDi+val2csvSz5+EhJlTeYvv6C/Wja+fcUh48gRokePxq5hQwJWrEBubw/AtWvXcO3eHd85s8n46Qj6q1ep9MUufD+eg+7sf9zs0oW0b7+lrN/nTp06VabjWQMhJ4fYadNRBwfj+eGHOLVujf+STzAmJZP42WflLV6ZcPXq1fIW4YlC7euL/6pViLm53OzSFeGeZMh3KWzOhdxc4mbPJnH1ahxatCDn2jXiPv4Ym2pVqbRrJ/5Llzx1Sh88vmtUMBqJ+nA0USM+QBQE/JYuIWjDBpTlkFxfMvVKANC5c2dsi7GjERERUQbSlC2iIJC4YQN2zZpViBtp6ldfoV2w8P9LtqlU+cf+/vtvmjZtilObNoiiSNzMWSCT4T11CvYhIcQvXUbc7Dlknz6N99SpyMuoCsKlS5fKZBxrkrhmLYboaCrtCMufN3VgIO4DB5K4bh1OrVujqVmznKW0LnfXl4TlcHzlZTyGDyPx09XcfO89Kn/11X2RvgXNuf7mTWKmTCX36lWU3t5k/vILds2a4fvRR4+lS4cleRzXqO6/s9weOhRTcjK2DRoQ8Nl6lGamwLIk0o6fxFNP5tGjFWK3TxRFkjZtQjt/AS5duuD78cf3KX0P4vz22/jMnEna/v1oFy5E7uSE7+xZ+H48h4xDh7k9eAjGxMQyvILHF93Zc6Ts2oXHsKHYVK163zG33r1QB1dGO29+uTljSzzeeH7wAS49epB74SKRXboi3JOM/V5EUST122+50aUruZcv56Vu8vIiYO0aAtesfuqVvscNQRCIm7+Am926YcrIwGvqFCp/satclT6Qdvwk7rB3796n0sdPFASSPiv/3T5REEhYtoyUnbtwHzoE94EDC0whUq/e/Td+57bvACJxs2Yj19jiOWY0Tm3aoKpUiZhx47k1cBCBa9eg8vW1qvyBj6g/XJER9Hri5sxBU7Mmrj16PHRcplLhPWkStwcNJuPwT3m1lJ9QHlxfEpbD96MZiDodaV9/zdUWr1MpbDs2wcHUq1cPURTRnT5N3Lx55F68BHI5tg0a4DF0KPYhLz416YSKw+OyRnOuXSNq6DAMt2+jqlyJoC1bUFv5PlxcJMVP4qkm8+hRcq9eJXDypHKTQTQYiJszh/QfD+I1edJ9CVkfpCATh3PbtgjZOuIXLULh5Ij7wIHY1q1L0KaN3B42PE/5W7PaqqlJ2j7GVS2SN2/BcOsWlXaEFZoL0a5hQxxefZWET1fh0Py1J7YY/eNmQnvc8FswH5uaNYlfvJjrbd5G6emJp4sLl8dPQMjIALkcTb16eI0di12zppLCVwAVfY0KgoB27ry8rAuAW79+eJfj86UgJFOvxFPLvbt9ds89Vy4yCDod0eMnkHH4J3znzytS6YPCk5e6du2S50e0dh0pu/cAoPL3J3DjBuS2ttweOgxDEXWBS8uaNWus1rc10UdFkbx1K659+2BTvXqRbT1HjcQYn5B/Q38SeRKS41Z03Pv1JfjrfTi++Sai0cihGtVRuLnh0qsnVX78geA9u7F/vpmk9BWCuWs0IiKCefPmMWHCBObNm2dVP/WM479x9ZVXSd25M69yy4HvKpzSB9KOn8RTTOaxY+W622dMTCRq9Gj0NyPxX7Ec++efL1V/bu+/jyk9g/hFi5Db2+N8J5Fr4No13BowkNvDRxC0cUOBKSWeVuKXLEHh7o77+4+ul6muXBmXTp1I2rQZ53btUDg7l4GEEk8imho1CFi+DICfVq+m2ieflLNETyZbtmzh6NGj+b9rtVpCQ0Np3rw5/fv3t9g4+shIoseOIyciAplajde4cbgPGmix/i2NtOMn8VSSv9vXtGm57PblXr9OZL9+mBKTCNq4odRKH4BMJsNz9Ic4t2tH3Jw5ZBw7BoDS05OANWsQs7OJGjkKU2ZmqceyFFqtln379rFhwwb27duHVqsts7Ezf/sfWcd/w2vMaOQaTbHOcR80ENFoJGXnTitLJyFR/pTn97O0RERE3Kf03cvRo0ctsvNn0MZze+gwrr3VhpwLF3Bs2ZJqv4dXaKUPpATOTz1PawLnu0k0AzdswK5h2Sp+2X//TfT4CSh9vAlYsQKVj49F+xdNJmKnTiPz11/xX7EC+2Z5PjG5V65wa9BgbGrWIHDVKmRllOqlMMLDw9m+fTt6vR5RFJHJZKjVavr06UNISIhVxxb0em526YrK15eANavNMqvFL1tO2tdfU+XAdyjKOTpPQsJahIeHExYWhiAICIKAXC5HLpfTu3dvq38/LcG8efOKTDNVs2ZNpk2bVqK+9dHRxM2cRdbvv4MooqlTB99FoWgeyAhQHMrjGSzt+Ek8deTX5G3atMyVvrQD3xP1wUg0desStGmT2UrfwYMHH9lGplDg+/Ec7Jo0JnrcOHR33mxtqlfHf9lScv49g3bRYosmeV6/fr1Z7bVaLVu2bEGn02EymRAEAZPJhE6nY8uWLVbfWUjZ8TmG2Fi8Jow325fKrU9vRJOJlJ27rCRd+VGc9SVhWSrinGu1WsLCwjAYDOTk5KDX68nJycFgMBAWFlaq76eg1yPodAjZ2QjZ2Wbfh4o7X6mpqaU6XhBpBw5w7Z22XGv5Blnh4Wjq1aXy3r0Ef7W3REpfeSH5+Ek8dWQe+5Xcy5cJ3LChzMYURZGkDRtJWr8ep3fb4jN1apE5+grj2rVrxWonU6vxW7yY20OHEf3h6Lyi7oGB2D33HN7TpxE3azbqKsG4FZC+pCQkJCSY1f7w4cPoC8llptfrOXz4ML1797aEaA9hiIsjadMmXLt2xaYEZeaU7u64dOpEyq5duPbsgcLR0QpSlg/FXV8SlqMiznl4eDiCIGAwGFAoFCgUCkwmU/7v4eHhRdbYNiYnk3PhAvobN9HfvIn+ViTGxERMiUkIWVn3tZVpNKi8vVH6+KCpVRPbho2wa9K40Mj54s6Xi4tLkQqqi4tLsfrJPnOG5A0byfrzT4TMTFCpcHjlFTwnjEdTrVqx+qhoSIqfxFNF3m7fBuyaNCmz3T4hJwftvHmk//AjHsOG4jZgQJlE7Mk1GgKWL+PW+wOIGvEBQVs2o3R3x7ltW3KvXydh2XLUlSrhUA5mm0dV+rBmJZCE5Xkl8NwHDy5xH259epO6dy8pO3fhMaTk/UhIVESSkpIQ7iQrVygU+ZVG7u7OJyUl5bcVDQZyzp9Hd+Y/ciIi0EWcwxgbB+QpderKlVEHBaGpXQeluzsKV9d7XnpFjElJGOO0GGJiSP/hR5K3bUdmZ4vTm61x7drlkdH2hdG+fXtCQ0OLPF4Qgl5P+g8/kn7gALr//kNITweZDJW/H279+uI+eHCZVUSyFpLiJ/FU8f+7fWVTe9Wg1RI9bhz66zfwnTev1Ml/X3nlFbPaK1xcCPh0Fbf6v0/UqA8J+mw9cnt7PD/4AP2Nm8ROnUalzz9HHeBfKrkeB/9QrVbL6Z07CfjhB7Qd2uOYlYm3g32J+lJ6eODSqSMpO3fi2qP7E7PrZ+76kig9FXHO3d3d71P27v1XLpPhpzeQHLaD7L//Jvuf04jZOmQaDZo6dXB8vSWaunXQ1KmLys8Xmbz4HmWiKKK/cYOMn46Qtn8/aV9/jeObb+I58oP8JPTFna+6devSvHnzAgM8mjdvTt26dQHQx8aScfAQWb+Hk3v5CsaEBBAEkMtR+fri3L49HoMGovT0LPZ1VHSk4I6nnKcpuEMUBCJ79kLh5ETg+nVWH0/3779ET5yETKXCf8knaGrVKnWf0dHR+Pubr6TlXLrM7UGD0NSvT8CypcjUakwZGUT26o3c3p6gzZuKHdlaEP/88w/PmREdHRYWxk8//VTo8TfeeMOipt7w8HDCtm+nw5kzyAWRL599BrlCUSpHdWNCAtfbtcetX79yL/dnKUq6viRKTkWcc61Wy8yZMzEYDBj0elxycwnKyKByZhYBGRk4y+UoNBpsGzTIs540bYKmZs1CE6BrtVrCw8NJSkrC3d2dkJAQvL29i5RBNBhIO/A9SevXY8rKxGv0aJw7diQmJsas+YqIiODAnj3Ibt/G32iigZMT9klJGKKjMaWmIt51OZHLUbi7o6lRA8fWb+Lctm2p7onFpTyewdKOn8RTQ1nu9qXu+5r40FA09evjtygUpZubRfrdv38/I0aMMPs8Tc0a+C/5hKiRo4j7+GN8Zs9G4eiI36JF3Orfn/hFi/H5aEaJ5fr+++/NUvxatWrFr7/+WqCfn1qtplWrViWW5UHuOqoHxsfjnZ7B3hrVycnNRaVSERYWRrVq1R75ECoIpacnLh07/P+un4ODxWQuL0q6viRKTkWcczeZjAE1anL9wHf4p6bikKtHlMmId3BA1bo1lTp3QlO/frEq2BQUHXzXh7eoly6ZSoVLh/Y4vvEGCStWoJ2/gMxfj7PP24vurq6IegOiQY9oMOYFiqSlYcrMQEjPyA8cETIzkefk8O6d3cq75KjVKFxd0dSri02t2ji+3gK7Zs2QF6K4Pmk8HVcp8dRzv2+f9d6qRL2e+CVLSd27F5fOnfEaN7bc06bcxa5JE3zmzCZ26rS8UlGjRqGpWQPvKZOJmzUbzTP1cSnE78XSeHt7079/f7Zt24bBYMhP56JSqejbt2+JFLHCCA8PRzSZeCHyFrecnYnz8EBhhqN6Ubj26UPqV/tI2bULj0FPxq6fRNmg++8sKTt3YlSriF++Auf27bCpXLlcZDEmJZF98hTZp06SffIkhshbOAENK1cmrnp1rnh4oKxXjxdbtDDru3lvdLDBYMj/3JyXLoWDPT7TpgKQsmMHprdakxi24+GGcjkoFMhVKmRqdV7QSFAQSi9PVH5+qIMqoa5aFdsGz6J8ytMwSYqfxFNBWUTyGuLjiZ06jZyzZ/GeNg2Xjh0sPoZbKXcOnVq1wpSURPwnS1B4eODWowfObduiO/Mf8aGL0NSqVSKTtKYEJpGQkBCqVatmtgnIXJKSkqgVF4dbTg4/1ahRpKO6uai8vHBu356UXbtw69EDuX3JfAYrCqVdXxKPRh8dTWTvPhhjYkAmw/bll0ja8yVJ69ejcHfHtUsXnN55B5sqwVaTwZiUhO7MGbL/Pkn2qVPo70TKqitVwr5JE2yHDsWucWOUbm6ULLQij9JGB98lZc8e0vbtw+W99/D09yN46FDkNjbINLbIbNTIHRyemt06SyDNlMQTT/5unxXz9mX9+Sex02cgUyoJXL8O2wYNrDJO9+7dS92Ha/fuGBMSSFiyFKW7B05vtsJrwnhyLlwgZspUKn++A7mdnVl9jh8/vkSyeHt7l3i3rbh4ODlRNyqai25uxNlqUNzJGQggl8txL2UJO7e+fUjbt4/Ur77CrU8fS4hcblhifUkUTsYvvxA9egyi0YhLt664DxlCLR+fvN2/bdvI+PlnEtetI2nzZjS1auHYqhWOrVqVKvjKlJGB/to1dBER5JyLIOfcWQwxeXW7VQEB2DVujPv7/bFt2BCVl5elLhUwLzq4MNK++4740EW49uiO59ix9JJqGJcaSfGTeOKx5m6faDSS+NlnJG/egt3zzfD9+GOUrq4WH+cuu3btssjD2eODDzAmJBI3cyZKN1fsmjTBb/48bvbshXbRInxnzTKrv08++aTEyp+1eU4bT7LBwIlKQZhMpnylT6VSIZfLS12FQOXjg1PbtiSH7cClS5cycQi3FpZaXxIPk3HsGFEjRyG3sSFo65Z8l5O7c263dAmG+Hi0CxaS+csvmDIzSdq4kcTVq1EHB6OpXQtNnTqoK1VC7uSMwsUZmUqFqNcj6vUIGRkYEhIwJSaij4rKy6F3/XpelCogs7FBU6sWDs1boKlXF9tnnrF41aAHKTI6uBgvXVl//kncx3Nx7tABz7Fjkclk0hq1AJLiJ/FEk1eT9zOr7PYZtPHETpuG7r//8BgxAre+fcxKXVASkpOTLdKPTC7HZ8Z0jElJRI8bT9CmjdhUr473pEnEzZqF/fPP49S6dbH7y8nJsYhclsaUmorhq6/g9dfR5eagKaD8lCVMy279+pH27bek7f8G125dLSB5+WCp9SVxP1knThD1wUjkNjYEf70PdaVK+cfunXOVlxf+S5eQtm8f2kWLsW34HE5vtSH3/Hlyzp8n48jP/x+FWgh3EyKrq1bFud27qIOroA4OxqZKcImSxpeGkJAQDh8+jEqlwmAwmPXSlXv9BjETJ2H//PN4T5mcn/tUWqOlR1L8JJ5oMo8dI/fKFQI3Wna3L+uPP/JMu2o1gevXYWdGRGtFQaZW47doEbcHD87L8bdlM07vvE3Wn3+gnTcfTb36pc7vV94kbdmKKJh4ZuZHzDYYrOZPqA7wx+nNN0nevh3njh0e+wSvEpZDf/s2twcPQaZUUunLPfcpfQUhk8lw6dQJVUAgMRMnkpqcgv+K5ah8fBANBoxJSZjS0hHS0xANhrxABrUaub09Si8v5A4OZZIgvjh4e3vTu3dvwsLCUCgUxX7pEnJyiJk8GaW3N77z5yNTKMpY8icbKY/fU86TnMdPFAQie/RE4eZG4JrVFulTyM0lce1aUsJ2YP/ii/jMmW1V0+6DWCPnlzEhgcj+/ZHb2RO0aSPI5ER2747C1ZWgTRuLtUtgbh6/ssAQH8+N9h1w69u3TKpr5F6/wc0uXfCeOtUqgT1lQUXMKfc4Y8rK4tobrTClpRG0ZTP2TZs+1KaoOc+9fp3oDz9EFEQC169DHRBgbZGtgrl5/OLmzSf9hx+otH0bNg/UwH3S1mh5PIOta5eSkChH7u72uQ8aaJH+ci5dJrJPH1K/2I3nhx/iv2J5mSp9YB0zh9LTk4BVqzAmJhA9bhwylRLf+fPJuXSJxHXri9VHbGysxeUqLclbtyFTq3HtaZl6xI/Cpkowjq+/TvLWrYhGI1qtln379rFhwwb27dtXqsL2ZYVkRrMcoigS2aMnppQUfGbMKFDpg6Ln3KZKFQI3bUJmo+b2oMHob92ylrhW5W4Q16BBg+jYsWORSl/64cOk7duH1/jxDyl9IK1RSyApfhJPJHm+fRuwa9as1GZY0WQiaetWbvXpg0wmp1LYdtz69La6P19BHD9+3Cr92gQHE7B0KTnnIoj7aCaaunXwGDaU5G3byPrzxCPPP336tFXkKikGrZa0r7/GrVfPMk2s7PZ+fwzR0ZxctYqZM2dy8OBBTpw4wcGDB5k5cybh4eFlJktJsNb6ehqJmTiR3EuXcHnvvSL9Ph815yovL4LWr0duZ8ftwUPQ37xpYUkrDoboaLRz5+HYqhXO7dsV2EZao6VHUvwknkgstduXe+MGtwcNIvHT1bj27EHQ9m0lLhpe0bFt0ADfeXPJ+OUXEpYtw61PH+yaNiV25kcYU1LKWzyzSN6yFZmtBpduZRv9p6lZE2WTJmR9vhODXk9OTg76O/8aDAbCwsIei50/idKRtG0b6d8dQPPsM/jMnlXq/pSengSuX4fc0ZHbw4ZjqIA77EVRnN1vURCInT0bhbMT3tOmVhg/xScRKbhDAoDOnTtja2v7yHYRERFlIE3psMRun2jIK0KetGEDSh8fAj/7zGo5AM2hagGmD0vi2Lw5XhPGEx+6CKW3Dz6zZhLZrTtxc+bgv3RpoTdjzwpUwNwQF0fa11/jPnQoCoeyT6h8qU5t/H77jcoJCVz38Chx0trywNrr62kg68QJ4kMXofD0oNL27Y9UYIo750oPDwLXrObWgIHcHj6CoE0bLVYK0poUt2Rb2tf70Z06TcCaNUXu0ktrtPRIO34STxyZR4+Se+UKHoNLVkIr5+JFIvv1J3HtWly7d6Pyrp0VQukDaG1GipWS4tqlC279+5OwbBm60//gM/Mjso7/RtpXXxV6zpAhQ6wuV3FJ2rQZuYMDrl27lMv40ba23HZ25vnYOBR3IhgVd6ISS1spxNqUxfp6kjFotdweMhSZSkXlXbuKVcvWnDlXenoSsGYNQnYWUSNHYcrMKo24Vufekm1F7X4btPEkrFiBc7t3sW9WsC/kXaQ1WnokxU8CgL179xIREfHIn4pMREQE8+bO5fT06US5unLdzJxVpsws4pcsIbJPXzAaqbRtK56jRlWohLyrV1smOvlReIwYjlObNsTNmoXczg6Xzp2IX7ac3Os3Cmw/d+7cMpHrURhiYkj79lvc+vYxu/qIpXB3d+dUYACe2dkEJSUjWLhSiDUpq/X1II9jIMyDCHo9N7t0RdTrCVi9utgRuObOuTrAn4BVqzBERxM9dgxCBc2hCQ+XbFOr1SgUCgwGA4Ig5NXRFkXiQ0OR2WrwHD36kX2W1xp9kpAUP4kngi1bthAaGopw4gTOaen85ORIaGgoW7ZseeS5oiiSfvAQNzt1InXf13gMH0alsO1o6tQpA8krJjKZDJ8Z07Ft2JDoceNxatsWla8vsdOmITwigWx5krRxEwonJ1zee6/cZAgJCSHOxYUYJyeaREejz83FZDJZrFLIk0Z4ePhjGQhzL6bMTCJ79sSo1eI5ZjQOL1n3b6ypUYOA5cvIiThP7NSpiEajVccrKQWVbHtw9zvz55/J/PVXvCdOROHkVJ7iPjVIPn4Sjz0REREcPXoURJEXYmKJdHIi5o6PyNGjR2natCl169Yt8Nzcq1eJ/2QJ2X//jcPrLfAaO9bqZYweF2RqNf6LF3Fr8BBiJkzEe/o0YsaNJ/HT1XiNHVPe4j2EPiqKtAMH8PxwFPJi+KtaC29vb3r36cOxlSt5+1wEVXU6ot3cLFop5EnhXlOgwWDI/1ylUhEWFka1atUq1HyZMrMwxERj1GoxxMRiTEzAlJpG+oEDmFJSUHh5khX+O5nHfkU0GO786EEERBEEAUQRETH/M0Ojhtzs1h1VUCCa2nWwf+F5bGrWfKRvoG2DBvgtCiV67Di0oYvwnjqlwgVEPKpkm4ejI/FLluLw6qs4vv56ucn5tCEpflbi5s2bBAcHF6vtr7/+yiuvvPLIdrNmzWL27NlFtrlw4QK1atUq1rhPCvv37wegRkoKHjodRyoFPXT8QcXPmJRE4vr1pH29H5W/PwGrVmL/4otlJXKJef/998t0PLm9PQHLlxHZvz8JK1biNnAgSWvXYv/iC9g//3x+u+HDh5epXAWRtGEjClcXXDp1Km9RCAkJoWrVqkT1f59WaWnEdu9OyEsvVSglpiDKen09aAqsSIEwotFIzrlz6P47S8758+RERGCIick/LlMqUXh4gChiSk0FtRr7kJeQa2zyKrcolXlVNZTKvNRPMjncVcxkMpDl7ax3zs1F5eyC/uZNkjZtIvHTT1FXq4prly44t22LrIgqMA4hIfhMm0rc7Dmo/Pxw79/PupNiJo8q2dbg5k0MaWl4jR9X7D7Leo0+iUiKn5VwcHCgb9++hR4/f/48f//9N46OjjRq1Misvp999lkaNGhQ4DFnZ2ez+noSSE1NRSaKhMTEcsPZOX+3797jdxFyckjZ9QXJmzeDUonX2DG4dOpU5M21IvHXX3/x6quvlumYdxM83xowgKw//8SuSRNiZ86k8hdf5Cew/u6774pc79ZGf+sW6T/8gNe4sRXGJ9PHxwfHWbOIGj6cem5uOFZwpQ/Kfn0VZAqEvF2h8giEEQWB7JMnST/wPZm//YaQno5Mo0FTqxYOr72GpnYtVAEBKH18ULq7kxNxnps9eiC3tydoxw5sa9U0e8xff/01f85FvZ7skydJ/Xo/2gULSd66Da+JE3B4+eVCz3d+910MMTEkfvopKl9fnFq/WeLrtzRFlWzr26oVhtBFuL3/Pio/v2L3WR73wCcNSfGzEh4eHmzdurXQ423atAGgW7du2Nubl3Kiffv2zJo1qxTSPVm4uLjgGRGBa04O31d5eJfVxcUF0WAg7dtvSdq4CWNyMq7vdcZ90CAUj5mifO7cuXK56dkEBxOwbBm3hw3HrkkTRIPxvhQvt2/fLnOZ7iVpwwaU7u44d6hYpdLsmzXFrlkzEtesxeGVVyp8zdGyXl+PMgWWVSCMoNeTfuB7ksPCMNy6hSooCNcu72H/0stoatdCpnz4UWlMSuJW//7I5DIqfbELTbVqJRr73jmXqdXYv/gi9i++SO7VqySsWEH06DE4tXkL78mTkRfyrHAfMgRDdAxxs2ah9PKqMFkIIG/Xr1q1aveVbHvxxRcxzpuH3ssTt759zOqvvO6BTxKS4lcOREdHc+jQIQAGDBhQztI8/rR/+22Sv9zLJTdX4h+I5JSJIu3dPbjRqTOGmBgc32yFx5AhqIOCCulNojBsn30W33lziZk4CfsXXyDr+G+k7t2LazkGUkBejdz0g4fwmjC+WOkzyhqPEcO51acv6T/8iHPbd8pbnArFo0yB1g6EEUWRzKNHSVi+AkNMDA7Nm+Pz0QxsGzQo0l9O0Ou50fk9BJ2OgE9XlVjpKwqbatXwX7mSjB9/RLtgIbqICAKWLUNdqdJDbe8GYxnitUSPH0elzZtRV65scZlKyt2SbXfJ/PVXon//A79PFleYHfqnCSmqtxzYunUrgiBQt25dmjVrVt7iPPb4XbyEiyjyh+//mwvkgkCdxCQ+uHUb5YYN2NSoQeVdO/GbN++xVvqaNGlSruM7Nm+O18QJZP0vHE3duiTcSfFSs6b5Ji5LkbRxI0ovL5zbty83GYrCtm5dHF5vQeLatQg6XXmLUyRlvb7umgJVKhUajQa1Wo1Go0GlUlk9EMaYlET02LHETJiIunJlKu/Zjf/iRdg999wjgyRu9e+PMTYWzw8/xLFFi1LJUdScy2QynNq0odLnO5DJFdx6fwC6cwWn1coLxlqM0s2dqFEfYqygNW2FnBziP1mC3QvP4/Daa2afX973wCcBacevHLhrAi7pbt/p06eZPHkyycnJODs789xzz9G2bVscHR0tKOXjgaDTkbRpEx4dOzCoc2e+3bsXz4gI6kfewlGvx7n5a7gNGIBtIVG9jxvVrLCzYC6u772HURtP0ubNKN3diZ02jedmzSwXWXKvXCHj0CG8p07Nc6ivoHiO+pCb771H8rZteAwdWt7iFEp5rK+CTIEhISFWVfqyTvxF7NSpIJfjt+QTHM1QQGJmfITu1Gmc3m6Dx5DBpZalOHOuDgoiaNNGokaP5vaQIfgtCsWhgN1QhZMTAStXENmvP9FjxuaVeatgO2rJYWEY4+MJWLWyRFHIFeEe+NgjSpQpx44dEwFRrVaLCQkJZp07c+ZMkTtJAB78cXZ2Frdt22a2PKdOnRIB8dSpU2afWxFI3LRZvNS0mZh99pyYsHadeKXlG+LFxk3E6GnTxJwrV8pbPIvz6aeflrcIoiiKoiAIYsyMj8SLjRqLFxs1FufMmlUuckSNGy9ea/uuKOj15TK+OcSvXi1eev4FUR8VVd6iFEpFWV/WJPmL3eLFJk3FW8NHiIbkZLPOTQrbIZ6vVVu81r6DaDKZLCKPOXNu0unE26NHixebNhPTf/650Ha6iAjx0oshYtT4CaJgNFpCTIugj4kRL73wohi/YmWJ+3jS1mh5PIMlU28Zs3nzZgDeffddPDw8zDq3atWqzJ8/n3/++Yfk5GSSk5P53//+xzvvvENaWhp9+/bl888/t4bYFRJTRgZJmzah9Pbi9oABJO/YgePrrxP89T785s7FRnoztBp3fYrs7roqmExk/flnmcqQc+ECmUeP4j54MDIzq7SUB+79+6NwcSF+2fLyFuWpRBRFEtasIX7RIly7diVgxfL8qPTikBkejnb+fBTu7lT+fEd+UEpZItdo8F+8GMcWLYidMpWs338vsJ2mTh385s8j89gxEpavKGMpCyd+6TIUTk64D5BSspQnkqm3DElPT2fv3r1AyXIR9e7d+6HPQkJC+O677xg1ahSrVq1izJgxvPfee6jNNHt16tQJ21IkvR0xYgQjRowo8fnmIOh0pH3zDQmfrsaUnIzCyRGPDz7AuX07FE+4ubs0fyNLI1Op8F8USuSgwcgFgdhp06m890uzHqalIXHNWtSVKuH01uNRu1Nua4vnhx8SO20aGUeP4ti8eXmL9BAVaX1ZElEUSVixgpSwHXh+OAq3PuZFkurOXyBq2DBkNjZU/nKPRcsBmjvnMqUS3zmzic7RET1+AgGfrsKuYcOH2jm8+ipe48cTv2gRKn8/XLt1s5TIJSLrzxNk/vILvvPmFRqd/CgiIiJITExkwoQJuLi40L59+0KT80sUjkwURbG8hXha+OyzzxgyZAgBAQFERkZa9I0xOTkZLy8vTCYTx48f5+Ui8j7dy+nTp2nUqBGnTp2iYQE3j4qCKIrknDlD2oHvyTh0CCEnB9FoxKF5c/wXL6rwaTKeZIyJiUT27o0hKhr7V18tse+OOejOnOHW+wPwnT8fpzdbWXUsSyKKIjHjxqE7e47Ke3aXmZL8tJO0eQuJq1fjNWG82QqQPjaW62+/g2gwUPnzz7F9pr6VpDQPITeX6NFj0J07S9CGDWgKSdwfv3w5KTs+x29RaKkDUUqKqNdzs3sPFG5uBH62vkT3hy1btuRVaHqA5s2b079/f0uIWS6UxzNYMvWWIXfNvP369bO4mcDNzQ0vLy8AoqKiLNp3eZJ75QoJqz7letu23BowkKw//sC1Z08cW7dG4eiIz/RpT5XSd7dKSUVC6eHBgZYtkTk6kHn0KCmf77T6mIlr12FTrRqOb7S0+liWRCaT4T11KqLJSHzoovIW5yEq4voqLWnfHSBx9WrcBw82W+kzpqdzs2MnxJwcAj5dZRWlr6RzLrexwX/JJ9gEVyHqww8xxMUV2M5z1CgcW7YkdvoMdGfOlELSkpPyxW70t27hNWF8iZS+/LKckP+cu8vRo0eJiCg40lmiYCTFr4w4f/48J06cQCaTWeXtxGQykZaWBvBYR/eKokjOhQskrl3LjS5dudmtO6lf78P+xRcJ3PAZVb77FsdWb5Bx6BDuAwegdHMrb5HLlOjo6PIWoUAydDqC1q5FplIRHxpq1QdM9t9/k/3337gPHZJXCusxQ+nhgffESWT89BNp331X3uLcR0VdXyVFd/Yc2rlzcW7XDvfBg8w6V8jJ4WaHjphSU/GdMxtHKyUNLs2cy+3s8F+2FLnahqhRH2LKyHiojUwux2f2LDR16hA9Ziz6W7dKI67ZGBMSSNzwGS7vvYemRo0S9XGvcmxTQK7OJ/GFxZo8fnfNx5RNmzYBedvSVapUsXj/3377LdnZ2chkMho3bmzx/q2JkJ1N5m//Qxu6iOtvv0Nkr96k7PkSTc0a+C9fRrWDB/GZOjXPj0UmI37pUlQ+PriUs8+KxP3YPvss/iuWIwoCtwYNxnhPqTxLIYpi3m5f7VolygFWUXB8sxXO7d5FO28+urNny1ucJxJjUhIxEydiU6c23pMnmbXTJOj1XG/fHkNMDB4ffIBL585WlLR0KN3d8V+5AmN8PDETJiLq9Q+1ubs7qHB1JWrkqDLN8ZewciVytQ0eQ4eUuI/UR9xLHnVc4n4kxa8MMBgM7NixA3h07r5PP/2UWrVq0ecB5+Nbt26xY8cOcnJyHjpn//79DBw4EICePXvi4+NjIcmtg6jXozt7lqTNW7g1ZAhXm7cgevRoMo8fx+G11whYu4Zqhw/h+/HHOLz88n11dLN++43sP/7Ec+yYCp23zVq8+WbFqcN5L6+88goAjq++ivfMjxAyMrjZpWuBD6HSkPXbb+jOnMFj2DCzTUZarZZ9+/axYcMG9u3bh1artahs5iCTyfCaPBlNndpEjx+PoRxluZeKur7MRRQEYmd8hGgy4RcaalYtbsFo5EaHjhhuRuI+aBCeI4ZbUVLLzLlNcDD+Sz5B988/aD/5pMA2CmdnAlatRNDpiB49BqGAZ4mlyf7nH9J/+BGPkR+gcHIqcT8uLi75/09MTCzyuMSjkaJ6y4ADBw4QHx+Pi4vLfWVrCiIxMZFLly49pLwlJyfTu3dvhg0bxnPPPYe/vz86nY7z589z5coVIG83ce3atVa7jpJiTEoi58JFdP+dQffvv+Sci0DMzUVmZ4td48Z4jh2L/fPNUAUFPbJMUvySpdg1a4bDU1Cr0ZicTNr+/WT+LxzD7duIublEOzoiJCUhd3JC5euLpnZtbKpXRx1cGZsqVVBUgBugW5cuGG5Gkrx5M5H936fSjjCLBHuIBgPxy5dj16wZ9i++aNa54eHhhIWFIQhCfqH4w4cP07t3b6uXBSsMuVqN3+LFRPbpS9Sw4QSsWY2qgr+0PS6k7NpF9okTBKxejeoBn7CiEIxGbnbshP7aNdz69cNr7BgrSmlZ7Bo1wnvqFOLmfIymRo0CdylVfn4ErFjOrUGDiZ06Fb9FiwqsQ2wJBL0e7YKFaOrUwfndd0vVV/v27QkNDS3y+ONCztWrpO3fj+7ffzFExxCZ9LAia20kxa8MuBvU0aNHDzQlzKIeGBjIpEmT+Pvvv7l69SqnT59Gr9fj4eHBO++8Q48ePejatWu55Ja6i6DXY4iMJPfGDfTXb5Bz6SK5Fy5iTEgAQOHqim2DBngMH45tgwZoatYwK/9ayuc7McTF4b9smdWjRsuT1G++JXnjRnKvXQVBBIUChbMzco2Gf+vXI+DffzGlpGKIjib75EmQy5GpVMhkMtTBwdg+9xx2jRphH/JimaW3OX78eP6uH4D3xAnoI2+S+fMvxEyalLfrUsq/WepX+zDcuo3fwoVm9aXVagkLC8NgMGAwGPI/V6lUhIWFUa1aNatWiSgKpbs7gevWcnvYMG4NGEjg2jXlWlLw0KFDj31lhNwrV0hc9SmuPXti/3zxS2IKej03u3Ql9/JlXHr2xHvyJCtK+f9Ycs6d27Uj59JltIs/QR0cjF2jRg+10dSujV/oQqLHjiNu9hx8Zs+yiq9s0saNGCIjCQrbXur+69atS/PmzTl69CgeHh7cvn07/1jz5s0rfEoXISsL7SefkHHoMKa7ZnaVCqWrC3IHhzKXR1L8yoDvzHDgnjVrFrNmzXroc3d3dxYuXGhBqcxDFEWErCxMSUkYk5MxauMxxMZiiI3BGBuL/nYUhuhoEAQgT8mzqVkTp7ffRlO7Fja1aqPy9yvxw98QH0/Spk24dnkPmyrBlry0CkPaDz8QvzAUY3w8MrUa+xdexLVPb+xffjlfoVetXk21O+vAEBdH+g8/krJnD8aEBGybNEHt64vu339J27cPmVKJbePGOL7+Oo6tWqFwKFnurJISsHIlNzq/R/p3B1A4OeE9bVqJ//6m9HQSP1uPc7t2ZjuIh4eHIwgCBoMBhUKBQqHAZDLl/x4eHv7InXhrog4MJGjTJqKGjyCyXz+8J07C8c1WT/TLjbUQjUZiZ89GVSkIDzNMtEJWFtfbd8Bw+zYu3bvhO2O6FaW0Ll5jRqO/fp2YiZOotCMMla/vQ20cQkLwnTOH2GnTkDs44DVxgkXXW86FCyRv3Yb7oIElDuh4kP79+9O0aVP27t2Lt7f3Y5HHT8jOJnbmLNIPHgSDAYWHB86dO+PWp3f+vGScPg0FKOjWRFL8JACImTIVd3//vLxicjlCVlbeT3Z2nsKXkvKQv5bc0RGVnx8qX18cXn4ZdXBwnskxONjiJsfEVauQazS4Dy59bcyKhj4ujugRH5ATEYFMo8Gtf388x41FXoAJxt/fP///Kh8f3N/vj2vPHqTu3k3i+s8wxsbiM2smKl9fMo/9SubRo2gXLCB+yRIcX38dl44d0Dz7rMWVCqcC/HdkCgWVd4Rx/d12pOzciUyjwWvcuBKNnfDpp4gGAx7DzK9zm5SUhHD3hUShyFeiTSYTgiCQlJRkdp+WRuXtTdDmTWhDF+UleD5yBI8hg7GpXt1iYwhZWRhiYzEmJmJKS8eUmoI+MhJ9ZCRCVhZirh4nHx9u9uqNwtkZdWAAmnr1sH/pJZQVwIWgOKTs+oLci5cI2rIFeQHRnwVhTErierv2mJKScB8+DK9Ro6ws5f3c+522BDKVCr+FC4js3YfoceMJ2rQReQFJop3ebJW3E3UnobLHiOGWccnQ64mbNRubatVw79ev1P3dS926dbly5cpjYdpN2b0bbegixOxs1MHBeE2eZLXIcHOREjg/5dxNHrm3WjXqqPNulApHR9TBwdhUr47C2Qm5vT0KF1cUrq4o3d1QuLmh9PJCUUZb1HeT9XpPn45Lh/ZlMmZZkbzjc7ShoWA04vTWW/guXFDioBX97dvEzZyF7uxZPEeNwrVXT2QyGQZtPOkHDpD27bcYoqLQ1K2LW5/eODRvXiY5EA1xcVzv0BEhPR33QQPx/PBDsx4wWX/9RdSw4XhNnoTre++ZPf6+ffs4ePAgOTk59+34mUwmNBoNrVu3LtcdvwfJOHKE+CVLMcbHY9e0KY4tW2LXuFGRPrCiyYQpPR1jfN5OvDE2FkNM7J1d+bydeSEtPa+t0YhoMoHJlHeyTAYKxf+vBUFANBrzd+8h7yVPU7s2Di1a4NyxA8pSOOpbC0N0NDe6dMW5fTu8J0wo1jn6yEhuvNcFITMT7ymTcSugOtLjSu6VK0T2fx+Hl17Cd8H8QtdO8o7PSVi2DNc+vfEcNarUyl/CmjUkb9tOpe3b0dS0zG7f44SQnc2tIUPR/f03cicnfGbPwvmttwptXx4JnCXF7ynn7qILDg7GV6OhrghNEWkgQhbwjUzGzzIw3rkZlHWiTNFoJLJvP5BBpW3bnphkzYJeT9Sw4WSFh+dls1+3rljJYTdv3lxkuT/RZCJx9RqSt23Dqe07eE+dmq9IioJA1h9/kLI9jOyTJ1EFBODWpw/O77Ytda3bBQsWMGXKlEKP6yIiiOzTFzEnB/fBg4r9gBGys7nZtRtKP18C164tka+QVqtl5syZBfr4qVQqZs+eXW4+foUhGgxk/PwLqXv25KV7EQRkdraovLxRuLqCQg6iiCktDVNyCqbU1PsUNZlajdLXB5Vv3o68wsmJ3Js3yP7rb4SsLDS1auHwxhvYPdcATa1a+TtC964vY0ICmb//QfaJE2SfOoUhKipPWZTJUFUKwqVjR9z69EFeQr9lSxM9YSI5584RvPfLYpUESz90mJgJE/IifxcvwrlNmzKQ8mEe9Z0uDRm//ELMhIl4jhmDW6+ehbZL+eIL4hd/gst77+WZfUvok5f1++9EjfoQj2FDcX9EBouSYs35Ki05Fy4Q2a8fQlo6Di1a4L9yRYGWm3spD8VPMvVK5JMqkxEug3BkeIoi74giPUSR10XYIocL5eBzlPL55+RevkzQli1PjNJnTEjgxntdMMbFYf/SSwSsWV3sXT6dTlfkcZlCgeeokdhUq0rcx3Mxxifgv+QT5La2yORyHEJCcAgJIef8eZK3bUe7YAHJ27bhMWwojq1alXiOTXd3jwrBtm5dgtav49bgISR9tgEMRjzHjS1S+RNFMW/nKzmZgLVrSvww8vb2pnfv3oSFhaFQKPKjeuVyOb17965wSh/kmeucWr+JU+s3MWVmofv3X/Q3bmCMj8eUmsLd93WbatVRurmicHVD4eaK0sMTla8PCjc3ZHI5psxMkrdvz6umIpPh3O5dXLt2LTSA5N71pfT0xKXdu7i0y4vIFASBrF+Okvrll2T99RcJS5eRsGIlmnr18Bo3FvumTa0/MYWQfepUXh3YuR8XS+nTLl5M8uYtyO3tCdq0Ebtnny0DKQvmUd/p0uDYogWufXqTsHIlmjq1C6zpC+DarRsyjQbt3HkI2dn4zJhu9sugPiqKmOnTsX/hBdysWELNmvNVGjKO/EzUmLwocN/583CpQFaEB5EUPwkA9u7dW+DbRu6VK3iFLmLeP//g0q0rQk5Omb3h62/eJHHdelx79sC2XsV14DUH3X//EdmvP2JODp5jx+BhJZ9FpzZtUHp5ETVmDFEjRuC/YsV9Eb6aOnXwC12YFwG5dh2x02eQtHUrniNH4fCSddKb2DVuTOCnq7g94gOStmzBlJGBz8yPClXokjZuJG3/fnw+moE6IKBUY4eEhFCtWjXCw8NJSkrC3d2dkJCQCqn0PYjCwT7vb2LG30UURdK+/56EpcsQcnJw7dYNt759SpVLTS6X49jydRxbvo4gCGQcOkTKtu3ozp7lVp++KL28cO3ZE7cB7z9yl8OSiCYT8UuXoalbF8dH5MQTsrO5NXgIupMnUVWqROXdXzw2/oslxXPECHLOnydmyhQq79iB0tOzwHYu7dsj19gSN3MmRq0Wv9CFxfbVNiYmEjV8BApnF3w/nvNYVtQpDck7d6KdOw+5rS1B27djW7dOeYtUNKLEU82pU6dEQDx16lShbQSTSUzasUO89PwL4o0uXcXcyEiryyUYjWLk+wPEa+3aiyadzurjlQUZx4+L5+vVFy/Uf0ZMP3asRH0kJSWZ1T777Dnx8mvNxZs9e4nGjMzC2/33nxg5eLB4sWEj8fYHI8XcGzfMGufatWvFbpt16pR4qdnz4vnadcRbQ4eJpsyH5Ures0e82LCRmLhhg1lySIiiPipKvDV8hHixYSMxespUUR+nLfa55q4vURRFQ2qqGDN7tnixUWPxfM1a4oVnnhVvj/pQzI2KMruvkpC6f794sWEjMfvMmSLbpf/8c76Mtz8YKZpMpjKR71GUZM7NxZCYKF5t9aYYOWCgKOj1RbbNOnVKvNK8hXj1rTZiVhHPhbvoo6LE6506i1ffbC3qo6MtJXKhlMV8mUPi1q3i+Vq1xUsvhoiG+Hizzy/OM9jSSIrfU445iy7n8mXxWvsO4uWXXxHTjx61qlwJn30mXmzcRMw6ddqq45QVqd9/L56vU1e88FxDUXf+fIn7OXHihNnn6C5eFC+/+poY+f4A0ZSdXWg7QRDE9J9/Ea+98454sWkzUbt0mWjMyCjWGHv27DFLptzbt8Urrd4Uz9eqLV5+9TUx8++/RX1MjJj931nx1rDh4sWGjcS4haGiIAhm9VsUcXFx4ldffSV+9tln4ldffSXGxcVZrO+KgGAwiElhO8RLL4aIV9u8LWb89j+z+yjJ+rqLyWQSU77+Wrza+i3xfK3a4vlatcVr7dqL6T//XOI+HzlmZqZ45Y1WYvSUqYW30enEW0OHiedr1RYvNHhOTPn2W6vJUxJKM+fmkP3PP3nf6yVLH9lWHxsrRg4cJF5s1FiMnT1H1GsffnkQBEFM/+kn8crrLcVr77Yz+2WxpJTVfBWHxG3b8pS+kJdEQ0pKifooD8VPMvVKFBub6tWpFLaduFmziRk3Hrd+/fAYNtTimd+zT/9D0mcbcB84ELuGz1m07/Igdf83xE6ditzBgeCv9qIODCxxX3///TdNzfSl0tSsScCqldweNpzocePxX76sQJ9CmUyGY4vm2Ie8SMqOHSRt3kL6jz/iNXbsI/PKXbp0ySyZ1AEBVPlmP9r5C0jdu5dbffvlpd+QyVBXrozfJ4txeO01i6WdqYiVOyyJPiqK2OkzyDl3DtduXfEYPhy5nZ3Z/ZRkfd1FLpfj0r49Lu3bk3P1KvGhoWT98WeeCdDNDZcuXfAYOsSiriJJW7ciZGbiOWpkgceTv9hNwiefIGRmYtu4EQFr1lS4iOTSzLk52DZogNfoD4n/ZAma+vVweuONQtuqfHwIXLeW1K++InHtOtIOHMDhpZewbdgQhbMTRq2WjGPHyL1wEftXXsbno4/yUoGVAWU1X48iL+/qQhTu7lT54fsKt66K4ukyxEuUGoWDA36LF+H54SiSt28n6oORFi34bUxOJnb6dGwbNMB9QMWM3DKHlK++ylP6HB2p8t23pVL6SoNt/foELFuK7t9/iZ02PS+dRyHIbWxwHzCA4H1fYfdcA2KnTSN61Ki8BN0WRK7R4DtnNkFbNqPw9EDh6or39OlU3v0Fjs2bW0zpu7dyR05ODnq9npycHAwGA2FhYeVas7e0iKJI2nffcbN7d0zJyQRt3oTX+PElUvosiaZaNYI2bKDmXydw698f0WQiad06LjVpSmTfvmT9/kepxzDExJCy43Pcevd6qNRd2o8/cqV5C7R3kuH7Lpif59/2GD2crYFLt244tmpF3Jw55F6/UWRbmUKBa5cuVPnuW7zGjcOUmkri2rXEzZpN0rZtqHz9CFi1koBly8pM6asoZP35JzETJiJ3cKTKt988dutKUvwkzEYmk+HWpw+Ba9eQe/06kT16ovv330Lba7Va9u3bx4YNG9i3b1+hD1ohJ4fo0WMQTUZ8535stRqSZUXa998TN+Mj5M5OVP3+ACoLBBLUq1evxOfaNWmC34L5ZB47RsLyFY9sr/L2xi80FP9lS8m9foMbXbqSvD0sL8fbAwSWQqG1b9aM4F27UHi4k7B8OdmnTpe4r4J4sHKHWq1GoVBgMBgQBIHw8HCLjldWmNLSiJ08mbhZs3Fs2ZLKu3Zi+8wzpeqzNOurIOR2dnhPmkjNE3/it2wpNtWqkf33SW69/z6XmjUjetx4sk+X7O+dsHIVCicn3Pr2BfISVMcvX8HlkJeIGTMWU3Iyrr17Uf3PP3Dp0MGSl2VRLD3nRSGTyfCZMR2Vjy8xEyciZGc/8hyFgwOuXbsQtHkT1Y//So0//6DGb7/hv3iR2TWzLUFZzldB6KOjuT1kKDKViuAv96B0cytXeUqClMfvKae0OYQM8fHETpmK7tw5PD8chWv37vft1BRkYrubRuNeE5toMhEzcRJZf/5J0MYNaGrXtsj1lRfpR44Q/eFo5Pb2VPnhe1QeHhbpV6fTYVtAFn5zSNm9h/hFi/CaMAHXbl2LdY6QnU3i2rWkfLEbm+rV8floBppatfKPJycn41bKG6ApM5OYSZPJPnkS7ymTcbFQdv4NGzZw4sQJ9Ho9arUauVyOIAj5vzdr1oxBgwZZZKyyIvvvv4n9aCZCTg7eU6cUabYzB0usr0dhTE8naf160r87kFfHWxSR2drmpRtp1gzH15pjU69ukXXHdf/+y60BA3EfPgxTcjKZvx5Hf/06CAJyZ2dcOnTAc+yYEidDL0vKYs4fJPfGDSL79MEhpOjkzhWNiIgIvv76a9LS0sqlZJug13P19ZaYkpII2rYV+yZNSt2nlMdP4rFD5eVF4Lq1JHy6moQlS8k5cwbvqVNRODvfZ2J7MHFuWFgY1apVw9vbGyE3l7iPPiLz+HH8ly557JW+rJMniR49BrlGQ/D+ry2m9EFe8tIRI0aUqg/Xrl0wREcTv2QJKl8fHIpRRkhuZ4fXuHE4vfUWcR/PJbJPX9z798NtwADkajVr1qxh+vTS1TdVODgQsGI52kWL0H48F/21a3mJnkuZXNrd3f2+Mm33/iuXy3F3dy9V/2WJqNeTuG49ydu3Y9uoIb6zZz9k5iwNllhfj0Lp5IT3hAl4T5iAMSGB5M8/J+PIz+jO/Ifu1GmS1qwFhQKFs3Pej4sLMlsNIEPMzcWUloYhKgpRrydh8ScAyDQa7Jo2wa1Xbxxbvm5V+S2NNeZcq9UWmbrIJjgY35kziZk0Gc0z9XHr0cOi41uDLVu2cPToUQIDA9FqtWi1WkJDQ2nevDn9rZg38F5u9euHKSEBr0mTLKL0lReS4idRamQqFV5jRmP7TH3iPp7Ljc7v4T1pIuFpafeZ2O6Wyrr7e3h4OO82b07MxEnkRETgt3gRDi+/XN6XUypyLl/m9vsD8urUfrkHtZ9feYtUIJ6jP8QQF0vM1GkEbfgMTZ3i5Z3S1KlDpe3bSNqylaRNm8g4dgzfO35UlkCmVOI9ZQo2VaoQv2w5ORHn8V24AJWXV4n7DAkJ4fDhw6hUKgwGQ77Sp1KpkMvlj01whz4ykphp08i9chWPD0bg1rv3Y5/UXOnpidfo0XiNHo0gCORevETmr8fQnTqNPjISY3IyhtgYRFNeVRKZXI5MpULMzUXp4YFDy5a4vPcetnUe75dFS1LcQCbHli1x7dmThBUrsa1TB9sGDcpP6EcQERHB0aNHCzx29OhRmjZtavWdv7h589Cd/gfHt97CvX8/q45lbSQfPwmL4fj66wR/uQfbZ58lZtJkfNd/RkByMogiCoUCuVyO4s6DSjSZUPz6Kzc6dUJ/7RqB69bi+Npr5XsBpcQQH8/N7j0QBYGgbVuxqVKlvEUqFJlcju+cOdhUq0b0uPEYExOLf65KhcfgQVTavh2ZQklk336IJhOCXm8Z2WQyXLt1I+iz9RhiYojs1ZvsU6dK3N/dyh0qlQqNRoNarUaj0aBSqSps5Y57EUWR1K/3c7NHT4TsbCpt3YJ7v36PvdL3IHK5HNs6tfEcNoygjRuo9tNhap74k1r//kvts/9R++x/1DrzL87t26MKCKDqT4fxnfmRpPTdg7mBTJ4jP8C2Xj1iJk+xaJCepdm/f3+pjpeWjKPHSNnxOeqqVfFb8olVxyoLJB+/pxxr+BeIokj2n39y4eO5KCMjyVIqiXRxIcNWg1EE1+xsgjMycBRF3Dt2wPODD1A+Rua2ghCys7na6k1Mycn4r1qF0+stylukYmFMSCCydx9Ufr4ErFtntk+UaDDk7/6pK1fCd9Ysi5rqjcnJxE6ZSvY//+A5YjiuvXuXuCrAo8xfFRFTWhpxc+eR+csvOLdvj9f4cfl1dZ9GDHFx3GjXHo/hw/KDOiT+n3379nHw4EFycnLus7KYTCY0Gg2tW7em4wOlxAzx8UT27IVNtWoEfLqqQr5QTJgwocjoe29vbxYvXmyVsY2pqVxtnnc/r3b0F4tXeikPHz9px0/C4shkMuxfeIGAzZv45pn6XPb0wCszk/qxcTSKjcUrJ4dL3l64rv4U35kzH3+lTxC40aUrpqQkvKZMtqrSd/DgQYv2p/T0xO+TT8i5cJH4haGY+x54d/fvlx49kClVRPbtR8KaNRbb/VO6uRGw+lPc+vQhYeUqbg8dWuK0Mt7e3nTs2JFBgwbRsWPHCq/0Zf72Gze7diP75En8Fi/CZ8Z0qyt9ll5fliY5LAyZnR0unTuXtygWw5JznpSUhCDkmcUftLIIgkBSUtJD56i8vPCbP4/skydJXL/eYrJYEpd7lK2CfHJdrFh279adEpv+S5c+MeX9JMVPwmr4+PjQ8oMPOFGtGnsaNWRzk8Zsfr4Zexs1pPpHH+H/0kvlLaJFiBo+HP3Vq7j26oV7795WHevatWsW79O2Xl28p00j7ZtvSN3zZYn6SMpIzzNBDhxI8rbtRPbuTc6FCxaRT6ZU4vnBCALXr8MQE8ONbt1I3fe12Urq44IpNZXYGTOIHj0Gm+rVqfzFLhxblM0OsjXWl6UwJiWR9vV+XLt1Q25vX97iWAxLzvmDgUyCIBQrkMmuSRM8hg8nedNmMn/7zWLyWIr290T42xWQo7K9hTIAPIh28WJyL17EuWNHHJu/ZpUxygNJ8ZOwKiEhIcyePZvWrVvTrFkzWrduzezZsx8bh/pHEf/JJ2Qd+xW7kBB8pk0tb3FKjPM7b+PaowfxS5aQffJkifooyPcvce1aRAvt/tk1bkzlL3bj9EYrtPPmEf3haAzaeIv0XVHI+PlnbrzXhczf/ofP7Nn4r1xhkfyPTwIpn+/MSypczBRETyMhISHI5XJUKhUmkwm9Xo/JZCpWIJNb3z7Yv/IysTM+sniy9tJSt25dmjdvXuCx5s2bWyWwQ/ffWZK3bEUVGIjPx3Ms3n95Ivn4PeWUh3/Bk0Lad98RM3ESqqAgqvz4Q5F5xyzF2bNnqV+/vlX6Fo1GokZ9SO7Fi1T6fAcqX99in/vDDz/Qpk2b/+/rHt8/m8qV8Zk96768f6Ul87ffiJs7FyErG/cBA3Dt2eOxyNlWGPrbt0lYtozMX4/j8NpreE+ehNLTs9jnW8p/0ZrrqzSY0tK49s47uL7XpdDybI8rlp7z4uZOLQhTejqRPXshd3IiaPOmvDKKFYiIiAj27dtHenq6VfP4CYLA1VdexZSWRtXDh1CbcS80FymPn4TEY4Lu/AVipuSVYqv85Z4yUfqAUidJLgqZUonfgvlE9upFzISJBG7aWOwbv+8DN8a7u38Or75K3OzZeXn/3u+P+/vvI7OAgubw8ssE791L0vr1JK5dS9o33+A1bhwOLz9e7gOmzCySN28i5fOdKDw88AtdiMPrr5uVUNeSdYitub5KQ8oXu0EQce3Vs7xFsTiWnvOQkBCqVatWohcBhZMTfosXcav/+8R/ssRiVgxLvZjUrVsXFxcX/P39LSJXYcRNnYYpMRGvCeOtqvSVF5KpV0LCTIxpadzq2xdkMoK2bS3TOo3WTlugcHbGb/Ficq9dI/6TJcU+7/vvvy/wc03NGnm+fwMGkLRlK5G9+5Bz8aJlZHV0xGv8eCrv2onK15fo0aOJGjnKYr6F1kQ0Gkn75htudOxIyu49uA0cQPBXe3Fs2dIspc/SdYitvb5KgpCTQ+ru3Ti/++5jWR7rUVhjzksTyKSpVQuviRNJ27ePtO8OlFqW8PBwZs6cycGDBzlx4gQHDx5k5syZJS6VaO01mn36NGnffINNrVq4Dxhg1bHKC0nxk5AwA0EQiOzeAyEzE7+FC7B9zKuMFISmVi28Jt298X9X6v5kajUeQwZTafs2kMnyfP/WrbeY759N1aoErFmN3+JF6KOiiOzVm6iRo9CdOWOR/i2JoNeT+tVX3OjQkbg5H2PXpDHBX+3FY9Ag5BqN2f09qXWI7yX9wAFMGRm49nzydvsqKs7t2+H0blu0CxaQc/lyifux9IuJtRGMRqJGfIBMpSRow2flLY7VkEy9EhJmEDtxEvrr13Ht3Rvnt98u8/HLyhTn0r49Of+dRbtgITbVq9/nn1eQ2UZTDKVFU7NmXtWPzVtI2rKFzGPH8Jk10yK+fzKZDMcWLXB49VUyfjpC0ubN3Hp/AHaNG+PWtw92zz9f4vx/lkDIzib1669JCduBMTERx5Yt8fvkEzQ1a5Sq34LSd8D/R3QWlL6jKCqaqVc0mUj+fCeOLVqgDrCuea+8qGhzDnnfJ+9Jk8i9eImYiZOotCMMhYOD2f08+GJSUPWmB/MKPgprzlfspMmYUlLwnjbVLB/bxw1J8ZOQKCYpO3eSfuAAmmefKbcI3u7du5fZWF6TJpJz6RIxEyZS6fMdKJycivQnKw4ytRqPoUNweO1V4mbNJrJ3H1y7d8dj6BDkBaRpMBeZQoFT6zdxbPUGmcd+JWnTJqJGjkLl54dz+/Y4tXnLrKCV0iCKIrmXLpH29X7Sf/gBQa/H6a3WuPfrh7pyZYuMYek6xGW5vopD5vHjGG7dwnfOkxVVeS8Vbc7vItdo8FsUSmTPXsTNmo3f4kVmuSGA5V9MwHrzlfXXX6T/8AOaunVxs3JarvJGMvVKSBSDnAsXiJs3H4WbG5W2bi03OXbt2lVmY8ltbPBfFIopM5PY6TOIi40t1Gxz6NAhs8w2mlq1qBS2HY/hw0nduzc/hYmlkMnlOLZoTqUdYQRt2YxtgwYkbd7M9Xfacuv9ASRvDyP3xg2L5wIUBQHduQgS163jRqdORPbsReavv+LaoztVvtmP76xZFlP6oHTpOwqiLNdXcUgJ24FtgwbY1q9X3qJYjYo25/eiDgzEZ/YsMo8eJSVsh9nnlzSvYFFYY74EQSB69BhkKhWBT7CJ9y7Sjp+ExCMQsrOJ7NcfZDIqhW0v15JZyWVcT1Pl74/v3I+J/nA0cQtDCzXbyOVys802MpUK9/79cHzjDbQLFhA9ejSOLVviOWY0Kh8fi8gvk8mwfeYZbJ95Bu/Jk8j89VfSD/9E4rp1JKxYgdLbG9vnGmD7zLPY1KiOTfXqZpm0jCkp6K9fJ+f8BXT//Yfu9GlMqanIHR1xeO1VvCdMwK5JE2RK69xq79YhDgsLQ6FQPJS+w9zIybJeX0Wh++8/dGfOPBG1UYuiIs15QTg2b45b3z4kfPopmnp1sTMj5UhISAiHDx9GpVJhMBjylb6SvpiAdeZLO3cepuRkvCZOeCIDiB5EUvwkAOjcuTO2xVBoIiIiykCaikVk334I6en4zp2LTdWq5S1OmeMQEoL7oEHoV68moEZ1rtrZPWS2AUpktgFQB/gT8OkqMg4dJn7pUm506ox7/3649upVooCHwpDb2+PUpg1Obdog5OSQ/fdJsk+dRHfqNJlHfkY0GvPaOTuh8vVD6eaK3MkJuY0GFAoQBASdDiEjHWNiEkatFlNaGgAyjQZN3To4d+qI/QsvYFu/vtWUvQcpTfqOikzyjh2ogoJweOWV8hblqcdj+HB0584RM2UKlT//HKWHR7HOu/tisn37dgRBQBRFZDIZSqWyRC8m1iD35k1Sd+9GVbky7u+/X97ilAmS4ichUQTahQvJOXsWp7ZtcelknhOyNbBWaaJH4T5oINcOH+bNK1eJr1WTrDv1P+8qfSkpKTzzzDMl7l8mk+HU+k3sX3qJpI0bSNqwkbRvvsFz9GgcWrQw27foUcg1Ghxefik/75+o15N78yb669cxRMdgiI3FlJaGMSEBMVePaDIik8mR29sjt7PD9plnUHp5oq5UCXWVKqgDA5GpVBaV0Rzupu8oLeW1vh5EHxVF5tFjeE+eVK5BOWVBRZnzopAplfjNn8/Nnj2JmTKVwLVrzHqxedClojQuFpaer6jhIwAIWP2pRfutyEiKnwQAe/futVrW8IiICPbv309qaqpVs61bmvRffiF523bUlSvjG7qwvMUB8swc1k5eWhAyuZyg0IVc7dKVd2/cZFeN6ujvMduo1WqLlOFTONjjNXo0Lh06EL9kKTETJ2HbsCGeI4Zj26BBqfsvDJlajaZGDTQ1Shdley+WSlpblhS1vsryelK/+AKFoyNO5RA5X9aU13faXJQeHvgtWMDtocNIXLMGz1GjHnnO3XQuJpMp/yUR8vz7wsLCqFatWoncESw1X0lbtqK/fh2Xrl3QPEXWHEnxk7AqW7Zs4ejRo/m/a7VaQkNDad68Of379y9HyYrGEJ9AzNhxyGxtqbRrZ5lV5ngUx48fL7eSWr7VqhE5cQJ28+bzRkwsv1QJzvcnc3R0tKgSoK5UiYCVK8gMDydx1afcGjAQ+5AQPIYPs2jpN2thyWoaZUlh66ssr8eUmUXaN9/i0q1rqU39j8NLZ3l+p83FrmFDPD8YQcKKlWieeQbH114rsr010rlYar6MqakkLF+Ows0N75kzS93f40TFeJpJPJFERETcp/Tdy9GjRyusv6AgCET26oWo1xOwZjVKV9fyFqnC8Hy3bnhOmMAzSUm84+hI69atmT17ttUUY4eQECrt/Bzf+fPRR90msmcvYiZNslj1D2vwuCWtfRRlfT3pBw4g5Obi0rlzqfrZsmULoaGhXLp0Ca1Wy6VLlwgNDWXLli0WkvTpxLV3bxxee424mbPQ375dZNuC0rko7riJlDSdi6WIHj0aUa/Hb/GiCvNiX1Y8XVcrUaY8qrSOpUvvaLVa9u3bx4YNG9i3b1+JH0ixkydjuHUL9wHv4/D88xaVsbRUrQDmiKA+vfHo3Jk6f56gTZ06eHt742nFZKcyuRynN1sRvGcPPh/NIOf8eSJ79uLWkCFkHj+OeOfBUlF4nKtpFLS+yvJ6REEgZfduHF9/HVUpdpAfp5fOivCdNgeZTIbP7FkoXF2JmTgJISen0LbWSOdiifnK+vNPsk/8hd0LL+BQgXfgrYVk6pWwGqmpqaU6bg6WMkWlff896d8dQFO/Pl7jxllMPkvRunXr8hYBAK+JE8i5dJGYCROotGMHQ4YMsWj/wp1ybnK1Ov8zmVKJc7t2OL39NpnHjpH8+edEjxmLKigI1y7v4fjmmxUiFYM1ktaWFQWtr7K8nqzf/8hL2DyrdKa34rx0lsbka0kTckX5TpuDwsEBv9BQbvXvjzY0FN9CTKXWSOdS2vkSBIGYiRORqVT4Ly1+PfInCWnHT8JquLi4lOp4cbGUKUofpyV2ylTk9vYEba2Y5qDVq1eXtwjA3eTOizBlZRE7fQZz5861SL/GlBQSVq7iavMWXHnhRS4//wKR/fqTcfRo/s6eTKnEsWVLKm3ZQtCWzWhqVCd++QqutX6LqJGjSD94EEGns4g8JcEauxxlRUHrqyyvJ+WLXWhq10ZTighxsO5Lp6VNyHfn3FIWi7JCU7MG3lMmk/7td6QWomjfTeeiUqnQaDSo1Wo0Gg0qlarE6VxKew9MWrMGY3wCboMGorTQM+hxQ9rxkwDgl19+wd/f36IO+u3btyc0NLTI45bAEg7EgiBwq3dvRKORwC2bUdjbW0S2JxmVnx9+8+YRNXIUYtt3St1f1om/iBk/HlEUce3WDXWVYISMTDJ++ZmY8ROwqV4dnzmz74u8vZuc2ZiSQsaRI2T8+COx06Yj02iwa9wYu6ZNsGvcBJvq1cosLYg1djnKk7K6ntwbN8j+40985swudfoeFxeXIhWnkr50PsqE3LRp0xLt/D2uwUDObdui+/cM8aGL0NSqVWDgVUXKM2lMTSXpsw0ovTzxGDGizMevKEiKnwQAv//+O1evXrXojaZu3bo0b968wBtl8+bNLRZdZwlTVNzUaRhu38Zt4EDsGzWyiFxPA/YvvID74MEQdZvM8PAS+8voIiKIHj8O22eexXfux/cF1Lh264ru33/RLljIrX798Ro7BudOne5TDpSurri+9x6u772HITqa9MM/kf3XXySuXoOYm4vCxQXbhg3zqnNUq4bKzw+llxcKFxezlAzRZELIyMCUloYpPR1TWjqmtFSE7GxEgwEEEbWNmgE1avLjXydItbEhXalEfmddVpSkteZg6eoghZG6ew8Kd3cc33ij1H1Z66XTGiZkk8lEWFgYer0e450k4gBKpbLEKU/KEq+JE8i5mOf2EbR9e4HBcJbKM1laYsaNRzQY8FsY+tQFdNyLpPhJAJCbm5tvGrXkjaZ///40bdrUqikVSluoPv3QIdK++QZN3bp4j694fn338n4FzCzvPnAAncaOI3b6DCrvCENlZo4t/c2bRI8chU21avh/srjAkni2DRoQtG0rCcuWo12wkNwrV/GaOAHZnQjBe1H5++Pevx/u/fsh5OaS899/ZJ88ie7fM6Ts2oWQlp7fVmZjk6cAOjsjUyrzkjArFcgUSkS9HiE7O69aR3YWQlY2QkYGFJR8VqHIO1cuQ9QbcDIa6SwIGI1GdCoVyX6+BHXsSJ1mzcyam7KmsPVl7V0bU0YGaQcO4Na7931+nSXFWi+d1jAh+/j4cObMmfuUPgCj0YhMJitRypOyRG5jg/8ni4ns1ZvYKVMJ+HSVVavWlPQemH36NFm//45t48bYv/iChaV6vJAUPwmA/Ci9kuZWKoq6detaNXdWaUxRhoREYiZOQm5nR+CWzVaT0VL89ddfvPrqq+Utxn3I5HL+fqY+L1+7RvTESQRt3oTcxqZY54pGIzHTpqNwdSVg+fIi6yDLNRq8p0xGU6c2cfPmY0xMxHfe3CJzvcltbLBr0gS7Jk3yxhNFTImJGLTxGLVxGOPjMcRpETLSEQ1GRJMpb+fOZETu4oLK1xe5nS0yW1vk9vYonF1QODuhcHJC4eyM3MkZhbPTQzKEHzvGd5s345itwzctjaD4BAxLlhIRtgP/wYNw6dy5XCt9FEZR68uauzZp334LBgMuHTtYrE9rvHRaw4R848YNDAZDgccMBgNRUVFm91nWqHx98QtdyO3hI0hYscKqgXElvQdGj58ASiUBK5ZbXqjHDEnxkwDI3zGr6FGHBVEaU9Stvn3z8vWtW4fSyakMpS4Z586dq3CKH8DtmBj8Fi/i1vsDiA9dhM9HM4p1XsrOneRevkzQli0onJ2LdY5zu3Yo3D2ImTSJqA8/fKTCeC8ymQylpydKT0+oZ52XEa1WS9gXX2BQqYixg0t2tuDrg69eTyNtPMolS0k78D2+s2dhU62aVWQoKeWxvkSTibht24n09GDDokUWtQpY+qXTGibknCLSoQBkZGSY3aelMCd62a5xY7zGjiV+8WJsatbC+R3rVF0xd41GREQQMXce9WJiuFynDkJsLHUrQPR/eSIpfhIA+T5yFT3qsDBKYoqKmzcf/fXruPbqhcMLFStf3+OIplYtvKdMJm7WbDT16+PSoX2R7fW3bpG4bj2uPXpga6YS5vBSCIGrP+X2yJFEjx6D/4rlpa7yYCkKCzaKVas5Ur0aDvXrU/v4b0T27IX3jBlWe0A+LuyfOZPgqCh+qV0LrVZboav7WMOE/ChfM0dHR7P7tER5vZJUXXLp2oWcixfQzpuHTZVgNHXqmC27JdmyZQvhP/3EqH//JVupZJ+dLVTQtVWWSIqfBJDnE/e4Rh3exRxTVNZff5GyYwfq4GC8p021smSWo8kdk2VFo2bNmsCdKL//zhK/aBGaWjXR1K5dYHtRFNHOX4DSwwOPYUNLNKZtgwYErFxJ1MhRRH84usIof48KNorWaGi9I4z40EXEzZyJKS0Vt549y1PkfMp6fUVERKA48jOxDvZoH4ikL02UrDWxtAnZx8eHmzdvFmjuValUBAQEmNWfJSKESxq9LJPJ8J4yBf31G0SPn0ClsO0oLbyRUNw1evcaOl2/gVIU+Tq4Mtz5LlbUtVVWPL1hLRL3YWNjU6rcSo8TpuxsokZ8gEytJihse6lTR5Ql1SqYafAuje6JhPYaPw6bqlWJnjABUyHO7lnhv5P99994TRhfKmXN7rnnCFi1Mi8q+MPRRVYRKCuKk/dObmOD94zpuPXtS8LSZSRtrhh5I8t6ff28dStB6emc9vIq8Lilq/tYirp16zJt2jQWL17MtGnTSqVAvPrqq6hUKpQPBEQolUpUKpVZL+KWymlqbtUlIScHITsbyPOr9Vu8OM9/d+IkxDvJ2C1Fcdfo/v378c7MonpqKtH29lx7INq4oq6tskBS/CQAePHFF5k9e/Zju9tnDlHDhiNkZOA7ZzYqD4/yFscsdu3aVd4iFMjOnTvz/59341+EmK0jZvp0xDtKz11Ek4nEVauwbdgQ+5deKvXYds89R8DKO8rf6DHlrvyFhIQgl8tRKpWYTCb0ej0mkwmlUnnfjrpMJsNz1EjcBw0icfVq0g8fLle5oezXl9+5c2Sq1VwpJCjCktV9Kio//fQTvXv3zk9ufO+/5r6IW6q8XnGil/VR0cQvWcq1Nm9zJeQlrrz8CldefY3o8RPQ/XcGv9CF5Jw7R/zSZcWWvzgUd42mpqbS/to1BGBf9YeVxadhbRWGpPhZkX79+iGTyYr8eZRjb0GcOnWK9957D29vbzQaDcHBwYwcOZL4+PgSy9qiRYsnfqcPIHnnTrJPnMD+tddwbteuvMV5YlH5+uI7fx7Zf54gacOG+46l//AjuVev4jlqlMV2W+0aPkfAyhXozp4lZsJEi+8ymIO3tzfNmjUrMD1Hs2bNHvqeuQ8ZjGPrN4mbNRvduYpTQ9bamNLSqBobxxlPD4RC/NwsVd2nohMSEsLs2bNp3bo1zZo1o3Xr1iV6ES/IzUBxJ+WROYF7Rc67KNIwTsvNLl1I//57HFs0x2fWLHznzcO1V0+MiYnETp5C3KzZOLVtS+qXX5L69X6zrsMSNIqNxTU3l9NeXmQVkCLoaVlbBSH5+JUBdwMPCkJRQB6yoti7dy/du3fHaDTSpEkTgoODOXnyJJ9++ilffvkl//vf/yqsObC80UdHE79gYV7qkJUrylucEmFbzOjVsqagdWz//PN4DBtK4pq12NSqheNrr2HQxpO4di2OLV/Htn49i8pg17Ah/kuWED16NLEzZuA7b55V84kVhlar5cSJEyiVyocS8p44cYI2bdrcp/zJZDJ8PvqI2zExxIwfT+XdXxQ7wtnSlOX6Stu/Hxu1mv+K2HW3VHWfiszdObdEupzS5jS9S2HRy3JBoPXNSJ7JzsalZw88Rox4yFXDY9Agci5eJHHdetK+/hqFuzvaBQuwCa6MbYMGpbi6PIqzRoXsbJ45e44chYIjQYEFtnka1lZhSDt+ZcDAgQPZunVrgT8qM3J5xcTE0LdvX4xGI+vXr+evv/5i9+7dXL58mV69eqHVaunRowdiQQlmn3JEUeRWv/6IJhOB69dZJElseVAREzgDTJkypcDP3fr3x6FFC2JnzCD9p5+4dSeSznPUKKvIYf98M/xCF5Jx9Bhxcz7Or+9bltw1txmNxvvMbUajsVBzm9zGBr+FoQi5uWgXLCy373BZrS/RaCRlz5e4tnmL51u1KrCNJav7VGQsOed33QxUKtV9bgbmBu7djV6+F5ko8s71G9TJzCQgdCFe48YV6p+rqVWLgOXL8F++DFEQEPV6okaOwhAbW+prLM58xUydhiw3l9vvvJ0f0HEvT8vaKgxJ8XuMWL58OdnZ2bRs2ZLBgwfnf65QKFi7di3Ozs78/fffHK4AvkIVjbg5c/JKsr3fH9tSFoAvTyqqQ/LKlSsL/Fwml+M7ayYqH19iJ09B4eJC0NYtZlf3MAeHV1/Fd84c0n/4gfjQRWWuRJXU3Kby9sJ7ymQyfvqJjIMHy0zeeymr9ZV5/DjGuDhcu3Wjf//+TJo0iZo1a+Lt7U3NmjWZNGnSU5Nuw5JzfjenqUqlus9fsCSBew/+XTpmZVEnN5cqq1biVMyyeg4vv0zw7i+wa9IEY2IiN7t1x1hK37pHzVfOxYtkHD6Mpm5d2oWGPtVrqzAkU+9jxNdffw1Ajx49Hjrm4ODAu+++S1hYGPv27ePNN98sa/EqLFknTpD6xW7U1ariPX58eYtTKqKjo8tbhAJJT08v9Jjc3p6A5ctI+/Zb3Pr0Qf5A2g5r4NT6TYQcHdqP5yKzs7WoP+GjKI25zalVKzKPH0e7MBTbho1QeRcc7Wotymp9pez6AtvnnkNTqxZg/eo+FRlLz7kly+vd/bukfr0f7S9H8Z4yGYeXXzarD6W7O4Hr1xG/dBnJmzZxo117gg98h7IE+Qnh0fMVPWYsyGT4L1923zVI/D+S4lcGHD16lLNnz5KRkYG7uztNmzalTZs22BSzrBXkZW+/evUqAI0bNy6wTePGjQkLC+Off/6xiNxPAoJOR9QHI/NSt2zdWt7iPLUo/fxw7tQJURQRRbFMlDCX9u0RdTriP1mC3M4Oj0GDrD4mlK6EIID3xIncOPEXCcuX47dgfrHGtETC3rIi59IldKdP4xe6sLxFeWKxZHm93KtXiV+8GOeOHXHp3LlEfcjkcrzHj0PhYE/CipXcePsdKn/5pcVfbFJ270Z/4wbOnTujDizYt09CUvzKhO3btz/0ma+vL5s3b6Z169bF6uPmzZv5/w8KCiqwTeCdhX7jxg3zhXxCuT10GEJmJn4LFz52qVsKoqLu5L7yyitFHk//4QfiPpoJgEyjwWfGDJxaW/9aXLt3R8jOJnHNWuR2dmWSKLk0JQQBFE5OeI0ZTeyMj8hq1w7755sV2T48PJzt27ej1+vzlepDhw7Rp08fs6NCy2J9pXzxBUofHxxee83qYz0OVNTvNICg1xMzdRqqwAC8xo0tdX8eQ4ciGk0krl7NjU6dqLRlMzbVq5vVR2HzJeTkEB+6CLmjIz6zZpZa1icZycfPijz77LOsWLGCc+fOkZ6ejlar5fDhw7z44ovExsby7rvvcuzYsWL1dW+9RvtCTGUODg5A0Wa3p4mUu6lbXnkF53bvlrc4Ty2iKJK8dRt2jRvjO38+9iEvEjdrFrozZ8pkfLf338etXz8Sli4j9at9ZTJmadNzOL71FraNGqJdFIpQRGoarVbLli1b0Ol09yWL1ul0bNmypdgJe8sKY0oKGQcP4fJe53KJuJYwj+QtW9FHRuL78ccWq4rj+cEIXHv2xJScTGTvPmT99ZdF+o2dNh0hOxufmR8hl9ZWkUizY0XGjBlz3++Ojo688cYbtGzZkg4dOvDNN98wevRo/v333/IR8B46depUqlQOI0aMYMSIERaUqHToo/+PvbMOk6p64/hncme7uygJARUpBaQMkFAkRbolRBTplgbp7lgpCWkXBGmkMVgEpbe7a/L3x7L7I7Zm987s7DKf5+GB3XvvOe8czr3z3nPe9/uGEpEt3bIs98SD0sixY8cMKtdT1C3Ds2fP5rnql3rhIsoHD3AfNxart9/GpllTQoYMJXTkd/hv3YLMy0vgT/E8IpEIl2FD0aalETl7NmIrS+w+/tigfULxtttEIhHuY8fyqOsXxG/bjnOf3rmed/z4cZR5OIZKpTKnVFdhMfT8Sty7F8RiHD77zGB9lDYMPeZFJfPBA+I2bsSpV08UlSsL2rb7+HGoY2NJPnGCkCFD8fx+GnatWhXq2tzGK+Pff0n65RcsqlXDvk0bQW0ti5gdvxJAJBIxbdo0Dhw4wJ9//klwcHDONm1ePFuoOzU1FftcdL5SUlIAsLOz09umvXv38vbbb+t9nSmSLd1CKZduMTZC1PjMjfiAABTVq2NZqxYAYrkcr/nzeNKrNyEjvsFv40YkNoZN+BCJROh69iA2KAjl2HGE37zJm/36mWwcHIBFhQo4dupI3MaN2Lf7FOkLJacA7t69m28bBR3Xh/Pnz7N3715SU1OxtramQ4cONNKj8opOqSR+927sWrUqMZ1CM4VDp9EQMX06Mm9vnPv1E7x9kViM1+xZPImJIfOffwibOAlVVBROvXoVKf439OsRIBKVWn1WY2Pe6i0hqj1TvD4kJKTA8/39/XP+/eTJk1zPCQ4OBqBcuXLFM66UU1akW3LD20AyKMWt8ZnXy0bGP/+Qdu0ajj26P/dAlzo64r14MerISMLHj3+prJvQXLhwganTprHFQs4de3tctu9g/fDhhS5hVVI49+8PYjGxa9flelylUuV7fUHHXySv+TV79mzWrl1LbGwsGRkZxMbGsnbtWmbPnl3otpNPnkQTE4tj18/1sqmsY6h7ujgk7NlLxl9/4z5xImI9khD1QaxQ4LNkMVIPDyQ2NsQsXUbUvPkFPgteHK+4HTuyEjratzcndBQSs+NXQjyr5WVbiLR2Ozu7nOXta9eu5XpO9u+LsnK3YMECzp8/r/d1pkbq5StPpVsqlXrpltwwlNp8cWt8Ds9DkDku4EdkXl7YviAGC2BRoTxec+eQeukS0YsXC/ExcuVZpzY9M5Mjfr48srOlxe1/OLF8ucnFwT2LxMEB5379SNi7l8xckrYUBcRdFXT8RXKbX+fPn+eff/7J9fx//vmnUM8NnU5H/LbtWNWvj0WFCnrZVNYxtQoS6thYYpYvx75De6zermXQvqROTviuWI5ILkfq7k7C7t2EjR2Xb73tZ8dLm5ZG1PwfENvZ4TFlskFtLUuYHb8SYufOnUCWQ1elSpVCXfPZ07iY7du3v3QsJSWFQ4cOARQprighIUHvN3hTI0u6ZViZlm7ZuHGjQdotbo3P3OaNKiyM5BMncOzePc9Afut33sFt5Ejit+8gYe/eYn6K3HnRqZUqFBx97TXCrK1oFXSb6z/9ZJB+hcKhS2dk7m7ELF/x0rGCSnAVtkRXNrnNr70F/L8UdBwg46+/yPjnHxy7dtXLnlcBQ9zTkZGR7Nu3j3Xr1rFv3z69Xm5iVq4CqRTXIUMEtys35P7++CxbijYlBXmFCqReuEDI0GFoEhNzPf/Z8QobPwFdWhoe06aaEzr0wOz4GYg//viDgwcPvlSoXavVsmHDBsaPHw9krZQ8W7bt559/pmrVqrz//vsvtTlixAisrKw4ceIE654pfK/RaBgyZAgJCQnUrVuXj/IogVQYCvsGb4pkS7d4TJ+OzEW/L7zSQnp6ukHafVF0ODs7FApX41OTy/ZM/I4diK2tsf+kbb7XOnbpjEPnzkTOnUfqZWEy/J4lN6cWmYwDFSsSa2mJ59YAMv/7T/B+hUJsYYHL4MGknD5NelDQc8d8fHzyLPsok8nw8fHRq6/c5ldqamq+1xR0HLIEm2V+flg3bKCXPa8CQt/TFy5cYMqUKQQGBnL58mUCAwOZMmVKocIaMu7eJfHAAVwGDULi4CCoXfmhqFYN70ULUQUHo6hencyHD3nSr3+uJd6yxyv10iWSjx1DUaMG9kZI1ipLmB0/A/Ho0SM+/fRT3Nzc+OCDD+jWrRutW7emfPny9O/fn4yMDLp27cqUKc/rDSUmJnL37l3u37//UpteXl5s3rwZiUTCwIEDeeedd/j888+pXLkyAQEBuLu7s3379mKL4xbmDd7UiMuWbmnSBIcCHA0zLyNUjc9sNElJJPy8H4dOHREXIlvcbeS3WNWrS9iYMWQ+eFDUj5EreTm1KomEw9VfR+vkRPDQYSgfPxa0XyGxbdECefnyxKxa9dzvGzZsiEwmQ/rCaodUKkUmkxUrKSebvOSjCntcFRFB8m+/4fj554hyqZtqRjiKE6ur0+mIWrAAeblyOHQQRvxZH6zq1MFrzmzS//oLRbVq6DIzeNyrN2k3brx0rlapJOTrrxHJ5fiuXWN0W0s75rvQQLz55puMGDGC6tWrc+fOHfbt28fJkycB6NixI0eOHGH79u0vPbALolOnTly+fJn27dvz4MEDfv75ZzQaDUOHDuXPP/8URBagMG/wpoQyNJTIMijdkhtdDbRVVtwany+WEUzYuw/Uahy7dClU/yKpNEtk2909q5h7ZFSRP8uL5OfUquVyvJYuQWJnR/DgIajCwgTrV0hEEgkuXw4i7fdLpN34f2We7P+37P+vZ//WtzYr5D6/OnTokO81BR1P2L0HsUKBfZvWetnyqiDkPV2cWN2UU6dIv34Dt2+/QZTHKrKhsWnSBK85s0m7dg2ptw9yPz+CvxxM3I/bcmpud+3aldAR36BNTMJ94gSkTk4lYmtpxrwpbiDKly/PokWL9L6ud+/e9O7dO99zateubdBVuYLe4E0JrVb7vHRLCT2wjMW9e/eoV6+eQdouTo3P69evU+Fp0L5WqSRh507sWrdGqkeMmcTGBu+lS3nSty+hw4fju2E9kqei5MWhoEoanlWqoFq5guD+AwgePAS/9euQuroWu1+hsWneHIuqVYlZuRLfdWtzVvaFrM2a2/xq1KgR586dyzXBo1q1avlKumgzMkjYtw/7Tz/Nt0ZzaSo5JzRC3tO5hjXw/5XuvGJ1tZmZRC9ajHWDBlg3KNnteNtmzfBZvIjQUaOR+flh9/HHRC9aRPoff+A68ltubtyI12+/YVm3Lo6dOpWoraUVs+Nn5iUKeoM3JSKnz8iSbunXr8xJt+TG1atXDeb4QdFFh5/Vi0sODEQdE4NjEcqjydzd8Fm2lCf9+hM6ciQ+y5YJosNYkHMkc3PDd/UqnvQfQPCQofiuXZOrbl5JIhKLcfnyS0JHjMgKa3jnnZxjQtVmzWt+jRs3rkg6fklHjqJNTsYhn5VfQ+lHlhaEvKdfDGt49u/8YnXjd+xAFRmJt4no4Fm/+y5+69cRPmEiyceOYVGtGilnzpD0yy/81eIj/P398dtkmES3VwGz42fmOQp6gzclUq9cJWHnzizpllFlT7qlNKLT6YgL+BHrxu9hUaF8kdqwqFAB74ULCBk6jIjJU/CcNVOQ2LCCnCOZlxe+q1bypP8AQoZ9he+a1YKsOAqJdaOGKGrWJGbFSqzq1y92PK8+NGrUSD/BZp2O+J07sWnSBLlP7lp1z8akPas5KJPJCAgIoFKlSq/Myp8QNGzYkOPHjyOTyVCpVDlOX36xuuqYGGI3bMChU0csyhftnjUEiqpV8d++jYRdu0g5fx6ppydiayskTk5UOHLYnMVbDMwxfmYAcHBwYODAgYwbN87gfanj40k8fIToFSuIXrGCuK1bybh7NyeGozBo09IIGToUkVyO/+ZNBrTWtKhRo0ZJm5Ar2ZVnUi9mlWdz0qNMWG5Y1aqF54wZJJ88SfSiRXrNjeIg9/fHZ8VyVGFhhA4fjtZAWdRFRSQS4TJkMBm3b5N69qzg7Qs5v9IuX0b54EG+gs3F1Y8sCwg55kWJ1Y1ZuQqRTIbLwIGC2SEUYgsLnHr2xG/tWioePED5HTt48733zE5fMTGPnhkARo4cafCSbcqQEKIXLiLl3DnQapF6eCASi1DHJ6BbshSphwdOvXvh0K5dgcHFwUOGoE1OxnPuXKQuLga125Qw5DZvcWjbNiuTOn5rAIrXX88pz1YcbJs3w230KKLmzEXq6oZTz+I5k4VFUbkyPsuXEfLlYEK/HYn34kUGq15QFKzr1cOqTh1iVq3G+r33BM2UFXJ+xW0NwKJqVSxr187znKLGpJUlhL6n9Yn5zLhzh8SDB3EbNarUlNEz1WdgacK84mfG4Oi0WmI3bOBRp85k3L2L+9gxVAz8hYpHDlPh0CFe++0kPqtWYlnrLaLmzuNhp86k3byZZ3tx23eQdukyNk2b4PDpJ0b8JCWPoQSci8vKlSvzLM9WHBw7dcKpbx+ilywh6ZdfBGmzMFhWr473ksWk//UXYWPHotOz9JmhcRkymMz//iP5+K+CtivU/Mq4c4e0y5dx6tkz37lQXP3IsoAh7unssIYBAwbQvn37XJ2+LPmWhcjLly8R+ZaiYqrPwNKE2fEzY1C0GRmEjxtPzKrVOH7xBeX37sGhQ4fnsiZFcjnW9erhNWMG/tu2IXV2JnjgIGLXr3+pbmOWdMtsJI6OeC8t29ItpY2c8mzNmwvarsuQIdi1bUP41GmknDfe1p/V22/j/cN80i7+TvjkKQavJ6wPlm++iXXDhsSuXYvuBZF4UyBuawAyL09s389/LgitH2mm8KScPEn6jafyLeat01cKs+NnxmBoUlIJGTKEpLNnefxZO/YrLNh/9Gi+IqKKKpXxXbMa5379iFm9hrDRY3LqNj4v3bJGkGxPMwKh02WVZ+vWTfAvEZFIhMfEidg0akTY6NGk5VGr2hBYv/sunrNnk3zyJBEzZqB7ui1pCrgM/hLl48ckBR4raVOeQxUa+rRUX48C50Jx9SPNFA1tZibRS5Zg3agR1u++W9Lm5IkqMorYjZuInDOX6GXLTVpkvTQh0hkratqMSXLjxg1q167N9evXBY3x02ZkEPL11yT/9Te7KpQnwtr6Jf20gt7mU86dJ2zsWBRVKuPQuTOJ+w+Qcvo0Tv36mbN4TYyoBQtIPHyEikcOI7ayMkgfWqWS0BHfkP73X/iuXIVlTeMluiQFBhI+aTL2bdvgPnGiyVSgCP1uFJl371J+394SE919kch580kK/IWKR44UqmoLvNo6fiVB7IaNxKxdS/ldO5GXK1fS5ryEJiWFmBUrSdi3D5FMhtzXF+WTJ2ji45E4O+M5ZTK2H3xgsP6DgoLYv38/CQkJODg40K5dO6pXr26Qvgz1HZwfpvH0MlOm0KnVhI0bR9pff7O7XDlCFQq9ywcB2LzXCN81a1A+CSZs/ARSzp7F4vXXX2mnLzAwsKRNeAlNUhI7w8KyyrMZyOkDEMvleC/4AcVrlQkZPpyMf/81WF8vYteyJZ7TppJ46DCRJrTy5zJoIKrwcBIPHhKkveLOL01CAokHDuDYuUuhnT4oXExaWcXY97QqKorYTZtw7NzZJJ2+1MtXeNShI4mHD+E6dAgVAn/BpmlTtOnpWFSpzPVy5Qj5egTJ584ZpP9NmzYxd+5c7t69S2RkJHfv3mXu3Lls2lR21CPMjp8ZwYlevJjUCxd53K4dYbY2xZJqsKxRnfL7f0ZRrRoWlSriv3GDET6B6ZJbDeeSJmHvPhJtbHDs3NngfYktLfFeugSZlxchQ4ehfPTI4H1mY9eqlck5fxavvYbtRx8Ru2ED2szMYrdX3PkVv3s36HQ4dDH8XCgrGPuejlmxErGFBc4DBxi134LQqVREL19ByNChyCtWpPyePTh+/jlRc+YQu3YtrkOHUH7vXmLr1EYklxM6/GvUSUmC2hAUFMSpU6dyPXbq1CmCgoIE7a+kMDt+ZgQl8cAB4nfsxO27kTxxcnxJqkEikQDoJdUQMXUq6X/+iSo8guChw9CWslrCZZns8myIxUaT1ZHY2OCzfBkSBweCvxxs1LgfU3T+XAYNRB0dTeLP+0vUDm16Ogm7fsK+bRuTqXoSGRnJvn37WLduHfv27Stwl6Gskx4URNLhw7gM/hKJrW1Jm5ODKjSUJ/0HEBcQgMuwoVn3t50doSNHknLiJJ6zZ+Hcrx8isRiRVIr3gh/QZWQQMuhLQe3Yv39/sY6XFsyOnxnBSP/7FpGzZmPfvj0OnToJItUQt20bSYePIPfxweXLQahCQgj9bhRapdKgn8VUady4cUmb8BzJx46hjonhzcqVjdqv1NER31UrEdvYEDzoS5RPnhitb1Nz/uT+/ti1bkXsxo05iVBFpTjzK2H3bjTJyTj16lUsG4TiwoULTJkyhcDAQC5fvkxgYCBTpkwxOVFoY93TOp2O6AULsKhUCft27YzSZ2FIOnacR12/QBMXh9/69Tj37o02JYWQoUNJu/kH3kuWYPfRRznnN27cGNvmzbH94APSb94kbvt2wWxJSEgo1vHSgtnxMyMImsREwsaNxaJaNdxHfYdIJCq2VIPyyRMi58xF4uRI+YMHcO7XD++FC0j/4w8ipkwtkS/ckl5BcHJyMmp/+ZFTnu299/CtWtXo/UtdXPBdvSrL+Rs46JV2/lwGDECTmEjCrl3Faqeo80ublkbclq3Yf/IJMi+vYtkgBM+WgitKfLExMdY9nXzsGOl//oXryG9NQr5Fm55OxPfTCR8/HutGjfDfsR3LmjVQx8QQPHAQmY8e4bt6Ndb1nxdszh4vrwU/IHF0JGrOXNQCOWQODg7FOl5aMDt+ZoqNTqcjYto0tKlpeM2ZjeipzEpxpBq0Wi2Pe/cBrfY56Rar2rXxnDGd5F9/JXrhQqOV8gLTWEEwpa2G1IsXUd6/j1OP7hw5cqREbMhx/qytS3TlL2L69BJ1/mTe3ji0+5TYzVvQFCPuqajzK37XT2hTUnDu17fIfQtJaSoFZ4x7WpOcTNSiRdi83xxrE6h8kXH3Lo+79yDp2DE8pkzGc+YMJDY2qMLCeNKvP5qEBPzWrcOyxsuZtNnjJZbL8fphPjqVitARIwSxq10BK6EFHS8tlLzbb8Yk6NixI5aFyMLLLbg1fscOUs6cxXvRQmQeHs8d06d80LNETJiIOiwM58GDsaxZ87ljtu+/j9uY0UTNmYvExQXn3r0L/oDFxFxM/mVyyrO9/TYYsarGi0hdXPBds5rgQV8SPHAQPqtWGq3YvF2rVgCET5kKgMekSSUm9eI8YACJR44St3kzrsOHG61fbWoqcQFbsW/36Uv3f0lhLgX3PDErVqJNS8NtZMkqIug0GuJ//JGYlauQV6iA/48BOfdq5oMHhAwZisjCAr8N65F5exfYnk3Dhlg3aEDqxYsknz2HbeP3imVf9erVadasWa4JHs2aNTOYpIuxMTt+ZopF+q0gYpYsxbFbN2zyiFXJlmooLMlnzpC4fz8W1ari9nXuX2COnTqhiY0lZtlyZB6e2LVsUST7C8uLKwgSiQSNRpPz84ULF/T6jEWlONtCQmqlZdy+Tdq1a3jOmY1IJEKhUJSoTTnO35ChBA8YiM+KFSiqGCfu0FScP6mLC049ehC3eTMOnTsXyQkryvyK37kLXVo6Tn366H2toXgxvvjZv02tFJyht3rTbwWRsGcPbiO/RebuZtC+8kMVHk745Cmk37yJY4/uuAwenLOTkx4UROhXw5G6uuKzfNlzlZ1e5MXx8lq0kHvvNSZ8zBisL5zP+X8vKn369KFevXpG0/ErCcwCzq84xRGP1CQl8bhbNyROzvitW5uzxVsc1ElJ3GvaDHQ6Kp36DWk+MRU6nY6IyVNIPnEC39WrsHzzzWL3nxfr1q3j8uXLKJVK5HI5YrEYrVab83P9+vUZMMC05BGe5cKFCwQEBKDVavUW0s6NsLHjyLh9m/I/70P0NFO7pG2CLB25kGFfoQwJwWfZ0pdWiw1J0tGjhE+Zil2b1iXm/GlTU3nwWXus33kHz++nGbw/TUoqD9q2xa5lS9zHjDZ4f4UlMjKSKVOm5LpCL5PJmDZt2iuxQq9Tq3ncsxeIRPhv2VwisX06nY6ko0eJmjsPsa0tnt9Pw6p27ZzjadeuEfLNN1hUrITPksVI7O317iN261aiZs3G4fMueE6dKqD1hscs4Gym1JAV1/c9muQUvGbPEsTpAwju2w9dejpe8+bm6/RBVikv90kTUdSoQei3I1GGhAhiQ26YSjH5HTt26H2N0IHuypAQkk+exLFH9xyn74cffihRm7KRODjgs3o1FpUqETx4CKlXrhSpnaKQHfOXdPhIicX8ia2tcRk4gKSjR0kvguaYvvMrfsd2dBkZOBkh3EIfDF0KTsgkr+wxN0TiWPyOnWT++y/u48eViNOniowk9JtviZg8BZsmjSm3a+dzTl/KmTOEfDUcy5pv4LtyRaGcvtzmqHPPnsjLlydh9x4yjajtWVoxb/WaKRLx27eTcvo0Xgt+ECyLL3rVajJu3cKuTWvsPvywUNeI5XK858/jcZ++hA7/Gr/Nm5DY2Qliz7M0bNiQ48ePI5PJUKlUOU6fsYvJx8XF6X2N0NvU8T9uQ2Jnh33btjm/y9BTRsSQW+cSG2t8li8jdOR3hH49Aq+5c/IMQxAau1atQCQifPIUUGvwmDLZ6F+49u3akbBnL1Fz5+G3eZNeK4/6zC91dDRxW7fi0LFjiW4h5kVR44sLIreV6uPHjxd5pTouLk7wNiErZi5m5Uocu36OpZG3KXVaLQl79xKzdBliKyu85s/Htnmz585JOnqU8KnTsGnSBM+ZMwpdez2vOeq9fBkP235CyLCvqHhYmEo2ZRXzip8ZvUn/80+ily7DsUd3bJs2FaTNjDt3iFm+HKm7O57z5ul1rcTBAZ8li1EnxBM6ahQ6A2j8leZi8rkFuhdFSBtAHR9P4qFDOHTpgriIcX1C25QbYoUC70ULsW7UiNCR35FgRHFju48/xnPGDJKOHSN80mR0z2w1GgORVIrbmNFkBAWRePCgwfqJWbUKkUyG84D+BuujuAhdCs4QK9UajUbwNnUqFeGTJiPz8sJl6FC9ry8OykePCB44iKg5c7Ft0YJye3a/5PTF79xJ+KTJ2LVuhdfsWYV2+vJDUbEi9p99hvLePeKKsDPyKmF2/MzohTo+nrBx47GsXh1XgR4oWrWaJ/0HgEiE3+ZNRQrOlfv54f3DAjL+/IuIWbMMIvPSsGFDpk2bRsuWLalfvz4tW7Zk2rRpRlvtg6LJCQi5TZ3w024AHDt3eu73rVu3LjGb8kIsl+M1ZzYOHToQOWMGMWvWGk3+x67FR3jNmUPKb78RNnac0QXHrWrVwq7Vx8QsW44mMbHQ1xV2fmXcuUPiwUO4DPrSICvspoohZGKcnJwEbzN2w0Yy//sPz+nfF+sFTR80KalELV7Moy6fo46Oxnf1KjwmTniuQohOqyVq0WKi5v+AY/fuWbGweq6I5zdHPaZNRWxvT9S8+ahTUor6Uco8ZsfPTKHRabVETJ6MLjMTz9mzEMlkgrQbNuIbNDExuI0cWSwZDqu3a+ExZTJJhw4Tt9EwBbVLuph8UbZ6iyuknY02I4OEXbuw//RTJC/EX4aHh5eITQUhkkhwGzMal6FDiV27lsiZs9Cp1YK0XRC2zZvh9cMPpF68SNh3owSppasPrsOHo1OpiFqwsNDXFGZ+6TQaImfNRl6hAg4dDJ/JbkoYYqVa6DbTg4KI3bgR5379ULz+ut726ItOqyXx0GEetm9Pwu49OA/onxXLV7fuc+dpMzMJHzee+G3bcBv1HW7fjChSAlR+c1QsleI1cya6jAzCvv1W77ZfFcyOn5lCE7dpE6m/X8Jz5gxkAjk8iYcPk3zyJJa138a5T+9it2f38cc4DxxIzMqVJB07XnwDTYyzZ8/qfY1Q29SJBw6iSUnBqXu3l47duHGjRGwqDCKRCOe+ffCYOpXEQ4eySv6lpwvWfn7YvNcI70ULSbt2jdBvvi12STV9kLq64jZqFElHjpCcR+H5FynM/IrfuZOM27fxmDjBJCpAGBNDrFSnp6cL1qY6Pp6wMWNQVKmCc1/Dy+uk3bjJkz59iZg6Fas6dSi/dw/O/fu/tMqoSUwkZMhQUs6dw2vePBw//7zIfRY0R20/eB/LOnVIPXee1Iu/F7mfssyrddeaKTLJp04Rs2o1zv37Yf3OO4K0qQwPJ3z8BMTW1vitXStImwDOAwegCgkmYupUZB7uBpV5KS0UN9Bdp1YT/+OP2H7wgWDJPIYKvs8L+7ZtkLo4Ezp6NE/69cd74QKjCA5bv/MOPkuXEDLiG0KGD8dn8WLEVlYG7xfArk1rUk79RuSs2Vi+9RZSR8ditacMCSVm5SocOnfG8o03BLKy9GCIJC8rK6uc1e/itKlTqwkfPwFdegZe6+cJtiOTGxn//EPMypWkXvwdi6pV8V23Fqs8pEhUoaGEfDUcTUJCluyWEeaNz7Kl3GvchNBRo6h07myxtf3KGubRMFMgGf/8Q/jESdi+3xzngQMFaVOr1fKkew90ajW+a9cgtrYWpF3IlnmZhKJ69acyL6GCtV3SVKxYscjXFmebOvnkb6jCwnDq2SPX4675CK4ayqaiYP3uu/ht2IAmMZHHvXqR/vctg/aXjVWdOvguX0bmP3cIGTYMjZHij0QiEe7jx4NGQ8TkKeieOhV5kd/80iqVhI8di9TJCddhxk0YMBUMsVJduXJlQdqMXrGCtOvX8Zoz22AvNJn37xM6ejSPu/dAFRaO19w5+AdszdPpy7h9m8d9+qLTaPDbvEkQp68wz0CpgwOuI75GExtL5MxZxe6zrGEWcH7FKUg8UvnkCU8GDEDm7pHloAkUKBw68juSjhzB+csvcRvxtSBtvogmIYHHffoiepo08ioFoQuJTqfjcfceSOzt8V25oqTNEQR1bCyh331H5p27eEyZYvDKL9mk3woiZNgw5L6++KxYbrQ5mXrpEiFfDcexa1fcvv2mSG1Ezp1H4s8/47dpI4pq1QS2sHQhZBUcIdpMCjxG+IQJuI78FqcvviiWHbmR/scfxG7ZQurZc0g9PXAZ9CV2H7fMd6s/KfAYEd9/j0WlSngvXoTUwBVKcuNey5aogkOocOQwFuXKGb3/wlASAs7ozLzSXL9+XQforl+//tKxzMePdfdatNQ9aN9Bp4qJEazP+IMHdberVtM96NRJsDZ1Op0uIiJCt3fvXt3atWt1e/fu1UVEROgyHz/W/dusme7JwEE6bWamoP2VBMuXLzd6nym//66783ZtXcrvl/I8Z/r06Ua0SBg0GRm6sIkTdXferq2LXrlSp1WrjdJv+j//6P5r1lz3sOsXOlVcnFH61Ol0urgdO3R33q6ti//55zzPyWt+xe3clXXt7t0Gsu7Vpbj3dMrvl3R369XXhU2arNNqtQJZpdNp1Wpd0qlTusd9+ujuvF1b96BDR13CwYMFPke1Go0uavly3Z23a+tCJ0zQadLTBbNJp9NvvNL/+093u9rrunutWwtqg5Dk9x1sKMwxfmZyJePOHUJHfIPY2hrf1auQClSZQhkaSsSEiYhtbPDfJFzmbX4CqLV++IGQwUOImD0bj8mTEYlEgvX7KhC7fgOK6tWxql+vpE0RFLGFBR7ff4+8fAViVq4k4/ZtPGfMKFLJKH1QVK36/7rCg77Ed9VKwe6v/HDo0oXMBw+yMpszlTh26Vyo6xJ+3k/UvHk4duuGfYcOBrbSjD6kXb9O6HffYVW/Ph6TJgrybFNHR5N48CAJP/+MOjwCyzffzNHELCgLV5OSSsTkSaScPYfr8K9w7NmzRJ+3ikqVsG/fnsQ9e4gLCMCpR+6hKq8aZsfPzHPodDoS9x8gat485BUr4LNoUb4Fs/VBq9XyuEdPdGp1ll6fQHF9z4qqvliXMyAggErTpuExZTLhkyYj9/HFuV9fQfp9FUi7cYP0mzfxXrQw5wGe25ZUaSU741fxejXCxo/ncffueM2fj6JqVYP2a/Haa/iuXUPIl4MJHjAQn1WrDF79QiQS4T52LGILC6LmzUMdGYHL4MF5JgHoVCpiVq0mbssWHDp1wvWbEeaXJhMi9dIlQkd+h+Ubb+A1b26xkjl0ajVpV6+S8PPPpJw5i0gqxfbDD3Do0KHQ9a6VISGEfjsSdUQE3osWYfNeoyLbIyQeU6eQcuIEUQsWYPfpp0gNEF4RFBTE/v37SUhIwMHBgXbt2lHdyNVS9MEc4/eKkx1fcO3aNaqq1MSuW0f6H39g36E9biNHIrawEKyv0G9HknT0KM5DBuM2fLhg7e7bt4/AwEAyMjKeK/+l0WhQKBS0bNmS9u3bE7NmLbFr1+I5axZ2LT4SrH9jkp6ejqWlpdH6Cx4yFE18PP7btyESiXJdWRWLxXTo0IEPC1lmz1RRhYcTNmo0mffv4z5uLPaffGLwPpXBwQR/ORiRVIrvmtVGyTIGiNu2jehFi5H5+uI6dAg2TZsikkpJT09HIZeTcvYscRs2kvHvv7gOHYJjjx5F0lwzUzBFuacT9u8ncvYcrOvXx2ve3CLFXuu0WtL//JPk47+SfOIEmrg45BUr4tC+PXatWz0nvFwQqZevEDZuLBI7e7wXLsSiQtH1WAuiKOOVfOYMIV8Oxurdd/HfuEFQezZt2sSpXOSSmjVrRp8+BUvqlESMn3nFzwwAwQMGYCMSo6hWDe/FiwV/W0s4cJCkX35B8eabgjp9kLsAKvxfEytbANV54ACUwU+yZF48PUqlHMWVK1do0qSJUfpKvxVE2uXLWWLdIlG+K6unTp3ijTfeMOnSdQUh8/TEd8N6oubNJ2La96Rdv4H7mNEGlV6R+/rit24twYO+5En//viuXoPcx9tg/WXj1K0bVnXqELN8OWFjxiKSy5FXqMBfri5U+/MvtElJWL75Jn7r15XK+6Q0oc89rc3IIGrBQhL37cO+Q3vcR4/WS0tRm5lJ+vXrpJy/QMqZM6gjIpC6u2PXqhV2LVtgUbWqXqu6Oq2WuE2biVm9Gqt69fCaPcvgCUtFeQbaNmmC1Tv1Sfv9d5LPnsO28XuC2BIUFJSr0wdw6tQp6tWrZ5Irf2bHzwwAdp98gm+bNljWri34dk7mo0dETHoa1yfw2xa8LKr67N/PCqCKRCI8Jk8mJDyC0G9H4rd5s1G+ZIXk1q1bRnP84jZuQO7vj+377wMvl6vKXllVqVTI5XIuXLhA+/alu5KD2MICj0kTsaxVi8g5c0j/6y+8Zs8y6NavzMsL33VrCR48hOABA/BZscKgKybZKKpUwWfZMtKDgsj46y8y//uPh1otDbt9gdU772JZw/S+sMoihb2n0//4g4jpM1CFh+M+YQL2n7Ur8Fmt02pRPnhA2o0bpF78nbSrV9FlZCD18MDmvfew/egjLN96s0iruZqEBMInTyH14kWc+/fDecAARE8rjhiSoj4DvZcs4d57jQkbNYrXzp0VpD7w/v37CzxudvzMmCwOn3ySpxZTcdAqlTzu3gOdRovf+nWC6vVlo4+oqlgux3vBDzzu3YfQr7/Gb9NGs8zLM2TH76XfucObJ3/DbvTonId5fiur2cfLCvZtWmNZswZh4yfwpFdvXIZ/hWPXrgbb7pR5eOC3dg3Bw4YR3L8/PiuWG00yxbJ6dSyffjlJV6zAuX9/o/RrLHQ6HZqEBFRh4Wji47I0FFVqdDodIpkUsVyO2MEBqaMjUjc3JDY2JW3ycyiDg4lZtZrkY8dQ1KiB/9YtWFSqlOu5mpQUMv/9l4xbt0i7eZP0P/9Em5gEUimWb76By6CBWDdsiLxChWK94Kf/fYuwsWPRpafjs3QJ1g0aFLktYyG1s8Nt3Dgip04lbMxYfBYVvpRhXiQkJBTreElhdvzMGJQnfftl1eEdPw4rA1XQyBZVDQgIQCKRPBd7lpsAqsTBAZ8li3ncpw9ho8fgs3QJIgHe/oxB3RfqX2YjhK7Ys/F7H965S7xEwsozp+lWzp+GDRvmu7Kanp5epHJVpozc3x//TRuJXrGS6IWLSP39dzwmTRKsXOGLSF1d8Vu7lpDhXxM8cBDeSxYb5GUsP/KaX6UBVVQUycd/Je3GDZQPHqCOjkabkoJOqQR9QtlFIpBIEMlkiBUKxFZWiO1skTg4InVyQuLqiszDHZm3NzJfX+S+vkiK8UKb25jrVCpSL10i8cBBUk6fRursnLXK9+kniCQSNCkpqIKDUT4JRvnkMZn//UfmnbuoQrPE6kUKBZY1a+LY5XMs33oLyzdqIhYgNlin05Hw026iFy7Eolo1g4pF50Vx5qjT511I3LOH5MBAUrt+jnW94ikVODg4EBkZme9xU8Sc3PGKY8jA0qiFi4hduxbbDz/EZ9lSQdvODX2dn7QbNwgZPAS71q1wnzSpVGQsxsXF4fSCEGpeCRc9evQodMZtZGQkU6ZMQaVSYZuUTK/btznh58sdLy9kMhnTpk0DyDnnxRg/a2trJkyYUKpj/PIj9eJFIr6fjjY9HbfvvsOuTWuDzRdtWhqh347M2maeNw+bRsbLms5tfpkq6phY4ndsJ+XMWTIfPECXlpZ1QCRCZGWJ1NEJqZsrUncPZG6uSJxdshw4G1tEMimIROg0GnSZmWiTktEkJaKOj0ebkIAmMQlNUtYfbWoquvR0dJmZ6NTq3J1IsRiRTIbIwgKxtRUSG9ucVUSJiwtSJ0fEdvZIrCwRWVoitrTMetkUi4lLSsYBUMdEo3z0OGvF7u7drC1ZV1cU1aoicXJGk5iIJiYGVUQEmvj4nK4l9vZYvPYaFpUrY1G1CorKlZGXKyd4yTZNcjKRM2aSfOIEjl0/x3X48BJ5YS7uHFXHxXGvaTPE1tZZ5dyKUW86KCiIuXPn5nl8zJgxBW71mpM7zJQZks+cIXb9OmS+vngtWWyUPrPLfxUWq7ffzpF5kTg74zrU9MtQ7dixg6HP2FmglE2lSoVyxp6N33snMpI0uZy7bm458XzZ8Xt5ray6uLiUWacPwLpBA8r9tIuoHxYQMXUqySdP4jFhvGBSR88itrLCe8liwseNJ3TkSDy//95oWegvzi9TQxURQczadaScPIE6Khp0OkRyObJy/ljVehubpk2wfucdQVa3ckOn06GOjUX15Amq4BCU4WGoIyJRx8RkbSMnJKJNSUEVEYHu8WN0KlWBq42BrT6m5dFfsn4QibKcSIkEJBI0yclk3n+AND4BiasLFlWrYt24MXI/P+R+vsh8fIwSqpJ24ybhkyahTUnBc85s7Eowg7+4c1Tq5ITbqO+InDmL8HHj8Z4/r8htVa9enWbNmuWZ1WuK8X1gdvzMGABleDihX3+NSGFJuZ07TLpAtl2rVqhj44hevBiJrS1OPXuWtElA4Vcv80u4eNZhK6jN7Pg9p/R0qsbGcrZCBZDJQKl8LjO6YcOGVKpU6aV21q1bZ7zBKSEkdnZ4fj8Nm+bNiJw1m4edu+D2zQjs2rYVfPVPbGGB17y5REz7nvAJE9CmpODQoXQnzhQVrVZLwvbtxP24DdXjx6DTIXFwwLZlSxy7fo5V3bpGW60XiUTIXFyQubhAIVZndDodmqRkNDHRqOPi0KamoctIR5uekbWCqNMiefQIr/nzkDg5IXF2RmJjk7W9bGWFyMKiRHcidGo1sevXE7thI5ZvvIHnjOnIPD1LzB6hcOrRg4R9P5N0+HDWHCrGSlufPn2oV69eqdLxMzt+ZgRFm5HBo06d0SlV+G1cbZSKBMXFqUd3tCnJRC9ZitjGFof2n5WoPflVIXlRv+rZhAv4f8wd8JzDll+bz8bvNQgLJ1ku55arS66Z0ZD7yqrECNl8poJt06ZYvfUWUQsWEDHtexIPHsJ93FgsClE8Xh9EUike06YitrEhctYstKkpBn8xMaZGZEGoExKInDOX5MBAdBkZiBQKbJo3w2XwYCxr1Chp8wqFSCRCam+H1N4uz/lhs3Ej9m3bGtmyglGFhhI2cSIZQbdxHjgA5z599JKOMRRCzVG/tWv4r/n7hHw1nEpnThdry7d69eom7ei9SMn/L5oxCTp27FioGyooKCjPY1qtlkdfdEMTG4v7+HFYv/OOkCYaFOcvv0STlEzkrFmIra1LTOC5oK3b7Fi7bJydnckO033W6YOs1QZnZ+dCbQc3bNiQG/v2UTkhgWP+fmSo1TnnvJgZnRvjxo0r1ucubUgcHPCcPh27Nm2JnDuHR190w6l7d5wH9C+SmG5eiMRi3EaPQmJnS/SSpWiSknEZOsRgq0B9+5Z8VRtlSAgRU6eR+vvvoNEg8/bGqU9vHLp2RVwGXzBMYcxfJOmXX4icNRuJg4PJaTkKNV5SV1fcRo4kas4cwr4bhc/iRYK0W1iyq33cvXvXqP0CmO4enJlSR/io0WTevo19hw6lriaiSCTCbdR32H3ckvDJk0k5d65E7Hh261YkEiEWixGJRKhUKrRaLTt37nzu/CpVqjznzD2LSqWiSpUqL20Hy+VyJBJJTpsXLlzA3d2dTjpItLTkgbc3crkchUKBTCbLNTP6RZYuNXzyjiliXb8e5XbuxLl/P+K3b+dhh44kBR5DyJw5kUiEy+DBuI4YQdymTUTNmYvuBSdfKArSJTMkqrAwHvftx/2PWpB64QKKatXw27aNSidP4NS9e5l0+qBkx/xFNCmphE+aRPjESdg0bYL/jh0m5fSBsOPl3LsXijffJPnYMZJPnBSs3YLYtGkTc+fO5e7duyUig2Ve8TMDwJ49e4qVURS9ajVJR45g+XYtvGZMF9Ay4yESi/GYPBltegZho0bjNX/+SxVMhJBNyY/Y2FjUT1fbdDrdcw6EWq0mJSXlufPv3r2bo1/4IjKZLOfBUlBlk/S//kJx5w4VRo+ihUym9+dLSkoq8mcu7YjlclwGDMCuZUuiFy0mfMIE4nfuxO3bbwT90nTq0R2xrQ2RM2ehjo3Fc8Z0QVcXAUKfyoEYE01yMuETJ5F84gRotVjWqoXH99+jqCTs1rmpUhJjnhvpf/9N+PgJaBIS8JwxHbuPPy5pk3JF6PHyXbeWe02bETp6NJXOnkFqYB3H/Kp9GAuz42em2CT9+isxy5Yi9fTEb/PmkjanWIhkMrxmzSRs3HjCRo3C64cfcuQ0CoqTEwKFQpHj+L2IWq1+aYsvNjY253fZq4M6nQ6tVotIJMpx4AqqbBKzchUWlSrh06kTviacjGPKyH198V64gLRr14hatJgnffpi+9FHuAwdgtzHR5A+HNq1Q+rkRNi48YQMGYL3woVITFQrrCC0ajXRCxYQv207OqUSi6pV8Zoz26BVUsy8jE6jIW7zZmLWrEXx+uv4rFpV6ioaFQepnR1ec+YQ+vXXhAwcSLnt2w3anyms8Jqf8GaKReqlS4R+8y1iK2vK79ktSBmckkYkl+M1exbWDRoQ9t13pJy/8FycXEZGBkqlkoyMDFQqFQEBAfmKeArJiyLJzzp1IpEIiUTynCOYvWonFouRyWRoNBqUSiUajSYnfq+etTVpV6/iPPjLIlemaNy4cfE+WBnCqk4d/AO24jF1Kuk3b/KwfQcivp+OKixMkPZtGjfGd80alE+CedK3X45orxC0aNFCsLbyI277dv57twFxmzYjcXbGZ+0aKuz/+ZV0+ow15rmhiowkeMgQYlatxrlPb/zWrzN5p88Q42X30YfYfvAB6TduEhcQIHj7z2IK1TzMjp+BUKlUnDx5klGjRlG3bl0cHByQyWR4eHjwySefcOTIEb3bnDp1KiKRKN8/d+7cMcCnyZ30v/7myYCBiKRSyu3+qVRk8BYWkVyO15zZOc7fH5s2FxgnJwQZGRl5ZshKJBKUSuVzvyvIqcvequ3RowcymQyFQvF8/F63bqi3BqCoWRMbI9UALo3o1Go0KalokpPRJGYJ/apjY7MEfjMzX4rpE4nF2LdtQ/n9P+M64mtSzp3jwWftiZg5C1VERLHtsaxRHb9NG9FptTzu05eM27eL3aYxSDl7lv+aNiPy+6xwEPfJk3jt1G/Yml8cjE7y6dM86toV1ZNgfFevwmXwYJPI2i0pvBYtROLkROS8+SiDgw3WjylU83h1/5cNzJkzZ/jwqcilh4cHjRo1wtramtu3b3Po0CEOHTrEwIEDWb16td4Zem+++SZvvfVWrsfs7e2La3qhyLh/n8c9eyASgf+PAViUN3xReWOT7fyFjRuP584dVCxXjiA7uzzj5ITA2dk5x4nLduazY/1kMhmpqanPnV/YcnV56e8prlwl4s4d/DZuKFam6NmzZ0vlqp9Oq0UVFpYlyBsejio8AlVEOOrIKDRJiWiTU9AkJ6FLSy+wLZGFRVaJLwd7pA4OiO3tkTg4ILG3x6FzJzL/u0fSL7+QuH8/th99hFO/vigqVCiy7XJfX/w2bSR0xDc86T8Aj0kTix2XdezYMSrlUQe2OGTcvUvYmLFk3rmDSC7HqU8fXL8bWWYTNvTBUGOeF9qMDKIXLSZhzx5smjbFY9LEUhUuYKjxEkul+K5ezaOuXXncoycVfztpEA3adu3a5VvtwxiYHT8DIRaL6dChA19//TXvvffec8d27dpFt27dWLt2LQ0bNqSnntpc7dq1Y+rUqQJaqx/K0FAed+6CTq3Bb+OGUqOpVRSynb/HfSJpcfMmEj9fgp7WpsxL5644NGzYkOPHj+ckbGSvJGWv4FlZWeV6TW5O3YtJGS/q72kzMni4ciW2H3yApYHqKJsSOrWazP/+I/2vv7Nqm/73H5n376NLf+rUicVI3dyQeXggdXfH4rXXkNjZIraxRWJrg0hhiUgiBnHWH5FYjE6lyir5lZGJTpmJNjUtq7RWYiKahASUDx+hSUhAk5iINikp6/9TrSZx3z4S9+1DbGWFvHw5FNVrIPfzQ+aXVftV7uuLuBD1X6WOjviuXUPkrNmET5xExr//4jpsWFblBxNAHRND2JixpF68CCIRti1b4DljBhIDB9CbyR3lkyeEjhqFKjgE93Fjse/QoVSUqjQWlm/UxGXYMGKWLCFsxDf4LF0ieB/5VfswFmbHz0A0b96c5s2b53qsS5cu/Prrr2zYsIGtW7fq7fiVJMrgYB6274A2IwOfZUuLXeS6NCCSyagwfx4nevbkgyfBKNQarni4g0hUaJ27wlLQCl50dHSe1+lTrg4gLiAATXw8Ll99VWy77YxQNkpfdCoV6X//Tdq166T/8Qfpf/+FLi0dkVSKvEIFLCpVwvb95li89hrycuWQuroadKtLq1SiiY5GFRWFKiyclDNnSL30Oxl37pJ5/wEiqRTd05VeAImzM3JfX2S+PlnOYLlyyCtUQO7r+5ydYgsLPKZOwaJKZaIXLUZ57x6eM2cWqZSXt7cw8V3ajIwscetDh0CjwbJWLbzmz0MuUPtlCaHGvCBSzpwhfNJkpC4u+G/dgoURVxmFxNDj5Tr4S1LPnyf5119J2LcPBz2fq4Xh2WofJaHjZ3b8SohatWoBEGzAWAKhSb/9D4+7dUOnVOL1w3xs83BsyyIenp6UnzKFazNn0ejJE6x1On4vXw6xRFIonTt9KOwKXnFQR0cTt2UrDl26CBLMPXz4cAGsKj6qyEhSL1wk9fffSbt8GW1qKmI7OyzffBPnfv2weustLKpVQ2xhYXTbxHI5Ym9vZN7eUKsW9q1bodPpSP/jDxIPHCD51xPoMjNRVK+Oonp1JDY2KMNCUT58RMrZs2gTsyRzRDJZlhNYsQKK11/HskYNLKpUwemLL7CoUJGwceN43LNXkTJk27VrV6zPqNVqiVmylLgtW9BlZCAvXx6v2bOwzCM0xUzxx7wgdBoNsWvXErt+AzbNmuExdSoSm4JXk00VQ48XgN+6tfzXrDnhU6ZiVbs2cn9/wfvIrvZx48YNAgycUPIiZsevhPjvv/8A8CxC3cMbN24wduxY4uLisLe3p1atWrRt2xZbW1uhzcwh6ddfCRs5Ep0OfFavwvaF7etXgYaNGlFp8yaCFi6izi+/UNXVhfJz5+Lh5yd4X3mt4G3cuFEQ5fropcsQy+U49xNGBX/27NklVr1DFRpK8okTJP96gox//gGxGMuaNXDq2QPrBg2wqFq1yNnKhkYkEmFVqxZWtWrh9t0oko8fJ/HAARJ27ULi6Ihdq1ZZDl21amji41Hev0/m/Qdk3r9P5n//kfLbKXRKJUilWFSqhOVbb+L2zQjid+zkSe8+uAz/CseuXQu9nVfU+aXVaIhdt464DRvRJicjcXXFY/Zs7D5uqXdbrxpC3dO5oUlMJHziRFJ/v4TL0KE49eld6rd2DTle2YitrPBbt45HXbvy6ItuVDp5QnDNzJLE7PiVABEREWx+qnfXoUMHva/PTg55Fnt7e5YuXWqQbeOoxUuIXbMGsZUV/ps2YflGTcH7KC24u7vjPncOyS1bED5xEpkTJ6FeuACpi4tR+k9PLzjJoCDSrl0j6ehR3CdNLNJ2YG68WC7O0ChDQkk+8SvJJ06Q+c8dRAoF1g0b4Nm9O9bvvoPESElOQiKxscah/Wc4tP+MzHv3SDxwkKQjR4jftg2puzs2TZpg06QJDh3aI5LJgKzt7Mx790i/dYuMW0GknD5Dws5dYGGB1MmJqLnzSD5xAs9p05D7+hZog77zS5uRQdTChSTs2YsuLQ2xjQ0uQ4cKXrquLCPEPZ0bypBQQoZ/hSYhAZ/ly0pVCc38MNR4vYjlGzVxHzeOyBkzeNyrN+V37Sz4olKC2fEzMmq1mu7du5OYmEjNmjUZNGhQoa+tWLEis2bN4uOPP8b/6dLz7du3mTNnDocPH6ZXr15IJBK6desmjK2xsTzp35/Mf+4g8/Gh3E+7kDo5CdJ2ace2WTNk69cROuIbHvfqjc+SxaUiZkanVBI5Zy6Wb76B/SeflLQ5eqGOjSXp2DGSjh7NcfZsGjXEqWdPbBo1QpxL4ktpxaJSJdxGfovr18NJv3mT5NOns5y6n35CbGWFZe3aWNWtg1WdulhUqYKiWjXo1AmdTofy/n1Szp8n9fwFVBERpF26zIPWbbBr1Qq3sWOQFiODUxUZRer586ReukTquXNontUkk8vRabXEbd5M3ObNiCwtkTo7Iy9XDouKFbGoVBGLypWRV6hgsiuwZYX0W0GEjhiB2MYG/y1bCuX0m3kZp+7dSP/zT5IOHSL8++l4Tp5U0iYJgkgnZFFJMwXSv39/NmzYgLOzMxcvXqRy5cqCtDt8+HCWLVuGq6srISEhyAsppHzjxg1q165NuXLlsLS0BECs1dEd+JisN4MzwHIAcd5bBEOHDmXo0KHF/BSlD1VkJKEjvkEVEoLH9O+xbdrUoP3FxcXhVAznO3bjJmJWr8b/xwAUAs09gAcPHlChGNIkeaHNzCTl7FmSDh8h9fffEYnFWL/3HrYffZjl7D2ds68COp2OzLt3Sb1wISth5c8/0WVmIrG3R1GzJopq1VC8Xg2LqlWRubkBoI6PJ+nwEWI3bkQdHg4SCdYNG+I26jsUr732Uh+5zS91fDwpJ0+S9EsgaVevolOrIbsEoIMDdp+0xe6jjxBbWWVVjUlOQRMfhzouDnV0NMoHD8m8fx/1U/1Csa0tlm+8geVbb2FVty6K16uZTBZySVDce/pFUs6dJ2zsWBRVKuO1YAFSR0fB2jYFhB6vgtBqtTxq9xmZ//2H5+zZOLT7VND2s7+Dr1+/XqyyqfpgdvyMyNdff83SpUtxdHTk5MmTOQkeQhAXF4ebmxsajYazZ8++JCGTF89OumpyOXGbt5Dy229o09KQurnhteAHrOvWFczOsog2LY3wyVNIOXUKp969cRn8pcGyQ69cuUK9ImZSq8LCeNipMw4dO+L2zQhB7dq9ezedOnUSpC2dTkfGX3+ReOQIycd/RZucjKJGDezatMbuo49K5TauIdBmZpJx6xZpV6+REXSLjH/uoImPB0Di5PR/eRgfX2R+vqgiIknYsQPlw4cAyHx8sHn/fRy7dM7R4cyeX6qICJJPnyFxzx4y7t4FtRqyvyosFdi88y4ugwfrFfahSUkh859/SP/zT9L++IOMP/9Cm5aGxN4eqwbvYtOoEdbvvFOqNOWEoDj39IuknD1L2KjRWDdqhOfMGWVyu13I8Sos6pQU7r//AdqUFPw2bRRUzaIkHD/zVq+RGDlyJEuXLsXBwYHjx48L6vQBODk54ebmRnh4OCEhIXpf/7BDBywtsh4SIktLrBo3xubdd1GFhJKckoLMwwOZlxdiO7tSHxwsNGIrK7zmzyM+IIDoZcvJCArCc9ZMg2yLX716tUgPPZ1WS8T305E4OOAyaKDgdgkhSaAKCyPxyBGSjhxFFRyM1MMDh04dsW/dGnm5csU3sowhtrDAqnZtrGrXBrIcZnVkJBm3/yHzv/9QPnmM8v4DUk6fQZuU9P8LLSxAq0UVEkL85s3EZ9fXlki40KIFtr16/9/Je4rIxgbLGtVx7NYN2w8+KNIzQGJjg1XduljVrYszWbqKGbdukXLxIqkXLhL+SyCIxShqVMe2+fvYfvgBsqeamWWZot7TL5Lj9DVujNesmTlxoGUNocZLH6Q2NpT/aRcPPm1H8ICBlNu3F0XFika1QUjMjp8RGD16NAsXLsTe3p7jx49Tp04dwfvQaDQkJiYCFCm7V2zvgMzNLUtqAh2amGjiArbmSEjknGdtjczLC7m/H/IKT+N2KlZE5uPzSpf7EYlEOPXsieL11wkbP4HHX3TDc/YsrAR28ItKwk+7Sbt6FZ+VK00qFk6TkkLyiRMkHT1K+vUbiCwtsX3/fdzHj8OqTh1zLJgeiESirBc0Dw9smzd77pgmIQF1dDTquHg08fFZW7Hx8ShDQsm8fRtNQgLa9HQQi5C4OCNxdsGiShVs3qmPTbNmxYoLzNNeqRTLt97C8q23cB0yBHV0NKm//07KmbPErFxJ9OLFKGrWxPaDD7D94P1XwgksKinnzr0STl9JIvf3x2/TRh736MnjLp9T8VhgqS1TapRv6rCwMG7cuEFkZCTx8fE4Ojri7u5O7dq1iyRnUpoYO3Ys8+fPx97enl9//ZW6Bto2PXjwIGlpaYhEoiI5lv4bN1Apl2VmnVqdVZs0MjKrtFVYGKrQMJSPH5OwZw+auDgARAoFiqpVczTILGvWQOrp+cqtDlrVqYP/jwGEj59A8MBBOPXqhcvAAYgKGXNZEDWKUCVF+fgx0cuW4dC5M9b1DfOm7KtH8LhOpSL10iWSjhwl5exZdEolVnXr4vH9NGybNTMpx7SsIHFwQOLgQEHqhRFnzlD5hx+MYtOLSF1dsf/kE+w/+QRtaiop57JEdGNWrCB60SIUb2Q7gR8ic3crERsNQVHu6WdJOXeOsO9GYf3ee6+E01fc8SoOVrVq4b3gB0K/+ZYHn7ajwuFDBnkpMjQGi/F78uQJq1atYv/+/fz77795nle5cmU+++wzvvzyS/wMoIdWkkycOJGZM2fmbO8Wxulbvnw5y5cvp169emzdujXn90+ePOHs2bN07NgRxQtxG/v376dfv37ExcXRvXt3vcQgs+MLvvjiCwYPHkyjRo0K/wEBdVwcmffukfnvf2QEBZFx629UYeEASD08sKpTJ+tP3Tqv1Bu7TqMhbstWYtaswaJiRTynf4+FAFsD6enpOUk4hUGrVBLctx+a1FTK7dhusJifggKudTodGbdvk3TkKMnHj6OJj8eiUiXsWrfCtkULZAKKU5spOvrOL2OgSUkl9dxZkn/9ldSLv6NTq7Gs/TZ2LVpi+37zUh/zWZwxTzl3nrBRo7Bu1Aiv2bPKvNMHpjFH437cRuTMmUicnYvt/JWJ5I779+8zZswYDhw4kKPt5eDgQLVq1XB2dsbOzo7ExERiY2P5559/crYnJRJJTvFiQ2QHGpuDBw/y6adZ2T916tShevXquZ7n4uLCD8+8YU+dOpVp06bRpEkTTp8+nfP7P/74g1q1amFjY0OtWrXw9vYmPT2d27dv54hBN2vWjIMHD2KjRx3M7EnXqlUrnJ2dqVatWrGFeNVxcWQ8LZWVdv06mf/+CzodMm/vLCewXj2sG7wrmIacKZNx5w7hkyajCgnBZcgQHLt+Xqwt8RUrVuiVPR05ezaJBw7it2ljluSHgZgxYwYTJ0586ffKkFCSA38h6egvKB8/Rurigm3Llti1aoWiinBZxa86kZGRglR6yW9+BQUFsX//fhISEnBwcKBdu3Z5PtcMhSYlhZRTp3IyjEViMVYN3sWuRUtsmjQulVne+t7T2eQ4fQ0bZjl9Au0qmDpFHS+hyXH+nJyocORwkZ2/Up/cMXbsWJYsWUJmZiZvvvkmvXv35sMPP+T111/P9XydTkdQUBC//vorW7ZsYe/evRw+fJgRI0Ywe/ZsIU0zOnFPt0ABrl27xrVr13I9z9/f/znHLy98fX0ZM2YMV69e5d69e9y4cQOlUomLiwtt2rThiy++oEuXLoiLGRP1zz//cP78eb1X/p5F6uSUIzYLWfFFaTduknbtGmnXrpF44ABIJFi+8QbWjRpi06gR8ooVy+S2sKJqVfwDtmZtVy1ZQlJgIO7jxmFZw/BfmElHj5KwZy/u48cb1Ol7EeWTJySfOEnyyZNk3rmTFbfXrBluo0dhVbfuKy3dYQguXLhAQEAAWq02p7bz8ePH6dGjh2A1pDdt2vRcUfnIyEjmzp1Ls2bN6NOnjyB9FAaJjQ32bdti37Yt6pgYkk+cJCkwkPAJExBZWmLTtAl2LT/Gun69Mr36lXL+wivp9JkSTt27gURM5PfTedCqNeX27UVeSna1BF3xE4vFtG7dmmnTphXJc71+/TqTJ08mMDDQ6JUAXlVeXPEDcHZ2ZtGiRQbrUxURQeqFC6ScP0/alavoMjKQenpg07AR1o0aYVW3TpmUIUi/FUTk7Nlk3r2LQ8eOuAwdgkTPRJzCvu2m//UXwYOHYPv++3hMm2pwp3rG9OkM9vQk+eRvZP7771Nx5UbYfPD+K6e3Z0wiIyOZMmUKKpUKlUqV83uZTIZMJmPatGl6rfzlNr+CgoKYO3dunteMGTPG6Ct/L6IMCSH52DGSfglE+fAhEnt7bD/8ENuWLbB8802TThLSdwUr5fwFwr77DusGDfCaM/uVc/pMZcUvm/hdu4iY9j0ihQL/zZv1rmxV6rd6L1y4IMgbplDtmCmY3Bw/hULB2rVrjdK/NjOT9OvXSTl3ntTz51GFhSFSKLCqVxebxk2wea+R0cqhGQOdWk3C7t3ErFyFyNISl0EDsf/kE0FXJzIfPORJ/35YVKiIz/JlBnGitUol6TduknrhAsm//oo6OhqRlSU27zXG9oP3sW7QoEw676bGvn37CAwMJCMjA4lEgkQiQaPRoNFoUCgUtGzZMteaz/owc+bMfOV6qlSpwoQJE4rVh1DodDoy//2P5GOBJB07jjoiAqmHB3YtWmDbogUWlV8r1TsLr7rTZ6oknzlD6FdfodPq8Jw6BYeOHQt9banf6hXKWTM7fSWLtbW10foSW1hg3aAB1g0aoBs9CuXDR6SeP0fK2XNEzppFpFaLokYNbBo3xqZJ41K/JSySSnHs2hWb5u8TvWwpkbNmE7dtG67DhmHTrFmBny0wMJCWLfMufK8KDyfkq6+QurrivWihoM6XKiyM1EuXSb1wgdQrl9GlpSN1c8Py7bfZ72DPl8OHm509IxMbG4s2u4qGRJIT6qHRaNBqtcTGxurVXm7zK+HZsmy5UNBxYyISiVBUqYyiSmVchg0j/Y8/ST4WSML+n4nbsgV5hQrYtWyBbYuWyH28S9pcoOB7OpuUC2anDwo/XsbEtkkTyu3Zw+MePQmfNJmUCxfxWvBDsUOvDIWgjt+ePXto164d0ldYz620otPpyF78vXr1ap5bN0FBQQazQSQSYVGhPBYVyuPUsyfq+HhSL1wk5ewZYjdtImblSmReXtg0aYx148ZY1apVauN4ZO5ueM2YQUb37kQvX07YqNEoatbE5ctBWNWvn6cDeP/+/TzbzHz4kJChwxBJpfgsXab3NvKz6HQ6VKFhpN+4npOko46IALEYyzfewLlPX6wbNcTitawVlLgZZbNKgKnj7Oz8nLP37N9isThnFb+w5Da/HBwciIyMzPMaBxOVsxCJxVi9XQurt2vhNnIkqZevkBT4C7GbNhOzclXWC2Wzptg0aZJTuaQkyO+ezib51CnCx43HusG7r7TTB4Ubr5JAUbkyr536jSd9+5H8yy/cu3oVn2VLTUbL9VkE9dA6d+6Mq6sr3bt3p0+fPiWqt2OmaCQlJRH/tOxTSSN1dMS+TWvs27T+/5bwmbMkn/yN+B07EdvYYN2wITaNG2PdsEGxHJ2SQlG1Kr7Ll5N6+Qoxy5YRMnQYFlWr4tSzJ7bvNy90BnDK2bOET5qM1MMd3+XLkbq66mWHJjGRjH/+yZLkCbpNxu3bqKOjQSTCokoVbJs3x6pObSxr1XolsrFLCw0bNuT48ePIZDJUKlWO0yeTyRCLxYLsnmSrLeR33NQRyeXYvNcIm/caoU1Pz3qOHD9O7Lr1xCxbjszf7+muQhMs33jDpBKQEg8cIGLGTGybN8dz+vevtNNn6oitrCi3cwex69YTtXQpj7/ohk3jxnjOnmWQSk5FRdAYP1dXV2JjY3NWK+rWrUu/fv34/PPPi1RNwozhKa6OX0mQXaw+5cxZUs6eJfPOHZBKsapVC5smjbFp3PhpBZLShU6nI+3yFeK2biXt8mVk3t44ftEVu1atcpytv//+m5o1/x88rElMJHr5ChL37cOmSRM8pk3N1wHWpqWhfPSIzAcPUT54gPLRQzLv3UcVGgpkVWZRvP46itdfx/LNNwrt6B09epRWrVoVcwTMFIXcsnrFYnGRsnpfnF/ZvJjVm42xs3qFRpuRQdqVK1nPknPn0MTGIrazw6puHazr18eqfn1k3t4GDS/Ja8x1Ol1WGcglS3Ho2AG30aNNyiEtKfIaL1NDHR1N8LBhZPz1N0gk2DZtiut3I7F4ofxkqU/uUKvVHDx4kA0bNnD8+HE0Gg0ikQhLS0s6duxI3759ady4sVDdmRGAkph0QqOKiCDl3DlSz54l7eo1dCoV8koVsX73Xazr18fyrbdKXVZpxj//ELc1gOTffkMkFmPzfnMcPvuMOHd3vD09ybhzh+Tjv5L4888AOPXvh22zZmhTUtAkJmWV6IqNQR0RgSoiEnV4OKrIyJxKK5AlsC0vXw6L8hVQVKuK4vXXkfn5FSkD8ubNm4LXny7tCKWtVxiE0tgLDQ3FO4+XpvPnz7N3715SU1OxtramQ4cOpeJFsbDotFoybt0i9fdLpF2+RPqtINBokHl5YlWvPpZvvYmiRg3k/v6CZgnnNubajAwi584l6eAhnAf0x3nQoFId2ywk+c1RUyTt5k3CJ01Cef8BAFJPT6zr1cO2RQssa7/NX/fulW7H71kiIiLYvHkzmzdvzqncIRKJqFixIv369aNnz55lvlxbaaAsOH7Pok1NJfXSJVLOnCXtypWsbFOpFMWbb2Bdrx5W9eujqFat1NQVVsfEkHDgIAk7d6IKDyewxUe0/CUQdDoQibK2fcTiXL8URAoFMnd3pE/rt0o9PJB5eWFRoTzycuUELY2Wl4Dzq4qQq3DG7CsvqQxjfh5TQZOSSvr1a6RevkLa1asoH2R9cYttbFDUqIFlzRooqlVDXqECMi+vIq/GvTjm6X/9RcT0GahCQ3EfPx77Nq0F+TxlBVOTcyksmY8eEb1wEWlXrqB5JiHqtkpFxwf3S29W77N4eHgwduxYxo4dy8WLF9mwYQO7d+/m3r17jB8/nkmTJtGyZUv69etHmzZtkJiXsM0IgNjaGtv338f2/ffR6XQoHz4i7coV0q5cIW5rADGrViOytERR/XUsa76R9fCuWdOk4i8gK4M25cIFUi9eJO3qNbRpach9fLL08Zo3R+bhgczXF7FCgUgqRWxrg8TOHomDPRI7O8R29oitrcyrBCVAZGQkAQEBuWrrBQQEUKlSJcFW/ozRlzH6MIWqIC8isbF+Xog+OTkr/vXW36T/fYuE3XtyvsBFcjlyPz/k5csjL18emZcnUlc3pO5uSF3dCrwXdRoN6X/9RfyOHaT8dgpFtWr4b92CRaVKxvioZoyARbly+CxdAoAqMork306Sefcuij//hAfGTVgxyrJHgwYNaNCgAcuWLWPXrl1s2rSJ8+fPc/jwYY4cOYKrqys9e/Zk3rx5xjDHzCvCs1nCjp93QadWk3H7Nuk3b5L+9y0SDx0kbtMmAGReXihq1sSi8mtYVHoNi0oVkbq7G8Vx0imVZN67R/rft3K+VFTBwTnVTZz7/j+D1n3nTny7djW4TfryYv3oV5kLFy6g1WpRqVTPaetl/3zhwoVia+sZqq/c6i0b+vOYSlWQgpDY2mL9Tn2s36kPZMXgqaOiUD58hPLRQ5QPH5H56CFpN26geVFGRypFYmuL2M4WiZU1yKSIZDJEUhkKG2vuffgh2sQkZN7euE+YgP0nbc3xfHmQX03w0oLM3Q2np89xzxs3YP9+o/Zv1P0uKysr+vTpQ58+fbh//z4bN25k7dq1REVFsWDBArPjZ8agiKRSLN94A8s33gCePrgjI0n/6y8y/r5FRtAtUs+dQ5uWBmStHsr8fJF7eyP18kLm5YXMwxOJoyMSBwekjg6IrApeVdOpVKjj49HEx6OJi8v6snj8BOXjxygfP0YVEoJOpUIklWJRuTLWDRpkyVDUr/9SokZXE3T6AL777ruSNsFkEFpbz5h95Ta/DPl5goKCck0aATh16hT16tUr8ZW/vBCJRMjc3ZG5u+c4g9loMzNRR8egjopEHRWNJikRbXIymqRktGlp6NQqdCoVqNS0trZC2uVzrN+pj6JGDbPDVwCm+gwsTZRIoFNmZiZXrlzhypUrJiMdYubVQyQSZW2Zenhg99FHwP+dwcx798m89x+q4BBUYWFk/PMbqogIeKGUoEgmQySX//+PTAZaDTqlCq1KiU6pQpee/mLHSD3ckfuXw6pePeSdOqGoVhWLKlUQW1jka/OOHTtM8sH3ww8/mJ2/pwitrWfMvnKbX4b8PPsLWOnYv3+/yTp++SG2sEDu410okWhTvadNFfN4FR+jOn7Xrl1j48aN7Ny5k8TERHQ6HRKJhFatWtGvXz9jmmLGTK486wzaNHo+aF2nVqOOjUOTkJC1epeQgCYxEV1mJjqVEp1KhU6pBIkEkUyOSJ7lFIqtrJA6OyNxcsr629GxQAcvL+Keyco1JTIyMkraBJPBGNp6huort/llyM9TmqqCGApTvadNFfN4FR+DO34xMTH8+OOPbNq0iVu3bgFZqyoVKlSgb9++9O7dGy8vL0ObYcZMsRFJpcjc3ZC5u5W0KWZMGHd3d3r06EFAQAASieSlLFghJV2M0Zch+yitVUHMmCnNGMTx02q1/PLLL2zcuJEjR46gUqnQ6XQoFArat29Pv379aNasmSG6NmOmTGOqVRJatzZLTjxLw4YNqVSpklF0/ITsK6/5ZajPUxaqghSXV+EzCol5vIqPoI7fv//+y8aNGwkICCAiIiKn9utbb71Fv3796N69O/b29kJ2aaYUYIpSDaWVuLg4kxQvDQ8PNws4v4C7u7tg2bvG6iu/+WWIz1O9enWaNWuWZ1WQV+E5Yar3tKliHq/iI6jjV61aNSBrK9fBwYEvvviCfv36mb8QXmFKi1RDaeHs2bMmWa7oxo0b5pJtJYhQVUJKYn716dOHevXqvbIvh6Z6T5sq5vEqPoI6fjqdjqZNm9KvXz86dOhg1vZ6xSnNUg1mzJQWcquqcfz48VJVVaN69ermZ4EZM0ZCUMfv3r17VKhQQcgmzZRiyqpUQ0lSsWLFkjYhV1xdXUvahFcSoatqmOr8KiqlIcykrI25oTGPV/ER1PHLz+lLTEzk6tWrREdH4+/vT4MGDYTs2owJYpZqEJ6WLVuWtAm5MmjQoJI24ZVE6Koapjq/ikJpCTMpS2NuDMzjVXzEhu4gOTmZ/v374+bmRosWLejevTvr16/POb5+/Xq8vLy4fPmyoU0xY2QKkmIwSzXoz4oVK0rahFyZMWNGSZvwSpJbVY3suudFqaphqvNLXwoKMwkKCjKyRXlTVsbcWJjHq/gY1PFLT0+nadOmbNy4EUdHRz7++OOcTN9s2rRpQ2RkZIHbgmZKHwWl3ZvT8s2YKR4vVtXQarUGqxJSmihMmIkZM68qBnX8Fi5cyM2bN+natSv379/n8OHDL53j4eFBtWrV8nw7M1N6yZZqyI1XRarBjBlD0rBhQ8RiMTKZDI1Gg1KpRKPRGKRKSGnCHGZixkzeGLRyx65du/Dw8GDDhg35ZvhWrlyZK1euGNIUMyXEqy7VIDR9+/YtaRNyZciQISVtwiuJ0FU1THV+6UtpqghSVsbcWJjHq/gY1PG7f/8+H374YYGyLlZWVsTExBjSFDMliFmqQTiuXLlCkyZNStqMlzh06BC9evUqaTNeSYSsqmGq80tfDF0RRMhs4bIy5sbCPF7Fx6COn0QieU5iIC9CQkKwtrY2pClmzJQJbt26ZZIPveDg4JI2oUCEEjk2RYSqqmGq80tfDFkRROhs4bIy5sbCPF7Fx6COX8WKFfnzzz9Rq9VIpbl3lZKSwl9//cXrr79uSFPMmDHzClMWRI7N6IchwkwMKUpfll9MzJgWBnX8PvnkE2bMmMGMGTOYOnVqrufMmDGDxMREPvvsM0OaYqYAOnbsiKWlZYHnFUUGwfxAE466deuWtAm5UqVKlZI2IU+EFjkuy5jq/CoqQoeZGEKUvm7duly4cIGtW7eiVCrR6XSIRCKOHTtGz549zS8mL1DW5mhJYFDH75tvvmHTpk1Mnz6dP/74g86dOwNZD+J9+/bx008/sXv3bsqVK8eXX35pSFPMlBDmlRZhqVSpUkmbkCu1a9cuaRPyRGiR47KMqc4vU8EQ2cIODg7MmzcPpVL53O/T09PZtGmT+cXkBcxztPgY1PFzcHAgMDCQTz75hIMHD3Lo0CFEIhGBgYEEBgai0+nw9/fn0KFD5hi/EmbLxIm827EjUjs7wdo0r7QIz44dOxg6dGhJm/ES27dvZ+LEiSVtRq7kJnIM/9e901fkuLSj0+nQpqSgSUxEl5mJNj0dVVQUmf/+y47oaHrUrIncywuLypWRmlD2qylgiGzhPXv2vOT0ZaNUKnNelM1kYarPwNKEQR0/gNdff51bt26xefNmjh49yoMHD9Bqtfj6+vLxxx8zcOBArKysDG2GmQKI+n46/82bj9jWFqt36uP27bdYlC9frDbNKy1mTIEXRY6f/bssihzrVCqUT56gDA5GFRKKKiQEZUgwmugY1AnxaBISQa1G9/QPT8cCQNPqYyLGjsv5WSSXI3VzxaJiJazeeQf7Du0FfTksbRgiWzgvpy+bu3fv6t2mGTP5YXDHD0ChUPDll1+at3NNGKtGjZA+eYI6KoqUX0+QcuIkFpUq4fH9NKxq1SpSm+aVFuEpTBxmSZBdJswUadiwIcePH0cmk6FSqXKcvrIgcqzTaMj8918ygoLIuHOXjDv/oLx3H93TFXaRQoHMxxu5tw/yt99GZGFB5p07pN28CVotIgsLdFotVnVqY/l2bawSE7H58ENSzp1DYmuLzM0NVXg4KefOkXLmDFHz5iHz8sK6SROc+/RG7utbwiNgXAyRLfxiNSsz+WOqz8DShFEcPzOmj/u33/Da22+TdvUqYZOnoA4LI/PBAx5/0Q2runXxXrwIqZOTXm2+aistxsBUxUvHjRtX8EklhNAixyWJTqsl899/Sbt2nbRr10i/cQNtaipIpViUL49F1SrYt2mDReXKyH19kbi4IBKJ0Gm1JB44SPSypaBSY/v++6ScPo3M0xOv+fOwqFABgEFP+8m4fZuwMWPRaTRUOHwIsZ0dqWfPkvDTbtJu3CBh+3YSduxA5uuLY9euOPbojjgP5YayhtDZwpUqVeLhw4d5HjflxKmSwFSfgaUJkc78uvFKc+PGDWrXrs3169d5++23AdAkJhI2dhwp165h4e1N5t27iGQy3MaPx+nzLoVuOzIykilTpuQa4yeTyZg2bVqp+tI1Bfbv32+SNY6XLl3K8OHDS9qMfCmt2eU6pZK069dJOX2alNNnUMfEILKwwPKNN7CqUxurOnWwqFYNsYVFrterIiMJnzSJ9Os3sGvTBsfPuxAy/Gvkvr74LFuK+Jn46mfnlyo0lMd9+yJ1ccVv7Zrnzsu4c4eY1WtIOXMGXXo6Irkc60aNcJ80Ebmnp0HHo6yxY8cOTp48meuWr1wuZ+bMmaVinhoLU30GFpXcvoMNjaCvaLVq1WL27Nm0bNmyyG0cPXqUCRMmcPPmTQEtM6MPEnt7fJYtJXzCRFLOnsVt3FhiVqwkcupUko8exXf9OsRyeYHtlKWVFlMhNDS0pE3IlaSkpJI2oUCEEjk2BjqNhrQrV0g8fJjUc+fRpqYi8/LC9qOPsGn8Hoo33sjT0XuWlHPniZgyBZFCge/qVVhUq8aTPn0RW1riteCH55w5eH5+yby98Vm6jCf9+xE5fz6ez0hyKapWxWfxIrRaLUn79xO7cSMpp06RcvoUiho1cB83rsghIq8acXFx9OnThy1btqBSqXLkXGQyGb169SrSc7K0vuQUBlN9BpYmBHX8YmJiaN26NfXq1aNfv3506dIFW1vbAq9LSkpix44dbNiwgevXr+Pj4yOkWWaKgEgqxWP694SO+IbYdevwXb+O2JWrSDl1invN38f/xwAsypUrsB0hy0mZMVPWyXzwgKTDh0k6+gvq6Gjk5cvj2L07Nk2bYPHaa4hEokK1o9PpiNu4kZiVq7Bu/B6eU6YgtrcnfOw41NHR+G3aiNTRscB2FFUq4z56NBFTp2HdsCF2H3743HGxWIxD+/Y4tG9Pxr//Ejl7NmlXrvK46xfIy5fHY9IkrBu8W6SxeJUQ8jlpltAyUxCCbvWmpaUxc+ZMFi5ciFKpxMLCgrp16/Luu+9SrVo1nJ2dsbOzIykpidjYWG7fvs3vv//OtWvXyMzMRC6XM3LkSMaPH2/O9DUSBS0za9PSeDJgINqkJPy3/UjC/v1EzZ0HYjFes2dh36ZNCVj96nLv3j2T1LE6e/YsjRs3LmkzSiU6lYrk06dJ2LmL9D/+QGxvh12Llti3bYNFtWqFdvay0SqVRE6fTtLRX3AeOBDngQMQiUQkBR4jfMIEPGfPwu6jj3K9Nrf5pdPpCB87jtTLlym/+yekrq759q+OiyNy1mySjh0DlQpZuXK4TxiP7Xvv6fU5XhWEvKdfhfAaU30GFpVSv9VrZWXFzJkzGTp0KCtWrGD9+vWcO3eOc+fO5frwyvY5XV1d+fbbbxkyZAheXl5CmmSmmIitrPCeP49H3bsTPnES3osXYfVWLZ7060fYqNGkXbv23BaQGTNmCoc6Pp7En/eTsGcP6shILOvUxnPObGyaNClUKEVuaNPTCR35Hek3b+I5axZ2LbIcPFVUFJFz52LbokWeTl9eiEQi3MeP42GHjkQtWozXrJn5ni91csL7h/m4T55E5IwZJP0SSMiAgcj8/XEfPw5bc51Vg2GW0DJTGMSGaNTLy4uZM2cSEhLCb7/9xsSJE2nVqhW1a9emUqVK1KlTh1atWjFp0iR+++03QkJCmDFjhtnpM1FkXl54zZhB6sWLxG3eguUbNal46jcsKlcmYecuHvfqlSPbYsawHDt2rKRNyJWzZ8+WtAmlBlVkJJHz5/OgdRti16/H+p138N++Hb81a7D78MMiO32alFRChn1F+t9/4bNsaY7Tp9PpiJw1G5FchvvoUfm2kdf8ktjb4zpiBMnHjpF66XKh7JHa2eE9bx6v/X4R+3btUIWFETLoS+61aEnKhQv6fbgyjJD3dG4SWtlSS2VFQstUn4GlCYPm38tkMpo2bUrTpk0N2Y0ZI2DdoAFOfXoTs2YN1g3eRVG1KuV+3kfY8K9JPnGCB61aUW7PHqQ2NiVtqhkzJokqNJTYLVtIOngIkaUlTr164dC5U6Fi7QpCk5BAyLCvUIaE4LtyJZY1a+YcSzlzhtRz5/CaPx9JMSpx2LVuReKBA0TOm0v5nTsRFdJBldrY4DVnNh6TJhIxYyaJhw8T3K8/8goV8Jg6Bet69Ypsk5nnMUtomSkMBlnxM1M2cRkwAItKlQifNBltZiZisRif5ctw6tcX1eMnPPjwI5TmjCuD4u3tXdIm5IrdK1zNoSBUERFEfD+dB5+1J+W3Uzh/OYiKhw/hMmigIE6fOiaGJ4MGoYqIwHfN6uecPm1GBlE//IB1gwbYNGtaYFv5zS+RSIT76FGongSTsH+/3naKra3xmj2L136/iF3btiifPOFJz148aPsJaTdu6N1eWUHIe7phw4aIxWJkMhkajQalUolGoykTYuXZmOozsDRh1vF7xdE3sDTz/n0ed++BQ+fOuH0zIuf38bt2EfH9dERyOX6bN2H15psGtDp3goKCBBNVNWOmuGgSE4ndtImEXT8htrLCqU8fHDq0Ryxg5QF1bCzBAwaiTUvDZ9XKl8osxqxeTdzmLZTb/ZNgVTbCp0wl9eJFKhzYj7gYSXjqhAQipn1P8vHjoNViUaUKnt9/j+UbNQu+2Eye5JbVmy2hVRYcv7JGSSR3mFf8zOiFRcWKOA8aSPyOHWQ8U0PSsUsX/NatA42Gx926k3zipFHt2rRpE3PnzuXu3btERkZy9+5d5s6dy6ZNm4xqh6HZuHFjSZuQK7Nnzy5pE0wGbUYGsZs28+CTT0nYsxenXr0of+AATt27Cer0aRITCRk6DG1qKr7r173k9KnCwojbshWnXj0L7fQVZn65DP4SbUoKcdu2FcnubKQODvgsWshr585i+8EHZP73H4+6dOFhh46kB90uVtulCaHv6YYNGzJt2jRatmxJ/fr1admyJdOmTSszTp+pPgNLE2bHz4zeOHXrhrxcOSJnzUb3TIF36wbvUm7PbsQWFoQMH07c9u1GsScoKCjX2pkAp06dIigoyCh2GIP09PSSNiFXNM/Mg1cVnU5H8smTPOrUiZjVq7Fr1YoKB/bj8uUgJDbWBTegB9rUVEK+Go46OhqfVSuR56J9GrNqFWI7W5x69y50u4WZXzIPDxw6dSJu61bU8fH6mJ0rUicnfJYt5bWzZ7Bp2pSMO3d41LEjDzt3JuPff4vdvqljiHs6W6x8wIABtG/fvtRLuDyLqT4DSxNmx8/A7N69m6ZNm+Lo6Ii1tTVvvvkm8+bNe05jSR+uX79Op06dcHd3R6FQUL58eb766iuioqIEtjxvRDIZHuPHkXHrFok///zcMUXlylQ4ehSJoyOR02cQtXCRwe3ZX0C8UUHHzZgpLhn//kvIl4MJGz0GeYWKlN+1E3r34uCZM6xbt459+/YRGRkpSF/ajAxCvv0W5aNH+KxYnlNn9zl77t4l6ZdAXAYOFHSVMRvnvn0QicTEbdggWJtSZ2d8V62k0m+/Yd2oIRm3gnj4aTsedf2CjPv3BevHjJlXHXOMnwEZMWIES5YsQSqV0rx5c2xsbPjtt99ISEigUaNGHD9+HEs9Hsp79uyha9euqNVq6tatS/ny5bl27RoPHjzA3d2d8+fP6y1sWZz4gojpM0g+cYLye/cgdXF57pg6JYVHHTqievwYu0/a4j1vnl5t68OoUaPy/VJ1d3dn/vz5BuvfmMTFxeHk5FTSZrzEgwcPqJCLA1IQpb20lCYlhZgVK0nYswe5ry+uI7/FpmFDg8VZ6ZRKQkd+R9qNG/iuWI7lW2/lel7w0GGow8Mp99MuRNLCizfoM79iN2wkdu1ayu/bi8wAAffK8HDCJ0wk7dIl0OmwrF0bzxnTC1UxqDRhqve0qVLWxssc41eG2L9/P0uWLMHGxobLly9z7Ngx9u7dy3///UfNmjU5f/48kyZNKnR7YWFh9OrVC7VazZo1a7hy5Qq7du3i33//pXv37kRGRvLFF19gTD/e9athiKRSoha9vKontbGhwpHDKN58g6SDh3jcu7fBtP4cCpCoKOh4aeLevXslbUKuXL9+Xe9rLly4wJQpUwgMDOTy5csEBgYyZcoULpQCjTedTkfSseM87NCBxMOHcB0+nHI7d2DTsCGRkZEEBASgUqnIyMhAqVSSkZGBSqUiICCgyCt/Op2O8O+/J+3qVbwXLMjT6Uu9dJm0S5dwGTZML6cP9Jtfjl90ReLgQMzqNXr1UVjknp74b9xAxWOBWNWrS/r16zxo1YpH3XuQceeOQfosCUz1njZVzONVfMyOn4GYNWsWAGPHjn3Oi3dxcWHlypUALF++nMTExEK1t3jxYtLS0vjggw8YOHBgzu8lEgmrVq3C3t6eq1evcvz4cQE/Rf5IHBxw/eYbkgNzF3UVS6X479iB7QcfkHbpMo8+bYc2I0NwO9q1a1es46WJq1evlrQJuXL3mUSfwmAo58gYKENCCPnqK8LHj8fyjTcpv2cPTj265+javVg9QS6XI5FIUKlUaLXaIju2satXk/xLIB7fT8P6nfq5nqPTaoletgzLN98olHzLi+gzv8SWljj17UtSYCDKJ0/07quwyH198d+yhQpHj2D59tuk37jBw8/a8+DTdqRe/N1g/RoLU72nTRXzeBUfs+NnAEJDQ3Mm5xdffPHS8UaNGuHr60tmZiZHjx4tVJs/P42ly609GxsbPvnkEwD27dtXVLOLhF3rVljWqU3k3LlolcqXjmdr/Tl270bmvXvcb/kx6oQEQW2oXr06zZo1y/VYs2bNzJIuJoihnCNDolMqid2wgUedu6B8+AjvxYvwnj8P2Qtb04aonpB44ACx6zfgOvyrfEuuJR8/TuadO7gOH653jd+iYN/uU6ROTsQaIdPSonx5yv34IxVPnsCmaVMy79/nSd++3PvgAxIOHDR4/2bMlBUEdfzefvttpk2bluuxJ0+eEBcXJ2R3JsvNmzcBcHJyovwLEgvZ1KlT57lz8yM5OTlneTv7uuK0JyQikQj3MWNQhYaSsOunPM/zmDgRt+9Goo6M5P5HLch89EhQO/r06cOYMWOoUqUK7u7uVKlShTFjxtCnTx9B+ylpatSoUdIm5Iqvnhpxpa20VNrNmzz6ohsxa9bi0KUz5ffsxua993I998XqCVqttljVE1IvXSJi5iwcOnbAsWfPPM/TKpXErFiBTZMmeW4DF4S+80tsYYFjr54kHf0FlZHE2+WenviuWslrFy9g37496ugYwseM4W69+kTOmYM2NdUodgiFqd7Tpop5vIqPoI7fH3/8wePHj3M9Vr58eUaNyr9OZFnh4cOHAPj5+eV5TvYXZfa5+fHoGScprzb1aU9oLCpUwKF9e2LXr89X3sG5Xz88581Fm5rKw3afkfbnn4LaUb16dSZMmMD8+fOZMGFCmVzpq2ei5a3atm2r1/lCO0eGQpuWRuTceQQPGIjYxgb/HwNw+/rrfDNlhayekPHvv4SNGo31O+/gNmpUvqt4iXv3ooqIxGXYUL0+47MUZX45tG+PxN6e2E2bi9xvUZDa2eE1ayaVr17BechgRDIZcZu3cLf+Ozzp17/UxAGa6j1tqpjHq/gYbatXp9MZNfGgJElOTgbA2jpv7S6bpzVtk5KSCt1efm3q054hcB6UFXcYW0Cgt0PbtvhtWA9aLY+7dSfp11+NYV6ZwVTFS7PjVgtLaSgtlXrpMo+6dCHx4EHcRn6L34b1KCpXLvA6d3d3evTogUwmQ6FQIJfLUSgUyGQyevToUeisZVVkFKEjvkHm54fXnNn5Jmpo09OJ3bgJuzatc5V3KSxFmV9ihQKnHj1IOnQIVXh4kfsuKmK5HLfhw6l84Tw+q1ZhUbkyqRcv8vCz9tz78CNi163PNQzFVDDVe9pUMY9X8dEv5ctMmaVDhw56Scu8yNChQ+k6YADRS5bg0KkjFvnIyli/8w7l9uzm8RfdCP16BOrx43Hq3q3IfZspfWQ7RwEBAUgkkpckT0pS0kWTkkL0osUk7t+PVZ06+KxajdxHP7mShg0bUqlSpSJL1WhTUwkdMQJEIrwXLSywNFrC7j1okpJw6d9fLzuFwqFjB+I2byZu8xbcx40tERsAbJs1xbZZU5Th4UTNm0/K6dNELVhA1NKlWL1dC5ehQ7E2rxgVmtIut2Qmd8yOnwGwtbUFIDWfWJOUlBSgcMXts9vLbtPe3r5Y7eXG3r17i60hpFMqSdizh6hFi/FZvizfbSlF5cpUOHKEh+3bEzlzJurICNxGjixW/2ZKF8V1jgxByrlzRM6chTY1Fffx47H/rB0icdE2RrKrJ+iLTq0mbOxYVKGh+G3cgMzNLd/ztenpxG3din3btgbR0ysMYisrHLt3J3btWpz69kXmnr/Nhkbu6YnPooVotVqSDh0mbvNm0q5e40nPXkgcHLBu0gTnAf1R6Kl7+iqRmxbl8ePHzTV/ywDmrF4DUO6pwGhwcHCe52QfK1cIMVJ/f/+cfz/JQzZBn/YMhUgux3XE16RdukTqhYsFni9zd6PS8WPI/PyIXbee0FGjjWBl6Wbo0KLHbxmSiRMnFuk6UyktpY6PJ2ziREJHfIPFa69RbvdPOHRoX2Snr6jodDoi584j9cpVvObNy3flPJuEn35Cm5yMc7++xe6/OPPLoXNnRJaWxP8YUGw7hEIsFuPw6SdU+Hkfr128kFW+Tiol6cABHrZpy7/vNiB01OgSLQ1nive0KcstmeJ4lTbMjp8BqFWrFpCVuZhXssW1a9cACrXKZmdnl1ORI/u64rRnSGyaNMGqTh2iFy5EV4iydGJr66dCz2+SdOgQj3v1MpjQc1kgMDCwpE3IlTVrDCPiawyST5zgUecupF64iMf30/BeugSZh0eJ2BK3ZQuJ+/bhMXFCnlp9z6JNTSVuy1bsPv0EmadnsfsvzvyS2Fjj2LkTCT/vRyOwZJMQSB0ccB87hsrnz1HxWCD2nTplOYGHD/Pwk0+zkkIGDSLx8GG0arXR7DLEPR0ZGcm+ffuKXC7QlOWWTPUZWJoQfKs3MDCQ5s2b631MJBJx8uRJoc0pEXx8fKhbty5Xr15l+/btTJgw4bnj58+fJzg4GAsLC1q1alWoNj/77DPmz5/P9u3bX5IoSUlJ4dChQwBF2loSEpFIhOu33/K4WzcSfv4Zx86dC7xGLJVSftdOQoZ/TfLx4zz85FPK/7SrwLimV5H7JlqzNDo6uqRN0Bt1bCyRc+eScvI3bJo1w33smJdKDxqTpMBjxCxbjvOAAdgXMks6ftdPaNPScO5b/NU+KP78cvj8c+J+3Eb8T7txGTig0NcZO5ZM7u+P1/TvAVAGBxO7YQMpZ8+Reu48qWfOwpixyHx8sG7UCPtP2qKoWTMnC11ohL6nhdiizU1uCf6fgV+Sckum+gwsTQju+EVERBAREaH3MWOIjRqT8ePH89lnnzFnzhw+/vjjnJW42NhYhgwZAsCwYcOei9f7+eefGTduHN7e3i85wSNGjGDFihWcOHGCdevWMWBA1kNVo9EwZMgQEhISqFu3Lh/lI+5qLBRVKmPXqhWx69Zj36ZNoR04n6VLiJg1m/iAAO63/Jjy+39GWoZqMpYVcvuSLk3odDqSf/mFyB9+QCQS4zl7FrYffliiz6C0mzeJmDoVu1atcjLkC0KTkkrcjwHYt2tXYiuULyJ1dMT+k09I2LkTpx7d85W9yaakY8nkvr54Tp0KZMn3JBw4QHJgIBlBt0nYto2EbdtAKkXm4Y7i9erYNH4Pm48+QlrEeGpD8uwWreqZHReZTEZAQACVKlUqlEP9otzSs3+bktySmaIhqOM3ZcoUIZsr1bRr147hw4ezdOlS3nnnHd5//32sra05efIkCQkJNGzYkOnTpz93TWJiInfv3iUjl7JmXl5ebN68ma5duzJw4EA2bNhAuXLluHr1Kg8ePMDd3Z3t27ebjAPtMmQwyb/+SlzAj7gU8osMwGP8OGQe7kTN/4H7LVpS7qddWOQhgl0SBAUFsX//fhISEnBwcKBdu3ZG1Qts3Lix0frKjby+pOvWrVuidhUWVWQUkbNnk3ruHLYtWuA26jukjo4lapPy0SNCR47E8s038Zg0sdD3cMKunejS0nHq01swW4SYX07du5Gwdy+JBw7i+HmXfM8VylERCrGVFU5du+LUtSsAmQ8fknTkCKmXr6C8d4/kX38l+fhxmDgJkUKB1MUZmZ8/iipVsKpbB8u330aqZ21wIe/pF7doJRIJGo0m5+cLFy4UaleoYcOGHD9+HJlMhkqlynH6TEFuqaSfgWUBs+NnQJYsWULDhg1ZsWIFFy9eRKVSUbFiRcaOHcs333yD/Gltz8LSqVMnKlSowKxZszh37hw3b97E09OToUOHMmnSJJNKs5d5eODQuTNxPwbg0LEDUj3eEJ379kXq5kbYmLE8/LQd3gsXYvvB+wa0tnBs2rSJU6dO5fwcGRnJ3LlzadasmdEqhDiV4Apofl/St27dIjIy0qTm4LPodDqSDh0iasFCRAoLvH6Yj20eZf6MiTo+npDhXyN1csZr/rycer8FoUlJIe7Hbdh/9tlLJeOKgxDzS+btje2HH2Td+x3aI5LJ8jxXKEfFUFiUL4/rsGG4Dsv6WZuWRvLp06SePUfmvXuowsNJu3KFtIsXidu0KeskiQSxhQViGxskTk5InZ0R29pm/Wxri9jODomDPWJrG8QWcix1OjLt7JA8PV7YOZAbQm3RmrLcUkk+A8sKZjkXA9O5c2c6FyLODaB379707t0733Nq167N3r17BbDM8Dj37UPi/v3Ert+A+xj9Mnbt27RB7ufPkz59CBn+Fc6DB+P21VcGsrRggoKCnnP6nuXUqVPUq1fPKCt/+/fvL7Gstvy+pO3t7Uv8SzovVBERREyfQdqlS9i1aYPbt98gyUUSydhoMzII/eZbtBkZ+K9ehUSPrcP47TvQZWQIutoHws0vp169eNz1C5J//RW7fOKYTTmWLDfEVlbYt2qF/QufSfn4MSm/X0J57z9UIaGoo6NRx8WhCgkh89490GggjwIGga0+puWIb0AiQSSTIfPwQOrpgdzPH0W1aiiqVsGialXECkWB9gm5RWuKcktQss/AsoLZ8TNjMCT29jj16U3MqtU4ftEVuZ71XC3fqEnFX4/zqHNnYlesJOPWLXxWrTJYkHV+7N+/v8DjZaFEXH5B9vl9SWcfNyV0Wi2J+/YRtWQJEls7vJcswaaRacQj6rRawidNJvO///BbtxaZl1ehr9UkJxO/bRsOHdoXqPFXUigqV8a6QQPitmzF9uOP89y+LiuxZHJ/f5yekd3KDa1ajTY+edUTEAAAmfhJREFUHnVMDJr4BNTJSaBUIvn7bxx79SL9xg0y795Fk5qK3NIK5f37JB87hk6lQiSTYfnWW1jVr49No4bIK1XKdUyF3qItqhalGdNG0G/Q5s2bM2/evFyPLV26lBMnTuR6bOjQoaXmBjejH46ff47UyYmYlauKdL3UyYkKgYFYN2xI6pmzPPi4FeoSkIpIKKDPgo4LhSG3OS5cuMCUKVMIDAzk8uXLBAYGMmXKlBzphvzq62q1WpO6h5UhoYQMHkLk7DnYPY0VNRWnDyB68RJSTp/Ga/YsFK+/rte18dt3oFOpcOrVS3C7hJxfTn16k3nvXr6anqWhdJ9QiKVSpK6uKKpVw7rBu9i3aIF927a4li+Px7ixlN/9E+V+2oWiShXSLl/Gsm4dKp0+hf/2bbiO+BqRhQWxGzbw6POuPOrchZh161CGhD7Xh1DlAk0Z81Zv8RF0xe/06dN5CgiPGDGC3r1788EHH7x0LC0tzWhfnGaMi1ihwOXLQUR8P5307t2wLMKqmFgqxW/DeqIWLCB2/Qbuf/Ahfps3YVmjhgEszh0HB4d8tbAc9AzoLipdnwadF4X8VvMKE2Sf32pCVFSUSXxJ69Rq4rdvJ2bNWqROjvisWFEoPTxjEr/rJ+K3bcNt9Ghs9AxU1yQlPV3t64DU1VVw24ozv17EslYtFDVrErd5c55OtynHkhmLZ8dcUbUqvmvXEP/jNqKXLUN57x5ec+agqFIFx88/R6tUknb5CknHAonbupXY1WuwbvAuDp06Yd2wISKJxGS3aIVCyDn6qmIWcDZjcOxat0ZeoQIxS5ehyyPOpTC4jRyJ9+JFaDMzedQlSy/MWLRr165Yx4Vix44dRbquoNW8wgi25rea4OfnV+JfLOlBQTzu0ZPoZctxaP8Z5XbtMjmnL+XsWaJ++AHHbt1w7FK42N9nid+2DZ1Gg1Nv4Vf7oOjzKzdEIhFOvXuRfvMm6X/+med5DRs2ZNq0abRs2ZL69evTsmVLpk2bZhIvEsbgxTEXicU49eyBz7KlpP/xJ8FDh6FJSgJALJdj814jvGbMoNKvv+IxdQqahERCv/mWh+0+I2HPHrSZmSZTEccQCDlHX1XMMX5mDI5IKsX1q2GEfvMtab//jnWDBkVuy65FC+SVKvGkZy8iZ8wg9eJFvJcuQSw17FSuXr06zZo1yzXBo1mzZoLH9+UlGxMXF5fr+cVdzStskH1eqwnr1q0T9PPrgzY1legVK0n46ScsqlTBf8tmvbdPjUHG7duEjRuPTdOmuI74Wu/rNYmJxG/fgUOnjnplyetDXvOrqNg0boy8fHnitmzBe+HCPM97lWPJ8hpz63fewXfNaoKHDSNkyFB81655ThNVrFBg37Yt9m3bkh4URPyP24icM5eYdetw6tETh04dEVtYGOtjGA2h52hJkf2Mv3v3rtH7Njt+ZoyC9XvvYfnWW0QvXYbVO+8UqwaqomJFKp36jeCBA0n57Tfuf/gR/tu3IRegZFV+9OnTh3r16hlcxy8/2ZjcKEgAtzCSGfoE2ZvSl3Ty6dNEzZuPJjER1xEjcPy8CyIDvwQUBVVYGCFP6wB7Tv++SPM/7scf0Wm1OPXsaQALDYNILMapV08ipk4j88EDLCpUKGmTShWK11/Hd+VKggcMJPS7UfgsXpSr3Itl9epYzp6F8stBxG3ZQvTSpcTv2IHLoIHYtW6NSCIpAevN5MWzz/iSSIozb/WaMQoikQjXr4eT+d9/JP3yS7HbE8vl+G/ejMvXw1FHRvKgRUsSnpatMyTVq1dnwoQJzJ8/nwkTJhhkpS8/2Zg33njjud8Vpph6bqt5kqdfBNmrecUNsm/durUAn77wqMLCCB35HWEjv8OiUiXK7/4Jp+7dTNLp0yQlETL8a8QKBd6LFhZKluNF1PHxxO/ciWOXzgatZmOIkAW7Fi2QursTt2Wr4G2XBQoac0XVqngvXED6jRuET52GLp9a5nJ/fzwmT6b87p+wrFGDiGnf8+iLL0i7cUNgq0sOY4XVGIr8nvHGwuz4mTEalm+8gU2zZsSuXo1WqRSkTdfBg/HbuhWRXE746DEEDx1m1ALrQlOQbMzp06ef+7kwsXn5ZeNmr+YVNxswPDy8yJ9ZH7QZGcSsWcvDjp3IuH0bz9mz8F6yWC85FGOiUyoJHTUKdVwsPsuWFrlKSPyP20AHjj16CGzh8xhiG00kl+PY7QuSAgNR5VGy81WmMGNuVbcunjNnkHz8ONGLFhd4vtzfH6+5c/DbugWxpRXBAwYSNnEi6lJYU/tFSvtWb0HPeGNgdvzMGBWXIUNQRUSSuG+fYG1a16nNa2dOY1n7bVJOnuRe02Zk3LkjWPvGpKDsdvULTu2zq3nw/+1Z0H81rzhB9jcMvKKg0+lI/u0Ujzp1Im7jRhy7dqX83j3YffSRyZQpfBGdTkfE9Blk/PkX3gsWIC9A5y0v1PHxxO/alSWNZODycmfPnjVIuw6ffYbYyor4bcZLyCotFHbMbd9/H7dRo4jfvp3EAwcKdY1l9er4bdyAx+RJpP1+iYftOxC3bRu6UvxybKg5aixMQcFE8H2RwMBAmjdvrtexf/75R2gzzJgoFhXKY9+2DbHrN2Dfti1ia2tB2hVbW1Puxx+J3bSZqAULeNihI85fDirRah9FoSDZmBfFq52dnXMypZ91+iDL8Xh2Na8wkhmmFL+XTebDh0T9sIC0S5ewbtAAnxUrkPv5lbRZBRKzahVJR4/iOXMmVrVqFbmduK1bszJku3cT0DrjIraywrFzJ+J+3IZz//4mUTmlNOLQuROZ9+4ROXsO8vLlsXwh9CM3RGIx9p9+ik3TpsSsWk30osUk/fILnlOnYlGpkhGsLvvoU8O9oGe8MRDc8YuIiCAij+X8/I6Z6lu7GeFxHjiQpF8Cidu2HZeBA4Rtu09vbJo24UnffsSuWEny0V/wXb8Oube3oP0Yinbt2jF37tw8j1d64UFdpUqVPLcOVCoVVapUAQxffsnVAJpymoQEYjduIn7XLmTu7ngvWoj1e++VimdFwt59xG3YiOvXX2PXskWR21HHxZHw024cu32BxAhakRUrVjRY2w5duhAX8CPxP/2EywBh7/vSjD5jLhKJcB/1HcoHDwj9bhT+AVsLXatZYm+P+9gx2LVpQ8TUqTzu3gPnAQNw6tXTJGNj88KQc7Qo6FvDvaBnvDEQ6YojrPYC06ZNK9b1U6ZMEcgSM4Xlxo0b1K5dm+vXr/P2228brd+ohYtI/Plnyh88YJDtK61WS+TMWSTs2AFiMa7Dv8Jl4EDB+zEELz5IssntQbJv3z6OHDnynExLNjKZjNatW5vcCl5BaDMyiN+5k7hNm9FpNTj36oVjjx6lRpoi5dw5Qr8dibzVx9x84w1i4+KK7GhHLVpM4s8/U+HQwTKxShY5Zy7Jv/5KhSOHi5TkYiYLdWwsj3v2QurkhO+G9YhzyfTND21mJrFr1hIXEICiShU8pk3FwsQcqtJAUFBQvk7cmDFjcl35ezGr9+jRo0b9DhbU8TNT+igpx08dH8/DTz7Fvl073EZ+a7B+0m/dImTIENRR0cgrVcRn+XIs8qguY0rktXWwYsWK5wqUr1u3jsuXL6NUKhGLxYhEInQ6HVqtFrlcTv369RlghNWVGTNmMHHixGK1odNoSDpyhJjVa1DHxuLQvj3OA/obNItVaNKDgggeOIi0ShVZo1Cgefp/8ezWemGFidUxMTz4tB1OPXrg8uUgA1uexYvzS2iUIaE8/Owz3EZ9h2Nn/QWsyyJFHfOM27d50rcf9p99hvuY0UXqO/3vW0RMm4YqNBTXr7/GoUtng6yo56czqi+GnqP6MHPmzHx1+KpUqcKECRNyPfasjl9AQIBRv4NLz/qumTKF1NERx549iNuwEccvuiIzkAafZY0aVDx9mogpU0ncu5cHrdvg0KUL7hMnvBQvZ0pUr169UFIxz2bsikSiHI0+KD1F7nU6HannLxC9fBnKe/ex/eADXIYOKRVxfM+iDAkh9OsRiPz9WSeXo1Sr8xTMLsyXXtyWLYikUhy7fWFIs42K3Mcb2w8+ID7gRxzaty9VW4ymhuL113H99hui5s7D8q23sGvxkd5tWNasgf+2H4leupSo+fNJvXwJj8mTBd2FKUhntDRTnBru2c/4GzduEBAQIKxhBWC633xmjErHjh1zJmJ+f4TEqVs3xLa2xKxZI2i7LyIWi/Ga/j3lDx5A5utLwvbt3GvYiORz5wzarzEozUXudTodqZcuE9yvP6EjRiCxt8dvyxa85s4pdU6fOj6ekK+GI7a15Xarj1GJRPlK7BTYXnQ0CXv34fjFF0hsbY3wCYyHU6+eqMLCSD5xsqRNKfU4dOqEbYsWRMyYTubDh0VqQ2xhgfuoUXgvWkjGn3/x+POupF65Ioh9hdEZLc0UVKPdWDXc9cXs+JkpMcRWVjj370/SkaNk3r9v8P4UlSpRKfAX3MaMQZuWRsjAQTz6vCtKI2nQCUHfvn2f+7m4+ntCMWTIkEKf+3+Hrx8hQ4eiU6nwXrIE3zVrsKwh7MuFMdBmZBD67bdok5PxWbaUqPT0AgWzCyJ28+Yc/Ttj8uL8MgSKqlWxql+fuICAYtXuLisUZ8xFIhEeEycgc3MnbMxYtOnpRW7LpnFj/HfsQF6uHCFDhhK9YgW6XGKH9aEwOqP6Yow5WlhMpYa7vpgdPzMA7Nmzh6CgoAL/CI3DZ+2QebgTs3KV4G3nhXOf3lQ6dxabxo1J//NP7n/wIaGjR6PNyDCaDUXlSi5v4qZQ5P5QIaqm6LRakk+f5knfvlkOn1qD99Il+G3dgk2jhqUiW/dFdGo14RMmkvnvf3gvXozcx6dQgtn5oYqMInHfzzh174bExsbgn+FZcptfhsCpZ08y79wh7bJx+jNlijvmYisrvObNRRUaSuSs2cVypmXubvisXIHLkCHEbdnKkwEDiyW6XZiqQfpirDlaGLJruOeGIWq4C4XZ8TNToojkclwGDybl9GnS//67WG1FRkayb98+1q1bx759+/LdRpDa2eG7ZjXlf96HRYUKJB08xL/vNiBq2bLnBJFNjVu3buX6+2z9vQEDBtC+fXujrfRlExwcnOcxrVJJwv79POrYibCR3yESifFZthS/LZuxaVg6HT54KtA8cyYp587hNWd2zmplcbff4zZtQmSpwOHzrsb4GM+R1/wSGqv69bCoWpW4LVuM0p8pI8SYW1SsiMeE8SQdPUriz/uL1ZZIIsG5bx/8NqxHHR3N4y+6kXrpUpHaKu5LUG4Ya44Wlj59+jBmzBiqVKmCu7s7VapUYcyYMblKuZgK5shaMyWObYsWxG3ZSvSyZfiuWVMkR6CoAcSKqlWpcOggib/8QuT0GcSuWEn8lq04DxyAU//+Jp0Aoi9CZtYVBnVsLIn79xP/009oYuOwadIEjymTsXzzTYP1aSx0Oh3RS5aQdPAQntO/x+a993KO6SOY/SKq8HASf/4Z58FfIrERRtzcFBGJRDj16kn4uPFk/PMPimrVStqkUo9dq1ak/fEHUfPno3i9GoqqVYvVnmXNmpTb9iPhkyYRMuwrnAcOxLl/P0R6PBMbNmzI8ePHkclkqFSqHKfP1GOQ9RFkhsIn45kKZsfPTIkjkkhwGTaM0BEjSPv9d6wbNNDr+mcDiIuaRWn/8cfYf/wxcQEBRC9fQfTCRcRu2IjLwAE49uljMg5g3bp1i3SdoTPrsoWidTodGX/9RfxPP5Fy4iRIpdh9/DFO3bshLwUyOoUlbvMW4gN+xG3Ud9i1avXS8aIKZseuW4/Yzg7HLl0MZXq+FHV+FQXb5s2J8fYmbstWvObMNlq/poaQY+42ciQZQbcJGz0G/20/FjsxSOLggPeSJcSu30Ds2rVk/P03ntO/L7SYeHFegvLC0HNUX0Hm0ohZx+8Vp6R0/F5Ep9MR3H8A2vR0/H8M0Outct++fQQGBpKRkYFEIsmRNNFoNCgUClq2bKmXiLFWqyV+w0Zi1q5Fm5yM2MoK+/af4fbtt4itrIry8QQjLi4OJz117SIjI5kyZUqujrFMJmPatGnFXvm799dfOP9zh8QDB8i8exeZry8OnTpi37YtEju7YrUtFEKteCbs+5nImTNxHjBAUH09ZXAwDzt0xPXr4Th1K5nybEWZX8UhfvduoubNp/zP+5D7+BitX1NC6DFXhoTyuFs3rOrUweuH+YKFUqT+/jvhEyYisrTEa95cLPVY4RJyt8GQc7SogszFoSS+g42+jBEXF8eTJ0+M3a0ZE0ckEuEybCiZd++SfPxXva4VOoBYLBbjPKA/r12+hPuE8YhtbIj/cRt3679DyLCvyHz0SK/2hGTHjh16X2OIzDrISmxIOXeesDFj2LF3L1ELFyLz8MBn2VLK79uLU7duJuP0XbhwgSlTphAYGMjly5cJDAxkypQpen/25BMniJw9G4fOnXEeJGwlmNi1a5E6OeHQoYOg7epDUeZXcbBv2xaJgwPxRtYxMyWEHnO5jzee308j5fRpQcfV+t138d++DamzM8H9+pOwd2+hE0mEjEE25BzNq/xlYY+XFozu+I0cOZIKFSoYu1szpQCrWrWwfu89Ylat0ktGwBABxNnXOvXowWtnz+CzcgVyPz+ST57kwcetuNeiJXE/bjPpRJBshHSMdSoVqZcuEzFzFvdbfkzoiBEoHz8BsZiKvxzFe+ECrBs00GvF1tAIpSWWeuky4RMmYvvhh7iN+k7QpJTMBw9I+iUQp759XqlSZmKFAsfPu5B48BDqImR4mskdmyZNcOrVi+hly0m7elWwdmUeHviuX4f9Z58ROWs2EZOnlAo1hMJSHEHm0kSJPJ3Nu8tm8sJlyGBUoaEk6PFmZQwRY9vmzal45PD/2rvv8Ciqr4Hj39mWTe8dQoDQBCwgoEaRooJiQcBCbwJSRFSQJiAqKMWGoCKdUBQQUYQXURFLVEAQCyoCEhKSkN7bbnbn/SMkPwLpW2aT3M/z8GB22sl1mJzcufdcWvzfftzvuYfipCSSXnmFf2/qROzYJ+xWDNrZ2bnWx1iaGJsLC8mNjubSSy9zrk9fLk6eTP6RI3g++ADNtm6h2fZtaHQ6h11azRo9ngV//En89Om4dO1K8MIXrZ7Ypq3+AE1gIJ4K1/2qy/1lKa9Bg0CtJuOjj+x+bUdgqzb3mzQRl5tvJmH2HIx1LJRcUaUElU5H4MznCV70CjmHDhE7chQGO77Fs+U9Wl8LMteW4/xaLgiAvnVrPO7tS9ratTUuRmrPIsZO4eE0efstWp84TuD8eWhDQ8n76ScujhvP6c43EzdxEjnffW+znsC6FC+tbWIsyzKGmBgytm/n4lNPcbZXb+KnPk3+iRN4DhhAs61baP7pHvynTkXfti2SJDF79mxrfYtWZ2mPZ+Hff3NxyhT0rVsTsmwpklZr1fgKT/9Lzldf4TvuCVQ6nVXPXVtKFMdVe3ri9fDDZO7YiTkvz+7XV5qt2lzSaAhevAjJyYmE52diNhhqdXx1wyM8+val2aaNmI0GLgwbTs7hwzb4Lq5ly3u0vhZkri2R+AkOx+/JJzFnZpGx/cMaH2PvIsYqlQqfIUNouX8frX7+Cd9JE1H7+pJ7+DAXx4/n3xtv4r+HB5CyciXFKSlWu25dxphUlxgH+PtT+O+/ZOzYQcKcufx3Xz/ODxxEytsrkE1m/CZNInzHRzT/ZDf+UyaXJXtXWrFihZW+Q+uzpMez8PRp4iZNRhceTuiKFTZ5DZu2ejXaJk3w7NfP6ueuLaXGMHkPHYK5oKBWPf0NhS3bXOPtTcjSJRSdPk3KG2/W+LiaDo9wioig2eYoXLp1I+G56aSseAe5uNhW3w5Q+/Y6deoUixYtYsaMGSxatKjKhQjqa0Hm2hLlXASHow0NxXPgQNI3bcJr4ADUnp41Oq50ALG9aTw8CJg6lYCpUynOzCRzxw5yvjhI0dmzpP79N6krV6Fyc0PXrBkuXbrgfs/d6K+/HlUdFqiPj4+vU4xl5UW++478c+cIKiikpUaNevNmzs6Zizk3FzQa9O3a4d63Dy6dOuNyc2dUNXytkp2dXae47KGutcSKzp7l4sRJ6EJDabLyHZvU1Ss4dYrcb78l6KWFVu9JrIu63l+W0gYF4dGnDxlbt+H9yCNICvd82pOt29y5fXsCnn+epEWL0Ldvj+cD91d7zNXDI0orJZR+HR0dXfasVbu5ErJ0CRlRW0hZuZLCU6cIXrwITR3HVlenNu1Vl9Iso0ePpmvXrrWq41ff2D3xa9u2Ld27d7f3ZYV6xnfsGLI++4z0TZvwnzpV6XBqTOPlhd/48fiNL5nxmffzz2R9vo+Ck79SdO4shadOkb5xI6gkVK5uaIOC0LVoga55OLqWLdG3a4cuPLxOSSGUTL4oTk+nODWV4pQUipOSMV6Mw3AhFkNcHO0TEuDyb+RyaCjqtm3wGTEc5xtuQN+hQ4OcWFCXWmJF/50nbuIkNEFBNFm10uJ6aJVJe/99dOHhePTta5Pz1yc+I0eQvW8f2V8crFFyItSc58P9KfzzD5IWL0YX3gznjh2r3L+i4RHwvx7zq4dHSJKEz4jh6NtfR8LsOVwYOqyk5Mv119vmG6qBU6dOlUv6rvTNN9/QtWvXSpO5+laQubbsnvjNnDmTmTNn2vuyQj2j8fXFZ9hQ0jdH4fXYY2jtvASZtbjecguut9xS9nXR+fPkHPySwj/+oOi//zAmJlJ09ixcOeFJkkCtRtJqS/7odEhOTkiSREcfH87t/RzJyQmViwuSkxNyURHm3FxMebmYs3PKn0ujQRsagi6sGW633442rClOLVrg1KaNVdeBdfRf5mpTULnov/+ImzgRjY8PTd9dVeMe59oqOHmSvB9/IvjVxUiXxxwqrU+fPopd26llS1zvuIP0zZvx6HefQ80MtyV7tLkkSQTMmoUh5gLxzz5Hs82b0AYHV7r/1cMjrvy7quERLp0702xLFImzZhM7bjwBzzyD12OPWm0G/KlTp0hPT2fGjBnV9sTVpDSLPZM7s9lM0Z+nyPv5J4rOnsWUnoEpI4O4xES7xVBKvOoVHJb3sOFk7thJ2pq1BL0wV+lwrMKpeXOcrqr/ZjabMV64QOE//1B09izG2DhM6emYcnOR8/MxFxRgNhQhm2XMhQWYMjMxFxaWlLxRq9EE+OPcth366zui8Q9A4++Pxs8Xjb8/ai+vWiUV9l7WzZ5qMhSg8PRpLk6ajMbfnybvrqrxCgV1kfre+zi1aoX7XXfZ7Br1jc+IEcSNG0dedHS5ZfAEy6l0OkJeX07siJFcnDaNsHXrKx2+YMlSa9qAAJqufp+UFStIXraMgt9/J2jeCzUeNlKZ0te2zs7OFBQUVPvaVunSLMXZ2WR/tpecQ4co+vtvTFlZUDrpr/SXe50Ocy1Kl1mLSPwEh6V2c8Vn7BhS3l7R4Jb8upJKpSpJCJs3r3bfL1etosfkyciyTHFCArk//kjut9+S9/PPFPx1Cu/HHsfjnrtRudZ+PJoly7p99913Dt/rV52CP/7k4lNPoWvSpOT1ro16+gDyjhwl/5dfSlZWcKCerS+++IKIiAjFru98043or+9I+sZNjSbxs2eba7y9CX37LWJHjSZxzhxC33gdqYJhJZYutSZptQQ89xz6jh259NLLXBg5itClS+r8DL/yta2fnx9xcXFl2yp7bevl5VVljU5blGYxJiWTvmE9OV9+hTEhoeTti1qNJjAQtxtvRH/99bjeekvJsJrL7Z5/4gR07mz1WKoiEj/BoXkNGkTGtu2kvvc+IUteUzochyFJEtrQULwfeQTvRx7BcPEimR99RPrGjWTu3InvuHF4DRpY494+a6x3XJ/lnzjBxaefRt+qNaEr3rbqa/CrybJM6jvvoO/YEbcePWx2nfpIkiR8Ro4k4bnpFPz2G8433KB0SA2OU4sWhCxdwsWpT5Py1lsETJ9e4X51XW/6Sh733INTRAQJM57nwvARBM6fh8fdd9c65rq8tu3fv3+Vy69ZqzSLOS+P1PffJ2vv5xQnJYEso3J3x61XLzz7P4Rbz551HrNtK47zq6YgVEDl5ITfhPHkfPUVhX/9pXQ4igsNDa3wc12TJgQ89xzNP9mN6x23k7xsGbFjxpaMH6wBS4scezjI0mx1kffzz1x8airO7TuU9PTZMOkDyP36awr//hv/p6ZYdfUPa6js/rInt+7d0YWHk75ps9Kh2IUSbe56yy0EzJhOxvYPyfiw8rJZ1lhqzalFC5pt3oRrZCSJs2ZzadHiWq/2ceVr2aKioiq3l7J1aZa8X44TM3wEp7vdQtqatZjz83Hv25fwHTtoc+woTVetxOPuux0u6QPR4yfUAx733Uf65ihSVq6i6burlA5HUdX9lqoNCiJ4wQK8HnqIS68s4sLQYfiMHo3v2DFVlgup7Sy+q02tRzOvr5S1bx+XXnoZ11tuIWTJazaf1SwXF5Py7ru43nYrLnZ+vVMTjlCgVlKp8BkxnEsvvUzRuXM4tWypdEg2pVSbez/yCMb4eJKXLUfl7m7TOpIqV1eCX12MS7duJC9fTsGvvxK8aBH6Nq1rdPyVr22Tk5Mr3F4Ra5dmMefnk/r+ajJ378aUmgoqFfp27fCbOBH3u3rX6ZxKED1+gsOTNBr8Jk0i/8gR8o4cVTocRa1fv75G+znfeCPNtm3FZ/Qo0tavJ3b8+JIxJ5WwdFm3V199tYbfgWOQZZm0DRu5NH8BHvfdS+jyZXYpZZP12V6MF2LxmzLF5teqi5reX7bmce+9aIKCSNuwQelQbE7JNvd/+mk8H3qISwtfsvnKG5Ik4fVwf5pFRSFpNMSOGkXGhx/VaAnXK5PjkJCQKrdfrX379sydO5dly5Yxd+7cOiV9eb8c58KIkZzu2o20Dz5ANhrwGvw4rX6MpvnHu+pV0gci8RPqCbeePdB36EDqO+806rWeC2q4jB2UzOLze/JJwtauoTglhZjBQ8j+8ssK97V0vePSJLE+kE0mkpcuI3XlSnzHPUHQ/Pl2KZ5sLiwk7YMPcO/TB32bNja/Xl3U5v6yJUmnw2f4cHK+OIjh4kWlw7EpJdtckiQC587BvWcPEmfPIe/nIza5zpVr/u47+Sv6pUvwHPAwycuWEf/ssxRnZFR5/JWvbdVXjVu21Yoa5vx8kt94k39vv4PYYcPI/+UX9G3a0GTlStocOULwggVo6unavSLxE+oFSZLwf2oKhX//Te6hQ0qHU684X3894du343rLLZWOsbHnesdKMhcWkjBrNpm7dhE4Zw5+Tz5pt3F2mTt2UJyRgd/EJ+1yvfrOs/9DqL28SN+4SelQGjRJrSbo5Zdxuflm4p95htwfqh7PW1sVrfn74uLFnL3tNkLffIPC334n5rHHq+1xHD16NDNnzkSn0xEYGEibNm2YOXNmpStw1FXezz8TM2z4/3r3DPW7d68ikmzF7pPNmzcTERHBbbfdds227Ozssh8mV9u+fTvHjh3jjTfesFYoQg2dOHGCzp07c/z4cTp16qR0ONWKmzKF4oREwnd8VGEZgoYuPT0dHx+fOh0ryzJZn+wheflydGFhhLz26jXlFWpSx6+iffLy8mjRokVdvy27MF66RPxz0zHExBDy6mLc7Fh+xpSTw38PPoRHnz4EznLcAvaW3F+2kLZxI2nvvU/zzz6tt0Xcq+MobW42GEicNZu86GiCX30V914VT4yojaSkJBYsWFBhtQCtVsvChQvxkSSSFr9K3vff435vXwKnT6+yfqYt2qs4M5OUd1aSs38/poyMsrF7vk9OqNMs5NpQ4mewVRM/lUrFqFGjKhyzoFarGTVqFOvWrbtm2+jRo9m8eXO9el3UUJTedM2bN8e5BgU2q1rg2h4K//mHC0OHETjvBbwcYCC6vR09epSuXbtadI7Cf/8lYdYsilNSCJr7Ah59a75yQEW1/lQqFTfccAMTJ060KC5byj9xgoTnZ6Jy1hOy/PUaDyq3lpSVq8jYvp0Wez5B4+9v12vXhjXuL2sy5ebx3/3343l/v0rLjtR3jtTmstFI4rz55Bw6RND8+Xjeb9mEj927d3PgwAEKCwvLrflrMpnQ6/X07duXAQMGIMsy2fv3k7xsOZJOR+DsWbhXMiPXWu1lLiwkY9s2sj7ZQ9G5c2A2o/b1xfOBB/CdNBGNnSoVKJH42e1VryzLjXpslmAd+rZtcb/nHtJWf1DrkgANwbFjxyw+h751a8KjonDr3p3EuXNrXF7hylp/hYWFGAwGCgsLMRqNJCUlVVksVSmyLJOxYwdxEyfh1LIlYZs32z3pMyYnk7F9O95DBjt00gfWub+sSe3mivfjj5P5yR6K09OVDscmHKnNJa2W4FdexvP+flxasICUd99FLl1tog4qqhZQOkbvymoBkiTh2a8fzXfuKFnvd/oM4qfPqHBCmiXtVZydTdqGjfz38MOc7nwzyUuXYYiNxaVbV8K2bKF19A8Ezpppt6RPKY3vXZlQoV27dtWLV70AfhOf5Pwjj5K5Yyc+I4YrHU69pHJ1JfiVV3C5uQvJy5ZR+McfhCx5DV2zZpUec3Wtv9Lf3ktf4URHR1e7JJo9mQsKSFq6lOzP9uL1+GMETJtml0kcV0tftw7JSYfPyJF2v3ZD4P34Y6Rv2ULGtu34T5msdDgNnqTREDhvHrpmzUh5ZyXGC7EELXyxTrPea7vmr8bfn9A33iDni4OkvPUW5wc9gs/oUfiMGIHKyanW1zebzeT/9BNZn+wh/+hRilNSQJaRdFqcb7oR76FDce/TpyzGxkIkfkK9owsLw6v/Q6Rt2IDnw/1Ru7srHZLddOjQwWrnKi2voG9/HQmzZhEzbFiVr36rqvVXVFRUba2/ithqbeDCf/4hYc4cipOSCXpxAZ4PPGDxOevCEBtL5id78J8yxeaFoa3BmveXtai9vPAaNJDMHTvwGTmiwf17d8Q2L11BRds0jMR587gwciQhixbhVMul5eqy5q8kSXj07YPbHbeTunYtaWvXkb33cwKmP4frHXdU2l7m/Hzyjh+n4PgJCv/8k6J//6U4LQ1MJpAk1D4+uPfujcdDD+LWu3ejS/auJBI/oV7yGTuWrM/3kR4Vhf+kSUqHYze2GAtU+ur30uLFJM6dS/6J4wQ8++w1v+FX9dt7RkZGtbX+rmbJ2sCVkc1mMrZuI3XlSnQRETTbElWjNZBtJfW999H4+eH16COKxVAbjjLW7Go+Q4eS+dEOMj/6CN8nnlA6HKty1DYHcO/VE13TDSS88AIXho/A/+mn8Xrs0RrPhLdkzV+VqysBTz+N54MPkrxsOfHPPIsmOJggT0/Or3gH2WDAlJeHOTcXubAA2VhcsjYugEqFxs8X11tuwfWWW/Ac8DCaWj6fGrLGm/LaUHJyMps3b2bIkCG0atUKvV6Pi4sLbdu2ZerUqcTExNTpvOHh4UiSVOmfW265xbrfiAPTBgTg/fjjZGzdRnFqqtLh2I2tir2WvvoNfOEFsj/fR+zoMRSdP19un6pq/QUFBdUqWatqvGBUVFSdxgsak5K4+NRUUt56C6/HHydsw3pFk76CP0+Rc/AgvuPH2aU4tDU4SgHnq2n8/fF86CEytm3HnJ+vdDhW5ahtXsqpVSuabdpUVncvbsIECk//W+PjIyMjWbhwIX379qVbt2707duXhQsX1vh5ofHxwfmmG5GcnDDExLA/KBBDTAzGpCRkoxFNgD/ON96Ex4MPEjh3Ds0/+5Q2f/5Bq+++I2zdWnzHPSGSvquIHj8bePbZZ9m6dSsqlYoOHTrw4IMPkpeXx7Fjx3jnnXdYv349n3zyCXfXcZr4wIEDcavgtVHLBr600dV8Ro4g8+OPSVu7zqFLZNQXV776TZw1mwtDhuI7YTw+w4aVjPup4rd3lUpVq1e0VY0XVKvVtRovKBcXk/HRR6S+/z5qF1earFqJq8K/BMmyTMobb+DUqpVir5kbGp+RI8j85BMyd3+Cz7ChSofTqKj0egJnzMDtju4kL1vGhWHD8OzfH78J49H4+VV7fOmav7VhuHCBjI92kPXppyDLeD74ID6jR6HbtYs2r79e129FwAaJ39mzZ9m8ueLFtSvbdraGC8nXFz4+PixcuJCxY8eWW4A7NzeXcePG8eGHH/L4449z9uxZvL29a33+5cuXE35V/bXGSO3hgc+okaS+9z7ew4aia9JE6ZAaBH3r1jTbtpXU998nddW75Hz1FUHz56Nv3ZrIyEgiIiKuGZe3Zs2aWl3D0rWBSxX88SdJixdTdOYMXo8+it+kiQ4xli73668p+O03mqxahXTVSgNC3WiDg/G4ty8ZUVF4PTKoToP9Bcu43tKN8A+3k7lrF6mrPyB7717c+/TBe/Dj6Nu2tfj8ppwccg8dIuvTzyj47TfUnp74DB+O12OPoqnDz0qhYlav41eXKviyLCNJUqOo45efn09QUBA5OTlERUUxbNiwGh8bHh7OhQsXOH/+vNUSv/pWwPlq5sJCzvd/GOfOnQhZtEjpcBqcgj9PcemllzBcuID3Y4/hO+4Jqwyur2l9r8oUp6SQuvoDsvbswaltG4LmzEF/3XUWx2UNZoOBmEGPoAsPp8mKt5UOp0ExxMRwftAjBM6aidegQUqH06iZsrPJ2rOHjI92UHzpEk5t2+LWvTuut0eib9cOqQaTJ8xFRRjOnSP/l+PkRv9Awa8nwWzGpVs3PB94ALeePRp8gq/Ez2Cr9viFhYXZbfmj+srFxYU2bdrwyy+/EBcXp3Q49Z5Kr8d33DiSFi+mcMQIh10D1VoOHDhA37597XY95w7tCd8SRXpUFGkbNpL9+ef4TpiA14CHy5VGWb16NRMmTKjxeesy2w+gOCODjK3byNi+HUmnI2D6dLweGeRQvWqZO3ZivHSJ0LfeVDqUWrP3/VVbuvBw3O+6i/RNm/B86KFqy/PYata4NTl6m1dG7eGBz4gReA8ZQu6335Lz9SEytm8n7YMPkJyd0TVrhq55ONqAACSdE5JOh2w0YsrIwJSRjiE2jqL//oPiYiQnJ1y6dCFgxnTcunevcpWW+tpejsSqiV9dJy00JkajsaydgoOD63SODRs2kJ6eTnFxMSEhIdx55510t+PyU47G88EHSN+yhdRV7zb4HpZz587Z/ZqSTofv2LF4PPAAqe+9R/KyZaRv3ozPiBF4PvQgKr2elJSUWp2ztrP9jPHxZGzfTuYnewDwHjoEn+HDHa60hykzk7S1a/F6+GGcHHwJu4oocX/Vls/o0VwYMoTsA1/g+cD9le5ni1njtlAf2rwqkkaDe+/euPfujWw0UvD77xT+9TeG8+cxxJyn8I8/kY1G5KIiUKvR+Pig9vFBf911eA54GH2763BqFVHjnr363l6OQEzusLN169aRmpqKs7Mz9957b53O8dJLL13zWZcuXdi2bRsRtayz1BBIWi1+E58kcfYc8k+cwKUevrKuD7QBAQQvWIDP0KGkbdhA8vLlpK1Zg9fAAf8ro1ALlY0XLE36zEVF5EX/SNaePeT9+CMqd/eSHobHHq1yLU8lpa5ZAyYTvhPGKx1Kg6Vv0xq3O+8kbf16PO7tW+Ga3VfOGr96jdioqCgiIiIcruevIZC0Wlw6d8alc2elQxGqIMq52NEff/zBjBkzAJg3b16tHzz9+vVj27ZtnD17loKCAs6fP8/mzZsJCwvj2LFj9OjRg+TkZFuE7vDc77oLp7ZtSXnnnQa9NKAj9Ow6RUQQsmgRzT/5BPe77iJj23aanz1H7JgxpG/bRtF/52v8/6B0tt+4ceMYMGAAvjod2Qe+IHH+As7d04eEGTMoTk8jaN4LtPy//fhNGO+wSZ/hwgUyd32Mz9gxaKy8iLy9OML9VRO+48dhjI0l+4svKtx+9axxnU6HWq3GaDRiNpuJjo62c8SVqy9t7ihEe1lO9Phd5fnnn+ezzz6r9XFr167l9ttvr3T7xYsXeeCBB8jNzeXBBx9k1qxZtb7GqlWryn0dHh5OeHg4/fr1o3PnzsTExLB48WLeeuutWp974MCBODs71/q4UpMnT2byZOWWU5JUKvyfmsLFyVPI++473O68U7FYbMnHgRIKXZNQAmfNxH/qU6Ts2IHqt99IXfEOKa+/gcbPD3379ji1boWuWTPUvr5ofHyQdDoktRpzQQHm3FyMyckY4xMw/HeOwlN/YbhwAShJLr0HD8b9nntwaqFcLb7aSHl7BRp/P7wHD1Y6lDpzpPurKvq2bUt6/dauw6NPn2t6/aw1a9we6kubOwrRXpYTid9VEhISOH36dK2Py83NrXTbpUuX6N27NxcuXKBPnz7s2LHDqpNgfHx8mDZtGtOmTWPv3r11Svw+/vjjejmr90ou3brh0qULKavexfX22x1qwL+17NmzR9EEuyIqFxcOXbzIC2++ibmggIKTJ8k/dozCf06T+fFuTOnpVR/v4YEuLAyXbt3wGTMGly5d0AYG2Cl668g/fpzcb78leNGiej0L0RHvr8r4jh/HhaHDSsb63d+v/LZarhGrpPrU5o5AtJflROJ3lS1btrBlyxarnS85OZlevXrx77//ctddd7Fnzx6cbPCDoV27dkBJz2JjJUkSflOmEDtyJNn/d+CaHwaC7amcnXG99VZcb7217DNzfj7FqamYMjKQi4uRi02oXJxRubqi8fND7eGhYMSWk81mkt94E32HDrj3uUfpcBqN//X6rcWjb/lev7rOGheExkCM8bOhlJQUevXqxd9//03v3r357LPP0Nto6abSVxfuDjbL0d6cO7THrVcvUt9/D7PBoHQ4Vueorzmquq9VLi7owsJwvuEGXDp3xrVbV5w7dsSpRYt6n/QBZO//P4r++YeAZ5+p9+WsHPX+qozv+HEY4+LIPlB+rF/prHGtVoter0en06HX69FqtdWuEWtv9a3NlSbay3JWLeAs/E9qaio9e/bkzz//pHfv3uzdu9eiMXTVeeihh/jss8+499572b9/f42Pq+8FnCtS9N95Yh57jIBnn6nX460Ex2fOz+f8gIE433A9IUuWKB1OoxT/3HSKzp2j+a6d14z1qw91/ITGTYmfwaLHzwbS09Pp3bs3f/75J3fddVetkr7evXvTtm1bPvnkk3Kff/rppxw/fvya/XNycpg2bVrZhJRnn33W8m+gnnNq0RzPB+4nbe06zHl5SodjVdu3b1c6hAotX75c6RAUkbZuPabsbPynTVM6FKtw1PurKr7jnqiw1w+unTXuiElffWxzJYn2spwY42cDTzzxBL///juSJOHj48PEiRMr3K9///7079+/3Gfnzp3jwoULZGVllfv8m2++4e233yYsLIyOHTvi5eVFQkICJ0+eJCMjA41Gw/Lly7nrrrts9W3VK77jx5P9fwdI37IVvwZUUy29mokSSiksLFQ6BLszxMaSsXUrPqNHo61jMXZH46j3V1X0bdvi1qNHhWP96oP62OZKEu1lufr1L6SeKL0xZVlmx44dle4XHh5+TeJXmf79+5Obm8uJEyf45ZdfSE9PR6fTERYWxmOPPcakSZPo2LGjNcJvELRBQXg9+ijpW6LwevQRscC3YHXJb7yJ2s8Xn5EjlA6l0fMd90SlM3wFQShPJH42cPjw4TofW9mydz169KBHjx51Pm9j5Dt6FFmffEL6unUETJ+udDhWUdNfFOytX7/G9cM294do8r7/npClS1DZaMKWEhz1/qpOuV6/PvdUu4avI6mvba4U0V6WE2P8hAZL7eWFz4jhZO76GGNCgtLhWIWjvuZITExUOoRqJSUlsXv3btasWcPu3btJSkqq03nMBgPJr7+OS5cuuPXqZeUoleWo91dN+I4fjzEujqzP9ykdSq3U5zZXgmgvy4nET2jQvIcMQeXuTurqD5QOxSq+++47pUOo0IkTJ5QOoUrR0dEsWLCAAwcOcOTIEQ4cOMCCBQvqtHRX5vbtGOPjCZj+XL0v33I1R72/akLfpjXuffqQtmYN5qIipcOpsfrc5koQ7WU58apXAGDQoEE1mnl86tQpO0RjPSoXF3yfeILkZcvwGT4Mp4gIpUMS7CwpKYmoqCiMRiNGo7Hsc61WS1RUFBERETWe7WlMTiZ17Vq8Hhkk7iUH5PfkBM4PeoTMXbvwGTpU6XAEwSGJHj+hwfN6uD/a4GBSrlrruD5q2bKl0iFUyN/fX+kQKhUdHY3ZbMZoNKJWq9HpdKjVaoxGI2azuVa9filvvY3KSY/fhAk2jFg5jnp/1ZQuLAzPBx8kff2GelPKqb63ub2J9rKc6PETANi1a1eDKeB8NUmnw2/yZBLnziX/+HFcOndWOqQ669u3r9IhVGiCAydCaWlpmM1mANRqdbk1XM1mc9mqN9XJ+/kIOV98QdDChQ1ixZGKOOr9VRu+454ge98+0rduw2/8OKXDqVZDaHN7Eu1lOdHjJzQK7vfcjf6660h58y3ky0lAfbTKQXstX3nlFaVDqJSvr+81yV7p2q0qlQpfX99qz2EuKiJpyRKcO3fCo999No1XSY56f9WGNjAQr0ceISMqClNmptLhVKshtLk9ifaynEj8hEZBUqnwf2YahX//Tc7Bg0qHI9hRZGQkKpUKrVaLyWTCYDBgMpnQarWoVCoiIyOrPUf65s0YExIInDWrwU3oaIh8Ro9CRiZt40alQxEEhyMSP6HRcOnUCbc77yRl5cp6NetPsExgYCDDhw9Hq9Wi1+vR6XTo9Xq0Wi3Dhw+vdmKH4eJF0tdvwGfoUJxatLBT1IIlNN7e+AwbTuaOnRiTkpUORxAciiTLsqx0EIJylFggWkmGmBjOP/oY/lMm4zOi9isuKL3oe0FBQY3Xfban9PR0fHx8lA6jSnX5fyfLMvFTp1J0/jzNd+5E5YBtb02Oen/VhSk3j/MPPojbXb0JmjNH6XAq1ZDa3B4aWnsp8TNY9PgJjYouPByvgQNJW7e+1uN/rFkLrq6OHj1qt2vVxt69e5UOoVqBgYEMGDCAcePGMWDAgBol7LmHDpH3408EzpjR4JM+cNz7qy7Ubq74jB5N1qefYYiLUzqcSjWkNrcH0V6WE4mf0Oj4jh8HZjNpa9fW+Jgra8EVFhZiMBgoLCzEaDQSFRVV51UgauvPP/+0y3VqK86Bf7DWlSk3l+Tlr+Pa/Q7c7rxT6XDswlHvr7ryemQQGh8fUt97X+lQKtXQ2tzWRHtZTiR+QqOj8fbGZ/RoMnbuqnFPgDVrwQn1Q+o7KzHl5hA4c6bSoQh1pNLr8Zv4JDlffEHBHyJhEAQQiZ/QSHkPGYzG15fUlStrtH9FteDUajVArWrBWapLly52uU5ttWnTRukQrKrg5Ekyd+3Cf/IUtEFBSodjN456f1nCo18/nFq1IuXNN3HEIe0Nsc1tSbSX5UTiJzRKKr0ev0mTyPnqawp++63a/a1RC84aIhx0mbDO9bgo9tXMBgOXXn4FfceOeD0ySOlw7MpR7y9LSGo1/tOmUfDbb+QeOqR0ONdoiG1uS6K9LCcSP6HR8rjvXpzatCH5rbeq7QmwRi04a9i+fbtdrlNb27ZtUzoEq0lfvwHjxYsEzXsB6XKvbmPhqPeXpVxv6YZrZCQpK95BNhiUDqechtrmtiLay3Ii8RMaLUmlwv/ppyn8/Q9yv/66yn0trQUn1A9FZ8+SvmEDPqNH4yTWBG1Q/J+eijEhgYxdu5QORRAUJdbqFRo1125dS3oC3lmJW/fuSDpdpftGRkYSERGhaB0/R61fpW4APWOyycSlVxahbdIEnzGjlQ5HEY56f1mDU8uWeD7cn7Q1a/Hs1w+1p6fSIQENu81tQbSX5UQB50ausRVwrkjRuXPEPD6YgGefwXvwYKXDERSSsX07yctfp+naNbjcdJPS4Qg2UJyWxn/9++PV/2ECnntW6XAEQRRwFgQlOLVsiedDD5G6Zg2m7Gylw6nSnj17lA6hQitWrFA6BIsYYmNJWbkKr0cfbdRJn6PeX9ai8fXFd9QoMnfscJiizg29za1NtJflROInCIDfhPHIBiNpa9cpHUqV4uPjlQ6hQtkOnjBXRTaZuPTiQjR+fvhPfUrpcBTlqPeXNXkPHYq6FqWcbK0xtLk1ifaynEj8BAHQ+PvjO3oUmR99hCE2VulwBDvK2P4hBb//TtCCBY1iWbbGTqXX4ze5pJRT/okTSocjCHYnEj9BuMx76FDUfn6kvPW20qFUqk+fPkqHUKHu3bsrHUKdFJ0/T+q77+I9eDAunRrvK95Sjnp/WZvHvfei79CB5KXLkIuLFY2lsbS5tYj2spxI/AThMpVej/9TT5H77bfkiYXAG7yyV7xBgfhNnqR0OIIdSSoVgTOfp+jsWTI/3q10OIJgVyLxE4QruPe5B/31HUl5403kyytzOJIvvvhC6RAq9N133ykdQq1lbNlC4V9/Efzii6j0eqXDcQiOen/Zgv666/B8+GFS33uP4vR0xeJoTG1uDaK9LCcSP0G4giRJBDw3naIzZ8j69DOlwxFspPDff0l97328hw7B+frrlQ5HUIjfpIkgSaSuXKV0KIJgNyLxE4SrOHdoj8d995L63nuYcvOUDqec0NBQpUOokIeHh9Ih1Ji5qIjEefPQNWuG38SJSofjUBz1/rIVjbc3fpMmkvXppxT8eUqRGBpbm1tKtJflRAHnRq60eGTz5s1rVBH91CllHo72ZkxK4vyAgXg/9lijL/HR0CQvX07mx7tpFrUZJ7Hge6Mnm0xcGD4CVBLNNm1qdOszC8oSBZwFwUFoAwPxGTGCjG3bMDpQ3aj169crHUKFXn31VaVDqJG8n38mY/uH+E99SiR9FXDU+8uWJLWawNmzKPrnNJk7d9r9+o2xzS0h2styYq1eAYBdu3Y12iXbKuMzYjhZe/aQsmIFIUuWKB0OAAUFBUqHUCGTA06EuVpxRgaJCxbgcssteD32mNLhOCRHvb9szbljR7weeYSUlatw69EDbVCQ3a7dWNu8rkR7WU70+AlCJVTOzvhNmXy50OuvSocjWECWZZJeWQTGYoJfXICkEo8+oTy/yZNRu7uT9NoSxAgooSETTz9BqILHvfeiv+46kt94HdlsVjocBg8erHQIFRoyZIjSIVQp65M95B4+TOC8F9D4+ysdjsNy1PvLHtRurgQ8P4O8778n9+uvq9w3KSmJ3bt3s2bNGnbv3k1SUlKdr9uY27wuRHtZTiR+glAFSaUiYPpzFP39D9n79isdDmfPnlU6hAodP35c6RAqVXTmDMnLl+M5YADuPXsqHY5Dc9T7y17ce/bErWdPkpYtw5STU+E+0dHRLFiwgAMHDnDkyBEOHDjAggULiI6OrtM1G3ub15ZoL8uJxE8QquF8ww2433MPqStXYs7PVzSWY8eOKXr9ypw+fVrpECpkzs8nYeYsdGFhBDz3rNLhODxHvb/sKWDGDOT8AlLefOuabUlJSURFRWE0GiksLMRgMFBYWIjRaCQqKqpOPX+izWtHtJflROInCDXgP/UpTNnZpG/apHQoQg3JskzSq69hTE4m5LVXxeocQo1oAwPwf+YZsj79lNzvfyi3LTo6GrPZjNFoRK1Wo9PpUKvVGI1GzGZznXv9BMGeROInCDWgDQ7Ge/gw0qO2YExIUCyODh06KHbtqjRt2lTpEK6RvXcv2fv3EzRnNrrwcKXDqRcc9f6yN8+H++N6221ceuVlTJmZZZ+npaVhvjzWV61Wo1KpUF+u+2c2m0lLS6v1tUSb145oL8uJxE8Qash31CjUnp4kV/AKyF66du2q2LWr8sADDygdQjlF586RtGQpng89iMd99ykdTr3hqPeXvUmSRND8echGI0mv/a+Uk6+vL6rLM8JNJhNms7mslJFKpcLX17fW1xJtXjuivSwnEj9BqCGViwv+Tz9N7qFD5P18RJEYHLV46bvvvlun46w5O7KUOT+fhFmz0YaGEvD88xafrzFx1PtLCRp/fwJnziLnyy/JPvAFAJGRkahUKrRaLSaTCYPBgMlkQqvVolKpiIyMrPV1RJvXjmgvy4kCzoJQC+597iFz1y6Sly8nfPs2JK1W6ZDqrejoaKKiojCbzZjNZlQqFQcPHmT48OF1+gEKJeP6Lr30MsbERJpt3iTG9QkW8ehzD7nffkvSkiU433QTgYGBDB8+nKioKNRqddl9q1KpGD58OIGBgUqHLAjVEomfINSCJEkEzJjOhWHDydi5Ex8Hr1/nqK6cHWk0Gss+12q1REVFERERUacfohlRW8j58ktClryGU4sW1gxZaKQCZz5PzOODSZwzh6ar3ycyMpKIiAiio6NJS0vD19eXyMhIkfQJ9YYkixLljZoSC0Q3BEmvvkb2//0fzfd8gsbHR+lw6p3du3dz4MABCgsLUavVqNVqTCYTJpMJvV5P3759GTBgQK3OmXf0KBcnT8Fn+HD8pz5lo8iFxqjg5Elix0/AZ9iwRnVvJSUliQTXxpT4GSzG+AlCHfhNfBI0alJXrrTrdQ8cOGDX69XU6tWra7W/tWdHGi9dInH2HFy6dMFv8qRaHSv8j6PeX0pzvvFG/KdMIX3TJnK//96q53bUNrd2oWprcdT2qk9E4icIdaD28sJv4kSyPv2Mgj9P2e26586ds9u1aiMlJaVW+1tzdqS5qIj46dORnPWELF6EdDmBFGrPUe8vR+A9fBiu3e8gcf4CjImJVjuvLdrc0klTtihUbS3iHrWcSPwEoY68BgzAqXVrkpcudYh1fOsTa82OlGWZpEWLMfx3ntDly1F7edk2cKHRkiSJ4IULUbu5kvD8TMxFRUqHVCFr9NSJQtUNm0j8bESSpCr/PP7443U6r9lsZvXq1XTr1g13d3fc3d3p1q0bH3zwAWK4pn1JajUBM6ZTeOoU2fv22eWa3bt3t8t1aqu2Y1NKZ0dqtVr0ej06nQ69Xo9Wq63V7Mj0DRvJ3rePoPnz0bdtW5fQhSs46v3lKNQeHoQsWULRuXNcmr/AKr/wWbPNrdVTZ4tC1dYi7lHLiVm9NjZy5MgKP+/WrVutz2UymXj00UfZvXs3Li4u9O7dG4CvvvqKCRMm8NVXX/Hhhx+WvUITbM+lUyfc+/Qh5Z2VuPXsidrNzabX83HQiSTBwcG1PsbS2ZE5hw6RumoVvuPG4dG3T62vL1zLUe8vR6K/7jqCX3mFhOefR7tyJf5Tp1p0vtI2t8ZEiqt76konTZV+HR0dXaNJU1cPxbjy77oWqrYWcY9aTiR+NrZx40arneudd95h9+7dhIaG8v3339O8eXMAzp8/z+23387OnTvp3r07U6ZMsdo1her5Pz2V8wMGkvbBGgKefcam19qzZw+TJ0+26TXqYt++fdx00021Pi4wMLDWs3cBCv/+m8R583G/5x58J4yv9fFCxRz1/nI07r164v/sM6S8/gbakBC8Bg2q87n27NnDjTfeaJWalhX11MH/xtHWtKcuMjKSgwcPotVqMRqNZUlfXQtVW3N2sLhHLSe6huoJs9nMkiUlSwctWbKkLOkDaN68edm2V199tewfvmAf2sBAfMeMIeOjjyj677zS4TR4xqRk4p95FqeWLQlaMB9JkpQOSWiEfIYMwevxx0haspTc73+o83lMJpPVJlJYa9KUtYZigOPODm7MROJXT/z0009cunQJJycnBg4ceM32gQMHotPpSEhI4MgRZZYTa8y8hw1FGxhI8uuv23SspaO+5tDbaYUMc34+8c8+C2o1oW+8LlbmsDJHvb8cVcCzz+LWvTsJM2fWeRnH4uJiq02ksOaScpGRkSxcuJC+ffvSrVs3+vbty8KFC2t1DlvMDhb3qOVE4mdjb7zxBpMmTWLy5MksWbKEEydO1Ok8v/76KwDt27ev8Iess7Mz7du3L7evYD8qJycCnnuW/J9/Jvebwza7zuDBg212bktMnz7d5teQjUbin38eQ+wFQt94A42fn82v2dg46v3lqCS1muDFi3Dp3Jn4Z58l7+efa30Od3d3q02ksGZPXen5BgwYwLhx4xgwYIDFYw6tMTtY3KOWE4mfjT333HO89957vPvuu8yaNYvOnTtz77331vo3nfPnS14hhoWFVbpP06ZNy+0r2Jdr9+643nYbya+/jrmgwCbX2L59u03Oa6nly5fb9Pyy2cyll16m4NgvhC5bjr5Na5ter7Fy1PvLkamcnAhZvgyXm28m/ulpZNeywHBOTo7ValqCdXrqrMUWs4PFPWo5kfjZyJAhQ9izZw8xMTEUFBTw77//snLlSnx9fTlw4AB33303hYWFNT5fTk4OAK6urpXu43Z5Rml2drZlwQt1IkkSATOfx5SeTtq69Ta5Rnp6uk3Oa6na3Mt1kbpyJdn79xO0cCGut9R+RrxQM456fzk6lZMToa8vx71vXxLnvkDqmjU1LvWi0Wis9nq2lKU9ddZizULtpcQ9ajkxq/cqzz//PJ999lmtj1u7di2333572ddbt24tt71Vq1a0atWK++67j5tuuok//viD999/n2nTplkaslUMHDgQZ2fnOh8/efJkMdMK0DVpgs+oUaSvX49Hv/twumISjlA36du2kb5pMwHTnxNlWwSHJWm1BL24AG1oKGmrP6Dw1F8ELZiPxtu7yuPUajXDhw8nKioKtVpdNqtXpVLV6fWsI7H27GDBOkTid5WEhAROnz5d6+Nyc3NrtF/z5s0ZPXo0b731Fnv37q1x4ufu7g5AXl5etTF4eHjU6JxX+vjjj+22QHRD5zNqJNn795O8ZClN3nvXqrNO+/fvb7Vz1VVFpRn69etnk2tlH/iClNffwGfkSLzF2B6bc4T7qz6TJAm/8ePQX3cdifPmEfPIowQ8PwP3u++u9DnQv39/QkNDLapp6ahKxxxaM6kV96jlROJ3lS1btrBlyxabXqNdu3YAXLx4scbHhIeHAxAbG1vpPnFxceX2FZShcnIi4PkZxE99mpwvDlq1lyo9PZ3Q0FCrna+2oqOjK6w31qVLlzrV8atKzqFvSJw/H4/778fvKVGb0h6Uvr8aCrfbI2m+cwdJS5aSOHsOmR9+iO/4Cbh063pNAlja5nWtaenoLC3UfjVxj1pOjPFTQOmA1tJevJoo7Y07depUheOpCgoKOHXqVLl9BeW4RUbi1qsXKW++iSm38l7a2vruu++sdq7aqqo0Q1xcnFUXbs/9IZrE2bNx79WLoHkviFp9dqLk/dXQaPz8CF22lCarViIbjFycPJnz/R8m5d13yfvpJ4zJyZgNhkbR5tYcc9gY2svWRI+fnZnNZnbs2AFA165da3zcrbfeSlBQEJcuXeLjjz9m6NCh5bZ//PHHGAwGQkJC6rQcnGB9Ac89y/mBg0hb/T4Bzz2ndDgWq2o5qNLt1uixyPv5CAkzZuAaGUnwyy8hacRjSqi/XG+5BZdu3Sg4fpysvZ+Ttetj0q+Y/GXo2YPTXS8/syUJ6fLf5f6UfQYS0rXbSz8vPYdWi8rVteSPmxsqV1c0Pj5oAvzR+F/+ExiErkkokk5nz+YQHIB4otrA1q1bufnmm2nTpk25z5OTk3n66ac5efIkWq2Wp5566ppjR4wYwdGjR5kyZUq5pddUKhUzZ87kmWeeYebMmdx2223llmybNWsWALNnzxZr9ToIbVAQfuPHkbJyFR73P2CVEiQtW7a0QmR1U9VyUEaj0SoLt+efOEH8c8/hcvPNBL/2KpJWa/E5hZpT8v5qyCRJwuXmm3G5+WZkWcYYG4shNg5TZiYtLsQQeMstJYXfZRlK67/LMlDyWVlR+NLtpfteuf2Kz2WjEXNeHub8fMx5eZhycyj4/SLFKSmYMjL+F5hGgy40FF1ES5zbt0ffoQP6665DZcFEP1sT96jlROJnAzt37mTYsGG0atWK6667DldXV2JjYzl58iS5ubm4uLiwcePGsrF+V4qNjeX06dOkpqZes+2pp57iu+++45NPPqFDhw7cddddAHz11Vfk5+czaNAgJk2aZPPvT6g578GDydr7OclLXqPp2rVINUzKK1vbsm/fvjaOuHJVLdyekpJC586dLTp//olfufj00zhffz0hy5aiEj0Rdqfk/dVYSJKErlkzdM2aAfCQna9vNhgwpaVhjI/HEBND0fnzFJ05Q+qatcgFBUgaDfobrsf11ttwve02nFq3cqihFuIetZxI/Gxg5MiRuLu7c/LkSaKjo8nMzMTZ2ZmIiAh69+7N5MmTy621W1NqtZpdu3axZs0a1q5dy9dffw2UrOYxduxYxo8f71D/QAWQdDoCZ80kbsKTZH/+OZ4PPljtMZVNoBg+fDgnT560admcqhZTr6o0Q0hIiEWlGfJ+/pn456bj3KGDWIpNQatWrRJlmezM3m2u0ulQBQejDQ7G5eabyz6XTSaKzp2j4NeT5P38E2nr1pG6ciW68HDc+/bB49570TVpYrc4KyPuUcuJxM8GHn74YR5++OE6HXv48OEqt6tUKiZMmMCECRPqdH7B/lxuvhn3e/uS8tbbuN5xR5V1va6cQFE6dg5KkquoqCiuu+46m8VZVcJZmgBWVppBpVLVecB2zuHDJM6ajUu3boQseU0kfYKgAEmtRt+6NfrWrfF+7FHMBgP5x46Rc+AL0jdvJu391bjcegvejw/G9bZba/z2QnA8IvETBDsIeOYZzv8QTcrbbxP84ouV7lfVBAq1Wk1+fr5N4qsu4YyIiCAwMLDS0gxr1qyp03WzD3xB4vz5uPfsQfDLL4uB5oLgIFQ6XUl1gshIAgsLyfnqazI+3E7800+jDQvDd+xYPPr2sevkq1OnTpGamsqMGTPw8vKif//+ZWvUCzUnEj9BsAONry/+U6eStGgRnvffX+4Vy5WqmkBhNpvxrmYVgKpU9Rq3uoTzyhm7FdUbq8vY0sxP9pC0aBEe991H0Px5YvauAxgzZozSITQ69aHNVXo9nvf3w6PffRT+8QfpmzZzacEC0tavw2/8eNzvucfmPYAbNmzgm2++QaVSYTabSUpKYsmSJfTs2ZPRo0dXetypU6fYs2cPmZmZIlm8TPTVCoKdePZ/COcbb+TS4sWYi4oq3Ke6tS3NNVz/82rR0dEsWLCAAwcOcOTIEQ4cOMCCBQuIjo4GLF9Mfe/evTWORZZlUld/QNIrr+A1cCBBLy4QSZ+DOHr0qNIhNDr1qc0lScL5+usJfX05zbZuQdesGYlzXyB29BgKLteRtYVTp07xzTffAODp6Vlu2zfffFNWw/ZqGzZsYMmSJZw+fZqkpCROnz7NkiVL2LBhQ7XXW7RoETNmzGDRokWVnr++EomfINiJpFIROHcOxfEJpG/YWOE+kZGRVS7YfuVr2JqqqvByVFQUSUlJFi+mXrpqTHVko5FLCxeS9sEH+E2aRMCsmWKskAP5888/lQ6h0amvba5v25Ymb75J0zVrkA0GYkeM5NJLL2HKzLT6tfbs2VP2325ublVuL3Vlsng1WySL9Yn4NVsQ7MipRQt8Ro0kfcMG3Pvcg9NVs7urW9vy5MmTFZ63qtcZNXmNa4/F1E25eSQ8/zwFx48T/PJLeNx3n8XnFARBWS6dbqJZ1GYyP/mE1FXvkvtDNIGzZuLeq5fVrpFZTTJZ0faKksGrt1/9yre6ZLFr164Vviauy+vk0mNOnz5d5X62IBI/QbAzn9Gjyf7iIEmLX6Xp6vev6fGqam1LbQUFjUvHvpS6euzLla9x4X+19+B/r3EtXUz96mLlVzNeukT8tGcwJibSZOU7uHTpUuX+gjK6iP8vdtcQ2lzSaPB+5BHce/Qg6dXXSJjxPO53303grJmovbwsPr+Xl1fZkpBZWVkVbr+avZLF6p6/FbnyGGsUvq8tkfgJgp2p9HoCZ8/m4qRJZO/di+dD15ZwrWzB9oiIiHJf1+Q3VF9f37LK/1cmfVAy3q70Na4li6lXVbw5//hxEmbOQnJyImz9OpxE5X2HdfX9JdheQ2pzjb8/Ia8vJ+eLgyQtXULMkKEEv/wSLhYWd+/fvz9LliwBqLCyQf/+/a/57MpksSLWSBbr0kNY1TH2IgbXCIICXLt1xeO++0h+622K09NrfNz27dvLfV2T31DbtGlT6dhAo9FYrreuroupb9u27ZrPZFkm48MPiZs4CaeICJptiRJJn4O7+v4SbK+htbkkSXj07UP49u1om4QS9+REUt9fjXzVL5210b59e3r27AlAcHBwuW09e/as8LVqRclgddsrSgar2l6T529NPrM3kfgJgkL8n30GJEh58806n6Mmv6GePn26wlfEUDKG78oxJklJSezevZs1a9awe/fuKn9jroq5sJBL8xeQvGw53o8/TpOV71RZuFoQhIZFGxhI0/few2/CeNLWrePiU1MtmvgxevRoZs6ciU6nIzAwkDZt2jBz5sxKX6demSxezVrJYl1eJ1d3jD2IV72CoBCNtzcB06ZxaeFLePTrh+stt1R7jPNVi6fX5HVGWlpa2VJ+KpUKSZKQZRmz2YwkSWVjTKpbuaMqpaVfAAwxMSTMfQFDTAzBi17BQ6ytWW9cfX8JtteQ21xSq/F94gn0119P4qzZXBg+gpDly9G3aV2n87Vv354jR47UuPbh6NGj6dq1a40nXpQmixW9iq0oWazL6+TqjrEHSS4d/CM0SidOnKBz584cP36cTp06KR1OoyPLMhcnTsJwMY7mO3agcnGp1fGnTp0qG/tSkZkzZ3L69GkOHDhAYWFhuVm9JpMJvV5P3759iYyMZMGCBRWu3KHValm4cGG1r31lWSbr009JXrYcTWAAIa++ir6aSR+CIDQOxsRE4qfPwBATQ9C8eXj07aN0SJWq6Szdmjx/Kxrjd+UxaWlp7N+/364/g8WrXkFQkCRJBL7wAqaMTFJWrqp2/6vHh9TkdUZ1tQEjIyOvKfmi0+lQq9UYjUbMZnNZoefKvP3WWyTOmkXSyyU9fOFbt4qkrx5yhPFHjU1jaXNtcDBh69bi3qsniXPnkvzWW3Ua92eP9mrfvj1z585l2bJlzJ07t9oewopU9jq5qmPsRbzqFQSF6ZqE4jdpIilvvoXHPXfjfOONlS6vFh8ff83x1b3OqEmpluqWiruy5MDVsXV1diE7PZ28o8cIWboE99697dBqgi1UdH8JttWY2lyl1xP00ks4tWtHyptvYbwYT/ArL6PS62t8Dkdrr9q+Tr76GFHHTxAaKe/HHyfn4JdceullEqY+RdSHH1Y41q4y7du3r/JBU12plqtX7rjy7ytX7rhyHKDWYOD2C7GkJifDoIGEb9+GNijIKu0hCELDJEkSPkOGoGvShITZc4gbP4HQN99AU83qQI6suudvVcecOHGCqKgoG0VWMZH4CQAMGjSoRoOMG9qahY5CUqsJmj+P84OHcPq11zCGhl4z1i4qKoqxY8fW+RqV1QYEarRyR9nSbwYDzVJS6B0bh9Zs5lDz5mTl5pIuSdSs+IvgqPr0cdxxVw1VY21zt+7dCVu3lvinp3Fh5EiarFiBU4sW1R7XWNvLmsQYP0FwEE4tW5J0663cdDEe76ysCsfa/fXXXza5dunrYK1Wi16vR6fTodfr0Wq1Za+Do6Oj8czN5YG//+bB/86T7O5O1PUdOenjjVmWqx0HKAiCcCV927aEbdqI2tWN2NFjyP/lF6VDahREj58AwK5du8SsXgdwpl1bmv/4I/fEXGDX9R3hqrF2Fy9etNm1q3odbMrJwe2TPTx28jdytFr2t2lNjK8vZlkGgwEPDw9Flh4SrOuLL75oUCtJ1AeNvc21QUE0XbeOhOef5+KUpwhevKjKdX4be3tZg0j8BMGB+AQEcKhVBIN++50b4+M50bRpubF2V9bLs4WrXwebCwpI37SJ9E2bCc7J5oewMI76eINWi1qWyy0B51uPx+gIgmA7lU1WK6V2c6XJW2+SuOBFEmbOInDWTLwGDlQw4oZNJH6C4EBKx9r9GhxMt/gE/vXwJN1ZXzbWrlmzZnaJw1xYSObu3aRv2Ig5OxvP/g/h+tBD/LZiBarLtf6uHAdoMpmqLfIsOL7Q0FClQ2h0Gnqb17QwvKTTEbzoFdTe3iQtfpXitHR8xz1RVny+VENvL3sQiZ8gOJDSsXbbNm6kZUYGfWNj+eT6jkhqdY1W0LBUcUYGWR9/TMaOnZgyM/G8vx++TzyBNiQEoNKyMH379q3xur6C46puySrB+hpym5dNCKugMHxUVBQRERHlnhuSSkXAjOlofH1Iffc9TBkZBEx/DumKNx0Nub3sRSR+guBgSsfandi+nSbrN/C4pyfXzZhBYGAg69evr/FyRbVRdPYsGTt2kP35PpAkPO/vh/fQoejCwiqM7erXNuvXrxc9fg2Are4voXINuc2vLgxfumpQ6dfR0dHXVBqQJAnfsWNRe/uQ9OqrmDIyCHppISqdDmjY7WUvIvETBAcUGBjIvdOmkWyWcdq5E69J+QAUFBRY7RqmzEyyvzhI1t7PKPr7H9R+vviOHYPngAFovL2rjO3qh7WpDhX4BcdjzftLqJmG3Oa1KQx/Na8BD6P29iJxzlzin55G6PJlqFxdG3R72YtI/ATBgflNmkjeDz9wacECwjast/h8xSkp5H73HbmHvyX/2DFkWcYtMhLfsWNxi4xEuvxbtSAIgqVqWhi+Mu49e6Je+Q7xzzxL7PgJNHlnhW0DbiRE4icIDkyl1xO08EVix4wlfXMUgwcPrtXxptxcCk7+RsGJE+QfO0bhX3+BSoXzTTfi//RU3Pv0QePjY3GcQ4YMsfgcgvJqe38JlmvIbV6TwvDVcencmaZr1nDxqSnEPPY4PTt2JP656aBWIak1oNEgadRIGg2SWoOk1SC5uKJ2c0Xl7oHK1QW1pycqN3fUnh6oPD1RubiUJaSNkUj8BMHBOXfsiM/w4aStXk1qYAC39et3zT7m/HyKU1IwxMZSdPYcRefOYjhzlqJz50CWUfv54nJTJ7weewy32yNRe3lZNcbjx4/TogZV9wXHdvbsWbp27ap0GI1KQ27zmqwTXhNOrSJwvS2SzB07OKvX0+rs2ZINslz34FQSqNRIKlVJ8qjVIGl1SFotkpMOlZMeSa9H5eKMSu+MytUVlZvr5b/dUbu7o/byROXhicbLqySp9PZG5ebm8EmlSPwEoR7wfXICOV9/zZFvviHgjTeRZRnMZuTiYuSCAuTi4pIdJQmVmxtOrVqhv/56vIcOwfmmm9A2aXJNWQRrUmKhccH6jh071mCTEEfV0Nu8unXCqyMXF3Pp5VfI/vxzghYs4FBqCg9O/qxsu9lsBoMBs8EAxcWYi4owZ2VhysnBnJODKScXc04O5vw8zLl5JX/n5WMuKCj574JC5Px8zEVFyEVFyAYD5qxsTMY0ZJOp5NlqNpf8qWmiqVKBSoWkLumJRKMpmZksSSBJJcmmJIFKRWxubl2a1SIi8ROEekCCkgcFlDzgrngASTpdWSKIJGHOz6fwzz8xpaZgvHiRojNncGrduuRP8+ZiHJ8gCHZV1TrhVTEXFpI4Zw650T8SvOgVPPr2hVWryu2jUqlAr0el1//vw+BgS0OuNB5TVjamjHRMmZmYsrIwZWeXJJjZOZhzcy4nl/klfwrykQuLMBcW/i+BlGXk0iTSbAZTsU1irYpI/AShHkhds4bixESuHz6M1suXX7NdlmXMubmY0tMxJl7CGB+PMT4eQ1wcud//QMa27UBJkqjv2AGXTp1xvukmnG+4vvwDs46aNm1q8TkE5XXo0EHpEBod0eYVM+XmEf/sMxSe+ovQN17H7fJ4QCXbS3U5wdQGBljtnDknTkDnzlY7X02IxE8QHFzB77+TvnETfk8+SdP77qtwH0mSSsacuLujq2B1D3NeHkVnz1Jw6hQFx0+QseMj0tasQdLrcb3lFtx63Inr7bdXWcalKg888ECdjhMcS0N+5eioRJtfqzglhYtPT8OYkEDTd1fhfMMNZdtEe1nOsUcgCkIjZ8rNI3HuC+g7tMdn5AjWr69bSReVqyvON9yAz5AhhL6+nIivviL8w+34jR+HKSOdSwtf4tw9fYibNJnsA19gLiys1fnffffdOsWVlJTE7t27WbNmDbt37yYpKalO5xGso673l1B3os3LM1y4QOyYMZgyMghbu6Zc0geivaxB9PgJggNLXraM4swMmrz3XskgYSuRVCqcWrXCqVUrfEaOpDgtjdzD35K9fz+Jc+eicnfHo889eD36KE4tW1rtuleq6RqegiA0DgV/niL+6adRe3vTdM07aIOClA6pQRI9foLgoLK/OEj2558TOHMWuia2XZhc4+uL18ABhK1bS/PdH+M1aBC5h78l5tHHuPjUVPKOHi2ZQGIlV67hWVhYiMFgoLCwEKPRSFRUlOj5E4RGJjc6mrgJE9A1CyNs3VqR9NmQJFvzaS7UOydOnKBz584cP36cTp06KR2OcJnx0iViHh+M6623Erx4kU1LsVRGNhjI/vJLMqK2lMwMbtcWvycn4hp5m8Xx7N69mwMHDlBYWFhuDU+TyYRer6dv3751mgUoCEL9k7X3cy69/DJut0cSvHixVSac1RdK/AwWPX6C4GBkk4nE+fNRuboSOHtWuSTrwIEDdotD0unw7NePZtu30WTVKlTOLsQ//TRxT4wj/9dfy+27evXqWp27ojU81Wo1QLVreAq2Y8/7SyjhyG1u6zG4siyTtmEjl158Ec8HHyRk6dJqkz5Hbq/6QozxEwQHk745ioITv9J09fuoPTzKbTt37pzd45EkCddbuuHSrSv5P/1Eyqp3iXtiHK533EHAc8+ia9qUlJSUWp3T0jU8BdtQ4v5q7By1zW09Blc2mUh+4w0yP/wI3/Hj8R0/rkZvEhy1veoT0eMnCA6k8K+/SH3/fXxGjcLFzrWdqiNJEq633UazqM0EL15M0dkzxDzyKCl1mNEbGRmJSqVCq9ViMpkwGAyYTKZareEpCIJt2HoMrjk/n4QZM8jcsZPA2bPwmzBekeEsjZVI/ATBQZgLCkiY+wL6Vq3wGz+uwn26d+9u56iuJalUePS5h+a7duEzaiQZUVtomZBA3s9HanyO0jU8tVoter0enU6HXq9Hq9XWag1Pwboc4f5qbByxzaOjozGbzRiNRtRqNTqdDrVajdFoxGw2Ex0dXedzG5OSiH1iHHnHjhH65pt4DRpUq+Mdsb3qG/GqV6iVgoICsrOzycvLK3s1J1hH0dmzFD/8MM433sDZCxcq3e/MmTN2jKoavXsjR0bS/Px5zvzzN9rMDHTh4XB5vF4ptVqNq6srHh4eODs7A5av4SlYn4+Pj9IhNDqO2OYVjcGFkuEYlozBLfznH+KnPQNqNWHr1qFv3brW53DE9qpvROInADBo0KCyH8iVuf7665k/f76dImpczAUFmJ2c0La/DrNWi7m44vUbCwoK0Fixnp9VaDQQEIA2JARTTg4FSUmoPT1ROTmV7VJcXExRURHp6emEhITg6ekJ1H0NT8E29uzZw+TJk5UOo1FxxDa3xRjcnMOHSZz7Ak4tWhD6xuto/P3rFJsjtld942A/QQRHFRISwsMPP1zuM4dLQOorsxmzSoXG37/aGW2urq4O2e5ubm7onJzA3R1zURGYTEgmE9Ll5K/4ikQ2ISEBJycn9I2oZIMg1CeRkZEcPHgQrVaL0WgsS/rqMgZXlmUytmwl5e23cevVk+CXXmpU5VockeP9BBEUsWvXriprCCUlJZGeng6Ah4cHQUFBZeU3hLqTzWYMMTGgVqNr3hypmjYtfSXqaC5dukTQ5YKrsixjysigOCkJSa1G26QJslrNpUuXyM7OBiArK0skfg5IvEazP0ds89IxuFFRUajV6rJZvSqVqlZjcM2FhSQtfpXsffvwGTkSvymTkVSWTS1wxPaqb0TiJ9RIXl5e2X+LpM96ipOSkIsM6JqHV5v0AQ6Z9AFlSR+UzP7V+PigcnbGeDEew3/n0YYEExQUVJb4XXk/CY5j8ODBSofQ6Dhqm1s6Btd46RLx06dj+O88wS+/hMd991klLkdtr/pEzOoVaqS0q1+j0Yikz0pMWVmYMjLQBAXW+NWHoxY2vnTp0jWfqZyd0bVojsrNFePFi5hTUsruHTExyDFt375d6RAaHUdu89IxuOPGjWPAgAE1Tvryjx/nwrDhmDIyCVu/zmpJHzh2e9UXIvGzgRdffBFJkqr906JFi1qdNzw8vMrz3XLLLTb6jgRrMxcVYUxMROXpidrLq8bHOWrCVDoD8GqSWo02NBRNUBCmjAzkwkLkSvYVlFc6nEOwH1u0ua1X3KiMLMtkbN9O3KTJOLVsSbMtUejbtrXqNcQ9ajnxqtcGbrzxRkaOHFnp9s8++4yMjAx69uxZp/MPHDgQNze3az5v2bJlnc4n2JdsNmOMj0fSaNAGBTX4wqVlr371evj3X4ozMlBfntUrCIJ12XrFjcqYcnK49NLL5B46hPeQIfg/PRXJASeiCSLxs4n+/fvTv3//CrclJCSwZcsWAMaOHVun8y9fvpzw8PA6Ricorbbj+q7kVYveQXuqSVwqFxdULi5IOTkU/P4H2cnJeNxzj+2DE2qssueWYDvWbPMrV9wwGo1ln2u1WqKiooiIiLBJncyCU6dInDUbU3Y2IcuX4V7HTo2aEPeo5cSrXjvbtGkTJpOJtm3bcttttykdjmBndRnXd6XiSur7Ke3KHzJVkiTUvr5ofH1InD2H1PdXI8uybYMTaky8RrM/a7a5LVfcqIgsy2R8+CFxY8ai9vIifNtWmyZ9IO5RaxCJn51t2LABqHtvn6CcmJiYa8ZVuri4EBISQu/evZk/f36VC4ibCwvrNK7vSrm5udd8dvjw4Wvi0uv1tGjRgnHjxhETEwPUfOxp6Z8XX3wRgFGjRl2zTaPREBQUxEMPPcT3339fq1m6kiTh1Lo1fpMnk7ZmDZfmz0c2GOrUHoJ1fffdd0qH0OiUtrk1xuVVtOJG6YQqS1bcqEhxSgrxU58medlyvB59hLB1a9GGhlrt/JUR96jlxKteO/r+++85c+YMWq2WESNG1Pk8GzZsID09neLiYkJCQrjzzjvF+oV21LJlS4YNGwZAUVERycnJHD16lJdffpnFixfz/PPPs2jRonJj9+TiYoxxcUg6HdrgYJuM6+vcuTP3338/AJmZmRw+fJi1a9fy8ccfc+TIEXr06HHNMSdPnuTTTz/lzjvvvGb71V+PHTuWJk2aACUriPz999/s37+fzz//nHXr1jFq1Khaxes7ZjTa0FAuLViAMTmZ0GXLUHt41OocgtAQWGtcni1W3KhIztdfk7RoMWg0hL71Fm533G6V8wr2IRI/O1q/fj0A999/PwEBAXU+z0svvXTNZ126dGHbtm1ERETU+bxCzURERJT1hl3phx9+YPjw4bz66quo1WpefvlloOR1iDE+HtlsRtesmUUFTJ2uWAbtajfffHO5uGRZZuTIkURFRbFo0SI2btx4TTK3ceNGPv30U3r06FHh93SlJ5544pqZ4zt37uTRRx9l9erVtU78ADz63IMmwJ/4554jdsxYmqx4G21ISK3PI1iHmCBmf8HBwVYbl2fNFTcqYsrNJXnJUrL378etVy8C58xG4+1t0TlrS9yjlhOveu0kJyeHnTt3AnV/zduvXz+2bdvG2bNnKSgo4Pz582zevJmwsDCOHTtGjx49SE5OtmbYQi3cfvvtHDhwACcnJ5YuXUpcXBwAxcnJmPPy+b+TJ7n73nvx9vZGr9fToUMHli9fXmmJlk8//ZTevXuX23/NmjU1LukiSVLZmpbHjh2zzjd5lb59+wIlK3HUlctNN9Fs/Xpkg4ELo0ZT+M8/1gpPqKXS/5+CfVlrXF7pihtarRa9Xo9Op0Ov16PVamu14kZFcr/9lphHHyP38GGCFi4kZOkSuyd9IO5RaxA9fld5/vnn+eyzz2p93Nq1a7n99sq7uz/66CPy8vIICQmp8427atWqcl+Hh4cTHh5Ov3796Ny5MzExMSxevJi33nqr1uceOHAgzs7OlW6fPn06zZo1w8fHhz///POa7QEBARb1YtYnRqORlJQUNBoNbm5uaLXasm1t2rTh0UcfJSoqij179jBpxAhMaWks+OADlr79NqGhoQwYMABPT0++//57ZsyYwZEjR8p+KSg1e/ZsXnvttRrvXx1blYw5ePAgAO3atbPoPLrwcMI2bSR+6tPEjRtPyOvLce3a1RohCrWwatWqsl8WBPv4+++/rxmXByWvaOsyLs/SFTeuVpySQtKyZeR+fQjX224jcM5stMHBdTqXNYh71HIi8btKQkICp0+frvVxFQ26v1Lpa96RI0dafeULHx8fpk2bxrRp09i7d2+dEr+PP/64yrV6z5w5Q3FxMRqNhlatWlkQbf1VOoGhuLi47L+zs7Px9fUtV1exR48eREVFcfTnnxl3990cOvkbS99+mz59+vDxxx/j6uoKlLyKnTRpEu+//z4ff/wxAwcOBODLL7/ktddeq3D/0aNHs2nTpnL7V0aWZd577z0AulohiVq7di0HDhwASsb4nT59mv3799OpUydmzZpl8fk13t40Xf0+8dNnED/1aYIXvYJ7794Wn1cQHNnVyd6Vf9d1XF7pihuWkM1msj75hJQV7yDpdAQvWoR7n3safN3RxkAkflfZsmVLWZ09a/nnn3/46aefABgzZoxVz12qtMfl4sWLNjl/dcyFhRguzx51RLrw8DqVTyllNBrJyMgo+/rKEiRpaWk4OTmV9fyFXB6jlhIfj6TVsfrDkiWGPvjgg7IkDkp64V577TVWr17N9u3byxK5lStXVrr/Cy+8wObNm8vtX+qXX34pG6eXlZXF4cOHOXnyJD4+PsydO7fO33updevWXfOZn58fgwcPtlptMJWLC03eepPEFxeSMHMWgbNn4VVNgisI9ZmLiwsqlcpm4/LqouDkSZKXv07h33/j+dBD+D89VRRdb0BE4mcHpb19d955p80mX5S+DnB3d7fJ+atjiInhwtBhily7Jppt3WLR0kFX9+hKkoQsy2UJYG5uLt6Xx7uUJYWyjLZpE34+cgRXV9ey++Bqzs7O/HPFuLaff/650v1lWb5m/1LHjx/n+PHjAOh0OkJDQxk3bhxz586lWbNmtf+mr/LTTz+VTe4wGAzExMTw9ttvM2PGDH788Ud2795t8TWAkt6FV15G7eVF0uJXKU5Lx3fcE6KnwQ5s9YupULlx48Zx4sQJoqKiUKvVZbN6VSqVxePyasuYmEjKOyvJ+eILnNq1penaNbjcdJPdrl8T4h61nEj8bKy4uJjNmzcDtq3d9+GHHwLWeaVXF7rwcJpttW5PqTXpLFzppKLCyaXJ39XbL15OygJCQ1HpdGWldxYuXFjp+a+sg1fb/UtNmDCB999/v/pvxgp0Oh2tW7dm1apV/Pbbb3zyySdER0dbrXdCUqkImDEdja8Pqe++hykjg4AZ0y2aES1U7+jRo9x5551Kh9GolLa5Ncfl1ZYpO5v0qCgytm5D5e5G0IsL8OjXzyH/vYl71HIi8bOxffv2kZSUhKenJ4MGDap2/969exMfH8+rr77Kww8/XPb5p59+SpMmTejcuXO5/XNycpg3b17ZhJRnn33Wut9ADan0eqsvxu1INBWsOXnl697S7cXp6Rw+fBiArpdXZvHw8ECSJFJTU2t0rar2T05OdrhJNN26dSM6Oppjx45Z9bWUJEn4jh2L2subpNdew5SZSfDCF5F0OqtdQyjvzz//FD9U7ay0za0xLq+2TDk5ZGzbTsbWrcgmE95Dh+A7ejQqFxe7xlEb4h61nEj8bKz0dd3gwYOrnDVb6ty5c1y4cOGa8hjffPMNb7/9NmFhYXTs2BEvLy8SEhI4efIkGRkZaDQali9fzl133WWT76Oxu3LyBvwv6StdycLNzQ1Tbi5/HznCx198gZOTU1ni3q1bN/7v//6PM2fO1GhiTG33V1rp2MfSmYnW5jVwAGpvLxLnzOViTjahy5ahqsG/JUGwlaSkJMV656zBlJNDxvYPydi2DdlgwGvQIHxGjkBjpQLPgmMTiZ8NJSUlsX//fsDycQn9+/cnNzeXEydO8Msvv5Ceno5OpyMsLIzHHnuMSZMm0bFjR2uELVRAq9WWjeGD/5VHkSQJX19f1GYzhz/by5iZz1NUVMSCBQsIvbx80dSpU/m///s/xowZw549e66ZpXfp0iUyMjLKJuhUtb+rq+s1+yspJiambGyfLVePce/VC9XbbxM//TniJk2iyVtvicHmNtClSxelQ3B41lplo5Q929xw4QIZH35E1t69YDLhNXAAPiNHovH3t1sMlhL3qOVE4mdDgYGBNV+8/rKYSmbG9ujRo8IltwT7KZ1hGxcXx6pVq8pKMKSmpHD0xx/58/Rp1Go1L7zwAgsWLCg7rm/fvsybN4+XX36ZiIgI+vbtS7NmzUhLS+Ps2bN8//33vPLKK2WJXFX7nzlzhh9++KHc/vZyZTkXo9FITEwMe/bsIT8/n7Fjx3LzzTfb9Pqu3brS9P33iX9qKrHjx9N05cp69QOrPhAr/1QtKSnJaqtslLJ1m8tmM/lHj5Hx4Yfkff89am9vfIYNw2vQQDR+fja9ti2Ie9RyIvEThFo6f/48y5cvB0pm5Hq5u9O6eXNemDOHUWPGVLik0EsvvUT37t1ZsWIFX3/9NZmZmfj6+tK8eXNefPFFhg4dWqP9mzRpUuH+9nBlORdJkvDy8qJr166MHTuWXr162SUG5/btabp2DRcnTylZ4u29d9FdXj9YsNz27dtFcdwqREdHl1tlQ61WYzKZyr6Ojo6u9Tg9W7W5ISaGrH37yN7/fxRfuoRTq1YELZiPe58+qKpY+tHRiXvUciLxE4QaCg8PLzehQ5ZljBcvYs7LQ9esWbXjzu66665ajcGsaP+KJnf06NGjXFy1MWrUqGrX2N24cSMbN26scp+EhIQ6Xb8unFq0IGz9OuImTSZ27FiarlyJUw3GQtb3cVmC8tLS0qy6yoa1GeLiyP3uO3IOfknhn3+icnfH/Z678ezXD/3114uSSAIgEj/hskGDBlU5+eS5556jWbNmhIWF2TEqxyXLMsWXkjDn5KJt2sRukw1UDlheAWy3JFxltMHBhK1by8UpTxE7bjxN3n4L5xtuqHR/a4/LaqhqMgGtMfP19bX6KhuWtLm5sJDCP/8k94cfyPvuewwXLiDpdLh060bwa6/i1r17ve7dq4i4Ry0nEj9BqANTWhqmjHQ0wcGo7Vg0289Bx+QEK7B2p8bHh6YfrCZ+2jPETZpM6PJluN566zX72WJcVkMliuNWLTIykoMHD1p1lY2atrlsNlN86RKFf/9NwcnfKPj9d4r++Qe5uBi1ry9ut9+O39SncO3a1aHLsVhK3KOWE4mfAMCuXbtqtFavAKasLIqTk1H7+aG5YqavPWRkZJSbXewokpKSFEme1G5uNFn5DgmzZhM/7RmCXnoJjz73lNvHFuOyGqo9e/bQv39/pcNwWIGBgQwfPtwqq2zIsoxcVMSePXu4/9ZbMeXmYs7JxZyXizkvr+TrrCwMF2IxxMRgiI1FLioCQBsSjP766/G47z6cb7wBp1atHLLYsi2Ie9RyIvEThFow5eRgTEhA5eWlyIzS2s4St5fSng8lqPR6Qpct5dJLL5E4dy7m3Jxy6/s6+rgsRxIfH690CA4vMjKy1qtsmPPyyP/lF/JPnqTon9MY4mIxpaQiFxdzoWcPzi9bfs0xkl6P2sMDbVhTnG+4Hs+HHkQXHo6uZUu0DlbE3Z7EPWo5kfgJQg2Z8vIwXoxH5eaONjhYDJR2IJJWS9DChajcPUha/CqmrGx8Ro8qq7No7XFZQuNWk1U2ZKOR3O+/J2vvXvJ/PoJsMKAJCEDfvj0e9/RBExiI2t0NzalTNP1gNSo3N9RubqhcXVG5uiJptXb6boTGRiR+glAD5oICjHFxqFyc0YaGKJb0eXh4KHLd6rjbcZxjZUrX91V7epK6ahWmrCz8pz1tk3FZDVWfPn2UDqHeMxcWkrnrYzKioihOTUXfvj1+UybjdmePCp8d97ZujYuoTVdj4h61nEj8BKEa5qIiDLGxSE5OaJs0aTRjaeojSZLwmzAetacnycuWYc7JJnDOHKuNyxKEypgLCsjcuYv0qChMWVl43t8Pr8cfR9+6tdKhCUI5IvEThCqYDQYMF2KRNBp0TZsiqdWKxpOdnY1er1c0hork5OQ4RK9fKe/HH0Pt6UHighcxZedw66JXaj0uqzH64osvxMoItSTLMjlfHCTlzTcpzszE8/778R0zGu3lJRurI9q8dkR7WU4kfoJQiZKk7wKSSkIXFoakEf9c6hOPe+9F5eZGwsxZxD89jdDXl4vZu4JVFf33H8lLlpL/yy+49epFwLSna5zwCYJSxDsrQahAWdInSWibNXOYgdZaB4njamqFe0Ir43bHHTRZ+Q6Ff/1F3IQnKRYzeKsUKpKWGjEbDKSsWkXM4CEYk5NpsvIdQpctrVPSJ9q8dkR7WU4kfoJwFbPRiPHCBSRKkj6VAyVbjljDD3DoV6YunTrRdM0HGFOSiR01GkNMjNIhOSxRH616hf/8w4Xhw8nYHIXv2LGEf/RhhYXDa0q0ee2I9rKcSPwE4QpmgwHjhQsAaMMdK+kDSE1NVTqECiUmJiodQpX0bdrQbONGJCcnLowZQ8HJk0qH5JDWr1+vdAgOSzYaSV39ARdGjkJSqQnbvBm/8eNQ6XQWnVe0ee2I9rKcSPwE4TJzURGGCxdAlh2up69UaSFiRyPLstIhVEsbHEzY+nU4RUQQN3ESOV99pXRIDqegoEDpEBySMT6e2CfGkbZuHb6jR9Ns00b0bawzW1e0ee2I9rKcSPwEgZLaW2Vj+sLDLf4tvq7OnDnDww8/THBwMCqVCi8vL0XiaKjUHh40WbkSt549SZg1m/StW5UOSXBw2Qe+IGbwEEzpaYStW4vfkxOQFHo+CII1iGmKQqNnLigoqdOn0aJrVvns3ZiYGJo3b17uM41GQ0BAAJGRkTz//PPcfPPNdY7DZDLRv39/zp49y/Dhw2nSpMk1pVt8fHzqfH5bqk+rX6h0OoJfeRltcDApb7xJcWIi/s88o3ipHkcwePBgpUNwGOaCApKWLiX7s72433MPgXPnoHZzs/p1RJvXjmgvy4nET2jUTPn5GGPjkHQ6dGFNa1SypWXLlgwbNgyAvLw8jh8/zs6dO9mzZw9fffUV3bt3r1Ms58+f56+//mLcuHF88MEHFe5TVFSExgHLyuTl5eHk5KR0GDUmqVT4PzUFbXAQSUuWYky8RPDLL6FycVE6NEWdPXuWrl27Kh2G4gpPnyZx9hyMSUkELZiPxwMP2Gy1HtHmtSPay3KO9xNEEOzElJ2NMT4eycUFXZMmNe7xiYiI4MUXXyz32Wuvvcbs2bOZN28e3377bZ3iSUhIACAkJKTSffLy8nB1da3T+W2psLBQ6RDqxGvQIDSBQSTMmU3s2CcIfeN1tMHBSoelmGPHjjWoH6pJSUm1KtotyzKZH31Eyltvo2vRgvCtW9CFh9s0xobW5rYm2styYoyf4FCSkpLYvXs3a9asYffu3SQlJdnkOsXp6RgvXkTl7m6VFTnGjh0LwPHjx8t9bjAYeOONN+jUqROurq64u7tzxx138Nlnn5XbLzw8nDvvvBOAhQsXIkkSkiRdk2AK1ud2x+0027ABc24OF0aMpOC335QOSbCC6OhoFixYwIEDBzhy5AgHDhxgwYIFREdHV7h/cUYG8dOeIXnZcrwGDSRs4wabJ32CoATR4yc4jOjoaKKiojCbzWXrqR48eJDhw4cTGRlZ7fFGo5Hc3FyKi4vRaDS4ubldU/BYlmWKU1Iwpaai9vFBExho1Vc4V76GLSoqom/fvhw+fJgbb7yRsWPHYjQa2bdvHw899BDvvPMOU6ZMAWDatGmcPHmSTZs2ceedd9KjRw+Asr9LOTs7Wy1Wa9LV88HuThERhG3eTMKM54mb8CSBc+fi+cD9Sodldx06dFA6BKtISkoiKioKo9GI0Wgs+1yr1RIVFUVERES5nr+8o0e5NG8+cnExoW+9idsdd9gt1obS5vYi2styIvETHEJtH9RXy83NJS0trVxZkezsbHx9fXG7PCBbNpsxJiZizspCExCI2tfHaknf2rVrAbj99tvLPnvppZc4fPgw8+bNK+vFg5J1bXv16sVzzz3HgAEDCAkJYdq0aRw+fJhNmzbRo0ePSnv6HPE1L9AgZh9rvL1p+u4qkl5bwqUXX6To9D/4P/20w6zaYg8N5RVadHQ0ZrMZo9GIWq1GrVZjMpnKvo6OjmbAgAEltfneX036pk243HwzQS8tRBsQYNdYG0qb24toL8uJV72CQ7j6Qa3T6VCr1RiNRsxmc6WvZ6Ckp6806bv6T1paGkajEbm4GMOFC5izs9GGhqLx861z0nf27FlefPFFXnzxRWbMmEGvXr2YM2cOgYGBLFu2DCipt/fee+/RsmXLckkfgLu7O/Pnz8dgMLB79+5aXdtRCzgnJycrHYJVSDodgfNeIOD558nYuYu4iZModtA2t4WGUhw3LS2trOalWq1GpVKVLStoNptJS0vDcPEisWOfIH3LFvymTKbJu6vsnvRBw2lzexHtZTnR4yc4hIoe1FBS4qT0QV2Z3NzcskQPQJKkcl/nZWSgz8oCWUbXLByVi2WvS8+dO8fChQvLfRYUFMT3339PREQEAKdPnyYjI4OQkJBr9gVISUkB4J9//rEoFsH6JEnC+7FH0bdpTcLMWVwYOoyQpUtwvuEGpUMTasjX17fcM+TKv1UqFeHxCVwYPAS1tzdh69bh3KG9YrEKgr2JxE9wCNU9qKuqE1dcXFz236U9a6XJn1NxMbrUVCS9Hm3TplZZjaNPnz4cOHAAKEngNm3axMyZM3nwwQc5evQobm5upKenA3Dq1ClOnTpV6bny8vIsjkewDecbb6TZligSZs0mbvwE/J99Fq9HH7FZWQ/BeiIjIzl48CBarRaj0Vj2LHFRqeh15ixNfjmO6333EjhrNmo3xxw+IQi2Il71Cg4hMjISlUqFVqvFZDJhMBgwmUxotVpUKlWVkzuunFBRNsZPlnEzGPAsLMLspEcXHm6TJdj8/f2ZPn06c+bM4e+//+aFF14AwMPDA4CBAwdW+Aq69M+GDRtqdb0ABV5F1URVJWjqM42/P03ffw+vRwaRvHQpCTOex5SdrXRYNjN58mSlQ7CKwMBAhg8fjlarRa/Xo9PpCDMWM+SPP2mfn0/Iyy8R8sorDpH0NZQ2txfRXpYTiZ8AwKBBg2jfvn2lf77//vuyOnO2UNGDWq/Xo9VqGT58eJUTO9zc3MrKnwBIZjNehYW4GovJc9Lh1LQJksq2t/qcOXMICQnh3XffJSYmhnbt2uHh4cEvv/xSbrKKpbKysqx2LmsqfXXdEElaLQHTpxOyfBn5x48TM3gIBSdPKh2WTZT2ZDcEkZGRLFy4kL53381AJB7/5x+CIyJotWsnnv36KR1emYbU5vYg2styIvETHEbZg7pvX7p160bfvn1ZuHBhtaVctFotvr4lkzV0ZjO+BYVozDKZznqcg4PR2qHUiLOzMzNnzsRoNPLyyy+j0WiYOHEiFy5cYPr06RUmf3/++WetJ0UUFRVZK2SrsmZy66jce/YkfPs2tIGBxI6fQNq69ciXXyFWxF41Ka3p3LlzSodgVV65uXTa8yktfv+doAnjiYjajK5pU6XDKqehtbmtifaynBjjJwCwa9cuOnXqVOn2M2fOlBtLZyuBgYEMGDCg1se5urqizcvDnJqGSauh2McHf0/Pa+r42dL48eNZsmQJmzdvZs6cOSxcuJATJ06wYsUK9u3bR/fu3QkICCA+Pp4//viD3377jZ9++slhX98K19IGBdH0g9WkrVlD6nvvkffTTwS9+CK6JqHl9rO0JqVgGdlkImPrNlLfew9tSAhhG9bj3F5M4BAEED1+QgNgNhgwXLiAnJaOxt8P14gIvPz87Jr0Aej1embPnk1xcTELFy7EycmJ//u//2P16tUEBQXx8ccf89Zbb/Hdd98RHBzMe++9R8eOHWt1DTcbLBJvDY5aX9AWJI0Gv4kTafrBaoqTkoh5/HEyP/64bHzplTUpCwsLMRgMFBYWYjQaiYqKcuiev7quM+1IDLGxxI2fQMqKFXg9+ijNtm5x6KSvIbS5PYn2spzo8RPqLVmWMWdnY0xMBLUabbNmqF1dbHa98PDwcgWiKzJlypSy1TigpDTN+PHjGT9+fLXn79GjR7Xnv3IiiyOxd5LtCFw6dSL8w+0kv/02SYtfJefQNwTNn1fj4sGOyMfHR+kQ6kw2GEiPiiJt7bqSSTkffIBLp5uUDqta9bnNlSDay3Kix0+ol2SjEePFeIzx8ajc3XFq0cKmSZ+jyMzMVDqECjlqXLamcnUlaM4cmryzAsO5c8Q88iiab74pG/tXWfFgR7Vnzx6lQ6iT/F9/JWbIUFJXf4D34MGE7/ioXiR9UH/bXCmivSznmN0HglAJWZYxZWZSnJQMKgltkyaoL5dOEQSluN52G+E7PiJlxTu02LmTQXo9B5s2If1ywlfTmpRC7Ziys0l5ewVZe/ag79CBZlui0LdurXRYguDQROIn1Btmg4HixETMeXmovLzQBgQgOeirT1sp7TlyNCobl8upD9QeHgS9MJfiW28lZdYshv39D8cDA/gpOBiTWl2jmpRKqy+v0WSTiaxPPyP1vfeQi4oImDUTrwEDkBz030dV6kubOwrRXpZrXD81hXpJNpkoTk3DlJ6GpNGgDQtD7aCTHGzNVEX5ECWJFUj+p0nvXlxYvoyjS5dyc2wc7dIzONKsGf8GBVZbk1JppSvO2FtSUhLR0dGkpaXh6+tLZGRkpe2U9/MRUt58k6KzZ3G/ty/+U6cqssautSjV5vWVaC/LicRPcFiyLGPKyqI4ORlMZtS+fmj8fG1ejNmR5efnKx1ChXR2qJVYn0TeeScRbdtyZN8+PPbt556zZ3lApyPUyUnp0Kr022+/2f2aNS19U/TfeVLeeou86Gicb7yRsM2bHHq2bk0p0eb1mWgvy4nET3BIprw8ipOTkQsKUHl4oAkIQCWSC/Gqtx4JDAzkwTFjYMwYCn77jeTX3yBuwpO43XknfhOfxKlVK6VDvIa9ywVdWfrmyiLgWq2WqKgoIiIi8JFl0tavJ2vPp2gDAwlZ8hpuvXs3mDWTHbVEk6MS7WU5kfgJNmc0GsnNzaW4uBiNRoObm1ul5T/M+fkUp6RgzstD0usvl2hpPDXihIbJ+YYbCNu4gZyDX5K6ahUxjw/G/a678B0/DqeWLZUOTzFVlb7xKC7mzNwXCPjzT1QuLvhPmYLX44+JXwAFwUIi8RNsKjc3l7S0tHL16bKzs/H19S33m5s5P5/i1FTMublITk5omzZFdXkNXuF/HHUsXVZWFqGhodXv2IhJKhUeffvg3rsXWfv2kb5uHTGPPY773XfjO2a0Q/QAHj161K7XS0tLw2w2A/8rfeNZWMj1cRfpkJaGytkZ34kT8X7sUVQN9BdAe7d5fSfay3Ii8RNqRK1WU1xcTHFxMSaTqUavHI1GY1nSd3Vh4rS0NJx0OlSFhRSnpyPn5yPpdGhDQ1F5eIiErxKO+kq1JgWcTSZT2bJ/jvrK2h4krRav/v3xvO8+sj7fR9r6dcQ8PhiXrl3xHjIE18jbFBvHau/XaL6+vmX3tH9WFjdfSqJlejr5Gg2/NG1K4Ijh3DR4sF1jsjfx6rJ2RHtZTiR+Qo24urpSVFQEwKVLlwgKCqr2h3dubm65pE+SpJL/NpvRm0wYz59HZTIhubiIHr4acnZ2VjqECrm4VF0822QycenSpbKvG9MSb5WRdDq8BjyM5wP3k/P1ITK2biV+2jR0zZrh9fhjeNx3n91nr1933XV2vd5tnTsTt3kz7RISCcjNJUOv58uwppwJCkLl5MTCXr3sGo8S7N3m9Z1oL8uJxE+oEQ8Pj7Jp9NnZ2WRnZ1e7fJjBYChXfkQly2V/CoF0lQqNkxMYjXBFUiBUrrCwkMLCQqXDuEZhYWGVM45Le/pKeXp62jqkekPSakteAfe5h8Lffydj2zaSly0n5e0VuPXsgecDD+LS5eYqewFrUw5FabIsU/jnKbL37ydn/37uys7mnKsr+69rx3lPT6TLr3wdvfSNINRXIvETasTZ2ZmQkBASEhLKPrv6h/nVCgsLKcrPR2MyoTWbkWUZoyRhUKkoVqvRu7jgotNBNecR/iczMxM/Pz+lw7hGVlZWjdcRDgkJQa/X2zii+keSJJxvuAHnG27AmJRM9v79ZO39jJz/O4AmOAiPvvfi1rMH+uuuK9czXtNyKDVxyUa/gMmyjOH8eXK+/Irs/fsxXryIxt8fr0GD8BrwMH4aDcXR0fjXg8TV2mzV5g2VaC/LicSvCvv37+fo0aMcP36c48ePk5iYCEBcXBxNmjSp8liDwcCbb77Jtm3bOHv2LDqdjhtuuIEpU6YwaNCgOse0c+dOVq1axW+//YbBYCAiIoKhQ4fyzDPP1GicVWUOHTpEaGholQ9bT09PnJycyMrKIi8vr+JiwmYzppwcTBkZqFNTcSoowCxJZGu05Gq1FGrUSCoVkiTRunXrGicLQokzZ84QFBSkdBjX+PXXX+nbt2+l29VqNa6urnh6eoqkrwa0gQH4jh6Fz6iRFP7+O1mf7SVz98ekb9iAJjAQtzvvxK1nD3KCg6sth1KbBOrkyZOVbqttr6JsNFLwxx/kfvsdud9+izEuDpWLC2539SZwzhxcbu5cttJGIDBgwIAax9mQVNXmwrVEe1lO/NStwpAhQ8jKyqr1cfn5+dx99938+OOPeHl50bdvX3Jzczl06BDffvstzz33HMuXL6/1eadNm8bbb7+NRqOhV69euLm5cejQIWbOnMnevXs5ePBgnceA/fjjj5w9e7baXgK9Xl/uB7fZYKDozBkKfj1J/pGfyT/xK1JhIU7e3vj26MGF4CA2/fwzxVDWG1H6Gqd9Ayi+am/vvfceY8aMUTqMa2zevJlWDjArtaG5shcwcPYsCn79lZxvDpP77bdk7tiBAbjfyYkLri7Ee3qS6uGBUZbLyqNER0fXKqGqLHmvSa+ibDBQeOYMBcdPkH/sGPm//opcUIDazxe3O7rj9txzuHTtgsrBi1jbW1W/MAnXEu1lOZH4VWHAgAG0atWKTp060alTJwJquCzQnDlz+PHHH+nYsSOHDh0qezV3/PhxevToweuvv06PHj24//77axzLnj17ePvtt3Fzc+Pbb7+lU6dOAKSmptKrVy9++OEH5s2bV6eEEqCoqAij0VhpL4Esy5jS0jDExmK4EEvR6dMUnjpF0b//IhcXIzk54XzjjfhNGI9Lt244tWqFpFIRBITff3+9GX8kCI5K0mhw6dIFly5dCJgxnaLTp/lqxQqKf/+dLpeSiExIxCxJpLm4kKTXk+7ujuH33ym+4w7Ufn51njh1TZFlWcaluJiA4mKOL11GyA0HUZ0/T9GZM8hGI5Jej/ONN+L7xFhcunRB365do15tRxAcjUj8qrB+/fpaH5ORkcF7770HlPTOXDkeq3PnzsycOZN58+axaNGiWiV+ixcvBmDWrFllSR+An58f7777LnfccQcrV65k3rx5dRo43zwnh6Yy6DVq/lq2HFVYU4rT0zGlpVOcno4xLg5zaQ05lQpd06boO3TA4/770bdvj1PrVpUWVg0MDGy0r3EEwRYkSULfti2Gu+7iQHExRQUFBBUVEZKfj19OLgF5eVyXno7u4kXO7f28pDZmUBDa0BA0/gGoPNxRu3ugcndD7e4Ol4dcOAM5X3+NbDBgys1Fzs/n9NFj3Hn6X5wLC3AzFuNhMKAzmUCWkSWJjNwcgm+LxKNfP/Ttr0Pfpg2SKLIsCA5Lkq8usCZUqvQ35qrG+G3dupVhw4YRFhbGhQsXrtn+33//0fJypf74+HhCQkKqvW58fHzZ9f777z+aN29+zT5hYWHExcWxbds2Btei7tWJEyfo3Lkz25q3oJ1eD5KE5OSEe2goal9fND4+qH180DYJRdesGbpmzdA2aSKq5yvkxhtvdMgxLoGBgSQlJSkdRqOTlJTEggULKhzj56RWM3fMGDwKCylOTMSYkIAxIZHi5GRMubmYc3Iw5eSUm1yVbjTiUzpWWK1G5eJCtsFAqqmYHLWGAmc9eU5OpDvpSdaoKXB35+Zbb2XcuHH2/tYbDEf9N+2oGlp7lf4MPn78eLlOHVsSPX5W9uuvvwJw8803V7i9RYsW+Pj4kJ6ezsmTJ2uU+JWe08fHp8Kkr/R6cXFx/Prrr7VK/ErtbNcWD29vdM7O9L33XtFD56AiIiKUDqFC9957r9IhNEqBgYEMHz6cqKgo1Gp1uXG0Q4cPJ/SWW6o8XpZl5KIi5GITIDNs1Ci2rF+PpNMhOTkhSRK7d+/mwIEDFBYWlltWzWQyoddo8PX1tc8320A56r9pRyXay3Ii8bOy8+fPAyU9cJVp0qQJ6enpZfta45xNmzYtt29tFQFqJydUanWtS0AI9lPVPaCk0vtPsL/IyEgiIiLqNI5WkiSkKyZrBYeFofbwuOb8Bw8eRKvVYjQay2bza7VaVCqVeF5YyFH/TTsq0V6WE4mfleXk5ABVr0xQuuRMdna2YucsVVBQUPZ3ZmYm/fr1Iz4+nvj4+FqdR7CPpKQkTpw4oXQY10hMTHTIuBqT8PBwwsPDAer8b7iy+6tr167s27cPWZbLehUlSRLPCytw1H/Tjqqhtdfff/8N/O9nsT00yMTv+eef57PPPqv1cWvXruX222+3QUSOKyYmBoBvvvkGgN27dysYjVAT27ZtUzqECq1bt07pEAQrqM39JZ4X1uGo/6YdVUNsr5iYGLv1njfIxC8hIYHTp0/X+rjc3FyLr+3u7g5AXukM2Cqu43HVKxV7nrNUnz592LJlC+Hh4Q67DqwgCIIgNEQFBQXExMTQp08fu12zQSZ+W7ZsYcuWLYpcu/RVS2xsbKX7XLx4sdy+NT1nXFxcpfuUbqvpOUv5+fkxdOjQWh0jCIIgCIJ12HucrKiqaWWl07F/+eWXCrf/999/pKenA3DTTTfV6Jyl+6WlpVU6eaP0evaaDi4IgiAIQv0jEj8ru++++9DpdMTGxhIdHX3N9tKxCbfcckuNSrlAySzgLl26lDv+Sj/88ANxcXE4OTlx3333WRC9IAiCIAgNmUj8rMzb25uJEycCMGnSJNLS0sq2nThxgiVLlgAwd+7ca46dPXs2bdu2Zfbs2ddsmzNnDgCvvfZauRlNaWlpTJo0CYApU6bUadUOQRAEQRAahwY5xs9aXn75Zfbt23fN5w8++CC6yytXdOrUiXfffbfc9sWLF3P06FF++uknWrVqRa9evcjLy+Prr7/GaDTy7LPPVrhcW2JiIqdPnyYxMfGabf3792fq1KmsWLGCW265hd69e+Pq6srXX39NZmYmkZGRvPzyy1b6zgVBEARBaIhE4leFc+fOceTIkWs+L11JA0B/RfHTUi4uLhw+fJg33niDrVu3sn//fnQ6HbfeeitTpkzhkUceqVM8b7/9NpGRkaxatYoff/wRo9FIy5YtmTVrFs8880xZMioIgiAIglARsVavIAiCIAhCIyHG+AmCIAiCIDQSIvFrpA4fPsy4ceO47rrr8Pb2RqvV4uvrS9euXZkyZQpfffUVojNYOYcOHUKlUuHq6srZs2cr3W/hwoVIkkT79u0pKiqyS2wajQZJknjiiScq3P7333/j6uqKJEno9fpKSxsJjkE8C+wrPDwcSZLYuHGj0qE4jHPnziFJEiqVipSUlAr32bJlS8na0pJUaZ3elJSUsuUEz507Z8uQ68Rhnuuy0KikpKTI99xzjwzIgBwaGir369dPHjJkiNyvXz+5WbNmZdtuuukmpcNt1CZPniwDcmRkpGwyma7Zfvz4cVmj0cgajUb+5Zdf7BaXWq2WAXns2LHXbPv5559lnU4nA7Krq6v877//2i0uoXbEs0AZpe26YcMGpUNxKE2bNpUBeefOnRVuHzNmTNn9WNGzR5ZleceOHTIgN23a1JahWsQRnusi8WtEMjIy5DZt2siA3LZtW/nQoUMV7vfHH3/IY8aMkV1cXOwcoXCl3NxcuWXLljIgL126tNy2wsJCuX379jIgz58/365xVZb47d+/v2ybj4+PnJiYaNe4hJoTzwLliMSvYiNGjJABedKkSRVub9Gihezv7y83adJEbtmyZYX7TJo0SQbkESNG2DJUizjCc10kfo3IsGHDZEBu0aKFnJ6eXu3+R44csUNUQlW+//57WaVSyU5OTvKpU6fKPp8xY4YMyJ06dZINBoNdY6oo8duyZYssSVJZz1FOTo5dYxJqRzwLlCMSv4pt2LBBBuR27dpdsy02NlYG5EGDBslDhw6VATk2Nvaa/dq1a1cv2lbp57pI/BqJs2fPyiqVSgbkTz/9VOlwhFp47rnnZEC++eabZaPRKEdHR8sqlUrW6XTyH3/8Yfd4rk78VqxYUfYKpm3btrLRaLR7TELNiWeBskTiV7GYmJiy58ilS5fKbdu8ebMMyCtXrpQ/+OADGZA3b95cbp9Lly6VHR8TE2PP0OtEyee6mNzRSHz++eeYzWa8vb0rLB4tOK5XXnmFdu3a8csvvzBv3jxGjRqF2Wxm4cKFdOjQQdHY5s+fz9SpUwHo1q0bf//9NxqNKA/qyMSzQHBEzZo1o3nz5kDJhKMrlX595513cueddwLwzTffVLhP8+bNadasmU1jtQYln+si8Wskjh8/DpSsNKJSif/t9Yler2fTpk2o1Wpee+01zpw5w6233sqMGTMUjWvv3r1lq8X069ePn3/+WdF4hJoRzwLBUfXs2ROoOKnz9/enffv2tG7dmqCgoEqTw9JzODoln+viV/NGIjU1FQB/f/8Kt//222+8+eab13z+xBNPcPvtt9s0NqF6Xbp04e677+bAgQMArF69GrVarWhMycnJAAQHB/P5558rGotQc+JZIDiqnj17sn79+nKJX2xsLP/99x8DBw5EkiSgpOfvo48+4sKFC2W9e6XH1JfED5R7rovETwAgLi6OTZs2XfN5jx49xMPeAXz99dd88cUXZV9v376djh07KhgReHp6kpWVRWJiIvfccw8HDx5UNB7BOsSzQFBKadL277//kpiYSHBwcLnXvKVKE7/Dhw8zcuRILl26xOnTp8udoz5Q6rku+vkbCT8/P4BKi2Pef//9yCWTfZBlmd69e9szPKEK2dnZjBkzBlmWmTJlClqtlqVLl3Ls2DFF4xo0aBCPPfYYAF9++aW4Z+oJ8SwQHFVoaCitWrUC/teDV5r49ejRo2y/0iSwdFvp361atSI0NNQusVpKyee6SPwaiU6dOgFw4sQJzGazwtEItfHMM88QGxtL7969WbFiBXPnzsVkMjFq1Ci7rdZRmQ8//JAhQ4YAJVXp69Nv242VeBYIjuzqcX6HDx/G19e33ISH6667Dn9//7J96uNrXiWf6yLxayTuv/9+VCoVGRkZ7N+/X+lwhBrat28f69evx8PDg/Xr1yNJEnPmzOGmm27ir7/+YsGCBUqHyNatWxkxYgRQ8pC+8pWM4HjEs0BwZFcmfrGxsZw/f57u3buXje8r1b17dy5cuEBMTEy9m9ih9HNdJH6NRERERNlruWeffZasrCyFIxKqk56ezrhx4wB44403CAsLA0Cr1bJx40a0Wi3Lly/nyJEjSoYJwKZNmxg9ejQA3333nRgL5sDEs0BwZKWvdM+dO1e2Ju+Vr3lLlf6CuXXrVv79999K93M0jvBcF4lfI7Jq1SoiIiI4c+YMt912G99++22F+8XExHDx4kU7RydcbcqUKSQmJnLvvfcyduzYctuuv/565s2bV/ZqoLCwUKEo/2f9+vU88cQTAERHR3PrrbcqHJFQGfEsEBxVUFAQ7dq1A+D1118Hqk783njjDQDatWtHUFCQfYK0gEM8121aHlpwOElJSXLv3r3LKpw3adJEvv/+++Vhw4bJAwcOlK+//vqypbc6duyoyMoQgizv2rVLBmQvLy/54sWLFe5jNBrlTp06yYA8Y8YMu8VW2Vq9pZ588smy+6tLly52i0uoHfEsUEbpyh0tWrSQu3XrVumf48ePKx2qYkrX3OXyut9ms/mafcxms+zj41O2X2Vr/DoSR3mui8Svkfrqq6/kMWPGyG3atJE9PDxkjUYje3t7y506dZInTJggf/nll7LJZFI6zEYpKSlJ9vPzkwF506ZNVe77xx9/yDqdTlapVPJPP/1kl/iqS/xkWZanTJlS9kDu3LmzXeIS6kY8C+yrNPGr7s8333yjdKiK2blzZ1k79O/fv9L9HnroobL9du7caccIa8+RnuuSLMuybfoSBUEQBEEQBEcixvgJgiAIgiA0EiLxEwRBEARBaCRE4icIgiAIgtBIiMRPEARBEAShkRCJnyAIgiAIQiMhEj9BEARBEIRGQiR+giAIgiAIjYRI/ARBEARBEBoJkfgJgiAIgiA0EiLxEwRBEARBaCRE4icIgiAIgtBIiMRPEARBEAShkRCJnyAIgiAIQiMhEj9BEARBEIRGQiR+giAIgiAIjYRI/ARBEARBEBoJkfgJgiAIgiA0EiLxEwRBEARBaCRE4icIgiAIgtBIiMRPEARBEAShkRCJnyAIgiAIQiMhEj9BEARBEIRGQiR+giAIgiAIjcT/A2Ts/pmc9VkCAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# AtomicData_options = {\"r_max\": 5.0,\"er_max\": 3.5, \"oer_max\":1.6, \"pbc\": True}\n", + "stru_data = '/Users/aisiqg/Desktop/work/github/DeePTB/examples/silicon/data/silicon.vasp'\n", + "kpath_kwargs = {\n", + " \"task\": \"band\",\n", + " \"kline_type\":\"abacus\",\n", + " \"kpath\":[[0.0000000000, 0.0000000000, 0.0000000000, 50], \n", + " [0.5000000000, 0.0000000000, 0.5000000000, 50], \n", + " [0.6250000000, 0.2500000000, 0.6250000000, 1], \n", + " [0.3750000000, 0.3750000000, 0.7500000000, 50], \n", + " [0.0000000000, 0.0000000000, 0.0000000000, 50], \n", + " [0.5000000000, 0.5000000000, 0.5000000000, 50], \n", + " [0.5000000000, 0.2500000000, 0.7500000000, 50], \n", + " [0.5000000000, 0.0000000000, 0.5000000000, 1 ]\n", + " ],\n", + " \"klabels\":[\"G\",\"X\",\"X/U\",\"K\",\"G\",\"L\",\"W\",\"X\"],\n", + " \"nel_atom\":{\"Si\":4},\n", + " \"E_fermi\":-4.722,\n", + " \"emin\":-15,\n", + " \"emax\":10,\n", + " \"ref_band\": \"/Users/aisiqg/Desktop/work/github/DeePTB/examples/silicon/data/kpath.0/eigenvalues.npy\"\n", + " }\n", + "bcal = Band(model=nnskf, \n", + " use_gui=False, \n", + " results_path='./', \n", + " device=nnskf.device)\n", + "eigenstatus = bcal.get_bands(data=stru_data, \n", + " kpath_kwargs=kpath_kwargs)\n", + "bcal.band_plot(ref_band = kpath_kwargs[\"ref_band\"],\n", + " E_fermi = -5,\n", + " emin = -10,\n", + " emax = 10)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "common_options = {\n", + " \"basis\": {\n", + " \"B\": [\"2s\", \"2p\",'d*'],\n", + " \"N\": [\"2s\", \"2p\",'d*'],\n", + " },\n", + " \"device\": \"cpu\",\n", + " \"dtype\": \"float32\",\n", + " \"overlap\": True,\n", + " \"seed\": 3982377700\n", + "}\n", + "model_options = {\n", + "\"dftbsk\": {\n", + " \"skdata\": './H_B_C_N_O_Si.pth'\n", + " }\n", + "}\n", + "data_options = {\n", + " \"r_max\": 2.6,\n", + " \"er_max\": 2.6,\n", + " \"oer_max\":1.6,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from dptb.nn.dftbsk import DFTBSK" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Overwrite the r_max setting in the model with the r_max setting in the AtomicData_options: 4.22\n", + "This is very dangerous, please make sure you know what you are doing.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = DFTBSK(**common_options, **model_options['dftbsk'])\n", + "# AtomicData_options = {\"r_max\": 5.0,\"er_max\": 3.5, \"oer_max\":1.6, \"pbc\": True}\n", + "stru_data = '/Users/aisiqg/Desktop/work/github/DeePTB/examples/hBN_dftb/data/struct.vasp'\n", + "kpath_kwargs = {\n", + " \"task\": \"band\",\n", + " \"kline_type\":\"abacus\",\n", + " \"kpath\":[\n", + " [0, 0, 0, 50],\n", + " [0.5, 0, 0, 50],\n", + " [0.3333333, 0.3333333, 0, 50],\n", + " [0, 0, 0, 1]\n", + " ],\n", + " \"nel_atom\":{\"N\":5,\"B\":3},\n", + " \"klabels\":[\"G\", \"M\", \"K\", \"G\"],\n", + " \"E_fermi\":-12.798759460449219,\n", + " \"emin\":-25,\n", + " \"emax\":15,\n", + " \"ref_band\": \"/Users/aisiqg/Desktop/work/github/DeePTB/examples/hBN_dftb/data/kpath.0/eigenvalues.npy\"\n", + " }\n", + "bcal = Band(model=model, \n", + " use_gui=False, \n", + " results_path='./', \n", + " device=model.device)\n", + "eigenstatus = bcal.get_bands(data=stru_data, \n", + " kpath_kwargs=kpath_kwargs,\n", + " AtomicData_options={'r_max':4.22})\n", + "\n", + "bcal.band_plot(ref_band = kpath_kwargs[\"ref_band\"],\n", + " E_fermi = -5,\n", + " emin = -18,\n", + " emax = 15)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'H-H': 3.42,\n", + " 'H-B': 3.82,\n", + " 'B-H': 3.82,\n", + " 'H-C': 3.92,\n", + " 'C-H': 3.92,\n", + " 'H-N': 3.64,\n", + " 'N-H': 3.64,\n", + " 'H-O': 3.48,\n", + " 'O-H': 3.48,\n", + " 'H-Si': 4.55,\n", + " 'Si-H': 4.55,\n", + " 'B-B': 4.22,\n", + " 'B-C': 4.32,\n", + " 'C-B': 4.32,\n", + " 'B-N': 4.04,\n", + " 'N-B': 4.04,\n", + " 'B-O': 3.88,\n", + " 'O-B': 3.88,\n", + " 'B-Si': 4.95,\n", + " 'Si-B': 4.95,\n", + " 'C-C': 4.39,\n", + " 'C-N': 4.13,\n", + " 'N-C': 4.13,\n", + " 'C-O': 3.99,\n", + " 'O-C': 3.99,\n", + " 'C-Si': 5.02,\n", + " 'Si-C': 5.02,\n", + " 'N-N': 3.85,\n", + " 'N-O': 3.7,\n", + " 'O-N': 3.7,\n", + " 'N-Si': 4.76,\n", + " 'Si-N': 4.76,\n", + " 'O-O': 3.55,\n", + " 'O-Si': 4.63,\n", + " 'Si-O': 4.63,\n", + " 'Si-Si': 5.64}" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nnskf.model_options['nnsk']['hopping']['rs']" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEEPTB INFO KPOINTS klist: 151 kpoints\n", + "DEEPTB INFO The eigenvalues are already in data. will use them.\n", + "DEEPTB INFO Calculating Fermi energy in the case of spin-degeneracy.\n", + "DEEPTB INFO Estimated E_fermi: -4.688051462173462 based on the valence electrons setting nel_atom : {'N': 5, 'B': 3} .\n", + "DEEPTB INFO use input fermi energy: -5, While the estimated value in line-mode is -4.688051462173462\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "common_options = {\n", + " \"basis\": {\n", + " \"B\": [\"s\", \"p\"],\n", + " \"N\": [\"s\", \"p\"],\n", + " },\n", + " \"device\": \"cpu\",\n", + " \"dtype\": \"float32\",\n", + " \"overlap\": True,\n", + " \"seed\": 3982377700\n", + "}\n", + "\n", + "model = build_model('./HBCNOSi.nnsk.model/nnsk_skf.pth',common_options=common_options)\n", + "# AtomicData_options = {\"r_max\": 5.0,\"er_max\": 3.5, \"oer_max\":1.6, \"pbc\": True}\n", + "stru_data = '/Users/aisiqg/Desktop/work/github/DeePTB/examples/hBN_dftb/data/struct.vasp'\n", + "kpath_kwargs = {\n", + " \"task\": \"band\",\n", + " \"kline_type\":\"abacus\",\n", + " \"kpath\":[\n", + " [0, 0, 0, 50],\n", + " [0.5, 0, 0, 50],\n", + " [0.3333333, 0.3333333, 0, 50],\n", + " [0, 0, 0, 1]\n", + " ],\n", + " \"nel_atom\":{\"N\":5,\"B\":3},\n", + " \"klabels\":[\"G\", \"M\", \"K\", \"G\"],\n", + " \"E_fermi\":-12.798759460449219,\n", + " \"emin\":-25,\n", + " \"emax\":15,\n", + " \"ref_band\": \"/Users/aisiqg/Desktop/work/github/DeePTB/examples/hBN_dftb/data/kpath.0/eigenvalues.npy\"\n", + " }\n", + "bcal = Band(model=model, \n", + " use_gui=False, \n", + " results_path='./', \n", + " device=model.device)\n", + "eigenstatus = bcal.get_bands(data=stru_data, \n", + " kpath_kwargs=kpath_kwargs)\n", + "\n", + "bcal.band_plot(ref_band = kpath_kwargs[\"ref_band\"],\n", + " E_fermi = -5,\n", + " emin = -18,\n", + " emax = 15)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pydptb", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/skf2nnsk/input.json b/examples/skf2nnsk/input.json new file mode 100644 index 00000000..7881635b --- /dev/null +++ b/examples/skf2nnsk/input.json @@ -0,0 +1,34 @@ +{ + "common_options": + { + "basis": "auto", + "skdata": "./H_B_C_N_O_Si.pth", + "device": "cpu", + "dtype": "float32", + "seed": 12345678 + }, + + "model_options": + { + "method": "poly4pow", + "rs":null, + "w":0.2, + "atomic_radius": "cov" + }, + "train_options": + { + "nstep":100, + "dis_freq":100, + "nsample":256, + "save_freq":100, + "max_elmt_batch":4, + "optimizer": { + "lr": 0.01, + "type": "RMSprop" + }, + "lr_scheduler": { + "type": "exp", + "gamma": 0.9997 + } + } +} \ No newline at end of file diff --git a/examples/skf2nnsk/input_test.json b/examples/skf2nnsk/input_test.json new file mode 100644 index 00000000..ce2c0b6c --- /dev/null +++ b/examples/skf2nnsk/input_test.json @@ -0,0 +1,34 @@ +{ + "common_options": + { + "basis": "auto", + "skdata": "./examples/skf2nnsk/H_B_C_N_O_Si.pth", + "device": "cpu", + "dtype": "float32", + "seed": 12345678 + }, + + "model_options": + { + "method": "poly4pow", + "rs":null, + "w":0.2, + "atomic_radius": "cov" + }, + "train_options": + { + "nstep":100, + "dis_freq":100, + "nsample":256, + "save_freq":100, + "max_elmt_batch":4, + "optimizer": { + "lr": 0.01, + "type": "RMSprop" + }, + "lr_scheduler": { + "type": "exp", + "gamma": 0.9997 + } + } +} \ No newline at end of file