diff --git a/deepmd/entrypoints/freeze.py b/deepmd/entrypoints/freeze.py index bf7b957a4a..1528c12e15 100755 --- a/deepmd/entrypoints/freeze.py +++ b/deepmd/entrypoints/freeze.py @@ -222,6 +222,13 @@ def _make_node_names( "fitting_attr/dfparam", "fitting_attr/daparam", ] + elif model_type == "dos": + nodes += [ + "o_dos", + "fitting_attr/numb_dos", + "fitting_attr/dfparam", + "fitting_attr/daparam", + ] elif model_type == "wfc": nodes += [ "o_wfc", diff --git a/deepmd/entrypoints/test.py b/deepmd/entrypoints/test.py index 4dbfa54a2b..52b98aba3c 100644 --- a/deepmd/entrypoints/test.py +++ b/deepmd/entrypoints/test.py @@ -30,6 +30,7 @@ if TYPE_CHECKING: from deepmd.infer import ( DeepDipole, + DeepDOS, DeepPolar, DeepPot, DeepWFC, @@ -123,6 +124,16 @@ def test( atomic, append_detail=(cc != 0), ) + elif dp.model_type == "dos": + err = test_dos( + dp, + data, + system, + numb_test, + detail_file, + atomic, + append_detail=(cc != 0), + ) elif dp.model_type == "dipole": err = test_dipole(dp, data, numb_test, detail_file, atomic) elif dp.model_type == "polar": @@ -147,6 +158,8 @@ def test( log.info(f"# number of systems : {len(all_sys)}") if dp.model_type == "ener": print_ener_sys_avg(avg_err) + elif dp.model_type == "dos": + print_dos_sys_avg(avg_err) elif dp.model_type == "dipole": print_dipole_sys_avg(avg_err) elif dp.model_type == "polar": @@ -435,6 +448,166 @@ def print_ener_sys_avg(avg: Dict[str, float]): log.info(f"Virial RMSE/Natoms : {avg['rmse_va']:e} eV") +def test_dos( + dp: "DeepDOS", + data: DeepmdData, + system: str, + numb_test: int, + detail_file: Optional[str], + has_atom_dos: bool, + append_detail: bool = False, +) -> Tuple[List[np.ndarray], List[int]]: + """Test DOS type model. + + Parameters + ---------- + dp : DeepDOS + instance of deep potential + data : DeepmdData + data container object + system : str + system directory + numb_test : int + munber of tests to do + detail_file : Optional[str] + file where test details will be output + has_atom_dos : bool + whether per atom quantities should be computed + append_detail : bool, optional + if true append output detail file, by default False + + Returns + ------- + Tuple[List[np.ndarray], List[int]] + arrays with results and their shapes + """ + data.add("dos", dp.numb_dos, atomic=False, must=True, high_prec=True) + if has_atom_dos: + data.add("atom_dos", dp.numb_dos, atomic=True, must=False, high_prec=True) + + if dp.get_dim_fparam() > 0: + data.add( + "fparam", dp.get_dim_fparam(), atomic=False, must=True, high_prec=False + ) + if dp.get_dim_aparam() > 0: + data.add("aparam", dp.get_dim_aparam(), atomic=True, must=True, high_prec=False) + + test_data = data.get_test() + mixed_type = data.mixed_type + natoms = len(test_data["type"][0]) + nframes = test_data["box"].shape[0] + numb_test = min(nframes, numb_test) + + coord = test_data["coord"][:numb_test].reshape([numb_test, -1]) + box = test_data["box"][:numb_test] + + if not data.pbc: + box = None + if mixed_type: + atype = test_data["type"][:numb_test].reshape([numb_test, -1]) + else: + atype = test_data["type"][0] + if dp.get_dim_fparam() > 0: + fparam = test_data["fparam"][:numb_test] + else: + fparam = None + if dp.get_dim_aparam() > 0: + aparam = test_data["aparam"][:numb_test] + else: + aparam = None + + ret = dp.eval( + coord, + box, + atype, + fparam=fparam, + aparam=aparam, + atomic=has_atom_dos, + mixed_type=mixed_type, + ) + dos = ret[0] + + dos = dos.reshape([numb_test, dp.numb_dos]) + + if has_atom_dos: + ados = ret[1] + ados = ados.reshape([numb_test, natoms * dp.numb_dos]) + + diff_dos = dos - test_data["dos"][:numb_test] + mae_dos = mae(diff_dos) + rmse_dos = rmse(diff_dos) + + mae_dosa = mae_dos / natoms + rmse_dosa = rmse_dos / natoms + + if has_atom_dos: + diff_ados = ados - test_data["atom_dos"][:numb_test] + mae_ados = mae(diff_ados) + rmse_ados = rmse(diff_ados) + + log.info(f"# number of test data : {numb_test:d} ") + + log.info(f"DOS MAE : {mae_dos:e} Occupation/eV") + log.info(f"DOS RMSE : {rmse_dos:e} Occupation/eV") + log.info(f"DOS MAE/Natoms : {mae_dosa:e} Occupation/eV") + log.info(f"DOS RMSE/Natoms : {rmse_dosa:e} Occupation/eV") + + if has_atom_dos: + log.info(f"Atomic DOS MAE : {mae_ados:e} Occupation/eV") + log.info(f"Atomic DOS RMSE : {rmse_ados:e} Occupation/eV") + + if detail_file is not None: + detail_path = Path(detail_file) + + for ii in range(numb_test): + test_out = test_data["dos"][ii].reshape(-1, 1) + pred_out = dos[ii].reshape(-1, 1) + + frame_output = np.hstack((test_out, pred_out)) + + save_txt_file( + detail_path.with_suffix(".dos.out.%.d" % ii), + frame_output, + header="%s - %.d: data_dos pred_dos" % (system, ii), + append=append_detail, + ) + + if has_atom_dos: + for ii in range(numb_test): + test_out = test_data["atom_dos"][ii].reshape(-1, 1) + pred_out = ados[ii].reshape(-1, 1) + + frame_output = np.hstack((test_out, pred_out)) + + save_txt_file( + detail_path.with_suffix(".ados.out.%.d" % ii), + frame_output, + header="%s - %.d: data_ados pred_ados" % (system, ii), + append=append_detail, + ) + + return { + "mae_dos": (mae_dos, dos.size), + "mae_dosa": (mae_dosa, dos.size), + "rmse_dos": (rmse_dos, dos.size), + "rmse_dosa": (rmse_dosa, dos.size), + } + + +def print_dos_sys_avg(avg: Dict[str, float]): + """Print errors summary for DOS type potential. + + Parameters + ---------- + avg : np.ndarray + array with summaries + """ + log.info(f"DOS MAE : {avg['mae_dos']:e} Occupation/eV") + log.info(f"DOS RMSE : {avg['rmse_dos']:e} Occupation/eV") + log.info(f"DOS MAE/Natoms : {avg['mae_dosa']:e} Occupation/eV") + log.info(f"DOS RMSE/Natoms : {avg['rmse_dosa']:e} Occupation/eV") + + def run_test(dp: "DeepTensor", test_data: dict, numb_test: int): """Run tests. diff --git a/deepmd/fit/__init__.py b/deepmd/fit/__init__.py index 233b987037..174dbd443d 100644 --- a/deepmd/fit/__init__.py +++ b/deepmd/fit/__init__.py @@ -1,6 +1,9 @@ from .dipole import ( DipoleFittingSeA, ) +from .dos import ( + DOSFitting, +) from .ener import ( EnerFitting, ) @@ -12,6 +15,7 @@ __all__ = [ "DipoleFittingSeA", "EnerFitting", + "DOSFitting", "GlobalPolarFittingSeA", "PolarFittingSeA", ] diff --git a/deepmd/fit/dos.py b/deepmd/fit/dos.py new file mode 100644 index 0000000000..43e31185d1 --- /dev/null +++ b/deepmd/fit/dos.py @@ -0,0 +1,610 @@ +import logging +from typing import ( + List, + Optional, +) + +import numpy as np + +from deepmd.common import ( + add_data_requirement, + cast_precision, + get_activation_func, + get_precision, +) +from deepmd.env import ( + GLOBAL_TF_FLOAT_PRECISION, + tf, +) +from deepmd.fit.fitting import ( + Fitting, +) +from deepmd.nvnmd.fit.ener import ( + one_layer_nvnmd, +) +from deepmd.nvnmd.utils.config import ( + nvnmd_cfg, +) +from deepmd.utils.errors import ( + GraphWithoutTensorError, +) +from deepmd.utils.graph import ( + get_fitting_net_variables_from_graph_def, + get_tensor_by_name_from_graph, +) +from deepmd.utils.network import one_layer as one_layer_deepmd +from deepmd.utils.network import ( + one_layer_rand_seed_shift, +) + +log = logging.getLogger(__name__) + + +class DOSFitting(Fitting): + r"""Fitting the density of states (DOS) of the system. + The energy should be shifted by the fermi level. + + Parameters + ---------- + descrpt + The descrptor :math:`\mathcal{D}` + neuron + Number of neurons :math:`N` in each hidden layer of the fitting net + resnet_dt + Time-step `dt` in the resnet construction: + :math:`y = x + dt * \phi (Wx + b)` + numb_fparam + Number of frame parameter + numb_aparam + Number of atomic parameter + ! numb_dos (added) + Number of gridpoints on which the DOS is evaluated (NEDOS in VASP) + rcond + The condition number for the regression of atomic energy. + trainable + If the weights of fitting net are trainable. + Suppose that we have :math:`N_l` hidden layers in the fitting net, + this list is of length :math:`N_l + 1`, specifying if the hidden layers and the output layer are trainable. + seed + Random seed for initializing the network parameters. + activation_function + The activation function :math:`\boldsymbol{\phi}` in the embedding net. Supported options are |ACTIVATION_FN| + precision + The precision of the embedding net parameters. Supported options are |PRECISION| + uniform_seed + Only for the purpose of backward compatibility, retrieves the old behavior of using the random seed + layer_name : list[Optional[str]], optional + The name of the each layer. If two layers, either in the same fitting or different fittings, + have the same name, they will share the same neural network parameters. + use_aparam_as_mask: bool, optional + If True, the atomic parameters will be used as a mask that determines the atom is real/virtual. + And the aparam will not be used as the atomic parameters for embedding. + """ + + def __init__( + self, + descrpt: tf.Tensor, + neuron: List[int] = [120, 120, 120], + resnet_dt: bool = True, + numb_fparam: int = 0, + numb_aparam: int = 0, + numb_dos: int = 300, + rcond: float = 1e-3, + trainable: List[bool] = None, + seed: int = None, + activation_function: str = "tanh", + precision: str = "default", + uniform_seed: bool = False, + layer_name: Optional[List[Optional[str]]] = None, + use_aparam_as_mask: bool = False, + ) -> None: + """Constructor.""" + # model param + self.ntypes = descrpt.get_ntypes() + self.dim_descrpt = descrpt.get_dim_out() + self.use_aparam_as_mask = use_aparam_as_mask + + self.numb_fparam = numb_fparam + self.numb_aparam = numb_aparam + + self.numb_dos = numb_dos + + self.n_neuron = neuron + self.resnet_dt = resnet_dt + self.rcond = rcond + self.seed = seed + self.uniform_seed = uniform_seed + self.seed_shift = one_layer_rand_seed_shift() + self.fitting_activation_fn = get_activation_func(activation_function) + self.fitting_precision = get_precision(precision) + self.trainable = trainable + if self.trainable is None: + self.trainable = [True for ii in range(len(self.n_neuron) + 1)] + if isinstance(self.trainable, bool): + self.trainable = [self.trainable] * (len(self.n_neuron) + 1) + assert ( + len(self.trainable) == len(self.n_neuron) + 1 + ), "length of trainable should be that of n_neuron + 1" + + self.useBN = False + self.bias_dos = np.zeros((self.ntypes, self.numb_dos), dtype=np.float64) + # data requirement + if self.numb_fparam > 0: + add_data_requirement( + "fparam", self.numb_fparam, atomic=False, must=True, high_prec=False + ) + self.fparam_avg = None + self.fparam_std = None + self.fparam_inv_std = None + if self.numb_aparam > 0: + add_data_requirement( + "aparam", self.numb_aparam, atomic=True, must=True, high_prec=False + ) + self.aparam_avg = None + self.aparam_std = None + self.aparam_inv_std = None + + self.fitting_net_variables = None + self.mixed_prec = None + self.layer_name = layer_name + if self.layer_name is not None: + assert isinstance(self.layer_name, list), "layer_name should be a list" + assert ( + len(self.layer_name) == len(self.n_neuron) + 1 + ), "length of layer_name should be that of n_neuron + 1" + + def get_numb_fparam(self) -> int: + """Get the number of frame parameters.""" + return self.numb_fparam + + def get_numb_aparam(self) -> int: + """Get the number of atomic parameters.""" + return self.numb_fparam + + def get_numb_dos(self) -> int: + """Get the number of gridpoints in energy space.""" + return self.numb_dos + + # not used + def compute_output_stats(self, all_stat: dict, mixed_type: bool = False) -> None: + """Compute the ouput statistics. + + Parameters + ---------- + all_stat + must have the following components: + all_stat['dos'] of shape n_sys x n_batch x n_frame x numb_dos + can be prepared by model.make_stat_input + mixed_type + Whether to perform the mixed_type mode. + If True, the input data has the mixed_type format (see doc/model/train_se_atten.md), + in which frames in a system may have different natoms_vec(s), with the same nloc. + """ + self.bias_dos = self._compute_output_stats( + all_stat, rcond=self.rcond, mixed_type=mixed_type + ) + + def _compute_output_stats(self, all_stat, rcond=1e-3, mixed_type=False): + data = all_stat["dos"] + # data[sys_idx][batch_idx][frame_idx] + sys_dos = [] + for ss in range(len(data)): + sys_data = [] + for ii in range(len(data[ss])): + for jj in range(len(data[ss][ii])): + sys_data.append(data[ss][ii][jj]) + sys_data = np.concatenate(sys_data).reshape(-1, self.numb_dos) + sys_dos.append(np.average(sys_data, axis=0)) + sys_dos = np.array(sys_dos).reshape(-1, self.numb_dos) + sys_tynatom = [] + if mixed_type: + data = all_stat["real_natoms_vec"] + nsys = len(data) + for ss in range(len(data)): + tmp_tynatom = [] + for ii in range(len(data[ss])): + for jj in range(len(data[ss][ii])): + tmp_tynatom.append(data[ss][ii][jj].astype(np.float64)) + tmp_tynatom = np.average(np.array(tmp_tynatom), axis=0) + sys_tynatom.append(tmp_tynatom) + else: + data = all_stat["natoms_vec"] + nsys = len(data) + for ss in range(len(data)): + sys_tynatom.append(data[ss][0].astype(np.float64)) + sys_tynatom = np.array(sys_tynatom) + sys_tynatom = np.reshape(sys_tynatom, [nsys, -1]) + sys_tynatom = sys_tynatom[:, 2:] + + dos_shift, resd, rank, s_value = np.linalg.lstsq( + sys_tynatom, sys_dos, rcond=rcond + ) + + return dos_shift + + def compute_input_stats(self, all_stat: dict, protection: float = 1e-2) -> None: + """Compute the input statistics. + + Parameters + ---------- + all_stat + if numb_fparam > 0 must have all_stat['fparam'] + if numb_aparam > 0 must have all_stat['aparam'] + can be prepared by model.make_stat_input + protection + Divided-by-zero protection + """ + # stat fparam + if self.numb_fparam > 0: + cat_data = np.concatenate(all_stat["fparam"], axis=0) + cat_data = np.reshape(cat_data, [-1, self.numb_fparam]) + self.fparam_avg = np.average(cat_data, axis=0) + self.fparam_std = np.std(cat_data, axis=0) + for ii in range(self.fparam_std.size): + if self.fparam_std[ii] < protection: + self.fparam_std[ii] = protection + self.fparam_inv_std = 1.0 / self.fparam_std + # stat aparam + if self.numb_aparam > 0: + sys_sumv = [] + sys_sumv2 = [] + sys_sumn = [] + for ss_ in all_stat["aparam"]: + ss = np.reshape(ss_, [-1, self.numb_aparam]) + sys_sumv.append(np.sum(ss, axis=0)) + sys_sumv2.append(np.sum(np.multiply(ss, ss), axis=0)) + sys_sumn.append(ss.shape[0]) + sumv = np.sum(sys_sumv, axis=0) + sumv2 = np.sum(sys_sumv2, axis=0) + sumn = np.sum(sys_sumn) + self.aparam_avg = (sumv) / sumn + self.aparam_std = self._compute_std(sumv2, sumv, sumn) + for ii in range(self.aparam_std.size): + if self.aparam_std[ii] < protection: + self.aparam_std[ii] = protection + self.aparam_inv_std = 1.0 / self.aparam_std + + def _compute_std(self, sumv2, sumv, sumn): + return np.sqrt(sumv2 / sumn - np.multiply(sumv / sumn, sumv / sumn)) + + @cast_precision + def _build_lower( + self, + start_index, + natoms, + inputs, + fparam=None, + aparam=None, + bias_dos=0.0, + type_suffix="", + suffix="", + reuse=None, + ): + # cut-out inputs + inputs_i = tf.slice(inputs, [0, start_index, 0], [-1, natoms, -1]) + inputs_i = tf.reshape(inputs_i, [-1, self.dim_descrpt]) + layer = inputs_i + if fparam is not None: + ext_fparam = tf.tile(fparam, [1, natoms]) + ext_fparam = tf.reshape(ext_fparam, [-1, self.numb_fparam]) + ext_fparam = tf.cast(ext_fparam, self.fitting_precision) + layer = tf.concat([layer, ext_fparam], axis=1) + if aparam is not None: + ext_aparam = tf.slice( + aparam, + [0, start_index * self.numb_aparam], + [-1, natoms * self.numb_aparam], + ) + ext_aparam = tf.reshape(ext_aparam, [-1, self.numb_aparam]) + ext_aparam = tf.cast(ext_aparam, self.fitting_precision) + layer = tf.concat([layer, ext_aparam], axis=1) + + if nvnmd_cfg.enable: + one_layer = one_layer_nvnmd + else: + one_layer = one_layer_deepmd + for ii in range(0, len(self.n_neuron)): + if self.layer_name is not None and self.layer_name[ii] is not None: + layer_suffix = "share_" + self.layer_name[ii] + type_suffix + layer_reuse = tf.AUTO_REUSE + else: + layer_suffix = "layer_" + str(ii) + type_suffix + suffix + layer_reuse = reuse + if ii >= 1 and self.n_neuron[ii] == self.n_neuron[ii - 1]: + layer += one_layer( + layer, + self.n_neuron[ii], + name=layer_suffix, + reuse=layer_reuse, + seed=self.seed, + use_timestep=self.resnet_dt, + activation_fn=self.fitting_activation_fn, + precision=self.fitting_precision, + trainable=self.trainable[ii], + uniform_seed=self.uniform_seed, + initial_variables=self.fitting_net_variables, + mixed_prec=self.mixed_prec, + ) + else: + layer = one_layer( + layer, + self.n_neuron[ii], + name=layer_suffix, + reuse=layer_reuse, + seed=self.seed, + activation_fn=self.fitting_activation_fn, + precision=self.fitting_precision, + trainable=self.trainable[ii], + uniform_seed=self.uniform_seed, + initial_variables=self.fitting_net_variables, + mixed_prec=self.mixed_prec, + ) + if (not self.uniform_seed) and (self.seed is not None): + self.seed += self.seed_shift + if self.layer_name is not None and self.layer_name[-1] is not None: + layer_suffix = "share_" + self.layer_name[-1] + type_suffix + layer_reuse = tf.AUTO_REUSE + else: + layer_suffix = "final_layer" + type_suffix + suffix + layer_reuse = reuse + final_layer = one_layer( + layer, + self.numb_dos, # TODO: output a vector + activation_fn=None, + bavg=bias_dos, + name=layer_suffix, + reuse=layer_reuse, + seed=self.seed, + precision=self.fitting_precision, + trainable=self.trainable[-1], + uniform_seed=self.uniform_seed, + initial_variables=self.fitting_net_variables, + mixed_prec=self.mixed_prec, + final_layer=True, + ) + if (not self.uniform_seed) and (self.seed is not None): + self.seed += self.seed_shift + + return final_layer + + def build( + self, + inputs: tf.Tensor, + natoms: tf.Tensor, + input_dict: dict = None, + reuse: bool = None, + suffix: str = "", + ) -> tf.Tensor: + """Build the computational graph for fitting net. + + Parameters + ---------- + inputs + The input descriptor + input_dict + Additional dict for inputs. + if numb_fparam > 0, should have input_dict['fparam'] + if numb_aparam > 0, should have input_dict['aparam'] + natoms + The number of atoms. This tensor has the length of Ntypes + 2 + natoms[0]: number of local atoms + natoms[1]: total number of atoms held by this processor + natoms[i]: 2 <= i < Ntypes+2, number of type i atoms + reuse + The weights in the networks should be reused when get the variable. + suffix + Name suffix to identify this descriptor + + Returns + ------- + ener + The system energy + """ + if input_dict is None: + input_dict = {} + bias_dos = self.bias_dos + type_embedding = input_dict.get("type_embedding", None) + atype = input_dict.get("atype", None) + if self.numb_fparam > 0: + if self.fparam_avg is None: + self.fparam_avg = 0.0 + if self.fparam_inv_std is None: + self.fparam_inv_std = 1.0 + if self.numb_aparam > 0: + if self.aparam_avg is None: + self.aparam_avg = 0.0 + if self.aparam_inv_std is None: + self.aparam_inv_std = 1.0 + + with tf.variable_scope("fitting_attr" + suffix, reuse=reuse): + t_dfparam = tf.constant(self.numb_fparam, name="dfparam", dtype=tf.int32) + t_daparam = tf.constant(self.numb_aparam, name="daparam", dtype=tf.int32) + t_numb_dos = tf.constant(self.numb_dos, name="numb_dos", dtype=tf.int32) + + self.t_bias_dos = tf.get_variable( + "t_bias_dos", + self.bias_dos.shape, + dtype=GLOBAL_TF_FLOAT_PRECISION, + trainable=False, + initializer=tf.constant_initializer(self.bias_dos), + ) + if self.numb_fparam > 0: + t_fparam_avg = tf.get_variable( + "t_fparam_avg", + self.numb_fparam, + dtype=GLOBAL_TF_FLOAT_PRECISION, + trainable=False, + initializer=tf.constant_initializer(self.fparam_avg), + ) + t_fparam_istd = tf.get_variable( + "t_fparam_istd", + self.numb_fparam, + dtype=GLOBAL_TF_FLOAT_PRECISION, + trainable=False, + initializer=tf.constant_initializer(self.fparam_inv_std), + ) + if self.numb_aparam > 0: + t_aparam_avg = tf.get_variable( + "t_aparam_avg", + self.numb_aparam, + dtype=GLOBAL_TF_FLOAT_PRECISION, + trainable=False, + initializer=tf.constant_initializer(self.aparam_avg), + ) + t_aparam_istd = tf.get_variable( + "t_aparam_istd", + self.numb_aparam, + dtype=GLOBAL_TF_FLOAT_PRECISION, + trainable=False, + initializer=tf.constant_initializer(self.aparam_inv_std), + ) + + inputs = tf.reshape(inputs, [-1, natoms[0], self.dim_descrpt]) + + if bias_dos is not None: + assert len(bias_dos) == self.ntypes + + fparam = None + if self.numb_fparam > 0: + fparam = input_dict["fparam"] + fparam = tf.reshape(fparam, [-1, self.numb_fparam]) + fparam = (fparam - t_fparam_avg) * t_fparam_istd + + aparam = None + if not self.use_aparam_as_mask: + if self.numb_aparam > 0: + aparam = input_dict["aparam"] + aparam = tf.reshape(aparam, [-1, self.numb_aparam]) + aparam = (aparam - t_aparam_avg) * t_aparam_istd + aparam = tf.reshape(aparam, [-1, self.numb_aparam * natoms[0]]) + + atype_nall = tf.reshape(atype, [-1, natoms[1]]) + self.atype_nloc = tf.reshape( + tf.slice(atype_nall, [0, 0], [-1, natoms[0]]), [-1] + ) ## lammps will make error + if type_embedding is not None: + atype_embed = tf.nn.embedding_lookup(type_embedding, self.atype_nloc) + else: + atype_embed = None + + self.atype_embed = atype_embed + + if atype_embed is None: + start_index = 0 + outs_list = [] + for type_i in range(self.ntypes): + final_layer = self._build_lower( + start_index, + natoms[2 + type_i], + inputs, + fparam, + aparam, + bias_dos=0.0, + type_suffix="_type_" + str(type_i), + suffix=suffix, + reuse=reuse, + ) + + final_layer = tf.reshape( + final_layer, + [tf.shape(inputs)[0] * self.numb_dos, natoms[2 + type_i]], + ) + outs_list.append(final_layer) + start_index += natoms[2 + type_i] + # concat the results + # concat once may be faster than multiple concat + outs = tf.concat(outs_list, axis=1) + # with type embedding + else: + atype_embed = tf.cast(atype_embed, GLOBAL_TF_FLOAT_PRECISION) + type_shape = atype_embed.get_shape().as_list() + inputs = tf.concat( + [tf.reshape(inputs, [-1, self.dim_descrpt]), atype_embed], axis=1 + ) + original_dim_descrpt = self.dim_descrpt + self.dim_descrpt = self.dim_descrpt + type_shape[1] + inputs = tf.reshape(inputs, [-1, natoms[0], self.dim_descrpt]) + final_layer = self._build_lower( + 0, + natoms[0], + inputs, + fparam, + aparam, + bias_dos=0.0, + suffix=suffix, + reuse=reuse, + ) + + outs = tf.reshape( + final_layer, [tf.shape(inputs)[0] * self.numb_dos, natoms[0]] + ) + # add bias + # self.atom_ener_before = outs + # self.add_type = tf.reshape( + # tf.nn.embedding_lookup(self.t_bias_dos, self.atype_nloc), + # [tf.shape(inputs)[0], natoms[0]], + # ) + # outs = outs + self.add_type + # self.atom_ener_after = outs + + tf.summary.histogram("fitting_net_output", outs) + return tf.reshape(outs, [-1]) + + def init_variables( + self, + graph: tf.Graph, + graph_def: tf.GraphDef, + suffix: str = "", + ) -> None: + """Init the fitting net variables with the given dict. + + Parameters + ---------- + graph : tf.Graph + The input frozen model graph + graph_def : tf.GraphDef + The input frozen model graph_def + suffix : str + suffix to name scope + """ + self.fitting_net_variables = get_fitting_net_variables_from_graph_def( + graph_def, suffix=suffix + ) + if self.layer_name is not None: + # shared variables have no suffix + shared_variables = get_fitting_net_variables_from_graph_def( + graph_def, suffix="" + ) + self.fitting_net_variables.update(shared_variables) + if self.numb_fparam > 0: + self.fparam_avg = get_tensor_by_name_from_graph( + graph, "fitting_attr%s/t_fparam_avg" % suffix + ) + self.fparam_inv_std = get_tensor_by_name_from_graph( + graph, "fitting_attr%s/t_fparam_istd" % suffix + ) + if self.numb_aparam > 0: + self.aparam_avg = get_tensor_by_name_from_graph( + graph, "fitting_attr%s/t_aparam_avg" % suffix + ) + self.aparam_inv_std = get_tensor_by_name_from_graph( + graph, "fitting_attr%s/t_aparam_istd" % suffix + ) + try: + self.bias_dos = get_tensor_by_name_from_graph( + graph, "fitting_attr%s/t_bias_dos" % suffix + ) + except GraphWithoutTensorError: + # for compatibility, old models has no t_bias_dos + pass + + def enable_mixed_precision(self, mixed_prec: Optional[dict] = None) -> None: + """Reveive the mixed precision setting. + + Parameters + ---------- + mixed_prec + The mixed precision setting used in the embedding net + """ + self.mixed_prec = mixed_prec + self.fitting_precision = get_precision(mixed_prec["output_prec"]) diff --git a/deepmd/infer/__init__.py b/deepmd/infer/__init__.py index f89eb560cd..f87541c889 100644 --- a/deepmd/infer/__init__.py +++ b/deepmd/infer/__init__.py @@ -13,6 +13,9 @@ from .deep_dipole import ( DeepDipole, ) +from .deep_dos import ( + DeepDOS, +) from .deep_eval import ( DeepEval, ) @@ -40,6 +43,7 @@ "DeepGlobalPolar", "DeepPolar", "DeepPot", + "DeepDOS", "DeepWFC", "DipoleChargeModifier", "EwaldRecp", @@ -51,7 +55,7 @@ def DeepPotential( model_file: Union[str, Path], load_prefix: str = "load", default_tf_graph: bool = False, -) -> Union[DeepDipole, DeepGlobalPolar, DeepPolar, DeepPot, DeepWFC]: +) -> Union[DeepDipole, DeepGlobalPolar, DeepPolar, DeepPot, DeepDOS, DeepWFC]: """Factory function that will inialize appropriate potential read from `model_file`. Parameters @@ -81,6 +85,8 @@ def DeepPotential( if model_type == "ener": dp = DeepPot(mf, load_prefix=load_prefix, default_tf_graph=default_tf_graph) + elif model_type == "dos": + dp = DeepDOS(mf, load_prefix=load_prefix, default_tf_graph=default_tf_graph) elif model_type == "dipole": dp = DeepDipole(mf, load_prefix=load_prefix, default_tf_graph=default_tf_graph) elif model_type == "polar": diff --git a/deepmd/infer/deep_dos.py b/deepmd/infer/deep_dos.py new file mode 100644 index 0000000000..2f6dc83d00 --- /dev/null +++ b/deepmd/infer/deep_dos.py @@ -0,0 +1,506 @@ +import logging +from typing import ( + TYPE_CHECKING, + Callable, + List, + Optional, + Tuple, + Union, +) + +import numpy as np + +from deepmd.common import ( + make_default_mesh, +) +from deepmd.infer.deep_eval import ( + DeepEval, +) +from deepmd.utils.batch_size import ( + AutoBatchSize, +) +from deepmd.utils.sess import ( + run_sess, +) + +if TYPE_CHECKING: + from pathlib import ( + Path, + ) + +log = logging.getLogger(__name__) + + +class DeepDOS(DeepEval): + """Constructor. + + Parameters + ---------- + model_file : Path + The name of the frozen model file. + load_prefix: str + The prefix in the load computational graph + default_tf_graph : bool + If uses the default tf graph, otherwise build a new tf graph for evaluation + auto_batch_size : bool or int or AutomaticBatchSize, default: True + If True, automatic batch size will be used. If int, it will be used + as the initial batch size. + + Warnings + -------- + For developers: `DeepTensor` initializer must be called at the end after + `self.tensors` are modified because it uses the data in `self.tensors` dict. + Do not chanage the order! + """ + + def __init__( + self, + model_file: "Path", + load_prefix: str = "load", + default_tf_graph: bool = False, + auto_batch_size: Union[bool, int, AutoBatchSize] = True, + ) -> None: + # add these tensors on top of what is defined by DeepTensor Class + # use this in favor of dict update to move attribute from class to + # instance namespace + self.tensors = dict( + { + # descrpt attrs + "t_ntypes": "descrpt_attr/ntypes:0", + "t_rcut": "descrpt_attr/rcut:0", + # fitting attrs + "t_dfparam": "fitting_attr/dfparam:0", + "t_daparam": "fitting_attr/daparam:0", + "t_numb_dos": "fitting_attr/numb_dos:0", + # model attrs + "t_tmap": "model_attr/tmap:0", + # inputs + "t_coord": "t_coord:0", + "t_type": "t_type:0", + "t_natoms": "t_natoms:0", + "t_box": "t_box:0", + "t_mesh": "t_mesh:0", + # add output tensors + "t_dos": "o_dos:0", + "t_atom_dos": "o_atom_dos:0", + "t_descriptor": "o_descriptor:0", + }, + ) + DeepEval.__init__( + self, + model_file, + load_prefix=load_prefix, + default_tf_graph=default_tf_graph, + auto_batch_size=auto_batch_size, + ) + + # load optional tensors + operations = [op.name for op in self.graph.get_operations()] + # check if the graph has these operations: + # if yes add them + if "load/t_fparam" in operations: + self.tensors.update({"t_fparam": "t_fparam:0"}) + self.has_fparam = True + else: + log.debug("Could not get tensor 't_fparam:0'") + self.t_fparam = None + self.has_fparam = False + + if "load/t_aparam" in operations: + self.tensors.update({"t_aparam": "t_aparam:0"}) + self.has_aparam = True + else: + log.debug("Could not get tensor 't_aparam:0'") + self.t_aparam = None + self.has_aparam = False + + # now load tensors to object attributes + for attr_name, tensor_name in self.tensors.items(): + try: + self._get_tensor(tensor_name, attr_name) + except KeyError: + if attr_name != "t_descriptor": + raise + + self._run_default_sess() + self.tmap = self.tmap.decode("UTF-8").split() + + # setup modifier + try: + t_modifier_type = self._get_tensor("modifier_attr/type:0") + self.modifier_type = run_sess(self.sess, t_modifier_type).decode("UTF-8") + except (ValueError, KeyError): + self.modifier_type = None + + def _run_default_sess(self): + [ + self.ntypes, + self.rcut, + self.numb_dos, + self.dfparam, + self.daparam, + self.tmap, + ] = run_sess( + self.sess, + [ + self.t_ntypes, + self.t_rcut, + self.t_numb_dos, + self.t_dfparam, + self.t_daparam, + self.t_tmap, + ], + ) + + def get_ntypes(self) -> int: + """Get the number of atom types of this model.""" + return self.ntypes + + def get_rcut(self) -> float: + """Get the cut-off radius of this model.""" + return self.rcut + + def get_numb_dos(self) -> int: + """Get the length of DOS output of this DP model.""" + return self.numb_dos + + def get_type_map(self) -> List[str]: + """Get the type map (element name of the atom types) of this model.""" + return self.tmap + + def get_sel_type(self) -> List[int]: + """Unsupported in this model.""" + raise NotImplementedError("This model type does not support this attribute") + + def get_dim_fparam(self) -> int: + """Get the number (dimension) of frame parameters of this DP.""" + return self.dfparam + + def get_dim_aparam(self) -> int: + """Get the number (dimension) of atomic parameters of this DP.""" + return self.daparam + + def _eval_func(self, inner_func: Callable, numb_test: int, natoms: int) -> Callable: + """Wrapper method with auto batch size. + + Parameters + ---------- + inner_func : Callable + the method to be wrapped + numb_test : int + number of tests + natoms : int + number of atoms + + Returns + ------- + Callable + the wrapper + """ + if self.auto_batch_size is not None: + + def eval_func(*args, **kwargs): + return self.auto_batch_size.execute_all( + inner_func, numb_test, natoms, *args, **kwargs + ) + + else: + eval_func = inner_func + return eval_func + + def _get_natoms_and_nframes( + self, + coords: np.ndarray, + atom_types: Union[List[int], np.ndarray], + mixed_type: bool = False, + ) -> Tuple[int, int]: + if mixed_type: + natoms = len(atom_types[0]) + else: + natoms = len(atom_types) + coords = np.reshape(np.array(coords), [-1, natoms * 3]) + nframes = coords.shape[0] + return natoms, nframes + + def eval( + self, + coords: np.ndarray, + cells: np.ndarray, + atom_types: List[int], + atomic: bool = False, + fparam: Optional[np.ndarray] = None, + aparam: Optional[np.ndarray] = None, + mixed_type: bool = False, + ) -> Tuple[np.ndarray, ...]: + """Evaluate the dos, atom_dos by using this model. + + Parameters + ---------- + coords + The coordinates of atoms. + The array should be of size nframes x natoms x 3 + cells + The cell of the region. + If None then non-PBC is assumed, otherwise using PBC. + The array should be of size nframes x 9 + atom_types + The atom types + The list should contain natoms ints + atomic + Calculate the atomic energy and virial + fparam + The frame parameter. + The array can be of size : + - nframes x dim_fparam. + - dim_fparam. Then all frames are assumed to be provided with the same fparam. + aparam + The atomic parameter + The array can be of size : + - nframes x natoms x dim_aparam. + - natoms x dim_aparam. Then all frames are assumed to be provided with the same aparam. + - dim_aparam. Then all frames and atoms are provided with the same aparam. + mixed_type + Whether to perform the mixed_type mode. + If True, the input data has the mixed_type format (see doc/model/train_se_atten.md), + in which frames in a system may have different natoms_vec(s), with the same nloc. + + Returns + ------- + dos + The electron density of state. + atom_dos + The atom-sited density of state. Only returned when atomic == True + """ + # reshape coords before getting shape + natoms, numb_test = self._get_natoms_and_nframes( + coords, atom_types, mixed_type=mixed_type + ) + output = self._eval_func(self._eval_inner, numb_test, natoms)( + coords, + cells, + atom_types, + fparam=fparam, + aparam=aparam, + atomic=atomic, + mixed_type=mixed_type, + ) + + return output + + def _prepare_feed_dict( + self, + coords, + cells, + atom_types, + fparam=None, + aparam=None, + atomic=False, + mixed_type=False, + ): + # standarize the shape of inputs + natoms, nframes = self._get_natoms_and_nframes( + coords, atom_types, mixed_type=mixed_type + ) + if mixed_type: + atom_types = np.array(atom_types, dtype=int).reshape([-1, natoms]) + else: + atom_types = np.array(atom_types, dtype=int).reshape([-1]) + coords = np.reshape(np.array(coords), [-1, natoms * 3]) + if cells is None: + pbc = False + # make cells to work around the requirement of pbc + cells = np.tile(np.eye(3), [nframes, 1]).reshape([nframes, 9]) + else: + pbc = True + cells = np.array(cells).reshape([nframes, 9]) + + if self.has_fparam: + assert fparam is not None + fparam = np.array(fparam) + if self.has_aparam: + assert aparam is not None + aparam = np.array(aparam) + + # reshape the inputs + if self.has_fparam: + fdim = self.get_dim_fparam() + if fparam.size == nframes * fdim: + fparam = np.reshape(fparam, [nframes, fdim]) + elif fparam.size == fdim: + fparam = np.tile(fparam.reshape([-1]), [nframes, 1]) + else: + raise RuntimeError( + "got wrong size of frame param, should be either %d x %d or %d" + % (nframes, fdim, fdim) + ) + if self.has_aparam: + fdim = self.get_dim_aparam() + if aparam.size == nframes * natoms * fdim: + aparam = np.reshape(aparam, [nframes, natoms * fdim]) + elif aparam.size == natoms * fdim: + aparam = np.tile(aparam.reshape([-1]), [nframes, 1]) + elif aparam.size == fdim: + aparam = np.tile(aparam.reshape([-1]), [nframes, natoms]) + else: + raise RuntimeError( + "got wrong size of frame param, should be either %d x %d x %d or %d x %d or %d" + % (nframes, natoms, fdim, natoms, fdim, fdim) + ) + + # sort inputs + coords, atom_types, imap = self.sort_input( + coords, atom_types, mixed_type=mixed_type + ) + + # make natoms_vec and default_mesh + natoms_vec = self.make_natoms_vec(atom_types, mixed_type=mixed_type) + assert natoms_vec[0] == natoms + + # evaluate + feed_dict_test = {} + feed_dict_test[self.t_natoms] = natoms_vec + if mixed_type: + feed_dict_test[self.t_type] = atom_types.reshape([-1]) + else: + feed_dict_test[self.t_type] = np.tile(atom_types, [nframes, 1]).reshape( + [-1] + ) + feed_dict_test[self.t_coord] = np.reshape(coords, [-1]) + + if len(self.t_box.shape) == 1: + feed_dict_test[self.t_box] = np.reshape(cells, [-1]) + elif len(self.t_box.shape) == 2: + feed_dict_test[self.t_box] = cells + else: + raise RuntimeError + if pbc: + feed_dict_test[self.t_mesh] = make_default_mesh(cells) + else: + feed_dict_test[self.t_mesh] = np.array([], dtype=np.int32) + if self.has_fparam: + feed_dict_test[self.t_fparam] = np.reshape(fparam, [-1]) + if self.has_aparam: + feed_dict_test[self.t_aparam] = np.reshape(aparam, [-1]) + return feed_dict_test, imap + + def _eval_inner( + self, + coords, + cells, + atom_types, + fparam=None, + aparam=None, + atomic=False, + mixed_type=False, + ): + natoms, nframes = self._get_natoms_and_nframes( + coords, atom_types, mixed_type=mixed_type + ) + feed_dict_test, imap = self._prepare_feed_dict( + coords, cells, atom_types, fparam, aparam, mixed_type=mixed_type + ) + t_out = [self.t_dos] + if atomic: + t_out += [self.t_atom_dos] + + v_out = run_sess(self.sess, t_out, feed_dict=feed_dict_test) + dos = v_out[0] + if atomic: + atom_dos = v_out[1] + + # reverse map of the outputs + if atomic: + atom_dos = self.reverse_map( + np.reshape(atom_dos, [nframes, -1, self.numb_dos]), imap + ) + dos = np.sum(atom_dos, axis=1) + + dos = np.reshape(dos, [nframes, self.numb_dos]) + if atomic: + atom_dos = np.reshape(atom_dos, [nframes, natoms, self.numb_dos]) + return dos, atom_dos + else: + return dos + + def eval_descriptor( + self, + coords: np.ndarray, + cells: np.ndarray, + atom_types: List[int], + fparam: Optional[np.ndarray] = None, + aparam: Optional[np.ndarray] = None, + efield: Optional[np.ndarray] = None, + mixed_type: bool = False, + ) -> np.array: + """Evaluate descriptors by using this DP. + + Parameters + ---------- + coords + The coordinates of atoms. + The array should be of size nframes x natoms x 3 + cells + The cell of the region. + If None then non-PBC is assumed, otherwise using PBC. + The array should be of size nframes x 9 + atom_types + The atom types + The list should contain natoms ints + fparam + The frame parameter. + The array can be of size : + - nframes x dim_fparam. + - dim_fparam. Then all frames are assumed to be provided with the same fparam. + aparam + The atomic parameter + The array can be of size : + - nframes x natoms x dim_aparam. + - natoms x dim_aparam. Then all frames are assumed to be provided with the same aparam. + - dim_aparam. Then all frames and atoms are provided with the same aparam. + efield + The external field on atoms. + The array should be of size nframes x natoms x 3 + mixed_type + Whether to perform the mixed_type mode. + If True, the input data has the mixed_type format (see doc/model/train_se_atten.md), + in which frames in a system may have different natoms_vec(s), with the same nloc. + + Returns + ------- + descriptor + Descriptors. + """ + natoms, numb_test = self._get_natoms_and_nframes( + coords, atom_types, mixed_type=mixed_type + ) + descriptor = self._eval_func(self._eval_descriptor_inner, numb_test, natoms)( + coords, + cells, + atom_types, + fparam=fparam, + aparam=aparam, + efield=efield, + mixed_type=mixed_type, + ) + return descriptor + + def _eval_descriptor_inner( + self, + coords: np.ndarray, + cells: np.ndarray, + atom_types: List[int], + fparam: Optional[np.ndarray] = None, + aparam: Optional[np.ndarray] = None, + efield: Optional[np.ndarray] = None, + mixed_type: bool = False, + ) -> np.array: + natoms, nframes = self._get_natoms_and_nframes( + coords, atom_types, mixed_type=mixed_type + ) + feed_dict_test, imap = self._prepare_feed_dict( + coords, cells, atom_types, fparam, aparam, efield, mixed_type=mixed_type + ) + (descriptor,) = run_sess( + self.sess, [self.t_descriptor], feed_dict=feed_dict_test + ) + return self.reverse_map(np.reshape(descriptor, [nframes, natoms, -1]), imap) diff --git a/deepmd/loss/__init__.py b/deepmd/loss/__init__.py index 452d21f54e..6f0b7c4eac 100644 --- a/deepmd/loss/__init__.py +++ b/deepmd/loss/__init__.py @@ -1,3 +1,6 @@ +from .dos import ( + DOSLoss, +) from .ener import ( EnerDipoleLoss, EnerStdLoss, @@ -9,5 +12,6 @@ __all__ = [ "EnerDipoleLoss", "EnerStdLoss", + "DOSLoss", "TensorLoss", ] diff --git a/deepmd/loss/dos.py b/deepmd/loss/dos.py new file mode 100644 index 0000000000..5a7e67e29c --- /dev/null +++ b/deepmd/loss/dos.py @@ -0,0 +1,208 @@ +import numpy as np + +from deepmd.common import ( + add_data_requirement, +) +from deepmd.env import ( + global_cvt_2_ener_float, + global_cvt_2_tf_float, + tf, +) +from deepmd.utils.sess import ( + run_sess, +) + +from .loss import ( + Loss, +) + + +class DOSLoss(Loss): + """Loss function for DeepDOS models.""" + + def __init__( + self, + starter_learning_rate: float, + numb_dos: int = 500, + start_pref_dos: float = 1.00, + limit_pref_dos: float = 1.00, + start_pref_cdf: float = 1000, + limit_pref_cdf: float = 1.00, + start_pref_ados: float = 0.0, + limit_pref_ados: float = 0.0, + start_pref_acdf: float = 0.0, + limit_pref_acdf: float = 0.0, + protect_value: float = 1e-8, + log_fit: bool = False, + ) -> None: + self.starter_learning_rate = starter_learning_rate + self.numb_dos = numb_dos + self.protect_value = protect_value + self.log_fit = log_fit + + self.start_pref_dos = start_pref_dos + self.limit_pref_dos = limit_pref_dos + self.start_pref_cdf = start_pref_cdf + self.limit_pref_cdf = limit_pref_cdf + + self.start_pref_ados = start_pref_ados + self.limit_pref_ados = limit_pref_ados + self.start_pref_acdf = start_pref_acdf + self.limit_pref_acdf = limit_pref_acdf + + self.has_dos = self.start_pref_dos != 0.0 or self.limit_pref_dos != 0.0 + self.has_cdf = self.start_pref_cdf != 0.0 or self.limit_pref_cdf != 0.0 + self.has_ados = self.start_pref_ados != 0.0 or self.limit_pref_ados != 0.0 + self.has_acdf = self.start_pref_acdf != 0.0 or self.limit_pref_acdf != 0.0 + # data required + add_data_requirement( + "dos", self.numb_dos, atomic=False, must=True, high_prec=True + ) + add_data_requirement( + "atom_dos", self.numb_dos, atomic=True, must=False, high_prec=True + ) + + def build(self, learning_rate, natoms, model_dict, label_dict, suffix): + dos = model_dict["dos"] + atom_dos = model_dict["atom_dos"] + + dos_hat = label_dict["dos"] + atom_dos_hat = label_dict["atom_dos"] + + find_dos = label_dict["find_dos"] + find_atom_dos = label_dict["find_atom_dos"] + + dos_reshape = tf.reshape(dos, [-1, self.numb_dos]) + dos_hat_reshape = tf.reshape(dos_hat, [-1, self.numb_dos]) + diff_dos = dos_hat_reshape - dos_reshape + if self.has_dos: + l2_dos_loss = tf.reduce_mean(tf.square(diff_dos), name="l2_dos_" + suffix) + if self.has_cdf: + cdf = tf.cumsum(dos_reshape, axis=1) + cdf_hat = tf.cumsum(dos_hat_reshape, axis=1) + diff_cdf = cdf_hat - cdf + l2_cdf_loss = tf.reduce_mean(tf.square(diff_cdf), name="l2_cdf_" + suffix) + + atom_dos_reshape = tf.reshape(atom_dos, [-1, self.numb_dos]) + atom_dos_hat_reshape = tf.reshape(atom_dos_hat, [-1, self.numb_dos]) + diff_atom_dos = atom_dos_hat_reshape - atom_dos_reshape + if self.has_ados: + l2_atom_dos_loss = tf.reduce_mean( + tf.square(diff_atom_dos), name="l2_ados_" + suffix + ) + if self.has_acdf: + atom_cdf = tf.cumsum(atom_dos_reshape, axis=1) + atom_cdf_hat = tf.cumsum(atom_dos_hat_reshape, axis=1) + diff_atom_cdf = atom_cdf_hat - atom_cdf + l2_atom_cdf_loss = tf.reduce_mean( + tf.square(diff_atom_cdf), name="l2_acdf_" + suffix + ) + + atom_norm = 1.0 / global_cvt_2_tf_float(natoms[0]) + atom_norm_ener = 1.0 / global_cvt_2_ener_float(natoms[0]) + pref_dos = global_cvt_2_ener_float( + find_dos + * ( + self.limit_pref_dos + + (self.start_pref_dos - self.limit_pref_dos) + * learning_rate + / self.starter_learning_rate + ) + ) + pref_cdf = global_cvt_2_tf_float( + find_dos + * ( + self.limit_pref_cdf + + (self.start_pref_cdf - self.limit_pref_cdf) + * learning_rate + / self.starter_learning_rate + ) + ) + pref_ados = global_cvt_2_tf_float( + find_atom_dos + * ( + self.limit_pref_ados + + (self.start_pref_ados - self.limit_pref_ados) + * learning_rate + / self.starter_learning_rate + ) + ) + pref_acdf = global_cvt_2_tf_float( + find_atom_dos + * ( + self.limit_pref_acdf + + (self.start_pref_acdf - self.limit_pref_acdf) + * learning_rate + / self.starter_learning_rate + ) + ) + + l2_loss = 0 + more_loss = {} + if self.has_dos: + l2_loss += atom_norm_ener * (pref_dos * l2_dos_loss) + more_loss["l2_dos_loss"] = l2_dos_loss + if self.has_cdf: + l2_loss += atom_norm_ener * (pref_cdf * l2_cdf_loss) + more_loss["l2_cdf_loss"] = l2_cdf_loss + if self.has_ados: + l2_loss += global_cvt_2_ener_float(pref_ados * l2_atom_dos_loss) + more_loss["l2_atom_dos_loss"] = l2_atom_dos_loss + if self.has_acdf: + l2_loss += global_cvt_2_ener_float(pref_acdf * l2_atom_cdf_loss) + more_loss["l2_atom_cdf_loss"] = l2_atom_cdf_loss + + # only used when tensorboard was set as true + self.l2_loss_summary = tf.summary.scalar("l2_loss_" + suffix, tf.sqrt(l2_loss)) + if self.has_dos: + self.l2_loss_dos_summary = tf.summary.scalar( + "l2_dos_loss_" + suffix, + global_cvt_2_tf_float(tf.sqrt(l2_dos_loss)) + / global_cvt_2_tf_float(natoms[0]), + ) + if self.has_cdf: + self.l2_loss_cdf_summary = tf.summary.scalar( + "l2_cdf_loss_" + suffix, + global_cvt_2_tf_float(tf.sqrt(l2_cdf_loss)) + / global_cvt_2_tf_float(natoms[0]), + ) + if self.has_ados: + self.l2_loss_ados_summary = tf.summary.scalar( + "l2_atom_dos_loss_" + suffix, + global_cvt_2_tf_float(tf.sqrt(l2_atom_dos_loss)) + / global_cvt_2_tf_float(natoms[0]), + ) + if self.has_acdf: + self.l2_loss_acdf_summary = tf.summary.scalar( + "l2_atom_cdf_loss_" + suffix, + global_cvt_2_tf_float(tf.sqrt(l2_atom_cdf_loss)) + / global_cvt_2_tf_float(natoms[0]), + ) + + self.l2_l = l2_loss + self.l2_more = more_loss + return l2_loss, more_loss + + def eval(self, sess, feed_dict, natoms): + placeholder = self.l2_l + run_data = [ + self.l2_l, + self.l2_more["l2_dos_loss"] if self.has_dos else placeholder, + self.l2_more["l2_cdf_loss"] if self.has_cdf else placeholder, + self.l2_more["l2_atom_dos_loss"] if self.has_ados else placeholder, + self.l2_more["l2_atom_cdf_loss"] if self.has_acdf else placeholder, + ] + error, error_dos, error_cdf, error_ados, error_acdf = run_sess( + sess, run_data, feed_dict=feed_dict + ) + results = {"natoms": natoms[0], "rmse": np.sqrt(error)} + if self.has_dos: + results["rmse_dos"] = np.sqrt(error_dos) / natoms[0] + if self.has_ados: + results["rmse_ados"] = np.sqrt(error_ados) + if self.has_cdf: + results["rmse_cdf"] = np.sqrt(error_cdf) / natoms[0] + if self.has_acdf: + results["rmse_acdf"] = np.sqrt(error_acdf) + + return results diff --git a/deepmd/model/__init__.py b/deepmd/model/__init__.py index 47e7675c43..43f4b4a3a9 100644 --- a/deepmd/model/__init__.py +++ b/deepmd/model/__init__.py @@ -1,3 +1,6 @@ +from .dos import ( + DOSModel, +) from .ener import ( EnerModel, ) @@ -13,6 +16,7 @@ __all__ = [ "EnerModel", + "DOSModel", "MultiModel", "DipoleModel", "GlobalPolarModel", diff --git a/deepmd/model/dos.py b/deepmd/model/dos.py new file mode 100644 index 0000000000..0da709409f --- /dev/null +++ b/deepmd/model/dos.py @@ -0,0 +1,219 @@ +from typing import ( + List, + Optional, +) + +from deepmd.env import ( + MODEL_VERSION, + global_cvt_2_ener_float, + tf, +) + +from .model import ( + Model, +) +from .model_stat import ( + make_stat_input, + merge_sys_stat, +) + + +class DOSModel(Model): + """DOS model. + + Parameters + ---------- + descrpt + Descriptor + fitting + Fitting net + type_map + Mapping atom type to the name (str) of the type. + For example `type_map[1]` gives the name of the type 1. + data_stat_nbatch + Number of frames used for data statistic + data_stat_protect + Protect parameter for atomic energy regression + """ + + model_type = "dos" + + def __init__( + self, + descrpt, + fitting, + typeebd=None, + type_map: List[str] = None, + data_stat_nbatch: int = 10, + data_stat_protect: float = 1e-2, + ) -> None: + """Constructor.""" + # descriptor + self.descrpt = descrpt + self.rcut = self.descrpt.get_rcut() + self.ntypes = self.descrpt.get_ntypes() + # fitting + self.fitting = fitting + self.numb_dos = self.fitting.get_numb_dos() + self.numb_fparam = self.fitting.get_numb_fparam() + # type embedding + self.typeebd = typeebd + # other inputs + if type_map is None: + self.type_map = [] + else: + self.type_map = type_map + self.data_stat_nbatch = data_stat_nbatch + self.data_stat_protect = data_stat_protect + + def get_numb_dos(self): + return self.numb_dos + + def get_rcut(self): + return self.rcut + + def get_ntypes(self): + return self.ntypes + + def get_type_map(self): + return self.type_map + + def data_stat(self, data): + all_stat = make_stat_input(data, self.data_stat_nbatch, merge_sys=False) + m_all_stat = merge_sys_stat(all_stat) + self._compute_input_stat( + m_all_stat, protection=self.data_stat_protect, mixed_type=data.mixed_type + ) + # self._compute_output_stat(all_stat, mixed_type=data.mixed_type) + # self.bias_atom_e = data.compute_energy_shift(self.rcond) + + def _compute_input_stat(self, all_stat, protection=1e-2, mixed_type=False): + if mixed_type: + self.descrpt.compute_input_stats( + all_stat["coord"], + all_stat["box"], + all_stat["type"], + all_stat["natoms_vec"], + all_stat["default_mesh"], + all_stat, + mixed_type, + all_stat["real_natoms_vec"], + ) + else: + self.descrpt.compute_input_stats( + all_stat["coord"], + all_stat["box"], + all_stat["type"], + all_stat["natoms_vec"], + all_stat["default_mesh"], + all_stat, + ) + self.fitting.compute_input_stats(all_stat, protection=protection) + + def _compute_output_stat(self, all_stat, mixed_type=False): + if mixed_type: + self.fitting.compute_output_stats(all_stat, mixed_type=mixed_type) + else: + self.fitting.compute_output_stats(all_stat) + + def build( + self, + coord_, + atype_, + natoms, + box, + mesh, + input_dict, + frz_model=None, + ckpt_meta: Optional[str] = None, + suffix="", + reuse=None, + ): + if input_dict is None: + input_dict = {} + with tf.variable_scope("model_attr" + suffix, reuse=reuse): + t_tmap = tf.constant(" ".join(self.type_map), name="tmap", dtype=tf.string) + t_mt = tf.constant(self.model_type, name="model_type", dtype=tf.string) + t_ver = tf.constant(MODEL_VERSION, name="model_version", dtype=tf.string) + t_od = tf.constant(self.numb_dos, name="output_dim", dtype=tf.int32) + + coord = tf.reshape(coord_, [-1, natoms[1] * 3]) + atype = tf.reshape(atype_, [-1, natoms[1]]) + input_dict["nframes"] = tf.shape(coord)[0] + + # type embedding if any + if self.typeebd is not None: + type_embedding = self.typeebd.build( + self.ntypes, + reuse=reuse, + suffix=suffix, + ) + input_dict["type_embedding"] = type_embedding + input_dict["atype"] = atype_ + + dout = self.build_descrpt( + coord, + atype, + natoms, + box, + mesh, + input_dict, + frz_model=frz_model, + ckpt_meta=ckpt_meta, + suffix=suffix, + reuse=reuse, + ) + + atom_dos = self.fitting.build( + dout, natoms, input_dict, reuse=reuse, suffix=suffix + ) + self.atom_dos = atom_dos + + dos_raw = atom_dos + + dos_raw = tf.reshape(dos_raw, [natoms[0], -1], name="o_atom_dos" + suffix) + dos = tf.reduce_sum( + global_cvt_2_ener_float(dos_raw), axis=0, name="o_dos" + suffix + ) + + model_dict = {} + model_dict["dos"] = dos + model_dict["atom_dos"] = dos_raw + model_dict["coord"] = coord + model_dict["atype"] = atype + + return model_dict + + def init_variables( + self, + graph: tf.Graph, + graph_def: tf.GraphDef, + model_type: str = "original_model", + suffix: str = "", + ) -> None: + """Init the embedding net variables with the given frozen model. + + Parameters + ---------- + graph : tf.Graph + The input frozen model graph + graph_def : tf.GraphDef + The input frozen model graph_def + model_type : str + the type of the model + suffix : str + suffix to name scope + """ + # self.frz_model will control the self.model to import the descriptor from the given frozen model instead of building from scratch... + # initialize fitting net with the given compressed frozen model + if model_type == "original_model": + self.descrpt.init_variables(graph, graph_def, suffix=suffix) + self.fitting.init_variables(graph, graph_def, suffix=suffix) + tf.constant("original_model", name="model_type", dtype=tf.string) + elif model_type == "compressed_model": + self.fitting.init_variables(graph, graph_def, suffix=suffix) + tf.constant("compressed_model", name="model_type", dtype=tf.string) + else: + raise RuntimeError("Unknown model type %s" % model_type) + if self.typeebd is not None: + self.typeebd.init_variables(graph, graph_def, suffix=suffix) diff --git a/deepmd/train/trainer.py b/deepmd/train/trainer.py index a0f47823b7..a459d296ba 100644 --- a/deepmd/train/trainer.py +++ b/deepmd/train/trainer.py @@ -35,16 +35,19 @@ ) from deepmd.fit import ( DipoleFittingSeA, + DOSFitting, EnerFitting, PolarFittingSeA, ) from deepmd.loss import ( + DOSLoss, EnerDipoleLoss, EnerStdLoss, TensorLoss, ) from deepmd.model import ( DipoleModel, + DOSModel, EnerModel, MultiModel, PolarModel, @@ -140,6 +143,8 @@ def _init_param(self, jdata): def fitting_net_init(fitting_type_, descrpt_type_, params): if fitting_type_ == "ener": return EnerFitting(**params) + elif fitting_type_ == "dos": + return DOSFitting(**params) elif fitting_type_ == "dipole": return DipoleFittingSeA(**params) elif fitting_type_ == "polar": @@ -219,6 +224,16 @@ def fitting_net_init(fitting_type_, descrpt_type_, params): ) # elif fitting_type == 'wfc': # self.model = WFCModel(model_param, self.descrpt, self.fitting) + elif self.fitting_type == "dos": + self.model = DOSModel( + self.descrpt, + self.fitting, + self.typeebd, + model_param.get("type_map"), + model_param.get("data_stat_nbatch", 10), + model_param.get("data_stat_protect", 1e-2), + ) + elif self.fitting_type == "dipole": self.model = DipoleModel( self.descrpt, @@ -307,6 +322,11 @@ def loss_init(_loss_param, _fitting_type, _fitting, _lr): loss = EnerDipoleLoss(**_loss_param) else: raise RuntimeError("unknown loss type") + elif _fitting_type == "dos": + _loss_param.pop("type", None) + _loss_param["starter_learning_rate"] = _lr.start_lr() + _loss_param["numb_dos"] = self.fitting.get_numb_dos() + loss = DOSLoss(**_loss_param) elif _fitting_type == "wfc": loss = TensorLoss( _loss_param, @@ -398,7 +418,9 @@ def loss_init(_loss_param, _fitting_type, _fitting, _lr): # self.auto_prob_style = tr_data['auto_prob'] self.useBN = False if not self.multi_task_mode: - if self.fitting_type == "ener" and self.fitting.get_numb_fparam() > 0: + if ( + self.fitting_type == "ener" or self.fitting_type == "dos" + ) and self.fitting.get_numb_fparam() > 0: self.numb_fparam = self.fitting.get_numb_fparam() else: self.numb_fparam = 0 diff --git a/deepmd/utils/argcheck.py b/deepmd/utils/argcheck.py index b66dc3b7fa..7c41232310 100644 --- a/deepmd/utils/argcheck.py +++ b/deepmd/utils/argcheck.py @@ -504,6 +504,46 @@ def fitting_ener(): ] +def fitting_dos(): + doc_numb_fparam = "The dimension of the frame parameter. If set to >0, file `fparam.npy` should be included to provided the input fparams." + doc_numb_aparam = "The dimension of the atomic parameter. If set to >0, file `aparam.npy` should be included to provided the input aparams." + doc_neuron = "The number of neurons in each hidden layers of the fitting net. When two hidden layers are of the same size, a skip connection is built." + doc_activation_function = f'The activation function in the fitting net. Supported activation functions are {list_to_doc(ACTIVATION_FN_DICT.keys())} Note that "gelu" denotes the custom operator version, and "gelu_tf" denotes the TF standard version. If you set "None" or "none" here, no activation function will be used.' + doc_precision = f"The precision of the fitting net parameters, supported options are {list_to_doc(PRECISION_DICT.keys())} Default follows the interface precision." + doc_resnet_dt = 'Whether to use a "Timestep" in the skip connection' + doc_trainable = "Whether the parameters in the fitting net are trainable. This option can be\n\n\ +- bool: True if all parameters of the fitting net are trainable, False otherwise.\n\n\ +- list of bool: Specifies if each layer is trainable. Since the fitting net is composed by hidden layers followed by a output layer, the length of tihs list should be equal to len(`neuron`)+1." + doc_rcond = "The condition number used to determine the inital energy shift for each type of atoms." + doc_seed = "Random seed for parameter initialization of the fitting net" + doc_numb_dos = ( + "The number of gridpoints on which the DOS is evaluated (NEDOS in VASP)" + ) + + return [ + Argument("numb_fparam", int, optional=True, default=0, doc=doc_numb_fparam), + Argument("numb_aparam", int, optional=True, default=0, doc=doc_numb_aparam), + Argument( + "neuron", list, optional=True, default=[120, 120, 120], doc=doc_neuron + ), + Argument( + "activation_function", + str, + optional=True, + default="tanh", + doc=doc_activation_function, + ), + Argument("precision", str, optional=True, default="float64", doc=doc_precision), + Argument("resnet_dt", bool, optional=True, default=True, doc=doc_resnet_dt), + Argument( + "trainable", [list, bool], optional=True, default=True, doc=doc_trainable + ), + Argument("rcond", float, optional=True, default=1e-3, doc=doc_rcond), + Argument("seed", [int, None], optional=True, doc=doc_seed), + Argument("numb_dos", int, optional=True, default=300, doc=doc_numb_dos), + ] + + def fitting_polar(): doc_neuron = "The number of neurons in each hidden layers of the fitting net. When two hidden layers are of the same size, a skip connection is built." doc_activation_function = f'The activation function in the fitting net. Supported activation functions are {list_to_doc(ACTIVATION_FN_DICT.keys())} Note that "gelu" denotes the custom operator version, and "gelu_tf" denotes the TF standard version. If you set "None" or "none" here, no activation function will be used.' @@ -595,6 +635,7 @@ def fitting_dipole(): def fitting_variant_type_args(): doc_descrpt_type = "The type of the fitting. See explanation below. \n\n\ - `ener`: Fit an energy model (potential energy surface).\n\n\ +- `dos` : Fit a density of states model. The total density of states / site-projected density of states labels should be provided by `dos.npy` or `atom_dos.npy` in each data system. The file has number of frames lines and number of energy grid columns (times number of atoms in `atom_dos.npy`). See `loss` parameter. \n\n\ - `dipole`: Fit an atomic dipole model. Global dipole labels or atomic dipole labels for all the selected atoms (see `sel_type`) should be provided by `dipole.npy` in each data system. The file either has number of frames lines and 3 times of number of selected atoms columns, or has number of frames lines and 3 columns. See `loss` parameter.\n\n\ - `polar`: Fit an atomic polarizability model. Global polarizazbility labels or atomic polarizability labels for all the selected atoms (see `sel_type`) should be provided by `polarizability.npy` in each data system. The file eith has number of frames lines and 9 times of number of selected atoms columns, or has number of frames lines and 9 columns. See `loss` parameter.\n\n" @@ -602,6 +643,7 @@ def fitting_variant_type_args(): "type", [ Argument("ener", dict, fitting_ener()), + Argument("dos", dict, fitting_dos()), Argument("dipole", dict, fitting_dipole()), Argument("polar", dict, fitting_polar()), ], @@ -921,6 +963,79 @@ def loss_ener(): ] +def loss_dos(): + doc_start_pref_dos = start_pref("Density of State (DOS)") + doc_limit_pref_dos = limit_pref("Density of State (DOS)") + doc_start_pref_cdf = start_pref( + "Cumulative Distribution Function (cumulative intergral of DOS)" + ) + doc_limit_pref_cdf = limit_pref( + "Cumulative Distribution Function (cumulative intergral of DOS)" + ) + doc_start_pref_ados = start_pref("atomic DOS (site-projected DOS)") + doc_limit_pref_ados = limit_pref("atomic DOS (site-projected DOS)") + doc_start_pref_acdf = start_pref("Cumulative integral of atomic DOS") + doc_limit_pref_acdf = limit_pref("Cumulative integral of atomic DOS") + return [ + Argument( + "start_pref_dos", + [float, int], + optional=True, + default=0.00, + doc=doc_start_pref_dos, + ), + Argument( + "limit_pref_dos", + [float, int], + optional=True, + default=0.00, + doc=doc_limit_pref_dos, + ), + Argument( + "start_pref_cdf", + [float, int], + optional=True, + default=0.00, + doc=doc_start_pref_cdf, + ), + Argument( + "limit_pref_cdf", + [float, int], + optional=True, + default=0.00, + doc=doc_limit_pref_cdf, + ), + Argument( + "start_pref_ados", + [float, int], + optional=True, + default=1.00, + doc=doc_start_pref_ados, + ), + Argument( + "limit_pref_ados", + [float, int], + optional=True, + default=1.00, + doc=doc_limit_pref_ados, + ), + Argument( + "start_pref_acdf", + [float, int], + optional=True, + default=0.00, + doc=doc_start_pref_acdf, + ), + Argument( + "limit_pref_acdf", + [float, int], + optional=True, + default=0.00, + doc=doc_limit_pref_acdf, + ), + ] + + # YWolfeee: Modified to support tensor type of loss args. def loss_tensor(): # doc_global_weight = "The prefactor of the weight of global loss. It should be larger than or equal to 0. If only `pref` is provided or both are not provided, training will be global mode, i.e. the shape of 'polarizability.npy` or `dipole.npy` should be #frams x [9 or 3]." @@ -948,6 +1063,7 @@ def loss_variant_type_args(): "type", [ Argument("ener", dict, loss_ener()), + Argument("dos", dict, loss_dos()), Argument("tensor", dict, loss_tensor()), # Argument("polar", dict, loss_tensor()), # Argument("global_polar", dict, loss_tensor("global")) diff --git a/doc/model/train-fitting-dos.md b/doc/model/train-fitting-dos.md new file mode 100644 index 0000000000..bbe5b50690 --- /dev/null +++ b/doc/model/train-fitting-dos.md @@ -0,0 +1,145 @@ +# Fit electronic density of states (DOS) + +Here we present an API to DeepDOS model, which can be used to fit electronic density of state (DOS) (which is a vector). + +See the [PRB paper](https://doi.org/10.1103/PhysRevB.105.174109) for details. + +In this example, we will show you how to train a model to fit a silicon system. A complete training input script of the examples can be found in + +```bash +$deepmd_source_dir/examples/dos/input.json +``` + +The training and validation data are also provided our examples. But note that **the data provided along with the examples are of limited amount, and should not be used to train a production model.** + +Similar to the `input.json` used in `ener` mode, training JSON is also divided into {ref}`model `, {ref}`learning_rate `, {ref}`loss ` and {ref}`training `. Most keywords remain the same as `ener` mode, and their meaning can be found [here](train-se-e2-a.md). To fit the `dos`, one needs to modify {ref}`model/fitting_net ` and {ref}`loss `. + +## The fitting Network + +The {ref}`fitting_net ` section tells DP which fitting net to use. + +The JSON of `dos` type should be provided like + +```json + "fitting_net" : { + "type": "dos", + "numb_dos": 250, + "sel_type": [0], + "neuron": [120,120,120], + "resnet_dt": true, + "fparam": 0, + "seed": 1, + }, +``` + +- `type` specifies which type of fitting net should be used. It should be `dos`. +- `numb_dos` specifies the length of output vector (density of states), which the same as the `NEDOS` set in VASP software, this argument defines the output length of the neural network. We note that the length of `dos` provided in training set should be the same. +- The rest arguments have the same meaning as they do in `ener` mode. + +## Loss + +DeepDOS supports trainings of the global system (a global `dos` label is provided in a frame) or atomic system (atomic labels `atom_dos` is provided for **each** atom in a frame). In a global system, each frame has just **one** `dos` label. For example, when fitting `dos`, each frame will just provide a `1 x numb_dos` vector which gives the total electronic density of states. By contrast, in an atomic system, each atom in has a `atom_dos` label. For example, when fitting the site-projected electronic density of states, each frame will provide a `natom x numb_dos` matrices, + +The {ref}`loss ` section tells DP the weight of these two kinds of loss, i.e. + +```python +loss = pref * global_loss + pref_atomic * atomic_loss +``` + +The loss section should be provided like + +```json + "loss" : { + "type": "dos", + "start_pref_dos": 0.0, + "limit_pref_dos": 0.0, + "start_pref_cdf": 0.0, + "limit_pref_cdf": 0.0, + "start_pref_ados": 1.0, + "limit_pref_ados": 1.0, + "start_pref_acdf": 0.0, + "limit_pref_acdf": 0.0 + }, +``` + +- {ref}`type ` should be written as `dos` as a distinction from `ener` mode. +- `pref_dos` and `pref_ados`, respectively specify the weight of global and atomic loss. If set to 0, the corresponding label will not be included in the training process. +- We also provides a combination training of vector and its cumulative distribution function `cdf`, which can be defined as + +$$D(\epsilon) = \int_{e_{min}}^{\epsilon} g(\epsilon')d\epsilon'$$ + + +## Training Data Preparation + +The global label should be named `dos.npy/raw`, while the atomic label should be named `atomic_dos.npy/raw`. If wrongly named, DP will report an error. + +To prepare the data, we recommend shifting the DOS data by the Fermi level. + +## Train the Model + +The training command is the same as `ener` mode, i.e. + +```bash +dp train input.json +``` + +The detailed loss can be found in `lcurve.out`: + +``` +# step rmse_trn rmse_ados_trn rmse_ados_lr + 0 1.11e+00 1.11e+00 1.0e-03 + 100 5.00e-02 5.00e-02 1.0e-03 + 200 4.70e-02 4.70e-02 1.0e-03 + 300 6.45e-02 6.45e-02 1.0e-03 + 400 3.39e-02 3.39e-02 1.0e-03 + 500 4.60e-02 4.60e-02 1.0e-03 + 600 3.98e-02 3.98e-02 1.0e-03 + 700 9.50e-02 9.50e-02 1.0e-03 + 800 5.49e-02 5.49e-02 1.0e-03 + 900 5.57e-02 5.57e-02 1.0e-03 + 1000 3.73e-02 3.73e-02 1.0e-03 + 1100 4.33e-02 4.33e-02 1.0e-03 + 1200 3.27e-02 3.27e-02 1.0e-03 + 1300 3.68e-02 3.68e-02 1.0e-03 + 1400 3.09e-02 3.09e-02 1.0e-03 + 1500 3.42e-02 3.42e-02 1.0e-03 + 1600 5.62e-02 5.62e-02 1.0e-03 + 1700 6.12e-02 6.12e-02 1.0e-03 + 1800 4.10e-02 4.10e-02 1.0e-03 + 1900 5.30e-02 5.30e-02 1.0e-03 + 2000 3.85e-02 3.85e-02 1.0e-03 +``` + +## Test the Model + +In this earlier version, we can use `dp test` to infer the electronic density of state for given frames. + +```bash + +$DP freeze -o frozen_model.pb + +$DP test -m frozen_model.pb -s ../data/111/$k -d ${output_prefix} -a -n 100 +``` + +if `dp test -d ${output_prefix} -a` is specified, the predicted DOS and atomic DOS for each frame is output in the working directory + +``` +${output_prefix}.ados.out.0 ${output_prefix}.ados.out.1 ${output_prefix}.ados.out.2 ${output_prefix}.ados.out.3 +${output_prefix}.dos.out.0 ${output_prefix}.dos.out.1 ${output_prefix}.dos.out.2 ${output_prefix}.dos.out.3 +``` + +for `*.dos.out.*`, it contains matrix with shape of `(2, numb_dos)`, +for `*.ados.out.*`, it contains matrix with shape of `(2, natom x numb_dos)`, + +``` +# frame - 0: data_dos pred_dos +0.000000000000000000e+00 1.963193264917645342e-03 +0.000000000000000000e+00 1.178440836781313727e-03 +0.000000000000000000e+00 1.441258071790407769e-04 +0.000000000000000000e+00 1.787297933314058174e-03 +0.000000000000000000e+00 1.901603280243024940e-03 +0.000000000000000000e+00 2.279848925571981155e-03 +0.000000000000000000e+00 2.149355854688561607e-03 +0.000000000000000000e+00 1.829848459515726056e-03 +0.000000000000000000e+00 1.905156512419792225e-03 +``` diff --git a/examples/dos/data/heat-221/set.000/atom_dos.npy b/examples/dos/data/heat-221/set.000/atom_dos.npy new file mode 100644 index 0000000000..22809c1068 Binary files /dev/null and b/examples/dos/data/heat-221/set.000/atom_dos.npy differ diff --git a/examples/dos/data/heat-221/set.000/box.npy b/examples/dos/data/heat-221/set.000/box.npy new file mode 100644 index 0000000000..6265bf150e Binary files /dev/null and b/examples/dos/data/heat-221/set.000/box.npy differ diff --git a/examples/dos/data/heat-221/set.000/coord.npy b/examples/dos/data/heat-221/set.000/coord.npy new file mode 100644 index 0000000000..f33ce430bf Binary files /dev/null and b/examples/dos/data/heat-221/set.000/coord.npy differ diff --git a/examples/dos/data/heat-221/set.000/dos.npy b/examples/dos/data/heat-221/set.000/dos.npy new file mode 100644 index 0000000000..904b23e709 Binary files /dev/null and b/examples/dos/data/heat-221/set.000/dos.npy differ diff --git a/examples/dos/data/heat-221/type.raw b/examples/dos/data/heat-221/type.raw new file mode 100644 index 0000000000..de3c26ec4e --- /dev/null +++ b/examples/dos/data/heat-221/type.raw @@ -0,0 +1,32 @@ +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 diff --git a/examples/dos/data/heat-221/type_map.raw b/examples/dos/data/heat-221/type_map.raw new file mode 100644 index 0000000000..e267321d2c --- /dev/null +++ b/examples/dos/data/heat-221/type_map.raw @@ -0,0 +1 @@ +Si diff --git a/examples/dos/train/input.json b/examples/dos/train/input.json new file mode 100644 index 0000000000..11c8bf2d99 --- /dev/null +++ b/examples/dos/train/input.json @@ -0,0 +1,73 @@ +{ + "model": { + "type_map": [ + "Si" + ], + "descriptor": { + "type": "se_a", + "sel": [ + 90 + ], + "rcut_smth": 1.8, + "rcut": 6.0, + "neuron": [ + 25, + 50, + 100 + ], + "resnet_dt": false, + "axis_neuron": 8, + "seed": 1 + }, + "fitting_net": { + "type": "dos", + "numb_dos": 250, + "ener_min": -15.0, + "ener_max": 10.0, + "neuron": [ + 120, + 120, + 120 + ], + "resnet_dt": true, + "numb_fparam": 0, + "seed": 1 + } + }, + "loss": { + "type": "dos", + "start_pref_dos": 0.0, + "limit_pref_dos": 0.0, + "start_pref_cdf": 0.0, + "limit_pref_cdf": 0.0, + "start_pref_ados": 1.0, + "limit_pref_ados": 1.0, + "start_pref_acdf": 0.0, + "limit_pref_acdf": 0.0 + }, + "learning_rate": { + "type": "exp", + "start_lr": 0.001, + "stop_lr": 1e-08 + }, + "training": { + "stop_batch": 100000, + "seed": 1, + "disp_file": "lcurve.out", + "disp_freq": 100, + "save_freq": 1000, + "save_ckpt": "model.ckpt", + "disp_training": true, + "time_training": true, + "profiling": false, + "profiling_file": "timeline.json", + "training_data": { + "systems": [ + "../data/heat-221/" + ], + "set_prefix": "set", + "batch_size": 1 + } + }, + "_comment": "that's all" +} diff --git a/source/tests/infer/deepdos.pbtxt b/source/tests/infer/deepdos.pbtxt new file mode 100644 index 0000000000..d923e1f8c4 --- /dev/null +++ b/source/tests/infer/deepdos.pbtxt @@ -0,0 +1,5491 @@ +node { + name: "train_attr/min_nbor_dist" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.9612421421978445 + } + } + } +} +node { + name: "train_attr/training_script" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "{\"model\":{\"type_map\":[\"Si\"],\"descriptor\":{\"type\":\"se_e2_a\",\"sel\":[90],\"rcut_smth\":4.8,\"rcut\":5.0,\"neuron\":[5,10,20],\"resnet_dt\":false,\"axis_neuron\":2,\"seed\":1,\"activation_function\":\"tanh\",\"type_one_side\":false,\"precision\":\"default\",\"trainable\":true,\"exclude_types\":[],\"set_davg_zero\":false},\"fitting_net\":{\"type\":\"dos\",\"numb_dos\":250,\"ener_min\":-15.0,\"ener_max\":10.0,\"neuron\":[40,40,40],\"resnet_dt\":true,\"numb_fparam\":0,\"seed\":1,\"numb_aparam\":0,\"activation_function\":\"tanh\",\"precision\":\"float64\",\"trainable\":true,\"rcond\":0.001},\"data_stat_nbatch\":10,\"data_stat_protect\":0.01,\"data_bias_nsample\":10},\"loss\":{\"type\":\"dos\",\"start_pref_dos\":0.0,\"limit_pref_dos\":0.0,\"start_pref_cdf\":0.0,\"limit_pref_cdf\":0.0,\"start_pref_ados\":1.0,\"limit_pref_ados\":1.0,\"start_pref_acdf\":0.0,\"limit_pref_acdf\":0.0},\"learning_rate\":{\"type\":\"exp\",\"start_lr\":0.001,\"stop_lr\":1e-08,\"scale_by_worker\":\"linear\",\"decay_steps\":5000},\"training\":{\"seed\":1,\"disp_file\":\"lcurve.out\",\"disp_freq\":100,\"save_freq\":1000,\"save_ckpt\":\"model.ckpt\",\"disp_training\":true,\"time_training\":true,\"profiling\":false,\"profiling_file\":\"timeline.json\",\"training_data\":{\"systems\":[\"/data/home/djy4/work/dp-dos/set-train/111/size-80\",\"/data/home/djy4/work/dp-dos/set-train/111/heat-5-fermi\",\"/data/home/djy4/work/dp-dos/set-train/211/cd-2000-5-fermi\",\"/data/home/djy4/work/dp-dos/set-train/211/heat-5-fermi\",\"/data/home/djy4/work/dp-dos/set-train/221/heat-5-fermi\",\"/data/home/djy4/work/dp-dos/set-train/222/heat-5-fermi\"],\"set_prefix\":\"set\",\"batch_size\":1,\"auto_prob\":\"prob_sys_size\",\"sys_probs\":null},\"numb_steps\":50000,\"validation_data\":null,\"enable_profiler\":false,\"tensorboard\":false,\"tensorboard_log_dir\":\"log\",\"tensorboard_freq\":1}}" + } + } + } +} +node { + name: "model_type" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "original_model" + } + } + } +} +node { + name: "t_box" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "t_coord" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "t_type" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "t_natoms" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 3 + } + } + } + } +} +node { + name: "t_mesh" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "model_attr/tmap" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "Si" + } + } + } +} +node { + name: "model_attr/model_type" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "dos" + } + } + } +} +node { + name: "model_attr/model_version" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "1.1" + } + } + } +} +node { + name: "strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice/stack" + input: "strided_slice/stack_1" + input: "strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul" + op: "Mul" + input: "strided_slice" + input: "mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape/shape" + op: "Pack" + input: "Reshape/shape/0" + input: "mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape" + op: "Reshape" + input: "t_coord" + input: "Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_1" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_1/stack" + input: "strided_slice_1/stack_1" + input: "strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "Reshape_1/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_1/shape" + op: "Pack" + input: "Reshape_1/shape/0" + input: "strided_slice_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_1" + op: "Reshape" + input: "t_type" + input: "Reshape_1/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "descrpt_attr/rcut" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 5.0 + } + } + } +} +node { + name: "descrpt_attr/ntypes" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "descrpt_attr/sel" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 90 + } + } + } +} +node { + name: "descrpt_attr/original_sel" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 90 + } + } + } +} +node { + name: "descrpt_attr/t_avg" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 360 + } + } + tensor_content: "\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\325\355i\325\332\264?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "descrpt_attr/t_avg/read" + op: "Identity" + input: "descrpt_attr/t_avg" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@descrpt_attr/t_avg" + } + } + } +} +node { + name: "descrpt_attr/t_std" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 360 + } + } + tensor_content: "Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?Qt`\373\203\261\300?\345\363\202\0317\272\266?\345\363\202\0317\272\266?\345\363\202\0317\272\266?" + } + } + } +} +node { + name: "descrpt_attr/t_std/read" + op: "Identity" + input: "descrpt_attr/t_std" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@descrpt_attr/t_std" + } + } + } +} +node { + name: "strided_slice_3/stack" + op: "Const" + input: "^descrpt_attr/original_sel" + input: "^descrpt_attr/sel" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_3/stack_1" + op: "Const" + input: "^descrpt_attr/original_sel" + input: "^descrpt_attr/sel" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_3/stack_2" + op: "Const" + input: "^descrpt_attr/original_sel" + input: "^descrpt_attr/sel" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_3" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_3/stack" + input: "strided_slice_3/stack_1" + input: "strided_slice_3/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_1/y" + op: "Const" + input: "^descrpt_attr/original_sel" + input: "^descrpt_attr/sel" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_1" + op: "Mul" + input: "strided_slice_3" + input: "mul_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_2/shape/0" + op: "Const" + input: "^descrpt_attr/original_sel" + input: "^descrpt_attr/sel" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_2/shape" + op: "Pack" + input: "Reshape_2/shape/0" + input: "mul_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_2" + op: "Reshape" + input: "Reshape" + input: "Reshape_2/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_3/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\t\000\000\000" + } + } + } +} +node { + name: "Reshape_3" + op: "Reshape" + input: "t_box" + input: "Reshape_3/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_4/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_4/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_4/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_4" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_4/stack" + input: "strided_slice_4/stack_1" + input: "strided_slice_4/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "Reshape_4/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_4/shape" + op: "Pack" + input: "Reshape_4/shape/0" + input: "strided_slice_4" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_4" + op: "Reshape" + input: "Reshape_1" + input: "Reshape_4/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdEnvMatA" + op: "ProdEnvMatA" + input: "Reshape_2" + input: "Reshape_4" + input: "t_natoms" + input: "Reshape_3" + input: "t_mesh" + input: "descrpt_attr/t_avg/read" + input: "descrpt_attr/t_std/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "rcut_a" + value { + f: -1.0 + } + } + attr { + key: "rcut_r" + value { + f: 5.0 + } + } + attr { + key: "rcut_r_smth" + value { + f: 4.800000190734863 + } + } + attr { + key: "sel_a" + value { + list { + i: 90 + } + } + } + attr { + key: "sel_r" + value { + list { + i: 0 + } + } + } +} +node { + name: "Reshape_5/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377h\001\000\000" + } + } + } +} +node { + name: "Reshape_5" + op: "Reshape" + input: "ProdEnvMatA" + input: "Reshape_5/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "o_rmat" + op: "Identity" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "strided_slice_5/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_5/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_5/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_5" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_5/stack" + input: "strided_slice_5/stack_1" + input: "strided_slice_5/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "Reshape_6/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_6/shape/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 360 + } + } + } +} +node { + name: "Reshape_6/shape" + op: "Pack" + input: "Reshape_6/shape/0" + input: "strided_slice_5" + input: "Reshape_6/shape/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_6" + op: "Reshape" + input: "o_rmat" + input: "Reshape_6/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_6/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_6/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_6/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_6" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_6/stack" + input: "strided_slice_6/stack_1" + input: "strided_slice_6/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "Slice/begin" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "Slice/size/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice/size/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice/size" + op: "Pack" + input: "Slice/size/0" + input: "strided_slice_6" + input: "Slice/size/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice" + op: "Slice" + input: "Reshape_6" + input: "Slice/begin" + input: "Slice/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_7/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377h\001\000\000" + } + } + } +} +node { + name: "Reshape_7" + op: "Reshape" + input: "Slice" + input: "Reshape_7/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Slice/begin" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice/size" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377h\001\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice" + op: "Slice" + input: "Reshape_7" + input: "filter_type_0/Slice/begin" + input: "filter_type_0/Slice/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "filter_type_0/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "filter_type_0/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "filter_type_0/strided_slice" + op: "StridedSlice" + input: "filter_type_0/Shape" + input: "filter_type_0/strided_slice/stack" + input: "filter_type_0/strided_slice/stack_1" + input: "filter_type_0/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "filter_type_0/Reshape/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\004\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape" + op: "Reshape" + input: "filter_type_0/Slice" + input: "filter_type_0/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Slice_1/begin" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice_1/size" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice_1" + op: "Slice" + input: "filter_type_0/Reshape" + input: "filter_type_0/Slice_1/begin" + input: "filter_type_0/Slice_1/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_1/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\001\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_1" + op: "Reshape" + input: "filter_type_0/Slice_1" + input: "filter_type_0/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/matrix_1_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 5 + } + } + tensor_content: "L\303h_\330O\244?|\001Xs~\205\313?\241\357\036\260\034\023\346\277n@\213v\341\322\226?b\214\017n+\214\335?" + } + } + } +} +node { + name: "filter_type_0/matrix_1_0/read" + op: "Identity" + input: "filter_type_0/matrix_1_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_1_0" + } + } + } +} +node { + name: "filter_type_0/bias_1_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 5 + } + } + tensor_content: "eF\2242C\227\360\277\224\0048\343\003\240\001\300\304\335^\241\234>\351\277\217\rU\366\241\021\353\277\031\260\023\270a1\360\277" + } + } + } +} +node { + name: "filter_type_0/bias_1_0/read" + op: "Identity" + input: "filter_type_0/bias_1_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_1_0" + } + } + } +} +node { + name: "filter_type_0/MatMul" + op: "MatMul" + input: "filter_type_0/Reshape_1" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/BiasAdd" + op: "BiasAdd" + input: "filter_type_0/MatMul" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "filter_type_0/Tanh" + op: "Tanh" + input: "filter_type_0/BiasAdd" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_2/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\005\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_2" + op: "Reshape" + input: "filter_type_0/Tanh" + input: "filter_type_0/Reshape_2/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/matrix_2_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 5 + } + dim { + size: 10 + } + } + tensor_content: "\033\267/h \376\332?\007\361\275r\271\226\342?C\274k(\306\003\274?\213B-\332\000i\346?\316VFQBG\317?\274O\214Z\217\376\342\277\3118\331\224\014{y?w\333\033\353\000\000\260?\\\201\321\220\3440\263?:HL\031\317\276\347?Z\022\033\330O\007\356?`\373\250Y\3570\344?\013\274\365\342&\313\347?\305\017\272m\261\217\361?\255X\276\244\264O\222?\'\334\220\276z\250\246\277n?\360\017r]\326\277\361\244av\025\204\256\277\326|\272\345\252w\333?P@\344\322\306y\275\277\364\270\3127\310\373\272?\211\177\336\206\227|\261\2778\203[\330\337#\262\277\014\243o6\370R\301?\353\365o\365\275\301\315?s.[\\\037\250\322?\'\\\246\220<\n\345\277\014\210a)\'?\264?\204\342&_/\217\334?\315\336Ws\r\033\335?\024U\000\303\372\314\324?\224\255\022?:\303\352?\026M\333!\363p\300?y\276\225\314r\254\265?i\350\330\014\037\346\316?%\365\205\303\365\243\272\277\204;\351\377\224?\322\277}\305e\345q\264\330\277\221\251\t\310_\234\274\277F\036\360*\"\260\244?\244\310\220#\235\336\304?*\373c\253MM\306\277F\327!\356oi\307?d\312\321\000g\037\250?\232X\244\245Q\353\327?=\377@h`C\276\277F\206\345\207\2706\320\277\310\364T\006L\360\304\277\326O\"\320\037\006\324\277\214\271m\207d\205\214\277" + } + } + } +} +node { + name: "filter_type_0/matrix_2_0/read" + op: "Identity" + input: "filter_type_0/matrix_2_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_2_0" + } + } + } +} +node { + name: "filter_type_0/bias_2_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "\364\2450QV\016\373\277\341\024J\370,\214\365\277\013\275\314{w\333\272\277\362\022\313\016p4\350\2775P[\217\244\315\365\277|\335\3609\010\252\340?#9\347{F\252\341?\237\354\373\221Xl\355?7\312\225\005\263\022\376?\205\342z\334\2211\363\277" + } + } + } +} +node { + name: "filter_type_0/bias_2_0/read" + op: "Identity" + input: "filter_type_0/bias_2_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_2_0" + } + } + } +} +node { + name: "filter_type_0/MatMul_1" + op: "MatMul" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/BiasAdd_1" + op: "BiasAdd" + input: "filter_type_0/MatMul_1" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "filter_type_0/Tanh_1" + op: "Tanh" + input: "filter_type_0/BiasAdd_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_3/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\n\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_3" + op: "Reshape" + input: "filter_type_0/Tanh_1" + input: "filter_type_0/Reshape_3/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "filter_type_0/concat" + op: "ConcatV2" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/add" + op: "AddV2" + input: "filter_type_0/concat" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/matrix_3_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 20 + } + } + tensor_content: "\013\2153\206\236\033\330?\014\0368\230\275\211\322?hhE\253\306\365\332?\"\036\r\226\261C\340?\022\221\t\r\320q\304?q\370\014\232\357\370\235\277\323\350\262\273\341\262S\277`\2457\272\274\272\264\277%\215\317Qt\023\303?&\020\016\262\362\250\261?\234\234\251\274\005\324\335?w\224\273\200\303v\325?\212\363bBr/\326?R\257Q\244\215\323\321\277>\033\340Q\250\346\337?\214\356\306}j\233\340?Y\235\351\223\013\237\304?\006\346\020\023\246\000\233?,\242\2258o\306\265?\'\256\352V\334o\331?!\031I\214N\010\320?M^i\"!0\351?Y\207;j\372f\337?\352!\017]\370X\327?&\273\266\331\272I\247\277q\326\031\220\365&\304\277UH\010\305W\263\304\277\331&y\236\334\216\311?_j#\245\376\314\324?\214L\314\264D\271\267?\000%\377Nf\304\226\277{\367\266\033\274\336\270?L\033\216\236\333\255\344?\312\334\036\034\031>\322?\275\237\r:\2712\304?]\347\370i\201\352\321?+hN]\260\377\323\277q\177n\271\206d\245?x2A\000\332\350\260\277y\377A\000\204\244\332?U\256Y1<\000\322\277\214\244\004ztv\323\277\367U\023b\032<\272?\201 &\212\256*\264\277\264\327\303\267\0354x??m\302\263\213x\304\277f\014\306\030\033\301\205?\"\25436\340\325\323\277J\332\322\261B\227\324?\017\333\364\251\323|\267\277\341C(\334Q\243\256?\204\273X\346B\327\262?\347\016^l\263;\327?-\234\022\324\375e\350\254\300\277>\323g\2775\276\313\277+\210\227Wr\263\342\277\023\021\273\324\205^\310\277\n\010\345J\330\335\335?,X\374\203\363r\305?\310\037\210+I\304\235?\275s\214H\n~\327?\307\226\013F\355\'\314?\214\364\247\256YK\341?\014\235\307\027\226&\317?\n5\274\\x\202\343?K\363H7\232:\341\277\212\214\264\342\331\374\325?!\003c}\204\247\336\277\302\312\016&N@\333?\334\023G\'qn\273?\026\211C\366\226\004\320?\021$)\272\246\320\321?c\304OOt\224\317?\251\374\350\336\230\221\343?s\017\n\3152\302\336\277\341*\240f$h\330\277\2075\332\307\025\177\322\277\376\230$\203\340\342\316\2778\032\002[;\237\305?\013A\332-%\330\337?I\255\356\326e\247\331?\352\002w\352\270\020\342?\276\227\241\346F\271\345?\013\010\365]\200\242\306?\200\253y\212\304\032\246?\340%NP\273\223\335\277m\033\013\203\331p\325?\325e\367\310o\301\262\277\342\336\225W{\245\306?%\226\252i\225.\240\277\336\205\016\037\004\306\307\277g\014\265\001z\006\323?\007\360s!n\327\275?\3659u\346\353}\312\277\317x\301\tW\253\317\277Q\245\222\332h\306\267?\023\317\310c[l\325\277\317PU_j\260\302?\351s;]@@\314?\214{\375W\007h\310\277\rZ\324\212\034\240\256\277\371\374d\350=U\260\277\205\214\343\201\242\r\305\277\277/\330\257\203\370\303? A\001\364\022O\275\277\013~\024z\324\315\312\277x\245j\3618\332\241\277\342\036yV\235\364\317\277\203\362\253\025q\375\303?\245qx\030\317\356\321?c\324Q9\023N\267?\3520\354\347\337J\303?\342\262\177U\306\230y\277M5\030\223\345\363\274\277m\335|\354s\341\273?q{\t\2405\331\221?\351\025\334\212:H\277\277\232\000P\312\002\323\224?\325\347,QR(\256\277\357&~:\001\324\320?\236\277\315\2052\320\267?2\371ok\256\204\307?\240\033\347\003dZ\306\277\033\304\321\203\324\365\316\277\'}\016i\3633\232?paI\027\034t\254?\016~;\337j\255\254?\224n\261\344\321\036\227\277\377v%\311\266\376\325\277X\312\262\224\217\366\321\277W\342\351G<\021\263?\363\005\006m\315k\263\277\001]\274\3338>\277\277\376\277O\211\026\264\271?+3c8\277\304\303?~\253j\032\352\216\317\277\365\\\352\305\236\350\342?\251\264T\356\\\376\313?\341=\240\224\360\"\275\277&\355\277\342a\305w\277\224\207\216fs\r\274\277/\230\177,B\356\304?\210\324\022\367R0\223\277\226@Gf1,\263?\374\256X1\312\261\256\277\206uF\353\270I\306\277ctR1\010\026\320\277\343\323\013\234\357<\306\277\313\373\214\310\367\222\306\277\004\031\254\200\204N\322\277.\253Y8\264\360\264\277\371\t\272\221Hq\333\277\231\266\036\364\375\206\304\277w@\236\336d\360\326\277<\265\301\031\246\254\273\277\252\361\025\276It\314?u&t\177\267\016\311\277|\262\037:Q\257\325\277\304L\036\211\2736\252\277\207\275U\346\265\372\321\277\206v:Y\254\002\320\277\214x\226V\220J\344\277\021\035\344\027d\035\227\277\"\002O\017\264\022\272\277\030\252\330\014l\346\331\277 \037q\214\361}\262\277\332\257\257\313Q\254\263\277\347\306\276\366-\n\333?T\354\363;\036\205\323\277\217I\261\251s\025\317?\337g\366~\362c\304?\271r\036L\035\376\334?C\032\353(\362V\332?\232\010\230\277\350\232\310?\275\002\t{g\273\333\277\277\211|\244\365Z\314\277*\275\312\371\304\245\311?\2707\225D\234\233\257?\377\022?&\326\265\311?\022\002W\304K\240\315?\201\0348\345\t<\305?\251i\023\331f\t\343?\232\350\364\333\316\010\322?\261\237\267\0311\261\310?M\222\013\027T\301\314?\300#\217\316\365\t\334\277\327\222\211\274\303l\333?j>\374\315\314\276\274?\347n]\313\0374\332?" + } + } + } +} +node { + name: "filter_type_0/matrix_3_0/read" + op: "Identity" + input: "filter_type_0/matrix_3_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_3_0" + } + } + } +} +node { + name: "filter_type_0/bias_3_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 20 + } + } + tensor_content: "\254\335^\205z\252\274?\203z\376\366e\372\334?:1\352\001\364^\362?\035N}t\316\257\317?\342`\371\304\036\224\375\277_\332\035\310q\342\365?\305\234\004p\314\203\376?\014\000\356\303\360o\344\277g\037\363H\375\r\343\277,T\303e,\372\341\277C\346\372\356j\r\327\277\034\224\316d\2457\354\277\016\350o\231\223\006\371?\223\030\246\374\256o\302\277\226=\21604\331\346\277AAP\235\032\211\326\277\014l\347m\332w\347?\224\356\364\027B\314\364\277ts\330\001\304y\362?hX\t\230#k\354?" + } + } + } +} +node { + name: "filter_type_0/bias_3_0/read" + op: "Identity" + input: "filter_type_0/bias_3_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_3_0" + } + } + } +} +node { + name: "filter_type_0/MatMul_2" + op: "MatMul" + input: "filter_type_0/add" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/BiasAdd_2" + op: "BiasAdd" + input: "filter_type_0/MatMul_2" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "filter_type_0/Tanh_2" + op: "Tanh" + input: "filter_type_0/BiasAdd_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_4/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\024\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_4" + op: "Reshape" + input: "filter_type_0/Tanh_2" + input: "filter_type_0/Reshape_4/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/concat_1/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "filter_type_0/concat_1" + op: "ConcatV2" + input: "filter_type_0/add" + input: "filter_type_0/add" + input: "filter_type_0/concat_1/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/add_1" + op: "AddV2" + input: "filter_type_0/concat_1" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_5/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377Z\000\000\000\024\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_5" + op: "Reshape" + input: "filter_type_0/add_1" + input: "filter_type_0/Reshape_5/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Reshape_6/shape/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 90 + } + } + } +} +node { + name: "filter_type_0/Reshape_6/shape/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 4 + } + } + } +} +node { + name: "filter_type_0/Reshape_6/shape" + op: "Pack" + input: "filter_type_0/strided_slice" + input: "filter_type_0/Reshape_6/shape/1" + input: "filter_type_0/Reshape_6/shape/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "filter_type_0/Reshape_6" + op: "Reshape" + input: "filter_type_0/Slice" + input: "filter_type_0/Reshape_6/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/MatMul_3" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_0/truediv/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 90.0 + } + } + } +} +node { + name: "filter_type_0/truediv" + op: "RealDiv" + input: "filter_type_0/MatMul_3" + input: "filter_type_0/truediv/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Slice_2/begin" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice_2/size" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\377\377\377\377\002\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice_2" + op: "Slice" + input: "filter_type_0/truediv" + input: "filter_type_0/Slice_2/begin" + input: "filter_type_0/Slice_2/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/MatMul_4" + op: "BatchMatMulV2" + input: "filter_type_0/truediv" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_0/Reshape_7/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377(\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_7" + op: "Reshape" + input: "filter_type_0/MatMul_4" + input: "filter_type_0/Reshape_7/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Shape_2" + op: "Shape" + input: "Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_9/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_9/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_9/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_9" + op: "StridedSlice" + input: "Shape_2" + input: "strided_slice_9/stack" + input: "strided_slice_9/stack_1" + input: "strided_slice_9/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_10/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_10/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_10/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_10" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_10/stack" + input: "strided_slice_10/stack_1" + input: "strided_slice_10/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "Reshape_9/shape/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 40 + } + } + } +} +node { + name: "Reshape_9/shape" + op: "Pack" + input: "strided_slice_9" + input: "strided_slice_10" + input: "Reshape_9/shape/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_9" + op: "Reshape" + input: "filter_type_0/Reshape_7" + input: "Reshape_9/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "concat/concat" + op: "Identity" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "o_descriptor" + op: "Identity" + input: "concat/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "fitting_attr/dfparam" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "fitting_attr/daparam" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "fitting_attr/numb_dos" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 250 + } + } + } +} +node { + name: "strided_slice_14/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_14/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_14/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_14" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_14/stack" + input: "strided_slice_14/stack_1" + input: "strided_slice_14/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "Reshape_11/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_11/shape/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 40 + } + } + } +} +node { + name: "Reshape_11/shape" + op: "Pack" + input: "Reshape_11/shape/0" + input: "strided_slice_14" + input: "Reshape_11/shape/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_11" + op: "Reshape" + input: "o_descriptor" + input: "Reshape_11/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_17/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_17/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_17/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_17" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_17/stack" + input: "strided_slice_17/stack_1" + input: "strided_slice_17/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "Slice_2/begin" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "Slice_2/size/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice_2/size/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice_2/size" + op: "Pack" + input: "Slice_2/size/0" + input: "strided_slice_17" + input: "Slice_2/size/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_2" + op: "Slice" + input: "Reshape_11" + input: "Slice_2/begin" + input: "Slice_2/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_14/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377(\000\000\000" + } + } + } +} +node { + name: "Reshape_14" + op: "Reshape" + input: "Slice_2" + input: "Reshape_14/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_0_type_0/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 40 + } + dim { + size: 40 + } + } + tensor_content: "V\341\034~\263x\253?\325\272\266n\377\343\342?9\227\354jm\254\255\277\200\242\271\256\235\026\253?\351\226L\260\346V\261?\330\337\204\014.\333\260?\002\023\301\225/\363\252?J5\317\256\231\234\330\277\204\330DC\365\250\302?cU\344=\324\371\236\277Go\243T\013Ju\277\336&\022\377\3173\310\277\340\005\251>\317\033\232?2(\215\322\340\234\312?\365~1\257\010\344\261?\355\216\240\346\2711\261\277\007\327\021dt\245\304\277\206\352\026\315~D\320?\2063B%\336*\177\277\234\367\t&d\306\241?\245(F\001x7\253?\333\341\264hw\'t\277q\010d4\366\347\302\277H\332\222P\250_\245\277\006\370\034\372K>\211\277^\332k4\034\205\236?[X9\327\"j\225\277G\362A\327q\375\315\277D\316\251\372~m\273\277\313\242\334\233C\311\246\277\261DY\262n)\266\277#\362\3563\3372\310\277\356\\\360\356\277\271\331?\275\n\312\333\342\220\347?\214\016\265\204\314r\350\277\000\034\244\240\215\222\250\2774\316{~C\315\302?\013\214\244D|%\243?2!\304,?\270\244\277n\300W\322\374\"\270\277\026Q=4\367\320\256\277\255\346k\222V\014\352?\201\211N\220\361\214\275\277\234\030\371vV\315\247?K\005\247\014|\347\255\277S\232Y\271\2017\257?\374\215\247\331\0227\302\277\326\373\246\264\332\251\307\277N\343\350\356\013\207\267?RF\366\222\'\320\310?D[\215\303xN\260\277\024\227\033\353\244\367\276\277\3023\200\336\200\264\313?\347os\311\233@\223?\331\313\227\204Q\353\320\277\023\006\352\271\315\334\242?\027c\314\276\367S\203\277\030\362\375Jd\360\246\277\301}$\332\244\377\227?\345\307\3047e\211\232\277\266\341\2607\207\034\266?\255\267\323\032l\314\260\277\341\3421\244\nb\324\277\346i\232\257Y\254\243?\351\271\362\335\nw\230\277\276~\254?]\233\\\277\"/u\312\336\223\270\277\222\230k\351L\232\305?\304\"q\204\230\313\241?\225\334}\270\317\313\314?\352\325zE4_c?\336D\325\026C\031\276\277\312~\350\332\316=\330?\207*T\"\023H\350?q\005\265q\177)\341\277\321\316k@\262t\215?\242\033\227\204\r\360\301\277\266|\355\313\027\324\301\277fj\224\373\020\363\300?a\306\370BK\226\265?\355\017\030a(\356\275?H\227\261\267\036\210\343?\355\205\241\326\377\265\242\277G\360\'\350q\275M?nd\306#~u\317\277\321\323g\213\302\234\330?\232*j\355\270.\264?{!m\252\263\315\303\277\360\025\036\022I\303\322?n=\215\307\303\353\315?\326Ky\265\264\032\277\277\374V\023\255\274\252\306\277\337Q\332\001\330\345\224\277E\032u\025eG\254?o \266\341~\332\223\277\313\031\220-\231\307\300\277l$\177\273JZ\240\277\241\034\034\357\026\355\273?)\356\372&)3\305?5.:7G\264\302\277\340\251\0169\273\036\270\277\376\0130\216b\264\311\277}\026\301!J\251\273\277\032`\253\310\272\255\241?\030m4\332\031\262\245?*\236\006R\3557\267\277T\033%\316\275\016\261?\372\254\332\373\353\365\302\277\356\005\310\017\\\255\254\277m\276\347\271j`\306?#\337\253\260\323\"\301?\212\310f\272\334\372\276\277*w:V\354J\336?\021\212y\233\3218\355?+\223\337\016\025\001\351\277\263\242$\265\333\330\313\277\002\020Ul\216\217A?$\032`\351\216\205\223\277\365\215\276\340^\356\265\277u\236\204\321C\271\272\277\245\032l\230\023G\264?Us\277\007\016\231\340?If\004\244\305$\266?8}\3502\335F\252?\377\243\365\001q\240x\277\226 \242e\364\253\307?5\005U\222\360L\221\277\231\275\267Aa\336\265\277\021\310\200\317/\034\247?9\364\260n@?\242?\003.\032\255\261\316\252\277\373\271\021\210y\035\300\277\314\005\010\213m\023\261?\2720F\231\346\nP?[\335\376\337\356\232\253\277\364\324@\207\261\357\203?%D\225|\271\313\314\277`\257\211-\335\272\256\277\221D*\013\265;\302\2771X\337\372\340\202\253\277f\341\374\007\353\234\257?\323\303\245\036\027\251\262?\231G\251\346\344m\325\2778H\315\377\303\365\304?Z}\026\331jw\251?\001\227\306\3411\000\233\277\212\220\241(p\327\254?\214\263\3468\257\t\242\277e\013\352\032\250Sy?\222\265^\357J\377\264\277\320C\030\237+P\240?\234\223\217=\311\343\302\277\373\362\020\277\022\027\342?7Z\2378\333\332\354?4\241e\231\352{\351\277U\362\203\013O|D?\202s\270#\346\247\200?\234\236\232\016\333i8?\210\3229\233\332y\305?\306/\003\313\236\353\225\277\332\023\357\222\227a\324?W\343\311\252\200\227\354?\305\210\314\274\303\254\302?\004QB\006\306$\312\277\036\200\245d\216\257\224?\344\337\215\344u\005\241\277\025~!\254\371\305\320\277\336\242\345\212\022^\326\277\013:\232rW\306\315?n\367\251qf\311\303?\021\016\331\210\000\237\272\277\352+X\037Ig\261\277t,\2762;3\276?\213\325\210\37394\274?=\370{\0136\025\272?E]\311.\305\020\320\277\214;\027o\\\240\263\277T6\343\350\312\332\256\277\317\205\036\303\357\313\240?~\227{\001\025\005\211?\326Wd\323jB\244\277\016\250\252\025\225K\266?5\223u\235\205\253\260?\323\341\201\337\346\243z?s-\2101\365\275\207\277\226\270\261\035\274\245\262?P\024c\r\0053\307\277z\201\336#o\215\261?8\3452c\246\204\312\277\022f\307\3318\037\275?\\\027K\017F\347\300\277jv\371/\010\355\316\277\277\361\267\002\376U\336?\202{Bp\031\350\351?\351\351\351*\344V\356\277\244\362,O\317\034\272\277,\237\205\206\246\037\323?Y\362G\323+\\\311\277\356M\2471)t\227?\346\2606I[\211\306?\273\202\027\027u \270?AH\222\035\312\337\351?z\000\243\246\367\301e\277\004^<\257\217O\232\277\276x\207\322\322\304\322\277OwG\365B\026\306\277\313\3213\351\251/~?\246\004]KRo\323\2773\024\320Hbe\320?0=\031\323\310\360\313\277&\263q\320\270\204\313\277T\270|\267\020\026\304\277L\320\3040\002\311\313\277n\242/,\225 \260?\034!\213}\214\362\250?\253V\372\236\361\243\250\277\322\332\357\374\270\344\204\277\313*\341\256@\316n?`^\210r\354\202\275?I\352(\000g\203\201\277\227\341\030\007\254\234\315?\276\027\313yS2\302?\026\337\345L\334#\303\277Q%\324,\311d\240?\340\322\213<\377\360\247?\332Y\377\306\3271\316?\225\026N!)=\245\277(B73_\275\263?\2001\037\366\tZ\254\277h\235\361\342\321A}\277y]\377\235\273X\304\277n\206$\264o\341\220?\311\340\260Wd0\326?U\321\0007A^\352?\265y\016?B\232\352\277\210\247f\023\361\232\243\277$\254\315\004,\023\313?\220\030\312\315\341\207\262\2777\372\372:!|\235\277@\2107%\273L\243\277\300\342\276\014]s\315?\267@\317\3137D\352?\365\"\212\274\236X\273?$\371X\243\023\217\304\277y\030t\231x\236\277\277a\032\321\356\211\342\314?\030 D\242\255\000\263?=\247n\243\312\327\322\277\371\345}Q\346\354\255?>XJ\274c\244\275\277\221^\222\224\216\034\242?\n&\036\310\273q\314\277\252\267\373KuV\313?[\213\230\272\025\300\202\277\267\373\224\2259{\312\277\312,\374\203M\206\253?\346\326\007wm\267\312\277\344\211Y\351\324P\272\277n\246Z\023\345\331\262?\372\376\333\035\262\312\267?\377\217\325\032Yq\240?>\346.\016y\333\260\277\010\006b>&\252\317\277\260\235\331\377%B\301\277\032{\244S\251\367\301\2779\352J\235\352$\304?|\351\223\253\242\262`\277\364d\316\364\221s\274?n\212\355\333\035d\241\277\314\350p 8a\267?G\3631;I\251\273\277\333\333\352_\313\357\305\277\356\370\216\333YW\347?3W\217\232\323\255\360?\271x\271L>\224\356\2779\307y\242QT\326\277\000\306\244\233K\271\264?\021\252\305\215\301\355\267?\372\213*\017\225(c\277\261\245\3079\365\346\324?\313\250\243\245\n\311\314?&\2556\037\265V\355?IuB\016\217+\317?o\347^\223\242;\266?\351\353=\211\332u\310\277\033\341\262\260\r\304\263?\220m\220\312\225k\264\277Zm\2742\002\257\332\27708\367j\2549\214\277\302/\3559\325P\263\277\372\363\224\213\341g\274\277\361J\017\302\013\241\225\277vLJ\364\274\022\302?r\347NH\227,\321?\233^\335r>\003\322\277\034\375\r\\\365\364\301\277\234Y\301\242\207\314\312\277XS\356p\222\326\253?\245F9XMN\310?h]\241\323\330\300\307?\231\324\007\265\025\246\266?_\371/{\253\022\302\277rm2-\322\013\314\277W;\356\212\264\250\303\277<\033@\312a\230\257?F\216f\250\361\366\300?\"\n\2425\010k\307?T\360\3747;\327\212\277\240\036\307\006\353\320\256?x\3570\307\211\257\265\277\346Dv\227\337k\272?w\3578\263\302\305g?\372I\"M>T\340?\222\217\3503\330f\361?\206\315\257D\324\343\353\277\317W0\357\346Z\320\277=\327\301\010\330\314\302?a\016q\305\204\234\277\277t>\013F\231\212\267?\350\351\007\352\201\366\323?\217\017r\0232\013\313\277O\007\263b\276\252\336?\224q}r\375 \321?\\\374\243\2724\234\213?X3\001\201\024\237\302\277\233W\2568\033\037\315?\353z\226z#j\204?Ci\346]\"\323\313\277iJ\007\004.\243\267?8\274\202\237\374\001\275\277\264BH\003\244H\266?\201z\371j53\213\277\275\244\000M\371T\313\277\222\272\352\2434*\214?\316\250Dew\275\301\277\007\027\215\350Z\301\306?I\314\003\272\030\211\222\277\300\'\321z\017H\243?\002\224h\3511\343\303\277\263\014k\370p\245\234?\210y[*\030\214\215\277\003\234u\266\325\032\311\277e\002!F,\031\303\277\006-\257L\244\312\255\277\341\237I7v\217\265\277\371\024\001\321\350,\243?v\255&\357E\262\255?\257\207\253\222\322<\270?i9i\361\352\237\320\277\005\027\351\370Nv\310?\336g\266\341\306\342\267\277\326:\216\001\347\274\315\277\262KI|\341\243\316?f\326&1\246{\344?,\342d63f\342\277\367\233\267\t\234\234\312\277:\231e\346\326\036\303\277l\301\307S\023\374\234\277\220\367\341\366\225\202\306?\253TC\033\322H\273?-\276\301l)>\263\277Sp!s\217\266\332?[\324\202\030\025\016\263?\322&w\007\304m\207\277C\214n\305\001\350\261\277\227\312\372\313\345\210\306?p\274\345>T\353\274?\372F\212\351\3606\326\277{\333X=b\030\274\277\215\023\356?\230ov\277n\331=\270\005\030\252?\035\265\026\313\301\300\305\277\203\267\333tF}\272\277\273\372\317\307L\222e\277\267\002cq\256\r\272\277r\006\027^\2503\234\277\2051\326\371\270\317\241?C\352\222\220\0028\271\2772\237\026\205?\005\202\277}\026\223\212\216\320\305\277\254\273\251\344\260\324\254\277y\320\357\374\250\207\263\2779\225\204\n\261\342\320\277\206\374$u\270\353\305\277dh\016B\261\026\321?\227ye;\035\320\270\277z\230F\022\274\207\300?8\344\033LA;\220?\322gI[\332\t\264?\366,sf\260\356q\277:/w\262\205\367\240\277#\207\216:\223\363\305\277\230\307\337\021\375\"\307?\326\202\021\010\350\021\332?\304\233\371\370\205>\323\277f\005\034l\221=\231\277\270 \350$l\246\322\277\374}\371:\202\231\223\2771\301\272\341\035\251\251\277~\000\301\363.\031\220\277\236\"6\023)\036\301?\366y\214\002bB\342\277\243M\007\2136\013\260?w8o*^\220\224?Jm\033\331\234\340\311?\316:\216\210\266]\302\277\204\354\250\235\340\306\276\2777[\312\207\2763\275?\277\211x\223\322\256\320\277\316H\004\tf\023\304\277\243\233F\312m\327B?\215(\360\325\242\021\201\277\357\335\233\226%-\263\277L\207\357\222sd\237\277\3448\236\255\031m\207\277d&=\364\357\264\236\277x{\302\331T\364\244\277\373\210\325\033\016Q\251?-\336\322=\026\262\255?\014\327\330\305Od\267?\210vT\352\236\007\263\277\342[l0\355y\310?\027R-:\361\276\323?\236\246\340\204\272 \321\277e\211;\223W\324\263\277\352~\370\273s\224\301?Di\3171\214\244\300?\346V\233M\232>\263?\343\331\213F\r\310\310\277\022G\201v\364J\274\277\r\332.\264\3215\244?\367\267\002\'b\007a?\272\221\256\207\362>\341\277\3240\034\312I3\346\277\351\272\365\207\331.\337?\030\274%n\204g\267?\217\353\251{\226\202\320?\2719b\375x9\273\277\270@\305jwD\221\277\332f\036/U\014\311?\377p4\343\230U\272\277W\202\376W\332\237\340\277,\3102\354\311&\262\277\264\032\212\0133\301\261\277\326\345\3028m@\260?\220J\331A\256\014\314\277\313\364ToZt\243\277\321\210+\204\rc\323?\\\225\334B\244w\301\277\360\254\204\230q\252\265\277Z\216L\216\360\214\247?\236\220\325\223\310\362\307\277/\331\230z`\301\276\277\010\247\335\251\024t\244\277\237\362\245+F/\245\2776s\213\374%\252\303\277\356}\315F\223A\300?\333O\270\tl\216\306?i\334;\311\372\205\300\277I\312\236b\013\362\266\277\256%\'\\\253\245\214?\006\245h\255\014:\277?\354W\350\356\211\217\324?\305\013PO\221\237\274\277\323\357~\264\250`\260\277\2041\313\032\223\361\262?(\256\210\017\2329\277\277\014\002\356[\221\234\325\277\022\254\331\361R\002\224?q\2715U,\225\301\277\201|\250\225\347\274\250?+\002\361\326\274\300\234?\004\274\354\315\022\014\330\277\264\300\005\274\201\266\343\277y\307{|\2771\333?\243x\303:\236(\304?p\037\317\264\034+\322?+~d\254\261\252\257?51I\346\307\337\233?\225\275\215yzq\312?\275\001\006\330\225\344\303\277\027O\221\315\320\314\354\277\'c\302\001rg\273\277\004\374k\026\341\207\261\277\027\217\026\202\313~\301?\266I\027\331>m\246?\034\354\321\211\241\345\313\277\227\253V\334\262\305\254?D\215\3028]\231\300\277\275@p\253\340b\263?\354W\216\032\213\177\316?5\326 \237\242\331\270?\362\262\327\333\352\353\263?f\305\031\352\230\376\323\277\252:S!\257e\275?\326BN;\2537\303?}7-\374\321P\220\277\r\2472N\003\n\250?\255re\364OD\246?\343\t?5\332\373\303\277d\276T\347D\210\276?MT\237s\247\337\216?\360\342}\221\205\341\277?C\201\354C=e\207?\261\210\272\277\231\014\264?\355\305\373\2744\241\302\277\033\023e\026c\211\305?\367\245@\301\177!\264\277<\260\367c\027\\\267?%\305\212[\322\334\273?\021\254#n\260D\243\277\327q\205\027\356S\307?\020\313\2121\006\330\333\277\320\222\276\2355\272\357\277\337\021\247e\244\031\351?a%\311\000g\247\260?\347\314\301b\363\001\303\277\354p\203d\030\326}?\207\016\262@\241\223\274\277\257&\'\024\203\245\317?\243\313X\231\020\374\217\277\213/[|\030\322\344\277i\371\360@\370\007\241?\202V\\\177\'\313\266?<\376\205\364z\010\322?\340\024 \225\354}\205\277\236!0\307_J\202?\336\327\224\306\031\275\314?\343\321\353\301\351\345\311\277\320/\366\256D\364\301\277\240\273#\334\260;\231?J8\316\3633i\256?\177\260n\354\006\373\244?\000\353\343\255\250\226\301\277\301\351(\235\256\032\311\277\353\361\032\373/\325\272\277\013\007S\322\316\335\313\277N\340\333K\344\"\261?\257\235&\220\264X\267?E]\210\016\314\225\301\277\374f\326\335V\\\277?vM\302^\355\264z\277VMo\030\213\227\272?2\004\221C\210t\313?b\037{\314\236\217\271?\374\337\313\2004\223\275?\213\036\362\002\036\337\304?\250\221=\306\365\324\273\277\005`K\355V\224\275?>\034&\017vq\261\277\323$\354\231J\035\253\277\'ri\022\217(\300?6Gb\230\314\"\337\277\356)\305\210\272\216\354\277\313kC[;\357\345?\256\273\244\316\363\321\300\277\t\366K\237\345\256\316\277h|n\0329I\273?\224\303d\203\370=\272\277\014\351\024\355Y_\212\2773F\030}*\205\300\277\345z\361\024\026\356\251?$\270\317E \363\301?\212;\325\215\313\265\320\277&x\234\223\350(\242?\344,`\241\232\371\320\277\0370\305\243\023\322\251?L\354J6}\247\271\277R\000l\3704\302\317\277_\030\374\233\223[\325\277\374_\3217\025O\223?-N\223\230\356\005\271?\22229t9\322\313\277\321\313\236\301\025\002\245\277\352\231\026\354\360\342\202\277A\265Ygy&\214\277\272\244\267C\220\177\246\277\000\216\312Zp{\240\277X\241c\246\246\217\310?\371\331)\217\017\006\277?E\'\332Y\350h\245?\014#f\212\354\335\267?\214\3078)\200\207\322?\222F\300\352\022[d?\274\214\270\302\303W\253?\261\003l\026\345M\224?\261s\304s\321\307\214?\3660\370\260\360&\262\277*F\312\014\337^\203\277c_\340vg{\313\277N\374N`\214i\306\277\204R\346\270\261Ij?n\t\304\230\n\336\325\277\231g\034\265$\212\225\277\236\001\000\0034\367\316?\320?e\2603\277\300\277]\234\352\233]a\324?I\300\344\342\300\357\252?\245\3719\315\014R\243?\236J\335w\017\276\252\277\260\3023%\274\r\217\277n0\007Z#\274\266?\202\2534S\311\215\276?\251\325\303\177\204\351\202?\362\005s}\026\327\272?$\\\317 \351\274\327\277\374\013o.\362\t\254?\2755\354:o\003\232?\3136\037\260\005\315\270?\340\243\261\212\260\010s?\0331\"\217\312}\270?Rj\007\225\325\336\306\277\257\267L\316Iq\271\277cY3\316\360B\303?\255\207>$\336@\314?9^\221oj\263\247\277+U\270\003_L\275?+\216xoP;\304?\375{\251\300\024L\265?#y\326\351\177*\204?\240\013>\205\036\037\245\277\215\254\\\022uo\321?w\241\223\036\315\275\323?\025m\305\356\373.\255?3!\321zq\255\206\277\271\035}\351\3260\313?mZ\020\211\032Z\301??\273\324AE\272\304\277J\354\230\036\255k\277\2772\014\037f;\354\304\277\241\322\375Hcv\243\277f!\034\375\312\225\261?\305\247\271\022\022|c\277\031\370\212P\323\036\314?\250\316\334d\346\244\244?\224\007*\023\366i\272\277\232\332\200\3231\312{\277u\r\346\210\177\337\313\277\333\274,N\212P\266?\200\202l\377\360\'\304?\312\304\303s\014c\302?\037b\270K\246\310\322?\240\345\366r\242\352\301?J\265\261\014\027\332\203\277pO\320}+\347\237\277\206\351p\360$\204\271\277\000pcS\364\221\262\277$\214\334p\177\356\244?|vu\204D\303\264?\265\272\023\032\003\304\223\277`\0054!\237\265\251\277?\343\252\224F\246\253\277\017\333\236\374\246\245\302\277\267\021\031\350\r\351\264\277\273$\322\r7f\325?#\250\334\004\372\007\221\277~E\307\345T\250\275?[+\010\221\307#\273?\306\303)\256\311\355\270?ph\250\304#\264\314?\004e\010\364\336\321\215?iY\230\344\235n\250?\265~ Za\332\311\277bTT\202\210\t\305?s\316b\315\236\336\267\277\361\246\320\3638{\267\277MC\\RK\273\257\277xN\255\222\"\225\246\277\260\225_\001\233}\254\277\271\256\030Y\313\211\226?\257t\200,&\272\253?\003e\271\206\320\230\177\277G\rm\017\n:\233?\035Gv\213(b\333?\325V\035\3538g\322\2771\260\274\362\225\032\315?i\007c!\330o\313?;\310z\374\275\\\244?\235oMH\'X\247?\253\375\177a\005\022\260\277EZ\3456]\030\256?\234\\\242S\337`\342?Xm\360\316\3762\307?\256\362\314f\030\010I?9\306\376\223\021\026\241?\373\346!\030\303\237\314\277\253O\021\352\"_\327?\334wn\021\306\227\314\277\005\226\205\216-\257\301?q\273B/\330\235\241?\245o\241\237\304\341\235?HrJ\345\010\310\314\277$\357\334\005\227\000\222?\261w\n\034\344\335\215\277\222\300\201\207\264<\317?\221\0072\004\026\251\265\2775fA\032#\222\235?!j\025\375\177/\247\277 \230\035\0222\203\224\277\363\321\367\303:\264\272?\'.\030\237;\271\243?Z\246\"\204HM\211\277\261s\356\241\224\352\255?\205}?S\037\257\312\277y\024>h`\342\304?x\245\211\242\n\205\243?\244\254\025\214\337\307\256\277\225b\372\010)@\306\277A\263\312\025\021 \264\277\270Vr\337 \207\261?\305\352\355\310w$\216?\260\020\033X\250\344\311?\352\373\313y\221\341\216\277nn\222\335\324J\332?\304\001\002\027\347\340\327\277j\265\236T\205G\217?mV\332\367\266\271\303?\2336\240\206%<\303\277\267UcCE\267\235\277@\3217\244_\251\261\277\271\022(\364\215\333\304\277\0242&\334\371\300\327?\372)\000o\302n\241?\004\003T=\217\352\227?\230\337OVJ%\324\277\363\237\306\230\274\332\330?\205b\022\303i\243\273?\225\242\253R\374\244\322\277\331g\36463y\253?1\nLE\004\003\224\277H\'o\321\203\250\314?\260\'\024\331d\230\275?\234\262\333]\350\202\303\277N\215\216\350\270r\321\277\312\017\360EM\270\270\277t\375\024\306f\212\250\277b\030\364\026k4\244?\225\341j&\375Z\262\277\375\201\215\207\230X\321?\202\344\352JUb\222\277\332bF)\250H\221\277J\352\326\017I\244\271\277\035\217oq/T\312\277\326\354\265\020\2266\201?K\nc\360l\314\307?_\267!\177\322\345\234?@X\336\376yC\311?9\224&=]\265\274\277B\375\324\231\007\233\241?;\312\231\267f\357\313\2775\343\341\200q\346\274\277\367\344T\273\353\363\270\277Q7\356\232\002P\335?G.!\327\305\214\343?\002A\240\354\313j\350\277\344L\210\312\020\365\320?\335\216l:\270Q\310\277\002T\224Z6\023\303\277\224\306\3104H\361\261\277\025\252\245F\362\327\314?\261\010\270\206R\222\236\277s\217\213\257\247\220\324?lCC[\340\367\245?]~\360\355\344\341\202\277\"\210\375\353T}\272\277\007\243lR\331o\315?\237\000\n|\245\212\304?\247)\031I\031\005\323\277i\300V\0240 \272\277\276`\036\022\322\201\265?<\335U/V\236\273?BI\270\261!g\360\263\277-\314\2122$0\304\277\352\017\316\242\233\325\241?\277\311\361D\020\220\264\277\346\213\212\0172\013\261\277\200\202\335\311\354\267\267\277\372\274y\265+4\247\277}[\337\'#\221\216\277\272\225\255\344\'\364\320?\237/!\212C\324\306\277\020\020\034Xk\214\334?\005\340\350\273\341\333\356?\036k\'`\257\323\355\277\231\337g\343\364\230\251?9\033s.\334\277\260\277\316n\004\332\313[\256\277\221\217j\204\317\360}?\340\001\000ldM\257\277T\351\234\364\336X\301\277\301C\027\235`\300\335?Qb\347\251S\021\277\277C\304\262\324\272\322\243\277\213\311\265\321G\336\303\277\300\233\262C\273\252\303?\037>\273\204J\225\261?\206\351\221\35389\270\277\266|\365\251\341\264\206?3\"\274s\306\347\267?JL*e\013\223\230\277\010j\'\211\261\201\262?c:Z4U\034\264?\267\302%\250\264z\272?]8\276X\236\305\261?\334\2145W_U\302\277\332\356M\312,\230\247\277\252\016\255[\007\006\221?\321\306@\014ozx\277(\031\013\374(\026\303?>\224\272\254(\273\254\277\0269\356\314\022\035\276?u\254\200x\210w\256\277>\320m\014G3\251?\235\237@\"\372\001\226?\004(\222\202!\256\250?\207]\215f\361m\312\27766\204\025x\005\265\277C\252\273O;\201\242?\226\316*\253\345\233\312\277!\265\222m\"\313\243\277\225\3336\022jK\310\277\352c\253J\271\273\337?\363\337\345\274\254\364\347?\237\220U\375\263\211\353\277\233\347\tt\245\335\301?\206?TKBv\247\277\266\203\307%\010H\305?6\273\234\220\214\033\301?\022\236\017\031h\0344\302?g\307\324\363A\360\245\277IB-\331\217*\264\277x\030\273d\223\254\316\277\240_&\375X\207\337\277\262\273!\351\221#\272\277g\321\243hhv\203\277 q\340D\340\330\311?(/\334&q;\320\277\243\314U\323\237\242\244\277\001\244\353\025\333\322\302?~\347\302k\034\246\305?T\331f\220\221\300\260\277S\016\013\276\221\"\304\277\200\326\233\260\245\310\330?\313\245h\233\030\236\354?\225\017p\347\262\334\344\277z\254l\303\265\310\271\277\334\037\205\245\005\363\266?\344\375\004\363\241&\313\277l\253\253q\025\346\240\277S\tx^\326\311\233?2\336\t\022\237\301\211\277\322\267\023\363\341\"\346?\034\232\014W\025\032\261?U\360\342zA\307\242?d\350\346\353\340]\310\277\302\326\014\315t\361\301?\017\361\267\007b\270\252\277\341\r~p\342\347\320\277\271\345\010\357\035\271\324?}\010A\2413X\302?m\311x~k\225\247\277\r\253\026W\2376\314\277K\345\362\326b\313\304?\253\222\332l(\342\274?&\304\261M\216<\222?\360\263\355\255\265\335\302\277\0038\003\004?\311\276\277\226\271jk\241+\277\277\370\\\360i\323\240\266?M\217\234.\325R\263\277\342\340\3622\354\023\260?Br\347\224WS\322\277\206#\024O\361\260\274\277\342\311q\356?\346{?\260\311e-\002\360\230?\212Bu\236\210\357\222\277\302U\220\365\257\207w?M\001\345\2718_\275\277y%\034\024\367\342\301?h\222V`\233\005}?\"[xw\234\303\311?=\223F\230\235\324\325\277\350u\013\273\244i\324?\206\324G\226\237\223\360?\2730\030D\005A\344\277LC\217gk\014\323\277\000\373\001\322\3170\234\277xA\311\356z,\302\277s\025\3707\341\020\226\277U\273\314Y&\264\307\277b\200\266s\246@\203?\235s\272\362m\367\330?\264\230\226mj\277&\210\367\323fP\304?5C\361\271\353x\272?\033Z\224.\267\311\322\277\325\307\016q\030\250\271\277\010\273\343\013\\5\300?\306\357\317\267\250\335\304\277\377\033Y\371\236\303\255\277\354\276\036\361\350\n@?\212<\013\331\020o\246?\361\361Od\241\227\240?\373\274\210.\240R\244\277\000\244&\000\320x\251\277\331o\341\366r\257\260\277~U\356\334\256\304\204\277g&B-C^\304?\317\326\177\265\035m\256?\216\274\2736,\307\266\2776yX\212\n\r\326\2770\202\005zK\255\313?\365 \217\2567]\235?\033\312\357\004[i\253?\002\206\374\346|\232\277?\\oW\307\336\215\246?\032\025\364\311\373y\271?\240\325\300\337f\376\262?QS\326\246y6\252?U\206\376\365\337\013\205\277\333\270\351{tN\325?\035K\340\023\326\\\341?y\342\005\312\265[\333\277\002\341/\325\213W\271?\334\000+)\275\374\263\277 \271\260\245\t\202\321\277M\033a,\200s\266\277\314\307\224\213\210\343\301?)o\264\204{\352\214?A9\272\234j\017\326?&u\256\247\363\344\310?\006\322\352\371\016@\303?\021\261\251\001\031\343\314\277\320\031.\275\222=\316?\237\027=v\\\376\307\277\276\303\305\336\323\334\265\277\030\321\244\013\240\020\270?0\'v\222\220O\316?\033\376\013VLl\301\2772\272\376n\376\312\233\277|\362.\023\257\273\262?O\353o\364\220\363\304?\357\255\364\375\005J\247?\230JF\337\242P\303?0N\333B\005r\263?v\3134Q_\301\267?LDF`\325\251\220\277\326\326>#\251\274\310\277)\256`4\312|\245?A\221\21227I\267\277\277\37135\3721\324\277>p19\225N\261\277\0075\243v\020\036\256?\346\232\200Ot\364\243?`w4\334(\310\304?^2\235\276\023\026\250?\233LY\340\346\262\271\277\360\325\303O\266\254\242?\355[d\335\340N\305\277\202z\022\236\245\262\322\277\345\313\341^jQ\321?\021E\026\006\200\323\337?\310\342\334o\025\002\332\277\331\345\343v\221\223\304\277\202\206\342}\\f\266\277\267\036\260|M\354\305?\365\366\264\356e\350\245\277\212\277\324T\320 \270\277\205m=\266~q\313\277\353\207m\231D\231\354?\363\021\270\340\373n\304?\370\364aR/\205\240\2778\233\261Z\206i\245\277\020\313Nr\000Y\263?X\255\242\367\374\257\321\277\214-\342KZ\230\257\277d\304,_\202\007\226?V\007o\036%\263\242\277\347P3y\372\205\306\277]\004\353!\377B\204?\377s0\006K\364\203\277]\2039\023\230\257|?\344+\356\215\260\346\323?c\006\272\210-S\315?\316\2362\210\371\351\242?\\\310\031\316d\027\251?<\375S\264\376\360\245?\245}\005Q\305\221\223\277\013-&\271\205\007\270\277\234$\301\221\207\341\217\277\022\024~F\342\357\227?\270\"\315\264Ml\245\277\031\265<7\027+\305\277/L\331\0311\255\304?\255\026\233\307\r\255\312\277@\260\206\027\324\316\265\277\325\025_HT1\225?,C\202o\234\304h?e\007\237\312\216\271\240?\203%\354~=5\254\277\356\202%\260\242E\342?x\205\226{y\033\360?\375\346\370L\230\351\344\277\322\333[c\233\301\305?e\3244\251\214q\303?\236\001\034\246\250\212\273?\334c\024\247*Z\305?\177^\021\371\037\216\255?T\251\217\216Su\303\277S\342\375\0260\212\347?j\311y\305\233y\304\277p\245L\360\010\330y?\233z\374\314B\\]?Vy\276[^P\307\277\244\3307k\'\250\272\277\262\217~\354\201\026\321\277\306\263\000\277\346\265\327?\004\257\306O\230:\241\277\317E\032\334v\203\316\2777\344b\246\352\310\323\277\343\341\2367\235\213\275?\330\372V\320u\007\316\277\252\361\260@\035\215\332?\t\263\260\017\341^\275\277\320\331\376\336b\351\312?\026i\347\377\244\270\251\277\242\265\205\202\270\335\277\277\213\201X\252\027r\242?P\001(\3401/\270?9\322\0204\205\017\303\277\357C\341\017q\341\223\277\276\232\361\350\177\264\307?415y\264A~?BH\324\277A_\267?7\020Z\321\357g\242\277\035\262\347\026w\240\225\277\333h+\233\377\016\224\277wX\000r\356\270\261?\203\364\272\327.\033+?Wh{\3433\204\233\277\033\363\335R\202k\322?WYY\211\007J\351?\232\233\367\204\236\354\343\277.o\216\370\301\372\252?\244\275\261a\244\010\301?~F\2374\361\005\216\277\016\373\230\"\013\233\251?\372\016z\273\006\243\246?\205Zz\335\022\247\220?\253\036>t\356/\346\277\200<\204\001D\034\301\277%7\216\257\003\233\305?p\227\306l\363\274\240?\311\r\267\346\337`\261\277 \263\326\247\225\352\235?\306\340\253\004?\355\315?\\wG\227\2536\276\277\201?\230& \313\236\277\273\230\354\227\224b\311?x\242\370\211\037C\274?\340\274\301\245q\331\264?\372\n\016c-^\261\2779\272.\334\361\330\306\277\334\333|\027g\242\244\277\3137\n\314\233A\266?\203\343L\205EG\273?B\343\376\024L-\226\277\t7\325\257\341I\323\277\0067u\302bN\226\277\374\371\334\020{\253\301?\3648>\253\216\263\302?\314}\034.\327\321{?\253\345\274t/\023\264?\203j\323\272\200\230\311\277\"\251\2079oY\256\277\327,ow\210\231\304\277\323CNeYE\301?\010k\323\201\034\307\246?-\337\215\324\2551\260?\250\0102-}\344\305?b$g3!\177\336\277\016>3\346\322\352\352\277\013\3149Bk9\352?d \322\270\020~\253\277&\276\037\250\352\316\260\277\322\240BJ2\025\227? \340\264\332F\017\306\277\205$\312\'Dd\251\277,\332\006Q\352\335\256\277\025\210\205\240\264\276\347\277\31416\324+\263\266?\000\227\212\235i\261\246\277\250\337{\033%\202F\277\034\306\026Rp\353\267?\206\257\306hz\217\217\277\274\331\360Q\2544\324?\236\343\345\274\266m\254?\252n\033\306g\330\266\277\025\353\261B\231<\317?\255}x\221\373l`\277(\205\212P\245\217\264?\027\023\245\317\215!\257\277:&\234\230\023\247\316?o\034h\230\242\025\244\277\013\376\030J\\\032\263?\362y\371\344\225S\316?p\321\340\250\3744\252?_\206\245U\260_\310\277\024\177-]\326\243\241\277\323t\277\007MO\263?&\354r\273\353\334\273?Y~\205:\365\324\267\277\330.\030S\262\321\275?\241\367\221\205\2457\207?\246\316;\213w\370\247?]K\021F\004\221\264?\033\003\255!\215\276\301?\2773\257\216\273@\302\277\311\303\203O\322?\276\277\205\366\247\354\331=\271?\n\027Vq\003\344\335\277\311M\232\337\005o\353\277#l\375\001\231J\346?\341\010\033\342\353\360\260\277^{\006^\030+\301\277\376\346\243S:\375p\277\036\241\230\265\341&\200?\027\223\243(f\020\321\277-\003:\337X\337\321?I\316\\\322|\035\326?\235\330 }\002?\254?\361H\350\rt&\301\277\252\274\213\314\234\272\300\277\305p++\321\224\254\277oi\205\327\314\200\270\277\013k%\n\037?\273?\376\003/\344\203\031\304?\342\3111u\265r\274\277T\032\336\267\006\264\224?%\204\227\332Qp\303?\360k\374\365\322\347\235\277\263\351\005\260p\373\275\277_\304E\010\323j\306?\236\211)C\017Q\245?\240Ig7\361\034\327?\343\347x\362t\342\266?\340\265Pi+\036\210?\307\232\205\340`\247\305?6\010\241\250\216S\226?v8\201C\340d\275?\314=Q\330\006\246\265?\354!-\300\3212\255\277\270\035\343\233\353K\221?\270\343\370\347\227D\260\277\014\027\364\351@]\311\277\000\252d\333\343\020\306\277M\361Y3y\276\277\344\211\233\264R_\223\277\n\366\203\3770\237\333?\360t\002\345-\340\311\277Y\215v\325\374\310\306?\271\2028\020Z\244\306?&v\364\2741R\302?\223\224\340\377+!\302\277)\271#8\356!\273?\223)\213FAx\242\277\304\261,\"\311a\303\277P\275P\026\014\'\310?\343=\302\365X\222\321?\331.i\273s\013\215\277\010\0058Zp\344\305\277\274v^\376\003\367\304\277\247\032\251b9\006\316?\263gl\325J\260\271?\274\362:E\264\364\250?\3358\306#\303\235\302?\310q\375\214V\026\244\277}\211\235H\325\031\177\2776\215\010\002\270E\213\277\001R\177y\323)\314?\"\230j\323\022\204d\277\210\301]r\")\253?s\027\206\324\237\314\244\277\305\214\010\372\252\020\343\277\357\267\006\232d\311\361\277\236\264\200\324\027\026\350?\253D\342\304#_\300?\223\364\023\257\375\307\317\277\023\246\025\000\302\324\301\277kV\356\031Y6\215?=\265S\216qX\302?\215\032\002\266\366\027\264?\247\273\003\255 \234\327?\226\240\363\212\351\177\305?\341\243qv\324\021\264\277O\266,\253.\354\317\277B\000>\231\257\362\317?}2\342\343o\331\303\277\372\200\337\322]\352\320\277\261\306\023\337\307\244\272?\312\206\375\000\025*\231\277\212\233EtJ\016\301\2770\255\"\031\306\367o?\026\317\246\"\203\356\276?\214\370T\237v\204\313?Lt\377\230\270(\246?\212\256\257\254\251\210\235\277\271\"\241\n\233\343\234\277\344\005\014\322\360\275\266\277\243\201j\214{h\247?\345\304\322{\312X\272?J\330>\002e\206\221\277w\365^\335\021\017y\277\023\351f\242nO\303\277\214P\373GJ\'\301\2770s\261\205=\031\230?\017\205,\242\037x\302?\361<\343=\224\366\256?4d&\255t\370\275?\013\210\330\224\247\221\274\277\366w>\020\216\n\260\277G\237\t\317d\237\223\277\252\2601\346\022\270\261\277\320\235\276\255\342+\325?S\036\246\026L\222\345?\236\313\253\305\033q\347\277.&yI\r\030\245?\353F\330\265\261Z\310\277\325\331;\337Y4\300\277W\373\350\236\021\300\303\277\277\020\007v\273h\262\277\350O\331~\277\315\267\277D\374(\246\224\333\337?\317FS\360\375\213\270?M^*!\nN\226\277\375r\352\004\322c\316\2779&\335\013\251\014\327?\'P\260n>\247\305?7k2BH\"\304\277JA\215Ff\202\277\277/\276,\037\2077\266?t\023\3308\305\276\275\277\231\326\316 \366s\310\277w\022\303w\210\257\317?d\203\341\200@\244\300?\r\000\010:\226\347\204\277J\3325y\264B\303?r\237\360\031\342c\264\277\266=+T\033z\246\277l\377jF\005\n\224?W \216\235\335z\233?\212\211\315\275\211y\260\277V\212Y)\221\027\303\277\277\177,\243\350i\316\277}\013\337\254On\245\277\016\302\235n\345r\210?V\023\262l%\232\274\277c\263\037\245\232\000\306?\312\320\263\361\023Z\206?\024/3\335\337\375\326?\253|\320\220~\332\235?\241b7\215\004\\\242\277f\214\210\021D\233\314\277Z[\214o\332\365\306?\037JT\221\271p\340?\034\037\225\247\2317\346\2774\016\3058\3049\274\277\274B9\334\343\320\263\277\0204\202\224L\277r\277\"p\224\2566\345\271\277\337\213\035O\307\313\202\277" + } + } + } +} +node { + name: "layer_0_type_0/matrix/read" + op: "Identity" + input: "layer_0_type_0/matrix" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_0_type_0/matrix" + } + } + } +} +node { + name: "layer_0_type_0/bias" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 40 + } + } + tensor_content: "XeN\270>\260\364\277Ax\224\251\302\261\256?T\371\016?Y\224\334\277\250\001\350\353\307\001\335?8\004\263\\)%\327?I\022)\222]\226\313\277\323a(#\304&\352\277\315\206i\252q\342\302?5d\241gQ\\\221\277\267&L\257\264\357\377?\206\253J\247\322(\332\277rC\345+\210{\234?\364\373b\331\2410\332?a\347%\370\030\004\360?\223\214z.}\n\367?F+S\343}\316\360\277\365l)\037\223\371\346?\353\215a?,_\342?\361yTh\254\354\316\277\276J)\362\200\346\375\277\207\\\313_\227\365\342\277\321\335\232.\264 \247\277[\224\203%F\216\266?\214^4i\005[\330?\024#\315\273Ql\002@\222\357\226\237`#\342\277@.=\010\325\264\370\277(\321\360\346A\203\366?\323\033A\032\276\325\340\277\\\035\360\024@v\330\277\234\350\032\345)I\356?0\301\253\207\272y\312\277I\nU\020\374\320\324?}`\376\253\374[\303?\222;>i\257\266\257?\367p\376\r|R\007@\321\360\311\0358p\372?2\347A\025\317\263\372?:\007\223\277;v\375??m\274TYh\355\277" + } + } + } +} +node { + name: "layer_0_type_0/bias/read" + op: "Identity" + input: "layer_0_type_0/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_0_type_0/bias" + } + } + } +} +node { + name: "layer_0_type_0/MatMul" + op: "MatMul" + input: "Reshape_14" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "layer_0_type_0/BiasAdd" + op: "BiasAdd" + input: "layer_0_type_0/MatMul" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "layer_0_type_0/Tanh" + op: "Tanh" + input: "layer_0_type_0/BiasAdd" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_0_type_0/Reshape/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377(\000\000\000" + } + } + } +} +node { + name: "layer_0_type_0/Reshape" + op: "Reshape" + input: "layer_0_type_0/Tanh" + input: "layer_0_type_0/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_1_type_0/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 40 + } + dim { + size: 40 + } + } + tensor_content: "\2620\322\214\014\216v\277=\2557\215\247\343\310?\205-s|$\326\300\277\231\211\177\333s^\224\277B\230m;\024K\213?G{\262\246gC\300\277\022\331U\236\034@\300?\321\366\272\336\260b\225?\003(K\307\375#\301\277 \331:hCs\226\277M\253\202\353\305\177\263?\203\032\331|\335\003P?\003Sj\2660\017\211?\275\303\274\365\256\334\225?[\375^\234\007\234\202\277?\033\206\357\003\370\306?;1%\326\212\002\230\277\304P\310$\206m\273?@\221\354\3406\010\276?A\000\001\014\034\024\274\2775\177\375x\371\365\274?eN\313\274[|\252\277\034\365/\230\032h\313\277x/1b\024>\274?\214\276\225\374\355\241m\277\320\230\375U\372\277\210\277j$\332\026\002\345\237\277`\320\2256\371\222\260\277evr\262U\r\306?\257\272\225\305\245\317\320?y\304\020\350i\271\302?\n\361\'`\310\030\212?)\372\363\320\251r\276?g\377\375 O`\311\277\214\263\277\327`\202\317\277\202e\022\0038\030\311\277\347W\307\311L:\274?\253\274-i\276\023\266?\270\357\320\336\326\354\224\2772&\201\252\207\374\212\277\233\224\337s\257\260\246\277\353\372\013\272\266\305\200\277\277{?\224\'G\266?N\344o\342=t\277?\316\236\271\301\346\242\333\277|0\213|;h\331?Br\205!.\017\265?0\\\244\007\033\322\307\277\317\264\267\303\256v\346?\253_\225T\3024\310?[\363\341\353\3372\264\277\231Y\010\246@\234\266\2770\316\000\031\235\304\021?\0379\211,o\036\263?\023\0201\302Z\031\221\2774\362\273\210\212\303\275?n\204y\016!3\233\277\3131\2253jb\231\277\336\002\020Lu\340\263\277\233\271\316\t\212\'\314?\260\362\201\035\351\"\313\277G\000Fu\246\017\327\277\305\221t8\300\264\321\277\321\250r\345E\226\227\277!\3322\340@\222\261?,\333z\346\264Y\304?\013\347\226G\'\362\315?\323\244YH\335\210\241?D\237\227\007\263-v?`\367\235\370a<\363?\326\352\007\013X\255\264\277\361=\220\'k\272\343\277\024\231N\303\366d\347?\336R\022\371\003<\312?=\371C\"\025\240\246\277\026\376M\023p\272\227?\022B\260\t\255\010\326?h`\370\313\033\345\272?\273\313\222\373\315\365\311?\215\037F~\r\033\275?\260\304\222\326\205\261\254\277\310u\214E\324a\247?\345Z\032N\207\274\226?1\304\332k\270 \310\277\336}~\023\016\262\302\277({&`\242S\312\277\037\367\344\205\313\372\253?*\203!e\272\223\273?\024\336\3725-\366\277?\022[\005\250\\.\242?\362\302#\2674\026\223\277ub5h\254\003\271?\312\267\n\366\027!\317?\"bfd\334\324\310\277\260V\361\361\312\240\323?\r\210;vUE\211?\022\032SI\251:\266\277\221d\266i\024e\256?O\370I\357\327?+\205\244\307<(\277?\023O\037#\273\262\247\277$!\236\2517\034\305?\321x\371\"9>\230?\371\232\374\344\024\331\233\277E\225\033\017\204\275\262\277\262\205\345\206\347z\252?V1\302ZG\310\223\277qr\311N\003\365\317?\"\002\371\244\255\002\237?\007\273\330eq|\305\277\360\275\354\350\n\341\253\277\346qNG\030\320\225\277\222\224\241\t\034\001\247?@\022h-\026q\320?l\032C\302\200\273\307?\343As\260\257D\311\277BdI\304Yz\264?\276\177\361*\210\277\255?\244\'L\243\215\342\252?\332J\315\257\023J\266\277\257\310\022\373`\365\241\277a\350\032\324\3027\316?\203XQHr\236\251?\022\333u\343Al\247?\362\225\246\267\346\271\264\277\000g\257z\027\333\311\277\301\3554J\250)\254?\332\244\331\211C\327\264\277\341\357\352^\004}\274?04\360\300t\n\260?\330\027\235?\037Y\237?\345\316\273\260\326\243\245\277T\270\013\246k\300\270\277\224\253\361O\364\246\261?l\026D\356\007\354\305?Z\r\215ye\026\206?D\031\253|\233q\303\277\275Pq\3264\033\301?\032kO\227f\033\315\277\2063,(\030Q\312\277g\226\332\204D\235\300\277\316&\304~\3057\304?9n\212\3679m\306?)w[\370O\016\275?\357,)\021\275Y\303?YF\'\323y\330p?jCRT\214\251\323\277\251$P\3307\r\321\277\321\247d\334\371\241\310\277\375=\303|\226E\212?\247\327\240\353W\334l\277\252n\204\034\204\023\262?at$\200\025\345\277\277\333\323\354\021l\276\311?\345\230\244\303\307\221\250?\225\310\014\327\231@\301?\025J\301\274n)\267\277i$/\206|\005\250?\304.-l\223\374\232?\023KW-\257]\302\277\212{!*^y\254\277:\263RR\244[\246?=\320Y\024^4\302\277\270\227\215\306q\335\236?\325kD{K\351\310\277\025_qH]\343\307\277wy%v\250\224\303\277\347\313y\312\037\207\214\277[\036\3548\212A\223\277?u\334\304o\334\252?\252F\273,L\361|\277\312\r\303\316>D:?\017r\0234\241\203\304\277M\026\247I\315C\303\277\205\260ZA\023\332\303\277q[\325u\203\363\307?\002S\334\246\207y\310\277]?v\223\204k\320?<\343\226\303b\034\302\277{\002K^\220\217\245\2779~\371\272e\330\270?\031\357\231c\334\003\317\277R\332\007\343#(\256?\000\245\200\246\277\225\272?\331\233G\365\347\354\263?\237s\251\326}8\242\277\2176\335\205\362\217\310\277l\352\232\320\346\t\322\277\235\243\236=\t\373\272?\367\367f\334\030\201\200\277\204?\374\220\333\254\177\277\217a\322\334\013\206\277\277l\251zY\305\276\276?k7\177Q|t\307\277\203\234B\025h(\272\277\364\317W\2650W\276?\236\247A\255\304p\217\277\247\363\316\367\201\330\234?\326\372\023\311\337z\303?\364N;\323j\002\263?\335M\275\3325\202\301?\t\377\205\031\017\333\265?\345\010W9\365\005\277?v\314@\325\"\333\255?\267 \211I\204\305\316?\266[\332\342\352\374\243\277KVj\2473.\211?z0\306\227\202\262\312\277\215\347f\372\322E\264\277\344\326t\325Xh\303\277\017\275P\\\212I\317\277(%\372\325\035.\317\277q8I+^m\250\277\016\230\360\351#\304\267\277l,\234\035\217\360\310\277B?B\3539tf\277\311\223\242\010Ko\230?\n\343.\331\030\375\243\277B\221\224\212\207O\321?\252u\330\361\345k\266\277eF\273\266\205\225s\277\205\312$!E|\267?\222\017\331S\203\213\236\2775\037\220\3426n\301?\026\261:gs\231\274?\232\245[\235\366v\321?\001|\210J\333\365\302?\010\366V<\337\377\306?\033\234\320\035t\311\235?\222\240{675w\277\033\"G\275\346\343\241?\301%\002\261\273Q\273\277\334%\261c\237\206\250\277r\231\0066@;\246\277cqfm\204F\243\277\247\212r\354\2153\270?\201\342\267\t\314!\245?\006t#\231~n\306\277f\203\377[e\034\277?\215\225\013L\347\327w?\224\371N\334d\303\255\277\244\333\344\236ig\241\277\201\202\246\224/\240\262\277\244\361\356X_\304\255?\337\223\326(\021\347\231\277\260\263\004\220u\324\314?\356\361\371\353\351\237\275?\355\326*L+\244\242?\304\033\225i\370\001\277?oz\221\363\335\335\306\277\036\334\022\337\212T\262?\374O\354\025i\365\264\277KH\001\355{V\255\277\252\330\n\300E$\276\277\016\235\246\362k\215\225\277\303\202Q\224Z\234\206?nd\361\204\222\020\322?\211\363\020nY\302\301\277\021\022\nE\375\231\240?Ilj\260\250 \307\277u()\213\224+\274?\376\314C\313I\t\244\277a\210:\200\002\275\267\277{>\322\344\203\333C\277}u2\322\323\247\245\277l\n\322\235\020\324\216\277\264G\226\276\324\321\213\277\213g\265\036\246\376\226\277c#a,\000\006\265\277\315}]dX\207\300?%\035\007\302\353\330\264?\221\207\221\353\350\227\306\277&\211\333\006\252\243\261\277\304rC0\312\366\326?\300\240`\207\234\211\325\277p\253\303Z}\230\221?n\361t\372l\216\247\277\220>\321\205\247\014\243\277\235\323\220\306\026\010\253?\031\277\214\277\341\037\267?\313G\202\276n\036\224?\035\203\365\216\367\361\274?\330\261\357\034i\343\304?\037g\376$\307\321\250\277\324x\206N\333\316\212?D\325\320\242\337\375\246?\2509yC,\034\322\277\200:kzy\030\256?B\237\n5\224n\262?2\231u\234\200\032\270\277\352\212\250\2713\013\307\277\374\006\331\346$\242\310?\235h\013\344\307\304\260?d\200\022\3203\254\223\277\321\007xw\332\\\320?Hl\217\252{\320\211\277\222\241\230\327w\231\251\277\032\005\216\370Ru\276?%\250\004vh\'\340\277\251S\214r1\256\304\277\345$wV\260*\315?\233#\344u\276\032\301\277I\320\3642\365\006\256\277\205\260\252\260\372w\311?\347\267Mz+<\271\277\210\254(\0321\256\301\277JX#\025u\245\317\277;3\270\025\004\353\261\277o\226\370\227\255q\301?\365*?\016\252\033\321\277\200\330v~\320\261y?ktN\252\253\277\320\322\272c\r\026\354?\260\367\224\370\257\326\302?\310_pv\371\345\271\277\003\326\322\347|m\336?Ly(\334o\224\313?\301\331\334\276\301\210\276?b\366 \'\020\235\253\277\35561\001\334[\232?&\366\245\215\301I\306\277\341\252\313\010\024X\323?\016\232\017\346\013$\311?U\376\335\200\215\270\250?2\003\264Va\334w?\337_@\n\367#\303\277lsS\221C\\\260?\357A\356Wy\223\261\277\366P\245/\'\355\270?\343\202e7\335\276\225?\340\302\364\265WP\275?p#\235l\0239\270\277\336r\200\315`\013\260?\311\250\2572\250\305\305?\254\370\t\021\005%\306\277\333,\017Q0\314\227\277\262\274\010\021\035\320\272?L&\364\0169\376\256?\377\023\256iq\375\231\277eo\377^;u\243\277\336L\343\223W\020\271?\267\353K\037\336H\306\277\000\220\003M\214G\221\277\250\244\333\246\2307\230?\301\376\272\"\337_\271\277\275\243_(\316\350\244?*\200(aF}w?Z\347\214\272\303;\234? \253[W\206\350\263?\r\020\251\177\216Ut\277\3066\300\255o\257\241\277\346\333\362X\345a\264?\235\001Y\367L9\317?\t\272\034\313\201]\263?M\3423\203?\273\271\277\2462\240\317\271\037\223\277\357o\272Z\216\364\312?&\216uKs$\262?d\262\334\004\350K\305?\204\352\036=\201}\272\277\313d\275\363\311gq\277\373\356\027\217z|\252?\226t\024\'\0260\206?\355bHdk\275\215?\236\341?\233\006d\032\277\n\031K\211\212\342_\277\021l\017\340\032\335\312\277\374`T\335\306\317\232?\313\352J\210]\031\302?\261\274nm\000C\224\277+\3234\363\335V\256\277\263\210\026,!\334\310\277t\332\022\024\027\340\302?\3733F\303t\277\261\277\371\305w\263Df\205\277\221p\220\302l\024\304?\201\221\221\245\244j\272?\263\264\342\007\035\217\262\277n\231s\340p*\305\277\233\2332\006n\206\314\277\314\013o\003\373\277\255\277\352O7\352\335\330\260\277\354e\001\234t\223\256?P(\216\327\375\021u\277\316\000\213\201\000\251\317\277\225\317\257\364\354\217\271?f\314\207\014\034\031\304\277\315\360\356 \235\t\277?\330\322\2300\3057\300\277%\223\343U\177S\244?qNz\207n^\227?D\301\250F\'.\271?o\271\036\364>\336\317\277\265\366\020\347\305\341\210\2777\037\276\342*\256\237?\363e+V\023c\263?\225Oy\271\036\n\305\277\361\020%\3357X\232\277\203_8`\020\020\261\277\3169\003VA\035\222\277L\225\350\016\245\374\240?\200\277!a\352\207\246?\207\232\032\010|(\277?\177Z\344S\3108\325?\234\013^\000e\205\317?\27692EV\264\326?HS\200\365ZL\263?\275W\3334mq\327?\006\357P\323\243\257\237\2778QgG`/p\277\313^\177@\247o\265\277\225\215\016*\017\205\317\277\321\254M\230\3467\261\277\343#\"\226\033\010|\277k\024U\334\303+\273\277\033\377%\257\307X\247?\003\024\227\346\254\351\305?C\374\001K\377C\261\277\343-Q\271\255\324\307\277\'\365\217\376\370|\254\277\036\326\263J\373\376\260\277\244\354\263\251\n\341\271?\371q?\213Y\320\236\277\037\352^/T\235\316\277iz\000\300\324K\305\277\0338\214\010\213_`\277\033\216e\245\344\307\227\277\351\007Dr\226\010\256\277\227\237\344\351\007\242\320?\234\005s\311\266\026\213?\222\364s;\215J\300\277\333\326\032\233\262\262\237?\373*x\227\262\342\360\277s\337\272\226\004\377\205?\312\215\037\024\\\276\235?`N\263$\022\306\325\277\255P\310L\237\036\261\277\314\036\303\372\312 \323\277(\201\340\027\362\351\255?\343\347\316\315\322\034\247\277w\226\033A\354\253\276?\273\232\010\n/\350\215\277\225\n\210\273)t\250\277\353\362\342*\375!\250\277\226\244\250\032qK\270?\021OD\361\220R\261\2775\232\352D\370\035\205\277\035\217\215\313c\375\310?\224T\322\247\241\226\262?\312\311/\014G\274\237\277\206\026\267n\347\t\303?\016]\273\2456\313\226\277^\177VW\202\003\210?E\335\236\235B \233?\225\030\315\273\262\364\247\277V\2763\310V\226\302?\022\337\205\336\307\323\271\277\"\0047\371\270n\267?\257\344\\\177:\222\306\277\321\344\210C\210\216\302?\260\335^_\355I\314?\216\370M$\033\235\234\277\242\004SK\353\032\272\277T\253\025|\337w\222\277\002\\b\034f\\\211?\'/I\331\375,\224\277Z\335M\014\330\267\321?\270\235\333\331c\226\302\2775\010f\273\347\034\200\2779z\007U7D\263?\207(\330\330\217\265\267\277m\242\222\204\202\013\304\277\230\207\372\263\354n\260?b\347\222\023\223\350\240?\n\263\231\364\345\215\250\277U\366\006/\200\207\216\277\333;\277bt\034\302\277F\',\301\354\340v\277\010>\343\320~\345\303\277\374\n\323\206 \317\235?\271+\022\202\212j\264\277n\004\235?\356\304\254?/\330F%|\002\312\277:5\3134\307J\254\277\236F\002h\314\311\207?\000r\\P,J\301?\354\303hP\230\340\204?\275@\035\200\365q\266\277\345\343\255\233\017\243\306?]\025\271f-\324\207\277\272\322\2020\363\036\265?\240\220\3510G\r\242\277`\332\334hXP\206?\257q\312@\227\026\235?\274z\205\232{y\306\277\026\016\337\350\r+\205?\223\0017\320\200\341\244?~\273XO`\303\272\277o\240i\034j@\274\277}\270\207\202\013{\222\2777x\323t$}\300?s\254\026\356}\276\257?S\366\t\257\257\310\242?\224A\327\372\361w\201\277\360x9fba\317\277\337\306\0041hb\300\277~,\355f\367\257\267\277+\210\343\366o\215\315?\212\262i\036\272\243\323\277u\303\352Y\253\254\243\277\005\334\321\251:\205\255?\257\267\035\226\337^\312?\212f~\014*\034\232\277\274\304V\312$\231\275\277\373]\253\014\322\302\306\277\342g)\0234Wt\277C\272\211r\361\032\311\277\233\235\253\327\226\243\227?\207\331\216\256\026\256\271?o\312jv\374H\236?\301\312\013\363^P\211\277%}$^1\227\261\277\240\232\022\031\226\276\240?oN\253g2s\271\277~\202:\255,\353\263\277l\321\343qT\016\241\277q\347\301h\310\215\252?\020b9\300k\376\272\277;\034\032\247@\221\254?>\333\277\226J\367\303?\305\377R\374\233\266\253\277\251\344\024x\030\300\263\277\217\342!n\260\230X\277M @\377H\372\303?^\204\333\035\312c\272?jM\017h]\367t?;\222g}\022R\264? y\014\264\277i\034_\363C\177\265?\235\336\333\331\347H\240?_\273\241\343~C\275\277\227\303[X\212\'\236\277\032\033n\017\204H\211\277\010CU\0240\016\246?8\266\305\013\212\347\265\277=uZ\315)\025\301\277\032\237\362\262aS\310?b\317\271\274\216\214\265?\231\002|\220\305m\263?\227a\263]u\220\252?\205\032i\260\204_\312\277^E\301\275\351\320\273\277:\230m\310c\220\306?;\205\200\321\324\217\312?\321\177Y\037#Z\244\277\251\265\3163[\\\300\277o\340\307\373b\302\267\277\313\215\236\225\300\216\301\277\253{\326\303\250\000\307?\316hK\230/\313\302?\255\242\377l\004\313\260\277\221\216\371\366\005v\275\277\327\347L\374\261\t\325\277Ik\257\236\373\215\260\277S#\206[\260\034\256\277=6\307B\236\254\253?\252},Z\240\031\260\277,^8Y\010i\230?\277\225\322\333\335p\262\277{h)\351k!\230?\346\031\n\261\006\213\306?\223\225R\0217Cm?\235\232\206l=\236\262?qY\314\322\204}\305\277\200\342\004\230\0134\314\2773\022t\235\325v\273\277\212e\262N\324\212\217?]\266\252I~\314\274\277\310\026.\215^\260\251?\225\371\374\372\306u\262?:\3311\205\373\262\253\277MR\246A\326\375\265?\214KA>\220z~?\272%:\262\341$\252?\3219`P[\023\307\277\2428\325>\202W\303?\306\211\214#\306\351\214?\316\221*\007\247\264\304?\254D\274\205\215\215\250?C\255\354\302\350R\311\277\314\331mg\2530u\277V\220\033t\034F\235\277 XMy\277/\235\277\177 5y\020D\313\277\221\\\232\320\372\337\302\277\252\375\2654X\250\277\277Ih\nA!\333\231?4\010-Y\031\220\271?yg\266\345\252:\276?\224\177\351PA\271\316\277\007\016\376\\_s\237?\010\360\2020U\364\250?x\371\267$\006\332\242\277\233\372g\354y\205\301?\"\315v*\303\350\307?\354t\260\324\376\267\224\277\014Usg\311\250\317\277P\354\261l\313\271\270\277\305\337ZP\217\213\257\277\334\177`n\177\215u\277\004\315$\304\233\030\315?Z\027t)x#\255\277I3*\371N\303\240?\317\325c\277\346\352\234?;-\037Hc\270\313\277\252\357I\366.\210\226\277\326\226\326\000[\225\305\277\027\250K+3\004\315?\303A\027\255;s\307\277p\326\234\3502\267\313?{\253\343\244\233\307\260\277\312\236(\204+\277\263?B\254|\333\202\257s\277Pf\31504\017\252?\266f\303\347W \243?\234\267\263rv\347\247\277bo!\003*\322\311?\245\270l\232\"\027\263\277ew\020a\360e\261\277\260Tb\331\336\307\262?o?\234\335\036W\265?dJ\003\t \355\232\277\234\210\372^\226\224\245\277gO\204\335\t,\221?\255\233\346\244G\364\313\277\330\223\rYf\302\222?[\323\254\312\022\326\270\277\005U\007\231\025%\242?\356\304\360\270\226\017\315?Q:\212a\363N\241?\325\3222o\356\004w\277\250GZ\006\014\277\302\277(0\245\353 \213\221?\256l\331U\230v\303?\253\022P%61\262\277G\210\330\203\322\306\200\277\321\363\205\264+\311\314\277c\306\307\217\376\246\273?\2179A:\340\256\300?\3708M\337\275/\300\277\247\260\252\025\225\316\266\277\026@t5|\027\305?\'\036\307\315\234K\257\277\177\005\265\202\342x\225\2778\r\352~\024~\226?SG\274\204o\355\300?\267\3309\240\305;\264\277\020\307\266\264p\267\263?\370\272\333K\304\033\324?\010Y}\270Z0\323?\207\260!\255c\277\263\277\025\001\366\312K\333\205\277|jn\240SV\211\277\245Ye.\210\316\273?\372\036?IX\331\263\277@N\021QwT_\277@\022\306\313\212F\272\277\326\351|\262\335\264\242?x;\342\271\350O\240\277Q-=\364\003\362\311\277)\367|\241#\033\300\277\313\275\263!`\306\306\277\037\224R\231\352\000\270?\377n\365\333a\035\201?\177\216\016x\225\211\311?\'\226o\331\255v\272\277\315\331K/0Y\260?\355\016Q\025\241\'\252\277D`\220\237\265\005\264\277U\314C3=,n\277\262\n\274\201p2\226\277o\313~\363\276|\267\277\341&\343\231\347 \274?uK\277xS\313\226\277yw\345\345\346V\315?\342\003\373*\356a\323\277\344\264\323Z\325\203\317\277\317\243\nM\373\025\275\277_\000\331\016\226=\260\277\036\322\0000\027\353\224?e\366bEH\262\305\277\314\276\265\t\352\243\302\277\237~\346\347\342~\264\277*#UF}\205\307?>\022\364]\320\253\261? \017\351\277\277\243\311?n\202\n\237\374\306\305?\321\005\223\200\030\330\277?@\345R\250\247\203\217\277}\'R8oU\315?\301\035\357\342/\231\270\277\261V+\236\2216\320\277\376/\324\207\277\227\242\277\222\013=;\007\212\300\277 L\257\324\242!\267?pm{\366\345%\276\277p\034\315\324:2\312\277C\344\034\342A\365\265\277\325\266\301ZaF\303?\245\225\214\215\027d\212?\207.\311$\001\224\273?F|k\021C\030\253\277kY\372M+\270\300?\335\252w\314\2716\274\277\247\320\311[\276\317\264\277\323,\374\213\267\251\310?M\024\014\310\3720\300\277N0\032\355\361\206\274\277\'\216%\331\005M\304\277\304\250\274\226oD\307?Ok\250\330d\302\262\277\032_\2034ghu?\326vA\177x\304\233\277\345\267.,\260\037\250\277z \351\221Gv}\277cY\017t\013=\312\277\371\331\311S\243Z\262?\353y\244\005\237T\274?\302I5?\n\222~\277\030\252:Ir\263\275?:*]\200\376\267\240?+x\222\016\303\361\265\277\362\313(u\327\026\200\277\003\037q^>[\310?\300j\325e\0363\302?\201h\031\211\336$\312?\275\372\230=\276#\275\277\366LX$\205\324\265?\326L\354y`\263\313?\204\211q\007\205\250\257?\340QF\367\330\256s?\035\\\245\\D\226\325?\254\220?\235\027\371\321\277\275\312{\n\016#\224\277\231-\t<\3444\304\277|\030si\301\025\263\277\214I\"\231\316U{\277\311\036\333JU@\262\277\215\206.d\267\233\246?4n\203\314h\033\246\277\0229M&\373h\224?\355\020\326\013\204\374\203?NS\276\316\366\230\260\277B\337\314T\261\240\240\277H\031\316\224\353\317\276\277I\301\344\023Rw\272?\rAJ*!\203\320\277J\250\200\034\211\226\264?\013\0222C.\256\304\277\216\177\n\037\004r\254\277\'\233\0312\375\333\275\277[\244\2559\210\377\261?\237\367\257\260\345\366\301?\360=]\225\315\t\224?\r;\307W\n\023\254?_\024\205\257\005\265\304?Di\226\2141\354\325\2771\362\336~\352K\277\277\000\033\307O\376\002j\277:\005\375+ww\303\2774\2751.\236M\202\277\010q\372\225\313\333\315\277 \034(\223B\207\252?jUE\234;\245\252?gX\374\031:~\302\277\307l_f=\272\265?\334\016\371p*\216\312?\227\2100\230\374\364\275?\217\213\'\353\3279\304\277\312_\204\260\373\006\300\277\217\252\234\031\007%\215\277\034\006\274\353w\220\344?\325\363\271\320X\247\320\277\226v\'\016\264i\310\277\222\342\212)C\031\240?\353![h_K\312\277`P\334\237c^\262\277\326\302\006$\232\351\263\277\261\327\370D9d\254?K\205\300p\352\363\231\277\273J\232UJ\350\212?!\262\216\255\201J\263?\212`Nb\224\000\333\277B3\364\277f\345\320\277\\F\340\034U\327\266\277\326\321\004!\211O\310\277\241\363\332\340;\236\301\277yLk*\334\370\301?\365\004\257\261\217\237\262\277{H2Je!\306?\225UP\233\370\261\304?\307\201\253\217D\202\265\277\377\273\233.D\264\207?\267\247\304f\013\010\200\277\215\263p\272\245\033\276?\317YS\341 \201\306\2779\034a\265\375=\357\277\375;\240>_\273\300?\\\221\360\004CA\275?\210\037\007\373\302\256\330\277#v\357\317\013\341\260\277\351\264\027\351\350\253\265?Q\007S\332\363o\260\277\232\321TU\030Q\215\277\200\374X\213\3277\310\277W\033q\367\233/\322\277~\250\207\337P\013\270?\325\267]a\365\365\213?\023\262]\310\346*\317\277<$\247\022`E\277\277\332n?}\357d\264?\234\2542o\3077\261?\277tj\274\302\315\246?\222\301\250z\311\323\271\277\001\210\364\230\367\\\251\277\200\206c}\217w\300?\303rL\360\266E\260?(6\020;\374F\234\277\243\316ZR\006\237\252?\206{\335y\242K\201?\333jI\305x@\220?\200HB\207\270/\312?\343\024C\327xl\313?\340J\337\340\301sq?\241\301\374\243BQ\304?PF\247\370\212\203\241\277\nj\267\331\244\376\266?.h\252\014\344\264\276\277N\255\006\246*]\261?\313B\032ee\210\255?\013\360\337\275\325\253\264\277tQ\001\240o\226\274\277\3011\367\243r\260\306?\343a\023c\240\304\266\277\275\024\256+=\317\314\277\307\371w\024\3175\261\277\"\373\357V\\_\274\277\203\210)\342\272#\266?\3153L\302y?\232\277\314\225\310B\211\036\265?\266S\303\362\361\r\301?\356Nx\306`L\240?\224B\252\230\324\323\247?\237\377\341\315*\200\222?\256\266\240\352\211\200\237\277v\303\036\310\347\003\300\277\02196M\346j\304?\321C\r\310B\025\323\277@\251HZ\030\244\235\277\n\322\026\345#\330\266\277\274\022\272\244\237\262\221\277\241\340\214\312\234\351y\277n\231\2025P\205\274?\205R$\350\033\013\315?\235jl7\027\237\314?D|\2247\222\207\224?\271q\361\363c\234\270?\233*\352\n\333_\230\277\347A\201\340\376`\254?gJ\354\236\317\301\314\277[\371\371\202}\014\306\277\205\276\351\356KZ\236?Y\035\365@\364\306\261\277\023o\215\000\246\246\302\277\256q\234\331\341\210\262\277\037\010\271\233\322/\231\277\216\373\205\000Z.\264?\224H\"\276\022\177\244\277\225\241~\332\2341\302\277\026\n\223\244\304\220\232\277\347\234\206\261\234H\253?x\024\236\307\342\353\255?\027U\367Z\017V\301\277f\341Q\362\322i\266\277VZ\364G\362\rA?\202\0067\036t\242\264?\274\256n=\036\370\264?(\227\316\002\317\242\306?\031\002\304m\013\340u\277|\367i\0176\337\301?[\026\203\2252_|\277\020a\367\232\276 \306?7\355\n\026\034\203\272\277\325\205\326?T\323u?\306\030\313\316+\254\242\277s\205\315\235\307\n\245\277+,\214\261\021\035\257?n\256\262\243?7\310?\017\303hm\tG\250\277GS\212%\270B\274?\211\002-\262\211\226\312\277\261\302\260}\276\027\233?ce-\374d\374\305\277\0339\303z\314*\316\277\327\220p\207\331\266{?\364AmO\202[\306\277\222L\371\257\323H\304\277<8\237(\214s\270\277\021\206\350\244\230\037\270\277j\374iB\301\204\301?\235\217\006Z\327\"\270\277M\366z0*\372\271\277\317\013C\r#\242\274?\214\034hy\334B\275?0\344\224\023\010\304\263?T\261v\'.\364\257\277 \001t\032p\004\267?u\217\270\264\024\221\302\277\350\356\333\203\014\204x?\375u\r\331\320\373c\277\315\257\344oW\024\267? \245\375\314e\236\311\277\353\007\210V\355_\273?s\014i\027\221\\\312\277\362\236\317\024h0\251\277\013ch\322\226\021\204\277F\246\355\265\n\242\236?;\241O[\316\001\223\277\036\010\304-\271\275\263?\211\004q\367|-\261?Q)\n(\264\320\254?\326\372\001\016\225\022\212\277\277@$\0050\013\251\277\036\034S\200\267\001\320?X;\026\'W:\252?\323\r|\366\253#\242?\000e8\230\262\264\221?\014\276U\300\0179\262?\030\351-X\270\347\302?\315ZD\234\221\231\211\277X\024y\234\235\371\314\277\016\364t#\247\213\303\277b`\000\350\231\234\263\277\324\332\247\327w^\301\277\245\311\202W?-\207\277M|\302\326\201h\311?\250\003\020\317\313\350\245\277\014\303\005\031\003j\305\277\000\273\227\327\372Ua\277_x\024tP(\273?h1\255\216+3\302\277%\353\\P$M\305?W\357\332\331\370{\276?\274\361)Ij\313\323\277\360\373\265\013P\322\327\277b\274H\357\261\216\320?\335\ti\002PE\261?\370}\2275\003\217{?V\315qAS\317\302\277/\000\037\374\247^\263\277[h\210\333\230\270\232?\216\005b\036\\X\241\277\014\302\177\201\206\001\305?\242G\270\253\000-\202?\233\212\352o\310j\224\277\204\234\251\274\370\304\265\277V[/\343K\275\253\277\222\245kG\336\232\261\277\210\353\313o#\237\230?\033:\275p\267\311\276?\270\376\0367Y\360\226?oj\361\016\252>\302\277\200\237`pw\255\237\277\214\2617\020S\272\326?\275u\375Z\347\200\217\277\355\241\266\tg\301\233?\267\360\244\305\341\354\254\277?\220\315\232\375\342\264\277\313uQ\314\343\352\266\277\314N\367\330\312\321\252\277\331\320\022\222\333\237\307\277\347\267\0302\211\230\266?\240\016m\304\301\376F\277\032\272?\262\014\025\260?\257\027,\256\177\341\312?R\367\036\010\225\3252?+[\t\314l\365\300?s%p\241\305\005\223?\262<\261\2005H\256\2770P\331Gpe\256?\242\"\"\211^\223\262\277\367\213\322\262u\220\260\277?\350\252\350aB\306\277\035\201FN\222\224\274?F\243!#\212\261\274\277m\326D\300;\343\345\2760\014VsjT\271?/\033\226\001\202\244\251?\177%W\315}\035\254?\312\370\374\252L^\177\277\245U\317\017\227\351\251?\374^.e\310\243\306\277~\377\271\302\330\322\311?\036\326&e\265~\272\277\244\030\242\204w3\277?\310\000H\\\211\351\303?\177\3449\321z\251\310\277\331\350\371\034{\232\245?&\343\025\341>@\252?\322|\356\241\231/\237?\200\276\tcBQ\262?\005~\254\000\312O\301\277`\227\005\252\2325\273?\227k`w\007n\275\277\247\035\270\253\304\207\236\277\235\211&\243t\230\212\277\312\350\365r\201\t\260\277\214j\243\264\3436\320\277So2a\273\033\325?y\235\273\032\214\352\250?\305k\021\375h4\304?\032\244O=\345c\300\277\327\205\246\250\2178\270\2770\037\255\013\345\031\242\277\261~\362>,2\254?\024\305\002\260\340H\234\2771X\010\303\363\033\254\277\203[[\373\321\236\255\277\327\324\270?^S\\?\003\035:v\302Q\241\277y\203\003\034\367\352\315\277\224\305\342]\3514\303\277\302x\221o\030\335\303\277>-Y\255\336\027d\277\302\032\332t\260\300\240?\367,z[6\016\323\277e\3713DU:\271?\365ME=5\273\267\277~!N\373z\200\237\277\023\200\000 \2533\302?\261\362\315m_\031\270\277+\244PC\2033\227\277N\363\372\360\\{\261?\312v\212\205s\376\263?\231\266\354d\307s\314?#\336\304l\035\026\236?o\343a\376\231\026\266\277\262\316\320D\205^]\277\330\020\247\235\347\'\266?i\311\307R\002\242\322?IY\301\355$\016\262\277\344\357|\262\342\235\311\277\221\224Y]=4c\277DE\360\366T\034s\277\207\244\345\304\221\'a?\220\352D+\244F\232?\013\364\344s\305\326\277\277\327\225\370;\205\311\261?\216+u\374\036\236\262?f8\344\257\rg\261\277l\022m\204P\355\313\277$\260E?l\262\324\277ztGC\203J\260\277\255%\266\235#T\265?\2137\274\027J\364\212?W\031\274\323\267v\310?n\222\264\026\013\'\321\277\300\376\032\021\350\024{\277H\224\0130R\002\300?\247lA\275\"\301\243\277\352\017ld\323\374\246?\374\272\342\307v\367\247?>\030,y\241\377\270?\267\274@\\\366\231\275\277\014\037\356\220\341+\256\277/\031@\212\270\200\311?\315u\274$\257\275\207\277\177Kw\210\027a\300?\225\260a\036<\301\270?\232a\023\220\031\355\227\277H\327\003\261\365\t\255\277\347\337\2359O}\241\277\2350r\202\276\257\261?\337\253\\\320c*\276\277mX=C\211K\302?\001C\273M\227\240\275\277\221\304\207\203Z\237\273?W\251z\354/\226\306?7_\t\257\213\032\304?,\374\"\303\373/\313?<)\310d\242\031\264\277\204T \211\336\214\243\2772_\027\340\242\031\324?\2039\313J\252\222\304?\321\351iR\272\240\317?\271\177a\346\020\303\245\277\014\023p\003\t\303\204\277\240\267\376[0\365\234\277\350\317\271\177\342\302\313\277\277\277\202\244\303x\266?\241=\016\020YT\261?\004$\024^<\214\266?\313\310%\247v0\252\277I\275\020\337SO\302?s_\324s\0053\247\277\317L\236\336\374\033\214?C\334\'\224\341\006\302\277!H\024\236k\244\310?Jg]\336Dn\260?R\0147;^\305\317\2778\250]1+\334\303\277\251^F\251u\324\303?v\237\255q@\353\204?\373\340\315,\317\247\301?\374\013P\363\353\014\303?\357A/\200WX\221\277w\226*\013q%\265\277Ke\311\206\327\365\251\277-9\017\214h\255\274\277aWuiB\034\222?2\244,d\247\014\264\277\262r W\341:\200\277[\261c!\210R\251\277Q\033\323\302\241N\226\277w\223p\257\316N\240\277\330\356\035\347\034]\303?\213ix\2441@\255?3\244\212G\347<\245?\330a\266<.\321\271?6>\235?\317vs?8|\tINr\317?0\n\3732\303(\321?\242\217\"\251`1\311?\343\332\334\330\315\331\257\277P<\037\000\340\355\251\277S\333l\344\\\255\204?5\271S\025+1\274\277]\031\274*\341\230\330?\340\266%d#[\266?\255Uy\230\350u\320?$Q\213\234Z\021\216?\024csA*\244W?/\221 \021N\276\302\277\250\252\027\330\371\235\224\277k\232v:\344\314\320?s\246\026\312\206:\263\277\244\033\256qj5\260\277\333\352l\255;\007\272\277\220\3450\247\221\254\262?\330\211Lf\234\352\253\277\201h\257\234\327\303\253?\331C<{\235y\242?\360\305M\340\017\227\276\2776\361\247\367\223\376\324\277\017A~\004\006\213\231?N\264\'G\306N\305?\\3oo,\370\307\277,\262\306\231\255\352j?\"p\320\356\tK\244\277\302\324\007R\025\301\301?\242\302\362\3533R\262?\203\265Ci.~\244\277t\360.\267\035\013\301?\027>\310\275\307\266\240\277\367_w|\354\375\214\277d\205\301Y\236\340\305?o)\346\213\233?\322\277)lv\364\236X\260?\310\332\335y\247\020\271?\336|+\357G\224\312\277\001\262\207N*\335\271\277\265x\247\035\367I\272\277\247\254]\313\226Q\266?W\376\261\313\226\221\245\277\032\320\026&\t{\277\277\221#%\rv#\245?\242tL\374%E\202\277\210h\335V\004V\243\277w\305\243\232@\037\265\277\352\274j\245@\250\277\277\033\030\022t\345\217\221?C\010\304\365\231(\273\277.\230q;\326M\320?UU\334\252\227\235\260?\340\257\227\334\370\365\267?%\357w\312/\224\311?g\372m\232\375\206\303?\036\301\007b\2667\315\277,\333K\307\242J\230\277w\324\273\005\321\341\305\277\232\006\231SaZ\312?%\3243Q8\245\307?\233\221:\316\010?\225?hz\035f\300\354{\277\307\254;\313\3650\254\277yUA\271v\365\235?\\\2558\032\375c\276?\230\257\372\233.Y\301\277\021\017E\232\362=\257\2772\r=\237\331\346\302\277\340\316y\036\035\023\265\277j\351\277\005\317\211\252\277\220\243:~\014\362\301\277\337\'\326B\216\336\272??\366D\265\205\227\261\277\331:\r\302\t/\314\277\317\243\201\212\374\020\324?>\353\322\372*\245\273\277\335\037\365\345`H\310\277\017\207%\021\337\376\253?<\377\000d\370V\313\2774\313T\256wN\265?g\263+\265\027\373\244?:r\233\235\316/\300?\236~\347cx\r\320?\243\005\355\035J9\217?\3505\215\3670\242\300\277\260\016\202\004\025\266\273?\333\245d\033\376N\256?\323\323\222#\1776\257?\337t\246\343wo\263\2772j\247\324\364\263\331\277\307\017\353=\3321\204\277\014\236l\251(7\240?\313\264\202\t^[\266\277\331\026\203\276\241\341\324?\232`\247:\231\257\303\277\023\342\272\335\372\336\234\277mYA\3416\256\206\2770S\342`\351+{\277_\340\216|Z\026\273?P@\006\237g\215\272\277\345\212\201ZS\237\314\243?\321\362=\277\222\263\314?\203\034\324p\340\243\215?\\\241e\354\245K\207\277\262\2050\2065\311\300\2770A \260\251\356\252?\302\252\000\354\331{\300?\374n\235\005f\016\261\277\215\341?L\025N\321\277\350\365\370\n\024o\306\277\004\004\033de#\314?\202\362\010\024X\021\310?\3659\321\342\343\026\244?\253\375k\252\214\361\300\2772+\234o.\370\274\277\231#\234\242+\306\334\277\210\350\272\221\014\223\224?2`\327}\000{\303\277\254\005\250\323\202v\000\300\354\r\"{\373K\314?k:#G\026y\321?\315E\\\301\254\223\357\277\310F\257s\204b\272?\237\341%\017\241\265\275?uZ\232\3517\r\216\277\253\024\271\373\341\254\331\277`\213\023\213\354\245\303\2774y\307\257\007\367\243?|t\232\233K\360\240\277W\267\267\256f2\305\277+\215\345\250\364\216\313\277T*\355\014\310\001\250\277\216\276l\014\257\361\276?G4e\361G\202\206?\246p\2339\241/f\277a0\032\216]O\230?\324\217\330\361~\354\251\277\227k\360\265\300r\302\277\033I%$\330\377\310?]\330+\334\206\022\302?\365\340\n\242z\301\267\277z\022\014_Cr\313\277\032\231\272\202\353\371\270?1l6a\337p\247?\246\340\203\244\234\352\253?~\253\200\375s\202\300?A\206\213\262\021\262\223\277\227\333\376\326,\022\220?P\374&\242\233!\271?S\344D\304?\333\263?S\330F\326\205\373\244?\346\305\226\205A7\271?Uf\207\026\255\014\255?\034\353\252\021\366\034\231?@\005b\250\210O\241\277T\370{\343\364=\317?K\004\2665SA\225?\255\252\305\204z\266\265?\3545)\365o\262\320\277^peE\372\340\252?\"Z\005\3327&\301?S\033:\307\345\314\220\277R\344\002E?\014\232\277s=\264\363^\320\312?\271\037\333;\326\014\305?(\350D\3125\372\274\277\302\323\"Ps5\256\277\210\274\'\242S2u\277\3345\373\347\324\334\236?\252,\t\254.p\262\277\241j{\266\352\335o?C\354\226:\364\240\220?\234c\236?]e\305?\030\316\311\020\365d\302?\355B\367YlN\257?\275i\377\251,C\264\277\233\231\221}\231\344\250?M\304\352\034\3439\262\277\327~\226\323\355W\260?\016\350\340qE\327\302?\272\026]\312\362\204\325\277\356\016}\202\037\245\313\277\340\327\201\225\322\203\240?\322\213\264(^\250\250\277u4+\362\0174\224\277\336\3430l\353\317\303?k\273\325\251q;\276\277\034>\253\307VM\276\277\231\332VD\371\021\306?\007\000L)\206\245\250?d\354Y\217\314\032\245\277\312G-X\nM\307\277\311R\3055Y\375\265\277\204\204\245{\257\357\305\277\355\245\200o\304\004a\2779\t\\E\246\333\307?dbMay\256q\277_z\316\200qL\323?\321B\211\246;E\263\277\030\207\313\341\346\037\315\277\017\372\357\327\274O\306?E\364\267\220\264\301\242?\352R\207!>\025\265\277gz\031w\226c\310?9\327A\305\216m\264\277W\t\344\340\004b\263\277\340\216\223)\027B\231?\255\272\0313\247d\303\277!]\270\027Sj\303?\245\254\305k\327\314\247\277j\256\'\306|\215\243?=;\027\242\373i\275\277\001*.\352\020\375\302\277\211\326\006\232,/\323?\005Uj+\\\267\267?\217\037\254b\211\023\267?;l\020X\200&\207\277r\026\372+c\212\262?\270\\\223\245\200N\261?C\320\230$\332\371\250?\252,\034\363T\031\266\277\206\345D\250%i\221\277+\233\253C\215\346\303\277\355\351\016\224\237O\276\277\270.f\324\212z\266?\303\200U\013_\310\307?/\327\367Q\2713\305?^\371\363\370,\347\260?\355\253\210Jk\317\302\277\360\335\352Q\377\246\277\277Va\324\007\220\271\220?\364,\372\\\323J\272\277\246tE\214\372R\260?\354\240\234q\366@\266\2770\375\365\034z\245\302\277\030u\375\264\005f\300?E\37008\311\256\317?\215\017\254n\037\363\271?\013\204\200\222iQn?\032\032\017\250%w\306?\355\335<\374\273\035\240\277\302.\270\340\034R\250\277\223Wf\376|\321\220?+\376\350i\230\220\233\277\335\201/\354\036\255\226?\372\303;`\253\356\207\277nY\207\220\027\313\227?\356B\374\033\224C\261?\236\212W\331\302\n\301?\255Cja\031G\221?\253\230\262\261\203m\274\277V\321\314\212D~\277\277\333\200\275[\030\341\310?0\360\340=dm\255?y\t\004\234I\214i\27740s\262K;\305?\352\3136\'\t\027\273??q\240\025\030+\300\277[\310\001\350L\034\243\277\364\034\204\214\361\262\215\277\332\266.\246\321[\207\277K\035\013\033\006\220\324\277\235.\215\341u\\\311\277\315\245*\276S\306\236\277\027\023R\016\324\360C?h|@U\274+\205\277c\354\037\037a\322\223?\212\036g\304BQ\214?l7t\323\364D\266?\n\245\'\2529\241\301\277\360\032\205\316s\370\240?y\037\375\344}A\252\277;m\2643\343\215\257\277h\225\201\305\317u\231\277\362\273\207\".\323\302\2779\035\351\236\rj\265\277\262\001\334H\273\336\301\277\347\020\237\227\031\260\302?\277,\340\025zr\260?q\263O\262\261M\305?\344\372\210\3351\242\317?X\354\016h\242\211\300?\324\247@6L\351\304\277>\342;5\342\'\254?\257R\272HoW\301?\340Z\037?:T\215?\306\222\263\241\336\220n\277V\346\\1M\331\275\277\0103\2205`&\271\277\316R\036\022\3211\303\277\315L[\271\024\306\313?\341_\365\363\325\266\274?\0368\364\2035#\200\277p\223\304\301{\233\300\277$n\247\247\344\304z?X+\261\024P\214\256\277\343b\315\225\211#\225?\242j\251\323\r\037\304?\221\321\236\274\331\035\244\277\3476S\340w\221\272?\013\3146\336\205F\312?\261\352?d\315a\263\277\356n\303\233Z\346\260\277\245\025\3153k^\215\277x0\361\252\247s\316?dv/\352\"0r?\365b\332\2128\271\240?\373\341P\033\320\235\267?\"\335\377\231\003t\207?\010\n\262}.\241\240?yk\325\354\237\374\277\277\340\226>\020\332G\300\277\'5jV\263\357\274\277\306\'\261\3536S\240\277\014\204\037q\315\317\304?\323=U\372\034\375\323\277\330\021^\230;M\311?Pc\370o\341\323\256\277J\020\277\220)\310\310?1X[\240\327\236\241?2\nW\302\356\331\262?\033\264`\265\256K\304?l\345\275\336\275b\303\277X\001\201YRY\313\277\335\370\\\037WV\256\277\244\242\276\016#du\277\344\274$t\010\214\240\2770\nA\305\224v\311?\006\01440/ \263\277" + } + } + } +} +node { + name: "layer_1_type_0/matrix/read" + op: "Identity" + input: "layer_1_type_0/matrix" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_1_type_0/matrix" + } + } + } +} +node { + name: "layer_1_type_0/bias" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 40 + } + } + tensor_content: "\254S\375\003\265\207\336\277\375\316\351\266\365M\001\300\335r\311\3366\356\351\2779\000,\357\263\333\325\277\024\007\177\322E\215\356\277\326\017\310\255i\017\000\300\2163\211\211X\262\351\277\232\370_=\233\205\365?\275\276g?}M\325\277\037L\006sCv\231?K~\261\003\352<\341\277\221A\323F\241U\324\277\300w\357\271\n\255\342\277\223\351\216\374\253\366\345\277IW\3557\200\225\335?\252m\030\224C1\001@I\026H\252\212\027\351?k\017\002\244#\032\363?\336\320\307\355\035?\367\277\022\2552\355\361\226\377?s|<\317\326n\306\277r\203\314\240?\367\332?N\225\340\234eR\366\277\036v\027\301c\037\343?\364\021\236\362\257*\353\277+\302l8\242F\343\277>oMZ\337\317\326\277\n\261\366\365d\334\206?\346~Z\206\373\256\262?\264P\363\242jw\313?C\351\265j\267\000\306\277\250\030\305\201\027\255\321?t\224\202\202\236M\340?dh-I\225C\343\277k\306\356\277n\031\325?\247d\0208\245\236\354?Z\257\311\201\372\016\313\277\235\307\321\256\014\010\336\277\367\301gX\220\333\350\277J\327\022@e\021\370\277" + } + } + } +} +node { + name: "layer_1_type_0/bias/read" + op: "Identity" + input: "layer_1_type_0/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_1_type_0/bias" + } + } + } +} +node { + name: "layer_1_type_0/MatMul" + op: "MatMul" + input: "layer_0_type_0/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "layer_1_type_0/BiasAdd" + op: "BiasAdd" + input: "layer_1_type_0/MatMul" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "layer_1_type_0/idt" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 40 + } + } + tensor_content: "\203\270\306\312\017F\265?n\371\336<@\361\305?\337,\264\356\303\247\301?\007p\244\230\310\310\265?z\244c\226D\202\317?\362\305i\213#-\261?Gt\375\n\362\"\264?\230f\271\3240\211\300?o\372=\221\270\253\316?>\3302\003\272\202\272?\221\272B[\364\255\262?W\367\001k\330\273\272?\261\356\244\276\237y\267?L\347\225\277\301\341\243?\345P\221\326\331T\256?6A[\370\325\004\270?\355\314*\320_o\267?\317\3435a)\037\267?\316\345\034\326\246\234\266?xY\313.\365g\276?\026\\y\001*\253\250?@J\263@*\023\266?8f78\260H\275?2\000\227\033*\265\265?\34545\200\201\005\253?\005\325\246\313[!\265?\357\245\344\030[\212\301?\247\215Fz\020\233\265?\322\273J\362\262\271\312?\271\255\352\257\010?\334?eq(\252\372\200\272?\006\341\005_@S\266?\361\377*\301M\343\305?q\347G\203L\316g?\024\322-\244\300\265\300?=;\341\211\010\361\272?\210\265\331\371*J\320?\243\344\304M\304/\277?\3121\374\026\005\236\317?hb\320}\246d\273?" + } + } + } +} +node { + name: "layer_1_type_0/idt/read" + op: "Identity" + input: "layer_1_type_0/idt" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_1_type_0/idt" + } + } + } +} +node { + name: "layer_1_type_0/Tanh" + op: "Tanh" + input: "layer_1_type_0/BiasAdd" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_1_type_0/Reshape/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377(\000\000\000" + } + } + } +} +node { + name: "layer_1_type_0/Reshape" + op: "Reshape" + input: "layer_1_type_0/Tanh" + input: "layer_1_type_0/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_1_type_0/mul" + op: "Mul" + input: "layer_1_type_0/Reshape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "add_1" + op: "AddV2" + input: "layer_0_type_0/Reshape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_2_type_0/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 40 + } + dim { + size: 40 + } + } + tensor_content: "\372\252\272\023\226 \243?2]\002\236S\024\273?\t\006\002\375\203\315\261\277h\\!\264\277o\247?>\234\030\202\270\037\247?L\014\244$~\r\323\277N\251NJ\332\307\272?FVM\276\345\203\264\277\003\273\251#\377\213\234?\347\267\334\017\243\265\301?\025\360\240\247\371\375\310?\3414\363[\310\304\274?3\232\265\214R\361\307?\303+\213\016FP\313?\307\340\210\tW\222\264\277[\014\216{\004\002\204?}\036a\'p\304\263\277=#!\316i\250\266\277\201+*HOE\312?x\275\r\226\0035\311\277A\031t+\300%\266?\304\334/\303\271W\213\277k\277$\235w\372h\277\237\371\002@\rz\225?W8\221\017\230\215\256?\361\0318so5\301?\313\230\245\252,c\315\277\021:\270\206P\252\234?jl\254\245cX\270?[I8V\230\215\306?^\306q/T\227\263\277\320\320\177\3154\007\311?\317m\261-\356\331\266\277\320\327\345UQ\352\303\277\000\205\215.c\252\265\277w\206Y\204\362h\241\277KLW\373\000\331\261?\016\372\002x\\\206\311\277\216\232\270\301\355\372\266?\3578\300!\373\335\270\277A\034\211\241\310\013\273?\300\377 \020\316V\262\277e\315\027H\351\001\270?<\346\257_\267\257\303\277\245\211\370/\270\201\256?\253Q\030\243\021\247\251\277X1\243\031}V\226\277\237\2442\234\337~\316\277\254\266\346\255\306\235\304\277\r\266\276\340\367H\307\277h#pw\026\356\245?T\022\2220\300\260s\277q\303\371z\220\340\303\277\211\326m\277\003a\311\277rG\200\254\223+\333\277C\203l\020\321\323\272?6\304\013M\360\016\225\277h\210\274$:\354\206\277\027\345\315\351\230N\302?\300\345\372X\335a\260?\214\244\340\203\3071\316?\226\334\206\237G\273\242\277\243\350\377k\021\236\274\277B\307\362\031\202\341\351\277\037\210\204\310\272f\264?2\201C\3018\033\271?p\252\330\304\325Z\270?\017\377\035\366\035\326\315\277<\216\206\341\006\003\315?\276j,*C\214\235?\031]7ZV\227\231?\355N\323`\376T\305?\023\3409\033vf\220\277\2134\010\316\214\220\001@9\247\243\375\016l\263?P\263\262KEu\312\277\3702\200\013\251^\205?\237\177\265\207\326\305\273\277@\354\236\341\375\337\317?\252\352?\212U\364\230?\327\372\373\231\346\276\257\2778p\327w\273\346\263?\245\243\001\325\205\210\314\277zbJz{G\303?EM\254\325$\353\266?F\370G\226\016\356\276\277\365P\214\351\245t\262\277\251x\347;\001#\265\277\314{L\327q\357\222\277\255\366\235\004L\250\272\277\211\306\276\237\016\257\277?\026\225\305\204\035\214\255\277\335a\017\375o\255\250\277\203\345\177\036\333{\310\277\016\353\232\'\377\177\304\277m\001\300\t\027\214\232?l\302E\312\000\027\227\277H\364|\021\006$\313\277aM;\354\311\261\231?^\203x\014ic\257\277\211G\231n\020\343Y?\314\024/K\014L\312\277B\301q\215\023\025R\277\313\305\001\367\236>\260\277M\350\244\303\354\036\265\277U#\216\310\311B\226?\010\016\354\373I\373\264\277\220@\204\373\244\317\260?\010\032\206m\327\324\234?\365{Fr8\027t?\240|3i\004\351\277\277\307v\301\361\221\243\277?\343\304_\343\250\r\321\277\201\330\337\224\335!\270?:t\256j\034G\231\277j\371L\247\301\r\273?\266\330\315\262ek\302?\217\350\331\273\0363\310?\357\245=\242\036H\257?|\232\327\364\220\273\276?\022&\262J.\002\301\277\241Q}\355\355\021\273\277\236\361\r\'\365\317\311\277\253\027P\017\\*\263?x\202\262\320\307\n\261?\024\301\276\364\022\001\316?\306\035\257pH\205\315?F.C\253\327\273\267?e\\\327\357\340U\201\277\260\375M-\336\246\266\277\375E\364!\314N\270\277]\007\216\020\375\351\200\277/\3314\211\372\r\323\277\322\210\324\037ek\207?\370\211kR\314\335\310\277\355\215\260\356,\007\265?\346|\2063_H\267?i\202*7\'\320\300?\341\2100\036\242\001\264\277\311\264\256\321\203\307\213\277Q\320Z\303e\370\254?d\345\212\264\200\033\270?\252\352\213U\010\221\307\277\307\034Z\270\217\315\264?\274\327\032h\n\364z?\261K\277\306a?\304\277he$\244rv\270?0\275*e\235\275\274\277\372\207\031*jC\270\277\0319h\217\0302\276\277\032\330\255\003^\010\255?\034\245f\312\223z\271?j\357\354\225\276\024\246\277\214\252\277O4dl9\024\250?\273\265\026\212\006\257\301?8{\223S_\331\310?\3607=\351y\371p\277\303\346v\246\231\244\214\277u\375\014\243;\307\275\277\312\301:a]0\261\277O,\251\027\036\211\306\2774\372s\234[\"\307?~\367\326\027\365\323\263?\313\315\305\321X\201\261\277J\242\207\266Sa\272?V\236\222C\257\340\203?\212B\\c\277a\265\277\357\312\032\325\366\376\252\277j\201B\371\034\355\242\277\351\326\276\017\031\354\200\2778\272\0305S\242\200?\257|\224\217\3076\301\277F\367\227ht\302\265?O\216\013~s\254\233\277$\262\236\375vU\265\277\201\252\332\300\0246~\277~\034\001+{\004\243\277\342P&I\177\000\321?7\001v\360\316X\266?\342\002c\264\256h\315?\'-\277\024\356\363\316\277=L\324\324H\001\224?\311Hj\210u\016\340\277] P\023\200b\277?\301\376,N\223)\245\277\272\330\243\014\323\n\303\277\026\323\"b\254\356\266\277\001\327\003\243\363\275\313\277\376\364\326\2008{\316??3$\376\034\316\261\277\240\254\311\311<\331\244\277\023\222\327\001\277\336\242?~\325\334\227\327\275\267?\225]\330\n\032\364\263\277\303\220\027\213\336\243\263?\003y\234\331\2338\273?H\262\201d<]\252?#\221\352\364/\027\254\277\004\005\224\353R%\317\277\223\323x\233R\213\304\277\335\027\"\264Ri\255?Q\364-\025wD\271\277\370\232\202\177\022\301\253?\346\004&\0028:\302\277\3753\221\361\243\270\242\277\206\223\006_\'\032\233\277\335\217\350\347\343Xg\277\"\0308\\\334\203\225\277\002\030\352\217\207\026\310\277\031\345\225\373\n\277\315\277\322\021\346\177\004;\310\277\206\363\220\346 \270\273?`\205\206\356\313|\267\277\202\244\307f6m\256\277\021\273\033\203\373\371\305\277\3131\262\352v(\262?\250\313\214\034\357\216\274\277.Sx\210\217\032\322\277\334\251\365IX\204\250?m\371\025I\207T\231?c\324gdv\222\247?\224\354UP&\264\226?\004L\202\225\307\311\323?\377|\353E\"\246\303?k\315!\231\303\213\311?4\247y\344\240F\201?Wj\to\272\214\301?\r<\010&P\320\305\277\377\014w\034\230\017\247?&\305,v\254E\272\277\215\000\222tS\373\301?3\276\014)*\326\201\277\0238\0324\350\016\245?\221\334\322R\3718\261\2774\241<\240u\031\277?\367\240\030~_\020\233\277*\254\233\006\227x\272\277g \271\377\"{a\277h\204\004na\356\310?\275\326\330\360\216\214\271?Q\364\301\235X\372\254\277e\030\375\221\202Z\230\277\374\222]j\"\331\207?M\214\344l\315~\313\277\\]7t\277d\\\2771~|@sh\253\277v\320F\223C\241\267?\255x\177\247\204\r\246\277\025\316\214\3329\215\273\277$e\277\250]\246\273?~\203B\375\372\027\260\2771A\226K\345}\314?\021+9Z%\005&\277\330\207\225.T\237\221\277\036\202\205\320Vi\275?\232\334a,!\215\257?\3462k\232\031\361\251?\201N\202h\244v\275\277z\1777\031\"3\310?[\301\220\007\013\013\217?\277\334\312a\034u\270\277\265\343\013\332\320#\257?\272\\\356\316+\232\254?\033\330\266vE\325\225?\267\335P\364\016S\240?\324\337\366b\247\255\305?+\241\325\330\314\303\311\277\036\207rM\256\"\211?\312\277\233\222\371i\225\277-\244G\007>C\277?\247\022\235\r\251)\256?\343\203!x\326\211\273?%\236\267\'\345\356\301?\356\263N1-\333\265?\024\213\004w{t\241\277k\002\023\351\\\323\247?\006\356C\'\365\202\302\277\232\023\252\276\326\336\270?\205\373}W+\301\270\277\365\262@|\372\217\272?\003\275\231\010\'\334\306\277\210\272\014)}\343\302?\243\253\001J\r\202\311?\374\252\\\256m\302\246?\233\213pCd\241\211?\225d\030\3046\340\302\277.\n\014gF\257?\311\007\264\331\2021\241\277\362\357M\203;\360\260\277y\206\215L\243/\233?xl\326Y\364\266~\277\354\270\353\301|U\306?\377\263\243lw\236\216\277B\025\003a\343\265\313\277\346G\330\0047\327\300?m\332\215\006\243\314\277\277\331\302\310\351^\234\320?\236\021\'\235\365Z\274?@\367\257\207\232p\241\277\330\323}|K\016\202\277U\256\260\010\215T\217?\335\353@\301oIe?\317\275E\003\206\324\250?&MsD]\276\247\277\263\313\033C\263S\264\277\326o\263\201!:\266\277\212\242\3478\177\303\233?\364N\007Ny\267\252\277>\201\326\217-\005\236\277B\265\005~.\023\306\277Q\334\312\034\357@s?\323\242zs\213\305\222?\330\334Q\312\303\343\320?t\267\200\025\306\330Q?\343\257[v/\325\273?A\013y\201<\242\224?\3529\216p\321\211\303?7(\241\362\264r\301?\211\310\220\"c@\242?/\203\326\301\317\177\271\277\225\210\316i\262\201\265\277\201\301\245\034\266-\301\277\371Y\212\310\031i\256?X\2141\356`\310\206\277\251\356\343\005\r\320\273?Qj\014\000`\305~?\254\331n\314\320\204\251?\221\244\334\270)Z\317\277\266\n\323\336\211\037\322\277W\220\361\323A\256\206\277\364\230\342v\210D\234?\\\257\376e\361\320\304?b\r9U\321\010\244?M\232C^\310n\303\277\234\263\363\220ci\301?\212:\345>j\013\304\277\301\003\301\266\026o\247\277\002\023r\356[n\275?\207\207\250j\376 \252?\267\206\246o\022S\301?1j\022\3401\311\244\277x\034\254.\272\314\263\277g\302jB\360\022t?\2068\014\332\303\247\252?\250w\370\275x\022\266\277\221K\354\241i\224\303?\021l\341\367>\252\220?\0008\016\206y\345\204\277\232\225\373\314\342\242\252?8!\250\275\202\342\301\277\350\231\231\225\300z\242?\\\037*\201\351-\266\277$m\277b`]\304?P\372\235D\272\277U?\315\202#\353\375\324\301\277\004\241\322A\235\267\262\277\336Y72\032\272\304\277\032\262\025r`p\231\277\267\332n\307;\207\227\277\347\362\245\224\320\033\245?@6\272\342\362\002\225?\336\227\366\221\013b\257\277\206%\324QQ\236\261\277\264\363\267_\2310\302?\317\021\022v\354\371\275?\211.\2028\002\020\317?\362\360\021\331\346m\247?\3131\305.\".\263?\235a+tL\006\211\277b\177b\341\232\303\300\277\354\266\332\250|@\265?bQ\006\256\325S\302\277cVI\307\304@\247?\357\002$4\326\331\264\277u\007\207(\260\277\263\265\322B$\032\235\277\270HK\224\340\241\240\277\260\216\244\210\030\'\275?\0046\371\342CV\261\277\367,\021#\274U\303?1\r&\321\206V\244\277JS\232\366\357w\250\277\034\2319\357\350\230\251?\320\267\350Tg\344\303?dT@*\336\242\201\277\t\270c[n\031\272\277@\3245M<\235\260?\\\334\242\365\300\017\255?\362\337\320\025\371\366\301?;\214\000D\211\377j\277\205r\326\202\275\331\214\277\344\317\030m\267,\320\277L\240\013\373\031L\243\277\372\303ndiJ\254?\2612_z= \267\277\315\330\314R\n\035\222?3%\315\207\240\247\256?1\240\227\331eku\277\316{\275\377;\267\311\277\251\263\177\262NN\261\277\020\231\020\036]7\274\277\202\377\027\001\265%\270\277\220MT\252\207\340\312?\025\253\r\321\242\230\300\277\315<\261\224\302Y\273?\373\234G\243\200J\234?\230\3023~\306\320\257?\334\316\370\367\231\234\263\277M\361\310\245n\177\271?\202\236Jj4\027\203\277x\026\327\256?\355\262\277\2752\010\2239%\301\277H\335\273\375\220?\236?\372/\216vL\227\264\277\236RO\272\362\217\271?^\330\337\327\210{\273\277U\233\354Cu\033\246\277/\330\221\"\326\250\310\277\223\301L\373\365\030\322\277\342\223\036\354\371\302\272\277\211\317\316x(V\301\277\230\"\320\211\276`\261?\306\315tM\'\353\261?\206>Z\021o\032\320?\r1\001K\355\220\222?]\013\241R\313_\211?\222K\237\027\004\362\266?.\316\207\233\344\325\302?\206S:\027\376\364\234?p>\200A\271\374\306?\275\310Ca\307^\301?\242\226\024\230\'\352\205?\372M\330\231\233\355\244\277\233\252\373c$\302\307\277\030\334\253\351Q}\301?\2121UE\214L\274\277\305\375\035*\227;\300?\216\206\376\321\302O\201?-h\342\365\347\271\302\277t\024)\321\212\317\270\277\320Q\377\232VI\276\277\307Om\312\224k\255\277\237v\005\231\204\237\262?,\221 \227\240\310\244\277\337p\344\352;N\266?\313\'2:\363U\304\277]-\245\t c\316?w%\371$\270\277\306?o-\254\005\224\r\231\277\357y\306\005\337j\265\277\374\266Yc\233O\302?\357\366B\036G}\260\277\256\006\223g\352\215\316?h\241\007\202e\371\230\277\204\357`~`\272\262?\344~\010!\266\272\261\277/\014\230t\206\206\261?\325\351n \214V\250\277\262\243\312\327\'\261\262?7\317\021U\177{\312\277\254\311\233\375\265Qs?\340\345=\362tP\241?\257\017\345\372\033<\225\277\365\347\265\\\020\353\265?l\376\035\3218\031\265?\257\026\375\245\301\036\222?\311\023[G\264\364`\277\345n\342\360\360\201\241\277\321t2\211\037\345\252\277\024Ql\"4I\253\277oQ\204\252\232\335\304?2E_\036\017\\\301?;\262,\273\376\304\304?\260\222Ejk \275\277\001jp\366\247\024\304?-\335\324y\214\246\276\277&\035\320\027\323$\261\2779T\331=\n}\305?\005S\246\272K\356\274\277\373]\322!\r\320\241?\341\322\271{\014\277\304?\010\306\300A\201{\262\277\003\332\3672\207\'\304\277\247\235\227\376\214\221\266\277o\230\356z\372\027\306\277\264w\213\035\256c\302?\304=\320\341\020\271\232\277\235\254{C\230q\200?\2349E\271\365<\250\277\017)\336d\343\263\273?\246\320+Y*\344\222?\321u\273\223\366\220\263\277\006\337\256\374C\303\271\277\3135\365\232]:\270\277N\000\300#\016\211\266? Y\305\311\3536\323\277Q\210pW\360\017\271\277\204Y\372#\026Q\266?7\005 \026\204\204\204?\244\201$\336\352#\303\277S\377PF\3744\246\277\373\372WM\341L\221?_\254P\364\243h\223?@\000\023\252\033\314\307?A\202\342\353O\310\246\277\237~\"53]\323?\305\344\200n\3626\245\277\222&\262Q\212\025\277?\355z\263\025\037\321\227\277\204\256Y\236a\374\252\277\265\325\005\272O\037\266\277\353\037\344\027\245E\243?\000;\313\251z\n\301?\252\3552C\203\260\304\277\321\254\274\001\357\317\231\277\022\234\206\236\361\222\260\277\036\347\027{`\331\215?\331\253\327kd\177\201\277R\242]j\213\251\243\277Iq\213\'C*\255?_\220\346\251\273\353\301\277#g\3337\232\014\277?\304U\031\224\307\270\315\277S\246sgv\312\260\277i\333\t\252c\021\242\277f\366Oz\314\361\263?\375\267\314\020\233D\266\277\216\344\237\341y\220\307?\022\234\203N@\304\266\277\214\261\2704|\347\265?\200:u\324kJ\257\277v\024Ey@\037\303\277\020\271\253\340\230\177\224\277\274\245\216S\2011\311\277#D\tg\220\013\312?6\360\030$\374\004\304\277Y\323-{\036\267\261?h\303\356\035\317\214\306\277N\237\253\304\2548\272?S\362\226\322{\312\304?9\302\020\375r|\242\277\002~w6\366<\277\277\020 \357\227HZ\304\277aKM\374\366\234\263\277\006\206w\022\226\017\257?F\214F\207\241\377\303\277\251\232\361\270\016t\323?Z\247\"\332\315?\213?fD\260Jh&\317\277*\352:\245*\250\313?~\317\212\214\025\321\221\277\232\240\013\360D\260\305\277\356)\032\n\014\350\271?,\215\363\311j\347\260?l\221\315\222\262\267\252\277\242\020S \3304\312?\352pj\023c\216\243?\223\230\016\333\010\237\240?\234\211\221\206\365\376\304\277\265\202\340\230\357[\275\277\rO\210D{\010\303?QD\032\302\362\321\303\277\364F\200aB\230\277\277!\350I\367\025\235\274?\2134\237\376\252\037\260?\036\320J\255\000[}\277\362+P\206\224\273\261\277A\244\364G\007\216\311?\376\037\'\027oT\264\277\230\314TD\347.\252?O\364\312\357\302\022\262?8\021\227\256+\036\314\277\254\276\301\376\314\332\326?\364\330\201gZl\225\277\365\204\335\341\364^\271\277\007\252\370+\337\210\277\277H\275\243\373\230\366\227?s\356\307tpT\264?\006\275\333Q \026\310\277\302r\317\271d\354\307?]W\314(S\223\006?F\215y\314{\022\307\2770e?k\017\230\312?\262\376\000tIq\203?\311\255\2134R\003\310\277z\037\260\215)\023\316?\2565o\313v\360\224\2770\337\020,\236\273\273?t\350~,\232q\303\277\272!8Y\003\356\302\277e\370<\"\2720\325\277\376\362;\263\310\253\217?3\032,+Q9\263?\\\027\314\367\356\345\226\277\0076l\017\326k\266\277OA\004\370\321\027\256?h\tl\333}\020\300\277\023\361w5\311\216\213?\276$\020\307|\340\300?n\361\277m\021\321\227?\255%F\265\327`\262?\314*g\033e\261\245\2779\321\007\033*\244\242?\251*SCXse?M\370G\215\356\257\241\277\270\366M\347\345\010\262?D1\310\224=\264\243\277\355N\025qN\252\266\277\363b\271\030[\274\255?o\210\355\341\226\370\231?\nu\364\353\210\273\300\277\224\212B\200\034\335\256\277I\265\200\303Y\006\303?\217|u\2122*\305\277C\234[$\237k\305?\021\366\304\267\010\353\253\277\016\376\317-\037\324\213\277VX\034P\201B\267\277\243%\177\277\254\253x?\n\026\322\334\002\202\300\277\013\'e\247M(\261?\375\004*r#\313e?\352\317\211;\345*\203?w\342\034{sH\202?\323\037\005\3013H\321\277\276\371;\0343\245\277?\314\005\321B\345\266\306?\312]X\2224L\310?\270X\341\210\335?\252?\204\031)\251d\260\304?*<9\326\001\035\271\27701d(\025\210\215?\026\311\256\376\354V\302?!\214v\003t?\307\277\021\217\357\326\306\227\261\277Bo\360`\350\024\265\277.bl1\316\250\234\277y\243g\303\262\320\271\277\361%\'\377\334\247\314?Q\236**\260\032\320?\353\207\237\367#\306\231?;-s\304WH\252\277lJ\326\306]b\273\277;kQ\307\313\223\257?\267\274\302\312`\304\265?\220\266\245(x\353\302?\0178\205+EW\251\277hA\237\2145&\302\277}r\237\322-\225\260?\232\017\214\306\313_\231?7*\362\275\303d\261\277u+q+\353@\314?\220\206\377S\226F\265?\200\016\256\254\310\240\227?\276\3155\360\326\032\241\277\021\377\242\303\022\201\257\277Tm\017\240Mo\245\277)j{g\270a\264?_P\276\2673R\255?\35577\272\317\263\320?\002\311l\352/\370\227\277\326H\353\314\231\340\235\277\311\352\306\267\225\032\276\277\315\342\344\360\224\273\304\277(R|\243\225j\200?\375JE\020\371\331\300\277\031\266\033\210\n,p?\220\215f\020\346\002\222?\\\025\234*\261E\305\277UB6\023W\216\262?r7}\257\226\033\261?y3\333,\273\255\244?\255\263\252\232t\242\264\277\037\325\374m\0204\270?\237\027\374\314\262\366\266?\347\226\267\001\333\310\314?-\260?\233\344L\214\315s\212?p\213\024M\352\\{\277\2019\243\270\375p\312?\326\256\257R\304%\267?{\035\371\224}\355\241?\1773\336\273\371\231\304\277\212\277\350A9|\267\277\376\347\270\377\026\211\240?\350\204J\206\323\374\316\277\003`\314%\345\230\313?\330\017\006E\016\242\257\277pR\301>08\306\277Y3\354\337\243\247\311?\301\'\230@\004^\334\277\026\373\220\234\310\246\317\277\322gO\267,\032\300\277\223ed\r[%\311\277\203\026\353E\005\301\304\277\325[Z\256\222W\225?\025Dt\336\214\315\314?d\306\027\371\336\004\261?\021\253.-\377/\323?\237:\250k2S\305?\362SW\322\\\016\207\277C\211VeY\336\274?\203\256\227\326|\343\313\277\272\301\335\365\006z\242\277JWcH\023\274\300\277[\245\001Oa\342\322?\373C\236\305\244O\314\277Kz\245z#\354\226?\317rs\351A\007\274?\320\220K\213<\316\220\277x\331\341U\025Z\277?\263\237\320v8\t\304?\343\300d\222[[s\277\030\355.\034\007#\275\277J\202q?OB\337\277Tk7\371\310\034\270?+ \223e\2745\247?\274O\277\335\364?\227?\025k\341Y+\352\266?\260\2018\251\253\365\264?\310\372\206D\343]\302?s\334h\031e\350\247\277\372\275\220t\013\215\320?+V \205G\226\300?\215\263\265n]\316\206\277\261NT\300\217%\274?\211\001\017\352\252g\226\277b\230^\255O\262\267?JlH\\\023n\251?56f\036z6\203?\274\014\235j\245\360\340\277br\374\364\246\210\240?\333V\024*c^\305\241\277\303\271\326O\376\223\264?=\333W\370\322\372\267\277\356M\210\t\330A\235\277\331\306\3553\332Z\266\277\202L\262\365<*e\277\317f<\242G\271\300\277\243\377^\212\356\343\300?\032\037\221\221\227\213\233?E\305\026\272A\242y\277[\337\005\244d\217\307\277\347\245j??5\230?\235U\361\031|\363\265?\036\322\036\225By\306\277\317\3676\342P\'\300\277\320\310\014\200\327\255\302?\345Z}\022x(\230\277\216\356\342\354\020\246\266\277\377\232en\203\001\237\277[l2\277\235\312\243\277\243]\034wv`\244?\303\333\003o\202\250\267\277giC19\033\230?C\010x\207\304\020\213?\3676\027\0038\261\225\277O\340\006\035\327\034\241?]\007M\217\217v\301\277\250\023\\\332\201\305\272\277\314vD\341\316\276\266?\360\346\213\301\320&\262?\240`1\021\353U\216\277X\252\207BM\314\273?GO\354\243C\025\275\277h\261\212\256\353\333\301\277\340~=\\\356\202H?\266V\303\023]_\273\277\002\211@\031\304\256\242\277B\231\373\210y\210\261\277\037\241\274\241\367J\271?y\035a\342%\262?^:\307\357\"i\277\277\357\322\210\311\005\210\265\277\255!\207\337@]y\277\321\377\004\312\205>|\277\375\005\351w\034\322\240?\372\016\255\311\230y\203\277\372#,\001\213\240\305?\211\336\343\"IM\231?\231\350\243\333\200\330\277?5\257\211\370\322\024d?OP?T\347)\274\277\241\1770\232w\017\202\277-\007dq,Y\212?\021q\267XHh\265\277J\216\337\007`\243\257\277\266K\024\021j\302\266\277\270\246\370\016[\351\246?\244\220E\301[\277\242?\374\301>Nc\002\264\277\370_K6\016\277\322?\336\362\'\0034o\300?*\263\"g\370\326\265?z{9\374\210\245\271?\312e\357\374\213\\\277\277\244z\250\251\256\360\271?r\'W4$\345\204\277*^\270\303S\211\264?v\031\326\206?\241\307\340\233\271\177\261?+\364\227t\343\315\323?\267\216\353\263\264\n\244\277\350\356Y\331\207+\263\277\376\220Gfbr\266?\360\005v\244(\362\274\277\026e\371\'\314\036r\277\316\326\033;\341S\313?\332:\243\031\374\265\270\277\364Zh$\273\227\301\277\t\322\311\362^\211\216\277\217T\211k\231\321\251\277\277\273\n\375\267\253\246\277\221M\272L$\037\315?\313Jq\005*\331\231?\216\272\005d~\352\301?\350\001\231rC\306\265\277X\367\023\004\247\305\262?\330\267\323\007\n7\272?\205\313\357\333\263V\214?K\223&\246#:\267\277\244K\361\301\032(\231?\202\353@!\246\031`\277\245\312\267\221\275v\223?\310z\037\3742\005\262?\351\020.\341\310o\220\277|1\237\372`\355\264\277\220\230\372W-\213\255\2775-\3450O\331\261\277h0\203m\270\324\207?\246W}\372~\350\225\277=\031\273H\210\363\267?9\023\361&k{h\277k\313p\373?\224\266??F\016\2700\304\234?v\371\273$\341\214\302\277\304\275B\315/l\275?{\0279# V\264?+Ih\241F)\261\277\267\026\023\02663\302?\345\245\335\237\373\034\320?\200\344\224V\025U\310\277\310\312]]\277\255\201\277\331:\236\253n\024\265?\311\226\267\227N\314\257\277\240]\215\304d\303\307\2772O\254\031\374~\317\277\362\021\211\312\364\273\271\277\343\254\336\215\267\341\312?^\007\310v(\024\233?\251\352\033\213\005&\247?\302\234\024\314K2\304?\277\221\322\\\005\337\276?\314V_S\372\272\304\277\240\254\254\007\307\345\310?\374\243n\017\227=\273?\r\334\277\016c\230\265\277\032\2762o}\342\264?\347U\233\n\367\014\233\277y[k\347\302_\306?44j\344\210\'\303?\224w\211\021-q\306\277/\244\264\317Ia\302?41\352\272\t\r\261?-X\205\305\241\207\265\277\352\212\024\022H\221\247?\233\002\227d\031\004\311\277T*s\257N\365\261\277\023\n\216\231\304\272\253?e\321\331\321\201\316\210?\304v\035\315\033\005\266?\207\312\356\314\315\000\265?\360?\'\373RX\224\277M\346\262\373\022\375\245?\235\377k \017\373\300?Y^\003\3041x\263?\370\003\210\272\032\312{?\330\021\007\243\'c\301?\0061\317m\364\204t?6U\300 H\212\326\277vun\206\020@\255?b\212y>\370\240\271\277N\327$\310f\313\246\277H\n\376e\007m\250?\254\353t\032\256\027\242?\320\203\330\251\313\235\262?)d`(\005s\310?\254\373+u\303w\304\277\356E\201;\235\025\262\277\261\213n<\024\366X\277\345!Il\343O\250\277!\224\2216\342K\303?/(\367c\000\030\322\277e\323mF\201\360\273?\007\312\'O\236\314\300?\211z\344\333\205i\256?\364\2619g\213o\241\277\032\342zZ\177\210\312?})?\200\314\351\300?\303\321\026\335\342c\307\277\3115\337\200\226\236\322?\025\307\333xgX\252\277\310@\033\275(\026\271\277\3540\346\014o\331\262?\236G\023\035\\\261\251?\375\263#;\320S\255?\\\354\373\016\266\361\247\277\2200\002\333h\006\306\277v\207\252\336\217d\274\277V\212\251\220\370[\302?\372\271 \3004j\265\277Q\323m\2264*\252\277\277Y\353\234\306#\204\277SOoeTb\260?\277\277\3331\262\021\244\277\252N\253\325l\204\272?xs\346\267\250\221\260?\t\272:}g\336\266\277)\256d\371|\013\271?\341T\360V\2415\205?\374|\276R\332\303\310?y\363\3610\301\231\321?\361\203%Vrz\303\277\031\217\230\035\007e\275\277;H\360\224C\253\310\277.\3253=i\312\305\277\245`\250\360\273\000\224?j\251z\000$\373\266?\271\300\003\037D?\241?\027\326\034O\360\033\247?\2714\256\337\271\315\273?z\351:`\2103\241?\356U\nh@_\244?\263\007\312\343LO\300?\322w\310\345\216l\205?\375\'2\340\322\334\222\277-\234#R\no\247?\344)\354\307\320\254\273\277\')}0\006Cx\277\324\264\300@\022\354\267\277D\361\366\255_\333\263?\r?\202\247dv\243?Y\266\202\333\020O\325\277\361\334\221a\370\206\302?K;\014(8\034\300\277\213\353o\374\210\372\307\277K\336\020\237$\337\303?%\247cc\272\243\311?\0253\301 o]\312?\243\004\311)rT\262\277\212\214\371\347\216c\276\277\222T\303\226q\213\311\277\000\237|\347\367\020\242?d\226\310kE\271\244\277t\210\336\212\336\240\300?\301\007|\3737\372\305\277\304\222\3110]\324\312?\317\206\330OZ\257\253\277\240\365\316-\\)\263\277\225a[\262\r\203\256\277-\264\363*\202S\266\277\224K\323p\200)\351?\216[\241\370\024\364\245?BsG\203}^\225\277i\0374\352\270\365\276\277L\355D\277&\227\313\277wp\250\365\017\006\303\277\225rE2i\225a\277S\363\313\273\347\326\210\277\023g\261\017\177\352\300?\333\311vo\311@C\277\330\277\016\022\233F\271?\270\306W\200}[\264?\020\315{#.1\237?\365(O\342\264\272\256\277[\376\236B\234\365\305?]h\203\362\201\315\216\277K^!\223@\302\263\277\032\255h\236\302\000\234?\364H\035\222\274\342\260\277\332\212$\317\323\232\307?\307\224\374:\274\326\323?\205\337\016\022g\264\326?)C\303lp\013\300\277\253\036\367\010\311\030\251\277\000\365a~\030\350\205\277\016~\346\356G=\271\277\366\214\301z\222]\310\277\320d|\t\026\226\322\277T\363\351m\356T\232?\320\317w+\351x\304\277,]y\232\031\306\337?\320s\352\230O\236\307?V\001\2414\r\365\253?\026\025\217\251k\236\271?]\337\340\0353\311\317?\350\026\322\340\014\315\225?\346(\347\356b:\243?B\212r#{r\227?J\374\230\033\327G\301\277\211\2346r\332\271\301?^\246\024k\021\\\364\277\024\270\316\r\237#\263\277\376\216\031\343\303\306\322\277\353\326\326CYn\321\277\266\216_\327\230\201\312?\014\234\037T\246\306\303\277\241\301\212\005\r\021\274?\265L\006x\242|\301\277\032\254\256P\243\033\307\277\023\010\033\177\270\373\302\277~im\341\377\320\206?\315\340\221\273\"\272\263?\213x?\242T\267\271?\346\301Z\010\302\341\301\277\277;\277\332\313u\270\277\2119\340F\213\030\254?\027\357\037\310sG\300?\337\240\225e\2416\240?h\243\315\221l\347\230\277\013Yh~Bt\265?\367\272\314\347\377X\200?\265>\301\\\005_\311?\236\016\254\235\037\336\274\277\346j\001[s\'\273\2778\336\265\260\r\335\303\277*\221\237\240\213\3027\277\367\005\344=R\270\305\277\372\365\312\325ZL\263?eHT\303YH\265?n\243)\334\003\025\265?\3619\320\036Wp\233?\347\001\213[\273\361\304?R\325.\246\225\334\303?\366\232\237\232\"m\254?V\266\264\'\372\311\202\277\332v\271\232\010\325\305?\312\220\365\0208Z\304\277\246P\001p\302\234\264\277N\330o\350k\030\230?\233\207\177H\346\325\271\2772i\3169\237\232\236\277\274\212\023\326\'\273\310\277l\030\325\250i\035\240\277\002\215\222\340q>\312\277\366;{I\223F\276\277a\312d\351\354\230\244?\256I\216\020m$\265?IF\243^\234!w?\203|KI\273\206\232?fU\262K\036\203\301\277^R\346\212\2165\242?V\207\271\353\235_\267?\221\213\353\246\315\206\254?\351+\355XY\215\273\277\272\332#/\241!\266?\302\356\247\233b\306\275\277\353V\267y\303\014\302?\346`3\346\251|\276?\341p\001\257Iw\270?\274i\211\235Q\267\302\277\241\354\262\273\351I\265?\251\371\226:\307^\250?\200\313\222\346\010\233\236\277\307\002\205,\340D\276?\322\345\312\350\330\371\303? \257\2303u\356\256\277l\031\227%ln\243?\252X\277\343\306N\252\277?o\264\325\270M\313\277\225y\253\335\220n\256?R2&H9\271\300?\270\310+?\2345\303?\374\321\027b@:\257\277B\226A\220\303\t\260?\327\352TUQx\305?\034\232r\315q\317\271?c\362\027g\202@\271?1\250\n\267\337\261\240?Z\361\2371B\367\304?1\344\235\t\325\203\300?\033)\316\001\232\373\251\277\351\227\3756\375R\255\277\0060\035\263\024G\244?\214\231\3733O\234\271\277&\351\321\275_$\254\277\355\376\005\344\202\246\302\277\017\330\204I\373\251\223\277\324\025S\3054\206\204\277z\275Y\014\276[\241\277\212\233\360G\301t\241\277\005*\'\213\205\330\272\277\377\347\233\205\221\030\246?\237#\276\362\026N\274\277\304\262\233\271\252G\251\277c^\342\344=~}\277\330+v\357?\310\273?g\233\325M\0326b\277\352\376\273!8\226\304?;P\222<\306\277\216?\271\214\316G\314\321\253?\037\035\337\270ei\310\277U\267 \233M\241\303\277}\370\264\237\376\224\262?w\027B@d\030\265?D\254@\324\251R\273?\333\271\224<}n\252\277\356\277q\332>ie?\326\2043d\006\236\300?\314A\301\360Q`\244?\3563ee\337\177\236?\311\352\213\204\177\254\303?D$\004F\357\223\243?\261E8\374d\215\220\277Gr\253U\242e\276\277a\000\024\036\222\002p?i\371\3059\357\335\231?\372\270\222\t\252<\237??Z\277P\336[\320?.&pnh\337\263?p\226\333\020\320\245\313\277\3413\257\3643\260\251?\345)\245a\004\267\265?K\271\206p\002R\276\277\t\232i\352V\264\304\277#\3429\335g\352\223\277Vs\343h?g\264\277w_SM7N\261??B\312\004\337\021\265\2779\224\030\335\211V\235\277B\250\355\230\376\315\300?\036\377\003\266\343;\311\277\301\255\365\3338\220\306?\265e%\324\233\032\304?\206\337\202He\273\300?\307/\213\314\031\326\307?\000\025n 6b\303?\270\221\316\313s\353\262?O\242A\277&x\266?\304\274\265\212\006\313\314\277n\330C\263\026\321\300\277\322\320\236\347\347G\271?\t\343\013\036\006\354\272\277\351e\332\016\024\332\270?\202\375\374~\t\315\217?e\372\206\265\320\031\321\277\245\332\254\271\353\232\260\277j\327\237\036?\365\316?\224Q5^\205\250\301?\377/A\236w~\256?\310\333\375\231\312\256\300\277\261\254\002\203\254\261\235?\"\013\360.cA\253?\251\376\350\231K0\271\277\nG\'\310D[\257\277\307\226\243\210%z\303\277\371Q\353\261\264\337\312?A(\000H\332)\263\277:\227\034\344T\377\227?%\345(Q\263c\256?\372\006M\310a\274\255?\216\255\036\347\000^\262\277\230\356?\245b\267\272\277\347\024\361\261\245\214\251?\372l\016\272\2406\276\277\266\277\317L\377C\270?\227QE\361\375\311\303\277\236\356\014?\027\262j?a\354\005D\370\326\320?\203\355d[.+\251\277\355\267\335E&9\302?\031\251j\351\220*\273\277\335\021\237\356\031o\242\277>\370J\003\246z\233\277\255 \372\n7\206\240\277v\341P}\010\311\301\277 \032?\362Y\321\254?\300\260\326\346\354D\271\277\345\216\355\307\315\307\307\277\261\330\211-\320\204\300?}\341\216z\005\307\320\277\253\004\331X\016\354\270\277\347q\352^\373\262\302?\313\265\333o\227\303\246?\335\027\004\346?\376\306?\361\373\316%\341\240\272?d\227\271\023\254s\305?+P\2155\342\362\264\277\355\330\274\204L\377\230?\332\325\036\267x\220\215?\212\365|\253\344\006\302\277\007O\265Y?\225\221\277\302\014\020K\032\273\257\277V\024\3532S\007\311\277Gb\351w\027\243\266\277k\342J\220\344\316\203?Q\251 \036P\344\257?q\341\267()\237\300\277c\t\263\313HI\302\277\202\"\372\237\326{\207\277\207\332\014\007rh\226?y\t\\\2365Y\267?\317\260\364\000{\000\273\277\335\306\333\330\016\244\313?\26706\326\246\362\223?\314}\310\364\314\\\266?\027\346C\354\3259\271?\253f)\234\032D\255?" + } + } + } +} +node { + name: "layer_2_type_0/matrix/read" + op: "Identity" + input: "layer_2_type_0/matrix" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_2_type_0/matrix" + } + } + } +} +node { + name: "layer_2_type_0/bias" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 40 + } + } + tensor_content: "\301sy\273\242\343\366\277V\010[i\177\354\355\277\336F\206\277\247~\310?\257\001\340\3665l\313\277\307\375A\'\034M\363\277\323\237/\367\225\345\337?\n\232\014~\334\300\324?@@\243\2662\363\360?\037jxS-=\376?\267K\203:\213\312\351\277\212\265\032O\253\275\345?\273\377&\263\262\337\355\277\004z\302\017+\200\302\277j\274\224B|\261\310\277 \346M\247y\222\326\277\234\026\306j\006\031e?\366{\275\034\177P\371?\371\367\353\230o|\324?\363\203\303yh\267\356?o\305\335I\345^\317?A\305\201\240\2340\342?B\010\243\375\364\256\374\277\200\024\271\321N\033\375\277\370\000\234B\227\331\365\277x\222y\000\215\221\315?\332C\310\206\335\217\353\277p\235\354\205bo\342\277n^\035\211\277\010\375\277\013I\331\024#]\354\277\257FFE#\005\243?m\314\034\317\322 \347\277<\203\360)\277\035\367\277\020!1)p\332\001\300\244v\325\225d\376\332?\210\215|\216\377\345\364?\007\324\274v{j\361?\003HB\340\312\313\274?\027\223\357\225\217\355\257?\003g\326\251EX\322\277\020\340f\342\261\337\373\277" + } + } + } +} +node { + name: "layer_2_type_0/bias/read" + op: "Identity" + input: "layer_2_type_0/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_2_type_0/bias" + } + } + } +} +node { + name: "layer_2_type_0/MatMul" + op: "MatMul" + input: "add_1" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "layer_2_type_0/BiasAdd" + op: "BiasAdd" + input: "layer_2_type_0/MatMul" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "layer_2_type_0/idt" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 40 + } + } + tensor_content: "nU\001P\003\257\266?ug\233\263&\235\305?\004\361\204\235\245h\272?\301\225\313UT\003\243?I\263\n\030^g\272?\253<\306\000\t\013\276?$\031\246^\221\370\245?\260\007\303\237\251\203\300?\204\036\272_\322\275\277?j^\313\245b\016\240?\246\234\371\220\371\255\263?\224\212U\325\217\021\274?\213d\221}\317\241\217\2770\317\351\374\275\307\246?\210%D\314^\323\267?it^\247\315\242\266?\307.\201\003yx\266?\363\014\337E/\237\265?\366\347\244]{\361\245?g~G\0050\271\257?\360\333\310\314\200`\243?i\306a\375\300)\264?\340<5\212\362\367\277?@SB\345\216\'\275?\332D\236osA\264?\211\344h\364\030\033\267?g\217\360\3745\245\265?{\323T\224\2013\306?\302\017\271)x\322\264?Bx\245\022Uf\240?\356\261C\3416\363s\277\231\307\325*h\000\275?H&\002\212t\315\262?\332\333\261\222\006\177\331?\016\210\020&d\330\300?\347\271\355\373*V\272?\323\311\"\004\202.\306?S\350\013a]\332\247?3\2772\201\337\343\306?\377\2101\034\237U\273?" + } + } + } +} +node { + name: "layer_2_type_0/idt/read" + op: "Identity" + input: "layer_2_type_0/idt" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_2_type_0/idt" + } + } + } +} +node { + name: "layer_2_type_0/Tanh" + op: "Tanh" + input: "layer_2_type_0/BiasAdd" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_2_type_0/Reshape/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377(\000\000\000" + } + } + } +} +node { + name: "layer_2_type_0/Reshape" + op: "Reshape" + input: "layer_2_type_0/Tanh" + input: "layer_2_type_0/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_2_type_0/mul" + op: "Mul" + input: "layer_2_type_0/Reshape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "add_2" + op: "AddV2" + input: "add_1" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "final_layer_type_0/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 40 + } + dim { + size: 250 + } + } + tensor_content: "B/\342\355c\301\275?s\211\330y\227S\237?\347\366HS\021\270\266?\301\234sM\327=\302?X\224d\264\264?\255\277\302qY\310\017\030\276?\336g\242\333o\234\311?\300\"\226\204\227)\265\277\341y\214\312\312\366\256\277\212\362u\361\203\005\264\2777\336\022\202\342\356\260?I7V\312P|\222?\230\341\230`^\346\261?\316jS=18\272\277s\034\323]\325q\243?\236\274\032\030k\016\217\277j\231hl\2055\304?\274f0\372\215\330\261\2777\"zm\325\375\274?\360eL\216\377\336\260?\303\243\021\010nn\266?\230\ro\231\355\'\311?\267\227\303\304\0361m\277\302\363\311\306\360\217\304?\363\345^\233\230\207n?d\321\366\363\332\357\224?\351\204=\241\253\020\205\277\262\342\250\205q\023\255?\310\336\225>\371\354\262?\ts\375\235\251\206\263\277\335-\0105\330\266\270\277k\313\305\214\374\003\250\277V]\274E\016\347\236?\325\021O{\271\221\245?\032\017\014z\232\266\246\277u\330Z_\033\024\236\277w\3533\244\357J\270\277\300\374A\232\267z\270\277.\307\2673hR\200?\304HB\207\260\240\222\2777Z\275L\354\036\264\277\027\303\242Qj>\302\277\022>\027\360[\327\227?\262\257IB?;y\277]D\233G\022E\201?:\235Md\250\335\260\277%\367\242;\310\223\251?\315|\024\270R\t\273\277Al\247\344I\213k\277\2139,z\212\272\274\277\361\014[$G\003\253\277\3264gy\262\257\211\277fw\376\007v\320\266?\233\313\363\227\245+\264\277\363\344\352f\357L\240\277r\352\264\263HM\253\277\234\254V\236\245\340\255\277@\217Z\201Cy\273?i\212\215\367\366\334\256\2775\371\272U%]k?:\3122h\267\212\231\277\035n\326\252\276\330\224?-\324\332\245hP\261?:104N\226\252?\304yu?g\251\260\277\1776c\005\252b\227?\204,\232\336&\315\272\2776\313W0\302\250\211\277\305\033\352x\376\235\262?s\311\001l\231a\263\277\246j3\321\322\n\231\277^E\364\271\334\032\240?\177\301>\366N\253\276\277|\341\353\010/f\265?>q\367\337[\032\256\277\201F\350~\335\320\222\2778\'\317\t\374g\271\277\375Z\024\241\002*\227?\016k*\341\255;\267\277\r\014\213\212G.\222?]$\266f\251\025\262\277\276\255*\325m\326\224?\275\000\376\014\373\222\243\277B>\345\260\302\376\300\277\277\254a\240\3231\263?\236ow[\332\260\274\277\217{\001EC\374\265\277\034\343{\233l\016\304\277\270\277\350\3666\024\253\277\315\221x\316p\227\256\277\235\321\035\255jZ\275?\333C\302.\261x\252?\007\346\013\204sT|\277q|\250;\341t\275?\275\345\017\313EBn\277|mP\001W\303\264\277\303\340\214\306\242\014\266\277\260B\230Q\366\\\254?\347\367L\241\200\265\251? \"\366z\277\243\204\277\n\346\201D\241\366\272\277\211\336O\326e5\252\277\304>_\357{>\246?Fk\235\216\"v\271?\263\214\207\311\217C\275\277\302f+6po\265\277M\'\235X\217;{?4\375@\020\335x\307\277$\177\014\200\374\327\206?\340!\2607\031\302\252?\353g6-\326\206\300\277\366\303\210\221a\005\250?\370\014c3 \373\234?\306\322\211}\341\221\301\277[\026|\226\252!\236?\224\271\323/w\240^?\321\237\002\n\234L\223\2776y\256q\2223\265\277Uw\317\371\305\025\302\277\000drY*\276\205?\260r\021\353\211\200\223\2777v\255<\245\'\243\277WQ\223\307\2642\241\277\201\'4M\0267\257\277,Z\312[Im\270\277\207\311\250\262<\337\243?\030\275I\346#\030\252?\007\022\004\207\016\333\272\277\351*,NT\254\271\277\022\277.\351\002\270\263\277\356mOo\355M\262?\376\3468\263\220U\270\277K\306\034y\035\326\244?_\201E[\234\343\304\277\223\216\\\310\200\203\275\277\323!p\221\244\313\260?\377c\2216\365\3113\277\031be&\373\353\262\277\253P\033\3255\355\244?\377\266\236\313t<\301\277p\304\n\327\275K\276\277\220\334\306\321\020\032\244?\317Y\3647\217G\251\277ex\002\000r(\254\277<\263\372t$\033\242\277=:\250qr\022\251\277\3448\206;\360\263\270\277\262\344T\315\"/\301?\300\035\003\356)\360\223?\245d\233\2554\340\225\277F\001L\246\220\262\270?\026\203\250k\3164\202\277\312\005\216\315\311\261\254?\362\211\242\001\317\267\226?A\256\026M\025\224\271?\016S\n\233=]\220\277\252K\241/\001\230\242\277\234y\264}\243\234f?e\252\221\364K\373\235\2778\252\366\356\304\360\246\2773L\263\033Rr\276\277\252\323\007\306\"\245\250?\260\216\346\031\233\366\270\277\016\320F\365!\004\205\277B\333tp\245k\300\277\235<\350<\356\200\302\277\026\226\010\362\013\\\242\277\376F\326jj\334\273\277\001\250\000\222a\264\301\277\235\321RC\206\253\252\277\000\316K&\342\352\262\277\376e:\341\277\332\256?\223\267\'\276g3\247\277h\002\220\322\000\225\230?\207!U\201=\203\235?\023g\326`\376&\251\277\216\373Gv\217\317\267\277q\266g<:\205\225?\262P&\310\270\273\225?X\253\002\264\0359\263\277\320\361\014\255\3554\210\277?\307\311\221\256U\223\277\205\002K\315\376-\241\277R\301}\2262$\220\277@\260\225\267 \214k?u\250\r\027\207N\237\277\352\227\\\271\242\374}\277(\031\357r\215\371\257?\244\275\313\222\310\260\252?\t\342[g\246=\221\277d\271\240\271\224\360\\\277j\352\302r\254\300\247\277\005\314c\376`\356\263\277\017\335I\216\244\355\241\277\261\203d\230\277j8\356\221D\370\264?\327\032\274 \330O\253?;\333\344\205.k\256\277{\231\2743C\313s?\023\247\365\213\350\323\260\277\276\026\303\305\267}}\277\220\034q\321`]\233\277\244\204\025>\026u\275\277\345\347\343I\326\362V\277\274\006\364\305\000\031z\277\256\"\031\34660\245?K\014#d)\356\220\277\354\306K\253\266\"\257\277\267O\330<\235\307\263\277\274\332\344\352\227F\274?\342\027K\025\331\224\247\277\212|<\311\213\014\242?\357m\364H\275P\215?t\034o\332\344_N\277ea6\274et\245\277+\250K\342N\262\252?I\243\272o\324\226\260?\260tH1\371\010{?\244=m\307\370\245\245\277\376o\003\017\257\037\214?\305\016\256\353G\003\261?\327\240-Z\356\334\206\277\017DZ\212\022/\231\2778S\001\342\303\210e?\212\261f\351\005\324f\277oB\2100\261\327\246?c\273I\014\266\321\301\277\273M3\323\321\333\224?\030%\241\340\267J\261?\025N\256\322uNq\277\257{\202\376\3205\303?3\t\254L\326\027\263\277\003)\2361\022m\264\277\333\247e ZM\265\277T\367\027\317\341c\243?\002(M\303\2019\252?\316\026\001\340\227\260\247?\307/\223\334u\"\260\2773c\253\216Ef\202?\342%\342\267\034L\263\277\273:f\030\337\212\252?\000\276F\200\251\354\216?\023\215\316\202m\256\261\277w\363\356ihz\272?\277\242\0065\020\226g??\177\327\207\204\361\207?\274\266%B`\237\260\277\261z\322-@\262?\214\224\230\222\322\201\263?W\030<\346\033\013\236\277\3758e\201#z\251\277$\021Q[\257\273\265\2778\340\335\242z\362\267\277\314\220F\334I\023\303\277\026\374T \270\353\203?\240\0161L\027\341\255\277\320<\334\032M\001\266\277.\007S&\356\311\260?\255f_\232\362r\267\277\271\343\323\362\252\010\303\277\276l;\263x\364\247\277\203T\265\242\355\256\214\277\036\2675\373oR\216?\217\020&\267P!\302?\332\322#K\206\366\213\277)6\026\362\273\227\265\277\366\237\022\332\257I\264\277\233\177G\372\335\330\226\277b\'T\255\251\025\242?k\327\276\2326A\247\277\242$\315;8\347\224?\007\252Ym\024uz?i\354\217h]\r\201?\224w\345;/\272\255\277\324\016\014 \237\217\242?\205\314\203\213\204\315\252\277\335)\027\260l\037\252?\204\310F\207\022\221\203\277\023#\332\315n\031\274\277Ii\352n\335\206\252?\227\202A\302\342\224Q\277\026\277~\025-E\221?\330T<\262g\365l\277\372\206\017\323\340x\211\277\345\355\256\300\264\022\300\2776\234]v\315\207g\277}\024\345\264\221w\216\277\375LGY:\014\243\277\302#h\0017m\244\277\021\310av\271G\251?M\336\024\252\005 \222\277\r\030R\3345\244\241\277\311\3763\354\236r\233\277o\256\250\367\274`\257\277t\266\226Ob\007\235\277~\016x\374\025v\257\277\342\226t\372\342\342\276\2776\367\346r\346\237\227?E\255\331NW\333\303\277\222Lkq.\203\250\277\210d4\030\327\302\244\277H\323\317\227M\223\303\277\035\375@\374\254\n\261\277\2668ry\304\001\223?X(=\331\373\344\261\277D\327\332C\364V\214\277)%\3475c\270\260?\266\tt\242\223\260\260\277\342\t\362\262\335Y\241?\351`_\242\2326\224?\266\223\021\nC\316e\277\251\223\244x\276\t\301?\'a[\265j/\253\277\372\266\236hs\305|\277\366\035\211L\277\010\232?g,\246\361T\025\226?n%D\352\246u\256\277Xz$\214\221\027\237\277\246\251Oa8\366\232\277\207\316\302Z\375\232\244\277\265\033\003\261\244X\264\277\344\t(\0020\254\241?Bd\376\245A\320\246\277\242\325\036\316\267R\254?7z\370\366\242\352\243?<\347\242\222\252s\242\277\233\370\037;\227$\301\277\376}c!\201N\241\277v\300\327\226\360\304\240\277Z\260\321\t\014\246\260?\3150\227\037x\204\262\277\312\221,Cm\252\242?\227\031(\246\257q\235?\373\306\2059\314\037\207\277\335&d\231.\265\253?\017.@\253\257\031\236\277\020\233IZ\371\204\240\277\200\033\245\254\264p\220\277\332\013\323\355\271\201\200?\363\303%\206\2441\250?K\260\247[\036\030\250\277\3062\005\025Q.\235?\225\237\216\007d\034\262?}Cx\021\253vt?\250|g\306q\334\263?\235\317\372%W\226\270\277\310Y^>\265`\273?\304Zy\001R&\267?\177\010~\206{!\260?\347\310\023\":\333\262?g\274}\205\003\346r\277\236G\227\357\327\n\275?S\350\037S^A\232?E\375j\207\333\237\247?\344\311\304cZ\316\221?\002\313\340\272\232\371\250?U\304\320\304D \262\277Y|>\017\\%z?^\353\224x\036<\240\2773\005 \001\245\235\261?\242\246\236\345H\345\273?\265\240\264+<\354\240?\225\014\214\201\033\277\266?\305\336.\021A+\270\277\253x\'\235\r\020\277?I\363,\216\001\252\246?\n\205j!\035\271\230?W\271\235\254\321\210\270\2773\355\"\226Z2\247?{\375\277\315\222\034\244\277\253|.\270l[\252?\177\2777\002\207\224\304\277.\356\256\300\023\323\225?\372\005G\254\261\315\224\277\361\346\360m\000\251\301\277\266P\321\3073\355\207\277\366\256\302t\261J\300?\262-\333\247\231\305\310\277\032!\324\366\2103\263\277;\325\027\322\022m\300\277R\302\330\327/H\261\277\331\247\301\014\225\204\271?\016\372 6\323q\252?-\2020h3Y\275?.\367;\254\335D\267?\367\331\223\213\347v\261?\013\201\345\034\307\323\211\277\236I\334k\227\356\270?\352\"\361\373\324ur?S\326O6b\205\271\277U\376;\000Q\273\235?dM\265d\237it?G\366\301\333\347\320\243?\250\350\203Ov\014\244?7\315\272\024\177q\301\277\262&/e0\254\222?\204\260\274\340\373\346\267\277\224\352\001\205$\t\247\277\022\252Zx\247\230\300?\321\014\366%\321\\\225?\372\340\213\200\260:\275\277)\231\271]\353\035\251\277\204)1\207\362f\266?\035w\330QRP\276\277%\362P\355\022\220\217\277\033(M\035s\356\213\277\300\262\330\301)_z?\331\224\321\311r\001\255\277cQy\024\317\361\270?\223]\312\246\0250\202\277\367\'Z\361 \020\226\277\0360\370o\2629\256?\"@^Y\n;\242\277=7\'\332x#z\277\032\267\037\314\227\214\303\277\014\370$-S\352\272\277\314v\323\265_9\261\277`\005\224\261]\273\234\277:rY|c\251\237\277V\311\323\236l\232\241?\274o-+\021\336\246?f\267!\344#\214\241\277\370\320\315\272\210L\221?~^M\372}qb\277W[o\021\023f\310\277R\242\371\365\307\036\306\277\267U\220\325\241]\240?\231&\261\253G\256\240?\001U\207\201.\346\300\277\035\271\010p\222\265\271?\240o\203\356N\265\260\277\177\316\201_\007\217\262?\004.\221\327\237\373\247?{\023\356\225.\217\271?=\006\342\366\r\375{\277$Q\340\306U*\240?][\365\234\304{\262\277(=P\034C+\214\277\t>\\\244 \314\244?\200\207(43-#/\262\277T\355f\023\344\206\307\277\270\210.\201\204\305\263\277\226\034>G\r\367\305\277\323`-v\256\215\213?\247=\325]tp\254?\216\"\010\301\275\005\222?3\037\023k\343\334\270\277b\347\027\032\242\215\260\277\372K\036\340\221\000\247?\343Mm1\336\256\210\277\222\213j\023e\270\260\277\355\362\3115e\276\250\277\021\000\032vy\267\265\277\363\220\347\234\223\270\271\277\023\320\314ZT\177\245?\312\221\204\254?/\262\277\312\307\314\234\204\315\300\277\307\303|\353\222\264\203?;(o\327\366\362H?\025\273\376\336\231\244\260\277}\267\2752\"\321\265\277\001#\374\342\333\375t?Q\261\205=\300a\225\27770n\245G\0344\277s/\007\3126\255\277\277\242\336X\326\343\262\261\277o%\207\357\331\273\277\277\n\244\216\226\226\016\217?\305y4\240N\004\265\277\2228\222u\372\305\226\277\270\016\002\233\333\347\271\277:\001.+\033\363\262\277\257\257\217\233\345\263\245\277=\244\031\006\243\276\236\277d\370\346CSa\253\277k\010\333\332K\343\231?\272\r\03032]\241\277\370m>\206\222\247\205\277D\334\305\305\357x,?Yn3n\321\344\246?\014\026D\033Pf\264\277H]\321\230\037~\227?f\362\276\332\375[\265\277\227\227TF\2578\274\277\262\005\360\375>@\232?B\000\021L\241K\271?\036\nq\334\350\252\276\277\241\221\354\331\361M\306?|;\376\004\261\270\217\277\316I\257\263]\203\255\277\336Q\374\354k\264\302\277j\346\240\024\276I\206\277\352\320\341.\026m\277?\024\212%\362\010%\265?:\360.\"i\336\224\277E2\2017\325\267\220\2776\000\217\263\302\013\277?\236\314\233\014\245\n\230?\200\024\366\303\233j\243\277\306\t\273\335\320z\226\277l\002\235\255\274\321\230?\365\n\320\277\314\244\225?\311:\365v\375\207\262\277\220}\343/J\305\261?\254\007Y\235x\302\231?=\346\315\003\355A\240\277\027\310y\204\305\266\230?\n6\374\2753\367\260\277\315\354\306\230&9\274\277\204\257\036\352[\"\272?gT\232\375\353^\252\277P\203\357CE\020^?\360\251\217\"{\301\221\277\003\010T\347\373O\245\277\301>X\316\376\266\277?\362!)\350;\202\201?\307\275\035M\016\305\273?\223\302\274\213\301-\273\277\365\205\001Wz_\271\277\n\357\326\030]\347\202\277B!\310\215\324gH?U\276\032\240\020}\263?\241\026\257[|\361\246\277\343\214\334\255X\302\224?*\323\367\261\224\237|\277`\350\233\254\262\303\310\277j\232\235\352\336\354\235\277\005\275A\234j\306\242?\242S\374Ih\301\256\277\324[\022K}\220\243\277\03463\002\000\317\217?\007:\"\032z$\260?\275\003aKBz\265\2779\344dW\337\203\203\277\267\277kc\020F\251\277*=\"\032\356Q\254\277\376\267Q\345\343\376\265\277\276\211\177\345\343\251\216?\235\274k\2340\033\301\277\'Q\341S\rD\262\277\227\333\210[X\344\253?Z1\001h\020h\221\277\233\316\336W^\326\257?6\364\344\\\361\323\257\277\317%\0036\261\332\221\277\327tOr\313\205\263?\233\253f\347|\254\244?Qo\227\r5~\204\277\0246\227\272+\226\265\277\006\374\341e)c\301?%\217\025h\025\267\230?\260\"%\334\030\254\254?\025\237\336{Z\333\253?\'\177R%\203\360\200\277B\261\020\271\215W\245\277\331\345[U\304\367s?\3579Y\013\220W\202\277\276\323j\330\375X\242\2778\356t\324\007\325i\277\347i\201{\217+\247\277\t\204\312>\343Y\303?\033}\363\264;\343\262?\323\021\207<\333N\222\277\234QZ*\336\360\276\277\025\322\243[fU\204\277C\010d\261\255\033\256?S\272J\300\215\377\251\277xU?Q\260_\250\277\200\010\207\365~\214\254?K\244\346\251\031\251e?K\317ej\\\360\213\277F\302`\350\232P\262?\332\000d\0007\306b?Jg(H\353}\213\277\240\353s\"\231%s\277\267\370\277e\"m\216?5(\340D\235\321\300?`\203\010\304\034O\266\277F]\367\352\337+\273?vE\r!\307|\253?\326t;[\253\372\303\277\001\376\310\334`\320\256?\301\00116\020\\\224\277,~(\277b\005\272?\332o9G\034\371\262\277s\226\210p%(\303\277a\363e\370\334\024\231?\035\t!7\221\261\230\277\014o\272\036\2519z\277yf\2306\\\335\302?\005\204\211\004\374,\322\277H\365C\362\243:\257?\305|\212\262\254~\310?=\340\202\033\220\315\260\277\352\\\255~7\273\266\277\337lt\315\311\235\267?,\005\000\331<\355\213\277\013E[\r]\274\240?\022\"\336y2\200\257?j7e\213\325\026\305\277\020\270T\211~$\300?@\035l\276_Z\224\277\217W\234/p&\255?g\340\226\004\205\212\260?\241\217\024\005\220)\215?\022\230\365\312\274\016\305?\364\354b@\006\367\272?\006\013\366\256\210\037\270\2772\363\355hKp\257?w\341\234\346\373\202\255?\220\251\211\203Za@\277\364\221\331\350O\243\271\277\005\357\372\344\221\265\233\277v\034F\341\326\223\214?\212IX\244\024\363\274\277\310v\214j}\271\235?\203\310\005\311\345*\202?\233;\027\205wz\200?\177k\271\303\030m\315?yg\243\276U\344x\277\nh\272}\267\036\247\277\013\332\276 )\231\226\277\367\272\005P\305\033\266?5\220\324\177.%\275?*&\304\273\3605\261?\252o\333Lh\200\211?\374\341\035\322\215\034\301\277!\305\230\236z\017\254\277\307c\213GWt\246\277\220\\jW2\233\245?\217y\327\0073\366\257?\222\254C^\370\264\247?n\212\221j\260!\233\277F\276\335\357\211\306\253?\314\3659Mz\336\231?\330\305&DV{\242\277\004\264\211h\370P\274?\263c\362\335\374\270{\277v!A\341\256\261\270\277Q\326\316Y\034K\232\277`\007Re\1771\257?\226\230A\3203\"\247?\307%\340\354i\277\261?\323\032G\231\302*\300?u\370\326\224\271O\251\277k~J\275%\274\241?\035\264\016\260!(\243?\264\0351\313M}\263?O\243\345\3641\344\265?\224\273tHe\214\240?\261\330;\315.N\316?\237`dO41\252?>;\217 \233\343o\277\007a\256\343\177L\260?7\270~\214x\022\306?\365\227L\277-A\232\277\236\371\372\177\242N\305?\353\333\274eSp\234\277\216[\207\221Lv\247?\007\311\272\375\250\027\262?\260WS\376e^\305?\221\022\375\236\031\017\206\277\025\032\227\346?z\256?@%\031\237A\024\255?@\310\337\222\026\031\237\277O\206\r\267\260\310\207\277\036\202\246?N,\243?\307\'\220\332T\004\273?\216\332\203O\333?\272?\037/\212\271\265]\262?\227\270 \026S\237\222\277\\\226\312)E\325\265?\032\342_6\314\030s?\364\"\325]C\177\271\277\003fFX\217N\263\277\023\325L\327\265\367\262?D\275b|d\303\253\277Vq\226\221\231\022\251\277R\265\351\031\013Yh?\"\210gvq)\243?\347@^\330\025\316\250\277s\340\331Y\372\243\236\277\221+\365x\345\213\265?\234\321\202\353\270T\265\277\372:N(}9\247?\323\027s\257\376y\274?WL\214\203\230\264\275?\323$\206\364g&\273?\005\370:.x\250\233?j\327\237I%\215\220?aW9\277\236\211\271?\302\220gR_J\274?v\325r\223\204\334\305?\277Y\376\353z\005\234?\203\213K\262\321\325\300\277O\223\240e\324\001\240?c\264&\207\222=\266?\213.\322\201\360`\222\277\261\3137oV\266u?\247\032C?\214\343\241?\"\272~g\273\235\271?\003wi\313i\214\254?<\037\t:\344\224\265?\311\234b\250N\237\261?N\031\307*\017\201\236\277\003\305\214\026\275\364\307?z\025]\030f\253\220?\3450q.#3\226\277\271\3047\245\344]\246\2776\302\316z\275\356\260?\034Fh\275u\227\263\277\273\242\240:\020\"\243\277\226\"f\275\235\306\263?\306\342\361\247\354\302\266\277\340\246c\313\014}\226\277\323\031\2533\2106\226?C\021\207\2557\340\235\277\346\n\254\226\320|\263\277\305\240\345\324:\224`?\026M=6\243i\224?_o3]\'\354\267?mz%)q\313\306\277\205\027\347\211i\377y?\001\031(\'\224u\256?\235\r\236\307\3452\242\277A|T\010\247!\232?\227q\277\"2\266\211?\035\320\235\031>\212x\277(o\264\334k\363J\277\3147\016\263q\014\217\277\324;\344\025y*\266?u\200\352U4?\273\277\212\2035\320\016\004\301?\237a\'}\310\226\236?\261D\272G\371\315\261\277\266\302\n\2120\357\276\277XX\2413{D\247?D,\272\n\366\233\256\277\320\377N\227\027v\236\277\033\177}\361kt\224?\247vB[\024\017\242\277\243\244\357\036^\267\253\277\256\345)\204`-\301\277\200=h/\300\002\220\277\375\345U\002\264\307\205\277O}\373\352\321;\263\277\2620\233o \355\265\277\332\274s@\325\351\227?\004\3632\255\027\262\261?\346\'\363U\354\n\270?Q:0\241*\235\261\277\303S\235 ^\346r?\232\t\334+\243>\275?\236\253OG\304\351w?A\201-O=\3038?g\234k0\324)\234\277Z\321@\313S\000\273\277\272\357\370\025@go?\210,\357t\362\263\275?\344\001\367\322\233\031\277?\273F \366}\324\243?\001\346\270\tDK\235\277PA\336\205\300\370\233\277\245\340\346\243=!\274?I\350\006\265\277\017\247?\270\235\373qePa?\242\242\021z\237I\261\277\300\t\303\220\362\315\244\277G6\254\303\257\250\305?\313\250\317\'\227M}\277\357\360\271\364\301\306\253\277}%D/\250\235\241\277J:\303o\307\346\276?\353\244\227Me\nD\277\303\2328\340\333q\245\277\\\223\364Z\001\016\267\277\360nr\313\\k\200?\r\241\220\352\2370\263?A\237^\210\203N\227\277\014\001?7\270\353\277\277&{q\013,\222\260?,\336\3226\206.\243\277\257\317\233d\305\210\272\277O%\350E\311<\244\277\264y\224\217}\312\237\277-\2247\215QH\313\277\266\243\277){\344\261\277\026e\n\\lD\241\277\302\332I\222\314\255\256\277w\377qR\252\321\253\277\262\266\2316\201a\226\277x\355%tB\356\253?K\343=#^\320\222\277\267\366\200\213\314$\250?2\304\r\374\241\241\272\277`\276\r\342\366\231\276?\216=M!XD\212\277UO_\364\210\376\245?\210\3104\376\221\311\206?\204X\n\004\r\341\262?\035\033\232p\034\316\216\277\216$HE\356\261\226\277\276_\024\276T\220s?v\021\035\315v\361\231?\025\366{\316?n\216\277\302\356Y\263\021\310\246?g\377\273\323\242\235\247?\225\003$\325\341[\223?\2158\237\364V\255\273\277\265\212\225D\013\334\246?\262\362M7\0314\263?\273%\007\257\341\227\200?w\206\255\350\232^\266?\2520\014\333>\017\245?\373\021T\326N\335\217\277G\346\321\211t\302\177?\376\313\224\254\214\337\216?W&\203W\001\254\257\277NO\003\333{\"\265?\336\304\307\276\027\342\263\277\214\020\265O\327\200\245?%6\260`8N\247\277.yce\'$\246\277K\325pu\330\021\203\277\215\303\253=F\034\251?\223\247\220\032\273\251\272\277rL\355\335g\300\220?\352\262\244\023nL\236?\0229\346\207\324-\261\277\036$\215\223,\311\244?\354\302}\027\206+\270\277\033\0171\253\2538\264\277\251\332\347T*\350\205\277\r\253\237m\231\010\300?`$tY4\032\214\277/\366\323J#\352\242?\363\265\250D\271-J?\371\003M\254\235M\245?i>\03417q\220\277\306\207{\031^\217\272?)Q\025PES\225?\262\315\3370\331\251\250\277\243\327\325k\222\353\246?\350)\251\361=\301\243?\003\204\274\250)\220l?\307\235RkF\227\232?:\321W\270m\013\264?E\265#o\232L\267\277+\';\375\244*\245\2776\327\\3}\343\250?\351\3431\373\217\033\255?\337\360\257/\364T\244\277Ea\341&\271\240\255\277cG\311\027\211\355y?\233\002\352G\221\r\202?\345q!\305R2\231?t\303\344\363;\265\266?\373\262\333\360\030\270\263?\341j\340\0023}\260?[\006\200\010\313\366\224?Uv\316\024\215\273g?z\270\321\304-M\177?\217?-?\0007\226?\005\264\300]nW\241?\366\004\217~\r\"\250?\'C\243\345\016\326\300?\355\t\260\037\211\243\245?q\231!\241\006P\261?\256\000\350\347\2013\266?\207w\034\r\357&\244\277]|-\236\310$\257\277\265S\257\255\335\326\233?\372<\000}\224\274\270?\310\2606?\020D\306?\275\210\243`=\305\232?\315\273\017}\361\273\253?\271\226\025\354:@\265\277\206\302\325\"4\026\207\277\335\310eD\236\326\214?\022\257\242\217\377w\232\277\376\004f\365\266^\252?S\350\337\340\327\001\267?N\363\231\321\256#\210\277\360x\212\257\360u\267?I\327\354_\007~\263\277G^\363`\254\023\260\277\354Q\264~A\242\263?\0373\243\264Kg\262?Sx`Q|&\275\277\317\241\325oFU\277\277\246e\n\362\373Q\305?\263\016Zw\337\037\247?\301#\361\023\263\004\231?\310\t\177vP\020\266\277\276o\022\234\267#\235?j0\035}\323l\274?\245\204kzj\213\260?\037P5\266\271?\261?e\232\342\002qb\232\277T\215&\204\350\260\250\277\262&\354\337\361\342\244?\025\344\343p\351\330\220\277\022\235\245awB\250?\\\243\276\352\256\002\242\277F\353\242\352~\317\260?\235\356\237\311q\365z?\251\0338L\356\247\307?\226T\252\032\352\013\270\277\362Xa\016\007\307\250\277\356)\237R\336\222\261?6\203g\177\357\270\302?\321\261\240\350\300;\255\277BU\206\036\007\336\263?\314\002\227\032\372s\244?4\026I\277\251\225\241?\352jp\317\342\201\267?M[\033\324\232\250\241\277\235c\357\026\220\353\263?m\247\010\315\264\346\315?\367\021\251\205\353*\212\277n\031/\311\366)\223?\3338F\303\363\236\264?\210\212OB3\265\260?\240qX\270\010\335\247\277\314\312D\2444\235\222\277\037\2506%9\322\227?\004\223\t\033\314\356\247?\013\224\366\204[\276\251\277\261\364k\216\375\237\254?\266|:\010\377\244\272?\264\317\003\nLn\262?X\316\010\250`\200\214\277\374\240$\325\nQ\261?\t2]\354\317\250\246\277\025\246\\,\013\343\202?\202\325\257\\\023\227\245?\366\270%\206(X\300?\335\275M\315\225\314\226?Q~r\253g:\267?\004\244\354N\303b\232?J\306\026\327x\000\241\277\207\001[\024r\341\262?\316\363\370\036\205\001\261?\241\244=\\B\003\246?[\037\377{\256\357\231\277\355A\343\311\224s\252?\267R\373[>b\264?\210\342\2325\333\247\222?\277\177\313\301t\324\230?\2728\020\036LQ\265?\363J\'\337\330\220u?\010\341\261P\201\310\251?\354S7\231\227\340\240?\335U\0056+\216\250?\330O\r\010\303C\207\277\340\214\313\252\321p\270?\037w\232\302\234\247\224?~#:G,\354\225?\032\302\265k\007\362\302\277*\025\276\220{!\260\277zP\315\233d\343\243\277\316\225m\"SF\271\277 L\244\300\245\305\244?\207\256g\237\321T\205?\233\002\313\333FN\203\277 _\330\252\024\323\233?\362+Qd\347[\242?\223\375\221\031\000\010\263?O\271do\222b\232\277\032\260\327\315\301{\240?\243\025J\376B6\300?\016?|r\3755\236\277\033*\211r\020\252\235\277\222K~\233\366{N\277\224\3649\352\225\233\226\277\221\356Cl\307x\250\277\346\231\345\322d\336\252\277\261\206j\330\271\341\231?\323F\"\241\365\322\260?\310\332\372\221\264\370\271\277L\371\0326\243\361\274?\204g-L\306\346S\277\301\223\314\267\253\217\211\277\231t\024\350\313\313\222?\257\217\025\\\252\034\260?v\247\210\256k1\202\277^\215f\231\212\310\240?t\033l\247\314,\242?0\254W\325\326\245\256\277\244\265\361j\271\253\032\2774u$I\245E\247?\255~_L\233a\201\277\025\333\265bX@\271\277\221\316\246le\223\253\277\312\320\240\257M%\274\277\376\324\215\326\266Q\206?\3460\221\201\355\262\242\277\016\005-w,\217\225?J\t\305\005V3\220?\004$\250\275\321]\255\277\036\233\351*\330\372\303\277\311\006\327\206\345/\260\277\3412kE\320\212n?\323\354\001\257p.\255\277-_\256\366\002\372\256?\263\027\326<\222;k\277T\273\n5\302\026\222\277\331t\335\032\266\342\245\2778\273\305\323\334o\252?\030\031b\017C\036\273?l\3744\177\203\336\223\277\254\300\303\236\240\366\242?2\"\200\314\207$\264?\346\320\307D^\350\222\277[\254P\016\376\212\275\277\345\244V\305c\032\246?T\013mR\372\251\256\277\237\323\3102\332\263\250?\336\002\306<\223b\275?\273\305\315y\244[\205?Dw\017\312\2662\235\277|\305M\347\251\000\242\277\035S\317\214\001^Q?\276\255q\363\357\265\244\277\217\236x\231y[i?E#\005\276\246\261\241?@\2600\nky\207\277V\273V\273\251\242\250\277\034\207\031rr\312\241\277\254\324\301\227\004\267\207\277B\325\014\242\020\030\272\277\206O\016\363\331^\255\277\353\276\010\263\r\377\240\277\344\022nz\227\272\265\277\212\363\023\234\022\t\310\277\332\221\274\323\013R\203\277\310\251\374\'\313\347\305\277B\313\027\257\020\341\267\277\017u\343\234\210\260\302\277\004\263\272\273If\275\277\322\265/<\342\335\313\277Ft\211\276A@\263\277X0\217\307\271\317\266\277\365R\021\031\270M\260\277\306\350\005\273\334\375\260\277v\204\357\360\177\317\277\277\223sn>\353\376\237?{\006l\370\3426\253\277#\314Y\262\004|\221\277\214x\322\240\023\223\264\277_\222*\016\004\261S\277\037y\222\037\016/e\301\260\277\341\327\014\366\233\324\224\277[\3008\352\230\002\206\277\n\005\221\370rE\265?5sN\325\311}\204\277\227\334\343\006v?\203\277u\246\321\375\\\344R?\"\206\032?\333\303\240?\333s\375(K\247\242?\013\340EN\343\377\236?\0218\273\024Y\002\271?\274\2503[\003\311\240\277g;\213\337\250m\265?\022\226$\004\232\320\207?\277\270\311\261\272+\260?\211\241\344\017lO\253?D\222\345\231\003Qw?\010ZV\237\303\271\243\277\354\223cS=(\240\277\314~\001d\316Z\257\277\025\300\370uQ\247\304?7\'\020l\221Q\246?\302\262\355\271\326u\252?G!\242vx\205\303?\377\362(\224\377\302\271?\327\033\\\270\340\365\265?\021\335\301\367c\317\271?\335\221E1\307\255e\277\225+;A\201I\264?7\305gI,\250\261?\351\241\351;\325\240\271?\315\343\324\342 V\212?\252\374\213\263g\256\277?~\034\353\364k\223\260?\021\376:\237\301\205\270?\365\365D\313n@\253\277\261\213\26744\263\276?\251\314<\227\242\321\273?\212\323\233}\025^\262?w2\320\334\035\036\264?\316F\247\t\241\201\262?\316\005]\3105b\240\277\377=\320.\006v\252?\2778\226k\016\242\260?x\266/\243\322\342\263?\355\2340\267\302\277\317s\365*\312-\301\277\354\310\332\373\024\036\250\277\313U\222E\315\023\275\277\310\252B\214\363X\246\277\331\361)\3202$\242\277\000\253\035\311\031\372\245\277\217\002\336YnE\224\277\201\202`\331\261\014\302?=\254\235\225\303@\230?\3021H\220\340\021\262\277!>\237\341\317\221\243\277\024\220\357\343(\327\240\277\332S9a%O\247?\256aV\252\240\244\263\277yU\300\277 y\265\277Oj\306\344\240\330\220?\231!y\'K\033\204\277J5\302jO\303\244?h\354\343G\366e\225\277\030\345\026%fu\272\277\024\252;\362\331r\241\2771\375\206\322s\032\201\277b\372]/m\306\243?\326I8\222\366\n\255\277\374\324\36380\320\250?z\211\373\247\270\027\220\277%1\022\347\234\267\257?/\026C\362\267}\216\277\305\031f}?\300\300\277;]\364E\256$\300?*f\306Q\262\242\277?\005A\231G\262\233\275\277\240\017\320\200\230h\265\277\232\033g\355z/\300?&\370bg\365\037\247\277J6\021_\215\331\250\277\250\327\200\260\356\275\266?\000\303L^W\205\203?\216\301\2264\323R\257\277\245\311\206\2703\244\244?\357\230\002q\374(`\277\351%\301#\300s\274\277W\236v@\002\017\263\277/ \261\367\235\215\305?T*\005\252\241\n\264\277\022\276\317p\370\330\272?\212\374\272\331\326\217\273\277J\245\277\206\215\220\252?dDJ(e\254\233?-p\347C\342\252\230?\274\035\337\356\352\364s?[\261\232H\310\344\241?1TPD\t\347\255?0*=\234V\265\262?\026\')(.y\226?\344cp~p\346\252?c\2213\370u\016\251?\304#\304\321E\207\272\277\036yQ\234\342Z\247?s\340q\317_\314\260\277\345\314r$\217\220\262\277\ra\254\027\r\005\302\277\353\036\217}\2025\270?\350\262s\005X\201\303\2770\221\337\272\027\020\256?#\017x\255\345\000\222\277\371\362p\370\003\271\263?\006\0355\312?\350\255?\\\312Mn\303*\242?h\303\353\306\205\"\250\277\262\204\033+@V\200?m\207n\271oG\243?\207\230\223\213\337c\235?7\331\006H4a\220?\252\254\030\020\247\365\246\277\r\205\312\032\315#\202\277\375&\254K8(\253?\325\177i\222?\002\265\277J\010\310\021\t\213\264?1\377\332\231\003G\257?s\263!\200\223\224\265\277\257$\267H\\\251\300?\315\236B\022x\211\223?\304\020\335\024\377\342u?e\031;\236k\037\225\277\221\" r\021^\206?\317\315ZS\256\237v\277&1\r%\222\025\263\277\233y\316\303\014>x?q\311\244\301\230g\264\277+\240\2728\324:\254\277z\n\027V\236$\302?\346H\302\266\371\003\245?\370\036\276\221\340f\204\2776! \307t\334\275?\220\260\232\237A\004\245?\376\303I\030db\267\277\345\342\324\315\217S\311\277U\217\331\000a\273z?@k\251\245\215\211\301\277\302\322\313\212\323\302\246\277\242\365\325\327\216\316\243\277\210\321\301n\253U\256?\306k\362\334\033m\251\277\304\376\247\324\202]|\277g\000\355\0331\225\231\277\332\251\005Y\232\377\227?\341\211\013\372_\247\267\277\216\266\200\264\022r\276\277zg\361BW\314\235?\027R\277\372\230*\254?\020`\256e\370\233\265\277 \020\177\2524\001\241\277\346\0351H\237\225\305\277\324\'\n\331o\323\224?\350@\270\350\024\361\241?\010\303\033_\370\203\303\277\303~{\271\263V\253\277\203\230\322\331}\255\261\277\367>\260\265s\022\300\277n\341(lC\365\220\277^\367\256\212Z\017\247?T7m\346OE\270?#-\204\3427\230\244\277cf\344\200\273\311\307\277p\323\034\233\252H\236?XU\000\376\376\217\242\277?\035\357\312\022\021\247?\n(\244m\270\256\243\277\245v\237p\200\340\273?\253$\367\247\352n\220\277t\273zb]\311\204\277\316A\316\244L\302\270\277G\214\3035Q\203r\277\023\322\233A@[\204?\000\251\346\355o#\242?m&;\t\n\337\217?\021\333\203\026\270\374\275\277\010:\223\257\245\253\202?\003\020\355^i\203\240\277\217\241k\002O|\266?\001X\300\330\252\325\265\277\250-\356\205\362y\300\277\313\004L\204a\230w\2772mJn\217\026\305\277\312\211\346=\036\313\263\277\271\274\271Jn\350\300?*B\230\264\203\224\263?7DY\355)\212\221\277\372 A\240\362\372^?\212m\205\304\254\001\256?\356\026\366j2\337\253\2778\311\362\212\nW\252\2777J\353M\000l\243\277\033]?\032\034\022\221?\\\374+\311\211\336\265\277\302w\025F\315K\207?\272\217\307p\220\310\307\277\374\031*J\204\251\177\277m\236\3563zC\311?S\216\001\207\373\271\300\277BJ\207\037\326\246\300\277+\377[\320\313\027\300?N\217.\270V\273\275\277\307\255\214\331\345\\\225?R\314\316Vk\206\255?\231\2709\376\357\252=?\250\350\333)}\367\255?T,Zz\220J\260\277\2346\310\252De\270\277\364\017\010%\220\374\217?D\035\370\345\340\323\270\277\230\010:\301\347\214\267\277\351\317\374\314\226\277*\366\250o\302\372\234\277\014QK\254W\331\261?\304\376+\236\023\313\263\277\271b\350\032s\257\225\277g\244s:h?R\003\202/j\366\275?(r\242\3575\311\255\277-\221\241\354\335]\207?\315O\303\301\256\021~\277\274\320\322\346\313h\253\277\036}\335`X\262\265\277\326\307\321\nM\225\225\277>\311~\007\264]d?\316Q\345\005\357\211\272\277\312\262\216y\366\321\257\277\231\n\375B\014%\275?!\006\317\245\310\303\252?\304\275mI\223\004\312\277\260\262\006\312y\361\243?\201\013\225V\336\253\223\277\322Q\3677\350fm\277\370l\314\033C\000\225?7\3538\271\t\227\273\277/\236\000\313#\r\276\277\260\344\'}\237\261\262\277e\372V\344\222T\242\277\201\t\'d\213\313\231?\347\265\310\273\314v\273\277o\271YxB\032\235\277\030\345\214\362\360\352~\2770\'\220\332\274\203\272\277\034\332\213\206\022s\215?\213i\221\"+{\236\277?9c\365cg\266\277hY\2774p\342\203\277g\241\017<\001Y\261?\014\337\306\255\024\304\266?\361`-\244(\220\252?=ar\346\256\210q\277\270\030\267\304\\!\273\277RM\020Q\255$\240\277H\267Z\226\312\210\262\277\220\031\364aS{\254\277\013\271\372:\303\250\200\277\224\027#\336$\246\220?\311q\357X\240\022\204\277\003\323\232\202|L\262\2772\2642\242\345Q\244?\3549\177\235\242K\261?\027\327~h\231\022\253?91rh?\336\240?r\213\264\333\217\354\225\277hq\031@4\271\310\277\216\270#&U\375\200?\203\327\221l$\020\265\277\022\31784\014\232\262?;K\322\233Q\020\243\277Z\350QP\223\004\301\277%\310\235\033%\201\244?\243\335\313\312`\332\246?\020\025\205\007\200\340\300?C\355\010\265\272\363\205?j\337\0355\016L\263\277\313GM\374\016\261\264?\230r\241r\275\234z?\352\325\321[\311\037\300?I\201\233Qnl\232?\037\257\346\304\247\214\261\277\005\001\331`\350,`?\264\350}\311\343\327\232\277\305\242\313\370\341\'\262\277[qe0lQ\266?\\\3160\342\256y\262\277\020\035\336&\251\204\253\277\032i\277\336\241\032\253\277H\326\0070\224\240\207\277\225\340\035Q\312\360\270?k\247=\210\270\202w\277X\343<\273\311\360\225\277;\275\262\371X\350\300\277\005P;K\236I\200\277\t\033\010d\252[\243?\221$\212H\254\266\264\277\364e0\352\221\335\240\277u\275\271\013e\237\243?\257\227\242 7\216\220\277\350`vC\307\r\256\277\3534\235\321ET\253\277\353\336\273\302\327A\231?\317_b\'\242\240\301?s7\303\366\375\215\274\277\000\356\345_\275\345\254\277\367y\204V\256\340\205\277\215q \017r\341\301?\212\351h\017\227\221\231?I\006@%\315&\257\277\313\233x \202\256\263?\361\264\t\3654\t\205\277VC\2776\312\226\267?\006\026\266?\206J\301?ufu\037\017[\207?\177\256Vt\210\301?\261\344\314\367\331\315\253\277\357\340\310`\357\356\256?i\217\010\216\341\213\233?]\005\373/&^\222?\352 \342\267\246l\220\277\236\260;\022I)>\277\265\026\302\200\3431\242?\001\326\365mCg\236?h\"\326\210\275\222\241?\346\240\002\016\331t\225\277V,U\024\305\004\230?5\231lM\233\263\236?\322\023\317\272\336I\271?\340\237\235jY\352\262\277r\017\367F\325N\210?\342/\020\365\226/\250?v&l\266\340`\274\277*:u\367\370p\275?\337\227&M\\\342l\277W#\032\335\365}w\277,\373+\327\264\353\260?:,z\n\374\010\301?\017\000\302!\021\223r?\000\237V\312\255\035\237?+\247x\201.\377\227?\343\330\364\241\260\266\246\277A\373\221\303/\016\234\277\220\373\344\000}\226\247\277\022\254l,o\271\247?\006W\326\370Z\267\253\277\371\206C`\227\336m\277l3j\231\373\270\243\2777wc\016\336,x?\374\244\323u\330w\253?qt\300MeF\246\277\313_`k\361\000\265?F\365\205\034\203\244\215?$r!#\275\000\224\277,\267`\331\313\037\210?\212r\255\023E\024\224?\346\304y\200\256\257}\277g\025(?\032C\254\277\016\275\\\tQC\251\277hJ\033\030\321\036\205\277W\002)\307Jk\257\2777\257\022\243\224\211\213\277\237\246x\004\217\313\273?i\372\227\300+\317\264\277s\230\252\033u\322\265?QV\336\350\360\324\217\277\006`\'/rB\245?oX\342\\\351\227\254\277^\350\220\312\034/\263?\312p\361x\315\256\267?\350U\240\306\212\336\273\277\204H\315\t\313\371\217\277\231F@5\253\010\253?j\301\014\212\210\341\271\277,\310\236TCE\262\277\0314\315m\310\344\264?\335H\020\222\333\\\251\277Py\272\n\267\271\276\277\301\231-\362\347\004\223\277\231\265\266mv\000x?\027\204\243\2049\213\271?F\372R\\7\204\304?\347\217_\026\363\300\272?\250l\356\365\005\323\202?{\\\250\275,\007\260?\237\331\230iGT\227?\356.\321\225\345\232\257\277}V\305d/\342\244\277.\340\364\0208E\271\277\363\334|_00\300?\354\177\252\3045\244\302??\004\372\243\240\327\252?\376\247fb\343s\264\2771\276\247Zw\304\300?\363r\306\037Pnd\277,\371\320\373\212w\264?\275\245\213NN\364\261?=K\207v\035L\300\277}N5+\370_)\277\032o1]D\263\270?\206;%\026\354[\221?\312\037L\217A~\273\277\240}=\021\225\253\256?\352\323\204\345G\342\242\277\033|\005\234\204\337\232\277\354nF\317\210\361\273?+\264\324)\031\374\305?\204\216\24715\365\311?\316\230\345\300f\"\276?\343c/5\340\205\266?p0\206\311\006\005\272?\'\277\274^\324\224\247?\337\365\236\241d\335\275\277iw%\374-R\267?zP\2204c\235\243?\345mD\210\277s\270\277\240\007\232J\253n\205\277\013F\241\234\275\265x?\304\330\251\272\3758\254\277NZ\014J\006E\266\277\325zdc#\272\252?\247\3406\306\002m\271?o[\232\372\\\353\261?\227x\225\n\277\373\273?\360\027R?B\307\251?j\206;\326a\312\247\277U4=\240)\212\207\277\230\326\0324u\201\270?\'\364\216\317Aj\233?\'YJ\371G1\234?\232\307.\342e\303\213?6UE\273\363=\303?\262\205@B\242\210\241\277n\366\250p\347@\270\277\276)\267a\375\265O?0\256+\031\246+\265\277`Z\336\240\022E\242\277zB\237|\346T\216?\002\001\t\001\200k\210\277f6\372HDA\224\277j\276\034\270qz\277?\225\361f+\360N\260?\211[\261\037\346\310\257?0\221\330@\306!\270\277\353A\006\210:\010_\277_6=\033&\252\226\277Rb`\307\2420\246\277\364\312y\323\302\217\242?\266\250Z\2475_\251?\377fA\"\014\004{?\356\205\334\204\375\243\273\277\230\206F\t\220\037\214?0\177\004\234QV\210\277\206\267\'C\014m^?\272\023\213;\205\310\260?\230\237\257\344\222)\252?\330p\370/\2475V?I\351\220\017\033\203\227\277(\251\366\"\241a\260\277\306\261\211\251\270\344\255\277Q\226\314\312P\300\223\277\024\030/\376JR\215?U\000*\367H\372u\277\004\321x\346\347\311\221\277aic\240P_\253?\350\223\246\274\306n\251?\342\213\255K\005o\241\277bw\216\232\276S\273?\207\253({\250I\216\2770K\033 @\375\275?\021\213S\343\221\225\245?\376\232\275Q\036tg?\354hAbUi\302?HSz\327S\000\257?\256\024\357\2147\344\301\277\262\310\314\265\274\252\256?\377\004\006\020\260\357\223\277\356\276A\340\375\213\244?n\300\340v\025\331\266?k\313\333|0\001\275?\027\362\352@\321E\270?\325\023d\333\230\264\247\277\034}\345\332Y\301w\277<^\214E\323\323\233\277\217\372\232\330\374\205\257\277\272\366\207\324v\331\301\277\220d\211\373\026\345\220\277(aP\250\213\024\250\277\026w\361\336f\240\263\277\313-\017o\373\220\237?\300\271?E\212\237\236?\'\354\330R\327\013\262?\213\310\326\241\243\245\255?o\372\227\013e\302\247\277V\323Aqr\240\230\277\032\021\265S\327\252\265\277\223\377a\305\n\360\262?N\026\177C\216_\303?(\301Ci\321\276\253?\376\346\374\245\217@\223?\356\363\225\375\234\304z\277jC\361\317\376d\235\277\371\356#\266\003\345\260?\370\023=\260\004\352\227?\354\035\362B\206n\264?H\331\3137\255Q\303\277\027\247\214\031\222 \254?\017F\217\310;K\250?\362`I\007\335\206U\277\325\316\233\300\351U\242\277\0132\311w\364\274\250\277\275\371\306\270\325o\260?\365\320W=\247F\204?\0342\tU\013(\212\277\2727\353C\322G\273\277z\276\341\352\246\270\234\277\342\372\324\350r%\276?k\026p\227A\250\203?\225r\320\274\r\252\216\277\332\035\236\342\006\n\212?\010\373\200\013\342\337\265?\257n\257c\211;\274?\340~\363\325\341\237\216?\006\273\305\244u(\301?\302\365yfV\016[\277\374\246\013\375\322K\257?\201c=\230\2745\265?u\364\204Q\326G\257?v\nQ\374\341\024\264?\236\206\273@\263y\264?\364+|\025^\277\243\277Uc\372T=\322\235?\2752=\004(\010\237\277\t\307%\r\362\330\266\277\277T\027\001\031\246\262?\345>\350\373\237\340\264\277B\360\231E\225(\254\277\027m\201\216\215\274\261\277T\266\014\262\350 \303?G\342\367\375\307$\264\277\336\337\342E\2665j?\311\355\026\322\306\033\270\277\317\265$\237\213\311\254?bMf=A/z?\2314\004\3006\331\232?;\3312\002\366\276\273?\004P\310\364\373\250\263?wW4\317Y\337\236?uq\357\315\243[\264?\252\357\353\204\253\324\300?\226MoI\330+\265?\204\206B\177M\231\302?`\332\356g\215\205\242\277\032\370\375Rb\327\225?m\261\356{\222{\257\2771\004\365\026\300\335\222?_S\253R\001\346\266\277Gr\201\362\000\347\260?\032\326\251~6\211\233?\370\243\364r.\241\271\277\305\374K8\277<\261?\211f\206\030-\272\257??\252\006\006\313\253s?\300\275\320\267\244q\246?\037\240\232\241\372<\220?\343\240\234\250\003A\307?\272A\350\220\236\320\207\277\315\224R\227\365\374\243\277\222\305\017N\350\215\230?\256\234\304\226\215\256\312\277\336\230z\2234e\242?-w\323\2466;\223\277\274*\347\025\026\253\271?\201\245L\224\272\215\213?\032j\252\022Wg\301?\254L9\307n \273\277\232%\247\211\373J\200\277\016\247\312T\267\347\225?yO\361\373\007\016\271?\353!8\022\226x\300\277\340g\333\014D\033k?{C\335\351\365N\240?y\377\375\231e\246G\277n\216\252D\3775\235\2778u\201n~\207\231?\226,p\3608\222\210\277u\376G\304\260\003\265?>M\330\333M~\202?\206\275z\362\330b\215?\003\023A\360St\312?\332l\352\356\354F\204\2775\215\213&e\253\243?\035M\242U\274q\243\277\3718e\177\177\346\244\277W\247\330]\324D\200\277\235\340X\023\355\322\276?\363\370F[E\221\263?n\276\036R\234P\256\277g\314\310\265.\002\267?:\333\r\247\032\270\301?!\261\364\201\356\020\216\277\016!\330\300\241\244\257?\313N\247\261}\256J\277\337\036\323[)bs?\256SA\272\303\304\235\277$\307\270\016\033\235\210?[6\236\223\324\303\232\277_\265\202\036Ak\272?\340n\351\017\006\336w\277\223\001\340E-\'\232\277\256\342t\332\227D\263?-\361\335\350\027_\240\277\022\375q\214t,\306?\"4p\324\257W\246?\237\353\241um*j\277A\005\203x(\200\265\277\221\301\007\375\013G\300?\016F\364~\207u\267?i\026\357\330\301\274\251?\237mE9\347i\314?\021\265\2169\223\023\246\277h\232\276\274\302\263\215?Y\273\343\003>S\266?Y\331@\"e\356\266\277/-\346\366~I\267\277>\237\242y\374g\316?\264\023\020d\212\336d\277\335{\354\016m\351\300\277\025\r\300\277\312K\227?\225\006\226+6\306\301?\031\025\253\270:\317\313?x\006\251\302;\300\260?\031\376z\305q+\232?;\260\240W\361\351\244?\257^Rk\355\210\301?\330=\030\255\017Y\264?W\364\014\314v\343\205\277([gZ!,\244?\333\026\276\323\210\331\262\277\365\355\367\222\375-\262?~j\233\273MB\237?\251\370t`\364\246|\277\001\203\3767\014\367\267\277k!\260\250\030|\253?i\314\177<\0235\220?\377\373\036\327\216\205\302?`\260\200\273:\340\265\277\010\260\016\370\230Z\265\277=\252\327\312\365\320s\277\373\232\221\363\261\001\273?\232mAQK`\302\277\330\202U\206B\260\260?\245\200\375\347?\303\236?\211\240\311k\212r\273\277\241\243F\334\264\224\250\277\207;\3569\030\205o?\'\320W\376c\275\247?\025&\271\255\205\034\274?^\372\350\317c\377\256\2773\344\3368\232\035i\277\203\235\310\\,\275\201?\301x\ntq\247\272\277gk_\353\213\003\306\277\037\370F\323\3634\242\277\002>\227z2\020\223\277t\213\032\203\277\210\271\277X6\n\374\255/\307\277c\332i>\317O\266\277\342\267WhC\312\274\277\364W\021\242N\327\302\277\340\262nr\t\321\267\277A\224w\217BeX\277\004X\362\205\372\342}?\222\305\254(\3368\260?\027\332\274\206=\231\252\277\372>gx\375(\260\277\025Q\2666\'\314\260?\253\245h\305\237\200q?n\n\201\351]$\223\277a\327\2235\314M\224?@SP\036r\372\262?\242\330\201\"it\300?9\247\342\257\320X\233?\303\262\327\267\"\372\177\277\037Z\363\374*\206\245\277_\262\307[\242\361\202?G\031\200\"\010?\241?\212f\200@M*\277\277\355n8\020\031a\247?7.\303?\355D\220?\221\232\352B\306~\222?6\310\257s\246\017\232?7\030d\3414\024\264?\304\225\2425k<\265?\177\014\006R\341\365\251?\352\033M\256\245x\217?%Q!\357\203d\234\277\246_\201\343\254%\271\277\236k\314,o\004\265\277RP\356\235\345\300\256\277C\313\343+\275\262\274\277\223\350\320\257\"\203\240\277\002\332o\000m~\204\277\240\243\277;4\343P\214#\262\277G,\354\230LK\244?\3700\242}G\013S?\233,\312\320\234\013\276\2774\313V%$w\272\277\017\006G\322\003\003\300?\254\010pO\373+\275?\025\r\372C\311\004\201?\212\"o5\347\372\232\277T=\316\300N\232Y?N=\223\210\204\247\262\277\337\322Ju/\266\246\277H\202,\'V\237\222?QPv\003\313\241\245?;\266e$\3676\247\277h\002\031\036\321\354\233?~%3\244\347\326\242\277\3059Tc\353\251\263\277\034o\017\357\310\223F?\261\002p\013tD\300?b&\317\202\370V\234\277\267}D\213\376d\225\277\025v\376\006@VT\277E\372\303\300\253\235\305\277\316\360\354\223\303M\266?\223\251m\007=\263\307\277\333\204c[\357\036\257\277\013\204G\000.\243\242\277\301\250D~[\370\220?&\335\245\231\321\000\243\277\255a\250a\331w\243?\316\0377\033!.\202\277\314\311Qzfrr\277I\375\235E\206\322\250\277vU`\257#\t\260?+J1\233\314o\241?\0035\255\'\273\226\203\277\351\2322\017\225\270\236?]\275\262\033l)\302?\252\311\332\275\313J\264?\300\365\327#\031\317\222?\216/\307\225n\031\302?\021\030\321\336\267\257\214\277\234\t\372\355\367\356\270?0\343\204\013\234E\244\277\363Y\037V\004\030\213?-4\251\230\267\361\260\277[\342 \257\246\316\304?\347V\222m*\252\247?\366\225\375\217\222e\251\277\271\247\347\207\210\315\230?\272\265\261\020\240\312\264?\\\216F\255\002~\252?\201p\343\344\177\033\243\277I\242\216\220W\221~\277\365h\367\225\\^\302?\'\304\014l\226\256`?\030\243jNy\032\302?I\333\225?\240\242d\277o\251\212D;\200\261\277.\027+\325\371\025\262?m\337\202pH\324~?[\033&rd\n\266?\306\354WT\204\343\270\277\004\241\377\342+\246\224?8\231;o\2219\222?\305\366v0F\216\215?^\275(\032\0270o?d\324\327\314L\236\223\277\204\005we\014o\302\277\357\253\264\372Q\\q?\212\340\223\300\320\231\255?W\244H\370\276\321\222?\026q\245:\341\357\202\277\341a]{~\243\254?\312/?\222G\210\241?\321\271DZ?\005\231?1`\004\323\n\240\223?v@\215o \000\267?\362\355\"\236\256\263\276?\210\300(=\316\274\213?\353k\210\r\252$\261?\207\362H\260\255\371\277?p\036\241r\\\353_\277\2657+\271 \321\253?@\364\034\004\271o\305?\214\r\377\324-\001\253?\304\270B|\007\235g\277e\261G\023\270\255\261?\272\2705\273\343Q\262?\235\360\250\346\213\326\276\277\331\217\031S.\346\301?t\326\274\0131I[?\312\322\203\347b\032\260\277\244\023+\352\023o\260?*\177\321\006:N\240\277\254\273\323(\321b\252?\036\r\3533j\374\263?\006\264\340\215s\032\257?\223\341i1\210dr\277\207\324\030ll\336\260\277\204\026\017\037\201a\202\277\021\"\277\317\025\271\311?f\202\356\225\326\225\301?@nT{izM\277\205\311\333\340\026\350\226\277\025:\033T\311\001\275?\264\343]\364\303\314\240?/%:]\204I\252?\n\367_o\262\244\200\277\352\020\004i\351\246\271?=T(*\034\t\246\277\023\263\277\361M\001\274?\321\303\331b\317\363\245\277\322\272\177zy.\265\277\034\376c@\252\332\264?X\014`\323\324D\303?UYg<\235\357X\277j\"1?\276\254\265\277\223\254<,\235X\271?~x@w\325\207r?v\376\312\331\353c\270?\340\177\360\223(\"\241?\334\236\337\214\306\260\250?q\307_\375,\306\262?\330ER\356L\270\302?\334O)8\247q\261?\334?=\246;)\225?\321\017\"^\257\216\201\277\260\001\307o\361\177\264?]?\001\306`\"\265?\036\2626\224\376t\235\277\275\227Vl<\341\253?;@(\373\344X\277?VK\252\214\345\313\226\277*\214\360b6\013\305?\312+\2265\033\213\231\277\002Tk\341QD\250?\373,\232\352\231;\244?\321\244\247\231\300%\256?jQO{eoa\277\353\200z\210B#\227?8L\273\364\345+\245?w\231N\307\260q\261?\325\230\344\327\031H\263?j\274/\206\213v\255?\236J\361X\020H\273?MZ\222\247WB\305?\222\333q\211a\260\226\277H\327o\346:,\233?\035\010\326\250\256\202\257?\231\206J\213\2438\252\277\322\026>\024D\350\275\277\321\300;\214\303\313q\277\325j?\373R9\243?V^\264\241(\310\262\277sMD^\023\207\254\277\375<\324\206J\026\251?\376@|9\352\003\260\277V]\302Q\3744R?\361\260L\346\225\272\264?\307\276pr\"K\257?5Xsq\306U\267?\026\24557\330;g?\317\022\272Rci\272?am\315\267\326\022\227\277\234\030\t\245\"\t\315?\220\007r\202\241\252\302?\375C=\234\2207\311?-\030\2071\3524\227?X [&\232\250\261\277\301\255\3731\336W\300?\201\020\305\341:\034\270?v\202\246\340\003W\260\277\007Sf~\266\236\213\277fZh\013\305\237\304\277\355\326Y\261\242%\231\277\254r\370t\245\211\207\277jY\364\026\356&\227?R\301D|\242\364\267?7\266\252%\314\r\266?\020}\344\370\363\262\200?n\354U\336\020\241\271? y7\016\323\232\246\277\352c\373F\263d\267?/lB&\377\034\246\277\324\352V\252B\317\262\277\036d\231R\310\216\270\277\352\251\316\321\351\'\263?\032uRa\254\325\261\277\034}\356\244d\355\231\277sB\371\2574\205\267?\315\345\234\262\346\200\206?4\002?\257\006\257\236\277\342\270\336\203\020\"\247?\352{\235}\3203\301?\244\272\325\371\033\257\265\277)?\220\033\302K\312?y\251\346\324m\205\200\277\'\321\354\252\tb\275?n\223\350\365\320)\246\277\225\367\305\351\3723f\277\234c-k\346\357\262?\253\222\377\371 \270\232\277y\231kz\370\263s?\204\"\037Z\342\263\242?\363|\350\205\366\263\220?$11\363\234:\265?\010\317\225\006\340c}?\352\371\002\365\360]\300?4\342\215\251\014Y\243?\327\257p\354;\232\263?@d(\255\231\314\302?qW\327\017:\214\253\277\001-\257q-\367\272\277s\210\344\250\204\270\264?6;<\2777\303\303\2776\n\242@[G\221?@\261\017]\304\237\246?\262\352\n\312\030\214\262?\260g\246g\024\350\300?\366f*9\373m\263\277!\353\316\274\202\016\307\277*\242\2119|\363\202\277\245\255\020\311\302\252\243\277\371\255\224\236\2270\273\277\222\365\326~\245:\211?R\234\332\257<\001\263\277\'\266x\374\366\000\204\2773\240\3204r\353\233?<>\037\310\336\241\320?\304\302o\003\310\205\231?\326\r\005\324\325\325\246\277d\227$R\362l\226\277\344\211)r\0309\254\277\245N\331\272\352L\260?\263\371\224\36169\272\277\3454\222+\324\\\266?,\335WH>\017\246?\316\241\263\273\321\035a?\204{w\207\246E\232? \213\007\222S\007\221?\244g#\004\317U\251?\324Jr\330R%\301\277E\213\010Y7w\242? \362\341\364$\372\237\277r/&_7\202\263\277\250\257!\233\003a\300?O\330j\024\306\341\243\277`\353\037\027\333\030\241\277B2ER\375\312\272\277-\306\207\252\027\031\265?\335\347y\314\321Z\247?\3569\322\221/-\240?\354\020\025R\002\366\226?\\\374\351\362E\332\252?\360\316\367\346!M\302\277f\207\365\014\223Oy?\225\r\205\375\276\371\300?\316\301\270-\031\277\213?b\373\"U\202!\254?\245\224Ib\304\363\275\277\001\255\346\261R\356\251\277\310\203\363}\333n\235?\201\305\035\023\330\006\273?y\177\377\022\253\302\225\277)\024\333P\006\223\217\277\271hg\266\244\025r\277\215JZL\204\362\264?M\300\307\265\305q\222?kx\301E\222\241\226?2XS\301\366\355\264?\315\376\310\212R\026\254\277\034\'\004\245\342\200\246?\360\320\224\202^\026\256\277\t\323\252\304cm\270?!|\375\001\235\346\267?*\350\210P?\017\263?d\372:o\314.\303\277\000~b\334_\230\263?\271\"\231\317o\"\265?\213\006ci_\252\224\277px5\353#\212\273\277XIan\312M\271\2773\246\0343\005=\276\277\270\315i\342\254Q\235\277\301\247\355\325!\351\237\277@n\'\370#D\263?\3401\373\267\036\207\303\277\343K\324\010\335\364\273\277Z;_\306 e}?\363H\251Vc*\216\277\3316\037\360\252\232\245\277V\227\2204\214w\245\277\324Z\023\250)?\213?2\367\362\251{5\207?!\216\261*\207|\241?z^\256F\026\335\242\277\034.x\016\324\241\215\277\014\355\241\350\007\314\203\277\310\274\002\212\'\277}?\'\013\007\007\373\235\232\277*.\341&\034\247\215?\327\300\002\333D\017\245\277a%\362\354/E\301?\253\217\'[\227\202\244\277\333.\364\270\003[\232\277\245\357\237>\224\273@\263\277\346\372\2417>c\252?\335R\206H$\030\247?\300\200u\354\272\262\240?P\314Rm\327\373\233\277Q\021G\231r{\270?\323\206\335\035\215K\233\277s$\207^\036\220r\277\315W\353X|D\225?\222=\243\244%\021\264?\037Wx}\341x\256\277Z\345y\243\266E\254\277f\247\024\366|\325\221?H\265\372\230\335`\270?t6,\263\375\010\232\277\003\216\372?\005\263\265?\356\377U\211X\272\221\277\247oK\302\001\023\256\277Xg}\333\n\331\240\277t\231;;\250\310U\277$1\030\237\203\355\271\277_\267\024am0\277\277V@\370=\220\306\230?bP\324\364\207I\301?\321\034\330 \307\352\252?\016\027 \206\335c\201\277\372\334\024\252\330\343\257\277\320\'WRr\362\253?\002m\227ky3\225?\216\224\216\270\342\315\272?\014\023\016pj\271\254\277U6\025\016s.\203?t\327\343\224L\307\255\277\333\214\275\037\004\002\231\277\216\016`\272\311\215\300\277\t\360\203E\237&\242\277M\014\260H\300}\247?\316f\177=\'\247\255?\022\207\337n! \277?\337\337\002\317/\343k\277\324\326\373\2761}m?\237\3214,\276\265j?E9\230\333x\275\225\277\274\'\306b\342A\222\277\036~\276\341\334\203\261\277\240FP\377\017\277\222\277\232\246iv\365\300\220\277?r\277\034\260\364\215\277\357\257y\273\237\300\250\277\342Q\323\210\246\350\214\277\337D\327d;\317\241?Z\331\005\0238\273\267\277\t\247\261\341\373B\204\277\267Q\364p\321}\245?\333<\022\307eI\253\277o\223\241)]\256\254\277\330\312\322\264n:f\277\035l\214},!\242\277\3431|\366\223F\277?\010g\324,\204s\272\277I\240\246\032O\326\256\277\206T\267\317\332\263\255\277oJ\034~\204\321\267\277\213Ul%\266]\261\277-^\n\304*\237\300?\020W\374z\322\351\262\277\217\030x\207\244\321{?\211e\220w\222\341\273\277Q\214\354\364j\301\270\277\374\316\355\024_\221u?`m\253\031\025\352\260\277,5\235\017 \201\207?\000U\372\227\022\237\221\277l\177\256\032\347\364\242\277\315\\8=\010\026\272\277^\224\301\243\363\026Q?\262K\325;\214\265\220?c\236\270\310e\263\241?\327\034\300\237\324\317\267\277\021Q!}\257\325\245\277\376\313\351\177)4\263?\021\217\2458\236\226\274\277%\225\010\013w\232\261?\027\374\240z\355y\253?\257\327dU\377\214\242?acE4<\264\270?\347\305u$\032|\230\277x\321\177\320\230:\313\277||\201x\255|\274\277\313:R\306J6\261\277\014\307\306\200\252,\215\277\000%\274\353p\231\257?\033G\335\004\013O\262?\270&T\312\202\010\212\277\324W\237\267SR\242\277\375J\030\276_\241\304?\256\256\274\036A\217h?2\224I\003R\321\304\277\212\231\010\306H\351\247\277\267w\034n\336\370\246?h\316v\340\265\317\212?\r\267S\020b\025\304\277\373`\013\330Z~\250?\005c\207&\\\351\271?\214\023\372($\"\261?d\223\247\231\362\036\256?\n\314Do\260?\263\277\007\355$\'\'\350\263?q\2245D\214/\275?\'\006\273\317\206a\206\277[\217\327\340p\324\260\277\0220\255(t\320\236\277\370YO\003Q6\261\277\276\t\330\016\361\235\227\277\250\214\340$PV\265?\201o\372\374l\321\243?\252\036n54D\272?\365C%\237\032%\264\2777\206\242jH\323\207\277\372\245%\266\325\004\263\277`\336\004+\006\203\262?\340\306u\036\247\037\246\277\036\343\021L \302\233\277O\014\037\t\325\334\260?1)j%8q\305\277 \204\211.Vfp\277\020\004?gB\372\250\277\321\330[\03512\242?\010%\275\245\022\254\301\277\322\366\311G\322`\254\277\223\345\305\033\351:\221\277\017\311\202\330h\344\244\277\273\325\372\000\262\354\222\277\034i\337E\037c\243?\205\215\267<\300\210\271\277\2068\357\222\272m\240?\237\216\255\277\206\036\234\277\373\263\264\260\2339\266?\336\343]3\311J\262\277\251\363\337\3236\337\255\277,7\244l\256r\247\277\351\204\204yBK\260\277Qf6;5\003\264\277\002j\364g\004\357\267?\214\307}l\217C\234\277\340cd\236\226a\245?\320s\034V\323~\251\277\356\331\251O?\240\303\277d\225\2337C\264\251?\025\301K\037s%\245\277@\247\305\203\220\216\301\277)\305&\321[E\233\277Z\345\267\232\270\253\261\277\241\263\255\345\255Y\270\277J\305\275\230\305>\254\277\305\206{\344\352\277\304\277\323W\036i\004C\220\277\336\206r\247\360K\236\277nz\262\027\242\337\256?\366\246.\003\231b\256?\223\3227#\225\342\224?Gj\\\214\360f\236\277\245\346\277\033\275\206\254\277\224ycQt\331\220\277*S\224\026\245}\262\277`\371U\350-\232\217\277L\025\035\\\257\"\264?zw\2332\332k\214\277\336)\204d\202;\231\277f\257\035\340\264K\313?\177\316\260\222\302]\267?\242\363\035\177\376\206\302\277\341\3371\031\005\270\255?\026\307\036\313\337-\242\277\272\314^\314\ra\260\277\354U\353\222\242;\270\277\321]!\341\227\263\273\277U\365j\210\2668\301\277\204\202Q\374\321\214f\277\027\370\002w\251c\253\277Y\365md\307\310\265\277X(A\247#_\301\277\374\315\023\203\016\245\260\277Y\216Oo\243\314\246?LC\311\270\207\033\245\277p\216@\371\027(\270\277\0052\3521\357Bs?\314h\266\014\365\310\242\277\355S\370\216Ge\244?\214C\243\330|e\263\277@\247\222\340\2474\260?~\033%RW\246\257\277\201*\213E\352\252r\277R\177\024>\360\031\252?N\3329\271\002\323\206?\341\372k\342\021 \241\277\274\027\n{\302R\263\277\344\217m\235\331\250\304\277\235[\312[\3421~?\267`j\r\251\232\264?)b\260S\355\201\273?\347\177\332\300\330\236\206\277nZ\340\002\271f\277\277*\340\313\'m[\223?m\003H\360wY\226?\337\206\217\001B\031\256?\000|\373\361E\234\253?\3521\312\002\253\005\226?\016\345\253\267\002\023\224?\006{!N\215\271\262\277D\305\265|[\024\246?\237/\rP,\271\262?\304\333\202\025K$\274\277\300\212*\021|\332\264?\034\335\203\373.\364\247?\366\370\005!\354\014\211\277\212\026|\251!\221\307\277\203h\ru\274\025\207\277\364gdH\371\010\304?\033\347\005Q\030\026\303\277\037[x,=\215\264\277\300\265h\004=\350\253\277\000Q-P\357r\225\277\265\016\360r\260\364\305\277sT|\341C\037\246\277\224\220\344:\355D\212\277\351\017J\030\350\242\252\277\324\207\366\367\366\211\271?\301\351\353\024hM\256?\242L\347\002\306\245\262\277fT,\242\t \303\2774kU-\346[\212\277J\317\270mq\323~\277N]\341\236\312:\205?r\234\225\211\227(\262?\231\030\371\347B\013\314\277\0078\243\\\275\234z?\031u\201\\\312\312\271?\373\007h\036W/\203\277D\216\353\344\212\022\261\277\322\0366\212\370\227\262?\300\225\260\217h7\256\277nAj\213gO\245?\023\330\020|\327A\221\277\356\261x\335\375R\230?\267\216;\"\177y\246\277\374H\223\3424\212\240\277\237\236\357\202\350\330\310\277F\302\000\355oK\217\277kP\306j\363%\261?\335\312E\032\333a\212\277N/\322\001\002\327\247\277\301\342\205\302_q\304?\t_\317\227\371\207\251?gj\274*\226\322\202\277\037\333\332\321\303|\266?\224r\221\0313\030\303?\311\033\014_\346\300\231\277b\347\277\345\347\347\241?\254i\r\252\312\266\300?y\221\300\305v\205\260?\256]N\370P\200\232\277-\037<\027~\315\257\277A\017\311\t\214\234\005\245?\350|\356[\033|\313\277\021\261\330\343\302Y\250\277v\010\240=_{\203?\031\236\016\001\367A\240\277}R\247\310\355M\266\277\242b\024\334l\005\307?\222\325j\022\317\302\253?\331\333\242S@5\305?\215\334\r\014?\021\253\277\374P\225L\264\376\260\277\006\351\2132\024\226z?\365\201w\r\027V\264?7\231\317>x%\234\277\327\002\037p\367!\276\277\230-2\220Xb\246\277\351W\202Sdh\224?[\233\221\320N\037\274?\003\274\1774\317E\264\277\220\226\205\226~\222\261?\256\363\306\313\345\304\234?D\234\023\030\350\305\266?\317\367\322F\321\220\266\277D\333\243\267\277\033\232\343t\336jv?\365u\256E\027L\257?\2452-\240\227\252\260\277J\237\027\217\320\323y\277Y\035\211\344o\350\305\277\205\030\205\t\003\021\305\277j\363L\324V[\250\277?\321L\250\300\034\251\277\025P\323\220\354\254?i\000\200\0366g\227?\227?\301k\022X\271\277\332_\365K\227\304\251?\301\212\335\025\031\352\234?\377@\231[\224\342\260\277\023\347\216u\256\260\251\277Zn\227\006r/\306?3>\030kF2\264\277\034\361\21481}\201?\333\177[,\022\221\240?W\261KU\366\327x?s\032$\376|\315\227?\033\367\025\320\037\211\302\277\337\340|s\034\312\221?\010\253\305\032\361\264\227?@b=E\353\242Q?\335\270\022\234\366D\234\277\313w\032$bN\260\277\214u[\024\003\244\226\277\323\310l\257\227G\223\277Uh\260\200\240\221j\277g\250vb\263\371??\344\267$K\356ir\277\316\233\370\333K\212\241?\0036h\236\225\236\252?\3478\035\362\025v\240?\2571$$R\000\267?\221-<\251F\n\200?DN\267\256\207_\233?\202\255oP\024\311\267\277\227\016\344v_o\251\277\037\221I\357\377\204\230?\344n\327\203R\'\223\277\0363sk&e\242\277E\276=\361+,\226\277\352\270k{|\305\265\277\277E~\355h\035\231?\264\265 S\254\035\236?\251nU\005/\206}?\203\322\031\253X\034\250?\255uR\n\335\371\206?\235\230\315\304\355\032\262\277\336\245\247%\n\307\311?`\304\004\244\325\304\250?4\254V\364\310\253\267?hF\254\"H\202\264\277\306\323\216\233\210?\303\277T\"\001\242\362(\246\277kw\265pC\351\272?\330\316\330\225)\r\231?\364\371\235\"\207\206\243?\242\014\343~\'\356\263?d\200;E\313v\230\277A\337!\356\213u\252\277`\352u\325\'\377\260\277\235\257\345\254`\245\261?\036\013{2\250\353\273?\277\240\323\371\343g\264?T\221Nf\026x\240\277x\3417\342\023\302\266\277\006\251<\210N\364\231?\305\372\354\247\024\023\260\277\036gg\367\3345\235?\363ox\315\270\217\263\277\372\271\032\245\272\201\301?\177\000\354\300\355R\202\277\347\213p\372\010\252\273?J\376OM\374^\256\277Q\246\030\354Ys\260\277c\275\341)9N\241\277c\361\264\373J\240\221?\260\3076E\036^\230?z\221\027.c\211\273?n\250z\204\323kp?j\367\232\\d\235\224?Xb\3646pVe?\305\232\246\026;H\310?\325w\275\316\327\300u?\0220[V\264\346\266?\303\336`\0011\203\247?\023\333\032R\032\\\244?\365@\363\226\245m\235?\227g\212\267\243\002\224?\3259\323[\205%\261?\332\366c\351\232\371\273?\177\373\335\000\263\"\230?\223H\327\001\273\323\263\277?\264\222\214\\ \273\277\007i\333\251\362;\213\277\362\351^\301\342\221j?\337\010\032\251!\254\213?\351\264\371\235\333\304\305?\t\373w\2656\000\271\277@\030\2722\205\236\301?\221\031\262$\3417\230\277\253\301#M[G\240\277Y\304\332\265\016\234\275?\212\210\212\343-\315\260\277\367I;\263\031*\240?\245&\261\306(\344\303?\357B\244\373\300\321\266\277\037\177\245.\201\222\210\277y^\201\212\246o\271?\264\250\035\270q\253V\277\010j\033\033k\255\241\277\351\276\nd\277\033\246\277o\266W\364\272\303\226?\n$\t\337\262\203\236?r8\206\023hU\232\277\r\2423\t\326\013\272?\327\240L!\010T\266?\254\032\037i\3750\210\277)@\330\251\344Q\224\277\035v\353p\371H\252?$\344\231f\243c\245\277\215wP\\\331\246\250\277\016\342\035\r]\340\273?\261\203\372\322sU\275?i\276\361\365\253\274\216\277\027Y\263;\006~\242\277F\336\241LX\347\265?\311_\336\247\215\032\246\277g)L\220\023\261\272?\310\362(\324e\330\267?\207\037\226\014s\275\305\277\026$\243,Li\262?[\037>\366\375\240\272?+2\023\357;\377\245\2779\222\216 q\210\255?`\340\313\037\300\350\232\277\362Z\264\310bA\261\277\355\206\226\207Wg\276?\306\240]\3420\r\260\277\0177kj\177\300a\277\352\316\277\3417<\300?Y<\350\022\'\343\225?9R\254\365H\223\300?\034(I\375\027\023\247?\302\303_B~\021\177?\333\204\263\333t\027\263\2776`\252\277K\031\360\350\375%\240\277\331L\267Nz+\257?wR j\311\210\202?\336\027\374]\324u\300\277WE11\"\234\265?\332\260\035(\014 \202?a\024p|D*\262\277f\2758\031\263\337\261?\312q\230\337\265P\221?%\r@\001\274\266\236\277H-\226\355d]\303?7\310K\241Ey\266?\367\303R\246\303v\220?9\032D\351\013\324\252?\217F\227\357\310\327\261\277E6\203\022\314&\274?\233\202@\'[A\205?\006\213)Z\275N\310?w\220eB\255\333\305?\177%\340\2146\333\221\277\243%*\233aq\264\2773\202\333\216`\343\263?~\234n|\363\224Q\277\034^\030eI&\210?\225\360-\221\307}\030\277\334o\006\002\013\354\267\277\255.\\\010\316\323\230\277bb\216\250<\361\262\277\222[\273\363\331\365\277\277\"\nJG\373\247\226?`t\201&4\271\214?\007\3161 \221\377\265\277.\343\235\033\245\024\257?\\\256g\325\265\360\232?\240\020\224}QI\230\277\227\357;\275\027t\253?\001\2244\227vx\252\277\370H\022\"\340_\303?X\017Z\371\241S\267\277cF\257ez\027\255?+\223\363\004\310\231\273\277\343d\225\021\355\030\300\277]\332l\235\257\003\263\277HT\264@O\357\266?q6\006\367\211\203\201\277\301\245\032\362(\314\236\277s\231Z\013]\216M\277\322|\013^\203\003\245?=\030\337\365s\274\260?e\202\336\262IK\246\277\371\263S\0300\006\224\277\213\370\277iI(\302\277\030\240\221\211\215\177\241?\177J\'\255Ma\247?5\376\352\240cH\305?&\305\302n\262\314\252\277q\220\344\320\376\261\301\277\314\242\213\"x0\261?2\310\246\376\003\311\244\277<\336!>\317`\263\277\254\347\\dZ\013\235\277\314)\024d\357/\242?\312z\257\316Y\177\301?X\202l\240\256\215\252?\253\344\027\364\226.\272\277t\003\"#^\035\227\277.*\252\037\001a\217?\356\315\244\003\274\207\276?\315p\223\001\345i\276\277\201\345\344\273^M\202\277x\320\377\365\331\033\301\277\360\024\016\261\021\227\244?\251\0064u\204\337\304?,\200\r\276\272a\241?\025\227\206cl\361\265\277\216L\035+\372\353\273?\000\376O !W\262\277\342\034S\252\344\201\265\277\211.ws1;\265\277\010X\227\205e\374\264\277\354\016\242\t\034\203\313?\353\320\362\247>\017\261\2777%\336/\3717\251\277\341\000\313\321Y\007\227\277\2671\367\247\373\207\303?)\002\3320\254\345\277\277\237\346@\354\003Y\245\277\274\253\350>n\024\252\277W\344w\226\356\201{\277\016-\251%\364k\244?$K\322\213\0316\201\277\240\"\023\343\346\366\231?-S\t\274\246\224\223?\311\357\037>D\221\274\277}\r2d}\250\300?\327\270\027Wf\351\271?\200\354m\322t\357\254?\203\"\036-w\332\207\277\032\"\213\333#\301\261\277\007\227\377\244q[\222?\347\341Sy\210>\271\2779U\323Q\343\265\264\277S\002\344\230`\221\247\277)@\372\362\320,\263?\205|\027\372\310\360\266\277k\323\017\374\362\246s\277\215\212P\266\230?\226\356\355\341\366X\260?\327c6$C\313f\277^\374!\007f_\272\277\031L\007\274+\325\255?\t\213\332\206x\240\305?\'\270\242\306<\177\264?\225\362\t>\224\256\245?n.\346\202\334X\264\277\310\301\252>:i\251\2772\033.*\254\254\250?\373\364\322\267\357\243\231\277\340=(\030\034\010\271?f\222\374V6\336\251\277\271x\237\223\275U\215\277\3422\335\025_&\273?\215\016\221\373\204\231\227?\330F\330\0223\377\250?Tq\222\270\326\032\253?\334\207\213L\324E\243?\315\257e~\350\202\220\277\020\020vH\005\265\267?\357A\257\261\340)\234\277\222z\242\020\353\330|?\220%\226\376\372t\251\277g\244\217\354\320Q\260?&\264cr\325\352\255?\362\273\303\225\013\000\266?/\321\001\266\321X\241?\246\302\221w\300\244\265?\376\275$\214\330\327\272?\326\305\026\367\3432\242\277}\300Fb&\034\305?\225\034\324u}[\261?\321\245O\322\257\252\202\277\264\300\341F\222\337V?\304kA\262{\221\240\277a\272\272N\304}\260?\377\276\323\302|\300\226?\246\rt\204c \232?]\200\355\022\256\306\234\2777\211\017\232+\214\237\277$z\252KI\375\236\277b\372\365tW\331\210\277\260\037\261\255\365&\301\277\224\244B\320\037\242\204?\013\233\265\033K$\264?\025\3624\003Tx\254\2772\026Lv(\377{?\037U\024\302\266Z\245\277\300\010\3767\315\231a?\260\267\354L\236\203\240\277\354\275\001\201\304\376\213\277[m\306\353\311\354\234?\336\364\257W\264\000\302?\231|\266D\350\253\246\277iC\355A\035\232\264?C\350\202\263\342\003\255\277G9\017\370<4\250?!\330\231\366\271~\233?\306\231%\203\317FU\277\311\332\355\032\213)\272\277\261\267\000\316\230/\224\277\235\376\272\304\374\244\300?\351\336@\000\254\276\261\277Q/\313\337\340+\245?0\256\265\370\323\376\277?\034\2511\334q\t\242?\371\276\221\261\227\243\265\277\354\337\344\302<\007\240?\223A\264\032\240\367\243?\r\306\357\022\341BH?\202Ua\306Q\237\244\2777y\255\022\262m\310?7f\236\215\352\371\262?\rn\334\236o\234\263?d\310\023\253\034]\216\277\202\362lEd\302\310?\342\267\366j\001h\266\277\262\251\363&]z}?\277\240\372d\036\304\212?.\201|\356\021\'\271\277\310\230\341,\202BN\277\315yd2\217\246\303?\253\231\374\033\371b\264\277G\252\303Y\327*\252?\306f\213\357/x\223?JssH$n\263\277\327\213\337%f)\240?p\221\210\350\246\000\254?]ys_\302B\264?\361\n\214\025g\212\304?\217\203-\264\375\234\201?\312\240\304\247\341n\211\277\340\335\252\357\273:\302?\254\261d\266\014\002\243\277\016\314\000\254\"\032\300\277C\363\323r\005\370\222\277;S\334\346\211\032\247?\341\335\326 \207^\252?tN\027+__\270\277p\010\032Z\'\340g\277\373YF\223\301\216\300?kX\214v\352\351\266\277)cT\320\336\200\256?\237\361\204\017W7\250\277\232\375\213\025y\270\244?\357\216\356\\F\243\252\277\345n\253x\032\032\231\277S\361*\333G9\252?\262\245\372%\3228\203?Glp5s\340\260?\343.\357\362)\025\240?-\253\007\007\321\006\266?C\357\210\252\326\021\310?\350\033\246Q%\224\260?\245,\272\326\014\326h?\345\256\217y\266\240\262\277wv\004\263\254\244w?1\262bM\267`\264?\323C\224$\274\356\262\277\322f\217RUF\342\276\346\037\003\360\205w\255\277V\240\233t\025\344\205?\253\272\223\032\331!\244?\206\027uN\346\036\211?\374B\214\222\276\023\302?*!\214\212|I\272\277\250\215Z\377\006\017\226\277e\205\273\022\265\340\266\277\237i\035\307\002\322\233\277m3\245\357aj\243\277\301&\227\'\014\017\265\277\017\247!0)\025\242\277\'1j82\026\267\277\326\2318\006Lis\277\310B\205\240pm\225\277e\201}M_\000\203\277\361\201Q\373\343\225\236?\326\261M-LP\261?\271\322cuB\014\204\277r1|\023\t\374\224\277\211\202\351\030[\370\274\276\362}\336\005\243\253\276?C\375\373\r\277\243\250\277\020\303d\247eR\256\277>\214\0202*:\263?\254v\323=\023!x?\266lZbBn\240?v\247Sv\240\211\271\277\322oe\325)\352\264?`\334\3550\265\024\275?\220\177\007\353\033\321\235?u\366\250\361\243\344\311?\370\375\017u\373\002\251\277\375\320S\360 \324\273?\242\221mA[\'\270?3\2079\2331\361\240?\265I\220\306_\"\274\27700 \'L\276\304?>KPg\310\t\237?\243\255!i\311\214\244?N\241W\364a\346\257?\334\206\350q\314S]\277\267\321\351\353;\322\2338a\253?\226 \267jn\323\240?\310\247\212L\276\274\272?\240\002\177\263\376\344\221?)\304!\215D\253\244?\021h\301C;\360\245\277\334\000\005\351~\334\242\277y\205\235\034<\264\235\277\202\257\236S=-\221\27701\305\272\360\216\234\277\002\253(w\367\032\304\277D}\340;\203\306\253\277\226\227\355\255n\025\242?\275\027\304\303\345W\274?pvj\343\273]\224?\243\243A\n\227Q\244\277Gq\361\212=\216\226\277\340\267C\324\020\361\226\277\263au\244\260\204\245?\'\323\017\227\021\221\211?\266\254\304t\001<\236\277\024\001\365\255\326\334\260?:\301\030\r\211\367s?\361\013n\344Jq\306?\346\016.\006\346]\270?\337\214\342\031\201E\265?\004\010\002\212\'\212\274?f\036\375\001d\327\237?\\\t]k\010OB?\306\375J5\014N\206?\363\273`NB\221m?\361\020!B\024\217\262\277\310\317a\213\253\201\232?\351WJ:e+\211\277$\306\'\206\252\004\247\277L.\243\304\276\364\265?\330\260s\277\017\020\222?5\361\331d\017\034\206?Ev*\326\2550{?\311&\032\363j\204\236?\033v\330\227\346~\272?o\000\370.\305\230\226??V\270\333\276`\237?\206\377E\2034\024\255?\3259e\324\025\000\271\277fg\247\326Z\221\222\277\335;\265\310\271\321\247?\330\343:&q\203\300?\007N\tc\227r\220?S\361(\216\037\226\302\277\233 \0331O\364e\277\336\253\373\021\022\256\240\277\363\354l\346\227\270\231?a\304\033\323:\256\245?\020i\007}f\313\263\277aA\0139d\021\233\277\366`~\250\177\222\234?x\0258\010\372/\251\277\327T\177\276a^\276\277\030\010\234\325m\306\271?\037\355L3[\240\247?\340\207=\204\331~\243\277\253\024\006\215;T\237?\335\177\254Ggi\244\277mX\002\276*\202\367>\356\016\032>z_\234?\340\276ME\340\027\267?\341oT\344\304\032\244? \337\2207\323V\244?\342\332\353\363\024\320\305?\262\202b\255\206\033\301\277\003T\303\375L7\210\277\366a]\002\243\n\256?\221cc\344\2149e?h\250L\030!\342\240?c\230\026\0143\036\264\277\374-\3579L[\223?m\255<\245\251\203\262\277\345\022pxI \253\277\334\256\373\001A\024\303?\202\370\327[z\007\215?r\223L9\242\345\207?\204u\317j\252d\266?\326\3114\0279N\226?\233\274\264\364\363\347\274\2777\026\201\337\244p\261\277 I\307$E7\276?9\253\t9-r\251?`\317I\256o)b?f\334\366n\266\300\261?_O\"\370\332\360\221\277Wc\001z\251S\300?\r\221\230\341\330\237\227\277\200W&\326&0\211\277\272\017.~\235\362\270?\354\244~\230g\346\224?\274m\231{>\005\230\277\244\306\021\256u\006l\277\331o\212im\341\260\277\251\232bM\315a\235?\354\244\344\321PG\303?)\354b{\210-\274\277`C\361\266\240\023\247\277{n\224]\240\274\274\277\322,!\212$4\264?\014\223\242\005\220\242x\277\232\224z0\210e\211\277\"\304vZ\215\230\264?\270\312\250\361x\234\274?\250\236\316\314\214\361\204?!\2536\007\367N\264?$\004Q\273%\261\225?\272\301\013\365\251\206\247\277\024\357\271\304\005\220\223?x\307\026{\022\006\251?|\355\243\246\267\226\257?\367\2044l\334\302\303?a\307\362X}\020\251?\004\211\335\301\332L\271?\'8~\234\032~\253?;jn\0331\206\242?\351\006Ir\331\276\262\277\346N\365,Y\024\257\277Ja\374IR\222\254?q\375\360\020\342\377\300?H\022\334\023\311\034\225?H\374$\034b8\243\277\242`l\206R\336\262?\367\233hy\3369\262\277H\350 #\242\210\245\277\036j\310\3546\221l\277M\002\273\3065\315\255?\003\t\236\234\345P\270?@~\203\010\312i\232?\244Z\211\020\351\234\241\277\307\033\033\350~\000\257\277}4\360\254\264\013\303\277@Mn\212]\235\273\277\200=\223oy1\253\277\222\3663,\031\342\225\277\027\210\036amD\264\277\242~\263\240\026\322\273\277\0014\034\'\260\035\263\277fl,na\230\250?D+\241\347\362\016\305\277gXi\213\250\346\204\277tvN\020\032\272Z?\305\177o\275\324]\250?cD}f\230\322\262\277L\005\325+\\k\262?d4\242L\217\344\232?\016g\206\234\223#\257?r\222\264\203\245J\244?\232{\254\002C\202\247?\205\022\205\340\337_\225?\341\270\342\033\3239\260?\220E\322\217\216\260\306?\341\330\002\017\246\004\276?\276/\2021 \375\240\277\013\276\337\021\221\213\275\277\301\017\253u*\n\276?\315\376\030\013\265U\243?\331`\034\2635dr\277\373\313|\313\345A\267?[\276\367nFA\231\277\346\362jX\224/\262?\236\336\227*q\236\260\277f<\246\026\'_\303?\0043\037\002\311v\233\277d\n\355\367\323\376p\277\212s\263\336\251,\257?\346Ag\201\t\005\216?\367\277\316i\255X\315\277\373O=\260;d\242?>\344\306\221\322\340\246?\3703\243\220\214B\303\277)\371\307\247?d\334\330\236\341=\241?\271HSAf\022\272?\022\304\232\010i\270\260?\017\205*X\332b\254\277JuQ(\036\313(\277E\352R\332\032`\231?\013\204\346\340\371J\304\277[75\331\255\316o\277>n\365\277\340\205\213\277\001%\256\236R\272e\277\305=\375u\306\275\262?^F\265\300BL\272\277\"\373\276\324R3\226\277\r[\317\255I\220\257\277\261\206\n0\306u\271?\217Mf\177Ht\303?lG]b\"\235\247?\341S9\004\230\250\222\277\341\204\375\307QZ\227\277\252\211\3176\2728\261?\373\215\025\371\3250\247\277~\306&H\274`r?\207BH\261.\335\220?H\367T\033HZ\264?\335\336\350]l\305\305\277vT\335\365am\310?\241\037M\'\340ht?\312\365ukn\353\260\277\214\200r\306/\230\251?\017\342\370\263\250\246u\277\335U\302y\242\206\262\277\233\214M\361}<\302\277\211\373_\334\353\234\246\277\271i`\256\"O\262\277`6\\\215KP\215?\202V4\344\025 \215\277\017\345W#A\227\213?\356\254\223\244WW\240\277\264\313?\006\264f\303\277e\335\207\356\241\303\220?W\311\272\253\267\267\301\277\360\302\230\026h\243\307\277\367\\@R\276K\250\277l\245\306(\334w\226\277\212\235\247\301\033\026\236?\030\032\371\352\222-a\277\177/I\212\327\203\230?\204\023\363[\345\333\265\277\366T\372\026\300\010\270?\365fcZ\232\345\233\277\212\206-\317\250\355\255\277\337\371n\205h\025\250\277|\256\276E\230l\255?/\311\252\274\026)\271?a\371\2340\324i\244\277\265\022k\023\340\355\266?\257vM\004\027)\271?\274\367wy\002\271\241?Kcz4\352\267\276\277\331\365n|YB\260\2777J\\\334\241M\270\277b\017t\330\001\251\250?\006\006?u#5\267?(\033A\313j\247\211\277O\271\301\310\313\302\221\277\362\363 z2\320\263\277\204\206Bb\371\247\264\277\204r\326\246\004_\267\277\000\241`\315\331]\301\277\357Q<\233P\322|\277\244\263\370\341V#\275?\272l\252V\334\227\267\277\244\220\201\253\'\022\256\277\031KH\222\226\001\300\277\323#\n4K\\\225\277\341~\230iv\366\264\277g\360\207\226\303Q\225\277F\006X\337\036\321\300\277h3\247<\002b\253\277\356g\334\336y\227\274\277\336}\t\013\306\016\271\277\231\301\004\305\010u\271\277y\034\026i\212\363\256\277\275\274b3\0164\263?\306\020\306Q\335R\200?WWj\203\276\265\224\277I78\306\335&\242\277\327\335>\273\313\256\235?\316n\233\312\236\220\251?\266\374/-_2\266\277N:\022sld\302?\366Q0\220\232\201\310\277\370*i\323\273U\245\277\251\303\r\000\345\341\254?h\0062$`\301\201\277+f\003H\300\361\234\277\032C,W.X\245?\316\3264\034\314\312b\277\026\261\357\204\257-\232\277\007\210\331L\n3\255?\343X\023\025\300\215\226?A\2504Z\232\273\205\277\344\360\024@\254\202\272\277\224\211\257\004\033\032\303\277\262\333\270;\331\016\276\277\266\002M\302\204\314\235\277-\251mm\256\023\266\277\377\322aI#\276n?\247\3270\2129N\272?\241\265\223&\0066\231\277r\345N\356\023-\224\277\346\n\254\003> ~\277T\233\3250\317\351\256?T\247\3479Na\222\277b\036n\302\260\233\215\277\3451\251\010\272=\301?{\315\303\230\321\222\272?\270\261|\021<\205\242?\327\0107\"\202\007\265\277{g\207\316\316.\226?\332\312\316\006\346\'\271\277\212\337g\362\306O\250?\310\036Ko\372K\271\277\034\3649Q\236\364\266?\255\353\341\245\007\206\245\277\311E\'\001\001\220\277\277J\004n\260,\377\274\277\301`&P\222\361\302\2776^\337\3466\231\222?,\341\265\224\013\374\263?\237\273\311\204\322*\200?\242k\022\003\356\227\266?\206\215\031\300\006\n\217\277\010\215Cfn[\267?\004,\033\007\003\322p?\'x\265V\350F\236\277\305\233\235\314\"\307\304\277\211I\3446\220q\224\2772\006p$_\253\267\277\322k\000\246\rl\243\277\324]\267\367\320]\255\277\273\330pr\3629\242\277\351\226\272\266z\345h?5d\355\244\000\030\273?\374r\3211Q=\244?\326\373\242tcM\260?a\245M\276\271\013\316?x\276 \241\215\265\210?\251\"\214A\356\016\306?x\244:\"Y\367\244?\016\257\307O\031\243\265\277P\365;\330K-\261\277K\244d\263\002\273\263?\023\213\236\242Zf\230?\374pL\004\246\033\177?\215)q\252#-\310\277\276\273Jw\323\312\236?q7\223\322\3771\255\277\360\330\326Wn\257\257\277\34287\232!\2167?\306\275\024\026\367e\270?\301\256\261G\255\322\225?\316\003\274\260{r\254\277o\025`\374\232\326\214\277dJ\366t\277\371\256?\333|U\201\204\003\244\277 kz\225m\260\277p=\375\310\"\002\246\277\2369E\222\367\361\266\277\024~\324c\005R\257\277\211\271\345b\345\246\235?\260\356\274:\220x\202?6\250\351\202\243\'\256\277\274J,\300!(\256\277\263\202{\340\013\326\306\277\260\354 \010\252\325\303\277\r\244Ab\300\036\201\277\213\212W\227o`\252?\200Dmm\347\026\311?\006\212O\030\270\332\251\277Mn+\237x0\261\277\001\205q<\035\232\242?.#W\023\037\274\264\277\026\023P\031\367\227\257?\341\367B*\243\253\262?yk\017\333\000\000\243\277\000\244\211\357K\377b?m\302+\024V\324\274\277\326\026T\036\003\005\240?\'\250\376\031f\342\225\277\363\333\225\207\3362c\277\033\347\262\251x\271\270?a\366\211>\374\214\222\277\274\220\262o\364\232\225\277\371t\016\242\261\027\253\277L\034\264\035\365\345\263\277\203\233\241u=m\242?\257A\225\361\032\006\177\2775\326\343\202\363\215\242\277\352\362-\202\200\235\264?#A\030\031&\030\234?\232j\24657 \251?\332\274\006\265w\247\260\277LBG\344\334t\271\277.\010\222\265\006\330\250?\262\341&\203\215\243\261?\270\300\373\375\274u\266?8\3137)\330\315\270\277\365\245VF\207R\246\277Q\242\340u\204`\253\277\323ka\364\272\005\304\277DE]\365p3\241?\372\273(\214\210\277\243?\003\251\016\r\215\t\264\277\201f\371m\312Z\256\277\341\334\212\366\336\213\256\277\350\206\257\r\221W\207?\310*\272 \002\337\271\277\027\232\367Y\3346\244\277\036\020E\326\202u\232?\n\273\243X\225\204\236\277\2704?\326\006\374\274\277\272]\360]\005j\260\277`\367\324\242\264r\244?~my\236&\014l\277tS.\202\n\333\303?\355K[k\215\003\300\277\265\323\214^c\347\203\277\231\020\332N\337X\227\277H#W\253z\\\222\277j\230\302\242F\005\256?#\n\032]Q\323\253?j\364\313\347{\026\257\277A4\355\014E\311\244\277\332h\352k\240\220\245\277U\235\036\270\025\271\216\277\305\253\000U\2713\240\277\277|\324\274\005+\266?\234\254%\032\301\245\207\277\354\376_\365\367$\201?\242G\023\270\363\317\243?\262PX\030[\317\236\277\344B\344\353p\357\272?\211\301\356\311\252\315\226\277sVL\233\340\303\237?\247J\307\232\331\215\271?&\324\013h\035\340\245\277gB\211}V\000\035?I\033\300\220r\243\214\277\2068;\326\333\031\247?\207-x\021~\017\213\277\206\351ZVj\320\235?\225M\373\243&\211\254\277\347(\226:$\\\232\277\263\200J==\311\276?\234u7\304\267\237\245\277\212Z{.\236\016\266?\311\277\301\247O\366\215\277\032\302\3256&4\206\277\004\r\010<\202dp\2770\013p\327d\302|\2772\277\026*xU\244?\177z\0356\246\r\216\277}6\267\334\365\311\270?\212\251\326\2570Q\300\277U\234J\3137{\273\277\210\321\001Z\267M\261?uZ\022\\w\273\254?YM\323qh\235\232?\336\256\303\2769I\246\277\306\001\006\347\333\343\252\277\271\034\263]\377\262\246\277\363 \2565\321d0\277\253\026n\357\224\367\212\277\275M5\202#\206\241\277=+\276Y\231[\226\277\2778\204\235\022r\241\277\242\251\260v\242i\201?\370\332&\366\217V\267\277\303\343\252\207\027\327\251\2779\356\366T\347\242\272?\021\355,\3024\363\215\277\000\034\367\202O\207\267?.\347\024\311y\375\303?T\262^\203\257\"|?\374\371r;`\376\272?,\225`Rj\307\243\277l\272\212\206\242V\274?\264\326[\237\351-w\277$\251\201\254QF\263?\336\025N\033VK\266?,\000\214\027|u\246?\275\274<\275e\201\271?\022\245\233\2227\315\265\277\036SV\216\273cl?\032\234Vz\344g\263?\037\370-D\257\367\270\277\260\0243=\261\277\272?\341d\307\266\023\357\211?\305\317\302I\367\036\275?\323\333\016\265\005\223\220?{\334\330\253\221u\270?\025\352\245\013\010\343\215?\276- g\221\355\231?\274\017@yA\227\231\277JS.Q\273i\200?T\203\226w|\304\267\277\024\t\230\2202\030\244\277\257\002H7Y\000\267?|8Z&\217?\267?\263\340\233\371\360\006\260\277\235\367\254N\217\014\273\277\374\007\014E\366\334\232?\022.-3\017\220\236?\346\337r\354\002%\260\277\033\370\303\270\025|\277?\233Z\204\257g\315u?\234\245\366I\n\232\230\277\"D\222\2617\244\257?\3627q\010%\377\267\277\225\207\235\\\3658\275\277\020\222N;s\204\253?\245\212\3149\301\377X\277x/\374N\261\365\221\277\355\004|\353z,C?\357\2155\363\364\363\264?\342Td\244\204\250\276?\020i\371\254\237y\245?5\016w\036\311\307\262?1\254\204\363\207\221\240?\354\267O\220\300f\264?\356\233aV\226\177\261?\233\276\261-\227\222\271?\366I\272\027p\312\240?\010\273\375o A\265\277\222\027a\r\201\232\260?\016&\232\310\203\251\260?\343XZ\215\343\r\252?\350\306\322\232T\201\263?\014\254\333o0\227\252?\344\274Dw\025}y\277:!\247&2\354\302?\272\235\225y*\274\270?e\233\tybs\245\277O]8\320@Y\222\277\371\360\205\317\215\373\302?\021\342\364\r\273\177O?\367\024\271j\212\256\262?\351\032x{o\264\210?\344\332lUC\305I?\360\024\241\316V\360\230?.a.m/\270\200?\332\'\331\330\243\375\221\277@\324\335\236\211Q\301?f\336\351\376\346V\271\277a4\307\n)\017\233\277\0236\334\233\273F\241\277\252\232\367\341,M\260\277\270.\216\360#\362\263\277o~\245\306]\200\230?:\001\267w|y\224?\225\266\210[\025\t\232\2770 2\272d\230\235\277[\3725\"\243\362\264\277\352\333\300H\212\314\263\277\227^\027Z+`\252\277\307U\356\366\277\316\252\277dImo\350k\240?=o\362\361vx\245?\356-\242\007L&\261?\272\343\232\336Y\322\276?b[#\234\376\202\262\277\341\025R\037\313\236\255?\337\335ow\000\217\267?Y8\316^\217u\254?\337\0244\245\261\253!?\\?z\375\216\225\273?\\\267\250\237,e\266?\033\240\\X\202\335\261\277\000,J\254\335\355\242\277\303E;\177\2243\203\277\275\301\276U\030\336\265\277`P\363A4\010\220\277\372dI\013\345\314\200?\213\260~a\302\232\205\2774\315\313\317\302f\227?@\2735\211M\222\221\277\330\211L\310\251\020o\277\332\261\201\234(}\272?\260\332\"\367\010Z\265?\005:\274\203\356\334\310?OC\024\241\231\374\223?T\334\031\270\345\t\226\2778\361\237c@\270\260\277z!\017$\026\307\210\277\037\312\255\346C\235y?\343\325f*\226\321Q?\271\r\265\261\240\304\256\277\335\031\256e\210\033\244\277\314\236H/k`\241\277[po\325\304\204\260?\254\333\3268\213-\242?\251\226\200o \316\237?\350sg\216\023\341\270\277\010\254\305E\244\026\241\277=+\272C\013\307\265?\004\371\010\346\000\023\246?\223y\211j?\032\233\277}-$[-\000\232?kc\t\233\234[\226\277\357\034\364\312\207\240\211?/\313\r\223\316\273\260?T\341\215\336Yt\275?&\2223\277\326h\275?\326\n\375\212\3261\262\277v\365\337\022\300\277\263?1Tm`\313\033\262\277\352-\213\347\014a\252?\212\220\257s\000t\265?:\253iy\225\351\261?\244\034\3306\362\323\225?\267\306<\301\324(\274?\245\216\322\267.\301\263?\254\310u\330\3147\253?Y\224\312hGi\252?\265\373i\n\357\004\261?\014\301\\\200VG\262\277\310)\205\211\223E\265\277(Y\'iD\205\316\277\022\340\177\334z\177\243?\222s_\365\344A\225?\013\342K<\014\253\262\277]\310\247 D\306\260\277\014\273\3350w+\253\277\371\270\321\241xD\237\277\025\254qwqP\203?\251#a\253\n\311\244?\353\204\276\3709y\270?f\205\354\203Z\320\266\277\352G\355\210\233\300\262?\366\203;\007\211\213\251\277\354\312\247\003\232\376\254\277\014\341\327\231\034\031\214\277\360\351jx\327\341\272?\006\037hy\205\244\244\277\376\356\332IN\224\275?\343!4EP\324\227?{7#\330\014T\234?\014g\265\013\320s\240?\362a\220W\242\001\240?\205\311\322y\232G\277?\227\377\235\253\027i\255\277K52q\365\340\245\2773\205\001\226\206\322\301?\304uZ\312\306f\243\277\220=m\351\314\242\264?A\252[\212\033\367\235\277d\375\233\222\345\356}\277J\024\233\231\010\303\263?\010=\340\233\323\325\244\277\223\021\026%\250\233\220\277\004\331\030q\232\240\232\277\333,\272\360M\t\271?Y\036\024;\326;\261\277\232\317\366\224\022\242\301\277`\037\253v\204D\266?qK\202\256\304\333\254\277=\033\004\370(\023\270\2773\002\375\277r\375\216\277\0343\024\311r;\237?8j\353\250kW\255\277v\324\3107\240\253\261?:U\301P\305s\303?ncU\016\224\'_\277\r2df\036\226\237\277+\2403\247\251\n\266?\225\030%\002\"l\262\277\244\235{5<\340\263\277\2110\256u4\263\254\277\224ok\n\021\215\262\277\236\t\367\205;[\257?\'\2667\201\222z\300\277a\234/\354\221\365\256\277\305X\220\276\236\212\233?\315B\033\226\366e\267?\363\244\034\300\177r\301\277b\351\253n\376?\307\277\250\373\000\210\000\365\265?7C\264\231\276\002\230\277\234^\343`\321\255v?\322d\265\353\031y\253?{\005\220S\2521\267\277z=\005\016\0015\231? :\260\ry\001\245?\334\266I\266@\231\305?\351\216\020Q]\243\267?\324\363//\274w\214\277\003\350\224\203\363\223p?\202\032\036\'\275\270\226\277E\276\274xf%x\277\255?\223\324\327\211\265\277b\014i\240\030\217\245?\210\322a\'\316q\210\277\230\022p%.\272\230?\326P\337\302\nu\245?\361\253\262\352\006C\177\277zm\236N\3065\303?a\316\272\016\206\320\243\277X\"xN\345\225\240?I\\\257\264\330V\271?b\235\230n>\376z?\007:`\274\r\262\226?\361\257\375\034\231\314\266\277aH\0332Ig\216\277\217\246\017\211\177\254\265?\373\302ri\274\200\276\277\265\020\026\305r\213\246?f\274i\350M\252\250?E\312.\230\213\211\223\277\0016U\227)U\232\277\203-\234j\356\315\260?N\030\356\026\264-\300\277\362\307eV\357\311\270\277\272/\271Uz\356\266\277\235\312\356m\327\022\254?\352\334\260\266\205\274\245\277\2250I\017@\363\220\277\300\023\250\366^\370\277?\362\217\346\220\370\032\300\277 \3553\224\261\257\261\277\2443\234\3014\327\211?\377\257YG\007\001\246\277\342\243\343\024\312\271\273?&\007\227\200\361V\233?\325%\210Mej\247\277\275W!Q\014\013\262?\3458Cy7\272\277?\265\004Z=\226h\244?[\242\016y\374$\250?\213\334\331\037q?\240\277\223\025\210\314:\354\247?\202\273\242Yvu\303?\210-\337\214\026\361\253?\253\223I\251\311\024\221?BjG\023\227{\241?\314:@\347\257\215\264?\333H\307\216xG\264\277\203\r\316\030\027\203\230?\342\351\205\255\377h\245?\254M\033e*\206\224?\3502t\302(\261\216?\215\347\240Kp\300\260\277\321\236\304\316\315b\240\2775*\341\307[\304\220\277\215\343\002\317f\273\252\277\352\2066\255\360F\265\277\351\007_v4d\255\277\341\2173Fd\361\264?\220d\244\207\323\325\303?\274\352\001\340\320/z?\317\364\365q\023\233\273?\215\350\r\037\352N\261\277\014\235yy1\017`?\221\326D\246\331b\263?\213:G\374P\361\206\277\235\230vw~\265e\277W\362J\327\210\036\270?\266\270,\231\n;\255\277\252\224m\277p\236\263?\223ES/\003\000\260\277\223\002\213\342\307\033\247\277\330\373B\014\211+\301?\031\203\000\217))\244?\204\350\300\006NT\244?\332-\331\206\366\221\255?#>GL9\200\242?\323s\303\360\004\264\261?\034@\203\335\206l\243?\353\220(\225\233\253\247\277:(E%\004\360\302?\37350d4A\243?\275\353mT\357\343\267?\3255\005\203y\260\251?\244\341no\316]\250\277\302\033\021\316\026\302\277?c\223z\220I \267?\344\336q`L0\264\2770\270\212\336^\350\212?t\310o\"\320\211\253\277\212\343\260\267\267\262\246?\\z\3632\212\201\232?\265\202\242\255c\346\306?\027t\265\223\365[\264\277\230\315\242\2009D\303\277\272\231\315\302\203\250\240?\274\010\361^\013\314\267?\022\370\301\353\305I\261\277\177\247\0021R%\264\277f\324\337r\243/\217\277\030.\273)\275(\241?n\213S\237\273!\245?)r\256)`V\276?\260\342\335\237\243\325\264\277\344\251\355\374\010\225\275?\002`\372lu\3647?\271\255\005\366Ek\220\277\334(=^4!\240\277\351\023\261g\263CS\277\356\367\035\255~\334\270\277\003\r\325\3403\346\243\277\232k;\217\004r\263?P%\352\367_\231\272\277\237\020\372\016\0326\273\277\257\013\325/\237\263\231?\345\021\362\203\010\363\273\277\305\216\033\273+\245\247\277IFA\360\'[\240?\227b\277\271\276\030\221?\244v{\014a\260\204?\027\334\340!\025=y?-\351\030\213Z\026\301?\226\023\356n\223\375\230?L\307c\216\331_\262?\212\246\327\021B|\241?\326xN\264\212\251\251\277\357\234rs\353T\245?\363\257\326\2060o\205\277\211c\253\324|\320\257?ds\016\250\263\200\243?E8b\301\277<\245\277\267f\277\025\000\214x\277\354W\337\365\330\307\261?\366\"\017\263\001\220\241?#$id\016-\270\277\344\323 \010\315\002\247\277|\233\314\231m\003\240?2W\251\017\340\303\263?\236\236J\214\034P\251?3\0243\210\357\316\250?\300\314\204\010\361p\177?\025>\322\243 k\202?$\245z\007?\306\276?1\250\243V\232\251\255\277\206n\221)\331\207\260\277\237\3572\220\376\304\211?\200\031\001\177\340\313\223?Rbt\212\207\215\300\277)\302\032\177\231\r\260\277\033\263\\\375\217\202\264?V\302l\356\020\332\244\277i;\221\254R\014\250?\363\257\365_\016\304\237?O-V\232\265\357\220?<\220\2044:\200\221?\0276\263J\374\002\276?7\275\264\025\351T\241?#\206\356\250h/\237?\374\327\215\2663\207\253\277i\376\037\205\177;\272??\007l\322\"\315\275\277:\234\336sG\212\271?I\357\321\213\264\212\210\277\243\032\335\301\244\246|?NOR9|\353\274?<\344A\265\302\321\250\277\362+\006\014\006&\247?:\327\274\030J[n?\243\371\022\025\205\275\253?\034\310\225\032Ri\302?\337J\206\265\206\376\255?u{\037\235\377Y\276\277Y\275J\207\257I\223?\242\004\366t\346\'\262?\207\000\310E\267\316\244\277\230\314u\227\327D\267?w\254\221=\2449\275?\235N\222\2615t|\277\0265s\024w\322\263\277 \225\362\361\223\320\274\277\037\256\337\000\\c\201\277\212\211O-\007b\240?\230\024OE\237\310w\277\334f\275\277H\211\360\346]\204\300\277M\372v\016\257\270|?\237\255\332Y\246\215\252?>W\327\361\216^\303\277\330\336\\B\213\272\204?\305\002\225\247\317\307\274\277\2404\000h)\244\243?\372\271\240\327\177\001\272?0w\341NiB\261\277\320\010\244\257\310S\224\277\240\350\237\236\212\214\242\277\357\177\374-D\254\264\277\263q\003\325&\362\264\277Af\305\211\2220\260?\034t\204\237\231\236\240?M\226\214\245E\310\237\277\330>\206UB\363\276\277\204\007\375hG\374\260\277\201\314\246Y\346\026\262\277\253T\302\031\023\337\260?\374*8V\313\322\252\277\321K\253\305\"O~?uM\340\321\355\004\244\277\250\2776]Qr\273\277W\024\253\374:\207\213?/\364\337\251\345\370P\277\206\030\232\2326P\211\277\006]nQ^\201i\277-\205\347\2514\347\266?\270GW\365t_\261\277Q\206\002\3064\313\242?\231fQ\037\253\326\271\277\035\316\224O\330\275\243?\222\016\376\216\224\343\272\277\007[\222\377\271C\201\277*[\310\331=k\230?\253\353\020\372\363l\265\277\256\024\035\016\010L\271\277\366A\205\365!\207\300\277\t\346#\036\334\353\234?\377\241\033+\330\344\233\277\036b\036\272\303f\251?k\277\244\002/\364\263\277\000#\263w\024Z\225\277&\027\034\323\230\030\276\277V\300F\303\006\013\263\277i8\223\"0\311\272\277\321_x\331\200\344\260\277\215w\200\245c%\233?\310Z\245\324M\250\265\277\023\214\216\023\357\346\240?9\231SV\021\227f\277\364r\035\376{q\261?\214L\334\035\236)\240\277\024{\302T\"\203\271?UF\244v\317i\224?4\250\023\374\305\343\223\2776Z\351\356\365\215\247\277~n&\026RK\256\277\006z\3428Z\'\223\277\"fVsc\t\314\277Egn\330W\013\277\277\034\231y\351\246J\270\277M\254 \037\244d\304\277\237\372\030\341]\345\303\277\242\016\260>\314`\263?$\222{9\202w\276?\030\314\320\036\257\203\253\277\\\366\371\201\346\351\205?\256\305\"\235\233\362\241?>\275\027\333\013jt\277\264\003\277C\352\235\212\277$\355\000_\324\265\254\277\247\235\273\334\275\275\271?W\335\276\034\0006\260?A\307\351\332\366\276\247?z\326}\336fM\271\277\254s\243\253\345\350\212?\352\316\354\016\014\312}\277i\354X.\343\'\212\277z\006{\'\265\376\305\277\375\333\346T\324\265\243\277\302a\004\364;v\270?\227\345\312\021\352\231\275\277\371\200\223\2103\245\306\277\341\335#\037\222\236\265\2778\260Y\025\263\345\261?\306|\324\273%,\303?L<\3262E\021\272?\003U\312\204\230\313\201?}\204\243[<\211\253?\350\266d\311\250\374\262?\303\310\025\006x\371\255?\246\030\242\r\227Q\225\277\271\272oY\220\207\235?\030g?\034A\355\246?\376\240su\314\021\302\277\032\014u\331:\020\245\277\211\266\000U\367a\225?\027\312\255\211\036#\234\277)\\\237\216~M\272?\314\252\202\314\362\367\264?\201\225K|w\235\236?q\025\301\236\230Z\256\277\354\351\277G\263A\225?W!\360-\215\353\243\277\n\321[L\342\243\265\277\r\016\243U\004g\207\277\253\370\3663u$\304\277\321\345Q\341;\271\247\277\226U\310\316=\202\243?\277\367\375\240o\351\232?zl$\224\300?\261\277\224\253\030U\354\242\244\277\270#\024\231\324\377\264?\017\364\344\231\032\322\224?\222\357\017\377\005\266\261\277*\277\301L\344F\243?42\036\314\233`\272\277\200\315\315\0052\023\260\277\r\225y\035(\364\247?n\311\0372\355/\262?s,(\037h]\210?\335tk\032\006\233\274\277\367Y\177\343c\236\262?\200r5E\340i\275\277Qv:\347\021k\235\277~\216P\340\321J\257\277k?Y\030\300zt?\241V\336*)x\200\277\342\2465\'2n\264?\327H\256\271-\211\246\277\367\302\240\317QC\263\277\266\325\242\206\001\241\265?D\025\035\017\371\377\252\277\365:\214\241\237\010\301?\333\017\354\224\0340\304?\3355\246\304\344\225\232\277\332\330\226\316w\270\254?\370\315\224\335\307\377\272?6gi\322\324r\273?$\272\371j~\204\237\277S\035\313\233\377\364\260\277\215\032\002k\377u\301?\217\025\214X\364l\300\277O?7\304N;\266\277\213\301\217\306\216\364\225?\361\360\0033\263c\207\277\'\237N/\254~V\277[P\226\300=E\207?\264\303\353\000\353\331\242?|\001\260\373\024\254\277\277\3072\033\274\240e\250\277~L\316Y\233\014\244\277\307\257\327\305\023\253\231?m=oB%\352\206\277\371\225\347S\324\'~\277k\225\375[\235\275\222? \327\314\247\304\202\257\277)\265^\377\346\321\262?\\9\t\335\225\355\237\277\331Nx\2748\307}\277}\250Uz\315\004\256?\206]Lk\361\370\247?z\310\331\373k\264\216?\201\004yZ\036\352\265\277\232\366\200\341\017\001\212?\302yZ&o\036\233?R\202L\306\014\347\262?0\313\200\232\305\214\247?L2\357c\277D\266\277\370\363F\022\241\330\263?_\343\304\030\361}\265?\253G\366\025\231\252\216?=\245\205\277\321\021\231\277]\311\356\234\363H\270\277>\016g\363A\332x\277:\"\265N\307\330\264\277\345]:}\372\004\276?-2\220\021\362\\\217?\324\r$\004%\331\222\277\211\345N*t\230\227?s\275C\021\231Tp\277\002\355\200\326\257\332\260\277:\327\247\326\224\n\234?e\307\0065\300\270\300?j\213\"r\207\323\247?R\343\253\216\355\204\265?\3221\316I\301\211\255\277\340u\342\211!\325\262?Sp\024&\003\233\257?J\036\003p,\256\210?\317\004\007\334t\026\265\277C(\003v\375k\250?&9V\201\311\315\177\277\343\363\272wV\226\251?G\334\236\240\253f\225?7,\216\324\221D\205\277\214\250V`\370\270\274\277\272\037D\360\033\267\206?C\225j6\010\246\247?q\217%{b%\200?oq\260x\3614\216?\030\263\335\342\010\315\267\277\317\237\021\321w\257\224?bI\270:\003\014\246\277O0\352\323\260\371\227?Sm\222R\336\016\230?\225\026A\241TX\177?L\235\274\202J7\234\277$J\245\240\305<\250?\026~\022\341\252\002\253?n6\2131\334E\261?\334\315E\355l\216\252?\217\361\330\321\240\227\263\277F\004\324\372E8\271?P/z\264\203\237\264\277i#\230\347\322\016\205?\377\215\262\31223\302\277\270\375\253\224\353\263\264\2778\020\305Icmq\277\227\277\353\340\021\030\202\230\265\277\247\244\243(\253\231\242\277q\313B\274\332\237\266?\374\257Uu\262\232\234\277\241U\014\304\014X\252?\247(\313Sp\207\243?\2262\205\344\225\311\243?\035o;\225\247\251.\277Y68\023\231Hu\277+\021\322\243\324\243\274?\275\220\031\017\361\313\211\277\324\236\3328\352\321\226\277\003\003g\214\234\345\302\277\234\037j+=\211\261?\251e\232\376\243\003\277\277\255\254\350\360\270\367\242\277\005\024\30237G\264\277\243\326F&\351\236\265\277\352(f\n\222\230\200\277\245\3052\276\034&\257?\230\315\301\366?(\247\277\264\262Z\350\212\335\306\277\347u*@\nv\246?\036*\365\034\357\370\300?}\034\00578\226\226?Gb@\221\264\314\264\277V\017\205\020\346G\255\277\020$\203\271\341\327\241?\327\036}{;\211\267?\327/a\376\251\346\255\277W\374B\020:\261\272\277\362\271\034G\207V\300\277^\004,\366\312\r\253\277\230\366\221\203\332\031\256\277\210\323\352\264\177\346\213\277\204\t\345\245\352V\205?\265\257\340\236\344\025\300?\212\226\223g\322U\274?\372\024\200\201\007\212\223?q\024\3471#\275\240\277\210\357\027\200\332\226\277?kl_z\345\357\224?\016~$\325f8\265?`0\315I\037\333\262?-;K\237\223\002u\2774\016%\215\302\270\261\277\017\236\346\000\313X\254?\177Q\202He\021\233\277S0\251\203\\r\243?}\010\313r\236\235\245\277\360m\024t\246\014\222?\177>^\254;\263\225?\376\264\005\251\245s\225\277\227\203lc\335+\224?\300\345\332}1\030\310\277\333\372\270\333`:\264\277\346gQ\324\265\002\255?\301Fo/\254\345\304\277\031\224i\273F\373\246?\347\020#\335\032\242\274\277\226s\373\326\316\222\221?As\305s\371\223\245?\253\241\037\345\262\361\251\277\241\334\361\250._\241?\207\234V\234\221\325\237?\013\334\302\344\351\344\246?\266\200\271\222\251U\233?\225\363N\232l\366\260\277\356\340\253/0`\277\277\220\375\254\010@y\255\277>\234\246.\256<\246\277B\021H\375\327o\270?\313J\275W\361M\261?\202\'\232\036!\020\263?\203N\215[\227\037\252\277\225H\251\347\345\261\240?\214\217\244nk\260\245?\021C@\024\202\302\244?\327\206\303\307\026\022b?\230FT:\200I\262?\272W\276Z\326}\216?\257\300\350\3547\030\265\277\000w6\321l\213\265?E\001\n\256%B\235\277\357:\021p\242_\256?:s\351\366\0327\263?\332\010\354-\220z\252\277\'\022\205&\360\231\243\277q\372\014\243g\200\262\277\241\270\266\276Q\036\260\277g\352\202\250\274\026\260\277MKF\255\227\331W?\340\036\264\177\342S\267\277;z\267@\206\216\204?\341TY]\323\364\246?\340\200\252(J\022\300?G\306\257ky\243\262\277\215\211y\242\203?\277\277\370\022\327Nd\t\257?\300\233\224.I\026\203\277:\301\203\354\326\033\214?\313c\322\203\303h\255\277\245A\374\305\374\265\267?\271z\212\352\025P\243?\372\203\275\306\3037\262?\321d\345\364P?\247?|\344\204\310\030\221\277\277\226j\355\026\221-\235?y\200\\ \000\246\260?A\274\005 lXr\2777_q\272\202\010\210?Q\210\226\373\002\001\240?\250f!\337\231K\260?\254\357\356\243\335\247\271\277^d\252H\221\342\250?\213~\371\343\004\326\243?\336id\200oL\236?w5\345\323\355_\244\277\3741\223b\324\301\261?\177\306\224\241\303\311\207\277\300,z\217\341q\273?[\356{h\032f\222?/\322h{\213\335\263?\004%e^\016b\241?\201\357s\347y\021\230\277\242\010\326:\025\206\261?\313\216\020\334m\307\270?d\214<\363\n\224\201?\360g\021D.a\300\277\023\254\002)`N\244?\177\265Q\246e^\301?\237\316\310\203\326\234\262?\221&\342\035rw\302\277\245B_tqq\232?\375d\031\345\014\326\300?\021\205\225\225}\177\337>>D\374\320\327\325\221\277\236\236L\026\223\230\233\277\356\224\334[Qp\270?\357@\035\235\244^\267\277\212Q9c\304^\241\277\\\021\254/?\221\222\277\260\247e\312\024e\220?Q\376\314\001dR\227\277\320\365\2276\272\022\260?pM\212pN\226\263?\251\373e\211\214\231\220\277,0Q,\243\013\240\277T1\224jw\335v?\377\375\225-\025\327\245\2770L\267\310\026\250\241?A/0Yqj\264\277\025)z^\326\205\273\277h*\333\255\353q\301\277\242F\nX\350g\241\277n+\255N-\347\303\277w\006b\003\323\013`\277\332\367 IqYm\277;b3Z\351\261\264\277u\031\001\375\311\026\256?\212\030U\\f\272\242\277\031\036K\255\331m\233? \346v\254-H\245?\025\271\177\315W\017\230?3\270\rI\347\323\202?Ig\275\246s\205\301\277\360\253\215\371\304\220\264\277\346g)o\223]\256\277D\354+6\323,\305\277\320\034\267\324\230\271\304?\340<\275%\364A\223\277H\2507\200e\230\261\277\210=%\0061\373\267\277\007\337\021{\255\257{\277\007k\2410\247\267\263?n\375\005Lq\247\261\277\245AP\306e\355\262\277\024f;\312\266\260\243\277\002z\212}\232E\247\277((y\245\305\237\241\277\307\022\352u0\211\256?\035\315dl|M\204?Q\375\344\207\216\232\240\277l%\224\350n\016\261\277\346\307Y?\002\351\261\277\306r\343D!\214\273\277B\205\372\262\001\302\261\277\022\014)5\247\214n?\211\273\340\254\"U\273\277B\244\215\2170\226\270\277\212Co\312\1775\240?\221\375\374\234}\306z?\r\353\352\267\244\013x?\255\200~\364*P\227?b|D\306\017,\266?\301\345\337\001\017\365\262?\225\262x\347\'k\254\277V\354\330\005\220\230\216?\222\033\337=^\344\253?\351\326\251\272\003z\211?\305\350\371A\005\217\274?~a\024\362\357\230\231\277\320\377T\222\322\273\301\277A\231tte\335\236?\202\360\3500\223\274\271?\331\010\355\377\265\222\250?\305\033\255\351\366C\257\277\226\207\207\"s\263\234?\355\362\016\222k\360\261?b\340\303o\263D\301\277b\232\273Z!\262\257\277\211\324;`\275\304\263\277\323\"YF6\357\237\277t\235\252\364I\252\254\277\014E\354\002\201\007\255?.\240\024l\030l\272\277\264\332zMg`\232?\263\250s\025\352\355g?\327\257^\313\177\347\302?\025\253\243\262\277)\265\326\016\203\004\260?\014\254\254\262\235&\235\277\213\370\013\27678\270\277\344,]\231\037\016\271?\017\203\366\330\276\305\273\277\304\345\365\356$\026\217\277\231Ar_!y\270?\217\037\212\thX\260\277D1\0047\235 \245\277\276\225\025)b\326\254\277\006\\/t:J\305\277\272\351bN\003\271\240\277\266\315\0005\345\325\266?w\325x\216U\212\272\277D\211R\225\210\211\253?\223]:\300\036\300\302?\202.i\200\2234\256?\021fD\214\010k\251\277W-{\316S\205\033\277^0\006\230\251\366\265?\316\343\240\330\205\372\246?X\350G\377|r\230?\320\352{\374\254[\270?\336\216_\310,h\311?2.N\260V\303\262\277J\333P\366\347\253\301\277!\252\263\\$\re\277\301\320\263\204\027\260\252\277\356\322\267\375\r.z\277\253\r:\024\367\310\302?-9\333\nU*\300\277\021+\365Ljn\302\277\306c\"\317az\301\277\3618\261\241\231\005q?\177e}\333\033\305\275\277h\326\002\204\003\232\241?\377\204\006\207\235z\250?R\353\307>1X\222?\303\200\351\345\263\315w\277\253<\241\250\227\377\212\277&\352\347\221\272B\303?\r~\351\240\t4\230?`\322\232\231\271\035\236\277\3163cN\202K\305\277\014\306\333WYD\261\277\252~\025\243\232\001\251?\212\201\244\243\321\355\265?Gs\t{\263\342\305\277g\202z\030\320S\242\277\347]}\247\235\260\241\277\262]Rc\273\364\243?\251\345\336\313\270.\253\277LRE#\225W\260?\244\335\355\206\377)\273?P+\370\224\001F\236?x\031\000\332\255\373\255\2776&\341\3232\262z?\270,\020\365g\n\267\277-,\020))=\262\277)l\021,\026\262\256?D\024\374\242*\246\200\277I\006\037\200\264\277\3411C=\006D\253\277Q\270\266Q\347a\207\277\260\n9\002w}\301\277u\372\273\271\263\327\243?\030\0225\306Y\264\240\277\233.\005_+s\310\277\337\352E\251\000\274\263\277l\311\263U\304<\241?\322\025\335\360#\351\266\277s[\276\022O&\211\277\002t\3472H\374\212?\212\222\3604wy\265\277\330\032\276S\327\235\240?\206\001j\241\020\274\226\277qw\357\020\225\264\272\277*b\262\246\\\304\274\277\361\367LE\316\210\267\277\206\234Q\341u\372\256\277M\321A\350\024\342`?\301\315K\263!\320\266?2|\004\'[C\261?\277\177\330uy\347\224\277\025\361\223\342Y\207\262\277$f5\305\010\014\261?p\007jU\026\324\262?\026\030\374\244\223\377\215?5\3112\322\364\324\240?\242o\326\244\\F\177\277\t\244G\216\246j\205\277\035\300\236\261}H\177\277\264)B\200$\005\301?b\326V\376BQ\243\277\035Q\"\363\276\346\305\277\221$\254\306\371*\203?i!d\234)\027\265?\242m88\353U\255\277\001\232\330\363\223\230\273\277\261\366\240\031q\036\310?\347\313\006\214C\352B\277h\301\373\010yv\311\2779\013\005\261u<\257\277!Z\243Q\373\203\261\277\265<\017\236\246\006\261\277\373\354&&\210\'\310\277,T\033D_\177\247\277\227\200\377\031\362\026\200\277\245\000\017\363#\317\301\277F\247RY\231\331\256\277\261\326:\331\223\'\227\2776\370\n\224\327A\250\277\204\030\246A\310\363\274\277f\272\373\376&\275\273\277{\002b9<\252\202?\005VI\001#o\313\277\006\246l\246n#\265\277Ri\'\013t\355o\277bSz\303\377\002t?;\343\001#\352\221\257?\3608,kL\224\256\277\na\333&\2647\273\277\325\0233\000\006\234\240?\345\334\'\003F7\244?\304\366\\\204\"\261\256\277\212pe\277\300\017\260>a|\215?\272L\321\311\033h\250?\020B\223\245\352\264\263?\304\005g\244\214>\260?\'\t\205z\267\027\256\277:?O\324\014x\254\277\027\244W\211\000\247\213?8\271\007\t\'\334\240\277\014\275*h\314\310\262?\332\263f\010X\240p?\232u\266\311\\p\212?\373\277\337\342\261.\252\277\327\\S*\030\030\243\277gk,-\231Q\273\277\222\211\021\2662\270\304\277\027\260pi\030\313\271\277^\217\272|R\302\262\277\203]\025\330\016y\264\277\257\340\245\231\311\020\264?\347<\222|,\375\203\277\306u\275\324\334\341\253?\r\327\207Q\000(\232\277\313?\004\220\271\237\245?\0054uK\363@q?]@|\216L\034\247\277\350\322\212\'\021\306\304\277\223V\001\227\352\321\270\277\307\336\'\210\261\221\310\277\233\023\016\246G<\265\277\1773\332\317D4\276\277\337\212\365\326\204\225\246\277\247Z\n\3622\3305\277\245q\010\033zB\247\277\202\235Nz\234\236\261?(\n\031\027\320\266\246\277\310\2274\255\321\025\261?J\253J\010XH\246\277\272\245\325\243\251\217\216\277\270\240~\346\026\363j\277h\244\002\316\360\r\265\277\363(M\017\325\217U\277kH\310\017\211\374\245\277;lA\333\017>\304?\336D\177\223\202\313\267?\003\323b\213\336:\247\277?\241\367\321}\324\240\277y\273\374\277\361/\276?lu\307\236\006\343\257\277\0278\227O\201\016\225?\257v\231\327\276\211\234\277\t\032\033x\t\236\233?|\211\251\013g\263\233\277\363[tQy\"\250\277\346v\303&\275\331\270?\225\225\223\361=b\301\277\023*\302M\r \241\277*0\330\002D\275\203?TFqBt{\212\277\260\202l\327\353\"a\277\306\254/5\304\315\212?f&.i\246\223\261?\375\220\316\r$\237\264?\006\361R\322\007\353\253\277\273Q\025\301\325\243\262\277\334\357=p\272\316\241? .\374Mq\376^\277\203\316\203\246\027\017\251?\217K\261\364\245\365\261?A\223-\255\372\340{?\307\217\240\233\031B\244\277\317S\033\025\t\241\221?h5\260Y\361\334`\277\207`\207\221\002\363\266\277\305\305\376\3735\013\263?=\300Y\307\352\004\246?dy\004I`\342\300\277\223<>Rp\262v\277\221\307=\237\326\354\241?\235\377\351B\244b\235?\267\240e\005\335n}\277\177/#,m:\261?\331\322\005\326(\326k?\274.9\366\332%\266\277\0378\267%YM\240?\223\237 E\270\323\263\277)\337\335\214(_\213?\220}U~\341\250\271\277=\014\r9\306A\247\277&\227&2Il\227?6WEI\205\212\246\277\234\337\237f7.\261?\037\353\210\336`\205\261\277\232\223T\022\333\336\250\277HI\252a\220\341u?g;\311\245\223\313Y\277\255$\225?\034q\270?\210\036\203J^\243s?\226\362\227Z\256\001\203?\202\362\"\004-\234\217?k\010\024b\347\030z\2771\267\206\244\227\236\242\277\254\242\246\251,E\264\277\004Qs\237\215D\244?\376\3276~\210\216\255\277\366k\005\030\341f\264\277\177\317+\033|\366\237\277\345F\234z\373\010\236?N4\267\254\020G\262?o\243\014\337\253\347\301\277\233\364z.\371\224\311?\222Dd\022\331V\254?3\271\322\035\223n\254?C\255j\026#\362\261?\342\"\303o,0\304?\234\343\2756\375\366\227?\352\010Od\254\374\253?\027\274\221\220|\364\300?w\205\343\211+o\300?\'\032\214J\017\302\261?n\226\273fo\247\220?\347\305_@f\225\262?\355&3-k\014a\277\321v\363\340\324\224\021?g\333 ^\227\254\267\277\213\3322t\320\001\224\277%e\230Z\370d\272?ScH\202\267\332\300\277d\000%\0268\347\271\277n)nxA\210\240\277$\026v\301\313\305\237?\276\'\230\232\313l\257\2771\376\"\007\263\323\246?\010\257:\224\260=\272?r|\352\250(\334\204?q\002\03504\364\266\277\n\235K\343\261\363\244\277\032D\035\362\323\300\264\277\350E\367\205S\326\263?\336\331\365vT\250e?3\235D\271\242\361\272?\226!th|o\252?\314\373Q\252.\021\200?\022\351\250|U\230\236\277\032\001\375\304\216!\263?L\216\007\216\377\037\243?\317\227\206\3640\344\252\277\265\026?\006\252R\244?\212B\314\225\\\021\256\277\031\357\025|{>\247\277\222\267\272\234_&\224\277\210\342\225\361\270\325\303\277g\222\262\207M\010\201\277]3P{\251d\241\277\327\272\355\005_t\301\277\376C\244\231\025h\263\277\240\206\211f\273\310\263\277\327:ty\311\'\207\277\251\211\362\262\315\021\243\277\225\253\301l\300\r\203?!\n\357\372\306\257\256?\242\317\024@\200\t\245?\221\200\002hP\023\206\277\024\373\322zQ\376\232\277\r\025G\'N\032\262\277\226S\346]q\313\237?\303\236E9\035\242\270?\264\022\216\327+\rx?\314\\j/\363\263\257?V\376\3139\220\265\242\277\355\014M\342V\267\263?>\204E\024\326\265\201?f\214\364\310\265c\253\277H4\317\321\033\251\262\277\200\260\223\306\"\247\257\277\252\317M{I\007H?bo\223\220\323\353\243?\241\375\270\261\004\244\211? F\201\251\2527\267\277`\262\364mx\004\234\277\007m\351\317Z8\240\277~\274\212\260V]\261\277\365\220n\363\003\342\315\277N_bJ\264y\236?\324\t\252\216\271\353\240\277\272\324\242\030\311\\\273\277[>\\\225\237}\305?\356\036$\270E\255\267\277\246\023\035\037:\"\261?(\230=s\261\016\242?\374m\342\n\"\276\243\277 \345\242\242\234\256\232?\360I\3675K\301\251?\275~o\217\275F\226?\037\302\2333\266\204\267?\035\342\236\361\362\235\230?:\321;\321\314\010\301?@\242-\332\027\376r?\021\032\007\246\034\037\266\277\256\335\344\346\307A\251?y/\341\001\261\217\237\277W\000-G%\252\271?Fw+\272\216\316\201\277\024r\0318\247/b?\014\302\224r\030\260\250?\351!\226\277\355]\026\325)e\227?\322\370\302\351\307\361\244\277T~\215\266(\204\232?\013\346\304\303\217\256y\277`\331\022\222\214\350\274\277D\235#ef\037\246\277\242m\016\222e\243\267\277B\002\325f\2510\202?\376\257\272\260\222\355\277?\355\306\306]\036\216\256?\377\354\263cX\276\267\277\333n\316#\"\375\251\277\333\311\021^\344\350\244\277\323\327F\007e\262\221\277h\374l\303\367G\231\277A\272H\361[\246\246\277[\267\366\322+h\243?a\341\214\215\256T\234\277\327\314\266\3753+\274?hJ\260\200\377R\233\2774\355ha\035\215\305\277\302~\275\377\326M\254\277I\300\"\341\205P\214\277\3238K\262\212\324}?C\006\222\364\311_\270\277\20170]}P\266\277\323\237\304\377d\263\232\277\017\303\032\267%\022\266\277\010\371Gfa\222\244\277\357\367\207\243\323\231\261?\302\224!\363\313\350\205\277\304j\266|\274+\234?,\220\251j\203\316\217?\t\267\034m\212\233\220?\350\253\007q\210I\200?\315\206\270\223?\333\204?)\302\300\274\346B\241?\355\226f\340\374\204\257\277(\'<.\010\225\251?Ej\206\265\217\324\272?B\265%\263\2639w\277\363\235g\217\2158\241\277\021\342~L\2469\265?\345%\356\225\251H\272\277\355\246k-$W\255\277\373\001\n\206\372B\232?\221/\267)\002\340o?\235y\242\005\177\r\266?I\221\226\267\t+\261\277\005\232\264-M\032\226\277|\312m\246\273\003\231\277N3\363\317AT\277?\'vy\203\025\026\243\277\322D\022\202,]\231?Y\222\002\336-d\247\277vb\200\226\346\374\302?NnjX\243x\247\277\210\251a\3173a\241\277n\022\3665\352g\217\277\200\017\313C\322\216\231\277T\255\037$/\320\216?\025\221\354\307\225L\223?\346:\372\304?N\274?\300w\254\33550\260\277\221\261\033#\314\342\262?\300\311?E\324\261\267?h\267\256$\010\316\261\277:\325P\343\010\367\243\277j\330\261\361c\030\244\277\353\202\324o\037\244\237?4J\370D\216q\301?\206\341 hn{\203?C\237\303\332P\234\275\277V\r \362\302\336p\277\324\210(\314a\001g?\311\321\304\\\236d\224\277\303\204\305\243\236\343\276?m\2441\362\377N\300?\351\252\014\334\213O\260?\255J\230\305\212\031\250?\t\217]JoQ\242?<\224\3128P\222\266?\0062>\320E\220\274\277\330\366\307\223P\377\241\277?&e\022\3508\252?#\t4\034\377G\250?M\332s\215^a\243?4\037LkO>}?\"\252U\234>S\223?%\235\252\341\222\316\231\277\246\334>\r#\273\262?0s\271\372\250C\230?m\3208\037 <\273\277D}\013}\350p\222\277\203\342\251\251]\016\232\277\254}\341\256\354\017\264\277{\212\277d\033\303\261?L\356`Q\257D\266?P\\\033\r\331\022\263?\272\322\266\t\017U\217?\\\261 {G\032\265?\235y\010\t\205~\250?\240\to\310\024\220\222?\206\313\214\370\005t\267\277\201\270!\314`M\236?\267FN\223Q\221\300?\207\202\237\302.\201\247\277\0060\022J\205O\265?p`/7\232v\232?N\024\347\314|i\300?\242\202\221X\356\316\223\277\370{\254\361\237k\243\277;\252\232Vl\375\263?`\312\013\260\310\325\247\277y%\210\366\353\276\262?\307\206JJ\2002\301\277so\272\264}\217\274?\001\217\271\255\200\034\270?\313D\347\223\034\217\241?}\347\255\374c\372\301?f|\202\365j\235\263?\261s\256\035\300\240V\277L<\240\340QLr\277\262%\307\321=G\245?f\035\006\267\313\373\216\277\265\213\235\311\024\246\303?\365J\365\210\246\204\243\2770L\304\246Z\356\263?(\004\347\n?K\236\2776%\344\371Y4\215?\245^\206\300V\260\256?Z8\305\326\257|\200\277e \333\345Qc\250?\005\005\031e%\262\243\277\377b5\024qo\226?c\312\227B\223\343\254?e\347\222G\236\003\264\277\030\377\357_Za\300\277$\360s\035\313j\262?Y\373\'\021\213\247x\277U\036\303\202.3\265\277\001\3707\']\035\205?,\"M\317\227=\267?\234\254\021PM\n\236?\241\315\275\201\235\201\207?\177oK\376u]\260?\254\227\3550/\343\263?p?\002C\210\347\267?g\213\342\265\275}\252?\027\221S9X\001\250?\264\212f=q\253\260\277\3679\221B\263\316f\277\243\324;x-\366\304?\001eXf/Z\270?\031[h\022(X\264?\233\317Y\r\354\274\236\277{\001f\242&\214\301?K\207\'F\002/\266\277\013\337:\350\026\010\311?\036\372j\202,n\267?H\254;\020\2370\256\277\345R<\245\317I\225\277\002\003\347f\327\013\247\277k\361XAU\003\223?\177\303\242{,8\241?\027 C\221\225\363\272?\302\333O\t\036\347o?_\035$\310$-\265?g8\\z\242\252\251?\037\000\3769\271\341\266?Ec,\363k\370\271?\264\333\2163I\337\243\277\177\357\322\350wr\223?\013%z0\242T\243?\376\356!+\375\210\213?\307Ce29\331\272\277t\265\377s\026\336\270\277\352\037#\202\274O\221?x\313\240\253#7\270\277\206\013\325]\203\373\260\277~\312\374\302}\231\265?\274\254\331F\377\277\242? n\031::\243\261\277_Cy\\\243\216\213\277\037>5\331]\013\251\277K\334?\014\363J\307?3\336\213LxZ\262\277]\355\373f\n6\254?uz\303\t)\261\246\2776\004\344b\224\243\245?\022\335p\257W\206\267?\3565\301\345\016\262\246?\007i\027ZFI\210?\323\375=\366{\327\310?B\341\356I}\007\247?\356\224\000\032H\354\226?\000b\000\013\037\313\275\277\272W\200\312\211\361\265\277l\342\335_\256\266o\277\022E\316\304\177M\276?\230\274%\304V\032\231\277\252\245\257\004^\236\260\277\240\004\255\031U\343x?\016\273n\375\204Q\303?\246\363\016\013\024\265\257?\330\341\357MIT\305?\017\201\213AP\025\250?\016\360Y\033T\200\276?\357;\t)\312\004\261?1{X\003\263\033\302\277\311\225\345\361\227\343\300\277\355!\332\200\354\241\230?QE\322\"\277\000\204?\241\267\216\226\360\r\227\277\327\346\200V\202c\225?\244c\377\215\300\016\261\277\324w\221\313\301\260\212\277\001\253j\307\017>\234\277\004\255\311m\255\037\251\277\307W-|\304:\244?\375\241?\305\336\303\244\277\317\265\242(\360B\201?\236\024\253oE\n\301?Y\221z\350\t\036\237?\000\017\351\305\237\270\261\277\310e*[\325\343\227?\207\220\231\300(\351\271??\226\342\322\010v\207\277a\331Z\340|G\235?\341\375\373\341\027\t\302\277\336\212*oO\363\271?X\232\245Zz\213\254\277\2246dDj\206\276?\260\312L\200\251\322\250\277\204.\023\373\350i\203?\332\233o\247\306\007\310?N\303\274C\360\020\220?\361\302\311\343IZ\260\2775\360e\031\005\007\303?z\334\302\220\314Z\275\277\315\227K\232{\326\232\277\304\357\\\212Y\353\273?>y\027l\300\010\262?\326ZT\030a\304o?\365s~,\212)\256?\207&\023{\324y\242\2770m8\236\320\231\276?:\220\013,8\215w?%\210\025!\013+\231\2772*F\334=\367\276?\241\227v\217\201\207\250?#\030\324\264)\200\226\277\327\362\205\276}\310\250?\303&\353bV\351\236\277\251-\353\035B\220\304?\366\035\355C\335\"\263\277\242p\352\237\301\371\177\277\250\330\031\344\214\021P\277\312\237Fe\316 \232\277\303\257!ya\273\221?F\025\031\224\335<\302?7[\001\030\0010\277?d;\227,\217}\244?\333z\000[\221\360\251\277\204X\032CMu\221?<\216<[\273\330\234?\311\324.\027\363o\212?\242H\032\2366(9\277\031\034x\214\021$\233\277^\003}\300\363\227\260?\227\253HO\365\250\252?\235\320\335\235\010n\265\277\315\202R2\337\320\207?\376j\021\242\021K\250?\206\272E\266I\247\211\277\356\206,\266H\312\270?A\0326uA\004\227?\006X\322\374\323\032\206?\312\007\026\303\262gL\277\025\224\005\232T\357\267\277\370\211J\2769.\271\2775;d~\276\257\273\277\n\3265\345\267g\240\277\025rY\373\272u\266\277|\333\377\302\313\'\265?`\0248\200lt\204?\354\266\022ye0\225?\037\030L\354)\237\302\277kC}2\236\020r?\244F\017\363\303d\227\277N\000m\210;\353\252\277\002\037\300NL\317\250?\270\3572\337:\375\211?\353\364\254\377\006\206\241\277\271u$\354\327\032\260\277\272\335\272L\r\376\226\277w1F\340r\242\254?\371r3\336\210:\276?\020/\000s\356\007\257\277\036Un2\204-\234\277B\r\345\262!d\244\2770\221\314\362\261\313\262?\211\327s\2428I\267\277U?\3019\312\322\262\277[1\354\2303\030\217?\220\210\352\203u)\235?\023\256\276\361fe\257\277\335\236\313\026\226T\240?\026=\221u\256\204\270?\305\255\027pP\363\225?E\\,S`\233\252\277\033\2075]8Y\236?8G\022\031\245\246\271?>o\344;w\373\274?\265\3347$\2634\240?V1\255\367r\036\310\277\324\260*\316\377\271\241?w\355\214\031\213~\246\277\t\346\2248E\233l?\345{\3025]\254\203?L\215\"\000e\260\231?\3655\247`\2747\265?\327\230n\214\353\304\256\277H$\300\013\273\304\307?\261\267\366\240\231\330\263?\316\276\301\322yi\252\277\300\016\270\21503\265?)j\022\333\2437S?\025\226\364T\251\361\304?\312\006\202\253d\304\242?#\245\027\275\r[\263?\r\2659\262-\210\271?8\026\263\2409D\305\277\354\335\030\303\350\317\237\277\366\0271\342_\320\300?\\\031\315\216e\271V?)K\036j}:~\277\000\346J\0342\004\233?\351\302@\276\202w\253\277X\231\275I\230b\256?\n\332\303R\245\277\225?\367\277\254^\2762\227\277\364\252\'\210Q\023\223\277\363[\212+9\363\223\277\361fk\200\212\205\226?%\363V\021x\013\220\277\233\326\"\177\3238\266\277T5\326\000kfy?\224\371\033\327s\316\271?\333\211\003rb\005\257?\374w\010\037~D\214?\316\020j\261\322\334r\277!\305\030\352\344\330\255?\262(\341\013\321\027\223?\256\027\307\2018H\265\277\027u\017a\3131\271?\3252\352dt\307\264\277u\004LT9\342\264?v\016\034\225}\316\262?\'\276}\251.&\304?\303\355qkg\030\242?8\303\257\254\315\202\273?\336\025\344\254\251x\210?\334V\362*)(\263\277n\">B\036\300\267?\024\212a\326\034&\252\277\334N@G\313\225\255\277\001%\203\r0q\272?L\233:<\340^\221\277\265\2260\021\251\345\257?\315\032~\017\037\367\226\277\332\223>\327\010\016\246?u\373\250\005\177\256\275\277\0343,\262\241\014\271\277\243cmP\331\372z?+\327\352\356\tk\306?\006\034\033\006}\235c\277\272\027\014\016\nk\303?\336\005\341a\362\204\247?\265\205\251\262\302\374\227?\201\371u\255^\327\240\277\312\266R\300\324\014\250\277\250\323E\271\004\211\260?.\331{M\032t\273\277\007l\000\251\024y\265?\226-\234)\217\370\243?\240D[\200\252\n\225\2770>\027\350\246&\251\277m\2152\345/\344\264?\"T\215\267*;\220?b\316\341g^\004\252\277K\361b\020P\224\216?\302\3528.\271\277\244?&\340\010\342\277\251\304?\310\234\375\014\304\230\275?\377\301\231\237\2559\261?\303\277\2122\330(\264\277\331O\210(\024q\203?\212M\212C\316[\222\277s\254\214>3q\262?\025U\302\341\342\224\236?&\024\215\034\202\231\221\277\231\263\331V~\265\265?\003\302\274*\201}\271?\214\242\356\326\016c\304?^.\315vrI\223\277\365\274^,k\345\274?Wt%\2234\301\221?K\216\341\200m\350\240?g\024)\230\200;\300?\273\364D^\261\367\276\277oW3\006\362\340\304?Z_\013>Q\371\273?y\345\222\313eP\240\277\rDmjTT`\277!\243\305B\315\010\234?w\261\213\260#\032\271\277\324\277\245\031b\204\221\277~a\257\"\250\347\273?a\n~\024\337\343\253?\323\255\2048F\207\275?\006\363\276{A5\224?a\340\270\277\212<\313H\n{\263\277\007\343y\310\273\343\223?\362\002\007\256\n\312\250?\274\254\036\236\244\260\260\277bp\002\016\216x\220\277\346\343\037\267\353T\260?\237\313-h\025\377\262\277`\030\267\366\257\245\253?\017\365 \304\260X\203\277Q\3033\265\007\221\260?\206\2773\343\013\370\205\277\334\264\270\2500B\246?i\323h[\374\264\270?U\"\005\213\265;\257\277mak+\242S\272?\236:k\346\nO\273?2Ak\375\266\236\274\277\211\324E\236\376V\237?\343\217\032\252\243Cz\277\215c\325\214\001\353d?\312\024$\315G\214\242?w\335\014\343\\\366\241?NS\255=$>\304?wkf\034\371$\250?\211\005U\272\211\022\232?Gr\256\273\213\375\312?\360\014\306\212_\316V?*\323\017U\003\264\246\277 m\366W9m\240?\223\233\003\333\021\205\257\277\240g\227\307\227\360I?\004\324\217\034\217^\306?\264\267\302]\211\225\264?m^KWF\312\216\277,\022H\013\375\310\263\277*\260t/\227\373M?e\337\332\265\321x\263?\025\346\202\333\317\323\265?R\036n\002\321_\253\277u\273\311\372\227\351\277?\373\345\353\273n4\206?\r\217\352\300~}\224?(\314T {\257\257?\206\035B9\010\235\232?l\016\0008P[\315?\037\210P\'\237\213n?\010\300\363\267\263\316\275?`G@22V\250?Od\326\032\301\252\263\277q\2233\242\0073\215?V\320X\0208\362\307?\243@\205!]d\275?\3244\\\2137\346\265?\234\256Z5*\001\207?\225\223j\001v\241\263?\254\202\010\245\213-\263?\372\366\245\034\211\033\264\277\374\t\036t\257\005\246?\265\246X\342 \331k\277B\001\210\326*\017\262?\361(w\367\353\034\271?\266\342\266\254\342\301\275\277\202\321\357(\372\243\241\277Hd@|\234\315\264\277\224\306\345\000\340\252\231?\376<\337\202\327\260\272\277m\226F-\235U\250?\206+\220#q\237\277?\035\310\252\323^5\271?\324\350:\256nq\227\277\037\223o\371$\266\263\277=7!\004\214\344\261?+\237_]\316\035\301\277\3702\342\227r\253\235?jP\013\303\320\227\250\277\031I\204\202K\021\271\277\035\3227\233O\343\224?/\332\340Yi\210\263?\340c\332\222B\331\256?Rk\2531\0015\240?\201\375\204^\253\020\207?7\2532\257c\024\207\277\252F\003T\227<\270\277l\027Wd\276\020\245?\3416F\212\236\271\201?7\277>\211c!\260\277\330W\277?\347Hd\321=0\260\277\243\001\313[v*\242?T5\342\002\331\221\215\277\257\201\247@\315\277\264\2777P\206\212<_|\277\347lf3\221\247\260\277Py\314ejt\273\277\025\321\3370b\253\202\277\347\265\231OP}\250\277\227\315e\203\254l\255?\354`\t8\224$\225\277\3057\372\373\213\212\264\277kU\325\3122b\270\277\342\310\202L\"x\223\277s{m\260\006a\266?\000\214\005\\\307=\235\277\2408\357J\030\005\277\277\366|\273W\231\375C?\243\352 \250\243\024\305\277i\025\341\014U\200\264\277x\344>\343\034@\223\277\231\212j\033]\277\252\2773\322\362\365\333\230\307\277\253\350\272\004\307\232\244?\330\236\2367\202\255\252\277\261\022&>\315\277\256\277}\376\272\033\360\360\271\2777\t\317\366\263\031\264\277\354\217q\303D/\252?\023\331\252\213C`\266\277jo\201S\022\001\240?\220p\021\023w\016\274\277\201\326v\0332s\265\277\343\'\344\247<\260T?,M0\357\316\013\224\277zp>.\237\236\302\277\000R\340\207\231|\271?\373\201b\260\013\224\240?\221n\340(\023.\252\277\376\216\333\036\333K\223?\304@\274;@\220\210\277\343\356\273\330\361>\227?\212h\327\023\301\336\256?V&\007\273T\312\301\277\242K\345w\377\227\266?t\254s\325\221b\220?MYF\255\234\224\250\277\245aq(I\305\254\277D\373\201\231\261\201\262?bM\030\014?\357w?n-S\006\3566\261\277\022\203&\226;n\270?\356\227xw:A\274?\270\350\033\361\322\336\261\277\342k7\313\021\026\256\277wb\372\271\rm\277?\377\251\270/\021)\255\277\217\026\374_\006\265\224?\037\265\032\010eY\301\277\220\370\316o(\242\253\277l\365\005\376\330\312l?\025H\243N\236\234\261?\005E\245|KO\253\277\033\016bS\355\361\300\277\373ZO\303\2139\220?l\234\333\210>$\253\277\345d#?l\332\264\277\'\016,m\373\306\210\277.7\205ad#\274\277\334\027\337\347%U\270?\366A,\255 ,\223?\303\024\'%\3305\221\277\214\244\3016f\305\207\277\352\351\365\375\343\334\271?3\231f\376\335\034\265\277@\336\244\374\004\375\306\277\'a\211\200\300\\\300\277\2630W\204Z\270\230?\370<\013$\266\340\271\277\251\025\274\273x\254\301\277\n\224\352\251\\\306\243? \334\332n\246\247|?\024\272\300Qt\303\207\277\303\003\276M\207>\257?\273\025\201/\202\242\274\277\200\316\205(\210R\225\277\3258<\372\353\221\270?V\345\277S\035s\226?Y\342#\367\276\324\252\277\210\243\237u&\032@\277[!K\300\214\210\255\277\370\211rUj9\253?\033\3624\377\017\365\260?\200R \006\362|\211?\232\215\334\373\252\352\244?\311\343\270\224g\217\241\277\355\226o\244\203\n\260?~\361\024\002\205\213\277\277\274\322\321\351\\t\264\277=J\361\372kJ\246\277\324\020\340\316\r\232\245\277M\026;\354q:\267\277\315%\235<\200\204\263\277wS>\326#\365\312\277\305\237\346\031\304b\243\277,\210Y\272\026\312\305\277\220\320\375N\247\237~?-\240k5\312\233\301\277\260{z\330R\205\303\277\301#\004<\225\016\206\277\241\001x\326\004S\255?\215\343\3160cQ\256\277\324\316\324\021\026;\244\277\3553\213\002\255\321\263\277Z<\367\255\365y\257\277\344j\202to\346\227\277\177w8\177m8\224\277\236-q^4du\277\242i\326\366\313\267\305?e\322\376\034\016\033\200\277\216\367C0\246\022\253\277\tx\002\314\374A\275?!/,\367\225\254D\277\362+\236\203\373\211\234\277\202\364\235\227R+\205?\231\244\205\226\207D\223\277\272=\262\332`k\251?\350o\352\245\r\233\217?\255\234\023\373\363:\202?\223yeu\342\022\246?M6\002\351\323K\247?\375d\026{\317O\250?\200\275e\205j\247\250?\374\0032Ym\225D?\353>\016\377|\335\247?\031\272\t{zw\264?\207\234x\013z\272\235?\374\013\270\366Y7\243\277\347\345s\207(\331\250\277\255\342#\336{\324\301?\214\"\232g\372C\253\277\242\001\246\254\253\237\245?~s\322\005ZY\270\277\257\245\213\322\362\244\270\277dL\251\265]\036{\277vmk\346]\037\237?\241c\220\027y\311\240?\0103\205\373\036\252\203?u*I\003\236\233\223?\243h\002%\346\244\244?\002\202\224\037c\344\246?e\230\001V\333K\273?\365\377\236\034\355W\301\277\366\343n@\215\274\264?46=\024\326C\252?j\361S\344\365;\256\277e\337\311\351\347P\261\277\004\270\245\001\n\203\225?\317Z\210K5\363\215\277\217\007\361a\256\301\264\277\274\325\312j\001_\246?\020\270\270\325\306\247\261\2772\363\304Ox,\273\277\314\352\365\210\261f\245?\357\\\262\317\022\365\245\277\004\231\025\275\261\n\264?\013\365\t\246\016\333\256?\216\0077\305\200f\267?o\311mij\\\241\277w\260\026\270\035\364\257\277^\235\241\374\352\216\243\277\031\037\367\244nO\263?VE\255\346+\020\244?\027\223\347\352T\014\263\277\222\277,}Ve\240\277\202V\244\2126?\233\277c\304.\260|\376\255?\346\203\340<\202\"\270\277c\240\347I\270\267\273\277\300\322\342\353QS\213?\303\212|\226\271\257\212?K\276\237h\241;\213\277\314\223&P(/\210\277P\355\322\232\250\354\240?c\263\304v\203\202\260\277c~\343\023\275m\311\277A\025\236\354\006\227\300?\"\206X\246\314\273\273\2779+\016\321L\036\214\277D\221U\272\305)\272\277\250\353cL\325r\264?#\364\177\225\241\243\263\277\316\032\335\231%\020\274?\227\232\222\311\024I\255?t\276\255\027v\352\301?4\177\211l\351\334\251\277\307nJ\006\t\205\267\277\000H\255?e\357\274\277\216(\341(\331_\262?\235\\\037N\260\324\264\277*@ \362\\\277\254?\357{\374bP\332\274\277\346us#\333D\256?\303\317\005\n[\026\265\277\324U\264\217\311\206\264\277-\213\"\236\250\356\252?1\376\225\263%v\247?s\017\256vz\247\266\277\265\017\335\301%\273\220?\213\330\270\253\337\263\246?(3\347[\007W\264?\255E\023\005\030z\275\277\243\246+\242\306\235w?\361\270\217\276\261\346z?\301\303\003\014\270\341\241\277\031\242Y\314a\360\244?i\230I\350\216\006\260?\262\203\342\032\264N\252\277n\021\223\031\n\302\224\277\310\023\031\200\301\254\267\277\215\314\000g9\247\241?/E\253\376\276k\267\277a\317\361\316X\276\245\277\332\237\331\327\340\377\241\277\\\215/V^\312y?\305\304S\026\302\235\244\277\315\254\376\215g\006\244?3]\r\255\276\212\212\277|&H\370=\227\314\277\351/3\227\233G\224\277\020\376\367\277=\355\275\277L\270\375\345\001W\265\277H\227\367\342|k\303\277\032\256\326\304\207\364\230?\234\3044\3541\005|\277\2609\230\264\234e\261\277\213.\253HMc\267?\354>/6i\354\237?\344I\344\033\032t\233?\330`\275\200\n^\220\277\232Z\204\366\376\225\260?\304\201\002\340\360jt\277\210\032\237\356\343R\255\277\275>\013\367\366<\300\277\255K\277\202\216\346\252\277\375Z\231#Q\013\264?\247\201SY\373\246\214?L\004\227\353F\216\226?\177\370\306\216Q\200\261\277\014\220\274\333\227\311\214\277Ud|$\033\037\264\277\"`\303\033I\334\273?/\025\371\313\272\003\232?\317\304l2Z\211\202?X\353\215\370\372\221\232?\223\233\220\247J0\271\277\212\275\204\236\211^\260\277\334\220\033A\004\ro?\007Y\010\302)\020\311\277#3\265\231\342}\244?\222R\243t\t\330\266?qi\203\2752\345\220?E\027\262\326\315\252\251?:\350(,0\213\261?F\342\335\374\025\n\244?\322\320\260V\273\026\271\277\241\r6\265\007\024\260\277Y\335\361\270\377\233\235\277\237uF\022\0251\244\277kK\263\020E\300\267\277\276\361\275\205\211%\256\2779\306\037H\340\320q?[\021U\341\250\321\221\277\273#\230\207m2\264?\224\340\000\200G\035\207?\236\247\320\362\221\215\263\277\254\373;A\346\213\264\277\261\346\266\372\007\255\240?\334\234\213k\003K\240\277\314\244](\341\264\264\277\021\311\255\177o\363\257?\000Y\267\3535\030\247\277\341\007\005\373^\'\276\277\276\"\361\266~\326\276?\271\0148\317\241\260\216?\031U\256\037\313|\264\277Z\351i\235\326\207\212\277;`\255\001@\264[?\203b\036\233*%\306\277\327\303\035(\360T\304\277\345,\\E\266\"\267\277\310R=m\033y\212?m\307\346\202[\237\365\276\336IW \000)\305\277\352=n\242\217_\203\277\022\2762\326e\374\246?( \360N6\023\231?\004\326\230{\272s\254?\\&\263C\205=\302?\257]uh\365\001\257\277\273\256\325BT\367\223\277\223\'wu\177c\231?\347\2060%\234\317\246?\006\320\253\322\236&\244?\344\357!K\347}{?\2442\014r\327\031\304?P\215\361H\030\307\270?<\226\n\201\366\245\245?\304I\362\035\354\200\240\277\307\356\373U\251f\265\277\364f\006\234\002\337\265\277H\327\350-OU\242?\356q\363\274\226\341\273\277DQ\257\226:0\310\277I\361\314\'V\032y\277:\035\254U\320D\253\277\25234\252\242m\271\277\254\333\307Eo\253\300\277\262%l\030-)\265\277\002G%!iN\235\277G\300f\017f5\234\277(\250F\235\356Z\204\277w\035+k\323(\273?T\216mC\002\345\255\277\205\316\373\324\302\"\257?\266\325\272,\360\000\224\277\353^\354^\271\022\307\277K\025\256\036\017\260\264\277yC_\221eW\230?\331\320D\343m\010\205?\364\344\321\204N\004\276\277\322\2102\036\376\273\206?\333KhJ\360*\227?\036~\317\221\206\273\251?A\027\264\246s\210r?\017\202e\201\351\341\204\277L^\260\370\033\321\237\277\024S\22399T_\277\337\017r@\004 \177\277\247\025\263Q4\003\220?\013j\334\r\"\035\274\277/;\200\272u\360\246?aR;\037,\344d\277Y\027\313Wq\016A\277\'\344\246\322Z\023\262?\356\r\201\262\371\273\260\277\236{\233t\320\371\245\277~\2408\030\3666\275?\227\3267\332\354\017\272\277\216D\177\005bt\276\277\356\034]\320\014\350\203?\026\256\014\261Z\t\266\277\t\315H\316 \250\244?\230l\rR\235\375\223?\277\242\244R\245\355\274\277L\224\221\257\331/\273\277\006\0223,ip\275\277x\365\251\334l\004\266\277\201:\302\336k\311\254?\254S\017_\340\026\204\277\274\372!\202\372\345\202?_\356G<\254\355\305\277OQ\325\273\356\201\261\277\246\255\270\305\362;\242\277Yl\225\321\025\253\273?\024[\321\222o]\272\277|vZ\006\341B\237\277\217<\315X\367[\207\277:O\332/\204\236\252?\\\241\266\377\233\310\261\277\306\314\326zq\365\271\277l?\241\264\323\177\232\277\215\257g\330\306@\303\277G8\231\314\356\366\254\277\341\024\234&\007\245\226\277J\027\014\016\314\001\256?\031\341/x\r\021\236?\363O\000\201}@\276\277\025\214M\245Z\201\261\277\247K\266\343\227Y\267\277\025\204\342\204\311\243\251?\020\325\242[-\277\257?\261\370\244|\353\261\261\277\363\032N\277\270M\312\277-I\007=\310\201\242\2779H\323jy\366\276\277\334M\354\216\235$\237\277\306\217q/\263T\250?f\205\001\2263\025\270\277yw\371\222\321/\223\2771c\245\333\307\242\252\277\202d~A\370%\274?\216\237\373\354#\332\300\277\r1\332\n\2346\224?C\244\264\022\264\017\263?\026\3008\302\347/\264?Cd>\002\213\246t?\215\311\275nsc\273\277f\324?F\273\016\271\277\250x\212^\027\233\267\277\356\351\r\271u3\242\277\245\354x\362T\235\267\277\355\236r\324C&\211?\255v\031\253\005\260\270\277\374\376\203\tCm\254?\003\254\327\014\203f\247\277\256\351\332\215cb\244?z\241\037\230\005\315\241\277N\240\262X\206P^\277\206\227\356v\356\016\275?,\277\021\201\314\273\240\277\265o\254\315f\302\242?u\024D\366/4\227\277\207xJ\022\"\261\257\277YRH\371\0254\300\277\331\231\253\205\242C\246\277\354\332.\3258\030\241\277U{\244g\321\351\305\277,)W\020\202\371w\277F\262{vb\025\244\277\262\'\210J=\267\302?\275\037Q#_\275\306\277\230$\233\244`\211\241?I\263\234\347=h\255\277Y\017\021\nJ\337\247?&\277\013{\326\252\243\277\344\357Z\302\273\316\233?&(\355I\t\276\252?\311B^\026p\035\270?\0249\243\210)\335\244?\023VB?X\343\206?by\35584Ix\277\320\360\3126\3270\253\277&\252o\"\273\274\244\277B\302\202wV\251\275?\341\340\005%\031h\301?\007F= p\010\260\277\021\026D\215\203\300\265?\343#c\320\375\330\263\277\272hY\365\317\025\237\2770\221\317\002\263v\244?\3540\300\n0j\250\277\006\300\025\024oO\270\277\321\360\342\200yl\270?\237\024H~\206\362\254\277\217\331\334\354\214\'}\277\330\337?b\030\342\264?[\303\365`\223:\227\277\331\215\365\270U\033\205?\257\345\237\003B_\241?\256Wa\031\357z\206\277\256\013\350\033=\232\251?\343,`\023\334\243\241\277a\332\014?U\361\300?\3635%\337\341(\225?\023m\312\017\0367\231\277Z\206\255\376\265\260\222?\221[\324\217\272O\235?\027\207u$\273W\302?\2044\326\315C\345\230\277V\355\027F\024@\214\277\030\232s\271G\214\222?Ruk\307w\324\270?\226\371=!\005\226\266\277\266\016\017\331z\243\304?\035\026{Y\261\320\227\277\230<\\\372\025l\275\277\t\036\332@\236\266\260?O\206P\341\230\\\207\277\334\347\036d\371\312\240?\251m\360\000\304\257\244?*\t\330\320\033y\311?\031\006\361!$\211\256\277\302\306S\230\216\300\205?\235\025\215-\231\204\260?Q\030L\270\2769\251?;\312\235\212\002=\244\277Zp\307\036\004)`\277\275z\315\017\254\215\262?\267\273K\r\372\250\251?\275\256\346\211\327\035\254?\212\305\273\262&g\273?\233T!\033\005\212r\277f\244\025\277*\233\233?\010\223/\311\324X\266\277\236Pa\373U\311\203?f\304\272\361\225|\216\277\034=&\035\220:\270?\026\210m\347\371\253\250?\254\273}\366h\n\253?\266%P\301h\240\300?\367\337\001`\"iw\277\027$\305\271\270\001N\277-\301\365\014\345\017\224?\202e;/\266\250\254?\n\266\257\232\225Gr?\n)\206\370t\260\222?z\257ob\010\027\234?%Bh\344\223\364\271?7\327C\312=\247\277\277#\204\360cI\204\251?Hd\317Z\351>\274\277\003\316\206\315\217\216\255\277:\205\244\257\225\305\263?\263\370J(\005h\240\277\2240@zZ\246\244\277L\027\364\013x\260\261?S:l\366kj\302\277{9\264\333U%{?:\223\311\245\321_\252\277\262+\032c\300\327\271\277\333>\000W\204\\\305?PP\230\210>2\253?e\365\250\017\255\217\253\277E\264\275wE\036\224\277Y\202\"Kr\313\262?\007{HT\237\206\260?]\242+\311\320\024\265?3G\317\303\025\220\300?\367\266\265\245\007c\212?\226~\362]\302\302\275?o\3014\372\031q\266?\352\'\355\362\365\362\272\277\r_\017>\211\366y\277\230\365\307\271\321\246\273\277\335\001\337\023^G\305?\352\247\237\335;\372\302?\2605\366$\331\260\246?q\330\306\254q\232\232?\230\356\263\312\377\202\274?S\350|\346L\314\213\277\376s\025\202\2276\300?\347\260\027\324X\321\210?\332%bf\300\036\234\277\013\2443,6y\273?\325M\207t\204\302\264?\237Z\356cy\240\254\277Zo\271R\033\350\251?\310\3056\251m0\222?\211\002\343O\000\307\265?\013\270\322\302\263K\240?\364Q\210\230\021\022\273?~\013\353Z\n\337\267?\\\030~7\230\354\302?\264OWD\032\356\243?|\027l\020J\331\240\277\342\\\025\207aX\223\277\320\277E?\237\250C?\246 `\nE\244\235\277E\252\210\373\311b\304\277\203\266\342\371K)\225?G\313\022\215>L\243\277g\002\264^\327r\257\277\266n\223epJ\255?\251{\273\342\365\364\262?\371\353\230/\320]\272\277\263(>\245\3505\231?\341R\331\311\367\254~?j\0274\'\337`\301?k\311I\367\212R\253?2\203\377\213\3179\261?\262\263\315A\006\354#?%\304\273t\0209\254?\007u\250\355\021\233\235?y\034\214~\260R\246\277\315\207\036\253\212\234\236?M\352\323\037\260\244\202?g8}3\271w\246?\312g\272\013\022\016\240\277L\314{*;-X\277(\353\340n%c\216\277x\313\224\316\230\361\266?\213\252\327\247vu\205\277\312mv\364G\371\200\277\3651\267J\323\347\255?\033\202H\265\376D\266\277\2367Q\250IL\272?\\\311\337\241\262\034\244?\322{\'l|s\227?\312\257f\321\250B\246?\215\327\020\322Jz\273?\377?\006lL\036\306?\347W\362xQ\253\257?4vIU\342GU\277sj\027\377\022\002\236?\n\003\365!\002&\263?\313\3254\026!(\234\277\320D\264\'\025\334\226\277\n\2758\027\230\307\232?e\237\330\233\207]\254?\027\226\231\331\221f\207?\233\356\324\234k\277\271\277j\353\310?*\225\242?\370\013\014t\257\025\202?\352\010\010q\314\372\265?q\317#\352R\223\314?\022\377@\337\204\322\236\277g\2521\263SL\260?\256\340[%\017f\276?E\317)<\030s\265?0\303\227\037l\350\227?\251\276\352O\004\r\211\277$\2557\214\201\316\300?\336\354?\221s\032\304?I\034\224\217\260 \242?\274\224\035`\241w\250\277\264C\321<\222ak\277X\201\332\034\025\367\235\277n\000X`\245\317\276?\273\037\320\203\3445\245\277\302\271\336U\303\235[?)\360}\315\2175\246?V\002\031d\343t\211?\272\261\352|\372m\264?\220\235\277\334\325q\300?\335\374oq=\317\260?\205$\363Q{\311\253?\032\211p\017\326\246\250\277W\343\2772$\274\267\277\027\013\232\205=\312\302?\233\260d\372\222\245\217?<(\354\251\317 \224?\243\277\007Ia\306\305?N\324\257\214\'\255\203\277r\316W\026\275\202\300?\353\276\231\357M\027\244?j\2422\317\177\207\266?\351\324z\247\320\266\274?\265\335\200\212$\274\271\277\303\3114 \353\201c\277\025\305\\V\333\221x\277\245\260\300+\330Q\245\277\013lK\370\010&\270\2778+\303\317\007t\233\277\222OgV]t\251?f!\021~\036l\225\277\300\207\252V\305\262\203?\324&\260\370\027v\267?;4\346b\213\333\302?\323Po\350\036\334\253?\347Xh\221p\014\265?\276>UT\247v\312\277\310\316\312\024\224\376\222\277n]\226p\'*\263?\025\252\201a\377\374t?\024<\236\330\367\277\260\277\261\213\302q7\300\245\277\324\326t\006\345\313\255?\376X$\360\372f\245\277\3317<\302\211\361\247?5\370\342\005&b\270??Z3\016\365\224\215\277\333\236\nrO\364\230?M\340H\020\022\036\260??\276\357\246Tn\265?\336\347\367\2616\266\274\277\320\312\r\177\\\304\231\277o\003\212<\333\021\247\277`\361\216*>\036\270?bN\333u\032.\227?\202(\030o\377S\260?\210\306\027?:\233\275?5\317wVW\242\210\277\022\030\022:\374{e?\202\300\242E\000\216\241?\014X\2172\275\274\261\2771\304\322\3679\354\206\277\226\000W\003\371J\241?\212\017\245\303\361\004u\277\206p\374\320C~\222??\021%\217e!\300\277\260\203\'\337\334\242\212\277\n\t90\217\366\262?<\210\275\377\303\310\233?\2645\321#\376\244\244\277\231\360\257\354\347\315\244\277X\261\245(\\\320\226?\340\3323\212\361\016\266\277\005\305>j\376\016\260\277\341\234oD\'\331\223?\306d\334Wz\215\245\277\221=\020\245g`\201?\257;\374>\027U\262\277\357\013\324x\023\377\260?\235l\364\r\220\224\270\277A\007U\210\2622\305\2771\372,\243\250\251\245\277.e\205\314\3648\257\277%\030\270 \252Fh\277\304\313\014\361\263\n\246?\323\310f4$\335\233\277\244\263^\350\263\022\261?_\220\300\227\017U\263?\210\231\202\265\265\361\256\277\304\013Lwl\235\260?J<\004\000\'+\251?\254\0356\342\201l\264\277\271x~\3054?\261?\356N\246\243\316\t\261\277\314P\363y\207\353\221?\377_bm\243c\274?\33744\361`\213\263\277\351ta`\256\r\260?\376T\277j\275\031\251\277TX\n\241\213\360\241\277\270\\\340*\225\316\243?\'\200\212\225\235\305\225?\247\237\236\257\2738\260\277\271\355\345\364\030R\302\2773\214\372\024\270\344\263?g\244_\252[9i\277\002\307H\014v%\273\277\013\264ao\372R\274\277\225\247\356\010\313\007\211?\3101\010\314\252 U?\t\327\002\037\316?\263?\370d\310[\2269\265?\006t\002\362\313\204\261\277\345\2401~\244A\277?\0263\016\345zB\254\277\217G]5\202}\265\2771\211\363%.\316\240?\000\371P\026Y\014\262\277\036^\262\010E\312\261\277\'\236\333\217y\242\204\277d\021\233\202\252\254\261\277\003\233S\353U\nD?\302l\363/\031\221\241?[c\220hZ\020\251\277JF\007\006\305\004i\277b9\313\337cf\257\277\220\223S\002\205y\273\277\217\355\357\031\356f\244\277\315\371\261\374+\265\274\277\272\302tW\271F\246\277\202B*\002P\356\260\277\3331\337zk\333\234?\367\233+\210\321\335\265\277\2471\232Q\217\353\273?e\220!\243\035\274\222\277\'\221m\344v\227\230?\326\371\352uc\375\252?Ak\312\014\226\347\260\277\030\326\032\004\\\311\220\277\343]\016\347V\013\220\277\0231\227\252z\007\217?\000qn\375\273\323\226?\nG\020+A\235\231\277\332\3250Y\225]\301\277\232\363:\3703Zp\277\376\273\353\375x\314\253?o\314H\274\334l\245?=\213\246\307\3177\235?\202\034r.\245\211\232?_K\217\311\317\347`?`\320x\037\317\277\251?P\2410\233|\370\202\277\2722XSe\252\237?\2646\273\026\345\315\266\277\361\220\031\201\351\212\231?\0167>\256i\210\242?\234\370\345\257\242\017s?\300\001\203\363\'\016\237?\201\210}F\001$\217?\227\242\375\320\227\262\277?\264\377\246\256m\003\252\277\n\330_\2604l\202?\330\323\362\340jL\224\277#$\220\210\210\330\260\277\257$\354\240\010N\250\277t\nl\177\217\374k\277DN\347\235\204v\264?\211\301\302Q?\314\275\277\343\352L\370+\226\237\277.C)\035D\267\273?\346\307\213Ow\273\257\2777\346\260Qvc\276\277\367m\026\217A6\270\277n\35451\267\314\234?\304A\370l]\271\302\277\3156\340s\261&\244?\367c\334P\327H\270\277\341E3\367Kg\262\277d\365)\374\267V[?\306@\016\007\334\001\\?b:\r\353\256\224\274\277\007\017}\313k\036\261?\273\313h9\270\230\257?\362\352\000t\203\271\243\277@\277\233i\251:\264\277\2247\001c\264q\211\277\225Q\320\301\307\214\241\277\356&\201\243\013\003\214?N\030pH\355V\301\277\212\212\370w\243\346\267\277T\'j\310}\016\242?\272d\204\267\206\035\222?Ag\362\257Z\203\260?\255\220\33672e\250?\304\370|\371K\230\257?BEK\237\204\031\244?\324\336.`\310[\205?(7\2716\031\206\215\277`\306-\014Z\004\262?\221\244\201\346\326)\265?\213\016\034^\236r\264\277\"\273;\235k\221\243\277X\t\237>P\030\221\277\374f\252\0238\365\261\277\246T\332\360Y\276\220?\teV)\331 \274\277\252P\022\272k;\301\277\366\222W\317\232l\253?F\315Z\217f\026\272\277\341`IP\315\327\036\277b&\361<\005\210\221?\360\001Q\362\343$\225\277\314w\207\316\322\254\265\277,RO\301\2315\253\277PV4\272#*\272?\266\311f\366\352\237u?\220\232]Q\017c\275?\016\247\341a\214t\265\277\277\031Q\222\244w\275?\t\3467\022\302\014\227?\032\323\304\2158{\016?\232G\204\372\376P\236\277\372Dz\372\346\313\266?\354!\377@Y\326j?\217\371\363C==\262?:\001o\363\355\242\312\2779\000\237?;\365\240\277\241\331\211\347\022D\242\277\206-\336\216W\230\250\277\347\304\207\242\356\324\232\277\315 N\241\205k\224?kwE\270\260\224\272?\366l\217k\351\312\260\277\356\317z\0057Ja\277Q\243k\2035\025\241?(\273\030\207>\272\277\277\342\203l\002\254j\302\277\002>\352\267\300U\213?\t\301\222\351j\'\256?\177>\317U\264\303\265\277\304]9\037\305\202\261\277\226\004M\262\3503\276?\273\326Z\216}\254\261?M\334\343\322RV\213\277?]2\250\007T\245\277\306D\360\234\376;\243?6U\261QE\217\217?\r\337\203\213\332\337\265\277@\345\331\0173\037\274\277\305]\317|$\262\232?\030\320r\327\307)\257\277\\V\247v\363\364&?\373\2610\373\264\020\267\277${\007\223.\302\265\277W\246y\212\342\253\220\277/\220JaN:\244?\036\253)Ak\207\300\277A\354x\341.1\200\277\003\260\211j\342[\241\2776\2221\375#\350\232\277\226\300k\314\226\304\266\277i\236q\334\265\253W?\037v\216\0100\364\245\277\336\311DH-j\254?\364\350\262\217\230\247\245\277X\247%K^\230\246\277\304]\'\366.{\247?\363\215\257p\265M\253\277\002\333\277\314\251\017\273\277D\366\0045\230*\266?\014sK.\373T\226?Q7?\356\317k\240?\265\342\344\223g@\267\277\261,\267\345B\330s?\303\003\215<\000\206\212\277\343\007W\202\374-\233?\360\311n\303\177\313\254?\026-?TD\376\241\277\240\332\033\317_\035\277\277Y\261\204\254\247\236\200?LEn\222j\236\233?`\372\235\236\343\327\234\277\315\235\311\326AW\261?\246\005\205S\340{t\277\035\222\264\3260\306\241?z\230\257\366\224V\217?\335\250\253\"\035b\224?5\002\201\250\375\252\262\277\215\000\237\267{\200\236\277SM\256\331\363\207r\277\007\000@\273d\301\251?\307\314\245\025\031Z\242?R\227X\304_\245\235\277B\202y\250\004\233\216\277\370\245\'\306\006@\261?y\274L\266\217\224\226?\r^^\277W\002\256\277\322|)\361\352\032\263\277[\270\023\305\375\253\272?\355g%\003\3521\251?\346\321#\331\355k\222?WI\320\233e\331\260?\005\357\'\351\245)\261?XA5\227\367P\245?\\{\010i\314\214\260\277\271\263\343&|\213\274?\251\005\022\035\004\236\204\277\251r\272\2059p\247\277\341xq\225z\362\240?\t=\234j`\342\265?\353\037J\341\322\360\220\277\336\331UT\353o\236\277\016\214\277\351\322\267\202?\371\031\311_l%\224?\300\355\177\335\241\206\267?\270\227:Tt\263\242\277\'\202\312\245XJ\302?1l8\300@\253n\277H%\005U\362F\272?\311\023\313TiQ\270\277Q$\035\227\235\001\221?d\240\375\202\316\025\211?\242C\3232\036\264\266\277\337s\240;\2255\201??rz)`\212\237?\276\343Rp[Q\203\277tH\350o\252Aw\277\367\350%\007\275\300\240\277\354\034\024\203\320\365\213?\241\345\003\267\360V\265?\021/eHYH\300\277\366\240^vS\376\251?\200\274?v\267\375\246\277\033A\376\371\006\036\247?\213\205\242\215\3065\240?\274\372\226|\303\246\263\277 \217\203_}$\224\277\024\t\030\336_O\302\277Q\310A\343q7\313\277\352H\241\246B\032\256\2771\000\313\302\001o\274\277x\000\265\316\031\253\230\27750U\212\214\234\232\277m\021\221\200\222\240\301\277L\360\n\324\005\220\270\277E\200 o\246\035\232?]\2163\213v\014\301\277\234\'\273\207\363\037\244\277o\326\342*3\352\255\277\367N\264\263I(\'?\222f\247\324/O\270?\030\316\357^J\355\230?\000\272?\303q\355\346_\343\263\277\253v\262\001\372\260\257\277\327\337P\300\367A\305?\372]\317d\205\331`\277E\321#*\003\254\225?+\3156\013\311\237\237?;D\302(\027\353\232\277\t\203\226\226A\021\214\277\332\360h\201s\337\272?\0201]/\213\207\303?\350\201\250k\222v\274?\016\261\346R!\340\270\277\246.\016\272fX\240?^%\325\016\203u\265\277\007\024\214.M!\223?gF\273\253\367\271\224?\207@\370\315R\337\267\277\010u\224:\203;\264\277\342\323o\303\364F\304\277\037\302 \317\330\350\262\277\204\367\315!\346\201\254\277\242\034\232\315\237*\263\277!\354*\217d\354\234?\230R\375C\230C\264\277\031\316t\354^\002\301\277w0!\311c\021\252\277\244\000Qd\007\372\226?\217\372\264\265\217\230\251\277\362M\274\243+\267\307\277\035N0\177m\371\307\277^\232\340C\200\247\320\277B\022\264}\344\230\312\277j\213\017\226\216\375\304\277\033\324\327\204\317\326\265\277\373\225\371b\2703\303\277O\220nz\223}\310\277[}U\006PT\262\277\364\330;_\264g\200?\tf\273=\000$\304\277\302\340\353\306\200\017\305\277+q\222\374\325\273\256\277\213@\2671{\237\245\277j\250\337\235Z\241\302\277\365\032\261\214\':\223\277B\n\025*<\316\306\277q>N\223;\243\245\277\355\263\007\235\310\363\253?R\345\036{g\"\252?_6G\341,t\256?\315d\201\223\354\031\253?\204\251\335\325\361p\237?\006\334,\362\225`\243?\013\004I\371r^\306?;\2126)\\\210\272?\247(Ho\321\004\303?i\002\221fj8\254?\331\300^\016\234m\207?J\372-\377\371\342\306?\251\317\n\333\361\355\275?\211\247\337\221\313z\252?\357\177\344\371\010u\305?u{E\031cK\322?\235\363\211\363:&\270?\326%\0303\214}\302?\374\312\373\363\363\"\301?I\241b\021\303\255\305?\375)\365\222.\221\273?\230\312\311\232\177y\306?r\360C@.\301\311?c\267\253\2339\312\301?Mq\213\366\362\314\267?i!\345-\354\207\266?\233\037\213\302\025\234\243\277\253\365a6&\213\231?\231\253\271\360\324X\274?i\371`2\315\232\260?\224 &%8\005\217\277rEcB\250\345\232\277\202\024*\223\230h\307\277\212\225a\341\350.\310\277\005\237\351L]\340\300\277\034h\317q\234/\234\277\347\204e\\(\214k\277\010\025g\353\2435\213\277\351\373@\366\022\201\244\277v\024\016\024\262L\256\277\3521\303\201\234\255\240\277\317\243w\341F\220\203?\356\201\233\014\3663J?\0231]\240\266\245\265\277\036\310P\205e*\265\277Fk?\035\262\260\303\277\303Q\311\336Vm\300\277e\362:\027b\372\310\277\240\323w\351N\276\303\277\031\207~\347\340\002\263\277\004\016\357\252\006\227x\277=\230\304D\317\225\234\277\'\221*\022\274\362\235\277\036\363{\214\370J\226?9\366\307\244\245o\276\277\243\360Nv\366\354\236\277z\231K\261\370X\245?z\223V\003\343\213\261\277m#s\004\346\2127\277Z4\234\261\324\313\226?\364\242\231\263d3\225\277\355\272Uu\234G\227\277\213\367:k!\335\270\277#tYt\345$\236\277\317\217H\227a\363\257\277\204\275\220\222\010\"\277\277n\311\247\330\304\277\222\277\"R\253\334\357\270\251\277<\322\274c\232\036\241?\305\034Vw)\366\224?!\036\337O\'Y\225\277y\360a\375\370\355\235?\353\217N\307\343&\300\277\257K\255\365\225\320b?\203K%\307\203\177\247\277\275\243\t\225\000{\241\277\355\227N\253\354\005{\277F\010\217\263L:\311?\021\330,\237f\240\241?\262\365\203]\335\237\265?*\263z\010\010B\211?\210\235\245\271\202\2707?\271\224.@\t\374\256?v\301[\266_\030\216?\003/ \207\246\353\257?\264\257u\321\2711\261?\225m\026\37334\241\277m\3757A\025;\240?\373w\340\234/\000\263?\347\205\256\370\355\231\243\277.\231l\000\322z\233?\360\264\002\007\374ox\277\353\344\266\027\314-\227?(\024\222\364oX\252?q\325\022\376\034\236\271\277\215\313\010\221$<\235\277\2365\211\237\021`\232?p\003\275y\254\212\273?y/\347\334~\033\300?\025\325\320\337\364\355\235?r\005@\316\232\241\241\277M\310\241\031\000\307\251\277\267\322\271\005\217vr\277\020T\222-\3351\222?\241\241j\032J$\254\277\356Q^\032\\\246\235\277\371&_l\211\351\250\277\036\275\"\347\005q\247\277\261\343\252\361\332\325\303?\262=fP\377B\241\277\220\214\244$\304\236\272\277\252\265K\262.\205\240?y\023\334\237\0375\241?\205\346]\303a\327\262?\3107\377\'e\213\264\277\017\262\307x\311d\205\277\213\327;\r\001\236\271\277<\265\333s_b\300\277`z\037>\206\302\242\277\323\366\272\311\253\274\246?\300\tf\247o\243\272\277\364\202\216\r\262\353\227\277\311\203\250\237\353^\266?~\327\261\017\315\277u\277\333\267#\232ux\246\277\022l9h\237d\231\277\346[\033\320\'\264k\277\331@\002C\3205\313\277F^>\024\333\001\230?\"\306\314\003\315\357\247?\323\241\3245\231V\202?ax\034\331\315\257\257\277\235\003\262\356\241\330\232?\302\251@|\225I\306\277\344\302\245OF\037\224\277l7\205a\2149\250\277\230\253\225\351{G\274\277V\362hP\357\255\232\277\\\203\010!=5\300\277\306\354\336\302\375\316\263\277\326o\253\333\302J\204?\367\203\277\361\333\355\245?\216B\347\300\274\016\243\277\263\023\031\016\001\326\240?\227\315A\307zn\245\277\306D\234\335I\033\242\277]U\343W\323T\223\277V\275\017\216rx\262?\006Z\331$\260\026\270?\263\000\306-s\354c?\312\305\252\300C\260\226?i\343\345\243\276\014\271?\337,\016.\r<\262?\022\353T7\377\261\271?G0\344Y\214z\276?\250\315\262m\226\177d?\312\260\264\277\345\230x?\327F\347\251\240\007\263\277\016(\035\234\240\232\222?\373\032\034\222cYz\277\205~\2352\264\333\252\2774\201\\\261\n|\245\277\316l<\rk\237\242\277\203C\325\333G\000\262?g@E\204=\223\263?\233W\252+\362%U\277|\'+;P\232\266?\266\336\312\240h_\273\277,\336\221D\264\261\303?\323u\202P\035>\242?6\240\337XQL\223\277q\365\224\347\333\016\267?\217]\357U:\232\261\277\nU\223\037ym\260\277o\300\342#\321\272P\277\217\\R\276\\\023\265?\032\320k2\374\334\255?\202\240\351\020\007c\260\277\004gx\"\"k\240\277rz\237(hp\261\277\024,vz0\206\255?\213\273\031\353YO\206\277j7\373\320\010\'\201\277gl\376\272\230\224\243?U\242i\236+\323\270?\221\035Pf\001=\246\277\"\211\245\202\005\225\272?\327\201\272\253&\"\251?\207\327\256\022p\217\267?\242o\263\177\264\330\255?!\336\240\337\343\035\262?\300T\311\304\215\341\261\277Y\"\276n\217\233\266?\000\247\301\325;\314\255\277Z>d&0:\253\277\252d9b\216\202\302?\245_-\310i\205\261\2771>\212\242\251J\247?S\335\\\347\214\324\261?\374{\017)U\n\266?\316\010M\262?b\255?\370\320w\336\021\370\220\277\305y\311\233\266_\256?\224\204ha\225\345\270\277\261\177R\010h\232\245\277\027\201\242?G,}\312\335\000\204?L\207X\263(\006\242\277\271\207\rL\255Aj\277\206\307\034\t\2350\244?\341\346\262P\330\025\243?\357\373azx\335\273?f\035\\\034>\203\210?\373\363\275`E\215\266?\037\313\3174U\230\270\277\"\027\004\007\317\222\204?-\027\304\372\361\033\253?\213\035`\243\206\027N?%8+x\361\223\266?\246\204\356\307n\346a\277\211\357\2505\224\203\252\277,DS\316\223c\274?T\305\261eI0\247\277\211F\355\240S\336\255\277Y\305V9*j\264?;\206\312c\317I\255?\267\232\344\254V\004\270\277\355[\031\3543\274\254\277\336\256X\260F\036\233?G\340\352s\236w\300?\005\024k\010)\306\263?\340\311>S\203\252\300?\330\224\355\333\376\244n?Rd\026R\376v\315?\363X|\245\367i\267?D{M0\350(\227\277\310c\222\237\335\037\243\277\347fr\371\300W\267\277h\022\3768\003\337\312?\346W\223kR\014\265?$\327\207f\377\212\237\277\353*\010\374\'\243\264?\207+\374?\343\252\275?\340\247I\271\345\206\244?\362=\235k\036\277\270?\315\023\374d\023\344\256\277\223\331GJ0J\240\277l\3374\354\323\021\244?\244X\202\006~\215\255?\215\221}I\374\345\255?\345j\346Jv\255\211?\r\\\313\026i;\257?>\320\265\262!\207\241?\254\331\223\232(\351\247\277\315\260\r\225W\211\220?>\017\216i\223E\245?\274\311\327\226\356\005\236?w\314\245\215L\361z?\206\320\271\227\253\233\250\2776\0064\0040\352\253?\377\343*1^\223\262?\247Sl\346f\035\260\2777Hr\226\031\346\226\277JK\005\227\315\266d?\261t\231\030s\356\337\276\313\370\"=\377\031\303\277\247M\367\320O\331\177?Rr\327~U\250|?\003u\262\326\360R\257\277\314\260\237\345QY\253\277\354\253{A%\272\225?\320*\375t\035\247\220?\217\0238\274\314\355\261\277\223EJq\266:\251\277\367M\334\371\261\262\227?Pc\245\324Z\030\262?\356\232\3226\242\211\260?6\313\355\365\326]\300?\360\353\372\352\206\213\261?\263\320r\026\251\343\272?\3325\021Iw\347\306?5\326\343\272\303\253\274?(\nT\tE\212\242?\014\222\205\013\240\271\241\277v\203\351\361\370d\240?`\266\016\025\376\371\243\277\240q\227\243.\254\273\277+\350\257\270_\343\274?\336q\212\361{:\236\277\306\371\017\017@]\277?\251\211\227\265\203\203\177\277\235\255\327\364\221\\\300\277\267\236p\330\353n\246?\266\033\223g5\343\302?\365m.\005\235\337\222?y\3132gV4\230\277<\007t\270I\356\222\277X\255\023v4q\247\277\354\350P\347\353\215\240\277gw=\224\030!\263\277P\245\022\007\204\006\242\277\027\035\211i\304\236\201\277\254\257\355z\t\203\243\277\325u\253\313\256c\273?\267\022\312Yh\353\200?\246\017\373\253\013\316\244\277CO\222\361\360\224\243\277A?\247\007\"g\272?\317OY\nq\325\245\277\236\204\201\251\203\353\254\277tM\275hi\007\243?\372X\374c\250\325\266?t\314\023\331\205{\231\277\304\366uw_\313\226\277\200\352\254\252B\344\200?\301\260\347:\000\004\267?3\353=\013n\243\217?(\221i\216\270\217\251?^\315\250#o\367\300?\304\3331\315\302\013\224\277Z8\212\322\2371\221?v\312E\317\257\333\270?\n\321t\264\303\242\251?\006\370\3205\240\224\264\277!H\366\341\026\236\261?\353\214\277\244\372p\242?\270\032\360\273$\214\231\277Y\350\236\272\330\001\256?\t\251O\200\365\003\270?\235\225\241\"\373\260\277\277\027\300\035\263\030z\274\277\215\263\347\304L\241\276\277y\221\013I\261\350\266?\331\353\224\021\'\345\276?d@E\261\230\350\252\277\000\277\263@mz\251?\261\277\'\272v\330\247?\213\000\351\211\370\354P\277~\374\016\352y\374\266?\321\t&\031\222\302\265\277\r\223\236d\370\262\262?\335\362Y\274f}\272?>%\364\344N~\253?\367i\005\021\245\327\277\277\204\356\261\023\374\260\262\277\037\222\323Z\340_\250?\364F\345\211\226c\257?t\000\324\222\332\337\300?\332\211\232\207\301\r^?\351\310vZ7\203\227\277\242\326\023\302\243\007\263\277\223\343\350\224\250\334\262?\341\327G\341e\276\276\277&\347\361\265OC\305?\223\230\300\316\206\317\300\277S\223\305x\n\327\206\277Rj\017l%\001\240\277\'t\315b\332>G\277/\243\276\337b\327}\277x\263\246d\201\240\304\277w!|.\376q\300?\2026\350\032\266\234c\277\"\366f\256\t\236\261\277\261\255$\353\2560\267?2\260\257/x\233\221?Rs|3\342\337\266\277\016\223\246)T\204\247?\342|\200 s\374\245?L\234\366\0379\311\242\277w\0078\352\254\227\223?\035pM\005\351\341t?\306\217\250\022L\256\252\277\3655\353:M\250\243?n]\373 \024\327\271?\0040\232;K\036\260?\365}\027\207 \013\263\277J3\342\006\025\231\226?k\262\t\340~\207\261? W3 \313\010\310\277u[\201\360\347\370\254?g\361KR\252\203\277?\244\200\363\021_J\207\277\307H\363\246S\217\252?\000\014\222\351\026|\262\277\272\263\320\205\231\262\306?\275[\330\266\317\323\262?l\313^\330\216\010\245\277#\266 \013\320\233\260\277lM\373A\365\240\214?y\377\013\225\016U\201\277\311V\322e\211\t\306\277S\317xu|C\214?9\356ek.!\227\277\375\254\354Z\350\221\272\277L\333a\264\036\357\241?\321\253\273\014\2016~\277~\301\216{\341\376\273?\370\340\203\200^\253\241\277%D\343Q\032\220\267\277\203\303f\224\010T\220?G\344\013\001\007\260\261\277\357f\273\032|\210\254?\256\236\206+x\314\261\277\'g,H\366\333\264?\352\253A\225\'\240\203\277\357\2012]\251)\245?\025~U\356\357h\220\277\260\257\235 \305Fc\277y\354\201\316\226~\222?\016\300\222\216\2273\232\277GW+\254\240-\272\277A\315\263\213\260\331\252\277\321\205\\D\353\322\241\277Qy\204\324\371\202\233?\226\327e8\212\364\273\277\332\222\212\206\023\362\257?!\001b\244\354\360\243?\226\342Z,\255\323\260\277\217\n\322\204\313e\255?^m\0312\314\254\223?\251\222\277\217\016\233\206\277t\246\\)!\004\261\277\022\201/\206nq\264?\215\203\262\264y\244\262?\t\261\376s\275\346\214\277r_\257\357da\263\277U\006S\251s\005\242?.\245\374\017S\241\231?)-.\263\020s\275?\360=\265\026\212\371\240?\343\237i\222\233P\261?\322\236\323\234\260Qz\277\206\362Xp\t\027\271\2776\007\312\372\005K\200?gb\207\360\346\334\233\277$U\266Ix~\266\277\003\336{9n|\215\277bC\230\3020\314\237?\355\263?\243\201\211\213\277\201l\307\244\325H\205\277Z\324Y\276\277%\242?+\276w\207e\032\306\277_S&!\037\257\257\2775\326\362\272=\211\302\277\341\247\251\272C\206\241\277\211\246\311v\222\364\213?\016_\265:\010\236\270\277-GnN\177r\260?\256\375\371\242\235\315\264\277\2467\272\210\322\216\201?\217 \260\216\2062\244\277\266\240\205\215\266\220\237\277dqD\232\227T\254\277\2413\335\260\3707\251\277\304TN\361\2173\214\277\300>\263\0077\364\221\277\3741]\352\250T\254?\323\251y\236\230\317\243?M\344\327c\344\r\224?\006u\371\222h\324\243?M\233\251{W~\257\277N\310\320\003LS\324\277x\236\260\224\013\210\206?0\010\245l\233\257\262\277\313BM\313\360\353\260?\214\025\230\216Z\302\223\277U`\304A+\221c?O\000\2641VY\243\277\014\t\200\200\230\003\274\277\247\210j\321\336\233\240\277)~\205\031\226%\226?<\200s\371$a\247?B\305C\001\211\367\253?xh\222\322\334\235\301?\221f\333o\036\022\232\277\323/\375\356\301^\236?\001i\301\315s\211\242?\006\\\262\304k\301B?sg\036Td\222\251\277\321o\333\302\313J}\277lT\024\370\323v\256\277d\273\003\256\037\033\260\277f&\225\267\244!\221\277\317\215\255\026\322%\275\277\363\225b\037\213\342\255\277\362\017\200\256>I\265\277\222\227U|E\352\227?\346T%\251\216i\245?na\330\3106\234\275\277>/0\034\220\366\271\277\241w\226\243\235\'\300\277K0b\322)\360\267\277H[\023\361l\\\273\277\233MQ\014\r\247\230\277\006\376\354\027)\306\307\277sy\222\000\033\340\237\277-\334*2\301\366\255?\217\200<\026\330Y\263\277NtTu\025\235\301\277n\305\341\375\036\253\263\277\306+\307\344\004\207\236\277\374\377*\211\022Y\310\277\300\243\231\340\264b\240?\305\344\260\032\210\t\243?\371\361pi\260\313c\277\250\311\275\226\276\327\254\277/\264\352\225\373>\310\277\225z\376$\206W\222\277\215l\020\341\316\037\302?\322\346C\224\254\333\247\277 ]\311\n\355\343f\277\327X\366\024\316\374\233?\027R\251\364J\013\223?\377\017\273\031L\345\242?\025\256yw\005\345\213\277\033\221\231\362\217z\302?\365\244\330\\\240Y\221?G\325r\253&\300\261\277?\341\224\213\203t\241?}\230\000!I_\225?\001\374\240\004\321Aw?\020\3550\036\277<\200?\200@\346\023H\014\247?m\321\302\'\207d\264\2778|\262\222\243\021\257?\037\343\226{F\270\263\277\335\223:\032f?\260\277\034\361q\344!dy\277\027P\203aj\277\246\277\213\264Z\334\026\230\245?o\333auXZ\305\277u\212=\220\340<\224\277\340\367\326\0013\026\277?\006\363\362\237\340r\212?0\254t\2217h\302?\357\001\243\373\320\030\274?)\016RnkD\220?\021\322\022=w\315\260\277\306\324\330h\274A\223\277\336\245$\222\351\203\203\277m\375U\237\361?\244?\177\2747\300\325\273\262\277z\036\016k\312\021\244?b\023\024k\277t\265\277s\255\303\356$\377\303?\232\310\355\270\353\372\241\277\257a\344\323)\232\201\277R\343\034F\221\326\200\277\200\262\366P\301$\242\277z\251\344\321\020\350\265?\3738\233O\234\321\243?\302m\024aoE\240?Rn\371V$%\241\277\217\237Nh\324\035\247\277wm\302\016\234\322\266\277\331\277\232l*\347_\277\222\245@c\337\031\261\277\271\276\210\362\273\370\246?1}\037#\324\376\234?Vm-\023|\312\226?\327\357\361C\205,\242?\277?\032\033\351\212\252\277-\264\311\314\371\016\261\2773F,\021\351\372\222?\376\353\264\217q0\300\277\001,\333\324u+\262\277.\224\252\370\233n\271\277Bj\221W\300\321\241?@Vd=\314\270\303\277^W\003\0177g\254?\337\252A\375\326\366\245?\276Q\240\246\346\001\235\277\201\275\362?\342\335\243\277\276{!b\207\027\275?\016*\314\370-b\303\277a\201\233\264\377\354\236\277\325V,U^A\212\277{\003\227\270\001\233\272\277\246\212\207l\0373\273\277y\270\0109%\001M?\214*\213G;}\277?6\322g\361n=\300?I\355\327\306\325\275\240\277N\021\335m\2110\210?\252\353\003\324\302\024\266?\270\245*\340\366\014\232\277K\023\252\372So\264\2774\213\270?\334z\263?\222{Z\360\303\341\244?\232)P3<\377\225\277#\243\363\322\343:\256\277\213\032:\353v\204\252\277\227\035\241\0223\224\220?\241\277\022\247\246\370\256\277\347t-\332\246\302\261?\236\324\245N\023^\257\277\350\231\254g\311L\312\277T\337/u\177J\273\277@\303\026\237\274\017y\277\321\301^\357\333J\261?\307\320\027<\257K\242\277\231 \r\004\241\260\245\277\004\177z\307.\237\260?]\005\233\330\017\334~\277\356\201\006\265\037\242)\277\335\324\314!\336\353\271\277Q\222\n7\276\326\254\277\266+\216^~v\272?XE\260\252t\266\270?2\356j<\344\024\241?[\334Y=e\036\241?\340\323\t7\354\260\274?\024\235!\315%:\247\277\020\302\374\376\rO,?\217\366\225\301\025\034\272\277]e\257\320\212\371\267?\021\276cj\330\026\241?\367\330N\365\230\224\261\277\270\306$\257\000\330\252?\364\306G\206\t\236\274?\306\340\031:\301\373\246?@F{\314\310\033\260?{\'\352\230\370\244\264?j\374l\356\277\357\271\277S\362\302\016$\"\263?\251\311\005\267\221\260|?\356\245\233\322\t\277\254?k6\3025\311\243\237?\225\241\326\002@M\224\277\rMi\035\276z\237\277\250\264/[5$\260\277Q\031\316\345\202\205\233?\274\350Q}\232Y\262\277\367\342\200\347./\245?|\3113\370\2069\300\277\375\025\t\2168\035\256\277\342LQ\233\014\204\236?\311\024Q\023\213\327\260?\212\236\301\23649\254\277\211t\014\345\375\224\261\277G\014\206\376\340\206\233?a\343C\032\271\242\254\277\000Q\307\201[\326\267?h\037\010\213@\332\242?\312\257Qg\260\375\262\277~;\273{\210o\232\277\0053\325\352\224\205\300\277\271o4\001\016t\230?%o;\214\"\230\255?\363\0026.\t\021\244\277z\205m\263\n\\\242?\334\300n\251y\t\272?o\311|\220\331\301B\277\364\001\325k`\020\243\277\376\253\275\377\007\034\257\277\257\202;\225\200\340\216\277\'%\002\320b\024\255?u\025\027\247\372\000\226\2779\010F\272\333\033\265\277\014m4f\266\247^\277l\020@\336\214\004k\277G\025f\271O\364\226\277y\225\266\0044W\207?\356\252\336(\306\347\244\277\275\352\034i\375=\203\277\026\213\305\256\036\032\243?\256\2703\036\307\312\201\277`\006\203q}@\205?\024SIT\212\221\274\277\346\225\264=u0\233?\362\330\215\205\300,\301?J\275^\351R5\235\277C[\354&\227\007\230?\025^\326M9B\261\277a\361,\273u\243\271\277\302\003N\223\271\203\270\277\272\014\323\316OGz\277\230\352\356:\331\004\251?\253`\000;\'\205\242\277+\375\222)5\322\250?\300\334\367+\301\030\242?\010\227\026\306\247>\305\277\327\237A\262r\241\241?\004\216SRD\371\266?,M\363]\215\240\265?eQ\036\367& \271\2770SZ\327\000\235b\277\325\316j\004\270\252\224?\234\211\014\363\223\013\263?$\301\276\206~%\216\277\233C`\2306r\254\277\314\267\340\330d\306\221?\0066C\337\222m\223\277\313\177\2308I\260\263?PN\004}\306\207\266?j/\221\316C%\234?\206\326j\3065\250\243?\316\337W\361Y\007\246?\017\267ot\222\220\264?\320\305\033;\037\033\262\277\370\264\377\376\245\t\264?\263u\225\375V\265\260\2778M\355K]_\225\2773\216\010=g\326\221?\017t\351\177N;\213\277E_\214\023h\026\245?\300pK\031\333\244\265?\227\211\260\361tU\262?n\306:\"\002\215\261\277\222\315\376\206\365k\274\277\251\275b\212\336.\261?o>B\302$l\320?\014\344Jm\307\022\204?TG\0312-M\250?@\213\311[\034g\243\277\217\201\314,\332\020_\2775\033\376\262>\207\223?\227\352\013\217s\373\252\277\005\270`\304\261)\263?\251\026\246\2304\271\251\277\337I\226\341\350m\273?\t \365I\376\302\213\277\321\340\323\365\344(\302\277\201\204T\3022e\277\277\217\t\252V\310\263\240\277\234\213\037\256\033\t\236?\351)CJ9\200\302\277\233]K*\202\016\266\277\010,\033\311\363\333\266?\017$\000\246\004\235\243?\035\200\313\320\213L\204\277\247\223\360]]\321|?\321\034\243\374\357.\232\277\026&~)\353\374\302?\363y\274`\315\336\255?x0-\241\210\265\210?\320\314&\325\202TT?)\223\365\237\205\230\263?\231`\311\375PW\271?\3522\260\350\367\251\306?Ay\210\274\nR\240?\254\225\224\2517!\246?\036\301T\004\215b\300?ck\336\227\031\177\273\277\270\320 \254\245\337g?\246\321\323\321>\361\250?\326\256\007\343$d\313\277\262=\211\222>hm\277v\312&\376\0218\271?\t&\371\335\025\202\246?\217T\2054\031\350\235\277v\366!\254\225\221\264?\207\0242\262\025]\264?\261Zd\006\211\324\305?\351\370\264S\336\233\277?,b\314l\3038\305?\316HbpA\251\270?\031ITc\006\020\260\277\024 \300\236\315O\300?*~\207?\313\275\303?\354\264\245\254\342\374\305?\227\222\n8\234z\241?\006\375\372\322N\374\247?\014\262b\222~Z\270?\212\201\371\264\223j\300?\366\250\334t\224\311\256\277Z\r\3103\216\254\266?p\375\265W\272\337\231?P\254\260\367\0017\260\277\315\356dk\007G\262?1\223\356!\271\022\306?\276\017\234\261\241@\262?r\033\335\374\261\275\270?IV\271\272\321x\267?~r\323=\273\302\273?\303\306F\017\203,\262?y\022\256IZY\306?.\017\203Yr\314\250?\210=X\266G\312\301?\202\257B\247\032\372\305?\351\321,a7\337\257?=\001\303\212\232\022\267?]\216\276\271`\020\245\277\360hF+\241|\256?m\361\313\356\205\356\010\277\233kOu\356\343\244\277\316\313\223\245G\334\220\277I\364J\214[\010\273?\3669\345:K\334\253\277g+\217\362\367\210\276?\217\242\240\3561\217\262?dY?\225\355\262\303?\234I\016`\374\004\247\277\356\222\005I\367\323\220?\n$l\231\034\311\223?\310x\370m@\177\261\277H\225\337\272\026\356\274\277\334\013p\207e\177\261?}\255\200\365\013_\234?D\202iP\225Y\276\277\321\227\371U\203\303\212\277\232\210x\021\233\304\205\277\301 \350F\245\277S\276\305F\243\327q\277\245\247\t\3670-\221?\366\202\3329\213\340\267?\336\020\232\272\265\256\220?\213$\027/i\304\267?\237/\251\017\263~\264?q\307\211\252\361Z\224?k\261\273XvY\221?\301`q\371\241\376\212?\031M\210z\310\312\227\277\372\253\345\026\372*\263?D\017\205`f\326\221\277\352^\024y\301g\261?d\222\376)\342O\224\277\350\247\265\305\007\261\254?\342(V7\021c\272?\252\336\206xh\214\240\277JoK3\177\206\271\277\"\237\243\0213.\210?\203\261z\237\367\220\265?\206\372\007\216\2320\256?u(\340\367\352\302\264? \030\021L=\327\257?/\327\333\005_\333\271?@\203\221\353O\305\277\277\365W\030\222W\261\301\277Z\032!o\3644\245?R3\254\361\275\271\232?\362\035\311od\002\311\277\260\327\333D\376\016\251\2774\204\\\016\314\205e?\035\320\022]\332\234\262?\266E\330YZ\342\264\277\350[(F\t:\243\277\272T\021\344p\335\254?S\235R\214A`\257\277\252\216\252 Z\026\266\277\264\341X\250\021o\201?;\352t\033\365\233\305\277b\370\314G]\326\273?)\327\376\034\204O\301?b\342\034\326\316\\\274?\007o\255\030O<\241?/\235\n\364*M\221\277\\D&\3178q\230?c.\301\023\204\323\254?\342i+@l\203\211?\347F\242\001\271\335\250?\211g\004]\030\033\301\277\266.t\006\271\036\227?\016\031\334\250]R\275?\251XY~\2343\302\277}|\320\251k\250\257\2777\304W}\344^\244\277eIr\206B9\231\2776\333\375\233,\224\200\2779\tm\022\242\326\256\277\005\007\317\346\243I\247\277\261w\244-\031\r\255?\323$1\256.=\267?\212\262M\361\tW\270\277&I\330\224\215\233\246\277(\002n\316Y\224\215?\215\214\255j\007F\253\277;wFJ\344\206\256\277\371\251\3251\212A\235\277\271\235\262\251\005\032\261?\3059\007\332\'\"\272\277s\220\317.\034\333\207?J\205\223E\033\257\265?\336\001o{\335v\202?R\033i\356\346\323t\277q,!\367?\376\274?&\216\265\362\002\001\275?V\235\0229\265\313\271?\3072f\212\321`\300?\247\335\212\276O\360\263?5\273e\264\224\323\307?|K\tF\r~\251?\272}\231u/\300\304?6\270\3353)\211\255?\t\203\363#\206L\316?\216\020\307\255\2779\265?\267\2700-\"\265\246?\342\363\321\024\333E\271?\225\330\265LB*\220?=c\022<\tE\257\277>\354m\021\000c\236\277\374[M\344W`\213\277\341L\0069\260\356\216?\341,W\332\362\001\227\277|\352\227\222\220\316\232\277Z|\361\237w)\304?\224\030\270w%\323\216\277)\335\243\217\242>\257?\361\037V\356tS\247\277S\006\203y\220\326\260\277\004_\324I\223\263a?\027\300\336\237\206\244\257\2771xB\276\270\n\247\277\301\027AV7D\251?\205\223\225\035>!\270\277A\311|\201g\240\220\277\212%\347e\300\276\261\277\327\230\253\313\2218\300\277M\014R\254b\252\260\277\007\361\326\267N\017\261\277p\335\245\347\350y\306\277\207N\340\337\316\342v?H\215B\004\3379\266\277\\\'\354\335\305}\253\277/$\251\246O(\260\277\253\0259\244lN\305\277\234:<\315\276\264\271\277\257JH.\305{\202\2770\254\243\241l\006\214?\262\347\200F\030\333\222?J\016\334\270\363\375\210?\020\217\201\036\276\235\267?\316\217Va\201\315\262?\361N$\256pP\251?\r\3328\250\'\243\307?ue\236]\202>\274?.\226\030\030\360\372\303?\364\231[\266%\332\316?\036\364n>\007U\301?\034pi\031U\023\275?{E\003\304\340\007\300?\301\'?$\344\362\270??\035\221}f\037\264?\200\001\033Aw+\243?7\246g\"\331G\266\277S\217h30\342\272\277\000\255\007\275\264\220\311\277\332F\346\0226p\306\277G\346E\277~\017\257\277\370hf\301\311\313\300\277:\'stf\342\177\277\333\023\202\014\345\365\276?f\037\307\305\274\364\235?[a\032\274\177\251\213?\367\341\262v\\e\206?\222.p\334\036\'\301?5\334.\3164)\237\277\366\025x\3452\371\303?\035p\366R\236\206\301?\241uA\205y\360o?\251\332\337\033\007P\304?,\025\013a%\005\302?\313\300\276\017\347p\300?\241%\200\306\240\222\305?\261/\2470\202O\303?\3133\2146\005K\274?\372\321\024[K\326\266?)\206bI\3154\300?,q8\264\nl\320?\341\262\212:]\332\267?R\026\355\003u\314\277?$C3Z\245\346\246\277\324\016\375\037\0350\266\277G\265\374\314\004a\251\277\305F\261\333\344\221\272\277\203t\233\254\233\n\235\277\333A\204\352\307\200\255\277j!\267\020U\346\262\277\305\322\260\306~\357\204\277\023\347\353FuD\304\277\266\215\3524Bs\265\277K\321\020L\211a\237\277\263\021\240\036\021D\300\277I\t\021\205A\330\313\277\001{\033q\264C\307\277\247{\r\343o\322\274\277\263\342\354^\0261\301\277\275X\327E\245}\264\277\004\"\347\364\332\261\273\2771\366\311?7\345\277\277\206\252\331\305\260\361\313\277Q\312\027\360\r\334\301\277\337\324\032\323O5\253\277\216\317Fo\234\255\306\277g\033Z8\021\022\313\277D\275?\216;\221\220\277\366\230\365Z\225=g\277\330%\242n\371\210\241\277:~\304\256\264s\271\277_5\314r\016\027\230?gg\236\262\363\211\264\277\265\313\r\203\255\005\304?\002\205\375dN\201\227?\320\021\003J\363\336\200\277k\256\356m\223\333\226?jY\370\n\265\213\254?\251\024\312\213\252\365\251?\370\304em\212s\304?Gn\364\r\372\265\310?\373\222I7f\257\265?Y\274Yf\367\324\306?\247{~^\306\010\302?v\205G\250\n\026\316?\333\242r\337\317\275\327?_\270\201\2407w\314?\345yO\010\333u\316?<\261E\037\364\004\324?\376u}\003\232\034\311?\200\210\365-\323\034\272?\251\354M@Mj\320?\241^\006R\031\366\314?\203\357g\364_\305\310?O\2109\225\034h\301?\223Ih\307\347j\311?\250\004.\227\002\247\275?\341k\235\251N\251\264?\367\251\257\035\317\017\271?$Q\311\327 8\276?\315\360wG>S\300?wX\240\2108I\305?\2415FJ=y\272?\322\365}\177\323\233\224\277\030\264\217q\\P@?\225P\004\221\331\321\213?\314\221\275\277M\007\250\277;R\254i\257\353\206?E\3326\240\007\177\231?\004\264X\267\237hx?\01679\227^\265\270\277\004\302\005\354\223\255\305\277D\377\251\201F\226\305\277\256\243j\313B\252\271\277\270\020\255\272D\020\251\277\357\"\211\224c\317\251\277\313 f\230\244e\267\277\241\246\317.\330\234\267\277S\006q\345\361\371\260\277\344<\030UZ\353\304\277` \337\212\035b\301\277yRB\365\324\014\303\277\371\221.\205\351\333\260\277@\322\\X\300\377\300\277\276\253\001Di\254\300\277SP qsj\304\277\322\2638\027\026\210\267\2778\005^\250\366p\263\277&\007\255U\213\273\274\277\356z\303\026U<\214?\320\304\225\337\362\025\243\277\020\336\025\252\200\366\267\27742\010R\033\273q\277\274x5F\202B\244\277\272)\225\247wb\240\277\261\305\317\007*\027\206\277\233g\367\007\352\361n\277\0334w*@\003\255?\371%\300\201\372\222\235\277UW\035G\235]\225\277\347\004u)\225\222\266?\223*o\224 \265\241?\305\037-I\010\351\260?\320b\344\364Q~\207?\370\276n\024\003K\237?\336k\222\357\3058\266?t\3013\0366\267\240?\246\322p<\220_\312?\017`\335\177\205\225\272?=\244!\235\235\025\307?be\t\372$\n\312?\214\n\036\207d3\312?\031\213o\275R\243\234?\330%^_\\\352\304?\271o\366\355Y\272\270?\236\024\'N\027\037\277?\324\247\275\251&\251\277?~\240\203\331\014\331~\001\264?\377<\32282\024\177?XF^\004\3135\207\277\242\354$\005\375h\264?\266\275 \366\211\022P?$}\321\212\306y\224?\266|\327\257\372.z\277\260\265\235R\322\256\240\277\331\014.5VV\277?\205K=\215~\205\222?L\270F\300\366\020m\277\303\010=\036\234\271\267\277\360\0012Q\344S\270\277\306\204\025\027E\331\245\2770f^\025U\303\243?f2\010\363YO\250??UC\355\342y{?\361R\204\202\203\265\223\277-\323=\217\376\004\252?\247<\210|\316,\233?ev\246w\344Hs\277\371\363\364\021\230\347\243?8-\353\332\033j\300\2772\252o\252\213\014\247?\304H\313D\272\353\271?\347\317\330\361\212[\224\277\203+\225\204\3767\234\277\0346\261\353_{\260\277\013%#\037z\205\264?\357\027\224xc\325\252?\312\357\244\255d_\234\277H\231\344$\021\307\200?@dq\245\232\364~?\215\2709pav\265?}r\355\252\256m\247\277E\256\020:\234V\261?\205m#\321\23658?=y\310\362\037\023\255?\032\340M\376\251\361\234?\214d\004\222\303\n\240\277\3664\203^~k\307?S\377\221M$\364\241?\274@\317\375e\356\207?a\344\375\3277\244\261?)\205\226\366::\263?t\342\024u\253\241\037?\231\211\177i\322n\260?\237\367\014/\006K^\277J\313\213\273\225:\254?#uq\333\353\323\231?\310_!\364\004\375\252\277\340b\"=R\253\240?V\010se\022\001\255\277WpI\247\325\201\252?q\324\0228\340P\211\277\357\206\004\0163\322\300?\013\221\332\245\006\201P?\213\235\225\360\n)\237\277\264\200)y\246\337o?\364\271\017\207\211j\203\277X\314H\016\366r~?!bp\354\2731\240\277\227\317>SXq\224\277k\257\005\0021\032\234?\014\322_\206Yh\216\277q\301\344\237\037$\241?c\377\273}\341m\301?\317\017\277\3145W\260?\016\301\327\350\213\331\264?\354B\211\355\320\254\230\277\022\"b\241\350\350\224\277\035\326?\325\240\222\240\277\336d=\243\004.\254\277\310\230\312}\306\'\266\277\240\256\366\306<\247\266?\244\223\223w-\016\231?3\307\220\302\315\231\231\277\203\310W\363\031P\244\277\021\336\330\036\265\206\244\277\357\274\017:(\336\271\277Q\375\340\023\331\260\237?\322\344\336\232aQ\261\277\240\035\260\3650\010\232?K\266\333\010\274\253d\277\225\363\253\331\274\252\223?-*\253\267\035\013\221?\373\356\322\306\\\250\270\277\267?\013e0\370p?\005\365\235\327\373(\253?\217\250\250\277y:\221?\264\331\236:\361\253\243\277\372p\244\272+\332t\277\301\367\302D\376}N?\323\331\031\201\376\215\253?\3705\305:\3439O?c\215\265\241z\371\202?\274\255yJ\210\t{\277Xm\237\275\2162}?x\036\307;\271f\272?\334\033D\004\255\017\217?,\300b$\272\366\235\277x\213\023\373\3354\246?\014D\252\342.\261\240?\306\244~g :\264?\265\035\025\323\233\327\263?\202\247\322 \305vr\277o\025f\3474\225\226?\365\350(\242e\314\237\277\216\244\357\233\264_\217?@],\013X\310\265?\311-\020iP\014p\277\033af\303\203e}?\245\322o\033y\260\302?M\371=0\215&f\277+\001\341\321a\333~\277\201a\210e\341\350\256?\022\027\253?C\243\306??\375~\376\345\210\247\277\210\264\230\200\304\313\275?,B\224$K\332u\277fe\024\267\334\344\261\277d\234,\375\344\210\210?\237\252,Wue\201?0B\374\344C\313\234?\350\373\331\305\376\255\276?\342\351\337\325\037A\255?g#\216\267\251\222\235?\013\350\272\n\366\250\273\277+\370\277\301\"\237\252\277)\200\016L\260)\311?Y\217\341\204\336n\252?\177\022}}\031\377\252?\266\001\215\263p3\244?#\334(\315\342Y\222\277\317\220\233\226a/\254?~\304U\202;\263\241?QS$\361\031@\261?$\345\000\275\"\303\251\277Cp\322\330m+\264?\373\r\315d\027\222\251?\332\250\260\021\242\342\267\277F\321\236\355\216\210\255\2773\362!\310)\377\210\277T\210l\223p\300\260\277\307\313\344\230\203\257\256\277\2355\246\261\331M\221?a;]dR\031\247?8\017\022\203\373x\224?Z\003q\330w\007\252?I\365\316\367\343\213\250?\007\310\314`?\335\261\277\216\210\027}\315Z\244?\031=HX\276\025\240?\033\267\223f\216`\240?0M\227\362\025\376\222?\234\236\033\027\0160r\277\223\351<\270\335K\263?\264\3538\344\016\236\253?@\251\255\340\341\014\240?\177\333\246N|\001\250?X\265\375\217\034\324\260?\243n\221v})\244\277}R\365\000\267\005\261?^\224\230\210\005\352\232?\304\321,=\240\313\242\277\265\256#AD\206\214?5\236&\234 \254\271?\000yB\353\331\235\234\277d\374\267|\005\317\253?\352N_\231\356l\275?\243~n5C\357\221?\376i\2234\2312p?\314\326a\323;\227\252?q\tU\024\232\007\251?4\250]\216\274\322\300?\271\247j\316\204\014\236\2773J\355\321\312\332\203?#\366BY\261M\303?\t\271\005\030#\004\261\277X\013\023\017G\277b?\266\257\346\263\3429\262\277\021\002\024\313\353DZ?\324A\357\277a\321\206?\355s\356\005\005\t\241\277\010?\325J[\031\243?\352wrzK\334\233\277\033\334l\336))\227\277U,\242x\247?\211?\224m\'\366\034a\262?\344\357\277\326\241\010\251?cdJ\320\221\236\274?\347\344\n\251\310\244\224?<\251o\004]\345\235?q\000#\035d\343\266?H\340-t\333\264\252?\221ntXV\233\252?\342\375\247\0249N\247?\271`[\203d\014\202?\221\346m8b\307\263?HsyKb\355\232?@\233\232#\265k\276\277\346\314*hWv\237?7\024\222B\341S\265\277\224\272\230V\0373\272\277\026\213\360\224\246O\300\277\314G\361\212\026\272\237??\004\251C\332\274\230?S\304\202\303d\247\240?\332\362\215u\334\206\232\277\217o\222\231j-\262?\025\006gd3rz\277\3558(cJ\376\220\277\223\202\273\"\025\264\264\277\006\347\337\002\240Z\302\2771\013k^}\021\266\277\365\000\301\365\376\022\212\277\362\010\345\203\235s\274\277\3528\350\220\370c\263\277\376\217\273\035\353\007\226\277\274j\276\236FS\227?$5\223\"\274\202\233\277>\023\201V[\277\271?\324Z\021\"\357\307\264\277\376DOz\267F\250\277\270\336[\202\233\273\210?\360n%S\362\225\211\277\204y\324&W\323\260?m\233\014\366k\255\223?\365h\273A\010\365\215\277\234\312\353\314\316\305\273?44\307\0013z\234?\310\306\201\2422G\213?\234\\\222\030\3275\206?5!\317SjF\226\277`o#)<\033\227?9\260]\030\330Q\230?\266N\343JB\262\230?0~\001A\007\317\224\277\375{7\372\315\355\305?Q=\314\177W\366\301?\370U<\201\302`\247?Xc\311\'\375\374\265\277\026J\020/\212\006\241?\365\246\346\315;^\235?9\226\312H\202 \303?\373\216]\341\177\243\264?\304\316\224nQ\336\255?\267\241%\240\327\275\247?-\376k)\360A\277\277\330\0227\3314\377\231?\274\313tPK\263\300?C\217\220\020\033\257\207?\2572x.\265\322\253\277\340\r\375\330s-\265?\01327\272\303q\240?\373\017\321\177\317\271\273?\212\223*}\024\210\200\277b\202)\374\367\252\212\277w\030j\345\321\331\301?\201\364\014a\206l\223?\274V\257\206\353z\256\277\351D\n\322\003\263\242?\240@\257\226\252\277\271\277\300Z>\013\367\006\207\277\034\350\265\337\205\016\251?u\340UKd=\252?\037\355h\037\343\254w\277\301 \214R\003;\212?J\233~\034.\373\223\277\003$\200\234\333A\264?\200\322(\212hQ\212\277\237T\013X\230\027\262?\235\370\253\035\023\207\276\277\034M\020!\263\224\233?\361\237\240\362\371\336\300?\274\303V+\264\214\302\277\350\237\207d/\212\251\277n\352\313U\320H\250\277ila\206o1\213?\323\340\205v\370E\277?\326A,\035+\241\246?\315\032.o\302\031\261\277\036\335\366o*\031\224?\266\267\214\312\331\333\305?\035U\244\227\333^\247\277\372\010\336\274\r\004\243\277\246p\022\003w\263\224?\357\350\305\010\337\215\271?VL-1\027\016\231?\020\013\010\004\333\324\240?\0058\273w\025\271\272?J{\225X\365>\260\277\035a\233~\211\252\267\277*\337G\203#[\247\277VL(\364\237\334\250?\356\327\321\227\354\232\227\277\312\243P\tM6\263?\021\300Z\312\360\013\211?n\233Z\003\352L\302\277\363\306\203\351\r`\261\277\017c\036\027\035}\263\277\324E\360\241\300\306\274?\337\300\232VV\242\252\277\304\367\321\362\246s\241\277\253y/(\205\343\246\277\312R\3554(&\302?\332\253\3142d\357\253\2778o\014:\362\013p\277u\333GL\n\330\252?\310(G\007\024@\222\277\3548\327\360$\025\212?\2431\263\377\320\332\225?\324\334GG\227,\240?\273;Y\251\261\217\255\2770\203\264\002Os\253\277\"\277\315+\346\307\261\277\264\360\264\240\242\245\245?V\2117\310\302\377\274?/s\237\366@\327\257?\007\373N@\361m\215\277\\F:\371\353\211\270?\210\231\311\002\330Ij?\366\271\305-Z\226\250?(\205\035-g\212\204\277\205\2274b# \242\277\234\345]c\216u\301\277uzo\362\252s\274\277fX\312\271sh\250?\260s\241\'\212M\264?\244Z\024\347\004\024\310?M\314-\257\2473\302?\246EW\224\343\322\302\277\335E\260\375\346\365\300?G9g\303\256\375\255?\020No\212\320h\224?II\001_^_\300?(1\230\376YT\262\277\205\230y\021\264\332\260?\374\035\014\361\010E\264?\227/!\232\371\335\214?\223\271$+\2135\240?\316t\225\370\334\311\255?\251\321\004Lz\324\267\277\220\241R\201@\267\272?\023b\251z\273s\250\277F\316\361\274w~\256?\267\034\346\272\220\032\227?\246\300\341\243?v\260\277v^w\024[;\242?\337\371Q\371\010u\273\277\220\367\034\247qD\230?Dd \341\247\n\261?\350I\377\023\275\371\211\277\373\273\003\241\000\036\222\277t\017(\230\314\221\253?\206\004\264\300Z\242\253?\216]\230\244\334\247\237?\273j;w\233\301\221\277\030\335F\022\244i\265?\355b\325))\375\244?\217T\367\362\214\237\222?\224V{\360\263|\222?V\367z\246\216@\302?\353\017\263\336\347j\305?\001:#\302\' \245?bW\320q/l\266\277\010\317\274\370\260\225\271?\205U\314\025\326\374\226\277\375\237V\006\250\300\245??\331\253Kb*\204\277\327s\317[I$\237\2779\276\031\216\003A\274\277\314\271Gx\351\030\236?_\200\340\274\246\326\274\277\331\264\320:\212\271\254?\275I\221\234\200\216\302\277\331\364\353f5\177j\277v\347\327\220\274g\254?\276\307\245U@`\254\277\327S\032\363\001\037\310?\332T\003\324\025)\262\277\021P\0045\2252\271?l\361\215\247\350w\301\277\331\3236&\305V\236?\016mx\235\254\244\221\277_\320aR\250\347\236?\3243=\233q\360\264?\177H\341\252\227\372\217?\265Ow\350*S\231?\375R\034\357\362\026\206?\305j\246\3174~\307\277\335wsd\rT\223\277\213\017\215\265\352W\272?\276\343\236\376:c\234?)\215Iq1\270\261?\r\351\300ryv\265\277\036\245\\\317\r-\267?w\242q\256\210\027\220?\273\304u\034\251\262\302?Y\276\266\323H\251\266?\214\311\205\177\206+\276?\374+[\356\232\371\253?\337x[\005\226\r\300?\334\323\243-\256\267\265?\200\273\036\225\206\330\214?\326\265iW\331\303\244\277\013\234\350f2d\301?\200\304T<\245\320\265?\207\376\312)\265n\270?\366B\272t\311\337\265\277\316%\265\241\274J\267?\277}\364<\323\235}?/sm\245\272\177\273?W\013\231\224\322)\267?\021\357<\2127\257\302\277j\215\\j\246\222\257?\246\024\271\377\323\230\275?w\236\331\365O\032-?\211Pn`<\024\272\277u\000\377D\373\206\300?\014\337\322\265\335m\246\2770\301\037\356\253\200\273?G\030\245\342+\354\300?\013Rw\370\036\252\223?\312\300\030\267\2230\276?\022\225Y\024\372|\212?\371jl.\312\265\275\277\021q^\317\370y\211?\356\317\257RY\363\256\277\331\3006o\201\030\272\277\2120\2023\t\243\207\277\200\366V\331\245)\231\277\366\252\366\313|W\267?\306\266\277K\307\007\265\277=n\204\375Of\262?\201\004\254\203hd\213?\345\311\003\213\367\312\261\277\304\t\037\001\264\355\257\277\342\307\240j,+\244\277\323\0058\273\326_\247\277\243\\\\\205.\026|?\226JBW\200\370\252?\037\371x\026\003\263\263\277\343R\277ZdE\302?\226\004\177\222\315V\243\277\300\253\313b\002\233\271\277\312*\307u~\244\270?\332\003,,kO\275?\260h\231\221G\030\246\277l(\245\330U \254?\'\'q\215z\372\262\277\333_:\301X\035\275\2774@\357\303\031\275\215\277T\t\300\004>O\242?r\347\344\302\006\277\277\277\227\206\224Ug5\211\277\020\377_u\244\332\270?\245\330<\260\304E\275?w\303\226,\274\215q?\311\0056]^T\272?\346\206\350\364\246\260\206?\t\274\237\203\332\302\300?\331\3120\004\355rq\277\033GUc\034\007\201?zD\231\022\'\203\200\277n\214\303Ll\026\241\277\224\"P\316uA\255?>\352Z\372\374\312\275\277\327\026\013\r\037\236\235??J^mQ\337b\2771\031\016\242\254a\211?\\$\233\306\341\331\277?~R\232R\230#\210\277\341n,m\361\355\263?\307\346\266\265\020\025>?\250o\231\\0\237J?\372\t,}\272?\202?u\275\204\271\204\t\225\277\334\004R\365q\032[?1^\255\177H\306\211?7\330\020\271\310\355\230\277\226\270\206\203\tHs?\3173\373K\r\335P\277\3157\'\233e\272\274?\324\n\212\344*\361\220?]\310\3117\353\t\261?`\324\212\225\006\367\274?\316(gm\310\000\221\277\3531d,\n@\271?\230\276\264\363\'\214\302?=\250\234\203FLH\277\375\215\204<\371\241\266\277F\341m\215\203\033\263?\"\311L\3637\277\265\277M\'#\330g-\207\277\331\247;\317&\023\252?D%B,\247\223\257?g\333\323\232\021I\262\277\202\324?\021W\377\266\2774L4\032c\322\226?\363\210(\311\225\025\221?SyZ\023\304\277\303?\227\254\003v\275\260\227\2775P\2673\307\320r?+\223\243\305\262B\217\277\242\273(\227H\306\233\277A\023\366\367\304\030\214\277\024x s?\222\207?\271I\360&\234\255\241\277z\ri\205\007\202\253\277\341\210Kb\343\307\247\277B\235\017\013\001\035\262\277\365\213\313D|\334\232\277\246O`\215\014d\230\277=\032\334\033M\341\253?}\324\354\270\\\310\261?\303W\341x }\222\277\253\3667S\273\007\203\277\241\360\247N\271\273\303?\271\346\216\301\232\002\212?\010\365\234\372-\272\202\277o\371\2149\233E\243?\014\010\226\020O\341\264\277\234\204\326 \nC\214\277\375\300\275\243.\253\277?\372\245<\352Am\244?~\256cn\343\002\210?\342\233E\027\203\025\224?gg\2457\213\273\216\277\3701*\'\273W\266\277\272\371\273\033\201\336\260\2779\271H\350\016\326\262\277H\250\267\262\2768\244\277\3545\327\343\366\342\306?\370\334_\3541\214\305\277\021S\275D\241}\255\277\257\206\320\251\236y\300?X\025\210v \033\260?\262+&n\253\232\235\277\230\336\2158\231\263\201\277\227\374pN\004\231\262\2779s\222)\321\247\301\277\312\005V@\321\310z?S\303\327\013\317s\271?\373?\207\376\316\276\266\277\350\034\275\215\277\036\263?\333\362OA$u\271?*_|\035\024\342\221\277<]\022\337\216\202\222\277\351/\005\365\274\333\250?\027\3153?\033E\264?\004\317\004\341\021\217%\277O\003\321m)\207\217\277\033|\037\357\204T\271\277\340\375c\242\231\r\245?X\310\376\231P\275\271?\232\247\247\347\223\265\362>y\210t\000\220d\302\277\243\035\354\262\031\256\235\277\335A\324N\303*\216\277^\336Gy\025-\262?\332\213}\246\306\235\261?r\333\033\266G\357\255?\210e\331?j0\267?7X\216\274\203X\262\277\212n\026\247P\373\210?\341W\250w&;\300?\237\355\236s\005\276\243?;\346apW\352\245?,\204\374\344s\273\273?y\331;\260sW\241\277\314T\315\207\360[\241\277\244\031\355D\272\355\265\277a\014\376mx\350\306\277\313\234%\205\340\264\226?\025\323\350\276\225\tx?}\235\311\014OH\250?\240X\312\'\265\333\275?\204\243\'sN\361\270?s\224\253\001\010\\m\277u]\3620>\274\266?A\242\005s\243B\\?\337\257\232/S7\303?\020\005\225&6J\242?7<-\272\371\225h\2775\007\333\215\3255\245?\357`\256\272GT\247\277\253 >\007_\004\204?\360?\036rMGy?\373aO\244\243;\226?\303\327Gz9\262\243\277\336\367\341f2Gw?\271\014W\360X\035\241\277\224`L\"\371\332\243\277\322T\2329\254|\274\277\327\004#\336,:\243?\034\177P\001\240u\233?<\266\017\313\325\014\255\277X\225c\003R\317\301?\336=\213\347\241\035\223\277\340\325[\310\026\366\301?\340\312\312\324x\354\247?\223\035\351\221\312\270\244?\253S\177\353\312\251\260?\307\323)\257,}\254? /\313\223v\330q\277\221\303dk\352+\241\277\320\3633\236Os4?\007\215\342Ueba?\330\006\374\016\216\260\246?\230\363\010\007-\201B\277H\262\252\246-\371\300?\316\262\371\350\322S\206?Z\350%\306ma\302?<\224\002\310\344\r\242?\241\254\247\202\316y\263\277\356\242l\177\306I\264?l\201\207S\252\177\260?R]\224S\367\326\276?@;d\224\035\361\264\277\243j\251\000\2241\177\277 \000Z\244\352\246\216\277G5\214s~+\244?\251\034\231\265B\017\243?9\241;\\\"\010\232\277\275\244,\036oC\264?\266\227\377s\337b\265?\252\277}Fn\201\262\277}\276\302\306}\033\261?N\026\'\326dA\213?\306\341\224\361}\354\263?\250(t\250\230\345\244?\352\371\331\025\334|M?Q\"\274G+\336\242?\003\207\200*!_\266?\356\257\376\367\341\210\255?RT|s)/\205\277\322\233\367\273\307\206\244\277\352\215,va\276\245?\353\242\037\202+\323\256?\270\021\023Q\206\247\237\277\301\370kG>\303\266\277\302\301,`$e\252\277\r\360&\302\013\277\251?L=\244.\361\374\263\277\302b\246\370\334\372\271\277h,MeDHc\277\\KV\007\2147\270?\234\376\247\027s#\264?X\257\324\236\236\031\254?U\217\231\027i\331\210?\3116\256\330\351\035\300?\360\003\361\277\007S\256?\373\014\014\221\373\023\260?X\3667\362\255\221\262\277Fr\034^\304\236\246\277@_Vt\352\306\261?\266 \304D\215\263\233?2\325\370\246\t\260\241?\357\247\201L\004\346\251\277\003\305G[\203\377\275?>\032\366\225\025\020\261\277\273\017@\316_\320\254?7\014~\220\177\004\245?<\330\325\310\025\203\261\277\272eMJ\307\032\243\277D\017\266F\320R\262?\206\244\221zQq\262\277\262d\017\324\274(\260\277\257E\274am\375\237?\374{\353\207\310\212\254\277\312\250\357T\266Q\207?\260\027[\342\250\037\221\277\266\301$\302\326\266\300?n\237\251Y\266\225\302?\"i\240U@\017<\277\234d\363\214e(\250\277\010\342\005%\227|\235?\344\301T)lR\246\277\376\317\226\300\2401\305\277\304\371\354\353\357B\273\277M\241\341\372>\177\252?w\331\303\313\324\316\261\277\256\227\326S\355v\253\277\336\235j%nH\242?\031\373\001Yn\262\260\277\001\037i\033\350\355\246\277\220\300\261v\336:\206\277mh\315t\033\357\244\277,\357\031\302\351\207\210\277\307{\256\333\276\370\234\277\366\031\205T\223\017\261?rdD\347\366d\243\277\305\2140\311\2733\247\277\210\227\215\237Q\001\271?\365\n\375\2665S\252\277\226\010\004\013\'\253\277?\320M]\327\0303\246?\t\263r\216\364\247\243?C?\367\331s\307\234?\333\265-\2109*\261\277y\022\2254\301\241\271?\253\t\260k\274\325\236?\034)\031e\376\323\276\277Z\025jeX\344\232?\206\271\306\245\212\250\010\277\300\235v\341\315\337\242?\253vh=\252\177\225?\223\233%Fp\332\275?*.\nW\374\343\227?\035UL\247\313_\221\277\212\235\210\363| \234?\304\033\nz\376V\273?3\027= \242\376\202?\031\220\3431.\376\225\277\232\304N\"\245s\266?\312\343er\345u\245?\372\020\205\336\017\023\303\277\266\367\364$E\321\253\277\240\035\243r!\344\253?:\214~\277\312\343\266?\200\r>\000\256\300Z\277\257V\325t0\354\230?\230N\316c\267\035\250\277\337\375\330\023?\016\242\277\215\372d\001\253U\244?_\361\273\355\376\252\253?g\337\026h\317\305\206\277\234\361\336s\000e\245?L\217\256\2668d\242\277Q\031\2206\212\031\203?5mS\271H!\237\277\277\350h\233J\303\244\277\331\246\022\373\237!\242\277\177}\033r@\323\306?\366\325A\265\266=\272\277\215\306\317\357\257\257\267?\2666\240\355\3304\220?\271\026\225\230z]\252\277V\254\004n}\025\301?\212m\322\305H\205\267?^9n\346\242$\271\277\255Dk\000 |\273?\236&\311H\005\210\242?L\005\247\306%\237s?L\223]\'\223\023\301?\241\270\2203(\316\277??\374\003\340\302\200\263?)\327\374\313u\317\252\277\277\231\223\361%\243\242?\335\317t\321P&\256?{\331HbF,\212\277d\203b\\\362\345\220\277{#0\276\240\311\260?\216Q0\340$\345\233?\370\262\256\227\302z\263?\226\360]\233E\034\237\277ML]\242\256\307\272?,\334\033\311P\256\273?\235\377\336\314\252e\273\277\303\007\230\251[+\270\277\327\354\221\006\r\204{\277\257\330\366\231?\022T\020\234\310\316\227?\020\206\322\026\3237\200?\367i\313P\272\221\234?@\350Qf\001\323\267\277\377\312c\310\"y\246\277\252\305Cb\014{\215\277\010+w\243\"[\267\277&zC\037Q\323\256?\001(S\221\306G\226?\213\354\357k\357+\244?K\271Lo\005#\235?\307\254F\251:Q\241?\210\265\377\007\364\373\242?\"\264_e\037\035\256\277R0zI\0036\253?\332\026 \021,\345c\277\224K\261\227~\351\273\277O>\306\t\233J\230\2775k\234\355r\262r?j\334\030\037-Z\222?\334\321\000Nr\252\300?P\031.{\237\327\204\277\000\006\333d\350\275\220\277ehb\n\252&\241?\374v\260\313K\226\212?\253\337\250\344\036\310\273?X\211+\232=\320\270?\005\002\356\206\010\356\277\277\024\225c\345\364\240\230?\242\212\371D`\204\247\277`\213\233\017\215\317\250\277p\274\212\020\273\030\230?j\331\253\306\204\000\226?\232\331\014=\3150\250?N\374t~\270\321\263\277\335\305u\320\363\357\274\277\'\373a\031\007\343\270\277{\376\342j\326<\261?ZI\263\275P\361\226\277?t\370~\227r\263\277a\222\255%=.\260\277\377\3555\333]f\255?\034A\260\234Q \213?^\000?\331lI\231?\340x\001\316\201\246\205\277\243\216\022\333\010\356\243\277\213ej/9\360\240\277?+C\244\376[\300?\010\202*\360\254\222j?\241\024\376\277\226\205\240\277\234\310\223\023G\367\227?\327bb\300\352\221\263?(\340}\033n\215\300?\241\023~\026\361I\256\277\256AM\346\367\277\221?\350\204\313>\244\033\233\277\261dC\330\211\303\213?\354\354z9\323;\211?\216\014\362D\223\343\237?Gs\341\344\017\365\243\277\313$\232\322b\322u\277\223\371LW\177)\274\277#\366Lr\343M\247\277\265\253\320\217y\022\212?\210\321d\360:\376\255?\r[$\303\026\024t?L5\006mj\377\257?\275H\\\323\2400\272?\320\305&v\033\202\275?\2126\t\277\241\217k?\334\3436\334\344L\270?\271q_#\301\t\270?HT[\236\344\343\271?#K\'\346OU\271\277\353\003\276\300\277b\326\253\271d\367\244?\320\002\306@h\351\217\277\207^\271hX\310\277\277\237\270)\221\315\014\255?\327\2119Z\334e\232\277\355^N2\0307\220?*\3065\016\345c\300?\212\255\3648\n\'\247?\363!u\022\035X\254?<\'\035\372&\365\260?\026\2259)\027\260\222?\366vr\313&\354\256?%\205\222\360Zr\260?\344\317\313c?}\277\277\315\n4$+\332\253??\345\263\221\205^\277?\275y\026\252(e\262\277\355\307\305f\266\255\262?{\326\n\271 \373\213?\326\037^eO\244\272?Ap\360\210`s\235\277\274\2304=;\314\262?a\010V$\347\202y\277\207\333\334\240\347\\\263?\345!\357\243\215C\250?uX\005\327\016\213\275?\241r&\333\203\315\247\277\335\347\237\3421A\262?/\307\322\316\241\254\302?Ys\2767\r\345\264?%+lG\027?\303?H\256\014\324\333\265\260?&H\307\257\255\312\241?\243R\277\203g&\223\277\360\211\307\037\006\240\274?\273\000\311C\227\261\300?\323i{\336\377\265\272\277$\354\310\037\235\273E?9\354\243\310\316x\242?\334\225\344\212\230\036\250\277\365\030\"e\032\231\301?Q\006M\306\003;\253?\035.\017\210<\266j?\213\030\344\005\351\273\300\277e3(5M\361\214?\376\312\242\214h\310\254\277X\314\004\374\300\301\247\277c\241\3760\330\305\251?\274R\200dC9\235?\373\352OZ\031\242\221\277\0162\007\010\304\245\245?\243\256\245\3353\264\255?\021\335~\205\306\017\252?\233\0322D\305,\217?\311\354pJ\301\014\253\2773\244E\265\022>\264\277\354wU\007\206\231\201?\005#e\326\215)\253?Z\035 \237N.\250\277(\017\347c\206\273X\277\274\020c\335\217\251\260\277\322:HA\024\010\236?\320\335\211X6\233\302\277j\315\231l\275U\301?\257\223F\376Dc\272?\023_\367H\276\\\264\277\010\2211\262\374\237\253\277`\007\027\257\014\\\273?\027B\017\330S\255\264?\340\271\216\241(P\221\277\303B\326UN\"\256?1W\350\376\206t\266?\n\360\023\010SM\274\277g\377kNJ\376\267?\004\216\204\021\370\376\233\277\323\303(\240\365\177\253?(ls6\300\210\204?*\355\017^$\004\303\277\335TQ\361\0044\271?|w\343\032\031\360\220\277ap\007C\026J}?^\344\336\006\370\377\242?\220\031HVL\205\271\277\210errt@\261\277\361H\025\373tt]?Y\367\273\362\253P\301\277\033\354N\240\027{\204?\2332\232\020{\303\242\277]&\234\361\230\371\233?\235\350<\300Kj\265?\241\035\000\316n+\266\277\204|\255\371)\310\262\277\300l\274\240\226\326\240?^\321%\222\227\243\225\277za\337h0\006\235?\3206>\n\366\002\253\277\205x\024\022|w\226\277n\355\275\333\307\354\206?\231\261\233&\342g\243\277\330\355\3361bt\212?\274\205\344\265JF\246\277jk\3608\300\301\262\277\344`\330\001\313\353\204\277\244\022\365\355$9\234\277\332R\341\325\307\007\271\277\371\224nW\\\274e?\274\032\014=\333\226\243?\234\210\343D\314\312\222?Y\257\303\233G\244!?(!\272\301\215\270\264\277\315\302TBul\224?\003?#.\010\367\265?R\326R\003\336\023\304\277 8w\331\362\271\235\277\006-\030\t\361\264\256\277\227bz\201X\252\267?\352`#|\"x\226\277\031\334\362\0335#\233\277\254gNg3{\251?,f\3227\270\316\256\277X\264\001%h$\211?5t,O8\013\234\277\224\010\277\255\330\247\233\277\000H%\023\313\177\302\277N\207\324\351\365\r\221?6@\312/\365\021\241?\356\244|:S!\301\277s`\242#T\025w\277\262R\376\263@\212\233?\001\025\216\350\320k\262\277\254\215!\336V\231u?\325\310\256\325\337\362\240\277\364vN\321\274\312\263\277Jgh\363\377\222\230\277\341\215\001\334%\365\262\277\237-\223\tSi\262\277\307\311\326X\361\331\263?=\005j\010\275a\271\277\214e\316<\271 \274?\227\371\311\000\301k\254\277\031\024\252\356\002\333\233\2773\260\236\315\235z\252\277%\240.\017\362\217\303\277\347\034:l\241+\203\277\r$5N(z\253\277(\037\306\266\230`\242\277T\257\357\033\230D\271\277\374\002\007\325\323\013\274\277G\210\202>h\036\251?\005\221\304\356h\022\221\277\217\231\034L\271?k \222f\340\246\240\277f\034\210\330\311\253\222\277n\034)\341\263\001\242\277\263\311\330\315\210\200\241\277\332Zt\005\206_\242?7\373=\251E\324L\277\315\222\273\255\"\234\257?\326\266\372c\247\246\222?\312,\027\307\177\256\252?\300\330t\255\334\036\213?\004\260?0c-\240\277\222J\226\234j\271\263\277\035lK\267\3567\246\277\246\307\310\010y\266p?\002!\'m\346B\231\277\215\210\033R\205e\251\277\233S*C\367\200\246\277\'\262/~\033n\265\277\351\340]\373\016\216\246?\311\006J\311\024\360\263?Zg*r+\255\262\277\247Enm\306\305\200\277\352Q\247\305\332\227\200\277\300F]\303\377\361\224\277\310\302.C\273\271\240?\351\007 \254\277\020\241?\207\r\316\230\n\222\220?|\321\033\316O\374\267\277+\262\317\375\334)\256\277d~\323\313\261\343\274?\374o\264f63\263\277b\032TT\023\373\255\277\311\336\305[\326\035\260?\323\243f\004\352\314\246?\331\007=\374\367\204\271\277<\321\342\325j\020\251\2774\335\211\345\254F\273?\334\233;\213\231\032\266?q\315\004\177\335\210\204?\326\370\014\225\235\324\277?!\213]<;\003\275?\345#\316r\3369\270\277\344?%a\271\032\206\277\351 ~\002\216\025\254\277,\236\315\'\366\370\262\277\016p\222D\350d\222?7\2066F\372,\233\277\355Z\233c\036it\277\267m\200\3550m\265?\300!\200\216t\3319\277\013\313f4|\320z\277\325H\214=:\252\250?H\204\267\013\250g\242\277\326_\321\271>5\275?\322\002\275\347\237\235\252?`\241\301\335{\373\264?\234\320LQ\350\035\245\277:f\223|\207c\243?\022\tm\325#\226h\277\310i?7\037\320\260\277\311\273\202\333\317\302\241\277=\232\354s\323\021\256\277w}\3525-0\236\277\2739pN\033\321\300?\243\261\030\000bc\302\277/{\342\031m\270\266\277%Z{\340.\275\276?\271\216+QM.l\277\030\030p\206\262\236\260\277\350\221-\332%\332\243?4p\227GX\364\254?x\334x\017s\347n?\374\314\210\340\214\332\215?\'x\313 \261\335\222?\310\261V\255\335k\256?)[s\311x\227\264?\363\264\207\036\256%\303?]\347\261\253\234|\243?\374\321\272\r\023\266\244?l\024e4i\306h\277\035\302sA7\244\300?a@\344E\256\233\222?\351\307\205=\324\257\231\277\376\312\340DzE\276\277=\013\2168 \266\265?\304|O\204A\227\303\277~\n\202\016\212 \270?\311\361 \\\337\241\235?\312,l\220Q\031\202?\024:*\013vM\246?\255\317\252\022\206\321\214?\257\330\001\372\251\026\304\277\245\260\245\237\301?\007\371N8\247|\215?\313s\261\327\245\216\274?\207\300\322p\224\006\265?\003e\032\345\265\256\302?\364\325\251\370\341\331\236\277\264[\030x\225\277\251\277\031\367\240xs)\270?9pv\252tz\247?\266\256rm \311\271\277T\331y\327\345v\263\277\315\n>\327?\345\254\277\335/\027\335\237\022\215?\362\2542R\205\300f\277\353)\331\270\257j\207?M2\226\375\366\201\255?1\2142\256\272\032\240\2772\0222\206X\346\271?\241\203(\361\004\201\242?\246^\005\332\235\327\305\277\371\311\366 x\231\264\27768\221I\004\206\226?\312L\007T\016\212\261\277v\373\245G\201^\304\2776H)\213\256\233\261?\275\t\365\263\2329\271\277\347\232X\274\277\247\250\277\22329qa\006\302?\366jZ\277\326\263\244?E\215\363\037^\275\300?\"\244\373\310o\257\264\277vI\332\334^\222\233\277\355s\031\373,\033\272?Y\026C.7\243\301\2777~\347\373\235C\273\277\271a\313\325\2473\262?\201\017\275\370\315h\265?,H\347\345\017\023\261?\372\'\256i\030\025T\277\365\252\374\247w\271\256?f8zs;3\240\277\344+\020\301\237\020y\277\207E\265\325\037\257\302?\311KKw\373\216\260\277sd=\267PY\262?4\354SX;\213\262?K0\016\3271\222\226?\367J\207tU\200\255\277\202\002\372^F|\271?1b\342\247\032\332\200?\000}ov\322\250\277?Y\327u\362\304L\261?\204\321_\262W\375\241\277_\310\307)c\032\234\277\221\253\344\322%w\301\277K(\3037\376\024\240?\336\330\315\214\301O\262?W\245\362 ~\352\223?a%\037<\205Mw?\247\264\003f_\004\217\277\004b\361\351\314Q\263?\026\'\276\262\231\003\264?i\225\376\3666\201\223\277\206\251\341\316\026\"\252?iR\273\3209\357\266?\2335\334!\203\327\267\277\347\237^\310J\303\221\277\226\257M-\2020\273\277\356\264\255T\212\024\234?\304\027N\336G\354\260?\210\206\271\220\025\305\300?\237\272\377fUc\274?\022\240\301\216\222\rm\277\202}\376\033I\014\231?\272\025-\255\231\333\244\277k\370/^\356\017\220?\244Vo8\323F\257?\274X\202 r\213\263?[sF\317\266\306\302\277\374\306\301J\027\376\272?\017<\240M9\200\230\277\261\243\265YC\200\241\277X-\030>Nr\256?\366\266b\250\306E\246\277 x,\305\371g\221\277\251\275f\"\375\323r\277N\245\353\240\031\355\224?~\342\306I\271\254\202\277\244\031Q\362\360S\262\277\344e\272L\177\313\266\277\024C\230\034k\035\274?\337\026\262;\256=\320?\010\224\263\207\004\n\221?\227z\025\360\tv\274\277\na\010\234^\242\264\277\232\005\005\251\245\025\264\277\261}}\361\363\344\243?\201#\333x\314@\254?\362\343v:\221\302\251\2775\325\021\247\214\302\264\277%\232\305Q\211B\253?\230@\'\332y\317\234?R\204kf\210\257\260\277\316\353\237\347\331\343\317?[\364\225?\274(\242?\014\010}O+h\233?#\301\372\355LK\242\277\032s%\246l\\\275\277\3433;L6\204\267?\346\031nsd\342\262?\200\\t\367G\325\236\2772\020\010\216\301:\266\277V\227\374^\0216\010\277\202\315\301<\237\353\225?\024\373HU\213\001\240\277@9\377\270\311]\243\277\224\356\252\304/r\240\277 \316n[\337\035j\277wn\230\t\365\215\250\277\364\324\013\346\026\364\240?f1\275\322W\224\255\277l\276\034r\251\250\211\277\231\315\241\037\n\321\276\277\3767\341\255\005\215\271?\204\320jYi\026\210\277\302\022]\257\201\360\234\277y\223\014\217Y\037\242?\023\325\253\360\215[\262?\214\241z\360(5\211\277&.{c\302z\245\277\204\373\000\277Gz\231\277\362I\321g)\267\255?\223\364y\235\263r\271?K\201\024\016\2435\213\277?\274\203\247K\216\262\277\375\013.\241\314\362h?H\236\253\222\377C8?\257\373\3414\017\333\244\277\274\277sb\304\266\306\277\367P\233\266V9\213\277h\305\346)\223\272\276?\036\206\233#hH\177\277=7\020\276c9\230\277\227\354B\272[\206\247\277\036/\200x\324\325\300\277\376+<\034\277S\225\277\007\025\314\210\370_\246?}\230\262&&H\265?\001\202i\250\336#\272?\317\317\000\263?\373t\320P\235-\277\277\030AX$\213g\261\277\025T\002n\013\212\272?\211\360=\301\244M\250\277<\353\223\227\2042\240\277>\000H,o\275\266\277,\024$v\035d\261\277\377\240\326\007g\261\265\277k8\0251D\215\254?N\354_\034M\360\220?\331\305U6K\177\267\277\241b\016\251%L\252\277:\217Z\325\002\036\241?\307)\334\223\330\233\225\277\035 \037\245\305(\261?m\360\241\346 \313\227?\363\2047t\224\211\242\277\243\257\307\0139U\250\277j\270\313\355bW\272?>\026S\310h/\225\277[\262\252E\306\265\235\277\315\237\202\266\037#\237?U\244\025\0015\304\250\277lv\331h\210-\223\277\t\'\317c\220Kh\277gD\017\376\230z}\277\013\334c\343\027\273\252?t\263\335\375\272\346\224\277\264\272\261\253\222\237\304\277>\227;\007\311\332\251?9\371`\303(;\221?\227\221\311.)\342\227\277\275d;w\224(\217\277\265X\312!\034h\247?B\001\2531\340\002\250\277\331r\nYk3\206?\344\220\331\326\274\326\r?\003v\016\205L/\303?M\263\227\016\273b\241\277\246\345\377B\274\204\253?\302W\362\351m0\266?f\"\322w\267\313\204\277\200\316\2336\026l\264?S3aq\320f\255\277\2656\260\317\265Q\255?\'_\346L%W\242\277\330\244\375\221v\306\240\277\211\205\374L{\240\206?\320\232\"\036,\351\242\277\026\370\221l\013,\277\277\024\2479\3462\017\254\277\355\004\240\033\250P\226?\323\301\324\276\276\312\303\277\247\301D\254}to\277\255J;,\035Y\204?\016]\311{m2\245?\323\213%J\202\322\246\277a\217\2054\231I\242\277\233\233\237\322\241\314\216?\037\220\210\273\266\376\227\277\211\234U\374|^\267?+/^\373\014[\275\277\004\016\244\337\023a\237\277\032\024,\302s7\307\277\334li3My\256\277\\\343vH7\203\313\277\272\264+\300\t\260f\277\031\202a\350\017\227\233?E\025\210\336x\260\203\277\313\005l\340\360\215\223\277\004*\303\271\365\316b?p\216!U\335\325\274\277^\326^y\327\246\256?\032\316iH\177\362\264\277\231]\270\315\231Q\221?\033t\030x\361\256\264\277Y_\017$\255]\270\277\226\212\036\231\331\242\271\277\010\361\331\3043\306\303?\334\337\356\217\215>\240\277\2770s[sd\260\277\323\263\314\202O\220\300?N\361q\232\263N\300\277q52DC[\252\277z\250\373\223\255\300\224?\035e\243\331\244\363\230\277\256\217\034\034-\232\215\277\360\230c\253\355\013`\277\007\233\033\315\364\236y?\267\201Y\320;y\216\277S\222l\023[\373\245\277\027\ty\021\347\361a\277\2056\326#\317\257\302\277\"\337\376e\372s\300\27744\351\367\372\035\237?\0143.\245G\266\301?\225\255\373X\237\232\274\277\314R\024\256\010*\255\277Iy\010\310\233O\274\277\220\033ke1\350\255\277\367e\030@\267\320\251\277\235\273\003lo\324\255?\216\032\336\013\\\033\250?k\256\317\2746\201\256?Y\235\263T\317\243\236\277\026L\251v\021\225\245\277\203\001H\253\023\003\207\277}`\2712\350\004\200?\023,H\016\272\225t?fo\3562\\\177x\277H\032\274\206\013\265\243?\267\231}wms\265?\036\213A\021\272*y\277r\235Sp\345\344?\000\231Sb\t\017\312\277\355\207\213}\025\221\360\277w\025\344\311\205\007\361?X]iX~\255\316?_\277\305\016xi\361\277\3445\016\177\351\377\330?\304H\321\324#\375\327\277f\276\301\210S&\207?h1\265\272\205\314\323\277\233\"\207\277\356\343\356\2778N\237\250\250\006\334?\355_sb\3651\375\277;\311\352\211\r\317\322?\020 \243x\340\362\357\277Ru[nd\277\374\277\0371\001B\177x\313\277\257^\373)n#\374?\265\274\223\034l\367\361\277\277w>\353\270h\326?\3321\'8\271\202\334\277\r\364.\201\264\374\362\277\264\'\337\334I\263\360\277\322\334\243q\211+\266\277\227\243\355}\002\365\367?\357\206\320\324SQ\367?\026\203?\023_B\350\277\314\234\360%\304Z\346\277IW<\034t\374\357?\035\264\254\320\203\315\335\277\201\345\305h\340\036\315\277FW\205\257\307S\327\277\235^7Z|\276\307?\314WZ\351~\332\312\277?\361\363G\002\004\375\277v\220\355\342r\233\343?\362\353z\253\030\303\272?\316\332\022\036\026\354\343?\227\304\022\272\247\310\360?F\220\323\3133\233\320\277\353\202\2040\016\266\377\277\244\006\035\345\204i\360\277\245,\351\306\372G\340\277\222>&\001b\321\321?\275\201*&\032\357\340\277\327\204G\0209\312\360\277\25385i\356\220\360?G\257\330\271(+\356\277w\237\215J\270\351\376?\246\340\027X<\003\351\277X\250\302z\004\332\371\277\320\372\023\226\201j\341?\022\2772\313w\232\336?z\376\226d\326\371\360?]\007\367\030!\304\360\277" + } + } + } +} +node { + name: "final_layer_type_0/bias/read" + op: "Identity" + input: "final_layer_type_0/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@final_layer_type_0/bias" + } + } + } +} +node { + name: "final_layer_type_0/MatMul" + op: "MatMul" + input: "add_2" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "final_layer_type_0/BiasAdd" + op: "BiasAdd" + input: "final_layer_type_0/MatMul" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "Shape_4" + op: "Shape" + input: "Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_18/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_18/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_18/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_18" + op: "StridedSlice" + input: "Shape_4" + input: "strided_slice_18/stack" + input: "strided_slice_18/stack_1" + input: "strided_slice_18/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_19/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_19/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_19/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_19" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_19/stack" + input: "strided_slice_19/stack_1" + input: "strided_slice_19/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "Reshape_15/shape" + op: "Pack" + input: "strided_slice_18" + input: "strided_slice_19" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_15" + op: "Reshape" + input: "final_layer_type_0/BiasAdd" + input: "Reshape_15/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "concat_2/concat" + op: "Identity" + input: "Reshape_15" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_16/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_16" + op: "Reshape" + input: "concat_2/concat" + input: "Reshape_16/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_21/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_21/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_21/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_21" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_21/stack" + input: "strided_slice_21/stack_1" + input: "strided_slice_21/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "o_atom_dos/shape/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "o_atom_dos/shape" + op: "Pack" + input: "strided_slice_21" + input: "o_atom_dos/shape/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "o_atom_dos" + op: "Reshape" + input: "Reshape_16" + input: "o_atom_dos/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "o_dos/reduction_indices" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "o_dos" + op: "Sum" + input: "o_atom_dos" + input: "o_dos/reduction_indices" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +library { +} +versions { +} diff --git a/source/tests/test_deepdos.py b/source/tests/test_deepdos.py new file mode 100644 index 0000000000..c8968c04d5 --- /dev/null +++ b/source/tests/test_deepdos.py @@ -0,0 +1,881 @@ +import os +import unittest + +import numpy as np +from common import ( + tests_path, +) + +from deepmd.env import ( + GLOBAL_NP_FLOAT_PRECISION, +) +from deepmd.infer import ( + DeepDOS, +) +from deepmd.utils.convert import ( + convert_pbtxt_to_pb, +) + +if GLOBAL_NP_FLOAT_PRECISION == np.float32: + default_places = 4 +else: + default_places = 10 + + +class TestDeepDOS(unittest.TestCase): + @classmethod + def setUpClass(cls): + convert_pbtxt_to_pb( + str(tests_path / os.path.join("infer", "deepdos.pbtxt")), "deepdos.pb" + ) + cls.dp = DeepDOS("deepdos.pb") + + def setUp(self): + self.coords = np.array( + [ + 2.288635, + 1.458305, + 3.706535, + 3.475085, + 3.504745, + 0.09779, + 1.573935, + 1.549525, + 1.131545, + 3.006885, + 4.479635, + 2.619155, + 5.152595, + 4.795225, + 2.359665, + 4.564595, + 2.294005, + 1.920635, + 0.271162, + 2.918505, + 3.850855, + 0.407016, + 4.924935, + 5.053735, + ] + ) + self.atype = [0, 0, 0, 0, 0, 0, 0, 0] + self.box = np.array( + [5.184978, 0.0, 0.0, 0.0, 5.184978, 0.0, 0.0, 0.0, 5.184978] + ) + + self.expected_dos = np.array( + [ + -1.39603429e-03, + -1.92390955e-03, + -2.93336246e-03, + -6.89005044e-03, + -7.84338945e-03, + -6.37879461e-03, + -1.10690045e-02, + -1.57944335e-02, + -1.41017668e-02, + -4.15140057e-03, + 7.71792797e-03, + 1.99412441e-02, + 5.10548794e-02, + 1.01076768e-01, + 1.56039938e-01, + 2.15395112e-01, + 3.02663312e-01, + 3.80252930e-01, + 4.75254195e-01, + 5.58468628e-01, + 6.54641167e-01, + 7.57292255e-01, + 8.32860223e-01, + 9.14471696e-01, + 9.88996826e-01, + 1.04753671e00, + 1.10007427e00, + 1.11869442e00, + 1.13010925e00, + 1.14578536e00, + 1.12353510e00, + 1.13633460e00, + 1.14922214e00, + 1.17046880e00, + 1.23263790e00, + 1.30740559e00, + 1.39474870e00, + 1.47573002e00, + 1.54402758e00, + 1.59417936e00, + 1.63017159e00, + 1.64617480e00, + 1.64632688e00, + 1.64807479e00, + 1.65193703e00, + 1.64721726e00, + 1.69176031e00, + 1.72309620e00, + 1.78413458e00, + 1.80906688e00, + 1.85785015e00, + 1.89456034e00, + 1.96632172e00, + 2.01793914e00, + 2.05232993e00, + 2.08347003e00, + 2.09469635e00, + 2.09994438e00, + 2.09880798e00, + 2.08695957e00, + 2.07824070e00, + 2.08276622e00, + 2.06380779e00, + 2.03929363e00, + 2.02880899e00, + 2.02322430e00, + 1.99222800e00, + 1.93997333e00, + 1.88114274e00, + 1.80893034e00, + 1.76219292e00, + 1.82217359e00, + 1.89333327e00, + 2.02360644e00, + 2.18544345e00, + 2.31464605e00, + 2.38889812e00, + 2.41743755e00, + 2.39244101e00, + 2.36446368e00, + 2.35240437e00, + 2.37677639e00, + 2.40832954e00, + 2.42714922e00, + 2.43265914e00, + 2.39769011e00, + 2.34234329e00, + 2.28782583e00, + 2.26373179e00, + 2.28309212e00, + 2.30357709e00, + 2.31154708e00, + 2.29570135e00, + 2.27557353e00, + 2.24059163e00, + 2.24075605e00, + 2.29794656e00, + 2.37066074e00, + 2.44316172e00, + 2.50178991e00, + 2.53515486e00, + 2.58569544e00, + 2.67054320e00, + 2.76630915e00, + 2.87856375e00, + 2.95530073e00, + 3.03032084e00, + 3.10891371e00, + 3.16266196e00, + 3.23966642e00, + 3.28899912e00, + 3.32381674e00, + 3.36746587e00, + 3.40019385e00, + 3.42817144e00, + 3.43598214e00, + 3.47668524e00, + 3.47685799e00, + 3.52705824e00, + 3.58318639e00, + 3.61960015e00, + 3.66636868e00, + 3.68055774e00, + 3.71591360e00, + 3.71871289e00, + 3.72753381e00, + 3.72466450e00, + 3.70633333e00, + 3.67081890e00, + 3.61239068e00, + 3.55272622e00, + 3.55024882e00, + 3.55061903e00, + 3.56265875e00, + 3.55682624e00, + 3.52874426e00, + 3.50783896e00, + 3.49618604e00, + 3.49037121e00, + 3.42867476e00, + 3.35788068e00, + 3.26222434e00, + 3.17601970e00, + 3.07729261e00, + 3.02038619e00, + 2.98073245e00, + 2.91513464e00, + 2.88749865e00, + 2.83922788e00, + 2.84838806e00, + 2.84492479e00, + 2.92385605e00, + 2.92999346e00, + 2.98952428e00, + 3.05588103e00, + 3.10640124e00, + 3.14875677e00, + 3.21675587e00, + 3.27913677e00, + 3.33546772e00, + 3.38229410e00, + 3.43984400e00, + 3.47070913e00, + 3.50738767e00, + 3.55720798e00, + 3.57609687e00, + 3.57008300e00, + 3.57885280e00, + 3.59893033e00, + 3.61423436e00, + 3.61980550e00, + 3.60556159e00, + 3.56494389e00, + 3.54140919e00, + 3.54576875e00, + 3.55583969e00, + 3.55858720e00, + 3.58428521e00, + 3.61107692e00, + 3.60119203e00, + 3.59449853e00, + 3.57238820e00, + 3.54789758e00, + 3.52535313e00, + 3.53170033e00, + 3.50967874e00, + 3.48335346e00, + 3.46534439e00, + 3.42071765e00, + 3.38548036e00, + 3.33026055e00, + 3.28560776e00, + 3.24771848e00, + 3.23164148e00, + 3.19545771e00, + 3.15457720e00, + 3.09675198e00, + 3.04579247e00, + 3.01345920e00, + 2.97670851e00, + 2.95000711e00, + 2.92729969e00, + 2.89379624e00, + 2.85327974e00, + 2.81009972e00, + 2.77506619e00, + 2.72497897e00, + 2.66778611e00, + 2.59606369e00, + 2.49898796e00, + 2.40319088e00, + 2.26655584e00, + 2.09713280e00, + 1.90081697e00, + 1.69550901e00, + 1.47054048e00, + 1.25949398e00, + 1.05075606e00, + 8.83294485e-01, + 7.30385473e-01, + 5.75582455e-01, + 4.56838769e-01, + 3.50334853e-01, + 2.63205822e-01, + 1.90607598e-01, + 1.40443324e-01, + 9.16355849e-02, + 7.32581544e-02, + 4.85474570e-02, + 2.66933884e-02, + 1.93280518e-02, + 1.02097760e-02, + -2.27192998e-03, + -1.34814976e-03, + 3.94898606e-03, + 6.28424522e-03, + -5.52494008e-03, + 3.76090091e-03, + -1.44064397e-03, + 2.79929602e-03, + -2.88968774e-03, + 6.90724081e-03, + -2.16453825e-03, + -2.19639041e-03, + 2.63994592e-05, + -4.49649270e-03, + 4.30308157e-03, + -3.19810785e-04, + 1.06598030e-03, + -2.42574160e-04, + ] + ) + + self.expected_ados_1 = np.array( + [ + 1.14175532e-03, + -4.19174936e-05, + -7.21885854e-04, + -2.80353452e-05, + 2.28109645e-03, + 9.71054959e-04, + -1.66136145e-03, + 2.41572074e-03, + 7.59108028e-04, + -1.09641315e-03, + 1.05930884e-03, + 1.22141915e-03, + 7.34257777e-04, + 6.65559142e-03, + 1.37987075e-02, + 2.09233653e-02, + 3.13229430e-02, + 3.90634675e-02, + 4.82889212e-02, + 5.64319923e-02, + 7.06793091e-02, + 7.92214066e-02, + 8.53724891e-02, + 9.83516640e-02, + 1.05937433e-01, + 1.14458508e-01, + 1.23284993e-01, + 1.25192022e-01, + 1.26194526e-01, + 1.31977531e-01, + 1.31374207e-01, + 1.35887189e-01, + 1.40204884e-01, + 1.47443044e-01, + 1.59154415e-01, + 1.67596384e-01, + 1.86427662e-01, + 1.93725971e-01, + 2.01287734e-01, + 2.05798493e-01, + 2.11383466e-01, + 2.10529975e-01, + 2.10948934e-01, + 2.13330547e-01, + 2.10421916e-01, + 2.18339681e-01, + 2.24446963e-01, + 2.33688117e-01, + 2.42512492e-01, + 2.43103645e-01, + 2.51145837e-01, + 2.61808994e-01, + 2.68780114e-01, + 2.77509173e-01, + 2.80643596e-01, + 2.80808795e-01, + 2.82641315e-01, + 2.78653415e-01, + 2.74870187e-01, + 2.70382936e-01, + 2.67680230e-01, + 2.60875725e-01, + 2.54114342e-01, + 2.49571462e-01, + 2.45246974e-01, + 2.37318488e-01, + 2.25764569e-01, + 2.17221817e-01, + 2.00175024e-01, + 1.95963933e-01, + 1.88586498e-01, + 2.05101813e-01, + 2.17773534e-01, + 2.46793989e-01, + 2.70504716e-01, + 2.95048730e-01, + 3.14788577e-01, + 3.26637275e-01, + 3.31674055e-01, + 3.34866098e-01, + 3.31791696e-01, + 3.25904579e-01, + 3.19175448e-01, + 3.14870863e-01, + 3.07347313e-01, + 2.99575478e-01, + 2.88188485e-01, + 2.80888515e-01, + 2.75463219e-01, + 2.75962192e-01, + 2.70914392e-01, + 2.72346524e-01, + 2.66575201e-01, + 2.63365725e-01, + 2.60849191e-01, + 2.61214581e-01, + 2.65058337e-01, + 2.72583484e-01, + 2.75791312e-01, + 2.87116593e-01, + 2.94439358e-01, + 3.07951705e-01, + 3.25241910e-01, + 3.45943998e-01, + 3.69523054e-01, + 3.85090178e-01, + 3.96255952e-01, + 4.07755591e-01, + 4.16952481e-01, + 4.26006603e-01, + 4.33746764e-01, + 4.33862772e-01, + 4.42475912e-01, + 4.47680196e-01, + 4.57403410e-01, + 4.59588233e-01, + 4.71249637e-01, + 4.74479663e-01, + 4.81876616e-01, + 4.88556769e-01, + 4.94491769e-01, + 5.02388004e-01, + 5.04097251e-01, + 5.05881204e-01, + 5.08035046e-01, + 5.01445276e-01, + 4.98505709e-01, + 4.89784972e-01, + 4.81614100e-01, + 4.74807751e-01, + 4.62217755e-01, + 4.60946050e-01, + 4.52659675e-01, + 4.53501336e-01, + 4.45706331e-01, + 4.41109113e-01, + 4.39381973e-01, + 4.36055545e-01, + 4.24106541e-01, + 4.12410809e-01, + 3.96092021e-01, + 3.77029550e-01, + 3.60284659e-01, + 3.37813440e-01, + 3.21487274e-01, + 3.15186497e-01, + 3.01281828e-01, + 2.88366497e-01, + 2.79570150e-01, + 2.78651476e-01, + 2.80986285e-01, + 2.90303718e-01, + 3.00018574e-01, + 3.13242081e-01, + 3.20862051e-01, + 3.37943988e-01, + 3.47843716e-01, + 3.64386614e-01, + 3.73867819e-01, + 3.85681914e-01, + 3.95934276e-01, + 4.10017107e-01, + 4.24607864e-01, + 4.36153253e-01, + 4.45913830e-01, + 4.53163893e-01, + 4.53782804e-01, + 4.55815014e-01, + 4.63449080e-01, + 4.68111779e-01, + 4.72112727e-01, + 4.66982304e-01, + 4.63444524e-01, + 4.58356047e-01, + 4.52449991e-01, + 4.52977039e-01, + 4.55984179e-01, + 4.64264003e-01, + 4.76869597e-01, + 4.76048872e-01, + 4.78388604e-01, + 4.77437466e-01, + 4.75562646e-01, + 4.61257457e-01, + 4.62749451e-01, + 4.53935193e-01, + 4.48675591e-01, + 4.42963669e-01, + 4.35824001e-01, + 4.29616948e-01, + 4.24494137e-01, + 4.17412473e-01, + 4.12379942e-01, + 4.09341508e-01, + 4.03414671e-01, + 3.96561009e-01, + 3.90786014e-01, + 3.83890764e-01, + 3.77173193e-01, + 3.70658765e-01, + 3.66654453e-01, + 3.63236154e-01, + 3.56207521e-01, + 3.50589368e-01, + 3.45146125e-01, + 3.40724451e-01, + 3.31700407e-01, + 3.24164395e-01, + 3.14654255e-01, + 3.02725442e-01, + 2.87242813e-01, + 2.66959043e-01, + 2.44904564e-01, + 2.17484655e-01, + 1.98557229e-01, + 1.69451750e-01, + 1.47235840e-01, + 1.20522212e-01, + 1.02667938e-01, + 8.70284577e-02, + 7.16080345e-02, + 5.96054705e-02, + 4.73006111e-02, + 3.84373330e-02, + 2.82578156e-02, + 2.13776086e-02, + 1.68435434e-02, + 9.78067568e-03, + 7.22150185e-03, + 4.92237110e-03, + 1.10008363e-03, + 2.62159776e-03, + 1.60340975e-03, + -1.43055047e-04, + 1.06168289e-03, + 2.64765256e-03, + 1.75308536e-03, + 1.03856602e-03, + -5.73130834e-04, + 1.30352570e-03, + 1.37962860e-04, + -1.85555443e-03, + 1.08196637e-04, + 1.28182817e-04, + 6.35661243e-04, + 1.73742133e-03, + -1.75466671e-04, + -9.39002066e-05, + -2.47114260e-04, + 2.22984128e-04, + ] + ) + + self.expected_ados_2 = np.array( + [ + 4.37750618e-04, + -2.84755141e-04, + -6.59853131e-04, + 6.73644688e-04, + 2.31276095e-03, + 2.18560151e-04, + -4.75346698e-04, + 2.79159285e-03, + 1.74560866e-03, + 1.28767705e-03, + 4.45638374e-03, + 8.08237458e-03, + 9.57354233e-03, + 1.64885909e-02, + 2.61870193e-02, + 3.41981514e-02, + 4.56264900e-02, + 5.55092972e-02, + 6.61801887e-02, + 7.55433635e-02, + 8.85846807e-02, + 9.65154491e-02, + 1.02489414e-01, + 1.13540271e-01, + 1.19991412e-01, + 1.24728643e-01, + 1.32181878e-01, + 1.31369680e-01, + 1.29978364e-01, + 1.33587586e-01, + 1.32928488e-01, + 1.36641235e-01, + 1.41997692e-01, + 1.50958132e-01, + 1.63882685e-01, + 1.73442577e-01, + 1.91027716e-01, + 1.99458087e-01, + 2.05133500e-01, + 2.07975486e-01, + 2.09271601e-01, + 2.06500962e-01, + 2.06228352e-01, + 2.06733416e-01, + 2.03140835e-01, + 2.11942604e-01, + 2.17377985e-01, + 2.27001797e-01, + 2.34500837e-01, + 2.35726174e-01, + 2.41983984e-01, + 2.52500402e-01, + 2.57267031e-01, + 2.65919955e-01, + 2.68827238e-01, + 2.69761516e-01, + 2.71938465e-01, + 2.69081037e-01, + 2.65898431e-01, + 2.63100707e-01, + 2.63516146e-01, + 2.58521749e-01, + 2.54745800e-01, + 2.52718934e-01, + 2.49673786e-01, + 2.42329581e-01, + 2.33873310e-01, + 2.28351106e-01, + 2.13443843e-01, + 2.11956908e-01, + 2.04826947e-01, + 2.16954076e-01, + 2.27877326e-01, + 2.53221319e-01, + 2.73915630e-01, + 2.93494715e-01, + 3.06248452e-01, + 3.12142890e-01, + 3.13961714e-01, + 3.16879141e-01, + 3.16319735e-01, + 3.14301737e-01, + 3.11619366e-01, + 3.11177824e-01, + 3.04191740e-01, + 2.98211798e-01, + 2.88849226e-01, + 2.84207353e-01, + 2.81236363e-01, + 2.83824842e-01, + 2.80422275e-01, + 2.80570045e-01, + 2.76432510e-01, + 2.73302267e-01, + 2.71838229e-01, + 2.74293620e-01, + 2.79934281e-01, + 2.89864631e-01, + 2.93365508e-01, + 3.03229377e-01, + 3.09380242e-01, + 3.20525219e-01, + 3.34765143e-01, + 3.51459640e-01, + 3.68188892e-01, + 3.79535850e-01, + 3.87162763e-01, + 3.96112298e-01, + 4.05099458e-01, + 4.14478443e-01, + 4.22900260e-01, + 4.22298613e-01, + 4.29910448e-01, + 4.33504846e-01, + 4.40685090e-01, + 4.41656343e-01, + 4.50383171e-01, + 4.51256548e-01, + 4.57454902e-01, + 4.64650984e-01, + 4.70633353e-01, + 4.76912361e-01, + 4.77658170e-01, + 4.80482014e-01, + 4.84275651e-01, + 4.79409965e-01, + 4.76688684e-01, + 4.71061984e-01, + 4.63358320e-01, + 4.58944927e-01, + 4.47742653e-01, + 4.47493470e-01, + 4.41143643e-01, + 4.44172680e-01, + 4.37940954e-01, + 4.37225087e-01, + 4.36772611e-01, + 4.34943950e-01, + 4.24801770e-01, + 4.16444551e-01, + 4.02852759e-01, + 3.85265358e-01, + 3.70971870e-01, + 3.52902426e-01, + 3.40187438e-01, + 3.38268743e-01, + 3.26935260e-01, + 3.15814985e-01, + 3.10516400e-01, + 3.08000461e-01, + 3.11578892e-01, + 3.17795720e-01, + 3.25833928e-01, + 3.35835206e-01, + 3.42402433e-01, + 3.57610079e-01, + 3.64845861e-01, + 3.78730173e-01, + 3.85307342e-01, + 3.94934826e-01, + 4.02440605e-01, + 4.13596747e-01, + 4.23561135e-01, + 4.32692247e-01, + 4.40203545e-01, + 4.45291010e-01, + 4.44589502e-01, + 4.44198817e-01, + 4.50512056e-01, + 4.56489469e-01, + 4.59647782e-01, + 4.53951937e-01, + 4.50391516e-01, + 4.45091152e-01, + 4.40331850e-01, + 4.41002923e-01, + 4.43363861e-01, + 4.49741329e-01, + 4.58385671e-01, + 4.55776649e-01, + 4.56814334e-01, + 4.56587814e-01, + 4.55485403e-01, + 4.43580785e-01, + 4.46749524e-01, + 4.41314541e-01, + 4.36978785e-01, + 4.31616813e-01, + 4.26233732e-01, + 4.21321668e-01, + 4.17067671e-01, + 4.10033599e-01, + 4.05599102e-01, + 4.01991787e-01, + 3.97867798e-01, + 3.91444255e-01, + 3.85723756e-01, + 3.79363913e-01, + 3.73115658e-01, + 3.66946552e-01, + 3.65185429e-01, + 3.62364934e-01, + 3.56512826e-01, + 3.50874076e-01, + 3.45818623e-01, + 3.41860046e-01, + 3.34184892e-01, + 3.27630577e-01, + 3.19886213e-01, + 3.10514928e-01, + 2.97272557e-01, + 2.80498862e-01, + 2.59844742e-01, + 2.34551682e-01, + 2.15879337e-01, + 1.88100845e-01, + 1.64389883e-01, + 1.36951746e-01, + 1.17093193e-01, + 9.96545109e-02, + 8.40434593e-02, + 6.93282879e-02, + 5.50489160e-02, + 4.56236402e-02, + 3.49793068e-02, + 2.56817776e-02, + 2.06901055e-02, + 1.29793255e-02, + 9.12834860e-03, + 7.23339850e-03, + 2.85341899e-03, + 2.99081369e-03, + 1.94257419e-03, + 2.47909563e-04, + 4.33900286e-04, + 1.65883835e-03, + 1.81092419e-03, + 5.21943727e-04, + -3.44130907e-04, + 8.94826999e-04, + 4.91047864e-04, + -1.82618130e-03, + 4.20399394e-04, + -4.10782601e-04, + 6.59204079e-04, + 1.97465107e-03, + -4.62844767e-04, + -1.49835051e-04, + -5.06931628e-04, + 5.76254430e-04, + ] + ) + + @classmethod + def tearDownClass(cls): + os.remove("deepdos.pb") + cls.dp = None + + def test_attrs(self): + self.assertEqual(self.dp.get_ntypes(), 1) + self.assertAlmostEqual(self.dp.get_rcut(), 5.0, places=default_places) + self.assertEqual(self.dp.get_type_map(), ["Si"]) + self.assertEqual(self.dp.get_numb_dos(), 250) + + def test_1frame_atomic(self): + dd = self.dp.eval(self.coords, self.box, self.atype, atomic=True) + # check shape of the returns + nframes = 1 + natoms = len(self.atype) + numb_dos = 250 + self.assertEqual(dd[0].shape, (nframes, numb_dos)) + self.assertEqual(dd[1].shape, (nframes, natoms, numb_dos)) + # check values + ados_list = dd[1].ravel().reshape(natoms, numb_dos) + + np.testing.assert_almost_equal(ados_list[0], self.expected_ados_1, 4) + np.testing.assert_almost_equal(ados_list[1], self.expected_ados_2, 4) + np.testing.assert_almost_equal(dd[0].ravel(), self.expected_dos, 4) + + def test_2frame_atomic(self): + coords2 = np.concatenate((self.coords, self.coords)) + box2 = np.concatenate((self.box, self.box)) + dd = self.dp.eval(coords2, box2, self.atype, atomic=True) + # check shape of the returns + nframes = 2 + natoms = len(self.atype) + numb_dos = 250 + self.assertEqual(dd[0].shape, (nframes, numb_dos)) + self.assertEqual(dd[1].shape, (nframes, natoms, numb_dos)) + # check values + expected_ados1 = np.concatenate((self.expected_ados_1, self.expected_ados_1)) + expected_ados2 = np.concatenate((self.expected_ados_2, self.expected_ados_2)) + expected_total = np.concatenate((self.expected_dos, self.expected_dos)) + + self.ados_list = dd[1].ravel().reshape(nframes, natoms, numb_dos) + + np.testing.assert_almost_equal( + self.ados_list[:, 0, :].reshape(-1), expected_ados1, 4 + ) + np.testing.assert_almost_equal( + self.ados_list[:, 1, :].reshape(-1), expected_ados2, 4 + ) + np.testing.assert_almost_equal(dd[0].ravel(), expected_total, 4) diff --git a/source/tests/test_fitting_dos.py b/source/tests/test_fitting_dos.py new file mode 100644 index 0000000000..7e4c5f4c07 --- /dev/null +++ b/source/tests/test_fitting_dos.py @@ -0,0 +1,207 @@ +import numpy as np +from common import ( + DataSystem, + gen_data, + j_loader, +) + +from deepmd.common import ( + j_must_have, +) +from deepmd.descriptor import ( + DescrptSeA, +) +from deepmd.env import ( + tf, +) +from deepmd.fit import ( + DOSFitting, +) + +GLOBAL_ENER_FLOAT_PRECISION = tf.float64 +GLOBAL_TF_FLOAT_PRECISION = tf.float64 +GLOBAL_NP_FLOAT_PRECISION = np.float64 + + +class TestModel(tf.test.TestCase): + def setUp(self): + gen_data() + + def test_fitting(self): + jfile = "train_dos.json" + jdata = j_loader(jfile) + + systems = j_must_have(jdata["training"], "systems") + set_pfx = j_must_have(jdata["training"], "set_prefix") + batch_size = j_must_have(jdata["training"], "batch_size") + test_size = j_must_have(jdata["training"], "numb_test") + batch_size = 1 + test_size = 1 + stop_batch = j_must_have(jdata["training"], "stop_batch") + rcut = j_must_have(jdata["model"]["descriptor"], "rcut") + sel = j_must_have(jdata["model"]["descriptor"], "sel") + ntypes = len(sel) + + data = DataSystem(systems, set_pfx, batch_size, test_size, rcut, run_opt=None) + + test_data = data.get_test() + numb_test = 1 + numb_dos = 100 + + jdata["model"]["fitting_net"]["numb_dos"] = numb_dos + + jdata["model"]["descriptor"]["neuron"] = [5, 5, 5] + jdata["model"]["descriptor"]["axis_neuron"] = 2 + + jdata["model"]["descriptor"].pop("type", None) + descrpt = DescrptSeA(**jdata["model"]["descriptor"], uniform_seed=True) + + jdata["model"]["fitting_net"].pop("type", None) + jdata["model"]["fitting_net"]["descrpt"] = descrpt + fitting = DOSFitting(**jdata["model"]["fitting_net"], uniform_seed=True) + + # model._compute_dstats([test_data['coord']], [test_data['box']], [test_data['type']], [test_data['natoms_vec']], [test_data['default_mesh']]) + input_data = { + "coord": [test_data["coord"]], + "box": [test_data["box"]], + "type": [test_data["type"]], + "natoms_vec": [test_data["natoms_vec"]], + "default_mesh": [test_data["default_mesh"]], + } + + t_prop_c = tf.placeholder(tf.float32, [5], name="t_prop_c") + + t_atom_dos = tf.placeholder( + GLOBAL_TF_FLOAT_PRECISION, [None], name="t_atom_dos" + ) + t_coord = tf.placeholder(GLOBAL_TF_FLOAT_PRECISION, [None], name="i_coord") + t_type = tf.placeholder(tf.int32, [None], name="i_type") + t_natoms = tf.placeholder(tf.int32, [ntypes + 2], name="i_natoms") + t_box = tf.placeholder(GLOBAL_TF_FLOAT_PRECISION, [None, 9], name="i_box") + t_mesh = tf.placeholder(tf.int32, [None], name="i_mesh") + is_training = tf.placeholder(tf.bool) + t_fparam = None + + dout = np.array( + [ + 0.0005722682145569174, + -0.00020202686217742682, + -0.00020202686217742682, + 7.13250554992363e-05, + -0.0014770058171250015, + 0.000521468690207748, + -0.001143865186937176, + 0.0004038453384193948, + 0.0005617335409639567, + -0.00019831394075147532, + 0.00048086740718842236, + -0.0001693584775806112, + -0.0001693584775806112, + 5.966987137476082e-05, + -0.0012342029581315136, + 0.00043492340851472783, + -0.0009566016612537016, + 0.00033706767041080107, + 0.00047065988464132244, + -0.0001657950398095401, + 0.0003647849239740657, + -0.00013744939018250384, + -0.00013744939018250384, + 5.1825826955234744e-05, + -0.00096004206555711, + 0.00036185565262332876, + -0.0007267433909643961, + 0.0002738914365542745, + 0.00038019365906978136, + -0.00014322754331896057, + 0.0004675256930823109, + -0.00017634410399626168, + -0.00017634410399626168, + 6.652672908755666e-05, + -0.0012328062885292486, + 0.00046500213384094614, + -0.0009328887521346069, + 0.0003518668613172834, + 0.0004877847509912577, + -0.00018396318824508986, + 0.0005154794374703516, + -0.00019422534512034776, + -0.00019422534512034776, + 7.318151797939947e-05, + -0.0013576642997136488, + 0.0005115548790018505, + -0.0010275333676074971, + 0.00038716440070070385, + 0.0005376426714609369, + -0.00020257810468163985, + 0.0004482204892297628, + -0.00016887749501640607, + -0.00016887749501640607, + 6.364643102775375e-05, + -0.001181345877677835, + 0.0004452029242063362, + -0.0008941636427724908, + 0.0003369586197174627, + 0.0004677878512312651, + -0.00017625260641095753, + ] + ) + + atype = np.array([0, 0, 1, 1, 1, 1], dtype=np.int32) + + dout = dout.reshape([-1, 10]) + atype = atype.reshape([-1]) + + natoms = 6 + tmp_dos = np.zeros([numb_test, numb_dos]) + tmp_atom_dos = np.zeros([numb_test, natoms * numb_dos]) + test_data["dos"] = tmp_dos + test_data["atom_dos"] = tmp_atom_dos + + atom_dos = fitting.build( + tf.convert_to_tensor(dout), + t_natoms, + { + "atype": tf.convert_to_tensor(atype), + }, + reuse=False, + suffix="se_a_dos_fit_", + ) + + feed_dict_test = { + t_prop_c: test_data["prop_c"], + t_atom_dos: np.reshape(test_data["atom_dos"][:numb_test, :], [-1]), + t_coord: np.reshape(test_data["coord"][:numb_test, :], [-1]), + t_box: test_data["box"][:numb_test, :], + t_type: np.reshape(test_data["type"][:numb_test, :], [-1]), + t_natoms: test_data["natoms_vec"], + t_mesh: test_data["default_mesh"], + is_training: False, + } + + sess = self.test_session().__enter__() + sess.run(tf.global_variables_initializer()) + [pred_atom_dos] = sess.run([atom_dos], feed_dict=feed_dict_test) + + pred_atom_dos = pred_atom_dos.reshape(-1, numb_dos) + + ref_atom_dos_1 = [ + -0.32495014, + -0.87979356, + -0.26630668, + -0.32495882, + -0.87979767, + -0.2663072, + ] + ref_atom_dos_2 = [ + -0.26630917, + 0.21549911, + -0.87979638, + -0.26630564, + 0.21550413, + -0.87979585, + ] + places = 4 + + np.testing.assert_almost_equal(pred_atom_dos[:, 0], ref_atom_dos_1, places) + np.testing.assert_almost_equal(pred_atom_dos[:, 50], ref_atom_dos_2, places) diff --git a/source/tests/test_model_dos.py b/source/tests/test_model_dos.py new file mode 100644 index 0000000000..a6c880046e --- /dev/null +++ b/source/tests/test_model_dos.py @@ -0,0 +1,335 @@ +import numpy as np +from common import ( + DataSystem, + del_data, + gen_data, + j_loader, +) + +from deepmd.common import ( + j_must_have, +) +from deepmd.descriptor import ( + DescrptSeA, +) +from deepmd.env import ( + tf, +) +from deepmd.fit import ( + DOSFitting, +) +from deepmd.model import ( + DOSModel, +) + +GLOBAL_ENER_FLOAT_PRECISION = tf.float64 +GLOBAL_TF_FLOAT_PRECISION = tf.float64 +GLOBAL_NP_FLOAT_PRECISION = np.float64 + + +class TestModel(tf.test.TestCase): + def setUp(self): + gen_data() + + def tearDown(self): + del_data() + + def test_model(self): + jfile = "train_dos.json" + jdata = j_loader(jfile) + + systems = j_must_have(jdata["training"], "systems") + set_pfx = j_must_have(jdata["training"], "set_prefix") + batch_size = j_must_have(jdata["training"], "batch_size") + test_size = j_must_have(jdata["training"], "numb_test") + batch_size = 1 + test_size = 1 + stop_batch = j_must_have(jdata["training"], "stop_batch") + rcut = j_must_have(jdata["model"]["descriptor"], "rcut") + + data = DataSystem(systems, set_pfx, batch_size, test_size, rcut, run_opt=None) + + test_data = data.get_test() + numb_test = 1 + numb_dos = 100 + natoms = test_data["type"].shape[1] + test_data["atom_dos"] = np.zeros([numb_test, natoms * numb_dos]) + test_data["dos"] = np.zeros([numb_test, numb_dos]) + + jdata["model"]["fitting_net"]["numb_dos"] = numb_dos + jdata["model"]["descriptor"]["neuron"] = [5, 5, 5] + jdata["model"]["descriptor"]["axis_neuron"] = 2 + + jdata["model"]["descriptor"].pop("type", None) + descrpt = DescrptSeA(**jdata["model"]["descriptor"], uniform_seed=True) + + jdata["model"]["fitting_net"].pop("type", None) + jdata["model"]["fitting_net"]["descrpt"] = descrpt + fitting = DOSFitting(**jdata["model"]["fitting_net"], uniform_seed=True) + model = DOSModel(descrpt, fitting) + + input_data = { + "coord": [test_data["coord"]], + "box": [test_data["box"]], + "type": [test_data["type"]], + "natoms_vec": [test_data["natoms_vec"]], + "default_mesh": [test_data["default_mesh"]], + } + model._compute_input_stat(input_data) + + t_prop_c = tf.placeholder(tf.float32, [5], name="t_prop_c") + t_atom_dos = tf.placeholder( + GLOBAL_TF_FLOAT_PRECISION, [None], name="t_atom_dos" + ) + t_dos = tf.placeholder(GLOBAL_TF_FLOAT_PRECISION, [None], name="t_dos") + t_coord = tf.placeholder(GLOBAL_TF_FLOAT_PRECISION, [None], name="i_coord") + t_type = tf.placeholder(tf.int32, [None], name="i_type") + t_natoms = tf.placeholder(tf.int32, [model.ntypes + 2], name="i_natoms") + t_box = tf.placeholder(GLOBAL_TF_FLOAT_PRECISION, [None, 9], name="i_box") + t_mesh = tf.placeholder(tf.int32, [None], name="i_mesh") + is_training = tf.placeholder(tf.bool) + t_fparam = None + + model_pred = model.build( + t_coord, + t_type, + t_natoms, + t_box, + t_mesh, + t_fparam, + suffix="se_a_dos", + reuse=False, + ) + dos = model_pred["dos"] + atom_dos = model_pred["atom_dos"] + + feed_dict_test = { + t_prop_c: test_data["prop_c"], + t_dos: np.reshape(test_data["dos"][:numb_test, :], [-1]), + t_atom_dos: np.reshape(test_data["atom_dos"][:numb_test, :], [-1]), + t_coord: np.reshape(test_data["coord"][:numb_test, :], [-1]), + t_box: test_data["box"][:numb_test, :], + t_type: np.reshape(test_data["type"][:numb_test, :], [-1]), + t_natoms: test_data["natoms_vec"], + t_mesh: test_data["default_mesh"], + is_training: False, + } + + sess = self.test_session().__enter__() + sess.run(tf.global_variables_initializer()) + [pred_dos, pred_atom_dos] = sess.run([dos, atom_dos], feed_dict=feed_dict_test) + + ref_dos = np.array( + [ + -2.98834333, + -0.63166985, + -3.37199568, + -1.88397887, + 0.87560992, + 4.85426159, + -1.22677731, + -0.60918118, + 8.80472675, + -1.12006829, + -3.72653765, + -3.03698828, + 3.50906891, + 5.55140795, + -3.34920924, + -4.43507641, + -6.1729281, + -8.34865917, + 0.14371788, + -4.38078479, + -6.43141133, + 4.07791938, + 7.14102837, + -0.52347718, + 0.82663796, + -1.64225631, + -4.63088421, + 3.3910594, + -9.09682274, + 1.61104204, + 4.45900773, + -2.44688559, + -2.83298183, + -2.00733658, + 7.33444256, + 7.09187373, + -1.97065392, + 0.01623084, + -7.48861264, + -1.17790161, + 2.77126775, + -2.55552037, + 3.3518257, + -0.09316856, + -1.94521413, + 0.50089251, + -2.75763233, + -1.94382637, + 1.30562041, + 5.08351043, + -1.90604837, + -0.80030045, + -4.87093267, + 4.18009666, + -2.9011435, + 2.58497143, + 4.47495176, + -0.9639419, + 8.15692179, + 0.48758731, + -0.62264663, + -1.70677258, + -5.51641378, + 3.98621565, + 0.57749944, + 2.9658081, + -4.10467591, + -7.14827888, + 0.02838605, + -2.48630333, + -4.82178216, + -0.7444178, + 2.48224802, + -1.54683936, + 0.46969412, + -0.0960347, + -2.08290541, + 6.357031, + -3.49716615, + 3.28959028, + 7.83932727, + 1.51457023, + -4.14575033, + 0.02007839, + 4.20953773, + 3.66456664, + -4.67441496, + -0.13296372, + -3.77145766, + 1.49368976, + -2.53627817, + -3.14188618, + 0.24991722, + 0.8770123, + 0.16635733, + -3.15391098, + -3.7733242, + -2.25134676, + 1.00975552, + 1.38717682, + ] + ) + + ref_ados_1 = np.array( + [ + -0.33019322, + -0.76332506, + -0.32665648, + -0.76601747, + -1.16441856, + -0.13627609, + -1.15916671, + -0.13280604, + 2.60139518, + 0.44470952, + -0.48316771, + -1.15926141, + 2.59680457, + 0.46049936, + -0.29459777, + -0.76433726, + -0.52091744, + -1.39903065, + -0.49890317, + -1.15747878, + 0.66585524, + 0.81804842, + 1.38592217, + -0.18025826, + -0.2964021, + -0.74953328, + -0.7427461, + 3.27935087, + -1.09340192, + 0.1462458, + -0.51982728, + -1.40236941, + 0.73902497, + 0.79969456, + 0.50726592, + 0.11403234, + 0.64964525, + 0.8084967, + -1.27543102, + -0.00571457, + 0.7748912, + -1.42492251, + 1.38371838, + -0.17366078, + -0.76119888, + -1.26083707, + -1.48263244, + -0.85698727, + -0.7374573, + 3.28274006, + -0.27029769, + -1.00478711, + -0.67481511, + -0.07978058, + -1.09001574, + 0.14173437, + 1.4092343, + -0.31785424, + 0.40551362, + -0.71900495, + 0.7269307, + 0.79545851, + -1.88407155, + 1.83983772, + -1.78413438, + -0.74852344, + 0.50059876, + 0.1165872, + -0.2139368, + -1.44989426, + -1.96651281, + -0.6031689, + -1.28106632, + -0.01107711, + 0.48796663, + 0.76500912, + 0.21308153, + -0.85297893, + 0.76139868, + -1.44547292, + 1.68105021, + -0.30655702, + -1.93123, + -0.34294737, + -0.77352498, + -1.26982082, + -0.5562998, + -0.22048683, + -0.48641512, + 0.01124872, + -1.49597963, + -0.86647985, + 1.17310075, + 0.59402879, + -0.705076, + 0.72991794, + -0.27728806, + -1.00542829, + -0.16289102, + 0.29464248, + ] + ) + + places = 4 + np.testing.assert_almost_equal(pred_dos, ref_dos, places) + np.testing.assert_almost_equal(np.sum(pred_atom_dos, axis=0), ref_dos, places) + np.testing.assert_almost_equal(pred_atom_dos[0], ref_ados_1, places) diff --git a/source/tests/train_dos.json b/source/tests/train_dos.json new file mode 100644 index 0000000000..cab1e6e452 --- /dev/null +++ b/source/tests/train_dos.json @@ -0,0 +1,72 @@ +{ + "model": { + "descriptor": { + "type": "se_a", + "sel": [ + 60, + 60 + ], + "rcut_smth": 4.80, + "rcut": 5.00, + "neuron": [ + 25, + 50, + 100 + ], + "resnet_dt": false, + "axis_neuron": 6, + "seed": 1 + }, + "fitting_net": { + "type": "dos", + "numb_dos": 100, + "neuron": [ + 100, + 100, + 100 + ], + "resnet_dt": true, + "numb_fparam": 0, + "seed": 1 + } + }, + + "loss": { + "type": "dos", + "start_pref_dos": 0.0, + "limit_pref_dos": 0.0, + "start_pref_cdf": 0.0, + "limit_pref_cdf": 0.0, + "start_pref_ados": 1.0, + "limit_pref_ados": 1.0, + "start_pref_acdf": 0.0, + "limit_pref_acdf": 0.0 + }, + + "learning_rate": { + "type": "exp", + "start_lr": 0.001, + "stop_lr": 1e-8 + }, + + "training": { + "systems": [ + "system/" + ], + "set_prefix": "set", + "stop_batch": 100000, + "batch_size": 1, + "seed": 1, + "disp_file": "lcurve.out", + "disp_freq": 100, + "numb_test": 0, + "save_freq": 1000, + "save_ckpt": "model.ckpt", + "disp_training": true, + "time_training": true, + "profiling": false, + "profiling_file": "timeline.json" + }, + + "_comment": "that's all" +}