diff --git a/autometacal/python/__init__.py b/autometacal/python/__init__.py index 3df6407..1e067d1 100644 --- a/autometacal/python/__init__.py +++ b/autometacal/python/__init__.py @@ -1,5 +1,5 @@ import autometacal.python.datasets as datasets import autometacal.python.tf_ngmix as tf_ngmix -from autometacal.python.metacal import generate_mcal_image, get_metacal_response +from autometacal.python.metacal import generate_mcal_image, get_metacal_response, get_metacal_response_finitediff from autometacal.python.fitting import fit_multivariate_gaussian, get_ellipticity from autometacal.python.moments import get_moment_ellipticities, gaussian_moments diff --git a/autometacal/python/metacal.py b/autometacal/python/metacal.py index 3131de8..4bb8150 100644 --- a/autometacal/python/metacal.py +++ b/autometacal/python/metacal.py @@ -4,16 +4,17 @@ import galflow as gf import numpy as np -def generate_mcal_image(gal_image, - psf_image, +def generate_mcal_image(gal_images, + psf_images, reconvolution_psf_image, - g): + g, + padfactor=3): """ Generate a metacalibrated image given input and target PSFs. Args: - gal_image: tf.Tensor or np.array + gal_images: tf.Tensor or np.array (batch_size, N, N ) image of galaxies - psf_image: tf.Tensor or np.array + psf_images: tf.Tensor or np.array (batch_size, N, N ) image of psf model reconvolution_psf_image: tf.Tensor (N, N ) tensor of reconvolution psf model @@ -25,31 +26,47 @@ def generate_mcal_image(gal_image, shearing by g, and reconvolution with reconvolution_psf_image. """ - #convert and cast - gal_image = tf.convert_to_tensor(gal_image, dtype=tf.float32) - psf_image = tf.convert_to_tensor(psf_image, dtype=tf.float32) - reconvolution_psf_image = tf.convert_to_tensor(reconvolution_psf_image, dtype=tf.float32) + #cast stuff as float32 tensors + gal_images = tf.convert_to_tensor(gal_images, dtype=tf.float32) + psf_images = tf.convert_to_tensor(psf_images, dtype=tf.float32) + reconvolution_psf_image = tf.convert_to_tensor(reconvolution_psf_image, dtype=tf.float32) + g = tf.convert_to_tensor(g, dtype=tf.float32) + #Get batch info + batch_size, nx, ny = gal_images.get_shape().as_list() + + #add pads in real space + fact = (padfactor - 1)//2 #how many image sizes to one direction + paddings = tf.constant([[0, 0,], [nx*fact, nx*fact], [ny*fact, ny*fact]]) + + padded_gal_images = tf.pad(gal_images,paddings) + padded_psf_images = tf.pad(psf_images,paddings) + padded_reconvolution_psf_image = tf.pad(reconvolution_psf_image,paddings) + + #Convert galaxy images to k space + im_shift = tf.signal.ifftshift(padded_gal_images,axes=[1,2]) # The ifftshift is to remove the phase for centered objects + im_complex = tf.cast(im_shift, tf.complex64) + im_fft = tf.signal.fft2d(im_complex) + imk = tf.signal.fftshift(im_fft, axes=[1,2])#the fftshift is to put the 0 frequency at the center of the k image - g = tf.convert_to_tensor(g, dtype=tf.float32) - batch_size, nx, ny = gal_image.get_shape().as_list() + #Convert psf images to k space + psf_complex = tf.cast(padded_psf_images, tf.complex64) + psf_fft = tf.signal.fft2d(psf_complex) + psf_fft_abs = tf.abs(psf_fft) + psf_fft_abs_complex = tf.cast(psf_fft_abs,tf.complex64) + kpsf = tf.signal.fftshift(psf_fft_abs_complex,axes=[1,2]) - # Convert input stamps to k space - # The ifftshift is to remove the phase for centered objects - # the fftshift is to put the 0 frequency at the center of the k image - imk = tf.signal.fftshift(tf.signal.fft2d(tf.cast(tf.signal.ifftshift(gal_image,axes=[1,2]), - tf.complex64)),axes=[1,2]) - # Note the abs here, to remove the phase of the PSF - kpsf = tf.cast(tf.abs(tf.signal.fft2d(tf.cast(psf_image, tf.complex64))), - tf.complex64) - kpsf = tf.signal.fftshift(kpsf,axes=[1,2]) - krpsf = tf.cast(tf.abs(tf.signal.fft2d(tf.cast(reconvolution_psf_image,tf.complex64))), tf.complex64) - krpsf = tf.signal.fftshift(krpsf,axes=[1,2]) + #Convert reconvolution psf image to k space + rpsf_complex = tf.cast(padded_reconvolution_psf_image, tf.complex64) + rpsf_fft = tf.signal.fft2d(rpsf_complex) + rpsf_fft_abs = tf.abs(rpsf_fft) + psf_fft_abs_complex = tf.cast(rpsf_fft_abs,tf.complex64) + krpsf = tf.signal.fftshift(psf_fft_abs_complex,axes=[1,2]) # Compute Fourier mask for high frequencies # careful, this is not exactly the correct formula for fftfreq - kx, ky = tf.meshgrid(tf.linspace(-0.5,0.5,nx), - tf.linspace(-0.5,0.5,ny)) + kx, ky = tf.meshgrid(tf.linspace(-0.5,0.5,padfactor*nx), + tf.linspace(-0.5,0.5,padfactor*ny)) mask = tf.cast(tf.math.sqrt(kx**2 + ky**2) <= 0.5, dtype='complex64') mask = tf.expand_dims(mask, axis=0) @@ -65,29 +82,95 @@ def generate_mcal_image(gal_image, # Compute inverse Fourier transform img = tf.math.real(tf.signal.fftshift(im_reconv)) - return img + return img[:,fact*nx:-fact*nx,fact*ny:-fact*ny] -def get_metacal_response(gal_image, - psf_image, +def get_metacal_response(gal_images, + psf_images, reconvolution_psf_image, method): """ Convenience function to compute the shear response """ - gal_image = tf.convert_to_tensor(gal_image, dtype=tf.float32) - psf_image = tf.convert_to_tensor(psf_image, dtype=tf.float32) + gal_images = tf.convert_to_tensor(gal_images, dtype=tf.float32) + psf_images = tf.convert_to_tensor(psf_images, dtype=tf.float32) reconvolution_psf_image = tf.convert_to_tensor(reconvolution_psf_image, dtype=tf.float32) - batch_size, nx, ny = gal_image.get_shape().as_list() + batch_size, _ , _ = gal_images.get_shape().as_list() g = tf.zeros([batch_size, 2]) with tf.GradientTape() as tape: tape.watch(g) # Measure ellipticity under metacal - e = method(generate_mcal_image(gal_image, - psf_image, + e = method(generate_mcal_image(gal_images, + psf_images, reconvolution_psf_image, g)) # Compute response matrix + R = tape.batch_jacobian(e, g) return e, R + +def get_metacal_response_finitediff(gal_image,psf_image,reconv_psf_image,step,method): + """ + Gets shear response as a finite difference operation, + instead of automatic differentiation. + """ + + img0s = generate_mcal_image( + gal_image, + psf_image, + reconv_psf_image, + [[0,0]] + ) + img1p = generate_mcal_image( + gal_image, + psf_image, + reconv_psf_image, + [[step,0]] + ) + img1m = generate_mcal_image( + gal_image, + psf_image, + reconv_psf_image, + [[-step,0]] + ) + img2p = generate_mcal_image( + gal_image, + psf_image, + reconv_psf_image, + [[0,step]] + ) + img2m = generate_mcal_image( + gal_image, + psf_image, + reconv_psf_image, + [[0,-step]] + ) + + g0s = method(img0s) + g1p = method(img1p) + g1m = method(img1m) + g2p = method(img2p) + g2m = method(img2m) + + R11 = (g1p[:,0]-g1m[:,0])/(2*step) + R21 = (g1p[:,1]-g1m[:,1])/(2*step) + R12 = (g2p[:,0]-g2m[:,0])/(2*step) + R22 = (g2p[:,1]-g2m[:,1])/(2*step) + + #N. B.:The matrix is correct. + #The transposition will swap R12 with R21 across a batch correctly. + R = tf.transpose(tf.convert_to_tensor( + [[R11,R21], + [R12,R22]],dtype=tf.float32) + ) + + ellip_dict = { + 'noshear':g0s, + '1p':g1p, + '1m':g1m, + '2p':g2p, + '2m':g2m, + } + + return ellip_dict, R diff --git a/autometacal/python/moments.py b/autometacal/python/moments.py index 6ff5076..147d1a5 100644 --- a/autometacal/python/moments.py +++ b/autometacal/python/moments.py @@ -29,7 +29,7 @@ def get_moment_ellipticities(images, scale, fwhm, **kwargs): q1 = Q11 - Q22 q2 = 2*Q12 - T= Q11 + Q22 + 2*tf.math.sqrt(tf.math.abs(Q11*Q22-Q12*Q12)) # g convention + T= Q11 + Q22 # e convention g1 = q1/T g2 = q2/T diff --git a/notebooks/autometacal_vs_ngmix_test.ipynb b/notebooks/autometacal_vs_ngmix_test.ipynb new file mode 100644 index 0000000..c769d8d --- /dev/null +++ b/notebooks/autometacal_vs_ngmix_test.ipynb @@ -0,0 +1,1240 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "533c9b7e-59f2-4014-b865-a3929a9cc662", + "metadata": {}, + "source": [ + "# ngmix vs amc calibration test" + ] + }, + { + "cell_type": "markdown", + "id": "f5ff9281-904b-4116-aca0-e84fec271de5", + "metadata": {}, + "source": [ + "In this test we want to show if autometacal (amc) can calibrate a small set (N=1000) of almost noiseless simple galaxies just as good as ngmix. This is a numerical precision and sanity check test designed to validate amc procedures.\n", + "\n", + "The test consist in creating the galaxy images, and performing the metacalibration procedure to get unbiased shear results. We evaluate our results by calculating the remaining multiplicative and additive biases.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f91f6ec3-4bd9-40f5-9711-46916478dcce", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "%pylab inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "08929395-d90a-4a84-8b29-48c05f123445", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/LSC/vitorelli/.local/lib/python3.9/site-packages/tensorflow_addons/utils/ensure_tf_install.py:53: UserWarning: Tensorflow Addons supports using Python ops for all Tensorflow versions above or equal to 2.5.0 and strictly below 2.8.0 (nightly versions are not supported). \n", + " The versions of TensorFlow you are currently using is 2.8.0 and is not supported. \n", + "Some things might work, some things might not.\n", + "If you were to encounter a bug, do not file an issue.\n", + "If you want to make sure you're using a tested and supported configuration, either change the TensorFlow version or the TensorFlow Addons's version. \n", + "You can find the compatibility matrix in TensorFlow Addon's readme:\n", + "https://github.com/tensorflow/addons\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "import galflow as gf\n", + "import tensorflow as tf\n", + "import galsim\n", + "import autometacal as amc\n", + "import ngmix\n", + "import tqdm" + ] + }, + { + "cell_type": "markdown", + "id": "1f83747f-bd42-4a16-8661-a1fa5f986dde", + "metadata": {}, + "source": [ + "We set up our galaxy sets here. They are:\n", + "\n", + "1) all circular \n", + "2) subject to the same shear of $e_1 = 0.01$, $e_2 = 0$\n", + "\n", + "We also switch off the fixnoise procedure from ngmix as it is not currently implemented in amc. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "573e3cf4-11b2-448f-a054-edba77d17230", + "metadata": {}, + "outputs": [], + "source": [ + "args={'seed':31415,\n", + " 'ntrial': 1000,\n", + " 'noise': 1e-6,\n", + " 'psf': 'gauss',\n", + " 'shear_true' : [0.01, 0.00],\n", + " 'fixnoise' : False\n", + " }\n", + "\n", + "rng = np.random.RandomState(args['seed'])" + ] + }, + { + "cell_type": "markdown", + "id": "8b4184eb-2d46-45b9-b8df-1c64b8baad04", + "metadata": {}, + "source": [ + "The functions bellow are taken directly from the ngmix metacalibration example. Our intention is to replicate the example and get similar results." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e6588dba-e224-4784-b5fa-40e16f9546bd", + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def make_struct(res, obs, shear_type):\n", + " \"\"\"\n", + " make the data structure\n", + "\n", + " Parameters\n", + " ----------\n", + " res: dict\n", + " With keys 's2n', 'e', and 'T'\n", + " obs: ngmix.Observation\n", + " The observation for this shear type\n", + " shear_type: str\n", + " The shear type\n", + "\n", + " Returns\n", + " -------\n", + " 1-element array with fields\n", + " \"\"\"\n", + " dt = [\n", + " ('flags', 'i4'),\n", + " ('shear_type', 'U7'),\n", + " ('s2n', 'f8'),\n", + " ('g', 'f8', 2),\n", + " ('T', 'f8'),\n", + " ('Tpsf', 'f8'),\n", + " ]\n", + " data = np.zeros(1, dtype=dt)\n", + " data['shear_type'] = shear_type\n", + " data['flags'] = res['flags']\n", + " if res['flags'] == 0:\n", + " data['s2n'] = res['s2n']\n", + " # for moments we are actually measureing e, the elliptity\n", + " data['g'] = res['e']\n", + " data['T'] = res['T']\n", + " else:\n", + " data['s2n'] = np.nan\n", + " data['g'] = np.nan\n", + " data['T'] = np.nan\n", + " data['Tpsf'] = np.nan\n", + "\n", + " # we only have one epoch and band, so we can get the psf T from the\n", + " # observation rather than averaging over epochs/bands\n", + " data['Tpsf'] = obs.psf.meta['result']['T']\n", + "\n", + " return data\n", + " \n", + "def select(data, shear_type):\n", + " \"\"\"\n", + " select the data by shear type and size\n", + "\n", + " Parameters\n", + " ----------\n", + " data: array\n", + " The array with fields shear_type and T\n", + " shear_type: str\n", + " e.g. 'noshear', '1p', etc.\n", + "\n", + " Returns\n", + " -------\n", + " array of indices\n", + " \"\"\"\n", + "\n", + " w, = np.where(\n", + " (data['flags'] == 0) & (data['shear_type'] == shear_type)\n", + " )\n", + " return w\n", + "\n", + "def make_data(rng, noise, shear):\n", + " \"\"\"\n", + " simulate an exponential object with moffat psf\n", + "\n", + " Parameters\n", + " ----------\n", + " rng: np.random.RandomState\n", + " The random number generator\n", + " noise: float\n", + " Noise for the image\n", + " shear: (g1, g2)\n", + " The shear in each component\n", + "\n", + " Returns\n", + " -------\n", + " ngmix.Observation\n", + " \"\"\"\n", + "\n", + " psf_noise = 1.0e-6\n", + "\n", + " scale = 0.263\n", + " stamp_size = 45\n", + " psf_fwhm = 0.9\n", + " gal_hlr = 0.5\n", + " # We keep things centered for now\n", + " dy, dx = 0.,0. #rng.uniform(low=-scale/2, high=scale/2, size=2)\n", + "\n", + " psf = galsim.Moffat(\n", + " beta=2.5, fwhm=psf_fwhm,\n", + " ).shear(\n", + " g1=0.02,\n", + " g2=-0.01,\n", + " )\n", + "\n", + " obj0 = galsim.Exponential(\n", + " half_light_radius=gal_hlr,\n", + " ).shear(\n", + " g1=shear[0],\n", + " g2=shear[1],\n", + " )#.shift(\n", + " # dx=dx,\n", + " # dy=dy,\n", + " #)\n", + "\n", + " obj = galsim.Convolve(psf, obj0)\n", + "\n", + " psf_im = psf.drawImage(nx=stamp_size, ny=stamp_size, scale=scale).array\n", + " im = obj.drawImage(nx=stamp_size, ny=stamp_size, scale=scale).array\n", + "\n", + " psf_im += rng.normal(scale=psf_noise, size=psf_im.shape)\n", + " im += rng.normal(scale=noise, size=im.shape)\n", + "\n", + " cen = (np.array(im.shape)-1.0)/2.0\n", + " psf_cen = (np.array(psf_im.shape)-1.0)/2.0\n", + "\n", + " jacobian = ngmix.DiagonalJacobian(\n", + " row=cen[0] + dy/scale, col=cen[1] + dx/scale, scale=scale,\n", + " )\n", + " psf_jacobian = ngmix.DiagonalJacobian(\n", + " row=psf_cen[0], col=psf_cen[1], scale=scale,\n", + " )\n", + "\n", + " wt = im*0 + 1.0/noise**2\n", + " psf_wt = psf_im*0 + 1.0/psf_noise**2\n", + "\n", + " psf_obs = ngmix.Observation(\n", + " psf_im,\n", + " weight=psf_wt,\n", + " jacobian=psf_jacobian,\n", + " )\n", + "\n", + " obs = ngmix.Observation(\n", + " im,\n", + " weight=wt,\n", + " jacobian=jacobian,\n", + " psf=psf_obs,\n", + " )\n", + "\n", + " return obs" + ] + }, + { + "cell_type": "markdown", + "id": "cdc3e701-44c7-4a0c-a060-78dad35c7f2c", + "metadata": {}, + "source": [ + "Bellow, we set the ellipticity measurement procedures for both autometacal and ngmix" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d461bd6a-311b-467c-894e-0a6e06fa490f", + "metadata": {}, + "outputs": [], + "source": [ + "rng = np.random.RandomState(args['seed'])\n", + "\n", + "# We will measure moments with a fixed gaussian weight function\n", + "weight_fwhm = 1.2\n", + "fitter = ngmix.gaussmom.GaussMom(fwhm=weight_fwhm)\n", + "psf_fitter = ngmix.gaussmom.GaussMom(fwhm=weight_fwhm)\n", + "\n", + "# these \"runners\" run the measurement code on observations\n", + "psf_runner = ngmix.runners.PSFRunner(fitter=psf_fitter)\n", + "runner = ngmix.runners.Runner(fitter=fitter)\n", + "\n", + "# this \"bootstrapper\" runs the metacal image shearing as well as both psf\n", + "# and object measurements\n", + "#\n", + "# We will just do R11 for simplicity and to speed up this example;\n", + "# typically the off diagonal terms are negligible, and R11 and R22 are\n", + "# usually consistent\n", + "\n", + "boot = ngmix.metacal.MetacalBootstrapper(\n", + " runner=runner, psf_runner=psf_runner,\n", + " rng=rng,\n", + " psf=args['psf'],\n", + " types=['noshear', '1p', '1m'],\n", + " fixnoise=args['fixnoise'],\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "raw", + "id": "c60e7c2c-1f7a-49e6-88c1-000721937764", + "metadata": {}, + "source": [ + "# We now create the autometacal function which returns (e, R)\n", + "@tf.function\n", + "def get_autometacal_shape(im, psf, rpsf):\n", + " method = lambda x: amc.get_moment_ellipticities(x, scale=0.263, fwhm=weight_fwhm)\n", + " return amc.get_metacal_response(im, psf, rpsf, method)\n", + "\n", + "\n", + "@tf.function\n", + "def get_finitediff_shape(im, psf, rpsf):\n", + " method = lambda x: amc.get_moment_ellipticities(x, scale=0.263, fwhm=weight_fwhm)\n", + " return amc.get_metacal_response_finitediff(im, psf, rpsf,0.01, method) " + ] + }, + { + "cell_type": "raw", + "id": "4143957a-bd8e-4185-b4c9-9b5c3623cfb3", + "metadata": {}, + "source": [ + "\n", + "def get_metacal_response_finitediff(gal_image,psf_image,reconv_psf_image,step,method):\n", + " \"\"\"\n", + " Gets shear response as a finite difference operation, \n", + " instead of automatic differentiation.\n", + " \"\"\"\n", + " \n", + " img0s = generate_mcal_image(\n", + " gal_image,\n", + " psf_image,\n", + " reconv_psf_image,\n", + " [[0,0]]\n", + " ) \n", + " img1p = generate_mcal_image(\n", + " gal_image,\n", + " psf_image,\n", + " reconv_psf_image,\n", + " [[step,0]]\n", + " ) \n", + " img1m = generate_mcal_image(\n", + " gal_image,\n", + " psf_image,\n", + " reconv_psf_image,\n", + " [[-step,0]]\n", + " ) \n", + " img2p = generate_mcal_image(\n", + " gal_image,\n", + " psf_image,\n", + " reconv_psf_image,\n", + " [[0,step]]\n", + " ) \n", + " img2m = generate_mcal_image(\n", + " gal_image,\n", + " psf_image,\n", + " reconv_psf_image,\n", + " [[0,-step]]\n", + " ) \n", + " \n", + " g0s = method(img0s)\n", + " g1p = method(img1p)\n", + " g1m = method(img1m)\n", + " g2p = method(img2p)\n", + " g2m = method(img2m)\n", + " \n", + " R11 = (g1p[:,0]-g1m[:,0])/(2*step)\n", + " R21 = (g1p[:,1]-g1m[:,1])/(2*step) \n", + " R12 = (g2p[:,0]-g2m[:,0])/(2*step)\n", + " R22 = (g2p[:,1]-g2m[:,1])/(2*step)\n", + " \n", + " #N. B.:The matrix is correct. \n", + " #The transposition will swap R12 with R21 across a batch correctly.\n", + " R = tf.transpose(tf.convert_to_tensor(\n", + " [[R11,R21],\n", + " [R12,R22]],dtype=tf.float32)\n", + " )\n", + " \n", + " ellip_dict = {\n", + " 'noshear':g0s,\n", + " '1p':g1p,\n", + " '1m':g1m,\n", + " '2p':g2p,\n", + " '2m':g2m, \n", + " } \n", + "\n", + " return ellip_dict, R" + ] + }, + { + "cell_type": "raw", + "id": "8ff2370e-707d-4404-a856-61fa38215f90", + "metadata": {}, + "source": [ + "def generate_mcal_image(gal_images,\n", + " psf_images,\n", + " reconvolution_psf_image,\n", + " g):\n", + " \"\"\" Generate a metacalibrated image given input and target PSFs.\n", + " \n", + " Args: \n", + " gal_images: tf.Tensor or np.array\n", + " (batch_size, N, N ) image of galaxies\n", + " psf_images: tf.Tensor or np.array\n", + " (batch_size, N, N ) image of psf model\n", + " reconvolution_psf_image: tf.Tensor\n", + " (N, N ) tensor of reconvolution psf model\n", + " g: tf.Tensor or np.array\n", + " [batch_size, 2] input shear\n", + " Returns:\n", + " img: tf.Tensor\n", + " tf tensor containing image of galaxy after deconvolution by psf_deconv, \n", + " shearing by g, and reconvolution with reconvolution_psf_image.\n", + " \n", + " \"\"\"\n", + " #cast stuff as float32 tensors\n", + " gal_images = tf.convert_to_tensor(gal_images, dtype=tf.float32) \n", + " psf_images = tf.convert_to_tensor(psf_images, dtype=tf.float32) \n", + " reconvolution_psf_image = tf.convert_to_tensor(reconvolution_psf_image, dtype=tf.float32) \n", + " g = tf.convert_to_tensor(g, dtype=tf.float32) \n", + " \n", + " #Get batch info\n", + " batch_size, nx, ny = gal_images.get_shape().as_list() \n", + " \n", + " #add pads in real space\n", + " padfactor = 3 #total width of image after padding\n", + " fact = (padfactor - 1)//2 #how many image sizes to one direction\n", + " paddings = tf.constant([[0, 0,], [nx*fact, nx*fact], [ny*fact, ny*fact]])\n", + " \n", + " padded_gal_images = tf.pad(gal_images,paddings)\n", + " padded_psf_images = tf.pad(psf_images,paddings)\n", + " padded_reconvolution_psf_image = tf.pad(reconvolution_psf_image,paddings)\n", + " \n", + " #Convert galaxy images to k space\n", + " im_shift = tf.signal.ifftshift(padded_gal_images,axes=[1,2]) # The ifftshift is to remove the phase for centered objects\n", + " im_complex = tf.cast(im_shift, tf.complex64)\n", + " im_fft = tf.signal.fft2d(im_complex)\n", + " imk = tf.signal.fftshift(im_fft, axes=[1,2])#the fftshift is to put the 0 frequency at the center of the k image\n", + " \n", + " #Convert psf images to k space \n", + " psf_complex = tf.cast(padded_psf_images, tf.complex64)\n", + " psf_fft = tf.signal.fft2d(psf_complex)\n", + " psf_fft_abs = tf.abs(psf_fft)\n", + " psf_fft_abs_complex = tf.cast(psf_fft_abs,tf.complex64)\n", + " kpsf = tf.signal.fftshift(psf_fft_abs_complex,axes=[1,2])\n", + "\n", + " #Convert reconvolution psf image to k space \n", + " rpsf_complex = tf.cast(padded_reconvolution_psf_image, tf.complex64)\n", + " rpsf_fft = tf.signal.fft2d(rpsf_complex)\n", + " rpsf_fft_abs = tf.abs(rpsf_fft)\n", + " psf_fft_abs_complex = tf.cast(rpsf_fft_abs,tf.complex64)\n", + " krpsf = tf.signal.fftshift(psf_fft_abs_complex,axes=[1,2])\n", + "\n", + " # Compute Fourier mask for high frequencies\n", + " # careful, this is not exactly the correct formula for fftfreq\n", + " kx, ky = tf.meshgrid(tf.linspace(-0.5,0.5,padfactor*nx),\n", + " tf.linspace(-0.5,0.5,padfactor*ny))\n", + " mask = tf.cast(tf.math.sqrt(kx**2 + ky**2) <= 0.5, dtype='complex64')\n", + " mask = tf.expand_dims(mask, axis=0)\n", + "\n", + " # Deconvolve image from input PSF\n", + " im_deconv = imk * ( (1./(kpsf+1e-10))*mask)\n", + "\n", + " # Apply shear\n", + " im_sheared = gf.shear(tf.expand_dims(im_deconv,-1), g[...,0], g[...,1])[...,0]\n", + "\n", + " # Reconvolve with target PSF\n", + " im_reconv = tf.signal.ifft2d(tf.signal.ifftshift(im_sheared * krpsf * mask))\n", + "\n", + " # Compute inverse Fourier transform\n", + " img = tf.math.real(tf.signal.fftshift(im_reconv))\n", + "\n", + " return img[:,fact*nx:-fact*nx,fact*ny:-fact*ny]\n", + "\n", + "def get_metacal_response(gal_images,\n", + " psf_images,\n", + " reconvolution_psf_image,\n", + " method):\n", + " \"\"\"\n", + " Convenience function to compute the shear response\n", + " \"\"\" \n", + " gal_images = tf.convert_to_tensor(gal_images, dtype=tf.float32)\n", + " psf_images = tf.convert_to_tensor(psf_images, dtype=tf.float32)\n", + " reconvolution_psf_image = tf.convert_to_tensor(reconvolution_psf_image, dtype=tf.float32)\n", + " batch_size, _ , _ = gal_images.get_shape().as_list()\n", + " g = tf.zeros([batch_size, 2])\n", + " with tf.GradientTape() as tape:\n", + " tape.watch(g)\n", + " # Measure ellipticity under metacal\n", + " e = method(generate_mcal_image(gal_images,\n", + " psf_images,\n", + " reconvolution_psf_image,\n", + " g))\n", + " \n", + " # Compute response matrix\n", + "\n", + " R = tape.batch_jacobian(e, g)\n", + " return e, R\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "01eaa8c9-7617-4ed2-a3bf-401030b4ca76", + "metadata": {}, + "outputs": [], + "source": [ + "# We now create the autometacal function which returns (e, R)\n", + "@tf.function\n", + "def get_autometacal_shape(im, psf, rpsf):\n", + " method = lambda x: amc.get_moment_ellipticities(x, scale=0.263, fwhm=weight_fwhm)\n", + " return amc.get_metacal_response(im, psf, rpsf, method)\n", + "\n", + "\n", + "@tf.function\n", + "def get_finitediff_shape(im, psf, rpsf):\n", + " method = lambda x: amc.get_moment_ellipticities(x, scale=0.263, fwhm=weight_fwhm)\n", + " return amc.get_metacal_response_finitediff(im, psf, rpsf,0.01, method) " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ae37a6d6-32c9-40a5-a21f-d56f94f0dfc6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/1000 [00:00ResamplerGrad\n", + "WARNING:tensorflow:Using a while_loop for converting Addons>ResamplerGrad\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1000/1000 [01:00<00:00, 16.47it/s]\n" + ] + } + ], + "source": [ + "dlist = []\n", + "dlist_auto = []\n", + "dlist_R_auto = []\n", + "\n", + "dlist_finite = []\n", + "dlist_R_finite = []\n", + "\n", + "for i in tqdm.tqdm(arange(args['ntrial'])):\n", + "\n", + " obs = make_data(rng=rng, noise=args['noise'], shear=args['shear_true'])\n", + "\n", + " resdict, obsdict = boot.go(obs)\n", + "\n", + " for stype, sres in resdict.items():\n", + " st = make_struct(res=sres, obs=obsdict[stype], shear_type=stype)\n", + " dlist.append(st)\n", + "\n", + " # Same thing with autometacal\n", + " im = obs.image.reshape(1,45,45).astype('float32')\n", + " psf = obs.psf.image.reshape(1,45,45).astype('float32') \n", + " rpsf = obsdict['noshear'].psf.image.reshape(1,45,45).astype('float32') \n", + " g, R = get_autometacal_shape(im, psf, rpsf)\n", + "\n", + " g_finite, R_finite = get_finitediff_shape(im, psf, rpsf)\n", + "\n", + " dlist_auto.append(g)\n", + " dlist_R_auto.append(R)\n", + "\n", + " dlist_finite.append(g_finite['noshear'])\n", + " dlist_R_finite.append(R_finite)" + ] + }, + { + "cell_type": "markdown", + "id": "5ddf40ec-d59c-4479-a5e4-d33f15dec002", + "metadata": {}, + "source": [ + "Finally, we calculate the remaining multiplicative and additive biases in the calibrated shear measurements from the galaxy set." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f7f2446e-d38b-4cd7-a413-08295a1bb86d", + "metadata": {}, + "outputs": [], + "source": [ + "data = np.hstack(dlist)\n", + "data_auto = np.vstack(dlist_auto)\n", + "data_R_auto = np.vstack(dlist_R_auto)\n", + "\n", + "data_finite = np.vstack(dlist_finite)\n", + "data_R_finite = np.vstack(dlist_R_finite)\n", + "\n", + "w = select(data=data, shear_type='noshear')\n", + "w_1p = select(data=data, shear_type='1p')\n", + "w_1m = select(data=data, shear_type='1m')\n", + "\n", + "g = data['g'][w].mean(axis=0)\n", + "auto_g = data_auto.mean(axis=0)\n", + "finite_g = data_finite.mean(axis=0)\n", + "\n", + "gerr = data['g'][w].std(axis=0) / np.sqrt(w.size)\n", + "auto_gerr = data_auto.std(axis=0) / np.sqrt(w.size)\n", + "finite_gerr = data_finite.std(axis=0) / np.sqrt(w.size)\n", + "\n", + "#ngmix\n", + "g1_1p = data['g'][w_1p, 0].mean()\n", + "g1_1m = data['g'][w_1m, 0].mean()\n", + "R11 = (g1_1p - g1_1m)/0.02\n", + "\n", + "#autometacal finite differences\n", + "finite_R = data_R_finite.mean(axis=0)\n", + "\n", + "#autometacal \n", + "auto_R = data_R_auto.mean(axis=0)\n", + "#ngmix\n", + "shear = g / R11\n", + "shear_err = gerr / R11\n", + "m = shear[0] / args['shear_true'][0]-1\n", + "merr = shear_err[0] / args['shear_true'][0]\n", + "\n", + "#autometacal finite differences\n", + "finite_shear = finite_g / finite_R[0,0]\n", + "finite_shear_err = finite_gerr / finite_R[0,0]\n", + "finite_m = finite_shear[0] / args['shear_true'][0] - 1\n", + "finite_merr = finite_shear_err[0] / args['shear_true'][0]\n", + "\n", + "#autometacal\n", + "auto_shear = auto_g / auto_R[0,0]\n", + "auto_shear_err = auto_gerr / auto_R[0,0]\n", + "auto_m = auto_shear[0] / args['shear_true'][0]-1\n", + "auto_merr = auto_shear_err[0] / args['shear_true'][0]\n", + "\n", + "s2n = data['s2n'][w].mean()" + ] + }, + { + "cell_type": "markdown", + "id": "57e33d8a-5445-4a39-9575-bca0141c5b3f", + "metadata": {}, + "source": [ + "The results are sumarised bellow:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0aa4c9b1-cd29-4bc5-b434-f979fe3a9739", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "S/N: 113364\n", + "-------------------\n", + "ngmix results:\n", + "R11: 0.351126\n", + "m: 0.000140164 +/- 0.000317124 (99.7% conf)\n", + "c: 7.39344e-07 +/- 3.03715e-06 (99.7% conf)\n", + "-------------------\n", + "finitediff results:\n", + "R11: 0.351113\n", + "m: 0.000215206 +/- 0.000329572 (99.7% conf)\n", + "c: 4.41873e-07 +/- 3.11042e-06 (99.7% conf)\n", + "autometacal results:\n", + "R11: 0.351128\n", + "m: 0.000172179 +/- 0.000329558 (99.7% conf)\n", + "c: 4.41854e-07 +/- 3.11028e-06 (99.7% conf)\n" + ] + } + ], + "source": [ + "print('S/N: %g' % s2n)\n", + "print('-------------------')\n", + "print('ngmix results:')\n", + "print('R11: %g' % R11)\n", + "print('m: %g +/- %g (99.7%% conf)' % (m, merr*3))\n", + "print('c: %g +/- %g (99.7%% conf)' % (shear[1], shear_err[1]*3))\n", + "print('-------------------')\n", + "print('finitediff results:')\n", + "print('R11: %g' % finite_R[0,0])\n", + "print('m: %g +/- %g (99.7%% conf)' % (finite_m, finite_merr*3))\n", + "print('c: %g +/- %g (99.7%% conf)' % (finite_shear[1], finite_shear_err[1]*3))\n", + "print('autometacal results:')\n", + "print('R11: %g' % auto_R[0,0])\n", + "print('m: %g +/- %g (99.7%% conf)' % (auto_m, auto_merr*3))\n", + "print('c: %g +/- %g (99.7%% conf)' % (auto_shear[1], auto_shear_err[1]*3))" + ] + }, + { + "cell_type": "raw", + "id": "ff9a6ee0-ec63-4b66-a6fe-3818de5afcad", + "metadata": {}, + "source": [ + "double pad, quintic\n", + "\n", + "S/N: 113364\n", + "-------------------\n", + "ngmix results:\n", + "R11: 0.351126\n", + "m: 0.000140164 +/- 0.000317124 (99.7% conf)\n", + "c: 7.39344e-07 +/- 3.03715e-06 (99.7% conf)\n", + "-------------------\n", + "finitediff results:\n", + "R11: 0.351113\n", + "m: 0.000215206 +/- 0.000329572 (99.7% conf)\n", + "c: 4.41873e-07 +/- 3.11042e-06 (99.7% conf)\n", + "autometacal results:\n", + "R11: 0.351128\n", + "m: 0.000172179 +/- 0.000329558 (99.7% conf)\n", + "c: 4.41854e-07 +/- 3.11028e-06 (99.7% conf)" + ] + }, + { + "cell_type": "raw", + "id": "d1cb467e-888c-407a-a960-e9a9e20977fa", + "metadata": {}, + "source": [ + "Results:\n", + "\n", + "\"pseudo noise padded, bernstein quintic\"\n", + "\n", + "S/N: 113530\n", + "\n", + "-------------------\n", + "\n", + "ngmix results:\n", + "R11: 0.350877\n", + "m: 0.000284432 +/- 0.000334726 (99.7% conf)\n", + "c: 6.48511e-07 +/- 2.92975e-06 (99.7% conf)\n", + "\n", + "-------------------\n", + "\n", + "finitediff results:\n", + "R11: 0.350922\n", + "m: 0.000143215 +/- 0.000346168 (99.7% conf)\n", + "c: 1.152e-06 +/- 3.08337e-06 (99.7% conf)\n", + "\n", + "autometacal results:\n", + "R11: 0.350879\n", + "m: 0.000267081 +/- 0.000346229 (99.7% conf)\n", + "c: 1.15285e-06 +/- 3.0837e-06 (99.7% conf)\n", + "\n", + "\n", + "\"not pseudo noise padded, bernstein quintic\"\n", + "\n", + "S/N: 113364\n", + "-------------------\n", + "ngmix results:\n", + "R11: 0.351126\n", + "m: 0.000140164 +/- 0.000317124 (99.7% conf)\n", + "c: 7.39344e-07 +/- 3.03715e-06 (99.7% conf)\n", + "-------------------\n", + "finitediff results:\n", + "R11: 0.351125\n", + "m: 0.000177767 +/- 0.000329538 (99.7% conf)\n", + "c: 4.39825e-07 +/- 3.11051e-06 (99.7% conf)\n", + "autometacal results:\n", + "R11: 0.351391\n", + "m: -0.000578467 +/- 0.000329303 (99.7% conf)\n", + "c: 4.39655e-07 +/- 3.10813e-06 (99.7% conf)\n", + "\n", + "\n", + "quad zero pad, quintic\n", + "\n", + "S/N: 113364\n", + "-------------------\n", + "ngmix results:\n", + "R11: 0.351126\n", + "m: 0.000140164 +/- 0.000317124 (99.7% conf)\n", + "c: 7.39344e-07 +/- 3.03715e-06 (99.7% conf)\n", + "-------------------\n", + "finitediff results:\n", + "R11: 0.351161\n", + "m: 7.93263e-05 +/- 0.00032946 (99.7% conf)\n", + "c: 4.40708e-07 +/- 3.11002e-06 (99.7% conf)\n", + "autometacal results:\n", + "R11: 0.351125\n", + "m: 0.000181772 +/- 0.000329494 (99.7% conf)\n", + "c: 4.40753e-07 +/- 3.11034e-06 (99.7% conf)\n", + "\n", + "\n", + "double pad, quintic\n", + "\n", + "S/N: 113364\n", + "-------------------\n", + "ngmix results:\n", + "R11: 0.351126\n", + "m: 0.000140164 +/- 0.000317124 (99.7% conf)\n", + "c: 7.39344e-07 +/- 3.03715e-06 (99.7% conf)\n", + "-------------------\n", + "finitediff results:\n", + "R11: 0.351113\n", + "m: 0.000215206 +/- 0.000329572 (99.7% conf)\n", + "c: 4.41873e-07 +/- 3.11042e-06 (99.7% conf)\n", + "autometacal results:\n", + "R11: 0.351128\n", + "m: 0.000172179 +/- 0.000329558 (99.7% conf)\n", + "c: 4.41854e-07 +/- 3.11028e-06 (99.7% conf)" + ] + }, + { + "cell_type": "markdown", + "id": "58a53df3-40b1-45b3-a62a-3bae4e992671", + "metadata": {}, + "source": [ + "# Unit Test Design Area" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "04d61a23-b460-4f6e-8efd-8bbfeb0e41e1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:Using a while_loop for converting Addons>ResamplerGrad\n", + "WARNING:tensorflow:Using a while_loop for converting Addons>ResamplerGrad\n" + ] + } + ], + "source": [ + "# This module tests finite-differences metacalibration\n", + "# against ngmix\n", + "# WARNING! This should be run after altering ngmix to use\n", + "# the same interpolation as autometacal!\n", + "\n", + "import numpy as np\n", + "import ngmix\n", + "import galsim\n", + "import autometacal as amc\n", + "import tensorflow as tf\n", + "\n", + "from numpy.testing import assert_allclose\n", + "\n", + "args={'seed':31415,\n", + " 'ntrial': 1000,\n", + " 'noise': 1e-6,\n", + " 'psf': 'gauss',\n", + " 'shear_true' : [0.01, 0.00],\n", + " 'fixnoise' : False\n", + " }\n", + "\n", + "rng = np.random.RandomState(args['seed'])\n", + "\n", + "\n", + "### functions\n", + "def make_struct(res, obs, shear_type):\n", + " \"\"\"\n", + " make the data structure\n", + "\n", + " Parameters\n", + " ----------\n", + " res: dict\n", + " With keys 's2n', 'e', and 'T'\n", + " obs: ngmix.Observation\n", + " The observation for this shear type\n", + " shear_type: str\n", + " The shear type\n", + "\n", + " Returns\n", + " -------\n", + " 1-element array with fields\n", + " \"\"\"\n", + "\n", + " dt = [\n", + " ('flags', 'i4'),\n", + " ('shear_type', 'U7'),\n", + " ('s2n', 'f8'),\n", + " ('g', 'f8', 2),\n", + " ('T', 'f8'),\n", + " ('Tpsf', 'f8'),\n", + " ]\n", + " data = np.zeros(1, dtype=dt)\n", + " data['shear_type'] = shear_type\n", + " data['flags'] = res['flags']\n", + "\n", + " if res['flags'] == 0:\n", + " data['s2n'] = res['s2n']\n", + " # for moments we are actually measureing e, the elliptity\n", + " data['g'] = res['e']\n", + " data['T'] = res['T']\n", + " else:\n", + " data['s2n'] = np.nan\n", + " data['g'] = np.nan\n", + " data['T'] = np.nan\n", + " data['Tpsf'] = np.nan\n", + "\n", + " # we only have one epoch and band, so we can get the psf T from \n", + " # the observation rather than averaging over epochs/bands\n", + " data['Tpsf'] = obs.psf.meta['result']['T']\n", + "\n", + " return data\n", + "\n", + "def select(data, shear_type):\n", + " \"\"\"\n", + " select the data by shear type and size\n", + "\n", + " Parameters\n", + " ----------\n", + " data: array\n", + " The array with fields shear_type and T\n", + " shear_type: str\n", + " e.g. 'noshear', '1p', etc.\n", + "\n", + " Returns\n", + " -------\n", + " array of indices\n", + " \"\"\"\n", + "\n", + " w, = np.where(\n", + " (data['flags'] == 0) & \n", + " (data['shear_type'] == shear_type)\n", + " )\n", + " \n", + " return w\n", + " \n", + "\n", + "\n", + " \n", + "def make_data(rng, noise, shear):\n", + " \"\"\"\n", + " simulate an exponential object with moffat psf\n", + "\n", + " Parameters\n", + " ----------\n", + " rng: np.random.RandomState\n", + " The random number generator\n", + " noise: float\n", + " Noise for the image\n", + " shear: (g1, g2)\n", + " The shear in each component\n", + "\n", + " Returns\n", + " -------\n", + " ngmix.Observation\n", + " \"\"\"\n", + "\n", + " psf_noise = 1.0e-6\n", + "\n", + " scale = 0.263\n", + " stamp_size = 45\n", + " psf_fwhm = 0.9\n", + " gal_hlr = 0.5\n", + " # We keep things centered for now\n", + " dy, dx = 0.,0. #rng.uniform(low=-scale/2, high=scale/2, size=2)\n", + "\n", + " psf = galsim.Moffat(beta=2.5, fwhm=psf_fwhm).shear(\n", + " g1=0.02,\n", + " g2=-0.01,\n", + " )\n", + "\n", + " obj0 = galsim.Exponential(half_light_radius=gal_hlr).shear(\n", + " g1=shear[0],\n", + " g2=shear[1],\n", + " )\n", + "\n", + " obj = galsim.Convolve(psf, obj0)\n", + "\n", + " psf_im = psf.drawImage(nx=stamp_size, ny=stamp_size, scale=scale).array\n", + " im = obj.drawImage(nx=stamp_size, ny=stamp_size, scale=scale).array\n", + "\n", + " psf_im += rng.normal(scale=psf_noise, size=psf_im.shape)\n", + " im += rng.normal(scale=noise, size=im.shape)\n", + "\n", + " cen = (np.array(im.shape)-1.0)/2.0\n", + " psf_cen = (np.array(psf_im.shape)-1.0)/2.0\n", + "\n", + " jacobian = ngmix.DiagonalJacobian(\n", + " row=cen[0] + dy/scale, \n", + " col=cen[1] + dx/scale, \n", + " scale=scale,\n", + " )\n", + " psf_jacobian = ngmix.DiagonalJacobian(\n", + " row=psf_cen[0], \n", + " col=psf_cen[1], \n", + " scale=scale,\n", + " )\n", + "\n", + " wt = im*0 + 1.0/noise**2\n", + " psf_wt = psf_im*0 + 1.0/psf_noise**2\n", + "\n", + " psf_obs = ngmix.Observation(\n", + " psf_im,\n", + " weight=psf_wt,\n", + " jacobian=psf_jacobian,\n", + " )\n", + "\n", + " obs = ngmix.Observation(\n", + " im,\n", + " weight=wt,\n", + " jacobian=jacobian,\n", + " psf=psf_obs,\n", + " )\n", + "\n", + " return obs\n", + "\n", + "def test_metacal_ngmix():\n", + " \"\"\"\n", + " This test generates a simple galaxy and measures the response matrix and\n", + " the residual biases after correction with ngmix, vs. autometacal.\n", + " We aim for m, c to be compatible with zero at the same level of ngmix. \n", + " \"\"\"\n", + " shear_true = [0.01, 0.00]\n", + " rng = np.random.RandomState(args['seed'])\n", + "\n", + " # We will measure moments with a fixed gaussian weight function\n", + " weight_fwhm = 1.2\n", + " fitter = ngmix.gaussmom.GaussMom(fwhm=weight_fwhm)\n", + " psf_fitter = ngmix.gaussmom.GaussMom(fwhm=weight_fwhm)\n", + "\n", + " # these \"runners\" run the measurement code on observations\n", + " psf_runner = ngmix.runners.PSFRunner(fitter=psf_fitter)\n", + " runner = ngmix.runners.Runner(fitter=fitter)\n", + "\n", + " # this \"bootstrapper\" runs the metacal image shearing as well as both \n", + " # psf and object measurements\n", + " #\n", + " # We will just do R11 for simplicity and to speed up this example;\n", + " # typically the off diagonal terms are negligible, and R11 and R22 are\n", + " # usually consistent\n", + "\n", + " boot = ngmix.metacal.MetacalBootstrapper(\n", + " runner=runner, psf_runner=psf_runner,\n", + " rng=rng,\n", + " psf=args['psf'],\n", + " types=['noshear', '1p', '1m'],\n", + " fixnoise=args['fixnoise'],\n", + " )\n", + "\n", + " # We now create the autometacal function which returns (e, R)\n", + " @tf.function\n", + " def get_autometacal_shape(im, psf, rpsf):\n", + " method = lambda x: amc.get_moment_ellipticities(\n", + " x, \n", + " scale=0.263, \n", + " fwhm=weight_fwhm\n", + " )\n", + " return amc.get_metacal_response(im, psf, rpsf, method)\n", + "\n", + "\n", + "\n", + " def get_finitediff_shape(im, psf, rpsf):\n", + " method = lambda x: amc.get_moment_ellipticities(\n", + " x, \n", + " scale=0.263, \n", + " fwhm=weight_fwhm)\n", + " return amc.get_metacal_response_finitediff(im, psf, rpsf,0.01, method)\n", + " \n", + " dlist = []\n", + " dlist_auto = []\n", + " dlist_R_auto = []\n", + "\n", + " dlist_finite = []\n", + " dlist_R_finite = []\n", + "\n", + " for i in np.arange(args['ntrial']):\n", + "\n", + " obs = make_data(rng=rng, noise=args['noise'], shear=shear_true)\n", + "\n", + " resdict, obsdict = boot.go(obs)\n", + "\n", + " for stype, sres in resdict.items():\n", + " st = make_struct(res=sres, obs=obsdict[stype], shear_type=stype)\n", + " dlist.append(st)\n", + "\n", + " # Same thing with autometacal\n", + " im = obs.image.reshape(1,45,45).astype('float32')\n", + " psf = obs.psf.image.reshape(1,45,45).astype('float32') \n", + " rpsf = obsdict['noshear'].psf.image.reshape(1,45,45).astype(\n", + " 'float32'\n", + " ) \n", + " g, R = get_autometacal_shape(im, psf, rpsf)\n", + "\n", + " g_finite, R_finite = get_finitediff_shape(im, psf, rpsf)\n", + "\n", + " dlist_auto.append(g)\n", + " dlist_R_auto.append(R)\n", + "\n", + " dlist_finite.append(g_finite['noshear'])\n", + " dlist_R_finite.append(R_finite)\n", + " \n", + " data = np.hstack(dlist)\n", + " data_auto = np.vstack(dlist_auto)\n", + " data_R_auto = np.vstack(dlist_R_auto)\n", + "\n", + " data_finite = np.vstack(dlist_finite)\n", + " data_R_finite = np.vstack(dlist_R_finite)\n", + "\n", + " w = select(data=data, shear_type='noshear')\n", + " w_1p = select(data=data, shear_type='1p')\n", + " w_1m = select(data=data, shear_type='1m')\n", + "\n", + " g = data['g'][w].mean(axis=0)\n", + " auto_g = data_auto.mean(axis=0)\n", + " finite_g = data_finite.mean(axis=0)\n", + "\n", + " gerr = data['g'][w].std(axis=0) / np.sqrt(w.size)\n", + " auto_gerr = data_auto.std(axis=0) / np.sqrt(w.size)\n", + " finite_gerr = data_finite.std(axis=0) / np.sqrt(w.size)\n", + "\n", + " #ngmix\n", + " g1_1p = data['g'][w_1p, 0].mean()\n", + " g1_1m = data['g'][w_1m, 0].mean()\n", + " R11 = (g1_1p - g1_1m)/0.02\n", + "\n", + " #autometacal finite differences\n", + " finite_R = data_R_finite.mean(axis=0)\n", + "\n", + " #autometacal \n", + " auto_R = data_R_auto.mean(axis=0)\n", + " #ngmix\n", + " shear = g / R11\n", + " shear_err = gerr / R11\n", + " m = shear[0] / shear_true[0]-1\n", + " merr = shear_err[0] / shear_true[0]\n", + "\n", + " #autometacal finite differences\n", + " finite_shear = finite_g / finite_R[0,0]\n", + " finite_shear_err = finite_gerr / finite_R[0,0]\n", + " finite_m = finite_shear[0] / shear_true[0] - 1\n", + " finite_merr = finite_shear_err[0] / shear_true[0]\n", + "\n", + " #autometacal\n", + " auto_shear = auto_g / auto_R[0,0]\n", + " auto_shear_err = auto_gerr / auto_R[0,0]\n", + " auto_m = auto_shear[0] / shear_true[0]-1\n", + " auto_merr = auto_shear_err[0] / shear_true[0]\n", + " \n", + " \n", + " #test R\n", + " assert_allclose(finite_R[0,0],R11,rtol=1,atol=1e-5)\n", + " assert_allclose(auto_R[0,0],R11,rtol=1,atol=1e-5)\n", + "\n", + " \n", + " #test m\n", + " assert_allclose(finite_m,m,rtol=1,atol=1e-5)\n", + " assert_allclose(auto_m,m,rtol=1,atol=1e-5)\n", + " \n", + "\n", + " s2n = data['s2n'][w].mean()\n", + " \n", + " print('S/N: %g' % s2n)\n", + " print('-------------------')\n", + " print('ngmix results:')\n", + " print('R11: %g' % R11)\n", + " print('m: %.5e +/- %.5e (99.7%% conf)' % (m, merr*3))\n", + " print('c: %.5e +/- %.5e (99.7%% conf)' % (shear[1], shear_err[1]*3))\n", + " print('-------------------')\n", + " print('finitediff results:')\n", + " print('R11: %g' % finite_R[0,0])\n", + " print('m: %.5e +/- %.5e (99.7%% conf)' % (\n", + " finite_m, \n", + " finite_merr*3\n", + " )\n", + " )\n", + " print('c: %.5e +/- %.5e (99.7%% conf)' % (\n", + " finite_shear[1],\n", + " finite_shear_err[1]*3\n", + " )\n", + " )\n", + " print('autometacal results:')\n", + " print('R11: %g' % auto_R[0,0])\n", + " print('m: %.5e +/- %.5e (99.7%% conf)' % (auto_m, auto_merr*3))\n", + " print('c: %.5e +/- %.5e (99.7%% conf)' % (auto_shear[1], auto_shear_err[1]*3))\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "test_metacal_ngmix()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a2af37d6-757a-4124-aac2-ffc773448bf3", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/test_metacal.ipynb b/notebooks/test_metacal.ipynb index 3e4ebd2..5bfef4d 100644 --- a/notebooks/test_metacal.ipynb +++ b/notebooks/test_metacal.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "id": "39f22406", "metadata": {}, "outputs": [ @@ -23,17 +23,36 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "30afc9c8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/local/home/az264973/.local/lib/python3.8/site-packages/tensorflow_addons/utils/resource_loader.py:78: UserWarning: You are currently using TensorFlow 2.6.0 and trying to load a custom op (custom_ops/image/_resampler_ops.so).\n", + "TensorFlow Addons has compiled its custom ops against TensorFlow 2.7.0, and there are no compatibility guarantees between the two versions. \n", + "This means that you might get segfaults when loading the custom op, or other kind of low-level errors.\n", + " If you do, do not file an issue on Github. This is a known limitation.\n", + "\n", + "It might help you to fallback to pure Python ops by setting environment variable `TF_ADDONS_PY_OPS=1` or using `tfa.options.disable_custom_kernel()` in your code. To do that, see https://github.com/tensorflow/addons#gpucpu-custom-ops \n", + "\n", + "You can also change the TensorFlow version installed on your system. You would need a TensorFlow version equal to or above 2.7.0 and strictly below 2.8.0.\n", + " Note that nightly versions of TensorFlow, as well as non-pip TensorFlow like `conda install tensorflow` or compiled from source are not supported.\n", + "\n", + "The last solution is to find the TensorFlow Addons version that has custom ops compatible with the TensorFlow installed on your system. To do that, refer to the readme: https://github.com/tensorflow/addons\n", + " warnings.warn(\n" + ] + } + ], "source": [ "obsdict, mcal = test_get_metacal(return_results=True)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "e4e81213", "metadata": {}, "outputs": [ @@ -43,18 +62,20 @@ "Text(0.5, 0.98, 'noshear')" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABLgAAAHPCAYAAABQumOIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAA9hAAAPYQGoP6dpAACUfElEQVR4nOzde3xU1b3///dMJpkESCIXIUQBg4IXLkqJIlgEqyBorRe0VC2VVj2lYBU5HivS1mgpKFKLfhVQi6g/L9AexFrrBaiCtkILCEoVOVpREImUa7glk5nZvz/SjI5Za8hk9iRzeT0fj3m0rNmz9tqXyce9Zq318TiO4wgAAAAAAABIU96WbgAAAAAAAACQCDq4AAAAAAAAkNbo4AIAAAAAAEBao4MLAAAAAAAAaY0OLgAAAAAAAKQ1OrgAAAAAAACQ1ujgAgAAAAAAQFqjgwsAAAAAAABpjQ4uAAAAAAAApDU6uAAAABL0ySefyOPxaObMmS3dFAAAgKxEBxcAAAAAAADSGh1cAAAAGSYUCqmmpqalmwEAANBs6OACAAAZp6KiQh6PR++9956uvPJKFRcXq1OnTvrRj36kffv2Rbarrq7W5MmTVVZWpry8PB1zzDGaMGGC9u7dG1Xfa6+9pqFDh6p9+/YqKChQ165dNWrUKB06dKjBvu+77z6VlZWpTZs2GjhwoFatWtVgmzVr1ug73/mO2rVrp/z8fPXr10+///3vo7b597//rfHjx+uUU05RmzZt1LFjR33rW9/Sm2++GbVd/fTIGTNmaOrUqSorK5Pf79frr7+ewBkEAABIL76WbgAAAECyjBo1SqNHj9a1116rDRs2aPLkyZKkxx57TI7j6JJLLtFf/vIXTZ48WYMHD9a7776rO+64QytXrtTKlSvl9/v1ySef6MILL9TgwYP12GOP6aijjtK2bdv0yiuvKBAIqFWrVpH9PfTQQzrppJM0a9YsSdIvfvELXXDBBdq8ebOKi4slSa+//rpGjBihAQMGaO7cuSouLtaCBQs0evRoHTp0SGPHjpUk7d69W5J0xx13qKSkRAcOHNDixYs1dOhQ/eUvf9HQoUOjjvWBBx5Qz549NXPmTBUVFalHjx7JPbkAAAApxOM4jtPSjQAAAHBTRUWF7rzzTs2YMUP/8z//EymfMGGCHnvsMR06dEhLlizRiBEjGmzz+9//XqNHj9Yjjzyi66+/XosWLdLll1+u9evX69RTTzXu75NPPlFZWZn69OmjdevWKScnR5K0evVqnXHGGXr22Wf1ve99T5J08sknq6CgQP/4xz/k8335W+NFF12ktWvX6rPPPpPX23CQfSgUkuM4GjFihIqKivTcc89F7fv444/Xxo0blZubm/gJBAAASDNMUQQAABnrO9/5TtS/+/btq+rqau3YsUOvvfaaJEVGTNW74oor1Lp1a/3lL3+RJJ122mnKy8vTf/3Xf+mJJ57Qxx9/bN3fhRdeGOncqt+fJH366aeSpI8++kgffPCBrr76aklSMBiMvC644AJt375dmzZtinx+7ty5+sY3vqH8/Hz5fD7l5ubqL3/5izZu3Gg8Vjq3AABAtqKDCwAAZKz27dtH/dvv90uSDh8+rF27dsnn8+noo4+O2sbj8aikpES7du2SJB1//PFatmyZOnbsqAkTJuj444/X8ccfr/vvvz+u/UnSF198IUm65ZZblJubG/UaP368JGnnzp2S6tby+slPfqIBAwZo0aJFWrVqlVavXq0RI0ZE6vuqzp07x3dyAAAAMghrcAEAgKzUvn17BYNB/fvf/47q5HIcR5WVlTr99NMjZYMHD9bgwYMVCoW0Zs0a/b//9/80ceJEderUKTL1sDE6dOggSZo8ebIuu+wy4zYnnniiJOmpp57S0KFDNWfOnKj39+/fb/ycx+NpdDsAAAAyDSO4AABAVjr33HMl1XUkfdWiRYt08ODByPtflZOTowEDBuihhx6SJL399ttx7fPEE09Ujx499M4776i8vNz4KiwslFTXYVU/Aqzeu+++q5UrV8a1TwAAgGzACC4AAJCVhg0bpvPPP18/+9nPVFVVpbPOOiuSRbFfv34aM2aMpLp1sF577TVdeOGF6tq1q6qrq/XYY49Jks4777y49/vwww9r5MiROv/88zV27Fgdc8wx2r17tzZu3Ki3335bf/jDHyRJ3/72t/WrX/1Kd9xxh4YMGaJNmzbprrvuUllZmYLBoHsnAgAAIAPQwQUAALKSx+PR888/r4qKCs2fP1+//vWv1aFDB40ZM0bTpk2LjJ467bTTtGTJEt1xxx2qrKxUmzZt1Lt3b73wwgsaPnx43Ps955xz9I9//EO//vWvNXHiRO3Zs0ft27fXKaecou9+97uR7aZMmaJDhw5p3rx5mjFjhk455RTNnTtXixcv1vLly906DQAAABnB4ziO09KNAAAAAAAAAJqKNbgAAAAAAACQ1ujgAgAAAAAAQFqjgwsAAAAAAABpjQ4uAAAAAAAApDU6uAAAAAAAAJDW6OACAAAAAABAWqODCwAAAAAAAGmNDi4AAAAAAACkNTq4AAAAAAAAkNbo4AIAAAAAAEBao4MLAAAAAAAAaY0OLgAAAAAAAKQ1OrgAAAAAAACQ1ujgAgAAAAAAQFqjgwsAAAAAAABpjQ4uAAAAAAAApDU6uAAAAAAAAJDW6OACAAAAAABAWqODCwAAAAAAAGmNDi4AAAAAAACkNTq4AAAAAAAAkNbo4AIAAAAAAEBao4MLAAAAAAAAaY0OLgAAAAAAgBTzxhtv6KKLLlJpaak8Ho+ef/75pO9z27Zt+v73v6/27durVatWOu2007R27dqk79cNdHABAAAAAACkmIMHD+rUU0/Vgw8+2Cz727Nnj8466yzl5ubq5Zdf1vvvv6/f/OY3Ouqoo5pl/4nyOI7jtHQjAAAAAAAAYObxeLR48WJdcsklkbJAIKCf//znevrpp7V371717t1b99xzj4YOHdqkfdx2223629/+pjfffNOdRjczRnABAAAAAACkmR/+8If629/+pgULFujdd9/VFVdcoREjRujDDz9sUn0vvPCCysvLdcUVV6hjx47q16+fHn30UZdbnTyM4AIAAAAAAEhhXx/B9a9//Us9evTQZ599ptLS0sh25513ns444wxNmzYt7n3k5+dLkiZNmqQrrrhC//jHPzRx4kQ9/PDD+sEPfuDKcSSTr6UbAAAAAAAAgMZ7++235TiOevbsGVVeU1Oj9u3bS5I++eQTlZWVxaxnwoQJkTW+wuGwysvLI51j/fr103vvvac5c+bQwQUAAAAAAAB3hcNh5eTkaO3atcrJyYl6r02bNpKkY445Rhs3boxZT9u2bSP/v3PnzjrllFOi3j/55JO1aNEil1qdXHRwAQAAAAAApJF+/fopFAppx44dGjx4sHGb3NxcnXTSSY2u86yzztKmTZuiyv7v//5P3bp1S6itzYUOLgAAAAAAgBRz4MABffTRR5F/b968WevXr1e7du3Us2dPXX311frBD36g3/zmN+rXr5927typ1157TX369NEFF1wQ9/5uvvlmDRo0SNOmTdN3v/td/eMf/9AjjzyiRx55xM3DShoWmQcAAAAAAEgxy5cv1znnnNOg/JprrtHjjz+u2tpaTZ06VU8++aS2bdum9u3ba+DAgbrzzjvVp0+fJu3zxRdf1OTJk/Xhhx+qrKxMkyZN0vXXX5/ooTQLOrgAAAAAAACQ1rwt3QAAAAAAAAAgEXRwAQAAAAAAIK2xyDwAWFRXVysQCLhSV15envLz812pCwCQGdyMMxKxBgDQUDY909DBBQAG1dXVKisrU2VlpSv1lZSUaPPmzSkdEAAAzcftOCMRawAA0aqrq1XWrY0qd4RcqS/V4wwdXABgEAgEVFlZqS1bNquoqCihuqqqqtS1a5kCgUDKBgMAQPNyM85IxBoAQEOBQECVO0LavLabigoTW6Gqan9YZf0/Tek4QwcXAMRQVFTkyoMHAAAmxBkAQLIVFXoT7uBKB3RwAUAMjhOU4wQTrgMAABM34kx9PQAAmIScsEJO4nWkOjq4ACAGxwnJcRKbs57o5wEAmcuNOFNfDwAAJmE5CiuxHq5EP98cMn+MGgAAAAAAADIaI7gAIAamKAIAkokpigCAZAsrrEQnGCZeQ/LRwQUAMdRNHUm0g4tpIwAAMzfiTH09AACYhBxHISexKYaJfr45MEURAAAAAAAAaY0RXAAQA1MUAQDJxBRFAECyZcsi83RwAUAMZFEEACQTWRQBAMkWlqNQFnRwMUURAAAAAAAAaY0RXAAQA1MUAQDJxBRFAECyMUURAEAHFwAgqejgAgAkG1kUAQAAAAAAgDTACC4AiKFu8d9ER3Cx8C8AwMyNOFNfDwAAJuH/vBKtI9XRwQUAMTBFEQCQTExRBAAkW8iFLIqJfr45MEURAAAAAAAAaY0RXAAQQ93UkcSmfTBtBABg40acqa8HAACTkFP3SrSOVEcHFwDEwBRFAEAyMUURAJBs2bIGF1MUAQAAAAAAkNYYwQUAMTCCCwCQTIzgAgAkW1geheRJuI5URwcXAMTgRvp21kUBANi4EWfq6wEAwCTs1L0SrSPVMUURAAAAAAAAaY0RXAAQA1kUAQDJRBZFAECyhVyYopjo55sDHVwAEANrcAEAkok1uAAAyZYtHVxMUQQAAAAAAEBaYwQXAMTACC4AQDIxggsAkGxhx6Owk2AWxQQ/3xwYwQUAMQUjDx9NfUk8dAAAbBKPM8QaAEAs9VMUE3011fTp0+XxeDRx4kT3DsqADi4AAAAAAAC4bvXq1XrkkUfUt2/fpO+LDi4AiMFxwpEMV01/hVv6MAAAKcqdOEOsAQDYheR15RWvAwcO6Oqrr9ajjz6qtm3bJuHIotHBBQAxuDFthHVRAAA2bsUZYg0AwMb5zxpcibyc/6zBVVVVFfWqqamx7nfChAm68MILdd555zXLcdLBBQAAAAAAgCPq0qWLiouLI6/p06cbt1uwYIHefvtt6/vJQBZFAIiBLIoAgGQiiyIAINkSXSS+vg5J2rp1q4qKiiLlfr+/wbZbt27VTTfdpCVLlig/Pz+h/caDDi4AiIEOLgBAMtHBBQBItpDjVchJbAJfyKn736KioqgOLpO1a9dqx44d6t+//5efD4X0xhtv6MEHH1RNTY1ycnISao8JUxSRFT755BN5PB49/vjjLd0UAEAKGDt2rI477riost27d+t73/ueOnbsKI/Ho0suuUSS5PF4VFFR0extBACkn+OOO05jx4494nbLly+Xx+PR8uXLU6I9gJvOPfdcbdiwQevXr4+8ysvLdfXVV2v9+vVJ6dySGMGFLNG5c2etXLlSxx9/fEs3BWmGEVxA9vjVr36lxYsX67HHHtPxxx+vdu3atXSTkAUYwQVklsWLFx9xdAvQ3MLyKJzg+KawnEZvW1hYqN69e0eVtW7dWu3bt29Q7iY6uJAV/H6/zjzzzJZuBtJQffr2ROsAkPr++c9/6vjjj9fVV1/d0k1BFnEjztTXAyB+hw4dUqtWrVyrr1+/fq7VBbjFzTW4UhlTFJEUFRUV8ng8eu+993TllVequLhYnTp10o9+9CPt27cvst3evXt17bXXql27dmrTpo0uvPBCffzxxw2mg9TX9+677+qKK65QcXGx2rVrp0mTJikYDGrTpk0aMWKECgsLddxxx2nGjBlR7fn6FMXq6mr169dPJ5xwQlR7KisrVVJSoqFDhyoUSvw/NgEA7vnjH/+ovn37yu/3q3v37rr//vsj8aHeQw89pLPPPlsdO3ZU69at1adPH82YMUO1tbXWeutjxLJly7Rx40Z5PJ4jThv55z//qYsvvlht27ZVfn6+TjvtND3xxBOR9x3HUadOnTRhwoRIWSgUUtu2beX1evXFF19Eyu+77z75fD7t3bu3aScGANAo9THj7bff1uWXX662bdvq+OOPl+M4mj17tk477TQVFBSobdu2uvzyy/Xxxx9HfX7dunX69re/rY4dO8rv96u0tFQXXnihPvvss8g2pimBH3zwgUaMGKFWrVqpQ4cOGjdunPbv39+gfbbphEOHDtXQoUMj/66urtZ///d/67TTTos8Fw0cOFB//OMfj3gOwuGwpk6dqhNPPFEFBQU66qij1LdvX91///1H/CyQiOXLl2vWrFlJ3QcjuJBUo0aN0ujRo3Xttddqw4YNmjx5siTpscceUzgc1kUXXaQ1a9aooqJC3/jGN7Ry5UqNGDHCWt93v/tdff/739ePf/xjLV26NPLQsmzZMo0fP1633HKLnnnmGf3sZz/TCSecoMsuu8xYT35+vn7/+9+rf//++tGPfqRFixYpHA7r6quvluM4evbZZ5M2LxjphSmKQGp45ZVXdNlll+nss8/WwoULFQwGNXPmzKiOIkn617/+pauuukplZWXKy8vTO++8o1//+tf64IMP9Nhjjxnrrp/GPn78eO3bt09PP/20JOmUU04xbr9p0yYNGjRIHTt21AMPPKD27dvrqaee0tixY/XFF1/o1ltvlcfj0be+9S0tW7Ys8rk1a9Zo7969Kigo0F/+8hddddVVkqRly5apf//+Ouqoo1w4U0g3TFEEmt9ll12m733vexo3bpwOHjyoH//4x3r88cd144036p577tHu3bt11113adCgQXrnnXfUqVMnHTx4UMOGDVNZWZkeeughderUSZWVlXr99deNnVX1vvjiCw0ZMkS5ubmaPXu2OnXqpKefflo33HBDk9tfU1Oj3bt365ZbbtExxxyjQCCgZcuW6bLLLtP8+fP1gx/8wPrZGTNmqKKiQj//+c919tlnq7a2Vh988AE/smQ4dxaZb/wUxZZCBxeS6tprr9X//M//SJLOO+88ffTRR3rsscc0b948vfLKK/rrX/+qOXPmaNy4cZKkYcOGKS8vL9IR9nX/9V//pUmTJkXqW7JkiR588EE999xzuvTSSyXV/cLx4osv6umnn7Z2cElSjx499Lvf/U6jR4/W/fffr927d2v58uV65ZVX1LlzZzdPA9IYHVxAavjlL3+pY445Rq+++qry8vIkSSNGjGiwUPx9990X+f/hcFiDBw9W+/bt9cMf/lC/+c1v1LZt2wZ1109jLyoqUiAQOOKU9oqKCgUCAb3++uvq0qWLJOmCCy7Q3r17deedd+rHP/6xiouLdd5552nBggXaunWrunTpomXLlumkk05Sz549tWzZMl111VWqra3VG2+8oZtuuinBM4R0RQcX0PyuueYa3XnnnZKkVatW6dFHH9VvfvObyHOGJA0ePFg9e/bUfffdp3vuuUcffPCBdu3apXnz5uniiy+ObPfd73435r5++9vf6t///rfWrVunU089VZI0cuRIDR8+XFu2bGlS+4uLizV//vzIv0OhkM4991zt2bNHs2bNitnB9be//U19+vSJmi1z/vnnN6kdSB91a3AlNsUw0c83B6YoIqm+853vRP27b9++qq6u1o4dO7RixQpJDYPClVdeaa3v29/+dtS/Tz75ZHk8Ho0cOTJS5vP5dMIJJ+jTTz89Yvu++93v6ic/+Yn+53/+R1OnTtXtt9+uYcOGHfFzAIDmc/DgQa1Zs0aXXHJJpHNLktq0aaOLLrooatt169bpO9/5jtq3b6+cnBzl5ubqBz/4gUKhkP7v//7Plfa89tprOvfccyOdW/XGjh2rQ4cOaeXKlZLqfoiRFBnFtXTpUg0bNkznnXeeli5dKklauXKlDh48GNkWAJB8o0aNivz/F198UR6PR9///vcVDAYjr5KSEp166qmR6eonnHCC2rZtq5/97GeaO3eu3n///Ubt6/XXX1evXr0inVv16kfxNtUf/vAHnXXWWWrTpo18Pp9yc3M1b948bdy4MebnzjjjDL3zzjsaP368Xn31VVVVVSXUDiCV0MGFpGrfvn3Uv/1+vyTp8OHD2rVrl3w+X4MsVZ06dbLW9/Vt8/Ly1KpVK+Xn5zcor66ublQbf/SjH6m2tlY+n0833nhjoz6D7FH/y3qiLwBNt2fPnsiaVl/31bItW7Zo8ODB2rZtm+6//369+eabWr16tR566CFJdbHHDbt27TKO9C0tLY28L0ndunXT8ccfr2XLlkU6vuo7uD777DNt2rRJy5YtU0FBgQYNGuRK25B+3IozxBqg8b76N/yLL76IxJjc3Nyo16pVq7Rz505JdaOmVqxYodNOO0233367evXqpdLSUt1xxx0x13nctWuXSkpKGpSbyhrrueee03e/+10dc8wxeuqpp7Ry5UqtXr1aP/rRj474DDR58mTNnDlTq1at0siRI9W+fXude+65WrNmTZPbg9QXllehBF+JZmFsDkxRRItp3769gsGgdu/eHdVxVVlZ2WxtOHjwoMaMGaOePXvqiy++0HXXXdeoxRmRPRwn5EIWRRIWAIlo27atPB5Pg/W2pOiY8fzzz+vgwYN67rnn1K1bt0j5+vXrXW1P+/bttX379gbln3/+uSSpQ4cOkbJzzz1Xf/zjH7VixQqFw2ENHTpUhYWFKi0t1dKlS7Vs2TINHjw48gMQso8bcaa+HgCN89XkJB06dJDH49Gbb75p/Fv81bI+ffpowYIFchxH7777rh5//HHdddddKigo0G233WbcV/v27Y3PN6ay/Px81dTUNCjfuXNnVGx56qmnVFZWpoULF0Ydi+mzX+fz+TRp0iRNmjRJe/fu1bJly3T77bfr/PPP19atW13NKInUkS1rcKV+Fxwy1pAhQyRJCxcujCpfsGBBs7Vh3Lhx2rJli5577jnNmzdPL7zwgn7729822/4BAEfWunVrlZeX6/nnn1cgEIiUHzhwQC+++GLk3/X/kf/VhxHHcfToo4+62p5zzz1Xr732WqRDq96TTz6pVq1aRa3hdd555+mLL77QrFmzdOaZZ6qwsDBSx+LFi7V69WqmJwJAC/r2t78tx3G0bds2lZeXN3j16dOnwWc8Ho9OPfVU/fa3v9VRRx2lt99+21r/Oeeco/fee0/vvPNOVPkzzzzTYNvjjjtO7777blTZ//3f/2nTpk0N9p+XlxfVuVVZWRn3D/VHHXWULr/8ck2YMEG7d+/WJ598EtfngVTDCC60mBEjRuiss87Sf//3f6uqqkr9+/fXypUr9eSTT0qSvN7k9r/+7ne/01NPPaX58+erV69e6tWrl2644Qb97Gc/01lnnaUzzjgjqftHeqj7ZT3RReb5VR1I1F133aULL7xQ559/vm666SaFQiHde++9atOmjXbv3i3py0QlV155pW699VZVV1drzpw52rNnj6ttueOOO/Tiiy/qnHPO0S9/+Uu1a9dOTz/9tP785z9rxowZKi4ujmz7rW99Sx6PR0uWLIksaCzVdXxdc801kf+P7OVGnKmvB0D8zjrrLP3Xf/2XfvjDH2rNmjU6++yz1bp1a23fvl1//etf1adPH/3kJz/Riy++qNmzZ+uSSy5R9+7d5TiOnnvuOe3duzfmGr4TJ07UY489pgsvvFBTp06NZFH84IMPGmw7ZswYff/739f48eM1atQoffrpp5oxY4aOPvroqO2+/e1v67nnntP48eN1+eWXa+vWrfrVr36lzp0768MPP4x5vBdddJF69+6t8vJyHX300fr00081a9YsdevWTT169GjaSUTKC7swxTCs1B/BRQcXWozX69Wf/vQn/fd//7fuvvtuBQIBnXXWWXrqqad05plnJjVd+oYNG3TjjTfqmmuu0dixYyPlM2fO1MqVKzV69GitW7eOlO0giyKQIkaMGKFFixbpl7/8pUaPHq2SkhKNHz9en3/+uf6//+//kySddNJJWrRokX7+85/rsssuU/v27XXVVVdp0qRJUclIEnXiiSfqrbfe0u23364JEybo8OHDOvnkkzV//vyomCLVTU057bTTtG7duqiOrPr/X/8+shdZFIGW9/DDD+vMM8/Uww8/rNmzZyscDqu0tDTqR+8ePXroqKOO0owZM/T5558rLy9PJ554oh5//PHIDxYmJSUlWrFihW666Sb95Cc/UatWrXTppZfqwQcfjMrGKNUtPP/5559r7ty5mj9/vnr37q05c+ZE/UAiST/84Q+1Y8cOzZ07V4899pi6d++u2267TZ999lmDbb/unHPO0aJFi/S73/1OVVVVKikp0bBhw/SLX/xCubm5TTyDSHUhx6OQk1gWxEQ/3xw8jpMGEymRVZ555hldffXV+tvf/saiu2gxVVVVKi4u1oYNd6mwMP/IH4hh//5q9enzS+3bt09FRUUutRBAbW2tTjvtNB1zzDFasmRJSzcHiIubcUYi1gAAGqqPNf/fuj5qVZiTUF2H9oc0pt+GlI4zjOBCi3r22We1bds29enTR16vV6tWrdK9996rs88+m84tpARGcAGp49prr9WwYcPUuXNnVVZWau7cudq4caPuv//+lm4a0GSM4AIAJFt9JsTE6kj9sVF0cKFFFRYWasGCBZo6daoOHjyozp07a+zYsZo6dWpLNw2QRAcXkEr279+vW265Rf/+97+Vm5urb3zjG3rppZdYwwppjQ4uAECyhR2vwglmUQynweQ/OrjQor797W/r29/+dks3AwCQBn7/+9+3dBMAAACQopKbpg4A0pzjhP+T4SqRV7hJ+549e7bKysqUn5+v/v37680334y5/YoVK9S/f3/l5+ere/fumjt3btT7jz76qAYPHqy2bduqbdu2Ou+88/SPf/wjapuKigp5PJ6oV0lJSZPaDwA4MnfiTNNiDXEGALJD/RTFRF+pLvVbCAAtqH7qSKKveC1cuFATJ07UlClTtG7dOg0ePFgjR47Uli1bjNtv3rxZF1xwgQYPHqx169bp9ttv14033qhFixZFtlm+fLmuvPJKvf7661q5cqW6du2q4cOHa9u2bVF19erVS9u3b4+8NmzYEHf7AQCN41aciTfWEGcAIHuE9WUmxaa+mvaTffMiiyIAGNRnHFm37hYVFvoTqmv//hr16zczrowjAwYM0De+8Q3NmTMnUnbyySfrkksu0fTp0xts/7Of/UwvvPCCNm7cGCkbN26c3nnnHa1cudK4j1AopLZt2+rBBx/UD37wA0l1v6w///zzWr9+fRxHCACIl5txRoo/1hBnACDz1ceah9/ur4I2ia1QdfhAUD/+xtrszKI4e/Zs3Xvvvdq+fbt69eqlWbNmafDgwUf8XDgc1ueff67CwkJ5PJ5kNQ9ABnMcR/v371dpaam83sQGqtb9Kp5YSt36X9Wrqqqiyv1+v/z+hg81gUBAa9eu1W233RZVPnz4cL311lvGfaxcuVLDhw+PKjv//PM1b9481dbWKjc3t8FnDh06pNraWrVr1y6q/MMPP1Rpaan8fr8GDBigadOmqXv37kc+0GbW1DgjEWsAJCbV4kx9PVLjYg1xpnGIMwBakpuxJiyvwglO4Ev0880hKR1c9UOeZ8+erbPOOksPP/ywRo4cqffff19du3aN+dnPP/9cXbp0SUazAGSZrVu36thjj02wFjcePOoeOr7+t+2OO+5QRUVFg6137typUCikTp06RZV36tRJlZWVxj1UVlYatw8Gg9q5c6c6d+7c4DO33XabjjnmmKgMdAMGDNCTTz6pnj176osvvtDUqVM1aNAgvffee2rfvn2jjrY5JBJnJGINAHekTpypq0dqXKwhzhwZcQZAqnAj1oQcr0IJZlFM9PPNISkdXPfdd5+uvfZaXXfddZKkWbNm6dVXX9WcOXOMQ56/qrCwMBlNApCFUu3vydatW6OG85pGb33V13/xdRwn5q/Apu1N5ZI0Y8YMPfvss1q+fLny8/Mj5SNHjoz8/z59+mjgwIE6/vjj9cQTT2jSpEkx29ucEokzUurdGwDSUyr+LYkn1hBn7NyKMzcuHSZ/6+jRbde3XWv8zB/2n2wsn7N6qLG8aEOesTyvyr4Czc7BAWP5Rb3eNZa/uLGPsbzVxnxjubfWvN9Dx5hX7wm1DhnL83bF95ga7nbYWH7s0Xusn/nk407G8tw9lg5ny1cj56D5jWOXHzB/IGy+Prt7tzGWV51gac6xB43lztbWxnLfAXM7azqZr4EkOV5zW9utM5+j/ZaBmEOHvmMs75BnPkcLNpQby/M+Md93nlOqjOWzT33WWF4VNv9dnPjXq4zlknTU+oajVCXpUEfzeR02wvw9v6LtP4zlbxw8sUFZzcGg7jl3eUrGmlTlegdXU4Y8fxVDeAG4xY2/J/XZqRKtQ5KKiooaNV+9Q4cOysnJafAr+o4dOxr8el6vpKTEuL3P52vwi/jMmTM1bdo0LVu2TH379o3ZltatW6tPnz768MMPj9ju5pJonJGINQDckSpxpr4eqXGxhjgTm5txxt86V/420Q/GhYXmURD5jvnRzFtgfqjP8Zs7uHLy7B1c3gLzvr/exiPv29LBZRng4c03d3A5BeZ735sf52NqK/Mx+1rbO3htx+Y9HGcHV9D8hs9nSfxg6eDKybO0x1wsTyvzuXPyLdes1txOr+UaSPYOrpw88zmytTWvjfle9efFed9Zjs3Tytxx29ryXQuFLe237FeScixtzck3n9c8y3fK1qZ8j3l7yZ1YE5ZHYdtNHEcdqc71MWbxDnmuqalRVVVV1AsAUkXdg0eima3ie3DJy8tT//79tXTp0qjypUuXatCgQcbPDBw4sMH2S5YsUXl5edS6KPfee69+9atf6ZVXXlF5ufnXsa+qqanRxo0bjVNPWkpTptYQawCkKnfiTHyxhjgTG3EGQKapn6KY6CvVJa2FjR3yPH36dBUXF0dezFUHAGnSpEn63e9+p8cee0wbN27UzTffrC1btmjcuHGSpMmTJ0cyUkl1maw+/fRTTZo0SRs3btRjjz2mefPm6ZZbbolsM2PGDP385z/XY489puOOO06VlZWqrKzUgQNfDg+/5ZZbtGLFCm3evFl///vfdfnll6uqqkrXXHNN8x18I8UztYZYAwDRiDNHRpwBgPTi+hTFeIc8T548OWq+fVVVFQEBQMqo+1U88QxZ8Ro9erR27dqlu+66S9u3b1fv3r310ksvqVu3bpKk7du3a8uWLZHty8rK9NJLL+nmm2/WQw89pNLSUj3wwAMaNWpUZJvZs2crEAjo8ssvj9rXVxcg/uyzz3TllVdq586dOvroo3XmmWdq1apVkf2mgqZMrSHWAEhVbsSZ+nriQZyxI84AyDQheRVKcHxTop9vDh6nfnVIFw0YMED9+/fX7NmzI2WnnHKKLr744iMuylhVVaXi4mK3mwQgC+3bt69Ra16Z1P8t+sc/fqA2lnUDGuvAgYDOOOPJhNqDaInEGYlYA8AdqRJnJGKN29yKM72v/XWDtZWckeaFz/255k7K/YfN60gdqrKsU7TTfj+FLetz5RxdbSwPHrCsO1RlWafKMY9wC9vW4MoxtydvV3zrYNUWmutx/Ob9SpL3kPlh3fFZ6iqw12Xi220ZS2J5+g61jq9+a1+DZbayE2NtNhtPwHzC8/9tuT6WQwgcZd63LcmA74C5fo+l/mCh+Q1fO/N9LY+5PbVVMZJyBOK7XzwF5u+zc8h8X5iSG4Srq7X5zimuxJoZqweroE1i45sOHwjq1tPfTOk4k5QsipMmTdKYMWNUXl6ugQMH6pFHHoka8gwAQCKIMwCAZCLOAED6SUoH15GGPANAunAziyLcQ5wBkCnczqIIdxBnAGSSsAtTFMNpMEUxKR1ckjR+/HiNHz8+WdUDQLNoqTW4cGTEGQCZoKXW4MKREWcAZIqw41U4wViT6OebQ+q3EAAAAAAAAIghaSO4ACAT1E0dSexXcaaNAABs3Igz9fUAAGASkkchW5aGOOpIdXRwAUAMdVNHEvtjzrQRAICNG3Gmvh6knpJXP5PPG52Z7YOzjjZuW1x8yFheW2vOKJebb77mvrIaa3tqDpuzIgarLJkXLVnrwuZq5PgtHa22BIGWLIqB0lrLBywsCQI9lgx3kuTkm9vqBC3fR0tbvbnmg/P3MF/PUMgyicpynb05lgyUYXM7PV7LOT1ovsbeXHvnuK+t+b3DrS33iyXToJXlVAcLzfv12I7Zku0xuMucadRju8bF9vvO29r8fQvb6rL8XffUmssdw+U3lTUVUxQBAAAAAACANMAILgCIgRFcAIBkYgQXACDZQkp8imE6TISngwsAYqhbGyXRLIrpEA4AAC3BjThTXw8AACZMUQQAAAAAAADSACO4ACAGpigCAJKJKYoAgGQLOV6FEhyBlejnmwMdXAAQQ93UkUQ7uJg2AgAwcyPO1NeD1LP3jGPky43O5Na+3a646si1ZLmrqTGnMrRlSpQkjyUToHyWNIe2BHHWemzpDG3tMe83r8CczS5syaLnhM0P3qHaGA/ktjblmo/Bdu5s2QyrD5szDfrzA8byglaWLH2WY6uuNl9nr2NuZ24r837z8ux/OwI15u6C3Fbm6+MtNF/PWks94UB8aQI9lraGq831eywZLsOW+8L6/ZBkOa3WLJper2Xflu2D+xtez3CMaxMvRx6FE1yDy0nw880h9bvgAAAAAAAAgBgYwQUAMdRNHUm8DgAATNyIM/X1AABgwhRFAABTFAEAScUURQBAsoUdj8IJxppEP98cUr8LDgAAAAAAAIiBEVwAEANTFAEAycQURQBAsoXkVSjB8U2Jfr450MEFADHQwQUASCY6uDLbF4MceQuiL3BHj/mCH6j2G8tray2Z5izThWJlprNlibNlm7NxbGvxhMxtyi00Z/DzeM3tCQXNx+CxZKZr07raWH7YkmlSkgKHzFkOnaAlU6PlK5ZTYHnDdn0sWRFtvJZz1KpVjbH88CHzfWTLQBm01C/JOn3aZ8nsGbBkMwxb7uGcfEtWREuWw3DQkv3Qdv9ajs2bb75mnliXxvK99fnMx2A7dx5LPW0+bnjuQpbsk03BFEUAAAAAAAAgDTCCCwBiqFv8N/E6AAAwcSPO1NcDAIBJWF6FExzflOjnmwMdXAAQU1BOwk8ePHQAAGzciDMSsQYAYBNyPAolOMUw0c83h9TvggMAAAAAAABiYAQXAMTAFEUAQDIxRREAkGzZssi86x1cFRUVuvPOO6PKOnXqpMrKSrd3BQBJV5fdKrEnDx463EWcAZBJ3IgzdfUQa9zkVqzxBD3y1EY/FP57d6Fx2/wCc6bBYMD8yOZYMs3ZMtNJUqjGkmHRkmHPlgnQloXOxvZgbDsGf36tsTwUMm+/b09rY7knx54d0mvJvOdYnpDDB8wZGUOWR2rbdbBl0bNlVwxasjrasivGK1hr7xLw5sR3DLl+830RtGTvDFmyLtqya+bkma+ZP9/83am1fHds95HtuCTJ9o4tW6JtH44l06jvoKE95sNqEsfxKmzLfhpHHakuKSO4evXqpWXLlkX+nZNjT1ULAEC8iDMAgGQj1gBAeklKB5fP51NJSUkyqgaAZlU3dSTREVz2Xw/RNMQZAJnCjThTVw+xxm3EGgCZIiSPQkpwkfkEP98cktLB9eGHH6q0tFR+v18DBgzQtGnT1L17d+O2NTU1qqmpify7qqoqGU0CgCapmzqS6HBeHjrcFk+ckYg1AFKXG3Gmrh5ijdt4pgGQKcJO4mtohd2ZFZtUrk+iHDBggJ588km9+uqrevTRR1VZWalBgwZp165dxu2nT5+u4uLiyKtLly5uNwkAkEHijTMSsQYAEB+eaQAg/bjewTVy5EiNGjVKffr00Xnnnac///nPkqQnnnjCuP3kyZO1b9++yGvr1q1uNwkAmqxu6kjiL7gn3jgjEWsApC634gyxxl080wDIJOH/LDKf6CvVJWWK4le1bt1affr00Ycffmh83+/3y+/3J7sZANAkTFFMfUeKMxKxBkDqYopieuCZBkA6C8ujcIJraMX7+enTp+u5557TBx98oIKCAg0aNEj33HOPTjzxxITaEUvSO7hqamq0ceNGDR48ONm7AgBkIeIMACDZmhprfPs9yqmNfiislbkj7NBR5o7OvFa1xvKQJatjKBCjwzRkfkD1+C0jAMPm7Z2QZR8e8yI93hzL4j1ec3mw1nxsHsv2Pn8wru0lKXAwz/qeibe1+TrYhC3nuvqQeb+5lmPIzTVfm0MH4utQ9frMneDhoP1+8XjM79UcTm5GUW9efCNSg8H47pccxf+DgPU8WU6FrSsor8B8Hx0c3PCYw4eqpUca0bgUtWLFCk2YMEGnn366gsGgpkyZouHDh+v9999X69atk7JP1zu4brnlFl100UXq2rWrduzYoalTp6qqqkrXXHON27sCgKRjBFfqIc4AyCSM4EpNxBoAmSTkeBRKcJH5eD//yiuvRP17/vz56tixo9auXauzzz47obbYuN7B9dlnn+nKK6/Uzp07dfTRR+vMM8/UqlWr1K1bN7d3BQDIQsQZAECyEWsAwOzrWWIbO0V73759kqR27dolpV1SEjq4FixY4HaVANBi6hbuTexXccdJg5y6aYQ4AyCTuBFn6uoh1riJWAMgk7ixSHz957+eJfaOO+5QRUVFzM86jqNJkybpm9/8pnr37p1QO2JJ+hpcAJDO6qaOJDacl4cOAICNG3Gmrh5iDQDALCyPwgnGmvpF5rdu3aqioqJIeWNGb91www1699139de//jWhNhwJHVwAAAAAAAA4oqKioqgOriP56U9/qhdeeEFvvPGGjj322CS2jA4uAIipbuoII7gAAMnhRpypq4dYk4oCnWvlLfhamjXbLCFLxkJbRkEbW7Y8ScrJN2fqq602PxZ6LLemJ8e8D48lW6LPkgnQdtvWBsztcQK2BlmKLVkdJclraZM1/Z2lKlt2vZw88znyei3ZDC2ZKYOWY8ixZUW03Eehg7nGclvmS0kKW7IQ2rJi2moK15qPzXYfhQPmez7e7IqO5VzYjjnHlu1TsTNymoQsx5CbZ/4ODj7u4wZlgQMBbY5rr3aOPJERWInUEdf2jqOf/vSnWrx4sZYvX66ysrKE9t8YdHABQAxMUQQAJBNTFAEAyRZ2XJiiGOfnJ0yYoGeeeUZ//OMfVVhYqMrKSklScXGxCgoKEmqLTeI5iQEAAAAAAID/mDNnjvbt26ehQ4eqc+fOkdfChQuTtk9GcAFADIzgAgAkEyO4AADJ5mYWxcZqibhEBxcAxOA49vUh4qkDAAATN+JMfT0AAJi0xBTFlsAURQAAAAAAAKQ1RnABQAyO43NpimKtOw0CAGQUN+JMXT3EmlTk9YfkzY/O/BY+aHkEi5HBzbi5LQNdjPvJG2f2w1y/OeObLTuhrU011XnGclt2PVky1tnaacv2GKqxZ6D0WLIQei37to2StLXJsSWztGyfZ8muV2vJomn7u2HNHGjZb6zMhGHL+XNsdeWaD9qxZBT0WLa3ZVe0ZaAMWTJQ2r4Jtvs3VsZS22es18FyvxzebV5cfUVNjwZl4UPV1vbEK+xCFsVEP98c6OACgBjo4AIAJBMdXACAZGOKIgAAAAAAAJAGGMEFADE4Tq5LI7gOu9MgAEBGcSPO1NVDrAEAmGXLCC46uAAgBsfJkZNgSl3HuggDACDbuRFn6uoh1gAAzLKlg4spigAAAAAAAEhrjOACgJh8Lvyyzq/qAAAbN+KMRKxJTTk54QaZCx1b5kBzEj05lkxz3jzLNbdklJOksOU9nyWDny1zXChozjYXtmXws2VdtGTwC9qy91Wby70F5vbnFtgTL4TD5nNhzexoOQZb5kCvLeueZb+2UZh5tnMUNNdf65gf8W2DPMOWcypJOQWWDIuWYwsHLefOkrHSli3RNm279oA5G6dNbpuAsTzHkgUyFOvvqKVNIdv9YvkueKrN24dCuQ2rOGzPcBmvbBnBRQcXAMRQl92KKYoAgORwI87U1UOsAQCYOZLCSnBdYXeaklRMUQQAAAAAAEBaYwQXAMRQl92KEVwAgORwI87U1UOsAQCYMUURAMAURQBAUjFFEQCQbNnSwRV3NH3jjTd00UUXqbS0VB6PR88//3zU+47jqKKiQqWlpSooKNDQoUP13nvvudVeAECGI84AAJKJOAMAmSnuEVwHDx7Uqaeeqh/+8IcaNWpUg/dnzJih++67T48//rh69uypqVOnatiwYdq0aZMKCwtdaTQANBfHyZHj2LPLNK4O9zKgZAPiDIBs4kacqauHWNNYzRlnenT+t3JbR2d+++eubuaNLSs4O5ZsbLaMiF/P2hhVl2UEhtdryfhnaZM/35ydsLbWkl3RlmnONiLEko3P4zff5+FqS+ZAy/aS5Mu1vJdnORchSxa9KnNmv5Alu6K/sMZYbrsGtsyUtutvk1dozigYDMTIouizZHC0fMaxXDevJRNk+LClO8KS5TCnlTlbZo7lng9a7sdgwJLh0JIdMhbHkvHTmkWxrfk6nHTsFw3Kggdr9FncLbI0hxFcZiNHjtTUqVN12WWXNXjPcRzNmjVLU6ZM0WWXXabevXvriSee0KFDh/TMM8+40mAAaE51U0cSfzXF7NmzVVZWpvz8fPXv319vvvlmzO1XrFih/v37Kz8/X927d9fcuXOj3n/00Uc1ePBgtW3bVm3bttV5552nf/zjHwnv123EGQDZxK0405RYQ5whzgDIDvUdXIm+Up2rWRQ3b96syspKDR8+PFLm9/s1ZMgQvfXWW8bP1NTUqKqqKuoFANlu4cKFmjhxoqZMmaJ169Zp8ODBGjlypLZs2WLcfvPmzbrgggs0ePBgrVu3TrfffrtuvPFGLVq0KLLN8uXLdeWVV+r111/XypUr1bVrVw0fPlzbtm1r8n6bW1PijESsAYCvI86YEWcAIH252sFVWVkpSerUqVNUeadOnSLvfd306dNVXFwceXXp0sXNJgFAQuqyWyX+itd9992na6+9Vtddd51OPvlkzZo1S126dNGcOXOM28+dO1ddu3bVrFmzdPLJJ+u6667Tj370I82cOTOyzdNPP63x48frtNNO00knnaRHH31U4XBYf/nLX5q83+bWlDgjEWsApC634ky8sYY4Y0acAZCJHMfjyivVudrBVc/jiT5wx3EalNWbPHmy9u3bF3lt3bo1GU0CgCZxc9rI13/Zrakxr8EQCAS0du3aqF+PJWn48OHWX49XrlzZYPvzzz9fa9asUW2teZ2MQ4cOqba2Vu3atWvyfltKPHFGItYASF1uT1FsTKwhzhwZcQZAJgnL48or1bnawVVSUiJJDX7d2LFjR4NfQer5/X4VFRVFvQAgE3Xp0iXq193p06cbt9u5c6dCoVBcvx5XVlYatw8Gg9q5c6fxM7fddpuOOeYYnXfeeU3eb3NrSpyRiDUAskdjYg1xxo44AwDpq2krH1uUlZWppKRES5cuVb9+/STV/VKzYsUK3XPPPW7uCgCaRV12q8T+VNZnINq6dWvUf/D6/f6Yn4v312PT9qZyqS5D1LPPPqvly5crPz8/of02J+IMgEzjRpypq6fuf+OJNcSZhtyOMxce/a4K2kRf3w255umLnoAlc6Dt1FgyvgWD9qx4tkyAObaMgpYpSTWWfdgy/lnbE7RlUTSXO17L+AxL1j2vpVyyZ4QLWTIy2s63YmRqNKkNWDI+WjKh5lqujS0LZCjO7IqeGJuHLNfZ9pmcfHOWw7Alu6IsmSM9lqyIIUvWRdsV8Fiuv8+SBdR2vJI9E6gts6cOmKeN51nO0UPdf9+gbP/+sPpZWxSfbMmiGHc0PXDggD766KPIvzdv3qz169erXbt26tq1qyZOnKhp06apR48e6tGjh6ZNm6ZWrVrpqquucrXhANAcEsmC+GUddf/b2F90O3TooJycnLh+PS4pKTFu7/P51L59+6jymTNnatq0aVq2bJn69u2b0H6TgTgDIJu4EWfq6qn738bEGuIMcQZAdnFjDa2MXINrzZo16tevX+QXjUmTJqlfv3765S9/KUm69dZbNXHiRI0fP17l5eXatm2blixZosLCQndbDgAZKi8vT/3799fSpUujypcuXapBgwYZPzNw4MAG2y9ZskTl5eXKzf3yF6R7771Xv/rVr/TKK6+ovLw84f0mA3EGAJKLOEOcAYBMFPfPRUOHDo0MRzbxeDyqqKhQRUVFIu0CgJRQl5kq0RFc8f/aMWnSJI0ZM0bl5eUaOHCgHnnkEW3ZskXjxo2TVLeY7bZt2/Tkk09KksaNG6cHH3xQkyZN0vXXX6+VK1dq3rx5evbZZyN1zpgxQ7/4xS/0zDPP6Ljjjov8gt6mTRu1adOmUfttDsQZANnEjThTV098sYY4Q5wBkD2YoggAcHWKYjxGjx6tXbt26a677tL27dvVu3dvvfTSS+rWrZskafv27dqyZUtk+7KyMr300ku6+eab9dBDD6m0tFQPPPCARo0aFdlm9uzZCgQCuvzyy6P2dccdd0T+I/5I+wUAuMvtKYqNRZwBgOyRLVMUPU6sny9aQFVVlYqLi1u6GQAywL59+5qcxaj+b9ETT3xLrVol9uBx6FBQ11zzWkLtgbuINQDckCpxRiLWpJr663v/mjMbLDI/9Y2LjJ+xLTKvQvOi1LaFssNh+yo0bi0yb3vQtS0yb9uvY1m4W7byPPPi47I8d+fEWgDesmh83IvMx8mbaz4G26LxtkXmbee6ptq8uLl1UfoYC6vHzXKObIvM266/x2c+R45tsXpbc5pjkXnLQvm2Reb9HQ8Zy186Y06Dsv37w+rXa4crsab/opvlax07wdWRBA/WaO2o36Z0nGEEFwDE4E4WxZT6HQEAkELcy6JIrElFf/53X+Ueyosq8x6yPERbOmnCls4hW0eW12vpBJKsKzCHQ+50cngtD/shW3ZFW3m+uTPGc9CSgdC239oYWUEt+7B1ioX2mzssrB1fueZyW2dfyGO+BrasiLbrXNAqYCwPBCwZEWN03Nnes9171o5MS8eU13KubfXI0lSPL76/f7WHzdeySclcbZ3AlvvL9qf6jwd6NyirPhiUtKMJjTLtN/EpiukwgosOLgCIwZ0pijx0AADM3JuiSKwBAJg5atqyKV+vI9XFnUURAAAAAAAASCWM4AKAGOqyW1mGpDe6DpcaAwDIOG7Embp6XGgMACAjheWRxzYPOo46Uh0dXAAQA1MUAQDJxBRFAECyZUsWRaYoAgAAAAAAIK0xggsAYmAEFwAgmRjBldk+2NpJ3lb5jdo23NqSOdBnzpZnzcYXIyOiJ8eSFS9orstryU5ny65nuwu9lv1asytaOLnmc+HxW86R5bgkyak1j/UIhW1ZEWNkpzSxbO7Jc+e7Gqyx/N2wjLKxZdDzxsiiGLJkP3QsmR09OeaDzskPWvdhErZcm9zWtcZyW1ZExciiaeJtY2+nN8f8/QxW27Jrmotr9pn/Hjz055ENysLV1ZKWW9sUj7DjkSfBEViJZmFsDnRwAUAMbqRvd5w4/4MIAJA13IgzdfUQawAAZo7jQhbFNPgdhSmKAAAAAAAASGuM4AKAGNzJopgGP3cAAFqEe1kUiTUAALNsWWSeDi4AiMmNtVGYNgIAsHFnDS5iDQDAJls6uJiiCAAAAAAAgLTGCC4kXTtPcvtRbfXvdmmxVbfqQXpyJ4si9xCQbMQapCv3sihyD6Wio/6ar5y86Kxp+040b2vLEGjLxtaUP3u28Rc58WYItAhbsu7l5Zuz33mLzfu1Ze8LWzJH2jJKxhrO4c01Z8ULH7J8H/MsGRy9lunBltEuHktTQ4fN2S9z2wSM5V5LNsaQJcOhlSXDpWQfseOzXE/bMdvalGPJumg719YRRLavTr4lM6nlmGP9GQ055uvj85szL9ruYVlmpDvehvU7tnurCciiCABwKYuiObgCAOBeFkViDQDAjCyKAAAAAAAAQBpgBBcAxOBOFkWmjQAAzNzLokisAQCY1Y3gSnSReZcak0R0cAFADO6swcW0EQCAmXtrcBFrAABmZFG0eOONN3TRRReptLRUHo9Hzz//fNT7Y8eOlcfjiXqdeeaZbrUXAJDhiDMAgGQizgBAZor756KDBw/q1FNP1Q9/+EONGjXKuM2IESM0f/78yL/z8vKa3kKknHgzVdm2t5W3dykT1q44h+rHm8GKjFfZgRFczY84A4lY09TtkX4YwdX8mjPOdHz1E/m80Z89VHK8cdtwZ/P3PcdnLg/WmrO62baXJI8nvsx7jiUTXE6e+X6zZUsM1prvcVtWRJ8lw2GuNWOd+VwEq+3fLVsY8BRYvku2ZImWc+SxZKbM8Znr97a2XDdbZkLbfm0ZAm0ZKGOMyok3Q6SN7ZjtO7Ycg61+yzULBSz3da25PLe1JTtkDLZ71aa48LCxfJ/pe3uoOu722Diyn7946kh1cUfTkSNHauTIkTG38fv9KikpaXKjACBVuJNF0fwfYzAjzgDIJu5lUSTWNBZxBkC2YYpiApYvX66OHTuqZ8+euv7667Vjx45k7AYAkKWIMwCAZCLOAED6cX2R+ZEjR+qKK65Qt27dtHnzZv3iF7/Qt771La1du1Z+v7/B9jU1NaqpqYn8u6qqyu0mAUCTuZNFkWkjboo3zkjEGgCpy70sisQatxBnAGScLJmj6HoH1+jRoyP/v3fv3iovL1e3bt305z//WZdddlmD7adPn64777zT7WYAgCvcWYOLhLVuijfOSMQaAKnLvTW4iDVuIc4AyDguTFGMd+21lpCUKYpf1blzZ3Xr1k0ffvih8f3Jkydr3759kdfWrVuT3SQAQAY5UpyRiDUAgKYjzgBAekj6Tz27du3S1q1b1blzZ+P7fr/fOtQXLSdW9qp4M1X18JpvsxMs5bbt482o9VHYvNjqh5byeLdvCrJhpR9GcKW+I8UZiViTqog1R96+KYg16YURXKkvkTiz6Zau8hbkR5V5QubvaPiQ+RrmFAWM5V5LtjxbpkRJCltGYNiy3HksGeJqD5un1dpGiHi95mP2WTINei3Z+wI15v3a6s8tsGfFs2UhVNh8DB5Ldkqf33x9bKNdbOfOZ8kQaWO7/rasfoFQfJksY+3Ddp1td16epU01lnNhywRqu39tx5DjN+/XsVzjWBlIbVlLw3HWFbBk/MzZ1LphYbV526ZwnLpXonWkurhHcB04cEDr16/X+vXrJUmbN2/W+vXrtWXLFh04cEC33HKLVq5cqU8++UTLly/XRRddpA4dOujSSy91u+0AkHT12a0Se7kXnLIBcQZANnEnzhBr4kGcAZBt6rMoJvpqitmzZ6usrEz5+fnq37+/3nzzTZeP7ktx/9SzZs0anXPOOZF/T5o0SZJ0zTXXaM6cOdqwYYOefPJJ7d27V507d9Y555yjhQsXqrCw0L1WAwAyFnEGAJBMxBkAaB4LFy7UxIkTNXv2bJ111ll6+OGHNXLkSL3//vvq2rWr6/uLu4Nr6NChcmKMTXv11VcTahAApBJ3sii6N/UoGxBnAGQT97IoEmsaizgDIOs4nsQXiW/C5++77z5de+21uu666yRJs2bN0quvvqo5c+Zo+vTpibXHgMn6ABADa3ABAJKJNbgAAMnWEmtwBQIBrV27VrfddltU+fDhw/XWW28l1hgLIiEAAAAAAACOqKqqKurftiQbO3fuVCgUUqdOnaLKO3XqpMrKyqS0jQ6uLBdvlirJnnnqjJw8Y/kFvnxjea/cVsby7ZbyQ5b95lqyRZUHq43lObWHjOVPW8rbhcyZUf5uKZfIYJVJGMEFJI5Y8yViDb6OEVyZ7a2L5qioMPpv3WlvjDNvXGX++2bL3ua3ZAiMlUXRtki0bR+KMzuhbYRHOGz+ex8KWDJHWrI6enMs2R4tM6fCIXuc8VgyBNr2YTurtmPzWq5DTp65flm2tx2bz9LOmmrzlGfb8ToxsijaMk3aMjWGAub7KOgxl1uzMdrKLRkLbWzZNUMhc3sCNfH/HXVqzZ/x5ZqnjVdbMoG2+bzh9QkFXExb6Mh+E8dTh6QuXbpEFd9xxx2qqKiwfszztZvYcZwGZW4hEgJADHUPHomuwWVPUQ0AyG5uxJm6eog1AACzRLIgfrUOSdq6dauKiooi5abRW5LUoUMH5eTkNBittWPHjgajutxi79IGAAAAAAAA/qOoqCjqZevgysvLU//+/bV06dKo8qVLl2rQoEFJaRsjuAAgBqYoAgCSiSmKAIBm4eKMx8aaNGmSxowZo/Lycg0cOFCPPPKItmzZonHjLFO1E0QkBIAY6OACACQTHVwAgGRzc4piPEaPHq1du3bprrvu0vbt29W7d2+99NJL6tatW0JtsSESAgAAAAAAwHXjx4/X+PHjm2VfdHABQAyM4AIAJBMjuAAASediFsVURiSEUazU7bYU7TfmtTGWf1HQzlj+v62ONpb/vY05o8J2X4GxvDhszhrU59AuY/kZh/5tLP/xwR3GctVUGYtjpWf/MGxOC2tDqvdUlutCdqvEs2MBmYhY8xXEmizmRpypqwep57+3fUu5raP/noUOmR/BPAXm77QTMk8L8njMT5vB2hxre3y5IWO5N8f898FWV6vWNcbyQMB8bDmW+j0+8zGEgub92tppOxdhy7mLxTYLy2Mtt1yHgOUYcs3H4ITjy/+Wl2e+X2znOsdnLq+N0Tnu1JoPOmxrq+UchYLm7W3nzjYVzgmby23HFqyxHJulfm+e+fsRS9hybGGvudx2D+/r2fBchKvd7FHyyHqB4qojtZFFEQAAAAAAAGmNEVwAEIPj5LgwRdH+SyoAILu5EWfq6wEAwIgpigAA1uACACQTa3ABAJIuSzq4mKIIAAAAAACAtMZPPQAQAyO4AADJxAguAEDSOR57BoV46khxRMIsYctUZSvv4bXfGhf48o3lu/OPMpb/b9vuxvIHju5lLB/SqY+xvKh1R2N5oPaQsXzJrv8zlm+oXG8sr7WcixssWad2xchGZXuPDFbpx3ESz27lTnYsIPURa75ErEFjuRFn6utB6tk27QT5vvb3rOB0c5bYw8cHjOU5fnNmN1sGuliCloxvuZbsij6fuTwUsmSOs5TnWjL+2YS9lox/1e5lxbNlpwzXxjfJyXZ9bEKWY7C11eO1ZJq0nGvb9rWWDJfhoL3TwpbxMVRjXvPPY8lmaMs06MkxtzUvz5y5OGDJihjvN8FjyWQY2h/j76itcyfPUpflOtgyk/qrGp6jUI17E+4cp+6VaB2pjimKAAAAAAAASGuM4AKAGMiiCABIJrIoAgCSLksWmaeDCwBiYA0uAEAysQYXACDpsmQNLqYoAgAAAAAAIK3F1cE1ffp0nX766SosLFTHjh11ySWXaNOmTVHbOI6jiooKlZaWqqCgQEOHDtV7773naqMBoLnU/7Ke6AuNQ5wBkG3cijPEmsYj1gDINh7HnVeqiysSrlixQhMmTNDpp5+uYDCoKVOmaPjw4Xr//ffVunVrSdKMGTN033336fHHH1fPnj01depUDRs2TJs2bVJhYWFSDgJNZ8tsdUKMzFa9clsZy/+3dSdjuS2D1SUnXWws79nTXH+HDn8wlh88eIqx/OOPRxvLP8jxG8uXBg4ay7sGDhjLBwSrjeWS9I+QOQvObsv5tiETVssji2LzIs5kJmLNl4g1+DqyKDa/5ow1/u0H5cuJziAYKmhr3NaWRc+bYy4/fND8dybXb89Y6LVkdqs+bM7s6LHNSLI86RYUmP8u2RyyHIOtnbase44lkaEte58kOZb3fPnm8xcOm09G6JA5lnks2fWs2RIt59p2CQI15u+87X7JsWTEVKyYYZuSZslAKctSgF5LdkWv5XqGLNcmx5L90Gspr7Fke3QClobGmIHnsdwXtqyV4WrLPizH5t/TsCxUY29P3FiDq6FXXnkl6t/z589Xx44dtXbtWp199tlyHEezZs3SlClTdNlll0mSnnjiCXXq1EnPPPOMfvzjH7vXcgBAxiHOAACSjVgDAJkpoTW49u3bJ0lq166dJGnz5s2qrKzU8OHDI9v4/X4NGTJEb731lrGOmpoaVVVVRb0AIFXUZ7dK7EVmq6ZyI85IxBoAqcudOEOsSQTPNAAyXv0i84m+UlyTO7gcx9GkSZP0zW9+U71795YkVVZWSpI6dYqePtCpU6fIe183ffp0FRcXR15dunRpapMAwHWsi9Jy3IozErEGQOpiDa6WxTMNgKzguPRKcU3u4Lrhhhv07rvv6tlnn23wnudrE4gdx2lQVm/y5Mnat29f5LV169amNgkAkEHcijMSsQYAYMYzDQBkjib91PPTn/5UL7zwgt544w0de+yxkfKSkhJJdb96dO7cOVK+Y8eOBr+A1PP7/fL7zYsLAkBLc+NXcX5Vj5+bcUYi1gBIXW6NviLWxI9nGgBZg0XmG3IcRz/96U+1ePFiLV++XGVlZVHvl5WVqaSkREuXLlW/fv0kSYFAQCtWrNA999zjXqvhmvaWrBk9YmS22unLN5a/3fpoY/ngo82Zp3r0KDKWDxgwxFjetevNxvJ9+54xlrdu/b6xfP/+C43lS3Z/aCwftn+bsbzH4d3GcsmeMQzppyWzKM6ePVv33nuvtm/frl69emnWrFkaPHiwdfsVK1Zo0qRJeu+991RaWqpbb71V48aNi7z/3nvv6Ze//KXWrl2rTz/9VL/97W81ceLEqDoqKip05513RpUdafqfm4gzmYlY8yViDb6uJbMoZmOckZo31nz6nbbK8Uf/PQscXWve+IDlGrY2F9sy0DmWbH+SZMuZassEl5trzrwXqDH//bZlY7RluWvdxpwptrbWUv8Bc/02tqyLkpTjNx+bY1lnyHaOvPmW7IQWtuvjWJrqsSX8i3M5JFv9sYQt2RJzWpvvYVvWSts5zfGZMxOGguaDzs0zbx+07Neba77vmpI72Km17KPAcv1t954l0ei+Xg2PLXzYnhE1blnSwRXXfxlNmDBBTz31lJ555hkVFhaqsrJSlZWVOnz4sKS6YbwTJ07UtGnTtHjxYv3zn//U2LFj1apVK1111VVJOQAAyEQLFy7UxIkTNWXKFK1bt06DBw/WyJEjtWXLFuP2mzdv1gUXXKDBgwdr3bp1uv3223XjjTdq0aJFkW0OHTqk7t276+677478Om3Sq1cvbd++PfLasGGD68dnQ5wBgOaRrXFGItYAQKaKawTXnDlzJElDhw6NKp8/f77Gjh0rSbr11lt1+PBhjR8/Xnv27NGAAQO0ZMkSFRYWutJgAGhOLTVF8b777tO1116r6667TpI0a9Ysvfrqq5ozZ46mT5/eYPu5c+eqa9eumjVrliTp5JNP1po1azRz5kyNGjVKknT66afr9NNPlyTddttt1n37fL6YDybJRJwBkG1aaopitsYZiVgDIAu5kQUxDbIoxj1F8Ug8Ho8qKipUUVHR1DYBQMqoT9+eaB2SGqQMt63XEQgEtHbt2gYPB8OHD7emJ1+5cmVUOnNJOv/88zVv3jzV1tYqN7fxU1c+/PBDlZaWyu/3a8CAAZo2bZq6d+/e6M8ngjgDINu4EWfq65EaF2uyOc5IxBoA2cfj1L0SrSPVsXgDADSTLl26RKUQN/1CLkk7d+5UKBSKKz15ZWWlcftgMKidO3c2uo0DBgzQk08+qVdffVWPPvqoKisrNWjQIO3atavRdQAAWk5jYg1xBgCQiUi3AgAxuDlFcevWrSoq+nLB6yNlW4onPblte1N5LCNHjoz8/z59+mjgwIE6/vjj9cQTT2jSpEmNrgcA0DhuT1GMJ9YQZwAgS2TJIvN0cGWJeDMtxdp+X445e8n23FbG8jZtzOmU27dfbCw/9tifGMuPO26ysXzPnteN5du2jTGWFxb+l7F8S645RU2V5XhjnSMyW2UON7MoFhUVRT102HTo0EE5OTkNfkWPlZ68pKTEuL3P51P79u2b2HKpdevW6tOnjz780Jz5DfgqYs2XiDVoLLezKDYm1hBnms/xQz5Rbuvo7/emyo7GbQN7zNljbZnpcgss2RhjrJNjzeBnyZYXCJkfF21Z8Xx+S1Y8S/1BS7a82oB5v16fOf9djqU8FLL/nczzm89fTbX5++iRLROgOYteOGQ+thxLZkrb/K9w2HwMYUtWv/rpyo2VZ7lmkmS5w1xbiylsuT4ey7nIsWTjtN0v/nzzEVSHzTHXdh9J9oyStrbaMng6llty8KkfNCirPRjQ760tggn/ZQQAKSYvL0/9+/fX0qVLo8qXLl2qQYMGGT8zcODABtsvWbJE5eXlca2L8nU1NTXauHGjOnfu3OQ6AACphTgDAMhEjOACgBhaKovipEmTNGbMGJWXl2vgwIF65JFHtGXLFo0bN06SNHnyZG3btk1PPvmkJGncuHF68MEHNWnSJF1//fVauXKl5s2bp2effTZSZyAQ0Pvvvx/5/9u2bdP69evVpk0bnXDCCZKkW265RRdddJG6du2qHTt2aOrUqaqqqtI111yT0DkAAJi1VBZF4gwAZA+PXFhk3pWWJBcdXAAQk8c6DD+eOuI1evRo7dq1S3fddZe2b9+u3r1766WXXlK3bt0kSdu3b9eWLVsi25eVlemll17SzTffrIceekilpaV64IEHIqnbJenzzz9Xv379Iv+eOXOmZs6cqSFDhmj58uWSpM8++0xXXnmldu7cqaOPPlpnnnmmVq1aFdkvAMBtbsSZunriQZwBgCzieBKfWurS1NRkooMLAFLU+PHjNX78eON7jz/+eIOyIUOG6O2337bWd9xxxx0xNfqCBQviaiMAIH0RZwAAmYQOLgCIwXHCchz7gpONrQMAABM34kx9PQAAGJFFEdlsd4z/SOoRNmfaKA7WGMv3Bw4Yyw8d6mUs37v3AXObdi+zbP+meb/7BxjLq6v3GsuLw+YsGwWW440l1vlDeqGDC0geYs2XiDXZiw6uzJafU6vcnOhpPYF9fvPGlodHW+ZAx5Jdz2vJNCdJeXnmvzU1NebHwlCtJSOfpa1By/a2Ntmy4uVa2hmyZJQM26ZOxXggD9qyU1r2bZtKXHvYnGTBm2u5DpaFkGz1WLPxWdrvtWR1tLFdM8k+8TkUNL/j9VlOuG3xJ1sGQsuObRkLfZbMlF6vrf74yiWpoLUlI6Ml66YsGUt9RQFj+WUdGo6OPeQPuZdFMUs6uMiiCAAAAAAAgLTGCC4AiIERXACAZGIEFwAg2TyOC1kU02AEFx1cABADHVwAgGSigwsAkHRMUQQAAAAAAABSHyO4ACAGRnABAJKJEVwAgKTLkhFcdHBlCVumpV2W8liZmToEq43lfar3GMv/tOv/jOUff/w9Y3lBwfnG8m3bfmosP3iwr7F80yZzzonKymeN5d88UGks71x7yFj+95A5AwYyCx1cQOMRa75ErEFj0cGV2dZt6C5vQX5UWf4Oc9a6mg6WTHCWLHq2zIROjIfQw4fMGRxtt0+OJYOjTShkniDky7VkArRkJrRls7Nt74TM5QWt7X9Day3ZA4O1lkdkS5ty8szXzeM1n7uwJfuljS2LZshyzKGAuX6PJaOgEyOLoq+VJcOv7TqELfuwHbMlAaHXcu4CAfO1CVsyFtbWmnfQptD83xgHLd+PurrM58lnyVoZqDUfs+3ref8n5zYoCx6skbTB2qZ4ZMsaXExRBAAAAAAAQFpjBBcAxMAILgBAMjGCCwCQdI7HOvIurjpSHB1cABADHVwAgGSigwsAkHRZsgYXUxQBAAAAAACQ1uLq4Jo+fbpOP/10FRYWqmPHjrrkkku0adOmqG3Gjh0rj8cT9TrzzDNdbTQANBfHcSK/rjf9lQY/d6QI4gyAbONOnCHWxINYAyDb1C8yn+gr1cU1RXHFihWaMGGCTj/9dAWDQU2ZMkXDhw/X+++/r9atW0e2GzFihObPnx/5d15ennsthqtsGaw+DFsyZkjaacn0dMbBHcbyDZXvGMs/8OUby/ftG2QsLy4ebSyvqakyltsyWH2+7e/G8iv3bTGWH2+pf0WMc2Q7f7bzHSuTGFoWUxSbF3EmMxFrvkSswdcxRbH5NWesyd3nlbcmekyBt9a8reO3ZMsLxjfpxpdrzur2n9qMpV5LlsNg0Jw5zrYST44ls6NNIGCu32vJ+JfnN5+8QI05W16gxv64G7asJ+TLNf9trbVk8PPlWba37NuxZPzLybNkXbRcf48lu6Zs9eda6rfVoxjZLC0ZAj2WjI+2fcfLdg3yC8zZMg8fMG9/uNp8v8RaYcp2T9rOkW29qvAec6bGquWlDcpCAXO2xybJkimKcXVwvfLKK1H/nj9/vjp27Ki1a9fq7LPPjpT7/X6VlJS400IAQNYgzgAAko1YAwCZKaE1uPbt2ydJateuXVT58uXL1bFjR/Xs2VPXX3+9duww/9oqSTU1Naqqqop6AUCqcGfaCL+qN5UbcUYi1gBIXW7FGWJN0/FMAyDjuTE9MQ1GcDW5g8txHE2aNEnf/OY31bt370j5yJEj9fTTT+u1117Tb37zG61evVrf+ta3VFNTY6xn+vTpKi4ujry6dOnS1CYBgOt46Gg5bsUZiVgDIHXRwdWyeKYBkBUcl14pLq4pil91ww036N1339Vf//rXqPLRo79cu6J3794qLy9Xt27d9Oc//1mXXXZZg3omT56sSZMmRf5dVVVFQAAAuBZnJGINAMCMZxoAyBxN6uD66U9/qhdeeEFvvPGGjj322Jjbdu7cWd26ddOHH35ofN/v98vvNy+0BgAtjUXmW4abcUYi1gBIXSwy33J4pgGQNVhkviHHcfTTn/5Uixcv1vLly1VWVnbEz+zatUtbt25V586dm9xINL+PYmRtejlozubw40M7jeW1HvNM2KXBw8by13duMpb/K7/YWF4cNA8V/+aBSmP5lfu3GcuH7v/cWP5G4ICx/O8hc7YOiUxVmYQOruZFnMkuxJovEWuyFx1cza85Y03w2Gp5W0WXef9VYN7Ykv3OlqXNllHQlmlOkkIhywo1Pkt2RW9891U4bK4/VG1uk9eSwS/smMtDtqyOtkx2tnLZ1+rJs2RFtGWUDFvOqe3YHMuObcdgCW/WrH7hkPk+sp0JJ0aWTsstKU+e+X7xWLZ3LBkFLZdZuT5bVk9zW21ZNG2ZJkO15mvpsxyXJNVaPmPLcukELVk6D5i3D/sabh+2XYAmiKyjlWAdqS6uNbgmTJigp556Ss8884wKCwtVWVmpyspKHT5c9x+PBw4c0C233KKVK1fqk08+0fLly3XRRRepQ4cOuvTSS5NyAACAzEGcAQAkG7EGADJTXCO45syZI0kaOnRoVPn8+fM1duxY5eTkaMOGDXryySe1d+9ede7cWeecc44WLlyowsJC1xoNAM2FEVzNizgDINswgqv5EWsAIDPFPUUxloKCAr366qsJNQgAUgkdXM2LOAMg29DB1fyINQCyTgqvwfXJJ5/oV7/6lV577TVVVlaqtLRU3//+9zVlyhTl5eXFVVeTsygCAAAAAAAATfXBBx8oHA7r4Ycf1gknnKB//vOfuv7663Xw4EHNnDkzrrro4AKAGBjBBQBIJkZwAQCSLZUXmR8xYoRGjBgR+Xf37t21adMmzZkzhw4umMWbaenDGJmtZMlsZXO1pa6uloxRw6o+M5ZX5ZiHJxZY6u9ceyiu/doyWD1tqSfWObKdbzJepSPHhYeGNEg5AriAWHPk/RJr0JAbcaauHqSe4zrvkq+1P6ps845jjNt6ApZMc63M5basbraMdZKUX2DOzFp92Py3z5apL9Y+TKyZ5sK27IeWYkt7PJb0fbmWjIiSfarq4UN+Y7kto6RjyRxp36+53Jtjrt+fZy4PWq6/11ysHEumzHCMXouwLfuhJaNkqMaSCdRyDB6fudyWLdOba9k+YN4+x5IV0XouYmUttJwL2z1pO6vBQvO+j7/y4wZltQcDeu9Re5Pi5lKYqKqqivq33++X32/+3jTVvn371K5du7g/F9+3EQAAAAAAAFmpS5cuKi4ujrymT5/uav3/+te/9P/+3//TuHHj4v4sI7gAIAamKAIAkokpigCApHNxkfmtW7eqqKgoUmwbvVVRUaE777wzZpWrV69WeXl55N+ff/65RowYoSuuuELXXXdd3E2kgwsAYqCDCwCQTHRwAQCSzc01uIqKiqI6uGxuuOEGfe9734u5zXHHHRf5/59//rnOOeccDRw4UI888kiT2kgHFwAAAAAAAFzToUMHdejQoVHbbtu2Teecc4769++v+fPny+tt2mpadHABQAyM4AIAJBMjuAAASefiFEW3ff755xo6dKi6du2qmTNn6t///nfkvZKSkrjqooMryzUl05I1o5Ml45Vt+wGW7QdU7zWW9/KYe3Ftx2Db7zJL+d9D5qwytno+ipX9CxmDDi4gccSaLxFr8HV0cGW249rsUl6b6AyF//KXGrf11JqztOXkmrOu2bL3xcpwaM28aMke5/Ob/wbVHM617sMoYBmN4bdkJgyZ2+PNN7fHlqWxNmB/3LVlWLRl2LMkalRNjXnfXp8t46O5Htv1rDlsvmaWcGXN0hiqNl8zWxZASXIs59Wa5dJvOXeWfdjOdchyn9q+C7a5d7bvgi1bYqyMmLYsmrWHzOfVu99874WLzffdpR3XNSg7fCCoF60tio+bUxTdtmTJEn300Uf66KOPdOyxx0a9Z8t2akMWRQAAAAAAADS7sWPHynEc4ytejOACgBgYwQUASCZGcAEAki6Fpyi6iQ4uAIiBDi4AQDLRwQUASLos6eBiiiIAAAAAAADSGiO4ACAGRnABAJKJEVwAgGRL5UXm3UQHFwDEQAcXACCZ6OACACRdlkxRpIMLRm6mdN9lqcuW+vxlS0r3eNmOwdYe2/bxlgMAGodY0/RyAOnhQDBfubV5UWWO3/y9dnI8xnKPYym37NOXa/67J0m1NebHP2+O+ck1FLLsxfKg6801H1vIm2P5gKWigHklnXDQXO71mffr84XM9UsKh21n0La9udznN59vn6VNgZpcY7mt78CxtNOTY7mPas3n2nZtYg3LcWzXx1YcMl8fp9p8DE6+udyXZ75uTthy/b3mY/NYLrHXclzBGCE3aPnu2L6I4daWey9o/sDvtnyz4aYHaySttTcKDdDBBQAx1KWoTXQEVxr83AEAaBFuxJn6egAAMGIEFwCAKYoAgGRiiiIAINmyZQ0usigCAAAAAAAgrTGCCwBiYAQXACCZGMEFAEi6LJmiGNcIrjlz5qhv374qKipSUVGRBg4cqJdffjnyvuM4qqioUGlpqQoKCjR06FC99957rjcaAJpL/YNHoi80DnEGQLZxK84QaxqPWAMg29RPUUz0leriGsF17LHH6u6779YJJ5wgSXriiSd08cUXa926derVq5dmzJih++67T48//rh69uypqVOnatiwYdq0aZMKCwuTcgBofvFmdLJmhvK0zAxZt9oPwH3EGdQj1gBIluaMNf9473h5C/KjCy0Z3HKKas2VWLIoNulZ05LxzZZ5MWzJiuexZF20ZTmUJRujU2PJruiznCNLZsJgtfmx1pNvLK57z5J5LzfXnP3OnpHPki0xYG6TLR9EjuW+CFmyKNrOtVNryTSYb76/gtXmrI6SPfOiNWJZ3vAWWu4vW1ZMS4bIUNB8v8SbLdGWHdSxfNckyYkzo6gs585TZT7fX7xxTIOyUI07GZ+zSVz/1XfRRRfpggsuUM+ePdWzZ0/9+te/Vps2bbRq1So5jqNZs2ZpypQpuuyyy9S7d2898cQTOnTokJ555plktR8Akopf1ZsXcQZAtmEEV/Mj1gDIOo5LrxTX5J81Q6GQFixYoIMHD2rgwIHavHmzKisrNXz48Mg2fr9fQ4YM0VtvvWWtp6amRlVVVVEvAEgVPHS0HLfijESsAZC66OBqWTzTAMgKdHCZbdiwQW3atJHf79e4ceO0ePFinXLKKaqsrJQkderUKWr7Tp06Rd4zmT59uoqLiyOvLl26xNskAEAGcTvOSMQaAEA0nmkAIPPE3cF14oknav369Vq1apV+8pOf6JprrtH7778fed/ztQmwjuM0KPuqyZMna9++fZHX1q1b420SACQNv6o3P7fjjESsAZC6GMHVMnimAZBNPC69Ul1ci8xLUl5eXmRBxvLycq1evVr333+/fvazn0mSKisr1blz58j2O3bsaPALyFf5/X75/f54mwEAzcKNhwYeOuLjdpyRiDUAUpdbnVPEmvjwTAMgq7gxxTANpijG3cH1dY7jqKamRmVlZSopKdHSpUvVr18/SVIgENCKFSt0zz33JNxQpL50yQCVLu0EUIc4g69Kl7/h6dJOAHWSFWuO2pCjnLzozG97+pkzyuX4zNn7HEsWPVumuVpL9j5J8liyyoXj3Ictm2HNYXOGOE+B+ZgdS5ZGW9bFsKXcdlxNEbK0yZaRLxw2Z/azbV/QKmAsD9RYMkHaMgRaMlmGLOVOOP7lt20ZIm2jGW3ZLEOHLfek5dhs2RJ91gyXtmyJ5mMOh8z1xwrd3jzzvq2ZIC3fEcfS1mP/crBBWTBYrY/sTYJBXB1ct99+u0aOHKkuXbpo//79WrBggZYvX65XXnlFHo9HEydO1LRp09SjRw/16NFD06ZNU6tWrXTVVVclq/0AkFSM4GpexBkA2YYRXM2PWAMg23iculeidaS6uDq4vvjiC40ZM0bbt29XcXGx+vbtq1deeUXDhg2TJN166606fPiwxo8frz179mjAgAFasmSJCgsLk9J4AEg+x4WHhjSIBimCOAMg+7gRZ+rqQeMQawBkHaYoNjRv3ryY73s8HlVUVKiioiKRNgEAshRxBgCQbMQaAMhMCa/BBQCZjCmKAIBkYooiAKBZpMEIrETFv9IcAGSRlkzdPnv2bJWVlSk/P1/9+/fXm2++GXP7FStWqH///srPz1f37t01d+7cqPffe+89jRo1Sscdd5w8Ho9mzZrlyn4BAE3nVpxpSqwhzgBAdqhfgyvRV6pjBBdaDBmmALuFCxdq4sSJmj17ts466yw9/PDDGjlypN5//3117dq1wfabN2/WBRdcoOuvv15PPfWU/va3v2n8+PE6+uijNWrUKEnSoUOH1L17d11xxRW6+eabXdkvkOqINYAZcaZ5HPWvgHy+6DEFe8rNqeNyLRniqqvNmQmDlnLHktVNkvxtaozltiyKjmMuD8XYh7EeS/22J2aP3/y3O1xryVhoyXAXq50eryVToy0jo+Vc2DL42TJQBmvjO6fxZu+zsWU4zLVkdZTsmRfjbmu1+brl2LJr2u47W3ZNWyZLy7Xx5Zr3W3PAbyyva5S52HbMPkt5MGg+Bt++6oaFIfP3FXaM4AKAGFrqV/X77rtP1157ra677jqdfPLJmjVrlrp06aI5c+YYt587d666du2qWbNm6eSTT9Z1112nH/3oR5o5c2Zkm9NPP1333nuvvve978nvNwfwePcLAEhMS43gIs4AQBZxXHqlODq4ACAGNx86qqqqol41NeZfZQKBgNauXavhw4dHlQ8fPlxvvfWW8TMrV65ssP3555+vNWvWqLa2tlHH2pT9AgAS43YHV2NiDXEGALJLtkxRpIMLAJpJly5dVFxcHHlNnz7duN3OnTsVCoXUqVOnqPJOnTqpsrLS+JnKykrj9sFgUDt37mxU+5qyXwBAamlMrCHOAAAyEWtwAUAMbmZR3Lp1q4qKiiLltukb9Tye6Dn6juM0KDvS9qbyI4l3vwCApnM7i2I8sYY4AwBZwo0phmkwgosOLgCIwc0OrqKioqiHDpsOHTooJyenwa/ZO3bsaPCrd72SkhLj9j6fT+3bt29UO5uyXwBAYtzu4GpMrCHOAEB2cWOKYTpMUaSDCwBSTF5envr376+lS5fq0ksvjZQvXbpUF198sfEzAwcO1J/+9KeosiVLlqi8vFy5ueYsS27sFwCQfogzzcfJ8cjJ+droNEsmOMeWpc3yVBm2bO+xZQGUVFtjfvzL8Zk7WfPzzRn2DlsyOOblmzPHBSzby5Jd0ZdnznIXDJvrsQ0AtJ1TyX6eHOv1se3EkvGv1rwakCfHduHMxbb6HUv9/kLzGq+2DIHhkDkDoWQ/f7Zz5LNkAg17zPuwZoK07NeXa7lmcf5GEA6Z95uTb77v6nZiuQ6Wfdu+a06++QMfj27XoCxUXS392t4kNEQHFwDE4OYIrnhMmjRJY8aMUXl5uQYOHKhHHnlEW7Zs0bhx4yRJkydP1rZt2/Tkk09KksaNG6cHH3xQkyZN0vXXX6+VK1dq3rx5evbZZyN1BgIBvf/++5H/v23bNq1fv15t2rTRCSec0Kj9AgDc5fYIrsYizgBAFmGKIgCgpTq4Ro8erV27dumuu+7S9u3b1bt3b7300kvq1q2bJGn79u3asmVLZPuysjK99NJLuvnmm/XQQw+ptLRUDzzwgEaNGhXZ5vPPP1e/fv0i/545c6ZmzpypIUOGaPny5Y3aLwDAXS3VwUWcAYAskiUdXB7HiTVws/lVVVWpuLi4pZsBIAPs27evUWtemdT/LfrOd36n3NxWCbWjtvaQXnjhuoTaA3cRawC4IVXijESsSTX11/escyvk8+VHvbd5lHmqU6sOh4zltQHzmIRgwDK1zDaVTpInx9wRapuiWFAQ3xRFr2XaX9xTFPNrjeVB235zze0PB+3nwvaZ+KcoWndhZJ2iaNvesttQtfn6xztFMcdvnlYo2acohi3TI3MtU/xqD1mmllquge2c5hWY74tQ0HwuPHEuGhWO8d2Jd4qi7X5xDpi/z/6dDY8hVF2tj389xZVY03fsNOXk5R/5AzGEAtV69/HbUzrOMIILAGJoqRFcAIDs0FIjuAAA2YNF5gEAchzHhQ6uNIgGAIAW4Uacqa8HAACjLJmiSAcXAAAAACTBgc65ysmLnp6V06bauK1tKppt2pRjmaKmGFPgPJanP1v2u0Ct+QPhsHmKWsgyJdBWf8iSRc825cybZ64nxzL10uOxZOmTffpa0HJsjmU6pS0rpjVbpu36WLb3+G1p+sztrDmYZ97elhGxCZ0WtgyUQUvmQFm291rOha3PP96prrmWKY211eZ22qatSvZpmXHfF5brOfyCdQ3KAgdq9TFZFONCBxcAxMAURQBAMjFFEQCQbB7HkSfBkb6Jfr450MEFADHQwQUASCY6uAAASZclUxTtYzYBAAAAAACANMAILgCIgRFcAIBkYgQXACDZsiWLYlwjuObMmaO+ffuqqKhIRUVFGjhwoF5++eXI+2PHjpXH44l6nXnmma43GgCaS/2DR6IvNA5xBkC2cSvOEGsaj1gDIOs4Lr1SXFwjuI499ljdfffdOuGEEyRJTzzxhC6++GKtW7dOvXr1kiSNGDFC8+fPj3wmL8+SxQEAgK8hzgAAkq05Y83ekx1586OfCv35AeO2YVs2Nps8S+ZAS8Y6SXIsmd2CteashaGQeTxEa0smyMOH/OYdW4Z+2LLo2TIc5vjMx2xrv2PJQClJHq+5Ln8rc+a9gCXznmyJ/SxZ92wZ/2zltix9noKgeXtLZkpbBkpvjPvFluUyx5Jt0HYPW/dhuT62+yJUazlHcXa82LIl+nzmcyRJAcv19OVbMoTuMX8XPEXm7/8DpasblFXtD+tRa4tgElcH10UXXRT171//+teaM2eOVq1aFQkGfr9fJSUl7rUQAFoQUxSbF3EGQLZhimLzI9YAyDZMUTyCUCikBQsW6ODBgxo4cGCkfPny5erYsaN69uyp66+/Xjt27IhZT01NjaqqqqJeAJAqmDbSctyKMxKxBkDqYopiy+KZBkBWyJIpinF3cG3YsEFt2rSR3+/XuHHjtHjxYp1yyimSpJEjR+rpp5/Wa6+9pt/85jdavXq1vvWtb6mmpsZa3/Tp01VcXBx5denSpelHAwBIe27HGYlYAwCIxjMNAGQej+PEN2M1EAhoy5Yt2rt3rxYtWqTf/e53WrFiRSQgfNX27dvVrVs3LViwQJdddpmxvpqamqhgUVVVRUAA4Ip9+/apqKioSZ+tqqpScXGxhg27V7m5BQm1o7b2sJYu/Z+E2pNN3I4zErEGQHKkSpyRiDXxaq5nmm6/nipvfn7Utv6y/cY6bOtFBQLmVWVCNeZ1p2KtwWXjs6zP5NYaXLb1rpywuf7mWIPLm2M+5hzL+k/WNbhsS2rFuwZXwLK937LWWo7lnMa7BpfleKUYa3BZroNtDS7rPWm5PrbrH7KcU9s6ZXmW9dRs93XMNbgOmxdbs61HFu8aXP86d36Dsqr9YbXt+bErsab/6F8rJy//yB+IIRSo1tqFU1I6zsS1BpdUt8Bi/YKM5eXlWr16te6//349/PDDDbbt3LmzunXrpg8//NBan9/vl99vWYwQAFoYa3A1P7fjjESsAZC6WIOrZfBMAyCruDHFMA2mKMbdwfV1juNYh+vu2rVLW7duVefOnRPdDQAgSxFnAADJlqxYU9C9Sjmtous9sM88Ys+W2c2aRc8yKsY2okSSQgHzSCevZTRQrWXUiu0YbKOZcixPnbYRVrbyULV55E2u35xR0BMjMWWtZWSc12uuK262EVw+Sy+BJSumbWSXY0ns6bGMrrKfa3M9kuTLtY9oMu471gk3CAct97b5NpXXcu6csLm8tsZyjS2j1mJm3bR8xvbdCVpGodn2cN/u7g3Kqg8EJX1sbRMaiquD6/bbb9fIkSPVpUsX7d+/XwsWLNDy5cv1yiuv6MCBA6qoqNCoUaPUuXNnffLJJ7r99tvVoUMHXXrppclqPwAkmePCr+Jp8HNHiiDOAMg+bsSZunrQOMQaANkoHbIgJiquDq4vvvhCY8aM0fbt21VcXKy+ffvqlVde0bBhw3T48GFt2LBBTz75pPbu3avOnTvrnHPO0cKFC1VYWJis9gNAUjFFsXkRZwBkG6YoNj9iDYCs4zixh+s1to4UF1cH17x586zvFRQU6NVXX024QQCA7EWcAQAkG7EGADJTwmtwAUAmYwQXACCZGMEFAEg2j5P4FMV0mOJoWfkOACB9+eCR6AsAABO34gyxBgBg5bj0SrKamhqddtpp8ng8Wr9+fdyfZwQXAAAAACTBwM6fKK9NdLq7V/b2Mm7rhGwZ5SwZ34LmsQphS9ZFyZ5hLxi0pK2LU7zZ6WxL+tiy9wUtWSBtx+yE7eM5fLnmbIk+yzmS4svUWGO7DpZjdizH5mll2a8li6bXUu6xDb+JMSzHdi6CtfHdL7Y70t+q1lhuu56hkPl6eq3NMR9bnt+8X1v9kv282rKc5hRb9rHfnJn0sadGNNy2plrSa9Y2ZaJbb71VpaWleuedd5r0eTq4ACAGpigCAJKJKYoAgGTzhOteidaRTC+//LKWLFmiRYsW6eWXX25SHXRwAUAMdHABAJKJDi4AQNK5McXwP5+vqqqKKvb7/fL7/QlV/cUXX+j666/X888/r1atWjW5HtbgAgAAAAAAwBF16dJFxcXFkdf06dMTqs9xHI0dO1bjxo1TeXl5QnUxggsAYmAEFwAgmRjBBQBINjezKG7dulVFRUWRctvorYqKCt15550x61y9erXeeustVVVVafLkyYk1UHRwAUBMdHABAJKJDi4AQNI5jj2rQzx1SCoqKorq4LK54YYb9L3vfS/mNscdd5ymTp2qVatWNegoKy8v19VXX60nnnii0U2kgwsAAAAAkuDKdn9X68LoVWFeru1j3Naz15xdLdTGnEUvx5JdL2zJrihJObaseNWWx0Lb87AlLV4oYN53Tl58HbC2bIm2bIzhkCW7oiUzpWTPpBew7FuWfVsz71nOXU6uLTOhuR5btkRbeY7PnIHSlhGxptp830lSwHI9vZahQN4c875DlqyL1dXmkT9eSxbNHEt5vNem1pYF0lKPZL9fbFk0AzXm71Q4YP5A3t6G5zQUSHTRrJbVoUMHdejQ4YjbPfDAA5o6dWrk359//rnOP/98LVy4UAMGDIhrn3RwAUAMjOACACQTI7gAAMnm5hRFt3Xt2jXq323atJEkHX/88Tr22GPjqotF5gEAAAAAAJDWGMEFADG87TjyJDyCK72HFwMAkseNOCMRawAAMTiyTzmOp45mcNxxxzU5ptHBBQAx5DphFzq4mDYCADBzI85IxBoAgF0qT1F0E1MUAQAAAAAAkNYYwQUAMficsLwJ/ioe5ld1AICFG3FGItakqiJvjdp4o8cUePzmTHBhS1Y8W8ZCx5Ih0KmxZIiT5ORYst/lmdtkyxBny05ozfhnHfphyYpoyQRpm7XkWPbrtRyvJNUGzI/CtkyNtuyENmGP+RhClmPLKTDXbz3msLmdtZbsfbUBcz2xjsuWU9CWFdEm12/J+GnLihjnfi2nWl7bd8rCF6M9tvvCdn1sGRwdn/kDB4YcalAWPlQtzbM2KT6OY29sPHWkODq4ACCGXDq4AABJ5EackYg1AAA7pigCAAAAAAAAaYARXAAQAyO4AADJxAguAEDSpVEWxUTQwQUAMdDBBQBIJjq4AADJxhTFRpg+fbo8Ho8mTpwYKXMcRxUVFSotLVVBQYGGDh2q9957L9F2AgCyEHEGAJBMxBkAyBxN7uBavXq1HnnkEfXt2zeqfMaMGbrvvvv04IMPavXq1SopKdGwYcO0f//+hBsLAM3N54SVm+DLx6/qTUKcAZAN3IgzxJqmIc4AyBphx51XimvSFMUDBw7o6quv1qOPPqqpU6dGyh3H0axZszRlyhRddtllkqQnnnhCnTp10jPPPKMf//jH7rQaAJqJzwkrJ8GHBg8PHXEjzgDIFm7EGYlYE6/mijPTPh+p3NZ5UWXOIcsjWE58D4+Oz2OupnWt/TMh82fCtTnGcm9uKK425eSa78NQrXlchROyjLeIcy5U+LD5nHry7O13csz79lmOORQ0n6NQ0FxPfquAsfzwfr+x3OMznzsnbLnOlnZ6veZzF7ac63DIfFySFKo2v5dTEDSW2+6v2pr4uh08lu+C9Vz44rtPbcec4zcflyQFLdffibPPx1to/n5uOPt3Dcqq9odVEl/1dlmyBleTRnBNmDBBF154oc4777yo8s2bN6uyslLDhw+PlPn9fg0ZMkRvvfVWYi0FAGQN4gwAIJmIMwCQeeIewbVgwQK9/fbbWr16dYP3KisrJUmdOnWKKu/UqZM+/fRTY301NTWqqamJ/LuqqireJgFA0uS68Mu6G4sHZxO344xErAGQutyIMxKxJh7EGQDZxiMXFpl3pSXJFVcH19atW3XTTTdpyZIlys/Pt27n8UQfuuM4DcrqTZ8+XXfeeWc8zQCAZuOTk/C6Jp50GM+bIpIRZyRiDYDU5UackYg1jUWcAZCVHCf++ZSmOlJcXFMU165dqx07dqh///7y+Xzy+XxasWKFHnjgAfl8vsgvHfW/fNTbsWNHg19B6k2ePFn79u2LvLZu3drEQwEApLtkxBmJWAMAqEOcAYDMFdcIrnPPPVcbNmyIKvvhD3+ok046ST/72c/UvXt3lZSUaOnSperXr58kKRAIaMWKFbrnnnuMdfr9fvn95oX2AKCluZGZioV/Gy8ZcUYi1gBIXW5lQCTWNA5xBkA28jguTFFM/QFc8XVwFRYWqnfv3lFlrVu3Vvv27SPlEydO1LRp09SjRw/16NFD06ZNU6tWrXTVVVe512oAaCZ0cDUv4gyAbEMHV/Nq7jjz+Zzu8uVGT4XM7W+eRBMsrTGW51oyu9my+smxT6X0WObv5OSb9+H1mu+r2kN5xvKgJYuevT2WbHmHLMeWZ7nPLfV4ffYncttsK9t59eebsyJWh83nojZgftTOsRyDx3KunUCusdx2qm35BG0ZCD1N6LWwXWXbrWfL7GgTtrTVZ8mKabuPbMeWm2e+322ZEmO1ybq9JXNoboE5i2Kt0/DYat38u54lWRTjXmT+SG699VYdPnxY48eP1549ezRgwAAtWbJEhYWFbu8KAJCFiDMAgGQizgBAekq4g2v58uVR//Z4PKqoqFBFRUWiVQNAi2MEV8sjzgDIZIzgannEGQCZzuM48iS4SHyin28Oro/gAoBM4nPCyk30oYGHDgCAhStxRiLWAADswv95JVpHiosriyIAAAAAAACQahjBBQAx5DKCCwCQRK7EGYlYAwCwYooiAIAOLgBAUtHBldnaLF4jnyc6C96ekwYZt621ZF2rdcyPbLYMgTk+Wx49ye83Z3ALWDL+BQ6bM/hZBczHkLPfnJ0ubKnelnQvnGN5w5LgzpbJTpJ8+eZzEQ6Z2+rLMX/HigoPG8uDYcv1rDXXX3PAbyz3WPZrvc6WVIbBoPkah2Nk3bSd1+Bec+ZIjyW1Y7DA3FZfK3M2QxtfrrmeUMh8rm3ZG3Ms5zRQY7/fbVkuw5brrKAlW+quAmN5n5d/2rDuw9WS7rC2KS5ZkkWRKYoAAAAAAABIa4zgAoAYGMEFAEgmRnABAJLOcepeidaR4hjBBQAx1Ge3SuTV1PTvs2fPVllZmfLz89W/f3+9+eabMbdfsWKF+vfvr/z8fHXv3l1z585tsM2iRYt0yimnyO/365RTTtHixYuj3q+oqJDH44l6lZSUNKn9AIAjcyPONDXWEGcAIDt4HHdeqY4OLgBIQQsXLtTEiRM1ZcoUrVu3ToMHD9bIkSO1ZcsW4/abN2/WBRdcoMGDB2vdunW6/fbbdeONN2rRokWRbVauXKnRo0drzJgxeueddzRmzBh997vf1d///veounr16qXt27dHXhs2bEjqsQIAmh9xBgCQaZiiCAAx5DpOwlNHnCYM573vvvt07bXX6rrrrpMkzZo1S6+++qrmzJmj6dOnN9h+7ty56tq1q2bNmiVJOvnkk7VmzRrNnDlTo0aNitQxbNgwTZ48WZI0efJkrVixQrNmzdKzzz4bqcvn8/FrOgA0EzfijBR/rCHOAEAWyZIpinRwAUAMbqyN4sT5+UAgoLVr1+q2226LKh8+fLjeeust42dWrlyp4cOHR5Wdf/75mjdvnmpra5Wbm6uVK1fq5ptvbrBN/cNKvQ8//FClpaXy+/0aMGCApk2bpu7du8d1DACAxnFrDa54Yg1xpvnsvuYM5eTlR5UFW5sfEj0HLI9mlsyBIUtmupBjztInScGAJZuhpdy7z9wmJ99yv+Vaji1ozq6Xd9BcHiow1+N4zROQbO3JybNnlCxsXW0sz7Vk2Nuxs8hc0X5L5r3W5gyBR7U7YCy3Zqw8YC6vPWy+Nh5LZkKnxnzuPNX2+0VHBcx1mRM+yltg3rctm2XwkOWet2WCtGSO7HiU+ZwerjXXv3uH+Vr6LO2XpGPa7zOWb9t5lLE8fNh8zLn7LRkfaxpeh1CN/f6Nlydc90q0jlTHFEUAaCZVVVVRr5qaGuN2O3fuVCgUUqdOnaLKO3XqpMrKSuNnKisrjdsHg0Ht3Lkz5jZfrXPAgAF68skn9eqrr+rRRx9VZWWlBg0apF27dsV9vACA5teYWEOcAQBkIjq4ACAGNxeZ79Kli4qLiyMv0xSQr/J4on+9chynQdmRtv96+ZHqHDlypEaNGqU+ffrovPPO05///GdJ0hNPPBGzrQCApnF7kfl4Yg1xBgCyRP0UxURfKY4pigAQgxtTR8L/+fzWrVtVVPTlkGi/3zy+u0OHDsrJyWnwK/qOHTsa/DJer6SkxLi9z+dT+/btY25jq1OSWrdurT59+ujDDz+0bgMAaDq3pijGE2uIMwCQZZz/vBKtI8UxggsAmklRUVHUy9bBlZeXp/79+2vp0qVR5UuXLtWgQYOMnxk4cGCD7ZcsWaLy8nLl5ubG3MZWpyTV1NRo48aN6ty58xGPDwDQ8hoTa4gzAIBMxAguAIjBzRFc8Zg0aZLGjBmj8vJyDRw4UI888oi2bNmicePGSarLTLVt2zY9+eSTkqRx48bpwQcf1KRJk3T99ddr5cqVmjdvXlTWqptuuklnn3227rnnHl188cX64x//qGXLlumvf/1rZJtbbrlFF110kbp27aodO3Zo6tSpqqqq0jXXXJPQOQAAmLk9gquxiDMAkD08jiNPglMME/18c6CDCwBiaKkOrtGjR2vXrl266667tH37dvXu3VsvvfSSunXrJknavn27tmzZEtm+rKxML730km6++WY99NBDKi0t1QMPPBBJ3S5JgwYN0oIFC/Tzn/9cv/jFL3T88cdr4cKFGjBgQGSbzz77TFdeeaV27typo48+WmeeeaZWrVoV2S8AwF0t1cFFnGkek276vVoVRmdHu/P9C43b7v+ijbmSkHldtIJP8ozlhZ/aH0Idjzkjn2OZ11Pd3rzv9sPNyQh+1PWvxvK3Dx5nLF/26YnGcttDasCS7TEUNJd3tmS+k6Qcr/k78/nuYmN56R/N567w5Q3G8qoL+xjL8/7LnL0xEDQfdfVO83Vue+Ie8/aWzIHOe0cZy8Pm6iVJnXvtNJYfDJg/FLZkP7Sd6117zfd87T7zLIdwyHydi/zmc7p9p3l6dPtV5mtZdbwlk6Wkob3+YSx//lBfY/nhva2M5b7eVcbyyb1eaVjHgaB+fLe1SfFxYw0tOrgAAE01fvx4jR8/3vje448/3qBsyJAhevvtt2PWefnll+vyyy+3vr9gwYK42ggASF/EGQBAJqGDCwBi8Lnwy3rIhV/mAQCZyY04IxFrAAAxOJISDROpP4CLDi4AiMWNqSM8dAAAbNyaokisAQDYZMsaXGRRBAAAAAAAQFpLuRFcThr0CgJID278PWEEV2Yi1gBwQ6rEGYlYk2rq743DB0IN3gsdqjF+JnzY8mhmWWQ+VGPePhSItci8pdwy7CFUY/5A8KD5GA4fCBrLAwdrzfVbzoVNOGBuaNiyyLytnZLkWBY+Dx8yL1gerLWcCydg2d5cj9fSptAh8wLn4Wpzue3chWob3nOS5NSY2xOO8WfMdv5s91hYlhvMYzvX5ns4fNhcvyfHfB/Z2mm7liHzJVPYvLkkqeZAfPdwqNpcmceyvem7U//3w5X/bnXkwiLziTcj2VKug2v//v0t3QQAGWL//v0qLjZnwmmsXDmJd3ClQzTIMsQaAG5IlTgjEWtSTX2c+cnZ/zS8+07zNiYZHjAXr7R+YE2SGhLbliNv0mgfx/uBxXGWx+lTd6qJ6aNm2Icb4j0XTbkv7rnD9s7LTaitoR/HeM+NWEMWxRZSWlqqrVu3qrCwUB6PR1VVVerSpYu2bt2qoqKilm5e0mXb8UocM8fsPsdxtH//fpWWliZ1P0hfX401+/fv5/uY4bLteCWOmTiDlkac4W9Qpsu245Wa/5iJNfFLuQ4ur9erY489tkF5UVFR1nxxpOw7XoljzhbNdcwJ/8rxH25ktwoybSTlfDXWeDx1w+n5Pma+bDteiWNOplSKMxKxJtUQZ+pwzJkv245Xat5jdivWKCzZZpDGVUeKS7kOLgBIJW6sjcJDBwDAxq01uIg1AAAbsigCAAAAAAAAaSDlR3D5/X7dcccd8vv9Ld2UZpFtxytxzNkiXY+ZEVyZL13vzURk2zFn2/FKHHM6YQRX5kvXezMRHHPmy7bjldL8mLNkkXmPQ650AGigqqpKxcXFerTrN9XKm9hvAYfCQV2/5a/at29f1q1RAAAwczPOSMQaAEBD9bHm3FNukS8nsY65YKhGf3l/ZkrHGaYoAgAAAAAAIK2l/BRFAGhJbkwdcWPqCQAgM7k1RZFYAwCwypIpinRwAUAMdHABAJKJDi4AQNKFJXlcqCPFMUURAAAAAAAAaS2lO7hmz56tsrIy5efnq3///nrzzTdbukmueeONN3TRRReptLRUHo9Hzz//fNT7juOooqJCpaWlKigo0NChQ/Xee++1TGNdMH36dJ1++ukqLCxUx44ddckll2jTpk1R22TaMc+ZM0d9+/ZVUVGRioqKNHDgQL388suR9zPteL9u+vTp8ng8mjhxYqQsHY+5/pf1RF9ITcSZ9Po+xkKcyb44I2VGrHErzhBrUhexJn2+j0dCrMm+WJMJcUaSPI7jyivVpWwH18KFCzVx4kRNmTJF69at0+DBgzVy5Eht2bKlpZvmioMHD+rUU0/Vgw8+aHx/xowZuu+++/Tggw9q9erVKikp0bBhw7R///5mbqk7VqxYoQkTJmjVqlVaunSpgsGghg8froMHD0a2ybRjPvbYY3X33XdrzZo1WrNmjb71rW/p4osvjvzxy7Tj/arVq1frkUceUd++faPK0/GYfS48cPh46EhJxJn0+z7GQpzJrjgjZU6scSPOEGtSF7Emvb6PR0Ksya5YkylxRtKXa3Al+kp1Too644wznHHjxkWVnXTSSc5tt93WQi1KHknO4sWLI/8Oh8NOSUmJc/fdd0fKqqurneLiYmfu3Lkt0EL37dixw5HkrFixwnGc7Dhmx3Gctm3bOr/73e8y+nj379/v9OjRw1m6dKkzZMgQ56abbnIcJ/2u8b59+xxJznOl5c6rx56Z0Ou50nJHkrNv376WPix8BXEmfb6PTUGcyezjzYRY42acIdakLmJNenwfm4pYk7nHmwlxxnG+jDXn9bjZGXHSbQm9zutxc1LjzIsvvuicccYZTn5+vtO+fXvn0ksvjbuOlBzBFQgEtHbtWg0fPjyqfPjw4XrrrbdaqFXNZ/PmzaqsrIw6fr/fryFDhmTM8e/bt0+S1K5dO0mZf8yhUEgLFizQwYMHNXDgwIw+3gkTJujCCy/UeeedF1Wersec6zgu/LKeBr92ZBniTHp+H+NBnMns482kWONOnCHWpCJiTfp9H+NFrMnc482kOCNJCjvuvJJk0aJFGjNmjH74wx/qnXfe0d/+9jddddVVcdeTklkUd+7cqVAopE6dOkWVd+rUSZWVlS3UquZTf4ym4//0009bokmuchxHkyZN0je/+U317t1bUuYe84YNGzRw4EBVV1erTZs2Wrx4sU455ZTIH79MO94FCxbo7bff1urVqxu8l67XuO6hIbGUI6yLknqIM+n5fWws4kzmxhkp82KNG3Gmvh6kFmJN+n0f40GsydxYk2lxRpI7UwyT9ENKMBjUTTfdpHvvvVfXXnttpPzEE0+Mu66U7OCq5/FEB3vHcRqUZbJMPf4bbrhB7777rv761782eC/TjvnEE0/U+vXrtXfvXi1atEjXXHONVqxYEXk/k45369atuummm7RkyRLl5+dbt8ukY0b6y/b7MVOPnziTmXFGItYgPWX7/Zipx0+sycxYQ5w5sqqqqqh/+/1++f3+Jtf39ttva9u2bfJ6verXr58qKyt12mmnaebMmerVq1dcdaXkFMUOHTooJyenwS8bO3bsaNBTmolKSkokKSOP/6c//aleeOEFvf766zr22GMj5Zl6zHl5eTrhhBNUXl6u6dOn69RTT9X999+fkce7du1a7dixQ/3795fP55PP59OKFSv0wAMPyOfzRY4r3Y6ZzFaZiTiTeX+D6hFnMjfOSJkZa8iimLmINZn5d0gi1mRyrMnEOFPHjQXm60ZwdenSRcXFxZHX9OnTE2rZxx9/LEmqqKjQz3/+c7344otq27athgwZot27d8dVV0p2cOXl5al///5aunRpVPnSpUs1aNCgFmpV8ykrK1NJSUnU8QcCAa1YsSJtj99xHN1www167rnn9Nprr6msrCzq/Uw8ZhPHcVRTU5ORx3vuuedqw4YNWr9+feRVXl6uq6++WuvXr1f37t3T8pjJopiZiDOZ9zeIOFMnk+OMlJmxhiyKmYtYk3l/h4g1dTI51mRinJHkahbFrVu3at++fZHX5MmTjbusqKiQx+OJ+VqzZo3C4br4NWXKFI0aNUr9+/fX/Pnz5fF49Ic//CGuw0zZKYqTJk3SmDFjVF5eroEDB+qRRx7Rli1bNG7cuJZumisOHDigjz76KPLvzZs3a/369WrXrp26du2qiRMnatq0aerRo4d69OihadOmqVWrVk1aaC0VTJgwQc8884z++Mc/qrCwMNLjXVxcrIKCAnk8now75ttvv10jR45Uly5dtH//fi1YsEDLly/XK6+8kpHHW1hYGFl/oF7r1q3Vvn37SHmmHTPSG3Ems76PxJnMjzMSsQbph1iTWd9HYk3mxxrizJEVFRWpqKjoiNvdcMMN+t73vhdzm+OOO0779++XJJ1yyimRcr/fr+7du2vLli1xtS1lO7hGjx6tXbt26a677tL27dvVu3dvvfTSS+rWrVtLN80Va9as0TnnnBP596RJkyRJ11xzjR5//HHdeuutOnz4sMaPH689e/ZowIABWrJkiQoLC1uqyQmZM2eOJGno0KFR5fPnz9fYsWMlKeOO+YsvvtCYMWO0fft2FRcXq2/fvnrllVc0bNgwSZl3vI2RjsfMIvOZiziTft/HWIgzxJl66XbcLDKf2Yg16fV9PBJiDbFGStNjDn85xTCxOhqvQ4cO6tChwxG369+/v/x+vzZt2qRvfvObkqTa2lp98skncf+t9DgOOYUB4OuqqqpUXFys1R1OVhtvTkJ1HQiHdPrOjdq3b1+jfu0AAGQ+N+OMRKwBADRUH2vO6zpePm/TF4KXpGC4Rsu2zE5KnJk4caL+93//V4899pi6deume++9V3/605/0wQcfqG3bto2uJ2VHcAEAAAAAACCz3XvvvfL5fBozZowOHz6sAQMG6LXXXourc0uigwsAYvK5MHWEhX8BADZuxJn6egAAMPrKIvEJ1ZEkubm5mjlzpmbOnJlQPXRwAUAMrMEFAEgm1uACACRdC6zB1RK8Ld0AAAAAAAAAIBGM4AKAGBjBBQBIJkZwAQCSLsWnKLqFDi4AiCFXTsIPDbmJDgcGAGQsN+JMfT0AABg5cqGDy5WWJBVTFAEAAAAAAJDWGMEFADH4nLByXagDAAATN+JMfT0AABgxRREAkOvCgwfrogAAbNyIM/X1AABgFA5LSjBOhFM/zjBFEQAAAAAAAGmNEVwAEAMjuAAAycQILgBA0jFFEQBABxcAIJno4AIAJF2WdHAxRREAAAAAAABpjRFcABDDHiesUIJ1VPGrOgDAwo04IxFrAAAxhB1JCY7ACqf+CC46uAAght1OWLUJ1rGfhw4AgIUbcUYi1gAA7BwnLCfBOJHo55sDUxQBAAAAAACQ1hjBBQAx7HHhl/UDafBrBwCgZbgRZyRiDQAgBsdJfIphGiwyTwcXAMSwxwkrkGAdB3noAABYuBFnJGINACAGx4U1uNKgg4spigAAAAAAAEhrjOACgBj2OI5qlNiv4ofS4NcOAEDLcCPOSMQaAEAM4bDkSTDWpMFIYTq4ACCG3U5Yh+VJqI7DPHQAACzciDMSsQYAEANTFAEAAAAAAIDUxwguAIhhjwu/rFenwa8dAICW4UackYg1AAA7JxyWk+AURYcpigCQ3vY4YfkTfPCo4aEDAGDhRpyRiDUAgBiYoggAAAAAAACkPkZwAUAMe5ywchP8Zb02DX7tAAC0DDfijESsAQDEEHYkT+aP4KKDCwBi2E0HFwAgidyIMxKxBgAQg+NISnANrTSIM0xRBAAAAAAAQFpjBBcAxLDHCcuX4C/rwTT4tQMA0DLciDMSsQYAYOeEHTkJTlF00iDOMIILAGLY44S1O8HXniam1J09e7bKysqUn5+v/v37680334y5/YoVK9S/f3/l5+ere/fumjt3boNtFi1apFNOOUV+v1+nnHKKFi9enPB+AQBN50acaWqsIc4AQJZwwu68UhwdXACQghYuXKiJEydqypQpWrdunQYPHqyRI0dqy5Ytxu03b96sCy64QIMHD9a6det0++2368Ybb9SiRYsi26xcuVKjR4/WmDFj9M4772jMmDH67ne/q7///e9N3i8AID0RZwAAmcbjpMM4MwBoZlVVVSouLlZbeeTxJDZ1xHEc7ZGjffv2qaioqFGfGTBggL7xjW9ozpw5kbKTTz5Zl1xyiaZPn95g+5/97Gd64YUXtHHjxkjZuHHj9M4772jlypWSpNGjR6uqqkovv/xyZJsRI0aobdu2evbZZ5u0XwBA07gZZ6T4Yw1xBgAyX32sGeq5VD5PbkJ1BZ1aLXcWx/VM09wYwQUAMeyRk/i0EcX3O0IgENDatWs1fPjwqPLhw4frrbfeMn5m5cqVDbY///zztWbNGtXW1sbcpr7OpuwXAJAYN+LMV2NNVVVV1KumpqbBPokzAJBlmKIIAHBTYx46JGnnzp0KhULq1KlTVHmnTp1UWVlp/ExlZaVx+2AwqJ07d8bcpr7OpuwXAJBaunTpouLi4sjLNCqKOAMA2SWoWgWdBF+qbenDOCKyKAKAQV5enkpKSlz7D+42bdqoS5cuUWV33HGHKioqrJ/5+pQVx3FiTmMxbf/18sbUGe9+AQDxczvOSFJJSYneeecd5efnR8r8fr91e+IMAGS2+ljz18qXXKmvpKREeXl5rtSVDHRwAYBBfn6+Nm/erEAg4Ep9pv94tz10dOjQQTk5OQ0eenbs2NHgV+96poekHTt2yOfzqX379jG3qa+zKfsFADSN23FGqnuQ+Wrnlg1xBgCyg9uxprFxpqXQwQUAFvn5+S3yBzwvL0/9+/fX0qVLdemll0bKly5dqosvvtj4mYEDB+pPf/pTVNmSJUtUXl6u3NzcyDZLly7VzTffHLXNoEGDmrxfAEDTEWeOvF8AQGJaKta0CAcAkHIWLFjg5ObmOvPmzXPef/99Z+LEiU7r1q2dTz75xHEcx7ntttucMWPGRLb/+OOPnVatWjk333yz8/777zvz5s1zcnNznf/93/+NbPO3v/3NycnJce6++25n48aNzt133+34fD5n1apVjd4vACAzEGcAAJmGDi4ASFEPPfSQ061bNycvL8/5xje+4axYsSLy3jXXXOMMGTIkavvly5c7/fr1c/Ly8pzjjjvOmTNnToM6//CHPzgnnniik5ub65x00knOokWL4tovACBzEGcAAJnE4zhOfPnrAQAAAAAAgBTibekGAAAAAAAAAImggwsAAAAAAABpjQ4uAAAAAAAApDU6uAAAAAAAAJDW6OACAAAAAABAWqODCwAAAAAAAGmNDi4AAAAAAACkNTq4AAAAAAAAkNbo4AIAAAAAAEBao4MLAAAAAAAAaY0OLgAAAAAAAKQ1OrgAAP9/e3BAAgAAACDo/+t2BCoAAMBalwY3Q16uwTIAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -74,7 +95,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "86cfd143", "metadata": {}, "outputs": [ @@ -84,18 +105,20 @@ "Text(0.5, 0.98, '1p')" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -115,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "da2545fa", "metadata": {}, "outputs": [ @@ -125,18 +148,20 @@ "Text(0.5, 0.98, '2p')" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABM4AAAHPCAYAAACr7ZZXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAA9hAAAPYQGoP6dpAAClAklEQVR4nOzdeXxU1f3/8fckk0z2AAlk0bApuAAqgrJYFKuguFZRcSnVVrEUrUXqrxWtGi2FrxYVrYLLFwUKCt/vl1rbigtUQVvByuaCSNGCLCYggez7zPz+SDN1yDlDJnOHBOb1fDzuQ/OZO+eee2eSD3PmnPtx+f1+vwAAAAAAAAAEiWvvDgAAAAAAAAAdEQNnAAAAAAAAgAEDZwAAAAAAAIABA2cAAAAAAACAAQNnAAAAAAAAgAEDZwAAAAAAAIABA2cAAAAAAACAAQNnAAAAAAAAgAEDZwAAAAAAAIABA2cAAABhePvtt/WjH/1IJ554olJTU3XMMcfo8ssv17p169q7awAAAHCYy+/3+9u7EwAAAEeKq6++WiUlJbr66qt18skn65tvvtGjjz6qtWvX6s0339R3v/vd9u4iAAAAHMLAGQAAQBj27t2rbt26BcUqKyt1/PHHq3///lqxYkU79QwAAABOY6kmAABAGA4eNJOktLQ0nXzyydq5c2cg1rNnT11yySV65ZVXdMoppygpKUm9e/fWk08+eTi7CwAAgAgwcAYAABChsrIyrV+/Xv369QuKb9y4UZMnT9add96pV155RcOHD9fPfvYzzZw5s516CgAAgHCwVBMAACBC3//+97VkyRKtWbNGgwYNktQ042zHjh3asGGDTj311MC+o0eP1gcffKCioiKlpKS0V5cBAADQCsw4AwAAiMB9992nRYsW6fHHHw8MmjXr169f0KCZJF1//fUqLy/X+vXrD2c3AQAA0AYMnAEAALTRgw8+qGnTpuk3v/mNbr/99haP5+bmWmMlJSVR7x8AAAAiw8AZAABAGzz44IMqLCxUYWGh7rnnHuM+xcXF1lhWVlZU+wcAAIDIMXAGAAAQpl//+tcqLCzUr371Kz3wwAPW/TZt2qSPPvooKPbSSy8pPT1dp59+erS7CQAAgAi527sDAAAAR5JHH31U999/vy688EJdfPHFWrNmTdDjQ4cODfx/fn6+LrvsMhUWFiovL08LFy7U8uXL9fDDD1MYAAAA4AhAVU0AAIAwjBw5UqtWrbI+3vxPq549e6p///764Q9/qAceeEBbt25Vfn6+7rjjDt15552Hq7sAAACIAANnAAAAUdA8cPaXv/ylvbsCAACANuIeZwAAAAAAAIABA2cAAAAAAACAAUs1AQAAAAAAAANmnAEAAAAAAAAGDJwBAAAAAAAABgycAQAAAAAAAAYMnAEAAAAAAAAGDJwBAAAAAAAABgycAQAAAAAAAAYMnAEAAAAAAAAGDJwBAAAAAAAABgycAQAAAAAAAAYMnAEAAAAAAAAGDJwBAAAAAAAABgycAQAAAAAAAAYMnAEAAAAAAAAGDJwBAAAAAAAABgycAQAAAAAAAAYMnAEAAAAAAAAGDJwBAAAAAAAABgycAQAAAAAAAAYMnAEAAAAAAAAGDJwBAAAAAAAABgycAQAAAAAAdDDvvvuuLr30UuXn58vlcumPf/xjVI9XWFgol8sVtOXm5kb1mEcCBs4AAAAAAAA6mKqqKp166ql66qmnDtsx+/Xrp6KiosD2ySefHLZjd1Tu9u4AAAAAAAAAgo0ZM0ZjxoyxPl5fX69f/epXWrRokUpLS9W/f389/PDDGjlyZJuP6Xa7mWV2EGacAQAAAAAAHGF++MMf6u9//7sWL16sjz/+WFdffbUuvPBCbd26tc1tbt26Vfn5+erVq5euvfZa/etf/3Kwx0cml9/v97d3JwAAAAAAAGDmcrn0yiuv6Hvf+54k6csvv1SfPn20a9cu5efnB/Y7//zzdeaZZ2r69OlhH+P1119XdXW1+vbtqz179mjatGn6/PPPtWnTJmVlZTl1KkccZpwBAAAAAAAcQdavXy+/36++ffsqLS0tsK1atUpffvmlJGn79u0tbvZ/8Hb77bcH2hwzZozGjh2rAQMG6Pzzz9drr70mSZo/f367nGNHwT3OAAAAAAAAjiA+n0/x8fFat26d4uPjgx5LS0uTJB1zzDHavHlzyHY6d+5sfSw1NVUDBgyIaOnn0YCBMwAAAAAAgCPIwIED5fV6tXfvXo0YMcK4T0JCgk488cQ2H6Ourk6bN2+2th8rGDgDAAAAAADoYCorK/XFF18Eft62bZs2btyoLl26qG/fvrrhhhv0gx/8QI8++qgGDhyoffv26e2339aAAQN00UUXhX28u+66S5deeqm6d++uvXv3atq0aSovL9eNN97o5GkdcSgOAAAAAAAA0MGsXLlS5557bov4jTfeqHnz5qmhoUHTpk3TggULtHv3bmVlZWnYsGF68MEHNWDAgLCPd+211+rdd9/Vvn371LVrVw0dOlS//vWvdfLJJztxOkcsBs4AAAAAAAAAA6pqAgAAAAAAAAYMnAEAAAAAAAAGFAcAAIva2lrV19c70lZiYqKSkpIcaQsAcHRwMs9I5BoAQEt8pokcA2cAYFBbW6tevXqpuLjYkfZyc3O1bdu2mEw0AICWnM4zErkGABCstrZWvXqkqXiv15H22pJnZs+erd/+9rcqKipSv379NGvWLI0YMcK4r60YwubNm3XiiScGfl66dKnuu+8+ffnllzruuOP0m9/8RldccUX4J9RKDJwBgEF9fb2Ki4u1Y8c2ZWRkRNRWeXm5unfvpfr6ej7MAAAkOZtnJHINAKCl+vp6Fe/1atu6HspIj+xOXeUVPvUa9FVYeWbJkiWaPHmyZs+erbPOOkvPPvusxowZo88++0zdu3e3Pm/Lli1BubFr166B/1+9erXGjRunX//617riiiv0yiuv6JprrtHf/vY3DRkypO0nGAJVNQHAoLy8XJmZmSotLXFk4KxTpyyVlZU58uEIAHDkczLPNLdHrgEAfFtzrin5Zy9HBs6y+m4LK88MGTJEp59+uubMmROInXTSSfre976nGTNmtNi/ecbZgQMH1KlTJ2Ob48aNU3l5uV5//fVA7MILL1Tnzp318ssvh3dSrURxAAAIwe9vdGQDAMDEqTxDrgEA2Hj9Pkc2qWkw7ttbXV2d8Zj19fVat26dRo8eHRQfPXq03n///ZD9HThwoPLy8nTeeefpnXfeCXps9erVLdq84IILDtlmJBg4A4AQ/H6vIxsAACZO5RlyDQDAxie/I5skFRQUKDMzM7CZZo5J0r59++T1epWTkxMUz8nJsd7fMy8vT88995yWLl2qP/zhDzrhhBN03nnn6d133w3sU1xcHFabTuAeZwAAAAAAADiknTt3Bi3V9Hg8Ifd3uVxBP/v9/haxZieccIJOOOGEwM/Dhg3Tzp07NXPmTJ199tltatMJDJwBQAhOLH9h+QwAwMapZZbkGgCAjU8++RxoQ5IyMjJadY+z7OxsxcfHt5gJtnfv3hYzxkIZOnSoFi5cGPg5Nzc34jbDxVJNAAihaflLpPedYfkMAMDMmTxDrgEA2Hn9fke2cCQmJmrQoEFavnx5UHz58uUaPnx4q9vZsGGD8vLyAj8PGzasRZtvvfVWWG2GixlnAAAAAAAAcNSUKVM0fvx4DR48WMOGDdNzzz2nHTt2aOLEiZKkqVOnavfu3VqwYIEkadasWerZs6f69eun+vp6LVy4UEuXLtXSpUsDbf7sZz/T2WefrYcffliXX365Xn31Va1YsUJ/+9vfonYeDJwBQAgs1QQARBNLNQEA0fbtm/tH0ka4xo0bp5KSEj300EMqKipS//79tWzZMvXo0UOSVFRUpB07dgT2r6+v11133aXdu3crOTlZ/fr102uvvaaLLroosM/w4cO1ePFi/epXv9J9992n4447TkuWLNGQIUMiOr9QXH5/mPPtACAGlJeXKzMzU3v3fq6MjPQI26pQt24nqqysrFX3AwAAHP2czDNN7ZFrAADBmnPNts/zlJ4e2Z26Kip86nViUUzmGe5xBgAAAAAAABiwVBMAQmCpJgAgmliqCQCItvZaqnm0YOAMAEJg4AwAEE0MnAEAoq0tVTFNbcQqlmoCAAAAAAAABsw4A4AQ/H6vAzPOvA71BgBwtHEizzS3AwCAie/fW6RtxCoGzgAgBJZqAgCiiaWaAIBo88ovb4T3KIv0+UcylmoCAAAAAAAABsw4A4AQmpbQRLb8heUzAAAbJ/JMczsAAJh4/U1bpG3EKgbOACAElmoCAKKJpZoAgGjjHmeRYakmAAAAAAAAYMCMMwAIgRlnAIBoYsYZACDafHLJK1fEbcQqBs4AIISme89EOnDGfWcAAGZO5JnmdgAAMPH5m7ZI24hVLNUEAAAAAAAADJhxBgAhUFUTABBNVNUEAESb14GlmpE+/0jGwBkAhMA9zgAA0cQ9zgAA0cbAWWRYqgkAAAAAAAAYMOMMAEJgxhkAIJqYcQYAiDaf3yWfP8KqmhE+/0jGwBkAhOTEBxo+zAAAbJwZOCPXAABsWKoZGZZqAgAAAAAAAAbMOAOAEPx+nwNVNX0O9QYAcLRxIs80twMAgIlXcfJGOG8qlms3M3AGACFwjzMAQDRxjzMAQLT5HbjHmT+G73HGUk0AAAAAAADAgBlnABACM84AANHEjDMAQLRRHCAyDJwBQAgMnAEAoomBMwBAtHn9cfL6I7zHmd+hzhyBWKqJmLB9+3a5XC7NmzevvbsCAOgAbrrpJvXs2TMotn//fl177bXq1q2bXC6Xvve970mSXC6XCgsLD3sfAQBHnp49e+qmm2465H4rV66Uy+XSypUrO0R/ANgx4wwxIS8vT6tXr9Zxxx3X3l3BEYYZZ0Ds+PWvf61XXnlFL7zwgo477jh16dKlvbuEGMCMM+Do8sorrygjI6O9uwEE8cklX4TzpnyK3SlnDJwhJng8Hg0dOrS9u4EjkN/vk98fWfFlv9/nUG8ARNOnn36q4447TjfccEN7dwUxxIk809wOgPBVV1crJSXFsfYGDhzoWFuAU7jHWWRYqomoKCwslMvl0qZNm3TdddcpMzNTOTk5+tGPfqSysrLAfqWlpbr55pvVpUsXpaWl6eKLL9a//vWvFstimtv7+OOPdfXVVyszM1NdunTRlClT1NjYqC1btujCCy9Uenq6evbsqUceeSSoPwcv1aytrdXAgQN1/PHHB/WnuLhYubm5GjlypLzeyP8RCwBwzquvvqpTTjlFHo9HvXv31hNPPBHID82efvppnX322erWrZtSU1M1YMAAPfLII2poaLC225wjVqxYoc2bN8vlch1y+cynn36qyy+/XJ07d1ZSUpJOO+00zZ8/P/C43+9XTk6ObrvttkDM6/Wqc+fOiouL0549ewLxxx57TG63W6WlpW27MACAVmnOGevXr9dVV12lzp0767jjjpPf79fs2bN12mmnKTk5WZ07d9ZVV12lf/3rX0HP37Bhgy655BJ169ZNHo9H+fn5uvjii7Vr167APqalkZ9//rkuvPBCpaSkKDs7WxMnTlRFRUWL/tmWVY4cOVIjR44M/FxbW6uf//znOu200wKfi4YNG6ZXX331kNfA5/Np2rRpOuGEE5ScnKxOnTrplFNO0RNPPHHI5wKxihlniKqxY8dq3Lhxuvnmm/XJJ59o6tSpkqQXXnhBPp9Pl156qdauXavCwkKdfvrpWr16tS688EJre9dcc42+//3v68c//rGWL18e+DC0YsUKTZo0SXfddZdeeukl/fKXv9Txxx+vK6+80thOUlKS/ud//keDBg3Sj370Iy1dulQ+n0833HCD/H6/Xn75ZcXHx0flmuDIwlJNoGN44403dOWVV+rss8/WkiVL1NjYqJkzZwYNQEnSl19+qeuvv169evVSYmKiPvroI/3mN7/R559/rhdeeMHYdvNy/kmTJqmsrEyLFi2SJJ188snG/bds2aLhw4erW7duevLJJ5WVlaWFCxfqpptu0p49e/SLX/xCLpdL3/3ud7VixYrA89auXavS0lIlJyfrr3/9q66//npJ0ooVKzRo0CB16tTJgSuFIw1LNYHD78orr9S1116riRMnqqqqSj/+8Y81b9483XHHHXr44Ye1f/9+PfTQQxo+fLg++ugj5eTkqKqqSqNGjVKvXr309NNPKycnR8XFxXrnnXeMg2DN9uzZo3POOUcJCQmaPXu2cnJytGjRIt1+++1t7n9dXZ3279+vu+66S8ccc4zq6+u1YsUKXXnllXrxxRf1gx/8wPrcRx55RIWFhfrVr36ls88+Ww0NDfr888/58uYo50xxAJZqAlFx88036//9v/8nSTr//PP1xRdf6IUXXtDcuXP1xhtv6G9/+5vmzJmjiRMnSpJGjRqlxMTEwADbwW699VZNmTIl0N5bb72lp556Sn/4wx90xRVXSGr6RuYvf/mLFi1aZB04k6Q+ffrov//7vzVu3Dg98cQT2r9/v1auXKk33nhDeXl5Tl4GHMEYOAM6hvvvv1/HHHOM3nzzTSUmJkqSLrzwwhY3+H/ssccC/+/z+TRixAhlZWXphz/8oR599FF17ty5RdvNy/kzMjJUX19/yKX9hYWFqq+v1zvvvKOCggJJ0kUXXaTS0lI9+OCD+vGPf6zMzEydf/75Wrx4sXbu3KmCggKtWLFCJ554ovr27asVK1bo+uuvV0NDg95991397Gc/i/AK4UjFwBlw+N1444168MEHJUlr1qzR888/r0cffTTwOUOSRowYob59++qxxx7Tww8/rM8//1wlJSWaO3euLr/88sB+11xzTchjPf744/rmm2+0YcMGnXrqqZKkMWPGaPTo0dqxY0eb+p+ZmakXX3wx8LPX69V5552nAwcOaNasWSEHzv7+979rwIABQat7Lrjggjb1A0eOpnucRbbUMtLnH8lYqomouuyyy4J+PuWUU1RbW6u9e/dq1apVklomm+uuu87a3iWXXBL080knnSSXy6UxY8YEYm63W8cff7y++uqrQ/bvmmuu0U9+8hP9v//3/zRt2jTdc889GjVq1CGfBwA4fKqqqrR27Vp973vfCwyaSVJaWpouvfTSoH03bNigyy67TFlZWYqPj1dCQoJ+8IMfyOv16p///Kcj/Xn77bd13nnnBQbNmt10002qrq7W6tWrJTV9wSMpMOts+fLlGjVqlM4//3wtX75ckrR69WpVVVUF9gUARN/YsWMD//+Xv/xFLpdL3//+99XY2BjYcnNzdeqppwaW7R9//PHq3LmzfvnLX+qZZ57RZ5991qpjvfPOO+rXr19g0KxZ86zjtvrf//1fnXXWWUpLS5Pb7VZCQoLmzp2rzZs3h3zemWeeqY8++kiTJk3Sm2++qfLy8oj6AcQCBs4QVVlZWUE/ezweSVJNTY1KSkrkdrtbVC3LycmxtnfwvomJiUpJSVFSUlKLeG1tbav6+KMf/UgNDQ1yu9264447WvUcxI7mmQCRbgDa7sCBA4F7hh3s27EdO3ZoxIgR2r17t5544gm99957+vDDD/X0009Laso9TigpKTHOTM7Pzw88Lkk9evTQcccdpxUrVgQG1JoHznbt2qUtW7ZoxYoVSk5O1vDhwx3pG448TuUZcg3Qet/+G75nz55AjklISAja1qxZo3379klqmuW1atUqnXbaabrnnnvUr18/5efn64EHHgh5H82SkhLl5ua2iJtirfWHP/xB11xzjY455hgtXLhQq1ev1ocffqgf/ehHh/wMNHXqVM2cOVNr1qzRmDFjlJWVpfPOO09r165tc3/Q8fkUJ2+EW6RVOY9kLNVEu8nKylJjY6P2798fNCBWXFx82PpQVVWl8ePHq2/fvtqzZ49uueWWVt1UE7HD7/c6UFWTQhNAJDp37iyXy9XifmZScM744x//qKqqKv3hD39Qjx49AvGNGzc62p+srCwVFRW1iH/99deSpOzs7EDsvPPO06uvvqpVq1bJ5/Np5MiRSk9PV35+vpYvX64VK1ZoxIgRgS+WEHucyDPN7QBonW8XlcnOzpbL5dJ7771n/Fv87diAAQO0ePFi+f1+ffzxx5o3b54eeughJScn6+677zYeKysry/j5xhRLSkpSXV1di/i+ffuCcsvChQvVq1cvLVmyJOhcTM89mNvt1pQpUzRlyhSVlpZqxYoVuueee3TBBRdo586djlYYRcfBPc4iE7tDhmh355xzjiRpyZIlQfHFixcftj5MnDhRO3bs0B/+8AfNnTtXf/rTn/T4448ftuMDAA4tNTVVgwcP1h//+EfV19cH4pWVlfrLX/4S+Ln5w8O3P+T4/X49//zzjvbnvPPO09tvvx0YKGu2YMECpaSkBN0j7fzzz9eePXs0a9YsDR06VOnp6YE2XnnlFX344Ycs0wSAdnTJJZfI7/dr9+7dGjx4cIttwIABLZ7jcrl06qmn6vHHH1enTp20fv16a/vnnnuuNm3apI8++igo/tJLL7XYt2fPnvr444+DYv/85z+1ZcuWFsdPTEwMGjQrLi4OewJAp06ddNVVV+m2227T/v37tX379rCeD8QKBs7Qbi688EKdddZZ+vnPf66HH35YK1as0K9//WvNnTtXkhQXF92353//939r4cKFevrpp9WvXz+NHTtWt99+u375y1/qH//4R1SPjSNH00yASJfPMAsAiNRDDz2k3bt364ILLtAf//hHLV26VOeff77S0tICHxyaC8xcd911ev311/XKK6/oggsu0IEDBxztywMPPKCEhASde+65WrRokV5//XV9//vf12uvvabCwkJlZmYG9v3ud78rl8ult956K+gemueff77efvttNTY2MnAW45zJM+QaoK3OOuss3XrrrfrhD3+oX/ziF/rLX/6id955Ry+99JImTZqkOXPmSGq6F9pFF12k5557TitWrNDy5cv1k5/8RKWlpSHvkTx58mRlZ2fr4osv1rx58wI54/PPP2+x7/jx4/XZZ59p0qRJ+utf/6oXXnhBl112mbp27Rq03yWXXKItW7Zo0qRJevvttzV//nx95zvfaVWBs0svvVRTp07V0qVL9e677+r3v/+9Zs2apR49eqhPnz5hXj0cKXz/XmoZ6dYWs2fPVq9evZSUlKRBgwbpvffes+77hz/8QaNGjVLXrl2VkZGhYcOG6c033wzaZ968eXK5XC221t6qqS0YOEO7iYuL05///Gdde+21+q//+i9dfvnleu+997Rw4UJJTd+ARMsnn3yiO+64QzfeeKNuuummQHzmzJk65ZRTNG7cOEoyQxL3OAM6igsvvFBLly5VSUmJxo0bpylTpuiKK67Q5ZdfHsgXJ554opYuXaoDBw7oyiuv1E9/+lOddtppevLJJx3tywknnKD3339fJ5xwgm677TZ973vf06effqoXX3wxUEm6WVZWlk477TRJChoga/7/bz+O2MQ9zoD29+yzz+qpp57Su+++q2uvvVYXX3yx7r//flVVVenMM8+UJPXp00edOnXSI488ossuu0xXX3211q9fr3nz5mnChAnWtnNzc7Vq1SqdfPLJ+slPfqLvf//7SkpK0lNPPdVi3+uvv16PPPKI3nzzTV1yySWaM2eO5syZo759+wbt98Mf/lD/9V//pddff10XXXSRHn74Yd19992tKjhw7rnn6t1339XEiRM1atQo/epXv9J5552nVatWKSEhIcwrhyOF1+9yZAvXkiVLNHnyZN17773asGGDRowYoTFjxlgryr777rsaNWqUli1bpnXr1uncc8/VpZdeqg0bNgTtl5GRoaKioqDt4PueO8nl98fwQlV0SC+99JJuuOEG/f3vf+dmyWg35eXlyszM1CefPKT09Mj+CFdU1GrAgPtVVlamjIwMh3oIoKGhQaeddpqOOeYYvfXWW+3dHSAsTuYZiVwDAGipOdf8fsMApaTHR9RWdYVX4wd+ElaeGTJkiE4//fTAzE1JOumkk/S9731PM2bMaFUb/fr107hx43T//fdLappxNnny5MM60YXiAGhXL7/8snbv3q0BAwYoLi5Oa9as0W9/+1udffbZDJqhQ3DiW3xmAQDOuPnmmzVq1Cjl5eWpuLhYzzzzjDZv3qwnnniivbsGtJlTs8XINQAAm+bKmJG10TTnqry8PCju8XiMhTXq6+u1bt26FoUzRo8erffff79Vx/T5fKqoqAgqJig13ee2R48e8nq9Ou200/TrX/9aAwcODOd0wsLAGdpVenq6Fi9erGnTpqmqqkp5eXm66aabNG3atPbuGiCJgTOgI6moqNBdd92lb775RgkJCTr99NO1bNky7hGGIxoDZwCAaPP54+SLsKqm79+LFQsKCoLiDzzwgAoLC1vsv2/fPnm9XuXk5ATFc3JyjFVlTR599FFVVVXpmmuuCcROPPFEzZs3TwMGDFB5ebmeeOIJnXXWWfroo4+idp8+Bs7Qri655BJdcskl7d0NAMAR4H/+53/auwsAAAAxbefOnUFLNU2zzb7t29VfpaaK5wfHTF5++WUVFhbq1VdfVbdu3QLxoUOHBlUwP+uss3T66afrd7/7neP3tW1GcQAACMHv9/274lkkm69Nxw6nAo0krVq1SoMGDVJSUpJ69+6tZ555Jujx559/XiNGjFDnzp3VuXNnnX/++S0qyBYWFraoUJObm9um/gMADs2ZPNO2XEOeAYDY0LxUM9JNarox/7c328BZdna24uPjW8wu27t3b4tZaAdbsmSJbr75Zv3P//zPIVcWxMXF6YwzztDWrVvDuCLhYeAMAEJor0pn4Vag2bZtmy666CKNGDFCGzZs0D333KM77rhDS5cuDeyzcuVKXXfddXrnnXe0evVqde/eXaNHj9bu3buD2urXr19QhZpPPvkk7P4DAFqnvapqkmcAIHb4FHllzXC/nklMTNSgQYO0fPnyoPjy5ctD3s/85Zdf1k033aSXXnpJF1988SGP4/f7tXHjRuXl5YXZw9ZjqSYAdECPPfaYbr75Zt1yyy2SpFmzZunNN9/UnDlzjBVonnnmGXXv3l2zZs2S1FStZu3atZo5c6bGjh0rSVq0aFHQc55//nn93//9n/7617/qBz/4QSDudrv59h8AjnLkGQBAtE2ZMkXjx4/X4MGDNWzYMD333HPasWOHJk6cKEmaOnWqdu/erQULFkhqGjT7wQ9+oCeeeEJDhw4NzFZLTk5WZmamJOnBBx/U0KFD1adPH5WXl+vJJ5/Uxo0b9fTTT0ftPKI2cDZ79mz99re/VVFRkfr166dZs2ZpxIgRh3yez+fT119/rfT09FatewWAg/n9flVUVCg/P19xcZFNrG36Fj+y0s3NswCiWYFm9erVGj16dFDsggsu0Ny5c9XQ0KCEhIQWz6murlZDQ0OLKjVbt25Vfn6+PB6PhgwZounTp6t3796HPtHDrK15RiLXAIhMR8szze1Ircs15JnWIc8AaE9O5hqf4uSLcMFhW54/btw4lZSU6KGHHlJRUZH69++vZcuWqUePHpKkoqKioJnOzz77rBobG3XbbbfptttuC8RvvPFGzZs3T5JUWlqqW2+9VcXFxcrMzNTAgQP17rvv6swzz4zo/EKJysBZ89Tv2bNn66yzztKzzz6rMWPG6LPPPlP37t1DPvfrr79uUaUBANpi586dOvbYYyNsxYkPNE0fZqJZgaa4uNi4f2Njo/bt22ecunz33XfrmGOOCbpvwJAhQ7RgwQL17dtXe/bs0bRp0zR8+HBt2rRJWVlZrTrbwyGSPCORawA4o+PkmaZ2pNblGvLMoZFnAHQUTuQarz9O3girarb1+ZMmTdKkSZOMjzUPhjVbuXLlIdt7/PHH9fjjj7epL20VlYGzcKd+f1t6eno0ugQgBnW0vyfRrkBj2t8Ul6RHHnlEL7/8slauXKmkpKRAfMyYMYH/HzBggIYNG6bjjjtO8+fP15QpU0L293CKJM9IHe+9AeDI1BH/loSTa8gzdk7lmWnvDFFSWvBHruMS9xifs6aqjzH+QUlPY7zR8iHW57e/hgM6Fxnjg9O2GeOvfnOaMf7xV8eYD2A5dNcuFcZ4ckKDMV7XaP6Y2jWl0hjvlVpijHvi7Pf++2dlN2O81tty9qQknZBuft121nQ2xj/5+/HGuMvSJffJ5muUnWY+58Q4rzGellgX1v4H6pLNHZJUWW/++7G/MsUYz8k0n8NVx6w3xnsl7DXG/3LgdGN8wz7z+65vZ3M7D+QtN8Yz4hKN8R98ab+f1j93mpeXD+i5yxi/vNtGY7zCm2SMl3tbvg51VY16+LyVHTLXxBrHB87aMvX725jKDMApTvw9aa5WFmkb0n8q0BxKWyrQ5ObmGvd3u90tvsGfOXOmpk+frhUrVuiUU04J2ZfU1FQNGDAgqlVqwhVpnpHINQCc0VHyTHM7UutyDXkmNCfzTFKaW8kHDZyleswzDD0u84CNu9Yy+NmGgbPENPMxUtLMfUqoNg8wxKWYP/zbBs7iU+uNcXeC+Ry8loGzhBRzOx7LeXni7NciwW8+N69l4Mx2jATLIExckvka2cby4i3n5k41Dy66LQNhCYl+c9yyv9ttH1x3J5gfi/eZz81teZ0P/h1olppoft8lNpivdXyNuT+JaebXID3d/P7KsCx7dKfar0VcsvmcE1LNx7adc6PXHK+3vO8kZ3KNTy75bL+gYbQRqxyvqhnu1O+6ujqVl5cHbQDQUTR9oIm00ll4H4jaUoFm2LBhLfZ/6623NHjw4KD7zvz2t7/Vr3/9a73xxhsaPHjwIftSV1enzZs3R7VKTbjassSIXAOgo3Imz4SXa8gzoZFnABxtmpdqRrrFqqideWunfs+YMUOZmZmBjXsBAEBTBZr//u//1gsvvKDNmzfrzjvvbFGB5tsVyiZOnKivvvpKU6ZM0ebNm/XCCy9o7ty5uuuuuwL7PPLII/rVr36lF154QT179lRxcbGKi4tVWfmfJQB33XWXVq1apW3btumDDz7QVVddpfLyct14442H7+RbKZwlRuQaAAhGnjk08gwAQIrCUs1wp35PnTo16H4G5eXlJBoAHUbTt/iRV0wLV7gVaHr16qVly5bpzjvv1NNPP638/Hw9+eSTGjt2bGCf2bNnq76+XldddVXQsb594+hdu3bpuuuu0759+9S1a1cNHTpUa9asCRy3I2jLEiNyDYCOyok809xOOMgzduQZAEcbr+LkjXDeVKTPP5I5PnD27anfV1xxRSC+fPlyXX755S32N5XIBoCOor0GzqTwKtBI0jnnnKP16803X5Wk7du3H/KYixcvbm332k24eUYi1wDouNpr4Ewiz9g4mWfmfnGW4lOC47np5huox8f5jPH81DJjvMZyT6QvD2Qb45K0scRcma+iwXz/JtuN8nO7mvuUYDmHRp/5PV5ea7lXVrx56XGK23y/rziX+b5elV577q9sMD9mW46Wl2g+50x3jTG+sbelgEKcua99s803uN9bbb4xfL3XfH+w07qYb1afk2BePvy3/ccZ45JUWmsuHJDsMd/LrKrefL+vP+051RhPije/nkVV5vs0NnjNr82eGvM1+r+KfsZ4V7f5WqQlmAsrSNKxefuNcdt774WdZxnj+6vMhRUyk2tbxBqr6iStsPYpHD6/K+T9D1vbRqyKSlXNKVOmaPz48Ro8eLCGDRum5557LmjqNwAAkSDPAACiiTwDAGgWlYGzQ039BoAjhZNVNeEc8gyAo4XTVTXhDPIMgKOJz4Glmj6Wajov1NRvADhStOdSTYRGngFwNGjPpZoIjTwD4Gjh88fJF2GuifT5R7LYPXMAAAAAAAAghKjNOAOAo0HTEprIvsVn+QwAwMaJPNPcDgAAJl655FVkN/eP9PlHMgbOACCEpiU0kSUJls8AAGycyDPN7aDjqd6Wobik4MqRdQPMVRi/k/WlMd7dU2KMf1DW2xhPdNvfCy5LBcCiGnMVQ1uVwWO6lBrjCS5zVc2t5V2NcVu1za4pVebjJpuPmxlvvqZ1cfaPuyluc2XIfTVpxnhRfaYxnuAyD1r3zf3GGO/iMZ9bmqU/1Y3mSpV9M8xVOEdnfGKMf1JbYIyH0inJfF27eKrN8URz3GcZcCm2VMOMt7xPkxLM7+3yOnN11r/uO9EYT4w3t5OZ0LKyZeCxTubHdleb3xe2apun55irnqa6W/6u1Sc2aLW1R+FhqWZkYvfMAQAAAAAAgBCYcQYAITDjDAAQTcw4AwBEm1eRL7WM5RsCMHAGACE03Xsm0qqasZxmAAChOJFnmtsBAMCEpZqRid0zBwAAAAAAAEJgxhkAhMBSTQBANLFUEwAQbV5/nLwRzhiL9PlHMgbOACCEpiU0kQ6csXwGAGDmRJ5pbgcdT3x+teJSgitNnpvzT+O+p6bsMMZtH1Y7JZgrGB6Xuc/an+T4BmO8pC7VGLdVGcxKMFeGrPaZK0CmWqpzJsSb37e908znYKueWen1GOPljcnGuGRfdpaSYK5uWeM1n9ueRvOxkyzXunvyAWPcdg62Cpanp31ljMfLXM3xn9W5xvieanNly1BOzNxjjA9IMVeMLGroZIwnxpkH/I+zvP4+y9/Kb+rNlVDrfebhjvJ6cxXOxDj731Hb705OcoUx/p3Mrcb40ORtxviyyv4tYrWNzn0h4pfLWt00nDZiVewOGQIAAAAAAAAhMOMMAEJoWkITeRsAAJg4kWea2wEAwISlmpFh4AwAQmCpJgAgmliqCQCINp/fZV3qGk4bsSp2hwwBAAAAAACAEJhxBgAhsFQTABBNLNUEAESbV3HyRjhvKtLnH8kYOAOAEBg4AwBEEwNnR7fv9PhSiWnB1Ri7uM0VKbfW5Rjje+szjHFbJcEuieYqjJKUEmerGJlgfY6JrVpllaXyZJalMmSq21xtMzuh0hhv8Mcb43WW6on761OMcUmqaTSfc9dk87E9ceaqio0+8zHccT5j3HYOttfgmORSY7xPYrExvqnuWGN8S1k3Y7y2wT4kkOg2LwGvaDBXpfy8Js8Yt1Uk7Z9qrsLZx2M+t+LGTsb4P2vNFUO/qTdXDC2tM79/d1Wa25ekbMv7YkDG18Z4z8RvjPHdjebf59e+HtAi1lhVJ+mv1j6Fg6WakYndIUMAAAAAAAAgBGacAUAITTdtjrwNAABMnMgzze0AAGDiU5x8Ec6bivT5RzIGzgAgpEb5I/5Ew4cZAICNE3lGItcAAGy8fpe8ES61jPT5R7LYHTIEAAAAAAAAQmDGGQCEwFJNAEA0sVQTABBtFAeIjOMDZ4WFhXrwwQeDYjk5OSouNlfGAICOrKnaWWSfaPgw4yzyDICjiRN5pqkdco2TnMo1pQ0pSqgPrii40Vdg3Ncn84fSb2rN1TPrvOF/lCtzmasJVjZ4jPH6eMv7ynLoOIX3XrZVZ2z0mStPJsebq4KWNpgrW35dlWk9dryl6uWJaebXOMFlvhbbqrKMcVtVTVs7njhzZdw4l/mabm/oaoxvqTZXmLTJSTNXi5SkpHhzJdEyy+tmi3dOrDHGa/3mSqK7Gzob419aKs9uqza/BqWWqqrVDeYqn7b3hCTlJ5cZ47Yque9UnGyMF9Wa35P7q1v+bnprnFsg6PfHyeePrD1/hM8/kkVlxlm/fv20YsWKwM/x8eY/fAAAtAV5BgAQbeQaAIAUpYEzt9ut3NzwRroBoCNqWkIT6Ywz+7dXaBvyDICjhRN5pqkdco3TyDUAjhZeueS1zGoNp41YFZWBs61btyo/P18ej0dDhgzR9OnT1bt3b+O+dXV1qqurC/xcXl4ejS4BQJs0LaGJdFozH2acFk6ekcg1ADouJ/JMUzvkGqfxmQbA0cLnj/weZT4nCkAfoRxfpDpkyBAtWLBAb775pp5//nkVFxdr+PDhKikpMe4/Y8YMZWZmBraCAvOafwAApPDzjESuAQCEh880AOCM2bNnq1evXkpKStKgQYP03nvvhdx/1apVGjRokJKSktS7d28988wzLfZZunSpTj75ZHk8Hp188sl65ZVXotV9SVEYOBszZozGjh2rAQMG6Pzzz9drr70mSZo/f75x/6lTp6qsrCyw7dy50+kuAUCbNS2hiXyDc8LNMxK5BkDH5VSeIdc4i880AI4mvn8XB4h0C9eSJUs0efJk3XvvvdqwYYNGjBihMWPGaMeOHcb9t23bposuukgjRozQhg0bdM899+iOO+7Q0qVLA/usXr1a48aN0/jx4/XRRx9p/Pjxuuaaa/TBBx+0+focSlSWan5bamqqBgwYoK1btxof93g88njMVVwAoL2xVLPjO1Sekcg1ADoulmoeGfhMA+BI5pPLWrk3nDbC9dhjj+nmm2/WLbfcIkmaNWuW3nzzTc2ZM0czZsxosf8zzzyj7t27a9asWZKkk046SWvXrtXMmTM1duzYQBujRo3S1KlTJTV9cbFq1SrNmjVLL7/8chvPLrSoD5zV1dVp8+bNGjFiRLQPBQCIQeQZAEC0tTXXbC3pqvia1g2opXjqjfG8VPP90romVRrjbpd9ELXRMkibmVh7iN4Fq/OZK4zWehOM8TiX+eZI5fVJxrg7znwOJ2UUG+M5HvM1KvGkGuNNxzDP0syMrzHGq32Jxni9z/yRutFS9KMmzGtk2391+fFh7d897YAxnhpvft9J9mu0o6qzMV7daL5GWZ4qY/yL6hxjvLjWfG6NlvedrZ9ulzmen1ZmjOcm2e9NeEbaNmO8ymf+/f6s3FxYJDHe3Kcren3cIlZX2aDPrT1qPwffw9H2xUF9fb3WrVunu+++Oyg+evRovf/++8a2V69erdGjRwfFLrjgAs2dO1cNDQ1KSEjQ6tWrdeedd7bYp3mwLRocX6p51113adWqVdq2bZs++OADXXXVVSovL9eNN97o9KEAIOqaZgJEvsE55BkARxOn8gy5xlnkGgBHE6/f5cgmSQUFBUH3dDTNHJOkffv2yev1KicneIA0JydHxcXmQfDi4mLj/o2Njdq3b1/IfWxtOsHxGWe7du3Sddddp3379qlr164aOnSo1qxZox49ejh9KACIuqb7xkS2/MVv+cYRbUOeAXA0cSLPNLVDrnESuQbA0aSt9yg7uA1J2rlzpzIyMgLxQy1Td7mCl3j6/f4WsUPtf3A83DYj5fjA2eLFi51uEgCAAPIMACDayDUAYJaRkRE0cGaTnZ2t+Pj4FjPB9u7d22LGWLPc3Fzj/m63W1lZWSH3sbXpBMeXagLA0YTlMwCAaGKpJgAg2nxyyeePcAuzOEBiYqIGDRqk5cuXB8WXL1+u4cOHG58zbNiwFvu/9dZbGjx4sBISEkLuY2vTCVEvDgAAR7KmJTSRTftl+QwAwMaJPNPUDrkGAGDmd6Cqpr8Nz58yZYrGjx+vwYMHa9iwYXruuee0Y8cOTZw4UVJTRczdu3drwYIFkqSJEyfqqaee0pQpUzRhwgStXr1ac+fODaqW+bOf/Uxnn322Hn74YV1++eV69dVXtWLFCv3tb3+L6PxCYeAMAAAAAKKga1ql3KkNQbHqBnPVwwRLJcnOieYqj92T9xvjSXENxrgkxVkqbu6tNy+7Km1IMcZL6tKN8ZpG87llWs6hkyVuq5KYYKmS2OA3V1u0VXOUpLwkc2VFr2Vw4J9V5mVgVQ3mSpKdPdXGuK2vNnW2qp2WCpPpCeYKqbb9bVU4JSndVnnUUoXVVg01Od78nqxoMFdVLaoyvx9zUiqM8X4ZRca4jcdlnqGbk2B+T0j2121dhfm+h7sqOhnjPTPNv7f9kne1iFU3mq//kWTcuHEqKSnRQw89pKKiIvXv31/Lli0L3C+yqKhIO3bsCOzfq1cvLVu2THfeeaeefvpp5efn68knn9TYsWMD+wwfPlyLFy/Wr371K91333067rjjtGTJEg0ZMiRq58HAGQCE0LT8hRlnAIDocCLPNLVDrgEAmDUvt4y0jbaYNGmSJk2aZHxs3rx5LWLnnHOO1q9fH7LNq666SldddVWb+tMWDJwBQAgMnAEAoomBMwBAtDlZVTMWxe6ZAwAAAAAAACEw4wwAQvD7m7ZI2wAAwMSJPNPcDgAAJu25VPNowMAZAITg97sdWqppv1EvACB2OZFnmtoh1wAAzHwOVNWM9PlHMgbOAAAAACAKBnfZIU9acNXCeEtlS5sGSzXEtnyItd2jqLzRXN2wqtFcMdI288RWSTLVXd+K3v1HYpy56mG4FSlT3XVh7S9Ju+s6G+NVXvO1SE80H8NWYdJWJTPXU26Mey2v2Tf1aca47bWxVVS19UeSqmrN1S1tx3BbjmHb31YBNC/VfC1sFWZtvyPVPvNr5rG8v0L9bn5R3c0Y/0dRd2O8psZ87J2W98Wb7gEtYvWV9ZI2WvuEw4eBMwAIgRlnAIBoYsYZACDaWKoZGYoDAAAAAAAAAAbMOAOAEPz+BIdmnJmnlgMAYpsTeaapHXINAMCMGWeRYeAMAELw++Plt9xbovVthHcvEwBA7HAizzS1Q64BAJgxcBYZlmoCAAAAAAAABsw4A4CQ3A7MBGAWAADAxok8I5FrOqZ4l69Fpb7MeEtlQEvFyKLGTGM8ReZKlSkhKljuaTBXSfym1lyhsaLBXG3TVg0xP7nMGG+0VD0sbUi2HNcTVjtdEquM8eR4e8GM0oYUY9xWZTLbcgxZ4rYqnPWW9hNcXmO8s9vcfqXXfI3KLNfU24bZQumWqqR1ltfB9vrYqrlmuM1VWHOTKozx4tp0Y3x3tfl3JM7lNx/X8v4tTTBfu1DHSHSbX7fcbiXGeNfkSmPcVCW3LZVzbZhxFhkGzgAghKZqZyzVBABEhxN5pqkdcg0AwMyvyAfizMOQsYGlmgAAAAAAAIABM84AIISmamfMOAMARIcTeaapHXINAMCMpZqRYeAMAEJgqSYAIJpYqgkAiDYGziITdpZ+9913demllyo/P18ul0t//OMfgx73+/0qLCxUfn6+kpOTNXLkSG3atMmp/gIAjnLkGQBANJFnAADhCHvGWVVVlU499VT98Ic/1NixY1s8/sgjj+ixxx7TvHnz1LdvX02bNk2jRo3Sli1blJ5uroIBAB2V3x8vv6XKVevbMFfbgRl5BkAscSLPNLVDrmmtw5ln9tSlKzEhuLrimopexn1rGhOMcdssjz6dvjHGj/EcsPbn4AqfzaobzRUg6xrNHxe7p5org6bFm6sw7mk0V/NstMy2tFVD9MQ3GuPljebqn7Yqj5LUYK30aD6HrERzNcSvazsZ41WWa2qrVFltqcJZ6zO/L2zn5ra8xukhqq3aeOLM19tWkdQTZ/47lBxvPvb+hlRjfF+dOW57n3p95tcy0W2uqmp7H9mqyIY6xnGd9xnjAzN2GuPZbnPFUJOa+EYtbvXeoTHjLDJhzzgbM2aMpk2bpiuvvLLFY36/X7NmzdK9996rK6+8Uv3799f8+fNVXV2tl156yZEOA8Dh1LSEJvKtLWbPnq1evXopKSlJgwYN0nvvvRdy/1WrVmnQoEFKSkpS79699cwzzwQ9/vzzz2vEiBHq3LmzOnfurPPPP1//+Mc/Ij6u08gzAGKJU3mmLbmGPEOeARAbmgfOIt1ilaNVNbdt26bi4mKNHj06EPN4PDrnnHP0/vvvG59TV1en8vLyoA0AYt2SJUs0efJk3XvvvdqwYYNGjBihMWPGaMeOHcb9t23bposuukgjRozQhg0bdM899+iOO+7Q0qVLA/usXLlS1113nd555x2tXr1a3bt31+jRo7V79+42H/dwa0uekcg1AHAw8owZeQYAcDBHB86Ki4slSTk5OUHxnJycwGMHmzFjhjIzMwNbQUGBk10CgIg0VTuLfAvXY489pptvvlm33HKLTjrpJM2aNUsFBQWaM2eOcf9nnnlG3bt316xZs3TSSSfplltu0Y9+9CPNnDkzsM+iRYs0adIknXbaaTrxxBP1/PPPy+fz6a9//Wubj3u4tSXPSOQaAB2XU3km3FxDnjEjzwA4Gvn9Lke2WOXowFkzlyv4gvr9/haxZlOnTlVZWVlg27nTvBYYANqDk8tnDv4muq7OfI+L+vp6rVu3LujbbkkaPXq09dvu1atXt9j/ggsu0Nq1a9XQYL6/Q3V1tRoaGtSlS5c2H7e9hJNnJHINgI7L6aWarck15JlDI88AOJr45HJki1WODpzl5uZKUotvY/bu3dviW5tmHo9HGRkZQRsAHI0KCgqCvo2eMWOGcb99+/bJ6/WG9W13cXGxcf/Gxkbt22e+aendd9+tY445Rueff36bj3u4tSXPSOQaALGjNbmGPGNHngEAHKxtd6y26NWrl3Jzc7V8+XINHDhQUtM3S6tWrdLDDz/s5KEA4LBoqnYW2Z9K/78LQ+3cuTPoH9Iejyfk88L9ttu0vykuNVUMe/nll7Vy5UolJQVXEAr3uIcTeQbA0caJPNPUTtN/w8k15JmWnM4zmQm18iQEVxrcX2OuSFhVa64Y6HabKxUeqDO3s70229qfffVpxrhtCVaXpGpjPNzqljaZCebqnPU+8+9EuaXqYVtuWm6r3GmrtmmrehlnqWKZFG+eiem2VJ6s9Ib+d+HBbJUquyaaqzYmuMzHLa63D/LuqTNXkfVZrlH35P3GuK3aalFtprlPVeENPGcnmyuedk81V5jt7Da/r7dU2gfH6y1VTONkfh/trutkjJc1JhvjI9M3t4hVWX7324KqmpEJO0tXVlbqiy++CPy8bds2bdy4UV26dFH37t01efJkTZ8+XX369FGfPn00ffp0paSk6Prrr3e04wBwOERSFfM/bTT9t7XfQGdnZys+Pj6sb7tzc3ON+7vdbmVlZQXFZ86cqenTp2vFihU65ZRTIjpuNJBnAMQSJ/JMUztN/21NriHPkGcAxBYn7lHGPc7CsHbtWg0cODDwDcyUKVM0cOBA3X///ZKkX/ziF5o8ebImTZqkwYMHa/fu3XrrrbeUnm4erQYABEtMTNSgQYO0fPnyoPjy5cs1fPhw43OGDRvWYv+33npLgwcPVkLCf24Y/dvf/la//vWv9cYbb2jw4MERHzcayDMAEF3kGfIMAKD1wv56a+TIkYFp2SYul0uFhYUqLCyMpF8A0CE0VSqLdMZZ+N/OTJkyRePHj9fgwYM1bNgwPffcc9qxY4cmTpwoqekmxLt379aCBQskSRMnTtRTTz2lKVOmaMKECVq9erXmzp2rl19+OdDmI488ovvuu08vvfSSevbsGfjGPy0tTWlpaa067uFAngEQS5zIM03thJdryDPkGQCxg6WakXH0HmcAcLRxcqlmOMaNG6eSkhI99NBDKioqUv/+/bVs2TL16NFDklRUVKQdO3YE9u/Vq5eWLVumO++8U08//bTy8/P15JNPauzYsYF9Zs+erfr6el111VVBx3rggQcCHw4OdVwAgLOcXqrZWuQZAIgdLNWMDANnANBBTZo0SZMmTTI+Nm/evBaxc845R+vXr7e2t3379oiPCwA4epBnAAA4NAbOACAEZ6pqtmHKGQAgJjhXVZNc0xH18OxTsif49T0jx1wZssabYIzXec3vj/SEWmM8VGXLb2rNVTUT4s3V+3qmlRjjnjhzVc399anGuG2JlyfOXJEy3lKR0tZ/W4VMW2VLSUq3VHq0nZutImm4r0+ypU+2SqK290VCQpUxnp1grqppq4RZ4jK/ZqGeY+O13EK92meuSBru0r+UBHMlUVv1zLzEMmPcVtmy1vJaSpLb8l61VUm1vSfLLcfeUNOzZX9qGyT909qncPgdWKrJjDMAgJEzSzX5MAMAMHNuqSa5BgBg5lfbbh9zcBuxKuyqmgAAAAAAAEAsYMYZAITQVO3MPEW+9W041BkAwFHHiTzT1I4DnQEAHJV8csmlCKtqRvj8IxkDZwAQAks1AQDRxFJNAEC0UVUzMizVBAAAAAAAQLs4cOCAxo8fr8zMTGVmZmr8+PEqLS217t/Q0KBf/vKXGjBggFJTU5Wfn68f/OAH+vrrr4P2GzlypFwuV9B27bXXht0/ZpwBQAjMOAMARBMzzo5uNT6P/AdVS+yRZK5Ume02V0Os8JmrZO6tzzDG99SZ45LUxWOuxNglsdoY7+7Zbz5Gg/kYtgqQtkqS4S79SrRUvExLMFfITHCZKyFK9mqIjf74sPpkE2+pqhgvc58afOEdt85nvta2CpYpceaKlN0Sze+7UMewvc5VjR5jPM7yOnjiza9nbmq5Md7Z8j5NcJlfS9u1qLNUMO2aVGmMS9KxKaXGuO29bTvGjurOxvj7RT1bxLzVdZJWWPsUDp/fJVeEM8YircoZyvXXX69du3bpjTfekCTdeuutGj9+vP785z8b96+urtb69et133336dRTT9WBAwc0efJkXXbZZVq7dm3QvhMmTNBDDz0U+Dk52VzZNBQGzgAgBL8/3oGBM/s/2gAAsc2JPNPUDrkGAGDm9ztQVTNK389s3rxZb7zxhtasWaMhQ4ZIkp5//nkNGzZMW7Zs0QknnNDiOZmZmVq+fHlQ7He/+53OPPNM7dixQ927dw/EU1JSlJubG1EfWaoJAAAAAACAQyovLw/a6urMMz5ba/Xq1crMzAwMmknS0KFDlZmZqffff7/V7ZSVlcnlcqlTp05B8UWLFik7O1v9+vXTXXfdpYoK+yxLG2acAUAIzlTVZPkMAMDMuaqa5BoAgJmTxQEKCgqC4g888IAKCwvb3G5xcbG6devWIt6tWzcVFxe3qo3a2lrdfffduv7665WR8Z+l5DfccIN69eql3Nxcffrpp5o6dao++uijFrPVDoWBMwAIyYl7z7B8BgBg48w9zsg1AAAbJwfOdu7cGTQ45fGY721XWFioBx98MGSbH374oSTJ5WrZN7/fb4wfrKGhQddee618Pp9mz54d9NiECRMC/9+/f3/16dNHgwcP1vr163X66acfsu1mDJwBAAAAAADgkDIyMoIGzmxuv/32Q1aw7Nmzpz7++GPt2bOnxWPffPONcnJyQj6/oaFB11xzjbZt26a33377kP06/fTTlZCQoK1btzJwho6li+vIvpXefm62G9OcqarJewiINnINjlTOVdXkPdQRzf/nmYpPCa6K2bfrN8Z9+2d+bYzbKgbaqvbFWao5SlKOpYJiprvGGN/XkGaO15nj9ZbKkBkJtcZ4sqXSY4OlsmVivPla2NgqHkpShuWcSxtTwjqGja3ypK16ZlmDuXpqbpK5wqStGqatemaSy3wtEtz2a1rmNlcftFUkrbe8J+u85uqW6W7z+6JLgrn6q+19sacu3Rj3WPqZ6jbfkyvLclzJ/jtS1mi+RjuqzNUzS2vN+zd4W56b1xBrq/aoqpmdna3s7OxD7jds2DCVlZXpH//4h84880xJ0gcffKCysjINHz7c+rzmQbOtW7fqnXfeUVZW1iGPtWnTJjU0NCgvL6/1JyIGzgAgJGeqaob3jzwAQOxwrqomuQYAYNaRq2qedNJJuvDCCzVhwgQ9++yzkqRbb71Vl1xySVBFzRNPPFEzZszQFVdcocbGRl111VVav369/vKXv8jr9Qbuh9alSxclJibqyy+/1KJFi3TRRRcpOztbn332mX7+859r4MCBOuuss8Lq45H99SwAAAAAAACOWIsWLdKAAQM0evRojR49Wqeccop+//vfB+2zZcsWlZWVSZJ27dqlP/3pT9q1a5dOO+005eXlBbbmSpyJiYn661//qgsuuEAnnHCC7rjjDo0ePVorVqxQfHx4s/mYcQYAIThTVZPlMwAAM+eqapJrAABmTTPOIi0O4FBnDLp06aKFCxce4vj/6UDPnj0PWU26oKBAq1atcqR/DJwBQAjO3OOM5TMAADPn7nFGrgEAmDlZVTMWhb1U891339Wll16q/Px8uVwu/fGPfwx6/KabbpLL5Qrahg4d6lR/AQBHOfIMACCayDMAgHCE/fVWVVWVTj31VP3whz/U2LFjjftceOGFevHFFwM/Jyaaq2jgyBRu5TLb/rZ4lkOV0UosSxacqlxGBbTYwIyzw488A+nIzzU24eYOcs3Rjxlnh9/hzDO136QoLjm4WmJVZ3Nb+xtSjfHEuMawjtkpodr6WI2luuHOGnMFwOpG8/4pbnPlxkxL9UyvZaZKnc+8TNlW9dBWYdJW7S9UVc20ePMxbJUb67zm39PKRo8xbrt2ifHm19PtMv+9t1VJtVXPzHWXGeO28yr3mas8SlKCpSplmst87RTmNW30OZOLfX5zOzurzNU2vZb9c5LNlUole2VY23u7c6K5CueQztuNcdM1qq1s0Axrj8Lj//cWaRuxKuwsPWbMGI0ZMybkPh6PR7m5uW3uFAB0FM5U1QzvH7yxjjwDIJY4V1WTXNNa5BkAsYalmpGJSlXNlStXqlu3burbt68mTJigvXv3RuMwAIAYRZ4BAEQTeQYA0Mzx4gBjxozR1VdfrR49emjbtm2677779N3vflfr1q2Tx9NyGmtdXZ3q6v4zpbO83Dz9FgDagzNVNVk+46Rw84xErgHQcTlXVZNc4xTyDICjDms1I+L4wNm4ceMC/9+/f38NHjxYPXr00GuvvaYrr7yyxf4zZszQgw8+6HQ3AMARztzjjALGTgo3z0jkGgAdl3P3OCPXOIU8A+Co48BSTbFUM3ry8vLUo0cPbd261fj41KlTVVZWFth27twZ7S4BAI4ih8ozErkGANB25BkAiG1R/2qqpKREO3fuVF5envFxj8djnfKM9hOqmlm4lcv6xJnfZsdb4rb9be3bKo7Z4lt95pvnfmGJ2/YPhSpoRw9mnHV8h8ozErmmoyLXHHr/UMg1RwdmnHV8keSZy89YL09a8FJcW2XLr2sywuqXrWpfuqX6nySVNpgrKNqqUuYkmasM2va3VWG0VQaNV3h/x2zHtVXIzHSbr5Ek1Voqetb5zL9LPpmPHWdZv7a/NsV83EZz+9kpVea4p9IYz4w3V0/NijfvX+oz96fKZ//3UV5CqfUxk2pLW9U+83t+r9dc9dJWSdQWt1VhVZI5XGupkGp7f0nSvjpz1VtbNdS8JHN10+M9e4zxf1T1bhGr85qrkbaF39+0RdpGrAo7w1ZWVuqLL74I/Lxt2zZt3LhRXbp0UZcuXVRYWKixY8cqLy9P27dv1z333KPs7GxdccUVjnYcAA4HZ6pqOpf0YgF5BkAsca6qJrmmtcgzAGINVTUjE3aWXrt2rc4999zAz1OmTJEk3XjjjZozZ44++eQTLViwQKWlpcrLy9O5556rJUuWKD3dPJoMAMC3kWcAANFEngEAhCPsgbORI0fKH2KO3ptvvhlRhwCgI3Gmqmb4S7BiGXkGQCxxrqomuaa1yDMAYo7fFfnN/ZlxBgAw4R5nAIBo4h5nAIBo4x5nkYl6VU0AAAAAAADgSMRXUzEu3Kplkr0S2Znx5mopF7nN5Uz6JZgruxRZ4tWW4/a0VBXLbjRXFCqrN1eaed2yvyxxKqDFBmacAZGLxVwT32CudrbIEifXxC5mnB3dxndeo7T04L91D+6+xLjv15WZxnhivLlSpU1Fo71Koq1qYIq73hjPsFSltFU3tLXvtczXKG80V/mMs1QqtFXP9Fiqdnr94c8TsZ1bVaM5/+ypTjPG95ebqzB6veY+2W68npdcbownuMLLD10s1TZDXaMKnzm32p6zv9F8zjVe83J0W4VZW3VWr+UaJcc3GOM9kvYb4zZ1If6OHmiwVCW1/L7tbzBfi//9ZrAx/uG/erSI+aprJb1q7VNY/P/eIm0jRpFhASCEpg80kd7jzJzMAQBwIs80tUOuAQCYUVUzMizVBAAAAAAAAAyYcQYAIbBUEwAQTSzVBAAcFjG81DJSZFgACIGBMwBANDFwBgCINpZqRoalmgAAAAAAAIABX00BQAjMOAMARBMzzgAAUUdVzYiQYWHUxWWfjHhmvLls8B2J5lLMe5K7GOP/l9LVGP8gLccYL3Kby1Vn+sxVpAZUlxjjZ1XtMcZ/XL3PGLdqrLU+tNUXXnno/X5zyW10BAkOVDuLvFoacDQi17QCuSYGOJFnmtpBx/P7A0PlaQh+bXZVdDLum+6pM8aT3ea/P43+eGP8QE2KtT9ZSVXGuCfOa4xXej3GeKeEGks74f1dipf575LXsjAqOd58LeJd5naqfeZcIkk1XvPvzP568/X7psacf/YdSDfGfXuTjHGX+VJrX5359dyeZM5vp6WnGuP17jJjvFOc+f3llX35XYXXnBNrLQP1dT5z3PY+avSbX2efN7wlgY2W1//ruk7GuO2194W4Fm7LMdyW3516y7X4ujLTfGzD6++rN78n2sb17y3SNmITSzUBAAAAAAAAA2acAUAIfn+8A0s1nfy2CABwNHEizzS3AwCAEUs1I8LAGQCEwD3OAADRxD3OAABRx8BZRFiqCQAAAAAAABjw1RQAhMCMMwBANDHjDAAQdX5X0xZpGzGKDBsjbJXLbPE+cfa3xkVuc4UYa0Wzzr2N8UdzTjHGR3Xrb4xnpGQb43X1lcb4myX/NMY/2fOxMX7zvs+N8dstVchKQlQnsz1GRbMjj98febUzZ6qlAR0fueY/yDVoLSfyTHM76Hj+8s/+iksJ/nuWn2Wuetgzbb8xbqtUWeU1V4xMslSelKTcpHJzPNEct1UZjLOs2Wqw3GvP1k6a21zp0aay0VydsbTBXAkzzlIJUZL21ZmrZO6q7GSMF5VYqiEWm/NVytfm3Oe2FEuuqTSf27Z4c15a5eljjFd3Mr8vMuOrjfHaEH87bK9nWaP5etveqxmWk45zmd9H2QkVYR33m3rza/lVpfnfDGV15tes0Wu/V2RGkvkcuiab/32QaLsWHnM7qV1aVqr1Vof3+xGK39+0RdpGrGKpJgAAAAAAAGDAjDMACIGqmgCAaKKqJgAg6igOEBEGzgAgBO5xBgCIJu5xBgCIOu5xFhGWagIAAAAAAAAGYQ2czZgxQ2eccYbS09PVrVs3fe9739OWLVuC9vH7/SosLFR+fr6Sk5M1cuRIbdq0ydFOA8Dh0jwTININrUOeARBrnMoz5JrWI9cAiDUuvzNbrAorw65atUq33XabzjjjDDU2Nuree+/V6NGj9dlnnyk1NVWS9Mgjj+ixxx7TvHnz1LdvX02bNk2jRo3Sli1blJ6eHpWTQNvZKp0dH6LSWb8EczWT/0vpaozbKppd3fcSY/yEE8yVYLKyXjHGq6pONsb/9a9rjfHPLZXaltVXGePdLZXU+jSYK9NI0j8s13W/LU4FtA6LqpqHF3nm6ESu+Q9yDQ5GVc3D73DmGm95ovwNwX9vPDnmantdE82VBDPdLavtSVK1z/x3zFbxUpISXF5jPNzqmZVecwVIr2VeRqMvvIVO7jjz36vyxmRj/EC9OV5Rb/5bLEn7qs15pqLS3JZvj7mttK/M55ay13wOCTXmeGK5+T6FtnNYV9PLGN9V0MkY751ZYox3SjS/vyTJbXm/1FgqunZKMOeslPh6Yzwt3lxhMt7yvou3VEm1VfNMSzBXpfRblhzafg8kKSvJnL9t1TNL622VXs3nlpPR8ve/Mb5O5trdbdDB73F24MAB3XHHHfrTn/4kSbrsssv0u9/9Tp06dbI+56abbtL8+fODYkOGDNGaNWsCP9fV1emuu+7Syy+/rJqaGp133nmaPXu2jj322LD6F9bA2RtvvBH084svvqhu3bpp3bp1Ovvss+X3+zVr1izde++9uvLKKyVJ8+fPV05Ojl566SX9+Mc/DqtzAIDYQp4BAEQbuQYAOpbrr79eu3btCvx9vvXWWzV+/Hj9+c9/Dvm8Cy+8UC+++GLg58TE4EHdyZMn689//rMWL16srKws/fznP9cll1yidevWKT6+9UV1IprTXVZWJknq0qWLJGnbtm0qLi7W6NGjA/t4PB6dc845ev/9941Jpq6uTnV1/xkJLi8vj6RLAOAoqmq2LyfyjESuAdBxUVWz/fGZBsBRrwMXB9i8ebPeeOMNrVmzRkOGDJEkPf/88xo2bJi2bNmiE044wfpcj8ej3Nxc42NlZWWaO3eufv/73+v888+XJC1cuFAFBQVasWKFLrjgglb3sc3FAfx+v6ZMmaLvfOc76t+/vySpuLhYkpSTkxO0b05OTuCxg82YMUOZmZmBraCgoK1dAgDHcd+Z9uNUnpHINQA6Lu5x1r74TAMgJvgd2qJg9erVyszMDAyaSdLQoUOVmZmp999/P+RzV65cqW7duqlv376aMGGC9u7dG3hs3bp1amhoCPoSJD8/X/379z9kuwdr88DZ7bffro8//lgvv/xyi8dcruCRSL/f3yLWbOrUqSorKwtsO3fubGuXAABHEafyjESuAQCY8ZkGAMJTXl4etH17tm1bFBcXq1u3bi3i3bp1C/nF+JgxY7Ro0SK9/fbbevTRR/Xhhx/qu9/9bqA/xcXFSkxMVOfOnYOed6gv3E3a9NXUT3/6U/3pT3/Su+++G3RTteYpcsXFxcrLywvE9+7d2+Ibm2Yej0cej/nmkgDQ3pz4Fp9ZAOFzMs9I5BoAHZdTs8XINeHjMw2AmOFgcYCDZ9Q+8MADKiwsbLF7YWGhHnzwwZBNfvjhh5JaflEhHfqL8XHjxgX+v3///ho8eLB69Oih1157LXB/SpNDtWsSVob1+/366U9/qldeeUUrV65Ur17BlTx69eql3NxcLV++XAMHDpQk1dfXa9WqVXr44YfD6hgOjyxL5a0+ISqdFVkqna1PNVc6O7+ruRJZ377mdoYMGW2MFxTcYYyXlb1kjKemfmaMV1RcbIy/U2KuWXJRufkbwyG1pca4JL3eaK4QY2OrOEcFtPbXnlU1Z8+erd/+9rcqKipSv379NGvWLI0YMcK6/6pVqzRlyhRt2rRJ+fn5+sUvfqGJEycGHt+0aZPuv/9+rVu3Tl999ZUef/xxTZ48OagNU4Jry7cybUWeOTq1Jdfss1SlJNf8B7nm6NCeVTVjMc9IhzfXpHSrVnxKcGVCT7y5Cp+tYmRavHk2h61C5r6GNGt/yhrMx2jwme+RlxBnPkZJXaoxbqvCmeUxVyTMSyozxmu85vdzSZ2lEmaDOWeU1pjPV5LKK8xteb8xt5W81/w3NHmf+W9o2tfm181dYq5imeq2tF9ivtZlpeZrtK8y2xjff4z5fHM7m6u5SlKnJHNfMxLM+cfnN/e1Jt5chbPaEi9vNL8GPr/5Gtmqap6YvscYt/GFuIeXrWJsUlyDMf6N21xJ1Pa7lt+ptEWsLrlBf7P2KEwODpzt3LlTGRkZgbDtS4Pbb79d115rrj7erGfPnvr444+1Z0/L1+qbb74J+cX4wfLy8tSjRw9t3bpVUtOXIPX19Tpw4EDQrLO9e/dq+PDhrW5XCnPg7LbbbtNLL72kV199Venp6YEEl5mZqeTkZLlcLk2ePFnTp09Xnz591KdPH02fPl0pKSm6/vrrw+oYAMSyJUuWaPLkyZo9e7bOOussPfvssxozZow+++wzde/evcX+27Zt00UXXaQJEyZo4cKF+vvf/65Jkyapa9euGjt2rCSpurpavXv31tVXX60777zTeux+/fppxYoVgZ/DqTgTKfIMABwesZpnJHINAEQiIyMjaODMJjs7W9nZ5oHcbxs2bJjKysr0j3/8Q2eeeaYk6YMPPlBZWVlYA1wlJSXauXNnYKbwoEGDlJCQoOXLl+uaa66RJBUVFenTTz/VI4880up2pTAHzubMmSNJGjlyZFD8xRdf1E033SRJ+sUvfqGamhpNmjRJBw4c0JAhQ/TWW28pPT09rI4BQEfQXks1H3vsMd1888265ZZbJEmzZs3Sm2++qTlz5mjGjBkt9n/mmWfUvXt3zZo1S5J00kknae3atZo5c2bgA80ZZ5yhM844Q5J09913W4/tdrut1WmijTwDINa011LNWM0zErkGQAzqwFU1TzrpJF144YWaMGGCnn32WUnSrbfeqksuuSSoouaJJ56oGTNm6IorrlBlZaUKCws1duxY5eXlafv27brnnnuUnZ2tK664QlLTlyE333yzfv7znysrK0tdunTRXXfdpQEDBgSqbLZW2Es1D8XlcqmwsNC4xhUAjjR+f7wDA2dN36QfXJredj+U+vp6rVu3rsWHjtGjR1srwKxevTqoYowkXXDBBZo7d64aGhqUkND6JTxbt25Vfn6+PB6PhgwZounTp6t3796tfn4kyDMAYo0Teaa5Hal1uSaW84xErgEQe1z+pi3SNqJl0aJFuuOOOwJ55rLLLtNTTz0VtM+WLVtUVta0vDs+Pl6ffPKJFixYoNLSUuXl5encc8/VkiVLgr7gePzxx+V2u3XNNdeopqZG5513nubNmxf2TGfuIgoAh0lrb6S5b98+eb3eFmv6Q90Dpri42Lh/Y2Oj9u3bF3Rz41CGDBmiBQsWqG/fvtqzZ4+mTZum4cOHa9OmTcrKympVGwCA9tOaXEOeAQB0JF26dNHChQtD7vPtLz2Sk5P15ptvHrLdpKQk/e53v9Pvfve7iPrHwBkAhODkUs3W3kiz2cHVXg5VAca0vykeypgxYwL/P2DAAA0bNkzHHXec5s+frylTprS6HQBA6zi9VDOcXEOeAYAY4WBxgFjEwFmMsFXSasv+1ZYqaLZqmykp5hsCdunyZ2P8mGNuNcZ79pxqjB848I4xvnv3eGM8Pd3c/peJ5ntWlFuqvfQLcY3Cvd7ouJysqhnOjTTj4+NbfOu/d+9ea2WZ3Nxc4/5utzuib/BTU1M1YMCAQHUaIBQnc02Z5W/vkZNrJhjj5BoczOmqmq3JNeSZw2dw7g4lpgX/ftsqUm6v6mKMl1oqYXZKMFc8rPKa/55I9op+tV7zv+9L683Hrmk0v2czE819sqnzmY9b4zOfQ5KlImmj31zZcL/fXlXTxlIkUZbipoqvN48muMvMT4jbd8AY99eaK1Wmlnc2xuMazHnP5zZfu8p4c/7cn2iunCpJHrf5eqdYKkYmyDyIbnudfZb9bdUzU93ma2qrqnls4n5jPM6y5jDRZW5Hkr6uN78ONv1Sdxvj1Zb39slJLfev9tlfGxxe/IsLADqYxMREDRo0SMuXLw+KL1++3FpZZtiwYS32f+uttzR48OCw7jtzsLq6Om3evLnVS3AAAB0feQYAgNZjxhkAhNBeVTWnTJmi8ePHa/DgwRo2bJiee+457dixQxMnTpQkTZ06Vbt379aCBQskSRMnTtRTTz2lKVOmaMKECVq9erXmzp2rl19+OdBmfX29Pvvss8D/7969Wxs3blRaWpqOP/54SdJdd92lSy+9VN27d9fevXs1bdo0lZeX68Ybb4zoGgAAzNqrqiZ5BgBih0sOFAdwpCdHJgbOACAkl/wRl14O//njxo1TSUmJHnroIRUVFal///5atmyZevToIUkqKirSjh07Avv36tVLy5Yt05133qmnn35a+fn5evLJJzV27NjAPl9//bUGDhwY+HnmzJmaOXOmzjnnHK1cuVKStGvXLl133XXat2+funbtqqFDh2rNmjWB4wIAnOZEnmlqJxzkGQCIIX5X0xZpGzGKgTMA6KAmTZqkSZMmGR+bN29ei9g555yj9evXW9vr2bNnUDUak8WLF4fVRwDAkYs8AwDAoTFwBgAh+P0++f2+iNsAAMDEiTzT3A4AAEZU1YwIA2cw2h/iH199fOZqI5mN5ion5XXlxnhV1anGeGnpY+Y+7V9h2f89Y7yycpAxXl9fYYxn+swldNxt+IdoqOuHIwsDZ0Drhfu372jINRUVQ4zx+vpKY5xcg4MxcHZ0y/JUyeMJrkC4vdJcPbO8NskYr0myFF8wF0nUMcml1v50cVcZ4xVe87HLG83xRr+5OmeipbqhrephvMzvW1s7qZZqjrbqjF1S7FU+4yyrzvZ7zQ/U1puvRfI+c709f4L5GvkbzHnAW1pmjLuTzZVB4xrM1y7c+1iFmiQa7zIfI84ygmJ73WxVMm06JVQb42mW0qa29+mOurZX/G3RVo3597aywWOMn5CxxxjPTjB/Fo06Bs4iQlVNAAAAAAAAwIAZZwAQAjPOAADRxIwzAEC0ufwOVNWM4RlnDJwBQAgMnAEAoomBMwBA1LFUMyIs1QQAAAAAAAAMmHEGACEw4wwAEE3MOAMARB0zziLCwFmMsFXeKrHEQ1Xqym6sNcYH1B4wxv9U8k9j/F//utYYT0m5wBjfvfunxnhV1SnG+D//+T/GeHHxH4zx71QWG+N5DeaqLl9YKr7h6MLAGRC5ozvXvGSMk2vQWgycxZ6uyeaqu8luc7VFn99c5dFWza/Uba7CKEmNvvAWHHVLNFcAzHab4w1+88fLWku8rNFcGjQlzlw9MyXRHO9q6Wf/9K+NcUkqrss0xr9IyTbH47oZ4+V15uudWGk+t/Syzsa4O8lcGbKhp/m4ZT3Nr39Njnl0w9/Fck095vedJKWEWcW0qtHcp0ZLVc10t7lKps9S8vSA5f2yry7NGK9uNFekTbH8rpU3mF8DSdpbZT6GTZylImlFsvkYe+szWsTqKhskbQ7ruDbc4ywyLNUEAAAAAAAADJhxBgAhMOMMABBNzDgDAESd39W0RdpGjGLgDABCYOAMABBNDJwBAKKOe5xFhKWaAAAAAAAAgEFYA2czZszQGWecofT0dHXr1k3f+973tGXLlqB9brrpJrlcrqBt6NChjnYaAA4Xv98fmA3Q9i2Gv54JE3kGQKxxJs+Qa8JBrgEQa5qLA0S6xaqwlmquWrVKt912m8444ww1Njbq3nvv1ejRo/XZZ58pNTU1sN+FF16oF198MfBzYmKicz2Go2wVzbaGqOK1z1L56yxLpbDP93xsjrvNFUXKy4cb45mZ44zxurpyY7y4+H+N8a++/tAYv7tshzF+nKX9F7zmKjOS/fqFqiCHjomlmocXeebo1DFzzTBj3Klc8/XuD4zxn5NrcBCWah5+hzPXJLi8SnAFz1XITqwy7ntSmvnv2x5DtT1J2lsbXpU/Sarxmc+hstEcL20wVzH0JpvnX6TEm6skVnrNf4trvOaqh50TzDkgL6HUGLdJirNXjOyeuM8YPyHF/DqsSuhjjK9v7G6MVxwwn3N8bRdzhyyDEpXHmD+ylx9v3t9XYK5K3SunxBjPSjK/HyUp1VJVs8JS0TXRbc5LmZbqmZ648CpHN/rijfFsj7lS7T6Zf0dsFS8TQ/QnN9VcuTUx3vwcWwXbHVXmqqpFFektYt5q83VrE5ZqRiSsgbM33ngj6OcXX3xR3bp107p163T22WcH4h6PR7m5uc70EAAQM8gzAIBoI9cAAMIR0T3OysrKJEldugSPmq9cuVLdunVT3759NWHCBO3du9faRl1dncrLy4M2AOgonFk+wyyAtnIiz0jkGgAdl1N5hlzTdnymAXDUc2KZZgzPOGvzwJnf79eUKVP0ne98R/379w/Ex4wZo0WLFuntt9/Wo48+qg8//FDf/e53VVdnnmY4Y8YMZWZmBraCgoK2dgkAHMeHmfbjVJ6RyDUAOi4GztoXn2kAxAS/Q1uMCmup5rfdfvvt+vjjj/W3v/0tKD5u3H/uDdK/f38NHjxYPXr00GuvvaYrr7yyRTtTp07VlClTAj+Xl5eTaAAAjuUZiVwDADDjMw0A4FDaNHD205/+VH/605/07rvv6thjjw25b15ennr06KGtW7caH/d4PPJ4zDcXBID2RnGA9uFknpHINQA6LooDtB8+0wCIGRQHiEhYA2d+v18//elP9corr2jlypXq1avXIZ9TUlKinTt3Ki8vr82dxOH3RYhKZ683miu13F5trkzTUPJPY3y5pWLaWyXmf5B8mZRpjGc2mqfMD6n+xhi3Vc+0VWp7t95cpeWDEJXOwq1oRgW0jouBs8OLPBNbjuZccx25Bq3EwNnhdzhzzRdVXZWg4IqV28vMVRUHd9tpjHdJMFc9zPeUGuNp8ea/n5J0oDHVGK9szDLGS+rM+1d5zVU40y3VE20S4rzGuMdrzg9lceYqn9lu8z3lOsXbK0amx5mvU7zM97Kr7mQ+5+Icc9XTol7djHFvormSqE1tV/NoRVxP87n1yj5gjPfJMOcrt8v8GkhSnMt87OR4c7XSdLftmpr/PtX5zMMRXssdpRr85niyy5wr85LKLO2Yq3PmeMyVMyWps9v874kESyXOzyvNfyu+LM82xuNcLWN+Q6ytAvcpi7CNWBXWPc5uu+02LVy4UC+99JLS09NVXFys4uJi1dTUSJIqKyt11113afXq1dq+fbtWrlypSy+9VNnZ2briiiuicgIAgKMHeQYAEG3kGgBAOMKacTZnzhxJ0siRI4PiL774om666SbFx8frk08+0YIFC1RaWqq8vDyde+65WrJkidLT0x3rNAAcLsw4O7zIMwBiDTPODj9yDQAgHGEv1QwlOTlZb775ZkQdAoCOhIGzw4s8AyDWMHB2+JFrAMQc7nEWkbCWagIAAAAAAACxok1VNQEgVjDjDAAQTcw4AwBEG8UBIsPAWYwIt5LW1hCVzmSpdGZzg+XYeZZKZyMrvjbGy+PNlWzcYbZ/XJ256o6topmtsluoa2S73lQ0OxL5HfgwEsNZBjGFXPMf5Bq0nhN5pqkddDz1Xrf83uCPXDX15qqKO6o6G+MNyeYKgF0SzVUV40K8Fxp85rZqveY+JbnN1RPdLvN7Ns4S91mqIXotZQOrfea/xbU+cz8b/OaPtfEhroWt0qOtrZwEc4XG7unmKpZ789KM8ar4ZGPc7zb3NTHLnB+OzSo1xnum7Tfv7zH301YVMpQDDeZqq7YqmXWWYYd62/5ec9xWVbPR8r62Vf+0CrEeL97y3k5yma+frSKpJ968/zkFLat911U26CN7l8JHmmgzlmoCAAAAAAAABsw4A4AQWKoJAIgmlmoCAKKO4gARYcYZAITQ/IEm0g0AABOn8gy5BgBg03yPs0i3aDlw4IDGjx+vzMxMZWZmavz48SotLQ19Ti6Xcfvtb38b2GfkyJEtHr/22mvD7h8zzgAAAAAAANAurr/+eu3atUtvvPGGJOnWW2/V+PHj9ec//9n6nKKioqCfX3/9dd18880aO3ZsUHzChAl66KGHAj8nJ5vvMxgKA2cAEAJLNQEA0cRSTQBA1HXgpZqbN2/WG2+8oTVr1mjIkCGSpOeff17Dhg3Tli1bdMIJJxifl5ubG/Tzq6++qnPPPVe9e/cOiqekpLTYN1wMnMW4tlTeslb4CrMi2BDL/kNqS43xfi7zymLbOdiOu8oS/8BbH1Y7X4SqBoejBgNnQOTINf9BrsHBGDg7ug3t8i8lpR1UVbPRXBnSVkmwzlIxsMZSCdMWl6R9deZKj7aqmidlFBvjSXHmaoWVjR5jfE9dhjEebtXDcCtA1vrt18JSVNP6nASX1xjvkmiurtytk7mK8r448+hDfLy5Q51Sa4zxrCRzVdVUd50x7pO5gqmtKqRkr27a4Le8Jy372yRaXk/b70K8Za2grYJlaYN5ZlGtpX1bdU5JKvOEN0tpV1UnY7zBaz5Gtrvl+6XW7dy/AZxYatn8/PLy4MrhHo9HHo/5d781Vq9erczMzMCgmSQNHTpUmZmZev/9960DZ9+2Z88evfbaa5o/f36LxxYtWqSFCxcqJydHY8aM0QMPPKD09PSw+sjAGQAAAAAAAA6poKAg6OcHHnhAhYWFbW6vuLhY3bp1axHv1q2biovNg/cHmz9/vtLT03XllVcGxW+44Qb16tVLubm5+vTTTzV16lR99NFHWr58eVh9ZOAMAEJgxhkAIJqYcQYAiDoHl2ru3LlTGRn/mUVqm21WWFioBx98MGSTH374oaSmG/23OJzfb4ybvPDCC7rhhhuUlJQUFJ8wYULg//v3768+ffpo8ODBWr9+vU4//fRWtS0xcAYAITFwBgCIJgbOAABR5+DAWUZGRtDAmc3tt99+yAqWPXv21Mcff6w9e/a0eOybb75RTk7OIY/z3nvvacuWLVqyZMkh9z399NOVkJCgrVu3MnAGAAAAAACA9pGdna3s7OxD7jds2DCVlZXpH//4h84880xJ0gcffKCysjINHz78kM+fO3euBg0apFNPPfWQ+27atEkNDQ3Ky8s79Al8i/kOuAAASf+ZCRDpBgCAiVN5hlwDALBpLg4Q6RYNJ510ki688EJNmDBBa9as0Zo1azRhwgRdcsklQYUBTjzxRL3yyitBzy0vL9f//u//6pZbbmnR7pdffqmHHnpIa9eu1fbt27Vs2TJdffXVGjhwoM4666yw+siMMwAIgaWaAIBoYqkmACDqHFyqGQ2LFi3SHXfcodGjR0uSLrvsMj311FNB+2zZskVlZWVBscWLF8vv9+u6665r0WZiYqL++te/6oknnlBlZaUKCgp08cUX64EHHlB8vL2CqgkDZzDa34Z/fG31mcvlllja+sKy/+uNtWEfOxy2ftrOuS3Xoi3PAYBYczTkGts52PpDrgFiSzd3mZLdwR+5spKqjPuW1icb410TK43xYzylxvi+hjRrf3Z5OxnjcZZPxD6/+cbcDT7zh846X4Ix3ug3L3RKjq83xuNl/vtma78hztwfr+W4klTuTzLGS72p5mP4zcfolFBtjPfO3GeMJ8R7jfE4y3Se1ATzNcr2mN9H1tfM0n9bXJKqfYnGeGlDijFeZ3lfeOLM55zuNufitKQyY7zSa74Jve2cbf2x7e+T/Ub0tvd8RoL5HGy/519XZhrj7x04vuUxq+olrbL26WjSpUsXLVy4MOQ+fn/L35Fbb71Vt956q3H/goICrVrlzPVj4AwAQvD7/Q7MOIvi1zMAgCOaE3mmuR0AAIw6+Iyzjo6BMwAIgaWaAIBoYqkmACDanLhHWbTucXYkoDgAAAAAAAAAYMCMMwAIgRlnAIBoYsYZACDqWKoZkbBmnM2ZM0ennHKKMjIylJGRoWHDhun1118PPO73+1VYWKj8/HwlJydr5MiR2rRpk+OdBoDDpfkDTaQbWoc8AyDWOJVnyDWtR64BEGual2pGusWqsGacHXvssfqv//ovHX98U8WH+fPn6/LLL9eGDRvUr18/PfLII3rsscc0b9489e3bV9OmTdOoUaO0ZcsWpaenR+UEcPiFW8XLWkHM1T4rhZ2qQkY1M8B55Bk0I9c42w6A/zicuearuq7yJARXgjwmudS4b6fEGmPcE2euDmyreFjns3/ES4o3t+W2VD20VU9MsOxvqzyYHN9gjGdYqiomuMztV3vN5/xp3bHGeL6l8qgkZSdUGOO2KpO2ip62vtrO2VZt0R1n/nvvdoWXB6oazZUnbf0MVXnUVn0yztInj6UpW+VRW/XU9Hjz+8LWH9vvQqcE8+9Ul8Tw+iNJae46Y7yz2/x6VnrMVVtttu7PbhHzVpuPicMvrH9NXnrppbrooovUt29f9e3bV7/5zW+UlpamNWvWyO/3a9asWbr33nt15ZVXqn///po/f76qq6v10ksvRav/ABBVzAI4vMgzAGINM84OP3INgJjjd2iLUW3+Gtbr9Wrx4sWqqqrSsGHDtG3bNhUXF2v06NGBfTwej8455xy9//771nbq6upUXl4etAFAR8GHmfbjVJ6RyDUAOi4GztoXn2kAxAQGziIS9sDZJ598orS0NHk8Hk2cOFGvvPKKTj75ZBUXF0uScnJygvbPyckJPGYyY8YMZWZmBraCgoJwuwQAOIo4nWckcg0AIBifaQAArRX2wNkJJ5ygjRs3as2aNfrJT36iG2+8UZ999lngcZcreN2x3+9vEfu2qVOnqqysLLDt3Lkz3C4BQNQwC+DwczrPSOQaAB0XM87aB59pAMQSl0NbrAqrOIAkJSYmBm6kOXjwYH344Yd64okn9Mtf/lKSVFxcrLy8vMD+e/fubfGNzbd5PB55POYbGAJAe3PiwwgfZsLjdJ6RyDUAOi6nBr3INeHhMw2AmOLEUssYXqoZ9sDZwfx+v+rq6tSrVy/l5uZq+fLlGjhwoCSpvr5eq1at0sMPPxxxR9HxHSmVv46UfgJoQp7Btx0pf8OPlH4CaBKtXPNJeb4SDqoEeXKGeclnjaVi5K7aTsZ4gqWyYaiqmukJ5mqFtuqWtoqe8ZZjl9SnGeNxlsqNtgqWtuqJpY3mKp/7683xtkiwVTH1mgdGKy1x2+uTm2Su5hkuWyXU8gZzNccaS+VJWzVPyV7d0lbF0lbRc5/lfVHnNb9XbRVmk+PqjfEUS9z2/rWdlzfEnCrb6/+vmq7GeGOY7+0DJS0r9vpqzJVccfiFNXB2zz33aMyYMSooKFBFRYUWL16slStX6o033pDL5dLkyZM1ffp09enTR3369NH06dOVkpKi66+/Plr9B4CoYsbZ4UWeARBrmHF2+JFrAMQal79pi7SNWBXWwNmePXs0fvx4FRUVKTMzU6eccoreeOMNjRo1SpL0i1/8QjU1NZo0aZIOHDigIUOG6K233lJ6esvRUwA4Mvgd+DASw1kmTOQZALHHiTzT1A5ah1wDIOawVDMiYQ2czZ07N+TjLpdLhYWFKiwsjKRPAIAYRZ4BAEQbuQYAEI6I73EGAEczlmoCAKKJpZoAgMMihmeMRcp8l0YAgKT/fKCJdGuL2bNnq1evXkpKStKgQYP03nvvhdx/1apVGjRokJKSktS7d28988wzQY9v2rRJY8eOVc+ePeVyuTRr1ixHjgsAaDun8kxbcg15BgBiQ/M9ziLdYhUzztBuqDgG2C1ZskSTJ0/W7NmzddZZZ+nZZ5/VmDFj9Nlnn6l79+4t9t+2bZsuuugiTZgwQQsXLtTf//53TZo0SV27dtXYsWMlSdXV1erdu7euvvpq3XnnnY4cF+joyDWAGXnm8Ph0R77iUoKrHCb1tlT6s1S8rGwwV/Nri1R3XVj7J7jMlRt9luqD5ZaqikXVmZb+mKshHpf2jTFuq6qYmWDuT4OlmqdkrwwpS7y0wVy501bFNMFS9TLRUunRxlYZssZrrrhoq9po2z/fUxpWf0Kx9rUh2RhvtLw+tiqp2YnmkZs4y4iO1xdeNdfyRnNFUknaW2e+x+HXleb3dk1DeBUx/d6Wr5sphvbBjDMACKG9ZgE89thjuvnmm3XLLbfopJNO0qxZs1RQUKA5c+YY93/mmWfUvXt3zZo1SyeddJJuueUW/ehHP9LMmTMD+5xxxhn67W9/q2uvvVYej/kftuEeFwAQmfaacUaeAYAY4ndoi1EMnAFACE5+mCkvLw/a6urM3/rW19dr3bp1Gj16dFB89OjRev/9943PWb16dYv9L7jgAq1du1YNDQ2tOte2HBcAEBmnB85ak2vIMwAQW1iqGRkGzgDgMCkoKFBmZmZgmzFjhnG/ffv2yev1KicnJyiek5Oj4uJi43OKi4uN+zc2Nmrfvn2t6l9bjgsA6Fhak2vIMwAAtB73OAOAEJysqrlz505lZGQE4rZlLM1cruD7Gvj9/haxQ+1vih9KuMcFALSd01U1w8k15BkAiBFOLLWM4RlnDJwBQAhODpxlZGQEfZixyc7OVnx8fItv3/fu3dviW/pmubm5xv3dbreysrJa1c+2HBcAEBmnB85ak2vIMwAQW5xYahnLSzUZOAOADiYxMVGDBg3S8uXLdcUVVwTiy5cv1+WXX258zrBhw/TnP/85KPbWW29p8ODBSkhoXVWfthwXAHDkIc8cRvs9UnXwrL9N6bnGXY/JLDPGUyyVJzMtVTg98faqjbaKjrZKjCUNqcZ4haX6YL2lwmSD11zFsD7OHM9wm88tJd58f9gDln7aqidKUlKc+d58xXXmKom2So+2650RV2Pe3/Ia2K51laVSqU2nRPNxG3zma1HWaK54KdkrhtriaZbXJznevL/tWti4LZVK7RVPzeec4DJ/WRGq6qztd6e20Xxu5VXm35HMNPPrM6jv9haxhqp67bL2CIcTA2cAEIKTM87CMWXKFI0fP16DBw/WsGHD9Nxzz2nHjh2aOHGiJGnq1KnavXu3FixYIEmaOHGinnrqKU2ZMkUTJkzQ6tWrNXfuXL388suBNuvr6/XZZ58F/n/37t3auHGj0tLSdPzxx7fquAAAZzk946y1yDMAEENYqhkRBs4AIIT2GjgbN26cSkpK9NBDD6moqEj9+/fXsmXL1KNHD0lSUVGRduzYEdi/V69eWrZsme688049/fTTys/P15NPPqmxY8cG9vn66681cODAwM8zZ87UzJkzdc4552jlypWtOi4AwFntNXBGngGAGMLAWUQYOAOADmrSpEmaNGmS8bF58+a1iJ1zzjlav369tb2ePXsGbuTc1uMCAI4e5BkAAA6NgTMACKG9ZpwBAGJDe804AwDEDooDRIaBMwAIwe/3OzBwFsNZBgAQkhN5prkdAACMWKoZEQbOAAAAACAKXN6m7dvKD5grADZ644zxgs6lxnh6grkCYJeEKmt/+iYVGeO1/kRj/N0DfY3xPTXpxnhnT7UxfmxaqTGeYKmSaKvamHDwxfw3r8zXLpRan7kabJXXfC0a/eZjpFoqNMZZpudUes1VMndXdzLG3Zb2bddalnF4W+XUGsv5Nj1mvkYNlmvRaKli6ZP52LZKlfGWa2erbLq/zlyR1HbtEi2VUNMtlWolKTneXIU1M8n8nIR483u1V8Z+Y/zW3JUtYlUVPv3F2iMcTgycAUAILNUEAEQTSzUBANHm8vvlinBmcqTPP5IxcAYAITBwBgCIJgbOAABRx1LNiIQ/pxUAAAAAAACIAQycAUAIzTMBIt0AADBxKs+QawAANs1VNSPdouU3v/mNhg8frpSUFHXq1KlVz/H7/SosLFR+fr6Sk5M1cuRIbdq0KWifuro6/fSnP1V2drZSU1N12WWXadeuXWH3L6yBszlz5uiUU05RRkaGMjIyNGzYML3++uuBx2+66Sa5XK6gbejQoWF3CgA6Cj7MHF7kGQCxhoGzw49cAyDm+B3aoqS+vl5XX321fvKTn7T6OY888ogee+wxPfXUU/rwww+Vm5urUaNGqaKiIrDP5MmT9corr2jx4sX629/+psrKSl1yySXyes3FG2zCusfZscceq//6r//S8ccfL0maP3++Lr/8cm3YsEH9+vWTJF144YV68cUXA89JTLRX6QAA4NvIMwCAaDucuSb+mGrFpQQPanZJqzHu2y210hjPSaowxg/UJxvjVY3drP3JSyw1xru6y63PMbFVdOyVWmKMJ8WZKxJ+XdvJGN9enWWMd0o0XzubOq/9467bUtHTVj0xNb7eGM9wm/vU4DdXmKxqNFfVbPCa90/xmI9rq55a2mCuPGmr8mm7DpIkS1VNW9VLW/XMBku1TRvbtQ6X7dzS3eaKtB5LlU/JXtEz2W1+v2QlmV+f0zN2GONnJ7WMlZubPio9+OCDkqR58+a1an+/369Zs2bp3nvv1ZVXXimp6W95Tk6OXnrpJf34xz9WWVmZ5s6dq9///vc6//zzJUkLFy5UQUGBVqxYoQsuuKDV/Qtr4OzSSy8N+vk3v/mN5syZozVr1gSSjMfjUW5ubjjNAkCHRXGAw4s8AyDWUBzg8CPXAIg1Tiy1bH5+eXnwQLvH45HHYx4QjpZt27apuLhYo0ePDurHOeeco/fff18//vGPtW7dOjU0NATtk5+fr/79++v9998Pa+Cszfc483q9Wrx4saqqqjRs2LBAfOXKlerWrZv69u2rCRMmaO/evSHbqaurU3l5edAGAB0Fy2faj1N5RiLXAOi4WKrZvvhMAyAmOLhUs6CgQJmZmYFtxowZh/VUJKm4uFiSlJOTExTPyckJPFZcXKzExER17tzZuk9rhT1w9sknnygtLU0ej0cTJ07UK6+8opNPPlmSNGbMGC1atEhvv/22Hn30UX344Yf67ne/q7o681RISZoxY0bQRS8oKAi3SwCAo4jTeUYi1wAAgvGZBgDaZufOnSorKwtsU6dONe5XWFjY4n6RB29r166NqC8uV/DyYL/f3yJ2sNbsc7CwlmpK0gknnKCNGzeqtLRUS5cu1Y033qhVq1bp5JNP1rhx4wL79e/fX4MHD1aPHj302muvBdadHmzq1KmaMmVK4Ofy8nISDYAOg6Wah5/TeUYi1wDouFiq2T74TAMglji5VLO5sMqh3H777br22mtD7tOzZ8829aV5KX1xcbHy8vIC8b179wZmoeXm5qq+vl4HDhwImnW2d+9eDR8+PKzjhT1wlpiYGLiR5uDBg/Xhhx/qiSee0LPPPtti37y8PPXo0UNbt261ttce62EBoLUYODv8nM4zErkGQMfFwFn74DMNgJjiRFXMMJ+fnZ2t7OzsCA9q1qtXL+Xm5mr58uUaOHCgpKbKnKtWrdLDDz8sSRo0aJASEhK0fPlyXXPNNZKkoqIiffrpp3rkkUfCOl7YA2cH8/v91mnLJSUl2rlzZ9AIIAAA4SDPAACiLVq55gcnfaCktOCPXAkuc6U/n998F50vasxVMvdUpxvjtuqMktQ58Vhj/ISUPcZ4raUqZaKlWuGxiQeM8TiXeWB3S2WOMb6zopMxXplsHpzsnmI+bpXXXg21ts5cMbJnmrkyaFq8+f0Rbzm3krpUY7zGUqkyPbHWGE+yVPm0Ve20Vbb0+cNbmibZK3GGqlZqbsd8jbxh9slW8TQtwfza2Kpndk00V6qt9tnfL/str6fbcm4Fyeb3ZLalgu3fa1u2U2WIHa127Nih/fv3a8eOHfJ6vdq4caMk6fjjj1daWpok6cQTT9SMGTN0xRVXyOVyafLkyZo+fbr69OmjPn36aPr06UpJSdH1118vScrMzNTNN9+sn//858rKylKXLl101113acCAAYEqm60V1jv+nnvu0ZgxY1RQUKCKigotXrxYK1eu1BtvvKHKykoVFhZq7NixysvL0/bt23XPPfcoOztbV1xxRVidAoCOw+/At/iRfr0TO8gzAGKPE3mmqR20DrkGQCyKdKlmNN1///2aP39+4OfmWWTvvPOORo4cKUnasmWLysrKAvv84he/UE1NjSZNmqQDBw5oyJAheuutt5Se/p8vFR5//HG53W5dc801qqmp0Xnnnad58+YpPt7+BYNJWANne/bs0fjx41VUVKTMzEydcsopeuONNzRq1CjV1NTok08+0YIFC1RaWqq8vDyde+65WrJkSVDHAeBIwlLNw4s8AyDWsFTz8CPXAIg5fn/TFmkbUTJv3jzNmzfvEIcPPr7L5VJhYaEKCwutz0lKStLvfvc7/e53v4uof2ENnM2dO9f6WHJyst58882IOgMAiG3kGQBAtJFrAADhiPgeZwBwNGPGGQAgmphxBgCINierasYiBs4AIAQGzgAA0cTAGQAg6tqhqubRhIEzAAAAAIiCK9M/UXp6cLXM92sKjPu+X3G8Mb6rupMxnp5orhjYxVNt7Y8nrtEYt1XurKhPMsbzU8uM8a6WioGl3hRjvLLBXCXTVmsxzVIl0Va10da+JGUkmKtY5iWaz81WxbLaUrkzwdKnVHe9OW6M2s+txnLcOMvoRoOlauu+ujTLke1sFTptVS/TLdc6O6EyrON+VZNljCda3tf5SaXGeGZ8jTG+ucpeObfRZ75+SQmWSp+WKqzb6sy/a7/fPazlMavqJM229gmHDwNnABACM84AANHEjDMAQLS5fE1bpG3EKgbOACAEBs4AANHEwBkAIOpYqhkR83xDAAAAAAAAIMYx4wwAQmDGGQAgmphxBgCINqpqRoaBMwAIgYEzAEA0MXAGAIg6v79pi7SNGMXAGQAAAABEQcK/t2/7nz2DjftuL+1ijPfvWmSMX5L1kTFe7bNXkvxnTa4x/q/qbGM8Id5rjHfzVBjjKXHmSoI7G8znVllv7muapWJon7S9xrjXUjHSVv1RkjolmisrJrjM51xUn2mMlzUkG+O26pa2ypO2qpf1vvA+smcnmitV7q831+3cVZ1hbSs1wfw6dE89YIzbrp2tIqknznwtklzmKpmplqqqHp+5fdtrsL3WXJ1ze6X5fSpJdY3m1yEp3tzXOsvrVt5ofr/srWhZ3dRbffBfD7QXBs4AIARmnAEAookZZwCAaGOpZmQYOAOAENb7/XJFPHAWw1kGABCSE3lGItcAAEKgqmZEqKoJAAAAAAAAGDDjDABCSPD7HJhxxvIZAICZE3lGItcAAOxYqhkZBs4AIAS336e4CD+M+PgwAwCwcCLPSOQaAEAIVNWMCANnAAAAABAF79R0V3J88EeuDV92N+7rSa03xs/p9E9jfHjSbmP85fJTrf3ZXm2uJmirPtjFU2WM26pVFjd2Msa31XQ1xqsbzFUDu6fvN8b7JhUb41/VmauC1nntH3f31rasYihJ+Z5SYzw7wVyt0lZJcl+9uf3i2nRj3B1nHvy2XetuHnN/Mt3maqG2qprxluNKUpqlqmZnd7Ux/k29+dxKLZVHj/GYq3PGucK7Fsnx5t8dWzXPXdWdjPHSGnM/JcnjNlfP7JNurvR6WupXxviHlb2N8dz0lpVqG+PqtNnaIxxODJwBQAgJzDgDAESRE3lGItcAAOxYqhkZBs4AIAQGzgAA0cTAGQAg6qiqGRGqagIAAAAAAAAGzDgDgBCYcQYAiCZmnAEAoo2lmpGJaMbZjBkz5HK5NHny5EDM7/ersLBQ+fn5Sk5O1siRI7Vp06ZI+wkAiEHkGQBANJFnAACH0uaBsw8//FDPPfecTjnllKD4I488oscee0xPPfWUPvzwQ+Xm5mrUqFGqqGhZJQIAOjq336eECDc3swDahDwDIBY4kWfINW1DngEQM3x+Z7YY1aalmpWVlbrhhhv0/PPPa9q0aYG43+/XrFmzdO+99+rKK6+UJM2fP185OTl66aWX9OMf/9iZXgPAYeL2+xQf4YcRFx9mwkaeARArnMgzErkmXIcrz/xhzyAlVCYGB+vNcxeOKSgzxvt4io3xT+uzjPENZd2t/YmzrLXqk7rXGN9SmWOMf/BNT2P8q9Quxvg3NWnGuN/vMsa7JFYb41U+jzH+aUW+Mb63wnxcSapuSDDGT0zfY4z38nxjjCe4vMZ4nc/8UbukLtUYr/War4VNckq9Md4todwYP5CQElZ/QkmJrzPG99XnGuP/KjW/VzMSao3xfE+pMV7VaH79PYmNxrjttcnymN9faVnm85KkHI954HxUxqfGeLzL/Dd5Z01nY/yUzrtbxOoSGrTS2qMwURwgIm2acXbbbbfp4osv1vnnnx8U37Ztm4qLizV69OhAzOPx6JxzztH7778fWU8BADGDPAMAiCbyDACgtcKecbZ48WKtX79eH374YYvHioubvg3JyQn+ZiInJ0dfffWVsb26ujrV1f1nZLe83DxCDgDtIcGBmQBO3PQ5ljidZyRyDYCOy4k8I5FrwkGeARBrXHKgOIAjPTkyhTVwtnPnTv3sZz/TW2+9paSkJOt+LlfwJfX7/S1izWbMmKEHH3wwnG4AwGHjlj/i+8a4Ynlec5iikWckcg2AjsuJPCORa1qLPAMgJvn9TVukbcSosJZqrlu3Tnv37tWgQYPkdrvldru1atUqPfnkk3K73YFvZpq/qWm2d+/eFt/aNJs6darKysoC286dO9t4KgCAI1008oxErgEANCHPAADCFdaMs/POO0+ffPJJUOyHP/yhTjzxRP3yl79U7969lZubq+XLl2vgwIGSpPr6eq1atUoPP/ywsU2PxyOPx3yTPwBob05UKuOGza0XjTwjkWsAdFxOVcQk17QOeQZALHL5HViqGbsTzsIbOEtPT1f//v2DYqmpqcrKygrEJ0+erOnTp6tPnz7q06ePpk+frpSUFF1//fXO9RoADhMGzg4v8gyAWMPA2eF1uPPMl3uyFJcSvCQ0t/t+474X55qr8zX4443xPx0YaIx/XZVp7c85OVuN8YEp243xHTXmKpn7KsyVGCtqLVUPE8xVD7skm6sbeuLM+39Wba6euWV/V2PcVrVTkjzx5oqLNV5ztU1blUTb62Or6Ng95YAxvq/efE33VKcb47trOhnjKfHmapuVXvNrU+8z91+SPHHmc8iMrzHG3ZZrZNNgOXa1N9EYt1WFtZ3zsYnm37WkuAZjfH9j+BVGP6s7xhjfXpttjH9Vbq6qOSiz5T0Uay3VQtuEqpoRCbs4wKH84he/UE1NjSZNmqQDBw5oyJAheuutt5Sebv6FBwAgHOQZAEA0kWcAAN8W8cDZypUrg352uVwqLCxUYWFhpE0DQLtjxln7I88AOJox46z9kWcAHO1cfr9cEd7cP9LnH8kcn3EGAEcTt9+nhEg/jPBhBgBg4Uiekcg1AAA737+3SNuIUWFV1QQAAAAAAABiBQNnABBCwr9nAkS6AQBg4lSeIdcAAGyal2pGukXLb37zGw0fPlwpKSnq1KnTIfdvaGjQL3/5Sw0YMECpqanKz8/XD37wA3399ddB+40cOVIulytou/baa8PuH0s1ASAERz6M8GEGAGDh2KAXuaZDamxwK64++CNX15Qq477ba7PCim8uzQm7P2WNycb4irJ+xvg3dWnGeO/sEmPcVvWwot5c0TE9sdYYb/SZ53fsqu5kjNfWmythZqSY25ekY9NKjXF3nPl36ZtGc3EI2zVNjjdXbsz1lBnjDX7zOX/jMr8GJbXmCpDpCRnGeL3P/NHf9pqFsrfBdgxzlcx4yzWtaDS/L8LV2W3+nerqLjfGv6ztZoxv3H+s9Rh1XvP165JkPrbP8nraqrnurW95Tevqze+hNungVTXr6+t19dVXa9iwYZo7d+4h96+urtb69et133336dRTT9WBAwc0efJkXXbZZVq7dm3QvhMmTNBDDz0U+Dk52fw7GwoDZwAAAAAAAGgXDz74oCRp3rx5rdo/MzNTy5cvD4r97ne/05lnnqkdO3aoe/fugXhKSopyc3Mj6h9LNQEgBJbPAACiiaWaAICo8/ud2TqwsrIyuVyuFks9Fy1apOzsbPXr10933XWXKioqwm6bgTMACMHtwAcZdxs/zMyePVu9evVSUlKSBg0apPfeey/k/qtWrdKgQYOUlJSk3r1765lnnmmxz9KlS3XyySfL4/Ho5JNP1iuvvBL0eGFhYYv7AET6DQ0AwM6JPNPWXEOeAYDY4PI7s0lSeXl50FZXV9e+JyeptrZWd999t66//nplZPxn2esNN9ygl19+WStXrtR9992npUuX6sorrwy7fQbOAKADWrJkiSZPnqx7771XGzZs0IgRIzRmzBjt2LHDuP+2bdt00UUXacSIEdqwYYPuuece3XHHHVq6dGlgn9WrV2vcuHEaP368PvroI40fP17XXHONPvjgg6C2+vXrp6KiosD2ySefRPVcAQCHH3kGANAWBQUFyszMDGwzZsww7mf6ouTg7eD7kbVFQ0ODrr32Wvl8Ps2ePTvosQkTJuj8889X//79de211+r//u//tGLFCq1fvz6sY3CPMwAIIcHvj3j5i78N05ofe+wx3XzzzbrlllskSbNmzdKbb76pOXPmGJPTM888o+7du2vWrFmSpJNOOklr167VzJkzNXbs2EAbo0aN0tSpUyVJU6dO1apVqzRr1iy9/PLLgbbcbjff/gPAYeJEnpHCzzXkGQCIIU4stfz383fu3Bk0q8vjMRd5uP322w9ZwbJnz54RdamhoUHXXHONtm3bprfffjuoXyann366EhIStHXrVp1++umtPg4DZwAQghP3jfGH+fz6+nqtW7dOd999d1B89OjRev/9943PWb16tUaPHh0Uu+CCCzR37lw1NDQoISFBq1ev1p133tlin+YPQc22bt2q/Px8eTweDRkyRNOnT1fv3r3DOgcAQOs4dX+ycHINeebw6ZW3T+7U4A+VRRXmD3b/KjFXz8xMqTHGUxLMFfe6JlVa+1PWYK4mt3HPMdbnmHz32H8a47aKkZ9X5hnjtqqdu2s7GeO2ypDdMsznnGmp2ilJXRLN1RC7WCo0flFtrsT4RXlXY/yY1FJjfHjmfmM8K8F83H+5so3xsrokY7wk0Vxts5vlfZFkqf4pSWUN5mMccKcY4/nJ5te/uMr8nt+633xuGUnmpX99M/ca4z0T9xnjFT7L+73UXD2zqiHRGJekkzrvMcaPTTpgjH9ZbT634ipzddai2swWsYa6emt/wuXyNW2RtiFJGRkZhxygkqTs7GxlZ5uvgxOaB822bt2qd955R1lZ5r+h37Zp0yY1NDQoL8/8N8mGpZoAcJi09n4A+/btk9frVU5OcJn5nJwcFRcXG59TXFxs3L+xsVH79u0Luc+32xwyZIgWLFigN998U88//7yKi4s1fPhwlZSYy84DADqW1uQa8gwAoCPZsWOHNm7cqB07dsjr9Wrjxo3auHGjKiv/M+B74oknBu6b2djYqKuuukpr167VokWL5PV6VVxcrOLiYtXXNw04fvnll3rooYe0du1abd++XcuWLdPVV1+tgQMH6qyzzgqrf8w4A4AQ3A7MBPD9+/kFBQVB8QceeECFhYXW57lcrqCf/X5/i9ih9j84fqg2x4wZE/j/AQMGaNiwYTruuOM0f/58TZkyxXpsAEDbOJFnpLblGvIMAMQIB5dqRsP999+v+fPnB34eOHCgJOmdd97RyJEjJUlbtmxRWVnTrMZdu3bpT3/6kyTptNNOC2qr+TmJiYn661//qieeeEKVlZUqKCjQxRdfrAceeEDx8fFh9Y+BMwAIwYklNM0fZlp7P4Ds7GzFx8e3+NZ/7969Lb7Jb5abm2vc3+12B6Yt2/axtSlJqampGjBggLZu3WrdBwDQdk4t1Qwn15BnACDG+P+9RdpGlMybN0/z5s0LffhvDdz17NnzkPf2LCgo0KpVq5zoHks1AeBwab4fQPNmGzhLTEzUoEGDtHz58qD48uXLNXz4cONzhg0b1mL/t956S4MHD1ZCQkLIfWxtSlJdXZ02b94c9n0AAADtozW5hjwDAEDrMeMMAEJwcsZZOKZMmaLx48dr8ODBGjZsmJ577jnt2LFDEydOlNRUqWz37t1asGCBJGnixIl66qmnNGXKFE2YMEGrV6/W3Llzg6qY/exnP9PZZ5+thx9+WJdffrleffVVrVixQn/7298C+9x111269NJL1b17d+3du1fTpk1TeXm5brzxxoiuAQDAzOkZZ61FngGA2OHy++WKcKllpM8/kjFwBgAhtNfA2bhx41RSUqKHHnpIRUVF6t+/v5YtW6YePXpIkoqKirRjx47A/r169dKyZct055136umnn1Z+fr6efPJJjR07NrDP8OHDtXjxYv3qV7/Sfffdp+OOO05LlizRkCFDAvvs2rVL1113nfbt26euXbtq6NChWrNmTeC4AABntdfAGXnm8Lir+5tKTQ++l85zxecY9916wFydMSHO/No2eM336NlTY67aJ0m1jeaPf6Ul5uqWCSnmqn69k78xxi9P22yMf5ViXoq7oqK/MV7tM1c3jJf5WpQ2mqs8huLzmxdf2apn/vXzE4xxz5fmypPb+5or/A0//UtjPNNtrp6a6ja/Bnkp5gqW8S7z4MaOqs7GeKPPvgitwFIZNMNtrlZqq0i6P8P8+ny+37yM2/Y+9cQ1mvf3JRjjb+7vZz7uV+YZrt26ma+pJF2d9Q9jPN5SqnJDaYEx7vOb7yPZJ7VlxdA6v73iadg6+D3OOjoGzgCgg5o0aZImTZpkfMx0D4BzzjlH69evD9nmVVddpauuusr6+OLFi8PqIwDgyEWeAQDg0Bg4A4AQnKh25nVgJgEA4OjkVFVNcg0AwMovWSZshtdGjGLgDABCcGIJDR9mAAA2Ti3VJNcAAGy4x1lkqKoJAAAAAAAAGHS4GWf+GB7FBOAsJ/6eMOPs6ESuAeCEjpJnJHJNR9P83qiubPm6NFSZb/bura4zxhsbzPtbj20pJiBJjY1eY9xXY77Zu0/mY9dUmm/SXmF5H1Y1muN1leabn9f5zDdQtxUHqG8M7xpJ9hkk9T7zMWzXyGt+2eSrNu9vu3a1XvO1sL1fGizvC69lPV1DnWV/y7WWpHq/+Tl1jea+1rrN5xbue16WG+7XJ5uPW+0yv69tx7W+llWW/kiqqjAfw1YcINxzNv0u1FU1xRz5d6tfDhQHiLwbR6oON3BWUVHR3l0AcJSoqKhQZmZmRG0kyB/5wFksZ5kOilwDwAkdJc9I5JqOpjnPXHvWNsOj5qqKR5Jfhhm32x5RP45Ed7V3B45g6yzx563PCF3M5GA7QzxmL3li80VYe28M8ZgTuYaqmpHpcANn+fn52rlzp9LT0+VyuVReXq6CggLt3LlTGRkZ7d29qIu185U4Z87ZeX6/XxUVFcrPz4/qcXDk+nauqaio4PfxKBdr5ytxzuQZtDfyDH+Djnaxdr7S4T9nck3H0eEGzuLi4nTssce2iGdkZMTML6QUe+crcc6x4nCdc8TfyvybE9XOGlk+0+F8O9e4XE1LFPh9PPrF2vlKnHM0daQ8I5FrOhryTBPO+egXa+crHd5zdirXyCfJviq39W3EqA43cAYAHYkT957hwwwAwMape5yRawAANlTVjAxVNQEAAAAAAACDDj/jzOPx6IEHHpDH42nvrhwWsXa+EuccK47Uc2bG2dHvSH1vRiLWzjnWzlfinI8kzDg7+h2p781IcM5Hv1g7X+kIP2eKA0TE5XektikAHF3Ky8uVmZmp57t/RylxkX3HUO1r1IQdf1NZWVnM3QMCAGDmZJ6RyDX/v727j42ietQ4/qzdbstLW4GGLoRaICJIKgRaxRIJ7wVUBEwAozaQGBMUkIJGCURBE4GQG40GgRCJ+BItUaxiBH5UpRWkmFIpohCisVhMqA1YWsqFlnbP/YPb/bl2u7Sdwd2d/X6SSdjZM2fmBGYf5sw5MwCAtlqzZvLw5+SOs9bh19zSqK9P/k9M5gxTNQEAAAAAAIAgIn6qJgCEkx1TaOyYggMAcCa7pmqSNQCAdjFV0xI6zgAgBDrOAAA3Ex1nAICbzifJZUMdMYqpmgAAAAAAAEAQEd1xtnnzZg0aNEiJiYnKysrSwYMHw31Itvn22281c+ZM9e/fXy6XS5999lnA98YYrV27Vv3791e3bt00YcIE/fzzz+E5WBusX79ed999t5KSktS3b1/Nnj1bp0+fDijjtDZv2bJFI0aMUHJyspKTk5WTk6O9e/f6v3dae/9p/fr1crlcys/P96+Lxja3jgSwuiAykTPRdT6GQs7EXs5Izsgau3KGrIlcZE30nI83QtbEXtY4IWckyWWMLUusitiOs507dyo/P1+rV6/WsWPHNG7cOM2YMUNVVVXhPjRbXL58WSNHjtSmTZuCfr9x40a99tpr2rRpk8rKyuT1ejV16lRdunTpXz5Se5SUlGjx4sU6cuSIioqK1NzcrNzcXF2+fNlfxmltHjBggDZs2KCjR4/q6NGjmjRpkmbNmuX/UXVae/+urKxM27Zt04gRIwLWR2Ob3TZcyLi5mIlI5Ez0nY+hkDOxlTOSc7LGjpwhayIXWRNd5+ONkDWxlTVOyRlJ/33GmdUlVpkIdc8995hFixYFrBs2bJhZuXJlmI7o5pFkCgsL/Z99Pp/xer1mw4YN/nVXr141KSkpZuvWrWE4QvvV1NQYSaakpMQYExttNsaYXr16mbffftvR7b106ZIZMmSIKSoqMuPHjzfLli0zxkTf33FdXZ2RZD7tn23+M+BeS8un/bONJFNXVxfuZuFvyJnoOR+7gpxxdnudkDV25gxZE7nImug4H7uKrHFue52QM8b8N2umDFlupg9baWmZMmR5zOZMRI44a2pqUnl5uXJzcwPW5+bm6vDhw2E6qn9PZWWlqqurA9qfkJCg8ePHO6b9dXV1kqTevXtLcn6bW1paVFBQoMuXLysnJ8fR7V28eLEeeOABTZkyJWB9tLY53hgbRgLE8N2ZCEXOROf52BnkjLPb66SssSdnyJpIRNZE3/nYWWSNc9vrpJyRJPmMPUuMisi3ap4/f14tLS1KS0sLWJ+Wlqbq6uowHdW/p7WNwdr/+++/h+OQbGWM0YoVK3TfffcpMzNTknPbfOLECeXk5Ojq1avq2bOnCgsLNXz4cP+PqtPaW1BQoB9++EFlZWVtvovWv+PrFyPWXkHDc2ciDzkTnedjR5Ezzs0ZyXlZY0fOtNaDyELWRN/52BlkjXOzxmk5I8meqZYxfIMmIjvOWrlcgf+JMMa0WedkTm3/kiVL9OOPP+rQoUNtvnNam4cOHaqKigpdvHhRu3bt0oIFC1RSUuL/3kntPXv2rJYtW6b9+/crMTGx3XJOajOiX6z/e3Rq+8kZZ+aMRNYgOsX6v0entp+scWbWkDMIJiKnaqampiouLq7NnZiampo2PbtO5PV6JcmR7V+6dKl2796tAwcOaMCAAf71Tm2zx+PR7bffruzsbK1fv14jR47UG2+84cj2lpeXq6amRllZWXK73XK73SopKdGbb74pt9vtb1e0tZk3nTkTOeO836BW5Ixzc0ZyZtbwVk3nImuc+TskkTVOzhon5sx1drwYIHZHnEVkx5nH41FWVpaKiooC1hcVFWns2LFhOqp/z6BBg+T1egPa39TUpJKSkqhtvzFGS5Ys0aeffqpvvvlGgwYNCvjeiW0OxhijxsZGR7Z38uTJOnHihCoqKvxLdna2HnvsMVVUVGjw4MFR2WbequlM5IzzfoPImeucnDOSM7OGt2o6F1njvN8hsuY6J2eNE3NGEm/VtChip2quWLFCeXl5ys7OVk5OjrZt26aqqiotWrQo3Idmi4aGBv3666/+z5WVlaqoqFDv3r112223KT8/X+vWrdOQIUM0ZMgQrVu3Tt27d9ejjz4axqPuusWLF+vDDz/U559/rqSkJH8PfUpKirp16yaXy+W4Nq9atUozZsxQenq6Ll26pIKCAhUXF2vfvn2ObG9SUpL/+Q6tevTooT59+vjXO63NiG7kjLPOR3LG+TkjkTWIPmSNs85Hssb5WUPOIJiI7TibP3++Lly4oFdeeUXnzp1TZmam9uzZo4yMjHAfmi2OHj2qiRMn+j+vWLFCkrRgwQLt2LFDzz//vK5cuaKnn35atbW1GjNmjPbv36+kpKRwHbIlW7ZskSRNmDAhYP0777yjhQsXSpLj2vznn38qLy9P586dU0pKikaMGKF9+/Zp6tSpkpzX3o6IxjbzcgDnImei73wMhZwhZ1pFW7t5OYCzkTXRdT7eCFlD1khR2mafDVMtY/itmi5jYni8HQC0o76+XikpKSpLvVM9b4mzVFeDr0V3nz+luro6JScn23SEAIBoZmfOSGQNAKCt1qyZctvTct+SYKmuZl+jvqraHJM5E5HPOAMAAAAAAADCLWKnagJAJHDbMIWGBzYDANpjR8601gMAQFB2PNw/hicr0nEGACHwjDMAwM3EM84AADcdzzizhKmaAAAAAAAAQBB0nAFACNdHAlhfAAAIxq6cIWsAAO1qnappdblJXn31VY0dO1bdu3fXrbfe2qFtFi5cKJfLFbDce++9AWUaGxu1dOlSpaamqkePHnrooYf0xx9/dPr46DgDgBDiZaxfzFgdFg0AcCxbcoasAQCEYmRDx9nNO7ympibNnTtXTz31VKe2mz59us6dO+df9uzZE/B9fn6+CgsLVVBQoEOHDqmhoUEPPvigWlpaOrUfnnEGAAAAAACAsHj55ZclSTt27OjUdgkJCfJ6vUG/q6ur0/bt2/X+++9rypQpkqQPPvhA6enp+uqrrzRt2rQO74cRZwAQgtuGUQC86QwA0B47coasAQCEZONUzfr6+oClsbExbM0qLi5W3759dccdd+jJJ59UTU2N/7vy8nJdu3ZNubm5/nX9+/dXZmamDh8+3Kn9MOIMAEK4Pv3Feh0AAARjR8601gMAQFA+nySLOeG7vn16enrA6jVr1mjt2rXW6u6CGTNmaO7cucrIyFBlZaVefPFFTZo0SeXl5UpISFB1dbU8Ho969eoVsF1aWpqqq6s7tS86zgAAAAAAAHBDZ8+eVXJysv9zQkJC0HJr1671T8FsT1lZmbKzs7t0HPPnz/f/OTMzU9nZ2crIyNCXX36phx9+uN3tjDFyuVyd2hcdZwAQAiPOAAA3EyPOAAA3nR1vxfz/7ZOTkwM6ztqzZMkSPfLIIyHLDBw40Nox/U2/fv2UkZGhX375RZLk9XrV1NSk2tragFFnNTU1Gjt2bKfqpuMMAEKg4wwAcDPRcQYAuOls7DjrqNTUVKWmplrbZydcuHBBZ8+eVb9+/SRJWVlZio+PV1FRkebNmydJOnfunH766Sdt3LixU3XzcgAAAAAAAACERVVVlSoqKlRVVaWWlhZVVFSooqJCDQ0N/jLDhg1TYWGhJKmhoUHPPfecSktLdebMGRUXF2vmzJlKTU3VnDlzJEkpKSl64okn9Oyzz+rrr7/WsWPH9Pjjj+uuu+7yv2WzoxhxBgAh1BqfWizWUc8oAABAO+zIGYmsAQCE4DOSLI4481ncPoSXXnpJ7777rv/zqFGjJEkHDhzQhAkTJEmnT59WXV2dJCkuLk4nTpzQe++9p4sXL6pfv36aOHGidu7cqaSkJH89r7/+utxut+bNm6crV65o8uTJ2rFjh+Li4jp1fC5jrI7XAwDnqa+vV0pKin7o0VdJLmuDcy8Zn0ZfrlFdXV2HngcAAHA+O3NGImsAAG21Zs3kXgvkvsVjqa5mX5O+rn03JnOGqZoAAAAAAABAEEzVBIAQao1P1yzW0cD0GQBAO+zIGYmsAQCEYIz1qZYxPFmRjjMACKHW+NRksY7LXMwAANphR85IZA0AIARjwzPOYrjjjKmaAAAAAAAAQBCMOAOAEGqNUaOs3cX/3xi+OwMACM2OnJHIGgBACD6f5LKYNTE8spmOMwAI4S/j0xW5LNVxhYsZAEA77MgZiawBAITAVE1LmKoJAAAAAAAABMGIMwAIodaGkQBXY/juDAAgNDtyRiJrAADtMz6fjMWpmoapmgCAYGqNTwkWL2gauZgBALTDjpyRyBoAQAhM1bSEqZoAAAAAAABAEIw4A4AQao1P8RZHAlyL4bszAIDQ7MgZiawBAITgM5KLEWddRccZAITwFx1nAICbyI6ckcgaAEAIxkiy+IyyGM4ZpmoCAAAAAAAAQTDiDABCqDU+uS2OBGiO4bszAIDQ7MgZiawBALTP+IyMxamaJoZzhhFnABBCrfHpL4tLbRdf3bx582YNGjRIiYmJysrK0sGDB0OWLykpUVZWlhITEzV48GBt3bq1TZldu3Zp+PDhSkhI0PDhw1VYWGh5vwCArrMjZ7qaNeQMAMQI47NniVF0nAFABNq5c6fy8/O1evVqHTt2TOPGjdOMGTNUVVUVtHxlZaXuv/9+jRs3TseOHdOqVav0zDPPaNeuXf4ypaWlmj9/vvLy8nT8+HHl5eVp3rx5+v7777u8XwBAdCJnAADoGJeJ5fF2ANCO+vp6paSkqJdccrmsTaExxqhWRnV1dUpOTu7QNmPGjNHo0aO1ZcsW/7o777xTs2fP1vr169uUf+GFF7R7926dOnXKv27RokU6fvy4SktLJUnz589XfX299u7d6y8zffp09erVSx999FGX9gsA6Bo7c0bqfNaQMwDgfK1ZM8E1R25XvKW6ms01FZvCTl3TOAUjzgAghFoZ69NndP3+RH19fcDS2NgYdJ9NTU0qLy9Xbm5uwPrc3FwdPnw46DalpaVtyk+bNk1Hjx7VtWvXQpZprbMr+wUAWGNHzvw9azqCnAGAGMNUTUvoOAOAf0l6erpSUlL8S3t31s+fP6+WlhalpaUFrE9LS1N1dXXQbaqrq4OWb25u1vnz50OWaa2zK/sFAESWjtykIWcAILY065qajcVF18LdjLDhrZoAEITH45HX67XtP/Jer1fHjx9XYmKif11CQkLIbf45dccYE3I6T7Dy/1zfkTo7u18AQOfZnTOS1LNnT6WnpwesW7NmjdauXRu0PDkDAM7WmjWHqvfYUp/X65XH47GlrmhCxxkABJGYmKjKyko1NTXZUp/H4wnoNAslNTVVcXFxbS6mampq2tylbxXs4qumpkZut1t9+vQJWaa1zq7sFwDQNXbnjBS8AyrYTRpyBgBiQzivaZyEjjMAaEdiYmJYgsHj8SgrK0tFRUWaM2eOf31RUZFmzZoVdJucnBx98cUXAev279+v7OxsxcfH+8sUFRVp+fLlAWXGjh3b5f0CALqOnLnxfgEA1oQraxzFAAAiTkFBgYmPjzfbt283J0+eNPn5+aZHjx7mzJkzxhhjVq5cafLy8vzlf/vtN9O9e3ezfPlyc/LkSbN9+3YTHx9vPvnkE3+Z7777zsTFxZkNGzaYU6dOmQ0bNhi3222OHDnS4f0CAJyBnAEAoGPoOAOACPXWW2+ZjIwM4/F4zOjRo01JSYn/uwULFpjx48cHlC8uLjajRo0yHo/HDBw40GzZsqVNnR9//LEZOnSoiY+PN8OGDTO7du3q1H4BAM5BzgAAcGMuY0zH310NAAAAAAAAxIhbwn0AAAAAAAAAQCSi4wwAAAAAAAAIgo4zAAAAAAAAIAg6zgAAAAAAAIAg6DgDAAAAAAAAgqDjDAAAAAAAAAiCjjMAAAAAAAAgCDrOAAAAAAAAgCDoOAMAAAAAAACCoOMMAAAAAAAACIKOMwAAAAAAACAIOs4AAAAAAACAIP4Pe6m65R0yaRwAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -179,7 +204,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.5" + "version": "3.8.8" } }, "nbformat": 4, diff --git a/tests/test_metacal_ngmix.py b/tests/test_metacal_ngmix.py new file mode 100644 index 0000000..ca6ec80 --- /dev/null +++ b/tests/test_metacal_ngmix.py @@ -0,0 +1,371 @@ +# This module tests finite-differences metacalibration +# against ngmix +# WARNING! This should be run after altering ngmix to use +# the same interpolation as autometacal! + +import numpy as np +import ngmix +import galsim +import autometacal +import tensorflow as tf + +from numpy.testing import assert_allclose + +args={'seed':31415, + 'ntrial': 1000, + 'noise': 1e-6, + 'psf': 'gauss', + 'shear_true' : [0.01, 0.00], + 'fixnoise' : False + } + +rng = np.random.RandomState(args['seed']) + + +### functions +def make_struct(res, obs, shear_type): + """ + make the data structure + + Parameters + ---------- + res: dict + With keys 's2n', 'e', and 'T' + obs: ngmix.Observation + The observation for this shear type + shear_type: str + The shear type + + Returns + ------- + 1-element array with fields + """ + + dt = [ + ('flags', 'i4'), + ('shear_type', 'U7'), + ('s2n', 'f8'), + ('g', 'f8', 2), + ('T', 'f8'), + ('Tpsf', 'f8'), + ] + data = np.zeros(1, dtype=dt) + data['shear_type'] = shear_type + data['flags'] = res['flags'] + + if res['flags'] == 0: + data['s2n'] = res['s2n'] + # for moments we are actually measureing e, the elliptity + data['g'] = res['e'] + data['T'] = res['T'] + else: + data['s2n'] = np.nan + data['g'] = np.nan + data['T'] = np.nan + data['Tpsf'] = np.nan + + # we only have one epoch and band, so we can get the psf T from + # the observation rather than averaging over epochs/bands + data['Tpsf'] = obs.psf.meta['result']['T'] + + return data + +def select(data, shear_type): + """ + select the data by shear type and size + + Parameters + ---------- + data: array + The array with fields shear_type and T + shear_type: str + e.g. 'noshear', '1p', etc. + + Returns + ------- + array of indices + """ + + w, = np.where( + (data['flags'] == 0) & + (data['shear_type'] == shear_type) + ) + + return w + +def progress(total, miniters=1): + last_print_n = 0 + last_printed_len = 0 + sl = str(len(str(total))) + mf = '%'+sl+'d/%'+sl+'d %3d%%' + for i in range(total): + yield i + + num = i+1 + if i == 0 or num == total or num - last_print_n >= miniters: + meter = mf % (num, total, 100*float(num) / total) + nspace = max(last_printed_len-len(meter), 0) + print( + '\r'+meter+' '*nspace, flush=True, end='') + last_printed_len = len(meter) + if i > 0: + last_print_n = num + print(flush=True) + + +def make_data(rng, noise, shear): + """ + simulate an exponential object with moffat psf + + Parameters + ---------- + rng: np.random.RandomState + The random number generator + noise: float + Noise for the image + shear: (g1, g2) + The shear in each component + + Returns + ------- + ngmix.Observation + """ + + psf_noise = 1.0e-6 + + scale = 0.263 + stamp_size = 45 + psf_fwhm = 0.9 + gal_hlr = 0.5 + # We keep things centered for now + dy, dx = 0.,0. #rng.uniform(low=-scale/2, high=scale/2, size=2) + + psf = galsim.Moffat(beta=2.5, fwhm=psf_fwhm).shear( + g1=0.02, + g2=-0.01, + ) + + obj0 = galsim.Exponential(half_light_radius=gal_hlr).shear( + g1=shear[0], + g2=shear[1], + ) + + obj = galsim.Convolve(psf, obj0) + + psf_im = psf.drawImage(nx=stamp_size, ny=stamp_size, scale=scale).array + im = obj.drawImage(nx=stamp_size, ny=stamp_size, scale=scale).array + + psf_im += rng.normal(scale=psf_noise, size=psf_im.shape) + im += rng.normal(scale=noise, size=im.shape) + + cen = (np.array(im.shape)-1.0)/2.0 + psf_cen = (np.array(psf_im.shape)-1.0)/2.0 + + jacobian = ngmix.DiagonalJacobian( + row=cen[0] + dy/scale, + col=cen[1] + dx/scale, + scale=scale, + ) + psf_jacobian = ngmix.DiagonalJacobian( + row=psf_cen[0], + col=psf_cen[1], + scale=scale, + ) + + wt = im*0 + 1.0/noise**2 + psf_wt = psf_im*0 + 1.0/psf_noise**2 + + psf_obs = ngmix.Observation( + psf_im, + weight=psf_wt, + jacobian=psf_jacobian, + ) + + obs = ngmix.Observation( + im, + weight=wt, + jacobian=jacobian, + psf=psf_obs, + ) + + return obs + +import pytest + +xfail = pytest.mark.xfail + +@xfail(reason="Fails because it needs the modified tensorflow_addons to work") +def test_metacal_ngmix(): + """ + This test generates a simple galaxy and measures the response matrix and + the residual biases after correction with ngmix, vs. autometacal. + We aim for m, c to be compatible with zero at the same level of ngmix. + """ + shear_true = [0.01, 0.00] + rng = np.random.RandomState(args['seed']) + + # We will measure moments with a fixed gaussian weight function + weight_fwhm = 1.2 + fitter = ngmix.gaussmom.GaussMom(fwhm=weight_fwhm) + psf_fitter = ngmix.gaussmom.GaussMom(fwhm=weight_fwhm) + + # these "runners" run the measurement code on observations + psf_runner = ngmix.runners.PSFRunner(fitter=psf_fitter) + runner = ngmix.runners.Runner(fitter=fitter) + + # this "bootstrapper" runs the metacal image shearing as well as both + # psf and object measurements + # + # We will just do R11 for simplicity and to speed up this example; + # typically the off diagonal terms are negligible, and R11 and R22 are + # usually consistent + + boot = ngmix.metacal.MetacalBootstrapper( + runner=runner, psf_runner=psf_runner, + rng=rng, + psf=args['psf'], + types=['noshear', '1p', '1m'], + fixnoise=args['fixnoise'], + ) + + # We now create the autometacal function which returns (e, R) + @tf.function + def get_autometacal_shape(im, psf, rpsf): + method = lambda x: autometacal.get_moment_ellipticities( + x, + scale=0.263, + fwhm=weight_fwhm + ) + return autometacal.get_metacal_response(im, psf, rpsf, method) + + + + def get_finitediff_shape(im, psf, rpsf): + method = lambda x: autometacal.get_moment_ellipticities( + x, + scale=0.263, + fwhm=weight_fwhm) + return autometacal.get_metacal_response_finitediff(im, psf, rpsf,0.01, method) + + dlist = [] + dlist_auto = [] + dlist_R_auto = [] + + dlist_finite = [] + dlist_R_finite = [] + + for i in progress(args['ntrial'], miniters=10): + + obs = make_data(rng=rng, noise=args['noise'], shear=shear_true) + + resdict, obsdict = boot.go(obs) + + for stype, sres in resdict.items(): + st = make_struct(res=sres, obs=obsdict[stype], shear_type=stype) + dlist.append(st) + + # Same thing with autometacal + im = obs.image.reshape(1,45,45).astype('float32') + psf = obs.psf.image.reshape(1,45,45).astype('float32') + rpsf = obsdict['noshear'].psf.image.reshape(1,45,45).astype( + 'float32' + ) + g, R = get_autometacal_shape(im, psf, rpsf) + + g_finite, R_finite = get_finitediff_shape(im, psf, rpsf) + + dlist_auto.append(g) + dlist_R_auto.append(R) + + dlist_finite.append(g_finite['noshear']) + dlist_R_finite.append(R_finite) + + data = np.hstack(dlist) + data_auto = np.vstack(dlist_auto) + data_R_auto = np.vstack(dlist_R_auto) + + data_finite = np.vstack(dlist_finite) + data_R_finite = np.vstack(dlist_R_finite) + + w = select(data=data, shear_type='noshear') + w_1p = select(data=data, shear_type='1p') + w_1m = select(data=data, shear_type='1m') + + g = data['g'][w].mean(axis=0) + auto_g = data_auto.mean(axis=0) + finite_g = data_finite.mean(axis=0) + + gerr = data['g'][w].std(axis=0) / np.sqrt(w.size) + auto_gerr = data_auto.std(axis=0) / np.sqrt(w.size) + finite_gerr = data_finite.std(axis=0) / np.sqrt(w.size) + + #ngmix + g1_1p = data['g'][w_1p, 0].mean() + g1_1m = data['g'][w_1m, 0].mean() + R11 = (g1_1p - g1_1m)/0.02 + + #autometacal finite differences + finite_R = data_R_finite.mean(axis=0) + + #autometacal + auto_R = data_R_auto.mean(axis=0) + #ngmix + shear = g / R11 + shear_err = gerr / R11 + m = shear[0] / shear_true[0]-1 + merr = shear_err[0] / shear_true[0] + + #autometacal finite differences + finite_shear = finite_g / finite_R[0,0] + finite_shear_err = finite_gerr / finite_R[0,0] + finite_m = finite_shear[0] / shear_true[0] - 1 + finite_merr = finite_shear_err[0] / shear_true[0] + + #autometacal + auto_shear = auto_g / auto_R[0,0] + auto_shear_err = auto_gerr / auto_R[0,0] + auto_m = auto_shear[0] / shear_true[0]-1 + auto_merr = auto_shear_err[0] / shear_true[0] + + + #test R + assert_allclose(finite_R[0,0],R11,rtol=1,atol=1e-5) + assert_allclose(auto_R[0,0],R11,rtol=1,atol=1e-5) + + + #test m + assert_allclose(finite_m,m,rtol=1,atol=1e-5) + assert_allclose(auto_m,m,rtol=1,atol=1e-5) + + + s2n = data['s2n'][w].mean() + + print('S/N: %g' % s2n) + print('-------------------') + print('ngmix results:') + print('R11: %g' % R11) + print('m: %.5e +/- %.5e (99.7%% conf)' % (m, merr*3)) + print('c: %.5e +/- %.5e (99.7%% conf)' % (shear[1], shear_err[1]*3)) + print('-------------------') + print('finitediff results:') + print('R11: %g' % finite_R[0,0]) + print('m: %.5e +/- %.5e (99.7%% conf)' % ( + finite_m, + finite_merr*3 + ) + ) + print('c: %.5e +/- %.5e (99.7%% conf)' % ( + finite_shear[1], + finite_shear_err[1]*3 + ) + ) + print('autometacal results:') + print('R11: %g' % auto_R[0,0]) + print('m: %.5e +/- %.5e (99.7%% conf)' % (auto_m, auto_merr*3)) + print('c: %.5e +/- %.5e (99.7%% conf)' % (auto_shear[1], auto_shear_err[1]*3)) + + + + +if __name__=='__main__': + test_metacal_ngmix() diff --git a/tests/test_tf_ngmix.py b/tests/test_tf_ngmix.py index ea5a093..6338886 100644 --- a/tests/test_tf_ngmix.py +++ b/tests/test_tf_ngmix.py @@ -30,7 +30,7 @@ def test_tf_ngmix(): col=stamp_size//2, scale=scale)) e = fitter._measure_moments(obs)['e'] - results_ngmix.append(np.array(ngmix.shape.e1e2_to_g1g2(e[0],e[1]))) + results_ngmix.append(e) results_ngmix = np.array(results_ngmix)