diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..54885c0 --- /dev/null +++ b/.gitignore @@ -0,0 +1,21 @@ +data/ +local/ +venv/ +.idea/ +*.log +*.pyc +*.ipynb +!curve_analyzer/visual/trait_results_multi_comparison.ipynb +.ipynb_checkpoints +*/.ipynb_checkpoints/* +curve_analyzer/**/__pycache__ +curve_analyzer/traits/test_launcher.py +curve_analyzer/traits/.* +curve_analyzer/traits/sample_curves.py +curve_analyzer/traits/**/*.json +curve_analyzer/traits/**/*.params +curve_analyzer/traits/**/*.txt +curve_analyzer/utils/parallel/results/* +curve_analyzer/curves_json_sim/* +/curve_analyzer.egg-info/ +DiSSECT.egg-info diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml new file mode 100644 index 0000000..ffc3232 --- /dev/null +++ b/.gitlab-ci.yml @@ -0,0 +1,19 @@ +image: + name: sagemath/sagemath:latest + entrypoint: [ "" ] + +variables: + GIT_SUBMODULE_STRATEGY: recursive + +stages: + - test + +test: + tags: + - shared-fi + before_script: + - sage --pip3 install Ptable + script: + - export PATH=$PATH:`sage -c "import sys; import os; print(os.path.join([x for x in sys.path if 'src/bin' in x][0],'../../local/bin') + ':' + \":\".join(sys.path))" 2>/dev/null` + - sage --python3 setup.py install + - sage --python3 -m unittest discover curve_analyzer/traits/unit_tests diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..d727e63 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,10 @@ +[submodule "curve_analyzer/curves_json"] + path = curve_analyzer/curves_json + url = https://github.com/J08nY/std-curves.git + branch = data + update = merge +[submodule "curve_analyzer/utils/efd"] + path = curve_analyzer/utils/efd + url = https://github.com/J08nY/efd.git + branch = master + update = merge \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..e118972 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2020 CRoCS FI MUNI + +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. diff --git a/README.md b/README.md new file mode 100644 index 0000000..ce34750 --- /dev/null +++ b/README.md @@ -0,0 +1,105 @@ +# DiSSECT: Distinguisher of Standard & Simulated Elliptic Curves through Traits + +[![pipeline status](https://gitlab.fi.muni.cz/x408178/curve_analyzer/badges/master/pipeline.svg)](https://gitlab.fi.muni.cz/x408178/curve_analyzer/-/commits/master) +[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://gitlab.fi.muni.cz/x408178/curve_analyzer/-/blob/master/LICENSE) +[![language](https://badgen.net/badge/language/python,sage/purple?list=/)](https://www.sagemath.org/) +[![traits](https://badgen.net/badge/traits/13/blue)](https://gitlab.fi.muni.cz/x408178/curve_analyzer/-/tree/master/curve_analyzer/traits) +[![curves](https://badgen.net/badge/curves/158%20std,%20217188%20sim?list=|)](https://github.com/J08nY/std-curves) + +# Setup +**Using virtual environment**: + +- Create virtual environment for python in sage: `sage --python3 -m venv --system-site-packages environment` + +- Activate the environment: `source environment/bin/activate` + +- Run `pip3 install --editable .` in curve_analyzer folder + +**Alternatively without virtual environment (not recommended)**: +From the root directory, run `sage --python3 setup.py develop --user` to initialize the project. + +## Running the curve traits + +Run `./run_traits.py` in directory `traits`. Use the `-h` flag to get the help menu. To merge the results of a trait ( +a05 in this case) into single file, run `./merge_trait_results.py -n a05`. + +### Example usage + +To run trait a05 on all standard curves of bitsizes up to 192 with cofactor 1 or 2 in verbose mode using 3 cores and 100 +jobs, run `./run_traits.py -n a05 -c std -v -b 192 -a 1 2 -t 3 -j 100`. + +### Supported curve sets + +- std: all standard curves +- sim: all simulated curves +- sample: curves secp112r1, secp192r1, secp256r1 +- all: all curves in the database + +## Overview of available traits + +| name | description | implemented | computed\* |time req.\*\* |memory req.\*\*\* +|:-------:| ----------------------------------------------------------------------------------|:------------------:|:------------------:|:------------:|:---------: +a01 | group stucture of the curve in field extensions | :white_check_mark: | :x: | high | low +a02 | CM discriminant, its factorizations and max conductors in field extensions | :white_check_mark: | :white_check_mark: | high | medium +a04 | factorizations of $`kn\pm 1`$ | :white_check_mark: | :white_check_mark: | high | high +a05 | field extensions containing nontrivial/full $`l`$-torsion | :white_check_mark: | :white_check_mark: | medium | low + a06 | Kronecker symbols of CM discriminants in field extensions w.r.t. small primes | :white_check_mark: | :white_check_mark: | high | medium + a08 | class number of the maximal order of the endomorphism ring | :white_check_mark: | :x: | extreme | low +a12 | multiplicative orders of small primes modulo curve order | :white_check_mark: | :white_check_mark: | medium | medium +a22 | factorizations of small division polynomials | :white_check_mark: | :white_check_mark: | high | high +a23 | volcano depth and crater degree in the $`l`$-isogeny graph | :white_check_mark: | :white_check_mark: | high | low +a24 | field extensions containing nontrivial/full number of $`l`$-isogenies | :white_check_mark: | :white_check_mark: | medium | low +a25 | trace in field extensions and its factorization | :white_check_mark: | :white_check_mark: | low | low +i06 | square parts of $`4q-1`$ and $`4n-1`$ | :white_check_mark: | :white_check_mark: | low | low +i07 | distance of $`n`$ from the nearest power of two and multiple of 32/64 | :white_check_mark: | :white_check_mark: | low | low +i10 | points satisfying ZVP conditions | :white_check_mark: | :x: | medium | high + +Notation: $`n`$ is the curve order, $`q`$ is the order of the base field +\* on sim and std curves with at most 256 bits and cofactor 1 +\*\* this is very rough and subjective +\*\*\* on the above dataset: low is <100 MB, medium is 100-500 MB, high is >500 MB (measuring JSONs) + +## Overview of planned traits + +| name | description | fully specified +|:-------:| ----------------------------------------------------------------------------------|:------------------: + a03 | distribution and sizes of isogeny classes | :x: + a07 | lifts of curves to other fields | :x: + a09 | existence of pairing-friendly cycles | :x: + a10 | existence of factorization bases | :x: + a11 | minimal codewords in elliptic codes | :x: + a13 | images of points under pairings | :x: + a14 | conductor and modularity | :x: + a15 | the lattice associated to the curve over $`C`$ | :x: + a16 | the Neron model | :x: + a17 | the L-series | :x: + a18 | the invariant differential | :x: + a19 | local heights | :x: + a20 | $`S`$-integral points | :x: + a21 | Galois groups of various polynomials | :x: + a22 | the embedding degree | :x: + i01 | curves under parameter bitflips | :x: + i02 | curves with the same $`j`$-invariant/group order, but different $`q`$ | :x: + i03 | the number of modular reductions in various computations | :x: + i04 | the coordinates of special scalar multiples | :x: + i05 | vulnerability against $`\rho`$ and kangaroo | :x: +i08 | properties of quadratic twists | :x: +i09 | quadratic residuosity of $`b`$ | :x: +s01 | statistical properties of scalar multiplication | :x: +s02 | distribution of point coordinates in various intervals | :x: +s03 | properties of other curve models | :x: +s04 | modular polynomials in given $`j`$-invariant | :x: +s05 | images of points under isogenies | :x: +s06 | summation polynomials | :x: +s07 | distributions of curves with similar properties | :x: +s08 | properties of the function shifting a point by the generator | :x: + +## Unit tests + +Run `sage --python3 -m unittest discover` in directory `traits/unit_tests/`. Only unit tests starting with `test` will +be run; those starting with `local` have to be run manually (as they require resources not available on the server). + +## Parameters and structure + +From directory `traits`, parameter files can be (re)generated by `sage --python3 params.py` and structure files can be ( +re)generated by `sage --python3 traits/traits_structures.py -t all` (both of these are already done during the setup). diff --git a/curve_analyzer/__init__.py b/curve_analyzer/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/curves_json b/curve_analyzer/curves_json new file mode 160000 index 0000000..73397a4 --- /dev/null +++ b/curve_analyzer/curves_json @@ -0,0 +1 @@ +Subproject commit 73397a4d61733da53e87415826f3133cf3ff8a09 diff --git a/curve_analyzer/definitions.py b/curve_analyzer/definitions.py new file mode 100644 index 0000000..0ac6be1 --- /dev/null +++ b/curve_analyzer/definitions.py @@ -0,0 +1,20 @@ +import re +from pathlib import Path + +ROOT_DIR = Path(__file__).parent # This is your Project Root +CURVE_PATH = Path(ROOT_DIR, 'curves_json') +CURVE_PATH_SIM = Path(ROOT_DIR, 'curves_json_sim') +TRAIT_PATH = Path(ROOT_DIR, 'traits') +PARALLEL_RESULTS_PATH = Path(ROOT_DIR, 'utils', 'parallel', 'results') +ZVP_PATH = Path(ROOT_DIR, 'utils', 'zvp') +EFD_PATH = Path(ROOT_DIR, 'utils', 'efd') +EFD_SHORTW_PROJECTIVE_ADDITION_PATH = Path(EFD_PATH, 'shortw', 'projective', 'addition') +EFD_SHORTW_PROJECTIVE_ADDITION_FORMULAS = [f for f in EFD_SHORTW_PROJECTIVE_ADDITION_PATH.iterdir() if + f.suffix == '.op3'] +EFD_SHORTW_PROJECTIVE_MINUS3_ADDITION_PATH = Path(EFD_PATH, 'shortw', 'projective-3', 'addition') +EFD_SHORTW_PROJECTIVE_MINUS3_ADDITION_FORMULAS = [f for f in EFD_SHORTW_PROJECTIVE_MINUS3_ADDITION_PATH.iterdir() if + f.suffix == '.op3'] +X962_PATH = Path(ROOT_DIR, 'utils', 'parallel', 'x962') +TRAIT_MODULE_PATH = 'curve_analyzer.traits' +TRAIT_NAME_CONDITION = r'[ais][0-9][0-9]' +TRAIT_NAMES = [f.name for f in TRAIT_PATH.iterdir() if f.is_dir() and re.search(TRAIT_NAME_CONDITION, f.name)] diff --git a/curve_analyzer/traits/__init__.py b/curve_analyzer/traits/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/traits/a01/__init__.py b/curve_analyzer/traits/a01/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/traits/a01/a01.py b/curve_analyzer/traits/a01/a01.py new file mode 100644 index 0000000..da812c1 --- /dev/null +++ b/curve_analyzer/traits/a01/a01.py @@ -0,0 +1,46 @@ +from sage.all import GF, Integer + +from curve_analyzer.traits.trait_interface import pretty_print_results, compute_results, timeout + +# global time for one factorization +TIME = 10 + + +def a01_curve_function(curve, deg): + """returns the orders of the two generators of the curve over the deg-th relative extension""" + E = curve.EC + q = curve.q + curve_results = {} + + E_ext = E.base_extend(GF(q ** deg)) + t = TIME + curve_results['ord1'] = timeout(E_ext.abelian_group().gens()[0].order, [], timeout_duration=t) + if not isinstance(curve_results['ord1'],Integer): + curve_results['ord2'] = 1 + return curve_results + try: + curve_results['ord2'] = timeout(E_ext.abelian_group().gens()[1].order, [], timeout_duration=t) + except IndexError: + curve_results['ord2'] = 1 + return curve_results + + +def compute_a01_results(curve_list, desc='', verbose=False): + compute_results(curve_list, 'a01', a01_curve_function, desc=desc, verbose=verbose) + + +def get_a01_captions(results): + return ['ord1', 'ord2'] + + +def select_a01_results(curve_results): + keys = ['ord1', 'ord2'] + selected_results = [] + for key in keys: + for x in curve_results: + selected_results.append(x[key]) + return selected_results + + +def pretty_print_a01_results(curve_list, save_to_txt=True): + pretty_print_results(curve_list, 'a01', get_a01_captions, select_a01_results, save_to_txt=save_to_txt) diff --git a/curve_analyzer/traits/a02/__init__.py b/curve_analyzer/traits/a02/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/traits/a02/a02.py b/curve_analyzer/traits/a02/a02.py new file mode 100644 index 0000000..7dd7e20 --- /dev/null +++ b/curve_analyzer/traits/a02/a02.py @@ -0,0 +1,64 @@ +from sage.all import ZZ, sqrt, factor, squarefree_part + +from curve_analyzer.traits.trait_interface import pretty_print_results, compute_results, timeout + +# global time for one factorization +TIME = 10 + + +def ext_trace(q, t, deg): + a = 2 + b = t + for _ in range(deg - 1): + tmp = b + b = t * b - q * a + a = tmp + return b + + +def a02_curve_function(curve, deg): + ''' + Computation of d_K (cm_disc), v (max_conductor) and factorization of D where D=t^2-4q = v^2*d_K + Returns a dictionary (keys: 'cm_disc', 'factorization', 'max_conductor') + ''' + t = curve.trace + q = curve.q + curve_results = {} + t = ext_trace(q, t, deg) + q = q ** deg + D = t ** 2 - 4 * q + d = squarefree_part(D) + disc = d + if d % 4 != 1: + disc *= 4 + curve_results['cm_disc'] = disc + t = TIME + factorization = timeout(factor, [D], timeout_duration=t) + if factorization == 'NO DATA (timed out)': + curve_results['factorization'] = [] + else: + tuples_to_lists = [list(i) for i in list(factorization)] + curve_results['factorization'] = tuples_to_lists + curve_results['max_conductor'] = ZZ(sqrt(D / disc)) + return curve_results + + +def compute_a02_results(curve_list, desc='', verbose=False): + compute_results(curve_list, 'a02', a02_curve_function, desc=desc, verbose=verbose) + + +def get_a02_captions(results): + return ['max_conductor', 'factorization', 'cm_disc'] + + +def select_a02_results(curve_results): + keys = ['max_conductor', 'factorization', 'cm_disc'] + selected_results = [] + for key in keys: + for x in curve_results: + selected_results.append(x[key]) + return selected_results + + +def pretty_print_a02_results(curve_list, save_to_txt=True): + pretty_print_results(curve_list, 'a02', get_a02_captions, select_a02_results, save_to_txt=save_to_txt) diff --git a/curve_analyzer/traits/a04/__init__.py b/curve_analyzer/traits/a04/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/traits/a04/a04.py b/curve_analyzer/traits/a04/a04.py new file mode 100644 index 0000000..0718a1b --- /dev/null +++ b/curve_analyzer/traits/a04/a04.py @@ -0,0 +1,67 @@ +from sage.all import ecm + +from curve_analyzer.traits.trait_interface import pretty_print_results, compute_results, timeout + +# global time for one factorization +TIME = 10 + + +def near_order_factorizations(n, sign='+', k=10, t=10): + '''Computer factorization of k*n+1 (k*n-1) if 'sign' is "+" ("-") in time 't' ''' + assert sign in ['+', '-'] + + if sign == '+': + m = k * n + 1 + else: + m = k * n - 1 + return timeout(ecm.factor, [m], timeout_duration=t) + + +def largest_factor_bitlen(factorization): + '''Computes bit length of largest factor(last item of list) of 'factorization' ''' + try: + bitlen = factorization[-1].nbits() + except AttributeError: + bitlen = factorization + return bitlen + + +def a04_curve_function(curve, k): + ''' + Computes factorization of ord*k+1 and ord*k-1 and bit lengths of their largest factors + Returns a dictionary + noinspection PyDictCreation + ''' + card = curve.cardinality + t = TIME + curve_results = {} + curve_results['(+)factorization'] = near_order_factorizations(card, '+', k, t) + curve_results['(+)largest_factor_bitlen'] = largest_factor_bitlen(curve_results['(+)factorization']) + curve_results['(-)factorization'] = near_order_factorizations(card, '-', k, t) + curve_results['(-)largest_factor_bitlen'] = largest_factor_bitlen(curve_results['(-)factorization']) + return curve_results + + +def compute_a04_results(curve_list, desc='', verbose=False): + compute_results(curve_list, 'a04', a04_curve_function, desc=desc, verbose=verbose) + + +def get_a04_captions(results): + captions = ['factorization (+)', 'largest_factor_bitlen (+)', ' factorization (-)', 'largest_factor_bitlen (-)'] + return captions + + +def select_a04_results(curve_results): + keys = [('(+)' + 'factorization'), ('(+)' + 'largest_factor_bitlen'), ('(-)' + 'factorization'), + ('(-)' + 'largest_factor_bitlen')] + selected_results = [] + for key in keys: + selected_key = [] + for x in curve_results: + selected_key.append(x[key]) + selected_results.append(selected_key) + return selected_results + + +def pretty_print_a04_results(curve_list, save_to_txt=True): + pretty_print_results(curve_list, 'a04', get_a04_captions, select_a04_results, save_to_txt=save_to_txt) diff --git a/curve_analyzer/traits/a05/__init__.py b/curve_analyzer/traits/a05/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/traits/a05/a05.py b/curve_analyzer/traits/a05/a05.py new file mode 100644 index 0000000..d8f166a --- /dev/null +++ b/curve_analyzer/traits/a05/a05.py @@ -0,0 +1,155 @@ +from sage.all import ZZ, PolynomialRing, GF, Integers, log, EllipticCurve + +from curve_analyzer.traits.trait_interface import pretty_print_results, compute_results + + +def embedding_degree_q(q, l): + """returns embedding degree with respect to q""" + return (Integers(l)(q)).multiplicative_order() + + +def ext_card(q, card_low, deg): + """returns curve cardinality over deg-th relative extension""" + tr = q + 1 - card_low + s_old, s_new = 2, tr + for _ in range(2, deg + 1): + s_old, s_new = s_new, tr * s_new - q * s_old + card_high = q ** deg + 1 - s_new + return card_high + + +def stupid_coerce_K_to_L(element, K, L): + name_K = str(K.gen()) + name_L = str(L.gen()) + return L(str(element).replace(name_K, name_L)) + + +def extend(E, q, deg, field): + """returns curve over the deg-th relative extension""" + if q % 2 != 0: + R = field['x'] + pol = R.irreducible_element(deg) + Fext = GF(q ** deg, name='z', modulus=pol) + return E.base_extend(Fext) + K = field + charac = K.characteristic() + R = GF(charac)['x'] + ext_deg = q ** deg + pol = R.irreducible_element(deg * (log(q, charac))) + Kext = GF(ext_deg, name='ex', modulus=pol) + gKext = Kext.gen() + + h = gKext ** ((ext_deg - 1) // (q - 1)) + assert charac ** (h.minpoly().degree()) == q + H = GF(q, name='h', modulus=h.minpoly()) + inclusion = H.hom([h]) + + new_coefficients = [inclusion(stupid_coerce_K_to_L(a, K, H)) for a in E.a_invariants()] + EE = EllipticCurve(Kext, new_coefficients) + return EE + + +def find_least_torsion(q, order, l): + ''' + Computes the smallest extension which contains a nontrivial l-torsion point + Returns the degree + ''' + x = PolynomialRing(GF(l ** 2), 'x').gen() + t = q + 1 - order + + f = x ** 2 - t * x + q + + roots = [r[0] for r in f.roots() for _ in range(r[1])] + + return min(roots[0].multiplicative_order(), roots[1].multiplicative_order()) + + +def is_torsion_cyclic(E, q, order, l, deg, field): + ''' + True if the l-torsion is cyclic and False otherwise (bycyclic) + ''' + card = ext_card(q, order, deg) + m = ZZ(card / l) + EE = extend(E, q, deg, field) + for _ in range(1, 6): + P = EE.random_element() + if not (m * P == EE(0)): + return True + return False + + +def find_full_torsion(E, q, order, l, least, field): + ''' + Computes the smallest extension which contains full l-torsion subgroup + Least is the result of find_least_torsion + Returns the degree + ''' + q_least = q ** least + k = embedding_degree_q(q_least, l) + # k satisfies l|a^k-1 where a,1 are eigenvalues of Frobenius of extended E + if k > 1: # i.e. a!=1 + return k * least + else: # i.e. a==1, we have two options for the geometric multiplicity + card = ext_card(q, order, least) + if (card % l ** 2) == 0 and not is_torsion_cyclic(E, q, order, l, least, field): # geom. multiplicity is 2 + return least + else: # geom. multiplicity is 1 + return l * least + + # Computes k1,k2, k2/k1 where k2(k1) is the smallest extension containing all(some) l-torsion points + + +def find_torsions(E, q, order, l, field): + '''Returns a triple of extensions containin torsion''' + least = find_least_torsion(q, order, l) + if least == l ** 2 - 1: + full = least + + else: + full = find_full_torsion(E, q, order, l, least, field) + + return least, full, ZZ(full / least) + + +def a05_curve_function(curve, l): + '''Computes find_torsions for given l and returns a dictionary''' + E = curve.EC + q = curve.q + order = curve.order * curve.cofactor + curve_results = {} + + try: + least, full, relative = find_torsions(E, q, order, l, curve.field) + + except (ArithmeticError, TypeError, ValueError) as _: + least, full, relative = None, None, None + + curve_results['least'] = least + curve_results['full'] = full + curve_results['relative'] = relative + + return curve_results + + +def compute_a05_results(curve_list, desc='', verbose=False): + compute_results(curve_list, 'a05', a05_curve_function, desc=desc, verbose=verbose) + + +def get_a05_captions(results): + captions = ['least', 'full', 'relative'] + return captions + + +def select_a05_results(curve_results): + keys = ['least', 'full', 'relative'] + selected_results = [] + for key in keys: + selected_key = [] + for x in curve_results: + selected_key.append(x[key]) + selected_results.append(selected_key) + return selected_results + + +def pretty_print_a05_results(curve_list, save_to_txt=True): + pretty_print_results(curve_list, 'a05', get_a05_captions, select_a05_results, save_to_txt=save_to_txt) diff --git a/curve_analyzer/traits/a06/__init__.py b/curve_analyzer/traits/a06/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/traits/a06/a06.py b/curve_analyzer/traits/a06/a06.py new file mode 100644 index 0000000..ff645a6 --- /dev/null +++ b/curve_analyzer/traits/a06/a06.py @@ -0,0 +1,50 @@ +from sage.all import kronecker + +from curve_analyzer.traits.a05.a05 import ext_card +from curve_analyzer.traits.trait_interface import pretty_print_results, compute_results + + +def ext_cm_disc(q, card_low, deg): + """returns the CM discriminant (up to a square) over deg-th relative extension""" + card_high = ext_card(q, card_low, deg) + ext_tr = q ** deg + 1 - card_high + return ext_tr ** 2 - 4 * q ** deg + + +def a06_curve_function(curve, l, deg): + """returns the Kronecker symbol of the CM discriminant over the deg-th relative extension with respect to l""" + q = curve.q + curve_results = {} + order = curve.order * curve.cofactor + cm_disc = ext_cm_disc(q, order, deg) + while cm_disc % l ** 2 == 0: + cm_disc = cm_disc / l ** 2 + + if l == 2 and cm_disc % 4 != 1: + curve_results["kronecker"] = 0 + else: + curve_results["kronecker"] = kronecker(cm_disc, l) + return curve_results + + +def compute_a06_results(curve_list, desc='', verbose=False): + compute_results(curve_list, 'a06', a06_curve_function, desc=desc, verbose=verbose) + + +def get_a06_captions(results): + return ["kronecker"] + + +def select_a06_results(curve_results): + keys = ["kronecker"] + selected_results = [] + for key in keys: + selected_key = [] + for x in curve_results: + selected_key.append(x[key]) + selected_results.append(selected_key) + return selected_results + + +def pretty_print_a06_results(curve_list, save_to_txt=True): + pretty_print_results(curve_list, 'a06', get_a06_captions, select_a06_results, save_to_txt=save_to_txt) diff --git a/curve_analyzer/traits/a08/__init__.py b/curve_analyzer/traits/a08/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/traits/a08/a08.py b/curve_analyzer/traits/a08/a08.py new file mode 100644 index 0000000..b83857a --- /dev/null +++ b/curve_analyzer/traits/a08/a08.py @@ -0,0 +1,43 @@ +from sage.all import PolynomialRing, NumberField, ZZ + +from curve_analyzer.traits.trait_interface import pretty_print_results, compute_results + + +def a08_curve_function(curve): + ''' + Computes the class number of the maximal order of the endomorphism algebra + Time consuming + ''' + q = curve.q + trace = curve.trace + Q = PolynomialRing(ZZ, 'x') + x = Q.gen() + f = x ** 2 - trace * x + q + K = NumberField(f, 'c') + # G = K.class_group() + h = K.class_number() + curve_results = {"class_number": h} + return curve_results + + +def compute_a08_results(curve_list, desc='', verbose=False): + compute_results(curve_list, 'a08', a08_curve_function, desc=desc, verbose=verbose) + + +def get_a08_captions(results): + return ["class_number"] + + +def select_a08_results(curve_results): + keys = ["class_number"] + selected_results = [] + for key in keys: + selected_key = [] + for x in curve_results: + selected_key.append(x[key]) + selected_results.append(selected_key) + return selected_results + + +def pretty_print_a08_results(curve_list, save_to_txt=True): + pretty_print_results(curve_list, 'a08', get_a08_captions, select_a08_results, save_to_txt=save_to_txt) diff --git a/curve_analyzer/traits/a12/__init__.py b/curve_analyzer/traits/a12/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/traits/a12/a12.py b/curve_analyzer/traits/a12/a12.py new file mode 100644 index 0000000..685ae73 --- /dev/null +++ b/curve_analyzer/traits/a12/a12.py @@ -0,0 +1,43 @@ +from sage.all import Integers, ZZ, euler_phi + +from curve_analyzer.traits.trait_interface import pretty_print_results, compute_results + + +def a12_curve_function(curve, l): + ''' + Computes the order of l (small prime) modulo curve order and bit length of the index of + Returns a dictionary + ''' + card = curve.cardinality + try: + mul_ord = (Integers(card)(l)).multiplicative_order() + complement_bit_length = ZZ(euler_phi(card) / mul_ord).nbits() + except ArithmeticError: + mul_ord = None + complement_bit_length = None + curve_results = {'order': mul_ord, 'complement_bit_length': complement_bit_length} + return curve_results + + +def compute_a12_results(curve_list, desc='', verbose=False): + compute_results(curve_list, 'a12', a12_curve_function, desc=desc, verbose=verbose) + + +def get_a12_captions(results): + captions = ['order', 'complement_bit_length'] + return captions + + +def select_a12_results(curve_results): + keys = ['order', 'complement_bit_length'] + selected_results = [] + for key in keys: + selected_key = [] + for x in curve_results: + selected_key.append(x[key]) + selected_results.append(selected_key) + return selected_results + + +def pretty_print_a12_results(curve_list, save_to_txt=True): + pretty_print_results(curve_list, 'a12', get_a12_captions, select_a12_results, save_to_txt=save_to_txt) diff --git a/curve_analyzer/traits/a22/__init__.py b/curve_analyzer/traits/a22/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/traits/a22/a22.py b/curve_analyzer/traits/a22/a22.py new file mode 100644 index 0000000..f59bdb7 --- /dev/null +++ b/curve_analyzer/traits/a22/a22.py @@ -0,0 +1,36 @@ +from sage.all import factor + +from curve_analyzer.traits.trait_interface import pretty_print_results, compute_results + + +def a22_curve_function(curve, l): + ''' + Computation factorization of l-th division polynomial + Returns a dictionary (keys: 'factorization', 'degs_list', 'len' ) + ''' + pol = curve.EC.division_polynomial(l) + fact = [list(i) for i in list(factor(pol))] + # count multiplicities? + degs = [x.degree() for x, _ in fact] + fact_str = [[str(i[0]), i[1]] for i in fact] + curve_results = {'factorization': fact_str, 'degs_list': degs, 'len': len(degs)} + return curve_results + + +def compute_a22_results(curve_list, desc='', verbose=False): + compute_results(curve_list, 'a22', a22_curve_function, desc=desc, verbose=verbose) + + +def get_a22_captions(results): + return ['degs_lists', 'lens'] + + +def select_a22_results(curve_results): + degs_lists = [x['degs_list'] for x in curve_results] + lens = [x['len'] for x in curve_results] + selected_results = [degs_lists, lens] + return selected_results + + +def pretty_print_a22_results(curve_list, save_to_txt=True): + pretty_print_results(curve_list, 'a22', get_a22_captions, select_a22_results, save_to_txt=save_to_txt) diff --git a/curve_analyzer/traits/a23/__init__.py b/curve_analyzer/traits/a23/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/traits/a23/a23.py b/curve_analyzer/traits/a23/a23.py new file mode 100644 index 0000000..a99e597 --- /dev/null +++ b/curve_analyzer/traits/a23/a23.py @@ -0,0 +1,51 @@ +from sage.all import kronecker, ZZ + +from curve_analyzer.traits.trait_interface import pretty_print_results, compute_results + + +def a23_curve_function(curve, l): + ''' + Computes the depth of volcano and the degree of the crater subgraph containing E + Returns a dictionary (keys: 'crater_degree', 'depth') + ''' + t = curve.trace + q = curve.q + curve_results = {} + D = t ** 2 - 4 * q + if l != 2: + curve_results['crater_degree'] = kronecker(D, l) + 1 + curve_results['depth'] = ZZ.valuation(l)(D) // 2 + else: + e = ZZ.valuation(2)(D) + if e % 2 == 0: + d = D // (2 ** e) + if d % 4 != 1: + curve_results['crater_degree'] = 1 + curve_results['depth'] = e // 2 - 1 + else: + curve_results['crater_degree'] = kronecker(d, l) + 1 + curve_results['depth'] = e // 2 + else: + curve_results['crater_degree'] = 1 + curve_results['depth'] = e // 2 - 1 + return curve_results + + +def compute_a23_results(curve_list, desc='', verbose=False): + compute_results(curve_list, 'a23', a23_curve_function, desc=desc, verbose=verbose) + + +def get_a23_captions(results): + captions = ['crater_degree', 'depth'] + return captions + + +def select_a23_results(curve_results): + degs_lists = [x['crater_degree'] for x in curve_results] + depths = [x['depth'] for x in curve_results] + selected_results = [degs_lists, depths] + return selected_results + + +def pretty_print_a23_results(curve_list, save_to_txt=True): + pretty_print_results(curve_list, 'a23', get_a23_captions, select_a23_results, save_to_txt=save_to_txt) diff --git a/curve_analyzer/traits/a24/__init__.py b/curve_analyzer/traits/a24/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/traits/a24/a24.py b/curve_analyzer/traits/a24/a24.py new file mode 100644 index 0000000..f1da4e3 --- /dev/null +++ b/curve_analyzer/traits/a24/a24.py @@ -0,0 +1,89 @@ +from sage.all import PolynomialRing, GF + +from curve_analyzer.traits.a05.a05 import ext_card, is_torsion_cyclic +from curve_analyzer.traits.trait_interface import pretty_print_results, compute_results + + +def eigenvalues(curve, l, s=1): + '''Computes the eigenvalues of Frobenius endomorphism in F_l, or in F_l if s=2''' + x = PolynomialRing(GF(l ** s), 'x').gen() + q = curve.q + t = curve.trace + f = x ** 2 - t * x + q + return f.roots() + + +def i_finder(curve, l): + ''' + Finds the minimal degrees i_2,i_1 of extension of curve E/F_q where + E/F_q**(i_2) - all l+1 isogenies are rational, E/F_q**(i_1) - at least 1 isogeny is rational + Returns i2, i1 + ''' + eig = eigenvalues(curve, l) + # Case with no eigenvalues + if not eig: + eig = eigenvalues(curve, l, s=2) + a, b = eig[0][0], eig[1][0] + i2 = (a * b ** (-1)).multiplicative_order() + i1 = i2 + return i2, i1 + + a = eig[0][0] + # Case with 2 eigenvalues + if len(eig) == 2: + b = eig[1][0] + i1 = 1 + i2 = (a * b ** (-1)).multiplicative_order() + return i2, i1 + # Case with 1 eigenvalue + i1 = 1 + i2 = 1 + deg = a.multiplicative_order() + E = curve.EC + q = curve.q + card = ext_card(q, curve.order * curve.cofactor, deg) + if card % l ** 2 != 0 or is_torsion_cyclic(E, curve.q, curve.order * curve.cofactor, l, deg, curve.field): + i2 *= l + return i2, i1 + + +def a24_curve_function(curve, l): + ''' + Computes i2,i1 (see i_finder) for all primes l 0: + chunk = jobs_total - args.jobs + 1 + yield {'trait_name': args.trait_name, 'curve_type': args.curve_type, 'order_bound': args.order_bound, + 'allowed_cofactors': args.allowed_cofactors, + 'description': "part_" + str(chunk).zfill(4) + "_of_" + str(jobs_total).zfill(4), + 'chunks_total': jobs_total, + 'chunk': chunk} + args.jobs -= 1 + + +def main(): + parser = argparse.ArgumentParser(description='Experiment parallelizer') + parser.add_argument('-t', '--tasks', type=int, default=1, + help='Number of tasks to run in parallel (default: 1') + parser.add_argument('-j', '--jobs', type=int, default=1, + help='Number of jobs to run in parallel (default: 1') + parser.add_argument('-s', '--sage', default='sage', + help='Path to the sage') + requiredNamed = parser.add_argument_group('required named arguments') + requiredNamed.add_argument('-n', '--trait_name', metavar='trait_name', type=str, action='store', + help='the trait identifier; available traits: ' + ", ".join(TRAIT_NAMES), required=True) + requiredNamed.add_argument('-c', '--curve_type', metavar='curve_type', type=str, + help='the type of curves for which to compute traits; must be one of the following: std (all standard ' + 'curves), sim (all simulated curves), sample (curves secp112r1, secp192r1, ' + 'secp256r1), all (all curves in the database)', + required=True) + parser.add_argument('-v', '--verbosity', action='store_true', help='verbosity flag (default: False)') + parser.add_argument('-b', '--order_bound', action='store', type=int, metavar='order_bound', default=256, + help='upper bound for curve order bitsize (default: 256)') + parser.add_argument('-a', '--allowed_cofactors', nargs='+', metavar='allowed_cofactors', default=[1], + help='the list of cofactors the curve can have (default: [1])') + + args = parser.parse_args() + if args.trait_name not in TRAIT_NAMES: + print("please enter a valid trait identifier, e.g., a02") + exit() + print(args) + + wrapper_path = os.path.join(TRAIT_PATH, 'run_traits_single.py') + + pr = ParallelRunner() + pr.parallel_tasks = args.tasks + + def feeder(): + """ + Create function that generates computing jobs. + ParallelRunner class takes any function that generates iterable of Task instances. + Usually its best to implement it as a generator so jobs are generated on the fly and they don't + have to be memorized. This function can be called several times during the computation + to add new jobs to the computing queue. + + The general approach of using a function to generate Tasks gives us flexibility + in terms of implementation. Here we use function that reads `args`, reads the input parameter + file and generates tasks based on this information. + The function also has an access to `pr` so it can adapt to job already being done. + The function can also store its own state. + """ + for p in load_trait_parameters(args): + allowed_cofactors_string = ' '.join(map(str, p['allowed_cofactors'])) + del p['allowed_cofactors'] + cli = ' '.join(['--%s=%s' % (k, p[k]) for k in p.keys()]) + + cli = ' '.join([cli, '-a', allowed_cofactors_string]) + t = Task(args.sage, '%s %s' % (wrapper_path, cli)) + yield t + + def prerun(j: Task): + """ + Function executed just after the Task is taken out from the queue and before + executing by a worker. + By setting j.skip = True this task will be skipped and not executed. + You won't get notification about finishing + """ + logger.info("Going to start task %s" % (j.idx,)) + + def on_finished(r: TaskResult): + """ + Called when task completes. Can be used to re-enqueue failed task. + You also could open the result file and analyze it, but this could slow-down + the job manager loop (callbacks are executed on manager thread). + """ + logger.info("Task %s finished, code: %s, fails: %s" % (r.job.idx, r.ret_code, r.job.failed_attempts)) + if r.ret_code != 0 and r.job.failed_attempts < 3: + pr.enqueue(r.job) + + pr.job_feeder = feeder + pr.cb_job_prerun = prerun + pr.cb_job_finished = on_finished + pr.work() + + +if __name__ == '__main__': + main() diff --git a/curve_analyzer/traits/run_traits_single.py b/curve_analyzer/traits/run_traits_single.py new file mode 100644 index 0000000..8c0e9b5 --- /dev/null +++ b/curve_analyzer/traits/run_traits_single.py @@ -0,0 +1,56 @@ +#!/usr/bin/env sage + +# A wrapper for running individual traits from the command line. + +import argparse +import sys + +from curve_analyzer.definitions import TRAIT_NAMES, TRAIT_MODULE_PATH +from curve_analyzer.utils.curve_handler import import_curves + + +def main(): + parser = argparse.ArgumentParser( + description='Welcome to Curve analyzer! It allows you to run traits on a selected subset of standard or ' + 'simulated curves.') + requiredNamed = parser.add_argument_group('required named arguments') + requiredNamed.add_argument('-n', '--trait_name', metavar='trait_name', type=str, action='store', + help='the trait identifier; available traits: ' + ", ".join(TRAIT_NAMES), required=True) + requiredNamed.add_argument('-c', '--curve_type', metavar='curve_type', type=str, + help='the type of curves or which to compute traits; must be one of the following: std (all standard ' + 'curves), sim (all simulated curves), sample (curves secp112r1, secp192r1, ' + 'secp256r1), all (all curves in the database)', + required=True) + parser.add_argument('-v', '--verbosity', action='store_true', help='verbosity flag (default: False)') + parser.add_argument('-b', '--order_bound', action='store', type=int, metavar='order_bound', default=256, + help='upper bound for curve order bitsize (default: 256)') + parser.add_argument('-d', '--description', action='store', type=str, metavar='description', default="", + help='custom text description of the current trait run for logs (default: "")') + parser.add_argument('-a', '--allowed_cofactors', nargs='+', metavar='allowed_cofactors', default=[1], + help='the list of cofactors the curve can have (default: [1])') + parser.add_argument('--chunks_total', action='store', type=int, metavar='chunks_total', default=1, + help='the number of chunks into which the curve list is divided (default: 1)') + parser.add_argument('--chunk', action='store', type=int, metavar='chunk', default=1, + help='the chunk of the curve list that will be processed (default: 1)') + + args = parser.parse_args() + tn = args.trait_name + module_name = TRAIT_MODULE_PATH + "." + tn + '.' + tn + try: + __import__(module_name) + except ModuleNotFoundError: + print("please enter a valid trait identifier, e.g., a02") + exit() + trait_function = getattr(sys.modules[module_name], "compute_" + tn + "_results") + ctype = args.curve_type + if ctype not in ["std", "sim", "sample", "all"]: + print("curve_type must be one of std, sim, sample, all") + exit() + curves_list = import_curves(curve_type=args.curve_type, order_bound=args.order_bound, verbose=args.verbosity, + allowed_cofactors=args.allowed_cofactors, + chunks_total=args.chunks_total, chunk=args.chunk) + trait_function(curves_list, desc=args.description, verbose=args.verbosity) + + +if __name__ == '__main__': + main() diff --git a/curve_analyzer/traits/trait_interface.py b/curve_analyzer/traits/trait_interface.py new file mode 100644 index 0000000..0c4d998 --- /dev/null +++ b/curve_analyzer/traits/trait_interface.py @@ -0,0 +1,249 @@ +import itertools +import json +import random +import time +from datetime import datetime +from pathlib import Path + +import pytz +from prettytable import PrettyTable # http://zetcode.com/python/prettytable/ +from sage.all import sage_eval +from sage.parallel.decorate import fork + +from curve_analyzer.definitions import TRAIT_PATH +from curve_analyzer.utils.json_handler import save_into_json, load_from_json + + +def get_timestamp(): + """Returns the current datetime as CEST.""" + cest = pytz.timezone('Europe/Prague') + now = datetime.now() + now = cest.localize(now) + return datetime.isoformat(now, sep='_', timespec='seconds')[:-6] + + +class Logs: + """Class for managing logs for each curve trait.""" + + def __init__(self, trait_name, desc=''): + self.desc = desc + self.main_log_file = None + self.main_log = None + self.log_dir = None + self.current_log_file = None + self.current_log = None + self.init_log_paths(trait_name) + self.create_logs() + + def init_log_paths(self, trait_name): + self.main_log_file = Path(TRAIT_PATH, trait_name, trait_name + ".log") + self.log_dir = Path(TRAIT_PATH, trait_name, 'logs') + timestamp = get_timestamp() + if not self.desc == '': + name = timestamp + "_" + self.desc + else: + name = timestamp + self.current_log_file = Path(self.log_dir, name + '.log') + + def create_logs(self): + self.log_dir.mkdir(exist_ok=True) + self.main_log = open(self.main_log_file, 'a+') + self.current_log = open(self.current_log_file, 'w') + + def write_to_logs(self, text, frmt='{:s}', newlines=0, verbose_print=False): + if verbose_print: + print(frmt.format(text), end=newlines * "\n") + for f in [self.main_log, self.current_log]: + f.write(frmt.format(text)) + f.write(newlines * "\n") + + def close_logs(self): + for f in [self.main_log, self.current_log]: + f.close() + + +def init_json_paths(trait_name, desc=''): + """Deduces paths to JSON files from the trait name.""" + path_main_json = Path(TRAIT_PATH, trait_name, trait_name + '.json') + path_json = Path(TRAIT_PATH, trait_name, trait_name + '_' + desc + '_' + get_timestamp() + '.json') + # tmp name must be unique for parallel trait runs + path_tmp = Path("%s_%04x.tmp" % (path_json.with_suffix(''), random.randrange(2 ** 32))) + path_params = Path(TRAIT_PATH, trait_name, trait_name + '.params') + if not path_json.is_file(): + save_into_json({}, path_json, 'w') + return path_main_json, path_json, path_tmp, path_params + + +def special_case(text): + if not isinstance(text, str): + return False + return text.strip() == "NO DATA (timed out)" + + +def compare_structures(struct1, struct2): + if type(struct1) != type(struct2): + if special_case(struct1) or special_case(struct2): + return True + return False + if isinstance(struct1, list): + value = True + for i in range(min(len(struct1), len(struct2))): + value &= compare_structures(struct1[i], struct2[i]) + return value + if isinstance(struct1, dict): + if set(struct1.keys()) != set(struct2.keys()): + return False + value = True + for key in struct1.keys(): + value &= compare_structures(struct1[key], struct2[key]) + return value + return True + + +def get_model_structure(curve_function): + name = curve_function.__name__.split("_", 1)[0] + with open(Path(TRAIT_PATH, name, name + "_structure.json"), 'r') as f: + results = json.load(f) + return list(list(results.values())[0].values())[0] + + +def is_structure_new(old, curve_function, curve): + if curve.name not in old: + return True + model_structure = get_model_structure(curve_function) + computed = list(old[curve.name].values())[0] + return not compare_structures(model_structure, computed) + + +def update_curve_results(curve, curve_function, params_global, params_local_names, old_results, log_obj, verbose=False): + """Tries to run traits for each individual curve; called by compute_results.""" + log_obj.write_to_logs("Processing curve " + curve.name + ":", newlines=1, verbose_print=verbose) + new_results = {} + new_struct = is_structure_new(old_results, curve_function, curve) + if curve.name not in old_results: + new_results[curve.name] = {} + else: + new_results[curve.name] = old_results[curve.name] + + for params_local_values in itertools.product(*params_global.values()): + params_local = dict(zip(params_local_names, params_local_values)) + log_obj.write_to_logs(" Processing params " + str(params_local), frmt='{:.<107}', verbose_print=verbose) + if curve.name in old_results and str(params_local) in old_results[curve.name] and not new_struct: + log_obj.write_to_logs("Already computed", newlines=1, verbose_print=verbose) + else: + new_results[curve.name][str(params_local)] = curve_function(curve, *params_local_values) + log_obj.write_to_logs("Done", newlines=1, verbose_print=verbose) + return new_results[curve.name] + + +def compute_results(curve_list, trait_name, curve_function, desc='', verbose=False): + """A universal function for running traits on curve lists; it is called by each trait file which has its own curve + function. Each trait is assumed to have a params file in its folder; the results and logs are created there as + well. """ + main_json_file, json_file, tmp_file, params_file = init_json_paths(trait_name, desc) + if curve_list == []: + print("No input curves found, terminating the trait run.") + save_into_json({}, json_file, 'w') + return + log_obj = Logs(trait_name, desc) + try: + old_results = load_from_json(main_json_file) + except FileNotFoundError: + old_results = {} + + new_results = {} + if not params_file.is_file(): + print("No parameter file found, terminating the trait run.") + return + params = load_from_json(params_file) + for key in params["params_global"].keys(): + params["params_global"][key] = sage_eval(params["params_global"][key]) + params_global = params["params_global"] + params_local_names = params["params_local_names"] + + total_time = 0 + timestamp = get_timestamp() + + log_obj.write_to_logs("Current datetime: " + timestamp, newlines=1, verbose_print=verbose) + std_count = 0 + sim_count = 0 + for curve in curve_list: + if "sim" in curve.name: + sim_count += 1 + else: + std_count += 1 + log_obj.write_to_logs( + "Hold on to your hat! Running trait " + str(trait_name) + " on " + str(std_count) + " std curves and " + str( + sim_count) + " sim curves with global parameters:\n" + str(params_global), newlines=2, + verbose_print=verbose) + + for curve in curve_list: + start_time = time.time() + + new_results[curve.name] = update_curve_results(curve, curve_function, params_global, params_local_names, + old_results, log_obj, verbose=verbose) + + end_time = time.time() + diff_time = end_time - start_time + total_time += diff_time + + log_obj.write_to_logs("Done, time elapsed: " + str(diff_time), newlines=2, verbose_print=verbose) + save_into_json(new_results, tmp_file, 'w') + + log_obj.write_to_logs(80 * '.' + "\n" + "Finished, total time elapsed: " + str(total_time) + "\n\n" + 80 * '#', + newlines=3, verbose_print=verbose) + log_obj.close_logs() + + json_file.unlink() + tmp_file.rename(json_file) + + +def init_txt_paths(trait_name, desc=''): + name = Path(TRAIT_PATH, + trait_name, trait_name) + if not desc == '': + name += "_" + desc + return name + '.txt' + + +def pretty_print_results(curve_list, trait_name, get_captions, select_results, curve_sort_key="bits", save_to_txt=True): + """Visualizes trait results from the relevant JSON; the functions get_captions are select_results are provided by + each trait separately. """ + path_main_json, _, _, _ = init_json_paths(trait_name) + results = load_from_json(path_main_json) + + captions = get_captions(results) + headlines = ['name', 'bits'] + for caption in captions: + headlines.append(caption) + t = PrettyTable(headlines) + + for curve in curve_list: + name = curve.name + if name not in results.keys(): + continue + order_bits = curve.nbits + row = [name, order_bits] + for result in select_results(results[name].values()): + row.append(result) + t.add_row(row) + + t.sortby = curve_sort_key + print(t) + + if save_to_txt: + path_txt = init_txt_paths(trait_name) + with open(path_txt, "w") as f: + f.write(str(t)) + + +def timeout(func, args=(), kwargs=None, timeout_duration=10): + """Stops the function func after 'timeout_duration' seconds, taken from + https://ask.sagemath.org/question/10112/kill-the-thread-in-a-long-computation/. """ + if kwargs is None: + kwargs = {} + + @fork(timeout=timeout_duration, verbose=False) + def my_new_func(): + return func(*args, **kwargs) + + return my_new_func() diff --git a/curve_analyzer/traits/unit_tests/local_test_import_curves.py b/curve_analyzer/traits/unit_tests/local_test_import_curves.py new file mode 100644 index 0000000..aa4fb2c --- /dev/null +++ b/curve_analyzer/traits/unit_tests/local_test_import_curves.py @@ -0,0 +1,16 @@ +import unittest + +from curve_analyzer.utils.curve_handler import import_curves + + +class TestImportSimCurves(unittest.TestCase): + def test_import_sim(self): + curves = import_curves(curve_type="sim", order_bound=128, allowed_cofactors=[1]) + self.assertEqual(len(curves), 15916) + + curves = import_curves(curve_type="sim", order_bound=128, allowed_cofactors=list(range(1, 1001))) + self.assertEqual(len(curves), 93796) + +if __name__ == '__main__': + unittest.main() + print("Everything passed") diff --git a/curve_analyzer/traits/unit_tests/test_a01.py b/curve_analyzer/traits/unit_tests/test_a01.py new file mode 100644 index 0000000..2a76f38 --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_a01.py @@ -0,0 +1,35 @@ +import ast +import unittest + +from curve_analyzer.traits.a01.a01 import a01_curve_function +from curve_analyzer.traits.example_curves import curve_names + +results = {'secp112r2': {"{'deg': 1}": {'ord1': 4451685225093714699870930859147564, 'ord2': 1}}, + 'bn158': {"{'deg': 1}": {'ord1': 206327671360737302491015346511080613560608358413, 'ord2': 1}}, + 'brainpoolP160r1': {"{'deg': 1}": {'ord1': 1332297598440044874827085038830181364212942568457, 'ord2': 1}}} + + +class TestA01(unittest.TestCase): + + def test_auto_generated_secp112r2(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["secp112r2"].keys())[0]).values() + computed_result = a01_curve_function(curve_names["secp112r2"], *params) + self.assertEqual(computed_result, list(results["secp112r2"].values())[0]) + + def test_auto_generated_bn158(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["bn158"].keys())[0]).values() + computed_result = a01_curve_function(curve_names["bn158"], *params) + self.assertEqual(computed_result, list(results["bn158"].values())[0]) + + def test_auto_generated_brainpoolP160r1(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["brainpoolP160r1"].keys())[0]).values() + computed_result = a01_curve_function(curve_names["brainpoolP160r1"], *params) + self.assertEqual(computed_result, list(results["brainpoolP160r1"].values())[0]) + + +if __name__ == '__main__': + unittest.main() + print("Everything passed") diff --git a/curve_analyzer/traits/unit_tests/test_a02.py b/curve_analyzer/traits/unit_tests/test_a02.py new file mode 100644 index 0000000..0b5e228 --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_a02.py @@ -0,0 +1,40 @@ +import ast +import unittest + +from curve_analyzer.traits.a02.a02 import a02_curve_function +from curve_analyzer.traits.example_curves import curve_names + +results = {'secp112r2': {"{'deg': 1}": {'cm_disc': -3147981784734289480448435252561803, + 'factorization': [[2, 2], [23, 1], [136868773249316933932540663154861, 1]], + 'max_conductor': 2}}, 'bn158': { + "{'deg': 1}": {'cm_disc': -3, 'factorization': [[3, 1], [51329, 2], [8849442974123583107, 2]], + 'max_conductor': 454233058418789397299203}}, 'brainpoolP160r1': { + "{'deg': 1}": {'cm_disc': -4645380339943745084523443872838008326722778443, + 'factorization': [[3, 2], [11, 2], [17, 1], [29, 1], [89, 1], [22067, 1], [577011261754261, 1], + [8314894957527277176257, 1]], 'max_conductor': 33}}} + + +class TestA02(unittest.TestCase): + + def test_auto_generated_secp112r2(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["secp112r2"].keys())[0]).values() + computed_result = a02_curve_function(curve_names["secp112r2"], *params) + self.assertEqual(computed_result, list(results["secp112r2"].values())[0]) + + def test_auto_generated_bn158(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["bn158"].keys())[0]).values() + computed_result = a02_curve_function(curve_names["bn158"], *params) + self.assertEqual(computed_result, list(results["bn158"].values())[0]) + + def test_auto_generated_brainpoolP160r1(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["brainpoolP160r1"].keys())[0]).values() + computed_result = a02_curve_function(curve_names["brainpoolP160r1"], *params) + self.assertEqual(computed_result, list(results["brainpoolP160r1"].values())[0]) + + +if __name__ == '__main__': + unittest.main() + print("Everything passed") diff --git a/curve_analyzer/traits/unit_tests/test_a04.py b/curve_analyzer/traits/unit_tests/test_a04.py new file mode 100644 index 0000000..0e2df5e --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_a04.py @@ -0,0 +1,45 @@ +import ast +import unittest + +from curve_analyzer.traits.a04.a04 import a04_curve_function +from curve_analyzer.traits.example_curves import curve_names + +results = {'secp112r2': { + "{'k': 1}": {'(+)factorization': [5, 688979, 2554037775511, 505965776926277], '(+)largest_factor_bitlen': 49, + '(-)factorization': 'NO DATA (timed out)', '(-)largest_factor_bitlen': 'NO DATA (timed out)'}}, + 'bn158': { + "{'k': 1}": {'(+)factorization': [2, 13, 19, 283, 2953, 12703, 255775566845467, 153820879925462235919], + '(+)largest_factor_bitlen': 68, + '(-)factorization': [2, 2, 3, 3, 7, 17, 1031, 1289, 9859, 18453708086941, + 199195681547286757733], '(-)largest_factor_bitlen': 68}}, + 'brainpoolP160r1': { + "{'k': 1}": {'(+)factorization': [2, 7, 7, 223, 19949, 85009, 464461626269101, 77398836126035560547], + '(+)largest_factor_bitlen': 67, + '(-)factorization': [2, 2, 2, 3, 83, 1933, 216841, 2745161, 3244753, 72663031601, + 2465333512157], '(-)largest_factor_bitlen': 42}}} + + +class TestA04(unittest.TestCase): + + def test_auto_generated_secp112r2(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["secp112r2"].keys())[0]).values() + computed_result = a04_curve_function(curve_names["secp112r2"], *params) + self.assertEqual(computed_result, list(results["secp112r2"].values())[0]) + + def test_auto_generated_bn158(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["bn158"].keys())[0]).values() + computed_result = a04_curve_function(curve_names["bn158"], *params) + self.assertEqual(computed_result, list(results["bn158"].values())[0]) + + def test_auto_generated_brainpoolP160r1(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["brainpoolP160r1"].keys())[0]).values() + computed_result = a04_curve_function(curve_names["brainpoolP160r1"], *params) + self.assertEqual(computed_result, list(results["brainpoolP160r1"].values())[0]) + + +if __name__ == '__main__': + unittest.main() + print("Everything passed") diff --git a/curve_analyzer/traits/unit_tests/test_a05.py b/curve_analyzer/traits/unit_tests/test_a05.py new file mode 100644 index 0000000..7d7c8df --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_a05.py @@ -0,0 +1,35 @@ +import ast +import unittest + +from curve_analyzer.traits.a05.a05 import a05_curve_function +from curve_analyzer.traits.example_curves import curve_names + +results = {'secp112r2': {"{'l': 2}": {'least': 1, 'full': 2, 'relative': 2}}, + 'bn158': {"{'l': 2}": {'least': 3, 'full': 3, 'relative': 1}}, + 'brainpoolP160r1': {"{'l': 2}": {'least': 3, 'full': 3, 'relative': 1}}} + + +class TestA05(unittest.TestCase): + + # This test has been auto-generated by gen_unittest + def test_auto_generated_secp112r2(self): + params = ast.literal_eval(list(results["secp112r2"].keys())[0]).values() + computed_result = a05_curve_function(curve_names["secp112r2"], *params) + self.assertEqual(computed_result, list(results["secp112r2"].values())[0]) + + # This test has been auto-generated by gen_unittest + def test_auto_generated_bn158(self): + params = ast.literal_eval(list(results["bn158"].keys())[0]).values() + computed_result = a05_curve_function(curve_names["bn158"], *params) + self.assertEqual(computed_result, list(results["bn158"].values())[0]) + + # This test has been auto-generated by gen_unittest + def test_auto_generated_brainpoolP160r1(self): + params = ast.literal_eval(list(results["brainpoolP160r1"].keys())[0]).values() + computed_result = a05_curve_function(curve_names["brainpoolP160r1"], *params) + self.assertEqual(computed_result, list(results["brainpoolP160r1"].values())[0]) + + +if __name__ == '__main__': + unittest.main() + print("Everything passed") diff --git a/curve_analyzer/traits/unit_tests/test_a06.py b/curve_analyzer/traits/unit_tests/test_a06.py new file mode 100644 index 0000000..9112395 --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_a06.py @@ -0,0 +1,35 @@ +import ast +import unittest + +from curve_analyzer.traits.a06.a06 import a06_curve_function +from curve_analyzer.traits.example_curves import curve_names + +key = "{'l': 2, 'deg': 1}" +results = {'secp112r2': {key: {'kronecker': -1}}, 'bn158': {key: {'kronecker': -1}}, + 'brainpoolP160r1': {key: {'kronecker': -1}}} + + +class TestA06(unittest.TestCase): + + def test_auto_generated_secp112r2(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["secp112r2"].keys())[0]).values() + computed_result = a06_curve_function(curve_names["secp112r2"], *params) + self.assertEqual(computed_result, list(results["secp112r2"].values())[0]) + + def test_auto_generated_bn158(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["bn158"].keys())[0]).values() + computed_result = a06_curve_function(curve_names["bn158"], *params) + self.assertEqual(computed_result, list(results["bn158"].values())[0]) + + def test_auto_generated_brainpoolP160r1(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["brainpoolP160r1"].keys())[0]).values() + computed_result = a06_curve_function(curve_names["brainpoolP160r1"], *params) + self.assertEqual(computed_result, list(results["brainpoolP160r1"].values())[0]) + + +if __name__ == '__main__': + unittest.main() + print("Everything passed") diff --git a/curve_analyzer/traits/unit_tests/test_a12.py b/curve_analyzer/traits/unit_tests/test_a12.py new file mode 100644 index 0000000..64022e2 --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_a12.py @@ -0,0 +1,36 @@ +import ast +import unittest + +from curve_analyzer.traits.a12.a12 import a12_curve_function +from curve_analyzer.traits.example_curves import curve_names + +results = {'secp112r2': {"{'l': 2}": {'order': None, 'complement_bit_length': None}}, 'bn158': { + "{'l': 2}": {'order': 68775890453579100830338448837026871186869452804, 'complement_bit_length': 2}}, + 'brainpoolP160r1': { + "{'l': 2}": {'order': 333074399610011218706771259707545341053235642114, 'complement_bit_length': 3}}} + + +class TestA12(unittest.TestCase): + + def test_auto_generated_secp112r2(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["secp112r2"].keys())[0]).values() + computed_result = a12_curve_function(curve_names["secp112r2"], *params) + self.assertEqual(computed_result, list(results["secp112r2"].values())[0]) + + def test_auto_generated_bn158(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["bn158"].keys())[0]).values() + computed_result = a12_curve_function(curve_names["bn158"], *params) + self.assertEqual(computed_result, list(results["bn158"].values())[0]) + + def test_auto_generated_brainpoolP160r1(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["brainpoolP160r1"].keys())[0]).values() + computed_result = a12_curve_function(curve_names["brainpoolP160r1"], *params) + self.assertEqual(computed_result, list(results["brainpoolP160r1"].values())[0]) + + +if __name__ == '__main__': + unittest.main() + print("Everything passed") diff --git a/curve_analyzer/traits/unit_tests/test_a22.py b/curve_analyzer/traits/unit_tests/test_a22.py new file mode 100644 index 0000000..890834d --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_a22.py @@ -0,0 +1,39 @@ +import ast +import unittest + +from curve_analyzer.traits.a22.a22 import a22_curve_function +from curve_analyzer.traits.example_curves import curve_names + +results = {'secp112r2': {"{'l': 2}": {'factorization': [['x + 841610090548475696082223908882494', 1], [ + 'x^2 + 3610075134545239076002374364665933*x + 2797590916291665130774294894805068', 1]], 'degs_list': [1, 2], + 'len': 2}}, + 'bn158': {"{'l': 2}": {'factorization': [['x^3 + 17', 1]], 'degs_list': [3], 'len': 1}}, 'brainpoolP160r1': { + "{'l': 2}": {'factorization': [[ + 'x^3 + 297190522446607939568481567949428902921613329152*x + 173245649450172891208247283053495198538671808088', + 1]], 'degs_list': [3], 'len': 1}}} + + +class TestA22(unittest.TestCase): + + def test_auto_generated_secp112r2(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["secp112r2"].keys())[0]).values() + computed_result = a22_curve_function(curve_names["secp112r2"], *params) + self.assertEqual(computed_result, list(results["secp112r2"].values())[0]) + + def test_auto_generated_bn158(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["bn158"].keys())[0]).values() + computed_result = a22_curve_function(curve_names["bn158"], *params) + self.assertEqual(computed_result, list(results["bn158"].values())[0]) + + def test_auto_generated_brainpoolP160r1(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["brainpoolP160r1"].keys())[0]).values() + computed_result = a22_curve_function(curve_names["brainpoolP160r1"], *params) + self.assertEqual(computed_result, list(results["brainpoolP160r1"].values())[0]) + + +if __name__ == '__main__': + unittest.main() + print("Everything passed") diff --git a/curve_analyzer/traits/unit_tests/test_a23.py b/curve_analyzer/traits/unit_tests/test_a23.py new file mode 100644 index 0000000..47dd330 --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_a23.py @@ -0,0 +1,35 @@ +import ast +import unittest + +from curve_analyzer.traits.a23.a23 import a23_curve_function +from curve_analyzer.traits.example_curves import curve_names + +results = {'secp112r2': {"{'l': 2}": {'crater_degree': 0, 'depth': 1}}, + 'bn158': {"{'l': 2}": {'crater_degree': 0, 'depth': 0}}, + 'brainpoolP160r1': {"{'l': 2}": {'crater_degree': 0, 'depth': 0}}} + + +class TestA23(unittest.TestCase): + + def test_auto_generated_secp112r2(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["secp112r2"].keys())[0]).values() + computed_result = a23_curve_function(curve_names["secp112r2"], *params) + self.assertEqual(computed_result, list(results["secp112r2"].values())[0]) + + def test_auto_generated_bn158(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["bn158"].keys())[0]).values() + computed_result = a23_curve_function(curve_names["bn158"], *params) + self.assertEqual(computed_result, list(results["bn158"].values())[0]) + + def test_auto_generated_brainpoolP160r1(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["brainpoolP160r1"].keys())[0]).values() + computed_result = a23_curve_function(curve_names["brainpoolP160r1"], *params) + self.assertEqual(computed_result, list(results["brainpoolP160r1"].values())[0]) + + +if __name__ == '__main__': + unittest.main() + print("Everything passed") diff --git a/curve_analyzer/traits/unit_tests/test_a24.py b/curve_analyzer/traits/unit_tests/test_a24.py new file mode 100644 index 0000000..46ffec9 --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_a24.py @@ -0,0 +1,35 @@ +import ast +import unittest + +from curve_analyzer.traits.a24.a24 import a24_curve_function +from curve_analyzer.traits.example_curves import curve_names + +results = {'secp112r2': {"{'l': 2}": {'least': 1, 'full': 2, 'relative': 2}}, + 'bn158': {"{'l': 2}": {'least': 3, 'full': 3, 'relative': 1}}, + 'brainpoolP160r1': {"{'l': 2}": {'least': 3, 'full': 3, 'relative': 1}}} + + +class TestA24(unittest.TestCase): + + def test_auto_generated_secp112r2(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["secp112r2"].keys())[0]).values() + computed_result = a24_curve_function(curve_names["secp112r2"], *params) + self.assertEqual(computed_result, list(results["secp112r2"].values())[0]) + + def test_auto_generated_bn158(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["bn158"].keys())[0]).values() + computed_result = a24_curve_function(curve_names["bn158"], *params) + self.assertEqual(computed_result, list(results["bn158"].values())[0]) + + def test_auto_generated_brainpoolP160r1(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["brainpoolP160r1"].keys())[0]).values() + computed_result = a24_curve_function(curve_names["brainpoolP160r1"], *params) + self.assertEqual(computed_result, list(results["brainpoolP160r1"].values())[0]) + + +if __name__ == '__main__': + unittest.main() + print("Everything passed") diff --git a/curve_analyzer/traits/unit_tests/test_a25.py b/curve_analyzer/traits/unit_tests/test_a25.py new file mode 100644 index 0000000..aafbd8f --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_a25.py @@ -0,0 +1,40 @@ +import ast +import unittest + +from curve_analyzer.traits.a25.a25 import a25_curve_function +from curve_analyzer.traits.example_curves import curve_names + +key = "{'deg': 1}" +results = {'secp112r2': { + key: {'trace': 72213667414400864, 'trace_factorization': [[2, 5], [11, 1], [205152464245457, 1]], + 'number_of_factors': 3}}, 'bn158': { + key: {'trace': 454233058419889982668807, 'trace_factorization': [[2953, 1], [153820879925462235919, 1]], + 'number_of_factors': 2}}, 'brainpoolP160r1': { + key: {'trace': 519972310379544251229703, 'trace_factorization': [[3023, 1], [49277, 1], [3490581720239293, 1]], + 'number_of_factors': 3}}} + + +class TestA25(unittest.TestCase): + + def test_auto_generated_secp112r2(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["secp112r2"].keys())[0]).values() + computed_result = a25_curve_function(curve_names["secp112r2"], *params) + self.assertEqual(computed_result, list(results["secp112r2"].values())[0]) + + def test_auto_generated_bn158(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["bn158"].keys())[0]).values() + computed_result = a25_curve_function(curve_names["bn158"], *params) + self.assertEqual(computed_result, list(results["bn158"].values())[0]) + + def test_auto_generated_brainpoolP160r1(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["brainpoolP160r1"].keys())[0]).values() + computed_result = a25_curve_function(curve_names["brainpoolP160r1"], *params) + self.assertEqual(computed_result, list(results["brainpoolP160r1"].values())[0]) + + +if __name__ == '__main__': + unittest.main() + print("Everything passed") diff --git a/curve_analyzer/traits/unit_tests/test_custom_curve.py b/curve_analyzer/traits/unit_tests/test_custom_curve.py new file mode 100644 index 0000000..9f962e0 --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_custom_curve.py @@ -0,0 +1,125 @@ +import unittest + +from sage.all import GF + +from curve_analyzer.utils.custom_curve import twisted_edwards_to_short_weierstrass, twisted_edwards_to_montgomery, \ + CustomCurve + +# Test vectors: https://tools.ietf.org/id/draft-struik-lwip-curve-representations-00.html#rfc.appendix.C.3 + +p = 2 ** 255 - 19 +F = GF(p) +a = -1 +d = F(-121665) / (121666) +x = 15112221349535400772501151409588531511454012693041857206046113283949847762202 +y = F(4) / (5) + +Wei25519 = {'a': 19298681539552699237261830834781317975544997444273427339909597334573241639236, + 'b': 55751746669818908907645289078257140818241103727901012315294400837956729358436, + 'x': 19298681539552699237261830834781317975544997444273427339909597334652188435546, + 'y': 14781619447589544791020593568409986887264606134616475288964881837755586237401} + +Mon25519 = {'A': 486662, + 'B': 1, + 'u': 9, + 'v': 14781619447589544791020593568409986887264606134616475288964881837755586237401 + } +B1 = CustomCurve( + { + "name": "sect163k1", + "category": "secg", + "desc": "", + "oid": "1.3.132.0.1", + "field": { + "type": "Binary", + "poly": [ + { + "power": 163, + "coeff": "0x01" + }, + { + "power": 7, + "coeff": "0x01" + }, + { + "power": 6, + "coeff": "0x01" + }, + { + "power": 3, + "coeff": "0x01" + }, + { + "power": 0, + "coeff": "0x01" + } + ], + "bits": 163, + "degree": 163 + }, + "form": "Weierstrass", + "params": { + "a": {"raw": "0x000000000000000000000000000000000000000001"}, + "b": {"raw": "0x000000000000000000000000000000000000000001"} + }, + "generator": { + "x": {"raw": "0x02fe13c0537bbc11acaa07d793de4e6d5e5c94eee8"}, + "y": {"raw": "0x0289070fb05d38ff58321f2e800536d538ccdaa3d9"} + }, + "order": "0x04000000000000000000020108a2e0cc0d99f8a5ef", + "cofactor": "0x2", + "aliases": [ + "nist/K-163" + ], + "characteristics": { + "discriminant": "1", + "j_invariant": "1", + "trace_of_frobenius": "-4845466632539410776804317", + "anomalous": False, + "supersingular": False, + "cm_disc": "46768052394588893382517919492387689168400618179549", + "conductor": "1" + } + }) + +B1_results = {"cofactor": 2, "a": 1, "b": 1, "order": 0x04000000000000000000020108A2E0CC0D99F8A5EF, + "gen_x": 0x02fe13c0537bbc11acaa07d793de4e6d5e5c94eee8, + "gen_y": 0x0289070fb05d38ff58321f2e800536d538ccdaa3d9} + + +class TestCustomCurve(unittest.TestCase): + + def test_Ed_to_Wei(self): + result = twisted_edwards_to_short_weierstrass(F, a, d, x, y) + self.assertEqual(result[0], Wei25519['a'], + "Should be " + str(Wei25519['a'])) + self.assertEqual(result[1], Wei25519['b'], + "Should be " + str(Wei25519['b'])) + self.assertEqual(result[2], Wei25519['x'], + "Should be " + str(Wei25519['x'])) + self.assertEqual(result[3], Wei25519['y'], + "Should be " + str(Wei25519['y'])) + + def test_Ed_to_Mon(self): + result = twisted_edwards_to_montgomery(F, a, d, x, y) + self.assertEqual(result[0], Mon25519['A'], + "Should be " + str(Mon25519['A'])) + self.assertEqual(result[1], Mon25519['B'], + "Should be " + str(Mon25519['B'])) + self.assertEqual(result[2], Mon25519['u'], + "Should be " + str(Mon25519['u'])) + self.assertEqual(result[3], Mon25519['v'], + "Should be " + str(Mon25519['v'])) + + def test_B1_constructor(self): + self.assertEqual(B1.cofactor, B1_results["cofactor"], "Should be " + str(B1_results["cofactor"])) + self.assertEqual(B1.EC.a2(), B1_results["a"], "Should be " + str(B1_results["a"])) + self.assertEqual(B1.EC.a6(), B1_results["b"], "Should be " + str(B1_results["b"])) + self.assertEqual(B1.order, B1_results["order"], "Should be " + str(B1_results["order"])) + self.assertEqual(B1.x, B1_results["gen_x"], "Should be " + str(B1_results["gen_x"])) + self.assertEqual(B1.y, B1_results["gen_y"], "Should be " + str(B1_results["gen_y"])) + + +if __name__ == '__main__': + unittest.main() + print("Everything passed") diff --git a/curve_analyzer/traits/unit_tests/test_gen_params.py b/curve_analyzer/traits/unit_tests/test_gen_params.py new file mode 100644 index 0000000..c1cb343 --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_gen_params.py @@ -0,0 +1,37 @@ +import json +import os +import pathlib +import unittest + +import curve_analyzer.traits.gen_params as g +from curve_analyzer.definitions import TRAIT_PATH + + +class TestGenParams(unittest.TestCase): + + def test_read(self): + result = g.read_default(pathlib.Path(TRAIT_PATH, 'default.params')) + for test in result: + self.assertIn("params_global", result[test], "Wrong format of parameters for " + test) + self.assertIn("params_local_names", result[test], "Wrong format of parameters for " + test) + if "i07" in result: + self.assertEqual(result["i07"]["params_global"],{},"Wrong global params for i07, shoulde be "+"{}") + self.assertEqual(result["i07"]["params_local_names"],[],"Wrong local params for i07, shoulde be "+"[]") + + def test_write_i07(self): + i07tmp = "i07.params" + result = g.read_default(pathlib.Path(TRAIT_PATH, 'default.params')) + g.write_file("i07",i07tmp,result["i07"],"") + shouldbe = {"params_global": {}, "params_local_names": []} + with open(i07tmp, "r") as f: + self.assertDictEqual(json.load(f),shouldbe,"Wrong param generation for i07") + os.remove(i07tmp) + + + + +if __name__ == '__main__': + unittest.main() + print("Everything passed") + + diff --git a/curve_analyzer/traits/unit_tests/test_i06.py b/curve_analyzer/traits/unit_tests/test_i06.py new file mode 100644 index 0000000..16ac455 --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_i06.py @@ -0,0 +1,34 @@ +import ast +import unittest + +from curve_analyzer.traits.example_curves import curve_names +from curve_analyzer.traits.i06.i06 import i06_curve_function + +results = {'secp112r2': {'{}': {'p': 1, 'order': 1}}, 'bn158': {'{}': {'p': 5, 'order': 277}}, + 'brainpoolP160r1': {'{}': {'p': 627, 'order': 3}}} + + +class TestI06(unittest.TestCase): + + def test_auto_generated_secp112r2(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["secp112r2"].keys())[0]).values() + computed_result = i06_curve_function(curve_names["secp112r2"], *params) + self.assertEqual(computed_result, list(results["secp112r2"].values())[0]) + + def test_auto_generated_bn158(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["bn158"].keys())[0]).values() + computed_result = i06_curve_function(curve_names["bn158"], *params) + self.assertEqual(computed_result, list(results["bn158"].values())[0]) + + def test_auto_generated_brainpoolP160r1(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["brainpoolP160r1"].keys())[0]).values() + computed_result = i06_curve_function(curve_names["brainpoolP160r1"], *params) + self.assertEqual(computed_result, list(results["brainpoolP160r1"].values())[0]) + + +if __name__ == '__main__': + unittest.main() + print("Everything passed") diff --git a/curve_analyzer/traits/unit_tests/test_i07.py b/curve_analyzer/traits/unit_tests/test_i07.py new file mode 100644 index 0000000..401c62c --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_i07.py @@ -0,0 +1,38 @@ +import ast +import unittest + +from curve_analyzer.traits.example_curves import curve_names +from curve_analyzer.traits.i07.i07 import i07_curve_function + +results = {'secp112r2': { + '{}': {'distance': 740611633441112928659565470072532, 'ratio': 6, 'distance 32': 12, 'distance 64': 20}}, 'bn158': { + '{}': {'distance': 23639966694374437715554742421545236103616790541, 'ratio': 8, 'distance 32': 13, + 'distance 64': 13}}, 'brainpoolP160r1': { + '{}': {'distance': 129204038890858043376599793886101655442989974519, 'ratio': 10, 'distance 32': 9, + 'distance 64': 9}}} + + +class TestI07(unittest.TestCase): + + def test_auto_generated_secp112r2(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["secp112r2"].keys())[0]).values() + computed_result = i07_curve_function(curve_names["secp112r2"], *params) + self.assertEqual(computed_result, list(results["secp112r2"].values())[0]) + + def test_auto_generated_bn158(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["bn158"].keys())[0]).values() + computed_result = i07_curve_function(curve_names["bn158"],*params) + self.assertEqual(computed_result,list(results["bn158"].values())[0]) + + def test_auto_generated_brainpoolP160r1(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["brainpoolP160r1"].keys())[0]).values() + computed_result = i07_curve_function(curve_names["brainpoolP160r1"],*params) + self.assertEqual(computed_result,list(results["brainpoolP160r1"].values())[0]) + + +if __name__ == '__main__': + unittest.main() + print("Everything passed") diff --git a/curve_analyzer/traits/unit_tests/test_i10.py b/curve_analyzer/traits/unit_tests/test_i10.py new file mode 100644 index 0000000..aba6285 --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_i10.py @@ -0,0 +1,47 @@ +import ast +import unittest + +from curve_analyzer.traits.example_curves import curve_names +from curve_analyzer.traits.i10.i10 import i10_curve_function + +results = {'secp112r2': {"{'multiple': 2, 'formula_file': 'shortw/projective/addition/add-1998-cmo.op3'}": { + 'points': [[0, 383296273550222982847666203456013], [3610075134545239076002374364665933, 0], + [4159582224672948383679261762056683, 2814392144387085746068211906712334], + [477385670508437829362683123244101, 730168561475395949236536954568441], + [3610075134545239076002374364665932, 964432197919735907550954472026594], + [3490426733362996282381221682434724, 857476884809506963982152529665944]], 'len': 6}}, 'bn158': { + "{'multiple': 2, 'formula_file': 'shortw/projective/addition/add-1998-cmo.op3'}": { + 'points': [[197365096272761189180916856350650853164048453949, 3193749963018467503822332301255897023155604465], + [144232476870848113222219965746662256387438589117, 3193749963018467503822332301255897023155604465], + [71057769577865302578894779390964957349695011372, 3193749963018467503822332301255897023155604465]], + 'len': 3}}, 'brainpoolP160r1': { + "{'multiple': 2, 'formula_file': 'shortw/projective/addition/add-1998-cmo.op3'}": { + 'points': [[696755845437195843599939013205699980408716152433, 839827601121512707764030778312813146231476135309], + [117764972768661695560743921822038428802344750232, + 265502462790670151082118111395716361050588074452]], 'len': 2}}} + + +class TestI10(unittest.TestCase): + + def test_auto_generated_secp112r2(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["secp112r2"].keys())[0]).values() + computed_result = i10_curve_function(curve_names["secp112r2"], *params) + self.assertEqual(computed_result, list(results["secp112r2"].values())[0]) + + def test_auto_generated_bn158(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["bn158"].keys())[0]).values() + computed_result = i10_curve_function(curve_names["bn158"], *params) + self.assertEqual(computed_result, list(results["bn158"].values())[0]) + + def test_auto_generated_brainpoolP160r1(self): + '''This test has been auto-generated by gen_unittest''' + params = ast.literal_eval(list(results["brainpoolP160r1"].keys())[0]).values() + computed_result = i10_curve_function(curve_names["brainpoolP160r1"], *params) + self.assertEqual(computed_result, list(results["brainpoolP160r1"].values())[0]) + + +if __name__ == '__main__': + unittest.main() + print("Everything passed") diff --git a/curve_analyzer/traits/unit_tests/test_import_std_curves.py b/curve_analyzer/traits/unit_tests/test_import_std_curves.py new file mode 100644 index 0000000..c39fb91 --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_import_std_curves.py @@ -0,0 +1,28 @@ +import unittest + +from curve_analyzer.utils.curve_handler import import_curves + + +class TestImportStdCurves(unittest.TestCase): + + def test_import_sample(self): + curves = import_curves(curve_type="sample", order_bound=256, allowed_cofactors=[1]) + self.assertEqual(len(curves), 3) + + curves = import_curves(curve_type="sample", order_bound=256, allowed_cofactors=[2, 3, 4, 5]) + self.assertEqual(len(curves), 0) + + def test_import_std(self): + curves = import_curves(curve_type="std", order_bound=113, allowed_cofactors=[1]) + self.assertEqual(len(curves), 3) + + curves = import_curves(curve_type="std", order_bound=113, allowed_cofactors=[4]) + self.assertEqual(len(curves), 1) + + curves = import_curves(curve_type="std", order_bound=113, allowed_cofactors=[1, 4]) + self.assertEqual(len(curves), 4) + + +if __name__ == '__main__': + unittest.main() + print("Everything passed") diff --git a/curve_analyzer/traits/unit_tests/test_merge_trait_results.py b/curve_analyzer/traits/unit_tests/test_merge_trait_results.py new file mode 100644 index 0000000..6e3b82b --- /dev/null +++ b/curve_analyzer/traits/unit_tests/test_merge_trait_results.py @@ -0,0 +1,195 @@ +import unittest +from pathlib import Path + +from curve_analyzer.definitions import TRAIT_PATH +from curve_analyzer.traits.merge_trait_results import merge_results +from curve_analyzer.utils.json_handler import save_into_json, load_from_json + +merge_inputs = [ + { + "x962_sim_128_seed_diff_3640081": { + "{'l': 2}": { + "factorization": [ + [ + "x^3 + 340282366762482138434845932244680310780*x + 69858533633187904213879055222589606230", + 1 + ] + ], + "degs_list": [ + 3 + ], + "len": 1 + }, + "{'l': 3}": { + "factorization": [ + [ + "x + 57684394103371434835061991181330480188", + 1 + ], + [ + "x^3 + 282597972659110703599783941063349830595*x^2 + 131361467314673257169224863338731807923*x + 235236902321734479651538900332443239374", + 1 + ] + ], + "degs_list": [ + 1, + 3 + ], + "len": 2 + } + } + }, + { + "x962_sim_128_seed_diff_3640081": { + "{'l': 2}": { + "degs_list": [ + 3 + ], + "len": 1 + }, + "{'l': 5}": { + "factorization": [ + [ + "x^4 + 177980960030996657236569222432725655388*x^3 + 179015355494025119327482085732000807424*x^2 + 216744513767469203344656553134460169377*x + 59873075032689953147204208915541107074", + 1 + ], + [ + "x^4 + 215301915362031801597625930420423931372*x^3 + 22866495619330969609719939869590653745*x^2 + 138217323356300110336638435026096196018*x + 300868354871567179274729464879481506102", + 1 + ], + [ + "x^4 + 287281858131935818035496711636211034806*x^3 + 23410975633657774686744387410174523121*x^2 + 270327788618048874734423025783234213456*x + 70315420425780573490221884732686552257", + 1 + ] + ], + "degs_list": [ + 4, + 4, + 4 + ], + "len": 3 + } + } + }, + { + "x962_sim_128_seed_diff_2012754": { + "{'l': 2}": { + "factorization": [ + [ + "x + 107153254081081322654423031912408718212", + 1 + ], + [ + "x^2 + 233129112681400815780422900332271592571*x + 325820627126239880063822572368425406855", + 1 + ] + ], + "degs_list": [ + 1, + 2 + ], + "len": 2 + } + } + } +] + +merge_output = { + "x962_sim_128_seed_diff_3640081": { + "{'l': 2}": { + "factorization": [ + [ + "x^3 + 340282366762482138434845932244680310780*x + 69858533633187904213879055222589606230", + 1 + ] + ], + "degs_list": [ + 3 + ], + "len": 1 + }, + "{'l': 3}": { + "factorization": [ + [ + "x + 57684394103371434835061991181330480188", + 1 + ], + [ + "x^3 + 282597972659110703599783941063349830595*x^2 + 131361467314673257169224863338731807923*x + 235236902321734479651538900332443239374", + 1 + ] + ], + "degs_list": [ + 1, + 3 + ], + "len": 2 + }, + "{'l': 5}": { + "factorization": [ + [ + "x^4 + 177980960030996657236569222432725655388*x^3 + 179015355494025119327482085732000807424*x^2 + 216744513767469203344656553134460169377*x + 59873075032689953147204208915541107074", + 1 + ], + [ + "x^4 + 215301915362031801597625930420423931372*x^3 + 22866495619330969609719939869590653745*x^2 + 138217323356300110336638435026096196018*x + 300868354871567179274729464879481506102", + 1 + ], + [ + "x^4 + 287281858131935818035496711636211034806*x^3 + 23410975633657774686744387410174523121*x^2 + 270327788618048874734423025783234213456*x + 70315420425780573490221884732686552257", + 1 + ] + ], + "degs_list": [ + 4, + 4, + 4 + ], + "len": 3 + } + }, + "x962_sim_128_seed_diff_2012754": { + "{'l': 2}": { + "factorization": [ + [ + "x + 107153254081081322654423031912408718212", + 1 + ], + [ + "x^2 + 233129112681400815780422900332271592571*x + 325820627126239880063822572368425406855", + 1 + ] + ], + "degs_list": [ + 1, + 2 + ], + "len": 2 + } + } +} + + +class TestMergeTestResults(unittest.TestCase): + + def test_merging_and_file_manipulation(self): + tmp_test = Path(TRAIT_PATH, "a00") + tmp_test.mkdir() + + for _ in range(2): + # check functionality without and with already existing result file + for (i, merge_input) in enumerate(merge_inputs): + save_into_json(merge_input, + Path(tmp_test, "a00_part" + str(i + 1).zfill(4) + "_of_" + str(len(merge_inputs)).zfill( + 4) + ".json"), + 'w+') + merge_results("a00") + results = load_from_json(Path(tmp_test, "a00.json")) + self.assertEqual(results, merge_output) + + Path(tmp_test, "a00.json").unlink() + tmp_test.rmdir() + + +if __name__ == '__main__': + unittest.main() diff --git a/curve_analyzer/utils/__init__.py b/curve_analyzer/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/utils/curve_handler.py b/curve_analyzer/utils/curve_handler.py new file mode 100644 index 0000000..3990413 --- /dev/null +++ b/curve_analyzer/utils/curve_handler.py @@ -0,0 +1,157 @@ +import json +import os + +from sage.all import ZZ + +from curve_analyzer.definitions import CURVE_PATH, CURVE_PATH_SIM +from curve_analyzer.utils.custom_curve import CustomCurve + + +def import_curve_db(ignore_sim=True): + '''Generates a dictionary with keys = sources of curves (secg, gost,...) and values = dictionaries + These dictionaries contain description and a list of all curves from corresponding source + Curves must be in the folder CURVE_PATH (std) or SIM_CURVE_PATH (sim) + The flag ignore_sim is used for ignoring simulated curves during importing''' + curve_db = {} + for path, dirs, files in os.walk(CURVE_PATH): + if dirs != []: + continue + source = path.split("/")[-1] + + # import std curves + for file in files: + if os.path.splitext(file)[-1] != ".json": + continue + with open(os.path.join(path, file)) as f: + curve_db[source] = json.load(f) + + if not ignore_sim: + # import sim curves + for path, dirs, files in os.walk(CURVE_PATH_SIM): + if dirs != []: + continue + source = path.split("/")[-1] + + # import std curves + for file in files: + if os.path.splitext(file)[-1] != ".json": + continue + with open(os.path.join(path, file)) as f: + curve_db[source] = json.load(f) + return curve_db + + +def curve_gen(curve_db, curve_type, order_bound, verbose, binary, extension, single_curve, allowed_cofactors): + ''' + Yields instances of the class CustomCurve from the dictionary generated by import_curve_db + Curves can be specified by order_bound or curve_type: simulated (sim), standard (std) or sample (smp) + ''' + sources = curve_db.keys() + for source in sources: + curves = curve_db[source]['curves'] + for curve in curves: + if ZZ(curve["cofactor"]) not in [ZZ(c) for c in allowed_cofactors]: + continue + if not binary and curve["field"]["type"] == "Binary": + continue + if not extension and curve["field"]["type"] == "Extension": + continue + if single_curve != "" and curve["name"] != single_curve: + continue + if ZZ(curve['order']).nbits() > order_bound: + continue + name = curve['name'] + if curve_type == "std" and "sim" in name: + continue + if curve_type == "sim" and "sim" not in name: + continue + if curve_type == "sample" and name not in ["secp112r1", "secp192r1", "secp256r1"]: + continue + if verbose: + print(curve['name']) + try: + yield CustomCurve(curve) + except TypeError: + print("Skipping curve", curve['name'], "(an error occurred)") + continue + + +def custom_curves(curve_db, curve_type, order_bound, verbose, binary, extension, single_curve, allowed_cofactors): + '''Makes a list from the result of curve_gen''' + return [c for c in + curve_gen(curve_db, curve_type, order_bound, verbose, binary, extension, single_curve, allowed_cofactors)] + + +def import_curves(curve_type="sample", order_bound=256, verbose=False, binary=False, extension=False, single_curve="", + allowed_cofactors=None, chunk=1, chunks_total=1): + '''Creates a list of instances of class CustomCurve out of imported database (conditioned by curve_type, see above)''' + if allowed_cofactors is None: + allowed_cofactors = [1] + assert chunk <= chunks_total + + if single_curve != "": + print("Importing " + single_curve) + else: + print("Importing " + curve_type + " curves of sizes up to " + str( + order_bound) + " bits from the database, allowed cofactors: " + str(allowed_cofactors)) + ignore_sim = True + if curve_type in ["sim", "all"]: + ignore_sim = False + curve_db = import_curve_db(ignore_sim) + curve_list = sorted( + custom_curves(curve_db, curve_type, order_bound, verbose, binary, extension, single_curve, allowed_cofactors), + key=lambda item: item.order) + if verbose: + print("") + + def chunkify(lst, n): + """Split lst into n chunks""" + return [lst[i::n] for i in range(n)] + + curve_chunks = chunkify(curve_list, chunks_total) + return curve_chunks[chunk - 1] + + +def filter_curve_names( + allowed_categories=None, allowed_bitsizes=range(257), allowed_cofactors=None, allow_binary=False, + allow_extension=False): + if allowed_cofactors is None: + allowed_cofactors = [1] + if allowed_categories is None: + allowed_categories = ["nist", "x962", "x962_sim_128", "x962_sim_160", "x962_sim_192", "x962_sim_224", + "x962_sim_256"] + ignore_sim = not any('sim' in cat for cat in allowed_categories) + curve_db = import_curve_db(ignore_sim=ignore_sim) + + curve_names = [] + sources = curve_db.keys() + for source in sources: + curves = curve_db[source]["curves"] + for curve in curves: + if curve["category"] in allowed_categories and ZZ(curve["cofactor"]) in [ZZ(c) for c in + allowed_cofactors] and \ + curve["field"]["bits"] in allowed_bitsizes: + if (allow_binary == False and curve["field"]["type"] == "Binary") or ( + allow_extension == False and curve["field"]["type"] == "Extension"): + continue + curve_names.append(curve["name"]) + return curve_names + + +def filter_results(json_file, + allowed_categories=None, allowed_bitsizes=range(257), allowed_cofactors=None, + allow_binary=False, allow_extension=False): + if allowed_cofactors is None: + allowed_cofactors = [1] + if allowed_categories is None: + allowed_categories = ["nist", "x962", "x962_sim_128", "x962_sim_160", "x962_sim_192", "x962_sim_224", + "x962_sim_256"] + curve_names = filter_curve_names(allowed_categories=allowed_categories, allowed_bitsizes=allowed_bitsizes, + allowed_cofactors=allowed_cofactors, allow_binary=allow_binary, + allow_extension=allow_extension) + with open(json_file, 'r') as rf: + results = json.load(rf) + for key in list(results): + if key not in curve_names: + del results[key] + return results diff --git a/curve_analyzer/utils/custom_curve.py b/curve_analyzer/utils/custom_curve.py new file mode 100644 index 0000000..2ba2f86 --- /dev/null +++ b/curve_analyzer/utils/custom_curve.py @@ -0,0 +1,192 @@ +from sage.all import EllipticCurve, ZZ, GF # import sage library + + +# Converting functions using formulas in https://tools.ietf.org/id/draft-struik-lwip-curve-representations-00.html + + +def montgomery_to_short_weierstrass(F, A, B, x, y): + a = F((3 - A ** 2) / (3 * B ** 2)) + b = F((2 * A ** 3 - 9 * A) / (27 * B ** 3)) + if x == '' or y == '' or x is None or y is None: + return a, b, None, None + else: + u = F((3 * x + A) / (3 * B)) + v = F(y / B) + assert (u, v) in EllipticCurve(F, [a, b]) + return a, b, u, v + + +def twisted_edwards_to_montgomery(F, a, d, u, v, scaling=True): + A = F((2 * a + 2 * d) / (a - d)) + B = F(4 / (a - d)) + if not B.is_square(): + scaling = False + s = F(1 / B).sqrt() + + if u == '' or v == '' or u is None or v is None: + if scaling: + return A, 1, None, None + else: + return A, B, None, None + else: + x = F((1 + v) / (1 - v)) + y = F((1 + v) / ((1 - v) * u)) + if scaling: + assert (x, y / s) in EllipticCurve(F, [0, A, 0, 1, 0]) + return A, 1, x, y / s + return A, B, x, y + + +def twisted_edwards_to_short_weierstrass(F, aa, d, x, y): + A, B, x, y = twisted_edwards_to_montgomery(F, aa, d, x, y, True) + a, b, u, v = montgomery_to_short_weierstrass(F, A, B, x, y) + assert (u, v) in EllipticCurve(F, [a, b]) + return a, b, u, v + + +def get_poly(poly_dict, K): + w = K.gens()[0] + poly = 0 + for mono in poly_dict: + poly += ZZ(mono["coeff"]) * w ** ZZ(mono["power"]) + return K(poly) + + +class CustomCurve: + '''Class for unified representation of curves from databases''' + + def __init__(self, db_curve): + """the "fixed" part of attributes""" + self.name = db_curve['name'] + self.order = ZZ(db_curve['order']) + self.source = db_curve['category'] + self.field_desc = db_curve['field'] + self.form = db_curve['form'] + self.params = db_curve['params'] + self.desc = db_curve['desc'] + self.cofactor = ZZ(db_curve['cofactor']) + self.cardinality = self.order * self.cofactor + self.nbits = self.order.nbits() + self.generator_desc = db_curve['generator'] + self.field = None + self.EC = None + self.generator = None + self.q = None + self.trace = None + '''the "variable" part of attributes''' + try: + self.seed = db_curve['seed'] + except KeyError: + self.seed = None + try: + self.x = ZZ(db_curve['generator']['x']['raw']) + self.y = ZZ(db_curve['generator']['y']['raw']) + except (TypeError, KeyError): + self.x = None + self.y = None + self.set() + + def get_xy(self, extension=False): + if self.generator_desc is None: + return None, None + if extension: + x = get_poly(self.generator_desc['x']['poly'], self.field) + y = get_poly(self.generator_desc['y']['poly'], self.field) + else: + x = self.generator_desc['x']['raw'] + y = self.generator_desc['y']['raw'] + try: + x = ZZ(x) + y = ZZ(y) + except TypeError: + pass + return x, y + + def set_generator(self, binary=False, extension=False, x=None, y=None): + if x is None or y is None: + x, y = self.get_xy(extension) + if x is None or y is None or x == "" or y == "": + self.generator = None + else: + if binary: + self.generator = self.EC(self.field.fetch_int(x), self.field.fetch_int(y)) + else: + self.generator = self.EC(x, y) + + def set(self): + if self.form == "Weierstrass": + if self.field_desc['type'] == "Prime": + p = ZZ(self.field_desc['p']) + F = GF(p, proof=False) + self.field = F + a = ZZ(self.params['a']["raw"]) + b = ZZ(self.params['b']["raw"]) + self.EC = EllipticCurve(F, [a, b]) + self.set_generator() + + elif self.field_desc['type'] == "Binary": + degree = ZZ(self.field_desc['degree']) + F = GF(2)['w'] + modulus = get_poly(self.field_desc["poly"], F) + K = GF(2 ** degree, 'w', modulus, proof=False) + self.field = K + a = ZZ(self.params['a']["raw"]) + b = ZZ(self.params['b']["raw"]) + self.EC = EllipticCurve(K, [1, K.fetch_int(ZZ(a)), 0, 0, K.fetch_int(ZZ(b))]) # xy, x^2, y, x, 1 + self.set_generator(binary=True) + + elif self.field_desc['type'] == 'Extension': + base = ZZ(self.field_desc['base']) + degree = ZZ(self.field_desc['degree']) + F = GF(base, proof=False)['w'] + modulus = get_poly(self.field_desc["poly"], F) + K = GF(base ** degree, 'w', modulus, proof=False) + self.field = K + a = get_poly(self.params['a']['poly'], K) + b = get_poly(self.params['b']['poly'], K) + self.EC = EllipticCurve(K, [a, b]) + self.set_generator(extension=True) + + elif self.form == "Montgomery": + assert self.field_desc['type'] != "Extension" # TO DO + A = ZZ(self.params['a']['raw']) + B = ZZ(self.params['b']['raw']) + p = ZZ(self.field_desc['p']) + F = GF(p, proof=False) + self.field = F + x, y = self.get_xy() + a, b, u, v = montgomery_to_short_weierstrass(F, A, B, x, y) + self.EC = EllipticCurve(F, [a, b]) + self.set_generator(x=u, y=v) + + elif self.form in ["Edwards", "TwistedEdwards"]: + # we assume c=1 + assert self.field_desc['type'] != "Extension" # TO DO + if self.form == "Edwards": + aa = 1 + else: + # TwistedEdwards case + aa = ZZ(self.params['a']['raw']) + d = ZZ(self.params['d']['raw']) + p = ZZ(self.field_desc['p']) + F = GF(p, proof=False) + x, y = self.get_xy() + a, b, xx, yy = twisted_edwards_to_short_weierstrass(F, aa, d, x, y) + self.EC = EllipticCurve(F, [a, b]) + self.set_generator(x=xx, y=yy) + else: + self.EC = "Not implemented" + + self.q = self.EC.base_field().order() + self.EC.set_order(self.cardinality, num_checks=0) + self.trace = self.q + 1 - self.cardinality + + def __repr__(self): + return self.name + ": " + str(self.nbits) + "-bit curve in " + self.form + " form over " + self.field_desc[ + 'type'] + " field" + + def __str__(self): + return self.__repr__() + + def __lt__(self, other): + return (self.order.nbits(), self.name) < (other.order.nbits(), other.name) diff --git a/curve_analyzer/utils/efd b/curve_analyzer/utils/efd new file mode 160000 index 0000000..7b49ddf --- /dev/null +++ b/curve_analyzer/utils/efd @@ -0,0 +1 @@ +Subproject commit 7b49ddf6ebe5e03f40e5a5d186fb56abac59901a diff --git a/curve_analyzer/utils/json_handler.py b/curve_analyzer/utils/json_handler.py new file mode 100644 index 0000000..0cc52a9 --- /dev/null +++ b/curve_analyzer/utils/json_handler.py @@ -0,0 +1,24 @@ +import json + +from sage.all import Integer + + +class IntegerEncoder(json.JSONEncoder): + def default(self, obj): + if isinstance(obj, Integer): + return int(obj) + try: + return json.JSONEncoder.default(self, obj) + except TypeError: + return str(obj) + + +def save_into_json(results, fname, mode='a', indent=2): + with open(fname, mode) as f: + json.dump(results, f, indent=indent, cls=IntegerEncoder) + + +def load_from_json(fname): + with open(fname, 'r') as f: + results = json.load(f) + return results diff --git a/curve_analyzer/utils/parallel/MANIFEST.in b/curve_analyzer/utils/parallel/MANIFEST.in new file mode 100644 index 0000000..8a94a6b --- /dev/null +++ b/curve_analyzer/utils/parallel/MANIFEST.in @@ -0,0 +1,4 @@ +include README.md +include LICENSE +include *.sh +include *.md diff --git a/curve_analyzer/utils/parallel/README.md b/curve_analyzer/utils/parallel/README.md new file mode 100644 index 0000000..d944001 --- /dev/null +++ b/curve_analyzer/utils/parallel/README.md @@ -0,0 +1,27 @@ +# Experiment parallelizer + +Helps parallelize experiments on a single machine by executing computing jobs on a given number of threads in parallel. + +The experiment should be designed in such a way that jobs are independent of each other, no communication is required between jobs. +Each job should save it's results to an individual result file (JSON ideally). Individual result files could be merged by user after experiment finishes. + +Take a look at `example_experiment.py`. +It defines some basic dummy experiment. + +The `example_script.sage` represents an individual job script which is executed by the parallelizer with parameters passed via CLI. + +Example of usage: + +```bash +python3 -m example_experiment --sage /Applications/SageMath/sage --resdir results --tasks 2 +``` + +- Defines path to the Sage executable +- All result files will go to the `results/` dir +- Execute 2 tasks in parallel + +## Installation + +```bash +pip3 install sarge shellescape coloredlogs +``` diff --git a/curve_analyzer/utils/parallel/__init__.py b/curve_analyzer/utils/parallel/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/utils/parallel/job_manager/__init__.py b/curve_analyzer/utils/parallel/job_manager/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/utils/parallel/job_manager/manager.py b/curve_analyzer/utils/parallel/job_manager/manager.py new file mode 100644 index 0000000..9481fda --- /dev/null +++ b/curve_analyzer/utils/parallel/job_manager/manager.py @@ -0,0 +1,224 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# Author: Dusan Klinec, ph4r05, 2020 +# pip install shellescape sarge + +""" +Manager takes care of parallel execution of computation jobs. +Number of tasks to be computed in parallel is set on the initialization and remains +fixed. +""" + +import argparse +import json +import logging +import os +import queue +import shlex +import time +import uuid +from typing import List, Optional + +from curve_analyzer.utils.parallel.job_manager.runner import AsyncRunner + +logger = logging.getLogger(__name__) + + +def try_fnc(fnc): + try: + return fnc() + except: + pass + + +def get_runner(cli, cwd=None, env=None): + async_runner = AsyncRunner(cli, cwd=cwd, shell=False, env=env) + async_runner.log_out_after = False + async_runner.preexec_setgrp = True + return async_runner + + +def is_task_done(file_path): + if not os.path.isfile(file_path): + return False + with open(file_path, 'r') as f: + content = json.load(f) + if not isinstance(content, dict): + return False + return True + + +class Task: + def __init__(self, wrapper, params, tid=None): + self.wrapper = wrapper + self.params = params + self.idx = tid if tid else str(uuid.uuid4()) + + self.failed_attempts = 0 # number of attempts failed + self.skip = False # should skip if found in the queue? + self.skipped = False # skipped + + +class TaskResult: + def __init__(self, job, ret_code, stderr=None): + self.job = job # type: Task + self.ret_code = ret_code + self.stderr = stderr + + +class ParallelRunner: + def __init__(self): + self.args = None + self.parallel_tasks = None + self.job_feeder = None # function, returning task + self.cb_job_finished = None + self.cb_job_prerun = None + self.last_job_id = 0 + + self.bool_wrapper = None + self.tick_time = 0.15 + self.job_iterator = None + self.job_queue = queue.Queue(maxsize=0) + self.runners = [] # type: List[Optional[AsyncRunner]] + self.comp_jobs = [] # type: List[Optional[Task]] + self.results = [] + + def run_job(self, cli): + async_runner = get_runner(shlex.split(cli)) + + logger.info("Starting async command %s" % cli) + async_runner.start() + + while async_runner.is_running: + time.sleep(1) + logger.info("Async command finished") + + def on_finished(self, job: Task, runner: AsyncRunner, idx: int): + stderr = ("\n".join(runner.err_acc)).strip() + br = TaskResult(job, runner.ret_code, stderr) # results + + if runner.ret_code != 0: + logger.warning("Return code of job %s is %s" % (idx, runner.ret_code)) + job.failed_attempts += 1 + + if self.cb_job_finished: + self.cb_job_finished(br) + + def get_num_running(self): + return sum([1 for x in self.runners if x]) + + def queue_threshold(self): + return self.parallel_tasks * 100 + + def pull_jobs(self): + cur_jobs = [x for _, x in zip(range(self.queue_threshold()), self.job_iterator) if x is not None] + for i, j in enumerate(cur_jobs): + j.idx = self.last_job_id + i + + self.last_job_id += len(cur_jobs) + for j in cur_jobs: + self.job_queue.put_nowait(j) + + def enqueue(self, j: Task): + self.job_queue.put_nowait(j) + + def work(self): + self.job_iterator = self.job_feeder() + self.runners = [None] * self.parallel_tasks # type: List[Optional[AsyncRunner]] + self.comp_jobs = [None] * self.parallel_tasks # type: List[Optional[Task]] + self.pull_jobs() + + logger.info("Starting Experiment runner, threads: %s, jobs: %s" + % (self.parallel_tasks, self.job_queue.qsize())) + + while not self.job_queue.empty() or sum([1 for x in self.runners if x is not None]) > 0: + time.sleep(self.tick_time) + + # Realloc work + for i in range(len(self.runners)): + if self.runners[i] is not None and self.runners[i].is_running: + continue + + was_empty = self.runners[i] is None + if not was_empty: + self.job_queue.task_done() + logger.info("Task %d done, job queue size: %d, running: %s" + % (i, self.job_queue.qsize(), self.get_num_running())) + self.on_finished(self.comp_jobs[i], self.runners[i], i) + + # Start a new task, if any + try: + job = self.job_queue.get_nowait() # type: Task + except queue.Empty: + self.runners[i] = None + continue + + if self.cb_job_prerun: + self.cb_job_prerun(job) + + if job.skip: + job.skipped = True + continue + + job.skipped = False + params = job.params if isinstance(job.params, str) else ' '.join(job.params) + cli = '%s %s' % (job.wrapper, params) + self.comp_jobs[i] = job + self.runners[i] = get_runner(shlex.split(cli)) + logger.info("Starting async command %s, %s" % (job.idx, cli)) + self.runners[i].start() + logger.info("Runner %s started, job queue size: %d, running: %s" + % (i, self.job_queue.qsize(), self.get_num_running())) + + # Re-fill job queue with some data + if self.job_queue.qsize() < self.queue_threshold() / 2: + self.pull_jobs() + + def process_input(self): + """ + Design options: + 1. This is the main executor + - Need to provide exp scripts paths, load dynamically. + + 2. Users experiment definition script is the main executor. + - Manager used as a library. + - Need to reduce boilerplate for the executor, argparse, loading, ... + + :return: + """ + raise ValueError('Standalone execution is not implemented yet') + + def main(self): + logger.debug('App started') + + parser = self.argparser() + self.args = parser.parse_args() + self.parallel_tasks = self.args.tasks or try_fnc(lambda: int(os.getenv('EC_PARALLEL', None))) or 1 + self.process_input() + self.work() + + def argparser(self): + parser = argparse.ArgumentParser(description='Parallelization of jobs!') + parser.add_argument('-t', '--tasks', type=int, + help='Maximal number of parallel tasks') + parser.add_argument('-w', '--wrapper', + help='Wrapper script absolute path') + + parser.add_argument('-ei', '--exp-import', + help='Experiment definition script import path') + parser.add_argument('-ep', '--exp-path', + help='Experiment definition script path') + + parser.add_argument('-c', '--config', type=int, + help='Experiment configuration file.' + 'Passed to job-gen to generate individual jobs & tasks.') + return parser + + +def main(): + pr = ParallelRunner() + return pr.main() + + +if __name__ == '__main__': + main() diff --git a/curve_analyzer/utils/parallel/job_manager/runner.py b/curve_analyzer/utils/parallel/job_manager/runner.py new file mode 100644 index 0000000..5ffeb99 --- /dev/null +++ b/curve_analyzer/utils/parallel/job_manager/runner.py @@ -0,0 +1,368 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# Author: Dusan Klinec, ph4r05, 2018 +# pip install shellescape sarge + +import logging +import os +import signal +import sys +import threading +import time +from shlex import quote + +import shellescape +from sarge import Capture, Feeder, run + +logger = logging.getLogger(__name__) +SARGE_FILTER_INSTALLED = False + + +def try_fnc(fnc): + try: + fnc() + except: + pass + + +class SargeLogFilter(logging.Filter): + """Filters out debugging logs generated by sarge - output capture. It is way too verbose for debug""" + + def __init__(self, name="", *args, **kwargs): + self.namex = name + logging.Filter.__init__(self, *args, **kwargs) + + def filter(self, record): + if record.levelno != logging.DEBUG: + return 1 + + try: + # Parse messages are too verbose, skip. + if record.name == "sarge.parse": + return 0 + + # Disable output processing message - length of one character. + msg = record.getMessage() + if "queued chunk of length 1" in msg: + return 0 + + return 1 + + except Exception as e: + logger.error("Exception in log filtering: %s" % (e,)) + + return 1 + + +def install_sarge_filter(): + """ + Installs Sarge log filter to avoid long 1char debug dumps + :return: + """ + global SARGE_FILTER_INSTALLED + if SARGE_FILTER_INSTALLED: + return + + for handler in logging.getLogger().handlers: + handler.addFilter(SargeLogFilter("hnd")) + logging.getLogger().addFilter(SargeLogFilter("root")) + SARGE_FILTER_INSTALLED = True + + +def sarge_sigint(proc, sig=signal.SIGTERM): + """ + Sends sigint to sarge process + :return: + """ + proc.process_ready.wait() + p = proc.process + if not p: # pragma: no cover + raise ValueError("There is no subprocess") + p.send_signal(sig) + + +def escape_shell(inp): + """ + Shell-escapes input param + :param inp: + :return: + """ + try: + inp = inp.decode("utf8") + except: + pass + + try: + return shellescape.quote(inp) + except: + pass + + quote(inp) + + +class AsyncRunner: + def __init__(self, cmd, args=None, stdout=None, stderr=None, cwd=None, shell=True, env=None): + self.cmd = cmd + self.args = args + self.on_finished = None + self.on_output = None + self.on_tick = None + self.no_log_just_write = False + self.log_out_during = True + self.log_out_after = True + self.stdout = stdout + self.stderr = stderr + self.cwd = cwd + self.shell = shell + self.env = env + self.preexec_setgrp = False + + self.using_stdout_cap = True + self.using_stderr_cap = True + self.ret_code = None + self.out_acc = [] + self.err_acc = [] + self.time_start = None + self.time_elapsed = None + self.feeder = None + self.proc = None + self.is_running = False + self.was_running = False + self.terminating = False + self.thread = None + + def run(self): + try: + self.run_internal() + except Exception as e: + self.is_running = False + logger.error("Unexpected exception in runner: %s" % (e,)) + finally: + self.was_running = True + + def __del__(self): + self.deinit() + + def deinit(self): + try_fnc(lambda: self.feeder.close()) + + if not self.proc: + return + + if self.using_stdout_cap: + try_fnc(lambda: self.proc.stdout.close()) + + if self.using_stderr_cap: + try_fnc(lambda: self.proc.stderr.close()) + + try_fnc(lambda: self.proc.close()) + + def drain_stream(self, s, block=False, timeout=0.15): + ret = [] + while True: + rs = s.read(-1, block, timeout) + if not rs: + break + ret.append(rs) + return ret + + def run_internal(self): + def preexec_function(): + os.setpgrp() + + cmd = self.cmd + if self.shell: + args_str = ( + " ".join(self.args) if isinstance(self.args, (list, tuple)) else self.args + ) + + if isinstance(cmd, (list, tuple)): + cmd = " ".join(cmd) + + if args_str and len(args_str) > 0: + cmd += " " + args_str + + else: + if self.args and not isinstance(self.args, (list, tuple)): + raise ValueError("!Shell requires array of args") + if self.args: + cmd += self.args + + self.using_stdout_cap = self.stdout is None + self.using_stderr_cap = self.stderr is None + self.feeder = Feeder() + + logger.debug("Starting command %s in %s" % (cmd, self.cwd)) + + run_args = {} + if self.preexec_setgrp: + run_args['preexec_fn'] = preexec_function + + p = run( + cmd, + input=self.feeder, + async_=True, + stdout=self.stdout or Capture(timeout=0.1, buffer_size=1), + stderr=self.stderr or Capture(timeout=0.1, buffer_size=1), + cwd=self.cwd, + env=self.env, + shell=self.shell, + **run_args + ) + + self.time_start = time.time() + self.proc = p + self.ret_code = 1 + self.out_acc, self.err_acc = [], [] + out_cur, err_cur = [""], [""] + + def process_line(line, is_err=False): + dst = self.err_acc if is_err else self.out_acc + dst.append(line) + if self.log_out_during: + if self.no_log_just_write: + dv = sys.stderr if is_err else sys.stdout + dv.write(line + "\n") + dv.flush() + else: + logger.debug("Out: %s" % line.strip()) + if self.on_output: + self.on_output(self, line, is_err) + + def add_output(buffers, is_err=False, finish=False): + buffers = [x.decode("utf8") for x in buffers if x is not None and x != ""] + lines = [""] + if not buffers and not finish: + return + + dst_cur = err_cur if is_err else out_cur + for x in buffers: + clines = [v.strip("\r") for v in x.split("\n")] + lines[-1] += clines[0] + lines.extend(clines[1:]) + + nlines = len(lines) + dst_cur[0] += lines[0] + if nlines > 1: + process_line(dst_cur[0], is_err) + dst_cur[0] = "" + + for line in lines[1:-1]: + process_line(line, is_err) + + if not finish and nlines > 1: + dst_cur[0] = lines[-1] or "" + + if finish: + cline = dst_cur[0] if nlines == 1 else lines[-1] + if cline: + process_line(cline, is_err) + + try: + while len(p.commands) == 0: + time.sleep(0.15) + + logger.debug("Program started, progs: %s" % len(p.commands)) + if p.commands[0] is None: + self.is_running = False + self.was_running = True + logger.error("Program could not be started") + return + + self.is_running = True + self.on_change() + out = None + err = None + + while p.commands[0] and p.commands[0].returncode is None: + if self.using_stdout_cap: + out = p.stdout.read(-1, False) + add_output([out], is_err=False) + + if self.using_stderr_cap: + err = p.stderr.read(-1, False) + add_output([err], is_err=True) + + if self.on_tick: + self.on_tick(self) + + p.commands[0].poll() + if self.terminating and p.commands[0].returncode is None: + logger.debug("Terminating by sigint %s" % p.commands[0]) + sarge_sigint(p.commands[0], signal.SIGTERM) + sarge_sigint(p.commands[0], signal.SIGINT) + logger.debug("Sigint sent") + logger.debug("Process closed") + + # If there is data, consume it right away. + if (self.using_stdout_cap and out) or (self.using_stderr_cap and err): + continue + time.sleep(0.15) + + logger.debug("Runner while ended") + p.wait() + self.ret_code = p.commands[0].returncode if p.commands[0] else -1 + + if self.using_stdout_cap: + try_fnc(lambda: p.stdout.close()) + add_output(self.drain_stream(p.stdout, True), finish=True) + + if self.using_stderr_cap: + try_fnc(lambda: p.stderr.close()) + add_output(self.drain_stream(p.stderr, True), is_err=True, finish=True) + + self.was_running = True + self.is_running = False + self.on_change() + + logger.debug("Program ended with code: %s" % self.ret_code) + logger.debug("Command: %s" % cmd) + + if self.log_out_after: + logger.debug("Std out: %s" % "\n".join(self.out_acc)) + logger.debug("Error out: %s" % "\n".join(self.err_acc)) + + except Exception as e: + self.is_running = False + logger.error("Exception in async runner: %s" % (e,)) + + finally: + self.was_running = True + self.time_elapsed = time.time() - self.time_start + try_fnc(lambda: self.feeder.close()) + try_fnc(lambda: self.proc.close()) + + if self.on_finished: + self.on_finished(self) + + def on_change(self): + pass + + def shutdown(self): + if not self.is_running: + return + + self.terminating = True + time.sleep(1) + + # Terminating with sigint + logger.debug("Waiting for program to terminate...") + while self.is_running: + time.sleep(0.1) + logger.debug("Program terminated") + self.deinit() + + def start(self, wait_running=True): + install_sarge_filter() + self.thread = threading.Thread(target=self.run, args=()) + self.thread.setDaemon(False) + self.thread.start() + self.terminating = False + if not wait_running: + self.is_running = True + return + + self.is_running = False + while not self.is_running and not self.was_running: + time.sleep(0.1) + return self diff --git a/curve_analyzer/utils/parallel/job_manager/wrapper_generic.py b/curve_analyzer/utils/parallel/job_manager/wrapper_generic.py new file mode 100644 index 0000000..ce26e1a --- /dev/null +++ b/curve_analyzer/utils/parallel/job_manager/wrapper_generic.py @@ -0,0 +1,45 @@ +""" +General wrapper for manager.py +Wrapper is intended to be executed by the manager.py per one computation job. +Wrapper could call another scripts or call specific sage methods. + +Implementation is not yet finished. +""" +import argparse + + +def main(): + etypes = ['cli', 'method'] + parser = argparse.ArgumentParser(description='Wrapper for the sage script') + parser.add_argument('-s', '--script', dest='script', + help='Sage script file to load') + parser.add_argument('-a', '--action', dest='action', choices=etypes, + help='Action to perform on the sage script') + parser.add_argument('-f', '--function', dest='function', + help='Function name to call') + parser.add_argument('-j', '--json', dest='json', + help='JSON input to pass to the function') + parser.add_argument('-c', '--cli', dest='cli', + help='Command line arguments to pass to the script') + + # parser.add_argument('-p', '--prime', action='store', help='') + # parser.add_argument('-s', '--seed', action='store', help='') + # parser.add_argument('-f', '--outfile', action='store', help='') + args = parser.parse_args() + + # generate_x962_curves(args.count, args.prime, args.seed, jsonfile= args.outfile) + + if args.action == 'method': + # Load Sage script to this namespace + load(args.script) + fnc = args.function + + + elif args.action == 'cli': + pass + else: + raise ValueError('Unknown action') + + +if __name__ == '__main__': + main() diff --git a/curve_analyzer/utils/parallel/results/x962/x962_stats b/curve_analyzer/utils/parallel/results/x962/x962_stats new file mode 100644 index 0000000..b558616 --- /dev/null +++ b/curve_analyzer/utils/parallel/results/x962/x962_stats @@ -0,0 +1,6 @@ +X9.62 stats +128b 5000000 seeds tried: 93796 curves found, 15916 of them with cofactor 1 +160b 5000000 seeds tried: 67584 curves found, 12509 of them with cofactor 1 +192b 5000000 seeds tried: 24663 curves found, 8303 of them with cofactor 1 +224b 5000000 seeds tried: 16058 curves found, 9360 of them with cofactor 1 +256b 5000000 seeds tried: 15087 curves found, 8101 of them with cofactor 1 \ No newline at end of file diff --git a/curve_analyzer/utils/parallel/run_simulations.py b/curve_analyzer/utils/parallel/run_simulations.py new file mode 100644 index 0000000..07f4824 --- /dev/null +++ b/curve_analyzer/utils/parallel/run_simulations.py @@ -0,0 +1,120 @@ +import argparse +import json +import logging +import os + +from sage.all import ZZ + +from curve_analyzer.utils.parallel.job_manager.manager import ParallelRunner, Task, TaskResult +from curve_analyzer.utils.parallel.x962.simulations_x962 import increment_seed + +try: + import coloredlogs + + coloredlogs.install(level=logging.INFO) +except Exception as e: + print('E: Package coloredlogs is not installed. No logs will be displayed') + +logger = logging.getLogger(__name__) + + +def get_file_name(params, resdir=None): + fname = '%s.json' % ('_'.join(map(str, params)),) + return fname if resdir is None else os.path.join(resdir, fname) + + +def load_x962_parameters(config_path, num_bits, total_count, count, offset, resdir=None): + with open(config_path, 'r') as f: + params = json.load(f) + p, curve_seed = params['%s' % num_bits] + curve_seed = increment_seed(curve_seed, -offset) + + while total_count > 0: + if total_count < count: + file_name = get_file_name([total_count, ZZ(p).nbits(), curve_seed], resdir) + yield {'count': total_count, 'prime': p, 'seed': curve_seed, 'outfile': file_name} + else: + file_name = get_file_name([count, ZZ(p).nbits(), curve_seed], resdir) + yield {'count': count, 'prime': p, 'seed': curve_seed, 'outfile': file_name} + + total_count -= count + curve_seed = str.format('{:040X}', int(curve_seed, 16) - count) + + +def main(): + parser = argparse.ArgumentParser(description='Experiment parallelizer') + parser.add_argument('--tasks', type=int, default=10, + help='Number of tasks to run in parallel') + parser.add_argument('-s', '--sage', default='sage', + help='Path to the sage') + parser.add_argument('-c', '--count', type=int, default=16, + help='') + parser.add_argument('-t', '--totalcount', dest='total_count', type=int, default=32, + help='') + parser.add_argument('-b', '--bits', type=int, default=128, + help='') + parser.add_argument('-o', '--offset', type=int, default=0, + help='') + parser.add_argument('--resdir', dest='resdir', + default=os.path.join('./results/x962', str(parser.parse_args().bits)), + help='Where to store experiment results') + parser.add_argument('-p', '--configpath', default='x962/parameters_x962.json', + help='') + args = parser.parse_args() + print(args) + + os.makedirs(args.resdir, exist_ok=True) # make sure resdir exists + + script_path = os.path.abspath(os.path.dirname(os.path.realpath(__file__))) + wrapper_path = os.path.join(script_path, 'x962/simulations_x962_wrapper.py') + + pr = ParallelRunner() + pr.parallel_tasks = args.tasks + + def feeder(): + """ + Create function that generates computing jobs. + ParallelRunner class takes any function that generates iterable of Task instances. + Usually its best to implement it as a generator so jobs are generated on the fly and they don't + have to be memorized. This function can be called several times during the computation + to add new jobs to the computing queue. + + The general approach of using a function to generate Tasks gives us flexibility + in terms of implementation. Here we use function that reads `args`, reads the input parameter + file and generates tasks based on this information. + The function also has an access to `pr` so it can adapt to job already being done. + The function can also store its own state. + """ + for p in load_x962_parameters(args.configpath, args.bits, args.total_count, args.count, args.offset, + args.resdir): + cli = ' '.join(['--%s=%s' % (k, p[k]) for k in p.keys()]) + t = Task(args.sage, '%s %s' % (wrapper_path, cli)) + yield t + + def prerun(j: Task): + """ + Function executed just after the Task is taken out from the queue and before + executing by a worker. + By setting j.skip = True this task will be skipped and not executed. + You won't get notification about finishing + """ + logger.info("Going to start task %s" % (j.idx,)) + + def on_finished(r: TaskResult): + """ + Called when task completes. Can be used to re-enqueue failed task. + You also could open the result file and analyze it, but this could slow-down + the job manager loop (callbacks are executed on manager thread). + """ + logger.info("Task %s finished, code: %s, fails: %s" % (r.job.idx, r.ret_code, r.job.failed_attempts)) + if r.ret_code != 0 and r.job.failed_attempts < 3: + pr.enqueue(r.job) + + pr.job_feeder = feeder + pr.cb_job_prerun = prerun + pr.cb_job_finished = on_finished + pr.work() + + +if __name__ == '__main__': + main() diff --git a/curve_analyzer/utils/parallel/secg/__init__.py b/curve_analyzer/utils/parallel/secg/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/utils/parallel/secg/parameters_secg.json b/curve_analyzer/utils/parallel/secg/parameters_secg.json new file mode 100644 index 0000000..594f3e8 --- /dev/null +++ b/curve_analyzer/utils/parallel/secg/parameters_secg.json @@ -0,0 +1,34 @@ +{ + "112": [ + 4451685225093714772084598273548427, + "00F50B028E4D696E676875615175290472783FB1" + ], + "128": [ + 340282366762482138434845932244680310783, + "000E0D4D696E6768756151750CC03A4473D03679" + ], + "160": [ + 1461501637330902918203684832716283019653785059327, + "1053CDE42C14D696E67687561517533BF3F83345" + ], + "192": [ + 6277101735386680763835789423207666416083908700390324961279, + "3045AE6FC8422F64ED579528D38120EAE12196D5" + ], + "224": [ + 26959946667150639794667015087019630673557916260026308143510066298881, + "BD71344799D5C7FCDC45B59FA3B9AB8F6A948BC5" + ], + "256": [ + 115792089210356248762697446949407573530086143415290314195533631308867097853951, + "C49D360886E704936A6678E1139D26B7819F7E90" + ], + "384": [ + 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319, + "A335926AA319A27A1D00896A6773A4827ACDAC73" + ], + "521": [ + 429049853758163107186368799942587076079339706258956588087153966199096448962353503257659977541340909686081019461967553627320124249982290238285876768194691071, + "D09E8800291CB85396CC6717393284AAA0DA64BA" + ] +} diff --git a/curve_analyzer/utils/parallel/secg/simulations_secg.py b/curve_analyzer/utils/parallel/secg/simulations_secg.py new file mode 100644 index 0000000..4beeacf --- /dev/null +++ b/curve_analyzer/utils/parallel/secg/simulations_secg.py @@ -0,0 +1,242 @@ +import json +from hashlib import sha1 + +from sage.all import Integers, ZZ, floor, log, ceil, GF, is_prime, PolynomialRing, EllipticCurve, prime_range, \ + is_pseudoprime, \ + sqrt + + +# Differs from x9.62 by: +# 1) embedding degree has to be at least 100 +# 2) cofactor h satisfies h<= 2^(t/8) where t is the security level in bits (usually log(p)/2) +# 3) n+1 and n-1 (where n is the prime subgroup) have to have large prime factor (log_n(factor)>19/20) + +# !! secp224r1 doesn't seem to satisfy 3) + +# hex string to binary string +def sha1_bin(x): + return format(ZZ(sha1(bytes.fromhex(x)).hexdigest(), 16), '0160b') + + +def sha1_hex(x): + return format(ZZ(sha1(x), 2), '0160x') + + +def int_to_hex_string(x): + f = '0' + str(ceil(x.nbits() / 8) * 2) + 'X' + return format(ZZ(x, 16), f) + + +def increment_seed(seed, i=1): + """accepts a hex string as input (not starting with 0x)""" + g = ZZ(seed, 16).nbits() + f = '0' + str(len(seed)) + 'X' + return format(ZZ(Integers(2 ** g)(ZZ(seed, 16) + i)), f) + + +# http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.202.2977&rep=rep1&type=pdf, page 42 +def generate_r(seed, p): + t = p.nbits() + # t = ceil(log(p,2)) + # originally floor + s = floor((t - 1) / 160) + h = t - 160 * s + H = sha1_bin(seed) + c0 = H[-h:] + c0_modified = list(c0) + c0_modified[0] = '0' + W = [0] * (s + 1) + W[0] = ''.join(c0_modified) + for i in range(1, s + 1): + input_i = increment_seed(seed, i) + W[i] = sha1_bin(input_i) + W_joint = ''.join(W) + assert (len(W_joint) == t) + r = 0 + for i in range(1, t + 1): + r += ZZ(W_joint[i - 1]) * 2 ** (t - i) + assert (r == ZZ(W_joint, 2)) + F = GF(p) + return F(r) + + +def expected_r(p, a, b): + F = GF(p) + return F(a ** 3 / b ** 2) + + +def verify_r(p, r, a, b): + F = GF(p) + return F(r) == expected_r(p, a, b) + + +def get_b_from_r(r, p, a=-3): + F = GF(p) + if F(a ** 3 / r).is_square(): + return ZZ(F(a ** 3 / r).sqrt()) + else: + return None + + +def embedding_degree_q(q, r): + """returns embedding degree with respect to q""" + return Integers(r)(q).multiplicative_order() + + +def embedding_degree(E, r): + """returns relative embedding degree with respect to E""" + q = (E.base_field()).order() + assert is_prime(q) + return embedding_degree_q(q, r) + + +def has_points_of_low_order(E, l_max=4): + # deterministic method utilizing division polynomials, useful for 256 bit E with l_max = 4 (see docs/division_early_abort) + p = E.base_field().order() + R = PolynomialRing(GF(p), 'x') + x = R.gen() + weier = x ** 3 + x * E.ainvs()[-2] + E.ainvs()[-1] + for l in prime_range(l_max): + div_pol = E.division_polynomial(l) + roots = div_pol.roots(GF(p)) + for root, mult in roots: + if weier(R(root)).is_square(): + return True + else: + continue + return False + + +# A2.2 in http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.202.2977&rep=rep1&type=pdf +def verify_near_primality(u, r_min, l_max=255): + n = u + h = 1 + for l in prime_range(l_max): + while n % l == 0: + n = ZZ(n / l) + h = h * l + if n < r_min: + return False, None, None + if is_pseudoprime(n): + return True, h, n + return False, None, None + + +def security_level(q): + L = ceil(log(q, 2)) + if L == 521: + return 256 + if L == 192: + return 80 + return L // 2 + + +def verify_n_minusplus_1(m, N, bound=19 / 20): + for d in m.factor(): + if log(d[0], N) > bound: + return True + return False + + +def verify_security(E, embedding_degree_bound=100, verbose=False): + if verbose: + print("Computing order") + q = E.base_field().order() + order = E.order() + # a somewhat arbitrary bound (slightly more strict than in the standard), but it will speed up the generation process + r_min_bits = order.nbits() - 5 + r_min = max(2 ** r_min_bits, 4 * sqrt(q)) + if verbose: + print("Checking near-primality of", order) + near_prime, h, n = verify_near_primality(order, r_min) + if not near_prime: + return False, None, None + if verbose: + print("Checking MOV") + if embedding_degree(E, order) < embedding_degree_bound: + return False, None, None + if verbose: + print("Checking Frob") + if E.trace_of_frobenius() in [-1, 1]: + return False, None, None + if verbose: + print("Checking cofactor") + t = security_level(q) + if log(h, 2) > t // 8 or h != (floor((sqrt(q) + 1) ** 2)) // n: + print("tu2") + return False, None, None + if not verify_n_minusplus_1(n - 1, n) or not verify_n_minusplus_1(n + 1, n): + print("tu") + return False, None, None + return True, h, n + + +def generate_secg_curves(count, p, seed): + bits = p.nbits() + sim_curves = {"name": "secg_sim_" + str(bits), "desc": "simulated curves generated according to the sec standard", + "initial_seed": seed, "seeds_tried": count, "curves": [], "seeds_successful": 0} + + # bitlens, primes and corresponding seeds, case a=-3 (curves r1, prime fields only) + # https://www.secg.org/sec2-v2.pdf + with open('secg/parameters_secg.json', 'r') as f: + params = json.load(f) + original_seed = params[str(bits)][1] + + for i in range(1, count + 1): + current_seed = increment_seed(seed, -i) + r = generate_r(current_seed, p) + b = get_b_from_r(r, p) + a = -3 + + # check if r gives rise to an elliptic curve + if b is None or 4 * a ** 3 + 27 * b ** 2 == 0: + continue + E = EllipticCurve(GF(p), [a, b]) + + # a heuristic for speeding up the generation process in exchange for sacrificing some curves with low cofactor + if bits < 224: + l_max = 3 + if bits < 192: + l_max = 2 + else: + l_max = 4 + if has_points_of_low_order(E, l_max): + continue + + secure, h, n = verify_security(E) + if not secure: + continue + + seed_diff = ZZ('0X' + original_seed) - ZZ('0X' + current_seed) + sim_curve = { + "name": "secg_sim_" + str(bits) + "_seed_diff_" + str(seed_diff), + "category": sim_curves["name"], + "desc": "", + "field": { + "type": "Prime", + "p": str(hex(p)), + "bits": bits, + }, + "form": "Weierstrass", + "params": { + "a": {"raw": str(hex(-3))}, + "b": {"raw": str(hex(b))} + }, + "generator": { + "x": { + "raw": "" + }, + "y": { + "raw": "" + } + }, + "order": n, + "cofactor": h, + "characteristics": None, + "seed": current_seed, + "seed_diff": seed_diff + } + sim_curves["curves"].append(sim_curve) + sim_curves["seeds_successful"] += 1 + + return sim_curves diff --git a/curve_analyzer/utils/parallel/setup.cfg b/curve_analyzer/utils/parallel/setup.cfg new file mode 100644 index 0000000..8e4a845 --- /dev/null +++ b/curve_analyzer/utils/parallel/setup.cfg @@ -0,0 +1,33 @@ +[bdist_wheel] +universal = 1 + +[flake8] +ignore = +# E203 whitespace before ':' + E203, +# E221: multiple spaces before operator + E221, +# E241: multiple spaces after ':' + E241, +# E402: module level import not at top of file + E402, +# E501: line too long + E501, +# E741 ambiguous variable name + E741, +# F403: star import used, unable to detect undefined names + F403, +# F405: name may be undefined, or defined from star imports + F405, +# W503: line break before binary operator + W503 + +[isort] +multi_line_output = 3 +include_trailing_comma = True +force_grid_wrap = 0 +combine_as_imports = True +line_length = 88 +not_skip = __init__.py +forced_separate = apps + diff --git a/curve_analyzer/utils/parallel/setup.py b/curve_analyzer/utils/parallel/setup.py new file mode 100644 index 0000000..2704061 --- /dev/null +++ b/curve_analyzer/utils/parallel/setup.py @@ -0,0 +1,56 @@ +from setuptools import find_packages +from setuptools import setup + +version = '0.0.0' + +# Please update tox.ini when modifying dependency version requirements +install_requires = [ + 'sarge', + 'psutil', + 'pid>=2.0.1', + 'coloredlogs', + 'shellescape', +] + +dev_extras = [ + 'nose', + 'pep8', + 'tox', +] + +docs_extras = [ + 'Sphinx>=1.0', # autodoc_member_order = 'bysource', autodoc_default_flags + 'sphinx_rtd_theme', + 'sphinxcontrib-programoutput', +] + +setup( + name='parallel_curve_analyser', + version=version, + description='Parallel execution', + url='https://github.com/crocs-muni/Parallel_Curve_analyser', + author='CRoCS', + author_email='xsvenda@fi.muni.cz', + license='MIT', + classifiers=[ + 'Development Status :: 3 - Alpha', + 'Intended Audience :: Developers', + 'Programming Language :: Python', + 'Programming Language :: Python :: 2', + 'Programming Language :: Python :: 2.6', + 'Programming Language :: Python :: 2.7', + 'Programming Language :: Python :: 3', + 'Programming Language :: Python :: 3.3', + 'Programming Language :: Python :: 3.4', + 'Programming Language :: Python :: 3.5', + 'Topic :: Security', + ], + + packages=find_packages(), + include_package_data=True, + install_requires=install_requires, + extras_require={ + 'dev': dev_extras, + 'docs': docs_extras, + } +) diff --git a/curve_analyzer/utils/parallel/x962/__init__.py b/curve_analyzer/utils/parallel/x962/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/utils/parallel/x962/merge_x962_results.py b/curve_analyzer/utils/parallel/x962/merge_x962_results.py new file mode 100644 index 0000000..005c25f --- /dev/null +++ b/curve_analyzer/utils/parallel/x962/merge_x962_results.py @@ -0,0 +1,63 @@ +#!/usr/bin/env sage + +import json +import os + +from curve_analyzer.definitions import PARALLEL_RESULTS_PATH, X962_PATH +from curve_analyzer.utils.json_handler import IntegerEncoder +from curve_analyzer.utils.parallel.x962.simulations_x962 import increment_seed + +X962_RESULTS = os.path.join(PARALLEL_RESULTS_PATH, 'x962') +VERBOSE = False + +# get the names of immediate subdirs, which should be the respective bitsizes +bitsizes = [f.name for f in os.scandir(X962_RESULTS) if f.is_dir()] + +for bitsize in bitsizes: + results_path = os.path.join(X962_RESULTS, bitsize) + # skip empty dirs + if len(os.listdir(results_path)) == 0: + continue + + with open(os.path.join(X962_PATH, 'parameters_x962.json'), 'r') as f: + params = json.load(f) + original_seed = params[bitsize][1] + merged = None + + for root, _, files in os.walk(results_path): + # iterate through result files, starting with largest seeds + for file in sorted(files, key=lambda x: int((x.split('.')[-2]).split('_')[-1], 16), reverse=True): + fname = os.path.join(root, file) + with open(fname, 'r') as f: + results = json.load(f) + if VERBOSE: + print('Merging ', fname, '...') + + if merged is None: + merged = results + expected_initial_seed = original_seed + else: + expected_initial_seed = increment_seed(original_seed, -merged["seeds_tried"]) + merged["curves"] += results["curves"] + merged["seeds_tried"] += results["seeds_tried"] + merged["seeds_successful"] += results["seeds_successful"] + # check seed continuity + try: + assert (expected_initial_seed == results["initial_seed"]) + except AssertionError: + raise ValueError('The expected initial seed is ', expected_initial_seed, ' but the current one is ', + results["initial_seed"]) + + # save the merged results into a temp file, then delete all others, then rename it + merged_name = os.path.join(results_path, + str(merged["seeds_tried"]) + '_' + str(bitsize) + '_' + original_seed + '.json') + merged_name_tmp = merged_name + '.tmp' + with open(merged_name_tmp, 'w+') as fh: + json.dump(merged, fh, cls=IntegerEncoder) + + for root, _, files in os.walk(results_path): + for file in sorted(files, reverse=True): + fname = os.path.join(root, file) + if os.path.splitext(fname)[1] != '.tmp': + os.remove(fname) + os.rename(merged_name_tmp, merged_name) diff --git a/curve_analyzer/utils/parallel/x962/parameters_x962.json b/curve_analyzer/utils/parallel/x962/parameters_x962.json new file mode 100644 index 0000000..594f3e8 --- /dev/null +++ b/curve_analyzer/utils/parallel/x962/parameters_x962.json @@ -0,0 +1,34 @@ +{ + "112": [ + 4451685225093714772084598273548427, + "00F50B028E4D696E676875615175290472783FB1" + ], + "128": [ + 340282366762482138434845932244680310783, + "000E0D4D696E6768756151750CC03A4473D03679" + ], + "160": [ + 1461501637330902918203684832716283019653785059327, + "1053CDE42C14D696E67687561517533BF3F83345" + ], + "192": [ + 6277101735386680763835789423207666416083908700390324961279, + "3045AE6FC8422F64ED579528D38120EAE12196D5" + ], + "224": [ + 26959946667150639794667015087019630673557916260026308143510066298881, + "BD71344799D5C7FCDC45B59FA3B9AB8F6A948BC5" + ], + "256": [ + 115792089210356248762697446949407573530086143415290314195533631308867097853951, + "C49D360886E704936A6678E1139D26B7819F7E90" + ], + "384": [ + 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319, + "A335926AA319A27A1D00896A6773A4827ACDAC73" + ], + "521": [ + 429049853758163107186368799942587076079339706258956588087153966199096448962353503257659977541340909686081019461967553627320124249982290238285876768194691071, + "D09E8800291CB85396CC6717393284AAA0DA64BA" + ] +} diff --git a/curve_analyzer/utils/parallel/x962/simulations_x962.py b/curve_analyzer/utils/parallel/x962/simulations_x962.py new file mode 100644 index 0000000..cf4a3c5 --- /dev/null +++ b/curve_analyzer/utils/parallel/x962/simulations_x962.py @@ -0,0 +1,210 @@ +import json +from hashlib import sha1 + +from sage.all import Integers, ZZ, floor, ceil, GF, is_prime, PolynomialRing, EllipticCurve, prime_range, \ + is_pseudoprime, \ + sqrt + + +# hex string to binary string +def sha1_bin(x): + return format(ZZ(sha1(bytes.fromhex(x)).hexdigest(), 16), '0160b') + + +def sha1_hex(x): + return format(ZZ(sha1(x), 2), '0160x') + + +def int_to_hex_string(x): + f = '0' + str(ceil(x.nbits() / 8) * 2) + 'X' + return format(ZZ(x, 16), f) + + +def increment_seed(seed, i=1): + """accepts a hex string as input (not starting with 0x)""" + g = ZZ(seed, 16).nbits() + f = '0' + str(len(seed)) + 'X' + return format(ZZ(Integers(2 ** g)(ZZ(seed, 16) + i)), f) + + +# http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.202.2977&rep=rep1&type=pdf, page 42 +def generate_r(seed, p): + t = p.nbits() + # t = ceil(log(p,2)) + # originally floor + s = floor((t - 1) / 160) + h = t - 160 * s + H = sha1_bin(seed) + c0 = H[-h:] + c0_modified = list(c0) + c0_modified[0] = '0' + W = [0] * (s + 1) + W[0] = ''.join(c0_modified) + for i in range(1, s + 1): + input_i = increment_seed(seed, i) + W[i] = sha1_bin(input_i) + W_joint = ''.join(W) + assert (len(W_joint) == t) + r = 0 + for i in range(1, t + 1): + r += ZZ(W_joint[i - 1]) * 2 ** (t - i) + assert (r == ZZ(W_joint, 2)) + F = GF(p) + return F(r) + + +def expected_r(p, a, b): + F = GF(p) + return F(a ** 3 / b ** 2) + + +def verify_r(p, r, a, b): + F = GF(p) + return F(r) == expected_r(p, a, b) + + +def get_b_from_r(r, p, a=-3): + F = GF(p) + if F(a ** 3 / r).is_square(): + return ZZ(F(a ** 3 / r).sqrt()) + else: + return None + + +def embedding_degree_q(q, r): + """returns embedding degree with respect to q""" + return Integers(r)(q).multiplicative_order() + + +def embedding_degree(E, r): + """returns relative embedding degree with respect to E""" + q = (E.base_field()).order() + assert is_prime(q) + return embedding_degree_q(q, r) + + +def has_points_of_low_order(E, l_max=4): + # deterministic method utilizing division polynomials, useful for 256 bit E with l_max = 4 (see docs/division_early_abort) + p = E.base_field().order() + R = PolynomialRing(GF(p), 'x') + x = R.gen() + weier = x ** 3 + x * E.ainvs()[-2] + E.ainvs()[-1] + for l in prime_range(l_max): + div_pol = E.division_polynomial(l) + roots = div_pol.roots(GF(p)) + for root, mult in roots: + if weier(R(root)).is_square(): + return True + else: + continue + return False + + +# A2.2 in http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.202.2977&rep=rep1&type=pdf +def verify_near_primality(u, r_min, l_max=255): + n = u + h = 1 + for l in prime_range(l_max): + while n % l == 0: + n = ZZ(n / l) + h = h * l + if n < r_min: + return False, None, None + if is_pseudoprime(n): + return True, h, n + return False, None, None + + +def verify_security(E, embedding_degree_bound=20, verbose=False): + if verbose: + print("Computing order") + q = E.base_field().order() + order = E.order() + # a somewhat arbitrary bound (slightly more strict than in the standard), but it will speed up the generation process + r_min_bits = order.nbits() - 5 + r_min = max(2 ** r_min_bits, 4 * sqrt(q)) + if verbose: + print("Checking near-primality of", order) + near_prime, h, n = verify_near_primality(order, r_min) + if not near_prime: + return False, None, None + if verbose: + print("Checking MOV") + if embedding_degree(E, order) < embedding_degree_bound: + return False, None, None + if verbose: + print("Checking Frob") + if E.trace_of_frobenius() in [-1, 1]: + return False, None, None + return True, h, n + + +def generate_x962_curves(count, p, seed): + bits = p.nbits() + sim_curves = {"name": "x962_sim_" + str(bits), "desc": "simulated curves generated according to the X9.62 standard", + "initial_seed": seed, "seeds_tried": count, "curves": [], "seeds_successful": 0} + + # bitlens, primes and corresponding seeds, case a=-3 (curves r1, prime fields only) + # https://www.secg.org/sec2-v2.pdf + with open('x962/parameters_x962.json', 'r') as f: + params = json.load(f) + original_seed = params[str(bits)][1] + + for i in range(1, count + 1): + current_seed = increment_seed(seed, -i) + r = generate_r(current_seed, p) + b = get_b_from_r(r, p) + a = -3 + + # check if r gives rise to an elliptic curve + if b is None or 4 * a ** 3 + 27 * b ** 2 == 0: + continue + E = EllipticCurve(GF(p), [a, b]) + + # a heuristic for speeding up the generation process in exchange for sacrificing some curves with low cofactor + if bits < 224: + l_max = 3 + if bits < 192: + l_max = 2 + else: + l_max = 4 + if has_points_of_low_order(E, l_max): + continue + + secure, h, n = verify_security(E) + if not secure: + continue + + seed_diff = ZZ('0X' + original_seed) - ZZ('0X' + current_seed) + sim_curve = { + "name": "x962_sim_" + str(bits) + "_seed_diff_" + str(seed_diff), + "category": sim_curves["name"], + "desc": "", + "field": { + "type": "Prime", + "p": str(hex(p)), + "bits": bits, + }, + "form": "Weierstrass", + "params": { + "a": {"raw": str(hex(-3))}, + "b": {"raw": str(hex(b))} + }, + "generator": { + "x": { + "raw": "" + }, + "y": { + "raw": "" + } + }, + "order": n, + "cofactor": h, + "characteristics": None, + "seed": current_seed, + "seed_diff": seed_diff + } + sim_curves["curves"].append(sim_curve) + sim_curves["seeds_successful"] += 1 + + return sim_curves diff --git a/curve_analyzer/utils/parallel/x962/simulations_x962_wrapper.py b/curve_analyzer/utils/parallel/x962/simulations_x962_wrapper.py new file mode 100644 index 0000000..57435c4 --- /dev/null +++ b/curve_analyzer/utils/parallel/x962/simulations_x962_wrapper.py @@ -0,0 +1,37 @@ +""" +Sage script containing the functions for the experiment. +Has CLI so we can start experiments directly from the CLI. + +User can specify job to compute either via CLI or as +a JSON config file (not implemented here). + +After experiment is finished, the script writes results to the output file. +""" + +import argparse +import json + +from sage.all import ZZ + +from curve_analyzer.utils.json_handler import IntegerEncoder +from curve_analyzer.utils.parallel.x962.simulations_x962 import generate_x962_curves + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description='Sage experiment runner') + + parser.add_argument('-c', '--count', action='store', help='') + parser.add_argument('-p', '--prime', action='store', help='') + parser.add_argument('-s', '--seed', action='store', help='') + parser.add_argument('-f', '--outfile', action='store', help='') + args = parser.parse_args() + print(args) + + # Do the computation + count = ZZ(args.count) + p = ZZ(args.prime) + seed = args.seed + r = generate_x962_curves(count, p, seed) + + # Save results to the output file + with open(args.outfile, 'w+') as fh: + json.dump(r, fh, cls=IntegerEncoder) diff --git a/curve_analyzer/utils/parallel/x963/simulations_x963.py b/curve_analyzer/utils/parallel/x963/simulations_x963.py new file mode 100644 index 0000000..b229888 --- /dev/null +++ b/curve_analyzer/utils/parallel/x963/simulations_x963.py @@ -0,0 +1,213 @@ +import json +from hashlib import sha1 + +from sage.all import Integers, ZZ, floor, ceil, GF, is_prime, PolynomialRing, EllipticCurve, prime_range, \ + is_pseudoprime, \ + sqrt + + +# For now, it is the same as x962 + + +# hex string to binary string +def sha1_bin(x): + return format(ZZ(sha1(bytes.fromhex(x)).hexdigest(), 16), '0160b') + + +def sha1_hex(x): + return format(ZZ(sha1(x), 2), '0160x') + + +def int_to_hex_string(x): + f = '0' + str(ceil(x.nbits() / 8) * 2) + 'X' + return format(ZZ(x, 16), f) + + +def increment_seed(seed, i=1): + """accepts a hex string as input (not starting with 0x)""" + g = ZZ(seed, 16).nbits() + f = '0' + str(len(seed)) + 'X' + return format(ZZ(Integers(2 ** g)(ZZ(seed, 16) + i)), f) + + +# http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.202.2977&rep=rep1&type=pdf, page 42 +def generate_r(seed, p): + t = p.nbits() + # t = ceil(log(p,2)) + # originally floor + s = floor((t - 1) / 160) + h = t - 160 * s + H = sha1_bin(seed) + c0 = H[-h:] + c0_modified = list(c0) + c0_modified[0] = '0' + W = [0] * (s + 1) + W[0] = ''.join(c0_modified) + for i in range(1, s + 1): + input_i = increment_seed(seed, i) + W[i] = sha1_bin(input_i) + W_joint = ''.join(W) + assert (len(W_joint) == t) + r = 0 + for i in range(1, t + 1): + r += ZZ(W_joint[i - 1]) * 2 ** (t - i) + assert (r == ZZ(W_joint, 2)) + F = GF(p) + return F(r) + + +def expected_r(p, a, b): + F = GF(p) + return F(a ** 3 / b ** 2) + + +def verify_r(p, r, a, b): + F = GF(p) + return F(r) == expected_r(p, a, b) + + +def get_b_from_r(r, p, a=-3): + F = GF(p) + if F(a ** 3 / r).is_square(): + return ZZ(F(a ** 3 / r).sqrt()) + else: + return None + + +def embedding_degree_q(q, r): + """returns embedding degree with respect to q""" + return Integers(r)(q).multiplicative_order() + + +def embedding_degree(E, r): + """returns relative embedding degree with respect to E""" + q = (E.base_field()).order() + assert is_prime(q) + return embedding_degree_q(q, r) + + +def has_points_of_low_order(E, l_max=4): + # deterministic method utilizing division polynomials, useful for 256 bit E with l_max = 4 (see docs/division_early_abort) + p = E.base_field().order() + R = PolynomialRing(GF(p), 'x') + x = R.gen() + weier = x ** 3 + x * E.ainvs()[-2] + E.ainvs()[-1] + for l in prime_range(l_max): + div_pol = E.division_polynomial(l) + roots = div_pol.roots(GF(p)) + for root, mult in roots: + if weier(R(root)).is_square(): + return True + else: + continue + return False + + +# A2.2 in http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.202.2977&rep=rep1&type=pdf +def verify_near_primality(u, r_min, l_max=255): + n = u + h = 1 + for l in prime_range(l_max): + while n % l == 0: + n = ZZ(n / l) + h = h * l + if n < r_min: + return False, None, None + if is_pseudoprime(n): + return True, h, n + return False, None, None + + +def verify_security(E, embedding_degree_bound=20, verbose=False): + if verbose: + print("Computing order") + q = E.base_field().order() + order = E.order() + # a somewhat arbitrary bound (slightly more strict than in the standard), but it will speed up the generation process + r_min_bits = order.nbits() - 5 + r_min = max(2 ** r_min_bits, 4 * sqrt(q)) + if verbose: + print("Checking near-primality of", order) + near_prime, h, n = verify_near_primality(order, r_min) + if not near_prime: + return False, None, None + if verbose: + print("Checking MOV") + if embedding_degree(E, order) < embedding_degree_bound: + return False, None, None + if verbose: + print("Checking Frob") + if E.trace_of_frobenius() in [-1, 1]: + return False, None, None + return True, h, n + + +def generate_x963_curves(count, p, seed): + bits = p.nbits() + sim_curves = {"name": "x963_sim_" + str(bits), "desc": "simulated curves generated according to the X9.62 standard", + "initial_seed": seed, "seeds_tried": count, "curves": [], "seeds_successful": 0} + + # bitlens, primes and corresponding seeds, case a=-3 (curves r1, prime fields only) + # https://www.secg.org/sec2-v2.pdf + with open('x963/parameters_x963.json', 'r') as f: + params = json.load(f) + original_seed = params[str(bits)][1] + + for i in range(1, count + 1): + current_seed = increment_seed(seed, -i) + r = generate_r(current_seed, p) + b = get_b_from_r(r, p) + a = -3 + + # check if r gives rise to an elliptic curve + if b is None or 4 * a ** 3 + 27 * b ** 2 == 0: + continue + E = EllipticCurve(GF(p), [a, b]) + + # a heuristic for speeding up the generation process in exchange for sacrificing some curves with low cofactor + if bits < 224: + l_max = 3 + if bits < 192: + l_max = 2 + else: + l_max = 4 + if has_points_of_low_order(E, l_max): + continue + + secure, h, n = verify_security(E) + if not secure: + continue + + seed_diff = ZZ('0X' + original_seed) - ZZ('0X' + current_seed) + sim_curve = { + "name": "x963_sim_" + str(bits) + "_seed_diff_" + str(seed_diff), + "category": sim_curves["name"], + "desc": "", + "field": { + "type": "Prime", + "p": str(hex(p)), + "bits": bits, + }, + "form": "Weierstrass", + "params": { + "a": {"raw": str(hex(-3))}, + "b": {"raw": str(hex(b))} + }, + "generator": { + "x": { + "raw": "" + }, + "y": { + "raw": "" + } + }, + "order": n, + "cofactor": h, + "characteristics": None, + "seed": current_seed, + "seed_diff": seed_diff + } + sim_curves["curves"].append(sim_curve) + sim_curves["seeds_successful"] += 1 + + return sim_curves diff --git a/curve_analyzer/utils/pseudorandomness_checker.ipynb b/curve_analyzer/utils/pseudorandomness_checker.ipynb new file mode 100644 index 0000000..a8f1013 --- /dev/null +++ b/curve_analyzer/utils/pseudorandomness_checker.ipynb @@ -0,0 +1,141 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#secp112r1, https://www.secg.org/SEC2-Ver-1.0.pdf page 13\n", + "p = 0xDB7C2ABF62E35E668076BEAD208B\n", + "a = 0xDB7C2ABF62E35E668076BEAD2088\n", + "b = 0x659EF8BA043916EEDE8911702B22\n", + "seed = '00F50B028E4D696E676875615175290472783FB1'\n", + "r = generate_r(seed, p)\n", + "print(verify_r(p, r, a, b))\n", + "order = 0xDB7C2ABF62E35E7628DFAC6561C5\n", + "E1 = EllipticCurve(GF(p),[a,b])\n", + "print(E1.order() == order)\n", + "# print(p.binary())\n", + "# len('010100111100100100111100011011011111001010000011100000110110010110111000001111110111000001010110101101111001110')\n", + "# len('1101101101111100001010101011111101100010111000110101111001100110100000000111011010111110101011010010000010001011')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# secp112r2\n", + "p = 0xDB7C2ABF62E35E668076BEAD208B\n", + "a = 0x6127C24C05F38A0AAAF65C0EF02C\n", + "b = 0x51DEF1815DB5ED74FCC34C85D709\n", + "seed = '002757A1114D696E6768756151755316C05E0BD4'\n", + "r = generate_r(seed, p)\n", + "print(verify_r(p, r, a, b))\n", + "F = GF(p)\n", + "print(hex(r))\n", + "print(hex(F(a^3/b^2)))\n", + "E2 = EllipticCurve(F,[a,b])\n", + "print(E2.order() == 4 * 0x36DF0AAFD8B8D7597CA10520D04B)\n", + "print(p.binary())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#192-bit, page 113 in http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.202.2977&rep=rep1&type=pdf\n", + "p = 6277101735386680763835789423207666416083908700390324961279\n", + "seed = '3045AE6FC8422F64ED579528D38120EAE12196D5'\n", + "a = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC\n", + "b = 0x64210519E59C80E70FA7E9AB72243049FEB8DEECC146B9B1\n", + "r = generate_r(seed, p)\n", + "r_exp = expected_r(p, a, b)\n", + "F = GF(p)\n", + "print(verify_r(p, r, a, b))\n", + "print(b == get_b_from_r(r_exp, p))\n", + "# print(p.binary())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#239-bit, page 114 in http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.202.2977&rep=rep1&type=pdf\n", + "p = 883423532389192164791648750360308885314476597252960362792450860609699839\n", + "seed = 'E43BB460F0B80CC0C0B075798E948060F8321B7D'\n", + "a = 0x7FFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFF8000000000007FFFFFFFFFFC\n", + "b = 0x6B016C3BDCF18941D0D654921475CA71A9DB2FB27D1D37796185C2942C0A\n", + "r = generate_r(seed, p)\n", + "r_orig = 0x28B85EC1ECC19EFE769EB741A6D1BA29476AA5A8F2610957D6EFE78D3783\n", + "#checks out if we don't unset the top bit of c0\n", + "F = GF(p)\n", + "print(hex(r))\n", + "print(hex(F(a^3/b^2)))\n", + "print(verify_r(p,r,a,b))\n", + "print(verify_r(p,r_orig,a,b))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#secp256r1, page 22 in https://www.secg.org/SEC2-Ver-1.0.pdf (last bytes cannot be copied)\n", + "p = 0xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF\n", + "a = 0xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC\n", + "b = 0x5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B\n", + "seed = 'C49D360886E704936A6678E1139D26B7819F7E90'\n", + "# 'C49D360886E704936A6678E1139D26B7819F7E90'\n", + "r = generate_r(seed, p)\n", + "r_exp = expected_r(p, a, b)\n", + "print(verify_r(p,r,a,b))\n", + "F = GF(p)\n", + "# print(format(r, '0256b'))\n", + "# print(format(r_exp, '0256b'))\n", + "E = EllipticCurve(F, [a,b])\n", + "print(E.order() == 0xFFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551)\n", + "print(get_b_from_r(r, p))\n", + "print(b)\n", + "print(hex(F(-r)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# hashlib.sha1(bytes.fromhex('616263')).hexdigest()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "SageMath 9.0", + "language": "sage", + "name": "sagemath" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/curve_analyzer/utils/zvp/__init__.py b/curve_analyzer/utils/zvp/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/curve_analyzer/utils/zvp/gen_zvp.py b/curve_analyzer/utils/zvp/gen_zvp.py new file mode 100644 index 0000000..5c9b254 --- /dev/null +++ b/curve_analyzer/utils/zvp/gen_zvp.py @@ -0,0 +1,187 @@ +import operator + +from sage.all import ZZ, Integer, PolynomialRing, QuotientRing, EllipticCurve, GF, next_prime + +ops = { + "+": operator.add, + "-": operator.sub, + "*": operator.mul, + "**": operator.pow, + "^": operator.pow +} + + +def eval_binary_function(f, x, y): + return [fi(x, y) for fi in f] + + +class ZVPFinder: + R = PolynomialRing(ZZ, ('a', 'b', 'x1', 'x2', 'y1', 'y2'), order='invlex') + a, b, x1, x2, y1, y2 = R.gens() + Q = QuotientRing(R, R.ideal(y1 ** 2 - x1 ** 3 - a * x1 - b, y2 ** 2 - x2 ** 3 - a * x2 - b), + ('aa', 'bb', 'x_1', 'x_2', 'y_1', 'y_2')) + aa, bb, x_1, x_2, y_1, y_2 = Q.gens() + E = EllipticCurve(R, [a, b]) + + def __init__(self, formula_file, multiple, verbose=False): + self.formula_file = formula_file + self.multiple = multiple + self.register = {"X1": self.x1, "Y1": self.y1, "X2": self.x2, "Y2": self.y2, "Z1": 1, "Z2": 1, "a": self.a, + "b": self.b, } + self.zvp_set = set() + self.zvp_set = self.fill_register() + self.zvp_lifted = [x.lift() for x in self.zvp_set] + self.zvp_sorted = sorted(self.zvp_lifted, key=lambda x: len(str(x))) + self.mult = self.E.multiplication_by_m(multiple) + self.x2_subst, self.y2_subst = eval_binary_function(self.mult, self.x1, self.y1) + self.zvp_substited = [x(x2=self.x2_subst, y2=self.y2_subst) for x in self.zvp_sorted] + self.zvp_numerators = [self.Q(x.numerator()).lift() for x in self.zvp_substited] + self.zvp_reduced = set() + for numerator in self.zvp_numerators: + for f, m in numerator.factor(): + self.add_atomic(f, self.zvp_reduced) + self.zvp_reduced_lifted = [x.lift() for x in self.zvp_reduced] + self.zvp_reduced_sorted = sorted(self.zvp_reduced_lifted, key=lambda x: len(str(x))) + self.zvp_univariate = self.make_conditions_univariate() + if verbose: + self.print_zvp_conditions() + + def interpret_symbol(self, symbol): + if symbol.isdigit(): + return self.Q(symbol) + else: + return self.register[symbol] + + def eval_reg_binary(self, expression): + """Assumes a binary operation.""" + for op in ops.keys(): + symbols = expression.split(op) + if len(symbols) == 2: + symbol1, symbol2 = symbols + value1 = self.interpret_symbol(symbol1) + value2 = self.interpret_symbol(symbol2) + self.add_to_zvp(op, value1, value2) + if op in ['**', '^'] and not isinstance(value2, int): + value2 = int(value2.lift()) + return ops[op](value1, value2) + + def add_atomic(self, value, zvp_set): + try: + rad = value.lift().radical() + except (TypeError, AttributeError): + try: + rad = value.radical() + except AttributeError: + rad = Integer(value).radical() + if not isinstance(rad, Integer): + for f, m in rad.factor(): + if not isinstance(f, Integer) and not isinstance(f, int) and not self.Q(-f) in zvp_set: + if self.Q(f) == self.y_1: + zvp_set.add(self.Q(self.y1 ** 2)) + else: + zvp_set.add(self.Q(f)) + + def add_to_zvp(self, op, value1, value2): + if op == '*': + for value in [value1, value2]: + if not isinstance(value, int): + self.add_atomic(value, self.zvp_set) + elif op in ['**', '^']: + if not isinstance(value1, int): + self.add_atomic(value1, self.zvp_set) + else: + self.add_atomic(ops[op](value1, value2), self.zvp_set) + + def fill_register(self): + with open(self.formula_file) as f: + lines = f.readlines() + for line in lines: + formula = line.strip().replace(" ", "") + lhs, rhs = formula.split('=') + self.register[lhs] = self.eval_reg_binary(rhs) + return self.zvp_set + + def print_zvp_conditions(self): + print("ZVP conditions for general affine points on E: y^2 = x^3 + ax + b:") + for p in self.zvp_sorted: + print(p.polynomial(self.x1)) + + print("\nBy setting (x2,y2) =", self.multiple, "* (x1,y1), we get:") + print("x2 =", self.x2_subst) + print("y2 =", self.y2_subst, "\n") + + print("Thus the ZVP conditions become (after eliminating linear occurences of y1):") + for p in self.zvp_univariate: + print(p.polynomial(self.x1)) + + def __str__(self): + return '{self.zvp_reduced_sorted}'.format(self=self) + + def make_conditions_univariate(self): + """Eliminate y1 from the conditions and return univariate conditions instead (though they are still not + recognized as univariate until a,b values are substitued in). """ + zvp_univariate = [] + for p in self.zvp_reduced_sorted: + if self.y1 in p.variables(): + # since the polynomial is at most linear in y1, we can solve for y1 and use the curve equation + p_wrt_y = p.polynomial(self.y1) + roots_wrt_y = p_wrt_y.roots(p_wrt_y.base_ring().fraction_field()) + assert len(roots_wrt_y) == 1 + r, _ = roots_wrt_y[0] + # use the curve equation as a rational function and substitute for y1 + curve_function = (self.y1 ** 2 - self.x1 ** 3 - self.a * self.x1 - self.b) / 1 + p_univariate = self.R(curve_function(y1=r).numerator()) + else: + p_univariate = p + zvp_univariate.append(p_univariate) + return zvp_univariate + + def evaluate_univariate_conditions(self, a, b, q): + """Evaluates the univariate conditions at a,b and returns a list of those that remain nonconstant or are zero + (as polynomials over GF(q)). """ + zvp_evaluated_nonconst = [] + for p in self.zvp_univariate: + p_eval = p(a=a, b=b).univariate_polynomial() + if not p_eval.is_constant(): + zvp_evaluated_nonconst.append(p_eval) + elif GF(q)(p_eval) == 0 : + zvp_evaluated_nonconst.append(GF(q)(p_eval)) + return sorted(zvp_evaluated_nonconst) + + def find_points(self, a, b, q, verbose=False): + """Solves ZVP conditions and finds corresponding curve points. Only works properly for nonzero univariate + conditions (i.e., y1 should not be present if x1 is). """ + if verbose: + print("\nFinding ZVPs over finite field with", q, "elements for a =", a, "and b =", b, ":") + E = EllipticCurve(GF(q), [a, b]) + zero_value_points = [] + zvp_evaluated_nonconst = self.evaluate_univariate_conditions(a, b, q) + for p in zvp_evaluated_nonconst: + if p == 0: + zero_value_points.append("Any point, since a,b already satisfy a ZVP condition") + else: + roots_with_multiplicity = p.roots(GF(q)) + if verbose: + print("Polynomial:", p, "\nRoots:", roots_with_multiplicity) + for root, m in roots_with_multiplicity: + if E.is_x_coord(root) and E.lift_x(root) not in zero_value_points: + zero_value_points.append(E.lift_x(root)) + if verbose: + print("Corresponding curve point:", E.lift_x(root)) + return zero_value_points + + +def main(): + from curve_analyzer.definitions import EFD_PATH + from pathlib import Path + formula_file = Path(EFD_PATH, 'shortw', 'projective', 'addition', 'add-2016-rcb.op3') + ZVP = ZVPFinder(formula_file, multiple=2, verbose=True) + q = next_prime(2 ** 256) + a = 1 + b = 2 + points = ZVP.find_points(a, b, q, verbose=True) + print(points) + + +if __name__ == '__main__': + main() diff --git a/curve_analyzer/visual/trait_results_multi_comparison.ipynb b/curve_analyzer/visual/trait_results_multi_comparison.ipynb new file mode 100644 index 0000000..acf1e42 --- /dev/null +++ b/curve_analyzer/visual/trait_results_multi_comparison.ipynb @@ -0,0 +1,2001 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Curve test analysis\n", + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "import ast\n", + "import json\n", + "import multiprocessing\n", + "from copy import deepcopy\n", + "from time import sleep\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "from pathlib import Path\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from IPython.display import display, Markdown, Latex" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "data_folder = Path('../data') # this comes handy for migrations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Processing functions\n", + "### Loading" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def parse_results_file(file_path):\n", + " df_data, df_index = [], []\n", + "\n", + " with open(file_path, 'r') as rf:\n", + " data = json.load(rf)\n", + " for curve_name, curve_data in data.items():\n", + " for params, results in curve_data.items():\n", + " dictionary = deepcopy(results)\n", + " dictionary.update(ast.literal_eval(params))\n", + " df_data.append(dictionary)\n", + " df_index.append(curve_name)\n", + " return df_index, df_data\n", + "\n", + "def plain_numerical2df(df_index, df_data, drop_cols=()):\n", + " columns = set(df_data[0].keys()).difference(drop_cols)\n", + " df_ = pd.DataFrame(df_data, index=df_index, columns=columns).fillna(0).astype(int)\n", + " df_['name'] = df_.index\n", + " df_['sim'] = df_.name.str.contains('sim').astype(int)\n", + " return df_" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Statistical understanding" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.stats import ks_2samp\n", + "\n", + "def plot_df(df_, drop_cols=()): # args cannot be mutable -- [] would cause problems\n", + " \"\"\"Logy histogram and relative density \n", + " => different sizes of sim groups can be shown together\n", + " \"\"\"\n", + " cols = df_.columns.drop(['name', 'sim',] + list(drop_cols))\n", + " for col in cols:\n", + " ax = df_.groupby('sim')[col].plot.hist(bins=100, logx=False, logy=False, figsize=(14, 6), \n", + " density=False, alpha=0.42, legend=True, xlim=(0, df[col].max()),)\n", + " ax2 = df_.groupby('sim')[col].plot.density(figsize=(14, 6), alpha=1.0, legend=False, logy=False,\n", + " logx=False, xlim=(1, df[col].max()), ax=ax[0].twinx())\n", + " plt.title(col, fontsize='xx-large')\n", + " ax[0].legend(title='sim')\n", + " plt.show()\n", + " \n", + " from scipy.stats import ks_2samp\n", + "\n", + "def kl_divergence(orig_p, orig_q, epsilon=1e-5):\n", + " p, q = get_bins(orig_p), get_bins(orig_q)\n", + " return np.sum(np.where(p != 0, p * np.log(p / (q + epsilon)), 0))\n", + "\n", + "def get_bins(ser):\n", + " hist = np.histogram(ser,\n", + " density=True,\n", + " bins=50,\n", + " range=(0, 5),\n", + " )\n", + " return hist[0]\n", + "\n", + "def per_group(drop_cols=()):\n", + " def per_group_inner(df_):\n", + " res_ = {}\n", + " for on_col in df_.columns.drop(['name', 'sim',] + list(drop_cols)):\n", + " res_[(on_col, 'ks_stat', )] = ks_2samp(df_.loc[df_.sim == 0, on_col],\n", + " df_.loc[df_.sim == 1, on_col])[0] # we need only the first value\n", + " res_[(on_col, 'kl_stat', )] = kl_divergence(df_.loc[df_.sim == 0, on_col],\n", + " df_.loc[df_.sim == 1, on_col])\n", + " columns=pd.MultiIndex.from_tuples(res_.keys(), names=['col', 'stat'])\n", + " return pd.Series(res_, index=columns)\n", + " return per_group_inner" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Machine learning understanding\n", + "...it's so simple to code, you have to give it a try!\n", + "I would test it again, once there are many test results per curve => the random forest / KMeans could find something interesting (== they would produce reasonable results => we can investigate those results)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt # doctest: +SKIP\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.metrics import plot_confusion_matrix\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.linear_model import SGDClassifier\n", + "from sklearn.svm import SVC\n", + "from sklearn import svm\n", + "import sklearn\n", + "from sklearn import ensemble\n", + "\n", + "def eval_classifier(classifier, X, y, ax):\n", + " X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)\n", + " classifier.fit(X_train, y_train)\n", + " plot_confusion_matrix(classifier, X_test, y_test, ax=ax) # doctest: +SKIP\n", + " \n", + "def eval_classifiers(df_, drop_cols=()):\n", + " \"\"\"Check performance of different classifiers on test set (last 20 %)\"\"\"\n", + " df_ = df.sample(frac=1, random_state=0) # should we \n", + " X = df_.drop(columns=['sim', 'name', ] + list(drop_cols))\n", + " y = df_.sim\n", + " \n", + " classifiers = [ # The hyperparams could be tuned/autotuned\n", + " SVC(random_state=0, degree=3),\n", + " SGDClassifier(loss=\"hinge\", penalty=\"l2\", max_iter=100),\n", + " sklearn.neighbors.KNeighborsClassifier(n_neighbors=2),\n", + " ensemble.RandomForestClassifier(10),\n", + " ]\n", + " \n", + " fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(15, 10)) # nrows * ncols = len(classifiers)\n", + "\n", + " for cls, ax in zip(classifiers, axes.flatten()):\n", + " eval_classifier(cls, X, y, ax=ax)\n", + " ax.title.set_text(type(cls).__name__)\n", + " ax.title.set_fontsize('xx-large')\n", + " \n", + " plt.tight_layout() \n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A05\n", + "> It would be great to have a real description here" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load data" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[PosixPath('../data/a05.json'), PosixPath('../data/a05_filtered.json'), PosixPath('../data/a25.json')]\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
relativefulllleastnamesim
prime192v21323prime192v20
prime192v21838prime192v20
prime192v252054prime192v20
prime192v23672prime192v20
prime192v31323prime192v30
.....................
P-224124724P-2240
prime239v11323prime239v10
prime239v11838prime239v10
prime239v1112512prime239v10
prime239v1116716prime239v10
\n", + "

216796 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " relative full l least name sim\n", + "prime192v2 1 3 2 3 prime192v2 0\n", + "prime192v2 1 8 3 8 prime192v2 0\n", + "prime192v2 5 20 5 4 prime192v2 0\n", + "prime192v2 3 6 7 2 prime192v2 0\n", + "prime192v3 1 3 2 3 prime192v3 0\n", + "... ... ... .. ... ... ...\n", + "P-224 1 24 7 24 P-224 0\n", + "prime239v1 1 3 2 3 prime239v1 0\n", + "prime239v1 1 8 3 8 prime239v1 0\n", + "prime239v1 1 12 5 12 prime239v1 0\n", + "prime239v1 1 16 7 16 prime239v1 0\n", + "\n", + "[216796 rows x 6 columns]" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(list(data_folder.glob('*.json'))) # list all files -> could be used to auto parse all files\n", + "\n", + "drop_cols = ('l', ) # comma needed for tuples\n", + "df = plain_numerical2df(*parse_results_file(data_folder / 'a05_filtered.json')) # *does tuple unpacking\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Numerical comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
relativefulllleastsim
count216796.000000216796.000000216796.000000216796.000000216796.000000
mean1.6752208.7411624.2500006.9607190.999815
std1.3337559.1054701.9202918.7701930.013582
min1.0000002.0000002.0000002.0000000.000000
25%1.0000003.0000002.7500003.0000001.000000
50%1.0000006.0000004.0000003.0000001.000000
75%2.0000008.0000005.5000008.0000001.000000
max7.00000048.0000007.00000048.0000001.000000
\n", + "
" + ], + "text/plain": [ + " relative full l least \\\n", + "count 216796.000000 216796.000000 216796.000000 216796.000000 \n", + "mean 1.675220 8.741162 4.250000 6.960719 \n", + "std 1.333755 9.105470 1.920291 8.770193 \n", + "min 1.000000 2.000000 2.000000 2.000000 \n", + "25% 1.000000 3.000000 2.750000 3.000000 \n", + "50% 1.000000 6.000000 4.000000 3.000000 \n", + "75% 2.000000 8.000000 5.500000 8.000000 \n", + "max 7.000000 48.000000 7.000000 48.000000 \n", + "\n", + " sim \n", + "count 216796.000000 \n", + "mean 0.999815 \n", + "std 0.013582 \n", + "min 0.000000 \n", + "25% 1.000000 \n", + "50% 1.000000 \n", + "75% 1.000000 \n", + "max 1.000000 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sim01
relativecount40.000000216756.000000
mean1.9500001.675169
std1.6322081.333693
min1.0000001.000000
25%1.0000001.000000
50%1.0000001.000000
75%3.0000002.000000
max5.0000007.000000
fullcount40.000000216756.000000
mean12.8000008.740413
std12.0303049.104713
min2.0000002.000000
25%3.0000003.000000
50%8.0000006.000000
75%17.0000008.000000
max48.00000048.000000
lcount40.000000216756.000000
mean4.2500004.250000
std1.9447501.920291
min2.0000002.000000
25%2.7500002.750000
50%4.0000004.000000
75%5.5000005.500000
max7.0000007.000000
leastcount40.000000216756.000000
mean9.7000006.960213
std12.2394918.769387
min2.0000002.000000
25%3.0000003.000000
50%4.0000003.000000
75%9.0000008.000000
max48.00000048.000000
\n", + "
" + ], + "text/plain": [ + "sim 0 1\n", + "relative count 40.000000 216756.000000\n", + " mean 1.950000 1.675169\n", + " std 1.632208 1.333693\n", + " min 1.000000 1.000000\n", + " 25% 1.000000 1.000000\n", + " 50% 1.000000 1.000000\n", + " 75% 3.000000 2.000000\n", + " max 5.000000 7.000000\n", + "full count 40.000000 216756.000000\n", + " mean 12.800000 8.740413\n", + " std 12.030304 9.104713\n", + " min 2.000000 2.000000\n", + " 25% 3.000000 3.000000\n", + " 50% 8.000000 6.000000\n", + " 75% 17.000000 8.000000\n", + " max 48.000000 48.000000\n", + "l count 40.000000 216756.000000\n", + " mean 4.250000 4.250000\n", + " std 1.944750 1.920291\n", + " min 2.000000 2.000000\n", + " 25% 2.750000 2.750000\n", + " 50% 4.000000 4.000000\n", + " 75% 5.500000 5.500000\n", + " max 7.000000 7.000000\n", + "least count 40.000000 216756.000000\n", + " mean 9.700000 6.960213\n", + " std 12.239491 8.769387\n", + " min 2.000000 2.000000\n", + " 25% 3.000000 3.000000\n", + " 50% 4.000000 3.000000\n", + " 75% 9.000000 8.000000\n", + " max 48.000000 48.000000" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "display(df.describe())\n", + "display(df.groupby('sim').describe().T)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visual comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3sAAAF5CAYAAAAmmjPBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi41LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvSM8oowAAIABJREFUeJzs3XmYXVWZqPH3S1VGMgOBJBVSmUgIYUxAZIYwCTY4YritoKI0NvRkYyPdXsTupltvt23LVUEQG1CvgLRKWiYZAiIEQkAhTCEjpAIhE2NChkrW/WOfA4dKJXWqUqf2qar39zzn2eesvdfe34mJ1FdrrW9FSglJkiRJUtfSI+8AJEmSJEntz2RPkiRJkrogkz1JkiRJ6oJM9iRJkiSpCzLZkyRJkqQuyGRPkiRJkrogkz1JUqcTEZ+NiBQR9XnHIklStTLZkySpjSLi4Ii4zKRTklSNTPYkSWq7g4GvA/U5xyFJ0jZM9iRJkiSpCzLZkyR1CRExJiJuiIhXI2JjRMyPiK9ERI8m1305Ih6IiJWF6xZGxDciomeT63aJiG9FxKKI2BARqyLi4Yg4s3D+MuCawuWzCmsIU0R8tiO+ryRJLanNOwBJknZWRIwHZgNvA/8XWAUcC/wfsimWF5Rc/hXgLmAmsB44EvgasBfwuZLrfgCcBVwJzAMGAgcAHwRuBn4J1AHnAv8CPFfo93D7fjtJktomUkp5xyBJUqsURs/+CxiTUloaEbcDk4ADU0pvllz3H8BfAxNTSgsKbbuklNY1ud/XgUuBvVJKywttrwH/L6VUmig2jeMLZKN7x6WU7m/HryhJ0k5zGqckqVOLiMHAKcB/A70iYrfii2wEL4Dji9cXE72IqImIwYXrZpH9N/Hgklu/AXwgIkZ10FeRJKldmexJkjq7vckSuovIpm+Wvu4sXDOseHFEnBIRDwPvAK8VrnugcHpIyX2/AkwGXoyIJyLi3yJiWiW/iCRJ7ck1e5Kkzq74i8uryEb3mrMYICIOA24DHgX+AmgANgIjgetK7kVK6RcR8QDwJ8AJwOeBv42Iy1JK/9j+X0OSpPZlsidJ6uwWAQlIKaV7Wrj2U8AmYHpK6Z1iY0Sc3NzFKaWVwLXAtRHRD7gduDQi/q3Q34XvkqSq5TROSVKnllJaBdwLnFOoyvk+ETEwInoXPm4hS9BqSs7XkE3ZLO1TExGDmjxnPfB8oW/x3NuFY+n0T0mSqoIje5KkruBLwEPAHyLiR2TbIAwCpgAfLxyXArcCXwbui4jrgb5ko31Nf/k5AFgeEb8CngTWAgcBXwDuSymtKFw3lyx5vKRQKOYd4NGU0pIKfU9JkspmsidJ6vRSSgsj4mCy/fI+DuxJVnzlBeAbwIrCdQ9GxFnAPwD/TpbE/YJs+4SnS265Hvge2Vq904DewDLgX8n27is+d1FEXEBWHOYaslG/zwEme5Kk3LnPniRJkiR1Qa7ZkyRJkqQuyGRPkiRJkrogkz1JkiRJ6oJM9iRJkiSpCzLZkyRJkqQuqNttvdCjR4/Ut2/fvMOQJEmSVKXWr1+fUkqdfmCs2yV7ffv2Zd26dXmHIUmSJKlKRcQ7ecfQHjp9tipJkiRJ2pbJniRJkiR1QSZ7kiRJktQFdbs1e5IkSZIqb/PmzTQ0NLBhw4a8Q9muPn36UFdXR8+ePfMOpSJM9iRJkiS1u4aGBgYMGEB9fT0RkXc420gpsWbNGhoaGhgzZkze4VSE0zglSZIktbsNGzaw6667VmWiBxAR7LrrrlU98rizTPYkSZIkVUS1JnpF1R7fzjLZkyRJklS1vvCFL/Dss8/mHUan5Jo9SZIkSVXrRz/6Ud4hdFqO7EmSJEmqCuvWreO0007jgAMOYMqUKdx0000ce+yxzJ07F4D+/ftz8cUXM3XqVE444QTmzJnDsccey9ixY5k5c2bO0Vcfkz1JkiRJVeHOO+9kxIgRPPnkkzz99NOccsop7zu/bt06jj32WB5//HEGDBjA1772Ne6++25+9atfcemll+YUdfUy2esojZtg5fPw0qOwdUve0UiSJElVZ7/99uOee+7h4osv5sEHH2TQoEHvO9+rV693E8D99tuPY445hp49e7LffvuxdOnSHCKubq7Z6wiL7oNffQneXpF9HjQKpl8K+5+Zb1ySJElSFdl77715/PHHuf3227nkkks46aST3ne+Z8+e71bQ7NGjB7179373fWNjY4fHW+1M9irtiRtg5l/A7pPgxH+ExffD0gfhl1+E52+D+iPff/2hX8wlTEmSJClvL7/8MkOHDuXTn/40/fv357rrrss7pE7NZK+Slj8Ot/0tjDsePvUz6NUPNr4Je+4Pf/wpPPtr6DsY9piSd6SSJElS7ubNm8dXvvIVevToQc+ePbnyyiu56KKL8g6r04qUUt4xdKhddtklrVu3rvIP2vwOfP9QSMCfPQD9hmbtc67Jjlsb4eErYMNbcPRF0GuXrN2RPUmSJHUBzz33HPvss0/eYbSouTgjYn1KaZecQmo3FmiplDlXw+svwUe+/16iV6pHLew/Azavh+csEytJkiSpfZnsVcI7r8GD34bxJ8KYo7d/3cARMOYoWP4EvLWi4+KTJEmS1OWZ7FXCI1fBhjfhhK+3fO3Y46CmJyy8p/JxSZIkSeo2TPba25bN8Ph/wYSTYM/9Wr6+1y4w+kh45Ul4+9XKxydJkiSpWzDZa2/P/yZL2g75Qvl9xhwNPXrAi7MrF5ckSZKkbsVkr709di0MHg3jp5ffp3f/bDuG5XNhUwdUCpUkSZLU5ZnstafXlmYbpk/9LPSoaV3fvQ6Hxg3w9H9XIjJJkiSpW7rzzjuZOHEi48eP55vf/Gbe4XQoN1VvT8/8Kjvu94nW9x1SD/33gMevg4PPbs+oJEmSpNzdMHtpu97v7A/Wt3jNli1buOCCC7j77rupq6vjkEMO4fTTT2fy5MntGku1cmSvPT39Sxg5DQbv1fq+EVnf5Y/D2sXtH5skSZLUzcyZM4fx48czduxYevXqxYwZM7j11lvzDqvDmOy1lzWLYMVTMOVjbb/HiAOzo1M5JUmSpJ22fPlyRo0a9e7nuro6li9fnmNEHatiyV5E/DgiVkbE082cuygiUkTsVtJ2SUQsjIj5EXFySfvUiJhXOHdFREShvXdE3FRofzQi6iv1XcpSnMI5+Yy236PvEBh1WDZCKEmSJGmnpJS2aSukE91CJUf2rgNOadoYEaOAE4GXStomAzOAfQt9fhARxQonVwLnARMKr+I9zwVeSymNB74DfKsi36JcL9wFIw6CQXU7d58pH4eVz8Krz7ZPXJIkSVI3VVdXx7Jly9793NDQwIgRI3KMqGNVLNlLKf0OWNvMqe8AfweUptlnADemlDamlJYAC4FDI2I4MDClNDtlafkNwEdK+lxfeH8LMD3yStPXrYGGx2DCyS1f25LJZwCR7dcnSZIkqc0OOeQQFixYwJIlS9i0aRM33ngjp59+et5hdZgOXbMXEacDy1NKTzY5NRJYVvK5odA2svC+afv7+qSUGoE3gF2389zzImJuRMxtbGzc6e+xjUX3AQkmnLjz9xqwB9RNg/m37/y9JEmSpG6straW733ve5x88snss88+nHnmmey77755h9VhOmzrhYjoB/wDcFJzp5tpSzto31GfbRtTuhq4GmCXXXZp9pqdsvBu6LdrNo2zPUz8ENz7j/DmyzCw+wwzS5IkqesqZ6uESjj11FM59dRTc3l23jpyZG8cMAZ4MiKWAnXAExGxJ9mI3aiSa+uAlwvtdc20U9onImqBQTQ/bbSytm6FhffA+BNav5H69kws/GV84c72uZ8kSZKkbqfDkr2U0ryU0rCUUn1KqZ4sWTs4pbQCmAnMKFTYHENWiGVOSukV4K2IOKywHu9soLgxxkzgnML7TwD3pebK7VTaq/Ng/RoYN7397rn7pGyT9fl3tN89JUmSJHUrldx64efAbGBiRDRExLnbuzal9AxwM/AscCdwQUppS+H0l4AfkRVtWQQUM6BrgV0jYiHwZeCrFfkiLVnyYHYcc1T73TMC9j4FlvwONm9ov/tKkiRJ6jYqtmYvpXRWC+frm3y+HLi8mevmAlOaad8AfHLnomwHS38PQ8e1/9q6cdPh0avgpdkw7rj2vbckSZKkLq9Dq3F2OVu3wIsPQ/2R7X/v+iOgphcsurf97y1JkiSpyzPZ2xkrnoKNb0B9O07hLOq1C+x1GCya1f73liRJkrRTIuKUiJgfEQsjYpslZRExKSJmR8TGiLioNX3bi8nezlj6++xYiZE9gHHHw6tPw1srKnN/SZIkqQv7/Oc/z7Bhw5gyZZtVYTslImqA7wMfAiYDZ0XE5CaXrQX+Evj3NvRtFx22z16X9OLDMHQsDBxemfuPmw73XAaL74cDZlTmGZIkSVJHmHNN+97v0C+2eMlnP/tZLrzwQs4+++z2fTYcCixMKS0GiIgbgTPICk4CkFJaCayMiNNa27e9OLLXVinBskdh1GGVe8YeU6DvEFj6YOWeIUmSJHVRRx99NEOHDq3ErUcCy0o+NxTaKt23VRzZa6u1i7P99UYdWrln9OgBex2ejSBKkiRJ6ii1ETG35PPVKaWrSz5HM33K3fN7Z/q2isleWy2bkx1HfaCyzxl9OMy/Dd58pXLTRSVJkiSVakwpTdvB+QZgVMnnOuDlMu+9M31bxWmcbbXsUeg9EHafVNnn1B+RHV98qLLPkSRJklSux4AJETEmInoBM4CZHdC3VUz22mrZHKg7JJtqWUl77p8llcXKn5IkSZJylVJqBC4E7gKeA25OKT0TEedHxPkAEbFnRDQAXwa+FhENETFwe30rEafTONtiwxuw8lmYfHrln9WjJttvz5E9SZIkqVXOOuss7r//flavXk1dXR3f+MY3OPfcc9vl3iml24Hbm7RdVfJ+BdkUzbL6VoLJXlu8/EcgQd2OpvG2o9FHwILfwtsrof+wjnmmJEmS1J7K2Cqhvf385z/v8GdWE6dxtsXLT2THEQd3zPOKm7Y7uidJkiSpTCZ7bbH8CRhSD/0qsmfHtoYfAD13gaUme5IkSZLKY7LXFi//EUYc1HHPq+mZ7efnfnuSJEmSymSy11rrVsMbL3XcFM6i+iNg5TOwfm3HPleSJElqo5Qqsld4u6n2+HaWyV5rvfyH7Diyg5O90cV1e47uSZIkqfr16dOHNWvWVG1ClVJizZo19OnTJ+9QKsZqnK21/AkgsnV0HWnkwVDTG16aDft8uGOfLUmSJLVSXV0dDQ0NrFq1Ku9QtqtPnz7U1TW7O0KXYLLXWq/8EXabAL0HdOxza3tnCWbDYx37XEmSJKkNevbsyZgxY/IOo1tzGmdrrZgHe+6fz7NHHZoVh2nclM/zJUmSJHUaJnut8c5r8MYy2HNKPs+vOwS2bIQVT+XzfEmSJEmdhslea6x4OjvusV8+zx91aHZcNief50uSJEnqNEz2WuPVQrK3Z07J3sARMLAOGkz2JEmSJO2YyV5rrHgadtkdBuyRXwyjDoGGufk9X5IkSVKnYLLXGiuegj1yWq9XVHdotm7wzVfyjUOSJElSVTPZK9eWzbDq+fyKsxTVHZIdncopSZIkaQdM9sq1egFs2ZTftgtFw/eHml4WaZEkSZK0QyZ75VoxLzvmPY2ztjcMP9DN1SVJkiTtkMleuV6dl42o7TYh70jcXF2SJElSi0z2yrXiaRi2D9T0zDsSN1eXJEmS1KLavAPoFFLKpnHufUrekWRKN1evm5ZvLFI1mHPNjs8f+sWOiUOSJKmKOLJXjrdfhfWr86/EWTRwBAwcCcvdb0+SJElS80z2yrHi6eyYd3GWUiOnurm6JEmSpO0y2StHcW1ctYzsQTZ98/UXYd3qvCORJEmSVIUqluxFxI8jYmVEPF3S9m8R8XxEPBURv4qIwSXnLomIhRExPyJOLmmfGhHzCueuiIgotPeOiJsK7Y9GRH2lvguvPg2DRkHfIRV7RKuNnJodHd2TJEmS1IxKjuxdBzStaHI3MCWltD/wAnAJQERMBmYA+xb6/CAiagp9rgTOAyYUXsV7ngu8llIaD3wH+FbFvsnK52DY5Irdvk2GHwjRw3V7kiRJkppVsWQvpfQ7YG2Ttt+mlBoLHx8B6grvzwBuTCltTCktARYCh0bEcGBgSml2SikBNwAfKelzfeH9LcD04qhfu9qyGVYvgGGT2v3WO6V3/ywBXf543pFIkiRJqkJ5rtn7PHBH4f1IYFnJuYZC28jC+6bt7+tTSCDfAHZt7kERcV5EzI2IuY2Njc1dsn1rF8PWzbD7Pq3r1xFGTs2Sva1b845EkiRJUpXJJdmLiH8AGoGfFZuauSztoH1HfbZtTOnqlNK0lNK02tpWbi246vnsWG0je5AVadnwBqxdlHckkiRJkqpMhyd7EXEO8GHgTwtTMyEbsRtVclkd8HKhva6Z9vf1iYhaYBBNpo22i5WFZG+3vdv91jttZGFDdYu0SJIkSWqiQ5O9iDgFuBg4PaW0vuTUTGBGocLmGLJCLHNSSq8Ab0XEYYX1eGcDt5b0Oafw/hPAfSXJY/tZ9TwMHg29dmn3W++03SdCr/4WaZEkSZK0jVbOaSxfRPwcOBbYLSIagK+TVd/sDdxdqKXySErp/JTSMxFxM/As2fTOC1JKWwq3+hJZZc++ZGv8iuv8rgV+EhELyUb0ZlTki6x6HoZV4Xo9gB41MOIgR/YkSZIkbaNiyV5K6axmmq/dwfWXA5c30z4X2GY385TSBuCTOxNji4qVOCecWNHH7JSRU2H292DzBujZJ+9oJEmSJFWJPKtxVr+1S6q3EmdR3TTY2ggrnso7EkmSJElVxGRvR1Y9lx2rsRJnkUVaJEmSJDXDZG9HVs3PjtVYibNo4HAYONIiLZIkSZLex2RvR1Y+V72VOEuNnOrIniRJkqT3MdnbkVXPw+5VPIWzqG4avP4irFuddySSJEmSqoTJ3vZsacwqcVbzer2ikVOz4/LH841DkiRJUtUw2duetYurvxJn0fADIXo4lVOSJEnSu0z2tmfV89lx94n5xlGO3v1h2GSLtEiSJEl6l8ne9nSmZA+yqZzLH4etW/OORJIkSVIVMNnbns5SibOobhpseAPWLso7EkmSJElVwGRve1a/0HlG9cDN1SVJkiS9j8lec7ZuhTULq3sz9aZ2nwi9+luRU5IkSRJgste8N5ZB4wbYdXzekZSvRw2MOMgiLZIkSZIAk73mrVmQHXebkG8crTVyKqx4GjZvyDsSSZIkqUuLiFMiYn5ELIyIrzZzPiLiisL5pyLi4JJzfxMRz0TE0xHx84joU4kYTfaas6ZQ5GTXTpbs1U3L9gZc8VTekUiSJEldVkTUAN8HPgRMBs6KiMlNLvsQMKHwOg+4stB3JPCXwLSU0hSgBphRiThN9pqzegH0Hgj9h+UdSetYpEWSJEnqCIcCC1NKi1NKm4AbgTOaXHMGcEPKPAIMjojhhXO1QN+IqAX6AS9XIkiTveasWZCt14vIO5LWGTgcBo503Z4kSZJUWSOBZSWfGwptLV6TUloO/DvwEvAK8EZK6beVCNJkrzmrF3a+9XpFxc3VJUmSJLVVbUTMLXmd1+R8c6NCqZxrImII2ajfGGAEsEtEfHrnQ95WbSVu2qltWgdvNnS+9XpFI6fCczNh3WrYZbe8o5EkSZI6o8aU0rQdnG8ARpV8rmPbqZjbu+YEYElKaRVARPwSOBz46c4G3ZQje00Vi7Ps1om2XShVV/g76eieJEmSVCmPARMiYkxE9CIrsDKzyTUzgbMLVTkPI5uu+QrZ9M3DIqJfRAQwHXiuEkGa7DVV3Hahs47sDT8QoodFWiRJkqQKSSk1AhcCd5ElajenlJ6JiPMj4vzCZbcDi4GFwDXAnxf6PgrcAjwBzCPLya6uRJxO42xq9UIgYNdxeUfSNr37w7DJFmmRJEmSKiildDtZQlfadlXJ+wRcsJ2+Xwe+XtEAcWRvW2sWwKBR0LNv3pG0XbFIS2q6RlSSJElSd2Gy19TqBZ13vV5R3TTY8MZ76w8lSZIkdTsme6VSgjULO+96vaLi5upO5ZQkSZK6LZO9Um+tgE1vd9499op2nwi9+lukRZIkSerGTPZKvVuJs5NP4+xRAyMOcmRPkiRJ6sZM9kqtLiR7nX1kD7IiLSuehs0b8o5EkiRJUg5M9kqtWQg9+8GAEXlHsvPqpsHWzbBiXt6RSJIkScqByV6p1Quy/fV6dIE/Fou0SJIkSd1aF8hq2tGaBZ2/EmfRwOEwcKRFWiRJkqRuymSvqHEjvP5S11ivVzRyqiN7kiRJUjdlsle0djGkrV1nZA+yZO+1pbBudd6RSJIkSepgFUv2IuLHEbEyIp4uaRsaEXdHxILCcUjJuUsiYmFEzI+Ik0vap0bEvMK5KyIiCu29I+KmQvujEVG/UwG/W4mzk2+7UKquuG7v8XzjkCRJktThKjmydx1wSpO2rwL3ppQmAPcWPhMRk4EZwL6FPj+IiJpCnyuB84AJhVfxnucCr6WUxgPfAb61U9F2lT32Sg0/EKKHyZ4kSZLUDVUs2Usp/Q5Y26T5DOD6wvvrgY+UtN+YUtqYUloCLAQOjYjhwMCU0uyUUgJuaNKneK9bgOnFUb82Wb0QBgyH3gPafIuq07s/DJtskRZJkiSpG+roNXt7pJReASgchxXaRwLLSq5rKLSNLLxv2v6+PimlRuANYNfmHhoR50XE3IiY29jY2HxkaxZ0rVG9opFTs5G9lPKORJIkSVIHqpYCLc2NyKUdtO+oz7aNKV2dUpqWUppWW1vb3AXZmr2uVImzqG4abHgd1izKOxJJkiRJHaijk71XC1MzKRxXFtobgFEl19UBLxfa65ppf1+fiKgFBrHttNHyrF+TJURdqRJnkZurS5IkSd1SRyd7M4FzCu/PAW4taZ9RqLA5hqwQy5zCVM+3IuKwwnq8s5v0Kd7rE8B9hXV9rfduJc4umOztPhF69XfdniRJktTNNDOnsX1ExM+BY4HdIqIB+DrwTeDmiDgXeAn4JEBK6ZmIuBl4FmgELkgpbSnc6ktklT37AncUXgDXAj+JiIVkI3oz2hxsV6zEWdSjBkYcZEVOSZIkqZupWLKXUjprO6emb+f6y4HLm2mfC0xppn0DhWRxp61eADW9YfBe7XK7qjNyKsz+PmzeAD375B2NJEmSpA5QLQVa8rVmIQwdm42CdUV102DrZlgxL+9IJEmSJHUQkz0oVOLsglM4iyzSIkmSJHU7JntbNsNrS7rmer2igcNh4EiLtEiSJEndiMneay/C1sauue1CqbpDYNmjeUchSZIkqYOY7K3pwtsulBp9BLyxDF5/Ke9IJEmSJHUAk701C7NjV57GCTD68Oz44sP5xiFJkiSpQ5jsrV4A/XaFfkPzjqSyhk2GPoNh6e/zjkSSJElSBzDZW7Ow66/XA+jRIxvdc2RPkiRJ6hZM9rr6tgulRh8OaxfBWyvyjkSSJElShXXvZG/DG7BuZfcY2QPX7UmSJEndSPdO9lYXirN09UqcRXseAL36w4sP5R2JJEmSpArr3slecduF7jKyV1MLoz7gyJ4kSZLUDXTvZG/1AogaGFKfdyQdZ/ThsPJZWL8270gkSZIkVVD3TvbWLMgSvdpeeUfScUYfkR0d3ZMkSZK6tO6d7K1e2H3W6xWNPBhq+5jsSZIkSV1c9032tm7NtiHYtZtsu1BU2xvqDoGlD+YdiSRJkqQK6r7J3hvLoHFD9xvZAxhzNKyYB+vW5B2JJEmSpArpvsled6vEWWrscUCCJffnHYkkSZKkCikr2YuIKZUOpMN1tz32So04CHoPgkWz8o5EkiRJUoWUO7J3VUTMiYg/j4jBFY2oo6xZkCU8u+yedyQdr6YWxhwFi++HlPKORpIkSVIFlJXspZSOBP4UGAXMjYj/FxEnVjSySlu9AHYbDxF5R5KPccdn6xbXLMo7EkmSJEkVUPaavZTSAuBrwMXAMcAVEfF8RHysUsFV1JqF3XO9XtG447LjYqdySpIkSV1RuWv29o+I7wDPAccDf5JS2qfw/jsVjK8yNq2DN5dnI3vd1dCxMHi06/YkSZKkLqrckb3vAU8AB6SULkgpPQGQUnqZbLSvc1lTKM7SnUf2IBvdW/ogbNmcdyRS+0hbYfMG16JKkiQBtWVedyrwTkppC0BE9AD6pJTWp5R+UrHoKmV1YduF7liJs9TY4+Dx62D547DXYXlHI7Xd6gWw6L7CL3IS9NsN6g6BscdAj3L/b06SJKlrKXdk7x6gb8nnfoW2zmnNQiCyqYzd2ZijgXAqpzqvlGDWv8KcH8Lbr8LYY2HiqdB3MLxwB8z+Przzet5RSpKkLigiTomI+RGxMCK+2sz5iIgrCuefioiDS84NjohbCjVQnouID7bwrP+OiNMKg25lK/fiPimlt4sfCu/7teZBVWX1Ahg8Cnr2bfnarqzf0GzPPYu0qLO68xJ44Jswchoc+/cw6bSs0uwHzoeDPgPrVmaJ4Pq1eUcqSZK6kIioAb4PfAiYDJwVEZObXPYhYELhdR5wZcm57wJ3ppQmAQeQ1UbZkSuB/wUsiIhvRsSkcuIsN9lb1yQTnQq8U2bf6rNmgev1isafAA2Pwbo1eUcitc4ffgqPXpkldvt/Kts/stTwA2DaufDOWrjpM7ClMZ84JUlSV3QosDCltDiltAm4ETijyTVnADekzCPA4IgYHhEDgaOBawFSSptSSjucipRSuiel9KfAwcBS4O6IeDgiPhcRPbfXr9xk76+BX0TEgxHxIHATcGGZfavPmkWu1yuadGpW1GLBXXlHIpVv1Xz4zZdhzDFw0uXb3y9z6FjY70x48fcw+/92bIySJKkzq42IuSWv85qcHwksK/ncUGgr55qxwCrgvyLiDxHxo4jYpaWAImJX4LPAF4A/kI0OHgzcvd0v0dJNAVJKjxWGCicCATyfUuqUJRxrI8Gmt2HXbrztQqnhB8KAETD/djjwf+UdjdSylOA3f5NNw/74tduO6DU1cmr2b37Wv8KkD/uLHkmSVI7GlNK0HZxv7jfNTcuBb++aWrIk7S9SSo9GxHeBrwL/e7sPi/glMAn4Cdk2eK8UTt0a9eH7AAAgAElEQVQUEXO31681C/wOAfYHDiKbk3p2K/pWjd41hf8Ndts730CqRQRM/BAsvC8rWS9Vuyd/Di8+BCf+I/Tfvbw+p34bevaBOy6ubGySJKm7aABGlXyuA14u85oGoCGl9Gih/Ray5G9HfpRSmpxS+tdiohcRvQF2lJSWu6n6T4B/B44kS/oOAXaU6VatXj1M9rYx8VTYvA6W/C7vSKQd27wB7vvnrCDLQZ8pv9+APeCoi2DRvbD095WLT5IkdRePARMiYkxE9AJmADObXDMTOLtQlfMw4I2U0isppRXAsoiYWLhuOvBsC8/752baZrcUZLkbUE0DJqfU+Xcq7lWzFXr1hwF75h1K9RhzFPQaAPNvg71PyjsaafueuAHeXA4f+QH0aFXlYTj0i/DID+Def4LP37n9dX6SJEktSCk1RsSFwF1ADfDjlNIzEXF+4fxVwO1k+5UvBNYDnyu5xV8APyskioubnHtXROxJts6vb0QcxHtTQwdSxu4I5SZ7TwN7Aq+0dGE5IuJvyBYWJmAe2ZfrR1b4pZ6swsyZKaXXCtdfApwLbAH+MqV0V6F9KnAd2R6AtwN/1VJC2rtHytbs+IPee2p7w/jpMP9OOG1r63+IljrC5nfgwW/D6COywiyt1bMvHH0R3Pa32Sj22DbcQ5IkqSCldDtZDlLadlXJ+wRcsJ2+f6S8mZInkxVlqQP+o6T9LeDvW+pc7k/1uwHPRsRdETGz+Cqz7/tExEjgL4FpKaUpZJnwDLJFifemlCYA9xY+U9ivYgawL3AK8IPCvhaQ7TdxHu/tX3FKS8/v1SO57UJzJp4Kb6+Al/+QdyRS8566Kfs7eszFbf9lzYGfhn67ZSN8kiRJVS6ldH1K6Tjgsyml40pep6eUftlS/3JH9i7bqSibf27fiNhMNqL3MnAJcGzh/PXA/cDFZPtT3JhS2ggsiYiFwKERsRQYmFKaDRARNwAfAe7Y0YN79kiu12vOhBMharKqnHVT845Ger+U4JGrYM/9YMzRbb9Pzz5wyBeyjdhXL7AypyRJqmoR8emU0k+B+oj4ctPzKaX/aKbbu8oa2UspPUA2tbJn4f1jwBOtDxdSSsvJir28RDYt9I2U0m+BPYqVZQrHYYUu29ufYmThfdP2bUTEecU9MgB/wGtOv6Ew+nB4/ra8I5G2teQBWPUcfOBLOz8F+5BzoaYXPHpVy9dKkiTlq7j/Xn9gQDOvHSprZC8ivkg2XXIoMI4sqbqKrHJMq0TEELLRujHA62SbtX96R12aaUs7aN+2MaWrgasBpo2oSSZ727HP6XDHV+DVZ2GPyXlHI73n0R9m0y+nfHzn79V/GOz7UXjqZjjxn6BXi2ubJUmScpFS+mHh+I229C93zd4FwBHAm4WHLeC9kbfWOgFYklJaVdiY/ZfA4cCrETEcoHBcWbh+R/tT1DXT3rKh49oYehe370ezqZzzbs47Euk9b62AF+6Cgz6dTcNsDwd9Bja+Cc/e2j73kyRJqqCI+D8RMTAiekbEvRGxuoUBM6D8ZG9jSmlTycNq2c4oWhleAg6LiH4REWSjg8+R7UNxTuGac4DiT2EzgRkR0TsixpAVYplTmOr5VkQcVrjP2SV9tmvT1mi/Hxi7mv67w7jjYd4tsHVr3tFImSd/DmlL6/bVa0n9kTB0LPzhJ+13T0mSpMo5KaX0JvBhskGvvYGvtNSp3GTvgYj4e7KiKicCvwD+py1RFnaKv4Vszd+8QgxXA98EToyIBcCJhc+klJ4BbibbaPBO4IKU0pbC7b4E/Ihs74pFtFCcBQrJnrZv/zPhjWWw7JG8I5Gywix/+CnsdTjsNr797huRjRS++BCsWdR+95UkSaqMnoXjqcDPU0pry+lUbrL3VWAVWXL2Z2T7SXyttREWpZS+nlKalFKaklL6TEppY0ppTUppekppQuG4tuT6y1NK41JKE1NKd5S0zy3cY1xK6cJyNn3ftMU95HZo4qnQs1+2nknK27I5sGZhlpi1t/1nAJGNZEuSJFW3/4mI58n25rs3InYHNrTUqdxqnFtTSteklD6ZUvpE4X1bp3HmaqMjezvWuz9MOg2e/TU0bmr5eqmSnvkl1PSGyae3/70Hjcwq0D59SzaCKEmSVKVSSl8FPki2V/lmYB1Z0csdKivZi4glEbG46WvnQs7Hpi0mey3a70x45zVYeE/ekag727oVnvl1tgdk7xYrC7fNlI/D6hfg1acrc39JkqT2sw/wqYg4G/gEcFJLHcrdVH1ayfs+wCfJtmHodFyzV4Zxx0G/XeGpm2DSqXlHo+5q2SPw9oqsSmylTP4I3PF32VTOPfer3HMkSZJ2QkT8hGwLvD8CxfolCbhhR/3KSvZSSmuaNP1nRPweuLSVceauMZnstaimJ+z7MXjihmyEr++QvCNSd/TMr6C2D+x9SuWescuuMPbYbAuGEy7b+Q3bJUmSKmMaMLm1S+nKncZ5cMlrWkScTxk7tqsTO/gzsGUjPHlj3pGoO9q6JUvAJpyUrSOtpImnwmtLYNX8yj5HkiSp7Z4G9mxtp3KncX675H0jsBQ4s7UPUycy/AAYORXm/hd84HxHPNSxXpoNb79a2SmcRRM/BLd9GebfDsMmVf55kiRJrbcb8GxEzAE2FhtTSjusYlfuNM7jdi42dUpTPwczL8x+8B59eN7RqDt55tdQ2xf2Prnyzxo4AkYclCV7R3258s+TJElqvcva0qmsZC8idvgTUErpP9rycFW5KR+Du/4B5lxtsqeOU5zCufdJ0GuXjnnmxFNh1r/AW6/CgD065pmSJEllSik9EBGjgQkppXsioh9Q01K/cncYnwZ8CRhZeJ0PTCZbt+fava6q1y4w9Wx4dia8vizvaNRdvDQb1q3smCmcRRNPBRK8cGfHPVOSJKlMEfFF4Bbgh4WmkcCvW+pXbrK3G3BwSulvU0p/C0wF6lJK30gpfaMtAauTOPTPsuOcq/ONQ93H/DugpheMP7HjnrnHvjBor+zZkiRJ1ecC4AjgTYCU0gJgWEudyk329gI2lXzeBNS3Lj51SoNHwT5/Ao9fDxvfyjsadQcv3An1R1W+CmepiKxQy+JZsGl9xz1XkiSpPBtTSu/mYxFRS7bP3g6Vm+z9BJgTEZdFxNeBR2lhAz91IUf8JWx8Ax67Nu9I1NWtWQRrFlZ2b73tmXQqNG7IEj5JkqTq8kBE/D3QNyJOBH4B/E9LncpK9lJKlwOfA14DXgc+l1L6l50IVp3JyKkw9jiY/T3Y/E7e0agre+Gu7Lj3SR3/7NFHQO9BWVVOSZKk6vJVYBUwD/gz4Hbgay11KndkD6Af8GZK6btAQ0SMaUuU6qSO/gqsW5VN55Qq5YU7YfdJMKS+459d0xPGT4cFd0NqcVaEJElSh0kpbSUryPLnKaVPpJSuSanlH1jKSvYKUzcvBi4pNPUEftrWYNUJ1R8Bo4+EB78Nm9blHY26og1vwosPdczeetszfnq2mfvKZ/OLQZIkqSAyl0XEauB5YH5ErIqIS8vpX+7I3keB04F1ACmll3HLhe5n+qVZSfxHr8o7EnVFi+6DrY35rNcrGnvce7FIkiTl76/JqnAeklLaNaU0FPgAcERE/E1LnctN9jYVhgkTQER00E7Hqip7fSD7Qfz334X1a/OORl3Ngt9Cn8FQd2h+MQwamU0jNdmTJEnV4WzgrJTSkmJDSmkx8OnCuR0qN9m7OSJ+CAwubOh3D3BNG4JVZzf967DpLZhlfR61o61bs+Is40+Amtp8Yxl3PLz4sMWIJElSNeiZUlrdtDGltIpsad0OlVuN89/Jdmz/b2AicGlK6f+2MlB1BXtMhmnnwtxr4dVn8o5GXcXLT8D61flO4Swae1y2BcNLs/OORJIkaVMbzwFlJHsRURMR96SU7k4pfSWldFFK6e5Whaiu5bi/hz6D4LaLshEZaWctvAeIrEBK3uqPgB49YZH77UmSpNwdEBFvNvN6C9ivpc4tJnsppS3A+ogY1B7RqgvoNxRO/Cd46WF4wq0Y1A4W3QcjDsr+buWt1y6w12Eme5IkKXcppZqU0sBmXgNSSu0zjRPYAMyLiGsj4oria+dCV6d20Keh/ii4+1J4oyHvaNSZbXgDGubCuOPyjuQ9446HV+fBW6/mHYkkSVKblZvs3Qb8b+B3wOMlL3VXEfAn34WtW+CX52VHqS2W/h7Slve2PagG447PjovvzzUMSZKknbHDsncRsVdK6aWUknP1tK1dx8Fp34Zfnw+/+zc49qt5R6TOaNF90HMXGJXjlgtN7bk/9Ns1i+2AT+UdjSRJUpu0NLL36+KbiPjvCseizujAs2D/T8ED34KlD+UdjTqjRbOyoii1vfOO5D09esDYY2HxLEgp72gkSZLapKVkL0rej61kIOrETvs2DKmHX34R1q3JOxp1Jq+9CGsXVdcUzqIxR8Pbr8KahXlHIkmS1CYtJXtpO++l9/QeAJ/4MaxbDTf+L9i8Ie+I1FksLlS8LK6Rqyb1R2XHJb/LNw5JkqQ2ainZO6BkH4f9S/d1iIg3OyJAdRIjDoKP/RCWPQK3/rn776k8i2bBgOGw+8S8I9nW0LEwYAQsfTDvSCRJktpkhwVaUko1HRWIuoB9PwqvLYV7LsumdU6/NOeAVNW2boElD8DeH8qqu1abCBhzVFakJaXqjFGSJGkHyt16QSrPEX8NB58DD34bHr0672hUzV55Et55rbr212uq/ihYtwpWzc87EkmSpFbb4cie1GoRWcGWdavhjq9ATS1M+3zeUakaLbovO449Ns8odqz+yOy49EEYNinfWCRJklrJZK8t5lyz/XOHfrHj4qhWNT3hk/8FN30GfvM30KMWDj4776hUbRbfD3vsB/2H5R3J9g2ph0GjsmTPf9uSJKmTcRqnKqO2N5x5A4ybDjP/Ep74Sd4RqZpsWgcvPQLjjs07kh2LyKZyLv29RYckSVKnk0uyFxGDI+KWiHg+Ip6LiA9GxNCIuDsiFhSOQ0quvyQiFkbE/Ig4uaR9akTMK5y7IsIKClWlZx+Y8bOsrP7MC3c8IqruZelDsHVzdW650FT9kbB+Dax6Pu9IJEmSWiWvkb3vAnemlCYBBwDPAV8F7k0pTQDuLXwmIiYDM4B9gVOAH0REsUrolcB5wITC65SO/BIqQ8++cNbPYeJpcPtF8NB3845I1WDxLKjpDXt9MO9IWla6bk+SJKkT6fBkLyIGAkcD1wKklDallF4HzgCuL1x2PfCRwvszgBtTShtTSkuAhcChETEcGJhSmp1SSsANJX1UTWp7w5nXw74fg7svhfu/mZWyV/e1aBaM/mD2y4BqN2Q0DN7LzdUlSVKnk8fI3lhgFfBfEfGHiPhRROwC7JFSegWgcCxWbRgJLCvp31BoG1l437R9GxFxXkTMjYi5jY2N7fttVJ6anvDxH8GBfwr3/2u2F58JX/f05iuw6rnOMYWzqP5oePEh1+1JkqROJY9krxY4GLgypXQQsI7ClM3taG4dXtpB+7aNKV2dUpqWUppWW2sB0tz0qIHTvwfTzoWH/hPuuNgfnrujxbOy49gq3l+vqTFHZXsCrnwm70gkSVKViIhTCjVFFkbENvlMZK4onH8qIg5ucr6mMPj1m0rFmEey1wA0pJQeLXy+hSz5e7UwNZPCcWXJ9aNK+tcBLxfa65ppVzXr0SPbh++DF8KcH8Jv/gq2bsk7KnWkRbOg326wx5S8Iylfcd3eEtftSZKkLFEDvg98CJgMnFWoNVLqQ7xXW+Q8snojpf6KrHZJxXR4spdSWgEsi4iJhabpwLPATOCcQts5wK2F9zOBGRHROyLGkP1hzSlM9XwrIg4rVOE8u6SPqlkEnPTPcPRX4Ikb4Ffnwxan13YLW7dm++uNOy5L/DuLQXUwZEy2BYMkSRIcCixMKS1OKW0CbiSrNVLqDOCGlHkEGFwyuFUHnAb8qJJB5jWn8S+An0VEL2Ax8DmyxPPmiDgXeAn4JEBK6ZmIuJksIWwELkgpFYeCvgRcB/QF7ii81BlEwPFfg9o+cN8/QeMG+Pi1UNsr78hUSSufgXUrO9cUzqIxR8Gzt2Yj0T1qWr5ekiR1ZrURMbfk89UppatLPjdXV+QDTe6xvdojrwD/CfwdMKDdIm5GLsleSumPwLRmTk3fzvWXA5c30z4X6ERzwbSNoy+Cnv3grkvgpj+FM3+S7c+nrmlRcb3esXlG0Tb1R2Uj0a8+DcMPyDsaSZJUWY0ppebylaJy6oc0e01EfBhYmVJ6PCKObWuA5ehE86jUZX3wz+HD/wkL7ob/dyZsWpd3RKqUxbNgt4kwqNnCudWt/qjs6Lo9SZK0/boi5VxzBHB6RCwlm/55fET8tBJBmuypOkz7HHzkymzj6p98DDa8mXdEam+bN8CLD2fr9TqjgcNh6DjX7UmSJIDHgAkRMaawNG0GWa2RUjOBswtVOQ8D3kgpvZJSuiSlVJdSqi/0uy+l9OlKBGmyp+px4FnwiR/D8rnZCN/mDXlHpPa07JFsbWZn2l+vqfoj4aWHrSArSVI3l1JqBC4E7iKrqHlzodbI+RFxfuGy28nqkywErgH+vKPjdNM5VZd9PwppK9zyefjVefCJ6zpX1UZt36L7oEdPGH1E3pG0Xf2R8MT1rtuTJEmklG4nS+hK264qeZ+AC1q4x/3A/RUID3BkT9VoysezrRmevRV++w95R6P2smgWjDoUevfPO5K2KyaqTuWUJEmdgMmeqtMHL4QPnA+P/ABm/yDvaLSz1q2GFU91zi0XSg0aCUPHwtKH8o5EkiSpRSZ7qk4RcPK/wKQPZ6N7ix/IOyLtjMX3Z8fOWpyl1Ogj4MWHsg3iJUmSqpjJnqpXjxr46FWw297wi8/C6y/lHZHaavEs6DMIRhyUdyQ7r/4o2PB6tm5PkiSpipnsqbr1HgCf+hlsbYQb/xQ2v5N3RGqtlGDR/TDmmCyB7+zqC+v2XnQqpyRJqm4me6p+u42Hj12Trfm67W/zjkattXoBvNnQNaZwAgyqgyH1FmmRJElVz2RPncPEU+Dov4M//gzm3ZJ3NGqNxbOyY2cvzlKq/kjX7UmSpKpnsqfO45iLoe5Q+M3fwGsv5h2NyrVoVjYSNnRM3pG0n/qj4J3XYOWzeUciSZK0XSZ76jxqauHj12Tvf/lF2NKYbzxq2ZbN2XTHrjSqB+63J0mSOgWTPXUuQ+rhw9+BZY/C7/4t72jUkoa5sOktGHd83pG0r8GjYPBoWPpg3pFIkiRtl8meOp/9PgH7fypL9l55Mu9otCOLZ0H0gDFH5x1J+6s/Cl582HV7kiSpatXmHYDUJqd8M1sLdusF8MVZUNMz74jUnEX3wYiDoe/gvCNpf/VHwB9/Cquegz32zTsaSZLUWnOuyTuCinNkT51Tv6Hw4f+AFfPgoe/mHY2a887rsPzxrrPlQlOu25MkSVXOZE+d1z5/Avt+FB74Fqx8Pu9o1NTiWZC2wvgT8o6kMoaMhsF7mexJkqSqZbKnzu1D/wa9+sPMC107VW0W3AN9BsHIaXlHUjmj3W9PkiRVL5M9dW79d4eT/wUaHoM//CTvaFS0dSssvBvGTc+2zOiq6o+E9WtglSPLkiSp+pjsqfM7YAbsdTjccxmsX5t3NAJ4dR68/SpMODHvSCqr/sjs+OJD+cYhSZLUjC78K3e1q5aqFR36xY6JozkRcNq/w1VHZQnf6VfkF4syC36bHbvqer2iIaNh0Khsv708/w1IkiQ1w5E9dQ177AuHfQmeuCHbyFv5WnAPDD8Q+g/LO5LKqz8Slj4EKeUdiSRJ0vs4sqfOrXTEccCe0HsA3Hw2HPFX2WbejrZ0vPVroWEOHHVR3pF0jNFHwJM/h1XzYdikvKORJEl6lyN76jpq+2TbMby5PNvfTfkobrnQ1dfrFRXX7S19MN84JEmSmjDZU9cy/MBs77P5d0Djxryj6Z4W3A19h8DIqXlH0jGG1MPAOljyu7wjkSRJeh+TPXUtEbDP6bDxTVh8f97RdD9bt8LCe7ItF3rU5B1Nx4iAscdkI3vutydJkqqIyZ66niH12Qjf4vvhzZfzjqZ7efkPsG5V95nCWTTmGHjnNVjxVN6RSJIkvctkT13TxFOBBPf+Y96RdC/zb4OogQkn5R1JxxpzdHZc8kC+cUiSJJUw2VPX1G8o1B+VVUlc/kTe0XQfz98Gow/P/vy7k4HDYbeJsNhkT5IkVQ+TPXVd446HfrvBb7/mHmgdYc0iWPU8TPpw3pHkY+wx8NJsaNyUdySSJEmAyZ66sp594bi/hxcfguf+J+9our7nb8uOk07NN468jDkGNq+HhsfyjkSSJAkw2VNXd/A5sPskuOcy2LI572i6tudvgz33y7a+6I7qj4To4bo9SZJUNXJL9iKiJiL+EBG/KXweGhF3R8SCwnFIybWXRMTCiJgfESeXtE+NiHmFc1dEROTxXVTFamrhhMtg7SJ44vq8o+m63l4Fyx7tvlM4AfoOLlSBNdmTJEnVIc+Rvb8Cniv5/FXg3pTSBODewmciYjIwA9gXOAX4QUQUN/C6EjgPmFB4ndIxoatT2fsU2OtwuP9bsPHtvKPpml64A0iFKqjd2NhjYPlc2PhW3pFIkiTlk+xFRB1wGvCjkuYzgOLQy/XAR0rab0wpbUwpLQEWAodGxHBgYEppdkopATeU9JHeEwEn/iOsWwmzv5d3NF3T87fBoL2yaZzd2dhjYWsjvPhw3pFIkiTlNrL3n8DfAVtL2vZIKb0CUDgOK7SPBJaVXNdQaBtZeN+0XdrWqENgn9PhoSvg7ZV5R9O1bHwbFs2CSadliXV3NuoDUNPbqZySJKkqdHiyFxEfBlamlB4vt0szbWkH7c0987yImBsRcxsbG8t8rLqc6V+Hxg3wwLfyjqRrWXAXbNmYJXvdXc++MPqDsOi+vCORJEnKZWTvCOD0iFgK3AgcHxE/BV4tTM2kcCwOvzQAo0r61wEvF9rrmmnfRkrp6pTStJTStNra2vb8LupMdhsPUz8Lj1+X7Qmn9vH0L6H/ntlm6oLxJ8Cq5+CNhpavlSRJ1WH9WljyO3j8evj9d/KOpt10eLKXUrokpVSXUqonK7xyX0rp08BM4JzCZecAtxbezwRmRETviBhDVohlTmGq51sRcVihCufZJX2k5h371Wya3b3fyDuSruGd12HBb2HKx6BHTcvXdwfjT8iOC+/NNw5JktSyt1ZkFdvv/1d4bia89Qr0HpB3VO2mmoa5vgncHBHnAi8BnwRIKT0TETcDzwKNwAUppS2FPl8CrgP6AncUXtL29R8Gh/8FPPBNaJgLddPyjqhze/43sGUTTPlE3pFUj90nwcCRsPAemHpOy9dLkqSOt2UzzL8DFs+Cml4w7rhs7X2/XQsXzMk1vPaSa7KXUrofuL/wfg0wfTvXXQ5c3kz7XGBK5SJUl3T4hTD3x3D3pfDZ2ywqsjPm3QJDxsDIg/OOpHpEwPjp8Myvs/+Q1PTMOyJJklTqrRXwi8/CS7Nh5LT/3959x7dV3nsc/zxa1rC8HTuxnZ04CSGQAGFD2JtAw96r0BZaaEuhcHtvFx23t4sWCmVD2asUSiBsStghbLJDlmM7HrEtWx4az/3jObZlx3GW7SPJv/frpZeOzpAexSf2+Z5nmXmCMzLtLtWgSKaaPSGGRkYQ5lwPz/8Qli+Acpmecac0b4Kv34SDftBvYI7G4jS3Rwm1RWmLxGiNxGiLxK3nxEe8x/a2SIyOWJxoLE40ronGNNF43Hq2Hp3bGguIxnsO7wsJozi9v7BHEbsWlcLtULicCrfTgcuhcDkdeJwOXE6Fy+HA7eze7nY68LoceD1OfG7r4XHiTVj2uZ0UjDiI4sUP0LTyXTImHEiGS5q4CiGEEEmhdiX841QI18Ke58KomXaXaFBJ2BPD06wL4b3b4JWfmj5WTvmvsDUd0TgNrR00hCNsbulgczhCY2sHJcv/wUE6zt9q92DV45/S3B4h1BaluT1Kc1uUkPXcGolt+0N68bhMqMpwO60AZoKXy6FwOkzwMs/mdcAVx6nAmRDoEofm1ZmePtfHNcTicSJRTXM0SjSmicTiRBICZudyJBqnIxanPdo7Um4pC8XiDAf3/+Nu/hAN4XE6CHpdBL0uMr0ughnuruUsr7t7W4abLJ+LXL+HHL+bXL+HXL8Hn0fCohBCCLHLNi2F+6zRwy+eb7r0pDm5whXDk9MNR/wPPH4BfPowzLrA7hINmXBHlNpQBzXN7dSE2qltNo+65g42h02oa2jtYHNLhIZwBy0dfYe1Jz3PsIwybl+SQdBbZ4UVF3kBD6Pz/F2vg143mRlmubPmy+t24vM4yHD1rBnzus06p2MHm9Z+cGf/22fP27H364fWmvZonNYOUwvZGonR2hHrqpXsXL/5zT05O7ocx6xymtpMEA61RWm2ltfWhQm1RUwobo+i+5w4xshwOUzwC3jItUJgVxgMeCjI9FCYmUFhMIOCzAxy/G6UNE8WQgghutWvhgfmmgHlLnoeCiZJ2BMirU09GUr3gdd/bQYY8fjtLtFOi8U1dc3tVDa2UdXU1hXiusNcR9fr8FbCW2eIyPa7GRH0MrkoaEKFz01OQsjI9rkpiFVTfM9y9OH/zWeHHDPE39ZeSim8VmDN7W/HpuPhtZu4cp9syCzs9z3jcU1Lhwl9ja2RrqC9ORyxArhZ7nxeUtVkQnm4g3gfIdHtVOQHOsOfpysEJj4XBjMozvISyJA/A0IIIdJcuB4enGcGlbt4vgl6w4T8lRfDl1Jw1C/g3uPg/dvg4B/aXaI+RWJxqpvaqLKCXFVjmwl1jW1UNrZS1djGplA70T6u+vOsWp+CzAz2KM3putjvHQDyAh7czh2YieWN2wCF2v30gfui6WbikfDaTWaUrxln9Lurw6EIet0EvW5GZvu2+yPicU1TW4Ta5nY2hUyo7wr4oXZTe9vczleVTdQ1d1+TYl8AACAASURBVPR5jgS9LkZmeynK8jIy20txto9ia7lzndQUCiGESFnRDnj0XGisgAufgxFT7S7RkJKwJ4a3MQfA5ONg4Z9h1kUQyN/mIQMt3BGlYnMrGza3smFzmA2bW1lvPVc2tlHb3L5FEz+f28nIHHMhvt+E/K6L9JFZXoqzvTsX4LZXPAaLHzBDFOeOGfj3TxfFe4C/AFa8vM2wt7McDkWO30OO38PEEf3PCRSPaxpaI101vJtCbVQ1tlPV2Np1E2FZVYiaPs63DJeDYiv8jcr2UprrpyTXR2muj5IcH6NyfHjd0q9QCCFEEnrlp7DuHZh3N4ze1+7SDDkJe0Ic+TO4bX946/dw7G8G/O1bO2JUNIRZnxjo6ruDXV1LR4/9PS5H10X0tJFZFGcn1rL4KM72kuV12VfTsvIVaKoYlH+rtOJwwKSjYdn8pJiCweFQ5AU85AU8TC7aejCMxOLUhEyT4Oqmth7PVY2tfLhmM89+unGL5qOFwQxKcqwAmOujNNdPaY5ZLsnxSXNRIYQQQ2/Jc/De32D2FbD78JwTWP76CjFiihl694M7Yd8rIHfsDr9FQ7iDNXVh1ta1sKbWeq5rYV19mNrmPsKcdRF89KhsSnN9lOX5KbVqSgoCGTh2dICSofTRfRAYAeXH212S5DfleDMA0Lp3Ydwhdpdmu7idDkZZtXVbE43FqWpqY8PmVio2t1LRYG5eVDS08nlFIwu+rCIS65kGc/1uSnP9jM73MzrPz5g8szwmP8DILG9yn/NCCCFST/3X8MyVMGoWHP3LQfkIpdSxwM2AE7hLa/3bXtuVtf14IAxcpLVerJQqAx4AijEzR92htb55MMooYU8IgMNuNBOEv3YTzLtri81aa+pbEgJdwvOa2hYaWyM99h+V7WVsQYCjphWZGg6rpqMs10dBZpKHuf40bYTlL8KBV9teU5USJhwOLi8snZ8yYW97uJwO67zue1CjeFxT09zeVXttwmAr6+vDfFnRyIIvqnr0H/Q4HZTm+UwAzPMzOj/AmDw/Y/L9lOX5pYmoEEKIHRNtN5OmK+D0e8GVMeAfoZRyArcCRwEbgA+VUs9qrb9K2O04YJL12Be4zXqOAj+0gl8Q+Egp9XKvYweEhD0hALJGwX7fhoV/ZOXEi/hSj2N1TQurappZU9fC2towofZo1+4OBSW5PsbmBzhpj5GMzQ8wJj/A2HS/OP34QdDxYTVVxS7xBGD8HFj2vGn2OkwGOXE4FEVZpunxXn1064zG4lQ2trG2Lsy6+jBr61tYVxdmbV2YD9dspjnh/xpAcZbXCoF+xub7GVeQybiCAGML/Pg98mdMCCFEL2/+Dio/gTMf3KkWW9tpNrBSa70aQCn1KDAXSAxsc4EHtNYaeE8plaOUGqm1rgQqAbTWIaXUEqCk17EDQv5KimFHa01lYxurappZXdPC6ppmVtW0UL1pJo/pTCqfvJ6rIzeiFJTl+hlbEGCv0bkmzBX4GZsfoDTXj8c1CIOfJLPOgVnGz4G88XaXJnWUH29qQ6u/hOLpdpcmKbicDsryzI2R3jpr0dfVW0HQCoHr6lt4a0UNT37U3mP/4iyvFfwCjC8IdC2PzhuG/0eFEEJAxWJY+CfTRWfqSbvyTi6lVOJEfHdore9IeF0CrE94vQFTa8c29inBCnoASqmxwEzg/V0p7NZI2BNpqzWqWL2xkVUJgW61FfBaI91zzWVmuJhQGGD6hNF80XEFh6z6A2+drCnc87j0raHbGStfgcb1g9buPW2VHwfPKTNQi4S9bVJKkZ+ZQX5mBjNHbzmTYbgjypraMF/Xmn6xq2ta+Lq2mRe/qGRzuLs5tUNBWZ7fhL/8AOMLA13Lo3J8OFO1KbUQQoiti7bDM9+GzCI45te7/G5a67372d7XH5Lecxz1u49SKhN4CrhGa92040XcNgl7IuW1RhWrQi5WhFwsb3KxosnNipCLdS1ONAsB03quNNfH+IJM9h2Xz/hCc/E3sTCTwmBG98iW0alwy5OUffhrmHWsjd8qCb17KwRHQvkJdpcktWSOgNJ9YOnzcOh1dpcm5fk9LqaNymLaqKwttjWEO/i6tmWLxwdf1xPu6L7B43E5GJtvaunHFXbWCGYyvjBAfsAjcwoKIUSqeuM3ULMUzn0SfDmD/WkbgLKE16XAxu3dRynlxgS9h7TWTw9WISXsiZTR2hFjVU0zy6tDrNjUzIrqEMvXjWB9ixNt3ThxK824YJTpORFOHR1m0sw5TBhh7uZvVy2dKwOOvgkePx8W3W1G5xRQ+Rl8/aaZpsLlsbs0qWfK8fDKz8yErtkldpcmbeX4Pcwc7dmiRlBrTU2ondW9QuDq2hZeX7apx8ihQa+L8YWZjO9sFloYYLzVR9DnkZp+IYRIWhs/hrdvhpnnw6SjhuITPwQmKaXGARXAWcA5vfZ5FrjK6s+3L9Cota60Rum8G1iitf7jYBZSwp5IOn2Guupm1m8Od0327HYqxhUE2D0nwjdGh5mcFWVyMMqYzCjuxG46M0bueAGmngTjD4PXfgW7fQMyCwfke6W0d28FdwD2usjukqSm8hNM2Fs2H2Z/0+7SDDtKKUZkeRmR5WW/8fk9tsXimorNrayubbaahLawuraZ91fX8c+PK3rsOyrb2yP8jbeWS3KlWagQQtgqHoPnroFAIRzzqyH5SK11VCl1FbAAM/XCPVrrL5VS37K23w7Mx0y7sBIz9cLF1uEHAucDnyulPrHW3ai1nj/Q5ZSwJ2wTicVZXdPC0qomllaF+g91pdnMm1XKpKJMJhdlMiY/gNvpMHPjDTSl4LjfmYnWX/0ZzL114D8jlWxeC188CftcBr4t+1CJ7VA4GfInwtJ/S9hLMk6HMnP/5fuZU95zW2f/wNW1zXxdY2oCV9e28MwnFYTaukcM9TgdjMn3W/0CM60QGGB8YSZ5AakJF0KIQbfoHjP65ry7wZs9ZB9rhbP5vdbdnrCsgSv7OG4hfffnG3AS9sSg01pT1dTG0soQS6tCLLPC3aqa5q7mU26nYnxBZleom1yUyaTEUDfUCifDft+Bd/4Ce10Mpf31z01zC/8EygEHfM/ukqS2aXNh4Z+huUZqi1PE1voHaq2pa+noGhxmtRUEV25q5rWlPZuF5vjdphYwIQSOK9yBpuVCCCH6F6qCV39hWmVNn2d3aZKOhD0xoEJtEZZXd4a6kBXwmmhKuAs+KttLeXGQw6aMYEpxkCnFWYwrCCTfMOmHXgefPQ7P/wAuew2cw/C/S2MFfPIQzDxP+prtqumnwVt/gK+ekdq9FKeUoiAzg4LMDGaPy+uxLRqLsyGhWejq2ha+rmlh4coanlq8IeE9YFS2r0ctYGfT0FHZPhzSLFQIIbbPgv8yo3Ce8IdhM5/tjhiGV69iIETjsKbZxZImF8sa3SxdsoilVU1s2NzatU9mhovy4iAn7TGKKcVByouzKC8Oku1z21jyHZARNBNhP3kxvHcrHHi13SUaev/5P9AaDrzG7pKkvqJpUDgVvnhKwl4aczkdjLXm+jt8Ss9tLe3RroFhVtc0m+WaFp78aAMtCaOFZrgcjLPmDOzdNDTHL81ChRCiy6rXTFeTQ38M+RPsLk1SkrAn+tU5it2S6gyWNbpY2uRmaaOblSEXHXFz98SpNOMLW9izLIezZ4+mvCjIlJFBSnJ8qT+E+W6nwudPwuu/hiknDq9fJLUrzSTq+1wKuWPsLk162H0evHYTNKyHnLJt7y92zLb68NocsgMZLqaXZDO9pGd/ksTRQhObhi6tCvHSV9XE4t3NQvMCHqtZaPdIoeMLA4zJ95PhkmahQohhJNIGz18LeePhoO/bXZqkJWFPdAl3RFnW2fyyyjS/XFYVsiYqNiPYFXljlGdFOHhEO+XZEcqzIkwMRsnY/0R7Cz9YlIITfg+37gvPXQ0XPjd8mgi89gtweeGQH9ldkvQx3Qp7Xz49PGuKRZ/6Gy00Eouzrj5sDRBjagNX1bTwxvIanviou1moQ0GJNZdo76ahxVleaRYqhEg/b98M9avg/H+C22t3aZKWhL1hKBbXrKsPs7SyiSUJA6asq+8eBdPvcTK5KMix04spLwpS3vAfpmRFyM3Q/b95OsoaBUf/0oS9xfcPj+kH1iyEr/4Fc24wk4KLgZE3Hkr2MrXFEvbEdnA7HUwozGRCYSZQ1GNbU1uENVZtYGLT0A/X9JxE3ud2MrZrqoieTUOzvCnSrF4IIRLVrTL94Hf7Bkw43O7SJDUJe2muIdzBEmuQlM7BUpZVh2iLxAFzN3hsQYDdRmUxb1Yp5cVBphQHKcv197wT/MErNn2DJDHrQnOBvuAnMO4Qc9GermJRmH8dZI+WETgHw/R5sOBGqF0BBZPsLo1IYVleNzNKc5hRmtNjvdaa6qZ2Vtc0s8oaIGZ1bTNfVDTywueVJLQKpSDT02PewHFWjeDoPH/yDZolhBBgxhKYfy04PXDMr+0uTdKTsJcmEuesSwx3VU1tXfvkBTxMKQ5yzuwxTBlpQt3koqAM/709lIJT/ga3HQRPXQaXLABnmt4R/+DvsOlLOPNB8PjtLk362e0bZuSwL56COT+2uzQiDSmlKM72Upzt5YCJBT22tUdjrK8Ps6pzAnmrNvCVJdXULero2s/pUJTl+hhbEKAs18/oPD9leZ3PPoJSIyiEsMuX/zQDsxz3O8gaaXdpkp6EvRSjtaamub2rlm5pZYglVSFWbgr1mLNu4oggB0zIt0JdFlNGBinMzEj9AVPslDMaTr4ZnrjIDNhy5E/tLtHAq1sFr/4SJh1jBqQRAy9rJIw9CD57DA69fvj0ARVJIcPlZOKIIBNHBLfY1hiOdPULXG3VBq6tC/PR2s09JpEHyPW7ewVA8zw6z8/IbC8uO+ZHFUKkv7YmePEGGLkH7HOZ3aVJCRL2klhbJMbKTc0sqWzqGjBlaWWIupbuu6/FWV6mjAxy6ORCplrBbnyhTRORDwe7nQorXzUTjY+fA+MPtbtEAyceg2e/a2osT/qzhJDBNPM8+OcVpm/kuIPtLk16ad1smsg2bYBwHbQ3g46b83rV61BYbvpNjj0IfDnbfr9hJNvvZuboXGaOzt1iW2M4wrr6MOvqw6zfbD3Xh/m8opEXv6gimtA21OlQjMrxdoW/sjw/Zbl+RuX4KM31UZiZIQPGCCF2zuu/guZqOPthcEjLtO0hYS8JaA0VrU6WNrpY+toKllSFWFrZxNe1LV19K7xuB+VFQY6cWtRdW1ccJDcgcy4NueP+F9a9B09fDpe/bgZwSQcL/wRr34a5t6bPd0pW0+bCC9fBR/dJ2BsIrQ3w6aPwzl+gqcKsc2WAv9DMl+lwQazDjNq2YgHEo6CcMPEIE7ynnCgXDduQ7Xezuz+b3Uuzt9gWjcWpamrrCoDr61u7guFLX1b3uEEJpvVJcbaXUdk+SnJ8lOT6GJVjHiU5Xkbl+PB75PJECNHLxk/ggzvMlFAle9ldmpQhv02HWHNEsazJxdJGtzVnnZm7LhTprIlbzug8P1OKg5www0xGPqU4yJj8AE65E5ocPAE44364+2h49By4aH7q921b+65pmjp9Hux5rt2lSX9uH+xxNiy6B1rqIJC/7WPEltoa4a0/wod3Q0cIsktNcCucYkaRVb1aOMz+JkTbYcMiE/o+fxIevwByxpiRZ2ecCQ5pFbGjXE4Hpbl+SnP90MdUpC3tUdZvDlPZ0EZFQysVDa1stB7vf11P1adtPeYSBNNMtDsA+hiV42Vkto/ibC9FQS8jsjKkv7kQw0k8Bv/+PvgL4PD/trs0KUXC3iCJxTVr61pYVhXqqqkz0xt0dyQNuuJMyY5wSlkrU7IiTMmOUH74eWRmyI8l6RXtBt+404S9f10Jp92Tus0eG9bD4+ebidNPlOabQ2bWhfD+7fDpI3DAVXaXJrXE4/DJQ/Dqz6GlFqZ/w0xlsf6DbR/ryoCxB5rHET+FZfPN8N3PfMv8PI75tdkmBkwgw2W1Rsnqc3s0Fqc61N4VACsaWqnYbJbX1YV5d1Udze3RLY7L8bspCnopyvZSFMygKKvncnG2l/yAR/oPCpEOFt0DGxebay9pgr9DJFXsIq2hqtXB0iY3y5tcLFvzCcurQ6yobqY92j29wbiCALuXZnNGcRVTsiNMyY5S4otteV0tQS91TDneDNLyys9MP6BUHFmxrQkePdvUdlz0PHj7vhgTg6BoGpTONk05979SQvb2qlluglnFR+bf79wnYNRMs217wl4ihxOmngTlJ8DnT5jweN/xMPN8OPY3pgmoGHQup8M058zxbXWfprYIGxtaqW5qp7qpjU1NbVQ1tVHd1M6mpjaWVTVRE2qnVwUhDgUFmSb8FWR6KMjMID8zo2vZvDbLeQGPtKARIhk1VsArP4dxh8Lup9tdmpQjyWIHbG7pYGlViOWr/CzrDHc9mmBCUVYtk4uCXLD/GCYVBZlanMWkoszu5iYffGRT6cWgOPAaqFkGb/wGfLmw7xV2l2j7RVrhkbNh0xI4+zETWMXQ2usi+Nd3YO07Upu0LVqbYPziDaYZ7Kl3wIwzBiYkOxywx5km+P3nd7Dwz7DmLXMHuWz2rr+/2GVZXjdZxW6mFG99n1hcU9tswmB1UztVVijsfL0p1M6SyhB1Le1do1cnUgry/J6u8JcYCnP9HnL8bvPwmeVcvwev2yGjXAsxmLSG+T8yfa1l8LidImGvDy3tUZZXh1heHWJZVbN5rg5RE2q39sgh2x2nPMs0wZycFaE8K8rkrAg5B8kwsMOKUnDyX6E9ZAbcUA7TLyjZdbTAY+eZAVnm3QWTjrS7RMPTbqea8PLRfRL2+tPWCM98B5b+24yCe8rtgzO3kscPR/4MJh0NT18B9xxj+oYc9H25wEgBTocyTTmzvP3up7WmqTVKbUs7taF26lo6qG1up7a5g7rmdmqb26lr7uDzDQ3UNXcQ6qMJaSePy0GOzwS/bL+7aznH77Zee8j2uQl6XWR6XQQzzHNmhouAxyWjkopBobUmEtNEYnEisTgdsTgd0XjXOrOc8DoWJxK1nmNxIlHdvWzt13lMTGvicU00bp5jWhOL071Oa2Kd62O6a/9Y53rr0b0fJtABuqv83d9l//aF3Nj8PPf4L+apByuAih7bE2/bKMy9O6dSOBwKh1LWsvn94FDWOofCoTDLDbnWssapTGsApwK3Y8sbQqlqWIe9jmicVTVWmKsKdYW69fWtXft43Q4mF5mpDTonIS+vfJYR3vjQ/+3/4M7+t6dCyEhHTjecdq+Zf2/+tWZdMv8swvWmRm/DBzD3Ftj9NLtLNHx5/KZG6aP74OibIFhkd4mST90qeOQsqF8NR/0S9r9q8AdRGXMAfPtteO5q07Sz6jMzSq0nMLifK4aEUopsK4xNKMzc5v5tkRgN4QgNrR3mOWw9t0bYHO6gMRyhIWyW19WH+WxDI5vDHV1dObZeDsj0dIe/zucsr7vrdSDDhd/jxOc2D6/Hid/txOdx4rXW+RK2+zxO3E4ltY2DJB43ISga10Si3UFqWyGqx+uEdZ2vE4/rPqb7dff2OB0xnbC97336qrkeCC6HCVFOpbqXrRDl6lxOCFsuR3e46np0bXOQ4eoMZd2f0bmolMIXa+Y7DX9nrWci7xaeRbFyJlx7dx/UuU5rukJkXHcHynjc9A3uDJ5xTXfgbHERB+JaEdMQ02Y50v9/35Qy5GFPKVUGPAAUA3HgDq31zUqpPOAxYCywBjhDa73ZOuYG4FIgBnxPa73AWr8XcB/gA+YDV2ut+z3D4xlBrnxoMcurQ3xd29I1N5DLoRhfGGCP0hzO3LvMhLriIGW5/i3vvDWk0RkgBobLA6ffB09caAJf43oz+EOyDee+aYkJek0VZlCZ3U61u0Ri32+ZGzkf3gmH/8Tu0iSXVa+ZmyjKCRf8y8yNN1S8Web/yMg9TL/c2hVw1sNmICMxrHjdToqznRRn919j2FtiSGxpjxJqM4/m9ijNbVFC7VFCbRGaO9dZ+2xsaO3ap6UjtsPldTqUCYZuJxkuB26nwuNy4Haah8flwGM9u52qxzp313pHjwt7p8NcfCderDtU79oSEmpNzD4KU/OSeGmmNWh0V+2MeW326dqr1z5xjVVTFO+qPeqsWYrGe9YYxRLXWbVLvY/pHZSivQOaVbvV43VMbzFq7EBxOVSPf3uPU+FO/JlZPye304Hf0/lz6l6XuE/XeyT8fM12B27rGLPc/TN3b+VYT8L723IT4bmrYUMDOZc+zZ2dfbMHWj8VKeoXg/ORQ82Omr0o8EOt9WKlVBD4SCn1MnAR8KrW+rdKqR8DPwauV0pNA84CdgNGAa8opSZrrWPAbcDlwHuYsHcs8EJ/Hx73BPm8opHJRUGO3q2I8uIsyouCjCsI4HHJiF1iF7g8cPr98OL18PbNUP2VaSKZDKNGJfZ3ygia6SLK9rG7VAIgfwJMOcFMH3DQD1J/Go+BsvgB84e+cKqZPDd37NCXQSk46Boomg5PXQJ3HwXnPgkjZwx9WUTK2dmQmCge17RFY7R2xGiNxGiLxGjtiBPuiHa/ttZ1bzfrwh2xnjVCCc30wh1RGlv1Fus7oj0D0CBlmwGnFF21SK7EWiSHo9dr8+gMV50hJ5Dh6hl6OgNOQjhy9Q5OCYGsR2iyQpTLYW13JISnxIDVGcYcDmnO25c1b1sDmF3VPQiX2ClDHva01pVApbUcUkotAUqAucAca7f7gTeA6631j2qt24GvlVIrgdlKqTVAltb6XQCl1APAKWwj7LlClfznusMG+FsJYXF54MQ/mYvDF66Du44wgc/OX1S1K+H5H8DXb8L4w+DU2yHYzygHYujtf6Xpj/bJQ8ndBHgoaA1v/9nUpk04As54ADK23dRuUE06Ei55CR6cB/ceD2c9aPoOCjHIHA6F3+OybZJ5rU2Tt8SmcTGrGVxnP6yuZnFdy937dlMo1bOJnqK7+Z2ytpO4LmEfxZZhrXezQJFGIq3mZl/OaDjsRrtLk/Js7bOnlBoLzATeB4qsIIjWulIpNcLarQRTc9dpg7UuYi33Xr8NKXKbSqS2fS41Ezs/dSnceQQc+D04+NqhvWjdvNaMLPjJI6av0Ql/gL0ukUmjk9Ho/aFsXzMK5KwLzU2D4Sgeh5f/G969BaafBqfcljz/FiOmwKUvwUOnwYNW2WbIEOAivSmlcCpwopA57MWQeeXnULcCzn9G+koPANuu+pRSmcBTwDVa66b+du1jne5nfV+fdblSapFSalE0uvVRtYQYUGMPhO+8C3ucBQv/BLfsDe/eakbuHCxaw9p3zciFf50Fnz0Bsy+HqxbBPpdJ0EtWSsEh10HTBjPJ+nAUi5hpKN69BWZfYaY9SJag1ym7BC5+wQTzpy+Dd/5qd4mEECK9rH4D3r/NXLtMkJZ4A8GWmj2llBsT9B7SWj9tra5WSo20avVGApus9RuAsoTDS4GN1vrSPtZvQWt9B3AHQCAQkKo9MXR8uXDK38x8aq/8HBbcCG/+L+x9iZkYdMS0XR/SPR6DisWw8hUzMXT9KvBkms886AfmAlUkv4lHmOa+b/0B9jg7+YLOYOoIm4FYViyAw34Ch1ybvFMd+HLgvKfgn1fASz+Blho48ufJW14hhEgVrQ3mZnX+JPN7VQwIO0bjVMDdwBKt9R8TNj0LXAj81nr+V8L6h5VSf8QM0DIJ+EBrHVNKhZRS+2GagV4AyG1WkZzKZsPFz8OGj+Cdm01zvYV/MoNOTD4OSvc2wa9gkpnKYWsibRDaaEbVrPocKj+DtQvNPGQoM2T8IdfCtLnS9CHVKAVzboSHT4ePHzA1scNB62Z4+CxY/z6c8EfTBDrZub1mpM4XCsxgTOF6OPHP4BzWsxkJIcSueeE6CFXBZS/LYGUDyI6/TAcC5wOfK6U+sdbdiAl5jyulLgXWAacDaK2/VEo9DnyFGcnzSmskToBv0z31wgtsY3AWIWxXupcZcCJUBctegGXzYdE9pskCgMMF/nzw5pgaBK0h1g7RdlODEK5LeDNlwuHUk8xAFuPngD/Phi8lBsyko2D0AfDm70ztXroH9qZKePAbULfSTF2y2yl2l2j7OZxw/O/N/9c3/9eE1nl3myAohBBix3zyCHz2GBz6YyjZy+7SpBU7RuNcSN/97QCO2MoxvwJ+1cf6RcD0gSudEEMkWAx7X2we0Q6oXQ6bvjI1duFa05ShrQGUA5y5prZv9P6QVQJZI6GgHIqmpX8YGG6UgiN/BvccDe/cAnOut7tEg6duFfzjFFMrdu4TqTm6pVJmpDhfnply5aHTzFx83iy7SyaEEKmj+iv49/dhzEFwyI/sLk3akTYnQtjN5YHi6eYhxOh9TTPchX+CPc+BnLJtH5NqNn5sRrREw4XPQcksu0u0a/b7lqlV/+e34P6TTJ++QIHdpRJCiOTX3gxPXGjmAD7tbmkOPwhkaD4hhEg2R99knl/6ib3lGAyrXoP7TgS3Dy5ZkPpBr9OMM+DsR6BmKdxzDDSst7tEQgiR3LQ2NXp1K03QkzmAB4WEPSGESDY5o+HgH8BXz8DyBXaXZuB89gQ8dAbkjIFLXzZ9TtPJ5GPMvFDNNXD30bBpqd0lEkKI5PXOX+Hzx2HODTDuELtLk7Yk7AkhRDI68GoonGruerb1NxVpinjnFjM3Xdm+cPF80/c0HY3Z33y/eBTuPRY2LLK7REIIkXyWPAcv/w9MOwUOvtbu0qQ1CXtCCJGMXBkw9xZo2ggv3mB3aXZePA4L/gte+i/TF/G8p8xIs+mseDpcugAysuD+k9OrdlYIIXbVxo/hqW+aUTdPvR0cEkcGk/zrCiFEsird2zTn/ORB+OJpu0uz49qb4bHz4N1bYJ9vwmn3Dp+pCfLGw6UvQcFEePhMePsvpn+KEEIMZ5vXmLlVA4Wmn7PbZ3eJ0p6EPSGESGZzboCSveG5a6B2pd2l2X4N68xAfX4zvgAAC/NJREFUJctfgON+B8f/n5mbbjgJFsPFL8C0k+Hl/4Z/XWXmzBRCiOGoYb0ZsTjaBuc8Bpkj7C7RsCBhTwghkpnTDafdY4LSo2enRv+91W/CnYebP+znPgn7XmHmpBuOPAE47T449HpTQ/vAXGiptbtUQggxtJo2mqDX2ggXPGPmChZDQiazECLVfHBn/9tnf3NoyiGGTu4YOOMBExSeuBDOfszMz5hs4nF46/fw+q+hYDKc+SAUTra7VPZzOMzk64Xl8Mx34I45JsCXzba7ZEIIMfgaK+CBk82NrguegVEz7S7RsCI1e0IIkQrGHQwn3WzmqXvm2xCP2V2inpoq4aF58PqvYMaZcPnrEvR6mz4PLnkRlAPuPQ7evtkEZCGESFdVn8NdR0KoGs570vRFF0NKavaEECJVzDofwrXwys9Ms8hTbgenzb/GtYbPHocXfgTRDhNIZ104fJttbsuomfCtt+DZ75phx7/+D5z8V8gaZXfJhBBiYK18FR6/EDKC5kZX8XS7SzQsSc2eEEKkkoO+D0f8FD5/Ah47F9pD9pWlYT08ei7883IonALffhv2ukiC3rZ4s+H0++GEP8Cat+HW/WDxP2S0TiFEeojHzdyqD59huiFc9ooEPRtJ2BNCiFRz8A/ghD/Cipfh7mOGfpTOjjC8/hu4ZW9Y9Soc9Usz6mT+hKEtRypTCva5zATk4unw7FXwj1OhZrndJRNCiJ3XUguPnGnmVp10jPnbkF1id6mGNQl7QgiRiva51PR/CG2Evx8Ci+4d/P5fkTb48C4T8t78LZQfD1ctggO/N/ymVRgo+RPgwn/D8b+Hio/gtv3hxRugdbPdJRNCiB2zdD7cdqAZkfn438NZD4E3y+5SDXsS9oQQIlVNOBy+/Q6U7gX/vgbuPRbWfzjwnxOuN5OC3zwDnv+h6V928Qtw+r2QUzbwnzfcOBxmFN3vLoaZ58F7t8FfZsJ/fp8aU20IIYa3+q/h4TPN9EC+XPjmq+Z3mjTpTwoyQIsQQqSyrFFwwbPw6SNmwI+7jzQhcPYVMPHInR/AJdoOq9+ATx6CZS9ArAPGHQrz7oKxB8sf8cGQWWgGuNn7UnjtJnjtl/DOX2C/78Del8gExEKI5BKqgnf+aqaEcrrh6Jtg32+ZZZE0JOwJIUSqUwr2PAemzYUP7oD3/276TPgLoPxYKNsXSveBgnJTi9Sb1tBSAzVLofJTWPU6rH0Hoq3gzzfhY+a5ULz70H+34WjkDDj3cdj4Mbz5f/DGb0wt39STTPPd0Qf0/XMUQoihULfKtEBY/ADEozDjDDjif2RU4SQlYU8IIdKFJ2BG69z/Klj+InzxFCx9Hj5+0Gx3uCFQYEKgxw+RsBlsJVwHbQ3d71MwGWZdABOPgPGHJecE7sPBqJlw9sNmAJ5F98AnD8KXT0NWCUw7BXY7FUpmSX9JIcTga2uCpf82Iweve8f8PdnzHDjoGsgbb3fpRD8k7AkhRLpxuk0t0NSTTK1d3SrY8AHULDPz9LXUQaQFfHkm9HlzTMArnAwjpkGw2O5vIBIVTIRjfw2H/8RcbH35T/jwTnjvVtM/ZvwcE8pH7wf5k6TWTwix6+JxqFthWnosfxHWLIR4BPImmOl/9jxH/lakCAl7QgiRzpQyYaFgot0lEbvK4zfNpWacAW2NsPwlWP06rHrNBECAjGwomQkjdoOCSSbEF0w2NbrSz1II0ZdYBOpXw6Yl5rHxY3ODsHNU4ILJsN+3YcoJpluA/C7popQ6FrgZcAJ3aa1/22u7srYfD4SBi7TWi7fn2IEiYU8IIYRINd5smHG6eWgNtStgw4dQschM4fDRvaaZbidPELJGQtB6ZI00NbvebOuRZZ4zsk2odGaY5rsuLzhccnEnRLLT2vSfi7abAbWi7abfdWuDaaaf+NxaD40V0LjBPEKVgLbeSJkbRVNONK0FxhwgzTS3QinlBG4FjgI2AB8qpZ7VWn+VsNtxwCTrsS9wG7Dvdh47ICTsCSGEEKlMKdMEt3CyGUgHTBOspgqoXW6CYP1qc0EXqoK1b5vleHR7PwBcGd0BUDlBORIeyvQb7LEuYZtymPfYqcC4kyFzKD+rT7qfTVvbtjPH9HPcTh3TzyGp+p36PS6Fv1M8ZgW7CMTazXL/P8BuLq/p+5tdakZvzi6FvHEwYqqpxXP7tu99xGxgpdZ6NYBS6lFgLpAY2OYCD2itNfCeUipHKTUSGLsdxw4ICXtCCCFEunE4zByIOWVmoJ3e4nHoaIb2JtMktK2pezkStmoF2rsvIhNrC3TcemjQsYTXvR+65+sd1e9FcL8HDtFnafoNiP0Gzq1s25lj+j1uqI7pR1J8p36OS9Wfk3Kamy+dN2GcicudNfM+8OWYftmdz95sE+aktn57uJRSixJe36G1viPhdQmwPuH1BkztHdvYp2Q7jx0QEvaEEEKI4cbhsJpuZpm7+kIIIXqLaq337md7X4m5952jre2zPccOCAl7QgghhBBCCLFjNgBlCa9LgY3buY9nO44dEDI+sxBCCCGEEELsmA+BSUqpcUopD3AW8GyvfZ4FLlDGfkCj1rpyO48dEFKzJ4QQQgghhBA7QGsdVUpdBSzATJ9wj9b6S6XUt6zttwPzMdMurMRMvXBxf8cORjkl7AkhhBBCCCHEDtJaz8cEusR1tycsa+DK7T12MEgzTiGEEEIIIYRIQxL2hBBCCCGEECINSdgTQgghhBBCiDQkYU8IIYQQQggh0pCEPSGEEEIIIYRIQykf9pRSxyqllimlViqlfmx3eYQQQgghhBAiGaR02FNKOYFbgeOAacDZSqlp9pZKCCGEEEIIIeyX0mEPmA2s1Fqv1lp3AI8Cc20ukxBCCCGEEELYLtXDXgmwPuH1BmudEEIIIYQQQgxrykzsnpqUUqcDx2itL7Nenw/M1lp/t9d+lwOXWy9nAa1DWlAxHLiAqN2FEKIXOS9FMpLzUiQjOS9Fbz6tdapXjOGyuwC7aANQlvC6FNjYeyet9R3AHUNVKDH8KKUWaa33trscQiSS81IkIzkvRTKS81Kkq1RPqx8Ck5RS45RSHuAs4FmbyySEEEIIIYQQtkvpmj2tdVQpdRWwAHAC92itv7S5WEIIIYQQQghhu5QOewBa6/nAfLvLIYY9aSYskpGclyIZyXkpkpGclyItpfQALUIIIYQQQggh+pbqffaEEEIIIYQQQvRBwp4QO0ApdY9SapNS6ouEdXlKqZeVUius51w7yyiGH6VUmVLqdaXUEqXUl0qpq631cm4K2yilvEqpD5RSn1rn5c+t9XJeCtsppZxKqY+VUv+2Xst5KdKShD0hdsx9wLG91v0YeFVrPQl41XotxFCKAj/UWk8F9gOuVEpNQ85NYa924HCt9R7AnsCxSqn9kPNSJIergSUJr+W8FGlJwp4QO0Br/R+gvtfqucD91vL9wClDWigx7GmtK7XWi63lEOYCpgQ5N4WNtNFsvXRbD42cl8JmSqlS4ATgroTVcl6KtCRhT4hdV6S1rgRz0Q2MsLk8YhhTSo0FZgLvI+emsJnVVO4TYBPwstZazkuRDP4MXAfEE9bJeSnSkoQ9IYRIE0qpTOAp4BqtdZPd5RFCax3TWu8JlAKzlVLT7S6TGN6UUicCm7TWH9ldFiGGgoQ9IXZdtVJqJID1vMnm8ohhSCnlxgS9h7TWT1ur5dwUSUFr3QC8genzLOelsNOBwMlKqTXAo8DhSqkHkfNSpCkJe0LsumeBC63lC4F/2VgWMQwppRRwN7BEa/3HhE1ybgrbKKUKlVI51rIPOBJYipyXwkZa6xu01qVa67HAWcBrWuvzkPNSpCmZVF2IHaCUegSYAxQA1cBPgWeAx4HRwDrgdK1170FchBg0SqmDgLeAz+nug3Ijpt+enJvCFkqpGZiBLpyYm8uPa61/oZTKR85LkQSUUnOAa7XWJ8p5KdKVhD0hhBBCCCGESEPSjFMIIYQQQggh0pCEPSGEEEIIIYRIQxL2hBBCCCGEECINSdgTQgghhBBCiDQkYU8IIYQQQggh0pCEPSGEEEIIIYRIQxL2hBBCCCGEECINSdgTQgghhBBCiDT0/3LG0Qc7zs0vAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# the 'l' col needs to be skipped as it contains only 1 value \n", + "# and causes LinAlg error when calculating the density\n", + "plot_df(df.loc[df.l == 7], drop_cols)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA24AAAF5CAYAAADnHXltAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi41LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvSM8oowAAIABJREFUeJzs3Xd8lfX5//HXlU1CBnskbJAhiKLgwFUn1qKdKmqtbZVatcu2X21rW9tv7bf9/vrVarV1ULXurYUWtWrrHgwXyBBkBgg7g0D25/fHfQ7EGMhJcs657/vk/Xw88riTe3zuC2xDrnw+n+sy5xwiIiIiIiISXGl+ByAiIiIiIiIHpsRNREREREQk4JS4iYiIiIiIBJwSNxERERERkYBT4iYiIiIiIhJwStxEREREREQCTombiIgEnpmNNrN/mVm5mTkzu7gdz54YeebEZueuMzP1wxERkdDI8DsAERGRGNwDHARcB2wD3vAzGBERkWRT4iYiIoFmZjnAUcCtzrk/+h2PiIiIH7RUUkREgq5v5FjuaxQiIiI+UuImIiKBZWb3AGsjX/4sslfNmdnFkePQVp5xZnZd8qIUERFJPC2VFBGRILsdeA+4Efg78HjkvP79EhGRLkUzbiIiEljOuTeBpyNfLnbO3e+cu9/PmERERPygxE1ERERERCTglLiJiIiIiIgEnBI3EREJo1abZ5tZerIDERERSQYlbiIiEkY7I8ceLc4PT3YgIiIiyaDETUREwmhF5HhSi/PfT3YgIiIiyaByyiIiEjrOuaVm9jLwGzPrBZQCpwHF/kYmIiKSGJpxExGRsPoq8ALwPeB6oBKY5mtEIiIiCWLOtbq/W0RERERERAJCM24iIiIiIiIBp8RNREREREQk4JS4iYiIiIiIBJwSNxERERERkYBT4iYiIiIiIhJwoe7jlpaW5rp16+Z3GCIiIiIiElC7d+92zrnQT1iFOnHr1q0b1dXVfochIiIiIiIBZWZ7/I4hHkKfeYqIiIiIiKQ6JW4iIiIiIiIBp8RNREREREQk4EK9x01ERERERBKvvr6e0tJSampq/A5lv3JycigpKSEzM9PvUBIilImbmU0HpmdnZ/sdioiIiIhIyistLSU/P5+hQ4diZn6H8ynOObZv305paSnDhg3zO5yECOVSSefcHOfczPT0dL9DERERERFJeTU1NfTq1SuQSRuAmdGrV69Azwh2VigTNxERERERSa6gJm1RQY+vs5S4iYiIiIhIUlxyySUsWbLE7zBCKZR73EREREREJHxmzZrldwihpRk3ERERERGJu+rqas4880wmTpzI+PHjeeSRRzjxxBNZsGABAN27d+fqq6/m8MMP55RTTmHevHmceOKJDB8+nNmzZ/scffAocRMRERERkbh79tlnGThwIO+//z6LFy9m2rRpn7heXV3NiSeeyMKFC8nPz+faa6/l+eef56mnnuIXv/iFT1EHlxI3v+zaAhveAef8jkREREREJO4mTJjACy+8wNVXX82rr75KYWHhJ65nZWXtTeYmTJjACSecQGZmJhMmTGDNmjU+RBxs2uPmhw+fhicugaZ6GHocjP4spEcaBU651N/YRERERETi4KCDDmLhwoXMnTuXn/zkJ5x22mmfuJ6Zmbm3EmRaWhrRHs1paWk0NDQkNVYzmwbcBKQDs5xzv2txfQxwNzAJ+Jlz7g8trqcDC4ANzrnPJSJGJW7JVr4enroMBh4Go6fBi7/2zo8729+4RERERETiaOPGjfTs2ZMLL7yQ7t27c8899/gdUqsiSdetwKlAKTDfzGY755qXv9wBfBf4/H6G+R6wFChIVJxaKplsL/2Pd/zyXXDcD2HS12DtG7B7h79xiYiIiIjE0aJFi5gyZQqHHnoo119/Pddee63fIe3PFGClc26Vc64OeBj4xKyKc26Lc24+UN/yYTMrAc4EEloyUzNuyVS9HRY9DpO+CkWDvHMnXA3v3Avr3/KWTIqIiIiIpIDTTz+d008//RPnXnrppb2f79q1a+/n11133Sfua34tDjLMbEGzr+9wzt3R7OtiYH2zr0uBI9sx/h+B/wLyOx5i25S4JdPix6GxFo745r5zhcXQdyyUzoeDpu3/WRERERER6YgG59wRB7hurZyLqYKgmX0O2OKcW2hmJ3YkuFhpqWQyLZkNfcZCv3GfPF88CWqrYOcaX8ISEREREenCSoFBzb4uATbG+OxU4CwzW4O3xPIkM7s/vuF5lLgly+4dsO4NGDv909d6j4G0dNi8OPlxiYgE3bw7932IiIjE33xglJkNM7Ms4Dwgpg7gzrmfOOdKnHNDI8/92zl3YSKC1FLJZFn7BrgmGHHSp69l5kDPEbBlWfLjEhERERHpwpxzDWZ2JfAcXjuAu5xzH5rZZZHrt5lZf7xy/wVAk5l9HxjnnKtMVpxK3JJl7euQkeMti2xN71Gw7J9QuQkKBiQ3NhERERGRLsw5NxeY2+Lcbc0+L8NbQnmgMV4CXkpAeICWSibP2tehZDJkZLd+vdco77j6leTFJCIiIiIioRCoxM3M8sxsYaQ6S+qoqYCyRTBk6v7vKRjozciVzkteXCIiIiIiIfHss88yevRoRo4cye9+9zu/w0m6hC6VNLO7gGiJzPHNzk8DbsJbQzrLORf9m78aeDSRMfli3dve/rYhx+z/HkvzWgNsWJi8uEREREREOuDeN9fEdbyLjh56wOuNjY1cccUVPP/885SUlDB58mTOOussxo0bd8DnUkmiZ9zuAT7RnMzM0oFbgTOAccAMMxtnZqcAS4DNCY4p+da9AWkZ3lLJAykcDGWLoaE2OXGJiIiIiITAvHnzGDlyJMOHDycrK4vzzjuPv//9736HlVQJTdycc68AO1qcngKsdM6tcs7V4fU7OBv4DHAUcD5wqZm1GpuZzTSzBWa2oKGhIYHRx9GmD7wm21m5B76vaDA01XvJm4iIiIiIALBhwwYGDdrXaq2kpIQNGzb4GFHy+VFVshhY3+zrUuBI59yVAGZ2MbDNOdfU2sPOuTuAOwDy8vJi6mjuu7JFMOrUtu8rjPyPccNCKDk8sTGJiIiIiISEc5/+sd/MfIjEP34kbq39De/9L+Gcuyd5oSRB1Wao3gL9xrd9b04hdO+nfW4iIiIiIs2UlJSwfv2+uZ/S0lIGDhzoY0TJ50dVyVJgULOvS4CNPsSRHGWLvGP/CW3fawbFhytxExERERFpZvLkyaxYsYLVq1dTV1fHww8/zFlnneV3WEnlR+I2HxhlZsPMLAs4D5jdngHMbLqZ3dHY2JiQAONqczRxi2HGDWDARNi+Eup2Jy4mEREREZEQycjI4JZbbuH0009n7NixnHPOORx88MF+h5VUiW4H8BBwItDbzEqBXzrn/mpmVwLP4bUDuMs592F7xnXOzQHm5OXlXRrvmOOubJFXLbJbj9ju7zsWcLBtOQw8LKGhiYiIiIh0RFvl+xPhs5/9LJ/97GeT/t6gSGji5pybsZ/zc4G5iXx3YJQtin22DaBvpBfFlmVK3EREREREBPBnqWSnhWapZH2Nt+wxlsIkUT2GQXoWbFmSuLhERERERCRUQpm4OefmOOdmpqen+x3Kge34GFwT9Bkd+zPpGdB7NGxZmri4REREREQkVEKZuIXGthXesfeo9j3XdyxsXRb/eEREREREJJSUuCVSNHHrNbJ9z/UdCxXroaYy/jGJiIiIiEjohDJxC80et+0roKAEsvLa91zfsd5Rs24iIiIiIkJIE7fQ7HHbtgJ6t3O2DaDPGO+ofW4iIiIiIgB84xvfoG/fvowf347Cfykkoe0AujTnvMTt0FY7IhxY0WBIz/YqUoqIiIiIBM28O+M73pS22zNffPHFXHnllVx00UXxfXdIhHLGLRR2bYa6KujVzsIkAGnp0HM4bP84/nGJiIiIiITQ8ccfT8+ePf0OwzeacUuUvRUlO7BUEqDXiK4149bytzYx/NZFRERERKSrCOWMWyiKk2z7yDv2Pqhjz/caATtWQVOA/4wiIiIiIpIUoUzcQlGcZMcqyMiB/IEde77nCGis89oCiIiIiIhIlxbKxC0Udq6BHkMhrYN/xdHeb9rnJiIiIiLS5SlxS5Sda73EraOUuImIiIiI7DVjxgyOPvpoli9fTklJCX/961/9DimpVJwkEZyDnath6NSOj9G9L2R1hx1K3EREREQkYHwoJPfQQw8l/Z1Bohm3RNi9Hep2dW7GzazrVZYUEREREZFWhTJxC3xVyZ1rvGOPYZ0bp6cSNxERERERCWniFviqknsTt6GdG6fHUKgoVUsAEREREZEuLpSJW+DtWO0diwZ3bpweQ6CpASo3dD4mEREREZFOcM75HcIBBT2+zlJxkkTYuQa694es3M6NE52x27m280mgtG3enZ/82odNtyKfoP9NiohIQOTk5LB9+3Z69eqFmfkdzqc459i+fTs5OTl+h5IwStwSIdrDrbOKhuwbb9hxnR9PRERERKQDSkpKKC0tZevWrX6Hsl85OTmUlJT4HUbCKHFLhHglWoUlYGlQvrbzY4mIiIiIdFBmZibDhnWy8J50iva4xVtjvbcnrXBQ58dKz4SCEm+ppIiIiIiIdFmhTNwC3Q6gciPgoCgOiRt4BUo04yYiIiIikjBmNs3MlpvZSjO7ppXrY8zsTTOrNbMfNTs/yMz+Y2ZLzexDM/teomIMZeIW6HYAFaXesTBO62t7DNGMm4iIiIhIgphZOnArcAYwDphhZuNa3LYD+C7whxbnG4AfOufGAkcBV7TybFxoj1tH7a/a297ELU4zbkVDYVcZ1O+BzG7xGbMlVa4LDv23EBEREUm2KcBK59wqADN7GDgbWBK9wTm3BdhiZmc2f9A5twnYFPm8ysyWAsXNn42XUM64BVrFeu9YUByf8XpEKkuWr4vPeCIiIiIiXUuGmS1o9jGzxfViYH2zr0sj59rFzIYChwFvdzTQA9GMW7xVlEJu7873cIva2xJgLfQZHZ8xRURERES6jgbn3BEHuN5aY7p2dfM2s+7AE8D3nXOV7Xk2Vppxi7eK0vjtb4NmM27a5yYiIiIikgClQPN9TiXAxlgfNrNMvKTtAefck3GObS8lbvEW78Stez/IyPF6w4mIiIiISLzNB0aZ2TAzywLOA2bH8qCZGfBXYKlz7oYExqilknHlnLfHbfiJ8RvTzFsuqcRNRERERCTunHMNZnYl8ByQDtzlnPvQzC6LXL/NzPoDC4ACoMnMvo9XgfIQ4KvAIjN7LzLkT51zc+MdZygTNzObDkzPzs72O5RPqqmAul3xnXED9XITEREREUmgSKI1t8W525p9Xoa3hLKl12h9j1zchXKpZGD7uMW7h1tUUaSXm2vXHkkREREREUkRoUzcAivePdyiegyB2kqoKY/vuCIiIiIiEgpK3OIp2sMt3jNu0UQwmhiKiIiIiEiXosQtnipKIT0L8vrEd1wlbiIiIiIiXZoSt3iqKIWCYkiL819rkRI3EREREZGuTIlbPMW7h1tUbm9Iz4bydfEfW0REREREAk+JWzxVlMa/MAl4M3iFxZpxExERERHpopS4xUtjA1RtTMyMG3jjKnETEREREemSlLjFS9UmcE0JTNwGKXETEREREemilLjFS9Um71hQnJjxC0u8dzTWJ2Z8EREREREJLCVu8RJN3PL7J2b8whLAQeXGxIwvIiIiIiKBpcQtXqrKvGP+gMSMv7eX2/rEjC8iIiIiIoGV4XcAHWFm04Hp2dnZfoeyT9UmSMuE3J6JGV9NuEVEREREuqxQzrg55+Y452amp6f7Hco+VWXebJtZYsYvjOyd04ybiIiIiEiXE8rELZCqNiVufxtAZjevEbdm3EREREREuhwlbvFSVZbYxA3Uy01EREREpItS4hYvVZsSV5gkqrAEyrVUUkRERESkq1HiFg+NdVBTkYQZt0gTbucS+x4REREREQkUJW7xUFPpHRM941Y0COqrYc/OxL5HREREREQCRYlbPNRWeMdk7HED7XMTEREREelilLjFQ7Jm3JS4iYiIiIh0SUrc4mFv4paEPW6gxE1EREREpItR4hYPtZWQ0Q1yChP7ntzekJ4NFesS+x4REREREQkUJW7xUFPpzbaZJfY9aWlQWKwZNxERERGRLkaJWzzUViR+f1uUmnCLiIiIiHQ5StzioaYSCpKVuA1W4iYiIiIi0sUocess57w9bsmccasqg4a65LxPRERERER8p8StsxpqobEu8RUlowpLAAdVG5PzPhERERER8Z0St86qTVIPtyj1chMRERER6XKUuHVWTYV3TNqMm3q5iYiIiIh0NYFJ3MxsrJndZmaPm9m3/Y4nZkmfcSv2jhXrk/M+ERERERHxXUITNzO7y8y2mNniFuenmdlyM1tpZtcAOOeWOucuA84BjkhkXHFVE0ncuvdLzvsyu3mNuDXjJiIiIiLSZSR6xu0eYFrzE2aWDtwKnAGMA2aY2bjItbOA14AXExxX/NRWQkYOZHdP3jvVy01EREREpEtJaOLmnHsF2NHi9BRgpXNulXOuDngYODty/2zn3DHABfsb08xmmtkCM1vQ0NCQqNBjV1MB2QXJfacSNxERERGRuGltRWCL62PM7E0zqzWzH7Xn2XjJSNTAB1AMNN+gVQocaWYnAl8EsoG5+3vYOXcHcAdAXl6eS1yYMaqthJxkJ26DYNVLXg85s+S+W0REREQkhTRbEXgqXm4y38xmO+eWNLttB/Bd4PMdeDYu/EjcWss0nHPuJeCl5IYSBzUV0GNYct9ZWAJ1u6CmHLr1SO67RUT80NQI696EskVwyDkw9Fi/IxIRkdSxd0UggJlFVwTuTb6cc1uALWZ2ZnufjRc/qkqWAoOafV0ChLObtHM+zbipl5uIdCHOwaLHYMnT8N6D8LfpsGy/CzNERERayohutYp8zGxxvbUVgcUxjt2ZZ9vFj8RtPjDKzIaZWRZwHjC7PQOY2XQzu6OxsTEhAcasfrf3W+DswuS+V73cRKQr2bIENiyAkafA1Wug/wSY/R3YU+53ZCIiEg4Nzrkjmn3c0eJ6qysCYxy7M8+2S6LbATwEvAmMNrNSM/umc64BuBJ4DlgKPOqc+7A94zrn5jjnZqanp8c/6PaItgLQjJuISGI4B8ufgby+MPJUr4Lv9Jth9zaYP8vv6EREJDV0ZkVg0lYTJnSPm3Nuxn7Oz+UABUhCI9p8O9lVJfP6QHqWmnCLSOpb+zrsKoMJ50Ba5Jd1Aw/1Zt/m3QFTvw/pfmzXFhGRFLJ3RSCwAW9F4PlJeLZd/Fgq2WmBWSpZU+Edkz3jlpYGBcWacROR1Pfu/V6vzIGHffL8pK/Brs1ehV0REZFO2N+KQDO7zMwuAzCz/mZWClwFXBtZTVgQj9WEsQrlrymdc3OAOXl5eZf6GohfM26gXm4ikvoaar0iJP3GQ3rmJ68ddDrkFMHix2HUKf7EJyIiKaO1FYHOuduafV6GtwwypmcTIZQzboFRUwmZuZ/+gSIZCgcpcROR1LbmVaitgAGHfPpaRraXvH30nFckSkREJMUpceuM2krISXJFyajCEqjaBI31/rxfRCTRVr7oLZPsNar16wdNgz07oHR+cuMSERHxQSgTt0DtcfNjmSR4iZtr8pI3EZFUtPIFGHLM/lc1DD/RO655NVkRiYiI+CaUiVtg2gH40Xw7Si0BRCSV7doC2z7al5y1Jrcn9B0Ha99MVlQiIiK+CWXiFgiuCWqrfJxxUxNuEUlh6+d5x0FHHfi+wUfD+rehsSHxMYmIiPhIiVtH1VV7yZtvM27F3lG93EQkFa1/2+tXOWDige8bcgzU7YLNi5ITl4iIiE+UuHVUtIdbtk/FSbLyoFtPzbiJSGpaP89L2jJzDnzf4KO949o3Eh+TiIiIj0KZuAWiOElNpIebXzNuoF5uIpKaGupg47sw6Mi27y0shqIhStxERCTlhTJxC0RxEj+bb0epl5uIpKKyD6CxFgZNie3+ksmw8b3ExiQiIuKzUCZugVBTARhk5/sXg2bcRCQVRQuTlMSYuA04BCpLoXp74mISERHxmRK3jqqthKzukObjrF9hiRdHdL+diEgqKPsAuveDggGx3d//kMhz7ycuJhEREZ8pceuoGh97uEWpl5uIpKKyxdBvfOz3RytPbvogMfGIiIgEgBK3jqqt9Hd/G6iXm4iknoY62LoM+rcjccvt6X0/LFPiJiIiqSuUiVtgqkoGZsZNvdxEJEVs+wia6qHfhPY91/8QzbiJiEhKC2Xi5ntVycZ6r+Gr3zNu3ftBWiZUbPA3DhGReNm82Du2Z8YNvAIl21dC7a74xyQiIhIAoUzcfLdrC+Agx6fm21FpaVAwUEslRSR1lC2C9GzoNap9z/U/BHCwZUlCwhIREfGbEreOqCrzjn7PuIF6uYlIatm8GPqOgfSM9j3Xd4x33Los/jGJiIgEgBK3jqja5B393uMG6uUmIqll84ftqygZVTQEMnJg6/L4xyQiIhIAStw6ImiJW+UGaPKxUIuISDzs3gHVW6HPmPY/m5YOvUcpcRMRkZSlxK0jqsrA0rwG3H4rLAHXuG/5pohIWG1b4R37jO7Y833GKHETEZGUFcrEzfd2AFVlkJ3vJW9+Uy83EUkV2yJJV+92FiaJ6j0aKtapsqSIiKSkAGQe7ed7O4CqjcEoTALq5SYiqWPbR15FyaIhHXs+OlO37aP4xSQiIhIQoUzcfFdV5n8rgKjCYu+oGTcRCbutH0Gvkd5+tY6I7o1T4iYiIilIiVtHVG0Kzoxbdj7kFClxE5Hw2/YR9Dmo48/3HAZpmWoJICIiKUmJW3vV18CencGoKBmlXm4iEnb1NVC+Fnp3InFLz4ReI1SgREREUpISt/baFaDm21Hq5SYiYbfjY3BNnUvcAHqOgB2r4hOTiIhIgChxa69o2f2g7HGDSOKm4iQiEmLRfWmdTdx6DYcdq6GpqfMxiYiIBIgSt/aKNt8O2oxbTTnUVvkdiYhIx2z/2Dv2GtG5cXoOh8Zar/qviIhICgll4uZrH7e9M24BS9wAyjXrJiIhtWM1dO8PWXmdG6fncO8YTQRFRERSRCgTN1/7uFVtgvQsyMxN/rv3p8cw71i+1t84REQ6ascqrypkZ/UcsW88ERGRFBLKxM1XVWWQ3x/M/I5knx6RZrU71/gahohIh+1cvW+2rDMKir0m3krcREQkxShxa6+qTZA/wO8oPim3F2TmwU7NuIlICNVVe99b4zHjlpYGPYYqcRMRkZQTU+JmZuMTHUhoRGfcgsTMm3XTUkkRCaPoaoEecUjcwCtwosRNRERSTKwzbreZ2Twzu9zMihIaUdBVlQVvxg283zBrxk1EwmjHau8Yj6WS0XHUEkBERNrBzKaZ2XIzW2lm17Ry3czs5sj1D8xsUrNrPzCzD81ssZk9ZGY5iYgxpsTNOXcscAEwCFhgZg+a2amJCCjQandBbWXwZtwAioZ4v7V2zu9IRETaJzo7Fo+lktFxGvbArrL4jCciIinNzNKBW4EzgHHADDMb1+K2M4BRkY+ZwF8izxYD3wWOcM6NB9KB8xIRZ8x73JxzK4BrgauBE4CbzWyZmX0xEYEF0q7N3jGQM25DoL4adm/3OxIRkfbZsQq69fA+4iFaWVItAUREJDZTgJXOuVXOuTrgYeDsFvecDdzrPG8BRWYWTQoygG5mlgHkAglpJhrrHrdDzOxGYClwEjDdOTc28vmNiQgskCoj/w2COuMGWi4pIuETr4qSUdGxtM9NREQ8GWa2oNnHzBbXi4HmDZFLI+favMc5twH4A7AO2ARUOOf+Fd/wPbHOuN0CvANMdM5d4Zx7B8A5txFvFq5riDbfzh/obxytibYEKF/jaxgiIu22Y1V8E7fCEq/fphI3ERHxNDjnjmj2cUeL6631+Wq5/6jVe8ysB95s3DBgIJBnZhd2PuRPizVx+yzwoHNuD4CZpZlZLoBz7r5EBBZIVZu8o2bcRETio6EOKkrjV1ESIC1dLQFERKQ9SvFqeUSV8Onljvu75xRgtXNuq3OuHngSOCYRQcaauL0AdGv2dW7kXNdSVeb1S8vO9zuST8vuDrm91YRbRMKlfB24pvjOuEGksqQSNxERicl8YJSZDTOzLLziIrNb3DMbuChSXfIovCWRm/CWSB5lZrlmZsDJeNvL9svMnjCzM82sXT21Y705xzm3K/pF5PPc9rwoJVRt8mbbrLWZ0gBQLzcRCZu9FSXjnLj1GKZKuyIiEhPnXANwJfAcXtL1qHPuQzO7zMwui9w2F1gFrATuBC6PPPs28DjetrJFePlVy6WYLf0FOB9YYWa/M7MxscSZEeOfp9rMJkX3tpnZ4cCeGJ+NOzObDkzPzs5O7ouD2sMtqmgIbHzX7yhERGIX71YAUUWDoW4X7NkJuT3jO7aIiKQc59xcvOSs+bnbmn3ugCv28+wvgV+2410vAC+YWSEwA3jezNbjJYT3R5ZcfkqsM27fBx4zs1fN7FXgEbys1BfOuTnOuZnp6enJfXF0xi2oegz19oo0NfodiYhIbHau9pag5/WJ77jRgk1aPi4iIgFkZr2Ai4FLgHeBm4BJwPP7eyamGTfn3PzIFN5ovIoqy/aXCaYs5yIzbkFO3IZAU73XtqBoUNv3i4j4rXyd90uneC9BLxq8b/ziSfEdW0REpBPM7ElgDHAfXpu1SAVEHjGzBft7LtalkgCTgaGRZw4zM5xz93Yw3uCYd+e+z6dcuv/7aiqgYU/wl0qC9xtmJW4iEgbl6xLz/ap54iYiIhIssyJLM/cys2znXK1z7oj9PRRrA+778BrLHYuXwE0G9jtoStrbwy3AM27RPSI7V/sbh4hIrMrX7Uuy4imnEHKKVLBJRESC6DetnHuzrYdinXE7AhgX2ZTXNVVFWjkEecatcJDXdHb7x35HIiLStj3lUFuZmMQNvHE14yYiIgFhZv2BYqCbmR3GvqbeBcRQsT/WxG0x0B/Y1NaNKasy8kcvCHDitrfprBI3EQmBaFKVyMRt24rEjC0iItJ+p+MVJCkBbmh2vgr4aVsPx5q49QaWmNk8oDZ60jl3Vsxhhl0YZtwAeo6A7Wo6KyIhEE3cChO0J7fHUFj5oldcKqj9N0XOzf5AAAAgAElEQVREpMtwzv0N+JuZfck590R7n481cbuuvQOnnKoy6NYDMrv5HcmB9RoBq/4DTU2Q1q5m7CIiyVWx3jtGCyvFW9Fgr6hU9TboHud2AyIiIu1kZhc65+4HhprZVS2vO+duaOWxvWJtB/CymQ0BRjnnXjCzXCDJTdR8Vrkp+LNtAD2HQ0ONN0NYWOJ3NCIi+1e+zuvhlqgG2dGEsHytEjcREQmCvMixe0cejilxM7NLgZlAT2AE3qa624CTO/LSUKraGI7ErdcI77j9YyVuIhJs0VYAiVrGuLclwFoo6VqFkEVEJHicc7dHjr/qyPOxrqW7ApgKVEZetgLo25EXhlblpmAXJonqGUncVKBERIKufG3iCpPAvrF3qiWAiIgEh5n9r5kVmFmmmb1oZtvM7MK2nos1cat1ztU1e1kG0HVaAzQ2QPUWyB/odyRtKyiGjBy1BBCR4Ctfn9jELbs75PZSSwAREQma05xzlcDngFLgIODHbT0Ua+L2spn9FK/nwKnAY8CcjkYaOtVbwDUFu/l2VFoa9BgGO1RZUkQCrKYCasoTm7iBermJiEgQZUaOnwUecs7tiOWhWBO3a4CtwCLgW8Bc4Nr2Rhhae3u4hWDGDbx9bppxE5EgK49UlExUK4CooiHekkwREZHgmGNmy4AjgBfNrA9Q09ZDsVaVbALujHx0PWHp4RbVczis+Bc0NXpNuUVEgibRrQCiigbD8mfUIkVERALDOXeNmf0eqHTONZpZNXB2W8/FWlVyNa3saXPODW93pGFUVeYdwzTj1ljn/WDUY6jf0YiIfFp0+WIylko21sKuzeEoMCUiIl3FWLx+bs3zsXsP9ECsDbib11HOAb6C1xqga6jcCGkZkNvb70hi07NZSwAlbiKBV1PfyLodu1m7fTdbqmrYVdPAnvpGMjd1JzvN0SeniYHdGhlSVUPf/By/w42P8nWQ0Q3yEvx9Nfo9sHydEjcREQkEM7sPr8Xae0Bj5LQjHombc257i1N/NLPXgF+0M84DMrPPA2fitRq41Tn3r3iO32FVm6B7//Ass4n2ctuxiq7Uak8kLPbUNfLqiq288fF23lm3kyUbK2loaq1Qb8Env3zlRfoX5HBISSHHHdSHz4zuQ0mP3KTEHHflaxPbwy1qby+3dTD4yMS+S0REJDZHAOOcc+2q0h/rUslJzb5Mi7wsP8Zn78IrdbnFOTe+2flpwE1AOjDLOfc759zTwNNm1gP4AxCMxK1yY7h+U5s/ALK6w7aP/I5ERCIaGpt4cdkWnn53Ay8t38qe+ka6ZaYzcVAhM48fzuj++QzplUf/ghzyczLolplO/duzqGk0ttams3F3Oit6HMei0nIWrN3Jv5ZsBmBiSSFfPryEsyYWU5ib2UYUAZLoVgBR0eIn5WsS/y4REZHYLAb6A5va81CsSyX/r9nnDcAa4JwYn70HuIVmU39mlg7cCpyK17tgvpnNds4tidxybeR6MFSVQZ/RfkcROzMv3q3L/I5EpMvbUV3HfW+u5aF56yirrKFPfjZfOryYaQcP4MjhPclM3/9MfnY6ZKc7CrMaGJnfwPFThgHgnOPjrdW8uHQzT727gZ///UP+55llzJgymEuOG8aAwm7J+uN1XPk6KJ7U9n2dlZULeX3VEkBERIKkN7DEzOYBtdGTzrmzDvRQrEslP9PRqJxzr5jZ0BanpwArnXOrAMzsYeBsM1sK/A54xjn3TmvjmdlMYCZAVlZWR8Nqn6pNMKLDfwX+6DMGVjzvdxQiXdbWqlpmvbqK+95ay576Ro4f1Ydfn30wJ43pS8YBkrVYmBkj+3ZnZN/uzDx+OB9urOSu11ZzzxtruPfNNZxzxCB+cOpB9O6eHZ8/TLzV7oI9OxLfCiCqaDDsVEsAEREJjOs68lCsSyWvOtB159wN7XxvMbC+2delwJHAd4BTgEIzG+mcu62Vd90B3AGQl5fXrnWhHVK7C2orw9MKIKrPGHjvAdi9A3K7Th0ZEb/V1Ddy5yur+PNLH1Pb0MhZEwdy5UkjGdk3ptXl7WZmjC8u5IZzD+UHpx7E7a98zEPz1jP7vY185+SRXHzMMLIyArY/d28rgCQslYy+Z+O7yXmXiIhIG5xzL5vZEGCUc+4FM8vF2z52QO2pKjkZmB35ejrwCp9Mvtqjtd3ozjl3M3BzB8dMjKrI0tOwJW59x3rHrctgyDH+xiLSBTjneHZxGdfPXUrpzj1MO7g/P542mhF9uicthkE9c/nN5ydw8TFDuf6fS/nt3GU8+c4G/vCViYwvLkxaHG3a2wogwT3coooGw9I56uUmIiKBYGaX4q0g7IlXXbIYuI02qgrGmrj1BiY556oiL7sOeMw5d0kH4y0Fmq+RKQE2xvqwmU0HpmdnJ2EZUDRxC1NxEvBm3AC2LFXiJpJgZRU1/PSpRfx72RbG9M/nwUuO5JiR/rUPGdk3n7u/PoUXlmzmp08t4uxbX+fyE0fw3ZNHHXBPXdIkq4dbVNEgaKqHXWXh6ccpIiKp7Aq8rWNvAzjnVphZ37YeijVxGwzUNfu6DhjazgCbmw+MMrNhwAbgPOD8WB92zs0B5uTl5V3aiRhiUxmdcQvZP/aFJV5lSRUoEUkY5xyPLyzl1/9YQn1jEz//3Di+dvSQTu9hi5dTxvVj8tCe/OofH/Knf6/kjY+3c8v5h/lfvKR8LaRnQ16f5LwvOrNXvl6Jm4iIBEGtc67OIi1xIk2429wCFutPF/cB88zsOjP7JV52eMAGcVFm9hDwJjDazErN7JvOuQbgSuA5YCnwqHPuwxhjSa6qyERgfn9/42ivaGXJLUv9jkQkJZXvrmPmfQv58eMfMLZ/Ac9+73i+eeywwCRtUYW5mdxwzqH8acZhLNtUyZk3v8YrH231N6jy9d4sWLKWLUaLoFR0dHW/iIhIXL1sZj8FupnZqcBjwJy2Hoq1quT1ZvYMcFzk1NedczHt9HbOzdjP+bnA3FjG8FXlJsgugOzk7VOJmz5jYUUwWuGJpJKFa3fwnQffZeuuWq49cyzfmDqMtLQEN5LupOkTBzJuYAHfvn8hX7t7HteeOY5vTB2KJboBdmvK1yVvmSR4SSJ4M30iIiL+uwb4JrAI+BZeTjSrrYfa8+vOXKDSOXcTUBpZ5ugLM5tuZnc0NjYm/mVVm8JXmCSq7xio3uJVlhSRTmtqctz28secc/tbpKcbj192DJccNzzwSVvUiD7defqKqZw2rh///Y8l/OLvH9LQ2JT8QMrXJa8VAEBWHuT28mb6REREfOacawKeBi53zn3ZOXency4+SyUjyyOvBn4SOZUJ3N/RYDvLOTfHOTczPb3NqpmdV7UpfIVJovpEKktquaRIp1XXNvDtBxbyu2eWcfrB/fjnd49j4qAiv8Nqt9ysDP5yweF864Th3PfWWi69dwF76pLwS7Cout2we1tyZ9zASxTVhFtERHxknuvMbBuwDFhuZlvN7BexPB/rjNsXgLOAagDn3EYgMU2JgqZyU/gKk0T1jVSW3KrETaQz1u/YzZf+8gbPL9nMtWeO5dbzJ1GQk+l3WB2Wlmb85Iyx/PYLE3jpo6187a55VNXUJ+fle3u4JakVQFTRYO1xExERv30fmApMds71cs71xOtlPdXMftDWw7EmbnWR6TsHYGZ5HY02VJqaIuWjQzrjVlAMWfmwdbnfkYiE1rzVOzj71tfZUL6Hu78+hUuOG+7PvrAEOP/Iwdx83mG8s24nF8x6mx3VdW0/1FnJbgUQVTTYWyrZ9koUERGRRLkImOGcWx094ZxbBVwYuXZAsSZuj5rZ7UBRpGHcC8CdHQg2LpK2x616KzQ1hHePm5k367Y5mAU7RYLusQXruWDWWxR1y+TpK6ZywkFJKl+fRNMnDuSOiw5neVkV597+Jtt21Sb2hdECIUVJ3OMGXuLWsAeqtyX3vSIiIvtkOuc+9Q+Rc24r3la0A4opcXPO/QF4HHgCGA38wjn3p3YGGjdJ2+NWucE7hrnvT/9DoGyRN3soIjFxzvGnF1fw48c/4MhhvXjq8qmM6BPCyrIxOmlMP+7++mTW79zNhbPepnx3AmfeytdDWiZ0T3KLlWgxFO1zExER/xzoH9g2//FtM3Ezs3Qze8E597xz7sfOuR85555vV4hhtTdxK/Y3js4YcAjUVkL5Gr8jEQmFxibHz/++mP97/iO+cFgxd108mcLc8O5ni9UxI3oz66LJrNpWzVf/Oo/KRO15K1+X3B5uUdGlmRVK3ERE5NPMbJqZLTezlWZ2TSvXzcxujlz/wMwmNbtWZGaPm9kyM1tqZkfv5zUTzayylY8qYEJbMbb5L6dzrhHYbWaFbd2bcioiiVthib9xdEb/Q7zjpg/8jUMkBGrqG/n2/Qu5/611XHbCCP7vKxPJyghWQ+1EOnZUb267cBLLyiq5+K55VNc2xP8lyW4FEFWkGTcREWmdmaUDtwJnAOOAGWY2rsVtZwCjIh8zgb80u3YT8KxzbgwwEWi1MqBzLt05V9DKR75zLj5LJYEaYJGZ/TWSad5sZjfH+Gx4VZZCRo7X/yes+o6DtAwoU+ImciDlu+u4cNbbPL90M9dNH8c1Z4wJTX+2eDppTD/+NOMw3i+t4PIH3qE+3n3ekt18OyqnELIL1ctNRERaMwVY6Zxb5ZyrAx4Gzm5xz9nAvc7zFl7tjwFmVgAcD/wVwDlX55wrT0SQsSZu/wR+DrwCLGz24YukFSep2ODtbwtzBbnMHOgzBja973ckIoG1taqWc29/iw9KK7hlxiQunjrM75B8NW38AK7//Hhe/mgrP31yETH0BI1N/R6o3pL8VgBRagkgItJVZZjZgmYfM1tcLwaa/wNRGjkXyz3Dga3A3Wb2rpnNSlQF/owDXTSzwc65dc65vyXi5R3lnJsDzMnLy7s0oS+q3BDu/W1R/Q+BlS/4HYVIIJVV1HD+rLfYVF7D3V+fzNSRvf0OKRDOmzKYjRU13PziCgYUdeOqUw/q/KAVpd7Rjxk38JZL7lzjz7tFRMRPDc65Iw5wvbVZmpa/tdzfPRnAJOA7zrm3zewm4Bq8Sa+4amvG7enoJ2b2RLxfHngVG8K9vy1qwETvt9yVm/yORCRQSnfu5pzb32RLZS33fnOKkrYWfnDKKM45ooSbX1zBQ/PisDfMr1YAUerlJiIirSsFmv/jVAJsjPGeUqDUOfd25PzjeIlc3LWVuDXPLIcnIoDAamqEqk2pMeM28DDvuPEdf+MQCZA126o59/a3KN9dx/2XHMnkoT39DilwzIzrvzCBEw7qw7VPL+bVFVs7N2B0f5lfM26Fg6CuCvbs9Of9IiISVPOBUWY2zMyygPOA2S3umQ1cFKkueRRQ4Zzb5JwrA9ab2ejIfScDSxIRZFuJm9vP56mvqgxcY7h7uEUNOMTrm1Q63+9IRAJh5ZZdnHP7m+yua+DBS4/i0EFFfocUWJnpadx6wSRG9unOlQ++y+pt1R0frHydVywpf0D8AmyPvS0BtM9NRET2cc41AFcCz+FVhHzUOfehmV1mZpdFbpsLrAJWAncClzcb4jvAA2b2AXAo8NtExHnAPW5Eeg3gzbx1i3xO5GvnnCtIRFCBUJkCrQCiMrtB/wlQusDvSER8t6yskgtnvQ0YD888mtH98/0OKfC6Z2cw62tHcNYtr3HpvQt48vJjKMjpQG+78nXe99S09PgHGYvmLQEGTPQnBhERCSTn3Fy85Kz5uduafe6AK/bz7HvAgfbQxcUBZ9ya9RrId85ltOg14FvSlpSqkqnQfLu5ksmw4R1oTEBfJpGQWLyhgvPueIuMtDQe+dZRStraYVDPXP58weGs2VbN9x9+j8amDizC8KuHW1S0mqVaAoiISAiFsrOsc26Oc25menoCf2u7t/l2CiVu9dWwtdV+gP5yzvtBas1rsOol2LpcCabE3TvrdjLjzrfIy8rg0W8dzYg+3f0OKXSOHtGLX551MP9etoX/fW5Z+weoWO9fKwCAbj0gM09NuEVEJJTaWirZdVVu8P6Bz0mRvS8lkdnb0vnessmg2LYSZl8J69785PmP/w2n/BLGtex9KNJ+b6/azjfumU+f/GweuPQoiou6+R1SaH31qCEs21TJ7S+v4uCBhZw1McZ9wA21XsEnvwqTgNeTU73cREQkpJS47U9FqTfbFubm2831GAq5vWH9PDjiG35H41n+DDz2dcjIhnFf8BLK9AzYtgI2vguPXgRHXganXe+dF+mA11Zs45J751Nc1I0HLz2KfgU5focUeteddTDLy6q45okPGDcgn5F9Y1hyureHm49LJaPvj7YlEBERCZFQLpVMilRpvh1lBkOOhrWv+x2JZ/kz8MhXoe9YuPwtGDoVcgogM9crGjDzJTjqCnj7Nnj6Mq89g0g7/WfZFr7xt/kM7ZXHI986WklbnGSmp3HL+ZPolpnOt+9/h911MSxtji5P9HPGDbw9dtrjJiIiIaTEbX8qUixxAxh6vPfD006ff9u8eQk8/g1vhu2ip6GgldLg6Zkw7bdw8i9h0WMw90fJj1NC7dnFZcy8bwGj++Xz0KVH0bt7tt8hpZT+hTncdN5hrNy6i58+uQjXVlProCRuRYOhphxqKtu+V0REJEBCmbglvKpkQx3s2pw6hUmihh7rHde85l8MtVXwyIWQnQ8zHoKcwgPff9xVMPX7sOAuWHhPUkKU8Jvz/kauePAdJhQXcv8lR9IjL8vvkFLSsaN6c9UpB/H0ext54O02Cn6UrwVLh3yfe2NGl2pqn5uIiIRMKBO3hFeVrNoEuNSbceszBnJ7+Zu4vfAr2LEKvnw35PeP7ZmTfwEjToa5P4bShYmNT0Lv8YWlfO/hdzl8SA/u/eaRFHbrQL8xidkVnxnJiaP78Os5S/igtHz/N0Z7uPm9X1UtAUREJKRCmbglXGWKtQKISkuDIVP9S9zWvQXzZ8GR3/L2tMUqLR2+NMtL9B69CPYc4IdD6dLuf2stP3rsfaaO7M3fvj6F7tkqapNoaWnGjeccSp/8bC5/4B0q9tS3fuPOtf4vk4R9feTUEkBEREJGiVtrotXPCkr8jSMRhh0PFetg+8fJfW9DLcz+jvdD00k/b//zuT3hK/d4s6Fzfxz38CT8Zr26imufXswpY/ty50VH0C0rgX0e5RN65GVxy/mHUVZRw8+e2s9+t/K10MPHHm5R3ftCRo73fVBERCRElLi1Zu8mep/LVifCyJO948oXkvveN2+BbR/B526E7A42Pi4+HE74L1j0KHz4VHzjk9ByznHziyv4zT+XcuaEAfzlwsPJyVTSlmyHDe7BVacdxD8+2MRjC0o/ebF+j7dvuGioL7F9gpm3ZFMzbiIiEjJK3FpTvs7reZaV53ck8ddzOPQaBR89l7x37toKr94Io8+EUad0bqzjfggDJ8E/fgBVZfGJT0LLOcfvn13ODc9/xBcnFXPTeYeSma5va3657PgRHDOiF7+c/SErt+zadyG6nywISyXBi0N73EREJGT0E05rKtYH5weMRBh1mrfPra46Oe97+XdQvxtO/VXnx0rPhC/eAfU18PcroK0S5JKympocv5qzhNte/pgLjhzMH748kQwlbb5KSzNuPPdQcjLT+M5D71JTH6n8G214HYSlkhDp5aYZNxERCRf9lNOa8nWpuUwy6qDToLEWVr+S+HdtWwEL7oYjvg69R8VnzN6j4NRfe8s958+Kz5gSKo1Njp88uYh73ljDJccO4zefH09amvkdlgD9CnL4w1cmsnRTJb9/dpl3cuca71gUkMStaBDs3gZ1u/2OREREJGZK3FpyzitOksozboOPgax8WPbPxL/r+V9CZi6ccE18x518idci4F/Xwpal8R1bAq2mvpErH3yHRxas5zsnjeRnZ47FTElbkJw8th8XHzOUu19fw7+XbfZ+GZaeDd37+R2aJ5pAVpQe+D4REZEACWXiltAG3Lu2QEMNFKZw4paRBaPPgGX/8JqNJ8qa12H5P+HY70P3PvEdOy0NPv8Xr5H349/0ih9Iyquqqefiu+fxzOIyrj1zLD88bbSStoC65owxjB1QwI8e+4Cabau9Wa60gPyTo5YAIiISQgH5V7R9EtqAuyJgm+gTZfyXYM9OWPVSYsZvavJmwwqK4ajLE/OO/H5e8rblQ/hXB1oMSKhsqarh3NvfYsGandx47kQuOW643yHJAeRkpvOnGYdSXdtA2ZrluKAsk4R939/VEkBEREIklIlbQkU30ad64jbiJMgphMVPJGb8D5+Eje/ASddCVm5i3gEw6lQ46gqYfycsnZO494iv1m6v5st/eZPV26qZ9bUj+MJhKdhjMQWN7JvPNWeMoaB2Iyvrevodzj75/SEtQzNuIiISKkrcWkrlHm7NZWTB2OnePrfGOC+XrK+BF34F/SfAIefFd+zWnPJLGHgYPPktKFuU+PdJUi0qreBLf3mTqpp6Hrz0SE4c3dfvkKQdvjapFz1tF7PXZrJmW5Iq2bYlLT3Sy00tAUREJDyUuLVUvh669fD2TqW6Qy+AuirY+F58x337Nm8J0mnXJ2dPS0Y2nPcQdCuCB89Vf7cU8uziMr5y+xtkZ6Tx2GXHcNjgHn6HJO2UFlmOWJbWjx88+h4NjU0+RxShlgAiIhIyStxaKl+X+sskowYfDX3Gwro34jdm9XZ49f/goGkw/IT4jduWggEw42HYUw73fxl270jeuyXunHPc9vLHfPuBhYwdUMDTV0xlZN/ufoclHRFJjs464SjeXVfOX1762OeAIoqG7NvTLCIiEgJK3FqqWL+v4liqM4MjvuGVxI7XkqGXf+819j711/EZrz0GHALn3gfbPoK/nQVVm5Mfg3RaXUMT1zyxiN89s4wzJwzgoUuPok9+tt9hSUdF9g0fN+UIzj50IDe9uIIPSst9DgpvOXzVJmio9TsSERGRmChxa865yIxbgKqfJdrEc73+Sqtf7vxYZYu9htiHfw36jO78eB0x8mSY8SDs+BjuPAk2ve9PHNIh23fV8rW75vHIgvV896SR3HzeYeRkJqB6rCTPzrWQmQe5vfj1WePpk5/NDx55jz11CWjn0h57K0uql5uIiISDErfmdu+A+t2pX5ikuZxCGDLVS3B2dWKGqqkR5nzX2x94ks+l+UeeAl9/BlwT3HkyvHpDYvvVSVy8t76cz/3pNRau28kN50zkqtNGk5amHm2hV77WS5LMKMzN5A9fmcjHW6v5/bPL/I1LvdxERCRklLg111VaAbQ0/ARIz4QVL3R8jPmzYMNCOOP3kBuAst8DD4XLXoXR0+DFX8Gtk2HR416CKYHinOOBt9dyzm1vkp5mPPntY/jiJJX7Txnl66DHvlUMU0f25htTh3HPG2t45aOt/sUV/QWd9rmJiEhIKHFrrqs0324pKw+GHAub3oWda9r//M618OKvYcTJXmPvoMjrDefcBxc8Dlnd4Ylvwh8PgZd+DxUb/I5OgN11Dfz48Q/42VOLOXpEL/7xnWMZX1zod1gSL8553x9aLD//r2mjGdW3Oz9+/H3Kd/s0G15QDJamlgAiIhIaStyaiy6Z6SrFSZobeTLkFHmzUo31sT/XUAePf937AehzN3oFT4LEzGvS/a1X4Zx7ofcoeOm38Mfx8MA5sPQf7fvzStws3lDB5/70Gk+8U8p3Tx7FXRdPpig3y++wJJ727PRajrT4ZVhOZjo3nnso23fV8fO/f+hPbOmZkD9QSyVFRCQ0lLg1t3ONt+erW5HfkSRfRjYc/AXYVQb/+W1szzgHz/3EWyJ59i2fWA4VOGlpMO5suOhp+O67MPV73r6+Ry6AG8Z5M4Z1AWkOnOKamrxS/1/48+vsrm3kgW8eyVWnHkS69rOlnujy81a+N4wvLuT7p4xizvsbmf3+xiQHFtFjaMdWGYiIiPggw+8AOsLMpgPTs7PjXCJ8x2roMSy+Y4ZJv4Nh0JHw2g3QfwKM/+KB73/1D97etmO+4yVFYdFzOJxyHXzmWlj5PLxzr1fAJD0Lhh4LI07yElmJu7Xbq7n6iQ94a9UOzhjfn99+YQI98jTLlrJ2RvcNt/5LnctOGMGLy7bw86cXM2VoT/oX5iQxOLzEbWUn9vaKiIgkUShn3Jxzc5xzM9PT41wmfOdq74f6rmzcF7zk7cmZ8MFjrd/T1AjP/Qz+/Rs45Fw4xYeebfGQngGjz4AZD8Hlb0HfsfDxi14D8W0r/I4upTQ0NnH7yx9z2o2v8OGGSv73S4fw5wsmKWlLdTtXe8ceQ1u9nJGexg3nHEpdQxP/9cQHOOeSFxtAz6HeKoO63cl9r4iISAeEMnFLiKZGb69Dzy484wZeMnP+o5Hk7RJ4+vJ9S4ka6mDli/DXU+HNW2DKTDj7z94yxLDrOwYOuxCO+ra3X2/e7fD8L1SFMg4WlVbw+T+/zv88s4zjD+rD81edwDmTB2FB2w8p8bdjFeT2hpyC/d4yrHcePz1zLK98tJX7307yfrPoCovokk4REZEAC+VSyYSoKYemhq69VDKqWxF89UlvRu3t2+G9B7wfvup2QUONt6H/i3fCIef4HWn89RwBx/0Qls6G12+CTR/Al+8KRouDkNlSWcP/e245j79TSq+8bP58wSTOGN9fCVtXsiO2VQwXHjmY55ds5rf/XMqxI3szrHdeEoJj3/f7Hau9GXcREZEAU+IWVb3dO3b1GbeojGw47b/hyG/Bh0/Dto8gO9+biRt1KmR28zvCxEnP9NoaHHo+/POHcPcZ8NWnoGCg35GFwp66Ru56fTW3/mcl9Y1NzDxuOFecNJKCnEy/Q5Nk27Ha2zfaBjPjf790CKf/8RWuevQ9HvvW0WSkJ2EmP7qEUwVKREQkBJS4Re3e5h014/ZJhSVwzJV+R+GPSRd5swUPngd/Pd1L3nqP9DuqwNpT18gDb6/ltpc/ZtuuOk4/uB8/OWMsQ5M1eyLBUr8HKktj3jfcvzCH//78eL770Lvc/puqcucAACAASURBVMoqrvhMEv6/ltsTsgv27cUTEZEuy8ymATcB6cAs59zvWly3yPXPAruBi51z7zS7ng4sADY45z6XiBhTYHNSnOzeDhk5kD/A70gkSIYeCxf/A+p3ezNvm5f4HVHg7Kyu49b/rOS4//03v/nnUsb0L+Cxy47m9q8eoaStK4tWlGxHwaezJg7kc4cM4MbnP2LxhooEBdaMmdeqQDNuIiJdWiTpuhU4AxgHzDCzcS1uOwMYFfmYCfylxfXvAUsTGacSt6jd271lM6lQaEPia+Ch8PVnIC0d7jkTNr7nd0SBsGRjJdc88QFH/c+L/L/nljN2gJew3X/JkUweqj2BXd6OVd6xnZV6f/P58fTMy+KqR9+jpj4JxYF6DPOWdIqISFc2BVjpnFvlnKsDHgZa9ro6G7jXed4CisxsAICZlQBnArMSGaSWSkbt3g4DDvU7CvFBfWMTmytrKNuexc7a/9/efcdXWZ5/HP/c2QNIwggjCXvvJSAI4kBBRXCg4Kha92ht1Wptf/3119ra6dZKcYuKoqgVRS0iIKDsjUH2DoSVsLLP/fvjDhoxSCDn5Dnj+369zuus53nOpXlCzvXc931dhvySKHfLX8ORolJKfZZSn486jR/j5o13k/D8hYxv/Si7U7oQFxNFfEw0yfExpCbGkpYcS0piHKlJsdRNcvfhVIwj90Ah/1m6g3eXbCc75wAJsVFc1iuT6/s3p23D2l6HJ8Hk28Tt5KafpybF8ffLu3L9Swt4dOoafnNBgIuGpDWHNZ+Az6cLdyIi4SvGGLOwwvNx1tpxFZ5nAFsrPN8G9D3mGJVtkwHkAI8D9wMB/TKkxA3AWrfGTYVJwpa1lh35hazZdZC1uw6ydtchNuw5zI68AnYdKMRnAeofs9dakuKiiYkyxEZHER0Vy1zzB57w/R9Xr/k5t/l+zZyStuX7Vi4uOor0OvE0TkmgYZ0EGtVJoFGKuzVOSaRJagLptROIjgrO5M5ay5pdh/gsexfTsnexZGse1kL3rFQeGtGJ4d2akJqkXmxSif0bISH1lCqyDm6XzjX9mvLcrA2c3T6dfgEI71t1W0BZMRzc4db0iohIOCq11vb+kfcr+yJ27De8SrcxxlwE5FprFxljBp9qgFWhxA2g6CCUlaj5dhg5WFjC0q15LNmSx5It+1m6NY/9R0q+fb9B7Xha1k+mf6v6ZKQlkpGaQKOdM0iL85ES6yMlzkft/jdWnlAdOBNeHcH4/L/D9RMobTaIQ0Wl5B0pIa+ghLwjxeQXlLDvcDG7DhSxM7+AnQcKWbk9n8+yd1FY4vve4aKjDA1rx9M4NZEmZak0SfTROKmMxollNNmWT+PUBOolx9XIyN2R4lLW7DrEwk37WLhpPws372PPoWIAumSkcPc5bRjerQmtGtQKeCwS4vZtqNa/qb+5oAOz1+7hvreX8fEZhtqxAWrOXbGypBI3EZFItQ3IqvA8E9hRxW0uBy42xlwAJAB1jDGvWWuv8XeQStzATZMEVZQMYSVlPpZsyWP2uj3MXrubZdvyKfNZjIE26bU4r2MjOmem0K5hbdqk1yItuZJRovlF339+vFGwOk3g+o/g1ZHw+hXEXPkaqW3Pq9LIk7WWAwWl7MgvYGd+ITvyC9iRV0BOnnu8fE8cn+6IpthX/tlzZwMQHxNF4/JRusapCTQpv29YO4HaCTHUTogtv48hOT6GaGMwhm+TvTKf5XBxKUeKyjhUVEp+QTE784vIyXcjjht2H2ZN7kG27S/Aln8/zqqbyKC2DejTvC6D26XTKCWhSj8LEcAlbhk/dnHzxyXFxfDIFd0ZNfZLHlpeh7/3ClCxkoq93KrQukBERMLSAqCNMaYFsB0YDVx1zDYfAHcZY97ETaPMt9bmAA+W3ygfcbsvEEkbKHFzjrYC0FTJkHKkuJSZ3+zmk1U7+Tw7l4NFpUQZ6JqZyh2DW9G3RT26ZaVQOxD9w2qlu2qT40fCm1fBqJegw/AT7maMISUplpSkWDo0rvPDDeY/h7WwtyiKHQXR7MgYSk5+ATn5hezIc0neV+v3VpjeeaLPgyhjKPuRjeNjomhWL4lumamM6pVF24a16J6VpkRNTl1pMeRtgS6jqnWYXs3SuH1wK56Zvp4hjQsZ0qToxDudrJRMMNGqLCkiEsGstaXGmLuAT3HtAF601q4yxtxW/v5YYAquFcA6XDuAG2o6TiVuUD7iZiAl64SbircKS8r4dNVOPlqew8w1uykq9VE3OY5hXRpxdvt0Tm9Zn5SkGmr0nFQXfvIBvH45TLwORjwD3cdU+7DGQP0EH/UTfHTt3KjSbUrLfOQeLGL3wSIOFpZyqKiEA4WlHCws5UhRKT4LPmux1uKzEBNtqBUfQ1JcDMnx0dRJjKVRnQQapySQkhheBVQkCORvBevzy/Tzu89py/TFq3lwSSo96+2mnh/C+57oWEjNUuImIhLhrLVTcMlZxdfGVnhsgTtPcIwZwIwAhAcocXMO74XEVIhRkYVgZK1l0eb9TFq8jQ+X5XCwqJRGdRIY06cp53dqxGnN04iJ9qgaXGKqa8w9YQy8fxts+RKG/g3ikgL6sTHRUTRJTaRJamJAP0fklJxiK4DKxMVE8Vjv/Qyf3oDfLElh7BnW/xca0pqrCbeIiAQ9JW4Ah3dDcgOvo5Bj5B8pYeLCrbwxfwsb9xwmMTaaYV0acXmvTPq1qEdUsFRijK/tkrfpD8Psx2DzlzD0r9BmiNeRiXjjaF80PxV8apdSyq86HeDPK1KYtHg7l/fycxGRui1h5bv+PaaIiIifKXGzFg7nQt0+Xkci5Vbnx/DKu8t5b8l2Ckt8nNY8jTsGt2JYl8bUig/SUzY6Fs79PbQYBB/d46ZPtjob+v8cWg528x9FTkXBPsjbClGxUJgPCSleR3Ri+9ZDXC2/XhD7aevDTM1J4A8frKJfy7pkpvlxVLteayjMgyP7Tql9gYiISE0I0m/BNagw3/XwSU73OpKI5rPw+c54nltbi3l74omP2c7I7hn8pH8zOjUJgS+qR7U6C+6YBwueg1mPuOIl9dpAp0ug3TDX5F1NfqUqCvNh2QTYvphvW8msmAhnPgCn3xXc59GeNVC/jV8vWEQbeKRXHkOnJ/Grt5fz+k19/TfqXq+1u9+7DpJ0EU9ERIJT0CRuxpiWwG+BFGvt5TX2wYdz3X0tJW5eKC3z8dGKHP41rQHfHIglI6mUBzvnc+Wll4duY+eYODj9Tuh9I3z9Pix6BWb9E774O9Rq5KZQtj3fjcTF1/Y6WglGR/bByxfB7mxoeSY07gGlha6AxtTfQW42jPxX8I7k7l4DzQf4/bBZyWX8fngn7p+0nJe+3MSNZ/ipEvDRxG3PWshS4iYiIsEpoImbMeZF4Gg38c4VXh8KPIErt/m8tfav1toNwI3GmHcCGdMPHFLi5oWi0jLeWbSNf8/cwJZ9R2hTG1eAILOAmCggVJO2imIToNtodzu8F9ZNhW8+hq//A0vGQ3QcdBwJp90IWX2D90u41KyyEnj7eti7FnrfBA3afvfe0L/AjL/AzL+5dVln/sqzMI+r6BAc2Ab1255421Mwqncm//16J3/7ZDWD2tSnTUM/XPxIbQZRMW7ETUREJEgFesTtZeBp4NWjLxhjooFngCG4DuQLjDEfWGu/DnAslTuUCzEJEKeRj5pQUubjnUXbeHLaWnLyC+mWlcr/XNiBcw9NPm6/67CQXO+7JK6sBLbOg1Xvw/K33PS3Fme6L+Uinz8EG2fCyGeh+PD33zMGBj/oRt6m/wmadA++Ijh717r7ACVuxhj+cmlXzn/8C345cSnv3TGA2OpWlY2OcY24lbiJiEgQC+giCWvtF8C+Y17uA6yz1m6w1hYDbwIjqnpMY8wtxpiFxpiFpaWl1Q/ycK4bbdNoR0D5fJb/LN3OkEdn8uC7K2hYJ4HxN/bh/Tv6c16nRuGdtB0rOhaanwEX/hPuyXYVKHcuh3+fCRtnuYI5EplylsOXT0OPa6H7VZVvYwwMfxIatIcP7/lhcue13WvcfYN2AfuIBrXjefiSLqzcfoCnpq31z0HrtYa96/1zLBERkQDwYnV7BrC1wvNtQIYxpp4xZizQwxjz4PF2ttaOs9b2ttb2jonxw4DhoVwVJgkgay3/XbWTYU/M4u43l5IQG83zP+nNe3f0Z2CbBmr8HF8L+t0Ody2C1udC9n9g5TuuebFEFp8PPvwlJKbBkD/++LaxCXDho5C/xU2bDCZ71oCJdiNYATS0cyMu65nJMzPWs2TL/uofsF4rVw3Tp989EREJTl4kbpV9U7fW2r3W2tusta2stTUzZ6zwABQd0Pq2AFm+LY8r/z2XW8YvoqTMx1NjejDl5wM5t2NDJWzHSq4HYyZAq3PcNMplE5S8RZrsD2D7Qpe0VaUkffMB0O0qmPss5G8LfHxVtecbt/4uJvDrVH9/cUca1Ung3onLKCguq97B6rV2BWAObPdPcCIiIn7mReK2Dciq8DwT2HEyBzDGDDfGjCsrq+Yf6qNrMTTi5lc5+QXcM3EpFz89hw17DvHnSzrz318OYni3JsHTNDsYGeNaBrQdCjuWwDdTvI5IaoqvzBUdqd/OrYOsqrMedFNrZz0SuNhO1p61AVvfdqw6CbH8Y1RXNuw5zMNTsqt3sG9bAvhp6qWIiIifeZG4LQDaGGNaGGPigNHABydzAGvtZGvtLdHR0dWLZE/5H2iNuPnFkeJSHp26hrP+OYMPl+dw++BWTL9vMFf3bUZMdYsHRJJW50DT02HDDFg+0etopCaseg92r4bBv4aok/h3LbUp9LoOFo+H/ZsDF19VlZW6dWINaiZxA+jfqj43D2zB+Lmb+XTVzlM/UP027l7r3EREJEgF9Nu0MWYC8BXQzhizzRhzo7W2FLgL+BTIBiZaa1cFMo7j2rMGTBQk1fPk48OFtZZJi7Yx+B8zeHLaWs7t0JBp95zJA0PbUzsh1uvwQo8xrk1AWgu35klfJMObtTDnCTdK1XHkye8/8F53P/dZ/8Z1KvZvAl9JjY24HfWr89vTJSOF+99Zzva8glM7SK2GEFdLlSVFRCRoBbqq5BhrbWNrbay1NtNa+0L561OstW3L17P9OZAx/Kg9a1zSdjJXuOV7Vu88wBX//op7315G49REJt3en6ev6klW3SSvQwttUdGuqmBUDLx3mwomhLPNX7qqov3ugKhT+Ce5ThPofJnrDViQ5//4Tsaeb9x9/cBVlKxMXEwUT43pQWmZj1+8uYTSslP4fTHGFShR4iYiIkEqJOev+W2N2+417iqrnLSDhSU89OHXXPjkbNblHuJvl3Xhvdv706tZmtehhY/ENNcqYNt8WPSS19FIoMz9l/tZd73y1I9x+h1QfAgWv3ribQNp99HErXWNf3Tz+sk8fGkXFmzaz5On2iKgXmslbiIiErRCMnHzyxq30mJX+lnr206Kta4f2zmPzOTFORu58rQspt83mCtPa6rCI4HQbTS0GASf/cG1rpDwkr/NFaHpdQPEVWOUunE3aD4Q5j/n7ejsnrVQuzEkpHjy8SO6Z3B5r0yemr6OL9fvOfkD1GsNeVugtMj/wYmIiFRTSCZufrFnDfhK3ZcMqZJ1uQe56rl53P3mUhrWSeD9Owbw8CVdSE0KfNnviGUMXPgYlBx2VQclvCx9w7V96PmT6h+r9w2ur9uGz6t/rFO1e/V3RT488oeLO9GifjK/fGspew+dZAJWv637eexRZUkREQk+kZu47Sqvh6LE7YQKS8r4+yerGfr4LFbtyOehkZ15/84BdMtK9Tq0yFC/NfT+KSx65bupaBL6fD63Lq3FIKjrh2bV7S+CxLruPPGCrwxys6FhZ28+v1xyfAxPjenB/sMl/Oqd5Vhrq75zekd3v3t1YIITERGphpBM3Pyyxi13FUTFQnID/wUWhuZu2MuwJ2bxrxnrGdE9g8/vG8y1/ZoRrWmRNevMByAuGT5/yOtIxF82feGm5fXww2gbQEy8K2jzzRRvptXu2wilBdCwU81/9jE6NUnhtxd24PPVubwwe2PVd6zX2hUEyv06cMGJiIicopBM3Pyyxm3X19CgnSpKHseBwhIefHcFo8fNpdTn47Ub+/LIFd2oXyve69AiU3J96HsbZE92566EvsXjISEVOgz33zF7XuemgC99w3/HrKpdK929xyNuR/3k9Gac17Ehf/14NYs276vaTjFxLnnL1YibiIgEn5BM3Pwi9+uguDIcjD5dtZMhj87krQVbuGVQSz79xSDOaFPf67Ck3+2uz9Ssf3odiVTXkX0uCe96BcQm+O+4DdpC0/6w+BXXH64m7Vrp+mI2aF+zn3scxhj+MaobTVITueP1xeyp6nq3Bu014iYiIkEpMhO3gv1wYPt36xkEgNzCKO6Yl8at4xeRlhTH+3cO4DcXdCApLsbr0AQgqS6cdhOsfFfFE0Jd9gdQVuSmNvpbz2th3wbYOs//x/4xu1ZBvTb+TUSrKSUxlmev6UnekRJ+9kYV+7uld3SNxIuPBDw+ERGRkxGZidvRqWYacQPchfmJmxI5d2o6n+Uk8Kvz2zH5Z2fQNVPFR4LO6XdBTALMetTrSKQ6VrzjpuQ17u7/Y3cYDjGJsOxN/x/7x+xaGZT/pnZqksKfRnbmqw17eXTqmhPvkN4esN81ExcREQkSIZm4Vbs4ydGKkkH4JaOmbd57mKtn1+P+xWm0r1PCx+fkcudZrYmNDslTI/zVagC9roMVb8OBHK+jkVNxIAc2zYbOl7l2Dycwb+Ne5m3cW/Xjx9eGDhfBqvdqrh9ZYb4rtNIoONa3HWtU7yzG9MniXzPWM/XrXT++8dGZGFrnJiIiQSYkv51XuzhJzlJXTTKCWwGUlvkY98V6zn/8C1bsj+XP3fN4c9BeWtWuRqVOqRl9b3UFKBa+4HUkciq+fh+w0PnywH1G19FQmAdrPg3cZ1T07cWw4EzcAH4/vBOdM+pwz8SlbN57+PgbprWA6DitcxMRkaATkolbteUsc1OUqnC1Oxyt2pHPJf/6koenrGZgmwZMHZLL1S2PoAr/IaJuS2h3ASx8EUoKvI5GTtaKd6BRF1dIJFBaDobkdFj+VuA+o6IdS9x9IKZ++klCbDTPXt2LKGO4dfwijhSXVr5hdAzUb6debiIiEnQiL3ErKXRNYht38zqSGldYUsbfPlnNxU/PISe/gGeu6sm4a3vRKLEKC/YluPS7HY7sdVMmJXTs3wTbF7ppkoEUHQNdRrkRtyNVLIVfHTuWQJ0MqN0w8J9VDVl1k3hidHfW7DrIvROX4fMdp/JmentNlRQRkaATeYlb7iqwZRGXuB1tpP3sjPVc2iODz+45kwu7NsZE6KhjyGt+hpuWNndszZd9l1O3cpK773Rp4D+r25XgK4FV7wb+s7YvhiY9Av85fjC4XToPDuvAxyt38tTn6yrfKL0D5G+BooM1G5yIiMiPCMnErVrFSXKWufsISdwqNtIu81leu7Ev/xjVjdSkOK9Dk+owxq11y10FW77yOhqpqpXvQmYfSGsW+M9q1BUadIBlAZ4uWZAH+9aHTOIGcNPAFlzaM4PHPlvDJysrKfLToIO716ibiIgEkZBM3KpVnGTHUkhIhdSm/g8syPxXjbTDW+fLID4FFr7kdSRSFbmrXcn8LgEsSlKRMW7Ubdt82Ls+cJ+Ts9Tdh1DiZozh4Uu60D0rlV++tYyvdxz4/gZHq2PuXF7zwYmIiBxHSCZu1ZKz1I22hfEUwdyDhdzx+iJuOaaRdmLcKVbhlOAUl+y+mH/9Phw+iXLx4o2V74CJgo4ja+4zu1wBGFg+MXCfcbQwSQglbuCKlYy7thd1EmO4+dWF7DlUoXVCShYkpn03Q0NERCQIRFbiVlLgylZn9PI6koCw1vLWgi2c+8hMPsvOVSPtSNDrBigrhmVveB2J/Bhr3fq25gNrtoBHSga0GOiqSwZqLeT2RZDWHJLqBub4AZReJ4HnftKbPYeKuOXVhRSWlE+/N8ZNNdWIm4iIBJHIStx2LHX9rzJP8zoSv9u05zBXPTePByatoEPjOnxy90A10o4EDTtCVj83XVJFSoLXjiWwb0PNTZOsqOto2L8Rts73/7GthS1zIauv/49dQ7pmpvL4ld1ZsjWPX7y5lLKjlSYbd3MX+spKvA1QRESkXGR9q9+2wN2HUeJWUubj2RmukfbKHfn85dIuTLi5Hy0b1PI6NKkpvX/qikNs/MLrSOR4Vk6CqFjoMLzmP7vjxRCbBEtf9/+x966Hw7uh6en+P3YNGtalMb+9oAOfrNrJnz/Kdi827uZGs3d/421wIiJSI4wxQ40x3xhj1hljfl3J+8YY82T5+8uNMT3LX88yxkw3xmQbY1YZY+4OVIyRl7ilNYdaDbyOxC9WbMtnxNNz+Nsnqzm7fTrT7jmTMX2aEqVO2pGl4wi3Hmfhi15HIpXx+WDVe9D6XPdzqmnxtd05svJdKD7i32Nv+dLdN+vv3+N64KaBLblhQHNenLORF2Zv/K7ysNa5iYiEPWNMNPAMMAzoCIwxxnQ8ZrNhQJvy2y3As+WvlwL3Wms7AP2AOyvZ1y9CMnE75XYA2xaGxWhbQXEZD0/JZsQzs9lzqIix1/Ti2Wt6kV4nwevQxAuxCdD9alj9IRzK9ToaOdaWr+DAdm+mSR7V/WooPgjZk/173M1fQVI9qN/Wv8f1yP9c2JHzOzXkTx99zSc5SRCbrHVuIiKRoQ+wzlq7wVpbDLwJjDhmmxHAq9aZC6QaYxpba3OstYsBrLUHgWwgIxBBhmTidkrtAPK3wcEdIZ+4zVq7m/Men8m4LzZw5WlNmXrPmQzt3MjrsMRrva536zeXjPc6EjnWykkQkwhth3oXQ7MBkNoMlr7m3+Nu+cpNkwyTKr3RUYYnRvege1Yqd7+1nIOp7V1zcRERCXUxxpiFFW63HPN+BrC1wvNt/DD5OuE2xpjmQA9gnj+CPlZIJm6nZGv5/7/M3t7GcYr2HirinolLufaF+cRGRfHWLf34y6VdSEmM9To0CQb127iKhYtedlPzJDiUlbp2De2GQbyH606jotyo28YvYP9m/xzzQI4retK0n3+OFyQSYqN54brTyExLZFJuY3w5y6C02OuwRESkekqttb0r3MYd835lVyCPrfr2o9sYY2oBk4BfWGsPVLJttUVO4rZpDsTVgkbdvI7kpPh8lgnzt3D2IzOZvGwHd57Viil3D6Rvy3pehybBpvcNkLcF1n/udSRy1IbpcGSvt9Mkj+o+BjCwbIJ/jnf0PGtxpn+OF0TqJsfx2k19WRfXnqiyIrZkB+TCqYiIBI9tQFaF55nAjqpuY4yJxSVtr1tr3w1UkJGTuG2e464MR8d4HUmVfb3jAJeP/ZIH311B+0a1+fjugfzq/PYkxKqRtlSi/XBIqg+LXvI6Ejlq+URISIXWQ7yOBFKbQsszXXVJf4zKrpsKtRpBoy7VP1YQapySyK1XXQnAW++/x9Z9fi7sIiIiwWQB0MYY08IYEweMBj44ZpsPgJ+UV5fsB+Rba3OMMQZ4Aci21j4ayCAjI3E7tBt2r3brPELAoaJSHvrwa4Y/PZvNe4/wyKhuvHlLP1qn1/Y6NAlmMXHQ4xr45mM4cOxFIqlxxYdh9UfQaaT72QSD7te4UdlN1WwdUVbqRtxanxs269sqk9W8DSVJDelYtoarn5/HrgOFXockIiIBYK0tBe4CPsUVF5lorV1ljLnNGHNb+WZTgA3AOuA54I7y1wcA1wJnG2OWlt8uCEScoTP8VB2b57j75gO9jeMErIVPVuTwh8lfs+tgIWP6NOX+89uRmhQkX/ok+PW6HuY8DovHw+AHvI4msq2eAiWHocsVXkfynQ7DXRXIeeOg5eBTP872RVCYD63P8VdkwckYYpv14dxty7k/v4jR4+Yy4eZ+NEpRBV8RkXBjrZ2CS84qvja2wmML3FnJfrOpfP2b30XGiNvmOa6sc5PuXkdyXJsORfPTL+ty++uLSUuOY9Lt/Xn4ki5K2uTk1G0Brc6Gxa+4URHxzoqJUCczuJpTxyZArxvgmymwb+OpH2fdVDBR0Oos/8UWrDJPI/7gZt64uhW7DxZx5biv2JFX4HVUIiISgSIjcdv4BTTtC9HBV4HxUFEpf11Zm/M+S2f+3jh+d1FHJt81gJ5NPWjUK+Gh1w2ub9i6qV5HErkO74F106DLZa6iYzA57SaIiob5z53a/tbCqvfd1HMvGorXtMw+AHTzrebVG/uw71Axo8fNZbuSNxERqWFB9o2iak6qAXfeVre+rVVwTenx+SyTFm3j7H/OYOya2gzPLGD6kFxuPKMFMdEh+WORYNFumCsasfBFryOJXKveA1sWXNMkj6rTGDqOdD3/ig6e/P45y2Dv2uColFkTMnq6Pnyb5tCzaRrjb+rL/iPFXPnvr1SwREREalRIZggn1YB7/TR33/rcwAZ1EpZtzeOysV9y79vLaJySwHuDd/NI7zzSE9V/S/wgOhZ6Xgtrp7pCFFLzlk+E9I7QqLPXkVSu3+1QdACWvH7y+654G6JiocPF/o8rGMXEQ9ZpsGk2AN2zUnnjpn4cLCxl1NivWLPrFJJfERGRUxCSidtJWfeZW2fSoJ3XkbD7YBH3v7OMEc/MYeu+Av5xeVfeu2MAPeqWeB2ahJue17lqf4te8TqSyLNnHWybD11GeR3J8WX2hqb9XSGbkpOY8ucrg5XvQpshkFQ3cPEFm+YDYddKOLIPgC6ZKbx1az981jJq7Fcs2rzP4wBFRCQShHfiVlYCG2a6ymcelqw+UlzKE5+tZfA/pvPeku3cMqgl0+87k1G9s4iKCt9S2uKh1CzXO2zJePd7IDVnyXgw0dBtjNeR/LizfgMHc2DRy1Xf55uP4eAO6HplwMIKSs3PACxs+erbl9o3qsOk2/tTNzmOq5+fx+erd3kXn4iIRITwTty2znPTgTwq+ISksAAAEgZJREFUWV1a5mPC/C2c+Y8ZPPbZGga2acCnvxjEby7oQO2E4CuUImHmtJvg0C5XSEJqRlkpLJsAbc5za8mCWYuBbiRp1iOutH9VfPmUa+Td/qLAxhZsMnpBTAJsnPW9l7PqJvH2bafTJr02N7+6iIkLt3oUoIiIRILwTtyyP4To+BovTGKtZVr2LoY9MYsH311BVloik24/nbHX9qJlg1o1GotEsNbnQr02MPcZVwlQAm/tf12y3PNaryOpmiF/dBUwpz984m23zoetc+H0uyA6MlqAfismHpr2c03Hj1G/VjwTbulH/1b1uP+d5fz149X4fPp9ExER/wvfxM1aWP2hG22Lr7lkaenWPMY8N5cbX1lIqc8y9pqeTLq9P72aRdB6EAkOUVGuCMWOJd+b4iUBtGQ8JKe7EbdQkNETev8U5o9z58nxWAuf/8mV/+9+dc3FF0xaD4E931Ra8KdWfAwvXn8aV/VtytiZ67n1tUUcLlIfRRER8a/wTdxylkL+VugwvEY+buX2fG58eQEjn5nD2l2HeGhEJ/77y0EM7dwY4+H6Oolw3ca4L9tfPeN1JOHv4E5Y8yl0HxOUPSOP65z/hVoNYeJ13xbf+IGVk2DjTBj8mxq9EBZU2gxx92sr748YGx3Fn0d25v+Gd2Ra9i4ue/ZL9XoTERG/Ct/ELXuyKxDQdmhAP2bNgRhun5vGRU/NZsGmfdx3Xltm3n8W157enFj1YxOvxSW5htyrP4J9G72OJrwtfAmsz1X0DCWJqXDFeFeo5O3rf1hlMjcbPrwHMk9zo3ORqn5bt75v3WfH3cQYw/UDWvDSDX3YnlfAxU/NZvbaPTUYpIiIhLPwzCx8PljxDrQYFLCS1esPRvPz+amc/1kDZuXG8/Nz2jDrgbO56+w21IqPsPUfEtz63AxR0TDv315HEr5Ki2DhC26KZL1WXkdz8rJOg+FPwsYv4KVhsGUeFB92hW1evhBiE+HyFyNvbVtFxrjpkhtmup/3jzizbQPeu2MAdZPjuPbFeTzx2VqtexMRkWoLz8Rt61zI2xyQctxf7zjAzyYsYcjUdKbmJHBr20PMOn8X9wxpS0piCE2PkshRpwl0utStvzreVDipnlXvweHd0O82ryM5dd3HwOjXYf9mePE8eLgJvH2dm0Z5/UdutCnStR0KJYdhw4wTbto6vRb/uWsAI7tn8Nhna7jupfnsPfTjCZ+IiMiPCc/Lp8smQGwydPBfyeqFm/bxrxnr+Xx1Lslx0dzc5jA3tTlEgwSf3z5DJGDO+AWsmAhzn4Wzf+t1NOHFWvf/tX47aHmW19FUT/sL3UyF1R/Bge3QoIMbRYzkkbaKWg6GhBQ3Etn2/BNunhQXw6NXdKNPi7r8/oNVXPjkbB69ohv9W9cPeKgiIhJ+wu+vcUmB+6PacQTEJVfrUNZaZqzZzbPT1zN/0z7SkmK5d0hbfnJ6c1JWvuyfeEVqQsNO0OFimDcWTr/DFSwR/9g63xVDuvBRN50u1MXXhm6jvY4iOMXEQbsLXWJbWuTaBJyAMYYxfZrSJSOFn7+5hKuen8dNZ7TgvvPbkRAbXQNBi4hIuAjJqZLGmOHGmHFlZWU/fHPFO67pdo9TL1ldWFLGxAVbGfbELG54aQFb9x/hfy/qyJxfn83PzmlDSpKmRIajeRv3fnsLS2c+4H435o71OpLwMuufkFhXyU6k6HQJFOVXabpkRZ0zUvjoZwO5tl8znp+9kRFPzyG/oCQwMYqISFgKyRE3a+1kYHJycvLNx7wB8/8N6R2h2YCTPu6uA4W8Nnczr8/bwr7DxbRvVJu/X96Vkd0ziIsJyRxX5DuNOkP7i9y0vn63adTNH7Yvck23z/nfao/wS4hoOdhNl1zxdpWmS1aUGBfNQyM7c3aHdGaszqVOQkj+CRYREY+E11+NLXNh5wq46PEqT1myFpbuj+WV9cl89J/PKfVZzmnfkJ8OaM7preqpB5uEl8G/dtO8Zj0C5/3J62hC38y/uwS4zy1eRyI1JSYOulwBi1+FYftOqXLxWe3SOatdegCCExGRcBZeidtXT7sroV2vOOGmBwpL+M+S7bwxowHZ+bHUivFxTb9mXN+/Oc3q6cq5hKlGXdw04rljXU+uui29jih07VgCaz6Bs/7HrQuTyNHrOljwnBt163ur19GIiEiECJ/EbedKWP2hW8dznClL1loWb8ljwvwtfLh8B4UlPjqlWP7UPY8RWQXUHjC8hoMW8cDZv4OV78HU/4UrX/M6mtA17SF3oaivRtsiTqMu0KQHLHrFjbZqZoaIiNSA8EncZv4N4utAv9t/8Nb2vAL+s3Q77y3eztrcQyTHRXNJj0yu6tOULjsmehCsiIdqN4IzfgnT/wQbZ0GLgV5HFHrWToX10+C8P7vkTSJPrxtg8s9d0/KWZ3odjYiIRIDwSNy2L4bsD2DQr74tuJBfUMLHK3J4b8l25m10TYd7N0vjL5d2YXi3JtSKL/9P3+FV0CIeOv1O15B78s/htjkQl+R1RKGjtBg+/a2bZqq1bZGr65Xw+Z9gzuNK3EREpEaEfuJmLXz8ACSnc7DXHXy+dDsfr9jJ59/kUlzqo2X9ZO4d0pYR3TNoWk9fTkUAl6iNeBpeGQ7T/wzn/9nriELHl0/Anm9gzFuuUIVEptgE1xPxs/+DHUuhSXevIxIRkTAX8onbofmvUWvbfF6ody9/+/s8ist8pNeO56o+Tbm0ZwZdMlJUGVKkMi0GuQIlXz3jmnM37et1RMFvz1pXSbLTJdBuqNfRiNd6/xRmPeYuflz9ttfRiIhImAvpxM0kpVI65QEW29a8fLg/1/VvwtDOjeiRlUZUlJI1kRMa8kdY+xlMuhFumQHJ9b2OKHiVFsOkmyA2CYb+zetoJBgkpMCg+2Dq72DdNGh9jtcRiYhIGAvprtIZMXkkR5dS68rn+eKBc/jthR3p1ayukjaRqoqvDVe8Aody4Z0boKzU64iC17Q/QM5SGPEM1G7odTQSLPreCmnN3brH0mKvoxERkTAW0olbbVNI7LCHaduph6ZDipyqjJ5w0WOuOt7U33kdTXBa9pbrE3nazdDhIq+jkWASEw9D/wq7s+GLv3sdjYiIhLGQTtzyiqOh941ehyES+npcDX1vg7n/glmPeB1NcNk0Gz64C5oPhPMf9joaCUbthkH3q93vzpa5XkcjIiJhKqQTt50FMWp8KuIv5/8FuoyCaX+EL/7hKrZGus1fwutXQFoLuOJVVZGU4xv6F0htCm9dA3lbvI5GRETCUEgnbhYlbSJ+ExUFI5/9rj/VR/dAaZHXUXknezKMvxRSMuC6yZBU1+uIJJglpMBVE906t9evcOtGRURE/CikEzcR8bPoWBg5FgbcDQtfhBeGwN71XkdVs8pKYNpD8Na10KgzXD9FxUikahq0g9GvQd5meOkC2L/Z64hERCSMKHETke+LinJtAkZPcF88nx0AM/4KxUe8jizwNs2B586GWf90a5aumwy1GngdlYSSFoPgmnfdiNu/B0H2h15HJCIiYSJoEjdjTLIx5hVjzHPGmKu9jkck4rW/AG6f4xpNz/gLPNUTZj0Kh/d6HZl/WesKkEy4Cl6+AI7shVGvwMhnIDbR6+gkFDU7HW6dUb7m7Wp4YzTsXOl1VCIiEuICmrgZY140xuQaY1Ye8/pQY8w3xph1xphfl798KfCOtfZm4OJAxiUiVZSSCaNehhs+gfptXC+zRzvAhDGw5DU3IheKRUzKSmHbIreW75m+8PKFsHkOnPVbuGshdBrpdYQS6uq2hJumwZCHYNMsGDsAXhkOi14Ov4sfIiJh4Dj5ScX3jTHmyfL3lxtjelZ1X3+JCdSBy70MPA28evQFY0w08AwwBNgGLDDGfABkAivKNysLcFwicjKane6mDeZmw6JXYPWH8M0U915yA2jS0yV2ac3dKENSfUhMhcQ0V7QhKrpm4y0thsI8KNgPBXlwaBfs3wj7NsLu1ZCzDEqOgImCrH6uqXanSyEuqWbjlPAWEwcDfg49r4UFz8PSN2Dy3e5Wvx1k9oZ6rVzV0tSmrgBOYhrEp7gpyyIiUiOOl59Ya7+usNkwoE35rS/wLNC3ivv6RUATN2vtF8aY5se83AdYZ63dAGCMeRMYgfsPzQSWEkRTOEWkgvQOMOyvrvT5rpWwdR5sX+xuG2dCaWHl+8UkQnScK35y7L059te9kmqxx77kK3NFRHwlbvSsrPi7x76S48eRWNclmD2vc1+aW52tapESeIlpMOhXMPA+d9Fg3WewbQGsnQpLX69kBwNxyeW/I3Hf/5359iKIqfB7YSq0xqnKYwlKCSlwzSSvoxCJVMfLTyomXyOAV621FphrjEk1xjQGmldhX78I9IhbZTKArRWeb8NlrU8CTxtjLgQmH29nY8wtwC0AcXHqqeQv8za6qTt9W9TzOJLIFjI/B2OgURd3O638NZ8PDudC3la3Tqwwz412FeyHksMu0SorcUnWt/fF3z9updMu7Q+3iYp2X2SjYsu/0FZ4HBUD8XW+G/FLTHWjgqnN3GMRrxgDTbq721FFB2H/Jsjf9t0IccF+NyJcVuxacnz7+1Lkzn9r+fb34mQfS/CKq+V1BCLhLMYYs7DC83HW2nEVnh8vP+EE22RUcV+/8CJxq+ySn7XWHgZuONHO5f+TxwEkJyfrL5FIsIiKgtqN3E1Eqia+9ncXQUREJFBKrbW9f+T9SvOTKm5TlX39wovEbRuQVeF5JrDDgzhERERERESqkp8cb5u4KuzrF16sJVsAtDHGtDDGxAGjgQ9O5gDGmOHGmHFlZaphIiIiIiIi1VKV/OQD4Cfl1SX7AfnW2pwq7usXgW4HMAH4CmhnjNlmjLnRWlsK3AV8CmQDE621q07muNbaydbaW6Kja7hSnYiIiIiIhJXj5SfGmNuMMbeVbzYF2ACsA54D7vixfQMRZ6CrSo45zutTcP/xIiIiIiIinqosP7HWjq3w2AJ3VnXfQFDZfRERERERkSDnRXGSajPGDAeGx8fHex2KiIiIiIhIwIXkiJvWuImIiIiISCQJycRNREREREQkkihxExERERERCXJa4yYiIiIiIhLkQnLETWvcREREREQkkoRk4iYiIiIiIhJJlLiJiIiIiIgEOeOagIcmY4wPKPA6Dgk7MUCp10GIHEPnpQQjnZcSjHReyrESrbUhP2AV0ombSCAYYxZaa3t7HYdIRTovJRjpvJRgpPNSwlXIZ54iIiIiIiLhTombiIiIiIhIkFPiJvJD47wOQKQSOi8lGOm8lGCk81LCkta4iYiIiIiIBDmNuImIiIiIiAQ5JW4SsYwxLxpjco0xKyu8VtcYM9UYs7b8Ps3LGCXyGGOyjDHTjTHZxphVxpi7y1/XuSmeMcYkGGPmG2OWlZ+Xfyh/XeeleM4YE22MWWKM+bD8uc5LCUtK3CSSvQwMPea1XwPTrLVtgGnlz0VqUilwr7W2A9APuNMY0xGdm+KtIuBsa203oDsw1BjTD52XEhzuBrIrPNd5KWFJiZtELGvtF8C+Y14eAbxS/vgVYGSNBiURz1qbY61dXP74IO7LSAY6N8VD1jlU/jS2/GbReSkeM8ZkAhcCz1d4WeelhCUlbiLf19BamwPuCzSQ7nE8EsGMMc2BHsA8dG6Kx8qnoy0FcoGp1lqdlxIMHgfuB3wVXtN5KWFJiZuISBAyxtQCJgG/sNYe8DoeEWttmbW2O5AJ9DHGdPY6JolsxpiLgFxr7SKvYxGpCUrcRL5vlzGmMUD5fa7H8UgEMsbE4pK2162175a/rHNTgoK1Ng+YgVsjrPNSvDQAuNgYswl4EzjbGPMaOi8lTClxE/m+D4Dryh9fB/zHw1gkAhljDPACkG2tfbTCWzo3xTPGmAbGmNTyx4nAucBqdF6Kh6y1D1prM621zYHRwOfW2mvQeSlhSg24JWIZYyYAg4H6wC7g98D7wESgKbAFGGWtPbaAiUjAGGPOAGYBK/huzcZvcOvcdG6KJ4wxXXFFHqJxF30nWmv/aIyph85LCQLGmMHAfdbai3ReSrhS4iYiIiIiIhLkNFVSREREREQkyClxExERERERCXJK3ERERERERIKcEjcREREREZEgp8RNREREREQkyClxExERERERCXJK3ERERERERIKcEjcREREREZEg9/+cgqc4NuWmRAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3UAAAF5CAYAAAA4UwNyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi41LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvSM8oowAAIABJREFUeJzs3Xl43Gd5//v3rd2StXuXLEveF3m3sxCaBAIhCU0CpZT4lH1JgaT8+LFcCS0XP3rOacuhtJwfhZOQAIWWkgClgQQMISwJgZjYju14d+JdI++LZFm29vv88Z1xxopsj6SZ72hGn9d1zTUz3+25leRydPt5nvs2d0dEREREREQyU066AxAREREREZGhU1InIiIiIiKSwZTUiYiIiIiIZDAldSIiIiIiIhlMSZ2IiIiIiEgGU1InIiIiIiKSwZTUiYhIWpnZe83Mzaw+3bGIiIhkIiV1IiIigJktM7PPK7kUEZFMo6ROREQksAz4X0B9muMQEREZFCV1IiIiIiIiGUxJnYiIjDhm1mBm/25mR82s08x2mdmnzSyn33WfMLNnzOxY9LrdZvZ3Zpbf77oSM/t/zGyPmXWY2XEze87M/iJ6/vPAw9HLfxvd4+dm9t4wfl4REZHhyEt3ACIiIvHMbCawBjgL/CtwHLgR+CLB0sh74i7/NPAk8DhwDngt8FmgDnhf3HX/H7AKeADYApQBi4FrgR8A/w3UAh8A/gHYEb3vueT+dCIiIsln7p7uGEREZBSLzob9G9Dg7vvNbDUwF1ji7mfirvsX4OPAHHd/OXqsxN3b+z3vfwGfA+rcvTl67DTwPXePTwj7x/FBgtm617n700n8EUVERFJKyy9FRGTEMLMK4BbgR0CBmY2LvQhm5Ax4fez6WEJnZrlmVhG97rcE/39bFvfoVuBqM5sa0o8iIiISGiV1IiIykswmSNw+RbDsMv71i+g1E2IXm9ktZvYccB44Hb3umejpyrjnfhqYDxwwsw1m9k9mtiKVP4iIiEhYtKdORERGkthfNj5IMFs3kL0AZnYN8DPgeeCvgQjQCdQA3457Fu7+QzN7BrgdeAPwfuCTZvZ5d/8/k/9jiIiIhEdJnYiIjCR7AAfc3X91hWvfAXQBN7n7+dhBM3vTQBe7+zHgm8A3zawYWA18zsz+KXq/NpmLiEhG0vJLEREZMdz9OPBr4D3RKpgXMbMyMyuMfu0lSMRy487nEiy1jL8n18zK+41zDtgZvTd27mz0PX7ZpoiIyIinmToRERlpPgL8AdhoZt8gaC9QDjQCb4u+7wd+AnwC+I2ZfQcYQzB71/8vLEuBZjN7DHgROAUsBT4I/Mbdj0SvW0+QJH4mWrDlPPC8u+9L0c8pIiKSFErqRERkRHH33Wa2jKDf3NuASQRFUF4C/g44Er3uWTNbBfwt8CWCZO2HBG0JtsY98hzwVYK9dG8GCoEm4B8Jet/Fxt1jZvcQFGl5mGAW732AkjoRERnR1KdOREREREQkg2lPnYiIiIiISAZTUiciIiIiIpLBlNSJiIiIiIhkMCV1IiIiIiIiGUxJnYiIiIiISAbL6JYGOTk5PmbMmHSHISIiIiIiI9S5c+fc3bN6Miujk7oxY8bQ3t6e7jBERERERGSEMrPz6Y4h1bI6YxUREREREcl2SupERERERGRUM7NbzGyXme02s/sHOD/XzNaYWaeZfSru+Bwz2xT3OmNmH4+e+7yZNceduy1V8Wfk8kszux24vbCwMN2hiIiIiIhIBjOzXOBrwBuBCLDOzB539+1xl50CPga8Jf5ed98FLIl7TjPwWNwlX3b3L6UwfCBDkzp3fwJ4oqSk5EPpjkVEREREJNt1d3cTiUTo6OhIdyiXVFRURG1tLfn5+YO99Spgt7vvBTCzR4E7gQtJnbsfA46Z2Zsv85ybgD3ufmCwAQxXRiZ1IiIiIiISnkgkQmlpKfX19ZhZusN5FXfn5MmTRCIRGhoa+p/OM7P1cd8fcveH4r7XAE1x3yPA1UMI4y7gkX7H7jWzdwPrgU+6++khPPeKtKdOREREREQuq6Ojg+rq6hGZ0AGYGdXV1ZeaSexx9xVxr4f63z7APT7I8QuAO4Afxh1+AJhBsDzzMPDPg3nmYCipExERERGRKxqpCV3MMOKLAFPjvtcChwb5jFuBDe5+NHbA3Y+6e6+79wEPEyzzTAkldSIiIiIiEooPfvCDbN++/coXhmsdMMvMGqIzbncBjw/yGavot/TSzCbHfX0rsHVYUV6G9tSJiIiIiEgovvGNb6Q7hFdx9x4zuxd4EsgFvuXu28zsw9HzD5rZJIJ9cWVAX7RtwXx3P2NmxQSVM/+q36O/aGZLCJZy7h/gfNJopk5ERERERJKuvb2dN7/5zSxevJjGxka+//3vc+ONN7J+fVCzZOzYsdx3330sX76cN7zhDaxdu5Ybb7yR6dOn8/jjg50oGx53X+3us919hrv/ffTYg+7+YPTzEXevdfcyd6+Ifj4TPXfO3avdvbXfM9/l7gvdfZG73+Huh1MVv5I6ERERERFJul/84hdMmTKFF198ka1bt3LLLbdcdL69vZ0bb7yRF154gdLSUj772c/y1FNP8dhjj/G5z30uTVFnJiV1ITvS2sFze06wJdJKd29fusMREREREUmJhQsX8qtf/Yr77ruPZ599lvLy8ovOFxQUXEj0Fi5cyA033EB+fj4LFy5k//79aYg4c2lP3dqHX/l8Vep6me860sb/9dPt/H73iQvHqkoK+Kvrp/P+1zaQn6v8WkRERESyx+zZs3nhhRdYvXo1n/nMZ7j55psvOp+fn3+hYmVOTg6FhYUXPvf09IQebyZTUheCn2xq5tM/3ExJYS6ffONslk2r5FR7Fz/aEOEff76Tp3cd58F3Lqe8OD/doYqIiIiIJMWhQ4eoqqrine98J2PHjuXb3/52ukPKWkrqUuznWw7z8e9v4qr6Kh5453KqSgounLt98RR+9EKE+/97M+/79lq++8GrKS7QvxIRERERyXxbtmzh05/+NDk5OeTn5/PAAw/wqU99Kt1hZSVzH1Sz9BGlpKTE29vbh/eQFC6/3Bxp4e0PrqGxppz//ODVFOXnDnjdL7Ye5qP/uYE7l9Tw5XcsSWoMIiIiIiLDtWPHDubNm5fuMK5ooDjN7Jy7l6QppFBoI1eKnO/q5eOPbqK6pICH373ikgkdwC2Nk/nYTbN4bGMzj22MhBiliEgGWPvwKy8RERF5FSV1KfKlX+5i74l2/untiy9acnkp975uJivrK/n849s51d4VQoQiIiIiIpINlNSlwO5jbXz7uf2suqqO62aOS+ievNwc/v6tCznb2cM/PbkrxRGKiIiIiEi2UFKXAv+weifF+bl86ubZg7pv9sRS3nNtPY+uO8iuI20pik5ERERERLLJiErqzKzEzF4wsz9NdyxD9cKB0/xm5zE++rqZVI8tHPT9f/36mRTn5/KV37ycguhERERERCTbpDSpM7NvmdkxM9va7/gtZrbLzHab2f1xp+4DfpDKmFLtgad3U1mcz7uvnTak+ytLCnjvdfWs3nKYl45qtk5ERERERC4v1TN13wZuiT9gZrnA14BbgfnAKjObb2ZvALYDR1McU8rsOHyGX+04xvuua6CkcOj95j742ukU5eXy8O/2JjE6EREREZHM9Ytf/II5c+Ywc+ZMvvCFL6Q7nBElpZ2u3f13Zlbf7/BVwG533wtgZo8CdwJjgRKCRO+8ma12977+zzSzu4G7AQoKrlxVMkxff2YPJQW5vOfa+sHd2K9XXmVJAX+2rIYfvhDhM7fNS6h6poiIiIhIWP59zf6kPu/dV/j9ube3l3vuuYennnqK2tpaVq5cyR133MH8+fOTGkemSseeuhqgKe57BKhx9791948D3wMeHiihA3D3h9x9hbuvyMtLaU46KCfOdvKzLYd5+4qplBfnD/t573lNPV09fTyy9mASohMRERERyVxr165l5syZTJ8+nYKCAu666y5+8pOfpDusESMdSZ0NcMwvfHD/trv/NMR4kuKH6yN09zrvvKYuKc+bPbGU62ZW890/HqCnd8D8VkRERERkVGhubmbq1KkXvtfW1tLc3JzGiEaWdCR1EWBq3Pda4FAa4kiavj7ne2sPcHVDFTMnlCbtue+6ZhqHWzt49uUTSXumiIiIiEimcfdXHTMbaK5odEpHUrcOmGVmDWZWANwFPD6YB5jZ7Wb2UG9vb0oCHKxnd5+g6dR53nnN0CpeXsrr506ksjif/9oQSepzRUREREQySW1tLU1Nr+zgikQiTJkyJY0RjSypbmnwCLAGmGNmETP7gLv3APcCTwI7gB+4+7bBPNfdn3D3u3Nzc5Mf9BA8tiFC+Zh8bl4wManPLcjL4Y7FU3hq+1Faz3Un9dkiIiIiIpli5cqVvPzyy+zbt4+uri4effRR7rjjjnSHNWKkuvrlqkscXw2sTuXYYTnX1cMvtx/lziU1FOYlP8l82/JavrPmAD/dcoi/vDq5M4EiIiIiIpkgLy+Pr371q7zpTW+it7eX97///SxYsCDdYY0YI6d85CCY2e3A7YWFhekOhae2H+VcVy9vWZKa6d+FNeXMmjCWxzY0K6kTERERkRHhSi0IUuG2227jtttuC33cTJCOPXXDNpKWX/5k0yGmlBexsr4qJc83M25fPIUXDp7m2JmOlIwhIiIiIiKZKyOTupHiVHsXv3vpOLcvmUJOTuqq79zaOAl3eHLbkZSNISIiIiIimUlJ3TD8fOthevqcOxfXpHScWRNLmTG+hNVblNSJiIiIiMjFlNQNwy+3HaW+uph5k5PXm+5Sbm2czPP7TnLybGfKxxIRERERkcyRkUndSOhT19bRzXN7TnDzgkmhND68deEk+jwozCIiIiIiIhKTkUndSCiU8vSu43T3OjfPT25vukuZP7mMadXF/HyrlmCKiIiIiMgrMjKpGwl+uf0o48YWsLSuMpTxzIw3zJvImr0nOdfVE8qYIiIiIiIjxfvf/34mTJhAY2NjukMZcTKyT126dfb08tudx/jTRZPJTWHVy/5eN2cC3/z9PtbsOclN88KZIQzN2ocv/n7Vh9ITh4iIiIhcWf/f3YYrgd/93vve93Lvvffy7ne/O7ljZ4GMnKlL9566NXtOcrazhzctmBTquCsbKikuyOW3u46FOq6IiIiISLpdf/31VFWlpjd0psvIpC7de+qe3nWcovwcrp1RHeq4hXm5XDdzHL/deRx3D3VsEREREREZmTIyqUu33710nGumV1OUH35S+fq5E2huOc/uY2dDH1tEREREREYeJXWD1HTqHHtPtHPD7PFpGf/GOcG4v9mpJZgiIiIiIqKkbtCeeek4QNqSusnlY5g7qZSndx1Py/giIiIiIjKyKKkbpGdeOk5t5RgaxpWkLYY/mTWOFw6cpqM7fc3XRURERETCtGrVKq699lp27dpFbW0t3/zmN5P2bDO7xcx2mdluM7t/gPNzzWyNmXWa2af6ndtvZlvMbJOZrY87XmVmT5nZy9H3lPVCy8iWBmZ2O3B7YWFhqON29fTx3O4TvGVpDWbhtTLo7zUzx/Hws/tYv/80r501Lm1xiIiIiMgolYb2U4888khKnmtmucDXgDcCEWCdmT3u7tvjLjsFfAx4yyUe8zp3P9Hv2P3Ar939C9FE8X7gvuRGH8jImbp0Vb984cBp2rt607b0Muaq+irycow/7On/342IiIiIiAzSVcBud9/r7l3Ao8Cd8Re4+zF3Xwd0D+K5dwLfiX7+DpdOCIctI5O6dHnmpePk5RivmZne2bGSwjyW1lXw3G4ldSIiIiIiw1QDNMV9j0SPJcqBX5rZC2Z2d9zxie5+GCD6PmHYkV6CkrpB+MPuEyybVsnYwvSvWr12xji2NLfSen4wf1kgIiIiIjLq5JnZ+rjX3f3OD7SvajBNoa9z92XArcA9Znb9kCMdIiV1CWo93822Q61cOz3chuOXct2Mavoc/rj3ZLpDEREREZFRwH0weU74LhNfj7uviHs91O98BJga970WODSIcQ9F348BjxEs5wQ4amaTAaLvKetJpqQuQWv3naLP4doZIyOpW1pXyZj8XNbsUVInIiIiIqlVVFTEyZMnR2xi5+6cPHmSoqKiody+DphlZg1mVgDcBTyeyI1mVmJmpbHPwM3A1ujpx4H3RD+/B/jJUIJLRPrXEWaINXtOUpiXw9K6inSHAkBBXg4rG6r4g/bViYiIiEiK1dbWEolEOH585PZKLioqora2dtD3uXuPmd0LPAnkAt9y921m9uHo+QfNbBKwHigD+szs48B8YBzwWLQyfh7wPXf/RfTRXwB+YGYfAA4Cbx/WD3gZGZnUpaOlwZq9J1k+rZLCvHArbl7OdTOq+cef7+RYWwcTSof0txIiIiIiIleUn59PQ0NDusNIGXdfDazud+zBuM9HCJZl9ncGWHyJZ54EbkpimJeUkcsvw25pcLq9ix2Hz4yY/XQxVzVUAbB+/+k0RyIiIiIiIumSkTN1YXt+X7Bv7aL9dGsfvviiNDRgbKwpZ0x+Lmv3neK2hZOH/qAR8LOIiIiIiMjQKKlLwJo9JxmTn8ui2pGxny4mPzfY47du/6l0hyLJogRbRERERAYpI5dfhm3N3pOsqK+kIG/k/eNaWV/FjsNnaOtQvzoRERERkdFo5GUpI8yJs528dPTsiGll0N/K+ir6HF44oH11IiIiIiKjkZK6K3h+b7C08ZoRViQlZmldBbk5piWYIiIiIiKjlJK6y+nrY92+YD/dwprydEczoJLCPBqnlLFun2bqRERERERGIxVKGcixHfDLz8LeZ/i05/O6sdeR374IyqakO7IBrayv4t//eIDOnt4R1UdPRERERERSLyNn6szsdjN7qLe3N/kPP/AcPPx6OLSR7hUf4qc9V/Oazt/BA9dB07rkj5cEKxuq6OrpY3OkNd2hiIiIiIhIyDIyqUtZ8/Ezh+HRv4SyGvjIc6yd/Unu6/4QG2/7KRSVw3/+OZx4ObljJsGKaZUArN2nfXUiIiIiIqNNRiZ1KbP6U9DTAasegdJJrNt/CjOY27gU3vUY5OTBd98GHSNrRqx6bCEzxpewXsVSRERERERGHSV1Maf3w86fwp98EsbNAmD9/tPMnVRGWVE+VDXAXd+D1ib4xd+kN9YBrJhWxcamFtw93aGIiIiIiEiIlNTF7H0Giirgmo8A0NPbx8aDpy8sbQSg7mp47f+ETd+FY9vTFOjAltZV0HKum30n2tMdioiIiIiIhEhJHcC5k3B0K6x4HxSUALDzSBvtXb2sqK+8+Nob7oPxc2H7T6C3Jw3BDmxpXRDnxoMtaY5ERERERETCpKQOYP8fwAyuuvvCodj+tJX1VRdfm1cIb/qHIBE88GyYUV7WzAljGVuYx8Ym9asTERERERlNlNR5HxzaCBMXXNSHbt2B00wpL2JKxZhX3zPzJpgwD3b/GrrOhRjspeXmGIunlmumTkRERERklFFSd2ofdLXB5MUXDrk76/efYkX/Wbp4c24LKmXu/10IQSZm6dRKdh5p41zXyFkWKiIiIiIiqaWk7siLkJMP4+ddOBQ5fZ6jZzpfvZ8uXulkmLQI9v8eukfGbN3Sugp6+5wtakIuIiIiIjJqjO6krq8XjmyBCXODvXJRLxwI9qUtn3aZpA5g5huD2bp9I2Nv3ZKpFQBsbNISTBERERGR0WJ0J3XNG6CzLZhxi7Px4GmKC3KZM7H08veXTYZJC2H/s3A+/YlU9dhC6quL2XhQxVJEREREREaLjEzqzOx2M3uot7d3eA/a+zRgMG72RYc3NbWwsKacvNwE/vHMfEMwW7fhO8OLJUmW1lWy4aCakIuIiIiIjBYZmdS5+xPufndubu7wHrT36aDiZbQ3HUBHdy/bD59hSV1FYs8oq4HqmfD816G3e3jxJMHSugqOt3VyqLUj3aGIiIiIiEgIMjKpS4qudmh6HsbNuujwtkNn6O51lk69wn66ePXXw5nmoCF5msXi3nBASzBFREREREaD0ZvUHVgDfd1QfXFStylaZGRpojN1EBRaqZ4Ja74GaV72OHdyKYV5OepXJyIiIiIySozepG7vbyG3AKoaLjq8qamFyeVFTCwrSvxZlgPXfBQObQhm/9IoPzeHRbXlbGrSTJ2IiIiIyGgwepO6pudhyrIgsYuzqen04GbpYhavgsJyWPfNJAU4dItqK6LLSPvSHYqIiIiIiKTY6Ezqejrh8IswdeVFh0+c7aTp1PkL/d4GpaAYFr8j2Fd37lSSAh2aRbXldPb08fLRs2mNQ0REREREUm90JnWHN0NvF9ReddHhTdF9aEsGUyQl3vL3QW8nbPrecCMclkW1QVK6OaJ9dSIiIiIi2W50JnWRtcF77cUzdZuaWsjNMRbWlA/tuRPnw9Sr4YVvp7VgyrSqYkqL8tjc3Jq2GEREREREJByjNKlbB+VToWzyRYc3Np1m7qRSxhQMo//d8vfCyZfhwB+GF+Mw5OQYi2rLNVMnIiIiIjIKjNKkbv2rZun6HDY3tQ5tP128BW+FonJY/2/De84wLaypYNeRNjq6e9Mah4iIiIiIpNboS+rajkBr06uSuj1tebR19rC0boj76WLyxwSVMHc8Du0nhvesYVhcW053r7PzSFvaYhARERERkdQbfUnd4c3B+5QlFx3eeCofYPgzdRAsweztgi0/HP6zhmhhbbAvcIuWYIqIiIiIZLXRl9QdeTF4n9h40eGNpwooLcpj+riS4Y8xYR5MXgIvPjL8Zw1RTcUYqksKeDGiYikiIiIiItls9CV1hzdDZQMUlV10eNPpApZMrSAnx5IzzuJVQS+8o9uT87xBMjMWqliKiIiIiEjWG31J3ZEtMHnRRYfO9xi7WvOSs/QypvFtkJMHmx9N3jMHaVFtBbuPnaW9sydtMYiIiIiIjHRmdouZ7TKz3WZ2/wDn55rZGjPrNLNPxR2fama/NbMdZrbNzP5H3LnPm1mzmW2Kvm5LVfyjK6nraIXT+2DSwosOb2/Now+70LQ7KcaOh5lvhM0/gL70VKBcXFtOn8O2Q2fSMr6IiIiIyEhnZrnA14BbgfnAKjOb3++yU8DHgC/1O94DfNLd5wHXAPf0u/fL7r4k+lqdmp9gtCV1R7YG75MWX3R48+kCABbVDrHp+KUsfge0HYa9Tyf3uQmKFUvREkwRERERkUu6Ctjt7nvdvQt4FLgz/gJ3P+bu64DufscPu/uG6Oc2YAdQE07YrxgxSZ2ZzTOzB83sv8zsIykZ5MiW4L3f8sstLflMKOplYllRcsebfSsUlsHWHyX3uQmaUFrE5PIiNqtYioiIiIiMXnlmtj7udXe/8zVAU9z3CENIzMysHlgKPB93+F4z22xm3zKzYfZOu7SUJnXR4I+Z2dZ+x1+1ZtXdd7j7h4G/AFakJKCjW6B4HIydeNHhzafzWVTRfYmbhiG/COa+GXb8FHq6kv/8BCysKWdLs5I6ERERERm1etx9RdzroX7nB6qU6IMZwMzGAj8CPu7usb1PDwAzgCXAYeCfBxl3wlI9U/dt4Jb4A5dbs2pmdwC/B36dkmiO7QzaDdgr/97ae4w9bXk0VqYo6VrwZ9DZCnt+k5rnX8HiqRXsO9FO6/kUJK0iIiIiIpkvAkyN+14LHEr0ZjPLJ0jo/tPd/zt23N2Punuvu/cBDxMs80yJlCZ17v47gk2F8S65ZtXdH3f31wB/mYJg4PiuIKmLs60lH8dSM1MHMP1GKKqAbY+l5vlXsLAm2Fe3VbN1IiIiIiIDWQfMMrMGMysA7gIeT+RGMzPgm8AOd/+Xfucmx319K3DR6sVkykvVgy9joDWrV5vZjcCfAYXAJSvDRNfA3g1QUFCQ+KitEehqg/FzLzq8+XQ+AI2VKUrq8gpg3p/C9sehuyNYkhmiWPGXFyMtXDdzXKhji4iIiIiMdO7eY2b3Ak8CucC33H2bmX04ev5BM5sErAfKgD4z+zjBqsNFwLuALWa2KfrIv4lWuvyimS0hWMq5H/irVP0M6UjqBlyz6u5PA09f6eboGtiHAEpKShJf63p8Z/Deb6ZuS0s+k8f0MqGoL+FHDdqCt8LG7wZLMOemrD3FgCqKC6itHKO2BiIiIiIilxBNwlb3O/Zg3OcjBMsy+/s9A+c3uPu7khnj5aSj+uWw1qwO2bEdwXu/mbotp/NprEhxEZOGG2BMVdqWYDZOKWebll+KiIiIiGSldCR1Q16zGmNmt5vZQ729g2jqfXxnUPWyuOrCobaObvaezWdRqpZexuTmw5zb4OUnoTf8giWNNWXsP3mOMx0qliIiIiIikm1S3dLgEWANMMfMImb2AXfvAWJrVncAP3D3bYN5rrs/4e535+bmJn7TsR2vmqXb2hwsSVyYqiIp8ebeBh2tcOAPqR+rnwXRYinbtQRTRERERCTrpHRPnbuvusTxV61ZTam+vqDy5bKLl7VuaW4BYGGqZ+oApr8O8sbAztVBRcwQNU55pQLmNdOrQx1bRERERERSKx3LL8PXdhi622Hc7IsOb460UjOmh+rCFBZJiSkohhmvg12rg/YKIRpfWsjEskIVSxERERERyUIZmdQNek/dyZeD93GzLjq8tbk1nFm6mDm3QWsTHNkS3phRjVPK1atORERERCQLZWRSN+g9dSd3B+/VMy8caj3Xzf6T58JN6mbfAlgwWxeyBTXl7Dl+lnNdPaGPLSIiIiIiqZORSd2gndwD+cVQ+kpT962HglmrRWEUSYkZOx6mXg07fxbemFGNU8roc9hxuC30sUVEREREJHVGSVK3G6pngL3SF3BzJEjqUt6jrr/Zb4Ijm6HtSKjDLqwNiqVsO6QlmCIiIiIi2SQjk7rB76nbfdHSSwj2002tGkNlYbhFS5j5huB9z29CHXZSWRHVJQXaVyciIiIikmUyMqkb1J66ni44feBVSd3m5hYW1VSkKMLLmLQwaIK++1ehDmtmLKgpv9CbT0REREREskNGJnWDcno/eC9Uv1L58nR7F02nzl9YkhgqM5hxUzBT15fgTGOSNE4p46WjbXT2hDuuiIiIiIikTvYndQNUvtwSXYK4sCYNSR3AzJvg/Gk4tDHUYRtryunpc146cjbUcUWjK2C4AAAgAElEQVREREREJHVGUVI3/cKhWFLXOCVNSd2M1wMW+hLM2M+7VcVSRERERESyRkYmdYMqlHJyNxSPgzGVFw5tibRSX11MeXF+CqO8jOIqqFkeelI3tWoMpUV5F5JaERERERHJfBmZ1A2qUMoAlS+3NLeysDYNRVLizXwDRNbDuVOhDWlmNE4pZ5uSOhERERGRrJGRSd2gnNwN415J6k6e7aS55TyL0rWfLmb6jYDDgT+EOmxjTRk7jrTR3dsX6rgiIiIiIpIa2Z3UdZyBs0cHLJLSmO6krmY55BfDvt+FOmxjTTldPX3sPqZiKSIiIiIi2SC7k7pTe4L3qhkXDm2JxJK6snRE9Iq8Aqi7FvY9G+qwC2LFUrQEU0REREQkK2RkUpdwoZRT+4L3qlcqX25ubmX6+BJKi9JUJCVew5/A8R3Q2RbekONKKC7IZdshNSEXEREREckGGZnUJVwo5fT+4L2y/sKhLZHW9O+ni2m4PniPtV0IQW6OMX9ymWbqRERERESyREYmdQk7vQ9KxkPhWACOtXVw5ExH+vfTxUxaDIXloSZ1EOyr2374DL19Huq4IiIiIiKSfFme1O2/aJYuNju1KN3tDGJy86D+urQkdee6etl3oj3UcUVEREREJPlGQVLXcOHr5kgrZrBgSpqLpMRruB7OnYTzp0MbMlYkZtshLcEUEREREcl02ZvU9XRBa+RV++lmjh9LSWFe+uLqr/61wfupvaENOXP8WArzcrSvTkREREQkC2RvUtfaBN53cVLX3MrCkbKfLmbCfMgreqVSZwjycnOYO7nsQs8+ERERERHJXBmZ1CXU0iBW+bIqWH559EwHx9o6WVg7wpK6nNwg8TwdXlIH0DiljG2HzuCuYikiIiIiIpksI5O6hFoaxJKk6Ezd5kisSMoIS+og2Pd39ih0hVe4pLGmnLaOHppOnQ9tTBERERERSb6MTOoScno/5BbC2EkAbIm0kGMwf/IITOqq6oP32OxiCBqnBP8ctqpYioiIiIhIRsvupK6yHnKCH3FLcyuzJpQypuAKDcvTobwOLDfUJZizJ40lL8e0r05EREREJMNlb1J3av+FpZfuHhRJGYlLLwFy86G8NtSZusK8XGZPLFUFTBERERGRDJedSZ37RY3HD7d2cOJs18jcTxdT1QAtTdAd3h63xppYsZTQhhQRERERkSTLzqTu3CnoartQ+TJWJGXEtTOIV9kA3guHNoY25MKack61d3H4fHb+ZyAiIiIiMhpk52/z/Spfbm1uJTfHmDe5LH0xXUmsn97BNaENuSCa5G5tKQhtTBERERERSa4sTer2B++xdgbNrcyeWEpR/ggskhJTUAJjJ8LBP4Y25LxJZeQYbG3JD21MEREREZGRxsxuMbNdZrbbzO4f4PxcM1tjZp1m9qlE7jWzKjN7ysxejr5Xpir+jEzqrth8PJbUVdQFRVIiLSwayUsvYyob4ODz0NcXynBjCnKZOWEs25TUiYiIiMgoZWa5wNeAW4H5wCozm9/vslPAx4AvDeLe+4Ffu/ss4NfR7ymRkUndFZuPtxyEkvFQUELk9HlOn+seuZUv41U1QGcrHN8R2pCNU8o1UyciIiIio9lVwG533+vuXcCjwJ3xF7j7MXdfB3QP4t47ge9EP38HeEuqfoCMTOquqOUglE8FuFCyf0RXvoypmBa8R9aFNuSCmnKOduRyrCM7/1MQEREREbmCGqAp7nskemy4905098MA0fcJw4zzkrLzN/nWJqioA4L9dPm5xpxJpWkOKgHF1TCmCiLrQxuycUpQPEZLMEVEREQkS+WZ2fq41939ztsA9yTa9Gs49yZNXtgDplxfX9Dvbc5tAGyJBEVSCvNGcJGUGDOoWQ7NL4Q25PxoUre1JZ/XTeoMbVwRERERkZD0uPuKy5yPAFPjvtcChxJ89uXuPWpmk939sJlNBo4lGvBgJTRTZ2aNqQog6dqPQW/nhSIpmyMtLKqtSHdUiatdCcd2QMeZUIYrLcpn+tge7asTERERkdFqHTDLzBrMrAC4C3g8Cfc+Drwn+vk9wE+SGPNFEl1++aCZrTWzj5rZyM6QWg4G7xV1HDx1jjMdPZmxny6mdjngoTYhX1DRpaROREREREYld+8B7gWeBHYAP3D3bWb2YTP7MICZTTKzCPAJ4LNmFjGzskvdG330F4A3mtnLwBuj31MioeWX7v5aM5sFvB9Yb2ZrgX9z96dSFdiQxSV1myNBkZSFmdDOIKZmefAeWQfTbwhlyMaKbp6IFHO606gsDH0JsIiIiIhIWrn7amB1v2MPxn0+QrC0MqF7o8dPAjclN9KBJVwoxd1fBj4L3AfcAHzFzHaa2Z+lKrghiSV15VPZ0txKQV4OsydmQJGUmDGVUD0r1H11jRVBZdZtrZqtExERERHJNInuqVtkZl8mmFJ8PXC7u8+Lfv5yCuMbvJaDQRXJwrFsjrQwb3IZBXkZVuSzdkVQAdPDmTVbEE3qtrYUhDKeiIiIiIgkT6LZzleBDcBid7/H3TcAuPshgtm7kaPlIFTU0dfnbG0+w6JMWnoZU7M8KPgSm3VMsYoCp7ZYxVJEZARrjcCar8E/zYQf3wPnW9IdkYiIyIiRaFJ3G/A9dz8PYGY5ZlYM4O7/karghiTaeHz/yXbOdvawMJOKpMTURiuuNofYr66iW73qRGRkOnMI/vg1OH8K6v8ENj8K330bdHekOzIREZERIdGk7lfAmLjvxdFjI4v7hcbjW5qDIikZVfkyZmIj5BVBJNx9dfvO5nGme6D+iSIiadLbDRu/C3lj4DX/A97+b/C2bwZ/6fW7L6Y7OhERkaQxsx+Z2ZvNbNB7xxK9ocjdz8a+RD8XD3awZDGz283sod7e3otPtB+Hng6omMbmSCtF+TnMHD82PUEOR24+TF4SVMAMSWxf3XbN1onISLL+34Ll6I1vg6Ky4NiCt8Ciu+C5fw2WZYqIiGSHB4D/A3jZzL5gZnMTvTHRpK7dzJbFvpjZcuD84GJMHnd/wt3vzs3NvfhEXDuDLZFWFkwpJy83w4qkxNSugMMvQk9XKMM1XiiWoqROREaI3m547itQ2QAT5l987vV/G6zO+MNX0hObiIhIkrn7r9z9L4FlwH7gKTN7zszeZ2aX/SU90Yzn48APzexZM3sW+D5Bk72RpeUAAL3lU9l6qDWz+tP1V7sCejvh6NZQhhtf1Mekol7tqxORkWPnz4Il9dNvBOu3NLyiDhr/DDZ9Dzrb0hGdiIhI0plZNfBe4IPARuB/EyR5l+0PnlBS5+7rgLnAR4CPAvPcPbwNX4mKztTt667iXFdvZid1NdFiKZFwi6Vopk5ERoyN/wFlNTBh3sDnV3wAutpg++PhxiUiIpICZvbfwLME29xud/c73P377v7XwGX3lA1mbeJKYBGwFFhlZu8easAp09IEYyp58Viw1y4ji6TElNfC2ImhVsBcUNHNnrY8znX1hDamiMiA2k/Ant/A4rvgUvvFp14F5XWw/cfhxiYiIpIa33D3+e7+j+5+GMDMCgHcfcXlbky0+fh/AF8CXkuQ3K0ELvvgtIj2qNvS3EpxQS7TM7FISoxZMFsXYrGUxoou+jB2HNZSJhFJs5d+Ad4H8++89DVmMP8O2PNb9a0TEZFs8H8PcGxNIjfmJTjACmC+u3vCIaVDy0EYP5vNkRYap5STm5Ph5flrl8Oun8G5U1BclfLhYsVSth1qZfm0ypSPJyJySTt/BuVTYdIiaFp76esWvBXWfBV2/RyWrAovPhERkSQxs0lADTDGzJYCsSSmjAQ7DiS6/HIrMGnQEYbJHVoO0ldex7ZDZzKz6Xh/NcuD90MbQhlu0pg+qgt72Rrt8ScikhZd54LZtzm3vbpASn81y4Pkb/tPwolNREQk+d5EsCqyFvgX4J+jr08Af5PIAxKdqRsHbDeztUBn7KC73zGYaFOq/QT0nOdYzgQ6e/oyez9dzJRoot68AWa+IeXDmcGC8m62Np9J+VgiIpe05zfQcx7mvvnK15rBrJth8/eDFgi5KvYkIiKZxd2/A3zHzN7m7j8ayjMSTeo+P5SHh6o1qHy5uytYppjRlS9jisph3GxoDq/Q6MLKbr7+chsd3b0U5ede+QYRkWTb8xsoKIVpr0ns+uk3wvpvBn9W1l2TyshERESSzsze6e7fBerN7BP9z7v7v1zpGYm2NHiGoAFefvTzOiCcNYGJirYz2NhWSmlhHvXVJWkOKElqlge/qIS0nbGxopuePueloyqWIiJpsv9ZmHZt4rNu9a8FDPY+ncqoREREUiWWuIwFSgd4XVFCM3Vm9iHgbqAKmEGwke9B4KbBxZtC0aTuuePFNNaUk5PpRVJiapbBi98LGvBW1KV8uFixlK3NZ1hUW5Hy8URELtJ2FE68BEvfmfg9xVUwZQnsfQZuvD91sYmIiKSAu389+v53Q31GooVS7gGuA85EB3wZmDDUQVOi5SBeVMELR7NkP11MrFhKSEswa4t7KSvKY+shFUsRkTTY/2zwXv/awd3XcANE1kLn2eTHJCIiEgIz+6KZlZlZvpn92sxOmFlCf8uZaFLX6e5dcQPmASOrvUFLEx0lNXT19mVH5cuYiY2QWwiRcJqQm0FjTTnbVAFTRNJh/++hsAwmLR7cfdNvgL4eaHo+NXGJiIik3s3ufgb4UyACzAY+nciNiSZ1z5jZ3xD0Tngj8EPgiaFEmjItBzmRNxGARTVZtGwwrwAmLwoqYIaksaacHUfa6O7tC21MEREgSOrqroXcROt4RdWsAAwi61ISloiISAhim8lvAx5x91OJ3phoUnc/cBzYAvwVsBr47GAiTKloj7oDvdWUj8lnatWYdEeUXDXL4fAm6O0JZbgFU8ro6ulj9zEtYxKREJ07BSdfHloFy6IymLhAM3UiIpLJnjCzncAK4NdmNh7oSOTGRKtf9rn7w+7+dnf/8+jnkbP88twp6G5n+7kKFtWWY1dqVptpapZD9zk4vjOU4Rqj7SDUhFxEQhXbO1y7cmj3166EyAvQp1UGIiKSedz9fuBaYIW7dwPtwJ2J3JtQUmdm+8xsb//X0ENOsmiPug2tpRcSkqwScrGUhuoSSgpy2XZITchFJESRdWA5MGXp0O6fehV0tsKJXcmNS0REJDzzgHeY2buBPwduTuSmRDctrIj7XAS8naC9QVKZ2VuANxNU1vyau/8yoRuj7Qya+sbxlmwsw181HYoqgqRu+XtSPlxOjrFgSjmbIy0pH0tE5ILIepgwHwrHDu3+qVcH703Pw4R5yYtLREQkBGb2HwTt4zYBvdHDDvz7le5NdPnlybhXs7v/v8DrEwzuW2Z2zMy29jt+i5ntMrPdZnZ/dJwfu/uHgPcC70jk+QC0NAHQ5ONYWpeFSZ3ZK03IQ7Kwtpxth86oWIqIhKOvL/gzLrYyYSiqpkNxNTSpWIqIiGSkFcB17v5Rd//r6OtjidyY6PLLZXGvFWb2YRLsbg58G7il3/Nyga8BtwLzgVVmNj/uks9GzyemtYmOnGKKS6uZWFaU8G0ZpWY5HNsOXe2hDLeotpzOnj5eOtoWyngiMsqd2gMdLVC74srXXooZTFkWFJYSERHJPFuBSUO5MdHll/8c97kH2A/8RSI3uvvvzKy+3+GrgN3uvhfAzB4F7jSzHcAXgJ+7+4A1/M3sbuBugIKCguBgy0EO+TgWZ+MsXUzNcvA+OPwiTHtNyodbHF3GujnSyoIpWbhPUURGlthKhJphJHUQtIDZ8xvo7oD8LP1LPhERyVbjgO1mthbojB109zuudGNCSZ27v27osQ2oBmiK+x4Brgb+GngDUG5mM939wQFieQh4CKCkpMQBek8fYG9PNYunZnNStyx4b34hlKRuWnUx5WPy2RxpYdVVdSkfT0RGucObIW8MjJ8zvOdMXgzeG6xsiP25KSIikhk+P9QbE0rqzOwTlzvv7v8yyHEH6jng7v4V4CuDfBZ++iDNfg1LsjmpGzsByutC21dnZiyqLefFJrU1EJEQHNkc9JnLyR3ecyYtCt4Pv6ikTkREMoq7P2Nm04BZ7v4rMysGEvofY6LNx1cAHyGYYasBPkywF66UxPfWxYsAU+O+1wKHEr3ZzG43s4d6e3uho5W87jYOMY6F2djOIF5tuMVSFtdWsOtoG+e7eq98sYjIULkHSd2khcN/VmU9FJYHzxMREckgZvYh4L+Ar0cP1QA/TuTeRJO6ccAyd/+ku38SWA7UuvvfufvfDTZgYB0wy8wazKwAuAt4PNGb3f0Jd787Nzf3QuXLntKplBblDyGUDFKzPGjfcPZ4KMMtqi2nt8/ZflizdSKSQq1N0NGanKTOLNhXd/jF4T9LREQkXPcA1wFnANz9ZYJWb1eUaFJXB3TFfe8C6hO50cweAdYAc8wsYmYfcPce4F7gSWAH8AN335ZgLBfxlgMAlE2aPpTbM0vITchjexS1BFNEUurIluB98uLkPG/SIji6DXp7kvM8ERGRcHS6+4Wcy8zyCPrUXVGi1S//A1hrZo9FH/xWEmiCB+Duqy5xfDWwOsHxL6nl8F4qgSn1w9xcnwkmLwbLCZK6Obdc+fphmlhWxMSyQjUhF5HUOrw5+LNtwvwrX5uIyYuhpwNOvAQTk/RMERGR1HvGzP4GGGNmbwQ+CjyRyI2JNh//e+B9wGmgBXifu//DEIMdtvg9daea93DeC5g3YxTM1BWUBL/0hLivblFtBZsjmqkTkRQ6sgWqZ0JBcXKeNzlaLEX76kREJLPcDxwHtgB/RTAB9tlEbkx0+SVAMXDG3f83EDGzhsFGmSzxe+q6Tu7nMOOYM7ksXeGEq2ZZkNR5QjOxw7a4tpy9J9ppPd8dyngiMgod2fJK1cpkqJ4VtEfQvjoREckg7t5HUBjlo+7+5+7+sHtiv/QnlNSZ2f8C7gM+Ez2UD3x3KMEmW35bhNbCyeTnDiY/zWA1K6CjBU7tDWW4RdEm5FubNVsnIilw7hS0HkxOkZSY3LygPcJhzdSJiEhizOwWM9tlZrvN7P4BzpuZfSV6frOZLYsen2Nmm+JeZ8zs49Fznzez5rhzt11ibIteewLYCewys+Nm9rlE4080E3orcAfQDuDuhxhaK4Okq+w+Sl9ZbbrDCE/IxVIW1QZtIl7UvjoRSYWjW4P3ZCZ1ECzBPLIltFUNIiKSucwsF/gacCtB27ZVZtZ/U/atwKzo627gAQB33+XuS9x9CUGHgHPAY3H3fTl2PlpTZCAfJ6h6udLdq929CrgauM7M/mciP0OiSV1XdOrPAcysJMH7UiK2p66PHKrtDGPG16cznHCNnwv5xaEldRXFBUyrLmazKmCKSCrEKl8mc/klBPuPO1vhTMItUEVEZPS6Ctjt7nuj1ScfBe7sd82dwL974I9AhZlN7nfNTcAedz8wyPHfDaxy932xA+6+F3hn9NwVJZrU/cDMvk4Q/IeAXwEPDzLYpIntqSssDPrSjZ86K12hhC83DyYvSUOxFM3UiUgKHN0GYyfC2PHJfW6skuaxHcl9roiIZKI8M1sf97q73/kaoCnueyR6bLDX3AU80u/YvdHlmt8ys8pLxJfv7if6H3T34wTb3q4o0eqXXyLobv4jYA7wOXf/10TuTaXYPrpxNTPTHEnIapYFe0V6uq58bRIsri3nUGsHx9s6QxlPREaR4zuDFQjJNmFe8H5se/KfLSIimabH3VfEvR7qd94GuKf/+v3LXmNmBQTb1X4Yd/4BYAawBDgM/PMl4rvcL/UJ/cJ/xaTOzHLN7Ffu/pS7f9rdP+XuTyXy8FTLyw3eraIuvYGErXYF9HbCsSH1ax+0WLEUzdaJSFK5w/FdqUnqiqtg7CTN1ImISCIiwNS477VA//X7V7rmVmCDux+NHXD3o+7eG61q+TDBMs+BLI4WWOn/agMS2nR+xaTO3XuBc2ZWnsgDw1RgTq/lQemkdIcSrlixlMj6UIZrrCkjx+DFJiV1IpJEZ5qh6yyMn5Oa50+Yp5k6ERFJxDpglpk1RGfc7gIe73fN48C7o5UqrwFa3f1w3PlV9Ft62W/P3VuBrQMN7u657l42wKvU3RNafpmXyEVAB7DFzJ4iWgEzGsDHErw/qczsduD2GZPL6CqZypic3HSEkT7lU4O/gW56Hq76UMqHKy7IY9aEUjapCbmIJNPxncF7KmbqIGhrsO4b0NcLo+3/EyIikjB37zGze4EngVzgW+6+zcw+HD3/IEEj8NuA3QQVLt8Xu9/MioE3EjQMj/dFM1tCsExz/wDnkybRpO5n0deI4O5PAE/Mn1LyofyqaekOJ3xmUHcNHHw+tCGX1lXw861H6OtzcnIGWlIsIjJIx3cF76lK6ibMg54OOL0fqmekZgwREckK0XYDq/sdezDuswP3XOLec0D1AMffleQwL+mySZ2Z1bn7QXf/TlgBDUY+3eRV1ac7jPSouwa2/xham6G8f+Gd5FtWV8mj65rYe6KdmRPGpnw8ERkFju+E4nFQ8qr/DyZHfLEUJXUiIpLFrrSn7sexD2b2oxTHMmj59ELF1CtfmI3qrgnem/4YynBL64JiKRsPng5lPBEZBVJVJCUm9mwVSxERkSx3paQufp3d9FQGMmTlozSpm7gQ8kvgYDhJ3YzxYyktymPDQRVLEZEkcI+2M0hRkRSAghKorFexFBERyXpXSur8Ep9HjtHWziAmNy9obRBSUpeTYyyZWqGZOhFJjrNHoaM1tTN1ABMWwFEldSIikt2ulNQtjuuRsCi+Z4KZnQkjwIGY2e1mFjQNHK3LLyFYgnl0K3SE869iWV0lLx1t42xnTyjjiUgWu1D5MoUzdRDsqzu5G3o6UzuOiIhIGl02qYvrmVDq7nn9eiaUhRXkAHE94e53A1CW+iIhI1bdNeB9EFkXynBL6yroc9isfnUiMlyprnwZM2EeeC+c3JPacURERNLois3HR7LuPoPchPrxZafalWA5Qb+6ECydWgnARiV1IjJcx3dCUQWMnZDaccbNfmU8ERGRLJX5Sd1oVlgKExvh4JpQhisvzmfG+BI2HNC+OhEZpljlS0vxn+PjZgEGJ15K7TgiIiJplNlJnY/ypA6g7lqIvAC93aEMt6yuko1NLQT9F0VEhijVlS9j8sdA5bRXlnuKiIhkocxO6kb7TB1A3dXQ3Q5HtoQy3NK6Sk61d3Hg5LlQxhORLNR+As6dDCepAxg3R0mdiIhkNSV1ma7u2uD9wHOhDLdsWrQJeZOWYIrIEIVV+TJm/OygAmZfbzjjiYiIhCwjk7pYS4POHi0BpGwKVM+Efb8LZbhZE0oZW5jHhgMqliIiQxRW5cuYcXOgtxNO7w9nPBERkZBlZFIXa2nQS266QxkZGq6HA38IZV9dbo6xeGq5ZupEZOiO74KCseG1pIklj1qCKSIiWSojk7qY7r50RzBCNFwPXWfh0KZQhls6tZIdh9s416Um5CIyBLEiKamufBkzPtrW4ISSOhERyU4ZndQ52lMHQP2fBO/7nglluBX1lfT2OZsOagmmiAxBrJ1BWIrKYewkOK62BiIikp0yOqmTqJJxQb+6kJK6ZdMqMYO1+0+FMp6IZJHzp+HskfCKpMSMn6OZOhERyVpK6rJFww1w8Hno7kj5UGVF+cybVMb6/dpXJyKDFJstC3OmDoKk7vhLoB6bIiKShZTUZYuG64PqbpG1oQy3sr6SDQdP09OrjY0iMghhtzOIGTcbutrgzKFwxxUREQmBkrpsMe01YLmw9+lQhlvZUMW5rl62Hz4TyngikiWO74K8MVBeF+64sZlBLcEUEZEspKQuWxSVQe1KePmpUIZbMa0KgLX7tK9ORAbh+M6gGmVOyP/7ic0Mqq2BiIhkoYxM6mLNx3t7e9Mdysgy+2Y4shnOHE75UJPKi5haNUb76kRkcMKufBlTMh6KKpTUiYhIVsrIpC7WfDw3V83HLzLrTcH77nBm61bWV7Fu/ylchQdEJBEdZ+BMJPz9dBD0xBs/F06orYGIiGSfjEzq5BImLoCyGnjpyVCGW1lfxcn2LvadaA9lPBHJcCdeDt7TMVMHwbLPWKEWERGRLKKkLpuYwaybg2IpPZ0pH25lfbCvbp361YlIIi5UvkxTUjduDpw7Ce0n0zO+iIhIiiipyzaz3wRdZ+HAcykfasb4EqpKClinfXUikojjOyG3ACqmpWf82LJPVcAUEZEso6Qu2zRcD7mFoVTBNDNWTKvUTJ2IJOb4LqieBbl56Rn/QgVMLcEUEZHsoqQu2xSUBIndzp9CCAVMrmqo4sDJcxxp7Uj5WCKS4Y7vTE+RlJiyWsgvhuMqliIiItlFSV02WvAWaDkAhzakfKhrplcDsGbviZSPJSIZrKsdWg6mbz8dBL3xxs3S8ksREck6Suqy0dw3Q04+bHss5UPNn1xG+Zh81uxR4QERuYwTLwOe3pk6CJJKzdSJiEiWUVKXjcZUwsybYNuPU74EMyfHuLqhijV7ldSJyGXE+sOlc6YOYNzsoFdeZ1t64xAREUkiJXXZasFbobXp/2/vvsOjKtM+jn+fmTQSQiAhBEioIdRQRYoioiiC0izr2sC6rK5ldXVd1313LbuWXd11LViwoWvFlVUQFAVBQZAOBghNQAgtITQhlJTn/eNMNGKAlJmcmczvc11znZkz5zxzTzghc89TbshZGPCXOi09iS27D7Fld0HAX0tEQlTeavBEQGJrd+P4YQVM9daJiEjtoaSutmp3vrMK5oqJAX+pvukNAdRbJyLHl7cGEtMhIsrdOEp7CjUEU0REapGQTOqMMcOMMeOKi4vdDiV4xdSDjHOdeXUlgf05tU2pS1JclObVicjxub3yZakGrZw5xyprICIitUhIJnXW2snW2jFer9ftUIJbl1/CgR2wfkZAX8YYQ5/0JOZ9m4+tgTIKIhJiio7A7g3uz6cDp0ZeUrqGX4qISK0SkkmdVFDbwRCXDEteC/hL9W2dxKcdIMoAACAASURBVI79h9mUX4F5dcVFsGkOzHkCPn8Isv4LhapzJ1Jr5a8HWxIcPXXgxJGnsgYiIvIjY8xgY8waY8x6Y8w95TxvjDFP+Z7/xhjTo8xzm4wxWcaYZcaYRWX2JxpjPjPGrPNtGwQq/ohANSxBICIKul0Bc5+B73dCfErAXuq0dKde3dxvd9GqYVz5B1nrJHAzH4I9G307DWAhIgY6DIO0XmBMwOIUEReUDnUMhp46gIbtIHuy82VSZIzb0YiIiMuMMV5gLHAukAMsNMZMstauKnPYECDDd+sNPOfbljrLWnts4eZ7gBnW2kd9ieI9wB8C8R7UU1fbdR8NthiWvB7Ql2nVMI6UetHHn1d3eD/891qYeANE14VLXoW7N8Kfd8F1n0JCGmS9B1kTnG/0RaT2yFsDxgNJbdyOxJHczvl/Zve3bkciIiLBoRew3lq7wVp7FHgHGHHMMSOA163ja6C+MabJSdodAZQOmXsNGOnPoMtSUlfbNWwDbc6BhS8681oCxBhD39ZJfL2hnHl13++AV8+HVZNg4H0w5gvIvAhiE535Lc17Q68xkD7QKcGwalLA6+uJSA3KW+0sUBIsvWKlw0Bzs92NQ0REgkUqsKXM4xzfvooeY4FPjTGLjTFjyhyTYq3dDuDbNvJr1GUoqQsHfW+GAzudoY8BdFqbhuw6cJTs7WWK+h7Ig1eHOIskXDkBzvgdeMpZ4MZ4oN0QaNUfvpsDi8cHNFYRqUF5a4Jn6CVAUobzf47m1YmIhIsIY8yiMrcxxzxf3tyfY3sYTnTM6dbaHjhDNG82xvSvZryVpqQuHLQ+Cxp1grlPQ0nghjb2z0gG4Mt1ec6OI9/Dm5fA/u0waqLTY3gy7YdCw7Yw7U+we+PJjxeR4FZ01FkoJbmt25H8KDLGKYKep546EZEwUWSt7VnmNu6Y53OAZmUepwHbKnqMtbZ0mwv8D2c4J8DO0iGavm2uP95MeZTUhQNjoN8dzgeYVR8E7GUaJ8TQLiWeL9fmOR/k3h0FO7LgF+OheZ8KxuqBzpc6vXmTbtUwTJFQt/tbKCmCRh3djuSnkttDrmrViYgIAAuBDGNMK2NMFHAZMOmYYyYBo32rYPYB9llrtxtj4owx8QDGmDhgELCizDlX++5fDXwYqDegpC5cZF4EyR1g1iMBLUbev21DFm/Kp+h/N8GGmTD8KWg3uHKN1KkPA/8Cm2bDmo8DE6iI1IzSeWvBNPwSoFEHZ1h4AOcai4hIaLDWFgG3ANOAbGCCtXalMeZGY8yNvsOmAhuA9cCLwG98+1OAOcaY5cACYIq19hPfc48C5xpj1uGsrPlooN6DShqEC48XzvojTBgNy96EHqMD8jL92ybTaN5fiVg51UnMul9VtYZOuQYWjIPP/gIZ54I30q9xikgNyc12euAbBtHwS3CSTFsMu9ZB40y3oxEREZdZa6fiJG5l9z1f5r4Fbi7nvA1A1+O0mQ8M9G+k5VNPXTjpMBya94Xp90PB7oC8RJ8db/KriKnMT74E+v2u6g15I+GcByB/HXzzrv8CFJGalZftzF8LlpUvS5X2HOZpCKaIiIQ+JXXhxBg4/3E4tBdmPOj/9pe/Q+SM+5gfeyb3FlxZ/SLi7YZA484w598BXeBFRAIod3XwDb0EaJgBxqukTkREagUldeGmcSb0uQkWvwrrPvNfu6unwAe/gVb9WdXnMb7NP8SW3QXVa7N0gZf8dbD6I//EKSI1p+iIM2+tUQe3I/m5iGinB1G16kREpBZQUheOzv6zU+Lgg5ucwuDVtWEWvHcNNO0Ol73FGe2dOow/lDaojg4jnKLFc5+qflsiUrN2rXPmrQVjTx1Ao/bqqRMRkVpBSV04ioyBS16GowfhrV9Wb/W3tdPgrcucYr5XvgfR8aQnx5Favw6z1vghqfNGQK8xkLMQti+vfnsiUnNKe8GCsacOnBWBd2+AwsNuRyIiIlItSurCVaMOcMmrsOMbWPJa1RK7ZW/B25c733aP/hBiEwEwxnB2+0bMWbeLw4V+KJ/Q7XKIqAMLX65+WyJSc/KywRPhfOkTjJLbgS1xiqOLiIiEMCV14azdYBj2lDNEasE4OLK/YucVHYGpdzvDN1v1h6snQ93knxwysEMjDhUWM+/b/OrHWacBdL4Est5zFnkRkdCQuxoS0yEiyu1Iylfag6ghmCIiEuKCJqkzxrQ2xrxsjPmv27GElR6joPso2L8VZv8Tti45fnFya53hls+dBgtegD6/gSsmQHT8zw7tm55EXJSXz7J3+ifOntdBYQGsnOif9kQk8PKynZ78YJXUxlkBU4uliIhIiAto8XFjzCvAUCDXWptZZv9g4EnAC7xkrX3UV7jveiV1LmjSBeJTYNnbsPwtyFkAnS6C1FOcIZWH9jjJ3qoPnG+0E9PhqvehzTnHbTI6wkv/tsnMyN6JHZmJqW55g6bdncUWlr/jJHgiEtwKD8HujdD5UrcjOb6IaEhKV0+diIiEvIAmdcB44Bng9dIdxhgvMBY4F8gBFhpjJllrVwU4FjmRuilw+m2wIwvyv4XZjztzTUoZD6T2hJHPQebFzoehkxjYIYWPV+xgxdb9dE5LqF58xkDXy2H6fU58SenVa09EAitvDWCDd5GUUsntYedKt6MQERGploAmddbaL40xLY/Z3QtY7+uZwxjzDjACUFLnNuOBJl1hxDNQsNtZFe7QHohJcBYUiKlcYnZWu2Q8Bj7L3ln9pA6gy6Uw/X745l04697qtycigVPa+xUKSd3qj5wVMCNj3I5GRESkStyYU5cKbCnzOAdINcYkGWOeB7obY/54vJONMWOMMYuMMYuKiooCHWv4ik2EtJ6QcS4061XphA4gqW40p7RowPRVfppXV68ptB4Ay9+GkpKTHS0ibsrNBk+kU+A7mDXq4IxK2LXG7UhERESqzI2krrzJVdZam2+tvdFam26tfeR4J1trx1lre1pre0ZEBHr0qFTXOR1SWLV9P9v2HvJPg92ugL2bYfNc/7QnIoGRtxoaZoA30u1ITizFN91bQzBFRCSEuZHU5QDNyjxOA7a5EIfUgHM6pgAwbeUO/zTY/gKIjIUVWgVTJKjtXBX8Qy/BmZ8bEaOkTkREQpobSd1CIMMY08oYEwVcBkyqTAPGmGHGmHHFxX4obC0BlZ5cl/aN45matd0/DUbFQdvzIHvS8UsviIi7Du2FfZt/7AULZh6vk3zuyHI7EhERkSoLaFJnjHkbmAe0M8bkGGOut9YWAbcA04BsYIK1tlJfkVprJ1trx3i9Xv8HLX53fucmLNy0hx37DvunwY4j4WAefPeVf9oTEf8q7fVq3NndOCoqJRN2rnBqcYqIiISggCZ11trLrbVNrLWR1to0a+3Lvv1TrbVtffPnHgpkDOK+8zs3AeDjFX7qrcsY5AzBXPmBf9oTEf/aucLZhkJPHThxFuTDgVy3IxEREakSN4ZfSphp08gZgjnlG38NwYx1EjsNwRQJTjuyIDYJ4hu7HUnFpHRytjs1BFNEREJTSCZ1mlMXeoZ2acKi7/awfZ+fVsHsdKGGYIoEqx1ZztBLU95ix0Hoh6ROi6WIiEhoCsmkTnPqQk/pEMypWX5aBVNDMEWCU3GRU6MuVIZeglOXs14q7FjhdiQiIiJVEpJJnYSe1sl16dikHlO+8VP1Cg3BFAlO+euh+EjoLJJSKiVTPXUiIhKylNRJjRnatQlLNu9lc36BfxrspFUwRYJOqC2SUiqlE+xaA0VH3Y5ERESk0kIyqdOcutA0slsqxsDEpTn+aTBjEETUgVWVKnMoIoG0Iws8kdCwrduRVE5KJygpchI7ERGREBOSSZ3m1IWmpvXrcFp6Eu8vyaGkxA/1oKLiIOMcyJ4MJSXVb09Eqm9HFjRqDxFRbkdSOY27OFsVIRcRkRAUkkmdhK6Le6SxZfchFm7a7Z8GO4yAAzsgZ4F/2hOR6tm5AlJCbD4dQFI6RMbBtmVuRyIiIlJpSuqkRg3ObExclJf3l/hpCGbb88AbpSGYIsHg+51wYGfoLZIC4PFCk66wbanbkYiIiFRaSCZ1tW1O3fyN+czfmO92GDUiNiqCIZ2bMDVrB4eO+uHfL6YetD7LGYJp/TCkU0SqrjQhatrd3Tiqqmk3Z/hlcZHbkYiIiFRKSCZ1mlMX2i7ukcaBI0VMzdrunwY7joB9m/UNu4jbti0B44EmXdyOpGqadoeiQ1osRUREQk5IJnUS2nq3SqR1wzjenP+dfxpsNwQ8EbDqQ/+0JyJVs20pJLd3FjEKRU26OVvNqxMRkRCjpE5qnMdjuLJPC5Zs3suKrfuq32BsIrQ8wylEriGYIu6wFrYuCd2hlwBJbSCqrnr9RUQk5CipE1dc0iONmEiP/3rrOg6H3Rtg50r/tCcilbMvBwp2hXZS5/FosRQREQlJSurEFQmxkQzv2pQPlm5j/+HC6jfYfqgzlydbq2CKuGLbEmfbtIe7cVRXk25OWYZiP/y/JCIiUkNCMqmrbatfhqtRfVpyqLCYiYv9UN6gbiNoflrolzawFgoPQdERtyMRqZxtS8ETCY0z3Y6kepp2h6LDkLfa7UhEREQqLMLtAKrCWjsZmBwXF/crt2ORquuclkC3ZvUZP3cTo/qD11SzwY7D4eO7IW8tJLf1S4w1ZscKmP8crHjfSeoAYpOgYDecegPEJbkbn8jJbF0CKR0hItrtSKqnaZnFUkKx3p6IiISlkOypk9rj1/1bsym/gE+2xlS/sQ7DnG12CK2CWVwIn/4ZXugPKz+ARh2doaQZ5zlJ3ayH4Zmeod8DKbWbtU4SFOpDLwES0yE6AbYucjsSERGRClNSJ64a1KkxrRrG8fzautVfuLJeU0g7NXQSoMP74M1LYO5T0P1KuGMFdL0cWg+AjHOh1xi4aS7Ubw4TRsEXj2l1TwlOuzfAkX2hvUhKKY8H0nrClgVuRyIiIjXIGDPYGLPGGLPeGHNPOc8bY8xTvue/Mcb08O1vZoyZaYzJNsasNMb8tsw59xtjthpjlvlu5wcqfiV14iqvx/CrM1qTtTeKeXlR1W+w4wjY8Q3s3lj9tgLp6EF442LYNAdGPAvDn4Y6DX5+XEonuGE6dPklzPwbfP63mo9V5GRKE6C0nu7G4S/N+0BuNhza63YkIiJSA4wxXmAsMAToCFxujOl4zGFDgAzfbQzwnG9/EXCntbYD0Ae4+Zhzn7DWdvPdpgbqPSipE9dd1COVhtHFPLe2bvUb+2EI5uTqtxUoxUUwYTRsXQyXvOr00p2INxJGPg89RsPsx2HRqzUTp0hFbZ4HMQmQ3MHtSPyjWS/AQo6GYIqIhIlewHpr7QZr7VHgHWDEMceMAF63jq+B+saYJtba7dbaJQDW2u+BbCC1JoMHJXUSBGIivVzX5iCzc2NYsjuyeo01aOnUmVoVxPPqZjwA66fDBf9yFnepCI8HLngC2pwLU+6E7+YGNkaRytj8NTTr7VyntUFqT6dEypb5bkciIiL+EWGMWVTmNuaY51OBLWUe5/DzxOykxxhjWgLdgbJ/QG7xDdd8xRhTzrAs/wjJv8AqaVD7XJ1+kIbRxTy+sl71G+sw3FnkYN/W6rflb9kfOXPoel4PPa+t3LneCLjkFWjQAv57PRzMD0yMIpVxMB92rXGGLNYW0XUhJRO2fO12JCIi4h9F1tqeZW7jjnm+vDXYj13I4ITHGGPqAu8Dt1tr9/t2PwekA92A7cA/qxR9BYRkUmetnWytHeP1et0ORfwkLsLym3YHmJsXzVe51Zxb19HXWx5sQzAP5MLk25zixoMfqVobMfXgF+OhYBd89NuTHi4ScKW9Wc37uhuHvzXvAzmLneHSIiJS2+UAzco8TgO2VfQYY0wkTkL3prV2YukB1tqd1tpia20J8CLOMM+ACMmkTmqnK1odpGmdIh5bWQ9bnVUeG2Y4pQGyg2gVTGvhozvgyAG48IXq1fJq0hXOutdJWoN5mKmEh83zwBtVO8oZlNWsNxQehJ0r3I5EREQCbyGQYYxpZYyJAi4Djv0gOQkY7VsFsw+wz1q73RhjgJeBbGvtv8qeYIxpUubhhUDA/qiEZPFxqZ1ivHB7h++5e0kDJi3fxohu1Zhj2nEkzHrEGYKZUONzVX/um3dh9Ucw6G/QqD0Ah44WszxnL+t2fs+m/AJ27j9MQW4ih4sNdbyW2IgSmu7KpmXDONqmxNM5NYGoCN/3MH1vhZX/gyl3QcszIDbRxTcnYW3z104pg0g/1JoMJs16O9st838sSC4iIrWStbbIGHMLMA3wAq9Ya1caY270Pf88MBU4H1gPFACl82hOB0YBWcaYZb599/pWuvyHMaYbzjDNTcCvA/UelNRJULmkxSHe2BDHw1OzOadDCnHRVbxEu/zCKdydNQH63eHfICurYDd88kdo1ptv00czZcY6Zq3JJWvrPgqLnR7JmEgPTRLqEFfkIcZr2XfUw4GiCKbN3cTRopIfjjmlRQPO69SYwZmNaTRiLIwb4BQvHznWxTcoYavwEGxbCn1/43Yk/le/GdRLdZLW3gH7GywiIkHCl4RNPWbf82XuW+Dmcs6bQ/nz7bDWjvJzmMelpE6CisfAfV33cfEXUYyduZ67B7evWkOJrZ1v2pe/A6ffDqbc37UaUfjZg3gP7+PmvVfy8RNzAOjarD7X9WtFr5aJdGqaQKP4aDweAwte/Mm5xT1vYNveQ6zcto/5G3cze90u/vLhSu6btJIBbZN5oP11NF82zll0pbbUCJPQsXUJlBTWvvl0pVqcBhu/dIZPu/h/iIiIyMkoqZOgc0pSIRf1SOXF2RsY0S2Vdo3jq9ZQl1/ClN/B9uWuDJ/K2VPAlGmf8Kvs8bxWPIit0encNyyVIZlNaJxQsaFqXo+hWWIszRJjGZzpDMteu/N7Ji/fxtsLtjDkQG++qPMenv/eTsKtX6DFg6RGffcVYH4cqljbtOoPWe9B3pofhk2LiIgEIy2UIkHpT+d3oF5MJHe9t5zC4pKqNdLpQvBEOvPZatDWvYe4939ZnP345/Ra9TAHI+rT85rHmHRLP649vVWFE7rjaZsSz52D2vHVPWfx0C/78mqda0jcm8U/H3+Qz1btrN4iMyKVsWEWNOlSe+d0tjrT2W78wt04RERETkJJnQSlpLrR/HVkJllb9/HCF99WrZHYRGh7nvNNew0sS76voJAHJq9kwGMzeW/RFh5pvZLunnXED32Izm1a+P31oiO8jOyeyp13/pk9Dbpw/eHXuP312Vw7fiGbdh30++uJ/MSRA7BlAbQe4HYkgdOgBdRv4QzBFBERCWIhmdSp+Hh4OL9zEy7o0oQnZ6xjyeY9VWuk6+VwMA/WTfNvcGUUl1je+Po7Bjw+k/FzN3FxjzS+uLUHF+ePg7ReTgwB5PF6aXDxv0mye3ir3RwWbdrDoCe+5InP1v6wyIqI330315lP1/ostyMJrNZnwqbZUKK/NyIiErxCMqlT8fHw8fDIzjROiOHmN5eQf+BI5RtoOxjim8DCl/0fHDDv23wueGo2//fBCjJS4vno1n48enEXmi75FxzaDRc8Dp4a+DVLOwW6Xk7XnDeZdUNLBmc25skZ6xg59itW79gf+NeX8LNhFnijnSLdtVmrM+HwPti27OTHioiIuCQkkzoJHwmxkTx35SnkHzzKb99ZVvn5dd4I6HE1fDsDdm/wW1w5ewr4zZuLufzFr/n+cBFjr+jBu2P60KlpAuzIgoUvQs/rnELhNWXgX8B4afj1ozx1eXfGjTqF3O8PM+zpOYyduZ7iEs21Ez/aMBNa9IXIOm5HEljpZwMG1n3qdiQiIiLHpaROgl5magJ/G5HJnPW7uHdiVuUXAjnlajBeWDy+2rEUHC3iX5+uYeA/v+Dz1bn87ty2zLjzTC7o0gRjjLP0+dTfQ50GcNafqv16lVKvKZz+W1g5ETbPZ1Cnxnx6x5kM6tiYx6at4aqX5pO7/3DNxiS1097NkLsK0ge6HUngxSZC2qlK6kREJKgpqZOQcOmpzfjtwAzeW5zDP6atqVxiV68ptBsCS9+AoioM4QSstXywdCtnP/4FT32+nvM6NebzOwdw28AMYiLLDAP+ZgJsngcD73NnRcDTb3OGm077I5SUkBgXxdgre/DYJV1YtmUvQ56czZdr82o+Lqld1vrmqLYb4m4cNaXtINi2BA7kuh2JiIhIuZTUSci4/ZwMrujdnOdmfctDU7IpqcxwwlOvh4J8WPF+pV932Za9XPTcXG5/dxnJ8dG8d2Nfnrq8O03rHzPs7NAe+PRPkHoKdB9V6dfxi6g4Zxjm1sVOj53PL3o2Y9Itp5NUN4qrX13AY9NWU1TVUhEiaz6GxHRomOF2JDUj4zxnu366u3GIiIgch5I6CRnGGP42IpNrTmvJS3M2ctd/l3O4sIIr0rU+Cxp1gq+ehJKKJTPf5R/kjneXMXLsV+TsOcQ/LunChzefzqktj9MDN/0BKNgNQ/9dM4ujHE+Xy5y5fNPvh8JDP+zOSInnw5v78cuezRg781uueFHDMaUKjhxwVoMMl146gMadnR7wNVPdjkRERKRcSuokpHg8hvuGdeTOc9sycclWLnx2LhsrUpPNGOh3O+StPml5g5w9Bdzz/jec/c8vmJq1nZsGpDPzrgFc2rMZHo8p/6QtC2Dxq9DnJqcYs5s8Hhj0EOzbAl8/+5On6kR5efTiLjzxy65kbd3H+U/NYe63u1wKVELSt59D8VGnBmS4MAbaD4V10+GoakCKiEjwUVInIccYw60DM3jlmp5s33eI85+czdiZ6zlSdJJeu04XQf3m8OXjzoImx1i+ZS+3v7OUsx6fxcQlWxnVpwWz7z6LPwxuT93oiOO3W1wIH90B9VJhwD3VfHd+0uoM50Po7H/B9zt/9vSF3dOYdMvpJNSJ4KqX5jN25vrKDWeV8LVyIsQ2hOanuR1Jzeo4AooOwbrP3I5ERETkZ5TUScg6u30KU287g/5tG/LYtDUMeGwWL8/ZyJ6DR8s/wRsBZ9wFWxfB6ikA7Nh3mJdmb2D4M3MYMfYrpmfncmXvFsz6/QDuH96JRvViTh7I3Kdh5woY8neIjvfjO6ymcx+EosMw86Fyn85IiWfSLf0Y2qUpj01bw/WvLTz+z04EnF6qtdOg43Dn9ymctDgN4pJh1QduRyIiIvIzYfZXWWqbpvXr8MKonsxel8fTn6/nrx+t4pGp2fRNT+KUFg3o2KQeyfHR1I2O4EhRCfvizyMzriVHPvgTV02NZW2eM+esU9N63DesI5eckkZ8TGTFA9i+HGY+DB2GOz1jwSQpHXqNgfnPO9vGmT87JC46gicv68aprRL56+RVDH16DmOv7EG3ZvVdCFiC3tpPoLAAMi92O5Ka5/FCh2Gw/B04WgBRsW5HJCIi8gMldVIrnJGRzBkZyazYuo9Jy7fxxZo8npyxrrxRlgz2jOT5qH8zKnY6BwZfz3mdUmidXLfyL1p4CCaOgdgkGPakM+8m2PT/PSx7y1mVc9QH5cZojGFUnxZ0TUvgpjeW8Ivn5/J/F3RkdN8WTu09kVIrJkLdxtC8r9uRuCPzYlj0Cqz+CLpc6nY0IiIiPwjJpM4YMwwYFh0dXe225m/Mp3erpOoHJUEhMzWBzNQE7j2/A98fLmRD3kHyDx7hwJFiYiI8xMdE0iLxLOzk5YzKeR163Ar1qpDQAXz6Z2fhlaved6cmXUXEJsKAP8Inf3CKJ59gcYsuafWZcls/7pywnPsmrWTBpt38/eIuJ55PKOHjQJ4z9LLXGKfXKhw1Pw3qt3BqXiqpExGRIBKSc+qstZOttWO83jD9YCEVEh8TSddm9Tm7fQrDuzZlUKfG9E1PommDWMzQf0GJb4GTyhQyL7X0DVj4IvS9Bdqc4//g/enU6yGpDUz7ExSdeM5c/dgoXhzdk7sHt+PjrO0Mf2YOa3Z8X0OBSlD75h3nd6bHaLcjcY/HA92ugI1fwt7NbkcjIiLyg5BM6kSqLbE1nHM/rP3YWeikMjZ84SSDrQfAOQ/4PzZ/80bCeY9A/jqY++RJD/d4DL8Z0Ia3ftWH7w8XMWLsHN5fnFMDgUrQshaWvA5pvaBRe7ejcVfXywHrDGsWEREJEkrqJHz1vtFZ4GT6/bC6gkWFN38Nb1/u9Hxd8mrorADYdhB0uhC+eAx2ra/QKX1aJzHltn50a1afO99bzh8nflPxYu9Su2yeB7vWhncvXakGLSB9ICx69aQ93yIiIjVFSZ2EL2NgxFho2g0mjIZVk058fNZ/4bXhEN8YRv0veOfRHc/gv0NEDHx0e4WHnDaKj+GN63tz81npvL1gCxc9O5fv8lV8OezMGwt1GkDmRW5HEhz63AQHdqi8gYiIBA0ldRLeYurBVROhSReYMAqm3AUHcn96zO6N8N618P71kNoDrv/MSexCTXwKDHoQNs2GhS9V+LQIr4ffn9eeV67pyda9hxj69BymrdwRwEAlqOxa79R1PPUGiIpzO5rgkD4QkjLg62erNidXRETEz5TUidSpD9d+DL1vchY/eaITvDLE6b174Ux4qpvzoXbAvTD6Q4gL4dVSe1ztLOzy6f9B3ppKnXp2+xQ+urUfrRvG8ev/LOahKas4UqThmLXevGeceZm9xrgdSfDweJzeum1LYcNMt6MRERFRUicCQEQ0DHkUblkMp/4KsLBzJUTHw9l/htuWwoA/OMeFMmNgxLNOj8v7N1R6TlCzxFgm3NiX0X1b8OLsjQx9ag5LN+8JULDiut0bYel/oPtVULeR29EEl+5XQb00mPmweutERMR1SupEymrYBgY/DNd9Arcuhms+gv53QUKq25H5T3wKDH8adnzj9NhVUnSElwdHZPLqtady4EgRFz83l4emrOLQUfXa1TqzHgFPBPS/2+1Igk9EtPN/Q85CpwakiIiIi5TUiYSj9hc4NfYWvABL36xSE2e1a8Snd/Tnsl7NeXH2RgY/STYvZQAADDVJREFU+SUzV+ee/EQJDduWwTcTnFVi6zVxO5rg1O1KpzxKBWpAioiIBJKSOpFwdc4D0OpMp+ZezqIqNREfE8nDF3bmrV/1xmsM145fyHXjF7Jxl1bIDGnFRTD5t86Qy353uB1N8IqIgiH/cGpAznvG7WhERCSMKakTCVfeCKfWXnxjeOvSSi+cUtZp6Q355Pb+3Ht+exZs3M2gJ77goSmr2H1QvRchaf7zsH0ZDH7UWUhIji/jXGg/FL74B+StdTsaEREJU0rqRMJZXJJTc88TAa+PgD2bqtxUVISHMf3T+fyuMxnRLZWX5mzkjL9/zj8/XcO+Q4X+i1kCa9tSmPEAtB3iFKyXk7vgnxAV65Q9KTridjQiIhKGlNSJhLukdCexKzwE44dC7upqNdcoPobHf9GVT2/vz4B2jXj68/Wc8ffPeXzaGnL3H/ZT0BIQBbvhvWsgLhlGjHVWS5WTi28Mw59xFh+a+nuthikiIjVOSZ2IQEonuHoSFB+FVwbBd3Or3WRGSjxjr+zBlNv60ad1EmNnref0v3/O7yYsY8XWfX4IWvzqaIEzDHf/dmdYbijXY3RD+/Oh3+9gyWsw5wm3oxERkTAT4XYAIhIkmnSF6z+DNy6G14bDwL84K2R6qvfdT6emCYwb3ZNNuw4yfu4mJizawsQlW8lMrcclPdIY3i2VxLgoP70JqZLD++HdK50Fcy59HZr3djui0HT2n2Hvd87wVeOBfre7HZGIiIQJ9dSJyI8atIAbPoN2g+GzP8MbF0L+t35pumXDOO4f3ol59wzkvmEdsRbun7yK3g9P54bXFjJh4RbyD2g+Uo3bswnGXwCbvoILn4eOw92OKHR5PHDhC5B5MUy/D6bcpVIHIiJSI9RTJyI/VacBXPofWDzeqb/1bB+nVlm/OyA2sdrNJ8RGcu3prbj29Fas2raf95fk8HHWdqZn5+IxcEqLBvTPSKZPehJd0hKIjvBW/z3Jz5WUwDfvwMf3OI+veNdZyVGqxxsJF70I8U2cMgdbF8Hwp6FxZ7cjExGRWixokjpjTBzwLHAUmGWtrVpFZBGpPmOg57XQbgjMeBDmPgULXoRuV8Ap1zgfUP2wiEbHpvXo2LQj/3dBB1Zu28+nq3YyfdVO/jV9LfYziIn00KN5A7o1q09magKZTRNollgHowU8qq6kBNZ+7Mz7ylkIzXrDReOgQUu3I6s9PF447yHnZ/vRHfDCmdDlUueLkeR2bkcnIiK1UECTOmPMK8BQINdam1lm/2DgScALvGStfRS4CPivtXayMeZdQEmdiNviG8PIZ+G0W51eh6X/gUUvQ1KGszBEi37O/KuYhGq9jDHGSdpSE/jduW3ZW3CU+Rt38/WGfOZv2M24LzdQVOKsKBgfE0G7lHhaJMXRqmGsbxtH44QYEmOj8HiU8P1MSbFTd271VFg5EXZvgITmzgqXXa+o9rxJOY6Ow6FlP/jycVj8Kix/x3ncaSS0HQwJaW5HKCIiPsfJT8o+b3zPnw8UANdYa5ec6FxjTCLwLtAS2ARcaq3dE4j4A91TNx54Bni9dIcxxguMBc4FcoCFxphJQBqQ5TusOMBxiUhlNOrgJADnPAjZH8KKiTBvLHz1JGAgqY3TA9EwAxKaQd0UqNvIWRo/Oh4iYyGyToV79+rHRnFep8ac16kxAEeKilm74wArt+1jxbZ9rNt5gK/W7+L9JT8tkRDhMSTHR9MoPprk+BiS46Po2DSBUX1a+PsnElyKC+HoAThyAA7kwv6tsH+bM19u+zLYvhwKC8B4ocVpzoIeHYY7BeglsGITYfDDcMadzhciWe/BlDudW700SO3u/P4kpkP9ZhCb5NzqJEJEtMpKiIjUgOPlJ9baVWUOGwJk+G69geeA3ic59x5ghrX2UWPMPb7HfwjEewjoX3Rr7ZfGmJbH7O4FrLfWbgAwxrwDjMD5IaQBy9ACLiLBKS4Jel7n3I4WOMP3Ns+DnSsgby2s/QRKio5zsoGoOCfB80Y6CYbH49t6y2w9zpYfP8xGA519t9KmaAjFSZajRSUcKSqhsNhSWGwpKimhcH8JhXssRcWW2DVeyIr7eSyV4qs7Zu2J79syx/9Qq8xW4Lxjjy3vfjlxFBbA0YNOKYryRMY6Q2V7jIbUU6DNOX6ZFylVEJcEZ94N/X8PudmwaTZs/hp2ZMGaT6Ck8OfnGA9ExDjJnTfa2UZEO/sxvoTPOI8Nx+wrbytBLSYBrnrf7ShEwtXx8pOySd0I4HVrrQW+NsbUN8Y0wemFO965I4ABvvNfA2YRikndcaQCW8o8zsHJdp8CnjHGXABMPt7JxpgxwBiAqCgtg+4v8zfmA9C7lWpTuSmk/h2iYqH1mc6tVHERHMyDAzt921wn6Sg86GyPFjj3i4vAFjvDAn+yLfnxcQV4gTpAnR+zqZOrdGFoyw9J4M8+IJd3v+yxVPG8E9wve15kHSdRjqrr28Y5PaT1Up1bbKI+zAcbYyClo3Pr/WtnX3ER7Nvs1AgsyP/xVngIig47SXvRYSg64txsCT9J+q09Zl85Wwl+UXXdjkCkNoswxiwq83ictXZcmcfHy084yTGpJzk3xVq7HcBau90Y06jqb+HE3EjqyvuEYa21B4FrT3ay7x9gHEBcXJz+UokEE28E1Gvi3ESkYrwRkNjauYmISCAUWWt7nuD5cvOTCh5TkXMDzo1hjjlAszKP04BtLsQhIiIiIiJSkfzkeMec6NydviGa+La5foz5J9xI6hYCGcaYVsaYKOAyYFJlGjDGDDPGjCsu1noqIiIiIiJSLRXJTyYBo42jD7DPN7TyROdOAq723b8a+DBQbyCgSZ0x5m1gHtDOGJNjjLneWlsE3AJMA7KBCdbalZVp11o72Vo7xutVUWIREREREam64+UnxpgbjTE3+g6bCmwA1gMvAr850bm+cx4FzjXGrMNZHfMnZRL8KdCrX15+nP1TcX4wIiIiIiIiriovP7HWPl/mvgVurui5vv35wED/Rlo+lQ4QEREREREJYSFZedYYMwwYFh0d7XYoIiIiIiIirgrJnjrNqRMREREREXGEZFInIiIiIiIiDiV1IiIiIiIiIUxz6kREREREREJYSPbUaU6diIiIiIiIIySTOhEREREREXEoqRMREREREQlhximOHpqMMSXAIbfjkFonAihyOwiRY+i6lGCk61KCka5LOVYda22t7swK6aROJBCMMYustT3djkOkLF2XEox0XUow0nUp4ahWZ6wiIiIiIiK1nZI6ERERERGREKakTuTnxrkdgEg5dF1KMNJ1KcFI16WEHc2pExERERERCWHqqRMREREREQlhSuokbBljXjHG5BpjVpTZl2iM+cwYs863beBmjBJ+jDHNjDEzjTHZxpiVxpjf+vbr2hTXGGNijDELjDHLfdflA779ui7FdcYYrzFmqTHmI99jXZcSdpTUSTgbDww+Zt89wAxrbQYww/dYpCYVAXdaazsAfYCbjTEd0bUp7joCnG2t7Qp0AwYbY/qg61KCw2+B7DKPdV1K2FFSJ2HLWvslsPuY3SOA13z3XwNG1mhQEvastduttUt897/H+aCSiq5NcZF1HPA9jPTdLLouxWXGmDTgAuClMrt1XUrYUVIn8lMp1trt4Hy4Bhq5HI+EMWNMS6A7MB9dm+Iy3xC3ZUAu8Jm1VtelBIN/A3cDJWX26bqUsKOkTkQkCBlj6gLvA7dba/e7HY+ItbbYWtsNSAN6GWMy3Y5JwpsxZiiQa61d7HYsIm5TUifyUzuNMU0AfNtcl+ORMGSMicRJ6N601k707da1KUHBWrsXmIUzJ1nXpbjpdGC4MWYT8A5wtjHmDXRdShhSUifyU5OAq333rwY+dDEWCUPGGAO8DGRba/9V5ildm+IaY0yyMaa+734d4BxgNbouxUXW2j9aa9OstS2By4DPrbVXoetSwpCKj0vYMsa8DQwAGgI7gfuAD4AJQHNgM/ALa+2xi6mIBIwxph8wG8jixzki9+LMq9O1Ka4wxnTBWXDCi/OF8ARr7YPGmCR0XUoQMMYMAO6y1g7VdSnhSEmdiIiIiIhICNPwSxERERERkRCmpE5ERERERCSEKakTEREREREJYUrqREREREREQpiSOhERERERkRCmpE5ERERERCSEKakTEREREREJYUrqREREREREQtj/AzVWTmGpP76EAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_df(df.loc[df.l == 5], drop_cols)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Metric comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: divide by zero encountered in log\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: invalid value encountered in multiply\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: divide by zero encountered in log\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: invalid value encountered in multiply\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: divide by zero encountered in log\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: invalid value encountered in multiply\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: divide by zero encountered in log\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: invalid value encountered in multiply\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: divide by zero encountered in log\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: invalid value encountered in multiply\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: divide by zero encountered in log\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: invalid value encountered in multiply\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: divide by zero encountered in log\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: invalid value encountered in multiply\n", + "/opt/SageMath/local/lib/python3.7/site-packages/numpy/lib/histograms.py:903: RuntimeWarning: invalid value encountered in true_divide\n", + " return n/db/n.sum(), bin_edges\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: divide by zero encountered in log\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: invalid value encountered in multiply\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: divide by zero encountered in log\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: invalid value encountered in multiply\n", + "/opt/SageMath/local/lib/python3.7/site-packages/numpy/lib/histograms.py:903: RuntimeWarning: invalid value encountered in true_divide\n", + " return n/db/n.sum(), bin_edges\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: divide by zero encountered in log\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: invalid value encountered in multiply\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
colrelativefullleast
statks_statkl_statks_statkl_statks_statkl_stat
l
20.000000-0.0000100.000000-0.0000100.000000-0.000010
30.2524531.4005600.54677719.4576280.5467775.093939
50.63526210.2607870.436142NaN0.3144753.741997
70.2567332.3159990.469507NaN0.52767413.133328
\n", + "
" + ], + "text/plain": [ + "col relative full least \n", + "stat ks_stat kl_stat ks_stat kl_stat ks_stat kl_stat\n", + "l \n", + "2 0.000000 -0.000010 0.000000 -0.000010 0.000000 -0.000010\n", + "3 0.252453 1.400560 0.546777 19.457628 0.546777 5.093939\n", + "5 0.635262 10.260787 0.436142 NaN 0.314475 3.741997\n", + "7 0.256733 2.315999 0.469507 NaN 0.527674 13.133328" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.groupby('l').apply(per_group(drop_cols)) # any groupby producing non-zero groups is supported " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ML comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "eval_classifiers(df, drop_cols)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The ML classification is not good for any of the algorithms." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## a25\n", + "> It would be great to have a real description here\n", + "### Load data" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
number_of_factorsnamesimtrace_factorization
secp112r15secp112r10[5, 13, 367, 653, 282930227]
secp192r15secp192r10[89, 179, 383, 6196490257, 835990267859]
secp256r15secp256r10[113, 2521, 12713, 3450079, 713804004685250272...
x962_sim_128_seed_diff_5253864x962_sim_128_seed_diff_5253861[3, 7, 1348597, 1211443907881]
x962_sim_128_seed_diff_17885124x962_sim_128_seed_diff_17885121[23, 251, 269, 21956051508929]
...............
prime256v15prime256v10[113, 2521, 12713, 3450079, 713804004685250272...
Fp256BN3Fp256BN0[38113, 39563, 225671696671686819525839357333]
secp256k12secp256k10[673, 642526577363535894282943337876185999]
ansip256k12ansip256k10[673, 642526577363535894282943337876185999]
numsp256d15numsp256d10[3, 5, 7, 349, 335691090326612982100461078411601]
\n", + "

37835 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " number_of_factors \\\n", + "secp112r1 5 \n", + "secp192r1 5 \n", + "secp256r1 5 \n", + "x962_sim_128_seed_diff_525386 4 \n", + "x962_sim_128_seed_diff_1788512 4 \n", + "... ... \n", + "prime256v1 5 \n", + "Fp256BN 3 \n", + "secp256k1 2 \n", + "ansip256k1 2 \n", + "numsp256d1 5 \n", + "\n", + " name sim \\\n", + "secp112r1 secp112r1 0 \n", + "secp192r1 secp192r1 0 \n", + "secp256r1 secp256r1 0 \n", + "x962_sim_128_seed_diff_525386 x962_sim_128_seed_diff_525386 1 \n", + "x962_sim_128_seed_diff_1788512 x962_sim_128_seed_diff_1788512 1 \n", + "... ... ... \n", + "prime256v1 prime256v1 0 \n", + "Fp256BN Fp256BN 0 \n", + "secp256k1 secp256k1 0 \n", + "ansip256k1 ansip256k1 0 \n", + "numsp256d1 numsp256d1 0 \n", + "\n", + " trace_factorization \n", + "secp112r1 [5, 13, 367, 653, 282930227] \n", + "secp192r1 [89, 179, 383, 6196490257, 835990267859] \n", + "secp256r1 [113, 2521, 12713, 3450079, 713804004685250272... \n", + "x962_sim_128_seed_diff_525386 [3, 7, 1348597, 1211443907881] \n", + "x962_sim_128_seed_diff_1788512 [23, 251, 269, 21956051508929] \n", + "... ... \n", + "prime256v1 [113, 2521, 12713, 3450079, 713804004685250272... \n", + "Fp256BN [38113, 39563, 225671696671686819525839357333] \n", + "secp256k1 [673, 642526577363535894282943337876185999] \n", + "ansip256k1 [673, 642526577363535894282943337876185999] \n", + "numsp256d1 [3, 5, 7, 349, 335691090326612982100461078411601] \n", + "\n", + "[37835 rows x 4 columns]" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "drop_cols = ('trace_factorization', ) # comma needed for tuples\n", + "df_index, df_data = parse_results_file(data_folder / 'a25.json')\n", + "df = plain_numerical2df(df_index, df_data, drop_cols) # *does tuple unpacking\n", + "df['trace_factorization'] = pd.Series([np.array(x['trace_factorization'])[:,0] # ignore ones\n", + " for x in df_data], index=df_index)\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate reasonable features" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "def max_min_ratio(x):\n", + " return np.max(x) / np.min(x)\n", + "\n", + "feature_fns = np.min, np.max, np.mean, np.median, max_min_ratio\n", + "\n", + "for fn in feature_fns:\n", + " df[f'log10({fn.__qualname__})'] = np.log10(df.trace_factorization.apply(fn).astype(float))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Statistics" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/markdown": [ + "### Numerical comparison" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
number_of_factorssimlog10(amin)log10(amax)log10(mean)log10(median)log10(max_min_ratio)
count37835.00000037835.00000037835.00000037835.00000037835.00000037835.00000037835.000000
mean4.0847360.9979381.25406412.06026211.4942414.99345710.806198
std1.4270540.0453582.9494003.7480453.8486234.8960344.161236
min1.0000000.0000000.3010300.4771210.4771210.4771210.000000
25%3.0000001.0000000.3010309.0775528.4414751.8512587.919536
50%4.0000001.0000000.30103011.73544811.1345033.21695710.651371
75%5.0000001.0000000.84509815.04863514.5135755.85025413.959781
max10.0000001.00000029.11005235.80789135.50686135.50686133.652243
\n", + "
" + ], + "text/plain": [ + " number_of_factors sim log10(amin) log10(amax) \\\n", + "count 37835.000000 37835.000000 37835.000000 37835.000000 \n", + "mean 4.084736 0.997938 1.254064 12.060262 \n", + "std 1.427054 0.045358 2.949400 3.748045 \n", + "min 1.000000 0.000000 0.301030 0.477121 \n", + "25% 3.000000 1.000000 0.301030 9.077552 \n", + "50% 4.000000 1.000000 0.301030 11.735448 \n", + "75% 5.000000 1.000000 0.845098 15.048635 \n", + "max 10.000000 1.000000 29.110052 35.807891 \n", + "\n", + " log10(mean) log10(median) log10(max_min_ratio) \n", + "count 37835.000000 37835.000000 37835.000000 \n", + "mean 11.494241 4.993457 10.806198 \n", + "std 3.848623 4.896034 4.161236 \n", + "min 0.477121 0.477121 0.000000 \n", + "25% 8.441475 1.851258 7.919536 \n", + "50% 11.134503 3.216957 10.651371 \n", + "75% 14.513575 5.850254 13.959781 \n", + "max 35.506861 35.506861 33.652243 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sim01
number_of_factorscount78.00000037757.000000
mean3.5897444.085759
std1.6859691.426319
min1.0000001.000000
25%3.0000003.000000
50%3.5000004.000000
75%5.0000005.000000
max8.00000010.000000
log10(amin)count78.00000037757.000000
mean2.4552831.251583
std4.0952162.946140
min0.3010300.301030
25%0.4771210.301030
50%1.0776680.301030
75%2.8113050.845098
max29.11005219.563892
log10(amax)count78.00000037757.000000
mean17.44037912.049148
std9.1589033.721003
min0.4771213.167613
25%12.5420079.076009
50%17.29119711.726212
75%21.85357915.037415
max35.80789119.563892
log10(mean)count78.00000037757.000000
mean16.95266311.482964
std9.0865763.822622
min0.4771212.547364
25%11.8769478.438439
50%16.77069011.125461
75%21.15460914.502280
max35.50686119.563892
log10(median)count78.00000037757.000000
mean7.3328884.988624
std8.5835074.884576
min0.4771210.477121
25%1.9542431.851258
50%4.1042483.214049
75%8.7442595.845231
max35.50686119.563892
log10(max_min_ratio)count78.00000037757.000000
mean14.98509710.797565
std9.2886214.139993
min0.0000000.000000
25%8.8928797.917634
50%15.37028910.645460
75%20.25050313.949272
max33.65224318.962057
\n", + "
" + ], + "text/plain": [ + "sim 0 1\n", + "number_of_factors count 78.000000 37757.000000\n", + " mean 3.589744 4.085759\n", + " std 1.685969 1.426319\n", + " min 1.000000 1.000000\n", + " 25% 3.000000 3.000000\n", + " 50% 3.500000 4.000000\n", + " 75% 5.000000 5.000000\n", + " max 8.000000 10.000000\n", + "log10(amin) count 78.000000 37757.000000\n", + " mean 2.455283 1.251583\n", + " std 4.095216 2.946140\n", + " min 0.301030 0.301030\n", + " 25% 0.477121 0.301030\n", + " 50% 1.077668 0.301030\n", + " 75% 2.811305 0.845098\n", + " max 29.110052 19.563892\n", + "log10(amax) count 78.000000 37757.000000\n", + " mean 17.440379 12.049148\n", + " std 9.158903 3.721003\n", + " min 0.477121 3.167613\n", + " 25% 12.542007 9.076009\n", + " 50% 17.291197 11.726212\n", + " 75% 21.853579 15.037415\n", + " max 35.807891 19.563892\n", + "log10(mean) count 78.000000 37757.000000\n", + " mean 16.952663 11.482964\n", + " std 9.086576 3.822622\n", + " min 0.477121 2.547364\n", + " 25% 11.876947 8.438439\n", + " 50% 16.770690 11.125461\n", + " 75% 21.154609 14.502280\n", + " max 35.506861 19.563892\n", + "log10(median) count 78.000000 37757.000000\n", + " mean 7.332888 4.988624\n", + " std 8.583507 4.884576\n", + " min 0.477121 0.477121\n", + " 25% 1.954243 1.851258\n", + " 50% 4.104248 3.214049\n", + " 75% 8.744259 5.845231\n", + " max 35.506861 19.563892\n", + "log10(max_min_ratio) count 78.000000 37757.000000\n", + " mean 14.985097 10.797565\n", + " std 9.288621 4.139993\n", + " min 0.000000 0.000000\n", + " 25% 8.892879 7.917634\n", + " 50% 15.370289 10.645460\n", + " 75% 20.250503 13.949272\n", + " max 33.652243 18.962057" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "### Visual comparison" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2gAAAF5CAYAAADqAwkqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi41LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvSM8oowAAIABJREFUeJzs3XmcnXV99//XZ/aZM1smk8kyE7KQsAQQZXNBAVcQDerdVqG11g2qFe9fF72xltvq3U3b3rVat4K1aFtFtArk1wiCFQRBwiZrgISQkMk6mSSz7/O9//iea3IyzHJm5rrOdZ1z3s/HI48rc861fDIEmM/5fL+fjznnEBERERERkfiVxB2AiIiIiIiIeErQREREREREEkIJmoiIiIiISEIoQRMREREREUkIJWgiIiIiIiIJoQRNREREREQkIZSgiYhIVszs/WbmzOxNcccyX2ZWbmZ/Z2Yvmtm4md01h2vrzOybZrYv/X24IbpIRUSkWJXFHYCIiEgOfRD4BHAdcC+wfw7Xfhr4EPA3wNPA86FHB5jZB4F659w/RnF/ERFJNiVoIiJSTF4P9AAfdc6Nz+Pap5xznw4/rON8EGgDlKCJiBQhLXEUEZHEMbOaiG7dAnTPIzkLrj0acjw5Y2YVZlYadxwiIjIzJWgiIgmTsdfrYjO71sx2m9mgmf3SzM7MOO+zZuamuH51+vr3T3HPS8zs/5hZu5n1mdntZnZC+pyPmdm29LMeNLOzpgmx3Mw+b2Z7zWzAzH4x1blmVmZm15jZ0+l7HjKzfzeztknn3ZCObaWZ3WhmR4Cn5vg9e5WZ/dTMutN/rl+a2Vsz3r8o/b16PdCaft5x36MZ7v3+9LVrgPMzrr0o/f4fm9ndZnbQzIbMbLuZfc7Myqe4Vyr9/X8m/T05mI77ten3dwLnA6synuMyrjcz+6P093TIzA6kv38rporZzC41s78xs3ZgEFiZfv/3zewxM+s1sy4ze8LMPjeX77mIiERDSxxFRJLrLwEH/ANQjd87dbOZrXfOjc7znn8FDAF/C6wA/gS4xcy+C7wP+DpQA1wD/NjM1jnnRibd428AA/4eqAeuBn5uZuc457aBTySAHwCXAjcAXwJa0+deYGavcM51TrrvT4Ct+L1eldn+gczsfOBnwCHg74AB4APAf5nZ5c65m9L3/V3gz4ClwP9MX35fFo/4RfraLwKHgb9Iv741ffwkcDtwK9APvBa4FjghHUcQZzXwc+Bc4CbgK0AV8BrgQvyeuD8EvgA0AX80RSz/BHwMuAP4GrAa/z19vZmdNcX39G/TMf09UA70mtkHgG8At6SPACenYxARkZgpQRMRSbbXBMmYmT0D/CfwFmDzPO83DlyQcc9SfOK3CDjNOdeXfv0IPoG4BNg06R51wJnOud70uT8GHsEnlO9Jn/NbwDuBjc65/z+4MH3ug/jk49pJ973XOfeRefyZvgiM4b9XL6afcz3wOPAlM/uxc+4A8O9m9mGgzjn379ne3Dm3A9hhZn8JdExx7brg+5b2dTN7DviMmV3rnNuTfv1P8MnZ1c65r2beIJ3Q4py72cw+AVROfo6ZnYZPzm4F3umcc+nX7wFuBv4U/88y0xjwWufccMZ9LgOeds69M9vvgYiI5I6WOIqIJNf1kyplP08fTwzxnr9MH/9jUpIRvL5uint8M0jOAJxzj+ErWJeaWfD/lcuBduBXZtYc/AJ2AzuAN05x36/N9Q9jZkvxSc/3guQsHVMXvjq0LP1+ZDKS2lIza0z/OX+O/39s5tLPdwMv4quUk+/xkqWqU9iYPv5d5vnOuVuAZ4HLprjmXzKTs7Qu/DLPV2XxTBERyTElaCIiybUr8wvn3JH0b5vCuifHml68OM3rUz3r2WleqwWWpL8+Bd+JsGOKX+vxDTcme2GmwKexJn3cOsV7T086JxLpfX334ZdWHsH/Ge9Ov70o49T1wJPzbFACfjkjTP1n3ZrxfqapvqefB7qB+81sh5l9y8wuC6p4IiISLy1xFBFJrrFpXg9+kJ6u6jJTp77p7jnbszJlU+0pwVfKfn+a9weyfC1bU8U02/dpwdJVqP8CHgA+jq8aDuH3293ASz8IDSOWmf6sk73ke+qce8bMTgYuxi+XvRi/V+6nZnapc266vwsiIpIDStBERPLXEQAzW5RRXQNYG/FzT5nitZOBXnz1CGA7cAFw1wIammRjZ/q4YYr3Tpl0ThTeAwwDb3TOTSRDZnbxFOduA043s5JZqmjTJXE708cN+IYimU5hDn/OdKw345vOGL7xyzX4pac/zfY+IiISPi1xFBHJX9vSxzcEL6R/2P7/In7uh80slfHMM/E/2P8kI/H4Hr6ZyP+afHG6VXxzGIE45/YDDwGXZ7bvN7M6fPVuP74pSVTG8AnVRNUy3Xjlk1OcexOwCrhq8huTlhf2Ao1TXB80a/mTzPPNbCM+QZ7czGVKZrY48+v0frZfp79cyPJZEREJgSpoIiL56w7geeCbZnYqvvnDb+Db5EepB7jPzG7At9n/OL6V+//OOOe7+C6Of2VmrwH+G7/cbk369e8Cnw0pnj8C7sQ3JPk6ft7XB/DJ0OVTjAkI0y3AHwP/bWbfxo9DeA9TfwD6f4F34bs8Bm31K/Bt9h8F/jp93oPAJWb2JfzSyXHn3I3OuafM7GvAHwC3mdkm/J/xavwewr8mO3eYWQe+Ecwe/Gy0j+Grn3fM5Q8vIiLhU4ImIpKnnHOjZvZOfDv8a/GNH74H/DNzHPQ8R38KXISvji0i3TbfOTfRPMQ558zsPcBHgQ/iW/CP4bs4/hRfTQqFc+7e9NDovwA+ha9mPQq83Tk333EE2T77HjO7Aj9f7e/xc9J+AFwPPDnp3IF0nH+GH0PwG/hmLI9wrKkI6fusw89e+zh+f9mN6fc+jk/Kr8QnfF347+Wnp5iBNp2vA1fgE7sG4AB+H91fzOEeIiISEcuus6+IiIiIiIhETXvQREREREREEkJLHEVEJHHSjTaWzHLamHOuY5ZzZntOA37f2Ey6Mjs0ioiIREkJmoiIJNFKZh9cvYuphzPPxZeA35vlnA/gZ5qJiIhETnvQREQkccysCnjtLKcNOOd+ucDnbABWzHLaU865fQt5joiISLaUoImIiIiIiCREXi9xLCkpcdXVs20dEBERERGRYtXf3++cc3nTHDGvE7Tq6mr6+vriDkNERERERBLKzPKq0VPeZJIiIiIiIiKFTgmaiIiIiIhIQihBExERERERSYi83oMmIiIiIiLRGxkZob29ncHBwbhDmVZVVRVtbW2Ul5fHHcqCKEETEREREZEZtbe3U1dXx+rVqzGzuMN5CeccnZ2dtLe3s2bNmrjDWRAtcRQRERERkRkNDg6yePHiRCZnAGbG4sWLE13hy5YSNBERERERmVVSk7NA0uPLlhI0ERERERHJiQ9/+MM8/fTTcYeRaNqDJiIiIiIiOfHNb34z7hASTxU0EREREREJXV9fH29729s488wzOf300/n+97/PRRddxEMPPQRAbW0t11xzDWeffTZvetOb2LJlCxdddBFr167l1ltvjTn6+CQqQTOzlJk9bGZvjzsWERERERGZv9tuu40VK1bw2GOP8eSTT3LJJZcc935fXx8XXXQRDz/8MHV1dVx77bXccccd/PjHP+Yzn/lMTFHHL9IEzcy+ZWYHzezJSa9fYmbPmtl2M/tUxlvXADdFGZOIFKC+Q3BkZ9xRiIiISIYzzjiDO++8k2uuuYZ77rmHhoaG496vqKiYSNrOOOMMLrzwQsrLyznjjDPYuXNnDBEnQ9R70G4AvgJ8J3jBzEqBrwJvBtqBB83sVmAF8DRQFXFMIlJI7v8a3PtF6OuAFa+A094F5dXH3j/vyvhiExERKWInnXQSDz/8MJs3b+ZP//RPectb3nLc++Xl5ROdF0tKSqisrJz4/ejoaM7jTYpIEzTn3C/MbPWkl88DtjvndgCY2Y3AO4BaIAVsAAbMbLNzbnzyPc3sKuAq8Fm3iBS57XdC30FYcRbsfRSqF8HJb407KhERkaK3d+9empqaeO9730ttbS033HBD3CHlhTi6OLYCuzO+bgde6Zy7GsDM3g8cmio5A3DOXQdcB5BKpVy0oYpIoh3aBjt+Dq3nwJmXw0g/tD8I698CJaVxRyciIlLUnnjiCT75yU9SUlJCeXk5X//61/nEJz4Rd1iJF0eCNtUEuYlEyzl3Q+5CEZG8tvVWcOPHKmYnvAoevgE6noGlp8UamoiISLG7+OKLufjii4977a677pr4fW9v78TvP/vZzx53XuZ7xSaOLo7twMqMr9uAvTHEISL5btudUN8KVelNx0tOhcp62P2reOMSERERmac4ErQHgfVmtsbMKoDLgTkNOjCzjWZ23djYWCQBikgeGDgKux+AJacce62k1DcK6XgWxkbii01ERERkniJd4mhm3wMuAprNrB34c+fcv5jZ1cDtQCnwLefcU3O5r3NuE7AplUqpPZvkjy3Xz/y+ug3OzY67wI0dn6ABNK2FF+6GrnZoWhNLaCIiIiLzFXUXxyumeX0zsDnKZ4tIgdt+B1Q2QOMJx78efH10pxI0ERERyTtxLHEUEVm4nffCmte9tFtjZR3ULIYju+KJS0RERGQB4ujiuGBmthHYGAyzE5EiM9gNR3bCK3536vcbV0HnNnCaxDFvWpIrIiJFxMwuAb6E34L1Tefc56c45yLgH4Fy/FiwC6OIJS8raM65Tc65q0pLNedIpCgdSG9bXXbG1O8vWgVDPTBwJHcxiYiISKRuu+02Tj75ZNatW8fnP/+S/GnezKwU+CrwVmADcIWZbZh0TiPwNeAy59xpwG+FFsAkeVlBE5Eid+BJf1x6Ohx98aXvN672xyM7cxWRiIhIUfnO/TtDvd/7Xr16xvfHxsb42Mc+xh133EFbWxvnnnsul112GRs2bJjxuiydB2x3zu0AMLMbgXcAT2ec89vAj5xzLwI45w6G8eCp5GUFTUSK3P7HoboJ6ldM/X7dMigpg+49uY1LREREIrFlyxbWrVvH2rVrqaio4PLLL+eWW27J9vIyM3so49dVk95vBXZnfN2efi3TScAiM7vLzB42s/fN70+SRbBR3VhEJDL7n4Rlp4PZ1O+XlEJqCfQeyG1cIiIiEok9e/awcuXKia/b2tp44IEHsr181Dl3zgzvT/UDxeSN7GXA2cAbgWrgfjP7lXPuuWyDyFZeVtA0qFqkiI2NwsGnYek0+88CtS3Q15GbmERERCRSborGXzbdB7Vz1w6szPi6Ddg7xTm3Oef6nHOHgF8AZ4YVQKa8TNDUJESkiB1+HkYHp28QEki1QP9hGBnITVwiIiISmba2NnbvPrYKsb29nRUrptnqMHcPAuvNbI2ZVQCXA7dOOucW4HVmVmZmNcArga1hBZApLxM0ESli+5/wx2Wnz3xe7VLAQef2yEMSERGRaJ177rls27aNF154geHhYW688UYuu+yyUO7tnBsFrgZuxyddNznnnjKzj5jZR9LnbAVuAx4HtuBb8T8ZSgCTaA+aiOSXzucBg8XrZz6vtsUfDz03e7VNREREEq2srIyvfOUrXHzxxYyNjfHBD36Q0047LbT7O+c2A5snvfaNSV//HfB3oT10GkrQRCS/HN4B9a1QXjXzeaklgEFH6Ht3RUREit5sbfGjcOmll3LppZfm/Lm5lpcJmpltBDZWVlbGHYqI5NrhHdC0ZvbzSsuhpgkOPRt9TCIiIiIhycs9aGoSIlLEDu+AprXZnZtqgUPboo1HREREJER5maCJSJEa7IL+Q9knaLXpBG1cIzlEREQkPyhBE5H8cfgFf8y6grYExoage/IoExEREZFkUoImIvnj8A5/zDZBq27yx6O7oolHREREJGRK0EQkf0wkaFk0CQHfJATg6IvRxCMiIiISsrxM0Mxso5ldNzamfSUiReXwC1C7DCpS2Z1f1QiYEjQREZEC8MEPfpCWlhZOP/30uEOJVF622XfObQI2pVKpK+OORURyaC4dHAFKy6BuORzREkcREZFQbbk+3PudN/uP9e9///u5+uqred/73hfusxMmLytoIlKk5pqgASxapQqaiIhIAbjgggtoamqKO4zIKUETkfwwMgi9+6HxhLld13iCmoSIiIhI3lCCJiL5oXuPPzaunNt1jav8tWMj4cckIiIiEjIlaCKSH4IErb51btc1ngBuHLraw49JREREJGRK0EQkPwQJVkPb3K5btMoftQ9NRERE8kBednEUkSIUJGjzqaCBEjRJhtm6nmXRxUxEpFhdccUV3HXXXRw6dIi2tjY+97nP8aEPfSjusEKXlwmamW0ENlZWVsYdSmHSDxCSRF27IdUC5VVzu66+DaxUjUJERETCFMPPg9/73vdy/sw45OUSR+fcJufcVaWlpXGHIiK50rUHGuZYPQM/C61+hSpoIiIikhfyMkETkSLU1T73/WeB+lbo3htuPCIiIiIRUIImIsnnXDpBm2OL/UD9ciVoIiIikheUoIlI8g0cgZG+hVXQevb5RE9ERETmxSX8/6NJjy9bStBEJPnmOwMtUL8CRvph8Gh4MYmIiBSRqqoqOjs7E5sEOefo7OykqmqOzcQSKC+7OIpIkZmYgTbPJY51y/2xey9ULwonJhERkSLS1tZGe3s7HR0dcYcyraqqKtra5rnaJkGUoIlI8s13SHUgqLx174Olp4UTk4iISBEpLy9nzZo1cYdRFLTEUUSSr6sdSsohtWR+19ev8MdgqaSIiIhIQilBE5Hk69nvlymWzPM/WXXLAFMnRxEREUm8vFziaGYbgY2VlZVxhyIiudCzL51kzVNpOdS2QI8SNBEREUm2vKygOec2OeeuKi0tjTsUEcmFnv0LS9DAL3NUBU1EREQSLi8TNJG81NsBT98Cz/933JHkn2CJ40LUKUETERGR5MvLJY4ieWfnL+EXfwukZ4dUNUDr2bGGlDeG+2CoK5wK2q5fhhOTiIiISERUQRPJhbu/AJV18PproWktPPFD6D0Yd1T5oWe/Py60gla/wg+qHu5beEwiIiIiEVGCJhK1PY/AC3fDmtdBdSO8/L3gxmH3A3FHlh8mErQQKmjgZ6GJiIiIJJQSNJGo3fdlqGyAla/2X1fVQ/NJsO8xcC7e2PJBTzqhWvAetGXH309EREQkgZSgiURpdAievQ1e9m4orzr2+vIz/XK7rhfjiy1f9B7wx4VW0GqXHX8/ERERkQRSgiYSpd1bYHQA1r3x+NeXngYlpb6KJjPr2QdlVb6xykLUtvijEjQRERFJMCVoIlHacRdYKaw6//jXy6v9Msf9T8QSVl4JZqCZLew+1YugtPLYnjYRERGRBFKCJhKlF+727fSr6l/6XvNJMHAEBo7mPq58EsYMNPAJXu1SVdBEREQk0ZSgiURlsAv2PAxrL5z6/cZV/nhU+9Bm1LNv4fvPAnVK0ERERCTZlKCJRGXnL307/TXTJGj1K6CkDI7uym1c+SasChr4ClqPEjQRERFJLiVoIlHZ87Dff9Z27tTvl5RBfasqaDMZ6oHhXp9YhaF2KfRqD5qIiIgcz8wuMbNnzWy7mX1qivcvMrMuM/t1+tdnooqlLKobR8nMNgIbKysr4w5FZHr7H4clpxzfXn+yxlXw4v0wPpa7uPJJUO0Kq4JWt8zv+xsdgjL990NERETAzEqBrwJvBtqBB83sVufc05NOvcc59/ao48nLCppzbpNz7qrS0tK4QxGZ3v4nYNkZM5+z6AQYH9Hw5On0HfTHoEX+Qk202j8Yzv1ERESkEJwHbHfO7XDODQM3Au+IK5i8TNBEEq+3wyddsyVoE41CtA9tSkFDj9ASNA2rFhERkZdoBXZnfN2efm2yV5vZY2b2EzM7Lapg8nKJo0jiHUjPN5stQatqhPIa6FYFbUpBpSusPWh16ftoFpqIiEgxKTOzhzK+vs45d13G11MNW3WTvn4EWOWc6zWzS4GbgfUhxwkoQROJxv4sEzTN5ppZ7wHfaKW6KZz7BYmevt8iIiLFZNQ5d84M77cDKzO+bgP2Zp7gnOvO+P1mM/uamTU75w6FG6qWOIpEY9/jUN8GNVkkFkFnQTf5gxqh9yCklkBJSP+pSrUApgRNREREMj0IrDezNWZWAVwO3Jp5gpktMzNL//48fB7VGUUwqqCJRGH/E7D8ZdmdW7cUdg/4ZKQupKV8haL3YHj7zwBKyyDVrCWOIiIiMsE5N2pmVwO3A6XAt5xzT5nZR9LvfwP4TeCjZjYKDACXOxfNp+tK0ETCNjoEndvg1I3ZnR8su+t4RgnaZL0Hwtt/FqhdpgqaiIiIHMc5txnYPOm1b2T8/ivAV3IRi5Y4ioTtyE5w49B8UnbnB50FO56JLKS81dcRbgUN/P2UoGVnsAu2boKf/zXsfTTuaERERIqCEjSRsB3a5o/N67I7v7IOyqqVoE02Ph7+Ekfwe9r6IlkyXlicg4e+BTvv8R84PP59/+GDiIiIREpLHEXC1rndH5tOzO58M7+08aAStOMMHvVDvMNe4phq9gOwnfPfe5nagaegew+87D3QsgHu+zI88h14/Z9BSWnc0Ykcb8v107933pW5i0NEJASqoImErXO7r9JUN2Z/Te1S6NiqTo6ZgmWIqSXh3re2BUYHYbg33PsWkvFx2PZTqGmGFWdBRQpOvQyGulXpFRERiZgSNJGwdW6HxVkubwzULoWBI9CvpXcTwh5SHQgSvuD+8lI774GevbDuTceqZUtO9onanofjjU1ERKTAKUETCdt8ErSaxf54+IXw48lXkSVo6T1tfaHPlSwc237qE7PMQeslZbD85XDwaRgZiC82ERGRAqcETSRMA0d958H5JmhHlKBNCJY41oa8xDHV7I99HeHet5Bs+6nfQ1lWefzrrWfD+CjsfzyeuERERIqAEjSRMB1+3h9VQVu4voNQWgFVc9jLl41giWOfljhO6chOOPQcLDnlpe81rISqhmOdSkVERCR0StBEwnQo3cGxef3cristh/pWVdAy9R70yxHD7rQ4kaBpieOUtt3hj0tOfel7ZrBoLRzeoYY2IiIiEVGCJhKmzu1gJbBo9dyvXbRGFbRMfR3hL28EKKvwVSA1CZna9p/5v7/BUtDJmtb4bo6aiSYiIhIJJWgiYTqy01fCJu/dyUbTalXQMvV1hN9iP5Bq0R60qTgHu38Fay6YvnLZtMYfX7w/d3GJiIgUESVoImE6+iI0rprftYvW+MYYQ5rPBfgliJElaEu0xHEqR3b6cQ8rzpr+nNqlUF4Nu+7LWVgiIiLFRAmaSJiO7oJF80zQgsqElo75Sk5fx/TL7BYq1awmIVPZ+6g/rnjF9OcES3hVQRMREYlEYhI0MzvVzL5hZj80s4/GHY/InI0MQs8+aDxhftcvChI0LXNkqAfGhqEmogStVkscp7T3Ud85s2XDzOctWuv3W/ZpsLqIiEjYIk3QzOxbZnbQzJ6c9PolZvasmW03s08BOOe2Ouc+ArwbOCfKuEQi0dXuj/Nd4hhU0NQo5FjyFOUSx4EjMDYSzf3z1d5H/XDqsoqZz2to9ccDT858noiIiMxZ1BW0G4BLMl8ws1Lgq8BbgQ3AFWa2If3eZcC9wM8ijkskfEd3+uN8lzhWL/K/VEE7tj8sygQt8zkC4+Ow99czL28M1C33xwNPRRuTiIhIEYo0QXPO/QI4POnl84Dtzrkdzrlh4EbgHenzb3XOvQb4nenuaWZXmdlDZvbQ6OhoVKGLzN2RXf443yWOwbVHd4cTTz6bqKBFtQctSNC0zHHC4edhuCe7BK2yznfCVIImIiISurIYntkKZP4E2g680swuAv4HUAlsnu5i59x1wHUAqVRKk1IlOY6+CCXlx6oL89Gw0u/tKXb9uaqgqVHIhL2/9sflL8/u/KWnaYmjiIhIBOJI0KYaruOcc3cBd+U2FJEQHd0FjSuhpHT+92hYCTvu8l0Mp5tDVQyirqDVtqSfoyWOEzq2QkkZNJ+U3flLT4Mt18PYKJTG8b8SERGRwhRHF8d2YGXG123A3hjiEAnXkV0LW94IPsEb7vUNLIpZ3yGorJ/fwO9sBIlfrypoEzqehaa1szcICSw9HcaG/NJIERERCU0cCdqDwHozW2NmFcDlwK1zuYGZbTSz68bGxiIJUGReju6afwfHQEObP3YV+T60KGeggU/+Siu1By1TxzOw5OTsz192uj9qmaOIiEioom6z/z3gfuBkM2s3sw8550aBq4Hbga3ATc65Oe00d85tcs5dVVq6gKVkImEa6oX+zvl3cAw0pIvLQcv+YtXXEd3+M/DLR1NLtMQxMDrkxzs0zyFBaz7JL4lUoxAREZFQRbpxwDl3xTSvb2aGRiAieSdIqBoWusQxfX2xd3Ls64RFq6N9RqpZTUICnc+DG4Mlp2R/TVklLF4HB7dGF5eIiEgRyu+d3eOjfpP6dM67MnexSHHrDhK01oXdp2YxlFVriWNfB7RFPK++tgV6D0T7jHxx6Fl/nMsSR/AJ2qFt4ccjIiJSxOLYg7Zgx/agjccdiojXtccf6xeYoJn5fWjFnKCNj/s2+1EucQR//17tQQN8gxAMmtfP7brF6+DwDhjXfmAREZGw5GWCdmwPWl6GL4Woew9gUL9i4fdqXFncSxwHjoAbz02C1tfhRxoUu45n/P7J8uq5Xbd4HYyP+AY5IiIiEgplOCJh6NoDdcugtHzh92pYWdwVtIkh1RF2cQSfoI2PwGBXtM/JBx3Pza1BSGDxOn/sVKt9ERGRsChBEwlD1+6FL28MNKz0lZ2RgXDul2+iHlIdCCp0xd5qf3wcOrfPfXkjHLumc3u4MYmIiBQxJWgiYejes/AGIYHGoNX+nnDul28mErSIlzjWKkEDoGevHzi9+MS5X1uzGKoalKCJiIiEKC8TNDUJkURxzidT9W3h3C/Yx9ZdrAlasMQxB3vQAHqLvNX+4R3+uGjN3K8188sclaCJiIiEJi8TNDUJkUQZOAKjA+FV0OrSCVrPvnDul2/6OgCD6qZon5NqyXheETv8gj82rZ3f9YvXaQ+aiIhIiJThiCxUMKQ6rD1o9cv9sXtvOPfLN32HoKYJSiMe01iz+NjzitnhHVBS7sc7zMdcMEmyAAAgAElEQVTidX4PZrHumRQREQmZEjSRhQqWIjasDOd+FSm/r6eYK2g1ETcIAZ8AVjdBX5EvcTzyAjSeACWl87s+2LumKpqIiEgolKCJLFRQQQtriSP4ZY7FXEGLev9ZoLZFSxwPvzD/5Y1wbO/akZ2hhCMiIlLs8jJBU5MQSZSudr9ELNjTFIb65cVdQYu6xX4gtaS4lzg6l07Q5tEgJLBotT9qWLWIiEgo8jJBU5MQSZTuvT6hKgnx72MxV9D6c1hBSy0p7i6O/Z0w3LOwClr1IqisVwVNREQkJMpwRBaqZ9+xzothqV8OvQdgbDTc+ybd2IjvipnLBK2YK2gLabEfMIPGVXBEFTQREZEwKEETWaiefVC3LNx71i0HN158DSz6O/0xtTg3z0s1w1AXjA7n5nlJs9AW+4FFq7TEUUREJCRK0EQWqme/T6jCFLTs7y6yfWhBw46cVdDSe936i7SKduQFwHwXx4VYtNpX0JwLIyoREZGipgRNZCGGemC4N/wKWjALrafI9qHlPEFbcvxzi83RF/2HC+VVC7tP4yo/rL2Y9/OJiEheM7NLzOxZM9tuZp+a4bxzzWzMzH4zqljyMkFTF0dJjJ4D/hh2BS3Y01Z0FbRgiWOOErRg3lqx7kM7+iI0hjC/T50cRUQkj5lZKfBV4K3ABuAKM9swzXlfAG6PMp68TNDUxVESI2iFH3YFrWaxb90fDMEuFhMVtBy22YciT9AWuLwR/B40UCdHERHJV+cB251zO5xzw8CNwDumOO/jwH8CkS4ZUYYjshA9+/0x7ApaSYm/Z7HNQuvrgJIyqGrMzfOCRLAYlziOjfoPAMJI0IJ7qJOjiIgkU5mZPZTx66pJ77cCuzO+bk+/NsHMWoF3Ad+INlQoi/oBIgUtqgoa+H1oxTYLra/DLzs0y83zqhp8pbIYm4T07IPxUWgIYYljeTXULoOjOxd+LxERkfCNOufOmeH9qX7wmNz56h+Ba5xzYxbxzylK0EQWomc/lKegsi78e9cthwNPhn/fJOvvzN3+M/CJYKq5OCtoXekPCsOooIFf5qgKmoiI5Kd2IPMTyzZg8qfk5wA3ppOzZuBSMxt1zt0cdjBa4iiyEMEMtCg+Salv9U1Ciql1eV9H7vafBVLNxbkH7eiL/ti4Kpz7Naw8lvSJiIjklweB9Wa2xswqgMuBWzNPcM6tcc6tds6tBn4I/EEUyRkoQRNZmChmoAXql8NIHwx1R3P/JOrryG0FDfySymJO0BrawrlfQ6tfkjuu7roiIpJfnHOjwNX47oxbgZucc0+Z2UfM7CO5jkdLHEUWomcftJ4dzb2DxK97r98rVQz6DsVQQVsCh3fk9plJcPRFqF268BlogYaVMDbsk+y6peHcU0REJEecc5uBzZNem7IhiHPu/VHGkpcVNM1Bk0RwLl1Bi6BBCEB9MAutSBqFjAz4od9xJGjFWkELa/8Z+CW5AN3t4d1TRESkCOVlgqY5aJIIg10wOhDdEsfgvsXSaj9IknK9xDG12C8lHe7P7XPjFnaCFiyV7FKCJiIishDKcETma2IGWkQVtIkljsWSoAVDqnOdoKWfV0yt9sfHfSIVRov9wESCVmTD1UVEREKmBE1kvqKcgQZ+b1B1E/QUyRLHuCpoNUU4rLrvIIyPQGOICVr1IiivUQVNRERkgZSgiczXRAUtoiWO4PehFVsFrWZxbp8bJIR9nbl9bpyCKld9SB0cwY+aqG/VHjQREZEFUoImMl9BBa02wo519Sugu0iWjPXHtQetCCtowd+poBFNWBraVEETERFZILXZF5mv3gNQWQ+VtdE9o2457H00uvsnSV8HlFVDRSq3zy3KBC29bDbovBiWhlbYtjXce4pIfLZcP/17512ZuzhEiowqaCLz1bMvuv1ngfoVPnEYHY72OUnQd8hXz8xy+9yKWiirKq4mId17oLQSaprCvW/DSv/BRTH8fRUREYmIEjSR+YpyBlog2N/Wuz/a5yRBX0fuZ6CBTwiLbRZa916f/IedDNe3Aq54GtuIiIhEQAmayHz17Iu2QQhkDKsugkYhfYfiSdDANyYptiWOYS9vBL/EEbQPTUREZAHyMkEzs41mdt3Y2HjcoUixci63FbRiqEgESxzjUHQVtD3hNwiBY3PVNAtNRERk3vIyQXPObXLOXVVampfhSyEYOAJjw9FX0CYStAPRPiduzsW3xBGKK0EbH/cVtIYIKmhBVa5rd/j3FhERKRJZZThmdnrUgYjklaiHVAdqmqCk/NjzCtVQD4wNxVhBSy9xdC6e5+dS/yE/pDqKJY4VNX64erGMhhAREYlAtiWob5jZFjP7AzNrjDQikXwwkaBFXEEz88/oKfAmIcH+rziXOI4NwXBvPM/PpahmoAUaWrUHTUREZAGyStCcc68FfgdYCTxkZt81szdHGplIkgUJU9QVNIC6pYVfQevv9MeaGJc4QnE0CpmYgRZVgrZSe9BEREQWIOtNXM65bcC1wDXAhcCXzewZM/sfUQUnklhBwlSbiwRtmZ8tVcgmKmiL43l+kBgWwz60qIZUB+pVQRMREVmIbPegvczMvghsBd4AbHTOnZr+/RcjjE8kmXr2Q/UiKK+K/ll1ywu/gjaRoLXE8/xUMSVoe/y+xqiqlQ1tMNQFg93R3F9ERKTAZVtB+wrwCHCmc+5jzrlHAJxze/FVNZHi0rM/+v1ngbplMNgFw/25eV4cJhI0LXGMXFe6xX5JRF1wG9r8UY1CRERE5iXb/0NfCnzXOTcAYGYlZlYD4Jz7t6iCE0msnn1QuzQ3zwqWUfYWcKOQvkNQ2QBllfE8f6KCVgQJWlRDqgNBgqZ9aCIiIvOSbYJ2J1Cd8XVN+jWR4pTrChoU9iy0OGegAZRXQ0XtsWYlhSyqIdWBIPnr1j40EREpXmb2n2b2NjOb85KVbC+ocs5N9J9O/75mrg8TKQjj475pRy46OELGsOoC3ofW1xFfi/1AqrnwK2jOpStoESZodcvBStQoREREit3Xgd8GtpnZ583slGwvzDZB6zOzs4IvzOxsYGBuMYoUiP5OGB+NoYJW4Esc46yggW+aUehNQvoP+3lvUS5xLC3z/25oiaOIiBQx59ydzrnfAc4CdgJ3mNl9ZvYBMyuf6dqyLJ/xh8APzCzdn5nlwHvmG7BIXpsYUp2jClr1IiitLOwKWu9BWPnKeGNILSn8qk/UQ6oD9a3QtTvaZ4iIiCScmS0G3gv8LvAo8B/Aa4HfAy6a7rqsEjTn3IPpstzJgAHPOOdGFhizSH6aGFKdowqamR9WXaiz0MbHfFUyCUsc9z4abwxRi3oGWqChrfC/lyIiIjMwsx8BpwD/hh9RFnzS/n0ze2ima7OtoAGcC6xOX/MKM8M59515xLtgZrYR2FhZPpfwRUKS6woaFPYstP7DgEtGgtZ/yO/TMos3lqgEjTsaok7QWuGZ/yrs76WIiMjMvumc25z5gplVOueGnHPnzHRhtoOq/w34e3xJ7tz0rxlvHCXn3Cbn3FWlpRHN8RGZSVBBy1WbffDJYKHuQQsac9TGnaAt8XsLB4/GG0eUuvdCSVn0yXB9q9/r1n842ueIiIgk119O8dr92VyYbQnqHGCDc85lHZJIoerZ5xtKlFXk7pm1y+D5n+fuebk0MaQ6AQka+EYh1YvijSUq3Xt9NbakNNrnBHvcuvdAanG0zxIREUkQM1sGtALVZvYK/PYwgHqy7IKfbYL2JLAMKNA1ViJzkMsZaIG6ZTDUDcN9UJHK7bOjlpQErSadSPQdgub18cYSlahnoAWCPW49+2D5y6J/noiISHJcDLwfaAP+IeP1HuDT2dwg2wStGXjazLYAQ8GLzrnLsrxepHD07Mvt/jPImIW2HxafmNtnRy1obR93gjZRQSvgWWjde2HZGdE/J7OCJiIiUkScc98Gvm1mv+Gc+8/53CPbBO2z87m5SEHq2Z+bH3IzZc5CK7gErQOsFKoa442j0BO0YEj1SZdE/6zapf6fadA1UkREpEiY2Xudc/8OrDazP578vnPuH6a47DjZttm/28xWAeudc3eaWQ0Q8SYGkQQaG4W+g/EscYTC7OTY1+E7KJbE3PQnWOLY3xlvHFEZOAIj/dG32Ae/x61umRI0EREpRsFelNr53iCrBM3MrgSuApqAE/Eb374BvHG+DxbJS30d4MZjWOKYfl4hzkLrOxT/8kbwTV+qGgq3gjYxAy0He9CC52iJo4iIFBnn3D+nj5+b7z2y/cj6Y8D5QHf6gduAlvk+VCRvxTEDDfzyv7Kqwq6gJUFqSREkaDmooEE6QVMFTUREipOZ/a2Z1ZtZuZn9zMwOmdl7s7k22wRtyDk3nPHAMkAt96X4BLPIcp2gmRXuLLS+jmRU0MCPTwialhSaoJqVqwpa3Qro2uP3vomIiBSftzjnuoG3A+3AScAns7kw2wTtbjP7NL6f/5uBHwCb5hOpSF6bqKDleA8a+FloBZmgJWSJI/hKXsEmaHvBSnI3YL1+BYz0+fEQIiIixac8fbwU+J5z7nC2F2aboH0K6ACeAH4f2AxcO5cIRQpC7wHAIBXDCt9CrKCNDMBwj5Y45kL3Xp/kl2bbvHeBJlrta5mjiIgUpU1m9gxwDvAzM1sCDGZzYbZdHMeB69O/RIpXzz6obcndD7mZ6pbD9p/l/rlRSsqQ6kCqGQYOw/iY70RYSHI1pDoQ7HXr3gMtp+buuSIiIgngnPuUmX0B6HbOjZlZH/CObK7NtovjC0yx58w5t3ZOkYrku579ud9/Fqhb5qtNQz1QWRdPDGFLXIK2xHfpHDiSnKpeWHKdKKmCJiIicip+HlpmzvWd2S7KtgxwTsbvq4DfwrfcFykuPfty1wVvsolZaAcKKEFL7/dKTIKWTsqS1FkyDM75hh3r3pS7Zwb7NJWgiYhIHjCzS4Av4Wc9f9M59/lJ778D+AtgHBgF/tA5d+8M9/s3/HiyXwNj6ZcdYSVozrnJk1v/0czuBT6TzfUiBaNnP7SeHc+zJ2ah7YfmdfHEELaJClpCkqGaIEErsEYhQ92+YUculziWVfi9mpqFJiIiCWdmpcBXgTfjOy4+aGa3OueezjjtZ8CtzjlnZi8DbgJOmeG25wAbnJt7O+NslzielfFlSfqBBfIRvkiWxkZ8QhFHB0c49txCahSSxCWOUHiNQnI9pDqgWWgiIpIfzgO2O+d2AJjZjfj9YhMJmnOuN+P8FLOPHHsSWAbMeYhttksc/2/G70eBncC75/owkbzWe8Af49yDBoU1rLrvEJTXQEUq7ki8iQStwCpoEzPQcrw8t74VjryQ22eKiIjMXSuwO+PrduCVk08ys3cBfwO0AG+b5Z7NwNNmtgUYCl50zl02WzDZLnF8fTbniRS0iSHVMVXQKuuhrLrwKmhJWd4IUNMEGPQXWoIWYwVt17TL80VERHKlzMweyvj6OufcdRlf2xTXTNUg8cfAj83sAvx+tJk2d392PoFC9ksc/3im951z/zDfAETyxsSQ6pgqaGaFNwutryM5yxvBt9avaYLeg3FHEq6uPYDl/sOF+hUw2AXDfcmpkoqISDEadc6dM8P77cDKjK/bgGnX6DvnfmFmJ5pZs3Nuyk91nXN3m9kqYL1z7k4zq8E3IJlVtoOqzwE+ii//tQIfATbg96FpL5oUh7graMGzlaBFq3ZpAe5B2+P/XKXluX3uxCy0AlqWKyIihehBYL2ZrTGzCuBy4NbME8xsnZlZ+vdnARXA5EaKmedfCfwQ+Of0S63AzdkEk+0etGbgLOdcT/qBnwV+4Jz7cJbXZ8XM3olfz9kCfNU599Mw7y+yID37wEqPdfqLQ90y2PdYfM8PW98hWH5m3FEcL7Xk2H7DQtG9N/fLGyFjFtqewuk8KiIiBcc5N2pmVwO346tc33LOPWVmH0m//w3gN4D3mdkIMAC8Z5YOjR/DNx95IH2PbWbWkk082VbQTgCGM74eBlZnc6GZfcvMDprZk5Nev8TMnjWz7Wb2KQDn3M3OuSuB9wPvyTI2kdwIhlSXZPuvTQQKaYmjc8mtoBXaEsfYEzR1chQRkWRzzm12zp3knDvROfdX6de+kU7OcM59wTl3mnPu5c65V880Ay1tyDk3kT+lh1Vn1XI/2580/w3YYmafNbM/x2eCsw5ZS7sBuCTzhYxZA2/FL5W8wsw2ZJxybfp9keTo2ed/eI9T3TI/z2qoJ944wjB4FMZH/aysJKlt8Qna3MeWJFf33ngGrGdW0ERERIrL3Wb2aaDazN4M/ADYlM2FWSVo6SzyA8AR4CjwAefcX2d57S+Aw5Nenpg1kM4sbwTeYd4XgJ845x6Z6n5mdpWZPWRmD42Ojk11ikg0evbHu/8MCmsWWm/CZqAFaltgdKAwkmDwf46hrngqaOXVUN2kCpqIiBSjTwEdwBPA7wOb8UWoWWW7Bw2gBuh2zv2rmS0xszXOufkOuJlu1sDH8e0qG8xsXVBSzJRuiXkdQKq6soA+4pbE69kPJ7w63hgyZ6E1r483loWaGFKdoDb7cKxK2tcBVfXxxhKGoEFHHBW04LlK0EREpMg458bN7GbgZufcnLqPZdtm/8/xnRxPBv4VKAf+HTh/jrFO3HKK15xz7svAl+d5T5HojA7BwOH4K2i1QYJWABW0vgRX0MA3Cll8YryxhKG73R8b4krQVmiJo4iIFI10p8c/B67G5zxmZmPAPznn/k8298h2D9q7gMuAPgDn3F4W1l5/TrMGRGI30WI/phlogTolaJEL9sQVSqOQuIZUB+pXqIImIiLF5A/xRaxznXOLnXNN+JWC55vZH2Vzg2wTtOF0G0kHYGYLnTg666yBmZjZRjO7bmxsfIFhiGQpCTPQACrroDxVQAmaQc3iuCM5XrDEsdAStLj+7ta3Qv8hGBmM5/kiIiK59T7gisytYM65HcB70+/NKtsE7SYz+2egMT107U7g+mwuNLPvAfcDJ5tZu5l9yDk3ii/73Q5sBW5yzj2VZSw45zY5564qLY2x3bkUl570Pp64K2hm6Vb7BTD4t/eA339WOpetsDlQ0+Tn3RXKLLTuPb5KWVYZz/ODyl0h/J0VERGZXblz7tDkF9P70MqzuUFWPxk55/4+3R6yG78P7TPOuTuyvPaKaV7fjO9mIpJ8SamgQeHMQus5EP/YgqmUlPrEsa+AKmhxLW+E42ehNa2JLw4REZHcGJ7nexNmTdDSM8tud869CcgqKRMpOD37oKTcV1fiVrcM9j4adxQL13vgWEOOpAlmoRWC7r3QeEJ8zw+6R2ofmoiIFIczzax7itcNqMrmBrOuEXTOjQH9ZtYwx+Aioz1oknPBDDSbqgFpjtUt9/Hk+yDl3gPHulImTaqlcJY4drXH12IfoD5ddVYnRxERKQLOuVLnXP0Uv+qcc+EtcQQGgSfM7A7SnRzTAfzPecS9YM65TcCmVHXllXE8X4pQz774958F6pbBSD8MdUNVYj43mZvxcV+hSmwFbSl0PBt3FAs33AeDR+Nd4lhZB5X1qqCJiIhkKdsE7b/Sv0SKU89+WHJy3FF4mbPQ8jVBGzwK4yPJSXonq23xe9CcS0bVdL7iHlId0Cw0ERGRrM2YoJnZCc65F51z385VQCKJ1LMf1l4UdxTexCy0fclJGucqaHKS2ApaC4wN+0SyelHc0cxfkBTFWUELnq8KmoiISFZm24N2c/AbM/vPiGMRSabhPhjqSk61J+gk2ZPHe6SC/V1J7OIIhTMLLe4h1YH6FWqzLyIikqXZErTMtT1rowxkLtQkRHIqSS32AerSyUM+/8AbJD5JbRISVPbyvVFIYiporf7fo7GReOMQERHJA7MlaG6a38dKg6olpyYStIRUeyrroKI2v2eh9SZ8iWMqSNAKoIJW3QTl1fHGUb8CcPmf8IqIiOTAbE1Cgj7+BlRn9PQ3wDnn6iONTiQJehNWQYP0sOo8r6CV1/hkM4lqCyVB2wMNMTcIgeNnoTW0xRtLkuR7ExoREYnEjAmac640V4GIJFbQCS8pe9DAJ4v5XI3o2e+ToKT+cFq9yA8mz+fvMfgELe4OjnBsiaU6OXrjY7DzF7D9Z1BWBS2nwqnvgNJsGyuLiEgh0xpBkdn07IOyaqhqjDuSY/K+gnYguQ1CwCeOtS3Q1xF3JAvTvTf+/WeQkaCpkyPOwSPfgWf+CxathsYT4MX74dFvw/ho3NGJiEgC5OXHdWa2EdhYWZ6X4Uu+6d7jf8BMUrWndqmvQuXrEqneg8kfEVDbkt8VtJFB6O9MRoJW1eiXtCpB88nYwafglLfB2tf713bdB0/9yCdtr/povPGJSPS2XD/9e+ddmbs4JLHysoKmJiER2nUfPH4TbL8zv5tQhCkpVYhMdcthdNDP6cpHvfuTXUEDH18+70HrCVrsJ2CJo5mGVQMc2QlbN0HzybDmwmOvr3oNrHwV7PoldD4fW3giIpIMynDEcw42fxL+9a2w7zF47ja478v6YQH8HrQk/JCbaWJYdR5WeEYGYbArOV0xp5Nakt8JWlJmoAU0rBru+ydw43DGb4FN+t/vSW/x+x7v/PN4YhMRkcRQgibeI9+GLdfBuVfCGz8Db/jfUN0ID30Tuor4U+/xcV+JSMoPuYGJYdV5uA8t6UOqA7VL/R608Tydtxj8e1ufkK6J9a3FnaD1HYJH/wNaz/b/bZ2ssh7WXugrbAeezn18IiKSGErQBDqeg598yu+HeOvfQlklVDXAKz8KpZXw9I99ha0Y9XX4jfuJS9CCCloeLkNN+pDqQG0LuDEYOBx3JPMzMaQ6IeMh6lf4DxTGx+KOJB5brofRAZ+ETWfV+VBa4T8wExGRoqUETeDnfwWl5fCuf4aSjL8SlXVw0iV+38T+x2ILL1YTP+QmbIljUH3K6wpaQodUByZmoeXhMlLw1aqqRqhIxR2JV7/Cf9iR750x52N8DB6+Ada/ZebKcUUKTt0Ij93olwKLiEhRyssEzcw2mtl1Y2N5uvQoSQ5th6dvgXM/PPWeoJXn+eV0z2z2eyeKTdL28QQqa/2SqLxM0NJVv3xY4gj5naAl6YOFiWHVRbhkeue9/u/9mVfMfu5Zv+eb/2y9Nfq4REQkkfIyQVMXxxD98h/9ksZX/cHU71sJrHuTX+bV8WxuY0uC7gR1wpssX/f09B4EzDfhSLJUUEHL04pPMB4iKYp5FtqTP4SKWr8iYTarX+fno/36u5GHJSIiyaQMp5j1H/ZLaV7xXqid4YflpadBRZ2f31Nsuvf4PSE1i+OO5KXqV0BXe9xRzF3vAUg1Q2nC5xjm/RLHpCVoQQWtyBK00SG/SuGUt0FFzeznl5TAhnfAzntgIE/HaIiIyIIoQStmT/0Ixkf8kpqZlJT5pY4Ht8LAkdzElhTde/0Sz5IE/qvS0Jqfy8V6DiS/QQj4PZhl1dCXh632Rwb8Xq/GlXFHckzNYv9hRz7+nV2I53/ux0qc/pvZX3PKRr9fb9tPo4tLREQSK4E/dUrOPH4TLDkVlp0x+7krX+mP7Q9FG1PSJHFIdaC+zf8QPjoUdyRz03sg+Q1CwA9Xrs3TWWhBi/2GBCVoE8Oqi6yC9txtfnnj2ouyv6b1bP8hxtZNUUUlIiIJpgStWB1+AXY/AC97t//BaTY1TbBoFex/PPrYkiRpy8QyNeTpkrHeA8lvEBKoXZafowy6dvtjQ0JmoAXqW/3g92LhHGy7wydnZRXZX1dSAqdcCtvv9NVQEREpKgnfBCKReeKH/viyd2d/zbKX+c5inc/D4hOjiStJnPPJz6lvjzuSqaX39IwfbedwxQo6eobo7B2mZ3CE3qFR/2twdOL3o2OO0XHH6Pg4o+OOsfTXpSVQVlpCWYlRVpI+lho1FaXUVJRRW1lGqrKMVGUpqQr/+4bqcppSFSxKlVNZVpp9zOPjviI1VcfQJKpblp/NcYK9iUmqoIH/sKOYqvAHt0J3O1z4v+Z+7Slvg4e+5TtArn9z+LGJiEhiKUErVs9uhrZz5/YJ+7LTfYK29VZ47R9FF1tS9B+GsaHYOzgOjoyx+3A/uzr72XW4n12dfbQfGaDi6AG+AXziW5v50Wj3tNdXlpWQqiyjorSE0nTyVVpilJeUUFJijGckbT6JG2d0zNE/PMbAyOxDhVMVpSxKVbA4VcGiVAVNqQqW1VexrKGKpfVVE79vrq2kdPCo3/eYLxW0uuWw4+64o5i7rt2AJa/6W7fcf+jhXHaV+3wX7CGbT4K16nworfR72JSgiYgUlbxM0MxsI7Cxsjwvw49fzwHY+wi84X/P7brqJp/QPV0kCdrEkOrc/JA7MjbO8x29PLOvh637unl6XzfbD/ayv3sQ546dV1dVxspFNaysWw5H4Z1rHWeechpL6ipZnKqgvrqc2soy6qp8tat8AeMoxsYd/cOj9A2N0Tc8Sl+6Gtc9MMLhvhGO9A/T2TvMkf5hDvf53z+7v4eDPUOMjbvj7lVaYryyZj/fBf7l1/0cPLLV/zmaali5qJoVjdVUlc+hGpcL9cthqAuG+5Iz8DkbXe0+GSotjzuS49W3+g89+g9DKoGdUcO27Q5Yesb8/htSXg0nvAp2/Dz8uEREJNHyMsNxzm0CNqWqK6+MO5a8tO12f8xmJs9kS8+A537i9+XU5UEnvoWIcAaac7Cjt5SHOyt45HAFjx2pYPsttzEy5pOaitIS1i+t5dVrF7NqcYrVzTWc0FTD6sUpGmvKsaD68PlGLmgZ5oLXrA49RvBJVV1VOXVVc/tBf2zc0dk3xIGuIfZ3D7K/e5ADXYPU7d0Hu+Dxrip+cu9OhicNm19aX3lc0rZmSYo1zbWsaU7RUB1DslG33B979ufXst6u3cnq4BgI9k127S78BG2oF3b/Cl79sfnf48TXw52f9R+q5cuyYBERWbC8TNBkgZ673XcAXHra3K9tOcUnaM//N7z8t8OPLUlCrKCNjo3zWGc5vzpUySOdFTxyuJwjw6nmRWMAACAASURBVL5a1FA+zpmLhrnw5Ws5dXkdpy6vZ01zKrvKV0NbIpuElJYYLXVVtNRVcQYNx9547NewC770oYv5YtOJHOgZZPfhAXYf7mf3kX7/+yP9PLCjk5snVQ4XpypY05zyv5akWNucYu2SWk4Yg6qoCm/BhxA9+/IrQTu6G1rPijuKlwr2xHXthhUvjzeWqO1+wLfKX3PB/O+x9vXAZ2HHXXDme0IKTEREkk4JWrEZHfJ7Gs68fH57QOqWQ6qlSBK0vWCl89ov5ZxjZ2c/927r4J5th7j/+U56hvww8BPrRnjz8kHOXjzC2U3DrK0bpcSA806Ze4z1rb4JQb7oTXdErFtKSYmxvKGa5Q3VnLem6SWnDo36vXc7Ovp44ZD/teNQH3c918EPHj72ZzaW01ozxpraUdbVjXJS/Sjr60dZXzdCQ4V7yX3npC6dnOdTJ8fxcf/hwobL4o7kpRpP8Meju+ONIxd23pOeIfmq+d9j2cv80vIdP1eCJiJSRJSgFZvdD8BI3/w3nVuJX3az/U7/g2ASBziHpXuvr6CUZFeeGR4d5/4dnfz0qf3c/VwH7Ud8e+y2RdW8/czlvJbHePWSYZoqx2e50xw0tEL7g+HdL2q9B6G8xs+FmkVlWSnrWupY11L3kvd6BkfYeaifHYd6eeGxX/BCbxk7esq4cWcNA2PH/k4urRrjpCceYF1LLSctreOkpbWsa6nLfrlkUEFLYJVyWn0dMDacvA6OANWL/D/7oy/GHUn0dt7r55lVzv53fVolJb4C98I94cUlIiKJpwSt2LzwC18VWnX+/O9x4hvh8e/D/sdgxSvCiy1pspiB1j04wl3Pdvik7NkOeoZGqako5bXrmvn9C0/kdeuaWbW4xu8Z2/JA+DHWt8LAYRjuh4qa8O8ftu69viK5wA5+dVXlnNHWwBltDTDcO/H6uIM9/aVs6y7juZ5ynusuY/vACDdu2X1cR8ql9ZWctLSO9S11nLysllOX13PS0rqXNimprIPyVH5V0CZmoCUwQTPzcXUVeAVtqAf2PAKv/cOF32vV+fD0zT6pDSqQIiJS0JSgFZsdd/u9KVX187/HiW/wx+0/K+wErWcftJz60pcHR/jpUwfY9Phefrn9ECNjjubaCt5+5nLevGEprzmxOXfdCOszhlU3r8vNMxeiZ1+kYwtKDFamxliZGuMNy4f8i+f9FuPjjj1HB9h2sIfnDvTy3IEeth/s5XtbXpxI3EoM1i7xydqG5fWcuryODcvrWVK3DOvJo+HKSR1SHWhcWfgVtBcfADcGq1+38HuterU/7rpPCZqISITM7BLgS0Ap8E3n3Ocnvf87wDXpL3uBjzrnHosiFiVoxWSoB/Y8vPBPdWuXwNLT/R6LCz4RTmxJ4xx07YF1bwL8LLK7nj3ILb/ey38/c5Ch0XHaFlXzgfPXcPFpS3n5ykWUlsQw1ynoitfdnh8JWveehe3JmaeSEvOdIZtqeMMpx/YUjo87Xjzcz9Z93enRBj08susImx47tqTxh1VV1PY9x482b+XU5XWctqKBE5fUxvPPOxvBkOokdnEEX0HbvSXuKKK1614oKYeVr1z4vVo2QFWDT9DOvHzh9xMRkZcws1Lgq8CbgXbgQTO71Tn3dMZpLwAXOueOmNlbgeuAEP5D/1JK0IrJrvv8p7prLlz4vVa/Fh75DowOQ1nFwu+XNEPdMNLHi6ON/NMPHuO2J/fTMzRKc20FV5x3AhvPXMFZJzQea3cfl8wKWtKNj/ulgvXL445kQkmJsbo5xermFG8941hcXf0jbN3vk7aSLctp6HmSG+7byfCo3z9YXV7K6a31nNHayJkrGzijtYHVi1P/j72zDm/rvP7450q2ZGZmDjjMzFBKcV25W3EdddBh19+2buvWbV23buvalbndVk4hhTTMzJyYndgxM+n+/jiW4yZO4tiSriS/n+fRcx3Zuu+xIkv3+55zvgeTO4i26kKwhshFvTsSlgLN1bJhZD2zv9ArKFgP8SMdU3ZsMsumRsG6/p9LoVAoFGdjAnBY1/WjAJqmvQFcAXQJNF3X13b7+fWA00pVlEAbSBxbCWYrJE/o/7lSp8KGJ6FkG6Q4ZfPAME7UNvPFyvXcAPxpbR3LfEq5eHg8V4xKYHJGJD79GPzscOwCrabY2Dh6Q2OFmFc4scTRUYQG+DIpI5JJGZHQMAQ2rmbPrxdwrKKR3cU17CyqYWdRNa9uyOe5NSLagv18GJ4ofXEjEsMYkRRKUri/60V8TZH7ljfCqcxedSHEDjU2FmfQ3iL9ZxMcOKYzdbLMr6wvlwoGhUKhUFwoPpqmbe7276d0XX+q278Tge4N0kWcOzt2B/CxA+P7Eh4p0DRNWwQssvp6ZPjGkbdaxJmvf//PZTcZyV/tFQKttd3GF/tP8N/NRSw/UMY0bQc3WOCaWeP506x5BFjc9LXm6wcBUZ5htV/XmeULdp8MWq8IToD2ZnzbasmJDScnNpirx4gAau+wcaisnp1F1Z2irYbnVh/rGjgeGWhhTGo4Y1PDGZcazrDEUOf3J9YUuKdBiJ1Qu9V+gXcKtNId0NHimPJGO/b324J17jk+QaFQKNyfdl3Xx53j+z3tpvY4q0fTtNmIQJvmiMB6wk2vOs+NruuLgcWB/lYHblF6OS11cHwnTHdQz1hgJEQPgbw1MP0+x5zTAI7XNPPy+jze2FhIRUMrsSFWvjkrk6/7l8AXMHv8KHBXcWYnNNEzMmj2MkwPyKB9iS6r/VKxie+Gj9nEkPgQhsSHcN14ua+lvYMDx+vYUVTD9oJqtuRX8tneEwBYzCaGJYYwNjWcsakRjE0NJzrY6th4a4ogyQFZcmdhN7rwVifHgvVyTHFgr2X8SDBbZKSGEmgKhULhDIqA7rubScAZ/SOapo0AngEu1nW9wlnBuPmVp8JhFG4E3XbKEcwRpE2F7a9DRxuYezlXyg3QdZ2tBVU8vyaPj3cfx6brzBsSy40TU5iRHS3mD8vflR/2hGxPSCJU5RkdxfnpEmge8Jx2xz5qoa6kVxkfq4+ZEUlhjEgK45ZJqQCcrG9ha34VWzpvL67L5+lVxwBIjQxgfFoEkzMimZwZSUJYPzLcLfXQVOXeJY6B0VJq7a1OjoUbIDwdgmIcd04fqwytLt7iuHMqFAqFojubgGxN09KBYuB64MbuP6BpWgrwNnCLrusHnRmMEmgDhYL1MmQ6abzjzpk6FTY9I5m5xLGOO6+TaGnv4IMdpbywNo9dxTWE+Plwx7R0bpmUSnLEac38NUUQGOMZBighiZC/xugozk9ticzgC4o9/8+6E3aB1g8jlqggKwty41iQK9m4lvYOdhfXsjW/is35lSzdd4I3t0iZampkQJdYm5wRSUyIX+8X6nJwdGM7dpNJBKQ3CjRdl/fa7PmOP3fSeNjyAnS0g1l9dCsUCoUj0XW9XdO07wCfIDb7z+m6vkfTtHs6v/8k8EsgEvhXZ3/5+com+4x6lx8oFKyTHVhHuqbZeywKN7m1QCurbeaV9fm8trGAk/WtZMUE8bsrh3H1mMSz95bVFLp3FqI7oYnQXCPZE2uQ0dGcnbpSEWcmF82IcxTB8YDm0DJSq4+5s8wxnLvIwGbT2X+8jnVHK1h3pIIPd5XyxiYpAcyMDmRKZhQzcqKZkhlJoPUcb9t2gebur92wFO8scazKg8aTjt0Is5M0DjY8AWV7pORRoVAoFA5F1/WPgI9Ou+/Jbl/fCdzpiliUQBsItLdK78LY2xx73tBEyd4UbQTucey5HcC2gipeWJvHhztL6dB15gyK4bap6UzNijy/s151IcQNc02g/SWk82K8thiiBxkby7moLT6VjfIkzL4iLJ1oxGIyaQxNCGFoQgh3TEunw6azp6SGdUcqWHe0gre2FvHy+nx8zRrj0yKYNSiaWYNiyI4J+vJr2d2HVNsJS4YDS4yOwvHYSxCTnLChaj9n0SYl0BQKhcLLUQJtIFC6A9qbHdu0bidpvFsNnW1tt/Hx7lKeW5PHjsJqgq0+3Do5jVsnp5IWFdi7k9hskokYdLFzg3UU9mHVNUVuLtBKITrH6Cj6houNWMwmrauP7RszM2ltt7E5r5LlB8tZfqCM33+0n99/tJ+EUD9mDopmZk4M07KjCKoplDJSd++dDE2BhjJoa3KMq6y7ULwVfPxkuLSjCUuV/r2iLTDeJRu4CoVCoTAIJdAGAkWb5OhI22c7yRNh77ty8W2g+UN5XQuvbSjglQ35lNe1kBEVyG+uyOXqMUkEnaskrCcaysUmOyzVOcE6mq5h1W7u5FhbApmzjY6ib4QkQvl+w5a3+JiYkhXFlKwo7r9kCCXVTazoFGuLd5Ty+sZCLD4mXgjdwUi/WJoa24kKcuNSUvsstJoiiMo2NhZHUryl03HRCaZJmiYbYvb3c4VCoVB4LUqgDQSKNkkZnDMElH3oddFGGHqF489/HnYWVfPCmjw+2FlKa4eNWYOiuW1qOtOzojCZ+jgg2F4mFubGs6S644QeKYfTXAutde6f2TkboUlweKmYQLh68HQPJIT5c8OEFG6YkEJru40t+VV8tvcE/ltL2N0Rwg0Pfc641AgW5MayMDfuTBMcownrNgvNWwRaR5tUK4y73XlrJI6FAx+JU+dpIx8UCoVC4T0ogTYQKNrsnJ4IEOMRs1XKHF0k0No6bCzZfZzn1xxja0E1gRYzN05M4dbJqWREO8Akw+4u587DfrvjYxFLb3fOoNWVytETe9BAMmhtDdBc7XYXxhYfkzg+ZkaiH66jJnoc34nN5tM9x/ndh/v43Yf7GBofwqKRCSwaGU9SuBuINfvfljc5OZbtg/YmSBzjvDXs5iPFWyBrnvPWUSgUCoWhKIHm7dSdgJoCmPgN55zfxwIJo1zSh1ZR38LrGwt4eX0+J2pbSI0M4JeXDeXacUkE+zmwpMjTMmggGR53dsXrMq/woOe0O3ZhWVPsdgKtC1sHWm0JYSMy+OHcHH44P4f8igY+3XOCD3eV8scl+/njkv2MTQ3n8pEJXDI83vFDsntLcLz0yrnza/ZCKd4sR2c62iaOATTZdFMCTaFQKLwWJdC8HftFg7MyaCBljhv+De0tMlDVwewuruHFtXm8t6OE1nYb07Oj+MPVw5mVE9P3MsZzUV0I1lDwC3X8uZ1FWCqUbjc6irNT7SHugmcjtJtTpru6e9YWg97xpd7J1MhA7pqRwV0zMiioaGTxzhIW7yjhV+/v4cHFe5iSGcXlIxO4eHicYzc5zofZR4xXqr1JoG0B/wgIT3PeGtZgiBmi+tAUCoXCy1ECzdsp2gQmH+faMidNgLX/gNKdkOyY+T/tHTY+3XuCF9bksTGvkgCLmevGJfO1KalkxThwlltP1BR6VvYMpKdn32JxoDSZjI7mTGqKPMNd8Gx4ghFLVZ4czyIQUiID+PbsLL49O4uDJ+p4f3sJ7+8o4Sdv7eRX7+/h4mFxfGVcEpPSI52z8XE6oV42C614q2TPnN2jmDQO9r7vNv2QCoVCoXA8SqB5O0WbIW64c62s7UYhhRv6LdAqG1p5Y1MBr6zLp6SmmeQIfx64dAjXjksm1N9FO/zVhadMDDyF8FSwtUmvl912352oKZIyQbOHvuUEx3WW5HmCQDu/+2hObDA/WjiI+xbksK2wmv9tLuKDHSW8va2Y5Ah/rhmTxDVmM8mBHc6LNywZjq103vldSUud9KANudz5ayWNh60vQcURiMpy/noKhUKhcDkeebWkadoiYJHV1yPDdx22DtnVHX2Tc9cJjpPd8KK+96HtLKrmxbX5LN4pZYxTsyJ58IphzBkcg9kVu/ndqSmEtKkOO91L6/IAGFRQ8aX7J6ZHOmyNL7niuaVAK/Tc/jMAk1le526dQcsXERnS+zJSTdMYkxLOmJRwfnnZUD7Zc5z/bSnksaWH+Jsey5ToFq5Pa+CixGYsjk7MhibLhkJHm3Ns6V1J6Q5Ad27/mZ1E+8DqjUqgKRQKhZfikQpH1/XFwOJAf+tdRsfi1pTtE+e5RCf2n9lJngD5ay/oIS3tHXy0q5QX1+azvbCaAIuZr45L4pZJaQyKc3IZ49loqoaWWs8TE2FpcqzOh9TJhobSIzWFkOyEQemuJCRRMoHuSlWeZKX6mKX0t5i5cnQiV45OpKiqkbfef4838wO4d1MEUTs7uC6tkRvSG0kKcFBWLSwFdJuIXmf2bbmC4i1ydKaDo53oQWAJks23UTc6fz2FQqFQuByPFGiKXuIKgxA7yRNg95tyAXseI4iS6iZe3ZDPGxsLqWhoJSMqkF8vGsrVY5MIcaVRQU94ooMjnHrO3dG23NYhQ6o91SDETmgSlGwzOoqzU5XnMKGTFB7A94bU893B9aw8YeWVYwE8cSCIJw4EMTuuhZszGphp0/vXqxbWzWrfGwRaeBoERjl/LZMZEkafEoUKhUKh8DqUQPNmijaJq1hEhvPXss/nKdzY44W4zaaz7mgFL63L47O9JwCYOySWWyenMjWzH0OlHc15jBbcFl8/MeCoyjc6kjOpOw62ds8TvafTZcTSIRfJ7kZVHgy+1KGnNGkwK66FWXEtFDeaef1YAG/kBbB0bSTJ+5dx88RUrh+fQmhAHzZW7H9jVXmQPsORYbueoi2QMtF16yWOgXX/cppzrkKhUCiMRQk0b8Y+oNoVTl+xw8DHT3Z1h13ddXdZXTNvbiniP5sKya9oJDzAl7tnZHLTxBSSI9xgYO7pdAm0dEPD6BNhKVLi6G7YywI9rWz0dMJSOo1Yjrtfn19LPTSedOrGQmJABz/KrePeIXV8WuLHy+VZ/OHj/Ty29BBfGZvEbVPTSY8K7P0JQ5LEYbbymNNidgl1x6G2CBK/5bo1E8fKa/H4bkhyQd+bQqFQKFyKEmjeSnMNlB+AYde4Zj0fi1j5F22iw6az8mA5r28sYOn+MjpsOhPSI/je3GwuGR6Pn68bZh/sVOWBXxj4hxkdyYUTlgqF642O4kxqPHwGmh37fDF3NGKxC3MXZH4tJrgsqZnLrp7M3pJanl19rGuA/NzBsdwxLZ1JGRFo59sYMvuI6K086vSYnUrxVjm6wiDEjn2t4i1KoCkUCoUXogSat1K8FdBd03/WSV3UKPx3vMDshz+hsLaDyEALd05L56vjk8mMDnJZHP3CgX08LicsBXa/BR3t7mVn7zUCrZtTprsZsRhUmjs0IYS/fHUkP714EK+sy+fl9fl8vu8EuQkh3DEtnUUjE/A1n8P+MTwdqjw8g1a8Rdwz40a4bs2QRAiKVX1oCoVC4aW40VWcwqEUbQY0p+/qVje28uGuUt7ZWkxsoZXHLS3MCS9n0qJ5zB0Si8XHDYcmn4uqPCnX9ETCU0Hv6HTFO/8sLJdRUyRZSatBzpyOoruphbthcO9kTLAfP1wwiG/NzuKdbcU8u/oYP/zvDh755AB3zcjg+vEp+Ft6yJxHpMt7lScPXS7eArFDweLCkm2t871dCTSFQqHwSpRA81aKNkFUDviFOvzULe0dLNtfzjvbili2v5zWDhtZMUEsmr4ANvydB8c2w/B4h6/rdGwdcvE9+DKjI+kbXRmefPcSaNWOn4Fmny0HX54v59DZcqfj6w+BMe7Z51eVB9YQ8A83NAw/XzM3TEjh+vHJLDtQxr+WHeHBxXv5xxeHuW1KGrdOTvuyoUh4OrTUQFMVBEQYF3hfsdmgZCvkXuX6tRPGwIGPpJzdCe/zCoVCoTAOJdC8EV0Xi/2cix12yjYbrC23sqTYj48+XkpNUxtRQVZumZzKVaMTyU0IQQPYEys74hM8cERdXSl0tHpuiaPdrbPymHu54lXnQ6SXDNQNS3HPDFrFEclGuUkWStM05gyOZc7gWDblVfKvZYf5y2cHeXLFEW6alMqd09KJCfHr9po96pkCrfKoCCRX9p/Zsc9cK9kGGbNcv75CoVAonIYSaN5I1TForOh3/1lLB6wus/JRsT+fl/pR02Yi0MfGvGHRXDU6kWlZUfic3l+SOE6yd56Ip1rs2wlJBLPFvUwXdF2e16x5RkfiGMJS3HMWWuURyag4gQ3HKnq8f+KE3j1+fFoEz982gb0ltTy54gjPrDrKC2vyuGZsEt8dFkcCyKaCC/tlHYZ91mSiAbEnjO6MYYsSaAqFQuFlKIHmjRTZB1SPv+CH1re0s6rYjyUlfiwt9aO+3USwr4358c1cktjEtJgW/CYvOvsJksbBgQ+hsdLzdsQ9XaCZzBK7Owm0+hPQ3uy5z+nphKe63yy09lbJ6g2/1uhIzsnQhBD+fsNo7luQw79XHuXNzUW8t7mFvRaoKj5AuAs9NhxG8RbwDYToQa5fOyACIjJPuUgqFAqFwmtQAs0bKdosFw0xQ877o7quc6S8gWX7y1h2oIxNeZW0dUQQbung0sQmLk5sZkpMC5been3Yd8GLt0D2/L7/DkZQlSdubJ7sNhie7l5zpTx5rlxPuOMstOp80G1yse4BpEYG8vurhvP9udk8ueIoJzaHs3rtBtbW7eC7c7JIu5BZakZTvAUSRhkn1hPHQt4qY9ZWKBQKhdNQAs0bKdok/QlnuWhoaGln47FKlh0QUVZY2QTAoNhgbp+WzizbRsZHttInA8aE0aCZRCR6okALTQKz73l/1G2JyIC81e7jiufpWcnT6W617y4CreKIHCM9Q6DZiQnx45eLhtJ6fBDja2q4f2cJ724v5spRiZ4h1Npb4PgumHiPcTEkjoVd/4XaEghJMC4OhUKhUDgUJdC8jbZmuWiY/O2uu5rbOtiSX8W6IxWsO1rBjsJq2m06/r5mpmZF8o0ZmcweHENimL88YOPqvq9vDYboIZ7Zh1Z51POFREQGtDVAfRkExxodTadA005Z1Hs6XcOq891nFlplp0DzkAza6Viis0ip/oRVP53NUyuO8sqGfN7ZVsSVoxP57pxs0t1VqB3fJaZCRvbO2Y1CircogaZQKBRehBJo3kbpdrC1sc9nMEs+O8i6oxVsL6imtcOG2aQxIimUu2dkMDkzkvFpEfj5OqE0J2kc7H3PfbI4vUHXoeIwDPuK0ZH0j+6ueO4i0EISwcdqdCSOITQZ0NyrjLTiiNise1rPp52oLNj+CjG+LTxw2VDunpnRJdTe3SYZtXvnZrtfRq3IQIMQO3HDweQjAm3IOXqDFQqFQuFRKIHm4ei6ztGTDWzNr2JbYTVpB/7D3cAtn+hUaocYlhjKbVPTmNQpyIKsLvgvTxoHW1+UC8coD7FXb6wUu2xPt4OP6Oz1qjrmHhmeqjz3msnWX3z9RKS5kxFL5RHJnnnKZsjpRGbL8eRhSBpLTLAfD1w2lG/MzOSplUd4eX0+7+0o4dqxSXx3bvapTL/RFG+G4HhjS119/SE2VxmFKBQKhZehBJoHoes6hZVN7C6pYU9JDbuLa9lRVE11YxsAwX4+POt/iBprAn+5cT6jksMI9Tegn8ruHlm0yXMEWsVhOXq6QAtLEaMTdxEQVXmQOcfoKBxLRLr7PL8AFUchuZee9+5IVKdAqzgESafmiUUHW/nFpUO5a0YG/1p2hNc2FPD21mJunJjCt2ZnEhPsZ1DAnRRtNmb+2ekkjoVdb8rQbFNfGocVCoVC4W4ogeamtHXYOHayoUuI7SmpYU9JLXXN7QCYTRrZMUEsHBrHmNQwxqSEkxkdhOmv34fUKczMiTYu+KgcsATLDvOoG4yL40LoEmie2cfThdlX+r3cQUC0Ncnwb0/v6zudiAwp4XUH2pqhptBz/s56IjxdNhVOHurx2zHBfvz68lzumpHBP5Ye4uX1+byxqYCvTUnjnhmZhAdaXBww0FAhWeqxX3P92qeTOBY2PyfvYdE5RkejUCgUCgegBJrBtHfYyK9s5NCJOg6eqOfgiToOnajn6Ml62jp0AKw+JobEh3D5yASGJYaSmxBCTmzwmf1jNcVQV2L8brrJLM3rnmQUUnFYejnCvKAcLyLjlLOfkVTly9HbBFpkJjRVQlMV+IcbG0vVMUD3WIMQAHwsUgZr3yQ5C4lh/jx8zQjumZnJ3z4/yFMrj/La+gLumJ7OHdPSCfZzYbVASWdJoZH9Z3bsWbziLUqgKRQKhZegBJqL6LDp5Fc0cPBEvYixMjkeLW+gtcPW9XPJEf7kxAQze3AMObFBDEsMJSMqEB9zL0pXijbK0UhXMTtJ42DNY9DaCJYAo6M5PxWHRUiYveBPIjIbCl813qSlqtNIw9sEWncjFqNL3MoPyNGIQcmOJDL7vALNTlpUIH+7fjTfnJXFXz87yN8+P8QLa/O4Z2YmX5uchr/FBTPJijbLOJGE0c5f63xE5YAlSASaJ2dSFQqFQtGF21yNapqWAfwCCNV1vVdWejabzoZjFWfcPzE90sHR9Z4Om05hZaNkwsokI3bwRD1HyutpbT8lxJLC/cmOCWJmTjTZscHkxAaRFRNEgKUf/yVFm8HHD2KHO+A36SeJ48DWDqU73MOs4nxUHPH8/jM7UdnQWi+zkYw0MPCWvr7T6RJox4wXaCcPytHex+WpRGXDsZUX1Ec1KC6YJ28Zy66iGh759AAPf7yfZ1Yd4zuzM7lhYgpWHycKteLNMk7EGuS8NXqLyQzxo0SgKRQKhcIrcKpA0zTtOeAyoEzX9WHd7r8IeAwwA8/ouv6wrutHgTs0TXvTmTE5CptNp6iqSQRYmZQlHjxRx+Gyelq6CbHEMH+yY4OYnh1FdkwQObHBZMUEEegMN8XCjfJB7WNAT8bp2LN4xZvdX6DZbOKElznb6Egcgz2bcvKgsQLt5CHwj/Bc+/ezYc8IukOfX/kBCE0Bi5tZ0F8okVnQ3gS1RaeGgfeS4UmhvHj7BDblVfLIJwf49eK9PL3qGPfOzeKaMUm9qz64EHTd/WztE8fA+idkeLa3jLRQKBSKAYyzM2gvAP8EXrLfoWmaGXgcmA8UAZs0TXtf1/W9To6lz5TXtbC3tJZ9pbVdPWKHy+ppauvo0n7y4AAAIABJREFU+pn4UD+yY4OZnBFJTmww2bFBZMcGu8bWHuSDuXQHTLzbNeudj6AYudCyzwpyZ2qLob3Z8w1C7ER19qGcPGSs6Kw47PmZnZ7w9YeQJPcQaCcPeEffkf11cvLQBQs0O+PTInjj7kmsPnySRz49yE/f2sUTy4/wg/k5XDYiAbPJQeW+lUel/9Ad+s/sJI4FW5sMz3aHEneFQqFQ9Aunqgdd11dqmpZ22t0TgMOdGTM0TXsDuALolUDTNO1u4G4AHweXsNhsOvmVjewtqWVvqbgm7i2ppayupetnYkOs5MQGc8OEFHI6RVh2bBAhrmxQ74nju6Cj5ZTFvTuQNB4KNhgdxfmxl+J5stFCd4JiwRpyqvzNKCoOQ9Z8Y2NwFu5gtW/rEEGTNsPYOBxBZDeBljW3z6fRNI3p2dFMy4ri831l/OXTA3zvje08vuwwP5yfw8LcOLT+9mXaN53cSQglT5RjwXr3ikuhUCgUfcKIHrREoLDbv4uAiZqmRQIPAaM1Tfu5rut/6OnBuq4/BTwF4G+16P0JpLSmiW0F1WwvrGZ7QTV7SmpoaJWsmN3Gflp2FEPjQ8hNCGVIfDBhAW5QPtgTdsdEtxJoE2D3W1BTBKFJRkdzdrzFaMGOpkkW7eQB42JoroX6E54zB+9CiciA/R8aG0N1gWR+veF1GxQjjpjl+xxyOk3TmD80lrmDY/hodymPfnaQe17ZyrDEEO6bP4hZg6L7LtSKN4NvIEQPdkisDiEkXjKPhRuA7xgdjUKhUCj6iRECradPRV3X9QrgHmct2tzWwY7CarZ1irFthVWcqJXMmMVsYmhCCNeMTSI3IYSh8aFkxwadaWPvzhRtkrKrkASjIzmFvfesYD0M75XvizGU7we/MMk8eQtROXB0mXHrV3TOtPI2gxA7UdnQeBIaK43rsbNnSL1BoGkaxAyFMscINDsmk8ZlIxK4KDeOd7eX8NjSg9z2wibGpITxowWDmJIVdeEnLdos7o0mN/t8SJ4Ex1YY796qUCgUin5jhEArApK7/TsJKHH0Is0dsPXISdYfrWTD0Qq2FVZ3uSimRAQwKSOSUclhjE4JZ0h8sHMdv1xB4Sb3K22JyZWB1flr3V+gRQ/2rouaqGzY8ZpksvxCXL++fQ5bpBf2oMGp7En5AeNMcOyZ3ygv6EEDeU53vekUgeFjNvGVsUlcPjKB/20p5B9LD3PjMxuYkhnJfQtyGJvaS5Hd2gDHd8KU7zo0PoeQMhF2/Req8qQEV6FQKBQeixECbROQrWlaOlAMXA/ceCEn0DRtEbDIt5uoatfhYEMAu+uC+EtBGNurLLTaNmDSIDchlFsnpTIxI5IxKWFEBnmZy1VtKdQUwCSnJSD7htkHksdLBs1d0XXZtc+90uhIHEt3o5AkA6zgTx6SOVHeeqHY5ZRpoEA7eQACo73HJTNmCLTUOHU8hMXHxE0TU7lmTBKvbSjgX8sPc80T65g9KJr7FgxiWGLouU9QvEXGh6RMcUp8/cLeh1a4wXv/7hQKhWKA4Gyb/deBWUCUpmlFwK90XX9W07TvAJ8gNvvP6bq+50LOq+v6YmCxn7//XUtPhrO9NphddUE02cxo6IwIb+PrmQ1MmjqLcWkRxht4OJv8NXJMcUM7+5QpsOwhcT3zDzc6mjOpL4Pmaplp5E10FxBGCLSKQxCW6r2W3yFJ4BtwKotlBGX73KsPqr/EDJVj2T6nj4fw8zVz+7R0rp+QzItr83lyxREu+8dqLsqN4wfzcxgUF9zzA/PXARokT3BqfH0iZqiYAxVugJHXGx2NQqFQeBw9jQE77fuDgeeBMcAvdF1/xFmxONvF8Yaz3P8R8FG/zx+WxFOFSUT6tjIlvIaRIXUMD65ndlanEBjsRT1F5yJ/rZQSxo0wOpIzSZkE6DKjLWeh0dGcid2UIMaLLnQBwtPBbIUTF7T34ThOHvbe/jOQYcpROVIeawS2DjixF8Z+3Zj1nUFM5yZJ+T7InueSJQMsPnxzViY3TUrh2VXHeHb1MT7Ze5zLRybw/Xk5pEedNl+uYC3EDgP/MJfEd0GYzFLm7gnOuQqFQuFm9HIMWCVwL+D0sisHT/B0LVpjFX8efJDHcw9wd0oxE8NqCTDbzv9AbyN/jfQfmI2oWD0PiWPB5Csi0h0p67zA9rYMmtlHRKcRAq2jXQwsvE30nk70ICg3aJRB5TEZ7Bw3zJj1nUFAhBj1ONgopDeE+Pnyg/k5rPrJbL4xI5NP9hxn3qMr+PH/dpB3skF+qKNden2NKmntDcmToGwvNFUbHYlCoVB4Gl1jwHRdbwXsY8C60HW9TNf1TUCbs4Nxwyv689O9By3Fv+W8P+/VNJyUXfwR1znkdC+ty2NQQcUZ909Mj+zbCS0BkDDKffvQuhwcY4yOxPHEDoNDn7l+3cqjMpMvJtf1a7uS6EGw8z/GGLGc2CXHWC8SaCAlm2W9GonpFMIDLfzs4sHcPi2NJ5Yf4bUNBby1tYgrRyXyw2ENJLU1dFYFuCnJEwBdRgFkuSYLqVAoFB6Cj6Zpm7v9+6nO0V12ehwD5pLIesAjM2i6ri/Wdf1us8kjw3cs9sxU6lRj4zgXKZOhZCu0NRsdyZmU75fSKm9ycLQTmwsNZdJn50rKOrN2sUNdu66rsfd/nTzk+rVP7AHN7F09aCB9VOUHpITTyDCC/fjVolxW/WQ2t09N56PdpTz/+msAHAlww1JyO0njxJxHlTkqFArF6bTruj6u2+2p077f4xgwVwTWE0rheDr5a8HHX+byuCspk6GjVRzQ3Aldlz6eGC8rb7QT25nBcnWZ44m9cpHoLfbvZyOqmxGLqzm+W0Yp+Pq5fm1nEjcc2hpPjWkwmJgQPx64bCirfzqHr0YXUqDHMu/pg3zr1S3sK601OrwzsQZLVrXQTSsWFAqFwn1xyRiw3qIEmqeTv1qs7H0sRkdyduwlQQXrjI3jdKryxNbbHc1VHIG9/M3VAq1sL0Rkgq+/a9d1NeFpYsRiREneid2nBLg3ET9SjqU7jI3jNKICLQxq2UPssJl8e1YWKw+e5OLHVnH3S5vZXVxjdHhfJmUSFG2RnrmBSlO1vL9X5UOH01tFFAqFd9A1BkzTNAsyBux9o4Lx+B60AU1Tteykz/qZ0ZGcm4AIKcVyN4F2fKcc471UoAVGiemCyzNoe7z3Oe2O2Ueyr8d3uXbdpmqoKYRxt7t2XVcQPUhE7/EdMOJao6M5RcVhaDyJNWMaPxo7iLumZ/DcmmM8t+YYn+49wcycaO6ZmcmkjAg0o8ulkyfCxqekT9GdKyucwfHdcGy5iDM7mll68mb9XLLOCoVC0QO6rrf3NAZM07R7Or//pKZpccBmIASwaZr2fWCorusOL6nwSIFmn4Pmb7XcZXQshlK4AdDdu//MTspk2P2W9JaY3ERYl+6UD29vNrOIzZVsi6tobZCLo5E9TtjwPuKGw4GPpFzWVRfmdsHtbQYhAGZfec26WQbtVK+vDKgODRDXxzump/PS2jyeX5PHDU+vZ2RSKPfMzGRBbhxmk0FCzT4PM3/twBFozbWw9SXZdAuMhkGXQHC8fN5UHoEDS2Dve7DwDzDhLu/sOVYoFP2mpzFguq4/2e3r40jpo9NRJY6eTN5qsbBPGmd0JOcndQq01J7KWrkDx3dKZs/b+ni6E5srRijtra5Zr2w/oHu/QYiduBHQWAG1LixTL9kqx4RRrlvTlcSPEIGmG9abfSYF6yAg6ozZfiF+vnxnTjZrfjaH3105jOqmNr756lbmPbqC1zYU0NxmgNlJaKKUGB9b6fq1jaC+HF68TDaici6G6T+CzDmS3Y4bBkOvgO/tEFfLj38MH97nXq8thUKh6AEl0DyZ/LUyZ8wTen3SZ8jx6Apj4+hO6U7vL8VLGCMGLa7KotkdHGMGiECzv35cWeZYvBVCU7xzNARIH1pzDVTnGx3JKQrWSW/XWTIvfr5mbp6Uyhf3zeLxG8cQZPXh/nd2Me2Py3h82WFqmlzcB5U+XT4fvL0PrbkGXrpc5hGOvQ2y5vZcoREUDde/DlPuhc3PwpKfKZGmUCjcGiXQPJWWeijZBmkeUN4IEBwnw6CPuYlAqzsB9ce91yDETuIYOdqzLs6mZBtYQyA83TXrGU1sLqC5WKBtgUQvLl3rMgpxk2x7dYGU7failNxs0rh0RDzvf2cqr905kSHxwfz5kwNM+cNSfvXebo6W1zs/XpANsZZa9ysVdSQdbfDfW+HkQbjxjfO78ZpMMP83MOlbsOFJWP+Ea+JUKBSKPqAEmqdSsB70Ds/oP7OTMRPy10G7GwwX93aDEDthqeAfAcXbXLNeyTYpvRsoMwqtwRCRIaYWrqDhpGSWEse6Zj0jiMmV3tDS7UZHItiz/pmze/0QTdOYkhXFy3dM5MN7p7EwN47XNhYw5y8ruG1NBCtPWJ2bwEmbLsc8Ly5z/PzXcHQ5LPo7ZMzq3WM0DRb+HgZfBp8+AMdWOS8+hUKh6AceeRWladoiTdOe6rDZjA7FOI58IW5nnU3rHkH6TGhvgsKNRkcCJZ0Xf3HDjY3D2WiaZNFckUFrbxEXtYFiTGAnbrjrMmglnUI7YYxr1jMCXz/pHSraZHQkwtFl4obax6HguQmhPHrdKNb8bA7fn5fNrmpfbl0TyfzPo3n5aACN7U4wrAiKkXi9tQ/t4Kew7p8w/k4YfdOFPVbT4MonIDIT3rwdGiqcE6NCoVD0A48UaLquL9Z1/W7zQNml74kjS0WceUL/mZ20qbIzfnS50ZFA0Ua5gPELNToS55MwRoxCWhucu86J3WBr827x0BPxI6QErqna+WsVbwE07zUIsZM0wT1medlskkHLmNVv57+YYD++Py+HNRed4NFxVfibdf5vexiTPo7lwR0hHK51sKlyemfFQluzY89rNA0V8O43xcV0wUN9O4dfCHzlOWiqgg++r/rRFAqF2zGAFY4HU1MsF9yZc4yO5MLwC5XSrCNfGBuHzSa780njjY3DVSSOBd3m/H4Ue3YncYAJNHu5YfFm569VvEU2FqzBzl/LSJInQFuDMUPAu3NiNzSehIzelzeeD6sZrk5p4v3ZJ3lrZjkzY5t55Wgg8z6P4asrInl3W7Fj3B+z5krFQsHa/p/Lnfj4J2IOcvXT/XPgjRsOc34B+96XETAKhULhRiiB5okcXSbHrLnGxtEXshdIuV19mXExVByWndPkCcbF4Ersgql4i3PXKd4GAZEQmuzcddyNxLGgmaDQySV5XRsLXtx/Zsf+t1lkcDm0PdufMdPhp9Y0GBvZxj8mVLP+khP8fFgNZc1mvv+f7Uz6w1J++8FeDpf1w1QkbRqYLXB4qeOCNpoDH8PuN2HmTxwzymPKvZLx/+R+EX0KhULhJiiB5okcXio9EZ5oZZ49X45GXjTYL/qSBohAC4qB8DQxlnEmJVvlYmegDYG1BouxReEG565Tvk82FjzJGKivhKVCYIzx/aqHPxP32ZAEpy4TabXxjZwGvlhQxqt3TmRqZhQvrs1j3qMruPbJtbyxsYDa5gu06rcEytBqbxFobc3w8U/l/2PaDxxzTpMZLnsUGsrhiz6WSyoUCoUTUALN0+hok/6zrHmeeSEcN0LE5aFPjYuhcKOUW0blGBeDq0mdKnORnGWs01wrZbcDrbzRTvJ4yVA607gob40cB4JA0zTJohkp0Jpr5G8mZ6HLljRpMDUrisdvGsO6n8/lpxcNpqKhlZ+9vYvxv/uc776+jeUHymjv6OXrLGueCPuaIucG7grW/UMcTC/+I5h9HXfehNFiNrLp6VPmUQqFQmEwHinQBrSLY8E6uXAYdLHRkfQNkwmy5ksfmlEGAPb+s4FkMpM6FZoqRUQ5g4L10ufmSa6ijiRpgsydctbzC5C/BkKSICzFeWu4E8kToOqYzCw0giNfgK0dci4yZPnoYCvfnJXJ0h/O5N1vT+W68cmsOlTO15/fxJSHv+D3H+1jX2kt+rkMLuxl8Ic/d03QzqKmGFY9CkMud0q5KbN/AQFR8MEPwOaA/j+FQqHoJx55hTqgXRwPLBF7fQc2rbuc7PnQXO38krCeaKyEsn2QPNH1axuJXTjlr3HO+fNXg8l34JSNno69Z8pZr2ldl2xO2lTPzJz3hdRpcswzaFbVwU/BL8xwMyFN0xiVHMZvrhjGhvvn8uTNYxmZHMZzq49x8WOrmPfoCh797CAHT9Sd+eCYoRCaIr1bnsxnv5QNoAW/c875/cNkPlrJVtjygnPWUCgUigtgACocD0bX4cBHkD4DrEFGR9N3suaKyNz/gevXzlsN6PIcDiTC0yAk0XkCLW+NlDdaApxzfncnIkN24J0l0CoOQ0PZwMpQJowCa6gxYzlsHVKGnT0fzA62v+8HVh8zFw2L4+lbx7Hh/rn87sphxAT78Y8vDrHgrytZ8NcVPPb5IQ6XdYo1TYPBl8CRZdDSD8MRI8lfK8YgU78H4anOW2f4V2TA9xe/k15PhUKhMBAl0DyJ8gNS8uOp5Y12rMEyImDfYtfPnzm6HCxBp6zRBwqadqoPzdHPeUu9WOynTXPseT0JTZPf/+hy57ym7QOHUwfQc2wyQ/p0mUPm6veJwo1ir29QeWNviAyycvOkVF6/exIb7p/Lb6/IJTzAwt+WHmTeoytZ+NeV/OXTAxyOmAkdLcaPN+kLtg6x1Q9Jgqnfd+5amgYXPSzVHcsfdu5aCoVCcR6UQPMk9r0vR08XaABDFkFNIZS6uCn72ArJQjiyydxTSJsG9SekxNORFG4AvWNgmFeci8zZUFcqGymO5vDn0nsWmen4c7szGbOgpkA2plzJ3ncly+9Cg5D+EBPsxy2T0/jPNyaz4edzefDyXMICfPnX8iMsfKedGoLY8umrfL73BE2tHtRjtfVFOL4LFvzWNdn5uGEw9jbY+LTj3ycVCoXiAnCf2g3F+dn9ttgmO9ny2SUMuhg0M+x9X1y0XEFNkZSKjbvdNeu5G/YRB4c+ccwMITt5q+X/cqD19Z2OvS/06DKIGey487a3SGZu1I0Dp//MTnqnIcTRFVJG6gpsNtj7njggeuBA8JgQP742JY2vTUmjurGV5QfK2bdsCkOqVjH2pfWYfSxMz45i5qAYZmRHkRoZaHTIPdNUBUt/K1nj3Ktct+7sX0hJ5ZKfwy3vDLy/OYVC4RaoDJqnULZP7JJzrzY6EscQECHlS3vecV350tEVckx3gguYJxCSAHHDxfzAkRz6VDYOPLkv0hGEp4qIOLLMsefNWw1tjTLkfaARlQ3BCa4tzyvaKJnQ3Ctdt6aTCAuwcOXoRCZdegehWgPvXdTKDRNS2H+8jv97dzcz/7yc6X/6gp+/vYuPd5VS03iBs9acybI/SLnhxQ+7ViQFRopIO7pMer4VCoXCADw6g5YYZCO5bDkN1hhqA9No9/Fig4Ldb4NmgqFXGB2J4xj+VXjvW2J7n+wC97/Dn8vwW08c8O0oshfC6r/K7rR/eP/PV10AJ3Y7z13N08iYDTvegPZW8LE45pyHPgMfPzEwGGhompQZ7vqfDCr29XP+mnvs5Y3u2392wWTOAf9wcis+Jfeaa/nVoqHkVTSy6lA5qw6dZPGOEl7fWIBJg+FJYUzLimRCeiRjU8MJshpwmXBiL2x6RsoN44a7fv1xt8Pm5+CT+yFzrmtedwqFQtENjxRomqYtAhYNjzURV7EBEzZ0NKqCcyiNmABEGh2iY9F12P2W9PgExxodjeMYejl8eJ9c0DpboLW3yIXusKsH1vyz08lZCKsegcNLxbWsvxz8pPO8XnQx2x8y58DmZ6FgrfRP9Rddl5LUtOkD1yFz8GWw5XkxSslxchaxo03K27Lng1+I05bZcKzirN+b6Iy3Qh8LDL0Sdv4XWhvQLIGkR8nt1slptHXY2FFYzapDJ1l1qJwnVxzl8WVHMGkwLDGU8WkRTEiPYHxaBBGBDtp4OBu6LsYg1mCY84Bz1zobZl8xDHn5Slj/L5j+Q2PiUCgUvWfj00ZH4FA8UqDpur4YWOxvtdy1afCPCWwuJaLuINHV24moOwAtO2SgpbdQsB4qj3jfh4Q1GAZfKuLzoj+Aj9V5ax1dAa11Yk4ykEkcCwGRUrrjEIG2BCIypRRNIQLNN0B6mDJm9f98x3dC5VGY8t3+n8tTSZ8OlmAZy+FsgXboU2goh9E3O3cdIxh+rQjdAx+f8bfvazYxLi2CcWkR/GB+Dg0t7WwrqGbjsQo2HKvk5fX5PLtajFqyY4IYlRzGqJQwRiaFMSguGF+zAze99rwts+8ueURK4Y0iczYMuhRWPgIjb4CQeONiUSgUAw6PFGhfQjPR4J9Ig38ixVFTia/YQFLZBjh5CCLSHXMRajTbXhFr+KGe3xNxBiOvlx3rAx87t+dj/2K5yBto889Ox2SWMtntr0NLXf9MEFrqJKsx4W7HxefpWAIkS7lvsVxgmsz9O9+u/8kAcG/82+8tPlbIniebCra/9v85PRfbXpUy6Kz5zlvDKFImQ2iyfJ6c53Mx0OrDtOwopmVHAdDS3sHOoho2Hqtkc14ln+87wf+2FAHg52tiWEIoI5PDGJUcRm5CCGmRgZhMfegba6mDT34BcSPcw8xp4e/g8Ymw9EG46kmjo1EoFAMIzxdo3bCZLBRHTycpdxrseB3eukNs3Oc96NwPdWfSUidGGsOv8U4Thsw5ctGw+VnnCTRbB+z/SHbfnZml8xRGXCf9Ffs+gFE39P08e9+HjlbvylY7gqFXyt9s/pr+bQjYbLDrLXETNDKT4A4Mvkye04L1kOakcQ715VJOOumbbjWc2mGYTDDmVlj2kGRlL8AV0+pjZnyalDgC6LpOYWUT24uq2V5QzY6ial7plmXz9zUzOD6YIfEhDIkPYWh8MIPiQs7fz7biT2LQ8tWX3OMzOyIDJn9b+nbH3wlJ44yOSKFQDBC88FMICIyCSd8SS/W1/5Bs2tVPO7WnwGnsehPaGmD0LUZH4hxMZtkpXfqgzI+KHuT4NY4ul6GzSkgIyRNlptbO//RPoG1/TcobXWHw4klkL5Ayxz3v9E+g5a+BuhKZATXQGXSxVBFsf815Am3LC2Br9973WpDfbfnD8rvO/02fT6NpGimRAaREBnD5SBn70tZh48DxOvaW1LK3tJZ9pbV8sKOE1zYUdD0uNTKAwXHBZMUEkRkdRFZMEBnRQSLcyg9Iv9fom93rPWX6fVJx8OEP4c4vvFO8KxQKt8N732lMZrj0EZlH9NFP4NkFcPObEJpkdGS9R9dh/RMQOxySxhsdjfMYcyss/4M0eF76iOPPv+0VcSz0hgHfjkDTJIu26i9QW9K3uXpVeZC/Gub8n5oTdDqWABh0ifRWLnio7+Ye9tLmQZc4Nj5PxBIoGfbd78DFf3R8NUF7K2x6Whz7nLFJ5C6ExMv74LZXxUregRUFvmYTwxJDGZYY2nWfrusUVzexr7SOfZ2i7cDxOj7fV0aH7dR4lbhgK8+afkOG5s/7YXcQd7CclIgAEsP8sfgYbOpkDZYe6Tdvg/WPw9TvGRuPQqEYEHivQLMz/k6IzIL/3CIi7ZZ3POcD+PBSOHkArvq3d18EB0bBsGtkd3z2/Y4t52qsFHOBcber8sbujLpRmt83Pg3zfnXhj9/+OqBJD6HiTMbfIb2Vu/4HY7924Y+vOy4Cb/wdA9e98XRG3Syide97MPomx557z9tQfwKu+Jdjz+uOjL9D3hN3/hfGODdbqGkaSeEBJIUHMH/oKQfi1nYbBZUNHC5r4Eh5PbEHXiH3+A5+rd/NCx+XAqWdj4eEUH+Swv1JiQiQW2QAyREBJIcHEBlo6Vuv24WSe5X8PS77vZTbRmY6f02FQjGg8X6BBuKmdttH8PLV8NxCuPF/kOwBGal1/4SgOO8ZTn0upn5P7PbXPQ5z/89x5935X+mT8kZXtv4QkSGOlpuflRKeC8lItDbKjKKseZ6VkXYlKZMhdphkZcbceuEbLJuekXK7id9wTnyeSMokKand+pJjBZrNJqXwUYMga67jzuuuZMwWE441j8lGjQG9XhYfE1kxwWTFBEPlMVj7FGTM5lc3/5Fv1rdSUNlIQUUjBZWNFFbKccXBcsrqWr58HrOJ2FAr8SH+xLWHEe9vI9a/g3j/DuI6j9F+Nvr9G2qamP48PhHe/y587YOBPa5FoVA4nYEh0ECGXd7xKbx8Fbx0OXz1ZXEGc1eKNsPRZTD3V44beOvOxAwRd8EN/4Yp33HMEGVbB2x8ChLGGDPs1N2Zci/se1+yEpPu6f3jtr4kPX3T73NebJ6Opkn2/oPvQ/7aC+ubam0QE5dBl1yQkYPXo2kw4S5Y8jMo2AApEx1z3r3vyrB1b69UsKNpMO0HUrK3/0OZR2kUNhu8920RiVf8E81kIjbEj9gQvy5Dku40t3VQVGUXbk2U1jRzvEaOO6osLCkx02r78v+hhk7Ep58RFWQlKtgix66bhahgK9Gd/44ItJy9pDIkHhY+BO9/R8YVjL/DGc+IQqFQAANJoIHY7t/xKbxyNbx+HVz5BIz4qtFR9czS30BAlFyQDBRm/FgultY8BvN+3f/z7X1X5sd99aX+n8sbSR4vmZ7Vj8pOem9MdNpb5P8ndSqkTnZ+jJ7MiOukt3Lpg3D7J72/+F/zd2isgGnfd258nsiYW2HFH2HN3yDl9f6fr6NdytaiB8ucsIHC0CtE/K/4o8yiNMoxceO/xQznisd7lY338zWfyrydca6n0XWoajVR2mTiRJOZ0iYzJ5rNlIekcrK+hZP1LWwtqOJkXStNbR09rhFoMRMWYCEswJfwzqP961C/KSyKmkzkJw+w3zoa//gcwgMsBPv5OHYWnEKhGPB4pEDTNG0RsMjXpw8fKkEx8PUP4Y2b4O275EJo0jcdHmO/OLYSjq2Ahb/v35wqTyNuGIy4XsocR9/Svzp/XYdVj0rZ0uABPpz6XCx4CJ6ZKxdqCx9xW1IrAAAX9UlEQVQ6/8+veUycBa8cAL06/cUSID2Vi78nc9F6k6moKZbnOPcq93KycxcsgTDxHhG+Zfsk894ftr0EFYekosIdbN1dhckMcx6AN2+X0nJH9/T1htKd8PmvIXshjHLM+poGEVYbEVYbuWHtp74x4cwKioaW9i7RVl7Xysn6FiobWqlubKO6sZXqpjaqGlspqW6iqrGVmqY2bDo8w418bN2F/uZtXNz6IK34AjIPLtjPl2A/H0JOO8rN90vHnn7GR4k8hULRiUcKNF3XFwOL/a2WvqWX/ELhpjfh7TulXKa+DOb+0j3KWzraYcnPISQJxg3AEor5D0rZzZKfw43/6fv/yZ63T5UtqV6Bs5M0VowCNjwpGZ/4EWf/2bJ9Mqco92rInO26GD2ZUTeLE+tn/ye9sOfKUuo6fPwT0G0yu1HRMxPuhnX/gk/uh5vf7vt7RN0J+OzXkDpN+jEHGrlXy/P4xW/FIdMS6Lq1m6rhv7dKKfsVjxvy2Rto9SHQ6kNqZO9+b5tNp665neqmVqr2+TH887tYMvhjVmb/jLrmdmqb26hrbv/S1yXVTV33nS1j1x1/X3MPgs6HYKvvmff1IPqCrD74+Q6gjQaFwovxSIHmEHz94NoXZbbJ6kehoRwu+5vxM042PCHC4rpXJMaBRnAczPoZfPoLcXXsy85ucw0suR/iRw2ssqW+MvfXcOhzeONGuHMpBMee+TNN1fDWXSIwLvmzy0P0WMw+cNlf4YXLpHfl2hfPfjG67p/irjf/txCe6to4PYmACMlMLvmpbOYMuezCz6Hr8vj2Jlj0N/fYnHM1miZZ8+cWSplnbzLojqCjHd66E2oKpZolKNo16/YTk0kjNMCX0ABfmPZVaNxFxtq/kzF8Ckw9v1NrW4etU6y1nSHo6rq+7lnk1bfIfY2t5xd5FrPpDAEXZO2euet2v1/P9/v7mtEG4t+EQuFGDFyBBlLmcdnfIDAaVv4ZmqrgmmfA19+YeCqPwrI/QM7FYuU7UJn0TTi4BD76sQxVjsq6sMcv/Y1YZt/w+sAqW+orgZHyXD1/Mbx6jZR7RaSf+n5jJbx6rYx8uOF1GYug6D2pU2SUwWe/lNu8B8/M6m5/HT77lQxTn/JdY+L0JMbfCVtfhI9/Ks/vhY7m2PKCDBKf8wBEZTslRI8gZZJUaqx7XF57jjJeORt2YXz4M/nsTZnk3PWcybxfy2bqh/dBWDJkzjnnj/uaTUQEWogI7LvpV3uHrUus1Ta3UW8XeC1fFnb1pwm//PpG+bqlnfqWdnT93OuYTRohfj6EBVgI7Ygi3reBTNMJYs01RJlqCTW1YPX1xVL3On4hkfjFDyYkIp5gPx/XjD1QKAYAA1uggewiznlARNrHP4FXroHrXwP/MNfG0d4C//s6mH0lQzGQd69MZrj6KXhiipi53Lak97usO/8rFuWTvgWJY5wbpzeRMEqE2Zu3w79niBlD/Cjpz9nwb2itF7OVLDd2PnVnptzbaSf+dzh5ULLEcSOgOh/W/lPGHaTPMKzcy+Mw+8AV/4RnF8Lbd8ON/+19KXPhRnmvz5wL037o3Dg9gfkPwqHP4J274e7ljnHQPRvLHpL35ynfhXG3OW8dV2Ayw1eehxculTmrX3sfEsc6dUkfs6nTwKTvIs9m02lobe8SdPUtbdSeJuj0miISy1YSX7OdxJbdJDQd7/lkRS92fVmmh7FDT2abeTi7rOM4GTSIsEAL4QGWLmEaaT8GWYgItBIZZCHY6qOydQpFDyiBZmfiNyAgEt75Bjx/iVyMXmjmpq/Ye09Kd8D1r8tu3EAnJAFueANeulKyOje/ff7MTd4amVGTOlX18PSF7HnwzdXw0U9kPEFHq9yfMVsMa2KHGhufJ6NpUuoYlSM9PweXnPqeyUf6qhb+XjZoFL0jcSxc/LBkMJb8DC56+PwirXCTbMKFJEq1hMqwixHVNc+I0HjzDrjpf45/XnRdjF1W/lk2f+b9xrHnNwr/MLj5LXh2Abx0FdzyNiSNMzqqc2IyaZ2ljKe911TlwY7/wP7FcHyX3BcUB1GREDpS2g8sQbT7BFKn+1HX3EZDwhRaak9gKj+AX9V+htbsZUbja9D8GtWtEaypn8L7+jQ+aUqjsdXWYzy+Zq1TwFm/JOAiO+/r/u/IQCsh/krQKQYGSqB1Z/hXZPfwzdvh39Ph4j+Km6Cz3wxW/ElKbqb9AAZf4ty1PImUSXDdy/Cfm+GpWdK/k9TDDqWuS+bs/e9AWKqI64EwO84ZhKXAjW9ASx1UF0Bocu/s9xXnR9Ng8rekr3L322JOZA0Wg4aQBKOj80zG3QEVR2D9v+Q1e+kjPZtd6DrseB0+/JH0WH5t8YWXRXozKROlcuOD78Pie2HRPxxnrtTRJiJ664timnPZY95l3BQcJ710Ly6Cl66Aa1+A7PlGR9U7Whtg73vS7523CtDkc3feg5BzEUQPkoxnN3yAcCA8FBg748xz1pbCkS8IO/QJlx78hEvbP4CoDNpyr6Ui80rKfRI52dBCZX0rlQ2tVDS0UtnQQkW9fF1Q2UhlQyv1Le1nnhvwMWldGbmoIGuneLOeEnFBX/460KL66RSeiRJop5M1F765Ft69R7IxBz+RDy5nXEDpuoiz5b+HkTfKUGrFl8meD7cvgTduhmfmiPOY3W1Q16F4M2x8Wj5cUqbA9a+qCy9HYA2G2Fyjo/BO/EI9v7zLXdC0znEkIbDiYchbDTN+JK6MARHQUi+Dwtf9U0aXpE6Fa56VocOKLzPuNqgrlZEbNhsseqz/G101xTIQu3ADTP+RtBN448VyWDLc9hG89lW5zf8NTPq2ewpRXZe/ie2vyazQ1nqZiTfnARlz098KnpB42YQafZMYdu1bDDv/g++qPxG36o/EpUyWsQrDrjznGKHmtg6qGlu7hFt3EVfZeaxoaKGgoJGK+hYazmKgYvUxdQ0ht4u5qCB7pk7EXFSglYhOUadcMBXughJoPRGaCLe8Jx/qX/wW/r5Uauanfg+sQY5Zo6UePvqR7OqOvAEu/7t3fnA5goTR8K21MsB3/RNiod+dgCi4+M9ygaFKxBSKgYWmweyfQ8ZMydQsvlduPv7Q3gzoEBQrQm7iPaqs8VzMvh80s2waVhySHqu+XLDbOqQq5PMHQe8QUTz8Kw4P160ISZB+6XfvgU8fgKPLReT2YgC3Szh5GHa/KdccVXlgCZJ5i6NukqyZM64//EJh9M1yqymGnf+B7a9KtcvHP5WB6aNvko2T09b38zUTH+pPfGjvTNua2zpEtNWfEnIV9S1UNJyacVdR38rB43WcbGiltb3nkssgq09nj9wpMWfvmYs6LVsXHmhRA8oVTkMJtLNhMsHUe2W47OcPwso/SYnGhLtg9K09W5H3Bl2XhuyPfwxV+TDr5zDzp0qcnQ+/UJj7fzDjx1C4Xsqa0CF2uJiBKGGmUAxsUqdI9UPpdrk4bqwAS7AY4GTMAh+rwQF6CLN+CtE58O634fEJMP2H0iPpF3r+x7a3SMZk5Z+hfD+kTReREpnp/LjdAWuQmC1tfhY+eQD+OQFm3AcTvuG4zd0LobZEyql3/U/+LtAgfbpcdwxZ5NrZd6GJ8lqa9gMx6tn+qsS24zUIT5PqmNwrxTypD9dDfr5mEsP8SQw7v6DTdZ2G1g4q6ls4WS9Czl5uebJT4FU2tFJU1ciOomoqG1rpsPVsfRkW4NvVHxcZZPlSyWVEp0lKqL8vof6+hAX4EqRMURS9RAm08xGeBtc+L66Ay34HX/wOlj8Mgy8VW+L0GRAUc/7ztNTLzJ5Nz0DRRikpuO1jSJ3s9F/Bq/D1k4utjFnGxqFQKNwPTZOMe8JooyPxbHKvEhOWJT+Xz7zVf5PPu+x5EDdSLrZ9/KSHqbZYTCWOLocDH4kwjhok2bfcqwbe5qOmyRiIrHny/C39jYwxGHe7GKSEpThvbVsHlGyXMQaHPoXirYAufw8LHoJhVxvf76pp0vOYMlGMffYtFpG25jGZSRueDjkLxWU1bapTRKSmaQRZZT5cbwaV22w6tc1tXWKuoqH1tGydHA+V1bP+aAvVTW1nHWVgNmki2LQYQn1thFpshFlshPrqhFlshPjaCDMXdYk6+xy7IKvMrVMZu4GDEmi9JXk83PqelAlseb6zfvs9+V70EHkDjEgXp0HfAHmjbKoSo4Xju6BoE9ja5M3nkkdgzNeUkYVCoVAo3JOwFOnpLdkGG54S8bXjtbP/vDVUerhH3QSZs1UpaXiazI0s3AgrH+m8/RnihkP2QhFwccPO2Yd1TmwdUqpYfkCyY4UboGiz9JShicCefb9kplzlSH2hWAJg5HVya6iA/R/AvvelPHbDk2C2yLiXpHHy+8SPkufV7NpLV5NJ6xpvkBVz/kxoe4eNqsY2Kuqbqa2toam2gqa6aloaamhprKWtqZb2k0fR21voaGinpVantQNaO3SqgNq9SwFowZdmLDRhoVm30IKFdrMfuiUQ3RIE1hBMfsGY/UII8LMS5OdDkPWUqAuwmAmw+OBvMeHna8bf14y/pfPoa8av82sl+k6hadpFwGOAGXhG1/WHT/u+1vn9S4BG4Ou6rm91RixKoF0oUVmw8CFxOTq+A46thGOrZPewpw8vSxBED5bhyzkLxcjCHRuHFQqFQqE4nYTRcNUT0NEOx3dK6WLdcenvswRKf1/MEIjJdfmFs0eQPAFu+q+IqT3vwMFPJVO06hH5fliKXCMExUg/dUCklONqJrm1t4joaqmDhpNQVyJOiVV50NEi59BMYuo04jpImSxDswMjjfqN+0ZgJIz9mtzamqFgHRz5QgTu5ufEqRVEtEVkStlscFznLV6O/uFS1mwNEuHrG9i36y1dh7amzlvjqVtro9zXWi8GKM3V0FTd7Sj3+TRVE91cTXRzDdh6dqM8A1PnrTd0AE2dt06asVBPgIxA0P1p0P2px586/KnQ/WlA7q/Hn3rdn4bO79Xr/jRpAXT4BtLuGwS+gfhbfPCzmLH6mLD6mLCYTfiaTVh85OZr7rzfx4SvWcNiNuPro2HpvL/7z/qYTPiYNMxmTY4m7f/bu9cYuco6juPf38zsdrcFKffUFi2aBjAkQCGlimkExFC5VE1MMFEJMagJKhATo74xvtPEGH1hIBUQjAhBLrGYBiF4S0y4Fgil5SbXSulyk20pu+3s/H3xnO3utrttaWf6zDz9fZKTc+acM9tf/plM5z/nec5Ql2jURX382KSlsWNdm3b/+PMl2j5UVFId+A1wHrABeFjSqohYN+m05cCiajkTuKZat53fTfdVvZG+0Zl/ehpTDemNdOtb1cR0pTeLgcMOviEeZmZWlnojzfedvzh3kt50+ML0WeHTV8PWt1MDMrQOhtanH69//cnUgLW2T//8+qw0QufQeWmO4KLzUmN89Inpdvj7eiWuG/UNpKuwHz87PR7bDpvWwqZ18OYz8Maz8PYL8PK/00il3VE9/dZkvS9d1a010j4iNU+tVrqRTWusWjchpr+ByIx/f3Bu+qw3MDdtz/3orvtmHTrRPPbPgadXp0a81phoxlH6vLjk8vS3myOpWW2+P6lhfH+iYR9fj25mYHSYgdEtHDW6mbGRYVojw8TIZtj2JrVtm9My02trXBNazRqjo4M0qTNGjRY1xqgxFtUa7dhuhmjGRFcppo7r1JTtncd8xpTzWtXS3OVvTD1v2mPVgdoHeO4MlgDPR8QLAJJuBVYAkxu0FcDvIyKAByTNlTQvIjbu3T+x93qyQZN0EXBRX6PLhlA0ZuUf321mZnYQevDFt6bdf+aSAxxkT2Yfkeaxn3jB1P0R6UP32PaJhqExkD7QZ7oR1ow1Pf4AXqGr9808t3T7CGx5PV1VHHm3alqG07z/be+lhrfVTPVsNScW1armrV6taxPNXK0OfYNpukrf7Int/tkT+wYOS41X/yH79iX8qw/NfGx8eHD/nH2ag1evll00R1NdRod3NHYTjV7aVxvdzODolqpu403rzk3s1P0BtAJaEbRCtCKIiGpfasUigkBEQBDVujq+45x0rBWaeM6kYy2CqI4RqaGrNiEgRt4hUNrecWxym/ZsQ9IjkyqyMiJWTno8H3h10uMN7Hp1bLpz5gNu0AAi4m7g7sFZ/ZfnzmJmZma236SyroQdCH0D6erk4QtzJ+l+jVlpafPwV7GbpvBAeui3ezjh/mZEnLGbE6brtHe+9Lc357SFJ0OZmZmZmdnBbAMw+YcfFwCv7cM5beEGzczMzMzMDmYPA4skHS+pH7gEWLXTOauArytZCrzbifln0KNDHM3MzMzMzNohIpqSvgP8lTRi84aIeErSt6vj1wKrSbfYf550m/3LOpXHDZqZmZmZmR3UImI1qQmbvO/aSdsBXHEgsniIo5mZmZmZWZdwg2ZmZmZmZtYl3KCZmZmZmZl1CTdoZmZmZmZmXcINmpmZmZmZWZdwg2ZmZmZmZtYl3KCZmZmZmZl1CTdoZmZmZmZmXcINmpmZmZmZWZdQ+lHs3iSpBbyfO0ehGkAzd4hCubad4bp2jmvbOa5t57i2nePadobr2jmDEdEzF6YauQPspzURcUbuECWS9Ihr2xmubWe4rp3j2naOa9s5rm3nuLad4bp2jqRHcmf4IHqmkzQzMzMzMyudGzQzMzMzM7Mu0esN2srcAQrm2naOa9sZrmvnuLad49p2jmvbOa5tZ7iundNTte3pm4SYmZmZmZmVpNevoJmZmZmZmRWjJxs0STdIGpK0NneWkkg6TtLfJa2X9JSkK3NnKoWkAUkPSXqiqu1Pc2cqjaS6pMck/SV3lpJIeknSk5Ie77W7YHU7SXMl3S7p6ep995O5M/U6SSdUr9XxZVjSVblzlULS1dX/YWsl3SJpIHemUki6sqrrU37N7p/p+gRJR0i6T9Jz1frwnBn3pCcbNOBG4PzcIQrUBL4fEScBS4ErJH0ic6ZSjALnRMQpwKnA+ZKWZs5UmiuB9blDFOrsiDjVt39uu18D90TEicAp+PW73yLimeq1eipwOrAVuCtzrCJImg98DzgjIk4G6sAleVOVQdLJwOXAEtJ7wYWSFuVN1dNuZNc+4YfA/RGxCLi/ety1erJBi4h/AW/nzlGaiNgYEWuq7c2kDwvz86YqQyRbqod91eIJoG0iaQFwAXBd7ixme0PSh4BlwPUAEbEtIv6XN1VxzgX+ExEv5w5SkAYwKKkBzAZey5ynFCcBD0TE1ohoAv8Evpg5U8+aoU9YAdxUbd8EfOGAhvqAerJBs86TtBA4DXgwb5JyVEPwHgeGgPsiwrVtn18BPwBauYMUKIB7JT0q6Zu5wxTkY8AbwO+qobnXSZqTO1RhLgFuyR2iFBHxX+AXwCvARuDdiLg3b6pirAWWSTpS0mzg88BxmTOV5tiI2AjpggRwTOY8u+UGzXYh6RDgDuCqiBjOnacUETFWDbtZACyphjTYfpJ0ITAUEY/mzlKosyJiMbCcNOx5We5AhWgAi4FrIuI04D26fMhNL5HUD1wM/Cl3llJUc3ZWAMcDHwbmSPpq3lRliIj1wM+B+4B7gCdI007sIOUGzaaQ1Edqzm6OiDtz5ylRNYzpH3geZbucBVws6SXgVuAcSX/IG6kcEfFatR4izeVZkjdRMTYAGyZdSb+d1LBZeywH1kTEptxBCvJZ4MWIeCMitgN3Ap/KnKkYEXF9RCyOiGWk4XnP5c5UmE2S5gFU66HMeXbLDZrtIEmk+RDrI+KXufOURNLRkuZW24Ok/+iezpuqDBHxo4hYEBELSUOa/hYR/la3DSTNkXTo+DbwOdJQHNtPEfE68KqkE6pd5wLrMkYqzVfw8MZ2ewVYKml29XnhXHxjm7aRdEy1/gjwJfz6bbdVwKXV9qXAnzNm2aNG7gD7QtItwGeAoyRtAH4SEdfnTVWEs4CvAU9Wc6UAfhwRqzNmKsU84CZJddIXI7dFhG8Hb93uWOCu9FmMBvDHiLgnb6SifBe4uRqO9wJwWeY8Rajm8JwHfCt3lpJExIOSbgfWkIbfPQaszJuqKHdIOhLYDlwREe/kDtSrpusTgJ8Bt0n6BunLhi/nS7hnivCN5MzMzMzMzLqBhziamZmZmZl1CTdoZmZmZmZmXcINmpmZmZmZWZdwg2ZmZmZmZtYl3KCZmZmZmZl1CTdoZmZmZmZmXcINmpmZmZmZWZdwg2ZmZmZmZtYl/g/uA4oqQvzKBAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2gAAAF5CAYAAADqAwkqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi41LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvSM8oowAAIABJREFUeJzs3XmcnnV97//XZ/bJZN9JJkDYCbsGcEMosqqRWk8tqHWHeirtaU/bA1qP2lN/rZ5zerQtVoqKiK3gCiYaoUAVFFEIigJhMYYAk0BWkpDJJLN9fn/cd+JkmCR3krnnvu/J6/l4zOO+r+v6Xtf9mQkPJu98t8hMJEmSJEmVV1fpAiRJkiRJBQY0SZIkSaoSBjRJkiRJqhIGNEmSJEmqEgY0SZIkSaoSBjRJkiRJqhIGNEkSEfHuiMiIOLzSteyviGiMiGUR8ZEK1nBDRKzYz3vrIuLxiPjEMJclSaohBjRJ0oiJiLcWQ8wjEdEbEXvcjDMizo2IeyNia0SsjYgvRcS03TS/ApgK/POwFz4CMrMf+HvgzyPikErXI0mqDAOaJGkk/THwVmAT8MyeGkbE2cDtQAvwF8A1wFuAH0RE66C2dcD/AP4tMzeVoe5SXQ4cewD3fxXYDvzp8JQjSao1BjRJ0kh6JzA+M18N/GQvbT8DPAecnZmfy8y/AS4DTgA+MKjtBcChFAJOxWRmT2ZuP5D7gW8B746IhuGrTJJUKwxokqQhRcQrIuI/ImJzRHQWhxpePES7xoj4+4hYVRyK+KOIOD0ifhgRPxzYNjOfyczeEj77GOBU4IuZuWXA/d8DfgNcOuiWtwAvAj8d9JzJEfGpiPhFRGyKiK6IWBIRbxviM28ozsObGRH/HhEvRMSGiLg2IpojojUi/ikiVhe/z29HxJQhnrFi0LkVEfHjiDgpIv6zeO/zEfGJiIghvv3bgZnAq/b2c5IkjT7+65wk6SUi4tXAXcA64P8AXcB7gO9FxKWZ+fUBzf+1eG0hhXBxHHAb8ALQsZ8lzC++/myIaz8Ffj8i6jOzr3juLODB4jyugY4A3kahV+rzQDPwe8C/R0RjZn55iOd/D3gC+DBwNvBHFIYdHkHhHzb/F3AihV68bcXn780hFH42XwO+DrwB+GvgKeCLg9ru+J7PAu4p4dmSpFHEgCZJGsqngT7gVZn5DEBEfB74FfCPEXFLZvZExEkUwtlNmbkzqETEL4EvsP8BbVbxdeUQ11YBTRQWBFkdEfXAMcC9Q7R9GDh8QJAjIj4D3Al8CBgqoN2TmX9efP+5iDgS+BPglsx8y4DnTAXeGhF/nJkb9/L9HAG8OTNvLR5fW/wZ/RGDAlpmPhsRPcC8vTxTkjQKOcRRkrSLiJgBnE4hdO1cyKO4+Ma1FIbfnV48/Ybi6z8OesyXgb2Flj3ZsQjIUPO5tg1qMwUICj12u8jM7TvCWUQ0RcTkYvs7gWMjYtwQz//coON7i8+/dojz9cDcPX8rADw3IJzt8EPgyN2030AhgEqSDjIGNEnSYDsCx2NDXFs6qM3hxddfD2xUnGf21AHU0FV8bR7iWsugNrsVBX8WEY9TCHbrgbXA3xWbTBritqcHHe8ImoNXndxxfvLe6hjimVAIlLu719/PknSQ8heAJGl3htqjLAZdG3w8VNv9sar4OmuIa7OAbgrz46AQupKhw9ZfUhiuuQR4F3AxcH7xHAz9e7BviHN7Ol/K97m7e3dnIr/9/iRJBxHnoEmSBltRfB1qDtRxg9rs6CU7hgELehSXiD8c+OV+1vBg8fVMCotrDHQG8MsdQxczsy8inmTo4YJvA+7OzHcMPBkRr9vPusouIg4FGvltb6Uk6SBiD5okaReZ+TyFHqdLI6J9x/nifK0/Ap4HHiieXlx8/W+DHvMuCr1A+1vDExTC3Xsjom1ADRcDR1NYDXGgHwEvL25YPVAfg37XRcQ04H37W9sIOLP4+uOKViFJqgh70CRJQ/lzCgtp/DQiPkdh/tZ7gMOAS4sbKpOZv4qIG4F3RsQY4D+AY4F3UNivbJehjxHxWuC1xcMTi+c+Ujx+OjO/MqiGO4C7I+ILwHTgLyjMjRu8kMe3gfcDr2TX1RxvAT4RETcD/0lhufs/Ap4Fpu3jz2SkXEQhBA+1KqUkaZQzoEmSXiIzfxwR5wB/C1xNYbXCXwBvzMzFg5pfTiFQvAu4gMLwxIsohKhtg9qeC3xs0Lm/Lb7eDewMaJn5g4i4qHj908BW4Fbgf2Tm1kHPuJ1C6LqMXYPNpygsyf8u4HcpDMn8O2AL8KU9/QwqISKagDcD15WyobckafSJzKHmdUuStP+Ke5OtAb6VmVeM0GdeCXwCOKy4JUDNiYh3Af8CHJ2Zq/bWXpI0+jgHTZJ0QCKidYjT76GwhPx/jmAp/0ph5cM/HcHPHDbF+XNXA58xnEnSwcseNEnSAYmIqygMbfwPYDOFTazfBTwEvGLHfDVJkrR3BjRJ0gEpzlX7n8BJFPYiWw0sAv46MzdUsDRJkmqOAU2SJEmSqoRz0CRJkiSpStT0Mvt1dXXZ2jrU3HRJkiRJgq1bt2Zm1kzHVE0HtNbWVjo7OytdhiRJkqQqFRFdla5hX9RkQIuIBcCC5ubmSpciSZIkScOmphcJaWtrS3vQJEmSJO1ORGzNzLZK11GqmhmLKUmSJEmjXU0OcZQkSZI0cnp6eujo6GDbtm2VLmW3WlpaaG9vp7GxsdKlHBADmiRJkqQ96ujoYNy4cRx++OFERKXLeYnMZP369XR0dDB37txKl3NAHOIoSZIkaY+2bdvGlClTqjKcAUQEU6ZMqeoevlIZ0CRJkiTtVbWGsx2qvb5SGdAkSZIkjYj3v//9LF26tNJlVLWanIPmPmiSJElS7fnCF75Q6RKqXk32oGXmosy8or6+vtKlSJIkSRpCZ2cnb3jDGzjllFM48cQT+drXvsY555zDkiVLABg7dixXXXUVL3/5yznvvPO4//77OeecczjiiCNYuHBhhauvnJoMaJIkSZKq22233casWbP45S9/ySOPPMJFF120y/XOzk7OOeccHnzwQcaNG8dHPvIR7rjjDm655RY++tGPVqjqyjOgSZIkSRp2J510EnfeeSdXXXUVP/rRj5gwYcIu15uamnaGtpNOOomzzz6bxsZGTjrpJFasWDGitUbERRHxREQsi4irh7g+ISIWRcQvI+LRiHhPuWqpyTlokiRJkqrbMcccw4MPPsjixYv50Ic+xAUXXLDL9cbGxp0rL9bV1bFjfYm6ujp6e3tHrM6IqAc+C5wPdAAPRMTCzBy4mskHgaWZuSAipgFPRMS/Z2b3cNdjQJMkSZI07FatWsXkyZN5xzvewdixY7nhhhsqXdLunAEsy8zlABFxM3AJMDCgJTAuColyLLABKEuKNKBJkiRJGnYPP/wwf/VXf0VdXR2NjY187nOf4y//8i8rXdZQZgPPDjjuAM4c1OYaYCGwChgH/EFm9pejGAOaJEmSpGF34YUXcuGFF+5y7oc//OHO91u2bNn5/uMf//gu7QZeGwYNEbFkwPF1mXndgOOhdrjOQccXAg8B5wJHAndExI8yc/NwFgoGNEmSJEmjW29mzt/D9Q5gzoDjdgo9ZQO9B/hkZiawLCKeAo4D7h/WSnEVR0mSJEkHtweAoyNibkQ0AZdSGM440DPA6wAiYgZwLLC8HMXYgyZJkiTpoJWZvRFxJXA7UA9cn5mPRsQHitevBf4WuCEiHqYwJPKqzFxXjnoMaJIkSZIOapm5GFg86Ny1A96vAi4YfF851GRAi4gFwIIdeyVIkiRJ0mhQk3PQMnNRZl5RX19f6VIkSZIkadjUZECTJEmSdHC57bbbOPbYYznqqKP45Cc/WelyyqYmhzhKkiRJqpwb71sxrM975ysP3+P1vr4+PvjBD3LHHXfQ3t7O6aefzpve9CbmzZs3rHVUA3vQJEmSJFW1+++/n6OOOoojjjiCpqYmLr30Ur7zne9UuqyyMKBJkiRJqmorV65kzpzf7iXd3t7OypUrK1hR+RjQJEmSJFW1zHzJuYioQCXlZ0CTJEmSVNXa29t59tlndx53dHQwa9asClZUPgY0SZIkSVXt9NNP59e//jVPPfUU3d3d3HzzzbzpTW+qdFll4SqOkiRJkqpaQ0MD11xzDRdeeCF9fX28973v5YQTTqh0WWURQ43nrBVtbW3Z2dlZ6TIkSZKkUe2xxx7j+OOPr3QZezVUnRGxNTPbKlTSPnOIoyRJkiRVCQOaJEmSJFUJA5okSZIkVQkDmiRJkiRVCQOaJEmSJFWJqgpoEdEWEQ9GxBsrXYskSZIkjbSyBrSIuD4i1kTEI4POXxQRT0TEsoi4esClq4Cvl7MmSZIkSbXnve99L9OnT+fEE0+sdCllVe6Nqm8ArgFu3HEiIuqBzwLnAx3AAxGxEJgFLAVaylyTJEmSpANx/+eH93lnXL7XJu9+97u58soreec73zm8n11lyhrQMvOeiDh80OkzgGWZuRwgIm4GLgHGAm3APKArIhZnZn8565MkSZJUG1772teyYsWKSpdRduXuQRvKbODZAccdwJmZeSVARLwbWLe7cBYRVwBXADQ1NZW3UkmSJEkaQZUIaDHEudz5JvOGPd2cmdcB1wG0tbXlntpKkiRJUi2pxCqOHcCcAcftwKoK1CFJkiRJVaUSAe0B4OiImBsRTcClwMJ9eUBELIiI6/r6+spSoCRJkiRVQrmX2b8JuA84NiI6IuJ9mdkLXAncDjwGfD0zH92X52bmosy8or6+fviLliRJklR1LrvsMl75ylfyxBNP0N7ezhe/+MVKl1QWkVm707ja2tqys7Oz0mVIkiRJo9pjjz3G8ccfX+ky9mqoOiNia2a2VaikfVaJIY6SJEmSpCFUYhXHAxYRC4AFzc3NlS5FkiRJkoZNTfagOQdNkiRJ0nCJiIsi4omIWBYRVw9x/a8i4qHi1yMR0RcRk8tRS00GNEmSJEkjq9rXrtjf+iKiHvgscDEwD7gsIuYNevb/ycxTM/NU4EPA3Zm54QBLHlJNBjSX2ZckSZJGTktLC+vXr6/akJaZrF+/npaWlv25/QxgWWYuz8xu4Gbgkj20vwy4aX8+qBQ1OQctMxcBi9ra2i6vdC2SJEnSaNfe3k5HRwdr166tdCm71dLSQnt7+/7cOht4dsBxB3DmUA0jYgxwEYVtw8qiJgOaJEmSpJHT2NjI3LlzK13G/mqIiCUDjq/LzOsGHMcQ9+yuq3ABcG+5hjeCAU2SJEnS6NabmfP3cL0DmDPguB1YtZu2l1LG4Y1Qo3PQJEmSJGmYPAAcHRFzI6KJQghbOLhRREwAzga+U85iarIHzX3QJEmSJA2HzOyNiCuB24F64PrMfDQiPlC8fm2x6ZuB/8jMznLWE9W6Eksp2trasrOzrD8fSZIkSTUsIrZmZlul6yiVQxwlSZIkqUoY0CRJkiSpShjQJEmSJKlKuEiIJEmSJFUJFwmRJEmSNGq5SIgkSZIkab8Y0CRJkiSpShjQJEmSJKlKGNAkSZIkqUoY0CRJkiSpSrjMviRJkiRVCZfZlyRJkjRqucy+JEmSJGm/GNAkSZIkqUoY0CRJkiSpShjQJEmSJKlKGNAkSZIkqUoY0CRJkiSpSrgPmiRJkiRVCfdBkyRJkjRquQ+aJEmSJGm/GNAkSZIkqUoY0CRJkiSpShjQJEmSJKlKGNAkSZIkqUoY0CRJkiSpShjQJEmSJKlKGNAkSZIkqUoY0CRJkiQd1CLiooh4IiKWRcTVu2lzTkQ8FBGPRsTd5aqloVwPliRJkqRqFxH1wGeB84EO4IGIWJiZSwe0mQj8C3BRZj4TEdPLVU9N9qBFxIKIuK6vr6/SpUiSJEmqbWcAyzJzeWZ2AzcDlwxq8zbg25n5DEBmrilXMTUZ0DJzUWZeUV9fX+lSJEmSJFW3hohYMuDrikHXZwPPDjjuKJ4b6BhgUkT8MCIejIh3lq3Ycj1YkiRJkqpAb2bO38P1GOJcDjpuAF4OvA5oBe6LiJ9m5pPDVOMuHyRJkiRJB6sOYM6A43Zg1RBt1mVmJ9AZEfcApwDDHtBqcoijJEmSJA2TB4CjI2JuRDQBlwILB7X5DnBWRDRExBjgTOCxchRjD5okSZKkg1Zm9kbElcDtQD1wfWY+GhEfKF6/NjMfi4jbgF8B/cAXMvORctQTmYOHV9aOtra27OzsrHQZkiRJkqpURGzNzLZK11EqhzhKkiRJUpUwoEmSJElSlTCgSZIkSVKVMKBJkiRJUpUwoEmSJElSlTCgSZIkSVKVMKBJkiRJUpUwoEmSJElSlTCgSZIkSVKVMKBJkiRJUpWomoAWEcdHxLUR8c2I+K+VrkeSJEmSRlpZA1pEXB8RayLikUHnL4qIJyJiWURcDZCZj2XmB4C3AvPLWZckSZIkVaOGMj//BuAa4MYdJyKiHvgscD7QATwQEQszc2lEvAm4unhP6e7//EvPnXH5/tYsSZIkSRVR1h60zLwH2DDo9BnAssxcnpndwM3AJcX2CzPzVcDbd/fMiLgiIpZExJLe3t5ylS5JkiRJI67cPWhDmQ08O+C4AzgzIs4Bfg9oBhbv7ubMvA64DqCtrS3LV6YkSZIkjaxKBLQY4lxm5g+BH45sKZIkSZJUPSoR0DqAOQOO24FV+/KAiFgALGhubBh6/pkkSZIk1aBKLLP/AHB0RMyNiCbgUmDhvjwgMxdl5hX19VWzS4AkSZIkHbByL7N/E3AfcGxEdETE+zKzF7gSuB14DPh6Zj5azjokSZIkqRaUdYhjZl62m/OL2cNCIGXlkvySJEmSqlQl5qAdsF3moEmSJEnSKFGTk7icgyZJkiRpNDLhSJIkSVKVMKBJkiRJUpWoyUlczkGTJEmSNBrVZA+ac9AkSZIkjUajtwtqqOX0JUmSJKmK2QUlSZIkSVWiJgNaRCyIiOv6+vorXYokSZKkGhcRF0XEExGxLCKuHuL6ORGxKSIeKn59tFy11OQQx8xcBCxqa22+vNK1SJIkSapdEVEPfBY4H+gAHoiIhZm5dFDTH2XmG8tdT032oEmSJEnSMDkDWJaZyzOzG7gZuKRSxRjQJEmSJI1mDRGxZMDXFYOuzwaeHXDcUTw32Csj4pcR8f2IOKFsxZbrwZIkSZJUBXozc/4erscQ53LQ8c+BwzJzS0S8HrgVOHq4ChyoJnvQXCREkiRJ0jDpAOYMOG4HVg1skJmbM3NL8f1ioDEippajmJoMaG5ULUmSJGmYPAAcHRFzI6IJuBRYOLBBRMyMiCi+P4NCjlpfjmIc4ihJkiTpoJWZvRFxJXA7UA9cn5mPRsQHitevBf4L8F8johfoAi7NzMHDIIdFlOm5I6KttTk7777mwB90hqv1S5IkSaNRRGzNzLZK11Eqe9B25/7PD33eMCdJkiSpTAxosPswJkmSJEkjyFU2JEmSJKlK1GQPWkQsABY0N9Zk+ZIkSZI0pJrsQXOZfUmSJEmjkQlHkiRJkqpESWMEI+LEzHyk3MXUhKEWFHFlR0mSJEnDoNQetGsj4v6I+OOImFjWiiRJkiTpIFVSQMvM1wBvB+YASyLiqxFxflkrkyRJkqSDTMlz0DLz18BHgKuAs4F/iojHI+L3ylWcJEmSJB1MSgpoEXFyRHwaeAw4F1iQmccX33+6jPVJkiRJ0kGj1I3ErgE+D3w4M7t2nMzMVRHxkbJUtgfugyZJkiRpNIrM3HujiLFAV2b2FY/rgJbM3Frm+vaorbU5O+++ppIlFLiKoyRJklSVImJrZrZVuo5SlToH7U6gdcDxmOI5SZIkSdIAEfGtiHhDsWNrn5Q6RrAlM7fsOMjMLRExZl8/bNQaam80sGdNkiRJOjh9DngPhYUVvwHckJmPl3JjqYmuMyJetuMgIl4OdO2hvSRJkiQdlDLzzsx8O/AyYAVwR0T8JCLeExGNe7q31B60PwO+ERGriseHAH+wvwVLkiRJ0mgWEVOAdwB/CPwC+HfgNcC7gHN2d19JAS0zH4iI44BjgQAez8yeA6xZkiRJkkadiPg2cBzwFQpblD1XvPS1iFiyx3tLWcWx+CGvAg5nQKjLzBv3p+DhUjWrOO4L56VJkiRJI6YSqzhGxOszc/Ggc82ZuX1v95bUgxYRXwGOBB4C+oqnE6hoQJMkSZKkKvQJYPGgc/dRmJO2R6XOQZsPzMtSu9skSZIk6SATETOB2UBrRJxGYXoYwHgKW5XtVakB7RFgJvDc3hpqP7hMvyRJkjQaXAi8G2gH/t+A8y8CHy7lAaUGtKnA0oi4H9g5bjIz31Ti/dphd2FMkiRJUk3LzC8DX46It2Tmt/bnGaUGtI/vz8PLJSIWAAuaG0stX5IkjQpD/UOnI04kVYmIeEdm/htweET898HXM/P/DXHbLkpdZv/uiDgMODoz74yIMUD9Plc8TDJzEbCorbV5dP8f2V9CkiRJUi3ZsVrk2P19QKmrOF4OXAFMprCa42zgWuB1+/vBkiRJu+WUAEk1KDP/tfj6N/v7jLoS230QeDWwufiBvwam7++HSpIkSdJoFRH/OyLGR0RjRNwVEesi4h2l3FtqQNuemd0DPrCBwj5okiRJklTTIuKiiHgiIpZFxNV7aHd6RPRFxH/ZyyMvyMzNwBuBDuAY4K9KqaXUgHZ3RHyYwnr+5wPfABaVeK8kSZIkVaWIqAc+C1wMzAMui4h5u2n3KeD2Eh7bWHx9PXBTZm4otZ5SA9rVwFrgYeCPKOyK/ZFSP0SSJEmSqtQZwLLMXF4cNXgzcMkQ7f4E+BawpoRnLoqIx4H5wF0RMQ3YVkoxpa7i2A98vvglSZI0fFwQRFJlzQaeHXDcAZw5sEFEzAbeDJwLnL63B2bm1RHxKWBzZvZFRCdDh76XKHUVx6cYYs5ZZh5Ryv0qs939YnNJfkmSJKkhIpYMOL4uM68bcBxD3DM4+3wGuKoYtkr93OMp7Ic2MHPduNdiS3z4/AHvW4Dfp7Dkvkaa/8ooSZIk7YvezJy/h+sdwJwBx+3AqkFt5gM3F8PZVOD1EdGbmbcO9cCI+AqF7ckeAvqKp5PhCmiZuX7Qqc9ExI+Bj5ZyvyRJkiRVqQeAoyNiLrASuBR428AGmTl3x/uIuAH47u7CWdF8YF5m7vPK96UOcXzZgMO64geO29cP0wgbqrfNYY+SJEnSTpnZGxFXUlidsR64PjMfjYgPFK9fux+PfQSYCTy3rzeWOsTxHwa87wVWAG/d1w+TJEmSpGqTmYsprFQ/8NyQwSwz313CI6cCSyPifmD7gHvftLcbSx3i+DultJMkSZIk8fH9vbHUIY7/fU/XM/P/7W8BGmEOe5QkSZLKKjPvjojDgKMz886IGENh+ORe7csqjqcDC4vHC4B72HW/ANUql+mXJEmShk1EXA5cQWHl+yMp7LV2LfC6vd1bakCbCrwsM18sfuDHgW9k5vv3p2BJkiRJGsU+CJwB/AwgM38dEdNLubGuxA84FOgecNwNHL4PBZYkIn43Ij4fEd+JiAuG+/mSJEmSNAK2Z+bO/FTcrLqkJfdLDWhfAe6PiI9HxMcoJMG9brJWLOb6iFgTEY8MOn9RRDwREcsi4mqAzLw1My8H3g38QYm1SZIkSVI1uTsiPgy0RsT5wDeARaXcGKXunVbcC+2s4uE9mfmLEu97LbAFuDEzTyyeqweeBM6nsHP3A8Blmbm0eP0fgH/PzJ/v6dltrc3Zefc1JdWvYeK8NEnScNvdXOhS+btJ0h5ExNbMbBvhz6wD3gdcAASFPda+UMrG1aXOQQMYA2zOzC9FxLSImJuZT+3tpsy8JyIOH3T6DGBZZi4vfgM3A5dExGPAJ4Hv7y6cRcQVFCbc0dRQ0kIokiRJkjRiMrM/Im4Fbs3Mtftyb6nL7H+MwkqOxwJfAhqBfwNevY+17jCbXVeA7ADOBP4EOA+YEBFHDbU5XGZeB1wHhR60/fx8SZJUCQfaWyZJVSwiAvgYcCWFnrOIiD7gnzPzf5XyjFJ70N4MnAb8HCAzV0XEuH0veacY4lxm5j8B/3QAz5UkSZKkSvkzCp1Yp+8YbRgRRwCfi4g/z8xP7+0BpS4S0l0cL5nFDznQMZwdwJwBx+3AqgN8piRJkiRV0jsprK2xcypYcVrXO4rX9qrUgPb1iPhXYGJx07U7gQMZo/AAcHREzI2IJuBSfrsJ9l5FxIKIuK6vr/8ASpAkSZKkYdWYmesGnyzOQ2ss5QElBbTM/L/AN4FvUZiH9tHM/OdS7o2Im4D7gGMjoiMi3peZvRTGZd4OPAZ8PTMfLeV5xXoWZeYV9fWl5ktJkiRJKrvu/by2017noBWXxL89M88D7iixsJ0y87LdnF8MLN7X56nChprc7fLGkiRJEsApEbF5iPMBtJTygL0GtMzsi4itETEhMzfta4XlEBELgAXNjfuyS4AkSZIklU9mHvA+YKUmnG3AwxFxB9A5oIA/PdAC9kdmLgIWtbU223UjSZIkadQoNaB9r/glSZIkSSqTPQa0iDg0M5/JzC+PVEGqQbvbdNS5aZIkSdI+2dsyiLfueBMR3ypzLSVzmX1JkiRJo9HeAloMeH9EOQvZFy6zL0mSJGk02tsctNzNe2n/uEy/JEmStFt7C2g71vEPoHXAmv4BZGaOL2t1kiRJknQQ2WNAG451/MvBfdBGmX1ZZMQFSSSpNuzu/9eSpD2qyYTjPmg1wl/OkiRJ0j5xlQ1JkiRJqhI12YO2Q0O4bsmoZg+cJEmSDjI13YPWWNPVS5IkSdKuarsHzYCmHVy+X5IkSaNATUaciFgQEdfV0V/pUiRJkiTVuIi4KCKeiIhlEXH1ENcviYhfRcRDEbEkIl5TrlpqMqBl5qLMvKKpISpdiiRJkqQaFhH1wGeBi4F5wGURMW9Qs7uAUzLzVOC9wBfKVU9ND3F0DppqTrXu4+YQUUkHwkWdJNW2M4BlmbkcICJuBi4Blu5okJlbBrRvA8q2WmFNB7SGOldx1B4YOiRJkrR3s4FnBxx3AGcObhQRbwb+HpgOvKFcxdR0QGt0hKOqmf+iLEmSVA0aImLJgOPrMvO6AcdDpYqX9ARl5i3ALRHxWuBvgfOGt8yCmg5o9qBpxFXrEEVJkiTtTm9mzt/D9Q5gzoCXVS0rAAAgAElEQVTjdmDV7hpn5j0RcWRETM3MdcNV5A41OYtr5yqOAfRsq3Q5kiRJkmrXA8DRETE3IpqAS4GFAxtExFEREcX3LwOagPXlKKYme9AycxGwaP6s+svZvhkaWypdkmqd89UkSZIOSpnZGxFXArcD9cD1mfloRHygeP1a4C3AOyOiB+gC/iAzyzKcryYD2i62bYKx0ytdhSRJkqQalZmLgcWDzl074P2ngE+NRC2jI6BJB4uRnAPnfDtJkqQRV5Nz0HZhQJMkSZI0StR0D1pfBmw3oElDKte8OufrSZIklU1NB7TefmDb5kqXIbnnmSRJkobFKAho9qCpTAxdkiRJGmE1HdB6+sOApn1TraFrpIYNVuv3L0mSJKBGFwnZsVF1d1/C9hehv6/SJUmSJEnSAavJHrQdG1XPntB4OWRhoZDWyZUuS6oce8YkSZJGhZrsQduhpz8Kb7a+UNlCJEmSJGkY1HhAK77pMqBJkiRJqn01OcRxh509aF0bKluIVA61NGzRvdEkSZKGRU0HtARoHg9dGytdiiRJo18t/cORJNWomh7iCEDrJHvQJEmSJI0KoySgOQdNkiRJUu0bJQFtI2T/3ttKkiRJUhUbHQEt+2Db5kpXIkmSJEkHpPYDWtvUwuvWdZWtQ5IkSZIOUE2u4hgRC4AFzY0NMGZK4eTW9TDlqIrWJWmA3a325vL7kiRJu1WTPWiZuSgzr6ivr4OWiRB10Lm+0mVJkiRJ0gGpyYC2i7p6aJ3sEEdJkiRJNa/2AxpA25TCEEdJkiRJqmGjI6CNKQa0zEpXIkmSJEn7rSYXCXmJMVOhdxv0bIWmtkpXI0lS7dvdQj+SpLIaHT1oO5ba71xb2TokSZIk6QCMkoA2vfC6ZU1l65AkSZKkAzA6AtqYyYXVHDsNaJIkSZJq1+gIaFFXmIe2xSGOkiRJkmrX6AhoAGOn24MmSZIkqaaNnoDWNr2w1H5/b6UrkSRJklRDIuKiiHgiIpZFxNVDXH97RPyq+PWTiDilXLWMnoA2djpkvxtWS5IkSSpZRNQDnwUuBuYBl0XEvEHNngLOzsyTgb8FritXPaMooM0ovL74fGXrkCRJklRLzgCWZebyzOwGbgYuGdggM3+SmS8UD38KtJermFEW0MKAJkmSJGmghohYMuDrikHXZwPPDjjuKJ7bnfcB3x/uIndoKNeDR1x9Y2HD6hefq3QlkiTVlvs/X+kKJKmcejNz/h6uxxDncsiGEb9DIaC9ZjgKG8roCWgA42bCZgOaJEmSpJJ1AHMGHLcDqwY3ioiTgS8AF2dm2Ra+qJohjhFxRER8MSK+ud8PGXdIYZGQvu5hrEySJEnSKPYAcHREzI2IJuBSYOHABhFxKPBt4A8z88lyFlPWHrSIuB54I7AmM08ccP4i4B+BeuALmfnJzFwOvO+AAxoJL66GiXP22lxSBQw1lOqMy0e+DkmSJCAzeyPiSuB2Cvnk+sx8NCI+ULx+LfBRYArwLxEBex82ud/KPcTxBuAa4MYdJwYsY3k+he7EByJiYWYuPeBPG3dI4XXzSgOaJEmSpJJk5mJg8aBz1w54/37g/SNRS1mHOGbmPcCGQaf3uozlfhszBRpaYVPHsDxOkiRJkkZSJeagDbmMZURMiYhrgdMi4kO7uzkirtixRGZvb9/gizBhNmw2oEmSJEmqPZVYxXHIZSyLK6F8YG83Z+Z1FHfubmttfunyl+Nnw9M/hv5eqBtdi1RKkiRJGt0qkWBKWsayFP3NE/i7h8eTQGMkjXVwcteRvK7/bpas2EDblFkc3tZHa8OQ2xhIkiRJUlWpREDbuYwlsJLCMpZv25cHRMQCYEHTzKO4cfkYAujpD3ozOCxO5HXN8K2H13NT36kAzGrt5YhxfZw4sZtTJ/VwyqRuDhnTP8zfliRJkiQdmHIvs38TcA4wNSI6gI9l5heHWsZyX56bmYuARW2tzZc/fsnzA87Dlh7ou7uNv5j6MK+adRortjTw1JYGntzcwBd/PZaeLIywPKytl1dP385rpm/n1dO2M6HJXjZJkiRJlVXWgJaZl+3m/EuWsRwOETCuCZh0GFM7n2JB+7Zdrm/rg8c2NfLzDU3ct7aJhc+28tWn2miM5JXTtnPR7G1ccMg2prbYuyZJkiRp5NXkKho7hjg2N+6m/EmHw5ql0N0JTW07T7fUw2mTezhtcg/vO6qTnn745QtN3PFcM7etbOXDv5jI/3wo+Z2Z2/j9w7o4d+Y2GiuxzqUkSQfKTeElqSbVZEAbOMRxyAaTDiu8bnwaps/b7XMa62D+lG7mT+nm6hNe5PHNDdz6zBi+/Uwrdz7XypTmPn53TheXHb6Vo8b3luE7kSRJkqTfGp39QxPmQNTDhuUl3xIBx0/o5UMnbea+i1dz/SvXc8aUbm78TRvn3Tmdd907mbtXN5NOVZMkSZJUJjXZg7ZX9U0w8VBY/5v9ur2hDs49ZDvnHrKd9dvruOmpMdy4vI133TuFo8b18N6jOvm9Q7fSUj/MdUuSJEk6qNVkQNsxB62xoZ6fPbV+yDaz62cx+4Wf8OCylfTVt+w8f+bcKfv0WVOa+7nyuC1cccwWvtvRyhd/3caHfzGRTy8dxx8ds4W3zd3KGPdZkyRJkjQManKIY2Yuyswr6ut2X/6LYw4jSMZtfXZYPrOpDn7v0C6+e+46vnrWOo4e38snHp7Aa26bzr88MZYtPTEsnyNJkiTp4FWTAa0UL7bOpj8aGN+5YlifGwGvmtbNV89azzfPXseJE3v434+O59W3zeDaJ8eyrW9YP06SJEnSQWTUBrSsa2DzmEOZ2Fn6QiH7av6Ubm58zQZuPWctp07u5pOPjOfs22dw01Nj6HUrNUmSJEn7aNQGNICNY4+ktXsDzd0vlPVzTp3cw5dfvYGbz1rH7DF9fOgXE7ngzuksXtniqo+SJEmSSlaTAS0iFkTEdX39e+6m2jj2CAAmbtm/1Rz31SumdfOts9fx+Vesp6Eu+eOfTeaSH0zlJ2uaRuTzJUmSJNW2mgxopSwSArC9aTJdTVOY9OKTI1RZYY7a+bO28/3XreUfXv4C67vreNuPp/L++yax/EXX5ZckSZK0ezUZ0PbF+vHHM37r0zT2bBnRz60PeMthXdx1/hquOmEzP13bzAV3Tud//Wo8G7td8VGSJEnSSx0UAS2AyS8+XpHPb6mH/3rsFn5wwRp+/7Ct3LCsjXP+YwZfWtZGjwuJSJIkSRpg1Ae0bc1T2do8jSmbl1a0jmkt/fz9yzbxvdet5YQJPfzNryZw4Z3TuOu5ZhcSkSRJkgRAQ6UL2B8RsQBY0NhQ2pyu9ePnMWft3TT1bAamlLW2vTl+Qi//9pr13PV8M3/38ATed98UXjN9Ox85aRPHTeg94Of/7Kn1e7x+5tzKfv+SJEmSdq8me9BKXSRkh/Xjjwdg8ubHyllWySLgvEO2c9t5a/joyZt4+IVGXn/XND708wms21aTfySSJEmShsFBkQa2N01iS8shTNv0MNU0nrCpDt57VCd3X7iadx7ZyTeeHsM5/zGda58cy/a+SlcnSZIkaaQdFAENYM2k0xizfS1sGJk90fbFxKbk46ds5rbz1nLG1G4++ch4zrvDja4lSZKkg81BE9DWjZ9HT30LPH1vpUvZraPG9XL9qzbwlVevZ0xDYaPrP7hnCg+/0Fjp0iRJkiSNgIMmoGVdI2snngqrH4WujZUuZ4/OmrGd7527lv/v1I38ZksDb/rBVP5iyURWdx00f1ySJEnSQemgWMVxh9WTXsas9T+DZ34Cx75+yDbVsgpiQx28/YitLJjTxWcfH8eXftPG4pUtfOCYLVxxdCetDY59rEXV8t+XJEmSqlNNdsns6yqOO3Q3ToAZJ8Az90FPV5mqG17jG5MPnbSZO85bwzkztvPpx8Zz7h3TufWZVvrNaJIkSdIBi4iLIuKJiFgWEVcPcf24iLgvIrZHxF+Ws5aaDGgH5KjzCuHsqXsqXck+OWxsH597xQt87bXrmNLcx58tmcSbfziVB9c7P02SJEnaXxFRD3wWuBiYB1wWEfMGNdsA/Cnwf8tdz8EX0Ca0w4yTYMU90N1Z6Wr22ZlTu1n4O+v4Py9/gee66nnL3dP44M8msfzFfRvuKUmSJAmAM4Blmbk8M7uBm4FLBjbIzDWZ+QDQU+5iDr6ABnDMhdDbDct/UOlK9ktdwO8f1sUPLljDnx73Iv/5fDPn3zmdD/9iAht6anJaoSRJklQuDRGxZMDXFYOuzwaeHXDcUTxXEQfn3+bHzYRZp8GKe+HQV8GYyZWuaL+0NST/fd6L/OERnVzz+Fi++lQb3+BYXj9tHW+asZaxDf2VLlGSJEmqtN7MnL+H6zHEuYqt9nBw9qABHHsxRMDSW6j13aCntfTzN6du5q4L1vCKiZtYuGYaf7L0OG55fhrb+ob6702SJElSUQcwZ8BxO7CqQrUcxAGtdRIcfQGseQxWP1LpaobFoW19XHl4B586bhnHtXVy83Mz+W9Lj+X2tZPp7jeoSZIkSUN4ADg6IuZGRBNwKbCwUsUcnEMcdzj8LFj5ICy9FaYcBY2tla5oWBzWuo2rjnyax7eM4aZVM7m+Yza3rJ7OJdPXcsqh0OJ6IpIkSRIAmdkbEVcCtwP1wPWZ+WhEfKB4/dqImAksAcYD/RHxZ8C8zNw83PXUZEDb342qX6KuHk76fbjvGnjkW3Dq2/d6y4FuNDySGxUfN3YrHz96OY9uaeNbz0/nhpWz+O66Pj5wzBbePnerm11LUjnd//mXnjvj8pGvY6ChapIkkZmLgcWDzl074P3zFIY+ll1NDnHc342qhzTx0MJQx+cego4HDvx5VSYCThzXyceOfoqPHbWcY8b38omHJ3DW7dO59smxvNjj0EdJkiSpWtRkQBt2R54Lk4+EpbfQun1tpaspm3njOvnqWev5xmvXcfyEHj75yHhe9f0Z/P3D43m+y/8UJEmSpErzb+UAUQenvg3qWzjm2W/S0Lu10hWV1elTu/nKazaw8HfWcvbM7Xz+122cddsM/mLJRB7fVJOjXiVJkqRRwYC2Q8sEmP8emnq3cEzHN4n+3kpXVHYnT+rhmjNe4O4L1/D2IzpZvLKFi+6azrvuncw9q5vpd4qaJEmSNKIMaANNPJTfzHoj47pWctTKW4nsq3RFI2JOWx8fP2UzP7loNX85bzOPbmzknfdO4XV3TOcLv25jU7fz1CRJkqSRYEAbZMP441kx43wmb/k1R65cCNlf6ZJGzKTm5MrjtnDvRav5zPwXmNzUzycensCZ35/BVQ9O4JGNDn+UJEmSysm/cQ9h9eT5RPZz2Jq7iJXJsllvIusOnh9Vcz387qFd/O6hXTy6sYF/W97Grc+28rWn2zhlUjdvPWwrb2zvYkKTYyAlSZKk4WQP2m48P+UMVsw4j8kvPsFxz36N+r5tlS6pIk6Y2Mvfv2wTP714NR89eRNdfcFfPzSRMxbP5E/vn8g9q5vpM6dJkiRJw+Lg6RbaD6snn05v/RiOWPVdTlhxI0+2v4VtzcO3kXQtmdCUvPeoTt5zZCcPb2zkm0+P4TvPtrKwYwyHtPbxe4du5ZI5XRwzfvQvriJJkiSViwFtL9ZPOIHuhrEcvfIWTljxZX4zawEbxx1d6bIqJqKw+uPJkzbx1ydt4s7nWvjm02P43BNj+ewT4zh6XA9vaO/ije3bOGqcYU2SJEnaFwa0ErzYdhiPzH0Px3R8m2M7vsnqiafxzIxz6a9rqnRpFdVcD29o38Yb2rexZlsdt69sYdHKVv7xsXF85rHxHDe+ENYunr2NI8f2Ei4GKUmSJO1RTQa0iFgALGhsqN/ne3/21Pr9+szuxgk8etgf0r72Hg7Z8DMmdD7Fb2YtYMuY9v16Xq3a08/vmDr4izmwYWYDP9s4gZ++MIF/WDqef1g6npnN23n5+Bd5+3Fw+pRuGp39KEmSJL1ETQa0zFwELGptbrp8RD+3roFnZ5zLxnFHceSq7zLv6a+wZuKpdEw7m96GMSNZSlWb3NjLxdPWc/G09azvbmDJpvH8fNN4bl83me/9qI5xjf2cPWM7583cxqunb2day8GzlYEkSZK0JzUZ0CrtxTGH8vDc9zF73Y+YseFBpmx+nI5pZ7Fm0mmVLq3qTGnq5cJpG7hw2ga29dWxbcwh3PVcM//5fAvf7WgF4LgJPbxm2nZePX07Z07tZkyDy0JKkiTp4GRA20999c08M+M81k48lcNW38Hhq+/gkA33Q8P50D4fDqJ900rVUt/P2bO2ceGsbfTnJh5+oZEfr23m3jXN3Li8jS8sG0tjJKdN6eaVU7s5fep2TpvcQ5uBTZIkSQcJU8QB6mqeyuNzLmVC529oX/tjmh/5Jiy7E+a+FtpPh8bWSpdYleoCTpncwymTe/jgsVvo6g2WrG/ix2ubuHdNM//8+Fj6GUd9JPMm9DB/SjenT+1m/uRuprc6JFKSJEmjkwFtOESwaexRbGo7kjPHrSsEtMcWwpPfh1kvgzmvgAntuIzh7rU2JGfN2M5ZM7YDL7K5J/jFhiaWrGvigfVN3LRiDF/6zVgAZrb0cdKkbk6e1MNJE3s4eVIPk5sNbZIkSap9BrThFAHTjit8beqAp38CK38Oz/4MxkyFWafS2nc4Xc1TDWt7Mb4xOXvGds6esR2A7n54dGMjP9/QxMMvNPKrFxq547nf9k62j+nl5Ek9nDixh+PG93DMhF5mt/b5Y5YkSVJNMaCVy4R2OPmtcPwCeP5XsOohWHYXJ5NsbxjHprFHsLHtCDa3HU5ffUulq616TXVw2uQeTpvcs/Pc5p7g0Y2NhcC2sYlfvdDI4pW/DW3jGvo5Znwvx4zv4bgJPcX3vUxu6je4SZIkqSoZ0MqtsRXmnFn42raZ5UsfYGLnciZvfpzpG39JEmxtnsaW1tlsaZ0FW06Atmn2sJVgfGPyymndvHJaN9AJFELbk5sbeWJTA09sbuTxzQ0sXtnKTSvadt43obGfuWN7f/s1bsf7PhckkSRJUkUZ0EZSy3jWTjqVtZNOJbKPtq5VTOhcwdiulUzZvJQZG38Bz30PGsfA+NkwfhaMOwTGHwJtM6DeP669Gd+YzJ/Szfwp3TvPZcKabXU8sbmRJzc3sGJLA09taeD+dU3c8uyu+9dNb+lj7theDmvrZfaYPtrH9NHeVnid0dJHgxtsS5IkqYz8G3+FZNSzZcwctoyZUzyRtHav5+S2TbDxadi8Ep6+F/p7C9ejDtqmFwLb2GmFXrYdXw3NlftGakAEzGjtZ0brdl5bnNO2Q1dv8HRnPSu2NLC8GNye2lLP3atbWL2tfpe29ZEc0loMbWP6CgGurTDXbUZrHzNb++2BkyRJ0gExoFWLiMLiIXOOhTlnFM7198HW9bB5Fbz4XOF14wp47iFgQBBomQBtU6FtOodsa2F74wS2N45ne+NEeuvHOFxyD1obkuMm9HLchN6XXNvWB8911bNyaz0dnQ10bK3f+XXv2mae76oj2fVnO66hf2dYm9HSx8zWPma29DGjtZ+ZrX280NPAhIZe6vwjkSRJ0hAMaNWsrh7GTi98cepvz/f1QOc66Fwz4HUtPPcQh/Z07fKI/mhge+N4uouBjb6Z0DoJWiYWgl3LBKhvHNnvq0a01MPcsX3MHdsHdL/kenc/PLe1npVd9azuquf5rnpWb6vj+a56nuuqZ9nmZtZur6MvB6axadSTTGjsZWJDT/G1d+frmsYWpjX3M62lj6nN/YxvTPO1pINHJvRth56t0NdX+AfG+kZoGlv4nShJBwEDWi2qbyzMSxt/yEsuLVm2kqaezTT3bNr5teN40rYnYeNDL31eU1sxsA0Iba073k80xO1GUx0cNraPw8b27bZNX8K6Ymh7fls9P+voYkNPIy/0NLCpp5EXehpZsbWVTb0N9BPcsHLwZyTTmvuY2tK/S3Cb1lI4N7mpnynN/Uxq6mdScz/1hjlJtaJnW2FI/8anYcuawtfWtYV/hHyJgOZxMG5mYaj/5CNh8hHQ6CrIkkYfA9oo01ffQld9C10t04e8fuah46BrI2zbCNs2Fd9vKhx3bYAXlsOgXjhgZ4g7pr+V7oZxdDeOp7txHN0N49neOI7uhnFknSFusPqd89/6OYUeJm7fMGS7/oQtvfUcOmMqa7fXsW5b/S6va7fV0dFVz0P/f3v3FiPJdddx/Puvqu7p2dusZ72YjdfObuy1ieMHsBzHIRAipGA7YBmQQOSBJAgwEYkEbyBeiCwhRQiQQIEgO0TEUhKIuMVWQuxgEYwiE+xYVmyzYFveTXxZe707szszuzM93VV/Hk51d1V39UzvZaZ7dn8fqVSnTp2qOjNz5nT9q05Vz9c42RwcWglgODN1Z7aeMpsHbXv65rNTIaibnQrTtlh36ERkkyyfgvkj+XQUFo4RhusbbJsNz1TvuS5cFKxtgygJ69tNWF2Cs3Ow+EZ4PvvIf4Rns2euCd89eu3tcNXNGtIvIpcEBWiXm7heGDY5RLuZB22n+wK5U9QX5tix/Cq1dGVgs1Y8zWrSCdzyIC7ZyWqygzSuk0VTsBxDUod4SsNVCiKDXbWUG2fa3LhO2dRhLg/a5lcjTjY785j51Yi5ZsTcasQrZxKemQvr2l590lKPnNl6xkw9Y1ctY6bm7KpnzNRC3kzNS+tmCusa+vOJyDBZO39u+gfhDtnckfB5AqH/330tHPogXHEgpJNzuBOWtsI+T74EJ16AFx+FFx+BXfvhxjvhhrvg4E/qBVoismVNTIBmZtuBvyI87PMtd//imKt0+UqmhgZxzx05CUCUrVJvLVJvL1JvLeTzRertBeqthaFBHC8X0lESAsYoCUMou/Pa4HJpXVJRZo1tO+WjWggKt/gV1thgbyNjbyMbqbw7LLatG7jNNTtBXMx8nrfQMk6vRry2HHP4dMLpVsRSe+3vFKhHzkwtY2ctY0fibK8525PwJsveFNZty5d3JBnbEs/zMqZjpxHDVLNNoxYT6+0pIltP2grPQS++AadfCUHZwmu9txBP7YLZg3DFT8EVB8MQxQu5QBfXYM/1YbrhTmguhrtvL3wDnvkSPPk5qG2H6386BGs33BFepCUiskVsaIBmZp8Hfg447u43F/LvBP4ciIHPufungV8E/sHdHzazvwcUoE2wLKqzMrWHlak9Q8tEWYtae5F6e4koWyXOVjk0Ww936NorYZ61IG2X51krX7cUPvjTVvig75Tx4c98rc8qgrq+4M5iwghCC1M3XdjHQF7/YarWGdefKb/mP7yLM8ItP9bidL6thbkZEBXSnfyoOj1k6OMuYBdwoLTCoQE0qr8aIMucZmY0U2PZE876FEteZymbYjFrcDqrcyptcCptMJ82mG9Pc6K5jZfaDZbSmKW2sZKO+MVxX3sEgCQyGrWYRi1iKomZyueNWkQjX24kMfUkIomNWpTP44gkMpI4ohYbSTc/pGtJRK1ifWxGHBlRFNJRRDfP8nk3v5subxcZpfwo6tvOjCjPF9myWiuwPB+Gwi/Ph+nsSVh6M7ysqvNm4agGM/vh7e8Ld8Z2vz0MWdzIC2NTO+GWXw1TawWOPA4v/Cv83zfg8MOAwf53h7trh+4IQyL1vaIi0mdIfFJcb/n6DwFngY+5+9MbUZeN7qH+FvgM8GAnw8xi4C+BDwKvAk+a2UPAfuDZvNiFnIHLhMiiGs36LM36bC/zmuEB3cg86wVtaWswuOsGfMUyxbL95foDw84r9z0/5ygEMO6F5SHfeVaZHTK3tfqbtmMe1pln0LRwDHcgK6SH5Y12F+18RMB0Pu0+142TGkw18KROFk/Rjhq0oyla1qAZTbFCgxVrsEyDZWuwvOcmzvo0Z6zBkk+z6HUWs2kWsjoLaY2zqbHSSjlzps1KK2W1ndFKnXaW0U6dVprRzjykswyf0K+jGwjcSsFcX7DXlx/lgV7cWY7y5Xx/UTGw7JTv7DMv2ytTDhwHy/Rtb4WAdY3tzTrBK910VIjRvf9fifK/ixcKlP6Exe3yBc//PdPMcXcyD+nMO9PgOncnzZezbLBc1bpOOnVCXmc5C/V16JZ197xeTpZBtrAHz+uauYWyT367vF1GXibs1/PjdH6+rJBf/P11rtkYls/D7zxc0klJSElWdlK3PE1K3VpMe5MGTaYpzL1Jw5psY4UZX2IXS8z4Ijt9kZ2+xE5fpEH54tIqNU7Fezie7Of49tt4q/Y2TtT2MV//YSxKiFInPgnxHMSR520yjABIzPO0d/PCeh9IR1BR1vM2WCj7yqleG951O/G730t0231Mn3ye7Ue/yfSRR6k/dh88dh+eNEiv/BGyve/CZw+EgHLmGqIde4mndxNNz4Qhl1t8tIVsTVkW+qLQL9FN9/qi0G+kpf6o1y+Vl/N+rLSP3rbFPjPNyvnddKEvLO63V5a+sr38wbJeqPdgPcJ6KsqW84v7HXYqdq6GxSfu/j+FYncBh/LpPcBn8/lFt6EBmrs/bmYH+rJvA15y95cBzOzvgHsIv4z9wDOEPlmkmkX5swVb7/mC7+VDRId5z8HzCGCLwZrnD9x32ECibMidvtJ69/CdfFkL0tX8rmZxnk+dO6PddBNLm8TtJnHaZKq9CO0TpfXdnvX4Oj9jPBVeVFObDn//WhReo2mFKYrztOEW4cR0wunOSXPnJLeTplMD917Y3e3v+8tU53u+slymuK64fdU+vW85n6flOnWP0vd5VKxv6fjdQl6uY2FlsayVfoZyJYvHs4pPw+pWtH65qjJVn7aj73+EbQ2iQjnL74h3tu2UD8FOeX9R3w5L96xL+flrfLK0lAfAatI7Rnf/NliO3r9n5c/vGbG3iWgTeUrsab6cln6+c7VMg0XbwYLtYJ5dHLW3cTrayUlmOMaVYfK9nPBdZJnRbhrpCvnJlpE5tEvpTQpyvvXtNVbeAtzCVczx49Hz3NT+Pu987fvceDIriuMAAAcoSURBVOxh9tpC5RZNTzhLgzYxbZJ8HtMioU1S+qN4aEXddIdZeXlgJEY+K25fWmsVeZeAjY57qy7QDbtuOrwHql7Zn+VVmfmagey1jueVW1wURrgdtBmPjff603y5m7Zyf2ZWUSb0u50yvfKD+6zKX8871i8yLD4pBmj3AA96uJr4X2a228z2ufuxEasxsnHc478aeKWw/Coh+vwL4DNm9rPAw8M2NrN7gXsBkmTy3lLwnXVOwCd9/+O23s93XgHMpa479HGDrmuYheFAcRICpIvFvXfX8qZ7YPVMeFNbcynMV5dCXnMJVhdDurWSB6LFKS2kQ6BqWYpd0FDYaq+dqnjDacHVu6d7P9tY9AXoHesF4iOUC8FuJwjM8/LAthPa+ECgG8I+q9jfmscsfEj38gbbd/EDuvuhbdHgB35+MlDe33n+Tk6+XFGG8DxUf+bJlwbLXnlo9GOeeKFU7q2l8l2slsW4RWSEixT7du+AqHPRIi5ctMjTURye+43rvZc1dZbzaTpOmAbWeI0U0ATeWrNEUQjeyO9CWjed5ulicNdfLituQ39+YR+H7hi8W9C5yl66E/F+MndezJz/zZyovcz0yhtsO3uMqdVTYVh+/nx1kp4lytpE3iLK0jD3NrG3C2fapcslpZNwK1yQKd8G7tsGCif6fafpfRd9+o+4MTbwCJvVNeYR7nqBb69f6EUP6/YMA2UKe6i6Plrarro37PVfFYFLvl1lsNOX1+sLra9frM7rHK14N75Un+Jxu/vv26byd7L5Xl/n8xlIzOypwvL97n5/YXlYfMI6Za4GLokArepv6O5+Bvi19TbOf5n3A0xP1cd1FiQiF8qsd2K457px12Ykjz1xdM31H3nvgc2oxlgMBDiXq/9+oDr/tt8crWxVuRGP9fI6F7D2TegFrDBEF8IXsQwGJxfFO6+6gI3fddGqISLj8W9PHF2nxMG2u9+6RoHK+OQ8ylwU4xhK+CpwTWF5P/D6GOohIiIiIiIySnyyaTHMOAK0J4FDZnbQzOrArwAPncsOzOxuM7s/zTbuBQkiIiIiInJZGCU+eQj4iAW3A6c34vkz2OAAzcy+DDwB3Ghmr5rZr7t7G/gk8AhwGPiKuz9/Lvt194fd/d440rtERERERETk/A2LT8zs42b28bzY1wnf6PsS8ADw2xtVn41+i+OHh+R/nfBDioiIiIiIjFVVfOLuf11IO/CJzajLlvymRjO7G7i7NoFvcRQRERERETlfW3KMoIY4ioiIiIjIpUgRjoiIiIiIyIRQgCYiIiIiIjIh9AyaiIiIiIjIhNiSd9D0DJqIiIiIiFyKFOGIiIiIiIhMCAVoIiIiIiIiE0IBmoiIiIiIyISw8KXYW0vnJSHAbwDLY66OnJ8EaI+7ErIlqK3IqNRWZFRqKzIqtZVLw7S7b5kbU1syQJOtz8yecvdbx10PmXxqKzIqtRUZldqKjEptRcZhy0SSIiIiIiIilzoFaCIiIiIiIhNCAZqMy/3jroBsGWorMiq1FRmV2oqMSm1FNp2eQRMREREREZkQuoMmIiIiIiIyIRSgyaYzs6Nm9qyZPWNmT427PjI5zOzzZnbczJ4r5M2a2TfN7MV8fsU46yiTYUhb+ZSZvZb3Lc+Y2YfGWUcZPzO7xsz+3cwOm9nzZvY7eb76FSlZo62oX5FNpyGOsunM7Chwq7ufGHddZLKY2fuBJeBBd785z/tjYM7dP21mvw9c4e6/N856yvgNaSufApbc/U/GWTeZHGa2D9jn7k+b2U7gu8DPAx9D/YoUrNFWfhn1K7LJdAdNRCaGuz8OzPVl3wN8IU9/gfCBKZe5IW1FpMTdj7n703l6ETgMXI36FemzRlsR2XQK0GQcHHjUzL5rZveOuzIy8a5y92MQPkCBHxpzfWSyfdLMvpcPgdSwNekyswPAjwHfQf2KrKGvrYD6FdlkCtBkHN7n7rcAdwGfyIcqiYhcqM8C1wE/ChwD/nS81ZFJYWY7gH8EftfdF8ZdH5lcFW1F/YpsOgVosunc/fV8fhz4Z+C28dZIJtyb+bMBnWcEjo+5PjKh3P1Nd0/dPQMeQH2LAGZWI5xwf9Hd/ynPVr8iA6raivoVGQcFaLKpzGx7/vAtZrYd+BngubW3ksvcQ8BH8/RHga+OsS4ywTon3LlfQH3LZc/MDPgb4LC7/1lhlfoVKRnWVtSvyDjoLY6yqczsHYS7ZgAJ8CV3/6MxVkkmiJl9GfgAcCXwJvCHwL8AXwGuBX4A/JK76+UQl7khbeUDhGFIDhwFfqvznJFcnszsJ4D/BJ4Fsjz7DwjPFqlfka412sqHUb8im0wBmoiIiIiIyITQEEcREREREZEJoQBNRERERERkQihAExERERERmRAK0ERERERERCaEAjQREREREZEJoQBNRERERERkQihAExERERERmRAK0ERERERERCbE/wMdogNSMIOmOgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "### Metric comparison" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: divide by zero encountered in log\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: invalid value encountered in multiply\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: divide by zero encountered in log\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: invalid value encountered in multiply\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: divide by zero encountered in log\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: invalid value encountered in multiply\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: divide by zero encountered in log\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: invalid value encountered in multiply\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: divide by zero encountered in log\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: invalid value encountered in multiply\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: divide by zero encountered in log\n", + "/opt/SageMath/local/lib/python3.7/site-packages/ipykernel_launcher.py:21: RuntimeWarning: invalid value encountered in multiply\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
colnumber_of_factorslog10(amin)log10(amax)log10(mean)log10(median)log10(max_min_ratio)
statks_statkl_statks_statkl_statks_statkl_statks_statkl_statks_statkl_statks_statkl_stat
True0.1423971.7071330.4257589.0971280.424721138.1551060.427873138.1551060.16881311.9313690.37599310.660652
\n", + "
" + ], + "text/plain": [ + "col number_of_factors log10(amin) log10(amax) \\\n", + "stat ks_stat kl_stat ks_stat kl_stat ks_stat \n", + "True 0.142397 1.707133 0.425758 9.097128 0.424721 \n", + "\n", + "col log10(mean) log10(median) \\\n", + "stat kl_stat ks_stat kl_stat ks_stat kl_stat \n", + "True 138.155106 0.427873 138.155106 0.168813 11.931369 \n", + "\n", + "col log10(max_min_ratio) \n", + "stat ks_stat kl_stat \n", + "True 0.375993 10.660652 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "### ML comparison" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "display(Markdown('### Numerical comparison'))\n", + "display(df.describe())\n", + "display(df.groupby('sim').describe().T)\n", + "\n", + "display(Markdown('### Visual comparison'))\n", + "plot_df(df, drop_cols) # subset it or something\n", + "\n", + "display(Markdown('### Metric comparison'))\n", + "display(df.groupby(pd.Series(True, index=df.index)).apply(per_group(drop_cols))) # consistency with groupby\n", + "# display(per_group(['trace_factorization'])(df).to_frame().T) # those 2 lines are equivalent\n", + "\n", + "display(Markdown('### ML comparison'))\n", + "eval_classifiers(df, drop_cols)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Those are some reasonable results for basic ML classifiers with un-tuned hyperparameters." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Playground" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/division_early_abort b/docs/division_early_abort new file mode 100644 index 0000000..4b41337 --- /dev/null +++ b/docs/division_early_abort @@ -0,0 +1,30 @@ +========256 bit======== +_______iter(p)__f(p) +1/2 0,1 3/2 +1/3 0,17 1/2 +1/5 0,25 1/5 +1/7 0,35 12/105 + + +0,03 overhead contained in all iterations + - polynomial ring generation + + +f(p) = (1-1/2)(1-1/3)...1/p*3 + - order computation + +iter(p) + - division polynomial generation + - root finding + - y-coordinate computation omitted (fast) + +interesting cases: + iter(p)=9.0', + 'prettytable', + 'pathlib', + 'pytz', + 'sarge', + 'psutil', + 'pid>=2.0.1', + 'coloredlogs', + 'shellescape', +] + +setup(name='DiSSECT', + version='0.2', + description='Distinguisher of Standard & Simulated Elliptic Curves through Traits.', + url='https://gitlab.fi.muni.cz/x408178/curve_analyzer', + author='Vladimír Sedláček and Vojtěch Suchánek', + author_email='vlada.sedlacek@mail.muni.cz', + license='MIT', + packages=find_packages(), + install_requires=install_requires, + entry_points={ + 'console_scripts': ['run_traits_single=curve_analyzer.traits.run_traits_single:main', + 'merge_trait_results=curve_analyzer.traits.merge_trait_results:main', + 'run_traits=curve_analyzer.traits.run_traits:main'] + }, + scripts=['curve_analyzer/traits/gen_trait_structures.py', 'curve_analyzer/traits/gen_params.py', + 'curve_analyzer/traits/merge_trait_results.py', 'curve_analyzer/traits/gen_unittest.py', + 'curve_analyzer/traits/run_traits.py', 'curve_analyzer/traits/run_traits_single.py'] + ) + +import importlib.util + +spec = importlib.util.spec_from_file_location("gen_params", Path(TRAIT_PATH, "gen_params.py")) +gen_params = importlib.util.module_from_spec(spec) +spec.loader.exec_module(gen_params) +gen_params.main() +spec2 = importlib.util.spec_from_file_location("gen_test", Path(TRAIT_PATH, "gen_trait_structures.py")) +gen_trait = importlib.util.module_from_spec(spec2) +spec2.loader.exec_module(gen_trait) +gen_trait.main(True)