diff --git a/README.md b/README.md index 14868d0b..5603ef3a 100644 --- a/README.md +++ b/README.md @@ -22,6 +22,9 @@ pip install -e ".[dev]" # Install JAX-Galsim pip install git+https://github.com/GalSim-developers/JAX-GalSim.git --no-deps --no-build-isolation +# Install ornax +pip install git+https://github.com/beckermr/ornax.git --no-deps --no-build-isolation + # Might be necessary conda install -c nvidia cuda-nvcc ``` diff --git a/bpd/draw.py b/bpd/draw.py index b4705642..427483fb 100644 --- a/bpd/draw.py +++ b/bpd/draw.py @@ -55,6 +55,31 @@ def draw_exponential( return image.array +def draw_spergel( + *, + nu: float, + f: float, + hlr: float, + e1: float, + e2: float, + x: float, # pixels + y: float, + slen: int, + fft_size: int, # rule of thumb: at least 4 times `slen` + psf_fwhm: float = 0.8, + pixel_scale: float = 0.2, +): + gsparams = GSParams(minimum_fft_size=fft_size, maximum_fft_size=fft_size) + + gal = xgalsim.Spergel(nu=nu, flux=f, half_light_radius=hlr) + gal = gal.shear(g1=e1, g2=e2) + + psf = xgalsim.Gaussian(flux=1.0, fwhm=psf_fwhm) + gal_conv = xgalsim.Convolve([gal, psf]).withGSParams(gsparams) + image = gal_conv.drawImage(nx=slen, ny=slen, scale=pixel_scale, offset=(x, y)) + return image.array + + def draw_gaussian_galsim( *, f: float, diff --git a/experiments/exp70/collate_samples.py b/experiments/exp70/collate_samples.py index b9e55e80..667527d2 100755 --- a/experiments/exp70/collate_samples.py +++ b/experiments/exp70/collate_samples.py @@ -9,14 +9,15 @@ def main( tag: str = typer.Option(), - mode: str = typer.Option(), start_string: str = typer.Option(), + mode: str = typer.Option(), + contains: str = "", overwrite: bool = False, ): assert mode in ("plus", "minus", "") mode_txt = f"_{mode}" if mode else "" dirpath = DATA_DIR / "cache_chains" / tag - newpath = dirpath / f"{start_string}{mode_txt}.npz" + newpath = dirpath / f"{start_string}{mode_txt}_{contains}.npz" if newpath.exists(): if overwrite: @@ -30,7 +31,8 @@ def main( cond1 = fp.name.startswith(start_string) cond2 = fp.name != newpath.name # technically not necessary cond3 = mode in fp.name - if cond1 and cond2 and cond3: + cond4 = contains in fp.name + if cond1 and cond2 and cond3 and cond4: fps.append(fp) full_ds = {} diff --git a/experiments/exp72/get_shear.py b/experiments/exp72/get_shear.py index 0902f8d6..eb208067 100755 --- a/experiments/exp72/get_shear.py +++ b/experiments/exp72/get_shear.py @@ -29,18 +29,20 @@ def main( initial_step_size: float = 0.001, n_samples: int = 3000, overwrite: bool = False, + extra: str = "", ): rng_key = jax.random.key(seed) assert mode in ("plus", "minus", "") mode_txt = f"_{mode}" if mode else "" + extra_txt = "" if not extra else f"_{extra}" # directory structure dirpath = DATA_DIR / "cache_chains" / tag samples_fpath = Path(samples_fpath) assert dirpath.exists() assert samples_fpath.exists(), "ellipticity samples file does not exist" - out_fpath = dirpath / f"g_samples_{seed}{mode_txt}.npz" + out_fpath = dirpath / f"g_samples_{seed}{mode_txt}{extra_txt}.npz" if out_fpath.exists() and not overwrite: raise IOError("overwriting...") @@ -103,6 +105,7 @@ def main( g_samples = pipe(rng_key, post_params) assert g_samples.ndim == 2 assert g_samples.shape[1] == 2 + print("Done running!") save_dataset( {"samples": {"g1": np.array(g_samples[:, 0]), "g2": np.array(g_samples[:, 1])}}, diff --git a/experiments/exp72/simple_bootstrap.py b/experiments/exp72/simple_bootstrap.py index 3a6244c3..cfaade70 100755 --- a/experiments/exp72/simple_bootstrap.py +++ b/experiments/exp72/simple_bootstrap.py @@ -28,6 +28,8 @@ def main( n_boots: int = 25, no_bar: bool = False, n_gals: int | None = None, + extra: str = "", + overwrite: bool = False, ): rng_key = random.key(seed) k1, k2 = random.split(rng_key) @@ -36,7 +38,10 @@ def main( pfpath = Path(samples_plus_fpath) mfpath = Path(samples_minus_fpath) assert dirpath.exists() and pfpath.exists() and mfpath.exists() - fpath = dirpath / f"g_samples_boots_{seed}.npz" + extra_txt = "" if not extra else f"_{extra}" + fpath = dirpath / f"g_samples_boots_{seed}{extra_txt}.npz" + if not overwrite: + assert not fpath.exists() # start in cpu to avoid memory issues. dsp = load_dataset(samples_plus_fpath) @@ -144,7 +149,7 @@ def pipe(k, d): "minus": {"g1": samples_minus["g1"], "g2": samples_minus["g2"]}, }, fpath, - overwrite=True, + overwrite=overwrite, ) diff --git a/experiments/exp72/slurm_bootstrap.py b/experiments/exp72/slurm_bootstrap.py index eb1cb2fd..ecc97e1a 100755 --- a/experiments/exp72/slurm_bootstrap.py +++ b/experiments/exp72/slurm_bootstrap.py @@ -3,6 +3,7 @@ import typer +from bpd import HOME_DIR from bpd.slurm import run_multi_gpu_job @@ -17,33 +18,38 @@ def main( time: str = "00:30", # HH:MM mem_per_gpu: str = "10G", qos: str = "debug", + extra: str = "", ): n_splits = n_nodes * 4 split_size = math.ceil(n_boots / n_splits) cmds = [] + script = HOME_DIR / "experiments" / "exp72" / "simple_bootstrap.py" for ii in range(n_splits): n_gals_txt = f" --n-gals {n_gals}" if n_gals else "" - base_cmd = """./simple_bootstrap.py {new_seed} + extra_txt = f"--extra {extra}" if extra else "" + base_cmd = """{script} {new_seed} --samples-plus-fpath {samples_plus_fpath} --samples-minus-fpath {samples_minus_fpath} - --tag {tag} --n-boots {split_size}{n_gals_txt} + --tag {tag} --n-boots {split_size}{n_gals_txt} {extra_txt} """ base_cmd = " ".join(base_cmd.split()) new_seed = f"{seed}{ii}" cmd = base_cmd.format( + script=script, new_seed=new_seed, tag=tag, split_size=split_size, samples_plus_fpath=samples_plus_fpath, samples_minus_fpath=samples_minus_fpath, n_gals_txt=n_gals_txt, + extra_txt=extra_txt, ) cmds.append(cmd) run_multi_gpu_job( cmds, - jobname=f"{tag}_boot", + jobname=f"{tag}_boot_{seed}_{extra}", time=time, mem_per_gpu=mem_per_gpu, qos=qos, diff --git a/experiments/exp93/Makefile b/experiments/exp93/Makefile new file mode 100644 index 00000000..a830b364 --- /dev/null +++ b/experiments/exp93/Makefile @@ -0,0 +1,202 @@ +SHELL=/bin/bash +SEED := 51 +EXP := exp93 +TAG := ${EXP}_${SEED} +DIR := /pscratch/sd/i/imendoza/data/cache_chains/${TAG} +SHEAR := 0.02 + + +# image sampling phase +QOS := regular +TIME_SAMPLE := 02:00 +NODES_SAMPLE := 8 +MEM_PER_GPU := 10G +N_GALS := 10_000 +N_SAMPLES_PER_GAL := 300 + +export JAX_ENABLE_X64=True + +PLUS_SAMPLES_FPATH_NU01 = ${DIR}/interim_samples_${SEED}1_plus_nu10.npz +MINUS_SAMPLES_FPATH_NU01 = ${DIR}/interim_samples_${SEED}1_minus_nu10.npz + +PLUS_SAMPLES_FPATH_NU03 = ${DIR}/interim_samples_${SEED}1_plus_nu30.npz +MINUS_SAMPLES_FPATH_NU03 = ${DIR}/interim_samples_${SEED}1_minus_nu30.npz + +PLUS_SAMPLES_FPATH_NU05 = ${DIR}/interim_samples_${SEED}1_plus_nu50.npz +MINUS_SAMPLES_FPATH_NU05 = ${DIR}/interim_samples_${SEED}1_minus_nu50.npz + +PLUS_SAMPLES_FPATH_NU10 = ${DIR}/interim_samples_${SEED}1_plus_nu100.npz +MINUS_SAMPLES_FPATH_NU10 = ${DIR}/interim_samples_${SEED}1_minus_nu100.npz + +PLUS_SAMPLES_FPATH_NU20 = ${DIR}/interim_samples_${SEED}1_plus_nu200.npz +MINUS_SAMPLES_FPATH_NU20 = ${DIR}/interim_samples_${SEED}1_minus_nu200.npz + +PLUS_SAMPLES_FPATH_NU30 = ${DIR}/interim_samples_${SEED}1_plus_nu300.npz +MINUS_SAMPLES_FPATH_NU30 = ${DIR}/interim_samples_${SEED}1_minus_nu300.npz + +PLUS_SAMPLES_FPATH_NU-02 = ${DIR}/interim_samples_${SEED}1_plus_nu-20.npz +MINUS_SAMPLES_FPATH_NU-02 = ${DIR}/interim_samples_${SEED}1_minus_nu-20.npz + +PLUS_SAMPLES_FPATH_NU-04 = ${DIR}/interim_samples_${SEED}1_plus_nu-40.npz +MINUS_SAMPLES_FPATH_NU-04 = ${DIR}/interim_samples_${SEED}1_minus_nu-40.npz + +PLUS_SAMPLES_FPATH_NU-06 = ${DIR}/interim_samples_${SEED}1_plus_nu-60.npz +MINUS_SAMPLES_FPATH_NU-06 = ${DIR}/interim_samples_${SEED}1_minus_nu-60.npz + + +shear_samples: + export CUDA_VISIBLE_DEVICES=0 +# ../exp72/get_shear.py ${SEED}2 --samples-fpath ${PLUS_SAMPLES_FPATH_NU01} --tag ${TAG} --mode "plus" --extra "nu10" +# ../exp72/get_shear.py ${SEED}2 --samples-fpath ${MINUS_SAMPLES_FPATH_NU01} --tag ${TAG} --mode "minus" --extra "nu10" + +# ../exp72/get_shear.py ${SEED}2 --samples-fpath ${PLUS_SAMPLES_FPATH_NU03} --tag ${TAG} --mode "plus" --extra "nu30" +# ../exp72/get_shear.py ${SEED}2 --samples-fpath ${MINUS_SAMPLES_FPATH_NU03} --tag ${TAG} --mode "minus" --extra "nu30" + +# ../exp72/get_shear.py ${SEED}2 --samples-fpath ${PLUS_SAMPLES_FPATH_NU05} --tag ${TAG} --mode "plus" --extra "nu50" +# ../exp72/get_shear.py ${SEED}2 --samples-fpath ${MINUS_SAMPLES_FPATH_NU05} --tag ${TAG} --mode "minus" --extra "nu50" + + + ../exp72/get_shear.py ${SEED}2 --samples-fpath ${PLUS_SAMPLES_FPATH_NU10} --tag ${TAG} --mode "plus" --extra "nu100" + ../exp72/get_shear.py ${SEED}2 --samples-fpath ${MINUS_SAMPLES_FPATH_NU10} --tag ${TAG} --mode "minus" --extra "nu100" + + + ../exp72/get_shear.py ${SEED}2 --samples-fpath ${PLUS_SAMPLES_FPATH_NU20} --tag ${TAG} --mode "plus" --extra "nu200" + ../exp72/get_shear.py ${SEED}2 --samples-fpath ${MINUS_SAMPLES_FPATH_NU20} --tag ${TAG} --mode "minus" --extra "nu200" + + ../exp72/get_shear.py ${SEED}2 --samples-fpath ${PLUS_SAMPLES_FPATH_NU30} --tag ${TAG} --mode "plus" --extra "nu300" + ../exp72/get_shear.py ${SEED}2 --samples-fpath ${MINUS_SAMPLES_FPATH_NU30} --tag ${TAG} --mode "minus" --extra "nu300" + + + ../exp72/get_shear.py ${SEED}2 --samples-fpath ${PLUS_SAMPLES_FPATH_NU-02} --tag ${TAG} --mode "plus" --extra "nu-20" + ../exp72/get_shear.py ${SEED}2 --samples-fpath ${MINUS_SAMPLES_FPATH_NU-02} --tag ${TAG} --mode "minus" --extra "nu-20" + + + ../exp72/get_shear.py ${SEED}2 --samples-fpath ${PLUS_SAMPLES_FPATH_NU-04} --tag ${TAG} --mode "plus" --extra "nu-40" + ../exp72/get_shear.py ${SEED}2 --samples-fpath ${MINUS_SAMPLES_FPATH_NU-04} --tag ${TAG} --mode "minus" --extra "nu-40" + + ../exp72/get_shear.py ${SEED}2 --samples-fpath ${PLUS_SAMPLES_FPATH_NU-06} --tag ${TAG} --mode "plus" --extra "nu-60" + ../exp72/get_shear.py ${SEED}2 --samples-fpath ${MINUS_SAMPLES_FPATH_NU-06} --tag ${TAG} --mode "minus" --extra "nu-60" + +boot: +# ../exp72/slurm_bootstrap.py ${SEED}3 --tag ${TAG} --samples-plus-fpath ${PLUS_SAMPLES_FPATH_NU05} --samples-minus-fpath ${MINUS_SAMPLES_FPATH_NU05} --n-boots 100 --extra "nu50" --time "03:00" --qos "regular" --mem-per-gpu 40G + ../exp72/slurm_bootstrap.py ${SEED}3 --tag ${TAG} --samples-plus-fpath ${PLUS_SAMPLES_FPATH_NU01} --samples-minus-fpath ${MINUS_SAMPLES_FPATH_NU01} --n-boots 100 --extra "nu10" --time "03:00" --qos "regular" --mem-per-gpu 40G + + ../exp72/slurm_bootstrap.py ${SEED}3 --tag ${TAG} --samples-plus-fpath ${PLUS_SAMPLES_FPATH_NU03} --samples-minus-fpath ${MINUS_SAMPLES_FPATH_NU03} --n-boots 100 --extra "nu30" --time "03:00" --qos "regular" --mem-per-gpu 40G + + ../exp72/slurm_bootstrap.py ${SEED}3 --tag ${TAG} --samples-plus-fpath ${PLUS_SAMPLES_FPATH_NU10} --samples-minus-fpath ${MINUS_SAMPLES_FPATH_NU10} --n-boots 100 --extra "nu100" --time "03:00" --qos "regular" --mem-per-gpu 40G + + ../exp72/slurm_bootstrap.py ${SEED}3 --tag ${TAG} --samples-plus-fpath ${PLUS_SAMPLES_FPATH_NU20} --samples-minus-fpath ${MINUS_SAMPLES_FPATH_NU20} --n-boots 100 --extra "nu200" --time "03:00" --qos "regular" --mem-per-gpu 40G + + ../exp72/slurm_bootstrap.py ${SEED}3 --tag ${TAG} --samples-plus-fpath ${PLUS_SAMPLES_FPATH_NU30} --samples-minus-fpath ${MINUS_SAMPLES_FPATH_NU30} --n-boots 100 --extra "nu300" --time "03:00" --qos "regular" --mem-per-gpu 40G + + ../exp72/slurm_bootstrap.py ${SEED}3 --tag ${TAG} --samples-plus-fpath ${PLUS_SAMPLES_FPATH_NU-02} --samples-minus-fpath ${MINUS_SAMPLES_FPATH_NU-02} --n-boots 100 --extra "nu-20" --time "03:00" --qos "regular" --mem-per-gpu 40G + + ../exp72/slurm_bootstrap.py ${SEED}3 --tag ${TAG} --samples-plus-fpath ${PLUS_SAMPLES_FPATH_NU-04} --samples-minus-fpath ${MINUS_SAMPLES_FPATH_NU-04} --n-boots 100 --extra "nu-40" --time "03:00" --qos "regular" --mem-per-gpu 40G + + ../exp72/slurm_bootstrap.py ${SEED}3 --tag ${TAG} --samples-plus-fpath ${PLUS_SAMPLES_FPATH_NU-06} --samples-minus-fpath ${MINUS_SAMPLES_FPATH_NU-06} --n-boots 100 --extra "nu-60" --time "03:00" --qos "regular" --mem-per-gpu 40G + +collate_boot: +# ../exp70/collate_samples.py --tag ${TAG} --start-string "g_samples_boots_${SEED}3" --contains "nu50" --mode "" + + ../exp70/collate_samples.py --tag ${TAG} --start-string "g_samples_boots_${SEED}3" --contains "nu10" --mode "" + + ../exp70/collate_samples.py --tag ${TAG} --start-string "g_samples_boots_${SEED}3" --contains "nu30" --mode "" + +# ../exp70/collate_samples.py --tag ${TAG} --start-string "g_samples_boots_${SEED}3" --contains "nu100" --mode "" + +# ../exp70/collate_samples.py --tag ${TAG} --start-string "g_samples_boots_${SEED}3" --contains "nu200" --mode "" + +# ../exp70/collate_samples.py --tag ${TAG} --start-string "g_samples_boots_${SEED}3" --contains "nu300" --mode "" + +# ../exp70/collate_samples.py --tag ${TAG} --start-string "g_samples_boots_${SEED}3" --contains "nu-20" --mode "" + +# ../exp70/collate_samples.py --tag ${TAG} --start-string "g_samples_boots_${SEED}3" --contains "nu-40" --mode "" + +# ../exp70/collate_samples.py --tag ${TAG} --start-string "g_samples_boots_${SEED}3" --contains "nu-60" --mode "" + + +test_slurm_boot: + ../exp72/slurm_bootstrap.py 992 --tag ${TAG} --samples-plus-fpath ${PLUS_SAMPLES_FPATH_NU05} --samples-minus-fpath ${MINUS_SAMPLES_FPATH_NU05} --n-boots 8 --extra "nu50" --time "00:15" --qos "debug" --mem-per-gpu 40G + +test_boot: + ../exp72/simple_bootstrap.py 991 --tag ${TAG} --samples-plus-fpath ${PLUS_SAMPLES_FPATH_NU05} --samples-minus-fpath ${MINUS_SAMPLES_FPATH_NU05} --n-boots 5 --extra "nu50" --n-gals 1000 + + +collate_interim: +# ../exp70/collate_samples.py --tag ${TAG} --mode "plus" --start-string "interim_samples_${SEED}1" --contains "nu10" +# ../exp70/collate_samples.py --tag ${TAG} --mode "minus" --start-string "interim_samples_${SEED}1" --contains "nu10" + +# ../exp70/collate_samples.py --tag ${TAG} --mode "plus" --start-string "interim_samples_${SEED}1" --contains "nu30" +# ../exp70/collate_samples.py --tag ${TAG} --mode "minus" --start-string "interim_samples_${SEED}1" --contains "nu30" + +# ../exp70/collate_samples.py --tag ${TAG} --mode "plus" --start-string "interim_samples_${SEED}1" --contains "nu50" +# ../exp70/collate_samples.py --tag ${TAG} --mode "minus" --start-string "interim_samples_${SEED}1" --contains "nu50" + +# ../exp70/collate_samples.py --tag ${TAG} --mode "plus" --start-string "interim_samples_${SEED}1" --contains "nu-20" +# ../exp70/collate_samples.py --tag ${TAG} --mode "minus" --start-string "interim_samples_${SEED}1" --contains "nu-20" + +# ../exp70/collate_samples.py --tag ${TAG} --mode "plus" --start-string "interim_samples_${SEED}1" --contains "nu-40" +# ../exp70/collate_samples.py --tag ${TAG} --mode "minus" --start-string "interim_samples_${SEED}1" --contains "nu-40" + +# ../exp70/collate_samples.py --tag ${TAG} --mode "plus" --start-string "interim_samples_${SEED}1" --contains "nu-60" +# ../exp70/collate_samples.py --tag ${TAG} --mode "minus" --start-string "interim_samples_${SEED}1" --contains "nu-60" + +# ../exp70/collate_samples.py --tag ${TAG} --mode "plus" --start-string "interim_samples_${SEED}1" --contains "nu100" +# ../exp70/collate_samples.py --tag ${TAG} --mode "minus" --start-string "interim_samples_${SEED}1" --contains "nu100" + +# ../exp70/collate_samples.py --tag ${TAG} --mode "plus" --start-string "interim_samples_${SEED}1" --contains "nu200" +# ../exp70/collate_samples.py --tag ${TAG} --mode "minus" --start-string "interim_samples_${SEED}1" --contains "nu200" + +# ../exp70/collate_samples.py --tag ${TAG} --mode "plus" --start-string "interim_samples_${SEED}1" --contains "nu300" +# ../exp70/collate_samples.py --tag ${TAG} --mode "minus" --start-string "interim_samples_${SEED}1" --contains "nu300" + +###################################################### + +samples_nu: + +# ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 ${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "plus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu 0.3 + +# ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 -${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "minus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu 0.3 + + +# ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 ${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "plus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu 0.1 + +# ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 -${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "minus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu 0.1 + + +# ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 ${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "plus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu 0.5 + +# ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 -${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "minus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu 0.5 + +# ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 ${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "plus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu 1.0 + +# ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 -${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "minus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu 1.0 + +# ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 ${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "plus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu 2.0 + +# ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 -${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "minus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu 2.0 + + + +# ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 ${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "plus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu -0.2 + +# ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 -${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "minus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu -0.2 + +# ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 ${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "plus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu -0.4 + +# ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 -${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "minus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu -0.4 + + ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 ${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "plus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu 3.0 + + ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 -${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "minus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu 3.0 + + ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 ${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "plus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu -0.6 + + ./slurm_get_interim_samples.py ${SEED}1 --tag ${TAG} --g1 -${SHEAR} --g2 0.0 --n-gals ${N_GALS} --n-samples-per-gal ${N_SAMPLES_PER_GAL} --time ${TIME_SAMPLE} --mode "minus" --mem-per-gpu ${MEM_PER_GPU} --qos ${QOS} --nodes ${NODES_SAMPLE} --nu -0.6 + + +test_slurm_samples: + ./slurm_get_interim_samples.py 991 --tag ${TAG} --g1 ${SHEAR} --g2 0.0 --n-gals 1000 --n-samples-per-gal 300 --mode "plus" --batch-size 1000 --qos "debug" --nodes 1 --time 00:10 --nu 0.1 + +test_samples_simple: + ./get_interim_samples.py 990 --tag ${TAG} --g1 ${SHEAR} --g2 0.0 --n-gals 100 --n-samples-per-gal 300 --mode "plus" --batch-size 100 --nu 0.1 diff --git a/experiments/exp93/README.md b/experiments/exp93/README.md new file mode 100644 index 00000000..07bd1b01 --- /dev/null +++ b/experiments/exp93/README.md @@ -0,0 +1,4 @@ +# Experiment 9.3 + +Quantify model bias when fitting a spergel profile with deviation from `nu=0.5` to an exponential +profile. diff --git a/experiments/exp93/get_interim_samples.py b/experiments/exp93/get_interim_samples.py new file mode 100755 index 00000000..ea0df58e --- /dev/null +++ b/experiments/exp93/get_interim_samples.py @@ -0,0 +1,193 @@ +#!/usr/bin/env python3 +import os +from functools import partial + +os.environ["JAX_ENABLE_X64"] = "True" + +import jax.numpy as jnp +import typer +from jax import Array, jit, random, vmap +from jax._src.prng import PRNGKeyArray + +from bpd import DATA_DIR +from bpd.draw import draw_spergel +from bpd.io import save_dataset +from bpd.likelihood import gaussian_image_loglikelihood +from bpd.pipelines import pipeline_interim_samples_one_galaxy +from bpd.prior import interim_gprops_logprior +from bpd.sample import ( + get_target_images, + get_true_params_from_galaxy_params, + sample_galaxy_params_skew, +) +from bpd.utils import DEFAULT_HYPERPARAMS, MAX_N_GALS_PER_GPU, process_in_batches + +_nu_hash = { + -0.6: "-60", + -0.4: "-40", + -0.2: "-20", + 0.1: "10", + 0.3: "30", + 0.5: "50", + 1.0: "100", + 2.0: "200", + 3.0: "300", +} + + +def _init_fnc(key: PRNGKeyArray, *, data: Array, true_params: dict): + image = data + assert image.ndim == 2 + assert image.shape[0] == image.shape[1] + flux = image.sum() + + k1, k2, k3 = random.split(key, 3) + + tlhlr = true_params["lhlr"] + lhlr = random.uniform(k1, shape=(), minval=tlhlr - 0.015, maxval=tlhlr + 0.015) + + te1 = true_params["e1"] + e1 = random.uniform(k2, shape=(), minval=te1 - 0.1, maxval=te1 + 0.1) + + te2 = true_params["e2"] + e2 = random.uniform(k3, shape=(), minval=te2 - 0.1, maxval=te2 + 0.1) + return { + "lf": jnp.log10(flux), + "lhlr": lhlr, + "e1": e1, + "e2": e2, + "dx": 0.0, + "dy": 0.0, + } + + +def main( + seed: int, + tag: str = typer.Option(), + mode: str = "", + nu: float = typer.Option(), + n_gals: int = 3000, + n_samples_per_gal: int = 300, + sigma_e_int: float = 0.3, + g1: float = 0.02, + g2: float = 0.0, + slen: int = 63, + fft_size: int = 256, + background: float = 1.0, + initial_step_size: float = 0.01, + batch_size: int = MAX_N_GALS_PER_GPU, +): + assert (g1 > 0 and mode == "plus") or (g1 < 0 and mode == "minus") or (not mode) + assert nu in _nu_hash + + rng_key = random.key(seed) + pkey, nkey, gkey = random.split(rng_key, 3) + + # directory structure + dirpath = DATA_DIR / "cache_chains" / tag + if not dirpath.exists(): + dirpath.mkdir(exist_ok=True) + extra_tag = f"_{mode}" if mode else "" + out_fpath = dirpath / f"interim_samples_{seed}{extra_tag}_nu{_nu_hash[nu]}.npz" + + # galaxy parameters from prior + galaxy_params = sample_galaxy_params_skew( + pkey, n=n_gals, g1=g1, g2=g2, **DEFAULT_HYPERPARAMS + ) + assert galaxy_params["x"].shape == (n_gals,) + assert galaxy_params["e1"].shape == (n_gals,) + + # now get corresponding target images + draw_params = {**galaxy_params} + draw_params["f"] = 10 ** draw_params.pop("lf") + draw_params["hlr"] = 10 ** draw_params.pop("lhlr") + target_images = get_target_images( + nkey, + draw_params, + background=background, + slen=slen, + draw_type="exponential", + ) + assert target_images.shape == (n_gals, slen, slen) + + # interim samples are on 'sheared ellipticity' + true_params = vmap(get_true_params_from_galaxy_params)(galaxy_params) + true_params["dx"] = jnp.zeros_like(true_params["x"]) + true_params["dy"] = jnp.zeros_like(true_params["y"]) + fixed_params = { + "x": true_params.pop("x"), + "y": true_params.pop("y"), + } + + # setup prior and likelihood + _logprior = partial( + interim_gprops_logprior, + sigma_e=sigma_e_int, + free_flux_hlr=True, + free_dxdy=True, + ) + _draw_fnc = partial(draw_spergel, slen=slen, fft_size=fft_size, nu=nu) + _loglikelihood = partial( + gaussian_image_loglikelihood, + draw_fnc=_draw_fnc, + background=background, + free_flux_hlr=True, + free_dxdy=True, + ) + + # prepare pipelines + gkeys = random.split(gkey, n_gals) + pipe = partial( + pipeline_interim_samples_one_galaxy, + initialization_fnc=_init_fnc, + logprior=_logprior, + loglikelihood=_loglikelihood, + n_samples=n_samples_per_gal, + initial_step_size=initial_step_size, + ) + vpipe = vmap(jit(pipe)) + + # compilation on single target image + _ = vpipe( + gkeys[0, None], + target_images[0, None], + {k: v[0, None] for k, v in fixed_params.items()}, + {k: v[0, None] for k, v in true_params.items()}, + ) + + samples = process_in_batches( + vpipe, + gkeys, + target_images, + fixed_params, + true_params, + n_points=n_gals, + batch_size=batch_size, + ) + + save_dataset( + { + "samples": {**samples}, + "truth": { + "e1": galaxy_params["e1"], + "e2": galaxy_params["e2"], + "lf": galaxy_params["lf"], + "lhlr": galaxy_params["lhlr"], + "x": galaxy_params["x"], + "y": galaxy_params["y"], + }, + "hyper": { + "g1": g1, + "g2": g2, + "sigma_e_int": sigma_e_int, + "nu": nu, + **DEFAULT_HYPERPARAMS, + }, + }, + out_fpath, + overwrite=True, + ) + + +if __name__ == "__main__": + typer.run(main) diff --git a/experiments/exp93/slurm_get_interim_samples.py b/experiments/exp93/slurm_get_interim_samples.py new file mode 100755 index 00000000..8ec4ed96 --- /dev/null +++ b/experiments/exp93/slurm_get_interim_samples.py @@ -0,0 +1,83 @@ +#!/usr/bin/env python3 + +import typer + +from bpd import HOME_DIR +from bpd.slurm import run_multi_gpu_job + +_nu_hash = { + -0.6: "-60", + -0.4: "-40", + -0.2: "-20", + 0.1: "10", + 0.3: "30", + 0.5: "50", + 1.0: "100", + 2.0: "200", + 3.0: "300", +} + + +def main( + seed: int, + tag: str = typer.Option(), + time: str = typer.Option(), + mode: str = typer.Option(), + qos: str = typer.Option(), + nodes: int = typer.Option(), + nu: float = typer.Option(), + n_tasks_per_node: int = 4, + g1: float = typer.Option(), + g2: float = 0.0, + n_gals: int = typer.Option(), + n_samples_per_gal: int = 300, + batch_size: int | None = None, + mem_per_gpu: str = "10G", +): + assert mode in ("plus", "minus", "") + assert nu in _nu_hash + mode_txt = f"_{mode}" if mode else "" + jobname = f"{tag}{mode_txt}_nu{_nu_hash[nu]}" + + script = HOME_DIR / "experiments" / "exp93" / "get_interim_samples.py" + batch_size_txt = f"--batch-size {batch_size}" if batch_size else "" + base_cmd = """python {script} + {{seed}} --tag {tag} + --mode {mode} + --g1 {g1} --g2 {g2} --nu {nu} + --n-gals {n_gals} + --n-samples-per-gal {n_samples_per_gal} {batch_size_txt} + """ + base_cmd = " ".join(base_cmd.split()) + base_cmd = base_cmd.format( + script=script, + tag=tag, + mode=mode, + g1=g1, + g2=g2, + nu=nu, + n_gals=n_gals, + n_samples_per_gal=n_samples_per_gal, + batch_size_txt=batch_size_txt, + ) + + cmds = [] + for ii in range(nodes): + for jj in range(n_tasks_per_node): + _seed = f"{seed}{ii}{jj}" + cmd = base_cmd.format(seed=_seed) + cmds.append(cmd) + + run_multi_gpu_job( + cmds, + jobname=jobname, + time=time, + mem_per_gpu=mem_per_gpu, + qos=qos, + nodes=nodes, + n_tasks_per_node=n_tasks_per_node, + ) + + +if __name__ == "__main__": + typer.run(main) diff --git a/notebooks/dec2-test-spergel-free.ipynb b/notebooks/dec2-test-spergel-free.ipynb new file mode 100644 index 00000000..130c113a --- /dev/null +++ b/notebooks/dec2-test-spergel-free.ipynb @@ -0,0 +1,709 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 10, + "id": "78444da1-8b91-4cbb-b3bc-31903e42ee3e", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from functools import partial\n", + "\n", + "os.environ[\"JAX_ENABLE_X64\"] = \"True\"\n", + "\n", + "import jax.numpy as jnp\n", + "import typer\n", + "from jax import Array, jit, random, vmap\n", + "from jax._src.prng import PRNGKeyArray\n", + "\n", + "from bpd import DATA_DIR\n", + "from bpd.draw import draw_gaussian, draw_spergel\n", + "from bpd.io import save_dataset\n", + "from bpd.likelihood import gaussian_image_loglikelihood\n", + "from bpd.pipelines import pipeline_interim_samples_one_galaxy\n", + "from bpd.prior import interim_gprops_logprior\n", + "from bpd.sample import (\n", + " get_target_images,\n", + " get_true_params_from_galaxy_params,\n", + " sample_galaxy_params_skew,\n", + ")\n", + "from bpd.utils import DEFAULT_HYPERPARAMS, MAX_N_GALS_PER_GPU, process_in_batches\n", + "\n", + "from bpd.chains import run_inference_nuts\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "740b6110-1431-4625-a876-e2aa36d3d2bb", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt \n", + "\n", + "from jax.scipy import stats" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "36251326-360f-4947-914c-245ed4606751", + "metadata": {}, + "outputs": [], + "source": [ + "def _init_fnc(key: PRNGKeyArray, data: Array, true_params: dict):\n", + " image = data\n", + " assert image.ndim == 2\n", + " assert image.shape[0] == image.shape[1]\n", + " flux = image.sum()\n", + "\n", + " k1, k2, k3, k4 = random.split(key, 4)\n", + "\n", + " tlhlr = true_params[\"lhlr\"]\n", + " lhlr = random.uniform(k1, shape=(), minval=tlhlr - 0.015, maxval=tlhlr + 0.015)\n", + "\n", + " te1 = true_params[\"e1\"]\n", + " e1 = random.uniform(k2, shape=(), minval=te1 - 0.1, maxval=te1 + 0.1)\n", + "\n", + " te2 = true_params[\"e2\"]\n", + " e2 = random.uniform(k3, shape=(), minval=te2 - 0.1, maxval=te2 + 0.1)\n", + " \n", + " nu = random.uniform(k4, shape=(), minval=0.4, maxval=0.6)\n", + " \n", + " return {\n", + " \"lf\": jnp.log10(flux),\n", + " \"lhlr\": lhlr,\n", + " \"e1\": e1,\n", + " \"e2\": e2,\n", + " \"dx\": 0.0,\n", + " \"dy\": 0.0,\n", + " 'nu': nu,\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "8ad80300-0cb6-41ec-ad93-0c6e529478b1", + "metadata": {}, + "outputs": [], + "source": [ + "seed: int = 91\n", + "n_gals: int = 100\n", + "n_samples_per_gal: int = 300\n", + "sigma_e_int: float = 0.3\n", + "g1: float = 0.02\n", + "g2: float = 0.0\n", + "slen: int = 63\n", + "fft_size: int = 256\n", + "background: float = 1.0\n", + "initial_step_size: float = 0.01\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "067da7a0-a485-4899-a703-228079938798", + "metadata": {}, + "outputs": [], + "source": [ + "rng_key = random.key(seed)\n", + "pkey, nkey, gkey = random.split(rng_key, 3)\n", + "\n", + "# galaxy parameters from prior\n", + "galaxy_params = sample_galaxy_params_skew(\n", + " pkey, n=n_gals, g1=g1, g2=g2, **DEFAULT_HYPERPARAMS\n", + ")\n", + "assert galaxy_params[\"x\"].shape == (n_gals,)\n", + "assert galaxy_params[\"e1\"].shape == (n_gals,)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "a2a0a543-ba1d-43d1-acc8-52bcee8d7a07", + "metadata": {}, + "outputs": [], + "source": [ + "# now get corresponding target images\n", + "draw_params = {**galaxy_params}\n", + "draw_params[\"f\"] = 10 ** draw_params.pop(\"lf\")\n", + "draw_params[\"hlr\"] = 10 ** draw_params.pop(\"lhlr\")\n", + "target_images = get_target_images(\n", + " nkey,\n", + " draw_params,\n", + " background=background,\n", + " slen=slen,\n", + " draw_type=\"exponential\",\n", + ")\n", + "assert target_images.shape == (n_gals, slen, slen)\n", + "\n", + "# interim samples are on 'sheared ellipticity'\n", + "true_params = vmap(get_true_params_from_galaxy_params)(galaxy_params)\n", + "true_params[\"dx\"] = jnp.zeros_like(true_params[\"x\"])\n", + "true_params[\"dy\"] = jnp.zeros_like(true_params[\"y\"])\n", + "fixed_params = {\n", + " \"x\": true_params.pop(\"x\"),\n", + " \"y\": true_params.pop(\"y\"),\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "3ddf7300-dda6-4238-b274-4ca3ff453e26", + "metadata": {}, + "outputs": [], + "source": [ + "def logtarget(params, *, data, fixed_params, sigma_e_int, slen, fft_size, background):\n", + "\n", + " nu = params.pop('nu')\n", + "\n", + " logprior = interim_gprops_logprior(params, sigma_e=sigma_e_int, free_flux_hlr=True, free_dxdy=True)\n", + " _draw_fnc = partial(draw_spergel, nu=nu, slen=slen, fft_size=fft_size) \n", + "\n", + " # account for nu\n", + " # logprior += stats.uniform.logpdf(nu, -0.85, 4.0) # galsim permitted values\n", + " logprior += stats.norm.logpdf(nu, 0.5, 0.1)\n", + "\n", + " loglikelihood = gaussian_image_loglikelihood(params, data, fixed_params, \n", + " draw_fnc=_draw_fnc, background=background, free_flux_hlr=True, free_dxdy=True)\n", + "\n", + " return logprior + loglikelihood\n", + "\n", + "\n", + "def pipe(rng_key, data, init_params, fixed_params, *, logtarget, n_samples=100,):\n", + " _logtarget = partial(logtarget, fixed_params=fixed_params)\n", + " _do_inference = partial(run_inference_nuts, logtarget=_logtarget, \n", + " n_samples=n_samples, initial_step_size=0.01, max_num_doublings=5)\n", + " return _do_inference(rng_key, data, init_params)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "cc869fe2-4deb-40fb-8ec1-21f4c03535ae", + "metadata": {}, + "outputs": [], + "source": [ + "_logtarget = partial(logtarget, sigma_e_int=0.3, slen=slen, fft_size=fft_size, background=background)\n", + "_pipe = jit(partial(pipe, logtarget=_logtarget, n_samples=500))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "02f25452-f8d1-4d91-a23a-f22c5e202b8d", + "metadata": {}, + "outputs": [], + "source": [ + "ikey, rkey = random.split(gkey, 2)\n", + "\n", + "rkeys = random.split(rkey, n_gals)\n", + "ikeys = random.split(ikey, n_gals)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "4ad153cb-5309-4f51-8ba2-7972c7e7b96c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100,)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# get initial parameters\n", + "init_params= vmap(_init_fnc)(ikeys, target_images, true_params)\n", + "\n", + "init_params['nu'].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "83a7249b-e07a-4bbc-b8bb-282ec05bfaa6", + "metadata": {}, + "outputs": [], + "source": [ + "# compilation on single target image\n", + "_ = _pipe(\n", + " rkeys[0],\n", + " target_images[0],\n", + " {k: v[0] for k, v in init_params.items()},\n", + " {k: v[0] for k, v in fixed_params.items()},\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "a3eeb5e7-da94-4acb-8057-6c0360069413", + "metadata": {}, + "outputs": [], + "source": [ + "vpipe = vmap(_pipe)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "a625a443-4996-4590-96a1-c70eb78406ef", + "metadata": {}, + "outputs": [], + "source": [ + "samples = vpipe(\n", + " rkeys,\n", + " target_images,\n", + " init_params,\n", + " fixed_params\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "a45f2ce0-afed-4d35-8d97-5b19495faea8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 500)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "samples['nu'].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "166ebab1-397b-4781-b17e-4cf27ed6b2a0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(samples['nu'][51])" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "837f9b65-68e9-4a4b-a6fa-115872751d45", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(samples['lf'][51])" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "a812af91-5b1c-4003-876e-6e8bbc30a14b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(samples['nu'][12], samples['e2'][12])" + ] + }, + { + "cell_type": "markdown", + "id": "b996605a-fe35-4e86-80c6-839a99dbdd17", + "metadata": {}, + "source": [ + "# Check convergence" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "8702d2d2-c799-4e27-8841-a3a2576c05ef", + "metadata": {}, + "outputs": [], + "source": [ + "# lets use 400 total galaxies to check for convergence\n", + "import numpy as np \n", + "from tqdm import tqdm\n", + "\n", + "from arviz import ess\n", + "from blackjax.diagnostics import potential_scale_reduction\n", + "def get_ess_all(samples: dict[str, np.ndarray]) -> dict[str, np.ndarray]:\n", + " \"\"\"Obtain ESS for all chains and parameters.\"\"\"\n", + " print(\"INFO: Computing ESS...\")\n", + " n_gals, n_chains_per_gal, n_samples_per_gal = samples[\"lf\"].shape\n", + "\n", + " n_samples = n_chains_per_gal * n_samples_per_gal\n", + " ess_dict = {}\n", + "\n", + " for ii in tqdm(range(n_gals)):\n", + " params = {k: v[ii] for k, v in samples.items()}\n", + " value = ess(params)\n", + "\n", + " for k in samples:\n", + " kval = value[k].data.item() / n_samples\n", + " if k not in ess_dict:\n", + " ess_dict[k] = [kval]\n", + " else:\n", + " ess_dict[k].append(kval)\n", + " ess_dict = {k: np.array(v) for k, v in ess_dict.items()}\n", + " return ess_dict\n", + "\n", + "\n", + "def get_rhat_all(samples: dict[str, np.ndarray]) -> dict[str, np.ndarray]:\n", + " \"\"\"Obtain r-hats for all chains and parameters.\"\"\"\n", + " print(\"INFO: Computing R-hats...\")\n", + " n_gals, n_chains_per_gal, n_samples = samples[\"lf\"].shape\n", + "\n", + " rhat_dict = {}\n", + " for p in samples:\n", + " rhat = []\n", + " for ii in tqdm(range(n_gals)):\n", + " chains = samples[p][ii]\n", + " assert chains.shape == (n_chains_per_gal, n_samples)\n", + " rhat.append(potential_scale_reduction(chains))\n", + " rhat_dict[p] = np.array(rhat)\n", + "\n", + " return rhat_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "911dd7d7-e94e-4176-803c-c944cbed9c2c", + "metadata": {}, + "outputs": [], + "source": [ + "ikeys = random.split(ikey, (n_gals, 4))\n", + "rkeys = random.split(rkey, (n_gals, 4))" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "2104c60d-421b-4de7-a4d7-441d779d1309", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 4)" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# get initial parameters\n", + "init_params= vmap(vmap(_init_fnc, in_axes=(0, None, None)))(ikeys, target_images, true_params)\n", + "\n", + "init_params['nu'].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "ce922526-ee65-431d-850b-343334e17319", + "metadata": {}, + "outputs": [], + "source": [ + "vpipe = vmap(vmap(_pipe, in_axes=(0, None, 0, None)))" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "87968806-0587-4464-b7f3-9154a0db23cb", + "metadata": {}, + "outputs": [], + "source": [ + "samples = vpipe(\n", + " rkeys,\n", + " target_images,\n", + " init_params,\n", + " fixed_params\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "7b408301-0478-40c3-b5c9-6387cfac8564", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 4, 500)" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "samples['nu'].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "e55ffc37-1138-4684-99b9-9ec7e775def4", + "metadata": {}, + "outputs": [], + "source": [ + "# save using pickle \n", + "import pickle\n", + "with open('samples_nu2.pkl', 'wb') as fp:\n", + " pickle.dump(samples, fp, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "375c0944-32e5-4a9b-803b-26b54315c518", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Computing ESS...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [00:01<00:00, 83.56it/s]\n" + ] + } + ], + "source": [ + "# check convernge of each param\n", + "ess_dict = get_ess_all(samples)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "ce846eea-3a3b-4c46-8385-dd442a9af148", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Computing R-hats...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [00:00<00:00, 172.79it/s]\n", + "100%|██████████| 100/100 [00:00<00:00, 1040.00it/s]\n", + "100%|██████████| 100/100 [00:00<00:00, 1078.78it/s]\n", + "100%|██████████| 100/100 [00:00<00:00, 1085.69it/s]\n", + "100%|██████████| 100/100 [00:00<00:00, 1047.27it/s]\n", + "100%|██████████| 100/100 [00:00<00:00, 1041.14it/s]\n", + "100%|██████████| 100/100 [00:00<00:00, 1061.03it/s]\n" + ] + } + ], + "source": [ + "rhat_dict = get_rhat_all(samples) " + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "c3da92de-6452-4309-a688-a09afe17157d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dx\n", + "1.0546209459483 1.0685894985948237 0.7651899466834704\n", + "\n", + "dy\n", + "1.0378443793524061 1.057440289477544 0.7760658672606309\n", + "\n", + "e1\n", + "1.0123463908950128 1.01917544965443 0.6439456304643713\n", + "\n", + "e2\n", + "1.0243261049452244 1.0184790404563115 0.6147803541201777\n", + "\n", + "lf\n", + "0.7559867862689423 0.7804291981841135 0.5451550986461776\n", + "\n", + "lhlr\n", + "0.6885143216681329 0.7199791299559267 0.4528714359618318\n", + "\n", + "nu\n", + "1.045636399210324 1.0658742888598765 0.6362905850809464\n", + "\n" + ] + } + ], + "source": [ + "for p in ess_dict:\n", + " print(p)\n", + " print(np.median(ess_dict[p]), np.mean(ess_dict[p]), np.min(ess_dict[p]))\n", + " print()" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "65b06677-fda8-42bd-8499-af1470dda25a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.00068609, 0.99972128, 0.99946165, 0.99907527, 0.99975973,\n", + " 1.00052663, 0.99955319, 0.9994141 , 0.99943226, 0.99924814,\n", + " 0.99950852, 0.99913251, 0.99907089, 0.99953516, 0.99997354,\n", + " 0.99992864, 0.99985013, 0.99904869, 0.99951245, 1.00140486,\n", + " 0.99950369, 1.00013786, 0.99965861, 1.0012618 , 0.99928947,\n", + " 0.99960497, 0.99927399, 1.00094 , 0.99974491, 1.00058087,\n", + " 0.99939884, 1.00003864, 0.9991226 , 0.99925595, 0.99917557,\n", + " 1.00049183, 0.99992778, 0.99945452, 0.99923881, 0.99984491,\n", + " 0.99932886, 0.99976013, 1.00097152, 0.99951916, 0.99962188,\n", + " 1.00120587, 0.99908686, 0.99939269, 0.99968173, 0.99915898,\n", + " 1.00232082, 1.00044152, 0.99908289, 0.99960973, 0.99956588,\n", + " 0.99985506, 1.00175027, 1.00275459, 0.99928619, 0.99946235,\n", + " 0.99986684, 0.99974786, 0.99901698, 1.00001089, 0.99966729,\n", + " 0.99990411, 0.99996116, 1.00044652, 1.00002566, 0.99923692,\n", + " 0.99964816, 1.00012023, 0.99927287, 0.99993201, 1.00121493,\n", + " 1.00033187, 1.00021758, 0.99917129, 1.00132035, 0.99919184,\n", + " 1.00051061, 0.99914898, 0.99949619, 0.99986066, 0.99981545,\n", + " 0.99907253, 0.99913882, 1.00021837, 1.00068308, 0.99971656,\n", + " 0.99948439, 1.00071535, 1.00112028, 0.99957868, 0.9993278 ,\n", + " 1.00035326, 0.99937916, 0.99975724, 1.00072854, 1.00131301])" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rhat_dict['dx']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6ebaf47d-067a-4274-8b5f-5f2189182728", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bpd_gpu", + "language": "python", + "name": "bpd_gpu" + }, + "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.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/nov14-spergel-profile.ipynb b/notebooks/nov14-spergel-profile.ipynb index 47a0385a..c1e742b7 100644 --- a/notebooks/nov14-spergel-profile.ipynb +++ b/notebooks/nov14-spergel-profile.ipynb @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "cba13ebb", "metadata": {}, "outputs": [], @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 3, "id": "028975d8", "metadata": {}, "outputs": [], @@ -52,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 4, "id": "d191afe4", "metadata": {}, "outputs": [], @@ -67,17 +67,17 @@ }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 5, "id": "f64965dd", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 92, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, diff --git a/notebooks/nov19-check-spergel-runs-fast.ipynb b/notebooks/nov19-check-spergel-runs-fast.ipynb new file mode 100644 index 00000000..18e5cbd8 --- /dev/null +++ b/notebooks/nov19-check-spergel-runs-fast.ipynb @@ -0,0 +1,990 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "ab322587-36fc-4d45-8096-9ed681bb6ba1", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from functools import partial\n", + "\n", + "os.environ[\"JAX_ENABLE_X64\"] = \"True\"\n", + "\n", + "import jax.numpy as jnp\n", + "import typer\n", + "from jax import Array, jit, random, vmap\n", + "from jax._src.prng import PRNGKeyArray\n", + "\n", + "from bpd import DATA_DIR\n", + "from bpd.draw import draw_gaussian, draw_spergel\n", + "from bpd.io import save_dataset\n", + "from bpd.likelihood import gaussian_image_loglikelihood\n", + "from bpd.pipelines import pipeline_interim_samples_one_galaxy\n", + "from bpd.prior import interim_gprops_logprior\n", + "from bpd.sample import (\n", + " get_target_images,\n", + " get_true_params_from_galaxy_params,\n", + " sample_galaxy_params_skew,\n", + ")\n", + "from bpd.utils import DEFAULT_HYPERPARAMS, MAX_N_GALS_PER_GPU, process_in_batches\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "140a6b6a-7878-4217-ade7-f1e6552b22b3", + "metadata": {}, + "outputs": [], + "source": [ + "def _init_fnc(key: PRNGKeyArray, *, data: Array, true_params: dict):\n", + " image = data\n", + " assert image.ndim == 2\n", + " assert image.shape[0] == image.shape[1]\n", + " flux = image.sum()\n", + "\n", + " k1, k2, k3 = random.split(key, 3)\n", + "\n", + " tlhlr = true_params[\"lhlr\"]\n", + " lhlr = random.uniform(k1, shape=(), minval=tlhlr - 0.015, maxval=tlhlr + 0.015)\n", + "\n", + " te1 = true_params[\"e1\"]\n", + " e1 = random.uniform(k2, shape=(), minval=te1 - 0.1, maxval=te1 + 0.1)\n", + "\n", + " te2 = true_params[\"e2\"]\n", + " e2 = random.uniform(k3, shape=(), minval=te2 - 0.1, maxval=te2 + 0.1)\n", + " return {\n", + " \"lf\": jnp.log10(flux),\n", + " \"lhlr\": lhlr,\n", + " \"e1\": e1,\n", + " \"e2\": e2,\n", + " \"dx\": 0.0,\n", + " \"dy\": 0.0,\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ea7cd676-4856-4813-8da0-9295f16b94b8", + "metadata": {}, + "outputs": [], + "source": [ + "seed: int = 11\n", + "n_gals: int = 100\n", + "n_samples_per_gal: int = 100\n", + "sigma_e_int: float = 0.3\n", + "g1: float = 0.02\n", + "g2: float = 0.0\n", + "slen: int = 63\n", + "fft_size: int = 256\n", + "background: float = 1.0\n", + "initial_step_size: float = 0.01\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "102ec150-176b-4969-9d84-1e9ad379b553", + "metadata": {}, + "outputs": [], + "source": [ + "rng_key = random.key(seed)\n", + "pkey, nkey, gkey = random.split(rng_key, 3)\n", + "\n", + "\n", + "\n", + "# galaxy parameters from prior\n", + "galaxy_params = sample_galaxy_params_skew(\n", + " pkey, n=n_gals, g1=g1, g2=g2, **DEFAULT_HYPERPARAMS\n", + ")\n", + "assert galaxy_params[\"x\"].shape == (n_gals,)\n", + "assert galaxy_params[\"e1\"].shape == (n_gals,)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a6b3ec39-54a7-494f-9d9c-5cd1b98bebfa", + "metadata": {}, + "outputs": [], + "source": [ + "# now get corresponding target images\n", + "draw_params = {**galaxy_params}\n", + "draw_params[\"f\"] = 10 ** draw_params.pop(\"lf\")\n", + "draw_params[\"hlr\"] = 10 ** draw_params.pop(\"lhlr\")\n", + "target_images = get_target_images(\n", + " nkey,\n", + " draw_params,\n", + " background=background,\n", + " slen=slen,\n", + " draw_type=\"exponential\",\n", + ")\n", + "assert target_images.shape == (n_gals, slen, slen)\n", + "\n", + "# interim samples are on 'sheared ellipticity'\n", + "true_params = vmap(get_true_params_from_galaxy_params)(galaxy_params)\n", + "true_params[\"dx\"] = jnp.zeros_like(true_params[\"x\"])\n", + "true_params[\"dy\"] = jnp.zeros_like(true_params[\"y\"])\n", + "fixed_params = {\n", + " \"x\": true_params.pop(\"x\"),\n", + " \"y\": true_params.pop(\"y\"),\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9decd8d1-e67c-4ede-a7b1-5ea3b286211a", + "metadata": {}, + "outputs": [], + "source": [ + "# setup prior and likelihood\n", + "_logprior = partial(\n", + " interim_gprops_logprior,\n", + " sigma_e=sigma_e_int,\n", + " free_flux_hlr=True,\n", + " free_dxdy=True,\n", + ")\n", + "_draw_fnc = partial(draw_spergel, nu=0.5, slen=slen, fft_size=fft_size) # need to specify nu\n", + "_loglikelihood = partial(\n", + " gaussian_image_loglikelihood,\n", + " draw_fnc=_draw_fnc,\n", + " background=background,\n", + " free_flux_hlr=True,\n", + " free_dxdy=True,\n", + ")\n", + "\n", + "# prepare pipelines\n", + "gkeys = random.split(gkey, n_gals)\n", + "pipe = partial(\n", + " pipeline_interim_samples_one_galaxy,\n", + " initialization_fnc=_init_fnc,\n", + " logprior=_logprior,\n", + " loglikelihood=_loglikelihood,\n", + " n_samples=n_samples_per_gal,\n", + " initial_step_size=initial_step_size,\n", + ")\n", + "vpipe = vmap(jit(pipe))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "51262adc-efdc-47af-a8f9-ecf69ab95ab7", + "metadata": {}, + "outputs": [], + "source": [ + "# compilation on single target image\n", + "_ = vpipe(\n", + " gkeys[0, None],\n", + " target_images[0, None],\n", + " {k: v[0, None] for k, v in fixed_params.items()},\n", + " {k: v[0, None] for k, v in true_params.items()},\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bfd9103b-6e85-403f-82cc-b993036ddec6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Processing batches: 100%|██████████| 1/1 [00:53<00:00, 53.08s/it]\n" + ] + } + ], + "source": [ + "samples = process_in_batches(\n", + " vpipe,\n", + " gkeys,\n", + " target_images,\n", + " fixed_params,\n", + " true_params,\n", + " n_points=n_gals,\n", + " batch_size=100,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "91ff1144-22c3-4b46-8263-9895781511dc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 100)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "samples['e1'].shape" + ] + }, + { + "cell_type": "markdown", + "id": "3ed44161-dc0c-42f2-82dd-85ed66ac864c", + "metadata": {}, + "source": [ + "# Check runs on SLURM (test)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "2e34e75b-43fe-44af-a5c9-b592f50c27a2", + "metadata": {}, + "outputs": [], + "source": [ + "from bpd.io import load_dataset\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9f1bc1b4-d5a1-4260-87d6-3ca763268fd1", + "metadata": {}, + "outputs": [], + "source": [ + "fpath = \"/pscratch/sd/i/imendoza/data/cache_chains/exp93_51/interim_samples_99100_plus.npz\"" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ea219515-0d1b-40ec-a09d-bd05a7a9fc3a", + "metadata": {}, + "outputs": [], + "source": [ + "ds = load_dataset(fpath)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f3b59910-e953-47f4-bd67-3196871da4c8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['samples', 'truth', 'hyper'])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "6bed4c02-e0d1-47d1-93b1-6d993e7aeb65", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'g1': array(0.02),\n", + " 'g2': array(0.),\n", + " 'sigma_e_int': array(0.3),\n", + " 'nu': array(0.1),\n", + " 'shape_noise': array(0.2),\n", + " 'a_logflux': array(14.),\n", + " 'mean_logflux': array(2.45),\n", + " 'sigma_logflux': array(0.4),\n", + " 'mean_loghlr': array(-0.4),\n", + " 'sigma_loghlr': array(0.05)}" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds['hyper']" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e51505e0-7a54-482e-aef3-f8f16b34e708", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1000, 300)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds['samples']['e1'].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "66289529-ce26-4115-8307-921f3c278d7a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(ds['samples']['dy'][11, :])" + ] + }, + { + "cell_type": "markdown", + "id": "b89af24b-042e-483a-9922-3b4c0616c4c1", + "metadata": {}, + "source": [ + "# Check large run in SLURM" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e12a0424", + "metadata": {}, + "outputs": [], + "source": [ + "from bpd.io import load_dataset\n", + "import matplotlib.pyplot as plt\n", + "\n", + "fpath = \"/pscratch/sd/i/imendoza/data/cache_chains/exp93_51/interim_samples_51152_minus_nu50.npz\"\n", + "ds = load_dataset(fpath)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "243ed647", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((10000, 300), array(0.5), array(-0.02))" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds['samples']['e1'].shape, ds['hyper']['nu'], ds['hyper']['g1']" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "83631a42", + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib.backends.backend_pdf import PdfPages\n", + "\n", + "\n", + "fname = \"traces1.pdf\"\n", + "with PdfPages(fname) as pdf:\n", + " for ii in range(25):\n", + " fig, ax = plt.subplots(1, 1, figsize=(12,7))\n", + " ax.plot(ds['samples']['e1'][ii])\n", + " pdf.savefig(fig)\n", + " plt.close(fig)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "f93729cd", + "metadata": {}, + "outputs": [], + "source": [ + "# compare with no model bias case\n", + "\n", + "fpath = \"/pscratch/sd/i/imendoza/data/cache_chains/exp72_51/interim_samples_511_plus.npz\"\n", + "ds2 = load_dataset(fpath)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "41d3a878", + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib.backends.backend_pdf import PdfPages\n", + "\n", + "\n", + "fname = \"traces2.pdf\"\n", + "with PdfPages(fname) as pdf:\n", + " for ii in range(25):\n", + " fig, ax = plt.subplots(1, 1, figsize=(12,7))\n", + " ax.plot(ds2['samples']['e1'][ii])\n", + " pdf.savefig(fig)\n", + " plt.close(fig)" + ] + }, + { + "cell_type": "markdown", + "id": "537755d4-22f0-4746-ae32-e4471ebed7bd", + "metadata": {}, + "source": [ + "# Check shear " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "72c6fc47-a5a4-4257-b269-41463d3ddc2b", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.environ[\"JAX_PLATFORMS\"] = \"cpu\"\n", + "os.environ[\"JAX_ENABLE_X64\"] = \"True\"\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "from bpd.io import load_dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a8ff1cb8-2ef9-48d8-ba2e-86834a35b111", + "metadata": {}, + "outputs": [], + "source": [ + "dsp = load_dataset(\"/pscratch/sd/i/imendoza/data/cache_chains/exp93_51/g_samples_512_plus_nu50.npz\")\n", + "dsm = load_dataset(\"/pscratch/sd/i/imendoza/data/cache_chains/exp93_51/g_samples_512_minus_nu50.npz\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e3060825-b5bf-43b1-b625-e177f7f1e034", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(dsp['samples']['g1'])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "76e82cba-e68a-4f7a-94c0-26a3da8597f2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(dsm['samples']['g1'])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "edccfa03-f8c4-4025-bd20-49586c7f551f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3000,)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g1p = dsp['samples']['g1']\n", + "g1m = dsm['samples']['g1']\n", + "g1p.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "80fd3b5f-935f-4332-ab16-cd70ca08f779", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(-0.00018929439224490974)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m = (g1p.mean() - g1m.mean()) / 2/ 0.02 -1 \n", + "m" + ] + }, + { + "cell_type": "markdown", + "id": "5ee9d13c-df30-4cca-a0ad-41c55ba2533b", + "metadata": {}, + "source": [ + " # Check boots\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8a189665", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.environ[\"JAX_PLATFORMS\"] = \"cpu\"\n", + "os.environ[\"JAX_ENABLE_X64\"] = \"True\"\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "from bpd.io import load_dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cbacb93d", + "metadata": {}, + "outputs": [], + "source": [ + "ds = load_dataset(\"/pscratch/sd/i/imendoza/data/cache_chains/exp93_51/g_samples_boots_513_nu50.npz\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ae60bb05", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 1000)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g1p =ds['plus']['g1']\n", + "g1m = ds['minus']['g1']\n", + "g1p.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fd892ae3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(g1p[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7a67b813", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([ 1., 1., 6., 11., 15., 18., 22., 10., 10., 6.]),\n", + " array([0.01839116, 0.01857487, 0.01875858, 0.01894229, 0.01912601,\n", + " 0.01930972, 0.01949343, 0.01967715, 0.01986086, 0.02004457,\n", + " 0.02022828]),\n", + " )" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(g1p.mean(1))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "cf0430d6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100,)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ms = (g1p.mean(1) - g1m.mean(1)) / 2/ 0.02 -1\n", + "ms.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ddd492b4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([ 4., 3., 11., 10., 21., 20., 20., 6., 4., 1.]),\n", + " array([-6.58358806e-04, -5.48208027e-04, -4.38057248e-04, -3.27906469e-04,\n", + " -2.17755691e-04, -1.07604912e-04, 2.54586680e-06, 1.12696646e-04,\n", + " 2.22847424e-04, 3.32998203e-04, 4.43148982e-04]),\n", + " )" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(ms)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "7cbcfcd2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.float64(-0.00011957386798073011), np.float64(0.00022498552873866418))" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ms.mean(), ms.std()" + ] + }, + { + "cell_type": "markdown", + "id": "fe12e1c8-3e2d-41f4-820d-afdfcf1420eb", + "metadata": {}, + "source": [ + "# Combine all experiments" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "fb1c85d7", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.environ[\"JAX_PLATFORMS\"] = \"cpu\"\n", + "os.environ[\"JAX_ENABLE_X64\"] = \"True\"\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "from bpd.io import load_dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6f23558d-7376-4371-bda1-c42e3df04cd1", + "metadata": {}, + "outputs": [], + "source": [ + "_nu_hash = {\n", + " -0.6: \"-60\",\n", + " -0.4: \"-40\",\n", + " -0.2: \"-20\",\n", + " 0.1: \"10\",\n", + " 0.3: \"30\",\n", + " 0.5: \"50\",\n", + " 1.0: \"100\",\n", + " 2.0: \"200\",\n", + " 3.0: \"300\",\n", + "}\n", + "\n", + "nus = [k for k,v in _nu_hash.items()]\n", + "nus_str = [v for k,v in _nu_hash.items()]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2637958c-45a5-43a4-9bac-f73e17fe8db6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([-0.6, -0.4, -0.2, 0.1, 0.3, 0.5, 1.0, 2.0, 3.0],\n", + " ['-60', '-40', '-20', '10', '30', '50', '100', '200', '300'])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nus, nus_str" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "64b70178-9d72-4d27-9642-531696972399", + "metadata": {}, + "outputs": [], + "source": [ + "ms = []\n", + "for nu in nus_str:\n", + " dsp = load_dataset(f\"/pscratch/sd/i/imendoza/data/cache_chains/exp93_51/g_samples_512_plus_nu{nu}.npz\")\n", + " dsm = load_dataset(f\"/pscratch/sd/i/imendoza/data/cache_chains/exp93_51/g_samples_512_minus_nu{nu}.npz\")\n", + "\n", + "\n", + " g1p = dsp['samples']['g1']\n", + " g1m = dsm['samples']['g1']\n", + "\n", + " m = (g1p.mean() - g1m.mean()) / 2 / 0.02 - 1\n", + " ms.append(m)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "594cbc63-0116-4d88-a25e-2e60fe4ded92", + "metadata": {}, + "outputs": [], + "source": [ + "# gaussian\n", + "dsp = load_dataset(f\"/pscratch/sd/i/imendoza/data/cache_chains/exp91_51/g_samples_512_plus.npz\")\n", + "dsm = load_dataset(f\"/pscratch/sd/i/imendoza/data/cache_chains/exp91_51/g_samples_512_minus.npz\")\n", + "\n", + "g1p = dsp['samples']['g1']\n", + "g1m = dsm['samples']['g1']\n", + "m_gauss = (g1p.mean() - g1m.mean()) / 2 / 0.02 - 1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "d2c6542e-1e3b-40fc-9d22-ba1b8ac38201", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(nus, ms, '-o')\n", + "plt.ylabel('multiplicative bias')\n", + "# plt.axhline(2e-3, c='k', ls='--')\n", + "# plt.axhline(-2e-3, c='k', ls='--', label='requirement')\n", + "plt.xlabel('nu')\n", + "plt.axhline(m_gauss, c='r', ls='--', label='Gaussian')\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "16600404-98dc-481f-8adf-a799044b6471", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "NERSC Python", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/nov19-test-hmc-ornax.ipynb b/notebooks/nov19-test-hmc-ornax.ipynb new file mode 100644 index 00000000..40612e9a --- /dev/null +++ b/notebooks/nov19-test-hmc-ornax.ipynb @@ -0,0 +1,844 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 43, + "id": "70da6956", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from functools import partial\n", + "\n", + "os.environ[\"JAX_ENABLE_X64\"] = \"True\"\n", + "\n", + "import jax.numpy as jnp\n", + "import typer\n", + "from jax import Array, jit, random, vmap\n", + "from jax._src.prng import PRNGKeyArray\n", + "\n", + "from bpd import DATA_DIR\n", + "from bpd.draw import draw_exponential\n", + "from bpd.io import save_dataset\n", + "from bpd.likelihood import gaussian_image_loglikelihood\n", + "from bpd.pipelines import pipeline_interim_samples_one_galaxy\n", + "from bpd.prior import interim_gprops_logprior\n", + "from bpd.sample import (\n", + " get_target_images,\n", + " get_true_params_from_galaxy_params,\n", + " sample_galaxy_params_skew,\n", + ")\n", + "from bpd.utils import DEFAULT_HYPERPARAMS, MAX_N_GALS_PER_GPU, process_in_batches\n", + "\n", + "import matplotlib.pyplot as plt \n", + "\n", + "import numpy as np " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "aff6be34-881d-4bcb-8dc4-a775716e22a4", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/pscratch/sd/i/imendoza/miniconda3/envs/bpd_gpu/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "from ornax.hmc import ensemble_hmc" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "c7b523ce", + "metadata": {}, + "outputs": [], + "source": [ + "def _init_fnc(key: PRNGKeyArray, *, data: Array, true_params: dict):\n", + " image = data\n", + " assert image.ndim == 2\n", + " assert image.shape[0] == image.shape[1]\n", + " flux = image.sum()\n", + "\n", + " k1, k2, k3, k4, k5, k6 = random.split(key, 6)\n", + "\n", + " _lf = jnp.log10(flux)\n", + " lf = random.uniform(k1, shape=(), minval=_lf - 0.01, maxval=_lf + 0.01)\n", + "\n", + " tlhlr = true_params[\"lhlr\"]\n", + " lhlr = random.uniform(k2, shape=(), minval=tlhlr - 0.015, maxval=tlhlr + 0.015)\n", + "\n", + " te1 = true_params[\"e1\"]\n", + " e1 = random.uniform(k3, shape=(), minval=te1 - 0.1, maxval=te1 + 0.1)\n", + "\n", + " te2 = true_params[\"e2\"]\n", + " e2 = random.uniform(k4, shape=(), minval=te2 - 0.1, maxval=te2 + 0.1)\n", + " return {\n", + " \"lf\": lf,\n", + " \"lhlr\": lhlr,\n", + " \"e1\": e1,\n", + " \"e2\": e2,\n", + " \"dx\": random.uniform(k5, shape=(), minval=-0.1, maxval=0.1),\n", + " \"dy\": random.uniform(k6, shape=(), minval=-0.1, maxval=0.1),\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "d9317a9b", + "metadata": {}, + "outputs": [], + "source": [ + "def initialize_params(key, image, true_params):\n", + " return _init_fnc(key, data=image, true_params=true_params)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "546577b1", + "metadata": {}, + "outputs": [], + "source": [ + "seed = 42 \n", + "n_gals: int = 100\n", + "n_samples_per_gal: int = 300\n", + "sigma_e_int: float = 0.3\n", + "g1: float = 0.02\n", + "g2: float = 0.0\n", + "slen: int = 63\n", + "fft_size: int = 256\n", + "background: float = 1.0\n", + "\n", + "_params_order = ('lf', 'lhlr', 'dx', 'dy', 'e1', 'e2',)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "39c6b72c", + "metadata": {}, + "outputs": [], + "source": [ + "rng_key = random.key(seed)\n", + "pkey, nkey, gkey = random.split(rng_key, 3)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "ab603d99", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# galaxy parameters from prior\n", + "galaxy_params = sample_galaxy_params_skew(\n", + " pkey, n=n_gals, g1=g1, g2=g2, **DEFAULT_HYPERPARAMS\n", + ")\n", + "assert galaxy_params[\"x\"].shape == (n_gals,)\n", + "assert galaxy_params[\"e1\"].shape == (n_gals,)\n", + "\n", + "# now get corresponding target images\n", + "draw_params = {**galaxy_params}\n", + "draw_params[\"f\"] = 10 ** draw_params.pop(\"lf\")\n", + "draw_params[\"hlr\"] = 10 ** draw_params.pop(\"lhlr\")\n", + "target_images = get_target_images(\n", + " nkey, draw_params, background=background, slen=slen, draw_type=\"exponential\"\n", + ")\n", + "assert target_images.shape == (n_gals, slen, slen)\n", + "\n", + "# interim samples are on 'sheared ellipticity'\n", + "true_params = vmap(get_true_params_from_galaxy_params)(galaxy_params)\n", + "true_params[\"dx\"] = jnp.zeros_like(true_params[\"x\"])\n", + "true_params[\"dy\"] = jnp.zeros_like(true_params[\"y\"])\n", + "fixed_params = {\n", + " \"x\": true_params.pop(\"x\"),\n", + " \"y\": true_params.pop(\"y\"),\n", + "}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "ac99423f-c14f-4ccb-92f4-ef17e83602c0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100,)" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "true_params['e1'].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "fa1aaccc-1c83-465a-ab79-75f40a8adb2c", + "metadata": {}, + "outputs": [], + "source": [ + "from bpd.prior import ellip_prior_e1e2\n", + "from jax.scipy import stats\n", + "\n", + "\n", + "\n", + "def logprior_flat(\n", + " x: Array,\n", + " *,\n", + " sigma_e: float,\n", + " sigma_x: float = 0.5, # pixels\n", + " flux_bds: tuple = (-1.0, 9.0),\n", + " hlr_bds: tuple = (-2.0, 1.0),\n", + "):\n", + " assert x.shape == (6,)\n", + " prior = jnp.array(0.0)\n", + " lf, lhlr, dx, dy, e1, e2 = x\n", + "\n", + " f1, f2 = flux_bds\n", + " prior += stats.uniform.logpdf(lf, f1, f2 - f1)\n", + "\n", + " h1, h2 = hlr_bds\n", + " prior += stats.uniform.logpdf(lhlr, h1, h2 - h1)\n", + "\n", + " prior += stats.norm.logpdf(dx, loc=0.0, scale=sigma_x)\n", + " prior += stats.norm.logpdf(dy, loc=0.0, scale=sigma_x)\n", + "\n", + " e1e2 = jnp.stack((e1, e2), axis=-1)\n", + " prior += jnp.log(ellip_prior_e1e2(e1e2, sigma=sigma_e))\n", + "\n", + " return prior" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "63060261-7298-45c2-b612-61d27978f64f", + "metadata": {}, + "outputs": [], + "source": [ + "def gaussian_image_loglikelihood_flat(\n", + " x:Array,\n", + " data: Array,\n", + " fixed_params: dict[str, Array],\n", + " *,\n", + " draw_fnc,\n", + " background: float,\n", + "):\n", + " assert x.shape == (6,)\n", + " assert data.ndim == 2\n", + " _draw_params = {}\n", + " lf, lhlr, dx, dy, e1, e2 = x\n", + "\n", + " _draw_params[\"x\"] = dx + fixed_params[\"x\"]\n", + " _draw_params[\"y\"] = dy + fixed_params[\"y\"]\n", + " _draw_params[\"f\"] = 10 ** lf\n", + " _draw_params[\"hlr\"] = 10 ** lhlr\n", + " _draw_params[\"e1\"] = e1\n", + " _draw_params[\"e2\"] = e2\n", + " model = draw_fnc(**_draw_params)\n", + " likelihood_pp = stats.norm.logpdf(data, loc=model, scale=jnp.sqrt(background))\n", + " return jnp.sum(likelihood_pp)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "84d24d15", + "metadata": {}, + "outputs": [], + "source": [ + "# setup prior and likelihood\n", + "_logprior = partial(\n", + " logprior_flat,\n", + " sigma_e=sigma_e_int,\n", + ")\n", + "_draw_fnc = partial(draw_exponential, slen=slen, fft_size=fft_size)\n", + "_loglikelihood = partial(\n", + " gaussian_image_loglikelihood_flat,\n", + " draw_fnc=_draw_fnc,\n", + " background=background,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "9acfa903-3bf5-4141-973e-b290df5029f6", + "metadata": {}, + "outputs": [], + "source": [ + "def my_logtarget(x:Array, *, data, fixed_params, logprior, loglikelihood):\n", + " return logprior(x) + loglikelihood(x, data, fixed_params)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "ebb3879e", + "metadata": {}, + "outputs": [], + "source": [ + "def run_ensemble_hmc(rng_key, data, init_positions, fixed_params, *, logprior, loglikelihood):\n", + "\n", + " _logtarget = partial(my_logtarget, data=data, fixed_params=fixed_params, logprior=logprior, loglikelihood=loglikelihood)\n", + " chain, acc, loglike = ensemble_hmc(rng_key, _logtarget, n_dims=6, n_samples=1000, params_init=init_positions, verbose=False)\n", + "\n", + " return chain, acc, loglike\n", + "\n", + "_pipe = partial(run_ensemble_hmc, logprior=_logprior, loglikelihood=_loglikelihood)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "6cf952d8", + "metadata": {}, + "outputs": [], + "source": [ + "n_dims = 6 # number of parameters\n", + "n_walkers = max(2 * n_dims, 10)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "275676e4", + "metadata": {}, + "outputs": [], + "source": [ + "init_key, run_key = random.split(gkey)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "90b67c94-2bea-49ac-98ec-2eafcedf0a80", + "metadata": {}, + "outputs": [], + "source": [ + "# vmap(initialize_params)(random.split(init_key, (n_gals,)), target_images, true_params)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "e70bbb19", + "metadata": {}, + "outputs": [], + "source": [ + "_init_keys = random.split(init_key, (n_gals, n_walkers))\n", + "_init_vectorized = vmap(vmap(initialize_params, in_axes=(0,None, None)))\n", + "init_params = _init_vectorized(_init_keys, target_images, true_params)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "851989c0-74c9-4589-abae-381a748271c5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((100, 12), ('lf', 'lhlr', 'dx', 'dy', 'e1', 'e2'))" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "init_params['e1'].shape, _params_order" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "7a969721-a135-4ff4-80fb-68d2f5679090", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array([2.65042952, 2.66264912, 2.66067957, 2.66793352, 2.66521762,\n", + " 2.66102399, 2.65600139, 2.66755406, 2.66321783, 2.66436271,\n", + " 2.66428985, 2.65486975], dtype=float64)" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "init_params['lf'][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "afbb90a0-3902-45df-a5d2-f2b4c2b4b577", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((100, 12, 6), {CudaDevice(id=0)})" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# convert to array in the correct order\n", + "_init_params_array = np.zeros((n_gals, n_walkers, 6))\n", + "for ii, k in enumerate(_params_order):\n", + " _init_params_array[..., ii] = init_params[k]\n", + " \n", + "_init_params_array = jnp.array(_init_params_array)\n", + "_init_params_array.shape, _init_params_array.devices()" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "e6bbeb94-d5f9-452d-b561-58f9045fe09d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100,)" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "run_keys = random.split(run_key, n_gals)\n", + "run_keys.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "ed45a1a7-e5ad-4bde-a1c4-f66015f212b1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100,)" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fixed_params['x'].shape" + ] + }, + { + "cell_type": "markdown", + "id": "f4c925da-1c7f-4756-a2bc-7637e8177cb6", + "metadata": {}, + "source": [ + "# Sanity check and jit one example" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "415e6644-fc59-4c22-8e3d-8245778d7b58", + "metadata": {}, + "outputs": [], + "source": [ + "pipe = jit(_pipe)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "426d447a-e981-46e5-ade7-c8d569852a94", + "metadata": {}, + "outputs": [], + "source": [ + "samples, _, _ = pipe(run_keys[0],\n", + " target_images[0],\n", + " _init_params_array[0],\n", + " {k:v[0] for k,v in fixed_params.items()},\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "ae66f465-e032-4a40-9846-0916eb4b8531", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1000, 12, 6)" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "samples.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "6344be98-b815-43de-bf07-0ec6d561ea9c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for ii in range(12):\n", + "\n", + " plt.plot(samples[:,ii, 0])\n", + "plt.axhline(true_params['lf'][0], c='r', ls='--')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "8a4bff81-258f-47ee-b563-d287ca8d2100", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for ii in range(12):\n", + " plt.plot(samples[:,ii, 1])\n", + "plt.axhline(true_params['lhlr'][0], c='r', ls='--')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "b995494f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGdCAYAAADuR1K7AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsfXe8HkW9/jO7bzklvRcCofcmIIIglggo1y5XUX8o94pXFL2IFQt4FaWKlaIUKaKEJgJCQENCDUlICOm9l9N7ecvuzO+Pbd+Znd13z8k5STjZ52PkPVtmZ3dnZ555vmWYEEIgRYoUKVKkSJFiiMDY2xVIkSJFihQpUqQYSKTkJkWKFClSpEgxpJCSmxQpUqRIkSLFkEJKblKkSJEiRYoUQwopuUmRIkWKFClSDCmk5CZFihQpUqRIMaSQkpsUKVKkSJEixZBCSm5SpEiRIkWKFEMKmb1dgb0Bzjl27tyJ4cOHgzG2t6uTIkWKFClSpEgAIQQ6OzsxZcoUGEa0PrNfkpudO3di2rRpe7saKVKkSJEiRYp+YNu2bTjggAMi9++X5Gb48OEAnIczYsSIvVybFClSpEiRIkUSdHR0YNq0af44HoX9ktx4pqgRI0ak5CZFihQpUqR4m6GSS0nqUJwiRYoUKVKkGFJIyU2KFClSpEiRYkghJTcpUqRIkSJFiiGFlNykSJEiRYoUKYYUUnKTIkWKFClSpBhSSMlNihQpUqRIkWJIISU3KVKkSJEiRYohhZTcpEiRIkWKFCmGFFJykyJFihQpUqQYUkjJTYoUKVKkSJFiSCElNylSpEiRIkWKIYWU3KRIkSJFihQphhRScpMiRYohi+bmZrz66qsolUp7uyopUqTYg9gvVwVPkSLF/oE//OEPEEKgo6MDH/rQh/Z2dVKkSLGHkCo3KVKkGLIQQgAAtm7dupdrkiJFij2JlNykSJFiyMMjOSlSpNg/kJKbFClSDHlwzvd2FVKkSLEHkZKbFClSDHmkyk2KFPsXUnKTIkWKFClSpBhSSMlNihQphjxS5SZFiv0LKblJkSLFkEdKblKk2L+QkpsUKVIMeaTkJkWK/QspuUmRIsWQR0puUqTYv5CSmxQpUgx5pOQmRYr9Cym5SZEixZCHSm7ae8qweUp4UqQYqkjJTYoUKYY8KLlZ39CJE3/2PD5/1+t7sUYpUqQYTKTkJkWKFEMelNw8/MZ2AMDrG1v2VnVSpEgxyEjJTYoUKYY8KLlhe7EeKVKk2DNIyU2KFCmGPFKH4hQp9i+k5CZFihRDHim5SZFi/0JKblKkSDHkkZKbFCn2L+wRcnPrrbdi+vTpqKqqwumnn44FCxZEHnvnnXfi7LPPxujRozF69GjMmDEjdPyXvvQlMMakf+eff/5g30aKFG9bLNnWho/+4RUs2LR/OtFK5CZ1ukmRYshj0MnNzJkzceWVV+Kaa67B4sWLceKJJ+K8885DQ0OD9vi5c+fioosuwpw5czBv3jxMmzYN5557Lnbs2CEdd/7552PXrl3+v7/97W+DfSspUrxtcdGfXsfS7e34zz/O29tV2StIlZsUKfYvDDq5ueWWW3DppZfikksuwTHHHIM77rgDNTU1uOeee7THP/jgg/ja176Gk046CUcddRTuuusucM4xe/Zs6bh8Po9Jkyb5/0aPHj3Yt5IixdsWvWV7b1dhryIlNylS7F8YVHJTKpWwaNEizJgxI7igYWDGjBmYNy/ZDLKnpwflchljxoyRts+dOxcTJkzAkUceicsuuwzNzc0DWvcUKVIMHaTkJkWK/QuZwSy8qakJtm1j4sSJ0vaJEydi9erVicr4/ve/jylTpkgE6fzzz8cnP/lJHHzwwdiwYQN++MMf4kMf+hDmzZsH0zRDZRSLRRSLRf/vjo6Oft5RihQp3o6Q89ykTjcpUgx1DCq52V1cf/31eOihhzB37lxUVVX52z/72c/6v48//niccMIJOPTQQzF37lx84AMfCJVz3XXX4f/+7//2SJ1TpEix7yFVblKk2L8wqGapcePGwTRN1NfXS9vr6+sxadKk2HNvvvlmXH/99Xj++edxwgknxB57yCGHYNy4cVi/fr12/1VXXYX29nb/37Zt2/p2IylSpHhbIyU3KVLsXxhUcpPL5XDKKadIzsCec/AZZ5wRed6NN96In//855g1axZOPfXUitfZvn07mpubMXnyZO3+fD6PESNGSP9SpEix/0AyS6VWqRQphjwGPVrqyiuvxJ133on77rsPq1atwmWXXYbu7m5ccsklAICLL74YV111lX/8DTfcgJ/85Ce45557MH36dNTV1aGurg5dXV0AgK6uLnz3u9/F66+/js2bN2P27Nn42Mc+hsMOOwznnXfeYN9OihQp3oZIlZsUKfYvDLrPzWc+8xk0Njbi6quvRl1dHU466STMmjXLdzLeunUrDCPgWLfffjtKpRI+/elPS+Vcc801+OlPfwrTNLF06VLcd999aGtrw5QpU3Duuefi5z//OfL5/GDfTooUKVKkSJFiH8cecSi+/PLLcfnll2v3zZ07V/p78+bNsWVVV1fjueeeG6CapUiRYn9DapVKkWLoI11bKkWK/QCpn0mA9FmkSDH0kZKbFCn2AxjpiJ4iRYr9CCm5SZFiP0BKbVKkSLE/ISU3KVLsB0iFmxQpUuxPSMlNihT7AVjKbnykyy+kSDH0kZKbFCn2A6TDeYoUKfYnpOQmRYr9AKlwkyJFiv0JKblJkWI/QBotFYA+ijRzcYoUQxMpuUmRYj9ASm304Cm3SZFiSCIlNylS7AdIHYr12NnWu7erkCJFikFASm5SpNgPkHIbPT7wqxf3dhVSpEgxCEjJTYoU+wFSbhOAPouSzfdaPVKkGKq45Y1bcP5j52Pm6pl7rQ4puUmRYj9AapZKkSLFnkJLoQU7unags9y51+qQkpsU+xx6SzZum7se6+r33ocx1JBymxQpUuxp7M2EmSm5GQwsfgC4/d1A29a9XZO3JX4zey1unLUGH/z1S3u7KkMGaSh4ihQp9hQE9n4YYkpuBgNPXg7ULwee++HersnbEm9uadvbVRhySKkNQUr0UqTYI9ib5vCU3AwmSt17uwZvS+wLrH+oIR3PU6RIsaeRmqWGLPadEWX9wtfx6C9+gq7WFn9bz5IGNN65FHZXaS/WLMWeQOpQnCJFiv6iubkZy5YtS5zRe1/I/J2Sm/0E/7j5WmxZ+ibm3nenv63loTUobmhH+6zNe69iGuwD38WQg5FymxQpUvQTv//97/HYY49hxYoVfTovVW6GKgZotiw4R/eCBbC7dt/M1dsVjkDiPdZul5ti38be7GT2NewLs8r9AesWvIZ5j/4tfd5DCNu3b0903L7gWpCSm0HFwAworX/7G7Ze/EVs/e//2u2y3g7mib3/WQw9pItFBuD7+f3vKTz5q1/itUcexOYli/Z2VVIMEJKOHx65SR2KhyoG6MW2/+NJAEDhraW7XZZhmuGN+1hnv78PvoMB2hLt/Wi1SNq5cu5kI96Pbn+fwMsP3Y9iTxpcMRTwdpgce0jJzaAipiH0YQA38vkBqIsDZmheedrZ7xcwYcMA369eN+2MPdKccuc9i8bNG/H0b2/c29VIsQexL0xQU3KzN2AVgT+cBjz8xUSHs+qqAbu0oSU3e78hphhkCI7P5xfjs/klsPn+s56STrnZFzre/Q2paWpooM9mqdSheIgiqiFsnAs0rwNWPpGoGKO6BgBQzmSwdu1aWFb/HYANI2yW2tf6+n2sOkMC1aIIgwE5ZsOy7L1dnT0GnXKT+tykSLFnkPrc7G9gfXvsRpWj3Lz27jPx17/+Ff/+979349L7jnLDhV5BSMeegQd9pPvT843zuWHgmGK0o1gs7o2qpUjxtkNisrIP9DEpuRlURDSEPrJZzyxVN3kyAGDRov5LvFpysxfw9ManccZfz8C8nfP2dlX2C9DQzChSORQR53NzcmYnzs2txUMzZ+6NqqVIMeSRmqX2O/TthRtV1QN35X3Eofiql69Cj9WDr8/++r5QnRAsqxObNv0Bra0L9nZVBhxptJRz/0eZDQCATRs37vmKpUjxNkQaCp7CQdSL7aNZamAdivetUHBbaPw/9gG7SX3DM9i46ddY/OZFsKxw4sP+gvf2Ytc1P0XXK68OWJlJQB8p348ciikC5cZzdkzezkSZo7ilA2I/IoZxeGzRdtz83JrUOXs/Q1/Jzd5ESm4GGpwO1gnMUgkGGpbN7l6daFn7iHLjYV81kdh2j/+7XO4YsHKb77wLbTNnYtuXvzxgZSYBfcX7k0MtHXzDPjfJn0PzX1eh8fa30PnitgGt39sV337kLfxhznq8uLZxb1dlz8MqAc0b9nYtUlRASm4GGnY5+B3Jcmm62ASRK8pgtDtSny4UfF+bfe1btQGAgYsuKm3dOmBl9Rf7k3KjIzferLIvnV9hlbPgbNcrOwesbkMBK3YmJ/77Wj/TbzzwCeD37wDW/Wtv12SPI7Fysw+865TcDDR4ufIx1CzFEwyc9sANRkyboXjAih86IB+nSEJAE6Dt0UfR8fTTA1JWX0H7mqQ+N0+8uQM/fXIF+BAxxQSh4M7ffVFu/DLsofEsBgpbm3sqH+RhHxjwGhoacNttt2HlypX9L2TLK85/3/jzwFTqbYQ0z83+DDsJuembciMG0HSjT+I3YMUPCPaBPhD0oQwUudn1458MSDn9A1EwEpLlK2Yuwb2vbca/VtUPVqUGHVrlxvO56U+/O0SI3kBhZ3tv4mP3hdn8P/7xDzQ0NODhhx/e/cLeRksR7C2kDsVDCZwk2Iv6mFXlhvN4UjSAHeq+Egoeh33BGU0MArnZm5CUmz4OMq3dpQGuzd7BQCy/kDoUyyj3QVUeyElaf7E7CVBDSBgY0vHvLWh7et+MyBNC9CnPU7q21P4MSlJ41IekKDd3nAX86ihnWQYdFB+J3Wlg2nP3gRnVPgfSEQ8FcsMlM9veH2T2FPQOxbvR3i2Ocl26CGR/sC8Qw1wuN3CFJSA3Qgh0/Hsrul7ZAaulMHDXHiA8+eSTuO6667Bt28A6ygcRialyM3Rgk1luFLlRo6UaVqB3ezt2fvubKNfVhY8fSLPUPu5zU99RwPIdHRjX04ZD23b0u5xSoRe2lcBEGAlKBgZwtjdAKHOB763Zhmca2xIdLw/yfXvhxttotmbZHDvb9KYS1eemv6j/zeLdK2A/xUAqsquaV+HZTc/2+bw9TW5Aum4xgL6TA4U333wTAPDyyy8nOr6vE+u9SW4ye+3KQxWU0EQ6F7PQMZufHw/gJXBcjwN++xvp6L5+FCt3dmB4VQbTxtSEr7yPR0vN+NWLAIAHnr8WAFDafC5y06f3qYxiTw/+cMl/Yvi48fjKrf1z+pOXK9j3OqW/7GrG/Tudf3XvO6nyCUL4za7PSfzePtwGl97/BuasacRfv3w6zjxs3MArNykkRD1KbZ8ygMrNfz79nwCASbWTcPKEkxOfN7DkJsGHMcTaWprnRsGtt96K6dOno6qqCqeffjoWLIjO+nrnnXfi7LPPxujRozF69GjMmDEjdLwQAldffTUmT56M6upqzJgxA+vWrRvs20gGidxEmTPIi1dMUVa9xnmzD6G79R0FfPh3L+PsG+cEVyMf2L7uUNxZlFWS7vl9zxBct36tU1bTbuTgoGacAQwFHyjsKPTND0YyS/VxkHkbcRvMWeO883te3QxAb5bal9r72x26R9nxzDPoWRxWtwZjkrCxrW++LHtcuSHtbzD8VazWwoCY+wbLl2ZIOxTPnDkTV155Ja655hosXrwYJ554Is477zw0NDRoj587dy4uuugizJkzB/PmzcO0adNw7rnnYseOwERx44034ne/+x3uuOMOzJ8/H7W1tTjvvPNQKOwDNk1KbqKchOlHbsuDVMvBh+CTb67H0w1tweEiuc/NhsYuzeWC85kuQ/E+DKux7wRlYGYNlAzse+TGipkRlrZvR++y5dI2OsjbfRxk3k5OhB5KGrUzXRV88FFYswY7rvw2Nn/+C6F9g6EQm33szyi52e36sMrXli4xwJ9R96J61N2wEK2Prt3tspJ+42meG4JbbrkFl156KS655BIcc8wxuOOOO1BTU4N77rlHe/yDDz6Ir33tazjppJNw1FFH4a677gLnHLNnzwbgPLTf/OY3+PGPf4yPfexjOOGEE3D//fdj586deOKJJwb7diqDDhxRPjdS6EoJ3AoazC2nvgevtXXhyys2k3KSNZTeZcsx4qv/D6fVyTkcuB0MzlrlZh9w9ItCf8iNpLr0O2HdwCo3A/2xx0U8bZjxQWy+8EKUtm3z71/shnLzdkTJct5ZXIbiFAMA5VmWYxxTB4XcJCAYFJTclMu745OHZGYp2tgGeJLQMdtJCNqzWC8UDAZSs5SLUqmERYsWYcaMGcEFDQMzZszAvHnJVoPu6elBuVzGmDFjAACbNm1CXV2dVObIkSNx+umnR5ZZLBbR0dEh/Rs00Fl+lM8NJUBWUSI3rXnNOlIJlYNtX7sM5rbN+NnrMnHk5Py3Qyg4xe6SG9vuHzEZ6FBwURrYcOokueQ2fPBcf5mHvjoU0+PffroNULLCpPbVV531vFLlZvcgEWV1EHOVFKENyhz45270cZ2+TCZwM+1LCLQWicxS9Pjdu1z48gNXYBxp2Z2M5kPWLNXU1ATbtjFx4kRp+8SJE1GniwrS4Pvf/z6mTJnikxnvvL6Ued1112HkyJH+v2nTpvX1VpKDEpdSRPZO1SxFFzXUHp6scfG2dv12uwK52Qt9fVIvet7ThwyoLqR1lGwLXS+/gvYnn+xjIaSUASA3/bmPOEQpN+oA0v3avND2JGYp6nT8NrRKoaghN2vWrAGQutzsLmI5Cgv9CM4boGU/aFvuq1mKol/KjeibEiMGUbnBAJKbOIh++A0NeeVmd3H99dfjoYcewt///ndUVfV/ZeyrrroK7e3t/r+BjumXQAeOQhsAZ6YsDzqyQ7HUDMgfpe3bnR8JdXR1YPN9DCqYpfaGfTSpnNyvDpGqFJaNbZdeip3f+z5KEe/d5jZe2v4S2ouUHA6scsM7B25lcUBPgoFohUiabSd437Z4e5ObksUj73Nv+QNsX7kcK1+eU/nAfRxyziR5X6wyPEDP3SbfY4b1LeCXvvt+kRvqR7npZaC3rdIFg99vU+WmP+TG6z6HbJ6bcePGwTRN1CsRQPX19Zg0aVLsuTfffDOuv/56PP/88zjhhBP87d55fSkzn89jxIgR0r9BAzUh9bbBLtn42//Nx5O/XRJsFxxc1KBgnwhRLkuEhjLeTZ/6NHihEMpz4zWwjRs34re//S02bnQjBhQi4M2+JYKgTeKX/PYGClEzrv9EDn/HMLCa8QAA0Y+MovQZ2qVAerYjlK2/rPoLvj7767j42YtJGaS8CuSGc4Gnfr8Erz4aHbFXHOBoviiHYqFxqudcSF2MnYAwSsrN29AwVbKjyc3eWjd05v/9AM/+4Vdo3LJp71RggMCl/kqBS24qmaUaGxv77R5Qds39kxursOLnd2LDor5HVAL9JTdk8tC2Bfjzh+OPj5jTDgjMPa/cRKG9vR2LFy8OPdMhS25yuRxOOeUU3xkYgO8cfMYZZ0Sed+ONN+LnP/85Zs2ahVNPPVXad/DBB2PSpElSmR0dHZg/f35smXsMdCAUNnatqUNbfQ+2r24l2wUaSjeiqfwLdK/kkWYp3t6O8s5dkerF/fffj9bWVtx///3uCfJxXidEfW60s6e9MJONspV/E1UYDwP54y8EAIh++MxwKzjH6g6yybKIMNCnNzqLWW5sp2GlyZWbHWtasXVFC5b821GG6uvrsd1T3VwUVq5KVPekiCI3nPgRsNoJyB12HqyiJXUxm9euxuOPPx7bud84a01QztuP28QrN3tZMm9v3HMOoIOB2OcX44fivY/Ozk7ceuutuOWWW/p1fY/cnLdwIqzObjxx48/QVQpHicbVAdCTGy4Enm1sw86oVAtKdCsaVlS6IP0jUR0TYx9Sbu644w48+eSTePFFJ0+ZSLKA9CBj0M1SV155Je68807cd999WLVqFS677DJ0d3fjkksuAQBcfPHFuOqqq/zjb7jhBvzkJz/BPffcg+nTp6Ourg51dXXo6nIaL2MMV1xxBa699lo8+eSTWLZsGS6++GJMmTIFH//4xwf7dipDcf4ttgezE7+RCAFLTAcA9GzIgOqVan9s1df1e1VwTz7eFzNjVpKTmWu26g+5sYnaY/UG2WpZLqs9vqwL2e/DquBc8e69/fbbcdddd6GbECu7rS22jL4iylJJzVK177sa+eM+hc7nt0grYC9fPB9Lly7FG2+8EVn+va9tHqiq7jGIGHMJxUBES+2Waett7tAsuaOp9+L1OTqfG1eBbiRBAk1/Xo6et/oWNNDUNAfjMnKfdt2C6xKdW4ncPF7fikuWb8Yp8yJWDVfJTaXrSbPVgX3v+5JDca/bz27YsAFY8Xdg/b8rljvYGHRy85nPfAY333wzrr76apx00klYsmQJZs2a5TsEb926Fbt27fKPv/3221EqlfDpT38akydP9v/dfPPN/jHf+9738I1vfANf+cpXcNppp6GrqwuzZs3aLb+cAYPwQm+dP0udwYwi+K5k/weps1CKK9fXh8xSSeGRG+pzo/289iGzlA/3oxCWhbJdxh1v3YHlTcvjz3HBybILNnXkde+zt7MDr858AK27dmBp41JsaN8QKkMQDa2izw35fml0Vif1sxngAS2JWYplHKWqtL5Ne2xPQifnfTbPzbp/ATP/H9DlDI5lQjJNg4UGXq/P6RcxUR/BPh5PXty4ER3PPz8oZUs+N8o+YbsTC12T0TyywppWtPxtdeJrt7S8ik2rr8SPJxckBem1na8lOr8SuXmptTOqqg76SG6k7/7Jb/Tt3ErYQx6zscpNsQtY/ABqQJY82fyq//zYXswRtkeWX7j88stx+eWXa/fNnTtX+nvz5s0Vy2OM4Wc/+xl+9rOfDUDtBhjCxpvdH8Xirk/ik2N/hFJnN9klHCmRkhUhYqOlrLr6UF6SpINNUrPUPu1QbNl4cNWDuHXJrbh1ya1Y9sVlFc+JUm685z7n3j9h1Stz8cY/n8B9H4zyf0iu3NC3USoGnZ9J1vEa6OysUdFSXBPeKiyuHWu0OY90Ze6rA/mDn3b+Wz0K+OjvpcR9ulvz3ke/bsdgUvy9sEWSHG7B8XHh04OAjR++AABg3nM3as88c0DLju0uXHKvO2QgvoHW1iDdh20IZLjTsjNGsqGsErmp6CNi9ZHc0Ma28UXn4Q3QZGGfcCj+57eBpQ/hC5iAP+Hz7n7Swvciudmno6XeluAcr3VegoIYiVc6LkGx1/vYOWY9N8uR7aREf/IHr3YKvLe33x6QnlOoTT5iLZHZJ5Ub1zHRtrGurW/OuJTc2L1EnXCfY90GpzyrWPTt9yrKZIbWF+WmSMiN1BEMMEGIynMjiuHOV9gCjIVPSExu9nUziqvc0Nw2JgsrN97f/SHzoYFEeZ+VHN8lv7k+toXGUhkbe/qXk0XNVD0QiGsPohz9HHTJI/tK9Cw7mCxy0nz7mswP0JObinyhz8oN/YMN7GBv7pnhO/Z7WfE4AGAKHD8yxpicuXkv9h0puRlokIGQMYFS0Xm5vbXbsfCNBXjggQdQLklG63gbNrcTmaUW1i0MV8UtyyqVsLb2UDwy+RNoKg68iaFcLvc50VPizmg3fW7sQqDceJ1rVe2wimXM3zU/OK9ChmJvttedZ/jSup1YP36qcx59lwMcohOZ56aoWYJEk/MFSE5uKi60WeoBVv4DKAxicsw45JwFYim5UWt8Gt7C+1v/CthW/5UbAkHYZe9bb2HNye9A85/vjTzdtvu/svzxr67AmfNXRTu5xmEQZs5c7r4keGYpvXKz++TGtogfmxGcmzX0/nRxddArN5UqEP8OtnVsww9f/iHWt64PXS/J+X3BQFqLkyo3icoxzMAsFZm0YvCRkpuBBiEiDAK25aonZjDorFxGH7sA/aTK7XK4srB5Iofg/3ruv0LbvE6oXCziuQnnoq5qEu7ZpOkEdkNVKBaLuO666/DHP/6xT+dVJjeuz02/oqWIzw0NjXY7+vywyuRme2eQEyepcjP3+Gq83l3Ev485zbmcRGicZzzsve8FAGSnTKlYhzgkiZbyr2xxyaHYw4ApN89+F3j4YuCRL/qbGkvlPWfuzFYDkMmNZcu5pS7ACzi8sARY+UT/lKgY5WbXj38CUS6j4YYbIk8Xkt9b/57L4o5+JLQchLh32cSmwLtPbcqJ8H3z3VJugnMHzixVAVHrBbr45pxv4qmNTwVpJVTlZgDJzd6IltKcqSmHpWapIQnpZarJ+xxI43XHLukDEGojs+3QrD+pz40347bKwYDXpZtA7sYYtGXLFnDOQ3mHKqGyWcr5j+B2n3MlSD43hNx4HT1VbnJG1CrByX1uvOr15ILPacH0oyVy412bZbNu6bs38EdGS2nMUrB1sSt9ITcVDnjzL85/N7wAAHiyoQ3Hv7oCP1q3I+ak3QPnAs+0/gALu/4TyNYCAIokBYDNI0LBO3bg2N43kIH8IVRSHpkZrdwkIeDcVvzs+oHe/hCVQfCXiqu+sCr73ND+q6+1sym5IabWxD58FciNUalvtePNg+vbHMWms+wGE0jPn1UkR33BQPrcxEHqxyq0XcZkn1I2CCvBJ0VKbgYa1CyFiA6WbOsyTDwqKQlKJ8p5vxzxmJDNUips6SPdFx2K3aZp7Z5ZikvKjUBTVxF3tB2MDTUHAwBqzGptGRL5qERu3EPpm1t80JHYTM0IXifnORnv5iO3IwoQJU3nu5vkpqJZSsEvNuwEANyzo6lP5/UF25Y3YlPxdCzoushXbuiSC8Vyt/7Ef12NHzT9EFdkHpM2VyI35jCFBFOykojcBG2yv4JWc1eyXC4SBmFw4bIdXb6cFT14D4RZyrKCZyD53CRchmGwzVJq/i45EnaAlZt9IYkf0yg3MT6lexIpuRlo0EUqISJWYA5e+PZMBg+OGB7sCcnfvM+zr3KmGpd1VGHBw4HjrF+cAHbtehxzXzwG7ZOd8Mmwm8/gN0jaCdg66dJ7DLbd51BkOpBQ5QaC47pnVmNZTzWemXg+AGC40JObvig3UdFEBc1s3U9Pv5sffWQoeORigP03Sz3X2I5btzagtHkz1r3//Wj5y4Oxx+f2wIzSLpAoxIzjc0NJmBWl3Lj4nDlb+rsSuTFqZLMH/a6TmH5oOgavfXa/2YDWx9clXqW9saPv5GYwzFK0uqGqe9FSmiag8zvqq1nKtoNnYA+AWapUKuHFF19MrjxXUF5C+bvUB9QPctNTsrByZ0e4Pe8Fs1SflZvU52YIQQqb4xU7LqYYXVSzlOB2n51qd016F2oFw5Y3nCgSVblZueq7AIC64/8k1dm2e/DCcx/BI7d9H+2NvUiC/vpV0M5IH7Hk+tyUy7tllpJ8UDhHc7c8+FcjHzp/Z9dOWNJMO/75+yYK5VkwadrmfuQmMPaYTuSHRSgLCRFploogpruj3LzQ3IGfb9iJnTf/CtbOXai/9trY4/N7YOV5ww7aJxduwkeyn/P4NmMyG9MPXgRvotHnlY8ls1RlZ2GZ3Di/W2euQfeCOvQujU5iR7+vYn8+tUGYqFC1RfVfEr7SGn7+P3jpB84xuxEWz0lfQX1uqrv6PtCXy2XMnTsXc+bMwe233w5g95WbkIIUcijuu1nqP/84Dx/+3cv49yo5s/VAm6WiFFp/jUIRjkDU+tyIgLKmZqmhBMUspe0zKQECA43SDRkQ7P6ZpSgsYqpY22Wi11KSHbrX37FzJkR2JcYd+zgWz9q8W9esBGqWsnjM4KCRuec0d2Buw1bM2TpH79NEzrF6yAyfh/O9GMqj3dC2Aec9dh7KPHkouKfchMom780jucOyKzHhhE4ceNra2DIrIUq56YsZIim58XuqhJ1pdg8k/WO9zf5vL/qQDrS2YJg5c2bk+dWZAqZNW4lJkx0fiUrkJhRWTmPxExAISm5sJWzc7o4e8GjJmji4yhiEwUVIt66Sm+hveW3rWvf8/pMbCqrcTJuXzNlaVW527JD9wiqqxFa8z01IQVIdivuxLMHyHU4U4syFysK/5HvcXef91za04Jyb5qBQDvd1Qgi08mo8UDwFD61M8JwFD5S71KF4CCGRWUqGQcmN8m0JbvfZLKV+nmXFVPH8lvdqzyuXW/t0nd0BneFoyY1ntlLs4mu7C7ho6UZ8dkULvjnnm3hh2wuhUzl1KKaL83Ee6rxUpWPOtjmh8ioqNxHvx9CEgmfMgXnGap6bNxvexOqW1ZFmCF20VHK451bVJDo6vwfMUqIpyCpdcskNfdwFK4NVG7dWLKcq75g5rEoLtKqPj5qlYpRVIQR+P3sd5qxvIfUtSZms40BD/gv9cA5OavLqC+JWBYcXCq5pAt4kbqDIDfW5yRSSlVPRobhSARWUFzUkXSYdu+dzU1T8DyXlZjff8/bWHmxv7cVrG8J+cpxzLLIOgADDP9bFU+yQz02q3AwhKKHgen8MWbmRo6WUV8JFv6OlPFhl+YMqWoopxl+moe9zw/7OGKipyRLhgcXfa8mLPq7vkeuoy+9DZ8ZlsgSCduBXyI1XL/qIEys3qu+Se715j/0NrzRtd4L+YxYW7AuoctPY04iLn70YFz51YdDJkesIFpENP+m78w6rTra8yZ7wubFadvq/y2WP3Mj381DxHSiIZFF5FcmNAkFzB8UQldc2NONX/1qLbz292TnPMPD0/EX47W9/SwqLvk6ZtM9+pfHrRyqFSpA4e6RZKhpUJeurzw3t+6hyw2v651As9aVt21BbqDD50JETUmZln5v+R0uFVBWq3ERl9UwIz2KQz4SfY38cilOz1FCEGi1VwSwFxCs3sO2KZinTLMGQGJJcvupzo2arLeZ3gfMybN6/LKj9Af1gPOVG+ojIR2PGfLhc82ykJH50fScuQpYVqtwcOvJQv7OT/KCUJH6lLVtQrg/s31GzY68Tf+3hB7G90IXG4TVh8tpPlMmzqusJnCGfz9fiN5+9BHaGEFjGtMpNYj8Tb8ZdHeV8LSM3yD437T1lNPSSQcpt3rrX0Mgr5TRyTuqrctP2VKAcxTntNnXJ35Ttql8dVFGMgUWU4FJSLiqF7g5utJSaTDIuiZ9WudFkzk4KqvqI6t3Lc1ONXuA3x+FHj58VX4CO3HAbJc6xtbdY2Sy1G8pNoaxMxAZQufGQz4S/3Shys7OtFwVVTWIMECJwr0jNUkMI1CzFeLB4pXQQUW6EPONXBz/BeaxNP5vtxZnvnomzprwHP/j691DIhvO2WLrwYBedExdg46nfxdzXv4RymTgRD7LfBO2YPIdirnYELoyIDLuA/sOTzFI0fJbbUDUMZpHZH6jqRq8RvFOrtRUbzjsf6885JzgvomOxlO22wSRFZXcglx3U9opx0/GPc87FrHe9J9gdcck+q27VgVkq7tzcILedE3/2PD5XfxIK7odTLjvX4xrzpn5VrQDeXp2JIg5GLTE/xBAjOhO2YUhO5klMMlS5SfxUqVoz8FYpJaO6ss/yyE24tp4qKuVN2Y16lLLkWVb1fZlEqtxMQHOFo1145OTID0vbPrZ4Pd75+ir05g6Tjx9As1SschPTR/YFuT6Qm588sVwamrK5njTPzZCGYpYSHHgjb+EeNhUN3iySNJasZSjRUkp5bhI/a7RATU1b6HKjxzjy/GOZr2D+cSfjqbM/EDrGKskdN53Ftx7oLE0vCq9j4aZgdfbBWhOEcwsNjc8hI4jTrzso2REDNotRbnQDhB1BbnQKi1kiUSyCw3A/iShyU9oQzNiLmzZh40c+gu7FS0LnABHKyCAoN0Lj4NA6crR8Wc1zSm6Wco8jZimhyZ3kIT+Ajo5xaHa9wT3/cUszcFQiNx4qKzfOfVQdM9b5myaii1Fu6Ey4ZGSl78pOECZLv4mknFHyARoEsxRVbkLZnr2ZvNYO6rQH2ib6apaSLmVWTi63efNm3HzzzVi1alXouFJMG44s02tjudpgGy/jzU7H0bYlf2pQP24pyv3uJfFTVRK5XrtrlorZF/FsW3rk53f00S+l5GZIQ4nxFxyYU12GxQzMLx/oHeQfM6yQjY2WEsLJ19HwizJOOfUp5HLdsp1YaXc91WGnT1WapmYpxoMZT3VX38OT+5IDAQCammdj2bKv4XPVS+CbBFxyI3WU5BbjGqnOLEXz3NjKquDqAPH+eSTjqQgcjqfvCp7jjtYubGh0SBL1Kaj7ydUorluP1kcedcuXy7YFl1dkB8lzA+DuVzbF3Fk8JHKjG/UoieL6JH599bkRVQG54T3RURPULEXriY5dQPvAZS32Si65yo3OrMojWo/6PJKapfxMxfS+3HNZLmwCo226ZOSk85IM7GXSfvRvUVNV0kYHwywV63MTQ6YYAFvYinLT/0FZehoR6vYDDzyArq4uP3IuyiwlkX8vNYauah45yZJ+lvQ3jESB9lq94UnibpqlLKsLjY3/dpKw0j6ApibgHFv/67+x6ydXJy7ba1u6cHDdJK29t4w3t7ZJbXLkyMaQz01qlhpKUKKlaFuxciZeOuwErCoo+Qoks1TQWLrfYzsfLWlcI0ZE58RwCtB0F8oG+iFTcjPGJB183DSxaT3QG3a8SzJYdnU6M6gs4xhpyuQmSrmJ6/8q+dxwaWXu8Dz+yE3kWFJWVclECY7p4bnlO/GBX73oVIWW7RIn4XZoOuWGK7MtgaDz+/nTK7B0e5v+xiqgTKN1tKEpRPniwDkIy/ZJfW789knK5N3RRJgqN73eoGNbwC1HAb8+Bpj1w0TXTQruduy2TrnRPRsKlsznxn/amuIE58gedBaGffgWdMyVw3WpWamkLPXhKzcx7dvqT54aOqAMcrSU2oS8DMVRPjcWtwaM3MiDu/45qVFpsQ7FLgz3vWjTLXih4Jkq+Ktfk3ZHB3uH3KgV2j2H4hUrvoWly/4H69b/QtpHzVK9S95C92uvoe2RR/p8Dd26a7p+/T9+/7L2/FS5GcoIORQHDaNl1GisnHoI7soqDr7kNycz7vbP2m4oeNBAcrn45HpMCNihFOByA+uxavDi9jPRXa4G44HvQN4IPrx1C+vR06GZZTStA/5wCnDzEbH1WLKtDdtbw7P7XG6c/9sbbj2fG8mPhNwDdbiWHX31oHlu6NgmeFi5oeSHkps/Tr8Cl7CH0I4RMBiZCdO8O+65UU7CXMh1oecAwDnGUqyr70dKfcgdr63pQFQ/zXOQQROvwUulQ9AlnEE2ucnIJQ/k/fDuaOWmsTNQUPzw5TI5/vVbE143Sa0Cc6NeuRlYs5T//uijs21UnewslNhB8kMJIaQlISLJTQzK5NuPWgk+VFU6oA/yquDRZindc2ewhT1goeBMmbhUQtP2LvR0BG3EsiztN2C631NR9cOa/ydg8yvuQVnnHyDlrqHF9Vq9yr1WNktZLQV0Ldil9aEpljmamp3UFzt2PCi1QXq8KPYrIxIAvQCme0bbWtyJXYUkfqlyM5SgOhTTkH93YcViroYcoyTxC/nccMmmX5HcQCZIgouQNDpn29m4f+VnceeyiyXlBmbw4ZWLNh6/aVH4AptedOvlEB/Jfu46vG1s7MLHb30VZ90wJ3Q67cy8vsk3S7m95hyUcWN1NcqeIkJVCuVuK/nchJUb+QFHkZvVw48DACzAGTBYhbDfKHLDuVQXweRjj2RbUdehdETlAvDHc4BZV2nL9FCiM1BdqLpmcHm6dCw28rF4qXSIU58+mqWk/CYxHegrJFdG1eI/A5teRlS+i9a6nXj5r/eip73N31a2Ob7+4GLc9fLG+Gr5icKcsrXKTUWH4njlpswFnm9qR4f72pL6vVz96tW44O8XoLMYfK8lppAbVnlAtiRyk+za1ME5SWh23xHtc+MRq6TKze743NBgoSSh0DOvXYBtq1qkbZ5piqrZHrm5+de/DvxyhACe/S6w7XX3oJzzD5AIC13zrdfqVZSzyg7Fdb96A22Pr0fnS9tD+0oK85CIEyU3CZ3jdY7dUcqNZLbrasAI6CdlqXIzhEGJCINAgfYtWf1MX0r2FpIWeKRyE5XvxiY+D1xnpnKxrOlYmdwoR2qXYIgZEDtfdCT51XWdkcfouj3fLOWW/RP04p/5PGYfeAqAsArhwbRNiK7wbF0mFLLjp/fnO9haXDR9CYaPCgZpLsLkx0YGhkGVG00GT/d9qvW0OVdUJAaQd2NCoEElN6ufBnYtAV6/LXQdCqpylSNmR5uMevwjtxAdrEcKuW0Xju/M3+Zv0SbtCsHzuaFEthBNbrx2+c72pRj53HeB+/4D+uEO+OuPvo0F/3gUz956i7/tySU78c9lu3DtP1dVrhsCZbJshdtrUuUmKlrq11vqcPGyTfif6c7fXW2t3kVjy/v7+r9jW+c2LK5fGlzDyMqmPV+5iS7Loss2JCQCVLlRB7qBcPCm47U606+0FEWZlwdMuVFSJferCJ1TseGmfijbdpDBWI3Ey+SDiQr5/uiz0ZulKvjcuCStsK5N2nz0mDX4j0NmRZ9Hoj7pO49733TfmcZKZGGFIj9feXgdlr8YEK1a9AI3H46lVV/BESUjZOwOKTeVFh0eRKTkZoDBpdBNjm6qypjO4+YSuWHSB8AVwqKuCm5m4j+O5tHHoFA1PjjfFrHRHNQslQgxMmPvWqfjpxEioTBp8kF5R6nKjYdud7XnKLPUx1+eipF3L0dnszxA13cECd7o82zvLvpjy+P5n2JKdSdOe2eQxZY6FHuwkIk2S3lh/pFmKQG7TJybGZMcDr+ffQhVzSvlkxIOPlS5sbQLjzLMzi1Ho9GBudmVUh/r3eGW5m587s75oVOjOkRqlopeoDO4wAGFIP+OFeFoWuhyiPCONQGR2doSbfKSB0b3v75ZKkxu7IRdXJRy81id06ZXVjs3tWXZm/LFEZbmKZ5/g0Uel8gsJUUmVTzcLZi21+C+OjqW4ZVXz8DOXY8mLEgPOUNxiNE723VuYAPic0NSREj2/P6RJI/c6JQbzozg/lRzkkmJql7J6in3aJSbhKumK/fznVNvxScOe0Y5gfyMUm4Skpsj2DZ8zHxVMn32dJTw1gvbsGZBnb9tOgu+6Y/15GEoLzpMblLlZsiAS/KogGQ69WbAZDBkADjPk0OUXsGWl18wmIhl4x0jD0HT5DOD+nCBDC/gPGMh8ggTI0puqGqRqW4JHetUMNpBz/tFc3uEwxc1yo2QlRsP1a7zHou43+kntoIZAluXvyVt7+htD65GHuetL6wLKTM031xzoRk3LrxR2m/DlMiNnEPEq1c4fBwIKzecMQglwd13t14mn2RWztehPictuSG1aWQd2kEkakgOjRMeiaMDbW+0edQjiDYhcp9evCbyeBUt3dEEXsqxomy0NMqNJfRdnGkJHLmuCxMK7e65enKjiqPCJSQLOlbh3/920ijsmPoe9TQAAC+PRFcpR84F6FO3Ewzs1KG4Pz43lISuWPltlEqNWLXq+4nKiSxfGoOVOsVNpICQz0290Y51xq6Ky0RYVjd27Xoc5XKbv23KxF6YOede49JFKLWX/ipqSHpAbshCkariYuYC5UaKgAvg+NzQk+LNUtc9uzqoZRIlil63p4zGu5eha/4umdxUWBrEw5KWyai1uvSLZ0qSdPxz9pL4+X+nPjdDB7JyIyAtHiAEphV24bBiEA47nzEsKP4c9x79IQgw2BnZLu8k8SN+PGSlxyTLMPS0l3Bq10z8MfdrXJkJe8+ziPT0h33k+8jWNoR3xDJxp1FnzaBePSWFDFGfG/e/nkOxzYXU4Vd5kQkR39O4E9ox9ujWULg1XQyTKje7Wrr7kAnNgQUTJlVuyuFB0IuWUuvpREsR/x9DVm4AIAOlPLo2TcRgVlQ6IEsj/cq5k4SyT0j/VRHq4Nw/qVkkVrlxexWL3OuWnnB01aquXmyfdJBTF1LhWHKj+e0pk5adXLkxABywq4Dzdy5zzo0gN4bSYIQQsGBjYdcqvPLKK+js7MSOye+OqKzi2M+Y9GJ8n5uY8cKS/FOSgZpOeSF4JoIsc7Jr1+MJSwtDylCsLpzp1lenZgnksbW3KCk3C7Mb8GJuJRobNH0NwZq112Dlqu+iXA4mXae/owWH/oervOpIlc5/RKlWoNwE8MiNlGJBNUuZ+eAs0ieGzVKqshXdtv/0EvExS6JEkUM6525HcV0b2v6+XuqjkpqlBADeXqwoHCdbo074zzn1uRlCoDMQxrik3DAAC+d/Fn/deh1MOKaUO1wiMPPID6Bx3AmwTGX9Hs7BaQQW436jdMhN/Gj94DWvY6zl+MJ8wnw1tN+wncG0jAzU7nPYlGW6G4y9HiB/lz3Fyszd4hbaHn0UhQfuBx0Ca3LDAUQrNwIGciPKoVkflUppB8VE0kwhAeyQWUpHbiKUGyFgl1XlpsIaODR9e4SEXVQ6civBO9GRyihuHJqNe5NXOtDG+Nx4VyiTdXZMpY5CCLxv4Rr87eOXoqtmuLSvuTuaOOk6a+/9W1a4ThYMxLIH77gochNSboRE8mLD6Zna9pk06PMEdEUiN0n9ZWhunN7gmdB1zVau+m6ysjSQ1DO1SqS+TaPHwyLtfc2xP8cnlndgk6ZL6O3RK4Flm+OWf63FK6uXa/fXjHfvTyUDL90UEdEpH+eFitNB2/O54Yxh9uzZWLJkSYRZynueYfUaiCA3ukWCdbW06ThS+XibRCiW6kgfEtM+1bZrwZBNz27do02HGjVYXTgzVW6GDriSLl2xUvmwh7+OumPugUFm1T01k/SrglOZr4JZKg7dIh/axngWb+A0fInNxDMjj5b3GZoPMWYgFb3OrIp+IN0lpQyhPJ/CZLT3WNj145+gfNtv0UMeUn6UO6uPuCT3/JWU52FwMoCQ58kg+rzoqGqWog6T3kcfGQquREtxxiovnCmRG/0gX1KVmwpmKaeuuiP03VbUICoNar0R5KbY5V+amqXGEnMCAKz532/5v7ura6V93TGEWDeh9XzSLM3CrwJAZ77yauZR35Sq3EAhN4ZhxIw+inKj7E3icyNFS8Uct/DJx/D0b24A57ZklpJJaLLFJSshLkOxcNvivBNOwZ8/8794esZ/+vvKuTEAgPlW+HlFkcsH5m3B72avw3ULvhFbp1Af8cK1QHe8GkRhkHcRKDcGdu7ciSeeeCKkuHA7j7J9gPMHVW7IMU60lFTLSOWmYBUAg7wr0tCrNItZOtclP0sk5cDWUQGJTmiWAgADQjJ9+rdFk76GqqD3ufH/TpWboQPZWY7Bikgi1nDUX9F+wEtAPlhAL1vuDA82NncGDBdh5SY5uqFZ+FBk8Ht8GwBwH7tU2qUlN1KCMNl+vrZ7J/6y8i+yU5pCbuhwWuidhp5N/4sfPUjIEJ0Ve+aTiIHHyz6rzkBMLis3mQPeiexhH4SRULmZ0d2Dw7s3A/CipUj5tBMO+VAps0IuZHJjMCBCufnXynr8fvY6Wdmx9ORGVW6ShYLTDsr5vfGog1H84BQ809gmHZnI5yYqFPy6qRgBp01Ts9Rzi/9HOmz7m2/6vw11BhkjyUuLJXr/9ZQbjVmqkMnhodPDS5IkhU65kdMZxKinoW+fSe+lr+QmTrl56cE/Y828l7HpzTeURJOBc3Zf+4soSEFKIWXC+fvBD30KALDukGND53dqFg21I0LWNzYlzAO1m8kKs2bQnqnPTVA+eaYAdj09FfVtP0OJH65MroJzClZBIRDR5Oa9D78Xw4/8qf+34M4k9qdPrkCvuqaUd0xEKDgArDrqC6Fj4s4HAENwKagj2B/uO9Tt/v5QnptkStVgICU3AwzqUCwEU5QbuTHMx7vQnAlmrZlyt1a5EST6x8mdE+O0F/ONd6NKuz3KjqpXbsixSsMtgOOGhTdI5gvV54Z+ED2dRwIAynZw01108HJ/GmB471KOrz9lw6L+BG7zVZMUUi4iGEP1qV9G1XEXYkKm8qrW7+ot4NcNTXj5jS8CcJSbyj43nmOhvN2yrZBDMc1zs6MYKGWX3v8GfvWvtVhGMxZHkhv5QmXN7ExdkkF9w5ZhoH7qBMBg+NbqbVjSEQyCkT43tDMtRJuOpnLHp8xi0UpB64hRwfXMDCRH25j2rXMo9jphW6N0dVTVxH4TQbkR34DmOFXvii5efQcR0VIx9bMllST6OA+lQkEyRUhmKU1339nZiYYIfxersRG2ZkkWHlcnd/KzY+KUyDo21teHtkWRGyMhIeuvQ7GHqlxwn1pyQ8xSj+LD2GU5BK3AT1HUbLKWGC9plBu9qbm7rDxnW2BNfSfufW1z9J1ovesd1E16l/Mj9lsipEUIGJAz6gfmfj25cX5r3k+q3AxNUGFDwKDpB0IN8Hfsu+gxAsmcf2QzjKwy+1T9SRgPEk+xZO5dHrqFhtywaGbNvPwunDuZOXvbFHuqfK4hHHmYppwPmRikDzL8YdC793wSGAe+9k+Oc5YLdC9ZQvYbEAIorF2r1IP6NQSoZZnQTFzF8YqjrAUTzCU3Qgjt2jlRPjerXnkRj193TVAXhdw0WweHymokJCPKLKVG2eh8bqipzBRGaEAuZAMTZbtl4/xFwTMMh++726U8N9HRUtwlNXYMuWkZMcL/bZvycTrlRme2sMqbAAC9nhOr7jmASSaHKESapSr43DiQDwqSQSrkRimLJ2Bd9FkkGiY41y4R4lQn3N3/5S9/wW233YZNmzbJ121uxrqz34N1Z54ZOkcaAENmqcr3pFNio32eEpKbPgo3hhK1aGh8bqQJgqS4MLyQ83yAOKSOnZxTtstSfydC5URD2AK9oYmhjO4l22L3A4hN6CcpP4zBYFw2S3k+N6yPvoqC+0SeHXF+X84cUKTkZoBBP24BpsbCBGDKfwGI0xq1oeB07SBmOMpNxXTxGqjKDQNHuboZUbMZX7l566/AvRcAd74vRG7oBzKmI4dzF05EU0+rv232g/dj1ctzSKnxvZClyRlhkFmdRRZsFG7zbZ35cHAOt6MdiiN8br74bxvHb3Luy1SqZyMDk3mDJ6RF8uB//HqzlJfbpWDk8MbIk9GcHwmQgVxHTemin7D0HaE6Nuh8brgZ7e/BmEBv1onK++aWB/C5XU/L5yoX8OqZVLnxlv+IU246hlFyI4e/q8rR4sWLce2112LlypWySaTkJMi7y+jR1htwcpUkmQIk9bkREBIpef6u5eipnaTU3yPDave6e2apJKHgzgCq97nRKTf1rory8svyWkFdbzrZyfWrv8coN2wszDGHxdZRN1DaEf2ZWWk24pWZ1G/VfXeZjNzmaCJVvVkqIAkmbBDdMNIsVeKlRGYp3fp4SZaT4GZ8tnoA2PTpCyP36XxuJLOUXwWq1oD8jmiP1CyV0VsL9gRScjPA4FJ+AsXnRreMANn93Ob3ITTb43JMhbeid6lU0g7U6haD0KsuIZtlDCbQfsCLkazcJzfLH3P+27IRUp4bJRvpmPxkvBvvxZLFb/nbWhvq8MwffgUA6F3RDLszfuZC+yjv48u39pL9VJUxAMGkGbG6UCWXyI0eFywU+MlDHFVMoEr1m4GJvHA6Ni5ERIZi/SAu3A507tj3YN6Yd+G2o74AkGOFZnCTFvrTRP/ooAsFl5aVgEpWgEI2h0N7tuKHm+/CLWtvkusQFS2VxOcGQDnBLNom5MtW/JAsW2BkuQ3HdqyAbVl48sknAQAPP/ywlsCU3Xvt7QrPUjmYnAE8AkmUm55RayGEkKKctq9tDZ1j+++jslN3pT19DQUXnMs5UsrlYPYeo4Ko9//wmuhFF+UMxcGAyHvKYMNmoOY934uto065iTZLxRYVW6YO3lEquWHk6WaEp9yQ4ZH0dRnYgT8guEJuiFnKLimvVm+WsjXfb5LlJHimcv9g7doVfX7LFulvBqGNllKP8dA+akWo5QqhkL2BcfPqF1JyM8BQF0qjfl6G1Ijdt06+3ofXfkKr3Miqp1OgLm24e1EJph2kzu6FHC3FIMC4wPhSRMI+zywlfeTk4+SqszCwdVwe9dvpyuXO/ZS2daL5gZXofGU72SPf61vjDsWPiGGKg8Myq1Bafi42HvVRjD+hAyNa15D9XsZnotSoIcfkEgZ5urZiIxCmwPUH9OKcYXLnQ0PBCz0WeFmj3IBhWpZhspLs2c47ZHJ79VQAQEduOBiRw3UzH+pTFCVhq2dZmlmetOwEU5xg4ZilRljEWVOSo/UXlGbpGt8jD957iTMHcdLubTMjEXWbC1y8/W94f/NLWPzMP3RVcX+70rf7LnUJyARj0sAVhWifm6Be2975SwBhnxsV/mCltjFFuUmSnVdnlmptnY9t2+4LzAaqKUGZdHjqjarcLF0aTEJUM81ru16LrJNqtvzEbU6KCdtdaLek6NWbpx4q/a1t9xFRPUZCdlPda6B5e7yZppQL+rmQckPNUl60FD0gpNz4O6QjBRgmNecxoSXvkBu1TWrIjVa5SUJuzGSTnyiIHfLagabgyorvgVlKh3JVcyhMzSE3wXRK7eP3JFJyM8CQzVIGSIQeTE0nGx5HlA6R2C+BgNyUy+WKyo0QAnb3Q/7f6jo7jHG8c3EbFr3+WRzWI7N4ADD8VcJlxzouqtFUuhrdS1tD68S0Gt3Sdby9VmshXEEFPzhLztbLAeyadDq4NRwHH7EO447pwie2/4yU7RQmkxv5idJ9hhD+9S0lLNaa6JynLkbh+NwITLEM3PfdV7C4bnKw071Wc3YL3lGbCZ0rsnkI00QmImLA6+RpnW3JLKU3/aht5vnOkbDNsfIxStuQTSAChWxOye1BzB9qh8w1g2iMWdTztYmbTdNZcZzPzZblcq4lXUZsrwPVXY6D7ZZDcTKfGxlRyk30tWPKkqKlnP8ufvNzWLvuZ2hpecU9n3rQh/3CuJdDRvG5efzxx/zfHrl5q/EtdJTkaCa1PLW6b21vd65TsFBAGfdXvSjtf+Qjl0h/69oFjzJLkXa8FCfiB7gFG3Co9th7v32ZdruH9jHL/drHKTemr9zofW5M2ISYCslUb8DA+fMn4cOvT0KpXAw/LM2ExdaYlQWvTH2TKDdxkMcaBgYhm561Zil5kiTVUginLe5FJ2KKlNwMMNp6ipjyrj9hzJHPQQgm5VkxdHKdwXAgq8eRzMm0GWrQNpdVPqLcVA7tLPn+IkCYXDEIDOtxPqwLGl8Knc1My7soqU8RndaFKPB3ovWpRn1SNerz4t6oOSznb6E1iINTtnPM+OzG0H5fuSEjkOrQKCRyEz7Xgz3GrZFyPzZMGAbHmQWnM9zYMV7a35s10ZGpgw6CAXZVrd9ZOpWQjgAANDW/EFxvM5kxRzgUq898fu9ItE76qfZYD1yZYVmKKYgm2QuZftxZpORsGJM/g0c4WFMIRbmRLkcHdEWVChvYAuVGS1DYbjoUa46TyY1moPbrHM5QLDTEX2eCEJxjzl23YdPfAwKi3kVvwVEqPFN4S3Y0vv5qCVe8IUfeCN/5W53ckIGKMdz92N343iPfw1ee/4p8vkI8tCHp3IYo2thlhM10KpI4FHd1r8PyFVfAttr8bTewq7GNHYTrG3+A+p5xoTKEYeD1119HhybUXEUmk4HNGOYdciy2jxov9Q1ePykN/opZStLTpKij4J2XrZLSH+nNUnqfm91TbpLQatpPgzn3bUs8mRC4hBCiBDmXWarcDBm81b4WIw5ciAknPuqYpaQESLrOF3gp/y08l/8BRqPDd5L1UN61C4ITU4ZbXk+XPv9DpiroXATvQYYu16Bc36gwpfWjpSDPYDhGBtfQkRu5FKWIYO+Y7smIg7QKtWaZCC9aylZW/paOkb7fwD9ATctvjXNt6NK4JVyzVHQu2ZKbYMvmFsKdAAPPVyND0t7r/B5aW1/3f9vEGTupcgMAwhzl/z64Zzu+hL9iKgJ7u63MuNQFWjOEgKlWLuYrN2RjzOrPAbmJU24IuVF9bqgpRlljh9bBYFkwEOVGdx0RXw8PXcVk0TqeciMAzD/4aLxxaDhBoLdWmj7PjVwaoCcL6xfNx+J/PYNtgqQSUB29XYXMI5pvjDoZW7qAf9cryo0bMaVOhii5Wbt2LbYt24YzGs7AiuYV0nFb69ulv9Xqfi/zEHDDwRBNG3DbMePx0uEnhu5Huq5mm63kclm06ELU1z+FpsZ/StuN5gL4m7344StXh8ooTDwQs2bNwj333BNzdQHTLGH06FVYPXUa3pp2OJ4+8d2yiukNzjTYI0K5cXxuZD9LD2Wu87nRKDfCcT04ewlRXxPwiTjlpnrUVljj4wtR1V0GNYmf+5sJ7TfkJAElVgUBAAXZLDVAuZX6g5TcDDCMDMmJAgMdwzcF+wTdF/41lTWFzVJKmnsvodySF57TNpz8yGDdKvBumKQDCyk3Ual/vf2GRrmxSvLsUzFLQcjmL79/13Tg47oPjL0+pRRck11V+MpN0IzDPjfBPgOBKZsqN2beBh8eJjcmbDdDsc71F4AQKHkmFebUSKq/cGaTGWn5jGC/J4UPqz3c32YlSOIX+dbcZ/yX5d/HsViNLyMwSVKzFIMIdWxUXQovhhgehHWO1cG1KpMbqrZZZkbmz5JTo8am7+KdEy7AB4Zn/EZma2bFAkjkUByVOyrcQToOxY3DR+HNaUdg4qSXMDG7WjoiMhTcpWK0bkBYbQSAjgYniokTB3S1hsz9Jry11WxQZ3VSHz8cPKRDha6rw1fvWyCfpZz2tcyTQLEd1rJfY87UEVg55eBQGVK/pnkf7a9tlxLRWZazWrxtyf6ARmt0QII9zJl0tbW1RR4DBhxx5KuYMPEZZKYEx+kyFEvmbkJKDMGx0JqMN+FNaGgfSJSbckm512jlZlhvBofuHBZdbw24qe8frFwbDjz352j4v+gwcOe6cvs0SIJYIOBssr+e+u6oagV45OY97efhps1XYvjqlNwMIRDmzpg00JuaDrSSeqIU6ROSf7Z04sUDj5SlRQVCdOPAmrbgWiFNpcK1DQucW+juISYhXpYqFA4nVKV32R9Cdk6rMLMgv3XkxomWkjuhZS88Lx+k+Nx4AzRVbiad2g7hWs1o9XLcgg3TSZyofczCV25Ut1XWbeGl5gPxQtUpinJDf7qEigxgFvWLiFiXJWqsfvdKZ8ehvdvVS4XWMeKK/wU1S4WipVxGuLk6UCnifG689xHnc0MJKSc+N7vae6XEj6uaV0rnqXnLak3mKzfd7fpkdEnMUlHZf3Wrggsm0FFVg/e2LsRN636FT4+9SikritzoobNKlN18S3QV+dBKVe475HbYR0SaYPjKjfwNsZi+h+7a1SKrxFHPikekLgBkMuv9MmHh3ViIyagHB/cdkilMU15IONZckzBiatw45/uorur0t8mh4BrFmiTj7BB5LLEn4xvogWqWog3GiZZSvyW9cmNUbqJhRExOy9WNoW0WF/jEm+vw43VBQIfs1cOc5RcqREtJl4cAfUaGENi8eRU2FUbggOJ0HNd7GBJEqw8aUnIzwKCdQhmm1MlQctHjLoWQIQ2UMVnmA5xBSDKNuheYdeYFWDxpOjbUHiQ10XKuFT21rv8O78X7JgXERI0aoR23rhkbhoWOjiXo6d1MDuSS3K46eDqDvOyo5h4YvlIEL6tGAVdkHsXoqmDWJiLMUoDs1/TyX/8srZzOmYG3YOEVlCWzFK1jfmQZwbJbQf0ywoKFjKvcaMxvQqCnyhvw5XpkVrahwLNYn50m+9xo7tlq7cK3Mo/iOLYRTWI0vUL44MitwDHbojsjapaq5iYEk8mHbJbSKzfXHPkOUmACh+KYsH8hKTfBu/3ag4ul44pluXfkSnsD4EcBRfXFSeYPth2l3CgExfW5KWTzOLJ7k/Yci+vNUlHRUqHnDcByoyGp8qjen0dWuB0ejCl5DaKlos1SKkzyODLKpGxrSw90YBHZdwHAygVpKLx29zH8Cx/EK/gkZkU6aWdMNQQx7mVWftFCUjBBfocVbvr6qHIjL6kTbZaybEshrnqzlNbnJgGiXY7DncxLrZ2Y19aNu7Y3kfPl4f+Eqnfj8GWtwX5ilgpKVtRpOr5xwDTLuK/5JIwvO7mfyqOS3MngICU3Aw7C3BVyY5KZeC9zBkWq3BgaJl7KjVSUGzkUtWjmpUbKAHQP3+z+Jc/1TAiYsFHrhlvThqqaKZwK2bDV9XoEl+5RNUuFlRvlBwsPTiquzDyKKzKP43OH/hUAMDW3DAfkwyuU66KlDvvIVhz3xXUwsu5s1mD4OnrwA/Siw8z4MxPJoVgwX7mhM6issMBhxPrcbDzwvTh2ZD1qzRdk5YYMWJJyQ23U7hPIz30C/5t5HE/nfyxHcUWM1lGdWtwgTh2KTeEMfpRsy2YppVydw2uMWcobWI1yTKdNzVBksdA3t7bJh6kTX02uKN+hWGnDZxrLcYa9LETqddCFkQPR0VKFbC6khHrwzERJ87qGnOCFwPy/z3TKoiRQcPR2UWdZ1xzXW8aJo9+LrBEkTLOJ4tMzf4HjlxPKUBzRYARArOtSvwUAP35Cv0J3HOHtOuw4UmvnuifAMeeNR4tjNtW096xJ0lcIsdvKjeDB86Ptgqp7QSi43ixlSgRJNkvleA16ph0OAWBV00rs6CRKiWCh9BmATG4aWDvmZdaEwum1qOBWQGFV8I1kzMARVadi+uZuX0GrtCq4kxSVjF9c4OBDFgHgGFee4Fx3dGqWGjKgr7IEQ2a2pBF7TSLDqD9GuBkZ3AoRcStLU+tb2tBr90i5LHA8lfsxVlT9N8agQ0umpHsxLECdU8WQGzBnpisFHXsDjub7iOqKTjDkyKiPjwk7DwKBWYoOasOm9MDMcQyf2iNfH0CPkfX7RmqWEhwQeWcHlaez3IJw5Vq9WQrIsRacP2UtxuZ+A5S7kF3cDKO+V3pnG2qD0NWy1Mk4TypbCGZTiQwZEZtVaZveo5oNVzAmqTU0d0c4FFxThSRmqZjehQ6+tplxFD9uoyanmE5CIlKwIUikxtyBLXh6VSjir7lf4r7SLzHM1isNUn2SKjcuuSlmspIpjy746is3mmgpWblx0LtK9tnpamkOjiHPqberC7df+ln/b0+56X2pHkeNOh3jqwMfNqrctNx3H5puvQ1qnpso5cYUpkRuaDuJNVXEkJt8dRDBpbssB9dyE5MqN6LCeE7Ot0yG5447FKMnbJUPETRjcwBdhuKW2hHYOXIs5h5xEnpLgX+L7LsoJOUmK3Kwh40Er64FA/DE2r/LdYxyKHbxZP4NrMhsxxuZDW6blsmThMjZDPV5FMoWUvOo7sX9FiplKAYUUsgFhg9vwejRu8CEM2Epj4io4h7AoJObW2+9FdOnT0dVVRVOP/10LFiwIPLYFStW4FOf+hSmT58Oxhh+85vfhI756U9/CsaY9O+oo44axDvoK4jPjarcgJIbI7TNIRtq8xGhTaU8cRxkhuYctyZK5kuDcRxjbAEAnGUsr+hzwwwrvF6PMojozFJq/gT5uAQ2AoKxk4+J3MfdubM3u+Vkhsnc2E7Jt4Qxrc+NEAzc87lRlBuAhZQb//4EkBGBP8KO1iaYjQXklrTolTAAW1uDgdYjFDbxK5D8QyKVGz3UgbiIoFzVoZiDSWpNJoFDsVSHBNFScb1L6zCiMpgmCt1duP3SL2Askx3omWLa0a61JADwYOGOE8ctx8ljA6VvpKWPLIwqlyKUQ0649IbJNP4RBIMW746KllLhXLP7dblPLJP1zTgJkxeMQW7ObqTejh5Smnue0v6a77477EAUQ25ks1TQNlp7YpxUIxzgnfrQv8LXtRGoMrRPyfRBuaFm1lmHHo8vjr0Hjx51bvTxob7XgfddzD/kWDx50tlYPXk6nmsMTOTSN8ps6Tv1vnvBGJhgIUJJyc3mzZvR0NCgdWZvZz04/NmL8HTuR8hEqDgRYQ6y24D7Uxd8QhX/2lHt2HTmVega/6b/evx+IKKdOD09VW6c/2ayRXSyXvcafevvBxKDSm5mzpyJK6+8Etdccw0WL16ME088Eeedd17kKrQ9PT045JBDcP3112PSpEnaYwDg2GOPxa5du/x/r7zyymDdQt9B3mWZGdJAT2cHniOwIfnc6ApkIe5SzAWzmbKRkQgUbWyjs/K6HlRGL7vJ6eLADNv5gOj1hewXVNxCZXIBA4bkhU+JgPIjUbOfeMBJkftUh2K6Po1HbiSSIbi/vAGn6/4I+D43sh+Ko4oZTMg5SQ33+QsBzgOyYoEoBBHjWk8myAqaNZyB3GJBBy6bOiqQm4KN3PxGGDud62aUz5mSGy6RG41yI2w82dDmHOs+g6zp3oQtwkQrLlrK87mJ6V2684R4uT43ha5OnNAiZ02NM0sxFDEmewPOEGsAu+y3NdOwcOL4gNyYmvT2oTpHREuFpxpBKDj9nntou27VJL9E2ExVJgMhhVWKIjcGGFn8zHMoFgXPjBJAzePEsln/+Kh786CSG6pQbVP8bShBEF2diILqwK6iaIK0MUI0DPk7jc//Eux7fsR7AQDrmDLxZfq+kqrqumSrrWS5EZPJUx1IirxXvpM80pAILvOjpVpbW3Hvvffitttu0y6/AADD617HccZmHGts1u5PYpZ65eyzvCuHQM8+4vQ3UBq2CztO/q3/HnqWeuZH+s3Jz1/K7Oy+G8YEbDiLcA7ZPDe33HILLr30UlxyySU45phjcMcdd6CmpiYyD8Fpp52Gm266CZ/97GeRz+e1xwBOAqZJkyb5/8aNCyd02lugr7IMJg30TBlgUObIdhW1+z3oFIBiNujwykZG7jTJ9d4/7kTpvE+Yr/q/bcgLCur8A5hRRjiUQ1Zuupc0SHsifW78VN6k/ERL+UZ/wF4H7pXJNeSGRh9VZdqxa9VijEEHphlBRIEQiIyWEi65oTWlSosQgU9SkqicEbWBipBhzizOMoLyRjH9kggUPvlY0w6jrYSc6wSYEdHkRl1JPExuOL6yYjMAYNO82cihjOqsFwmGEM+KNUu57z8uWkrKLkBMDxlFKlE7R+p8e6L5BGrMl/Ff+Jc0I2YI3j/gmBcrIYrcxOW5MUm5Y2k9PXKjcSj2vufW6mH46geOw41H5UMs0CJLq0ih4IxJ9+WrokXPx4fcjxEmN2p3H/X95csM714ZPA+q3LR0y2aVPAIlR66bDJlshfuan551Kno9cwjN+Cv57sYrN/R7mWAH37dl6Ic5FjFoGxoHXyNi+QWmLr9A+zc4GYulLW6b2bgqiALUORTTdj+ZNYf2A0DnxIVaZYSeWz91kl+X4HphhczMBG25tLMbQgg0/ua3znERZikGZcyyXF87wybGtCFIbkqlEhYtWoQZM2YEFzMMzJgxA/PmzdutstetW4cpU6bgkEMOwec//3ls3bo19vhisYiOjg7p36BBAIds6sbEhiI4lFBwKc8NQ25eA7KdAbmxrCyyrzTAXK84DSpvqUz8EspGFrLXu9TFRVazjExFcmGYZXf5hwDFzklQpBzpnKwwoQsF1yk3Iyat0l6Xnj8hd0Vk/YS7cCZnDD0d7di4iMj7o5yEWJw4qzIm0FM2cUP2T3JBnEHk3E+R3E5GBOSG3rHtkREhYEDvaBjpLkO2Z10TjGUEg/uX2HPSHerQ3uGqEpbcKWbUJSUQ3LtNZnnduQw405uldi5dgI+t+C+8mv8GcpLXr0KOkkRLRR7hmVMdlDPB/Y+pkUN/R3fK90TD1CcY64Id3PKJA2NCeY/xyo2zYGCyPDdCuKuCMwaDJJ6TnlWH92xUM1Dwc9FBRwIAHj4oFzrOLgdtSpjUBC2TG58EFF0iT9qLqpSwbDY8i46Y+V/4qoFj3GWa1oyahnLe9OtUUnyTqkj7twEwzeKlTn3ofYT3lzIm1vorzUeo2QJa53b/OyFto5pMOjqqaoNDI5Qbmg9M114YIbJhnxv6l28Hcs1Sys26RLG3o93fFKXclPkUAMAEo027vzBqIzonzQ/vEOH+Weq/vMcVYTpveXAVuhfUkXuJ+paFpNwwy7VGGE7+nwRJlgcVg0ZumpqaYNs2Jk6cKG2fOHEi6ur06eqT4PTTT8e9996LWbNm4fbbb8emTZtw9tlno7MzWhK97rrrMHLkSP/ftGnT+n39Shhvt+Lgbb04bnUnuOpQTA8UgNFryz43QsDosZHdIN+L2kboBN3OMMUsBfI7PtEabZifavgXLqybJR3DzHLILNW48ZPSVWQjivOXHP3okRuNnT0TdEBR30FOcS6mZdGFM+//3jf81ccBoDS8GoeMOk1e2RdO53OSsT5UnK/ckO2fqZsFuOTGhEAx3wRulMCJ0kDNihk6o4vKm0J+c9GD7T0jQtmS1ftUYdnd3s1IMGPMIDaZHTbXVIEzI2SWAoDWN52MsONZB3gvaT9qT+WapRoaGvBr/BcW49jg0AQZimlVLUJuzAo9EuUgI1h98AcxSzHGpSjErIhXbgxwbTg2ICsHzmzU0W0EGEyyBEUJAm2s29nnEwDd+9D5PsiwSiWUh4+GVTsCnCR17K2qAc8QXzFFKZRMp2r22Ww2dHwU+aw78Fy8dOKpAIAr3vu/2FwzBZ/6xV/Q2FlEOYbcbGIM+VcbgFK437F1Ex4FwzwzGyULqpVW9578MTjYZ7GA2BdJ+5J1LzIwU7OUhmyUSiQnjvQc5VBwShgcs5Si3HjrVknZ13XKDVBf+hMsPgETWGtov4ee0asj9wEO0RdCyCvoeMoNcYRSeU7XyzvIRmoKlVUc+gwnNTnklCo3qs/cnsTbLlrqQx/6EC688EKccMIJOO+88/DMM8+gra0NDz/8cOQ5V111Fdrb2/1/27bFrx67O8jTdOlQfW7Ctllqv1XNGn/E17Fj3PhQL0S/l5rRLUpnkUy5MSCkgfno7k34/ZrrYBI1wMiUYFu6mRjtYKlpC27XHyY/wbccltUBoKyk4I+DN1h5pE4whu7WFqlsg3EcPfrMkIqkm60IzrQ+N/+z4xFwMGQMG8PydegYvRItYxf5PjdzjjgWr59ytn98X5Wb9nwV/tL6vpgIFP32qMFBVW7o2XRWD+Y8h4mlQO72iE5rU5u/rUoEgenejNl/n65Z6uknn0A7RuJJnIvuOochBlmWk5mlqHJTKXEY9bmpYW1kh2yWot9SEnITFQpOF250yLSToVgw2RdlC2vBo/nXMS+zNlgrSpvnxqskHVjk49rbO1A44FD0HnhEiO3NPel8UqD8fdO7tNWEfdkshHJ8lHJ7z4xP4Jqvfhs7xgcT0yWFifjCXfPD5IbJzx0AWI9mIUg61ESMd0Er0PmwwPl4NGKTr2aR2ykTciOnBdcrN1JIs+Yi3AomYvQ7/7txmD67NXN9blRDjnssPccWduiRMDBY2U4UxRGyqTp0HZ36RtuWcBVmMtGB5yIQTTxYqRmHH7MCE7NrEJehmPaXBzQ5ky7D4K75NmxW3pMYNHIzbtw4mKaJ+vp6aXt9fX2ss3BfMWrUKBxxxBFYv3595DH5fB4jRoyQ/g0W6MsWUBPaSZlQAMgfiqk0nJfY+3HDxf+tITfBcUVUQU3GFCCa3GRgazs3Gk7MDBtbli6MHKJKsLAisw0WM/DssafjyWnV4OBKaLqi3NA8N7QzMuTFE+OQc+3fHAbASJi2FEni1ISG0jJEEAMBeKN4+JEwZA2ByRPecg41y76p68cf+xxykwOnbarcRGmy0hpZDChMPRg2ItJ4Jsy46iFWuVFI6Ac7XsUv1/82ONcdqOkSS+Ps3sDnxMsP5DnBeo7ZO970j986d5x7jKvcxNSfdqxWhvowidj7puYjgzzvXa2dga8P5PwblRyK48xS0rXdL9Qx1DKJ3Gw12wAAKzPbiXKj+y7d50e2qG2yqztQCbhCUhYceVZwnjLjr6Tc6P3n5L+2jAkITcNoeaX5NfWdKFvyOVXU58bryzS3Tc1kWv++zjLKVtjnRuLkHNrvqrfaMfEYxDeoCL1aI5MbxbzkwtQoKVlp5e/g9zo2GouWb/L/5pJyw0IRjB4h5TGLwwJAzYTV2PC+b2DrIY1yvwJgxM53a+uthwBsmTz5S9DEnDqi9FtMmroDnx77A12nCMD5bnQZ9g3DxijjDYzN/hnD61ZoztwzGDRyk8vlcMopp2D27Nn+Ns45Zs+ejTPOOGPArtPV1YUNGzZg8uT4RRj3FGQNRY59oR+N139T5zRd3pmd48aHttHGVkIuciYfl7zM+WDCDVNVEQs9LaB3NQdlvC6GAwBezq5CNyti9eSDsGXcZPz+6JGwmarcqD43cg099IXc5IUzW+QwwBjJq0IlU4O7JgTSqTI1TN3dLgI1TP1WveOPOPJlfxs3snju9LPxubp/4vbV1/rbpU4oouPY0h6YRBkEDj9iHrprVuoPjihEk34CAGDCkIiBFNXG5CUgvlH/F/lcXy4Pto0VvcHT88iNRxZd5cYUsoNpb0sWlu9zE9170kFAVm7iHbOpywUt/+nFW/yBizH5y9stsxRVXi34GYoFZCXWphGCbllVSmR0ZFI/NVqqHNRXKM6w1Il5Uf0b6Ch1+N9sJZ+bSsrNxnFT8OzxQd+sI6dxPjf+XWheH1n7V9sq8q814J6Fnu8kGfhV5UZ3shdBJik3Wc2BMljEbx25ycREUzXUU4dfj7w6yg1TzVJegkeq3Ggc3scc/iIAYOdBzcgZ8n7GaQSd5oHQIBYmIDhH0913B9erkJwPADKC+rHqlZuoZTgMw8JoYyHGZB/HqLq3Iq8x2BhUs9SVV16JO++8E/fddx9WrVqFyy67DN3d3bjkkksAABdffDGuuipYl6VUKmHJkiVYsmQJSqUSduzYgSVLlkiqzHe+8x28+OKL2Lx5M1577TV84hOfgGmauOiiiwbzVhJD0mmY3KHJVMfZnkH0RwMAo7o6Q29JEBJUQJWiDtFLRA8SWViJBEPBZLPUT9CLr4vpeCWzCptMJ1KqRMJVuZr0zzfbhj8o+mwqhYpSeMqNI/OTRSDJDXmLwEnXAAvNaAF3QuveQhS5KZeC9PFLDz0M13/pa/jizn9Ix5qRzgIBusvB+kwMwKRJG8KMskIZUV1ShsvEgN57N3mPOjna978hnfip5spAubFlcuOZpdRZZev6mmQ+NzTzboYmauPaaBUPcodKTQmWn16BQUgDcyXlxiE3UdFSzn+/vflenPfaLkypXu+QG8YkPw3pTt3Q+a8/rSgjShK/API2u0zeVYjcBPfy2NpH8N0Xv+v3D/QubQ254epzUBr7jtGaiZQCSyE3UhI377cuL5KSb0qHh5c6q9hL/ihFQp4FtN/EAcd3wcjZ0mOk5EZEmqVo9GpQ7oX11KnfQZa2J6gkkRBb3zbnmUdpO+dYf2AGra0LZHJjWyHfFMFNHLW2C8et6kBGyH0wJTf0HS6EhT+iIEdGMgFr1y70kHQpXrZiEadWkvst1AQ+snQMixp3DMNGresr2TnuiOhrDDKST5f7gc985jNobGzE1Vdfjbq6Opx00kmYNWuW72S8detWGOTj3blzJ04++WT/75tvvhk333wzzjnnHMydOxcAsH37dlx00UVobm7G+PHjcdZZZ+H111/H+PGVP8w9AYnZAlIouLQ6sQibpdSBAgBGdoXtrXQyUIS8/IK0BH0ls1SEI5sEo0M79q7O7NSW6+glMcoN+Rh7RUAY1M44Djnu+dwYzmRIp9ww7g5C8sxJa8KT7k/+eL36FwrD/e1bJ07SnSh3eppxPY8SPm0FkYJ+W4l0uosgN24nb7bI0oDZ267MOp2IDaFZsyxuVXAPX6+9A7eV3+uUxB1a6pMb1yyldvRGVfDM44Lx6NXLWWqWqqDcSHlu5G/Hb2JM9ierFAoer9w4+O6WPwMAThr9Ep7nFwBQlFhyjuACJo8n7Np0CS6kaCm1jdFElQx4bedrAPsCANnnhjMDPZk8aqwiBIBNBke+VzZ/hnKWJDDNlZVoJZncOPvyC5tQPHMCxHDiRUMFGABVIhvpe0OVm3IzUUWE0LapA47tRm2+DmvWBDltellV+EAFUcrN2W2LQ8fmOJ2EypVghqa/c7896lC88vhGdI7Ko3XDjeDiM/729kJbqBEIm2FqnRNNOZL1yGn8JDUoOPFbbp6tseUcjif3Zbe3y4uqet1OwpxB9G/aZmzBtO8wizKqmUOIusYOUXIDAJdffjkuv/xy7T6PsHiYPn16RYfChx56aKCqNiigH9/WsSNhdQUNUTcjlcxSWuWmK+xzQ/52fG7Cn+ma8hYAclgtRYbZkr08KFz+s8ziw+yDKzpw0qiHP3ZdhuKdmBqcJy0QWElTclUE1ywVhACTOhmuzw31O1GSKvrHUjcYcv9rqg5yhAwDKBUDxcWrq1rNbAWfm0+ZL4e2ATEuJjHfgtEUzga79YATQgNulcijlxViB1OAmKW4OjNXlBvvPXlmKTVih4Quxyk3NFcQNUsBAnl1kBXCf7k0FFx2Gi6TBiD73FQ2Swkc0jEf2HEaMPUd0r5wZlcnFFwwpqhk5AjOkbPCfi8CDBOrD8ZWKEuqMAPCtsHcZ0eTUaoqR3fVcHxf3IIf4v9geL5a3ishx9mModclN43Da7CY9+DwbZtRS4JXVbOUzhyjQjVLRRGE7FstKJ0VXExaAJRpfFFccC5knxvVLSbimxh+QBfE2qDMdhb4VUrvRrP8BRB+FipolmAjZtIYipYi99k5yvlmOzrehOAX+tt/teBXYYdi4puXV1aaoqYuS5O9eCc3AnLDBOyuLqktet+QFUtmo8g+ITcR7zBL6mTnhmuP2RN420VL7etosIOX+dg7j0f9iDH+37Qz9MKYZYficGOr7e0JDaKqcqNbW6qeb62o3Nwu/hDaHvrI8voEUlHjruePENRHUW6kfeQ89+N7B1uLM8woHxQH3nMMORQri5A6OXqCh8Whj5bqzZNcOKRSmZ4yupe622m93Wig0Kyaytya+x0FOcQ/GPz7qNwAMNpK7pkcedfvYeeUo0K5lLLuGi+qQVQlHp5ZSs1f409KPYtDhHIzDF0YfUQX7EyEUqnANoJ6SmYpzvGRruhuiUvKjWx68kPBhbwvx2OWDABgsjLGn7QYG175f9L2he3deLy+NVwHt41TMiD5p3CBnBVuH4yZmFB9kKYGDIIk7pOVmzC2s4PwBD4dDDQe/1R8bnpdAtmTz3qVVEpS2gCPN98BwMNvyJGmUp4T2v6VRVPD352+zTvLYJB+UupMhFZtBlwOSAfwqLw65LecWLACuZHWYVPuTRcKzpj7nenvk07id3XtCL8aO6hbjqntNyizxQinQGnMUc1CgHd2SeTSM0ttbCD51Cq0jeDKinKjgUl8hNRUHHsSKbkZYLxcCKTRjLDRnQvkUV0oeKaCcpO17HA/QFKwq9FSfog5bFSKljoK28M7lAHJMCt3eBReJElkufQjEs4Ch1dmHsaoCU4Y4eP5n1a8hjeoiJBDcXCMr9wY8rNhufBHW86TiCqy24SNspuAOUOTpzE9uSkgUHd07K+GyWpLYJYKHRpZBuB2/e6l/5r9JZbn/xsjy04nN7VIM0YzZEVWW1eV3HgdNlfITSbr1tlVbuq/Y6P7TDvwuXE7/S/iMUx6RwdGT6bp+aMHDM5NP+FbOZvzjxy+7U2Mbf2zcjTpUCm5IS8rx3ulw7fhQP/PSsrNuLFbkRvRic3jHTNAb6fT6X9k8brQsc66XM6zivK5KRR7kdUoN84SrAIb7TFoWIEg4R1j4IUgvb9t08FBP4CUkQ3c2dwfsnJjoDfj5DfIuGoLY8CyxqMxf9c73L/l95MLresVfn9bmuXlFwwplQX5Rky53vRZCBYdIGxzIQ38Vmdglr+w+XmsYJfgPcZbTjkKY6fPyiZpEeT79CZbQlKIaX06TJL0z0VW0AzFilpp6dsBEwymMNAzehU2nXmVdA7nHM28Gp08B8adZH9lMhEGUW6yaj8urR0VHjO2VgWqKGMCdmeHlLHaO0MN66eIoqKy24Xyjt3/GmTiElpbaw8iJTcDDNkGbUutXfr4hYFvZx7GI/mf+dtqIXcugNsxKZ0QjSYOR0u55EYIxJGb0AdDzv77+g/jF/O/hZKdBTOE1iUkcthiipLshxLrz3yfsQTfzDyBd7xrEyZDrxKp8Eii53PjsxpKblhglsrCwhnGCuRGtyFTE75vGs4oOaJSswc5hkcoN9ICd0q/8VHjNVye+Ye0rbLPjR4CwVM8w1yJLLMxo2UeAI6X3vgiOY6SG6UABZ7iw5W8RvlhzjthLqkoT2Jo/4IN2DYE5/5549ECAKgdFrThOMfghu21yL/a4A/wtpTnSHVACH5qE9QCmNi9OlBuIPAcLvD3VVZugjax4sXZuO3Ln8OCfzyqPZYx4TsUS2vFkWNWN692lJvQQpUOuXmpfCisIpBd2eYVCkEWy6S+ELl8N3RgELhwTBkTM0H/IIeCGyi45IYRk/Bv3rwMf1r2JTT2jAWYwFnlYDI2/YC3pGuo9VcfffbQZyFyNNUC7exUckMnGdGKhmMq0ZOF322/GbWsiO9nHnL30Q8+MF0Cap4fUgpjYELgjIWt+O6bj2vrrvP/i4uWsm1NX+rmuWFg2HbaDSgN2yXtbikIPFU6Do+VTnRenwAKUw8JDiDhZVmmREuR++YQaGIdeDEbqN1C+djttjY59YJ3QKwLSGXlRrW8e1cwmBd5qcnQvAeRkpsBBiU3GSGTGypjczB8I/OEdO4tuTugNip7uBfFQmdFwf5GNhFLcVKwz21Mh7fsRHwoeMRsVgBPbzwfG9sPxvxdp0SeH+MNKO1TfW68u+hBNRoxAWNZII0eaSRLruiRRMfnRj+TZ8xbBcjADzJ/w99yv8DHq553ZxuKOUkiN3Q7kdnJb09qVT//jJSfw92bc671u1zYBKgemniHQMgXwxAcB2JX6FCtcqNxzPQUGE466jazGqa3gqIdPHMfpYLGEVk/G46C0ewM6nEJxeiTXvTaS9ojejYH+ZiYEKDrNVVafoGSlFm3/RoA8PJf742si5eoMsqB3BSmo9wo3auTRJJs8J6pmYfVFBB7rzqjR+/A5Clh9Yhe8FOjS/61VXLjRTFyl2hQNaOhdxxMMEy3J/jbVPOHuj4Vqky//rmxL8AYXq91KAYAKMqNCDndyg3Q66tsxefGa7f0OtuFEzzCVeWFDuCU3EgxBQw1PTZqChzTuxp89Y0O2rr2kiHqn5qyg0csIhvOUBxgew8132o8kHhQ/1CgCSlTMI4n8guxzgy+fSmkgAmU29sVnxv/7OA4cs4/UEJjxNgRt7CvV0bGIAvHxlv7BhUpuRlgmCFyE7xd2QGx8mJuAGCdUMSBZzXhPfNacMDOXu8iEu5hXw3KdRvxhWtfQyWzlP76AWxhao8Botvsa4ceh7oRo8PHKT9+i++gC8MxjCSwi1ogLlRHVbnxoCTxs4UTufPfmWcBACeJDRDCCNVeUm7IdmmGplNulAFZIoz+SBtzHxWVG/1TFppyGYAcSqFjTWGACSPEk0JmKc/UR0wiDIDpZXX08txQE2ixJ2RKlWX56J7Nr7436MWSmwBbN+oH+2qUCJFmEtHN8/BzkevStx6YgwNMdcANyhiRGY5cOWyWcu4xrG40jz0O3Zt2BOW75Y4dty06zYOL4cRETfPcNFeNAM8678p2r1Mm8SO95WqYkDPXZtQAgwlHS3+KahM5b+BiHHnGZFNwjHJjK+HYqj+W9605PjfUBOz8l+bT2SUc842a9Vg2S8lrykn3QariERnpu9eQmxyPNku1dIUVd+GuLaV3nGbgxCTk5MNRDiHkJsvk+rAKZin6aBkTsDo6g/xUIOkUiPTy8LqP4qY3vg6bG7gJBTmjOQH93rWTZyFgZsr+0XsTKbkZYFDSYAobjHPcn70O12f+JPvcRDB6Q2lU3BQYnrGQtQSOXO9I1Ko926jvRXZxM1ByXAqLwkTRyICxaHIzjIU/SKfw4GeZZ7C29RBtBxs1HCw94DB056rJFtdUUGhy/3TOXM5OAgAMZ4ENfxJriawvRaDcmPHKDXPMUkVB8vBoiISUZZNOPt2PVwh5thblcyN1Qr6PUfTgVHFQjcxzo7kH8FDbcfK9GDC5unJ8uEyvQ594lhyqbrjKDdORm3JBE9lGZ9PR9+d3kp4LRNwgnoB7mIw4FDsaib+vks/N4vYj0FoYEXuMB8s0nWgpyKuq0yqawkDOEho1SqaC3qNjAJo2NZEd3lEiZhLkoLVsapWbG077AsaNaUfDQSfCyDuTjZIIfDG6yjVgTDZxqEQ1c+SH5IsK4IDeHcijhC+XluBku0uZGFB1Od4spYZT+z5fCZQbr51Lbc9gsnIDfS4YWiZAyU28ckPbkEputrfoTYeHlQ7CaGukZo8hRSp5rscSOFUeLYxqK+PAbT1un6Bf/saDbLoV4MWC3ixF7uP5LR/A6pYjsbLFWdA1KnpMnkvqj8kYmkneXkBKbgYYOWIfzQgbR/KteI+5DJ/NzJU+kKjOPOSJDwYhZAc3rsjFuSUtMBsLyKztQNky8bfiO3DRh36KOOXmDEMfkURr9dCaT+GGhVdga+cBoeOi17MKH/fOsVtRO/cs1JpPqztl5QYJyU2UcqP63LjRUgUSEs+FAbUjoR20IfncOM+vYOelDjIwSynmLdopemN3zBfmn91n5UaElRshQmTC+5tpuqGoaCn1GMNTbjRmKd7WGiK+Up6lBMtHeLf+6mnvx5Yph8QfjErfjc+UpKPOaV0YW+ayrkNw65Iv+1eIBQscinPEyVRap4gzJxRc65Yp8F7jTZzE1kvqhk3yuXgRYUyTn0i93qjSKL/OKoW75viv4NCTv45jT/sRDBgoiyAqrb04Eqbi2Ktey2JMTiYhBDgMfCvzGL5XWoz71r4q3bfUylSfG+rYz8Kzflm5CUcfUXITTDpIW1OelRWV3wGQGoepITf6DMWU3ChPWtPOh2VH40ft/4uTeo4M7QNs7NzUFpTHWbiK5N4yzMYpS9tx+KYeTGgqhcxSKra3Cby6451OOUzALpYkcukvfaZp6rrJn1Qv2s4jCJBppsrNkESONHxTcBTIbGkUAs//Sp1WcJyTfZUiKjkYK3F09ThOhL3ZKsSFgp+srIwtXVDB9q4pkeVUKkMw4OwJWwAAo7OyTxGDwHAWkBs1migKBgTQa2F74wTZDBJK4schDCaRG529v5JyU7CqJJ8b7is3MqRVwUM/wvA7+KjxNC5DsVKuLtLOaUvMMUvRE6wwEfI7eSppA75yozNL9Sxe4pLFAEWyYnq8V5asbL1x4ll4+KP/pT32HDYf78NrylZ15m8HHFEh/yd0RfmtuIdDYFPH9MqVhkN+bTiqTJQvj6PcBCTYB2OoRhPuzd2EJ/JXB5mFi4tQ1xKYpYREbpyDcqEFbJ1j8nZeq9ycyNZjHr8Mw81HAAAZI4cSITfdVjWqRRYmDGQ9tz5lOLANxS9eOGTjncaq4HlEKDfU52ZisQk1NJoNLKTcZGAjhzJGzvoGjJXP+Ns9gqgLOTcsgSm7CsiUuVO5iGipsHJDrqsjN+ChkHM6Mc3SUGehJ/HDs2ND2yhoRmwmwm63gvrcEEW4uteWsxlHLX664gv+fl6ywbOBmu6ZpbznSB2DvfcZnig5OM7YRLaFr81IGcKxFWrrtyeQkpsBRlYiN7ZkfhpTbvd/8wh/lrAPgwED8qCvrvgrQZJmKyflCp2uabA6Nh8/v5Uoh3oBAMD3Nt2Nb/U8hOEIzFJRfkAqDMFR9VI9Xn3zFKwqkJmRpNw4jp8cTCKY6mAMIFAnlNp678IWhuxQ7Hbcqtkhq3PSNqI/7hEjGt0Co46IMUuFHIp1hnvnfphyz0aPFQo7+vXaG/G9TXdL25gQgc+NRrkpbtwIDoZdJITVImuExZmlGIDR6MDlLQ9jYrEp8rgss/E+Yz7OwXzUoMcvUW0rlj0CAgY+bb6IQ+36iknZKKT8RGb8eU4ouGMMoAPeLdlbfaXPEAayFqScPwDAmIEaanr1UhgAWNKw3N8s/PoE2b7V7MFqq+LkLAD4efbPyIBjZPY+f9sGcZj/2+IZDEceDAwf2l7tliG3k4cPzIbIjQ1Tel6S6knNUm67f3zJ/+Kt1z+F27b/khYTJtewcZH5AmpXP4L8U98P3Skt2/t90rpWHL2uCyes7NDkuaE+N8pNaH1uVLIvP+8cyXKtJm/U9pmVekgSLn1k46lgXH72jJAb01D78WSqOdy6ieH/gfw7ghxOnlnKa1I2ee+e+V3/7Qop4lOXc0hwWqW9R2yAlNwMOOgAlxG2pJ6MsYLIoORmqTC8WUmtCCdwosf/AXpbcBx0Y4La6QFAt4jOfiwpN+Q+hchAQCBb4rhy6/24sjBT8rOJjOBSQDuXjcXpQd11yg3MimapqGgpb90v4ZKbNl6FZ4tHoslXBhRy06NxXI1VbkTsQeqqz2SHtiy9WcoJxwzludGUceXW+0PnG+5gz3TRUuUyhDDwzxPODKoW5WCqwADH77J/wA+b/4yZS78TeRx9pxnYGDdus/+b4q2Wb+PQUj1uzv4RP+2aib4Y+yWp3UgwWIADjEnk5mhjK47HagCAwQVORS+qaxS/NsZkHwmf+CqmPaLcePtMJcEekz+yUBIJ1RDZkhmJmcs+7v9t8QxGHv6CdIxqRls0WumNhEC7OUJRKPVmCgYBCIEz25dI5wPOpEDt50wIjGHh/oyzMLnJuAPwpFbnrke3W265+mVohPROhdQ0bllzA4ZZ3RXNtJlInxt9sHPcopTOaUEZh3Udh8NbT5LPp8v2qJNUKQN89AR2PQ5HV64Ggskl2AD+vbIeV204HFvsUTK58XI4acpTvznvnZTJRN22s+TcNBR8SCFHIg4ywpZ8OL6TfcT/HUVu1E5J51DomaV0ZGDRyJP93y0JyYJ0Pa0dNpzJ8x+l47HLzcYcl9xS7layAARMooPWEFUqKveOisjMt5J/oZuhmDGF3ISfe55Z/o3r8tw4yo3Ai+VDUS9G4PXuUe79KOSmHM6nEhcEZHMT/9pyDixbvwpK1FIkPBjzfBhC7+HhFGTgP9gc/Cb7B3hvJKpa6rtUQ8GlhJF2GRwGLLJwqhpyHgUG4GzTUSuO6tkUeZx8jsC0A1cAkM2/AHDeqJvw3fZ/+n9HOTvqICk3FciNIbhWuXHq5Obs4U/jv2ub8ZUjlQUYmTyEMn8gUd6GbzYIlBu6KGueF3F23VLkitwnFD3K/ar3P3/kidLfFs+A1TgTiyo/i7VaD/lPo8tClzFMfl6KmZmeG3JQ9glD2AvMhC0NkqRQ935IFGpUv5ZgaQVV0Tu3ZR6+v/nu0PdQw3vxwebXUGM7yjJ911HLbgCBmqtdrZuCtLOeYU2YkJFN/9oFSeE9jspmKQC4hl2PO47/HATktb1sIfDl+99AkZuYUz5cIjccBj5svI7JmuAO9Zvz2q9FTIDczkpH7E31JiU3A4h7X90kDdCmQm4ootZPCvvchI/zwhwzsMA6y9LRFBm/8SV/zbooLnkxzuAabxlTsWXMxNDxMmiHk3E+RlJNKVFeP5QbueOil3XXAFIcirWRRgwwbY/c0Lq5uV+EATCOgpBJiPpmtWa1mG+7rmsiHlrzKSxvOlp/QMTCdrpZoQGBkjI4OLNnBkMAH2Tz8HHzNRzBNFmpCbbiIOl8FpfnxrIcsigls9O3FRV9Db/2ztFl9gaAA/Nv9bt8KZ9RReUGsBnXkhuPiEyF45NSZcpkV/X3MiKu5ZNaFjxPqtz8YNPduHTtszhtSZtjLhVAr1a1C6AOTJa7sjRnZYyY9E68/9+ztRMpHeh3GmWWgghPQvwlPliYfGVgy34yLrz2JpObCLXC0Cs3UMiN+kke2rMtRMR+se63eGD5Vbh11S8AANmIUHABplVBK5mluCGXoUJWwQiEOnZUbudNOZncPLH+KWm/5Zb3VfNJnFq/HbflfqctR+2fvShUidxw5lfJEixJ9QYNKbkZQDR1laSPPWNbkVlaozqS8LolhFW7DdTrBIxSGfnXGqTj6ZfgDc4lI8aEpNaLhz80+vHRTmnHqPF49vgz0FYzTD3Bx9KRx5MdWaifMnWWy8SErlPQTlOqrWKWctaWkn1uxooO6JArh8mNJ39zYcAwREU1QF0hW4QqKKPMnVmOzfU+VFFmKSFEqNMwShYWl6aqR4KBoYYYLbwBOGrwvw9f9n8zAKZvliIRal7p3EaZTVU8AAaW3KjROFHkJnReHyaM0jUqkBvTNXaqZilAb76lEKaBjWYQFeW1d3VxTm/xUofMuYM7afPnNr8KAKgqct9HogfAe4038Vr+crzbWAbaQGxwVCs5kCyXCNs5J8hhYrkmbLosRDhMS5OLYLsBHlhMhEB2k/yteaYdJwGi3LYNxlHSkJsgFJwqqpX7iVKnAXNDJ8AFdnWOwEZ7jFvf8LfjpEyQt32i0THZfaj5FbfueiUlqrVUIjdS9KVm95aecdpjq1uPkMtO4Fu2elQGLRYH63Ge/1Mb5ahVAYHPmHPwg+xDOLNpS2Q5KkHuEM7SQpLyQ6I2OZhm4dk9h5TcDCCGVWVAm2qmtRC50FuhpCccuqBdD7aSadTQdT7S4OyRm0BxUGf3Kio5D6uzMwDorh6pnBClOGRQbw7HbeKb/jZZuUlIbsg5bZnR/m8anGJ4DsWMoQvB+l4fZ2rUjXvtMgdEeA7FwGELEwbjclQVwlFroWgvkyXyuVHfeQOcSAu7ZKOjN+zHw11/Bvpmqtu6Q7NPr/wayWk7zmFQri7Nc6MqNy8eeQAaujphGVPlmWsyxTzy+nZVDXoOPAJ2VQ3KuZFg5Bm38xy6Sk5ahByLV/kqLblA0ReHYsBbODNMbix3IhL1ynvzWbRWBxOBQDFS1FqyDptvluLRfi6CO8rNvbmbMIW14M/ZG6U6zMy/hrzSNj3lxs66fi7MkH1uSjbyL9dr74NOQqTFMv3/c24pt75dPs8zS2mUm2qU5Nw0SkZzmmcqSeBB04I8sus7kFnfgWV1B+Cl8qEouwk81bZnCI6yHT8UGsQHR3Kchv59V/K5qTLz5NhwCU/WnaY9r7b52PhVEzToYgJ317c575MLCIVEvhcLcEP2zgqliJBy45FMqtwIEYS1O6pW3+o6kEjJzQBieFVGaqbZcjnSLLV89RHa7Wr+B2lVayaTG7NCcjKv0y6xgEh10sUdNXhGfDS0TVZuwmRNXYslqnMXIoNfVX0AW/nB/jbaUSV1KKaD6aIRp/u/zTzpdF2HYjAD3SIIgxxNwvEpsmX9e8qAuxlvw0ny1E6JRn45FYp3p4siN95M6I1nN+OK78/FrXPksH0hHFOE6u+gki8GAIKhmuQSyqlZaJXrhsr0lAwlFLynJod/19fH57nph3LTc9CRsGtHoOegoyCMDAxjuL9vbvkw/Hrx1wBUbivVIllaAUAxc7pNOa5P5q5CodahknLDDUjE31MGRc4lsLccCzSt98kNNcNFKcDMsGFxLvnc5Jgt3VMPKyJnyuf75CbnOfHKCQON9uh2IkdLkbqABxtEWIWmyo3a5p/Pf1/2M/GyJOgcihNOggDAaCWrrUOOegzqDZTLer833TVNxQzbH7PUyPzI2P15aSkMeZVvyZ8nAXvopodYAmryrWPZhoplAOHlOTySS8mN5Ows+mN8Hjik5GYAMSyfkTptk9sYJ9q0x+pIgrM9egAVptM3+sqNmmdDKGYVhJWbThFPbpaI8HpSKrl5B1uLH2T+iip3ALHVcOeIFt2LDDYuzKD6rcCURiXm443NsXWjdfDAui1/gD30w8HaVM6q4E7SMepTMZLpI8gW2mdq/Y0MV7kBC5ul1NukOXsAhLK0hsv2yI3cFrxBkkHglFIGv5q1RrmucB02CRER4XK8tpgnhC7vkhtdzQpGTiE3gZKhRksxw5mbOoYvubPPrG1Hbn6jn9VYh8gn4y2gaThRbfS4vgxw1by/5MZVDGLkdO7O17PK92dpzCoq6DN5b2kxLt/6IJB3203HduDZ7/nLL0CKlpLftf+bCTBuYyeJjCyKbNinJSO3jbJCbjYc9imZrMc03choKadCzh9CRDoUC+j7v8NZkOvH4J5y45Gbvik3PpTFTRkLm6AM8NASBypoaLjscwMtufGUm5CC43ItTlNLaB728ExgSrbEJP+3k3ldnoB49YgC9TQwWoqwdpwg70/k9MtCyrqfeJEqN4r2uzfZTTxdTdEnDK/KoIO8zU92zcEXMEt7bFRz0mUo9sCZw4a9HA66NVDox+wrN0bgwd5RQbnRf6iyz83j+Z8CAArFalyPy8ML7Ln4qPEqPmC+6f/d5n4E+Z4i4Kqykc6BMZCyCDcWMHvce/HBpjnyfTDh+9zQDnhkRHj8EpyCejuHGXhS2m6Cg0coNypCyo3hOZDqzwvCLlXlRh4kP9Cblf7mQriDB+3k9PVjYMiTe86zsjurDredgpGX378A/JRKKrkxOWAZTluUTmHIbHLIlIlognFj9k+R+4LKM1g1QXuVHFkrvItqEbG8iAbSc3TJTVSiTMA1S7GwQ7HXyUea/IT8Hm9t/xXQDizJBSuYQ/BAuWE0z41+8DUYxwazHgvMVn9bEdlQHYSSc2dj+8Fo7h2NCa5ZqmPUYeAgJDomP1MVL/rr28n5Z3gwXRbhdxSYpXQ5s516ezC5wMjmEr5TehKr2dHS/fSpz1Dapi7/kSGEv5K1DmNLbRhmBxMXAwIZWK4ZLZxmAaAChnK9AgNyApxcT9dahmd6/JTTajJIiTC51wmtY0Zgk125t1rAcZS0P3bpE1JH1eeGRpMi4LSBWYqF/cn2JFLlZgBRk5PNUl/o0hMbANqPDEDItECTd3GDAcL0bdNackO+e2+GU2ZBp1FJuVGThYX2kw/rMO5E3pRMZcbqds6/y92Kj5mBj4tXb0ni7csszDtHue/Vw48KHcMYh2AilFMjSrnJcAuPv3Z+eDtsJ+EiE2HiqXy4I1jYLAVWeZHSkFlKBMoNAJxUUucg3B08iIwvwspSIZuDgLwgYh4lHMG2+SYRil4zHzJLwfTS6KrkJjx7BIAJ5Rb/neqI8nbhOEoebWwN7QvDQHFK4FgpmUMqkZs+KDeqz41tiNASJxTcXbNM9UHozlRHnOHAgKk1I1TR/C6GqZilnHpQU4icl4djZXYnyoQQF5DTkJvw/dy74iJfuXG8UeQlEqJgUp8bNVrK+yZ42LclMEvpCSA16xkcOGlFBw4VDfh19jZZuangbyWBJKt0kl+GlRsGHsqYTPHKwi+EtnlO+twpIATfLKVcrNscASGAmd3TSL3CGJYJ+hKLvIxWz6FdOTuOoFgV+EUy5SYcLaXzuaEykW1YabTUUEFV1uxTFMg2Pl6zXR50smTG5kTdGii7M5yMiHeaNDVmqUrKjc5HKMrnxrvXkplRT9DCC2HPSn42/VBuIi7QURwG28302W1Vo1d49v3gGqMifG5yVglWMSxkGkS5Ud+t6mMxHLJZyktBXxNKseYg8LmRn0Gg3ChkZe1arJ/xQRS2bHVWElaIiFpOd74aDAymEVw/Bwu/yMqZiD2UWBaqmcEb5JkAvLWFAOqbIjCtsEsq58ummz5f54vQp3TssuoWZQ7RoaZPZilZuSllOEQMuSkKgJdFSLmpqx0dcYZfOvK5nvBmeikj4yfxA1kvKdqhmKPV6JbSPRSE/B5baoaDu+SGmkqbCmP8aCnYTXJ7jplxUyJglOV6eZZdnZk02+28E10SP0BR5ogZbjQ6FZNkH/oMUg4X+nbDNCY0itFWOLlgra9KMu2zCtQV+XqWlUPBrlKODZ9PfW5sUsYTKEnKje+/HfO+rAoRgFFpSdQ6qv56QaoRvUOxW7GKZQ8WUnIzgMhnjD6RG516o370WTvoPLjBAG7EKzeSWcolH9ShuJJyo3Fc5BXITTGTzLppuXkRsmTm1R/lRheB1pAbh2+9+Ev8fsml6CrX4HuvXY0fZg6CUJxkR0UoNzdt/DX+J/N0aHsGHJbIwBJAvRgRWy/VLCVch+LaCPNMJYfiTsMLv3b27/rRj1Hevh3dbywMmaVsI9z2GDiEADJkBfg8ypFO1UwISW1hQsAUHGcbS5FHCRAk74jp1Q3446qfSeV81FXr9FEkfens5HuibaWyWar/PjflDI81Sz1dPgQdb5WkrLUAEJVQOihcH0goOYgaGd/nRjJLRQQmGH66gmBbGRnp+Tx82gdQyrh9ACE3ebMEK+uEa9uFVxO/Gxq5ZHClPyDmLFUNqVodJIbTkYk8GTxNZXmQvoaC+3UiD8YxS4WvayCsylZCretf52lsKoJkft53wtCEcbCtnK/MBvXS1JuGipOqOekQyAZvHac4chN9GwCAXpas/84yvXIjm9EThkvuAaTkZgAxZWR14q7bWcrQeflz7BOl7RRZrnSgknKjabak3furWhvJo6WiojJ09YucNUS0acurN12iQtPZeJhZdUbFOnhYMsJxklvWdCy2djirmNuMYc206VLHlUdJ6sSpnP/1TOBv482EDXDcJS7DC7veJV/QDtd7uGqWcjv6GqZXbnyH4jHyZ9jokqilOec5dXkdWNGd+RosZJZylBuV3DgeRwYZDPKsjJFMT24MzfD235uexQO56x0fGUJucsOdgUhA4Aglw3CV6zWpI/p9ITfewhEeZKfPgSM3aobiUobHmqXqxDAIGyGHYoPkp4lCXBivEAAME+1kGQ/PVJSxg2+Glp/L98J5qkreGKUOJdPtAwxKboq+cnPsqDORNIkfJS1ifNC3hM1SykTNXfxTMIYOjfN+ngX3rS6nRNt60pQRTj2Cn57PTcihWPBY5YbC8wuqddVYx9SlOdAlxx65uRtfxf+yP2Je7l2avFb6aYAHq6xGJIYR53NjVSAZvbxyHjSBsFlKlyR2pzEFN+Eq/+/uurqKZQ8WUnIzgBhZk8XhOX1uCBV0LaBbrAul7RR0jRPHNGD4JEENBTebitIUzgvVa86N8rd1I4846Pwk1ERqccfGoQDHJyFp59TL9HXVdUS9pt7fYekhRyqzPiUkVpsVNdhugqMFY7DaWzXaRdW/d4VIXci3xmQoZnN+R6jCe65enWZa78X5xevRJmrd/Q62Zzg6Zj2H4saNANwOVSjOnDzcQXuzfdpOclkboyKcqlV5ngGY0bAYABzfKRGYSYYf4JQhmEBRSRLp5fvRqQ0V7fuSb4ls5u2bz034mW/LT8JTw96Bv1nvk7ZLbdoUKGfifW48hHwQ3NxD2ax8bU/p8KLcQvBSPJQYwEzUtfe6mwMDRD60KniAKVPWSJGTJnhIFbZdvzhByE2VWQLPOO9xTH6y/G5ivm1pJfCa4PtxlBv3Dx4m2zRaao4dXjWbKjeGEmlH22Wf1F5qlvIdisOq0ES0JSqu4Pafte6ExXlM4TadNavcazp1nctmAACerTnfib4k0D/pYOtOEaRDYFCipRIoN+WYCaRzpWQTjrBDcVi5+XvVf6ILI9w6AW3PzU5U9mAgJTcDjBqmWTxRA4bgk+Aw0OTO1mkHbm7pQqFRXtfJUW6izVKZbcHA5ZXVkh0Z2haFUHg55E83iuhIiOwYne1Jlln4aPHnKEYE8+kGzYJZFdp2NNuCr7Q+Lq/3pa4mrcuKypivUJjMdoiEpoNQfW5CoeKuCaA2QrkJyI1Tp41iMlaLA6X9q7IWRhe7sOa7P4DtqkWCARAi9C7U6zsDApMcQHOsFAp7/bv9bv94ySylVpgoN9lay30GYXJT7ZrhvPqt51OwS4zBT8pfqtyRSu/WkI723t14tGI6i58RVvHwd9hjVuGZ2lNQJ8ZI2yVSyABuCHAWHdZ9hrECgAg9R4PbGD16J4YNa5G3u20nW9OK2trWUHneYFXuygBGhtQncCjOUeVGaf6Tp6yR3n2elcP+YX6IfbAtbxYhopYBSDpvoWHGVLkR4e/Be38CzFf3KOjgqfY5/c1zI5Mb9+rKvb2jc1Xi4nxyQ5QbLbFwlRuu9BsCzM8xRLeFTiffQbsI+jbHyVxIf0eV4cEykye0jILjc6MoN8wjN7QfpGorgygkGw8HA2ko+AAjqc/N6cYqf3EyZy7h5XNwrbjdZWRXt6OV1fph05WUGwBAkTrrumYp4nNTiwKKIuMsFqmBOmNS7ylq0TwJEZu945N0TjvFOBRZRBZnjelMp9w8m78KaAYof0mm3DD/gzXdyCRd/6XeZkhRckPBKyk33kzYu6YXWs+YwNO1ZZxfKuPCC67F4a3b8LsXf+uUq5ilnIUzlWSKbgVpO8lriOVWMcE9vgL1cMmNAGBkAzUiTG5KfnkAsF5MxVdLVwBg+JKpLCYZAwYlb5TbbhZWfb3iuV9ueDy07ciezbBrMyH1yHuOwn3PnMUrN58x5+ANfmRouyE4RoxoBJQVPrJGGRbPIFPTjo7e2tB51ZnhADpR6syg2jD9t8hch+Ivb38UZ7a8hQXTfwYwFvruCr3DUUVyLFWjiB5FobU095PPFEHtNtQsldi8rkRL+coQj85zA8YklcavDyE8qircX3JDiUxUKHhfUHSfa41PbqDvHNwsEOqq3QIs7HMjEH7gpJ6mIb8XORTc+R1nltpVkwFikncmVW7C0VJuKLj7dhgcVwnDTXkgALCYlAKDjVS5GXAk+3hoiLRjnXajImDjXcZKjCg4HvpVihJkC9PPc6Mb5OWFH93GR2ahI1iPlE9ChbZMSSGg+/vWUXg2+CRmKRsssp46danXqMI72FqMVkcWBVlmS/ejW4mYM+Y/swxsRyVRnQB09dKSm+hoKTWJn9cGvJmg1y0sGOYQt3Wjp/n1o+cDer8BAxzTzQU4LbvC3xZaIgJA2XX0dhLwx71Tgd+x7+Lb+AN4zvUp0JAbL9JDTjDG3Hus0OUI2tZkh+K+DGq1GrMUAFjcDHXmJllDDHAiftTcIhS7xFhthmQGAXVhWADIZ5xvuGxnUd8ajpDcWl2DnFGNco+JLW1FTHInPV6G4ms3/B4f7noJZ7Utds9QyE2xFn/J/sL/uxrFEIn3lCiRD9p7hlm+TwigmAwTmpwpucmzMqZjp1N3LkJqZ6DcyP419HwPukR7Hg40GnEkS5JKQIZnlorjN5WWp/GUm2GuGtsm9OZw5j5vHsqfk0y5kUylLHpC6e2LM0stGB0fxZeE3JiZYsih2HufXAS1zYGohgxQsyHvSaTkZh+AIErBp82X8FDuWjy1/n8ByHZoJgCLLAJZKVrKa3wWJTfoRhHRDmSVyE0or4X+hvRle2apBHkqbBgoRJKb8AXOMpfj8fxP8WL+yoplS+RGI15azPTfh+H6SehmfGoIZeh5GEnNUu7gGuqgnP0tWcVGn0MoWsoUuiR+AmdVyWHfl/O/h+rhqVeGYuoKwd1VzyZjee0JEGB4c/JkFAy9b5ROMu8LHWYio5CbvqcNUMFFWLkJFvozwBhQPayEsSeFzUceSshqTas1NW2YMmV1aHvOJTdFO681C780eix6ho1BkZuYv74xKJsJiQweUKiT6uvBslRyaYWSVfqDn8lwyESnHCfzdtgs9V7xL4zuip8keFCb7As9Vzg/dD43CPLc6JWbZOQGAL6feSh0/qjRO2PrGhUtRVGKmfgBAbnxTK9zyodrlRvTdeAWyo04yk3lTNY605Pz29nr/53A56YSkuS5GTGyMTqJH4JEhjlhy2NImsRv6KA/r5Ij8PH4D/N1AMARBWdmouYWoIvLMV3CPUm5cW2izESz65T2Mj+hgnITb5YyIj66cCV05Tj1TTID5zBilJvwfX/AdGa1I1iPa9OPjpah19eZpSxmSA7FkeRGrZeyxZPoo8xSqnITmAU85UZzTVOgcLxLuOjAL+zQ9aPCh1V4BE/1uVExvBxEWbEMsPj4d+GfRx0TUm78Y5TFD53f8V8Ivb4IORT3PW2ACkuYUKOCvE76ifUfxsZRx+M9Z9dj1FFybpPWTODUWYterfo4YngLMpkw6XHMP84q8Lq2zwD0VtXiIfMENO3k/jNyTBDB8xprtWnvSecPVqWsA0RD2y138VFbmBBSplznmOHowqENO5AEoehO7/54eJ9P7BjzTVDP2O/090s+NyFyo14n/JyPPz7eeZULBrD4Fqib7FB4/YI00GsGcNv/ppV3Ixz1UN5USbmRowTpk2C+SVtnNxf+NeNQ6Zt0/OQ1PjeeckO+p6yw/LqnGYqHHPpu0xVgvgrQoeShUaNXMCzodCtFK/mheszE+aXr8bXSN/EXewYKoq/KTQDJ5yaG2+g7cVe5SeBQbMNAkSUnN2pDHhtjnqL3UIpQbqiZkAmB9eZhoePUTsFQIzHcSlVH5bnxHEldJc0bgLwSdN2CPcIZhJiQc3NkhB0iQ0n9v7xnwCooN+sWfRTvbF/qHJsRWHr0qQCAoq0fEPxUAZJyk7yzK2fyWDUpcLDukyOpBj895GuwhRmaqXqd8azNM/CX5guQz3NwhfRSojgMvdq6eMOOeodtGceBuWRnIwiaQM6dqPT2BAH5ggm8xt7jHzXOcs1VyiuqpEYAhNww+IOxzWXlJljTjPvRd58zZ+OEmIUVI0OoNT43WT9aKvC56RA1WMQPB1DB50bN9Iv4bNDaKnnOrjGfRSVy40UG0T5MqElMEeSm0jkUq6HgummTkQ3SShhMTQMgTxe8cjXFRF2gwvVlrLfHgiPsJ3Ukc9bys0kSiayQzVIsNUvt3xAIpMFO5aOVZiwCfo6brChBcE2DJg7BJjFLNWA0nuHvgg0zVnp1iEP0IKlL4qeDrvP3zk1CbjiMSBKmV5fkeo1l0eSG1s3zN6EosYzfyWXhREt1slGh43R3L70vV7nJRZjh1CR+nlnKI7rabKqW84rNnb1yeKwIVoJeW3OQU25C5cY3S6GCWQrAFVsecI41BZrGTHTO79KfEwxQlckNay/B3NzlZ+cVAph34rFYOfVg/xgnOqPvkwcPd0/9JDjXkZvwAK2u70VJyWczc/GlTNgxOorst2WdsOcSz2oVH+eZk6UP3PotyL5TOm6i3agtP4mTrOQg7a+oYUo+N4Is+1GT68D3Mg/hl9m7cVP2j9EFR7QxNYM2EDxDwQL/miKyfvtL6nMDOOZ1HS4oHxddVehDwSl0kx0Kr13QFbK5Ge5Pue9HZ6NoZ2E0FgDbiX4Lh4Ir7fGANizAmf7fjMlRZDrlRutQLEI/tKiU3+hVy/kGVT+pd5sr3PODa2dFmXz3IjVLDSX0Z5F36nNDMwiriyEyCLI+UxlcR27I5b0EeTYzpe00cV3TcNlf4jsN92NB/uuYjGbtPUU7F3vXF7hL3ITfZm/V3qlT9yQOxQaKEZkzze6wvZ4+p6hQU//8CmapMjIoM+85W4AQ2iziejmZPBOP3EREKhgQ+LDxOv6j/WUAwczZG3y1bUkA9a3Oekt0UMsgMEsV3YVSk7ZFj8ixig7Fwf3RSGmVCHjQrVgcRW7yrzciu6Yd68QElIWBv5eOw7rCMCkDbiZB/eJQNrLOgK7UwZHb5XJtpWtU1cLLMk9prqC7N+Gv61Syc1qfGyYE/NXQAZRcJ9XV5jHSceOtZvcq6uQjgXLj1y1Yad1REGxk2FY4hpQgceW0KSvxKfMlAMCRxvaIMvV+d9/JzMQnjJfD2dbdSU1vJud/nwXk/Gcd73MjbxjH2rV1GpsXONieAF2gZRKH4l4RnwfMqyslqUKTod1TboTB8ecVn0NucTMyq9uchY8jlJtMdycm8VF44cB3+UvVAKpZCtLDiXUoTmyWiocJDiEYqiL6sX/YZ/rfVAZW8N0TlXBvICU3+wAEccjqIsrNcPTKHQRVbmBVXBPEG4gsJWcH7bjVMo4tbsIE1oZvZoJQWtqxROWi8HBo7zacizdwnvlGaJ/FShiFTnwv+3Bo373WuaE6Rik32a3htV5Czosxq/zmyD6dDE2VmxxzF3/TjlsaR0KJ3AAQeudJwBmkbsv9zv/bV26Iz4XmJLR3D3eLJ0RTcF+6574Sk8wBt+RFS4n4jt87xqljALV9BVUNS+aVOtIGMRyb7DHoENXobeEwSsG7OtNYEe3EnhC2JlrqJ9m/4KHctVId6zBFOiZKBWukS3JoDvmwMR9wV+Qu2blInxtB1n/jbtsrs6y01MjZ9cvx7tbFYXIT09b9qnmDDIPfsGxhYmpdOyblv4bR2d8R5YbDFFYosu0C43W8kv+m/7fNMloT8eWZf+DXudvDPjeuWaqlerj/TRSRRXmU0+fJPjeKWUppy6r/h4fisB0OudGI0xwsxpbuoBvhfFkU+Rqn76lklhKsDAEODo6FdacAADLbHX9AS6jRUoBR6MawbRtxmD0JgEym1QmuXrnRDOU8KbmJH0dMcNeUqJ8wbhaTiFnKInVnabTUUEJ/eKogDsV0FjyKdSnmFrqEQRmca15fRLQUrZe00FlEjaNS3VP/Ed0sWl1MkILDwo+zD2r3qQqKiPO50QzaIft+Qv8MHbkpI+PL0zl45Cb8nHR9Bn0mws1z4yk3W5WFUiexVrk8L/FXjFkKDOguOIOBtFKysP22YjGy2GUCULOULsxevnzY1NTGhukPFjpyE/+FlCBHMzFCbv7DfH23lBsAsHk4WgoA3mUEidwew2fwJ3a5tD/KmbmIHF6yj5c3kirelvsd8obz/ks8KyVU9OAsOEm/Sef/uclC7fqxpd8KnZ8kiqyb5oFyuw1LGJi+3VFAas3Z/rsxIGAKO6Re3Zr7HQ5gTf7flmHGvs0oZ2OjsxyQG5HzyfFwkqunknKjU8Cqe210TnyVaFMyhOtzE+9QHB/JNHq8o2LRCYtKbkyzhGPO+Bu2v+MW2exnOHWwLLlfy2SLqNq5Gc5yIzbOa5iHu1t/6e+nCq3qc+NH+iVJxNVPDEMhVg23kAnUJwQOxZyl5GaIoe8tiiaNozO7PMohn5vmjecAALIo65UbcjiNlqKQbL4R1Q05MrugYc2Siaq+F9mlLWBW9OBoQOAQpg/XpOTGW6ukU8gJz7rcWZWuY1MdDnV5SHTQ5bkpIeP7JWU9k0Vis1TY58bzJXjA/iDm8aMj6+JFPARmKQ0Y0FvMh65lErOU974ZuJu7RUaTGImTC3eQ63qh4JWDQr1ZWS9RGLtYRK4P97+01EpXKMGUFAOzJL/H/io33YaXDt+IzLXjfS9/Z/8Z2hel3BRFNhhYIqq2dOfnAQAWz2qJCIOAMEk0E2OoqupECTmYFVIzAMkUui35ycH5nnLDTamReb4XzCW59DnpTF8WM2OvrZ5jggNcoLi018/fVUAWORFWNqV8XSzI4WS7fZ5KEsc1FXHmwlYcsXOBQ2GEwHnGQkxBQMY4XDNOTBPaKcZF7wT8Vc+j/AYFGCZM2IRsrhc945ZL0Whw33GZy+TmgGlOxuu8YeGczJW4av19GCVIZKLkCiArN/7Cmbrvyldu4r+ZShOGA4xWQIRzrnlw+mvPLBUENgjG0mipIYV+vEtqlqIzROpH4RXd1TkdAJBDSetzQzsFGi1FQRc6a6wJZ0x16qF3HK6JUG5yS1pg7upFdofe0Q8ActneSGdmSm5sl+0vYydKx7xonwCAEA4CSTERLHFkjc7npsSygVkKFjLrOsCscAeg6xIk4uW+Hi8rcAlZfKH0Q3yx9H1tXXzlxn0/X808hRnGIvkgQ3b89DeTvDceWWEQsDTkjUFIs3KLDGqVIvC8a3QiCI1WiWVwHS8cNrlyU1aoq1mUB5H+KDdv4RB8/B2/BuCZpfQI+UaVOLJvNsOo74lctsRR+GRyo95hrSj4O3UKEBMCgnyjHALZbBFlZLXkRoVODYqEYpaiCMgNhwkuZdKt1szaBVis07rW58YdcD3lo4Qshts9oXPpe57KmnEYc0LT/aVnlLKn7XAmXaO628AAXCDm44+5X2NW/gf+MVy4PjcR9b3D+kgoWlWFR2Rpri71CVRVBcSkxwgmgyLj9PNlxecmmysAAjhoWDMympxY4TZPfW68bz5+LIhDpSV5Hsn+GEIgRrkJTL0chmy6TsnN0EF/0owJBDNaeXFALuWw4IKhJ+uQg2Ho9M0XUQgWNpNfMzWHLJw4FbcddCHqc9Hr7UjKDcnZol1ksxyv3BSFntzQOvphuErxXud7TfYB3JW9ObK+wO6ZpYrIkmgpC4wD5s5wB6xTzqTZqqfcEP8CGyZ2ivCigUDYoRgA7sr9Sj6GAVvFQU7x0jsKnM89cmiIcJZYv+7S805ObjwfkE4Eviaq8uzNrr3OlZZYqb8tQfaJMRQlsFJHrGIjn4SPs2uxpcbxoeHCiBzcvNl4lXDedWZjB8yGAqqWNEec4QzOWn8HBcHSIzqTqmyWMrgNZnCUkdUqJnGRRPVsdEQNCPn3QsEjyI3htgP6HqqNcDqDcFiyDNXXjN57kADO1CYjVe/x25lHAQTRTOr3LqsbDDOEMykYwYLvttLyC22iFr0VFhb2PAFknx+5RWVzgXltRX49AIFfZO7GlXgEgKPgyfCmt/qWGfK5Ie/Ncyi2DM19ud9yJZJTaSKYZxYywk5EbgQCU6pgDCzBArSDhZTcDCDaCm2w+qXcGFqzlKrctGM0/j1tKrJvtaC8g0PofG4IvM5ENUtR01DRyOGPB30KK2sPlY6JCvmukcxSYcTL1CJSuaEdbUB0omcsM8w3letS5SZ5ThRd6GdRZP1FO+OyKev6DKkeSrSU57gbZZrxwnXjTDff+PYdKLsEccLBQbi7k11YVuoml5p8x+o3+RGk3kwik76vhSYNgAqvZkXieBlagRqqskSVm/g2KwST7t/sVQfIZObG4HqBH4n3d5T64ylsw4Xjh8JK3D03uk2XkNFEqmhIv/tfnXKTEZak3ACAwWyUE5qlmEsOSsLEnPw7IuvqH++FgisqFiW5XDCp7UeRG51DsYc8i353QVZohnwFsxQQqIue0hrvZ6Qqt8G1dMtjeLBjTJZqPTwiPMHoCMcVkA0804tD2U58PjMbV4hHwcA1SfycOh03+j3QIdRed7wT5bJDwrxvT11Xzi1Y/m8EkiTH5DAjo6VC6jCdIKXKzdBAS7GlP1YpCBEMaPSjNCGvF2SAo7lVwKzrxfYVYxMrN6pZ6kfWfwMAri1/HhY33Tk/U84NO60BinKj+WriZGoDInKlb51ZSu3g1JTyatkehDASLfGgXtdDETlfuYmKdAL05E6OlmJgnOMcc6lfbhy8NhBHbtaMGRWYP6SlMALlRqck/IFfKNVbNktRh+J4ZcRrj0Uyw1X7L6GQm75ESxnuwOoh0yIPqrl+JPJzLDFu3hFhRPrteCTU2uXW2wirqSpkn5to3xvvuenKumLrX2CYsrLiKTeJzFLuBR3Hzoi2Q3kmVW60PjccQhhS26/WrCzNRHiJBQqtcuOb7oK2keXhsjcKebJV666JZkWYpSihYJD7Ua/P6sjXuAqJc+1uQ/YV4zAqDvTe5MxTbrK6+yffZdYsSf1knpdgK2tLgQE15ghUm3oXATUVh7BzWLzoPwAAhsExbtxmCJ0jNE/GbjIJkkBuw4GRPjdl0u4c5cbzuXFqvLcw6OTm1ltvxfTp01FVVYXTTz8dCxYsiDx2xYoV+NSnPoXp06eDMYbf/OY3u13mHoVIbueUT2N+x2IyWbqVw32FFD2ijZYiiFJuHrLfj9MKt+Iu+8P+Im7qgCiZx8hN1UQ4FNM6RoEBkUsqUD8g1Yymq5OKMQjCw4Uw+uBzE2GWYoFZSofD2XZ8rP3F0HbZoRi4sDzH/9NTiaJmh0JJ4hcJ9xnT9/JB/obfiWuXlKB5MyATDrqOVkWfG3c/VW5Un5tAuZGq6/yu0Nl5i0UGZetzpSSFAIPzP6rc6NuRl2yxd7lbYdNTfYLjb7c+Ip1TQtavr5+UUUtuPJ8b/bWnGfJyBwbjKCGnVY1C353wyI0Ru+AnKQAAQqtTc9IOOJjkg9Qv5SZEboJv0ifiYNoIy+XiJG2ZJZ/cyN93qTuYOBhgGIbANDSetQEA3jrgcGdC4D4+XYqMSv1GgTvX8chNvrYtdAyddIhMQTJ919qF0MKZiFETgfCYIiCkPuLoY15GQ3V7+MSEyk2SvrKEfKRZyiYOxRDkW2MYumapmTNn4sorr8Q111yDxYsX48QTT8R5552HhoYG7fE9PT045JBDcP3112PSpEkDUuaeBBe8X+yGmgmklPrKCtYGuOTUU1G5YXrlBgAaMRoAc9PRGyG1YDJrxg8yf8MBrBH065iINlIfnfwep9xwlCJ9boI6juEuUVGKispdMxnNOMNc6f/NeXJyo1sFuBlj/HpGDab/yn9Pu126f4PhfGt+cC2X2EU9Ie47FFcgN24boM+/CmV8LvMCgED5oqCER3Uo9iLGwrl7w/AG2wJVbhBBbjSh4FEJDYPyhRwKrpSdVJHzoBIPO8bnJlQ3QzZpAcDLXA77lnxuFF8jCu/6Ud+HvBYUg2HYFcmDh+3dTiSUBVMfEgyQRsdgdrcBgCaZnPesOFp7RmEECc2u0czaK4VVf8x8VfrbZHbgB0LIpi5aqopHqASkrSqVl2pGiZU/8RHO7NOrc9mQSYYNoyJ5Lrq5t/x2aAio6gSDQB0mYxYuQCFrSe2nmhc0vk7R/jZeefS39wQpOvPANFYvn5gwz02SvtIQIjLPTZn2HExxMh+qoeC33HILLr30UlxyySU45phjcMcdd6Cmpgb33HOP9vjTTjsNN910Ez772c8in9c7dvW1zD2N/ohwzsKZYbOUoZilmJDtxZV9bqLJjQfLTWqmKjfHGZvx1cxTuD97nXRPn8nMDerTR3LDhIhMb65TG1REfYQXmrKCIoSR2KFYp9wURN7Pd5G0HA+qWYrmgPFUqyjlhivRUpEQXvH6Z60qdQAwfvJ6+RiYWDFqAt7IH4xNIggTrjSYeu9X8rlR1B4/lF1Dbg5n8QsyhpQbldz0WbkBjIwgK1JHz5JDieE0Zil1uY4iyfEREKhwm1KX2lBRRaNkGMAMJxtzJZ+bFc1H4h9bnASYsWYpFwJBpx+1DMDWnZPxru1yyoZhRi9UOGap6PZyrilH+mU1yo0QDDmNWSofRW4iHYpJmxHyM/KXPxGQQsHLTCU3ZmXlxiU3pxpr8ePMAzA4h8KrwJjAd/A7PMD+Cy+PfpekMtXYvSFS6SiLJIxNAf3MnVBwEVJ3r2ibjZfz38IHaHSlr9zEs5skPjcGRMiHygPtQ4UI3o0TCj4EyU2pVMKiRYswY8aM4GKGgRkzZmDevHl7tMxisYiOjg7p32Bg2YJlMPrhExAdCs5D0VO0oVb2udGbpSi8dPRRc/ZDjLrIwUBrlqrgUBzld0KVhJkj3fdL7rXXyEkDW6/IARCYznbhUEPuiG1hJnY81ZGqArJBEr+IDzoK9P6FwdDOAju651AcqdxooqV0YMrsV4XOrGfmwyH8/5pyJG4f+UHpeJNXSOLnXrujg4SCK/Vg/n89chNAXa06VD6T7z9pZtoo+JlT3Zm8zSr73Pjn+spNUAeVnJdY1jcpe8pNuxgZKts3S0X4N4xgNOs2g8G4a6wOH5+1gnqubD4y8K2DEa3cBEWjJjsKgM6h2Dl3ydqj8PmMvML2GM1abUmi6yhMd50271zvmjmNWaoSuVEdiqsMumwNk96xT1i4s4yK94SsELkxMD8mDxXgTHw8fDnzLN4lVoc4ybjxW33z4Kaq6VJda3khlHtKADBjJndh5SZMbj7d4bhm/DJ7d3BswneTJAkkA4/89ujCmXTyIICh6VDc1NQE27YxceJEafvEiRNRV1e3R8u87rrrMHLkSP/ftGnT+nX9SiiXy/00SwX274xCZqQwQAFppLArKDceuYlTRSye0So3FFGDKJ3lj0M7ZuZ+hguLc7THAk5ji/a5Ceq4pOqI0P7lww4P2ew/a87B3Py38THzNenY05t24mhja2Q9KHRKUpsYJuW56QukyCEGtLGABHgzn6iIIe4OppVIq/c6ogbKsC8B016TCwNCyM7klRLCeftLxBkzvNaRLJz3ZSVwAZXc7K5ywyBsSMpNJLmJMHnR49XUAY5ZSnHG165a72yL8vepJiYgR7mxo5UbMmgJwXxFxBJmIp+bnOkM0J5J2i/Lfe6jasNEZpyO3FRYRV4FVW4kh2KtWSrs4wMEaouqWjLpt6zOee+eCdlkWzbk74SD4Qn+7th76OXy5Ez9ftQV2jmYrNzwgqNWoYxT2Bp/nxHz3qiZx/GXi/bLm+j6F7kXdysZfT9AQuVG8Mjj6Dch5T4izut7A/tFtNRVV12F9vZ2/9+2bdsG5TqGYfTToTjweVGT+IV8bqSOrRK5qWyWciTSeOt51B5at29lHsXpxmp8rvivmHKEr16ooOTGV20F8P+O/SUWDjsG32r7ijLDELg884S2rPe1L8MnFHt/FHTEr13UKhmKk0NO4ic/1y53QcQo8pLY58ZTbqIaW4M867VhKLNFL1rG2U7rWFXSDyoevI6rnAlIalTGXC8nTl8+CXVpTLXs/9EuWBkN4RSKcrPznp08NxEOxcq79kgEJTch5YY4FEMAv1r0NQiN6FDJoVgerIlyoyU3wW+BQJkoQ7+0hH+gdy13uQBbmOghyqJ3H+OrW0Onf9QKf09JousoopSbrCbPTSXlJgSlkdF245MqIcBJHx1SboQBAQMNueGIwhJ+kvR3j6JEq+2VG3JYeo3dCy5M3JT9Ix7L/x++k3kYgiVXbgDPoVju+xsygVo4HG5un4QLZybJHWVARB7HyeTYCYoQwe+haJYaN24cTNNEfb3s5FRfXx/pLDxYZebzeYwYMUL6NxhgJuu3cuPNoEJJ/Ojfis9NnHKTd1fpAfQOph4skZEapw7RZin3v20l1LKwTT50LTsT6U9CIzfoTPhf496NL427CttL4yVTkxFDlPoCHblpFcP7rdyo0VI0EmSZOARAtJJBI0hUjEQX7s9eh0/W/8ufkUVRILVd2IrDuD+wCANcyStzzPolEaXK55bNOHKjujz2ZfYm10dVki4w+xYZKWA4fqQl4gcQcWzIodg3/7nfkWChFdCLLOvXt6dQjZXNR0Fneavkc6Pe50tj3oU6NiUiWopLf3mO9jSZWhjBbJq5kx2bm5K/hHcfOkJ/FA8roZVCwVXofG4AhpW1znfRKobhobyjnIwta6J/AJQjF2ml9y2b83xyIQDbMOA9i7DPjeEfF4W3FHJT6f4d4hLUxSE3zFebL8s8hVObtmNsri2yDEvI35otwspNqxkQsqNGuH5tHIDFwXri+zCdn5EFE5+dHqxvZQgec6/Mf2aiZ6RPeJ1oqSGo3ORyOZxyyimYPTuw3XLOMXv2bJxxxhn7TJkDCRbTccaBLpyZCfncUEmSg/Hg77iQ4WGmRWzxCRyKY2oe1ai9Djs/vzHU6esgRHghQA/0fIvJnUxtzpmJ0MU8GUT0LK4PUB1EASdTqTdD76tyc0P2TzjTWO5V0j//TuvD/jFRz9obXHUmpCsyj+E95jLctvraIPS3rF/BWC3fhoHOUtD5eevdcOHRZxqGH/8e45SbP1vnSX/rFs6MwsFsl3usrGztbtco3P8zbfeeUdmhWAx324QSlSbApJQFgDNAevd3cmkDqlCMXBzTKStCuXH3HzWiAWeOWoV/jX4fAL2JS61/hnzn4YSCYTDTJTeq74eXXyohYWF9OBZwB3nFX4yD4UvH/gJ/G34uPl26xk8Id1Cvfg26csRiumq9qClHUm5YMBCHfW6ca88Z7fjdaFa3CS1545sIyxzZN5pg77Jwg/ghJhUb3fuTIzereTHkc/Oexo34yJR/Rt6PLfVzAo4LM4PFTSyqPwFdpRop4qzKzQkEIZB/uR7ZdWGTYu4wA/mMUy+deZszhteGnwxLBOkBPJLWaYaXqPCXXygPl8eLoajcAMCVV16JO++8E/fddx9WrVqFyy67DN3d3bjkkksAABdffDGuuuoq//hSqYQlS5ZgyZIlKJVK2LFjB5YsWYL169cnLnNvghkslvVHgUZLyXlugpWegbByU9c+IbLMXFVHomgp36E4thHGkxtAvwClCtWHiIKuxmt7tnC346h287eoPjcDQm50Zile66tCGX1erUi801iDv+bcGQ8LnCVVu7SKf447G7Ny73L3hzGRriBOTNo6qNttGJiz7ezQfi5Ml+AEZ2wxD4wo1YEBDqOxgOzLjTCanU7UG0g8Eh3keyGOhRXw2+wfnDopJtIki0LGQbizSpNbbvmVHYp51iPX4YFYjTAqk4U+Tyuux6+yt0cusUD/q8Lz1bhg6hq8N/MWzmh/C0BAbmStJihjgtUuk5skZin3+xKQTZL+b3Kxu40L9OW595IkyaCHDLP8q3lmOAGGrdVT8J0JV2CDmOq3oSmlRm0ZqtpCKh+AyYqSr/hyJwu4HwquyXMDABurJ+HFM8Zg9eHh1e516/kJxpBZ3wGzuYjcslZ8cuM8LHn90/j8rqdgC0Pq06t5oaI7gQpZzRewXXLz9MZzcdtbX8ZNb3wDVYTc+IkueaBYqqg6WGDaaGcNLN0EzmYGDMGlbOO+D6dmPPHbDgv8sATDXiU3uz86xOAzn/kMGhsbcfXVV6Ourg4nnXQSZs2a5TsEb926FQZJ8rNz506cfPLJ/t8333wzbr75ZpxzzjmYO3duojL3Jhjrr1lKHwoeSuKn+NzEwWS2/1HxmNm4nUC5SRItlSSU24CI9BORMuYqH0TeTcglkRs2UGYpvXLjdaKV8rLEgig3lcjNt478PqyVZZgRq71L0rGfxC9KBZC3q2qDNxLYPOxzU4lMMCGQW+ystZR7owmF86b67cBfXdwbyONWLFZwiKvcqGYpMSyDiPQaiaAqN0JEKze/zt2OvxfODj7hkHJjhNq5o9wEuMBcgGYR9tmo6HOjmKC98Ghvm0PKPB+m4H1e2/wIXjaPA+DmuYl41v5WxpDN5AHXL4PW3fZS+bsbuWB41Hg/Lso9i5pCRL37Qm4QzlDs1ddr8rrvkUI3GXHKo79lR2c/P5YQjlnKE1uUPDdBtCJgZQ3YxKTSK3L4k30B1GBCT1lnxWDHV3c4a0hds+F2PHPqvdI7zwoLXMiZkStB/SZt95oL65ylNrZ3TUVuWEBQvBw8rBCtOmcYB+PRWbMFDGQEh/dkHbNU5ehb59jgu9+bq4IPKrkBgMsvvxyXX365dp9HWDxMnz4dIsHgHVfm3gQz+sVtFJ8bYpZi8tpSqnITh5xZRqacJM+NI6vHRVlENc+4KBIdTKa6i5J6ULOU1+m4h+aFoxCoM4zBUm46eTUsI3oNmyTRBQCcgcRbEVzEkxuLZSAMK3K/TG7c4iMuq0aSRBFPDsNdy4mEglcgNwf37sCd2V/hdusjWCycqLZgNXI1dDo5ufEGuW7kJJ+hqFw+SSHAwMvMX4CTMxZb5jO5q/Apca3Dp5RM0BzymlyAMxirqqfOh8FTYCN9bphATSYg0p0ZR/r3yANnBiC8iCu5jLPN5W5dkpmlYOjbg6rc2DCAwiiI4dFlJv4W4CooCrkJZvyBk3scLCNTeXViFuVQ7Dj4mq5pXxcKDsA3G7WOckxg9WIUziz+HjZMHGS3KJcSPoEOV0OACzl3TobbMdGQEb54SrSU7T6rjBH0hzScPgcLU9GIrZ16szUA7GQHYHrGSXyra682M5BlZf+7NDj33QJ044lPUkGe/V5WbvaLaKk9BhbueJKeqHcolld1ZkhObqoyBWnl3Sg0iXHoYcN2W7mJWjJBPT6qc6d1VOViT1ZWB94kpjCKR6z3hLbpCJLghm/7z2jCg/ui5gRmKRINpnnWZZbx+zbdE6IdkDc2R69wLG/v5rKN3Bv/PJMUPboSucnAxgfNRXg8/9PQ9fws2/5ifsnNUn4EF0x0k+zHA2KWAlDoMv2/o6KlAOAYYwsutOZ4J7s189QTFiKKuo5eT24cRN2PCQMTWJf/tzegeWYfGhQQ9Q3FKTf0lFlT9X4rfoZiEZA5btUCBZKIUmRx/tG3+n9nNJFOUaAThTC5CVVTCxumtq+R71rvUMyEwPae8ThqvbNGnbqmVUBunNLKOQO/bvkxzin+2u+fVKHKeVbR7gg25PWqss09eLXx1Ap3KcNUnpun3GQpuSH38sPiA3i16n9xWc/jseWONIsQWUP7zXNmoLaqPXCXIJKVfrLsvQEhOxTv5uRkd5CSmwGE6OeLjMpQnHHjXDxQh7xKqDYLiXxuXhLvc+vQd+WGftGV5GTANUtFdsw0/4RcVkZ4i9TZyjl9U24esc8JbdM5FIMLn4zolBtdBNUOMVZ7Tb1ZKgyH3Hizn3jlxvMfSaKoAeF365uRuJPn5v+z991xdlR1+885M3Pb9s1usum9d0ISEnozAVRAQASRIiKKWEBE4FVEsbyvoFhAwfrasKFgRxEFC00QRHqHBNLbJrt7y8yc3x8zZ+a0mTs32Q2+/PbLJ+y9c8+cOTNzynOebxN/3x0wEUfmFfsZE6a7LNR0AqOxW5sFvdaBfp76or7RP5/sic9wnvUL/K/z2ehcdWEVbW64mG1uQuYmQZVogeHYKY/HdYSgwQr/1jwxfYa5DlNbNCFI7Dj8XObG/dADAC92d/6FtxLPFuI4YY2ppTzwNxKr+ni7gms2+2X9REE8Sg1qVkjzIiFyvxG9pX73bOx4MrksR8v2FXADALv8JinViGoMXEYxeJ6+3k8DzyZb6g/OjvT7M4kIjghYVJtNOaBhUmb1HhawS5fVvp9er+/BH5E3gnEfBDlajZ6J48dznsp4BS2IQaoIXHdU90CnvIcyDG4GURhLVrukngfRWyo5iF94kUx1isxNGrjhg9LyEwLCMZq44FEwnHrzDQCSdeFy+WSDYtlbSjYotkKAoEYdznJNubw+KE11EBZPYqaBryYE/G3XHG3S48Ij44rXVhcgFzSYkaPdq776iEaJpVBNl+xWLB9PYtWCIH6yjUuWmBfa9ZjM3ADBBNcd5iHLAm6yArXGJai5aAXPzPPtumM0WjwZcLHzY0ylgT2QkbmBrQfxM/SZegbFFB6okHGTgxreVvG6uYQca6Lnlig5vxrFHAoqJUICc92gODfQBSB4ny5kG59taJbUcA0ZFAtxbuKwB5QfAAC0sPSQEj6hRgAn3jVTnrEIbqRzFCKcv/c71y/Hlx98B2q+/jxVlVINuUS1FBCAHzV2WbIk9Q3V5iYQxzJv+rIIZV4w5xNzf+VqKX7/tieCG0NiXh7nRtjAMkKwdaB+iJChkmFwM4hy/0tb6xcyiGjQKyXOhKdNhtl2SgwFO2ZuUg3AwuptzzxA/JSdLmUMYzcEARHdPfWWYiK4kW1uOHNjZbQlSbu+Kkl11Lxwx2JgadSUDGIQRq1s2PZqCnMTTRYp1LzIFpXCBSCJ8tUCiSnDfIDkouNM2conMQtpQtSFCsDh9EG8JcxDlgXcmADYOLIRX658oeH2iOJboSur4LlVDzBFDJSyGw+YDBXcUO3+bMMz5HY7iaEQaA3b+mMbCQ5uuDogC0tZS8gt9fjf34hfbP6Q2iAAcl/j5/I34YfgBqLKWLlGY2opU4RifiCosxV1wI2BPQOAIosTJxOSEOfGZ+IVAxZEAKa8/76wazwe2rQAf3t5v0gFFJVRXh9lPu6YuQ8IY2jDLlxpf0suwOQNazoQMfeNqWxd9JmQ2L6eGw436vRwrfNF/POek9DsBeo5E9PIQJEj1WheE5kb03oyQENmlMgGxXZ9z/0hk2FwM4hS8/xkV8UUkdVScSdSvaWAbDtZQhgKViUa4KkgIJzASQJoCiZz8zVFIJbVWyqpLnFhVMOi853FNbUTpOPiNZ/yx9a9/jboXixJRsk8uZ2JyVCZG4bk2DWRWkoyKJaHXXTv0URr2H0L14yZG7MkZel+R/WDeLI0Cdc0vz64rk+jnajHdHCdVWKD4rhF38h9LrE9aXWI8il1odgN4fmhuGdIWvoFLrxfqVFyg8XeYFDcgNotMcorqcEWWNlILeW64XXqT9VJ4KbJH8A+tafkg4YmP4VZQUsj93MSLu6CJyOsMBBeIFYj4IaYIhTzvh/8uYfMks5RmVWf6B5rquyacbP0jh0xcaZwnDI56aVqzLyj0qKxQCpDa8HHC12jARYk8H2b/cfoNxJSOjJzkxY3K8PcDh9/Dm3obCuYExoBN3lU8XrrXvRUt2C693zAGBo2SR6hyIvgRriHNFdwMR8aIwS23TirNFgyDG4GUfI5Cr+Om5xJRLWUyE5YIewRJQtzQ8CQt6qCzY0wGSkGsiQCN+a6PNDExUkctFnBTZoxZPQ5BDe8TXwC/ZJ3PN5UuSIqJwKTckJCTi5/yy3EBtahHVcnz8+6b5baYxtUACq48SF7HHE52Lszk83NAAt37JE2xARu4vfWxAI33iTbC525Cer7o78Eh+z7LaxxAvsgHuMoKKMbtGeVWHVink6y1an3iw4pmWR2uaNtiVCrbCQbeGNmU0u1+H3S8TiVZfx+aiwtKnAs9dRS5VwOOWF3HDE3buwKXk+qBhWZJhF+1u27Io9JFl/TBQCBVa0xGcw1zNwosYMYgHnsoahdv8VS6Zwv43jpu09onZhcQHnsXQk2N/KbovAl7zKVEap4OSg5v7UwDdF1fGaOZs7kOSSNuUkzdI/LAHezANxwg+JGoqjPIS9Gn6fOvA92Qn/0CGdudAbbaOYQzdWuZJBuOXvmELAnMgxuBlHyOdKQgZ0ofUx327PgaQtDJnBDAoNiDpREGtGmyuAKO2USg+GDJk7dIp2ZDdwk2ySJk7dqsLZzR1fYVIrHWRxkTlSF+SCpCSdvLh5ipLNFuv+jk9+Dr7jHhcfDBc4b0Fqsqqoe2rjAuPi0YXuUfkF8vrX2vFRuE0aguzogLDi6iLuzfFhnkktzmkGxAzeOf8QouPEFi87dDXATTWa7D25Mi36WbMUmeao4MfrMFy/O3MDz8Htvqem0SPh9LHGflI7zpVHs6yXsQhaJDIoT7smGF6mKou8AaGjrkEXt6ybY3CQ0CECSyjBenAKbG1EtZcEXmNVGmBsxt5QYO4gAUd93YeOe1vnROVvRitu9xdH3AHDVfxYiUBBtbsTnT8AgThlq/616eagUl2o3HPVtpm+wuHeramqQ3Oj6IOVN1t+wKAzoOdAbMNGqmjxNJpI4dZHDqqAJ7WEgcFCNbW4EgCauJ+d1BurOsX4QdPG6Zy+VjMUdexjcvCYk7yQHCEsTHxTboUfDNKmlsjhkBWqp2CpfRNoqc8NHa5JOP425ESeKLK7gacyNuKTXlAjF/b0x4yJOQNUeOXywqQ0/dg/Bt91V+EPXgUaXeHGi3OG0CMfDCMXw4E5v1e5DlH6vaFRNEPjRrkq0uXHHyu96MzoBwGjkGdUjvLfItTXxvSQbFNuoRXY1nhCdmKvKdgdQxEH8zH0gC2Ayg5vGUl9webI0OfocMTd+bOT4IJuOgybdgI9NOc94vs8IZvU9h29UPysd53WJk7vLrMhoXBXRgy6JuYm88nxPWkc5I2KH8XmyjK+aIeaOLtyrJQUEScwNg2hzoxpQNwJuHOhqKa9gSSDDZzSOcwXAq8kG7zWSnJ9OFPHuOFtCfHlkWcyXwI0KmipeLnpbUfuUvG1iqpFkhlsANwnG4EFd2UDK62mQfqg/BDcqk5wmLaQ/+pxntUSw1W8VkIOoluIRvuX38bQzXmtDbFBMYQ8zN68NyTsZd02KMARRcVWxDUHvsiwUBAxFKoAbMcZKs6K+4bmCEnK2uBnVUtnsKuIol1VlJ+pPiu9fZW6Iwc0SANxc3GYLvhFg3OQdhCuss8DaC8YFQgyuJwbLimK2ME8bJXqWXrNaihDfrJaictkBFBD4UJqZGxu+xBbxCbJRmxsgYICokFuK0+xRsK4GwM0y8rh0vT1jbvQy6Z4lumxibXiFdWJDLgYV/L6IYOQIAM/kJ6LX1jcUvL2rN/9NO87rEtW8NTjGfgcAJ1c/Gn1Oyi3VTwIWz2ZeZB8ECN5SXnZwU01UMgjCAXSK8ToRbG50g2JZDdeIWkrKLRV6hh1E/46BLXmIQfxEu0U1pUSV2PWfBZMNis+2f4ej6T2ALx+njEkoSO2/FS8Xq62obJsW1xEzN8Y5kKk2N2ngppJ6W1zG0vX8kgAaBDeIwY3ju0gKwri2MEpSS/F2+yCpqjxAZHIBa5i5eW1IwUlW4aQJA8EOA3OjhmQHMnpLESZRleJOc/uCcfBGFeCOD8FEWF0FZnCTlotHdltvzGhUjB0BAOiJ1XI1JUIxEUCHOAGJxwuoGRfXAeTgjSzCJ+YUEyLwE6ls7r1lM1ldENyH/A6SDIoJ8SK1lAQwlfqi3xKYGwpfUktFKouEXWCaWipgbsLJR0i9sDvg5if5K6XrJS06psR8qpjGTaPg5uDKNTi48oU4N5lYsyGEQlI03yQ2gj9H8V0m2dz4jGAtG4ltpDlshRncVMO2WsyDm4vD8nMXaysCN/VVMYFBcdqULjwDU7Zmn4GuH0CvH4PVg+BAZm4sgJq9O+uJAxe8K/Crj97+Mtx+KzrgMyoxzb4Sh6lGnPTQFvz2lDHw3843NGckVS2l9t+ql4/fLfcuU3JLRa7wCqCKhMnzZDq4yRYTJh+CIL7nK2UERQDQSmJvNIfVjJ59QABuCihHTzECNwoz6BmiXcfPgQyDm9eKdDYnexaliQ+C7UwHN2ZXcPE7wxeda3GNcx0KYQe34OEn1pV4/brHolLSZFC0UVs0An5nwOBwVqSawNxkVUtluW8RrA0o+umnSxOwBe3Y4LTp1DozfpQWoRIpGxdXrgcPPDyItvMSFyrxWfPFxDKAG0u516TcXFRUS7Fk5iZauBKC+NnwkBeYmyPpAwCAUkLAM9UwUbRFclCLslZ7EnMTtOl46+/GOhNFoOOTbCHEfnLi3Kvx+xEr67YZSKfwTdKPAmqwpQk3AjBcexCpZZLBmA0fYyobteP8HYtjpcrM3lLcZov3lBjcmNVSDnPNaimPezxm9ZZKFjlbs/578ba1yP1ra9TqPCg+iAKIaC8Wfo4M0BtkbvJeBe3YGfUJxkigag/bs7XcKbGcrmLAXSFOXbUUYfpz3sTaAE9WHVH40lhT+0PZywngBlF7RYn6tuGa/LgUoTgN3JBs4KaF7MJmv4Tn7MBDtESSwc1/2d/HfjReC0TmhrK4n9WYhd94y6LfXi6MRIEM6MwNkRPbmtSgEXNDCCxr2FvqNSHObr5IBmJUS1nwtZ2RuAh0oRfHWnfheOvvOC5clPYhT2MxeRZTdsUxdzxlog0qkif9RLVUiiGjmqW7nuSJG93PAJOZmxq1cR3OwM2dB8TmAIp+HpBZCPGaTSgbF5kycgBjUfh6PcKsoJYS7X44uIEvqQsAPRaMKXItb7dJLeUru53I3ilBVWDBQ15g4t5m/xFjsSkR3Kh2M7xttZltsOFG7fdZHK6fX7NV0MlnkTyrRoA7KZCh2E/+1r4EZ8z7jFamnkHxb7xleMYfk6lNYqqCCFwYwE2SfYoFD6OqW7TjUSoHGvfdGnOMzE0Urp8zYg6vWwGefPFgnjS2I7UUa4y5SVv4LfgxqKE6kObPm7exyChKIDK4YRZASGR305C3FPFw/1On4aHCuehA4Ak3KldGoNMR7Goq8T14SkqJGrHrAj3ugi3KE2w8iC/b/BEmMzcqe72z2hzb3ITPS4tzEz4rte7wLAAqc5NsR5aVuWlFH35dnRt9L6YwN+fYv8WPcp+MvjcLzA31WcSqeqCoCBvOXVYJBQxEYI7PYwE8FAGhibmJIb017Ar+2hDmVXdLLQUQ7ERJO2oZvItE5kYcKF3YEdak2lsQGLdpfMEOmZtKArjps4qZDOWyRpIthrsTlbmJ7FaIfBSQoyfLzI0QtRdlI0VeYWHAOj45KV1enDhlA+lYLXXyztsi+xLAYHPDiFEdkAxu5HLRBBGBKPl9FQw69VFkG5o9c8AzFeTxe/bGleCgKnhLEbAQkIh0dSOS86rgbyWLQfG78CWMZy9qZUx9TOzfPig2oy1Tm3wJ3CSPSC8B3HyKfRMlLwCOYoZvPtGXadx3KyyXqu6MDJptrvZTxieJGRAiMFVx+oUMsapCqWdzIzGtygZC/D0ux5+PyKSozE12tYMNDyO8YJ4aGc5Xvh8wN6wkXIPIajDxHU7bSUHVAaTIzf6J2nOuwjEyN6LsUrJ1byl3amopz1OZmwg1D4LNTTZwM5OuxSLyTPS9hGwpHU6zbsOx1l3x9VjMJKnP2SUWShiIDYpJrJYS79I0hnieK58Q0GHm5rUhXk3vZN92V2HJ8p/gxlFHJ55XXdyJWnNeO27ViVAs/lYMqUl1opUmRfGnKAxpulqqaufqqqVW0X9gCX3KWAYADq9cFbcz3GVUDOAmamO8zcb+Tz8cRU9mDkF1bkd8fWHXmCOe0bAuUkuFg7CgRRcWwI0AHDlz0+H34pr1n4/sSwB9gWJIMKzb1WVOnElU5sbC2L6+RJubooF2dglFk28GJB+tnSV9j9pGCRzBW8rPGKMlTfJeNYNBcfy8luMe/Dcu1MsY3ADFhcAHzZQolQGSt02slpINikHMgJTLgdv/CQDYyeJNBx9bAyS2D6sys51LBG64qrEjGF/qghotHsyFL9ze9P4AAMbJb/fcW0q6tiFCcWTLpYAbWS0V2MdwxmOCAaiq0huCBtPC3u7UglZYBBNGBbmeaq7I3Mg2N02uBeql99nfucdoz9mGB/gyuLGYL22c+iCH43B9BzXFoFglqkRX8EQ3fzHOTYqqlVnZwgoAwC35y8HfXppaiss88hw+6XxbOkb9GHh5oJL6ukZtFEjMhicaFBvsn4oho8wwrJZ67cguvXN6oHi5MAopIVjgjywaJy/LYFAsDs6CoKMthqhfXWA8Zhm9jVRbhNYtvca2peQZhg0fnbl+3JC7Bq+zHjCW+XXT/niWjY28o7jxm6qWmrH+JQBQSE9g/ivPRZ/9rgK8cbFtksjU7GAlo3EcBzc+NXd1CdwYmBtRHLhoRZ/BoNhsc4ON8yLmRnQFhyWX9WDhmCceT1RLFQ07Oj8B3PzBW4KX0Y23VS8R6hcNil3JFVy1Iagn76u+R/qe92oR2EtiDdSsxski/+ZI4EbP6wQAz/hj8EX3eKzuviY4QFW1VMJDRTJzI0ovdHAjMjdV3zHekWpzw8aXUJvRClKixnIW86SNyzkv/wxtz24AdeN3VU9cwUDcJBSxd1C8QIlqKS8uByB2jxC9w+zwvoJjzSx9QfYZwduqlwIwq0+abA9dOwNVaGTovit+oi6ULOC+Db8Oi2W7+qbQgh96S4nMDYMlDGWTU8V2/q6juECKK7hkUCxfs9E4N/3d9yT+ZhKeuy1NLcWlJ4yNI7WPxe1RVZo1YqOIfqPNjdhnTGOo4AXtKVebQGr1I8cPlQyDm0GUph1bNa8MVeefJCYEbBlCY3N24UoU8dbCX6PjhYQO7oLCeVC3H1DVUp0bt+plkB54jxKGtlw6Jcpz+3CQwVkIVS114NP/Cj4QJjE3wR+B1YkPS5T4mdUPG6/PGRMvwTNGvDPCGGiBSOeJ8vvcxXi4cA46IUfO9TVIFtbnW8b0C6qBsgsLLVUPPXglbJP8u4l2ZqBoMqil+GRUZY5QNn5+MnOTvhiaRA32mGeVusyNUR1iELWfWRq40WMxlZHDNe5JeMSaGlYiu+WbrSCCdmQBNzJzwxkwwasuwRU8srmJNv4M3uQWbTyLNjeqimfMs2vgbOgLy9V/T1XYiR5gAF9kw99trqYVjc25F17QRp5VTgzi50K2uak3r93kHRSlPWkyMAyE0WhO44lDxY1AnP+MS/04N5brRX3pG+5R4Vme0RaHSPO1Qb2ouoIr146Aiw/t3Qb1y4AmDdzkatlU+1ymkPUg8PFfzo0AYobMJKY5nLDYtstTDLddYqFIBqJnH8W5IfL7MI2hoh+85/6BNqAyS/t9b8kwuBlMGRgAVXdYdrbFw8Tc2CbmJhyMnSBRsC0gtmXRbW4s0F0GIza+3jGgONCP/R560NiuIqtgFn0psd31bG1YBG4CpoYv1Ho0TxI1S31iggmg9J0vBl92j8ODbHpCC8JJPIG5IdJnhjfQRwCYDamnhPElltEnlPYR486a+nFodAkUEB3cACRKhJlFLeVTgpIR3PBJWDT6oyDEBwiBLXhL+YymRnU2iQpucl5NSkppkqzMjdqXxOzXDNScwZ2fw9lJSqSNAn+WTEQ1oWQJBmeyhRNtQqqwI7slqUzU1uB6eb+K7uoWbTzHtl2uBm5qsKNn56P+u0rKLcVFvDZrDhMdCl2LhxuIPJlA4Po1iMuEG6ql+LPj89G3xxxnvOZTE8ehf2VPYpsIAvUIgKCPQlalu8p9U+bUZRvFDRmfZ/hz1GyeBBbV1BtqnIGLbPZ0mxuLufgfegNOsP4i31sIpsT+v4g+i6nkZWO7nVpjbtMT6AaMDNkbAJJHpSqmFA3UZ7i8L1BVjSLbZZsbaqEo2NxwUMYgB6o1pRvi4IaBgCTMu3tDGs/yOCyJQvoHoE7xxa7QyrxOzheTB0BgFSDXN4FtwCa0BqV9Eo1IrrpQPWWkeqWVPGZuPvCDr8CqmncUk9116bvtOls33wo6f5k5ABHUUprNTfwpqlNlwUQmncU2N6Zd7WGVq7EzZScT1UnFidNHhx9Q5GneKTuh1mtWS+UEdZIcxE8u58EGYSTauapP1BTHghAY1VK8HeLC7QkKBo252UNwU8hkcyP2LYW5YETImM0S97U+I8b4JlHrPRYdkNRSnGFQnyrJBm52Ce86inMjTNgus4wbEw52OcNx478/bHxfHITazNN29YzFbICuaNElsLlJXiBFtZTfEoAbceHNkZrs0swoPFaTOiwPaRB5S4XPfZclg8BfeitwjXsiZjSvRc1JzvvGQDTmRmTovFA5H5d3Um2lgMABgd9DlCMuIaq3ZxEgZEwcQlBR5pwoYGOCsT+Fj7eu+w3eYt+RdINaupbb8x8yFs01CG7ykCMM51PSMJSIzv5SBhxQfTj6LjM3NgqIXcFj5oZISZaDvi+3uxCCG58Q0FcR3AwzN4MpA2VtibOK2TqsOcKtbqR2qf+D4DdAWidWW/9AN7bDVtIrJC7S/HIMIL4PVsdIL0nqMjeUoDajVVNLVZiq3xaoJN6UsOpeQ94tQJyY9bY/x8ZgEzrqNR9M2rnpBsUmUW0/GPT314QBXLHhnOi7ZHOjqKXa+zsAlszc7B+ySaJQ4qPk66DHlP/IB43qFsGNtxsGxVWVufGrwk7fLDJzI4v4nKeRl7E//bexDh8klbkhAnMjG9UGV3yRjAd8JtyvOaq0KiJAjiIUCxP2iAQD0dhbKhAV2GywWwEAvyzsCwBwDC7VFvFjIKoY1pqkBhteq9kxAJDfg99d0I5xtZQFgblhrgQmOHPD2bFcNSi7xWmXrtXHCniejYZNPaPKPZJCO/hT4n20KjI3TFaX+HXYqaD9MRTkYMyKwI0srjD+TQHma/wMy3xNCoY5u55NbgxLV0WJ0qhayoErARpTOBEuzdCBtWqLKYL0GrGkqO+8bzBCpHnSM4AXbnMT9NdhcPOaENIfo+Nnm8bAtQhuGXNgpnNNxpLEYO/ShkAHb4HAr8g7onfbv9SCRCW6kEYAgoEwBr+2m+CmHnMDCm9yCwZCtRRnmMTdGQMweswTUrO4bPcLeNrrltoc2TEkqEPcDMaXXMR1kBt05ucUUBnbknCGPlmZFp7D6IMosnhCqaWCmxFIU0udaf9Ba4NFGBxf36nxCUqcqDzQKNx9oJbaA5sbRV2X98XwB+a6xAjFKtMn9s/f5S/FD3KfwSyiq0GDhdZENIf1hQwCo/K9i1sDa20fXCuOKZTF5kb0oIlYMeG0N1o7jKAjakMCY3tjxwrMK38Dz1nJKhsbnqSWqrf0VWGDWclAIghaF4pFMD3/HMbTTdHvXC1FhE2D59eg5pYCYu9KbpC71WmTrhXZEpGalE5Bk7knRnY7NLRlEt+zp7goM9iw6rDglHkR4ObjjjsbqE9xe1sMBnOG/tvHNxAJXYWCYXR5k/G3wKCYaczNYIkND1fY34m+X1E7I7GsCdxQpUNJBsXUBhBvBrjHlw8iqU9NrGXBD+Z4RvCqqqWGwc0gCinHO+kvTDsZf1nZia359kznmgKgmRJN3usHBloEgF+1lPK+tvDKtiBE/8wCi39fcL+8rbQM1489KVO76+WU4moBztxwFYs4KBiAadP+EVYo17fWlydNUbgxnPrsqorXAzGE3hevHZULv9kdNsqzR5hPgK6/DpgbeWJsEQytfaYE+VPmUI9ZAKN1VXyiWIhTO4jCJyhfWuDjz44UxG/P1VJ5P3TlRbLRq5qJOa0+AJhpADcezNmgoyvyXShRbG4EAEN6YzBoemcmEWOfcAajIBiqNBNqrId73iS+UepjF0qpDKGYONfTDGt1qW9zI7fmbeRP0vd8ZHPDQXaolpK8pQKD4iqVx5gObsIdP/HS0yVQJxqfvP/LNjcWrE7xBBu0DrgRF1/ev6wEtdSzk5vw/eJheH3lk2gzkOwDLHgmiak64BmjWXOhmyup7t97Ig48HGTFTOdLbGRi2SaDWkq18RHtIF1igYrgRmJuBHBjSL9QiGxuaCK43xsyDG4GUUg5DmgW5C0hMIWVN4lp4qaCMdo61hnWG4gFfaBuYu1aIrS6cW5YsPhLOVMIcMvIwzO1u17f5YODq6E4jSob2MofxQjF0sKhJJZU1SEc+H3dk2MKpQIwQvBrbzlqzMJPRq0ODjGWOiHTTlUtpdvcnDDun3F5Mb58eM0X/XgiquU87LNqUsSCZWFTKGVGcBNlrhbBjaDyslED5bEtBsNbyq8Ki2Eydc9F7S+qmgswq2irzQVU23T1pNmg2OAKjhDkcqArqFbSRLS54Xcxvrw5OuYiZ+xd1QjcJC2KwfGapp6NxUbMQAT9qz64SQNsFvGxYG2sQmlSvPB0tRRQ86uSWqp/XhcAoKKAG1UtJeaecg0LIBdixQsq3SR7VgIhqBNVQixnNOAWJbC5kY2TuS2iyebm96U5eIRNgUn5HSXxJYBj60wpYQxtrtkdnoDBXtM3qMzNm8gnos+qjY1poxCVNcQAy1fltUkMz8GZG92gWI4HZlq34jg3wLBa6jUi67cRgO8QInfKbJJkUNwU0ol8sYpsDABAMR7ciaKmlkoK/iUGNyOKl4bN6ujJxTbWVUsF1xlQEmUmByUTFkIkLA5h2/kOjZe5oHoe3la9BNe4J2ZoeVzV+bX3YW7lW9iYHxFeNx3c6MyNbr+RL69PuShwYvWK6OvOri2YOK87US1lEgu+mblhOrjxQFENUwbkUItzv6QwN+tG5vHw1HbtuBoLJCcZFCct5MkA32QTZpowqyNK8Np1w9RoPHhm0CL1TqWr1jPyB2Tmht/fhlKgsiz7LWG1el8u5/JoLeyEbZsXNv7Yq0ZVWyBWg2qpGkl3BSfwUfCqaA/V568QmZ3kyXZFg2KXVSEuE9WOwK5DTNrqg2CbI6txfWG+SmVuSC5mVrcFz0I02HcJle6JwUa9WVVkvKp1mBsgZn4LhnqjvkQInJz+Li34sAzjUBQODD5SOwtvDWP+7K7cb83C/7qvA6DHt0kDN6YxKDI3h1euQlkY2zVig4AZ49yIG3ZT0MhmN1yziDWslnqtSK2jQzBXZNLfehOTmm8IAN5o3Y0DrEcBxOolIuJhRd3iQPe4SAQRAjuiqm1s5mayRwjqSZ9oeOdXd+hmOt6XDYqhqNWUS3FwwxedV9CFv/oLtILpzE3wP0mVxWR1hioqqGDQA8yxgb7Ua4rUrgsAJNlbyiRJNjdRqgVVLcW9W1CT8iwluRe7NsE2Q9Rs9T6LAwOgngwyVUnLNL4duhGkqc+61Db2yVgtxS9GjN5SYQPjh0vM+cBUMXlLvTgmh2cnlnDL1v8BYOZmy61NeN+B30icYbkNVKVWij1yFAnC1cURiuuB3qqVSzU6thT2oubKQHUaeRknWndKeYRqfhWizU2NZzGncd8r01zMcITC20EZS8+LRW1hTgv+irGFPGpr4EZ8Di/ldZulwOYmvMcQPJqYm1dyAXvKAX7e8HxFYJYzgBsKBrtOCgoxBctGZnZy2NJc37MTAIjLojGoxr9KU3G2EX0+4sGDX/RH4lk2VtqAeiTwsORzK9/QMULk5M2G+b/VC5gsF1bDoSYGU4bBzSBK/7TxII0srIJUO/V4GqKozA0FNPsUBy6crN5SRPhjAElZ7BGEahKFT0TqrsJkHNrcshUTJvwb48ia6FiHp9vcxAbFHMiltyLtV9O6wp/xU6UJxnPMNjdyRVSZ7/yiqB4k2IR2vOCPwmaMRhk2iODRlEktRRKYm/BcEYR4oNEzc1DDzpdCxkHIifXR2plaXSZGoqa8t+LLO+oCeDU8gSibDPmiTLvMGrEj92NRovHFDYqJ3OelZ6n08yzspGhQHHmiOcALE0vo9UaFx/XnVCEOLOLBSlBJMB6Nl1F41Py+LcTJNJMCRYpSs8zPKK7Px2x3TLQ4KVMFPuZ8D1c7N+BU6/bwCIHLZABdoXI6EyB8N8oz4P2QMg8gJDl1BrW1QIASc0MtCdwQBdz8sWOFVuX8gWciFa9qcyPyX5eP+wS2P9+MnesDgK1DeWB7roNf2MjcUPiJyUN53+Rseo1ZWv4qLlua0+f/qM6yFxl1q/GvTCpeLmJOKS484zx/RmU7fgIutUEQZ00X49zUC8rZ4oaBJwkFtYaZm9eEiCBVZW7qLVe1ya2pv/MJm9dDoQMnB662MNSNcwNoq5LNXGNwJpO014tQHF5HDXJnUsMtXvw7WJaH4/GT6Ni/tJgysViQmZtkCXfJy7vxmaa31SkbP6bDl3zL+LuZuZHvRw03UlvQKX/vacKh+S/iV4Vr4IEBhEZBzLKAG7uOQXFN8jih0U3ZqKG8uRBeJ961fs97Hf7tT4rviZhD/usRimsCuDFPJ2nMzRbo/T6HmnaOR6xUcJPkCt6xPbaPCVjK6MRUIMBFtEOIFuwImHAbMINBMc2BwkchIakhEcBNUjuOsP4pB/Gry9yYM5RH1wRDEbnoGaj2eVxWWo8BCO4rsPSJPW122EH6E9GQ1CWWll4melbh+0lWTQW2HQCwqxSADJG5cakNX6rbgTiRVV/R2csvrYlz2UXeUopaaoDksNkagxf+MB6VnVxlmy62Y3DXhy/luBOFP2fO3LiwtfxVXP5FFta5eiAMMUOjxr9SNx71xKnJAHDX5FhN6RIrZG641xtnbqAwN3q9PJ+eS/Y8d92eyDC4GURhYJrlf1bmBg5NzR/DF884c6/KEQXuerpaqo4rOIIOO/qdq6PvfbSUWS21vFP3bBElWmyVdojMgrpzaxIyVG83gDNeXLW5SZJo8W3P4cYFxys/Gs4N32GNmo09HWU3y6CrOFQHCdbmwBtdhDslYE1qCzsxsKIH7R6FRzwQEMGguL5YlEWTiCh8URF3cQQsuk8Htej+mGJQrO6+mWG3rcW5QWO5pVTZbAA3eVKL3JK51Iht9MyoZ1Bs+8KLUBqYJc6NFHwxAjc+GAP+PuGXEnUvSjUEN4msPH/XwWphLPJu+1dR0tEsxt/1wA3PE8cXJy+fbMzM20ZhgQjj0QvVTyLbVKM6czO/+1FcsvC6aD5MCknBYEdldobgZpfC3EwjTwsnyMyN66dvwvi8E6nkhOdOFbW2U8+WxwBuAg9Vc//mtXE36ips6d5E2U7N6ipTnS5LADcNxuTl3Y6P6WouhneB+z6LgHcc5waRQ0LcIrN40EHv3pRhcDOIIpuHJIObH7qHms9P6Sg8km6U6gQKgkagLlEt8+vGuQHAfKB9/9n4hHsSHvUn4rLR78k08TciKsgy5QmKm5a0GBLpD3cFzwgfAQA1Jft5wTVE/61TY14BNz6I5o6uJSslBLUFnXCnx4v58ucfw+RdHly/hu2V3obUUuriL7YFkN3h5UBttQgIbOzvwob+kcK5snu+cdFWmZs4zFlinzExNwP5oOwfyD7abzm42v25xEIv0YGQqpYCkVUmkhmu4i2VlkGbS0XKcxSDGzDgobF/AhM8SkQp0xyYG/AeZomZm7QETXwsZIlQXLVyqQbFHB6xkCGs5dO5CgYKQiioIUaKyDa5BpXhmOYNGFXaHAGIxHmIxWopXoeUz4tStKJXaJMDLR1EisRxbmTmhjHg2fD+WbSAp0jCqwzSL5iZG86M5SLmxkocI6rNUppwwKarpdLBanJ9wbVFrzaXWiAmb6kMzE1UB6Egw95Srw1hRFwY1b+xXOqeg2+7q/Tz0wzCwuB9os3N6IqcENOklkr0xhCN9AgA5uEvbCGOqX4Gz+fGZjcoriN8AVEnIVGNo46PxPGi/BDvvNLbKoKVKlVsRkzgRnhlV7afp/2exaBYtLm5v2WOsV2L1zwNAmBrZQveedu5dQMiilJgeqZwIH4WGrgR1FJ8gd9WkXeLopqCMvNzdWHj6Mqn8Q9/BoDQ+0pxyVfFxNzcu6Qddy3twLMYA0/Z3uVR1fLkuMRCzmBAHZ3JwQ0lEpCWgLJoUAySqY/XJHAj2L1FKilmBKNV6uClxw9FzUtYcGgMZP0EmxsgtldiSaur2FbbSR0LXLFVs0P2NyVVQyAElFiSWoqLHJlWfwb8UdN6zA2JDYo5yBAzseepJ7WTaLZ72cBNbEwdiA8KHk8+Tg6Z8nwJgUt0MGhBz/+niq3kl7u8dgZ6mWxjk+pRpgh/lqq3VJrNTZpwdZY4bgK1FBOeTTg3EGg50JLEI5YWsHRvyjC4GUQR4n9qzI068ZsmobSJaUS4e+H1tdP7cdSov0plHLiaK3hiwkbhow8AvhfHjyBqCPvdF1M6gOB7CnNTZ5HX1VL1WxFdV9khmYae6D32pDMFFYXt0dVS+rsT142LZppzyXDxiA8faMjmpljVFxzxXFENKDM3rmpXG0lByIVluwzVmk6h+yB4jE3C/f5MADJzkxzTRZ8MPZtioGhhwC1o5+WVsPJAYHthsjHSbNqozMhozE18ovTOfFj4ffsKLCh/TapftGMQ1VKRNgzMOG4rNIf52/fBwIBuMB1cX7C5EU7fZcnPnNs6ZGFuymNbU8sEaikSPYf6aQEIXu57CpQYwI0wl+RZGavYb9RTwVCfBWWwYzVp+BwrcHCbtw/+4c/AS9bISDUXVCvnlqrH3FSZbHMjxsaqhsausdFsuvQT3eiXgCUaFAd1xnMyH5Pf9VZpBvyNgBs+p++pWio+L7i2S3Vww/t2PpwbfFLfoFisIyV+6pDLcOLMwRQa28HUs7kxHU1b1ApRaPTgzLFC2G0ugSu4vABINgPFJGqYAA/dCOC0sPHZ7BGySGRQnMLcqJIIbuKHi4DnSs4tZToNgBYKfh30SMTyO2PBDl84pNu6mAyKGUCBP3UswxNNU1LaRsD4Tii8RpaowTwLvCqx7U9chy0YAInMjSpSss1KHs89twTAY0qZoF4e7yYvGP8mgpuUCK0Dbgm+krcnyeYmb2Ru5HthRE6wKbJh1tYqmMMBvAyCNjiLccasT6GwXo5PJI0fxsENi98VfOPjrNAcnBT3bdGgWFQlqeOEL4yqK7iYcJRLtaUIv5rG3DDJEcGqw9wUrRfxYl87GPQgdQNUCG5IgDeSn0u/83viGb9NWakDsWNwHD0HgnNqFwFgYG00YmgDkY1U64Eb/ruaW4qBoMaDgmZUS/XTZkDpl1aKzQ0QbBgiV3ADUOaSNa4YEPdJVS3Fo/s0ypVUDWopkGAt4+3kmw2fAk5GxKKmztjbMszcDKI05ZqgqqOSwE0jzM0m1opvkaOk+mpslFbOgSstZIA8OXs9wq6QENnYa+OjcUdU7Bb2RJIMitPAU72ozvyJqgaB9c+AFL/m3NmXo2aY0sQ1gzB94lEZBB96ED9eR5Yd2ayXmjHvmdZEls8kPH+LKqZnYcOLKnVQ0zy5uIg7sp07ulGuNmtleB+pshjc1GNufu8tNV8wOk9+djnUtIiqLrE0xgwwTOSKQbE6/ogQuEx+Vub3JNrccPUIER7gOL9Daz8QuoKz5GfCx54PIjE36rgTXXDFur7mvR4XVt8lla3ReukXAuYmSjNSh7mxQt3qmr7ZAIB7W+fH7RTUDSY7H0kDCGibLi6+YFCse40RgBIl8WoQmz1qR50lTPWWEoE4v/s483X6PDJAdCazniq5KIAbEYip7yk1/5YicZwbGdxYxJP6Ulbhz+jJ0uTomBqYk49HnxLZoDjFxssjVqo92VDLMLgZRFk+dr+YXFCCRr1QHCeVNTM3+uvoZUUsrXwVL5EAzMTZbvU8Ig5xtQkrVQ8bNpafwYRdvzrJ/r1lYXI9KWJKBwAgNbhT4oShnNKot5QqZZo3skRiecKZG0FyBm8pdQc51dkJoD64IQAYY5jycjPypVpUn0l+4a2MPn+I/thYxtSHRFuawFvK3BZR8eHATQCgMnMT2NxwFsLc7v92TzFfMGqzLHnozI1PqNnmRn1/CuuYqBYhCmhl1ICU5M0BX2Qp/Gjm7GRNxtD2FZqD7acwN2HGSaYwN6o6+Bz7twB0tZQHgvVQwgsQG23YZrwebzcJLhp+r6MyCp/Pc31L8Vjtgzh3+sei38YKsah8QhIN5zjblZSCgBErAje2yUuaElgCU6AoIeuqYqoRuJERPQNB164KfBD0h6rAdOaGGBfyehuxAolzS4lzsTq2xL54l2e20ePC55oCjTc4H6mdBYu4maJuD1A5ZQh/hpvyI3DIvt/Gvst/LGy0gvo48+ZTkrix0tpJLPjZzHOGRIbBzSCKGGq6b1cHBrZOjDrJ18adiK+7R+OU6n8BMC9gpoXJ41mkwk4bdzo9sqttiFAsxT7QJqCQlg0noChuBwFyvjwZfXHMqdr1sghvtxqDIZ25qYP2w/uwkBXcmMVhbl3OhzCDqsBgUFw3zUVq6wI1h0UYarPaEu/nBTYKt3m6d5EoJubGAosegoNa4tMVn7sNV6fOhe+iWkqdCEX5lz8FlZQIIjataX3BxNwwEA1UGoWaFyGTiEyByZjfZ0RaPDn7QIkPYgX37BEPPUwHFFWag80ScSRsN4itUoWfytxExyFnnvdA9ez0dYC0Faml/PB+siV0dH0fvWwBDn78X1j88hO4np0Bi8ZjwCM6TOLMDu//ucRrxW3OtyPo/wWB4bBkG4+AEWrcW0pNv+CD4MRHXsJNo4/H5nw3gDrgJjjZ0Po6qj1Uo37jwoI7rhTdhyjiexfv6VO1U/GwHzMqNrwoIGIhHA8v+KPwfe9IWNRDzanf911iwxO6mdjHn2iagrWFOOqzZnNDgYIngJs6NjevnlJqGNwMqgTgJpzomYUt/35jNJiqNIdPuafhbn9u8LvhtZsWJm7LEYObQLZu0+PL5IwGxeLgV+rnu6voQGyPsCEv7wpdJeaL6uGSJKZ0AMHx5PMT1yYm/YmzgtcDN06yatC0exUNigmYtptWd6Emg+KorAISp21YI30PoA0LASaLDDFNUmN2eih7JIEbL/JasFPUUiK4cQzgRrzHmLlxNQpblHrA85KlX5TUPEDI3BBd9fd0aWJqm8MD8tfEyxP4kpqAaoUZ5IWGjy2RWRzjjUIPZK9FIHAFb/Hzifc/4vk3AACqxJdAVtL7ZUpP9UGNC2vasKQkeEN8LkkK4seFhIsnj1Lc0b8L+z37KFqwSwqst2ugHb293dK5rkWEfp0sDDFz41sU3sRm+G3CXEOJZFCsjo264EYzKI6BeEu5ig2FWL2f7i0Fo+dPPfariErEetRgw+8IQK06XziCikkyJVDcx4/OPY6akkB2K3heL4LnJ9SPdOwRKtm5RR61htvnY3oqXRd8pwR5Pxu48WBBjYixN2UY3AyiUCogVcbAfFuffEMxLwRm11sg3mVGbree7sIcuIKneUspJ3BwE2XbFiZZYuNrbW+O26ZM/EnBqFThd6/nPdlzTJ9VLVWcLH+/LX8i7mmdj9tGrDC+H7E2U4ZwFUD6oIkG0qonhcmNkhsUU/iBLVTC/VRhS+wJoE/upn7lwJOYm6QZR5yobbhaXWK7oizvSM8KXu/dTG57CY4lAxmbeNFOkYtPKL4x9gTtfB3cyNdLXHyIvFtODsMQ1xcF0FTA2FZDIMKtThtaWR5tvm63BACF8mgAurfUmOomY/ngvQvqK6YzN2p7VeE2N1sLgRF9miFsUFMAajzmgrtKcI9KcXF0mYN/P3Kk3F5bZoWThLHYBijKrye+Q0okg2KuUIuvnZG5IUF6W5FlrCpdI425YYDx0dZzAy+SavSearDASnZ0fUmEr+KY9hVWuJMOwB8v9ylxjt/QbUoiIYtHLCn8gEm1l7Rh8QlR+l3y+3Wplc2AcIhkr4Cb6667DpMmTUKhUMDy5ctx3333pZb/6U9/ilmzZqFQKGD+/Pn47W9/K/1+5plnghAi/Vu9enVCbXtPpAyoDBhAsj1VdrWU7K7Iz6KGic0WsghzSbe5CWpr7wuAUrRDCI9XhLgO6m1kBTec9VB3pFlzV5kkzi1VH9yMaXoFliM/k18XzsZxi69FjTpmmxstB1G6zQ2QzNyo4Gby5mAHVKoEYfmDqV3VXySBGz2OSRZDbQte9E7TbW4Ul3GlLvE58zg6OeLqAENqT/33rJ5twUdRATcMBFWa0+rTatfWjGRwI6uldJsbtV9ZBnDzp+Jd+IJ1En7qHoSvum+Ijm922kEZUGLmcPs0fLaqt1SSqN5SHqhxYWUp74JHKI68pcLzOVBVJQI3fk24cvDJFcGNARi6IbjJ17HPYCQO4ueZMkhbciR29Y7ruoILv7+R3iUnBVUeez1vKRNOq6eWKqAieUtxj1X1LYnjtpYCbgDdti3O28XgWwQ/mzAfaeISS44wzdcIQz9UWWstJlMd5iatPw61DDm4+fGPf4wLL7wQH/vYx/DPf/4TCxcuxKpVq7Bx40Zj+bvuugunnHIKzj77bDz44IM47rjjcNxxx+GRRx6Ryq1evRrr1q2L/v3whz8c6lupK5RSYWHkYMT89s1qKQNzE3Zc1ebGRCnniKtNeFmYm5E7ggCB6i6rVI7z4qidvC8zcxNOhoMBbpRxksXmhhB99y4aKJoj34u/G9RSiqopj2riDlIFNxO3rMdxD96Jk++/PTrG6XsKHyyXTHRX4WgTnerJpUZKBuQgfi/+oicRcIvqlgDcJIvJ5sbsAZjhPStFKHzdzZWHFFDehe4KLtdlJ+jgGGTA/YohWm8SuBGv+b9tP8Vm0oIPue/CX/14Udmc64hC/pmEhtf2mZXJw8WkljJFpE3DSZy54R6DfA6p1LE2cVkNRHmwIrgxufzy3ztrO/Bm9oPEuhkjkYFzudAW3oTwOyWpDjf1XcHj+e+Lua/gXPvXQb0AqkqbbeG7rRmvE+PDTTKU5lJCBbnQoLinMADkQlCrjBWRHVYDR6aph8XyvNSOXDp74xK5z6UxN9q1Darb5Ou8uoqhIb/65z//eZxzzjk466yzMGfOHFx//fUolUr41rfMSQm/+MUvYvXq1fjQhz6E2bNn48orr8Q+++yDa6+9ViqXz+fR09MT/evo6BjqW6krRMl9w4BEJXh2tVQ4CYYdhU9x1BA7JFBLyd0tNZlaFOdBGXAEAGNYX+7B2vwo/LrrYK2T7zK4RZqEDwZ1Etqj+AcacxNeq8l8ryrgs4Svo/OBVxPLCx420iNkGuukRgduQiWRuVFDsxMAPb3bkHdr0XfGYubGH1nAiI7txroCgluZFDOARov4ETh2N1vIwhUHRpDq5B9P5JwRzKGWmhMrS7wkE3NTsuSEk7weVUVYTy3lqKmvhXLiRP1YW17DISo7yfuReAlfQMdin97sdMBK0mUAsEdyRpainK//jNTcUh4I7vQXauXS3qy6TEbMTQZwo7XHrgNubBIa/xIci5/jJnslPEawmckqvBBuBedYAcDsKQt3YREplclIZbtYzxVc/f119IHwuhQVpc3iU8ipD1LWCkZi8pQTpZX0R58noBcgBNXFnaiNk1VLUnRgJjI3es7BJHAT/V4nKrBHLHiizU0KQFTnEy2DfRpzQ+xXNYjfkIKbarWKBx54AEcccUR8QUpxxBFH4O677zaec/fdd0vlAWDVqlVa+TvuuAMjR47EzJkz8e53vxtbtuhGfXtbKKWCzQ3/k+BFk9E+gS9eMR8kU8qiOHC1wFyJEYoR4y4/AjeEXwTjtm1EDQ5WLL0R75jzcY06H8iYxyRalAZTLRWeq6VfsPQ6AwsW+ZmIqRFG5vrRPM9BZf9R0jnRZ4PNjSpFUkm0uTFF1dVbGIAbbnMzfvwGY8kqs+EpDJHKKpnUMLZoc+Mme4iJIJA/078ijlEjAmeuyphN12Ac2Syd07CobAt8TBgn257w/udDBTfpdeWTwA30Z8dPfkf1g3jRH4mzqxdJv5oNeM0uUX1WMQCuCU+7uG/oWsso1o8yq65E0YL4hd5T15M31j2Xi6WMOm47UWbpOaYCtZTKzIieW+qWSvg9/OFbucMxv/JNPOhPk+v24s1ExCbUYkDQSTZLm42JyvvXbfmUdmj9Jd4Q7VKBsPC5w/RMDKChkBBMk8t/O9+IPtvV8J2PLMIdKRv+iiCsnlpKvSctKXE9cFPnmQHJNjdZVKhROxoITDgUMqTgZvPmzfA8D6NGyQHnRo0ahfVKJFAu69evr1t+9erV+O53v4vbb78d//M//4M777wTRx11FDzPbP1fqVTQ29sr/RsKEb2lgvWKwTdQfvv0vWI0tFMnbkCwuQn10a+zHsCn7W9oHiYAd/VsxOYmvEZkFxPb3PDWMRJ4kfiKPrzebk+VA8nj5ovvgViQmZukPCbqgm+JBrWMwW62ACe+v86+uH8QmBZBWYqoJO4gk5LqifUzRTP9EptsLGtSS6mAop306W0QwE0A9uobFP8IwaJ5Ow4wljW5dxuZm5RM90lC4aPk6NFXgfpqKbVb5ZKiIxNDPJzw3D/6S3Bw9Qv4J5sht8ugH/ER3/d9/iz8yVuEL41/q7CRMN9/0Qlda1mQhuKufTvwx9GLcXLXlcbyE9vWSCCdt/0V2iWVy5I4k0sjzI143oYNU1AVFi4VeAGc2WGRAXLOctEPPdXGA79/CRu7Fwf3xPuoG7N2Bzzfh6orh70Qa0hL48LbZjrXB9XAjaiWshgJ7NOSLhxKATq4+Yr7RvzOELgyX47rU3uSCDhkbymqjXF17MXqyZBBrYMpXGIhV4370iLyrKGUWdUsskKe4GF4N/TYPB6x4L+K1M3/yfQLb3nLW6LP8+fPx4IFCzB16lTccccdOPzww7Xyn/nMZ/Dxj398yNtFBOYmGNrQdtoA0OxWMzM3HJWL4OJU+094GVO1shY8dGCncn79ODd8wTBdn8RYTZJKxq7DgUFJ9X7ZE5ubSC0VR28FAGZgboB0tRR/T6IsWvM0PEoxafN61Cy7brTmZ9hYzCK6az5Qn7mhLEy/IHiNbFeCs3Gpwtbsh9TFbATZEX1+zu/BFLoet3rLJNYuCdyIx9dgTGq7Tbu/rOENAKCvrw1NTUFbXS+HnOAKa8GH48ugJLLdalAtpbqUiyJFMs4wCRuZG0Et5cHC22sXozxlrNRCk+SZC8AGC+eHgZKFzW0U5UcKxll5dPM6tHm94I+JL9o/sI/E1JGb8afO5eHVku+Dwsc+1s244pkyrph2fmRzUy+btOgtBQBPPbkSmzAbK/Cd8Pyc9O63t9qh2iM+5lghmFMWy+qAB9cJwAtXeVDBpi2/ZSTctlYA241tq2dzAxC4jEa2V+Lz2aW8G3WUS/3ZZ0abG9XwHQBeZKMwNmQzRcnXYnCjbphE1ZMI2LiPlygVJYFnX2i0zjxuZlBfLWW58XP4tb9fanlRRFVumca2PafjUhw2+2nc8PgnomPBWN3zTezuypCCm66uLliWhQ0bZJp9w4YN6OnpMZ7T09PTUHkAmDJlCrq6uvDMM88Ywc2ll16KCy+8MPre29uL8ePHA319gGUYHJYFFASquE/fDUdCKVAMdPPUskCqPuAxOOUqrKqN3ICDkh0knnNqFVScPFor1aDD1gJKuzQQJqarIkYTBIATZzh2qjWIvouWK3wPy86kazETa6N6AQA1hqIX7ITsygD8AYr+sL0gQL5WQdfMHUCVwalWUUQZtDKAQrUMpyqY3BEKuCxyV+CwQpKc0JHDslbFRWlgAE5fP1CMy0veyC4DHZAXjmI13r0NOHnwfFK5ahWsyoAqC3IWMQanVkPRK8NzGWqMRTZEjldDoVoBGxhASUj+ly8PoDRgYSCfDxY1QuDUanBcF041mOoPePJfAIC17V3wXRY0mO9aPAZ4wBP+VHzVXYWH/Kl454QfAhvDm7IRx5Vx3fj9AnCq8mQYAC0GxoCN7kiU3AEUBwag+akCcH2KCdbG+AG6ALNYnBEbQLe3DcVaGTXLxgnVK7AvfQp3ugtQrA7AGRiA7brI1WrS861ZNlwrBE5hvY40aQuGxl4NNctBPwpRWS65ahXf8I7CO8KourBicEOYj0KtGr1n0k9AQ/2gXyaAxSK1ImUeiv1l6RnYlSpKAwPwa+Hzt+N6xXuxqzn4A1Z0bl5UGzCGYi1AB7QygDypROXsiot8TWaLonpDAGOz4LnRAT+KPXdSpYhrIfdXGr5vUh0AmA/YDBCDq1UZiv27UKwWYHvxM9nw3DTkqlV5Vg7HMqn6QVvD9tKah4JfRh9txYdnfDBob3kAdqVq7DsgwFutP2Kl9ShWvgz8oOv1yIVzSs2numV9jqBaWBY8tuoAaLUMR3iWAcscnLM+141oEXMZXuougA74oGUXVsUDHfDRUutDsVqG78hzhF2rolAeQGmAwXIZbJegWB1AsZrDgJOHR6rBOA/nE1IdAGUuQoMmWJVa0A4HMfgQ5qlitQyP0CgtDWE+kAsM+PsIgePVYIeMfw4ERQTvsehS5FkNnkPBCAXxGWwvHDfCsyqxgXjODse9DwLPI9K4BBDeZ9A3mPibx2BVvOi9MRfRBGlXa2B5EvU36nmgZU96x2XXQdEto0jKIB6LGUZlfHLpctbBHgidDCyCm7yDYfmeNE8VWTkwQK+G3KQVlLVpNaq3bNsoVgaQr5bBqIV/56YH7QrLusQG82rp66fjALkQrPk+ILQhtWwGIYwNLW+0fPlyLFu2DF/+8pcBAL7vY8KECTj//PNxySWXaOVPPvlk9Pf341e/+lV0bOXKlViwYAGuv/564zXWrl2LCRMm4JZbbsEb31hfB93b24u2tjbsAAwRKgAcfTTwGyHLbVMT0N9vKgkcfDBwxx0AgBcefhATVywB6Tc/0ocmzcLpp3wcn7r/r/jCkvm4/avvAnYkPP5uCpzXjHv9WTi5ejnu+faZ6Nmo7wYAAG0E+EBL/P3ru4BXzF4iW9raMffmPwMAcndtxE9u+CD2W/OIsWzVcTDjN3ejbFtYtONx3Hrx6cDTKUzEx4Sn+dN+4LHksu/64EdwffOXgi+3DAD/SjbM2+e9P8DWUhvciU248vdfxVm/+Eli2QPe9U2sbQvUmpf++Vs4976fJ5Y9+Js3YeHmF3D31Hk4+Zc346Lv3pBYFu9oAsaGM8zfK8Af9ThDkZxRAiaFIc0fKqH7F2YVLABsOPHTuDn3CMrWFuzsmYaPXnVdYtnPH3caDp//CBbS54BHa8BNyRPBRUd/ADfND2zXDn32H/j2TcnM5UePfBe+t8/rcX/+Xeh6cSvwnYS+DuDTh5yFry0/ASPJDty3+Z3AN1ImroNz+MuBS3F67VJM3/QibvvWe5LLrsgBrws2FPdvmYp9r30wuey+DnBMANC37Sqi43NmGyUAwEIHk1bfDCBY6B6/5sTEor866Ai8d8UHou8v/M/rE8tuXl5E7ZgCduWX4ujae/Cvj78ZpVpCn5hoAWcKqpWrdgIJc8S/e6Zh/rmCJ+kXdibOEU+NmIDDP/xN1PYNVFN3nnUCZr74nLkNyhzx2I0jMefpZ8xlSwTssrFg734Q17z7TJz853sxblPC3OMAV112EfrQhCtwDXBjf+oc8euPvA6vt+4JvtSZI2ZfcBMO9wnetvRbWH7VH1LnCFzUDDSF7MdvBoD7U8q+vxkvtvbgtL5P4LS/3ZQ6Rxz59uvwdPdEuBObccGfv4cP/vSbyfWGc8RFtXPx1nt+g8V/eiyx6CeuuACXs7Cu+6rA78qJZR88eT4Wz3oRAHDLQ4fiuF/8IrHsvy8fibsWzsO5D99fd47AsQVgUQ6TyjfWnSNwVAFYlsNjM5ox5w/bU+cIHJEH9s/jvLEfxanrSjjgYynj/mMfA664Ivj86KPAvHnJZS+6CLjqqnj93rEDra3GFRzAXvCWuvDCC/H1r38d3/nOd/D444/j3e9+N/r6+nDWWWcBAE4//XRceumlUfn3v//9uPXWW/G5z30OTzzxBK644grcf//9OP/88wEAu3btwoc+9CHcc889eOGFF3D77bfj2GOPxbRp07Bq1aqhvp1UoaY4DYK00x0497FvI+/V8Cwbi1eYnpFaFd8ODYrtIaD3GqhyTwyAB62+IYDhhDEc+PS/MKKSLRR9o5L366ilQEODYj35pioeLC1Z3mBKvYBkotTL6cNld7zirAaS7b16pDcw2vMAqzHbs3rig+AJf/yg1mkSWmdPS5acBtoZgKa0WCU12OgzpIJJkkbHvW+Vcf+MQ4GuGfULNyAMBP2NGLz6LDX6s1R3hrE8FmtSf5cu3eAyXS9q8p4I9RmemJbtfbvUHsKW1Jcht7k5+eSTsWnTJlx++eVYv349Fi1ahFtvvTUyGn7ppZckULBy5UrceOON+MhHPoLLLrsM06dPxy233IJ5IaKzLAsPP/wwvvOd72D79u0YM2YMXve61+HKK69EPl8/OqMkr7wCmJCfqqpKiMkDIFBLhUIoReWCDhT8Gj4w7mLMeLGAHx40Hi+TCQCAq55+N+zb3YAaBXDYO64HKRJUVgbRSv/8lwswkYZonw+kkoXyfqNx1azz8fmnro6utbW3G52tm+SyXM5sioDAB2rvxu+9gF6uzm0HGy1Y6RPgjJM+jpPonfiZd1B0uLL/SIwb2IJVj90XMbCMEODNxYju/TFZiZPZXcnP5fgicCzw2Uln4b6xU/DxH12HueNjBqPChHf1+gL+/Kmx0ul/umslbhp4E4BQLRXKx979QZw153dS2Yur5+BX/kp4nQ5qO+OHcfVBb8NNqw+GtawJT5HY4O09f+3FdQe2YiCfx+JNz6O13I/lE47D9y6ejZcseYf6YucovLP2Q+w7IOzC9ssBS3P4i3cAzq2dDQC4dvIncfi60DBPGFXWPkX89tw5+BsOQunRAsh22b34DHcZ2NqHwAD85ojD8J1DTsHbX74JH3n+69oj/Yu3D95K7gy+zLaBS1uwyWlHd207AOAd9EP4e39wnzUrbsRfJu+DGZ/9Ndy5nXj/Nz+ODbmRuHn0sdHvvCwBgAkWcGkLPoXzo9//C3EYhm/XAmaUAsBoClwaswFvrFyJPlbA7YUPhTcfL2bPdI3H7AtuwmmFB3B4dT42L70KTc3bAAAr/74TeStWeXS27YzqXVMYhX+0zsNF0y8CCMVf/nE6xtUEpqZEMPuCm+J7mdMGf0wTnvtbuNGhwBnPfw9/HnEwXiqOj8pWDumBRX08fdcxAIAfj1qFi2ddBPLn+P3zso8Xgo1YLytieeUr+MrhFwEWcOg9W8PwDwRLzg9iuXRMfxTrJwbRev/6x53ocK5Gyb4Hkry/GRtYOw6pXANVfEIworoTdxXeFxx4TzPAgPvGjsa8LRtQKgcD8LLaWfi5f5A09ld/9fs4ZevP8elHAwbyZTYCY0noRarMER/+1EdwyRNfw4ryI7jdW4zDLQvLRaMAAHoKSURBVIUps2L6/+cHLsVhk87BL/P3a+3V5M1FPDS7Bdvac9i8qx1PsU6sbHkOv3x2NW594Qh8BrH3EI4v4lsrvo3fLejEA9NiM4BpdzyCNW4nBpw8fLYdnuUAX/wsvnvTAzh8x3L0O1djesj+XLT8e7j63rfJrk6rCsCRQX3Tu3+Meze+HZ2iob0TBMIrExtXH/Q2fGH/IG/el1DE+xAwHQfSh/FXfwHKTvAciO/jSyeciW+OPSrqD5qEQ84Hwb+XzcSS5S9KP39x7Rn41amn4Dmf4JP9Hwc4Yb7EwYfmnIercsGYv6b2JlzgBGzShdV34Yj8AwCeBwA8PH8+vrf6WPzspfdH9X60diZu8g5GCX246oArQHaFk3Y4R6jyN+yL4jM7sGDKs/jC9hOAQjBHTPlNMJ/PffKfeMeMG9CKndh61xycwP4aqcUsj+Gl5c1Y9+smvAffQnmXhfy9m8ByFPbKVjxyz/FRWRcU2ydPB3btMj8vIFA1cZk9O3vZDLJXDIrPP//8iHlR5Y5QpSPKSSedhJNOOslYvlgs4ve///3gNKypKfiXpVwGaX3yhyjYQXyQSi6HWi6PzcUu9IcxYfx8YHDMjRfLTgHIEZRDG5hyrkXz+PFI4MlTLeQlmxY778s2LqIIeu0tVjsGasFArxaK8IvC4koIKk4e38frxPx1KBeLKLMCarmc4DVFIjsHgHtYpGxlwrLVfA61oh18F9rLqkQq6xeV2A05BwOe7iJbzeW0+64ghwG/AN9yQElMR9csB+VcHnYxH70DAPDsWmx3FKJAYjnw7DxqlqzTreQLqFkOUBGuaQU6cM/LYYAEbfQK1Pg+XmmZg6eenoAJxR1Y3z8KoqMDYQB8Gww+wICKnUe/UwRylrGugUoebQgnaUqCunKxx8IL9hgMuPoz86iFSlMT3GIRrm2j5tgYyMnlcggDQIb11iSPjLgtNT+YYChY3IZQ+lkB/awotd0PM/QxQjGQC/oUUIRXpNE7JzkmXWOitSmyv/n52CPxmSnvjK+fd6TYUVvQJt1LtVgK+rjQhlZ3V+C1RkhUtlwsAnb8zmbXnkcll4f4VKJ6wzJ54uKcRf8r91XbAVhctrmJRH2L5VzAyekhCnIElDEMJEQvfgV59LEWNJGd0Vh2mmrAThK5FFVQQNkvSEauA4UiagUnam/Zzyd6EOatGlb4jwI5gn6voLcxHAdv+cRVePKfd+PHD30Xdm6RsS5JwrHsFyk8l8IlTvC8SsEzklgIm6DmFFHJF9FfFN5hLocBGo4rWsb2ynagxUE154DlimCOHbV3V1u3PlaEeWrngh64d+cBV1ajMEZQJRZq1A7GNwCGEgZ4zB1qY8CP20R8H7VcLnjPSfNuKD4IKlZOagcA+JaFm8a1ojJ9Jh76rRC6xCKoCPUOkEL03svIw6e2VAezbKkNu1DCgFUAIR6YReKo68r4BIBHMR13YCUW7XgA2+4kuGvhFKAQzBHlYhG5WhWH3PM7NC/sgw+KWk4eb7YX2Mb5RYIqy2HAy8HPFYLgo00tUrsoYYGtZsb1E7SBslmqG7SahgXUjXcHnI7fBSFYU9jpRJdOsftXDVF/uUGxSu9Tmq7uAIB7WufjHoGx0L2l6lYhMzdiuzJytAwENlwtj009qjWL90p8DcobpdGgI4ubdW8poVB0HQYtlgcQjGs1CnB0br2GFTvxjxFvwvbtY7B+3Qx0blqGhdtWRD/zEPwHnnoWwAiq4UyU5D5ehYO1TE5QKKaPqBna6Y0pwm914E4VdnCGR3tM7nE911D4bP6CgPm7Iv92oe2m0P+6r47pLVqKe3gajf6HESul7y8XRkaf/+HPwLtqFxjPe6YYqHb8hP7L5eqJZwIArh93cmIbuNhwsbBbsaOwZOqdZVSp1cvrpPYukdkC5JhUoojzhApgRTljXWy3YczaHgYkHTtzNpaecBI22wl2TYZxGreBxPGVaE1rX3BAj0Asjn3X7se28jaAMeQMz8wr6MyEfB8ELjXv4WvKcSp9lhtF/TjK92GVq3HLiEMTL8lAjWpb6vso5vMYlXe0yECiuk51BVfd2XOubE/E20qi78l9627sAxc2LM+D+H7ixsvtUu+jtzn+bsOVzq8RuazFfAyxSW+qDIObQRQiDZYgOFuNxCoVwvuSmDxRdKKAntHVUwPshWJZ6eDmoukfxJsWfVGOT6PNKwnLsxDnJim0vuebz/2xewju8mJAxQiBBS/yVoiOp7Y+waU14aTosCUP1v1G/wNvnf1T6EH84ori+zQnymDQg2iJrYzqNDVuxXvg0niBsbwCLCGPjxXWO/fQw9EyohsVBH0lyX28xmycV3u/dIwA+Jp7DH7iHoznqe6+7Y5vRnXFyIANis7R21ogNS0RI2HACZX9sKP2VlyLM/BDJ06OSAnTctwA+uJlCmJJQaQ2JLkvv1AYgwfaZAPDW9ovwp86luHN86/GSdUr8DQbJ7c5fNenzf9vPDZQxLfKEwEYwHTY96+edBYW7vcz/HykHDiUGGzcTP2DKAukev85+kT8xRb6Qp2M3Opzo0KUaSAlMq9w+XI+GdzM6ItVJubcUnFFFrHgJU0Vfjy2nsFEbEUbdrTyXEUseh45iyfhlNttDj8R9wfP6sfW8lYADIcYvG5Yrn6kdNPmxJyDTW6ZKOKc8RwbgxvGJBum+yBGF3XL90FC0wliyHrPpaa4gmvgxpPPLfkBKzW98ExYd/Lsyt3MnYQNlGqLJcZA+tHIg7F5RAyELdEViyHyUo2EsNduhOL/70Swc+AvdTR7GQDQw14JVguGyOYmi0TMDWkM3PRZRfjEApFcPJWJpP6anRjnxnXNJ29HE9YhNpT2QUHhYdtGGbjVZW4Sjr9581PasfkTH0dTcz9qczvgzmgDAHSOLOKo7U1wPENuKfHxs/h6ZuYmeecnljbulqiJ8REWDZ59iARlqyG4SWZubDzLZNskQnx82n0rLnbPNasghEOX3/+58JB5xjHxLh2sCSNZBzajU2k7w9HVz0il/TB7kVyDzFQCMWOVfN1AnmyapB079fl2nLrgKvylcymOnHWn9rsT7mpfKI7DT7aOwIZQtaABeeHrhnyXFsOEmKJdG2koGRioRbyQafNbxwPFjuh4PeZGBTdqa6RUKdJ5cQv6bH2zFF1f6GMlYvDUEWMAEQLXSugzwur1fRyPL+NMMKEf8ufuUB7nRu0fRHv/4mJOaBklpwQwhtYw7Yl4j45T3yjYFCnXdDfiE1efN3XVKMDJFh0+CKqGtDeW54LkODurMnFinJv4WkGcG525uWTaB6LvC17+N1ZuvRtvGvnLsO31wY1rm419Vca8QuL+fV/HLGmc2ERgbgwo5qn85ES16N6QYXAzmEJFcBMsqRfhMziM/R6X4BMgJFBzJKlcctAnGT4wtSR+ddRSfnieRfVJdMRAOLCSOh5B1FmjEsrk79bMXYdA3p35hMCGB7+f4i/7dQrl6nhrGJ7R0lc24OIHRmvHR7TvwLKVT4C1OPAmNqFy4CiMG9cC3y0BhslTxHvxbwTFWXrwvO6d21Gm5tgKNSHjsWV6p6ZJVSjGwQ1owBu54UQiMjerF8fhD0zB1sSouUZNYXjsqE2/x6Gv3C0eUool+zVRQ8U2fGxibVodau2TyHopizYQMDebN00CAPT3tyaqpXJa8kKgJMQHWTzhEVyw6KvKjcTXYgKR16jXll3S353xudnp4GZb7TzsdN+Ayim/lxjb+syNhlok4SCBOckgaKsjvx9RJpdfjj63w2DEKVQUMDdJ4EZ8t0QCZQyI5g3O3OjeUkS7t7LAJI0vlHDZssvC2kL2RyjrWPWXMBO4MW2u0jYrxJcbWaPJxq0+qJG5KQ1si8CNLTA3N3kHSe+7qgBmlSG1fQ//O/Z4nLTgc7hm5GmobfCxZMdDaC4ExtCU+Di28gn82D0En6pciPsRJ3R1wxwXrTuCKOzqW+Xz7sZ/BXOhyOpRS+6zFmpI2oZ+ZOp74VELE+a1G3/fGzIMbgZTDGi+B+twNr6GbmwCSLDYqztZLs+ypWDMxlZhMeWDUAM3VvrOj6uzKNVVYMc9twn7P/JgJlS90zGDKzfBI5mASXmWGAh6t3ejUmNwBaq/nkuzCfw0+ebdkgdLSh3BSjZsEFCQKNu2KJawQPL7IhSgRX3COnLBXPRs22q8bk1YfE3Ra0EtTecsfotsTwhAhMnQFtzHxbabUmnIebBMrYyfeUxX6wUJ9GfOU35QwwRmE0/TxxdQ1RYvCmYANxSvrJmPxx49GP96KDl8Q7PXj8VbZRBfEOZX37Xx0osLlfsQ361wLxnBTWV5N6qLO5FryeZrQSzFbsOXNygum4Qd7rkgrbKtlKoCNNScemhE+Oy9SbLNibgObsslxwAR5efeganXJ4RIiRalUnXUDrw9ucjmRldLpeWtO37EXIxvHQ8wBhLOGWJvOqAzvv+NrN3YBpNaytRs2aggkNYQ+JW6ZBWfa2Rled3EaHNj+R5ImLFbVOl8svZWadyIrBABwz3+bKkeGqoC/9qxL37UdhTs8IFseyoAs5Qw/ItNw4fdd6IXHfgLlkfnHvG7P+KwP96Oju3bo/EtCgc3r9wzCr4PVPz4XaiPUUzroj5Q65leDPTKFhh7W4bBzWCKqJYy7gwYPErk3Y4wrvswAq9UfoAvtMU2K3xgpoXUXsd0xoGDIosKk2hYBQXw0e9/FQdvT3DtFGxueEh0ddHyq+b2UMhZtH0QlHe1oY/4El1dElgqz6R3N0w/HaxZOxZcg8JTJpOInWE6mLTkzWb0gSjPuLu7GxMnTtR03JEIwMWsltInOPGuqADICCGYyx4GANzVvjgqI6oPjOBGZG4cw3Am/LqCHZWBZSJKXfJvZuZGbU8BeloRF5aWk8kCAWMUW7ZMgGvw7uLS5A3ggE0err0/9nSxhaqefOhwDPR1yCf5ojtavPiK4e5t4hmxAwCw9hz8kUXkOx3ss/1BvH79b8wFQ6G2HH6ie+OdKFWfxEc82RaEEKL0l3RUwAxpW8QzzkUR5UN6wJrkdyDe1rYU5obLB6rnmeNtCc+LgsJVIxiHouac034PW2SHTLNqP8JAsKsgv4yCwGpQAZATosdFX9gSq97+7U82tsGcwFHvAAXhGH8/h9KH8O5N30dbd1E6Jw3cALoh7uVT3wPL90FzAViwBXbWh5xiQXUMuNk/AO+rno8vsLMABIa6XCzfhxWCne3PcaAXPyF10+WUa+jeHIQ7yFMb6nMQbW7+8UQbasKGUs02bpnCH3NxgU3PW6B1ntNQyjC4GURhwotkzKAmIOEkmwRnGQFDk0QBuwneUlz+7U7SshcDMXNjW/oOkTKgWK3I8UKUdupNU6jRBLuQgLkRngOhoMzH118nd7VmQc/vGUAAMajTzCa/AQBUcx1xGxrTcxOrjpgbooMb/j3Lrt+sltKHl8TcRKwRAaEWzsc1AAIPoVPn/Q8W7/dTaSIzZ5hnAduwbxdYrh64SVtQ0xJq6vXa8DXqfS3rNtsyqMxNxmSaVerAYgyze5NZDq3NgqH7VgELi+9wWdtaTc2qCaXYf9s9mDxgzhkWFQtdwaPvrIqx267F2wQ3b58xEEogFqyfXFnpi8ptFmADeX3hEMflVrs+c7MdzeYs0UIDKaHwEl4ZS9maM7CoHjvcZJnUUgN5ufKpuU1Ytn0bTt+Zj/sOYyDhYipeUbaTYdiv/GV8wz1Kqs9sUKy/ABGm8n6VIy6mVl9CnhGwgmAXk6KWImASuFnHOvG1cW8GZX4Uq0W8Os/wzkX1OmKg+JW/AttJOwAE9YRi+Z4ASIJaxXyGNhh2oSkIl4E8fDe+cg8jGDVFztIuAvCn1zbDFcaqmux5Jf4ar3FK/+wLgyoMe0u9VoTIQ81RqVzCmRthty10nogtEXpK7C1lflU/qB6Ol1mXdpzvVG2JuSG8GQB8OGnIWxF1gbcTIu8SMGl3xhDE9HhKdmqRd4vEYEtiADdJw8SFDm4sxkLTIaJlDhZ3J3xwUqqDGx5cMimqqriwZjUoFvLVIddWRNfZ80BsCkIpWtEbVkzwpxH7YV1+JB5tDhKkuin2Uaw9B39EPnXFbHb7YuYmQS31AoKX1KtEnOW2Qd07t0XHHOJJ4OZWf19sRIfWT214GnOWb9oOz5DVXpWLpl8EmwFtNeDbf16Li38mqwebKmXtXsQn8Jd5sbJP7L9ZIrj69dFHUG9eZhMZAJ/50qtgCABsI64j9QC1GegCJS8Ot7/DqeMmDWAnK0pq5EgUg+IkcEMryWkDwrMBAFbIxuj3RdCvxI3pb27BiZs2YJRH43mA+UAEboRxR4CfeUHm+q+6b8R6jMCTTI7wbDYo1p/vaPsaoVXBNTjz4fgMyFmo7NeN2n7dGgARhcKHKwCMXWGMLeIzbY4B9KzqslqK1yncs+ChRn1f8uQC4lhUQMBS+qC4Cufic3intOO28gWMmy17I4pzI2GycbM6JlbjNzgBPw6/Bef9YctM3O4txi+8/YNz/FdPLzUMbgZRJC8BRlDKKZQxAWzfT7S5iZC3sE2LbG4S5jqf6XEQgJj+tQ2GxxYYCPORSwI3RN5liu3gksTcAPqAIGDRKP37vC5cUTsdd/gLhTIG/XSCd4ZJTMwNZSFzwwhcxRDXMjA3oDSFuTEPk6JgN7SlaHBJNUyq2wV7H6eYQ2F6h3QtVXrtFtww4wLJGLsReTN+gLnsYZz8yk3ROzBdiYDh5zgKf8VSfBtvln7LhRO1mNU48PaJa3qMBVG41bdmwdPUUt3z76vb7nW5LjzSMiNSL3a4DPmwu3737j5ce38/mqv9+r0Il2KURIuCyDzanfWfZb3MylxqLRPhtIfXoAjAJmMS0GQAKCENGiAYWD+pSWa6v+TGYKNq2DSosgtFM5AqyRumU+e+TSti79iiHROFAZFdX8zc6PfltsrtfGLEFFSbAh6FxvplEPA6YqEg+GDt3VhUvgH/YLMAAL/w9sffvLn4bC3ox1m9pTr2myrUG1zFgg9CGByOsdpyoE023FRwIzM3XH0rAQehvOplKBsUs6hOLiJLbPkeLAXcFC0hiWtYrRtGGxOFFAsa3pZDNCjOIcq7s+BjAR4Sm4n7dkzE2bUPRfc/DG5eIyJStIwRfSNNAMf1E13BY+YmFi/BWyr63RDkSTzPBG4oCybaROZGsFXgooIri9VwbvUCw6lMGgRiuxkDdrVT/K+3GuLwNi0kxLCzT4I7npG5Ca/AqP6bUHVzJfQwMDA3hBAwxhKZm2Yh0/hfaDf+q0tZNA3qtppwE06TGAMpeShW8l623GKGIstxDy7Dx9Hi9gkTl/lJ7kITbscB2IZ26bgTTlTiWZorM9E+BOcST1JL2aihmK+f2Zf3X45xRaPmOb0+9tvihb5ZycwNgChYmvgOm1auQD3Jyty4rePRNMVHbWYrqvuPAgv/E4dksMhHnzKJ5gquGqYzC3M26d5kmwrt0eek4JOi7GJFyS7jw9MvwCtNRwMLZIC7/3iD0TFjqHdPqs2NaSztVOx5fMtBpS1Qa4hqKe4tJYEbAgAE2xGzVFU4OK32X/iKdxyABrylVn0yrjcCFcHVcsJFqc9QS7ElCcBN/HsBgVelNO8Lt+ylqKWyMDeqSnxU0ya8ddZP8ca+9HFG8wWoYU/FeZ8wKCy8oQ5V5ayAmTtfTEncOcQyDG4GUTwmTjbclkOwNidAzvOQFMQvqkfoYZabvOMBzCoZIJ6ceWRQ8Vpc2ZJDSuZcRUxqqd/7S7VyVPGW8gW7l9tvHYs1f4xdubeFBsK9eTl2CwBYts4MJU2j9s6JOnMDhDZM0HcsAN73q3U47e5b4fjBdYiVrJZKApYtNDZ0vX1rB25rUuKKKBMgVdSUdl7oGymGmcxOzrzNwHAxuxIdbAv2xb3a79xImDAhbmyCQXGSONGzFShtZVIjBhABBLs7cQK8CF+DleB5I4qbAm64FGsGFZPqtRF+FwOMZYEtLGN8Dq91PIgVeC2xkh3Y1TFfZm6YblBcX+pd38L77+3DW/6yE8ueinfqT7ZNwL0jx+I9iy9MMKSVZSdK0jP8/ujX49Guj+jxezyTDRyrE7OLRaDdCo2BTRux0a4y7kgM7uK+EzM3XWjsXWZlbuAU0RGO6SOsB4J2w0eeurBFY3DGUpkbAl9ibqZiXXSeSVTmxldzG0IG8RZLBxQAcNiEv2JmLf39k6JuzC8DMCIHXTQA/kgdz8ep0rYn+oYmIXEWGQY3gyg+0V/kvkt+En8hDK0DlcQ4N9xgVrRH6O7djjkvP4d9X3jceE6NWcaYChwM5QzgJljvGHIkmblRRXNFTzEoFg3aRC+VgbKNHc/HRo5n1C7DE+6Z2NwsuzoC0FQZQRvM4hJL85YiEXNDjOCvuczQXI0XBUItLat7PYNikblhJmWjMqm+/aoDsOqcWMdtCZMYSVlMmZOSTA7AQjyEa/FOjCR6glfeKmrFBsNGtVTKKpHkLaUUCtqqgmDIzE0BVaAQe/F4hjEDxAsSb7Npolr2vI/Wnb3JDRfOk9qVYUUU2cRv9wdxQp6cash7U2yT2UkAHYUO6Xn64M+3EXBTXy2Vd4Hp62rICXQgAcOLre14smViNuYGRclezGhcDICY2Lb6xA1oCAK4Wso0lr44YQxOHNURnwMCBh6ni6NTBoTz1SjRfioDw2Z2BTcvfX8cfQN+4HwKx9Bgo2DBx8r2F3Xmpo5aqhk6YyHP+6Lpgez44Amborj/JzA3jOGFKfWjNBvbmTeopUTmBvKm2rRu8bEddG+mAa0NWVOpD4EMg5tBFKcUTwC8s7a2LpDKzFi/NcXmJhBPmjEoDnrmYXT1mSfxKrONVC8f0DkqRsIMylXDNAVpNjdazBNVZZOwQqihx9WJX5SXWTc2+QeCmfKw1InjI0pgc6MHM+PeUr4WWJ2B+vJkTSzSMLi5s7w4rpMZyilxbvIlB9OWxLmRbFugn1MmaVYIbBtOmP5LzO58MrGcShEH9QbXL46oRgtuvQCKWUR1MeVqRJ258WR2Zf6bgVysQnATADbvvxtCDxWTh1VTheHgv/xFbocyAXPKXmxXJuZGeB+3VabizhWdWDtWX0QsW979Tq7V8KXDvqShxUaZG5Wp1dTEsCKDCsuXwQ2/QS9F1SleZ70QSuIqvN8IWHpmz0ZPPq8cZXXvKR8+nyS11GlXrsDy2d24ds7E6Fhge22Fn0XmhvcVAdykXh1YuOZplIi+OUhq9Qi7jP2tR6PXR+GjxalJ4MbKAG4GhHxd/0NOCY6L70lqAIEvBT4VmakQ3BAR0MSftzf5uG9ZvFloREihgOa8uikU8h6yDOBGidekgptXD9oMg5tBFZ/Jah61K1Aw2H4ylRvZ3EgGxekLbDDIiOSyF9QRfC9SYQcRVlEOGQOTzU3SoNdzBgEnvfwzrdy17nGynlac5JVbqMICAQUxoHsTuEm2udHj3PDLBQbFetYYAopcOfbYIpRq4CZNLVWBgxe8WJ3GCNGNvuvEeBCZmzTqhIPhoyf/ERfte53yo7KwqU0If6dU/H33wE2azc0O1hSW0ZkbKX7OyFnSc3ETIm1z5qYcFjWppcCYTvWraqnwb1dVNH6tP+X6kkEwhWuKIQTAUiLkXrZ1K2Z0zJAuUWrPR+3NKubxLh6j2MWNdSUtNwMNU1BkUUu9YeEY2J0T8OLBp+Ifi9owBi8by1FKce4ll+BNb3qT0Mh06sYHQ84Kg9YRs3o9iB8jS2DrFoADypk9JoIbgcWow9yseO5RTCHPaMcTvdHUNDfwAcICbyl+TcVgXBVKfPzRX4IvucfhrdVLcR09PjwvecMmq6VMMdKE+oV+tK3Zh9eA84XUzmIR7zx4CjrpTtRmBwBJBdHi3GkCN6J6mni+wQZuzzdSuyvD4GYQxVPyhSxomSp9j3bOieCGq6VEcMMXWLPwIEsqnczBjaiq4HUMWDSw/zHZ3CSMWdNk0FOV1SB/OmAENqFD9pZKMUirMhsUBKS5R6u7IVdwYkUZtbkEjzAIFqcBH8bLCLsSi8hgAzGbYjSCJE2goiqJ1PT21VlcROYmTdKy/ErlTMyN4Vz1bj5gygqdUS6ovhs/cQ/GH8g+AEzgRra5AbUhuhm3Jdjf8IX51BeCPkqNXKGvLRgta/qQ96so7bgZQMzcHLLlrzhjxUT85n0HZIgxI4PytDxCNtUj7AKQFj9im6fZcV03pbQgvZH/6gd2hdHDxYjbFD6oVwVAMqmlvnzKYtxx0SHwJs1Gb2u6dxUhOruZCtgIQ94KwEvM3NRfcjoZhesF3lpUMjY2OEfUrU13hgD0lAaRKGwXReDW70hqqfTxyAOZft59M/7uz49tHTOCG6/OpkhsednZfXBTWroUrQUHx4zdBW9Cs9ZGwgge8qcJ3022emJ5/f7aWrNFyR4KGQY3gyiekGtocW0yJhWVLM1RFkpFsamIGMchZkESFoEQSKixKt43cTTOeekR2Aabm3I42ZrUUkkR+k3MDQA8GibJfGpKU2SEmQRoVMv8CmwQEBBLN2wrb1YpcOBoQ24lIFgIX8JE6ZiF+ImpE6rR6p/qEzelFIwxo37eBwUhFEvtlzDL2gAn/4pebyPMTcoikR3cJDM3BOJ6G5dbBgsnQH/WquRqMv08iu4EANzsHxgk7bR5zQa1lAhuiCV5kfU45gjFHrHw+X/2o6satLWdleAYhoBmXFnzcVTvo2ja8fPw+oEU/TI+fuw8zB3TllEtJVzDNw5SwC7AUmyl+DfRhir+LL+f5uKziddX+2zzs+9HfueE6Psml8IOgzaKzA2FDxBufptteqeUgGQsq/bZJPtBIBjvBTsEN5y5ER5s7ZBrzOcJj1RkbnKUMzCN2dyYcExirCMF3FjwAQpNLZUm2njl8cUk9aHSRgncZDeYJvDhZ5tGJLG6u9B6dBDscMShh5nrZsA6jMDBlc9jUfkG4zMTmRs13g4A5HO7v3HaUxkGN4MovsDcFJi+YMQ2DwLaFX8P/4o2N0m5pfgxNxyM6kS2emQHxg7skg3Rwp4/Z1ugqko0KDZIkmvsP9CDvy/rwJpxMb0s5ZZKUUsB4Y5cWOyoOxYv3j4G25+VA5B9ZeZ47BOuoE/1nyX9dk/zWFSITG/31XzEcW6Sdt7iCqarpThzswZ6ss4A3BDMtTdgP+clgKrQDUZXcFEk5iY8+XD2++BULwYTadSuVWtOLRcdY4JBsZQGIJtW/Oi7H0NTR5wfiRJgDN0hfPfD29DVUmnMTc4xPyOXWEGsokI8cy9Rk1kyZtwNNwnZsI2LWIZbFvs79Qmc54LvL788C08/vRzO/eMicPOWLd8BAJzEboxVcGJXiqyaVTulZE8SEVD3eyvh1vYHETJN+6CwcyFzIywqNlyQkO0wqaXW+VO1Y0FbMrKIDTA3PmLmxjLY3DDHbAjrS+AmtrmxyHb0TL8BxTmdwu/122xk1pR2d1S3BR9UcEN4nBvRoDcdQVjw0e7F12wqD2Dus09iwoZXomM7lbQZIpgVvaXqqnWYB0/Ubqfsg2a9HF9/6m9+A6slmGOtpthQXmJuwr8vsp7A1d5w3yKQo77en1XwvzdlGNwMorgCuGGAPvCJvrgoBQAAwrhIVUt5NB9tSzQvh3Biq5Tjjrvq0Xvxhof+hvlbBwDCUl3BNYNibUUIbYEYQbmgqMSEtoiBxEz3YDcRlBbHainij8C2Z9o03e+ktniH/2LlOHx74zej70aqO9rwmb2lVKGUamopPpE/jmn4OVZLOV88UGl3zjReCtpEqYqqlnr5rpE4C1/DZf+4DPOe/GfcjhTmxh7oQun5I4PLGZgbIjI3/JjwexB3LnkC2l7ZCM8tI7/hGdgF2VtIAs5JBsVESZxJLUAINJdL2Nl5JIiLTIvxMxqp2r0wXS3FgIgtAMyh7sQWHnjvbcbrS+wBA0ZcZ6PjBhvPP7cP1q+bgc5yP+AUYVOCadWn8R12Mo7Dz+K6JVAffj5OzmBOkgz6IY+3gTDaqxwzyoITMjdihhUR3PgGcFNLmPLT4iyJInn4sToGxYShEDJzfIcvbsKSwh+IYESOcwPYzi4QQZW5u2opsd+MG1iLE9f9nDdKKneTdzAIAaxta+Jzw0X+DYuuNV5PTfoyfstGfPnqKyRbmVqO4qZlc3FM55UAFJsb4bm8wEal3xx8VPLiO1Dfefzbkueei++hEM+nlqhCZcCoHYEB9uOTdko1mVzZqQDQqTFcwKsnw+BmEIV5wi46TQ1fx6DYNzA3JvGog5I/EJZTLhh66mzeOCk6VHSrGLtjM/xw8DmGzMS1ue3Ga2ngJlJf6Tcq2txUaC6+m7DoGzbdCgcuDnaeRddRTbBbhR1cuDtVwVVOWOQYAJ/VYUX4QGTU4C0VNkdoe5q3FEDwMGZLuVV8UCmX2IA1sEdqKQaGTf8egUe/Ox21B6ikv6bwYVVijwhXmNwJKAprD5TuyyQy7hGZm3T5wyvfwZN3fwzwqqnRTC2S7OorsSeEAtXYeyXnxOC3IgBhj9CAuUmwV4nqVhrlAyiJ4KYOT59k/yayB0vHdWDC1dehfWAWTjtiNV6HOzEHT0XMzS67GTYHKqs+Fd6mQS019zjg7b+Pjo/14gjXqtQzKPZhRcyNrTI3YTETc9OZ5OotMDdpj0weI+kGxQwMBasU1s/bLcZNUVVAgUzYGG+6LIG5kSri7dlNtZT43icMrEGBmxQobVpPRgIffgZkTRxVmyeq3JDT094AQXZysRZzhjugo7ABPfZaAKpBsYU3Va7A+6rn4xE2JeXOAMI8VArCOKwFUZp3lEt6YbGvC+NOaivzsc8LG7C9ex22tMk2pCYWSTIoNowlK4uB2xDJMLgZRHnpQSFeCyMoTGuXC0S7aKFDNJti1MQyaSBY1EzDw6P5iAUaQWSUDRKAG+aLFGdYP/GBUkcUOVMUlrCYqBNE2pIh7s6qVGduJpRfxqn5BzHZ2gpKLRBxwk0AN/mCSMnLtL2J2eDOVoGPRRLIkBegJG+pqE7hOgwENSHQmU99beJNMigeOzbwspo7d258MHyP7kB4/8IKM+rx0zDprjh66n2L2+XLRJong+pSBHBR/8sObhh8IMxg/PDaHYnlrEgtpQtR1VIVEdzEz6hMY1WujwDcWK0pOnvmazY3BEBRUEslLOXxpwRwwwjghl4r81fsi5bDD8eUX/4CU/ffHyvxz+C5OSXYlGKnLWxqxi8L71NUeQqf2+K8RxdvS05fIBq7s8jWzAxuZOamBkJZqLLW777QalYFNTXF6qpSyjOXbW7SWGiAESaxaIC88VHB/7dpJ46+vw8rnhTTB8jMjW7wW19MaikRFEvsn1K/bRGQUjscN2bZcmFg1QHL/Jz+4O+reDclM6+xOje+rkct/JPNwC/9lYnnxeJjXd+66Ft5zQFgdBl+/bgeYFXaY0jsmHCcBb2snDe8VzEnny8HZwQA4umb5VdRKzUMbgZTFh0ZG7U6XUU0HyBH3s2FtB1hPs7szWNF2cbM0lYAQOeuHeDZl0VvqYKXg21RI7jxrVyyTjZkbmSbg+CzBx+wcigSw84xnIh1g7cE0GO4vJg0zpzfhsVxJCgFESdhxoO3yVJQmRsR3JjoUmHDp6qlGIDuCS2Ysii2ISG2ZfSWammJbX+k2C4MKHrBDjMnxDeSprEEm5u3v/3t+PCHP4yOjo64OuUWxHtq3j4Zdq0lQpgDJfV+TAon+Tc1rHp0HWMLZYnAkxbrSKgnweZG/C34YgHVOOJyzhbAjSXGiQra1nZM+s5VXTgogJIjMjf6OeJtJEaNJcC/54zGb1asw/ylB5svnmvSoi1zlsZsUAygFNuLjElgbpbBQpvUZ3k/EhhdQS2lMjeI1FL627W7mrVjANDZeRBGlC6Cu+bTWPr6ycYygAJukK6WCgyKZQZBYm4UcLNsVheWPFuRDaSlxJmA2sezeb7px8QNprQ5Up6ZQylgWXDcmE1yQnBTM8xtv/aWgymWbCYAOHPGJwAATf8O31UdV/BEYT4mt09Grhg857EzFsHKLcZALczKLZZN8PKikloqKGNbhnlbfJDhptkisZ7BMqilXk3mJpsV2bBkkubOeOLIT2wDUTppzvMABCqHbp+iu0yx45nH0F3ZgTHbN4EgAEOSK7gpR1UoHk3Z1RKKnp4ekHXr40P8PPgApcgbmRvzxdRFa87azVjr17Blhl6HyNxUaA5N1TKQN08yGrgJB404IViUIFdyojSV1CJRkC/AzNzYPs/yQ4wxcEZObEGfYMdjYm4IIZg4cSKOOOIIdPU/DdwlNBMUrV4FR554BkrdJfzw1h8CUCaTBLWUZVkoaok25QlQVkvxYxTMYITKM8uLNVDmgVo+mp0+oRwHrtmYG2fLeq18ksQ7uHrgRn4XInOTo/GOnRGCtsMn1GFudIPiHIAmR1xQTUbWwueExZkRgppDsKmjihHFEfKPi04DHr0ZWPEe2JRIFUa2K5JBsVBAAF5Jud0+jybJe4kHuRQXZIm5EbUNqIEQ7mxg6H9SnxRZPYJF+70b2M/YpPh0cYwoz65982IwwTuTwUfBKUFMHuIqChvp/FElwCFSArbIpuOZ23hD5fZksOqoZ3MjAVylfjtMy2ILzA1ncXbaBtVP2B7Rg93E3Iwb91YMvPt7yNsMaG3MFVyUae2T8Jm5n8HYA7rwytNPYNq+++Fv/3jEOGKZweAXUNVSwd+FlTGo9D2Mnwu/iWCOMQsEtWDzTBCweAaD47TgpEMtw8zNYIowmRiN5cIeT31Bp+z7mLL5FRTcWjRQxS6SFsTPt/KwWVKUYYqjjjoKU8ePFA7yXQIDCEXRAG4iCl1N1KdcvrOvjJnrt8LkJSuCm7GbN6K0807p+qJo4Ca6TxncOAJz4/msLnMT5RRiVDKsXLhra8AKqIkyDTY3NMwUfsABB2DWuE7pNx8UhDHMmzcPU0ZNwc/f+HP9DjPEGeHCmApuRNqcF0oarrFxN5dz134DXz70EljRzjdBZZTSpvyWddG59cQUYwcAHvfHy+CIWMABH4i+dglqEiqk9GAgsChJTUsRqKXkxm0C0JSLF5160d9Jwm6WEYCF90RVBuS464DLXgbmHqfZfER9SuL6VXVlUJ/J5g1AyPgK4CayLxPUosyKno0txLmp5y0l9cndWHhUdlOcJxy3BblqPE4YYShaycyNaY4kLTJjEIGbR28O/m58XPm9fpvNainRKyhNLRWGzZDUUqFxNLHx3qYf4K/LhXuO6hSqTOhj7tMvRu2QvaWyL8tvGL8UMztnorlzBGYs3x/UsmBTG09134fe/BbkqWCukODlJRsUB2WKVh6f37hZKicxVeHmMmAKzWtGUHfmWxl0GQY3gylSfAIjFxoUE8CNpCKIPJ9E5gbwKlUzEqc55GzZJTeuzEKpVMKimTHFHDE3xAehllktlTBbJEX0NA1bUQ20xf0Wnh0dpAxIZm6Ebujr7IJFCCzBU8b35dgznLn52bxYzcPdY1U7lGueeTCoXwEzrYeOTzEohsY4qIbe0zumB9eTbw6HHRbEkFi61KADF0U11jWAG1Mk56Tjju8hZwn9DCyKMSI+29S5J2zD9hGj8b1Zr9MWQ/kdmSfwt1cvluPvUAto6cEpp5yCgw46CHPGxwvDTj9WATKQADik5dyCzty4AEqCsaRXZ2efxNz4BDhqylH4/tHfTzgxBBYKcxPFNBEXDHWGD3NrJWGLtqMnIze5PfrOovEkMjcU5b7g/YrMjSV5Sxmmd/FYRg8pUcQxQhiDVU3L+sxQcFJsbgzXV8Gs9n52bZDbAwK/KV0BYWZuEtzwNbVUcLKsloqBzk7SgWpeZNl0tf72vFkVCMRxmmRvqfqbok9f/zm8dXQnzpU2r4FQYqFmV3Dj4k/gjfaPkcvlsGrVqhS1VPyZj2mTv0ZNCPZJQoadx1UCzKYLWQy+h0qGwc1gipGBAEaNfD0AoPkP3ACwKpQi2mexC/oewHwfpmWIURvr8z14Xe4pPKMEseNtEeMM8E8+fIASFAyu4CwBaid5bZmGi0g999suCkr+HRHhU4vKnhrhuWIrLCovcgzyQOIT4Fgh0jHlTAUjmMYCcNXNNoAwK8jBpzA3uXEtGoXaCLgR2yaeM2HCBFx66aU45phjjOXj8+RJXEqOFxUyXZNEAE52FdYbFv+egYoRir04a1/cOOt1qUUp1ReL77uHYx1GKAbFQb+cOXMmDjvsMFDLxiOYjvXoxh3Ni5Q608FNkhdKzqY4ZPwhGNc8DmPd9FhOyWopYOW4/bCwe2Hq+VRdjE3MjXoPQuLQM1dOwmGz4gWq4AQhBmhBZDD4Z4FtcBxMmh+oy0TmxkEtGjzGPir2490ANypzY+3agfz6FzGid5FWlkE27h5p98vxuDKAm7yjssuKWooA1eXdqC7tgp8QYdkEbmw/7heEAePnzDe2iTM3kkFxLQEYIQYporpsTbMOQLjwBMRSED9DVnBVVjz2L3xu1gQUTaka+D0QYDTZgEsuuQQrVqxIBjfCtbmb+9H+H7RyVdEMwtcZQFMk92FvqdeKULNaau7cz6Pn6k6U7gnRrjCwxJHHO5mo6vFDhaaRuSFWNCjuVJXlYaeyJDYpqKXAcqFaysDc5OJ76BAy9WreUmGDPEPflePcEOQSvAoAgFJLnlDCBVy1uZFiyrDgbqI6wkm/KNxr7C0FfABX4Q3sZvwXPhbYrcCgloKuH5aYHGU3ZRrIgPKcQoCZ1xIOmk5U1FLCG+cBxJKYGz6MJZZKZYJGzYsdToTfrDRmg3tw5U22BUoLDMzNBLoNp679kdIQPR7TeozE9TgN22m8w2WEwCIAzVkozU3oPwnAxLEovnTol/Dr439dN85NkieLTwyMS5JIGigd3GiqNQHcXPHGufjWmTGr15Sz+UnRMZPNzduvOgjFluC5iMwNV0sxEHPgTZrOnNQT1eaGAMht24SC32EsX3Ti2Ehfmvg3vJsJfcmklhKe1end58CxavKibPKWcij8zuQxZlJLETAcv+4XOKhyPz7R/WOc8F+fCH+Qy9oWZ250m5ugHuVaBubmjc/9LbFt3K08Kc5N0nXaTzwhsU6RCbfe8OU4R17CeJG7Z2g6Yetlq0KEeDGgZMzcGMDNq4gwhsHNYIqkzxY+EgvOdoHSk1YeA3MjLBRV31V23YJQK5rANHfnsCOLnWtFbQame6Mx2xsLEIq8wtzMcjZEStKNxQ1Y+YbYFTEx0ZxBxIFaJSRiboxeC4RKruAmo1eLEmnS6Rwr07w00hPHNxt5kDCKDmzDW/B9dGNTBJ5M6RZUcNPcLFyHqOAmickSd+zZbW5UEY3z8tFGMcljTWdugn4lfF/wZvj7nBX+Ijzb1FYE5XaOHJtaKmiZPhnm4WNEbRv6NwqqCdWDjFpxe4RJueBVIlak8zAHjOksY+uxx2LUpZdox3NWYCtlUTN0k9jSJG8fUx6lBBGvwRcQkpG5UaWUD9+ImH/L/t+gmmLMGOQKdoLNTS1SSxnH7B6qpTRvqagq8/wguoLnCUGbYNzPDONDbFKLtRnwXEBQ46ttlsZswqs0zTuMEYwrv4IzBn6BcYUdsGzHWL9DOXMTtyFfEoJZJlxTNCg+7pm/mAtBVEsJruCCB6E3qgBYBAc4z0nnjbpE7/dcRHBD5xwf/5DA3NiiWzhLBjc1IawH8fW1ztTf0gKEDrUMg5vBFJG5USeOhElUfPmcuRFJzwG3Pyqpn2xFg0KPwsvBTXzeeNaJg2tzYMMCLEvLRfTO42PVQ8Uqo7M5todIWswntk7SjokLXZUQ5MPMwI9O7gUATB8jAD3NFVxXnViUSLvoaUvlqJ1W+MRE5iayo1VmNsJdza105mbatGk44IADhJsyqKUM73R3DYo1A27hveXrMjchuFHvVTRwd5rBph+ptTJtAuC1WQkpEuRr6c+CAz2/lsyAgRBMxYtBq4T2t7s74wXTqwEG41u7ewQ6zzhDO56rE/hPunxaDJKsQTqEe2d8ARExhFpNGrhxdOamaP0TY/InwMrJbeX2DCJzEyR6DJmbemqp3Vh41Dg3QKBCNYEbBsARYhcFC6LkRqad07QgmHP8XBgR2C2H759XYrDriC6YrGJMEg2UG+LcADK4aR4f5/hKYm5E9r25lmyXxMGN5EQitMEb2wQc2ImRtE86j6axwcL5th3PtW3HHgsAaNp/f6m4CG442CeGGAq1BOaGz1XDzM1rWAY2dWBtbhweapmpeAAhceDBAG7EKazf60eSWgokjn+TFKjOlvKUCKcaJomu5njALOxehCltU+LmJ0wQJUN+GNE1WwQ321tquPWN/Thy3/a4LCHSsxo/O7BxmLFsRXTMIkRqPFXc1SljyHksMv4DBINidcAJaqk05uYtb3mLrE4ygJu6S0MDzI36fkV30GhNS7S54feq/ELkFZYvvGK7t5fXoZ7YCTYAMk9kAnqmxVVXS03Cy3g7foRj58YGxe1uL2zefr8GU9KcpPD9ErgZu8RYJqojJU5LVrWUbOvEWSjh3ASDYpOYmBsAoKSiqy7DIrZvPj7kaqmw+mXPrjMaR/uQ+2CwsUj3KG2e1IwbWsrob747OOBWDMyNfL+RXUcjzA3/2zUNOPFbSv2xOOHqPPFTn4qO5VNGPq9XdAEp1crmwojBjVij9N4Yizc6KUBcFCK8Y9HTb9Rll2LST3+KcV+5Tm6DAm4YYcb3WaOiQbFJLaXLsEHxa0SqL/XhXTO+haMWX69T0UmTqBhBlgMVIZbJrlrAdhgTZ1I72h1rzE1TYMQmdlxpOTZ0OpHlmdAyXmE21PsJ6zQFChN22TVAMiimeQdMAAoqc1Nq7cD7v/dzHHH2u+V2STS/AkrgY8yAPPBn7jMSADMwN6FNj8HmRiqn/qaBG2LUYcsGxbvP3PgGcJPE3FjlEdjy+D7YtU61jZG999pG9oSf42v1Vjfi5f5nkCb2bm6/PGMOEuWZhPc5AetQzMU7w47aTlAOCpp7YGJuTDYbAJAXwM2kN38EAGDZZvZJDCNw9rOyDVpm5kaQCECKgEZTS7Vr5513SBAh+CPHzOEVmSqXvnK2xJIeDYnUUpudDtzVtghrLIHpJHsGbmS1FMEBT65BZ39ZGi/r/3kqav3tuGlbDrbdHh2vFTfLgNcwPlqLDnothgp3MvAqgWoqRRKSrkeSlHQYAPzpq4B5gv2KBm6Cci3Tp0XHcsJ1VMKyzXHw9qZ2ibmxUgz4TckmPcl7FOBzrykCsElIe+xcYonsrWWhOH+exvqIe8UXRwKPna5Euw+lSmJwYzPBeJukMDfD4OY1IoTAJxYYodrimGTMZWJuRCPdil9Jdm6hVtSxJObmbTcDIR1pSXmI5LYamq/JjxYG7E1S4kyigKoTNtwmR/IVmBsAWNC9AEwccApzQ4gDO5eTDaGJrNOnyk6YMoZx/fJDamvLR95SkjArE3Oj2VtoBsX6xPy/Iw9DkxQQbPdtbjwT45YAbhiA9Q8chv5NMrghykI2aso0rD7vApz00U8JJ3v424afaXUWXo51/MmZfeN7zeU6DL/WU4sAcmwoAeT65bg/dk0DDEbNScyNI4CxUVOn4/SrrsW5N3zPXDYf25UdukFeRLOCG7EU4wBE3A1nsLm5ePUsPP6J1VgyUX+OceXy4hbZLgtdjoHEBwjBmxZ+AT8pHR4XkJibxhcecVzMmLsAreWqVtX2Zw7Fs7/+LDa6FJaVR+dzbwAAtK7bD5KVl+H9dYbRvqvcNscty8wN86ButHZLLcU3ZwY1qSh22Mac8A5zKXquRaNHY16hgHZTADCDxMxN3HafWmgKg2/6HSGgYH7gOptFCq3RxyxB9ES1lEcZbMf8HFduuTv6nGO98Q+cuTE8l2Hm5rUiJJ7utXeaCG5E2lbX14IRELAE48DYW0piboQIrSJIkF52ePwq+3rhWkLV4eUO6WwN22TupFRZwE9c+0ccsu1O6ZgIbpb2LIXo5ZrP5xRwE3qUqSST6H2igJttTitGl4NJ4sRRHZjZVMBBDg8/bmZuaB2bG525MXlLye90SWmcfE6TObGeSVTwa4pSmmxzA5jsJySVQPj25x58OMbNnCMc1/vl883Pw+ndGn236yR6BYDODj20bWxcLbIYZuYmKGbjexNXAQCumHJeEEOGi6OEEwBgtZjjh6g2N90TJqHYHKu8JA9/GgMNdTLM7i0l2txkMCje53TAygNzj5cOF3PmMSxULn3l5j3SdAFEEYqDHwlkA6A9MygWwc3ohfuAFIvIT59msLkhUYygrmfehOm3fxWlbbOT2xJKZ1OwmFe4fYdblW1ufA/quKu7gKeopSyVlUywuckJ9y2u/bzqx6c3Y2uphA0TzwO1CPapBOBsame6p6GaGw0IvLuuPuhylA/pAfLBZixgbbKC7cYAhcyuMOQS1qojNt0efXbwsnBBztyY6m6oKYMqw+BmEIVQEgETrYMlWKqLr8DKUxQXdsvGZdxY1OgtJUTtFcGN4Gouu4KLjQ2+HWXF2W6TyVP9+rz/W0oXsmoAKcs7DBHcFO0iHIvi/fgmPoBvwLZsI7iRgAaIEdz8wP8gvjruZPy5Yxmaw5Dt186ZiDuWzkSeG7kZ1FIMZrVU6iSZJc6NYLyHMYsBO4MLeIKIaqm7Nv4CDnkOFrYZy0b2A1ofMe/S5aBdcr+0Oi082PWgdMxOiKQrnWdw9+fPKNXIWgRg1MYPJxyBpct/hOvHvVlmTkyzpG1mxnJ11GhiTaI/FVUGwB4xN2mu4C09wCUvASd+O7nSnAncKEbnnnnEcldwo4is0W7sqqUxYtuYcc/dmHzLLcaxw2MEERBQL7DNYxJzo7+/Dg5uuNpDNSg2BN/jb9tg0x5e03SMhE1I7o9AzALmhfuToumE7+SV0QXcM30a/FwHqEUw0bVw6s4crj9+oblRoZjAjUesIABnZH9FUtYPXWaPmA2b2BjXPK5+YcjMDcDgJLmMi/HJJPd8fqaFfNs50jnJrO/QyzC4GUwhcVgx3eTG3GEsN9bztx3cjc63zJSWG8aQopaKbf3dBHAjbmKllx22T8p0zcSyCphJmCw12tEF1vS34Z7N4/HR1sDuR7S5KdpFgFjoQC/asTOYTCTVhB3WK15DATvhhPOwfwg+PvU8gBB5N0UIIk5CU0tldwWXbzSDQbFoONiUHLjLJGnMzZq+JzAq/z5MeyGggv+8RvZ2CETnYEzMTXBcXNDls+wRNpiyStjGUI3q1fVnZ4yQazAojiTXDEKANYXRCFyxJYpFv2bC7NWIt5R0CRXcZNx2lnLx9Zo7RhgqNtTjFNLBRQbmxjMkKpyGp7XnwkDwKxyOHW1zgIMuApa+I/jh8I8lXz+DMMZA83kQy2qABEpXizWF7FXM3CgGxQbVTGxzY54ox4w9x3gcMKifVeaGRygW3qHoJW16g1xdOtaz0NWSvsGxfINayvgwWVbiBkW7iLtPvRu/PP6XmcrL3ZwhQSslebpIhviRtxTDiwoofzUBxjC4GUwRn2YdVuAA528Yve5utO5cE58exucQ+xYL1R/GGAKCWkqybxDAjbxLFz8H3yxhVy76ZGlatSRwo9iekFpw9t83TcJtYTwIkbkp2AVN7y8vvFwtpaiIRDY7HI3iYuSo8zzhd6QyN+YIxdF1kiQLc1PeEX9OCbmeRUSbm30716LGLIzcUsWBd2/B9x9/s3xZwlC2AfWtqTY3XMQ+kaOynYnpGSSGqq8jZldkVS0lvPtCO9S0G/GX7NdtBNyI1apALzWvlSCzR8c2Du09o8NzG69Hkpyh//hyrB8meEldeMs2fCO3JojlpAoDHsACPLzvZ4FiB3D01cAHHgGW6G70jYgIyGlGo3PGxLFuAKzhO48CxnmVDMxNRB2oVwMAFAo6gxExz3XUUpy5EW1uktQ+LExyLILieu8+F77TCouZTzXoIIv+l70fFewCHGqO2KyKxNwwhpzR8xHS85X2P3yj7AJ/Ksp9dJi5ea0IIRFRoK4RVnu79L3L2Y7ZT34ftpCKgXsiyOAGoJWBumopSYTdjWgJb1JL2QnMjVZlwsJvKYsVFTdZ4SnNTjxRF6yCopogUvoFGiZnk8GNPEnwCVDcPThqUrhoN5fA3BgSZXZ1pdjIZIlQLIIbg4t8qmjeUnHbDvri3fi6F6RvyNUY1ElureXj4ZFUu1UJNEJ/fgCwoG0djuh5Ov4tfM47muIXWRgzydhkmcw2TYgZ+qzYFwrtEHt/PeYmiS6op5aSqpC8CWXJrpYyDJx6zE09MamllHgpvqCWaqowjDOkUwkbGDSDP0NCgPbxjbdJERHc2DkVJCSdla6WAoC7Lz0Mlx+3OPiiMjcGSfKW4nMbMYYyCOcQjUk029zkJRZUKK7TpZITR70+VAyZ+3UYgRvcY3BN7QScRa/Xyhn72CCJFOcmSS1F5HsV2zO5uh0AcMBjA1DD4wwbFL9GhND4lat92urslA+Eg0pKkGiYwH1GUNjwEuwdW7XfQBOcDLtnxUXEOTb8W3nyN9FiIQbyk8C40n5tFx4W7mrpkI9LmSWCQk1CCHYjcyNOHJHNjVBEuRGTl4gaUJMvWkk2N6b0Cx0dHTjrrLNw3nnnQZMszM1oQb9uUiukiPoeRZsbkiviOvdY3Oztj7OrH5TPYwGgZiAYVdkoVyJN1OZJpkhrWNixPvputQTX/dX+6zDjnJNwypVXo9BdP0KxqSMaAaAW/ykG4qSoMDfCImG0pU6YN7N4iETXGAS1lGkMynnJdmOCL42oW6SpXVZ5JIVB4c80a8TlrCKCG0thy5IXtfp9cnRbEZN7wvvf+Bjwh8tT28GBe22BPBfx2dHEEPFHpT2TqYcFv4cdjntLiV1hpJJzxnYPBgBsefyo4HoiuKnTh8QYOL8d8x5snu7hEHKHVIYFFuKNEDcNiequnQRukpibDj+4h46deijZ17wr+HXXXYdJkyahUChg+fLluO+++1LL//SnP8WsWbNQKBQwf/58/Pa3v5V+Z4zh8ssvx+jRo1EsFnHEEUfg6aefTqhtL4qgUlKpS1sDN+HOQWAc+CB0hQ7R7+ZAPA+5zXqwtWDXEZf92tNL8XTzO4COieplwjYB/sB2VB//hVHf7adRN4RAJUcAgIpdqMavEtYX/tScU5kbRUEmGRQHIEKkM5lyI1FeuDS1VHieHsQvBE+UYOxYfdGeOHEiRo402MsY0i9odlRLzhQa1Bi4EZmbuQcfrnlL9aGIC2rvwe2+HJSuxibDRzABztr1FA7f9Ge8de0PAQCuG7trmiZ4IM7mfeYZZ+DII49EYUxgH+XaDG2zJmPMjFkppiHpu0kjAGwdLX8f2B5/zrVK4EZceMwAIvXyiSKeJhoUq7vO7OqkdOaGqqxGFpl/EjDpQOBgQ5j9sG/1TGnDASdNjw77njhmDOrFIQQ3GnOTcCnRoDhtuoFooP5icm4mIH7UflcB75wQz7PcnlBjZwC4YfoAy1EM4ee/GT+a8hnsX/kSgDjODSEED6yYg7uWz0azgrSb/P/Cs7/+DHauWd6wWqoo2Fy+79BpOGxC0r0OHbqRY6L6CTY3JBHccBDpE8BW2via9pb68Y9/jAsvvBAf+9jH8M9//hMLFy7EqlWrsHHjRmP5u+66C6eccgrOPvtsPPjggzjuuONw3HHH4ZFHHonKfPazn8WXvvQlXH/99bj33nvR1NSEVatWoVxOjgS5V4TEO0y1T5eWLZOLGpgbrv/1CMFR48bgm88tQY1xVZWJ4rewwY+Bw063gH6rRy4iMTcEYG7UViw8Va6vjqFcvfxSxJWneT+JuSEqc6N7S4luwNxGJi4TfKYCoNHVUgnMjR8yN1YAbk477TScf/75qfcVXKxBb6lG1VKCvO5d78Ohi9K9LH68+Wr0uiei1z0NQPBuCIA5u55AZ207AMDzhJDtSeAmXAAmTZqE/fffXwr6xQM07m5+GGN/UWO8jBTc0pVcUCKlbwLWu41upCpESl6W7EH80sENcXYj3pGdB878NXDopfpvTd3Rx4WHx+olkbmRnj3ZG8yNYnuXhblJAze27vofyf7vD/7OO1GtEWsrcaUjwpQFJrWUx5mZnGKXQime7DgY6xAwR7awOo8t5DCllJfVMwywLAe1/i6higTmxvD8SwK4SbdPGTq11O4wN1L5lmBu9KFvEOzdYS0HSYYc3Hz+85/HOeecg7POOgtz5szB9ddfj1KphG9961vG8l/84hexevVqfOhDH8Ls2bNx5ZVXYp999sG1114LIBhQX/jCF/CRj3wExx57LBYsWIDvfve7eOWVV3DLLbcM9e2kioTSlQ7Tecbp6Hrfe+MDXC0kzEji5LPWsbG1lr77J8TCTlaA+8ILaH7qweCYwmCIO2ECRB2UgADHfQW4JDZormf8JYeZjw7G9btAaUWcNiER3Eg7KTNzI06OPmPS8+TPWTQA1XYbJPyngpuwy/P6p02blm5rw8Vgc5OqT24Y3IiMhYWPzp6M904Yidv2nWEsvdmdil73TDCUMvgyASzBKDhKlcHtmCQbFE6RmetMAiJckvKRSdIyCnj/v4CLn9fYJXFidIoG+7JBmDdFxa5mL5B122lYDCSD4t1hbkwy6/XB39WfMf7sGxFg/JgGG9x0dMRqIJW5MT052pJDYX7MimpstihpYRTGLglc6U/4RlCvyHR7DG/bmcdsextWOi8EvxtsE93Q9s5WmRvIi33OAIykoIkEsNR0MILNF6UEE2/8AQrz5mHSjT/Q6hLBTdU1j2QWsiam7OaDITK48eEIY8KdEsSHqs1uS2Ruck0CuFHqbkRFPNgypOCmWq3igQcewBFHHBFfkFIcccQRuPvuu43n3H333VJ5AFi1alVU/vnnn8f69eulMm1tbVi+fHlinZVKBb29vdK/IREav3/1nRLbRrdgy8HdmUW1FJ98Tpl1SvhdoHANl9sx/8zgN9dLDM1NrXhnIkUdoTRoZKEVZ+0/CSumjMDKqSMwOh+UP6a7XavLtFgV586P76kGOIV4Uee4QrTa567g8Ulm5ka6LmOytxRnbuqopYxeZjxCcaN8qYG5SY46jcZtbpS6mm0L/zV1DOa31K+HAaglLGxcatUtxuOWAo0kloZIfyRx28ZJ6jvH8DxfwSjtmFE6JgGlTgRBKYXLC+Cm2KovQoMxcba0xYuoanOTVS1lzPy2p8yNSZacCVz0DDDrGHM76kTFtRNSUDQqZ5xxBg455BDMnx+PfdXmZtICfcNAixbajpwqHNmDzUGhLZpkVSueHo9iBVmDIuEstT5vcXCjqaUgA3WT553aavHeCSGwHOE7JSjtsw8m3/RTFBct0urKCw4l5QRwI+1Kh0AkbMYgBfFzp7eifGgP/LFNiXGErCgLvYG5ea2Cm82bN8PzPIwaJU9yo0aNwvr1643nrF+/PrU8/9tInZ/5zGfQ1tYW/Rs/fs89BYwi2tzUeam0NXAflZibcJdw2fLLcO+p98IRgImkXtn3bOCSNfBGBPp20XBTzXJMWuLnFIwRTt3E53zsDXPxw3fuB9uiuHPZLNy6ZAYO62yBKiJQOP+QC3DNCZchPz3W+cMFSvk8Djz1TJAjZ0Z5HkVVR97Ky/p0omQFN8VL8RX1gcHmJpdXJu4o2ZyulgIaUTnw+jKopQCgM5y8Z6xurP4G5q7TV0yUvjMAuyoyuD3yHFnVVq1uNtZFFXBDJZdxmeUSxZqyH0aPie1nbIEVuHNJFx5Y0Ib1GBm2L9uzDmJxCzYwSXEMlGN7wnyXWuK+SBlw6gvBYjP7pUoDANhE44vgZrCmWQI0dyf+6icE9eMDZbDAzeTJk3HIIYdITJDK3Bzy1pn6icGuQmhXynNpGQ1MPCBTeyTng4zqSy+cBzS1lFLcBG40rzrRO4/IYKdeHxJ/rdTMG1QW/W9oRAQgbb6LMa7SDh45W2JuBMYzPN0jDJYyUIe9pYZYLr30UuzYsSP6t2bNmvon7YaQFFdwLqMu/yg6zzorQvFJ3lIlp5SYOwfUAgqtUccRgz6pDIC+PujgRpRW28Ki1pJxQRNBVG+uGa/0TJLdjb3AcHXZsSeidfns6Piophhg2dRWKGeCeoG9VENnk81N16pJ2nkMgO+ru+YwQnHDzI1uUGy0iDzvbuBDzzbsapuQ990o4ztkNocB6K/GE9Lbv3ADFhwhg6umpukwicbcGNRSpidVyFkSyyPmcyoXLTznxwCs4Ge0hROy3AOyt5QRwURjrbF3KZUXLwGG9z1Vwdv+3Itj7+troF6DWko0KrUHaYJvn5D6s59gc8M/DRa4MYktLOhzDhiDfMkQY6URcEMIcPovgBHTksuEYkmbO+FaKdfhc5mJuRHVNPk64MYp2ppayhbAbCObqO7EgH8kNC8YerXUvEol+SoJxJIdMjcmm5tX06B46Ho7grghlmVhw4YN0vENGzagp6fHeE5PT09qef53w4YNGD16tFRmkYH2A4B8Po98fvdD4WcWQS1liF8LAOg8NTDi3fmnPwFQEHBOHmiJ3iLhYOU7WzGAH9HAjTLJRcxN2o2YRbK54XVLGWwJELJPp846FQ9ufBBHTDgC41vG46qDrkJbPjQmFY0FVbWUiblR7snpDhZ30eam2CEbIPLb9hRwQ0IDbSfXoKpA1dv395vL2fndS7uQ6joCjGkr4JUdAUhQ11zVK0wLKQ9g1KjXG+tVwQ2V3PK5HY5+XtGxpOOiWur+f7wBbjUGYAdv+RtGzNkHZx0wxdiG6HrKXkvs/yagwW10KDHmDE+5jnANoV6LBSEFJm10w/ozVliPLWggqKBR3vEnYNd6oNtsf8UlV7BhhpGDy9yYxBLGUypbQdI3MnKlNjBqHrAlPWu9tIELx5HUlwzghjPhtqODMFoH3Ijs0NLXTwbdLsyxCnOTRbX56aduxtbzP4yDZ3TjTy8nFGJsqLCNxNyogSzlNsQfJW8pUS2lnPKadQXP5XJYsmQJbr89Trjl+z5uv/12rBAMT0VZsWKFVB4Abrvttqj85MmT0dPTI5Xp7e3Fvffem1jnXhMl8FyqUN3mxhEM9MQy+nX4pM6Zm+SLmRZCwAwikmRa5TaM2fAknGocTIt750iTiB/bEpWcEq47/DocP/14AMDqyauxYkz4fkSvIsWg2CQ8ynzPxUsx8v37wArtL6Q4N+okwp+Np0zo4aTWMiLFG8MkqrGrKe7QHkgdbIOLVgU0/7LJuhGmD0gTn+r6Smku8RlbE/YFDro4Plfa8dcBN8J30aukUm4BY/H1mr0+/Pid++Ho+YobuCqESjciUdppzM2ezPppKo2M1ZpYN8m7r4GggkYZtyTRzgYAVp0zDzOX92DyQjGEgX5jQ8rcZGErGMvO3ESV1W8zlfosv5Y0IPSmhH9NBsWN2NzkNOZGsbnJsLgv27UG5x82XSprng+GirkRr9C4/ot37wrRwc2rqZYaUuYGAC688EKcccYZ2HfffbFs2TJ84QtfQF9fH8466ywAwOmnn46xY8fiM58JPADe//734+CDD8bnPvc5HHPMMfjRj36E+++/H1/72tcABJ3lAx/4AD75yU9i+vTpmDx5Mj760Y9izJgxOO6444b6dtKFEnOwMYOQOt5S6nfZbiGkVMNBKNl/KIalXc0xi2ADsb9oA54T49wHsOD33wZR7EMdi8oB+BiyTVgac6OaBMrCVW12p8LOiLsH9SRiVksR3wbgoalNn9RSRRmkftYXnVnSJ5U37TMOPa0FzBrdipsflLd3TKGsVeZGjACtirXoVGBZrO4w2dwcOacHo1qfwIbe2LOjqDBfos2N8clkeFwERFJ9WummWNEKsCfzJ1GYG1FUI9lkMRkUC9cYNJsbs0xbMhLTlozEtu3/MP6+N9RSqhGtSZg6P2SZK6z6KQSojuMyMzcqW67WZ2JuukY3AX4QLdoHQCWDYhnoZRGT+cGA6wBh0xhB/d3PHojI3JjzWoUiMjc0fm4TOwI7taccD1PcZI/HvS1DbnNz8skn4+qrr8bll1+ORYsW4aGHHsKtt94aGQS/9NJLWLcuDlC3cuVK3Hjjjfja176GhQsX4qabbsItt9yCefPmRWUuvvhivPe978U73/lOLF26FLt27cKtt96KQqHB3fggCyGxWrIuYufGmgZvqbi+BCRPZHDjibtyZRA05W384Y0MN6JJDrDUwIrAd8Zi1Qwk3K3LzA2y7FKVDNLS4ttAcEGRuTHTnwy+H9c95sH3gYDCsmnmXDhJMvjgpr6snNaFzqacRmIUHRvnHxrbJjQCbtRdtilNQ3Pext8/fBgOnB57wBQcCycsCXL2zB7dKqmlTK8iKYigXChFLWWaJMN+sSe7Q4kcCvvTEWfOxhFnzUGukA0MFApjUitu2L5rN6Ueg7W3mJvU1yG+4ywLdkKKBqlKo81NVuZGB0+SK7gB3MzdP2YgGZhsG0ZkoJdJDNnty67YLiL9GWwRwU2a8b8UZmTft6NYDDZFxy7ZFwCwnTKUWuV7ec3a3HA5//zzEwOl3XHHHdqxk046CSeddFJifYQQfOITn8AnPvGJwWri4AgVvaXqFQ4nZsEK0FEGWqJBsWJz83jLTEworw1qNcRgnzFvCUq/5HrrdINi4+UICfJESeCGMzdCPYpXU6KkMDc8t5QoXoKbs6gf1i4bHvC8eLBZtSDezv4n1jdSrCc+BteBIdWtXBH1VlfP70HvlH6sDb9T2gBzozw4yeZGuJJtUclouOhY2G/KCNxx0SHoaSvgf+96Ib3NGfoFgRxxW/KWMoEbf/eYG4kDlQyogfyMDozbr476TJFZM6/Ek8TGuLGnxfWKWaS7dj+gY0Mi3EsntuA5BP18165AlTmkzE1WOxMJ3GSI0JRFLVWPuWnTjfv5Il7PFTxvAB62MA4YU5gbNML4hecI47W1t4beVgcvbBkLlHhbgwsRzwPbU/stg1i7xdzYWL7sVtRqWwBrFIAXAAK0jXGA54V8ia9ltdT/V0IQzZz1rOS97dsBAGNeeQU7T34zpkyZgqamJqkMSVJLhR2QU35PNc/AuY/9DJtbShjRpLtwByHvQ3CzBwbFss6NIGfJbtxqAMFEsWVXcAAYP/4sVKub0dSkG00mrfuit5Q2iAiwrzsVf/CejQ+FdiDzD9GzBDcqg87cNICUNKBACJgvhhRQGcDk3a8auFFa7FOC6hXD2C2TuoI+KwIf27bhunK28SxCiKyWkhgZ0+P2DeWyXEf8Itzi2EuXwW5uUF0JIJ8fhQXzv6IdH33ZcjDXB83IAO2piGD0THwdW7wCjn78YbhuMCcMJbgxRRDXJAg1LnzPAm4yqKXEdpiYm555wISVwEt3SU0BANuglpJcwQ0MrxRgFIoaihB0jm7SzkkVAUAtXvEr7Hz2J9jWsUCqk4ChuOZpNC89CKuPPrqx+utdXrhfL02Zo3igWVYeljUGjDHYlMD1GXqr8kQ2nBX8NSKEZGduvK2BQWpzXx9OO+00rFy50lBfNuYGAKZt7MVBT65B5yGH1mkl3+1mf/UEAXNjUktJrEDWBdpSXcGBGdM/gnlzv2B2QU9AN6LNjXo3hAAtrIjXl/eLj/mDN7n7bHCHTiOu4EYNjQBu1HDzaeBGdT81GRRzkZgbxeYmJ/DPPMBmy2ZzipVkoYnxg0xsAO3Ih+3cfRH7m9OabyCfVH2xWnOandjQStz2DmzDT2YyzNvyUnRsKMGNuJlLmlqs5pwc3DLfbC4oVay0+ezb9CIGbx+ijs+FJ0tf+WZxd9RScj26Gqp7QgtWnTMPJ3x4ifmkUEZd/lFY7e0Y8+lPR8fsUQvRsfJTaC8qiVMZYJX78bZT3oIpU9K9DhsVyebGSgH34nwrMOyEELSEAH5HVQasr1lvqf/vRFRL1SnasjrIIFvab7/EMvVcwUUjzitP/ywm3/xzFBcuTL+wIYhfJklUSwmLnJ9RvaKopeqJl8HmRo+EGdLOnrB4s/r6+1RZdm700QdJppR2Q8bPCaK95or1IxLrzI2sjsyilvrSKYtx/qHTsHKqPImaDIq5iHY1BSXqrkjVL1++HGcefjjGP/7vOnciCyEUNSRMrsI937Gzhlt31EDytvpTw/IqmgQMvijvy7JK8Jrj5LBDCW5kcz75qXadPQ/5qW3oPHkm4BQC1/az/wjkMjAcYl9eeg4wfplexNgM5c36crCA3lowLxjVUnVcwUVhjMEWxgI/ddqSkeiZ3JZ6buepp2L63XehMGuW9pu+yQvNGAxhHvZUxPv1Ry+K03yokmBQDADNIbjpVcDNYIV42h0ZVksNpgjgpt6M64waiRn33w9aStbHi7tIZjCQE91v+/NNKMyOA+fVlUZWBBK4m6trec6igAJuMokWxC9dkjILEAD7VyzQniJmNik75HBOIr6oAsvawAQ54ALgvhvCNg3uqD3srHPROWYcZq08qG5ZDdtQAt9P9rozgZs3LhwDGHCwKc4NF1uxuZF+U9QSozo6YddJCWG4OqpJ4Ea4pSoDKoKDWMPRpgVpaYDB/E8XlWmzrCZ4Y5cCTz4NYG8yN3I7CtM7UJjeER8Yl85oyBULbU7wnDJFKNaYGwHceAdfiheu/ysIpUawUM8VXKoWSnTmRveMWefh8L6GAtyI4lt5YMX5wBO/1n4jwpxHlTmlJe8AGMB2JVK6Ncj5zBqRYXAzmEIQJTfLMt9azek7l7pqKcnKPavsJnMTnCTUEqilqBSAL6tBsQBuMpRPSggIABfsLOCA1ckGwtQbRHBTNw7F7kuhqRn7venk+gWhL2KAopbKAG525zoic6OqpRzVNoGg4ZgZhBDUkLSA6c+eH9oTb6lxPsXlU8egK/famwo7OpbD9X8ffbeGcGGUbW4GsWIR0CQYF0txbuLdpVzIj23ArEMvwfnL3wtqWcb5Spy764EbALCFseC7gzMxJDM3Q9tPPbBkRk1ibuRxypmbHWUZ3LyazOhrb0S/iiIbY+75a+3f2Rt9ltVSIYDanR0rXxkaOJfb3JjVUrZ0LJtaSlQV1QccSTY3qRLeH2FCF9dSMTQoAtj0QTBqyp57Xe1WMwwaOBHcqELrBEmUy6appVKYG4PPJ22UuUlTS6X0V1F18NHXz6l/GUWFct6EkcmF/y+J8L6mTvkgcrmu3TLs3q1LS8TyIC5pGZgbk7eUXWtGpSjYfDF50c2XkjeWVh1vKVEYkw2K3doebqBCSdok0jrt2VPxWDK4aT70UOzEH4N2KBum1hDcqCP+NR3n5v8rochsUJxFygK4qYeBs7sS8/DkjYEb1cSEgeg2N1mlWYgGaNc3uExdI5NUVsLiO5aejZGFY5HftYcJU4XFY8bKQ3DY29+1Z/XtbjO0AyQV3LS17ZO57jS1lPhNBTcacwMkZhFOEpKmlhIuzpSDX3nrPhjZkscnj5uHsw+YnOE6sYwYl8Go9f+IiGOaex329vYmFR/caw8VcyPa3CR4TpkiFBf7x6C0cyKWTwtzrPnZE3RM6Yr7REsdTzcfTEo34Q0VuAknX2uImRufIRHclBYsij6rNjem8Q8AzqsIboaZm8EUIibOHNyXajIoln7PjG12Ty3lq2MNJFRTiOHUM1bmFIELHgs+Z4hAujtCBT34WPsMWM05bMUTe1ap8NwXr3oD0Gxwu98LorGCCczN8uW3YuOG32LChLMz153mLVUTUGZByQJ94PQudDXnMHt0kO2eEBKmKM0uaQbFkv1ZVD74u3hCB+697PDdGnMzlo6qX+j/jIh2L8HUvmXLlr1zZTFo4ZAxNwlqKZPNDSia+iaipRAazLPs4Gb/aSNw1YkLsGOghlGt6ZsvxuR799zBATeqcBVvYuyzQZI+zzeCGxJcPPquxiNL0iIM9jrYiAyDm0EU2RV8kF+quE60jk0slrmiBoP4qW0weks1Im17cg/1hQh6cELJ4Ct/X01DVMO9+AZw09w0Hc1T3t9Y1Slxbjwv7gBq/I9SzsY9lx4uUfpqEtf6QlFNsLkRxVTr7o63QV2IX3UR313wHFtaWrBz5060trYO6ZWpYlA+eBU75s9iEeFyauJHn/dZQyC/JCGE4KR9s5VX+6JbbSSFa7L09vYCLe3ahYYaLOxwPdldPxQCZeOjqKWSzDBezeE1rJYaTJF8EgebuRHq69TjHGSOk7IbejMCgoEcoCbOsvcE3GSQdx8yFQBw2dG6q2Q9IQKzwDyG4qwRsLuLKC3eA/sKcbF/Fb0ACICbmuI8T6SOWqoRSVNL1USjZUP/scWI1YRIrvpZJNUV3HhCY/W/1kXK8xaCm1NOOQWzZ8/GGWecMcQXjz/uifeaJhJzY+4bolrKVuYoxsHNvBOAAy8CTvvZ4LUNuoPoYDE3W7eqiXmHLreUKDtdz5jyghDIzI0CNJPSLOxRUts9lGHmZjBFYG4GG7FKQ2aEbsiadZMcgaAGG7i9GWC7xCMEOYvIi9wg3/PFq2bi1GUTMK4j2V2+e4LZZkK0uWGuD+JQjLpwyZ7tfBpN+jdEQgnB847QI4iZudkdSVNLuV4DEywhu8XceEmeXYPoqfZqTrh7S2gICsaMGYOTT87mhbdn1xuieUBcaDMYFDe7KnPDw1hbwOEfHcSGBaLaOg6WQbFmQ7l3sA2qSTHFQGDRWEWnekslMTevolZqmLkZTCF06Gxuar6NteNOBlb/N9Dcrf2eue9HmZQbU0vtaCKKWooY3X8HUwghGN9ZMrb15I8sw8GnzsSMZT3mc0UbjXA3tcfv5D8E3JjyaM1ccQCKLa2YvlyPdN1Y3clqKbdBAKWqCBq5dprEgTJf+yClMUlWGwz5lYXxNmTMTYIruNjNmhXjQL8RQL4boqmlBgncHHXUUXWutHeFAKBWDG6y29wMZavSZZi5GUwhYlbwwa9+w+hjMG6/Y42/Neot1SgS2a7YmDHIQd32tnSNa0ZXVk8Xb5CM/GR/18Gpcw+a8Q+4WAobTUtHwSk14V03fG+PDQ6psN+hyt6n1uBC0d5XbvjqWSQplElWea1CIpNaau9d2/x5j0VkaxKYm4pg6N7sA1XhN28vgZt8yUal38XEuSNSy2eVnp4e4PH1woX2Mrg558/AxseA7cFXQoKI11zU/pWUZmEwQqLsrgwzN4MposfAXn6nQxnEj4Bge5PuCp57NfPZNyBskAJryczN0MabSG1GuDxfiH6MuXw/OKMC5JkUlKwRkdgapSq3QZDYUqlhxdNr8Y5rrs9UnhCKC9h/o8D68dXp+QzlG2rO/weie0vttSunRCjeI5GYGzO46RBU0I4C7hcctudJctOEz4lv/fh+OO6CxZi8sGtIrzdUcsKoDgDA4pYQwIzdB1gcZ7mnACwamweoNjdJe6ph5ua1IgRDppYKZPcX6dLikeh/cCOqT/4uONDgDr+SI9jaTMCxOwP5P7O6sEFjbv6z1FIMAC0N7g49XS3VmM0NAHT0V9A60qw61IViX/wDX8fpWNHxu8RSry5B/58s4rt7FcHNoHpL1XcFF6NLizFnTrl8OTrHNJihu0HhNozFlhzGzmw8o3xWadx+rTH57IxxWNHejFVdSV51RFJLZfeWGmZuXjMymEH8duvCCdLx5hkozVsPb1MYX6aB9vHJakObfNLWXVVT8f84IYOmPvtPUUsNXecS7VhUtdTi8e27V2lGIM3VKhQslYbf42n+/wYmb1ikWDOvplpqMIdGhiB+75s4CjlCcGLIPnBpah86sMHltQK0m2wLp40Zge6c+RnnKVGYG/nZWkk2N4PXxIZlmLkZTBnKODcApu6bnEG8XooCQgiIw6TvWYUveKKXJQOwYWdZLbj3dcMp0n7cVPTdvwEthwwSNS1OtMWO5HJDLEM5YaS5gp936DSU8jYOn9WgO33GvpaYSw0w3vSrGSDsP1NEo969DG72RpybBFfwScU8HjtgHkoWxffZy3HxDHmh9lSGcrY7vcnCd/s8LHvu0SG+UrJ8fe4kfPTpl/H1eZNgWWuj4yp4/k/0lhoGN4MoRFJLDV69+aYmvP2aG1Bqa9+zikjil0zCpM8Eq+ZmVTe8OtK83xg07zdm8CqkFnDqT4DagNFjbW/JUFK90u5f6SMFx8K7Dp6aqZ78tGnIz54Nu6O9gcVu77Bh/z9Aor3tLZWWFXyPJCcElEtJPdAc5lwS433tDXCTH8J4V29vdeDd/ls0VwZeNYroDSPb8YaR7QCA/n7RFTybWmo4QvFrUAbznTr5Ql1gk6XvS540DQxKvsiJlivfOH0p9p/+f9N4bo9kxqpXuwVDuhuSvKX2QL9ALAuTf3ZTY4brQtlCQYlgbarm/weU0oAwJgZZ3LvMjaSxHcz3Mmp+/LmWwftOylw9dB3k8qlj8LtNO3DmmMHxjjIJpRQtlYHw26vPiFuWoJbSbG7M5wyrpV4rIoSC2ZOFQRVq1ffMyaQN2kN/TfESB0zv1usYXmz2ihw6cyTGtBUwf1zboNct223s2QvdHbf0gw68H75fg23XNwQd1krJwhCH/qd72VtqyJgbkSEt1E8hMdSu31zOmzByyLPJi+OvZ8o0HPKOdw7p9eqJCG603xLe+atpUDwMbgZZhiJCcSZwk427MX7Mepo/jF7+I6SYs/DXDx82JHlb0iIU7w1xnCRbpuG+V0+YkBxyrwfxG0RQrMk7bgdeeRCYdGDdov4QJa58NUR8jjOW748pi5e+iq0BqBChmCmJSP8Tg/gNe0sNsgyFK/jo6fVzKzXK3OyOQbEU/HN42/yqikXJkOiz01zB//Nk9+7/TaFXzfRS/Vg6/5eEMTf6vNe9pSTmZpArH7cvsOycTHPOUGXlfjXk/7V398FR1ecewL/7kn2JYbN53SWQkFAsAUEakyasoN4rUYKMVWF6BxstIherJMqLRUEHnepgUDr0Vi9q6ygdWzAtM75US2kziZXSCQFSgkYw6oiGoSRcTcMmAiHJPvcP4bDHZIEkZ3fPnv1+ZjKT7Pnt5neefTnP/l7N5tCD+6PBbE5ASooPSUmTkJiYpz4WonpsuTGKoNlSWnzR/PGG/8XBnXUoufW/Llp2yN1Sg2yOdtH/oX6wId+fYouutjcYdLbU8B7qylGJaPRNVq2PYgQmnH9PR/piqO7xjt7rpl+rBTt1IKytYcNU8L3fApABMxtDrVAcTcZ6d+vCN0+yFs91Rk4urrvj7pE/0FmqvvAh9GkoU8FVNw68v+jv9U0joJcP1HAY4wj/GiiRlpSUD6/nFtjtkZ/FGLYViodIhrLQpM6pWlHDOCtrKL6p08DnN9Rnhab7jA0RkxsNWdOckLOvwUhfGC5pb6ngbwJDaLmZnDYZ9cfq1TuT6+lbPYWF3ruldLSkki6YTCZcccXGqPxv1YBifjRoIvgaYrXq+1LNRfwMzmQxAXYL0B+IeMZ6SZ/zqm6pS79w/WTaT2C32FGI7cDhnQMfS3n8S35IigG66pYahJHGV8S84G6pKH5bN5Lg1pqYTW44oNg4hrfn9vBNO7sk/ryrxly4IKAa6TeULQmcVifu+959GGW/+FRMMg69t9wwudEPttxoL5ZabkI95xxQbBA7/u8Eus5u0hipb72v3l2MPYc7cN13L75iriqhGc6FS/VCHfz8bGPDuwsvEemPXsbcuNId8H95Gimjw7thZiQEJzcJCRFelHGIQg0oZreUQTT6v1Z+j9STmuxMwA2TPZdWOHiczXA2k1Ttij3wDK0Z6UiZ8+OhPy7pkl5bbq4qG4eur04jfWxStKtCZ+llttTN938PB2qPoODGnKjVQSux1HLD7RcMzmrSedOsqulY++QmYUwWzDbjzUKJV3pKboJfbr5bL21/K4qc4NaaaE7scXsScd2PJkavAhqKpTE3XMTP4IKb5vSY25iCVzoe1ieQHs+KwkVPA4rNTn03y8c7k7rpJnoVMZBYarmx6HDMDZMbDYV6gnXDPLwBxQrb4P3YEyasgcWSiIkTnxhuzUiH9LTOTeJVmXBemQ73vAnRrgoNQtWoG71qGEosjbkJ2XIT4XoE03c6GGOsem+5MY9wQHHS4GN7xuX8N3KyF8FkGvqqx6RfuuqWspqR9qNJ0a4GhaCnRNgoYqnlJlQLDVtuDELVLaXHN/tIBxQnhd4Fl4mN8eipW4r0LfibO9dW1EZMjbkJdb3jmBtjsAZ3O0evGiEFd0WZhjPm5gLJDRmPLhN00iUu3Ke94FXn9d4tFeq7cjRfFkxuNBScveoysMEtN8PYOBPucdrVhYgMg3mw9vr6zu/yHqstN5wKbhB6nwo+3I0zFVkFwPSlwGUXXzCQiOIHW26019/fr/wes8lNhOsRLGwNDB0dHSgvL4fL5YLb7cbixYvR3d19wfucPn0aFRUVSEtLQ1JSEubPn4/29nZVGZPJNOCnuro6XKcxJOoBxTp8swdNBR/Kxpnn72QCyqqAa1ZqWCnSE12+bkn3mNxoLy0tTfld713EofaWMuT2C+Xl5Th27BhqamrQ29uLRYsW4Z577sHWrVtD3mfFihX405/+hG3btiE5ORmVlZWYN28e/vGPf6jKbd68GWVlZcrfbrc7XKcxJGa9j7kJHmcTzZW2SLeEw0FpGHR+7Y1JDocDq1atgsWi/8kawQPKzSYgcPZjJJqvi7AkN4cOHcKOHTuwd+9eFBUVAQCee+453HTTTfj5z3+OrKysAfc5ceIEXn75ZWzduhXXX389gG+SmEmTJmH37t2YPn26UtbtdsPr9Yaj6iOi96ngqnVu+E2LiDSiallgfqyZyy6LjT2ygi8nCRYzenSwqW1Yvr7X19fD7XYriQ0AlJaWwmw2o6GhYdD7NDY2ore3F6Wlpcpt+fn5yMnJQX19vapsRUUF0tPTUVxcjFdeeUU1qnwwPT098Pv9qp9w0PuYmxEPKCbDY7cUEQ1V8DIoCcGzco3WctPW1obMTPW0YavVitTUVLS1tYW8j81mG9DF5PF4VPd54okncP311yMxMRF//etfsXTpUnR3d+OBBx4IWZ+qqir87Gc/G/4JXSK9d/SoViVmyw0REWkguOXOkWBGd08UK3PWkJKb1atX4+mnn75gmUOHDo2oQhezdu1a5feCggJ8/fXX2LBhwwWTmzVr1mDlyvODYP1+P7KzszWvm0XvA4pV3VJsuaGBxiSNiXYVKEbZnFacOdXH3drjUPCA4nFpl2HmhHQk2q2wW6N3nRlScvPggw/irrvuumCZ8ePHw+v14vjx46rb+/r60NHREXKsjNfrxZkzZ9DZ2alqvWlvb7/g+JqSkhI8+eST6Onpgd1uH7SM3W4PeUxLHFBMsW68ezw2/sdGZDg53Z+GZtEzM9DfG4DNqe9py6S94E6BZGcC/mdBQfQqc9aQXoUZGRnIyLj4h57P50NnZycaGxtRWFgIAKirq0MgEEBJScmg9yksLERCQgJqa2sxf/58AEBLSwtaW1vh8/lC/q+mpiakpKREJHm5GAt0PuYmeCr4cLZfoLhww7gbol0FikHWBAusCWwRjkfB3VKZo6J/LQbCNOZm0qRJKCsrw5IlS/Diiy+it7cXlZWVWLBggTJT6ujRo5g1axZeffVVFBcXIzk5GYsXL8bKlSuRmpoKl8uF+++/Hz6fT5kp9fbbb6O9vR3Tp0+Hw+FATU0NnnrqKfz0pz8Nx2kMmd5bblQZl442RSQiothliZfkBgC2bNmCyspKzJo1C2azGfPnz8ezzz6rHO/t7UVLSwtOnjyp3PaLX/xCKdvT04PZs2fj+eefV44nJCRg06ZNWLFiBUQEEyZMwMaNG7FkyZJwncaQmHU+FdxkGeHGmURERN8SfO3LcDmiWJPzwpbcpKamXnDBvtzc3AFTuB0OBzZt2oRNmzYNep+ysjLV4n16E9wgq8fkJnj697A2ziQiIvqW4MuJRyctN7zCaUg1W0qHg25UC/exW4qIiDQQ3E4x0TsqehUJwiuchnQ/5oYDiomISGMnTvUqv2enJEaxJudxzp6GzND5mBtOBSciIo3958RMlOSl4trvZqj2mYomJjcasgS33Ojj+VULHlDMbikiItKA02bB738SesmWaOAVTkNmva9QrMuMi4iISFtMbjQUHEw9phGqqeBEREQGxeRGQ3pf54Y7gRMRUTxgcqMhvY+5UU0F/9YaQ0REREbB5EZDFr233LBbioiI4gCTGw2px9zoL73hqsRERBQPeLXTkP7H3AQ/3eyWIiIiY2Jyo6G0hPPLBulxzA0X7iMionjARfw0lG6z4rdT8+Awm1Xjb/RCj/tdERERaY3JjcZuSE+OdhWIiIjiGvsp4hWnghMRkUExuSEiIiJDYXJDREREhsLkJl6xW4qIiAyKyQ0REREZCpMbIiIiMhQmN3HKlpsb7SoQERGFBde5iTO5v6/GmdYjcE6bFu2qEBERhQWTmzjjnDaNiQ0RERkau6WIiIjIUJjcEBERkaEwuSEiIiJDYXJDREREhsLkhoiIiAyFyQ0REREZCpMbIiIiMhQmN0RERGQoTG6IiIjIUJjcEBERkaEwuSEiIiJDYXJDREREhsLkhoiIiAwlLncFFxEAgN/vj3JNiIiI6FKdu26fu46HEpfJTVdXFwAgOzs7yjUhIiKioerq6kJycnLI4ya5WPpjQIFAAP/6178watQomEwmTR/b7/cjOzsbR44cgcvl0vSx6TzGOTIY58hgnCOHsY6McMVZRNDV1YWsrCyYzaFH1sRly43ZbMbYsWPD+j9cLhffOBHAOEcG4xwZjHPkMNaREY44X6jF5hwOKCYiIiJDYXJDREREhsLkRmN2ux2PP/447HZ7tKtiaIxzZDDOkcE4Rw5jHRnRjnNcDigmIiIi42LLDRERERkKkxsiIiIyFCY3REREZChMboiIiMhQmNxoaNOmTcjNzYXD4UBJSQn27NkT7SrFlKqqKnz/+9/HqFGjkJmZiVtvvRUtLS2qMqdPn0ZFRQXS0tKQlJSE+fPno729XVWmtbUVc+fORWJiIjIzM7Fq1Sr09fVF8lRiyvr162EymbB8+XLlNsZZG0ePHsUdd9yBtLQ0OJ1OTJ06Ffv27VOOiwgee+wxjB49Gk6nE6Wlpfjkk09Uj9HR0YHy8nK4XC643W4sXrwY3d3dkT4V3erv78fatWuRl5cHp9OJ73znO3jyySdVew8xzsOzc+dO3HzzzcjKyoLJZMKbb76pOq5VXN9//31cc801cDgcyM7OxjPPPDPyygtporq6Wmw2m7zyyivy4YcfypIlS8Ttdkt7e3u0qxYzZs+eLZs3b5bm5mZpamqSm266SXJycqS7u1spc++990p2drbU1tbKvn37ZPr06XL11Vcrx/v6+mTKlClSWloq+/fvl+3bt0t6erqsWbMmGqeke3v27JHc3Fy58sorZdmyZcrtjPPIdXR0yLhx4+Suu+6ShoYG+eyzz+Qvf/mLfPrpp0qZ9evXS3Jysrz55pty4MAB+cEPfiB5eXly6tQppUxZWZlMmzZNdu/eLX//+99lwoQJcvvtt0fjlHRp3bp1kpaWJu+8844cPnxYtm3bJklJSfLLX/5SKcM4D8/27dvl0Ucflddff10AyBtvvKE6rkVcT5w4IR6PR8rLy6W5uVlee+01cTqd8qtf/WpEdWdyo5Hi4mKpqKhQ/u7v75esrCypqqqKYq1i2/HjxwWAvPfeeyIi0tnZKQkJCbJt2zalzKFDhwSA1NfXi8g3b0az2SxtbW1KmRdeeEFcLpf09PRE9gR0rqurSy6//HKpqamR6667TkluGGdtPPzwwzJz5syQxwOBgHi9XtmwYYNyW2dnp9jtdnnttddEROTgwYMCQPbu3auU+fOf/ywmk0mOHj0avsrHkLlz58rdd9+tum3evHlSXl4uIoyzVr6d3GgV1+eff15SUlJUnxsPP/ywTJw4cUT1ZbeUBs6cOYPGxkaUlpYqt5nNZpSWlqK+vj6KNYttJ06cAACkpqYCABobG9Hb26uKc35+PnJycpQ419fXY+rUqfB4PEqZ2bNnw+/348MPP4xg7fWvoqICc+fOVcUTYJy18sc//hFFRUX44Q9/iMzMTBQUFOCll15Sjh8+fBhtbW2qOCcnJ6OkpEQVZ7fbjaKiIqVMaWkpzGYzGhoaIncyOnb11VejtrYWH3/8MQDgwIED2LVrF+bMmQOAcQ4XreJaX1+Pa6+9FjabTSkze/ZstLS04N///vew6xeXG2dq7csvv0R/f7/qgx4APB4PPvrooyjVKrYFAgEsX74cM2bMwJQpUwAAbW1tsNlscLvdqrIejwdtbW1KmcGeh3PH6BvV1dX45z//ib179w44xjhr47PPPsMLL7yAlStX4pFHHsHevXvxwAMPwGazYeHChUqcBotjcJwzMzNVx61WK1JTUxnns1avXg2/34/8/HxYLBb09/dj3bp1KC8vBwDGOUy0imtbWxvy8vIGPMa5YykpKcOqH5Mb0qWKigo0Nzdj165d0a6K4Rw5cgTLli1DTU0NHA5HtKtjWIFAAEVFRXjqqacAAAUFBWhubsaLL76IhQsXRrl2xvGHP/wBW7ZswdatW3HFFVegqakJy5cvR1ZWFuMcx9gtpYH09HRYLJYBs0na29vh9XqjVKvYVVlZiXfeeQfvvvsuxo4dq9zu9Xpx5swZdHZ2qsoHx9nr9Q76PJw7Rt90Ox0/fhxXXXUVrFYrrFYr3nvvPTz77LOwWq3weDyMswZGjx6NyZMnq26bNGkSWltbAZyP04U+N7xeL44fP6463tfXh46ODsb5rFWrVmH16tVYsGABpk6dijvvvBMrVqxAVVUVAMY5XLSKa7g+S5jcaMBms6GwsBC1tbXKbYFAALW1tfD5fFGsWWwREVRWVuKNN95AXV3dgKbKwsJCJCQkqOLc0tKC1tZWJc4+nw8ffPCB6g1VU1MDl8s14EITr2bNmoUPPvgATU1Nyk9RURHKy8uV3xnnkZsxY8aApQw+/vhjjBs3DgCQl5cHr9erirPf70dDQ4Mqzp2dnWhsbFTK1NXVIRAIoKSkJAJnoX8nT56E2ay+lFksFgQCAQCMc7hoFVefz4edO3eit7dXKVNTU4OJEycOu0sKAKeCa6W6ulrsdrv85je/kYMHD8o999wjbrdbNZuELuy+++6T5ORk+dvf/ibHjh1Tfk6ePKmUuffeeyUnJ0fq6upk37594vP5xOfzKcfPTVG+8cYbpampSXbs2CEZGRmconwRwbOlRBhnLezZs0esVqusW7dOPvnkE9myZYskJibK7373O6XM+vXrxe12y1tvvSXvv/++3HLLLYNOpS0oKJCGhgbZtWuXXH755XE/RTnYwoULZcyYMcpU8Ndff13S09PloYceUsowzsPT1dUl+/fvl/379wsA2bhxo+zfv1+++OILEdEmrp2dneLxeOTOO++U5uZmqa6ulsTERE4F15PnnntOcnJyxGazSXFxsezevTvaVYopAAb92bx5s1Lm1KlTsnTpUklJSZHExES57bbb5NixY6rH+fzzz2XOnDnidDolPT1dHnzwQent7Y3w2cSWbyc3jLM23n77bZkyZYrY7XbJz8+XX//616rjgUBA1q5dKx6PR+x2u8yaNUtaWlpUZb766iu5/fbbJSkpSVwulyxatEi6uroieRq65vf7ZdmyZZKTkyMOh0PGjx8vjz76qGpqMeM8PO++++6gn8kLFy4UEe3ieuDAAZk5c6bY7XYZM2aMrF+/fsR1N4kELeNIREREFOM45oaIiIgMhckNERERGQqTGyIiIjIUJjdERERkKExuiIiIyFCY3BAREZGhMLkhIiIiQ2FyQ0RERIbC5IaIiIgMhckNERERGQqTGyIiIjIUJjdERERkKP8PZouVr9O6SysAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for ii in range(12):\n", + " plt.plot(samples[:,ii, 4])\n", + "plt.axhline(true_params['e1'][0], c='r', ls='--')" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "fe66b889-23ee-476a-9d52-1e15b2b2118f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for ii in range(12):\n", + " plt.plot(samples[:,ii, 5])\n", + "plt.axhline(true_params['e2'][0], c='r', ls='--')" + ] + }, + { + "cell_type": "markdown", + "id": "17bc6bb9-d5c4-40ba-a70f-101315ca0d4d", + "metadata": {}, + "source": [ + "# Vectorize" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "fe12a20c-173b-4344-9e0e-5e2654113247", + "metadata": {}, + "outputs": [], + "source": [ + "# samples, _ , _ = vmap(pipe)(run_keys[:10],\n", + "# target_images[:10],\n", + "# _init_params_array[:10],\n", + "# {k:v[:10] for k,v in fixed_params.items()}\n", + "# )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "442c496a-ad09-4722-ab28-45f5e06e65e1", + "metadata": {}, + "outputs": [], + "source": [ + "samples, _ , _ = vmap(pipe)(run_keys,\n", + " target_images,\n", + " _init_params_array,\n", + " fixed_params,\n", + " )\n", + "# > 5 min" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "7630c5da-0f4b-4bee-b198-49fd6e4de5c4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 1000, 12, 6)" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "samples.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "222a6967-ecfb-48af-bd0e-31dc20e18cc1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "jj = 23\n", + "for ii in range(12):\n", + " plt.plot(samples[jj, :,ii, 0])\n", + "plt.axhline(true_params['lf'][jj], c='r', ls='--')" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "8d17b0e4-8ffa-4a61-9308-60e322d08ce9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "jj = 44\n", + "for ii in range(12):\n", + " plt.plot(samples[jj, :,ii, 1])\n", + "plt.axhline(true_params['lhlr'][jj], c='r', ls='--')" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "id": "f96e8f0c-0635-4add-9923-be56b2238adf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "jj = 55\n", + "for ii in range(12):\n", + " plt.plot(samples[jj, :,ii, 4])\n", + "plt.axhline(true_params['e1'][jj], c='r', ls='--')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a66dbe47-8990-4c23-897c-1f0f42e6cb20", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bpd_gpu", + "language": "python", + "name": "bpd_gpu" + }, + "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.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/old/test-matplotllib.ipynb b/notebooks/old/test-matplotllib.ipynb new file mode 100644 index 00000000..fa24a3df --- /dev/null +++ b/notebooks/old/test-matplotllib.ipynb @@ -0,0 +1,309 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "bfec722c-4972-41b4-8b42-4bb35bb41c64", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/global/common/software/nersc9/texlive/2024/bin/x86_64-linux/tex\n" + ] + } + ], + "source": [ + "!which tex" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ca58af7d", + "metadata": {}, + "outputs": [], + "source": [ + "# from bpd.plotting import set_rc_params\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "from matplotlib.ticker import ScalarFormatter" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1d418b49", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('/global/u2/i/imendoza/.config/matplotlib',\n", + " '/global/u2/i/imendoza/.cache/matplotlib')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mpl.get_configdir(), mpl.get_cachedir()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "bbc70392-462e-4816-8421-ed2c22422f0e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot([0,1],[0,1])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "eefa433b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, '\\\\TeX\\\\ is Number $\\\\displaystyle\\\\sum_{n=1}^\\\\infty\\\\frac{-e^{i\\\\pi}}{2^n}$!')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "plt.rcParams['text.usetex'] = True\n", + "\n", + "\n", + "t = np.linspace(0.0, 1.0, 100)\n", + "s = np.cos(4 * np.pi * t) + 2\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 4), tight_layout=True)\n", + "ax.plot(t, s)\n", + "\n", + "ax.set_xlabel(r'\\textbf{time (s)}')\n", + "ax.set_ylabel('\\\\textit{Velocity (\\N{DEGREE SIGN}/sec)}', fontsize=16)\n", + "ax.set_title(r'\\TeX\\ is Number $\\displaystyle\\sum_{n=1}^\\infty'\n", + " r'\\frac{-e^{i\\pi}}{2^n}$!', fontsize=16, color='r')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e172d336", + "metadata": {}, + "outputs": [], + "source": [ + "def set_rc_params(\n", + " figsize=(10, 10),\n", + " fontsize=32,\n", + " title_size=\"large\",\n", + " label_size=\"medium\",\n", + " legend_fontsize=\"small\",\n", + " tick_label_size=\"small\",\n", + " major_tick_size=10,\n", + " minor_tick_size=5,\n", + " major_tick_width=1.0,\n", + " minor_tick_width=0.8,\n", + " lines_marker_size=10,\n", + " legend_loc=\"best\",\n", + "):\n", + " # named size options: 'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'.\n", + " plt.rcParams.update(\n", + " {\n", + " # font\n", + " \"text.usetex\": True,\n", + " \"font.family\": \"sans-serif\",\n", + " \"font.sans-serif\": \"Helvetica\",\n", + " \"text.latex.preamble\": r\"\\usepackage{amsmath}\",\n", + " \"mathtext.fontset\": \"cm\",\n", + " \"font.size\": fontsize,\n", + " # figure\n", + " \"figure.figsize\": figsize,\n", + " # axes\n", + " \"axes.labelsize\": label_size,\n", + " \"axes.titlesize\": title_size,\n", + " 'axes.unicode_minus': True,\n", + " # ticks\n", + " \"xtick.labelsize\": tick_label_size,\n", + " \"ytick.labelsize\": tick_label_size,\n", + " \"xtick.major.size\": major_tick_size,\n", + " \"ytick.major.size\": major_tick_size,\n", + " \"xtick.major.width\": major_tick_width,\n", + " \"ytick.major.width\": major_tick_width,\n", + " \"ytick.minor.size\": minor_tick_size,\n", + " \"xtick.minor.size\": minor_tick_size,\n", + " \"xtick.minor.width\": minor_tick_width,\n", + " \"ytick.minor.width\": minor_tick_width,\n", + " # markers\n", + " \"lines.markersize\": lines_marker_size,\n", + " # legend\n", + " \"legend.fontsize\": legend_fontsize,\n", + " \"legend.loc\": legend_loc,\n", + " # colors\n", + " # \"axes.prop_cycle\": mpl.cycler(color=CB_color_cycle),\n", + " # images\n", + " \"image.cmap\": \"gray\",\n", + " \"figure.autolayout\": True,\n", + " }\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2bfac215", + "metadata": {}, + "outputs": [], + "source": [ + "set_rc_params(fontsize=32)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6c4b73e7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "ax.plot([1e-3, 1e-1, 10], [1e-3, 1e-1, 10])\n", + "# ax.plot([-1,-2], [-1, -2])\n", + "# ax.yaxis.set_major_formatter(ScalarFormatter())\n", + "ax.set_yscale(\"log\")\n", + "ax.set_xscale('log')\n", + "ax.set_xticks([1e-3, 1e-1, 10])\n", + "# ax.set_xticklabels([r\"$10^{-3}$\", r\"$10^{-1}$\", r\"$10^{0}$\" ])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "29ca6af9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.5, '$10^{-1}$')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.text(0.5,0.5,'$10^{-1}$')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "04545815", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bpd_gpu", + "language": "python", + "name": "bpd_gpu" + }, + "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.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/paper/model_bias.png b/paper/model_bias.png new file mode 100644 index 00000000..6d0cb098 Binary files /dev/null and b/paper/model_bias.png differ diff --git a/paper/table_bias_boot.txt b/paper/table_bias_boot.txt index 6dba2510..2a01a4c4 100644 --- a/paper/table_bias_boot.txt +++ b/paper/table_bias_boot.txt @@ -14,3 +14,4 @@ \caption{\textbf{Multiplicative and additive bias for different settings.}} \label{tab:bias} \end{table*} + \ No newline at end of file diff --git a/paper/timing.png b/paper/timing.png index ffc74c0d..caf9ebca 100644 Binary files a/paper/timing.png and b/paper/timing.png differ diff --git a/paper/timing2.png b/paper/timing2.png index 75e6b5eb..8124dfff 100644 Binary files a/paper/timing2.png and b/paper/timing2.png differ diff --git a/pyproject.toml b/pyproject.toml index dd38dd16..592113e6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -19,6 +19,7 @@ dependencies = [ "quadax>=0.2.5", "tensorflow-probability >=0.21.0", "arviz>=0.21.0", + "jax-tqdm", ] requires-python = ">=3.10,<3.13" diff --git a/scripts/get_paper_figures.py b/scripts/get_paper_figures.py index 807577f3..2e592d9e 100755 --- a/scripts/get_paper_figures.py +++ b/scripts/get_paper_figures.py @@ -6,6 +6,8 @@ from functools import partial from pathlib import Path +import cycler +import galsim import jax import jax.numpy as jnp import matplotlib.pyplot as plt @@ -53,6 +55,63 @@ }, "exp72_interim_samples": CHAIN_DIR / "exp72_51" / "interim_samples_511_plus.npz", "eta_pc": CHAIN_DIR / "exp81_53" / "eta_shear_samples.npz", + "exp93": { + "shear": { + -0.6: { + "plus": CHAIN_DIR / "exp93_51" / "g_samples_512_plus_nu-60.npz", + "minus": CHAIN_DIR / "exp93_51" / "g_samples_512_minus_nu-60.npz", + }, + -0.4: { + "plus": CHAIN_DIR / "exp93_51" / "g_samples_512_plus_nu-40.npz", + "minus": CHAIN_DIR / "exp93_51" / "g_samples_512_minus_nu-40.npz", + }, + -0.2: { + "plus": CHAIN_DIR / "exp93_51" / "g_samples_512_plus_nu-20.npz", + "minus": CHAIN_DIR / "exp93_51" / "g_samples_512_minus_nu-20.npz", + }, + 0.1: { + "plus": CHAIN_DIR / "exp93_51" / "g_samples_512_plus_nu10.npz", + "minus": CHAIN_DIR / "exp93_51" / "g_samples_512_minus_nu10.npz", + }, + 0.3: { + "plus": CHAIN_DIR / "exp93_51" / "g_samples_512_plus_nu30.npz", + "minus": CHAIN_DIR / "exp93_51" / "g_samples_512_minus_nu30.npz", + }, + 0.5: { + "plus": CHAIN_DIR / "exp93_51" / "g_samples_512_plus_nu50.npz", + "minus": CHAIN_DIR / "exp93_51" / "g_samples_512_minus_nu50.npz", + }, + 1.0: { + "plus": CHAIN_DIR / "exp93_51" / "g_samples_512_plus_nu100.npz", + "minus": CHAIN_DIR / "exp93_51" / "g_samples_512_minus_nu100.npz", + }, + 2.0: { + "plus": CHAIN_DIR / "exp93_51" / "g_samples_512_plus_nu200.npz", + "minus": CHAIN_DIR / "exp93_51" / "g_samples_512_minus_nu200.npz", + }, + 3.0: { + "plus": CHAIN_DIR / "exp93_51" / "g_samples_512_plus_nu300.npz", + "minus": CHAIN_DIR / "exp93_51" / "g_samples_512_minus_nu300.npz", + }, + }, + "boot": { + -0.6: CHAIN_DIR / "exp93_51" / "g_samples_boots_513_nu-60.npz", + -0.4: CHAIN_DIR / "exp93_51" / "g_samples_boots_513_nu-40.npz", + -0.2: CHAIN_DIR / "exp93_51" / "g_samples_boots_513_nu-20.npz", + 0.1: CHAIN_DIR / "exp93_51" / "g_samples_boots_513_nu10.npz", + 0.3: CHAIN_DIR / "exp93_51" / "g_samples_boots_513_nu30.npz", + 0.5: CHAIN_DIR / "exp93_51" / "g_samples_boots_513_nu50.npz", + 1.0: CHAIN_DIR / "exp93_51" / "g_samples_boots_513_nu100.npz", + 2.0: CHAIN_DIR / "exp93_51" / "g_samples_boots_513_nu200.npz", + 3.0: CHAIN_DIR / "exp93_51" / "g_samples_boots_513_nu300.npz", + }, + }, + "exp91": { # gaussian + "shear": { + "plus": CHAIN_DIR / "exp91_51" / "g_samples_512_plus.npz", + "minus": CHAIN_DIR / "exp91_51" / "g_samples_512_minus.npz", + }, + }, } @@ -66,10 +125,24 @@ "subset_bias": FIG_DIR / "table_bias_subset.txt", "boot_bias": FIG_DIR / "table_bias_boot.txt", "eta_pc": FIG_DIR / "eta_pc.png", + "model_bias": FIG_DIR / "model_bias.png", +} + +_nu_hash = { + -0.6: "-60", + -0.4: "-40", + -0.2: "-20", + 0.1: "10", + 0.3: "30", + 0.5: "50", + 1.0: "100", + 2.0: "200", + 3.0: "300", } def make_distribution_figure(fpath: str | Path, overwrite: bool = False): + print("INFO: Making distribution figure") set_rc_params(fontsize=36, legend_fontsize=30) cache_fpath = HOME_DIR / "paper" / "gprop_cache.npz" @@ -206,6 +279,7 @@ def make_distribution_figure(fpath: str | Path, overwrite: bool = False): def make_timing_figure(fpath1: Path, fpath2: Path): + print("INFO: Making timing figure") set_rc_params(fontsize=24) # get avg ESS across all galaxy properties @@ -226,54 +300,8 @@ def make_timing_figure(fpath1: Path, fpath2: Path): plt.close(fig2) -def make_errorbar_figure(fpath: str | Path): - set_rc_params() # reset to default fontsize - data1 = load_dataset(INPUT_PATHS["exp70_sp"])["samples"] - data3 = load_dataset(INPUT_PATHS["exp72_sp"])["samples"] - c = ChainConsumer() - assert "g1" in data1 and "g2" in data1 and "g1" in data3 and "g2" in data3 - df1 = pandas.DataFrame.from_dict(data1) - df3 = pandas.DataFrame.from_dict(data3) - - # Customise the chain when you add it - c = ChainConsumer() - chain1 = Chain( - samples=df1, - name="Only Shear", - marker_style="*", - ) - chain3 = Chain( - samples=df3, - name="All Free", - marker_style="*", - ) - - c.add_chain(chain1) - c.add_chain(chain3) - - c.add_truth(Truth(location={"g1": 0.02, "g2": 0.0}, color="k", line_width=2.0)) - - c.set_plot_config( - PlotConfig( - usetex=True, - labels={"g1": "$g_{1}$", "g2": "$g_{2}$"}, - label_font_size=30, - tick_font_size=24, - ) - ) - - fig = c.plotter.plot_summary( - errorbar=True, - figsize=4.0, - # extra_parameter_spacing=0.8, - # vertical_spacing_ratio=1.5, - ) - # fig.tight_layout() - plt.close(fig) - fig.savefig(fpath, format="png") - - def make_contour_shear_figure(fpath: str | Path): + print("INFO: Making contour shear figure") set_rc_params() # reset to default fontsize data3 = load_dataset(INPUT_PATHS["exp72_sp"]) data4 = load_dataset(INPUT_PATHS["exp73_sp"]) @@ -337,6 +365,8 @@ def make_contour_shear_figure(fpath: str | Path): def make_contour_hyper_figure(fpath: str | Path): + print("INFO: Making contour hyperparameters figure") + set_rc_params() ds = load_dataset(INPUT_PATHS["exp73_sp"]) samples = ds["samples"] @@ -394,6 +424,8 @@ def make_contour_hyper_figure(fpath: str | Path): def get_bias_table_subset(fpath: str | Path): + print("INFO: Creating table with subset approach") + """Create a latex table of mean multiplicative and additive bias, as well as their errors from each experiment.""" # load datasets @@ -515,6 +547,7 @@ def get_bias_table_subset(fpath: str | Path): def get_bias_table_boot(fpath: str | Path): """Create a latex table of mean multiplicative and additive bias, as well as their errors from each experiment.""" + print("INFO: Creating table with bootstrap approach") # load datasets dsp1 = load_dataset(INPUT_PATHS["exp70_sp"]) @@ -626,6 +659,8 @@ def get_bias_table_boot(fpath: str | Path): def make_eta_posterior_calibration_figure(fpath: str | Path): + print("INFO: Making posterior calibration figure") + set_rc_params(fontsize=24) ds = load_dataset(INPUT_PATHS["eta_pc"]) @@ -651,6 +686,99 @@ def make_eta_posterior_calibration_figure(fpath: str | Path): fig.savefig(fpath, format="png") +def make_model_bias_figure(fpath: str | Path): + print("INFO: Making model bias figure") + set_rc_params(fontsize=28, legend_fontsize=20) + + nus = list(_nu_hash.keys()) + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(18, 9)) + + # plot with profiles + + def _draw_spergel_galsim( + nu: float, nx: int = 71, fwhm=0.8, hlr=0.4, g1=0.0, g2=0.0 + ): + gal = galsim.Spergel(nu, half_light_radius=hlr, flux=1.0) + gal = gal.shear(g1=g1, g2=g2) + psf = galsim.Gaussian(fwhm=fwhm, flux=1.0) + gal_conv = galsim.Convolve([gal, psf]) + img = gal_conv.drawImage(nx=nx, ny=nx, scale=0.2) + return img.array + + def _draw_gaussian_galsim(nx: int = 71, fwhm=0.8, hlr=0.4, g1=0.0, g2=0.0): + gal = galsim.Gaussian(half_light_radius=hlr, flux=1.0) + gal = gal.shear(g1=g1, g2=g2) + psf = galsim.Gaussian(fwhm=fwhm, flux=1.0) + gal_conv = galsim.Convolve([gal, psf]) + img = gal_conv.drawImage(nx=nx, ny=nx, scale=0.2) + return img.array + + color = plt.cm.coolwarm(np.linspace(0, 1, len(nus))) + cycles = cycler.cycler("color", color) + ax1.set_prop_cycle(cycles) + + for nu in nus: + img = _draw_spergel_galsim(nu, nx=63) + ax1.plot(img.mean(1), label=f"${nu}$") + + gauss_img = _draw_gaussian_galsim(nx=63) + ax1.plot(gauss_img.mean(1), label=r"\rm Gaussian", c="k", ls="--") + ax1.set_yscale("log") + ax1.set_ylabel(r"\rm Average counts") + ax1.set_xlabel(r"\rm Pixel $x$ coordinate") + ax1.legend() + + # multiplicative bias + error as a function of nu + all_m = [] + all_err = [] + for nu in nus: + dsp = load_dataset(INPUT_PATHS["exp93"]["shear"][nu]["plus"]) + dsm = load_dataset(INPUT_PATHS["exp93"]["shear"][nu]["minus"]) + dsb = load_dataset(INPUT_PATHS["exp93"]["boot"][nu]) + + g1p = dsp["samples"]["g1"] + g1m = dsm["samples"]["g1"] + g1ps = dsb["plus"]["g1"] + g1ms = dsb["minus"]["g1"] + + assert g1p.shape == (3000,) and g1m.shape == (3000,) + assert g1ps.shape == (100, 1000) and g1ms.shape == (100, 1000) + + m = (g1p.mean() - g1m.mean()) / 2 / 0.02 - 1 + ms = (g1ps.mean(1) - g1ms.mean(1)) / 2 / 0.02 - 1 + m_err = ms.std() + + all_m.append(m) + all_err.append(m_err) + + all_m = np.array(all_m) + all_err = np.array(all_err) + + ax2.plot(nus, all_m, "-o", color="#377eb8") + ax2.fill_between( + nus, all_m - all_err * 3, all_m + all_err * 3, color="#377eb8", alpha=0.3 + ) + + print("Model bias points:", all_m) + print("Error on model bias points:", all_err) + + # gaussian + dsp = load_dataset(INPUT_PATHS["exp91"]["shear"]["plus"]) + dsm = load_dataset(INPUT_PATHS["exp91"]["shear"]["minus"]) + g1p = dsp["samples"]["g1"] + g1m = dsm["samples"]["g1"] + m_gauss = (g1p.mean() - g1m.mean()) / 2 / 0.02 - 1 + ax2.axhline(m_gauss, c="r", ls="--", label=r"\rm Gaussian Fit") + ax2.axhline(0.0, c="k", ls="--") + # ax2.axvline(0.5, c="k", ls="--", label=r"\rm Exponential Profile") + ax2.legend() + ax2.set_ylabel(r"\rm Multiplicative bias $m$") + ax2.set_xlabel(r"\rm Spergel index $\nu$") + + fig.tight_layout() + fig.savefig(fpath, format="png") + + def main(overwrite: bool = False): make_timing_figure(OUT_PATHS["timing"], OUT_PATHS["timing2"]) make_distribution_figure(OUT_PATHS["galaxy_distributions"], overwrite=overwrite) @@ -659,6 +787,7 @@ def main(overwrite: bool = False): get_bias_table_subset(OUT_PATHS["subset_bias"]) get_bias_table_boot(OUT_PATHS["boot_bias"]) make_eta_posterior_calibration_figure(OUT_PATHS["eta_pc"]) + make_model_bias_figure(OUT_PATHS["model_bias"]) if __name__ == "__main__":