diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..191310e --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +build/* +*.DS_Store diff --git a/CMakeLists.txt b/CMakeLists.txt index 33ffb95..1aea837 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -39,7 +39,7 @@ if(GetFFTW) # FFTW3 include(ExternalProject) ExternalProject_Add(project_fftw - URL http://www.fftw.org/fftw-3.3.7.tar.gz + URL http://www.fftw.org/fftw-3.3.9.tar.gz PREFIX ${CMAKE_CURRENT_BINARY_DIR}/fftw CONFIGURE_COMMAND ${CMAKE_CURRENT_BINARY_DIR}/fftw/src/project_fftw/configure --enable-openmp --prefix= BUILD_COMMAND make -j 8 diff --git a/code/open_spacecharge_core_mod.f90 b/code/open_spacecharge_core_mod.f90 index 96afddc..c5a672f 100644 --- a/code/open_spacecharge_core_mod.f90 +++ b/code/open_spacecharge_core_mod.f90 @@ -46,7 +46,7 @@ subroutine osc_freespace_solver(rho,gam0,delta,phi,efield,bfield,nlo,nhi,nlo_gbl complex(dp), allocatable, dimension(:,:,:) :: crho integer :: icomp,i,j,k,im1,ip1,jm1,jp1,km1,kp1 -real(dp) :: gb0,xfac,yfac,zfac +real(dp) :: beta0,xfac,yfac,zfac integer :: mprocs,myrank,ierr real(dp), parameter :: clight=299792458.d0 ! @@ -124,12 +124,12 @@ subroutine osc_freespace_solver(rho,gam0,delta,phi,efield,bfield,nlo,nhi,nlo_gbl endif ! set the magnetic field: -gb0=sqrt((gam0+1.d0)*(gam0-1.d0)) +beta0=sqrt(1-1/gam0**2) do k=lbound(phi,3),ubound(phi,3) do j=lbound(phi,2),ubound(phi,2) do i=lbound(phi,1),ubound(phi,1) - bfield(i,j,k,1)=-efield(i,j,k,2)/clight/gb0/gam0 - bfield(i,j,k,2)= efield(i,j,k,1)/clight/gb0/gam0 + bfield(i,j,k,1)=-efield(i,j,k,2)*beta0/clight + bfield(i,j,k,2)= efield(i,j,k,1)*beta0/clight bfield(i,j,k,3)=0.d0 enddo enddo @@ -554,7 +554,7 @@ subroutine osc_rectpipe_solver(rho,a,b,gam0,delta,umin,phi,efield,bfield,nlo,nhi integer :: icomp real(dp), parameter :: clight=299792458.d0 integer :: i,j,k,im1,ip1,jm1,jp1,km1,kp1 -real(dp) :: gb0,xfac,yfac,zfac +real(dp) :: beta0,xfac,yfac,zfac dx=delta(1); dy=delta(2); dz=delta(3) xmin=umin(1); ymin=umin(2); zmin=umin(3) @@ -610,12 +610,12 @@ subroutine osc_rectpipe_solver(rho,a,b,gam0,delta,umin,phi,efield,bfield,nlo,nhi endif ! set the magnetic field: -gb0=sqrt((gam0+1.d0)*(gam0-1.d0)) +beta0=sqrt(1-1/gam0**2) do k=lbound(phi,3),ubound(phi,3) do j=lbound(phi,2),ubound(phi,2) do i=lbound(phi,1),ubound(phi,1) - bfield(i,j,k,1)=-efield(i,j,k,2)/clight/gb0/gam0 - bfield(i,j,k,2)= efield(i,j,k,1)/clight/gb0/gam0 + bfield(i,j,k,1)=-efield(i,j,k,2)*beta0/clight + bfield(i,j,k,2)= efield(i,j,k,1)*beta0/clight bfield(i,j,k,3)=0.d0 enddo enddo @@ -924,7 +924,7 @@ subroutine osc_cathodeimages_solver(rho,gam0,umin,delta,phi,efield,bfield,nlo,nh complex(dp), allocatable, dimension(:,:,:) :: crho integer :: icomp,i,j,k,im1,ip1,jm1,jp1,km1,kp1 -real(dp) :: gb0,xfac,yfac,zfac +real(dp) :: beta0,xfac,yfac,zfac integer :: mprocs,myrank,ierr real(dp), parameter :: clight=299792458.d0 ! @@ -1067,14 +1067,14 @@ subroutine osc_cathodeimages_solver(rho,gam0,umin,delta,phi,efield,bfield,nlo,nh endif ! idirectfieldcalc ! set the magnetic field: -gb0=sqrt((gam0+1.d0)*(gam0-1.d0)) +beta0=sqrt(1-1/gam0**2) do k=lbound(phi,3),ubound(phi,3) do j=lbound(phi,2),ubound(phi,2) do i=lbound(phi,1),ubound(phi,1) -! bfield(i,j,k,1)=-efield(i,j,k,2)/clight/gb0/gam0 -! bfield(i,j,k,2)= efield(i,j,k,1)/clight/gb0/gam0 - bfield(i,j,k,1)=-(efield(i,j,k,2)+2.d0*efieldimg(i,j,k,2))/clight/gb0/gam0 !I subtracted efieldimg above, - bfield(i,j,k,2)= (efield(i,j,k,1)+2.d0*efieldimg(i,j,k,1))/clight/gb0/gam0 !so add it back 2x to get sum +! bfield(i,j,k,1)=-efield(i,j,k,2)*beta0/clight +! bfield(i,j,k,2)= efield(i,j,k,1)*beta0/clight + bfield(i,j,k,1)=-(efield(i,j,k,2)+2.d0*efieldimg(i,j,k,2))*beta0/clight !I subtracted efieldimg above, + bfield(i,j,k,2)= (efield(i,j,k,1)+2.d0*efieldimg(i,j,k,1))*beta0/clight !so add it back 2x to get sum bfield(i,j,k,3)=0.d0 enddo enddo diff --git a/code/open_spacecharge_mod.f90 b/code/open_spacecharge_mod.f90 index 3ed68b4..0d2b6c2 100644 --- a/code/open_spacecharge_mod.f90 +++ b/code/open_spacecharge_mod.f90 @@ -70,10 +70,11 @@ subroutine space_charge_freespace(mesh3d, direct_field_calc, integrated_green_fu if(present(integrated_green_function) .and. .not. integrated_green_function) igfflag = 0 call osc_freespace_solver(mesh3d%rho, mesh3d%gamma, & - mesh3d%delta(1), mesh3d%phi, mesh3d%efield, mesh3d%bfield, & + mesh3d%delta, mesh3d%phi, mesh3d%efield, mesh3d%bfield, & mesh3d%nlo, mesh3d%nhi, mesh3d%nlo, mesh3d%nhi, mesh3d%npad, idirectfieldcalc,igfflag) end subroutine + !------------------------------------------------------------------------ !------------------------------------------------------------------------ !------------------------------------------------------------------------ @@ -389,4 +390,353 @@ subroutine interpolate_field(x, y, z, mesh3d, E, B) end subroutine +!------------------------------------------------------------------------ +!+ +! Subroutine space_charge_3d(mesh3d, offset, at_cathode, calc_bfield) +! +! Performs the space charge calculation using the integrated Green function method +! and FFT-based convolutions. +! +! Input: +! mesh3d -- mesh3d_struct: populated with %rho +! +! offset -- real(3), optional: Offset coordinates x0, y0, z0 to evaluate the field, +! relative to rho. +! Default: (0,0,0) +! For example, an offset of (0,0,10) can be used to compute +! the field at z=+10 m relative to rho. +! +! at_cathode -- logical, optional: Maintain constant voltage at the cathode +! using image charges. Default is False. +! +! calc_bfield -- logical, optional: Calculate the magnetic field mesh3d%bfield +! +! Default: False +! +! +! Output: +! mesh3d -- mesh3d_struct: populated with %efield, and optionally %bfield +! +! +! +! Notes: +! The magnetic field components can be calculated by: +! Bx = -(beta/c) * Ey +! By = (beta/c) * Ex +! Bz = 0 +! The image charges move in the opposite direction, so the signs are flipped. +! +! +!- +subroutine space_charge_3d(mesh3d, offset, at_cathode, calc_bfield) +type(mesh3d_struct) :: mesh3d +real(dp), allocatable, dimension(:,:,:,:) :: image_efield ! electric field grid +real(dp), optional :: offset(3) +real(dp) :: offset0(3), beta +real(dp), parameter :: c_light = 299792458.0 +logical, optional :: at_cathode, calc_bfield +logical :: bcalc + +if (present(calc_bfield)) then + bcalc = calc_bfield +else + bcalc = .false. +endif + +if (.not. present(offset)) then + offset0 = 0 +else + offset0 = offset +endif + +! Free space field +call osc_freespace_solver2(mesh3d%rho, mesh3d%gamma, mesh3d%delta, efield=mesh3d%efield, offset=offset0) + +! Optional B field +if (bcalc) then + beta = sqrt(1-1/mesh3d%gamma**2) + mesh3d%bfield = 0 + mesh3d%bfield(:,:,:,1) = -(beta/c_light)*mesh3d%efield(:,:,:,2) + mesh3d%bfield(:,:,:,2) = (beta/c_light)*mesh3d%efield(:,:,:,1) +endif + +! Cathode calc +if (.not. present(at_cathode)) return +if (.not. at_cathode) return + +! Allocate scratch array for the image field +allocate(image_efield, mold=mesh3d%efield) + +! Image field, with an offset assuming the cathode is at z=0. +! The offset is the z width of the mesh, plus 2 times the distance of the mesh from the cathode. +offset0(3) = offset0(3) + 2*mesh3d%min(3) + (mesh3d%max(3)-mesh3d%min(3)) + +! Flip the charge mesh in z, with opposite charge sign +call osc_freespace_solver2(-mesh3d%rho(:,:,size(mesh3d%rho,3):1:-1), & + mesh3d%gamma, mesh3d%delta, efield=image_efield, offset=offset0) + + +! Finally add fields + +if (bcalc) then + ! Opposite sign for beta, because image charges are moving in the negative z direction + mesh3d%bfield(:,:,:,1) = mesh3d%bfield(:,:,:,1) + (beta/c_light)*image_efield(:,:,:,2) + mesh3d%bfield(:,:,:,2) = mesh3d%bfield(:,:,:,2) - (beta/c_light)*image_efield(:,:,:,1) +endif + +mesh3d%efield = mesh3d%efield + image_efield + +end subroutine + + + +!------------------------------------------------------------------------ +!+ +! Subroutine osc_freespace_solver2(rho, gamma, delta, efield, phi, offset) +! +! Deposits particle arrays onto mesh +! +! Input: +! rho -- REAL64(:,:,:): charge density array in x, y, z +! delta -- REAL64(3): vector of grid spacings dx, dy, dz +! gamma -- REAL64: relativistic gamma +! icomp -- integer: Field component requested: +! 0: phi (scalar potential) +! +! +! efield -- REAL64(:,:,:,3), optional: allocated electric field array to populate. +! +! The final index corresponds to components +! 1: Ex +! 2: Ey +! 3: Ez +! If present, all components will be computed. +! +! phi -- REAL64(:,:,:), optional: allocated potential array to populate +! +! offset -- real(3), optional: Offset coordinates x0, y0, z0 to evaluate the field, +! relative to rho. +! Default: (0,0,0) +! For example, an offset of (0,0,10) can be used to compute +! the field at z=+10 m relative to rho. +! +! Output: +! efield -- REAL64(:,:,:,:) : electric field +! phi -- REAL64(:,:,:) : potential +! +! +! Notes: +! The magnetic field components can be calculated by: +! Bx = -(beta/c) * Ey +! By = (beta/c) * Ex +! Bz = 0 +! +!- +subroutine osc_freespace_solver2(rho, gamma, delta, efield, phi, offset) + + +real(dp), intent(in), dimension(:,:,:) :: rho +real(dp), intent(in) :: gamma, delta(3) +real(dp), optional, intent(out), dimension(:,:,:,:) :: efield +real(dp), optional, intent(out), dimension(:,:,:) :: phi +real(dp), intent(in), optional :: offset(3) +! internal arrays +complex(dp), allocatable, dimension(:,:,:) :: crho, cgrn +real(dp) :: factr, offset0=0 +real(dp), parameter :: clight=299792458.0 +real(dp), parameter :: fpei=299792458.0**2*1.00000000055d-7 ! this is 1/(4 pi eps0) after the 2019 SI changes + +integer :: nx, ny, nz, nx2, ny2, nz2 +integer :: icomp, ishift, jshift, kshift + +! Sizes +nx = size(rho, 1); ny = size(rho, 2); nz = size(rho, 3) +nx2 = 2*nx; ny2 = 2*ny; nz2 = 2*nz; + +! Allocate complex scratch arrays +allocate(crho(nx2, ny2, nz2)) +allocate(cgrn(nx2, ny2, nz2)) + +! rho -> crho -> FFT(crho) +crho = 0 +crho(1:nx, 1:ny, 1:nz) = rho ! Place in one octant +call ccfft3d(crho, crho, [1,1,1], nx2, ny2, nz2, 0) + +! Loop over phi, Ex, Ey, Ez +do icomp=0, 3 + if ((icomp == 0) .and. (.not. present(phi))) cycle + if ((icomp == 1) .and. (.not. present(efield))) exit + + call osc_get_cgrn_freespace(cgrn, delta, gamma, icomp, offset=offset) + + ! cgrn -> FFT(cgrn) + call ccfft3d(cgrn, cgrn, [1,1,1], nx2, ny2, nz2, 0) + + ! Multiply FFT'd arrays, re-use cgrn + cgrn=crho*cgrn + + ! Inverse FFT + call ccfft3d(cgrn, cgrn, [-1,-1,-1], nx2, ny2, nz2, 0) + + ! This is where the output is shifted to + ishift = nx-1 + jshift = ny-1 + kshift = nz-1 + + ! Extract field + factr = fpei/(nx2*ny2*nz2) + + if (icomp == 0) then + phi(:,:,:) = factr * real(cgrn(1+ishift:nx+ishift, 1+jshift:ny+jshift, 1+kshift:nz+kshift), dp) + else + efield(:,:,:,icomp) = factr * real(cgrn(1+ishift:nx+ishift, 1+jshift:ny+jshift, 1+kshift:nz+kshift), dp) + endif + +enddo + +end subroutine osc_freespace_solver2 + + +!------------------------------------------------------------------------ +!+ +! Subroutine osc_get_cgrn_freespace(cgrn, delta, gamma, icomp, offset) +! +! Computes the free space Green function on a mesh with given spacings in the lab frame. +! The computation is performed in the rest fram by boosting the coordinates by gamma. +! +! +! Input: +! cgrn -- COMPLEX128(:,:,:): pre-allocated array +! delta -- REAL64(3): vector of grid spacings dx, dy, dz +! gamma -- REAL64: relativistic gamma +! icomp -- integer: Field component requested: +! 0: phi (scalar potential) +! 1: Ex +! 2: Ey +! 3: Ez +! offset -- real(3), optional: Offset coordinates for the center of the grid in [m]. +! Default: (0,0,0) +! For example, an offset of (0,0,10) can be used to compute +! the field at z=+10 m relative to the rho_mesh center. +! +! Output: +! cgrn -- COMPLEX128(:,:,:): Green function array +! +! +! Notes: +! Internally, dz -> dz*gamma. +! For efficients, the indefinite functions lafun2, xlafun2 are actually evaluated +! on a grid slightly offset by -dx/2, -dy/2, -dz/2, +! and these points are used to evaluate the integral with array addition and subtraction. +! +!- +subroutine osc_get_cgrn_freespace(cgrn, delta, gamma, icomp, offset) + +complex(dp), intent(out), dimension(0:,0:,0:) :: cgrn ! Convenient indexing +real(dp), intent(in), dimension(3) :: delta +integer, intent(in) :: icomp +real(dp), intent(in) :: gamma +real(dp), intent(in), optional :: offset(3) +! Local +real(dp) :: dx,dy,dz +real(dp) :: u,v,w, umin, vmin, wmin +real(dp) :: gval, factor +integer :: imin, imax, jmin, jmax, kmin, kmax +integer :: i,j,k, isize, jsize, ksize + +! Mesh spacings. dz is stretched in the rest frame. +dx=delta(1); dy=delta(2); dz=delta(3)*gamma + +! Special cases: Ex and Ey are enhanced by gamma +if ((icomp==1) .or. (icomp==2)) then + factor = gamma /(dx*dy*dz) +else + factor = 1.0 /(dx*dy*dz) +endif + +! Evaluate on an offset grid, for use in the indefinite integral evaluation below. +isize = size(cgrn,1); jsize=size(cgrn,2); ksize=size(cgrn,3) +umin = (0.5-isize/2) *dx +vmin = (0.5-jsize/2) *dy +wmin = (0.5-ksize/2) *dz + +! Add optional offset +if (present(offset)) then + umin = umin + offset(1) + vmin = vmin + offset(2) + wmin = wmin + offset(3)*gamma ! Don't forget this! +endif + +! !$ print *, 'OpenMP Green function calc osc_get_cgrn_freespace' +!$OMP PARALLEL DO & +!$OMP DEFAULT(FIRSTPRIVATE), & +!$OMP SHARED(cgrn) +do k = 0, ksize-1 + w = k*dz + wmin + + do j=0, jsize-1 + v=j*dy + vmin + + do i=0, isize-1 + u = i*dx + umin + + if(icomp == 0) gval=lafun2(u,v,w)*factor + if(icomp == 1) gval=xlafun2(u,v,w)*factor + if(icomp == 2) gval=xlafun2(v,w,u)*factor + if(icomp == 3) gval=xlafun2(w,u,v)*factor + cgrn(i,j,k)= cmplx(gval, 0, dp) + + enddo + enddo +enddo +!$OMP END PARALLEL DO + +! Evaluate the indefinite integral over the cube +!cgrn = cgrn(1:,1:,1:) - cgrn(:-1,1:,1:) - cgrn(1:,:-1,1:) - cgrn(1:,1:,:-1) - cgrn(:-1,:-1,:-1) + cgrn(:-1,:-1,1:) + cgrn(:-1,1:,:-1) + cgrn(1:,:-1,:-1) +! (x2,y2,z2) - (x1,y2,z2) - (x2,y1,z2) - (x2,y2,z1) - (x1,y1,z1) + (x1,y1,z2) + (x1,y2,z1) + (x2,y1,z1) +cgrn = cgrn(1:,1:,1:) - cgrn(0:,1:,1:) - cgrn(1:,0:,1:) - cgrn(1:,1:,0:) - cgrn(0:,0:,0:) + cgrn(0:,0:,1:) + cgrn(0:,1:,0:) + cgrn(1:,0:,0:) + +end subroutine osc_get_cgrn_freespace + + +!------------------------------------------------------------------------ +!+ +! elemental real(dp) function xlafun2(x, y, z) +! +! The indefinite integral: +! \int x/r^3 dx dy dz = x*atan((y*z)/(r*x)) -z*log(r+y) + y*log((r-z)/(r+z))/2 +! +! This corresponds to the electric field component Ex. +! Other components can be computed by permuting the arguments +! +!- +elemental real(dp) function xlafun2(x, y, z) + real(dp), intent(in) :: x, y, z + real(dp) :: r + r=sqrt(x**2+y**2+z**2) + xlafun2 = x*atan((y*z)/(r*x)) -z*log(r+y) + y*log((r-z)/(r+z))/2 +end function + +!------------------------------------------------------------------------ +!+ +! elemental real(dp) function lafun2(x,y,z) +! +! The indefinite integral: +! \int 1/r^3 dx dy dz = +! -z**2*atan(x*y/(z*r))/2 - y**2*atan(x*z/(y*r))/2 -x**2*atan(y*z/(x*r))/2 +! +y*z*log(x+r) + x*z*log(y+r) + x*y*log(z+r) +! +! This corresponds to the scalar potential. +! Other components can be computed by permuting the arguments +! +!- +elemental real(dp) function lafun2(x,y,z) + real(dp), intent(in) :: x, y, z + real(dp) :: r + r=sqrt(x**2+y**2+z**2) + lafun2 = -z**2*atan(x*y/(z*r))/2 - y**2*atan(x*z/(y*r))/2 -x**2*atan(y*z/(x*r))/2 & + +y*z*log(x+r) + x*z*log(y+r) + x*y*log(z+r) +end function + + end module diff --git a/code/test_opensc.f90 b/code/test_opensc.f90 index fb33b33..8a05d73 100644 --- a/code/test_opensc.f90 +++ b/code/test_opensc.f90 @@ -55,7 +55,7 @@ program opensc_test integer :: nxlo,nxhi,nylo,nyhi,nzlo,nzhi namelist / opensc_test_params / & nxlo,nxhi,nylo,nyhi,nzlo,nzhi, n_particle, e_tot, bunch_charge, sigma_x, sigma_y, sigma_z, gaussiancutoff, & - direct_field_calc, integrated_green_function, cathode_images, image_method,& + direct_field_calc, integrated_green_function, cathode_images, image_method,disttype,& rectpipe, read_rectpipe, write_rectpipe, apipe, bpipe ! if rectangular pipe BC is being used, apipe=full width, bpipe=full height !Namelist defaults @@ -67,11 +67,11 @@ program opensc_test bunch_charge=0.25d-9 sigma_x = 0.001d0; sigma_y = 0.001d0; sigma_z = 0.0001d0 gaussiancutoff=4 -disttype=0 ! =0 for uniform, =1 for Gaussian +disttype=1 ! =0 for uniform, =1 for Gaussian direct_field_calc = .true. ! .false. integrated_green_function = .true. -cathode_images=.true. -image_method=2 ! =1 for convolution/correlation, =2 for shifted Green function +cathode_images=.false. +image_method=3 ! =1 for convolution/correlation, =2 for shifted Green function , =3 Chris' method rectpipe=.false. read_rectpipe=.false. write_rectpipe=.false. @@ -154,6 +154,7 @@ program opensc_test write(6,*)'delta(1:3)=',delta(1:3) call depose_rho_scalar(ptcl(:,1),ptcl(:,3),ptcl(:,5),lostflag,rho,chrgpermacro,nlo,delta,umin,n_particle,nlo,ifail) + write(6,*)'Done with charge deposition' mesh3d%nlo = [nxlo, nylo, nzlo] @@ -176,13 +177,28 @@ program opensc_test if(.not.rectpipe.and..not.cathode_images)then !FREE SPACE print *, 'Space charge field calc with free-space boundary condition...' !!call osc_freespace_solver(rho,gamma,delta,phi,efield,bfield,nlo,nhi,nlo,nhi,npad,idirectfieldcalc,igfflag) - call space_charge_freespace(mesh3d, direct_field_calc, integrated_green_function) + !mesh3d%rho(:,:,33:)=0 + !call space_charge_freespace(mesh3d, direct_field_calc, integrated_green_function) + ! New method + print *, "Chris' method" + call space_charge_3d(mesh3d, calc_bfield=.true.) + endif if(.not.rectpipe.and.cathode_images)then !FREE SPACE BUT WITH CATHODE IMAGES print *, 'Space charge field calc with cathode images...' if(umin(3).lt.0.d0)write(6,*)'error: umin(3) is less than zcathode!' if(umin(3).lt.0.d0)stop - call space_charge_cathodeimages(mesh3d, direct_field_calc, integrated_green_function, image_method) + + if (image_method == 3) then + print *, "Chris' method" + call space_charge_3d(mesh3d, at_cathode=.true., calc_bfield=.true.) + + else + call space_charge_cathodeimages(mesh3d, direct_field_calc, integrated_green_function, image_method) + endif + + + endif if(rectpipe)then !RECTANGULAR PIPE print *, 'Space charge field calc with rectangular pipe boundary condition...' @@ -261,17 +277,18 @@ subroutine write_lines(mesh3d,xcent,ycent,zcent) subroutine write_plane(mesh3d) type(mesh3d_struct) :: mesh3d -real(dp) :: x, y, z, Evec(3) +real(dp) :: x, y, z, Evec(3), Bvec(3) integer :: i, k, outfile -open(newunit=outfile, file = 'x_z_Ex_Ez.dat') +open(newunit=outfile, file = 'x_z_Ex_Ez_By.dat') y = 0 do k = mesh3d%nlo(3), mesh3d%nhi(3) -1 ! skip last point z = (k-1)*mesh3d%delta(3) + mesh3d%min(3) do i = mesh3d%nlo(1), mesh3d%nhi(1) -1 ! skip last point x = (i-1)*mesh3d%delta(1) + mesh3d%min(1) call interpolate_field(x, y, z, mesh3d, E=Evec) - write(outfile, *) x, z, Evec(1), Evec(3) + call interpolate_field(x, y, z, mesh3d, B=Bvec) + write(outfile, *) x, z, Evec(1), Evec(3), Bvec(2) enddo enddo close(outfile) diff --git a/examples/benchmark.ipynb b/examples/benchmark.ipynb new file mode 100644 index 0000000..39afd62 --- /dev/null +++ b/examples/benchmark.ipynb @@ -0,0 +1,935 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "written-thesaurus", + "metadata": {}, + "source": [ + "# OpenSpaceCharge tests\n", + "\n", + "This notebook will run the test_opensc program, and reproduce the benchmark plots in:\n", + "\n", + "C. E. Mayes, R. D. Ryne, D. C. Sagan, *3D Space Charge in Bmad*, IPAC2018, Vancouver, BC, Canada\n", + "https://accelconf.web.cern.ch/ipac2018/papers/thpak085.pdf\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ambient-matthew", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "import subprocess\n", + "import tempfile\n", + "import os\n", + "import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib\n", + "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", + "matplotlib.rcParams['figure.figsize'] = (8,6)\n", + "%config InlineBackend.figure_format = 'retina'" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "crude-liberal", + "metadata": {}, + "outputs": [], + "source": [ + "# Executable \n", + "TEST_BIN = os.path.abspath('../build/test_opensc')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "general-lobby", + "metadata": {}, + "outputs": [], + "source": [ + "# Change any of this to test\n", + "\n", + "PARAMS = \"\"\"\n", + "&OPENSC_TEST_PARAMS\n", + " NXLO=1 ,\n", + " NXHI=64 ,\n", + " NYLO=1 ,\n", + " NYHI=64 ,\n", + " NZLO=1 ,\n", + " NZHI=128 ,\n", + " N_PARTICLE=1000000 ,\n", + " E_TOT= 5e6 ,\n", + " BUNCH_CHARGE= 1e-9,\n", + " DISTTYPE = 1, \n", + " SIGMA_X= 1e-3,\n", + " SIGMA_Y= 1e-3,\n", + " SIGMA_Z= 1e-4,\n", + " GAUSSIANCUTOFF= 4 ,\n", + " DIRECT_FIELD_CALC=T,\n", + " INTEGRATED_GREEN_FUNCTION=T,\n", + " CATHODE_IMAGES=F,\n", + " IMAGE_METHOD=1 ,\n", + " RECTPIPE=F,\n", + " READ_RECTPIPE=F,\n", + " WRITE_RECTPIPE=F,\n", + " APIPE= 1.2000000000000000E-002,\n", + " BPIPE= 1.2000000000000000E-002,\n", + " /\n", + "\n", + "\"\"\"\n", + "\n", + "with open('test.in', 'w') as f:\n", + " f.write(PARAMS)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "quantitative-pavilion", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ------------------------\n", + "&OPENSC_TEST_PARAMS\n", + " NXLO=1 ,\n", + " NXHI=64 ,\n", + " NYLO=1 ,\n", + " NYHI=64 ,\n", + " NZLO=1 ,\n", + " NZHI=128 ,\n", + " N_PARTICLE=1000000 ,\n", + " E_TOT= 5000000.0000000000 ,\n", + " BUNCH_CHARGE= 1.0000000000000001E-009,\n", + " SIGMA_X= 1.0000000000000000E-003,\n", + " SIGMA_Y= 1.0000000000000000E-003,\n", + " SIGMA_Z= 1.0000000000000000E-004,\n", + " GAUSSIANCUTOFF= 4.0000000000000000 ,\n", + " DIRECT_FIELD_CALC=T,\n", + " INTEGRATED_GREEN_FUNCTION=T,\n", + " CATHODE_IMAGES=F,\n", + " IMAGE_METHOD=1 ,\n", + " DISTTYPE=1 ,\n", + " RECTPIPE=F,\n", + " READ_RECTPIPE=F,\n", + " WRITE_RECTPIPE=F,\n", + " APIPE= 1.2000000000000000E-002,\n", + " BPIPE= 1.2000000000000000E-002,\n", + " /\n", + " ------------------------\n", + " gamma= 9.7847566837275650 \n", + " beta0= 0.99476389387590491 \n", + " particle xmin,xmax= -3.9826073840537940E-003 3.9869615736364229E-003\n", + " particle ymin,ymax= -3.9509672876726944E-003 3.9790345163215803E-003\n", + " particle zmin,zmax= -3.8981835420025880E-004 3.9605290566242015E-004\n", + " added zcentroid to z particle data, where zcentroid= 0.0000000000000000 \n", + " Done computing initial 3D Gaussian spatial distribution w/ cold velocity distribution\n", + " mesh xmin,xmax= -4.1132560554917492E-003 4.1176102450743799E-003\n", + " mesh ymin,ymax= -4.0809673172467788E-003 4.1090345458956682E-003\n", + " mesh zmin,zmax= -3.9610532427919985E-004 4.0233987574136174E-004\n", + " delta(1:3)= 1.3064867143755760E-004 1.3000002957368962E-004 6.2869700789020598E-006\n", + " Done with charge deposition\n", + " Space charge field calc with free-space boundary condition...\n", + " Chris' method\n", + " ...done\n", + " Time for space charge calc (s): 6.4767380000000001 \n" + ] + } + ], + "source": [ + "!../build/test_opensc test.in" + ] + }, + { + "cell_type": "markdown", + "id": "academic-cambridge", + "metadata": {}, + "source": [ + "# Parsers\n", + "\n", + "Simple parsers for the line output and grid output text files" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "green-corps", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 367, + "width": 492 + }, + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Simple parser\n", + "def parse_lineout(file):\n", + " rdat = np.loadtxt(file)\n", + " columns = ['x', 'y', 'z', 'Ex', 'Ey', 'Ez']\n", + " return {name:rdat[:,i] for i, name in enumerate(columns)}\n", + "\n", + "dat = parse_lineout('x_lineout.dat')\n", + "plt.plot(dat['x'], dat['Ex'])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "complete-concord", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 367, + "width": 492 + }, + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "dat = parse_lineout('z_lineout.dat')\n", + "plt.plot(dat['z'], dat['Ez'])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "appreciated-pension", + "metadata": {}, + "outputs": [], + "source": [ + "# Simple parser\n", + "def parse_plane(file):\n", + " \"\"\"\n", + " \n", + " \n", + " \"\"\"\n", + " rdat = np.loadtxt(file)\n", + " columns = ['x', 'z', 'Ex', 'Ez', 'By']\n", + " pdat = {name:rdat[:,i] for i, name in enumerate(columns)}\n", + " \n", + " zvec = sorted(list(set(pdat['z'])))\n", + " xvec = sorted(list(set(pdat['x']))) \n", + " nx, nz = len(xvec), len(zvec)\n", + " dat = {}\n", + " dat['zvec'] = np.array(zvec)\n", + " dat['xvec'] = np.array(zvec) \n", + " dat['Ex'] = pdat['Ex'].reshape(nz, nx).T\n", + " dat['Ez'] = pdat['Ez'].reshape(nz, nx).T\n", + " dat['By'] = pdat['By'].reshape(nz, nx).T\n", + " return dat\n", + " \n", + "\n", + "dat = parse_plane('x_z_Ex_Ez_By.dat')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "handed-jesus", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 277, + "width": 1056 + }, + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def plot_plane(dat):\n", + " zmin, zmax, xmin, xmax = dat['zvec'].min(), dat['zvec'].max(), dat['xvec'].min(), dat['xvec'].max()\n", + " \n", + " fig, axes = plt.subplots(1,3, figsize=(18,4))\n", + " \n", + " for ax, name, unit in zip(axes, ['Ex', 'Ez', 'By'], ['V/m', 'V/m', 'T']):\n", + " im = ax.imshow(dat[name], origin='lower', extent=[xmin, xmax, zmin, zmax])\n", + " divider = make_axes_locatable(ax)\n", + " cax = divider.append_axes('right', size='5%', pad=0.05)\n", + " fig.colorbar(im, cax=cax, orientation='vertical')\n", + " \n", + " ax.set_title(f'{name} ({unit})')\n", + " ax.set_xlabel('z (m)')\n", + " ax.set_ylabel('x (m)') \n", + "plot_plane(dat)" + ] + }, + { + "cell_type": "markdown", + "id": "green-activity", + "metadata": {}, + "source": [ + "# Paper results\n", + "\n", + "Reproduce plots in:\n", + "\n", + "C. E. Mayes, R. D. Ryne, D. C. Sagan, *3D Space Charge in Bmad*, IPAC2018, Vancouver, BC, Canada\n", + "https://accelconf.web.cern.ch/ipac2018/papers/thpak085.pdf" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "under-glory", + "metadata": {}, + "outputs": [], + "source": [ + "def set_params(filename='params.in', sigma_z=1e-3, sigma_x=1e-3):\n", + " params = f\"\"\"\n", + " &OPENSC_TEST_PARAMS\n", + " NXLO=1 ,\n", + " NXHI=128 ,\n", + " NYLO=1 ,\n", + " NYHI=128 ,\n", + " NZLO=1 ,\n", + " NZHI=128 ,\n", + " N_PARTICLE=10000000 ,\n", + " E_TOT= 0.51099891e6 ,\n", + " BUNCH_CHARGE= 1e-9,\n", + " DISTTYPE = 1,\n", + " SIGMA_X= {sigma_x},\n", + " SIGMA_Y= 1.0000000000000000E-003,\n", + " SIGMA_Z= {sigma_z},\n", + " GAUSSIANCUTOFF= 6 ,\n", + " DIRECT_FIELD_CALC=T,\n", + " INTEGRATED_GREEN_FUNCTION=T,\n", + " CATHODE_IMAGES=F,\n", + " IMAGE_METHOD=3 ,\n", + " RECTPIPE=F,\n", + " READ_RECTPIPE=F,\n", + " WRITE_RECTPIPE=F,\n", + " APIPE= 1.2000000000000000E-002,\n", + " BPIPE= 1.2000000000000000E-002,\n", + " /\n", + " \n", + " \"\"\"\n", + " with open(filename, 'w') as f:\n", + " f.write(params)\n", + "set_params() " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "generic-necklace", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ------------------------\n", + "&OPENSC_TEST_PARAMS\n", + " NXLO=1 ,\n", + " NXHI=128 ,\n", + " NYLO=1 ,\n", + " NYHI=128 ,\n", + " NZLO=1 ,\n", + " NZHI=128 ,\n", + " N_PARTICLE=10000000 ,\n", + " E_TOT= 510998.90999999997 ,\n", + " BUNCH_CHARGE= 1.0000000000000001E-009,\n", + " SIGMA_X= 1.0000000000000000E-003,\n", + " SIGMA_Y= 1.0000000000000000E-003,\n", + " SIGMA_Z= 1.0000000000000000E-003,\n", + " GAUSSIANCUTOFF= 6.0000000000000000 ,\n", + " DIRECT_FIELD_CALC=T,\n", + " INTEGRATED_GREEN_FUNCTION=T,\n", + " CATHODE_IMAGES=F,\n", + " IMAGE_METHOD=3 ,\n", + " DISTTYPE=1 ,\n", + " RECTPIPE=F,\n", + " READ_RECTPIPE=F,\n", + " WRITE_RECTPIPE=F,\n", + " APIPE= 1.2000000000000000E-002,\n", + " BPIPE= 1.2000000000000000E-002,\n", + " /\n", + " ------------------------\n", + " gamma= 1.0000000000000000 \n", + " beta0= 0.0000000000000000 \n", + " particle xmin,xmax= -5.1371331804109365E-003 5.2486260066664289E-003\n", + " particle ymin,ymax= -5.1327292599210534E-003 5.1362984650888356E-003\n", + " particle zmin,zmax= -5.1727941411408721E-003 5.5060669996351945E-003\n", + " added zcentroid to z particle data, where zcentroid= 0.0000000000000000 \n", + " Done computing initial 3D Gaussian spatial distribution w/ cold velocity distribution\n", + " mesh xmin,xmax= -5.2202192539080776E-003 5.3317120801635804E-003\n", + " mesh ymin,ymax= -5.2148814817216532E-003 5.2184506868894372E-003\n", + " mesh zmin,zmax= -5.2582250302676062E-003 5.5914978887619624E-003\n", + " delta(1:3)= 8.3086073496627225E-005 8.2152221800087325E-005 8.5430889126217069E-005\n", + " Done with charge deposition\n", + " Space charge field calc with free-space boundary condition...\n", + " Chris' method\n", + " ...done\n", + " Time for space charge calc (s): 26.418604000000002 \n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 277, + "width": 1056 + }, + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def run_test(verbose=False, **params):\n", + " dat = {}\n", + " tdir = tempfile.TemporaryDirectory()\n", + " fname = os.path.join(tdir.name, 'params.in')\n", + " set_params(filename=fname, **params)\n", + " t0 = time.time()\n", + " res = subprocess.run([TEST_BIN, 'params.in'], cwd=tdir.name, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n", + " dat['run_time'] = time.time() - t0\n", + " if verbose:\n", + " print(res.stdout.decode('utf-8'))\n", + "\n", + " \n", + " dat['x_line'] = parse_lineout(os.path.join(tdir.name, 'x_lineout.dat'))\n", + " dat['z_line'] = parse_lineout(os.path.join(tdir.name, 'z_lineout.dat'))\n", + " dat['xz_plane'] = parse_plane(os.path.join(tdir.name, 'x_z_Ex_Ez_By.dat'))\n", + "\n", + " return dat\n", + "\n", + "DAT = run_test(verbose=True) \n", + "plot_plane(DAT['xz_plane'])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "cross-macintosh", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 535 ms, sys: 33.4 ms, total: 569 ms\n", + "Wall time: 2min 1s\n" + ] + } + ], + "source": [ + "%%time\n", + "# Run various ratios\n", + "ALLDAT = {}\n", + "for ratio in [.01, .1, 1, 10]:\n", + " sigma_x = 0.001\n", + " sigma_z = ratio*sigma_x\n", + " ALLDAT[ratio] = run_test(sigma_x=sigma_x, sigma_z=sigma_z) " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "unnecessary-newark", + "metadata": {}, + "outputs": [], + "source": [ + "# To plot the charge density. Ignore the normalization.\n", + "def gauss(x):\n", + " return np.exp(-x**2/2)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "sorted-politics", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABDAAAAKCCAYAAAAnRilSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAABYlAAAWJQFJUiTwAADd30lEQVR4nOzdeXycVdn/8c+ZzEz2pE3SNN3oRjeWtkBpS4GyV0AU3MBHURD19yA+IrggigooiAqyCYIbLqCyKpuIBVq2FgqlCxS6r3RJ0mZPZp85vz/uzCRpkzbLJDNJvu/X67zumXPfc+4rbSgz15xzHWOtRUREREREREQknblSHYCIiIiIiIiIyKEogSEiIiIiIiIiaU8JDBERERERERFJe0pgiIiIiIiIiEjaUwJDRERERERERNKeEhgiIiIiIiIikvaUwBARERERERGRtKcEhoiIiIiIiIikPSUwRERERERERCTtKYEhIiIiIiIiImlPCQwRERERERERSXtKYIiIiIiIiIhI2lMCQ0RERERERETSnhIYIiIiIiIiIpL2Bn0CwxjzaWPMr40xrxlj6o0x1hjz0CFeM88Y85wxptoY4zPGvGuMucoYk9GN+ydtLBEREREREZGByp3qANLAD4EZQCOwE5h6sIuNMecDTwAB4BGgGvgYcAdwIvCZzt44mWOJiIiIiIiIDGTGWpvqGFLKGHMaTuJiE3AKsBj4m7X24nauLWi+rhA40Vq7vLk/C1gEnAD8j7X24U7cN2ljiYiIiIiIiAx0g34JibV2sbV2o+1cJufTwDDg4XjCoXmMAM5MDoCvdfLWyRxLREREREREZEAb9AmMLjq9+fh8O+deBXzAPGNMZh+PJSIiIiIiIjKgKYHRNVOajxv2P2GtjQBbceqKTOjjsUREREREREQGNBXx7JrC5mNdB+fj/UP6cixjzDsdnDqm+ejvRDwiIiIiIiLSv2QDUWutJ9WB9AUlMJLLNB+TURk1GWMZgOzs7JyehyMiIiIiIiLpxO/3A2SkOo6+ogRG18RnRRR2cL5gv+v6ZCxr7XHt9RtjmrKzs3N8Pl8nwhEREREREZH+JCcnB39zFmMwUA2MrlnffJy8/wljjBsYD0SALX08loiIiIiIiMiApgRG1yxqPp7dzrn5QA6w1Fob7OOxRERERERERAY0JTC65nFgH/BZY8yseKcxJgu4qfnpfa1fYIwpNMZMNcaM6OlYIiIiIiIiIoPVoK+BYYy5ALig+WlZ8/EEY8yfmx/vs9Z+B8BaW2+M+SpO8uFlY8zDQDXwcZxtUR8HHtnvFp8A/gT8Bbg03tnNsUREREREREQGpUGfwABmApfs1zehuQFsB74TP2GtfdIYcwpwHfApIAvYBHwLuNta2+ldQ5I5loiIiIiIiMhAZvQZeeDSLiQiIiIiIiIDV/MuJD5rbW6qY+kLqoEhIiIiIiIiImlPS0hERERERET6uVgsRnV1NQ0NDQSDQTTTvv8xxpCZmUl+fj5FRUW4XJpvsD8lMERERERERPqxWCzGhx9+iJaO92/WWgKBAIFAgKamJsaMGaMkxn6UwBAREREREenHqqur8fl8uN1uysrKyM3N1QfffigWi9HU1ER5eTk+n4/q6mpKSkpSHVZa0W+1iIiIiIhIP9bQ0ABAWVkZ+fn5Sl70Uy6Xi/z8fMrKyoCWv1dpod9sERERERGRfiwYDAKQmzsoNqIY8OJ/j/G/V2mhBIaIiIiIiEg/Fi/YqZkXA4MxBkCFWNuh33ARERERERGRNBFPYMiBlMAQERERERERkbSnBIaIiIiIiIiIpD0lMEREREREREQGKWPMp40xvzbGvGaMqTfGWGPMQ90ca7Qx5gFjzG5jTNAYs80Yc6cxZmgyYnUnYxARERERERER6Zd+CMwAGoGdwNTuDGKMmQgsBUqBp4B1wGzgm8DZxpgTrbVVPQlUMzBEREREREREBq+rgclAAfC1HozzG5zkxZXW2gustddaa08H7gCmADf3NFAlMEREREREREQGKWvtYmvtRtuDfVuNMROABcA24N79Tl8PNAFfMMbkdjtQlMAQERERERGRNLdt2zaMMVx66aVs2LCBiy66iNLSUlwuFy+//HKqwxM4vfm40Foba33CWtsALAFygLk9uYlqYIiIiMiAEv8CyRiT4khERCTZNm/ezJw5c5g8eTKf//zn8fv9FBQUpDqsVMsyxrzT3glr7XF9FMOU5uOGDs5vxJmhMRl4qbs3UQJDRERE+q1IJEIkEiEcDieO4XCYjIwMsrOzycnJwePxpDpMERFJktdff53vf//7/OxnP0t1KNJWYfOxroPz8f4hPbmJEhgiIiLS7wQCAerq6hKJi2g0mkhmRKNRMjIyyMzMTLScnByys7PJyMhIdegiItIDw4cP5/rrr091GOkm0IczLborPi2y23U2QAkMERER6UestdTX11NfX09DQwPRaBS3201GRgYejyeRpIhGowQCAWpra8nIyCArK4vMzEyys7MZMmQILpfKgImI9EczZswgMzMz1WHIgeIzLAo7OF+w33XdogSGiIiI9AvhcJja2loaGxtpbGxMzKpoj9vtJi8vj9zcXMLhMIFAgKamJnJycohGoxQVFWk2hohIP1RWVpbqEKR965uPkzs4P6n52FGNjE5RAkNERETSXlNTE3V1dTQ0NBAOhyksLMTtPvTbGGMMXq8Xr9dLNBqlrq6OWCyGtZaioqJOjSEiIulDBZrT1uLm4wJjjKv1TiTGmHzgRMAPvNmTm2j+pIiIiKStWCxGTU0NVVVV1NTUADB06NBuJR4yMjIYMmQI4XCYmpoa9u7dSzgcTnbIIiIiA5YxxmOMmWqMmdi631q7GVgIjAO+vt/LbgRygb9aa5t6cn997SAiIiJpq7a2ltraWpqamsjNzSUrK6tH47lcLgoLC6mvr6euzlmGW1RUpPXUIiIyaBljLgAuaH4aX6NzgjHmz82P91lrv9P8eBSwFtiOk6xo7QpgKXC3MeaM5uvmAKfhLB25rqexKoEhIiIiaamhoYGGhgZ8Pl+nl4x0hjGGgoICGhoaqK2tJRaLUVRU1GE9DRERkQFuJnDJfn0Tmhs4yYrvcAjW2s3GmFnAT4CzgXOBPcDdwI3W2uqeBqoEhoiIiKSd+DapDQ0N5OXlJb1WRTyJ0djYSG1tLQAlJSWaiSEiIoOOtfYG4IZOXruNli1R2zv/IfClZMTVHiUwREREJK1EIhFqamqor68nKysLr9fba/fKy8ujsbGR+vp63G43w4YN0xarIiJpaNy4cVhrUx2GpJj+Dy0iIiJpIxaLUV1dTX19PS6Xi5ycnF6/Z25uLtZaGhsbE3UxREREJP0ogSEiIiJpo7a2lsbGRsLhMHl5eX1yT2MM+fn5+Hw+Ghsb8fv9fXJfERER6RotIREREZG00NjYSENDA01NTRQWFvbpUo6MjAxyc3MTS0m8Xi8ZGRl9dn8RERE5NM3AEBERkZQLBoPU1tb2WtHOzsjKysLlctHU1JQo7CkiIiLpQwkMERERSSlrbWLHkczMzJTuBJKfn08gEKCxsZGmpqaUxSEiIiIHUgJDREREUqqpqQmfz0c0Gu2Top0H43K5yM3NTRT0jEQiKY1HREREWiiBISIiIikTi8USdS/y8vIwpsOt5ftMZmYmbrebhoYGampqtG2fiIhImlACQ0RERFKmoaEBn8+Hy+XC6/WmOpyE3NxcwuEwTU1NWkoiIiKSJpTAEBERkZQIh8M0Njbi8/nIzc1NdThtuFwu8vLyaGpqoqGhgVgsluqQREREBj0lMERERCQl6uvraWpqSizZSDderxdjDH6/X7MwRERE0oASGCIiItLnAoEAPp+PYDCY8sKdB5Obm4vf76exsVGzMERERFJMCQwRERHpU9baxOyL7OxsXK70fTvi8XhwuVz4fD4aGxtTHY6IiMiglr7vGERERGRA8vl8+P1+IpEI2dnZqQ7nkHJychKzMKLRaKrDERERGbSUwBAREZE+E982tbGxkdzc3LTYNvVQPB4Pbrc7kcQQERGR1FACQ0RERPpMfNcRYwyZmZmpDqfTcnJy8Pl8NDU1aRaGiEg/sHPnTi677DJGjhxJZmYm48aN46qrrqKmpqbXxgmHw9x111186UtfYubMmYli0H/4wx+S9WMNeulX8ltEREQGpFgslkhgFBQUpDqcLnG73Xg8Hvx+Pw0NDQwZMiTVIYmISAc2b97MvHnzqKys5Pzzz2fq1Km89dZb3HXXXTz//PMsWbKE4uLipI/T1NTEVVddBcDw4cMpKyvjww8/7K0fc1DSDAwRERHpEz6fj0AgQEZGRlpum3oorWdhRCKRVIcjIiIduOKKK6isrOTuu+/mySef5Oc//zmLFi3i6quvZv369Vx33XW9Mk5OTg7PPfccu3fvpry8nMsuu6w3frxBTQkMERER6XXWWpqamvD7/f2icGd73G43Xq83MQtDRETSz5YtW1i4cCHjxo3j61//eptzN954I7m5uTz44IM0NTUlfRyv18s555zDiBEjkvcDSRtKYIiIiEiv8/v9BAIBwHmD11/FdyTx+XyEw+FUhyMiIvtZtGgRAAsWLDhgm+78/HxOPPFEfD4fb775Zp+MI8mlBIaIiIj0uqamJnw+X7+dfRGXkZFBZmYmPp9PO5KIiKSh9evXAzB58uR2z0+aNAmADRs29Mk4klz9bwGqiIiI9CvBYBC/308kEul3xTvbk52dTW1tLX6/n4KCAjIyMlIdkojIQd1obkx1CJ12vb2+R6+vq6sDoLCwsN3z8f7a2to+GUeSSzMwREREpFe1rn1hjEl1OD2WkZGBx+MhEAjg8/lSHY6IiHSBtRagx/8/StY40jVKYIiIiEiviUQi+Hw+QqEQWVlZqQ4nabKyshK1MOJvYkVEJPXiMyPiMyj2V19f3+a63h5HkktLSERERKTXNDY2EggEyMzMPKAIWn/m9XoTP1sgEOj3tT1EZGDr6bKM/mTKlClAx7UpNm7cCHRc2yLZ40hyDZx3EiIiIpJWYrEYPp8Pv98/oGZfxGVnZ2sZiYhImjnttNMAWLhwIbFYrM25hoYGlixZQnZ2NnPnzu2TcSS5lMAQERGRXhGvfeF2u3G7B96kz8zMTEKhUKJAqYiIpN7EiRNZsGAB27Zt4957721z7vrrr6epqYkvfvGL5ObmAhAOh1m3bh2bN2/u0TjSN4zWbQ5cxpim7OzsHH0zJCIifc1aS0VFBVVVVeTm5uL1elMdUq9obGzE5XIxbNgwrYMWkZRZu3YtANOmTUtxJOlh8+bNzJs3j8rKSs4//3ymTZvGsmXLWLx4MZMnT2bp0qUUFxcDsG3bNsaPH8/YsWPZtm1bt8eJ+/nPf866desAWLVqFatXr2bevHmJbVdPOukkvvKVrxzyZ+js32lOTg5+v99nrR0UmZSB93VILzPGXAr86RCXxay1h9xTzRizDRjbwekKa21Z16ITERFJD36/n0AgADBgkxfgFPOsr6/H5/ORn58/oOp8iIj0VxMnTmT58uX8+Mc/5vnnn+e5555jxIgRXHnllVx//fUUFRX12jjPP/88r7zySpu+pUuXsnTp0sTzziQwpH2agdFFxpiZwAUdnD4ZOB34t7X2vE6MtQ0YAtzZzulGa+1t3Ymx1fiagSEiIilRWVlJVVUVmZmZA7L+RWu1tbVkZ2dTWlqqqcQikhKagTHwaAZG+zQDo4ustauAVe2dM8a80fzwd10YstZae0PPohIREUkfoVCIYDBIJBKhoKAg1eH0ungxz6amJiUwREREepHmOSaJMeYoYC6wC/h3isMRERFJGZ/PRyAQICsrC2NMqsPpdV6vl0gkQiAQIBgMpjocERGRAUszMJLnf5uPf7TWRrvwukxjzMXAYUAT8C7wahfHEBERSQvWWvx+P8FgcFDMvgAwxpCVlZXYUjUzMzPVIYmIiAxISmAkgTEmG7gYiAF/6OLLy4AH9+vbaoz5krX2lfZeICIikq7isxBcLteA3Dq1I9nZ2dTU1ODz+SgoKCAj45C1vEVERKSLBs87i951IU4xzn9baz/swuv+BLwGvA80ABOA/wP+H/AfY8wJ1trVhxrEGPNOB6cGdtU0ERFJOz6fj2AwOOhmIbhcLjweT2IWRn5+fqpDEhERGXBUAyM5/l/z8bddeZG19kZr7SJrbYW11metXWOtvRy4HcgGbkhynCIiIr0mGo0SCAQIhUKDLoEBLcU8fT4f2uVNREQk+TQDo4eMMUcA84CdwHNJGvZ+4NvA/M5cbK09roPYmoCcJMUkIiJyUPHinR6PB5dr8H1H4vF4sNYSDAYHbRJHRESkNw2+dxfJ193inQdT2XzUXmwiItJvxIt3ZmUN3hWMmZmZBINB/H5/qkMREREZcJTA6AFjTBbwBZzinX9M4tAnNB+3JHFMERGRXhMKhQgGg0SjUTweT6rDSZl4AiMQCGgZiYiISJIpgdEznwGGAs91VLzTGOMxxkw1xkzcr/9IY0xRO9ePBe5pfvpQsgMWERHpDfHlI1lZWRhjUh1OyrjdbowxiSSGiIiIJI9qYPRMvHjn7w5yzShgLbAdGNeq/zPAtcaYxcBWnF1IJgIfxdk95DngtiTHKyIiknTW2sTykYKCglSHk3JZWVkEAgH8fj/Z2dmpDkdERGTAUAKjm4wx04CT6H7xzsXAFOAYnCUjuUAt8DrwIPCg1dxTERHpBwKBAMFgEJfLhduttxaZmZmJGSmxWGxQFjQVERHpDXqX0U3W2rXAIefIWmu3tXedtfYV4JXkRyYiItK3fD4fwWBQu240iydy4sU8c3NVk1tERCQZ9JWAiIiIdFs0GiUQCGjb0P1oNxIREZHkUwJDREREui2+VMLj8WipRCter5dwOJzYmUVERPrWzp07ueyyyxg5ciSZmZmMGzeOq666ipqamk6P8fjjj/ONb3yDk08+mYKCAowxXHzxxb0YtRyKlpCIiIhIt8WLd+bk5KQ6lLTicrnweDyJYp55eXmpDklEZNDYvHkz8+bNo7KykvPPP5+pU6fy1ltvcdddd/H888+zZMkSiouLDznOTTfdxOrVq8nLy2P06NGsW7euD6KXg9FXJSIiItItoVAoMcPA4/GkOpy0k5WVRTAYxOfzpToUEZFB5YorrqCyspK7776bJ598kp///OcsWrSIq6++mvXr13Pdddd1apw77riDDRs2UF9fz3333dfLUUtnKIEhIiIi3RLffSQzMxNjDlnXetDxeDxEo1GCwSDhcDjV4YiIDApbtmxh4cKFjBs3jq9//ettzt14443k5uby4IMP0tTUdMixTjvtNCZNmqT/x6URJTBERESkW+LLR1S8s33GGBXzFBHpY4sWLQJgwYIFB9Rmys/P58QTT8Tn8/Hmm2+mIjzpISUwREREpMtCoRChUIhYLKblIwfROoFhrU11OCIiA9769esBmDx5crvnJ02aBMCGDRv6LCZJHhXxFBERkS5rvXxEOubxeLDWEgwGtdWsiKRMf1oB0dNcb11dHQCFhYXtno/319bW9uxGkhKagSEiIiJdpgRG52kZiYhI+ojPhlNdi/5JCQwRERHpknA4TDAYJBaL4XZrMuehxBMYgUBAy0hERHpZfIZFfCbG/urr69tcJ/2L3nWIiIhIl/j9/sRyCH2DdWhutxtjDMFgkGAwSFZWVqpDEpFBZjDlTqdMmQJ0XONi48aNQMc1MiS9aQaGiIiIdEkgECAQCOD1elMdSr+RmZlJKBQiEAikOhQRkQHttNNOA2DhwoXEYrE25xoaGliyZAnZ2dnMnTs3FeFJDymBISIiIp3WevmIdh/pPK/Xm0hgaBmJiEjvmThxIgsWLGDbtm3ce++9bc5df/31NDU18cUvfpHc3FzA+f/aunXr2Lx5cyrClS7SEhIRERHptEAgQCgUwuv1avlIF7jdbqy1hEIhwuGwZq+IiPSi3/zmN8ybN48rr7ySl156iWnTprFs2TIWL17M5MmTufnmmxPX7tq1i2nTpjF27Fi2bdvWZpwnn3ySJ598EoDy8nIA3njjDS699FIASkpKuO222/riR5JmSmCIiIhIp/n9foLBIDk5OakOpd+Jz8Lw+/1KYIiI9KKJEyeyfPlyfvzjH/P888/z3HPPMWLECK688kquv/56ioqKOjXOqlWr+Mtf/tKmb8uWLWzZsgWAsWPHKoHRx4ymMQ5cxpim7OzsHJ/Pl+pQRERkAAiHw1RUVFBTU0NRUZFmYHRROBymsbGRkpIShg8fnupwRGQAWbt2LQDTpk1LcSSSLJ39O83JycHv9/ustbl9EVeqqQaGiIiIdEogECAYDGr5SDd5PB5isVhiGYmIiIh0jRIYIiIi0inxBEZmZmaqQ+m3tBuJiIhI9ymBISIiIocUiUQIBoNEo1HtPtIDXq+XYDCoBIaIiEg3KIEhIiIihxQv3qnlIz3j8XiIRqMEg0EikUiqwxEREelXlMAQERGRQ9LykeQwxuDxeDQLQ0REpBuUwBAREZGD0vKR5FIdDBERke5RAkNEREQOKj77wuPxaPlIEni93jZJIREREekcJTBERETkoAKBAOFwWMtHkiS+jESzMERERLpGCQwRERHpUCwWIxgMEg6HtXwkibQbiYiISNcpgSEiIiIdiicvMjIycLn0tiFZvF4v4XCYYDBILBZLdTgiIiL9gt6JiIiISIe0+0jvcLlcZGRkEAqFCAaDqQ5HRESkX1ACQ0RERNplrU3MwPB6vakOZ8DJzMwkGAzi9/tTHYqIiEi/oASGiIiItCsUChEKhQDIyMhIcTQDj9frTRTytNamOhwREZG0pwSGiIiItCsYDBIKhTT7opfE64rEa2GIiIjIwSmBISIiIu2K179QAqP3ZGZmqg6GiEgSPf7443zjG9/g5JNPpqCgAGMMF198carDkiRxpzoAERERST+RSIRQKEQsFtP2qb3I4/HQ2NhIIBCgsLAw1eGIiPR7N910E6tXryYvL4/Ro0ezbt26VIckSaQZGCIiInKA+PIRj8eDMSbV4QxYHo+HWCxGOBwmEomkOhwRkX7vjjvuYMOGDdTX13PfffelOhxJMs3AEBERkQMEAgHVv+gjXq+XYDBIIBAgLy8v1eGIiPRrp512WqpDkF6kGRgiIiLSRiwWUwHPPuT1elXIU0REpBOUwBAREZE24skLt9uNy6W3Cr3N4/EkCnnGYrFUhyMiIpK2tIRERERE2tDsi77lcrlwu92JWRjZ2dmpDklEBpj+VMvIWpvqECSN6WsVERERSbDWqv5FCsTrYGgZiYiISMeUwBAREZGEcDhMKBQCwO3WRM2+ojoYIiIih6Z3JiIiIpIQCAQIh8OafdHH3G43sViMUChEOBzG4/GkOiQRGUC0LEMGCs3AEBERkYT4MgYlMPqe1+slFAoRCARSHYqIiEhaUgJDREREAIhGo4RCISKRiGYApEA8gaFlJCIi0teMMaONMQ8YY3YbY4LGmG3GmDuNMUO7OM5HjTELjTE7jTF+Y8wWY8xjxpgTkhGnlpCIiIgI4Cwfic++6E8V6wcKj8dDY2NjYjtVbWErItJ1Tz75JE8++SQA5eXlALzxxhtceumlAJSUlHDbbbelKLr0ZIyZCCwFSoGngHXAbOCbwNnGmBOttVWdGOcXwDVAFfAksA84HDgf+JQx5ovW2od6EqsSGCIiIgI4y0dU/yJ1XC4XGRkZ2k5VRKQHVq1axV/+8pc2fVu2bGHLli0AjB07VgmMA/0GJ3lxpbX21/FOY8ztwNXAzcDlBxvAGFMGfAeoAKZbaytbnTsNWAT8BOhRAkOpfREREcFaSzAYJBQKaflICsW3U1UdDBGR7rnhhhuw1nbYtm3bluoQ04oxZgKwANgG3Lvf6euBJuALxpjcQww1Fie/sKx18gLAWrsYaACG9TReJTBERESEUChEKBRKzAKQ1Gi9nap2DRARkT5wevNxobU21vqEtbYBWALkAHMPMc5GIATMNsaUtD5hjJkP5AMv9jRYLSERERGRxPIRzb5ILbfbeWsW305Vy3lERKQTsowx77R3wlp73CFeO6X5uKGD8xtxZmhMBl7qaBBrbbUx5nvA7cAHxpgncWphTAQ+DrwA/O8hYjkkJTBEREQksXwkJycn1aEMeq1nYSiBISIivayw+VjXwfl4/5BDDWStvdMYsw14APhqq1ObgD/vv7SkO7SEREREZJCLb58ajUY1AyMNqA6GiIh0UcBae1x7LQljx7clO+S6RmPMNcDjwJ9xZl7kAscBW4C/GWN+2dNglMAQEREZ5OLLFdxut7ZPTQMej6dNUklERKQXxWdYFHZwvmC/69pljDkV+AXwtLX2W9baLdZan7V2BfAJYBfw7eaiod2mBIaIiMggp91H0osxBrfbTSgUIhgMpjocEREZ2NY3Hyd3cH5S87GjGhlx5zUfF+9/wlrrA97CyT8c09UAW1MCQ0REZJCLJzBUbyF9eL1eJTBERKQvxBMOC4wxbfIDxph84ETAD7x5iHEym48dbZUa7w91J8g4JTBEREQGsXA4TCgUwlqb2AFDUs/j8SQKeYqIiPQWa+1mYCEwDvj6fqdvxKlj8VdrbROAMcZjjJlqjJm437WvNR//nzFmVOsTxphzcBIhAWBpT+LVO5VuaK6sOraD0xXW2rIujDUa+AlwNlAM7AGeBG601tb0LFIREZGD0+yL9BRPJoXDYW1vKyIive0KnMTC3caYM4C1wBzgNJylI9e1unZU8/ntOEmPuMeBF4EzgbXGmH8B5cA0nOUlBrjWWlvVk0CVwOi+OuDOdvobOztAc9ZqKVAKPAWsA2YD3wTONsac2NO/YBERkYMJBoOEw2EyMzMPfbH0KY/Hk1hGogSGiIj0FmvtZmPMLFq+WD8X54v1u3G+WK/uxBgxY8y5OLM4PotTuDMHqAaeA+621i7saaxKYHRfrbX2hh6O8Ruc5MWV1tpfxzuNMbcDVwM3A5f38B4iIiLtstYmZmDk5eWlOhzZT+sEhv5+RESkN1lrPwS+1InrttGyter+58I4X/LfmcTQ2lANjBRp3j5mAbANuHe/09cDTcAXjDG5fRyaiIgMEvHZF263G5dLbwnSjdfrTdTBsNamOhwREZGU0wyM7ss0xlwMHIaTbHgXeNVa29kN209vPi601sZan7DWNhhjluAkOOYCLyUpZhERkQRtn5reXC4XLpcrUWhVy3xERGSwUwKj+8qAB/fr22qM+ZK19pVOvH5K87Gj/XQ34iQwJqMEhoiI9AItH0l/rWdhKIEhIiKDneaLds+fgDNwkhi5wNHAb3GqsP7HGDOjE2MUNh/rOjgf7x9yqIGMMe+014CsTsQhIiKDUDQaJRwOE4vFtH1qGmtdB0NERA7t8ccf5xvf+AYnn3wyBQUFGGO4+OKLD/qapUuXcu6551JUVEROTg7Tp0/nzjvvJBrt7OR66St6x9IN1tob9+taA1xujGkEvg3cgFN1tSfihVG06FVERJKu9fIRY9qtxSVpwOPxEI1GCYVCRKNRMjIyUh2SiEhau+mmm1i9ejV5eXmMHj2adevWHfT6p556ik996lNkZWVx0UUXUVRUxDPPPMPVV1/NkiVLeOyxx/oocukMzcBIrvubj/M7cW18hkVhB+cL9ruuQ9ba49prQKATcYiIyCAUCARU/6IfMMbgdrsTdTBEROTg7rjjDjZs2EB9fT333XffQa+tr6/nq1/9KhkZGbz88sv88Y9/5NZbb2XVqlWccMIJPP744zz88MN9FLl0hhIYyVXZfOzMziHrm4+TOzg/qfnYUY0MERGRbrHWEgqFCIfDeL3eVIcjh6BlJCIinXfaaacxadKkTs0ufPzxx9m7dy+f/exnmTVrVqI/KyuLm266CeCQSRDpW0pgJNcJzcctnbh2cfNxgTGmzd+DMSYfOBHwA28mLzwRERHafJuvJQnpr3UhTxERSZ5FixYBcPbZZx9wbv78+eTk5LB06VL9+5tGlMDoImPMkcaYonb6xwL3ND99qFW/xxgz1RgzsfX11trNwEKcwp9f32+4G3FmcfzVWtuUxPBFREQIBoOafdGPuN1uYrFYYtaMiIgkx/r1zqT4yZMPnBTvdrsZP348kUiELVs68/209AUV8ey6zwDXGmMWA1uBBmAi8FGcXT+eA25rdf0oYC2wHSdZ0doVwFLgbmPMGc3XzQFOw1k6cl2v/RQiIjJoxQt4ZmdnpzoU6aT4MhLVLRGRbulPxZpt3+1hUFfnlBssLGy/LGG8v7a2tq9CkkNQAqPrFgNTgGNwlozkArXA68CDwIPWdu6/OmvtZmPMLOAnwNnAucAe4G7gRmttddKjFxGRQS3+TX4kEtH2qf1I62UkubmdKbUlIiI9Ff9Yp9260ofeuXSRtfYV4JUuXL+Nli1R2zv/IfClnkcmIiJyaPFlCBkZGbhcWknaX3i9XpqamggEAlhr9WZaRCQJ4jMs4jMx9ldfX9/mOkk9vXMREREZROLLR7QMoX9xuVy4XC5tpyoi3WNt/2l9aMqUKQBs2HDgxo+RSIStW7fidruZMGFCn8YlHVMCQ0REZBDR9qn9l8fj0W4kIiJJdPrppwPw/PPPH3Du1VdfxefzMW/ePDIzM/s6NOmAEhgiIiKDRDQaVf2Lfszr9RIKhZTAEBFJkk9/+tOUlJTw8MMPs3z58kR/IBDghz/8IQBf+9rXUhWetEPvXkRERAaJ+OwLj8ejGgr9kMfjSSShYrGYapiIiLTjySef5MknnwSgvLwcgDfeeINLL70UgJKSEm67zdk0sqCggN///vd8+tOf5tRTT+Wzn/0sRUVFPP3006xfv55Pf/rTXHTRRan4MaQDSmCIiIgMEqp/0b8ZY8jIyEgsI9E2uCIiB1q1ahV/+ctf2vRt2bKFLVu2ADB27NhEAgPgggsu4JVXXuHmm2/miSeeIBAIcPjhh3P77bdz5ZVXKuGfZkwnd/yUfsgY05SdnZ3j8/lSHYqIiKSBiooK9u3bR35+vpaQ9FM+n49YLEZpaSlDhgxJdTgikibWrl0LwLRp01IciSRLZ/9Oc3Jy8Pv9PmvtoNhjW3MPRUREBoFIJEI4HCYWiyl50Y/FC3lqJxIRERmMlMAQEREZBLR8ZGBwu93EYjFCoRDRaDTV4YiIiPQpJTBEREQGgdYFPKX/MsZoO1URERm0lMAQEREZBILBIOFwGK/Xm+pQpIc8Ho+2UxURkUFJCQwREZEBLhwOEw6HAcjIyEhxNNJTHo+HSCSiOhgiIjLoKIEhIiIywKn+xcASr4MRDoeJRCKpDkdERKTPKIEhIiIywMWXjyiBMXBoGYmIyMBlrU11CGlLCQwREZEBzFqbKOCp+hcDh9fr1XaqIpJgjAEgFoulOBJJhngCI/73Ki2UwBARERnA4vUvjDG4XPrf/kChnUhEpLXMzEwAmpqaUhyJJEP87zH+9yot9E5GRERkANPuIwNTvBhr6wKtIjJ45efnA1BeXk5DQwOxWEzLEPoZay2xWIyGhgbKy8uBlr9XaeFOdQAiIiLSe+IFPLOyslIdiiRZ6zoYqm8iMrgVFRXR1NSEz+dj586dqQ5HkiAnJ4eioqJUh5F2lMAQEREZoFrXv9C3OANPPIGhOhgi4nK5GDNmDNXV1TQ0NBAMBjUDox8yxpCZmUl+fj5FRUVa+tkOJTBEREQGqPjyEbfbrTdBA5DX66WpqSnxQUXF3kQGN5fLRUlJCSUlJakORaTX6N2MiIjIABWffaHlBQOTy+XCGNNndTCstfpGV0REUkozMERERAaoeP2LnJycVIcivSS+nWowGExKodZQY4gP3/iQms011O2oo/7Deuo+dI71O+uJhqN4c714cj1487xOy/WSOzyX0SeMZuzJYxlx7AgyvBlJ+OlERETaUgJDRERkAIrFYoRCIaLRqGZgDGAejyeRqOoOG7OUrypn88LNbF64mR2v7yAWjh30NaHGEKHGEE0VbbdrXPevdQC4s92Mnjuaw04+jLHzxzL25LFKaIiISFIogSEiIjIAxetfZGRkqDbCAObxeNoU7Ovs3/WO13ew/L7lbF64Gd8+X1JjivgjbFu8jW2LtwGQWZjJ1POnMu3T05i4YCLuTL39FBGR7jFayzhwGWOasrOzc3y+5L4xERGR9FdXV0dlZSXGGC0hGeBqamrIy8ujrKyMzMzMg15bvqqcl37wEpv+s6nDa0qPLmXkrJEUjCmg8LBCCscUOo/HFOLOdhNuChNqcmZhhJvCBBuCVK2vYsdrO9j+2nZqt9Z2OLY338uUj0/hiE8fweFnH447S8kMEZGeyMnJwe/3+6y1uamOpS8ogTGAKYEhIjJ4VVZWsnfvXvLy8rSEZIBrbGzE5XJRWlpKQUFBu9dUbaxi8Y8W8/4j7x9wLmdYDhMXTGTigolMOGsC+SN6tuVu/c56dry+g+2vbmfjcxup217X7nVZQ7I46n+OYualMxl5/EjNFBIR6QYlMGTAUAJDRGRwikajlJeXU1VVRXFxsT4YDnChUAi/38+wYcMO2D6xYXcDL9/4Miv/uBIbbfWez8CML8xg9pWzGXHMCIyrd35HrLXseWcPHzz+AR889gE1W2rava5kWgkzL53J9Iunkz+yZwkUEZHBRAkMGTCUwBARGZz8fj8VFRX4/X4KCwtTHY70slgsRk1NDUVFRYwYMQKXy4WNWZbfv5wXr32RUEPbAp9TL5jKaTedRumRpX0ap7WWitUVvP/Y+6z5x5p2l5oYl2HyeZOZ9915jDlxjJJvIiKHoASGDBhKYIiIDE51dXVUVFTgcrlU/2KQqK2tJTc3l+HDh9OwtYFnvvoMHy75sM01404bxxm3nMHoOaO7PL61UFkJtbUQjUIs5rT449xcmDgROrtaycYsO17fwao/r+L9R98n3BQ+4JrRJ4xm3nfnMfX8qb02Q0REpL9TAkMGDCUwREQGJ9W/GHyampqIRWJse3Qbb//sbaKhaOJc8ZRizrn7HCacNaFTMxo+/BDeew/WrnXaBx84x9rag7/O44GpU+Goo1ra0UfDuHFwsNuGGkOs/edaVv15VWLnktaKJxdzwndOYMYXZqjop4jIfpTAkAFDCQwRkcFH9S8Gp12rdvHaXa/RsLIB9jp9LreLk75/Eif/4OSDfvCPRGDJEnj2WaetW5fc2MaOhY98BBYsgDPOgCFDOr5279q9LL1tKe899F6bJAxA3og8Tr3hVI657BhcbldygxQR6aeUwJABQwkMEZHBR/UvBpdoKMry+5fz7oPvQjFQBZTDqONH8bHff4zhRw9v93VNTfDUU07C4j//OfTsCoD8fBgxAjIywOVyWvzx3r3OzI1DyciAOXOcZMYFF8D06e3PzmjY3cCyu5ex/P7lBOuCbc4VTynmjJ+dwdRPTFWCTkQGPSUwZMBQAkNEZPCpra2lsrJS9S8Ggb1r9/Ly9S9Tu6XW6SiEDJvBqZefyrxvzMOVceAshbo6uPdeuOMO2Lev/XGzs+H44+GII2DatJbjyJEHXwpSV+csN1mzxmnvvQdvvw2NjR2/ZtIkuPBC+Mxn2k9mBOuDrPjDCpbetpTGPW0HGjVnFGf98izGzh/b8Q1ERAY4JTBkwFACQ0Rk8FH9i4EvFomx8oGVrPjDCoi19JedWMacq+Yw/qjxB8y+2bcP7roLfv1rJ9Gwv9Gj4bzz4GMfg9NOc5IYyRAOwxtvwH//CwsXwjvvOAVB2zN5spPI+PznnYRJm3F8YZbdvYzXf/76ATMyJn10EmffdTZFE4uSE7SISD+iBIYMGEpgiIgMLvH6F9XV1RQVFWl6/QBUs7mGxT9eTNX6qkSfO8vNnKvmMPFjE/H7/QwbNoxhw4YBUFEBt90G993nLBtp7bDD4KtfdZIWHS3lSLa9e+HFF+GZZ5zW0eyMefOc2D7zGWeHkzhflY/Xb3mdt379VpsaGe4sN/N/NJ9535lHhjejl38KEZH0oQSGDBhKYIiIDC4+n4+KigoCgYDqXwxAH77xIQu/vZBYqGXaRdnMMk654RQKRhdgrU0kr4YNG8H997v40Y+gvr7tOJMmwfe/Dxdf3PltT3uD3w/PPw+PPQZPP31gggWgoAA+9zknmXHssS39tdtrefnHL7P6wdXQ6q3ssCOGcd5vz+Owkw7r/R9ARCQNKIEhA4YSGCIig4vqXwxc5avKee7rzxENOrMOXF4Xs78+m6P+5yiMq2XqRG1tLVu35nDjjcN5++2260COOgquu86Z1ZCRZpMU4smMv/3NKS4aiRx4zfHHww9+AB//uFM4FGD3O7t59v89y54Ve9pce+xXj+XMX5xJ9tAkrYUREUlTSmDIgKEEhojI4FJRUcG+ffvIz8/H7e5420zpX6o2VPHM/3uGcGMYcLYTPfvusxk6fmib6+rq4De/8fH885bKylLq651ZOFOmwM9/3vaDfzqrrIS//AX+8AfYsOHA80cfDT/8IXzqU04iJhaJ8dY9b7Hoh4sIN4UT1+WW5vLR+z7KtE9OO3AQEZEBQgkMGTCUwBARGTwikQjl5eXU1NRQXFyc6nAkSep21PH0V54mUB0AIKsoi/P/eD4FYwoS11jrbId6113Q2BgmL6+RfftKaWgYxo9+BN/+NmRmpuon6D5r4bXXnETGY49BIND2/NSpzoySz34W3G6o+7CO//zff1j/9Po218344gzOvvtssgqz+jB6EZG+oQSGDBhKYIiIDB7x+hfBYJCCgoJDv0DSXlNlE09f9jSN5U6lS2++l/N+dx7Fk1oSVLW1cNNN8PLL8R5LcXE1RxxRxM9+NoKJE/vBlItOqKiAX/0KfvObA2tlHH6482dw4YVOIdJ1T67juf97joZdDYlrCg8r5IK/XMC4U8f1beAiIr1MCQwZMJTAEBEZPGpqaqisrMTtdpOdrD0wJWX8NX6e/eqz1G6rBSAjM4OP3vdRhk8fnrjmjTfghhugqmVDEsrK4JvfrOWUU3IYPnz4gPtd2LcP7rzT2Q52/+Kkxx8Pv/wlnHoqBGoDPPd/z/He395rucDA3KvncsbNZ+DO0hIrERkYlMCQAUMJDBGRwUP1LwaOcFOYZy9/ln1r9wFg3IaP3PERxpwwBoBg0PkA//DDbV/3mc/AlVeCtT6stZSWlg7Y3Whqapw/gzvucGahtHbuufCLXzhFS99/9H2evfxZAjUt60+GHTmMTzz4CUYcM6JvgxYR6QWDLYExMOYVioiIDGKRSIRwOEwsFlPyop+z1vLy9S8nkhcYOP2m0xPJi40b4QtfaJu8KCpy6l9873uQnQ0ej4dQKEQwGEzBT9A3hg6FH/8YtmyBa65pW+Pjuedgxgy47DIYetKRXLHmCiZ+ZGLi/N739/KH2X9g0Y8WEQm2s92JiIikLSUwRERE+rlQKEQ4HMbj8aQ6FOmhNQ+vYdvL2xLPT/rBSUw4cwIAixbBF7/ofGiPmz8fHnkETjyxpc/tdhONRgmHw0Sj0T6KPDWGDnVmW2zYAJdc4tTAAIjF4E9/cnZguf9v+Xzmqc9z7r3n4s52EnyxSIzXbnqN3x33O3a9vSuFP4GIiHSFEhgiIiL9XDAYJBQKKYHRz1WuqWTZncsSz4/6n6OY9glnC9BnnoFrr4Vw8y6hmZnwgx84hS2Htt1NFWMMHo+HcDhMKBTqq/BT6rDD4M9/hlWr4OyzW/obG50ZGtOnG6omHM/lqy/nsJMOS5zf+/5e/jj3j7x47YtEApqNISKS7pTAEBER6edCoRCRSEQJjH4sWB/kpe+/hI06tclKjihhzpVzAGe5yI03OrMKwPmw/ve/wyc/2TLjYH+DLYERN306/Oc/8MILcMQRLf0bNsA558Bl3ynm5Acu5ey7zsaT4/z3YmOWJb9Ywm+P+S0739yZoshFRKQzlMAQERHpx1T/ov+z1vLKDa/QuKdlu9Qzf34mxu3ij3+E225ruXbyZPjjH2Hs2IOPORjqYBzMmWc6szHuuANa7yr89NNw1NGGZ/fO4YvLLm+zreq+dft44MQHeOF7L2g2hohImlICQ0REpB/T8pH+b83f17D91e2J56dcfwp5I/K5+264776W66ZPh9/+9sAlI+0ZTHUwOuLxwFVXOYVPL7uspT8YhJtugpM/VsTQq77Iub85F2+eF3BmYyz95VJ+d9zv2L18d2oCFxGRDimBISIi0o+pgGf/VvleJcvublX34nNHcdj8cdxyCzz4YMt1s2fDvfdCfn7nxh2MdTA6UlrqzFpZtgyOP76lf9s2OP8Cw0+eO55zn/s6408fnzi394O9/GGus1NJNDQ4E0AiIulICQwREZF+TAmM/itYH+TFa19M1L0YduQwZn9jDrfeCv/8Z8t1p54Kd97pbJHaFfFlJIM9gRE3eza8+Sb87nfO1rNxzz4LcxcUsHX+Fzjjzo+21MaIWl676TV+f/zvKV9VnqKoRUSkNSUwRERE+ql4/Qtrrepf9DPWWl658RWaKpoA8BZ4OePnZ/Do4y4ee6zlunPPdbYJ9Xq7fo/4DIzBWgejPS4XfPWrsH69c4wXQQ0E4IYbDF+6ZxaTfv0Nxs5vKTJS8W4Fv5/9e5b8cgk2ZlMUuYiIgBIYIiIi/ZbqX/Rf659az/ZXWupenHrjqazalM/tt7dcs2CBs/tIRkb37qE6GB0rKXFmYrzxBhx7bEv/pk1w4Zfzeab4EmZe/zHc2U5iMBaO8eL3XuSvZ/yVug/rUhS1iIgogSEiItJPaflI/1T/YT1v/OqNxPMjLzqS4PCx/OAHYJu/4J8+HW64oeNtUjtDdTAObc4ceOstp77IkCEt/f/8l+Fztx5L6IqrGD5rTKJ/28vbuH/6/ax5ZE3fBysiIkpgiIiI9FehUIhIJKIERj9io5bFP15MxO9s0zlk3BDG/89srroK/H7nmpEj4Ve/6t6ykf0N9u1UOyMjA664wllWcumlLf0+H/zkV7nc3fgl8i7+GMblZJMCtQGe+OwT/OuL/yJYrz9XEZG+pARGFxljio0xXzHG/MsYs8kY4zfG1BljXjfGfNkY0+k/U2PMNmOM7aCpWpSIiHQoXv8iFoup/kU/svJPK6l8rxIAk2E44Uen891r3VQ6XeTmwl13dW6r1M7QDIzOKy2FP/0JXnsNjj66pX/tOsN3HjqWNR/5Fp4xZYn+dx98l/tn3s/OZTtTEK2IyOBkrFUxoq4wxlwO3AfsARYDO4DhwCeBQuAJ4DO2E3+wxphtwBDgznZON1prb+thrE3Z2dk5Pp+vJ8OIiEga8vl8lJeXEwqFKCgoSHU40gl7P9jLk5c+CTHn+bFfm8XfPziGV15xnrtc8OtfO8saksVaS3V1NUVFRZSVlZHR3YIag0wk4vxdXH89NDS09JcUWz4/9R2GLPk38dU9LreL0392OvO+PS8xS0NEpK/k5OTg9/t91trcVMfSF5TA6CJjzOlALvBva22sVX8Z8BYwBvi0tfaJToy1DcBaO66XYlUCQ0RkgKqpqaGyshK32012V/fXlD4X9of51+f/Rd0OpwDk8BnD2T7jY/zlry0feK+7Dj7xieTfu66ujuzsbIYPH67flS7avRuuvhoefbRt/7zpDZy49SFyGyoTfYeffTgX/OUCcksHxWcIEUkTgy2BoSUkXWStXWStfaZ18qK5vxy4v/npqX0emIiIDCqqf9G/LLtrWSJ54c5xk/3xM9skLy6+uHeSF6A6GD0xciQ88gg88wyMaanlydJ387knfDnvHXYO0ea5GJue38T9M+5ny0tbUhStiMjApwRGcoWbj5EuvCbTGHOxMeYHxphvGmNOM8ZofqeIiHRI9S/6lw+XfMjax9cmnk/96nx+fndO4vm8eXDllb13f9XB6LnzzoMPPoCrrnKW+gD4A4Yndszm0RHfpJJhADSWN/LgWQ+y6IeLiEViHQ8oIiLdoiUkSWKMcQMrgaOAs621/+3Ea7YBY9s5tRX4krX2lR7GpCUkIiIDkOpf9B+BugCPX/g4/ipni5Ex88fxeP2ZrFrlfGtfWgp//3vbLTyTzVpLVVUVxcXFqoORBG+/DV/9Kqxe3dLn8VjO8L7O8U2LycB5bz1qzig++dAnKTq8KEWRishgoCUk0l0/x0lePNeZ5EWzPwFnAGU4dTWOBn4LjAP+Y4yZ0ZlBjDHvtNeArK7+ECIikv6CwSDhcFjLR/qBpb9cmkheZBVlsX70qYnkhcsFN9/cu8kLAGOMZmEk0fHHw/LlcMstLVvdhsOG55tO5sH8r1PRPBtj17Jd3D/zflb8cQX6wlBEJDmUwEgCY8yVwLeBdcAXOvs6a+2NzTU1Kqy1PmvtGmvt5cDtQDZwQ68ELCIi/ZrqX/QPWxdtZfN/NyeeF3xmAQ/9o+Xv7PLL4Zhj+iaWeB0MJTCSw+2Ga6+FlSth9uyW/m0Nxfw+43Jec80niotwU5hnvvIMj37qUXz7NCNWRKSntISkh4wxXwfuAT4Azmgu5tnTMQ8HNgLV1triHoyjJSQiIgNMJBKhvLycmpoaiou7/b8I6WX+Gj+PX/g4gZoAAMPPOJJfr5hHTY1zfs4cuOceMH2062Y4HKaxsZFhw4ZRWlraNzcdJCIRuP12+PGPoXWd1FGZ+zg3+C9GsRuAvLI8zv/z+Rz+kcNTFKmIDERaQiKdZoy5Cid5sQY4LRnJi2bxPbkGxS+hiIh0XigU0vKRNGet5fVbXk8kL7KG5fJs9dxE8qK4GH76075LXgC43W6i0SjhcJhoNNp3Nx4E3G645hpnNsacOS39u4Il/NF8hef5CEE8NJY38rez/8azX3uWYIN2hBER6Q4lMLrJGPM94A5gFU7yovLgr+iSE5qP2odLRETaCAaDhEIhJTDS2JYXt7Bt0bbE84rjP8qKlc5bLmOcuhdFfVzXUXUwet+0abBkCdx2G2RnO30xa3iTudzv+jobmQjAO/e/w31H3cfmhZsPMpqIiLRHCYxuMMb8CKdo5zs4y0b2HeRajzFmqjFm4n79RxpjDnj7YowZizOrA+ChJIYtIiIDgOpfpDd/lZ8ltyxJPPfOn8Wjzxcmnn/1qzBrVioi03aqfSEjA779bVizBs46q6W/JlbI37iYJ/gEjeRQt6OOhz7yEE9/5WkCdYHUBSwi0s+oBkYXGWMuAf4MRIFfA3XtXLbNWvvn5uvH4WyLut1aO67VODcA1wKLm883ABOBj+LsHvIc8AlrbbffZagGhojIwKL6F+nNWssL33mB7a9sB8BTOoR/uj/N7t3OWpFjj4X773d2H0kF1cHoW9bCgw/C1VdDdXVLf7YJcJpdxCyW48KSPyqfj/3uY0w6d1LqghWRfmuw1cBwpzqAfmh88zEDuKqDa17BSXIczGJgCnAMzpKRXKAWeB14EHjQKrskIiKtqP5Fetv0n02J5AXAusPPZfdSJ3mRl+fUvUhV8gIOrIORkZGRumAGAWPgi1+Ec85xkhh/+5vT77dZPMe5rOAYzuU5Dtu1k79/9O8c/bmjOevWs8gfmZ/awEVE0phmYAxgmoEhIjKw1NTUUFlZidvtJju+yF7Sgr/Kz6OffpRQgzNxMjzvJB5YOi1x/qab4OyzUxVdi7q6OrKzsxk+fLh+h/rYf/8L//d/sGlT2/6ZrORMXiQPH948L6fccApzrpxDhkcJJhE5tME2A0M1MERERPoJ1b9IX2/e8WYieeEqG8Y/35+aOLdgQXokL0B1MFLpIx+B995zklmtc0erOIZ7+D/eZDb+xggvfOcFfjvzt2xdvDV1wYqIpCklMERERPqBSCRCOBwmFovhdmsFaDrZ9fYuNj3vfK1ugWVFZ1Nb5ywdKS2F738/hcHtx+PxEAqFlMBIkawsuO46WLsWPvGJlv4A2TzPOdzLFaxlCpUf7OWvp/+Vxz/7OPU761MXsIhImlECQ0REpB9Q/Yv0FA1H2+w6sveI+az4ICvx/MYbIT+NShrE62CEQiFisViqwxm0xo6Ff/4TnnsODj+8pb+aYh7hs/yZS9jFCN5/5H3umXoPS25dQjQUTV3AIiJpQgkMERGRfiD+rbkSGOll9V9WU7fD2ZCsMaeE5zZNTpz73Ofg+ONTFVn7jDG43W7C4TDBYDDV4Qx655zjbLl6221Q2LLbLtsZx+/5fzzBJ9jblMOL17zI/TPvZ+siLSsRkcFNCQwREZF+IBgMqv5Fmqn/sJ6VD6wEIIphacHZBEPO0pGJE52CjenI6/WqDkYaycyEb38bNm+Gb34TWq8Qe4/p/Jr/4wXOYOfaBv56xl954n+eoH6XlpWISHIZY0YbYx4wxuw2xgSNMduMMXcaY4Z2Y6yTjTFPGGP2NI+1xxiz0Bhzbo/j1C4kA5d2IRERGRgikQjl5eXU1NRQXFyc6nAEsNby/DeeZ+ebOwFYN+wkXtnr7Dri8cBf/wqTJqUywo6Fw2EaGxspLS1l2LBhSRvXWksoFCIQCOD3+wkEAoTDYdxuNx6PB4/Hg9frTRy9Xm/S7j2QbNwI3/se/OtfbftzaOIUXmUWy8nOc2u3EhEBkrMLiTFmIrAUKAWeAtYBs4HTgPXAidbaqk6O9UPgp8A+4FlgD1ACHAMsttZe0904AVQFTEREJM2p/kX62fri1kTyosoUsaS6ZdeRyy9P3+QFOHUwYrFYog6Gy3XoCbn79u3j3XffZfv27ezevZtdu3axe/fuRKuuriYQCNCVL8ZycnIoKiqiqKiI4uLixLGsrIyRI0e2aaWlpWRkDI4P6pMmOfUxXnvNmZnx9ttOv49c/sM5LGM2ZzW+SPA7L7DqT6s4995zGXfKuJTGLCL93m9wkhdXWmt/He80xtwOXA3cDFx+qEGMMZ/BSV68CHzSWtuw3/kev5HRDIwBTDMwREQGhtraWioqKnC73WS33n9RUiLcFOaRTz2Cf5+fKIbnh36WnTV5ABx1FDzwAHQiJ5BStbW15OTkUFZWRlZWS9FRay2bNm1i5cqVrF69mtWrV7Nq1Sp27dqVwmghIyOD0aNHM2nSJA4//HAmTZqUaBMmTBiwszliMXj0Ubj2Wti+ve25w9jOWbzAGHYx/eLpnHXrWeSV5aUmUBFJmZ7OwDDGTAA2A9uAidbaWKtz+TgzKAxQaq1tOsg4LmATMBwYZ63d2514DhmvEhgDlxIYIiIDQ0VFBfv27SM/P19bqKaBpbct5f2H3wfg3ZzZvOGbAYDXC3//O4wbl8LgOsnn82GtZdiwYezevZtXXnkl0crLy7s9rsfjISsri+zsbLKysvB4PIktgOMzieIFRKPR5Oyq4Xa7mTJlCtOnT2f69OkcffTRTJ8+ndGjR2OMSco9Ui0QgHvugZtvhtratueO4H3OYBEjC5o47abTOP5rx+Nyp3kGTUSSJgkJjK8Avwd+Z63933bO/xdYAJxprX3pIOOcBLwGPA78D/AR4CggALxlrX2jO/HtT++CRERE0lg0GiUcDhOLxZS8SANVG6p4/1EnebGPIt4KTE+c+9rX+kfyora2lldeeYXly5ezZMkS1q9ff8jXZGVlcdRRRzFlyhRGjRp1wBKPYcOGkZWV1enfUWstjY2NVFVVUV1dTXV1NVVVVVRVVbFnz57E0pT4UpWqqo6XXkciEd5//33ef/99/vGPfyT6hw4dyjHHHMOxxx6baJMmTerUkpl0k5UF3/kOfOlLcNNNcO+9EA475z7gSNYxlePq36HqyldY+ceVnPnzM5n4kYkDJoEjIoeUZYx5p70T1trjDvHaKc3HDR2c34iTwJgMdJjAAOL7blUAK4CjW580xrwKfLqnMzP0TkhERCSNBYNB1b9II2/d/RbEnF1HluScRdTnfECcPh0+//kUB3cQu3bt4pVXXuHll19m1apVxGIxiouLaWhowOVyEYslZgwzZMgQZs+ezcyZM5k5cyYzZsxg8uTJSU2gGWPIz88nPz+fcZ3I+gQCAbZu3crGjRvZtGlTm+P2/ddWNKupqWHRokUsWrQo0ZeXl8fMmTOZPXs2c+bMYe7cuYwZM6bffNAvLoY77nB2uLnuOnjkEac/RgZvM5vVzODE1UvZfs5jTD6pjNNvPp2x88emNmgRSXfxTZzrOjgf7x9yiHFKm4+XA1uBM4FlwFjgVzgzMh4DTu1mnICWkAxoWkIiItL/1dbWUllZicvlIicnJ9XhDGq73trFc1c8B8BycyzvNH+p5fXCP/4BY9Psc+KePXt47rnneOGFF9i0adMB5wsLC/H7/QSDQebOncupp57KKaecwtFHH92vCmY2NDTw/vvv8+677ybae++9R+3+ay06UFZWxpw5c5gzZw4nnXQSxx9/fJu6IOnsrbfgu9+FV19t25+Fn7ksYw7LOPKskZx+0+mMmj0qNUGKSK9KwhKS3wFfBb5qrf1DO+d/Bnwf+L619ucHGeeXwHeBGHCstXZ1q3PZODM8RgPzerKcJGmpdOOkrs8EzgLmA4fhbJfiByqBVcAi4GlrbWorQYmIiPQT8RkY+fn5qQ5lULPWsuyuZQDspYiVHJs4d8UV6ZO88Pv9vPTSSzz77LMsX7683WuMMUyfPp1TTjmF4447jlmzZjF06NA+jjR58vPzmTt3LnPnzk30WWvZsWMH77zzDitWrGDFihW88847VFZWHvD68vJynnrqKZ566ikAMjMzmTNnDqeccgrz58/nhBNOIDe327sT9qrZs+Hll+Hf/4ZrroG1a53+ANm8zKm8wVxmv/AWa174G8d8/DDm/2g+I2eNTGnMIpJ24jMsCjs4X7DfdR2paT5uaZ28ALDW+ptraXwZZ3vW1CUwjDE5wJXA/+IkLeJz8AI4iYtsYAIwEfgUcJcx5hngV9bapT29v4iIyEDVuv5Ff/pGfCDavHAzVeuriGB4xZxGzLYsHfnc51Ibm7WWFStW8NRTT7Fo0SICgcAB13i9XubMmcOpp57KySefTFFREaFQCJ/PRyQSSUHUvcsYw9ixYxk7diyf/OQnAefPac+ePbz99tssW7aMZcuW8fbbb9PQ0GaXP4LBIK+++iqvNk9rcLvdzJ49m7POOoszzzyTOXPmpNWSLmPgvPPg7LPhwQedQp+bNzvngmTxGvN5k7kc//TbLH/6H8xcMJyTvn8SY08Z22+WzohIr4oXQprcwfn4xuAd1cjYf5zaDs7HExw92k6tR0tIjDFfAm4CRgDrgIeBJcDb1tr6VtcZnOIgc3HWvpwPZOJUKP2utXZHt4OQDmkJiYhI/+bz+aioqCAQCFBY2NEXI9LbouEoj37qURp3N7KSGbzFbMBZOvLww3DYYamJy+/38+9//5tHH32ULVu2HHDe5XIxZ84czjvvPObPn3/AFrzWWqqrqykqKmLEiBH9srhlT0WjUdauXcuyZct44403ePXVV9m4ceNBX5OXl8epp57KmWeeyVlnncW0adPSKhEQiTi/lzffDOvWtT2XQYTpvMs8lnLMCdmc9P2TmHze5LSKX0S6JglLSCbibH+6jY63UXUBww6xjWpJ87VNOFuuhvY7/x/gbOB/rLUPdydW6HkCIwY8CdxirX27C68rAC4BrgV+a639SbeDkA4pgSEi0r+p/kV6eO8f7/Hmr96knjwe4zNEmiewXnUVXHxx38ezfft2Hn30UZ599lmamg58LzlhwgTOO+88zjnnHIYNG3bQsWpra8nNzWX48OH9pu5Db9uzZw+vvfYar7zyCq+++ipr1qw56PWjRo1iwYIFLFiwgDPPPJOSkpI+ivTgolF44gn46U+hvR9hCus4kaXMOjrISdeexJEXHqntV0X6oZ4mMKDNVqlXWmt/3ar/duBqnM/slzf3eXBWV4SttZv3G+ch4PPAzdbaH7bqPwv4L1APjLPW1nY71h4mMI611q7oweuzcH6AdYe8WLpMCQwRkf6tsrKSvXv3kp+fry1UUyTUGOLh8x8mWBfkPyxgB06xi8mTnen6fbmyZ/Xq1fz+97/nzTffPOBcdnY25557LhdccAFTp07t9Dfq8QRIaWmpZvl0YO/evSxevJgXXniBF154ocNdT8BZunLcccexYMECzjrrLObNm4fX6+3DaA8Ui8HTT8MvfgHt/Oowmg+ZxxvMHVvOSdecwMwvzcSTnT5LZETk4JKUwJgILMXZSeQpYC0wBzgNZ+nIPGttVfO143B2GdlurR233zilOCsyDgdeA97C2YXkE4AFPmetfay7cYJ2IRnQlMAQEem/otEo5eXliSn+muKdGm//5m1WPbCKrYxlIQsAp+bAAw/A0Ucf4sVJ8t577/Hb3/623cTF2LFjufDCC/noRz9KXl5el8eO18EYNmzYIWdriLPsZsuWLYlkxksvvURdXcd17XJycjj11FM566yzOOusszjiiCNS9t+ytbBkCfzyl/DMMweeH0INc3iLE4vXceq3juX4K44na4hm5Yiku2QkMACMMWOAn+As8yjGWQ7yJHCjtba61XXj6CCB0Xy+CPghTtJiFNAAvI6zaqOdNGoX41QCY+BSAkNEpP9S/YvU8+318fAFDxMIGh7l0zTi7ATzyU/CD37Q+/f/4IMPuP/++1m6tG3Nc5fLxfz587nwwgs5/vjje/SBWHUweiYSibB8+XL++9//snDhQpYtW0Y0Gu3w+pEjR3LmmWdy5plncsYZZzByZGp2BFm7Fm67DR580BIOt/398RLkGFZycs5Kzrx8AnOunMOQsUNSEqeIHFqyEhj9RdITGMaY0TjrZGbi7PPa3hw0a62dmNQbywGUwBAR6b9U/yL1Xrv5Ndb9ax1vMpvVzABg6FCnrkBBwSFe3ANbt27l7rvv5rXXXmvT73K5OPfcc/nyl7/MmDFjknY/1cFIntraWhYtWpSYobF58+aDXn/kkUcmEhrz58+noDd/sdqxezfcey/cf7+lurptIsMQYzIbON71Dh/7dCYnfvsERs0e1afxicihKYHRk8GMORV4DsgCIkBF8/EA1trxSbuxtEsJDBGR/kv1L1Krdlstj134GFWxIfyTTxHDmZlwww3OlpW9we/38/vf/56//e1vbb7Fd7lcnH322XzlK1/hsF7Y8kR1MHrP/stNamtrO7w2IyOD2bNnc8YZZ3DGGWdwwgknkJmZ2Sdx+nzw0ENw5x2WtesOnNEzlGqO4x3Om13Jgu8dy5Tzp+DK0GwdkXSgBEZPBjPmLWAG8GXg7623YJG+pwSGiEj/pPoXqffCd15g68vbeJrzKGcEAMceC7/9rVMDI5mstbz00kvcfvvtVFZWJvqNMSxYsICvfvWrjBs3Lrk3bUV1MPpGJBJhxYoVvPjii7z44ossWbKEUCjU4fXZ2dmcdNJJnHHGGZx55pnMnDmTjF6uGhuLwQsvwB23W/678MBf9AwiHMEHnFK6jk9+rZRjLzuGwsOU9BJJJSUwejKYMX7gEWvtpUkbVLpNCQwRkf7J7/dTXl6u+hcpUr66nGe+/AzrmMQrnAo4u4384x8wYUJy77Vt2zZ++ctf8tZbb7XpnzlzJt/73veYNGlScm/YDtXBSA2fz8frr7+eSGisWrWKg70vHzp0KKeffnoioXH44Yf3anJzwwa4/3740x9j1NYf+DsxlGpmsJrz59ex4BuTmfLxKWR4+3BbHhEBlMDo2WDG7AYettZ+K2mDSrcpgSEi0j+p/kXqWGt5+stPs/3dOh7lMwTIBuCSS+Ab30jefSKRCA888AAPPPAAkUjLatuioiKuuuoqzjnnnD6deaM6GKm3b98+Fi9ezEsvvcRLL73Epk2bDnr9mDFjOP300xNt9OjRvRKX3w+PPAL33B3lnZXtJyjGso3Z+Wv5ny96mHvZkZQdU6aZYyJ9RAmMngxmzO+A46y1xyVtUOk2JTBERPqneP2LvLw8PJ72amFLb9m6eCsvfvdFXuUk1jINgBEj4NFHITs7OffYsmULP/7xj1m3bl2iz+VyceGFF/K///u/5OfnJ+dGXRCvgzF8+PA+LyQp7duxY0cimfHiiy9SUVFx0OsnTZrE6aefzmmnncapp57K8OHDkx7TihVw/30xHv67pcF3YDLDTZjJbGDeqB1c+OV8Zl1yJEMnDE16HCLSQgmMngxmTAnwJvBf4BprbVPSBpcuUwJDRKT/ide/qKqqori4WN9i9iEbtTx24WNs2u7hn1wAOH/2v/oVnHJKz8ePxWL8/e9/5ze/+U2b2gfTp0/n+9//fp8sF+mI6mCkN2st77//fiKZ8corr9DQ0HDQ10ydOpVTTz2VU089lVNOOYWysrKkxeP3w9NPwx/uD7PoFTcxe+C/U16CTGUdp04p58LLi5h+4VTyR/Z9ck5koFMCo6cDGnM4sAzwAhuAunYus9baM5J6YzmAEhgiIv2P3++noqICv9+v+hd9bO0/1/Lqz17nKT5OJc631yeeCHfe2fPCnbt27eKGG25g5cqViT6Px8MVV1zB5z//+ZTXnVAdjP4lHA7zzjvvsGjRIhYtWsSSJUsIBAIHfc2UKVM45ZRTmD9/PvPnz0/aVry7d8NDD8b44/1hNmxrf9eULPxMYT0nT93Hp76UzzGfnarinyJJogRGTwYz5khgMVByiEuttVZVfnqZEhgiIv2P6l+kRtgf5pELHmFl1ehE4U6Px1k60pPPedZann76aW677Tb8fn+if+rUqfzkJz9hQrKrgvaA6mD0X4FAgDfffJNFixbx8ssvs2zZsoPucAIwbtw4Tj75ZObPn89JJ53ElClTejzja80a+PuDUf72lwg7KtpPZngIcTibOHFCBZ/+YjazPjeJ4knFPbqvyGCmBEZPBjPmv8CZwPXAX4Dd1trowV8lvUUJDBGR/kf1L1JjxR9WsOT+d3mUi/A3F+687DK44oruj9nY2MjPfvYzFi5cmOhzuVx8+ctf5stf/jJut7unYSeV6mAMHH6/nzfffJOXX36Zl19+mTfffPOQCY2SkhLmzZvHSSedxIknnshxxx1HZmb7SYhDsRZWroQH/xTm4b/HKK9ufxwXUcaynWPLdvPxT2Rw5mVjGXHcCC2dE+kCJTB6Mpgx9cB/rbWfSdqg0m1KYIiI9C+qf5Ea/ho/D5//MK/4ZrGGowEoLYUnnuh+4c41a9bwgx/8gN27dyf6xo4dy09/+lOOOOKIZISddKqDMXD5/X7eeustXn31VV599VWWLl3Kod4fZmZmMmvWLE444YREGzFiRJfvbS0sXw6P/i3EY4/E2F7e8eyeIqo4Om8bC86IcP6Xi5ly1jjcWemV6BNJN0pg9GQwY/YBf7LWfjdpg0q3KYEhItK/qP5Faiz55RJee3QPT/ApbHPhzp//HM48s+tjWWt56KGHuOeee4hGWyahfvKTn+Rb3/pWWi/NUB2MwSMcDrNixYo2CY3q6upDvm7cuHGccMIJzJ07lzlz5jBz5swuz9JYuxYe+VuYRx8Ks3Z7x8vkPIQY79rBnCl1nPtJDwu+NIaiidrRRGR/SmD0ZDBjHgeGWWuTUKtbekoJDBGR/kX1L/pe/Yf1PPKpR3k69lH24Hy7fPzx8JvfdL1wZ3V1Nddffz1vvPFGoi83N5cf/ehHnNmdbEgKqA7G4BSLxVi/fj2vv/46S5Ys4fXXX2fz5s2HfJ3H42HmzJnMnj2bOXPmcPzxxzN58uROJ7927oSn/xXh8Qf9LF2ZTTDS8WyLfOo5omAXJ80OcvYns5n7yVHkDc/r9M8oMlApgdGTwYyZgLMDya+AX9hkb3EiXaIEhohI/6L6F31v0Q8W8fxCyyKczdEyMiwPP2wYP75r47z99tv88Ic/pKqqKtF31FFH8bOf/YyRI0cmM+Re1dTUhDGG0tJS1cEY5CoqKnjjjTcS7e233z7kTicAeXl5HHPMMRx33HEcd9xxzJo1q1NJjUAAXnoxyqN/bGThYg/ldQdP4g6hhikF5cw9JshHLshi3qdHUjhav7My+CiB0ZPBjHkAGA/MB7YBq+h4G9UvJ+3G0i4lMERE+o94/Yv4FH7Vv+h9NVtq+PuFT/IIF+LDed938cVw1VWdHyMajfLb3/6WP/3pT8TfUxljuOSSS7j88svTrlDnoagOhnQkFAqxevVq3njjDd566y2WLVvGpk2bOvXa3NxcZsyYwTHHHMPMmTM55phjOOqoow66/GTLFnjq7008/XiQt97PwxfxHvQe+dQzIaeCmVP9nHKGhzM/W8zomcMwLv1bKgObEhg9GcyYWCcv1TaqfUAJDBGR/sPv91NeXk4gEFD9iz7y4rUv8vCLJaxiJgDFxfDPf0JuJ98CVlRUcN1117Fq1apEX1FRET/96U+ZM2dO8gPuA6qDIV1RVVXF8uXLWbZsGcuWLeOdd96hoqKiU691u91MmzaNGTNmMH369EQrKys7IIEbicAbr0f455/qefVVWLOjgFDs4MnBDCKMyqjgyDH1zDrOcsq5Ocz9eCm5JVqeJwOLEhg9GcyYsZ291lq7PWk3lnYpgSEi0n+o/kXfqt5YzZ//5788zIXEcL5T+clP4NxzO/f6V199lRtuuIH6+vpE3+zZs/npT39KcXFxb4TcZ1QHQ7rLWsvu3bt55513Em358uWdTmoAFBcXM336dI466iiOPPLIRBs6tKWAZygEby6J8Mzf63llMby3LZ9A9NDL7rLxMTZ7L0dO8DN7ruGUc/OYedYwMvMPPrtDJJ0pgSEDhhIYIiL9R7z+RX5+fr9bdtAfvXDNC/xx0Tg2MQmAI4+EP//50IU7w+Ewv/71r/n73/+e6HO5XHzta1/j0ksvHRBLf1QHQ5Jtz549rFy5kpUrV7Jq1SpWrlzZqSKhrY0cOZIjjzySI444gmnTpiXasGHDiERg9cooCx9v4NVFYVauzaKiKb9T4+bQxNjcfUwbG+DY4+Ckj+Qw6yMl5JZ0cw9lkT6mBEZXBzDmTuCfwGsq2plelMAQEekfVP+ib1VtqOL+z73Kv/hEou/3v4djjjn46/bt28e1117bZslIaWkpP/vZz5g5c2bvBJsCqoMhfaGuro53332X9957j3fffTfxuLGxsUvjFBcXM3XqVKZOncqUKVOYPHkyU6ZMITd3PK8+F+KV//h4Z6WLdbvy8UU7N6PIS5CR3iomlDVx5NQYx53g4aRzCxl/7FBcbi2rkvSiBEZXBzAmAhigCngaJ5nxorU21PPwpCeUwBAR6R98Ph8VFRWqf9FH/vuthdzz6tGJbVNPOw1uvfXgr3n33Xe55ppr2LdvX6Jv/vz5XH/99QPu70x1MCRVYrEY27dv59133+X9999PtLVr1xIKde2jRUZGBuPHj2fSpElMmjSJiRMPJytzPLvWDmfdyuGsWZ/Dlr0FBGKdXz6STz2j8uqYMDLIlCkxjjney+wz8zl81hAyPCrvJ6mhBEZXBzCmFLgA+ARwGuABmoDngH8Bz1lrG3oWpnSHEhgiIv2D6l/0nb1r93LnF1bwXz4CONumPvaY4bDD2r/eWsvjjz/Or371KyKRCOAsGfm///s/vvCFLwzY2TKqgyHpJBKJsHnz5kQyI97WrVtHd97nZmRkMHbsWMaPn0DRkHGE6kdSUzGK8t3j2Vl9FL7YiC6Nl4OPsuw6xgwLcPj4CEcc7WbmvGyOPa2QIWVaiiK9SwmMngxmTAFwHk4y4yNAHhAEXsJJZjxtrd2btBvKQSmBISLSP6j+Rd957psL+dWS2dQxBIALL4Rrrmn/2mAwyC233MKzzz6b6CssLOSWW25h9uzZfRBt6jQ1NQHOEpmBNsNEBo5YLMbOnTtZu3YtGzZsYP369Ynjjh07uj1uQUEhQwvG4GYUYf9oGhonUBecQowJwGFAEc4E9EOxDHHVU5bXyJjSEOPHRZl6pJsjj8vi6BPyKJuYO2CToNJ3lMBI1sDGZOIkMT6Bk9QoBqLAUpxlJk9qJ5LepQSGiEj6U/2LvrP3g73c/MX1vM5JAOTkWJ56ytBqc4OE8vJyvvOd77Bu3bpE39SpU7n11lsZMaJr3872R6qDIf2dz+dj06ZNbNq0iY0bNyYeb9q0iZ07d/ZobHdGNt6MUdjoGILR8cQYB4wGxrQ6HvqzZA4+SrIaKBsSYMyICOPHwYQpbqbMyGLa8bmUTVCCQw5NCYzeuIkxLuAU4JPA+Tj/ZVtglbX2uF4PYJBSAkNEJP2p/kXf+dcVL/Crt04igDOl+xvfgEsuOfC69957j29/+9tUV1cn+j72sY9x7bXXkpmZ2VfhppTqYMhA5vf72bJlC1u3bmXLli0HNL/f3+N7GAqxjAFGASObj60fjwBKgY5n3WXhpzizkdL8AGUlEUaPshw23jB+sofJ07OZclweBSWD498k6ZgSGH1xU2Nm4SQzLrDWHtHnAQwSSmCIiKQ/1b/oG5XvVXLdl3axEmerkdLiGP962sX++Yh///vf3HTTTYTDYcBZK//d736XT33qU4Pum9Da2lpycnIoKytTHQwZNKy17N27l23btrFt2za2bt2aeLxjxw62b9+eWGLVcy6cJMaIVq2suQ3f73E+7S1byTVNDPX6KM4LUjo0TNlwy+gxhsMmuBlzuIcJR2Qz/shcsvK0PHGgUgKjqwMY83HgWWttLDkhSbIogSEikv5U/6JvPPz/FnPHipOJNn/b+dOfwjnntJyPxWLcc889/PWvf030DRkyhFtvvZVjDrW/6gDl8/mw1qoOhkgr1lpqa2vZsWNHon344Yfs3Lkzcdy5c2eXd005tCycREbpfsdhHbTWSUdLnmmi0BugKC9IcUGEYcUxyspgxGgXo8a6GTspk8OmZDHq8Gy8WdpRpT8ZbAmMZLxTehLYZYz5E/BH1bUQERHpnGg0SigUIhaLkZGhN4y9pXx1OU+vGJVIXkyaEOXss1v+vH0+H9dddx2vvfZaom/ixInccccdjBw5ss/jTRdutxufz9cLH8RE+i9jDEOHDmXo0KHMmDGj3Wviszh27drVpu3evTtx3LNnD3v3dmVvgwCwvbl1Rh5QkmiNtoTG4DB2BYuhqhi2FuOUKCzGKUqaC2RjiJFjmijwBCjMDjE0P0xRYYyS4hglwwxlIzMoG+1mxFgPI8dnMmpiFvlFnkE3Q01SJxkzMF4ATseZ0xQDXgB+h7PjSLTHEUq3aQaGiEh6i9e/CAaDFBQUpDqcAeuPl7zGfe+fRHz69f33w6xZzrk9e/Zw1VVXsXnz5sT18+fP56abbhr0S3pUB0Okd4VCISoqKtizZ0+iVVRUUF5enmjx84FAoA8iysRJZrRuQw/RhuAmh7wMyPMEKcgKU5gXoTA/xtAhlqIiKBlmKBmewbAyN6WjPJSO8TBibBZDhntxuZT46CnNwOgia+1ZxpixwFeAS3F2HlkAVLSalbGlp/cREREZaEKhEOFwWEtHetGeFXt45v1xxJMXc48LM2uWB4A1a9bwrW99q02xzksuuYSvf/3r+rCO801zRkYG4XCYYDBIdnZ2qkMSGVC8Xi9jxoxhzJgxB73OWktjYyOVlZVUVlZSUVGROO7du5e9e/cmliPu3buXffv2EYlEuhFRENjT3DovAtRGM6mNDoHAEKgtBOJtSKvH8VYAFOIihyyyyXFnkufNIj/LTX5ujIK8GIUFliFDYMgQGFqcwdASFyXD3RSXuSkZ6aF0VCZDy7y4Pfq3erBJahHP5t1GzgW+CpyDkyCJAYtwZmU8aa3tzn9N0g2agSEikt4qKirYt2+f6l/0Emstd312GQ9tnguAy1gefsQwYQIsXryY6667LrE8wuPx8MMf/pCPfvSjqQw57agOhkj/Y62lrq6Offv2tWl79+6lqqqq3VZdXZ0Gy8XcOMmN/OZj/HFHLRc3WWSaLLIyssjxZJKTmU1edjYFuVkU5rnJy4OCAigcYvj4xYXMPaedfbP7Oc3A6IHmQp7PAs8aY8qAy5rbmcAZwD5jzJ+BP1hrNybz3iIiIv1JNBolHA4Ti8WUvOglu97ew3ObJyWen31WhPHj3Tz00N+46667iH+JU1hYyO23397hevbBzOPx0NjYSDAQAK8XAgGnBYMtLRCAUAjCYae1fhyJOC0abTnGH1sLsdiBx7j2vmQz5sDmckFGRttj/HG8ud1tH7duHk/bx16v01o/bt00O0fSnDGGIUOGMGTIEA4//PBOvcZai9/vp7q6+oBWW1tLTU3NAa22tjZxLr5zU89EgOrm1vlXRCw0RaAqAviB2vhZD04tEKdt3vNNHjnnf5MQp6RSr71jstaWAz8DfmaMOQNnickFwHeAb/fmvUVERNJdMBgkHA7j8XhSHcqAZK3lzz+voLp521RvRpQrrnTxi1/8gscffzxx3ZgxY7j77rsPOYW737HWSSw0NDitsRGampzW2Njy3OdraX5/y9Hvh0AAdyBANCeH8J49RPfsISOmTedwuyEz00lmZGYe+LgzLSur/ccdnWt9bP3Y63WSOCI9ZIwhJyeHnJwcRo8e3aXXxpMf8WRGXV3dAa22tpb6+nrq6uoSx9qaOqqr66ivq6PJ30gkkuwZIGGgprmBNzuY5PElFfoqifAKThWY8cDsPrqniIhI2orXv1ACo3dsW7KbF3a0zL741AX13HLLDSxZsiTRN2PGDH71q18xZMiQFETYSdY6SYWaGqfV1jqtvh7q6pxj6xZPWDQ0ODMdesgAnmiUsNtNyOslu08KCaa5+KySpqZUR+LoKNHR3vFQ59p73lHf/k3JlEGrdfKjJzs3BYNBGhoaqK+vT7SGhoYOW319I9X76qiprqe+roGGxkb8/iYCwSYCoSb2309i8pEDb/nIYNSrCQxjzBScmRdfxNnDxwBbgT/25n1FRETSXXwGRlZWVqpDGXCstdz381qaGAVAjnc3y9/9Dhs3bkhcs2DBAm644Qa8Xm9qggwGYe9ep+3bB1VVLS3+PJ60SMrU7O7zhMOEPB5CeXlkd/ShtvWyi/jSi9ZLM/ZfwhFf4hFfAtL62PpDcOvH1rbfYjGnRaMHHlsvWdn/ceslLpFIy7KX1stgQqGWFgw6x3QTX8qTDjqamdKZ4/6PO9s6WvbT+vew9dHtVqIlTWVmZpKZmUlJSUmPx7LWEgqFaGxspLGxkaamJkaNGpWEKCXVkp7AMMZkARfiJC5OxElahIF/Ar+31i5M9j1TwRgzGvgJcDbOBsp7gCeBG621NX09joiI9B+RSET1L3rRBy/u4vXy+OyLLWR4v8HGjRWJ85dddhlf+9rXML3xIcZaZ3lGRQVUVjrH+OPKypakRX198u+9v8xMyM93Wl4e5OYeeMzNhZwcyM4+8Ni8XMHjdtMYDhMcPhxKS3s/7nRmbUtio3UdkJ629uqK7H9s73GKk1sHiMff0JDqSA6udb2TeNKtqy0+RkePO3Nsrw5LV9v+dV1aJwkHMWNMIiFSXFyc6nAkiZL2rskYMxNn95HP4ZSMNcBm4A/An6y1lcm6V6oZYyYCS4FS4ClgHc7SmG8CZxtjTrTWVvXVOCIi0r+EQiFCoZCWj/QCay333hoghBd4B8O3aWhsBMDlcnHddddx/vnnd/8GPh/s2dOSmNi/VVY69SOSKSureS/BoU4bMgQKC5tL67c6xsvtFxQ4j5P0++W2lmhVFeFwmGg0SkZGRlLG7ZeMafmGPy8v1dE4M01aJz1aJ0L2T3i0d66zjzvT0i2ZcjDxWTfJ/m81nRjTcXKjvcK2HfXt/7i954dq+1+/f5Hdg7X9r239vL3HB+s77DDn31Dp13qcwDDG/C9O4uIYnKRFCHgM+J21dlFPx09Tv8FJOlxprf11vNMYcztwNXAzcHkfjiMiIv2ICnj2nuVP7WZ59QTgeeBGLM6HqpycHH7xi19wwgkndPxia536Env2OG33budYXu60PXuS981yRgYMG9bSiotbWkkJFBU5behQJ4GRQsYYPB4P4XCYUChEdnZ2SuORVlwuZ7ZMOvydxGJtZ6bsP0tl/6U4rRMf+5+P97dewhM/13qZT0f9+59vfS4JtWH6BWtbEjXieOgh+PznUx2F9JCx7W1R1ZUBjImXo94A/B74i7V2X08DS1fGmAk4M0u2ARObt46Nn8vHWQJigFJrbYfVnZI1ziFibcrOzs7x+XzdebmIiPSS8vJy9u3bR0FBgZaQJJG1lktO38kHDS8B9yT6S0pKuOuuu5gyebKzdGP37rZt166WpEUyilRmZcHw4S2ttLSlDRvmHIcO7Vfr8H0+H7FYjNLS0vQueipyKLGY86G+dWJj//on+9dEad3aOxfvO9jxUH3xx/E6Le31x8+1d/3+5+RA//gHfPazqY4i6XJycvD7/T5rbW6qY+kLyXjX9A+c2RavJGGs/uD05uPC1kkHAGttgzFmCbAAmAu81AfjiIhIPxIOhwmHw1hrlbxIsv/+eSdbGv7CBJ5kFDASOKKggDMmTiTrhhucREVPk/peL5SVtU1QlJU5SYn487y8fpWc6AyPx0NjYyOhdCxiKdIVLlfLMqCBLJ6oaS+5cbDitvv3tX7eUWHcg7X2rtu/yO7BWutru/K4vYK+Sr4OCD1+52StHWzzcKY0Hzd0cH4jTuJhMgdPPCRrHBER6Ue0fWoPBYMtsyV27UrMooju3MmcdZt4nf2+eayvh2XLOj9+Tg6MGgUjRrRtZWXOsZ/NnEgWt9tNLBZTHQyR/mKwJGpk0ElGDYwvdud11tq/9vTeKVLYfKzr4Hy8f0gfjYMx5p0OTmlvPhGRNBOvf5Gy7TvTXTjs1Jtob4nH7t3O9qLtyAA6VZotKwtGjnSSFPHjiBEtxwE4eyIZjDG43W5CoRDBYJCcnJxUhyQiIoNQMuau/hnoSiEN03x9f01gHEr8XU/PioskbxwREUkT8X3pw+Hw4P0AGAy2JCjihTHjxTL37HG2GO1Bfa4wsM+VR9nxR2JaJylGjnTakCFKUHRT60Keg/b3V0REUipZi28jwLPAB0kaL53FZ0YUdnC+YL/renscrLXHtddvjGkCBvY7jHvugT//uevbKHVmC6f2tm3q6rZRh9pu6mBbWHV2uyvt+S3Sb0QiEcLNWw0OyCn40agzQ6L1tqLxHTziraamZ/dwuZzlHCNHUpGRwTMrVrAjHGYXsAcXNVzD009+DDMyMyk/krTwer00NDQQDAZTHYqIiAxSyUhgvALMBy7A2RL098Cj1toklPFOS+ubj5M7OD+p+dhRbYtkjzO4ffghvNPRCppByJgDkxvttYOd93i61newY0d9+5/zeJw1mvufb6/P7da3p9JvBYNBQqFQ/6x/4fM5syMqK2HfPucYfx5v+/Y5BdN6wuVyCmKOHNl2aUd8BkVpKWRk8Pjjj/PLX/6SWOJ+ecCtXHRiGcOUvOgVretgRCIRFaEVEZE+l4winqcZYw4Hvgp8EfgTcJcx5iHg99bad3t6jzSzuPm4wBjjamf70xMBP/BmH40zuA2Wvbw7y9qWLb0GstbJjfaO+z9u7/mhWmZm+8/bO+7/ODPTuZ8SLbKf+PKRtKl/EQ5DbS1UV7e0qionEbF/S9aW3C6Xs1NHvDhmPDERL5I5fLjz308HrLXcdeedPPTQQ616RwB3M8RVzP/9JDs5cUq7PB4PoVCIUCikBIaIiPS5pPyfx1q7CfieMeY64HycZMbXgCuaC0z+FnjYWtuUjPulkrV2szFmIc4OIV8Hft3q9I1ALvDb+M9qjPEAE4GwtXZzd8eRDlx1FVx0UftbJR2s72CPO7ONU3e3jdq/r6OtrNrbzupgx8G253d/SNIYc2BSo72WlXXwx4c635lzmZlaXpQGrLWJAp55eXnJHhwCAWfHjf1bbS3U1TnH1q2mBhoakhsHQFGRk4QYNqwlKRHfdrSsDEpKuv37GAgE+NGPfsTixYtb9R4B3AkU8fmzt5JdOD4JP4R0JF4HQ4U8RUQkFYztQaGsgw5szFjgK8ClOFuxNwJnW2vf6JUb9iFjzERgKc6SmaeAtcAc4DScJR/zrLVVzdeOA7YC262147o7TjfjbMrOzs7xJetbM0l/sZjzwb6jBEfrc6339g6H2/a1vr69vtb98ccH6299vnWLRCAUav9cR/2addM9Hk/bBEfr1rqvvcedTZK0NxulvVkrg3QZUCgUory8nPr6eoqKilqSDvs3v9+Z7eDzQVNT28dNTU7SId4aG1se93YS0+t1kg+lpU5yIt5KS50WT1r00vKY6upqrr76at5///1EX2HuydQ13QJkMdpdzmOLi/Fk98PlOf1IJBKhvr6ekpISysrKUh2OiMigl5OTg9/v91lrc1MdS1/otbl/1trtwI+MMUtxZmCMAob11v36UvPsiVnAT4CzgXOBPcDdwI3W2uq+HGcwa2xsJBKJkJeXp6ms4HyrmTnA137HkzStkxyhUNvHrfs6uiYUcnZD2P956/7483hfR8/be5xuM2Lif2aNjamOxNHe8p+O6p50VGdl/+K48ecuV9vCvfFmTPuttdZJfWtbZl/tP6OrvSRfR79/oRAEAgSNIZybizcScWZApMMsIpfL2ZWjqMhpQ4dCcbGTqNi/5eenLPG0detWrrzySvbs2ZPoO/20z7Fo8VWAC7B85aIGPNn6QN3b3G431lrC4TDhcLh/1nMREZF+q1c+8RljRgKXNbexQAB4CFjRG/dLBWvth8CXOnHdNlq2RO32ONK+yy78CY/951YAMjIyyfLmkJ2VR25OLnl5eRQU5jO0KJ+ikkIKCvLJy8sjP985FhQUkJ+f3+FRCZE0FU/SpHuiJhZrSWa01wKBzj9v7/H+x4ONEwql+k/jQP1hGVCShYqLCQOZgUDv/OxeLxQUOK2w0Ek4FBQ4CYrCQucYb4WFTrKisDDtlxe9/fbbfPe736WxOfnmcrn4zne+yz/+dB5O8gKOyNrKOV+fkMIoBxev15uog6EEhoiI9KWkfUIzxriA83CWjZzdPPZ7wDeBB621h9wOVKSr3n+v5dcqGg3S5A/S5K9hXw936QPI9OaQl5fPkMJChhYVUjikgIKCAgoLCxOtoKCAIUOGUFhY2O4xbQr1Sd9zuSA722mpZm1iFkC7iZD4Y7+/7fnW7WBJkvba/rNaWs9sGWSJCwBrDEGvl7DHQ17ruhOZmc7vSHzZTvxxdjbk5DgtN7flmJvrJCby8yEvr+0x3ZN63fDMM89w0003EW1eOpadnc0tt9zCvooT+HCvsw1tBhH+35cjZHgH4La0aap1HYzc3EExY1lERNJEjxMYxpjxwJdxZhGMAJqAv+DsQPJWT8cXOZhwKAMowCmx0sOt+/YTDPkIVvuoqq5wqph0Q05ODkOGDGHo0KEMGTIk8Xj/VlRUlDjGm5IfkjTGpNeslfhuOfsvs2iv5knrein7Hzsqfrv/0o/4sg9r22/7L4to/Ty+PKX1UhSXq+3SltbLWtrb+cbjIeR2E/b5cEUiuEpKnCTFIK0F0hnWWu677z4eeOCBRN+wYcO46667OOywyZz3kTDgJCyOz1vLvIuPTFGkg5PH46GpqYlQKIS1FqPfYxER6SPJmIGxqfm4HLge+Id2zpC+8t0rfsDLC7/rFNtvDFHv89MYCOALBfCHAwRiAUI2SJQA0NDcGoH6Vs8bWj1vfex5gVufz4fP52P37t1dfm1eXh5FRUUUFxdTVFRESUkJxcXFiVZSUpJow4YNo6SkRBXhpX+I79AyiJJ0oYYGIpWVeKJRZ8aEdCgUCnHDDTewcOHCRN+kSZO46667KC0t5ff3R6ltcpYt5ODjK1dk4vKk9zKYgSYjIwNjTPptCywiIgNej3chMcbEgDBQ0YWXWWvt2B7dWA5Ju5C0CPqi7N0VpGpPmL17QlSVR6iujFK1N0pttaWmxlJXB3X1LuqbXDQ0GRqCYZrCAXzRIMFEAqTuIK221TH+uG93zMjJyUkkNEpLSyktLT3g8fDhwxk+fDilpaV60ynSR/bt28fevXvJzs7Wf3cHUVNTw7e//W3efffdRN+JJ57ILbfcQk5ODlVV8PHzYgTDTsJiQeFb3PT8LCUwUqCxsZGMjAyGDx+e/G2BRUSk07QLSfd4gNFJGksk6TJzMhg9KYfRk7r3+kg4RuWHASq2h6jYGaJiZ5h9FVH2VcSorrJUV0NNnYu6Bhf1fjcNAS8NIS8+osRoAGpoSWzUtGrV7Tyuan7c9SUxPp+PHTt2sGPHjk5dP3To0ERCo6ysjLKyMkaMGJF4HH9eUlKCK80L/YmkK2tt4pvq/Pz8VIeTtrZv386VV17Jrl27En2f+cxn+M53vkNGhrNc5L57W5IXRVTz+a/nK3mRIh6Ph2AwSDAYVAJDRET6TI8TGNZavXOQAc/tcTFyQg4jJ3RtiUYsatm3K5Odm/LYs304e3aEqdgVpWJPjL17oaraUFOfQW2Th7pAJg2RLAJk4yQvGnCSGfGExr5Wz6uan8fb3uZj13abqKmpoaamhnXr1h3853e7GTFiBCNGjGDkyJGJNmrUqEQbPXo0BQUFXbq/yGAQT1643W4lAjuwfPlyrrnmGurr6wEwxvCtb32Lz372s4n6Clu2wNPPtNRaOHXoaqZ97JSUxCtOAqOxsZFgMKg6GCIi0me0T6RIL3JlGEoPy6b0sM7vRNFQHWLHej87NgTYtdXDrh3D2LO7mIryyeyrcVFV56HGn0ldKAc/rce1OPU99ja3ylbH+OOKVm0vnZ3lEYlE+PDDD/nwww8Pel1eXh6jR49m9OjRjBkzpk077LDDOOyww1SxXgadYDBIOBzWdpMdeOyxx7j11luJxZx/j7Kysrj55ps55ZS2yYk777DErPMheRQ7ueDyMs2+SCGXy4XL5SIcDhMKhchMlyLBIiIyoCmBIZJm8ou8HHmClyNPKDzktQ3VIba852Pz+352bA6zc1uE3bthT0UZlTVjqGrKoiacS4j23lhGcWZyVADlrY7lwJ5Wxz04S18OrbGxkXXr1h10RkdxcTFjx45t08aPH8+4ceMYP368ZnHIgBMMBgmFQiqyu59IJMKtt97KE088kegrLi7mzjvvZNq0aW2ufestWPpG/Bt+y2lF7zL142f3YbTSHo/HQyQSUQJDRET6TI8SGMaYbGutP9VjiAxW+UVeZpziZcYpQzq8xlpLxTYf61c0sen9AFvWR9i+1bJrj4vyai/7mkZTE51G9KD/HPhxEhm7m4+7mh/vAnY2H3cBgUPGXFVVRVVVFStWrGj3fFFREePHj2f8+PFMmDCBiRMnJo5jxozB7VbeVfqPWCxGKBQiGo1qBkYrtbW1XHPNNW3+HZg2bRq/+tWvKC0tbXNtLAZ33G4BJ4ExmQ185H/Ha/ZFGvB6vfj9foLBoOq7iIhIn+jpJ4GtxphbgPuttcGuvNAYMwP4Cc72qz/tYRwi0gFjDGXjcygbn8Mpn2r/mnAgysaVNXyw3MfGNSG2bIzx4U7Drr1eKhpzqI4UEGUCMOEgd7I4tTp2Ah8mjm6zFW/GdnDtJBDZQywWPmi81dXVVFdX88477xxwzu12M27cOA4//HAmTZqUOE6aNIlx48YpuSFpJ758JL7tpMDmzZu5+uqr22wvvWDBAq6//vp2v8V/7jnYuMn5s3MT5pSSD5j88Y/3WbzSMbfbnZiBEYvFVONFRER6XY+2UTXG/BX4PM5+kY8AjwJvdjSjwhgzAfgI8EVgNs6nnIutta93OwjpkLZRlWQJNoXZsLyBNW81sX5NiM0bLdt2ZLCzKpvKQAE+Ojs1PoqzNGUHXrORguyN5OZsx531IYHYTvbu20Eo1LVCpHFut5sJEyYwdepUpkyZ0uZYXFzcrTFFeqquro7KykqMMVpCAixevJjrr7+e1v9f+vrXv86ll17aboInEIBPfsJSudc5dywruOraLI749BF9FrMcXG1tLbm5uQwfPpysrKxUhyMiMugMtm1Ue5TAADDGzAJ+BpzR3BUF1uLMM68BsoBiYApQgjMHtAK4C7ijqzM3pPOUwJC+EIvG2P5ePStfbWTNiiDr18bYvN3Dh9W5VIaHEKEr0+ajlGRtYmTJBkpHbKNw+G5M5i5279nMli1bKC8v71aMJSUlHHHEEUybNo0jjjgi8XjkyJH6Vlx6VWVlJXv37iUvL29QLyGJRCLcc889PPTQQ4m+nJwcfvrTnx5QrLO1P/0J7r3XeZyNny8Pe4YvPP0pMjwZvR2ydFJTUxPGGEpLS1XDSEQkBZTA6O5AxkwCvoyTyJgJ7P/uYi/wKvAE8IS19uDzyKXHlMCQVAs0hHj31Vreea2J91ZEWLchg63l2ewOFnVQWLR9Q7xNTBndxFFHNXL4jAqGHbabfVWb2LRpExs3bmTjxo1tpqN3VmFhIUceeSRHHXVU4njUUUcdsAZfpDsikQjl5eXU1NRQVFQ0aJNle/fu5dprr2X16tWJvpEjR3L77bdz+OGHd/i6mho4/3yLz+f8uZ3Ma3zle0Uc+Zkjez1m6bxQKITP52PYsGEMGzYs1eGIiAw6SmAkY1BjcoBRODMv/ECltXZP0m8kB6UEhqSrUFOY1S9X8daiJla+HeGD9W627CugMlaMpXNrqIuzmjhyfBNz5hrOOD+fGXMi7NmzkXXr1rF+/frEcf369fj9XasTPGzYMKZPn8706dOZMWMGM2bMYNq0aaqyL13i8/moqKggGAwO2m+m3377bX7wgx9QU1OT6Dv55JO58cYbD/ln8stfwqOPOo+HUMMlJf/hc09fRIZXsy/SibWW6upqioqKGDFihOpgiIj0MSUwZMBQAkP6E2st5etrWfJMLcteDbD6PRcbduexOzyMMN5Dvt4QY+zQeo6fEeKs87I4+8J8xowxxGIxduzYwQcffMDatWv54IMPEo/r6uo6HZ/b7Wbq1Kkcc8wxHHvssRx77LHMnDlz0H4wlUOrqamhsrISt9tNdnZ2qsPpU9ZaHnjgAe6//37i7zNcLhdXXHEFl1xyySFno+zYAZ/5jCUada77CM/zP98dzVEXHdXrsUvX1dbWkpOTw/Dhwwfd77qISKopgSEDhhIY0t9Za6nd0cDrT+1jyUsBVq12sX5XHjsjwztVW2NYThPHTvNx+ke8XPDFAiZNNsQ/N1lr2b17N2vWrOH9999nzZo1rFmzhg8++ICmpqZOxzhp0iSOPfZYjjvuOI4//niOO+44bScoAJSXl7Nv3z4KCwvJyBg8swb27dvHDTfcwJtvvpnoKyoq4pZbbuG4447r1BjXXAOLFjmPR7CHi4Yt4n+e+qxmX6Qpn8+HtZbS0lIKCwtTHY6IyKCiBIYMGEpgyEBkraVyfQ2v/rOK114KsvI9Dxv3DaHSDjvk8pOibB9zp/s4+xNZfOyiXMaNO/Bb4FgsxtatW3n33XdZvXo1q1ev5t1332XLli2dis8Yw9SpUzn++OOZNWsWs2fPZubMmVp+MsiEw2HKy8upq6ujqKgo1eH0mVdffZWf/OQn1NbWJvqOPfZYfvazn1FSUtKpMd59Fy67rOX5J/gXn/jeFI74jHYeSVfhcJjGxkaGDRumGkIiIn1MCQwZMJTAkMEiEoywaUkFzz9cy2uvWFZvyWNHZOQhl56U5TdxyglBPvGFPM7+mJeDfXFYX1/Pu+++y8qVK1mxYgUrVqzg/fffJxqNHjI+r9fLzJkzmTNnDnPnzmXOnDlMmDBh0BZ1HAwaGxupqKggEokMihk5gUCAO+64gyeeeCLRZ4zh0ksv5fLLL+/0DBRr4ctfdpIYABPZxPnD3+KiJy/SziNpLF4HY+jQoZSVleF2u1MdkojIoKEEhgwYSmDIYGVjlt2r9/Liw/tY9N8wb6/NY0toFEGyOnyNixhHjmvknHNdfOILuRx/vOFQn7n8fj9r1qzhnXfeYfny5bz99tudTmqUlJQwb968RJs1a5bWjg8gVVVV7N27F6/XS1ZWx793A8H69eu57rrr2LZtW6KvtLSUn/zkJ8yaNatLYy1eDN/9rvPYRYyLeIRzvz+TaZ+alsSIpTfU19eTmZlJaWkpubmD4j20iEhaUAJDBgwlMEQc1lp2r6rk+b9U8sLzUVZsKmBrdMxB62gUZgc5c36Iiy7L5SNnu+hsrU6fz8eqVat4++23efvtt1m2bBmbNm065OvcbjfHHnss8+bN4+STT+akk07SVOx+ylrLnj17qKqqYujQoQN2V4ZYLMbf/vY37r33XiKRSKL/jDPO4LrrrutygdtIBC680CngCXA077GgbA0X/esiXJ6B+Wc4kPj9fiKRCKWlpQwdOjTV4YiIDBpKYMiAoQSGSPui4ShbXt/Fs3+qYuELsLp8OHsY2eH1bleM2Uf7+fQXsvjkpzMYO7Zr96uqquKtt97izTffZNmyZSxbtqxNjYCOTJ48mZNPPjnRxo8fr2Un/UAwGKS8vJzGxsYB+0Fu27Zt3Hjjjbz33nuJvuzsbK655hrOO++8bv2ePvYY/OIXzmMvIT7Lw5x13fFM+4RmX/QH0WiUuro6SkpKGD58uP6tEhHpI0pg9MZNjBlmrd3b6zeSNpTAEOmcxvJG3np0K0//w8dr7+SwPjyeJvI6vH76JD//v707D4+rrPs//r5ny8wkTdI23YAClraUAgWk7GWHsrggyCIIAs+Dsqqg/NTHFVQe9XFDEBFBwV1Q2dygUOhCC7KXrUApFKilTdvssy/3748zM03aJM0yyZnl87quuU7mnDMn35SQmfnMfX/vcy4McMZZXqZNG/z3y2azvPbaayxfvrxwe/XVV7f7uB133JEjjzySI488kiOOOILdd99dbxJKUEdHB83NzWSzWerq+v49Kkf5URc333wzyWSysH/27Nlcd911TJ06dUjXjUTgIx+B1lbn/kH8m3lT3uSsuzX6opy0tLRQX1/P5MmTCQS2v/y1iIgMnwKMkfgmxqwCTrDWDqyNvxSFAgyRwcums7y1+G3+dss6/vmAhxc7d2U9U/o8f8/pcc4+P8DZ53iGFGbkbd68mccff5xly5axdOlSnnrqqR5vEHszadIkjjjiiEKoMXv27IqdrlBONm3axMaNGwmFQhX1Jq63URc+n4+LLrqICy64YFiNG2+6CW6/3fm6jk7O5C6O+dphzDpl1nDLllHU1dWF1+tl4sSJVdG8VkSkFCjAGIlvYsxPgLOAk621z3bbfwTwHWvtYSNeRBVSgCEyPDZr+c9T/2Hpr9/ivr+keGbjVN5kGll67+55wJwE/3VpgLPOMgx35kA8Huepp55i6dKlLF26lGXLltHZ2dnvY8aPH98j0JgzZ44CjVGWzWZ57733aGlpYdy4cRUxQiaTyfCHP/xhm1EXu+++O9dccw0zZswY1vXffdfpfZFKOfeP5lH233EDZ/71TDw+/f6Wk0QiQSKRoKmpacDL5oqIyPAowBipb2TM1cDXgDOAZuC7wPHAXdbas0eliCqjAEOkeKy1bHhhA0/c8Rp/+X2CJzfuymp26zXM8HuznHxilv/6lI8TT4RifAifTqdZsWIFixcvZsmSJSxZsoTW/Hj7PowdO5YjjjiCo446iqOOOkqBxiiIx+Ns2LCBSCRCY2Oj2+UM28svv8x1113H66+/XthXrFEX4Cyb+tnPwvLlzv2JbOAU7ueobxzB7h/afVjXltGXzWZpaWmhqamJKVOmVESAJyJS6hRgjOQ3M+aLwLcAA9wLXGOtfXnUCqgyCjBERoa1lnVPr+PJ37zGX/6Q4KmW3XiD6Vi2DQfG1qc5/0IvF33SsOeexashm83y0ksvsXjx4sJt06ZN/T4mH2gcffTRHHfcccyePVtvMIqsvb2d5uZmjDGEw2G3yxmyrq4ufvazn/HnP/+Z7q8TijXqIm/JEvjc5/L3LKdxL9N2SnDWX8/CePW7WY7a2tqora1l0qRJFb+EsIhIKVCAMRLfxJipwFeBC4CngX2AK6y1d4z4N69iCjBERp7NWt557B0W/ewV/nyPl2eTe/W5osnc/dJ86lIfZ53FgJdlHXAd1rJy5UoWLVpUCDQ2bNjQ72OmTJnCcccdx/HHH89xxx3HlCl99/qQgWlubmbjxo3U1dXh9/e9TG+pstbyyCOP8P3vf79HIFZTU8MnP/lJzj333GGPushLJOCMM2DdOuf+bFZyOI9x5DVHMvODM4vyPWT0RSIRACZOnEhDQ4PL1YiIVD4FGCPxTYyJAy8AX7HWPmSMOQb4K/ADa+11I15AlVKAITK6kl1JXv7zy/zzprd44JkJvMAcOtj2BXyoJsuZHzNceqnhwANhJAZBWGt57bXXWLRoUeG2vUBjzz33ZP78+ZxwwgkcfvjhZT2CwA2ZTIb169eXbf+Ld955hx/96Ec89thjPfYfeuihfPGLX2THHXcs6ve79Va45Rbn6xrinMVdTJkW4vQ/nY7xlNe/nWyRTCaJRqM0NTUxceJEt8sREal4CjBG4psYc7q19i9b7dsH+Adwv7X2shEvogopwBBxT8sbLTz9y+f48y1tLG+dxavM6rVfxj57Z7n80x7OOQdqR/BpJx9oPProozz88MM88sgjtLW19Xl+TU0Nhx9+OPPnz2f+/PnMmTOn7N6Qj7ZoNMqGDRtIJBLUF3uIzQhqa2vj1ltv5S9/+QuZTKawf/z48Vx99dUcd9xxRf9vv24dnH465HuCHs5SZvMqJ/7kRKYeNrSlWKU0WGvZvHkz48ePZ/LkyXi9vTc9FhGR4lCAMdgLGPNl4G5r7atDeOwuwL+stbOHVYT0SgGGiPsyqQyv3f8ai258ifsX1/Mc+9HMpG3OG1OX5RPne7j0UoraK6PPujIZnnnmGR5++GEeeughli9f3u+yrZMmTeL4449n/vz5HH/88UyePHnkiywzra2tNDc34/P5CIVCbpezXclkkjvvvJNf/vKXdHV1FfYbY/joRz/K5ZdfPmJLYX7+87B4sfN1Exs5lXvZce4UPnDzBxSUVYD29naCwSCTJk3SSC4RkRGmAGOwFzAmi9OM85vd9oWstbEBPn6stbb/VvoyJAowREpLy+oWnvnFs9z/i/d4rG0vXmIv0mzbJ+G44yxXX22YP39kppf0JhKJsGTJEhYsWMCCBQt45ZVX+j1/zpw5hTDj8MMPL4s37CNt/fr1bNq0ifr6+qL1iRgJ1loefvhhbrzxRtblG1DkvP/97+eqq65ijz32GLHvv3w5fOYzW+6fwr1MZiMf+e1HmLDHhBH7vjJ6YrEY6XSaiRMnMna4a0qLiEi/FGAM9gK9BxjfAC631m4z+dEYMxnotNZGhvWNZbsUYIiUpnQizct3vcyjP3qeB56fxNPMZTNN25y3156Wz19tOPtsqKkZ3RrXrl3LggULePDBB3n44YdpaWnp89yamhrmzZvH8ccfz/HHH8++++5bdcu1plIp1q9fT3t7O+PGjXO7nF6l02kWLFjAHXfcwZtvvtnj2M4778xnP/tZjjjiiBEdAZFKwZlnwrvvOvdn8hpHs4TpJ07n6G8fPWLfV0ZXOp2mo6ODpqYmjdYSERlhCjAGe4G+A4yvW2u3mfiYO/ZVa235tWcvMwowREqbtZb//Ps//PuGJ/n7nRH+nd2fV5m1zXKsUyZbPv0Zw6WXQmPj6NeZyWR47rnnWLBgAQ899BDLli0jlUr1eX5TUxPHHHMMxx57LMceeyzTpk2r+GkBXV1dbNiwgXQ6PWLTLoYqkUhw//3389vf/nabERcNDQ1cfPHFnHbaaaMyauT22+Gmm5yvAyQ5izup8yc5869nMmaH0vp3k+HZvHkzjY2NTJ48uSxX5BERKRcKMAZ7gaEFGL0ek+JSgCFSPjrf6+Tpnz/NA9e/xuKO/XiW/UgR6HFOfb3l0582XHUVjB/vUqE4b9YXL15cCDRWrlzZ7/m77LJLIcw45phjKvIT2c2bN7Nx40ZqamqoGe3hMn3o6Ojgr3/9K3/84x+3GUETDoc544wzuOCCC0YtcHn7bTj77C2NOw9lOXvzMnt9fC8OueqQUalBRk9nZyc+n49JkyZRV1fndjkiIhVLAcZgL6AAo2QpwBApP4nOBE/f/DQLv/8sSzbtwb85iC56vsGsq7Ncdpnh85+HUlilcO3atYVmoA8//DDNzc39nj9z5kyOPPLIwm2nnXYapUpHRjabLfS/GDdunKvTZ6y1PP/889xzzz08/PDD2zRmbWxs5Oyzz+bMM88c1ZEi1sJFF8GKFc798WziVO4hNCbAx+77GDX1pRH6SPHE43GSySQTJkxgvJuJq4hIhVOAMdgLKMAoWQowRMpXKpri2V8+y+LvPs7j63blMQ5jEz0bHIZClksuMfy//wdTprhU6Fay2SwvvfQSCxcuZOHChSxevLjHChe9mTZtGkcccQSHH3448+bNY8aMGWU15SQej7NhwwYikQiNbszxwVn14R//+Ad33303a9as2eb45MmTOe+88zjllFMIBoOjXt+dd8L3v+987SHLR7iHCbRw0GcPYs55c0a9Hhl52WyW1tZWxo8fz5QpU8rq/2kRkXJSrADDGLMT8E3gRGA88B5wL3DtUBfdMMacB/wmd/eT1trbhlMjFC/A+Ia19lvd9inAKAEKMETKXzqRZsWvV/DotUv497qdWMIR2yzDGgzCxRfDF79YOkFGXiqV4qmnnioEGk888QSJRKLfx0yYMIF58+Yxb948DjvsMPbbbz8CgUC/j3FTe3s7zc3NGGNGdcnIeDzOsmXLWLBgAUuWLOm1L8ns2bM588wzOfHEE11bGWXdOqdxZzzu3H8/z3IAz1A3uY4z7z4Tb0AvBypVa2srdXV1TJ48uWSmVomIVJpiBBjGmN2A5cBE4D7gVeBA4GjgNeAwa+3mQV5zKvAi4AXqKLEAI5Ur7qnc7TDgAgUY7lKAIVI5UrEUT974JEv+9zFWtO/KYo5gPT3TilIOMvLi8ThPPvkkixcvZvHixSxfvpxYrP9Vt4PBIAcccACHHnoohx56KIcccggTJpTOcpvNzc1s3LiRurq6EW9WmEwmWb58OQsWLGDp0qW9/tuFw2FOOukkTj31VGbNmjWi9WyPtXDZZfDUU879caaVU+3d+Mhy1LeOYsZJM1ytT0ZWV1cXHo+HiRMnUl9f73Y5IiIVqUgBxoPAfOAz1tobu+3/EXAVcIu19pJBXM8ADwHvA+4GrqaEAoyHgP2A/Lpx3S/4GLCi2+1F4EsowBgVCjBEKk+sNcZj332MJ67/NyuT01jMkaxjxx7n1NRsCTJ22MGlQgcomUzy9NNP89hjjxVura3bH6U4ffp05s6dy3777cf73/9+9ttvP1fm2afTadavX09rayvjxo0r+jB5ay1r167lqaee4qmnnmLZsmX09Td99uzZnHbaaZxwwgmEQqGi1jFU99wD113nfG2wnMK9TGITTbOb+MivP6JpBRUumUwSjUaZMGFCSYWOIiKVZLgBhjFmGrAaWAPsZq3Ndjs2BmcqiQEmWmsjA7zmZ4EfA0cBxwDfoFQCjMKFnB98brfbfkBD7nD+m2SBLqBeAcbIU4AhUrna321n0TWLeP72Fbxup7OolyCjHEZkbC2bzbJy5Uoee+wxli5dyvLly3nrrbcG9Nidd96Z/fbbj7333ps999yT2bNnM3PmzBHt+RCJRNiwYQPJZLIonzBba1m3bh3PPfdcIbTorynqrrvuyvz58zn++ON53/veN+zvX0zNzXDGGRDJvdSZwwscwr8BOOWOU5i4Vwl0oJURZa2lpaWFcePGMXnyZLxevfQTESm2IgQYFwG3Ar+w1l7cy/H86IzjrLULB3C9PYBngZ9ba68yxlxDKQYYvV7cmJn0DDX2xZn/YhVgjDwFGCKVb+MrG3nkK4+w8t5XWcWMPoOMSy91goxJk/q4UAlbv349jz/+OMuXL2f58uU8/fTT26yu0RePx8Nuu+3G7Nmz2X333Zk2bVrhtvPOOw97ykdLSwsbN27E7/cPOijp6urizTffZNWqVbz++uusWrWKN954o88RFnlTp07l+OOPZ/78+ey2224lOYrBWrjySli2zLk/1tfJqek/4yfDzA/P5MivH+lqfTJ62tvbCQaDTJo0aVR7xIiIVItcgJEFnu/tuLV2//4eb4z5Ps4Uj6uttT/s5fhPgcuBy6y1N2/nWj7gCWAMsK+1NlbsAGNEO3pZa18HXgf+AIW5MHsA/f4jiojIwEyYPYGz7jmLdx9/l4VfWsiMJbexiuks4qhCkBGPw49/DD//udOP4AtfKI3lVwdq8uTJnHrqqZx66qkAJBIJVqxYwXPPPcezzz7Lc889xwsvvNBrc9BsNsuqVatYtWrVNsc8Hg8777wzu+yyC1OmTGGHHXbosZ04cSK1tbXU1tYSDocJhUI9lki11pJIJEgmk9TW1mKtJRqNEolEiEQidHV1FW4bNmzgvffe63Hb3uosebW1tey///4ccMABHHDAASUbWnT3wANbwguAw9OL8JPBX+vnwCsOdK8wGXWBQIBkMkkikVCAISJSmvKzJtr7OJ7f3ziAa30dZybGPGtt/03OhmhUW5JbZ7jHK7mbiIgUydRDpnL+ovN5419vsPB/FjLjhdt4nRks4ijew2mEEYvBD3/oBBlXX+3c6upcLnwIampqOPDAAznwwC1vhFOpFCtXruT555/nlVdeKdzefPNN+hppmM1mWbNmTa/LjvYlHA4TDAbJZDJ4PB7Gjx9POBxm8+bNZLPZ7V9gABoaGpg1axZz587lwAMPZNasWWU19H7jxi1LpgLs7VvJlPR6APa/ZH9C40qjP4eMjkAgQCwWI5FIYK0t+fBNRKRMxbc30mIY8n+4+526YYw5EPgy8ENr7eMjVMvoBhgiIjJyjDHMOHkG00+czkt/eolHv/YoM9+8ldeYySKOKqxaEonAtdc6QcY118BFF4FLK2wWjd/vZ86cOcyZM6fH/lgsxmuvvcYrr7zC6tWrefPNN3nzzTdZvXo1//nPfwb9faLRaGGKx5gxYwqjLoYSXgQCAaZOncrMmTOZMWMGM2bMYPr06TQ1NZXtmzxrnd+pjg7n/thQjLmxJwBonNbInmfs6V5x4op8+JZMJkmlUiW9JLKISJXKj7Bo6ON4/VbnbSM3deS3OLMvvla80nr5XiPZA0PcpR4YItUtk8rw3C+fY/E3F9P5XhevsjuPcjTN9GyEsfvu8L3vwYc/DGX6vnlI4vE4a9asYe3ataxbt4733nuPdevWFb7evHlzYTpIJBLZZorKhAkTaGpqIhKJkEqlAAiFQtTW1lJXV1eYflJXV0dTUxNTpkzpcRs7dmzZBhV9uesu+L//c742xvJB+3d2wBl98YGbP8AOB5T4sjgyIrq6uvB6vUycOJExY8a4XY6ISEUphSaexphGYPvLyDl+Yq29cii1ggKMiqYAQ0QAUtEUT970JMu+u4xIS5wVzOERjqGTnqtmzJsH118P+6tLUa8ymQzRaJR4PA44DTw7OjpoamrC6/Xi9XorLpAYjDVr4JxzIN9f9aBxr7Nvy2IA3nfs+zjue8e5V5y4KplMEovFCqGfiIgUTxECjN2AN+h/GVUPMKGvZVSNMSHgxj6+xftx+mI8BrwGPGStvXMotYICjIqmAENEuou3x3nsO4/xxI+fIJ40PMFBPMY8EmxZPcMY+OQn4brrQO8z+haNRtmwYQPxeJyGhr5GXFaPdBouvBBWrnTuT50YZ37z7/GRxVvj5cy/nknd5DJsuCJF0X051SlTpvRohisiIsMz3AADeoyy+Iy19sZu+38EXAXcYq29JLfPD+wGpKy1qwdw7Wso4iokegYREakSwYYgx333OC596VJmf+B9HM4yPsONHMS/8ZABnB4Gv/gFzJwJN93kvDGVbeVXH9F8fsdtt20JL/x+y7yuBfhwPsDZ98J9FV5UOWMMPp+PVCrV62pBIiLiusuAZuAGY8y9xpjvGGMewQkvXge+0u3cHYGVQK/TSUaaAgwRkSozfsZ4zvn7OZz997OZOj3ISTzA5fyM6WxZarS1Fa64wplOsmSJi8WWqEQiQSqVwu/3u12K6158EX71qy33509bTX10AwB1O9Sxzyf2cakyKSV+v59EIlGYgiUiIqUjN5JiLnAHcBDweZxRFjcAh1hrN7tXXU+aQlLBNIVERLYnnUjzxPVPsORbS0hGUrzOTB7gBFoZ1+O8c891lmCdONGlQktIKpVi/fr1tLe3M27cuO0/oILFYk7fi3ffde7vOT3OoW/8tvDpyIk3nsjUQ6a6Vp+UjnQ6XegZM3nyZLfLERGpGMWYQlJONAJDRKSK+Wp8zPviPC57+TJ2O34au/M6l/EzjuER/CQL5/3udzBrljNVYAgrhlaUeDyu6SM511+/JbwIhy2HdDxYeGEx/aTpCi+kwJdbqzmVSpFMJrdztoiISO8UYIiICI27NHLug+fyods+RF29jyNYyhXcxGxeLpzT2uo0+DziCHjpJReLdVm+/0W1Tx956CH461+33P/ovqvxNjcDUFNfw8GfO9ilyqRUBQIBksmk+mCIiMiQKcAQERHAabT3/v9+P5e9fBnTT5pOAx2cyV/4OL+jsdvS3suWwX77wZe+BNU2Qy2bzZJMJkmn01UdYLz5Jnzzm1vuH3ZAgvDjjxbuH/y5gwmNDblQmZQyv9+vAENERIZFAcYgGGNmGGO+aIx5xBjzrjEmaYzZYIy5zxhz9CCvtasxxvZz+9NI/RwiIv2p36mec/5xDqfccQrBxiAzWM1l/IzDWYo3t1pJOg3f+x7svTcsdKUHtTvyzTu9Xm/VLgUZicDVVzv9LwB23tlycNsCyLXU2uGAHZjxgRnuFSgly+/3k06nSSQSZKt9LpqIiAyJmngOQi5UOAt4BXgMaAF2Bz4MeIHPWmtvGOC1dgXeAlYA9/ZyykvW2r8Ms1418RSRYen4Twf3//f9rH7QWea7mSb+wQd5m116nHfhhU6Tz7Fj3ahy9LS1tdHc3IzH4yEcDrtdzqizFr7wBXg0N9giGISvnP46a3+3GABvwMvpd55O/dR6F6uUUtbW1kY4HGbSpEmEQhqlIyIyXNXWxFMBxiAYYy4AVlhrn9tq/5HAQzifP+1qrX1vANfaFSfA+LW19oKiF4sCDBEpDmstz9zyDAs+v4BUNEUWeJ59edh7ItFMTeG8SZPgxhvh9NPBGPfqHUnr169n06ZN1NfXF5oSVpPf/AZu6BbTf/XzMVpv+hPpeBqAuZfPZb8L93OpOikH0WiUbDbLxIkTaWxsdLscEZGyV20BRnWOfx0ia+0dW4cXuf2LgUVAADh0tOsSERlJxhjmXjKXS1Zcwk6H7IQHeD/Pc2nmRvbyvlI4b8MGOPNMOPVU+M9/3Kt3pCSTycLqCdUYXjz1FPz0p1vuf+xjlprliwrhxdjpY9nnvH1cqk7KRSAQIJVKqQ+GiIgMiQKM4knltulBPm4HY8zFxpgv57Zzil2YiEgxjJs+jguXXMgx/3sMHr+HMUQ4PfNnPsafGFuzZaTXfffB7Nnwi19U1pKr+f4X1bh86oYN8OUvb/nvuc8+MH/Hlax9fK2zw8ARXz0Cj08vK6R/Pp8Pay3JZJJUKrX9B4iIiHSjKSRFYIzZBXgNyAA7WWtbt/OQ7lNIerMION9a+84Av/8zfRzaNxQKeTSFRESKbf3z67n73LvZ+PJGAOLU8GjNifw7sW+P8446Cm69FaZPH/0ai23jxo1s3LiRcDhcVSFGKuUsn5tfOnf8ePjpN1tZcuXdZFNOorHXOXtxyOcOcbFKKSednZ34fD4mTZpEXV2d2+WIiJQ1TSGRQTHG1AC/B2qAawYSXuREgW8B+wNjc7cjgUeBo4CFxpiq+CUUkfIzed/JfOrpT3HwVQcDECTBSYn7uIA72KG+q3DeokXOSiU/+IGzckm5ymQyJJNJMplMVS2fai1861tbwguPB759TZrn/u+hQngxfuZ4DrziQBerlHITCARIJpPE43G3SxERkTJTdSMwjDFrYKv2+f37vbX23D6u5QX+CJwB3AmcbYf5D2qM8eGscHIQcKW19ifDuJaaeIrIiHtz4Zvcd8F9dKztACCFjycaTmBR1/5kMlu6ec6dC7/8Jcwpw4ly0WiUDRs2kEgkqK+vnhU2br8dbrppy/3Pfx52eH0xr//tdQB8IR+n/u5UGndpdKdAKUvZbJbW1lbGjx/P5MmTq3ZJYhGRYtAIjMq3Gme6x0Bv63q7SC68+B1OeHEXcO5wwwsAa20auC1394jhXk9EZKRNO3Yal7xwCXudvRcAftIc3v4PLrK3Mn3KltEYTz8N++8PX/wiRCJuVTs08XicZDJZVVNHFi7sGV585CMwt3FVIbwAOOyLhym8kEHzeDx4vV6SyaSaeYqIyKBU3QiMYsiNkvgDTnjxB+AT1tpMEa9/CnAv8KC19sRhXEcjMERkVL34hxf5x2X/INHuvCnJ4OGVXU/m7++9n0Riy2iMXXZxVrT44AfdqnTgrLW89957bN68mbFjx1bFp8WvvOL0vci/t5w7F677Ygf3n/9X0lFnLtD0k6dz1LVHYSp1zVwZUbFYjHQ6zcSJExk7dqzb5YiIlC2NwJB+GWMCwF9wwovfAOcVM7zIOTi3fbPI1xURGVF7n7M3l6y4hKmHTQXAS5a91/ydKwK3MXePLcMu3n4bPvQh+OhHYe1at6odmPxqCR6PpyrCiw0b4KqrtoQXO+8M3/l2hiVfW1gIL+qn1jPvS/MUXsiQdV9OVR+miYjIQFX+K7EiyjXsvAc4BfglcKG1tt9FAo0xDcaYWcaYKVvtPygXhmx9/jHAVbm7vytO5SIio6dxl0YuWHSB8+m813mDO6ZzHR9Y+QM+Pe9Zxo/b8mbl7rthjz3gxz8u3Saf1TR9JBZzwovNm5379fVw/fXw6m+eZNOrmwAwPsOx3zkWf7h6mplK8Xm9XsBZnjiZTLpcjYiIlAtNIRkEY8ztwAXAJuBnQG//eIustYu6PeYC4Hbg19baC7rtXwTsibNkav7zxznAMbmvv2at/fYw69UUEhFx1bvL3+Xuj99N25q2wj7f1Mm8sPfHueufPZdP3GcfuPlmOKTEVuNsbm5m48aN1NXVVfQKJNksXH01LFni3Pd6nR4YTZE1PPT5hwrnHfz5g9n77L1dqlIqSSQSwRjDxIkTq6o5rohIMVXbFBKf2wWUmffltk3A1/s5b9EArvVb4FTgAOAkwA9swGkI+lNr7dKhlykiUhqmHjqVi5+/mH9e9k9e/MOLAKTfXc/stT/kB2edzK9emMsrK51RGitWwKGHOr0XvvtdGDfOzcod6XSaZDJJNpvF56vcp0xrnX/zfHgB8D//A9MntHHP5x4t7Nv58J3Z62N7uVChVKJAIEBXVxfxeFwBhoiIDIhGYFQwjcAQkVLy4h9f5J+X/5N4a7ywb+wek1h/7Dlc/8t6YrEt5zY1wfe/D+efD262Wejq6mLDhg2k02nGjBnjXiEjyFr40Y/gj3/csu+88+CyT6W49/x7aXuzDYC6Heo49benEmwIulOoVBxrLS0tLYwdO5bJkydXdEgoIjJSqm0EhnpgiIjIqNj77L259MVL2e2E3Qr7WlduIPTzn/Cri5/ggx/YEqhv2gQXXghHHumsiOGWeDxOKpWq2P4X1sKNN/YML04+Ga64wrL42sWF8MIb8HL8949XeCFFZYwhEAiQSCSIx+Pbf4CIiFQ9BRgiIjJq6nes5+P/+jgfuPkDhSaQ2XSW165/kA8338ZvftrBzjtvOX/pUth3X/jqV+kxQmM0ZLPZwgokldr74tZb4Te/2XL/uOPgG9+Al//4Im89/FZh/7wvz6Np9yYXKpRKFwgESCaTCjBERGRAFGCIiMioMsYw95K5XLLiEnY6ZKfC/nVPreOdq2/k11c8xRe+YMmPJk+l4LrrYM4cWLhw9OrMr47g9XorcvnU22+HX/xiy/0jj4Rvfxs2PLeOf9/w78L+Pc7Yg5kfnOlChVIN/H4/6XSaRCJBNtvvwm4iIiIKMERExB3jpo/jwqUXcux3jsXjd56O0vE0i7/wT2Y/9RuW/LOTQw/dcv4bbzgjBD7xCdi4ceTrq+TlU//wB2eFkbxDD3WaeMY3d7HwfxZC7n3kxDkTOfRzh/Z+EZEi8Hg8+Hw+UqmURmGIiMh2KcAQERHXeLwe5n1pHp986pNMmjOpsH/No2tYfPpN3HjR89x8s6WhYctjfvtbmDXLmf6QyYxMXdbawgiMSgowrHX+/X70oy37DjzQaZjqIcPDX3i40GQ1OC7Icd87rhAuiYyUfB+MRCLhdikiIlLi9KpERERcN3mfyVz05EXM+595GI+z7EiiI8Hf/us+xj38Z557PMZZZ205v6UFPvUp5833smXFryeVSpFMJgEqZmWEVAq+9S34yU+27NtvP/jhDyEQsCy5dgkbX84NbfHAcd89jtoJVdHQXFyW74ORSCTQ6ngiItIfBRgiIlISfDU+jv3fY7lw6YWMmz6usH/lX1dy7/yf873L3uaf/4Rdd93ymGefhXnz4Nxz4T//KV4tlTZ9pL0dLr8c7r9/y7799nPCjFAI/n3Dv3njgTcKxw6+8mCmvH+KC5VKNcr3mcmPehIREemLAgwRESkpUw+dysXPX8z+l+xf2NextoNfH/1rapY/wosrsnzjGxDstqLn738Pu+8O3/kOFGMUejweJ5FIVESAsWYNnH++E/bkffCD8LOfQTgML/7xRV787YuFY7M+Oou9zt5r9AuVqqbVSEREZCAUYIiISMkJ1Ab44M0f5Kx7zyI0LgSAzVqWfnspd554O589v5VXX4XTT9/ymEgEvvxlJ8j41a8gnR7a985PH8lms2W/fOqTT8IFF8Datc59Y+DTn3aWSvX7YfVDq3nih08Uzt/1qF2Z98V5GGPcKViqlgIMEREZCAUYIiJSsmadMotLXriEXY/etbBv7eNruWXfW2hbsoK77rIsXAh77rnlMW+/Df/93zB7NvzxjzDYlRm7j74o1zfy1jorjVxxBXR1OfuCQfi//3NGYxgD655ex6KvLyo8ZtI+kzj6uqMLPUhERpPf7yebzZJKpUilUm6XIyIiJUoBhoiIlLT6Hes576HznOVWfc7TVqIjwb2fuJc/fvCPzJ3ZwfPPww03QFPTlsetWgXnnAP77AP33OO8qR+IfP+Lmpqa4v8wo+C99+DSS52VRvLhzcSJ8MtfwtFHO/c3r9rMgs8vIJtyTmh8XyMn/PgEfDWV0bBUypNWIxERke1RgCEiIiUvv9zqfy37L8ZOG1vYv+qfq/jZnj9jxa+e4YorLG++Cd/+Nj2WXX3pJTjtNKdp5W9+A/31CMxkMiSTSdLpdNlNH7EW/vY3OOssePrpLftnz4Zf/9qZWgPQ+V4n//r0v0hFnE+5wxPCnHTjSdTUl2dgI5VD00hERGR7jJarqlzGmEgoFApHo1G3SxERKZpkV5KFX17Ikzc+2WP/+455Hx+69UOMnTaW1lZnBML112+ZQpE3ebIzteLii3uO2ACIRCJs2LCBZDJJfX39yP4gRdTa6gQ3ixdv2efxOP0vPvlJp98FQOubrfzrin8RaY4A4K/18+FffrjHqi8ibrHW0tLSwrhx45gyZQoejz5nExHZnnA4TCwWi1prq2LtcwUYFUwBhohUsreXvs39/30/LataCvv8YT9HXXsUB376QHw1PjZudPo+3HQTxGI9Hx8Mwic+AVdeCXvs4ezbvHkzGzduJBAIEOy+zEmJymbhwQfhhz+EtrYt+3feGa69Fvbee8u+DS9s4IErHyDZ4QxB8fg9nPzTk5myv5ZLldLR3t5OMBhk0qRJhMNht8sRESl5CjCkYijAEJFKl4qlWHTNIh7/wePY7Jbns8b3NXLcd49j9hmzMcaweTPccgv89KdOj4itnXgiXHlllr32Wk9Ly2bGjh1b0p/+ptPwr3/B7bfDO+/0PHbmmc5KI6HQln3vLH2Hh7/0MJlEBgBf2Mf8H8xnxwN3HMWqRbYvHo+TSqVoampi/PjxbpcjIlLyFGBIxVCAISLV4j9P/Yf7/+t+ml9q7rF/p4N3Yv4P5zP10KmA0//irruc6SXPPdfzGqFQlAMPbOa002J86EMNlGIPz1TK6XNxxx2wbl3PYxMnwte/Dgcf3HP/6397ncXfWgy5hp7BsUFOvOFEJuwxYVRqFhmMbDZLa2sr48ePZ/LkySUdJIqIlAIFGFIxFGCISDXJJDM8/fOnWXztYmItPeeLzD59Nsd+59hCrwdrYckS+PGP4f77nftjx7YwYcJGUikfwWCI006D44+H6dOdZUfd9O678MgjcOed0Nwzo6GuDj72Mfj4x2HMmC37rbWs+M0KnrrxqS3n7lDHyTedTMPUBkRKVVtbG+FwmIkTJ2oaiYjIdijAkIqhAENEqlG8Lc6S65bw5A1PkklmCvuN17DPJ/bh8C8f3qNp5erVcMMNlr///T3C4c20to4lm93yqe+UKXDkkc5tv/3ANworjVrr1PXoo05wsWrVtuc0NDihxZlnOiFGd6lYiid+9ASv3vNqYd+4meM4+caTCY0PIVLKYrEY6XSaCRMmMG6cGsyKiPRHAYZUDAUYIlLNWt9q5ZEvP8JLf3qpx37jNcz5+BwO/+rhjJ/hzLGPx+OsXr2Bv/89wl13NfbaJwOcEQ6HHOIsSbrrrs5txx2HH2pY60wJefllePFFeOwxZ9RFb8aNc5qPfvSjPftc5G18ZSOPfvVR2t9pL+ybsv8U5v9wPoG6wPAKFRkF3aeRTJkyBeP2ECgRkRKmAEMqhgIMERFY+++1LPyfhax5dE2P/cZj2PucvTn8q4fjm+SjubkZj8dDTU2YJUvg4Ydh2bJtl2HdmtcLU6fCLrs4ozUmTXKWap040fl6wgRntZCuLucWiTjbzk544w146SUnuOi+isjWAgGnt8XRR8P8+fTan8NmLM/f8TzP/OIZbGbLc/u0+dM46pqj8Aa8A/9HE3FZW1sbtbW1TJw4kVBvSZ2IiAAKMKSCKMAQEdni7aVvs/jaxby18K2eB7ww+/LZTDtrGhN2moCv23CKVMpp9rlokdMzY/360as3HIZ585zQ4rDDnPt96VjbwaNff5TmF7Y0yPCFfRz6/w5l5gdn6hNsKTvRaJRMJsPEiRMZO3as2+WIiJQsBRhSMRRgiIhs651l77Dkm0tYvWC1syMATALfZB9zz5rLnqfvice/7coH1jq9KFasgDVrttw2bChOXWPGwOzZsOeesM8+cMABzsiL/qTjaVbes5Knb36adDRd2D9pziSO/tbRjNlxTD+PFildmUyGtrY2TSMREdkOBRhSMRRgiIj07d3H3+XRrz7KW8+8BU25nVFo2LmBg686mKnzpg7oTVMsBm+/7dyam51RGs3NTrCxfj20tIDH4zTa7H6rrYUddoC99nJCi6lTB77aSaw1xit/foWX73yZRHuisN94DftfvD/7nr8vxqs3fFLeWltbqaurY9KkSQSDQbfLEREpSQowpGIowBAR6Z+1lifvepKlv1hKZFUEtgxiYMeDdmS/i/Zj8r6Th/XpbybjBBjF+AC5Y20HL/z+BV6/7/UeK6yAE7wcfd3RTNhjwvC/kUgJiEajZLNZJk6cSGNjo9vliIiUJAUYUjEUYIiI9C+ZTLJhwwZaN7eybsE6nr31WVKRVI9zmmY1sdfH92K343brdWrJSEvH07yz9B3eeOAN3l76NmR7Hq+bUsfeH9+bWR+ZhS84Cmu8ioySdDpNR0cHTU1NTJo0SdNIRER6oQBDKoYCDBGR/nV0dLBx40YymQx1dXXEWmM8/fOnefWeV7cJCkJNIfY8a0/2OG0Pgg0jO5w9m8qy9om1rH5wNWsWryEdS29zzvjdx7PP+fsw7dhpmi4iFSs/jWTy5MnU9Lb8johIlVOAIRVDAYaISP+am5vZuHEjtbW1BLp1zGxb08aLf3iRVX9ftc1UDY/fQ+OujTTs0kDDzg3O1zs7XwfGBIb0KXEqlmLz65vZ9OomNr68kXcee4dkR7LXc3c6ZCfmfGIOO8zdQZ9IS8WLRCIATJgwQdNIRER6oQBDKoYCDBGRvuWnj7S1tTFu3Lhew4B4W5yVd6/k5bteJrYptt1remu8hMaHCDeFCY8PExofIjQ+hMfXy9STLLS93camVzfRtqZtmxEf3TXs0sBuJ+7G9BOm07BzwyB+SpHylk6n6ezsZPz48ZpGIiLSCwUYUjEUYIiI9K2jo4Pm5may2Sx1dXX9nptNZVn90Gpe+sNLbHp106jUVzeljt3m78ZuJ+zGuBm9Bywi1aClpYX6+nomTZqkaSQiIluptgBD3b5ERKQqxWIxEonEdsMLcKaNzDh5BjNOnkG8PU77O+20v91O+zvttK1po/2ddjre7SCTyGz3Wr1/A2jctZGmWU007dHEpL0nMWHPCQotRICamhqSySTxeFwBhohIlVOAISIiVSeZTJJIJLDW4vf7B/XYYEOQ4N5BJu09qcd+ay3paJro5ijRzVFim2OFrc32Ptox3BSmaY8mxs8cjz80uDpEqkUgEKCrq4t4PE5Dg6ZQiYhUMwUYIiJSdWKxGMlkskfjzuEyxuCv9dNQ26A+FSJF5Pf7sdaSTCaL/v+tiIiUl9Ff0F5ERMRF1lri8TiJRIJgcGSXQxWR4ggEAiQSCeLxuNuliIiIixRgiIhIVek+fcTn00BEkXJQU1NDIpEgFouhBvQiItVLAYaIiFSV/OgLNQMUKR/5aSSJRIJkMul2OSIi4hIFGCIiUjWstYXVRxRgiJSX7qMwRESkOinAEBGRqpGfPgJo+ohImckHGPF4XNNIRESqlAIMERGpGvnVRzT6QqT8+Hw+jDEkEolCECkiItVFAYaIiFSF7quPKMAQKU81NTXE43FNIxERqVIKMEREpCrkP7U1xmj6iEiZqqmpIZlMEovFyGazbpcjIiKjTAGGiIhUBTXvFCl/Xq8Xr9fbo5+NiIhUDwUYIiJS8fLTR9T/QqT8aTUSEZHqpQBDREQqXiKRIJlMYozB6/W6XY6IDEN+Gkk8Htc0EhGRKqMAQ0REKl4sFiMej2v0hUgF8Hg8+Hw+jcIQEalCCjBERKSiZbNZLZ8qUmE0jUREpDopwBARkYqWXzo13/xPRMpfIBAglUqRSCTIZDJulyMiIqNEAYaIiFS0aDRKIpEgGAy6XYqIFInH48Hv92sUhohIlVGAISIiFSudTpNIJEilUpo+IlJhNI1ERKT6KMAQEZGKlW/eGQgEMMa4XY6IFFEgECiElOl02u1yRERkFCjAEBGRihWNRrX6iEiFMsYQCAQ0CkNEpIoowBARkYqUSCRIJBJYawkEAm6XIyIjIBgMEo/HiUajWGvdLkdEREaYAgwREalIsViMRCKh0RciFczv92OtJR6Pk0wm3S5HRERGmAIMERGpONbawvQRrT4iUtmCwSCJRIJoNOp2KSIiMsIUYAyCMWZXY4zt5/anIVzzUGPMP40xLcaYqDHmBWPMlcYY70j8DCIi1SAWi5FMJvF6vXi9+nMqUsm6r0aSzWbdLkdEREaQz+0CytQK4N5e9r80mIsYY04B/grEgTuBFuBDwI+Bw4AzhlWliEiVyk8f0egLkcrn9Xrx+XyFEKO2ttbtkkREZIQowBia56211wznAsaYeuBWIAMcZa19Orf/a8AjwOnGmI9Zawc9qkNEpJplMpnCfHi9kRGpDt2beer/exGRyqUpJO45HZgA/CkfXgBYa+PAV3N3L3WjMBGRcpbvfeH3+/F49DQnUg0CgQDpdJp4PE4qlXK7HBERGSEagTE0OxhjLgbGA5uBx621LwzyGsfktg/0cmwJEAUONcbUWGsTQy9VRKS65KePhMNht0sRkVFijCn0wohGozQ0NLhdkoiIjAAFGENzfO5WYIxZBJxvrX1ngNfYPbd9fesD1tq0MeYtYE9gGrCyvwsZY57p45Amf4tIVUkmkyQSCTKZDH6/3+1yRGQUBYNBOjo6iMVi1NfXY4xxuyQRESkyja0dnCjwLWB/YGzudiTwKHAUsNAYM9CJl/mPBtr7OJ7f3ziUQkVEqlEsFiMej1NTU6M3LyJVxufzYYwhkUgQj8fdLkdEREZA1Y3AMMasAXYZxEN+b609F8Ba2wx8favjS4wx84HHgIOAi4CfFKPU3NZu70Rr7f69XsCYCKAx1CJSFay1hekj9fX1bpcjIi7o3swzFAq5XY6IiBRZ1QUYwGqcZUsHat32TshN+bgNJ8A4goEFGPkRFn1N0qzf6jwREelHfvSFx+PB56vGpzcRqampKTTyzWQyeL1et0sSEZEiqrpXeNbaY0fo0htz24FOIXkNmAvMBHr0sDDG+ID3AWngzWIVKCJSySKRCPF4nGBQ7X9EqpXH48Hv9xdGYYwZM8btkkREpIjUA6N4Ds5tBxo4PJLbntjLsSNwpn4s1wokIiLbl0qlSCQSpFIpampq3C5HRFzUfRqJiIhUFgUYg2CMOcgYE+hl/zHAVbm7v9vqWIMxZpYxZspWD/sLsAn4mDFmbrfzg8C3c3dvLlrxIiIVLBKJEIvF1LxTRAgEAlhrSSQSJBL6HEhEpJIowBic7wH/Mcb82Rjz49xtIbAQqAG+Zq1dvtVjTsVZBvU73XdaazuATwJeYJEx5jZjzP8BzwOH4AQcd47oTyMiUgGy2Wxhzrumj4gIOL0wNApDRGTgjDE7GWN+ZYxZZ4xJGGPWGGOuN8aMHeDjxxtjLjLG3GOMecMYEzPGtBtjHjPG/LcxpijZQ9X1wBim3+IEEgcAJwF+YANwF/BTa+3SwVzMWnuvMeZI4CvAR4Eg8AbwOeAGa+12VyAREal2+ZVHvF6vmneKCOBMI2lrayMWi1FfX69mniIi/TDG7AYsByYC9wGvAgcCnwVONMYcZq3dvJ3LnIEzg+A94FHgHWAScBpwG3CSMeaM4b7HNXqPXLmMMZFQKBTWpw8iUsmam5vZtGkToVBI/S9EpKCjo4NAIMCECRPUzFNEKlY4HCYWi0WttQNdTGIbxpgHgfnAZ6y1N3bb/yOcVgm3WGsv2c41jsFZ0OIf1tpst/2TgSeBqcDp1tq/DrVO0BQSEREpY8lkkkQiQSaTIRDYpkWRiFSxYDBILBYjGo2iD+xERHpnjJmGE16sAW7a6vA3gAhwnjGm34DEWvuItfZv3cOL3P71wM9zd48abr0KMEREpGzlm3cGg0E17xSRHvLNPOPxOPF43O1yRERK1TG57YJewodOYBnOCpkHb/3AQUjltulhXANQgCEiImUqm80W+l+oeaeI9CYUChGPx4lEIm6XIiJSqnbPbV/v4/iq3HbmUC5ujPEBn8jdfWAo1+hO3c5ERKQs5Vce8fl8atAnIr2qqakp/K1IpVL4/X63SxIRGQlBY8wzvR2w1u6/ncc25LbtfRzP728cQl0A3wX2Av5prX1wiNco0AgMEREpS/npI6FQyO1SRKREeTyewpKqGoUhIjIk+Tm6g24mZIz5DPB5nFVNzitGMRqBISIiZScej5NIJLDWqnmniPQrGAzS3t5ONBqlvr4ej0ef34lIxYkPYKRFX/IjLBr6OF6/1XkDYoy5HPgJ8ApwrLW2ZWjl9aS/4CIiUnai0WiheaeISH98Ph8+n494PI6WlhcR2cZruW1fPS5m5LZ99cjYhjHmSuCnwEvA0bmVSIpCAYaIiJSVTCZDLBYjmUwqwBCRAck389SSqiIi23g0t51vjOmRDxhjxgCHATHgiYFczBjzReDHwPM44UVz8UpVgCEiImWmq6uLeDyO3+/XUHARGRC/399j5SIREXFYa1cDC4Bdgcu3OnwtUAv8xlobATDG+I0xs4wxu219LWPM13Cadj6DM21kU7HrVQ8MEREpG9lsttC8s76+fvsPEBEBjDEEg8FCM0+N3hIR6eEyYDlwgzHmWGAlcBBwNM7Uka90O3fH3PG3cUIPAIwx5wPfBDLAUuAzxhi2ssZae8dwClWAISIiZSO/HKLX68Xn01OYiAxcMBiktbWVeDxOOp3W3xARkRxr7WpjzFycAOJE4GTgPeAG4NoBNuB8X27rBa7s45zFwB3DqdVoHmDlMsZEQqFQWA2rRKQSWGtpbm5m06ZN1NbWavURERm0zs5OfD4fTU1NNDT01XBfRKR8hMNhYrFY1Fpb63Yto0GTh0VEpCzEYjHi8TiAwgsRGZJQKEQsFiMajZLNZt0uR0REBkkBhoiIlIWuri6i0SihUMjtUkSkTPl8PjweTyHEEBGR8qIAQ0RESl48Hi/MW6+pqXG7HBEpY7nh1nR1dWlJVRGRMqMAQ0RESl5+5ZFQKEQvHa1FRAYsPwUtHo9rFIaISJlRgCEiIiUtlUoRi8VIJpNa+lBEiiIcDhONRjUKQ0SkzCjAEBGRktbV1UUsFqOmpgaPR09bIjJ8NTU1ZLPZwvQ0EREpD3olKCIiJSuTyRCNRonH42reKSJF1X0UhoiIlAcFGCIiUrIikQjxeBy/34/X63W7HBGpIDU1NaTT6R5LNIuISGlTgCEiIiUpm80Wpo+Ew2G3yxGRCmOMIRQKFVYkERGR0qcAQ0RESlJ+9IXH48Hn87ldjohUoFAoRDKZJBaLkUgk3C5HRES2QwGGiIiUHI2+EJHRkB+FoV4YIiLlQQGGiIiUnEgkQiwWwxhDIBBwuxwRqWDBYLAwCiOVSrldjoiI9EMBhoiIlJRsNktnZyfRaJTa2lq3yxGRCufxeKipqVEvDBGRMqAAQ0RESkp+6ojX68Xv97tdjohUgVAoRDweJxqNkk6n3S5HRET6oABDRERKhnpfiIgbvF4vNTU1RKNROjo63C5HRET6oABDRERKhkZfiIhbwuFwYRRGMpl0uxwREemFAgwRESkJmUymEGCo94WIjDaPx0MwGCQSidDZ2el2OSIi0gsFGCIiUhLy4YXP58Pn87ldjohUoVAoRDKZJBqNkkgk3C5HRES2ogBDRERcl8lkCkunqveFiLjF4/EQCoXUC0NEpEQpwBAREddp9IWIlIr8KIxYLEYsFnO7HBER6UYBhoiIuCo/+iIajWr0hYi4zhhDOBwu9MKw1rpdkoiI5CjAEBERV3V2dhKLxfD7/Rp9ISIlIRgMkslkNApDRKTEKMAQERHXJJNJurq6iEajWnlEREqGRmGIiJQmBRgiIuKajo4OIpEIwWAQr9frdjkiIgXBYBBrLbFYjEgk4nY5IiKCAgwREXFJLBYjGo2STCYJhUJulyMiso3a2loikQhdXV1ks1m3yxERqXoKMEREZNRZa+no6KCrq4va2lo8Hj0diUjpCQQCGGOIRqN0dXW5XY6ISNXTK0YRERl1+b4X1lpqamrcLkdEpE91dXWFXhipVMrtckREqpoCDBERGVWZTIbOzk4ikQh1dXUYY9wuSUSkTz6fj5qaGiKRCB0dHW6XIyJS1RRgiIjIqOro6CAajeLz+fD7/W6XIyKyXeFwmGQySSQS0bKqIiIuUoAhIiKjpvsbAC2bKiLlwuPxEA6H6erqoqOjQw09RURcogBDRERGjZZNFZFyFQwGAQqrkoiIyOhTgCEiIqMiGo0SiURIJpOEw2G3yxERGTQ19BQRcZcCDBERGXHZbJb29vbCsqlq3Cki5UgNPUVE3KUAQ0RERlx7ezvRaBSPx1MYhi0iUo7U0FNExD0KMEREZETF43G6urqIRqPU1dW5XY6IyLCooaeIiHsUYIiIyIjJTx3p7OwkHA6rcaeIVITuDT07OztdrkZEpHoowBARkRHT0dFR6NYfCoVcrkZEpHi6N/RMJBJulyMiUhUUYIiIyIhIJBJ0dnZq6oiIVCSfz0coFKKzs5O2tjZNJRERGQUKMEREpOiy2SxtbW10dXURCoXw+XxulyQiUnShUAhrLV1dXbS3t7tdjohIxVOAISIiRdfZ2UkkEiGbzWrqiIhULGMMY8aMIRqN0tXVpVVJRERGmD4SExGRospPHYlEIjQ0NGCMcbskEZER4/V6CYfDdHZ24vP5CAQCalgsIjJCNAJjEIwxdxhj7HZuCwd4rV23c50/jfTPIyJSbJo6IiLVKBQKYYwhEoloKomIyAjSK8vBuRdY08ex84BpwL8Gec0Vuetu7aVBXkdExHX58CKTyTBmzBi3yxERGTVjxoyhtbWVrq4ugsEg4XDY7ZJERCqOAoxBsNbeSy9hgzGmEfgCkATuGORln7fWXjO8ykRE3NfV1VVYdaSxsVFTR0Skqng8Hmpra3tMJdEoNBGR4tIUkuI4DwgBd1trN7ldjIjIaEsmk7S3t9PZ2UldXZ3mf4tIVQoGg3i9XiKRCG1tbVhr3S5JRKSiKBYujk/mtr8YwmN3MMZcDIwHNgOPW2tfKFplIiIjLJvN0traSmdnJ4FAgJqaGrdLEhFxTV1dHW1tbYWRGI2NjW6XJCJSMRRgDJMx5hBgb+B1a+2jQ7jE8blb92suAs631r4zwBqe6eNQcAj1iIgMSr7vRTabVd8LEal6Ho+H+vp62tvbC1NJ1A9DRKQ4NIVk+D6V2946yMdFgW8B+wNjc7cjgUeBo4CFxpjaItUoIjIiuve9GDNmjPpeiIgAPp+P2tpaOjo6aG1tJZlMul2SiEhFMNU2N88YswbYZRAP+b219tw+rtUArMMZybJjMfpfGGN8wGPAQcCV1tqfDONakVAoFI5Go8MtS0RkG8lkko0bN9La2kptba2mjoiIbCU/Om3s2LE0NTWpP5CIFF04HCYWi0WttVXx4Xc1TiFZDcQHcf66fo6dC4SBPxWreae1Nm2MuQ0nwDgCGHKAISIyUjKZjPpeiIhsR21tbaHBsc/nY9y4cRqpJiIyDFUXYFhrjy3i5fLNO28p4jUBNua2VZGiiUh5yWaztLS00NHRob4XIiL9MMZQX19Pa2srPp8Pv99PfX2922WJiJStqgswisUYcxCwD07zzkVFvvzBue2bRb6uiMiwWGtpbW2lo6ODRCJBY2OjPk0UEelHvqlnR0cHXq8Xv99PKBRyuywRkbKkJp5Dl2/e2e/SqcaYBmPMLGPMlK32H2SMCfRy/jHAVbm7vytKpSIiRZIfCh2LxWhoaMDj0dOIiMj2+P1+wuEwHR0dtLS0kEgk3C5JRKQsaQTGEBhj6oGzgCTw6+2cfipwe+68C7rt/x6wZ27J1LW5fXOAY3Jff81au7xIJYuIDFtnZycdHR10dnZSX1+vZnQiIoMQCoXIZDK0t7djjGHChAn4/X63yxIRKSsKMIbm4zj9KYbTvPO3OOHGAcBJgB/YANwF/NRau7QYhYqIFEMsFqO9vZ2Ojg7q6ur0oltEZAjq6uro6Oigo6OjEGL4fHo5LiIyUFW3jGo10TKqIlIMiUSCTZs20dbWRjAY1NxtEZFhsNbS0dGBx+OhsbFRy6uKyLBU2zKqmrwsIiJ9SqVShRVH1HhORGT48iuTZDIZOjo62Lx5M9ls1u2yRETKggIMERHpVTKZZNOmTYX52rW1VRHsi4iMuHyIkUwm6ezspKWlBY2KFhHZPk26ExGRbSSTSTZv3kx7ezsAY8aM0XKpIiJF5PF4aGhooK2tDWMMxhjGjRunv7UiIv1QgCEiIj1sPfJC4YWIyMjIhxj5sNhay7hx47REtYhIHxRgiIhIQSKRKIy8UHghIjLyvF4v9fX1dHR0YK0thBhq7Ckisi0FGCIiAvQMLzweD3V1dQovRERGgc/nK4zEyGazhRBDS6yKiPSk8WkiIkIsFisslerxeDTyQkRklHm9XhobG0kmk7S1tbF582ZSqZTbZYmIlBQFGCIiVa6zs5PNmzfT1taGz+djzJgxbpckIlKV8j0x0uk0bW1tbNq0iWQy6XZZIiIlQwGGiEiVstbS2tpKS0sLbW1t1NTUUFdX53ZZIiJVLR9iWGtpb29n06ZNxGIxt8sSESkJmlgnIlKFMpkMLS0tdHV10dXVxZgxYwgEAm6XJSIiUGii3NXVRWtrK5lMhvr6eurr6zW9T0SqmgIMEZEqk0qlaGlpoaOjg0QiQUNDgxrFiYiUmHyIEYvFaGtrI5PJkEqlGDt2rFYoEZGqpVesIiJVJBqN0tbWRkdHB9lslsbGRjwezSYUESlVoVAIn89HR0cH6XSaTCbD2LFjNWpORKqSAgwRkSqQzWZpa2ujq6uLzs7OwpJ9GoosIlL6/H4/Y8eOpaOjg9bWVtLpNI2NjdTW1rpdmojIqFKAISJS4eLxOO3t7XR1dRGNRqmtrSUYDLpdloiIDEK+uWckEilMKclPA9SUEhGpFgowREQqlLWWjo4OOjs76ezsxFpLY2OjXuiKiJQpYwx1dXWFYDqZTBZCjHA47HZ5IiIjTgGGiEgFSiaTtLW1EYlE6OrqIhQKEQqFNGVERKQCBINBAoEAnZ2dtLS0kEqlqK2tVUgtIhVPAYaISAXJZDJ0dnbS1dVFJBIhlUpplRERkQqUn1ISj8cLq0rlR2OoN4aIVCq9ohURqQDWWiKRCJ2dnUSjUaLRKMFgkLFjx2rUhYhIBcuPxujq6qK1tZVUKkU0GqW+vp6amhq3yxMRKSoFGCIiZS6RSNDe3k40GiUSieDxeDSMWESking8Hurr60kkEnR0dBCPx4nH49TW1jJmzBj8fr/bJYqIFIUCDBGRMpVMJgsjLiKRCOl0mrq6OgKBgNuliYiIC2pqaggEAsRiMdra2ojFYsRisUKQoWBbRMqdAgwRkTKTSCQKS6JGo1GSySShUIgxY8ZouoiISJUzxhAOhwkGg0SjUVpaWojH40SjUerq6qitrVWQISJlSwGGiEiZSCQSdHZ2EovFCsFFvs+Fx+NxuzwRESkhHo+Hurq6QpCRH43R1dVFOBymtrZWU0tEpOwowBARKWHZbLYQWORffOZHXCi4EBGR7fH5fNTX15NKpQrPJ92X2K6rq1OzTxEpGwowRERKUDKZLEwRSSQSxONx0uk0oVCIcePGaaqIiIgMit/vx+/3k8lkiMVitLa2EolEiEQiBINBwuEwoVBI00tEpKQpwBARKRGZTKYwTznfQT6RSODxeAgGg9TX1yu4EBGRYfF6vdTV1REOh4nH47S3t9PV1UUwGKSmpqYQZgSDQT3niEjJUYAhIuKifGgRi8VIJBIkk8nCaIuamhrq6+vx+fSnWkREisvj8RRGXaRSKeLxOJFIhEAgQDAYJBAIEAqFCsGGwgwRKQV6VSwiMspSqVRhWkgikSgEF6lUCp/PVwgu9GJRRERGmjGGQCBAIBAgm82SSCSIRCJ0dnYSCASoqanB7/f3GKGhaSYi4hYFGCIiIyydTpNMJgthRSqVIplMkkwmSafT+P1+AoEAdXV1asopIiKu8Xg8hEIhQqFQ4bkrEomQyWQKIUf+VlNTU/haz10iMloUYIiIFJG1llQqVbjlg4r816lUCmttjyG6GmkhIiKlxufz4fP5CIfDZLPZQhDf1dWF1+sthO8+n2+bcEMjNETKjzFmJ+CbwInAeOA94F7gWmtt62hfp8/rW2uHew0pUcaYSCgUCkejUbdLEalI2WyWdDpNOp3uEVjk7+ePZbPZQvd3v9+vnhYiIlK2tg7qM5lMIdDIP8f5fL4ez3t+vx+v16vAXmQEhMNhYrFY1FpbO9RrGGN2A5YDE4H7gFeBA4GjgdeAw6y1m0frOv3Rq2gRkX5YawtBRSaT2SacyO/LZDKF/R6Pp/AiLr8knV60iYhIJejeMwOc58n8c2MsFiOdTgNbRnBs7+b1ejUFRcR9P8MJHT5jrb0xv9MY8yPgKuA64JJRvE6fNAKjgmkEhsj2ZbNZMpkMmUymx9cDvXm9Xrxeb48XY3ohJiIi1SybzW4T9mez2cLzZf65c3s3j8dT2Oq5VaR3wx2BYYyZBqwG1gC7WWuz3Y6NwZkCYoCJ1trISF9nezQCQ0QqQjabLYyW2Hq7vVsmk8FaW3iBld+X3xpjerygqqmpKXytkRUiIiI9eTweampqqKmpKezLP7/mA41EIlH4MMAY0yOs6B5adL/1tT//+O5fd9+KSL+OyW0XdA8dAKy1ncaYZcB84GBg4Shcp18KMEQEcIaADvRYf/d7+3og2/6+7uuWDyn6299XoJH/2hhTCCi6v0DKd1VXSCEiIjJ8+efY3vpAdf/wIH9LpVI9PmwACs/JvYUW+fv579V9X/7rgd6Afr/ubTvQrwdyf3v7RYps99z29T6Or8IJHmbSf/BQrOv0SwGGlL1kMsmmTZvcLqMiDHRK2UADjd6ut3VAsfV5Aw0z8vvyYcRQ5F/o5OfvioiISOkxxgz5ubqvcCL/GmDrkKKvYKK/4KL7eb09trdzBlq7FIfX66WpqamSV8gJGmOe6e2AtXb/7Ty2Ibdt7+N4fn/jKF2nXwowpOxlMhm3Sxi0Uus9M9x6hvPkLCIiIlItBvOaK39uqb6uKtW6etO9D4sMWv4/9HDfwBTlOgowpOyFQiECgUBheGG5Gck//uX0xCIiIiIiQzNSH46V2oduQ1UFq93EBzDSoi/5kRENfRyv3+q8kb5OvxRgSEXIN1QUERERERGRAXstt53Zx/EZuW1fvS2KfZ1+VXQMJSIiIiIiIiJ9ejS3nW+M6ZEP5JY/PQyIAU+M0nX6pQBDREREREREpApZa1cDC4Bdgcu3OnwtUAv8xlobATDG+I0xs4wxuw3nOkNlKmVek2zLGBMJhULhaDTqdikiIiIiIiJSZOFwmFgsFrXW1g71GrkwYjkwEbgPWAkcBByNM+XjUGvt5ty5uwJvAW9ba3cd6nWGSiMwRERERERERKpUbvTEXOAOnMDh88BuwA3AIQMNHYp1nf5oBEYF0wgMERERERGRylWMERjlRCMwRERERERERKTkKcAQERERERERkZKnAENERERERERESp4CDBEREREREREpeQowRERERERERKTkKcAQERERERERkZKnAENERERERERESp4CDBEREREREREpeQowRERERERERKTkKcAQERERERERkZJXtQGGMcZvjPmsMeZ2Y8zzxpikMcYaYy4awGPPN8Y8aYzpMsa0G2MWGWM+OMQ6inYtERERERERkUpVtQEGUAtcD1wATAbWD+RBxpgfAHcAU4Bbgd8BewN/M8ZcMZgCinktERERERERkUpmrLVu1+AKY0wAOBZ43lr7njHmGuAbwCettbf18ZhDgWXAauAAa21rbv+uwDM4ocgsa+2aAXz/ol2rn+8RCYVC4Wg0OtRLiIiIiIiISIkKh8PEYrGotbbW7VpGQ9WOwLDWJq21/7LWvjeIh12S216XDxxy11oD3ATUABe6cC0RERERERGRila1AcYQHZPbPtDLsX9tdc5oXktERERERESkovncLqBcGGNqgR2Brj5GbazKbWeO5rVy13umj0PhWCxGOBweyGVERERERESkjMRiMYCQ23WMFgUYA9eQ27b3cTy/v3GUr7VdsVhMTTCkWIK5bdzVKqSS6HdKikm/T1Js+p2SYtPvlBRbVX1aXdYBhjFmDbDLIB7ye2vtuSNUTl4xu6IO6FrW2v17258fmdHXcZHB0u+UFJt+p6SY9PskxabfKSk2/U5JsfUzGr8ilXWAgbOCx2DSy3XD+F75URENfRzf3qiKkbqWiIiIiIiISMUr6wDDWnvsKH6viDHmP8COxpgpvfSumJHbvj6a1xIRERERERGpBlqFZHAeyW1P7OXYSVudM5rXEhEREREREaloCjAG5+e57VeMMWPzO40xuwKXAwng9u4PMMZMMcbMMsZsPV1k0NcSERERERERqVZlPYVkuIwxXwJm5e7um9teaIyZl/v6MWvtbfnzrbXLjTE/Aj4HvGCM+QsQAM4CxgGfttau2erbfAc4H7gQuGOY1xIRERERERGpSsbaYi6aUV6MMYuAI/s55dfW2gt6edz5wBXAbCALPAt831r7917OvYNcgGGtvWM41xIRERERERGpVlUdYIiIiIiIiIhIeVAPDBEREREREREpeQowRERERERERKTkKcAQERERERERkZKnAENERERERERESp4CDBEREREREREpeQowRERERERERKTkKcCoMsZxvjFmkTGmxRgTM8a8ZYy5yxgz0+36pLwZY35pjLG523S365HyYoyZYYz5ojHmEWPMu8aYpDFmgzHmPmPM0W7XJ6XLGLOTMeZXxph1xpiEMWaNMeZ6Y8xYt2uT8mKMGW+MucgYc48x5o3c66R2Y8xjxpj/NsbotbMUhTHmvG6vmS5yux4pT8aYw40xfzXGvJd7/nvPGLPAGHOy27WNFJ/bBcjoMcYEgT8DHwReA/4AdAI7AIcDM4HXXStQypox5kPAfwFdQJ3L5Uh5+hZwFvAK8E+gBdgd+DDwYWPMZ621N7hYn5QgY8xuwHJgInAf8CpwIPBZ4ERjzGHW2s0ulijl5QzgZuA94FHgHWAScBpwG3CSMeYMa611r0Qpd8aYqcCN6DWTDIMx5qs4r502AX/H+bvVBOwHHIXzWqriGP39rR7GmJuAy4DvAF+11ma3Ou631qZcKU7KmjFmAvAisAiYDBwJzLDWvuFmXVJejDEXACustc9ttf9I4CHAArtaa99zoTwpUcaYB4H5wGestTd22/8j4CrgFmvtJW7VJ+XFGHMMUAv8o/vrJGPMZOBJYCpwurX2ry6VKGXOGGNwntPeB9wNXA180lp7m6uFSVkxxpwB3AU8DJxmre3c6njFvq/TMLgqkfuE6hLgKeArW4cXAJX6Sy6j4he57eWuViFlzVp7x9bhRW7/YpxwLAAcOtp1SekyxkzDCS/WADdtdfgbQAQ4zxhTO8qlSZmy1j5irf3b1q+TrLXrgZ/n7h416oVJJfkMcAxwIc7fKJFByU1l+x4QBc7ZOryAyn5fpykk1eNsnMDq10B9brj/VGAz8Ig+KZehyn1q/hHgVGvtZueDBZGiyz8Rp12tQkrNMbntgl7ecHYaY5bhBBwHAwtHuzipOPo7JMNijNkD+C7wE2vtktyIH5HBOhRnBM9fgFZjzAeAvYA48KS19nE3ixtpCjCqxwG5bQOwGhjf7Zg1xtyMM/w2M+qVSdkyxuwC/AT4nbX2XpfLkQqV+z07FueThiUulyOlZffctq/+TatwAoyZKMCQYTDG+IBP5O4+4GYtUp5yv0O/xemr8mWXy5Hyln9ftwF4Fti7+0FjzBKcqW4bR7uw0aApJNVjYm77TeBpnF/0MThvClbj9Mb4mjulSTnKDV/7NU4Dqs+4XI5UKGNMDfB7oAa4xlrb6nJJUloactv2Po7n9zeOfClS4b6L8wnnP621D7pdjJSlr+M0V7zAWhtzuxgpa/n3dZcAIeA4nPd1ewEPAkfgLNxQkRRglJHcsnB2ELffdXu4N7d9D2eo/0vW2i5r7SPA6UAW+JwxJjDaP5e4Z5i/U1fhNOv8pN5USt4wf6e2vpYX59Oqw4A7gR+M1s8hFSM/p00dy2XIjDGfAT6Ps8LNeS6XI2XIGHMgzqiLH1b68H4ZFfn3dQZnpMXC3Pu6l4FTgbXAkcaYQ1yrcARpCkl5WY0zt2mg1nX7Ov8G84GtU19r7QpjzFvAbsAewIphVSnlZEi/U8aYGcB1wO3W2opcokmGbDh/pwpy4cXvcJY0vAs4V8sWSi/yIywa+jhev9V5IoNijLkcZ6rkK8Cx1toWl0uSMtNt6sjraLSzFEf+fd2b1toe79ustbHc6lz/jbOkeMUFZgowyoi19thhPPw1nHnAbX0cz/+PEBrG95AyM4zfqT1xhvRfaIy5sI9zVuUaep6q/hjVY5h/p4DCi70/4IQXfwA+of480ofXctuZfRyfkdv21SNDpE/GmCuBHwMv4YQXze5WJGWqji1/o+J9NDu/1RhzK05zzytHqzApW/nnvrY+jlf0+zoFGNVjIfBpnLlRPeTmmOdf5K0ZxZqkfK0BftnHsQ8Ak3Hm3nWg3ykZhNw0truAU4DfABf2tuyzSM6jue18Y4yn+++KMWYMzvSjGPCEG8VJ+TLGfBGn78XzwPHW2k3uViRlLEHfr5nej9MX4zGcN6UV92m5jIglOKshzTDGBKy1ya2O59/vrRnVqkaJ0Yjc6pB7U7ASZ8mdE6y1D3U79m3gK8Bia+1R7lQolcIYswinN8YMLc8rg5ELU+8GTsZ5sfcphReyPbmhsvNxVtK6sdv+H+H06rnFWnuJW/VJ+THGfA2n6fkzwHxNG5GRYoy5BvgGTj+x21wuR8pIrofYx4HrrLVf7bb/eJxGnh3ArtbaNncqHDkagVElrLVJY8z5wALgX8aYe4C3cZbhOQLYCHzKxRJFRH6OE15sAv4DfL2XobaLrLWLRrkuKW2XAcuBG4wxx+KE9QcBR+NMHfmKi7VJmcm9VvomkAGWAp/p5e/QGmvtHaNcmohId5/Dea77ijHmCOBJYBecJp4ZnFCszb3yRo4CjCpirX3MGDMXJ+k9GmdZuQ3AL4BvWWvXulieiMj7ctsmnOXm+rJo5EuRcmGtXZ17bvsmcCJOCPYecANwrT49l0HK/x3yAlf2cc5i4I7RKEZEpDfW2mZjzEHAV3FCi4OBTuAfwHestRU7dVJTSERERERERESk5HncLkBEREREREREZHsUYIiIiIiIiIhIyVOAISIiIiIiIiIlTwGGiIiIiIiIiJQ8BRgiIiIiIiIiUvIUYIiIiIiIiIhIyVOAISIiIiIiIiIlTwGGiIiIiIiIiJQ8BRgiIiIiIiIiUvIUYIiIiIiIiIhIyVOAISIiIiIiIiIlTwGGiIiIiIiIiJQ8BRgiIiIiIiIiUvIUYIiIiEjZMsZMMsZkjDE3uF2LiIiIjCwFGCIiIlLOTsF5PXOP24WIiIjIyDLWWrdrEBERERkSY8y/gAOASdbajNv1iIiIyMjRCAwRERFxnTFmgTHGGmNO22q/McbckTv23a2ONQDHAH/bOrwwxtQZY75ujHnOGNOZe3xvt4kj/9OJiIhIMSjAEBERkVLw/4As8G1jjLfb/h8A5wO3Wmu/tNVjPgAEgLu778yFEk8B1+K81vk5cCOwPndKClgN/Nta21zkn0NERERGiKaQiIiISEkwxtyBE1ZcaK29wxjzZeA64C7gbGttdqvz/wycBDRZa+Pd9j8MHAv8H/Alm3uxY4yZCqwCvMAUa+2mkf+pREREpFgUYIiIiEhJMMbshBMwbMAZeXEj8CDwYWttcqtzg8BG4AFr7Rnd9h8PLACWAUf0Eno8BBwHHG+tfXgEfxwREREpMk0hERERkZJgrV0LXA/sghNeLAdO2zq8yJkP1LHt6iPn5rY/3jq8yGnPbfUaSEREpMzoyVtERERKycZuX/+3tTbax3mnAkngH1vtPxynl8YDfTxup9z2jSFXKCIiIq5QgCEiIiIlwRhzNs7UkXyzzc/2cZ4X+BDwiLW2vdt+D87ojWZrbaSXx03CWXL1LWvtm7l9ZxhjEsaYXbqd9xNjzOrc+SIiIlIiFGCIiIiI64wxJwO/Bl4G5gCvAhcZY2b1cvoRwHi2nT6Sb+w1JhdmbO0LOK99bum27y/Ai8BXc3VcDZwNnGit3TC0n0ZERERGggIMERERcZUxZh5OkLAWmG+t3Qh8DfAB3+3lIafhTBO5r/vO3GojK4BanBCi+/c4HbgSJxj5yVaP+TJwgTHmS8A3gA9Ya1cV42cTERGR4tEqJCIiIuIaY8w+wGIgBsyz1q7uduwpYC7OaiJLu+1/F1hjrT28l+t9BLgbSAN3Au/iTBs5DmeFkxOstW/18rjlwIHAh6y1/yraDygiIiJFoxEYIiIi4gpjzHScZVItTrCweqtT/ie3/X63xxyA04hz6+kjAFhr78Vp8Pk0zkiNK4EJwFeA9/cRXhwD7AMYnCVcRUREpARpBIaIiIiUDWPM/+IEG9N6CyOGcL38CJDPAR8A6qy1Jwz3uiIiIlJ8CjBERESkbBhjVgIJa+2+RbjWLsBy4BZr7TeNMXsBLwDHWGsXDff6IiIiUlwKMERERKTqGGPGAcuAJdbai7vtvxPY2Vp7iGvFiYiISK8UYIiIiIiIiIhIyVMTTxEREREREREpeQowRERERERERKTkKcAQERERERERkZKnAENERERERERESp4CDBEREREREREpeQowRERERERERKTkKcAQERERERERkZKnAENERERERERESp4CDBEREREREREpeQowRERERERERKTkKcAQERERERERkZKnAENERERERERESp4CDBEREREREREpeQowRERERERERKTkKcAQERERERERkZKnAENERERERERESt7/B900oyn0GkG/AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 321, + "width": 536 + }, + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Ex \n", + "\n", + "fig, ax = plt.subplots(figsize=(8,5))\n", + "COLOR = {1:'black', 0.1:'blue', 0.01: 'purple', 10:'red'}\n", + "for ratio in [.01, .1, 1, 10]: \n", + " dat = ALLDAT[ratio]['x_line']\n", + " x0 = dat['x']\n", + " Ex0 = dat['Ex']\n", + " sigx = .001\n", + "\n", + " ax.plot(x0/sigx, Ex0/1e6, color=COLOR[ratio], label=f'{ratio}')\n", + " \n", + " \n", + "# Charge density \n", + "ax2 = ax.twinx() \n", + "ax2.fill_between(x0/sigx, 0, gauss(x0/sigx), color='gray', alpha=0.2) \n", + "\n", + "ax.set_xlim(-6, 6)\n", + "ax.set_ylim(-10,10) \n", + "ax.set_xlabel(r'$x/\\sigma_x$')\n", + "ax.set_ylabel(r'$E_x$'+' (MV/m)') \n", + "ax.legend(title='r')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "extended-collaboration", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 321, + "width": 536 + }, + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Ez \n", + "\n", + "fig, ax = plt.subplots(figsize=(8,5))\n", + "COLOR = {1:'black', 0.1:'blue', 0.01: 'purple', 10:'red'}\n", + "for ratio in [.01, .1, 1, 10]: \n", + " sigz = .001*ratio\n", + " dat = ALLDAT[ratio]['z_line']\n", + " z0 = dat['z']\n", + " Ez0 = dat['Ez']\n", + " ax.plot(z0/sigz, Ez0/1e6, color=COLOR[ratio], label=f'{ratio}')\n", + " \n", + " \n", + "# Charge density \n", + "ax2 = ax.twinx() \n", + "ax2.fill_between(z0/sigz, 0, gauss(z0/sigz), color='gray', alpha=0.2) \n", + "\n", + "ax.set_xlim(-6, 6)\n", + "ax.set_ylim(-10,10) \n", + "ax.set_xlabel(r'$z/\\sigma_z$')\n", + "ax.set_ylabel(r'$E_z$'+' (MV/m)') \n", + "ax.legend(title='r')" + ] + }, + { + "cell_type": "markdown", + "id": "systematic-lincoln", + "metadata": {}, + "source": [ + "# Cathode images\n", + "\n", + "Test the three methods" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "female-institute", + "metadata": {}, + "outputs": [], + "source": [ + "def set_params(filename='params.in', sigma_z=1e-3, sigma_x=1e-3, imethod=3):\n", + " params = f\"\"\"\n", + " &OPENSC_TEST_PARAMS\n", + " NXLO=1 ,\n", + " NXHI=64 ,\n", + " NYLO=1 ,\n", + " NYHI=64 ,\n", + " NZLO=1 ,\n", + " NZHI=64 ,\n", + " N_PARTICLE=10000000 ,\n", + " E_TOT= 1e6 ,\n", + " BUNCH_CHARGE= 1e-9,\n", + " DISTTYPE = 0, \n", + " SIGMA_X= {sigma_x},\n", + " SIGMA_Y= 1.0000000000000000E-003,\n", + " SIGMA_Z= {sigma_z},\n", + " GAUSSIANCUTOFF= 6 ,\n", + " DIRECT_FIELD_CALC=T,\n", + " INTEGRATED_GREEN_FUNCTION=T,\n", + " CATHODE_IMAGES=T,\n", + " IMAGE_METHOD={imethod} ,\n", + " RECTPIPE=F,\n", + " READ_RECTPIPE=F,\n", + " WRITE_RECTPIPE=F,\n", + " APIPE= 1.2000000000000000E-002,\n", + " BPIPE= 1.2000000000000000E-002,\n", + " /\n", + " \n", + " \"\"\"\n", + " with open(filename, 'w') as f:\n", + " f.write(params)\n", + "set_params() " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "strong-ribbon", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 127 ms, sys: 23.7 ms, total: 150 ms\n", + "Wall time: 36.5 s\n" + ] + } + ], + "source": [ + "%%time\n", + "IDAT = {}\n", + "\n", + "method = {1:'convolution/correlation', 2:'shifted Green function', 3:\"Chris' shifted Green function\"}\n", + "\n", + "for imethod in method:\n", + " IDAT[imethod] = run_test(verbose=False, imethod=imethod)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "matched-haven", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "13.635 s for convolution/correlation \n", + "13.893 s for shifted Green function \n", + "8.793 s for Chris' shifted Green function \n" + ] + } + ], + "source": [ + "# Print the times\n", + "for i, name in method.items():\n", + " print(f'{IDAT[i][\"run_time\"]:0.3f} s for {name} ')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "separated-passion", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 318, + "width": 504 + }, + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8,5))\n", + "\n", + "isymbol = {1:'o', 2:'x', 3:'.'}\n", + "\n", + "for i, name in method.items():\n", + " zdat = IDAT[i]['z_line']\n", + " z = zdat['z']\n", + " Ez = zdat['Ez']\n", + " \n", + " ax.scatter(z/1e-6, Ez/1e6, label=name, marker=isymbol[i])\n", + " \n", + " ax.set_xlabel(r'$z$'+' (µm)')\n", + " ax.set_ylabel(r'$E_z$'+' (MV/m)') \n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "express-boutique", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 277, + "width": 1048 + }, + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Method 1\n", + "plot_plane(IDAT[1]['xz_plane'])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "neither-guide", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 277, + "width": 1048 + }, + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Method 2\n", + "plot_plane(IDAT[2]['xz_plane'])" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "downtown-belfast", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAACDAAAAIqCAYAAADYEygWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAABYlAAAWJQFJUiTwAADQD0lEQVR4nOzdeZx8V1ng/89T/e0krAEExB8om0AcdURAQDIDARQRBEFhxAUURUdlZB2VEZVFcRkRBFyYQdlEJIIjuABGgQgSEUEFFcISiCCLCkEICd+lq57fH1VNOp06T3ffvrX25/161au+3zp1nnPurVv3Pvf2qXMjM5EkSZIkSZIkSZIkSVqkwaI7IEmSJEmSJEmSJEmS5AAGSZIkSZIkSZIkSZK0cA5gkCRJkiRJkiRJkiRJC+cABkmSJEmSJEmSJEmStHAOYJAkSZIkSZIkSZIkSQvnAAZJkiRJkiRJkiRJkrRwDmCQJEmSJEmSJEmSJEkL5wAGSZIkSZIkSZIkSZK0cA5gkCRJkiRJkiRJkiRJC+cABkmSJEmSJEmSJEmStHAOYJAkSZIkSZIkSZIkSQvnAAZJkiRJkiRJkiRJkrRwDmCQJEmSJEmSJEmSJEkL5wAGSZIkSZIkSZIkaY4i4vsjIiPiKT3GfOIk5iP7iilJ8+YABkk6gIj4y4jYiogvXXRf+hIRg4i4MCI+GxFfuOj+SJIkaXlFxNMmF0Qfvui+9CkinjdZrvsuui+SJEk6vIh44SS/2/0YRsQlk+u8j4uIqy2of1cDngRcCjxr8tr3NPq8n8f3TEI/B/gP4Kci4hqLWDZJOiwHMEhaKkViOe3xmDn37f7A2cDLMvP9k9cePunLVkR80T7jfPmOZbh34z2PnpQ/q78lmC4zR8DPA9cAfmrW7UmSJGlvy5gXR8SNgMcAFwO/PXntFhExmvTjv+0zzkZEfGxS5xca7/mqSfk7eur+Xn4eGAI/FxFeK5EkSVofp4B/3fG4FLgu4+u8vwy8LSJusIB+PQq4MfDrmXnJ5LXP7err9uMTO+p9qvGezwFk5meAXwW+kHHuLkkrx5NySctqd2I57XHZvDozuYj5c0ACT9tR9PJJPzaA79xnuIdNnj8G/FnjPd80ef7jg/W0s98BPgj8QETcfE5tSpIkaW/LlBc/Cbg68IuZuQWQmR8A3jQpf1ir4i73Am40+feLGu+Zaz48WY7fBf4z8O3zaFOSJElzcUFm3mjH4zrAdYD/CYyA/wRMHVQ7KxGxwXgAA8Dztl/PzHN39fVGmXkj4Gt2VP+Wae/JzHN3vOc3J88/EhHHZrs0ktQ/BzBIWla7E8tpj+ftHaY33wB8OfCXmfnu7Rcz87PA/5v896F7BZkMhNge6PCSzBxOec+1gLsyHg38F4fs975MLkC/CNgE/sc82pQkSdK+LEVeHBHXBb6H8S+7XrKreHsQwjdExA33EW57oMPf7Mytd5n3gF644kLv4+bYpiRJkuYsMz+dmb8M/NbkpfvNuQv3Af4/xvnwRX0Hz8x/Bv6K8SwM37TH2yVp6TiAQZL25xGT55dNKdu+YPufI+Kr9ohzT8ZTg+2st9u9gNOAP8vMkwfq5eH87uT5oRGxOcd2JUmStPy+CzgD+OPJIN6dXg5cDhxjj9kLIuLawDdP/js1H55M4XtH4N+Bvz5Enw/qTcBHgNtFxG3n2K4kSZIW452T52vsfDEinj+5ndkrqsoR8ZTJ+y44YLsPnzz/3gHrHcR27IeX75KkJeQABklrISL++yRZPB4RX9F4z/+dvOdDEXGdA8T+AsajcJPxxdnd3gB8ePLvvabN3S5/e2b+U+M9V/m1WUTcbPsex5P/3zEiXhUR/x4Rl0bEBRFxnx3vPy0ifjwi/jEiLo+If42I/xMR12t1LDPfC7wDuAGOzJUkSVpJEfHC7bxxj8cLDxi6eZE1My8F/mDy373y4QcDVwNOMn1wMIx/kTYAXpOZo+0XI+LiSd/PiYgviojnRsSHI+JzEfHuiHjsZMaz7fc/OCLeFBH/ERGfiYg/aZ0rTJZjBGxfpPZCryRJ0vr7ysnz+3e9vj0z1/0m14avIiIC+O7Jf5+/3wYn+eo9Jv99837rdbAd+x7eRkLSqnEAg6S1kJn/h/Ef/E8HficiTttZHhHfBHw/40EI35OZ/3GA8HdnfGuF92Xmv09pewT89uS/3zG5h9lVRMQ1gQdO/tv6tVkA3zjp56sb77k/8JeMB1VsAtcEvhb4o8lF2jOAP2V877ZbTqrdEPgB4M93r5tdthPbexXvkSRJ0vL6NPCvxeMqtzDbS0RcH/jqyX9bF1m389vbRcSXF+G2Bzj8cWZ+svGevW4fcXPgb4H/DlybcU58FvAM4FmTPv8C48EWX8v42se1GA+MeFNE3Kron/mwJEnSmouIa0fEY7hi1t1n7izPzAuAdzGeJfc7me6ewE2By4BzD9D8VwJnMs7L33GAegf1DsaDhq8J3HaG7UhS7xzAIGmdfB/wb8B/Bn52+8XJFLTbo2afmZmvP2DcsyfPby/es33B9kbA1zfe862MpyM7xRW3a9jtjozvTfY3mfmvjfe8ePL4osy8DuPBCa9ivE9/JvB0xhdwv4lxgnotxtP0Xsr4wvMjrhry8942ef6vxXskSZK0pDLz0Zl5o2kP4HuBmLz1tQcIu50PfywzP9Z4z+uAf5n8+6HT3hARN+OKPLM1oHeT8eCBU4wH5U7zTOCDwFdl5pmMBzH81KTskRHxE8DjgMcAZ2bmtRlfKH4PcB3gaY24cEU+fNbkPEKSJEmr7S4R8fEdj/9gPOj3mYz/yP+wzHzhlHrb15NbM3N97+T5FZMZyfbrjpPn92fm5QeodyCTWxO/Z/LfO82qHUmaBQcwSFpWuxPLaY9r76yQmf/GFX+cf3xE3G3y7//LeFDAPwI/0aEv20nlO1tvmNx+4S2T/7amzd1+/U8y8xON9+z1azOAv83MR2wPcJjMCvGdwGeAGwOPBB6SmX+SmcPJ4w+BX5rUf1ARe3vU73+KiGsV75MkSdJ8HDgvniYibgO8lPF1gP+dma3bN0yzn3x4BLxk8t/v3Hkrhx0eyngAxb8Dr2mEuivjAQlvyszPNN4zAu6Tme+ctH15Zv4s8PpJ/KcBP5uZz8rMyybv+UfGM7IB3L81K1lmfpBxXg1XLLckSZJW1ybja8PbjzN3lF0PuOFkVtzdXsx4BoPbRsRX7yyIiDO5Yqbdfd8+YuKLJs+t68N92m7ji8p3SdKScQCDpGW1O7Gc9rjKPiwz/4jxgIUB8OKIeCzwAMbJ5ndl5okOfdlvUrn9K7IH7P7jf0TcBDhn1/um2c8Ahl/Y/cLkwuz2AIoLMvMvptR73eS5ed9frljGYLyOJUmStFid8uKdJhdY/5DxxdrXAP/rgH04aD58E664r+9O2zMzvDQzTzVi7Ccffm7jlnB/Pnk+yfh2Eru9GTjO+LZzX1rE3761hRd6JUmSVt9fZGZsP4BjwC2AH2Y8e+3TuWK2hc+b3O7slZP/7p6F4TuAMxjfcviNB+zP9SfPnzpgvS6227h++S5JWjIOYJC0rK6UWDYe/9Go+zjgfcCXcMWFy5/KzK73FNtvUvky4ARwNa46y8FDGe9zPwn8ybTKEXFjxvcj+0hm/l3Rzj80Xv+3yfM/Nsq3b0lx3SL2zmU0sdXCRcSDIuI5EfGmiPhMRGREvGTvmgdu5ysj4sUR8eGIOBER/xYRfxERrRlVJEmal8PkxUxmQvhd4NaMp5D99slsCQexr3w4My8E3jr575VuIxERXwvcavLfFxdh7jt5rgYw7JUPX5yZn53SvxFXDMLYT05sPqylYE4sSVJ/JrPVfjAzf4PxrLYA3xsR/2XK27cHNnzHrhm8tm8f8YIOXTh98nyyQ92DOj55vtoc2pKk3jiAQdLamcxG8D92vPQWxiNpu9pXUjm5cPyqyX93X+DZvoD7u4f8tRnFfYeHk+e9yo8V4Y/v+LeJrZbBTzL+Pt8W+MgsGoiI7wH+jvFsLW8Cfhl4BeOZSO4zizYlSZqjXwC+EfgP4P6Z+ekOMQ5ykfWFk+dviYhr7Hh9Oz/+x8z822kVJ7e5uBXwnsx8X9FG13x453s2i/d4oVfLxpxYkqQZyMw/BT4++e9/m/KWPwc+CHwBcH+AiPhy4A6M88pqpt2WSybP1+lQ96C2B+1+snyXJC2Z6o9YkrTKdk7rdSvGU+tWFzIrlwA3Yn9J5YsYJ7t3i4gvycwPRcTXAF+2o7zlfpPncgDDjO38JZqJrZbBY4F/Ad4P3A14Q5/BI+LOjEfT/yNw78z8+K7y6o8bkiQttYj4DuBHGV9cfUhmvrdjqINcZH0Z8EzG0/F+C/Dbk1+rbV8QXvZ8GLzQq+VjTixJ0ux8iPG131vsLsjMjIjnAz/D+HrzK4DvmxT/aWZ+tEN7+5kRrC/bbex1KzhJWirOwCBp7UTEdwIPAbYYT5P7BcDzDxHyIEnl9qjdAL5r8tr2r83elZlvm1YpIq7G+D7BnwNe172rh7ZzGU1stXCZ+YbMfF9m5n7rRMS3R8QbIuJTEXE8It4dET8ZEadPefv/BjaA79p9oXbSfmvGFEmSllpE3J4rprz98cmvy7radz6cmZ8C/mjy3+1ZyO4HXI/xQIrfKarva0ayOfBCr5aKObEkSTN148lz63j3AsZ57DdExE254ppv1+vN75k836xj/YPYbuPCObQlSb1xAIOktRIRXwz86uS/T2U8/eXngHtHxA93DLudVN58rzdm5s6Lsg+d/FLlIZP/V782uyfjKWpfn5mf69jPPtxs8vxprpg+TVoZEfFbwEuBLwX+H/BrjH81+jPAayPi2I733gT4r8DbgH+KiLtHxP+MiMdHxD0n9wyXJGnlRMQXAq9knF/+dmb+8iFD7jsfntjOe+8ZETfmigG957VuhxYR1wHOZnyri7/s1s3Di4irAzeY/NcLvVpJ5sSSJO1PRJzNFQMYpt7mLDM/AryG8WC/32GcK/478Icdm70ASOC6EXHLjjH2NDnG32jy34Xl15LUhSchktZGRATje+5eB3gL8HOZeSHw45O3/FJE3LpD6DdPnu+wz/dvX7A9C3gycH1gBLykqLMsvzb7msnzmzNztNCeSAc0uW/v9wJ/ANw6M78vMx+fmWcDTwHOAR65o8r29v4+4PWTxy8BT2d8j8O/j4gvnU/vJUnqx+R2Db8P3AR4K/ADPYTdzoe/IiLO2Mf7Xwv8K+NrDo8GvnHyejWg996Mb3P5p5m51bWjPbgd44vTlwLvWGA/pE7MiSVJ2ltEXC0iHgD87uSly6lnVNie2ezsyfNLus5QlJmXAO+e/Pdrqvce0nbs92Tmv82wHUnqnQMYJK2TxzK+DcNlwEMnsyHAeEaGPwOuzvgevMca9Vu2R6h+dURs7PXmzPwH4O8m/33C5PnP9rgn2n0nz8sygOFNC+2F1M2jGd865nunzGTyM4zvY/2dO1674eT5vwFfxvg+3Wcy/qXabwNfCfzJ5A9BkiStimczvrD6UeCBmXm8h5jvBD7DeIDBbfd682QAwksn/308sMl4hq9XFdWWbUDvBTvOJ6RVYk4sSdKV3SUiPr7j8e+Mrx//AfDFk39/22SmhZY/AXbOJHaY2xUDnDt5vm/5rsPZjn1u+S5JWkIH/SOeJM3LXSJir1sYnJuZjwaIiK8Afm7y+uMz8/3bb8rMjIiHA/8A3BH4ScYzI+zX24APALdg/GuV1+2jzouAr+aKgWLNX5tFxG0Z/0LuHZn5LwfoV68mv6a7O+MpzF6+qH5IXUyme/4qxveqfsx4QparOMH4ouy2jR3Pj8jM7T+YfCYivnvy3jsA38oVI/IlSZq3A+XFjGcygPGsZH/bOCburlPKzGFE/D7wcMYXQt+yj2ovYjzAeDsfPrc1mGIySPjejO8t/Jr99GmGvNCrlWVOLEnSVJvAF+567bOMr/f+GfCczPznKkBmbkXEHzGe3exvMvMfD9mnFwBPAr45Is7oadDx501ua/xAxtd5X9BnbEmaBwcwSFpW0xLL3c6Ez0+T+xLgdOBPMvP/7H5jZn4kIh7J+JdgT4yIV2fmW/fTkckAiOcDPws8hP0NYHgp42k3Nxn/Wu2VxXuX5ddm3wRcC3hDZl604L5IB3VdIBjfh/BJ+6zzqcnzCeDVOwsm3/tXMb5Ye0e8WCtJWpx958W7XH3yOEidym8xHsDwbcBP7fXmzHxHRLyD8R9TAV5cvP1rgS9gfBuzTx6wX72JiBsyHrD8WeD3FtUP6RDMiSVJmsjM7wG+p8eQd588H3b2BTLzwxHxGsaDZ78JeMUe77+Y8TF+v+4NXA84b1JXklaKAxgkLZUuiWVmnmR/U9n+Lt0vuGyPiv2WiPgfmXlij7b+HdjvFJt7DmDYT5K617rbR4xvnzw/r2pHWlKfnjz/XWbebp913jN5vjQzR1PKty/mXu1QPZMkqYOuF1wz82Z992US980R8U/Al0fEHTLzbfuoc9t9ht/XgN69li0zXwi88BAxvo3xr9BfmpmXVXGkJWVOLEnSDETEPYFbMb7dxEv3ePt+PRm4D+NbrpUDGDr4n5Pn/Q5olKSlMtj7LZKkzPwo8H8Yj1x9eF9xI+IGjO+z++/AvmaEmIWI+FLgm4F34XS5WkGZ+Vlg+48q19tntXcynl73+hEx7ZetXzF5vvjwPZQkaS1sXwD9n+W7Dm7hM5JNbmPxaMa/Qv+5Pd4uLSVzYkmS+hcR12c80y7A8zPzM33EnQwIfjlw54j4uj5iAkTEfwHuCrwqM/dz6zdJWjoOYJCk/fsZxtPJ/nhE9DWDzXUncR/d+LXLvPwvxr82e+KC+yEdxjMYz3zy/Ii4zu7CiLhuRHz+l2iZucV4YBLA/46IwY73fiXjX71u0f8oeEmSVlJm/j7w18CDI+LWfcSc3A7u5cBP9HAv4cP4DuCWwHP3ugeytOTMiSVJ6kFEPD0iPgR8FPhqxgP+frbnZp4APAW4Zo8xrzOJ+aM9xpSkuYrMXHQfJGllRMQDGd/H94Xrcv+wyQWqJwAnM/Ppi+6PtFNEPAB4wOS/NwK+AfgA8KbJa5/IzP+54/2/BvwwcAnwp8CHGM+ccnPGo89fkJk/uOP9VwdeB9wZ+DvgfMb3DP5WxtPkPj4znzGThZMkaQVFxFcznrnr/Mw8f8Hd6U1EfBfwpcCvTW4HJy0Nc2JJkuYvIl4IfDfwGeAtwP/MzH9YaKck6YhwAIMkSVpaEfFk6vv1/fPue1lHxDcBPwjckfGo80sYX7Q9D3hJZl646/1XB34MeAjji7rHgb8BfjkzX9PHckiSJEldmRNLkiRJOkocwCBJkiRJkiRJkiRJkhZusPdbJEmS1JeIuG9EnBcR/xIRn4uID0TEyyPiaxfdN0mSJEmSJEmSFskZGCRJkuYkIn6R8dS8nwReCXyC8f227w8cAx6WmS9ZWAclSZIkSZIkSVogBzBIkiTNQUTcCPgI8O/Af87Mf9tRdnfg9cAHM/MWC+qiJEmSJEmSJEkL5S0kJEmS5uOmjHOvv945eAEgM98AXArcYBEdkyRJkiRJkiRpGRxbdAc0XxHxQeDawMUL7ookSV3dDPhMZt58d0FE/A5w1ozavTAzv/MQ9d8HnATuGBHXz8xPbBdExF2BazG+rYSkGTMnliStgZuxmjmxpCVhTixJWgM3w5x4LTmA4ei5dmxuXm/zC294vWmFudGuONgYNcs2Bu1bkWxEVW96WVmHjm0VZdEx5qCoN+har1EWzRp7lXW7TUxUQVdA17vjVNWyXNP9x+xab5TTy2bRVpd+HCZm9bmOOsecXlbHa2vF27MfnWP2X6+1V6nWf9d+VFoxT3z4E+TJrVa1s4Db3e4rT+/UZsvf/sMJgLMi4u3TyjPz9nvFyMxLIuLHgWcA74qIVwKfBG4J3B/4M+C/99VnSaVrx7HN651x3S+cmhNXyl1ax/ypGXOebQFExwSqiFlG7LR87Yid89eiXplLl/WKso7ruarX3ITKdXLweHv1o1Kty66fXRnzgK+PC7utkzJk1/OxsnAGMXu24qeTS6X1aX/yg5eydXzYqjbLnFjS+rj21c6I633ZrU47cE68CrLjMXjeuvWyXavrUtf1urXXuS/l9aeDX+ua97XZztfxul6D7XAttfO12Xlft22H7H4NtsPn03W5Z7FslXnGnEUf64rT2zvxL/++qOvEmjEHMBw9F29+4Q2v9/89/rFTC0fXaX7ROeNa7S/lta5+vFl25hntsuuefvn0OpvtOtc+9rmirOjHseltAVx9cLIdc9Bu7+qD9jq5RlF2RpwqyqZ/BpvFgIhN2mWnlQMp2jY6XnGaxX1p2kvQNiwTpqJekVScyvbSzaZee0TRqWzvvo/n5tTXT3aMV/Wj1da4vXbME6N2veNVX0ZFzGqdFO1tjaZ/PlUfTxT92Co+7xPDbvVOdqx3atj+7Kp6w8Y6OdV4vaqzd1n7O9Cq9/7HPY/jF3384la9233l6fzNeV/SjNvF19zrQ70kp5n5KxFxMfB84Pt3FL0feOHuW0tImpmLz7juF17v1g+enhPnoLg4VJxBFYeiul5jd123VVxELAYlj4qyrjHrekVSViWOxxoZWxEvirJBVdYYVD2uVwyQLsoGxQDvY0V7x8pB4wcv2+xQB+BYh0HosMeyRfMPrWW9QfHH+qqfm4Pp7dWD0NtlrXh7x+y2bBvFWUtVr9KlXtWPvtvSdK2B4S/89tfzr+/+j4tb9ZY5J5a0NC7+sluddr2/Oe+LF92PmRhmt2NYV6OOf5YbdTjWDou/mFbxhkUfR0XMsl6zBE6W/Ww7VazKk8X1rNYfyatrsyeLk5Ku12bLa7D0H7O67tmK2fV6b7lOOl63PVWcpFbt1ddni3rFddbWtrJV9PFkUVbVq67Ntq5XAwy71itjHvz6bN/Xe6Ee3DBq1Pvg4/8vxz/wsYtb9cyJV5cDGCRJ0lpJstMFgL1iMp4abM+ZFioR8WPAzwHPBn4V+Djj0cA/D/xORNw2M3/skN2VJEnSETfDnFiSJElaCebEq2sWP5aWJEnSLhFxDvCLwB9m5uMy8wOZeXlm/i3wQOAjwOMj4hYL7KYkSZIkSZIkSQvjDAySJGntzHuqyH36psnzG3YXZOblEfFWxgMZvhr4wDw7JkmSpPWzpDmxJEmSNDfmxKvJAQySJGmtJN3vPVnF7MHpk+cbNMq3Xz/ZT3OSJEk6qpY4J5YkSZLmwpx4dXkLCUmSpPl40+T5ByLixjsLIuIbgbOB48AF8+6YJEmSJEmSJEnLwBkYdGXF0KHRKJplw6Jsa9QeJ9Mq28p2nVO50XvZKItlK8b5jIqyYbEMtJtr2ig+nNOiPQXOZtHWZtHeZrQrbhQLMOhYr2/DYn2Nsl1W1TuVw6Je26nie3WqWCenyu/BqWbZ8UbZSdrfgeOj9tZwqqi3OWov+fFsx9ygvc0OiimdTkW7vY1REbP4XE/0fSgcFfE2ttplw3a90aC93NW+eWPQXidVvVFMX18bjderOgBRljWLGDTq7b0nSUbFNtZNL2NrXwH8OfB1wLsj4g+AjwNfxvj2EgE8ITM/2UdjkmoxhM3LppeNjhW5wmntmNW+tdqNFKlJu61yb9htv8uwKCz25XW9dlFWMVvrsur/oB2vWsdZnAt0LZv3bzK6ZNmt4yzUx+6qXpVzlfWKsmPFuc6gKmv0pWprs8i56mWr+tiuV+bEHddX15jNeMWydVWty1VQ739nYfp54QrnxJKWSJJLM7V237+QrdtajmWehUFxvbr6NeuoQ161l82iXnkNtig7vehnq6S6pnuyuv5aXIc8le1rfNXfIarrpSeLK8yb0Y5Z/d2gtexVPwbFydOJ4hryRnE+Vn3lBh3r1Rt0UdZele3rs0VbXXPD6vpBlbdn8fmU9arrusW5bevcsO/rvQDDDv3YmznxqnIAgyRJ0hxk5igi7gM8EngI8EDg6sAlwKuBZ2fmeQvsoiRJkiRJkiRJC+UABkmStFYSGHb5OfMeMXuJk3kK+JXJQ5IkSZqJZc6JJUmSpHkwJ15dDmCQJElrZ55TT0qSJEnLyJxYkiRJR5058Wqq7hIjSZIkSZIkSZIkSZJ6FBE3iYjnR8RHI+JERFwcEb8SEdedVZyI+OKI+PWI+OuI+Pjk/R+NiDdFxMMjYrO/JezOGRgkSdJaSWDY88hax+lKkiRplZgTS5Ik6ahb5pw4Im4JXADcEHgVcCFwR+DRwL0j4uzM/OQM4twS+E7gr4FXApcAXwB8I/B84GER8fWZudXHcnblAAZJkiRJkiRJkiRJkubj1xkPOnhUZj5n+8WIeAbwWOBpwA/OIM4FwHUzc7QzyGTmhfOAc4BvAX7v4IvUHwcw6MqG0S4atu84cnKrvSkd3xo2yy4bnD719WOD0dTXAQbF+KZBtMs2oh2zMizutDLMYn0N2vVOsdEsu0acnF4nTrXjRXsg1OnRXv9nlOukGEfWXmwGVWFhM9rrZFB8Bp3a69bF8l5Jp7K9nk9RlGX7MzhexSzKTm+UnSrW4/Fi+zqe7RmDNotl2ywG6G0W2+zmqF12PE9rlm2swu+BRu195XDQXpejYqMdFdtCdaOoUbH/GsX0siz3se2yql422tqr3l68t5mkvUQmx45P31cUu2so9p+R1b6n2O+2apQ5V1trPz6O2S3Hq84Tyv11Ua9avuZqHhTHlFHRVlWv3Q2qjzSLbaEqK4/BRXvtbLmt/LwL1XlVXVacx1X1ynO8dszNDu1tFjlX1Y9jRb2N5re4+7rsGrPreW+17H23teq6fBcBhtntLq6Dxjl97OMzMyeWtJcRyedy+rXIrvr+pWtXozI3X1/Lsv73UmURG+WJQpU/TTcowlX5ZHXd9mRxRnaqyl+L63jHs30ieqoo2yjOdU7m9LUyKJat6mOVo1bXkCsbRV9KVbXyhLldNGxtLEWdUZUTl9dm+7+mW+X0o0NcZ52X6pLEYXq/jDlxRNwCuBdwMfBru4qfBPwA8NCIeHxmXtZnnMzpB/7MPBURr2Q8gOFWB1ui/nU7e5IkSZIkSZIkSZIk6Wg5KyLePu2xz/r3mDyft3smhMy8FHgzcHXgznOKQ0RsAPeZ/Pede71/1pyBQZIkrZUkGfb8S4tcwpG6kiRJUos5sSRJko66Jc6JbzN5fm+j/H2MZ1a4NfC6WcSJiOsD/4Px5Bc3AL4e+FLgpcAf192fPQcwSJKktXM0JzSWJEmSrmBOLEmSpKNuRjnxhZl5+0PUP3Py/OlG+fbr15lhnOszvs3EtgSeDvxE5uLvw+QtJCRJkiRJkiRJkiRJWryYPB92IEEzTmZemJnBeLKDmwKPBX4AeGNEXO+Q7R6aMzBIkqS1ksCw5+ltFz7kVJIkSToAc2JJkiQddUucE2/PjHBmo/zau943sziZOQQ+BDwrIv4V+F3gqYxvL7EwzsAgSZIkSZIkSZIkSdLsvWfyfOtG+a0mz++dU5xtr5k8n7PP98+MMzDoykbRLMphu2xra6NZdrIoO7ExfRO8fOu0Zp1BtMc3VWUbHe90M8pu43xOZfvrdY1sr5PhYHp7J6NYx4NTzbIzaJedYtipbLO4/c1mtOudFu1taDPbn8+gqsf09bJZrK8B7Xgb0f682xHr9obFso2Kbfbq2e3zOdFo73huNescL9oqy6K9fV0+Or1ZdloR87RiG9oY9f8dH8T0ehuN1xeh2g+NBu3tuVolVb3xzFFT6hTfxWr/G53LmkV7GvrzMEl7GcHGiek7yijy3sYuclKxqlftmBr1ql18URbtQ36ZV1V5SdWXan1RxCxSpPZQ+3LB20XZsV75mRY5cXW3yGpLaB2DAUZFWStmFW8Wup6rledxHettDqbnlMeKXLOM17FelaPWy13UK7airjlsFbPvtlbdsOM1gkGxDY3KHVF35sSS9jIiuXRUJI9Lrr1nXS5H84g5G/M8tlVH/NOKPGijytWKss0iZnV9drO85rs5vR/Fydjx6vrroFjuImaVE7f6eCjVNdHqgmOHNK/K40bFufKxYl2Ohu2OVPWqv+F1PR9rnmtWdbpeG5nR+euS5sRvmDzfKyIGmVd8gSLiWsDZwOeAt8wpzrYbT54Xnhw4A4MkSVoryfg8pc/Hcua5kiRJ0nTmxJIkSTrqljUnzsyLgPOAmwGP3FX8FOAawIsz8zKAiNiMiLMi4paHiTOJdaeIuPruPkXENYFnTf77J92WrD/OwCBJkiRJkiRJkiRJ0nz8MHAB8OyIuCfwbuBOwN0Z3/LhiTvee+NJ+T8zHqzQNQ7A/wLOiYi/AD4EXA58MfCNwHUmsX6+jwU8DAcwSJKktTOc0TS8kiRJ0qowJ5YkSdJRt6w5cWZeFBF3AJ4K3Bu4D/Ax4NnAUzLzkhnFeR5wGfA1wDnA1YFPAW8Hfg94fmZxb5o5cQCDJEmSJEmSJEmSJElzkpkfBh6+j/ddDO2RGPuNM3nvn7AEt4jYiwMYJEnSWsmEUc836E1v+CtJkqQVYk4sSZKko86ceHU5gEGSJK2ZmMHUYMs51ZgkSZI0nTmxJEmSjjpz4lXlAAbtWw4HzbLhsP2FPTXcaJadaJRtDtub5rEYdSobFGWljt+S0aBYXxy8rIo3GhVl0S47Fe3b2ByPYbPsjKJsM9vr+bTiM9iM9rC1zWJE20Yj5iBPFW2118lmtrfXjWhv54PiMx0UB7Sq7PRob3ynFxtm6/M5vbht0RnF53a8qHfZqPi8B+2yy4qYm0XZgHbMjaqs2jeMTm+WzdOo2BZG2S0pquoNiu9cNMqOFZ9pdmwryzKTQUmzEwkbJ6bvg4pUh2wf8stz2HKf1tgX5qBdpwxX7T6LZYuiYg6q40bRXpGC56hYvka98pBY9LFsq6hXHUujKKuOi7Moa/Wz6n/XslmoztUGFOcJg/YGfazxRa7yks3qPKcoq2KWeWixbLOoV+lyvrxR9GMdtC50dr22MCoOIO2zUBg26sWar39J8zFMuHTOx/1VNnRdLbXq2tqy6PqH1NPK655FbtjIF8q8tzhpPJ6bzbJBcX25VFWrzr9nodGX6m8soyI3HBbnK6PiHPVYx3qta7pQn0NU5zOtc8OqrbqsWVRfQ24GNCdeVw5gkCRJayXpfkJYxZQkSZJWhTmxJEmSjjpz4tU17/FLkiRJkiRJkiRJkiRJV+EMDJIkae3Me+prSZIkadmYE0uSJOmoMydeTQ5gkCRJa8WpwSRJknTUmRNLkiTpqDMnXl3eQkKSJEmSJEmSJEmSJC3cSg5giIibRMTzI+KjEXEiIi6OiF+JiOvOOk5E3CUiXh0Rl0TE5RHxzoh4TERsNOI/MSJeHhHvj4hRRGREfOke/bpaRDwlIt4TEccj4t8i4vci4ssOsnySJB1NwZBBrw96Hqkr9cGcWJIktZkT62gwJ5YkSW3mxKtq5W4hERG3BC4Abgi8CrgQuCPwaODeEXF2Zn5yFnEi4puB3weOA+cClwD3A54JnA08eFczdwB+lvGMIh8EPg1cZ49+nQ782STe24BnAV88iX3fiLhHZv71XsvXWTH3SY7aX8rRqD0WZjhsl20Nr5LPA3Biq71pbsSoWXZsMGyWDYp6G1Es+Fa7aLhRLHcWZcUOrnU/nmFxn56Tg+nrEeDkVc+ZPu+0aK+vzWgv+Kk4VdRrxzwt25/BZvH5VGUbOf2zq0ZnVX3coCiL9mewWXymg6LeRlFvs/jsKoPG0p8R7e/VZvHlP71YX2cUn81lo2I7KbaFy7L6fNr9rPYNg1G7rG/Vd7+sV2y11fd/VGxDW0VfRsV6Hg2mx8xhu60o9qNVSlfVk9RmTtxDTpzJxonGvrDYf24ca5dlY/8JUKSNzcSlPKR0LCtSeqKoV6QD5Y6+OoeIUfsY0EwVquWuFq6oV/axY71qW8jquF6WFX1p1KvjzaKP3S7kjKqNvcjxuqjOBaqyQZGzlOcXVY7aNbetzo+KmFW9LvHWQXVu3iWrr7bljWI7KfvR+NyK00zpyDAnPnxOPCK4fLRyfyKYqb6nGtf8+Nnt3wbtvPCMQfuablGtzF8rgyLooHHtf96q67bVtdny3KlYX6Mi0avOIY4N2jG7XtdtnQdV16ulPqziDAy/zjiZfFRmPiAzn5CZ92CcHN4GeNos4kTEtYHnAUPgnMz8vsz8UeC2wF8BD4qIh+xq423AXYHrZOYtgXfso1+PY5yUvgK4U2b+eGZ+B/Ag4OrA8yOqy2iSJB1tyfgEoc/HcpwuSVdiTmxOLElSkzmxjghzYnNiSZKazIlX10olOBFxC+BewMXAr+0qfhJwGfDQiLjGDOI8CLgB8LLMfNv2i5l5HPjJyX9/aGegzPyXzHxTZn5mz4Ub9yuAH5z898cyr/jdUWa+CngT8J+Au+0nniRJktaPObE5sSRJ0lFnTmxOLEmS1tdKDWAA7jF5Pm9n0gaQmZcCb2Y8+vTOM4izXee1U+K9EbgcuMtkaq+ubgl8CfDezPzglPLX7OqLJEmaYkj0+pCWjDnxlfsiSZKmMCfWmjMnvnJfJEnSFObEq2nVbnB1m8nzexvl72M8YvbWwOt6jtOsk5lbEfFB4MuBWwDvLtqu7KdfTPpVioi3N4rOOminJElaJQkMyxvHd4spLRFz4jFzYkmSGsyJdQSYE4+ZE0uS1GBOvLpWbQaGMyfPn26Ub79+nRnE6avtyjzakCRJ0mozJz58G5IkSVpt5sSHb0OSJGkprdoMDHvZnrvjsANgusTpq+1e2sjM208NMB5xe7tOrVetZnvalNGoPU7m5NbG1NePbQybdU4M25vtscGoWTaI9gJsFGWzMCqmmTk1mL5OhsV4o1PZXienBu2yzdhqlp0Rp9oxo1vMzWh/rqdlu6yqt9HYMKvPezPb20m1LWxmt21oUGxe0z/t7Zjt5a5Gn200tq9BtLe7Vp29yk6Pdk8Gxfdxo/q8q8+n2BENOtZbFtV3fFTtY4sRpMeivU5Ggyrm9Hpb1eddfQeKsuqTiUa9YlPefgej3sdoOj2YVoo58fYbipw4RtxucLK9n2zG3GjvDwYbxf6uOOiPGjEHRRKRxX682F3XZe3Dc5lHjIp+VjGrXXWOprdXHNqqUxIYFZtLsS6zyP+yPAcqtpNqudtFnZSncFX/i+Ne17yklV8A5WG26suw6Muxng/dG8XGV56vdKw3KOp1zW3rmAffH3ZV5YbV9jULgw45Y7WdV+dw1XSzVS/a7e21HZgT68gzJ95+Q5ETj4jbXZabvXZsFVTXYHRV1bFP66fKWarcttpOqr81bFQXz6sUdQabZevc43Taf/OoVOcrnc+5Bu18szoPbV1nhT2u3TbKutQZl1XrZBbMiVfVqh15tkeWntkov/au9/UZp6+2++6XJEmSjhZz4sO3IUmSpNVmTnz4NiRJkpbSqg1geM/kuXVvr1tNnlv3BjtMnGadiDgG3BzYAj6wR9t990uSJO2QjEeL9/lY/jk8dMSYE1+1X5IkaQdzYh0B5sRX7ZckSdrBnHh1rdoAhjdMnu8VceXJTyPiWsDZwOeAt8wgzusnz/eeEu+uwNWBCzLzxF4LUbgI+BBw64i4+ZTyb9zVF0mStEsCwxz0+jAx1ZIxJ75yXyRJ0i7mxDoCzImv3BdJkrSLOfHqWqkBDJl5EXAecDPgkbuKnwJcA3hxZl4GEBGbEXFWRNzyMHEmXgF8AnhIRNxh+8WIOAP42cl/f6Pzwo37lcBzJ//93zuT5oj4ZuC/Au8C/uIw7UiSJGl1mRObE0uSJB115sTmxJIkaX0dW3QHOvhh4ALg2RFxT+DdwJ2AuzOeMuuJO95740n5PzNOQrvGITM/ExHfzzhBPT8iXgZcAtwfuM3k9XN3dzYiXrjjv2dNnn8xIi6d/Ps3M/Mvd7znGcA3AQ8C/joiXgd8CfBg4HLgezNz1Fg3kiSJYET0HlNaMubE5sSSJBXMiXUkmBObE0uSVDAnXlUrN4AhMy+ajGx9KuNpuu4DfAx4NvCUzLxkVnEy85URcTfGSeu3AmcA7wceBzx7MjJ2t++e8tq37Pj3+cDnE9PMPBERXwc8AfgO4LHAZ4BXAk/KzHftZ/kkSZK0vsyJzYklSZKOOnNic2JJkrSeVm4AA0Bmfhh4+D7edzHFUJj9xtlV582Mk9j9vv/AQ3Ey83PAkyaP+apu3lKUVWN9h8P2KhhuTL+LycmtjWadjWh35MSgvUkPinrzNio2i2FOXyejxusApwbt9XUq22WbMWyWHY/NZtlpRb0zBqeK9rbaZbRjbkR7A2stw0axUVbLvTH1/HK7XjtmVa+6K1K1Pdcx21oxB8VXoL2V1Dai22jDM4p65foanGyXjap68/tBQvVdHQ2KsmLk5taoXW9r0N6et6q+FPuhrca2fqxYj619F9T732HRj3a9en+ewLDnu2QtzxFEuoI58SFlEqem70OrPchgs126cbK9t8iNYn/XOBAXaRxFOlOXFQtXHdaL3TwUh9mqvRy1G4zGcb38jWHVx2ITnP73hYmij1kkV2XI4rg+KGO2+9I6rkeHOrNStTeLvrRysrKtGaySQXEOUZWV5yzFl67Ku6p6zTpFH2ei42dQ5aKV6jy0lU+OOqxHgEGxk6rOITYa28Jeq8qcWEeFOfHhjHLAZaPTZxH6wEardbfrhRr669+5qPKLuedIHXXNkeapWpfV3xrKlKzjYjfXVxGvPM8ZVOdA7aDD4npvfQ25+HtCcZ5QlY0aZbPYC0XRj+rctmJOvLpWcgCDJElSU87gBK3nzDQi/ivwGOAuwPUYTzf6D8CvZOar+21NkiRJR86S5sQR8QXAA4H7Al/JeFr/k4xz4RcAL3BKfEmSJPViSXNi7c0BDJIkSXMUET8J/AzwCeCPGU9Nen3gq4FzAAcwSJIkaV09GPgNxjnwG4APAV/IeBr93wS+MSIe3Jh+X5IkSdIR4AAGSZK0VpLoferJ7GlitIh4MOPBC38OfEtmXrqrvH3/HkmSJGmfljgnfi9wf+BPds60EBE/AbwV+FbGgxl+v4/GJEmSdHQtcU6sPSz/DXAkSZLWQEQMgF8ELge+Y/fgBYDMLG7uJ0mSJK22zHx9Zv7R7ttEZObHgedO/nvO3DsmSZIkaWk4A4MkSVo7w1zKkbB3AW4OvAL4VETcF/gK4Djw1sz8q0V2TpIkSetlSXPiyvZg3q2F9kKSJElrYwVzYuEABkmSpP06KyLePq0gM2+/j/pfM3n+V+Bvga/cWRgRbwQelJn/fqheSpIkSbNz2Jx4qog4Bjxs8t/Xdo0jSZIkafU5gEFXEsVIpKzKRlVZ+04lo9Fo6utbw41mna2N6XUAThX1BmSzrDKIbvUqw+LuLa2yUXFfnVPZXu5Tg3bZZgw7lZ0R7RnOTxZ9Oa1jexvR/sw3Y/oPMzbpFm+j2E4GZb2qj0Vfst1e1ZdKa5stl60o2yi+A1X/u96jaKMYEFnFvPqg/SOdQdHPvg2z+n63F66qV32Py/1Jsd+uyo41+rJVba/F92Mr2n2cxfjXpF4vXWP24IaT5x8EPgh8HfDXwE2BXwa+AXg5TpkrzUdCnGrvu1oGp4rc9lh7rxbD4pjZSBVyq8ixN9rxclj0o9g9lmXtdIbBoN3eaNDuZ3HooJVaVecdVMf7sq0q+SjWc1UvqvOqImbX87Gef1EyKuKVZR2P7FW9KmcZFflTvYE12iryh+r8outyVzqfXxTLPShitnL+qh/zVn4+xTrp+ourjUZ7XfPM6pxrVKzndnt1hrrEOXHLLzCenezVmfmns21K0rYhwaWjqy26G0ulunbT9Vpd1/Y0e2U+qaVWXbM+rZjMaVScq9G6BFucDw8HxTWCIg/dal0I2KtesR86VsWszrmKv+G1VH83ixn8Ta2rFcyJNeEABkmStGZiBiegAXDhYX5VxhWnQcF4poV3TP7/TxHxQOC9wN0i4mu9nYQkSZIOZ2lz4qtGjXgU8HjgQuChfcaWJEnSUTaznFgz5vAySZKk+fjU5PkDOwYvAJCZnwO2f2l2x7n2SpIkSVqQiHgk8CzgXcDdM/OSBXdJkiRJ0oI5A4MkSVorSzw12Hsmz//RKN8e4OD8nZIkSTqUJc6JPy8iHgM8E/hH4J6Z+W89NyFJkqQjbBVyYk3nDAySJEnz8UZgC7hVRJw2pfwrJs8Xz61HkiRJ0gJExI8zHrzw94xnXnDwgiRJkiTAGRgkSdIaGuby3YssMz8REecC3wn8NPCT22UR8fXANwCfBl67mB5KkiRpnSxjTgwQET8FPBV4O3AvbxshSZKkWVnWnFg1BzBIkqS1kgSj3qcG6y3RfRxwJ+CJEXFX4K3ATYEHAkPg+zPzP/pqTJIkSUfTsubEEfHdjAcvDIE3AY+KuErcizPzhYduTJIkSUfasubE2psDGLR/xY1dctT+wmYxumk4nL7j2NgYNeucatQB2Bi0yyI22mXD9sIN2GyWVapRXacP2n3ZapRtFct2+mCrWXYq222dHu16m0XMUbT7slms5+PRXs+nVX2JYbNso/H5lHWivX0NaJdV9Tbp1l5lo/jSDYqYGzm9rHu8dr0qZmVQbAtVe11V/bxGnJpe0DGvGWW7YnW/rape9T2uyraK7+PJ4jNofT6DchvqvyyKslWVmf8WEXdiPPvCA4E7A5cCfwL8fGa+ZZH9k46UTOJU+/jdEqeKPGKzvS8fbLX3aaNj0/PGIp3pXtY+NFClLFVZI/UYq2JW5xeNsvLQUJ2TVMf1IveoznNiUNQrzgXqsmYRo6LeqFGvaquO163/XWPOwqhxUanKx44VG+yw2Iiqc495q85nTiv62VqGrucyXZXruTjnGhYXETeLTa/O3ad/sarPu7oOsFFse9V22crBV/iy6c0nzxvAYxrv+QvghfPojHTUjRhw2WjaHQ41Td9/BJu36jhbmXc+0Leuy70qqjyii43qJG4NVNciW/nmGYPG9WPa5x1QnwNVn1uVUx4rtuetoqy6rrsxKK5zNGJWZ0Ddr/eucIar3jmAQZIkrZ1lPjmdTJH7uMlDkiRJmollzIkz88nAkxfcDUmSJB0Ry5gTa29+apIkSZIkSZIkSZIkaeGcgUGSJK2VpJ6+rWtMSZIkaVWYE0uSJOmoMydeXQ5gkCRJ6yWj/6nB5nzfbkmSJOlQzIklSZJ01JkTryxvISFJkiRJkiRJkiRJkhbOGRgkSdJaSWDY8xhNpwaTJEnSKjEnliRJ0lFnTry6HMCgK6u+eWVZe8qUHBXVRtPrDYftHcpWbDTLTg3anawmdRlE/7uc0Ua7xVExZc2osS6r+/ScyvY6OT23mmXDQbsfm0XMU9HedWwO2u1txrBZdoLNot7BY25Ee8Mb0C7bKLaFjaLeoGjvtGK5K3U/i7LGl7XveHup1slGtWMoVH2p2uu7rTPiVLPsWhufa5ZVyVLruw/1d7xr2bFRe30da6zLY4P2trxV7Neqfews9r+StB+RSZxq5BjFuW0M23lQbBX7uw5lxW6c0bB93BgM221lUa9Is6l219UhOBr5PkCOity9Ua+q0/lcpuhjtS1kdQ5UNJjVIpQxD16vyi+6xIPu9w+tz4HaG1HXeu061XlasWxFUTUladV/ivOEKm/cpNv5RaV1PlCdi3U9T6gMo9v21XVa2FG067ViDouNYaP43IbVuUx1rtaIaR4tqQ+jDC4fnd5rzL7/UKSDKXMPraUqN+liFjnequiyLqu/eWwW11I3s7jOWpycbxUn4F3LBkVO3Mo5q1x02PEWC2F+qx0cwCBJktZO+QcISZIk6QgwJ5YkSdJRZ068mhyOJ0mSJEmSJEmSJEmSFs4ZGCRJ0lpJYgb3NnOkriRJklaHObEkSZKOOnPi1eUABkmStHa856MkSZKOOnNiSZIkHXXmxKvJT02SJEmSJEmSJEmSJC2cMzBIkqS1ksCw56m8stdokiRJ0myZE0uSJOmoMydeXQ5g0P5l8SXP9lc2i3qtstGoXWdUxNsaticVGUSxW9kqvgodvyWjYqdYLUOrrIp3LDaKeO11cirb9TZj2K0s2yusqjcodvubg60Dx9wo4g1idOB445jtehtFzONlvXY/q/aqZWjHK9rqEA9g0HGdVMrPrmivjNnz+qqSnk3a29A1BieaZdX38Xie6lTvxKj4Pg7a/dxq7DdOjtptVfvY6vtdacX0LmOSejOcvi+MrSKn3GofU3LYLhtVeepw+v5uNGzv8YrdOFkc9qpD4tzLisNDaxnqOt3OV8rDVOeyqi8HPz86TNk8Vec58z6ADxt9OVb0o8t5GtB52cqpTIvzkuoerhvlRJvFjqODrucCVZ5dqXLwrve1HRX1hjG9vVPFOe+w47lM9bm1YoaXTiX1YMSAS0dnLLoba8/py7Uuhku0LXe99lzpe/nKv3kU+f6p4oT/WNHHrmVbxflyaxmiODmvTo+qa8h9DzTQanMAgyRJWjMxg4sDJtCSJElaJebEkiRJOurMiVfV8gyXkiRJ6sH21GB9Pvx9myRJklaJObEkSZKOumXPiSPiJhHx/Ij4aESciIiLI+JXIuK6s4oTEbeKiB+PiNdHxIcj4mRE/GtEvCoi7t7f0h2OMzBIkiRJkiRJkiRJkjQHEXFL4ALghsCrgAuBOwKPBu4dEWdn5idnEOdngG8D3gW8GrgEuA1wf+D+EfHozHx2P0vZnQMYJEnS2vH+kpIkSTrqzIklSZJ01C1xTvzrjAcdPCozn7P9YkQ8A3gs8DTgB2cQ57XAL2bm3+0MEhF3A/4M+KWIeHlmfqzTUvVkaT81SZIkSZIkSZIkSZLWRUTcArgXcDHwa7uKnwRcBjw0Iq7Rd5zMfOHuwQuT1/8COB84DbjL/pdmNpyBQZIkrZXMYNjzyNrM6DWeJEmSNEvmxJIkSTrqZpgTnxURb59enrffR5h7TJ7Py8zRrvqXRsSbGQ9MuDPwujnE2XZq8ry1j/fOlAMYdGU5g3qj9glu6+R3VNQZDts7m4h2R2JYlBX1Tg03mmWzMGqtE9rr5FiMmmWteADHih33VrSX+9Rg2CzbzHbZoFjPm1HFbPdlo7Hsg2Kj3By0970bRb1BsZ6712uXVeurqtdaJ5VBEa+yUfSxrFcud8e+dNyBtbehbv3o6ow41Sy7+uBks+xU8f04fbDZLDsxaqcAg0Z6UG2T1Xeu3Dd33Ib2Uu0zJQmATGJrev6Rg+Lkdqt9fIitYn9X1WvkmzEq4hWHqRi294FlzKIeVUpc7crL84R2USsVzeI8IbJorDonqa5lVDGLPDuL9ZxRnR9VXWnXa+X8XerMrKw4Ns8i5rKoLpZV50DlNKdFva5a/dzsuIqr3Hwzup2PVYbF92pYTD5areeTjTy7Ogeq+nEq2/n3sDqfbOws9/PRrMJ3RNJijTK4fHj6oruxFtznal30/cfeddDlejt0X5fVeUL1d5uT1bXbnq/rVvGWzZLun28zeX5vo/x9jAce3Jp64EFfcYiImwL3BC4H3li9dx4cwCBJkiRJkiRJkiRJ0t4u3OdMCy1nTp4/3Sjffv0684gTEacDvwOcDvxYZn5qj3ZnzgEMkiRprST9jxZfnTHFkiRJkjmxJEmStMI58fa0EYdtbs84EbEB/DZwNnAu8PRDttkL54KRJEmSJEmSJEmSJGn2tmdGOLNRfu1d75tJnMnghZcADwZ+D/iuzOrmlvPjDAySJGnNRHm/7K4xJUmSpNVhTixJkqSjbmlz4vdMnm/dKL/V5Pm9s4oTEceAlzIevPBS4GGZOdyjvblxBgZJkiRJkiRJkiRJkmbvDZPne0XElf5WHxHXYnw7h88Bb5lFnIg4DXgF48ELLwYeukyDF8ABDJIkac0kMGTQ62Mp5s2SJEmS9smcWJIkSUfdsubEmXkRcB5wM+CRu4qfAlwDeHFmXgYQEZsRcVZE3PIwcSaxTgf+APhm4LeAh2fmqIfF6pW3kND+Vd/KYgqW6nYpra9ERntszWjUjjcatettNUtgsESzII4anRlle9mODdoDo6rpcY4VMU9Gez2flu21eTLau5Vj0e7niaLeZlFv0OhnVWcj221Vh5+NaO/DO9cryjaKmF3rdYlX2aBbvdbnNqv26s+u32PzRsdlK2MWfay29ars9EH7e3xiMP07cmzUbVvu6jC75v6nBpO0dhLYmr6fjEE7R4phMSB91M4xqt1kDKcfO2LU3pcVu/i6rWp3XRzCyphd6xXLl42cvzhNoLxLY9eyso9FveIEI4sGszyvajfXKipOncq2quNoVVbFnLfW+VN1XlV+saq2OmYtw6LeZtVetZ6LomHxG5ZNpi/7sFhfVa7ZVXkeV3x3qnVZlY2KddLKb6tt6GRuNMuq84STFPUafYx9nPeZE0vay4jg8tFpi+5GZ133c9V1KfedWkZ9b+tu56urugZ7rGNZFbPLdfyu1/5nZYm39x8GLgCeHRH3BN4N3Am4O+NbPjxxx3tvPCn/Z8aDFbrGAXgucB/gE8BHgJ+OuMo6Oj8zz+++aIfnAAZJkiRJkiRJkiRJkuYgMy+KiDsATwXuzXhQwceAZwNPycxLZhTn5pPn6wM/XYQ+f5+LMhMOYJAkSWslifLXdF1jSpIkSavCnFiSJElH3bLnxJn5YeDh+3jfxRTz7e03zuS95+yzewvV76cmSZIkSZIkSZIkSZLUgTMwSJKktTNc3nubSZIkSXNhTixJkqSjzpx4NTmAQZIkrZVMGPWcmGb2Gk6SJEmaKXNiSZIkHXXmxKvLW0hIkiRJkiRJkiRJkqSFcwYGXVk1cqhzWXt0UzbKqhFMo1E73nDYHpMT0Q66VdTrqhrVNdooliFH0+sMhu14FG0V/TiW7eU+FtP7AXBqtNEs2yz6OSh2OceKeiejqBfT650o6mzQXrZBsZ1UZV1jbhTreVB+sdpaMat4VT8qg471Njou27zb66J7H/tftjMGp5plJ0bt78hmaxuqtteO352q7DBGxf5NksYSho38o8opt4p9YVGWw3bZaDS9vcGwvY+scuLqUNRInfauN4uy4hDQKqvOE6q2yl9IzL2sOj8qqnX41UhVp+9foeylPD+qyopznWoq0GNHdJbQYZEDbVY7gBVQ5Y2bHXPpU8XvejaZvr5O0T4frvLlKj8dFP1vtRf7OMcxJ5a0l2EOuGzr9Lm11+Waifuy1VXlcbPQ9Vpqy7z7L81S39d1Z3VNdxY8jqwmPzVJkiRJkiRJkiRJkrRwzsAgSZLWShIMex4ln466lyRJ0goxJ5YkSdJRZ068uhzAIEmS1s68p8WWJEmSlo05sSRJko46c+LV5C0kJEmSJEmSJEmSJEnSwjkDgyRJWjujdIymJEmSjjZzYkmSJB115sSryU9NkiRpQSLioRGRk8cjFt0fSZIkSZIkSZIWyRkY1I/sWDaafu+ZHLQr5ag97mYUo2bZcDjf8To5aPelrNe4H091n57hqN3W1qC93MeyXe9YDJtlg2h/PlvFaLZBsTEcK+ptFO0NGruxqo+DYjup2+oWs+rLBt3qVWVd2qp0aQtgo1on5Y6hW8y+LVMfq+2re8yDb8/l96Pn7fUwEhjR773NZrEEEfHFwHOAzwLXnEETkiqZ5Nb0fCc2Ntr1hsU+ucjJGLb3JDGaXhbD9r6sVWdc1u4GRU5ZxazqlSlGeS5w8LLqkJLlOUmx3J1jdltf2bnewcuqOpV6sdsxq+Pvstx3tOrjsPiNR1W2SfvcqWtOMizqbXaK2L9R+ZuY9jqpdF3uKnevctjNYod5qnGOulGdFxY7tlMUx5ZKo7m9tqxVyYklLVZm8LnhshxZNGvVcaHrdbC+jzWS5m+Zruv2zZx4dTkDgyRJ0pxFRAAvAD4JPHfB3ZEkSZIkSZIkaSk4A4MkSVozwbD3X3n2/ouCRwH3AM6ZPEuSJEk9WomcWJIkSZohc+JV5QAGSZK0VjJhVNyWpmvMvkTElwG/ADwrM98YEQ5gkCRJUq+WPSeWJEmSZs2ceHU5gEGSJGl/zoqIt08ryMzb7ydARBwDfhv4EPATPfZNkiRJkiRJkqSV5wAGSZK0dka9Tw3Wm58Gvhr4L5n5uUV3RpIkSetriXNiSZIkaS7MiVeTAxi0b1F8ycspU0btombIUdFWsa/Jot4oqp1Uv1PIAIyKdVLtMFv349kYtfs4HLRX8ka2y4ajdtnWoN3eINoLd6yIOYiibLTRqb1W2YCD1xmXFeuyqtexvcos+tKlra7936i+/GVf+l+XXcyi/11tFJ/PLGzGcOrrXbatNXPhfmdamCYi7sh41oVfzsy/6q9bkjpJYDR9f8ew8TpAkevEVlFWJIcxnF5W1iny3uqwMZOy4vDQd1l53lHk2FFUXJXpH6t+ZocLMl3qzEo1peeoOJ+pY85v+YZF/1t5FewxlWlRbxaGjfu4bs61F7OxUeSwm8Vmssn0z+BUsUPcLD7T40U/qj62ztVijudGktbXiOBzw+l7+1Fxj2+vDyxW9dlo8WaRh/Z9vbFrH7v2Y97tVbr0ZZ7XpFeFxwHNmgMYJEnSWkn6P5k/bEq+49YR7wV+6vA9kiRJktqWMSeWJEmS5smceHU5gEGSJK2ZmMFo90PHuyZw68m/j8f0WYGeFxHPA56VmY85bIOSJEk6ypYyJ5YkSZLmyJx4VfU/b/4cRMRNIuL5EfHRiDgRERdHxK9ExHVnHSci7hIRr46ISyLi8oh4Z0Q8JiKa899HxHdHxFsj4rMR8emIOD8ivql4/1dGxO9ExPsj4nMR8ZGIeENEfFtErORnJknSEXcC+K3G4+8m7/nLyf+9vYT2xZxYkiRJR505sSRJ0vpZuRkYIuKWwAXADYFXARcCdwQeDdw7Is7OzE/OIk5EfDPw+8Bx4FzgEuB+wDOBs4EHT2nn6cDjgX8BngecBjwE+KOI+JHM/NVd778f8P+AEfCHwCuA6wMPBF4GfB3w/XstnyRJR1l5T+kFyMzPAY+YVhYRTwa+GnhRZv7mPPul1WVObE4sSdJeli0nlvpmTmxOLEnSXsyJV9Mqfmq/zjiZfFRmPiAzn5CZ92CcHN4GeNos4kTEtRknlkPgnMz8vsz8UeC2jH8p+aCIeMiuOndhnJReBPznzHxsZj4SuD3jpPbpEXGzXf36BcYDS+6VmQ+e9OsRwJcD/wY8IiK+ZJ/LKEmSpPVkTmxOLEnSyurrV/M68syJzYklSdIaWqkBDBFxC+BewMXAr+0qfhJwGfDQiLjGDOI8CLgB8LLMfNv2i5l5HPjJyX9/aFesH5w8Py0zP7Wjzna7pwMP31XnFsBnMvMvdr6YmR8H/nry3xtUyydJ0lGWwCij10cueqGkHcyJzYklSdrLMufEk1+7v53x8f+tjP9I/AHGv3b/q4j4gp6a0hozJzYnliRpL8ucE6u2areQuMfk+bzMHO0syMxLI+LNjBPOOwOv6znOdp3XTon3RuBy4C4RcXpmnthHndcAPzV5z5N2vP5PwO0j4r9k5l9uvxgRN2Q8ddlHgXcVy3Y4GUVZ8bWsvrFdykbtfmS0A446jsnJatnKeu1+bhRluza7fcXMQVGnWQJbo/Y6GRYxN4o+DorP4FTRmyjqHSv6UrU3aLQ3iI7xirJKlz4eKmaxfBsdlqHqY9d1UrbXc/+h+3ru1FbR/7refNObDbr181ROv13nLL47lcNEHFEcz5ZMZj4ZePKCu6HVYk7cV048mr6nyVF7/xnDIicbFnlQo62yrNiNl7vdoqw8hHWs1zVmXdbYjxd5e7VOynS/7z5Sn1/U/ex2/Go1N+oYr6rXNWbZXsfjdjkVaId8rfNyzzntGBbnvZsMe22rPsdutzUsVspm177M+TM4oxFzs9gxnOi4/jeqnU2jaD/nP0ucE+/8tftztl+MiGcAj2X8a/cfbNSVtpkT95ATjzK4fOu0w4SQlt4SHw91CFUutCyfedfr1cvSf+h2/tf1OnF1PnxUrhPrCis1AwPjKbsA3tsof9/k+dYziNOsk5lbwAcZDwi5BcBkVO6Ngc9m5scO0NfHAp8B/jwizo2In4+I5zFOWC8FHjC5j3YpIt4+7QGctVddSZIkLTVzYnNiSZJWUl+/mpcwJzYnliRJa2vVZmA4c/L86Ub59uvXmUGcg9bp1NfMfFNEfC3we8B/21F0KfAC4B8a8SRJEuPRun3/OrTrL2KlGTEnNieWJKm0xDlxX7+al8yJzYklSSotcU6sPazaAIa9bG81h53Hukucrm1f6f0R8fXAy4C3AQ8DLgRuBPwPxlPo3Tci7jYZzdsOmnn7qZ0cj6693QH7KEmSpNVhTrwd1JxYkqS+nTU5jl5F67i7y35+7X4vxr9EdwCDDsOceDuoObEkSVoxqzaAYXs06pmN8mvvel+fcQ5aZ6/3X2XkbURcDziX8X3SHpiZl0+KPgA8LiJuDjwA+C7ghY24kiQdebO4P7e0RMyJzYklSdrTkubEff1qXjInNieWJGlPS5oTaw+DRXfggN4zeW7du+xWk+fWKO7DxGnWiYhjwM2BLcZJJJl5GfAR4JoR8UX7bOMuwHWBv96RlO70hsnzfka0S5IkaT2ZE4+ZE0uSNH8XZubtpz16it/Xr+a1/syJx8yJJUnS2lm1AQzbidm9IuJKfY+IawFnA58D3jKDOK+fPN97Sry7AlcHLsjME/us84273gNw+uT5Bo1+b79+slEuSZIYj6zt8yEtGXPiMXNiSZIKS5oT9/WrecmceMycWJKkwpLmxNrDSt1CIjMviojzGN8L75HAc3YUPwW4BvB/JqNaiYhN4JbAqcy8qGuciVcAvwg8JCKek5lvm7RxBvCzk/f8xq4uPxd4KPDEiHhlZn5qUudmk3ZPAC/Y8f6/Yjw69+yIuFdmnrddEBFfDPz3yX9X6x6A1Zj5RlmOip1AVDuIdmOjot5g1I44LMb5ZLbbK4rKndxwNL3ixqBdZ2PQ7uNGsXDDoh8bo3bMQbQXriqLouxUY7kBjkXxATVUy131sVIud7HtDTr0f6/2utTrHK/jD1+697/b+qpsdOxLy7zXybJYlQQt6b+vq/3Jad2YE/eUE2fCcDi9bFiM8x61j1NRJIAxLMoaeVB12GjVGZe194F1zHZZl5z+MO216lXxqvy7a/9LZcz2Z5BVWRG0qtdFsQkdIma7j12PzX0f06tzoGMzSHWG2d6fbEZjHwSMinoU9eq+tBdwczXSvLnaaFxD2KjqVOeFtD+34x12RLFHnSXOifv61byOOHPifnLiUQbHhyv1JwKtkL7zV6ivL3dpr4pXmcWySatkRP/nfpXmd26PtpY4J9YeVjE7+WHgAuDZEXFP4N3AnYC7Mz65eeKO9954Uv7PwM0OEYfM/ExEfD/jBPX8iHgZcAlwf+A2k9fP3VXngoh4BvA44J0R8QrgNODbgOsBP5KZF+94/0cj4mcYJ8eviYg/Bi4EbgR8C3BN4A8y89UHWF+SJElaP+bE5sSSJK2iK/3aPTM/P5ztgL+al8Cc2JxYkiStpVW7hQSTEbJ3AF7IOJF8POPRs88GvjYzPzmrOJn5SuBuwBuBbwV+BDjFOPF8SE75OX5mPh74HuDjwA8ADwP+CbhfZv7qlPc/FXgAcB7je509Hngg8A+Mk+kH72f5JEk6ykZErw9p2ZgTmxNLkrSXZcyJJ7nHeYz/gPzIXcXbv3Z/8a5fu0tTmRObE0uStJdlzIm1t1WcgYHM/DDw8H2872Job037jbOrzpuB+xywzouAFx3g/a8CXnWQNiRJknS0mBNLkqQVdaBfu0sVc2JJkqT1s5IDGCRJklqSmMG9zRxdK0mSpNWxzDlxZl4UEXcAngrcm/EfgD/G+NfuT8nMS3ppSJIkSUfaMufEqjmAQZIkrZek98SUq0z+KUmSJC2xJc+Ju/zaXZIkSTqQJc+J1TZYdAckSZIkSZIkSZIkSZKcgUH7V40qKsuK0U2jxuvRDpijIl41kKrVFjAqhvIMqnpFc/X4oHbNjOkLUa7ibJeOioqDYn0Ni89gUJRF13rtrnCqQ8woFrzqR1lWfArVcle69qXvtsp6HYcUDqL+hrTrzXcI47Ks52XS5TPvOpK1qtcq20/veh9ZK2ntJEkOh1PLIovTpCLvYlQljgdPKqt8psqxq0NR95jd6pUJc5fzi47nJNU6yar/1XJ3NYuQhzhmHiQeLNcxtswjnNZz5obFOt4s67XPlTeZvl9eJtWZ/mZ0uw6w19WFg/bj81GX6PsqaTklcGLonwjUXZlLF6prqV1jdmlrHfS9vqTD6nK9F2a3LZsTryZnYJAkSZIkSZIkSZIkSQvn8EpJkrRWkv5H1q73WH1JkiStG3NiSZIkHXXmxKvLAQySJGntOH2eJEmSjjpzYkmSJB115sSryVtISJIkSZIkSZIkSZKkhXMGBkmStGaCEX2PrHWkriRJklaJObEkSZKOOnPiVeUMDJIkSZIkSZIkSZIkaeGcgUG9iOIeMkm2K7aKRsUIpmpw0+jgTe1lVAzzGRTtDavFznbQaCxfFvGq1TUoPptqVQ6i3WAUZRuDbvUqXfpS1unYVqVrvWqdzLsvzXgdvz1dP++uel/uOfd/Fua5LVQjWbeKHWl1D7Ku9ydLYNTzvc1Wf2uQNFUrwRoO23WGRQI4qhK2dlG06hXxouhiMx5AlRtWO7uirKrX+VDUqle1VYXr2I/yPKcK2nm5q/Y6xmzGa7fV93F0r/ZWXbm+iqJhcV64WX3JC8PidyqbnSIeXcPGl27QOmnfo+yM8jdExUGiURZ77GjMiSXtR2Zwcrix6G6ooct+fBbXs7oeT7r2ZRa5qHQUzOKcq8s1/q7Xe6vvvteJjx5nYJAkSZIkSZIkSZIkSQvnDAySJGm95AxGHDu0VpIkSavEnFiSJElHnTnxynIAgyRJWjtONyhJkqSjzpxYkiRJR5058WryFhKSJEmSJEmSJEmSJGnhnIFBkiStlaT/qcGcGUySJEmrxJxYkiRJR5058epyBgZJkiRJkiRJkiRJkuYkIm4SEc+PiI9GxImIuDgifiUirjurOBGxGRGPjogXRMTfR8TJiMiIeER/S3Z4zsCg2SuHIzVGPmVRaVQ0VQykiiJkjrqNwBpFu14UDY6q5WvUy2yPNyq6wahYtqqPVczBoP0hDIvPZ1B9CIW6n9PLBh0H1VVtVWaxbF3b6/uOTl2XrWu9Stf11bdZLNu8LcsyVPcgG46m7/f2HjUbM7i3mfdKk9ZOAqNG4jKqEscqT20nQlHVa5RFkVfV8Yr8r9r9HzxF3bNepYrZKitz+rKP1TppVywXrTrWdPx8yhaLeq1jY9+/NNlLefytzlmKevO8X+moOOfqumxH1bBYl5sx7L290Qp8CJvR9TdE0w8Ge5/zmhNL2tsog5Nb/olgkapTjy66XhPtux+SavM+V5un6hp+tdzVbqj1d669d13LmxNHxC2BC4AbAq8CLgTuCDwauHdEnJ2Zn5xBnGsAvzL5978CHwe+uI9l6pMzMEiSpLWT2e9DkiRJWjXmxJIkSTrqljgn/nXGgw4elZkPyMwnZOY9gGcCtwGeNqM4lwP3Af6/zLwR8PwelqV3DmCQJEmSJEmSJEmSJGnGIuIWwL2Ai4Ff21X8JOAy4KERcY2+42Tmycx8TWZ+7DDLMGsOYJAkSWslGU8j3OfDH5xJkiRplZgTS5Ik6ahb4pz4HpPn8zLzSveMy8xLgTcDVwfuPKc4S8cBDJIkSZIkSZIkSZIk7e2siHj7tMc+699m8vzeRvn7Js+3nlOcpXNs0R2QJEnqVUJm9B5TkiRJWhnmxJIkSTrqljcnPnPy/OlG+fbr15lTnKXjAAZJkrR2Rn0nppIkSdKKMSeWJEnSUTejnPjCzLz9LAJPbHf6sMMl+oozdw5g0JVEsQln1827qtfab1R1qp3NqF1UdqMIWS52scKyCBpVg62Y1QdQ9KNqK8p67eZGo24xK+Uq6RCzcz+KskHnZev/2FDFHDQWYhb96LpOuprFMnTRdbmrZGkW63IVLlcOi3UyLPY1knR4SQ4byWORd8WoSjiLfXlRL0bT60UVr1tquFT1Sq161blA1xOWWfS/o87nXJ3a6nacXY5sbGxUZDutHGOUxZ00o/h+d1T1sXPMchmG/cbsGG9jButy1Q2Ku7ieHtUdXremvhorke1LWnYJnNzaWHQ31t4886fq6LBMeZwOpmvuvizXUo+q3n/5v4eun3eXfs5i2xqN2jnxvNflHGzPjHBmo/zau9436zhLxwEMkiRp7czzD0CSJEnSMjInliRJ0lG3pDnxeybPt26U32ry/N45xVk61RBvSZIkSZIkSZIkSZLUjzdMnu8VceXp2CLiWsDZwOeAt8wpztJxAIMkSVoryXhasV4fi14oSZIk6QDMiSVJknTULWtOnJkXAecBNwMeuav4KcA1gBdn5mUAEbEZEWdFxC0PE2eVeAsJSZIkSZIkSZIkSZLm44eBC4BnR8Q9gXcDdwLuzviWD0/c8d4bT8r/mfFgha5xAIiIJwBnTf5728nzwyPiv0z+/ZeZ+ZuHWLZDcwCDJElaM+PRsH3HPHSEiC8AHgjcF/hKxonnSeAfgBcAL8jM0aEbkiRJkpY0J5YkSZLmZ3lz4sy8KCLuADwVuDdwH+BjwLOBp2TmJTOMc2/gbrteu8vksc0BDJIkSb1JGPWdmPYzX+6Dgd9gnEC+AfgQ8IXAtzBOCL8xIh6cmc7OK0mSpMNZ3pxYkiRJmo8lz4kz88PAw/fxvospRk7sN86O95+z3/cuigMY1I/iCxvFaKT232iKHcqo2jsU9YpqOShCls0V7UW7YrW/jEZfRh3bqnbNUdQrVe11PBZUfSkXvesy9BxvFsvdVZeYVfcHM+hjV7NYX13a6n/U5nyXbRYGHVdJtUsfjqbvEFd4Tb0XuD/wJztnWoiInwDeCnwr48EMv7+Y7klHTAKtSU9G7clQsiiLYqfWaX6VaofXsaw83HStV+jaXqtsFv0oQ3Y96BS5QjVObVl+2zyLXEfaj1F1ch7rO1HVZmw0y0ZMX26/pZL6kBlsDasLo/23twy6XoNZlv7r6Ol721v165Crwn1Gf4bD6evSn4Gtr/llJ5IkSXOS2e+jnz7l6zPzj3bfJiIzPw48d/Lfc/ppTZIkSUfdMubEkiRJ0jyZE68mBzBIkiQt3qnJ89ZCeyFJkiRJkiRJ0gJ5CwlJkrRWkv6naJsMrj0rIt4+tTzz9l1jR8Qx4GGT/762axxJkiRp2wxzYkmSJGklmBOvLgcwSJKktbNi95j7BeArgFdn5p8uujOSJElaDyuWE0uSJEm9MydeTQ5gkCRJ2p8LDzPTwjQR8Sjg8cCFwEP7jC1JkiRJkiRJ0qpxAIMkSVo7qzCVV0Q8EngW8C7gnpl5yYK7JEmSpDWyCjmxJEmSNEvmxKvJAQzav2qaley2C4jR9Jg5qOIV/RgW1QZFWcfmsopZ1IsOq7Ke5aZdGFEsXNGRqo9UMatqnWrttQz9Hn7K5S7r9X8Y7NqXbm21+z+LZZu3ea7LZbLqn92odYxYg2m/IuIxwDOBf2Q8eOHfFtsj6WjK0fT9ZHTMbbvmxHToR50eFYXFPrTzYaNjvb4PU1W8sqllOlxWy9Dh+DfvY2bV3qjz2cDyGxYnm5vlSaq0t9Njc+rrgzX+Tkman0w4dWpj0d2QBPUfALqePHU5H5j39cRVuM5XnmyuQP/XQPtc0/W/rhzAIEmS1s4yD3KIiB8HfgH4e+DrM/MTi+2RJEmS1tEy58SSJEnSPJgTryYHMEiSpPWS9P9r2p7iRcRPAU8F3g7cy9tGSJIkaSaWOCeWJEmS5sKceGU5gEGSJGkOIuK7GQ9eGAJvAh4VV72/ycWZ+cI5d02SJEmSJEmSpKXgAAZJkrRmYgZTg/US7+aT5w3gMY33/AXwwj4akyRJ0lG2tDmxJEmSNCfmxKtqsOgOSJIkHQWZ+eTMjD0e5yy6n5IkSZIkSZIkLYozMEiSpLWSQPZ8LzJvbSZJkqRVYk4sSZKko86ceHU5gEFXVn3zqllR+v7Gdo1X9XFUFEbR4FXvT36Fqp/F/Cbl4lXtNet07H9Rr2sfo3PMzoWNfhy4yqRi/4efeU8o1PoMqqmSqs+tbszDdV86b7Mz0Hl76Flzm91H9/qfGkzS+knI0fSiUeN1gFG3fWQUZ8yddrvVGXh1zK/amndZodXPzkeoWRzaluNwCfR/QaYymsExdhYxuxgVmfuwOME7RrHPWCKjchLO4dz6MW/D4nPdXJIv8mBGZ43mxJL2lMFouLHoXqhHVV64TNeedDDzzPelpdT6DnideG15CwlJkiRJkiRJkiRJkrRwzsAgSZLWjyNrJUmSdNSZE0uSJOmoMydeSc7AIEmSJEmSJEmSJEmSFs4ZGCRJ0nrJGdwb0HsNSpIkaZWYE0uSJOmoMydeWc7AIEmSJEmSJEmSJEmSFs4ZGCRJ0vpxJKwkSZKOOnNiSZIkHXXmxCvJAQzatyi+5EkUNQ++d4hREa8oyqqTVRfLoFW1aqWUDXbqSpdK9Trpv49lex116WbZi7KP8/zcZiM6fQarv9y9JyJzXrauX8ejKPexf93PeySpJYv5BSNHVcV+y4qmZpBy1aqUsly2jnl2lzody8qUvut6LvtS5O7l8avfD320IsfKUbYnjhxV30f1Ylis/83V2IRKw+JrtSzLtxHTP4PYxwmLObGkPSWMTi35JM1zT3xXXJVrzqK9WXw+Hr80Q73fTqAjrwX3ZB+fpznxalry7ESSJEmSJEmSJEmSJB0FDmCQJEnrJ3t+SJIkSatmzXLiiLhVRPx4RLw+Ij4cEScj4l8j4lURcfdF90+SJElLaM1y4qPCW0hIkiRJkiRJWnY/A3wb8C7g1cAlwG2A+wP3j4hHZ+azF9g/SZIkST1wAIMkSVo73ttMkiRJR90a5sSvBX4xM/9u54sRcTfgz4BfioiXZ+bHFtI7SZIkLZ01zImPBG8hIUmS1kvf04I5PZgkSZJWzRrmxJn5wt2DFyav/wVwPnAacJd590uSJElLag1z4qPCGRi0WD1/0aMaSVUUZXTsSHRrb6669qNz//tfJ+Wn0+mz69iRZflMod6e59eLWtfvlQ6k2g2tLTctSX3JnncoSxIvRt1i1ofuo3jA2YPHo6U2yum/1xhl9QVZHsPiO7c5x35slDuUtmFj/QNsVF+eGLZjLsk6mYVRsU425tiPFXdq8ry10F5IKyYJcquxf513+tfcFa5IHjrPbi5VHroin490GDP4BX/nv0npStJ90NpyAIMkSVozQf8n0CbDkiRJWiUzy4nPioi3TyvNzNv33OC+RMRNgXsClwNvXEQfJEmStIy8TryqHMAgSZIkSZIkaeVExOnA7wCnAz+WmZ9acJckSZIkHZIDGCRJ0vpxFjZJkiQddbPJiS88zEwLEXExcNMDVPmdzPyuRqwN4LeBs4Fzgad37ZckSZLWlNeJV5IDGCRJ0voxMZUkSdJRt5w58UXA8QO8/6PTXpwMXngJ8GDg94DvyszlXGJJkiQtjhniSnIAgyRJkiRJkqSZy8x7HjZGRBwDXsp48MJLgYdl5vCwcSVJkiQth8GiO9BFRNwkIp4fER+NiBMRcXFE/EpEXHfWcSLiLhHx6oi4JCIuj4h3RsRjJiO/W3W+OyLeGhGfjYhPR8T5EfFNe/TtZhHxGxHxgYg4HhGfjIi/jojHH2QZJUk6kjL6fUhLyJxYkiSV1jAnjojTgFcwHrzwYuChDl442syJJUlSaQ1z4qNg5WZgiIhbAhcANwReBVwI3BF4NHDviDg7Mz85izgR8c3A7zOe6u5c4BLgfsAzGd9v78FT2nk68HjgX4DnAacBDwH+KCJ+JDN/dUqdbwD+H+PP548nbV0TuA3wQOCX91q+eYtiCpak+EK3KlZTulRl1b6jqBfRcaczg31VViuzi67LNgsz6coSLV9L35/pylie79U6m8nWteSfQZooSubEs86JR1Vy23HPW9VbgRmvj2w6s0RW4SMYeYyWNEMRcTrj3OA+wG8BP5CZo8X2SotkTtxDTpzA1hx/49glqTS/kLSW3Lf1YhVOlNVJbwMYIuKawF0njy8Brg98Dvg34O+BN2Tmu3po6tcZJ5OPyszn7Gj/GcBjgacBP9h3nIi4NuPEcgick5lvm7z+U8DrgQdFxEMy82U76tyFcVJ6EfA1mfmpyeu/BLwdeHpE/HFmXryjzi0YjyT/JPB1mfnenZ2OiM19LJskSUdW0v/fAs2FtV/mxObEkiQtgzXNiZ/LePDCJ4CPAD895Qcp52fm+XPul3YxJzYnliRpGaxpTnwkHHp4ZUTcOSJezDgB/SPgxxiPHP06xqNOvw94DvAPEfGuiPiRiLhWx7ZuAdwLuBj4tV3FTwIuAx4aEdeYQZwHATcAXradlAJk5nHgJyf//aFdsbYT26dtJ6WTOtvtng48fFedJzMeRftDu5PSSd1T1bJJkiRp/syJzYklSdLM3XzyfH3gpxnnK7sf5yykZwLMic2JJUmS+tF5AENE3Doi/hB4M/DtwFuAnwMeANwZuDXwVcA9gB8GXgJcC3gWcFFE/FBEHLT9e0yez9s9RVxmXjrpy9Un7fcdZ7vOa6fEeyNwOXCXyXR2+6nzml3v2R41+yDGSf6rI+KOEfHYiPjRiPimGN/nT5IkVXJGD2kKc+IrMSeWJGlZrGFOnJnnZGbs8XjyYnt5NJkTX4k5sSRJy2INc+Kj4jC3kPhHxgnUE4CXZObHiveeDzw3xvO6fT3w34FfBa4D/PwB2rzN5PkqI04n3sd4xOytgdf1HKdZJzO3IuKDwJcDtwDePRmVe2Pgs411877J8613vPYVwNWAvwJeBvy3XXU+FBEPysy/aS3Ytoh4e6PorL3qSpK08rxHpubHnHjCnFiSpCVjTqz5MSeeMCeWJGnJmBOvpMMMYHgC8OuTqbH2JTMTOA84LyK+CviiA7Z55uT5043y7devM4M4B63TpY0bTp7vxvi+cN8HvJLxVGGPZDzt2qsj4ssy8xONuJIkSZofc+K6jjmxJEnS+jMnruuYE0uSJB1A5wEMmfmMwzScme8A3nGYGFNsD6M57AQeXeJ0bXvn+zd2PP+vzHz+5P+XAD8eEV8KfAvw/ewxIjkzbz+1k+MRt7c7YB8lSVoZAUTPU3k5Tlct5sS9tW1OLElSj8yJNU/mxL21bU4sSVKPzIlX12FmYFiE7dGoZzbKr73rfX3GOWidvd4/beTtp3b8+w+m1PkDxonpHRsxZ6vjl7z8Mjembuk8o0vXHVHfe7BDGM+gd9BKHRurFnuZ9sLL1JdO2guQHbe9WPFpj7out9bQam/K0qKYEy8yJ14WoxkcS5fp8LxMfVkB2Tqvcj1qCQ1itPeblsCw8fpG43VJc2dO3ENOHAkxnOeJuRcBpJU2i/OLZdotdFm+Ve9/V0uy3P6ZYX0NFt2BA3rP5PnWjfJbTZ5b9yw7TJxmnYg4Btwc2AI+AJCZlwEfAa4ZEdOmQKvaAPiPKXW2E9erNfotSZJgnLD3+ZCWiznxmDmxJEkVc2KtN3PiMXNiSZIq5sQrqdcBDBFxx4j4/Yi4KCJORMRwymPrEE28YfJ8r4i4Ut8j4lrA2YzvCfaWGcR5/eT53lPi3RW4OnBBZp7YZ51v3PUeMvMS4O8n//2KKXW2X7t4SpkkSdqW0e9DOgBzYnNiSZKWgjmxFsic2JxYkqSlYE68knobwBARDwIuAB7IePKQtwJvnPJ4U9c2MvMi4DzgZsAjdxU/BbgG8OLJqFYiYjMizoqIWx4mzsQrgE8AD4mIO2y/GBFnAD87+e9v7Ir13MnzEyPiujvqbLd7AnjBrjq/Nnl+2iT2dp2bAI+d/PdlSJIkaemYEwPmxJIkSUeaOTFgTixJktTZsR5jPRm4DLhvZv5lj3F3+2HGCfCzI+KewLuBOwF3ZzzN1hN3vPfGk/J/ZpyEdo1DZn4mIr6fcYJ6fkS8DLgEuD9wm8nr5+6qc0FEPAN4HPDOiHgFcBrwbcD1gB/JzIt39ev5wH2BBwDviIg/ZZwoP2BS59mZef6ea0mSpKNqFtN5OT2Y9u/JmBObE0uStGjmxFqsJ2NObE4sSdKimROvrD5vIfGlwO/OOCndHhV7B+CFjBPJxwO3BJ4NfG1mfnJWcTLzlcDdGI8Q/lbgR4BTjBPPh2TmVTbbzHw88D3Ax4EfAB4G/BNwv8z81SnvHwEPBh7DeHqyRzBOZC8EHpqZj97P8kmSJGkhzInNiSVJko46c2JzYkmSpM76nIHh44yTtJnLzA8DD9/H+y5mPE3ZoeLsqvNm4D4HrPMi4EUHeP8W8KzJQ5IkHZQjYbU45sTtOubEkiTNkzmxFsecuF3HnFiSpHkyJ15JfQ5geDlwv4g4LTNP9hhX87QkX+To2o/macgesmvF+enaxc7rckWswEdXis4b7Wo7qsutfsRoH29a832flpo58VE2OqI7n3Ve7DLZXOcF1zyMViAnHmZ74s7N5e++3E1pccyJV0UCW/3u0Ktrkat+HU9SW9e/Q8x7v7AKfy+ZxTpZ2+Xez3KtwLLrqvq8hcSTgP8Afi8ibtpjXEmSJGlVmBNLkiTpqDMnliRJUme9zcCQmZdHxA8AbwA+EBH/AXx6+lvzln21K0mSdBX+rEMLYk4sSZKWhjmxFsScWJIkLQ1z4pXU2wwMEfFfgAuA6wJD4HLGE/rvfvQ564MkSZK0NMyJJUmSdNSZE0uSJOkwepuBAfhFYBN4GPDSzNzPHaolSZJ6twr3ddPaMieWJElLwZxYC2ROLEmSlsIy58QRcRPgqcC9gS8APga8EnhKZn5qlnEi4i7ATwJ3Bs4A3g88H3hOZg67LVF/+hzl+lXA72bmS0xKJUmSpouIm0TE8yPioxFxIiIujohfiYjrLrpv6oU5sSRJko46c2JJkqRCRNwSeDvwcOCtwDOBDwCPBv4qIr5gVnEi4puBNwJ3Bf4A+DXgtEndlx1qwXrS5wwMnwUu6TGeJEnSweXk0XfMHkwSyguAGwKvAi4E7sg4obx3RJydmZ/spzUtiDmxJElavCXOiXUkmBNLkqTFW+6c+NcZXyN+VGY+Z/vFiHgG8FjgacAP9h0nIq4NPI/xbb7Oycy3TV7/KeD1wIMi4iGZudCBDH0OYHg1cLce42ldzPMEd84n012nnsno0Fa3ppZ6epwr6djPTuulqjTv9dX1g62syme+rqov+Mp8IXvWZacH67q++kpMtbzMibV4q5LPrMJufj2PRdJCjbKYDDQWPlOppH6YE6+QwVajYAZpUO/X8bR41XYyi2uwXWLOexvquk6OqHKVzOJ0rMtnMO+/O823uaVxlJY7Im4B3Au4mPHsBzs9CfgB4KER8fjMvKznOA8CbgC8eHvwAkBmHo+InwReB/wQC56Joc9bSDwBuHZE/FpEXKPHuJIkSStvHwnlZYwTSvOo1WZOLEmSpKPOnFiSJKntHpPn83bfbiszLwXeDFwduPMM4mzXee2UeG8ELgfuEhGn77UQs9TnDAwvAy5l/KvBh0XEe4FPT3lfZuY9e2xXkiTpSmb0g9mzIuLt0woy8/b7qF8mlBHxZsYDHO7MeKSrVpM5sSRJWgpOIqMFMieWJElLYUmvE99m8vzeRvn7GF8nvjX1deIucZp1MnMrIj4IfDlwC+DdRdsz1ecAhnN2/PsawFc33ufpkyRJOor6Sky13M7Z8W9zYkmSJB1F5+z4tzmxJEnSlZ05eZ42wHPn69eZQZy+2p6p3gYwZFY3MZQkSZqXgOz7rmkBcOE+R9C2rERyqMMxJ5YkScthZjmxtCdzYkmStByW9jrxvhrh8IM9u8Tpq+1D6XMGBkmSpOWwmr/jWYrkUJIkSWvCrFKSJElH3XLmxNs/ZDuzUX7tXe/rM05fbc+Uo2ElSZLmYyWSQ0mSJEmSJEnSzLxn8nzrRvmtJs+tWxEfJk6zTkQcA24ObAEf2KPtmeo8A0NE3CEz33aI+mcAN8/Md3eNoeURyzKCaRb96H16mf4nXZzJ+l+Wz3Qvq9LPnlXbUGuVzGKyz2r1O7noFDPYn6y3xvraz3pczn1DX4mplog5sa5ksCT7+a7dWJLuaz2NZpAHDZbmRLSbQZGwbCxpMqMV42akOTEnXmEZxKk1TQK7Lta8952rsPo9nqyu1vbV9TOd9wVmaS+re534DZPne0XEIDNH2wURcS3gbOBzwFtmEOf1wHcC9wZ+d1e8uwJXB96YmScOtkj9OswMDG+NiD+IiDsdpFJEnBkRj2Y8cuPBh2hfkiRplVwpodxZcMDEVMvFnFiSJElHnTmxJEnSPmXmRcB5wM2AR+4qfgpwDeDFmXkZQERsRsRZEXHLw8SZeAXwCeAhEXGH7RcnA0p/dvLf3+i8cD3pPAMD8AjgZ4ALIuJ9wMuANwNvy8xPbb8pIjaA2wB3Br4BuB9wBvBy4AWHaF+SJGmqZfxBZmZeFBHnAfdinFA+Z0fxdkL5f3YllFp+5sSSJGkpLWNOrLVlTixJkpbSEufEPwxcADw7Iu4JvBu4E3B3xjP0PnHHe288Kf9nxoMVusYhMz8TEd/PeCDD+RHxMuAS4P6M87RXAOf2tpQddR7AkJnPj4hzgUcD/x34aSYTcUTEKeBTjBPQ7fs5BzAE/gj4pcz8q0P0W5Ikabqk/6nB+ot3oIRSy8+cWJIkLaXlzom1ZsyJJUnSUlrinHjyY7c7AE9lfDuH+wAfA54NPCUzL5lVnMx8ZUTcjfG16G9lnKe9H3gc8OzMXHjmf5gZGJj8QvDnIuIXgK8Hvg74L8CXAF/AeBrk9wPvBM4HXpmZHzlMm5IkSauqr8RUy8WcWJIkSUedObEkSdLBZOaHgYfv430XMx4Aeqg4u+q8mfG16aV0qAEM2zJzBPzp5CFJkrRYCx8j2tYlodRqMCeWJElLZYlzYq0vc2JJkrRUzIlX0mDRHZAkSZIkSZIkSZIkSeplBgapsy4jn7I5SwrRdSTVvOt10F7qQ5hF/+c8mq3TZ75MI+669qXYIDptKx37MZPtsqPO3/8Oit1QaZ59XGf7WY+ua0mHMlimI9waczX3JlbgwDeYQR9HVVLm9qUZWaVfAq3ArkHSgkXCYLjoXkiS1I3XidfXKp13SZIkSZIkSZIkSZKkNeUMDJIkaf10nSZDkiRJWhfmxJIkSTrqzIlXkgMYJEnS+nFqMEmSJB115sSSJEk66syJV5K3kJAkSZIkSZIkSZIkSQvnDAySJGmtRI4ffceUJEmSVoU5sSRJko46c+LVNfcZGCLCQROSJEk60syJJUmSdNSZE0uSJGma3pLEiPi/wKMy83jxnpsDvwvcua92NT+dRxVV9TLm2Fa7aHov9hGzq6ovfbc3i3VZmMnos8Z20tXcR8it+oi8Ve//Hhwx2ZNZrMfWV38/bfm5akHMiY+A6Dcv6Www3370nI7N3yz6vwLrZN6b62AFEquqjwMTiLkYxGjRXTg63KS1IObEKyQhtlYgqZEkaRqvE6+tPmdgeATw1og4a1phRDwI+Fvga3psU5Ik6Sq2pwfr6yEdgDmxJElaCubEWiBzYkmStBTMiVdTnwMYngb8J+BtEfHw7Rcj4rSI+HXgXGAIPLDHNiVJkqRlYk4sSZKko86cWJIkSZ31NoAhM38K+AbgUuA3I+K3I+IOwFuBHwQuAG6bmX/YV5uSJElTZc8PaZ/MiSVJ0tIwJ9aCmBNLkqSlYU68kvqcgYHMfB3wVcCfA98B/DXw5cDPAnfLzH/psz1JkiRp2ZgTS5Ik6agzJ5YkSVJXx2YQ87PAvwMx+f+ngTdm5mgGbUmSJF2Vo2G1eObEkiRpscyJtXjmxJIkabHMiVdSrzMwRMRXAX8LfDvwp4ynBDsNeG1EPC0iem1PkiTpKhKi54eJrg7CnFiSJC2cObEWzJxYkiQtnDnxyuptBoaIeCTwS5OYP5GZvzh5/Q3AucATgHMi4tsz80N9taslUX1hM5pF0apXxmsXtVs6RMyuO6N5tles48pMlm0G9Tr3s2UWB5g5H7R6XycVD8hLba7bwpI4isus1WFOvGKiWw7VKV6Xso79y+rPAUXM7Ht9HEaXrnTsfsdUulbF7Hgg67ubgxU5oA7CH+n2ZcD81uXGDD63DU9MpJVhTrxaBluL7oEkSdKV9TnS9TnAvzG+h9kvbr+Yme8D7gz8OvC1wN/12KYkSZK0TMyJJUmSdNSZE0uSJKmzPgcwvAr46sz8q90FmXkyM38E+JYe25MkSZKWjTmxJEmSjjpzYkmSJHXW2y0kMvOB+3jPKyPi7X21KUmSNJUzDGtBzIklSdLSMCfWgpgTS5KkpWFOvJL6nIFhXzLzw/NuU5IkSVom5sSSJEk66syJJUmSNE1vMzBIkiQti3BkrSRJko44c2JJkiQddebEq8kBDJIkaf2YmEqSJOmoMyeWJEnSUWdOvJIcwKAr6TwSKaNbzFZZUafdUl2vjFnVG3Ws13WdNON1K+v+mXYsK8ykL3O0Kv3vfUThkqz/uZvBclefTbHLOLKjRJvr5IiuD0nzE1HtlDveha+K2UF13JhFvTpmtb6Kil36MoP+L1N7sQIH/cES9bHqyyCKEzlphQxz+racJsUARMRvAd87+e+tMvP9i+yPtHISYmvRnZAkaQ9eJz5yHMAgSZLWj8mrJEmSjro1z4kj4n6MBy98FrjmgrsjSZKkZbTmOfG66vjzIUmSJEmSJEmav4i4AfA84Fzg7QvujiRJkqQeOQODJElaL+mtVCRJknTErX9O/H8nz48Efn+RHZEkSdKSWv+ceG05gEGSJK0fE0lJkiQddWuaE0fE9wAPAB6YmZ+MaN0UWZIkSUfemubE684BDJIkSZIkSZL246yImHrLhsy8/awbj4ibAs8CXpKZr5x1e5IkSZLmzwEM2r+uo5SKes2pW6q2usTbq96oqtceyV+2V8Ts1M+O67/rOulqFu11muJnBttrpfdpiGC5+tIy5/XMLH5Y06Evc13Hy6Ra7hl8Ns3d7x7rP+j/M/I3XdI6CohBzyE77i1a9aruVW113WlV9ea8IyxS8G51ZrFsHhyOlI3iBK8qW3Ub5cmy5mGL4dTX90p31zEnjogB8CLgs8CjFtwdaS1EwmCrS8WODS7L9ZRV778OZhaf96IPivvVWoYlucZ6KKvyGagXrfP9vfLddcyJjwoHMEiSJEmSJEnajwsPM9NCRFwM3PQAVX4nM79r8u/HAncD7puZn+raB0mSJEnLzQEMkiRp/firCEmSJB11y5kTXwQcP8D7PwoQEbcCnga8IDNfPYuOSZIkaQ0tZ06sPTiAQZIkrR8TU0mSJB11S5gTZ+Y9O1b9cuB04OER8fDGe94X41ssPTAzX9mxHUmSJK2TJcyJtTcHMEiSJEmSJElaZhcDv9Uouy9wI+DlwGcm75UkSZK0ohzAIEmS1ktC9D2y1pG6kiRJWiVrlhNn5t8Dj5hWFhHnMx7A8BOZ+f45dkuSJEnLbM1y4qNksOgOSJIkSZIkSZIkSZIkOQOD9i+jWVSOYOpSVtSJUbeyzv2v2uu43HU/i7K++9H1c6t0ba9jzE5tzbEfMIMRftD/OulqVWL2LHIFOnkY81y89q6Z3JheuK9tec0/Ikn9iEFjJzQoxnm36gBEuyzLsoPXqZT1qv1u1dwMyrq0V9aZha7tFQerjh9r3VwjZnRMALvW62ow5/bmabAiScmgPEldX410c1w2v24wKi48nMrh1NdzP9vWamx+khYpYbC16E5I/WidK6xxqgl0O0da93WyCrqe23b97OZ+Lt23wyTnbu8ryQEMkiRJkiRJklZSZp6z6D5IkiRJ6o8DGCRJ0vpxZK0kSZKOOnNiSZIkHXXmxCvJAQySJGntOBWeJEmSjjpzYkmSJB115sSrqbi5qyRJkpZBRNwqIn48Il4fER+OiJMR8a8R8aqIuPui+ydJkiRJkiRJUh+cgUGSJK2f9RtZ+zPAtwHvAl4NXALcBrg/cP+IeHRmPnuB/ZMkSdKyWb+cWJIkSToYc+KV5AAGSZKk5fda4Bcz8+92vhgRdwP+DPiliHh5Zn5sIb2TJEmSJEmSJKkHDmDQlRUjkcr7xIyKeh3aiypeUUa2W+secwb1qnXZWicd6syiH4fqS2We66tjP2ZRL7JjxZ5HDc59fRVmck+qVR9luQL97/q55Ua7bNR1wXMG29GCP4PMfGHj9b+IiPOBrwfuAvz+HLslrbYAonFHvShyyqIsB0XmW928r1WvCFekvWtRr5Nl6cdhFH2Jng9ufcfbK+Zg0QfTNTIoT0TnZ2MGn+myLNu8DYvzwuM5nPp67rX+1zAnljQDCbE1vWgW12fKnKxnq95/HdxR/XiO6nKvuuLSwmyuufddcRb72Oq6SbPS3uXmxKvJAQySJGn9zCaRPCsi3j61uczbz6TF/Tk1eW5cdpIkSdKR5MVVSZIkHXXmxCupy3iWhYuIm0TE8yPioxFxIiIujohfiYjrzjpORNwlIl4dEZdExOUR8c6IeExENH9DGhHfHRFvjYjPRsSnI+L8iPimffbx1hFxWURkRLzkIMsnSZLWW0TcFLgncDnwxgV3R3NmTixJkqSjzpxYkiRp/azcDAwRcUvgAuCGwKuAC4E7Ao8G7h0RZ2fmJ2cRJyK+mfHUzMeBc4FLgPsBzwTOBh48pZ2nA48H/gV4HnAa8BDgjyLiRzLzV4s+HgN+m/IGDZIk6SpmM7L2wgXPtHAlEXE68DvA6cCPZeanFtwlzZE5sSRJ2pO/NtOaMyeWJEl7MideSas4A8OvM04mH5WZD8jMJ2TmPRgnh7cBnjaLOBFxbcaJ5RA4JzO/LzN/FLgt8FfAgyLiIbvq3IVxUnoR8J8z87GZ+Ujg9oyT2qdHxM2KPv7EJP4T97lMkiRpSU1+wZMHeDR/UTP5Rc9vM74wdi7w9Hkth5aGObEkSZKOOnNiSZKkNbRSAxgi4hbAvYCLgV/bVfwk4DLgoRFxjRnEeRBwA+Blmfm27Rcz8zjwk5P//tCuWD84eX7azl9FZuZ2u6cDD2/08Q7ATwE/A7yzWh5JknRl0fOjJxcB7znA46NTl208eOEljH/R83vAd2WmY4mPEHNiSZK0H0uaE0u9MCeWJEn7YU68mlZqAANwj8nzeZl5pemyMvNS4M3A1YE7zyDOdp3XTon3Rsb3nr7LZDrn/dR5za73fF5EXA14MfD3wC80l0KSJE2XPT/66FLmPTPzrAM8fmx3jMm0ob/LeJrRlwLfkZlb/fRQK8ScWJIk7W0Jc2KpR+bEkiRpb+bEK+nYojtwQLeZPL+3Uf4+xiNmbw28ruc4zTqZuRURHwS+HLgF8O7JqNwbA5/NzI812mDSxm6/MIlzu0nsYlGmi4i3N4rOOnCwwyq+0NEqq3YC2V4fMSzaqu4Q16WPe9Ur2itjNupVdbou20yWu+sOvHN7jcJ597Ew7/b6PoiuzPqqLEliMZNlm6eu/S8OY9XuK1rDLFd9PXYUEacxnnHhmxlfwHr47gtsOjLMifepzokDBtNjxsZGFbT3smyUtV4HyqHoRbpc7pNXot68D6az+HlFsQzlZl7Wm996WaZfnAyKpGCjsU4G5cnTfG0sUV80e6Mi8z1VpHTHG+e8bj2SOfF+VTlxJAxOHc08oouy/1XhKlzHWPUPR1J5DaH5d5Q5K69zVFbt5/g6tFUbwHDm5PnTjfLt168zgzgHrdOprxFxT+BHgCdk5rsadSVJUkPQ/9+3Fn0eP/nlzv8D7gP8FvADDl440syJJUlSaR1zYmkXc2JJklQyJ15dqzaAYS/b281hN8cucbq2/fn3R8R1gBcAfw388gHjXDlo5u2nvT4ZcXu7w8SWJElz91zGgxc+AXwE+Okpv7w5PzPPn3O/tJzMibeDmhNLkiQdVebE20HNiSVJWjsRcRfgJxnf5uoM4P3A84HnZGYxX/3hYkXETYDvBm4LfDXjmaICuFVmvv8Qi3QlqzaAYXs06pmN8mvvel+fcQ5aZ6/3Txt5+wzg+sDXH3TjkiRJE7O4H9niZ1m7+eT5+sBPF+87f/Zd0RIwJ5YkSbX1zImlncyJJUlSbU1z4oj4ZuD3gePAucAlwP2AZwJnAw+eYaw7AD/LeE18kHH+cp3OC9OwancNec/kedr9wABuNXlu3bPsMHGadSLiGOM/LGwBHwDIzMsY/0LymhHxRfts43bA1YALIyK3H8AbJuXfOXnt71sLJkmS1k9mnpOZscfjyYvup+bGnNicWJIk6agzJzYnliTpyImIawPPA4bAOZn5fZn5o4xnRPgr4EER8ZAZxnobcFfgOpl5S+Adh1+qq1q1GRi2E7R7RcRg572fI+JajEeCfA54ywzivB74TuDewO/uindX4OrAGzPzxK46D53UecGuOt+44z3b/h/jD363L2I8bfRFjH9Z+aFi2SRJ0hKMhJVmyJzYnFiSpL2ZE2u9mRObE0uStLf1y4kfBNwAeHFmfj5XyMzjEfGTwOuAHwJeNotYmfkvwL/0sSCVlZqBITMvAs4DbgY8clfxU4BrMF7JlwFExGZEnBURtzxMnIlXML7v9EMi4g7bL0bEGYynygD4jV2xnjt5fmJEXHdHne12T7AjYc3Mp2bmI3Y/gF+avOUtk9eeepWVI0mSPi+y34e0TMyJzYklSdoPc2KtM3Nic2JJkvZjDXPie0yeXzul7I3A5cBdIuL0Ocfq1arNwADww8AFwLMj4p7Au4E7AXdnPM3WE3e898aT8n9mnIR2jUNmfiYivp9xgnp+RLyM8X1A7g/cZvL6ubvqXBARzwAeB7wzIl4BnAZ8G3A94Ecy8+KuK2KZRFVYfaEbZTFqR4xRs6jeeRRlXWNW9Tq31yqb83KX9bIoLOt1ba9bvd7bWqKYld4Pop370bHinJOAZVlfs7AkCRWjjaJwoziCLEn/pSVlTnxYAbHR2EENin1Tqw5AtOvloBg73mqv2kUWbdX12mWVst4c2+vaj+qg2LWP9YlCx5g9i47JwGAGSUTVl6q9WfSl3Vb7BGme/TiMjerE8YjaWJKk8lS2P5vjRdmJRve7nm5Ja8acuAeDrUW0qiNvFvly69i4JLm5NGtZnLPM83SmPMceFB0prsUsYe57VkS8fVpBZt5+xm3fZvJ8ldtkZeZWRHwQ+HLgFoxzmnnF6tVKzcAAnx8VewfghYwTyccDtwSeDXxtZn5yVnEy85XA3RiPOvlW4EeAU4wTz4dkXvUrlJmPB74H+DjwA8DDgH8C7peZv7qvhZYkSQeTPT+kJWNOLEmS9mROrDVnTixJkva0fjnxmZPnTzfKt1+/zpxj9WoVZ2AgMz8MPHwf77uYYnzdfuPsqvNmxvcZO0idFwEvOkidXfXPx3GCkiRJ2sGcWJIkSUedObEkSVqACw8z00JEXAzc9ABVficzv2u/4SfPfQy36DPWgazkAAZJkqTKiszyLEmSJM2MObEkSZKOuiXNiS8Cjh/g/R/d8e/tWRHOnPZG4Nq73lfpM1avHMAgSZLWyyym81rORFeSJEmazpxYkiRJR92S5sSZec9DVH8P41tf3Rp4+86CiDgG3BzYAj4w51i9Gsy7QUmSJEmSJEmSJEmSdCCvnzzfe0rZXYGrAxdk5ok5x+qVAxgkSdLaiez3IUmSJK0ac2JJkiQddWuYE78C+ATwkIi4w/aLEXEG8LOT//7GzgoRcWZEnBURX3TYWPPiLSS0f9UXsyirvtAx6q8OAEVZVa9sb9gxZtd+NvrSPV574cqYHT/TWWwnnep1bavSsV71Gcyknx3aqsx7fVVmkiBUn08HS5LEjM2xL1kMiYxBtMvm+R2QpN2isX/a2Dh4HYCNYmdYFGUjZG4UbRVFWex363rtsrJeUVbV61RW9aMIV7fVrpmzOBh17Eu16UWHfnaps5fBET14z2K5B+XJ2mrbqE5gOxosyb0NTmV72U4V5x3Hi+6fbOycs9yZSNL+RMJga9G9kBanPJeRVszSbM5dry10/bvTEZOZn4mI72c8+OD8iHgZcAlwf+A2k9fP3VXtgcALgBcB33PIWETEC3f896zJ8y9GxKWTf/9mZv7lIRbTAQySJGkNmdRKkiTpqDMnliRJ0lG3hjlxZr4yIu4GPBH4VuAM4P3A44BnZ+7/V5sdY333lNe+Zce/zwccwCBJknQla5iYSpIkSQdiTixJkqSjbk1z4sx8M3Cffb73hcAL+4g1ef//3969h8tSVnce/63qvc8BjaASHI1GUCJgxsxF0CTgBWEkakBkxNF54gxqTGLi3TiZRLygE6O5eMMkGo0KxgvGG2RUjBE8aiRRg4PXgIIco4A3QLkezt5da/7o2rLPPv2u7n67qrur+vt5nnr6nF693nrr7e6q1XXeU9X4BT+iC3kAAAAAAAAAAAAAAADMBFdgAAAAnbOkt+AGAAAAfoKaGAAAAMuOmriduAIDAAAAAAAAAAAAAACYO67AAAAAusVV/73NmKkLAACANqEmBgAAwLKjJm4tJjBgT26ZeUGszFhflBPEbNaxfv1tpsbSyvQg172uUbHokju56wsv4xPmJYKNrCvIi2Tmxf2cvNGF6n+uBtrM+Qy1Rfh9zODBdZvK1QaOH7mfPQXva6bMrQOwwEwm6/USweBb3wt2hlFeEeT1hudFpbknuj4yL+pjA3lxmxl5Tawrkrm+RTlwZG92UMgVXH9zIr26C7Ip9DLeuyL8cb6cohHZHdSga8Hw7woK7VsTO/xR7ww1MYCxuKuIdlAp0Q6hDaVCEzu03O2uuy+L0o+OC38fAUsgOk8c/jaf8b/NUBO3F7eQAAAAAAAAAAAAAAAAc8cVGAAAQPe04X98AAAAAE2iJgYAAMCyoyZuJa7AAAAAAAAAAAAAAAAA5o4rMAAAgM7h9twAAABYdtTEAAAAWHbUxO3EFRgAAAAAAAAAAAAAAMDccQUGAADQPcysBQAAwLKjJgYAAMCyoyZuJSYwYHyZX/Lo8ixWTvb8yPYy1iVJ1s/My4310x3NGRPl9iN6T7PHOQhmtpmVl72u4L1pYLxC2d+5jMTM705um7mytk2qvy8zLnpmfZkrt0RgJRVYMN7AmFHoAt1jJvV6w2Op5yWpSF/EzqNYL70PdRse82LyHElSEPLoGnzRbj7Ii9rMXV/qWJQ8Ro1oLzsWCdsMasooFjUZthkkJgQfr0YUQf+L4EAb5mW02cttj+uOLp3UaYK14DfJWvAx2eXpY8tasLPc5cNP3fmonRc1MYBxuFSsz7sTWHgtOR00S05tiGWR+P6XwY4hKHvzZfw70EacmriduIUEAAAAAAAAAAAAAACYO67AAAAAuoeZsAAAAFh21MQAAABYdtTErcQVGAAAAAAAAAAAAAAAwNxxBQYAANA53IoQAAAAy46aGAAAAMuOmridmMAAAAC6h8IUAAAAy46aGAAAAMuOmriVuIUEAAAAAAAAAAAAAACYO67AgFqEl2BxC2ITPj8iZmUDsX5um+mO5rTZyLYFfcwe59z3Llzf5P3MvixQ2Me89zR3hl+0vlDO9yrsR16ecvsfCPsSfU5m2Y9cM/6ceJHeN5erw+c3lsG0x2hXn22KzzKXBgMwkknqDd+xWZHe4XkiR5LUS+8Mo/1uMhbtd2cdi/bzUbmfmZfckTeyrtxYUBvmtlmzooEDYtRmE+trg170AylQZOb1lJcXt1nve1d3e1Izn69+0GTqJ95a8CXe5b1kbC3Yya4Febs1PFaOsTNZ0q8kgAmYS8U6OwuMMMP6ddZyz2cVLfnaNHK+Dt0T/IAt02Vq/d0IznP7FDsiauJ24goMAAAAAAAAAAAAAABg7rgCAwAA6Bb3+q8A0sAVRQAAAIDGUBMDAABg2VETtxYTGAAAQKeY6r80GFfcAwAAQJtQEwMAAGDZURO3F7eQAAAAAAAAAAAAAAAAc8cEBgAA0D1e8wIAAAC0TUdrYhs41cx2mNm1ZnaLmV1hZn9rZofOu38AAABYIB2tibuOW0gAAAAAAAAAWHhmto+k90o6QdKlkt4l6QZJPyPpwZIOlfT1uXUQAAAAwNSYwICxNXFfl9S9Z6wMcoKYorx+ZixsMz3dqgjaDPuZiEXtWRlM+wpCueMcrS+8n1BuX3zy7Qs/J1E/MtY1us0oL3MsI4n3J7u9zLxwLBdpfdFnJUduPwK5750X6T23rwaxVKhFN/gK9wEAIEkyqdcbHko9L0lF+iJ2vhLEon1yIi0nZy6xzONDzvrCdeUeMHOPbw30xYI8C9YX5eXkFJn9L4JCLrdNTKbX8iKo18B/aeoHX9boZ/taYkeUel6SdgcXOl3z9LFlzdOn53Yn8nyMnW/LPw4pr9Jg8sIrJL3Q3ffYSjNbnUuvgLZyqVjnGA3l18TRx6dF55EwHo9+lCyQ3PPEbdm+LMGmlb3oHzcSiTMequS/JY6T282auPOYwAAAAAAAAABgoZnZIZKeJunzkk5z3/tfJ9x9beYdAwAAAFArJjAAAIBuaeJ+ZAv4H1LM7C2SnlL99T7uftk8+wMAAIAF0lxNfLiZXTQ07H5EzWvc6r9LKiSdJWk/MztR0s9KukbSBdTDAAAA2MOSnCfuIiYwAACAzun6Vaqrk7VPkXSjpJ+ac3cAAACwgDpYEz+getxf0uWSDtgUczN7g6RnuXt0dxAAAAAskQ7WxEuBCQwAAAAtYmYHSnqzpPdIuqukh863RwAAAFgil8zgSgspd6keXybp45KeL2mnpAdK+itJvyPpB5JOn0PfAAAAANSkmHcHAAAAaude77JY3lQ9Pn2uvQAAAMBiW8Ca2Mx2mplPsLxjU3qverxa0snu/hV3v9HdL5B0iqRS0vPMbFstnQUAAED7LWBNjNG4AgMAAEBLmNmTJD1GgxO215jZfDsEAAAATOZySbsmeP1Vm/58XfX4UXe/ZfOL3P2LZnaFpEMk3VfSF6fqJQAAAIC5YQID6hFMOgrvL5MxWcnKGcf66U4WwV0VLTeW6IuV6X7kb3cDbQYz0KLtDj9DQT9TefHnLuhjlBeNV82f80Gbk2+3FH9m0+3VP3Mw9z0INTGWOaLPZNiPershSd5L/wO2W3ChpejfvRMxj/6xPIj5HP6NvaF7mx1uZhcNC8ziMrpmdpCk10l6h7uf0/T6gM4zyYrEfrIX7D+jWKo9SYr21yvD87w39OlBrAjaC2LR/j/cz0fX7gtiHuVlHIuyciR5kT4weHTQCGNBXwLh3LNgfZYRi3IiYRcbOMgWwQ+MIlhfTl4RFJQ9BT90MkXri/SCvGhM4jbr3b6igfHKVQaf2jIoRteCnVQ/0eZasHPerXQsyusH/VhLtDnOp2AR7/fr7sdNkX6ppOMl/SgR35jgsO8U6wCWirlUrC3gzgLLLSpGcz6u/N+PGnV9f7EY2xf+No8EaeVK3nndLljEmhijcQsJAADQPV7zMmdmVkg6S9KNkp415+4AAACgDTpWE0s6v3q839aAmW2XdJ/qrztn1SEAAAAsuO7VxEuBKzAAAACM55JprrRgZjslHTRByjvd/YnVn58r6aGSftXdrwtyAAAAgK46T9I3Jf2KmT3c3f9hU+xFkvaX9El3/+5cegcAAACgFkxgAAAA3eINXBqsnvay7vdrZveR9HJJb3P3j9TSEwAAAHTb4tbE+at3321mp0r6mKTzzOyDkr4l6QGSHiLpB5J+c45dBAAAwCLpYE28LJjAAAAAMANT3O/330vaLunJZvbkxGu+YYP71Z3s7udkrgcAAABYaO7+j2Z2pKSXSHqYpDtK+p6kN0n6P+7+nTl2DwAAAEANmMAAAAC6xzs1FXanpLckYr8q6a6S3ivpenG/XwAAAGzoVk38E+7+NUmPn3c/AAAA0AIdrYm7jgkM2EN4KZUgZmWQF8RSeVF7Yayfm5feuGI9b31F2Jf0+lJtxmMStBfkFcF2R9sWfxaCYGZe+LlM5IXjFR2woj5GedF3IBK0mTuWyfbC/ucdxLMvvxS+B5mN5r4HCeF4RRooiHylCGLpQ3mY17N0rEjE0inyIBbKzRvRZN2XBmugm2Nz94slPXVYzMx2aDCB4QXuftkMuwV0gEm93vBQ6nk1sG+V5Ikmc3JGxtKbFseiY0CwvvDYUaR31sk2G+hHGIvajITrC+q/IM8yDm5RTlH7dTTz1xfGgsK318A2JNcVFJtRH+M2OZG2VT/48vSCHdFa8GWN2iyDHcduDd8phjnBjrQM+piT5yMq1K7VxACaU6xn7CwyzyPFHVmQvUwT25ZrUcak5bLPWQFzEv0ujH/vZ55DyDjnm5MzD9TE7ZV7OgYAAAAAAAAAAAAAAKA2XIEBAAB0zwL9hwkAAABgLqiJAQAAsOyoiVuJCQwAAAAt5e7HzLsPAAAAAAAAAADUhQkMAACgc2Z4S2wAAABgIVETAwAAYNlRE7dTMe8OAAAAAAAAAAAAAAAAcAUGAADQLS6prHlqLTN1AQAA0CbUxAAAAFh21MStxQQG7Cn64oUxS4bCy7MkYlamU7Jj/XRHin6Ul47FeZnrS2xD1F48JkE/1oM3J2ozSIvWF21D9PkK2/RELOi/Ujka9XmN3oNoLOtfXxiLtj3Zj8x1RXLzws/ejPtSd3uW3lf6SnBRpCBPRdBmECt7QV4v8XzQDeXGIqm8cdqjkAQwiklaGb7D816wTy7SsSgv3O8m9tdlYn88WFcQC7rfSCzYL+fmpfb1XkRF4+TtjY5F6wtqvCgWrS7z2pY5h9poXUVmbJEU0Y+kGerNuB9Fzo+BwKz7XwY7jV3BRUT7wbegH+RF69ud2NGWmf1Y8/QpuH7Qj1SbPs43vx1fVwDzVLqK3YtxzMzaaeWeb2jN/rHmjuaOV0t44vxZFzY7+5xohtQ4ombR7+jw9/7k53RHrS8r1qaPSWv2+diMW0gAAAAAAAAAAAAAAIC54woMAACgc1ryn0MBAACAxlATAwAAYNlRE7cTV2AAAAAAAAAAAAAAAABzxxUYAABA98zw3oAAAADAQqImBgAAwLKjJm4lJjAAAIBu8QYuDUadCwAAgDahJgYAAMCyoyZuLW4hAQAAAAAAAAAAAAAA5o4rMGBs0SylcAZTGeQlYqnnJcn6s40VYV56w+vOszKdY+vBuqK8aJzX08EwL1pfdKmeYEyiNlOz3cJ1hX1Mp6kMNjwak6gvubFgfbPtR+Z0w9zLNs0wL/rceWHpxCKYG7jSS7fZS8fK1SBvJd2XKBZOYUykeZDjwarcgj4GeVNhJiyAUczkqf1ytL9eSe8M431ylJd4PjjehLF090ccw4K8sM10LDze5BxXwuNNsK4wFv3QCUJFZl6wvuCQGcaKRJvR2x1JtTdVLDg4N9Fmur2MQnoO2tLPHGupnZ6ktSCvH3yx+uGOKK0MdkSp9UX9j/oR9b8M84bHxvr0UxMDGMFcKnanTkY29YMdTWrsPEsLLPGm12rm45i7r4nO9y7I/st70e/2zN/7TcQyz+sm5f42b0pHa2IzO0rSCyX9kqR9JF0m6a2SXu/uwb9QTteWmR0t6SRJD5N0sKT9JF0l6XxJr3T3y/K36jZcgQEAAAAAAAAAAAAAgAVnZidJ+pSkh0j6oKS/kLRN0msknd1wW++X9LuSdkl6p6TXazCB4dclXWxmvzz5Fu2NKzAAAICO8fiKI5ltAgAAAO1BTQwAAIBl172a2Mz2k/RmSX1Jx7j7v1TPv0jSBZJOMbMnuPvIiQyZbb1G0t+4+1Vb2nqBpJdLepOkX5hyM7kCAwAA6KCy5gUAAABoG2piAAAALLvu1cSnSDpQ0tkbEw4kyd13aXAbCEn67abacvc/3jp5ofLHkm6RdD8zO2DM9ScxgQEAAAAAAAAAAAAAgMV2bPX40SGxT0m6WdJRZrZ9xm25pPXqz/0xXh9q5QQGM7uHmb3VzK4ys1vNbKeZvdbM7tR0O2Z2lJl9xMyuNbObzexLZvYcM+sFOaea2efM7EYz+7GZ7TCzE4a8btXMTjazt5jZV8zs+modXzazl5nZHSbZPgAAlpG5ZO41L/PeKmBv1MQAACCFmhjLgpoYAACkNFgTH25mFw1bZrBZh1WPX98acPd1SVdIWpF07xm39ThJd5D0z+7+ozFeH2rdBAYzO0TSRZKeLOlzGtxr45uSni3pn8a9LEVOO2Z2kgYzTh4i6YOS/kLStip36L1EzOzPJJ0p6W4a3EfkHRrc++P/mtkztrz8EEkfkPR4DT4Ub5D0Nkn7SnqRpH8xs58eZ/sAAADQXdTE1MQAAADLjpqYmhgAgCW0f/X440R84/k7zqotM7uXpNdrcAWG3x1jvSOt1NHIjP2lpLtIepa7v37jSTN7taTnSnq5pKfV3Y6Z7adBYdmXdMzGvUDM7EWSLpB0ipk9wd3P3pRzlAZv1OWSHuDu11XP/6kGRfGfmdmH3H1nlXKDpKdLOsvdb9rUzjYNCtZflfQSSc8cY/vqF820D+77YhkxCy4uErVX9NOdDNsMY+k2i/VkKL8v5fC8Yr3e9iTJojajvGjbgjyFbabf2LBNT8TCz10QTLU3qs0oLzcWbXck1WZmP7LGf1QsVxPjlVJYMmRK/mcKeS+d56tB3mp6TmHUZtkL8oJtyIpZOkdBKIw1hf8dhu6jJq6jJu4N3y9H++syioX75HQ3ysR+3tOrUhnEonU10WY0Ld6DY0AUSx074n6kd/4exLKPYdFhMVxfUHdlxnJyigX6r9RN9KWX0WbUjyjWi36khuvLy+s1cOPVnG0ogy//rvDLmtbPLBz7meuLtiHVZtTHMuhHP1xX0GYiz8cZq8X5mgNNoSaetiZ2V7G2GDf0zhHWk10WnrPqgNxzfMG4dJlH5+syhOe5Zyx/22rehuh3bfS5C/ofnkPO/E1f9+/vKNbE/rfuz/JtDTfS6iXufkRuspntlHTQBCnvdPcnjtt89VjHlo9sy8zuIuk8SQdKerq7X1jDett1BQYzu7ek4yXt1GBW62YvkXSTpP9hZrdvoJ1TNBj8szeKUkly912SXlj99be3tLVR2L58oyitcjbWu12Dmb0bz1/p7n+5uSitnt8t6Y+qvx4TbRsAAAC6jZpYEjUxAADAUqMmlkRNDABAW10u6dIJlqs25W5cFWF/DbffltdFpmqrmrxwgQa3oni2u//lGOscS6smMEg6tnr8mLvvMTXU3W+Q9BlJt5P0Sw20s5Hz0SHtfUrSzZKOMrPtY+act+U1o6xVj8H/+QcAAJIGV+uocwEWCzUxNTEAAKNRE6PbqImpiQEAGG0Ba2J3P87dD59g+b1N6ZdWj4dubdfMViTdS4Ma4ZtjdCW7LTO7m6Qdkn5egysvnDHG+sbWtgkMh1WPX0/Ev1E97jXQNbSTzHH3dQ3uRbYi6d6SVM3KvbukG9396in6uuEp1eOwIncvZnbRsEXS4WOuDwCA1jKvdwEWDDUxNTEAACNRE6PjqImpiQEAGKmDNfEF1eMjhsQeosHEywvd/dam2jKze0j6pAa1xNPqvPLChrZNYNi4hEXqshcbz9+xgXYmzamrrzKzR0v6LUnfkfQno14PAACATqMmpiYGAABYdtTE1MQAACyj90n6oaQnmNmRG0+a2T6S/rD66xs2J5jZ/mZ2eHXVhGnbuqcGkxcOkfTr7v6m6TdpbytNNDpHVj1OOwcmp53cdYevN7OjJL1Lg/utPXbzPdLCRt2PSLR3kaT7T9hHAADahUvcYrlRE280Sk0MAFhm1MRYbtTEG41SEwMAllnHamJ3v97MfkODyQc7zOxsSddKerQGV4l6n6T3bEk7WdLbJJ0l6UlTtvVJSQdLukjSQWZ2+pBununuO7M3Uu2bwLAxG3X/RHy/La+rs51Jc0a9ftTMW5nZL2twD7RS0iPd/XOp1wIAAGBpUBMDAABg2VETAwCApeTu55jZQyWdJumxkvaRdJmk50k6w338WRsZbR1cPR5RLcPskLRz3D4M07YJDJdWj6n7gd2nekzds2yadi6VdGSVc9HmF5vZiqR7SVqX9E1JcvebzOxKSXc3s7sNub9Z2Fcze7CkD2tQlP6Ku//ziG2qR/SRDmLRfV/CWDnZ85Jk/XSD1k/nFVFsPd1mmBf0JWoz6mdq+6LtjteVGSuDNy6IWT/95oVthn0JPhCp8Yr2z1F7UR9zZ+pFeUEsHK+cNsMxqXldUjzOizTrcSVxKLT0XZZ8pZeObU8fWn01yFuJ1hfFLB0LbhSVEwtz0t0IY8qNRTw+juS2CSwQauIauJl8dfg+23vB/roX7HeDfXK5GuQl2iyjdQX75Ny88AaD0X4+PKYEO9CcvCaOKWEsqNWiWNRkEAzbzIgV2X0MfnsEB8VofUXmwTk3L91eXv/z11d3UdKMfvKLnK5t12bajxF5mYVjGayvn3HX1X5Q+JZBe9F2p/pRhkW2qImxDKiJ6+CSrQUnKhdc7mmDiEfFGvY265uUR8e2tt0wvSZW92d2gc7bZm9Z/KMrGUr9Nvci+HAFv7+j3+bx7/bcWDKU/5s+ldfEOd0mdLgmdvfPSHrUmK89U9KZNbU1k3e4bbv0T1SPx5vt+S9LZnYHSUdLukXSqCIup50LqsdHDGnvIZJuJ+lCd791zJxHbnnN5j4cq8GM2nVJD5/Z5AUAALrCvd4FWCzUxAAAYDRqYnQbNTEAABiNmriVWjWBwd0vl/QxDS5P8fQt4ZdKur2kt7v7TZJkZqtmdriZHTJNO5X3SfqhpCeY2ZEbT5rZPpL+sPrrG7a09cbq8TQzu9OmnI313qrBPUe0KXa8pA9J2iXpOHf//NZxAAAAwPKiJgYAAMCyoyYGAADorrbdQkKSfkfShZLOMLPjJP2rpF+U9DANLrN12qbX3r2Kf0u33ZMjpx25+/Vm9hsaFKg7zOxsSddKerSkw6rn37Ml50Ize7UG9wn5kpm9T9I2SY+XdGdJz3T3nRuvN7PDJJ2rwf1FPiLpJDM7aesAuPvpI8YIAIDlxmRYdB81MTUxAAAxamJ0HzUxNTEAADFq4lZq3QQGd7+8mtn6Mg0uufUoSVdLOkPSS9392qbacfdzzOyhGhStj9WggLxMg8LzDPe9rx3i7r9rZl+S9AxJv6nBXZq+IOlP3f1DW15+t6pNVe0/NtH908fZRgAAAHQTNbEkamIAAIClRk0siZoYAAB0UOsmMEiSu39b0pPHeN1OSTZtO1tyPqNBETtJzlmSzhrjdTsU9BcAAIzDZbXfj4ypulg81MQAACCNmhjLgZoYAACkURO3VSsnMAAAACS5pLoLU+pSAAAAtAk1MQAAAJYdNXFrMYEB9Yi+sEHM+pM9L0nFem4s3ZEiXF+QF8Qssy+2Xg7P6Qc5ZdReEOsPX9cgFrxx5eLkKbXtUU5wwIrGJDzQRbHg/ck+ePaDD22izSFXL7xN1MeIZ45XJOpLEfzng6KXDNlKOqZEzLetJlPC2Gp6XWUQ814RxNLb7cGYZMcSodTzkuL/FxLEojbD9QHAtMyS+2xfDfbJQaxcCfatwb68TBwePDh8NRJLb1p2TFFedAxI5HmRrhOimCyqL4LaMGwzCAXrK6L1RW2mQ8n1hf3IjOUK1xf8aOzlbkOizZ6C+jXQs7y8RdIPvpD9xJeuF9X7Mxb1P8zLLCrLxPpSYzWyH0H/y6CPqTzOmwKog7nL1oJzTEso91SER4Uc9hYdThel/Mg75GNWgu+cF8GbF/1uT5wvjc6jlpnndMPfypm/2+MxCdrM/SGagfO9GBcTGAAAQPcsyo9dAAAAYF6oiQEAALDsqIlbiTlkAAAAAAAAAAAAAABg7rgCAwAA6Byr+95mAAAAQMtQEwMAAGDZURO3E1dgAAAAAAAAAAAAAAAAc8cVGAAAQPcwsxYAAADLjpoYAAAAy46auJWYwAAAALrFVX9hSp0LAACANqEmBgAAwLKjJm4tJjBgDxbFynTUyihv8pj103sA6wftBbFiPYql1xfG1oJ+5ra5nhiUcEwy2pOkMh2L2lTQpgVtqp/Xl+gAY6k2o/bKYNuig1k/+IAFeR61GfYlb0ySbUbtRf0IhNsWMAv2NkUQs/Rhy1Z66bzt25Ih37Y60fOS5KvpdYWxXnrbfCUdK4OYB5sdxoKbSHnqPQjeGg/eU48OLgAwLyb56vCdYbQvLxM5g1jevjwVK4P9ePaxIdz/B7GwzaAOylxf8pgT5eS0N0UsKmdkQf2aGSvCWNCXmuX2sQlF9GMzQ0957RUzPoO1Fnwh+8EXoRf9Hkjl1DzGTemHO5TMNhNjWWYWt9F7U2b1nyIbQA3cpbXgpOkiyP2Hp7BYq99M1zbjbVtasyyyuy76zIbnFIO84DexgnOw5Uq67vJe4hxB9Ps7/G0exILPVxxLhuJY5u/eVF7UXhPngpP9qH9VWBD1/8IDAACYt7LmZUHYwKlmtsPMrjWzW8zsCjP7WzM7dN79AwAAwALpaE0MAAAAjI2auJW4AgMAAEALmNk+kt4r6QRJl0p6l6QbJP2MpAdLOlTS1+fWQQAAAAAAAAAApsQEBgAA0Ckml9V8bzNbjAuSvUqDyQuvkPRC9z2vA21m6fueAAAAYKl0uCYGAAAAxkJN3F5MYAAAAN1Tc2E6b2Z2iKSnSfq8pNPc995Ad1+beccAAACwuDpWEwMAAAAToyZuJSYwAAAALL7/LqmQdJak/czsREk/K+kaSRe4+2Xz7BwAAAAAAAAAAHVgAgMAAOgWV/0zawfNHW5mFw0Nux9R7wr38oDqcX9Jl0s6YPPqzewNkp7l7v2G+wEAAIA2aK4mBgAAANqBmri1mMCAPQVfPIu+lFFe8E8pVg5/vohygljRT3fEglixHsTWgjYz84p+YsMl2drwmK0HOVF7wXYrarNMx7QevAlBXtTPKE9lsA2pvH66j0OuvD7muqLtDvI8vW2eOyaR1PYF7YVjEjCzdLDXS8dWg8PP6rb0+ratpvOCmAfr80Ser6b776tFOtYLYivpWNlLj6UXmbGwzWRISqRFOTntTRVbPnepHl8m6eOSni9pp6QHSvorSb8j6QeSTp9D34B2Mkvu68tgP1+upHdOcSzdlVTMgxwPDrPZsdz9fHZeuv5I5uUeG4J1WRQLfgTFsXRX8tucPFYEOY3Egh+GTbQZKRI/NqN1NaEMvgRlsG3RfaHK4EtXKF3zrym9A+gl8tainUagiXEuvf7isB/twJL9mDxnsK68/qfWx3lTALVwl+1ekLsRpgqo3H94igqytuvyti2Q6JybReeCZyzqZ+3iHzrpWHC+NMwLzqWG51mj87rR+dLEb/pmztsmQyPOswZtZp5nzSqzcz92nAvGmJjAAAAAuqeZe5tdMs2VFsxsp6SDJkh5p7s/sfrzxs+aqyWd7O63VH+/wMxOkfQFSc8zsz9y9925fQQAAECHcL9fAAAALDtq4lZiAgMAAOiezAuYNOxySbsmeP1Vm/58XfX40U2TFyRJ7v5FM7tC0iGS7ivpi1P1EgAAAN2wmDXxVMxsu6SnSjpV0r0l7SPp25L+QdKr3P1bc+weAAAAFk0Ha+JlwAQGAACAGXD346ZIv1TS8ZJ+lIhvTHDYd4p1AAAAAAvLzFYknS/paEmXSHq3pFslPUDSMyX9TzM7yt2/Nr9eAgAAAJgWExgAAEDnWPcuDXa+Bidl77c1UP0vtPtUf905wz4BAABggXWwJj5Zg8kL50s63t1/8v/pzOylkl4s6fmSnjKf7gEAAGDRdLAmXgrFvDsAAACAkc6T9E1Jv2JmD98Se5Gk/SV90t2/O/OeAQAAALNx7+rxw5snL1TOrR4PnGF/AAAAADSAKzAAAIBucR8sdbc5R+6+28xOlfQxSeeZ2QclfUuDy+U+RNIPJP3mHLsIAACARdLBmljSV6vHR5rZ67ZMYjihevz4jPsEAACARdXNmngpMIEBe4q+d1vntm9iubH+8BVaP51TJHIkqVgP8qLYWrpNWw/WF+QVa+kNt/V0rEjFghzrpwcsWpfWg4Euo/XV32YU8ygvte3RQSQYL5XpPI/ygvWFecH6tNd/KNkcmvwgaYVFwXSoF1ysZ3U1nbctiAV5UZtaTR+2PDvWSzyf3u5UjiSVUV4v/R74SmZeuivy4K3z4POQynOLPkPBuoJYdt4Scvd/NLMjJb1E0sMk3VHS9yS9SdL/cffvzLF7QOt4IZXbhu/won15uS29cypX8mKeOEyFOdH+P/fYEOYFtU72sSgdU2J9UT9SOZLC440s+C0Q9NGCvCLoS+bhNF5fIpbdXvDDMLWuQSz4nZOZF+kFbc7SWvAlKIN3oR98CXrhWKZjveB3SZS3puHb0AtPEgQW460ZqR9+SyZXhju2uvsxt2L5cDO7aFjA3Y9oeN0flvQBSf9V0pfN7OOSdks6QtKDJL1e0p833AegW9ylteCkaVdFBVnbdXnbZqwtIxn2M3X+L/qcFHnnKKM2vRf8aIzOiQaxMjg/m30ONjFe8XnbZGjEb+XJz81OFcv+IVpjDjABJjAAAIDuyZjk0wbu/jVJj593PwAAANACHauJ3d3N7BRJL9bgNmo/vyl8vqR3uXvwPwgAAACwdDpWEy8LJjAAAIDu4VJeAAAAWHbN1MSXTHOlBTPbKemgCVLe6e5PrHL3kfR2SY+U9HRJ50q6WdLRks6Q9Ckze5y7n5vbPwAAAHQM54lbiQkMAAAAAAAAAGbhckm7Jnj9VZv+/PuSHifp2e7+V5ueP6+6MsPFkl6nwcQGAAAAAC3FBAYAANA9zKwFAADAslvAmtjdj5si/YTq8RND2v2imV0r6SAzO8Ddr5liPQAAAOiKBayJMVox7w4AAAAAAAAAwAjbq8cDtwbMbLuk/aq/7p5ZjwAAAADUjiswAACAbnHVP7OWiboAAABok27WxJ+WdD9JLzCzz7j7rZtip2twnvPz7n7DPDoHAACABdPNmngpMIEBY7MyM9ZPx4r1yZ4fHUvvOYq1dMwy84rd6Y0r1tODYlFsbXibUY7Wg0Hup2MW5gXrK4NYsD4P28zbhmSbTfTR0zEvg6NWkJd98DRLh3q94YHU85JsJX04sG3b0v0I81bTeavpPF9J9zPMW03nebDtvjr8YkRheyvp8fdeOlaGeclQHCuCNtMheXANpmRe1F4Qy87L5lL0ncxtE0C3mKm/ffgONtpf91eD/Xxw6OsHsTJxeIv2/6kcSSpzjym99L4uzIv25UXQZnQ9wFQsc11RzKI8y8uzKC+IFWEsGUq2GbdXfx/bYC36MEeCkj4akzL40BZBfRHmBV+eMvpxHmx7kchbS7emXsfro364w5lcGe70gn4k8kb/lOxkTfxySSdKOk7SJWb2UUm3SDpa0gOrPz97ft0DWshdfuuto19XF2vBBaGjomtJWXAeEjWKxrkIvjvh+5OIBTneC9YVnLeNz78GNfhKUNsGsegcrGfmpc4FhOdRo3OzYSzdZvj+ZJ6DzT0/m3PuNm4v+mE7+bpG62RNvBRaUDEAAAAAAAAAWGbufqWk+0t6laRdkp4s6RmS7irpTEn3d/d/mlsHAQAAANSCKzAAAIDuia58AgAAACyDDtbE7v4DSc+vFgAAACDWwZp4GXAFBgAAAAAAAAAAAAAAMHdcgQEAAHTP6JsCAwAAAN1GTQwAAIBlR03cSkxgAAAA3eKSypoLU+pcAAAAtAk1MQAAAJYdNXFrMYEBe7Dgi2fBbWKsn44V6+lGbX3ynGItiO2O8tIb0NudjlmQV+xOb3iUZ/0oLxFbD3KCWJSn9cQbIMnL4A0P+q9+Xp6HbUZ5ifUF9zUK1zXr2XhFLxmyXhQL7gC0ujo8ZyXY5QcxW0n3I8rTajrmYZvpmK8GsZX0mHgwXqk2fcWSOWWwrjLI814QK3JjyVCYpyCUyovWFbVXeyzKAYAxuUn97cN3KNG+vFxNx/pBzINDZmp95fBD+sj2wmNDcAiOjylRm+n6KTx2FFFeIhbkRMcHy81Lh2TBj6dZx4pELPX8NLFIbl4ZfFDKoM21MvhAJ5pcUfq3wJqC9gJFcAar9PSnKBqvMvj0hevLLJSK8MuaWFd0kqDD+hljNUrO++YUxQDqULq0e23evRiIzmEsClvOO3KHFV4b3rdclrltweckPKcbKYK86Lxn6jxrcN45PDcbndsM24zOpUbndKPf2Hl5Oeduw3Ozub+xw3OzuW0G/az5/GzYXhM4T7x0mMAAAAA6xhuYjMTUWgAAALQJNTEAAACWHTVxWy3nlEEAAAAAAAAAAAAAALBQuAIDAADonlnfDgYAAABYNNTEAAAAWHbUxK3EFRgAAAAAAAAAAAAAAMDccQUGAADQPcysBQAAwLKjJgYAAMCyoyZuJSYwAACAbnFJZVl/mwAAAEBbUBMDAABg2VETtxYTGLCn4HtsQaxYrzdWrKX3AMV6EFtLd7K3Ox0rgpit9YNY1Gaw4etRm4m8fjonas/Xo34EsWB9nurjqLx+8CHydMzL4IgQ5GUxC2Lpu+5YrxfEgrv1hHnpmFaD3XcxPM9WgvZWgvaCPA/bDPKibVtJj5fnxoL3wFeGv+dl0F6ZyBmsKy8Wt5kMyYsgL/joRTElmvTg69FMLAgCwLQKqb99+M6wDA6L69uDffm2dF65GuStJp4P+hHu44O8speuq6LjTXTzwbAv4fqCGi81XEWQE8XCEi+dZ0XwOyFqM4qlQzILfusEsVSbUXtNKIMDexgLRqUf5BVB3lqZ+EAHn9ci+p85UUkf/CYpgw9DEZz5isYr+ixEYxmJ+lL3upZVPyzAAWA+3F2+e/e8uzF7RQP7ZM5hTCbzPbCccQ7OnUXnexWcxwvP6UbbFp4TDWJBm+H52cQ50fDcbHRuM/v8axCLzm2G68s8PxueSx0ea+bcbF5e/IMyLxadn03/2Ky/H8BmTGAAAAAd4w1cGoyptQAAAGgTamIAAAAsO2ritmL6NwAAAAAAAAAAAAAAmDuuwAAAALqn9pm1AAAAQMtQEwMAAGDZURO3EhMYAABAt7iksubClDoXAAAAbUJNDAAAgGVHTdxa3EICAAAAAAAAAAAAAIAWMLOjzOwjZnatmd1sZl8ys+eYWa/JtszsIWb2N2b2FTO7xsx2mdkVZvZ3ZnZcPVvHFRgAAEAHuZfz7gIAAAAwV9TEAAAAWHZdrInN7CRJ75e0S9J7JF0r6URJr5F0tKTHNdjWsdXyWUkXSLpJ0j0lPVrSiWb2h+7+otxt28AEBuyh6FsyZutB3lr6minFWjqvt3t4Xi9qL5EzaC+9IyrCWD8Zs93pDbe1dJ7Wgrz1jLz1dHsexNQPds79dD88iIV5ufcTsvQFYcL5YsXkuzGz9OdcvWBlRdTH4II2YZvpWHabK4lY0H9P5YzIS65Lkq8E6wvbTMfKqM1e+n0N+5LIK1eC9qJ1FVFeMiQPhiRsM8wLYsH3IJkXfHVmHgOAKbmZ1vdJHAOC/XW5LR3rb0vvuMrVoC+JciY6bpRBCeS9dD2WfSwK2gyv65cdS6wvyLFUzqhY0I2obDQL2gxiRRgLOpPBPa/BMsgLY8EbVAa/E8pgoMvggxn81NSqhv8OWgu+4KtF+nfOepAX9b8Iri/aC06k5bYZvT/RZy+15T0L+hjtUAJR/9ugnHGR2k98B5xiGUAdvFR5662zW19w/m9RWN0F2egVzm5dmdsWnksN1xdsWxmcs47yom1IjWXmOVaL+pFzblaKz89G/cw9P5s4h+lR/3PPsYbnRDPP6WbGyiAW/aZMlbe552ajH5TxedsoFrQZ5qVjUVmZ+ZMyyyzX1WZmtp+kN2vwM+4Yd/+X6vkXaTCh4BQze4K7n91QW69099OHtHV3SV+Q9AIz+0t3v3qa7Vz8igEAAGAiPri3WZ1Ly0+0AwAAYNlQEwMAAGDZdbImPkXSgZLO3phwIEnuvkvSC6u//nZTbVWxvbj7lZIu1GDuwb3HXH8SV2AAAADdk3s1GAAAAKArqIkBAACw7LpXEx9bPX50SOxTkm6WdJSZbXf3UZdZqq0tM7uLpF+UdKukS0esdyQmMAAAAAAAAAAAAAAAMNrhZnbRsIC7H9Hwug+rHr8+ZN3rZnaFpH+vwVUQ/rWptszsSEknaDDX4B6SHi1pP0nPdPcfjr01CUxgAAAA3eKK76WY2yYAAADQFtTEAAAAWHbdrIn3rx5/nIhvPH/Hhts6UtJLNv39BklPdve/GWO9IzGBAQAAAAAAAAAAAACA0S6Z5koLZrZT0kETpLzT3Z84bvPVYx1TLZJtufsbJb3RzPaRdC9JT5P0djM72t2fNu2KmcAAAAC6p3v3NgMAAAAmQ00MAACAZbeYNfHlknZN8PqrNv1546oI+w97oQa3cdj8usjUbbn7Lg1uL/FsM9su6bfM7OPu/r4x1p/EBAbsKfgeW3CVlTDWj/KGrzDKKfrpTqbakySFsWADop1bE7EUs3Ss15u8PUkq0m1a1KanxyvoZTOsGP58sG3hWKbaG9GmFVFeZqyXl+epvGhdK+n323vp7fbocxLlrQT9D8Y5uW2SfCXIC9osE3nhdkd9DI6sZdhmOi8/lrm+RFrq+dz2BrGZ7zUAQNJgv7V2u1QsOG6sBm1Gx4Ag5onDaZizkq4nw7xof91Lt5mfF/3ACGKpvCgnt/wL2syNzVpOT8rgAF0EgxnllcFAh3lBbF3pD190QqNMvT/BYK2V6dp2tQh+pEZfEEU/lqMvVt5lTkult6EINr6X6GeZ2kGNUATfj2AkMUTq+7E4eyAArTfLf9jxGR4FMs83ZHcxOq6HaRnH/Nzzl9GYROcNM/MsOrcZbUOUF5yLTG5fdP5yludmp1ifh+d1o74kxiRorwzaiz5f8fnSes/bjsoLfkJktdnE+dfwH1JmHcuQfb43sx/R+trI3Y+bIv1SDW7fcKikizYHzGxFg6shrEv65ozbkqTzJP2WpGMkTTWBIe+oCgAAsKBcLi/LehdOEQMAAKBFqIkBAACw7DpaE19QPT5iSOwhkm4n6UJ3v3XGbUnS3avH9TFfn8QEBgAA0C2uwf8gqXWZ90YBAAAAE6AmBgAAwLLrZk38Pkk/lPQEMzty40kz20fSH1Z/fcPmBDPb38wON7O71dDWQ832voyOmR0i6bTqrx+eeKu24BYSAAAAAAAAAAAAAAAsMHe/3sx+Q4PJBzvM7GxJ10p6tKTDquffsyXtZElvk3SWpCdN2da5kn5kZp+V9G0N5hocosFVHFYkvd7d/2Ha7WQCAwAA6J5y/lNhAQAAgLmiJgYAAMCy62BN7O7nmNlDNbjiwWMl7SPpMknPk3SGu4+90RltvUTS8ZJ+SdKJknqSvifpHEl/7e5/P8Wm/QQTGAAAAAAAAAAAAAAAaAF3/4ykR4352jMlnVlTW6+T9LpxXjsNJjAAAICOccnL+tsEAAAAWoOaGAAAAMuOmritmMCAPXgRxHrpWLliQSz9ZU7llavpdVk/vS6V6Q0Iuq8y+CoUFqwviFmR7ov3+uk2V4fvTK2f3slaGeyAgzxFV5EZ/woze4r6kisYy6TofcvN6wX9yPyceNRmtN1BnqfyekE/wnVFeUFsJepjNM7B/iTc7nSTcV8Sz0fbHe0Pw/FK54VjGealY4q+BkEs2WYD6wrl5rnkdV8abAHqUjPbLumpkk6VdG8NLuf1bUn/IOlV7v6tOXYPaB0vpPXbJXY00T4yPAbE65u0TQ/q6KgfuTV9nBfsCKPjQ83HjrjkCvqYG8sU9iUQHb6i3zPp9oLfK0GsjH7nRHlRLPgwlJm/PcrgQ7SW+EKuFsFvsaAbqfYkqbD0b6Be0Mci2O7oPSiCjvaU7kv4/mT8fiqCz3k//Cw38Jux5frhzjJTR2tiAHUz2UpH/4nAGti3RuezAhYdZ6Nzcqm8ICdeV1RMR+co8857qpeun8J+BnlZ525zxlgzPm8rzfTcbRPnbeNzm9G/H+XlReVTbl+S54mjdUXnD3LOv6qZ88RRX7LO6y7SueAINXFrNXAUBwAAQJ3MbEXS+ZL+XNIdJL1b0hslfV/SMyV90cx+fn49BAAAAAAAAABgeh2dXgkAAJZa7ZcGm7uTJR2twSSG491v20Aze6mkF0t6vqSnzKd7AAAAWDjdq4kBAACAyVATtxJXYAAAAFh8964eP7x58kLl3OrxwBn2BwAAAAAAAACA2nEFBgAA0Dm139ts/r5aPT7SzF63ZRLDCdXjx2fcJwAAACywDtbEAAAAwESoiduJCQwAAKBjvIFLg7kkHW5mFw2Nuh9R8wq3+rCkD0j6r5K+bGYfl7Rb0hGSHiTp9ZL+vOE+AAAAoDUaq4kBAACAlqAmbitzZ6CXiZldY6urd179d3cZHu9bOjf4jkcxhXnDP38WfCzDdQWf56jNcH8TfUey15fxvQtToj5OvqopExdE+rM8+yaDxNw2LZ2YfOfCdc22j7ltehN9yVlXdj+C9WXmZa8wpy8NbHeOXdd9T76+dq27H7DXqswuKtS7/+11h1rXeZNuUKn+zZIuGRafwQQGmZlJerGkF0nqbQqdL+mF7v7PTfcB6Aozu8ZWVu+8/c7/LvGCvHbzj1MTPt9YP6IiPK/JusfEoiNm9rE7qOmjtOgwG4xlfjlTb5uL1Mfc9zXuZ+K3ZtiPKJj3+yj/KzDb9eVsXwO/uDCBa664Qeu7+vOoib8wi9oXQPPM7JpCvTvfXvvNuyvNaORAtSjnG4Nz+Nnryty2RWqz5rGc6XnbkeuruZ8tP287yEuHaj/Pmruu7H7UfE53qr7UmDNCzmfo1mvndp6YmrhhXIFh+Vzva2va/Z0rd867Iy10ePU49B+vEGLs8jF2+Ri7fIs+dgdLuj4Ru6RUXzfoR02s9xJ3/7XcZDPbKemgCVLe6e5PrHL3kfR2SY+U9HRJ50q6WdLRks6Q9Ckze5y7n5vbP2DJXO/ra9r1/e/snHdHWmjRjxGLjLHLx9jlY+zyLfrYHaw51cRNNApgLq4f7Cuu2znvjjSi2f+bVd8xou3/h2xyi358XWSMXT7GLt+ij93BoibuJK7AAIxp47LhzKqaHGOXj7HLx9jlY+yaYWbnS7r7BCl/5+6/V+WeLuklkp7t7mdsafc/SrpY0rfc/eBaOgsACRwj8jF2+Ri7fIxdPsYOAJDCMSIfY5ePscvH2OVj7DAvXIEBAABgBtz9uCnST6gePzGk3S+a2bWSDjKzA9z9minWAwAAAAAAAADA3BTz7gAAAABG2l49Hrg1YGbbpZ/ctHT3zHoEAAAAAAAAAEDNmMAAAACw+D5dPb6gmrCw2ekaXFXr8+5+w0x7BQAAAAAAAABAjbiFBAAAwOJ7uaQTJR0n6RIz+6ikWyQdLemB1Z+fPb/uAQAAAAAAAAAwPa7AAAAAsODc/UpJ95f0Kkm7JD1Z0jMk3VXSmZLu7+7/NLcOAgAAAAAAAABQA3P3efcBAAAAAAAAAAAAAAAsOa7AAAAAAAAAAAAAAAAA5o4JDAAAAAAAAAAAAAAAYO6YwAAAAAAAAAAAAAAAAOaOCQwAAAAAAAAAAAAAAGDumMAAAAAAAAAAAAAAAADmjgkMAAAAAAAAAAAAAABg7pjAAAAAAAAAAAAAAAAA5o4JDGgdM7uHmb3VzK4ys1vNbKeZvdbM7tR0O2Z2lJl9xMyuNbObzexLZvYcM+sFOaea2efM7EYz+7GZ7TCzE4a8btXMTjazt5jZV8zs+modXzazl5nZHSbZvrq2ua52mhy7RO6hZnaTmbmZvWOS7Uu01/mxM7ODzewNZvZNM9tlZteY2WfN7Hcn2cZpt7eudmYxbmb2C2b2TjO7zMxuMbMrzewTZvZ4M5vqGNuWsavaP83M3luNQ1l9735uRL/2NbOXmtml1eft+2b2t2Z230m2DwCWVVuOE5tyqIlFTTxNO7MaO6Mmpia+LYeaGAAWXFuOE5tyqIlFTTxNO7MaO6Mmpia+LYeaGPPh7iwsrVkkHSLpe5Jc0jmSXinpgurvl0g6oKl2JJ0kaV3SjZLeIulPq9e6pPcm1vNnVfzbkl4j6S8kXVM994wtrz28ev5GSf9X0h9Xr7+sev5SST/N2O09dkNyVyR9VtIN1evfwecuHjtJvyLpJkm3Snq/pFdIer2kj0n6R8Zt73GTdKKktWrM3lv166835bx5GT5zkh5TxUpJl0u6rvr7zwX92i7pH6vXfV6D/d27qvG8SdIvTvOdZWFhYen60qbjRJVDTTyDsRuSS01MTUxNPKOxEzUxCwsLy8yXNh0nqhxq4hmM3ZBcamJqYmriGY2dqIlZalzm3gEWlkkWSX9f7cieueX5V1fPv7GJdiTtJ+n71QHoyE3P7yPpwirnCVtyjqqev0zSnTY9f3B14Nol6eBNz99d0u9Iuv2WdrZJ+lDV1usZu73HbkgfX1yt71mqpzDt9NhJurcGRfy/STp0SL9XGbeh4/bVKuehW56/q24rBu+5BGN3D0kPlrRf9fcdGl2Y/kH1mvdKKjY9f1L1/Fc3P8/CwsLCsufSsuMENfGMxm5IH6mJqYmpiWc3dtTELCwsLDNeWnacoCae0dgN6SM1MTUxNfHsxo6amKW2Ze4dYGEZd6kOni7piq07LEl30GAW2E3aUtjV0Y6kp1Q5Zw1p79gq9sktz7+9ev7JQ3JeVsVeOua2bxw0v8zYxWMn6UgNZue9UNIxmrIwXYax25Tzq7njtKTjdoukHyf6/XdVzhFdH7shr9uhoDCVZJK+Vb3mXkPin6piD6vr88jCwsLSpaVtx4mcY2zQZ2riMcdO1MTUxNTEMx27Ia/bIWpiFhYWlsaWth0nco6xQZ+picccO1ETUxNTE8907Ia8boeoiVkyl6nuuwLM2LHV48fcvdwccPcbJH1G0u0k/VID7WzkfHRIe5+SdLOko8xs+5g55215zShr1eP6mK/fainGzsz21aDAuFiDSyDVodNjZ2arkk7RYDblR8zsgWb2XDP7X2Z2gpltG7FdKZ0et8pXJe1nZg/a/KSZ3UXSAyVdJelrQ9obpW1jN6lDJN1T0tfd/Yoh8Un3jwCwbNp2nKAm3jOHmnjydqiJF3TcKtTEeaiJAWA6bTtOUBPvmUNNPHk71MQLOm4VauI81MRIYgID2uSw6vHrifg3qsdDG2gnmePu6xrMXFvRYCabzOz2Glzq60Z3v3qKvm54SvU47GAxjmUZu1dW7ZxatV2Hro/d/STtK+krks7W4J5wr5b0JxrcY+8bZvaA5FaldX3cJOm5kq6X9HEze4+ZvcLM3qxBwXqDpMe4+y2pDQu0Zuwy1bV9ALCsWnOcoCamJq6pHWrixR03iZo4FzUxAEynNccJamJq4praoSZe3HGTqIlzURMjaWXeHQAmsH/1+ONEfOP5OzbQzqQ5dfVVZvZoSb8l6TsaFAs5Oj92ZnacpGdK+n13z5nNmNL1sbtL9fhQDS519euSzpH0U5KeLun3NJhxe193/2Gi3WG6Pm5y90+b2S9L+ltJ/21T6AZJb5P05UR7o7Rp7HLMYh0A0GVtOk5QE+fnUBPn51AT5+VQE9e/7gg1MQBMp03HCWri/Bxq4vwcauK8HGri+tcdoSZGEldgQJdY9ehzaCd33eHrzewoSe/S4P5Dj3X36yZsf1ytHjszu6MGhcBnJb1qwnam1eqxk9Tb9PgH7v5Wd7/W3f/N3f+3pA9I+mlJvzHhOkZp+7jJzB4u6dOSrpR0hKTba3DZq7+W9HJJ55tZExMF2zh2k5jFOgCgy9p4nKAmpiaeph1qYmriWbdDTQwAi6+NxwlqYmriadqhJqYmnnU71MRoFBMY0CYbs632T8T32/K6OtuZNGfU60fNLFM1Y+88SaWkR7j751KvHUPXx+7VGhRPT3L3fiIvV9fHbvOPnQ8Oydl47oGJNlM6PW5mdmdJ79FgNvLJ7v4Fd7/Z3b/p7s/TYHbyUZKemGgz0qaxyzGLdQBAl7XpOEFNnJ9DTZyfQ02cl0NNXP+66+4XAOA2bTpOUBPn51AT5+dQE+flUBPXv+66+4UlwQQGtMml1WPqfjf3qR5T98uZpp1kTjVz7l6S1iV9U5Lc/SYNZtv9lJndbdK+mtmDJf29BjPLjnf3zyT6Oq6uj939Nbg/1yVm5huLpE9U8V+rnrs4tWGBro/dpZv+/KMhORuF676Jfqd0fdyOknQnSZ9195uH5Gx89o5I9DvSmrHLVNf2AcCyas1xgpqYmrimdqiJF3fcqInzURMDwHRac5ygJqYmrqkdauLFHTdq4nzUxEhiAgPaZGNHf7yZ7fHZNbM7SDpag1lu/9xAOxdUj48Y0t5DJN1O0oXufuuYOY/c8prNfThWgxm165Ie7u6jtmccXR+7D0h6y5DlI1X88urvHxi6VbFOj527Xyvp4uqv9xuSs/HcziGxSKfHTdL26vHARL83nt+diEfaNnaTulzSv0k61MzuNSSe3D8CACS17zhBTTxATZzfDjXxgo6bqImpiQFgftp2nKAmHqAmzm+HmnhBx03UxNTEaIa7s7C0ZtFts02fueX5V1fPv3HTc6uSDpd0yDTtVM/vJ+kHkm6VdOSm5/eRdGGV84QtOUdVz18m6U6bnj9Y0jWSdkk6eEvO8ZJulvRDSf+ZsRt/7BLbfEzVzjsYu/Bz99Qq5+OS9tn0/D0kfbeKHcO43TZukn5G0pqkvgaz3ze39bOSvl+196iuf+aGrHNH9bqfC17zB9Vr3iup2PT8SdXzX938PAsLCwvLnkubjhOTHmOrGDVx5tgltvkYUROP87mjJqYmzh67IevcIWpiFhYWlkaXNh0nJj3GVjFq4syxS2zzMaImHudzR01MTZw9dkPWuUPUxCyZy9w7wMIyySLpEEnfq3Zc50h6hQazr1yDy80csOm1B1fP75ymnU05j9FgtuuNkv5a0p9IumTTztWG5Lyqin9b0msk/YUGRadLesaW1x6mwSw3l/Q+SacPWxi7vccu2OZjVE9h2umx0+BqPB/c1I8zNJiJfE313OsYt6Hj9uIq1pd0rqQ/lnSWpBuq5z+wRJ+5MzctGz9m3r/puQdtef12SZ+pXvd5Sa+U9C4Niv2bJP3iNN9ZFhYWlq4vLTxOUBPPYOyCbT5G1MTUxNTE1MQsLCwsHVtaeJygJp7B2AXbfIyoiamJqYmpiVlas8y9Aywsky4azFp7m6SrNbjszrckvU7Snbe8LrmznqSdLTlHa3C5qes0KCK/LOm5knpBzqnVjvem6oD1SUknDHndMVV/w4Wx23vsgvyNMZ2qMF2GsZO0IunZGlwm7GYNipLPSHoi4xaO20kaXMrvBxoUc9drMAP1t6P1dG3sNHrf9aQhOftKeqmkb2gwk/cHGhS+Pz/t95WFhYVlGZY2HSeqHGrihscuyN8YU2piamJqYmpiFhYWlk4tbTpOVDnUxA2PXZC/MabUxNTE1MTUxCwtWKz6cAAAAAAAAAAAAAAAAMxNMe8OAAAAAAAAAAAAAAAAMIEBAAAAAAAAAAAAAADMHRMYAAAAAAAAAAAAAADA3DGBAQAAAAAAAAAAAAAAzB0TGAAAAAAAAAAAAAAAwNwxgQEAAAAAAAAAAAAAAMwdExgAAAAAAAAAAAAAAMDcMYEBAAAAAAAAAAAAAADMHRMYAAAAAAAAAAAAAADA3DGBAQAAAAAAAAAAAAAAzB0TGAAAAAAAAAAAAAAAwNwxgQEAAAAAAAAAAAAAAMwdExgAYEpmtsPMvmxmjexTbeBiM/t0E+0DAAAA06ImBgAAwLKjJgaAejCBAQCmYGanSHqopJe4e9nEOtzdJb1E0oOq9QEAAAALg5oYAAAAy46aGADqY4P9HQBgUmZmkv5Vkkk63BveoZrZ1yT1ZrEuAAAAYBzUxAAAAFh21MQAUC+uwAAA+f6LpMMknTWjQvEsSYdKOm4G6wIAAADGQU0MAACAZUdNDAA1YgIDgKVjZjvNzIPlzDGb+vXq8T1D1vGkqq0nmdnDzezTZnajmf3AzN5mZnesXvefzexDZnZdFf87Mzs4sb6zt6wXAAAAyEJNDAAAgGVHTQwAi2ll3h0AgDl4raQ7Dnn+REn3l3TzqAaqy4IdK+m77n558NJHSzpB0ockvVHSUZKeJOleZvb7ks6X9GlJb5H0C1UfDjGzX9h6rzR3/5aZXSnpv5iZcXkwAAAATOG1oiYGAADAcnutqIkBYOEwgQHA0nH31259zsweLuk0SZdJevEYzRwm6UANCs7IoyUd5+6frNZTSPp7DS4r9hFJv+nu79zUj7dIeooGBeq5Q9r7vKTHSLqvpK+N0U8AAABgL9TEAAAAWHbUxACwmLiFBIClZ2b3k/Q+ST+W9Ch3/+EYafesHq8e8bp3bxSlklTNlv2b6q9f2VyUVt5ePf6nRHvf3bJ+AAAAYGrUxAAAAFh21MQAsBi4AgOApWZmd5P0YUnbJZ3g7t8YM/WA6vG6Ea/7lyHPXVU9XjQkdmX1eI9Ee9dWjz89Yr0AAADAWKiJAQAAsOyoiQFgcTCBAcDSMrPba3Bpr5+V9Gvu/ukJ0m+pHvcZ8bofD3lufYzYaqK9fbesHwAAAMhGTQwAAIBlR00MAIuFCQwAllJ1j7F3S7q/pNPc/d0TNvH96vGA8FX121jf98NXAQAAACNQEwMAAGDZURMDwOIp5t0BAJiT10o6UdJb3f2PMvK/Kqkv6fA6OzWGwyWVkr484/UCAACge14ramIAAAAst9eKmhgAFgoTGAAsHTN7jqRnSjpf0tNy2nD3H0u6WNJ/MLN9R7y8Fma2XdJ/kvT/3P1Hs1gnAAAAuomaGAAAAMuOmhgAFhO3kACwVMzsrpJeJck1mJ16mpltfdnF7n7OGM29X9IRko6V9OEau5lyjKRt1XoBAACALNTEAAAAWHbUxACwuJjAAGDZ7KPbrj7znMRrzpJ0zhhtvUXS6ZL+p2ZTmJ4qaXe1XgAAACAXNTEAAACWHTUxACwoc/d59wEAWsvM/kqDgvFgd/9ug+u5i6Sdkt7l7k9taj0AAADApKiJAQAAsOyoiQGgPsXolwAAAi/WYLbraQ2v5wWS+pJe1PB6AAAAgElREwMAAGDZURMDQE2YwAAAU3D370l6oqSrzKyRfaoNbr52taT/4e5XN7EOAAAAIBc1MQAAAJYdNTEA1IdbSAAAAAAAAAAAAAAAgLnjCgwAAAAAAAAAAAAAAGDumMAAAAAAAAAAAAAAAADmjgkMAAAAAAAAAAAAAABg7pjAAAAAAAAAAAAAAAAA5o4JDAAAAAAAAAAAAAAAYO6YwAAAAAAAAAAAAAAAAOaOCQwAAAAAAAAAAAAAAGDumMAAAAAAAAAAAAAAAADmjgkMAAAAAAAAAAAAAABg7pjAAAAAAAAAAAAAAAAA5o4JDAAAAAAAAAAAAAAAYO6YwAAAAAAAAAAAAAAAAOaOCQwAAAAAAAAAAAAAAGDu/j/ltCsc0B9H8wAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 277, + "width": 1048 + }, + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Method 3\n", + "plot_plane(IDAT[3]['xz_plane'])" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "utility-yacht", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.4142942337258546e-06" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Max relative difference 3 vs 1\n", + "np.abs(IDAT[3]['xz_plane']['Ez']/IDAT[1]['xz_plane']['Ez']-1).max()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "latest-dylan", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.001019045432372e-09" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Max relative difference 2 vs 1\n", + "np.abs(IDAT[2]['xz_plane']['Ez']/IDAT[1]['xz_plane']['Ez']-1).max()" + ] + }, + { + "cell_type": "markdown", + "id": "connected-single", + "metadata": {}, + "source": [ + "# Cleanup" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "optional-prototype", + "metadata": {}, + "outputs": [], + "source": [ + "# Cleanup\n", + "!rm *in\n", + "!rm *dat" + ] + } + ], + "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.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}