hexsha
string
size
int64
ext
string
lang
string
max_stars_repo_path
string
max_stars_repo_name
string
max_stars_repo_head_hexsha
string
max_stars_repo_licenses
list
max_stars_count
int64
max_stars_repo_stars_event_min_datetime
string
max_stars_repo_stars_event_max_datetime
string
max_issues_repo_path
string
max_issues_repo_name
string
max_issues_repo_head_hexsha
string
max_issues_repo_licenses
list
max_issues_count
int64
max_issues_repo_issues_event_min_datetime
string
max_issues_repo_issues_event_max_datetime
string
max_forks_repo_path
string
max_forks_repo_name
string
max_forks_repo_head_hexsha
string
max_forks_repo_licenses
list
max_forks_count
int64
max_forks_repo_forks_event_min_datetime
string
max_forks_repo_forks_event_max_datetime
string
content
string
avg_line_length
float64
max_line_length
int64
alphanum_fraction
float64
qsc_code_num_words_quality_signal
int64
qsc_code_num_chars_quality_signal
float64
qsc_code_mean_word_length_quality_signal
float64
qsc_code_frac_words_unique_quality_signal
float64
qsc_code_frac_chars_top_2grams_quality_signal
float64
qsc_code_frac_chars_top_3grams_quality_signal
float64
qsc_code_frac_chars_top_4grams_quality_signal
float64
qsc_code_frac_chars_dupe_5grams_quality_signal
float64
qsc_code_frac_chars_dupe_6grams_quality_signal
float64
qsc_code_frac_chars_dupe_7grams_quality_signal
float64
qsc_code_frac_chars_dupe_8grams_quality_signal
float64
qsc_code_frac_chars_dupe_9grams_quality_signal
float64
qsc_code_frac_chars_dupe_10grams_quality_signal
float64
qsc_code_frac_chars_replacement_symbols_quality_signal
float64
qsc_code_frac_chars_digital_quality_signal
float64
qsc_code_frac_chars_whitespace_quality_signal
float64
qsc_code_size_file_byte_quality_signal
float64
qsc_code_num_lines_quality_signal
float64
qsc_code_num_chars_line_max_quality_signal
float64
qsc_code_num_chars_line_mean_quality_signal
float64
qsc_code_frac_chars_alphabet_quality_signal
float64
qsc_code_frac_chars_comments_quality_signal
float64
qsc_code_cate_xml_start_quality_signal
float64
qsc_code_frac_lines_dupe_lines_quality_signal
float64
qsc_code_cate_autogen_quality_signal
float64
qsc_code_frac_lines_long_string_quality_signal
float64
qsc_code_frac_chars_string_length_quality_signal
float64
qsc_code_frac_chars_long_word_length_quality_signal
float64
qsc_code_frac_lines_string_concat_quality_signal
float64
qsc_code_cate_encoded_data_quality_signal
float64
qsc_code_frac_chars_hex_words_quality_signal
float64
qsc_code_frac_lines_prompt_comments_quality_signal
float64
qsc_code_frac_lines_assert_quality_signal
float64
qsc_codepython_cate_ast_quality_signal
float64
qsc_codepython_frac_lines_func_ratio_quality_signal
float64
qsc_codepython_cate_var_zero_quality_signal
bool
qsc_codepython_frac_lines_pass_quality_signal
float64
qsc_codepython_frac_lines_import_quality_signal
float64
qsc_codepython_frac_lines_simplefunc_quality_signal
float64
qsc_codepython_score_lines_no_logic_quality_signal
float64
qsc_codepython_frac_lines_print_quality_signal
float64
qsc_code_num_words
int64
qsc_code_num_chars
int64
qsc_code_mean_word_length
int64
qsc_code_frac_words_unique
null
qsc_code_frac_chars_top_2grams
int64
qsc_code_frac_chars_top_3grams
int64
qsc_code_frac_chars_top_4grams
int64
qsc_code_frac_chars_dupe_5grams
int64
qsc_code_frac_chars_dupe_6grams
int64
qsc_code_frac_chars_dupe_7grams
int64
qsc_code_frac_chars_dupe_8grams
int64
qsc_code_frac_chars_dupe_9grams
int64
qsc_code_frac_chars_dupe_10grams
int64
qsc_code_frac_chars_replacement_symbols
int64
qsc_code_frac_chars_digital
int64
qsc_code_frac_chars_whitespace
int64
qsc_code_size_file_byte
int64
qsc_code_num_lines
int64
qsc_code_num_chars_line_max
int64
qsc_code_num_chars_line_mean
int64
qsc_code_frac_chars_alphabet
int64
qsc_code_frac_chars_comments
int64
qsc_code_cate_xml_start
int64
qsc_code_frac_lines_dupe_lines
int64
qsc_code_cate_autogen
int64
qsc_code_frac_lines_long_string
int64
qsc_code_frac_chars_string_length
int64
qsc_code_frac_chars_long_word_length
int64
qsc_code_frac_lines_string_concat
null
qsc_code_cate_encoded_data
int64
qsc_code_frac_chars_hex_words
int64
qsc_code_frac_lines_prompt_comments
int64
qsc_code_frac_lines_assert
int64
qsc_codepython_cate_ast
int64
qsc_codepython_frac_lines_func_ratio
int64
qsc_codepython_cate_var_zero
int64
qsc_codepython_frac_lines_pass
int64
qsc_codepython_frac_lines_import
int64
qsc_codepython_frac_lines_simplefunc
int64
qsc_codepython_score_lines_no_logic
int64
qsc_codepython_frac_lines_print
int64
effective
string
hits
int64
175f61b9d802a91e4de9d9247955ef5ce23d1af4
35
py
Python
tf_semseg/model/pretrained/openmmlab/__init__.py
fferflo/tf-semseg
b392cac2e8cca5389e7a099e8f7a87d72f4a70fc
[ "MIT" ]
null
null
null
tf_semseg/model/pretrained/openmmlab/__init__.py
fferflo/tf-semseg
b392cac2e8cca5389e7a099e8f7a87d72f4a70fc
[ "MIT" ]
null
null
null
tf_semseg/model/pretrained/openmmlab/__init__.py
fferflo/tf-semseg
b392cac2e8cca5389e7a099e8f7a87d72f4a70fc
[ "MIT" ]
null
null
null
from . import upernet_vitb_ade20k
17.5
34
0.828571
5
35
5.4
1
0
0
0
0
0
0
0
0
0
0
0.066667
0.142857
35
1
35
35
0.833333
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
17822a1b24fd1c362503fd797eef56d974a5838a
366,229
py
Python
Colab_notebook/psp_colab_notebook.py
Ramprasad-Group/PSP
6f0df0a052898c8f44a58ef9ab0578731455c4a3
[ "MIT" ]
11
2022-02-24T00:29:46.000Z
2022-03-30T08:07:00.000Z
Colab_notebook/psp_colab_notebook.py
Ramprasad-Group/PSP
6f0df0a052898c8f44a58ef9ab0578731455c4a3
[ "MIT" ]
null
null
null
Colab_notebook/psp_colab_notebook.py
Ramprasad-Group/PSP
6f0df0a052898c8f44a58ef9ab0578731455c4a3
[ "MIT" ]
1
2022-03-05T01:49:48.000Z
2022-03-05T01:49:48.000Z
# -*- coding: utf-8 -*- """psp_Colab_notebook.ipynb Automatically generated by Colaboratory. Original file is located at https://colab.research.google.com/drive/1CuAuTpxlR6f1CT_Qmm6LJ8GzP7GyNkDR # Polymer Structure Predictor (PSP) Polymer Structure Predictor (PSP) is an autonomous model generator that builds a hierarchy of polymer models from SMILES strings, ranging from monomers, linear and loop oligomers, infinite polymer chains, to crystal and amorphous structures. The flexibility to define parameters allows for the construction of desired models at a reasonable computational cost. Individual output models can be visualized and used to perform *ab initio* and molecular dynamics simulations. In this tutorial, we will cover: - Instation of PSP and dependencies - Examples for building polymer models - $MoleculeBuilder$ (Linear and circular oligomers) - $ChainBuilder$ (Finite and infinite polymer chains [*periodic*]) - $CrystalBuilder$ (Crystal models for small molecules and polymers) - $AmorphousBuilder$ (Amorphous structures) > The user can save a copy of this notebook to Google Drive or download it using the **File** tab (top left) for later use. # Install PSP and dependencies - Miniconda - Scipy (v1.7.3) - Open Babel (v3.1.1) - RDKit (v2020.09.1.0) - Packmol (v20.3.1) - PySIMM (v1.1) - py3Dmol (v1.7.0) - Ambertools (v3.1.1) - PSP (v0.1.0) ## Install Miniconda Miniconda is a free minimal installer for conda. For more details visit https://docs.conda.io/en/latest/miniconda.html. ### Download the installer script The following code downloads the suitable Miniconda installer script. """ !wget https://repo.anaconda.com/miniconda/Miniconda3-py37_4.10.3-Linux-x86_64.sh !chmod +x Miniconda3-py37_4.10.3-Linux-x86_64.sh """### Unset the *PYTHONPATH* variable It is recommended that you clear the PYTHONPATH environment variable prior to installing Miniconda. Otherwise, it may cause problems if the packages installed and accessible via the PYTHONPATH directories are incompatible with the Python version included with Miniconda. """ # Commented out IPython magic to ensure Python compatibility. # %env PYTHONPATH= """### Install Miniconda The code below will install Miniconda into */usr/local*. """ !./Miniconda3-py37_4.10.3-Linux-x86_64.sh -b -f -p /usr/local """### Appending to the sys.path You must include the directory where *conda* will install packages in the list of directories that Python will search for modules to import. """ import sys _ = (sys.path.append("/usr/local/lib/python3.7/site-packages")) sys.path """## Install Scipy (v1.7.3) SciPy provides algorithms for optimization, integration, interpolation, eigenvalue problems, algebraic equations, differential equations, statistics, and many other classes of problems. Additional information can be found at: https://scipy.org. It will be installed as follows: """ !conda install -y -c anaconda scipy=1.7 """## Install RDKit (v2020.09.1.0) RDKit is a cheminformatics toolkit for reading SMILES strings and writing and optimizing 3D molecular structures, among other things. Additional information can be found at: https://www.rdkit.org/. It will be installed as follows: """ !conda install -y -c rdkit rdkit """## Install Open Babel (v3.1.1) Openbabel is used to read, write, and convert chemical file formats, obtain information about atomic connectivity, and perform constrained optimization. For additional information, see: https://open-babel.readthedocs.io/en/latest/ReleaseNotes/ob310.html. It will be installed using the following code: """ !conda install -y -c conda-forge openbabel """## Install Packmol (v20.3.1) Packmol generates initial configurations for amorphous structures by utilizing 3D geometries of individual molecules. It packs all molecules into a predefined simulation box with a specified minimum intermolecular distance cutoff. For additional information, see: http://leandro.iqm.unicamp.br/m3g/packmol/home.shtml. The following codes will download the PACKMOL to /usr/local/ and install it. """ !git clone https://github.com/m3g/packmol.git /usr/local/packmol cd /usr/local/packmol !make """The code snippet below will create a variable for the PACKMOL executable.""" # Commented out IPython magic to ensure Python compatibility. import os os.environ['PACKMOL_EXEC'] = '/usr/local/packmol/packmol' # %cd .. """## Install PySIMM (v1.1) PySIMM is an open-source, object-oriented Python package for molecular simulations. Additional information can be found at: https://pysimm.org. This package is used for generating GAFF2 FF parameter files. The following code will install it and append it to the *sys.path*. """ !git clone -b 1.1 --single-branch https://github.com/polysimtools/pysimm sys.path.insert(0,'/usr/local/pysimm') """##Install py3Dmol (v1.7.0) Py3DMol is a python package for molecular visualization in iPython notebooks. For more details, visit https://github.com/avirshup/py3dmol. It is used to visualize 3D models generated by PSP. It will be installed as follows: """ !pip install py3Dmol """Function **visualize3D** shows 3D structure of molecules. It accepts **pdb**, **xyz** and **vasp** files as input.""" import py3Dmol def visualize3D(input_file, supercell=[1,1,1]): if input_file.split(".")[-1] == 'vasp': !obabel -iposcar $input_file -ocif > model_wCell.cif input_file = "model_wCell.cif" with open(input_file) as ifile: print(input_file) system = "".join([x for x in ifile]) view = py3Dmol.view(width=400, height=300) view.addModelsAsFrames(system) view.setStyle({"stick":{}}) # 'colorscheme':'greenCarbon' view.addUnitCell() view.replicateUnitCell(supercell[0],supercell[1],supercell[2]) view.zoomTo() view.show() """## Install Polymer Structure Predictor (PSP) The code snippet below will download the PSP package from the Ramprasad GitHub account and install into /usr/local. *Currently, PSP is a private package. To download the package, please use your GitHub login credentials.* """ # Commented out IPython magic to ensure Python compatibility. # %cd /usr/local !git clone https://github.com/Ramprasad-Group/PSP.git # %cd PSP !python setup.py install """## Verify that PSP and dependencies are installed properly If all packages are properly installed, PSP is capable of building a hierarchy of polymer models using SMILES, starting from monomer, oligomers, infinite polymer chains, crystal, and amorphous structures. It can also generate GAFF2 FF parameter files for molecules and amorphous structures. """ !pip show PolymerStructurePredictor from rdkit import Chem from openbabel import openbabel as ob import psp.AmorphousBuilder as am """**Note**: LAMMPS and LigParGen packages are not installed. So, it doesn't perform MD simulations or generates an OPLS FF parameter file. *If you encounter an error during the package installation, contact hsahu3@gatech.edu.* ## Install Ambertools (v3.1.1) AmberTools is a set of programs for biomolecular simulation and analysis. Additional information can be found at: https://ambermd.org/AmberTools.php. This package is used for generating GAFF2 FF parameter files. """ !conda install -y -c conda-forge ambertools """The code snippet below will create a variable for the *antechamber* executable.""" import os os.environ['ANTECHAMBER_EXEC'] = '/usr/local/bin/antechamber' """## Clean /content/ directory and move test files to /content/polymer_models/ The following code snippet will remove unnecessary files and move sample INPUT files to the /content directory. """ # Commented out IPython magic to ensure Python compatibility. # %cd /content/ !rm Miniconda3-py37_4.10.3-Linux-x86_64.sh !rm -rf sample_data/ !mkdir /content/polymer_models !cp -r /usr/local/PSP/test/* /content/polymer_models/ """# PSP Examples There are four modules in PSP, each of which is designed to build a specific type of polymer model. - $MoleculeBuilder$ (Linear and circular oligomers) - $ChainBuilder$ (Finite and infinite polymer chains [*periodic*]) - $CrystalBuilder$ (Crystal models for small molecules and polymers) - $AmorphousBuilder$ (Amorphous structures) Note that $ChainBuilder$ accepts only polymer SMILES, whereas $MoleculeBuilder$ and $AmorphousBuilder$ accept both polymer and molecule SMILES strings. >**Polymer SMILES**: Two linking atoms are indicated with asterisks (\[\*]). For example, a SMILES string for polypropylene can be expressed as C(C(C)\[\*])\[\*]. For more details, please visit our *Polymer Genome (PG)* website at: https://www.polymergenome.org. To obtain a polymer SMILES string, use the $Draw Polymer$ tool of the PG platform. >**Model visualization**: The function $visualize3D(input\_file, supercell=[1,1,1])$ can be used to visualize models in XYZ, PDB, and POSCAR ($.vasp$) file formats. Users must use the POSCAR file to see the boundary box or supercell structures. Supercell (default value: supercell=[1,1,1]): Users need to define the size of the supercell as [x,y,z] where x, y, z define replication of the unit cell along X, Y, and Z directions, respectively. Users can rotate and zoom in/out the molecule using the mouse pointer. >**Download models** : Go to the **Files** tab (on the notebook's left side) and navigate to the relevant directory; then, simply select and download. If you don't see directories or models, refresh it. In the */content/polymer_models* directory, we provided test samples for all model builders available in PSP. Let's go to the respective directories and start building models. ## MoleculeBuilder $MoleculeBuilder$ is designed to build 3D structures of linear and circular oligomers. It accepts SMILES strings for both molecules and polymers as input, and output models are saved in a variety of formats, including xyz, pdb, poscar, and lammps data files, as well as GAFF2/OPLS parameter files. Several examples are provided here to show how we can quickly build models with $MoleculeBuilder$. Let's go to the *polymer_models/MoleculeBuilder* directory: """ cd /content/polymer_models/MoleculeBuilder """### **Example 1**: Linear oligomers with endcap units Now, we intend to construct a model for linear oligomers with endcap units. To construct such a model, users must define SMILES strings for the repeating/endcap units and the length of an oligomer. Note that the endcap SMILES include just one [\*\], as there is only one connecting atom. Let's build a model for **Pentaethylene** end-capped with **CF$_3$** and **CCl$_3$**. As shown below, SMILES strings for the repeating unit of polyethylene and endcap units (**CF$_3$** and **CCl$_3$**) are provided. The oligomer is defined to have a length of 5 units. Let's run the code below to build a pentamer model. """ # Input SMILES strings and length of the oligomer repeating_unit = '[*]CC[*]' leftcap_unit = 'C(Cl)(Cl)(Cl)[*]' rightcap_unit = 'C(F)(F)(F)[*]' oligo_length = 5 # Create a pandas DataFrame import pandas as pd input_data = [['PE',repeating_unit,leftcap_unit,rightcap_unit]] df_smiles = pd.DataFrame(input_data, columns = ['ID', 'smiles', 'LeftCap', 'RightCap']) # Build models import pandas as pd import psp.MoleculeBuilder as mb mol = mb.Builder(df_smiles, Length=[oligo_length], GAFF2=True) results = mol.Build() """PSP terminated normally. All models are stored in *molecules/* directory. As mentioned before, models are stored in different file formats. The output files are named according to the following convention: \$*ID*_N\$*Length*_C\$*NumConf*.\$*file_format*.""" ls molecules/ """Let's visualize a model built by $MoleculeBuilder$.""" visualize3D("molecules/PE_N5_C1.xyz") """###**Example 2**: Loop oligomers $MoleculeBuilder$ also builds loop models of a polymer. Required inputs are SMILES of the repeating unit and length (in terms of the number of monomer units) of the loop oligomer. Below, we have shown an example of a loop model for deca(vinyl chloride). As can be seen, we have provided the SMILES string for poly(vinyl chloride) and defined the length as 10 units. """ # Input SMILES string and length of the oligomer repeating_unit = 'C(C([*])Cl)[*]' oligo_length = 10 # Create a pandas DataFrame import pandas as pd input_data = [['PVC',repeating_unit]] df_smiles = pd.DataFrame(input_data, columns = ['ID', 'smiles']) # Build models import pandas as pd import psp.MoleculeBuilder as mb mol = mb.Builder(df_smiles, Length=[oligo_length], Loop=True) results = mol.Build() """PSP normally terminated. All PSP output files are stored in *molecules/* directory. Let's visualize the loop model for deca(vinyl chloride).""" visualize3D("molecules/PVC_N10_C1.vasp") """### Additional information $MoleculeBuilder$ allows fine-tuning of atomic models by adjusting a variety of parameters or keywords. Users may also construct several models simultaneously by defining all the input SMILES strings in a comma-separated values (CSV) file and supplying them as a pandas DataFrame to $MoleculeBuilder$. $MoleculeBuilder$ supports the following **parameters** or **keywords**: - $\verb=Dataframe=$ **:** A *pandas Dataframe* that contains polymer IDs and SMILES strings representing repeating and endcap units. - $\verb=ID_col=$ [*default option=`ID'*] **:** Column name for IDs of polymers/molecules in the Dataframe. - $\verb=SMILES_col=$ [*default option=`smiles'*] **:** Column name for the polymer SMILES string (repeating unit) in the Dataframe. - $\verb=LeftCap=$ [*default option=`LeftCap'*] **:** Column name for the SMILES string of left cap molecular fragment in the Dataframe. - $\verb=RightCap=$ [*default option=`RightCap'*] **:** Column name for the SMILES string of right cap molecular fragment in the Dataframe. - $\verb=Inter_Mol_Dis=$ [*default value=6$Å$*] **:** When periodic boundary conditions are applied (POSCAR format), it determines the minimum distance between two molecules in x, y, and z directions. - $\verb=Length=$ [*default option=[1]*] **:** Monomer and oligomers can be generated by setting $\verb=Length=$ as desired. For example, if $\verb=Length=$=[1,2,5], monomer, dimer, and pentamer chains will be constructed. - $\verb=NumConf=$ [*default value=1*] **:** PSP can create *N* number of conformers if $\verb=NumConf=$=*N* is assigned, where *N* is an integer. - $\verb=Loop=$ [*default option=False*] **:** It specifies whether to produce a linear or circular oligomer model. For circular one, set $\verb=loop=$=True. - $\verb=IrrStruc=$ [*default option=False*] **:** If $\verb=IrrStruc=$=True, a short MD simulation will be performed to generate a more relevant structure. *This feature is not available here.* - $\verb=OPLS=$ [*default option=False*] **:** If $\verb=OPLS=$=True, an OPLS FF parameter file will be generated for each model. - $\verb=GAFF2=$ [*default option=False*] **:** If $\verb=GAFF2=$=True, an GAFF2 FF parameter file will be generated for each model. - $\verb=GAFF2_atom_typing=$ [*default option=`pysimm'*] **:** Use *pysimm* or *antechamber* for atom typing. - $\verb=OutDir=$ [*default option=`molecules'*] **:** The output directory, which contains output models of all molecules in XYZ ($\textit{.xyz}$), POSCAR ($\textit{.vasp}$), and PDB ($\textit{.pdb}$) formats, including FF parameter files. **NOTE**: In the colab notebook, $\verb=IrrStruc=$ and $\verb=OPLS=$ do not work. $\verb=IrrStruc=$ necessitates the installation of LAMMPS. $\verb=OPLS=$ requires the BOSS executable and the LigParGen package. Please contact Prof. William L. Jorgensen for the BOSS executable, and to install LigparGen, follow the instructions at http://zarbi.chem.yale.edu/ligpargen. As previously stated, users can provide a CSV file to build multiple models at the same time. An example CSV file containing SMILES strings of one molecule and two repeating polymer units, including endcap units, is provided below. Note that endcap units for **Mol1** are not provided, and the corresponding columns are left blank. """ cat linear_oligomer_with_endcaps.csv """Below is an example of a python code snippet required for $MoleculeBuilder$. The definitions of keywords and parameters are provided above.""" cat molecule_model.py """###**Example 3**: Build multiple models using a CSV file Now, we'll build models for all the SMILES provided in the CSV file (*linear_oligomer_with_endcaps.csv*). Also, we will simultaneously build monomer and pentamer models for each case, which is defined by $\verb=Length=$. GAFF2 parameter files will be generated, which can then be used directly in LAMMPS MD simulations. All output models will be stored in */models* directory. """ df_smiles = pd.read_csv("linear_oligomer_with_endcaps.csv") mol = mb.Builder( df_smiles, ID_col="ID", SMILES_col="smiles", LeftCap = "LeftCap", RightCap ='RightCap', OutDir='models', Inter_Mol_Dis=6, Length=[1,5],#16 NumConf=1, Loop=False, NCores=1, IrrStruc=False, OPLS=False, GAFF2=True, GAFF2_atom_typing='antechamber' ) results = mol.Build() """PSP terminated normally. Users can visualize models stored in */models* directory using the $\verb=visualize3D()=$ function. **Note:** it accepts *.pbd*, *.xyz* and *.vasp* file formats.""" ls models/ """Users can modify the supplied CSV file or upload their own to create the desired models. ## ChainBuilder $ChainBuilder$ builds periodic 3D structures of finite and infinite polymer chains (periodic) using polymer SMILES strings. Notably, all generated models are aligned along the Z-axis. Infinite polymer chains are stored in POSCAR format ($.vasp$), while oligomers are stored in POSCAR and XYZ formats. Several examples are provided to show how quickly infinite chain models can be built using $ChainBuilder$. Let's go to the *polymer_models/ChainBuilder* directory: """ cd /content/polymer_models/ChainBuilder/ """### **Example 1**: Models for infinite polymer chains The minimum input required to construct a periodic chain model is the repeating unit SMILES string. Here's an example of creating an infinite polymer chain model for poly(vinyl chloride). """ # Input SMILES string repeating_unit = 'C(C(CC([*])Cl)Cl)[*]' # Create a pandas DataFrame import pandas as pd input_data = [['PVC',repeating_unit]] df_smiles = pd.DataFrame(input_data, columns = ['ID', 'smiles']) # Build models import psp.ChainBuilder as ChB chain_builder = ChB.Builder(Dataframe=df_smiles) results = chain_builder.BuildChain() """PSP normally terminated. The polymer model is saved in the directory: *chains/PVC/*. Let's see how the model looks.""" visualize3D("chains/PVC/PVC.vasp") """### Additional information $ChainBuilder$ allows fine-tuning of chain models by adjusting a variety of parameters or keywords. Users can also build multiple models simultaneously by defining all of the input SMILES strings in a CSV file and supplying them to $ChainBuilder$ as a pandas DataFrame. $ChainBuilder$ allows altering the following **parameters** or **keywords**: - $\verb=Dataframe=$ **:** A pandas Dataframe having polymer IDs and SMILES strings. - $\verb=ID_col=$ [*default option=`ID'*] **:** Column name for the polymer IDs in the Dataframe. - $\verb=SMILE_col=$ [*default option=`smiles'*] **:** Column name for the polymer SMILES strings (repeating unit) in the Dataframe. - $\verb=Length=$ [*default option=`n'*] **:** It defines the lengths of oligomers. For example, if $\verb=Length=$=[1,2,5,*`n'*], monomer, dimer, pentamer, and infinite polymer chain will be created. Note that *`n'* stands for infinite polymer chains. - $\verb=Method=$ [*default option=`SA'*] **:** The default option for $\verb=method=$ is *`SA'*, which means that the simulated annealing (SA) method will be used. If method=*`Dimer'*, then the $ChainBuilder$ will create dimers by rotating one monomer unit while keeping the other one fixed. This can quickly create polymer chains; however, the quality of chains may not be good, and the number of atoms in a unit cell will be high. - $\verb=Steps=$ [*default value=20*] **:** The computational cost of $ChainBuilder$ mainly depends on how many steps and substeps are used in the SA method. \verb=Steps= is the outer loop of the SA, and we recommend to set a large value ($\verb=Steps=$=100 or more) if there are many rotatable single bonds in a molecule. To avoid unnecessary calculations, if the SA doesn't find a better geometry after three steps, it is terminated. - $\verb=Substeps=$ [*default value=10*] **:** $\verb=Substeps=$ is the inner loop of the SA, and $\verb=Substeps=$=20 should be sufficient for most of the cases. - $\verb=IntraChainCorr=$ [*default option=True*] **:** $ChainBuilder$ sometimes generates a twisted polymer (often helical) backbone. If $\verb=IntraChainCorr=$=True, $ChainBuilder$ makes the backbone straight by gradually moving two sets of the dummy and linking atoms towards opposite directions on the $z$-axis. - $\verb=Tol_ChainCorr=$ [*default value=50*] **:** While straightening a monomer, we apply a cutoff for a sudden energy bump (in KJ/mol) defined by $\verb=Tol_ChainCorr=$. Once it is reached, $ChainBuilder$ doesn't stretch the molecule further. - $\verb=OutDir=$ [*default option=`chains'*] **:** This key allows users to define a directory where they want to store output files. As previously stated, users can provide a CSV file to build multiple chain models at the same time. An example CSV file containing repeating unit SMILES strings for 6 different polymers is provided below. """ cat input_chain.csv """The python code snippet required for $ChainBuilder$ is shown below. The definitions of keywords and parameters are provided above. """ cat chain_model.py """###**Example 2**: Build multiple chain models Using the given CSV file (*input_chain.csv*), let's build infinite chain and pentamer models for 6 polymers simultaneously. """ import pandas as pd import psp.ChainBuilder as ChB df_smiles = pd.read_csv("input_chain.csv") chain_builder = ChB.Builder( Dataframe=df_smiles, ID_col="PID", SMILES_col="smiles_polymer", NumConf=1, Length=["n", 5], Steps=20, Substeps=20, MonomerAng="intense", DimerAng="intense", Method="SA", NCores=0, OutDir='chains', Tol_ChainCorr=50, ) results = chain_builder.BuildChain() """PSP terminated normally. All infinite and pentamer chain models are stored in *chains/* directory. The output files are named according to the following convention: *\$ID_1.\$file_format* (infinite chain) and *\$ID_N\$Length.\$file_format* (oligomers).""" !ls chains !ls chains/ABPBO """Let's visualize a pentamer chain model generated using $ChainBuilder$:""" visualize3D("chains/ABPBO/ABPBO_N5.vasp") """To generate your desired chain models, modify the CSV file or upload your own and adjust the parameters as needed. ## CrystalBuilder $CrystalBuilder$ generates crystal models for small molecules and infinite polymer chains. It accepts only POSCAR files as INPUT that can be generated using $ChainBuilder$. Users can also provide their own POSCAR files as INPUT. Note that all input chain models are expected to be aligned along the Z-axis. Examples of crystal models are given below, starting with the construction of a chain model, which is then used to build crystal models. Let's go to the *polymer_models/CrystalBuilder* directory """ # Commented out IPython magic to ensure Python compatibility. # %cd /content/polymer_models/CrystalBuilder/ """###**Example 1**: Crystal structures for an infinite polymer chain First, we'll use $ChainBuilder$ to create an infinite chain model for poly(vinyl chloride). See the $ChainBuilder$ section for more information. Second, using the generated chain model, several crystal models will be built by placing two chains in a simulation box and translating and rotating one while fixing the other. The SMILES string of a polymer repeating unit is the minimum requirement for building crystal models.The following is an example of crystal models for poly(vinyl chloride). """ # Input SMILES string repeating_unit = 'C(C(CC([*])Cl)Cl)[*]' # Create a pandas DataFrame import pandas as pd input_data = [['PVC',repeating_unit]] df_smiles = pd.DataFrame(input_data, columns = ['ID', 'smiles']) # Build chain models import psp.ChainBuilder as ChB chain_builder = ChB.Builder(Dataframe=df_smiles, Inter_Chain_Dis=0.0) results = chain_builder.BuildChain() # Build crystal models import psp.CrystalBuilder as CrB vasp_input_list = ['chains/PVC/PVC.vasp'] crystal_builder = CrB.Builder(VaspInp_list=vasp_input_list, NSamples=3, Polymer=True) results = crystal_builder.BuildCrystal() """PSP terminated normally. We created 27 crystal models for Poly(vinyl chloride). Models are stored in *crystals/PVC/* directory and follow the following naming convention: *cryst_out-$N.vasp*, where *N* is an integer, indicating the model's serial number. **NOTE** : While rotating and translating polymer chains, identical crystal structures can be generated. Before proceeding with downstream ab-initio simulations, it is strongly advised to filter out identical models and keep only unique ones. """ ls crystals/PVC """Let's visualize a crystal model for poly(vinyl chloride):""" visualize3D("crystals/PVC/cryst_out-06.vasp") """###**Example 2**: User defined configurations $CrystalBuilder$ allows us to construct a specific set of desired crystal models by providing translational distance and rotational angles. Let's build a T-shape crystal model for penta(vinyl chloride), including a few models close to it. To get a T-shape model, we need to rotate molecule B around its Y-axis (See Figure below). ![Crystal5.png](data:image/png;base64,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) ![Crystal1.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAADwAAAALhCAYAAADi9FHaAAAAAXNSR0IArs4c6QAAAHhlWElmTU0AKgAAAAgABAEaAAUAAAABAAAAPgEbAAUAAAABAAAARgEoAAMAAAABAAIAAIdpAAQAAAABAAAATgAAAAAAAAFKAAAAAQAAAUoAAAABAAOgAQADAAAAAQABAACgAgAEAAAAAQAADwCgAwAEAAAAAQAAAuEAAAAAaLkv1wAAAAlwSFlzAAAywAAAMsABKGRa2wAAQABJREFUeAHs3QmcLFddN+6TkPWGBIQQwk5CFiDs+5rcuQkEwhLWoCCCQY2gKAp/UXx9uSCCiMAL5hUBwZdFlEWUxUjIMjfIJruyCAIhLGFJwpKQff1/z8z03J6eqp7umZ6enpnnfCiq6tSpU+c8daq6ufRvTikSAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgbILAwIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIExi8wXcoN8+Odx15XyvFZ3rGtlHeNvxWuSGDkArtkbN8ztT4myxHXlPL8Y0r5n5FfRYUECKxI4NRSbrV7KU/ctZSj8hn0sqlSPrmiCp1MgAABAgQIECBAgAABAgQIECAwcoHdRl6jCgkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQWCRwSil77lHKffKDnQcl2OqoBP8m3qrskXVN+2QRADxD4b/Wm0AG7h77z47n4zOeH53lFp0+XK+U92RbAHAHxJrAGgp8uJSb5zPoCQn6fVKacf8sMx9B+a8a/CsAeA3vjUsTIECAAAECBAgQIECAAAECBJoEBAA3qcgjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECKwzgQTg7f0LCcLLj0Ey4Wa5OtF21/wgy/ZSrl2rrqRNif2bXW6S9dVZzi7l0pNKuWqt2jSO63YCfdP52+V6h2TprO+cIKs9axtmIq7qxs504c5NWwQmUyAzhh6Qd8ztEzx4aFpYx3ZdDs14rvtbsixKeQFdtChTBgECqyqQWbgPzB+aODzP5u1zodtnfXhdZ7ltluwuTHlOL1mYY48AAQIECBAgQIAAAQIECBAgQGASBPLvsRIBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMB6FqjBvwmwPTsRPQd2+lEjfeqyI0uCgBJ7W67J8RocfE32Z9YN+9fWY8mvQcO1XF1fl/3E+5Xdsj8T0Jv9mXVT3lyZ3ebOyWpn2j2badO/ZXXcztyNt7VnKUcE6CPD9CxQAoCHAVN2TQQyg/WbM1YfMeTFje0hwRQnsBKBHaW8POf/wYIP4CUqTFkBwEsYOUyAAAECBAgQIECAAAECBAgQWAsBAcBroe6aBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIERCiT496oE78wH//ZWnWP1NyLzvxPpDQrq3m/brnV2H+tcozevd79Trmu9f9f2htxM1PR1NUJ6yHT5kOUVJ7AuBPJOEAC8Lu6URm4ggfnP+yH6dPEQZRUlQIAAAQIECBAgQIAAAQIECBAYk8By/qFnTE1zGQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgUEEpjLD73SC7BJod4NByq9xmZ+u8fVX/fKZLvknuchb64UyI3ImBC4H5t7cOesb1bymlHKXNeXLIzBhAh9Ney6tbcqYrZN63yxj+95Z11nCG9NVpVzUeEAmAQKrIpA/QnFuHsjP18rnntP6GdT3j2+knADgVbkbKiVAgAABAgQIECBAgAABAgQIrExAAPDK/JxNgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEJgIgQT3/DgNWRQAPBfU87McvyzbV2R9Zcpdk+3ECJXrsl/XnXTLbNy6s9O7zjnfTvlza3626yS39bcnM0vyazDgvsnfN9v7ZDurxSnHN3wA8NFxSs+f1t37DyX4d69SPpO8g7rzu7bNANyFYXMyBaZK+fPelp1RyqPyMnh/b35nP8dmAoY7+9YECKyuwLZSXpUr1GU+TZfymHwo//N8xuINAcCLTeQQIECAAAECBAgQIECAAAECBNZcQADwmt8CDSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIjESgBgAf3KkpgbYnZ9rNFxxfys87eUutEyD0vAQIvaJPuVdvLeU1fY7PHNqe2UCPKmW/azLrbYL/Xpc6j+ick3bV2XE3XXpY+r2jlE+k4we1dN4MwC0wsidbIAHvH8y74/I854lxX5zyDrhkca4cAgTGKTBVyr/kOf1xntMbN103+Z7TJhh5BAgQIECAAAECBAgQIECAAIE1Fth1ja/v8gQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAqMRmJ+9L0G2lyea9HnDBP/ONWGpINSBZqndnlmFE2z0s2NK+ffU+3+6u5cfq2z4GYC7+9u9namWf9S937M9kG3POXYJTIJAnUm8NbD/LDMAT8I90oYBBE4t5VYJkn31jlKeOUDx9Vik3+fv/HeI9dixUbd5E4yFUZNtyPqMgw15W3WKAAECBAgQIECAAAEC607ADMDr7pZpMAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgUWA+eDfBeP91XClXNJbqk5nA4ctybmuqx1sPthzILMBf7v6BSuroF4DUUsvGyO4XJLkc242hohcbQaDt3ZH8y7fnDwJshD7qw8YVOK2UW+9eynMzXk/Ke3rP2tMzSjkls1t/e4P1ut8fmhAAnJu9icbCBhvao+2OcTBaT7URIECAAAECBAgQIECAwMoEuv//lZXV5GwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIG1FJgP7EkQ038tpyGZnbdvgO9Sx5uueXUp5/T8QGXTBgDHp5/v/P1rcpRHYJ0KGNfr9MZthmafWcp9E/D7e+nr47Pslu35lM+7C+d3NshG+ndVW1cuKSX/2bxps42FzXun+/fcOOjv4ygBAgQIECBAgAABAgQIrI1Az/+/sjaNcFUCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEVC8zHLiUA+LvLqS3TdF6aoKfWlHr7BbA2npepFM/vPpBr/KR7f5Nt9wuG7HdskzHp7gYSyN8AkAhMnkBm+H1sPu/e29SyfNZdM7UBA4DTryvnvyj0dDwWl/ZkbZrdzTgWNs3NHaKjxsEQWIoSIECAAAECBAgQIECAwFgF+v1/NmNtiIsRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBDaCwGml3DkziB2xBn2Z/0PwCfA5dznXr8FB/c5bTgBwgqiuznnzMynmxyqbeQbgK/r4CgDug+PQuhUQALxub93Gbng+J9tiYeuBi9L7fHRtrJR+tX7Gf6rP7MAbS2FxbzbjWFisIMc4MAYIECBAgAABAgQIECBAYFIFBABP6p3RLgIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGBdCiQK98b5QcaZaxAEPB8AnFl2v79MvGv6nbecAOC5+i7o1Js6NnMAcL9gyH7BwR0+awLrTaDvO2W9dUZ7N5RAvz+68PMN1dOdnWn7DLpueyn56rBp02YcC5v2ZvfpuHHQB8chAgQIECBAgAABAgQIEFg7AQHAa2fvygQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMDGFThg3EHACaw9r8OZ7WXNAJw29w0AysHLOtcYZp1Z1X7cKZ9owE0bAJz70uqbY1d1jKwJbCCBtoDDDdRFXVmPAv0+z/I+3pABwH0+gzb1c7oZx8J6fGZXu83GwWoLq58AAQIECBAgQIAAAQIElisgAHi5cs4jQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECPQXGGsQcCJzT7qylMPqcr1SvtK/ac1HE5zbd7bOTDG8rADgBB09vtO2RP8uKzi5ucXrKzeB0K0BwOnJpg7AWl93UmuHEDCuh8BSdHwC+Zxs/TzLu/qS8bVkrFfKx3Fj2tR/gGKTjoXGgbCZM42DzXz39Z0AAQIECBAgQIAAAQKTLZD/X0YiQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBYJYFOEPC2baV8eZWuMVPtcaVckY2vr+QaCXrqGwCcui9fTv1TpXxvOedttHPq7IsxbkwD2DeeJ5PAhAsIAJ7wG7SJm9f6eZZ39aUb0SWfM21/hGKzP6ebbixsxPE9gj4ZByNAVAUBAgQIECBAgAABAgQIjF7ADMCjN1UjAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKBboBMEfER35iRuLxWEmujg1hkTJ7E/k9am/FCnbfbFGpXVFpg1ad3QHgLDCGz2wMJhrJQdo0Bexv0+zzbkDMDpc9tn0KZ+TjfjWBjjo7ZuLmUcrJtbpaEECBAgQIAAAQIECBDYdAICgDfdLddhAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYA0E1kUQcJ/goBmyRAhdtQZ2LkmAwDoVWOqPCqzTbmn2BhDIX1zo93nWLzh4Pfe+MQA4mf0s1nN/B2r7Jh0LA9lspkLGwWa62/pKgAABAgQIECBAgACB9SWw2/pqrtYSIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBEYj8KFSbrRHKQflB//75S+o75tlz1HUnECatpl+O0HA27aV8uVRXEsdKxc4o5RbJEjxkNz/g3PvDs72wan1oCx1PPwweT/I8v3kfz8zIH/zylI+clwpV6z8yoPXcFopd8+PfO6ZdhyWdtTl1tmuM1R+L8u5Wc5Ju953bCnfHbzW5ZX8QClbtpRydNpwaJZqdbusb5P15WnTt7M+py7Z/upHSjlt+yrObPz6UnY/tJTjcv1fyzXvnuV+U7Mm2VyYPljKL+xTyl2Te7ssh+Scur5t2rlLts/Pe+CCrL+Z/dOz/o+pUlZ9RsxTM87yDrpnrndorl8965Jmlp9muSBt+X7yP5JIxB2PnM1L9uqn+m7cq5Tjc6XbZzkk7bhN1pdnOSfLt+o6eV/YVspns903pdy6CCx8Vyl77F/KMenMg3IPbpb1gVkfkHVWMzPF/iz34pvZ+Z/sf2iqlG9kvax0St4tebk89HqlPCEV5NaWb28t5R5NlU2nHcl/Rpb7Z7lNrp/Tyk/j+sWsT047vpR32G2CfGXq/Hn263shh9vT9lJ2vWPakOd4rwy2nFb2yhi75Lg8B21npR23rdfIQ3HxxSl7Qil5HS5O21P3UXlH5H20JWN7j7SnvqMGTuN8Hwep9RnPsVULAF7Ld2jGT7rWmFotGkuPIXOjjoVRP/+D3orpPOcpe3zGwNOyvmue0a0PLeXrg57fr1zqvluOPyZ1PzoD7Jq8SI7MO2Lkz9Bqv6fT9tbnIMdG3p+4rZt7slbjtnfcTer3pt522idAgAABAgQIECBAgMCoBXYbdYXqI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhMmsD2BCU9OMGBiZw6Om3bmh/y3yWBCon3yoH6XyNMqbdfEgTcT2eMxxJ4cafcq5fmko/qXLbp3tW8Tn79oU3G0CU597SMoQ8kIO6Dx5ZyXuf8Ua9PT7BvrvlXqTdxOjvb0btd9xPF95q068y09c1bS/nHZKWJo0upuwaDPi/1J66n7NtUc47VINyZVM22JljyzFJengijt500mkDQXVLfXVL10Xlu67Ocx3pnW9Lh22Z/QcBh2l0DbF6Y5dlpUw2uXZBqO2vqvAeyvz27F+W8N19Typ8fU8qP6vFRpe251JGlPDzXqe2p93WmCZ3rd1+nHsh4e871E0S9I0Gnac+L0ulPdZcZ4fYu6XM1fUaWx2apgaEzaaaBs5sPnMuaaXTKfzXH3npd7m8nv2Gdx2RyU56xB8f+mVkekVbu16+l3fcoff9Y+v6WdO5dDynlwn7n1WM1qHqPXCvnPDFLfefMXyt+ObQo1fvxByn7pzmye+/R5D8g5902+Q9Lu3ZkkNftsiNjJfmX5viVWV+VdeKWy27Z3j3be2S9R9Z5rSxMOf91yXnWwtwFe59OI/evDd2SZUeC4VJXYghnAuaunqt7S9Yz46YzeKbT16m8J1Oub0q5sb+P0/7WYL80tga8jzSlj5PwDk23F6fct7xeJiNtxLGwms9/v7t2xuwf6Jj5vMyNf2ju8w075fNSuU228/E8fHpXPppulHdQ3j2PzfKY1HBQp5Zco9yklBtnteCzuHN8OetxvadjtOrvhPV0T9Zq3PaOke2T+72pt6n2CRAgQIAAAQIECBAgsGoCi/4xb9WupGICBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwJgFEkhySC75a1mekqCEW3YuXwMU1jAJAl5D/ARf3CYBKy/KGHhqmpHN4VLOq0Gkdaa7xyTI7doEpD5uW2bfHa6WpUunnY+6XilvT8n5QMElzto1bTomZY7JuD/xmlJ+OTsrDl5N4M3BQdqeup+Suof1OiwnvOnwnB+nX4rTx5bow/zhzPJ2QAKU7pDr3iGZt6/rBOfcI+uZwP35gl0biXSsAYnzqd7r7PxTzrnnfOZgG/vlnOfsVspvxPKlU7OB4rn88tPrE4B5WCm/lXqfnVoOHrKm6n5cxsNxac8/ZRrCE49LkPKQdbQWT50PS7temgLzAdythbsO5Jwa0PjSrF+SdW3jopRjC+7JogJrlJE+b03b/ncuP7WcJuTcB+a8B2aMvibj7NCjZ2fiLvU+HzobGHfHDJg7plxdH5H1TftcJ4/rzlTryDPzj8l53M7cxVups872W7LOJeZTfQ8kZrz5Dwbk2KjS3qlr7+7KmupOw27eXaZ3uz6jGThr8j5O21qD/dKmJWf7nE4g9VSfOjp9Xat3aOf662W9EcbCWjz/9f5mdtab5PtInUH+kOzWGe7zGir3z/o29XhN2V6Q8tJZ8g8XJNB3jwTzHpxn5XY5+Xap445Z3y3rO2e9ZUGFXTtX5I8QdO0uezPP2Kq8p9salH6O7J2wnu7JWo3btvvQya/tmtTvTZ02WhMgQIAAAQIECBAgQGBcAvl3aokAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgsLEEEmxYA67+V5Y6W2ljYNoa91gQ8BrcgIyLozImTs2SWJmFKYEfn03OZ7J8I8cvTDDpzbK+c5Y6M+iCQLeuM3fNeSMPcEzQy+/muq/KdZY1dnPuMQkW/c8EVD06gYmf6mrvwJunlXKD/LCoPkO/k5P2GPjE5oK3SkdOSSDcMceU8unmIgtzc4N2JKcG/86ntKVvyvHEHc2mXOveMagzjx7QyVvGus5o+pLcj3vl3KdOlXLxMuooactd0pa3pK679ZxfZ2v97+R9Jsf+M9v5z0zA1iOzXwO5FqXkPz6D8YjUeXws/2dRgSEyMj4ekHa9LKcc2XBaDYA8P8u+WX6h4Xh3Vus4TYdG/nx0X3jY7enZ4LXX5LymPg9bXS2/VyLdfto5MTft5sHYUfdzr2ZSZz2327S6ujszAU9vyH7f4N9aPrbfmVs/K+ujc50anPfwLANcspydch/Ne+7crGv6j9lV63+/Jder47cG49+itVQOpNzlKTOddR3TX2gre+Yavo9z7SPSrue2tS35vzOdAO/0o77j6/jeLcue2a+zKNfAx33rdup5zLZS3p/9RWmt36GLGjTBGRtlLGRs/Oe4n/96WzMgz8pqweflUrc74/cnS5XJh+dTUubNKTtUunbujxMMdVJX4Tx7Nch41d7TXZea3xz1O2E93ZO1+Nyah2/ZmNTvTS3NlU2AAAECBAgQIECAAIFVF6j/MCURIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBDaEwCmZLTXBcS9OZ347wQOJbZvoJAh4jLcnwVi3TmDOu3PJBcG/Cdj5apY/TBDX+5qak8x9MwXvkzOe/jTHMxnewpT88xbmLH9vewLNjirllanzOcuvZfbM1HHT9PedeSbuetwQs8W+K89NOvnrOb8+Rwv6G6erk/+5rM/OsXOynRiXcqcsdTbABWWz35v2yw+VPpT7sPUhpXyx9+Ao9tOemQDgBPI8ItvvTJ37jKjex6SeU2MzdcIQAa3VMgFUL8i5f5Jl9562fCIzMD7x6J0BmN2Hfz/BuQ/JC+zVybxj94G6nb7dPpanTWdm46lSLug9vtR+zjswdbwy5Z7cXTb3tQa/vyHrf0693+gcS/k6o+ydkl+fg1/K0joLc+eczjplc9rap7nnuI7pZ2fp/WyobTwny5ey/Hd2LstyQNp+WJYHJ681AD7lzn3UCme7zDUyFGbTdCkvzP7TO/tLrL9dj0/lucqqLiXnP6hup45+Y//ftmY26Vp+0JRrPK9TNteoQcDV8VmdvK711xPxffSxpXy3K2/R5lq8j7fPvl9rv+sfWDhmUaN6MlJmZubwrBeknv0bLjiYnXet43dob1/Gsb+Rx8IgfhlPK3r+566RV9Fw6aquP1ww3Jn9S6ch1+Qhm/9jHP1LLzw67vf09tV9J2yIe7LwDu3cG9G43Vnh3FZ9f07i96ZFDZVBgAABAgQIECBAgACBMQsIAB4zuMsRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECqyOQoL86u+vfZ7nF6lxhVWoVBLwqrAsrTUDB3om+/Jfk9gap1tlX75Pg39aZXY8v5ecp8/pE1717r1L+NtuPzTKfEkSz5Cx684X7b+x1VGLHMn4f310sESRnJa/OznnOtZmZOEG9N03ewclLLGr/2W1T5rZp8/9JuRO76+y3ncjOOvPe67rL5HqXZP9vc/1XH13Kt7uPdbZPLeWgRFa/PvuJ721NN8p9+PMcfURribkDuWadMffRdTfbW7KqMzLfdO5w4yqBh1fsSPByyr8uZeeDPLN/YZZTkveprM/Lus7eeXAquXP2H9pdtrHi2cwHJCilujyjT5nuQ7vE8u+S8dTuzLntv/5agrxPKiXDpzFdF+cPT5dy37TtLSnRNBvsrZP/jxnbx2YgzAeQNdbWlbmjlGemzy9L1g062dm/OtsvuqyUVxzXELg1Nft8fDJlPpkb/NxDU0fG4Uuyv2+njklen1bK3fMjuQ/Esvez4dK0+3np/9vm+rioGxnX+2TMHpNzfy/LUb0Fkvf17ry4XJj9l3bl7Z/66/O6LXk53Jiqf8ln2ONT7oWNJRoyU+93erOnMqvvjtng3Df3Huvs5zn+amd7Oetc46vTpTw/bX1W9/lpz8+uiNHDSvlBd37vdsbs2N/Hae9T0o7tafMhve1Z4f65vedPyju0t12TuL/RxkIe8DV5/vMB8Ox84OVjY+bzsv7BgltlOT7jPV8BmlNe6D9rPrIzN8/zu1LZrVNPrXO3POM3znat+5gsje+zHK/v1aHTON/TtXGr/U5YT/dkrcZtwyCZyO9NDe2URYAAAQIECBAgQIAAgbEL5H9vSwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB9S2QwKkX5EcQL86SGIh1mc5LUNa2baV8eS1bf0YpDwjgx9racHmCPxLcNaqA17bLjDw/gR4nZWz8TXfFCWSpQa33mhoiGC7Bj7sfNhtIWoNfZlIi9/bPzo87+/3WOzJ7ao6/o1+ZeixtS+zITHtPbmtfAqf2SDRzre816dt8MGc9vyddmzbePG38UU9+426sagDw57sOXpf23LGtHV3l6uYuOf+5Of/Psl0Dhhal2reM9dskUmlR4Nyiwj0ZO0r51WS9uSd7fjd1/79c++nzGQlEyrX+KBGar2sLtk17b5vydcbw38h6yYDW1PekPKfh759S78mp87caSr10ayl/3JDfmJV69ko9n8vBOzQWKOVXtiaAteXYguwdpbw8GX+wIDNByOnTL6ZP7+3J77t7aoLA9pwdo8f1LZiZircmyHqJMqt2OH4PSuUfjGHvM/KpBIz/chqW4TFYSl31uf/H1HXjzhnXJeh9qpTf7Oy3rXPuE3Leu1uOfyf34NE5/rEs/WbuXXB6XhJH5zk6c0FmdjI46yzeX01dh/Qem9s/e2spt2s5NlB2+vPI1P+B7sLpw/Mzjv6iO69pO+eO/X2ca56W9tb7N9KUPt8+ff5ad6W51iS/Q/81bW16Zr+zNe/l7n6MY3ujj4WOYfo5tue/65q/nDHf+NlwXb7/TM3O7N4pPtR6R//P4vO2LvHHOnovFp+xv6dzzbG9Ezr9zTXXzT2pbU57xzpuc72TM2Yn6ntT595ZEyBAgAABAgQIECBAYK0Fdl3rBrg+AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGC5AjXQKT8Yf2N+APFn+dH49ZZbzwSc15kJ+IgJaMtGbMIjGzo1nQCYoWbCrEGk183OYDtfXaKh6wzBI0up/3upbGva9tv92pdZX6/M8bdcXcqDU/77fRqw627NAV+Np6S+Gnw8n9Kes/q1Y77g7MZ1KfuXOWfBLMbdZXbJc5rn9endeYNub82Muqm7Ndg6dc/Xm3I70pc7JzjvtW3Bv/W6ae85WZ6XQL5755wFgXz1eG/KNV5c3zu9+d3707NB0IuCWGr9mRrxxd1ll9pO2y5P257dp9wf5lia1T+lTX+ZEr3Bv/Wk58ZoqODfetKxpXx3a4JA06eT6/4kpjNKOTIwp2ZZEPybNv9TlgcOE/xb+zdVyul5OBbMAJ56zh6k7+eX8s8pe3FL2TrDZm3nPvV4yl2de/5XudbRVyX4PvtPzfL3Nb/7/DxHGU6LU94N9RmuM3+3pYOnS7lf28EB83+xp9x5+YsKg46FtXgf/1Pa+4kYnp7lfVmq51t6+tC9+/7cgwcF8oFBf0DK3j/b9832fbJ977pdjyV6fNH9T5kc2plSfmLeoTtbNTFbG3osdJTH+fx3rpl1v+83K/rekmej/lGKtnR524Gm/DPW7j09tndCV7/XxT3ptHec43Z6Ar83dRysCRAgQIAAAQIECBAgMAkC+fd9iQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCw/gRqEF5mOayzMT5h/bW+scUHpC/3z5EvNx6VuSyBjJO943p078kJyuqe5bb3cOt+Ar4+cngpiX8pib8rVyXYLhOJjix997JS7nlcKYm7GCw9pJQvJoDm1xKRekrbGWns3XPs79qOd+enntqv7vS33TuDbE9lxtUdcUrZI5vK534clfw6S/ByUg2geWC/E3Nvn5c2vCplsjlY2pbg3NMS1Lf77CytYW1OafvhB5SS217+oalEHW/J/19Nx9KYV+XeXtF0rF9eIKcD9sNc+8CGcnc8PTObZmrTNL85ZXxsy7nPbTj6nfMyg21D/qBZNeD72dOlXJD6tw960jjK5WHYMwP5TbnWlp7r1ee1jo/EaQ6f4vzv6e856e9t69lZtwakd9eeAXNNPS95d+rO72ynnpvW7etmg9Afk/HYHSj23zn09pz/nhx/T8rOBKCnA4m5bU1vyZGXZtmvqUTqOTH5n2w6tlRe2nH9lDm+u1zqe9WjWgKSu8vV5yPtH/v7eGp2tuq/6W5L+nHD7D+tO6+znXfml3MPPtbZH2a9Dt6hw3Rn1cpuhrHQwVuD579e+med6/eu8wyuKAA4z3tr3TmWrzGDpbV8T4/zndCl0eo2Kfekq631i85YPrfquyDXnajvTd0OtgkQIECAAAECBAgQIDAJAvl3TokAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgsP4EDijlr/OD+Y0S/FsDv+qMr3+7/u7EZLf4RpnFMS2swQULUn40s+eCjAF3TpqdBfgnc8UHDnRZqvrc/6uvKeUXjxsi+LdTZ6Lp/i3b05393nX6enhvXtt+2jETXFiPZ7sGq9RZ8oZOCU5sDOaYq+iWQ1e484TWAJpaJG1+SZ6jV85u7jxpkK1E/V6Y80/Icu4S5RfMAttdNu+lJ+S9dMPuvLqdOq9IfuJchk/bZwPO/6XtzNywDIHmlOje3XP8r5qPlpckwGfFAezxflHqP7vlGmuSvSWzHcf7kIaL/03ae05D/jBZ3+4qfGHXdt/NtOcH/QpkjPwoN+PhaV938O/8KcmvY2A+iDXP9aXzB3s2Uvbi1Pd3Pdnzuzn3SR9YHBw9f7zfRuo9IX2pQcCdVN+H/7ez02+9Xt7H/fqw1LH4TPo7dKkujOX4ZhgL3ZB5Zsb2/NfrJoi93/eTFQUAX9U/gLjfdbtJ6l9nmLj39IIGjnhnPdyT3i6PY9xO2vemXgP7BAgQIECAAAECBAgQmASB/FueRIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBYXwJnJmggLf6N9dXq9tYmYKgG/w4UQNVeiyNNAonESmxBY6qzLS83fTX37Ic5+dvLraDhvFMTxfnxhvyBstKed/YpeGCfYwsO5cdE30/GW1PfuQn8eGvG5eULCgy4U2dKrXU0FU9+Yr+Wl3LuRW1n5tiXzirlhW3HB8lPf2uA8a8tUfaY7YtnSu6c0nhuLD81V3en3FDr9O30Picc1Xbs0FKemWN3bDh+9tdK+X8N+cvKSvvyn8lI06XcMo15QW9rkndxImZf0ps/7H7uZecPAJQE7Q8cAJzr1LHVL/32saV8q1+BHKuB9SfUJVMP12e1Xzo5B9PtxrTfvqU8vvHIEpl5Rzyjp8jJGdsX9+Q17q6j93Fj+wfJnPR36CB9GEeZzTAWehzH+vxf0eePO+SlsKIA4LwDU31zyrGBAoCnJ/c93dyxEeRO+j1p6eI4xu1EfW9qcZBNgAABAgQIECBAgACBNRXYbU2v7uIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgSEFEvz7wAQY/NmQp01s8QRiCP5dm7vz4B0JjtxayuuGvXyC3R487DkDlP/0AGVaiyQQ8XN9fgh0k9YTew6kbzWw+Wk92cvazXP6zZx4i96Tk79fb96g+zm3X8DlydtnZ8sdtLrGcjH4UIKTPphrPbKxQCm/8KBSbp9jX+k+ngjdw7J/ZHdeZzsz/32hs73M9ffazks779p2LMGIbffy5JMym3Xbees8v87CvFdvH5I3fdwyZtjurSf38oK4zqTU2W88Ljg17/pLUr4x5diP/qeU9zUe7Mqcmg0ifndXVutmyn5jx+zs4On24pRrnpjcty0+0p4zPTvuH9BV4tLU81dd+8vdnLT38XL7UeI+0e/QZXdsfCdumLHQTZbnZKzP/x79PwtXFACcl95VbX9ZJX0eKAA45SbyPd19z0a9vQ7uyaIur/a4ncTvTYsQZBAgQIAAAQIECBAgQGACBDr/FjkBTdEEAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEB/gVNL2ScBVH+fpU+sY/86Juloflgv+HeVb0iMWwMnc+nXTJfysiz7r3IzBqn+24MUaiuT2RS/1XYs+YuCIfuUHdmh2J/dUtneMV/WM5w6+wUXfa3lesvJ/sclTrpp7/Hcg1/tzeva/1LX9tCbidTtN9vr3u8qZe/eSs8o5TbJu0dvft1PwPhXm/I3SN5jWvrxrZb8obIvKeU5V5fygLpkRuGB72s+t1K8OeXYO1cjIDvByq9tvmIpueZRCb46uO14S/4zuvNT/5umEhDdnddvO8/venkf9+vG2I7Fa+Tv0LE1fokLbbaxMO7nP++nELemgWbsbjv7hD5/PCIX7fcZ3V3lRL6nuxs46u11cE8WdXm1x+2kfW9aBCCDAAECBAgQIECAAAECEyKwrH9In5C2awYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCwyQQye9af5Mfot9kI3U6QhODfMdzIBDp+q89fyN894+kP04zn7sisr1l/IPfltKlSzsn2WFOu+9OVXDBt/vGO2Rn/mrq750rqHubc6QQbx/zOCeq4a2zv0nbuRbMBq0PPQpg6U31zyoHzmo8Mn5v2vT/TFF+e6zUGTwd50azKKdsYbDt39R8P34qdZ2TGxQv6zLhYblzKjVL63J1nlJI2PrZ7v3s74+3b3fsbZTsBraEoD2rpzzkt+UNlP2o2kPcTQ52UwjG/KmOkLa10hujGereV8uEdpXw9Bw9tKLDLXPDVnzQcW5T1+lJ2T+ZTOwfSn6uzvLKzP8g6z+i6eB8P0pfVKjO9yu/Q1Wr3sPVutrEw7uc/75rW3wbn2JXD3q+e8ulOSfx//ZhZlJYMAJ7k9/Si3owwY5LvSVs3V3vcxmSivje1OcgnQIAAAQIECBAgQIDAWgu0/o/8tW6Y6xMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEugXOKOV2+aH473fnrdft/KBe8O/czatBZYeV8gfZvSIul+YeX1rX2b+8Bh5kuTrbVyfK5NpsJ16t7JbtPbK9R9Z7Zl2DW2uQ5sw6+1dtK+VV2Z9JDynlO9OlfDL13q+T17CugW2J6yuPSrmyI0FqiWz5ZDY/mfo++Y1SPn9SnxnvUm7FKdfNxKIrStelrRelnhs21FL7N/JUZ+TODblHfoB0r1Rel7ulDYdnv96nvikNqvds6ADgnFPHQ2NK369oPLCMzOPTth2l1CDPqabTM/Zu0JB/q4a8mayUv0vG4Y/iU4Oj6ti+vK7T4Cvzhw2uDdg1OTCzTrDvtYku3jNjcJ+ct2/KXT/bNcC3NeV44pUXBgBn/5i2E3Ktc9qOref8jIEjszSOv5h/ay37lnYl5rE5rWLb6nvhDbn2K5qunPynbS/lhVkyhPqnQ0p5ZMrftKvUO48eMpB8vbyPu/q4qptr9A5d1T4NWvlmGwvjfv7zOdz6uZ93QiaVX1lKHdemT/mIWpiSXz/j+qacN7Hv6b4NX+HBSb4nbV0bw7idtO9NbRTyCRAgQIAAAQIECBAgsKYC+d+UEgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBg8gUSZfBHaWVrQMMye3BRghW+kh+415lDRxI8mPoOSH1HtbUnxwX/duEk+PfYeL2kZmU9kzrrud3GVadMZ90pVPdPKeVvj0swbFdeDQh+V2d/gPVBGW8Hpdwv1bJp4+XTpXwmmx/LUmcK/uhUn0DUHF9Oag1sHbSy9L0GTi8KAM6Yaw08HLTuWu70BP/lx0bbsvmg1PnArO+Uay4Itsz+QCknNc6sO8DJrX0J4EpnNVxw+UREfm9RdNPOEhfv3JzfuuX81uKN/x2buixIW7r2OtsHzOV1w3Zvd50yv5n7siigK9e6+XyBhRvnz81iuzB3A+zlfrX1uUa4fmctu5jrX9M2njKoz1uttqXuv8v4eUnGQ/0jCb3pVg+eDRT/cO+B3v20/Rk9eX/Zsz/QbtqxHt7HA/Vl2EIT8g4dttmrVn4zjYU1eP77/TZ40efFsDc59y5fAxanvCeWDABOmYl9Ty/u0UhzJvaetPVyDON2or43tTnIJ0CAAAECBAgQIECAwFoL9PsflGvdNtcnQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECMwIJPjylgk2+JURceT37OXtiVx44/mZ4fOEEQVHdtqWtm7NdlaLU64p+LeHJSZPzr0dZfrUcV3Bv7XiraW8+8xS/ipBJ89ezoXSvhqs+qC55flp889yg995ZSl/dmwp311Onb3nJEgv/1lxurqphrQ/TV1eOq2UWyd48Omp43FZ7pJastoZrN1ba2zqTMZ19uSPpuADss5Ej4tTfrSUiW+XlRr7WGtKhSsOaupp0Q979ud3c7N+PL+TjTjVGYHrbL1rkvJSawq66p6tdb5duUffmd/ZYBvp201nBmhDv/L8L/s5aKhu6KxcP81rTnnGftJ8ZOW5x2SsTpfyntT0lKba0q4Tk//hpmOdvBy8ebYf1tlPR06fKuULnf1h1lvXwft4mP4sVXYC36FLNXlsx7duorEw7uc/1+v3B3NaP0eHuPmN77N8Fi35x3Ry4sS+p4fo/9BFJ/metHVmNcfthH5vaqOQT4AAAQIECBAgQIAAgTUVEAC8pvwuToAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAwo8LSU6xfMMGA15SMJTnjWtlK+POgJoyqXgAfBvz2Yp5ayT4L1Ht2TvaLd3N93NlXwkVKec2Rm8s31fj9L4u2Wn3J+nWX3pEyn+cTpBNVNzc4KvPwKV/nMjL2rhr1EDczIA/eCnPu76W/TzKGdKq9NmU9l+bcsH0qwyOfiMRNctKOUP0mhxgDg1Lms3y3lGtfm3HGln7VdKP1cELCZztyqrewQ+Rm+5Zr0sQaDX5N+zqyzXwOq6ozDM0vy68zlX8/6yynw5bTlK0cnKD3Hu1Nlukl3Rmc7B5YM0OqUHXSdOkfxfh70cq3l0o7OBMpNZepzu2Yp92zXelOaUqYrr4Hzq5n+JpU/peUCj5kuZf+pUi5oOV4f1vpHAObfmxmor2grO0j+ZngfT+o7dJD7M84ym2EsVM9xP//5EN697aWctgz9nWCIMbFkcPEkv6eH6OfQRSf5nrR1ZjXH7QR+b2pjkE+AAAECBAgQIECAAIE1F1jWP6Sveas1gAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIENhsAk9daYcTsPS6BB38zra54MSV1jfM+fkB/boI/o1P/jO+lOCU43PBfUZ4xetS37ua6tuewNHk/8F0Ke/I+uVZamDqSvt7o1Tw3tNLudcxCcJMfWud6kzFTWmoYJ8Ert05PyrKqnWWvgzp8tH811sTSfreTAu6IBi204Ac7xesO/G/W8q9bQygTf+uTcDm1zr9rOsMrgPmoyO7D8xt5/i98u75bMOhVcn64GyQelv818gDYXOv91vpwzQKiLShNQA4bbzRKK6x3DrStl3bzs1zdGnbsVHkT+V5nS7lS2nDnXrrS96eGZ8nJv8veo/V/bxQr5cyv9517L8ScN53xuCuso2b2zf4+9g7tPG2N2Zu9LHQ6XSeobE+/7le2/u/NmnJIN1Ou9vWeZ82/kGDXLf+4Yq+KWUm9j3dt+ErPDjJ96Sta2nzqo3bSfve1GYgnwABAgQIECBAgAABApMg0Po/ziahcdpAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEDizlCPyA/TDVyjxhm2Z+XdqBEEPw7YjQRLrIvi39itt7RfDWGeBzK0YXUplTxxdbTPt/1ju8ff61ZnjX9hayrHp660TfHBSyv5zlp/3O2eJY3sH7S1LlBnL4fRpS9OF4jxwAHCet7vmPp+Zc27aUFed7fftWQ7bWsqRsfzbtuDfem7qCHFrymUmO6X9t2tp4ZePXzxmLm8p28lu8uwcG/k6keCtvwvL/Rt1IOwusdpv5J1YXoWtYz1tPGh5VY7mrLg3vl+Tf80JAwTNjaAVr2+rI4PlN7e3jJkbZ5b22N22c24e6ld2tle6ntqA7+MJf4fmVjamtvzGwquRuRHHQrfTuJ//PNOtAcC52f0+m7ub3bqdOto+Y5YMAE6lE/uebu3wCA5M+D1p7OEqj9uJ+t7UCCCTAAECBAgQIECAAAECEyIw8f+QPiFOmkGAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiskUB+ML9thZf+RKbq/O0V1rGs0/PD+XUT/DvXwb6/JbmyPeBjWT45aUeM9p47+efZ/nmCSi7N+src96uyrktnuwbP7ZX9LSlTz9m7s07ezH7yWgPc5q4xv5qaDRR+QzLeMF1qbHO5W5b7pc7713WWg7MMlHLOvVLHvVLnZwY6YfUKdSx7r9AabNNd8EMJDE1fPpRl/+78uh3jGtTzmPQxk8sOlnLOup4BOL1sDABO5NQnewVi9uPevJ79A3v2V3U3UzL/LFMs5hYsDtpPWw88JbMbH1fK+aNoxPtKuX7qySO79ikd/kH615bqs/2atoOrnZ+2LXvGzFG0LVN+vi0RgS9PXU1/KOCgI0t5eI79a++1cmN/p5OXPvzwglL+sbM/qnXeK99LXWN9H1+SZ6MO3FGmSX+Hto3B5Pd5bEYptHRdG2Us9Pa0zT7wgwTM9lY3yH6/73ONf4xgkEprmenZ70xt7/wlZxeOxUS+p1fjndBjOrH3pKed87urOW4z9ifqe9N8p20QIECAAAECBAgQIEBgAgX6/Q/KCWyuJhEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKbUGDrCvp8XYL1np1pXgcKgFzBdRadmh/Nr7fg39qHvr8l2WPEQX4J9KnBeGsWkNe5aWlHDVipwbt1ObnmJ8DlwNzDhyZA4eFZHpqspWZNfULK1PPXJCXyefe0szGoJ/0YaPxn1tjfSuPbAlWfG6eBg3/nEPz5R7MAAEAASURBVPoFNvUda2uCuPCiu8Tt4JguSsn/QG9myvUNZMnxe+ecN/eet1r7dUbZ6VIuynVv0HSNPWeD3Bf1o6nsUnkZNzdcqsy4jqe/57ZdK8ce0HZsHPm5flvAXL/nZGRNe0gpF2ZM/EPa8YymStO4ZyV/QQDw6aXcJeW3dspn+68ztvK3IFYvTY3pfbxPy/uy9iz9bLtXfTs+6e/Q9Cv/WZyW29/FNY02Z2odj4VeiT7Gq/L853qtMwCnbSv6/L0sf0Sg6a8I1D7nukv2J2Um8j29Gu+E7nEwyfeku53d22lz27twyfvcXU/TduqeqO9NTW2UR4AAAQIECBAgQIAAgUkRaPsfZ5PSPu0gQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECNxpuQQJ1HvvtlI+u9zzl3NernldlvUY/Fu72xhA2nFIlOym+a3JVGa6zNh5a9a/9LUExSaQ/Pm5r5kgrjklkOGg5iM7c1NHijWnHGg91nzGwtyDm2f1nCmUipcM2MuMsHumfzUAuCm9d2oZgdqpL11uTjnWd6w1nzW+3NNKuVXcEs+3MKXdF3wjsyQvzJ2ZSvenOVYDyRtT6jqy8cAqZuaamQi4OeXYg5uPDJ+bKLO7DH/W6pyRe/D9PjXfarqU2/c5vtqHGoPu0ubcjvGkRGzlbwW0pocl4Devkp0pDf7dnXvlyiv6n99VdLSbU6vwPk4LG+9HbXnuydCfdevkHdo21tryR3sjR1DbehgLLd1sHG+r9fznWe8XALx3SxsHys6Hd+Mflqgn50N/ycDQ9HlS39ON96j2aznvhHped5rke9Ldzp7tRpNRjNvzS5m47009fbdLgAABAgQIECBAgACBiREY+h+qJqblGkKAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhseIE6q2l+ZL4gIGmYTufcNw9TfhRlLyjlowlQ+b+jqGsN6mj8oX+nHYkmWZe/NZnObKdnlLIty206fRlmXWeQ3lbKX2Qa3btnTF3cdG7yb96U352XCKtWvxzLf5afcuP6BfQsOQNwTn5CGnDTphYkoOfUpvyl8lJfTm1O8ZroAOCM9ac1tTzt/oemGcXrjLsp3++PDdwhUcM3a6pztfLS1i+31Z178yvvKiWTeq88pa6pldcymhpyE/oFltUgrjrL7VqlTLzcmPoF6jWesNzMY0r5dM79fMv5u+YF9ZudY9Ol7B+vJ3f28zC/89hSzuvsL3edeififZz2t37eZUwPfU/Wwzs097PxM6gtf7n3eNDzNupYaOn/WJ//JcZwJrtdfsqH94F9zm79Qxidcyb4PT3Sd0Knv531JN+TThsb1qs2bifxe1ND/2URIECAAAECBAgQIEBgIgQa/0FnIlqmEQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMCmFzislFvkB/OtP8jvB5SAlqszXeuOfmVW49jcD9pXo+pVr3OJ4IQaOTR0UNSqN3qJCyTA6Ibp18cTsHJG2v+aJYr3PfzQUr6eul7QVCj5rcGunfIpk/80p5y8ot/xZIrf1gDgPAtLBgCnYfdobtlMbr/A1tbTct1Wk9yPiQ0Azpi5ftrePfNpp4+XJf/lnZ2G9Y6GvE7WLnuU8szOzpjWH227Tu73TfdP0Hfb8WHyU9dUW/l45fD4UgbV53PNTFTbnPKQPf19pezbfHTVcxuf0QDVZ2FsTvHJ39ZoTmnEidNzM1+n3G9kf34W7Gy/tvmswXNT98S8j9Pqft8tGu9Vv57GZ+LfoWlj42d4W36//q702EYeCy02jWMq9qv1/LcG4uaaN2pp40DZeY/eu61g6q5/DKNvmuD39EjfCQ0IE3tPGtrayVrtcbujc6GG9Vp8b2pohiwCBAgQIECAAAECBAisvcCK/o+DtW++FhAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIbWSC/lF92oFaCEM5+VCmXbmSfUfctZn29ExDWNhPYqJsysvoSCVh/H5OuzaQVtz+RLe+fq2vBKjaDzIzZGlySRq7odzyJ6tqyoEHD7xzUdkrwWmeSbTvnXQlqSoce1nY8kcGJh53Y9Jvp840bWvfqo0s5tyG/k7Wjs9G0Tp3PiktjME1T+ZXmxfjf+9WR+/OnCcK7fr8ySx3L+fdKmbu1lUufVzSu2+pty58q5Wc59sG248nf9wal/GGf46t5aD6Ytvcip4zxebiolHfkfXVxbxvq/ty4f1Lu6251vHbKpPwnY/uZzv5y1+vlfZy+9/0sbOn/QS351XUi3qG5j43v3bb8tv6MIn+Dj4UmonE///Vd2JZu1nZgqfy8G66f8dz4h1Dmzl0yAHhqct/Trd/R0uflvBN6OSf2nvQ2tGt/tcftjq5rLdqM+1i/Ny1qgAwCBAgQIECAAAECBAhMiMBY/4F1QvqsGQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMA6EcgPG1byg/sL1kk3J6aZ+aH9fks0pjUQYInz1uxwojnmZzxM/1YcAPzj9kDffkGHM/1PQOZ8W3pBVhqAlb61BpbmWOt1O+3I9Q/qbPeuE4h/QG/eUvs54bUp8/A+5VZ8L/rUvexDCW6qY/y5DRWc9rVStjfkz2edX8qZcfzefEbPRu7DjW+SoNue7FXb/UYpn057+gUsH5w2vXK5DahB3jn/9Tm/9TdouX7rseVed4Dz3t6vTNr0/OlS7tevzGoci1XrM5rrje15OL6Un6ct72jrY47VwN/HZ32LrjInd20ve3OS3sfpRJrTmvZvPdJyIOPqoJZDZVLeobmnjQHAbflt/RlF/kYeC00+MR7r85/x2C/Y9Pb1/d3UzgHyXpK+dL8bFpySY/nPQGkS39MjfSf0KqyDe9Lb5HozV3XcTtr3pkUAMggQIECAAAECBAgQIDAhAmvxD6wT0nXNIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBCZdID9saAxWGaTd+aH9VYOUU2anQMw2XABwpqLb0unhAP3rFG1dJ4Dznr0HU+8Vl5Xyz735DfutAdQZ6ysKAEw/W4M00r4ln6MEebTe+7Ttrg19ac2anp1htQYRtqaV9rep4vTzpdtXHnD6vFgc2F1/6v1MlsedtMQ75YRSrsx5f9l9bu926v79M0t5RG/+auzPtXepwM3fyP1qCnheskl5Fl6UQvdYouCSwedLnD/04QQUZULd8pO2E3MPauDyWxOx/wttZVYpv/X5TyRe04zTq9SMUvLHCN7Qp/L7xOdtneMZ+z+K6bs7+ytZT9L7OP1qDYDMsSOGDZCM2cS/Q9Ovts+Z+pymC+NLG3kstCiO9fm/vJSftrSjZu+d9/cT+xxvPLSjlD/KIPndxoM7M/sF0c6XmsT39KjfCfOdnduY9HvS2965/VUdt5P2vanFQDYBAgQIECBAgAABAgTWXCD/li4RIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKCXBDzfo55DAj3EHzPVrzkDH8uOYG3YVvGW2VxrkdHRXfTObqfCU40q5qDe/dz9t2ac3r2u/Nciiq0zrZtrQGgCcY62BaZ0Kc++/3tnuXSdKbvsgwXCJutwzwa1vyPVe1ltH736ut6U3b6X78f3Vo0r5++n+M3u2Xibn/WLa/uKeAl9PcPdxU6Vc3JPfuJtCb8yBxDa1pl3SznecUcpDW0sMeCDWJ+wo5U/63ZtLMkNvrLNqT+nzX6bv27cPGDxdr5fyf5Pz/ri91tkjKdM6Lpc6d7nHa0BR+vyKJc4/NA/jdPqx/xLlRnY4bWp9vyZCf6wBwNtK+Wza89k+nesO3H7jXJBWn+KDHcrYn5j3cf5CyKVtrc64vUUGxm+1HW/Kj+fEv0PTr7bPgl3y/t63qV+rlbeRx0KT2bif/8+UcmHa0e97yfb3DXHPp0v589T30qa+deelnwN9tk/ie3rU74Rul7o96fekt711fxzjdtK+NzU5yCNAgAABAgQIECBAgMBaC+TfUSQCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECM5GxB/RzSCDAjfodn8RjCXiaD/DL9k0TePmY5bbz9FLunXP/qOf8K69eOthw5pTMutkvgLo7MK7nEkvv5kdArUE3uW997+tc7V/sc5V7pIIX53gIm1OCUe+aBvx72vHrcyWuzXV/1Fx6JtK0NRiy7ZxB8tPAX0y506ZLOWSQ8p0yKX9Szn1L9rv7+IHc2wcf1z+gt1PFzPpRCSrMzJbPyE6635r2i9O/7ijl2dsHDLrtrinj8C5p73TqeGfyX3yTUvKf5vTIzAKZhryg+ejO3HT6hUeV8vHTSrn7ztzFW7n2VMbCdMpnguGZdGXG9TNyjZ8tLj2Ts6Jx3VLnktlnlfIXKRSm9pQ+3DXLR1LoXu2lmo/knOvXIO54HNZcojF3wczSPSXm31M9+au2m3vWbxbgmeumzNW5v38zqkbEe76f2V7T93Ge0x/361fa9+Lc50X3LO+6++4o5Yzc/zzuC9LEv0NzP9sCgOt0yKvyTl4g1LWzwcdCV0/nNxeNpfkjXc9FV96KNrfPTPRd8opqTvE/PDf89A8t8b0uz8D9snw05Z/fVdNPurZ7Nwd+5581Ye/pVXgnLLDZvg7uyYIGz+6s+ridtO9NDQayCBAgQIAAAQIECBAgsOYCu615CzSAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBgUgT6BsIl4PB2k9LQQduRH8fMB5zVc9KHd+9IEO95pbzmhMwUOmg9Cfa6Rc59b4Jg9uw+JwFVJx5Tyie689q2c/7hbcdS783ajg2Sn/NbZ1rNsb0SwHPLqVK+11ZX+vHFlOuXXpA6HpgC/yvLF85KoGt2bhnfe2T/t3JuGObT+anvyVkOTv7r53O7NnJskKDkrjMG38w1t6b+LyZQ72W5wW98WCk/aDu7BvOl/Et62n9ezv+dqdkA27ZTW/OPLuUD05kpMXX+cVuhHAtdee1RCaTN2PqTRCL+a7/xeErGXaaIfkTGUJ2VdFun3rTzY2nnDzv7TesUfm3a85BcM/HA7SnH75tpXz+Xsp9Nqfdk+WqCP3+S/AOzHJr9R2Z9v04NufaPsjw+9X9sR0uQaI7fPANg95NKuapz3jjW2xNoFdenxus/0+Z+s+veIcf/I+Pg9Vm/aqqUb/RrX2welD6dmDInJGByn2xfmHtz6FJB4jnv+qm/NVA79d2233VX49jPS/mHRIO+Mu26flv9OfbPGc/nth0fNj+DfmLex7lnF+0oJRN8N7870/caEPvZjI1X5j5/KWOpvqOnkv/UrHfN/n1OzbNx7NwM2ykz0e/QuTHYGuSbWahvkX59N8tY0kYeC72Aa/j8J763PK63PV3798nnyjcyxk++upS3fauUc/JXSq7NQ3pIyhyRMf6krPPRtCBddE0pv5T3X4Z/YzqoMbchc/uEvadH/U5o6HLNmuh70t3mcY7bfM5M1PembgfbBAgQIECAAAECBAgQmASB/HuURIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCYTIH8+HxrftyQ1fDpulLOmsr5w5+5Oc8I8i/G+h+W6P3ZCfx4Yn6o/7klyk3M4R2l/F4a86reBmV81KC2v0yA6DsSwJV44OYUl73iUuv4oyz7dpdKHdszxl7UndeyvUum4TsmATPvT12Jt1mcUtc5sT3+mFL+a/HRpXMSwHNignXe1KfkX++YnXH22qYyH8zsxPvMBrDVILAlU9p7TfqSLi1Myf9YLvCkjJFzp0v5tZR548IS83ufu7SUByTg5or5nAE20s//nX4OYt6prfb3o2nXx7M+N+25JBk3yfpWWR6RvIM6Bes65d50SSn/X505tzt/2O3tCRA8spS3p62/NMi5ue7Fac+ZWX8u6xqAfNOcd0G2b5b1/bN//2wvGjvpyzO2lfLmpa4xPRt4+e+p4/ZLlR3keNrz5QSMHfeQUr7z+gT4Ht4nmD5la8DT700loHiQukdZJv1+WOp7T/qd4b10Slv/M6VOT/lzs10DhxMnW26b5aDk3SHrW2fpTl/8Win3PGmJAOe04/k5/8+7T+zezrU+eVFmFD5+9nrdh1Z1+8zMApwx+uttF8n42prxdVbb8WHzd0zG+3i+2WnP+7Lz6PmMITZyz/5laja4MpulTPo7NGPwtzMG/6qti+nEm84v5VmJ9hz4D2O01TVI/o4NPBZ6+x/7NXn+T0sQ++6z3yl631u9TRx0/yd5JxyX5acJ4M6rrzH9/KpSjspnw+cbjzZkxmci3tO1aTtG+E5o6GpZL/ektn3c43b7hH1varp/8ggQIECAAAECBAgQILBWAvk3HYkAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgMJkC+fG5AOAR35ozE7CUH4w8dK7a62W7BrnV2d7uPMilrislcX/lqznv+9n+fravqOclePUtCV79RN2epJT+/nUC3J7Zp03XpR+fyvLhlDknyw+zvWciWw/J+rD089jk3SpLd8qh8uqtpTy3O7OznRlBb7IlwVYJkjko16711FlGb9g5vsS6mv5nzqnrH6aOMxNMm270T9NLBHfNnV0Dnb+Uur+T9blZ3jOV2XznjtWLHJv21mDNZaXU+8qc+Ieps46RsmM2sPANdbsppfwPk18DLmv58y/O7LaPyszCTWU7eWnjsAHAnVP7rtOWC1LgV9P2xPGNLk2X8sLc+xemxqxGm9Lm/0iNx6TNoVs6pS37pxEZnuXeS5fuW2I6AV6PTYDXhbXUqZnNec/MBtz3jBxMe2uZGhR2Tpb3pd3LHms5f+CUgKs7JFjt3en7EQOfNFjBa/Peu3+ez091iieadN/MqltnxL5J+ntA1jfP+o5ZH9gp07ZOuctT7sNZ/0+W87OdWPSZ9M6p2fHZduqy80/PWIjNfPu7K0obvpTrDvS50H1ev+08v2N/Hy/RnsfnnVdnux42fT4ffA/Oh0PnHs2cPynv0DNKOTKfYRmaMzMu3yzre2Xp/RybaXP3f+WeX5FxVz9/zk5+/YMJ/7E1z053mVFtb8SxMInP//Ts9+hwr+wzKGPi3LzvHprveV9JZffNc/PJtrGQsvUz/V+yfCNjqH5XrO/Kf8+5rX/gZJzv6bZ21/z0baTvhKZrTdo9mbRxG5+J+d7UdP/kESBAgAABAgQIECBAYC0E8u93EgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwGYRSNDGfdPXk5bb3wRz1N+b3Kku2Z5PCTaqwSCfmM+YkI208eAlmrJLyty3Lr3luvvXOZZAlu8lkOXEBLIkXqU57TkbaFUDVWdSUz3NZ87k3jz/ffPOOXH9hezX4J2+KeX37ltg9uABWW3r1H3t7MzH8wHA2xLLmQu9Iu3+/waoa75ITC7MztOnZgN+uvN37VxrPrNrI8dqUOR8YGSCpuvslGsxu/Q7LivlOccl6LKreSPZjMmLYvr59PWVWQ4ZRaXxrs/ai1L3UAG0KX9BAmu25fwahPnLqSNNGjq947wESp/QNUtoxuj+g9SSi9VZjR9Wy6YNNUBsqPbX85aTEqj83x8o5T7XT7/Thqctp46Gcz6dPrwyEZYLgmdzjRvlGi+r5Tu4nXVDHQuyUm6vZDy6lu8+J9f5WLIuWFB4RDt5j316OgGfud5dG6r8vw15K8rKdQ5eooKRv4/7XS/vvH/aMTuD9on9yvUc+34+Ax51bE/wby2T+ibiHZpnMpNJl9/vafeSu7k/+fgq98n6PnOF6+fcqgQAb8SxMInP/1T+FseOUp6U98ibY54mDp9y7ul5YT8j79Lv1LNTT/1e0ppyvH5PfEKnQPbLrqX8blatAcDjfE932tW0zjM80ndC0zWmJuyeTNq4jc/EfG9qun/yCBAgQIAAAQIECBAgsBYC+d/VEgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwCYS+Nlq9DXBpDUIdOJSAlf+OG37u6zrzLeJ21peyrl1VsRfz1Srh/cL/q2153opOt6Ua87MxLzSqyb45Q+CdFTqqTO1LpnS0Y/m2vdMwEad7W9ByrGfL8hY5Z1c7+VZPjvEZT6X8g/fWspTViP4t9OOmL4/23fI8hu53jc7+cOsc973Uv5VWd871vfPsqzg2Zx3cdrzK7lnD059C4JXl2pPrv3nWxM43B38W89JfuINF4z5ZM1k1NlRr6rba53qzNLp+9PT7ztleUXaU2fYHiqlU/Ud99c5/25bEyCZ+t45VAWTW/iNDU27KHlvb8hfUVYMx/4+XqrB5+W5TJkXZLlyqbI5fmnu/6MT+H1uW9lJeIemjaP6PJ55ltv6upL8zTAWVuIzynO3zgZx3zvmO4apN+W/mbH0+LzrHtIJ/h3m/GHLTsp7etTvhCaHrevknjS1fRx5k/S9aRz9dQ0CBAgQIECAAAECBAgsJbDLUgUcJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAislcB0KVvz44ashk8JXDgrQQtbhz9zY58RzN1ic98EeV6anl4e3yvqkrzLE8V3xfmzQbI5XK75SmL4jsrEbZkd9Xo5tlsyr5dpZvfIsTpT5V6ZEW7vnLtXll0SEDVUMGHOH3vKLKBbtiR4L+29V5a7ZDkgjbhx+n7jus7+lmzXoNWfZvunCXz5atYfT78/nqDfcAyWpjPLXs65e8wuS32XpZ66XJ7osst2T5BZjl2dQOKrq+/NYpqp9HbLtIu77ZfZF2O6JeftnTJbdp1dn//QUr6+1JW35z49uJT7pb2X1CXRwHW5OMsVqXvP3LC9c+O21HuW+rekzN5p07dy3xoD2Wp9R2YGv5S7R659yNxy26xTRflu8r+T8980F6SRrOZ0egJWc72fJwr0ooyjn9f23CQx0rHYM+2p/dwvx/fLet+sPz+VNjfXNJt7Zil1ZuUXNZWJ9c1y/g9PS7DtbqU8LvuHp+ztsj447a339uyc99W55WMpm+aNP+Wih6V9x6Y9IS43S9tCUm6S/QyPmcC9nyXvx9mvY+4zWX8mzv+V7WyONk3n3qbSx8XpqKxvntpvlqXOEnlBlh8k77/TljNz387I1L0/SF5jivmd06fc5nLBWaX8ZPtMHPx80V1OnR1zN0hdN0i5G9RyU6V8Y77EmDfeledu/1KOSXselD7eIus66/bNq0HWu2f93TTpnLnlW1l/MwPzwzVALdut6ZSM6zxv943nlXk+rkxdM+/XjPcrMr6vzFLfsfUZuKq+VwO2xz5ZUnbP3Pw98hzskTJ1f4/U0Vl/bmqJ56K1QQMc+GBm80wbvp+21vd6J7126+yMnZ39ka/H9T4etOEfzr3PO6nOlHpczrlllgOzhKX8IP91dvLPzP35wDGl/E/ylkzb1/Ad+vqM4UMTpJ4218+gy9PYmc/6uj03Bq/5ad7l+ey5Ng/7bhl79XN8rxzb++osKb9Xxt/eKX9x+lvfPauaNspYWA/P/5mzn4sn5t7eJTf1VllukaXOvP3jrOt7/0c59rGMg1MeUsoXs9+YpvM9Ks9DfaddlPXPf5IlY+q6fIjsnhfJ7snbkndhXi3l+qlvnyznHN3yfaPxAslcrfd02/V680f9Tuitv7O/1vdkPYzb0yfoe1PnvlkTIECAAAECBAgQIEBgnAL1H6gkAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMBECiTAQADwRN4ZjSKwNgIJlFkyAHhtWuaqBNavwI4E+6X1D5/rwXUJQL7DtlK+tn57pOUECBAgQIAAAQIECBAgQIAAAQIENoZA/lCbRIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECGxCgTqJyOFd/T5N8G+Xhk0CBAgQIECAAAECBAgQIECAAAECayggAHgN8V2aAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAislcDppRyTax/cuf51pby6s21NgAABAgQIECBAgAABAgQIECBAgMDaCggAXlt/VydAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYECBTFXa+nunK0qpM5lKBAgMIXC9Uk7qKv6VqVJO7dq3SYAAAQIECBAgQIAAAQIECBAgQIDAGgq0/oP4GrbJpQkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILBIIBG+rUG++SFU67FFFckgQKBMl3JgHppHdyiuLeU12c4kwBIBAgQIECBAgAABAgQIECBAgAABApMgIAB4Eu6CNhAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgsKRAIhNbf++UmUwFAC8pqACBBQK/mb3da06erQsuKOVtC47aIUCAAAECBAgQIECAAAECBAgQIEBgTQVa/0F8TVvl4gQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEOgRSIRv6++dru5zrKcauwQ2vcAppeyZ5+mZXRCvP6GUy7r2bRIgQIAAAQIECBAgQIAAAQIECBAgsMYCrf8gvsbtcnkCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgsEOg3A/AepWQSYIkAgUEEtpTy5JQ7YK7slVmfPMh5yhAgQIAAAQIECBAgQIAAAQIECBAgMD4BAcDjs3YlAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgRWIJAZSxPn25yuFQDcDCOXQI/A9syWnWD653ays/2OqVJ+2Nm3JkCAAAECBAgQIECAAAECBAgQIEBgMgQEAE/GfdAKAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSWEEig4p5tRfJDqN3bjsknQGCnwNZSnpRg+iM6OVeX8qrOtjUBAgQIECBAgAABAgQIECBAgAABApMjIAB4cu6FlhAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAg0EcgAcCtMwD3Cw7uU6VDBDaVwHQpu+VZeWFXp097SClf7Nq3SYAAAQIECBAgQIAAAQIECBAgQIDAhAgIAJ6QG6EZBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAj0F8ispVv6lNirzzGHCBCIQIJ//yDP0eEdjOz/RWfbmgABAgQIECBAgAABAgQIECBAgACByRLYbbKaozUECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoFbhh65FSrt/nmEMENrzAdCkfSif3uraUZxxdyjd7O3xmKcdlxpDu2X8/P1XK6b3l7BMgQIAAAQIECBAgQIAAAQIECBAgMBkCZgCejPugFQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQILCGQmUtv1FYkP4S6ddsx+QQ2ukCieO+Y5+PYLEddr5SPJ9j3vl193iXBwc/Jsfcnb49Ofmb/fXln25oAAQIECBAgQIAAAQIECBAgQIAAgckTMAPw5N0TLSJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoEdgeyl1soPDe7K7d5+Znb/rzrBNYLMIJOj3UV19PSAPyycT9PulBP1+J/n3znKTruMlwb9fOquUd3fn2SZAgAABAgQIECBAgAABAgQIECBAYLIEBABP1v3QGgIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEugROKWW/vUs5OFl/mqV1BuAcu3cCHrdfU8pbEwz5/alSLu+qxiaBjS7QHQA809cE/94pG3XpTZddXcqTt5dybe8B+wQIECBAgAABAgQIECBAgAABAgQITI6AAODJuRdaQoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBABHaU8tnMUHp4Ahjzn7JlUJQUfmF+EPXCWj7BwJdn/8rUc/zUTJWD1qIcgfUlkLG+f8b6/Qds9XV5Jp75kFK+OGB5xQgQIECAAAECBAgQIECAAAECBAgQWCOBXdfoui5LgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBNoG9E9C4Tw4OHPzbW1HO3yt5+2W5W+8x+wQ2mMDW9GfJ3wIm8PfCTPn72ATEv2WD9V93CBAgQIAAAQIECBAgQIAAAQIECGxIATMAb8jbqlMECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE1q9AAhX/LK1PnGK5LMsVWS6vS/KvTGDvNdm+JtvXZrsGPV4vy+7Z3j15e2bZI5l7Jm+vuf3/zrZEYCMLfCGd+0iWI5s6meegPjv/kOXPji7lm01l5BEgQIAAAQIECBAgQIAAAQIECBAgMHkC+XdviQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAwmQLTpWzNjxuyGj4l0OmsqZw//JnOIECAAAEC60/gzFKOSPD7A/L5d1g+O7dk/d0sZ19ZyukPK+Un669HWkyAAAECBAgQIECAAAECBAgQIEBgcwuYAXhz33+9J0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIENIPD/s3cncLNkZWHwa2AYhkX2TREZGZHNBcUooAIDTFAQtygqEiJLopEkKlHUJOC4RCMEjeYzCkbhc/0EFxAcAYG5SEBBAiI7CFwEFRgGBllnWOZ7ztz7TnW9b3fVU91V1fV2/+v3O/et5alT5/zr6aW6+9y6d1W9LrpRiokAAQIECBAgQIAAAQIECBAgQIAAgR0QiP/wz0SAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwFwEDACey5nQDgIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIhYACwNCBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAwIwEDgGd0MjSFAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAgAHAcoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAjAQMAJ7RydAUAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgYAywECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECMxIwAHhGJ0NTCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBgALAcIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIzEjAAOAZnQxNIUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIGAAsBwgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgMCMBA4BndDI0hQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgIABwHKAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwIwEDACe0cnQFAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIGAMsBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAjMSMAB4RidDUwgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgYACwHCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECMxIwADgGZ0MTSFAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBgALAcIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIDAjAQOAZ3QyNIUAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAAcBygAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMCMBAwAntHJ0BQCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBgDLAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIzEjAAeEYnQ1MIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIGAAsBwgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjMSMAA4BmdDE0hQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgYACwHCBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAwIwEDgGd0MjSFAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAgAHAcoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAjAQMAJ7RydAUAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgYAywECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECMxIwAHhGJ0NTCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBgALAcIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIzEjAAOAZnQxNIUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIGAAsBwgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgMCMBA4BndDI0hQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgIABwHKAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwIwEDACe0cnQFAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIGAMsBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAjMSMAB4RidDUwgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgYACwHCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECMxIwADgGZ0MTSFAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBgALAcIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIDAjAQOAZ3QyNIUAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAAcBygAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMCMBAwAntHJ0BQCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBgDLAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIzEjAAeEYnQ1MIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIGAAsBwgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjMSMAA4BmdDE0hQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgYACwHCBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAwIwEDgGd0MjSFAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAgAHAcoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAjAQMAJ7RydAUAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgYAywECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECMxIwAHhGJ0NTCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBgALAcIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIzEjAAOAZnQxNIUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIGAAsBwgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgMCMBA4BndDI0hQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgIABwHKAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwIwEDACe0cnQFAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIGAMsBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAjMSMAB4RidDUwgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgYACwHCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECMxI4MwZtUVTCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQINgQ9X1cuvVVV3aqxMLpxRVR9JhgojQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBDYnsAZ2zu0IxMgQIAAAQIECBAgQIAAAQIEZiVwdrTmZ6NcM8qlp8sHT//9UPy9/HS5LP5+KsrVT5cz428pZ0W5XpTrny5l/jpRPh3lZVGeFqXPNLf29Gn7nGPLefqeKJ8XpZzLj0Yp5/fDC38/FvOfWCjlM7RrRCn7llJypJzfGyyUkg9/HuUPohzHSb6Nc9bk23JX+bbcZdO18m25oHxb7rLpWvm2XFC+LXexlgABAgQIECBAgACB4QVcl602dW222mbdLfJtuZxcW+6y6Vr5tlxQvi132XTtHPNtjm3a1Nn+BAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQ2Fjg66OGK0Yql6zRurm1Z40uzHKXrx3pHJfc+cAse5xrlHzLOfWNkm/LxeTbcpdN18q35YLybbnLpmvl23JB+bbcxVoCBAgQIECAAAECBIYXcF222tS12WqbdbfIt+Vycm25y6Zr5dtyQfm23GXTtXPMtzm2aVNn+xMgQIAAAQIECBAgsIHA1TbY164ECBAgQIAAAQIECBAgQIAAgV0SKHeCHWsqd4rtO82tPX3bP9f4m47YsI+PWPfYVcu3cYTl23JX+bbcZdO18m25oHxb7rLpWvm2XFC+LXexlgABAgQIECBAgACB4QVcl602dW222mbdLfJtuZxcW+6y6Vr5tlxQvi132XTtHPNtjm3a1Nn+BAgQIECAAAECBAhsIHDmBvvalQABAgQIECBAgAABAgQIECCwSwL/NGJnyn/CdkaUcpfY7DS39mTbfTju6rHiC6LcMspnn/5b5j8zSpkujVLunFvukvzqKH8V5Z1Rxpo+MlbFUe+YdY/Y7Curlm/jCI+ZE2PWPY5GXat8qy2GnBszJ8ase0iDZXXJt2Uqm68bMyfGrHvznrfXsCv51t7L7q3lvd43R/mWKOdGeVWU/x7lRVG2Oc3tfek2LTY59g1j56+M8rlRbhTlxqdLWV+udz4YpbzHL6W8x//rKOU9/piPj6h+sEmebEj5zKr6jOtW1d3iIvizIiFuFn9vXv5GtTeJi+LLP11V74m/74nlUt4d295+76p6ZcyX/Jn99LSquvpNFq5xo3+3jIbfMvp01TVuLH8gli+Jvr76E5H/9xv3Gnf2Zhs2sDwmbxHl7zesZ+rdd/m5ZJf7NnWedB3vOOV/ef/3xVHK8/1iiafMKp4Or3xPUN4XHJS/jfmXRhlzIFNUP/g0t/wf89ppzLoHPzFLKhzzvWe8/Pf+rH9JEztXybdOolkE7EKuFUj5Not06myEfOskWitgzNe8deted78MwJh1Z44vhgABAgQIECBAgACBNQQMAF4DzS4ECBAgQIAAAQIECBAgQIDATgqM+cX5O0Ks74+Z59aevif9y2OH74zy7VHKD//6TP8YwU+P8pQoZcDAkNPbhqzsUF3H7UeLi82Xb/JtMR/Gnpdv8m3sHFusX77Jt8V8GHv+uOfbJj63ip2/NUoZ9HvXKDH27aqpDAj5uiiviPITUZ4VZcppru9LpzTY5Fjlh+D3j3LfKPeM8oVRyqCHPlO5FnpjlBdH+bUoL48yt0mebHBGLqqq28dJvn888EvWTRLRAABAAElEQVT56qjqrFLdwRPBwd+y7nDylG2xfxkIXJ4bnhnLLzivqj5eYuc0vaCqvjweDEuvcRf7V9p8sFz6es0oJ6rqymvc6ONTom9DX+PGEXZyukb06qFRfjTKuVFeFOXbopSB43Oedvm5ZJf7NrecOg75X94ffEWUB0Qp7xPuHKXv9InYobwnOBHleVH+PMpcp7nmv885V2fMcb42k2+rz+sctxznXCue8m2OWbW6TfJtfz7n9Bq/+nFgCwECBAgQIECAAIG9FDj47mkvO6/TBAgQIECAAAECBAgQIECAAIEFgXJ32ncuLGdn/y4Cy4/Zyw96yw9RL41SvoQvpdz9qtzd9nVR3h+lzzS39mTafp0IenSUfxnltpkdEjFloMhjosRvwgebbh813SZK3JiqunaUa50u14u/N43yOVG+6PTf+JOe/jIi75aOnlegfDt1PuTbNHkp3+TbNJl26ijyTb7Jt3EF7h7Vl/d/3xilDATpml4cAffoChpg+3F5XzpAV0erorxH/q4o/zHKuVGGnMpdoX85ylOjlME/25rkyYbyL6yq+8Ug15+Jar5kw6qu2j0GyZa7Ef3qJ6vqgvNPXVNftW3qmedW1XViAO+g17jRv1d8Kq5xY0T9kNe4U9OMebwgrx4e5Yej3PrQgcp1+msOrZvD4i4/l+xy3+aQO4fbcBzyv3yWVh6f3xvlRoc7sOHyK2P/8pryh1E+vWFdQ+x+XPLf55zLz/Zx+yxAvvlcfajvlZY/Ippr5Zt8k2/Nx0RZmuPr6RzbdFTOGgIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECEwoUH60Fr/FTZfXRuzhH6MO2dy5taerb2Ugx1uj9DHsE/v0qLvcPW7K6dviYOUHh9l2Pn/Kxg18LPnWPM/ybeAEO1SdfJNvh1Ji1EX5Jt9GTbBDlR+3fDvU/PTimRFZ3ieV//wk+z6pvKd6YZRvjjL2tIvvS8c2W6y//AfS3xel/OdG2fO7blwZCPzFUbYxyZMN1C+qqi87EXfqjXLFiOW9cZxHXnD0psHVFFPc8fceJ+IaN8oofYy+PT2OMfU17hR06x6j/KcD/yHKu6Ksek75vHUrH3G/XX4u2eW+jZgSa1V9HPL/6tGzfxPl3VFWPUaHWl/+o8VvibLNaRfzf58+5yy5c5yuzeRbVflcfbpnPPkm36bLtlP/AZzvDccX37fX+PFFHYEAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgdkKlB/bZX+o9uGIvcPIPZlbe1Z1t7Tz56N8OkqX38cipvyI7y1RLkvEH66v/MjwK6JMOT0uDna4HauW/3jKhg18LPl29DzLt4GTbKE6+SbfFtJh9Fn5Jt9GT7KFAxyXfFtocq/ZMjD0oVHeEWXV+6HD68t/mvPDUW4VZeyp+O/y+9Kx/Ur9N4nyJ1EOn8dVy+W66O1R/u/pUnLjo1FWxS9bf3nE/5coU03yZAPpi6rq7ChPORHXf1FSA2Mj/uMR+6b4+4YoH87udxAX+7wiRoTcsZpoelpVXSuO+fNx/M4+RtzHorwxylsi/rIoKZODuNjv3S+c/hq3mtl0TrTn8VEuiXJFR5nTgOldfi7Z5b5Fis1qOidacxzy/97RzvKerusxOvT2/xXHPCvKlNOu5/++fM5Zcqacy2xOlve0dyg7TTzJt/oc+Vx9/OSTb/Jt/CyrjyDfps+3fXqNrzPNHAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECeydQBjR8Okrmh0G/MoHO3NqzrMu3j5Vv6jD7u9j+6Cjlh7qlTwfT1WKmDAT5vih9/gfwMoj4QVGmmkqbPxQlkxe/N1WjRjiOfFt+juXbCMkWVco3+TZOZi2vVb7Jt+WZMc7a45Bv6/b8rrHjy6Jk3hP9Y8Q9McqXRJlq2of3pWNbfnUcoO3Omwfn/iUR9++jlDv3lvf0h6dyh8Dyn/b85yivj3KwX9ffX4jYsSd5soHwc6vqZieq6qVRMoNcL4yBrQ94QVXd+oJDeRKDeW8e27436nl5sq4rLqqq90VdX1qNPMVxbh9telNHu/4u2v/oaE/jGveC6GcY3Srq+L7Y/60ddVxlGPEfi/qmvMatZjCV18vzozwzyqeiXJEsN4q4OUy7/Fyyy32bQ+6UNhy3/P+30eZPRsk+ToeOe3kc+3OiTDHtQ/6X/NuHzzlLvsz92ky+NZ9XfK4+7rOcfJNv42ZYs3b5tp1826fX+GbGWSJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYO8EPho9zvxQbao7VM2tPYsJcatYKIN7V3mVgZOPjHJmlK6pDBz4F1EujrKqvsX1n4i48mPhqaY3xYEWj79q/qlTNWik48i35edZvo2TcPJNvo2TWctrlW/ybXlmjLN2zvm2To/LALffjPLpKKveAx2sf17E3C9KGQA65bRP70vHcr1PVHxZlINzuezvidh+9yh9pvI+/8FR3hZlWZ2H1/1cn8p7xsqTnmCL4eUOvCfiPEa5auDqkvlyx9zfjtgvqpJTDHz9ytjnzVHa6r1y20VVdekL+udgsiVV9dwYvBvt+LtVbYnjl7v9PjJK5zXuBTEYOPr2LyL24lX1La6PuE+E25TXuNWWpuvHcct/IPDGKFesUa4V+2x72uXnkl3u27bzphz/uOV/GUTys1HWeawOvc97ox23iTLmtE/5/6aAzJyjp44JPlHdc702k29Hc/C459tcc6081OSbfJvoKffKw8i37ebbPr3GT5nXjkWAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwMwEPhDtyfwA6lETtXtu7Tno9o1j5g0tVmUg790Ognv8PTdi2+pdPDeXRuwde9S9SehfxM6Lx141/8ubHGQG+8q31edZvg2foPJNvg2fVatrlG/ybXV2DL9lrvm2Tk//dez04Sir3vscrP/7iHnQOgcYYJ99e186ANmRKsqdmv8pysH5PPz3k7HtsVHKYN51pxvGjmWA+OG6ly3/q3UP0rKfPGnB6dp0UVXdNcqlJ+L8rSqx/RNRvrOrrmXbn1VV1456f2lV3Yvr4xgffkFV3XtZPZusi8G3N46637B4rMX52HZxxPS+xo22nttW76FjXBrHmOoadxOuvvuWAdP3j/L/RSn/UdgVG5QyIHGb0y4/l+xy37aZM8c1/68ZaOUxu8njdeh9Xx/tucFIJ3Pf8n9fPucs6TLHazP5tvy5xefq4zzByTf5Nk5mLa9Vvm0/3/bpNX55FlpLgAABAgQIECBAYIcFNvmidodZdI0AAQIECBAgQIAAAQIECBDYU4HLk/0uP5CfYppbe0qfrxPlwii3LwtLpnJXjvLD6PJFc9/prbFD2ffliR2vHzHPiHJ2InbTkA8lK/h4Mm6uYfJt9ZmRb6tt1t0i31bLybfVNutukW+r5eTbapt1t8wx3/r2pQyueHqUJ0cp7/1WTWVg6M9HKe8Ln7YqaMT1+/i+dGjOc6LCP43yGSsqLoN3HhrlJ6N8ekVMZvUHIuhro2Ty5IkRd5NMpckYeZKEWhYWA1JvHiMu/yBKeb1YNX00kuPrz4u7/64KaFv/wKr66L2q6lER8xNtcWVbtOM68QOHP3hOVX1mV2x2+3Ojzhihd2HU3XqNe981rnHj1trpa9xiHO14xkXTXONmeTaJu3PsXO7q/a4ofxLl26Jscv1+WexfnpO2Ne3yc8ku921b+XLc8/9XAq48Zuc03SEa8/Qo8VQ56LSP+b8vn3OWRJnbtZl8W/3w9bn6apt1t8i31XLybbXNulvk22q5KfNtn17jV4vbQoAAAQIECBAgQGBHBQwA3tETq1sECBAgQIAAAQIECBAgQIDAWgLlB6WZ6SOZoAFi5tae+E1y9ftRvrylb4+MbX/bsr1r06URUH5kmBlkfduI+89dFQ6wvdz5LjN9IhM04xj51n5y5Fu7T9+t8q1dTL61+/TdKt/axeRbu0/frXPLt77t/8rY4a+jfEvHji+J7XeJ8ugo2R8YdlTZa/O+vi/thZQI/uWIuXlL3H+Kbb/Tsr3Ppk9F8MOjvKZjpxvH9v/WEZPdLE+yUkviYiDqmVc/dQfIz1qy+WDV5XFiz4+Brn96sGLdv/eqqh+L0Z2/0LV/nNQbxCjSMjhtiOmMszqucaN/jzxvg2vc2PfS6NfcrnGHsFtWx+fGyh+K8jdRXhXlB6K0PcfE5vS0zevtSLud/Sxkl/uWTq6BAncp/8v1Qd/po7HD26K8NMofRvmNKM+K8pdR3hNliOm+UclPDFHR6Tr2Nf/35XPOcprndG0m39ofvNt8nW9vWW7rnHKttFi+tZ83+dbu03erfGsXmzLf9uk1vl3dVgIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEdlrgLdG7ckeZrvI1EynMrT3f0WHzpAFdHtJxrINzVH5cc/sBj7usqt9KtuWnl+18jNbJt+7HvnwbLqHlm3wbLpu6a5Jv8q07S4aLmFu+9enZj0ZwuavvwfusZX8vju0Pi1J+4LnN6Tvi4Mvad7DuSQM2bk7vSwfsVvWNHYaviO1jnOc7Rb1lMPDBuVr2twwium6UTSd5soHgRVX1hBNxntpKxPzMBodYtusZUeefth1zYVs5vxtNJ6rqO6K09fFJGx1gYefo10M6jnXQjssiduxr3IWWbTxbHtOPjfLKKFf0KJ+I2Hf1iC93Et/WVHKtrW+D5UkcZ+rXnF3u2xT5sqv5/9qOnD94PLw54h4f5e5R2m5AUd5PfHGUx0Qp/9HMwf7r/P1Y7H/LKENM+5r/+/I5Z8mROV2bybf2x77P1Yd4VqvrkG/yrbzGTvU9pnybT77t02t8/YxnjgABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBvRN4XfQ48+Oze04kM6f2nB19PtniU364e50oQ07ljiGZ8/HMIQ+6pK5fTbbjx5fse5xWyTf5NmW+yjf5Jt+W54DX06ryejrlo+PUseImn1Xm/c5fRdxNp2/ekSPu8/vSIxhrriiGb4/S9l77XmvWndnt9zuOXdpVfkS8ySRPNtB7ftzV90TkR0d5R9za8dobHGbprs+tqs+N436k49hXXFRVF1+4wXNS7H92lJOrjhPb3hVtGfQaN471h6uOd2j92Ne41YbTP4v9y+DvN0a5omd5Z8T/aJRbRCmP0/dHydTx3ojbxrTLzyW73Lcxc2Uf8r/csbftcfmC2P4layKXwcAPivKmKG3HaNv2pDWPvbjbPud/5n1/8T/u12XlfM/lsyf51v14P+75NpdcK3kv3+TbwWvoPUtCjDzJt3nl2z69xo+c2qonQIAAAQIECBAgMD+Btv+BcX6t1SICBAgQIECAAAECBAgQIECAwLgClyer/3gybtOwObXn+6Mzt27p0M/Hto+0bF9n04/FTuXHCl3TAyPgdl1BG2zPnu9yx7zjPMk3+TZl/so3+Sbflgt4PT11B9rlOsdj7Zye3zJi14qg8p+uPLIj+EWx/d5RLu6Im2LzPr8vHcr3m6Oic1oqe1tsO9GyfdNNT0hUUNq4ySRPNtA7MzHo59NV9QNxIVbu1jzodL8YnB4XgT/RVekZVXWTeAJ7XFdcy/bvjzpar3GjLYNe436iqtLXuC8c9xq3haVzUxmc/PIoPxKlz3V4uUNwubvtbaL8TJR3RynX2m+Jkpm2db29y88lu9y3TE6tE7MP+X9WwNx0BU65++63R7lPlFetiOlaXT7ne1qUL4jya13BK7Y/PNbfdsW27Op9zv99+Zyz5MJcrs3kW/cjc1uv890ty0XMJddKa+Vb9zmTb91G2Qj51i01Zb7t02t8t7wIAgQIECBAgAABAjsmcLUd64/uECBAgAABAgQIECBAgAABAgQ2EYjf46am7JeoqcpagubSnptFG8sdelZN5QeAT161cYP1r4l9n53YP363XT06EbduyGXJHbPnK1nd5GHZ9o+d//Itd+qz5ytX2/RR2fbLN89vQ2SnfPN6OkQeZeuYS75l2nujCHp+lK/vCC7vx74myoc64qbYvO/vE4Yy/o6OijLvwTuqaN1cBg9e0hqx2cAeedKB27Y5Bp6WgV13a4uJbX9x71P/eUBH2Hqb31xVPxd7/mNi74dcdOouZ4nQOuS5VXWzuIj80XrNkbmP/dMI17jnV1X6Gjd+yDHmNe6RDvdYcfUesSX0wijnRblLlN+Ocvh1MqhT05Q/nD9o0C4/l+xy3w7O3xh/9yH/PzPgyudsh6fyGPzWKL93eMOay+W5oPwHNI+JUgYF95ni/6moHtZnh0Ox+57/lx3yWLV4+Pl6Vdyc12f7MOZnT/ItlyHZc5WrbfqobPvHzLXSa/mWO/fZ85WrbfqobPvl27jXVHN8PZ1jm6Z/hDgiAQIECBAgQIAAgR0VMAB4R0+sbhEgQIAAAQIECBAgQIAAAQJrCWR/UJr9EnWtRizsNJf2/Hi06XoL7To8+5xYMdaAkKccPtiK5YfG+hus2Lbp6uwPJbLna9P2jLV/tv1j5798y53h7PnK1TZ9VLb98q2qPL9tnp/yraq8nm6eR9ka5pJvXe0td3Z7cZS7dwT+Tmz/pijZ90Md1W28ed/fJ2wMGBWUgd9xY9PW6S9bt26+sQz0eVFHNZ/Vsb1tszxp0+nYdkZVPbYjpIzUKndvHG367hgkGsf4ja4DRFtvEHHf3BV3eHvc3rIzR75hpGvcTyVfk6NfD71ovGvcwyR9lrsG75e6ymvhb0X5oigPiHIiyqrpo6s2HFqfHehwaLeNFjvzJGo/rp+F7HLfNjrpHTvvQ/5/9gqD/xbr/2TFtk1WPyF2/sk1Kij/Oc26077nf/Z9ffa6Zt3zMMV+2T6M+dmTfMud6ey5ytU2fVS2/WPmWum1fMud++z5ytU2fVS2/fJt/z5X36fX+OkfeY5IgAABAgQIECBAYMsCBgBv+QQ4PAECBAgQIECAAAECBAgQIDArgewPSi+fqNVzaE8Z+Pvwjv7+Qcf2TTZfGDt/MFHB2RFz/0TcOiHZ8509X+u0YYp9su3PeqzTZvlWVVnf7Pla5zxMsU+2/VmPddos3+Tb4byRb6fuouj19HBm9Fuew/NbV4uvEwHlDq937Aj85dj+L6Nkf1zaUd3Gmz1vb0x4ZQVfG/9eo6Oq93RsH2LzqzoquUls72rnsirkyTKV5LoYcPpVZ1TVPbvCP11Vf9QVM8D2p2bqiB88PCITdxATF5jXiz62XuPG4NvRrnHjV/gXRv2d17jRxrMjbqzX5AOOdf6+v2Wn8l7qyVFuG6W8fpQ7HndN2YEJU78W7fJzyS73rSvfNt2+D/l/myVIZTDJzy9ZP9SqMmDteT0ru3PE37znPiVc/u/P5wDlfG/72ky+7U++bTvXPL8VAfl2SqH+1+ec+/c5Z/acZ5+z6mwyR4AAAQIECBAgQIDA1gXi+zATAQIECBAgQIAAAQIECBAgQIDAaYHsD0qzX6JuCjuH9pS79cQNklqni1q3brax/Bi4DFDJTA/MBK0Rkz3f2fO1RhMm2SXb/qzHOo2Wb/kfKmXP1zrnYYp9su2Xb6fOhue3zbJSvlWV19PNcqjP3nPIt7b2nhkbnxbly9uCYtvPRPneKDHObzaT9wnDnIrbJ6qJm5SOPr0vcYR1vsuWJwnYlpBva9l2sOmV96mqdxwsjPX3vKp6YwyAfVmi/vOeW1Wfm4i7MuTap+5I23qNG7+GHu0aN0b0pl+Tz6iqsd4DZrmWxV2yZGV57XtSlM+LEjdwrk5GyU7Z9/tT/0h9l59Ldrlv2bxbN24f8n/Z8+kfB1jb4Od1PQ/2K+83HxLlwwcrEn/jKbK6XyLucIj835/Pncq53/a1mXzbn3zbdq6VfJdv8q3kweKUfZ+9uE92Xr7NM9+y5zz7nJXNB3EECBAgQIAAAQIECEwgsM6XphM0yyEIECBAgAABAgQIECBAgAABAlsRyP6gNPsl6qadmEN7vqmjEydj+z90xGy6+YXJCjJ3M0tW1QjLnu/s+WpUPqOFbPuzHut0Tb7lfziSPV/rnIcp9sm2X76dOhue3zbLSvl2ys/r6WZ5lN17DvnW1tYyQCvGn7VO5c6e/6k1YjsbvU8Yxr3cmbNrKoP4xp4u7TjA38f2MlCy7yRP+ootxMdoqnsvLC6djUG5U9z99+DYJw5mWv6eEbeK/o6W7Yc3teZI9O/kPx/5GjeOkX5Njift6N6spsODAH8/WnfHKN8T5Z1rtDT7ujn1j9Rb8yT6eTLKcf0sZJf7tkYK9tplH/L/NktEfnvJuqFXXRwVlvepfaYv7RN8Olb+78/nTuWUZ19jxvrsSb7tT75tO9dKvss3+VbyYHEa67mtHEO+zTPfsuc8+5y1mE/mCRAgQIAAAQIECBDYsoABwFs+AQ5PgAABAgQIECBAgAABAgQIzEog+4PSqb4c3XZ7zo6zUwadtU1/0bZxoG3Zuy9dP453t4GOuVhN9nxnz9di3XOaz7Y/69G3b/LtlFjWN3u++p6HqeKz7c969G23fJNvy3JGvp1S8Xq6LDvy67b9/NbW0sfGxoe3BcS2d0f5Nx0x29jseXs49dsmqiqD+caeynNN2/SWto0rtsmTFTCZ1XHRdYuI6zz3cXvozF15M4fsjImBsq/sDIqAGLjcdVfzK6uJPp4ddbZe48b20a9x4w1HNKV7in5dP0bjj3GN233w1REvjk3PifKnUb4qyrdGWefxGrtdOWXvOJ59fT2od5O/u/xcsst92+ScZ/fdh/w/9xDGR2L5eYfWjbX4xKj4sh6V37RHbAmV/6fAste9Uz7v9jyV6fBsH7Im6QNHoHw7pZW1zZ6rPudgyths+7Mefdsu3+TbspyRb6dU9ulzzuw5zz5nLcsr6wgQIECAAAECBAgQ2JKAAcBbgndYAgQIECBAgAABAgQIECBAYJYC2S89s1+ibtrJbbfn/OjAdTs68dqO7UNsfntU8q5kRevc/aOr6uz5zsZ1HW9b2+XbKXn5Nk0Gyjf5Nk2mnTqKfJNv+5Rvq/r6lbHhx1ZtXFj/iJh/38LyXGa9Lx3uTHxmoqo7JGI2DTmno4K/7di+bLM8WaaSXHdF4u6/paqIe3eyyo3D4lj/N1nJXTJxn66q82NQ7davce9XVW+PvqWuceMHHWNc42a4VsW8JjaUQdTlbvIvWRXUY312APCU19u7/Fyyy33rkXZrh+5D/t/2kM5zY/njh9aNtfiPUfGf9aj8Zj1iS6j8PwWWfT7NxvU8DZOGb/OzAPm2X/m2zVwr0vJNvp0SaP471vO4fJtvvmXPeTaumVGWCBAgQIAAAQIECBDYqoABwFvld3ACBAgQIECAAAECBAgQIEBgZgJz++HpttvzTYnz8/pEzBAhr05W8kXJuD5h2S/Dsz/06XPsKWPlW60t32qLsebkWy0r32qLsebkWy0r32qLsea2nW/L+nW9WPlbUa6+bOPCul+J+QsXluc0+02JxuzD+9IEQ2fINTsjquoLEjGbhpzTUcFbOrYv2yxPlqkk18XA2HtnQuPiaLIBwPepqrfFQNkPdrUr2v7Z8eTVeSfIiOvMkYiZ1XNJ9H+Ma9wu0im3Z183p7ze7syTAJpVnkR7snmyy32bMm+HOtbc8r/cIe/mhzr3x4eWx1480eMAnc/7h+qS/6dA9uVzztLb7GMsa3IopVoX5dspnqztlK/zrSduzY3bzLXSZPl26sTJt2YCZz2ae3Uvybf55lv2nB/359zuLBVBgAABAgQIECBAYAcFDADewZOqSwQIECBAgAABAgQIECBAgMDaAtv+ocbhhm+zPeVzowcebtCS5TcsWTfGqlcnK83+6DVZ3ZVh2S/Ds3F9jj1lrHyrteVbbTHWnHyrZeVbbTHWnHyrZeVbbTHW3DbzbVWf/mdsOGfVxtPr3xJ//2NHzLY2e186rHzmLn63ikN++7CHPVLbOUfWNFe8pLnYuSRPOok6Az6vKyIGo34ybvs65V3C45C5AcfXqqq7tLX/gqq6Wgzu7bzGjQNOco0bbUm9JkfcGNe4bVRTb4sbM6emqa63d/m5ZJf7lkqiGQbNLf9vd8ioPAeXOwBPOV3U42A36REr/2us7PNpNq6ueX5z27o2k291LmTzKBtX1zyvuW3lWlGQb3UuZPMoG1fXPK85+Vafj9Q1VYSPcU2VzaNsXN2r9eeyx8rGrd8SexIgQIAAAQIECBAgMLhA+QDARIAAAQIECBAgQIAAAQIECBAgcEog88V5+fFb9gd6m7pusz23icZnfkj3jk07mdz/b5Jxd4y4rrvbJau6Kix7vo/7l+by7apTXsm32mKsOflWy8q32mKsOflWy8q32mKsuW3m27I+PShWPnTZhoV15T3MQ6J8dGHdnGa9Lx32bLw/Wd0TIu46ydi+YTeIHdp+gPvS2F5Kn0me9NFaHpu5/vtg7FquiSebYgBsOWbnFI360rage1bVbaKuzj5GzCTXuNHe1GtytOeOTxv+GreNaupt2XzK3s1q0/bv8nPJLvdt0/O+rf3nlv+HBwCXQTWT3fX99El4TY+TkXnffVCd/D+QyH+ufdw/5yw9zuRIeRxmP/utFdvn5Fvtk7U97vm2rVwr0vJNvtUC9dwYz22ldvlWG8/x+W2ObarFzBEgQIAAAQIECBAgsJHA1Tba284ECBAgQIAAAQIECBAgQIAAgd0SyPxQIxMzlErmWJmYddpz+8ROF0dM5g5iiao6Q97cGXEqIG78VN06GZsNyxpn47LHnTou0/5MzDrtlm+1WtY4G1fXPK+5TPszMev0Sr7ValnjbFxd87zmMu3PxKzTK/lWq2WNs3F1zfOay7Q/EzNEr8rgzV9IVPTEiHl5Im5bIR5Hw8pnBwB/dhz2R4c99FW1PSLmrn3V0tGZnzm6qnONPOkk6gzIDI6N8aiTT6kBwNGwtkHlpdGpHDlvomvcGOWSvsa90fDXuJOfxJYDzu1H6qk8if4cx89CdrlvLSk2601zy/+zDmlNffffcvgy2P+fDrVj1WL5XDI7yf9aKnstko2ra57fXKYPmZi+PZNvtVjWNxtX1zyvuUz7MzHr9Eq+1WpZ42xcXfO85jLtz8Ss0yv5VqtljbNxdc3rz2WPlY1bvyX2JECAAAECBAgQIEBgcAEDgAcnVSEBAgQIECBAgAABAgQIECBwjAUyX3pmYoYiyBwrE7NOezJf5L9znYrX3Odkj/1u0SM2Ezq3H2Rm2rxOTCaXMjHrHFu+1WryrbaQb7XFwZzntwOJfn8zuZSJ6XfUU9Ge32o1z2+1xVj5Vh/h1NwPxJ+u541yp6VfPLzjzJY9joY9IW/qUd0PRuwdesRnQsv3049qCSx3/vuTlu2rNsmTVTK59WVg740ToVM9f13VlLh1VWoAcKL9s8qRy6rq5FWd7JiJk9P1XN5Rw6w3l7uTZaap7gA8qzwJmJMZnNMxXXmyy33rwTSr0Lnl/6+FzjlRPvd0+an4u43pkuRB35uMK2Hyv8bal+uy0uPM+5ZMTK2Xm5NvtdO+5FsmjzIxtVx+Tr7VVvKttpBvtcXBXNd75YO47N855tsc25T1FEeAAAECBAgQIECAQIeAAcAdQDYTIECAAAECBAgQIECAAAECeyWQ+VK8DJKYatpmezI/9P+HqSDiOB+Ikr0DyD58kT8GvXyrVeVbbTHWnHyrZeVbbTHWnHyrZeVbbTHW3DbzbbFP5U6eP7S4YsX8s2P9lO/pVjSjdbX3pa08vTe+pMce14zYE1G+tMc+XaFfFwFlYNGqqdz9NzsgarEOebKo0XP+oqq6fgwyPTOx2/UTMVsJifa3ti22d+ZIJN5kz4fxQEi/Jkfbh77G3co52vCgU30W05kn0Y/J8iSOlc6TiO3Kk13u24bpNfvdp8r/AvGOKCdPlw/H321MlycP2ucOwPK/Rt2nwUHbujaTb/uXb9vKtSIt3+RbLVDPjfXeQb7VxnN8PZ1jm2oxcwQIECBAgAABAgQIbCRgAPBGfHYmQIAAAQIECBAgQIAAAQIEdkwg8+Vo5sccQ7Fssz2Z/zn+/UN1NFnPyWRc149ek9VcFZY959m4qyqe2Yx8a56Qk83FlUvybSVN6wb51uQ52VxcuSTfVtK0bpBvTZ6TzcWVS/JtJU3rhm3m22LD/kssXG9xxYr5J61YP6fV3pcOezZe3LO6m0V8jA+tHthzv2XhN4iVP7tsw+l1T4+/v9uyvW2TPGnT6d5Wzk1mOiuS4exM4FAxXQN7F47TOgA44jpzJI61L9e4C2xbn41x16lprEEMhw/emSexw3HNk13u2+HzeFyW55b/c3HLviad7NFg+V9jZT+/zMbVNc9vblvXZvKtzoVsHmXj6prnNbetXCsK8q3OhWweZePqmuc1J9+a5+Nkc3Hl0j58zpnN7WzcSkwbCBAgQIAAAQIECBCYXsAA4OnNHZEAAQIECBAgQIAAAQIECBCYr0Dmi/OpfnRalLbZnswPRy6Z+FT+Y/J4N0/GZcMy56HUNWVuZNveJy7Tz7H6KN/qM5U5DyV6rHNRt2TcuUw/x+qjfKvPbeY8lOixzkXdknHnMv0cq4/yrT63mfNQosc6F3VLxp3L9HPsPn5OdPHfJrp5MmKel4jbdojH0bBn4G1R3Ut7VlkGk/9xlF+PkhlYvqz6cnfZMsB31fl8ZWz7rijrTqvqXaxvX65fFvucnf94NjCe5G6ZjR0ormtg75WHiVF0XbnZmSPRt0lzJNqcusaNH3UMfY070KkZpJoYd52aPpGK2jyoM0/iEJPmSRwvlScR15Unu9y3zc/8dmqYW/5vR+HoUW90dNXSNSeWrl2+Uv7XLvFyl5rGvmZJNWLDoExfx+infKtPXOYclOgxzkPdivHnMv0cq4/yrT6/mfNQosc6F3VLxp3L9HOsPsq3+txmzkOJHutc1C2p5+bYprp15ggQIECAAAECBAgQ2EjAAOCN+OxMgAABAgQIECBAgAABAgQI7JhA5svRKf9n5G2156ZxXjM/tnv/xOf/4uTxtvU/eU/5RX6SoleYfGtyybemx9BL8q0pKt+aHkMvybemqHxregy9tK18W+zHv46FsxZXrJj/1Vifae+K3SdZ7X3pOMz/a81qHxb7vSbKN66xfznmfVfs97pY/3VRPrpie9dqedIl1LE9XhjS13YxWu0uHdUNvTl1J8ho18qBwhdWVSpHoo60w0Cd3NZr8kDNH6SaqydrmeJ6O5Un0d7jmCe73LdkCs0ybE75Pxegc6Mh10g0pvzHFX+RiCsh8r8Jlf1se4rn3WbLhl/KXOtkPbKtk29Nqazvcc+3beRakZZv8q0pUC9lH3v1Ht1z8q1plDWe8vltjm1qqlkiQIAAAQIECBAgQGBtAQOA16azIwECBAgQIECAAAECBAgQILCDApkfakz5Ze222nOH5Ln9QDJuqLDsj6OvN9QBT9eTOQ8lNPvl+sDNG6y6TD/HyH/51jyFmfNQ9pBvTbfsknxrSsm32sPzW21xMOf19ECi39/M42qMfDtoZRlI8vCDhZa/5U6Kv96yfS6bPG+PcyaeHtW+dc2qPyf2+6MoL4ryz5J1/JeIKwPTl00vj5X3iJK9w+WyOuTJMpUe6x5UVZfH3Wg/ktklfmAw2QDgGLh7zWjTOZl2Rcy1nrRi0FhUMsscCfPUNW7i7sZJolmGzWkA5CzzJM5aKk8iru292y73bZaJnWzUnPI/2eTRw74ieYQy+Dd793r530TNXK+UPY77506lD5m+Dn1tJt+KfD1lzkGJPu75lunn0LlW3ORbUainzHko0fKtNuszJ9+aWnPMtzm2qalmiQABAgQIECBAgACBtQUMAF6bzo4ECBAgQIAAAQIECBAgQIDADgpkvhyd8scB22rPZyXP7bp36EpWfyTsfUfWLF+RuePd8j2Xr82ch7LnGD/iWd6icdZm+jlG/su35vnMnIeyh3xrumWX5FtTSr7VHp7faouDOa+nBxL9/mYeV2Pk20Er7x8zmee6P464dx/sNOO/mb6U5u/L+9KhTtXlUdH3bFjZPWL/l0X57Sifv6Kum8T6Z0b5yRXbnxHr7xNl07tpypMVwH1W97j77Zf1qXeT2Hgh+qLYP/16dMuquu6y48WPIlI5EgazfC6JdqUNlvV/5uuyAyDLf1wx9pTKk2jELPMk2tWWJ7vct7HzYsz655T/Y/azT93ZAcAX9qhU/jexMtcrZY/j/rlT6UOmr0Nfm8m3Il9PmXNQoo97vmX6OXSuFTf5VhTqKXMeSrR8q836zMm3ptYc822ObWqqWSJAgAABAgQIECBAYG2BM9fe044ECBAgQIAAAQIECBAgQIAAgd0TyHw5OuWPA7bVnqU/ml5yuqf+0Wt2YEC5S9SQU/bHOdm4Ids2ZF3yrakp35oeQy/Jt6aofGt6DL0k35qi8q3pMfTStvLtoB+r7rJ6sP3g7+8czHT8vV5sLwMxyh0/bxzlBqdL3JCyuiRK+Q9aSimDiV8S5V1Rhpy8Lx1Ss1nX82Px16Nk7hjd3LNeinGJ1YOjfHuU34/y01FeHaVM943yG1E+sywcmso11Y9EeeKh9esuypN15Rb2iwf1JXFCb7WwatXs3f6sqq5/flV9cFXAUOtj4G72LtNXHjIuBFc9B6dyJAwmvcYN79RrcrRr6GvcoU7REPVkB0BO8VlMKk+i05PmSRwvlScR15Ynu9y3IfJwW3XMKf+3ZXD4uPc7vGLJ8sdi3VOWrF+1Sv43ZbKfX2bjmrXPa2nV+4LFVg79+iLfFnXzd1o97vm2jVwr0vJNvjUF6qWhn9tKzfKt9i1z2eetbFyz9vWWssfKxq3XCnsRIECAAAECBAgQIDCKgAHAo7CqlAABAgQIECBAgAABAgQIEDimApkfakz5xei22nOd5Pmb+kevH062q+1Hr8kqGmGZ81B2yMY1Kp/RQqb9Y+S/fGsmQeY8lD2ycc3a57OUab98O3q+PL8dNcmskW9NJa+nTY+hl7aVb6Uft4hS7gCcmV7VElQGdX5DlB+McrcoMQYvPb0pIp8fpdxh+HnpvVYHep+w2maILd8dlZRB3d+8YWUlRx50uvzJ6bpKLpZcOjy9PVY8NMr/Obxhg2V5sgHewq6vjfk7Lyyvmr3WNU4N/P7lVQFDrY8Eukefut62emBmKkfiCXxfrnH7sI4dmx0AOcUdgFN5EiDHMU92uW9j5+iY9c8p/8fsZ7bu8hp0u0Twb0dM+Y9ospP8b0rFy11qysalKttSUKYPQ3/2JN+aJztzDsoe2bhm7fNZyrR/6FwrvZdvzRzInIeyRzauWft8ljLtl29Hz9c+fK6eyY0ik407qmgNAQIECBAgQIAAAQJbE+jzhf3WGunABAgQIECAAAECBAgQIECAAIGJBDJfeo7xP2ev6t622jPX/8n7I6ugDq3f1hf5Y/yo4lDXRl2Ub01e+db0GHpJvjVF5VvTY+gl+dYUlW9Nj6GXtpVvpR//PEpmIMmHIu5klGXTvWJlGQT4R1G+Mkrf7xLLoI1HRXlulJdFKW3aZPK+dBO97n3LtU25e+8zukPTEQ+IyFIOD/4tj41fjPKFUYYc/BvVzfZORNt6vi0mvae4y+yLsztF7COysevGxf8kUO46/o3Z/aNNn/zuqlo1SDT1XBJJO+nAznhQpHIk2jX0NW6WdYq47H9aP8VnMak8CZRJ8ySOl8qTiGvLk13u2xR5OtYx5pT/Y/WxT73lPUlmKu8n+kzyv6mVuV4pexz3zzlLHzJ9Hfr1Rb4V+XrKnIMSfdzzLdPPoXOtuMm3olBPmfNQouVbbdZnTr41teaYb3NsU1PNEgECBAgQIECAAAECawv0/dJ+7QPZkQABAgQIECBAgAABAgQIECBwDAQyX45O+eOAbbUn+z/HXz7xOR3iR6/rNDl7zrNx67Rhin3kW1NZvjU9hl6Sb01R+db0GHpJvjVF5VvTY+ilbeVb6cf5yc68JuJirFxjOiuWHh/lBVHu2Niy/sKXx65lIPCLotxyzWq8L10TrsduZcDkg6L8YY99+oaWY9wvyvdFyT4H9TmGPOmjtSI2LmbSA4BjQOpdYoDuV6+oapDV8b8ZPKzPwNeIXTkoM57wUjkST+D7co07yDkaqJI41alpjEEzhw+cypPY6TjmyS737fB5PE7Lc8r/bbvFzeWrhyQa8ZyIKe9l+0zyv6mV/fwyG9esfV5L27g2k2/NHMjmUTauWft8lraRa6X38q2ZA9k8ysY1a5/PknxrnovsZwxt/1lOs8bcUjaPsnG5o7ZHZY+VjWs/mq0ECBAgQIAAAQIECEwqYADwpNwORoAAAQIECBAgQIAAAQIECMxc4PBAiGXNneJHpwfH3VZ7sj8cmfpL4uwX+eVHg0NOmR9UlONl44Zs25B1ybempnxregy9JN+aovKt6TH0knxrisq3psfQS9vKt9KP+yQ78+pDcbeP5XK33h+KMsZ3h/eIel8e5S5R+k7el/YVWy++DND9lijfH+Xj61XRuld5f/5bUR4d5dqtkettlCfruTX2iv9B4I3xBPa+xsqWhRi19uQL2+842rJ3+6ZnncqTR7VHNbdG21cOAI4ntlSOxCDiSa9x43jbek1u4m13KTsAsjxPjT2l8iQaMWmexPGGyJNd7tvYeTFm/XPK/zH7man7wRF0y47AMvi+/GcifSf53xTLfn6ZjWvWPq+lbVybybdmDmTzKBvXrH0+S9vItdJ7+dbMgWweZeOatc9nSb41z8UQ75WbNeaWsnmUjcsdtT0qe6xsXPvRbCVAgAABAgQIECBAYFKBMb7En7QDDkaAAAECBAgQIECAAAECBAgQGFAg88X5lD/03FZ7rps0ndKiNCk7GGHoL6+z/czGJXknD5NvTXL51vQYekm+NUXlW9Nj6CX51hSVb02PoZe2lW93io58ZrIzf7MQ97CYf0WUOy+sG2P2s6LSP4/yDT0r9760J9gG4SV3fyFKGaj9qg3qWbXrzWPDE6O8Lcq/j3JmlKEmeTKMZMmBZ2erisGrt79WVT02G98n7jOq6glR/zl99onYS1viUzkSx5z6mi71mhwnZuhr3BaqyTdlB0BO8Z+xpfIkhGaZJ9GutjzZ5b5NnrQDHnBO+T9gt3pXFU+/1WMSez0+Yt6ciDscIv+bItnnsGxcs/Z5LW3j2ky+NXMgm0fZuGbt81naRq6V3su3Zg5k8ygb16x9PkvyrXkuUtdUsUvbe+VmjbmlbB5l43JHbY/KHisb1340WwkQIECAAAECBAgQmFTAAOBJuR2MAAECBAgQIECAAAECBAgQmLlA5ovzTMxQ3cwcKxPTtz1z/Z/js19KD31noOwPA7Jxfc/HVPGZXMrE9G2vfGuKZfMoG9esfT5LmVzKxPTtkXxrimXzKBvXrH0+S5lcysT07ZF8a4pl8ygb16x9PkuZXMrE9O3RfXvsUAYAx/i66rej/HqUbK5G6EZTufPr70b5wh61ZNuWfZ/Y49CtodnjDf2+tLVRA218fdTzFVF+JsoYj8cyEPgXo7w2ytdFGWKSJ0MoRh0xwvLnelb1wy+sqq/vuU9reNR3/wj43tag5RtPLl9dVfGkm8qRqQcA9zjecXwuWXU6Dq+f0wDIVJ5EB7KvAYf7uu5y9nhtebLLfVvXdQ77zSn/t+lRXkfu2NGAt8f2n+6IWbVZ/jdlsu/vsnHN2ue1lLnuysT06ZV8a2pl8ygb16x9PkuZPMrE9O2RfGuKZfMoG9esfT5LmVzKxPTtkXxrimXzKBvXrH29peyxsnHrtcJeBAgQIECAAAECBAiMImAA8CisKiVAgAABAgQIECBAgAABAgSOqUDmS/FMzFDdzxwrE9O3Pdn/Of5GfSveMD57x5+2H72u04Tsl+HZH+Wu04Yp9snkUiamb1vlW1NMvtUe8q22OJjz/HYg0e9vJpcyMf2Omr8Ti9fTpqzX06ZHdulLk4El168Z5ZVRHrxin/Jc89IoZYDwT0X57tPlx+Lv/47yzijrTnHD0OrpUbKv/9m4fXkcreved7+SA/8pygP77tgj/nYR+6woz4hy0x77LQuVJ8tU1lh3flW9Jp4knpPdNQawnhk/OPj9Fw40CDjquX/U+bTs8Q/FnTy0vLiYypF4Iz7L55IwGfo94KLNtuezdwOfwiCVJwE2yzyJdrUZ7XLftp3Dmxx/Tvm/ST822be8L/3vHRWU96/fE+VjHXGrNsv/psy+fO5Uel1yp2vKxHTVsbhdvi1q5P9DIZ8DNN2yS/KtKbUvz2+Z561MTFOve0m+NY3mmG9zbFNTzRIBAgQIECBAgAABAmsLZD9MXvsAdiRAgAABAgQIECBAgAABAgQIHCOBzJfi2S9Qh+j2ttrT9qPRxX59YHFhgvnsD4GyA4WzTc4ed8rcyLa9T5x8a2plz7t8a7pll+RbU0q+NT2GXpJvTVH51vQYemlb+VYGU2amGEd25eC+s5YEvyvWPTnKr0Z595Lti6vuEgsPi1IGB/f9vrG09Zei/KsoXZP3pV1C42w/O6r9gSg/Ok71jVq/IZbuGuWRUZ7d2JJfkCd5q87IeJF4fDyov6YzsA64xulBwN9/76r65VideR6s9z49d6Kq/nXs+L/iSarvc8pBXScPZpb8TeVIHH/Sa9y4kPjUNZY0dsmqoa85lhxia6uyd0BNncMNe5E9xqR5En0a4r3bLvdtw9O+1d3nlP/bgvjhOPDndRy83Pn3eR0xbZvlf1Mn+5xy3D/nLL3OvCcZup/ybT/zbRu5VqTlm3xrCtRLQz+3lZrlW+1b5ub4ejrHNjXVLBEgQIAAAQIECBAgsLaAOwCvTWdHAgQIECBAgAABAgQIECBAYAcFMj/UyMQMRZM5Viamb3vKndkyU/aHipm6MjHZL6+zP0TIHLPEZH8skY3LHnfquEwuZWL6tlu+NcWyeZSNa9Y+n6VMLmVi+vZIvjXFsnmUjWvWPp+lTC5lYvr2SL41xbJ5lI1r1j6fpUwuZWL69ujze+xwePDv+2Lfb49yTpSfjNI1+DdCqv8b5d9F+ZIoJ6L0nf5l7HDHxE4eRwmkgUPKgNw3RymDbT5j4LpXVXfz2FDuBvykKNdeFdSyXp604PTddN+quij2KXfq7jOVQcC/dKKqXvJnVfWFfXZ8YVV9RRzwxbHPk5cM/n1bj7pOtsSmciQucCe9xo3+busat4Vq8k1Z86Gv85d1NJUnsWO2zcuOsc66IfJkl/u2julc9snm0hT5vw2Tz42Ddv1nIy+ImMdt2Dj53wTMXm9l45q1z2spc92VienTK/nW1MrmUTauWft8ljJ5lInp2yP51hTL5lE2rln7fJYyuZSJ6dsj+dYUy+ZRNq5Z+3pL2WNl49Zrhb0IECBAgAABAgQIEBhFwADgUVhVSoAAAQIECBAgQIAAAQIECBxTgcyX4pmYobqfOVYmpm97sj9AXPfOTH3b0zd+6B9GZr8MH+Nc9O37JvGZ9mdi+rZBvjXF5FvtId9qi4M5z28HEv3+ZnIpE9PvqPnBIV5Pm7JjnIvmEcZdyrQ/E9OnlTeN4Bv22WEh9sUxf+covxclO8BoYffqtbFwnyj/e3FlYj7GvVX/MRHnfUICaaCQ60Y95Tw+I8qtVtT5V7H+i6PcIkoZIDz0XTD/TdT5J1H6DgKWJ4E25PTRuCNzPFH97Rp13i3uaPvqi6rq/5yoqn8fo7ZufUFVNX6TUJZfWFV3ivKYiPnz2PiX8YTwVVVziiZUD442/Gpz9eqlT1bV61dvTQ/YnOVrcjgM/R6whWryTdnH7xQG2bbMMk/izLUZ7XLfJk/aAQ+YPS9t53bA5kxaVXkvWP7jj7Nbjvr3se3BUbKfk6yqKut8HB/bq/rctj7rGS8/x37K9CET0wdCvjW19iXfMnmUiWnqdS/Jt6aRfKs95FttcTA39PupOebbHNt04O8vAQIECBAgQIAAAQIbCjS+bNuwLrsTIECAAAECBAgQIECAAAECBI67QOZL8UzMUA6ZY2Vi+rYnfjudmrI/MElVlgjKHu+fEnX1CckOhhnjXPRp56axmfZnYvq2Q741xeRb7SHfaouDOc9vBxL9/mZyKRPT76hV5fmtKeb5rfYYOt9uV1fda+6JEX1elDK4YpOp/MCwDNz8Hz0r+c6ILwNJ2yaPozad4baVOzn/dZRHrKiynIcfjnLXKH8T5T1R/nOUz4lSBnK/K8pQ072iomdHyd5dqBxXnhSFAaf7V1V5z/Gt8WT18TWqPSNGdX1l7PeLcQF38p5VddlFkSNR3nAicudeMUgxfqTw2ig/GzFfHeXw9PZ4Urn7varqd2PD7Q9vXLH8oZdU1etWbCurUzkS/c1ec7YcKr8pe7yIG/o9YL6R40dmzVPncMPmZo+RbfOGzblq9+zx2vJkl/t2FdQxnMme2+z5O04Ej4nGnt/S4Mtj27dFeW9LTHZT1i97PrLH7YrLHq/tsd11jGXb9+W6rPQ9XkI7p0xMZyULAfJtASNm9yXfMnmUiWnqdS/Jt6aRfKs95FttcTC3D6+n+/IYODin/hIgQIAAAQIECBDYKwEDgPfqdOssAQIECBAgQIAAAQIECBAg0CGQ+VI8E9NxmPTmzLEyMekDng7M/nDkGn0r3jA++8O4D254nMO778v/mp3JpUzMYb+uZfnWFJJvtYd8qy0O5jy/HUj0+5vJpUxMv6MmBxtFpV5Pm7JjnIvmEcZdyrQ/E9OnlbfpE3w69pnx9wejZH8c2HWI0qdHR3lBV+DC9mvG/EMXlpfNep+wTGXYdfeN6l4U5dwV1f59rL9XlMdHOfw+5cOx7ueilBx8ZJR3RBliKgPT/7BHRfKkB1Y2NE7CX8cD+yFR1hkEfNVhzqiqM6PcMkoZzHuzKG2/UXheHOzL7h13ES4VxD53KH+7pmjjyy84mp+Lu6VyJI436Wty3GoydY0b7Rr6PeCizbbngyE1DX3HrmUHTeVJ7DhpnsTxUnkScW15sst9W3Yuj8u6OeX/lGZ3i4P9VMsBy/vK74rykpaYPpvkf1Pr8Pu55tZ6qZyH4z5l+pCJ6eMg35pa+5JvmTzKxDT1upfkW9NIvtUe8q22OJhre698ENPn7xzzbY5t6mMqlgABAgQIECBAgACBFoG2L9dadrOJAAECBAgQIECAAAECBAgQILC3AmN8cb4J5hjtyf6w9tqbNHyNfbM/jLx0jbrbdskOjBnjXLS1axvbxuijfGueSflWe8i32uJgzvPbgcTwf+XbUVP5dtRkqDVD59v1ejbsHRH/sJ77ZMJLvx4R5UOZ4NMx9+iI9T6hA2jDzd8R+18Y5TNW1PM3sf4uUboG4JTz9GtRPj/Kv4vyj1E2nb4mKnhAshJ5koTqGxYDcf8gfkF8n3hwv6/vvj3jr4hj/NSJqvraOPHvL/teFAOHY90dk/X8RVtcDKBN5Ugcb1+ucdu4pt6WHdyaHeCySftTeRIHOI55sst92+Scb3vfOeX/VBY3jAOVO7y3fcb3I6djhmqT/G9K+typ6REv/4NO8q3JKd9qj6FzrdQs32rfMiffag/5VlsczO3D55weAwdn218CBAgQIECAAAECOyhgAPAOnlRdIkCAAAECBAgQIECAAAECBEYVyP4PyqM2YqHyMdqT/WHtdRfaMcVs248DF4+/D/+T92J/p5yXb0e15dtRk6HWyLejkvLtqMlQa+TbUUn5dtRkqDVD51vf92TfFR35wFCdOVRPGVz8uEPr2hbvHhtjbN7KyfvSlTQbbygDbH8zyqo7Wb4stt0rynuiZKfLI/CXopwb5TFRNn0e+fGoIzPJk4zSmjH3qaqXxpPWXWP3N6xZRetu8cv0S6Lc/7yqeuwFC3fxjXV3iSeH7PNb1yB1OdJ6Fra6MTsAMjvAZZPO7HKe7HLfNjnn2953VjiD/AAAQABJREFUTvk/hUV5z/eUKLduOVh5H/H4lu3rbJL/TbXstUi8FO/FlPXIYsi3plTWdx/yLWvRFGxfkm9Nn6yxfGu6ZZfkW1Nqjvk2xzY11SwRIECAAAECBAgQILC2gAHAa9PZkQABAgQIECBAgAABAgQIENhTgbn9OGCM9mS/yL/OxDmQvcvO0P+Td/ZL84k5tnI4+XaUXb4dNRlqjXw7KinfjpoMtUa+HZWUb0dNhlozdL6tunvrsva+MVaeWLZhwHVPibo+mqzvhhF3p5ZY70tbcDbY9AWx7+9FWTXw6GRs+7oo6w4U/1js+4Qot4vym1HWncrdhx+Y2FmeJJA2CblPVb31vVV156jjP0S5eJO6FveNJ8MXxKjxL4nBv89ZXF/mY5TYvQ6vW7H8oUi4i1Zsu3J1XNClciR+PDHpNW60a1vXuG1cU29b9Tx0uB2pc3h4p57L2WNMmifRhyHyZJf71vM0zyp8Tvk/BcxPx0G+oeVAz4ht5XVm6En+N0V9ztn0GPraTL41feVb7TF0rpWa5VvtW+bkW+0h32qLg7l9+JzTY+DgbPtLgAABAgQIECBAYAcFDADewZOqSwQIECBAgAABAgQIECBAgMDaApkvxTMxazfg0I6ZY2ViDlXbufjxzohTAVP/6DV7vPht+qDTp5K1HffP2jK5lIlJcl0VJt+uorhyRr7VHvKttjiY8/x2INHvbyaXMjH9jlpVnt+aYp7fao+h8y17h8zSghfWzRhtrtz1tQwuzU5f1hLocdSCs+am8p76mVGut2L/cpfNb4zyvhXb+6wudw9+aJR7RHl9nx0XYn98YX7VrDxZJTPg+gdV1eX3qqr/GQ/wc+NJ7MejvGOD6v8q9j8/Bv7e935V9c5l9cQA4HsuW79k3bPuX1WXLVm/uCqVI9Gm7DXnYt2bzKeOF+0a+j3gJm0eet/sAMgp7gCcypMASJ23AaGyx2vLk13u24DUk1c1p/wfu/P/Kg7wIy0HeXFse3CUMQauyP8m/L5cl5Vex0to55SJ6axkIUC+LWDE7L7kWyaPMjFNve4l+dY0km+1h3yrLQ7m2t4rH8T0+TvHfJtjm/qYiiVAgAABAgQIECBAoEXguP8osaVrNhEgQIAAAQIECBAgQIAAAQIERhEY44vzTRo6RnvKoI3MtGrQQGbfdWKyP3p91zqVt+yT/fFh9oebLYea/Sb5dvQUybejJkOtkW9HJeXbUZOh1si3o5Ly7ajJUGuGzrc+A4BfNVQnOup5asf2xc03XVw4NO996SGQARYfF3XcpqWe/ye2vbpl+zqbyqCeMtD7KWvs/CWxz1079pMnHUBDbo5bN34oBu5eEOWcGJF5x3hC+8Go/3nx963x90NLjnVFbLs0yoti2+PiNmV3v1dVfXns//wlsVeuuqiqzoyZr1q1fXF91Pv0xeVl82dUVSpHoq5Jr3Hjxxqpa9xo19CvycuYtrUuex2dvcPdJv1I5UkcYNI8ieOl8iTi2vJkl/u2yTnf9r5zyv8xLcp/BPLklgP8ZWx7QJS4ofsok/xvsvqcs+kRL7ODTvKtySnfao+hc63ULN9q3zIn32oP+VZbHMy1vVc+iOnzd475Nsc29TEVS4AAAQIECBAgQIBAi0D54sxEgAABAgQIECBAgAABAgQIECCQFxjji/P80Y9GjtGeS48eZumamyxdO97K7OCWob/Izxrvw2dtWYs+WSDfmlpZY/nWdMsuybemlHyrPbIW9R7dc/KtaZQ19vzWdMssnZ0JOh3zjh6xm4T+VexcBmtlzucNWw7kcdSCs8amO8U+P9CyX7nr74+3bN9kUxnU8/AoZTBwGQSUyY0Iu3K6XfxbBgetmuTJKpmR159fVW+IQ5TyxINDXVRVZ8eD/2Yx6PbsuP3QpTEq4ZK4e3D2TkRXVhMvGPeJ/T/joM6Wv2XA8XNath9sOtY5EnjvOujIDv7NPhdMcQfgY50nkRttebLLfTvOD4s55f9YjudGxX8Y5awVB3hFrP+aKMv+A4kVu/ReLf+bZK7L1vNo7rV6Sb41beRb7ZG1qPfonpNvTaOscfb1t1n78VrKWvTplXxramWNp8y3ObapqWaJAAECBAgQIECAAIG1Baa8uFi7kXYkQIAAAQIECBAgQIAAAQIECEwkkPlyNH6HPNm0rfZk/+f4tru1jYGUuctOGWjy7oEPnj3n2Tu3DNy8waqTb01K+db0GHpJvjVF5VvTY+gl+dYUlW9Nj6GXtpFvH+nRiff0iN0ktAz2fF2UL05UcqOWGO9LW3DW2PS42OcaLfv9j9iWNW+ppnXTU2JruSvNU1ujmhvL4KG2Kdvmfbl+abMafdt5VfXxOMjfbXKguAB7SHL/3zx9vK7wVI7EcSfNkXjBuF4cs3WKmE++dPhr3NZjTrwxex1drvXHnlJ5Eo2YNE/ieEO8d9vlvo2dF2PWP6f8H6Of5bFyYZQbr6j8r2P9P4+Szc8V1XSuztZ/HB/bnZ1fEtD10nOwSzY/D+Ln+Hcb12byrZkJ+5Jv28i1Ii3f5FtToF7KPvbqPbrn5FvTKGs85evpHNvUVLNEgAABAgQIECBAgMDaAldbe087EiBAgAABAgQIECBAgAABAgT2UyD7BepUOmO0J/tF/tR3AM78EO8fAr4MKBhyyhpP+UX+kP3rU1fWok+d8q2plTWWb0237JJ8a0rJt9oja1Hv0T0n35pGWWPPb023zFI210pdH8hUOFBMuQtwZrphS1C2b/vyvrSFqnPTLSLim1qiynvo/7dl+5CbynF+okeF53bEypMOoOO0+blVdZ1ob1uuHnTn03Fn3J87WGj7Gy9As8yRaFfnNW7E/MMFw1/jtnFNvS37uj/FHYBnmSdxQjrzJGK6PgvZ5b5NnbNDHm9O+T9kv0pdZeB6uUP755eFJdNrY919o0zx3lT+N09AvLSkpmx+piqbcVDWI9sF+daUyvruQ75lLZqC7UvyremTNZZvTbfsknxrSs0x3+bYpqaaJQIECBAgQIAAAQIE1hYwAHhtOjsSIECAAAECBAgQIECAAAECOyiQ+eI/+wXqEDzbas+lycZnfoSarCoVljnem1M19QvKnvPM+ep35GmjM+3PWvRpuXxramWNM+erWfO8ljLtz1r06Zl8a2pljTPnq1nzvJYy7c9a9OmZfGtqZY0z56tZ87yWMu3PWmR7lv0RZqnvsmylA8S9JVnHtVriPI5acHpuekTEt939989i+7t61rlJ+H+Nnd+WrODcjjh50gF0nDafVVXfGE+SZRBw6xS3Wfuj+1TVW1uDTm+MgcLHNkein2Nc42bYporJvG6WtkxxB+Bjmyfh05Unu9y3qXJ1jOPMKf+H7N/ZUdmzonzpikpfH+vjKby6ZMX2oVfL/6Zo9lokm5/N2ue1lOlD1iPbM/nWlMr6Zs5Vs+Z5LWXan7Xo0zP51tTKGmfOV7PmeS1l2p+16NMz+dbUyhpnzlez5vWX5tim9XtjTwIECBAgQIAAAQIEGgIGADc4LBAgQIAAAQIECBAgQIAAAQJ7LpD5Ijb7BeoQlNtqz3uTjf+cZNxQYZk7u71uqIMt1JM952cu7HMcZ+Vb86zJt6bH0EvyrSkq35oeQy/Jt6aofGt6DL20jXzrMwB4igFUB6bZdr3/YIclf70vXYKy5qoHdOxX7tI35XR5HOyxyQOe2xEnTzqAjtPmuPh6VLK9/z0ZV0WdqRyJuH25xs3STRGXed0s7ZjiDsCpPIm2HMc82eW+TZGnYx1jTvk/VB/LZ2NPj3KPFRW+KtbfM0o2J1dU02t19ljH8bHdC+J08L58zlm6m3mMZT2y1vKtKZX19bl60y27JN+aUvKt9sha1Ht0z8m3plHWeMrntzm2qalmiQABAgQIECBAgACBtQUMAF6bzo4ECBAgQIAAAQIECBAgQIDADgps40dBbYzbas872hq1sO2GMX+9heWxZ2+ROMBrEzF9Q7JfmmfOV99jTxmfaX/Wok+75VtTK2ucOV/Nmue1lGl/1qJPz+RbUytrnDlfzZrntZRpf9aiT8/kW1Mra5w5X82a57WUaX/WItuz7F1YSn3XzlY6QFx2APDFLcfyOGrB6bGp3InvLh3xL+/YPsbm34tKP5CouOs/LpAnCcTjEHJRVd032nm3rrbGXXGffV5V/WVX3MH2eNJN58iF+3GNe0Azh7/ZH8RP8R9YpPMk4I7bZyG73Lc55PG6bZhT/q/bh8X94um2emqUr1tcuTD/FzF/XpT3LaybYlb+N5XLecpMmeuaTD3bjMn0IeuR7Yd8a0plfTPnqlnzvJYy7c9a9OmZfGtqZY0z56tZ87yWMu3PWvTpmXxramWNM+erWfP6S3Ns0/q9sScBAgQIECBAgAABAg0BA4AbHBYIECBAgAABAgQIECBAgACBPRfIfBE75ecp22rPP0QeZO+uc86EOXPrxLHGuANw9pxnzleiC1sLybQ/a9GnE/KtqZU1zpyvZs3zWsq0P2vRp2fyramVNc6cr2bN81rKtD9r0adn8q2plTXOnK9mzfNayrQ/a5HtWXagbalvygFL/5TsQNtdZDyOkogdYf8stp/VElMG1r2yZftYmz4VFT8/UXm5W3DbJE/adI7Xth9LNLfkww8k4q4KeVFVpXMkHijnXLXj+DOd17jxIBnjGnf8nuWPkHndLLVlP6PIH/loZDpPYtdzju4+2prOPIkjd+XJLvdtNPgJKp5T/g/R3f8ZlXzniopeGOvPj9LnfeuKqnqvlv9Nsuy1SDY/m7XPaynTh6xHtmfyrSmV9c2cq2bN81rKtD9r0adn8q2plTXOnK9mzfNayrQ/a9GnZ/KtqZU1zpyvZs3rL82xTev3xp4ECBAgQIAAAQIECDQEsm/4GztZIECAAAECBAgQIECAAAECBAjsqEDmi9js/6A8BNG22vPpaPy7kh04Jxm3adhZUcFndVRSBhC8piNmnc3Zc569c8s6bZhiH/lWK8u32mKsOflWy8q32mKsOflWy8q32mKsuW3k2yU9OjPlAODs95BtA4C9L+1xcltCb9OyrWx6T5SPd8SMtfnPEhW/syNGnnQAHYfNL6iqe8eF11d1tfWKqvq586rqb7viFrdfUFXpHIknrnMW9x1r/mkxKD/623qNG339VLyojHGNO1a31qk387pZ6i3/UcHYUzpPoiHnjN2Y0/UP9d5tl/s20akY5TBzyv9NO/j4qOBRKyp5dqx/QJSPrNg+9mr53xSOl5/UdNw/5yydzDzGsh4ptAiSb02prO9xz7dt5FqRlm/yrSlQL2Ufe/Ue3XPyrWmUNZ7y+W2ObWqqWSJAgAABAgQIECBAYG2B7Bfvax/AjgQIECBAgAABAgQIECBAgACBYySwrR9qrCLaZntOrmrUofV3OrQ81uKtouKuz7JeFTEfHqEB2S/NM+drhOYNVmWm/VmLvo06mdxBvtVQmfNVR89vLtN++VafN89vtcU6c/KtVvN6WluMNbeNfPub6EyME0tNUw4Avn6qRVV1cUfcyY7tB5v34X3CQV/7/r1xxw4f6Ng+5ua3Jyo/OVBMqUaeJDCnDrmoqq4bT56/kjjuP0TMf03ELQs5uWzl4XVx0TlJjsSDMvWafN4417iHu73N5ewP4qe4A3BxOJnEmCRPoi2pPIm4zGchu9y35GmbXdjc8n9doAtixx9asXP8fwfVN0fZ1n80ctCskwczHX+P42O7o0tHNmc/a8lc1xypfGYrMn3IevTp2slksHyroTLnqo6e31ym/WPkWpE4meSQbzVU5nzV0fOby7RfvtXnbZ8+V8+e90wO1YLmCBAgQIAAAQIECBCYhUDXjyZn0UiNIECAAAECBAgQIECAAAECBAhMJJD54V32C9QhmrzN9pSBJJnpizJBA8TcPlHHnydi1gnJnvPj/qW5fKuzQ77VFmPNybdaVr7VFmPNybdaVr7VFmPNbSPfPhSdeXOyQzdJxg0Rlh0A3HV3S+9LNz8bN+qo4oMd28fcfHGi8pOJGHmSQJprSFxw/VK07bYd7bsibgH7XeflBjoeqSr+l4RUjkTcJNe40efO1+SIGesa94jPFldkr6OnuANwYUjlScRNkidxnM48iZhsnuxy34LhWE5zy/91EH84dvqxFTv+Rqx/cJSpBvCvaMaVq+V/rRMvL6kpm5+pyrYUtI1rs9JV+Vaf8H3Jt23lmnyrc63MybfaI2tR75Gb8/xWO2WNp3w9nWObajFzBAgQIECAAAECBAhsJHC1jfa2MwECBAgQIECAAAECBAgQIEBgtwQyX8Rmv0AdQmab7XlZsgNfnIzbNCzz49rsj177tiV7zjM/9Ol77Cnj5VutLd9qi7Hm5FstK99qi7Hm5FstK99qi7HmtpVvr0h26AuTcUOE3SBRyRsi5p0dcd6XdgAlNl+7I+bsju1jbh7qrpXyZMyzNGLdcfffh0T1D00c4gn3rao/S8QtDYmLulSORNwk17jxQ43/n707gZPjKA/+XzW7K1nyIdkG28IGX1wJpw/Atg5L2tVhg194cTiTkBDACQRjS9gc+efYF3IBtowxhJf8wxESSIJNSDCgcyXZWskyyFzmJgkYG1/4wJKta3em3qe8Wu/MbB/V09U9Pd2/9qc8013V1VXferpnZzQ1Hfua3HCf2BnY5x7Z6PqdlbwmEDrFidjmEidynNg4kTKun4WUuW89Eu7Tmlm0+J/WwJgNl0r+34aU+RfZ/kZJ9ZD8vDcT/1PiVfmc0/a4W+/NiLfqxVu3Ys1KE2/E25TA1DPXa/3UHm7PiLcpJ1fjPP/dsIhtmhLjGQIIIIAAAggggAACCKQScP0wOdVB2BkBBBBAAAEEEEAAAQQQQAABBBDoEQGXL2rk+XlKN9uz03HMninljnQsm6ZY3GQV+2Vg1y+9Jm2H65i7jFfSY+dZ3qX9rhZJ2028TYm5GruM11StxXvm0n5Xi6S9I96mxFyNXcZrqtbiPXNpv6tF0t4Rb1NirsYu4zVVa/GeubTf1SJJ71wnAL8wSaUpy57isP96hzKcRw5IMUUeisk/NiY/y2yXO0V/3aEBxIkDUtGKyOTfp8s3lP/OoV1f/7FSf+pQLrTIAaWcYkTuAPzM/8zhPa5M7o19j7s3u/e4oU5dyHB53bTNkqHJZXGKE2lJL34WUua+5RIcGRykaPGfpItvlsLXhuxwg2z/XUlyqSvMQvxPDYXrexHX+JyquXjPXPrg6pGkd8TblJarr8tYTdVavGcu7Xe1SNo74m1KzNXYZbymai3eM5f2u1ok7R3xNiXmauwyXlO1pntWxDal6xF7I4AAAggggAACCCCAwBMCrn/wP7EDTxBAAAEEEEAAAQQQQAABBBBAAIESC7j8Q6zrLyj7YOpme34mHbjXoRO2jQscyqUtclZMBSOS/3BMmU6zXcfcZbw6bUMe+7m039UiaXuJtykxV2OX8ZqqtXjPXNrvapG0d8TblJirsct4TdVavGcu7Xe1SNo74m1KzNXYZbymai3eM5f2u1ok6V0RJwDH/f1m++cyAZjzKEkkBJeN+7v+ScG75bL1yTFHeUDyN8eUsdnEiQNSkYp8QakZ0p5/lRT3g1IPyeTd1/6hUqnuALtCYsQ4vMeVC3TfETm8x5UvakReI6WtIy/L7j1ukULB5XXTtjev77aU+VpS5r4VKaaTtKVo8e/a9t+Wgp+QFPQ3rfyGgnq9pKLc+Vea8vhC/E9KBI/bVO7UM9f4nNqjeM9c+hAUx2l7QrxNCbr6uozVVK3Fe+bSfleLpL0j3qbEXI1dxmuq1uI9c2m/q0XS3hFvU2Kuxi7jNVVrumdFbFO6HrE3AggggAACCCCAAAIIPCGQ1z+SPHFAniCAAAIIIIAAAggggAACCCCAAAIFFnD5h1jXf0D10c1ut+ffHTux2LFcp8XmyY727jpRy/VRmSnzXMe8P+Vx0uz+Atn5Iklp2kC8TYwA8RYficRbvJFrCeItWspHrNkjcH2bcCbeyh1v35Luyc0iY5cTpMTxsaXSF5gpVcTd3fKAlLnJ8VD8XRoM5XqdjJsALPMd1YnBh8h860kxR7BjPx5TZjKbOJmUaH10jZPWvTJeO06pv5E3WpGTYKUJ+2QG2UV28q6P5sjxnGJE/nBY7ON4YXWsUyr2NdkoleV73PamdTNGXP5Os+11Ldfet07WneJEKl7cSeUJ9omNE6kraZyUuW8JaKcV7dY54BrXruWmdSyDDRdLnf8oKej7Zl+T7a+WlOoHG2T/rBbif0JWXg6dljSfMTodIKKQr3PS5dxx9YhobmAW8TbB4urb6/HWzViz0sQb8TYhMPV/13Nvag/3Z8TbhJWrcZ7XtyK2yT2yKIkAAggggAACCCCAAAKRAkEfyEbuQCYCCCCAAAIIIIAAAggggAACCCBQYgGXL2rk+XlKt9vzecexXuZYrtNi58fsaL9Y+B8xZdJku4yDrd+1XJq2NO97uqz8qaTvS/q2pC9L+rQk13/kl6Iti0v7s4x/4m1iOFzGwZZ0LdcyyClWiLcUeBG7cn2bjuM71uwRXM4Xrm8TX9Sv2utpmeLtMYl110lAclPJzJfnyxEGYo7yOcnfF1NmMpu/EyYllOokbu+Z2j302ZLQnGwz4o77bwkOT5xMYXUSJ1N7Z/xsi9zRVw6xKuYwDSN3kRxUakdMOefshlKFiBH5hYTYvwEPZvse15oVIUZmSDtc37/GvaY4x4FDwULEibQzNk6kTNK/3crcN4ehbSnS7XOgqPHfgtS28lJZ/xdJfW3b7epGSXZysFy+CrsQ/xNDEzR+QYPmWi5o3062ZXFOuvQhq88CiLdqxVs3Y81KE2/E24TA1P+zurbZIxBvE84u570t6VpuotZ0/3c9lmu5dK1hbwQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQCAjAfvlcvmOcWT6XkbHDqq22+2xX8T9uaQ4E5v/DElZLZ+WiqPa8M9ZHfhQvWfHHH+yba/IuB32Sxu2LX8iaaekyeO2Pw5KXicL8Tah9ml5aDdtXifeWn2It07Otql9iLeJO0dleW2z2lzfJmKOeCt/vC2QoW5+zQp7vmUiJDL9/3BMW+wPuJyaoAVV/rvUx9+A9o4zD8eMyacSjIevonZc74to1/9IXpIvphIn2b1X8DXmaqtM/JVUl2Ri0luV/0XLBfDnMcd9vF0bMnyPK234dFQbJD+L9xw+riW+R+RJUqFxTM/yffCI+sp8LSlz3yKG9PGsop0DRY3/MEf73t/+cEvQOSuXLTUrbMcCba9y/DcPg33/HTSO7dt6/XNO2+dufhZAvE1EXVXirZuxZqWJN+Kt/Rr+vQmSTP5PvBUr3poHuSjX3OY28RwBBBBAAAEEEEAAAQQ8CdgPuFkQQAABBBBAAAEEEEAAAQQQQAABBCYEXL5c7lLGl6fLsVzKdNoe+6UBe2c2l8XewSmLZYZUGveFs6uzOHBTna7GruWaqo59epKUeJMk+yWi+yV9Q9JfSXqJpKDlIdl4S1CGwzaX9ruUcThUYBHibYLF1di1XCB2yEbiLRiG61uyyVfBiq1b84w1e2SX88WlTGsv3Ne4vk1YuRq7lnMdgSrF26ig/MgB5nwp8zSHcp0Wsf/++MaYnT8j+T+LKdOcXbXzyHfcjgvm2mbQgOcXyrbDArZnucn+TXtcxAGukLx6RH57FnGS3XuFduvE68PyIwxblPqw7LhGUuj3FGQQ63Kn3j9erNTHpZzvxci31Z3e48ob0Uz+BvyCUrHvceWE9fUe1/e1xPd4zElQ4eEJyqYtWuZrSZn7FjTuRT4Hihr/QY4LZON/Sgr6O2G7bH+ZpH2Sir5ULf7DxsP1/ZZrubDjBG3P+5x06YNLmaC+xG0j3iaEXH1dy8W5N+fnGW8u7Xcp09z+JM+JtwktV2PXcknGgHgL1srkPZUcKvY9lZTx9Z4quGdunzfbfbOIt15qU1hb2Y4AAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAgh0LPAfsqf9skRU+mnHtSffsQjtOV6avTfGxHr9TJK9s5jv5X9JhVHjsdn3AQPqmx/Thsn2vSZg37Sb/tvx2JNt+MsUByTelCLeos+3yTibfCTeUpxwsmuV4y3Pa5sdJa5vxNvkdcvlMc21rQjx9k5phEs//z/b2IyW5VJvVBsOSv4pHRy7Sn+XZnGdtH+rRo2LzfvjDsYlzS5fiWjTxg4rJk7Cxznt9a3DIVFqi0wak3TDVmlbVJIyj8obvJd2fCCHHTcpdby0YW9UO2yetOVnkvodqkxURPr3v2KO7fM9bhbXkkT9jSl8puQbx7Q0pi7f2WW+lpS5b+1xUORzoMjx3+z4Ill5RFLQubpTth/ZXLgHnlcp/sOGoyqfc9r+d/uzAOJNqarEW7djzcY78Ua8Nb9W/9QGRYYL8dbdeAsb2m5ec8PaxHYEEEAAAQQQQAABBBDwJBD6y7qe6qcaBBBAAAEEEEAAAQQQQAABBBBAoJcEXH6J2aWMrz67HMulTJr23Cc7f9yhglOkzOscyiUtcnnEDvYLDe+NyPeV5WrsWs61XbOl4CmuhaWcnUzz0QTl24u6tN+lTHu9SdaJN/dfhPc9FsRbeKSeIllc38J9kubkHWu2fS7ni0uZpH1tLs/1zW0cXMer2TbqeRXj7R8FZE8UyqE8O1H4yQ7lOilyacxO/1fyfx5TJii7KudRVnG7VlB3B8E2bXu3PB9oWs/y6blSedhEz3HJu6zDgxMnwXBp3ysE1+qwVSbcHit33R2RdHFM8btl4BfKLM+vxpRLlT2klFOMSHtPkeT9b0D5gkbke9yGv/e4WV1LUvm37Xx023rUqp1kkOfiFCfSoFMkeY8TqTMyTiT/vZI6Xcrct2aTop8DRY7/SccXyJN1ko6a3ND0eJs8XynJ5e/Opt28P7Xfe7N/0z5H0rMdaq9K/EdRuL73dS0XdazmvG6cky59cCnT3I8kz4m37nwOYMco73hziSOXMkniq70s8Ua8NccE8daskc1zV2PXcj5a6Xos13I+2kQdCCCAAAIIIIAAAggg4EnA+y/WemoX1SCAAAIIIIAAAggggAACCCCAAALdEHD5R888P08pSns+KIPxVkmzYgblzyT/Bkn7Ysq5Zr9YCi6JKPxJybs1It9XluuYu4xXkjb9hhRO8gN+n5Py9yY5QFtZl/a7WrRVnWiVeHPjchkvt5omShFv0Vpc36J9kuTmHWu2bS7nC9e3JKPYWVlXY5fxcm1BFePtAcG5UpKdZBu12EknfyvpTVGFOsh7uezzsoj97GQR275Olyr8nZBV3NrJv38l6QMR+E+VvP8j6U8iyvjImiWVXBdRkW3jDyLy47KIk+lCad8rTK/RYYtM/j1NLv528vkzY4rffkAmhK9Q6s6Ycl6yZaLxB6Vdb5XKbCxGLX/2BXmP+2pP73FHlIp8jyu/cPVJmQB9a1SDEuT9hpTN8/1kgqY9UfT0J57FP7HXp7yXMl9Lyty3yTgp+jlQ9Pi3fhskHTMJ2vb4dVm/om1bp6v2WtWc5PcXHr8D+0x5nCHJPtp0mCR7x+HJZCcmHyupT5Jd5DcU1KmSfmFXIpYqxH9E953vbj/pGlVXkrxunJMufXB9n5qkr81libdmjfDnLmMVvvf0nLzjzaX9WceaVSDepsdC0BaX8QraL2wb8RYmM7Gdz9WjfXzmul5nfJ8DPvtAXQgggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggECswHopYe8qG5V+GVuLvwJFas+fx7hMmkV9kT+JjP2C3zcjjmknuj4pSYUpyi6LaMdkv+3jG1McI2jXNzged7INzw2qJME24i383CfeptsQbwlOrraiVb++5X1ts/xc36afw5OvHWW/vlU13uykic2SJsc57LEhZc6R5GuxkzHulBR2vAcl7xRJaZc/lwrCjtG8vVf/Ls0ybu3kmZ/F+Nm4eIWkLJfPS+XNY9X8/N8kz8Zw2oU4aTVO+7dbovEYlolcW5W6VNJuSSYmrf9a8N0lVZbLZqX+PKZdj7d7S/RkdecmfkEmscnxvikp0EOOc68kn+9xs7yWKE/Lh6Se5vM/6vk/ezpm0mrKfC0pc9/sOBf9HChy/J8ufvbzz6hzsqh5c+3gOyxlj/8ogqp8zmkNivJZAPEWfz3hc/WoszZZHvFGvNnX6Lz+HZN4yz/eoq4I3XqNj2oTeQgggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggIB3AblBUeyX2+7zftTwCovUHvvL0bc6+DSkzPLwLjnnfCDiWHslz945Ka/lAjmQyxcb3+y5QVEG7e1Z5+HYxFvwOBNv012It3QnXNS5XYV4i+p/Ftc2O1pc36afx9aaeGt18XFtK1K8nSaNeVRS+3nVvv5zKXOipLSLnbD5T5La659ct38j2r+pfCxl/7s06+vkq2QQJscl7PERKXO2j8EKqOP9EcffJnl2krKPhTiZGmdf1zencdmo1Blblfq6pMCJrs3btyj1/0uyY5X7Yo+7Vd7jSoprZ0Pu3Jv6Pa4c5wMRx9p76O7AyuOS9bXER1NdJmZNXqfsj0gc5uOgCeso87WkzH2zw1z0c6Co8f80sfu5pMlzr5ce7XXCdSl7/Ec52L/JXcb1zVGVdJDXjXOyKJ8FEG/xMdfr8VaUWLOnJvFGvNlr/H0dXKc72YV4yz/eosapW6/xUW0iDwEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEPAusEVqjPsC1APejxpeYdHa80xp6mMORvZugmeEdys25yIpUZcUNBZ2e9Z3JGtv4MtC2tLevj9s3zHl+lccj2vbYX/ZO+1CvE2POeJtugnxxvUt7bUm72ubbS/Xt+nnclWub1WPt7dL/Nvrdlz6gZQ5VlKni538+3FJUcf5k04rD9mvzH+X5hG3a2LGy46l/ZEAO1nY1zJbKvq8pLA4+ZHkHePrYIfqIU4mvH28V4gdmhGlTt8yMaF3fKscNybdL/m+7/QW28b2AjJT45nSjsckRbZX+nWvndjcvr/ruthcJMeohxynLvVn8R43j2uJK0FQuRNk45iksGtC0PY3BFWUw7YyX0vK3LcinwNFjf95cj79NOF5GXSudmvbNxJeD8oc/1EUVfmc0xpskRQXjw9EYXnMI96ix4LP1T0Gm1RFvBFveV3bbOQSb/nGW9TVoluv8VFtIg8BBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBDwLnCz1Bj3paBfez9qeIVFa49t6esk2UlDcU6PShk7kTfp8g7ZYVxSWP2rklboobz9MnZYe5q3/7GHYzVXcafjce2d0nwsxNv0cSbeppsQbxN31OT61vlVJ+9rm20p17fp53JVrm/Em1Lvk3Og+e+VsOffl3Jn2RMm4TJHyn9GUli99u/GyyRlsZT179I84tZO2v6CpLBxm9xu79z8QUl2nNMsL5GdvyVpst72x1sl78Q0B4jYlziJwPGRtUWp525V6nPyGDvx15aR9FFJc30c20cd0vbXSQqbnGsk7/EkbX7UTuRNeszNSr1D9o2yyeo1OY9rSVKOyfInyROXv8+MlGtOv5L1501WkvNjWa8llrGsfSvqOVDU+H+yxIL9e7D5nOu15+ttQCdcyhr/UQxV+ZzTGri81uT5WT/xFn6N4XP1qLO2szzijXjrLHI624t4yy/eokaoW6/xUW0iDwEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEPAusF1qjPty2x7vRw2vsGjtmWzpW+SJnQwQZ2UnfHxY0imS4hb7K+GflRRV53VxlWSUf3FMuybbbCcv+1p+UyqarDfu8VxPByXeWs2Jt1aPyTgk3iZcuL51duHpxrXNtpTrW+v5XJXrG/E2dZ7+mTydvI5HPdo7Mf6lpKOndg19VpOc35L0S0lhde6XPJ93kJXqpi1l+7s0z7idKZpbJYWNX/P2B6XclZKOlJRkOUcKf01Sc13tzz8p+bYtWS7EiWfdG5WaLRNbX79FqXVb5b2hJBOXpOyopBd6boqX6qTtb5Hk0g97t94PSzol7sD27sJi9FmpN9RG6snqNTnPa0kcxWFS4GRJKyWtlrRekn29MR2mh2S/D0myd7c6XdJsSXktZbuWNLuVrW9FOQd6Jf7t335RP9TR6fma934bm4M6wfOyxX9c1y+WAi5j0+ufc1qH7Q593WML5rgQb8Hx1+vxVsRYs2FNvBFvOV7eiDfBDnp99Xl9ixvPbrzGx7WJfAQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQMC7gL3zVNA/0DZv2+f9qOEVFq09zS21/2jtMgnY2tk7+t4g6fclnS/p1ENpkTz+vqS1kqLqsuZ5/iO5HK5leY2sNcdA2HOfd256t+Mx/72lpelWiLeJcSbewuOdeJtuw/Ut2XWnG9c220Kub9W8vhFvrefne2Q17G+Y9u0HpOyXJP2OpHMlnSzpKZJeIOmlkuyEtXskte/XvP6w5Nu/9fJYyvR3ad5xayfefkxS89hFPT8oZbdIsu0clGTvxDlP0nGSniVpvqQ3SPpHSb+UFFfXW6VMXgtxklL6E0oNyOAPSfqMpD1bZXxdkpS9V9LvyeF1yiZkuvtmec8p/XGZBGykP/ZOxjdI+n3Z7/z18h7XphG57tltktZG1SX5++zxMuxQ3teSk6Uv0n11i6TvSPqppHsl7Zdkckh75RgPSLpD0o8lfVvSTklC/fg1SR68LWW6lrSjlKlveZ4DvR7/9m8Bl/dLeZzLaY9hJzF3upQp/uMMXiMFXKx7/XNO6+AS2/viwDLIJ96mx2Cvx1tRY82GL/FGvGVwGQutknjLNt5C4Q9ldOM1Pq5N5COAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAALeBXZJjXFfgLJfes9rKVp72vu9XDbYL/XGmaXJv13qtxMLurm8Xg7u0gd7VzRfyzapKO6Y9q5JdqKFr4V4U4p4C4874i3cJu5cDcuvYrx149pmr5Fc36p5fSPepv+FEHfH3rDrVdLt18uhT55++Ey3lOXv0m7F7WtldPZISjrWnZYflWO9JNOICK6cOAl2Cd26RannSrpc0lckOU/63SqxJOXH5PHajUrNCT1AwTJkButyafe9tv1ZJan/djHJ+j1u3teS58hQmoKm90u7fC9luZYEuZSlb3meA70e//MkEIp6/iZt1wNBQZ1gW1niP67LVfmc0zoU+bMA4q312sPn6nFnbrp84o14SxdByfYm3rKLt7iR6MZrfFybyEcAAQQQQAABBBBAAAFPAjVP9VANAggggAACCCCAAAIIIIAAAgggUAaBPodO9DuU8VWkaO1p79cG2fB8SV9rz/C0/lGp50WS7CS5bi6uY+4yXi79OFYKnetQ8FNSxt7dyNfi0n5XC19taq6HeGvWUMplvFr3CF4j3oJdiLdWFx/x1q1Ysz1xaT/Xt9Yxz2LN1dhlvOLaR7wFC90gm58t6SOS6sFFUm39ruy9RNKrJNm7MOa5lOG63c24/VcZrDMkfV5SFrExGQu3yZMLJC2QZO+SlfdCnCQQ36rUBrll7+2SrpH0UklHOO5+t8zY+j/y6zEnL1bqsmVKPeK4X9eLDUqfD2b4HldcHn+PKya3Z9jZbl5LMuxWoaouw7UkDLQMfeMcCBvd8m+3Yz87RTfLEP8u3c/zfZltTzfPSZf3lq4eLrZJyhBvrVouY9W6R/Bat+LNpf3dijUrRby1xovLeLXuEbxGvAW7EG+tLr7irbXW4DXX60yebQpuKVsRQAABBBBAAAEEEEAgsQATgBOTsQMCCCCAAAIIIIAAAggggAACCJRYwOUfPeV7z8qmPJaitSeoz/fLxpdKmi/py5Ls3TnSLHfLzn8ryU5OuVTSfkndXvL+R3M7KSJu7PdKmWHPMHHHtIfLM/6Duke8Tam4jNdU6fBnxFu4DfE2ZeMj3roVa7YXLu3n+jY13lk9y/P1lHgLH8U9knWZpBdL+qKkfZLSLPZvvx2SLpF0pqStkrq19Pp1u5txa8fsvyT9tqRnSvqEpAOSfCwHpRK5sap6paSzJa2T1M2FOHHXn+leVO2Ri8ENDaV+Sx5PXiLvVZYrdXeC/QtTdIVS9y+W97gyE97be1wx+Vuxeba4XCop6/e43biW2PO8akuvX0uixqvX+5b3OdDr8S+/16DkElWaZV7KnvR6/Lt0P8/3ZbY9eZ+TzQZF/yyAeJsaLZexmiod/qxb8ebSfj53Ch83XzlVub4Rb9m/p3KJybzjrVfb5NJuyiCAAAIIIIAAAggggICDgOubEIeqKIIAAggggAACCCCAAAIIIIAAAgj0vIDLP5zbTg5IyuMLfkVrT9QA75DMl0uyE3dfIWmxJHtnr8MlRS32S4b3SRqV9GlJGyRledcxqT7xYsfbZfH1WZt1jFv+WgrcE1coYT7xlhAso+LEWytsXtfb1qO2rnF9U8rH9a1b1zY7mlzfWmO6W2t5Xt+It/hR/qYU+S1J9m81+2Mu9vmFh9blIXKxfwffLOnfJf2HJN9/k0iVqZZevW53M26bwf9HVv5I0nsknS9pqSSZs6ieK8l+ad1l+ZkUWivJTvbdLOkxSUVbiJOYEZFfHLpollKrZNBXS9Gj2oobmdT6Y0lbZPt/PiCPr87nPXJbM7JbHZz4cYOXSwdb3uOKh/N7XHlj++kH5T2u2OT5Hrcb15KfykislHS0JDvB2b5O2B8RaE52m51oaB9tGm9L1khC6omJiPbH7O01x/4dZ/8WtX9H2EebZhxKdtvkc/toJ63b1Pz8e7Ke5bJDKrfmLXEi685xImU/LWmDpDzjRA4Xu/Rq3/I+B3o9/uUSroYk2Ymzk+eoy6MtY2PWfq5n0+T5G7duz+vJ89s+hqXJcvZ8njynmx+Dntvrz88l+Vh2SCVlPbfzfF9mxyLvc7J5/HvlswDizc/nTt2Mt16JNWtEvBFvzdfJrJ8Tb/7izWWs8n6Nd2kTZRBAAAEEEEAAAQQQQMCTgP3AlAUBBBBAAAEEEEAAAQQQQAABBBBAYELgR/LwLAeMI6RMHl9iL1p7HGhaith/bLaeT5b0pEPpMHm8V9Kdku6S9EtJ9kuDRV7eLo27zqGB75cyf+5QLqrISZL5P5Ki/qH+25L/Ikn2C9M+F+LNp2bndRFvrXZ5XW9bjxq/xvUt3qi5RDevbbYdXN+aR6N7z/O6vhFvnY+x/XfDYyXZCSBPOfR4jDz+WtI9ku4+9PiAPNrJHb20FP263e24dRnLuVLIxsXk3/U2Vo6U9Igke/cym+wP+9hHmTvakwtxEjBs65Q6ZqZMBJasE2R2l30fd6tcLG5dMnFtCNijvJs+Ie/TninvcWXG25NlFurkufD4e9xDNnf9RN7j/mH33uP2wrWkvAEy1bOiX0umWpr8WdH7xjmQfEzZw12g6PHv2pO83pfZ9nT7nOzlzwKIN9eInirXzXjr5VizgsTbVBy5PiPeXKWmlyPeppv42pLna7yvNlMPAggggAACCCCAAAIIOArYX0dlQQABBBBAAAEEEEAAAQQQQAABBBCYEEjyS+15mBWtPUn7bCf2Zn23naRt6qS8/UKCy+I6XlF1XSaZUccbl/w/kGQffS+u7Y9qn+82JamPeEuiNVGWeEtuNrkH8TYp4fbYzVizLeT65jZOWZdyff1wHa+w9hJvYTLx2+2d2+zkXptujy/eUyWKft3udty6DKadCG5TmRfiJGB0Vyr1kGz+s4Csym06NLG3yO9xe+FaUoW4Kfq1JM0YFL1vnANpRpd94wSKHv9x7Z/Mz+t9mT1et89J1/eWriaThnk8Em/JlbsZb70ca1aaeCPekgt0vgfx1rld3J6ur2eu16y445GPAAIIIIAAAggggAACOQrUcjwWh0IAAQQQQAABBBBAAAEEEEAAAQSKLuD6j54zcupI0dqTU7cLd5i8/tH8KOn5W2J6/0HJ/1ZMmU6zibdO5fzuR7y1euZ1vW09anXW8oi3bl/b7GhyfStGTBNvrePA9a3Vo8prRbhOVtm/V/pOnPTKSHWvncRI9+w5cjEEOAeKMQ60ovgCebwvswpFOCf5LKD78ViVeCPWuh9rtgXEW+s48LlTq4fvtbziLUm7i9imJO2nLAIIIIAAAggggAACCEQIMAE4AocsBBBAAAEEEEAAAQQQQAABBBConIDrP47m9Q/nRWtP5QLiUIddx7s/JdCbZf85EXX8UPLeF5GfNot4SyvoZ3/irdXR1aN1L9ZcBVx901zfun1tsxZc31wjIttyxFurr6tH616slVGgCNfJMrqWrU/ESdlG1H9/iBH/ptTYWwKcA701XrS2ewKu70P6UzaxCOcknwWkHEQPu1cl3og1D8HioQrirRXR1aN1L9ZcBVx9076eurbHlitim5K0n7IIIIAAAggggAACCCAQIcAE4AgcshBAAAEEEEAAAQQQQAABBBBAoHICrv8Q6/qFjrSARWtP2v706v6u/2ju+kv/QQ52rC8Lyji0rSGPfyDpQESZtFnEW1pBP/sTb62OeV1vW49anbWs460I1zY7mlzfihHTxFvrOHB9a/Wo6lpRrpNV9e+VfhMnvTJS3WsnMdI9e45cDAHOgWKMA63oDYGs35dZhaKck7YdLgvvzVyUOitTlXgj1jqLD997EW+tolzbWj18r+URb0nbXMQ2Je0D5RFAAAEEEEAAAQQQQCBEgAnAITBsRgABBBBAAAEEEEAAAQQQQACBSgq4/oP4zJx0itaenLpduMPk8Y/mr5ZePy2i59dI3s6IfB9ZxJsPxfR1EG+thnldb1uPWp21rOOtCNc2O5pc34oR08Rb6zhwfWv1qOpaUa6TVfXvlX4TJ70yUt1rJzHSPXuOXAwBzoFijAOt6A2BrN+XWYWinJN8FtD9mKxKvBFr3Y812wLirXUc+Nyp1cP3Wh7xlrTNRWxT0j5QHgEEEEAAAQQQQAABBEIEmAAcAsNmBBBAAAEEEEAAAQQQQAABBBCopIDrL7Xn9Q/nRWtPJYNCOu063q7j1e54mGx4f/vGpvWvy/P3Nq1n9dS1/a4eWbWz7PW6+rqOV7sX8dYuUu31LOOtKLFmR9j1fHH1qHbUdN57V1/X8WpuCfHWrMHzXhEoUtz2ilkV20mcVHHUk/WZGEnmRenyCXAOlG9M6VG2Alm+L7MtL9I56fre0tUk25EpZ+2utq5j1a5UlHhzbb+rR3s/WXcTcPV1Ha/2oxJv7SLVXs863jrRLWKbOukH+yCAAAIIIIAAAggggECAABOAA1DYhAACCCCAAAIIIIAAAggggAAClRVw/Yd/139ETQtZtPak7U+v7u863n0ddvBK2e+0kH0flu32rhljIfk+NxNvPjU7r4t4a7Vz9WjdizVXAVffTq5vRbm2WQuub64RkW054q3V19WjdS/WyiRQpOtkmVzL1hfipGwj6r8/xIh/U2rsLQHOgd4aL1rbfQHX9yGdfA5ge1ekc5LPAog3Plfvfgzk2YKqXN+4tuUZVeHHyjrewo8cnlPENoW3lhwEEEAAAQQQQAABBBBIJMAE4ERcFEYAAQQQQAABBBBAAAEEEEAAgZILDDj2b5ZjubTFitaetP3p1f1dx7uTL8Y9TVDeEwHze5J3R0S+zyzizadm53URb612rh6te7HmKuDqm/T6VqRrm7Xg+uYaEdmWI95afV09WvdirSwCRbtOlsW1bP0gTso2ov77Q4z4N6XG3hLgHOit8aK1xRBwfR+S9HMA27uinZN8FtD9mKtKvBFr3Y812wLirXUcXD1a92LNVcDVt5PXU9c2tJcrYpva28g6AggggAACCCCAAAIIdCjABOAO4dgNAQQQQAABBBBAAAEEEEAAAQRKKeD6y9mu/4iaFqlo7Unbn17d/zDHhruOV3N1V8vK7OYNTc+vkuc3Nq1n/dS1/XnFf9b9LWr9xFvryBBvrR6+17KKtyJd26wZ1zffkdNZfcRbqxvXt1aPqq0V7TpZNf9e6S9x0isj1b12EiPds+fIxRDgHCjGONCK3hLI6n2ZVSjaOclnAd2PzarEG7HW/VizLSDeWseBz51aPXyvZRlvnba1iG3qtC/shwACCCCAAAIIIIAAAm0CTABuA2EVAQQQQAABBBBAAAEEEEAAAQQqK2A/J3H9rCRswqZPvKK1x2ffeq2uwx0bnPSXvJdKvb8VUvcO2f7ekLwsNhNvWah2Vifx1uqWx/W29YjVWssi3op0bbOjyfWtODFNvLWOBde3Vo8qrRXtOlkl+17qK3HSS6PVnbYSI91x56jFEeAcKM5Y0JLeEsjifZkVKNo5WZM22eSy8N7MRamzMlWIN2Kts9jIYi/irVWVa1urh++1rOItTTuL2KY0/WFfBBBAAAEEEEAAAQQQaBJw/aCraReeIoAAAggggAACCCCAAAIIIIAAAqUUmJGgV67/iJqgymlFi9aeaQ2s0AbX8U4yAdjeFeAjIYYPyvbXShoPyc9iM/GWhWpndRJvrW6uHq17seYq4Orren0r2rXNOnB9c42G7MsRb63Grh6te7HW6wJFvE72umkZ20+clHFU/faJGPHrSW29J8A50HtjRouLI+D6PsT1cwDbsyKek3wWUIyYq0K8EWvFiDXbCuKtdSxcPVr3Ys1VwNU3yeup67HDyhWxTWFtZTsCCCCAAAIIIIAAAggkFGACcEIwiiOAAAIIIIAAAggggAACCCCAQGkFBhL07KgEZTstWrT2dNqPMuznOt72y26uy5ul4HMCCj8s214v6c6AvCw3EW9Z6iarm3hr9XL1aN2LNVcBV1/X61vRrm3WgeubazRkX454azV29Wjdi7VeFyjidbLXTcvYfuKkjKPqt0/EiF9Paus9Ac6B3hszWlwcAdf3If0JmlzEc5LPAhIMYIZFqxBvxFqGAZSwauKtFczVo3Uv1lwFXH2TvJ66HjusXBHbFNZWtiOAAAIIIIAAAggggEBCASYAJwSjOAIIIIAAAggggAACCCCAAAIIlFYgyRc1jslBoWjtyaHLrYcYfOfNvzm0escZrVu7sna041GT/Nr/vVJno6ne3fJ8WNIpkjZIynupfLzlDR5xPOKtFSeP623rEau15jveinZts6PJ9a04MU28tY4F17dWj6qsFfE6WRX7XuoncdJLo9WdthIj3XHnqMUR4BwozljQkt4T8P2+zAoU8Zzks4BixGYV4o1YK0as2VYQb61jwedOrR6+17KIt7RtLGKb0vaJ/RFAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAIEWgRNkzTimT7bsmc1K0dqTTS/bal1+xU2nLnvn6JuHVo1+UdKWZatHP9pWJO/VI+SA+yS5xMb6hI17o5T/laS/ltTtL2NUMt4SjlcexYm36edaHtfbPMa2iMfIKt6KdG2z7lzfihF9xBvXt2JEYjFaUbTrZDFUaEW7AHHSLsJ6uwAx0i7CetUEOAeqNuL014dAVu/LbNuKdk7yWYCPiElXR1XijVhLFye+9ibe+NzJVyy51JNlvLkcP6hMEdsU1E62IYAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAqkETpa9XSZ52jIHJS1MdbT4nYvWnvgWd1hi8LKdx8tk39cPrR79nJ30254WX7nFfommW8vH5MCucXFTtxrp4biVibcoq5e+Z5vrL6RHVZMmj3ibfr7lcb1NM2a9vC/xRrzlGb/EG/GWZ7xxLAQQQAABBBBAAAEEEJguUJX3ZbbnfNY5ffzz3lKVeCPW8o6s4OMRb3zuFBwZ2WwtYrwVsU3Z6FMrAggggAACCCCAAAIVFeivaL/pNgIIILOyzrcAAEAASURBVIAAAggggAACCCCAAAIIINAuMLN9Q8T6gOR9UdLLJH09olyarKK1J01fpu27/Irtx5l6Y77S+qXGjJ/+eAE7zTZg6WsMDMrmzwVkZbnpSKn89ZLemuAghyUoW7SipY63KGw7AV33NVYoVV958KDeLWX/KKp8RnnEWzhsHtfb8KOXM4d4Cx9X4i3cptMc4i1cjngLtyEHAQQQQAABBBBAAAEE/AlU7X2ZlavsZ53+wqbjmqoWb8Rax6HiZUfiLZyRz53CbTrNKWK8FbFNnfqyHwIIIIAAAggggAACCEQIMAE4AocsBBBAAAEEEEAAAQQQQAABBBColECSL2pYmCdLulXSryT9UNK9kh6Q9JikfYeSff6IpF2SfiApyVK09iRpe2DZCy7dedTYjMa5yjSGGnVztlJ64jfJA0tPbdRGL5W1z01tSfWsJnu/WNJJko6VNEeS/QfyuYfWj5fHUw4lWzbJUpUJwNYk6/hP4p647AWX/nTmwRn3LdINdYHS4y+UezxLMGp7q+d5S9+5/eTNV8+/I3GlwTsQb8Eupbu+BXcz963EWzA58RbsknYr8RYsSLwFu7AVAQQQQAABBBBAAAEE/AvwvizclPdm4Tad5hBvwXLEWrBL2q3EW7Ag8RbsknZrEeOtiG1K68z+CCCAAAIIIIAAAgggkEKACcAp8NgVAQQQQAABBBBAAAEEEEAAAQRKJZD0H84nO28nQtoUtdjJwfOiCgTkFa09AU2M33Tuqh2zZqvG2aqmhsZMfb5qmL74vdpKGHPa8ituOnXDVef/rC2nk1V7N+ENnezosM8shzJFLVKKeHPBHVo1+vYxfd8FMvl39uPl2+48XTPqQtn+cZe6HMoQb8FIlYm34O5ntpV4C6Yl3oJd0m4l3oIFibdgF7YigAACCCCAAAIIIICAfwHel4Wb8t4s3KbTHOItWI5YC3ZJu5V4CxYk3oJd0m4tYrwVsU1pndkfAQQQQAABBBBAAAEEUggwATgFHrsigAACCCCAAAIIIIAAAggggECpBCYmA2bTpROkWrnDqL3BqPNStPY4N3zx8Jb+gUcGXqi0HjTKLJFez1QNu3uS7rcezpg++4/d/9C6taO1Ezvay22nXr4DcM/Gm9vQTJXSWh9ujInorxkcHjafGB6WKcLpF+It2DDCP3iHBFs7ud4mqL7QRYm34OEh3oJd0m4l3oIFibdgF7YigAACCCCAAAIIIICAfwHel4Wb8t4s3KbTHOItWI5YC3ZJu5V4CxYk3oJd0m4tYrwVsU1pndkfAQQQQAABBBBAAAEEUggwATgFHrsigAACCCCAAAIIIIAAAggggECpBLL8h3MLVaQJwJ20J3KwZcJk7aZHtv9GTSb96t1qmUz8PUKZzif8Tj+Y8TUB+OD0ur1tYQJwOGXS+A+vKWVOTTXW1ZVeGVqNUcfevPvmcyR/R2gZ9wziLdiqaNfb4Fb23lbiLXjMiLdgl7RbibdgQeIt2IWtCCCAAAIIIIAAAggg4F+A92Xhprw3C7fpNId4C5Yj1oJd0m4l3oIFibdgl7RbixhvRWxTWmf2RwABBBBAAAEEEEAAgRQCTABOgceuCCCAAAIIIIAAAggggAACCCBQKoG+DHvzC6k76d1Ei9aeQJ7lV9x0qr077+gj2y+QBh/jd9KvHFKbe2Qe8WhD1b4a2IDkGx9MvovzHlmOmXMjOiyYZds7if8OuxG/2/o1C78ztHr0Prkh9fFhpfv0wArJ8zEBmHgLRq5MvAV3P7OtxFswLfEW7JJ2K/EWLEi8BbuwFQEEEEAAAQQQQAABBPwL8L4s3JT3ZuE2neYQb8FyxFqwS9qtxFuwIPEW7JJ2axHjrYhtSuvM/ggggAACCCCAAAIIIJBCwN55gwUBBBBAAAEEEEAAAQQQQAABBBBAQCn7D+e/I+kUSY82pT1Nzye3j8u2mZLsHV/tY/PzyW320aaapM2SfiopyVK09jzR9sVXbjmhrzEwqI26UCZRPuWJDH9PHtI1vUPV1cjGD8//tr9qH69phvz/IknHSbK/oG3H92FJdmz3SjogaexQqsvj5G2MB+S53dcmO95HSZor6ehDyT63E0bXSerFpbDxlgXm0Oodb1Cm8cawurVWY7P61cVf/uACGx9pFuItWK9S8RZMkMlW4i2YlXgLdkm7lXgLFiTegl3YigACCCCAAAIIIIAAAv4FeF8Wbsp7s3CbTnOIt2A5Yi3YJe1W4i1YkHgLdkm7tYjxVsQ2pXVmfwQQQAABBBBAAAEEEEghwATgFHjsigACCCCAAAIIIIAAAggggAACCFRFYPkV249rGLPATvqVO/KenkG/HzNa3WpUfWTzmvN3ZFA/VSLwhMCKy3fNq9f2f06md4d/PlpT1226esG/P7ETTxBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBDIUaA/x2NxKAQQQAABBBBAAAEEEEAAAQQQQACBHhIYeveuOebgvnO11oONujnbNn3ydrheuqHVQZl9eZvcJHlk7KgDN20dXmLvrMyCQOYC6z989j1Dq0bt3aXPCD2Y0SsljwnAoUBkIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIZCnABOAsdakbAQQQQAABBBBAAAEEEEAAAQQQ6DGBc1ftmHVkzbxIbow6aMYOzNdK9/mc9SsTiBtK6dv7VGNkj+nbdMs15+3rMSKaWxIBie11RpmICcDmGcuvuOnUDVed/7OSdJluIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAII9JAAE4B7aLBoKgIIIIAAAggggAACCCCAAAIIIJCFwOLhLf0Djwy80NTUkDJmcaNhZnq+16/M+TU/VTW9Sfcdtn7TB85+JIt+UCcCSQTG5hy8WeL+cpmUPitsP9OoXSh5HwvLZzsCCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACWQnorCqmXgQQQAABBBBAAAEEEEAAAQQQQACBYgusWDX6nHGtB7Uxy6Wlh/turdHqrprSI7qmvrbhqvn3+66f+hBIKzC0avRKqcNO8g1cjDYPH3PnPa+6/vpX1wMLsBEBBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQACBjAS4A3BGsFSLAAIIIIAAAggggAACCCCAAAIIFFFgaNW205SuDcqdflfKjMZjZPKv32Zqc49UOWpqta9uvnr+HX4rpzYEfAvU1inVCJ0ArI0++uGnPeVcOeqo7yNTHwIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAJRAkwAjtIhDwEEEEAAAQQQQAABBBBAAAEEECiBwOIrt5zQ1xiwd/p9qTJ6nkz+9d2rh7QyO5SpjWy8ZsG3fVdOfQhkJbDpmvNuH1q97Z7Hz4uwg8hkecliAnCYD9sRQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQyEWACcCasVIoAAggggAACCCCAAAIIIIAAAgh0V2D5FduPaxizQBt1oRlXp0+0Rvts1GOqpneauhoZ+fD8W3xWTF0I5CmgVe1rRpk3hR5T65cMvXvXnE0fOPuR0DJkIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIOBZgAnAnkGpDgEEEEAAAQQQQAABBBBAAAEEEOiWgJ2k2Diw/7xaTS1t1M3Zth1e7/Wr9QG50+83lWqMjB1Vv2nr8JLxbvWV4yLgS6BR79uo+8b/QE6W4BnyDdWvx/Ytl+Nd7+uY1IMAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIBAnAATgOOEyEcAAQQQQAABBBBAAAEEEEAAAQQKLHDuqh2zjlDjL1a1/qVm7MD8mlZ9Xmf9al2XacS3G1Ub2WvUyC3XzN9XYA6ahkBigZFrz7lvaPXobbLj45PmgyqQ+F8m25kAHITDNgQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAgUwEmACcCSuVIoAAAggggAACCCCAAAIIIIAAAtkJLB7e0t+3Z8YZypghrRqLjanNUI2G5wOan2jdt8kMzNiw6QNnP+K5cqpDoFACWtXWGdUInQAs59ozll258xkbP3TOTwvVcBqDAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCBQWgEmAJd2aOkYAggggAACCCCAAAIIIIAAAgiUTWD5Fdufa0xj0Dyi5W6k5nDf/TNa3aW02tSn9doNVy2433f91IdAUQX6x548OjZw3165e/bssDaaRn2l5DEBOAyI7QgggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAl4FtNfaqAwBBBBAAAEEEEAAAQQQQAABBBBAwKvA0KptpyldG5Q7kNrJh8d4rdxWptXd8r/RhlZf23z1/Du810+FCPSIwLJV295plH5ZaHO1/vX4UQdftXV4yXhoGTIQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQ8CTAHYA9QVINAggggAACCCCAAAIIIIAAAggg4EtgxeU3z2vU+gaNalyojJ4nk399VT1Zz0NamR01udvv+jULvzO5kUcEqiwwrvS6PqXCJwAbM3fGnhnnidHNVXai7wgggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAvkIMAE4H2eOggACCCCAAAIIIIAAAggggAACCEQKLL9i+3ENYxbIZN+X1o0+bWLSr47cJ1Gm1o8q07jVmNrIyIfn35JoXwojUAGBLdcs+P6y1dvvMsacFNZdybN34mYCcBgQ2xFAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBLwJMAHYGyUVIYAAAggggAACCCCAAAIIIIAAAskEht69a07jwP7zdJ8ebNTNWRN7e530e0Brc5uu65GDcw7evHV4yXiyFlIagWoJyATftdLjt4T12ij94sWXf2vu1g+f8euwMmxHAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAwIcAE4B9KFIHAggggAACCCCAAAIIIIAAAggg4Chw7qodsw439Zfoml7aOLh/fk2rmmoYx70dimldV8rcbpQZ2St3+71lzfx9DntRBAEERKDWpzc1GubNSmb6BoIY09dXe2yF5P1bYD4bEUAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEPAkwARgT5BUgwACCCCAAAIIIIAAAggggAACCIQJLB7e0l97pO9MrWuDWjUWK6VnGJnzGzzDMKyWiO1aGanrJzJ9ccQMzNiw6QNnPxJRmiwEEAgR2HDV/PuXrd72DXun35Aict6a5ZLHBOAwILYjgAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAgh4EWACsBdGKkEAAQQQQAABBBBAAAEEEEAAAQSmCyy/Yvtz5W6iQ+oRNSS5h8tdRT0v5k6l+zbVamadnbjouXKqQ6CSAg2l18mE+tAJwDLd/rTl79zx7A1Xn/ejSgLRaQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAgVwEmACcCzMHQQABBBBAAAEEEEAAAQQQQACBqggsvXL76bVGY1A19IpG3Rzjvd9a3a212mbG1dc2XbvwF97rp0IEKi4wY2z3jrH+ox4ThsPDKBqmsVLymAAcBsR2BBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQACB1AJyMwsWBBBAAAEEEEAAAQQQQAABBBBAAIE0Aisu3zWvUTswaFTjQrk76Lw0dQXuq9WDRukdqta3aeSqc74bWIaNCCDgTWBo9ejlcsful4dWqNXu8aPGLt46vGQ8tAwZCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCKQQ4A7AKfDYFQEEEEAAAQQQQAABBBBAAAEEqiuw/IrtxzUaaqGSSb91s/80mSwoi8ffWtP6Ual7p9Q5smnNAnlkQQCBvARqurZO7vIbPgHYqKP6H+1fIO3ZmlebOA4CCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggEC1BJgAXK3xprcIIIAAAggggAACCCCAAAIIIJBCYOjdu+bUxvefZ4wZatTNmRNVeZ30e0Dqvq3P6JGDcw7ezN1FUwwWuyKQQmDD1ef9aGjVtjtlAv5TQ6tp1FZK3tbQfDIQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQSCHABOAUeOyKAAIIIIAAAggggAACCCCAAALlF7jokhtn75s998WqrzZoDu4/r6FUzfOdfutKm++quh55TOnNt1wzf1/5VekhAsUXMMp8TSv9hxEtPXvFqh3HrL/mvIciypCFAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAQEcCTADuiI2dEEAAAQQQQAABBBBAAAEEEECgzAJnXbJr4NhZ+86s9+mlMht3sTJqhmoY5e1ev1oZqesnSpmR/rH+9WuvO2d3mT3pGwI9KXDYzI1m/9hb5FyVSf8BizF9jVpjheT8S0AumxBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBIJcAE4FR87IwAAggggAACCCCAAAIIIIAAAmUSGFq143lKNwaV2T/UUPpwbTz3TqtfyFzCkVrNrNtw1fz7PddOdQgg4FFg5G9e8uDQqtGvS5XnhFXbMHq55DEBOAyI7QgggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAh0LMAG4Yzp2RAABBBBAAAEEEEAAAQQQQACBMggsvXL76bpuhuRuvCuUaRwtd/v1u2h1t9xB9GZTV2s3XbtAJgCzIIBArwho1VhnVC10ArD8SMApg++8+TdHrl70g17pE+1EAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBDoDQEmAPfGONFKBBBAAAEEEEAAAQQQQAABBBDwKLDsXaNPUXUzaIy6QI2beRNVyzRdX4tWDyqttpvxxsjItYu+66ta6kEAgXwFHnps9o5jjty/xzTUkaFHNn0rJY8JwKFAZCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCHQi4PGbrZ0cnn0QQAABBBBAAAEEEEAAAQQQQACBfASWX7H9uLqpL9JGX6CMPs37UbV+VKnGzlqtf9OGq8691Xv9VIgAAl0RGFy9/R3amP8ddnBdU3se2nPYxbf9/dljYWXYjgACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggEBSAe4AnFSM8ggggAACCCCAAAIIIIAAAggg0DMCiy/fMnegNnCeUmawUTdnalXz23atD8ik311G6ZH6UQe3bR1eMu73ANSGAALdF2isU0qHTgC2dwc+5oi9i6SdI91vKy1AAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBAoiwATgMsykvQDAQQQQAABBBBAAAEEEEAAAQQeF7jokhtn7ztq7otVQw0Zo881xs761f50tK4rY74rdxEeeUzpzbdcs3Cfv8qpCQEEiiYwsmbhT5atGr3DKHVyWNvkMrNS8pgAHAbEdgQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAgcQCTABOTMYOCCCAAAIIIIAAAggggAACCCBQNIGzLtk1cOysfWeafj24z6jzVV3NsG30Nu1XK7nJr/qxUY2RGQdnbFh73Tm7i2ZAexBAIEMBXfuqMo23hR1BfmjgzMH33nrsyN+85MGwMmxHAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAIIkAE4CTaFEWAQQQQAABBBBAAAEEEEAAAQQKJTB42c3P1321pcrsH2oofbjc9dfromvqDmPM5lqttm7DVfPv91o5lSGAQM8I1IwaGVfqj+RHBeSO4tMXu90cHLN3Af7c9Fy2IIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIJBcgAnAyc3YAwEEEEAAAQQQQAABBBBAAAEEuiiwYtWOpzd0Y7ChzApt9NFyb16/i1a/lMl820xdrd14zYJf+K2c2hBAoBcF1l9z3kODq0Z3StvPC2u/Nmq55DEBOAyI7QgggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAokEmACciIvCCCCAAAIIIIAAAggggAACCCDQDYFl7xp9ihk3Q3LslXXTmGcn/Wr5z9ui1YNS16ipNzaPXLvou97qpSIEECiTwDrpTOgEYLkuPW35FdufK3cL/16ZOk1fEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEuiPABODuuHNUBBBAAAEEEEAAAQQQQAABBBCIERi8bOfxqv/gQrnL7wVmTJ1mp/x6XbR+VGtzix43IxuuXXir17qpDAEESidQnzN2S//ugd0y0feosM41Gmal5DEBOAyI7QgggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAs4Cnr8563xcCiKAAAIIIIAAAggggAACCCCAAALTBBZfvmVuv5oxX2kzKJlnTCuQdoPWB5Rq7FI1tWn8iPHRrcNLxtNWyf4IIFAdgaFVo2+X3l4c0ePHjp5z9CuvH37OwYgyZCGAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCAQK8AdgGOJKIAAAggggAACCCCAAAIIIIAAAlkKXHTJjbP3HnH0S7Qyg8boc5UyNa/H07quVeM7cgfhkbGjDm6WSb/7vdZPZQggUBkB3d+/3oyPR00APvyhPQ+fLyAbK4NSjo7aH8q0n5U3JNXL0SV60QMCxF0PDBJNRAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEuinABOBu6nNsBBBAAAEEEEAAAQQQQAABBCoqcNYluwaOPWrszEZjfGif0ou0UTNkgq7852mR2cTy34+V1psGxvo2rr1u/m5PNVMNAghUWGDjh8756eDq0f+Sa9bTwxhqxqyUPCYAhwEl2/6wFO9r2mVMntsfcbBpX9ujvaO7ncBry9vPvQcOJXl9sa8xj6eZ8miTzbPbJss0f07+mGx/5FC6Wx5vlXSLpJ2SHpDEUn4B4q78Y0wPEUAAAQSKIcCPYRRjHGgFAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIBAgQW8fa+2wH2kaQgggAACCCCAAAIIIIAAAgggUACB4WFT2/borc/VZnxQpmgNSpMO990sXVN3yB2ER/oPmnVrr1v0K9/1Ux8CCCAwtHr7xcqYt4dKyA8QDIw1XsM1KFQoSYa9G6/fu8InOXprWSOrX5b0PknfbM1irWQCxF3JBpTuIIAAAggkFuDHMBKTsQMCCCCAAAIIIJBYwP443R817WV/gO4bTes8RSBLAeIvS13qjhMg/uKEyEcAAQQQQAABBBBAAAEE2gSYANwGwioCCCCAAAIIIIAAAggggAACCPgVWPaOm56h+vuWNpRZoY0+2m/tUptWv5RZWdt0Xa3ddO2CX3ivnwoRQACBJoHFl39rbn9t7w0yCbj5zrRNJeSpNp/etGbhZ1s3staBQJEmYjY3/0uy8kZJ9k7BLOUTIO7KN6b0CAEEEEAgmUCRXgv5EZZkY0dpBBBAAAEEEOgdgYulqTc0NfdWeX5O0zpPEchSgPjLUpe64wSIvzgh8hFAAAEEEEAAAQQQQACBNgEmALeBsIoAAggggAACCCCAAAIIIIAAAukFlq7acWJN27v8mpUySW5e+hrbatDqQdkyqkxtZNM1593elssqAgggkKnAstWj7zNGLQw7iNb6ro1r5v9uWD7bnQV+81BJ+zn2UyQ9XdKZkt4kqdPPtsdl38ckzZJk7zTQ6WJfey6Q9MtOK2C/wgoQd4UdGhqGAAIIIJCTQJEmADd3mR9hadbgOQIIIIAAAgj0usCN0oGXtXXiXFnf2baNVQSyECD+slClTlcB4s9VinIIIIAAAggggAACCCCAwCGBTr8kBSACCCCAAAIIIIAAAggggAACCCDQIjB42c7ja31ji4yq2Um/p7VkeljRNbWnYdQtfXWzecO1C+2v4bMggAACXRFYvnrHeQ3T+Kuog5u+/stGrjrnu1FlyOtYwE68/aIkO4k3avlnyfxPSfc3pYflub2TnF1mSjpZ0gskvUjSqw+ty4PT8gMpZSckH3AqTaFeFyDuen0EaT8CCCCAgKsAP4bhKkU5BBBAAAEEEECgM4ETZbc7JPW17f4vsv76tm2sIuBbgPjzLUp9SQSIvyRalEUAAQQQQAABBBBAAAEEDgkwAZhQQAABBBBAAAEEEEAAAQQQQACBjgUWX75lbr+aMV/1mUHVUGd0XFHYjtocULr2DVVvjIzPHR/dOrzE3rmRBQEEEOiqwOLhLf39u2dcLz92MDesIbqm1268ev4Hw/LZnlog6C4B7ZX+tmz4fPvGiHX7efkySddKenZEueasD8nKu5o38LzUAsRdqYeXziGAAAIIxAjwYxgxQGQjgAACCCCAAAKOAn8h5YYDyo7JNvtjdfcE5LEJAV8CxJ8vSerpRID460SNfRBAAAEEEEAAAQQQQKDyAkwArnwIAIAAAggggAACCCCAAAIIIIBAMoGLLrlx9oHZx5xT1zLpV6lz5MOFWrIaYkprXdeq8R2t9aaDR45tkUm/+2P2IBsBBBDIXWBw1ba3aaVfFXpgrfYOjB3/yrXXPYO7w4Yipcr4a9n7vTE1XCT5X4kpE5Rt7wz8GUmvDcps21aX9adK4ouZbTAlXSXuSjqwdAsBBBBAwFmAH8NwpqIgAggggAACCCAQKGDv+vtzSScF5ir1ftn+5yF5bEYgrQDxl1aQ/dMIEH9p9NgXAQQQQAABBBBAAAEEKi3QX+ne03kEEEAAAQQQQAABBBBAAAEEEHASOOuSXQNHH7H/LLnb5dA+rRfK4wyvvyqmlZGG/EgpPTIw1rdx7XXzdzs1jEIIIIBAlwRMf229HjfhE4CNmj0241eLpXnru9TEsh/WZcLtng4R7KTtt0g6S9IzYuqwX1p6tSR712CW8gsQd+UfY3qIAAIIIBAtcLtkvyy6iEr6ft5+HrBB0gslfUaSy4+wrJZy10hyeW2WYiwIIIAAAggggEBhBOzfUmGTf20jL5H0l5IO2hUWBDwLEH+eQakukQDxl4iLwggggAACCCCAAAIIIIDAlAATgKcseIYAAggggAACCCCAAAIIIIAAAk0Cw8Omtu3RW5+rGvUhbfYvlSm6h8sEXfX4VN2mcmmeSm13KLnTb/9Yff3a6xb9Kk1d7IsAAgjkKbD5Q/P/e2jVtp/IdfGZocc1jZWSxwTgUKBUGS6vGftSHOFR2fd1km6RNBBTzysknwnAMUglySbuSjKQdAMBBBBAoGMBlwm3/AhLx7zsiAACCCCAAAIVELg0po/HS779QZTPxpQjG4FOBIi/TtTYx5cA8edLknoQQAABBBBAAAEEEECgcgJMAK7ckNNhBBBAAAEEEEAAAQQQQAABBKIFll258xmqMT64bffocm300dGlO8jV6pdKm5trprF2w5rz7+ygBnZBAAEECiEgP2KwTm5XFj4BWKkXDF628/iRa8+5rxANLlcjHnPozn6HMlFFbpPMj0h6Z1QhyTs1Jp/s8ggQd+UZS3qCAAIIINCZAD+G0ZkbeyGAAAIIIIAAAlbgNyQNOlC8XcowAdgBiiKJBIi/RFwU9ixA/HkGpToEEEAAAQQQQAABBBColgATgKs13vQWAQQQQAABBBBAAAEEEEAAgUCBxZduOal/YOZSub3vSjM+Ps8W0vZuv54WXdMPGGO212p604ar5n/PU7VUgwACCHRVwMyYtVmN73+baqjgz1mN0rW++gXSyM90taHlPPheh26luQPwZPU75EncBGD7umlfNGU+OEvJBYi7kg8w3UMAAQQQiBXgxzBiiSiAAAIIIIAAAgiECtiJvS7Li6TQeZLs51IsCPgSIP58SVJPJwLEXydq7IMAAggggAACCCCAAAIIHBII/mIaPAgggAACCCCAAAIIIIAAAgggUHoBe1fKWl9jkZFJv8qY05RpeO2zrqk9DaNuMaYxsvnqRV/3WjmVIYAAAgUQ2PSBsx8ZWr1tu8z9PD+sOUY1lkveZ8Ly2d6xgMtEzLGOa5/a8fapp6HPZkjOTElp7zgcegAyCiNA3BVmKGgIAggggECXBFxeC/kRli4NDodFAAEEEEAAgUILzJHWvSFBC98hZZkAnACMopECxF8kD5kZCxB/GQNTPQIIIIAAAggggAACCJRfgAnA5R9jeogAAggggAACCCCAAAIIIIDAEwKLL98yt6/Wv0Du7juozPgLje97FWpzQOr+ummYzWNHjo9uHV4y/sTBeYIAAgiUUkCvk26FTgBWRs8bWn3TGZvWnP+tUna/e51ymdzr4zXov6WLdqLL7Iiu3it5TP6NACpRFnFXosGkKwgggAACHQm4TAB2eb2MOzg/whInRD4CCCCAAAII9JrAm6TBRyRo9Cul7ImSfplgH4oiECZA/IXJsD0PAeIvD2WOgQACCCCAAAIIIIAAAqUWYAJwqYeXziGAAAIIIIAAAggggAACCCCg1EWX3Dj7wOxjzjF9ZrDRUOdoo2peXbSuG62+bepmpDFnfItM+mUSlFdgKkMAgSILHH3n3d946KnzHtZGHx3WTqP6VkoeE4DDgDrb7nLbeh8TgO1x7pF0ekQzXSaoROxOVg8JEHc9NFg0FQEEEEAgEwGXyb0+/gbjR1gyGT4qRQABBBBAAIEuCfTJcS9NeOwBKf9WSX+acD+KI9AuQPy1i7CepwDxl6c2x0IAAQQQQAABBBBAAIHSCjABuLRDS8cQQAABBBBAAAEEEEAAAQSqLHDWJbsG5s4+cLbWjcF9Wi9UxsxQMmVF+0LRyt47+EdS4aaBg32b1l53zm5fVVMPAggg0EsC11//6vqy1aPr5aL42rB214xauHh4yzX8QEKYUEfb6w57uUxQcahGzYkpxATgGKASZRN3JRpMuoIAAggg0JEAP4bRERs7IYAAAggggEDFBV4h/T+lzeCDsv47kp7Str159S2y8n5JB5o38hyBhALEX0IwinsVIP68clIZAggggAACCCCAAAIIVFWACcBVHXn6jQACCCCAAAIIIIAAAgggUDqB4WFTu2X36PMaRg0ZvX+pTNGd/fiUXztV19Mid/r9eU3pkf6x+vq11y36ladqqQYBBBDoaQFdq28w9b7QCcByGZ41Y8/AEunk2p7uaLEa7zL5xKVMXK/ktVQdE1OICcAxQCXKdokplzJxJMRdnBD5CCCAAALdEuDHMLolz3ERQAABBBBAoJcFLm9rvP2b6qOS9koalhS2HCcZr5P0mbACbEfAQYD4c0CiSGYCxF9mtFSMAAIIIIAAAggggAACVRLwduOfKqHRVwQQQAABBBBAAAEEEEAAAQSKJLDsyp3PMPX6kFGNZdroo323TWt9l0xeu7mmxtdtWHP+nb7rpz4EEECgDAJDq0Y/Lv14dlhf5Fr63Y1r5l8Wls/2xALPkT2+F7OXfU38dUyZuOyLpMCXIwo9JHnPkvRARBmyyiNA3JVnLOkJAggggEBnAs+T3b4bs6v98ZSHY8rEZdsfw9gjqRZR8I2S95mIfLIQQAABBBBAAIEiCJwtjfhGW0O+JOuvlDRP0h2SBiSFLbdJhq2DBYFOBIi/TtTYx5cA8edLknoQQAABBBBAAAEEEECg8gLcAbjyIQAAAggggAACCCCAAAIIIIBALwpc8K6dJx2sjw/KhN8VZnzcfklEafnP16JrWiYyNUZrDb1p/Zr53/dVL/UggAAC5RVorJP5CaETgI0yz1tx+c3z1n940T3lNShcz+T3K1IvL4+p4T2Sz+TfGKSKZRN3FRtwuosAAghUTMDlTvc+XgsHxTVq8q/9EZavVMye7iKAAAIIIIBAbwqsCmj2xw5ts58T2snArw4oM7npLHmyQNLo5AYeEUggQPwlwKKodwHizzspFSKAAAIIIIAAAggggEBVBZgAXNWRp98IIIAAAggggAACCCCAAAI9J7D4yi0n9JuBRaqhV4yNjZ82Md3Xx/dqJyh0Te1pGHWL0nrTpqvnt/8ifc950WAEEEAgT4HZA7XN+8bVHxsTcscOo3S9pi+QNn0qz3ZV/FhpXySfLn6/G2G4U/L+ISKfrGoKEHfVHHd6jQACCCAwJZD2tdDWxI+wTHnyDAEEEEAAAQR6V+BEafqr2pr/Q1kfadpmJwNHTQC2Rd8hiQnAVoIliQDxl0SLsr4FiD/fotSHAAIIIIAAAggggAAClRZgAnClh5/OI4AAAggggAACCCCAAAIIFF1g8eXfmttX27dAq8agGlcvnGivj+/SHuq5Nge07rtVNcY3jx1Z3751eMl40U1oHwIIIFBEgS9/cMGeZatG7RfxloS1T2u1TPKYABwG5H97mhdMe8e5ayXNCGnWmGx/m6Q0xwipms09LpAmJoi7Hh98mo8AAggg8LhAmtdCWwE/wkIgIYAAAggggEBZBN4uHRlo68zfta3fLOu3S3pe2/bm1f8tKydJuqt5I88RiBEg/mKAyM5UgPjLlJfKEUAAAQQQQAABBBBAoGoCTACu2ojTXwQQQAABBBBAAAEEEEAAgcILXDS8a/b+3XvPVao22DCPvUQbZSeD+FtqMpXYqG83GmpzY874lq3DC/f7q5yaEEAAgeoK1FVjXU3VQicAm4Y+Yfk7t5214eqFt1VXqSd6rqWV/1fShSGtta+b9u4t3wrJZzMCnQgQd52osQ8CCCCAQBEF0kwA5scwijiitAkBBBBAAAEEOhGYLTtd0rbjo7L+2bZtdtXeBdh+FhW22O942h+i+5OwAmxHoE2A+GsDYTVXAeIvV24OhgACCCCAAAIIIIAAAlUQYAJwFUaZPiKAAAIIIIAAAggggAACCBRe4KxLdg3MnX3gbN2nBvft3r9Qmdrjdxy0M0G8LFqm/Gr9Q7lR4cjAwf5Na687Z7eXeqkEAQQQQOAJgUVzFu4a3b39QbniHvvExrYnDaNWyiYmALe5FGj1RGnLdZLsnVWCll/Ixt+WNBqUyTYEOhQg7jqEYzcEEEAAgVIJ8GMYpRpOOoMAAggggEDlBX5PBI5pU/gnWQ/6t5nPyfYPSJrTVr559c2y8j5J/KBrswrPwwSIvzAZtuchQPzlocwxEEAAAQQQQAABBBBAoFIC3r5HXCk1OosAAggggAACCCCAAAIIIICAB4HhYVPb/usdz1e6MWi0XioTxuwvIvtdavpnRib9zjjY2LD2ukW/8ls5tSGAAAIItAsMrd7+FmXM69u3P7GuzYFZj/76lTf+/UV7n9jGk04EniM7fS9mx6Mkf09MmcnsZ8oTO7F3laQjJzc2Pdo72X1K0mpJQV/UbCrK0xILEHclHly6hgACCCDgJOD7tXDyoPwYxqQEjwgggAACCCBQBgH7nUz5QVb1rLbOPFfWv9+2bXL1WnnyjsmVkMc3yXb7+RQLAlECxF+UDnlZCxB/WQtTPwIIIIAAAggggAACCFRSgDsAV3LY6TQCCCCAAAIIIIAAAggggEA3BQZXb3umTPYd2r57+5DR6mil5N9C7bQiT4vW+i6p7uaaGl+34erz7/RULdUggAACCDgINLTaUDMqfAKw0TP3HjF3qVT1FYfqKJJOwE4APijpwKFq7OfhRxxKT5NH+6VLO4lloaQzJAUtDdl4vaT3Swr7gmbQfmyrrgBxV92xp+cIIIAAAskF+BGW5GbsgQACCCCAAALFF7hQmtg++fcm2Rb12dLfSf6lkuzkubDl7ZLBBOAwHbZPChB/kxI8dkOA+OuGOsdEAAEEEEAAAQQQQACB0gswAbj0Q0wHEUAAAQQQQAABBBBAAAEEiiBwwbt2njQ+Xh+SibnL5c6Q82ybjM9JvzX9QMOobf3GjKxfMz/qSyRF4KANCCCAQGkFNl89/45lq0e/L9d4O7E0bFkpGUwADtPxt/2uQ1XZV9xxSQMJqr5fyn5e0t9LsndsYUHAVYC4c5WiHAIIIIBAWQX4MYyyjiz9QgABBBBAAAFXgVUBBT8WsK15049lZUTSUPPGtuf2B+wWSbq5bTurCDQLEH/NGjzPW4D4y1uc4yGAAAIIIIAAAggggEAlBJgAXIlhppMIIIAAAggggAACCCCAAALdEFh85ZYT+s3AImX0yrGx8VN9t0HX1B6Z0bRDN9SmjVfP3+W7fupDAAEEEOhMoKFq67RqhE4A1kY/Z+mqHSduvua8X3Z2BPZKKGDvnJJk8q+t/jZJfZLsHQvsD3dskzQmiQUBVwHizlWKcggggAACZRPgxzDKNqL0BwEEEEAAAQSSCDxPCg+27XC3rH+pbVvQqp0kHDUB2O7zDklMALYSLEECxF+QCtvyEiD+8pLmOAgggAACCCCAAAIIIFA5ASYAV27I6TACCCCAAAIIIIAAAggggECWAosv/9bcGfrRhXVVG9Tj5gUTx/J5q19zQOu+W7UyIwePPLhj6/ASe0dDFgQQQACBAgnU9x/Y2n/YwKXKqBlhzeqrNS6QvH8Iy2d71wXs+DQvu2VlvSR75+avSXpAEgsCvgWIO9+i1IcAAggg0E0Bfgyjm/ocGwEEEEAAAQS6JRB098tPSGNc/i3nRin3C0lPi2j8yyXvqZLujChDVnUFiL/qjn0Rek78FWEUaAMCCCCAAAIIIIAAAgiUUsD+oxsLAggggAACCCCAAAIIIIAAAgikELhoeNfs/bsPnqtUY7Bh1EvkzXYtRXXTd63JF0OM+rYxZqQ+Z3yrTPrdP70QWxBAAAEEiiQwtGrbnyql2+/2MdXEmrp/09ULXjO1gWcJBewdlr8Xs8/9kr9Xkr1zr011SfZOwDMlzZb0JEl9kpIuB2WHD0r6K0m8JifV6+3yxF1vjx+tRwABBBBIL+DyWpj+KFM18CMsUxY8QwABBBBAAIHiCxwnTbQTeO1nT5OL/UzqZEn3TG6IeXyv5P91TJkPSP57YsqQXT0B4q96Y16kHhN/RRoN2oIAAggggAACCCCAAAKlE2ACcOmGlA4hgAACCCCAAAIIIIAAAgjkIXDWJbsG5hzx2Iu06huUN9cLou7y2FF75Ba/Uu8PlEz6nTWgN335gwv2dFQPOyGAAAIIdEVg2arRs+X+7x+KOrip6XeNXD3/G1FlyAsVcJl8cpTsHfX6aX+ww04CPlXS8yW9WNJFko6X5LL8lxR6q6RNLoUpUwoB4q4Uw0gnEEAAAQRSCLi8FvIjLCmA2RUBBBBAAAEEelpgWFr/F209+DdZf23btqjVoEl07eUflA32LsD72jNYr7TAsPSe+Kt0CHS188RfV/k5OAIIIIAAAggggAACCJRdgAnAZR9h+ocAAggggAACCCCAAAIIIOBNYHjY1EZ33/wCrfuXyt14l8qkX3v3QL9LTf/MKDMy42Bjw9rrFv3Kb+XUhgACCCCQp8CyVduuN0rbCaaBi/zSw+aRNQveH5jJxjgBl8kncROAg45hJwW/WtLVkp4SVCBg22Wy7SMB29lUPgHirnxjSo8QQAABBJIJ+Hgt5EdYkplTGgEEEEAAAQR6Q8De9dfe/ddO4G1eFsnKtuYNDs//Scr8Tky5t0j+P8SUIbs6AsRfdca6iD0l/oo4KrQJAQQQQAABBBBAAAEESiXABOBSDSedQQABBBBAAAEEEEAAAQQQyEJgyWWjz6rVzGBN6yFj1NG+j6G1vktpc5M29fUb1px/p+/6qQ8BBBBAoDsCg6tG3yQfwIZ/WU/rA7OOmvnKG4fP3tudFvb0UX1MPokCOFIy7eRsO7k3bmlIgddIuiGuIPk9L0Dc9fwQ0gEEEEAAgZQCWb0W8iMsKQeG3RFAAAEEEECg6wJ/IC34ZFsrvivrL2jb5rJ6jhS6JabgdyT/hTFlyK6OAPFXnbEuYk+JvyKOCm1CAAEEEEAAAQQQQACBUgn0l6o3dAYBBBBAAAEEEEAAAQQQQAABTwLLV9/01IapDemaWm4a6gSltJLJv94WXdMPNIza1jBmZMua+d/3VjEVIYAAAggURmDGQP/6sbHx8AnAxszcv3v/kDT4y4VpNA2ZFNgjTy6X9LCkYUlRi52w8ilJN0n6VVRB8hCIESDuYoDIRgABBBAorYD9QZV/lfRVSa4/wnKNlL1bEj/CIggsCCCAAAIIINB1Afs5Uvvyd+0bHNd3SrlvSjozorydWLxY0lZJLAgQf8RANwWIv27qc2wEEEAAAQQQQAABBBCohAB3AK7EMNNJBBBAAAEEEEAAAQQQQAABF4HFV245oa8+cL7ckXeFaphTXfZJUkYmE+9RRm+XmcQjG69ZsCvJvpRFAAEEEOhNgaHVox9RRj0vtPVa/XDTmgVvC80nI0wgq7vPBR3vc7Lx9UEZbds+IuuXtW1jtVwCxF25xpPeIIAAAggkF8jrtfAvpGnDDs2zP55xuiR+hMUBiyIIIIAAAgggkJmA/YG/jW21PyLrJ0p6rG2762rQHTXb9/2SbHhl+0bWKydA/FVuyAvVYeKvUMNBYxBAAAEEEEAAAQQQQKCsAkwALuvI0i8EEEAAAQQQQAABBBBAAAEngcWXf2vuDP3oQqPVkDH6+U47JSmkzQGj9a2qoTbV54zdsnV4yXiS3SmLAAIIINDbAstWj14od5C/MqoXNV1/w4Y1598ZVYa8aQJ5TT6xB54p6SeSnmZXIpaDkvdkSbsjypDV2wLEXW+PH61HAAEEEEgvkOdrIT/Ckn68qAEBBBBAAAEE8hH4qhzmwrZDpf2huFlS312Sjmmrt3m1Liv2x1DuaN7I88oJEH+VG/JCdZj4K9Rw0BgEEEAAAQQQQAABBBAoq0CtrB2jXwgggAACCCCAAAIIIIAAAgiECVw0vGv20KptQ0OrRv+mTz/2xYbSq71O/q2p8f/H3p3AyVGWiR9/3+qZJAQIAY8QUDKsoiAqoig5ySQzucBrV8N6rcIqixeSTALiBYOLIllyYFRYL4K7XrCe658kZCaZJDMJAoqIuggeEw4VOUISIMd01/t/nmQaik5VX1Pd0139ez8+dNX7vvVW1bfLSU9PPW8Za+4wnveF9Jj0W7uXTr2se/nUzST/Rr0j1COAAALJFRg1ZlSPsXZvvjPMmFTuDYL5utNWfQF9/75exG5HSJ+2IvrRBYFiBLjuilGiDwIIIIBAkgX0qXf3F3GCH5Q+Y4roRxcEEEAAAQQQQKASAi+XQeflDOxk/Ss5daWu7pYNri+wUUraP1KgD83JFuD6S/b7W+tnx/VX6+8Qx4cAAggggAACCCCAAAKJEeAJwIl5KzkRBBBAAAEEEEAAAQQQQACBfALzO387YsfOHac557fL036nGGc0SSe+Yo084NH9znOm+5Bm2/XTJVN3xTc4IyGAAAII1LNAW0fvJ6wzs6POQf4JeXTd8mnzo9qpDxWo5tPn9ACOkdCnqTTpSp7yn9KmSSiUZApw3SXzfeWsEEAAAQSKF6j2v4WfkUP7bBGH90/S50dF9KMLAggggAACCCAQt8C1MmDud0HrpC7yu8ASDkCf7nuvRL6HvDwu7S+WeFqC0ngCXH+N957X0hlz/dXSu8GxIIAAAggggAACCCCAQKIFCt2slOiT5+QQQAABBBBAAAEEEEAAAQSSLdDZ6bzenZtOMSbVtn3n9hmS9Dt6/xnr3OtxFWv/JKm/3Wk76paepac9GtewjIMAAgggkBwBa7w1xviRN/05Y58/e/HW02+5etLPk3PWiTuTv8gZ6c2buU90yT3RE3IrWEdgCAJcd0PAY1MEEEAAgUQIfEPO4lKJQvc1zJE+JAAn4i3nJBBAAAEEEKgrgaPkaN8bcsQ/kLpxIfWlVj0pG/xK4rV5NtRjeI/EV/P0oSmZAlx/yXxf6+WsuP7q5Z3iOBFAAAEEEEAAAQQQQCARAoX+UJaIk+QkEEAAAQQQQAABBBBAAAEEGktg9qItJ2aMm9m3s6/duNSRcZ+9PEH4Qc+ajU2ppjWrl0x8MO7xGQ8BBBBAIFkCXcsm39ne0fuwTEQReeOf7/tz5axJAK7tt/73cniFEoBfUNunwNHVoQDXXR2+aRwyAggggEBsAkyGERslAyGAAAIIIIBABQTOlzEPTDz73MGvk1WNapWPyo5IAK6Wdu3sh+uvdt6LRjwSrr9GfNc5ZwQQQAABBBBAAAEEEBg2ARKAh42eHSOAAAIIIIAAAggggAACCMQp0H5h73HGc23WM7MliepoK4PH+qBf4x51nrfJmUx399IzfhfnsTMWAggggEADCDi31hgb9kSQwZN3k1s/vOGwnq/M0Cd7UGpT4KEiDuv5RfShCwKlCHDdlaJFXwQQQACBJAowGUYS31XOCQEEEEAAgfoXaJZT+EiNnMar5DhmSqyvkePhMCovwPVXeWP2EC3A9RdtQwsCCCCAAAIIIIAAAgggUBEBEoArwsqgCCCAAAIIIIAAAggggAAC1RCYs2DT+LQ1062Xmm18d7wkVhnnx7hna3Zaa/tk7PXrlk+7I8aRGQoBBBBAoMEEfJO6xTN+dAKwMyNSh4xsF5YfNxhNPZ3ug0UcrM5Bkq98SBpbJbzBkBeTkdBPMPpabgS312PQ7/41DpM4cvD13fJKqT+BoVx34+V0T8qJE2X9KIm3SsjEBEMuKRnhKonDQ0b6H6lbF1JPFQIIIIAAAqUIMBlGKVr0RQABBBBAAIFqCZwtOzq2WjsrYj8fkz7ri+hHl2QIcP0l432s17Pg+qvXd47jRgABBBBAAAEEEEAAgboV0BuAKAgggAACCCCAAAIIIIAAAgjUjUDrgjvHNntPnSHJvm0Z5169P8vGj/FZv9btFYxbnbPdmTEDW3s6Z6TrBocDRQABBBCoWYH1yyc/1Law7y6ZquKUqIP0nD9X2kgAjgIa/vpdRRzCzgJ9XiPteoPUcBQSgIdDfej7LOe6u052+w6JI/LsXn/WvFliqAm6l8gYiyL2c18M40cMTTUCCCCAQAMJlDsZhj6V6pUSr5M4bfD11fL6SwlNkLldIu7yIhnwMzmD3ivrS3PqWEUAAQQQQACB+hdYEHIK+rllR0h9HFUyCa4ZnWegN0pbi0S/BCX5Alx/yX+Pa/kMuf5q+d3h2BBAAAEEEEAAAQQQQCCRAiQAJ/Jt5aQQQAABBBBAAAFyju/0AABAAElEQVQEEEAAgWQJvKnzjtG7d+yeLA/4bXfuqdc7p0/NizHp1zOa5Hun9W3XwJiBTZL0uydZgpwNAggggEBtCPhrZAKLyARg+fft5TMX9U1Yv3TKtto43po+Cn2CbrXL2CJ2+LcCfZ4s0F6p5scqNXCDjVsv193L5H3Jl/yrb9soiZ9InC5xt0Q5RX+eXRay4R+k7lcSPwhpowoBBBBAAIFSBcqZDEOffjdFYkTIziZK3c8lNAn4SyHtQ6m6SjZ+V84A/0/WSQDOQWEVAQQQQACBOheYJsevE4wES0ZW9PPH/cHKGJc/J2N9Ms94KWn7qMTiPH0KNY2XDiflxImyfpTEWyXWSgy16HHqZ6bDQwb6H6kb6kRlIcMmripp1x8T99TXJZq06y+o/yFZaZXQ74Cz3wPrz3ZfQl/LjeD2Ore53revcZjEkYOv75ZXCgIIIIAAAggggAACCCAQKUACcCQNDQgggAACCCCAAAIIIIAAAsMpML/ztyOeeOKx1xvrte3ZuWeqJEw1a86v/lUsliKPYHTG/c7YVNehKb/7p0umFnNDaSy7ZhAEEEAAgcYUGP3UE5t2HzZ2gXF2ZJSA58yZ0nZtVDv1zwjozYKFSmwfGwZ39PxCO5T22wr0eSqnfZ+s642hD0joE2L0CcL6mSQbT8vygIROVqKvepOR3nyk5683x2kSp8anJaKeArNX2t4iQRm6QL1cdzfKqW6QGCMxT+JkibByiFR+S+INEnp9lVI0oUq31eswW/R61f1tylbwigACCCCQOAH9HFLtUs4kLK+WgwxL/s0eu35OvEbiHomubOUQXyfL9u/MGUMnYdFEYwoCCCCAAAIIJEsgLMn2p3KK91fwNL8hY39CIt/3Xf8q7ZdK6O/npZTrpPM7JPJNJvZjaX+zxDqJoZRLZONFEQPcJ/VDHT9i6ERVJ+n6Y+Ke+rs0k3T95eq/RirOzq2s0vq7q7QfdoMAAggggAACCCCAAAJ1KkACcJ2+cRw2AggggAACCCCAAAIIIJBEgc5O5/Xu3HqKcX779p3bWyX590AiS4wP+zXW/UkSr7rTdtQtPUtPezSJjpwTAggggEBtCvzvV9/09KyOvg0yAcXc6CN0bfLv4X92dlqdFZ4SLVBMImbcCSqviD6cZ1p+/sxS+IIm/GbLV2RBb5jana0o83WibPfZiG31U9T7JPoi2qkuTaBerju9cTdb9ObgyyWinhKkN7Z9XOIKiVJKp3TW5Kps0WvtXRKbshW8IoAAAggkUqCYfwvzJaWUg/L8Ija6LafP12X9WInXS7w8py27qp8V/1vilRJD/X5Iz3mFRPDcB2T9nyT+JEFBAAEEEEAAgeQI6GeLN4WczpdC6uKs0s8UOnHJrDyD6pMk3ysR/F4gT/dnml4mS/mSf7WjTkD3E4nTJe6WKKecIhtdFrLhH6TuVxI/CGmj6rkCSbv+mLjnue9vra8l7frL9X4yt6JK6zpxFAUBBBBAAAEEEEAAAQQQyCtAAnBeHhoRQAABBBBAAAEEEEAAAQSqITB70ZYTncu09e3sa5On/OoNCkaf9htXcdY8KOP1jGhuWrt6ycQH4xqXcRBAAAEEEChVwDP+moyx0QnAzjxv085NmtC5pdSxG6x/MckncScA57vBUvnTEr0F3ofgJ5wvS9+hJv+OlTG+KxH1Xf+npO37EpR4BOrxutPrUq8DnVTg0xEM2v5tiT9HtOdW68+oi3MqdWy9EZiCAAIIIJBsgeH4t7CcSVguCbwN75Plr0qEPRF4nNRfKzFfYihFE2002ThY9BiYGCMowjICCCCAAALJENCn1wYn/dCz+p3Eel2ocPmajF/o+6mPSp/rSjyOG6X/BokxEvMkTpYIK4dI5bck3iAxENYhT51+FtNtmwN9npZl3R+fmQIoBRaTdv19Xc73WAkm7inwxtdIc9Kuv1zWp3IqdDLP+yUekNghsVNiVyD0Z5j+LNTvX/U1I+FJ6O/N+rNOJ07Q0O9NR0uElb1S+ZawBuoQQAABBBBAAAEEEEAAgaBA1E1BwT4sI4AAAggggAACCCCAAAIIIBC7wMxFfRM8a2Za58/2ff/og++XGNourXGPOs9tMpnmru7lk/5vaKOxNQIIIIAAAvEIrF027a5Zizb/zflW/u0LLynbPEdaSAAO58nWVjv55CWy4+OzO494/aHU/y2iLVudvclRE4H/mK0cwuvXZNuWiO01MfjKiDaqyxOo1+tOz/YzEidKvF1XcoreiLZS4o059WGrerPvDRJBC732Px/WmToEEEAAgcQJBH/+R52c3vAcZymU5KI3W+ebhEX/3XpY4n8lwu6P0H8b/1HiRxLllMNko9zPXDopxrJyBmMbBBBAAAEEEKhpgRfK0f1LyBF+OaSuElX6GeMRiRfkGVyTd9sluvL0yW0KJgx/Qhovl/hkbqfB9dfI68clrohoj6rulIZXBxr1u7F3SZD8G0ApsJjE6++SwDkzcU8AowYXk3j95TJrwm+2fEUWFkvszlaU+TpRtvtsxLb6c1Cv+76IdqoRQAABBBBAAAEEEEAAgWcEwv7A9UwjCwgggAACCCCAAAIIIIAAAgjEKTBnwabxrik13XdmtvHd8Tq2O2ii9CHs0Zqd1to+a/zuW5ZO+8UQRmJTBBBAAAEEKibgXGq1PIzz3KgdOD8z+c0X9x7+0yVTdTZ5SrhAMd9tx5l88rHww3hO7YrnrIWvHDpY/bi86uz+Qykfko3Dkjl1TP0c9H5doMQqUK/XXRZBr4lTJE7IVgRez5JlfdqE3kycr3xBGl8W6HCPLJ8TWGcRAQQQQCDZAtVOAH6JcO7//igP6w+lrdAkLGukzyKJayLG0YkwuiX0iU6lFk2OGR/Y6EFZjvysH+jHIgIIIIAAAgjUn4A+XVcn0QoW/fzwrWBFBZc1Oe0GCU1Ky1f0e6xSEoCDY+nkKp+S8CU+HWwILGv7tyX+HKjLt6gJcBfndNCxC30HkbNJw68m/frTa5uJe2r3Mk/69afympCbLTqxw1CTf8fKGDpJZ9R3yvqz9PsSFAQQQAABBBBAAAEEEECgoECcN0AV3BkdEEAAAQQQQAABBBBAAAEEGk/grEs2H9m+cNNbZnX0XZOx3nf8jDs/m/wbi4Z1e4y1PfIXuUvTYwbetm7plCUk/8YiyyAIIIAAAhUSSPnpdTL/RfBmkpw92aanM6bQk85ytmm41dybLcMARoZVllF3rGxzfoHt9KbKrQX6aHM2AfjvRfTN10WftrI8osMTUq+JwUO9QSli+IaurtfrLvum6U3J75HIZCtyXvWayneOM6T9gsA2T8ny2ySYrCCAwiICCCCQcIGoG5eDpx3nPQhxTcKix/dFiVW6EFL0815nSH2hquOlQ0egk37Gf5/E9kAdiwgggAACCCCQDIHRchofDjkVTf59MqS+UlVfL2JgneTrH4rol6/LZ6TxfyI66HcHOoFKMeUQ6aSJncGJZHQCl88XszF9nhFolOsvO3HPMyees6DX3ZicumJXmbinWKmD+zXK9dc8eOr6e90fD2YoueZrskVLxFaaGHxlRBvVCCCAAAIIIIAAAggggMBBAnH+8e2gwalAAAEEEEAAAQQQQAABBBBoTIE3dd4xum1R76z2jr4v7Nlr5QYBb4Fz7tWxaXgmba27zRp7ZXpM+h+7lk25vHv51M09nTPSse2DgRBAAAEEEKiQwNoVZ/xV0n9/lXd4Z+fmbacxm0ibT0JvTBpqsTKAPiluZJ6Bdkjb+/O0B5t+KSuPSNwXrCxx+XDpf6NE1DGdI239EpT4Ber1ugtK3CYrVwUrAsuaxJT7RJ5ss95ceb2E/n8iWz4gC7/LrvCKAAIIINAQAvkmisgCRH1GybYX+xrnJCzZfX5QFu7OruS86iQXr8ipK7T6H9IheL4rZH19oY1oRwABBBBAAIG6FNDfgZ8XcuTXhdRVsur3MvjGAjvQe0L1aZ1DLfp9V9R3WGdJ21uK2MEXpM/LAv3ukeVzAussFifQSNcfE/cUd01Us1ejXH/Z734fF9y9QwT+kGyvk3SGlV9IZbF/TwjbnjoEEEAAAQQQQAABBBBoQIHgjRoNePqcMgIIIIAAAggggAACCCCAQFwC8zt/O+KJJx57vfNsuyTmTnHOZGfJjWcXB56U+Fvj2a7Rnlv/0yVTd8UzMKMggAACCCBQfYFZC/tmO+M+kW/PXirzr7dcPf3P+fo0cNu75Ny/XeD89Sm5dxXoU6j5MunQWaDT+6Rdn/ZSrfJd2dE7Ina2VOoXR7RRPXSBpFx3I4TiTomwJCd9cvRJEtskgkWfMBS8MU1vxrww2IFlBBBAAIGGEHirnOWPCpzpidKuiSlDKXofw00Sb8sziE7CopPN3Z+nT1jTqVKpE2I0hTSulbq5IfVhVa1SuSHQ8H+yrGMP9UbxwJAsIoAAAggggECNCOjv0fo0yBflHE+vrE/LqavG6rtlJ/9dYEf6WUmPd6hPJ36DjLFFIiWRW/R7S/1uYU9uw+D6DHntlsjeo/qULOt4TCYmCCWURrz+dJKd2yVeFeKkk0GfIlHKdaRPsw7+brFc1jskKIUFGun6+4pwaOKu/m4X9r1pYa0DPfTvErdKBCeLym77hCzo74392QpeEUAAAQQQQAABBBBAAIFiBML+qFXMdvRBAAEEEEAAAQQQQAABBBBAwHR2Om/TE7e+xrOZtu07t7ca642WJxrq/2Ir1spNFdZ1D5hD1vUsPe3R2AZmIAQQQAABBIZRYOCIfZuadzQvkH8zD4k6DOd7Z0rbl6Paq1k/d8HWloznt4bt03l+f9fV03rC2ipYl52NP98uhjoZiSY3XpZvB9K2TKKayb/ny/6ikn/1ZsxLJCiVE0jKdbdPiD4osVEiexNuVk1/JmkiefAJFWfJejD5V29gI9FcECgIIIBAAwqMLuKcRxXRp1CXS6VD8Ab9sP4fk8pSk391nDslPi+h+8gtc6RirsSa3IacdU/WVwTqfFn+VwmSfwMoLCKAAAIIIJAggffKueQm/+rpfXWYzvEHsl+dmOuoPPs/QtrOkfhSnj7FNN0mna6S+GRI5+Ol7mKJz4a0jZG66yWC3zt8QNZLSdoMGbYhqxrx+tPP1e+T0Osv9x5nXdfvZPVzezGlVToFf7fQ5M5PFLMhffYLNNL190s540ckop58Xswlcbh0ulEiLPlXtz9Hol+i5FKDf6Mp+RzYAAEEEEAAAQQQQAABBMoXCH7BUv4obIkAAggggAACCCCAAAIIINBQArMXbTnR9/12Sc6dKU/6PTLuk3fWPChZxD0jmpvWrl4y8cG4x2c8BBBAAAEEakGgfWHvRXIcZ0Ydi/w7u33sA3+Zf9NNZ2ei+lSrvn3x5lbj2w3h+7Mbu5ZNaQ1vq1jtAhlZn9SQr7xBGm/P1yGi7TCp/7rEP0e0Z6ur/QRUfXLAVomwpBqdJEWfHMDnJkGoYEnadfdNsTo3wqtd6vUpPXoz8W8kxktoeUxCr7UHdIWCAAIIINBwAufJGRdKdHm99LljCDI6CYt+zst3L4Pe8L9oCPvQiWI0mUA/X+WW30rFKRL5PoOfL+3XBTbUyTOYHCMAwiICCCCAAAIJEkjJudwj8dKcc3pS1o+WeCqnvlqrK2RH+rkpX9EktpdLuHydimjTJ4DeKfGKkL67pe4kiW05bfrd2vsDddX+Hi2w67pebPTr73J59y6NeAfnSX0xE/doUqd+vtfiS0yRuFVXKAUFGv36KwgU0uG7UveOkHqtGtLvjTX4N5qI06QaAQQQQAABBBBAAAEEKiHQVIlBGRMBBBBAAAEEEEAAAQQQQCB5AjMX9U3wnN8myUizJPlXb2owkvwbW7HGPeqM3Whcqrt7+SSdfZmCAAIIIIBAwgU8uUHJj0wA1kk2th93zCRB6E04RDmnd0wRG+0qok+wyxGy8kEJTfLc/1kn2JizPNSkk5zhCq6OkR43SYQl/+onsn+ReFCCUlmBpF13OgnBWyTCnhikN+bqzZFfkcgm/+q19h6JByQoCCCAAAKNKXBoEaedL3E33+alTMIylORfPYYBCX1ir04Woze1B8vJsnKuhCathBWdCO+KQMMfZPkzgXUWEUAAAQQQQCBZAmfL6bw05JR+KHXDlfyrh6OTel2oC3nKCdL2Zomf5OlTTNM+6aTfmW2UyP2sd4jUaVLb2yWy5SxZeH92RV412ZLJUgIgJSw2+vWnn7v1Gg6buOdqqV8nkW/iHp3ASL/fypblsqDXI6U4gUa//opTeraXThQVlfy7RdouebYrSwgggAACCCCAAAIIIIBAaQJNpXWnNwIIIIAAAggggAACCCCAQCMJzFmwabxrSk3P+G6O9V2L/l0/zqRfGW6ns36fyzR3rV8x6ZeNZMu5IoAAAggg0LV88t3tHb1/kWdwRCcVOjdXpHrROkhg+kE1B1docvXzJPol/iqhT3gIltGyojdCTpM4Q2KOxBiJfEWftPsBiaHeOJlvH2FtmoDy0rAGqfu8hCSTU6ogkLTrTp/m+0mJ60Ls9Kk++rPn9EDbVbLMtRYAYREBBBBoQIHoz63PYtTLJCx3yiHrRBcXPHvozyxdLkvfkXj6mZpnF7Tt+c+uGr3JW598R0EAAQQQQACB5AlosusnIk7rxxH11ar+tezoLolgcmPYvjXhLI7vsTbLOKskzpXILW+TijaJbgmdZOxrEtmi3z1oEqFOwEIpTYDrj4l7Srti4u3N9Veapyapr4jYRP+m8M8S6Yh2qhFAAAEEEEAAAQQQQACBggJNBXvQAQEEEEAAAQQQQAABBBBAoKEEzrpk85F7094ZxndtGWdeZeQ/+he+2Ip1e4zxbjXWdacPH7i1p3MGf+yKDZeBEEAAAQTqTcAau9oZF3wixnNPwdrT2z9+xxFdV52247kN1V1rSjf1p72ohynoJCFVK/pUEb2R5g1F7FGfPpItevCajKKh34vrzYgjJUop+kSJ90loMnE1y0dlZ/Mjdtgj9ZdFtFEdn0CSrzu9KfcDEqeFcAWTf/uk/TMhfahCAAEEEGgsgaRNhqH/tmlCyrict1ETnRdKfC6n/lWy/uFA3Q2yvD6wziICCCCAAAIIJEvgHXI6+u9/WOkOq6xynU5YUigBeKL00Unybo7h2C6SMd4iod+r5ZYvSoUey1ckxg82Onl9j8QDg+u8lCbA9XfA60550evqghC+y6WOiXtCYGKo4vorHlEnFb1JYlTIJvpz8F8kHgxpowoBBBBAAAEEEEAAAQQQKFqABOCiqeiIAAIIIIAAAggggAACCCRXYPbiuw51mSenOGtm7tnrXi/P+fViPVtPZrR19hfWmfVNA+M2rl55wt5Yx2cwBBBAAAEE6lTAeuYW55t/lacAh8+34ZsmO7B7tpye3kDS6EWTFPWmrmKePJdrlZKKsYOR21ZovVc6aDKxPi1Fb9ipZtGkTN13WHlYKt8pkQlrpC42gaRfd/pk7I9I3CoR/nPImCek7V0STNwjCBQEEECgQQWSOhmGTrJzscQNIe+r1v+nhD6tKVu+JAv6uVKL1i/av8R/EEAAAQQQQCCJAkfISV2Z58ReIW36u/Rwlv4id66Tf82R+E2R/aO6PSYNn5S4LqSDeuh3aMHJxK6S9TUhfakqLMD191wjJu55rkel17j+ShP+unR/acQmn5f6WH4OWt9rkclkQ3djresPbaASAQQQQAABBBBAAAEEEiPQlJgz4UQQQAABBBBAAAEEEEAAAQRKEpjf+dsR23dtf4Mk5rY5f9cU+XNRs/7NKOqu/5IG186SRSz//Y1xfvfolLf+p0um6BP3KAgggAACCCAQELjl6il/b+/o/YVUhT19c39P31gSgA+Y6ZMemg8sVvy/u2UPP5PQ5NufV3xv4TvQhOUbJUaENGvSryb//i2kjap4BRrhurtNyPRGtfMi6K6R+vsj2qhGAAEEEEi+QNInw/iWvIV6jtNy3kp9ipMmuHQM1r9bXs8YXNYXTRDWJBgKAggggAACCCRHQP9EdqTEZIlLJSZIRBWdKE4n7Pu1xB8k9PfmByX2SFSq6KQs+n3RMRIvlfiERDFF+2+W0P7rJfol9kmUUzSZWD87hX2XGUz+7ZM+mrRJKV6A6y/aiol7om3iauH6K0/yo7LZ/IhNe6T+sog2qhFAAAEEEEAAAQQQQACBkgSaSupNZwQQQAABBBBAAAEEEEAAgboW6Ox03pZdvadmjGvbvnP7dEnRHa0PstNM3biKteaP1rNd+9zIrp6lpwWfkhLXLhgHAQQQQACBRAlY461xxg+7aW7/eVpnXjrrYxtPWPfF6fcl6sRLPxmdTOSo0jcruIU+1VSTN34lsVFik8TtEuXeCCmbxlKul1GOjxipU+o3RLRRHa9Ao1x3ehPw2yTC/j/2Rqn/dwlNPKcggAACCDSeQCNMhqE3bd8p4eW8vR+W9RUSmnCgE8Nkiz7tb1V2hVcEEEAAAQQQqHsBnRBkroT+Tpwq8mxeKP0+EtJXE4JPCakvt6pVNtQJ4jTxdygT4+n210pkyxOyoE8F1knBSim+dNbz1s9DmjAYVnTsd0nod26UwgJcf4WNtIc6afI5E/eoRnyF6698S/2bTvD3xOBID8uKTuDJ96lBFZYRQAABBBBAAAEEEECgbAESgMumY0MEEEAAAQQQQAABBBBAoH4E2hdsPcnYTFvfzr6ZztkjbeTf5Ms9J/eADNnT3NR8y+olEx8sdxS2QwABBBBAoBEFmgZe0DvQ/PDTBybmCBdwzU16E2KjJwBPFINjJfTpvBpPSjwtsXcwNGFX5zXR7701Rkrok1FGDYY+SVfr9GZJfRqLJv1q7JSIcz4UGW7IZaGM8NaIUdZK/eci2qiOX6BRrjv9/4LeCPypEMLXSZ3e3PvFkDaqEEAAAQSSL9AIk2Foos43JT6Q83bqZ8fLJfSz47jBtmzSS619fhw8PF4QQAABBBBAoAwBTeZ9QRnbhW1yVFjlEOr0u624ji14GJoQrJ91yimaNPx1ifMiNr5G6u+PaKP6YAGuv4NNomqYuCdKpvx6rr/y7PRnqE7OoH9zyC2a9KvJv3/LbWAdAQQQQAABBBBAAAEEEChXQG+CoiCAAAIIIIAAAggggAACCCRQYOaivgnWd+3yRN5ZxmX236To4rw10dpHjHObPM/rumXp5HsSSMgpIYAAAgggUBWB1StP2Dtr4eb1zlh9ymZ4ca6ttXPDtT2dMxr5yRmaAF1MErTeYKNJwU+FY9Z8rSacXhVxlA9J/b9IxPmpLmJXVA8KNMp1pzf9Rv8MMuYKaf+BhF6DFAQQQACBxhJolMkwPiNv6zskDst5e8/JWdcnZP0yp45VBBBAAAEEEKhvAZ3whFKawCek+9skwhKe9fuFf5fQ7+gohQW4/gobZXswcU9WIr5Xrr/yLK+XzY6P2LRT6jdEtFGNAAIIIIAAAggggAACCJQlQAJwWWxshAACCCCAAAIIIIAAAgjUpsCcBZvG+ynb6js7W5J/W/YfZZzpIVaekOdMr+9S3euXT+Jmx9q8DDgqBBBAAIE6FEgbuyaVL/nOmSNG7BoxWU5tUx2eHodcvIDeNPl9ieaQTTT5W5NSHglpowqBoQpo0vkpeQY5XNr0CT5vz9OHJgQQQACBZAo0ymQY+nSmL0jopBdRZY80aKIwBQEEEEAAAQSSJXC+nM5XJHQyuScHX3V5QEKTWPU7GX3V8CTkazyj911q6IRa+juzxhgJKxFnuV0GmyOxW0I/i2joxHfB5eDx+dKmx6fHNWrwVZeDofX61MrfSJRbHpMNr5X4VMgAr5O6j0h8MaSNqoMFzpcqrr+DXaJq9PP4OySYuCdKqLR6rr/SvLT3Qom3Rmy2Vuo/F9E2pGpn/Jb4/4kZ0iGxMQIIIIAAAggggAACCFRRIO4vnKp46OwKAQQQQAABBBBAAAEEEEBABc66ZPORe9PeGUae9ivJua+MXcU6vYngVkko7hoYm/l5gz95MHZeBkQAAQQQQCArMKuj77+ccy/Krue+Wmu2rls29ZO59dVab+/ojZxWpGvZVL5rHvoboYY/ldCnpISVS6Qy6snAYf2pQ6BYgTOl488kivn/sV6f/6/YgemHAAIIIIBAnQkcIsf7e4kXRxy3JrFcGNFGNQIIIIAAAggg0EgCmlD8c4moycT0qaInSTwkQUEgbgFNPC80cc8J0ufBuHfMeA0vMFEEdJLWsAk89efdqRIVmcCzvWNzp3x9e5mMH1Lc5V3LpnWGNFCFAAIIIIAAAggggAACCRHQWegoCCCAAAIIIIAAAggggAACdSYwe/Fdh7rMk1OM9dv27LWnWeN0xvH4iiezmTv7C2dd94h9R29avfIEnU2cggACCCCAAAIVFJDk39Uy/HlRu3DGvqF1wZ1je1ac+kRUH+rrWuAiOfqo5F9NuFxS12fHwdeqwDg5sOslssm/O2T5DRKaEKw3SuaWL0nFBomncxtYRwABBBBAIAEC+mQ9nXDnvyLOZUVEPdUIIIAAAggggECjCegkdVHJv2qhT0S+RuLtukJBIGaBZTKePrk2auKer0obyb8xozOcOUoMvi8RlvyrT2LXJ1NXJPlXxqUggAACCCCAAAIIIIBAgwuQANzgFwCnjwACCCCAAAIIIIAAAvUjML/ztyMe37H9dGtdm/N3TZZH8DVLku4zd+oP+Uwki1hGu9u5zPrdKW9935IpOjs3BQEEEEAAAQSqJNCc9tcNNHsfMJLpG7pL51Ip76k50qY3mdRUmbtga8uaFZP6a+qg6utgpsrhfi7ikO+X+vdKyMc/CgKxCujPmhskXhgYVW+evFdCn254c6A+u9giC5dJfDxbwSsCCCCAAAIJE/i2nI8mq+jN3cHyN1n5c7CCZQQQQAABBBBAoEEFzpTz/lgR5/426XOWhE5sR0EgTgEm7olTk7GKEch+j3pcROdPS31vRFss1dbaFhfxFwJrvP5YdsIgCCCAAAIIIIAAAgggULMCJADX7FvDgSGAAAIIIIAAAggggAACxsyff2Nqx3HjX+OM17Z95/bp8pel0ZqmG/G3nbLIZLg/GOd3m5Ej13VdefpjZQ3CRggggAACCCAwZIHVK894ZFbH5tv1Sb9Rg8lkHbOlbbgSgLfJvidEHRv1ZQs8X7b8nkTY9/UDUq9PDnhcgoJA3AILZUCdVCBbVslC9ufLaln+qcSbJXJLh1T8t8TduQ2sI4AAAgggkAAB/drtKYncBGD9LExBAAEEEEAAAQQaXWCcAFwvIX+y3F92yH/1u8yfSZywv+a5//mSrG6QePq51awhMGQBJu4ZMiEDlCBwkfR9Y0R/neRgSUQb1QgggAACCCCAAAIIIIBALAJhNxTFMjCDIIAAAggggAACCCCAAAIIlC/QtmjTK+Qv523bXWqm8d3Y+B/45h4wKW9Deu++dT0rZzxY/pGyJQIIIIAAAgjEKeAbu0Y+A0QmABvn/mHGhb0v33DN1N/Hud+hjpVuSrfIGP1DHacBt9ebJTWR8tiIc79E6rdGtFGNwFAETpWNrwwM8IAs5z69Z4HU6aQDowL9dFH/tnSdhD65WpOkKAgggAACCCRNYG/ICe0JqaMKAQQQQAABBBBoJAH9HusGiRcGTvp8Wb5X4kKJmwP12cUWWbhM4uPZCl4RiElAv5Ni4p6YMBkmr4B+B/q5iB73S/17JfiONAKIagQQQAABBBBAAAEEEIhHgATgeBwZBQEEEEAAAQQQQAABBBAYssDcBVtbBmymzVozy/hGZ9CWEuPfiqx9xBp/o7Wp7luWTr7nwPj8FwEEEEAAAQRqSeCoMUf2bd+xXW9cOjTquFIpM0/ahiEB2PbLZ5MJUcdFfVkCn5St5kRs+ROpXxbRRjUCQxHQny/flRgRGOQDsrwrsK6Lf5bQp1dcqis5ZbKsnyfx1Zx6VhFAAAEEEEiCQFgCcFhdEs6Vc0AAAQQQQAABBIoVWCgdg99jrZL17w9uvFpefyrx5sH14EuHrOgEeHcHK1lGIAaBsM/oTNwTAyxDPCPwfFn6nkTYvfYDUv8OicclKl6csy1R9444z++v+AGwAwQQQAABBBBAAAEEEBhWgbBfSob1gNg5AggggAACCCCAAAIIINBIAnMW3DE+Y/fMcJL0m3aZFp06O86cX2PNThlxszFed9eyyXc2ki3nigACCCCAQD0K3NR58r72jt4u+TzwljzHP6O1c8OXejpnpPP0oan2BVrlEC+POMx+qT83oq2Uan1ya7OE3vimNyRREFCBayReHqD4hizfElgPLn5BVvQpFi3BysFlbfuxxN9D2qhCAAEEEECgngXCEgn8ej4hjh0BBBBAAAEEEBiiwKmy/ZWBMR6Q5Y8F1nVxgcRsCf0+Klj0HtXrJPQpmjHOfBzcBcsNKhD2uT2srkF5OO0hCuitGzp5wbER41wi9Vsj2qhGAAEEEEAAAQQQQAABBGIVIAE4Vk4GQwABBBBAAAEEEEAAAQQKC5x1yeYj9wykphuXac+4PSfrFjbOP3dbt8c6u9U4v3vgiMzPSQ4q/J7QAwEEEEAAgVoS8Ky3xnd+dAKwM2OanmzSG+Z6auW4re+11Mqx1MlxHCPH+T2JVMjx7pO6syW2h7SVWvVN2eCdEvdInFTqxvRPpMB8Oav3B87sQVleFFjPXdwtFfqEnx/lNsj6kRL6lOr3hLRRhQACCCCAQD0LhCX7hn1uq+dz5NgRQAABBBBAAIFiBQ6Vjt+VGBHY4AOyvCuwrot/llgicamu5JTJsn6exFdz6llFYCgCYcm+YZ/lh7IPtm1cgU/Kqc+JOP2fSL1+L1rF4lqidtaUbuqPaqMeAQQQQAABBBBAAAEEkiFAAnAy3kfOAgEEEEAAAQQQQAABBGpcYPbiuw51mSenOM+179lrXmeN70nab4xH7dIy3C9k3uyu5oGjN69eeULYHzxj3B9DIYAAAggggEClBG5ZOvkeeQrw/fLv+nGR+/C9udLWE9legQZrXb9zZnoFhm60IfWJvDdKjIs48Yuk/vaItlKrjxnc4OhSN6R/IgX0Z0rujbb/JnU7CpytPuV3rUTYDW/vlvrrJbolKAgggAACCCRFQL63O6hwb8VBJFQggAACCCCAQIMIXCPn+fLAuX5Dlm8JrAcXvyAr75VoCVYOLmubfsfw95A2qhAoR8AP2YiJe0JQqCpZoFW2uDxiq36pPzeirZTqUdJZ/1awR2KglA3piwACCCCAAAIIIIAAAo0nwB+pGu8954wRQAABBBBAAAEEEECgSgLzO3874vEd20+XZJk25++aLA/5bTbyZ8jY0n6tcdbYu41x3U832Q19S6bmzrRdpTNlNwgggAACCCAQt4Bz/mprvPOjxnXOvX7Owi1HrV0++fGoPnHXyz77oz7JOOO3xL2/BI+nT0KZEnF+P5D6L0a0lVN97OBGcTxNuJz9s03tCOjNj9+WGBs4pP+S5dWB9XyLH5NG+d3jOU/7yfa/VhZeLaE3q1EQQAABBBBIgkBYAjCJBEl4ZzkHBBBAAAEEEChVYL5s8P7ARg/K8qLAeu7ibqlYKPGj3AZZP1JCn5j5npA2qhAoRyDsczv3RJcjyTZBAZ1U83sSYb8D7pP6syXi+L79mzLOOyXukThJolCZENVhzYpJ/VFt1COAAAIIIIAAAggggEAyBPhlNxnvI2eBAAIIIIAAAggggAACNSIwf/6NqSdedMypxtq27Tu3nyHJvqM1TVeSf+Mr1t7nXGa9GTlyXdeVpz8W38CMhAACCCCAAAI1IzBq5Dq3Z+A8+SwRdhOTTiji+V5Gn8b53WodsyQk97uITzXW2pZqHUed70dvDloQcQ5/lPrgDZUR3Yqu1qcHZG8KiuOGpKJ3TMeaFLhMjmpq4MgelWW9IbfYcq90XC7x8ZANTpC6z0h8KqSNKgQQQAABBOpRYETIQR8SUkcVAggggAACCCCQZIHj5OS+mnOC/ybrO3Lqclf1Kb9rJfS7y9zybqm4XqI7t4F1BMoQCPvuPCxps4yh2aRBBfQ79RslxkWc/0VSf3tEW6nVmmis5egDL/wXAQQQQAABBBBAAAEEEIgWIAE42oYWBBBAAAEEEEAAAQQQQKBogbZFm15hTaptuzMzjXNjJYretriO7gHptyGdTq/rWTlDZ9emIIAAAggggECCBbplko/2hb23ySlOjDxN31Y1ATjyOGgoVuBV0vEbEZ33Sr0mBxe6gTJi89Dql0mt3rCkhQTgAw6N+t8ZcuK5ybmaiF7qZEJXyDb6lJ7sk6Vl8ZmiN7/pkzH0KcEUBBBAAAEE6l0gLNl3TL2fFMePAAIIIIAAAgiUIKBJlN+WGBvY5r9keXVgPd/ix6RRvyMIm1jlWql/tcQeCQoCQxEIu77CPssPZR9s21gCS+R0p0Sc8g+k/osRbeVUZ79jLfjd/dwFW1vSJhO1j21RDdQjgAACCCCAAAIIIIBAcgRIAE7Oe8mZIIAAAggggAACCCCAQJUFZi/eeLxzqTbJ9W03vs4CG3PSr7WPyMODe/y0695wzbTfV/n02B0CCCCAAAIIDLOANf4aZ7zIBGD55DGhfcHWk7pWTPq/ahyq8/x+48uzh0OKc7YlpJqqZwXks6L5mcRhz1Y9Z0mfxPrL59QMfeXNgSEK3kQU6MtisgT0CRLfkQg+EWWdrOtNvKWWJ2WDxRJhTx7XZPNvSkySSEtQEEAAAQQQqGeBQ0MOfkxIHVUIIIAAAggggEBSBS6TE5saOLlHZVm/vyq23Csdl0t8PGSDE6TuMxKfCmmjCoFSBMKSffncXoogfYMCOkGnTpoYVv4ole8PayizTr9LnTC4bcHv7tNN6Zaov80YY/vLPAY2QwABBBBAAAEEEEAAgToSIAG4jt4sDhUBBBBAAAEEEEAAAQSGX2DOgjvGp1N7Znq+meVnnvmjTHwHZs1OGWyzMZnurmXT74xvYEZCAAEEEEAAgXoTePyp0VuOOnzPLuebw6OOXZJy50lbVRKAm9JN/WkvapZ51xJ1jNSbUWLwE4njIiy+L/XXRrSVUq3Z2Zqs0iJxnkTwhqQnZJ3SeAJ6I5k+lVeTgLNFn67zoexKGa863vkSrSHbniZ1lw5GSDNVCCCAAAII1IWAfqZ6XsiRHiV1OqGGH9JGFQIIIIAAAgggkCSBGXIyucm5mhT3WIkneYX0f49E9imXwc0vkhX9jkGfEkxBoFwBJu4pV47tcgVeJRXfyK0cXN8rr5ocvCOivZzql8lG+t2tloIJwNb3Wlzck9Ef2Df/RQABBBBAAAEEEEAAgToRIAG4Tt4oDhMBBBBAAAEEEEAAAQSGT2DOwi1H+SYzXR5415Zxe062cpufPHEvvmLdHmfslpTxuveN2XtbT+cMnpgVny4jIYAAAgggULcCv/jqaQNtHX1d1rh/jDoJz7rW1/3bHSu1b1Qf6odVQBNIbpA4Pc9R6JN6/5anPdik42VDE1BSgzFCXjWiSsGbiKI2pL4uBcbLUc+U0ETdaTlncKWs/zGnrtTVC2QDnawo7G9Mn5b6sRI/kvi9xMMSUTMHSBMFAQQQQACBmhNokSPSz1i5ZaRU6E3hd+U2sI4AAggggAACCCRIQCcR+46Efu+ULetk4dvZlRJen5S+iyW+G7KNJr59U2KSBH8XDQGiqqCAfkfKxD0FmehQhMA46fMzicMi+i6U+l9GtJVbrX8TyJaC390747cc+LNAdpPgq98TXGMZAQQQQAABBBBAAAEEkikQdnNGMs+Us0IAAQQQQAABBBBAAAEEShCYvfiuQ3331FTj/Pa0819rjZX8mhIGKNjVyR+z7R2SStzdPHD05tUrT9CZYykIIIAAAggggECOgL9GPjNEJgDr04GPOuzpM2Sj7pwNY19ds2JSf3tHb9S4E6IaGrz+hXL++nSAfOUQadSoZOEJwJXUra2xz5LD0RvWwsqfpHJJWEOJdb+R/l+S0Kf/5Ba9+VIThDW0HC/RrwsUBBBAAAEEalBAE0/GDB6XPplOE16uGFwPe/kfqdT4g8Q2iYckdGKNfRIUBBBAAAEEEECg3gX0s5E+lVc/E2XLHln4UHaljFcd73yJ1pBtT5O6SwcjpJkqBPIKtEgrE/fkJaKxCIFR0ucnEsdF9P2+1F8b0VZKtX5nqk+sbpE4T+L9EtnCd/dZCV4RQAABBBBAAAEEEEAgUoAE4EgaGhBAAAEEEEAAAQQQQKDRBOZdcPPIfU1j3iBzWrc7f9ckecyv/qF7/yPWYrGQx/fJ/+6WROKup5ptT9+SqbtiGZdBEEAAAQQQQCCxAt3Lpt3b1tHbL58fWqJO0hlvrrRVPAF4cP+a6BCa7Dt3wdYWTRIe7MfLAYHd8qKf+Q4fZhCeED3Mb0AVdx91s5oewkUSeuNuHKVTBnmnhD4hI6o8LQ1PRjVSjwACCCCAQA0InCHH0FXCcbxU+l6S018n37g5p45VBBBAAAEEEECgngTGy8HOlNBE3Wk5B36lrOuEJ0MpOknYnRJh96p+WurHSvxI4vcSD0tkJCgIBAX0b/ZM3BMUYTkOAU3KvUHi9DyD6ZN6/5anPdik42VDn6KuCeoaIwZDXkJLwScAW2tbXMRk9dZ4/aGjUokAAggggAACCCCAAAKJEgj7UiVRJ8jJIIAAAggggAACCCCAAAL5BObPvzH1xIuOOdVY2zZg3BmSXDPa+PJc3nwbldpm3X3O2G4zsrmr68rTHyt1c/ojgAACCCCAQGMLeMa72Rn/w1EKcuPHa1sX3fH8nqWnPRrVJ7562y+flEITgNNN6RbZj7RTAgI7ZfkkCZ3dX5OB9elwGpqQqzczZkM/fmY/gmZvDtLv7/UGodzXbN1IadPQG4j0JjgNbdObjOQT7f6xdT8a2yQojSFwo5xmj8TjEnrzmF4jz5PQJPS7JeIqO2Sg10scJqHXua7vldDrUK933Z+uV+HnkuyFggACCCCAQHkC+j2dfm7Sz18UBBBAAAEEEECgEQV0MpOfRZz4n6R+SURbKdW/kc5fklgQspF+j3XBYGjz8RL9ukBBICBwhiwzcU8AhMVYBF4oo5xdYKRDpF2jkqXgE4Cdsy3P/vmgkofC2AgggAACCCCAAAIIIFCrAiQA1+o7w3EhgAACCCCAAAIIIIBARQVmLOw92ZOkX7kjfoZxbqxEzPtzD8iAG9Lp9LqelTMejHlwhkMAAQQQQACBBhLwnOnOWHu+fF7R5M6Ditwl56XMnjnS8O2DGqtYYX2vpYq7q6ddPVTiwWaTgjVRmIJAqQKayKSRLXod6VOoK1H0d57cognn+uTfR3IbWEcAAQQQQKAGBX4lx/QyCZ1QRf8Ny07UkvuqiSn6WVwnuhgloTeA66vGNgkKAggggAACCCBQrwLH5Tnwi6RtT572Upo6pfM7Jcbl2Ui/T3gyTztNjSvAxD2N+95X8sx1wk793vTwSu6kiLH1d9ECxbVEdUj5Xk9UG/UIIIAAAggggAACCCCQHAESgJPzXnImCCCAAAIIIIAAAgggUEBg9uKNx0veTJvk+rbL89XGxZ70a+0jzvk9vm+7N1wz7fcFDodmBBBAAAEEEECgKIG1yyc/3raw9+eSdTA5agPruyolAPs98oDZ6aHHYV2r1K8KbaMSAQQQQAABBBBAAIHaFPhjkYeVln76dHuSUooEoxsCCCCAAAII1IXAjXKUPRKPS8i8yWakxPMkNCHubom4yg4Z6PUSh0nslNB1/WylE6wcKqH70/VHJSgI5AowcU+uCOtxCOjPopMk9GeQJgPrRFDZyaCyk3Tqq84kn51N3pNlnRxK770Pe83W6c9SDZ1sSn/OaWibTi7lS+i4mvirUcykUhOkX2hZs2JSf2gDlQgggAACCCCAAAIIIJAoARKAE/V2cjIIIIAAAggggAACCCCQKzBnwR3j06k9Mz3fzPIzJvIPI7nbFb1uzU5r7Sb5E033uuVT9I+PFAQQQAABBBBAoBICa2TQyARguW/kxXMW9p68dvnU31Zi59kxrfH63TP3umRreUUAAQQQQAABBBBAAAEEEEAAAQQQQACBOhTQJ6tqZIsmv+kTMStRHggZVJPf9Mm/j4S0UYVAUICJe4IaLMcl8FCJA2UTg/VnZVXK3AVbW9L784Wrsjt2ggACCCCAAAIIIIAAAjUqQAJwjb4xHBYCCCCAAAIIIIAAAgiULzBn4ZajMp7fap2ZmXF7TrYyh2p2StbyRw1sad0eZ+wWZzLd/hj/tp7OGfoEEAoCCCCAAAIIIFAxgcwRA1ubdjbvlA81Y6J2krFmnrRVNAHYeX6/8XWS+oOLc7bl4FpqEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEShVIN6Vbov4mIxPDbix1PPojgAACCCCAAAIIIIBAfQqQAFyf7xtHjQACCCCAAAIIIIAAAjkCsxffdWgms3OaPI23Le3810rSrxdr0q9xaRn7dmO87qaBF/SuXnnC3pxDYBUBBBBAAAEEEKiYgE440r6wd53s4G2RO3Gmdd4FN69cvfLMin1OaUo39ac9neQ+rLiWsFrqEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEShTwTWvUFta6/qg26hFAAAEEEEAAAQQQQCBZAiQAJ+v95GwQQAABBBBAAAEEEGgoAUlwGZkZccTp8jTeNufvmmSNbdZH/YY/k64MGmucPMnu18barj1N/sa+JVN3lTEKmyCAAAIIIIAAArEI2ExmrUulohOAjTl034gxZ8jONFF4OMqE4dgp+0QAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEkiYgk9S3uIiZ7+Vmlv6knS/ngwACCCCAAAIIIIAAAuECJACHu1CLAAIIIIAAAggggAACNSowf/6NqcePO/a1kpvbNuDMNOO70UazfuMs1t1nPNvlmpu7u688/bE4h2YsBBBAAAEEEECgXIF1X5x+X1tH7x+sMy+NGsNzbq60VSwBeM2KSf3tHb3bZB+hyb7tize3dl09rSfq+KhHAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBAYmoA1Xv/QRmBrBBBAAAEEEEAAAQQQqBcBEoDr5Z3iOBFAAAEEEEAAAQQQaHCBOQt7T05b27bdmBnWd2Nj57DmfnmC8IaMs+vWL5v8UOzjMyACCCCAAAIIIBCDgHxeWSOTn3w0aihn7KmzF/e98Jarp/w9qs/Q622/HENoArDxTauM3yNBQQABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQKFNAnv7bGrVpyvd6otqoRwABBBBAAAEEEEAAgWQJkACcrPeTs0EAAQQQQAABBBBAIFEC7Qs3/4OxXpskmLRlnBln5a8bsRbP/N35bqOxpqt72bR7Yx2bwRBAAAEEEEAAgQoIpP193U2p5g9Kom34d7uSAez7vj4F+FsV2P3+Ia0xq+RT2fSw8a21LWH11CGAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCBQn0L54c6v8LSh8MlYZYs2KSf3FjUQvBBBAAAEEEEAAAQQQqHeB8JvE6v2sOH4EEEAAAQQQQAABBBCoW4FZF/ce42fMDM83sySxZIKJO+nXmp2SSLzJOK973dIpv6pbKA4cAQQQQAABBBpSoGfFjCdmdfRulc9J06IB7Gxpq1gCcPR+ZdqWPLPR59uONgQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAgUEBP/rpv8bYjTghgAACCCCAAAIIIIBA4wiQANw47zVnigACCCCAAAIIIIBAzQrMWbjlqIznt8ofKdrcgHuFPFXOSFJLbEXG2+08u8VlTHfmiH2393TOSMc2OAMhgAACCCCAAAJVFrDGW+OMH50A7MyxbRduenX3NWf8uhKHlvK9nrSXiRo6cjb6qA2oRwABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQeFbAWtsSPV++3/NsT5YQQAABBBBAAAEEEEAg6QIkACf9Heb8EEAAAQQQQAABBBCoUYHWD284zBvRPM3zzMyM8V9nfCN5unGm/bq0/EHkdmP87qaB8b2rV56wt0YpOCwEEEAAAQQQQKAkgX1j9t7WtHPEE/K43bFRG3pNqbnSVpEE4DUrJvW3d/Ruk/FDk33bF29u7bp6Wk/UsVGPAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCAQLSDJv61RrTJRbH9UG/UIIIAAAggggAACCCCQPAESgJP3nnJGCCCAAAIIIIAAAgjUrMC8C24emW46bKKxXpsc5ET5g0VzrDm/dv9odznjde9p8jf2LZm6q2YxODAEEEAAAQQQQKBMgZ7OGem2hZvXWWPnRw3hnJs+74L7rqncJCi2XyZvCU0Ats6eI8fVI0FBAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBAoXSD0bzA6TMr3ekofji0QQAABBBBAAAEEEECgXgVIAK7Xd47jRgABBBBAAAEEEECgTgTmz78x9fhxx75WnlDXPmDMVEnRHR1r0u9+B3evtakuf2RqffeVpz9WJzQcJgIIIIAAAgggULaANWaNbByZAKyfuQZGPNIqfdaWvZM8G8r+Vzljpod1yTcrfVh/6hBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBA4IzOroO8flubFmzYpJ/VghgAACCCCAAAIIIIBA4wiQANw47zVnigACCCCAAAIIIIBAVQVmL+57pXN+23ZnZ1jfHRH7zq2531mz3vle1/rlkx+KfXwGRAABBBBAAAEEaliga/m0P7Uv3HyvMfZlkYfp/LnSVpEEYJ1dPu1lonY9oX3x5tauq6f1RHWgHgEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAIETAutao/F9rzQ0hW1CFAAIIIIAAAggggAACCRYgATjBby6nhgACCCCAAAIIIIBAtQUkCeUfjPXajHFtfsaNk4SUeA/BM383zvbYVKpr3X9MvC/ewRkNAQQQQAABBBCoLwF9CrA8hTc6AdiYU9ouvHVc9zUTH477zHR2+faOvo3yuS/0KcDW2XNknz1x75fxEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAIEkCzhn3hd5fnLPTGQbDQgggAACCCCAAAIIIJBIARKAE/m2clIIIIAAAggggAACCFRPYNbFvceYtJ1pnGuXBJQJ8hrvzq3Z6Yzd2GT87rVLp90V7+CMhgACCCCAAAII1K9AU7q5e6Bp4MMy6Ur497zyIcpLZebJGa6qxFlKAvIq+eQ3PWxs+UjYGlZPHQIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAQLhAe8fmzvCWA7Up3+vJ104bAggggAACCCCAAAIIJE8g5sdxJQ+IM0IAAQQQQAABBBBAAIGDBeYs3HJUxvNbjTPtEicd3GNoNfKLym5n3BbnvO6jHnrotptuOjsztBHZGgEEEEAAAQQQSKbA/htBnA1Nwt1/xtb9tWvZtHdV4uznLtjakvYyfy4w9rYC7TQjgAACCCCAAAIIIIAAArELWGt6nHWruq6e1lPs4Ad+x0mfY4zXaoxrMRQEEEAAAQQQQAABBBBAoLoCE/Lvzm7sWjalNX8fWhFAAAEEEEAAAQQQQCBpAiQAJ+0d5XwQQAABBBBAAAEEEKiQQOuHNxzmjWieZlO2zTr3Wkn8jfn3CZe2nr3NZmx3KvPCvtUrT9hboVNhWAQQQAABBBBAIDEC7R29E+Vz2ZX5Tsg6u3Ddiim/yten3Lb2jr4euTE+OgG53IHZDgEEEEAAAQQQQAABBBCIR2Bbk59qXbNiUn++4doXb241vt2Qrw9tCCCAAAIIIIAAAggggMBwClhjz123bMqq4TwG9o0AAggggAACCCCAAALVF2iqXM8qnAAAQABJREFU/i7ZIwIIIIAAAggggAACCNSLwLwLbh45kDp8kiTmzpRjnuicaTa+i+/wraSrGHOXPO23e0+T3di3ZOqu+AZnJAQQQAABBBBAIPkCRz7wl9sff/H47ZLke2TU2fqemydtFUkAlhlhVskHuulR+6YeAQQQQAABBBBAAAEEEBhmgQlpL9Mjx9ASdRyzOvrOcb67PqqdegQQQAABBBBAAAEEEECgBgS2kfxbA+8Ch4AAAggggAACCCCAwDAIxPzErmE4A3aJAAIIIIAAAggggAACsQrMn39j6rEXHf06a702+YVhqqTojo51BzKYteb3xnjd/t6n13d/uf2xuMdnPAQQQAABBBBAoJEEZnX0ni8Ttbwj8pyt2/OUS/3T1uWTd0f2KbNh7oKtLWnPX8VTgMsEZDMEEEAAAQQQQAABBBCoioB8J33DuqVTz8nd2YHfaTJ/zq1nHQEEEEAAAQQQQAABBBCoKQHPzei6elpPTR0TB4MAAggggAACCCCAAAJVEeAJwFVhZicIIIAAAggggAACCNS+wOzFfa/0fde+3ZhWz5kj9j+bN87Dtub+/Um/znSvXzb5oTiHZiwEEEAAAQQQQKCRBVJ+am3aZqITgJ0ddbjnt4rR6rid1qyY1C83zJ8jT9Tihvm4cRkPAQQQQAABBBBAAAEEYhOQSZPe175486rcG+YPTGgU224YCAEEEEAAAQQQQAABBBCogIDd2HX11J4KDMyQCCCAAAIIIIAAAgggUAcCJADXwZvEISKAAAIIIIAAAgg0hsC8C+4buXrlCXurebYzL+p7ief7bcbZmX7GjYt939Y8LE9W6DEDme51X5x+X+zjMyACCCCAAAIIIICA0STc9oW99wjFiVEcztm50hZ7ArDub//+F2+eYXy7IWr/1COAAAIIIIAAAggggAACwy1gnT1HjqEnexz7n/5rMtOz67wigAACCCCAAAIIIIAAArUnIMm/y6a01t5xcUQIIIAAAggggAACCCBQLQFbrR2xHwQQQAABBBBAAAEEEIgWkISNjxrP/KVr6dQfRveKp2XWxb3HmIxrM8a2Od9MiGfUwCjW7HDGbjJeqqv76om/DrSwiAACCCCAAAIIIFAhgfaFm95ijLcgcnhrXMof9e61K077a2SfITbsv3ne81cZ47iBfoiWbI4AAggggAACCCCAAAIVEvDcjOxTgGct6l2lTwau0J4YFgEEEEAAAQQQQAABBBAYisA2+XvLqq5l0zqHMgjbIoAAAggggAACCCCAQP0L8ATg+n8POQMEEEAAAQQQQACBOhdo6+g93zjzNknI/Z2cSkUSgNs+0vU8O/KQVvnjQJsbMCfJvmJVk9F2O+v6ZNzuIx/4y+033XR2JtYdMBgCCCCAAAIIIIBAXoHdzd760WnzEbl5vTm0o8zQkvF2z5O2b4a2x1CpTwKWYVo1ETiG4RgCAQQQQAABBBBAAAEEEChZIF1gUqLgU4Dl96fW6B3YjU2+d050Oy0IIIAAAggggAACCCCAQGUEBv/eUpnBGRUBBBBAAAEEEEAAAQTqTiDeu/7r7vQ5YAQQQAABBBBAAAEEhlegfXHfufI03vdmjyLl/HetXXFGLE9la/3whsNGHNI8zTnXLvkep0qSccyf/11ahrwt5Wx3KrOjb/XKM/dmz4NXBBBAAAEEEEAAgeoLzFrYe6kzZkbknq15uGvZ1HdEttOAAAIIIIAAAggggAACCCRAoL2jr0cmw5wecSrb5PeilvbFm1uNbzdE9DFNfup4brqP0qEeAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEqiXAE4CrJc1+EEAAAQQQQAABBBDIEWhb1PvuYPKvNqdT3kx5+XZO16JX511w88iB1OGTTMprM74/0feNfOaPMe/X7k8j/pXJ2O70voGNPV+Z8WTRB0dHBBBAAAEEEEAAgYoKZIy/xjNedAKwM+NmLtj62vUrJv2yogfC4AgggAACCCCAAAIIIIDAcAp4fmee5N4Jcxdsbcm4zDkygVJEsRtJ/o2goRoBBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQSqKkACcFW52RkCCCCAAAIIIIAAAgcEZnVsme98/wMHeTjTLnUlJQDPn39jascx40/LpOxMeSTvNNn+EOPrrUsxJv565h7r3Hp/79713V9uf+yg46YCAQQQQAABBBBAYNgFzjhi2h29O/sekylbnhd1MJ6XnidtJABHAVGPAAIIIIAAAggggAACdS/QdfW0nvaO3m1yIhPCTibdlG6RBOHWsDatk2/WV0W1UY8AAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIVFMgxoyAah42+0IAAQQQQAABBBBAoH4F2hZteav1/Qujz8C9v2v5tD9Ftx9oaV+45VXG+m2y1ipJHkcU6l9qu/XMNue89ZJL3L1++eSHSt2e/ggggAACCCCAAALVF2jv6DvPOPeuyD1bt/eQJ5/4p//96puejuxDAwIIIIAAAggggAACCCBQ5wLyu1GPMW562GlYa25wzrwvrE3rmvzU8TwBOEqHegQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEKimAE8ArqY2+0IAAQQQQAABBBBoeIH2BX1nGed/LC+E9TSpNzQBeOZFfS+xGdcuM/nMkHHGSeJvvMUzf7fOrDfpzPp1y6ffF+/gjIYAAggggAACCCBQaQHfmls8Z6ITgJ0d+fRhY2fKcfys0sfC+AgggAACCCCAAAIIIIDAcAnoU3zl6/PQBOB8yb9yvNtI/h2ud439IoAAAggggAACCCCAAAIIIIAAAggggAACCCCAQK4ACcC5IqwjgAACCCCAAAIIIFAhgVkL+2Y76xZJ0q7cexRdrPU1IeNr2R6zLu49xmScJAXbNpd2E7L1sb1as0OOaKNL+93dy8/4dWzjMhACCCCAAAIIIIBA1QXWL52ybVZH72/lhvaT8+x8rrSRAJwHiCYEEEAAAQQQQAABBBCob4GU7/WkvUwZJ+FWlbERmyCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACFREgAbgirAyKAAIIIIAAAggggMBzBdo6emf4zn1cnq6bN/lXt3K+PXr2or4zMibzQut7bW7AnCjJv88dcIhrMtpuSUbu87ymriO2PXDHTTedXc6dUEM8CjZHAAEEEEAAAQQQqISAb7w11viRCcDW2ZNbL9jwop6VMx6sxP4ZEwEEEEAAAQQQQAABBBAYbgF9im97R+82OY6SJtW0xusf7mNn/wgggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIBAVoAE4KwErwgggAACCCCAAAIIVEigbWHvNGvspyS11yt2F77vLpcbjYrtXmQ/l5Y84p9LDnJ388DOLatXnrm3yA3phgACCCCAAAIIIFBHApk9e3uaRjVfYJwZEXXYzSOa9SnAX49qpx4BBBBAAAEEEEAAAQQQqH8B2y/fy5eUAKxPDq7/8+YMEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAICkCJAAn5Z3kPBBAAAEEEEAAAQRqUkCeMDDROHepJF+khuUArezZmV9Za7oG9qQ39XxlxpPDchzsFAEEEEAAAQQQQKBqAvqZr33h5s3G2LaonTpjZkkbCcBRQNQjgAACCCCAAAIIIIBA3QtYY1bJ7z7TSzkRfXJwKf3piwACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAghUUoAE4ErqMjYCCCCAAAIIIIBAQwvMWth7mgB8Vp64W/3P3Z65xxm/2+zZt6H7y+2PNfQbwckjgAACCCCAAAINKGCNXSM3ukcmABvfvFA/r65bPvWOBuThlBFAAAEEEEAAAQQQQACBEAG7MaSSKgQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEBg2ASqn4gwbKfKjhFAAAEEEEAAAQQQqJ7ArAV9r3HWXCFP/22u1l6tZ7Y559bbJtu1bsnUv1Rrv+wHAQQQQAABBBBAoPYENLG3vaPvEfk8+oKoo/OtmSdtJABHAVGPAAIIIIAAAggggAACdS2Q8r2etJcp4Rz8nhI60xUBBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQqLgACcAVJ2YHCCCAAAIIIIAAAo0mMGdh78m+cZ83zoys+Llb87A1ZoPnvO61Syf/oeL7YwcIIIAAAggggAACdSMgk8Oslc+K74k6YHlK8JTZi+869JarT3kqqg/1CCCAAAIIIIAAAggggEC9CqxZMam/vaO3Xg+f40YAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEDAnAXAQIIIAAAggggAACCMQoMHvRlhMzzl8iyb+HxDjsc4eyZodU9LiMv777mjN+/dxG1hBAAAEEEEAAAQQQOCAworlp7cBAOjIBWJ4OPNL5u9qk908xQwABBBBAAAEEEEAAAQSSKWA3GuOmF3Nu1nj9xfSjDwIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCBQLQESgKslzX4QQAABBBBAAAEEEi8wZ+GWl/pmf/Lv6LhPVp7cttt4ptemXfcRf/nrHTfddHYm7n0wHgIIIIAAAggggECyBFYvmfigPO3qbpmc5lVRZ+aMmSttJABHAVGPAAIIIIAAAggggAACDSOQ8r2ehjlZThQBBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQTqQoAE4Lp4mzhIBBBAAAEEEEAAgVoXmL144/EZ37/a+ObwuI/VWbe0eWDXutUrz9wb99iMhwACCCCAAAIIIJBsAZlIZo0k+UYmAEty8EmzOza++JZl0x9ItgRnhwACCCCAAAIIIIAAAo0p4PcYY4t6AnBj+nDWCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAgggUMsCXi0fHMeGAAIIIIAAAggggEA9CGjCRMb3lkryxBEVOV5n0iT/VkSWQRFAAAEEEEAAgcQLjBozqsdYm3cimYxJnZl4CE4QAQQQQAABBBBAAAEEGlLAGq+/2BNfs2JS0X2LHZN+CCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggMBQBEgAHooe2yKAAAIIIIAAAgg0vMCsi3uPcbZpmXX2yEphWGvbKjU24yKAAAIIIIAAAggkW+B/O0972hm3Md9Zeta2d3Y6vivOh0QbAggggAACCCCAAAII1KWA8/z+4g7c5v29qbgx6IUAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIxCvATV3xejIaAggggAACCCCAQAMJtF146ziXNsuc755fydN2zrz2rEs2VyzBuJLHztgIIIAAAggggAACwy8gT7xak+8o9PPslu29r8/XhzYEEEAAAQQQQAABBBBAoB4FmtJN/cUct7WuqH7FjEUfBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQCAuARKA45JkHAQQQAABBBBAAIGGEph3waYX2NTAcuPMuEqfuDXG2ztgZ1R6P4yPAAIIIIAAAgggkEyBrmWT7zTWPJzv7PyUNzdfO20IIIAAAggggAACCCCAQJIFnCMBOMnvL+eGAAIIIIAAAggggAACCCCAAAIIIIAAAggggEC9CpAAXK/vHMeNAAIIIIAAAgggMGwC8y64eeRAs/cZ4+z46h2EbavevtgTAggggAACCCCAQOIEnFub75yscVOmXNx7eL4+tCGAAAIIIIAAAggggAAC9SawZsWk/no7Zo4XAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEMgKkACcleAVAQQQQAABBBBAAIEiBVavPHNv17KpH2tOj5vb5FLnytPUPiEJE190xt1kPW+TsfY+iSeLHK64br57xZwFm6qYcFzcYdELAQQQQAABBBBAoD4EbLPNmwDsnGkelfGYdKY+3k6OEgEEEEAAAQQQQAABBEoT2FaouzVef6E+tCOAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAAC1RZoqvYO2R8CCCCAAAIIIIAAAkkRWL3yhL1yLv2DcdBpzV5816E289T4jOcfbZ0b76x3tCQKH+2MHW99fTWHHLRRnop0ypspzd/O04UmBBBAAAEEEEAAAQRCBdYtmfqXtoV9d8nn0VNCO0il5/y58vLjqHbqEUAAAQQQQAABBBBAAIH6FLD9xrgJ+Y7deb70oSCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACtSVAAnBtvR8cDQIIIIAAAggggECCBG65+pSn5HT+MBgHnVn7x+84wkvvG+9nMkd7Td7RviQJS6Lw0fL0tfHyBOFxxpkRwY2ssfpENhKAgygsI4AAAggggAACCJQg4K8xxkYmAMvn0JfPXNQ3Yf3SKQWfjlXCTumKAAIIIIAAAggggAACCNS8QFO6qb/mD5IDRAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAgYYTIAG44d5yThgBBBBAAAEEEECgVgS6rjpthxyLxj1hx9T2ka7nNY0YdbQvTw6WpxOMd74b37pgw9ieFTOeCOtPHQIIIIAAAggggAAC+QSeNqmNh9rMhcbZUVH9PGfOlLZro9qpRwABBBBAAAEEEEAAAQTqTcBa1y8THk2vt+PmeBFAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABCwECCCCAAAIIIIAAAggggAACCCCAAAIIIIBAYwjM6uj7uHNubp6zfXzqEVPmd3ZaP08fmhBAAAEEEEAAAQQQQACBuhFo79jcaYy9LN8Bdy2byv0z+YBoQwABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAgWER8IZlr+wUAQTiFHixDNYh8ROJiXEOzFgIIFAzAnrDQavEFRLXS3xf4iqJ90u8SoKCQJgA/z6EqTR2HddEY7//9Xr2XLf1+s5x3KUKjJUNzpX4scTZpW5MfwQQQKAUAc/4awr0P2rzE1tOL9CHZgQQQAABBBBAAAEEEECgbgSs8frr5mA5UAQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAgINAUWGYRAQTqR+AYOdS3S/yzxCSJ7GzEt8qyBgUBBJIjcKKcyvckTok4pR9Ivf48oCCgAvz7wHWQK8A1kSvCej0IcN3Ww7vEMQ5VYKQM8AaJqRLTJWZIjJDQcqjEjfuX+A8CCCBQAYG1y6bd1d7R91fj3Pio4b2UnSttW6PaqUcAAQQQQAABBBBAAAEEEiawLWHnw+kggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIBAQgTqOQH4EHkP9ObYjER68FWXfYnhKinZcW48LXUDw3VA7LfuBY6WM3i5hCYAamSXW2Q5m/Qri8+Up55ZYgEBBJIg8B45ieskNAkkquyOaqA+0QL8+5Dot7esk+OaKI7Nk26adJct+rvD3uxKGa/62b9ZQn8v0VcN3Yd+JtslMZy/m8jua75w3db8W8QBxiCgP3M00fclEi8NvL5KloM/j2T1mbLjmSUWKiGgP6ePldDXbOjv105Cv1cqNirxM16vidES2yUoCFRYwK6Ry/7cqJ04PzN53gW3jlm9cuLOqD7UI4AAAggggAACCCCAAAL1IuA8v9/4YX9ez56B7c8u8YoAAggggAACCCCAAAIIIIAAAggggAACCCCAAAII1JJAvSYAa/LvnyT0hvGwEkwIznfjpt6smU0azr7qDZ96A6ja5CbzhtVpH63XbcL+YrRa6s+UoCBQqsBVssHFJW5EAnBpYNOk+zslXi7xN4luiesl9OcABYHhFrhcDuDSIg6CBOAikBLWhX8fEvaGxnA6XBPFI86Urutyuuu/+5oErD9Ps6ET+OjvB9nfC7LJvZroq6EJWvqq7VFFx9Uk4Acktg7Genntl6AYw3XLVdAoAifLiW4q8WRJAC4RrMTuL5D+95e4TVT37HdJ+lpK6L8R2e+TshNJjJW6URL6XVWrxGYJSn0JTJPDrZvvGNKpvbc0ZZrPkW9Awr7PlFOxTQMj0u2y8MP6ehs4WgQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAgOQKauFqPRW/Ij0r+1fPR86qVc3u+HhAFgTIEyrmGnyxjP426iSZXf0EieKPru2T9bIk3SuhEAhQEhkvgStnxJUXuXBMNKI0lwL8PjfV+F3O2XBPFKEX30c8CmnClcWR0t5JbdNwxEpr8p/EBCf2Z/R2JKyTulWjkwnXbyO9+Y517OZML7WksoqqfbZwTZ2kSr4Ym8cZVdHKJF8c1GONUTaDuvmPo+Y8Z/5+9LwG7ZDi//74xY4l9l1hm7MQWS8RuxFgjBEFkI5aICLEFIQkJEkIIIhI/EcQSZJWIsQ/GkkjCnxCxzmDs+xYM8/3PGbejpqa27tt9b/e9532e83X3+1a9VXW6urqquuq7T405YPydYGhVL0tDg5vDpg3AXoJkEANiQAyIATEgBsSAGBADYqApDAx/Z/iEd4bpk1pT7pfyKQbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMvM8AFxU2Ubgxrym/iPNiEwlWnmvBwCTk4o4W/oXjcwm50gbgBJIQZHXg+4C5+TeLuRlODs4udBQDXWDgJKSZuvmX2eOGNUl/MaD3Q3/d75TSqk6ksPReGI4hbmnhbhzfeE/dsb/cJPYF4B7gSx1LtZ4Jqd7W874oV+Uz8AJcntfCxTjeAFAXEv4auaQ6BrgBuMjG7OpyNL1nje2n56TOmsbOMQwODI4NEjs0tPSYA25aIhhGRjEgBsSAGBADYkAMiAExIAbEQA8wMDg4NKEHiqEiiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADPchAkV9dqgsNzyMjczoyw0WSLwFcMPsW8DbAf+U6BeACTx4zWQQni2UXjuNE6LgwncLF+uQrwwicz97CrDi6NhJCPaANwGRBUoQBbgIkTPkULn5vKqxzLRK2CPFcbgs9n2mfbA/DcT6j9GKgQgZOhO8DDP/89bdDgeuAfwPzACsD+wFbA5TZ3jvobx8xwHcDYYreDyYb/XeuOpF+z29H0HWN4OzDLwWcC6xt6F2nj0L5OPCMAbbTCwH8pcYM8+M8JhxTnA1wPHFqLHCP2lVve/TGqljTMcB5hV0sLft0fwcWt/TZJdsWSXUMcG6I/wCCczmpwk3Dr7bAcffkFvgP6ghec76J48xs/ojzRrMA/Ic9PPruN0zTCN9Jl02j0UXdGWjsHMPkOd++ccTLI/bHQ8E66pTBwYEtYDjdaZRSDIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBiplgAvPmyrcAGz+AsVPcH04wAWZqXIwAp4QCHwybKcE7JlpGE7mAFYCzgBWADJ5ITvRUQyUwMAf4IN1f16PLy5KlsQZWDoSJGaPRJdZDBRi4KuIdZAR82WcfxK4ydA9i/NrW9gax68AlwASMaD3g+qAzYDqhM2I+5qbwB4ARgNPAXMDPuHmnn/6jIZ+NM6/A2xk6Hyn/McP44C7fAH6TK9622c3vI+Ly3mCWwHfhlD+QzNJtQxwk7W5Afg2XF8OPAxMBDjuNjf8cnNvO8J/FsG2fv6Ik+tg3zMSRub6MRCbQ4jZu1aicUdt9OaYA8Zfjwxs6c/E4MY77HDJzy69dEf+g0WJGBADYkAMiAExIAbEgBgQA2KgkQyM/fHaE8YcON6b96GhoQleowxiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAY6CID3LjaVDF/6ZQLN7mZN8/mX5Y7tqiWflOEC0FfArhJ68dWBP0CsEWILttmIFSnzOei7YRq5oC/qsdN+XuXkK8nIj5i9kh0mcVAbgb4i0qnWrH4DyrMzb+WeeqvgnGR9qW2Qdd9y0C/vh/69oYnFFx1IoGkVpC3ceSvcYaE/5ghRcYh0MeB9YF7gJCMgNFu/0Ph+8GmetsPd7m5ZSxzTPJ0gIbUuYiAC5kiDPAXezO5Gif8FfhjgAuBm4H7gEnAK0C7m38H4eNcILb5l++M7QAzb7iUNICB2BxCzN7lIg4bG8rA0NDA3C8tvNBaoTCyiQExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxEA1DDR5A7C5efcu0PNWAYpMH67oMbsrjr3IP7SA3RVfOjEQYyC0GLwXNwAvBkJOAfjrfPsDPwVGAu3ItZHI/NUliRjoFAMLICFuNJjBSvAi61qXYiDGQL+9H2J8yD4woDqRrxbENufk/WdD/DkJbuR6PZKNDWBnf0fyHgOqt6oJdWSgijEJfwXYJ0XmIny+pHczwF+Az4S/Pl6lHALnm0YSeAb2TwCp/2wi4k7mDjPQ6DmGa05e5+6BwYFgP2ho2CD/aZVEDIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBjrMQJM3AJsLw7kBuIjEFtXG7K40J1hKbQC2CNFl2wyEfg0otsGk7cQ76OBjSOvXwEPAfsBMQCbtLor+Mxz5Nlc+AtsRWUI6ioEOMHA80pjLSuclXD9s6XQpBmIM9Mv7IcaD7O8zoDrxPhcpZ9x8FZIiY4P74ZD9mJDwlyG56UvyHgOqt6oJdWKgyjFJqE0x5zvqxEcv5YW/wJ7Jg9lJBce14JO/LBwS/gr99sDEUCDZas1A4+cYBgcGrwgyPDj4sdH7X2+PW4NRZBQDYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIiB9hlo8gZgLpTP5LHsJOfxjUj40IJcX9RnLUPoV32soLoUA0kMcHGwT2J12hevbvptkaHbgJ2A4Vbm3sV1uxuA6fJzADfk3ArwOb0X+AmwKlCGf7iRiIEoAysjxC6OUKyPEjGQl4F+eD/k5aTfw6tO5KsBsX5U0Q15ZyMbd0Syol8Afp8g1dv3udBZdxmoekwSalNCtu6y0jupm/9gakJFxeJmSf7jKXtMayf3VSj4q/GSZjPQ6DmGwWEDV+FXgM1fxp72bkwZGD5i2PBNplXqSgyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAaqZqDJG4DNBZSTChIVWlxOl0U2AL+DeObmQf0CcMGbo2heBkL1NvSLaV6HNTSYG/zt7L0ChX9Rqh3af00fpwHrAPMCKwD7Aubzi0uJGKiUgW3g3VXfn6o0VTnvVQb64f3Qq/euqnKpTuRj9vVA8CmwtdPP+kfAN00fjNj7yax62093u95ldfXRshyXMSZ5K3PmOGoDsIOUklWzGv5ivwBvBM11+guEHhWJcTrsDCdpPgONnmO46sR1+RxE+iuDmzX/NqkEYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIiBZjHQKxuAnyhIO39JNCRFNgDT33OGU20ANsjQaSkMcJO5S7jYlJtTekFCC95f7YUCqgxioMXAFh4m7F+T9wSTWgxMw0A/vB+mKbAuogyoTkQpmiZAqP/h43IaB4GLuwM2mtrZXBxx3Tizj+te6us27qb0aYZDbUIZYxJfXSfdoc3BfXo7Si32LPCWzYex/X2pVO/vOfsaDttF/N4O+4GRMDKLgY4xMDgwbGwosaGhgSU32e+GpUNhZBMDYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIiBchnIFjyW67Uz3sxfaCn6C8CxzZJFNwA/b1CgDcAGGTothQFfvQ0tIC8l4Q46CT17ZSy272BRlJQYCDLAX552id4dLlakizHQD++HGAeyT8uA6sS0fMSuQv8cqN0Nuo9EEr8nYu8ns+ptP93tepe16jGJr66TlXbbnHoz2/3czYws8J8KUKr4xzurwe+JU737/7C/vyMQ+tVzf2xZxEAFDAyf/NL4gcGBN0Kuh0YM3zxkl00MiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGymWgyRuA9wIVy7Rwb0FaQov86TK04DeU5PYwZnkrujk55F+2/mYgW6hss9BLi8RDz97rdsF1LQYaysAI5HsOT961EcBDjNRBBvrh/RAkQMbpGFCdmI6SoCK0Ga/df7TyoWDKAwOxXwiORO8ps+ptT93ORhem6jFJlW1Oo4nvQOa5+ZabGL8M7F9yeuzfXwLMFPG7K+wTImFkFgMdZeCK07Z8a3Bo6LpgokNDG48+6vrhwTAyigExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxEBpDDR5wdZbYOGBNpmIbQB+s6D/xwvGUzQxkMKAb6F4uxtTUtLuVJjQsxf8NZpOZVDpiIESGJgn4EMbgAPkyORloB/eD97Cy+BkQHXCSYtXGRobhGxeh4ZhFePcdaoNwO+zonr7Phc66y4DVY9JfHWdpW63zekuc81I/aqKsnkW/C4Z8c1fB74sEkZmMdAVBt4ZGBw7w8DAVt7EhwbmnOHlEWvDfpM3jAxiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExUBoDTf4F4DJIiC2qDf3iTxnpy4cYKMKA71fRemkDcOjZ0y8AF6k1ilNHBmYNZEobgAPkyORloB/eD97Cy+BkQHXCSYtXGdqM5+PS68wyhDYAX4uwz1jh+/nSx3Uv9XX7+f42qexVj0l8dZ0chdqjJnHYb3ndBwXeIVLom2H/ZiSMzGKgawxcf/J69wwNDgT/seGwwYEtupZBJSwGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGOgzBvp9A3BowS2rwuQ+qw8qbjMY8NXbXqqvobKEFuI34w4ql2IgzoA2fcQ5UojpGeiH98P0pZYmxIDqRIidfDYflyle5kUg3wZg/sMHbhiTvM+Aj+tQ//D92DoTA+UxEKpzGpOUx3OveFodBflRpDDPwf4ZQP/QIEKUzN1lYHBo4IpQDoYGBtf8xGE3zR0KI5sYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMlMPA8HLcyEtJDMwEP5sCnwa2AiYCqwEuWQjK3YG1gZHADMCLwN3AT4B/AXnlA4iwMbA0sASwJEDfbwLMy4QW7sPxaqCqDWrLw/dOAHlYBlgXuB1wyaJQrgB8uHVk3BHAJIC/WEJcCdwBVCULw/FSADnLsDjOeT+fAp4EnmjhIRxvBN4CiopvU0TZi4i7WR9CZalisf2MuBmfBHYBlgNOBfgclSmsl+sDrBustxkWwDl/1ZiLwZ8HWFduauENHKuQpj1jVXBAn3W6J1WVsSq/s8LxjsBuAOvyqgDfQbbMD8WawErAigDbyHcBts2PAA8DlwNsJ/PIIALT18otcGMd34tsc/m+ot/fAXwXdErqUJ869X7IOGV7xs0uSxtg3WBdYJvG9ozvvHGAq35AXaqwLR8DrAd8EGCdYBvL+sJ3x0vAQ8D9wFjgQaAdmRmRtwH47mAdHA08AJQhH4GTTwFbA3xmNgCKvP/6vU6AttLEx2UsAda/8wA+Gy45Ecr/uAxd1nWzH+jjOtQ/bIeuOrTfZv57oZ/Gd8MWAN8To1pgf4HtGNvgDKz7bI/ZPtdRQnWuSJtcVhnZ7yLHy7SwGI4cT7B/xb7PBOCPwGNAp4T3uk59gk6VO0tnTpxcAnAOwCds2z4P8D41Xbr5jiB3mwK7Any/sg0pS9h3ZJ81m6/h+2Fe4FmA/bE8wn5p2XMMHZt7GvHOlKsnjxi2xwB2+joLPTQ0w5tvD/I+XOy0SykGxIAYEANiQAyIATEgBsSAGGgiA8MGxjUx28qzGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBnqdgXVQQC7C9GGeDhDANLh55HzgZcDMy6u4toWL7w4F3gbMsOZ53gWQ3PB4FvBKwKfpn+dcrL0bwAWRZcjScHIEcBdgp8XNL7Zwc/IVgB3Wd30Hwu4LhBbkwpxLuJntMsCXpk//GuL8HiB/3JiUV7hZzuV7Yl5HnvB1qA8f8pSR5T7Tk++86jkRYTvgXIAbb01OL8B1WbICHP0IeBow04idc9HxOIB5dC+6hSGHNPEZy1G8XEHrck+WQK599eCgXCXqTGDytj/wZ4DtmJl3thum8N3Ad5UdzoyTnU9GOLaJHwNShO8EvoOy+L4jN+3Q7/pAlVKX+sQyVv1+YBrDgE8A7GtMAXz8m3pumGDeuBm8CuE9vhCw+1FmHlzn4xFnT4Dvg1Rh/+PLADc7vAiYfsfguqjMgIgsx0kAN7Cbfnm+CFBE+rVOFOGKcXYHbO6za77Hi8ghiJT5sI+3wzZLEacVxqlDP7AT9ZYU1qn97oV+2ihwyvHcvwG7roeuX0H4E4C5gbpJ1WOSnVFgHzeu/ssyCH9lII7pi+/eqwGmUcZYAm6mkzr2CabLZIcUv0U6Jv+u86M7lJcqk+n2O2IrFO6vFtc/xTU3JLcrn4WD7L6xT8m2KbsehfMUYZ+yijmGrsw9bXLgTcePOWD89V4cdPPZKaQojBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIgXYYWAeRswV9ruM87Ti34nIz1IbA3sBpwLXAU4Ar3Uxn/xISfaQsLGWYFOHms/MALg7O0sx7fBRx1wVShRtwVwN2AfiLZ1zA/AQQSndz2E3hr+b8FwjF8dn+iXhLmc4KnI9EnHOAdnjL8kcf2wB5pKpNEd2oD75yc2N0xpF9PMUXydAPN8654H0UsCVwMHAOwI0JoY1rZ8DermwEB/biZLssqdd3wVdqPemFZ6xd7n3xu3VPfPnZAgZfHfgWbHwHLQhw4x+fT25U4nuL8T4D7AbwvVC20CcXmXPDyLHAZUCsnTY3J7KNvQfwlc2nfwtx2L77hBsvrwF88X16PuvccDEDUKbUrT6xbFW9H+ib9YIbwB8CfFyn6H+D+HMAZchoOLkOSEk3FOYN+FgYMGV+XPB5+yLwPeAiYAIQ8vNR2GMyIwJw88wngP2AnwG3Aa8DId9sD4pIv9WJIhyZcXbHhe8+PG0GTDzfFuEme3yy7s6e6KcTwerUD6yy3pLLbrbfvdhPGwlO2Vfg+9b3/KToJyH+ZkBIBmGcCxgFzAZULWWOSVx5ZV/Lx836VoRP4pqbEn3hQ3puBGafsiypY5+grLIV8fN1RArxTxvb/LL7okXyWjRON98RfO63B+4AfDzfD9uaQFFZFBFfBHz+R1mOmSfqqp5jGIk0zgE4b+TLW6qePlLnFBB0YGDjA8dv5N3829oYvNHXxy87NbD+iAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYqIiBTm4A5sK91IV5WbjnrHL/MtHHyVY8+3JOKPgrS9xslaXVzpELkVM2vSDYwFcKpLkxI7bkMBzbXVzO/Bb9lb4NEfdNwMXX36HnRh5uMt0T+A5wKcCNRa7wmY6b+fJI2ZsiulkfXOXmJsezgYwf15FcczP3ncC/gAeAicCzAO8P68jWAOVwwOUjpDt+asxif7iw+2jAt0j3dthOBbiR7msAn9e/AL56ZebzFIQzNzfjcjpp+jM2XYFKUHT7nthFWAWKPwLmvS16vrjtvITrInmbt5XuGjhyk1zR8jDeN1u+zMOquGjX75XwEXt+zDR953WrT2Y+y34/ZL5XxskdgH1f2c6xDT4HOABgu8Y2jW2yHda85j9h4K8YFpWPIOINgOmznXO+M+xfjru3gP8lEScmX0KAInnlpsEi0i91ogg3rji7Q+m7P2yDUoV11PdPe/4L2yEA25I6yJzIxAlAN8YFvvJXVW/r0H73Uj+NfLLdfw2wn5v7oOM/veKYaCvgYOBS4DnADmtfP4QwD7YwAcdJAJ+/F4B3gCz8GTivUlaA8zLHJK687gxlVh77uL4R4es4940t7Hi+66fgY03DZ9HTuvUJipajrHjk9G3Axzv1TwILAU2Ubr8j1gVp9wAhfjPbqwjH5zavDCLCtUDmxzw+C/1YIBvr4HSqdGKOYUOk5Jsj4HzIzwC2rZXNPe1w1D0zjjnw5j8FNwEfOJ7vAYkYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiIHKGKj7BmBzo8GRYMFciBg69y3A4yJtLjp/xuFrMnR/BS4CfgCcAnARpCusK+3nEXYlICZFFr1vCKfDgJ8ArrSL6FiuvL+CtBjiuPjgRqZtAJ/MDsNegCsu8766L6JHX9amiDrUh6yIvL/cHHA1UOR+uuJ8seX8iAI+GaeIsI6MB1z5+RP06wacLgzbaQA3BrniZ7pxsM8F+KTJz5ivTO3o63BPsvwvj5NLgClAdj/bOXKzVhkbWuFmGuGv+OXNF9u5zYFXC8S10yI/HwcyGY2TlwE7XJHr4zOnBY91qk+uIpT1fsh88z3xbcC1seUW6NluuYQbKTYFQhs2JsI+nytyQMd6djJgbgDL6gHrzcMA6y/v81HATwH+anRsY+NjCGNLKO9ZmvZxHtuJ47rIBmCWt6j0ep0oyosv3u4w2Pc1u2Y/jr/gbAqv5wVWA74A/BC4D8jimMfJ0J8DLAXUQerUD7T5KLve0n9d2u9e6aex//EXwKzjPGd7xbGk/axANVU4/roBsOMVuT7yPZel/q1yTOLKaGwDMPPD914RflxxHoGvOVwZSdDVrU+QkOXKg8yNFCYALq4zHZ+JjYCmSV3eEUeAuIzLlOMDCJ+3jvOf2Ni+ufH2G8AIwCV580X/jJMqfGe55o86Pfc0MAYbfCMbgP84+qjrqxiTpnKlcGJADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATHQ4wx0cgMwN+wda+DnOL8aeBewFxtm15Ngo2wPcGNLpo8dt2Mkh6wOnR33Neh+DIx0hM9Ui+PkKsCOa19zsX5MuNnnNOAM4BcAfwnqQcD2ZV5vAvvvrDCTcf0n4ERgb+DzABdo0ucrgBnfd85F66kyCwL+E7B93QvdbIlOuDHILgf9kd88UtamiDrUB5b7c8ADgM1tu9cb0znks8A1LdyII+9Z7HnaF2HyysKI8BRg55tpHZbD2TII+7jDj+n3Sti5KNslTX3GXGVpV1eXe8JyrAWE2nvz/qae390uQZ7460LPNprvqQsAtv9vAKF8fRn2yUaYt3HO9vgzANua5QC25d8BngZCvmibAHCzJ99nXIBvhufz8WvgaGA/gBuN/gCY6ZvhzXM+jxsCRaRO9cmX/7LeD/Q/CJwHmPxl56dDPwKICd+PvwWyePaRbbOvLbN9rwqFq218HXr2A0Lv4llh5z/qGAfYeeD1dYAtH4fi2BZOwJF17r+AK36m40atmDAvRwL0fTxwFsA2PdQ+sF9TVHq5ThTlJBRvdxiz++k78l6xTWQ75wtj6p9EuB8Bo4A6SV36gS5Oyqy39F+n9rtX+mlng1eznvOczwbbzphwoxjHn3b8PNcTEf8DsYRy2j+H8A8AefKREnbjQD52DqTHftNvHPZx0PH9wXcfxzncvHga8DSQkh/eu7xStz5B3vxXEZ6cXAbEOD+iisQ74LMu74hDEji278GvcvCzIsLaY423oPtExAefvarmGGaB77rMPQ1setAtywU3AB8w/vox+980OsKXzGJADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBgozsA5i2osFzWtu2KxaPo0EzDTNcy5sXgV4LRDGDJ+d+xZef8Tyw41Q3JSVIlzgejDAxZBZOvbxHdi4wL6I/AeRbH/Ztbkphun/HBgF+ISbxvYHYht16H+kz4ml3wvXWX6yI+9LKn+ZO26YutryNW9mTDyWtSmiLvXB5iPjt93jsgE+N7LugZ3WLoG4LhPv680en19yRYjoloZ9ksdflteTIj5sc92fMTu/7V7X7Z6shwJl9y71+CriPAc8ATzWOvKamwG5UP1CoFOyBhJKzfe5CLtYIGMzw8aNKzF/LDPfK1k4PhNfA2YEXLI4lEw7C+87XuSKHNHVrT75slvW+4H+fwK4ODzWl7hHz/vNf7zg8kXdFzzxTDWfn5cA28dfoVvaDJhwPgZh+ByZvn6WEI9BPm/FM32wT9CO8F1h+jPPuamrqPRqnSjKRyze7ghgcl/G+b/h888An6kdgTmBOkhd+oEuLsqst01pv5vUT/s2bprr2eA/D8kjNyKwy0+Kboc8CSWG7caYZOdEDtgfYhsSGnuyf7QL4HpfmpxybL0gkEeYtukjO+9GnyBPvqsMe7CHk4wbHq8ABqvMRIW+6/KO4D9XGQksA/Adeilgcuw73wnhYsJn5k7A9ME5sqLty0aWL9Mvz3cBUqROc09T87vJQePPCW4CPvDm41IKpjBiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAaKMFCHDcAzIOPc5GUvDsyunzJsk3F+KsANvssD3IhyPkB9Fp7HtQCXrASlGe56V6CIbivLh+mP50dE4vvMx0T80jc37HzU58ChXxO6JwE7j+b1VxzxXKo/OfxQV0Q2RiQzD77NbD7fZW2KqEt94D24BeCi+z8ArNPnACZH5vkfYVsX4PO7NsD6znvNurFG65w2bvgIyV0wmn7N87yLfn/s8XVZKAMRGzcw/9fjN8vr6IgP01z3Z8zMaxnndbwnY1Awtt8fAbhBlv/gIbuX9vEg2OomLyJDdj7t68NyZJph7fi+a/4K1tyJvvlrrT4/1POdO0uiryxYHetTljfzWNb7gfXPxeF90M9kJph4br/3TN/3wEdoc8wGsL8OmHF4/htgOFBE1kck098hiU74jjHjmefsb7QjofZgYhuOe7FOtEFHNGoVG4DNesJz9tuvA/irnbMB3ZK69ANd5S+r3tJ3U9rvpvTTFgKnbwF2vX4eunmAPLIWAtt+zGu++/d2YFfoqpBujElSNgA/hsLyH2GkCp/tSYDJpX3+pVRnCFenPkGObFcalGNNtuU2r+Y179t8leaiWud1fkfw13mfAEy+7fMXYGd7FZLjYbTjtTsGK2OO4U+OfFFXROw+eN65p6lpbnzAjZ8JbQDe+IDx1268zzXzFsmg4ogBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGIgxUIcNwMzj3YC98NC+5qab5RjYIZ+Cjr8KlMXhYk2X2JtLPucKlKC7AWGytOzjVQnxXUH2C/hkGk8BK7giRnT2gkc7v9xMGhNuFHsDsON+LxbRY+fGVP7yEv297QkTUpe1KaLO9WGuFj8257z+foicHLbfBdLYJoefbT1+eG8XzeHHFfSHHt8ZLze5Inl0dX7GPFkurG7KPVkCJczupX08qHDpq4t4TyC/zP+3CiR9c8Qn/fIdmXdB+ZURv5vDnipNqU8sTxnvB77zXgTsOsnrLwNFZBgihf4hxyYep9xs/ABg54Wbz0YB7cgjiJz53T3R0VJGnCxudrw/0Ycv2MiAb/YBi0qv1YmiPKTGY13I7ql9fB029kGOBL4JfKN15DXf1+cCbHseA+y4vutHEXZroBtS535gGfWWnDap/W5KP+1o8Oqqz2cXrMT8Zw4uf9T9qaDPMqNVPSbZOVB+csA2Yv4CBdoi4vfURJ916hMkZrnyYNzUG2vnuTl4ncpzUm0CdX5HsOTLAE8DvvaD+t8CPuE/ZpoCmPFP8wXOoW93joHPXJ3mnqYWnZt7uck3tAl4k4NuYnsmEQNiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiIEKGOCGDEn3GYj9ahwXNm4B+DaA/AG2nxnF4IJBl8xgKF/CeWhBpBF0utPQJq9FpgudpohthOUmi3vSXE0T6lpcXTyNZtqL5ae9dF6tB+0sDgs3JhURLgh+oRWRv/DaLalzfegEJ77nhGnzHqXKEZ6A/HU/Lg5vR45DZD6rPmHd5OLlFKnzM5aS/zxhmnJP8pSpDmHfDGTiQdi4AS6vHJ4Q4SCEeT4hnBkklpc876p+q0+fBpHc8GTLW1BcYisTr7nBgn0Vn2zsMRwCPTfd2sI+zwRbmfN6ohH+ZeM8dBp6Z78aiphgC8UPpZvguu0gdaoTbRemDQevIS7brO8CPwD4a+M88pp1dRdgM4D//IMb9nh9CxAShv0jwE2QM4cCVmDrh35gk9rvJvTTOB7a21MX7/foY+oLAgFWDdj6wfQOCvkZ4NkChb0Cca4PxFs2YDNNav9NNgYGBnF5HhDrR34TYWLt/7Se63dV93cE25ztgVDbuR3srMO2LADFrwDez0yuxMn+2UUbx3bnGNZD2rWbe7r29DHPg6y/hXkZZB9IIgbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEAMVMKANwBWQWsBlaIMf3X0NeCTi91uw79jCE56w1HPB6qTWMbSZy+Niqvqmlg9XmHlcygQdNxb55D8wXOgzJui5qcInc/sMhp4LRF2ytkuZqLsP4firxhMTw1cRrM71oYry2j5DG6pCC4lNP2vgYnVTYZzz13/aFW4Uj21k5AajFKnzM5aS/9QwTbonqWWqSzhuRPEJN6unPjemjxtxEdrYwn/8cJUZIfGc//xhQiCsr123o/RjfdrDJqF1zUX/sf6KJ+pU9TUB44YO2yLQHe7QvwbdMQ59XlX2jzgYL3UDcKiOhzbwpuQt1EaH3lcpvtsNU5c60W45Ohn/OSTGPvd6wJeAUDsH89RNTOfj2MmxWa/3A5vWfofagP+gbnRzLMQ6SiGn8049m/7P/dOrkjQPBkJ9ELZOPhOBrHTFdCVSvaWNlC8OxF0oYDNNav9NNgYGDsPlFtOqpru6DJofTadtnqIJ74jxoPXACLU/gX0uIww3/fL9bD4DnJvZCXgXaFdCfbZQPzJL1zdGWTsLUODI8rU99zQ4MGVsKO2hKQMjx+x/6/KhMLKJATEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEQDEG+nlBbTHGqon1esDt07Dxl8Fiwk05l7bgW3TIRX/cLMhNNV8H2pGHPJHn8Ohj6tBiSC5+bmcx5s2BxFM2APuirw/D3j5jRM+4XNS+ciRcleY614cqy535fjM7cRxD9dEM/hXzwjiP/dqlETR6yl8nCsmYkNGwhcpU12fMyH7yaaqurZwAAEAASURBVJPuSXKhahLwnUA+bg/YQqYhGP8ZCHB1wBYz/SMQwLe43o7Sb/VpGRCwgU1C6/pOjz5V/Xgg4CoO26ehm9mhvx662GZKR7TpVNygmUnqBmC27T5pdwPwZJ9j6H39ukCU0kx1qhOlFaqDjtjGnQOwv/coEJLtYTwgFKBk21PwV9dxQRlFbVr73YR+2hKBG1O0DeSYks+JS96C0mdzhe81XdG+VcZDqH/FXymPidr/aRli/+joaVXTXfGfe+0K9EK9bco74nTwzXkwnywIw3GG8WCcm79U+wKutwJS+4KGK+dpGXMMLsddn3t64fUP3ILfTH7FlblMNzRsSmyDfBZURzEgBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBjIwYA2AOcgq8KgbwR8XwxbaFNIIGqlpoc93meBfrjHFlK/GzDyF4vbkScRmXDJDFDO7jIYutCmpVMQ7gfAfEb4fjwtuz50gsNQnUt55uZAJnf2ZPQx6J/x2PKqWf/uDURaCLYVA/bMFCpvt5+xLI/tHpt2T9otb6fjhzY/tlOHfO0Hy+dru1PKHvqF9Vi7T//9WJ/4S6U++ZfPkKjnL8n5hH0HwpRPmRfG+SPGeTun+yPyOi2kli20oee1djKDuKH3Tjc3ANepTrRJcVejcyMVNxjFNkkejjBzdTWnxRL3teNFxwXFcvF+rCa2303opy35PsXTnS06nSZNwXHwoCfo/dCH2l1PtJ5Rh/oxKYUMvS9nTnCg9v99kviPYy4COHfgE77HdwRe9AXoY33V74g9wW3oefky7GsDawLHApnwnxvtADyUKUo4htryUF8vS7q2c0//OHONyUMDg9dmGXUd0ZhvtMNR98zoskknBsSAGBADYkAMiAExIAbEgBgQA2JADIgBMSAGxIAYEANiQAyIATEgBsSAGBADYkAMiAExIAbEgBgQA8UZ0Abg4tyVGTO0ELDdX9wrM59cKPxRYA9g5YBjexNPIOj/TKGNZS/9L1Txk9BC3DkjbkOLp0cg7mEANzZdBnDx6SigH6TK+tAJ/kJ1LvRMZnn7CE4+kF1Yx3Y2LVqupl5e5VIaulWNc99pqLzdfsZ8ec6rb9o9yVu+bof31SFuznmhjcyFNsvHNsuFkg09h76ymP76sT6tZhJgnT9vXee9NH9x1xV3HkM5L87XM67N0wnmRRvn3HR2aws8T5HhgUBvB2wpJj5HvnrZzQ3AdakTKRzWPczdyOBBkUzyOdglEqYu5jr3A5vYfvuef97vuvTTFglUvtCvAweiTd386/vFzPtCEfvAFhq/phSf721fvZopwYHa//dI4pzZ+cCHIpx9A/a/RcL0k7mT7wj+eu/nAN/mW+xLHfg18BuA8zeZ8J18XXZR0tH3zNF9yhxDzeeepowN8jQ0NNvLL73k68MHo8ooBsSAGBADYkAMiAExIAbEgBgQAz3JAMfko4FjgF8CFwPHA7sDKwESMeBiYFEoDwT+CKzlCiBd3zGgOtF3t7xjBd4WKf0OOB34NsC2h9gQkIgBMSAG6swA+9lrAOxn/x5YBpCIATEgBsSAGBADYkAMiAEx0AcMhDYy9EHxa1NE30JFZjC0ALDKAswK51z0y8EiwYX0ywKhX72BeapwseerrfPUQ2ihZBkbX0L54aA4JI/CeBsQ+sDAhaSfbAGHqfeNcTLcgfOUBZ+MW0fpdH3oBAeh5y7lXo0MZJIbwssUbgDeP+Bw/oAtM9X5Gcvy2O6xafek3fJ2Ov6QJ0G20T6bJ8o06tAGl9enCZnvIrRhKvQ8ZKn0Y33iB1Sf8B9/PA3wfr9pgBtfySfbVPPIzUV8d8wOzAbMA4RkDhgntQJsgKOvv/FIyEnFNnPTiJ1UynvDjmNfkz9uNLKljH6Q7TP1ui51IjW/dQ93ATL4Q2CuQEa3gO2UgL0bpqb1A5vYfvP590kZbUA7Y6EsX6F/9rFEFijnkW0Mx44uudGl7CNdO30g0sS+2SuAq70Jvc8Yl6L2/z0evoXDJu+dev9ygVCn2m3eu0OAtwD+A5MM7JuxL/JOC2xT2JfinB9/kZVg34zgM5cdGeckoB2pwzviZhTgBwDvl0sWs5S/xPWplq6MS/aHfZLSV6z13NO1J61//5iDbn5kYMrQ4r5CThk2xH7MdT679GJADIgBMSAGxIAYEANiQAyIATHQNwwsh5L+GljFU+LfQv9pj03q/mOA/3yP9WEnYG0gW79zG84JSf8xoDrRf/e8GyXeD4mOdiTM9Vk3OPRSiQExIAa6yQC/9W0EbANsDSwMZMJ/gnt/dqGjGBADYkAMiAExIAbEgBgQA73LgDYA1+PehhYJhn4ZsczcLwhnHwf4ax3rAisCvs03MAVl5qDVbeQCZZ9wMWu7Elr0zkWyMeGi2EtigQw7F0QSO7d0LMPfAS5MHQuMB1LSRbCuSLfrQycKHdpokXJvQptL5ii5AKw7IUnZAFz3ZyxUvlRb0+5JarnqEs5Xh1J/PdVXjlB8bm4oKqGNM6HnP0uvH+vTIlnhHcfvQEdUJeamCH7U9Qk3RnRLQv1mM/9F8+d7xsrY/Fc0T3WpE0XzX7d4bO9+BewbyNgGAVunTE3vBzax/fY9/7zndRgLMR/38I9HNoR+FiBve7W0xx/HwL/02PpFnTIeiXHBNse1ATg0/5D5VPv/3vzIkRkhnuPD0O/msVWh3gxOjynZ8Vnwx83iqVLXd8T3UABuPl09UhAuGt07EqaoeUogYuozXeu5p8GhwSuGBoa+Gijn6qMP+vt84360xnOBMDKJATEgBsSAGBADYqCTDPCf6PD7CcerRNExNhfa8tsnwX+oQ2T/dGcYzt8G6Jt4AShjrhBuJGJADIiBRjLweeT6ZwD/aZhP8s4j+vxI3ywGFkJ2lwWWayE7H4XrQcCW0LdeO6yum8mA6kR97tvuyMp8rez8Bce765O1SnLC9Qi+b7InJqTIMQDHBJlwbridtS0cW3DswnEHjwTTYDvI9Y6huWeYJWJADPQQAwugLOwrLQ0s1QLPiQ8ALsnznc8VXzoxIAbEQBkMsO8yEli+Bfa3jgOeBaoWrlcKSdPmIPgP+/nDfasB/BGk0wHOO3dD2OflvbWF8+Epa4/seLquDwO8rwsDPGbg3MwQwHubiirGKqx37PeEflwMZokY6E8GQhsZ+pOR7pSajaVP+KG4KlkMjncFtgNWBlyT6lD/TzixdBswHlgH2ARwCSek8kroBVBGJ4GLn32SshDzUkQ+DQht2PD5p35mYL0WDsWRnbKLgWOBx4A6SJ3qQyf4CD13KYszOFjplLAd4DPi6kgzD/PyT0Tq/oxFsp9kbto9SSpUAwKltKGhYoSet3Z8hz4Kh56HLK/9Vp/mRMH5a73dEnOiZcFAJjh50C0ZEUi4nbqaufW9l9r5WJj5LnKsU50okv+6xuFH81B/kpOS3LDHvmInpZf6gU1sv0PvpTqMhVgX7wlUSE7cfw04IRDGZfqMSwndSYD5XvAE62l1Gffd926KvUvV/g8McOHZhYBv/MXKx/fzjsDLvOiQfLbkdP4GfymLAprwjuCY4vPAHQDnX3zCd3BVfStfX455CY15zLzWeu5pxhnfveatt4ftNTA0xAVp08vQwOAMg29uBsMF0xulEQNiQAyIATEgBsRAVxhYCan+w0iZfTaONwkummI/jWMngmNz9nP47Zx9ygycqwmNDWCeRujnaWAicDNwDXATEJqvhlkiBpIZWB8hdwaWBZ4CrgV+CYTGJDBLxEBHGPguUvlOQkr9PveXQFHPBTkeJTokZ6n07sxJWMOCq07U54Zx/vdMIOvzrovzreuTvUpyspNRXjMBzi9fbSo85x93hGNfjHPP2XiDR443+L2H3HKcwfUGBNdVElzYzmPGPU6nE/rlJmCuLby1hetwnABIxIAY6D0GzkaRPpGzWJ38VhnKmsaqIXZkEwO9wwD7L0sDyxtYDufLArMApmyKi42AKv95NNcqcW+HT7h3ZFafsQZ69sW50Xd1AwtY+WIZDwZ+a+mrvhyJBP4N2PeV6XLtykU8kTSWgfmR80dLyj3HPFMAHvOAY53sm0w2TuK6WX6bob/RAL+tSOrHgPp9Xbwn2gDcRfKNpEMTOVVManNB7+HA1wF2xnzCxpMLQq8AxgL/BPgRnPJtYJOpZ9P/KbtesYGvUrIyxdLYHwG4IOBAgC+cdoQvqL2AHYDPAeS3W9K0+lAWT6EN7+yAxCT07CwSi5zTzvxwI9A8nnihsniiTKOuyzM2TaYKXPTSPSlQ/Mqj+OpJyvNSNHP8IFJUQnH5fotJv9WnRWOEJNh9gzh+6HrNADeaPADc08K9OLKNy8SexMj0PPL92S3hINMnofrmi5OqT+2npPpLDVenOpGa5yaEezwhk5xgMZ+JhCiFg/RiP7DX2m/f+7fwTbciprYxnNRlWN9Y7zDYuEAk9QMjJ693A2zhu+F0W6nrUhmIvbP6vf3nWP8iYMEI6wfBbm4kiARv28yPUmUvuro4kqumvSPuQ3k418V/IuCTY2HYHKiibQ2Ny/OMmfZH/mo593T5ceu/uPEB4/+Kgq7jIxjMkt8LvHYZxIAYEANiQAyIATHQXQbYZ+N/jieqEn7z/WALa+HIscPbwPnAEcBTgEQMFGXgEEQ8DjDHH5/F9Y7AVkDqPA+CSsRA6Qz8AB45R5giecbJKf4Upv4M+OaVQznnt0VJ7zKgOlGfe7sLsmKuW+TGsyWAh+uTxdJzwn+m4pLjXcpEHftnM7cwd2KclGD0OwewQgt74Mj36IXAMcD9gEQMiIH+ZiD1+3yVLGmsWiW78i0G6sPAmsjKLUDq/okVEfZa4OPA80DZsjQcttN/Kzs/ef2NQ4QNEyKNQpjfAN8CuN6hU0JuZ3EkxrUWjzr0UjWLgddLzC7bBGJEiT45Rl20RH9yVR4D6veVx2UhT0Um1AolVNNI5sexbmaRjZRP3vAZCupXQryrAd9iVr6YxwPnAb8DXgBcEto8VaRehe4F89SuhDhO/RjKMrPR4iQaOzabAKF8wxwVbugkz2sA90ZDlx+grvWh/JLm85hSJ0Kb0BbJl1xS6OcQyrcBOKUjFqqrdXnGkogIBGraPQkUpZYmXx0KvQ9SChLq9Kc8i740QosHUvLcb/VpAR+RLT3fU53a5BLKi68djGS/FHNVdTXLnK+vEqrLWdwqjqH7wPQ6WSeqKF+3fD6ekDA/DndCerUf2MT22/eOZT2oSz/tVeTlR8ChzJRD2D6fAXwJ4D9+CMmMMJ4G2O3eE9BtAWhhF0goQXxtSWwDcL+3/0eB+9ER/i+BvdMb1bdBmmX+Z1q2LSyHT5r6jjgFBdoJ+JinYJtC/1Wg0/cvz7im7nNPY8GfdwPw4NDAIpsdMH6FK09e7x7PPZBaDIgBMSAGxIAYEAOdZIDfTm4BOO7mWIffbkL/OAzmSoTj4N2AHYHvA9zAWcZ4H24kfcTA6igr649rHmkz6A8GWLckYqAbDJyERA/IkbBv3iqHCwVtGAOTkN87Wnnm97aFgPla176D5ol9zPSGXnWiHveR32l2t7JC3deAAy19r1xyI8pHHYV5CDpurEgRbrbjOIMyO7AkUOU/GWI6pnBx/RcAbmT+MvBLQCIGxEBvMMB122+0isI+E//BGNssts0+ecVn6JBeY9UOEa1kxEANGGC7xH5IHlkZga8C1gXezBMxEpbt4jmArw/2Nmz8Xn0DUFdhPzKPHIPA/wFS+6x5fNth14eC6y5c8i0ob3YZpGsUA/x2wm8UrrnmuhRE80J1uRPv50P9vve56NpZkY2aXctsBQnHOiKdatR8+eCGD6IsWQWOrgFcE+lcYHgh8F3gQSAmoc1TRepViOuQLZbPzB4aBL+TBUo83olw/JC6CLAlsDkwBsjbGUOUqcL/kHIu4JpgfC/EtH99fPj008Z+/6rO9eH9XFZ3FuIr5bl7KZC12WDj5pNQmEB0p+l5p/Y95YsBW2YKlTdky+LHjmU+Y7G0fPYQ33W8J75y1FVfRj1xlW1Gl7KlC71rAtGmmkJxQ7bMbxPrk+8e+fRZWXmMTbAsaAau+Dy0MWnxitMOuecklk9S6pQvbqb3taMp76TMh3303Xuf3oxfpzph5qvp52xbYpMnr3agkHXuB/rqp09v09VL7TfLllpumwfz2te+MEyesdD3EJ6LlRdnRIdwocGSwPbA4w47VSsC5wOsg6bwwyTHVo+ZSp23xYDvQ0foPcsE+7n95zj/8AjrD8C+ZyRMFeYdSnbKDzK+57TO74gYDRxbxDZKn4Aw1wD8OFamhNrrIv25O5G5bs49Obl5d87Jtw5/ZcTL6M3M6QwA5buDU/+ZAz+oSsSAGBADYkAMiAEx0G0G2Ofj4rJM2GcbBZwBsK8VE46ZbwOuBP4KPNUC/3nyBwGOgZdoHbfGcSUgJPxO8X1gYeBroYCyiQEHA9tC51tTwOCcjzmOJxIx0GEGTkR65uZfzi0dClwH/BvgPw7kgt/9ALaVFLaHkv5i4CQUlzDlU7j4vamwzrXQ0yKkxy5VJ+pxQ7nebaQjK1+C7tsAF4X3muztKdCp0KfO496OsPY4YynozgXWBkLyKIycm3/GAN+dCwGLGpgf5zEZjgBnA1yvyPxLxIAYaD4DrjHdJ1GsywJFyzYMB4JUatJYtVJ65VwM1IqBCcjNQwD7TFyPwj0UKbIaAv0Q2C8lcGKYbyCc659WT4T+i8BtADcB11mK5O8XKNAdAO9DVcI1Zj/2OD8fes5vS5rPANevsg8RW19jlpTjQ65rJThnM7kFfkcheM111JzDJjhe4Zpr7pOauXVcHMcU4dgq1P9J8aEw5TOgfl/5nOb2yAernyVWfr7EOiG+dNhJKkvmgaOxgGvzL9Ph5PqfgVRhA+2TGK+ueD4OGHbQFSGnLuSfL50i8jgindkCy/wRYC2Ak3k8LgGkyhoISPw9IYKvLHl4qnt9yFOWBMqcQUIfyUP1O3P2QnbiOXJw85LHVkQdytO9CQ599YZRy+A75L/oM5ZQrGmCNO2ehHgP2aYpdAcvqspTaAMwBxlFJVQnU/w2rT6RJ1+ZU+5d6J8M0Dc/OHVKngwkxHfsKQF7laZQ/yb0TknJE3377l87bajPZ9PqRAqHZYTx8VWG78zHHDgJ8c/3/bNZ4IqOde8H+u5DiDeTql5qv1mu1HKbHNjnPk4ZLk8bw4k/LozguNHXJq4J2z+AswEujuYiCE78c0Mhx0hc4DwTYMoNuNgdqHKC2kwv9bwM7lPTqiIcJ1BdwgnXkNSpTxDKZ9m2heHwV0DoeXkT9h2BV4BOyzgkmN3TbEKdzyQ/CmWT6tk5+yWcPOezxzgu/Bx6l9T9HeHKc6bjM3sOsGKm8BzJB+/1OkCeNtDj7n9q8u6T0HjeFyfTP46Tbsw9ZelPcxx31EbvjDlg/DVQcnOBTzbaYt+/nHbFaVu+5QsgvRgQA2JADIgBMSAGusQA54UfAbYAJgKLAj45GYajAF//n/00gmNayneAXYFjgA8CIdkHRn4/+lYokGxiwGJgaevavozZ7fC6FgNlMPBVODnIcPQyzrlB4SZDx/nua1vYGsevAJcAEjHwB1DAuch5PVT04sZDT1GlbjGgOtH5qrC3J8m5oN8F+KnH3lT17Mj4FxyZfw26cx36VBXHGQ8Ao4GngLkBn3DB9D99RkM/GuccY2xk6HynJ8IwDrjLF0B6MSAGGs0Av83zGyW//bmk232m2Fg0ZneVSToxIAbqycAkZGspI2ucAz0K+LKh851yrdClgDlf4Asb03M9wHcdgTj/sAnAflkTZG1kkmun+cM8GwKHA8sDIeG6Q/ZbNwDaWYMQSmNXGFdzBGAfdg+HXqrmMsD+xaxG9m/D+eXAw8BEgHM22fokjpnarXMLwQfHLPMDIbkOxj1DAWTrGgOxfl3M3rWM91LCw3upMAXKEit/aOFngeS8UXzpvOuNkd+wD6Kw4XQJP8pwoJhHQnmL8epKZ9ClbOlCtkC0aUyhhZhlLPikj7+38JNWyuR7U4ALCXicBwjJp2Gkj5j4+PDVI5e/uteH0P3KU05X2TNdyA8nZ2PyQiTAYrD/KxImj5kT0T5JScdXb+gzZPOlaetD96yMZ8xOz3XdtHsSqoMhm6vsndD58tRu/eEg1icpz6IvbuhdlDIQaVp9Ig++e+G7dyZ3HKyF5KMwnh0KUKJtUsAXN2p0S0YEEg7Vt0C0/5m4QccnoT6XL06m75U6kZWn6mPoXZbyHKXkLzaBcS+cvJ7iqI0wde8HtlNvSUsvtd8sj48P2lIlVLfz9tOuRKKjgV8DiwAuWQDKw1wGS/daKxwXkLTzzrfclnYZ4q2sNqG0zFqO+M7y5Z+bRUNSpz5BKJ9l2vgeZ52OtdFfR5g7y0zY8rU4rpmXt4GJlo3/AIWoWur+jgiV/0gYdwoFMGzs2x4BfNfQtXsaahfKauM6Offk5WOGgWFj3x2Ysr03wNDAByYPn3192K/xhpFBDIgBMSAGxIAYEAPdZYD9s38Aiwaywb7/KwG7beKcM+dPLwZ+AOwLhIQLui4C7gkF6jEb+T4QuB84o8fK5itOmWV+wpdISx+zR6LLLAZyM8A1EKdasU7A9U2Wzry8DBeERAxkDLyIE98GYM4fS/qPAdWJzt1zzkdvGUiOmzTYZytrbjOQVMdMX0BKsztSuwC6lx36vCrO7XPd3yaBiKnpjIMPYj3gZ8AKgE/4TYjv5NG+ANKLATHQaAbYDnMNxIc8pXjDo++UOjYWjdlT81nm+Do1TYUTA2IgzAB/5GUv4HLgUmBGwCeDMJwJrAKwz1RU2O85D5jJckCf2wJN2fybZZ/5fgw4HyCHvwR2BkKyLowHAieGAhW0sa/8fUdc9mF3BN5y2KRqLgPm+rGrUYxNKywK24Bzgdi6LH4v2Q4w84ZLSU0YiPXrYvaaFKPZ2QgtTmt2ydJy71sQm8XuFD++TSNs7MoQdnT28Tj6HfSneGwhdWjzVIxXl99QWUM2ly+XbkaXErp3gaomK5+Cb3Y02RnjZuBDgdcBnyzuM1h6Hx8+vRV9ase37vXB90ywLGU9l6F6mpLGf2xireutrOt2L/kfNl3CDvX9LoOlC9WPkM1y473sxjNmZ6Zp96TdOmiXv+prXz1JeV5CefPVHcZpp30OtSOhd1iW16bVJ+bbd498+qysPPJjKjcU+GQDn6ECfWgQwAnd5SpIM8UlJ5B8MovPkKifMxCOfZWi4rv3Pr2ZTp3qhJmvKs870S6vGSnAXyP2ds1NHhek1Fvy00vtN8uTWm6G9YnvXVt0LHQzEuKk/HeASb5EA/pbYeOvg4wETgfaed8jemUS6ku02/9hpkP3NmRLKXDoH0vEPqb0Y/t/AkjlIpqQXAjjmaEAJdjugg+O7R4BOtn3yrLehHdEllf7uDMUR1rKPXH9uKUzL7+Fi9h72QwfO+9EP8KVh6rmnlxpTdVdefI6Dw4Ohn+1HXYuBJeIATEgBsSAGBADYqDODDwdydx/I3afmd8B9wdu9AVo6Tnu+0YkTK+YF0NB+C36AYDc/BTgnEAvSxVlvjZC2HURu8xioEwGFoAzzpXYY+GLykxEvvqCgTcDpdQG4AA5PWxSnejczeV3mtC3juVh36Rz2elISnt7UuG3qrIktNaBafAXtPLIeATmAniOM0LCbwrsg0rEgBjoTQZ8cxR8b07pcpGrHquybeu3OYUu31IlLwZyM3AZYnweiLVHXPN5SG7v00b4Ni5XnVY19Yr9PK5larK8hcyTx3MTCnE0wiyZEC5vEK6hWNARaXfoHnLopWo2A+Z6vT9UXBQ++5tG0ngG9k8AL0fCydw9Bqru93WvZA1KOTSR06BiFM5qaEEvnXaKHy6ydMkIl7KA7tOI43oh09WVBfwxSqijZn/oSUkiVNZ2Fz8z/Rk9mXjHo7fVa0HxcaDoB2n+J4ofAux4+j5UfAi2FPHVS5/e9tmE+hB6NkN1xS5r6LrdNG4KOYfts0Bo4X0k+jRm+llkGs37F2Nx+u77l96zEG91eMa8Gc9haNo9CT2zIVsOSkoN6suTT5+auK99ZnxzgJHqLwsXesZD77AsftPqE/Ptuxc+fVZWHtmO8FcvfMIPfB/0GUvWxz6KfbXk9FLdhdrRWVOdeMIt5NFTndpXcbnw3Xuf3vRRpzph5qvK81AfNoWzlLxtEgn0+4i9XXMT+oE+rn16m5Mmtt+h9qWu/TT+l+GjgVGA61cg74T+DuA64FzgWOArwNLAOsAZQOzXmhGkqxLqS4TuWWqmQ3W63fs+SyATsf+S2G/t/47gigvQQ3IfjHuFApRgmxM+Zmv54f0vayyZJ2tNeEe4ysP5mrMtw3G4PgvY09Kbl3zGfw3MYSrbOC+jzWBZPg7UYe4pSMXQwOAVoQCwr7rpwTdzQbhEDIgBMSAGxIAYEAN1ZeDZSMb+G7GHzJx/3gWILe7nd6T5Qo4abvsY8s8+90PAfoD5PbxXF/FUWeY/g0Pf5spHYDsCkIiBTjFwPBKay0rsJVw/bOl0KQZiDITmKmOb3WK+ZW8mA6oTnblvnH/ePSEp9uF6RTZAQVZ0FOZG6O526IuqnolELDLOuB8+Y/eC3xW4WF4iBsRAfzHwZg2KW9VYtcrxdQ1oUxbEQM8xcClKdGhCqTh/tXhCOFeQj0L5TYfhp9DZ6wUcwRqh4rzyHsDVkdzODPvPImHympdEBNfamZ9A/9u8zhS+EQyYa98erDDHXAdzTMT/27Bz/eHESDiZu8tAVf2+7paqYamHFpw2rCiFsms2XC4HMbsrThGdb3HuDHDGCZp2ZbWAg9Bmn0C00jcAhxZKkod2xbfBLGVTDT9e3QJcC5zSZkYeQPzDPT7YcUsRX7306W2fTa8PvufFLmfsOsRXqD5mfrlBjYsWfMIF3Dv4jDn1KyG8r70+J9FXqEzdfsYSixAN1rR7EuI9ZIsSUVEAXzvqq5up2fD5TY3vCxeq8yntbdPqE3nwtWs+vc3dOFthXLM/srdxXeUpN4zxP5r5ZFcYZvcZK9SH+gzztJkuJ6h8wo1YRcV37316O51xtsK47mSdMJKt9DTUbrTb1jHj3Ci+VaAE7Cf+JWAvw9SEfqCvfvr0Ni9NbL9Dda+MPoHvXRtq12xefdfc3GW+H7hw4XMA//ER69vGwK7At4CfAw8CTZHQfSljTBIa67fb5oTyNznhBowLhOml9n85lPMXgbLSxDq9I/AaLyqUD1m+X7SuO3HZhHeEzcNiUPwB4AeuTK7EyRGti7E4hu7x4rCf2Qrb7iH0ngq1J1m6dZt7yvLlPL4z5e1rMUvhf49gB/CUKVM2d0aWUgyIATEgBsSAGBAD9WDglUg2OBZoRyYg8mERB+xDfjgSpqnmbZHx24CdALs/zPnOXtwA3Ikyc86Fmz9uBV4A7gW4CI/zML3IKYolqSEDKyNP/CcHtrA+SsRAXga4wNMnb/gM0vc0A6oTnbm9n0cycycktQXCLJUQrglBvurJ5OkefVF1rO16s6DjsxGP6yhCwvlyiRgQA/3FgP87TWd5KHus2onxdWcZUmpioD8YOBHF5Lf7kPC7/o9DATw2xjsXsOcZb4Fuf0+cpqrZtnPvwYORAoyB/QuRMHnMvH/2+jLO9XwjjxOFbRQD5j/snFBRzrkOhv/U0n527eQ4XhtvK3VdSwbK7vfVspB1zlS7i0rrXLaUvMU2j5gNW4q/omHYMfGJ/TL1hQvpuaDRJ/f4DAE9F6FvHrAXyXO7CyUD2Zlq8t3LoVhE2PmccJEzxefnPWva38s8wWL/BTCL5uPXp8/iZccm1IfQiz723GbljB1DdS5kM/1ebV44zvdw6Iqo+N9PXPIclJe7DA5dqEwhvh2unCrfs5HyjDkdFlQ26Z6ENmb4+CxISynRfHWo3foTaruytrdIAUL5StkAzDSbVJ+YXx+XPj3jmDLOvHCcc5AVqreOKIVULyEW/1OQT/geiC2e88VtR898+eSDPkOCfjaEOTwQjgviiorv3vv0djrjbIV13ak6YSVb2WWo7fW1gXkysw8Czx+I8CPYqn5vNqEf6KufPr2L0qa136H6FXqfucru0vnqdrv1bRskdhcwppUoF56uB1zYum76IcR9GWOSkP9252o+0Cb54yLxe6H95/v3dwCPIfkajGX+939fWotYhm5sAG7CO8KkiffuT8CChnIizncGzP7+Qbh+3Ahjn3JDwh62ssB1qC0P2bKk6jb3lOXLeRz3441eGhyauunAaX9PObhpwCiTGBADYkAMiAExIAa6zUBs4X27G4BZvqsSChnqhydEr22QwUDOuPm63TmJgPuumTpRZvJ2GrAOMC+wArAvoM2/IEHSMQY4J+iq7091LAdKqJcYCG32nNxLBVVZkhlQnUimqq2AX0+MzTlLzpE3XfgtfztHIZ6Ajt8JypTXA844b91O2/aPgG+a2lmzEHEtsxgQAzVlgJvE6iBlj1Vd442snL06p5CVT0cx0HQGvoQCPBIpxNawbxkJY5uPhWJ5S/k0rncA2ulfWS5rc8m5PpYtNof9Q4SZo4Rc88cdPmX5Ia+fB2J5sKLpskEM8MdsMnkmOyn5yH/YPyri83TYGU7SDAbK7vc1o9Q1ymW7i0prVJRCWYm99EIbcwsl6IkU2kzjW6ztceVUL+7UvqdcIGDzmU6FYQufEfoieQ4thuSG43bFl6cU32befH7y5M/3kgxtdjL9+zY/+PRmXJ43oT6EFsPPZxeo4HXoXn4g0Sc/svNF5hNugFjOZ8yh/6wn7HHQpw5ezHpsu0t5Duw49rWPzzJ822mFrpt0T0L1rFPvnxCXts3XxoTqlu3Dde3zy7Dt9FNC7YgrHy5dk+oT8+/j0qe3y3wdFKHNEVxQdLQdqaLr8yN+D4V9rUiYss2hDcBs64u2d8cg7sKBzA4GbDGT79779La/OtUJO29VXMfa5XbuxaLIMOutT26E4f98xhL1TegH+uqnT++ip2ntd+hdWrRtMXkpu5/GZ+EE4A8A3w2ZbI+Tf2YXPXAM9SXKGJOE7nue+u6iOjTHEEo389UP7f9ZKOzyWYE9x3OhP9tjK1u9lOUw1O+wgpZ22YR3RFZYjhMuAlbOFDhybMzNvPbmaX4c2wMIySkwfjgUIMHma2sZNdTHyFybz2bIVxY+dnzGEyB17skT/X314MCwse9fOc6GBhbe+Os3mvfIEUgqMSAGxIAYEANiQAx0jYHYBt+YPSXjDyNQ7BfAQv3wlDTqGia0MOzVuma6zXz1Y5nbpEzRG8qAb53Isw0tj7LdXQZ8m1a4BmNKd7Om1LvEgOpE9cRviiTMuVA+bz7emZtdgdg/0mS4Ogvnh8351yyvZ+IkVPYsXJ5jqE/Yblp3RzKSun4s4kZmMSAGGsRAOz8oUOdihtrSXp1TqPP9UN7EQB4GuM7hi0BsPMfv86nrYjZA2P0BU9j+fQZ4wlT22PmdKM+BkTItBPt3ImFiZq5LO9kRiH7vcOil6g0GuK4sW5/PcUQVa5T4z6Rc/4jJZPB2XMTquRle52Kg7xnIHtx+JaIuG4BDG73mLeHmhMq5Sk7/hyH8VyNxiixUDHEQWngdycr/zL7JSNcE3/8itU7MhZohLu14vuvVHYa3oPu9Q+9S+fhlWbgYPyahMtSlPoQ2OqyAAobssfJn9lCdmzsLFDneC/vlkTDt/jdMTryv6UiDnfsfO/Q+Vai83X7GfHkuom/SPTHbFrusoU0bdthOXYfannbyEGqH2+mnhOp1ahvSpPrEexC6RynvB/5H5RMjN5ODrU9EwpRh/gucvBBwxHt4HpDaXgdcJZteDITkM8v/upZXvokIX49ECtXlSNSeqhOxspZhnzXghM+Q7xkLRJtqYnv/R2AeT0B+oNgFiE1+eqLnUjehH+jjObWvS0Ka1n43rZ/2A3B8sFXzHsX1OEvX9MtQf6GMMUnovvueg1ROQ33JlI8odeoTpJY5T7j9EZgbRUNyD4xfDQUo2bai5S/U77CClnbZhHdEVtgTcLJVdtE6HorjXy1ddnklTs7KLhxHvqsvBmZz2FJVoWc6pc9qjg9D9yI1P+3OPUXTeXuOt/42ODjdhutp4g0bPsPm0yh0IQbEgBgQA2JADIiB+jDA73IhKWMDMOd6OEcRktD8eChe3W0h/jgX1ovSj2XuxfuoMsUZ4LyYS7oxl+HKh3TNYsD3XaTdTXLNYkG5NRlQnTDZqOac8+OmXIKLo0yFdT4nrne1dE265Lf2LzsyzEXu3ABctoQ247W7QfeRSGb5XUMiBsRAfzHQq30mja/7qx6rtL3HwHgU6ZRIsZaC/aBIGJr5/f6XgL2O+HDoxgG9LmeggFdECrkf7MtGwoTM7CuvZAXgPfyhpdNlbzHA9S38Z1CUZ987lPp3NXg7MeKRc4k7AlyjJhEDYiCRAfuFmBitZ4JxkiokKQv0QvFTbaF8zJvqJBDugYDtKNhCC5uzqFyAzIkvLvaOibloMRY2s4cWWabkL/PjO/r8c6Ivtrh6LsPpIjhP2URlRJnudOPpNAMD3Oj0ikPvUvkWgjJfs7siWLom1Ic3rDyblwvjYh9TUfA8xFWeZ//7SN/3EYJZ2xtw3XPaUsQ1EOKEMTvdoYlj27fvGWC4bj9jdl7bvW7KPQnVM99z3i437cT3PTOxNjSW5oyBAGyji0qozoc2xdjpNaU+Md++epP6fqCP/wNCAzr6uhDYFGhXOHj7NuBqgzioOyGSwNKwXw+U8SuMkaSmml/G39C7+ijYfc/JVAfWn+NwzfoVkyL9qsxnL9WJrExVHmNcF2mTFkCG+c9CVvVknItNuXl8gsdetroJ/cAy6i15a1L7HXpnudrIvPXC5z9lLGSntSAUB9pKXM8K+O6dI3gjVFWPSciZT0IbCX1xTH2or5N6n+rSJzDLVcb5FnByYsTR67CznxKqAxEXuc2c/M6E6U/OLjp4bMI7gnR8GbDbIX70OpnGgDAO/1mBT1aE4SKg6FxpqB8YGvtl+anb3FOWL+9x3FEbvTNlaOgabwAYhoaGNtxi3wfaHTOGkpBNDIgBMSAGxIAYEANFGYgtkv1vUcdWvIeta/vyaVvRI9ch/jjm6UXpxzL34n1UmcIM8J8W+OaWtFgvzJ2sbgayxaa2tRtzY3YedN0dBlQnquV9Objf3EridFzze0CoHd8H9nbXylnJduzyk0iJa/1s+T0UT9rKEq5D68diY5BY8h+KBLg7YpdZDIiB3mOg3XalroxofF3XO6N8iYF0Bo5A0P9EgjPMwpEwXNuxhBWG/bh+2py6G8r7vMWBecm5mtg6WzO8ec41Ct8zFThnG8w0Q/1aK4ouG8jAi8gzx4Zcf2P/k6h2i8O5w0uA2DqRXRFmAiARA2IgBwPDcoTtxaBckB+SeULGEm0LBXyVsaklNMHDRaZ8eYcm6laB/SZgT4DCl3rog/ScU0Pl++NblE4v7Jy0IyxbaHG1ucjSlY55DxZEgE+5AiXqPopw37TCpmxyMqP4PqoxTAr3TagPoc4qy8k663puPgb9tQAncGNi3lc7bMhmh70VimNtpXHNdvZ8gHUnr+yFCGOsSPzgsRtwu6WPXdb5GYvlPa+9KffEVYezss6fndTo6Gt72MbGNs2FihFaDD9TKGLE5ssvo4XStN02pT4x36Eyp7wf6IMbXXYHfB9XGYbpXA7sC7CNyysrI8L1wMUA23NffedEDcOFhH2UG4E1QoE8NraLmwLLeOy2mv2fa2ylcb1syx7rP66FcOOBQ424Lxjn9mmsn2KHN697rU6YZaviPNY2hJ4LV344SXIHMNplhI59wO2AKz32KtRN6AeWUW/JXZPa7yb107YHt67x2bzQc8y4GTAL0AtS9Zgk1Oa00/aT+1DfLDYPkt27OvUJsjy1e1wRDn4NxDbW740w97abWI747M+wf5DJi9lJh49NeEewDfqpxctLuN7D0rkuX4Uy1s/dCmFOckVO0IXmEUK2zLUZpg5zT1m+gkcMBscGAwwNfOCd4c9sGAwjoxgQA2JADIgBMSAGusNAbAHTf0vKVmh8xiSeKimdurl5M5Ahjjd7UfqxzL14H1WmMAOh7x+hjWNhr7L2MwO+93Gvbmbp53udWnbViVSmioXbH9HM9YGcE+a3nWeASwGfLAcDv/80Ub7qyfRPPPp21aEfcgjZUtLlt4SQhOb4Q/FkEwNioLkM9GqfSePr5tZJ5VwMZAxwbpXf8ENr7biv48QsguPI/udelv4BXO9q6Xr9kvPH7MeHhHsmPh4K4LEdCb25ToHB+IM+5FnS+wxchSL+HxAaCxZh4SxEWjISkc/+ZZEwMosBMSAGpmPgX9Cwc+EDX2JVy2xIgBM8vjx8pYQMfDHgP0t3HMKsBzA/w4DFgE8BVwNZGB456ccNifyPD6bePD8atrzyK0QwfZjn383rzArPTqLpzz7nptyQ7AyjGYcD528AM4YiOWwLQ/cYYPri+eccYX0q3h87vnm9li+ioW9CfWB2uQDALJt9Pgn2AwFu3toFOAfIniUu7OV9Dwnrsu0zu+bGtjwyAwJfD2TxXceHYF8xh9MvIGxWHtPfPjl8mEHr/IyZ+SzrvAn3hAvXzXtrnv+7LCJK8sMP+mb+7HN+8Ckq/Ahh+8uuDynqFPGOD/i9IaffJtSnMt4PJi3HBPjL7g+P7EttC8TeiTMhzHbAtYAZfzyuQ8J353OAGcd1zvaSz9RSQEzY3zkbeA2gL24a8W1Chmka2RNXrvRNHTfzfg9YGhgBsP4sC7D83PRshuX5ywDfZbY+u/4zbEWkV+tEES5S4zyGgBnv9nFyopP5EI59u38EfNH3k8DGQKel7v3AsuttE9pv1oFfAXady667PRay6+jJgbxmeeZE/j+B64E/Ahe0cAmOlwHc9H4jcDvA98hDwKPAE8DTwCMA3w+HAysC3ZQqxyTkJuPMPrZ73+0xrO1/kRyk1qVPkCPLzqALQDsBsLmwr89yxq5GOQvcbgk8CJj5uKua5KJe6/6OYH/pLYsr8vb5aMmmDXC6w4fJP8/PAdh/zSPtzjHYz+07SLxbc095yj0w5oCbfj7mgPHXe3HgeL47JGJADIgBMSAGxIAYqBsDOyBDdj/QvJ69pAzfEUmH85+9KJwPNfk0z4vOd9adp34sc93vifJXPgNLwKX5PJvnHMNKxEBeBsYiglmPsvPYP2fMm47CN4cB1Ynq7tW8cG1/89jLSG5tnGfPoOv4FyNsU07ZP5viKNf/q7AAuzvSy/jkuod25GZEznzZx2vacay4YkAM1J4B+1ti1gbwW3svisbXvXhXVaZ+ZeAXKHjWZvmOGzjImQu6x6247Muu7AjbL6rLLT5sPjkPPSwHGcsjLNdDmn5uy+kjR3IK2icMcI+LWadc51wTOLxP+FAxxYAYKJGBz8CXq1ExdVyIvFqJabpcHRrJx62wt/uReW74sDtCZjntcy4ytHW8ZoObfYjewxOG4bjhYSYgVRZCwImAK03quDCcC2OLyiKI6PNN/RkRxwd44pNT/lcVLiQOycwwfhN4BbDzcWQoosP2NYcP0+dZsMc2YdW9PmTF/mOkrGa57fPfI+5g5shx3Cbim8/AJ4GQD9vt/FD8DbDzYl5zYzI7N7MCPpkHBg567ElobqT4si9SRF/3ZyyS/cLmOt+TBVGqhwGzfpjnvP9jCpe8/Ij8ZxRm/uzzs2Fn25JXPowI7wK2v+ya74aiG3/Ytmd+7OObsOWdDKhzfUJxBsp4P9BPJpwMuBCwufNds31ju30ksDdwFMA8HQtcB7ANc8XdDfqYbI4ArwGu+C7dnQh7InAAcAxwKMD6MBZw9Te4yWYEkCJzIpDLhysfKTouYPgYsAzgC8/+w6pAXunlOpGXi5Tw2yKQ7x5k+gkIcwNwLsA6diTwXeBU4ALgHoDtdxbed7wMYdimdEPmRqLsw/ryZus7PS4ou96S47q3303rp52co/7Y9ano9ZlIk5u5uyF/RKJF8+0bkwzC5yaA793I9B4B8vZVEOV/wvdrKN+nw5468V+nPsH/CpjzhGNyzq2EOMlsf0K4SwriUsT7DfDbFv6AI/1dAVwN3Aj8FbgbmAjwl3GydM0jw3VD6vyO4Bj+dcDkied8p+YVjscfAGxf9jXnBH8MHALMDoSE+bPjm9cpcwwHeHzwvd3puadQWaezbXLATdt6N/9yY/CB468b/Y3r+b6TiAExIAbEgBgQA2KgTgxsj8yYfTb7fHgJmZ0XPkLz33eUkEZdXSyBjNmcZtccO/Wi9GOZe/E+qkxhBkL1/KBwVFnFgJMBzptl7wfz+JQztJT9wIDqRHV3mf901XzOXsK1vXaJ/9zVDGOe8xvo0kCThPO7Zhmy870qLERoA/CzbaTLsYVvzQT/ceaybfhWVDEgBurPwIPIYtaGmcf/V/+sF8phaNzRq3MKhYhSJDHQAAbYh2EfyGy77HO2ZfaaoF854uwGXT/Loij8q4DNn3m9aw6CrrR8cU0113NLxEBRBlZHRNYjs07a52wPFimagOKJATGQb3NbU/naDhnftJV5dhDYmVgKWKmlix24SO8+4IkWOGlC4cJ/LiBNFS4W3AfgAnRuGP0QwBdlygI4NoZXAfcDbPi46JFyMfDc1LP4n80QZGw8mDfEj2A5DCAflD2BM6eeuf9wQp6dMoZnnll2/veVFYDRAIWccHKQ9yfWmJP/3wGPAvRDuQb4z9Sz8J+PwBz7iH4jwtwEPNlyRa65QJfyU4CbmXzCl9PfAN6jCQDLPhPAerYMQO7Z8TKFcU4GDjKV1vkGuN4YmA/4ILAGYPuBajphHSX3DwOTAC4wvhQwhXmqQ30w82Sfbw8FF0/nFd7r9YHsOVkT59sA3LzOerZs64hDVDh5ehfAxcHk8wSAC/V98gEYLgK29gVo6V/B8ULgXwDr9LsA88dnYUuAfkz5Ny4+AzAvMWniMxYrUzv2OtwTdmrXahWC76CRAO/zQi2d78APKJcDDwKPAW8DFLaHv596Vs0f5m3xlmu2P3xfbgsMa+l8B+aXGxn4vPDIus13R/bMrIfzVQDKHMBiwE7A3EBMXkQAtst8Dun7EuAOICTnw/i5QADyybb/PuBZgO+WvwD3Aj6pQ31i3jYAqno/2GU/Egpi0DaUcM330xiAbW1MlkcAvsvYxpUprLdrA3/L4XQ0wl4HtMsJ39Fs91nnPgbcBvjkHRj+ALA9YBvAfLPfkr0X+rFOoPilCPtW3wV2AWLtXLsJPgQHxwK/bNdRm/Hr0g/sZL2tS/vdC/20on30Nqvt1DHZPu06KRC/aHnZT8nGJJwD4Ob2xQGOEflOmwtIEbb5HNvxyHEm3z9ETJjeaZFAz8CejUf4TuLY685AnLr0CQJZ9JpOgWU/r7V+hsuQpW26lK26vCNY/AWAI4DlAPYZ7ff0q9B9GHgcyCvs/7EvNUNixFEIN7EVdk0ceX84hl8EKGuO4afwtTfgkyEY2Gcte+7Jl16yfot9b5tj8vDJv0X3eLgv0uDg4LlXn7TuOT679GJADIgBMSAGxIAY6AIDnPPmd0eX8JuNt2/jiuDRfQH68zw2qjl2Oz1gb8c0ApE5LuVYdFED7Gfz+9lzwPMAx5vsGxNvAGXJYnCU9aFtn7+C4ou2sqRrzgFtDCwNLAEsCYwE3gSYnwkt8LvA1cAUoCzpdJlnRMY/CewCcNx0KvAToEzpdj0yy8L5FH5T+jSwDLAucDvgEtZ5zsNxzMgj47IskwCOIYkrgdh3JgSpnXT7nvC5esjDysHQ87tgXWVWZGxHYDeAdWRV4EXAFs7lrQmsBKwIsMzvAqw3jwAPA5cDTwJ5ZBCB6WvlFlbBkd+KOefH9ol++V5iPe2UdLs+sZx/AbZwFJg8cN6lbFkcDlcHljbAusG6wHcj34s3AuMAV/2AulRhWz4GWA/4IMA6sQDA+sJv7C8BfOb4nXwswO+E7cjMiLwNwHcH6+Bo4AGgDPkInHwK2BrgM7MBwDLklX6vE3n5Sg3P530C8CEjAvsOXzeuebo7cJalMy/53WE/U1Hjcz7bbLvnsvLI54rtC/vEVUiIw2eRIJ/xvMI24c/Alp6I34f+CI+tm+pu9s3Ncs+Ei00B9iO3AvjeXQ1wCdth3kN+Q+A4YgaA74O7gZ8A/wKKSh3eu2bem/BOMPPbS+OBeVAwvo85jlsKYF17E5gAsL/J453AP4BM2AdYMrswjgyzhnFdh1P2bz4JsL/BMhYZq3Z6fL0w8sl7wf56BvYb2X48BTwJPNEC+2bsL74F1Fk61eYMBwnk740W2P+bAsSE+ZulBfqYFItg2HlvTm9dn4vjxYYt5ZT9AN6/LM9DnkiD0DOP7FPw+CiQR5ZHYM1jvMfYl3A4O0LevrDzXUvZDvjt1LP3/5yDU/rpd/kGCPhhgITHYFsG4HslJHwP/cEK8B1cH23p6n7ZqbYuhQe+M+rQ50zJaxVh5oTTfwJ8j/qE7e0WwJW+ADXUd3tMwzq1K3AewHmhsoTjHo5zsv4Mn6V5AY5ZOaeTKjMiYLv9Pldavdg3c5VTOg8Dx0PPBqNs7OpJz6ceWUEePuJLzKPnSz8vD5z4+pTD3145fWUTJ1/JGS+U3y868uVSjSmQ5gWGIzaYoXzktbGDtYnh33f6o5LS5eJQl9ShPrjyZep+gYs8/E5CeDb6phyBizw+QmHnNx17zmeAnp1svhhDvlJsfP6OAdiBSJUmPmOpZSsartv35HBkPOV+p4bhJFKVchmcp+YlFs58Zk4u0W/KR6Ui5dg9gdhu1ydmser3g00DP9Q+AMTud6r9Vvja3E4k4Zpt4TlAajqxcH+DL060FZEdEOlVIJaGz3414i5mJEw+fGF9evM56Nc6YVBY+PSaAtz77olPfzPS4OTksMK5LD9iHfqBna63dWi/e6WfxnvHyR5fna9CPwXpfaz8RyHJY7tjEo6Fy+Lk9KQcvzceyZum+V7xJVOXPoEvfz59kX5hXv7KDH++ryAd0tfhHcGixsZR+7bJB+e12Lak3LuRRlpVzTF0a+7JKFrx0zEH3nRU+FeAb76wuHfFFANiQAyIATEgBsRAJQxwA7CvLzi5hBQ5D8HF4b40HoaNiyPKlhXgkOP2pwFf2i49F3qMAziHxQWO7Qo3l7jSoe7Mdp074i8H3VnAK4AvXVv/H4TdDRgBlCGdKDMXUvEenQs8D5hlugDXZUld6tHSKBDHYHcBZll5zjkKW5aE4grADuu7vgNhObbkAr26S13uyRIgysfnQTUkkbztD/wZeA0w8852wxS2BYcCdjgzTnbO98TvgdT5StZXtjlZfN/xnZbf9XGsUupSn1jGywEXHxNLJIDfZj4BcO4ldS6I89/M25pAFcJ7zLmSlwFX+X268Qi/J8D3QaqwbfwycDHwImD65lqqosK+DstxEsB+jemX59xYUUT6tU4U4SpPnM8jsHmP+Cws63DA7/EvWGHNeKyzszvi1VG1h6ccP644s7t70iWP7KMXkUMQybwP5vntsM1SxGmFcerQN58H5dsG4PcWu63lOg9bOAZiP+BtwOTXPOd7pIjU6b3btHdCL40HWMf43r0IeBMw65bv/N8I902A79QHPXFuhb4Owr5JmWPVToyvyRv/4c9lgO8e+PQcM/we4JzCAkCdpNNtDuegbJ5Yx18BOG/Bd9+TwDMA+xhsg98B7DibQJcqxyFgFv+fqZFa4ez5QPaJXge4Tpv/EOgp4FmAOnvswD51THqp3YqVNY+dbeB4ILtvriPrx3wAnynWFzPM3biuW38HWeqKjECq9wAmP/Y5+44hmQlG+71CnzOGItXM1um2zlf8OvU5fXnslP63SMiui/b10Z3KTAnpdHtMw39c9FeL05/immP2duWzcJAWjDRkAABAAElEQVTdG46V+M7OrkfhPCZl9/vM9Hqxb2aWT+eJDHAQlFXKMo/sCOaRkQhcZvr09ZE8GWiF3QBHdnpT8nITwnHg7xLz4U/xtVrLyc44poRPCfNFV8Ycus0KpHmB4Wd1nJ8NsBPpGnyk5JVh7gQ4wZja+H4HYVN9h8JdCT8+6XZ98OUr08+AEz7DbwGhMtLGQRfvlS1VLc6107Gv2bE7CeDAJJZ3284PWiz3HEBe2RkRbH9Frzv1jOUtY9Hw3bon++S4J2xjWN/5UdF3326ErUo5D859aefVz29k9MiAX5bb/KDOc34896W3H2wx4USbGd9sv32+t485Nezdqk/MQifeD0ZRp54Ox989gQcBk9fU88cQj5N+awDtCgfwPwQmAanpZ+E4YXc6sArQrnCQdz2Q+U45kr/tHAlvntMP0zKfg36vEw5Kk1XXFuA+dK/ZH7kX+DnA/vIiQF2l2/3AbtRb3otutt+91E9jO3omEHoeyrZdxRvYBWl3TLIq8lwWF3yHpQjfEXnTNN8roTTq1CcI5dO0ldm/zctrkfC/MjPfpfNuvyNY7NBY/jbYh5XAzRfgwzc2eBG23wFfBWYGMgnlK+/9NsdL3Zp7ysrV1nHMgePXCm4APmD89Zvsf3ORecy28qXIYkAMiAExIAbEgBgIMGAv+DP7cuwjtit7w4Hp0zyfAtsn2k3Air8Rru0FIWaaec7vgq9tLP95L7lYz5fmKQnOOPZMkSUQiGO+0DcVXz4y/aOIv25KYpEwZZaZCyNHAVsCBwPnAFz8zbqT5ds+ngFbu9KtesSFh6sBuwAnAlcCTwB2Gc1rzqmb8nlc/Bcww6Se/xPxljKd1ei8W/fER8EWMPh4/RZsnHtdEOC8OJ9Pfs9ZB2C8zwC7ASOAsoU+uUCM86/HApcBsTpkzt3z/t8D+Mrm07+FOKx7PlkShmsAX3yfns/60QDnJcuUutUnlu1ywMXDxBIKznqxP/CQJw1Xui7dbxB/DqAMGQ0n1wGudPLo3oCPhQFTOM/E5+2LwPeAi4AJQMjvR2GPCReBLwew78I55J8BnJt7HQj5ZntQRPqtThThqEicvyOSeb+uDjhxbeQx47IeNEH4fjfzzXO2r8tUnPndHelm+Xi6QNoct3B8kvkwj2xPZi/gs6oofPefB3Syb862fkNgb+A04FrgKcDkyT7nmhFT6CNlwwLD5JFuvneb9k7o9fEAxy6uNsmum77r0DN1Q55KWULYQfgYBVQ9Vi1zfO0q9kgozwFC3Pruh62nj3bnUOCibelWm/Nr5NzmpMj1LokMsG/6jJUm166kytcQsEj+GOe7RiK93m4ZRS3tlPfpHSDEP9cg/c4Kw3XEywOS9xng8x7i8UXYQ+OxI6z47COvBzRButXW1bnPWYf79nVkIlQnaePYpex5rirK3o0xTVaOQZxwD8MdgI/P+2FbEygqiyIi2wif/1GGY+aH11X3+5jkSOAcoJf6ZihONcIb0+vCD4QfAzgByv8sw0l4IjtnRcnAyjwMYAPDeDyywzhzC7O0juTtb0AeYYeP+Xi7hSwfPFKXXXPSJkuXaTMejy5wYMjOTV5hGT8NrAbwYwYxCmDn6jHgUeAXAD+MhISTwa8Cr7SOLAM7AswzuZqjBU42sTHK8koeGJYTwln5We6MG+bDvA98cWbc85iBjdjTQIqsgUBM62WA+WV94H1nOvTPPM8GMM/ML8P9G7DlA1BwwSL9rQxwsDmvAdrJCRtH4j7glhbuxTGPMF9rAv8FWF+zOpsdmX9yRc5ZX816avJF3u8CfNLt+uDLl6n/EC52AvgSWQRYCOBz+CTwMMCOwZ8A1glbFoOC4P3PuLOPrH9mnSOf5JD3MzuS31sBhs0jfJ7XAfhBJKszC+J8HoDPwLMtPIHjTcA1wANAO/IxRG7qM9ZOuVPjdvqesG6tDfB55X15O3Dkc51J9lyzHhJsowjW3zuBqoTtID/Is51kHWV6rPfMv3nkO5PvpqztYTvK8+xIm/nMsE3je4NtEv0STIOgb5fwXtnlJwcTgElASOaGcRTA98TzALk3hfmbFcjafqZzuxkg8bzT9YnZ6tT7wUfBMjBsBmwAfBCYvwXmi+9PfjAh5/cCf2+B7yHWmTKF3I8B1gMWBviuyMC8PAZMaOERHB8CrgJY58qUZeFsN4Bt/KIA88J3FDl4DmAdvBn4C3A34BP2Ldg+sJ/CvgRBzlgWgnU0q7M8TgAmARTa1wSq7jMwLZfUpU648hbTrYIA5JbcEWyjsn4C240pAOta1iazX5C1dWxHyD3D8X4TjNsk6WY/sNv1thvtN+tGr/TTeP8OAY5hoQxhX2ECwCPbWz5TPqEPPkdzASNb5zh4hf0FvnfYtnZD+I7ZCdgSWARYCEgZk7CvsSqQtTM8sq3gke0+y0Wwzc/aG7Y5MwFsn7LxCI/PAg8AMeGzvRaQ9bl45L1ge0W/ps8sDb4rJwF5pCntP/u3KwLknPWSPLCOkn8e2Qc3wXuRAadThZzyfvOYgfeL9dgF1m1yTfCcyMLx/tIXhenyXcN8ZHgc5/cC3RaW89PAasBSLYzCkfX1MeBR4BfAZUBIPgoj+zVZH4f8s8xZXeT9IWYHzLmjxXC9IPA0wLiMMx9A3QTgSaAM+RSc/Lrl6GYcrwWuAf4B8P7YwnwRLAefZdeR95L8mc+0/dyxP3ErwLC28Ln8CLAGwD7mAsC8Bmgnp2XMPcFN+7LDDpfM8OIiH7oEnubxeRsaHLjq2pPW+4HPLr0YEANiQAyIATEgBjrMwLZI73eeNNnnZf+9qIxGxCsBjgNc8j0oj3QZCujY5zwKOBxgH9SWv0PBfufDAMu1JLAs8HFgJiAkp8J4EMB4eWQFBGa8LwUisb/N/BIcIzEv5It9XY4NeM6++mWAS+aE8lvAfoCPZ1c8n45jjjHA7b4AEX3ZZeb9PDaSpm3+IRSH2srE627Xo68gn2ck5jULxvvF8RvlMOD7QDbWpi6vsA5sD1yTN2JF4bt9T+xicR79e8DWtqHA9RKIw3moMuWPcJY3b5xjeB7g2PtygGPvosJn9gdWZM4HjgXa8XsV4n8CyNsOI8o0Urf6ZGaO3G9pKlrnj+I40qFPVa2MgOcCnF8xhfNL/wb4fvx/AOcAmc5WwFKAT+6DYRvgfl+AiJ75OAXYIBIu1cx8zwa8YUS4F+fLG9cppyzzQ5GAfJ+fHQnjMnPui/NmeaVf6kReXtoJz3p3g+WA/Sy2nS5hvWBd971XaVsOYD2sq6yFjN3qyBzb1c0c+jJVu8PZWR6Hz0DP+e0UYbvxbWA7R+A3/z975wEvSVHu7ZmzLFkQFBCJZjEHEIkSFlzMCRMKKAJmWQTEcGW96jWgIKIiKoqKqJhBZSWHRS6KyidmlCBZUMAAAsvO9/9zT2Nv0VXdM9Mzp3vOU7/fe7rqfSs+VV1dPVM1R7pDJB+VFH2GXZBkpKqZXJt7Dr+8z9b5+e91QOa+IM+eWSBx/ZhsCxL2zNSE527bngmT+j6wpQaF14hFz//bpL9B4vffNSSDOr+/7DRo4gHSvUNpRv2uWvf7ddjMp0nhz2xWCA0K/0zideIfJbdI1pU8VuI1ub/nizmvZ0+OGUesn+k556Vqn9feG0rmS+4nKXNew54huVLid/Glkm9Kfi4pcy7vq0GkIxTeL9DFglvI8Oxp42q6un+L7tHpKHe/M3p9erXEdfY9Zzep89b/tW50fz+urN/UZ/Z7Kr7f7XDLEviKgi9fVrVM6DCF/Pls6DaUwu/EK+cMn5V/n1y4id6ZnuuauOZsSj89RRVZLJmbqNB1sj1R4mtT3Uy+05jJVpLPSB7lQIn7p+x+5/11SbzQ7Hd8P8d2CA0K3yj5mWQ3yV8lduNY97mcSVubuU04CEAAAhCAAAQgAAEIQAACEIAABCDQCALPVi38IVIvJ/6S0l+q+AOxQZw3Ky2UeNNCPt/Qv6fsOAhAAAJ1E3iAMkx9cV93eROZ3077L943+V+A9z/35C0W/BjOE9n7NAoCEIAABCDQSgLPV63Dd84sXPQjLVUa6Q0Uu0tuTuR9tGyxwxQy9eW8Ycuba7J6568nSe9NIzG3ngxHSvw+n08X+s+S/b6SMjelCM+SnCoJ8xg0bJah82Yvb7L04YkwX/fbBRJvBPUma28A9QHRorhhWoe9seWxkqpulG1+pypRVMeUzmkGcU0YR+7TVNuKbE9TGvfBJwZIW5SfdR4r60hm2jWhTzIGm8hzgmSpJMatH/3tymc5Sd3uRGXYTz0c9z6S+ZJ/DJA2LMt88pvntlP4lhrydTkfkgzjmjSeitrhzfQhT4evKIpcQefnhA/M3SEJ8/2xdOtJipyfzTtLws+983m4TvkDY0X5hDqPs8MlSyT5vOz3uLlU4vHrfl4o+ZTEmzF9r4Tx82Eflghdqu75tHn/mmEmBeFXSZdPU8Xv9g7qJn1MDMplmHTfUeJ8v3ks+15JuR/KmE8T+p+RStwA25ci9X/OGOq2V6RsM/RaY/mgDg7fT/IkySslH5b8ThIyd9jr3WMlD5U0wXkczfTafCPVoYhVSnd9Dt4hfaSvcrisKc/dtj0TJu19wN85+WBWOA4vke5ASXgP+3vyp0o+LvGh4DBdKnyK4o/T+b0zVZ8im9OUuVG+X+fL9j3quTispw/DPTcfMfB7TbevpCit83pyEH9cwabMOVl7/VzwcyzkG4YflSUY4Hp2Qf6+b8Lnaz9Zf6QgT9fZB5IfGMlo0uatSDNrV3s/kZ/D4ZiIhb2mwxUTWFfqv0ti7P4tm+eI0H1Tinya6xSu8tlvmM84w02Y6zYKuOUZxvyjXHOOk3+qrDVkvFwSY2C9Px/YXtJU14R3GrPpd43ldaV/yKIft0CRw77yXOH1adEB7n7r5LyrrPsU7R43aWuzexqGBwIQgAAEIAABCEAAAhCAAAQgAAEIzCSBnVT4BZLww6CLpfMv8dbhXqRM/GvlYRlZ+L11FEIeEIAABCBQP4H5+52/cfIA8ILFZ+6w3+Jd6i+ZHCEAAQhAAAIQgMBABJ6vVNm7Zni9c4Act1SanyTyXCrbQQPkG0uyngzeoBXW3eUcHEtUoH+4dFdJwnzy4R/J7o0wMbebDJdI8mnq8O9YUKA31YZ5+xfvPybZqCB+pnqQPN4YHaYNwz50VMWNus0vVyV8AMxyjuQ3EvdtWN98+E2y9+uaMo58oO5IyVGSYyTfkPxRkm9f6PfnVN8O4typ8EkSb959neQVEm9gcp6pTZH5vH3gaSZdU/rEDHwIIfU5XZ5bVb8/RxyF20qZevwcLfFhC9/vt0pS9dpHdo+ZLM4d8nusvFTiueaREo+zd0u8aTOLF7terjg+GPACiTfP5eN5nv2axJ9tvlniHyn4riRffj5+3u97/2mSQVyTxlOs/p538+3N/D6g2K/rKkHs0N8nZZtbIUMfwPmWJKtHePW8nHom5ot4ogJFz9h/Se85ymXF3Coy+BDKWZKwDg6fIQndDlK8f1oO1dVj7jZJUfpMNyV7mXNdDpE47w9JPifx2iA1P3jOHdRN8pgYlMkw6R6sxGFfvb1Chs9UnGycFF0XVchjpqKspYLDedhtuExSZcwPW++9lEERs7zOfeLnlJ89eX3Mf63ifVSysaRJzs/LsM7jXpv7wEo29/nqtcCpknDc5+t5tex2L5SUrbHz6fyMT7kmPXfb9kyYpPcBP+NvluTHjtd875KsIClzcxXB68Wq7y9e947TvVyFeT1kOUdSx7vqbsrnEkmeWR3+8DOFlVTGzwvKcRtS6zKZ73Fryhe+h7qu/sxh3K5Jc06+7V4rnymJ9eFf85H79PvgcCxfz+mDuk2VMMzXa4nwsH4+/0mat/LtGod/DxUS8i4K/1Hx/I6NixMoOsyXZ/mFIOnOCuft9u8RxGlasClzXZPWnE3pI38Gc6IkHFNh+J1NqXCkHk14p3HVDpKE7MrCX460qUj9GCnD9+TbpfO7f8yNYt2XL2vS1mb5tuGHAAQgAAEIQAACEIAABCAAAQhAAAIzRmA/lVz0wdL/Su8NQHW6w5VZUVnWfa7OgsgLAhCAAATqJaADwEelDgHvtP95R9RbIrlBAAIQgAAEIACBgQkMewDYG3c3kTxHcrwk9h5r/a8lO0nqct4QfJ6kqMxXDVDIw5Tm6kh+WRmHJfI9tSRtlke/10cUlPmEoCxv2PchvSrOm5IOkHhjS6wuS2TzxrIyN842Z3XZXp5Yva3fI4tY8dq0cVRU7d9LGWtz/lCH+/RoycaSmPOmUX++VXYYzuVtFMtkxPqm9cnWam+Mf0z/D6W5UXKN5Mrpq8M+wOBNZp4vx+WKNnHH6v1FVWrDRMVWlO1Dklj6TO82ex7Jwp5b3yhZXlLkHiSly87ix65fLUpcomvaeIpVt87Dnp+IsHx/rPCI3v3tgyCx/nhlJF1e7fvn5oI8LpDuYfmIFfzzFMf3Ub4+n66QzlFeEaTL5/HPinnEor0qkff1sUQV9JM6Jio0fSRR/Flcvt89F/uAbJnzQdlLJfm0eb/XYEVrtbJ8x2F/W6Te1o/D7aVC8qzq8P9WeX5f4nnuxRL/97wmuKaszYtYvEjKGPsrZHu8xPNgLE6R3odqY64Nz902PhPa9j5QtF70Qf8XxAZOQr+BbLFnYn58jvsAcFGVt5cyX6fQv0dRopxuXO/X+xbU0/NA1c8Usir7fg/rfL/MOKZr0+ecbcUhHAf58EMG5HRUIt/vD5ink72sIN+PDJhf2+atAZs5VLKuUi+W5MdEkX/HoUqZHYmXUzN/nWDpz86y/7jt99xLgrjnKez+aKpr+lxnbuNeczaprw5QZYru3bzuZMVp8hgzz6a80/gdfCPJwyV+5/uGJM8y5n+J4pU5fy55kSSfh9/pdy1LWGAfdt2Xz3KS1mb5duGHAAQgAAEIQAACEIAABCAAAQhAAAIzRsAbJG+Q5D8Isv9vklF8mbW+8vWXoWF5Dn9HgoMABCAAgYYSmLfgnOemDgDP23/xGU/f78J1G1p9qgUBCEAAAhCAwOwiUPUAsDdJ/1jijYQ+gOVNnpdJ8ocPi95frbtK8nqJN2PV6T6mzIrK9C/uD+p8gOM2SVG+mW67SOavld6MzOa7kuMkx0qydOH1e7JtJdlSsoXkqZKnSDaTbDrtt82bvEL3WCny+Z0ZRqgQflaQRz4/+99ZIY9xtjlfnV8m6t7vhp2mjaN8OzP/+xLtzfrNh+I8dqo6j7VrJVn6oqv7dyZcE/tknkD4sMsTJBtKfFimiJl1b5U0zd2kCsXqm+kP7qPSjpulK7v+XHHXqJj3oSX5+mD1ShXzyqI1cTxldctff6BAEcsr8pEq+D3+ivL5nfQrVEgfRvFm86L8rPu1JLWB1Qce/lWQ/pvSDbom2CbI7yCFqzg/V2Pt8Fw4jEvNB/32X74ekzgm8u0bp391FeYfYMiPgS/3UYEDg7T5fOz/RB95jSuqN01fJgnr6nXu/cdUib0Kyg/rM2z4TpVxhmSBZFXJTLmmrM2L2j9HSj8/Y6yvy9nM8+MSr3k2kfgd0O801ufT+70l5trw3G3jM6FN7wMf0eDIj5fM/6bYoKmg93rjyEi+Wf5NOADspgzzrjqu9+uTClhaN4gL14o+WDNO1/Q5x89j/yBMNk7D66sHgHVfpflnIs8lsg36/ePng3xvVXgdySCuTfPWIO2rK43fJdxn4djIhz2v4soJ7KIoeW6h/7vTWbwniOfPtp84bWvqpelznbmNe83ZlL7yZ/fhWjkce1cqzrjewYbh0uR3mmeqYddIQrb5sPduPqAEwIcK8nhrSZqUeZh1Xz7fSVqb5duFHwIQgAAEIAABCEAAAhCAAAQgAAEIzBiBhSo5/+FR5v/ECGt0VqTMo0ZYJllDAAIQgMCQBLY6aPF9dtp/8SnpQ8DnDvLF/pA1IzkEIAABCEAAAhC4F4HnS5O934ZXb17JXNVfWs/yuEQJvaHCm8NTh4Oy/Pu9xup9hzLaoN/MgvgfVjhrR9H13CB+KuiNmUV5WPc/qYQltvCw0W4l8WPms2WI1W/QDdSjanO+Dd9O1Pu5+Ygl/raMozcn2uv+88GNR5e0tcgcbtYOx8L3ihKNWNeWPnmwOIS8svAwG8dGhdcHNbP6FV3fNUDB/g85RXnldRcrzv36zPtHJfnO7yO/townN6mOw54rKZ+bJPk+yPz7uJABnA8tpH4sYKdInj5s7LVAVn52vV26jSXDuMuUOMtvr4oZPTSXJkubXf9QMY9YtI0Sefvg9aBu0sbEoBzqSOd5Oevv7Jo6wBiW6Xks9QMxPly8WphohsPeIJ21NX/94hjr5fszX3be/y/ZvBY+RPJ2yYHTV4e9Fnc9/Ty4UpJPl/L/WXGfI5kJ1+S1uXn4eZxiZ5vnq0dKitzzpMwfTvLhgCLXluduG58JbXkf2EEDo2isXSH98kWDpk/dIZH8Xeag7699VqE0+rcTdeznXTUrqO73a68Xfagz7Kf/zgrs8+ofLMt+GM6fx4zTtWXO+ayghLyz8JcHAHZAIr8s34MHyNdJwufuxwbMx8naMm8N0cTakvrHN7K+K7reKbvXGrhyAmWfJ3h96nfSPOdPl2c7ozHaMtcZ0rjWnDPaIbnCfag3nDfzY8t+379b5tI02dv0d5qHC971kpBxPvytBOB5si0N0h+ZiF/FVMe6b5LWZlWYEQcCEIAABCAAAQhAAAIQgAAEIAABCIyFwKUqJf/BUebfaoSlfyFS5n4jLJOsIQABCECgBgI7LVj87vQB4MVfq6EYsoAABCAAAQhAAALDEohtIvI7rzeoZO7Z8mSbOrP34dj1yVmiEV4vVN5F5S+qocw1lcdNkfyzMr1hpIqre7NuVuaT5Mnq4rqumBn6vG6TyyfLL7v+ps+8suijanOWv6/HSbJ6htdn5COW+Nsyjl6baK/b/8qSdqbMfi8JGWbhYQ/FpcqN2drSJw9OcHtrrHEzqP9Zor6XyDbIgYynJfLMxtDOA7R5x5J8X9NHnm0ZT25SHYc9PRdk7PPXf0vvuXlQ5x+jzOeX938wkul/RdIcEYnfj/qsXN4vqphwvVyafP3t9/0xjPO6IcwzC/9iiIwnbUwMgWKopHOU+nJJ1ie+em7o131BCfJ5hP6mfWcTGz9P6bfhQ8T3AYuQUxb2xu2qzhvrd5dU+eEJ5/9NyaBrYyUdyDV5be4G+WBkxr7oep3sD3LEhPuEbFnah0TiteW528Znwmtz/LN+yF+b8D7gg6C/jtRz78iYGUT9p0gZHudNcHW9q2Ztqfv9eidlnB87mf9DWYEDXG+YzvOWAdIOk6Qtc84u03wy1vnrNX0C8LrmskR+Wd5+x+v2mfdmQb53Krxhn3nko7dh3srXdyb9qc8Xsj49XxWcmslKtqTsx6qe+R8tyfjFrv9U/EH/y/W4kLRlrjOPca05x8U+VY7n2B9KYmMr0x+QyqRhtqa/0xjX1pLwEH/GOru+qIDr2tKFP27n75H8XB3G1bHum6S12TAsB0rLg3EgbCSCAAQgAAEIQAACEIAABCAAAQhMPIH7qIUbR1r5x4i+DvVykUx+F9GjhgAEIACBhhC4q7M0ffik11lnh/3O9xcpOAhAAAIQgAAEINAGAiepku+qWNFhNh9XKWJTRYodMvavrg/r/qYM/J/HUm6PlHEMNm8S/ZLk6umrD3cN4s5VIudR5HygqanO/4Uv5u6IGQJ9m8aRNzbF3O9lOD5mrKD3IZmYWyNmGJG+TX0yIgQjy9YbYGPugzJUvW/yeZyjgDf7x5wPgAxyEON0pbs8lqn03rRXxc3G8RQ7HP0TAbu5CrRInNMiequfVmBbX7p3FOj/Kd37CvT9qvyczlzVgyapMf6PLLMBr6k5OvW8GrC4vpI1ZUz0VemaI79A+W0U5PmpIFwl+MmSSG+QvSl7T304c35BfT0XWNrmblSFve7dWvIqSerZI3PnhZLjJOPsj6avzcueAW8Ur8skKfcuGV88LUUH1tr03G3jMyH1rGnK+8DrND4eVTCI/APbxxboB1X1Bk04pnSpZ39q7I2petG19BZDVMD7Fq6TXDFEHv0mbdOc4/ebv0cauK70j4nYitRe12xcZAh0D1V4u0BXFnxJEOEbCv850PUTbMO81U97Rhn3IxUyf6ri7Fsh3myPcrEAfL4PCGbfzw/T9JF1LVHbNNe5weNYc9YCtoZMDlYe/oGHlDtRxo+mIjTM1vR3GuNaLNm/hNsnZPcPqGSuK4/fJx+QKXT12sXPvbtyukG8daz7Yp9ztm1tNgi/odOM86V/6MqSAQQgAAEIQAACEIAABCAAAQhAAAJjI+AvXvyhUJEr22xQlKaq7uGRiL+N6FFDAAIQgEBDCGy7+jYXdqe6N6aqMzW1pOyLoVRybBCAAAQgAAEIQGDcBD6gAr9aodC3KM4o1zn+LyJFbqmU3y0yDKD7ckmaeSX2UZu9uXYPiQ9Zmfcw7k+RxKtF9E1Q/ztRiaqbqts0jlJt+pFYDLNZ6bwEy3EfAG5TnySwNdK0JFGrnyZsKZMPX/w8EeHUhK3MlPqPrLGNcWGes208+XPkbUMI0+GLIvqq6qsSER9fYHuRdCsW6M+Uro7P0vOftVQ9AOw1QswNewDY/x0t5lKbQWNp6tI3aUzU1aZB8lkQJPIB8irr2SDZ3f81OHV41gdtnhEmmqGwD4cU7YMd5ODzDDWhsFg/d46VPE5SdiDJh4DDvpdqZO465dzktfm/Ei33oZfvJeyZyQc6fBjMUjS3tem528ZnQhveB3wPFDkfwkg9K4vStFlXx7vqTLR/GxX6ugELdlofZPX8PC7XpjnH9+8PEmCenrCFpgMDxVlBOB98TT5Q4vc+GP/IQ975YOQwrg3z1jDtqyut123Pr5jZ/yhe/gBbxWSzLtp/qcX/rNDqmxRn2HFeoZihorRprnNDx7HmHApoTYn92ct7S/K6QvY9JX6HaYtr+jtNxvGT8vidJObWkeGDOeMB8ueftf5M4FmSW3JxBvWOct3XtrXZoAyHSlf0wcdQGZIYAhCAAAQgAAEIQAACEIAABCAAgYkgsGaiFRslbMOY/F+Hi34p+XTp/WEhDgIQgAAEGkxg4cLu0l6v9L8dbfPshReu3OBmUDUIQAACEIAABCAQEthLigtDZUH4WOm82aJut5oyfFkk0yul/0vE1q/ah51+k0jkDXePSdjbZLo0UtmVpF8uYptp9V2JClTZXN62cZRqb+w/OCcQLWO6ViFLkZsjpT+fGodrW5+Mg0mdZaQOugwzhmLzh+seG1dV2pX67LPKmJyN4+lVCbC/StiqmK5JRPKzwpJ3z8sHcv7Lcv5hvPsp8ZbTUrVtqU23VTaHp+qbeu4UHZJL5VWnrUljos529ZPX5ooc/tecz0s3aL98oqTwN5fYx2FeUYW8uqCgG6X7eoG+jSpvTPeG7bLD++9QnPu2sIGxZ+swa/NbExw8LlLzWCLpPaa2PXfb+Exo+vuAvyt/0j0jYlnP75YNTnwo1VfD3mt1wPNnHTF3hAwfkNw/FqEh+rbNOcb2nQS7+Qlb3vQ0BTbLKc6Qf99cOPT6xzBSe1zy8bdSYIOc4iz5f54LD+JN3QvDvIO6Ln7XjL1vjvNzjEG45NNsosDheUWJ3+uafuKXZDex5uvVsvzhv1hDPy3DsO+Csbzr0Ldxrhv1mrMOrsPmsbYy+KrEc03M+Xn/YokPmc9WN4p3mjzLvRVIfXa4j+z+LOApkvdLMucfSNxV8qdMMeQ19ayruu6bhLXZkBgHT84B4MHZkRICEIAABCAAAQhAAAIQgAAEIDDJBLyhIOY2jRmG1L9O6VctyON9BTpUEIAABCDQRAJ39X6UrFavu8JtN9++fTIORghAAAIQgAAEINAsAj4w4YM9sY12WW29GeZYSTdT1HR9gvKJ/YBKWZ36rcIpJQmeWGJvsnlFVc4bR18jeVyioislbDNpWpoovMrmmraNo1R7b06wqGpKbUhbvWomQ8ZrW58M2dyxJ4+NIR+A+dsQtUn96ELZwaxUsan5PNaWfH6zcTzFDt2Yy1/zcAbw++BgyuUPFtxPEbeORL48ou9XfasSnD8t9ldxyyUipf47WSLZPSbfR7FxOehB03syH8LTlDExRBOGTrogyMH9dFSg6yd4giKn7od5svsgx0y6F6tw34ehO0aK1H8nCuM3PXyxKvjWkkp6btqjJE5TzKNem6fWxxfVAKFtz902PhNizxl338019OGw7wPPT9QhdTgjkay1plRfpe7FcTX4skRBc2U7WOIffzlR4sM1G0ua5to255jfyZLbIyC3kT72OVc+yYH5gPwfkvxBcnagz4IryPPKLFBy3T2wfywIDxJM3QtNmLcGaVOdadw/X5XkP3fzwbQvlhTyUtl3LomDudM5TBD8Q5Ep5wPATXZtnOtSz7mLmgy7Yt181vA4yQNL4nu+/klJnEk0j/qdJs/sFgV2k8QO4HZl+5rkmxKvbzLnd8gzskAN19SzLnU/5IuehLVZvj1j9ade7MZaEQqDAAQgAAEIQAACEIAABCAAAQhAoFEEUh8O+wDwN2qurT8Y278gz8XSnVWgRwUBCEAAAg0kcNoRW/95p/0X/1r/CfjRser1ppbuItsPYnb0EIAABCAAAQhAoIEErladvMHXmwy9YS3m5svgd9uPxiIMoN8okcabVOt0PgC8XyLDtRK2JplWUWWeJPHnFxZvIHuEJPWfCmS+2/nziX9M+5t0iW3ucR2rbK5p2zhKbSaq43BZqo+9YWocrm19Mg4mdZbRi2Tm8ROzRZIso04dFvnXMjH7C9yciJ66H7Jks3E8bZA1vuDqH3q4XuL+9gHATHzw1Tw9p+avfrb72eH/tuwfqFxTknKryei1gd22ktjz5bK7Y8zMn/yGz7AGVZ4bYZowbH5F/3ikjjk6LKtquCljomp9647n9r8wyPTvCm83LYGpctB9HXN+Zr5J8vpYhDHoi8p2nZt+wGEQNF9Rog9L7ptI7M9dj0jYZ8I0E2tzz/MxV8fc3LbnbhufCam5p45nzbDvA/NiA0z6yxO2STSl7rc61hzDMvuzMvhfyVMTGfkeefa0OJrnCafJ5Bfyz2Rb2jbnCNfd/2X0DF39XAqd197bS1LfE/o7xmfkEroP/JmV3WclT7vbd+8/e0tV9hxcSXH8AyKZc3+flAWGuDZ93hqiabUk/ZByeXyQ0zsU9meoj5E8ObDlg5+ajuP3OlwxAT8bvyHx59JFzj/q4/mwya6Nc13qGei5pe3uXWrATiWN+LbsZfNuSRatMM/EO00I5jwpPiBxvxS5DQPlFxT+eKAbNpga81XXSpOwNhuW48DpOQA8MDoSQgACEIAABCAAAQhAAAIQgAAEJprAX9S6n0ueVNDK3aU7THJ9gW1Q1dFKuE6Q2B8cxT64CqIShAAEIACBphBY2pla1O0s9Zfzha7b6z56uzeduf5ZR25/VWEElBCAAAQgAAEIQKCZBC5QtfaRfLGkeh+U/XzJj0viVTWnNj/5AFKd7sKSzJp6ANifJ+wg2VqylcQbB2OHsWRKuhWT1pkzpjaSLqlQrbaNo16iTXVs+Ext+K/CM1G9yqa29UnlhjUkYmwMVf3vqbFmpNLH/sNVLK+8PnV4OHX/Z3nMxvG0ftb4guu7pbOMyuU3NT4wUchMbrBO7QnM1z9R/aQpdo/VcSgrWXDC2JQxkajiSE0+iBv2uw+KHjPSUv/vP+29XWXcMuJyirL3D71sXmDwgaLLC/RtV/kZ9GWJ+zrmto0Zxqhvwto8tTHd338O69r23A3nhnz7m/pMiD1nXPcmvA/Env83qH6p9WKe/aT4U2vVcb1blbH0voYTyiLl7A+S3/KyaZ3HnD8v8cGbRZLFknG2rW1zjvDc7U7U312m/eHFh3tTB4DfKns3l8iHRzP3LXmOlKyRKXJXfze5hcSfy8Xc82RYPWf8pPypcZyLmvQ2fd5KVn7ERvf3W4IyTlP4IxJze6PEn6Pm+1zBe9xD5HvXtNyjxHMvAql3sbp/RPJehdegaONcN+o1Zw1YB87Cn7UfUpL6UtlfXRKnreYmvNMUsftvKf1sTf1ogtP5R0xeZ0/NLvW87Gdt1Pa1Wc1Yq2c3VT0qMSEAAQhAAAIQgAAEIAABCEAAAhCYZQS8kaDIPUDK4yV1fa7gD6h2LyhoX+nOLtCjggAEIACBBhOYM7XKmfqK9o5UFecuP3d+yo4NAhCAAAQgAAEINJTAl1Qvb05LOW+u/rrk/qlIfdhSm5/6yKZS1L8pVmoTx/0q5TKeSBuqmHdLLpJcK/HnFK+X+L+JFB3+9eG60yXvkZwqibnlY4YZ1ntDZMxV2bTftnGUGoepzXUxRqE+tSm/n81KYb79hNvWJ/20rclxh+3f1P02TN6eo2IudT9kaWbbePKG/ftkjZ+Ba35jtTeFxlzys5FYopr0cxP5DDNWs2xjz6VhDsJneQ9ybdKYGKT+w6bxfyPae9hMBky/qtLtNWDaYZPFNjR/YtiMG5z+hyV1W0n21H8ILkk+sLlpa/PYHOUG+p1nWNe2524bnwmp9U8T3gdiz/8/Dzu4Wpg+db+l1s7jbOo3VJgPjA7q/ENhW0veJjlT4oPen5ZsIBmHa9uckzHxAeDY+PCB0JjzAfvdcsZL5f9mLuwD2bF9LI5WtibaI5eX38OOyYWH8TZ93hqmbcOk9d6iLwQZ+Fm8pyQbHz6o9kVJyh0o4yapCNg6qXexf7SAz0ZjrGNdn4FnY7io6nWsOYvyHYeuyp5Aj7cXS2bih6BGxaBp7zRF7fTa6hUSPwtTzj8alZoTUmlTttSY72fd1/a1WYrRSG11bdQdaSXJHAIQgAAEIAABCEAAAhCAAAQgAIEZIXC0Sr0kUvIO0nvT7DDOX5Z9WPJfBZm8S7q6vmwpyB4VBCAAAQiMisApH3n8vzq93rmp/Hu97s4pOzYIQAACEIAABCAwQgLdRN4pW5bMGz5PzgKR6/rSHyepkl8ki3vUK9zju7fH5dTp7lJmNycyrKM9iewrmXzA50OSP0jeI/GB36J6eeOlNxAeItlc4oMQ8yQLJam1qg9wN9EVtTGrp/utzE3SOEptNCrjUMW+pEqkGuJMUp/UgKP2LGLjpMr9Mmhl+tnoFpaRSpvaSJ7lM9vG0wZZw4e4mqu5e9OkN/7/XXKT5DrJHyX+gYnFEh+2O0Kyj2Qrif/T2NWSzK2deQquM3EIL6tG6rBXarxl6Qe9jmsODevXpDER1m0c4VepkJkcb/4RlnHvQ/W9+LICuF4jnlqgnxTVVRUaslaFOHVFaeraPDUePecP69r23J20Z0JsnTdsv2bpy55lfjeL3WejOGiR6r+szjN5HfZddVx1308FHSqp433Az9x9JRdJ5ktG7do252Q8rpHnZ1kguG6scOww51tky/842+EKh/32WelizgfSVosY15N+p5ztS/LfnAuPyjvT89ao2lWWr+eHYyXhO9Nrpbtaknf+vDV1kNBj4tP5BPjvRSD1DLrtXrGbp2jjXDfqNedM9NIcFfpVyTolhb9V9tgcX5K0ceamvtPEQP1OhnfEjNP69+uaWqOVJI+aU3mGz+poJtOGNq/Nyto2MntTv7waWYPJGAIQgAAEIAABCEAAAhCAAAQgAIHKBPwh8KslZ0jmFqR6l3SbSg6SXFxgT6m2kfFzkocXRPq4dP4wCgcBCEAAAi0l0O10F+nb7B2j1e/11tppweJNTz186wujcTBAAAIQgAAEIACB0RBIbVJIbdrJauMDQz5s8HPJgzNlwfXp0r1T8r4CWz8qbyyNufVjhiH0NyrtmpH0dWyWj2RdSf1YxfKBjtgGJG+o9GGtL0m+LYn9p4XUYbo27qEo26AuFMlDQU0cR6n7tI6Ns6l7vQpPMx3WcW8PSzCdPjaGUvd/Osf/sxZ9RpqlG2bspDbJVanzbBtP4QbyrA+yqz+zHtdG1FRdYs/TrJ6jvI5qrGZ1js2jqbGcpR3FNdUPLm+cY2IU7Uvl6b7wQZm8+4sC/g6mzv74svLbIl9Izv8Q+Z8lOTGnG7V3TxXg/3YbuqOkqGOtEObblPBVFSqyYoU4dURp8to8Nke53bfW0Pi2PXfb+EyIreXcfXXc46kxUramc//HmKbGxqBDL3aQcdD8xpmujOU46+I19UGS4yX+UbGdJKlxJnOp81rPnz14nfGb0tiDR0iNq/UHzzaass7Phb6nUsynyD1Tyt8GhvsovG9O91f5P58LZ95fyfO/kqdmitx1Ffn9ud3ROV3mfYU8+fv/U5mhhmtqPM30vFVD8wbKYoFS+fPRvPu6Av7Pj6Hz+vXdkiNCQy68rfyvknwhp8P7HwK3/8d7L1+d7wX3yrwmRRvnuvx8EmKoY80Z5jmO8EIVsl1JQSfI/smSOG0xN/mdJsXQc+VLJJtHIu0svX+oa5z91O+6r81rswj20atTk87oS6cECEAAAhCAAAQgAAEIQAACEIAABJpOwBtnd5XcEamof9X2IskxEn8wltpYsKHsB0h+KjlHEh7+vVq6F0jCzSpS4SAAAQhAoE0E7j7Y2+3ekKrz0m5nl5QdGwQgAAEIQAACEBgRgdR35KnNevnq3KKAN1jE3pWzuO+RZ/ssMOD15kS6VWVLbY5KJI2avLky5m6KGcagf7zKOEOyTkFZ3ixynMSfM2wr+ZwkdvhXpo7jx1xTDwCnxmaVTXxtG0ep9qZssX4N9al5oN/NSmHeVcNt65Oq7WpKvDrGSVFbli9STutSc0si2d2mVNqULcu3jeMp1kcxfdZWX/1fe1Ou6FmRij+M7c5E4gclbKM2xQ4mudwqY6qsfrF5tMozKZZ3rO9j+nw+TRoT+XqNw/9cFfLQoKDPKPwHyZ9qlE8HZYTBN4eKEYY9Jl5XkL9/rGbSD4R4vi87RPSPAjZ1q5q+Nvd/LitynqOGmaeyPNv23J2kZ4L7oMpzIeur2DX2HHP8sveBVNq6f/zDbW36AeBUf9Rxv8X6cFD9RUroA4kbSnzQ9DuSYebNlZT+i5JRurbNOXkWqR8HeWY+4rR/H11Xz+l9cCl2iO6zuXihd+9QMR3eI6c/X34fJK7Lpe6FlK1q+am5p2zeqlpGnfGeqMw+EGR4vcJvCHT5oA9kl/3jgUMV5/75RPjvIZA6AHxPpAZ72jjXjXrNOe7u8vPxHSWFXiJ7bI4tSdo4c9PfaVLA/PnkKqkIsnm+fERJnH7NqefZoOu+Nq7N+uVWW/zUYqC2QsgIAhCAAAQgAAEIQAACEIAABCAAgVYT+J5q/wzJbyOt8OcLr5b8UuIvYK6UnCnx5tvvSi6Q/FlyucQfMG0qyTtvOPKXN4+S+Es2HAQgAAEITACBXq/3o1Qz9O3A1jsf8P/KvphIZYENAhCAAAQgAAEIDEIgtUnB+ZXZszIvlOfgLBC5+n35q5J1I/Yq6tRBVqdfv0omfcRJHQr6TYV8qvKrkNU9UbyJepGkaIOfN5Y8V/JKyR8lVVyqjYMcAB5Fm8N2xDaUOV6qPVk+bRtHvndirg7eqfzHtXG2bX2S4p6yxfpx1PpR1Sl1ALjsQFaqzakxWSXfto0ns4i1uUrfpX6swnk/wH/G5K5NlLNFwjZqU+p5lnqmVKmX84713zBzaCzPto2JKgzrjHNAkJn7oOywbpCkUvAbipXalL+j7P6OZxxungp5WEFBX5HOP9QzUy42huusz2rKLHVPeF14Q50FFuTV9LW5qxzri0E3pYcY2vbcnaRngvsidQ+EfRULx8aI45c9yzwXxtZnXoOs5Uxqcv7Rr1RdaypmqGxS64oq76ph4XX0b5hnUfgqKf2DGS+QeF7bTPImyfGSSyX9OO99CPc/9JO+LG7b5px8e36pwOV5Rc6/tfz5w75zFd4vZ/+3/J/IhUPv16WIHd5+smw+gJp3T1Fgk5zi6Jy/Dm/qXq1jXKfyL5u36mhfP3n4u19/Hhq+P+8rXepdzu3wfZhy95Px0FSEWWxL/ThVaq5uCrI2znWx+7KuNec4+2Y9FfZlSaxNrovn5RdL/u5Ay52f/Ysk9y9oRxO+byio1j0qP1OOlTzmHk2xZyWp3aepd4HilHFtai4ZZN2XL6lNa7N8vcfqT92gY60IhUEAAhCAAAQgAAEIQAACEIAABCDQaAKnq3b+8OiVkj8mauoPmtaXbCfZTeJNuP4yZQNJ+MWGvyD9osQbod4omYQPCdUMHAQgAAEImMBdS+78UZJET1/83vX3HZJxMEIAAhCAAAQgAIH6CZR9R15mz9focAVOyisK/P4vhN6UOOhGi7LNTxsWlDmM6j6JxL9K2DJTahNIP2yz/Hx9g8QbqYvcW6X8fpEhofMmnpgbpJ9G0eawfil2sc3n+TzaNo7Cz5DybUnZ8vFS/lSfjWvjbNv6JDUGU7ZUP4zSFqvTsOMn3MCcb0OVezEfP+9PzT1VNtC1bTy57bG+iPVdnldq07jj+QDHuNzViYK2TNhGbfIBiphLjbdYmrx+5Xwg8KeesUHUewUnZUzcq2EjVPi7lXCcfVe61LgctDq3KeFXShK/ucRel9lrwyLnH5qdSZdaX1SZ26rUvexgoX+w519VMhoiTtPX5m5ajPcwc1QeWdueu5P0THA/xJ4X+T4q86fu17L3AY+j1HfaTy0rvA/7ffuIO1NRY/eb6zPI+jjVN6myhmm/+/xCiQ+ben/DQyTrSvaQfE1Sds8rSudF/jMiV1Z+0z4XCjGcGCqmw16T7pyzvVR+7zPJ3JfluSELFFz9vPOB7ZjbOzDsmQt7n8oJuXAd3tTclLJVLTt1b5TNW1XLqCveEcroEUFmPhDsfzxQ5s5WBMdNuT1lfFoqwiy1pcbZsO+A40Daxrku9lyqa805Du4uw+PDz7uyd423KM5FklG5Bynjh0k2GlUBuXzb8E6Tq+4y3kMUeskymnhgM5neGTf3bYmNeWfU6zu3eIKmr83iNR+xJdUBIy6a7CEAAQhAAAIQgAAEIAABCEAAAhBoGQFvNjtO4l9GfY1kseQvkn6cv0z5ouRZEm+C3lPyEwkOAhCAAAQmjMBZR25/lbbiXJxq1tJud5eUHRsEIAABCEAAAhAYAYGy78jL7GGVXiXFlaEyCG+j8AcCXdXg70si+v26ThfbYHy7CvlDhYK8YSjm+mXrfFaQxA55fFs2byrs16UO06U2VMbKqbvNReWk6lWFa9vGUWrTYspWxK5IFzvE6Q16dW5WKio707WtT4Ydg1m7x3WNjZMq90uqjrGx4zTDjJ3UPJKas7K6tm08ud6xPorps7b6epMktcl923zkEfuvSeS/gWyPTNhHaUod9vJ/gRnGrZ5IPMxG51jfx/T5ajRpTOTrNWr/AQUF+PDSqNxnSzJ+hexrlMQZ1ryhMiha/54r/S+HzXzI9ON4VvoHd1PugpSxBlsb1uZuZuy5WmU+qYKpbc/dSXomuH/q6MfYmq7q+0DqkNI2VQZRxTiPqxhvJqPVPffF7l+3cdi1fD+crlPkL0leJvEPkr1NkvqBhQfJPirXtjkn5BA7AOx4+Wd6fl3jd6vDw4wKwqm1ycsVP/vhGj+/fMA4c8fJ4x83qdOl5qaUrWodhp23qpYzbLxdlcFeQSY+yP3mQJcKHijjP1MRZDtKEmNSknRizak5MjVXNwVIG+e62DOrjnt+nP1yqArbuqTA42X/TEmcYc1+n/P3D5dJRvm5TlveaYp4el1ySGDwD15cFejywXcpUPYemY+f8qfmktQclMqzqq1Ja7Oqda493qgh115hMoQABCAAAQhAAAIQgAAEIAABCEBgxgl4c9UxEn+B6UO83hzsX43zL+K+R3K05NOS90peL3m+5KmSjSVrSfaU/EByhwQHAQhAAAITTEDfbi1KNq/X2WTeWxZ74x4OAhCAAAQgAAEIjItA2eawMntYT/8XQm8q9EbhlPNGRr8f9+vOLUngsrMNjSVRS83OZ/1ILK/rytropLGNT7alNp7bXuReJKU/eyhyPypSVtAtTcRJbWKJJau7zUXlDFtG28ZRaqzUsYkudp/7M69xubb1SWp/Uco2Lp5hObE6xfRh+lg4NnYcfyYPALdtPJlXrC9ieqfJnJ9HP8sCBVf/gOW6BfpRqK4pydSfj8+ES82jqwxZoQck0g8zj8b6PqbPV6NJYyJfr1H6H6rMnxcU4B/iOzvQ1Rn8f8rsJ4kMPbb2StjrMO2jTOYUZPTJAt24VUX1yupQZRxncVPXnVJG2b5TYh/W3Ia1udvoTf1FLjU3FsWP6dr23E21u6nPhFSdm/A+8OvY4JB+d0lqzZhIei/T9vfSNE8x7Ltq2KK683P+3qewg2QjBwZwdyrNhyVPlMQOJT5wgHyrJmnbnBO2y2sT/0h8kXuGlH5GPl2SP/B+ssK/lZQ5vxNcFInkH63Zddr2HF3XyMXzfpa6XdPnrbrbW5Sfv+/9TIHBh39vLNDHVFfL8N6YcVrvd76DSuLMNnNqvZmaW5vCqY1z3ajXnOPomxerkP1KCvqd7PuWxBnW7Dl71elMvNZbedgME+nb8k4TNsHrmc8Hyg8q/DnJ3oE+H/T9/zXJannlgP7UXJJ6DobFtX1tFrZnbOHURD+2SlAQBCAAAQhAAAIQgAAEIAABCEAAAq0mcItqf6HkeMlCyWslr5O8W3KU5LsS/+r4FZJhNgApOQ4CEIAABNpEYMXVVjyr0+3dnqpzb05nl5QdGwQgAAEIQAACEKiZQNlG3NjGnVQ1Fsvod+Ayd6wiPKwsUmC/RuE/Bbp8ML+hMa8fxP9YJYrtITi2YoapTSArVcwjH+1J+UDgTx3+CqIuE1y6TGjZwJxlg5VCdbe5qNDUBppU+VlekzSOBumjjEN2jc0D4/zcqm19kuKesmXMx32N9XFsjqtav1i+VdPH4qXu49ScleXXtvHkesfmtZg+a2t2PSvzFFy9WdSfT4/D/UKFpD732FP2+4yjIkEZqflszSBuv8HNEgmq/FhILHms72P6MJ+zQkUuPM4xkSt2pN4DlHs4p/n7mFG71H/ac9mvl4T1qqtOnoNfU5DZtdJ9u0A/blVqLq+DiQ9q5v9TYti+S6T4YaisOdyGtbmbHHvv8JrF88Gwrm3P3TY+E1L3Ux1rz9iaLsUqP24W5wOBfx2FfbCkDrd9IpM6xnIi+8qm1HM61Y+xAlJpYvd2LC/r7yv5seR0yRGSYZzn2XdEMqiyZo8kLVW3bc4JG+T76uRQOR2+v66bSw4M7IcF4VQwtTbZezrhHrkMzpf/V7lwXd7U2G3CvFVXO2P5uI1fkfiey7sTFfDBs37d4Urw+5JE75T9ISVxBjW7PTtLth00gxlIlxqDKdsMVLWwyDbOdbHnksdPU57ThbCnlY/U9ZhUBNluk/iQ8D9L4g1rDn9I46ZhM0ykb8s7Tb4JGyrgvZcr5pQ/kt/zoN0iSaovHyR70Q80OG0/ro513ySszfphVmvcOj5YqLVCZAYBCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAKTQeCkhZve2ut0z061ZqrbnbdwYY/PqlOQsEEAAhCAAAQgUCeB5UsyG+QAsLP8oOS0krz9K+vflMQ2B8WSnxozTOtfU2KvavYvrxe5G6X8QZGhQJfaUDbIAShvTom5X8cMCb03YM1P2MvGR1HSuttcVEZqc03Kls+rTeMo1aYU73x7U/7YfT7Mf3BNlReztalPUvNWjGes3ePQx8bQsOMnNUcMs7kzVa+qhwnaNJ48BmIsY/pw3JwVKoKwDyGmxm0QfeDgzUr5/URqP/sOTthHZXK9Ym7dmKGCflXFiR18cfJhDgDH+j6mD6t7VqgIwuMaE0GxIwm6D/cMcvaG7OMC3SiCX1Om/0hk7LXbcxP2YUwvUGIfrAvdZ6W4M1TOQDj1PIw9l/qp5hsUea1Ego/KNuq1qYeGBQAAQABJREFUTBvW5kaU3xgfIqs6p4TpwnCbnrttfCak7pnUuinsp1g4dr9WvYfOjWU8rX+vrn5mDuM2VeInJDJoyncqqb5K2WJNS/XvIJ8pmFO2To/1e6wuRXofZixyfylS1qhr05xT1OyTipTTukN03TFnv1h+H9iu6o5XRB9QK3JbSbmDJP850NFFEWvQpcZ7alxXLTo2fqvOW1XLGTTefynh1kHivyvsNfggzmu7N5ck9PP+0yVx+jG7n7aRHCm5RuLDdWdLdpe0waXWP8M+k8bV/rbNdSnmda05R8XeY8I/olQ2Nt6oOJ6XR+3WDwoY5QHgtrzTZEjcR36O5t+Fr1D4ZZL8Z4ZvVfgqScy9RIbXxIwV9alnXcqWz35S1mb5No3N35QXgLE1mIIgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEBgfAS6nSn/4mjU9Zb27v/jmxZvFo2AAQIQgAAEIAABCNRLILZhLiulzJ7FC6/ebPEKyfWhIQg/TuF+N6d541lqQ5832D0yKGeQ4MsjiT4ovTfeVXGpTY33r5JBECe1IWftIG6V4McVaZdExEH6v+42F1UvVa+VixIU6No0jlIbhuYUtK1fVYxnHXn3U5c29UlqnKU2PPbDo864sY2WqbFVpfxYvk47zB6s1DxSpV6O06bx5PrGWMb0TpN3ZyhwVV4R+O+nsA/fjMMdV1LI22R/akmcus2pw15eMww6371PaddLVLabsJWZYn0f04f5NWlMhHWrO3yAMgyfZV+T7h91F1SQnw8au6yUe0vKOITNB2BDt0SKUR3kCcsqC5c9K4e5PzZQ4Z5LYu4cGT4bM9aob8Pa3M1N/QBEeO8MiqdNz902PhNSa7ZBn2H5vo6Ng6p5/1SZXZ3PMPA/WGEfyh/UuR6e21Lry5Rt0HIHSRdj6bxS82KsrNS6eJDPFPJjKVXXWH1C/V9CxXT4+xF9Xeo2zTlFbfb3hHcVGaR7eqD35zb9OM9x30wkOF227N523BMScYcx5cdamE9WfqjvJxwbv3Xk3U89iuI+Tcr/KjC8XbrUXFmQZBnVKQr5gGLKzZNx91SEEpvfG18v+Y7krxKvqXzgMf+Z42oKt8GlPptpSxvaNteNY805qrH3OWW8SUnmX5T98yVx6jI/NMgotX4NovYdbMs7jRvm9d5XJf5OKXP+nsaHecND0rdI95osUuR6hPSPitiqqGPPIqdduUoGipN/Xqbyq5hd5y+RiKNem0WKHa26KS8Ao20luUMAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgMCMEDjtsC1/od9Xvz5V+NI5U/NTdmwQgAAEIAABCECgRgL+xfSUG+Q/ymT5ec3jQ8BLM0Xk6o1p+0RsRerfSFn2H3i9OW0Y540fTynI4CLpPlagj6lSGw8frUQpe1GeqQ1qjy9KkNAdLNvrE3abBtl0kmrTIG0uqmJqE98aRQkKdG0aR6n2pjaEFzS7UBWbB/IbkAoT1qxsU5+kNnGlNjzWjKxydrF7edg+TqUfZg9Walyn5pg8kDaNJ9c71UdVDsndoTw+kgdQ4N9fumcW6OtW/VAZ/i2RqfvwS5Kq83Uiq8qmcCNoPqHv2V3ziop+b+B/S0nc1FguSTpRY6KsrcPYfUhh34IMji3QjUr1mZKMfQjkCSVx+jV7w7N/9CZ035HimlA5Q+FVEuV6XovNe4lkd5v8DP6eZM1IxH9Iv4ek7B0kkrwvdRvW5m5Qai3pe6gO16bnbhufCak+HOZZk/X9sO8DPnjxiSyzyNXv/G+N2MrU71GEJ5VESq1LS5LWak711SBrn9Tad5D36/x7TGoOqwrlyQURb5fOz6NRujbNOUUcPA+dV2QIdD6A+ZVAVyV4TJVIivM1yW0V4/YbLXUvNGHe6rc9VeP7YL77LHwfdn8fVTWTRDy/05X12WGK43oM4nZTok9KnicpmiNulv5YSRtc6rOZorY1sU1tm+tS931da85R9NN+ytQHSFPu1zKWfY6eSt+v7TFBgtT6NYjadzB1Pzy+z9xG9X1DVo1D5XlWFpi+vk3XCwJdFvyRPD7cHXNeF31dElsLx9Jl+tSYr7rum5S1WcZkrNfwYTvWwikMAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEZgGBXs9fNkRdt9PbaquDFg9z2CaaNwYIQAACEIAABCAQECjbiBDbWB9kEw2eJssHotb/GD4ub9HG0f/EWNb3PwqmNvW/TvYdl03SV+iIgtj+7yzetOxrVXdrIuJ6sr0hYS8yXVKknNYt1DW1OThL6sMWPqhSpV/yG1Cy9GXXuttcVF5qrVw2pvP5tWUcpTYhVenzfJuL/LH8vSl30MM5ReVU0bWlT1LjLLVxrgqDUcSJ3TPD9u/yicoOs6k7NiZdXGoTb1idtown1zs2bnxILtZ/YXs/K8UNoTIXdl7HS3bO6Qb1vlgJ/V+tiuYgH0b2psyUe5iMZ0oG3ZieyrvIdouUfy8yTOsW6lqVs5N8UOLxVeYGeY5meU7SmMjaNIrrW5TpKkHGlynsQxbjcheqoItLCjuwxN6v2WvdIucDG01xZeN/kOfE2mrcDyRPjDTSh852lVwesdetbsPa3G1ePdHwOg9jtOW528ZnQmptVPQsTnR5oSmWfz/vA0cr538V5v4f5UfkXSipulffbfu05J2SMtfPGrEsr2HsqfVE6h0iVmbd79f3zRW0vvxeHw7jdixI/EPpUuuugiQDqdoy58Qa9/2YIaf3oaWyw5656Pd4z5Hvj/eE4p6vx01DW2LzijNuyrw1dCODDHw/fVGyXqC/U+F9JL1AP0jwCiUq+zzPz/aPDZK50jy6JJ0/T/xnSZymmFOfaXt8Djv/jaudbZrrxrXmrJP9LsrM65OU8/rGn4Gknsmp9IPYnpRL5PI9j4zKXZLIeKFsVeZsf744yu8bXEXPo/vbk3Mny394LlzkdZo/FxmmdY/R9auSquvTfFZ1rPsmaW2WZzMW/yCdNpaKUQgEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhMBoE5vZUW6WvF6Be9vV5n7kpLuztMRmtpBQQgAAEIQAACDSdQtgG1jg3hh4jB4hIO3iTyTUnV8s5X3Pcn8vR3/8dJ1knEiZn2lWFeYPTa7dWSnwb6suBfSyL8t+wPKIizuXSnS54d2C4OwvmgNwY5v9QGtsfLfq5kb4mdD1Fff7ev+E9q41Zxik6n7jYXlZM6MJayhXm1ZRx5Y2LMzY0ZKuo9XsKDU/mk+U1Ief2o/G3pk6L7NmOyVuZp0DV1kLDsgFaqGalnyAqphCW2WH2dLFVmmG1bxpPrnWpz1bnYm1H3kkQ/b5gu5we6vkniZ2W/7nFKcKbEhwX8zImN9w9Px9Ml6vxMOkeyaTRG3OB5cWfJw+NRlrH4eecfJYm5R8hg+5qxCNP6p+rqNc3bcvH+lvOH3mHm0EkbEyGbOsK+NzyWQ/e9UDGG8JdLyvCG8QeXxKlq9th4RUFkrxPPLtDPlKpsvk7NVUV1ni/lLyTbFRml848PvECS/OHFSNpB1W1Ym7ttqXVLP2vnMk5tee628ZnQhveBmzRA3lE2SGQ/RPJjyRNL4m4vu9cc+07H8z3udc7N0+HwMswzN8xrmHDqnkrZYmXW/X6dr4M/L3lerOAK+s0U5+1BPPfToYFuVMG2zDmx9ntNXua+UBYhYvcz9vMRW6a+Th6vxUfl2jBv1d32g5XhMwoy9T3xmwL9oCrnd2lJ4t1kf35JnCLzo4uU0zofQPx4wt4009qJCvmzsPUT9iaZ2jTXjWvNWVf/PEYZfU0ypyTD18le5z1cUlzHn5X4s4fMeY01SteGd5oXCsCnAgheE74m0BUF/yFl2Wdlz1Kcw4oSl+jy66owasqWj5uP1/a1Wb5d+CEAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACk0FgxwXnfWzegsVnxmSn/Rd/ejJaSisgAAEIQAACEGg4gQtUP28MjMm7aqq/N1XdmCgnK/8sxal6oNGbc84syfNPsnszT1X3SkW8S5LVJ7u+oWoGBfFuLcgvy9fXqyX7S3yQaQ/JsZKsDt6gsookc7vLk09b5D9LcbaWrCqZkmwo8abeUyX5+H9R2Aed9wn0+TjvlW0QV2ebi8p33fP1zPurbKLN59mGcfTlRHvfk2/MAH6Przy/0O9N3eN2begTbzoLWWXh344bWEl5PtCY1a3o+siS9CmzNwkW5WndQamEJbYPJfLt93BbG8aT5+sYR+vzGz9L0N1tfl9JfllZv1I8bwpf/u5U8T8ryORDdadLsrS++iBsyq0nY5Vnv595vqcemsps2ubnmw8z/FPiOnjD51qSKm5vRcrXv8jvw7z/LXmYZK7E4+cRErffh57DNLdI5+d3qM/C35dtEDepY2IQFqk0sbliv1SiEdkepHyzfo9dv6s4XpsN67wuLSrjtcNmXHP6KyP1dN19gKSK82bo3SQ/kxS1OdNdK/uOknG7NqzNPZ9k7xYZr/y17nHThueux0mbngmu75cl+X7L+5v2PnBSoq75ett/oeRgid9Xt5W8WPJOiQ875eNep/BWEjsfMM3bMv9t0vvZPdOuznfVrC23ypO1s+h6texVP1N4WZDXEoUPlJStBxVlGbeeQkXzvOfscbq2zDkxJpfKUNSn1vk+GMY9UIndv7H8jxwm8wpp2zRvVWhOaZQdFKOI9x+lX6k0df8Rnq0ksb7N9Dcojg+T9eN80DBLH17dp21yft8N25APD3JAeqba34a5btxrzmH7Ym1lcLkkPyaK/J8btqA+0nuu8I8IeN7I1+WXfeQxSNSmv9P4M5fbAybm84o+G/vJgjzynO0/VrKCpKqrY903aWuzquyIBwEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhBoB4EdF5w7P3b4N9PP3+/8jdvRGmoJAQhAAAIQgEBLCfjwwBJJuNEhH/Zmse1ral+VzWku+xuSqht3fejnJ5J8nUO/D9G6ratIYm5NGY6RLJXk03sT8T6SYdz3lDifZz/+7yhtN1f4GvJf1Ud+sf71oS1v2LV7jSRWJx+26GfTi/Ozq7PN/5fjf/4+V95Yfa13mz3W8twUTLomj6MHqOZXSGJt/qlsw2wmXT+Rt8s8SjITrsl94g20qY3ankfmzQS0SJk+2BMbP9Z/XuK5pV/3KCVIHSjyuH1Mv5lOx/e4i9X537I9rs98mzye3JQ3SmLttf5zkn4OZfiA4fEleebL83PS8/YhktdJFkpcp/dLzpD4WZiPn/lfLX2Zm68I2WHdLF3qepHif0SyQPI+ydskHg+LJEVzoTfCVl0zrB7JI1WflO2vym9zycMlsXh/l+2Jkn7dJI+JflnE4j9fhtghsItl20ni9d24XLhpNzYmTlCFVh2yUr9W+jD/m2vId8hqLZPc/RPWMQxfrjhnS74o8X1/iOQ9ko9LviJxO/1MDdOF4RMVx/P8TLg1VOhVkrBOsfBMrM09j8bqY70PmN1HUqdr+nPXbW3TM6Ft7wM+uP9bSWrc9WPzAa4NJXZ+5qfSniz7Ix1xhtwo3lXdlO9JUu1O2b6jtF1nMu0W6FoU33PZfhIfiEq5FWV8u8RrnDCfQ1IJR2hrw5wTa76feSHHLDzsZ1Eu84eJ/Ld2hBG5ts1bw2LYRhn4h4Syvstfdxk280T6H0TKzJd/nuJUnRdT7zV3Kp9HJOrSNJPfa8vWkb9UHH9+uE7TKh+pT9PnuplYc0ZQlar9LPMaOH+vxPwnKZ7f4QYRf8fxTcm3puW7ujo/r1dOlZwjuUDi99crJLH3W8cbpWvyO43XVv+ShP3jd8B+nb8bukQS5hWG/6Q4H5McJEm9J9W17pvEtZnQjcflF7njKZFSIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAYNYR2GLBj1dapXvXtzu9rr9kKnbd7gmnHbbVUcVGtBCAAAQgAAEIQKAyAW+Wfcd0bG+Y3Ujy0OnrtDp58YapSyWXSa6UeNOX3Sck3ozbjztMkb2pocx58+nZEm+S8eaYlFtZxq9KnpOKJJs3qPpAlOv8Z4kPrq0n2VnyDInzybvfKvBSiTeEDeNeqMRuR7/uF0rgTYTe5JJ3T1fAB6EGdR9VwoMlPoBgt7fkM3f7iv9cJ/X/kzj+DZI3SG6VpFxdbX6KCvFmGvfT+hJvNvS1ivunIrnvvLHH4/dQyW2SmGvCOHq0KrfddAW9wehhEo/PsjZfozjflnhcZ31zmvy/l5S5JyiCx1rKeaPZuZJrpyP9QddTp/2jvDShT56sBj51upH309Xzp+eLB0zrYhfPm96M+0eJ501v4rNzX33nbt9o/rhuD5rO+v66PlbyfMnUtC52cX292dD3i68eS54rsntma/kfL7FbTbKh5CWSNSRl7iZF8Jjxfei8T5CUjbnjFGc3ScyZp8fl7ySelzzufyj5jSTmmjCeXLdtJTtK3D/rSjaVbCApc7crgudic7xa4k2i35Ck3CEyWrqpSAPaXP48iefaMreJIriunuPqdEuV2RaSn/SR6XaKe4ZkWCbuA8/PHnObS/5XEnNLZPBaxvOB5wDX23Nqtr7YVv7ZNibU5L6d15APlHjju5+PVe4bRet4DvKc5rnY89pZkmHcQ5R4oeS+ktUlfja4Ln5uV3V3KuLFEo8Hz11HSaq67RTxzILIH5fuLQX6cavM4j2SPSRlz55h6/YnZfB+yReGzWjI9E1Zm3sMvkHie2Rtie+XR0nK1iyK0vm35BTJHyQ3SLL3j6/Lf6NkENeU526q7tvJ2LRngp+Vrped+9TznZ8360tSzvNJk94HvM7x/LZZqtIVbJ7vvJa9ZTqux/b10/7UxXG83rxc8j3JIknd7inK8LmS9STun1G+q75Q+df1mcKnlNfrJDHXk8FrK88Jl0v8ecAKkodKHi55uiR8BjvN4ZK3SmbKtWHOKWLj+/tHBQbPy56/s7FfEKWSalfFOqEgptey7kf33bBuUuatfjj4XeIdEq8LfV9sKSl6v/A7gOewUTnfl7+S+B4tc37XP1dyleSQSOQF0nvNXeSOlvK1RYYZ1j1e5e85XYfldd1IYi6PmNZVvdyqiFdIfG9YzOImSdNcE+a6pq05B+mjI5TozYMknKE0J6pcrzlG6fx8H2a99FGlP1jizz/s9pZ85m5f8Z/U9w1e771T8kjJPEn4XvkP6R4l8XzWr/NnSJ4L51RMuLHieW4Y5bpvUtdmFRETDQIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCDQAgI77X/e27L/9hu5fmvXXU+o+gVEC1pMFSEAAQhAAAIQmCECT1K53tRXtzxjgPZ4M9ZP+qjLByqW4TXTgRJvzhq2nTcrj/dJvKmqLneMMuqnXt5s5o3EMfdhGfrJz3HdrucVZLhvn3l5PFVxdbTZm336bWcs/loVKj3T48ibKWP171e/e4X2Ooo3UvWb91cq5l1HtJnuE2/q7ZdPKv45dUBJ5OFNgany+7Hl75nDa8y3yibLQdqxV4JLZprp8eR6eFNkP/0Qi3tK1qiS63Nk92bvWD796s9XXvNLyiwy+5l6rKTf8mLxvZbwIfRBnA9CeMNoLO8y/alKu2GuYPMoSxPa8/fBbB0TOYSVvNcNwDnk7ufssM4HPMJ8hwl/tc8KnVBQ/lLpHtFnPqOKflpB/YbhU5T2PJXxAkm4EXxUbaqSbxPW5hupokW8htE9oUrjE3Ga8NxNVO9uU9OeCZ6nhumzfNqZfh9YVW35ksRzVL5eVf1+5/DnB3n3KAWqps/iHZnPoEb/uN9V63i/dvN9uCdjU8f1SuW3kzNugGvDnBNiWkGKonXp8WHEAcPO/2+SsK/9fleXm6R5qyqTjRQxZBqGb1OcjatmOES89yttWHYq/PtEWWdE8vKPPvlAehOd75VUewe1bdTExk7XaabnOrMZlGss3bBrzn67a5DPnGJ1H4f+uH4bOGD8JrzTuOpln8W+acD2Zcn2lafq+nSj6USjXPdN8tosYz6ya5M+FBhZI8kYAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEZp7AVGepP9BPuTX/tt56/kVRHAQgAAEIQAACEBiGgDcT3jVMBjWmvUN5vVRyS8U8fWi1inP7DpU8ROKNjD4I3K/7sxJ4g8mGkndJbpXU5fZRRs7b7S9zLtcHtq5ORDxItqdJfpGIkzctVuDJku/mldN+j49RuLrbPIo6hnnO9Diqel+E9R4m7I2DTXZt6hPX1fe4N5HNlKs6Z/Zbv1S+bve/chnan/3Hj5y6L6/zzLt8OJZ3qo5ZXs5npp8Vdd3n3mRaxXlj6yYSz8l/qpKgIM5V0h0m2Uzi/5ZS9lmGotzL+dm2p+QxEvfBNZJ+ndl9SvIEyVMkX5cM4r6hRG7LWX0mNr8XSnzIxWuGutxsHRN18Wt7Pv30/wPV2OcXNPh06VKHOQqSjExV9N/vhinMc8dvJZ+R7CbZQLKV5NuSmXzeqvhl3EEKNX1tvkyFxxS4S+XM9HO3rKmT+kwoa3fePqr3AR8Y212yjeQn+QIr+D+oOK+QhO/Prmt+DZT5vf68UzLJrq73ax9g+YLE/zXU9+ig7v8p4d4S/wDFqYNmUnO6Nsw5YZNvj/A7Now4YNj5F62Zi3QDFlH5871B8y9KN6p5q6isQXX+bPLyQRP3kc4HgK/sI37svXl15eH5usi5LdcVGdDNCIE2znUzAipRaOw+SCSZUVO23hl1JZryTpN6p7xAED45JIijlX4PSerzxe/I/gbJ9ZJRu0lem42aXSc1WEZeOAVAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIDA7CIwb//zju/0euvGWt2dmjrn1I9ueUjMjh4CEIAABCAAAQhUJOADN6tIvPnv39NX+72h1uLNspZsI7030y0n8XWuZKVAVlT41xL/J5FBnDeJrinxoQfL3yXewOQ6+j8F3Wfa/1NdY5sxZIo613tLyTMlj5OsLVlH4jK9OfiGafEBpHMlp0kukYzaPVAF+D8WPkOyvuQBEu9TuFZyqeQMyUmSP0iqOP/I+YskT5I8dFo21tXMrpT4gNIxkhMlKbeZjD4I7H7w1WPDY2EFift+tWlxv/xC4s3cVd0wbd5QhVjy4zYbv9nV49Yc3OcesxbXeeXc1eP1fInj9uNmYhxtrgq6vR6n2T3qet8xLe7bfHuz+9NtzN+nHkPXS6q4TRXJZWX3og/b+H50Oc7f48D3pceBx4Dj+TDOTLhx94kZbCEx96w/Ylczy5zHofvE49BifhaP24sko3Luo0dL3IceQy7P48f1z1+9eXB5ietocR/nr7bl7xmPA88Tvvedr8VlWJx3kXNfhe03g8slV0tSbg0ZN5Z4DP9VYuZ55/qtIsnGpcv5aT5CRf+4x5OrZZZPkdwmcf9kc1l29TgyU8/B2Thy32T3d+Z3X/xS0q97uBI8XbKtZF3JWtPievne9kZYM/+N5MJpcTl1bzg1+3mSrSXrSfysyMR1uVJy+bRcpuufJKdIPObqdI9QZq+WeK2wgcR18XPZDG6UeAyeJ/mh5GJJzHkevUOSPUf9LDUzt8XiMZqNWV8vl1wtsbOdMXE3iuSfLWT1/eH5J5uLPDdYl4nvG48t3zuWFSR+bmXisXSNZBjnefbxkuz+ze7d7Oq5NquPx4DnK9cjk2yuzcJ+JrhNVdy7Fek9BRGfJ933CvQzoTIbj3fPcRb3VcbG/ZXvo2w+y5iYle8Hx/M9aHHaNjmvG14keZLkodOysa6e1z2v/VlyjOREScptJmO/a3OPqc0lnoss5phJPuwx6vvEvLPxmfnD688Vx31Yl3O5W0qeKfG8u7ZkHcmaEt8HN0zLNbqeKzlNcolkXO4RKmimnwluq/vRfWcmvrr/3G++WjyePNbM03Od7xuvE7J7Klsz/EE6P8equE0VyWV5LeBnmZ+3nstcjvP3+MrWXZ5THe+3kn6c74kXSJ4meaBkXYnz9PP2WonzO0Ny+nRYl0L3WGnNw+n+JvG8kjk/wz0HrZ4Tx/ujpG63oTK0mFs2z4VX1zPfV+4v94/rmF3db+dLHLeKM7uXSJ4hWV/yAInbbYaXSs6QnCRx/5c51+MJEvd/dk/eT/5MbPdcdNO0/E7XH0/Lb3Rtumv6nJPx214eP8szd5U8H5UszRRDXh+j9Hvn8vCYfZvE65S63ObKyPlO2rwV4+M50et33xter/hqt4bE94+vfoaaxzjcQ1TIOpJsDs/mcc85fravKvHcbfmzpOjZsJf0n5OEzvEfLalzPRCWMUx4EyU28+w5WXb1fZU9P311X+afn/ZbLpB4TLfBuR1bSsa1vjIz3/N3TIs5ZWJd5ndfuG7Z+tLpMn949f0yzjG2msrz3HibxGse1zk/drL3uezq+TITee92fr77+etrJm6v101F4jabQZ5DFs/3qvOyc5kep65PJn4ujPO56/a8SPIkyUOnZWNdvQa9UvJnyTGSEyUpt5mMXkd4TvLVnN02M/A6yP1g8dz0C0k2BjaU33Oa5yqndZr7S6y7XHKtpA7nZ+/XpjM6T9fTJadJfiZxP+Sd62RxG8L1XhZ2f5mdx4H71OJ29rPum/S1mXDU67Ibp95cyQ0CEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgUEBg3v4/3r3TW/qqAtO0qrdk7pK5Lzz5yKf6Cw4cBCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgMLsIePPw5ZL1gmZfofBDJOEG5SAaQQhAAAIQgAAEIAABCBQS8PmpiyU+6Bu6+VL8KFQShgAEIDAhBPxDKv7xBB8Gx7WQgE9c4yAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACYyGwZM7tp+g3XRO/tN1d7s7ll8wbS2UoBAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEGgageeqQuHhX9fxaAmHf00CBwEIQAACEIAABCAwCAEf8i06/Hus9Bz+HYQoaSAAgbYQuE4V5fBvW3qroJ4cAC6AggoCEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAARGQ+CsQ7e/Tsd/L0rm3uv6y1ccBCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgMPsIvL6gybdL97kCPSoIQAACEIAABCAAAQhUJXBAQcRrpVtQoEcFAQhAAAIQaAwBDgA3piuoCAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIACB2UGg2+kuSra013vYvAXnPjgZByMEIAABCEAAAhCAAAQgAAEIQAACEIAABCAwaQQ2UYN2KGjUCdLdUKBHBQEIQAACEIAABCAAgSoEtlCkcJ3Zk25vyc1VMiAOBCAAAQhAYKYIcAB4pshTLgQgAAEIQAACEIAABCAAAQhAAAIQgAAEIACBWUpguSVrn93pdm5NNb/b7eySsmODAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEJo7AayMt+mREjxoCEIAABCAAAQhAAAJlBHxu6siCSB+V7gcFelQQgAAEIACBRhHgAHCjuoPKQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCYfAInH/mw2zu9zlnplnZ33G7hmcul42CFAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEJoTAKmrHHgVtuVC6Cwr0qCAAAQhAAAIQgAAEIFCFwF6K9OQg4o8VfnugIwgBCEAAAhBoJAEOADeyW6gUBCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFJJzC1KNXCXq+zxtyb52yeioMNAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQmBgCu6klqxe0hv/+WwAFFQQgAAEIQAACEIBAJQJrKNb/BDH/qvBLJEsCPUEIQAACEIBAIwlwALiR3UKlIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhMNoHTDt/y4k63c3Wqlb2p7i4pOzYIQAACEIAABCAAAQhAAAIQgAAEIAABCEBgYgi8vqAlPpzxtQI9KghAAAIQgAAEIAABCFQh8B5Fun8uYk/+V0quyunwQgACEIAABBpNgAPAje4eKgcBCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAYHIJdDvd5H8B7nS7m2+335n3nVwCtAwCEIAABCAAAQhAAAIQgAAEIAABCEAAAhAQga0kjy8g8Xnp/l2gRwUBCEAAAhCAAAQgAIEqBNbNRTpb/m0lJ+d0eCEAAQhAAAKNJ8AB4MZ3ERWEAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIDCZBLpTnVP0X4D9K8vFbmlnuTlz5swrNqKFAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEJoTAgoJ2LJXuqAI9KghAAAIQgAAEIAABCFQlsKcifkTi75y3kyyW4CAAAQhAAAKtIsAB4FZ1F5WFAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIDA5BE75yFZ/UWt+lmrRVG9qfsqODQIQgAAEIAABCEAAAhCAAAQgAAEIQAACEGg1gQer9s8raMEi6S4r0KOCAAQgAAEIQAACEIBAVQL/UsQDJadXTUA8CEAAAhCAQNMIcAC4aT1CfSAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIzCIC3c6UN/JFXa/XechObz77YdEIGCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIE2E9hPlZ9T0IBjC3SoIAABCEAAAhCAAAQgAAEIQAACEIDArCLAAeBZ1d00FgIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIBAswgsd+fNizvdzq2pWvXmLsd/AU4BwgYBCEAAAhCAAAQgAAEIQAACEIAABCAAgXYSWEPVflVB1W+S7sQCPSoIQAACEIAABCAAAQhAAAIQgAAEIDCrCHAAeFZ1N42FAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEINAsAicf+Yzbu73eGcla9Xrztlt45nLJOBghAAEIQAACEIAABCAAAQhAAAIQgAAEIACBthHYRxVetaDSX5fu9gI9KghAAAIQgAAEIAABCEAAAhCAAAQgMKsIsGFqVnU3jYUABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQg0DwCSzrdRXM6nWdFa9brrDbnlrlbyH5uNA4GCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAoG0E/lcVPlJys2Sp5D7T8ildcRCAAAQgAAEIQAACEIAABCAAAQhAYNYT6M56AgCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIACBGScwb8G5X+p0uhvEKtLtds4/9bCt3xGzo4cABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIDBJBKYmqTG0BQIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABNpKoLsoVfNep/uUZx587hqpONggAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhMCgEOAE9KT9IOCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAItJrBkasVTOt1OL9qEXm/O7Uu6O0XtGCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEwQAQ4AT1Bn0hQIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAm0lcNZHN71R539/mqx/rzs/accIAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEBgQghwAHhCOpJmQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhBoO4Glne6iZBuW9h60/VsWPyIZByMEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIEJIMAB4AnoRJoAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQGASCKy52hrndbrdf6baMmdOZ5eUHRsEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFJIMAB4EnoRdoAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQGACCHxj4aPv6HR6p5c0Zfsn73Ph3JI4mCEAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCLSaAAeAW919VB4CEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAwGQRmOpOLUq2qNdZbY2Vb9sqGQcjBCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIACBlhPgAHDLO5DqQwACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCYJAKnfHTL33WnOlck2zQ1NT9pxwgBCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQKDlBDgA3PIOpPoQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCaNwNKlS5P/BbjX62224xtOu9+ktZv2QAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQyAhwADgjwRUCEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAASaQeCOO07tdTpLY5XpdjpTc1ZaaaeYHT0EIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIG2E+AAcNt7kPpDAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEJgwAqd/ct5fdcj3J6lm6b8Az0/ZsUEAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEGgzAQ4At7n3qDsEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAgQkl0O0sXZRqWm9pZ6N5+52/SSoONghAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAm0lwAHgtvYc9YYABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgMMEE7lz9rvM63c7fU03sTS3dJWXHBgEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAoK0EOADc1p6j3hCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEJpjAWQu3X9LrdE9PNbHb6Wy/68JfL5+Kgw0CEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgEAbCXAAuI29Rp0hAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCMwKAksXJZvZ6616y803b52MgxECEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgEALCXAAuIWdRpUhAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCMwGAqcfts0fOlPdy1JtXTrV2yVlxwYBCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQKCNBDgA3MZeo84QgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABGYJgW6ve3JJU5+8y5vOWaskDmYIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAKtIsAB4FZ1F5WFAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIDC7CCy//F2ndbrdu6Kt7nW6dyw/tXPUjgECEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgEALCXAAuIWdRpUhAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCMwWAj/44DY39Xq9C5Lt7XXmJ+0YIQABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEItIwAB4Bb1mFUFwIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIDALCSwKNXmbq+z/tMXLH50Kg42CEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACbSLAAeA29RZ1hQAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAwCwnctfqd53e6nVtSTb+r29klZccGAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCECgTQQ4ANym3qKuEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAARmIYGzFm6/pNPrnFbS9O13edMPVyiJgxkCEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgEArCHAAuBXdRCUhAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCMxuAnM6U4uSBHqdle9c7j7bJONghAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQg0BICHABuSUdRTQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACs5nAjw7f8o/dbudPKQay75KyY4MABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEINAWAhwAbktPUU8IQAACEIAABCAAAQhAAAIQgAAEIAABCEAAArOcQK/TPTmFQPYn7nzAeWun4mCDAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCDQBgIcAG5DL1FHCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQ6HTmrnBaZ6qzJIpCJ4B7vaVPj9oxQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQaAkBDgC3pKOoJgQgAAEIQAACEIAABCAAAQhAAAIQgAAEIACB2U7gtA9teku31zk/xaHX685P2bFBAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhBoAwEOALehl6gjBCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEI3E2g25lalETR6zxwx7ec87hknGnjk/e5cG6VeMSBAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAwbgLLjbtAyoMABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIDEpg9SuvuuDmDR54U6/XWSOWx9Ryc/xfgH9ZZF+4sDe1+O/nPaXT6SnObf6M/F1F8dBBAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCYSQLdmSycsiEAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAAC/RLYccG5r+92urvG0umD79vuXP3OF5y1cPt/Z3F2eOt5G83p9ebr4PDO0q05rf/haYdvfWgWhysEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIGmEOA/ADelJ6gHBCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIVCKgA76LFDF6ALjX6aw095blt93qoMXnr3Tn0h06nan5naW9R0q/rJvTvXFZBSEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAALNIDDVjGpQCwhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIBANQKnHb7NpZ1u75Jk7G7vtSsv6XxLh3/3U7xHFsWdumspB4CLwKCDAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABGacAAeAZ7wLqAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQj0S6Db65ycStPrddaQzE3Fuas3xQHgFCBsEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgMCMEeAA8Iyhp2AIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhAYlMByS+ae3un0lgya3umm5s7hAPAwAEkLAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCIyMwHIjy5mMIQABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIjILDTgsWb3tm5c35nqtvpLB28gOXn3MkB4MHxkRICEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQGCEBDgCPEC5ZQwACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAQD0Edljw4/W6naXzu1OdnXtLO2t3OsMd/u10u3f94INb31RP7cgFAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIBAvQQ4AFwvT3KDAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIACBmgg8e5+TVv73qmts1+t05nd6Sx97d7ZD/MffZarV7f11mTABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACDSLAAeAGdQZVgQAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAgf8jMG//c3e/rdN5eafXWWEkTHodDgCPBCyZQgACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAJ1EJiqIxPygAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQjUSWDJ0lVP7HW6V9aZZz6vbnfqhnwYPwQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAgSYR4ABwk3qDukAAAhCAAAQgAAEI/P/27gPemqI8HPD3odgBwa4oYm9YECuIGrAbW4yJsUWJxkrssZeoMRo7Go2JEWs0Go0lRgUUxd7/IlhQBBUUqYLS4fu/r7lLlnV3dk+79+y9z/x+r7s7Mzs7++ycPfvJmbsECBAgQIAAAQIECBAg8HuBg193i1MustU2T960edOhiyA5f8sWbwBeBKw2CRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCYi4AJwHNh1AgBAgQIECBAgAABAgQIECBAgAABAgQIzFvg06+62e+2PufUZ0S7X5l325u3bDlh3m1qjwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAvMSMAF4XpLaIUCAAAECBAgQIECAAAECBAgQIECAAIG5C/zPfvc8a/tfHPu8TZu3HDjPxjdv2mwC8DxBtUWAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwFwFTACeK6fGCBAgQIAAAQIECBAgQIAAAQIECBAgQGDeAh/4wIPOO/A1d3jZls2bPzyvts/bspUJwPPC1A4BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAnMXMAF47qQaJECAAAECBAgQIECAAAECBAgQIECAAIFFCBz0mt3fsGnTlnfOo+2ttpxnAvA8ILVBgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMBCBEwAXgirRgkQIECAAAECBAgQIECAAAECBAgQIEBgEQIHvvYOb9+01ab9Nm3etGWW9i+5/SVMAJ4F0L4ECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECCxUwATghfJqnAABAgQIECBAgAABAgQIECBAgAABAgTmLXDgq/f40JbNm16+afPm86Zpe/OmTWd87EW7nT7NvvYhQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAagiYALwayo5BgAABAgQIECBAgAABAgQIECBAgAABAnMVOOjVexyw5fxNz483AZ89acPnb9504qT7qE+AAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHVFDABeDW1HYsAAQIECBAgQIAAAQIECBAgQIAAAQIE5iZw0Ot2//KWrS76jJgEPNHbfDdv3nT83DqhIQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECCxAwATgBaBqkgABAgQIECBAgAABAgQIECBAgAABAgRWR+CgV932u5vPPe/JMan35KFH3Lxp0wlD66pHgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBtRAwAXgt1B2TAAECBAgQIECAAAECBAgQIECAAAECBOYmcMAb7njEOeecs2+8Cfi4IY2ev2XTiUPqqUOAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIG1EjABeK3kHZcAAQIECBAgQIAAAQIECBAgQIAAAQIE5iZw8H53/sW5my/xxM1bbTq6r9F4W/DxfXWUEyBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYC0FTABeS33HJkCAAAECBAgQIECAAAECBAgQINAvsDmq3CnipRFvj3h/xCsi9onYJUIi0CZw9ch8asRHIm7bVmE95h386t1OuOjZF91301abflA6v83nn78R3wC8IcdEaRwoI0CAwCoK5PPcbhH5PPfhiOtFSAQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoChw0WKpQgIECBAgQIAAAQIECBAgQIAAAQIE1lLgBnHw90XcrKMT/xn5D+wok73xBK66Mh7+LJa3i8jJRpm+shK/31jv//M/+9321Ns95UtPvczm8166ZcvmXdvO99xNW53Qlr8O84yJdXhRnRIBAqMRuFj09M4R9424T8TVIqr0wVj5UbVhSYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE2gRMAG5TkUeAAAECBAgQIECAAAECbQJbR+YVIs5YiTPbKg3Iyx9BX2IlLh7LjItE5L9Rt4o4OyLbzjgp4pwIiQABAhtR4KFx0m+JuHTh5POeLG08gSvHKV8/IieIZ1Tr14z1atJvrF6QfnfB2gZZ+fJrb3/GLR/zjWftsM3Zz9ty/vl7Nk97q/Mvut4mABsTzYvcvp3PmvnsWaXzY+WsamOKZT7D5jNyPt/mMiOPkZ+50yKyfYkAgfUvcMU4xfw+vm7EdVYi1zMuFdGWTm3LHHnePtH/y6+cwydieejIz0f3CRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgsOYCJgCv+SXQAQIECBAgQIAAAQIECIxGYJfo6Tdrvd0S6/XJwDlR99yVyMkO1aTearJvLi8ZkZMihqZs57iIoyO+GHFgxCERG24iU5yzNH+BO0STD47IiXO/ijgo4u0RObYlAmst8OLowAsGdMIE4AFI66zKK+J8njnhOW3I781vvnW3c170oi0vPuS0Q56++fyt7nGB2eZNW87b/owTL9ge/4oxMfwa/lFUPaBRPb/3cxJw9Vyby3yuPS8in1vzv6NsvRI50TcjJxHnsvRcm+3mJOCfR3x5JT4Ty6MiJAIE1pfAv8Xp3GvCU/rNhPWXvfo1ooNvjajui7vHer71WCXaCCMAAEAASURBVCJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYBUEdo1j5ESGtY6coPG2iHzTnURgWoGcPHd+RHM8fzLy/MG0aVXtNy+Bl0dDzbHZtf3meR1UO6MRePUE46MaN382mrNbUEfv8rQvPHbvp3zhs7+Pp37xwws6zFo1a0wMl987qlafi7VY5h/LeWfE9YZ3WU0CBEYg8PHo46T3lJuN4Lwm6eLzGwb5RxSuNUkD6hIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAHwpUf4X5D0vkECBAgAABAgQIECBAgACBCwvk2wO/FJFvMPtJRE7EXYuUb1t7VMQREc+O2BwhEZhE4JZR+e8j2sbO3SL/6ZM0pi6BOQu8Jtp71gRt5tvVpY0lcEyc7rdX4nuxPGHA6f92QJ11XeWAV+/xljjBf8mT3LJpyxCzMXkYE8OvVr5xM59nMw6NOD1iNdNF4mAPizgs4pGreWDHIkBgoQJfiNY/sBL/FcuvRuQfGyqlU0uFIyvL/968T6PPmffERp5NAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgRWSSAnT+4ckW9MHfK2o3Oi3iERz4u4S8QuEVeIyIkQO0bcMSInQrw04rsRQ9rMOm+MkAhMIpBjrDS+vj5JY+oSmKPAq6Kt+tg8I7b3jbhJRN4r8565V8RHIqp6OdlEInC/IKjGRNvyjoj+V2Cvpx5y73gb8Ms2gIcxMewi5/PsdSNyQnDbZ6eed3TU+WJEvkH6nyNeEvHciP0icsLfNyN+HVHfp2897/ESAQLrU+CP47RK94ArraPTvmfHuZ4c+ZdeR+fpVAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiMTiAnTvwsovTj5nyj5bYTnFm+LehREcdGlNqtynJCp0RgqMD7o2I1dtqWpwxtSD0CcxR4fLRVH485Du9QaP8+UfaJiD8t1FG0sQTyrbb1MVRf321jUZTP9k5P+8blyzXWTakxMfxSXiyqnhRR/9w013cd2Nydot5netqq2j476t00QiJAYP0J5L+T84+5VJ/35vIy6+iUP1Y4z3zGlQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQWEOBfBNa8wfN9e2HT9m3fFvQG3razuOcH3HjiI2Srh4n+tqIx22UE47znOc5p119fDbXD99Ark51OQTuEd04N6I+FvOtkhKBSQSOiMr1MVRfv8EkDam7bgSMicku5aejev1z01y/9mTNbdoj6n+vp808xsEREgEC61PgmDit5r2k2s4/erUe0s5xEudFVOfVXOa/rXIytESAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwBoJvCWO2/yhb317ljdU5g+jP9fTfh5r/4j1nq4RJ/j6iDMjKt+d1vlJL+Kc713zqxzryzeuc1Ont1wCV4zunBxRH4O5fq3l6qbejEDg0OhjcxxV2zuOoP+6OH8BY2Iy0/2jevWZaVvm/XrSdL3Y4bcRbe1VefmHbPJ5RyJAYP0J/DhOqfqs15f5ZuD1kv4xTqR+bm3rd10vJ+s8CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECIxR4CXR6bYf+lZ5OeFylnTN2PnUiKq9tuXZUX75iPWYbhMn9b6IcyKa537Z9XjCcU6LPuf3tlim7ZER20VIBFZL4O1xoObnOicESwQmFfhW7NAcS9X29pM2pv66EDAmJruMr4zq1WembbnNZM1dUPtRPe3msR53QW0rBAisJ4GuCcDr5VnvUnGxTopou2fW8z6+ni6qcyFAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAwNoFnRIfrP/Btru81hxN6fM8x8ph7zuE4y9bE/QvnfW6UbV62Ds+hP6txzun2pIgvRZwYcVjEfhEm/waCtGoCN40j5Zsfm/fML65aDxxoPQl8pWUsVWPr4uvpRJ3LYAFjYjDV7yu+KP63+sy0LbeerLkL1S5Nxs5jvfxCtW0QILBeBLomAB+/Tk7wMXEebffLZt55Ue866+ScnQYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgRWVWCrVT2agxEgQIAAAQIECBAgQIDAehU4s+fEzugpH1L86QGVdh5QZ2xVShN8q7cij+2c+vq7GuecP0rPCb+3j7hcxI0jckLwbyIkAqslcN84UNt4/9VqdcBx1pXA2YWzyTfISxtPwJiY7Jr/rlA9/1jDLJ+jbxbazqKr9JQrJkBgfQnkH3JaD+lvBp5E/vfoJw6sqxoBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQI1ARMAK5hWCVAgAABAgQIECBAgACBqQX6Jvj2lQ858JFR6fSeiutxAnBpcvVpPR5jLd6I5zzWa6Xfswnco2P39fJWuI7Tk70gga7JRPkHD3LyorTxBIyJya556fmjy3LoEQ7tqTjL5OKephUTILCEAvlG3LGnu8YJ3Kh2Evm8UbpX/mWUX6ZW3yoBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIDBAwAXgAkioECBAgQIAAAQIECBAg0CtwVk+NeUwAzslLh/ccZ+ue8jEWl+zW6wTgjXjOYxyb+jy7QL55ui2d3JYpj0CPQNck39JknJ4mFY9cwJiY7AKWJuTNOkH3pz1dOaynXDEBAutLYD18Nz+5cUn+I7Zf1Mirb24XG39Zz7BOgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAv0CJgD3G6lBgAABAgQIECBAgAABAv0CfT9gLk3o7G/9/2oc+X+rrWvHteaOO7Nk97txn1pn7zfiOXdiKFi3AvkHC7btOLuzO/JlEygJ5Jv32tKsExfb2pQ3DgFjYrLr1DVhOlvpe9btO9JVeyr0vSG4Z3fFBAiMTGDWe8pan+4NogN3b3TiTbH9LxGl59gnRPnmxn42CRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKAgYAJwAUcRAQIECBAgQIAAAQIECAwWKE2YyEZKEzoHHyQqXqqn8q96ysdYfGah06cXysZctBHPeczXS9+nE9ihsFtp4kRhN0UbXKDru3jsk4w2+GWd6fSNicn4Sm8ALpUNOcrNeiqZANwDpJjAOhMY+3dzvv23PpE372GHRPw64gMRXSknDt+tq1A+AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECPyhgAnAf2gihwABAgQIECBAgAABAgQmF+iaYFK1NK8JwDtWDXYsv9iRP+bskp03AI/5yur7Rhe4dAHABOACjqJOga63vY59klHnCSvoFTAmeokuVKH0PNtleaEGChulCcAHxX45aU4iQGDjCIz5u/lycZke3rhU+fbfKtXXq7z6ct/6hnUCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKAuYAFz2UUqAAAECBAgQIECAAAECwwRKEyayhdIk1mFH2LQpf2h800Ll70TZMYXysRadU+j4PFwLza9Z0UY85zXDduClFOi7py5lp3VqzQW6JiiW7qlr3mkdWKiAMTE/3i7LIUfIZ9iuCcD5Bx+eMKQRdQgQWFcCs75VfC0x/joOfslaB34T6++ubX851r9d226u3j0yrtvMtE2AAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC7QIXbc+WS4AAAQIECBAgQIAAAQIEJhIoTVbLHzfP4w1H94x2Sn/I6l8n6vHwyltH1TtE7Bxx9VpcMdbzDbwnRJwYcWzEIStxeiznlUp2i5wAfKk4gb0i8sfZ14q4dsROEWdGHB1x1Er8IJYHRJTGQBRPlFb7nC8WvfvjiEdE3CDiDRFvjJhnWutxVD+XG8bGn0U8MOJ6EbtHfD2iLeWYv3HEjVaWuW+eyzERv1iJT8Wy9CP/KF7KtEzXZCmBCp3Ktxc/KOJRETlGbhFxckQzXSEybh2xS8RNIvJecl5Ejp2fRhwZ8d8Rv4yYJG2OytlW/lGIjJxYd+WIX0Xk/Snb/VBEjtPVSsswnromKJbuqbP45PfiLSOuW4scGzkW8rsxvxc/H3FwRNv4iOy5pryX7x2xR8RVInJM5Hd1jpf8vjwl4icRP4r4ZMSPI2ZJl4id7xuR3x05Bu8UcUTEPNLNo5H7RdwnIj8ze0ZM852/0cdEsM0tdVn2HSDH3zsj8rPRll4VmT9sK1jjvLV8DqxO/eKxcteIfF65d0Te33eNaEv5ed8n4nYRO0VcJCLvO4dG5DPd9yJmSctwj6/3fwz3n6q/6+m5c4c4qbzv578XrhORY+3MiKMifrqyzD9K9c2IvjTWP86Rn4UnNE7uHbGd/y6upzfFxr/WM2rreV98UsS+tTyrBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgsUOD+0XZOjGiLefy4OX/Enz/cb2s/83KyV078mWe6cTT26ojjIrqO25Z/VtQ/OOIBEfnj5lnTVaOBtuNk3ltnbbxl//xBe/5Y+9SIruM283PiyqMi8gfh80ircc7bRUfzGuUP1k+MqJ/Te2J7XmlZxtF144SeG/HdiPq55npOMGumnPD9PxHNul3b3466+UP+nKyz7GlZrsm1AqrL82lLiJhuT474eMRvI+p9z/tGPeW94G8jmvXq+1Tr+R3x4YjbRAxJOV7znlPt37U8N+pku3eIWGRalvGU55iTqds8jp4jwFbR1r0icgLt+RFtx2vm5QTW7FtOBl9Eymv83oh8A2Hz2KXtL0T9R0fk98HQlPfGx0S8P+LkiHr7Ofl42pTPOXker4nIZ5p6u7m+Y8Q0aaOOiWmscp99Ipr21XY+D06Tnhk7VW00l1+PsktO0+gC91nr58Ad4tzuG/HuiOZn+rSW885n7fy+OTui6Vtt5/1q2rRM9/gx3X/W03NnjrG8v/97RE72rcZVafn9qPfsiLx3/7hjny9H/hjTQ6PT9XPPZ4Hrt5xI/hGBkxp16/vl53ublv1kESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCwAIFFTwB+XPS5/oPh+nr+6DgnI80r3Tka+mpE/RjTrudky5zEMEvKtxd2Hf/1Axq+6IA6WSUnI74zIidqdR2vL/9nse/uEbOmeZ5z/mj/mhH3jHh6xP4R+aP80sS1N0f5rGmtxlFOwN014hER+VbBT0UcG1G6dneP8nrKH/afEVHap6vsW7HfdeqNLdH6Wl2TLoJ7REGX4/OiLCdBXSlix4j8fOYkpNtH5H5/HvGoiJxoO++Ubd4k4sERL4v4aETfGMo+Vimv/2ERXefWlX9W7JNjryvlxKcDI7r278rPz/pLIi4SMc+0bOMpz22Rkz1zXOQE8J9EdFkPyf9g7L9txDzSnaKRz0QMOW6pzunRxtUi6ukKsZGft4dH/F1ETvw6KqLUzq2ivC9dLCrkBMt8btk34i0RX4n4XUSp7bwfTJM22piYxqi+zz6x0XUdjqtXHLiez8f5Rw7a2syxu0yT3/J75p0Rq/UcmPeUO0Y8LmK/iIMifhXRZlXlnRLl9ZRt/GdEVd61zDqTprW8x4/p/rPenzvzGTmfbbvGVl9+6fP0uUkH5ZLU/0bD44BCv17dqNv0yu9BiQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBVRBY5ATgO0X/c2JY8wfD1faL53R+OTksJ4l1/VD761H2hoicAPXEiNdGfCJiyJugcqLu0Im4UfWClBP+/i2iOte2Zf4IO3+Y/p2I70UcEXF0xPER2bfzI+4T0ZW2i4J/jCgZtx23K+830daQSVBd/Zn3OT8nDtTV1678V3R1bkD+Wo+jx05xvnvVzutZsZ5jpstmSH6Ogb1rba716lpfk+b53ywyPhIxxLKvzs7NxuewPU3fLrdy3N1imZPk+vpdKn92yzncYg7tfiramOY+3OzOso2nev8WNdnzpnGQb0c0r1t+X+b3zv4RT4nI78f8bszvoWbd+nb+EYbrRUybbh475sSpepuzrOc9L99UWE+Hx8akbV673kDH+iOnaDf7kZPspkkbZUxMY9O2zz6R2XXdJ5kAnGO0a2Jq/oGNZ0bkvWQZ0lo9B+4UJ99l3ZV/QgPs7QPbyPvS0LQM9/gx3X/W63Nn/gGIru+Z06Ps6IiTIrrG6pD80sTZaHop057Rq+a53bfQ0/yjMKV/V/wwyjcX9ldEgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMCcBO4f7TR/DFxtnzPlMfLHwA+POKXQ9j9H2Tx+NHyNaOcLHcf5WOTvHtGVrhYF+eayvjemHhx1LhvRl7aKCveOyB+FV4azLtOxmXKCQ/5o/9cRzfbzmn01It94+PKI10fkm9na6jb3ze0TI3aJGJoWec7PjU609bGUl/tMk5ZhHE0zEeOOcbJ5Dd4YUXKZpCzHSr69dq3TMlyTyuCGsfIfEedHTGLZVfesaGceE1qjmQulfONv1zG78reJfe4ecdoU+zbbTJ8/iqjSnWLlNxHNetNsv6JqdMrlMo2ntlOY92TP/J54fsTZEU3vL0Xe1SLaUn4v3zXisIjmftX20VF2+YhJUo6znMh3bkTVTrXMcXNkRI7fvM4viviniHxrdH5Wqnpty59HeTOV+t7WRuYNeUvvI6Ne1/5d+Xm+06b1Piamdenab58o6LoO+b2Wb3Cup9zOP4Cwa8TDIl4Z8YOItjby2Wr/iJwQtwxprZ8DdwqENqdS3nE1uBdOsP+Ta/uVVpflHj+m+896e+68cgyQ97SMrSMi7xkRzc/vZSLvthFviMg/vlQav82yT0f9saUPR4fr55Hf5XkvKaVPRGF9n+b6PUs7KyNAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYD4C854AnG9d+lpE8wfC1XZO9HnmfLr++wlMv2o5Vh4j34Y6NF0vKv4ioupj2/JTUV76kfRDojx/YN627yx5e0WbzXTLyGi2+dvIe13ETs3Kte2dYz1/sN7ct7mdk46GpEWf819EJ3ICWMbnIw6PyGvb7G99+0lRPmm6WuywDOMoJ9TlhPQ3R7wt4gMRP46on19z/S5R/qFGnXNi+2MRr4p4XMRDI3LiQ7Z5akSzjbbt/MH/WqZluSZpkJNDzotoc5o279BseAFp92gzx0/+gYWcBJOf99MjSv18TJTnmKnqnB3rOVb+PCLvNTeIyHH2goicwFXV61oeFXVysucDIs6MqNfL++z7Il4SsW9E/pGC/4qoH79ev76en/07RkyTlmk8dfU/77v1863Wc4LOpGlz7PDOiKqN+vJNkb/1gAZzYtR/drSR7eV9ufSdGMUXpFvEWtt37O8iP+9ReayudOkoyDcUHhxRP49q/TOR30w5Cf1lK/GPscwx1/eHPraKOn0p+/LCiGz7FRH/GpHPBqX7Q95zp03reUxMa1Lab58orMZF1zKvVd4T8z7XVaee/8uo9+qIa0YsU8p7c72fub6az4H5R3Gqz1gu8zvngIjSZ+GYKM/0JxF9z3L1c8vvkr60TPf4Md1/1tNzZ36XnBJRHzv5bPG8iItH9KWto0I+lwx9Ts7nqzGla0Vnm5/PZw84gXtFnbppc/2TA9pQhQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBGQVmnQCcP6q+YcR9It4b0fxhcH37sCi/S8Q8Uv5Q+4sR9far9UdOcYDrxj7HdLRXtfuaQrs58aGqN8/l9VuOefPGsXIiRU7SG5JyYtjTI86K6OrnuVGWkyn60mqec9WXO8dKV78z/xFVxYHLZRtHbd3+YWR2nXP9x/x5Tf854poRXSknZj45om8yXB5vp65GFpy/bNdkjzjfLv+u/NNinxMijo34+coyt3NiSU6KzXvlaqXd4kBd/WzmvyPqXqPQsUtEWU58bO7X3M5zzvtIlZ/31idGXCyiLe0cmXnsqn7X8t/bdu7JW7bx1NXdeU72fGOH5cu6Dt6Rn9c7//BC1/V4WMd+9ez8/DQnZWV7X424br3igPW9o05+jur9ecuA/bLKQxv71dv47cA2uqo9stD2cV07Dchfr2NiwKlPVWXIBOD6dR+y/v3oyccj8jP1oIjtIpYhLctzYNPigZHR5Xp0lN0sIj9vXXXa8nNCbSmN4R4/tvvP2J47255LcpL/kMnjzbF19cjouvfWx+fYJgC/Ps6r3v98Fr1C8+RbtvOPYxwZUd+3vp7/Bm37t2pLU7IIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEJhWYOgE4Pzx+pciciJETsLKyZ8/jahPQKz/ILi+nm/+e3zERSPmlV4XDdWPUa1/dIYD5A+Y+yZG3qmj/cdGfvqky39FvDti/4iqX83lR6Js94jbR9wu4rYRt464VcRuK+tZlhMbmmmXyKi399lmhQHb9260UW8v1587oI3VPOd6d75b6Puf1isOWF+2cdTW5ZcWzre6bjkpLsfO0JRj7ZcR1f5ty7y+a5GW8ZrsHRA5CenmETlBNicxtZll3tMili2dHB3q6m+V/6wJOp11q/36lt+KutsPbDvf1lpqLydWX3JgW1W1ZRxPVd/qy/+OjbZzz0lzk6Qcf23t/CDyLz5JQyt19+poL49xWMTmlXptiz0j83cRzf58MPKmfR64Q6O9Z8b2kJTfq81+VNt5L5wlle4Hk16/ej/W45ion9+81xcxAbgaI9XynOj0ZyKeEnGZeZ/ABO0ty3Ngs8sXiYy8T1dezeWvamVp+YaI/G69YUT+OyOfnTO/vl8+H5fSGO7xY7v/jOm581UxOOrjpVp/UmnQ9JTl99p+He1W7Y9pAvB2cS6nNs7nXbE9ND0jKlbn3bZ849CG1CNAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYDqBoROAPxDNt/3otyvviKifb2TKH+6XJghF8cSpq89nR0v55qZZ0itj565zyvxDJmj8soW2/n6CdppVm5ONHtKsMHD7c1Gv61yn/WH7os65fkofKvT7vvWKPetjGUf7Fs43r19OqLlxz7m2Fe8VmV3XP/M/0rbTgvPGck2uVbDLCZjLlnKiZulaP2+KDn+xp8083qERl5uw7U/1tHv3Cdoby3jKU5rHZM+cHH1yRNu1fkweZIqUb/8r/bGAu3S0mZON8zmg2ZezIu+aEbOkn8bOVbv7DGzoOrV9qn2r5Y8GttFVbadC2znxetq03sbEtA5D98uxUF3T5vJ3UZbPXS+MeHbEM1aWuZ3Pfe+IyHvPzyOa+3Zt/yzq3idiLdIyPwfmfb/LrMrPz8UNOuDuF/nn1trIyc5daSz3+LHdf8by3JmTx6sxVV8eHfkX6xo0E+S/sKP9PNa0/06a4PBzq5rPpXWfXO+bWF8/eD7Hlf5AVk4u3ra+g3UCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOYr0PXj+fxxcL6Fq0p/HCtD3vab+92y2mlBy29Eu80fMuf2J+dwvB2ija4JVNUx9x54nEVNht01jl/1Jft6iYH9aVZrvkmxajOXhzcrD9xe1DnXD//u2Kj3tb5+z3rFnvWxjKPHFs43z/1hPedZKn5foe1ZJ8WVjttVNpZrMrYJwN8sXOecpDnNRJk7FtqsPpN37brQhfy+iel/Vdi3WTSW8ZT9nsdkz7wXVPb15ZmRn/fmadObY8d6e/X1f+ho9Pkd+7y+o/4k2QfX2n7gwB2vVtun3v9cz8/HLCmfG5ptVtvfnqHh9TYmZqAYtGtpAvBxg1r430qXj8XDI4b8kYO8zh+MmPY5LHadKi3zc2BOjKzGf9vyV1G+c89Z5xtFq32vXag7lnv82O4/j635V9ehvlyG586to4+HdfTz0YUxM2nRTzqOMZYJwBeJ/h/VOIf83Eya3h471MdAc/3JkzaoPgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBDaKQL59QSJAgAABAgQIECBAgAABAqsl8LE40NC3RM7yw/C+89ktKnRNMP5Q384Dyk+KOvk2uFJ6RKlwFcqOjWO8M+KYlWVO7pomHRI7ZRttKSc0LWvKt1B1pbO7Chr5YxpH+cbMrvTDKHhvV+GA/Jy41JW27ypYUP6YrsmCCBbWbL5NsSvlBM6hn5t6G5+PjePrGY31nJgzzQSZg2K/oxpt1TevWN8orG/E8dQ1Ofpr4XRKwaqv6MBChTu2lO0Yec9pyf9t5L20JX/SrPyertJvqpWeZWmMn9azb19x6R5d+r7qa3ce5csyJuZxLqvVxglxoHzG2iPikRGl+1wUb/qTiHdHrOZ/r1nm58C+e80Tw+qnEaX0vCh80ErkubalMd3jx3b/Kd3TluW583ExKG7UMjCOjLz9W/KnzcqJrmNOD4jO79Q4gX9qbA/ZfFNPpSdE+WreA3u6o5gAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDA+hIY+gbg6qxzsmH+GLov7lHtMOflv3Yc+7zIHzoxrK9LOXmpdH6/7GtgpTzfuNjVzt8PbGPR1T7X0cfTpzzwapzzfh19Tus9B/Z7TOPoIYXznfVtmlcptH3uQMt5VRvTNblWwe1p8wKZYztfLPT3pjMcJ9+63nWPe+0M7ebE9K52Xzew3TGNpzylWd/2er2C2RsGmnVVu02h7bbviid31P9o1wEmzH9rrf1bD9z3crV9mmPrYwPb6Kp2sULbOaF92rSexsS0BpPsN683ADePeeXIODqiOW6a28t472+eS9v2vJ8D316wyrf/bt3WiSnyxnSPH9v9ZwzPnfnm9uZnMLefMsVYKu3y447jfLq00xKVfanR/xNj+5JT9u+rjbaa/veesl27ESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYF0L+GvK6/ryOjkCBAgQIECAAAECBAgsrUBOsPjGgN7tH3WuNKDeJFW2jcoP7tjh55H/646ySbN/ETscXtgpJ4PcpFA+pqJ8U1Zbyh+HX7StYAnycrJ3Vzqnq6CWP7ZxVDrfrjc41063uJqT2bsmtF8kyrYp7j2/wrFdk/md+eq0dH7hMLOMoa77Rx6ua1wVunJBUU6260pDxuRGHE+P7AKL/O8VyoYUHVuolN8VzclE9+uo/9OO/Emzc4Lx7Vdi6LnlRKWulG8mniWVvnfW8g3AyzQmZvFd631z0mpObDutpyPPifLL9tRZxuKu+/i0z4FtfxSgOu/3x0rp81LV61uO7R4/tvvPsj937hQDZNeOQfKDjvyNmJ1/vON2jRP/t9ie9nvpjY22mpv7NjNsEyBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMCmTSYAGwUECBAgQIAAAQIECBAgsBYC+aPhnNzTN7nrilFn/4jNEfNKN4+GLtXRWF9/OnbrzO57s9MtOvdc/oJLRBdvFfFXETctdLc5qatQdVWLSpMZh0wsGds4Kp3vKXOQP7nQxnaFsnkWje2azPPcV6OtrjGUk5JOmqEDpT+60DdZrnTY0v2861zq7W3E8dQ1GSpd8o1/s6QTenbeoVaeb7rco7ZdXz2qvjHDek4w/PJKlCYb1g9R+oMWZ9crTrGen6OucTntRKspuvEHuyzLmPiDjo0w49Do89N6+p2fg0f01FmW4kU+B5aew74zJ4Cx3ePHdv/pup/l5TtlDtdw1ufO+xf6UPoDIoXd1mVR823IeV3fPMOZ/kfsW3oe2DvKbzhD+3YlQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAuhQo/WhgXZ6wkyJAgAABAgQIECBAgACBpRHIN0bmj68/F3HxQq/uHmVPjXh1oc4kRfnGp65UekNh1z6l/JwA/ORChSsUypap6NLRmZwEtNtK5KSJ60fk2137Uk4QmWUSX1/705aX3kxWmnhSHW9s46g0EWMek8tK13ieE/gr/7bl2K5J2zksc96Wjs7l+Okq69jlQtmlSTy/u1DNyTZKE4xKn4fqKBtxPF29OvmWZf6hh+Mi8nqfWYuc+JqeeU+tL/N7Pb878m3Ll4nIiY2ltG0UVm+S3jPWu75fflpqZMFlWxfaH/K9Udj990Xp1/YHO+dxj+47dlf5soyJrv6NLf890eFXRly20PF7RNnrC+VrUbTaz4GlZ7R53QPGdo8f2/0n72ddaR73tFmfO3OiaVc6qqtgg+Xn/f9PGud8amzfaSUaRYM3S2Mj/83wpIjHD25NRQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECGwAAROAN8BFdooECBAgQIAAAQIECBBYYoGvRt8eE/GOnj7+Q5Tnm/q+1FNvSHHpB/85AWme6Rs9jS3rBOArRb//KCLfwLh7xE0iuiZjRVEx5QTgZUylH5+fO6DDYxtHWwrnlJP5Zk2liRhDPGc9fu4/tmsyj3NezTa6xtDQt6d29bW0/1ldOw3IL00eLn3+q6Y34njasTr5luULIi9jUak+gfaqhYP8rFC26KLS/5de7/+0/ej6jM1jsty0fVqWMTFt/5dtv7zfvSsiJ7h1pT27ClYxf62fA0sTgEtvjZ+EaGz3+LHdf7ruZ3mNluG5s+t75vjoX+m5ZJIxNva6eZ9qjrv84wVvW/CJPSzaf3bEbxZ8HM0TIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBgNALN/3g7mo7rKAECBAgQIECAAAECBAisG4F3xpnsEvH0whnlv1/fH3GLiBMK9YYUlX7wP2T/SeqcFJVzotlWHTtdriN/LbKvEQf9y4gHROSbHvve2pqT674S8YWI20fcJaItXawtcwnyShMThkzkGts4ynHYlUoTbbr2aeaXJksswwTgZn9n3R7TZ3vWc+3bf9brW/q8zdL2IicA95lMWr4M42m76PQ2k3Z8jvXrk1xz8mFXyjcOr1UqvYFzlrFanU/X99IsE+GrtqdZLtOYmKb/y7rPJ6JjpQnAl4zynGRXeov5Is5tmZ4Duz4Led55v5xHGttz3NjuP8v+3Nn1PbOWf2RiHuN6Xm3kW78fPa/GJmznMlF/n4jXTLif6gQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEFi3AiYAr9tL68QIECBAgAABAgQIECCwqgKlyaKlsqqTfxsrN464R5XRstwx8t69Uqc0MaBl1wtlXfxCWxfeyGPMM+XEypzAsUNHo0NsOnadW3ZO8HlOxN9ElGzyh/xfi/ifiE9GfCuimvD0/FjvmgC8rP/fQ8l+yITYktXYxtEsn6e49L2pGie9FWessJ6uyYwUC9m9a5wM+bxM26HS5OC+Nkv7liYmVe1utPF09erEZ1ima46HZuQE1t/W4tRYPyLisJU4PJb1yY5XjO2ulBMj1yqVJuCVxtus/V2te2izn8s0Jpp9G/P2LwZ0/gpRp/6ZGLDL1FWW8Tmw6w/n5EmW/rjDJAhju8evp/tP1/PEJNevVLfvnpn/BsjPWFtaxB9cKF27tj4sQ94joxNr+X37+Dj+6yKGPK8tg5c+ECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYKECy/oj3IWetMYJECBAgAABAgQIECBAYO4CpcmUpR/xVx3JH/c+OCInlV6rymxZ3i3ynhvx0payoVmlHzPPe+Jm9infWNw1AXhekxiGnnuzXr55+YCIrrdg5Q/0vxDxzogPRZwU0ZZKP84e4//30DdxIA3GNo5Kn9F5TMQofc6HeLaNq0nzxnZNJj2/ta7fNYZKn/8hfS5NjJll7OQk1K40pM8bbTyVJt2m424R3+wCnXN+qS9d36dz7kJrc4saq9XBuu6jpbFc7buIZek65PFWc0ws4vzWqs1fDDjwJQbUmUeVZX0O7Pos5DmfPo8TjzbGdo8f2/2n65khL99aP3fmte/yLI2L7Ps0adtpdlrDffLzl38Yqp5+HRt3iJjn99G7or3b1Q9SW792rN874qO1PKsECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBDYsAJj/BHuhr1YTpwAAQIECBAgQIAAAQJLLFD6oX7pB+D1U/pNbPxZxBcjLlYvaKy/eKXOZxv5QzdPKVS8TJTlD79LdQq7txad2Jr7v5knF8oWXXSzOMCBEZdvOVBOjntvRFr/uKW8mVWaTLes/99DaVwO+XF7aYws4zgqnW+prHmtu7ZL94BZJnF2Ha8tf2zXpO0cljlvHuOk7fxK9/vSvaWtrXpead9SWdXGGMdT1zXqyq/ONZdn1jda1rv+UERL1ZmzSm/T3Xnm1qdvoGvCWLY4ZEz1HbnrPjrkO6mr7a5r35Vfb2eZxkS9X2Nfz3tLToAsXYPTVuEkl/k58CId55+fhVk+D/Vmx3aPH9v9pzS+S2X1a1Ra77pf5j59z52lfef9RybyXMc2Afi+0efrJGQtvTXWf1TbnsfqW6KRrgnA2f6+ESYAp4REgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMCGFyj9h+4NjwOAAAECBAgQIECAAAECBAYL9P2Qu6+8OtA3YuVZ1UbHMv8t++8RV+ko78vueotttd+O1cqclqVJQYcPOMZQuwFNXVAlf9z+yYi2yb85sSJ/+P2wiCGTf6NaceLTNBOAF3HO2c966ppcknVK16xqY2zjqPT/Ac3Du9R+30SMynTW5diuScm9VDar07T7L6pPpQnAs7wlsDQmh7Q7tvGU17XrnIdcu9Ifq8i2r5z/s0rpl4XjlCYLFXabS1Hp+6z0nTLk4Nl21/Wb5R7a1ebYxsQQw3nU6fKaR9tVG9vGSsk/n0GOryovaLnsz4Fd12Fek3+TdWz3+LHdf7quYdqXxn+WD0ml9vvumdUk/Lbj5HfdFdoKpszLPwpU6uuUzS50t6c3Wk/PtzTy5rH5gWikNBF/ryi/0TwOpA0CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiMXWBs/+F57N76T4AAAQIECBAgQIAAgfUq0Pfvy77yustrY+Nj9YyW9XwT4fsjSj+Gb9nt91l9P/i/RteOU+ZvU9jve4Wyqqg0qWgS16q9XD4homsy19Oi7ONZaYJUmpAxzTVaxDk3T6dkN4/Jgcs2jkqTLUplTbeu7dI165uI0dXmpPlj+2yXxmCpbFKXedXv6tOs42dRE4BL9555TPJfts94Xueua9F17epjo28C8K3qlRe8fkyh/dsXyhZdVHoDZ2m8DenXpQqVSt+xhd1+X7RexkTfec6rvPRdNuRzNKQffZML84/D/G5IQzPUWfbnwC7rWT4LTa6xPTOM7f7Tde/J61Aqa16nru3SZ7XvuTPH0aldDUf+bQtlkxZddtId1rh+/pGN5vfsf0Ve6Xt52i6fETu+p2fnfXvKFRMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGBDCHT9kGJDnLyTJECAAAECBAgQIECAAIG5CfT9+7KvvNmRR0bGz5uZje07xPbLG3lDNn/YU+nePeWTFnf98PusaOhHAxorTSqa1DUPd/GInPjRlj4Uma9vK+jJK02mK/1Av6vZeZ9z23FK/RriOrZxVJpsUSprs2vL65rEmZMshkyobmtz0ryxXZNZx+CkPrPW7xonQz4vpWN3jZ3cZ5axU7qPlO5ZVV/HNp6y313XqCu/OtdcnhxRmjS1Z73ygtePLbR/9Si7QaF8kUWlCXiXnPHA2xX2z/votKnr2nfl14+zTGOi3q9Frq/GffnWPSfw1Z7yWYvH/Bw4ZNwO9RnbPX5s95/StSqVDb1+Xc8OQ587SxPA7zC0EwPq3XRAnWWq0nz7b/btjQvs4L/0tP3QKN++p45iAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIrHuBWX+gt+6BnCABAgQIECBAgAABAgQIDBLo+hF2tXNfeVWvWuabCP8iom/SS/5I+f7VTgOXh/TUy+OW3sTXs/uFirOdHS+U838bn4zVvvPL2qVJbKXJAP93pAuvPTA28w3KbelTbZkD8kqT6UqTabqanvc5tx1n1mOMbRyVxsoiJ2KUJhS2XZdZ8sZ2TUr/v1ypbBajWfbt6lNX/tBjlb4f1nIC8NjGU3p3XYuu/Po1yu+jb9YzGus3jO2rNPIWtXlsT8OP7ylfVHHpPnrpGQ965cL+s9xHu659V369G8s0Jur9WuR66ZlliNmQvt2lp9KHe8pnLR7Dc2BOUm5Lpc9gW/1S3tju8aVzX8b7T6m/y/DceVhhcDw8ykrPJoVd/6Dozn+Qs7wZ14mu3a/RvUNj+3ONvHlu/r9o7GuFBnNs71MoV0SAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIENITCvH61sCCwnSYAAAQIECBAgQIAAAQKdAn0/ku76IX9ng1HwhYgXlCqslO0fy+sOqFdVyYlFP6k2Wpb5Fr4/bcmfJmuX2Knr3977D2ywNFF1mjcO7lo4bmnyV2G3Tas5AXiac27re2liQsm8ams9jaPShKfqfPuWXfeAWSau9R2zWT62a1JyL5U1z3u1truucdc9bmi/utodun9XvdLnuHTPqtob23jKfnfd17ryq3OtlgdXKy3LnLD1uJb8RWR9Oxo9q9DwX0bZNoXyRRWV7mc7zHjQWxX2H/LHQrp277r2XfnNdg5uZtS2V3NM1A670NXSfWPWe112PCez3btwBkdE2ScK5fMoGsNzYNezXn435ribRxrbPX5s95/SZ2kezzhdzw4lp/q4+UJ9o7GefygpJ8rPI9250Mi8xnLhEBMV5R/Wat7n3jxRC9NV7nsLcP7Rj2a/pjuSvQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIDBSAf/RdKQXTrcJECBAgAABAgQIECCwZAJdP8KuujnNBODc9x8iDqwa6VhuG/kfjOiaLNC22wFtmbW8v6qtz7J6246dT4j8/+4oa2aXfkA/zQSonZsHqG2X3oZVq3ah1fwR/90vlHPhjb6xceHa/7s173NuO0Zp8lOprN7WmMZR6ZxK3vXzLa13fcZneYNr6XhdZWO6JqV7Vpdn13mvRn7XGJp1/JTuEbNMjin1a8gE4DQd03jK/nZZduXnPvV0cH2jZT0n4ZTGbcsuU2WdEnt9vLBnfvc9q1C+qKLsV1ea5e3Il4lGn9PVcOTPMgG469p35Te7cXAzo7G9WmOicdiFbZbuvV33wEk684SofIXCDq+OskV/b47hOfASBaOhY7fQxAVFY7rHj+3+U/q8lL6fL7g4PStdn9Whn59Detp/SZTnvXmWtFvsfPNCA8v032fzO+wvG339bWy/u5G3iM33RaOnFRrOe9Z9C+WKCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgsO4Fluk/MK97bCdIgAABAgQIECBAgACBdSzQ9SPs6pT7yqt6zWVO0npoxHHNgsb2TWP7LY280uZ+UVj6gfgeUX6DUgMDy/6io94/RP45HWXN7NKP5C/frDxguzTx44oD9m9WeUNk3KOZWdue5trP+5xr3blgtdSvS11Qq7wypnFUmoiRk7hnTV2e82h7kr6N6ZqUxllp8tMkHvOs2zXpqjS2hhy/q93cd5b/77J0HxnSr6wzpvGU/e2y7MrPferpM7Hxi3pGY/1ysZ2TolYjvbvnIH8b5V1/ZKNn16mLSxPw8plh2vvdS2PfqxV6NctE+K5r35Xf7MYyjYlm3xax3XdfnuVaXD06nOO2K30+Cv6lq3CO+WN4Diz9oYGu541piMZ0jx/b/af0bDDtvbJ+jbvGwdC2vx6NHVNvsLF+rdjOCfnTpuzHP0eUnmNKZdMed9r9nh47Nk3fF3mnTdvgBPvlROM8Vin9TalQGQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC/QIvjCo5obYrdulvolhj7yjNN+B1tV/lP6bYyoULP9bT3hsvXH3irRt1tP/tyB/64/Q86I072slzzolak7QV1Tf9JKLyai7/OCtMkPINjM02mtsPnKC9quq8z7lqt778cGw0+1pt53gbmsYyjp4aJ1SdX3O5z9CTLdQ7tqP9oRPdC01PXDSWa3LPDrO8Pm+a+KwXv8ORHf09Y8ZDv7Wj3XQo/XGBvsM+qtDuy/t2rpWPZTxll78X0fx853b+MY2hExdzkk1bG1VetnWviEWnnKB6YkR13Lblj6J8+0V3pNZ+HqutH1Xen9fqDl19dk+b2XbWmTatpzExrcEk+70mKlfXs2057R9nyInF3yq0fWqUXTNiNdIYngM/FxBt/plXmsA8jd9Y7vFju/+M4blzyL9jnjbNoIp98g87dI3hKv8LU7Y9790uFw3+tqW/u8/7QIX2dms5fuVULUtvUy40rYgAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgRR4XUT149y25R3nwDTkh9RnxnFuOfBYt4t6pUnFWbbXwLbaqh0QmU2LcyPvVm2VC3k50aHZTn1738K+bUWfLLT3zSgbMqE43xBVmrRX79/D2zrRkzfvc2473IGRWe9nff1P23boyBvLOHpB4XwnmTjfwbApJy/VDevrzTeKdbUxr/yxXJOHFMzeNS+MObZzfEd/c0LoLGn/2Lk+Xurrk/5Rgno/8t5Yb6u+nt9ZQ9NYxlOez88i6udZX9924AnnRMVfF9rJNn8TcdeIWdODooHnR3R97wyZnPWd2P/ys3Zk4P75tsY897prff0HUbbNwLay2j9E1PfvWn/JBG02q663MdE8v3lvvyUa7LoOmX+ZKQ54xdjns4V2z4yyu03R7rS7fLLQl2V5DszPddd1yImC80xjuceP7f4zhufOnFTdNvG1OfZeFPXSf0jK77O++0jVfn7eliH9XXSi6lO1PHINOvbdln5U/cnle9agTw5JgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYN0IvCPOpP4D3eb6A+ZwpvmD6kN6jpPH/WlEvsloSGr7wXO977+MRq40pKFGnb+O7Xo7uZ6T5B7eqDdkMydtNduqb58S5Vduaeg2kXdQRHMC3T9GXn3/5vrLonxzRFe6WRR8LaLaLydK/6q2XeVXyydF2aRp3ufcdvzS5JLHte1QyBvDOHpl9L+6Js3lEwrnNqQox0uOg2a71fY0n6Ehxy3VGcM1ybfKVUbNZU7QWrZ0VnSo2c9qOyeNTps+EjtW7TSXD5y20djveYV28ztrkjSG8ZTnk98HTcNq++oTnHB+b+R3VrVv2zLf7p33960iJk03jR0+G1G12/Ydlm1m25+p1avqN5eHR51pJgXmZM6cyHy9iKHpP6Ni8/j17a9G+Q49jd02yvPNj/X9Tmxs18v262mvVLzexkTpXOdR9v5opG7fXL/0hAe5e9Q/ptBm3lfvOWGbs1Yfw3Ng6bkyTeedxnKPH9P9ZyzPnfvGYGp+ztu2vxL1btEz8O4c5Z+vtZef70dFnFzLq7f9k8hf67RddKCtf69dg449I45Z92mu53PHtdagXw5JgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYF0I5ISX5o9069s5EWseacdo5ISIettt6wdHna0j+lJOKv5sRFsbVV7+OPsmfQ3Vyh8W6+dFVPtXy1kmWZ7e0l7Vbi5zcslTI3Ii0yMi9o+o+nBarNcnrOQk5Pq+besHR509InJy1FYR14i4X0Tzrca/jry9Ix4T0dZO5r0kYpo0z3NuO372vavP/922QyFvDOPoXYXzfXHh3IYU5fjqssz8Sd96PeSYfXXGcE3+qeD2/b4TXOXynNBYusY3mKE/hxbafuYM7b6i0O7nJmx3DOMp79ela5STTidJL43Kpfaqsu9FvftHXKyn8XwTeP4xkIMiqn1zmRNhS+lqUTjkez+/8/IzdZ1SYytl+f32bxHVmx9zkuwVVsr6Fo+OCvX+t62fFHX+LuK6EVtH5Pi5fkSef9sE099Efn5/t7WVeR+PmCat1zExjcXQfX4eFbuuQ04+G5IuH5UeEvHNiK62Mj//yMxeEaudlv05MMdt9Qzb5vfYBYCN4R6fpz2m+8+7or9t1y/zlu2582OFvjbP4RtR91kR+e+iPSMeFPHciC9H1Ov+KrZ3j8h0dkS9rFo/I/LzO2ItU9ez0pPXoFM7xzErm67lf0Wd/LepRIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDABAI5sfXciK4f6mb+8RF3jphH+uNopHSsquwDUW/Ij6pz0s/XetrMSbR5npeO6Eo5Qe5tEedHVH3IZf64OyfIzpJKb8isH6tt/cNx4M21g28f67+IaKvbltd1bXPS1tVW2v2rQns5ASYnfk2a5nnOzWPfNzLazrXKy3POcVZ3a7bR3F7mcZRv1zw6ojq/5vLrUXbJ5glNsL1joe081psnaGueVZf5mlwpTvTIiOa1qLbzPrL3PDFmbCsnXFV9a1v+W5TnvWXSdKPYoTTRK8ftTSZtdKV+jru2vmbemRH5FtpJ0jKPpzyPJ0Z0nW/m/2tE3yTdqHJBygk2740otVkvy+/JvG+/MOJxES+KyD69LOIzEfldWK9frT8q8vvS3aNCNVm32q+0/E7Uf1XEUyJeGvG3ETkePhnRdi/8buQPeV6Iapu262ij1J9S2YnR3m0irhfRVe/UKLtFxKRpPY+JSS2G1L9/VOq6BlX+UVHncxHviMgx9sKIF0e8IeI9EYdF5P27qt+1/GjUyXvKWqTt46C/iOjqWzN/tZ8D8/Pa7EN9OydabhMx77Ts9/g837Hcf8b23JmT9r8fUR9ns6x/L9q6RkSm/G4ptfU/UX6DrLgGKe95XZOT84+z3CVih1Xs14PjWCWrquw/ot5lVrFfDkWAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIE1F9i85j3QAQIECBAgQIAAAQIECBAYi0D+kPk5K53NHzPvFHGdleVKdnGREyKOjPhpRL5h7ZyITG+MyB9KT5JeE5WfMmCHnOCQEzU+GJFvDOpKl4qCf4+4T1eFlfychJMTorK/P4vIiWs5CfauEfeMyHbqKX9M/ucR361nTrH+J7FPnsOk6duxwx0iftfY8W6xnROhpk2vjh2fFZGTQjI9OuKtv19r/598C9b/i8j6x0fkZOrTI0ppXud86zhITvjN67RjxPVXlrHoTb+NGnntjojIsfuPEWdEdKVlGEc3js7daaWDOUHmuhE5PvPcS+nYKPxQRI7r6tocGOs/jOhLN48KOdZK6fNReEjEL1cq/SiWB6ysL3KxDNfklnGCt105ycvFMu+deb+48kpe1yLvmf8Cf5uxAAAZa0lEQVQd8eOIvGfmJI1Mea0+/Pu1xfxP9m3nlaYvH8tdInKSyFYreV2L7O/REfl5yWWOpbxXVJ+ZPWL9ZhGZto24RsSfRWwf0ZdOjgo5ZvJzmG3/R0TfmHt31HlIRFdKzxyXP4jI+1KO+09EHB7RlZZhPGXf9ozYKyKvz1Uidou4ekRfOisq5L04HY+J+GrEByJK6YVRmLG5VGnKsjz+3hF5r+1LN4wK2de8x80znR+N3S7iaxM0eqeo+5mIWU3yGuT9OcfcbSK+EtGVzo2CfI7J+0HeA7LfeU+tni/2jPWNNibilOeS8rPz4ohHRPTd52Y94E+igZdFvH3WhmbcfxmeAy8S5/CEiJx4e8WIq0bcKKLvuzGq/P6POHw6lvm9cHxE9Zz7/lg/IWLatCz3+FL/7xSFy3T/yXty9inTmJ878/s0nwFulScyQ/ps7JvPTL9ZaSPH9nEr66VF1snnmqMiPhLxyYh5p/z3c37O8jOX/z4Y8twQ1TblM1g+0/08Ip/rDo6YJV07dn5RxGUjtovIZ+PsS46foemcqHhoRH4f5nV7c4REgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYMML7BoCWxYQ95xC9mKxT07WGdqflw84Rk5EeEZE/sh5aLtd9U6JNl4akRMJ5pXeFg11Ha8tPycWXa1w8FdO2F4eI8/rfi1t/vWEbeVYGpLmcc7PjQO1+UyTlz+Y70trPY4eGx2c5tza9nl438mulOcEvrb9S3nvGdj2PKqt9TV5zhQ+JbuctLrI9NFovHT8Scrqn5nXzrHdfQcATHMe+wxod63HU3YxJ+BMch266uYEuiHpPlHpiIiudibN/3K0dfchB27Uye/U/SMmPV5X/XyOyEno06Q/jZ1Oi+hquy//gNj3GrUDp0ffPs3y+udgo46JGuHUqwdOYd+8Fn3bX4xjPCBi0ROMJ0FY6+fAnRbgfvNJADrqLsM9vqNrF2Qv0/1nPT135ltl3xlxfkTfZ7qtPJ9t89+o9XSj2GirW8rbr97AHNd/NUVfmv3M6z1run000Gx3lu1/n7VD9idAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCwXgSuGyeSb6Cb5Qe6bfvec0qga8V+OSG1rc1m3t9OcIwdom6+IemkgW3Xj5Vvpnx2xLYR8045ISHbzjc41o/Ztv67qHPLiL60Z1T4VkRbG828Q6LetTsa/IuBbVRt7trRTjN7Hue82hOAq3NYq3H04AmvRXVN2pZDJwDfbYpj5iSJ1U5rdU3yDYdtvm15eY/Nz/h5hX0WPQE4J7+09W2avPoE4BcW2s3zzrfAVsfI9XNq21V+tdw3yvrSh6NCVT+X9e+vrrb/pK/RWvlajafswgsi6uc27fqnaufTt3rRqPDoiB9HTHO8n8d+OUl1t4hZU75xMicvHhMxaV/yueFNETeLmDXdIBr4bMQkfUi/B7Qc+O4TtpPHrH8ONvqYaCEdnHXQFPala57PYIdH/HNEPh/tGLGsaS2fA3cKlJLjNGXzmABcXau1vMdXfSgtl+X+sx6fO3cP+K9GTDIGXx71294Kv0vkn19rq1rP55yza/n1Y5kAPJn9W8JRIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwLoWaPsP0uv6hJ0cAQIECBAgQIAAAQIECMwkcJPY+9IROUHtzJVlrucPmDNyUlVG/rg5U07gzElDudw64pKNuERsHxZxUsQ06fqxU/5A/zcrcWosc+Jc9jHf4rTNyvrXY5mTvyZJ2efbR9wr4qYRV4y4UkQeLyd3HL8Sx8bykIgDI46IWHS6ahwg31iYE6dzUsmVI/Lf97+MODLiMxEfi/hRxJC0VVR6YMSuEddZiWvGMr1+HvGziHwT70cjSulWUXhaRF6DXOa4yHFw8Yi87tuuRF6Tb0fkD9+HplnO+RpxkIz6mK3GbrXMMZsOec1zvGZkny9VW+ZY/XJE1p0krcU4uk10MM83x2n1+cx+n70SeW3r51t9NvMc65/RHEPHRQxJOakvj5WfxRwDp0fkZzGPk+3nOMjPZI6DHANZ7/sRa5FW+5qkwe0i0r26Hl3LNKtSjsO8JjkOM9IvI8ftdyIWlfIa3Tgir2GOoTxejp/sf32Zk1XyTXfZx4y8xvVlltU/MzkO8j6Rn/1sNyOPkZFtt6W8Vs3zT4OjIo6JKKXto/CaETmGT4xI83rK/l06ohqXeZyv1ysMXF/t8ZTdSstbR5wRkdenupdVyxxHaZr34Goc5bWpPt/Vel6L70ZMmq4XO9wtYs+Iq0RcYSWyX/nZzkm2aX54xDdWIo+TY2aeKe33jtgj4moR+V1RRfbl5xFHrcRPY/mTiE9H5JibZ7p+NPaoiHxWuHpE9iW/l9PghIgcg1+M+ETEoRFdKe+jZ0dU36P5XZpmeS4ZOUarMZvLoyKOiciU5cbE7ykm/p+cDJ62+XnKyM9F9VnK+0Z+jnKsVZ+l/BxV97q8j6R91svrnZH7jinld9QDI3aNuM5KXDOWeQ/Jz9DPIt4W8dGIUsr7+yTPgfl9cpuIHPMZaVhFfTvrpX9aZ1y8tl7lVctvRVlev3mmPPbtI+4VkZ/xK0ZcKWKHiPweO34ljo3lIREHRhwRsVppGe4/eR3z2qVHLvP65XXLZUaOpRxnaZmfo/zMVJ+j6nsplz+KOC5iSMr7ZR5rkc+d+Xl4QMQdI64acZWIfGbI+/ovI74f8ZmIg1a2Y9Gadonc9Mj9TorIe0qV8rsi7z/b1SLr/Thi3ul20eB5EXmd8nNSXa/Mq6J+v8trlZ+3bWqR36U51mdJ28bOed/Ne2UVeS2r+25aVf3J78D8fGc/qqjuv9V2PhPnuUgECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAAgT+PwEU88IIbjpHAAAAAElFTkSuQmCC) First, the user will generate a pentamer model using $ChainBuilder$. Second, two pentamer chains will be placed in a simulation box and translated/rotated as specified by the user. As INPUT, the user must provide the repeating unit SMILES, length of an oligomer, and transitional distance or rotational angles in a list of lists format, as shown below. """ # Input SMILES string repeating_unit = 'C(C([*])Cl)[*]' length_oligomer = 5 samples = [[0],[0],[0],[0],[60,80,90,100,120],[0],[0],[0]] # Create a pandas DataFrame import pandas as pd input_data = [['pvc',repeating_unit]] df_smiles = pd.DataFrame(input_data, columns = ['ID', 'smiles']) # Build chain models import psp.ChainBuilder as ChB chain_builder = ChB.Builder(Dataframe=df_smiles, Length=[length_oligomer], Inter_Chain_Dis=0.0) results = chain_builder.BuildChain() # Build crystal models import psp.CrystalBuilder as CrB vasp_input_list = ['chains/pvc/pvc_N5.vasp'] crystal_builder = CrB.Builder( VaspInp_list=vasp_input_list, NSamples=samples, Polymer=False, OutDir='selective_models' ) results = crystal_builder.BuildCrystal() """Crystal models are stored at *selective_models/PVC_N5/*. As can be seen, there are only five models generated, including a T-shape model (*cryst_out-3.vasp*).""" !ls selective_models/pvc_N5/ visualize3D("selective_models/pvc_N5/cryst_out-3.vasp") """### Additional information $CrystalBuilder$ allows users to modify a number of parameters/keywords in order to create desired crystal models. It can build crystal models of multiple molecules/polymers at the same time by providing $CrystalBuilder$ with a list of chain models. $CrystalBuilder$ supports the following **parameters** or **keywords**: - $\verb=VASPInp_list=$ **:** A list of names of oligomer or polymer chains with their PATH. Make sure that $CrystalBuilder$ can find them in the specified locations. - $\verb=NSamples=$ [*default value=5*] **:** It determines the number of crystal models to be generated. It can be an integer or a list of lists. If it is an integer, it will be considered as the number of samples for each degree of freedom. For polymer and small molecules, the total number of crystal models will be $\verb=NSamples=^3$ and $\verb=NSamples=^8$, respectively. A specific set of crystal models can be generated by specifying translation distance and rotation angles in a list of lists. - $\verb=InputRadius=$ [*default option=`auto'*] **:** This key defines the distance between $z$-axes of two chains, which is used to rotate one chain with respect to another fixed one. If $\verb=InputRadius=$=`auto', $CrystalBuilder$ will calculate an approximate distance by considering $x$ and $y$ coordinates of the input geometry and the minimum atomic distance defined by $\verb=MinAtomicDis=$. To define your own value, change this to a float or an integer (in $Å$). - $\verb=MinAtomicDis=$ [*default value=2.0*] **:** This key defines the minimum distance between any two atoms of two chains in $Å$. Note that this key works if $\verb=InputRadius=$=`auto'. - $\verb=Polymer=$ [*default option=`True'*]: In the case of polymers, fixing the position of the first polymer, the second one is moved in three distinct ways, i.e., (1) translated along the $z$-axis, (2) rotated around its own axis, (3) rotated around the first polymer chain. However, for oligomers, more degrees of freedom must be considered to capture every possible crystal models, which can be activated by setting $\verb=Polymer=$=`False'. - $\verb=Optimize=$ [*default option=`False'*] **:** PSP generated crystal models can be further optimized using UFF and conjugate gradient method by setting $\verb=Optimize=$=`True'. - $\verb=NumCandidate=$ [*default value=50*] **:** This keyword is activated when $\verb=Optimize=$=`True', determining the number of crystal models selected based on the total energy computed by UFF. Note that high-energy models are discarded. - $\verb=OutDir=$ [*default option=`crystals'*]: This key allows users to define a directory where they want to store output files. The code snippet below demonstrates how to build crystal models from a set of repeated unit SMILES strings (provided as a CSV file). """ cat crystal_model.py """## AmorphousBuilder $AmorphousBuilder$ builds models of amorphous organic materials. It accepts SMILES strings for both molecules and polymers. In this section, we'll show you how to build a variety of amorphous structures using SMILES strings as INPUT. Let's go to the *polymer_models/AmorphousBuilder* directory. """ # Commented out IPython magic to ensure Python compatibility. # %cd /content/polymer_models/AmorphousBuilder/ """###**Example 1**: Amorphous structure of a polymer Users can build an amorphous model for polymers by providing repeated unit SMILES, length of an oligomer, and number molecules to be included in the simulation box. The below example shows a toy amorphous model for polyethylene, where 10 pentaethylene molecules are packed in a cubic box. """ # Input SMILES string repeating_unit_PE = '[*]CC[*]' Length_PE = 5 Number_molecule_PE = 10 # Create a pandas DataFrame import pandas as pd input_data = [['PE', repeating_unit_PE, Length_PE, Number_molecule_PE, 1, False]] input_df = pd.DataFrame(input_data, columns = ['ID', 'smiles', 'Len', 'Num', 'NumConf', 'Loop']) import psp.AmorphousBuilder as ab amor = ab.Builder(input_df, density=0.65, box_type='c', OutDir='amor_model') amor.Build() """PSP terminated normally. All models are stored in *amor_model/* directory. Output files are in POSCAR ($.vasp$) and LAMMPS data ($.data$) formats. Individual models are stored in *amor_model/molecules/* and PACKMOL output files are saved in *amor_model/packmol/* directory.""" ls amor_model """Let's take a look at the amorphous model.""" visualize3D("amor_model/amor_model.vasp") """#### Force field parameter file PSP also allows generating a GAFF2 FF parameter file for the amorphous model. It can use either AmberTools (antechamber) or PySIMM for atom typing. """ amor.get_gaff2(output_fname='amor_gaff2.lmps', atom_typing='antechamber') """For the amorphous model, a GAFF2 parameter file is now generated: *amor_gaff2.lmps*""" ls amor_model """###**Example 2**: Build amorphous models with O2 gas Next, we'll learn how to incorporate multiple types of oligomers/molecules into an amorphous model. For example, oxygen molecules can be incorporated into the polyethylene system. As shown in the code snippet below, we must supply the SMILES strings and the number of molecules for both polyethylene and oxygen to be included in an amorphous model. """ # Input SMILES string repeating_unit_PE = '[*]CC[*]' Length_PE = 5 Number_molecule_PE = 4 Oxygen = 'O=O' Number_molecule_Oxy = 10 # Create a pandas DataFrame import pandas as pd input_data = [['PE', repeating_unit_PE, Length_PE, Number_molecule_PE, 1, False], ['O2', Oxygen, 1, Number_molecule_Oxy, 1, False]] input_df = pd.DataFrame(input_data, columns = ['ID', 'smiles', 'Len', 'Num', 'NumConf', 'Loop']) import psp.AmorphousBuilder as ab amor = ab.Builder(input_df, density=0.85, box_type='c', OutDir='amor_model2') amor.Build() """PSP normally terminated. Let's take a look at the amorphous model we created.""" visualize3D("amor_model2/amor_model.vasp") """### Additional information $AmorphousBuilder$ allows altering keywords or parameters to fine-tune an amorphous model. A CSV file may be used to supply SMILES strings and other information for all polymers/molecules that will be included in an amorphous model. $AmorphousBuilder$ supports the following **parameters** or **keywords**: - $\verb=Dataframe=$ **:** A pandas Dataframe that contains polymer IDs, SMILES strings representing repeating and endcap units, length of oligomers, number of oligomers/molecules, chain type (linear or loop), etc. - $\verb=ID_col=$ [*default option=`ID'*] **:** Column name for molecule/oligomer IDs in the Dataframe. - $\verb=SMILES_col=$ [*default option=`smiles'*] **:** Column name for polymer SMILES strings (repeating unit) in the Dataframe. - $\verb=NumMole=$ [*default option=`Num'*] **:** Column name for the number of each molecule in the Dataframe. - $\verb=Length=$ [*default option=`Len'*] **:** Column name for the length of each oligomer in the Dataframe. - $\verb=LeftCap=$ [*default option=`LeftCap'*] **:** Column name for the SMILES string of left cap molecular fragment in the Dataframe. - $\verb=RightCap=$ [*default option=`RightCap'*] **:** Column name for the SMILES string of right cap molecular fragment in the Dataframe. - $\verb=Loop=$ [*default option=`Loop'*] **:** Column name for selecting linear or circular chains. - $\verb=OutFile=$ [*default option=`amor_model'*]: The names of the output files exported in POSCAR and LAMMPS data formats. - $\verb=OutDir=$ [*default option=`amorphous_models'*] **:** The output directory, which contains all files, including POSCAR and LAMMPS data files. - $\verb=density=$ [*default value=0.65 g/cm$^3$*] **:** The density of a simulation box. - $\verb=tol_dis=$ [*default value=2.0*] **:** The minimum distance between any two molecules in a simulation box. - $\verb=box_type=$ [*default option=`c'*] **:** The shape of a simulation box. Here, *`c'* and *`r'* denote cubic and rectangular, respectively. - $\verb=incr_per=$ [*default value=0.4*] **:** If the shape of a box is rectangular, $\verb=incr_per=$ determines the length of z axis (l$_{z}$). l$_{z}$ = Volume$^{1/3}$ + $\verb=incr_per=$ $\times$ Volume$^{1/3}$. - $\verb=box_size=$ [No default value]: It is a list of six numbers that offers an alternative method of explicitly defining the box size. [*xmin, xmax, ymin, ymax, zmin, zmax*] A sample CSV file containing data for three oligomers is provided below. Users can add more molecules/oligomers to the amorphous model by appending new raws to the list. """ cat input_amor.csv """Below is an example of a code snippet required for $AmorphousBuilder$. The definitions of keywords and parameters are provided above.""" cat amor_model.py """###**Example 3**: Build an amorphous model that includes multiple polymers/molecules The code snippet below will read all of the relevant information about molecules/polymers from a CSV file (*input_amor.csv*) and then generate an amorphous model. """ import pandas as pd import psp.AmorphousBuilder as ab input_df = pd.read_csv("input_amor.csv") amor = ab.Builder( input_df, ID_col="ID", SMILES_col="smiles", OutDir='amor_model', Length='Len', NumConf='NumConf', NumModel=1, LeftCap = "LeftCap", RightCap = "RightCap", Loop='Loop', density=0.85, box_type='c', ) amor.Build() """Let's take a look at the amorphous model.""" visualize3D("amor_model/amor_model.vasp") """# References and further reading - Harikrishna Sahu, Huan Tran, Kuan-Hsuan Shen, Joseph H. Montoya, Rampi Ramprasad, *PSP: A python toolkit for predicting 3D models of polymers*, J. Chem. Theory Comput., **2022**. DOI: 10.1021/acs.jctc.2c00022 - User Manual: https://github.com/Ramprasad-Group/PSP/blob/master/documentation/PSP_user_manual.pdf - https://github.com/Ramprasad-Group/PSP """
567.796899
249,487
0.945075
16,008
366,229
21.60576
0.680722
0.001203
0.000489
0.000625
0.024677
0.020147
0.017822
0.015639
0.0152
0.013479
0
0.134519
0.014283
366,229
645
249,488
567.796899
0.823561
0.002889
0
0.318627
1
0
0.135387
0.052436
0
1
0
0
0
0
null
null
0
0.142157
null
null
0.004902
0
0
1
null
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
0
0
0
0
1
0
0
0
null
1
0
0
0
1
0
0
0
0
0
0
0
0
6
bd6e8b67b15f5ca5c21f230302daaa4e6c227964
59
py
Python
python3/__init__.py
deanelzinga/google-diff-match-patch
90823d875839edcd690e88fe785a936bc87f2fde
[ "Apache-2.0" ]
5,211
2018-01-30T10:31:38.000Z
2022-03-31T12:38:38.000Z
python3/__init__.py
deanelzinga/google-diff-match-patch
90823d875839edcd690e88fe785a936bc87f2fde
[ "Apache-2.0" ]
533
2016-08-23T20:48:23.000Z
2022-03-28T15:55:13.000Z
python3/__init__.py
deanelzinga/google-diff-match-patch
90823d875839edcd690e88fe785a936bc87f2fde
[ "Apache-2.0" ]
1,008
2018-02-12T17:08:53.000Z
2022-03-30T11:24:31.000Z
from .diff_match_patch import diff_match_patch, patch_obj
19.666667
57
0.864407
10
59
4.6
0.6
0.391304
0.608696
0
0
0
0
0
0
0
0
0
0.101695
59
2
58
29.5
0.867925
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
0
0
null
1
1
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
0
0
0
6
bdade5aa91ae469459270b10546366003a412bd3
43
py
Python
837477/app/models/__init__.py
837477/Django-Study
a55006f1788080ba4f57b46bc7f0aaa5246c7b6e
[ "MIT" ]
null
null
null
837477/app/models/__init__.py
837477/Django-Study
a55006f1788080ba4f57b46bc7f0aaa5246c7b6e
[ "MIT" ]
null
null
null
837477/app/models/__init__.py
837477/Django-Study
a55006f1788080ba4f57b46bc7f0aaa5246c7b6e
[ "MIT" ]
null
null
null
from .sample import Sample, SampleReference
43
43
0.860465
5
43
7.4
0.8
0
0
0
0
0
0
0
0
0
0
0
0.093023
43
1
43
43
0.948718
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
bdc0c9c198cea4c9aeca3bd89f8df8fb7c56a9d7
1,643
py
Python
testapp/render/views.py
Bit03/django-text2img
8da3af93a691ed26cefcc670d50a0f1d605d3657
[ "MIT" ]
2
2022-01-24T04:23:25.000Z
2022-01-24T07:16:43.000Z
testapp/render/views.py
Bit03/django-text2img
8da3af93a691ed26cefcc670d50a0f1d605d3657
[ "MIT" ]
6
2021-04-08T21:45:54.000Z
2022-02-10T14:06:09.000Z
testapp/render/views.py
Bit03/django-text2img
8da3af93a691ed26cefcc670d50a0f1d605d3657
[ "MIT" ]
2
2018-05-27T16:49:26.000Z
2019-05-15T04:34:49.000Z
import json from django.views.generic import View from django.http import HttpResponse from django.views.decorators.csrf import csrf_exempt from text2img.render_text import RenderText class RenderTextView(View): def get(self, request, *args, **kwargs): return HttpResponse("need post json data") def post(self, request, *args, **kwargs): json_data = json.loads(request.body) r = RenderText(**json_data) content = r.draw_image_output() return HttpResponse(content=content, content_type="image/jpeg") @csrf_exempt def dispatch(self, request, *args, **kwargs): if request.method.lower() in self.http_method_names: handler = getattr( self, request.method.lower(), self.http_method_not_allowed ) else: handler = self.http_method_not_allowed return handler(request, *args, **kwargs) class RenderListTextView(View): def get(self, request, *args, **kwargs): return HttpResponse("need post json data") def post(self, request, *args, **kwargs): json_data = json.loads(request.body) r = RenderText(**json_data) content = r.draw_24h_image() return HttpResponse(content=content, content_type="image/jpeg") @csrf_exempt def dispatch(self, request, *args, **kwargs): if request.method.lower() in self.http_method_names: handler = getattr( self, request.method.lower(), self.http_method_not_allowed ) else: handler = self.http_method_not_allowed return handler(request, *args, **kwargs)
34.229167
74
0.652465
195
1,643
5.34359
0.25641
0.084453
0.130518
0.120921
0.790787
0.790787
0.790787
0.790787
0.790787
0.790787
0
0.00241
0.24224
1,643
47
75
34.957447
0.834538
0
0
0.717949
0
0
0.035301
0
0
0
0
0
0
1
0.153846
false
0
0.128205
0.051282
0.487179
0
0
0
0
null
0
0
0
0
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
bdc3a6e726cd5f261f14f9b8efd8aa58b600c4ef
208
py
Python
server/expenses/admin.py
cristicismas/top-budget
d61db578287b2f77c12032045fca21e58c9ae1eb
[ "MIT" ]
null
null
null
server/expenses/admin.py
cristicismas/top-budget
d61db578287b2f77c12032045fca21e58c9ae1eb
[ "MIT" ]
11
2019-12-05T15:21:40.000Z
2021-10-05T22:08:17.000Z
server/expenses/admin.py
cristicismas/top-budget
d61db578287b2f77c12032045fca21e58c9ae1eb
[ "MIT" ]
null
null
null
from django.contrib import admin from .models import Expense, Category, Location, Source admin.site.register(Expense) admin.site.register(Category) admin.site.register(Location) admin.site.register(Source)
23.111111
55
0.817308
28
208
6.071429
0.428571
0.211765
0.4
0
0
0
0
0
0
0
0
0
0.081731
208
8
56
26
0.890052
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
0.333333
0
0.333333
0
1
0
0
null
1
1
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
0
0
0
6
bde9fafe024c4d30c30bdea43d026d8256d6b927
135
py
Python
sympde/__init__.py
pyccel/sympde
69e6a6634b2045d46286a0453cb66deab5f2e76c
[ "MIT" ]
12
2018-09-02T17:50:19.000Z
2022-03-08T01:26:47.000Z
sympde/__init__.py
pyccel/sympde
69e6a6634b2045d46286a0453cb66deab5f2e76c
[ "MIT" ]
51
2019-08-18T14:50:01.000Z
2021-09-16T13:54:58.000Z
sympde/__init__.py
pyccel/sympde
69e6a6634b2045d46286a0453cb66deab5f2e76c
[ "MIT" ]
3
2019-10-04T18:05:48.000Z
2020-10-17T02:15:10.000Z
from .version import __version__ from .core import * from .topology import * from .exterior import * from .printing import *
22.5
34
0.711111
16
135
5.75
0.4375
0.326087
0
0
0
0
0
0
0
0
0
0
0.222222
135
5
35
27
0.87619
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0.2
1
0
0
null
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
da14b7a4c7b8d7555d4d86eff8cfe40d36bc0d3b
21,707
py
Python
explore/zhou.py
sjshao09/KaggleRH
da22d6b42ecf4172d8c35313c35334ee8cc28c85
[ "MIT" ]
null
null
null
explore/zhou.py
sjshao09/KaggleRH
da22d6b42ecf4172d8c35313c35334ee8cc28c85
[ "MIT" ]
null
null
null
explore/zhou.py
sjshao09/KaggleRH
da22d6b42ecf4172d8c35313c35334ee8cc28c85
[ "MIT" ]
null
null
null
# Mostly a lot of silliness at this point: # Main contribution (50%) is based on Reynaldo's script with a linear transformation of y_train # that happens to fit the public test data well # and may also fit the private test data well # if it reflects a macro effect # but almost certainly won't generalize to later data # Second contribution (20%) is based on Bruno do Amaral's very early entry but # with an outlier that I deleted early in the competition # Third contribution (30%) is based on a legitimate data cleaning, # probably by gunja agarwal (or actually by Jason Benner, it seems, # but there's also a small transformation applied ot the predictions, # so also probably not generalizable), # This combo being run by Andy Harless on June 4 import numpy as np import pandas as pd #import matplotlib.pyplot as plt #import seaborn as sns from sklearn import model_selection, preprocessing import xgboost as xgb import datetime ########################## Gunja Model ############################ # ----------------- Settings ----------------- # EN_CROSSVALIDATION = True ######################### Train for Investment Data ############################ DEFAULT_TRAIN_ROUNDS = 432 #load files df = pd.read_csv('input/train.csv', parse_dates=['timestamp']) test_df = pd.read_csv('input/test.csv', parse_dates=['timestamp']) macro = pd.read_csv('input/macro.csv', parse_dates=['timestamp']) # ----------------- Data Cleaning ----------------- # # Training Set df.loc[df.id==13549, 'life_sq'] = 74 df.loc[df.id==10092, 'build_year'] = 2007 df.loc[df.id==10092, 'state'] = 3 df.loc[df.id==13120, 'build_year'] = 1970 df.loc[df.id==25943, 'max_floor'] = 17 # Clean - Full Sq df = df[(df.full_sq>1)|(df.life_sq>1)] df.loc[(df.full_sq<10) & (df.life_sq>1), 'full_sq'] = df.life_sq df = df[df.full_sq<400] # Clean - Life Sq df.loc[df.life_sq > df.full_sq*4, 'life_sq'] = df.life_sq/10 df.loc[df.life_sq > df.full_sq, 'life_sq'] = np.nan df.loc[df.life_sq < 5, 'life_sq'] = np.nan df.loc[df.life_sq < df.full_sq * 0.3, 'life_sq'] = np.nan df = df[df.life_sq<300] # Clean - Kitch Sq df.loc[df.kitch_sq < 2, 'kitch_sq'] = np.nan df.loc[df.kitch_sq > df.full_sq * 0.5, 'kitch_sq'] = np.nan df.loc[df.kitch_sq > df.life_sq, 'kitch_sq'] = np.nan # Clean - Build Year df.loc[df.build_year<1000, 'build_year'] = np.nan df.loc[df.build_year>2050, 'build_year'] = np.nan # Clean - Num Room df.loc[df.num_room<1, 'num_room'] = np.nan df.loc[(df.num_room>4) & (df.full_sq<60), 'num_room'] = np.nan # Clean - Floor and Max Floor df.loc[df.floor==0, 'floor'] = np.nan df.loc[df.max_floor==0, 'max_floor'] = np.nan df.loc[(df.max_floor==1) & (df.floor>1), 'max_floor'] = np.nan df.loc[df.max_floor>50, 'max_floor'] = np.nan df.loc[df.floor>df.max_floor, 'floor'] = np.nan # Test Set test_df.loc[test_df.id==30938, 'full_sq'] = 37.8 test_df.loc[test_df.id==35857, 'full_sq'] = 42.07 test_df.loc[test_df.id==35108, 'full_sq'] = 40.3 test_df.loc[test_df.id==33648, 'num_room'] = 1 # Clean - Full Sq test_df.loc[(test_df.full_sq<10) & (test_df.life_sq>1), 'full_sq'] = test_df.life_sq # Clean - Life Sq test_df.loc[test_df.life_sq>test_df.full_sq*2, 'life_sq'] = test_df.life_sq/10 test_df.loc[test_df.life_sq > test_df.full_sq, 'life_sq'] = np.nan test_df.loc[test_df.life_sq < 5, 'life_sq'] = np.nan test_df.loc[test_df.life_sq < test_df.full_sq * 0.3, 'life_sq'] = np.nan # Clean - Kitch Sq test_df.loc[test_df.kitch_sq < 2, 'kitch_sq'] = np.nan test_df.loc[test_df.kitch_sq > test_df.full_sq * 0.5, 'kitch_sq'] = np.nan test_df.loc[test_df.kitch_sq > test_df.life_sq, 'kitch_sq'] = np.nan # Clean - Build Year test_df.loc[test_df.build_year<1000, 'build_year'] = np.nan test_df.loc[test_df.build_year>2050, 'build_year'] = np.nan # Clean - Num Room test_df.loc[test_df.num_room<1, 'num_room'] = np.nan test_df.loc[(test_df.num_room>4) & (test_df.full_sq<60), 'num_room'] = np.nan # Clean - Floor and Max Floor test_df.loc[test_df.floor==0, 'floor'] = np.nan test_df.loc[test_df.max_floor==0, 'max_floor'] = np.nan test_df.loc[(test_df.max_floor==1) & (test_df.floor>1), 'max_floor'] = np.nan test_df.loc[test_df.max_floor>50, 'max_floor'] = np.nan test_df.loc[test_df.floor>test_df.max_floor, 'floor'] = np.nan # ----------------- New Features ----------------- # # month_year_cnt month_year = (df.timestamp.dt.month + df.timestamp.dt.year * 100) month_year_cnt_map = month_year.value_counts().to_dict() df['month_year_cnt'] = month_year.map(month_year_cnt_map) month_year = (test_df.timestamp.dt.month + test_df.timestamp.dt.year * 100) month_year_cnt_map = month_year.value_counts().to_dict() test_df['month_year_cnt'] = month_year.map(month_year_cnt_map) # week_year_cnt week_year = (df.timestamp.dt.weekofyear + df.timestamp.dt.year * 100) week_year_cnt_map = week_year.value_counts().to_dict() df['week_year_cnt'] = week_year.map(week_year_cnt_map) week_year = (test_df.timestamp.dt.weekofyear + test_df.timestamp.dt.year * 100) week_year_cnt_map = week_year.value_counts().to_dict() test_df['week_year_cnt'] = week_year.map(week_year_cnt_map) # month df['month'] = df.timestamp.dt.month test_df['month'] = test_df.timestamp.dt.month # day of week df['dow'] = df.timestamp.dt.dayofweek test_df['dow'] = test_df.timestamp.dt.dayofweek # floor/max_floor df['floor/max_floor'] = df['floor'] / df['max_floor'].astype(float) test_df['floor/max_floor'] = test_df['floor'] / test_df['max_floor'].astype(float) # kitch_sq/full_sq df["kitch_sq/full_sq"] = df["kitch_sq"] / df["full_sq"].astype(float) test_df["kitch_sq/full_sq"] = test_df["kitch_sq"] / test_df["full_sq"].astype(float) # Avg Room Size df['avg_room_size'] = df['life_sq'] / df['num_room'].astype(float) test_df['avg_room_size'] = test_df['life_sq'] / test_df['num_room'].astype(float) # Apartment Name df['apartment_name'] = df['sub_area'] + df['metro_km_avto'].astype(str) test_df['apartment_name'] = test_df['sub_area'] + test_df['metro_km_avto'].astype(str) # ----------------- Train for Investment Data ----------------- # df = df[df.product_type=="Investment"] #df = df[df.price_doc>1000000] df = df[df.price_doc/df.full_sq <= np.exp(13.05)] #df = df[df.price_doc/df.full_sq >= np.exp(9)] test_df.product_type = "Investment" y_train = df["price_doc"] * 0.97 x_train = df.drop(["id", "timestamp", "price_doc"], axis=1) x_test = test_df.drop(["id", "timestamp"], axis=1) x_all = pd.concat([x_train, x_test]) # Feature Encoding for c in x_all.columns: if x_all[c].dtype == 'object': lbl = preprocessing.LabelEncoder() lbl.fit(list(x_all[c].values)) x_all[c] = lbl.transform(list(x_all[c].values)) # Separate Training and Test Data num_train = len(x_train) x_train = x_all[:num_train] x_test = x_all[num_train:] dtrain = xgb.DMatrix(x_train, y_train) dtest = xgb.DMatrix(x_test) # ----------------- Cross Validation ----------------- # xgb_params = { 'eta': 0.03, 'max_depth': 5, 'subsample': 0.7, 'colsample_bytree': 1, 'objective': 'reg:linear', 'eval_metric': 'rmse', 'silent': 1, 'seed': 0 } if EN_CROSSVALIDATION: print "[INFO] Cross Validation..." cv_output = xgb.cv(xgb_params, dtrain, num_boost_round=1000, early_stopping_rounds=20, verbose_eval=20, show_stdv=True) DEFAULT_TRAIN_ROUNDS = len(cv_output) print "[INFO] Optimal Training Rounds =", DEFAULT_TRAIN_ROUNDS # ----------------- Training ----------------- # print "[INFO] Training for", DEFAULT_TRAIN_ROUNDS, "rounds..." model = xgb.train(xgb_params, dtrain, num_boost_round=DEFAULT_TRAIN_ROUNDS, evals=[(dtrain, 'train')], verbose_eval=50) y_predict = model.predict(dtest) gunja_invest = pd.DataFrame({'id': test_df.id, 'price_doc': y_predict}) print gunja_invest.head() ########################## Train for OwnerOccupier Data ######################### # ----------------- Settings ----------------- # DEFAULT_TRAIN_ROUNDS = 704 #load files df = pd.read_csv('input/train.csv', parse_dates=['timestamp']) test_df = pd.read_csv('input/test.csv', parse_dates=['timestamp']) macro = pd.read_csv('input/macro.csv', parse_dates=['timestamp']) # ----------------- Data Cleaning ----------------- # # Training Set df.loc[df.id==13549, 'life_sq'] = 74 df.loc[df.id==10092, 'build_year'] = 2007 df.loc[df.id==10092, 'state'] = 3 df.loc[df.id==13120, 'build_year'] = 1970 df.loc[df.id==25943, 'max_floor'] = 17 # Clean - Full Sq df = df[(df.full_sq>1)|(df.life_sq>1)] df.loc[(df.full_sq<10) & (df.life_sq>1), 'full_sq'] = df.life_sq df = df[df.full_sq<400] # Clean - Life Sq df.loc[df.life_sq > df.full_sq*4, 'life_sq'] = df.life_sq/10 df.loc[df.life_sq > df.full_sq, 'life_sq'] = np.nan df.loc[df.life_sq < 5, 'life_sq'] = np.nan df.loc[df.life_sq < df.full_sq * 0.3, 'life_sq'] = np.nan df = df[df.life_sq<300] # Clean - Kitch Sq df.loc[df.kitch_sq < 2, 'kitch_sq'] = np.nan df.loc[df.kitch_sq > df.full_sq * 0.5, 'kitch_sq'] = np.nan df.loc[df.kitch_sq > df.life_sq, 'kitch_sq'] = np.nan # Clean - Build Year df.loc[df.build_year<1000, 'build_year'] = np.nan df.loc[df.build_year>2050, 'build_year'] = np.nan # Clean - Num Room df.loc[df.num_room<1, 'num_room'] = np.nan df.loc[(df.num_room>4) & (df.full_sq<60), 'num_room'] = np.nan # Clean - Floor and Max Floor df.loc[df.floor==0, 'floor'] = np.nan df.loc[df.max_floor==0, 'max_floor'] = np.nan df.loc[(df.max_floor==1) & (df.floor>1), 'max_floor'] = np.nan df.loc[df.max_floor>50, 'max_floor'] = np.nan df.loc[df.floor>df.max_floor, 'floor'] = np.nan # Test Set test_df.loc[test_df.id==30938, 'full_sq'] = 37.8 test_df.loc[test_df.id==35857, 'full_sq'] = 42.07 test_df.loc[test_df.id==35108, 'full_sq'] = 40.3 test_df.loc[test_df.id==33648, 'num_room'] = 1 # Clean - Full Sq test_df.loc[(test_df.full_sq<10) & (test_df.life_sq>1), 'full_sq'] = test_df.life_sq # Clean - Life Sq test_df.loc[test_df.life_sq>test_df.full_sq*2, 'life_sq'] = test_df.life_sq/10 test_df.loc[test_df.life_sq > test_df.full_sq, 'life_sq'] = np.nan test_df.loc[test_df.life_sq < 5, 'life_sq'] = np.nan test_df.loc[test_df.life_sq < test_df.full_sq * 0.3, 'life_sq'] = np.nan # Clean - Kitch Sq test_df.loc[test_df.kitch_sq < 2, 'kitch_sq'] = np.nan test_df.loc[test_df.kitch_sq > test_df.full_sq * 0.5, 'kitch_sq'] = np.nan test_df.loc[test_df.kitch_sq > test_df.life_sq, 'kitch_sq'] = np.nan # Clean - Build Year test_df.loc[test_df.build_year<1000, 'build_year'] = np.nan test_df.loc[test_df.build_year>2050, 'build_year'] = np.nan # Clean - Num Room test_df.loc[test_df.num_room<1, 'num_room'] = np.nan test_df.loc[(test_df.num_room>4) & (test_df.full_sq<60), 'num_room'] = np.nan # Clean - Floor and Max Floor test_df.loc[test_df.floor==0, 'floor'] = np.nan test_df.loc[test_df.max_floor==0, 'max_floor'] = np.nan test_df.loc[(test_df.max_floor==1) & (test_df.floor>1), 'max_floor'] = np.nan test_df.loc[test_df.max_floor>50, 'max_floor'] = np.nan test_df.loc[test_df.floor>test_df.max_floor, 'floor'] = np.nan # ----------------- New Features ----------------- # # month_year_cnt month_year = (df.timestamp.dt.month + df.timestamp.dt.year * 100) month_year_cnt_map = month_year.value_counts().to_dict() df['month_year_cnt'] = month_year.map(month_year_cnt_map) month_year = (test_df.timestamp.dt.month + test_df.timestamp.dt.year * 100) month_year_cnt_map = month_year.value_counts().to_dict() test_df['month_year_cnt'] = month_year.map(month_year_cnt_map) # week_year_cnt week_year = (df.timestamp.dt.weekofyear + df.timestamp.dt.year * 100) week_year_cnt_map = week_year.value_counts().to_dict() df['week_year_cnt'] = week_year.map(week_year_cnt_map) week_year = (test_df.timestamp.dt.weekofyear + test_df.timestamp.dt.year * 100) week_year_cnt_map = week_year.value_counts().to_dict() test_df['week_year_cnt'] = week_year.map(week_year_cnt_map) # month df['month'] = df.timestamp.dt.month test_df['month'] = test_df.timestamp.dt.month # day of week df['dow'] = df.timestamp.dt.dayofweek test_df['dow'] = test_df.timestamp.dt.dayofweek # floor/max_floor df['floor/max_floor'] = df['floor'] / df['max_floor'].astype(float) test_df['floor/max_floor'] = test_df['floor'] / test_df['max_floor'].astype(float) # kitch_sq/full_sq df["kitch_sq/full_sq"] = df["kitch_sq"] / df["full_sq"].astype(float) test_df["kitch_sq/full_sq"] = test_df["kitch_sq"] / test_df["full_sq"].astype(float) # Avg Room Size df['avg_room_size'] = df['life_sq'] / df['num_room'].astype(float) test_df['avg_room_size'] = test_df['life_sq'] / test_df['num_room'].astype(float) # Apartment Name df['apartment_name'] = df['sub_area'] + df['metro_km_avto'].astype(str) test_df['apartment_name'] = test_df['sub_area'] + test_df['metro_km_avto'].astype(str) # ----------------- Train for OwnerOccupier Data ----------------- # df = df[df.product_type=="OwnerOccupier"] df = df[df.price_doc/df.full_sq <= np.exp(13.15)] df = df[df.price_doc/df.full_sq >= np.exp(10.4)] test_df.product_type = "OwnerOccupier" y_train = df["price_doc"] x_train = df.drop(["id", "timestamp", "price_doc"], axis=1) x_test = test_df.drop(["id", "timestamp"], axis=1) x_all = pd.concat([x_train, x_test]) # Feature Encoding for c in x_all.columns: if x_all[c].dtype == 'object': lbl = preprocessing.LabelEncoder() lbl.fit(list(x_all[c].values)) x_all[c] = lbl.transform(list(x_all[c].values)) # Separate Training and Test Data num_train = len(x_train) x_train = x_all[:num_train] x_test = x_all[num_train:] dtrain = xgb.DMatrix(x_train, y_train) dtest = xgb.DMatrix(x_test) # ----------------- Cross Validation ----------------- # xgb_params = { 'eta': 0.03, 'max_depth': 5, 'subsample': 0.7, 'colsample_bytree': 1, 'objective': 'reg:linear', 'eval_metric': 'rmse', 'silent': 1, 'seed': 0 } if EN_CROSSVALIDATION: print "[INFO] Cross Validation..." cv_output = xgb.cv(xgb_params, dtrain, num_boost_round=1000, early_stopping_rounds=10, verbose_eval=20, show_stdv=True) DEFAULT_TRAIN_ROUNDS = len(cv_output) print "[INFO] Optimal Training Rounds =", DEFAULT_TRAIN_ROUNDS # ----------------- Training ----------------- # print "[INFO] Training for", DEFAULT_TRAIN_ROUNDS, "rounds..." model = xgb.train(xgb_params, dtrain, num_boost_round=DEFAULT_TRAIN_ROUNDS, evals=[(dtrain, 'train')], verbose_eval=50) y_predict = model.predict(dtest) gunja_owner = pd.DataFrame({'id': test_df.id, 'price_doc': y_predict}) print gunja_owner.head() ############################## Merge ############################# test_df = pd.read_csv('input/test.csv', parse_dates=['timestamp']) test_df['price_doc'] = gunja_invest['price_doc'] test_df.loc[test_df.product_type=="OwnerOccupier", 'price_doc'] = gunja_owner['price_doc'] gunja_output = test_df[["id", "price_doc"]] print gunja_output.head() print "[INFO] Average Price =", gunja_output['price_doc'].mean() ################# Louis Model ##################### train = pd.read_csv('input/train.csv') test = pd.read_csv('input/test.csv') id_test = test.id mult = .969 y_train = train["price_doc"] * mult + 10 x_train = train.drop(["id", "timestamp", "price_doc"], axis=1) x_test = test.drop(["id", "timestamp"], axis=1) for c in x_train.columns: if x_train[c].dtype == 'object': lbl = preprocessing.LabelEncoder() lbl.fit(list(x_train[c].values)) x_train[c] = lbl.transform(list(x_train[c].values)) for c in x_test.columns: if x_test[c].dtype == 'object': lbl = preprocessing.LabelEncoder() lbl.fit(list(x_test[c].values)) x_test[c] = lbl.transform(list(x_test[c].values)) xgb_params = { 'eta': 0.05, 'max_depth': 5, 'subsample': 0.7, 'colsample_bytree': 0.7, 'objective': 'reg:linear', 'eval_metric': 'rmse', 'seed': 0, 'silent': 1 } dtrain = xgb.DMatrix(x_train, y_train) dtest = xgb.DMatrix(x_test) # cv_output = xgb.cv(xgb_params, dtrain, num_boost_round=1000, early_stopping_rounds=20, verbose_eval=25, show_stdv=False) # print('best num_boost_rounds = ', len(cv_output)) # num_boost_rounds = len(cv_output) # 382 num_boost_rounds = 384 # This was the CV output, as earlier version shows model = xgb.train(xgb_params, dtrain, num_boost_round= num_boost_rounds) y_predict = model.predict(dtest) output = pd.DataFrame({'id': id_test, 'price_doc': y_predict}) print "[INFO] Louis Model Average Price =", output['price_doc'].mean() # output.drop('average_q_price', axis=1, inplace=True) # output.head() ######################## Bruno Model ######################### # Any results you write to the current directory are saved as output. df_train = pd.read_csv("input/train.csv", parse_dates=['timestamp']) df_test = pd.read_csv("input/test.csv", parse_dates=['timestamp']) df_macro = pd.read_csv("input/macro.csv", parse_dates=['timestamp']) df_train.drop(df_train[df_train["life_sq"] > 7000].index, inplace=True) mult = 0.969 y_train = df_train['price_doc'].values * mult + 10 id_test = df_test['id'] df_train.drop(['id', 'price_doc'], axis=1, inplace=True) df_test.drop(['id'], axis=1, inplace=True) num_train = len(df_train) df_all = pd.concat([df_train, df_test]) # Next line just adds a lot of NA columns (becuase "join" only works on indexes) # but somewhow it seems to affect the result df_all = df_all.join(df_macro, on='timestamp', rsuffix='_macro') print(df_all.shape) # Add month-year month_year = (df_all.timestamp.dt.month + df_all.timestamp.dt.year * 100) month_year_cnt_map = month_year.value_counts().to_dict() df_all['month_year_cnt'] = month_year.map(month_year_cnt_map) # Add week-year count week_year = (df_all.timestamp.dt.weekofyear + df_all.timestamp.dt.year * 100) week_year_cnt_map = week_year.value_counts().to_dict() df_all['week_year_cnt'] = week_year.map(week_year_cnt_map) # Add month and day-of-week df_all['month'] = df_all.timestamp.dt.month df_all['dow'] = df_all.timestamp.dt.dayofweek # Other feature engineering df_all['rel_floor'] = df_all['floor'] / df_all['max_floor'].astype(float) df_all['rel_kitch_sq'] = df_all['kitch_sq'] / df_all['full_sq'].astype(float) train['building_name'] = pd.factorize(train.sub_area + train['metro_km_avto'].astype(str))[0] test['building_name'] = pd.factorize(test.sub_area + test['metro_km_avto'].astype(str))[0] def add_time_features(col): col_month_year = pd.Series(pd.factorize(train[col].astype(str) + month_year.astype(str))[0]) train[col + '_month_year_cnt'] = col_month_year.map(col_month_year.value_counts()) col_week_year = pd.Series(pd.factorize(train[col].astype(str) + week_year.astype(str))[0]) train[col + '_week_year_cnt'] = col_week_year.map(col_week_year.value_counts()) add_time_features('building_name') add_time_features('sub_area') def add_time_features(col): col_month_year = pd.Series(pd.factorize(test[col].astype(str) + month_year.astype(str))[0]) test[col + '_month_year_cnt'] = col_month_year.map(col_month_year.value_counts()) col_week_year = pd.Series(pd.factorize(test[col].astype(str) + week_year.astype(str))[0]) test[col + '_week_year_cnt'] = col_week_year.map(col_week_year.value_counts()) add_time_features('building_name') add_time_features('sub_area') # Remove timestamp column (may overfit the model in train) df_all.drop(['timestamp', 'timestamp_macro'], axis=1, inplace=True) factorize = lambda t: pd.factorize(t[1])[0] df_obj = df_all.select_dtypes(include=['object']) X_all = np.c_[ df_all.select_dtypes(exclude=['object']).values, np.array(list(map(factorize, df_obj.iteritems()))).T ] print(X_all.shape) X_train = X_all[:num_train] X_test = X_all[num_train:] # Deal with categorical values df_numeric = df_all.select_dtypes(exclude=['object']) df_obj = df_all.select_dtypes(include=['object']).copy() for c in df_obj: df_obj[c] = pd.factorize(df_obj[c])[0] df_values = pd.concat([df_numeric, df_obj], axis=1) # Convert to numpy values X_all = df_values.values print(X_all.shape) X_train = X_all[:num_train] X_test = X_all[num_train:] df_columns = df_values.columns xgb_params = { 'eta': 0.05, 'max_depth': 5, 'subsample': 0.7, 'colsample_bytree': 0.7, 'objective': 'reg:linear', 'eval_metric': 'rmse', 'seed': 0, 'silent': 1 } dtrain = xgb.DMatrix(X_train, y_train, feature_names=df_columns) dtest = xgb.DMatrix(X_test, feature_names=df_columns) # cv_output = xgb.cv(xgb_params, dtrain, num_boost_round=1000, early_stopping_rounds=20, verbose_eval=25, show_stdv=False) # print('best num_boost_rounds = ', len(cv_output)) # num_boost_rounds = len(cv_output) # num_boost_rounds = 420 # From Bruno's original CV, I think model = xgb.train(xgb_params, dtrain, num_boost_round=num_boost_rounds) y_pred = model.predict(dtest) df_sub = pd.DataFrame({'id': id_test, 'price_doc': y_pred}) print "[INFO] Bruno Model Average Price =", df_sub['price_doc'].mean() df_sub.head() first_result = output.merge(df_sub, on="id", suffixes=['_louis','_bruno']) first_result["price_doc"] = np.exp( .714*np.log(first_result.price_doc_louis) + .286*np.log(first_result.price_doc_bruno) ) # multiplies out to .5 & .2 result = first_result.merge(gunja_output, on="id", suffixes=['_follow','_gunja']) result["price_doc"] = np.exp( .78*np.log(result.price_doc_follow) + .22*np.log(result.price_doc_gunja) ) result.drop(["price_doc_louis","price_doc_bruno","price_doc_follow","price_doc_gunja"],axis=1,inplace=True) result.head() print "[INFO] Ensemble Average Price =", result['price_doc'].mean() result.to_csv('sub-silly-fixed-price-changed-local.csv', index=False)
37.620451
122
0.680518
3,672
21,707
3.753813
0.096678
0.071387
0.022345
0.040554
0.782429
0.75341
0.737377
0.728743
0.714234
0.702554
0
0.024801
0.126964
21,707
576
123
37.685764
0.702549
0.158244
0
0.688889
0
0
0.168039
0.002185
0
0
0
0
0
0
null
null
0
0.013889
null
null
0.044444
0
0
0
null
0
0
0
0
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
1
0
0
0
0
0
0
0
0
6
da6f71630a22c262b4073a0c51a77d513715b121
425
py
Python
appJar/__init__.py
AndreaMordenti/spotydowny
2c0630b1abb6f1fed1aeda46e81a303f9b3057ec
[ "MIT" ]
null
null
null
appJar/__init__.py
AndreaMordenti/spotydowny
2c0630b1abb6f1fed1aeda46e81a303f9b3057ec
[ "MIT" ]
null
null
null
appJar/__init__.py
AndreaMordenti/spotydowny
2c0630b1abb6f1fed1aeda46e81a303f9b3057ec
[ "MIT" ]
null
null
null
# -*- coding: utf-8 -*- from appJar.appjar import gui from appJar.appjar import SelectableLabel from appJar.appjar import AutoCompleteEntry from appJar.appjar import ajScale from appJar.appjar import AjText, AjScrolledText from appJar.appjar import Meter from appJar.appjar import Properties from appJar.appjar import Link from appJar.appjar import Separator from appJar.appjar import Grip from appJar.appjar import PieChart
32.692308
48
0.832941
59
425
6
0.305085
0.310734
0.497175
0.683616
0
0
0
0
0
0
0
0.002667
0.117647
425
12
49
35.416667
0.941333
0.049412
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
0
0
0
null
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
e538de8873ebefefd24ac4ce0c1e5d7dcb552650
124
py
Python
core/__init__.py
wmww/instigate
bc4f77d2cc40a57a0757ca4f460d5a9bc8a076ae
[ "MIT" ]
null
null
null
core/__init__.py
wmww/instigate
bc4f77d2cc40a57a0757ca4f460d5a9bc8a076ae
[ "MIT" ]
null
null
null
core/__init__.py
wmww/instigate
bc4f77d2cc40a57a0757ca4f460d5a9bc8a076ae
[ "MIT" ]
null
null
null
from . import text from . import result from . import context from . import task from . import mission from . import runner
17.714286
21
0.758065
18
124
5.222222
0.444444
0.638298
0
0
0
0
0
0
0
0
0
0
0.193548
124
6
22
20.666667
0.94
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
0
0
null
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
e57305d58af2a255c91b8b82a61a357fa4e8287c
21
py
Python
scadasim/fluids/__init__.py
sintax1/scadasim
8d8beaecf081b81ca5cb0a84b19cb9fe84b7cfa7
[ "MIT" ]
6
2017-10-09T20:02:01.000Z
2021-06-02T11:43:46.000Z
sim/scadasim/fluids/__init__.py
PMaynard/ndn-water-treatment-testbed
926db68237b06f43f6e736f035201ed71fc153bc
[ "MIT" ]
1
2017-03-24T03:31:35.000Z
2017-03-24T03:31:35.000Z
sim/scadasim/fluids/__init__.py
PMaynard/ndn-water-treatment-testbed
926db68237b06f43f6e736f035201ed71fc153bc
[ "MIT" ]
3
2018-05-19T07:47:47.000Z
2019-04-09T15:57:57.000Z
from fluids import *
10.5
20
0.761905
3
21
5.333333
1
0
0
0
0
0
0
0
0
0
0
0
0.190476
21
1
21
21
0.941176
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
f92bb9642c37c93c60e01ee1eac6056d6c684fe1
301
py
Python
venv/Lib/site-packages/pybrain/datasets/__init__.py
ishatserka/MachineLearningAndDataAnalysisCoursera
e82e772df2f4aec162cb34ac6127df10d14a625a
[ "MIT" ]
4
2015-01-01T14:57:38.000Z
2018-07-12T04:21:36.000Z
pybrain/datasets/__init__.py
abhishekgahlot/pybrain
c54661f13857d5bcb0095ba2fb12f5a403a4a70f
[ "BSD-3-Clause" ]
null
null
null
pybrain/datasets/__init__.py
abhishekgahlot/pybrain
c54661f13857d5bcb0095ba2fb12f5a403a4a70f
[ "BSD-3-Clause" ]
2
2015-01-23T09:23:58.000Z
2019-02-22T05:42:29.000Z
# $Id$ from sequential import SequentialDataSet from supervised import SupervisedDataSet from unsupervised import UnsupervisedDataSet from importance import ImportanceDataSet from reinforcement import ReinforcementDataSet from classification import ClassificationDataSet, SequenceClassificationDataSet
43
79
0.900332
26
301
10.423077
0.615385
0
0
0
0
0
0
0
0
0
0
0
0.086379
301
7
79
43
0.985455
0.013289
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
0
1
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
00a24a7c834a962e5087dd20d0c9645c710fc243
35
py
Python
jdaviz/components/file_loader/__init__.py
mariobuikhuizen/jdaviz
1757f49b2ea8c679c23f5925d754798a1deb0c96
[ "BSD-3-Clause" ]
null
null
null
jdaviz/components/file_loader/__init__.py
mariobuikhuizen/jdaviz
1757f49b2ea8c679c23f5925d754798a1deb0c96
[ "BSD-3-Clause" ]
null
null
null
jdaviz/components/file_loader/__init__.py
mariobuikhuizen/jdaviz
1757f49b2ea8c679c23f5925d754798a1deb0c96
[ "BSD-3-Clause" ]
null
null
null
from .file_loader import FileLoader
35
35
0.885714
5
35
6
1
0
0
0
0
0
0
0
0
0
0
0
0.085714
35
1
35
35
0.9375
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
00b824bbfaff68674d84422b6eb362cb02c5a447
120
py
Python
tests/conda_env/__init__.py
jack-pappas/conda
c53a3a44acd3f4194e8c065cfa31a2eb9bc0cd77
[ "BSD-3-Clause" ]
6
2017-09-09T04:47:49.000Z
2020-09-30T11:20:46.000Z
tests/conda_env/__init__.py
jack-pappas/conda
c53a3a44acd3f4194e8c065cfa31a2eb9bc0cd77
[ "BSD-3-Clause" ]
2
2015-11-08T05:03:41.000Z
2016-08-27T17:58:48.000Z
tests/conda_env/__init__.py
jack-pappas/conda
c53a3a44acd3f4194e8c065cfa31a2eb9bc0cd77
[ "BSD-3-Clause" ]
4
2015-11-08T04:46:01.000Z
2016-05-27T15:48:37.000Z
from os.path import dirname, join def support_file(filename): return join(dirname(__file__), 'support', filename)
20
55
0.75
16
120
5.3125
0.6875
0
0
0
0
0
0
0
0
0
0
0
0.141667
120
5
56
24
0.825243
0
0
0
0
0
0.058333
0
0
0
0
0
0
1
0.333333
false
0
0.333333
0.333333
1
0
1
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
1
0
0
1
1
1
0
0
6
00d93841bbcb2760d3fb2ef11fed4aedff75748e
47
py
Python
app/rooms/models/__init__.py
mandarhan/mandarhan
9ce38d10e536e0d3e2f907c3b5c560d66ccf8e40
[ "MIT" ]
null
null
null
app/rooms/models/__init__.py
mandarhan/mandarhan
9ce38d10e536e0d3e2f907c3b5c560d66ccf8e40
[ "MIT" ]
6
2020-02-18T03:49:09.000Z
2022-03-12T00:10:05.000Z
app/rooms/models/__init__.py
mandarhan/mandarhan
9ce38d10e536e0d3e2f907c3b5c560d66ccf8e40
[ "MIT" ]
1
2020-03-25T10:25:43.000Z
2020-03-25T10:25:43.000Z
from .categories import * from .rooms import *
15.666667
25
0.744681
6
47
5.833333
0.666667
0
0
0
0
0
0
0
0
0
0
0
0.170213
47
2
26
23.5
0.897436
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
00e58020cddc3e823098e7657cd1bc61ff2364e1
142
py
Python
geopayment/providers/bog/installment/form.py
Lh4cKg/tbcpay
481ef6148defc9897643919f7c47ce78d149acbf
[ "MIT" ]
null
null
null
geopayment/providers/bog/installment/form.py
Lh4cKg/tbcpay
481ef6148defc9897643919f7c47ce78d149acbf
[ "MIT" ]
null
null
null
geopayment/providers/bog/installment/form.py
Lh4cKg/tbcpay
481ef6148defc9897643919f7c47ce78d149acbf
[ "MIT" ]
null
null
null
class InstallmentForm(object): def __init__(self): pass def media(self): pass def static(self): pass
10.923077
30
0.549296
15
142
4.933333
0.6
0.324324
0.297297
0
0
0
0
0
0
0
0
0
0.366197
142
12
31
11.833333
0.822222
0
0
0.428571
0
0
0
0
0
0
0
0
0
1
0.428571
false
0.428571
0
0
0.571429
0
1
0
0
null
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
1
0
1
0
0
1
0
0
6
9767f117d5090e013ff3b0b1f7b56c6efb209143
73
py
Python
parqser/page/loaded_page.py
ARQtty/parqser
2f4f9505544d718dc818d1d9177ac1394bfbb352
[ "MIT" ]
null
null
null
parqser/page/loaded_page.py
ARQtty/parqser
2f4f9505544d718dc818d1d9177ac1394bfbb352
[ "MIT" ]
null
null
null
parqser/page/loaded_page.py
ARQtty/parqser
2f4f9505544d718dc818d1d9177ac1394bfbb352
[ "MIT" ]
null
null
null
from parqser.page import BasePage class LoadedPage(BasePage): pass
12.166667
33
0.767123
9
73
6.222222
0.888889
0
0
0
0
0
0
0
0
0
0
0
0.178082
73
5
34
14.6
0.933333
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0.333333
0.333333
0
0.666667
0
1
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
1
1
0
1
0
0
6
976d4e5094f350a685ab32e681cd8d16f8fd1538
139,327
py
Python
AppDatabase.py
msimms/OpenWorkoutWeb
21e506b7d5cfaf30875c3f584cfae796ba112d49
[ "MIT" ]
1
2021-06-23T03:59:19.000Z
2021-06-23T03:59:19.000Z
AppDatabase.py
msimms/OpenWorkoutWeb
21e506b7d5cfaf30875c3f584cfae796ba112d49
[ "MIT" ]
10
2021-06-26T20:37:01.000Z
2022-03-22T16:42:22.000Z
AppDatabase.py
msimms/OpenWorkoutWeb
21e506b7d5cfaf30875c3f584cfae796ba112d49
[ "MIT" ]
1
2021-06-17T01:51:27.000Z
2021-06-17T01:51:27.000Z
# -*- coding: utf-8 -*- # # # MIT License # # Copyright (c) 2017 Mike Simms # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. """Database implementation""" import json import re import sys import traceback import uuid from bson.objectid import ObjectId if sys.version_info[0] < 3: from bson import Binary import pymongo import time import Database import InputChecker import Keys import Perf import Workout def retrieve_time_from_location(location): """Used with the sort function.""" return location['time'] def retrieve_time_from_time_value_pair(value): """Used with the sort function.""" if sys.version_info[0] < 3: return value.keys()[0] return list(value.keys())[0] class Device(object): def __init__(self): self.id = 0 self.name = "" self.description = "" super(Device, self).__init__() class MongoDatabase(Database.Database): """Mongo DB implementation of the application database.""" conn = None database = None users_collection = None activities_collection = None workouts_collection = None tasks_collectoin = None uploads_collection = None def __init__(self): Database.Database.__init__(self) def connect(self): """Connects/creates the database""" try: self.conn = pymongo.MongoClient('localhost:27017') # Database. Try the old name, if not found then create or open it with the new name. db_names = self.conn.list_database_names() if 'straendb' in db_names: self.database = self.conn['straendb'] else: self.database = self.conn['openworkoutdb'] # Handles to the various collections. self.users_collection = self.database['users'] self.activities_collection = self.database['activities'] self.records_collection = self.database['records'] self.workouts_collection = self.database['workouts'] self.tasks_collection = self.database['tasks'] self.uploads_collection = self.database['uploads'] # Create indexes. self.activities_collection.create_index(Keys.ACTIVITY_ID_KEY) return True except pymongo.errors.ConnectionFailure as e: self.log_error("Could not connect to MongoDB: %s" % e) return False def total_users_count(self): """Returns the number of users in the database.""" try: return self.users_collection.count() except: self.log_error(MongoDatabase.total_users_count.__name__ + ": Exception") return 0 def total_activities_count(self): """Returns the number of activities in the database.""" try: return self.activities_collection.count() except: self.log_error(MongoDatabase.total_activities_count.__name__ + ": Exception") return 0 def list_excluded_user_keys(self): """This is the list of stuff we don't need to return when we're building a friends list. Helps with efficiency and privacy by not exposing more than we need.""" exclude_keys = {} exclude_keys[Keys.HASH_KEY] = False exclude_keys[Keys.DEVICES_KEY] = False exclude_keys[Keys.FRIEND_REQUESTS_KEY] = False exclude_keys[Keys.FRIENDS_KEY] = False exclude_keys[Keys.PR_KEY] = False exclude_keys[Keys.DEFAULT_PRIVACY_KEY] = False exclude_keys[Keys.USER_PREFERRED_UNITS_KEY] = False return exclude_keys def list_excluded_activity_keys_activity_lists(self): """This is the list of stuff we don't need to return when we're summarizing activities.""" exclude_keys = {} exclude_keys[Keys.APP_LOCATIONS_KEY] = False exclude_keys[Keys.APP_ACCELEROMETER_KEY] = False exclude_keys[Keys.APP_CURRENT_SPEED_KEY] = False exclude_keys[Keys.APP_HEART_RATE_KEY] = False exclude_keys[Keys.APP_CADENCE_KEY] = False exclude_keys[Keys.APP_POWER_KEY] = False return exclude_keys # # User management methods # def create_user(self, username, realname, passhash): """Create method for a user.""" if username is None: self.log_error(MongoDatabase.create_user.__name__ + ": Unexpected empty object: username") return False if realname is None: self.log_error(MongoDatabase.create_user.__name__ + ": Unexpected empty object: realname") return False if passhash is None: self.log_error(MongoDatabase.create_user.__name__ + ": Unexpected empty object: passhash") return False if len(username) == 0: self.log_error(MongoDatabase.create_user.__name__ + ": username too short") return False if len(realname) == 0: self.log_error(MongoDatabase.create_user.__name__ + ": realname too short") return False if len(passhash) == 0: self.log_error(MongoDatabase.create_user.__name__ + ": hash too short") return False try: post = { Keys.USERNAME_KEY: username, Keys.REALNAME_KEY: realname, Keys.HASH_KEY: passhash, Keys.DEVICES_KEY: [], Keys.FRIENDS_KEY: [], Keys.DEFAULT_PRIVACY_KEY: Keys.ACTIVITY_VISIBILITY_PUBLIC } self.users_collection.insert(post) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_user_details(self, username): """Retrieve method for a user.""" if username is None: self.log_error(MongoDatabase.retrieve_user_details.__name__ + ": Unexpected empty object: username") return None if len(username) == 0: self.log_error(MongoDatabase.retrieve_user_details.__name__ + ": username is empty") return None try: return self.users_collection.find_one({ Keys.USERNAME_KEY: username }) except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None def retrieve_user(self, username): """Retrieve method for a user.""" if username is None: self.log_error(MongoDatabase.retrieve_user.__name__ + ": Unexpected empty object: username") return None, None, None if len(username) == 0: self.log_error(MongoDatabase.retrieve_user.__name__ + ": username is empty") return None, None, None try: # Find the user. result_keys = { Keys.DATABASE_ID_KEY: 1, Keys.HASH_KEY: 1, Keys.REALNAME_KEY: 1 } user = self.users_collection.find_one({ Keys.USERNAME_KEY: username }, result_keys) # If the user was found. if user is not None: return str(user[Keys.DATABASE_ID_KEY]), user[Keys.HASH_KEY], str(user[Keys.REALNAME_KEY]) return None, None, None except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None, None, None def retrieve_user_from_id(self, user_id): """Retrieve method for a user.""" if user_id is None: self.log_error(MongoDatabase.retrieve_user_from_id.__name__ + ": Unexpected empty object: user_id") return None, None try: # Find the user. user_id_obj = ObjectId(str(user_id)) result_keys = { Keys.USERNAME_KEY: 1, Keys.REALNAME_KEY: 1 } user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }, result_keys) # If the user was found. if user is not None: return user[Keys.USERNAME_KEY], user[Keys.REALNAME_KEY] return None, None except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None, None def retrieve_user_from_api_key(self, api_key): """Retrieve method for a user.""" if api_key is None: self.log_error(MongoDatabase.retrieve_user_from_id.__name__ + ": Unexpected empty object: api_key") return None, None, None try: # Find the user. rate = 100 query = { Keys.API_KEYS: { Keys.API_KEY: str(api_key), Keys.API_KEY_RATE : rate } } result_keys = { Keys.DATABASE_ID_KEY: 1, Keys.HASH_KEY: 1, Keys.REALNAME_KEY: 1 } user = self.users_collection.find_one(query, result_keys) # If the user was found. if user is not None: return str(user[Keys.DATABASE_ID_KEY]), user[Keys.HASH_KEY], user[Keys.REALNAME_KEY], rate return None, None, None, rate except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None, None, None, None def update_user(self, user_id, username, realname, passhash): """Update method for a user.""" if user_id is None: self.log_error(MongoDatabase.update_user.__name__ + ": Unexpected empty object: user_id") return False if username is None: self.log_error(MongoDatabase.update_user.__name__ + ": Unexpected empty object: username") return False if realname is None: self.log_error(MongoDatabase.update_user.__name__ + ": Unexpected empty object: realname") return False if len(username) == 0: self.log_error(MongoDatabase.update_user.__name__ + ": username too short") return False if len(realname) == 0: self.log_error(MongoDatabase.update_user.__name__ + ": realname too short") return False try: # Find the user. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user was found. if user is not None: user[Keys.USERNAME_KEY] = username user[Keys.REALNAME_KEY] = realname if passhash is not None: user[Keys.HASH_KEY] = passhash self.users_collection.save(user) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def delete_user(self, user_id): """Delete method for a user.""" if user_id is None: self.log_error(MongoDatabase.delete_user.__name__ + ": Unexpected empty object: user_id") return False try: user_id_obj = ObjectId(str(user_id)) deleted_result = self.users_collection.delete_one({ Keys.DATABASE_ID_KEY: user_id_obj }) if deleted_result is not None: return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_matched_users(self, username): """Returns a list of user names for users that match the specified regex.""" user_list = [] if username is None: self.log_error(MongoDatabase.retrieve_matched_users.__name__ + ": Unexpected empty object: username") return user_list if len(username) == 0: self.log_error(MongoDatabase.retrieve_matched_users.__name__ + ": username is empty") return user_list try: matched_usernames = self.users_collection.find({ Keys.USERNAME_KEY: { "$regex": username } }) if matched_usernames is not None: for matched_user in matched_usernames: user_list.append(matched_user[Keys.USERNAME_KEY]) matched_realnames = self.users_collection.find({ Keys.REALNAME_KEY: { "$regex": username } }) if matched_realnames is not None: for matched_user in matched_realnames: username = matched_user[Keys.USERNAME_KEY] if username not in user_list: user_list.append(username) except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return user_list # # Device management methods # def create_user_device(self, user_id, device_str): """Create method for a device.""" if user_id is None: self.log_error(MongoDatabase.create_user_device.__name__ + ": Unexpected empty object: user_id") return False if device_str is None: self.log_error(MongoDatabase.create_user_device.__name__ + ": Unexpected empty object: device_str") return False try: # Find the user. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # Read the devices list. devices = [] if user is not None and Keys.DEVICES_KEY in user: devices = user[Keys.DEVICES_KEY] # Append the device to the devices list, if it is not already there. if device_str not in devices: devices.append(device_str) user[Keys.DEVICES_KEY] = devices self.users_collection.save(user) except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return True def retrieve_user_devices(self, user_id): """Retrieve method for a device.""" if user_id is None: self.log_error(MongoDatabase.retrieve_user_devices.__name__ + ": Unexpected empty object: user_id") return None try: # Find the user. user_id_obj = ObjectId(str(user_id)) result_keys = { Keys.DEVICES_KEY: 1 } user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }, result_keys) # Read the devices list. if user is not None and Keys.DEVICES_KEY in user: return user[Keys.DEVICES_KEY] except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None def retrieve_user_from_device(self, device_str): """Finds the user associated with the device.""" if device_str is None: self.log_error(MongoDatabase.retrieve_user_from_device.__name__ + ": Unexpected empty object: device_str") return None if len(device_str) == 0: self.log_error(MongoDatabase.retrieve_user_from_device.__name__ + ": Device string not provided") return None try: return self.users_collection.find_one({ Keys.DEVICES_KEY: device_str }) except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None def delete_user_device(self, device_str): """Deletes method for a device.""" if device_str is None: self.log_error(MongoDatabase.delete_user_device.__name__ + ": Unexpected empty object: device_str") return False try: self.activities_collection.remove({ Keys.ACTIVITY_DEVICE_STR_KEY: device_str }) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False # # Friend management methods # def create_pending_friend_request(self, user_id, target_id): """Appends a user to the friends list of the user with the specified id.""" if user_id is None: self.log_error(MongoDatabase.create_pending_friend_request.__name__ + ": Unexpected empty object: user_id") return False if target_id is None: self.log_error(MongoDatabase.create_pending_friend_request.__name__ + ": Unexpected empty object: target_id") return False try: # Find the user whose friendship is being requested. user_id_obj = ObjectId(str(target_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user was found then add the target user to the pending friends list. if user is not None: pending_friends_list = [] if Keys.FRIEND_REQUESTS_KEY in user: pending_friends_list = user[Keys.FRIEND_REQUESTS_KEY] if user_id not in pending_friends_list: pending_friends_list.append(user_id) user[Keys.FRIEND_REQUESTS_KEY] = pending_friends_list self.users_collection.save(user) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_pending_friends(self, user_id): """Returns the user ids for all users that are pending confirmation as friends of the specified user.""" if user_id is None: self.log_error(MongoDatabase.retrieve_pending_friends.__name__ + ": Unexpected empty object: user_id") return None try: # Things we don't need. exclude_keys = self.list_excluded_user_keys() # Find the users whose friendship we have requested. pending_friends_list = [] pending_friends = self.users_collection.find({ Keys.FRIEND_REQUESTS_KEY: user_id }, exclude_keys) for pending_friend in pending_friends: pending_friend[Keys.DATABASE_ID_KEY] = str(pending_friend[Keys.DATABASE_ID_KEY]) pending_friend[Keys.REQUESTING_USER_KEY] = "self" pending_friends_list.append(pending_friend) # Find the users who have requested our friendship. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If we found ourselves. if user is not None: temp_friend_id_list = [] if Keys.FRIEND_REQUESTS_KEY in user: temp_friend_id_list = user[Keys.FRIEND_REQUESTS_KEY] for temp_friend_id in temp_friend_id_list: temp_friend_id_obj = ObjectId(str(temp_friend_id)) pending_friend = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: temp_friend_id_obj }, exclude_keys) if pending_friend is not None: pending_friend[Keys.DATABASE_ID_KEY] = str(pending_friend[Keys.DATABASE_ID_KEY]) pending_friend[Keys.REQUESTING_USER_KEY] = str(pending_friend[Keys.DATABASE_ID_KEY]) pending_friends_list.append(pending_friend) return pending_friends_list except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return [] def delete_pending_friend_request(self, user_id, target_id): """Appends a user to the friends list of the user with the specified id.""" if user_id is None: self.log_error(MongoDatabase.delete_pending_friend_request.__name__ + ": Unexpected empty object: user_id") return False if target_id is None: self.log_error(MongoDatabase.delete_pending_friend_request.__name__ + ": Unexpected empty object: target_id") return False try: # Find the user whose friendship is being requested. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user was found then add the target user to the pending friends list. if user is not None: pending_friends_list = [] if Keys.FRIEND_REQUESTS_KEY in user: pending_friends_list = user[Keys.FRIEND_REQUESTS_KEY] if target_id in pending_friends_list: pending_friends_list.remove(target_id) user[Keys.FRIEND_REQUESTS_KEY] = pending_friends_list self.users_collection.save(user) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def create_friend(self, user_id, target_id): """Appends a user to the friends list of the user with the specified id.""" if user_id is None: self.log_error(MongoDatabase.create_friend.__name__ + ": Unexpected empty object: user_id") return False if target_id is None: self.log_error(MongoDatabase.create_friend.__name__ + ": Unexpected empty object: target_id") return False try: # Find the user. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # Find the target user. target_user_id_obj = ObjectId(str(target_id)) target_user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: target_user_id_obj }) # If the users were found then add each other to their friends lists. if user is not None and target_user is not None: # Update the user's friends list. friends_list = [] if Keys.FRIENDS_KEY in user: friends_list = user[Keys.FRIENDS_KEY] if target_id not in friends_list: friends_list.append(target_id) user[Keys.FRIENDS_KEY] = friends_list self.users_collection.save(user) # Update the target user's friends list. friends_list = [] if Keys.FRIENDS_KEY in target_user: friends_list = target_user[Keys.FRIENDS_KEY] if user_id not in friends_list: friends_list.append(user_id) target_user[Keys.FRIENDS_KEY] = friends_list self.users_collection.save(target_user) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_friends(self, user_id): """Returns the user ids for all users that are friends with the user who has the specified id.""" if user_id is None: self.log_error(MongoDatabase.retrieve_friends.__name__ + ": Unexpected empty object: user_id") return None try: # Things we don't need. exclude_keys = self.list_excluded_user_keys() # Find the user's friends list. friends_list = [] friends = self.users_collection.find({ Keys.FRIENDS_KEY: user_id }, exclude_keys) for friend in friends: friend[Keys.DATABASE_ID_KEY] = str(friend[Keys.DATABASE_ID_KEY]) friends_list.append(friend) return friends_list except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return [] def delete_friend(self, user_id, target_id): """Removes the users from each other's friends lists.""" if user_id is None: self.log_error(MongoDatabase.delete_friend.__name__ + ": Unexpected empty object: user_id") return False if target_id is None: self.log_error(MongoDatabase.delete_friend.__name__ + ": Unexpected empty object: target_id") return False try: # Find the user. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # Find the target user. target_user_id_obj = ObjectId(str(target_id)) target_user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: target_user_id_obj }) # If the users were found then add each other to their friends lists. if user is not None and target_user is not None: # Update the user's friends list. friends_list = [] if Keys.FRIENDS_KEY in user: friends_list = user[Keys.FRIENDS_KEY] if target_id in friends_list: friends_list.remove(target_id) user[Keys.FRIENDS_KEY] = friends_list self.users_collection.save(user) # Update the target user's friends list. friends_list = [] if Keys.FRIENDS_KEY in target_user: friends_list = target_user[Keys.FRIENDS_KEY] if user_id in friends_list: friends_list.remove(user_id) target_user[Keys.FRIENDS_KEY] = friends_list self.users_collection.save(target_user) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False # # User settings methods # def update_user_setting(self, user_id, key, value, update_time): """Create/update method for user preferences.""" if user_id is None: self.log_error(MongoDatabase.update_user_setting.__name__ + ": Unexpected empty object: user_id") return False if key is None: self.log_error(MongoDatabase.update_user_setting.__name__ + ": Unexpected empty object: key") return False if value is None: self.log_error(MongoDatabase.update_user_setting.__name__ + ": Unexpected empty object: value") return False if update_time is None: self.log_error(MongoDatabase.update_user_setting.__name__ + ": Unexpected empty object: update_time") return False try: # Find the user. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user was found. if user is not None: # Do not replace a newer value with an older value. if Keys.USER_SETTINGS_LAST_UPDATED_KEY not in user: user[Keys.USER_SETTINGS_LAST_UPDATED_KEY] = {} elif key in user[Keys.USER_SETTINGS_LAST_UPDATED_KEY] and user[Keys.USER_SETTINGS_LAST_UPDATED_KEY][key] > update_time: return False # Update. user[Keys.USER_SETTINGS_LAST_UPDATED_KEY][key] = update_time user[key] = value self.users_collection.save(user) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_user_setting(self, user_id, key): """Retrieve method for user preferences.""" if user_id is None: self.log_error(MongoDatabase.retrieve_user_setting.__name__ + ": Unexpected empty object: user_id") return None if key is None: self.log_error(MongoDatabase.retrieve_user_setting.__name__ + ": Unexpected empty object: key") return None try: # Find the user. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # Find the setting. if user is not None and key in user and key in Keys.USER_SETTINGS: return user[key] except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None def retrieve_user_settings(self, user_id, keys): """Retrieve method for user preferences.""" if user_id is None: self.log_error(MongoDatabase.retrieve_user_settings.__name__ + ": Unexpected empty object: user_id") return None if keys is None: self.log_error(MongoDatabase.retrieve_user_settings.__name__ + ": Unexpected empty object: keys") return None try: # Find the user. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # Find the settings. results = [] if user is not None: for key in keys: if key in user and key in Keys.USER_SETTINGS: results.append({key: user[key]}) return results except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None # # Personal record management methods # def create_user_personal_records(self, user_id, records): """Create method for a user's personal record.""" if user_id is None: self.log_error(MongoDatabase.create_user_personal_records.__name__ + ": Unexpected empty object: user_id") return False if records is None: self.log_error(MongoDatabase.create_user_personal_records.__name__ + ": Unexpected empty object: records") return False try: # Find the user's records collection. user_id_str = str(user_id) user_records = self.records_collection.find_one({ Keys.RECORDS_USER_ID: user_id_str }) # If the collection was found. if user_records is None: post = { Keys.RECORDS_USER_ID: user_id_str, Keys.PERSONAL_RECORDS_KEY: records } self.records_collection.insert(post) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def update_user_personal_records(self, user_id, records): """Create method for a user's personal record. These are the bests across all activities. Activity records are the bests for individual activities.""" if user_id is None: self.log_error(MongoDatabase.update_user_personal_records.__name__ + ": Unexpected empty object: user_id") return False if records is None or len(records) == 0: self.log_error(MongoDatabase.update_user_personal_records.__name__ + ": Unexpected empty object: records") return False try: # Find the user's records collection. user_id_str = str(user_id) user_records = self.records_collection.find_one({ Keys.RECORDS_USER_ID: user_id_str }) # If the collection was found. if user_records is not None: user_records[Keys.PERSONAL_RECORDS_KEY] = records self.records_collection.save(user_records) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def delete_all_user_personal_records(self, user_id): """Delete method for a user's personal record. Deletes the entire personal record cache.""" if user_id is None: self.log_error(MongoDatabase.delete_all_user_personal_records.__name__ + ": Unexpected empty object: user_id") return False try: # Delete the user's records collection. user_id_str = str(user_id) deleted_result = self.records_collection.delete_one({ Keys.RECORDS_USER_ID: user_id_str }) if deleted_result is not None: return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False # # Activity bests management methods # def create_activity_bests(self, user_id, activity_id, activity_type, activity_time, bests): """Create method for a user's personal records for a given activity.""" if user_id is None: self.log_error(MongoDatabase.create_activity_bests.__name__ + ": Unexpected empty object: user_id") return False if activity_id is None: self.log_error(MongoDatabase.create_activity_bests.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_activity_bests.__name__ + ": Invalid object: activity_id") return False if activity_type is None: self.log_error(MongoDatabase.create_activity_bests.__name__ + ": Unexpected empty object: activity_type") return False if activity_time is None: self.log_error(MongoDatabase.create_activity_bests.__name__ + ": Unexpected empty object: activity_time") return False if bests is None: self.log_error(MongoDatabase.create_activity_bests.__name__ + ": Unexpected empty object: bests") return False try: # Find the user's records collection. user_records = self.records_collection.find_one({ Keys.RECORDS_USER_ID: user_id }) if user_records is not None: bests[Keys.ACTIVITY_TYPE_KEY] = activity_type bests[Keys.ACTIVITY_START_TIME_KEY] = activity_time user_records[activity_id] = bests self.records_collection.save(user_records) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_recent_activity_bests_for_user(self, user_id, cutoff_time): """Retrieve method for a user's activity records. Only activities more recent than the specified cutoff time will be returned.""" if user_id is None: self.log_error(MongoDatabase.retrieve_recent_activity_bests_for_user.__name__ + ": Unexpected empty object: user_id") return {} try: user_records = self.records_collection.find_one({ Keys.RECORDS_USER_ID: user_id }) if user_records is not None: bests = {} for activity_id in user_records: if InputChecker.is_uuid(activity_id): activity_bests = user_records[activity_id] if (cutoff_time is None) or (activity_bests[Keys.ACTIVITY_START_TIME_KEY] > cutoff_time): bests[activity_id] = activity_bests return bests except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return {} def retrieve_bounded_activity_bests_for_user(self, user_id, cutoff_time_lower, cutoff_time_higher): """Retrieve method for a user's activity records. Only activities more recent than the specified cutoff time will be returned.""" if user_id is None: self.log_error(MongoDatabase.retrieve_bounded_activity_bests_for_user.__name__ + ": Unexpected empty object: user_id") return {} if cutoff_time_lower is None: self.log_error(MongoDatabase.retrieve_bounded_activity_bests_for_user.__name__ + ": Unexpected empty object: cutoff_time_lower") return {} if cutoff_time_higher is None: self.log_error(MongoDatabase.retrieve_bounded_activity_bests_for_user.__name__ + ": Unexpected empty object: cutoff_time_higher") return {} try: user_records = self.records_collection.find_one({ Keys.RECORDS_USER_ID: user_id }) if user_records is not None: bests = {} for activity_id in user_records: if InputChecker.is_uuid(activity_id): activity_bests = user_records[activity_id] activity_time = activity_bests[Keys.ACTIVITY_START_TIME_KEY] if activity_time >= cutoff_time_lower and activity_time < cutoff_time_higher: bests[activity_id] = activity_bests return bests except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return {} def delete_activity_best_for_user(self, user_id, activity_id): """Delete method for a user's personal records for a given activity.""" if user_id is None: self.log_error(MongoDatabase.delete_activity_best_for_user.__name__ + ": Unexpected empty object: user_id") return False if activity_id is None: self.log_error(MongoDatabase.delete_activity_best_for_user.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.delete_activity_best_for_user.__name__ + ": Invalid object: activity_id") return False try: user_records = self.records_collection.find_one({ Keys.RECORDS_USER_ID: user_id }) if user_records is not None: user_records.pop(activity_id, None) self.records_collection.save(user_records) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False # # Activity management methods # @Perf.statistics def retrieve_user_activity_list(self, user_id, start_time, end_time, return_all_data): """Retrieves the list of activities associated with the specified user.""" """If return_all_data is False then only metadata is returned.""" if user_id is None: self.log_error(MongoDatabase.retrieve_user_activity_list.__name__ + ": Unexpected empty object: user_id") return [] try: # Things we don't need. if return_all_data: exclude_keys = None else: exclude_keys = self.list_excluded_activity_keys_activity_lists() if start_time is None or end_time is None: return list(self.activities_collection.find({ "$and": [ { Keys.ACTIVITY_USER_ID_KEY: { '$eq': user_id } } ]}, exclude_keys)) return list(self.activities_collection.find({ "$and": [ { Keys.ACTIVITY_USER_ID_KEY: { '$eq': user_id }}, { Keys.ACTIVITY_START_TIME_KEY: { '$gt': start_time } }, { Keys.ACTIVITY_START_TIME_KEY: { '$lt': end_time } } ]}, exclude_keys)) except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return [] @Perf.statistics def retrieve_each_user_activity(self, context, user_id, callback_func, return_all_data): """Retrieves each user activity and calls the callback function for each one.""" """Returns TRUE on success, FALSE if an error was encountered.""" """If return_all_data is False then only metadata is returned.""" try: # Things we don't need. if return_all_data: exclude_keys = None else: exclude_keys = self.list_excluded_activity_keys_activity_lists() activities_cursor = self.activities_collection.find({ Keys.ACTIVITY_USER_ID_KEY: user_id }, exclude_keys) if activities_cursor is not None: while activities_cursor.alive: activity = activities_cursor.next() callback_func(context, activity, user_id) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False @Perf.statistics def retrieve_devices_activity_list(self, devices, start_time, end_time, return_all_data): """Retrieves the list of activities associated with the specified devices.""" if devices is None: self.log_error(MongoDatabase.retrieve_devices_activity_list.__name__ + ": Unexpected empty object: devices") return [] try: # Things we don't need. if return_all_data: exclude_keys = None else: exclude_keys = self.list_excluded_activity_keys_activity_lists() # Build part of the exptression while sanity checking the input. device_list = [] for device_str in devices: if InputChecker.is_uuid(device_str): device_list.append( { Keys.ACTIVITY_DEVICE_STR_KEY: {'$eq': device_str} } ) if start_time is None or end_time is None: return list(self.activities_collection.find({ "$or": device_list }, exclude_keys)) return list(self.activities_collection.find({ "$and": [ { "$or": device_list }, { Keys.ACTIVITY_START_TIME_KEY: { '$gt': start_time } }, { Keys.ACTIVITY_START_TIME_KEY: { '$lt': end_time } } ] }, exclude_keys)) except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return [] @Perf.statistics def retrieve_each_device_activity(self, context, user_id, device_str, callback_func, return_all_data): """Retrieves each device activity and calls the callback function for each one.""" """If return_all_data is False then only metadata is returned.""" if user_id is None: self.log_error(MongoDatabase.retrieve_each_device_activity.__name__ + ": Unexpected empty object: device_str") return None if device_str is None: self.log_error(MongoDatabase.retrieve_each_device_activity.__name__ + ": Unexpected empty object: device_str") return None if callback_func is None: self.log_error(MongoDatabase.retrieve_each_device_activity.__name__ + ": Unexpected empty object: device_str") return None try: # Things we don't need. if return_all_data: exclude_keys = None else: exclude_keys = self.list_excluded_activity_keys_activity_lists() activities_cursor = self.activities_collection.find({ Keys.ACTIVITY_DEVICE_STR_KEY: device_str }, exclude_keys) if activities_cursor is not None: try: while activities_cursor.alive: activity = activities_cursor.next() callback_func(context, activity, user_id) except StopIteration: pass except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None @Perf.statistics def retrieve_most_recent_activity_for_device(self, device_str, return_all_data): """Retrieves the ID for the most recent activity to be associated with the specified device.""" if device_str is None: self.log_error(MongoDatabase.retrieve_most_recent_activity_for_device.__name__ + ": Unexpected empty object: device_str") return None try: # Things we don't need. if return_all_data: exclude_keys = None else: exclude_keys = self.list_excluded_activity_keys_activity_lists() activity = self.activities_collection.find_one({ Keys.ACTIVITY_DEVICE_STR_KEY: device_str }, exclude_keys, sort=[( '_id', pymongo.DESCENDING )]) return activity except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None def create_activity(self, activity_id, activty_name, date_time, device_str): """Create method for an activity.""" if activity_id is None: self.log_error(MongoDatabase.create_activity.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_activity.__name__ + ": Invalid object: activity_id") return False if activty_name is None: self.log_error(MongoDatabase.create_activity.__name__ + ": Unexpected empty object: activty_name") return False if date_time is None: self.log_error(MongoDatabase.create_activity.__name__ + ": Unexpected empty object: date_time") return False if device_str is None: self.log_error(MongoDatabase.create_activity.__name__ + ": Unexpected empty object: device_str") return False try: # Make sure the activity name is a string. activty_name = str(activty_name) # Create the activity. post = { Keys.ACTIVITY_ID_KEY: activity_id, Keys.ACTIVITY_NAME_KEY: activty_name, Keys.ACTIVITY_START_TIME_KEY: date_time, Keys.ACTIVITY_DEVICE_STR_KEY: device_str, Keys.ACTIVITY_VISIBILITY_KEY: "public", Keys.ACTIVITY_LOCATIONS_KEY: [] } self.activities_collection.insert(post) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False @Perf.statistics def retrieve_activity(self, activity_id): """Retrieve method for an activity, specified by the activity ID.""" if activity_id is None: self.log_error(MongoDatabase.retrieve_activity.__name__ + ": Unexpected empty object: activity_id") return None if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.retrieve_activity.__name__ + ": Invalid object: activity_id") return None try: # Find the activity. return self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: re.compile(activity_id, re.IGNORECASE) }) except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None @Perf.statistics def retrieve_activity_small(self, activity_id): """Retrieve method for an activity, specified by the activity ID.""" if activity_id is None: self.log_error(MongoDatabase.retrieve_activity_small.__name__ + ": Unexpected empty object: activity_id") return None if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.retrieve_activity_small.__name__ + ": Invalid object: activity_id") return None try: # Things we don't need. exclude_keys = self.list_excluded_activity_keys_activity_lists() # Find the activity. return self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: re.compile(activity_id, re.IGNORECASE) }, exclude_keys) except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None def update_activity(self, device_str, activity_id, locations, sensor_readings_dict, metadata_list_dict): """Updates locations, sensor readings, and metadata associated with a moving activity. Provided as a performance improvement over making several database updates.""" if device_str is None: self.log_error(MongoDatabase.update_activity.__name__ + ": Unexpected empty object: device_str") return False if activity_id is None: self.log_error(MongoDatabase.update_activity.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.update_activity.__name__ + ": Invalid object: activity_id") return False if not locations: self.log_error(MongoDatabase.update_activity.__name__ + ": Unexpected empty object: locations") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id, Keys.ACTIVITY_DEVICE_STR_KEY: device_str }) # If the activity was not found then create it. if activity is None: first_location = locations[0] if self.create_activity(activity_id, "", first_location[0] / 1000, device_str): activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id, Keys.ACTIVITY_DEVICE_STR_KEY: device_str }) # If the activity was found. if activity is not None: # Update the locations. Location data is an array, the order is defined in Api.parse_json_loc_obj. if len(locations) > 0: # Find any existing location data. old_locations = [] if Keys.ACTIVITY_LOCATIONS_KEY in activity: old_locations = activity[Keys.ACTIVITY_LOCATIONS_KEY] # Append the new locations. for location in locations: value = { Keys.LOCATION_TIME_KEY: location[0], Keys.LOCATION_LAT_KEY: location[1], Keys.LOCATION_LON_KEY: location[2], Keys.LOCATION_ALT_KEY: location[3], Keys.LOCATION_HORIZONTAL_ACCURACY_KEY: location[4], Keys.LOCATION_VERTICAL_ACCURACY_KEY: location[5] } old_locations.append(value) # Make sure everything is in the right order, no guarantee we got the updates in the correct order. old_locations.sort(key=retrieve_time_from_location) # Update the database. activity[Keys.ACTIVITY_LOCATIONS_KEY] = old_locations # Update the sensor readings. if sensor_readings_dict: for sensor_type in sensor_readings_dict: # Existing sensor values. old_value_list = [] if sensor_type in activity: old_value_list = activity[sensor_type] # Append new values. for value in sensor_readings_dict[sensor_type]: time_value_pair = { str(value[0]): float(value[1]) } old_value_list.append(time_value_pair) # Sort and update. old_value_list.sort(key=retrieve_time_from_time_value_pair) activity[sensor_type] = old_value_list # Update the metadata readings. if metadata_list_dict: for metadata_type in metadata_list_dict: # Existing metadata values. old_value_list = [] if metadata_type in activity: old_value_list = activity[metadata_type] # Append new values. for value in metadata_list_dict[metadata_type]: time_value_pair = { str(value[0]): float(value[1]) } old_value_list.append(time_value_pair) # Sort and update. old_value_list.sort(key=retrieve_time_from_time_value_pair) activity[metadata_type] = old_value_list # Write out the changes. self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def delete_activity(self, activity_id): """Delete method for an activity, specified by the activity ID.""" if activity_id is None: self.log_error(MongoDatabase.delete_activity.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.delete_activity.__name__ + ": Invalid object: activity_id") return False try: deleted_result = self.activities_collection.delete_one({ Keys.ACTIVITY_ID_KEY: activity_id }) if deleted_result is not None: return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def activity_exists(self, activity_id): """Determines whether or not there is a document corresonding to the activity ID.""" if activity_id is None: self.log_error(MongoDatabase.activity_exists.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.activity_exists.__name__ + ": Invalid object: activity_id") return False try: return self.activities_collection.count_documents({ Keys.ACTIVITY_ID_KEY: activity_id }, limit = 1) != 0 except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_activity_visibility(self, activity_id): """Returns the visibility setting for the specified activity.""" if activity_id is None: self.log_error(MongoDatabase.retrieve_activity_visibility.__name__ + ": Unexpected empty object: activity_id") return None if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.retrieve_activity_visibility.__name__ + ": Invalid object: activity_id") return None try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found and it has a visibility setting. if activity is not None and Keys.ACTIVITY_VISIBILITY_KEY in activity: visibility = activity[Keys.ACTIVITY_VISIBILITY_KEY] return visibility except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None def update_activity_visibility(self, activity_id, visibility): """Changes the visibility setting for the specified activity.""" if activity_id is None: self.log_error(MongoDatabase.update_activity_visibility.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.update_activity_visibility.__name__ + ": Invalid object: activity_id") return False if visibility is None: self.log_error(MongoDatabase.update_activity_visibility.__name__ + ": Unexpected empty object: visibility") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found. if activity is not None: activity[Keys.ACTIVITY_VISIBILITY_KEY] = visibility self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def create_activity_locations(self, device_str, activity_id, locations): """Adds several locations to the database. 'locations' is an array of arrays in the form [time, lat, lon, alt].""" if device_str is None: self.log_error(MongoDatabase.create_activity_locations.__name__ + ": Unexpected empty object: device_str") return False if activity_id is None: self.log_error(MongoDatabase.create_activity_locations.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_activity_locations.__name__ + ": Invalid object: activity_id") return False if not locations: self.log_error(MongoDatabase.create_activity_locations.__name__ + ": Unexpected empty object: locations") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id, Keys.ACTIVITY_DEVICE_STR_KEY: device_str }) # If the activity was not found then create it. if activity is None: first_location = locations[0] if self.create_activity(activity_id, "", first_location[0] / 1000, device_str): activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id, Keys.ACTIVITY_DEVICE_STR_KEY: device_str }) # If the activity was found. if activity is not None: location_list = [] # Get the existing list. if Keys.ACTIVITY_LOCATIONS_KEY in activity: location_list = activity[Keys.ACTIVITY_LOCATIONS_KEY] # Append the new locations. for location in locations: value = { Keys.LOCATION_TIME_KEY: location[0], Keys.LOCATION_LAT_KEY: location[1], Keys.LOCATION_LON_KEY: location[2], Keys.LOCATION_ALT_KEY: location[3] } location_list.append(value) # Make sure everything is in order. location_list.sort(key=retrieve_time_from_location) # Save the changes. activity[Keys.ACTIVITY_LOCATIONS_KEY] = location_list self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_activity_locations(self, activity_id): """Returns all the locations for the specified activity.""" if activity_id is None: self.log_error(MongoDatabase.retrieve_activity_locations.__name__ + ": Unexpected empty object: activity_id") return None if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.retrieve_activity_locations.__name__ + ": Invalid object: activity_id") return None try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found and it has location data. if activity is not None and Keys.ACTIVITY_LOCATIONS_KEY in activity: locations = activity[Keys.ACTIVITY_LOCATIONS_KEY] locations.sort(key=retrieve_time_from_location) return locations except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None def create_activity_sensor_reading(self, activity_id, date_time, sensor_type, value): """Create method for a piece of sensor data, such as a heart rate or power meter reading.""" if activity_id is None: self.log_error(MongoDatabase.create_activity_sensor_reading.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_activity_sensor_reading.__name__ + ": Invalid object: activity_id") return False if date_time is None: self.log_error(MongoDatabase.create_activity_sensor_reading.__name__ + ": Unexpected empty object: date_time") return False if sensor_type is None: self.log_error(MongoDatabase.create_activity_sensor_reading.__name__ + ": Unexpected empty object: sensor_type") return False if value is None: self.log_error(MongoDatabase.create_activity_sensor_reading.__name__ + ": Unexpected empty object: value") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found. if activity is not None: value_list = [] # Get the existing list. if sensor_type in activity: value_list = activity[sensor_type] time_value_pair = { str(date_time): float(value) } value_list.append(time_value_pair) value_list.sort(key=retrieve_time_from_time_value_pair) # Save the changes. activity[sensor_type] = value_list self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def create_activity_sensor_readings(self, activity_id, sensor_type, values): """Create method for several pieces of sensor data, such as a heart rate or power meter reading.""" if activity_id is None: self.log_error(MongoDatabase.create_activity_sensor_readings.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_activity_sensor_readings.__name__ + ": Invalid object: activity_id") return False if sensor_type is None: self.log_error(MongoDatabase.create_activity_sensor_readings.__name__ + ": Unexpected empty object: sensor_type") return False if values is None: self.log_error(MongoDatabase.create_activity_sensor_readings.__name__ + ": Unexpected empty object: values") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found. if activity is not None: value_list = [] # Get the existing list. if sensor_type in activity: value_list = activity[sensor_type] for value in values: time_value_pair = { str(value[0]): float(value[1]) } value_list.append(time_value_pair) value_list.sort(key=retrieve_time_from_time_value_pair) # Save the changes. activity[sensor_type] = value_list self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_activity_sensor_readings(self, sensor_type, activity_id): """Returns all the sensor data for the specified sensor for the given activity.""" if sensor_type is None: self.log_error(MongoDatabase.retrieve_activity_sensor_readings.__name__ + ": Unexpected empty object: sensor_type") return None if activity_id is None: self.log_error(MongoDatabase.retrieve_activity_sensor_readings.__name__ + ": Unexpected empty object: activity_id") return None if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.retrieve_activity_sensor_readings.__name__ + ": Invalid object: activity_id") return None try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found and if it has data for the specified sensor type. if activity is not None and sensor_type in activity: sensor_data = activity[sensor_type] sensor_data.sort(key=retrieve_time_from_time_value_pair) return sensor_data except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None def create_activity_event(self, activity_id, event): """Inherited from ActivityWriter. 'events' is an array of dictionaries in which each dictionary describes an event.""" if activity_id is None: self.log_error(MongoDatabase.create_activity_event.__name__ + ": Unexpected empty object: activity_id") return None if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_activity_event.__name__ + ": Invalid object: activity_id") return None if event is None: self.log_error(MongoDatabase.create_activity_event.__name__ + ": Unexpected empty object: event") return None try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found and if it has data for the specified sensor type. if activity is not None: events_list = [] # Get the existing list. if Keys.APP_EVENTS_KEY in activity: events_list = activity[Keys.APP_EVENTS_KEY] # Update the list. events_list.append(event) # Save the changes. activity[Keys.APP_EVENTS_KEY] = events_list self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None def create_activity_events(self, activity_id, events): """Inherited from ActivityWriter. 'events' is an array of dictionaries in which each dictionary describes an event.""" if activity_id is None: self.log_error(MongoDatabase.create_activity_events.__name__ + ": Unexpected empty object: activity_id") return None if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_activity_events.__name__ + ": Invalid object: activity_id") return None if events is None: self.log_error(MongoDatabase.create_activity_events.__name__ + ": Unexpected empty object: events") return None try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found and if it has data for the specified sensor type. if activity is not None: events_list = [] # Get the existing list. if Keys.APP_EVENTS_KEY in activity: events_list = activity[Keys.APP_EVENTS_KEY] # Update the list. events_list.extend(events) # Save the changes. activity[Keys.APP_EVENTS_KEY] = events_list self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None def create_activity_metadata(self, activity_id, date_time, key, value, create_list): """Create method for a piece of metaadata. When dealing with a list, will append values.""" if activity_id is None: self.log_error(MongoDatabase.create_activity_metadata.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_activity_metadata.__name__ + ": Invalid object: activity_id") return False if date_time is None: self.log_error(MongoDatabase.create_activity_metadata.__name__ + ": Unexpected empty object: date_time") return False if key is None: self.log_error(MongoDatabase.create_activity_metadata.__name__ + ": Unexpected empty object: key") return False if value is None: self.log_error(MongoDatabase.create_activity_metadata.__name__ + ": Unexpected empty object: value") return False if create_list is None: self.log_error(MongoDatabase.create_activity_metadata.__name__ + ": Unexpected empty object: create_list") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found. if activity is not None: # Make sure we're working with a number, if the value is supposed to be a number. try: if not key in [ Keys.ACTIVITY_NAME_KEY, Keys.ACTIVITY_TYPE_KEY, Keys.ACTIVITY_DESCRIPTION_KEY ]: value = float(value) except ValueError: pass # The metadata is a list. if create_list is True: value_list = [] if key in activity: value_list = activity[key] time_value_pair = { str(date_time): value } value_list.append(time_value_pair) value_list.sort(key=retrieve_time_from_time_value_pair) activity[key] = value_list self.activities_collection.save(activity) return True # The metadata is a scalar, just make sure to only update it if it has actually changed or was previously non-existent. elif key not in activity or activity[key] != value: activity[key] = value self.activities_collection.save(activity) return True # It's ok if the value isn't being updated. elif activity[key] == value: return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def create_activity_metadata_list(self, activity_id, key, values): """Create method for a list of metaadata values. Will overwrite existing data.""" if activity_id is None: self.log_error(MongoDatabase.create_activity_metadata_list.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_activity_metadata_list.__name__ + ": Invalid object: activity_id") return False if key is None: self.log_error(MongoDatabase.create_activity_metadata_list.__name__ + ": Unexpected empty object: key") return False if values is None: self.log_error(MongoDatabase.create_activity_metadata_list.__name__ + ": Unexpected empty object: values") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found. if activity is not None: value_list = [] for value in values: time_value_pair = { str(value[0]): float(value[1]) } value_list.append(time_value_pair) value_list.sort(key=retrieve_time_from_time_value_pair) activity[key] = value_list self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def create_activity_sets_and_reps_data(self, activity_id, sets): """Create method for a list of of metaadata values.""" if activity_id is None: self.log_error(MongoDatabase.create_activity_sets_and_reps_data.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_activity_sets_and_reps_data.__name__ + ": Invalid object: activity_id") return False if sets is None: self.log_error(MongoDatabase.create_activity_sets_and_reps_data.__name__ + ": Unexpected empty object: sets") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found. if activity is not None: activity[Keys.APP_SETS_KEY] = sets self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def create_activity_accelerometer_reading(self, device_str, activity_id, accels): """Adds several accelerometer readings to the database. 'accels' is an array of arrays in the form [time, x, y, z].""" if device_str is None: self.log_error(MongoDatabase.create_activity_accelerometer_reading.__name__ + ": Unexpected empty object: device_str") return False if activity_id is None: self.log_error(MongoDatabase.create_activity_accelerometer_reading.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_activity_accelerometer_reading.__name__ + ": Invalid object: activity_id") return False if not accels: self.log_error(MongoDatabase.create_activity_accelerometer_reading.__name__ + ": Unexpected empty object: accels") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id, Keys.ACTIVITY_DEVICE_STR_KEY: device_str }) # If the activity was not found then create it. if activity is None: first_accel = accels[0] if self.create_activity(activity_id, "", first_accel[0] / 1000, device_str): activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id, Keys.ACTIVITY_DEVICE_STR_KEY: device_str }) # If the activity was found. if activity is not None: accel_list = [] # Get the existing list. if Keys.APP_ACCELEROMETER_KEY in activity: accel_list = activity[Keys.APP_ACCELEROMETER_KEY] for accel in accels: # Make sure time values are monotonically increasing. if accel_list and int(accel_list[-1][Keys.ACCELEROMETER_TIME_KEY]) > accel[0]: self.log_error(MongoDatabase.create_activity_accelerometer_reading.__name__ + ": Received out-of-order time value.") else: value = { Keys.ACCELEROMETER_TIME_KEY: accel[0], Keys.ACCELEROMETER_AXIS_NAME_X: accel[1], Keys.ACCELEROMETER_AXIS_NAME_Y: accel[2], Keys.ACCELEROMETER_AXIS_NAME_Z: accel[3] } accel_list.append(value) activity[Keys.APP_ACCELEROMETER_KEY] = accel_list self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def create_activity_summary(self, activity_id, summary_data): """Create method for activity summary data. Summary data is data computed from the raw data.""" if activity_id is None: self.log_error(MongoDatabase.create_activity_summary.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_activity_summary.__name__ + ": Invalid object: activity_id") return False if summary_data is None: self.log_error(MongoDatabase.create_activity_summary.__name__ + ": Unexpected empty object: summary_data") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found. if activity is not None: activity[Keys.ACTIVITY_SUMMARY_KEY] = summary_data self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_activity_summary(self, activity_id): """Returns the activity summary data. Summary data is data computed from the raw data.""" if activity_id is None: self.log_error(MongoDatabase.retrieve_activity_summary.__name__ + ": Unexpected empty object: activity_id") return None if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.retrieve_activity_summary.__name__ + ": Invalid object: activity_id") return None try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found. if activity is not None and Keys.ACTIVITY_SUMMARY_KEY in activity: return activity[Keys.ACTIVITY_SUMMARY_KEY] except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None def delete_activity_summary(self, activity_id): """Delete method for activity summary data. Summary data is data computed from the raw data.""" if activity_id is None: self.log_error(MongoDatabase.delete_activity_summary.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.delete_activity_summary.__name__ + ": Invalid object: activity_id") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found. if activity is not None and Keys.ACTIVITY_SUMMARY_KEY in activity: # Currently left out for performance reasons. #activity[Keys.ACTIVITY_SUMMARY_KEY] = {} #self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False # # Tag management methods # def create_tag(self, activity_id, tag): """Adds a tag to the specified activity.""" if activity_id is None: self.log_error(MongoDatabase.create_tag.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_tag.__name__ + ": Invalid object: activity_id") return False if tag is None: self.log_error(MongoDatabase.create_tag.__name__ + ": Unexpected empty object: tag") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found. if activity is not None: data = [] if Keys.ACTIVITY_TAGS_KEY in activity: data = activity[Keys.ACTIVITY_TAGS_KEY] data.append(tag) activity[Keys.ACTIVITY_TAGS_KEY] = data self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def create_tags_on_activity(self, activity, tags): """Adds a tag to the specified activity.""" if activity is None: self.log_error(MongoDatabase.create_tags_on_activity.__name__ + ": Unexpected empty object: activity") return False if tags is None: self.log_error(MongoDatabase.create_tags_on_activity.__name__ + ": Unexpected empty object: tags") return False try: activity[Keys.ACTIVITY_TAGS_KEY] = tags self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def create_tags_on_activity_by_id(self, activity_id, tags): """Adds a tag to the specified activity.""" if activity_id is None: self.log_error(MongoDatabase.create_tags_on_activity_by_id.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_tags_on_activity_by_id.__name__ + ": Invalid object: activity_id") return False if tags is None: self.log_error(MongoDatabase.create_tags_on_activity_by_id.__name__ + ": Unexpected empty object: tags") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found then add the tags. if activity is not None: activity[Keys.ACTIVITY_TAGS_KEY] = tags self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_tags(self, activity_id): """Retrieves all the tags for the specified activity.""" if activity_id is None: self.log_error(MongoDatabase.retrieve_tags.__name__ + ": Unexpected empty object: activity_id") return [] if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.retrieve_tags.__name__ + ": Invalid object: activity_id") return [] try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found and contains tags. if activity is not None and Keys.ACTIVITY_TAGS_KEY in activity: return activity[Keys.ACTIVITY_TAGS_KEY] except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return [] def delete_tag(self, activity_id, tag): """Deletes the specified tag from the activity with the given ID.""" if activity_id is None: self.log_error(MongoDatabase.create_tag.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_tag.__name__ + ": Invalid object: activity_id") return False if tag is None: self.log_error(MongoDatabase.create_tag.__name__ + ": Unexpected empty object: tag") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found. if activity is not None and Keys.ACTIVITY_TAGS_KEY in activity: data = activity[Keys.ACTIVITY_TAGS_KEY] data.remove(tag) activity[Keys.ACTIVITY_TAGS_KEY] = data self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False # # Activity comment management methods # def create_activity_comment(self, activity_id, commenter_id, comment): """Create method for a comment on an activity.""" if activity_id is None: self.log_error(MongoDatabase.create_activity_comment.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_activity_comment.__name__ + ": Invalid object: activity_id") return False if commenter_id is None: self.log_error(MongoDatabase.create_activity_comment.__name__ + ": Unexpected empty object: commenter_id") return False if comment is None: self.log_error(MongoDatabase.create_activity_comment.__name__ + ": Unexpected empty object: comment") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found. if activity is not None: data = [] if Keys.ACTIVITY_COMMENTS_KEY in activity: data = activity[Keys.ACTIVITY_COMMENTS_KEY] entry_dict = { Keys.ACTIVITY_COMMENTER_ID_KEY: commenter_id, Keys.ACTIVITY_COMMENT_KEY: comment } entry_str = json.dumps(entry_dict) data.append(entry_str) activity[Keys.ACTIVITY_COMMENTS_KEY] = data self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_activity_comments(self, activity_id): """Returns a list containing all of the comments on the specified activity.""" if activity_id is None: self.log_error(MongoDatabase.retrieve_activity_comments.__name__ + ": Unexpected empty object: activity_id") return None if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.retrieve_activity_comments.__name__ + ": Invalid object: activity_id") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found and contains comments. if activity is not None and Keys.ACTIVITY_COMMENTS_KEY in activity: return activity[Keys.ACTIVITY_COMMENTS_KEY] except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None # # Activity photo management methods # def create_activity_photo(self, user_id, activity_id, photo_hash): """Create method for an activity photo.""" if user_id is None: self.log_error(MongoDatabase.create_activity_photo.__name__ + ": Unexpected empty object: user_id") return False if activity_id is None: self.log_error(MongoDatabase.create_activity_photo.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.create_activity_photo.__name__ + ": Invalid object: activity_id") return False if photo_hash is None: self.log_error(MongoDatabase.create_activity_photo.__name__ + ": Unexpected empty object: photo_hash") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found. if activity is not None: # Append the hash of the photo to the photos list. photos = [] if Keys.ACTIVITY_PHOTOS_KEY in activity: photos = activity[Keys.ACTIVITY_PHOTOS_KEY] photos.append(photo_hash) # Remove duplicates. photos = list(dict.fromkeys(photos)) # Save the updated activity. activity[Keys.ACTIVITY_PHOTOS_KEY] = photos self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def list_activity_photos(self, activity_id): """Lists all photos associated with an activity. Response is a list of identifiers.""" if activity_id is None: self.log_error(MongoDatabase.list_activity_photos.__name__ + ": Unexpected empty object: activity_id") return [] if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.list_activity_photos.__name__ + ": Invalid object: activity_id") return [] try: # Things we don't need. exclude_keys = self.list_excluded_activity_keys_activity_lists() # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }, exclude_keys) # If the activity was found and contains comments. if activity is not None and Keys.ACTIVITY_PHOTOS_KEY in activity: return activity[Keys.ACTIVITY_PHOTOS_KEY] except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return [] def delete_activity_photo(self, activity_id, photo_id): """Deletes the specified tag from the activity with the given ID.""" if activity_id is None: self.log_error(MongoDatabase.delete_activity_photo.__name__ + ": Unexpected empty object: activity_id") return False if not InputChecker.is_uuid(activity_id): self.log_error(MongoDatabase.delete_activity_photo.__name__ + ": Invalid object: activity_id") return False if photo_id is None: self.log_error(MongoDatabase.delete_activity_photo.__name__ + ": Unexpected empty object: photo_id") return False try: # Find the activity. activity = self.activities_collection.find_one({ Keys.ACTIVITY_ID_KEY: activity_id }) # If the activity was found. if activity is not None and Keys.ACTIVITY_PHOTOS_KEY in activity: photos = activity[Keys.ACTIVITY_PHOTOS_KEY] photos.remove(photo_id) activity[Keys.ACTIVITY_PHOTOS_KEY] = photos self.activities_collection.save(activity) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False # # Planned workout management methods # def create_workout(self, user_id, workout_obj): """Create method for a workout.""" if user_id is None: self.log_error(MongoDatabase.create_workout.__name__ + ": Unexpected empty object: user_id") return False if workout_obj is None: self.log_error(MongoDatabase.create_workout.__name__ + ": Unexpected empty object: workout_obj") return False try: # Find the user's workouts document. workouts_doc = self.workouts_collection.find_one({ Keys.WORKOUT_PLAN_USER_ID_KEY: user_id }) # If the workouts document was not found then create it. if workouts_doc is None: post = {} post[Keys.WORKOUT_PLAN_USER_ID_KEY] = user_id post[Keys.WORKOUT_PLAN_CALENDAR_ID_KEY] = str(uuid.uuid4()) # Create a calendar ID post[Keys.WORKOUT_LIST_KEY] = [] self.workouts_collection.insert(post) workouts_doc = self.workouts_collection.find_one({ Keys.WORKOUT_PLAN_USER_ID_KEY: user_id }) # If the workouts document was found (or created). if workouts_doc is not None and Keys.WORKOUT_LIST_KEY in workouts_doc: # Make sure we have a calendar ID. if Keys.WORKOUT_PLAN_CALENDAR_ID_KEY not in workouts_doc: workouts_doc[Keys.WORKOUT_PLAN_CALENDAR_ID_KEY] = str(uuid.uuid4()) # Create a calendar ID # Make sure this workout isn't already in the list. last_scheduled_workout = 0 workouts_list = workouts_doc[Keys.WORKOUT_LIST_KEY] for workout in workouts_list: if Keys.WORKOUT_ID_KEY in workout and workout[Keys.WORKOUT_ID_KEY] == workout_obj.workout_id: return False if Keys.WORKOUT_SCHEDULED_TIME_KEY in workout and workout[Keys.WORKOUT_SCHEDULED_TIME_KEY] > last_scheduled_workout: last_scheduled_workout = workout[Keys.WORKOUT_SCHEDULED_TIME_KEY] # Add the workout to the list. workout = workout_obj.to_dict() workouts_list.append(workout) # Update and save the document. workouts_doc[Keys.WORKOUT_LIST_KEY] = workouts_list workouts_doc[Keys.WORKOUT_LAST_SCHEDULED_WORKOUT_TIME_KEY] = last_scheduled_workout self.workouts_collection.save(workouts_doc) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_planned_workout(self, user_id, workout_id): """Retrieve method for the workout with the specified user and ID.""" if user_id is None: self.log_error(MongoDatabase.retrieve_planned_workout.__name__ + ": Unexpected empty object: user_id") return None if workout_id is None: self.log_error(MongoDatabase.retrieve_planned_workout.__name__ + ": Unexpected empty object: workout_id") return None try: # Find the user's workouts document. workouts_doc = self.workouts_collection.find_one({ Keys.WORKOUT_PLAN_USER_ID_KEY: user_id }) # If the workouts document was found. if workouts_doc is not None and Keys.WORKOUT_LIST_KEY in workouts_doc: workouts_list = workouts_doc[Keys.WORKOUT_LIST_KEY] # Find the workout in the list. for workout in workouts_list: if Keys.WORKOUT_ID_KEY in workout and str(workout[Keys.WORKOUT_ID_KEY]) == workout_id: workout_obj = Workout.Workout(user_id) workout_obj.from_dict(workout) return workout_obj except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None def retrieve_planned_workouts_for_user(self, user_id, start_time, end_time): """Retrieve method for the ical calendar ID for with specified ID.""" if user_id is None: self.log_error(MongoDatabase.retrieve_planned_workouts_for_user.__name__ + ": Unexpected empty object: user_id") return None workouts = [] try: # Find the user's workouts document. workouts_doc = self.workouts_collection.find_one({ Keys.WORKOUT_PLAN_USER_ID_KEY: user_id }) # If the workouts document was found. if workouts_doc is not None and Keys.WORKOUT_LIST_KEY in workouts_doc: workouts_list = workouts_doc[Keys.WORKOUT_LIST_KEY] # Create an object for each workout in the list. for workout in workouts_list: workout_obj = Workout.Workout(user_id) workout_obj.from_dict(workout) scheduled_time = int(time.mktime(workout_obj.scheduled_time.timetuple())) if (start_time is None or start_time == 0 or scheduled_time > start_time) and (end_time is None or end_time == 0 or scheduled_time <= end_time): workouts.append(workout_obj) except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return workouts def retrieve_workouts_calendar_id_for_user(self, user_id): """Retrieve method for all workouts pertaining to the user with the specified ID.""" if user_id is None: self.log_error(MongoDatabase.retrieve_workouts_calendar_id_for_user.__name__ + ": Unexpected empty object: user_id") return None try: # Find the user's workouts document. workouts_doc = self.workouts_collection.find_one({ Keys.WORKOUT_PLAN_USER_ID_KEY: user_id }) # If the workouts document was found and it has a calendar ID. if workouts_doc is not None and Keys.WORKOUT_PLAN_CALENDAR_ID_KEY in workouts_doc: return workouts_doc[Keys.WORKOUT_PLAN_CALENDAR_ID_KEY] except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return None def retrieve_workouts_by_calendar_id(self, calendar_id): """Retrieve method for all workouts pertaining to the user with the specified ID.""" if calendar_id is None: self.log_error(MongoDatabase.retrieve_workouts_by_calendar_id.__name__ + ": Unexpected empty object: calendar_id") return None workouts = [] try: # Find the user's document with the specified calendar ID. workouts_doc = self.workouts_collection.find_one({ Keys.WORKOUT_PLAN_CALENDAR_ID_KEY: calendar_id }) # If the workouts document was found then return the workouts list. if workouts_doc is not None and Keys.WORKOUT_LIST_KEY in workouts_doc and Keys.WORKOUT_PLAN_USER_ID_KEY in workouts_doc: workouts_list = workouts_doc[Keys.WORKOUT_LIST_KEY] # Create an object for each workout in the list. for workout in workouts_list: workout_obj = Workout.Workout(workouts_doc[Keys.WORKOUT_PLAN_USER_ID_KEY]) workout_obj.from_dict(workout) workouts.append(workout_obj) except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return workouts def update_workouts_for_user(self, user_id, workout_objs): """Update method for a list of workout objects.""" if user_id is None: self.log_error(MongoDatabase.update_workouts_for_user.__name__ + ": Unexpected empty object: user_id") return False if workout_objs is None: self.log_error(MongoDatabase.update_workouts_for_user.__name__ + ": Unexpected empty object: workout_objs") return False try: # Find the user's workouts document. workouts_doc = self.workouts_collection.find_one({ Keys.WORKOUT_PLAN_USER_ID_KEY: user_id }) # If the workouts document was not found then create it. if workouts_doc is None: post = {} post[Keys.WORKOUT_PLAN_USER_ID_KEY] = user_id post[Keys.WORKOUT_LIST_KEY] = [] self.workouts_collection.insert(post) workouts_doc = self.workouts_collection.find_one({ Keys.WORKOUT_PLAN_USER_ID_KEY: user_id }) # If the workouts document was found (or created). if workouts_doc is not None and Keys.WORKOUT_LIST_KEY in workouts_doc: # Update and save the document. workouts_doc[Keys.WORKOUT_LIST_KEY] = [] for workout_obj in workout_objs: workouts_doc[Keys.WORKOUT_LIST_KEY].append(workout_obj.to_dict()) self.workouts_collection.save(workouts_doc) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_users_without_scheduled_workouts(self): """Returns a list of user IDs for users who have workout plans that need to be re-run.""" try: user_ids = [] workout_docs = self.workouts_collection.find({ Keys.WORKOUT_LAST_SCHEDULED_WORKOUT_TIME_KEY: { "$lt": time.time() } }) for workout_doc in workout_docs: if Keys.WORKOUT_PLAN_USER_ID_KEY in workout_doc: user_id = workout_doc[Keys.WORKOUT_PLAN_USER_ID_KEY] user_ids.append(user_id) except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return user_ids # # Gear default management methods # def retrieve_gear_defaults(self, user_id): """Retrieve method for the gear with the specified ID.""" if user_id is None: self.log_error(MongoDatabase.retrieve_gear_defaults.__name__ + ": Unexpected empty object: user_id") return None try: # Find the user's document. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user's document was found. if user is not None: # Read the gear list. gear_defaults_list = [] if Keys.GEAR_DEFAULTS_KEY in user: gear_defaults_list = user[Keys.GEAR_DEFAULTS_KEY] return gear_defaults_list except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return [] def update_gear_defaults(self, user_id, activity_type, gear_name): """Retrieve method for the gear with the specified ID.""" if user_id is None: self.log_error(MongoDatabase.update_gear_defaults.__name__ + ": Unexpected empty object: user_id") return False if activity_type is None: self.log_error(MongoDatabase.update_gear_defaults.__name__ + ": Unexpected empty object: activity_type") return False if gear_name is None: self.log_error(MongoDatabase.update_gear_defaults.__name__ + ": Unexpected empty object: gear_name") return False try: # Find the user's document. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user's document was found. if user is not None: # Update the gear list. gear_defaults_list = [] # Remove any old items that are no longer relevant. if Keys.GEAR_DEFAULTS_KEY in user: gear_defaults_list = user[Keys.GEAR_DEFAULTS_KEY] gear_index = 0 for gear in gear_defaults_list: if Keys.ACTIVITY_TYPE_KEY in gear and gear[Keys.ACTIVITY_TYPE_KEY] == activity_type: gear_defaults_list.pop(gear_index) gear_index = gear_index + 1 # Add the new item. gear = {} gear[Keys.ACTIVITY_TYPE_KEY] = activity_type gear[Keys.GEAR_NAME_KEY] = gear_name gear_defaults_list.append(gear) user[Keys.GEAR_DEFAULTS_KEY] = gear_defaults_list self.users_collection.save(user) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False # # Gear management methods # def create_gear(self, user_id, gear_id, gear_type, gear_name, gear_description, gear_add_time, gear_retire_time): """Create method for gear.""" if user_id is None: self.log_error(MongoDatabase.create_gear.__name__ + ": Unexpected empty object: user_id") return False if gear_id is None: self.log_error(MongoDatabase.create_gear.__name__ + ": Unexpected empty object: gear_id") return False if gear_type is None: self.log_error(MongoDatabase.create_gear.__name__ + ": Unexpected empty object: gear_type") return False if gear_name is None: self.log_error(MongoDatabase.create_gear.__name__ + ": Unexpected empty object: gear_name") return False try: # Find the user's document. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user's document was found. if user is not None: # Find the gear list. gear_list = [] if Keys.GEAR_KEY in user: gear_list = user[Keys.GEAR_KEY] # Make sure we don't already have an item with this ID. for gear in gear_list: if Keys.GEAR_ID_KEY in gear and gear[Keys.GEAR_ID_KEY] == str(gear_id): return False # Update the gear list. new_gear = {} new_gear[Keys.GEAR_ID_KEY] = str(gear_id) new_gear[Keys.GEAR_TYPE_KEY] = gear_type new_gear[Keys.GEAR_NAME_KEY] = gear_name new_gear[Keys.GEAR_DESCRIPTION_KEY] = gear_description new_gear[Keys.GEAR_ADD_TIME_KEY] = int(gear_add_time) new_gear[Keys.GEAR_RETIRE_TIME_KEY] = int(gear_retire_time) gear_list.append(new_gear) user[Keys.GEAR_KEY] = gear_list self.users_collection.save(user) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_gear(self, user_id): """Retrieve method for the gear with the specified ID.""" if user_id is None: self.log_error(MongoDatabase.retrieve_gear.__name__ + ": Unexpected empty object: user_id") return None try: # Find the user's document. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user's document was found. if user is not None: # Read the gear list. gear_list = [] if Keys.GEAR_KEY in user: gear_list = user[Keys.GEAR_KEY] return gear_list except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return [] def update_gear(self, user_id, gear_id, gear_type, gear_name, gear_description, gear_add_time, gear_retire_time): """Retrieve method for the gear with the specified ID.""" if user_id is None: self.log_error(MongoDatabase.update_gear.__name__ + ": Unexpected empty object: user_id") return False if gear_id is None: self.log_error(MongoDatabase.update_gear.__name__ + ": Unexpected empty object: gear_id") return False try: # Find the user's document. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user's document was found. if user is not None: # Update the gear list. gear_list = [] if Keys.GEAR_KEY in user: gear_list = user[Keys.GEAR_KEY] gear_index = 0 for gear in gear_list: if Keys.GEAR_ID_KEY in gear and gear[Keys.GEAR_ID_KEY] == str(gear_id): if gear_type is not None: gear[Keys.GEAR_TYPE_KEY] = gear_type if gear_name is not None: gear[Keys.GEAR_NAME_KEY] = gear_name if gear_description is not None: gear[Keys.GEAR_DESCRIPTION_KEY] = gear_description if gear_add_time is not None: gear[Keys.GEAR_ADD_TIME_KEY] = int(gear_add_time) if gear_retire_time is not None: gear[Keys.GEAR_RETIRE_TIME_KEY] = int(gear_retire_time) gear_list.pop(gear_index) gear_list.append(gear) user[Keys.GEAR_KEY] = gear_list self.users_collection.save(user) return True gear_index = gear_index + 1 except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def delete_gear(self, user_id, gear_id): """Delete method for the gear with the specified ID.""" if user_id is None: self.log_error(MongoDatabase.delete_gear.__name__ + ": Unexpected empty object: user_id") return False if gear_id is None: self.log_error(MongoDatabase.delete_gear.__name__ + ": Unexpected empty object: gear_id") return False try: # Find the user's document. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user's document was found. if user is not None: # Update the gear list. gear_list = [] if Keys.GEAR_KEY in user: gear_list = user[Keys.GEAR_KEY] gear_index = 0 for gear in gear_list: if Keys.GEAR_ID_KEY in gear and gear[Keys.GEAR_ID_KEY] == str(gear_id): gear_list.pop(gear_index) user[Keys.GEAR_KEY] = gear_list self.users_collection.save(user) return True gear_index = gear_index + 1 except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def delete_all_gear(self, user_id): """Delete method for the gear with the specified ID.""" if user_id is None: self.log_error(MongoDatabase.delete_gear.__name__ + ": Unexpected empty object: user_id") return False try: # Find the user's document. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user's document was found. if user is not None: # Update the gear list. if Keys.GEAR_KEY in user: user[Keys.GEAR_KEY] = [] self.users_collection.save(user) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def create_service_record(self, user_id, gear_id, service_record_id, record_date, record_description): """Create method for gear service records.""" if user_id is None: self.log_error(MongoDatabase.create_service_record.__name__ + ": Unexpected empty object: user_id") return False if gear_id is None: self.log_error(MongoDatabase.create_service_record.__name__ + ": Unexpected empty object: gear_id") return False if service_record_id is None: self.log_error(MongoDatabase.create_service_record.__name__ + ": Unexpected empty object: service_record_id") return False if record_date is None: self.log_error(MongoDatabase.create_service_record.__name__ + ": Unexpected empty object: record_date") return False if record_description is None: self.log_error(MongoDatabase.create_service_record.__name__ + ": Unexpected empty object: record_description") return False try: # Find the user's document. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user's document was found. if user is not None: # Find the gear list. gear_list = [] if Keys.GEAR_KEY in user: gear_list = user[Keys.GEAR_KEY] # Find the gear. for gear in gear_list: if Keys.GEAR_ID_KEY in gear and gear[Keys.GEAR_ID_KEY] == str(gear_id): service_rec = {} service_rec[Keys.SERVICE_RECORD_ID_KEY] = str(service_record_id) service_rec[Keys.SERVICE_RECORD_DATE_KEY] = int(record_date) service_rec[Keys.SERVICE_RECORD_DESCRIPTION_KEY] = record_description service_history = [] if Keys.GEAR_SERVICE_HISTORY in gear: service_history = gear[Keys.GEAR_SERVICE_HISTORY] service_history.append(service_rec) gear[Keys.GEAR_SERVICE_HISTORY] = service_history self.users_collection.save(user) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def delete_service_record(self, user_id, gear_id, service_record_id): """Delete method for the service record with the specified user and gear ID.""" if user_id is None: self.log_error(MongoDatabase.delete_service_record.__name__ + ": Unexpected empty object: user_id") return False if gear_id is None: self.log_error(MongoDatabase.delete_service_record.__name__ + ": Unexpected empty object: gear_id") return False if service_record_id is None: self.log_error(MongoDatabase.delete_service_record.__name__ + ": Unexpected empty object: service_record_id") return False try: # Find the user's document. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user's document was found. if user is not None: # Find the gear list. gear_list = [] if Keys.GEAR_KEY in user: gear_list = user[Keys.GEAR_KEY] # Find the gear. for gear in gear_list: if Keys.GEAR_ID_KEY in gear and gear[Keys.GEAR_ID_KEY] == str(gear_id): if Keys.GEAR_SERVICE_HISTORY in gear: service_history = gear[Keys.GEAR_SERVICE_HISTORY] record_index = 0 for service_record in service_history: if Keys.SERVICE_RECORD_ID_KEY in service_record and service_record[Keys.SERVICE_RECORD_ID_KEY] == service_record_id: service_history.pop(record_index) gear[Keys.GEAR_SERVICE_HISTORY] = service_history self.users_collection.save(user) return True record_index = record_index + 1 except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False # # Pace plan management methods # def create_pace_plan(self, user_id, plan_id, plan_name, target_pace_min_km, target_distance_kms, display_units_pace, display_units_distance, splits, last_updated_time): """Create method for a pace plan associated with the specified user.""" if user_id is None: self.log_error(MongoDatabase.create_pace_plan.__name__ + ": Unexpected empty object: user_id") return False if plan_id is None: self.log_error(MongoDatabase.create_pace_plan.__name__ + ": Unexpected empty object: plan_id") return False if plan_name is None: self.log_error(MongoDatabase.create_pace_plan.__name__ + ": Unexpected empty object: plan_name") return False if target_pace_min_km is None: self.log_error(MongoDatabase.create_pace_plan.__name__ + ": Unexpected empty object: target_pace_min_km") return False if target_distance_kms is None: self.log_error(MongoDatabase.create_pace_plan.__name__ + ": Unexpected empty object: target_distance_kms") return False if display_units_pace is None: self.log_error(MongoDatabase.create_pace_plan.__name__ + ": Unexpected empty object: display_units_pace") return False if display_units_distance is None: self.log_error(MongoDatabase.create_pace_plan.__name__ + ": Unexpected empty object: display_units_distance") return False if splits is None: self.log_error(MongoDatabase.create_pace_plan.__name__ + ": Unexpected empty object: splits") return False if last_updated_time is None: self.log_error(MongoDatabase.create_pace_plan.__name__ + ": Unexpected empty object: last_updated_time") return False try: # Find the user's document. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user's document was found. if user is not None: # Fidn the pace plans list. pace_plan_list = [] if Keys.PACE_PLANS_KEY in user: pace_plan_list = user[Keys.PACE_PLANS_KEY] # Make sure we don't already have a pace plan with this ID. for pace_plan in pace_plan_list: if Keys.PACE_PLAN_ID_KEY in pace_plan and pace_plan[Keys.PACE_PLAN_ID_KEY] == str(plan_id): return False # Update the pace plans list. new_pace_plan = {} new_pace_plan[Keys.PACE_PLAN_ID_KEY] = str(plan_id) new_pace_plan[Keys.PACE_PLAN_NAME_KEY] = plan_name new_pace_plan[Keys.PACE_PLAN_TARGET_PACE_KEY] = float(target_pace_min_km) new_pace_plan[Keys.PACE_PLAN_TARGET_DISTANCE_KEY] = float(target_distance_kms) new_pace_plan[Keys.PACE_PLAN_DISPLAY_UNITS_PACE_KEY] = int(float(display_units_pace)) new_pace_plan[Keys.PACE_PLAN_DISPLAY_UNITS_DISTANCE_KEY] = int(float(display_units_distance)) new_pace_plan[Keys.PACE_PLAN_SPLITS_KEY] = int(float(splits)) new_pace_plan[Keys.PACE_PLAN_LAST_UPDATED_KEY] = int(last_updated_time) pace_plan_list.append(new_pace_plan) user[Keys.PACE_PLANS_KEY] = pace_plan_list self.users_collection.save(user) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_pace_plans(self, user_id): """Retrieve method for pace plans associated with the specified user.""" if user_id is None: self.log_error(MongoDatabase.retrieve_pace_plan.__name__ + ": Unexpected empty object: user_id") return False try: # Find the user's document. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user's document was found. if user is not None: # Read the pace plans list. pace_plan_list = [] if Keys.PACE_PLANS_KEY in user: pace_plan_list = user[Keys.PACE_PLANS_KEY] return pace_plan_list except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return [] def update_pace_plan(self, user_id, plan_id, plan_name, target_pace_min_km, target_distance_kms, display_units_pace, display_units_distance, splits, last_updated_time): """Update method for a pace plan associated with the specified user.""" if user_id is None: self.log_error(MongoDatabase.update_pace_plan.__name__ + ": Unexpected empty object: user_id") return False if plan_id is None: self.log_error(MongoDatabase.update_pace_plan.__name__ + ": Unexpected empty object: plan_id") return False if plan_name is None: self.log_error(MongoDatabase.update_pace_plan.__name__ + ": Unexpected empty object: plan_name") return False if target_pace_min_km is None: self.log_error(MongoDatabase.update_pace_plan.__name__ + ": Unexpected empty object: target_pace_min_km") return False if target_distance_kms is None: self.log_error(MongoDatabase.update_pace_plan.__name__ + ": Unexpected empty object: target_pace_min_km") return False if display_units_pace is None: self.log_error(MongoDatabase.update_pace_plan.__name__ + ": Unexpected empty object: display_units_pace") return False if display_units_distance is None: self.log_error(MongoDatabase.update_pace_plan.__name__ + ": Unexpected empty object: display_units_distance") return False if splits is None: self.log_error(MongoDatabase.update_pace_plan.__name__ + ": Unexpected empty object: splits") return False if last_updated_time is None: self.log_error(MongoDatabase.create_pace_plan.__name__ + ": Unexpected empty object: last_updated_time") return False try: # Find the user's document. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user's document was found. if user is not None: # Update the pace plans list. pace_plan_list = [] if Keys.PACE_PLANS_KEY in user: pace_plan_list = user[Keys.PACE_PLANS_KEY] pace_plan_index = 0 for pace_plan in pace_plan_list: if Keys.PACE_PLAN_ID_KEY in pace_plan and pace_plan[Keys.PACE_PLAN_ID_KEY] == str(plan_id): pace_plan[Keys.PACE_PLAN_NAME_KEY] = plan_name pace_plan[Keys.PACE_PLAN_TARGET_PACE_KEY] = float(target_pace_min_km) pace_plan[Keys.PACE_PLAN_TARGET_DISTANCE_KEY] = float(target_distance_kms) pace_plan[Keys.PACE_PLAN_DISPLAY_UNITS_PACE_KEY] = int(float(display_units_pace)) pace_plan[Keys.PACE_PLAN_DISPLAY_UNITS_DISTANCE_KEY] = int(float(display_units_distance)) pace_plan[Keys.PACE_PLAN_SPLITS_KEY] = int(float(splits)) pace_plan[Keys.PACE_PLAN_LAST_UPDATED_KEY] = int(last_updated_time) pace_plan_list.pop(pace_plan_index) pace_plan_list.append(pace_plan) user[Keys.PACE_PLANS_KEY] = pace_plan_list self.users_collection.save(user) return True pace_plan_index = pace_plan_index + 1 except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def delete_pace_plan(self, user_id, pace_plan_id): """Delete method for a pace plan associated with the specified user.""" if user_id is None: self.log_error(MongoDatabase.delete_pace_plan.__name__ + ": Unexpected empty object: user_id") return False if pace_plan_id is None: self.log_error(MongoDatabase.update_pace_plan.__name__ + ": Unexpected empty object: pace_plan_id") return False try: # Find the user's document. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user's document was found. if user is not None: # Update the pace plans list. pace_plan_list = [] if Keys.PACE_PLANS_KEY in user: pace_plan_list = user[Keys.PACE_PLANS_KEY] pace_plan_index = 0 for pace_plan in pace_plan_list: if Keys.PACE_PLAN_ID_KEY in pace_plan and pace_plan[Keys.PACE_PLAN_ID_KEY] == str(pace_plan_id): pace_plan_list.pop(pace_plan_index) user[Keys.PACE_PLANS_KEY] = pace_plan_list self.users_collection.save(user) return True pace_plan_index = pace_plan_index + 1 except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False # # Deferred task management methods # def create_deferred_task(self, user_id, task_type, celery_task_id, internal_task_id, details, status): """Create method for tracking a deferred task, such as a file import or activity analysis.""" if user_id is None: self.log_error(MongoDatabase.create_deferred_task.__name__ + ": Unexpected empty object: user_id") return False if task_type is None: self.log_error(MongoDatabase.create_deferred_task.__name__ + ": Unexpected empty object: task_type") return False if celery_task_id is None: self.log_error(MongoDatabase.create_deferred_task.__name__ + ": Unexpected empty object: celery_task_id") return False if internal_task_id is None: self.log_error(MongoDatabase.create_deferred_task.__name__ + ": Unexpected empty object: internal_task_id") return False if status is None: self.log_error(MongoDatabase.create_deferred_task.__name__ + ": Unexpected empty object: status") return False try: # Make sure we're dealing with a string. user_id_str = str(user_id) # Find the user's tasks document. user_tasks = self.tasks_collection.find_one({ Keys.DEFERRED_TASKS_USER_ID: user_id_str }) # If the user's tasks document was not found then create it. if user_tasks is None: post = { Keys.DEFERRED_TASKS_USER_ID: user_id } self.tasks_collection.insert(post) user_tasks = self.tasks_collection.find_one({ Keys.DEFERRED_TASKS_USER_ID: user_id_str }) # If the user's tasks document was found. if user_tasks is not None: # Get the list of existing tasks. deferred_tasks = [] if Keys.TASKS_KEY in user_tasks: deferred_tasks = user_tasks[Keys.TASKS_KEY] # Create an entry for the new task. task = {} task[Keys.TASK_CELERY_ID_KEY] = str(celery_task_id) task[Keys.TASK_INTERNAL_ID_KEY] = str(internal_task_id) task[Keys.TASK_TYPE_KEY] = task_type task[Keys.TASK_DETAILS_KEY] = details task[Keys.TASK_STATUS_KEY] = status # Append it to the list. deferred_tasks.append(task) user_tasks[Keys.TASKS_KEY] = deferred_tasks # Update the database. self.tasks_collection.save(user_tasks) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_deferred_tasks(self, user_id): """Retrieve method for returning all the deferred tasks for a given user.""" if user_id is None: self.log_error(MongoDatabase.retrieve_deferred_tasks.__name__ + ": Unexpected empty object: user_id") return None try: # Make sure we're dealing with a string. user_id_str = str(user_id) # Find the user's tasks document. user_tasks = self.tasks_collection.find_one({ Keys.DEFERRED_TASKS_USER_ID: user_id_str }) # If the user's tasks document was found. if user_tasks is not None and Keys.TASKS_KEY in user_tasks: return user_tasks[Keys.TASKS_KEY] except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return [] def update_deferred_task(self, user_id, internal_task_id, activity_id, status): """Updated method for deferred task status.""" if user_id is None: self.log_error(MongoDatabase.update_deferred_task.__name__ + ": Unexpected empty object: user_id") return False if internal_task_id is None: self.log_error(MongoDatabase.update_deferred_task.__name__ + ": Unexpected empty object: internal_task_id") return False if status is None: self.log_error(MongoDatabase.update_deferred_task.__name__ + ": Unexpected empty object: status") return False try: # Make sure we're dealing with strings. user_id_str = str(user_id) internal_task_id_str = str(internal_task_id) # Find the user's tasks document. user_tasks = self.tasks_collection.find_one({ Keys.DEFERRED_TASKS_USER_ID: user_id_str }) # If the user's tasks document was found. if user_tasks is not None and Keys.TASKS_KEY in user_tasks: # Find and update the record. for task in user_tasks[Keys.TASKS_KEY]: if Keys.TASK_INTERNAL_ID_KEY in task and task[Keys.TASK_INTERNAL_ID_KEY] == internal_task_id_str: task[Keys.TASK_ACTIVITY_ID_KEY] = activity_id task[Keys.TASK_STATUS_KEY] = status break # Update the database. self.tasks_collection.save(user_tasks) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def delete_finished_deferred_tasks(self): """Delete method for removing deferred tasks that are completed.""" try: # Find the user's tasks document. user_tasks_list = self.tasks_collection.find({}) # For each user's task lists. for user_tasks in user_tasks_list: if Keys.TASKS_KEY in user_tasks: # Find and update the record. new_list = [] for task in user_tasks[Keys.TASKS_KEY]: if task[Keys.TASK_STATUS_KEY] != Keys.TASK_STATUS_FINISHED: new_list.append(task) user_tasks[Keys.TASKS_KEY] = new_list # Update the database. self.tasks_collection.save(user_tasks) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def create_uploaded_file(self, activity_id, file_data): """Create method for an uploaded activity file.""" if activity_id is None: self.log_error(MongoDatabase.create_uploaded_file.__name__ + ": Unexpected empty object: activity_id") return False if file_data is None: self.log_error(MongoDatabase.create_uploaded_file.__name__ + ": Unexpected empty object: file_data") return False try: if sys.version_info[0] < 3: post = { Keys.ACTIVITY_ID_KEY: activity_id, Keys.UPLOADED_FILE_DATA_KEY: Binary(file_data) } else: post = { Keys.ACTIVITY_ID_KEY: activity_id, Keys.UPLOADED_FILE_DATA_KEY: bytes(file_data) } self.uploads_collection.insert(post) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def delete_uploaded_file(self, activity_id): """Delete method for an uploaded file associated with an activity.""" if activity_id is None: self.log_error(MongoDatabase.delete_uploaded_file.__name__ + ": Unexpected empty object: activity_id") return False try: deleted_result = self.uploads_collection.delete_one({ Keys.ACTIVITY_ID_KEY: str(activity_id) }) if deleted_result is not None: return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False # # API key management methods # def create_api_key(self, user_id, key, rate): """Create method for an API key.""" if user_id is None: self.log_error(MongoDatabase.create_api_key.__name__ + ": Unexpected empty object: user_id") return False if key is None: self.log_error(MongoDatabase.create_api_key.__name__ + ": Unexpected empty object: key") return False if rate is None: self.log_error(MongoDatabase.create_api_key.__name__ + ": Unexpected empty object: rate") return False try: # Find the user. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user was found. if user is not None: key_list = [] if Keys.API_KEYS in user: key_list = user[Keys.API_KEYS] key_dict = { Keys.API_KEY: str(key), Keys.API_KEY_RATE: int(rate) } key_list.append(key_dict) user[Keys.API_KEYS] = key_list self.users_collection.save(user) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False def retrieve_api_keys(self, user_id): """Retrieve method for API keys.""" if user_id is None: self.log_error(MongoDatabase.retrieve_api_keys.__name__ + ": Unexpected empty object: user_id") return None try: # Find the user. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj}, { Keys.API_KEYS: 1 }) # If the user was found. if user is not None and Keys.API_KEYS in user: return user[Keys.API_KEYS] return [] except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return [] def delete_api_key(self, user_id, key): """Delete method for an API key.""" if user_id is None: self.log_error(MongoDatabase.delete_api_key.__name__ + ": Unexpected empty object: user_id") return False if key is None: self.log_error(MongoDatabase.delete_api_key.__name__ + ": Unexpected empty object: key") return False try: # Find the user. user_id_obj = ObjectId(str(user_id)) user = self.users_collection.find_one({ Keys.DATABASE_ID_KEY: user_id_obj }) # If the user was found. if user is not None and Keys.API_KEYS in user: # Make sure we're dealing with a string. key_str = str(key) key_list = user[Keys.API_KEYS] for item in key_list: if item[Keys.API_KEY] == key_str: key_list.remove(item) break user[Keys.API_KEYS] = key_list self.users_collection.save(user) return True except: self.log_error(traceback.format_exc()) self.log_error(sys.exc_info()[0]) return False
45.031351
281
0.615444
16,796
139,327
4.785068
0.031496
0.037278
0.063904
0.074344
0.851761
0.815242
0.784298
0.755842
0.730559
0.707391
0
0.002084
0.311088
139,327
3,093
282
45.04591
0.835243
0.114895
0
0.669492
0
0
0.068796
0.00036
0
0
0
0
0
1
0.045941
false
0.00446
0.006244
0
0.252899
0
0
0
0
null
0
0
0
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
976fc30ffc8fc3771f270d96bc8eaf0871a14ee4
21,311
py
Python
v1/api/statbotics/main.py
avgupta456/statbotics
8847cec161104ec54f4c501653cd4ec558d30379
[ "MIT" ]
14
2020-05-28T21:54:45.000Z
2022-03-17T19:39:23.000Z
v1/api/statbotics/main.py
avgupta456/statbotics
8847cec161104ec54f4c501653cd4ec558d30379
[ "MIT" ]
59
2020-05-28T21:39:45.000Z
2022-03-25T23:51:39.000Z
api/statbotics/main.py
statbotics/statbotics
37bb0e3730d5b3aff7b6a5ba6e78ef2eada950bc
[ "MIT" ]
1
2020-07-04T07:30:40.000Z
2020-07-04T07:30:40.000Z
import datetime import requests from cachecontrol import CacheControl from . import validate class Statbotics: """ Main Object for interfacing with the Statbotics API """ def __init__(self): self.BASE_URL = "https://api.statbotics.io" self.session = CacheControl(requests.Session()) self.login(self.get_token()) self.token = self.get_token() def get_token(self, retries=0): if retries > 2: raise UserWarning("Could not connect to Statbotics.io") self.session.get(self.BASE_URL + "/admin/") if "csrftoken" not in self.session.cookies: return self.getToken(retries + 1) return self.session.cookies["csrftoken"] def login(self, token): login_data = {"csrfmiddlewaretoken": token, "next": self.BASE_URL + "/admin/"} self.session.post( self.BASE_URL + "/admin/login/", data=login_data, headers=dict(Referer=self.BASE_URL), ) def _filter(self, data, fields): if fields == ["all"]: return data for field in fields: if field not in data[0]: raise ValueError("Invalid field: " + str(field)) out = [] for entry in data: new_entry = {} for field in fields: new_entry[field] = entry[field] out.append(new_entry) return out def _get(self, url, fields, retry=0): resp = self.session.get(self.BASE_URL + url) if resp.status_code != 200: if retry < 2: return self._get(url, fields, retry=retry + 1) raise UserWarning("Invalid query: " + url) data = resp.json() if "results" in data: data = data["results"] if len(data) == 0: raise UserWarning("Invalid inputs, no data recieved for " + url) return self._filter(data, fields) def _negate(self, string): if len(string) == 0: return string if string[0] == "-": return string[1:] return "-" + string def get_team(self, team, fields=["all"]): """ Function to retrieve information on an individual team\n :param team: Team Number, integer\n :param fields: List of fields to return. The default is ["all"]\n :return: a dictionary with the team's number, location (country, state, district), and Elo statistics (Current Elo, Recent Elo, Mean Elo, Max Elo)\n """ validate.check_type(team, "int", "team") validate.check_type(fields, "list", "fields") return self._get("/v1/_teams?team=" + str(team), fields)[0] def get_teams( self, country=None, state=None, district=None, active=True, metric=None, limit=1000, offset=0, fields=["all"], ): """ Function to retrieve information on multiple teams\n :param country: Restrict based on country (select countries included)\n :param state: US States and Canada provinces only. Can infer country.\n :param district: Use 2 or 3-letter key (ex: FIM, NE, etc)\n :param active: Restrict to active teams (played most recent season)\n :param metric: Order output. Default descending, add '-' for ascending. (Ex: "-elo", "team", etc)\n :param limit: Limits the output length to speed up queries. Max 10,000\n :param offset: Skips the first (offset) items when returning\n :param fields: List of fields to return. Default is ["all"]\n :return: A list of dictionaries, each dictionary including the team, location, and Elo statistics\n """ url = "/v1/_teams?" validate.check_type(metric, "str", "metric") validate.check_type(limit, "int", "limit") validate.check_type(offset, "int", "offset") validate.check_type(fields, "list", "fields") if limit > 10000: raise ValueError( "Please reduce 'limit', consider breaking into multiple smaller queries" ) url += "limit=" + str(limit) + "&offset=" + str(offset) url += validate.get_locations(country, state, district) if active: url += "&active=1" if metric: if metric not in validate.get_team_metrics(): raise ValueError("Invalid metric") url += "&o=" + self._negate(metric) return self._get(url, fields) def get_year(self, year, fields=["all"]): """ Function to retrieve information for a specific year\n :param year: Year, integer\n :param fields: List of fields to return. The default is ["all"]\n :return: a dictionary with the year, match prediction statistics, and RP prediction statistics\n """ validate.check_type(year, "int", "year") validate.check_type(fields, "list", "fields") return self._get("/v1/_years?year=" + str(year), fields)[0] def get_years(self, metric=None, limit=1000, offset=0, fields=["all"]): """ Function to retrieve information on multiple years\n :param metric: Order output. Default descending, add '-' for ascending. (Ex: "elo_acc", "-opr_mse", etc)\n :param limit: Limits the output length to speed up queries. Max 10,000\n :param offset: Skips the first (offset) items when returning\n :param fields: List of fields to return. Default is ["all"]\n :return: A list of dictionaries, each dictionary including the year and match/RP prediction statistics\n """ validate.check_type(metric, "str", "metric") validate.check_type(limit, "int", "limit") validate.check_type(offset, "int", "offset") validate.check_type(fields, "list", "fields") url = "/v1/_years?limit=" + str(limit) + "&offset=" + str(offset) if metric: url += "&o=" + self._negate(metric) return self._get(url, fields) def get_team_year(self, team, year, fields=["all"]): """ Function to retrieve information for a specific team's performance in a specific year\n :param team: Team number, integer\n :param year: Year, integer\n :param fields: List of fields to return. The default is ["all"]\n :return: a dictionary with the team, year, and Elo/OPR statistics\n """ validate.check_type(team, "int", "team") validate.check_type(year, "int", "year") validate.check_type(fields, "list", "fields") url = "/v1/_team_years?team=" + str(team) + "&year=" + str(year) return self._get(url, fields)[0] def get_team_years( self, team=None, year=None, country=None, state=None, district=None, metric=None, limit=1000, offset=0, fields=["all"], ): """ Function to retrieve information on multiple (team, year) pairs\n :param team: Restrict based on a specific team number\n :param country: Restrict based on country (select countries included)\n :param state: US States and Canada provinces only. Can infer country.\n :param district: Use 2 or 3-letter key (ex: FIM, NE, etc)\n :param metric: Order output. Default descending, add '-' for ascending. (Ex: "elo_pre_champs", "-opr_auto", etc)\n :param limit: Limits the output length to speed up queries. Max 10,000\n :param offset: Skips the first (offset) items when returning\n :param fields: List of fields to return. Default is ["all"]\n :return: A list of dictionaries, each dictionary including the team, year, and OPR/Elo statistics\n """ url = "/v1/_team_years" validate.check_type(team, "int", "team") validate.check_type(year, "int", "year") validate.check_type(metric, "str", "metric") validate.check_type(limit, "int", "limit") validate.check_type(offset, "int", "offset") validate.check_type(fields, "list", "fields") if limit > 10000: raise ValueError( "Please reduce 'limit', consider breaking into multiple smaller queries" ) url += "?limit=" + str(limit) + "&offset=" + str(offset) if team and year: raise UserWarning("Use get_team_year() instead") if team and (country or state or district): raise UserWarning("Conflicting location input") if team: url += "&team=" + str(team) if year: url += "&year=" + str(year) url += validate.get_locations(country, state, district) if metric: if metric not in validate.get_team_year_metrics(): raise ValueError("Invalid metric") url += "&o=" + self._negate(metric) return self._get(url, fields) def get_event(self, event, fields=["all"]): """ Function to retrieve information for a specific event\n :param event: Event key, string (ex: "2019cur")\n :param fields: List of fields to return. The default is ["all"]\n :return: a dictionary with the event and Elo/OPR statistics\n """ validate.check_type(event, "str", "event") validate.check_type(fields, "list", "fields") url = "/v1/_events?key=" + event return self._get(url, fields)[0] def get_events( self, year=None, country=None, state=None, district=None, type=None, week=None, metric=None, limit=1000, offset=0, fields=["all"], ): """ Function to retrieve information on multiple events\n :param year: Restrict by specific year, integer\n :param country: Restrict based on country (select countries included)\n :param state: US States and Canada provinces only. Can infer country.\n :param district: Use 2 or 3-letter key (ex: FIM, NE, etc)\n :param type: 0=regional, 1=district, 2=district champ, 3=champs, 4=einstein\n :param week: Week of play, generally between 0 and 8\n :param metric: Order output. Default descending, add '-' for ascending. (Ex: "elo_pre_playoffs", "-opr_end", etc)\n :param limit: Limits the output length to speed up queries. Max 10,000\n :param offset: Skips the first (offset) items when returning\n :param fields: List of fields to return. Default is ["all"]\n :return: A list of dictionaries, each dictionary including the team, event and Elo/OPR statistics\n """ url = "/v1/_events" validate.check_type(year, "int", "year") validate.check_type(metric, "str", "metric") type = validate.get_type(type) validate.check_type(week, "int", "week") validate.check_type(limit, "int", "limit") validate.check_type(offset, "int", "offset") validate.check_type(fields, "list", "fields") if limit > 10000: raise ValueError( "Please reduce 'limit', consider breaking into multiple smaller queries" ) url += "?limit=" + str(limit) + "&offset=" + str(offset) if year: url += "&year=" + str(year) url += validate.get_locations(country, state, district) if type is not None: url += "&type=" + str(type) if week is not None: url += "&week=" + str(week) if metric: if metric not in validate.get_event_metrics(): raise ValueError("Invalid metric") url += "&o=" + self._negate(metric) return self._get(url, fields) def get_team_event(self, team, event, fields=["all"]): """ Function to retrieve information for a specific (team, event) pair\n :param team: Team number, integer\n :param event: Event key, string (ex: "2019cur")\n :param fields: List of fields to return. The default is ["all"]\n :return: a dictionary with the event and Elo/OPR statistics\n """ validate.check_type(team, "int", "team") validate.check_type(event, "str", "event") validate.check_type(fields, "list", "fields") url = "/v1/_team_events?team=" + str(team) + "&event=" + event return self._get(url, fields)[0] def get_team_events( self, team=None, year=None, event=None, country=None, state=None, district=None, type=None, week=None, metric=None, limit=1000, offset=0, fields=["all"], ): """ Function to retrieve information on multiple (team, event) pairs\n :param team: Restrict by team number, integer\n :param year: Restrict by specific year, integer\n :param country: Restrict based on country (select countries included)\n :param state: US States and Canada provinces only. Can infer country.\n :param district: Use 2 or 3-letter key (ex: FIM, NE, etc)\n :param type: 0=regional, 1=district, 2=district champ, 3=champs, 4=einstein\n :param week: Week of play, generally between 0 and 8\n :param metric: Order output. Default descending, add '-' for ascending. (Ex: "elo_pre_playoffs", "-opr_end", etc)\n :param limit: Limits the output length to speed up queries. Max 10,000\n :param offset: Skips the first (offset) items when returning\n :param fields: List of fields to return. Default is ["all"]\n :return: A list of dictionaries, each dictionary including the team, event and Elo/OPR statistics\n """ url = "/v1/_team_events" validate.check_type(team, "int", "team") validate.check_type(event, "str", "event") type = validate.get_type(type) validate.check_type(week, "int", "week") validate.check_type(metric, "str", "metric") validate.check_type(limit, "int", "limit") validate.check_type(offset, "int", "offset") validate.check_type(fields, "list", "fields") if limit > 10000: raise ValueError( "Please reduce 'limit', consider breaking into multiple smaller queries" ) url += "?limit=" + str(limit) + "&offset=" + str(offset) if team and event: raise UserWarning("Use get_team_event() instead") if event and (year or type or week): raise UserWarning("Overconstrained query") if (team or event) and (country or state or district): raise UserWarning("Conflicting location input") if team: url += "&team=" + str(team) if year: url += "&year=" + str(year) if event: url += "&event=" + event url += validate.get_locations(country, state, district) if type is not None: url += "&type=" + str(type) if week is not None: url += "&week=" + str(week) if metric: if metric not in validate.get_team_event_metrics(): raise ValueError("Invalid metric") url += "&o=" + self._negate(metric) return self._get(url, fields) def get_match(self, match, fields=["all"]): """ Function to retrieve information for a specific match\n :param match: Match key, string (ex: "2019cur_qm1", "2019cmptx_f1m3")\n :param fields: List of fields to return. The default is ["all"]\n :return: a dictionary with the match, score breakdowns, and predictions\n """ validate.check_type(match, "str", "match") validate.check_type(fields, "list", "fields") return self._get("/v1/_matches?key=" + match, fields)[0] def get_matches( self, year=None, event=None, elims=None, limit=1000, offset=0, fields=["all"] ): """ Function to retrieve information on multiple matches\n :param year: Restrict by specific year, integer\n :param event: Restrict by specific event key, string\n :param elims: Restrict to only elimination matches, default False\n :param limit: Limits the output length to speed up queries. Max 10,000\n :param offset: Skips the first (offset) items when returning\n :param fields: List of fields to return. Default is ["all"]\n :return: A list of dictionaries, each dictionary including the match, score breakdowns, and predictions\n """ url = "/v1/_matches" validate.check_type(year, "int", "year") validate.check_type(event, "str", "event") validate.check_type(elims, "bool", "elims") validate.check_type(limit, "int", "limit") validate.check_type(offset, "int", "offset") validate.check_type(fields, "list", "fields") if limit > 10000: raise ValueError( "Please reduce 'limit', consider breaking into multiple smaller queries" ) url += "?limit=" + str(limit) + "&offset=" + str(offset) if not event: raise UserWarning("Query too large, be more specific (event)") if year and event: raise UserWarning("Year input will be ignored") if year: url += "&year=" + str(year) if event: url += "&event=" + event if elims: url += "&playoff=1" url += "&o=time" return self._get(url, fields) def get_team_match(self, team, match, fields=["all"]): """ Function to retrieve information for a specific (team, match) pair\n :param team: Team number, integer\n :param match: Match key, string (ex: "2019cur_qm1", "2019cmptx_f1m3")\n :param fields: List of fields to return. The default is ["all"]\n :return: a dictionary with the team, match, alliance, and then elo\n """ validate.check_type(team, "int", "team") validate.check_type(match, "str", "match") validate.check_type(fields, "list", "fields") url = "/v1/_team_matches?team=" + str(team) + "&match=" + str(match) return self._get(url, fields)[0] def get_team_matches( self, team=None, year=None, event=None, match=None, elims=None, limit=1000, offset=0, fields=["all"], ): """ Function to retrieve information on multiple (team, match) pairs\n :param team: Restrict by team number, integer\n :param year: Restrict by specific year, integer\n :param event: Restrict by specific event key, string\n :param elims: Restrict to only elimination matches, default False\n :param limit: Limits the output length to speed up queries. Max 10,000\n :param offset: Skips the first (offset) items when returning\n :param fields: List of fields to return. Default is ["all"]\n :return: A list of dictionaries, each dictionary including the team, match, alliance, and then elo\n """ url = "/v1/_team_matches" validate.check_type(team, "int", "team") validate.check_type(year, "int", "year") validate.check_type(event, "str", "event") validate.check_type(match, "str", "match") validate.check_type(elims, "bool", "elims") validate.check_type(limit, "int", "limit") validate.check_type(offset, "int", "offset") validate.check_type(fields, "list", "fields") if limit > 10000: raise ValueError( "Please reduce 'limit', consider breaking into multiple smaller queries" ) url += "?limit=" + str(limit) + "&offset=" + str(offset) if not team and not event and not match: raise UserWarning( "Query too large, be more specific (team, event, or match)" ) if (year and event) or (year and match) or (event and match): raise UserWarning("Only specify one of (year, event, match)") if team: url += "&team=" + str(team) if year: url += "&year=" + str(year) if event: url += "&event=" + event if match: url += "&match=" + match if elims: url += "&playoff=1" url += "&o=time" return self._get(url, fields) def get_event_sim(self, event, index=None, full=False, iterations=None): validate.check_type(event, "str", "event") validate.check_type(index, "int", "index") validate.check_type(full, "bool", "full") validate.check_type(iterations, "int", "iterations") url = "/v1/event_sim/event/" + event if index: url += "/index/" + str(index) if full: url += "/full" if iterations: if iterations > 100: raise ValueError("Iterations must be <= 100") url += "/iterations/" + str(iterations) else: url += "/simple" return self._get(url, fields=["all"])
36.934142
156
0.58444
2,643
21,311
4.64283
0.089292
0.034716
0.085894
0.021677
0.800098
0.784288
0.777606
0.758047
0.735148
0.706136
0
0.013131
0.295997
21,311
576
157
36.998264
0.804772
0.31411
0
0.608187
0
0
0.158312
0.004894
0
0
0
0
0
1
0.061404
false
0
0.011696
0
0.146199
0
0
0
0
null
0
0
0
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
978789bc1d6bed55a57cc09abbb28c1c2dad01ec
21
py
Python
src/__init__.py
reticenceji/samplemod
77c90a9a72202687bbdf0ed3184e8f95f5557d7f
[ "BSD-2-Clause" ]
null
null
null
src/__init__.py
reticenceji/samplemod
77c90a9a72202687bbdf0ed3184e8f95f5557d7f
[ "BSD-2-Clause" ]
null
null
null
src/__init__.py
reticenceji/samplemod
77c90a9a72202687bbdf0ed3184e8f95f5557d7f
[ "BSD-2-Clause" ]
null
null
null
from .core import add
21
21
0.809524
4
21
4.25
1
0
0
0
0
0
0
0
0
0
0
0
0.142857
21
1
21
21
0.944444
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
979fae5d7e238b3a6dca17482d2db31170e6e3d9
1,803
py
Python
pysixdesk/lib/dbtypedict.py
michuschenk/pysixdesk
151c8bcff0625cfb1dbb78228a85a1e31809df01
[ "MIT" ]
3
2019-07-03T11:49:14.000Z
2020-03-03T05:49:38.000Z
pysixdesk/lib/dbtypedict.py
michuschenk/pysixdesk
151c8bcff0625cfb1dbb78228a85a1e31809df01
[ "MIT" ]
27
2019-03-04T17:51:21.000Z
2020-08-24T15:47:34.000Z
pysixdesk/lib/dbtypedict.py
michuschenk/pysixdesk
151c8bcff0625cfb1dbb78228a85a1e31809df01
[ "MIT" ]
4
2019-02-19T15:08:02.000Z
2019-07-02T12:20:33.000Z
def bigint_check(val): """ Checks to see if `val` is or contains BIGINTs. Args: val (int, float, list): value or list of values to check. Returns: bool: True if `val` contains one or more BIGINT, False if not. """ if not isinstance(val, list) or isinstance(val, str): val = [val] return any([(type(v) == int and v > 2147483647) for v in val]) class SQLiteDict(object): def __init__(self): self.db_type = {} self.db_type['NoneType'] = 'NULL' self.db_type['int'] = 'INT' self.db_type['float'] = 'DOUBLE' self.db_type['str'] = 'TEXT' self.db_type['bytes'] = 'BLOB' self.db_type['tuple'] = 'TEXT' def __getitem__(self, param): '''Get the corresponding sqlite data type''' if isinstance(param, list): param_0 = param[0] else: param_0 = param a = type(param_0) sql_type = self.db_type[a.__name__] if sql_type == 'INT' and bigint_check(param): return 'BIGINT' else: return sql_type class MySQLDict(object): def __init__(self): self.db_type = {} self.db_type['NoneType'] = 'NULL' self.db_type['int'] = 'INT' self.db_type['float'] = 'DOUBLE' self.db_type['str'] = 'TEXT' self.db_type['bytes'] = 'BLOB' self.db_type['tuple'] = 'TEXT' def __getitem__(self, param): '''Get the corresponding mysql data type''' if isinstance(param, list): param_0 = param[0] else: param_0 = param a = type(param_0) sql_type = self.db_type[a.__name__] if sql_type == 'INT' and bigint_check(param): return 'BIGINT' else: return sql_type
28.171875
70
0.547421
233
1,803
4
0.270386
0.103004
0.171674
0.060086
0.703863
0.703863
0.703863
0.703863
0.703863
0.703863
0
0.014718
0.321686
1,803
63
71
28.619048
0.747343
0.149196
0
0.863636
0
0
0.08445
0
0
0
0
0
0
1
0.113636
false
0
0
0
0.272727
0
0
0
0
null
0
0
0
0
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
97c52685e87be4d31f352727755d75a4494ea8f9
12,754
py
Python
tests/k8s/test_scanning.py
pshchelo/kopf
a94648d18b3d0dc84e8d15caf1fcab7a84f7fdb8
[ "MIT" ]
null
null
null
tests/k8s/test_scanning.py
pshchelo/kopf
a94648d18b3d0dc84e8d15caf1fcab7a84f7fdb8
[ "MIT" ]
null
null
null
tests/k8s/test_scanning.py
pshchelo/kopf
a94648d18b3d0dc84e8d15caf1fcab7a84f7fdb8
[ "MIT" ]
null
null
null
import aiohttp.web import pytest from kopf._cogs.clients.errors import APIError from kopf._cogs.clients.scanning import scan_resources async def test_no_resources_in_empty_apis( resp_mocker, aresponses, hostname): core_mock = resp_mocker(return_value=aiohttp.web.json_response({'versions': []})) apis_mock = resp_mocker(return_value=aiohttp.web.json_response({'groups': []})) aresponses.add(hostname, '/api', 'get', core_mock) aresponses.add(hostname, '/apis', 'get', apis_mock) resources = await scan_resources() assert len(resources) == 0 assert core_mock.call_count == 1 assert apis_mock.call_count == 1 @pytest.mark.parametrize('namespaced', [True, False]) async def test_resources_in_old_apis( resp_mocker, aresponses, hostname, namespaced): core_mock = resp_mocker(return_value=aiohttp.web.json_response({'versions': ['v1']})) apis_mock = resp_mocker(return_value=aiohttp.web.json_response({'groups': []})) scan_mock = resp_mocker(return_value=aiohttp.web.json_response({'resources': [ { 'kind': 'kind1', 'name': 'plural1', 'singularName': 'singular1', 'namespaced': namespaced, 'categories': ['category1', 'category2'], 'shortNames': ['shortname1', 'shortname2'], 'verbs': ['verb1', 'verb2'], }, ]})) aresponses.add(hostname, '/api', 'get', core_mock) aresponses.add(hostname, '/apis', 'get', apis_mock) aresponses.add(hostname, '/api/v1', 'get', scan_mock) resources = await scan_resources() assert len(resources) == 1 resource1 = list(resources)[0] assert resource1.group == '' assert resource1.version == 'v1' assert resource1.kind == 'kind1' assert resource1.plural == 'plural1' assert resource1.singular == 'singular1' assert resource1.preferred == True assert resource1.namespaced == namespaced assert resource1.subresources == set() assert resource1.categories == {'category1', 'category2'} assert resource1.shortcuts == {'shortname1', 'shortname2'} assert resource1.verbs == {'verb1', 'verb2'} assert core_mock.call_count == 1 assert apis_mock.call_count == 1 assert scan_mock.call_count == 1 @pytest.mark.parametrize('namespaced', [True, False]) @pytest.mark.parametrize('preferred_version, expected_preferred', [ ('version1', True), ('versionX', False), ]) async def test_resources_in_new_apis( resp_mocker, aresponses, hostname, namespaced, preferred_version, expected_preferred): core_mock = resp_mocker(return_value=aiohttp.web.json_response({'versions': []})) apis_mock = resp_mocker(return_value=aiohttp.web.json_response({'groups': [ { 'name': 'group1', 'preferredVersion': {'version': preferred_version}, 'versions': [{'version': 'version1'}], }, ]})) g1v1_mock = resp_mocker(return_value=aiohttp.web.json_response({'resources': [ { 'kind': 'kind1', 'name': 'plural1', 'singularName': 'singular1', 'namespaced': namespaced, 'categories': ['category1', 'category2'], 'shortNames': ['shortname1', 'shortname2'], 'verbs': ['verb1', 'verb2'], }, ]})) aresponses.add(hostname, '/api', 'get', core_mock) aresponses.add(hostname, '/apis', 'get', apis_mock) aresponses.add(hostname, '/apis/group1/version1', 'get', g1v1_mock) resources = await scan_resources() assert len(resources) == 1 resource1 = list(resources)[0] assert resource1.group == 'group1' assert resource1.version == 'version1' assert resource1.kind == 'kind1' assert resource1.plural == 'plural1' assert resource1.singular == 'singular1' assert resource1.preferred == expected_preferred assert resource1.namespaced == namespaced assert resource1.subresources == set() assert resource1.categories == {'category1', 'category2'} assert resource1.shortcuts == {'shortname1', 'shortname2'} assert resource1.verbs == {'verb1', 'verb2'} assert core_mock.call_count == 1 assert apis_mock.call_count == 1 assert g1v1_mock.call_count == 1 async def test_subresources_in_old_apis( resp_mocker, aresponses, hostname): core_mock = resp_mocker(return_value=aiohttp.web.json_response({'versions': ['v1']})) apis_mock = resp_mocker(return_value=aiohttp.web.json_response({'groups': []})) v1v1_mock = resp_mocker(return_value=aiohttp.web.json_response({'resources': [ { 'kind': 'kind1', 'name': 'plural1', 'singularName': 'singular1', 'namespaced': True, 'categories': [], 'shortNames': [], 'verbs': [], }, { 'name': 'plural1/sub1', }, { 'name': 'plural1/sub2', }, { 'name': 'pluralX/sub3', }, ]})) aresponses.add(hostname, '/api', 'get', core_mock) aresponses.add(hostname, '/apis', 'get', apis_mock) aresponses.add(hostname, '/api/v1', 'get', v1v1_mock) resources = await scan_resources() assert len(resources) == 1 resource1 = list(resources)[0] assert resource1.subresources == {'sub1', 'sub2'} async def test_subresources_in_new_apis( resp_mocker, aresponses, hostname): core_mock = resp_mocker(return_value=aiohttp.web.json_response({'versions': []})) apis_mock = resp_mocker(return_value=aiohttp.web.json_response({'groups': [ { 'name': 'group1', 'preferredVersion': {'version': 'version1'}, 'versions': [{'version': 'version1'}], }, ]})) g1v1_mock = resp_mocker(return_value=aiohttp.web.json_response({'resources': [ { 'kind': 'kind1', 'name': 'plural1', 'singularName': 'singular1', 'namespaced': True, 'categories': [], 'shortNames': [], 'verbs': [], }, { 'name': 'plural1/sub1', }, { 'name': 'plural1/sub2', }, { 'name': 'pluralX/sub3', }, ]})) aresponses.add(hostname, '/api', 'get', core_mock) aresponses.add(hostname, '/apis', 'get', apis_mock) aresponses.add(hostname, '/apis/group1/version1', 'get', g1v1_mock) resources = await scan_resources() assert len(resources) == 1 resource1 = list(resources)[0] assert resource1.subresources == {'sub1', 'sub2'} @pytest.mark.parametrize('group_filter, exp_core, exp_apis, exp_crv1, exp_g1v1, exp_g2v1', [ pytest.param([''], 1, 0, 1, 0, 0, id='only-core'), pytest.param(['g1'], 0, 1, 0, 1, 0, id='only-g1'), pytest.param(['g2'], 0, 1, 0, 0, 1, id='only-g2'), pytest.param(['', 'g1'], 1, 1, 1, 1, 0, id='core-and-g1'), pytest.param(['', 'g2'], 1, 1, 1, 0, 1, id='core-and-g2'), pytest.param(['g1', 'g2'], 0, 1, 0, 1, 1, id='g1-and-g2'), pytest.param(['X'], 0, 1, 0, 0, 0, id='unexistent'), pytest.param([], 0, 0, 0, 0, 0, id='restrictive'), pytest.param(None, 1, 1, 1, 1, 1, id='unfiltered'), ]) async def test_group_filtering( resp_mocker, aresponses, hostname, group_filter, exp_core, exp_apis, exp_crv1, exp_g1v1, exp_g2v1): core_mock = resp_mocker(return_value=aiohttp.web.json_response({'versions': ['v1']})) apis_mock = resp_mocker(return_value=aiohttp.web.json_response({'groups': [ {'name': 'g1', 'preferredVersion': {'version': ''}, 'versions': [{'version': 'g1v1'}]}, {'name': 'g2', 'preferredVersion': {'version': ''}, 'versions': [{'version': 'g2v1'}]}, ]})) crv1_mock = resp_mocker(return_value=aiohttp.web.json_response({'resources': []})) g1v1_mock = resp_mocker(return_value=aiohttp.web.json_response({'resources': []})) g2v1_mock = resp_mocker(return_value=aiohttp.web.json_response({'resources': []})) aresponses.add(hostname, '/api', 'get', core_mock) aresponses.add(hostname, '/api/v1', 'get', crv1_mock) aresponses.add(hostname, '/apis', 'get', apis_mock) aresponses.add(hostname, '/apis/g1/g1v1', 'get', g1v1_mock) aresponses.add(hostname, '/apis/g2/g2v1', 'get', g2v1_mock) await scan_resources(groups=group_filter) assert core_mock.call_count == exp_core assert apis_mock.call_count == exp_apis assert crv1_mock.call_count == exp_crv1 assert g1v1_mock.call_count == exp_g1v1 assert g2v1_mock.call_count == exp_g2v1 @pytest.mark.parametrize('status', [404]) async def test_http404_returns_no_resources_from_old_apis( resp_mocker, aresponses, hostname, status): core_mock = resp_mocker(return_value=aiohttp.web.json_response({'versions': ['v1']})) apis_mock = resp_mocker(return_value=aiohttp.web.json_response({'groups': []})) status_mock = resp_mocker(return_value=aresponses.Response(status=status)) aresponses.add(hostname, '/api', 'get', core_mock) aresponses.add(hostname, '/apis', 'get', apis_mock) aresponses.add(hostname, '/api/v1', 'get', status_mock) resources = await scan_resources() assert not resources assert status_mock.call_count == 1 @pytest.mark.parametrize('status', [404]) async def test_http404_returns_no_resources_from_new_apis( resp_mocker, aresponses, hostname, status): core_mock = resp_mocker(return_value=aiohttp.web.json_response({'versions': []})) apis_mock = resp_mocker(return_value=aiohttp.web.json_response({'groups': [ {'name': 'g1', 'preferredVersion': {'version': ''}, 'versions': [{'version': 'g1v1'}]}, ]})) status_mock = resp_mocker(return_value=aresponses.Response(status=status)) aresponses.add(hostname, '/api', 'get', core_mock) aresponses.add(hostname, '/apis', 'get', apis_mock) aresponses.add(hostname, '/apis/g1/g1v1', 'get', status_mock) resources = await scan_resources() assert not resources assert status_mock.call_count == 1 @pytest.mark.parametrize('status', [403, 500, 666]) async def test_unknown_api_statuses_escalate_from_old_apis( resp_mocker, aresponses, hostname, status): core_mock = resp_mocker(return_value=aiohttp.web.json_response({'versions': ['v1']})) apis_mock = resp_mocker(return_value=aiohttp.web.json_response({'groups': []})) status_mock = resp_mocker(return_value=aresponses.Response(status=status)) aresponses.add(hostname, '/api', 'get', core_mock) aresponses.add(hostname, '/apis', 'get', apis_mock) aresponses.add(hostname, '/api/v1', 'get', status_mock) with pytest.raises(APIError) as err: await scan_resources() assert err.value.status == status assert status_mock.call_count == 1 @pytest.mark.parametrize('status', [403, 500, 666]) async def test_unknown_api_statuses_escalate_from_new_apis( resp_mocker, aresponses, hostname, status): core_mock = resp_mocker(return_value=aiohttp.web.json_response({'versions': []})) apis_mock = resp_mocker(return_value=aiohttp.web.json_response({'groups': [ {'name': 'g1', 'preferredVersion': {'version': ''}, 'versions': [{'version': 'g1v1'}]}, ]})) status_mock = resp_mocker(return_value=aresponses.Response(status=status)) aresponses.add(hostname, '/api', 'get', core_mock) aresponses.add(hostname, '/apis', 'get', apis_mock) aresponses.add(hostname, '/apis/g1/g1v1', 'get', status_mock) with pytest.raises(APIError) as err: await scan_resources() assert err.value.status == status assert status_mock.call_count == 1 async def test_empty_singulars_fall_back_to_kinds( resp_mocker, aresponses, hostname): # Only one endpoint is enough, core v1 is easier to mock: core_mock = resp_mocker(return_value=aiohttp.web.json_response({'versions': ['v1']})) apis_mock = resp_mocker(return_value=aiohttp.web.json_response({'groups': []})) scan_mock = resp_mocker(return_value=aiohttp.web.json_response({'resources': [ { 'kind': 'MultiWordKind', 'name': '...', 'singularName': '', # as in K3s 'namespaced': True, 'categories': [], 'shortNames': [], 'verbs': [], }, ]})) aresponses.add(hostname, '/api', 'get', core_mock) aresponses.add(hostname, '/apis', 'get', apis_mock) aresponses.add(hostname, '/api/v1', 'get', scan_mock) resources = await scan_resources(groups=['']) assert len(resources) == 1 resource1 = list(resources)[0] assert resource1.singular == 'multiwordkind' # TODO: LATER: test that the requests are done in parallel, and the total timing is the best possible.
37.511765
102
0.638466
1,460
12,754
5.367808
0.096575
0.05742
0.060738
0.086768
0.854919
0.832334
0.823785
0.807197
0.801455
0.801455
0
0.028552
0.200878
12,754
339
103
37.622419
0.740385
0.013016
0
0.671533
0
0
0.150509
0.003338
0
0
0
0.00295
0.189781
1
0
false
0
0.014599
0
0.014599
0
0
0
0
null
0
0
0
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
c1032838bbeb109ad9a4215c10b83d42db4b6591
48
py
Python
kaori/support/files/__init__.py
austinpray/kaori
b21c4146b9d0d27b87015cff0768138568a12e9c
[ "MIT" ]
3
2020-05-04T03:43:20.000Z
2020-12-03T22:34:47.000Z
kaori/support/files/__init__.py
austinpray/kaori
b21c4146b9d0d27b87015cff0768138568a12e9c
[ "MIT" ]
287
2020-04-21T02:39:47.000Z
2022-03-28T13:11:59.000Z
kaori/support/files/__init__.py
austinpray/kaori
b21c4146b9d0d27b87015cff0768138568a12e9c
[ "MIT" ]
1
2020-10-22T00:20:43.000Z
2020-10-22T00:20:43.000Z
from .hash import file_digest, hashed_file_name
24
47
0.854167
8
48
4.75
0.875
0
0
0
0
0
0
0
0
0
0
0
0.104167
48
1
48
48
0.883721
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
c159f1783f883d83bd7616672805dadd74c8ae35
828
py
Python
notebook/numpy_select_fancy_index.py
vhn0912/python-snippets
80b2e1d6b2b8f12ae30d6dbe86d25bb2b3a02038
[ "MIT" ]
174
2018-05-30T21:14:50.000Z
2022-03-25T07:59:37.000Z
notebook/numpy_select_fancy_index.py
vhn0912/python-snippets
80b2e1d6b2b8f12ae30d6dbe86d25bb2b3a02038
[ "MIT" ]
5
2019-08-10T03:22:02.000Z
2021-07-12T20:31:17.000Z
notebook/numpy_select_fancy_index.py
vhn0912/python-snippets
80b2e1d6b2b8f12ae30d6dbe86d25bb2b3a02038
[ "MIT" ]
53
2018-04-27T05:26:35.000Z
2022-03-25T07:59:37.000Z
import numpy as np a_1d = np.arange(4) print(a_1d) # [0 1 2 3] print(a_1d[[0, 2]]) # [0 2] print(a_1d[[0, 3, 2, 1, 2, -1, -2]]) # [0 3 2 1 2 3 2] print(a_1d[np.array([0, 3, 2, 1, 2, -1, -2])]) # [0 3 2 1 2 3 2] a_2d = np.arange(12).reshape(3, 4) print(a_2d) # [[ 0 1 2 3] # [ 4 5 6 7] # [ 8 9 10 11]] print(a_2d[[0, 2]]) # [[ 0 1 2 3] # [ 8 9 10 11]] print(a_2d[:, [0, 2]]) # [[ 0 2] # [ 4 6] # [ 8 10]] print(a_2d[[0, 2], [0, 2]]) # [ 0 10] print(a_2d[np.ix_([0, 2], [0, 2])]) # [[ 0 2] # [ 8 10]] print(a_2d[np.ix_([0, 2, 1, 1, -1, -1], [0, 2, 1, 3])]) # [[ 0 2 1 3] # [ 8 10 9 11] # [ 4 6 5 7] # [ 4 6 5 7] # [ 8 10 9 11] # [ 8 10 9 11]] print(a_2d[:, [1]]) # [[1] # [5] # [9]] print(a_2d[:, [1]].shape) # (3, 1) print(a_2d[:, 1]) # [1 5 9] print(a_2d[:, 1].shape) # (3,)
14.033898
55
0.415459
194
828
1.680412
0.134021
0.257669
0.245399
0.06135
0.518405
0.493865
0.493865
0.453988
0.355828
0.355828
0
0.274744
0.292271
828
58
56
14.275862
0.28157
0.369565
0
0
0
0
0
0
0
0
0
0
0
1
0
false
0
0.058824
0
0.058824
0.823529
0
0
1
null
1
1
0
0
0
0
0
0
0
0
1
0
0
0
0
0
1
0
0
0
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
1
0
6
c165b0e06ec07bef7ad3b094ec7223baafa8a02f
497
py
Python
utilities/exceptions.py
Hecate946/Candybot
e98a7acb73acb806aa5118fccb10fef428929bd4
[ "MIT" ]
2
2022-01-28T12:56:18.000Z
2022-02-23T20:11:28.000Z
utilities/exceptions.py
Hecate946/Candybot
e98a7acb73acb806aa5118fccb10fef428929bd4
[ "MIT" ]
null
null
null
utilities/exceptions.py
Hecate946/Candybot
e98a7acb73acb806aa5118fccb10fef428929bd4
[ "MIT" ]
null
null
null
from discord.ext import commands class AlreadyConnectedToChannel(commands.CommandError): pass class NoVoiceChannel(commands.CommandError): pass class QueueIsEmpty(commands.CommandError): pass class NoTracksFound(commands.CommandError): pass class PlayerIsAlreadyPaused(commands.CommandError): pass class NoMoreTracks(commands.CommandError): pass class NoPreviousTracks(commands.CommandError): pass class InvalidRepeatMode(commands.CommandError): pass
15.53125
55
0.784708
45
497
8.666667
0.355556
0.410256
0.492308
0.520513
0
0
0
0
0
0
0
0
0.148893
497
32
56
15.53125
0.921986
0
0
0.470588
0
0
0
0
0
0
0
0
0
1
0
true
0.470588
0.058824
0
0.529412
0
0
0
0
null
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
1
0
0
1
0
0
6
c1f2d0a797b5e28daf184fe10d6586db4c86ef2b
165
py
Python
module/__init__.py
zxlzr/LegalPP
5039b3848adfd9a9962eac5ff3e86084a3fe8596
[ "MIT" ]
4
2021-08-22T16:25:30.000Z
2022-01-05T13:34:53.000Z
module/__init__.py
Riroaki/Text-Graph-Reasoning
a87737f6bbc47dbb7a106756c6472453d5cb026d
[ "MIT" ]
null
null
null
module/__init__.py
Riroaki/Text-Graph-Reasoning
a87737f6bbc47dbb7a106756c6472453d5cb026d
[ "MIT" ]
1
2022-03-14T08:57:51.000Z
2022-03-14T08:57:51.000Z
from module.module_with_device import ModuleWithDevice from module.graph_encoder import load_graph_encoder from module.relation_decoder import load_relation_decoder
41.25
57
0.909091
23
165
6.173913
0.478261
0.211268
0
0
0
0
0
0
0
0
0
0
0.072727
165
3
58
55
0.928105
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
0
0
null
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
a9ffdf393208ecc2a8dc6469a58e4c5a588b047d
1,522
py
Python
problem_008.py
arboreus/project_euler
796173e8e72fcbfc15bbb3def7a36349639fafcf
[ "MIT" ]
null
null
null
problem_008.py
arboreus/project_euler
796173e8e72fcbfc15bbb3def7a36349639fafcf
[ "MIT" ]
null
null
null
problem_008.py
arboreus/project_euler
796173e8e72fcbfc15bbb3def7a36349639fafcf
[ "MIT" ]
null
null
null
#8) Largest product in a series #The four adjacent digits in the 1000-digit number that have the greatest product are 9 × 9 × 8 × 9 = 5832. #Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product? num = """ 73167176531330624919225119674426574742355349194934 96983520312774506326239578318016984801869478851843 85861560789112949495459501737958331952853208805511 12540698747158523863050715693290963295227443043557 66896648950445244523161731856403098711121722383113 62229893423380308135336276614282806444486645238749 30358907296290491560440772390713810515859307960866 70172427121883998797908792274921901699720888093776 65727333001053367881220235421809751254540594752243 52584907711670556013604839586446706324415722155397 53697817977846174064955149290862569321978468622482 83972241375657056057490261407972968652414535100474 82166370484403199890008895243450658541227588666881 16427171479924442928230863465674813919123162824586 17866458359124566529476545682848912883142607690042 24219022671055626321111109370544217506941658960408 07198403850962455444362981230987879927244284909188 84580156166097919133875499200524063689912560717606 05886116467109405077541002256983155200055935729725 71636269561882670428252483600823257530420752963450 """.replace('\n', '') # Solution def prod(x): product = 1 for i in x: product *= int(i) return product l = 13 nums = [num[x:x+l] for x in range(len(num)-l+1)] prods = [prod(x) for x in nums] max(prods)
39.025641
126
0.87385
113
1,522
11.79646
0.584071
0.021005
0.024006
0.028507
0.090023
0.090023
0.090023
0.090023
0.090023
0.090023
0
0.734532
0.086728
1,522
39
127
39.025641
0.222302
0.177398
0
0
0
0
0.819055
0.800641
0
1
0
0
0
1
0.032258
false
0
0
0
0.064516
0
0
0
1
null
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
1
0
0
0
0
0
1
1
null
1
0
0
0
0
0
0
0
0
0
0
0
0
6
e777d21769c1cd0304143ee438b6c6104208ba75
95
py
Python
sarepy/__init__.py
dtasev/sarepy
3179a63ac09aca791f3bccf13d61e2d47bee44c3
[ "Apache-2.0" ]
null
null
null
sarepy/__init__.py
dtasev/sarepy
3179a63ac09aca791f3bccf13d61e2d47bee44c3
[ "Apache-2.0" ]
null
null
null
sarepy/__init__.py
dtasev/sarepy
3179a63ac09aca791f3bccf13d61e2d47bee44c3
[ "Apache-2.0" ]
null
null
null
from sarepy import prep from sarepy import losa from sarepy import post from sarepy import reco
23.75
23
0.842105
16
95
5
0.4375
0.5
0.8
0
0
0
0
0
0
0
0
0
0.157895
95
4
24
23.75
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
0
0
null
1
1
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
0
0
0
6
99af15ae175663d346120648e835c4d382b3d757
188
py
Python
tests/test_dummy.py
PedrosWits/pydummy
154f7f6e638ebe4effc335c92f650cf533c2a547
[ "MIT" ]
1
2022-01-30T13:42:30.000Z
2022-01-30T13:42:30.000Z
tests/test_dummy.py
PedrosWits/pydummy
154f7f6e638ebe4effc335c92f650cf533c2a547
[ "MIT" ]
null
null
null
tests/test_dummy.py
PedrosWits/pydummy
154f7f6e638ebe4effc335c92f650cf533c2a547
[ "MIT" ]
null
null
null
import pytest import dummy def test_imports(): import numpy def test_dummy_True(): assert dummy.dummy_equals(1,1) def test_dummy_False(): assert not dummy.dummy_equals(1,2)
15.666667
38
0.739362
30
188
4.4
0.466667
0.159091
0.181818
0.257576
0
0
0
0
0
0
0
0.025641
0.170213
188
11
39
17.090909
0.820513
0
0
0
0
0
0
0
0
0
0
0
0.25
1
0.375
true
0
0.5
0
0.875
0
0
0
0
null
0
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
1
1
0
1
0
1
0
0
6
99cea7075d8d9d0714b550e3a13dab3b9873f5c1
43
py
Python
f2py_skel/frontend/__init__.py
HaoZeke/f2py_skel
240dd65456f1cb5dbcf4e312cec552fb35f72922
[ "MIT" ]
null
null
null
f2py_skel/frontend/__init__.py
HaoZeke/f2py_skel
240dd65456f1cb5dbcf4e312cec552fb35f72922
[ "MIT" ]
18
2021-11-24T19:01:13.000Z
2022-01-09T12:24:48.000Z
f2py_skel/frontend/__init__.py
HaoZeke/f2py_skel
240dd65456f1cb5dbcf4e312cec552fb35f72922
[ "MIT" ]
1
2021-12-26T17:40:52.000Z
2021-12-26T17:40:52.000Z
from f2py_skel.frontend.f2py2e import main
21.5
42
0.860465
7
43
5.142857
1
0
0
0
0
0
0
0
0
0
0
0.076923
0.093023
43
1
43
43
0.846154
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
8209a8e8f549b8aaa726ef2fb3bb0783ebd606a2
44
py
Python
__init__.py
sanmik/brain-network-viz
9c881e49c14c94e3f7ef4b7776d98c930716ee91
[ "MIT" ]
5
2017-09-01T14:05:03.000Z
2019-07-13T07:52:49.000Z
__init__.py
sanmik/brain-network-viz
9c881e49c14c94e3f7ef4b7776d98c930716ee91
[ "MIT" ]
null
null
null
__init__.py
sanmik/brain-network-viz
9c881e49c14c94e3f7ef4b7776d98c930716ee91
[ "MIT" ]
1
2017-09-01T14:05:03.000Z
2017-09-01T14:05:03.000Z
from source import networkviz as networkviz
22
43
0.863636
6
44
6.333333
0.833333
0
0
0
0
0
0
0
0
0
0
0
0.136364
44
1
44
44
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
416f90dbc695f4173c084d7c4cb793e3eca82e64
1,786
py
Python
ftc/migrations/0013_auto_20210212_2215.py
drkane/find-that-charity
25f778cfa1429e465bc19a6465b09f0473cfe113
[ "MIT" ]
14
2018-09-14T11:51:26.000Z
2021-02-28T22:00:29.000Z
ftc/migrations/0013_auto_20210212_2215.py
drkane/find-that-charity
25f778cfa1429e465bc19a6465b09f0473cfe113
[ "MIT" ]
89
2018-01-26T22:20:43.000Z
2022-01-20T14:16:25.000Z
ftc/migrations/0013_auto_20210212_2215.py
drkane/find-that-charity
25f778cfa1429e465bc19a6465b09f0473cfe113
[ "MIT" ]
7
2019-01-31T11:23:17.000Z
2022-03-09T07:42:08.000Z
# Generated by Django 3.1.1 on 2021-02-12 22:15 from django.db import migrations class Migration(migrations.Migration): dependencies = [ ("ftc", "0012_remove_organisation_location"), ] operations = [ migrations.RemoveField( model_name="organisation", name="geo_ctry", ), migrations.RemoveField( model_name="organisation", name="geo_cty", ), migrations.RemoveField( model_name="organisation", name="geo_lat", ), migrations.RemoveField( model_name="organisation", name="geo_laua", ), migrations.RemoveField( model_name="organisation", name="geo_lep1", ), migrations.RemoveField( model_name="organisation", name="geo_lep2", ), migrations.RemoveField( model_name="organisation", name="geo_long", ), migrations.RemoveField( model_name="organisation", name="geo_lsoa11", ), migrations.RemoveField( model_name="organisation", name="geo_msoa11", ), migrations.RemoveField( model_name="organisation", name="geo_oa11", ), migrations.RemoveField( model_name="organisation", name="geo_pcon", ), migrations.RemoveField( model_name="organisation", name="geo_rgn", ), migrations.RemoveField( model_name="organisation", name="geo_ttwa", ), migrations.RemoveField( model_name="organisation", name="geo_ward", ), ]
25.514286
53
0.517357
140
1,786
6.378571
0.3
0.329227
0.407615
0.470325
0.768197
0.768197
0.768197
0
0
0
0
0.024172
0.37458
1,786
69
54
25.884058
0.775291
0.025196
0
0.666667
1
0
0.182289
0.018976
0
0
0
0
0
1
0
false
0
0.015873
0
0.063492
0
0
0
0
null
1
1
1
0
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
418ca7469c2babd664df7570056a6315b995c662
90
py
Python
vesper/django/app/refresh_recording_audio_file_paths_form.py
RichardLitt/Vesper
5360844f42a06942e7684121c650b08cf8616285
[ "MIT" ]
29
2017-07-10T14:49:15.000Z
2022-02-02T23:14:38.000Z
vesper/django/app/refresh_recording_audio_file_paths_form.py
Tubbz-alt/Vesper
76e5931ca0c7fbe070c53b1362ec246ec9007beb
[ "MIT" ]
167
2015-03-17T14:45:22.000Z
2022-03-30T21:00:05.000Z
vesper/django/app/refresh_recording_audio_file_paths_form.py
Tubbz-alt/Vesper
76e5931ca0c7fbe070c53b1362ec246ec9007beb
[ "MIT" ]
4
2015-02-06T03:30:27.000Z
2020-12-27T08:38:52.000Z
from django import forms class RefreshRecordingAudioFilePathsForm(forms.Form): pass
15
53
0.811111
9
90
8.111111
0.888889
0
0
0
0
0
0
0
0
0
0
0
0.144444
90
5
54
18
0.948052
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0.333333
0.333333
0
0.666667
0
1
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
1
1
0
1
0
0
6
418cef3b14d5a6c6f85f68c9486aa33bfb49651f
41
py
Python
src/apps/startposes/serializers/__init__.py
sanderland/katago-server
6414fab080d007c05068a06ff4f25907b92848bd
[ "MIT" ]
27
2020-05-03T11:01:27.000Z
2022-03-17T05:33:10.000Z
src/apps/startposes/serializers/__init__.py
sanderland/katago-server
6414fab080d007c05068a06ff4f25907b92848bd
[ "MIT" ]
54
2020-05-09T01:18:41.000Z
2022-01-22T10:31:15.000Z
src/apps/startposes/serializers/__init__.py
sanderland/katago-server
6414fab080d007c05068a06ff4f25907b92848bd
[ "MIT" ]
9
2020-09-29T11:31:32.000Z
2022-03-09T01:37:50.000Z
from .startpos import StartPosSerializer
20.5
40
0.878049
4
41
9
1
0
0
0
0
0
0
0
0
0
0
0
0.097561
41
1
41
41
0.972973
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
419fd38f818abbc14a74cb98f09c9b355f504fc0
31
py
Python
cred_loader/__init__.py
ntnunk/aws_credential_manager
c37cafd99472d608ce4fcb6b475a4ae2f22a25f5
[ "MIT" ]
null
null
null
cred_loader/__init__.py
ntnunk/aws_credential_manager
c37cafd99472d608ce4fcb6b475a4ae2f22a25f5
[ "MIT" ]
null
null
null
cred_loader/__init__.py
ntnunk/aws_credential_manager
c37cafd99472d608ce4fcb6b475a4ae2f22a25f5
[ "MIT" ]
null
null
null
from cred_loader import loader
15.5
30
0.870968
5
31
5.2
0.8
0
0
0
0
0
0
0
0
0
0
0
0.129032
31
1
31
31
0.962963
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
41c6c4a37904a6bdb5c4fe28ebe5c2e5c3f5c4e0
2,412
py
Python
src/animator/rotateout.py
Z3t5upro/AC_Management
d9c64177312d8c3eebc5e05124fd372bfe42d000
[ "MIT" ]
22
2020-01-05T19:30:13.000Z
2022-03-29T06:14:04.000Z
src/animator/rotateout.py
Z3t5upro/AC_Management
d9c64177312d8c3eebc5e05124fd372bfe42d000
[ "MIT" ]
7
2019-12-07T09:51:11.000Z
2021-12-05T00:22:46.000Z
src/animator/rotateout.py
Z3t5upro/AC_Management
d9c64177312d8c3eebc5e05124fd372bfe42d000
[ "MIT" ]
8
2019-11-17T07:16:47.000Z
2021-10-06T04:32:22.000Z
from kivy.animation import Animation from functools import partial from .base import Animator __all__ = ( "RotateOutAnimator", "RotateOutDownLeftAnimator", "RotateOutDownRightAnimator", "RotateOutUpLeftAnimator", "RotateOutUpRightAnimator", ) # rotate out class RotateOutAnimator(Animator): def start_(self, tmp=None): props = ["angle", "opacity"] vals = [-200, 0] anim = Animation(d=self.duration, **dict(zip(props, vals))) anim.cancel_all(self.widget) anim.start(self.widget) anim.bind(on_complete=partial(self.anim_complete, self)) class RotateOutDownLeftAnimator(Animator): def start_(self, tmp=None): pivot = (self.widget.x - self.widget.width / 2, self.widget.y) self.widget.origin_ = pivot props = ["angle", "opacity"] vals = [-90, 0] anim = Animation(d=self.duration, **dict(zip(props, vals))) anim.cancel_all(self.widget) anim.start(self.widget) anim.bind(on_complete=partial(self.anim_complete, self)) class RotateOutDownRightAnimator(Animator): def start_(self, tmp=None): pivot = (self.widget.x + 3 * self.widget.width / 2, self.widget.y) self.widget.origin_ = pivot props = ["angle", "opacity"] vals = [90, 0] anim = Animation(d=self.duration, **dict(zip(props, vals))) anim.cancel_all(self.widget) anim.start(self.widget) anim.bind(on_complete=partial(self.anim_complete, self)) class RotateOutUpLeftAnimator(Animator): def start_(self, tmp=None): pivot = (self.widget.x - self.widget.width / 2, self.widget.y) self.widget.origin_ = pivot props = ["angle", "opacity"] vals = [90, 0] anim = Animation(d=self.duration, **dict(zip(props, vals))) anim.cancel_all(self.widget) anim.start(self.widget) anim.bind(on_complete=partial(self.anim_complete, self)) class RotateOutUpRightAnimator(Animator): def start_(self, tmp=None): pivot = (self.widget.x + 3 * self.widget.width / 2, self.widget.y) self.widget.origin_ = pivot props = ["angle", "opacity"] vals = [-90, 0] anim = Animation(d=self.duration, **dict(zip(props, vals))) anim.cancel_all(self.widget) anim.start(self.widget) anim.bind(on_complete=partial(self.anim_complete, self))
29.777778
74
0.635987
288
2,412
5.229167
0.159722
0.172643
0.092961
0.066401
0.766932
0.766932
0.749004
0.749004
0.749004
0.749004
0
0.011796
0.226783
2,412
80
75
30.15
0.79571
0.004146
0
0.724138
0
0
0.072917
0.040833
0
0
0
0
0
1
0.086207
false
0
0.051724
0
0.224138
0
0
0
0
null
0
0
0
0
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
ec097cabfa465d4801932fdd7fbc521e952d2c87
137
py
Python
anysma/datasets/__init__.py
saralajew/thesis_GTLVQ_experiments
4f6eb967a1f37917cd185fc20d6df7bbbd9288d1
[ "BSD-3-Clause" ]
2
2019-10-09T07:51:42.000Z
2020-02-11T02:49:35.000Z
anysma/datasets/__init__.py
AnysmaForBlindReview/anysma
98445edfdbbe81f227ec807995ea75a5f6e08628
[ "BSD-3-Clause" ]
4
2020-04-05T22:29:05.000Z
2022-02-09T23:36:01.000Z
anysma/datasets/__init__.py
AnysmaForBlindReview/anysma
98445edfdbbe81f227ec807995ea75a5f6e08628
[ "BSD-3-Clause" ]
null
null
null
from __future__ import absolute_import from keras.datasets import * from . import tecator from . import affnist from . import smallnorb
19.571429
38
0.810219
18
137
5.888889
0.5
0.283019
0
0
0
0
0
0
0
0
0
0
0.153285
137
6
39
22.833333
0.913793
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
0
0
null
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
ec127137489977087bf4175c25340390eccba253
109
py
Python
commands/upgrader/commands/playsound.py
Red-Teapot/mc-commandblock-1.13-update
64106e1ecb5adca2aff1eeb3a1fcc11486940000
[ "MIT" ]
1
2020-07-27T16:53:26.000Z
2020-07-27T16:53:26.000Z
commands/upgrader/commands/playsound.py
Red-Teapot/mc-commandblock-1.13-update
64106e1ecb5adca2aff1eeb3a1fcc11486940000
[ "MIT" ]
5
2019-01-02T14:21:32.000Z
2019-07-07T05:39:39.000Z
commands/upgrader/commands/playsound.py
Red-Teapot/mc-commandblock-1.13-update
64106e1ecb5adca2aff1eeb3a1fcc11486940000
[ "MIT" ]
null
null
null
# Nothing to do # TODO Maybe process selectors properly? def upgrade(command: str) -> str: return command
27.25
40
0.733945
15
109
5.333333
0.866667
0
0
0
0
0
0
0
0
0
0
0
0.183486
109
4
41
27.25
0.898876
0.477064
0
0
0
0
0
0
0
0
0
0.25
0
1
0.5
false
0
0
0.5
1
0
1
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
1
0
0
1
0
0
0
1
1
0
0
6
ec1cf38700b934b57b1240453458b10bd2ff171e
38
py
Python
hmpa/__init__.py
awesome-archive/hmpa-pi
190a257395bc067ebb83a04e9abe7df9b0e5311f
[ "MIT" ]
166
2019-01-24T10:18:43.000Z
2022-02-12T22:42:32.000Z
hmpa/__init__.py
ykbj/hmpa-pi
a60a1cff0cdf334240abdfaf6613a285608c6e08
[ "MIT" ]
null
null
null
hmpa/__init__.py
ykbj/hmpa-pi
a60a1cff0cdf334240abdfaf6613a285608c6e08
[ "MIT" ]
27
2019-01-24T11:02:41.000Z
2021-02-05T05:54:50.000Z
from . import oui from . import tshark
19
20
0.763158
6
38
4.833333
0.666667
0.689655
0
0
0
0
0
0
0
0
0
0
0.184211
38
2
20
19
0.935484
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
0
0
0
6
6b8edf3af09bc8bac94c324feb1377373966fc60
1,361
py
Python
MaximumLikelihoodEstimation/PSET09-03.py
sum-coderepo/HadoopApp
0e8d48c5d541b5935c9054fb1335d829d67d7b59
[ "Apache-2.0" ]
2
2020-05-26T23:58:32.000Z
2020-11-01T20:45:30.000Z
MaximumLikelihoodEstimation/PSET09-03.py
sum-coderepo/HadoopApp
0e8d48c5d541b5935c9054fb1335d829d67d7b59
[ "Apache-2.0" ]
null
null
null
MaximumLikelihoodEstimation/PSET09-03.py
sum-coderepo/HadoopApp
0e8d48c5d541b5935c9054fb1335d829d67d7b59
[ "Apache-2.0" ]
null
null
null
import numpy import statistics as st from scipy import stats mu, sigma = 0, 1 samples1 = numpy.random.normal(mu, sigma, 1000) X = numpy.array_split(samples1, 10) print("The below stats is for {0} sets and {1} samples each".format(10,100)) for num,arr in enumerate(X, start=1): mean = st.mean(arr) stdev = st.stdev(arr) mle = stats.norm(mean, stdev).pdf(mean) print("The maximum likelihood of sample {0} and mean {1} and standard deviation {2} is {3}".format(num,mean,stdev,mle)) print('\n') samples2 = numpy.random.normal(mu, sigma, 2000) X = numpy.array_split(samples2, 10) print("The below stats is for {0} sets and {1} samples each".format(10,200)) for num,arr in enumerate(X, start=1): mean = st.mean(arr) stdev = st.stdev(arr) mle = stats.norm(mean, stdev).pdf(mean) print("The maximum likelihood of sample {0} and mean {1} and standard deviation {2} is {3}".format(num,mean,stdev,mle)) #print('\n') #samples2 = numpy.random.normal(mu, sigma, 500) #X = numpy.array_split(samples2, 5) #print("The below stats is for {0} sets and {1} samples each".format(5,100)) #for num,arr in enumerate(X, start=1): # mean = st.mean(arr) # stdev = st.stdev(arr) # mle = stats.norm(mean, stdev).pdf(mean) # print("The maximum likelihood of sample {0} and mean {1} and standard deviation {2} is {3}".format(num,mean,stdev,mle))
41.242424
124
0.683321
234
1,361
3.961538
0.235043
0.05178
0.055016
0.061489
0.883495
0.805825
0.805825
0.805825
0.805825
0.805825
0
0.051573
0.159442
1,361
32
125
42.53125
0.758741
0.306392
0
0.47619
0
0.095238
0.290909
0
0
0
0
0
0
1
0
false
0
0.142857
0
0.142857
0.238095
0
0
0
null
0
0
0
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
6b9e2cfff591f7be08a404ad6e2a9a5179077eb0
17,414
py
Python
krake/krake/api/openstack.py
rak-n-rok/Krake
2f0d4a382b99639e2c1149ee8593a9bb589d2d3f
[ "Apache-2.0" ]
1
2020-05-29T08:43:32.000Z
2020-05-29T08:43:32.000Z
krake/krake/api/openstack.py
rak-n-rok/Krake
2f0d4a382b99639e2c1149ee8593a9bb589d2d3f
[ "Apache-2.0" ]
null
null
null
krake/krake/api/openstack.py
rak-n-rok/Krake
2f0d4a382b99639e2c1149ee8593a9bb589d2d3f
[ "Apache-2.0" ]
1
2019-11-19T13:39:02.000Z
2019-11-19T13:39:02.000Z
import dataclasses import json import logging from aiohttp import web from uuid import uuid4 from webargs.aiohttpparser import use_kwargs from krake import utils from krake.api.auth import protected from krake.api.database import EventType from krake.api.helpers import ( load, session, Heartbeat, use_schema, HttpReason, HttpReasonCode, make_create_request_schema, json_error, ListQuery, ) from krake.data.core import WatchEvent, WatchEventType, ListMetadata from krake.data.openstack import ( ProjectList, Project, MagnumCluster, MagnumClusterList, MagnumClusterBinding, ) logger = logging.getLogger(__name__) class OpenStackApi(object): """Contains all handlers for the resources of the "openstack" API. These handlers will be added to the Krake API components. """ routes = web.RouteTableDef() @routes.route("POST", "/openstack/namespaces/{namespace}/magnumclusters") @protected(api="openstack", resource="magnumclusters", verb="create") @use_schema("body", schema=make_create_request_schema(MagnumCluster)) async def create_magnum_cluster(request, body): kwargs = {"name": body.metadata.name} namespace = request.match_info.get("namespace") kwargs["namespace"] = namespace # Ensure that a resource with the same name does not already # exists. existing = await session(request).get(body.__class__, **kwargs) if existing is not None: message = ( f"MagnumCluster {body.metadata.name!r} already " f"exists in namespace {namespace!r}" ) reason = HttpReason( reason=message, code=HttpReasonCode.RESOURCE_ALREADY_EXISTS ) raise json_error(web.HTTPConflict, reason.serialize()) now = utils.now() body.metadata.namespace = namespace body.metadata.uid = str(uuid4()) body.metadata.created = now body.metadata.modified = now # Initialize subresource fields for field in dataclasses.fields(body): if field.metadata.get("subresource", False): value = field.type() setattr(body, field.name, value) await session(request).put(body) logger.info( "Created %s %r (%s)", "MagnumCluster", body.metadata.name, body.metadata.uid ) return web.json_response(body.serialize()) @routes.route("DELETE", "/openstack/namespaces/{namespace}/magnumclusters/{name}") @protected(api="openstack", resource="magnumclusters", verb="delete") @load("entity", MagnumCluster) async def delete_magnum_cluster(request, entity): # Resource is already deleting if entity.metadata.deleted: return web.json_response(entity.serialize()) # TODO: Should be update "modified" here? # Resource marked as deletion, to be deleted by the Garbage Collector entity.metadata.deleted = utils.now() entity.metadata.finalizers.append("cascade_deletion") await session(request).put(entity) logger.info( "Deleting %s %r (%s)", "MagnumCluster", entity.metadata.name, entity.metadata.uid, ) return web.json_response(entity.serialize()) @routes.route("GET", "/openstack/magnumclusters") @routes.route("GET", "/openstack/namespaces/{namespace}/magnumclusters") @protected(api="openstack", resource="magnumclusters", verb="list") @use_kwargs(ListQuery.query, location="query") async def list_or_watch_magnum_clusters(request, heartbeat, watch, **query): resource_class = MagnumCluster # If the ListAll operation namespace = request.match_info.get("namespace", None) # Return the list of resources if not watch: if namespace is None: objs = [obj async for obj in session(request).all(resource_class)] else: objs = [ obj async for obj in session(request).all( resource_class, namespace=namespace ) ] body = MagnumClusterList(metadata=ListMetadata(), items=objs) return web.json_response(body.serialize()) # Watching resources kwargs = {} if namespace is not None: kwargs["namespace"] = namespace async with session(request).watch(resource_class, **kwargs) as watcher: resp = web.StreamResponse(headers={"Content-Type": "application/x-ndjson"}) resp.enable_chunked_encoding() await resp.prepare(request) async with Heartbeat(resp, interval=heartbeat): async for event, obj, rev in watcher: # Key was deleted. Stop update stream if event == EventType.PUT: if rev.created == rev.modified: event_type = WatchEventType.ADDED else: event_type = WatchEventType.MODIFIED else: event_type = WatchEventType.DELETED obj = await session(request).get_by_key( resource_class, key=rev.key, revision=rev.modified - 1 ) watch_event = WatchEvent(type=event_type, object=obj.serialize()) await resp.write(json.dumps(watch_event.serialize()).encode()) await resp.write(b"\n") @routes.route("GET", "/openstack/namespaces/{namespace}/magnumclusters/{name}") @protected(api="openstack", resource="magnumclusters", verb="get") @load("entity", MagnumCluster) async def read_magnum_cluster(request, entity): return web.json_response(entity.serialize()) @routes.route("PUT", "/openstack/namespaces/{namespace}/magnumclusters/{name}") @protected(api="openstack", resource="magnumclusters", verb="update") @use_schema("body", schema=MagnumCluster.Schema) @load("entity", MagnumCluster) async def update_magnum_cluster(request, body, entity): # Once a resource is in the "deletion in progress" state, finalizers # can only be removed. if entity.metadata.deleted: if not set(body.metadata.finalizers) <= set(entity.metadata.finalizers): raise json_error( web.HTTPConflict, { "metadata": { "finalizers": [ "Finalizers can only be removed if " "deletion is in progress." ] } }, ) # FIXME: if a user updates an immutable field, (such as the created timestamp), # the request is accepted and the API returns 200. The `modified` timestamp # will also still be updated, even though no change from the request on # immutable fields will be applied. # Changes to immutable fields should be rejected, see Krake issue #410 if body == entity: raise json_error(web.HTTPBadRequest, "The body contained no update.") entity.update(body) entity.metadata.modified = utils.now() # Resource is in "deletion in progress" state and all finalizers have # been removed. Delete the resource from database. if entity.metadata.deleted and not entity.metadata.finalizers: await session(request).delete(entity) logger.info( "Delete %s %r (%s)", "MagnumCluster", entity.metadata.name, entity.metadata.uid, ) else: await session(request).put(entity) logger.info( "Update %s %r (%s)", "MagnumCluster", entity.metadata.name, entity.metadata.uid, ) return web.json_response(entity.serialize()) @routes.route( "PUT", "/openstack/namespaces/{namespace}/magnumclusters/{name}/binding" ) @protected(api="openstack", resource="magnumclusters/binding", verb="update") @load("cluster", MagnumCluster) @use_schema("body", MagnumClusterBinding.Schema) async def update_magnum_cluster_binding(request, body, cluster): cluster.status.project = body.project cluster.status.template = body.template if body.project not in cluster.metadata.owners: cluster.metadata.owners.append(body.project) await session(request).put(cluster) logger.info("Bind %r to %r", cluster, cluster.status.project) return web.json_response(cluster.serialize()) @routes.route( "PUT", "/openstack/namespaces/{namespace}/magnumclusters/{name}/status" ) @protected(api="openstack", resource="magnumclusters/status", verb="update") @use_schema("body", MagnumCluster.Schema) @load("entity", MagnumCluster) async def update_magnum_cluster_status(request, body, entity): source = getattr(body, "status") dest = getattr(entity, "status") dest.update(source) await session(request).put(entity) logger.info( "Update %s of %s %r (%s)", "Status", "MagnumCluster", entity.metadata.name, entity.metadata.uid, ) return web.json_response(entity.serialize()) @routes.route("POST", "/openstack/namespaces/{namespace}/projects") @protected(api="openstack", resource="projects", verb="create") @use_schema("body", schema=make_create_request_schema(Project)) async def create_project(request, body): kwargs = {"name": body.metadata.name} namespace = request.match_info.get("namespace") kwargs["namespace"] = namespace # Ensure that a resource with the same name does not already # exists. existing = await session(request).get(body.__class__, **kwargs) if existing is not None: message = ( f"Project {body.metadata.name!r} already " f"exists in namespace {namespace!r}" ) reason = HttpReason( reason=message, code=HttpReasonCode.RESOURCE_ALREADY_EXISTS ) raise json_error(web.HTTPConflict, reason.serialize()) now = utils.now() body.metadata.namespace = namespace body.metadata.uid = str(uuid4()) body.metadata.created = now body.metadata.modified = now # Initialize subresource fields for field in dataclasses.fields(body): if field.metadata.get("subresource", False): value = field.type() setattr(body, field.name, value) await session(request).put(body) logger.info( "Created %s %r (%s)", "Project", body.metadata.name, body.metadata.uid ) return web.json_response(body.serialize()) @routes.route("DELETE", "/openstack/namespaces/{namespace}/projects/{name}") @protected(api="openstack", resource="projects", verb="delete") @load("entity", Project) async def delete_project(request, entity): # Resource is already deleting if entity.metadata.deleted: return web.json_response(entity.serialize()) # TODO: Should be update "modified" here? # Resource marked as deletion, to be deleted by the Garbage Collector entity.metadata.deleted = utils.now() entity.metadata.finalizers.append("cascade_deletion") await session(request).put(entity) logger.info( "Deleting %s %r (%s)", "Project", entity.metadata.name, entity.metadata.uid ) return web.json_response(entity.serialize()) @routes.route("GET", "/openstack/projects") @routes.route("GET", "/openstack/namespaces/{namespace}/projects") @protected(api="openstack", resource="projects", verb="list") @use_kwargs(ListQuery.query, location="query") async def list_or_watch_projects(request, heartbeat, watch, **query): resource_class = Project # If the ListAll operation namespace = request.match_info.get("namespace", None) # Return the list of resources if not watch: if namespace is None: objs = [obj async for obj in session(request).all(resource_class)] else: objs = [ obj async for obj in session(request).all( resource_class, namespace=namespace ) ] body = ProjectList(metadata=ListMetadata(), items=objs) return web.json_response(body.serialize()) # Watching resources kwargs = {} if namespace is not None: kwargs["namespace"] = namespace async with session(request).watch(resource_class, **kwargs) as watcher: resp = web.StreamResponse(headers={"Content-Type": "application/x-ndjson"}) resp.enable_chunked_encoding() await resp.prepare(request) async with Heartbeat(resp, interval=heartbeat): async for event, obj, rev in watcher: # Key was deleted. Stop update stream if event == EventType.PUT: if rev.created == rev.modified: event_type = WatchEventType.ADDED else: event_type = WatchEventType.MODIFIED else: event_type = WatchEventType.DELETED obj = await session(request).get_by_key( resource_class, key=rev.key, revision=rev.modified - 1 ) watch_event = WatchEvent(type=event_type, object=obj.serialize()) await resp.write(json.dumps(watch_event.serialize()).encode()) await resp.write(b"\n") @routes.route("GET", "/openstack/namespaces/{namespace}/projects/{name}") @protected(api="openstack", resource="projects", verb="get") @load("entity", Project) async def read_project(request, entity): return web.json_response(entity.serialize()) @routes.route("PUT", "/openstack/namespaces/{namespace}/projects/{name}") @protected(api="openstack", resource="projects", verb="update") @use_schema("body", schema=Project.Schema) @load("entity", Project) async def update_project(request, body, entity): # Once a resource is in the "deletion in progress" state, finalizers # can only be removed. if entity.metadata.deleted: if not set(body.metadata.finalizers) <= set(entity.metadata.finalizers): raise json_error( web.HTTPConflict, { "metadata": { "finalizers": [ "Finalizers can only be removed if " "deletion is in progress." ] } }, ) # FIXME: if a user updates an immutable field, (such as the created timestamp), # the request is accepted and the API returns 200. The `modified` timestamp # will also still be updated, even though no change from the request on # immutable fields will be applied. # Changes to immutable fields should be rejected, see Krake issue #410 if body == entity: raise json_error(web.HTTPBadRequest, "The body contained no update.") entity.update(body) entity.metadata.modified = utils.now() # Resource is in "deletion in progress" state and all finalizers have # been removed. Delete the resource from database. if entity.metadata.deleted and not entity.metadata.finalizers: await session(request).delete(entity) logger.info( "Delete %s %r (%s)", "Project", entity.metadata.name, entity.metadata.uid, ) else: await session(request).put(entity) logger.info( "Update %s %r (%s)", "Project", entity.metadata.name, entity.metadata.uid, ) return web.json_response(entity.serialize()) @routes.route("PUT", "/openstack/namespaces/{namespace}/projects/{name}/status") @protected(api="openstack", resource="projects/status", verb="update") @use_schema("body", Project.Schema) @load("entity", Project) async def update_project_status(request, body, entity): source = getattr(body, "status") dest = getattr(entity, "status") dest.update(source) await session(request).put(entity) logger.info( "Update %s of %s %r (%s)", "Status", "Project", entity.metadata.name, entity.metadata.uid, ) return web.json_response(entity.serialize())
38.021834
88
0.589181
1,778
17,414
5.702475
0.124859
0.044186
0.028109
0.031068
0.873755
0.853634
0.826511
0.82375
0.82375
0.806884
0
0.001408
0.306592
17,414
457
89
38.105033
0.838261
0.107155
0
0.622807
0
0
0.136504
0.050665
0
0
0
0.002188
0
1
0
false
0
0.035088
0
0.084795
0
0
0
0
null
0
0
0
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
6bedd385b0bf9c29210ea6006e37e60df05eeac5
32
py
Python
lantern/analysis/__init__.py
CameronLonsdale/cckrusher
3d9d99d27e56a78b0c4982c30f30818f13150e47
[ "MIT" ]
19
2017-04-08T08:03:40.000Z
2022-02-23T03:06:33.000Z
lantern/analysis/__init__.py
CameronLonsdale/cckrusher
3d9d99d27e56a78b0c4982c30f30818f13150e47
[ "MIT" ]
21
2017-04-23T12:42:22.000Z
2019-06-15T03:51:43.000Z
lantern/analysis/__init__.py
CameronLonsdale/cckrypto
3d9d99d27e56a78b0c4982c30f30818f13150e47
[ "MIT" ]
4
2017-06-28T06:10:05.000Z
2019-11-19T04:23:46.000Z
from . import frequency, search
16
31
0.78125
4
32
6.25
1
0
0
0
0
0
0
0
0
0
0
0
0.15625
32
1
32
32
0.925926
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
d43517d81e20b38dd612fdabcdaeb957f04ddc02
46
py
Python
infrastructure/cognito/__init__.py
maciejGolebio/aws-crud-lambda
5b4bdfc1cd2da60ebe99b6d9036fa06ea5ce861d
[ "MIT" ]
null
null
null
infrastructure/cognito/__init__.py
maciejGolebio/aws-crud-lambda
5b4bdfc1cd2da60ebe99b6d9036fa06ea5ce861d
[ "MIT" ]
null
null
null
infrastructure/cognito/__init__.py
maciejGolebio/aws-crud-lambda
5b4bdfc1cd2da60ebe99b6d9036fa06ea5ce861d
[ "MIT" ]
null
null
null
from infrastructure.cognito.user_pool import *
46
46
0.869565
6
46
6.5
1
0
0
0
0
0
0
0
0
0
0
0
0.065217
46
1
46
46
0.906977
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
d48a828a08ea0d083a01bd3c0890eb056000d5e1
94
py
Python
Lesson 5.py
Dmitrii388444/python_lesson_5
da6f9640b149ccece65ce751ea6de4bfcc186658
[ "MIT" ]
null
null
null
Lesson 5.py
Dmitrii388444/python_lesson_5
da6f9640b149ccece65ce751ea6de4bfcc186658
[ "MIT" ]
null
null
null
Lesson 5.py
Dmitrii388444/python_lesson_5
da6f9640b149ccece65ce751ea6de4bfcc186658
[ "MIT" ]
null
null
null
import requests import flask print ('Hello world') print ('Hello') print('Hello', 'student')
13.428571
25
0.712766
12
94
5.583333
0.583333
0.447761
0
0
0
0
0
0
0
0
0
0
0.12766
94
6
26
15.666667
0.817073
0
0
0
0
0
0.301075
0
0
0
0
0
0
1
0
true
0
0.4
0
0.4
0.6
1
0
0
null
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
0
1
0
6
2e394fe2a9cc7481c7aa0986a0f6c43847204520
29
py
Python
geowall/__init__.py
kashev/geometric-wallpaper
7797f99278d05c6a4e57c089fa53dafbdb0b7c77
[ "MIT" ]
null
null
null
geowall/__init__.py
kashev/geometric-wallpaper
7797f99278d05c6a4e57c089fa53dafbdb0b7c77
[ "MIT" ]
null
null
null
geowall/__init__.py
kashev/geometric-wallpaper
7797f99278d05c6a4e57c089fa53dafbdb0b7c77
[ "MIT" ]
null
null
null
from . import colors, shapes
14.5
28
0.758621
4
29
5.5
1
0
0
0
0
0
0
0
0
0
0
0
0.172414
29
1
29
29
0.916667
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
2e74f51344b0451768609aff68a25e0cad80d2a4
394
py
Python
pyecog/__init__.py
mikailweston/pyecog
9a1674ec95b63ad9aa0a2d3aedc1a74be6441446
[ "MIT" ]
10
2016-09-07T16:01:39.000Z
2019-03-26T11:14:28.000Z
pyecog/__init__.py
mikailweston/pyecog
9a1674ec95b63ad9aa0a2d3aedc1a74be6441446
[ "MIT" ]
54
2016-11-21T14:41:52.000Z
2022-03-18T08:41:11.000Z
pyecog/__init__.py
jcornford/pyecog
356439bd5e3c50fd0cd74eef90a897bd41363920
[ "MIT" ]
5
2016-10-11T14:14:44.000Z
2017-08-02T11:45:48.000Z
''' from .ndf import H5File from .ndf import NdfFile from .ndf import plot from .ndf import basic_plot from .ndf import DataHandler from .ndf import FeaturePreProcesser from .ndf import Classifier from .ndf import FeatureExtractor from .ndf import load_classifier from .ndf import make_hmm_model from .visualisation import pyecog_main_gui ''' from .ndf import * from .visualisation import *
20.736842
42
0.80203
56
394
5.535714
0.339286
0.248387
0.46129
0.109677
0
0
0
0
0
0
0
0.002967
0.14467
394
18
43
21.888889
0.916914
0.847716
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
0
0
0
null
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
2e754e6532ceb633cb77f35a7cd979d84fe72a19
71
py
Python
sprocket/__init__.py
ontodev/sprocket
f0bf09b23f38513a693178f4ee960092bd7f5ee3
[ "BSD-3-Clause" ]
null
null
null
sprocket/__init__.py
ontodev/sprocket
f0bf09b23f38513a693178f4ee960092bd7f5ee3
[ "BSD-3-Clause" ]
29
2021-09-01T20:20:36.000Z
2021-12-15T18:43:55.000Z
sprocket/__init__.py
ontodev/sprocket
f0bf09b23f38513a693178f4ee960092bd7f5ee3
[ "BSD-3-Clause" ]
null
null
null
from sprocket.lib import * from sprocket.run import BLUEPRINT, prepare
23.666667
43
0.816901
10
71
5.8
0.7
0.413793
0
0
0
0
0
0
0
0
0
0
0.126761
71
2
44
35.5
0.935484
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
0
0
null
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
2e7e5c6fb4642fd70082ae7e8c936db5d7c3a2c2
116
py
Python
srcs/parser/tokens/square_open_bracket_token.py
pomponchik/computor_v2
742b3f3b47c8d46806b2f733b4ec07ae63a23f00
[ "MIT" ]
null
null
null
srcs/parser/tokens/square_open_bracket_token.py
pomponchik/computor_v2
742b3f3b47c8d46806b2f733b4ec07ae63a23f00
[ "MIT" ]
null
null
null
srcs/parser/tokens/square_open_bracket_token.py
pomponchik/computor_v2
742b3f3b47c8d46806b2f733b4ec07ae63a23f00
[ "MIT" ]
null
null
null
from srcs.parser.tokens.abstract_token import AbstractToken class SquareOpenBracketToken(AbstractToken): pass
19.333333
59
0.836207
12
116
8
0.916667
0
0
0
0
0
0
0
0
0
0
0
0.112069
116
5
60
23.2
0.932039
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0.333333
0.333333
0
0.666667
0
1
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
1
1
0
1
0
0
6
cf0bb91af6c75e0953044e49b7df6168e6a0e1f4
148
py
Python
geometri/square.py
enterprise-analytics-id/modularisasi
629edced07ca92f51826e89da9934b49ba13c301
[ "Unlicense" ]
null
null
null
geometri/square.py
enterprise-analytics-id/modularisasi
629edced07ca92f51826e89da9934b49ba13c301
[ "Unlicense" ]
null
null
null
geometri/square.py
enterprise-analytics-id/modularisasi
629edced07ca92f51826e89da9934b49ba13c301
[ "Unlicense" ]
null
null
null
def info(): return 'Modul menghitung rumus tentang persegi panjang' def hitung_luas_persegi_panjang(panjang, lebar): return panjang * lebar
29.6
59
0.77027
19
148
5.842105
0.631579
0.252252
0
0
0
0
0
0
0
0
0
0
0.162162
148
5
60
29.6
0.895161
0
0
0
0
0
0.308725
0
0
0
0
0
0
1
0.5
false
0
0
0.5
1
0
1
0
0
null
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
1
0
0
0
1
1
0
0
6
cf3085d2aa372ef6a29aa73b06bbb72676cfaacf
1,777
py
Python
liaison/forms.py
hhdMrLion/DJANGO_CRM
1f8d2d7a025f9dc54b5bf498e7a577469f74c612
[ "Apache-2.0" ]
1
2021-06-18T03:03:46.000Z
2021-06-18T03:03:46.000Z
liaison/forms.py
hhdMrLion/DJANGO_CRM
1f8d2d7a025f9dc54b5bf498e7a577469f74c612
[ "Apache-2.0" ]
null
null
null
liaison/forms.py
hhdMrLion/DJANGO_CRM
1f8d2d7a025f9dc54b5bf498e7a577469f74c612
[ "Apache-2.0" ]
null
null
null
import re from django import forms from customer.models import Customer from liaison.models import Liaison class LiaisonAddForm(forms.ModelForm): """联系人新增""" def __init__(self, request, customer, *args, **kwargs): super().__init__(*args, **kwargs) self.request = request self.fields['customer'].queryset = Customer.objects.filter(name=customer) class Meta: model = Liaison fields = ['name', 'customer', 'phone', 'job', 'injob', 'wx', 'qq', 'email', 'hobby', 'birthday', 'remarks'] def clean_phone(self): """验证用户输入的手机号""" phone = self.cleaned_data['phone'] # 判断用户名是否为手机号码 pattern = r'^1[0-9]{10}$' if not re.search(pattern, phone): raise forms.ValidationError('请输入正确的手机号码') return phone def save(self, commit=True): obj = super().save(commit=False) obj.user = self.request.user obj.save() class LiaisonEditForm(forms.ModelForm): """联系人修改""" def __init__(self, request, *args, **kwargs): super().__init__(*args, **kwargs) self.request = request class Meta: model = Liaison fields = ['name', 'customer', 'phone', 'job', 'injob', 'wx', 'qq', 'email', 'hobby', 'birthday', 'remarks'] def clean_phone(self): """验证用户输入的手机号""" phone = self.cleaned_data['phone'] # 判断用户名是否为手机号码 pattern = r'^1[0-9]{10}$' if not re.search(pattern, phone): raise forms.ValidationError('请输入正确的手机号码') return phone def save(self, commit=True): obj = super().save(commit=False) obj.user = self.request.user obj.save()
28.66129
82
0.556556
186
1,777
5.209677
0.327957
0.068111
0.022704
0.037152
0.72033
0.72033
0.72033
0.72033
0.72033
0.623323
0
0.008013
0.297693
1,777
61
83
29.131148
0.768429
0.033765
0
0.780488
0
0
0.104039
0
0
0
0
0
0
1
0.146341
false
0
0.097561
0
0.390244
0
0
0
0
null
0
0
0
0
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
cf380e3ade3fa8a4f697b4a49f7a1a4d12ea7986
47
py
Python
example_pkg/main.py
j5ew9/ExamplePackagePEP517
252eea2240e6bc90cdfe4f37f21b397d15f0c215
[ "MIT" ]
null
null
null
example_pkg/main.py
j5ew9/ExamplePackagePEP517
252eea2240e6bc90cdfe4f37f21b397d15f0c215
[ "MIT" ]
null
null
null
example_pkg/main.py
j5ew9/ExamplePackagePEP517
252eea2240e6bc90cdfe4f37f21b397d15f0c215
[ "MIT" ]
null
null
null
def main(): print("just example package")
11.75
33
0.638298
6
47
5
1
0
0
0
0
0
0
0
0
0
0
0
0.212766
47
3
34
15.666667
0.810811
0
0
0
0
0
0.434783
0
0
0
0
0
0
1
0.5
true
0
0
0
0.5
0.5
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
1
1
0
0
0
0
1
0
6
cf88ecaac421de66666443a4ca70c0e43911de3e
56
py
Python
Strings/Mutations.py
AbdallahHemdan/HackerRank-Python-Solutions
0e388b4f594a210426791246ca1278a6a872dd96
[ "MIT" ]
3
2020-01-03T11:39:24.000Z
2021-03-13T13:35:23.000Z
Strings/Mutations.py
AbdallahHemdan/HackerRank-Python-Solutions
0e388b4f594a210426791246ca1278a6a872dd96
[ "MIT" ]
null
null
null
Strings/Mutations.py
AbdallahHemdan/HackerRank-Python-Solutions
0e388b4f594a210426791246ca1278a6a872dd96
[ "MIT" ]
1
2018-10-20T09:36:06.000Z
2018-10-20T09:36:06.000Z
def mutate_string(s, p, c): return s[:p]+c+s[p+1:]
18.666667
27
0.553571
13
56
2.307692
0.615385
0.2
0.2
0
0
0
0
0
0
0
0
0.022222
0.196429
56
2
28
28
0.644444
0
0
0
0
0
0
0
0
0
0
0
0
1
0.5
false
0
0
0.5
1
0
1
0
0
null
0
1
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
1
0
0
0
1
1
0
0
6
d8742b5f3ac97ebe919d74d6f0f59ef3e54f4abf
750
py
Python
src/models/__init__.py
andrijaster/FAIR
cf4f3ced1f54c87d543ea1345f241ce338f7bea0
[ "MIT" ]
2
2022-02-25T22:38:30.000Z
2022-02-25T22:38:43.000Z
src/models/__init__.py
andrijaster/FAIR
cf4f3ced1f54c87d543ea1345f241ce338f7bea0
[ "MIT" ]
null
null
null
src/models/__init__.py
andrijaster/FAIR
cf4f3ced1f54c87d543ea1345f241ce338f7bea0
[ "MIT" ]
null
null
null
from .FAD import FAD_class # Fair Adversial Discriminative model from .FAIR_scalar import FAIR_scalar_class # Fair Adversarial Instance Re-weighting (not probabilistic) from .FAIR_Bernoulli import FAIR_Bernoulli_class # Fair Adversarial Instance Re-weighting with Bernoulli distribution (reparametrization) from .FAIR_betaSF import FAIR_betaSF_class # Fair Adversarial Instance Re-weighting with Beta distribution (score function) from .FAIR_betaREP import FAIR_betaREP_class # Fair Adversarial Instance Re-weighting with Beta distribution (reparametrization) from .LURMI import LURMI_class # Learning Unbiased Representations via Mutual Information backpropagation from .CLFR import CLFR_class # Conditional Learning of Fair Representations
93.75
138
0.845333
94
750
6.585106
0.37234
0.072698
0.129241
0.180937
0.323102
0.323102
0.260097
0.19063
0.19063
0
0
0
0.12
750
7
139
107.142857
0.937879
0.613333
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
0
0
0
null
0
0
1
0
0
0
0
0
0
0
0
0
0
1
0
1
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
d87a547b078ff1e23939c724135d6a3ec6c04e4b
48
py
Python
deco/schedules/__init__.py
mfojtak/decor
203979351635a6794c91200fca4a14296ec9bc37
[ "MIT" ]
1
2019-09-05T07:23:19.000Z
2019-09-05T07:23:19.000Z
deco/schedules/__init__.py
mfojtak/decor
203979351635a6794c91200fca4a14296ec9bc37
[ "MIT" ]
2
2020-10-25T17:41:08.000Z
2020-10-26T16:48:19.000Z
deco/schedules/__init__.py
mfojtak/deco
203979351635a6794c91200fca4a14296ec9bc37
[ "MIT" ]
null
null
null
from deco.schedules.warmup import WarmupSchedule
48
48
0.895833
6
48
7.166667
1
0
0
0
0
0
0
0
0
0
0
0
0.0625
48
1
48
48
0.955556
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
d87bac2629499a69b2f96733637d7208f1199610
26
py
Python
src/schctest/micro_enum/__init__.py
saguilarDevel/open_schc
ac7f2a84b6120964c8fdaabf9f5c8ca8ae39c289
[ "MIT" ]
21
2018-11-05T06:48:32.000Z
2022-02-28T14:38:09.000Z
src/schctest/micro_enum/__init__.py
saguilarDevel/open_schc
ac7f2a84b6120964c8fdaabf9f5c8ca8ae39c289
[ "MIT" ]
34
2019-01-28T01:32:41.000Z
2021-05-06T09:40:14.000Z
src/schctest/micro_enum/__init__.py
saguilarDevel/open_schc
ac7f2a84b6120964c8fdaabf9f5c8ca8ae39c289
[ "MIT" ]
28
2018-10-31T22:21:26.000Z
2022-03-17T09:44:40.000Z
from .micro_enum import *
13
25
0.769231
4
26
4.75
1
0
0
0
0
0
0
0
0
0
0
0
0.153846
26
1
26
26
0.863636
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
d891661bc917b1c04e57acf495dc06b6bf082b65
64
py
Python
acq4/drivers/MultiClamp/__init__.py
aleonlein/acq4
4b1fcb9ad2c5e8d4595a2b9cf99d50ece0c0f555
[ "MIT" ]
47
2015-01-05T16:18:10.000Z
2022-03-16T13:09:30.000Z
acq4/drivers/MultiClamp/__init__.py
aleonlein/acq4
4b1fcb9ad2c5e8d4595a2b9cf99d50ece0c0f555
[ "MIT" ]
48
2015-04-19T16:51:41.000Z
2022-03-31T14:48:16.000Z
acq4/drivers/MultiClamp/__init__.py
sensapex/acq4
9561ba73caff42c609bd02270527858433862ad8
[ "MIT" ]
32
2015-01-15T14:11:49.000Z
2021-07-15T13:44:52.000Z
from __future__ import print_function from .multiclamp import *
21.333333
37
0.84375
8
64
6.125
0.75
0
0
0
0
0
0
0
0
0
0
0
0.125
64
2
38
32
0.875
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0.5
1
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
1
0
6
d89db256818771d01163fab0c0a583b36892b4ff
21
py
Python
example_project/some_modules/third_modules/a194.py
Yuriy-Leonov/cython_imports_limit_issue
2f9e7c02798fb52185dabfe6ce3811c439ca2839
[ "MIT" ]
null
null
null
example_project/some_modules/third_modules/a194.py
Yuriy-Leonov/cython_imports_limit_issue
2f9e7c02798fb52185dabfe6ce3811c439ca2839
[ "MIT" ]
null
null
null
example_project/some_modules/third_modules/a194.py
Yuriy-Leonov/cython_imports_limit_issue
2f9e7c02798fb52185dabfe6ce3811c439ca2839
[ "MIT" ]
null
null
null
class A194: pass
7
11
0.619048
3
21
4.333333
1
0
0
0
0
0
0
0
0
0
0
0.214286
0.333333
21
2
12
10.5
0.714286
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0.5
0
0
0.5
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
1
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
1
0
0
0
0
0
6
d8a18bbb8fdfcd40164a176a9330974e6c0c1a45
12,090
py
Python
tests/test_detection.py
theovincent/ruptures
2bd37c2655bf4d20ef5a0797a5b22bd7ea5fc494
[ "BSD-2-Clause" ]
null
null
null
tests/test_detection.py
theovincent/ruptures
2bd37c2655bf4d20ef5a0797a5b22bd7ea5fc494
[ "BSD-2-Clause" ]
null
null
null
tests/test_detection.py
theovincent/ruptures
2bd37c2655bf4d20ef5a0797a5b22bd7ea5fc494
[ "BSD-2-Clause" ]
null
null
null
from copy import deepcopy from itertools import product import numpy as np import pytest from ruptures.costs import CostAR from ruptures.datasets import pw_constant from ruptures.detection import Binseg, BottomUp, Dynp, Pelt, Window, KernelCPD from ruptures.exceptions import BadSegmentationParameters @pytest.fixture(scope="module") def signal_bkps_5D_n10(): signal, bkps = pw_constant(n_samples=10, n_features=5, noise_std=1) return signal, bkps @pytest.fixture(scope="module") def signal_bkps_5D(): signal, bkps = pw_constant(n_features=5, noise_std=1) return signal, bkps @pytest.fixture(scope="module") def signal_bkps_1D(): signal, bkps = pw_constant(noise_std=1) return signal.astype(np.float32), bkps @pytest.fixture(scope="module") def signal_bkps_5D_no_noise(): signal, bkps = pw_constant(n_features=5, noise_std=0) return signal, bkps @pytest.fixture(scope="module") def signal_bkps_1D_no_noise(): signal, bkps = pw_constant(noise_std=0) return signal, bkps @pytest.fixture(scope="module") def signal_bkps_1D_constant(): signal, bkps = np.zeros(200), [200] return signal, bkps @pytest.mark.parametrize("algo", [Binseg, BottomUp, Dynp, Pelt, Window]) def test_empty(signal_bkps_1D, algo): signal, _ = signal_bkps_1D algo().fit(signal).predict(1) algo().fit_predict(signal, 1) @pytest.mark.parametrize( "algo, model", product( [Binseg, BottomUp, Window], ["l1", "l2", "ar", "normal", "rbf", "rank", "mahalanobis"], ), ) def test_model_1D(signal_bkps_1D, algo, model): signal, _ = signal_bkps_1D algo(model=model).fit_predict(signal, pen=1) ret = algo(model=model).fit_predict(signal, n_bkps=1) assert len(ret) == 2 assert ret[-1] == signal.shape[0] algo(model=model).fit_predict(signal, epsilon=10) @pytest.mark.parametrize( "algo, model", product([Dynp, Pelt], ["l1", "l2", "ar", "normal", "rbf", "rank", "mahalanobis"]), ) def test_model_1D_bis(signal_bkps_1D, algo, model): signal, _ = signal_bkps_1D algo_t = algo(model=model) ret = algo_t.fit_predict(signal, 1) if isinstance(algo_t, Dynp): assert len(ret) == 2 assert ret[-1] == signal.shape[0] @pytest.mark.parametrize( "algo, model", product( [Dynp, Binseg, BottomUp, Window, Pelt], ["l1", "l2", "ar", "normal", "rbf", "rank"], ), ) def test_model_1D_constant(signal_bkps_1D_constant, algo, model): signal, _ = signal_bkps_1D_constant algo = algo(model=model) if isinstance(algo, Dynp) or isinstance(algo, BottomUp) or isinstance(algo, Binseg): ret = algo.fit_predict(signal=signal, n_bkps=1) # Even with constant signals, return the specified number of # change-points. assert len(ret) == 2 if isinstance(algo, Window): ret = algo.fit_predict(signal=signal, n_bkps=1) # With constant signal, this search method returns 0 change-point. assert len(ret) == 1 if isinstance(algo, Pelt): ret = algo.fit_predict(signal=signal, pen=1) # With constant signal, this search method returns 0 change-point. assert len(ret) == 1 assert ret[-1] == signal.shape[0], "The last change-point is equal to" " n_samples." @pytest.mark.parametrize("algo", [Binseg, Window]) def test_costnormal_on_constant_old_behaviour(signal_bkps_1D_constant, algo): signal, _ = signal_bkps_1D_constant algo = algo(model="normal", params={"add_small_diag": False}) ret = algo.fit_predict(signal=signal, n_bkps=2) # With constant signal, this search method returns 0 change-point. assert len(ret) == 1 # The last change-point is equal to n_samples. assert ret[-1] == signal.shape[0], "The last change-point is equal to" " n_samples." @pytest.mark.parametrize( "algo, model", product( [Binseg, BottomUp, Window], ["l1", "l2", "linear", "normal", "rbf", "rank", "mahalanobis"], ), ) def test_model_5D(signal_bkps_5D, algo, model): signal, _ = signal_bkps_5D algo(model=model).fit_predict(signal, pen=1) ret = algo(model=model).fit_predict(signal, n_bkps=1) assert len(ret) == 2 algo(model=model).fit_predict(signal, epsilon=10) @pytest.mark.parametrize( "algo, model", product( [Dynp, Pelt], ["l1", "l2", "linear", "normal", "rbf", "rank", "mahalanobis"], ), ) def test_model_5D_bis(signal_bkps_5D, algo, model): signal, _ = signal_bkps_5D algo_t = algo(model=model) ret = algo_t.fit_predict(signal, 1) if isinstance(algo_t, Dynp): assert len(ret) == 2 @pytest.mark.parametrize("algo", [Binseg, BottomUp, Window, Dynp, Pelt]) def test_custom_cost(signal_bkps_1D, algo): signal, _ = signal_bkps_1D c = CostAR(order=10) algo_t = algo(custom_cost=c) ret = algo_t.fit_predict(signal, 1) if isinstance(algo_t, Pelt): assert len(ret) >= 2 else: assert len(ret) == 2 @pytest.mark.parametrize("algo", [Binseg, BottomUp, Window, Dynp, Pelt]) def test_pass_param_to_cost(signal_bkps_1D, algo): signal, _ = signal_bkps_1D algo_t = algo(model="ar", params={"order": 10}) ret = algo_t.fit_predict(signal, 1) if isinstance(algo_t, Pelt): assert len(ret) >= 2 else: assert len(ret) == 2 @pytest.mark.parametrize( "kernel, min_size", product(["linear"], [2, 5]), ) def test_kernelcpd_1D_linear(signal_bkps_1D, kernel, min_size): signal, bkps = signal_bkps_1D ret = ( KernelCPD(kernel=kernel, min_size=min_size, jump=1) .fit(signal) .predict(n_bkps=len(bkps) - 1) ) assert len(ret) == len(bkps) @pytest.mark.parametrize( "kernel, min_size", product(["linear"], [2, 5]), ) def test_kernelcpd_5D_linear(signal_bkps_5D, kernel, min_size): signal, bkps = signal_bkps_5D ret = ( KernelCPD(kernel=kernel, min_size=min_size, jump=1) .fit(signal) .predict(n_bkps=len(bkps) - 1) ) assert len(ret) == len(bkps) @pytest.mark.parametrize( "kernel, min_size", product(["rbf"], [2, 5]), ) def test_kernelcpd_1D_rbf(signal_bkps_1D, kernel, min_size): signal, bkps = signal_bkps_1D ret = ( KernelCPD(kernel=kernel, min_size=min_size, jump=1, params={"gamma": 1.5}) .fit(signal) .predict(n_bkps=len(bkps) - 1) ) assert len(ret) == len(bkps) @pytest.mark.parametrize( "kernel, min_size", product(["rbf"], [2, 5]), ) def test_kernelcpd_5D_rbf(signal_bkps_5D, kernel, min_size): signal, bkps = signal_bkps_5D ret = ( KernelCPD(kernel=kernel, min_size=min_size, jump=1, params={"gamma": 1.5}) .fit(signal) .predict(n_bkps=len(bkps) - 1) ) assert len(ret) == len(bkps) @pytest.mark.parametrize( "kernel, min_size", product(["linear"], [2, 5]), ) def test_kernelcpd_1D_no_noise_linear(signal_bkps_1D_no_noise, kernel, min_size): signal, bkps = signal_bkps_1D_no_noise res = ( KernelCPD(kernel=kernel, min_size=min_size, jump=1) .fit(signal) .predict(n_bkps=len(bkps) - 1) ) assert res == bkps @pytest.mark.parametrize( "kernel, min_size", product(["linear"], [2, 5]), ) def test_kernelcpd_5D_no_noise_linear(signal_bkps_5D_no_noise, kernel, min_size): signal, bkps = signal_bkps_5D_no_noise res = ( KernelCPD(kernel=kernel, min_size=min_size, jump=1) .fit(signal) .predict(n_bkps=len(bkps) - 1) ) assert res == bkps @pytest.mark.parametrize( "kernel, min_size", product(["rbf"], [2, 5]), ) def test_kernelcpd_1D_no_noise_rbf(signal_bkps_1D_no_noise, kernel, min_size): signal, bkps = signal_bkps_1D_no_noise res = ( KernelCPD(kernel=kernel, min_size=min_size, jump=1, params={"gamma": 1.5}) .fit(signal) .predict(n_bkps=len(bkps) - 1) ) assert res == bkps @pytest.mark.parametrize( "kernel, min_size", product(["rbf"], [2, 5]), ) def test_kernelcpd_5D_no_noise_rbf(signal_bkps_5D_no_noise, kernel, min_size): signal, bkps = signal_bkps_5D_no_noise res = ( KernelCPD(kernel=kernel, min_size=min_size, jump=1, params={"gamma": 1.5}) .fit(signal) .predict(n_bkps=len(bkps) - 1) ) assert res == bkps # Exhaustive test of KernelCPD @pytest.mark.parametrize("kernel", ["linear", "rbf", "cosine"]) def test_kernelcpd(signal_bkps_5D, kernel): signal, bkps = signal_bkps_5D # Test we do not compute if intermediary results exist algo_temp = KernelCPD(kernel=kernel) algo_temp.fit(signal).predict(n_bkps=len(bkps) - 1) algo_temp.predict(n_bkps=1) # Test penalized version KernelCPD(kernel=kernel).fit(signal).predict(pen=0.2) # Test fit_predict KernelCPD(kernel=kernel).fit_predict(signal, pen=0.2) @pytest.mark.parametrize("kernel", ["linear", "rbf", "cosine"]) def test_kernelcpd_small_signal(signal_bkps_5D_n10, kernel): signal, _ = signal_bkps_5D_n10 algo_temp = KernelCPD(kernel=kernel) with pytest.raises(BadSegmentationParameters): KernelCPD(kernel=kernel, min_size=10, jump=2).fit_predict(signal, n_bkps=2) with pytest.raises(AssertionError): KernelCPD(kernel=kernel, min_size=10, jump=2).fit_predict(signal, n_bkps=0) with pytest.raises(BadSegmentationParameters): KernelCPD(kernel=kernel, min_size=10, jump=2).fit_predict(signal, pen=0.2) assert ( len(KernelCPD(kernel=kernel, min_size=5, jump=2).fit_predict(signal, pen=0.2)) > 0 ) @pytest.mark.parametrize("kernel", ["linear", "rbf", "cosine"]) def test_kernelcpd_small_signal_same_result(signal_bkps_5D_n10, kernel): signal, _ = signal_bkps_5D_n10 algo = KernelCPD(kernel=kernel) list_of_segmentations = list() n_iter = 100 for _ in range(n_iter): bkps = algo.fit(signal=signal).predict(pen=1.0) list_of_segmentations.append(bkps) # test if all segmentations are equal first_bkps = list_of_segmentations[0] all_elements_are_equal = all( first_bkps == other_bkps for other_bkps in list_of_segmentations[1:] ) err_msg = "KernelCPD returns different segmentations on the same signal." assert all_elements_are_equal, err_msg @pytest.mark.parametrize( "algo, model", product( [Binseg, BottomUp, Window], ["l1", "l2", "ar", "normal", "rbf", "rank", "mahalanobis"], ), ) def test_model_small_signal(signal_bkps_5D_n10, algo, model): signal, _ = signal_bkps_5D_n10 with pytest.raises(BadSegmentationParameters): algo(model=model, min_size=5, jump=2).fit_predict(signal, n_bkps=2) assert ( len(algo(model=model, min_size=5, jump=2).fit_predict(signal, pen=10**6)) > 0 ) assert ( len(algo(model=model, min_size=5, jump=2).fit_predict(signal, epsilon=10)) > 0 ) assert ( len(algo(model=model, min_size=9, jump=2).fit_predict(signal, pen=10**6)) > 0 ) @pytest.mark.parametrize( "model", ["l1", "l2", "ar", "normal", "rbf", "rank", "mahalanobis"] ) def test_model_small_signal_dynp(signal_bkps_5D_n10, model): signal, _ = signal_bkps_5D_n10 with pytest.raises(BadSegmentationParameters): Dynp(model=model, min_size=5, jump=2).fit_predict(signal, 2) with pytest.raises(BadSegmentationParameters): Dynp(model=model, min_size=9, jump=2).fit_predict(signal, 2) with pytest.raises(BadSegmentationParameters): Dynp(model=model, min_size=11, jump=2).fit_predict(signal, 2) @pytest.mark.parametrize( "model", ["l1", "l2", "ar", "normal", "rbf", "rank", "mahalanobis"] ) def test_model_small_signal_pelt(signal_bkps_5D_n10, model): signal, _ = signal_bkps_5D_n10 with pytest.raises(BadSegmentationParameters): Pelt(model=model, min_size=11, jump=2).fit_predict(signal, 2) assert len(Pelt(model=model, min_size=10, jump=2).fit_predict(signal, 1.0)) > 0 def test_binseg_deepcopy(): binseg = Binseg() binseg_copy = deepcopy(binseg) assert id(binseg.single_bkp) != id(binseg_copy.single_bkp)
31.24031
88
0.669479
1,705
12,090
4.518475
0.090909
0.093458
0.060228
0.025312
0.807373
0.771937
0.748702
0.740395
0.704569
0.656931
0
0.028329
0.191232
12,090
386
89
31.321244
0.759562
0.038958
0
0.599359
0
0
0.06789
0
0
0
0
0
0.102564
1
0.096154
false
0.003205
0.025641
0
0.141026
0
0
0
0
null
0
0
0
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
d8b76bc731be69bcc0d64a5c3c587dc9815b187f
34
py
Python
perceptual_similarity/__init__.py
wilhelmhb/PerceptualSimilarity
bdeac239ca24064c0ac2a1c62e8ee539e75a27ff
[ "BSD-2-Clause" ]
1
2020-06-16T21:28:13.000Z
2020-06-16T21:28:13.000Z
perceptual_similarity/__init__.py
wilhelmhb/PerceptualSimilarity
bdeac239ca24064c0ac2a1c62e8ee539e75a27ff
[ "BSD-2-Clause" ]
null
null
null
perceptual_similarity/__init__.py
wilhelmhb/PerceptualSimilarity
bdeac239ca24064c0ac2a1c62e8ee539e75a27ff
[ "BSD-2-Clause" ]
null
null
null
from models import PerceptualLoss
17
33
0.882353
4
34
7.5
1
0
0
0
0
0
0
0
0
0
0
0
0.117647
34
1
34
34
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
d8cdf91c76ecf7e5ce4575fee510f91dcb0df964
50
py
Python
cw02/zad1.py
BartoszHolubowicz/projekt-psi
e1d753e543ed2676a21ba1d99191e36dbe484ae5
[ "bzip2-1.0.6" ]
null
null
null
cw02/zad1.py
BartoszHolubowicz/projekt-psi
e1d753e543ed2676a21ba1d99191e36dbe484ae5
[ "bzip2-1.0.6" ]
null
null
null
cw02/zad1.py
BartoszHolubowicz/projekt-psi
e1d753e543ed2676a21ba1d99191e36dbe484ae5
[ "bzip2-1.0.6" ]
null
null
null
def fun(l1, l2): return [*l1[::2], *l2[1::2]]
16.666667
32
0.46
10
50
2.3
0.7
0
0
0
0
0
0
0
0
0
0
0.175
0.2
50
2
33
25
0.4
0
0
0
0
0
0
0
0
0
0
0
0
1
0.5
false
0
0
0.5
1
0
1
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
1
0
0
0
0
0
0
0
null
0
0
0
0
0
1
0
0
0
1
1
0
0
6
2b28eba4063c14d306ae2ae56ca5f5f158f336d0
33
py
Python
retro_star/utils/__init__.py
cthoyt/retro_star
280231eb2f5dffc0e14bed300d770977b323205a
[ "MIT" ]
65
2020-06-27T04:28:21.000Z
2022-03-30T11:18:22.000Z
retro_star/utils/__init__.py
cthoyt/retro_star
280231eb2f5dffc0e14bed300d770977b323205a
[ "MIT" ]
15
2020-07-07T13:17:05.000Z
2022-03-22T12:52:29.000Z
retro_star/utils/__init__.py
cthoyt/retro_star
280231eb2f5dffc0e14bed300d770977b323205a
[ "MIT" ]
14
2020-06-30T09:22:13.000Z
2022-03-30T11:18:28.000Z
from .logger import setup_logger
16.5
32
0.848485
5
33
5.4
0.8
0
0
0
0
0
0
0
0
0
0
0
0.121212
33
1
33
33
0.931034
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
2b47783d3fea518b7086f2dd472d28ecba960f49
153
py
Python
telemetry/telescope_devkit/filesystem.py
hmrc/telescope-devkit
86bcc7ef808ea42bc29f56bc48b4c5f1f0cb2b73
[ "Apache-2.0" ]
1
2022-01-18T09:47:30.000Z
2022-01-18T09:47:30.000Z
telemetry/telescope_devkit/filesystem.py
hmrc/telescope-devkit
86bcc7ef808ea42bc29f56bc48b4c5f1f0cb2b73
[ "Apache-2.0" ]
3
2021-11-18T13:59:06.000Z
2022-03-31T15:59:55.000Z
telemetry/telescope_devkit/filesystem.py
hmrc/telescope-devkit
86bcc7ef808ea42bc29f56bc48b4c5f1f0cb2b73
[ "Apache-2.0" ]
1
2021-04-10T23:28:45.000Z
2021-04-10T23:28:45.000Z
import os def get_repo_path() -> str: return os.path.realpath( os.path.join(os.path.dirname(os.path.realpath(__file__)), "./../../") )
19.125
77
0.601307
21
153
4.095238
0.571429
0.27907
0.325581
0
0
0
0
0
0
0
0
0
0.189542
153
7
78
21.857143
0.693548
0
0
0
0
0
0.052288
0
0
0
0
0
0
1
0.2
true
0
0.2
0.2
0.6
0
1
0
0
null
1
1
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
0
1
0
0
0
6
99507b799c6b0c9bdbd9faa162e34c5b1c490ad5
117
py
Python
examples/keyboard/drivers/drivers.py
Breq16/vibrance_ctrl
93247f686b4e5e42d5f36b9d592fe9cd8322069e
[ "MIT" ]
null
null
null
examples/keyboard/drivers/drivers.py
Breq16/vibrance_ctrl
93247f686b4e5e42d5f36b9d592fe9cd8322069e
[ "MIT" ]
null
null
null
examples/keyboard/drivers/drivers.py
Breq16/vibrance_ctrl
93247f686b4e5e42d5f36b9d592fe9cd8322069e
[ "MIT" ]
null
null
null
import vibrance.driver.pygame_if drivers = [] drivers.append(vibrance.driver.pygame_if.PyGameDriver("PyGame Demo"))
23.4
69
0.803419
15
117
6.133333
0.6
0.304348
0.434783
0.478261
0
0
0
0
0
0
0
0
0.068376
117
4
70
29.25
0.844037
0
0
0
0
0
0.094017
0
0
0
0
0
0
1
0
false
0
0.333333
0
0.333333
0
1
0
0
null
1
1
1
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
0
0
1
0
0
0
0
6
99a97f531695848aa026ba944f3bb991c6aef185
20,328
py
Python
tests/unit_tests/api/auth_methods/test_approle.py
reimerp/hvac
306fe62473664deb076c9e3f1ed54da370d1541e
[ "Apache-2.0" ]
544
2018-07-23T08:17:41.000Z
2022-03-31T11:53:01.000Z
tests/unit_tests/api/auth_methods/test_approle.py
reimerp/hvac
306fe62473664deb076c9e3f1ed54da370d1541e
[ "Apache-2.0" ]
469
2018-07-22T18:50:04.000Z
2022-03-30T08:56:06.000Z
tests/unit_tests/api/auth_methods/test_approle.py
harrinry/hvac
bf899c6504704ad6d5f85c1d74361c6f6e1b5dfb
[ "Apache-2.0" ]
236
2018-07-24T16:59:47.000Z
2022-03-25T14:15:43.000Z
from unittest import TestCase import requests_mock from parameterized import parameterized from hvac import exceptions from hvac.adapters import JSONAdapter from hvac.api.auth_methods import AppRole from hvac.constants.approle import DEFAULT_MOUNT_POINT class TestAppRole(TestCase): @parameterized.expand( [ ("default mount point", DEFAULT_MOUNT_POINT, "default", None), ("custom mount point", "approle-test", "default", None), ( "bad token type", DEFAULT_MOUNT_POINT, "bad_token", exceptions.ParamValidationError, ), ] ) @requests_mock.Mocker() def test_create_or_update_approle( self, test_label, mount_point, token_type, raises, requests_mocker ): expected_status_code = 204 role_name = "testrole" mock_url = ( "http://localhost:8200/v1/auth/{mount_point}/role/{role_name}".format( mount_point=mount_point, role_name=role_name ) ) requests_mocker.register_uri( method="POST", url=mock_url, status_code=expected_status_code, ) app_role = AppRole(adapter=JSONAdapter()) if raises is not None: with self.assertRaises(raises) as cm: app_role.create_or_update_approle( role_name=role_name, token_policies=["default"], token_type=token_type, mount_point=mount_point, ) self.assertIn(member="unsupported token_type", container=str(cm.exception)) else: response = app_role.create_or_update_approle( role_name=role_name, token_policies=["default"], mount_point=mount_point ) self.assertEqual(first=expected_status_code, second=response.status_code) @parameterized.expand( [ ("default mount point", DEFAULT_MOUNT_POINT), ("custom mount point", "approle-test"), ] ) @requests_mock.Mocker() def test_list_roles(self, test_label, mount_point, requests_mocker): expected_status_code = 200 mock_response = { "auth": None, "data": {"keys": ["testrole"]}, "lease_duration": 0, "lease_id": "", "renewable": False, "request_id": "860a11a8-b835-cbab-7fce-de4edc4cf533", "warnings": None, "wrap_info": None, } mock_url = "http://localhost:8200/v1/auth/{mount_point}/role".format( mount_point=mount_point ) requests_mocker.register_uri( method="LIST", url=mock_url, status_code=expected_status_code, json=mock_response, ) app_role = AppRole(adapter=JSONAdapter()) response = app_role.list_roles(mount_point=mount_point) self.assertEqual(first=mock_response, second=response) @parameterized.expand( [ ("default mount point", DEFAULT_MOUNT_POINT), ("custom mount point", "approle-test"), ] ) @requests_mock.Mocker() def test_read_role(self, test_label, mount_point, requests_mocker): expected_status_code = 200 role_name = "testrole" mock_response = { "auth": None, "data": { "bind_secret_id": True, "local_secret_ids": False, "secret_id_bound_cidrs": None, "secret_id_num_uses": 0, "secret_id_ttl": 0, "token_bound_cidrs": None, "token_explicit_max_ttl": 0, "token_max_ttl": 0, "token_no_default_poolicy": False, "token_num_uses": 0, "token_period": 14400, "token_policies": None, "token_ttl": 0, "token_type": "default", }, "lease_duration": 0, "lease_id": "", "renewable": False, "request_id": "860a11a8-b835-cbab-7fce-de4edc4cf533", "warnings": None, "wrap_info": None, } mock_url = ( "http://localhost:8200/v1/auth/{mount_point}/role/{role_name}".format( mount_point=mount_point, role_name=role_name ) ) requests_mocker.register_uri( method="GET", url=mock_url, status_code=expected_status_code, json=mock_response, ) app_role = AppRole(adapter=JSONAdapter()) response = app_role.read_role(role_name="testrole", mount_point=mount_point) self.assertEqual(first=mock_response, second=response) @parameterized.expand( [ ("default mount point", DEFAULT_MOUNT_POINT), ("custom mount point", "approle-test"), ] ) @requests_mock.Mocker() def test_delete_role(self, test_label, mount_point, requests_mocker): expected_status_code = 204 role_name = "testrole" mock_url = ( "http://localhost:8200/v1/auth/{mount_point}/role/{role_name}".format( mount_point=mount_point, role_name=role_name ) ) requests_mocker.register_uri( method="DELETE", url=mock_url, status_code=expected_status_code, ) app_role = AppRole(adapter=JSONAdapter()) response = app_role.delete_role(role_name=role_name, mount_point=mount_point) self.assertEqual(first=expected_status_code, second=response.status_code) @parameterized.expand( [ ("default mount point", DEFAULT_MOUNT_POINT), ("custom mount point", "approle-test"), ] ) @requests_mock.Mocker() def test_read_role_id(self, test_label, mount_point, requests_mocker): expected_status_code = 200 role_name = "testrole" mock_response = { "auth": None, "data": {"role_id": "e5a7b66e-5d08-da9c-7075-71984634b882"}, "lease_duration": 0, "lease_id": "", "renewable": False, "request_id": "860a11a8-b835-cbab-7fce-de4edc4cf533", "warnings": None, "wrap_info": None, } mock_url = "http://localhost:8200/v1/auth/{mount_point}/role/{role_name}/role-id".format( mount_point=mount_point, role_name=role_name ) requests_mocker.register_uri( method="GET", url=mock_url, status_code=expected_status_code, json=mock_response, ) app_role = AppRole(adapter=JSONAdapter()) response = app_role.read_role_id(role_name=role_name, mount_point=mount_point) self.assertEqual(first=mock_response, second=response) @parameterized.expand( [ ("default mount point", DEFAULT_MOUNT_POINT), ("custom mount point", "approle-test"), ] ) @requests_mock.Mocker() def test_update_role_id(self, test_label, mount_point, requests_mocker): expected_status_code = 200 role_name = "testrole" role_id = "test_role_id" mock_response = { "auth": None, "data": {"role_id": role_id}, "lease_duration": 0, "lease_id": "", "renewable": False, "request_id": "860a11a8-b835-cbab-7fce-de4edc4cf533", "warnings": None, "wrap_info": None, } mock_url = "http://localhost:8200/v1/auth/{mount_point}/role/{role_name}/role-id".format( mount_point=mount_point, role_name=role_name ) requests_mocker.register_uri( method="POST", url=mock_url, status_code=expected_status_code, json=mock_response, ) app_role = AppRole(adapter=JSONAdapter()) response = app_role.update_role_id( role_name=role_name, role_id=role_id, mount_point=mount_point ) self.assertEqual(first=mock_response, second=response) @parameterized.expand( [ ("default mount point", DEFAULT_MOUNT_POINT, None), ("custom mount point", "approle-test", exceptions.ParamValidationError), ] ) @requests_mock.Mocker() def test_generate_secret_id(self, test_label, mount_point, raises, requests_mocker): expected_status_code = 200 role_name = "testrole" mock_response = { "auth": None, "data": { "secret_id": "841771dc-11c9-bbc7-bcac-6a3945a69cd9", "secret_id_accessor": "84896a0c-1347-aa90-a4f6-aca8b7558780", }, "lease_duration": 0, "lease_id": "", "renewable": False, "request_id": "860a11a8-b835-cbab-7fce-de4edc4cf533", "warnings": None, "wrap_info": None, } mock_url = "http://localhost:8200/v1/auth/{mount_point}/role/{role_name}/secret-id".format( mount_point=mount_point, role_name=role_name ) requests_mocker.register_uri( method="POST", url=mock_url, status_code=expected_status_code, json=mock_response, ) app_role = AppRole(adapter=JSONAdapter()) if raises is not None: with self.assertRaises(raises) as cm: app_role.generate_secret_id( role_name=role_name, metadata="metadata string", mount_point=mount_point, ) self.assertIn( member="unsupported metadata argument", container=str(cm.exception) ) else: response = app_role.generate_secret_id( role_name=role_name, cidr_list=["127.0.0.1/32"], mount_point=mount_point ) self.assertEqual(first=mock_response, second=response) @parameterized.expand( [ ("default mount point", DEFAULT_MOUNT_POINT, None), ("custom mount point", "approle-test", exceptions.ParamValidationError), ] ) @requests_mock.Mocker() def test_create_custom_secret_id( self, test_label, mount_point, raises, requests_mocker ): expected_status_code = 200 role_name = "testrole" secret_id = "custom_secret" mock_response = { "auth": None, "data": { "secret_id": secret_id, "secret_id_accessor": "84896a0c-1347-aa90-a4f6-aca8b7558780", }, "lease_duration": 0, "lease_id": "", "renewable": False, "request_id": "860a11a8-b835-cbab-7fce-de4edc4cf533", "warnings": None, "wrap_info": None, } mock_url = "http://localhost:8200/v1/auth/{mount_point}/role/{role_name}/custom-secret-id".format( mount_point=mount_point, role_name=role_name ) requests_mocker.register_uri( method="POST", url=mock_url, status_code=expected_status_code, json=mock_response, ) app_role = AppRole(adapter=JSONAdapter()) if raises is not None: with self.assertRaises(raises) as cm: app_role.create_custom_secret_id( role_name=role_name, secret_id=secret_id, cidr_list=["127.0.0.1/32"], metadata="metadata string", mount_point=mount_point, ) self.assertIn( member="unsupported metadata argument", container=str(cm.exception) ) else: response = app_role.create_custom_secret_id( role_name=role_name, secret_id=secret_id, cidr_list=["127.0.0.1/32"], mount_point=mount_point, ) self.assertEqual(first=mock_response, second=response) @parameterized.expand( [ ("default mount point", DEFAULT_MOUNT_POINT), ("custom mount point", "approle-test"), ] ) @requests_mock.Mocker() def test_read_secret_id(self, test_label, mount_point, requests_mocker): expected_status_code = 200 role_name = "testrole" secret_id = "custom_secret" mock_response = { "auth": None, "data": { "secret_id": secret_id, "secret_id_accessor": "84896a0c-1347-aa90-a4f6-aca8b7558780", }, "lease_duration": 0, "lease_id": "", "renewable": False, "request_id": "860a11a8-b835-cbab-7fce-de4edc4cf533", "warnings": None, "wrap_info": None, } mock_url = "http://localhost:8200/v1/auth/{mount_point}/role/{role_name}/secret-id/lookup".format( mount_point=mount_point, role_name=role_name ) requests_mocker.register_uri( method="POST", url=mock_url, status_code=expected_status_code, json=mock_response, ) app_role = AppRole(adapter=JSONAdapter()) response = app_role.read_secret_id( role_name=role_name, secret_id=secret_id, mount_point=mount_point ) self.assertEqual(first=mock_response, second=response) @parameterized.expand( [ ("default mount point", DEFAULT_MOUNT_POINT), ("custom mount point", "approle-test"), ] ) @requests_mock.Mocker() def test_destroy_secret_id(self, test_label, mount_point, requests_mocker): expected_status_code = 204 role_name = "testrole" secret_id = "custom_secret" mock_url = "http://localhost:8200/v1/auth/{mount_point}/role/{role_name}/secret-id/destroy".format( mount_point=mount_point, role_name=role_name ) requests_mocker.register_uri( method="POST", url=mock_url, status_code=expected_status_code, ) app_role = AppRole(adapter=JSONAdapter()) response = app_role.destroy_secret_id( role_name=role_name, secret_id=secret_id, mount_point=mount_point ) self.assertEqual(first=expected_status_code, second=response.status_code) @parameterized.expand( [ ("default mount point", DEFAULT_MOUNT_POINT), ("custom mount point", "approle-test"), ] ) @requests_mock.Mocker() def test_list_secret_id_accessors(self, test_label, mount_point, requests_mocker): expected_status_code = 200 role_name = "testrole" mock_response = { "auth": None, "data": { "keys": [ "ce102d2a-8253-c437-bf9a-aceed4241491", "a1c8dee4-b869-e68d-3520-2040c1a0849a", "be83b7e2-044c-7244-07e1-47560ca1c787", "84896a0c-1347-aa90-a4f6-aca8b7558780", "239b1328-6523-15e7-403a-a48038cdc45a", ] }, "lease_duration": 0, "lease_id": "", "renewable": False, "request_id": "860a11a8-b835-cbab-7fce-de4edc4cf533", "warnings": None, "wrap_info": None, } mock_url = "http://localhost:8200/v1/auth/{mount_point}/role/{role_name}/secret-id".format( mount_point=mount_point, role_name=role_name ) requests_mocker.register_uri( method="LIST", url=mock_url, status_code=expected_status_code, json=mock_response, ) app_role = AppRole(adapter=JSONAdapter()) response = app_role.list_secret_id_accessors( role_name=role_name, mount_point=mount_point ) self.assertEqual(first=mock_response, second=response) @parameterized.expand( [ ("default mount point", DEFAULT_MOUNT_POINT), ("custom mount point", "approle-test"), ] ) @requests_mock.Mocker() def test_read_secret_id_accessor(self, test_label, mount_point, requests_mocker): expected_status_code = 200 role_name = "testrole" secret_id = "custom_secret" secret_id_accessor = "84896a0c-1347-aa90-a4f6-aca8b7558780" mock_response = { "auth": None, "data": { "secret_id": secret_id, "secret_id_accessor": "84896a0c-1347-aa90-a4f6-aca8b7558780", }, "lease_duration": 0, "lease_id": "", "renewable": False, "request_id": "860a11a8-b835-cbab-7fce-de4edc4cf533", "warnings": None, "wrap_info": None, } mock_url = "http://localhost:8200/v1/auth/{mount_point}/role/{role_name}/secret-id-accessor/lookup".format( mount_point=mount_point, role_name=role_name ) requests_mocker.register_uri( method="POST", url=mock_url, status_code=expected_status_code, json=mock_response, ) app_role = AppRole(adapter=JSONAdapter()) response = app_role.read_secret_id_accessor( role_name=role_name, secret_id_accessor=secret_id_accessor, mount_point=mount_point, ) self.assertEqual(first=mock_response, second=response) @parameterized.expand( [ ("default mount point", DEFAULT_MOUNT_POINT), ("custom mount point", "approle-test"), ] ) @requests_mock.Mocker() def test_destroy_secret_id_accessor(self, test_label, mount_point, requests_mocker): expected_status_code = 204 role_name = "testrole" secret_id_accessor = "84896a0c-1347-aa90-a4f6-aca8b7558780" mock_url = "http://localhost:8200/v1/auth/{mount_point}/role/{role_name}/secret-id-accessor/destroy".format( mount_point=mount_point, role_name=role_name ) requests_mocker.register_uri( method="POST", url=mock_url, status_code=expected_status_code, ) app_role = AppRole(adapter=JSONAdapter()) response = app_role.destroy_secret_id_accessor( role_name=role_name, secret_id_accessor=secret_id_accessor, mount_point=mount_point, ) self.assertEqual(first=expected_status_code, second=response.status_code) @parameterized.expand( [ ("default mount point", DEFAULT_MOUNT_POINT), ("custom mount point", "approle-test"), ] ) @requests_mock.Mocker() def test_login(self, test_label, mount_point, requests_mocker): expected_status_code = 200 role_id = "test_role_id" secret_id = "custom_secret" mock_response = { "data": None, "auth": { "renewable": True, "lease_duration": 1200, "metadata": None, "token_policies": ["default"], "accessor": "fd6c9a00-d2dc-3b11-0be5-af7ae0e1d374", "client_token": "5b1a0318-679c-9c45-e5c6-d1b9a9035d49", }, "lease_duration": 0, "lease_id": "", "renewable": False, "request_id": "860a11a8-b835-cbab-7fce-de4edc4cf533", "warnings": None, "wrap_info": None, } mock_url = "http://localhost:8200/v1/auth/{mount_point}/login".format( mount_point=mount_point, ) requests_mocker.register_uri( method="POST", url=mock_url, status_code=expected_status_code, json=mock_response, ) app_role = AppRole(adapter=JSONAdapter()) response = app_role.login( role_id=role_id, secret_id=secret_id, mount_point=mount_point ) self.assertEqual(first=mock_response, second=response)
33.88
116
0.56951
2,086
20,328
5.232982
0.083893
0.122756
0.052767
0.056797
0.89978
0.891993
0.880542
0.876512
0.85993
0.8428
0
0.045991
0.325069
20,328
599
117
33.936561
0.749636
0
0
0.620818
0
0.009294
0.200905
0.04757
0
0
0
0
0.037175
1
0.026022
false
0
0.013011
0
0.040892
0
0
0
0
null
0
0
0
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
41f187a29a6bf2c3e4eacdb4d15521d2e73bc273
399
py
Python
geotrek/core/tests/__init__.py
jmdecastel/GEOTADMIN
15547c0a99ae4c541ca517cdbc2cf17ab5c96f87
[ "BSD-2-Clause" ]
null
null
null
geotrek/core/tests/__init__.py
jmdecastel/GEOTADMIN
15547c0a99ae4c541ca517cdbc2cf17ab5c96f87
[ "BSD-2-Clause" ]
null
null
null
geotrek/core/tests/__init__.py
jmdecastel/GEOTADMIN
15547c0a99ae4c541ca517cdbc2cf17ab5c96f87
[ "BSD-2-Clause" ]
null
null
null
from .test_triggers import * # NOQA from .test_views import * # NOQA from .test_factories import * # NOQA from .test_path_filter import * # NOQA from .test_topology import * # NOQA from .test_path_split import * # NOQA from .test_filters import * # NOQA from .test_graph import * # NOQA from .test_forms import * # NOQA from .test_fields import * # NOQA from .test_models import * # NOQA
33.25
39
0.724311
57
399
4.842105
0.280702
0.318841
0.507246
0.652174
0.15942
0
0
0
0
0
0
0
0.192982
399
11
40
36.272727
0.857143
0.135338
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
0
0
0
null
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
41f78e3197b2675cacb8ee4688c1daf1da7756c4
28
py
Python
Section 6/6.5 Start/main.py
chenjianAgain/Full-Stack-Web-Development-with-Flask
e110b0b649c19a9fd11ae70311cbf03727640921
[ "MIT" ]
14
2019-10-24T16:14:29.000Z
2021-12-29T16:44:21.000Z
Section 6/6.5 Start/main.py
chenjianAgain/Full-Stack-Web-Development-with-Flask
e110b0b649c19a9fd11ae70311cbf03727640921
[ "MIT" ]
6
2019-10-03T08:03:00.000Z
2021-08-14T12:36:11.000Z
Section 6/6.5 Start/main.py
chenjianAgain/Full-Stack-Web-Development-with-Flask
e110b0b649c19a9fd11ae70311cbf03727640921
[ "MIT" ]
29
2019-03-31T00:19:44.000Z
2022-02-07T11:12:24.000Z
from application import app
14
27
0.857143
4
28
6
1
0
0
0
0
0
0
0
0
0
0
0
0.142857
28
2
27
14
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
5126109ebb18c6329572ec7d7ade0aa493ab7e28
213
py
Python
tests/conftest.py
iamareebjamal/flask-combo-jsonapi
35a5e35de8c94fd5d9d24492c8b00f6cb2ea5e4a
[ "MIT" ]
15
2020-05-02T05:05:03.000Z
2022-01-10T18:32:23.000Z
tests/conftest.py
iamareebjamal/flask-combo-jsonapi
35a5e35de8c94fd5d9d24492c8b00f6cb2ea5e4a
[ "MIT" ]
48
2020-04-21T17:32:58.000Z
2022-03-02T20:55:19.000Z
tests/conftest.py
iamareebjamal/flask-combo-jsonapi
35a5e35de8c94fd5d9d24492c8b00f6cb2ea5e4a
[ "MIT" ]
14
2020-05-17T11:08:14.000Z
2021-12-16T09:28:32.000Z
import pytest from flask import Flask @pytest.fixture(scope="session") def app(): app = Flask(__name__) return app @pytest.yield_fixture(scope="session") def client(app): return app.test_client()
14.2
38
0.70892
29
213
5
0.482759
0.165517
0.262069
0.303448
0
0
0
0
0
0
0
0
0.169014
213
14
39
15.214286
0.819209
0
0
0
0
0
0.065728
0
0
0
0
0
0
1
0.222222
false
0
0.222222
0.111111
0.666667
0
1
0
0
null
0
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
1
0
0
0
1
1
0
0
6
512e7af1fc1797b067b5be9983ccdd0ed9664b40
47
py
Python
jupyterlab_gitsync/jupyterlab_gitsync/handlers.py
angelakuo/jupyter-extensions
06efeb0240e7bbba59b8dc7b4941ab4301737471
[ "Apache-2.0" ]
39
2020-06-04T14:42:21.000Z
2021-11-16T10:03:02.000Z
jupyterlab_gitsync/jupyterlab_gitsync/handlers.py
angelakuo/jupyter-extensions
06efeb0240e7bbba59b8dc7b4941ab4301737471
[ "Apache-2.0" ]
161
2020-05-30T01:13:05.000Z
2022-02-06T10:04:14.000Z
jupyterlab_gitsync/jupyterlab_gitsync/handlers.py
mwiewior/jupyter-extensions
b928265ee22246ac2761a5439b8363e98ec735e6
[ "Apache-2.0" ]
28
2020-06-05T20:38:09.000Z
2021-11-25T20:03:40.000Z
from jupyterlab_gitsync.git_handlers import *
23.5
46
0.851064
6
47
6.333333
1
0
0
0
0
0
0
0
0
0
0
0
0.106383
47
1
47
47
0.904762
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
5a9cb4c86ad9db08bbbc6d5a2743d984f45c2e58
24
py
Python
apps/polls/views/__init__.py
Eduardo-RFarias/Django-docs-tutorial
b4af94baf946b3b6b823b1f971cb905c061c03ec
[ "MIT" ]
null
null
null
apps/polls/views/__init__.py
Eduardo-RFarias/Django-docs-tutorial
b4af94baf946b3b6b823b1f971cb905c061c03ec
[ "MIT" ]
null
null
null
apps/polls/views/__init__.py
Eduardo-RFarias/Django-docs-tutorial
b4af94baf946b3b6b823b1f971cb905c061c03ec
[ "MIT" ]
null
null
null
from .PoolCRUD import *
12
23
0.75
3
24
6
1
0
0
0
0
0
0
0
0
0
0
0
0.166667
24
1
24
24
0.9
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
5ac2978767e59d2c9ef1a377dbbc09eccbe8d125
226
py
Python
django_mri/models/choices/__init__.py
GalBenZvi/django_mri
558e9187a6ba18b7ba69aced919a6f94d066a2fc
[ "Apache-2.0" ]
4
2020-07-27T20:33:54.000Z
2022-01-11T20:24:03.000Z
django_mri/models/choices/__init__.py
GalBenZvi/django_mri
558e9187a6ba18b7ba69aced919a6f94d066a2fc
[ "Apache-2.0" ]
107
2019-09-04T11:38:46.000Z
2022-03-04T13:59:51.000Z
django_mri/models/choices/__init__.py
GalBenZvi/django_mri
558e9187a6ba18b7ba69aced919a6f94d066a2fc
[ "Apache-2.0" ]
2
2020-05-24T06:35:33.000Z
2020-06-14T13:15:32.000Z
""" Choice ENUMs for easier maintenance of CharField's choice parameters. """ from django_mri.models.choices.scanning_sequence import ScanningSequence from django_mri.models.choices.sequence_variant import SequenceVariant
25.111111
72
0.836283
28
226
6.607143
0.714286
0.108108
0.140541
0.205405
0.281081
0
0
0
0
0
0
0
0.10177
226
8
73
28.25
0.91133
0.30531
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
0
0
null
0
0
1
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
5ad1d1d129ee697a259d4b093b71075cc3d15fc8
157
py
Python
Controller/ZO/__init__.py
colindomoney-hardware/ZeroOne
3e02f7b7ba1957ab4c35abeba228e40a8a06e810
[ "MIT" ]
null
null
null
Controller/ZO/__init__.py
colindomoney-hardware/ZeroOne
3e02f7b7ba1957ab4c35abeba228e40a8a06e810
[ "MIT" ]
4
2021-06-08T19:58:45.000Z
2022-03-08T21:09:20.000Z
Controller/ZO/__init__.py
colindomoney/ZeroOne
3e02f7b7ba1957ab4c35abeba228e40a8a06e810
[ "MIT" ]
null
null
null
print('__init__ in ZO') # TODO : These * imports are going to clutter the root namespace ... from ZO.zero_one import * from ZO.Image import * import ZO.ui
19.625
68
0.719745
26
157
4.153846
0.769231
0.111111
0
0
0
0
0
0
0
0
0
0
0.184713
157
7
69
22.428571
0.84375
0.420382
0
0
0
0
0.159091
0
0
0
0
0.142857
0
1
0
true
0
0.75
0
0.75
0.25
1
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
1
0
0
0
1
0
1
0
1
0
0
6
852a00ffb3cf9a75fd2755fbf46022d7ef06a0e9
4,905
py
Python
functions/basic_functions.py
raghuvarapadma/streaming_movies_shows
6e1717c1042b07be95c61f955245564c2d781386
[ "MIT" ]
null
null
null
functions/basic_functions.py
raghuvarapadma/streaming_movies_shows
6e1717c1042b07be95c61f955245564c2d781386
[ "MIT" ]
null
null
null
functions/basic_functions.py
raghuvarapadma/streaming_movies_shows
6e1717c1042b07be95c61f955245564c2d781386
[ "MIT" ]
null
null
null
# adds in Platform column into datatable which represents on what platforms the show or movie is availble on def plat(row): string = '' if row['Netflix'] == 1: if string == '': string+='Netflix' else: string+=',Netflix' if row['Hulu'] == 1: if string == '': string+='Hulu' else: string+=',Hulu' if row['Prime Video'] == 1: if string == '': string+='Prime Video' else: string+=',Prime Video' if row['Disney+'] == 1: if string == '': string+='Disney+' else: string+=',Disney+' return string def taking_input_movies(user_arr,data): while True: try: param = input('Which parameter would you like to search by? Search by Title, Year, Age, Rating, Directors, Genres, Country, Language, Runtime, Platform. ') except TypeError: print('Please input a valid answer!') continue else: if (param in data.columns) or (param == 'Rating'): user_arr.append(param) while True: try: repeat = input('Would you like to search for another parameter? ') except TypeError: print('Please input an integer!') continue else: if repeat.lower() == 'yes': return taking_input_movies(user_arr,data) break elif repeat.lower() == 'no': return user_arr break else: print('Please enter a valid input!') continue else: print('Please enter a valid input!') continue return user_arr def taking_input_shows(user_arr,data): while True: try: param = input('Which parameter would you like to search by? Search by Title, Year, Age, Rating, Platform. ') except TypeError: print('Please input a valid answer!') continue else: if (param in data.columns) or (param == 'Rating'): user_arr.append(param) while True: try: repeat = input('Would you like to search for another parameter? ') except TypeError: print('Please input an integer!') continue else: if repeat.lower() == 'yes': return taking_input_shows(user_arr,data) break elif repeat.lower() == 'no': return user_arr break else: print('Please enter a valid input!') continue else: print('Please enter a valid input!') continue return user_arr def sorting_data_movies(data): while True: try: param = input('Which parameter would you like to sort the data by? Search by Title, Year, Age, IMDb, Rotten Tomatoes, Directors, Genres, Country, Language, Runtime, Platform. ') except TypeError: print('Please input a valid answer!') continue else: if param in data.columns: return param break else: print('Please input a valid answer!') continue def sorting_data_shows(data): while True: try: param = input('Which parameter would you like to sort the data by? Search by Title, Year, Age, IMDb, Rotten Tomatoes, Platform. ') except TypeError: print('Please input a valid answer!') continue else: if param in data.columns: return param break else: print('Please input a valid answer!') continue def data_to_csv(data): while True: try: copy = input('Do you want to copy to a .csv file? ') except: print('Please enter a valid input!') else: if copy.lower() == 'yes': print('Here is your .csv file!') data.to_csv('Movies and Streaming.csv') break elif copy.lower() == 'no': print('You did not want to convert to a .csv file!') break else: print('Please enter a valid input!') continue
36.604478
189
0.459939
480
4,905
4.647917
0.197917
0.069027
0.057373
0.037651
0.755267
0.755267
0.723442
0.723442
0.723442
0.70372
0
0.001508
0.459123
4,905
134
190
36.604478
0.839427
0.021611
0
0.742188
0
0.03125
0.254273
0
0
0
0
0
0
1
0.046875
false
0
0
0
0.117188
0.125
0
0
0
null
0
0
0
0
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
518dfd66ec08f00dc11db6ca2c41b813e1e16729
157
py
Python
tests/basics/string_strip.py
mgglcode/micro-python
8c1bec4ae75d4d042a6fdeda00f7e1e495ed14e9
[ "MIT" ]
1
2015-06-15T11:52:01.000Z
2015-06-15T11:52:01.000Z
tests/basics/string_strip.py
mgglcode/micro-python
8c1bec4ae75d4d042a6fdeda00f7e1e495ed14e9
[ "MIT" ]
null
null
null
tests/basics/string_strip.py
mgglcode/micro-python
8c1bec4ae75d4d042a6fdeda00f7e1e495ed14e9
[ "MIT" ]
null
null
null
print("".strip()) print(" \t\n\r\v\f".strip()) print(" T E S T".strip()) print("abcabc".strip("ce")) print("aaa".strip("b")) print("abc efg ".strip("g a"))
22.428571
31
0.566879
29
157
3.068966
0.586207
0.337079
0.247191
0
0
0
0
0
0
0
0
0
0.095541
157
6
32
26.166667
0.626761
0
0
0
0
0
0.273885
0
0
0
0
0
0
1
0
true
0
0
0
0
1
1
0
0
null
1
1
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
0
0
0
1
0
6
51f5c5835b32785597a5dc44ea3324c4980442ab
82
py
Python
kaolin/io/__init__.py
T0mt0mp/kaolin
57d1e1478eec8df49dc7cc492f25637cec40399f
[ "ECL-2.0", "Apache-2.0" ]
1
2021-04-02T17:48:05.000Z
2021-04-02T17:48:05.000Z
kaolin/io/__init__.py
T0mt0mp/kaolin
57d1e1478eec8df49dc7cc492f25637cec40399f
[ "ECL-2.0", "Apache-2.0" ]
null
null
null
kaolin/io/__init__.py
T0mt0mp/kaolin
57d1e1478eec8df49dc7cc492f25637cec40399f
[ "ECL-2.0", "Apache-2.0" ]
null
null
null
from . import dataset from . import materials from . import obj from . import usd
16.4
23
0.756098
12
82
5.166667
0.5
0.645161
0
0
0
0
0
0
0
0
0
0
0.195122
82
4
24
20.5
0.939394
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
0
0
null
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
a40045ac6795db5522019a74d5443924c91d5a2f
95
py
Python
app/utils/states.py
edementyev/aiogram-chatbot-template
a3c0b3b7c2f7f57e5c8ffee8e48e10aa6bf89101
[ "MIT" ]
1
2020-10-07T12:09:21.000Z
2020-10-07T12:09:21.000Z
app/utils/states.py
edementyev/aiogram-chatbot-template
a3c0b3b7c2f7f57e5c8ffee8e48e10aa6bf89101
[ "MIT" ]
null
null
null
app/utils/states.py
edementyev/aiogram-chatbot-template
a3c0b3b7c2f7f57e5c8ffee8e48e10aa6bf89101
[ "MIT" ]
null
null
null
from aiogram.dispatcher.filters.state import StatesGroup class States(StatesGroup): pass
15.833333
56
0.8
11
95
6.909091
0.909091
0
0
0
0
0
0
0
0
0
0
0
0.136842
95
5
57
19
0.926829
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0.333333
0.333333
0
0.666667
0
1
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
1
1
0
1
0
0
6
a4029434386a37498c80316b3b152a6337f4aa0f
42
py
Python
recipes/psutil/run_test.py
pelson/RaspberryPi-conda
757a94dc17d76fbe9203dcec45172e19b2c84e22
[ "BSD-3-Clause" ]
null
null
null
recipes/psutil/run_test.py
pelson/RaspberryPi-conda
757a94dc17d76fbe9203dcec45172e19b2c84e22
[ "BSD-3-Clause" ]
null
null
null
recipes/psutil/run_test.py
pelson/RaspberryPi-conda
757a94dc17d76fbe9203dcec45172e19b2c84e22
[ "BSD-3-Clause" ]
null
null
null
import psutil print(psutil.cpu_times())
8.4
25
0.761905
6
42
5.166667
0.833333
0
0
0
0
0
0
0
0
0
0
0
0.119048
42
4
26
10.5
0.837838
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
0.5
0
0.5
0.5
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
0
1
0
6
32076fb3c140795781d160cffa965995ee916664
13,867
py
Python
models/decoder.py
okwrtdsh/3D-ResNets-PyTorch
f36a32ea8b283524d1d102937c49689b1f475b5f
[ "MIT" ]
null
null
null
models/decoder.py
okwrtdsh/3D-ResNets-PyTorch
f36a32ea8b283524d1d102937c49689b1f475b5f
[ "MIT" ]
null
null
null
models/decoder.py
okwrtdsh/3D-ResNets-PyTorch
f36a32ea8b283524d1d102937c49689b1f475b5f
[ "MIT" ]
null
null
null
# import torch import math import torch.nn as nn import torch.nn.functional as F # from torch.autograd import Variable # from functools import partial from .binarized_modules import Exposuref from .pattern_conv_modules import PatternConv __all__ = [ 'STSRResNetExp' ] ############################################################################## import torch from torch import nn def pixel_shuffle(input, upscale_factor): r"""Rearranges elements in a Tensor of shape :math:`(N, C, d_{1}, d_{2}, ..., d_{n})` to a tensor of shape :math:`(N, C/(r^n), d_{1}*r, d_{2}*r, ..., d_{n}*r)`. Where :math:`n` is the dimensionality of the data. See :class:`~torch.nn.PixelShuffle` for details. Args: input (Variable): Input upscale_factor (int): factor to increase spatial resolution by Examples:: # 1D example >>> input = torch.Tensor(1, 4, 8) >>> output = F.pixel_shuffle(input, 2) >>> print(output.size()) torch.Size([1, 2, 16]) # 2D example >>> input = torch.Tensor(1, 9, 8, 8) >>> output = F.pixel_shuffle(input, 3) >>> print(output.size()) torch.Size([1, 1, 24, 24]) # 3D example >>> input = torch.Tensor(1, 8, 16, 16, 16) >>> output = F.pixel_shuffle(input, 2) >>> print(output.size()) torch.Size([1, 1, 32, 32, 32]) """ input_size = list(input.size()) dimensionality = len(input_size) - 2 input_size[1] //= (upscale_factor ** dimensionality) output_size = [dim * upscale_factor for dim in input_size[2:]] input_view = input.contiguous().view( input_size[0], input_size[1], *(([upscale_factor] * dimensionality) + input_size[2:]) ) indicies = list(range(2, 2 + 2 * dimensionality)) indicies = indicies[1::2] + indicies[0::2] shuffle_out = input_view.permute(0, 1, *(indicies[::-1])).contiguous() return shuffle_out.view(input_size[0], input_size[1], *output_size) class PixelShuffle(nn.Module): r"""Rearranges elements in a Tensor of shape :math:`(N, C, d_{1}, d_{2}, ..., d_{n})` to a tensor of shape :math:`(N, C/(r^n), d_{1}*r, d_{2}*r, ..., d_{n}*r)`. Where :math:`n` is the dimensionality of the data. This is useful for implementing efficient sub-pixel convolution with a stride of :math:`1/r`. Input Tensor must have at least 3 dimensions, e.g. :math:`(N, C, d_{1})` for 1D data, but Tensors with any number of dimensions after :math:`(N, C, ...)` (where N is mini-batch size, and C is channels) are supported. Look at the paper: `Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional Neural Network`_ by Shi et. al (2016) for more details Args: upscale_factor (int): factor to increase spatial resolution by Shape: - Input: :math:`(N, C, d_{1}, d_{2}, ..., d_{n})` - Output: :math:`(N, C/(r^n), d_{1}*r, d_{2}*r, ..., d_{n}*r)` Where :math:`n` is the dimensionality of the data, e.g. :math:`n-1` for 1D audio, :math:`n=2` for 2D images, etc. Examples:: # 1D example >>> ps = nn.PixelShuffle(2) >>> input = torch.Tensor(1, 4, 8) >>> output = ps(input) >>> print(output.size()) torch.Size([1, 2, 16]) # 2D example >>> ps = nn.PixelShuffle(3) >>> input = torch.Tensor(1, 9, 8, 8) >>> output = ps(input) >>> print(output.size()) torch.Size([1, 1, 24, 24]) # 3D example >>> ps = nn.PixelShuffle(2) >>> input = torch.Tensor(1, 8, 16, 16, 16) >>> output = ps(input) >>> print(output.size()) torch.Size([1, 1, 32, 32, 32]) .. _Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional Neural Network: https://arxiv.org/abs/1609.05158 """ def __init__(self, upscale_factor): super(PixelShuffle, self).__init__() self.upscale_factor = upscale_factor def forward(self, input): return pixel_shuffle(input, self.upscale_factor) def extra_repr(self): return 'upscale_factor={}'.format(self.upscale_factor) ############################################################################## class ResidualBlock(nn.Module): def __init__(self, n_channels=64): super().__init__() self.conv1 = nn.Conv2d(in_channels=n_channels, out_channels=n_channels, kernel_size=3, stride=1, padding=1, bias=False) self.in1 = nn.InstanceNorm2d(n_channels, affine=True) self.relu = nn.LeakyReLU(0.2, inplace=True) self.conv2 = nn.Conv2d(in_channels=n_channels, out_channels=n_channels, kernel_size=3, stride=1, padding=1, bias=False) self.in2 = nn.InstanceNorm2d(n_channels, affine=True) def forward(self, x): identity_data = x output = self.relu(self.in1(self.conv1(x))) output = self.in2(self.conv2(output)) output = torch.add(output,identity_data) return output class ResidualBlock3D(nn.Module): def __init__(self, n_channels=64): super().__init__() self.conv1 = nn.Conv3d(in_channels=n_channels, out_channels=n_channels, kernel_size=3, stride=1, padding=1, bias=False) self.in1 = nn.InstanceNorm3d(n_channels, affine=True) self.relu = nn.LeakyReLU(0.2, inplace=True) self.conv2 = nn.Conv3d(in_channels=n_channels, out_channels=n_channels, kernel_size=3, stride=1, padding=1, bias=False) self.in2 = nn.InstanceNorm3d(n_channels, affine=True) def forward(self, x): identity_data = x output = self.relu(self.in1(self.conv1(x))) output = self.in2(self.conv2(output)) output = torch.add(output,identity_data) return output ############################################################################## class STSRResNetExp(nn.Module): """ Spatio-temporal super-resolution ResNet for a pixel-wise coded exposure image """ def __init__(self, sample_size, sample_duration, n_classes=101, upscale=2, n_features_base=256, n_features_up=16, n_features_clf=1024 ): super().__init__() assert sample_size == 112 assert upscale == 2 self.activation = F.sigmoid self.n_classes = n_classes self.upscale = upscale self.duration = sample_duration self.n_features_base = n_features_base self.n_features_up = n_features_up self.n_features_clf = n_features_clf n_batchs = 1193 self.exp = Exposuref(t=sample_duration, c=1, s=8, block=sample_size//upscale//8, noise_count=0, pass_count=n_batchs*3) self.conv_input = nn.Conv2d(in_channels=1, out_channels=self.n_features_base, kernel_size=9, stride=1, padding=4, bias=False) self.relu = nn.LeakyReLU(0.2, inplace=True) self.residual = self.make_layer(ResidualBlock, 16, self.n_features_base) self.conv_mid = nn.Conv2d(in_channels=self.n_features_base, out_channels=self.n_features_base, kernel_size=3, stride=1, padding=1, bias=False) self.bn_mid = nn.InstanceNorm2d(self.n_features_base, affine=True) self.upscale2x = nn.Sequential( nn.Conv3d(in_channels=self.n_features_base//(self.duration//self.upscale), out_channels=self.n_features_up*self.upscale**3, kernel_size=3, stride=1, padding=1, bias=False), PixelShuffle(2), nn.LeakyReLU(0.2, inplace=True), ) self.residual2 = self.make_layer(ResidualBlock3D, 3, self.n_features_up) self.conv_output = nn.Conv3d(in_channels=self.n_features_up, out_channels=1, kernel_size=9, stride=1, padding=4, bias=False) self.conv_clf = nn.Conv2d(in_channels=self.n_features_base, out_channels=self.n_features_clf, kernel_size=1, stride=1, padding=0, bias=False) self.bn_clf = nn.InstanceNorm2d(self.n_features_clf, affine=True) self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.fc = nn.Linear(self.n_features_clf, self.n_classes) for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) if m.bias is not None: m.bias.data.zero_() elif isinstance(m, nn.Conv3d): n = m.kernel_size[0] * m.kernel_size[1] * m.kernel_size[2] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) if m.bias is not None: m.bias.data.zero_() def make_layer(self, block, num_of_layer, *args): layers = [] for _ in range(num_of_layer): layers.append(block(*args)) return nn.Sequential(*layers) def forward(self, x): x = self.exp(x) out = self.relu(self.conv_input(x)) residual = out out = self.residual(out) clf_out = torch.flatten(self.avgpool(self.conv_clf(out)), 1) clf_out = F.dropout2d(clf_out, training=self.training) clf_out = self.fc(clf_out) out = self.bn_mid(self.conv_mid(out)) out = torch.add(out,residual) shape = out.shape out = out.view(shape[0], shape[1]//(self.duration//self.upscale), self.duration//self.upscale, *shape[2:]) out = self.upscale2x(out) out = self.residual2(out) out = self.conv_output(out) return self.activation(out), F.log_softmax(clf_out, dim=1) class SVSTSRResNetExp(STSRResNetExp): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.conv_input = PatternConv(in_channels=1, out_channels=self.n_features_base, kernel_size=9, stride=1, padding=4, bias=True) class TSRResNetExp(nn.Module): """ Temporal super-resolution ResNet for a pixel-wise coded exposure image """ def __init__(self, sample_size, sample_duration, n_classes=101, upscale=1, n_features_base=128, n_features_up=16, n_features_clf=1024 ): super().__init__() assert sample_size == 112 assert upscale == 1 self.activation = F.sigmoid self.n_classes = n_classes self.upscale = upscale self.duration = sample_duration self.n_features_base = n_features_base self.n_features_up = n_features_up self.n_features_clf = n_features_clf self.n_batchs = 1193 self.exp = Exposuref(t=sample_duration, c=1, s=8, block=sample_size//upscale//8, noise_count=0, pass_count=self.n_batchs*3) self.conv_input = nn.Conv2d(in_channels=1, out_channels=self.n_features_base, kernel_size=9, stride=1, padding=4, bias=False) self.relu = nn.LeakyReLU(0.2, inplace=True) self.residual = self.make_layer(ResidualBlock, 16, self.n_features_base) self.conv_mid = nn.Conv2d(in_channels=self.n_features_base, out_channels=self.n_features_base, kernel_size=3, stride=1, padding=1, bias=False) self.bn_mid = nn.InstanceNorm2d(self.n_features_base, affine=True) self.upscale1x = nn.Sequential( nn.Conv3d(in_channels=self.n_features_base//(self.duration//self.upscale), out_channels=self.n_features_up*self.upscale**3, kernel_size=3, stride=1, padding=1, bias=False), nn.LeakyReLU(0.2, inplace=True), ) self.residual2 = self.make_layer(ResidualBlock3D, 3, self.n_features_up) self.conv_output = nn.Conv3d(in_channels=self.n_features_up, out_channels=1, kernel_size=9, stride=1, padding=4, bias=False) self.conv_clf = nn.Conv2d(in_channels=self.n_features_base, out_channels=self.n_features_clf, kernel_size=1, stride=1, padding=0, bias=False) self.bn_clf = nn.InstanceNorm2d(self.n_features_clf, affine=True) self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.fc = nn.Linear(self.n_features_clf, self.n_classes) for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) if m.bias is not None: m.bias.data.zero_() elif isinstance(m, nn.Conv3d): n = m.kernel_size[0] * m.kernel_size[1] * m.kernel_size[2] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) if m.bias is not None: m.bias.data.zero_() def make_layer(self, block, num_of_layer, *args): layers = [] for _ in range(num_of_layer): layers.append(block(*args)) return nn.Sequential(*layers) def forward(self, x): x = self.exp(x) out = self.relu(self.conv_input(x)) residual = out out = self.residual(out) clf_out = torch.flatten(self.avgpool(self.conv_clf(out)), 1) clf_out = F.dropout2d(clf_out, training=self.training) clf_out = self.fc(clf_out) out = self.bn_mid(self.conv_mid(out)) out = torch.add(out,residual) shape = out.shape out = out.view(shape[0], shape[1]//(self.duration//self.upscale), self.duration//self.upscale, *shape[2:]) out = self.upscale1x(out) out = self.residual2(out) out = self.conv_output(out) return self.activation(out), F.log_softmax(clf_out, dim=1) class SVTSRResNetExp(TSRResNetExp): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.conv_input = PatternConv(in_channels=1, out_channels=self.n_features_base, kernel_size=9, stride=1, padding=4, bias=True)
43.065217
184
0.612822
1,936
13,867
4.193698
0.119318
0.050992
0.05444
0.037689
0.825225
0.822885
0.805887
0.797512
0.791969
0.764873
0
0.033153
0.24086
13,867
321
185
43.199377
0.738102
0.201053
0
0.692308
0
0
0.002843
0
0
0
0
0
0.019231
1
0.076923
false
0.009615
0.033654
0.009615
0.1875
0
0
0
0
null
0
0
0
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
5c7d618cdbf581afd8b16400b6fda4e1c7ed5436
441
py
Python
dashboard/lib/flanker/mime/message/headers/__init__.py
robertsimmons514/isthislegit
aa8f2b6cb2ac3de2b0fe03bb93dbceccc4c1f495
[ "BSD-3-Clause" ]
929
2015-01-01T11:14:21.000Z
2022-03-28T23:47:40.000Z
dashboard/lib/flanker/mime/message/headers/__init__.py
robertsimmons514/isthislegit
aa8f2b6cb2ac3de2b0fe03bb93dbceccc4c1f495
[ "BSD-3-Clause" ]
141
2015-01-10T19:02:03.000Z
2021-07-26T18:04:14.000Z
dashboard/lib/flanker/mime/message/headers/__init__.py
robertsimmons514/isthislegit
aa8f2b6cb2ac3de2b0fe03bb93dbceccc4c1f495
[ "BSD-3-Clause" ]
179
2015-01-01T18:42:46.000Z
2022-02-16T21:57:14.000Z
from flanker.mime.message.headers.headers import MimeHeaders from flanker.mime.message.headers.encodedword import mime_to_unicode from flanker.mime.message.headers.parsing import normalize, is_empty, parse_header_value from flanker.mime.message.headers.encoding import to_mime from flanker.mime.message.headers.parametrized import is_parametrized from flanker.mime.message.headers.wrappers import WithParams, ContentType, MessageId, Subject
63
93
0.868481
60
441
6.266667
0.4
0.175532
0.239362
0.351064
0.462766
0
0
0
0
0
0
0
0.06576
441
6
94
73.5
0.912621
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
0
0
0
null
0
1
1
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
5c8e9ce7437351d7d69328dc8914a2ec60532ac5
199
py
Python
projects/admin.py
stafazzoli/django_issuetracker
fd12605d53cfff9619abcb35e7e011d9d9c1da33
[ "MIT" ]
1
2020-08-13T13:20:55.000Z
2020-08-13T13:20:55.000Z
projects/admin.py
stafazzoli/django_issuetracker
fd12605d53cfff9619abcb35e7e011d9d9c1da33
[ "MIT" ]
2
2021-06-10T17:44:39.000Z
2022-02-10T10:49:21.000Z
projects/admin.py
stafazzoli/django_issuetracker
fd12605d53cfff9619abcb35e7e011d9d9c1da33
[ "MIT" ]
2
2020-06-18T00:09:39.000Z
2020-07-03T19:18:14.000Z
from django.contrib import admin from . import models # Register your models here. admin.site.register(models.ProjectCategory) admin.site.register(models.Project) admin.site.register(models.Issue)
22.111111
43
0.81407
27
199
6
0.481481
0.166667
0.314815
0.425926
0
0
0
0
0
0
0
0
0.090452
199
8
44
24.875
0.895028
0.130653
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
0.4
0
0.4
0
1
0
0
null
0
1
1
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
0
0
0
6
7a41146d9d9f5b3170add4863afcb1b9d7b5f894
2,302
py
Python
epytope/Data/pssms/smm/mat/A_02_02_9.py
christopher-mohr/epytope
8ac9fe52c0b263bdb03235a5a6dffcb72012a4fd
[ "BSD-3-Clause" ]
7
2021-02-01T18:11:28.000Z
2022-01-31T19:14:07.000Z
epytope/Data/pssms/smm/mat/A_02_02_9.py
christopher-mohr/epytope
8ac9fe52c0b263bdb03235a5a6dffcb72012a4fd
[ "BSD-3-Clause" ]
22
2021-01-02T15:25:23.000Z
2022-03-14T11:32:53.000Z
epytope/Data/pssms/smm/mat/A_02_02_9.py
christopher-mohr/epytope
8ac9fe52c0b263bdb03235a5a6dffcb72012a4fd
[ "BSD-3-Clause" ]
4
2021-05-28T08:50:38.000Z
2022-03-14T11:45:32.000Z
A_02_02_9 = {0: {'A': -0.145, 'C': 0.221, 'E': 0.72, 'D': 0.844, 'G': 0.058, 'F': -0.922, 'I': -0.135, 'H': 0.116, 'K': -0.195, 'M': -0.461, 'L': -0.138, 'N': 0.087, 'Q': 0.011, 'P': 0.503, 'S': -0.089, 'R': 0.099, 'T': 0.161, 'W': -0.221, 'V': 0.035, 'Y': -0.547}, 1: {'A': 0.108, 'C': 0.324, 'E': 0.89, 'D': 0.324, 'G': -0.085, 'F': -0.094, 'I': -0.572, 'H': 0.05, 'K': 0.233, 'M': -1.25, 'L': -1.345, 'N': 0.41, 'Q': -0.308, 'P': 1.043, 'S': -0.004, 'R': 0.877, 'T': -0.128, 'W': -0.272, 'V': -0.341, 'Y': 0.14}, 2: {'A': -0.513, 'C': 0.144, 'E': 0.353, 'D': 0.04, 'G': 0.163, 'F': -0.354, 'I': -0.132, 'H': 0.102, 'K': 0.352, 'M': -0.561, 'L': 0.233, 'N': -0.217, 'Q': 0.135, 'P': 0.1, 'S': -0.352, 'R': 0.425, 'T': 0.128, 'W': 0.149, 'V': -0.037, 'Y': -0.157}, 3: {'A': -0.172, 'C': -0.042, 'E': -0.216, 'D': -0.315, 'G': -0.157, 'F': 0.003, 'I': 0.129, 'H': 0.033, 'K': 0.103, 'M': 0.093, 'L': 0.145, 'N': 0.118, 'Q': 0.037, 'P': -0.045, 'S': -0.121, 'R': 0.226, 'T': 0.118, 'W': 0.026, 'V': 0.092, 'Y': -0.056}, 4: {'A': 0.035, 'C': -0.054, 'E': 0.023, 'D': 0.049, 'G': 0.109, 'F': -0.272, 'I': -0.3, 'H': -0.127, 'K': 0.131, 'M': 0.092, 'L': -0.107, 'N': 0.122, 'Q': 0.034, 'P': 0.264, 'S': 0.04, 'R': 0.161, 'T': 0.195, 'W': 0.052, 'V': -0.097, 'Y': -0.351}, 5: {'A': 0.099, 'C': -0.034, 'E': 0.087, 'D': 0.139, 'G': 0.167, 'F': -0.218, 'I': -0.196, 'H': 0.144, 'K': 0.449, 'M': -0.138, 'L': -0.265, 'N': -0.078, 'Q': -0.003, 'P': 0.028, 'S': -0.151, 'R': 0.218, 'T': -0.17, 'W': 0.112, 'V': -0.145, 'Y': -0.044}, 6: {'A': -0.116, 'C': 0.037, 'E': -0.098, 'D': -0.071, 'G': 0.241, 'F': -0.355, 'I': 0.156, 'H': -0.175, 'K': 0.554, 'M': -0.063, 'L': 0.183, 'N': -0.031, 'Q': 0.062, 'P': 0.19, 'S': -0.029, 'R': 0.47, 'T': -0.083, 'W': -0.39, 'V': -0.06, 'Y': -0.422}, 7: {'A': -0.048, 'C': 0.154, 'E': -0.175, 'D': 0.432, 'G': -0.001, 'F': -0.374, 'I': 0.173, 'H': 0.007, 'K': 0.243, 'M': 0.1, 'L': -0.233, 'N': -0.014, 'Q': -0.004, 'P': -0.08, 'S': -0.086, 'R': 0.077, 'T': 0.143, 'W': -0.157, 'V': 0.264, 'Y': -0.42}, 8: {'A': -0.423, 'C': 0.65, 'E': -0.065, 'D': -0.186, 'G': -0.273, 'F': 0.009, 'I': -0.619, 'H': 0.454, 'K': 0.779, 'M': -0.252, 'L': -0.945, 'N': -0.315, 'Q': 0.288, 'P': -0.101, 'S': 0.282, 'R': 0.578, 'T': 0.148, 'W': 0.44, 'V': -1.051, 'Y': 0.602}, -1: {'con': 4.16801}}
2,302
2,302
0.393136
557
2,302
1.61939
0.319569
0.019956
0.011086
0.013304
0.031042
0
0
0
0
0
0
0.372214
0.162033
2,302
1
2,302
2,302
0.095386
0
0
0
0
0
0.079462
0
0
0
0
0
0
1
0
false
0
0
0
0
0
0
0
1
null
0
0
0
0
0
0
0
0
0
0
1
0
0
1
1
1
1
0
0
0
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
7a704638f4ead736faef7491ca6fb950df8e7bc2
123
py
Python
actors/__init__.py
andriikobyakovskiy/simple_actors
d02017313626784ba8addbbcd1ce1f4bf9d94c3b
[ "MIT" ]
null
null
null
actors/__init__.py
andriikobyakovskiy/simple_actors
d02017313626784ba8addbbcd1ce1f4bf9d94c3b
[ "MIT" ]
null
null
null
actors/__init__.py
andriikobyakovskiy/simple_actors
d02017313626784ba8addbbcd1ce1f4bf9d94c3b
[ "MIT" ]
null
null
null
from actors.message import Message, PoisonPill from actors.actor import Actor, Props from actors.system import ActorSystem
30.75
46
0.845528
17
123
6.117647
0.529412
0.288462
0
0
0
0
0
0
0
0
0
0
0.113821
123
3
47
41
0.954128
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
0
0
null
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
7a80c1b9fd0aeed94abc826cb34fecf2ee81d23b
173
py
Python
app/modules/streamer/__init__.py
Sean2525/VAWSR_backend
c3fcff8308648777b0a678debcb7b2989ae860b2
[ "MIT" ]
null
null
null
app/modules/streamer/__init__.py
Sean2525/VAWSR_backend
c3fcff8308648777b0a678debcb7b2989ae860b2
[ "MIT" ]
null
null
null
app/modules/streamer/__init__.py
Sean2525/VAWSR_backend
c3fcff8308648777b0a678debcb7b2989ae860b2
[ "MIT" ]
null
null
null
from app.modules.streamer.websocketstream import WebsocketStream from app.modules.streamer.google import GoogleStreamer from app.modules.streamer.kaldi import KaldiStreamer
43.25
64
0.878613
21
173
7.238095
0.47619
0.138158
0.276316
0.434211
0
0
0
0
0
0
0
0
0.069364
173
3
65
57.666667
0.944099
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
0
0
null
0
1
1
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
0
0
0
6
8f50319ef794198dd2cd134fcff2c181935e63d3
34
py
Python
part4/first.py
MADTeacher/python_basics
06ae43d8063c1c8426a4fbb53443b6d1ee727951
[ "MIT" ]
null
null
null
part4/first.py
MADTeacher/python_basics
06ae43d8063c1c8426a4fbb53443b6d1ee727951
[ "MIT" ]
null
null
null
part4/first.py
MADTeacher/python_basics
06ae43d8063c1c8426a4fbb53443b6d1ee727951
[ "MIT" ]
4
2020-10-04T12:24:14.000Z
2022-01-16T17:01:59.000Z
def function(): print('first')
17
18
0.617647
4
34
5.25
1
0
0
0
0
0
0
0
0
0
0
0
0.176471
34
2
18
17
0.75
0
0
0
0
0
0.142857
0
0
0
0
0
0
1
0.5
true
0
0
0
0.5
0.5
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
1
1
0
0
0
0
1
0
6
56c6fa4e6f6850444b1df89bf9a14b406e92a780
604
py
Python
torchsupport/interacting/environments/environment.py
bobelly/torchsupport
5aa0a04f20c193ec99310f5d6a3375d2e95e740d
[ "MIT" ]
18
2019-05-02T16:32:15.000Z
2021-04-16T09:33:54.000Z
torchsupport/interacting/environments/environment.py
bobelly/torchsupport
5aa0a04f20c193ec99310f5d6a3375d2e95e740d
[ "MIT" ]
5
2019-10-14T13:46:49.000Z
2021-06-08T11:48:34.000Z
torchsupport/interacting/environments/environment.py
bobelly/torchsupport
5aa0a04f20c193ec99310f5d6a3375d2e95e740d
[ "MIT" ]
12
2019-05-12T21:34:24.000Z
2021-07-15T14:14:16.000Z
from torchsupport.data.namedtuple import namedtuple class Environment: data_type = namedtuple("Data", [ "state", "action", "rewards", "done" ]) def reset(self): raise NotImplementedError def push_changes(self): pass def pull_changes(self): pass def action_space(self): raise NotImplementedError def observation_space(self): raise NotImplementedError def is_done(self): raise NotImplementedError def observe(self): raise NotImplementedError def act(self, action): raise NotImplementedError def schema(self): raise NotImplementedError
18.30303
51
0.716887
65
604
6.569231
0.415385
0.393443
0.393443
0.362998
0.168618
0
0
0
0
0
0
0
0.200331
604
32
52
18.875
0.884058
0
0
0.391304
0
0
0.043046
0
0
0
0
0
0
1
0.391304
false
0.086957
0.043478
0
0.521739
0
0
0
0
null
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
1
0
1
0
0
1
0
0
6
7127277f1c785585c5d59116c38ea2722f1ef895
323,918
py
Python
projects/customer_segmentation_with_python.py
Jacquedelest/jacquedelest.github.io
7bd2434f85e6e2a7a12f23145182bbf756d88091
[ "Unlicense" ]
null
null
null
projects/customer_segmentation_with_python.py
Jacquedelest/jacquedelest.github.io
7bd2434f85e6e2a7a12f23145182bbf756d88091
[ "Unlicense" ]
null
null
null
projects/customer_segmentation_with_python.py
Jacquedelest/jacquedelest.github.io
7bd2434f85e6e2a7a12f23145182bbf756d88091
[ "Unlicense" ]
null
null
null
# -*- coding: utf-8 -*- """Customer Segmentation with Python Automatically generated by Colaboratory. Original file is located at https://colab.research.google.com/github/Jacquedelest/Latihan-dengan-Python/blob/main/Customer_Segmentation_with_Python.ipynb --- Title: "Data Science in Marketing: Customer Segmentation with Python" Author: "Joseph Armando Carvallo" Date: "25/03/2021" --- # Prepare Libraries and Data ![custsegmen.png](data:image/png;base64,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) The data above has seven columns with the following explanation: * `Customer_ID` is a customer code in mixed format CUST- text followed by a number. * `Nama Pelanggan` is the name of the customer in text format of course. * `Jenis Kelamin` is the gender of the customer, there are only two data content categories, namely Pria and Wanita. * `Umur` is the age of the customer in numeric format. * `Profesi` is the profession of the customer, also type of category text consisting of Wiraswasta, Pelajar, Professional, Ibu Rumah Tangga, and Mahasiswa. * `Tipe Residen` is the type of residence of our customers, for this dataset there are only two categories, Cluster and Sector. * `NilaiBelanjaSetahun` is the total expenditure that has been issued by the customer. **Preparing Libraries** * Pandas is used to perform data analysis processing Matplotlib, also as a basis for visualizing data. * Seaborn is used on top of matplotlib to do more interesting data visualization. * ScikitLearn is used to prepare data before modeling. * kmodes is used to perform modeling using K-Modes and K-Prototypes algorithms. * Pickle is used to store the model to be made. """ import pandas as pd import matplotlib.pyplot as plt import seaborn as sns from sklearn.preprocessing import LabelEncoder from kmodes.kmodes import KModes from kmodes.kprototypes import KPrototypes import pickle from pathlib import Path """**Reading Customer Data** The first step that needs to be done is to read the data which was originally a textfile into a pandas dataframe. """ # Import dataset df = pd.read_csv("https://storage.googleapis.com/dqlab-dataset/customer_segments.txt", sep="\t") df.head() """**View Information from Data** Next I need to see the information from the existing data. So that I can find out the number of rows and columns, column names, identify null values, and also know the data type easily. """ df.info() """After doing a data call and looking at the data information, I finally found out that: * The data to be used consists of 50 rows and 7 columns * No data dense *Null* values * Two columns have numeric data type and five data type string # Perform Data Exploration In the previous step I have just prepared the data and seen the basic information of the data. Next I need to do data exploration to get to know the dataset that is going to be used. I am going to do some exploration for numeric data as well as categorical data. **Numeric Data Exploration** First I need to look at the data distribution of data of numeric type. Here I am using a boxplot and also a histogram to see the distribution of the data. To create the graph, I need to set up which column is the numeric column, then use the seaborn library to plot each of the numeric columns, namely `Umur` and `NilaiBelanjaSetahun`. """ sns.set(style='white') plt.clf() # Function to create plot def observasi_num(features): fig, axs = plt.subplots(2, 2, figsize=(10, 9)) for i, kol in enumerate(features): sns.boxplot(df[kol], ax = axs[i][0]) sns.distplot(df[kol], ax = axs[i][1]) axs[i][0].set_title('mean = %.2f\n median = %.2f\n std = %.2f'%(df[kol].mean(), df[kol].median(), df[kol].std())) plt.setp(axs) plt.tight_layout() plt.show() # Call function to create plot of numeric variables kolom_numerik = ['Umur','NilaiBelanjaSetahun'] observasi_num(kolom_numerik) """From the results of the data exploration, I can get the following information: * The average age of the customer is 37.5 years * The average value of a customer's annual spending is 7,069,874.82 * Gender of customers is dominated by 41 women (82%) and 9 men (18%) * Most professions are Entrepreneur (40%) followed by Professional (36%) and others (24%) * Of all customers 64% of them live in clusters and 36% live in sectors # Prepare Data Before Modeling Each machine learning model has different characteristics. This makes me have to prepare the data that I have before it is used for modeling. So that it can adjust to the characteristics possessed by each model and get optimal results. I am planing to do the modeling using unsupervised clustering technique. The algorithm that is going to be used is K-Prototypes. One of the main factors in this algorithm is that I need to use data that scales between variables equally. In addition, I also need to encode the categorical columns I have into numeric, then combine the results of data processing into one data frame for use in modeling. **Standardization of Numeric Columns** In order to get optimal results in the application of the algorithm, I need to equalize the numerical data is on one scale. This can be done by standardizing the data. The goal is variables that have a large scale do not dominate how the cluster will be formed and also each variable will be considered equally important by the algorithm that will be used. """ from sklearn.preprocessing import StandardScaler kolom_numerik = ['Umur','NilaiBelanjaSetahun'] # Statistics before standardization print('Statistics Before Standardization') print(df[kolom_numerik].describe().round(1)) # Standardize df_std = StandardScaler().fit_transform(df[kolom_numerik]) # Create data frame df_std = pd.DataFrame(data=df_std, index=df.index, columns=df[kolom_numerik].columns) # Display examples of data content and summary statistics print('\nExample of standardization') print(df_std.head()) print('\nStandardization of statistics') print(df_std.describe().round(0)) """**Categorical Conversion of Data with Encoder Labels** Next I need to convert the categorical columns into numbers. I am using one of the functions from sklearn namely LabelEncoder. Basically this function will convert customer data from text to numeric. For example for the `Jenis Kelamin` column, the text `Pria` will be changed to the number `0` and the text `Wanita` will be changed to the number `1`. This change is required for all text variables before being used in the K-Prototype algorithm. """ # Initiate categorical column kolom_kategorikal = ['Jenis Kelamin','Profesi','Tipe Residen'] # Make a copy of the data frame df_encode = df[kolom_kategorikal].copy() # Encode all categorical columns for col in kolom_kategorikal: df_encode[col] = LabelEncoder().fit_transform(df_encode[col]) # Print data df_encode.head() """**Combine Data for Modeling** After completing the previous two steps, this time I am combining the two processing results into one data frame. This data frame is going to be used for modeling. """ df_model = df_encode.merge(df_std, left_index = True, right_index=True, how = 'left') df_model.head() """# Modelling **Clustering** is the process of dividing objects into several groups or clusters based on the degree of similarity between one object and another. There are several algorithms to perform clustering. One of the popular ones is **k-means** which is usually only used for numeric data. As for the categorical only, use **k-modes**. If the data contains composite variables, use **kprototype** algorithm which is a combination of **k-means** and **k-modes**. it can be called using the **k-modes** library which contains the **kprototype** module. To use the **kprototype** algorithm, I need to enter the number of clusters needed and also provide a column index for categorical columns. **Looking for the Optimal Number of Clusters** One of the important parameters that must be included in kprototype algorithm is the number of clusters needed. Therefore, I need to find the optimal number of clusters. One way to get the optimal value is to use the help of an *elbow plot* that can be made by visualizing the total distance of all data to the center of the cluster. Next, I am selecting the angled point of the formed pattern and making it my cluster count. To do this I need to run kprototype algorithm with various number of clusters. Next I am also storing the value of `cost_` and visualizing it with line plot or point plot. """ # Import the original data df_model = pd.read_csv('https://storage.googleapis.com/dqlab-dataset/df-customer-segmentation.csv') # Iterate to get `cost` value cost = {} for k in range(2,10): kproto = KPrototypes(n_clusters = k,random_state=75) kproto.fit_predict(df_model, categorical=[0,1,2]) cost[k]= kproto.cost_ # Visualize elbow plot sns.pointplot(x=list(cost.keys()), y=list(cost.values())) plt.show() """From the results above, I can find out that the angle of the plot is at `k = 5`. So I decided to use 5 as the optimal number of clusters. **Create a Model** Then I can create a model with the number of clusters that have been obtained in the previous stage, namely 5 and save the result as a pickle file. """ kproto = KPrototypes(n_clusters=5, random_state=75) kproto = kproto.fit(df_model, categorical=[0,1,2]) #Save Model pickle.dump(kproto, open('cluster.pkl', 'wb')) """**Use the Model** The model that I have created can be used to determine which each customer belongs to which cluster. This time I will use the model to determine the customer segments in the dataset. """ df = pd.read_csv("https://dqlab-dataset.s3-ap-southeast-1.amazonaws.com/customer_segments.txt", sep="\t") # Determine the segment of each customer clusters = kproto.predict(df_model, categorical=[0,1,2]) print('customer segment {}\n'.format(clusters)) # Combine initial data and customer segments df_final = df.copy() df_final['cluster'] = clusters df_final.head() """**Displaying Clusters of Each Customer** After combining the initial data of customers and their clusters, I need to display and observe the results to help me in naming each cluster based on its characteristics. """ for i in range (0,5): print('\nPelanggan cluster: {}\n'.format(i)) print(df_final[df_final['cluster']== i]) """**Boxplot: Visualization of Clustering Results** I am also making a visualization of the clustering result to make it easier for me to do naming in each cluster. """ # Numerical variables kolom_numerik = ['Umur','NilaiBelanjaSetahun'] for i in kolom_numerik: plt.figure(figsize=(6,4)) ax = sns.boxplot(x = 'cluster',y = i, data = df_final) plt.title('\nBox Plot {}\n'.format(i), fontsize=12) plt.show() """**Count Plot: Visualization of Clustering Results** I am also making a visualization of the clustering results to make it easier for me to name each cluster. """ # Categorical data kolom_categorical = ['Jenis Kelamin','Profesi','Tipe Residen'] for i in kolom_categorical: plt.figure(figsize=(6,4)) ax = sns.countplot(data = df_final, x = 'cluster', hue = i ) plt.title('\nCount Plot {}\n'.format(i), fontsize=12) ax.legend(loc="upper center") for p in ax.patches: ax.annotate(format(p.get_height(), '.0f'), (p.get_x() + p.get_width() / 2., p.get_height()), ha = 'center', va = 'center', xytext = (0, 10), textcoords = 'offset points') sns.despine(right=True,top = True, left = True) ax.axes.yaxis.set_visible(False) plt.show() """**Name the Clusters** From the observations made, I want to give the name of the segment for each cluster number, namely: * `Cluster 0` is Diamond Young Entrepreneur. The contents of this cluster are entrepreneurs who have average transaction value of close to 10 million and have ages of about 18 - 41 years with the average age is 29 years. * `Cluster 1` is Diamond Senior Entrepreneur. The contents of this cluster are entrepreneurs who have average transaction value of close to 10 million and have ages of around 45 - 64 years with the average age is 55 years. * `Cluster 2` is Silver Students. The contents of this cluster are students and college students whose average age is 16 years and the annual expenditure value is close to 3 million. * `Cluster 3` is a Gold Young Member. The contents of this cluster are young professionals and housewives with age range of about 20 - 40 years and with the average age is 30 years, and their annual spending value is close to 6 million. * `Cluster 4` is a Gold Senior Member. The contents of this cluster are elderly professionals and housewives with age range of 46 - 63 years and the average age is 53 years, and the annual expenditure value is close to 6 million. """ # Map column name df_final['segmen'] = df_final['cluster'].map({ 0: 'Diamond Young Member', 1: 'Diamond Senior Member', 2: 'Silver Member', 3: 'Gold Young Member', 4: 'Gold Senior Member' }) print(df_final.info()) df_final.head() """# Operate Model The newly created model must be able to be used every day to predict new data. For that I need to prepare the data again and then make predictions with the parameters and models that have been made. **Prepar New Data** Here I am creating a new sample of data to be predicted with the model that has been created. I do this by creating a dataframe that contains customer information. """ # New data data = [{ 'Customer_ID': 'CUST-100' , 'Nama Pelanggan': 'Joko' , 'Jenis Kelamin': 'Pria', 'Umur': 45, 'Profesi': 'Wiraswasta', 'Tipe Residen': 'Cluster' , 'NilaiBelanjaSetahun': 8230000 }] # Create data frame new_df = pd.DataFrame(data) # Print new data new_df """**Creating a Data Processing Function** Next I need to create a function to perform data processing based on the same parameters when I do the modeling and call the new data. From the previous process, the representation of each code and their meaning, namely: `Jenis Kelamin` * 0 = Pria (Male) * 1 = Wanita (Female) `Profesi` * 0 = Ibu Rumah Tangga (Housewife) * 1 = Mahasiswa (University Student) * 2 = Pelajar (Pupil) * 3 = Professional * 4 = Wiraswasta (Enterpreneur) `Tipe Residen` * 1 = Sector * 2 = Cluster To standardize numerical data with the same variables when modeling, I need to use the average value and standard deviation of each variable when modeling. `Umur` * mean = 37.5 * standard deviation = 14.7 `NilaiBelanjaSetahun` * mean = 7069874.8 * standard deviation = 2590619.0 From these values I can calculate the standardized value (`z`) using the formula `Z = (x - u)/s` where `x` is each value, `u` is the average and `s` is the standard deviation. Finally, combining the results of the two previous processes into one data frame """ def data_preprocess(data): # Convert categorical data kolom_kategorikal = ['Jenis Kelamin','Profesi','Tipe Residen'] df_encode = data[kolom_kategorikal].copy() ## Gender df_encode['Jenis Kelamin'] = df_encode['Jenis Kelamin'].map({ 'Pria': 0, 'Wanita' : 1 }) ## Profession df_encode['Profesi'] = df_encode['Profesi'].map({ 'Ibu Rumah Tangga': 0, 'Mahasiswa' : 1, 'Pelajar': 2, 'Professional': 3, 'Wiraswasta': 4 }) ## Residential type df_encode['Tipe Residen'] = df_encode['Tipe Residen'].map({ 'Cluster': 0, 'Sector' : 1 }) # Standardize numerical data kolom_numerik = ['Umur','NilaiBelanjaSetahun'] df_std = data[kolom_numerik].copy() ## Standardize age df_std['Umur'] = (df_std['Umur'] - 37.5)/14.7 ## Standardize annual shopping value df_std['NilaiBelanjaSetahun'] = (df_std['NilaiBelanjaSetahun'] - 7069874.8)/2590619.0 # merge categorical and numerical data df_model = df_encode.merge(df_std, left_index = True, right_index=True, how = 'left') return df_model # Run function new_df_model = data_preprocess(new_df) new_df_model """**Call Models and Make Predictions** Once, the data ready to use, it's time to call the previously saved model and proceed with making predictions. To do this, I need to make the process into a single function called modeling using the new data as input. """ def modelling (data): # Call model kpoto = pickle.load(open('cluster.pkl', 'rb')) # Predict clusters= kpoto.predict(data,categorical=[0,1,2]) return clusters # Run function clusters = modelling(new_df_model) print(clusters) """**Name the Segment** Same as before, I need to create a function to do this process. The cluster names that have been obtained in the previous step need to be changed to segment names to make them easier to identify. """ def menamakan_segmen (data_asli, clusters): # Merge cluster and original data final_df = data_asli.copy() final_df['cluster'] = clusters # Name segment final_df['segmen'] = final_df['cluster'].map({ 0: 'Diamond Young Member', 1: 'Diamond Senior Member', 2: 'Silver Students', 3: 'Gold Young Member', 4: 'Gold Senior Member' }) return final_df # Run function new_final_df = menamakan_segmen(new_df,clusters) new_final_df
723.03125
306,309
0.951407
12,775
323,918
24.114286
0.801174
0.000357
0.000364
0.000276
0.006635
0.005577
0.004356
0.002746
0.002532
0.001961
0
0.153817
0.010759
323,918
448
306,310
723.03125
0.80757
0.953217
0
0.181208
1
0.006711
0.205691
0
0
1
0
0.002232
0
1
0.026846
false
0
0.060403
0
0.107383
0.073826
0
0
1
null
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
0
1
0
0
1
0
0
0
null
1
0
0
0
0
0
0
0
0
0
0
0
0
6
857cabe01377edfef935c53e8f284384e0ed52cd
33
py
Python
endaq/batch/__init__.py
MideTechnology/endaq-python
a878efdd65f718c1324d92d467b19fd3b4142cd0
[ "MIT" ]
5
2021-12-02T04:41:52.000Z
2022-02-01T19:44:41.000Z
endaq/batch/__init__.py
MideTechnology/endaq-python
a878efdd65f718c1324d92d467b19fd3b4142cd0
[ "MIT" ]
136
2021-09-28T17:45:20.000Z
2022-03-30T11:35:15.000Z
endaq/batch/__init__.py
MideTechnology/endaq-python
a878efdd65f718c1324d92d467b19fd3b4142cd0
[ "MIT" ]
2
2021-11-08T19:22:17.000Z
2021-12-15T20:25:04.000Z
from .core import GetDataBuilder
16.5
32
0.848485
4
33
7
1
0
0
0
0
0
0
0
0
0
0
0
0.121212
33
1
33
33
0.965517
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
85984587412dd84a61dbf5ae4733b540c9c41a19
1,830
py
Python
tests/test_webargs.py
FrailLeon/sanic-pydantic
e65b14fc36ad4b0bf6134ca8a64e184bd7535511
[ "MIT" ]
null
null
null
tests/test_webargs.py
FrailLeon/sanic-pydantic
e65b14fc36ad4b0bf6134ca8a64e184bd7535511
[ "MIT" ]
null
null
null
tests/test_webargs.py
FrailLeon/sanic-pydantic
e65b14fc36ad4b0bf6134ca8a64e184bd7535511
[ "MIT" ]
null
null
null
from examples.server import app import json def test_sanic_webargs_query(): params = dict(name="ahmed") request, response = app.test_client.get("/get-request", params=params) expected_response = dict(payload=None, query=params) assert response.status == 200 assert response.json == expected_response def test_sanic_webargs_path(): request, response = app.test_client.get("/get/1") expected_response = dict(payload=None, query=None, id=1) assert response.status == 200 assert response.json == expected_response def test_sanic_webargs_payload(): data = dict(age=29) params = dict(name="ahmed") request, response = app.test_client.post( "/post-request", params=params, data=json.dumps(data) ) expected_response = dict(payload=data, query=params) assert response.status == 200 assert response.json == expected_response def test_async_sanic_webargs_query(): params = dict(name="ahmed") request, response = app.test_client.get( "/async-get-request", params=params ) expected_response = dict(payload=None, query=params) assert response.status == 200 assert response.json == expected_response def test_async_sanic_webargs_payload(): data = dict(age=29) params = dict(name="ahmed") request, response = app.test_client.post( "/async-post-request", params=params, data=json.dumps(data) ) expected_response = dict(payload=data, query=params) assert response.status == 200 assert response.json == expected_response def test_sanic_webargs_payload_invalid(): data = dict(invalid_body_param=29) params = dict(invalid_query_param="ahmed") request, response = app.test_client.post( "/post-request", params=params, data=json.dumps(data) ) assert response.status == 422
31.016949
74
0.704918
234
1,830
5.337607
0.162393
0.123299
0.086469
0.105685
0.880705
0.880705
0.851882
0.82466
0.82466
0.82466
0
0.017299
0.178689
1,830
58
75
31.551724
0.813706
0
0
0.543478
0
0
0.057924
0
0
0
0
0
0.23913
1
0.130435
false
0
0.043478
0
0.173913
0
0
0
0
null
0
0
0
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
a44a3703a199e2432a447693a6f3f73fed55eb2c
190
py
Python
1_joint_alignment/SE/Edge.py
BGU-CS-VIL/JA-POLS
0ee34ec0c8c7d7fdfc0c5b1c85b2bb6632cc3c41
[ "MIT" ]
16
2020-03-16T08:52:09.000Z
2022-03-09T09:05:47.000Z
1_joint_alignment/SE/Edge.py
BGU-CS-VIL/JA-POLS
0ee34ec0c8c7d7fdfc0c5b1c85b2bb6632cc3c41
[ "MIT" ]
1
2020-08-24T17:28:19.000Z
2020-08-24T17:28:19.000Z
1_joint_alignment/SE/Edge.py
BGU-CS-VIL/JA-POLS
0ee34ec0c8c7d7fdfc0c5b1c85b2bb6632cc3c41
[ "MIT" ]
1
2022-02-04T20:54:24.000Z
2022-02-04T20:54:24.000Z
class Edge: def __init__(self, src, dst): self.src = src self.dst = dst def get_src(self): return self.src def get_dst(self): return self.dst
14.615385
33
0.547368
27
190
3.62963
0.333333
0.214286
0.285714
0
0
0
0
0
0
0
0
0
0.357895
190
12
34
15.833333
0.803279
0
0
0
0
0
0
0
0
0
0
0
0
1
0.375
false
0
0
0.25
0.75
0
1
0
0
null
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
1
0
0
0
1
1
0
0
6
a469a30cf8dcc295148ca4429da22f75c4be3d97
118
py
Python
syn/tagmathon/b/__init__.py
mbodenhamer/syn
aeaa3ad8a49bac8f50cf89b6f1fe97ad43d1d258
[ "MIT" ]
1
2021-07-15T08:55:12.000Z
2021-07-15T08:55:12.000Z
syn/tagmathon/b/__init__.py
mbodenhamer/syn
aeaa3ad8a49bac8f50cf89b6f1fe97ad43d1d258
[ "MIT" ]
7
2021-01-07T23:51:57.000Z
2021-12-13T19:50:57.000Z
syn/tagmathon/b/__init__.py
mbodenhamer/syn
aeaa3ad8a49bac8f50cf89b6f1fe97ad43d1d258
[ "MIT" ]
2
2016-07-11T08:46:31.000Z
2017-12-13T13:30:51.000Z
from .base import * from .function import * from .builtin import * from .interpreter import * from .compiler import *
19.666667
26
0.745763
15
118
5.866667
0.466667
0.454545
0
0
0
0
0
0
0
0
0
0
0.169492
118
5
27
23.6
0.897959
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
0
0
null
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
a49d965a8320f1d32580a7596eb63761aa392a0a
35
py
Python
grapheap/__init__.py
practo/grapheap
f9f22290eb0e8cd191747f555c3d15dbbcfa7a3e
[ "MIT" ]
null
null
null
grapheap/__init__.py
practo/grapheap
f9f22290eb0e8cd191747f555c3d15dbbcfa7a3e
[ "MIT" ]
null
null
null
grapheap/__init__.py
practo/grapheap
f9f22290eb0e8cd191747f555c3d15dbbcfa7a3e
[ "MIT" ]
1
2019-09-12T06:54:09.000Z
2019-09-12T06:54:09.000Z
from .src.grapheap import Grapheap
17.5
34
0.828571
5
35
5.8
0.8
0
0
0
0
0
0
0
0
0
0
0
0.114286
35
1
35
35
0.935484
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
74b36e2e62ebc6c302472884d8e45300784ae159
118
py
Python
descriptors/__init__.py
WPaczula/image-fragmentation
f5650ff384bf803b3cca8b21c621019ce25018e6
[ "MIT" ]
null
null
null
descriptors/__init__.py
WPaczula/image-fragmentation
f5650ff384bf803b3cca8b21c621019ce25018e6
[ "MIT" ]
null
null
null
descriptors/__init__.py
WPaczula/image-fragmentation
f5650ff384bf803b3cca8b21c621019ce25018e6
[ "MIT" ]
null
null
null
from descriptors.haralick import get_haralicks from descriptors.lbp import get_lbp from descriptors.hog import get_hog
39.333333
46
0.881356
18
118
5.611111
0.444444
0.445545
0
0
0
0
0
0
0
0
0
0
0.09322
118
3
47
39.333333
0.943925
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
0
0
null
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
74db8448252041399a8b471be0180831f6f74eef
40
py
Python
ansible_subprocess/__init__.py
blawesom/ansible-subprocess
4c04a265d8cf1bee15dd7dbc8166b1d81642f234
[ "MIT" ]
3
2016-11-22T12:43:15.000Z
2021-01-14T15:58:21.000Z
ansible_subprocess/__init__.py
blawesom/ansible-subprocess
4c04a265d8cf1bee15dd7dbc8166b1d81642f234
[ "MIT" ]
2
2020-01-01T05:28:56.000Z
2020-03-11T01:38:12.000Z
ansible_subprocess/__init__.py
blawesom/ansible-subprocess
4c04a265d8cf1bee15dd7dbc8166b1d81642f234
[ "MIT" ]
3
2017-11-24T14:21:04.000Z
2019-11-18T20:06:46.000Z
from .main import run_playbook, run_ping
40
40
0.85
7
40
4.571429
0.857143
0
0
0
0
0
0
0
0
0
0
0
0.1
40
1
40
40
0.888889
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
74f9fe4b46e57e51f27b84c8cf2c939bdd035db2
96
py
Python
venv/lib/python3.8/site-packages/jedi/common/__init__.py
Retraces/UkraineBot
3d5d7f8aaa58fa0cb8b98733b8808e5dfbdb8b71
[ "MIT" ]
2
2022-03-13T01:58:52.000Z
2022-03-31T06:07:54.000Z
venv/lib/python3.8/site-packages/jedi/common/__init__.py
DesmoSearch/Desmobot
b70b45df3485351f471080deb5c785c4bc5c4beb
[ "MIT" ]
19
2021-11-20T04:09:18.000Z
2022-03-23T15:05:55.000Z
venv/lib/python3.8/site-packages/jedi/common/__init__.py
DesmoSearch/Desmobot
b70b45df3485351f471080deb5c785c4bc5c4beb
[ "MIT" ]
null
null
null
/home/runner/.cache/pip/pool/c2/12/a2/2453035eedfb8af7c8b0bf4b253e20ea83c33b19874f4ee1918f0c0113
96
96
0.895833
9
96
9.555556
1
0
0
0
0
0
0
0
0
0
0
0.416667
0
96
1
96
96
0.479167
0
0
0
0
0
0
0
0
1
0
0
0
0
null
null
0
0
null
null
0
1
0
0
null
0
0
0
0
0
0
0
0
0
0
1
0
0
1
0
0
1
0
0
0
0
0
0
0
null
1
0
0
0
1
0
0
0
0
0
0
0
0
6
2d1edbedece3b088563616e2bfd468e2a94b9f04
138
py
Python
web/forms.py
wabscale/flasq
ea5cba81c3259441f64e96a7c63d2234728100a3
[ "MIT" ]
1
2022-02-25T02:12:10.000Z
2022-02-25T02:12:10.000Z
web/forms.py
wabscale/flasq
ea5cba81c3259441f64e96a7c63d2234728100a3
[ "MIT" ]
null
null
null
web/forms.py
wabscale/flasq
ea5cba81c3259441f64e96a7c63d2234728100a3
[ "MIT" ]
null
null
null
from flask_wtf import FlaskForm from flask_wtf.file import FileField, FileRequired, FileAllowed from wtforms.validators import Required
23
63
0.855072
18
138
6.444444
0.666667
0.155172
0.206897
0
0
0
0
0
0
0
0
0
0.115942
138
5
64
27.6
0.95082
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
0
0
null
0
1
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
2d27f65d3810b3dbdaa183d729578e760beb9c75
24
py
Python
__init__.py
mputs/BayesCCal
49113ae969d4e30651c4aaa28c622d988447da60
[ "MIT" ]
1
2021-06-02T17:59:37.000Z
2021-06-02T17:59:37.000Z
__init__.py
mputs/BayesCCal
49113ae969d4e30651c4aaa28c622d988447da60
[ "MIT" ]
null
null
null
__init__.py
mputs/BayesCCal
49113ae969d4e30651c4aaa28c622d988447da60
[ "MIT" ]
null
null
null
from BayesCCal import *
12
23
0.791667
3
24
6.333333
1
0
0
0
0
0
0
0
0
0
0
0
0.166667
24
2
23
12
0.95
0
0
0
0
0
0
0
0
0
0
0
0
1
0
true
0
1
0
1
0
1
1
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
1
0
1
0
1
0
0
6
2d344b6df986ef2087f2155abd8348966a3ef2ce
10,537
py
Python
iter8_analytics/api/v2/examples/examples_metrics.py
sriumcp/iter8-analytics
87704d0111328a718e6692d5f0aed946083732ba
[ "Apache-2.0" ]
14
2019-11-14T01:30:32.000Z
2021-09-10T06:03:51.000Z
iter8_analytics/api/v2/examples/examples_metrics.py
sriumcp/iter8-analytics
87704d0111328a718e6692d5f0aed946083732ba
[ "Apache-2.0" ]
120
2019-12-09T21:17:37.000Z
2021-07-21T00:21:17.000Z
iter8_analytics/api/v2/examples/examples_metrics.py
sriumcp/iter8-analytics
87704d0111328a718e6692d5f0aed946083732ba
[ "Apache-2.0" ]
14
2020-04-01T15:40:39.000Z
2021-08-19T14:23:40.000Z
""" Metric examples used in other examples. """ request_count = { "name": "request-count", "metricObj": { "apiVersion": "iter8.tools/v2alpha2", "kind": "Metric", "metadata": { "name": "request-count" }, "spec": { "type": "Counter", "params": [{ "name": "query", "value": "sum(increase(revision_app_request_latencies_count{service_name=~'.*$name'}[${elapsedTime}s])) or on() vector(0)" }], "description": "Number of requests", "provider": "prometheus", "jqExpression": ".data.result[0].value[1] | tonumber", "urlTemplate": "http://metrics-mock:8080/promcounter" } } } mean_latency = { "name": "mean-latency", "metricObj": { "apiVersion": "iter8.tools/v2alpha2", "kind": "Metric", "metadata": { "name": "mean-latency" }, "spec": { "description": "Mean latency", "units": "milliseconds", "params": [{ "name": "query", "value": "(sum(increase(revision_app_request_latencies_sum{service_name=~'.*$name'}[${elapsedTime}s]))or on() vector(0)) / (sum(increase(revision_app_request_latencies_count{service_name=~'.*$name'}[${elapsedTime}s])) or on() vector(0))" }], "type": "Gauge", "sampleSize": { "name": "request-count" }, "provider": "prometheus", "jqExpression": ".data.result[0].value[1] | tonumber", "urlTemplate": "http://metrics-mock:8080/promcounter" } } } # This yaml body is marshalled into the corresponding JSON body. # body: | # { # "last": $elapsedTime, # "sampling": 600, # "filter": "kubernetes.node.name = 'n1' and service = '$name'", # "metrics": [ # { # "id": "cpu.cores.used", # "aggregations": { "time": "avg", "group": "sum" } # } # ], # "dataSourceType": "container", # "paging": { # "from": 0, # "to": 99 # } cpu_utilization = { "name": "cpu-utilization", "metricObj": { "apiVersion": "iter8.tools/v2alpha2", "kind": "Metric", "metadata": { "name": "cpu-utilization" }, "spec": { "description": "CPU utilization", "body": "{\n \"last\": $elapsedTime,\n \"sampling\": 600,\n \"filter\": \"kubernetes.node.name = 'n1' and service = '$name'\",\n \"metrics\": [\n {\n \"id\": \"cpu.cores.used\",\n \"aggregations\": { \"time\": \"avg\", \"group\": \"sum\" }\n }\n ],\n \"dataSourceType\": \"container\",\n \"paging\": {\n \"from\": 0,\n \"to\": 99\n }\n}\n", "method": "POST", "type": "Gauge", "provider": "Sysdig", "jqExpression": ".data[0].d[0] | tonumber", "urlTemplate": "http://metrics-mock:8080/sysdig" } } } business_revenue = { "name": "business-revenue", "metricObj": { "apiVersion": "iter8.tools/v2alpha2", "kind": "Metric", "metadata": { "name": "business-revenue" }, "spec": { "description": "Business Revenue Metric", "units": "dollars", "params": [{ "name": "query", "value": "(sum(increase(business_revenue{service_name=~'.*$name'}[${elapsedTime}s]))or on() vector(0)) / (sum(increase(revision_app_request_latencies_count{service_name=~'.*$name'}[${elapsedTime}s])) or on() vector(0))" }], "type": "Gauge", "sampleSize": { "name": "request-count" }, "provider": "prometheus", "jqExpression": ".data.result[0].value[1] | tonumber", "urlTemplate": "http://prometheus-operated.iter8-monitoring:9090/api/v1/query" } } } new_relic_embedded = { "apiVersion": "iter8.tools/v2alpha2", "kind": "Metric", "metadata": { "name": "name-count" }, "spec": { "params": [ { "name": "nrql", "value": "SELECT count(appName) FROM PageView WHERE revisionName='${revision}' SINCE ${elapsedTime} seconds ago" } ], "description": "A New Relic example", "type": "Counter", "headerTemplates": [ { "name": "X-Query-Key", "value": "t0p-secret-api-key" } ], "provider": "newrelic", "jqExpression": ".results[0].count | tonumber", "urlTemplate": "https://insights-api.newrelic.com/v1/accounts/my_account_id" } } new_relic_secret = { "apiVersion": "iter8.tools/v2alpha2", "kind": "Metric", "metadata": { "name": "name-count" }, "spec": { "params": [ { "name": "nrql", "value": "SELECT count(appName) FROM PageView WHERE revisionName='${revision}' SINCE ${elapsedTime} seconds ago" } ], "description": "A New Relic example", "type": "Counter", "authType": "APIKey", "secret": "myns/nrcredentials", "headerTemplates": [ { "name": "X-Query-Key", "value": "${mykey}" } ], "provider": "newrelic", "jqExpression": ".results[0].count | tonumber", "urlTemplate": "https://insights-api.newrelic.com/v1/accounts/my_account_id" } } sysdig_embedded = { "apiVersion": "iter8.tools/v2alpha2", "kind": "Metric", "metadata": { "name": "cpu-utilization" }, "spec": { "description": "A Sysdig example", "provider": "sysdig", "body": "{\n \"last\": ${elapsedTime},\n \"sampling\": 600,\n \"filter\": \"kubernetes.app.revision.name = '${revision}'\",\n \"metrics\": [\n {\n \"id\": \"cpu.cores.used\",\n \"aggregations\": { \"time\": \"avg\", \"group\": \"sum\" }\n }\n ],\n \"dataSourceType\": \"container\",\n \"paging\": {\n \"from\": 0,\n \"to\": 99\n }\n}", "method": "POST", "type": "Gauge", "headerTemplates": [ { "name": "Accept", "value": "application/json" }, { "name": "Authorization", "value": "Bearer 87654321-1234-1234-1234-123456789012" } ], "jqExpression": ".data[0].d[0] | tonumber", "urlTemplate": "https://secure.sysdig.com/api/data" } } sysdig_secret = { "apiVersion": "iter8.tools/v2alpha2", "kind": "Metric", "metadata": { "name": "cpu-utilization" }, "spec": { "description": "A Sysdig example", "provider": "sysdig", "body": "{\n \"last\": ${elapsedTime},\n \"sampling\": 600,\n \"filter\": \"kubernetes.app.revision.name = '${revision}'\",\n \"metrics\": [\n {\n \"id\": \"cpu.cores.used\",\n \"aggregations\": { \"time\": \"avg\", \"group\": \"sum\" }\n }\n ],\n \"dataSourceType\": \"container\",\n \"paging\": {\n \"from\": 0,\n \"to\": 99\n }\n}", "method": "POST", "authType": "Bearer", "secret": "myns/sdcredentials", "type": "Gauge", "headerTemplates": [ { "name": "Accept", "value": "application/json" }, { "name": "Authorization", "value": "Bearer ${token}" } ], "jqExpression": ".data[0].d[0] | tonumber", "urlTemplate": "https://secure.sysdig.com/api/data" } } elastic_secret = { "apiVersion": "iter8.tools/v2alpha2", "kind": "Metric", "metadata": { "name": "average-sales" }, "spec": { "description": "An elastic example", "provider": "elastic", "body": "{\n \"aggs\": {\n \"range\": {\n \"date_range\": {\n \"field\": \"date\",\n \"ranges\": [\n { \"from\": \"now-${elapsedTime}s/s\" } \n ]\n }\n },\n \"items_to_sell\": {\n \"filter\": { \"term\": { \"version\": \"${revision}\" } },\n \"aggs\": {\n \"avg_sales\": { \"avg\": { \"field\": \"sale_price\" } }\n }\n }\n }\n}", "method": "POST", "authType": "Basic", "secret": "myns/elasticcredentials", "type": "Gauge", "headerTemplates": [ { "name": "Content-Type", "value": "application/json" } ], "jqExpression": ".aggregations.items_to_sell.avg_sales.value | tonumber", "urlTemplate": "https://secure.elastic.com/my/sales" } } mocked_request_count = { "name": "request-count", "metricObj": { "apiVersion": "iter8.tools/v2alpha2", "kind": "Metric", "metadata": { "name": "request-count" }, "spec": { "type": "Counter", "params": [{ "name": "query", "value": "sum(increase(revision_app_request_latencies_count{service_name=~'.*$name'}[${elapsedTime}s])) or on() vector(0)" }], "description": "Number of requests", "provider": "prometheus", "jqExpression": ".data.result[0].value[1] | tonumber", "urlTemplate": "http://metrics-mock:8080/promcounter", "mock": [ { "name": "default", "level": "0.001" }, { "name": "canary", "level": "0.00002" } ] } } } mocked_mean_latency = { "name": "mean-latency", "metricObj": { "apiVersion": "iter8.tools/v2alpha2", "kind": "Metric", "metadata": { "name": "mean-latency" }, "spec": { "description": "Mean latency", "units": "milliseconds", "params": [{ "name": "query", "value": "(sum(increase(revision_app_request_latencies_sum{service_name=~'.*$name'}[${elapsedTime}s]))or on() vector(0)) / (sum(increase(revision_app_request_latencies_count{service_name=~'.*$name'}[${elapsedTime}s])) or on() vector(0))" }], "type": "Gauge", "sampleSize": { "name": "request-count" }, "provider": "prometheus", "jqExpression": ".data.result[0].value[1] | tonumber", "urlTemplate": "http://metrics-mock:8080/promcounter", "mock": [ { "name": "default", "level": "20.0" }, { "name": "canary", "level": "10.0" } ] } } }
33.239748
410
0.480023
925
10,537
5.398919
0.182703
0.007609
0.044053
0.061674
0.800561
0.789347
0.762115
0.754505
0.74169
0.711254
0
0.022195
0.307298
10,537
317
411
33.239748
0.662008
0.042612
0
0.618881
0
0.017483
0.520815
0.09995
0
0
0
0
0
1
0
false
0
0
0
0
0
0
0
0
null
0
0
0
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
743b06c9b9babccd07fa5f3cb7217db6d4f93509
1,842
py
Python
tests/probes/test_slo_is_met.py
chaostoolkit-incubator/chaostoolkit-reliably
f7d7f1f262b9416f6caa66ade2082119d9718d50
[ "Apache-2.0" ]
null
null
null
tests/probes/test_slo_is_met.py
chaostoolkit-incubator/chaostoolkit-reliably
f7d7f1f262b9416f6caa66ade2082119d9718d50
[ "Apache-2.0" ]
4
2021-07-22T14:07:36.000Z
2022-01-28T12:50:22.000Z
tests/probes/test_slo_is_met.py
chaostoolkit-incubator/chaostoolkit-reliably
f7d7f1f262b9416f6caa66ade2082119d9718d50
[ "Apache-2.0" ]
null
null
null
from unittest.mock import MagicMock, patch from chaosreliably.slo.probes import slo_is_met @patch("chaosreliably.slo.probes.all_objective_results_ok") @patch("chaosreliably.slo.probes.get_objective_results_by_labels") def test_that_slo_is_met_correctly_calls_probe_and_tolerance_with_no_limit( mock_get_objective_results_by_labels: MagicMock, mock_all_objective_results_ok: MagicMock, ) -> None: expected_results = [{"objective_result": "a-result"}] mock_get_objective_results_by_labels.return_value = expected_results mock_all_objective_results_ok.return_value = True expected_labels = {"a-label": "a-label-value"} slo_is_met_result = slo_is_met(labels=expected_labels, limit=1) mock_get_objective_results_by_labels.assert_called_once_with( limit=1, labels=expected_labels, configuration=None, secrets=None ) mock_all_objective_results_ok.assert_called_once_with(expected_results) assert slo_is_met_result @patch("chaosreliably.slo.probes.all_objective_results_ok") @patch("chaosreliably.slo.probes.get_objective_results_by_labels") def test_that_slo_is_met_correctly_calls_probe_and_tolerance_with_limit( mock_get_objective_results_by_labels: MagicMock, mock_all_objective_results_ok: MagicMock, ) -> None: expected_results = [{"objective_result": "a-result"}] mock_get_objective_results_by_labels.return_value = expected_results mock_all_objective_results_ok.return_value = False expected_labels = {"a-label": "a-label-value"} slo_is_met_result = slo_is_met(labels=expected_labels, limit=10) mock_get_objective_results_by_labels.assert_called_once_with( limit=10, labels=expected_labels, configuration=None, secrets=None ) mock_all_objective_results_ok.assert_called_once_with(expected_results) assert not slo_is_met_result
40.043478
75
0.812704
260
1,842
5.223077
0.176923
0.188513
0.053019
0.123711
0.908689
0.908689
0.908689
0.908689
0.908689
0.908689
0
0.003656
0.109121
1,842
45
76
40.933333
0.823888
0
0
0.588235
0
0
0.161781
0.114007
0
0
0
0
0.176471
1
0.058824
false
0
0.058824
0
0.117647
0
0
0
0
null
0
0
0
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
744221466b465fa0fb1e34b9a380394b822b599a
19,017
py
Python
src/MSI/cti_core/cti_combine.py
carlylagrotta/MSI
e958beb5df2a2d1018bbb2f96382b5c99b08c3ef
[ "MIT" ]
1
2021-06-25T15:46:06.000Z
2021-06-25T15:46:06.000Z
src/MSI/cti_core/cti_combine.py
TheBurkeLab/MSI
e958beb5df2a2d1018bbb2f96382b5c99b08c3ef
[ "MIT" ]
null
null
null
src/MSI/cti_core/cti_combine.py
TheBurkeLab/MSI
e958beb5df2a2d1018bbb2f96382b5c99b08c3ef
[ "MIT" ]
2
2019-12-18T23:45:25.000Z
2021-06-10T20:37:20.000Z
# -*- coding: utf-8 -*- """ Created on Thu Aug 03 14:32:24 2017 @author: Mark Barbet """ """Active parameter CTI writer. Function takes a subset of reactions from an already modified cti file and writes them to internal memory. It then reads an input from a portion of the code dealing with master equation simulation and adds those reactions to create a complete internal mechanism """ import numpy as np import cantera as ct from ..utilities import soln2cti_py3 as ctiw def cti_write2(x={},original_cti='',master_rxns='',master_index=[],MP={},working_directory='',file_name=''): #print(MP) flatten = lambda *n: (e for a in n for e in (flatten(*a) if isinstance(a, (tuple, list)) else (a,))) #flatten master index master_index = list(flatten(master_index)) print(bool(x)) if not original_cti: raise Exception('Please provide a name for the original mechanism file and try again.') if not master_rxns and np.any(master_index): raise Exception('Please provide a mechanism file for reactions analysed with master equation or leave master_index empty') if master_rxns and not np.any(master_index): raise Exception('Please provide master_index, a non-empty list of reaction numbers from original file which are analysed with master equation.') if not master_rxns and not master_index: master_index=np.ones(ct.Solution(original_cti).n_reactions,dtype=bool) elif master_rxns and np.any(master_index): temp=np.ones(ct.Solution(original_cti).n_reactions,dtype=bool) for j in np.arange(len(master_index)): temp[master_index[j]-1]=False master_index=temp lineList=[] with open(original_cti) as f: lineList=f.readlines() done=False count=0 while not done or count<len(lineList): if 'Reaction data' in lineList[count] or 'Reaction Data' in lineList[count] or 'reaction data' in lineList[count]: done=True lineList=lineList[0:count-1] else:count+=1 #with open('tempcti.cti','w') as p: #p.writelines(lineList) #Attempt to get rid of temp cti files: NewModelSpecies=ct.Species.listFromFile(original_cti) NewModel=ct.Solution(thermo='IdealGas',kinetics='GasKinetics', species=NewModelSpecies) #NewModel=ct.Solution('tempcti.cti') original_mechanism=ct.Solution(original_cti) original_rxn_count=0 master_rxn_eqs=[] if master_rxns: with open(master_rxns) as f: reactionsList=f.readlines() lineList=lineList+reactionsList with open('masterTemp.cti','w') as f: f.writelines(lineList) master_reactions=ct.Solution('masterTemp.cti') master_rxn_eqs=master_reactions.reaction_equations() original_rxn_eqs=[] for i in np.arange(original_mechanism.n_reactions): if master_index[i]: NewModel.add_reaction(original_mechanism.reaction(i)) original_rxn_count+=1 original_rxn_eqs.append(original_mechanism.reaction_equation(i)) # if 'FalloffReaction' in str(type(original_mechanism.reaction(i))): # print(original_mechanism.reaction(i).high_rate) # print(original_mechanism.reaction(i).low_rate) if master_rxns: for i in np.arange(master_reactions.n_reactions): # print(master_reactions.reaction(i).rate) NewModel.add_reaction(master_reactions.reaction(i)) # #print(master_reactions.reaction(0).rate) if x=={}: for j in np.arange(original_rxn_count-1): #if master_index[j]: #print(str(type(original_mechanism.reaction(j))),str(type(NewModel.reaction(j)))) if 'ThreeBodyReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).rate=NewModel.reaction(j).rate elif 'ElementaryReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).rate=NewModel.reaction(j).rate elif 'FalloffReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).high_rate=NewModel.reaction(j).high_rate NewModel.reaction(j).low_rate=NewModel.reaction(j).low_rate if NewModel.reaction(j).falloff.type=='Troe': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff if NewModel.reaction(j).falloff.type=='Sri': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff elif 'ChemicallyActivatedReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).high_rate=NewModel.reaction(j).high_rate NewModel.reaction(j).low_rate=NewModel.reaction(j).low_rate if NewModel.reaction(j).falloff.type=='Troe': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff if NewModel.reaction(j).falloff.type=='Sri': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff elif 'PlogReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).rates=NewModel.reaction(j).rates elif 'ChebyshevReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).set_parameters(NewModel.reaction(j).Tmin,NewModel.reaction(j).Tmax,NewModel.reaction(j).Pmin,NewModel.reaction(j).Pmax,NewModel.reaction(j).coeffs) #Rinv = 1/R #cal/mol*K E = 1 #going test for energy #T = 4184 #T= 4.186e3 T=ct.gas_constant if x!={}: for j in np.arange(original_rxn_count-1): #if master_index[j]: try: if 'ThreeBodyReaction' in str(type(NewModel.reaction(j))): A=NewModel.reaction(j).rate.pre_exponential_factor n=NewModel.reaction(j).rate.temperature_exponent Ea=NewModel.reaction(j).rate.activation_energy NewModel.reaction(j).rate=ct.Arrhenius(A*np.exp(x['r'+str(j)]['A']),n+x['r'+str(j)]['n'],Ea+x['r'+str(j)]['Ea']*T) elif 'ElementaryReaction' in str(type(NewModel.reaction(j))): A=NewModel.reaction(j).rate.pre_exponential_factor n=NewModel.reaction(j).rate.temperature_exponent Ea=NewModel.reaction(j).rate.activation_energy NewModel.reaction(j).rate=ct.Arrhenius(A*np.exp(x['r'+str(j)]['A']),n+x['r'+str(j)]['n'],Ea+x['r'+str(j)]['Ea']*T) elif 'FalloffReaction' in str(type(NewModel.reaction(j))): A=NewModel.reaction(j).high_rate.pre_exponential_factor n=NewModel.reaction(j).high_rate.temperature_exponent Ea=NewModel.reaction(j).high_rate.activation_energy NewModel.reaction(j).high_rate=ct.Arrhenius(A*np.exp(x['r'+str(j)]['A']),n+x['r'+str(j)]['n'],Ea+x['r'+str(j)]['Ea']*T) A=NewModel.reaction(j).low_rate.pre_exponential_factor n=NewModel.reaction(j).low_rate.temperature_exponent Ea=NewModel.reaction(j).low_rate.activation_energy NewModel.reaction(j).low_rate=ct.Arrhenius(A*np.exp(x['r'+str(j)]['A']),n+x['r'+str(j)]['n'],Ea+x['r'+str(j)]['Ea']*T) if NewModel.reaction(j).falloff.type=='Troe': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff if NewModel.reaction(j).falloff.type=='Sri': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff elif 'ChemicallyActivatedReaction' in str(type(NewModel.reaction(j))): A=NewModel.reaction(j).high_rate.pre_exponential_factor n=NewModel.reaction(j).high_rate.temperature_exponent Ea=NewModel.reaction(j).high_rate.activation_energy NewModel.reaction(j).high_rate=ct.Arrhenius(A*np.exp(x['r'+str(j)]['A']),n+x['r'+str(j)]['n'],Ea+x['r'+str(j)]['Ea']*T) A=NewModel.reaction(j).low_rate.pre_exponential_factor n=NewModel.reaction(j).low_rate.temperature_exponent Ea=NewModel.reaction(j).low_rate.activation_energy NewModel.reaction(j).low_rate=ct.Arrhenius(A*np.exp(x['r'+str(j)]['A']),n+x['r'+str(j)]['n'],Ea+x['r'+str(j)]['Ea']*T) if NewModel.reaction(j).falloff.type=='Troe': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff if NewModel.reaction(j).falloff.type=='Sri': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff elif 'PlogReaction' in str(type(NewModel.reaction(j))): temp_rate=[] for number, reactions in enumerate(NewModel.reaction(j).rates): A = NewModel.reaction(j).rates[number][1].pre_exponential_factor n = NewModel.reaction(j).rates[number][1].temperature_exponent Ea = NewModel.reaction(j).rates[number][1].activation_energy pressure = NewModel.reaction(j).rates[number][0] temp_rate.append((pressure, ct.Arrhenius(A*np.exp(x['r'+str(j)]['A']),n+x['r'+str(j)]['n'],Ea+x['r'+str(j)]['Ea']*T))) NewModel.reaction(j).rates = temp_rate #NewModel.reaction(j).rates=NewModel.reaction(j).rates elif 'ChebyshevReaction' in str(type(original_mechanism.reaction(j))): NewModel.reaction(j).set_parameters(NewModel.reaction(j).Tmin,NewModel.reaction(j).Tmax,NewModel.reaction(j).Pmin,NewModel.reaction(j).Pmax,NewModel.reaction(j).coeffs) except: print ('we are in the except statment in marks code',j) if 'ThreeBodyReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).rate=NewModel.reaction(j).rate elif 'ElementaryReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).rate=NewModel.reaction(j).rate elif 'FalloffReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).high_rate=NewModel.reaction(j).high_rate NewModel.reaction(j).low_rate=NewModel.reaction(j).low_rate if NewModel.reaction(j).falloff.type=='Troe': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff if NewModel.reaction(j).falloff.type=='Sri': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff elif 'ChemicallyActivatedReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).high_rate=NewModel.reaction(j).high_rate NewModel.reaction(j).low_rate=NewModel.reaction(j).low_rate if NewModel.reaction(j).falloff.type=='Troe': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff if NewModel.reaction(j).falloff.type=='Sri': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff elif 'PlogReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).rates=NewModel.reaction(j).rates elif 'ChebyshevReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).set_parameters(NewModel.reaction(j).Tmin,NewModel.reaction(j).Tmax,NewModel.reaction(j).Pmin,NewModel.reaction(j).Pmax,NewModel.reaction(j).coeffs) if MP!={}: print('insdie the MP if statment') #print(MP) for j in np.arange(original_rxn_count,NewModel.n_reactions): try: if 'ThreeBodyReaction' in str(type(NewModel.reaction(j))): A=NewModel.reaction(j).rate.pre_exponential_factor n=NewModel.reaction(j).rate.temperature_exponent Ea=NewModel.reaction(j).rate.activation_energy NewModel.reaction(j).rate=ct.Arrhenius(A*np.exp(MP['r'+str(j)]['A']),n+MP['r'+str(j)]['n'],Ea+MP['r'+str(j)]['Ea']*E) elif 'ElementaryReaction' in str(type(NewModel.reaction(j))): A=NewModel.reaction(j).rate.pre_exponential_factor n=NewModel.reaction(j).rate.temperature_exponent Ea=NewModel.reaction(j).rate.activation_energy NewModel.reaction(j).rate=ct.Arrhenius(A*np.exp(MP['r'+str(j)]['A']),n+MP['r'+str(j)]['n'],Ea+MP['r'+str(j)]['Ea']*E) elif 'FalloffReaction' in str(type(NewModel.reaction(j))): A=NewModel.reaction(j).high_rate.pre_exponential_factor n=NewModel.reaction(j).high_rate.temperature_exponent Ea=NewModel.reaction(j).high_rate.activation_energy NewModel.reaction(j).high_rate=ct.Arrhenius(A*np.exp(MP['r'+str(j)]['A']),n+MP['r'+str(j)]['n'],Ea+MP['r'+str(j)]['Ea']*E) A=NewModel.reaction(j).low_rate.pre_exponential_factor n=NewModel.reaction(j).low_rate.temperature_exponent Ea=NewModel.reaction(j).low_rate.activation_energy NewModel.reaction(j).low_rate=ct.Arrhenius(A*np.exp(MP['r'+str(j)]['A']),n+MP['r'+str(j)]['n'],Ea+MP['r'+str(j)]['Ea']*E) if NewModel.reaction(j).falloff.type=='Troe': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff if NewModel.reaction(j).falloff.type=='Sri': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff elif 'ChemicallyActivatedReaction' in str(type(NewModel.reaction(j))): A=NewModel.reaction(j).high_rate.pre_exponential_factor n=NewModel.reaction(j).high_rate.temperature_exponent Ea=NewModel.reaction(j).high_rate.activation_energy NewModel.reaction(j).high_rate=ct.Arrhenius(A*np.exp(MP['r'+str(j)]['A']),n+MP['r'+str(j)]['n'],Ea+MP['r'+str(j)]['Ea']*E) A=NewModel.reaction(j).low_rate.pre_exponential_factor n=NewModel.reaction(j).low_rate.temperature_exponent Ea=NewModel.reaction(j).low_rate.activation_energy NewModel.reaction(j).low_rate=ct.Arrhenius(A*np.exp(MP['r'+str(j)]['A']),n+MP['r'+str(j)]['n'],Ea+MP['r'+str(j)]['Ea']*E) if NewModel.reaction(j).falloff.type=='Troe': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff if NewModel.reaction(j).falloff.type=='Sri': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff elif 'PlogReaction' in str(type(NewModel.reaction(j))): for number, reactions in enumerate(NewModel.reaction(j).rates): A = NewModel.reaction(j)[number][1].pre_exponential_factor n = NewModel.reaction(j)[number][1].temperature_exponent Ea = NewModel.reaction(j)[number][1].activation_energy NewModel.reaction(j)[number][1] = ct.Arrhenius(A*np.exp(MP['r'+str(j)]['A']),n+MP['r'+str(j)]['n'],Ea+MP['r'+str(j)]['Ea']*E) NewModel.reaction(j).rates=NewModel.reaction(j).rates elif 'ChebyshevReaction' in str(type(NewModel.reaction(j))): converted = MP['r'+str(j)]/np.log(10) test = NewModel.reaction(j).coeffs +converted NewModel.reaction(j).set_parameters(NewModel.reaction(j).Tmin,NewModel.reaction(j).Tmax,NewModel.reaction(j).Pmin,NewModel.reaction(j).Pmax,(test)) except: print ('we are in the except statment in marks code',j) if 'ThreeBodyReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).rate=NewModel.reaction(j).rate elif 'ElementaryReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).rate=NewModel.reaction(j).rate elif 'FalloffReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).high_rate=NewModel.reaction(j).high_rate NewModel.reaction(j).low_rate=NewModel.reaction(j).low_rate if NewModel.reaction(j).falloff.type=='Troe': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff if NewModel.reaction(j).falloff.type=='Sri': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff elif 'ChemicallyActivatedReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).high_rate=NewModel.reaction(j).high_rate NewModel.reaction(j).low_rate=NewModel.reaction(j).low_rate if NewModel.reaction(j).falloff.type=='Troe': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff if NewModel.reaction(j).falloff.type=='Sri': NewModel.reaction(j).falloff=NewModel.reaction(j).falloff elif 'PlogReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).rates=NewModel.reaction(j).rates elif 'ChebyshevReaction' in str(type(NewModel.reaction(j))): NewModel.reaction(j).set_parameters(NewModel.reaction(j).Tmin,NewModel.reaction(j).Tmax,NewModel.reaction(j).Pmin,NewModel.reaction(j).Pmax,NewModel.reaction(j).coeffs) new_file=ctiw.write(NewModel, cwd=working_directory,file_name=file_name,original_cti=original_cti) #tab return new_file,original_rxn_eqs,master_rxn_eqs
61.944625
212
0.573014
2,269
19,017
4.709564
0.09167
0.191185
0.357945
0.134756
0.788415
0.764645
0.754726
0.750795
0.731518
0.723096
0
0.003503
0.294368
19,017
306
213
62.147059
0.792831
0.04191
0
0.670996
0
0.004329
0.066689
0.007547
0
0
0
0
0
1
0.004329
false
0
0.012987
0
0.021645
0.017316
0
0
0
null
0
1
0
0
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
0
0
0
0
0
0
0
6
7794a404ef721f23086ce2ab23e2c4524ae9c056
2,950
py
Python
test_rm.py
ClaudeNovaMB/rightmove_webscraper.py
2077b5f46a0ccfb307426857e5ea9f86b6fb5d67
[ "MIT" ]
null
null
null
test_rm.py
ClaudeNovaMB/rightmove_webscraper.py
2077b5f46a0ccfb307426857e5ea9f86b6fb5d67
[ "MIT" ]
null
null
null
test_rm.py
ClaudeNovaMB/rightmove_webscraper.py
2077b5f46a0ccfb307426857e5ea9f86b6fb5d67
[ "MIT" ]
null
null
null
import pandas as pd import unittest from rightmove_webscraper import RightmoveData base_url = "https://www.rightmove.co.uk/" columns = sorted(["price", "type", "address", "url", "agent_url", "postcode", "number_bedrooms", "search_date"]) class RightmoveWebscraperTest(unittest.TestCase): """Unit tests for the `RightmoveWebscraper` class.""" def test_sale(self): """Test a search on properties for sale.""" url = f"{base_url}property-for-sale/find.html?searchType=SALE&locationIdentifier=REGION%5E94346&insId=1" rmd = RightmoveData(url) self.assertIsInstance(rmd.average_price, float) self.assertIsInstance(rmd.get_results, pd.DataFrame) self.assertListEqual(sorted(rmd.get_results.columns), columns) self.assertGreater(len(rmd.get_results), 0) self.assertIsInstance(rmd.page_count, int) self.assertEqual(rmd.rent_or_sale, "sale") self.assertIsInstance(rmd.results_count, int) self.assertIsInstance(rmd.results_count_display, int) self.assertEqual(url, rmd.url) df = rmd.summary() self.assertIsInstance(df, pd.DataFrame) self.assertListEqual(sorted(["number_bedrooms", "count", "mean"]), sorted(df.columns)) self.assertGreater(len(df), 0) for c in columns: df = rmd.summary(by=c) self.assertIsInstance(df, pd.DataFrame) self.assertListEqual(sorted([c, "count", "mean"]), sorted(df.columns)) self.assertGreater(len(df), 0) def test_rent(self): """Test a search on properties for sale.""" url = f"{base_url}property-to-rent/find.html?searchType=RENT&locationIdentifier=REGION%5E94346" rmd = RightmoveData(url) self.assertIsInstance(rmd.average_price, float) self.assertIsInstance(rmd.get_results, pd.DataFrame) self.assertListEqual(sorted(rmd.get_results.columns), columns) self.assertGreater(len(rmd.get_results), 0) self.assertIsInstance(rmd.page_count, int) self.assertEqual(rmd.rent_or_sale, "rent") self.assertIsInstance(rmd.results_count, int) self.assertIsInstance(rmd.results_count_display, int) self.assertEqual(url, rmd.url) df = rmd.summary() self.assertIsInstance(df, pd.DataFrame) self.assertListEqual(sorted(["number_bedrooms", "count", "mean"]), sorted(df.columns)) self.assertGreater(len(df), 0) for c in columns: df = rmd.summary(by=c) self.assertIsInstance(df, pd.DataFrame) self.assertListEqual(sorted([c, "count", "mean"]), sorted(df.columns)) self.assertGreater(len(df), 0) def test_bad_url(self): """Test a bad URL raises a value error.""" bad_url = "https://www.rightmove.co.uk/property" with self.assertRaises(ValueError): _ = RightmoveData(bad_url) if __name__ == "__main__": unittest.main()
42.142857
112
0.664068
352
2,950
5.440341
0.244318
0.146214
0.120104
0.093995
0.739426
0.739426
0.71436
0.71436
0.71436
0.71436
0
0.008109
0.205763
2,950
69
113
42.753623
0.809219
0.054237
0
0.666667
0
0.037037
0.140535
0.06539
0
0
0
0
0.574074
1
0.055556
false
0
0.055556
0
0.12963
0
0
0
0
null
0
0
0
0
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
1
0
0
0
0
0
0
0
0
0
6
77e7c50c439da73f7a25ca67244d0128f870a03e
1,413
py
Python
data/train/python/77e7c50c439da73f7a25ca67244d0128f870a03e__init__.py
harshp8l/deep-learning-lang-detection
2a54293181c1c2b1a2b840ddee4d4d80177efb33
[ "MIT" ]
84
2017-10-25T15:49:21.000Z
2021-11-28T21:25:54.000Z
data/train/python/77e7c50c439da73f7a25ca67244d0128f870a03e__init__.py
vassalos/deep-learning-lang-detection
cbb00b3e81bed3a64553f9c6aa6138b2511e544e
[ "MIT" ]
5
2018-03-29T11:50:46.000Z
2021-04-26T13:33:18.000Z
data/train/python/77e7c50c439da73f7a25ca67244d0128f870a03e__init__.py
vassalos/deep-learning-lang-detection
cbb00b3e81bed3a64553f9c6aa6138b2511e544e
[ "MIT" ]
24
2017-11-22T08:31:00.000Z
2022-03-27T01:22:31.000Z
# -*- encoding: utf-8 -*- __author__ = 'faide' from sqlalchemy import MetaData metadata = MetaData() from xbus.broker.model.auth.main import user from xbus.broker.model.auth.main import group from xbus.broker.model.auth.main import permission from xbus.broker.model.auth.main import user_group_table from xbus.broker.model.auth.main import group_permission_table from xbus.broker.model.auth.main import role from xbus.broker.model.auth.main import emitter from xbus.broker.model.auth.helpers import gen_password from xbus.broker.model.auth.helpers import validate_password from xbus.broker.model.setupmodel import setup_app from xbus.broker.model.service import service from xbus.broker.model.event import event_type from xbus.broker.model.event import event_node from xbus.broker.model.event import event_node_rel from xbus.broker.model.emission import emission_profile from xbus.broker.model.emission import emitter_profile from xbus.broker.model.emission import emitter_profile_event_type_rel from xbus.broker.model.input import input_descriptor from xbus.broker.model.logging import envelope from xbus.broker.model.logging import event from xbus.broker.model.logging import event_error from xbus.broker.model.logging import event_error_tracking from xbus.broker.model.logging import event_tracking from xbus.broker.model.logging import item from xbus.broker.model.logging import event_consumer_inactive_rel
44.15625
69
0.847134
220
1,413
5.309091
0.195455
0.171233
0.299658
0.406678
0.781678
0.730308
0.674658
0.390411
0.086473
0
0
0.000772
0.082803
1,413
31
70
45.580645
0.900463
0.016277
0
0
0
0
0.003602
0
0
0
0
0
0
1
0
false
0.071429
0.928571
0
0.928571
0
0
0
0
null
0
1
1
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
null
0
0
0
0
0
0
0
1
1
0
1
0
0
6