From ba8c43cb3f75e16dc660f7b236fb00d2cb1a477e Mon Sep 17 00:00:00 2001 From: yony <yony1018@foxmail.com> Date: Mon, 25 Dec 2023 01:28:24 +0800 Subject: [PATCH] update with new data processor --- README.md | 3 +- models/ANN.py | 36 ++- options/base_options.py | 22 +- options/test_options.py | 5 +- options/topopt_options.py | 26 +++ options/train_options.py | 6 +- test.py | 43 ++-- topopt_EMsFEA.py | 466 ++++++++++++++++++++------------------ train.py | 51 +++-- utils/data_loader.py | 55 ++++- utils/mesh_reshape.py | 28 +++ utils/topopt_88.py | 14 +- utils/visualization.py | 35 +++ visualization.ipynb | 404 ++++++++++++++++++++++++++++----- 14 files changed, 841 insertions(+), 353 deletions(-) create mode 100644 options/topopt_options.py create mode 100644 utils/mesh_reshape.py create mode 100644 utils/visualization.py diff --git a/README.md b/README.md index f77e31c..0387483 100644 --- a/README.md +++ b/README.md @@ -33,6 +33,7 @@ python test.py ``` python topopt_EMsFEA.py +# 参数详见options/topopt_options.py ``` ## 数据集 @@ -40,8 +41,6 @@ python topopt_EMsFEA.py > > Download from: > -> http://118.195.195.192:3000/GyeongYun/EMsFEA-net/raw/branch/resources/checkpoints.zip -> > http://118.195.195.192:3000/GyeongYun/EMsFEA-net/raw/branch/resources/datasets.zip mod1:  diff --git a/models/ANN.py b/models/ANN.py index 34cfdb0..e2aedec 100644 --- a/models/ANN.py +++ b/models/ANN.py @@ -3,42 +3,36 @@ import torch.nn as nn import torch.nn.functional as F class ANN_Model(nn.Module): - def __init__(self,input_features=8,out_features=72): + def __init__(self,in_dim=25,l1=36,l2=36*2,l3=36*2,l4=36*4,l5=36*4,l6=36*8,l7=36*8,l8=36*16,out_dim=36*2*4*2): super().__init__() - self.fc1=nn.Linear(input_features,12) - self.fc2=nn.Linear(12,16) - self.fc3=nn.Linear(16,20) - self.fc4=nn.Linear(20,25) + self.fc1=nn.Linear(in_dim,l1) + self.fc2=nn.Linear(l1,l2) + self.fc3=nn.Linear(l2,l3) + self.fc4=nn.Linear(l3,l4) - self.fc5=nn.Linear(50,60) - self.fc6=nn.Linear(60,70) - self.fc7=nn.Linear(70,80) - self.fc8=nn.Linear(80,90) - self.fc9=nn.Linear(90,100) - self.fc10=nn.Linear(100,90) - self.fc11=nn.Linear(90,80) + self.fc5=nn.Linear(l4,l5) + self.fc6=nn.Linear(l5,l6) + self.fc7=nn.Linear(l6,l7) + self.fc8=nn.Linear(l7,l8) - self.out=nn.Linear(80,out_features) + self.out=nn.Linear(l8,out_dim) # -> 576 def forward(self,x): - density=x[:,:25].reshape(x.shape[0],25) - displace = x[:,25:] - x = F.relu(self.fc1(displace)) + density = x[:25] + displace = x[25:] + + x = F.relu(self.fc1(density)) x = F.relu(self.fc2(x)) x = F.relu(self.fc3(x)) x = F.relu(self.fc4(x)) - x = torch.hstack((density,x)) + # x = torch.hstack((density,x)) x = F.relu(self.fc5(x)) x = F.relu(self.fc6(x)) x = F.relu(self.fc7(x)) x = F.relu(self.fc8(x)) - x = F.relu(self.fc9(x)) - x = F.relu(self.fc10(x)) - x = F.relu(self.fc11(x)) - x = self.out(x) diff --git a/options/base_options.py b/options/base_options.py index 9c711a9..caf7e8f 100644 --- a/options/base_options.py +++ b/options/base_options.py @@ -1,5 +1,6 @@ import argparse import os +import time from utils import utils import torch @@ -24,6 +25,7 @@ class BaseOptions(): parser.add_argument('--device', type=str, default='cuda:0', help='generate device with gpu_id and usable user device') parser.add_argument('--checkpoints_dir', type=str, default='./checkpoints', help='models are saved here') parser.add_argument('--ms_ratio', type=int, default=5, help='multiscale ratio') + parser.add_argument('--results_dir', type=str, default='./results', help='saves results here.') # model parameters parser.add_argument('--model', type=str, default='ANN', help='chooses which model to use. [ANN | CNN | AutoEncoder]') @@ -31,9 +33,9 @@ class BaseOptions(): # parser.add_argument('--resolution', type=str, default='180_60', help='data resolution. nelx_nely here') parser.add_argument('--nelx', type=int, default=180, help='num of elements on x-axis') parser.add_argument('--nely', type=int, default=60, help='num of elements on y-axis') - parser.add_argument('--nelz', type=int, default=1, help='num of elements on z-axis') + parser.add_argument('--nelz', type=int, default=0, help='num of elements on z-axis') parser.add_argument('--dimension', type=int, default=2, help='dimension of dataset models') - parser.add_argument('--is_standard', type=bool, default=False, help='whether need standardization or not') + parser.add_argument('--is_standard', type=bool, default=True, help='whether need standardization or not') # additional parameters parser.add_argument('--epoch', type=str, default='latest', help='which epoch to load? set to latest to use latest cached model') @@ -80,12 +82,16 @@ class BaseOptions(): print(message) # save to the disk - expr_dir = os.path.join(opt.checkpoints_dir, opt.model+'_'+opt.mod) - utils.mkdir(expr_dir) - file_name = os.path.join(expr_dir, '{}_opt.txt'.format(opt.phase)) - with open(file_name, 'wt') as opt_file: - opt_file.write(message) - opt_file.write('\n') + if opt.isTrain: + curr=time.strftime('%y%m%d-%H%M%S') + expr_dir = os.path.join(opt.checkpoints_dir, opt.model+'_'+opt.mod+'_'+str(curr)) + opt.expr_dir = expr_dir + + utils.mkdir(expr_dir) + file_name = os.path.join(expr_dir, '{}_opt.txt'.format(opt.phase)) + with open(file_name, 'wt') as opt_file: + opt_file.write(message) + opt_file.write('\n') def parse(self): """Parse our options, create checkpoints directory suffix, and set up gpu device.""" diff --git a/options/test_options.py b/options/test_options.py index 0877495..ffe2971 100644 --- a/options/test_options.py +++ b/options/test_options.py @@ -9,10 +9,9 @@ class TestOptions(BaseOptions): def initialize(self, parser): parser = BaseOptions.initialize(self, parser) # define shared options - parser.add_argument('--results_dir', type=str, default='./results', help='saves results here.') parser.add_argument('--phase', type=str, default='test', help='train, val, test, etc') - parser.add_argument('--mod', type=str, default='mod3', help='chooses which dataset model for test. mod1....') - parser.add_argument('--pretrained_model_path', type=str, default='./checkpoints/ANN_mod1/ANN_mod1_opt.pt', help='pretrained model file load path') + parser.add_argument('--mod', type=str, default='mod2', help='chooses which dataset model for test. mod1....') + parser.add_argument('--pretrained_model_path', type=str, default='./checkpoints/ANN_mod1_231224-222338/ANN_mod1_opt.pt', help='pretrained model file load path') self.isTrain = False diff --git a/options/topopt_options.py b/options/topopt_options.py new file mode 100644 index 0000000..649b99a --- /dev/null +++ b/options/topopt_options.py @@ -0,0 +1,26 @@ +from .base_options import BaseOptions + + +class TopoptOption(BaseOptions): + """This class includes test options. + + It also includes shared options defined in BaseOptions. + """ + + def initialize(self, parser): + parser = BaseOptions.initialize(self, parser) # define shared options + parser.add_argument('--phase', type=str, default='topopt', help='train, val, test, etc') + parser.add_argument('--pretrained_model_path', type=str, default='./checkpoints/ANN_mod1_231224-222338/ANN_mod1_opt.pt', help='pretrained model file load path') + parser.add_argument('--mod_idx', type=str, default='mod1', help='mod_idx for identify save path') + + parser.add_argument('--nelx_to', type=int, default=180, help='num of elements on x-axis') + parser.add_argument('--nely_to', type=int, default=60, help='num of elements on y-axis') + parser.add_argument('--ms_ratio_to', type=int, default=5, help='multiscale ratio') + parser.add_argument('--volfrac', type=float, default=0.4, help='volfrac') + parser.add_argument('--rmin', type=float, default=5.4, help='rmin') + parser.add_argument('--penal', type=float, default=3.0, help='penal') + parser.add_argument('--ft', type=int, default=1, help='ft') + + + self.isTrain = False + return parser \ No newline at end of file diff --git a/options/train_options.py b/options/train_options.py index b25adf1..294498a 100644 --- a/options/train_options.py +++ b/options/train_options.py @@ -15,9 +15,9 @@ class TrainOptions(BaseOptions): parser.add_argument('--phase', type=str, default='train', help='train, val, test, etc') # training parameters - parser.add_argument('--epochs', type=int, default=10000, help='number of epochs') - parser.add_argument('--lr', type=float, default=0.001, help='initial learning rate for adam') - parser.add_argument('--mod', type=str, default='mod2', help='chooses which dataset model for train. mod1....') + parser.add_argument('--epochs', type=int, default=200, help='number of epochs') + parser.add_argument('--lr', type=float, default=1e-5, help='initial learning rate for adam') + parser.add_argument('--mod', type=str, default='mod1', help='chooses which dataset model for train. mod1....') self.isTrain = True return parser \ No newline at end of file diff --git a/test.py b/test.py index 97478d0..3b861ab 100644 --- a/test.py +++ b/test.py @@ -7,19 +7,22 @@ import torch.nn as nn import torch.nn.functional as F from utils.data_standardizer import standardization -from utils.data_loader import data_loader +from utils.data_loader import data_loader_new from options.test_options import TestOptions - +from utils.visualization import surf_plot def test(X, opt): - # OLD: model_load_path, X, standard = False, device = 0 - if opt.is_standard: - X = standardization(X) - X_test=torch.from_numpy(X).type(torch.float32).to(opt.device) model = torch.load(opt.pretrained_model_path) - return model(X_test) + + N=(opt.ms_ratio+1)**2 * 2 + pred=torch.zeros(X_test.shape[0], N) + for batch_idx, data_batch in enumerate(X_test): + pred_ShapeFunction=model(data_batch) + pred[batch_idx,:]=pred_ShapeFunction.reshape(N,8) @ data_batch[25:] + + return pred if __name__=='__main__': @@ -27,18 +30,27 @@ if __name__=='__main__': opt = TestOptions().parse() # Load datasets, mod2 as default - global_density, global_displace, coarse_density, coarse_displace, fine_displace = data_loader(opt) - X = np.hstack((coarse_density[:,:] , coarse_displace[:,:,0] , coarse_displace[:,:,1])) - Y = fine_displace[:,:] - + m=opt.ms_ratio + c_nelx=int(opt.nelx/m) + c_nely=int(opt.nely/m) + c_N=c_nelx*c_nely + global_density, global_displace, coarse_density, coarse_displace, fine_displace = data_loader_new(opt) + # X = np.hstack((coarse_density.reshape(c_N,m*m), coarse_displace.reshape(c_N,2,2,2)[:,:,:,0].reshape(c_N,4), coarse_displace.reshape(c_N,2,2,2)[:,:,:,1].reshape(c_N,4))) + X = np.hstack((coarse_density.reshape(c_N,m*m), coarse_displace.reshape(c_N,8))) + Y = fine_displace.reshape(c_N,(m+1)**2*2) + if opt.is_standard: + X = standardization(X) + Y = standardization(Y) + # Predict pred = test(X, opt) - + pred.to('cpu') + # Set loss function loss_function = nn.MSELoss() # Calculate loss pred_loss=[] - Y_test = torch.from_numpy(Y).type(torch.float32).to(opt.device) + Y_test = torch.from_numpy(Y).type(torch.float32).to('cpu') for i in range(pred.shape[0]): pred_loss.append(loss_function(pred[i,:],Y_test[i,:]).item()) @@ -58,3 +70,8 @@ if __name__=='__main__': plt.title("Show loss value in grid") plt.savefig(os.path.join(opt.results_dir, 'test_loss_in_grid.png')) plt.show() + + # Plot every mesh displacement for comparation + # for i in range(pred.shape[0]): + # surf_plot(pred[i].detach().numpy(),6,6,os.path.join(opt.results_dir, 'meshes', 'test_pred_mesh'+str(i)+'.png'),'u') + # surf_plot(Y_test[i].detach().numpy(),6,6,os.path.join(opt.results_dir, 'meshes','test_GT_mesh'+str(i)+'.png'),'u') diff --git a/topopt_EMsFEA.py b/topopt_EMsFEA.py index 8b1b388..b0c5f99 100755 --- a/topopt_EMsFEA.py +++ b/topopt_EMsFEA.py @@ -1,5 +1,6 @@ -from __future__ import division +# from __future__ import division import numpy as np +import os from scipy.sparse import coo_matrix from scipy.sparse.linalg import spsolve from matplotlib import colors @@ -11,251 +12,274 @@ import torch.nn as nn import torch.nn.functional as F from utils.data_standardizer import standardization -from utils.data_loader import data_loader +from utils.mesh_reshape import Ms_u_reshape +from options.topopt_options import TopoptOption - -def top_EMsFEA(nelx,nely,volfrac,penal,rmin,ft,mod_idx,m): - print("Minimum compliance problem with OC") - print("ndes: " + str(nelx) + " x " + str(nely)) - print("volfrac: " + str(volfrac) + ", rmin: " + str(rmin) + ", penal: " + str(penal)) - print("Filter method: " + ["Sensitivity based","Density based"][ft]) - # Max and min stiffness - Emin=1e-9 - Emax=1.0 - c_nelx=int(nelx/m) - c_nely=int(nely/m) - # dofs: - ndof = 2*(nelx+1)*(nely+1) - coarse_ndof = 2*(c_nelx+1)*(c_nely+1) - # Allocate design variables (as array), initialize and allocate sens. - x=volfrac * np.ones(nely*nelx,dtype=float) - xold=x.copy() - xPhys=x.copy() - g=0 # must be initialized to use the NGuyen/Paulino OC approach - dc=np.zeros((nely,nelx), dtype=float) - # FE: Build the index vectors for the for coo matrix format. - KE=lk() - edofMat=np.zeros((nelx*nely,8),dtype=int) - for elx in range(nelx): - for ely in range(nely): - el = ely+elx*nely - n1=(nely+1)*elx+ely - n2=(nely+1)*(elx+1)+ely - edofMat[el,:]=np.array([2*n1+2, 2*n1+3, 2*n2+2, 2*n2+3,2*n2, 2*n2+1, 2*n1, 2*n1+1]) - # Construct the index pointers for the coo format - iK = np.kron(edofMat,np.ones((8,1))).flatten() - jK = np.kron(edofMat,np.ones((1,8))).flatten() +def top_EMsFEA(opt): + mod_idx=opt.mod_idx + m=opt.ms_ratio_to + nelx=opt.nelx_to + nely=opt.nely_to + volfrac=opt.volfrac + rmin=opt.rmin + penal=opt.penal + ft=opt.ft # ft==0 -> sens, ft==1 -> dens + + print("Minimum compliance problem with OC") + print("ndes: " + str(nelx) + " x " + str(nely)) + print("volfrac: " + str(volfrac) + ", rmin: " + str(rmin) + ", penal: " + str(penal)) + print("Filter method: " + ["Sensitivity based","Density based"][ft]) + + # Max and min stiffness + Emin=1e-9 + Emax=1.0 + c_nelx=int(nelx/m) + c_nely=int(nely/m) + # dofs: + ndof = 2*(nelx+1)*(nely+1) + coarse_ndof = 2*(c_nelx+1)*(c_nely+1) + # Allocate design variables (as array), initialize and allocate sens. + x=volfrac * np.ones(nely*nelx,dtype=float) + xold=x.copy() + xPhys=x.copy() + g=0 # must be initialized to use the NGuyen/Paulino OC approach + dc=np.zeros((nely,nelx), dtype=float) + # FE: Build the index vectors for the for coo matrix format. + KE=lk() + edofMat=np.zeros((nelx*nely,8),dtype=int) + for elx in range(nelx): + for ely in range(nely): + el = ely+elx*nely + n1=(nely+1)*elx+ely + n2=(nely+1)*(elx+1)+ely + edofMat[el,:]=np.array([2*n1+2, 2*n1+3, 2*n2+2, 2*n2+3,2*n2, 2*n2+1, 2*n1, 2*n1+1]) + # Construct the index pointers for the coo format + iK = np.kron(edofMat,np.ones((8,1))).flatten() + jK = np.kron(edofMat,np.ones((1,8))).flatten() - coarse_edofMat=np.zeros((c_nelx*c_nely,8),dtype=int) - for elx in range(c_nelx): - for ely in range(c_nely): - el = ely+elx*c_nely - n1=(c_nely+1)*elx+ely - n2=(c_nely+1)*(elx+1)+ely - coarse_edofMat[el,:]=np.array([2*n1+2, 2*n1+3, 2*n2+2, 2*n2+3,2*n2, 2*n2+1, 2*n1, 2*n1+1]) - # Construct the index pointers for the coo format - coarse_iK = np.kron(coarse_edofMat,np.ones((8,1))).flatten() - coarse_jK = np.kron(coarse_edofMat,np.ones((1,8))).flatten() + coarse_edofMat=np.zeros((c_nelx*c_nely,8),dtype=int) + for elx in range(c_nelx): + for ely in range(c_nely): + el = ely+elx*c_nely + n1=(c_nely+1)*elx+ely + n2=(c_nely+1)*(elx+1)+ely + coarse_edofMat[el,:]=np.array([2*n1+2, 2*n1+3, 2*n2+2, 2*n2+3,2*n2, 2*n2+1, 2*n1, 2*n1+1]) + # Construct the index pointers for the coo format + coarse_iK = np.kron(coarse_edofMat,np.ones((8,1))).flatten() + coarse_jK = np.kron(coarse_edofMat,np.ones((1,8))).flatten() - # Filter: Build (and assemble) the index+data vectors for the coo matrix format - nfilter=int(nelx*nely*((2*(np.ceil(rmin)-1)+1)**2)) - iH = np.zeros(nfilter) - jH = np.zeros(nfilter) - sH = np.zeros(nfilter) - cc=0 - for i in range(nelx): - for j in range(nely): - row=i*nely+j - kk1=int(np.maximum(i-(np.ceil(rmin)-1),0)) - kk2=int(np.minimum(i+np.ceil(rmin),nelx)) - ll1=int(np.maximum(j-(np.ceil(rmin)-1),0)) - ll2=int(np.minimum(j+np.ceil(rmin),nely)) - for k in range(kk1,kk2): - for l in range(ll1,ll2): - col=k*nely+l - fac=rmin-np.sqrt(((i-k)*(i-k)+(j-l)*(j-l))) - iH[cc]=row - jH[cc]=col - sH[cc]=np.maximum(0.0,fac) - cc=cc+1 - # Finalize assembly and convert to csc format - H=coo_matrix((sH,(iH,jH)),shape=(nelx*nely,nelx*nely)).tocsc() - Hs=H.sum(1) - # BC's and support - # dofs=np.arange(2*(nelx+1)*(nely+1)) - # fixed=np.union1d(dofs[0:2*(nely+1):2],np.array([2*(nelx+1)*(nely+1)-1])) - # free=np.setdiff1d(dofs,fixed) + # Filter: Build (and assemble) the index+data vectors for the coo matrix format + nfilter=int(nelx*nely*((2*(np.ceil(rmin)-1)+1)**2)) + iH = np.zeros(nfilter) + jH = np.zeros(nfilter) + sH = np.zeros(nfilter) + cc=0 + for i in range(nelx): + for j in range(nely): + row=i*nely+j + kk1=int(np.maximum(i-(np.ceil(rmin)-1),0)) + kk2=int(np.minimum(i+np.ceil(rmin),nelx)) + ll1=int(np.maximum(j-(np.ceil(rmin)-1),0)) + ll2=int(np.minimum(j+np.ceil(rmin),nely)) + for k in range(kk1,kk2): + for l in range(ll1,ll2): + col=k*nely+l + fac=rmin-np.sqrt(((i-k)*(i-k)+(j-l)*(j-l))) + iH[cc]=row + jH[cc]=col + sH[cc]=np.maximum(0.0,fac) + cc=cc+1 + # Finalize assembly and convert to csc format + H=coo_matrix((sH,(iH,jH)),shape=(nelx*nely,nelx*nely)).tocsc() + Hs=H.sum(1) + # BC's and support + # dofs=np.arange(2*(nelx+1)*(nely+1)) + # fixed=np.union1d(dofs[0:2*(nely+1):2],np.array([2*(nelx+1)*(nely+1)-1])) + # free=np.setdiff1d(dofs,fixed) - coarse_dofs=np.arange(2*(c_nelx+1)*(c_nely+1)) - coarse_fixed=np.union1d(coarse_dofs[0:2*(c_nely+1):2],np.array([2*(c_nelx+1)*(c_nely+1)-1])) - coarse_free=np.setdiff1d(coarse_dofs,coarse_fixed) + coarse_dofs=np.arange(2*(c_nelx+1)*(c_nely+1)) + coarse_fixed=np.union1d(coarse_dofs[0:2*(c_nely+1):2],np.array([2*(c_nelx+1)*(c_nely+1)-1])) + coarse_free=np.setdiff1d(coarse_dofs,coarse_fixed) - # Solution and RHS vectors - # f=np.zeros((ndof,1)) - # u=np.zeros((ndof,1)) + # Solution and RHS vectors + # f=np.zeros((ndof,1)) + # u=np.zeros((ndof,1)) - c_f=np.zeros((coarse_ndof,1)) - c_u=np.zeros((coarse_ndof,1)) - # Set load - # f[1,0]=-1 - - c_f[1,0]=-1 - # Initialize plot and plot the initial design - plt.ion() # Ensure that redrawing is possible - fig,ax = plt.subplots() - im = ax.imshow(-xPhys.reshape((nelx,nely)).T, cmap='gray',\ - interpolation='none',norm=colors.Normalize(vmin=-1,vmax=0)) - fig.show() - # Set loop counter and gradient vectors - loop=0 - change=1 - dv = np.ones(nely*nelx) - dc = np.ones(nely*nelx) - ce = np.ones(nely*nelx) - while change>0.01 and loop<2000: - loop=loop+1 - # Setup and solve FE problem - coarse_xPhys=xPhys[12::25] - sK=((KE.flatten()[np.newaxis]).T*(Emin+(coarse_xPhys)**penal*(Emax-Emin))).flatten(order='F') - K = coo_matrix((sK,(coarse_iK,coarse_jK)),shape=(coarse_ndof,coarse_ndof)).tocsc() - # Remove constrained dofs from matrix - K = K[coarse_free,:][:,coarse_free] - # Solve coarse situation - c_u[coarse_free,0]=spsolve(K,c_f[coarse_free,0]) - # Predict fine situation - u=pred_net(c_u,xPhys,c_nelx,c_nely,m,'checkpoints/ANN_mod1/ANN_mod1_opt.pt') + c_f=np.zeros((coarse_ndof,1)) + c_u=np.zeros((coarse_ndof,1)) + # Set load + # f[1,0]=-1 + + c_f[1,0]=-1 + # Initialize plot and plot the initial design + plt.ion() # Ensure that redrawing is possible + fig,ax = plt.subplots() + im = ax.imshow(-xPhys.reshape((nelx,nely)).T, cmap='gray',\ + interpolation='none',norm=colors.Normalize(vmin=-1,vmax=0)) + fig.show() + # Set loop counter and gradient vectors + loop=0 + change=1 + dv = np.ones(nely*nelx) + dc = np.ones(nely*nelx) + ce = np.ones(nely*nelx) + while change>0.01 and loop<2000: + loop=loop+1 + # Setup and solve FE problem + coarse_xPhys=xPhys[12::25] + sK=((KE.flatten()[np.newaxis]).T*(Emin+(coarse_xPhys)**penal*(Emax-Emin))).flatten(order='F') + K = coo_matrix((sK,(coarse_iK,coarse_jK)),shape=(coarse_ndof,coarse_ndof)).tocsc() + # Remove constrained dofs from matrix + K = K[coarse_free,:][:,coarse_free] + # Solve coarse situation + c_u[coarse_free,0]=spsolve(K,c_f[coarse_free,0]) + + # Predict fine situation + u=pred_net(c_u,xPhys,opt) + + # u=pred_net(c_u,xPhys,c_nelx,c_nely,m,'checkpoints/ANN_mod1/ANN_mod1_opt.pt') - # print(f.shape, f) - # print(K.shape, K) - # print(f[free,0]) - # print(u.shape, u) + # print(f.shape, f) + # print(K.shape, K) + # print(f[free,0]) + # print(u.shape, u) - # Objective and sensitivity - ce[:] = (np.dot(u[edofMat].reshape(nelx*nely,8),KE) * u[edofMat].reshape(nelx*nely,8) ).sum(1) - obj=( (Emin+xPhys**penal*(Emax-Emin))*ce ).sum() - dc[:]=(-penal*xPhys**(penal-1)*(Emax-Emin))*ce - dv[:] = np.ones(nely*nelx) - # Sensitivity filtering: - if ft==0: - dc[:] = np.asarray((H*(x*dc))[np.newaxis].T/Hs)[:,0] / np.maximum(0.001,x) - elif ft==1: - dc[:] = np.asarray(H*(dc[np.newaxis].T/Hs))[:,0] - dv[:] = np.asarray(H*(dv[np.newaxis].T/Hs))[:,0] - # Optimality criteria - xold[:]=x - (x[:],g)=oc(nelx,nely,x,volfrac,dc,dv,g) - # Filter design variables - if ft==0: xPhys[:]=x - elif ft==1: xPhys[:]=np.asarray(H*x[np.newaxis].T/Hs)[:,0] - # Compute the change by the inf. norm - change=np.linalg.norm(x.reshape(nelx*nely,1)-xold.reshape(nelx*nely,1),np.inf) - # Plot to screen - im.set_array(-xPhys.reshape((nelx,nely)).T) - fig.canvas.draw() - # Write iteration history to screen (req. Python 2.6 or newer) - print("it.: {0} , obj.: {1:.3f} Vol.: {2:.3f}, ch.: {3:.3f}".format(\ - loop,obj,(g+volfrac*nelx*nely)/(nelx*nely),change)) - + # Objective and sensitivity + ce[:] = (np.dot(u[edofMat].reshape(nelx*nely,8),KE) * u[edofMat].reshape(nelx*nely,8) ).sum(1) + obj=( (Emin+xPhys**penal*(Emax-Emin))*ce ).sum() + dc[:]=(-penal*xPhys**(penal-1)*(Emax-Emin))*ce + dv[:] = np.ones(nely*nelx) + # Sensitivity filtering: + if ft==0: + dc[:] = np.asarray((H*(x*dc))[np.newaxis].T/Hs)[:,0] / np.maximum(0.001,x) + elif ft==1: + dc[:] = np.asarray(H*(dc[np.newaxis].T/Hs))[:,0] + dv[:] = np.asarray(H*(dv[np.newaxis].T/Hs))[:,0] + # Optimality criteria + xold[:]=x + (x[:],g)=oc(nelx,nely,x,volfrac,dc,dv,g) + # Filter design variables + if ft==0: xPhys[:]=x + elif ft==1: xPhys[:]=np.asarray(H*x[np.newaxis].T/Hs)[:,0] + # Compute the change by the inf. norm + change=np.linalg.norm(x.reshape(nelx*nely,1)-xold.reshape(nelx*nely,1),np.inf) + # Plot to screen + im.set_array(-xPhys.reshape((nelx,nely)).T) + fig.canvas.draw() + # Write iteration history to screen (req. Python 2.6 or newer) + print("it.: {0} , obj.: {1:.3f} Vol.: {2:.3f}, ch.: {3:.3f}".format(\ + loop,obj,(g+volfrac*nelx*nely)/(nelx*nely),change)) + - np.save('results/top88_' + mod_idx + '_xPhys_' + str(nelx) + '_' + str(nely) + '.npy', xPhys.reshape((nelx,nely)).T) - np.save('results/top88_' + mod_idx + '_u_' + str(nelx) + '_' + str(nely) + '.npy', u) - plt.savefig('results/top88_' + mod_idx + '_img_' + str(nelx) + '_' + str(nely) + '.jpg') + np.save('results/EMsNetTop_' + mod_idx + '_xPhys_' + str(nelx) + '_' + str(nely) + '.npy', xPhys.reshape((nelx,nely)).T) + np.save('results/EMsNetTop_' + mod_idx + '_u_' + str(nelx) + '_' + str(nely) + '.npy', u) + plt.savefig('results/EMsNetTop_' + mod_idx + '_img_' + str(nelx) + '_' + str(nely) + '.jpg') - # plt.show() + # plt.show() - print(u.reshape(nelx+1,nely+1,2)) + print(u.reshape(nelx+1,nely+1,2)) - # Make sure the plot stays and that the shell remains - np.save('results/top88_' + mod_idx + '_xPhys_' + str(nelx) + '_' + str(nely) + '.npy', xPhys.reshape((nelx,nely)).T) - np.save('results/top88_' + mod_idx + '_u_' + str(nelx) + '_' + str(nely) + '.npy', u) - plt.savefig('results/top88_' + mod_idx + '_img_' + str(nelx) + '_' + str(nely) + '.jpg') - plt.show() - print("Press any key...") + # Make sure the plot stays and that the shell remains + np.save('results/EMsNetTop_' + mod_idx + '_xPhys_' + str(nelx) + '_' + str(nely) + '.npy', xPhys.reshape((nelx,nely)).T) + np.save('results/EMsNetTop_' + mod_idx + '_u_' + str(nelx) + '_' + str(nely) + '.npy', u) + plt.savefig('results/EMsNetTop_' + mod_idx + '_img_' + str(nelx) + '_' + str(nely) + '.jpg') + plt.show() + print("Press any key...") #element stiffness matrix def lk(): - E=1 - nu=0.3 - k=np.array([1/2-nu/6,1/8+nu/8,-1/4-nu/12,-1/8+3*nu/8,-1/4+nu/12,-1/8-nu/8,nu/6,1/8-3*nu/8]) - KE = E/(1-nu**2)*np.array([ [k[0], k[1], k[2], k[3], k[4], k[5], k[6], k[7]], - [k[1], k[0], k[7], k[6], k[5], k[4], k[3], k[2]], - [k[2], k[7], k[0], k[5], k[6], k[3], k[4], k[1]], - [k[3], k[6], k[5], k[0], k[7], k[2], k[1], k[4]], - [k[4], k[5], k[6], k[7], k[0], k[1], k[2], k[3]], - [k[5], k[4], k[3], k[2], k[1], k[0], k[7], k[6]], - [k[6], k[3], k[4], k[1], k[2], k[7], k[0], k[5]], - [k[7], k[2], k[1], k[4], k[3], k[6], k[5], k[0]] ]); - return (KE) + E=1 + nu=0.3 + k=np.array([1/2-nu/6,1/8+nu/8,-1/4-nu/12,-1/8+3*nu/8,-1/4+nu/12,-1/8-nu/8,nu/6,1/8-3*nu/8]) + KE = E/(1-nu**2)*np.array([ [k[0], k[1], k[2], k[3], k[4], k[5], k[6], k[7]], + [k[1], k[0], k[7], k[6], k[5], k[4], k[3], k[2]], + [k[2], k[7], k[0], k[5], k[6], k[3], k[4], k[1]], + [k[3], k[6], k[5], k[0], k[7], k[2], k[1], k[4]], + [k[4], k[5], k[6], k[7], k[0], k[1], k[2], k[3]], + [k[5], k[4], k[3], k[2], k[1], k[0], k[7], k[6]], + [k[6], k[3], k[4], k[1], k[2], k[7], k[0], k[5]], + [k[7], k[2], k[1], k[4], k[3], k[6], k[5], k[0]] ]); + return (KE) # Optimality criterion def oc(nelx,nely,x,volfrac,dc,dv,g): - l1=0 - l2=1e9 - move=0.2 - # reshape to perform vector operations - xnew=np.zeros(nelx*nely) - while (l2-l1)/(l1+l2)>1e-3: - lmid=0.5*(l2+l1) - xnew[:]= np.maximum(0.0,np.maximum(x-move,np.minimum(1.0,np.minimum(x+move,x*np.sqrt(-dc/dv/lmid))))) - gt=g+np.sum((dv*(xnew-x))) - if gt>0 : - l1=lmid - else: - l2=lmid - return (xnew,gt) + l1=0 + l2=1e9 + move=0.2 + # reshape to perform vector operations + xnew=np.zeros(nelx*nely) + while (l2-l1)/(l1+l2)>1e-3: + lmid=0.5*(l2+l1) + xnew[:]= np.maximum(0.0,np.maximum(x-move,np.minimum(1.0,np.minimum(x+move,x*np.sqrt(-dc/dv/lmid))))) + gt=g+np.sum((dv*(xnew-x))) + if gt>0 : + l1=lmid + else: + l2=lmid + return (xnew,gt) -def pred_net(coarse_u,fine_x,coarse_nelx,coarse_nely,m, model_load_path, standard = False, device = 0): - coarse_density=np.zeros(shape=(coarse_nely*coarse_nelx,m*m)) - fine_x=fine_x.reshape(coarse_nely*m,coarse_nelx*m) - for ely in range(coarse_nely): - for elx in range(coarse_nelx): - coarse_density[elx + ely * m] = fine_x[ely * m : (ely + 1) * m, elx * m : (elx + 1) * m].flatten() - print(coarse_density.shape) +def pred_net(coarse_u,global_x,opt): + m=opt.ms_ratio_to + nelx=opt.nelx_to + nely=opt.nely_to + coarse_nelx=int(nelx/m) + coarse_nely=int(nely/m) + c_N=coarse_nelx*coarse_nely + N=(opt.ms_ratio_to+1)**2 * 2 + + # Generate coarse mesh density + global_density=global_x.reshape(nelx,nely) # -> (nelx , nely) + coarse_density = np.lib.stride_tricks.as_strided( + global_density, + shape=(coarse_nelx, coarse_nely, m, m), + strides=global_density.itemsize * np.array([nely*m, m, nely, 1]) + ) - - global_displace = coarse_u.reshape(coarse_nelx+1,coarse_nely+1,2) - global_displace = np.dstack((global_displace[:,:,0].T, global_displace[:,:,1].T)) - coarse_displace=np.zeros(shape=(coarse_nely*coarse_nelx,4,2)) - for ely in range(coarse_nely): - for elx in range(coarse_nelx): - coarse_displace[elx + ely][0] = global_displace[ely, elx, :] - coarse_displace[elx + ely][1] = global_displace[ely, (elx+1), :] - coarse_displace[elx + ely][2] = global_displace[(ely+1), elx, :] - coarse_displace[elx + ely][3] = global_displace[(ely+1), (elx+1), :] - print(coarse_displace.shape) - - X = np.hstack((coarse_density[:,:] , coarse_displace[:,:,0] , coarse_displace[:,:,1])) - model = torch.load(model_load_path) - if standard: - X = standardization(X) - device = f'cuda:{device}' if torch.cuda.is_available() else 'cpu' - X = torch.from_numpy(X).type(torch.float32).to(device) - pred=model(X).cpu().detach().numpy() - - # print(pred) - u_reconstructed = np.zeros(shape=(coarse_nely*m+1, coarse_nelx*m+1, 2)) - for ely in range(coarse_nely): - for elx in range(coarse_nelx): - u_reconstructed[ely*m : (ely+1)*m+1, elx*m : (elx+1)*m+1, :] = pred[elx + ely * m].reshape((m+1, m+1, 2)) - # u_reconstructed = u_reconstructed.reshape(coarse_nely*m+1, coarse_nelx*m+1,2) - u_reconstructed = np.dstack((u_reconstructed[:,:,0].T, u_reconstructed[:,:,1].T)) - u_reconstructed=u_reconstructed.flatten() - - return u_reconstructed + # Generate coarse mesh displacement + coarse_displace= np.lib.stride_tricks.as_strided( + coarse_u, + shape=(coarse_nelx, coarse_nely, 2, 2, 2), + strides=coarse_u.itemsize * np.array([(coarse_nely+1)*2, 1*2, (coarse_nely+1)*2, 1*2, 1]) + ) + + # data preprocess + X = np.hstack((coarse_density.reshape(c_N,m*m), coarse_displace.reshape(c_N,8))) + if opt.is_standard: + X = standardization(X) + X=torch.from_numpy(X).type(torch.float32).to(opt.device) + # predict + model = torch.load(opt.pretrained_model_path) + pred=torch.zeros(X.shape[0], N) + for batch_idx, data_batch in enumerate(X): + pred_ShapeFunction=model(data_batch) + pred[batch_idx,:]=pred_ShapeFunction.reshape(N,8) @ data_batch[25:] + pred=pred.to('cpu').detach().numpy() + pred=Ms_u_reshape(pred, coarse_nelx, coarse_nely, m) + pred=pred.reshape((nelx+1)*(nely+1)*2,1) + + return pred # The real main driver if __name__ == "__main__": - mod_idx='test1' - m=5 - nelx=180 - nely=60 - volfrac=0.4 - rmin=5.4 - penal=3.0 - ft=1 # ft==0 -> sens, ft==1 -> dens - top_EMsFEA(nelx,nely,volfrac,penal,rmin,ft,mod_idx,m) + # Load parmetaers + opt = TopoptOption().parse() + # mod_idx='test1' + # m=5 + # nelx=180 + # nely=60 + # volfrac=0.4 + # rmin=5.4 + # penal=3.0 + # ft=1 # ft==0 -> sens, ft==1 -> dens + + top_EMsFEA(opt) + + # u=np.load('./results/coarse_u.npy') + # x=np.load('./results/global_x.npy') + # pred_net(u,x,opt) + diff --git a/train.py b/train.py index fca4152..6a53783 100644 --- a/train.py +++ b/train.py @@ -8,7 +8,7 @@ import torch.nn as nn import torch.nn.functional as F from utils.data_standardizer import standardization -from utils.data_loader import data_loader +from utils.data_loader import data_loader_new from options.train_options import TrainOptions from models.ANN import ANN_Model @@ -33,25 +33,34 @@ def train(X, Y, opt): loss_function = nn.MSELoss() # Set adam optimizer - optimizer=torch.optim.Adam(model.parameters(),lr=opt.lr) # ANN 学习率最好0.001 左右(无归一化) + optimizer=torch.optim.Adam(model.parameters(),lr=opt.lr) # Train start_time=time.time() losses=[] - for i in range(opt.epochs): - pred = model.forward(X_train) - loss=loss_function(pred,Y_train) - # loss.requires_grad_(True) + loss=0 + N=(opt.ms_ratio+1)**2 * 2 + for epoch in range(opt.epochs): + for batch_idx, data_batch in enumerate(X_train): + model.train() # 启用 batch normalization 和 dropout + + pred_ShapeFunction = model(data_batch) + pred_U=pred_ShapeFunction.reshape(N,8) @ data_batch[25:] + loss=loss_function(pred_U,Y_train[batch_idx,:]) + # print(loss.item()) + # loss.requires_grad_(True) + + optimizer.zero_grad() + loss.backward() + optimizer.step() + losses.append(loss.cpu().detach().numpy()) - if i%(opt.epochs/10)==1: - print("Epoch number: {} and the loss : {}".format(i,loss.item())) - optimizer.zero_grad() - loss.backward() - optimizer.step() + if epoch%(opt.epochs/20)==1: + print("Epoch number: {} and the loss : {}".format(epoch,loss.item())) print(time.time()-start_time) - # save trained model, mkdir opt has done in options/base_options.py - save_path=os.path.join(opt.checkpoints_dir, opt.model+'_'+opt.mod, opt.model+'_'+opt.mod+'_opt.pt') + # save trained model, mkdir opreate has done in options/base_options.py + save_path=os.path.join(opt.expr_dir, opt.model+'_'+opt.mod+'_opt.pt') torch.save(model, save_path) return losses @@ -60,11 +69,18 @@ def train(X, Y, opt): if __name__=='__main__': # Load parmetaers opt = TrainOptions().parse() - + save_path=os.path.join(opt.expr_dir, opt.model+'_'+opt.mod+'_opt.pt') + # Load datasets, mod1 as default - global_density, global_displace, coarse_density, coarse_displace, fine_displace = data_loader(opt) - X = np.hstack((coarse_density[:,:] , coarse_displace[:,:,0] , coarse_displace[:,:,1])) - Y = fine_displace[:,:] + m=opt.ms_ratio + c_nelx=int(opt.nelx/m) + c_nely=int(opt.nely/m) + c_N=c_nelx*c_nely + + global_density, global_displace, coarse_density, coarse_displace, fine_displace = data_loader_new(opt) + # X = np.hstack((coarse_density.reshape(c_N,m*m), coarse_displace.reshape(c_N,2,2,2)[:,:,:,0].reshape(c_N,4), coarse_displace.reshape(c_N,2,2,2)[:,:,:,1].reshape(c_N,4))) + X = np.hstack((coarse_density.reshape(c_N,m*m), coarse_displace.reshape(c_N,8))) + Y = fine_displace.reshape(c_N,(m+1)**2*2) # Train losses = train(X, Y, opt) @@ -73,4 +89,5 @@ if __name__=='__main__': plt.plot(range(opt.epochs),losses) plt.ylabel('Loss') plt.xlabel('Epoch') + plt.savefig(os.path.join(opt.results_dir, 'train_losses.png')) plt.show() diff --git a/utils/data_loader.py b/utils/data_loader.py index 5357faf..a5615da 100644 --- a/utils/data_loader.py +++ b/utils/data_loader.py @@ -1,6 +1,54 @@ import numpy as np import os +def data_loader_new(opt): + nelx=opt.nelx + nely=opt.nely + m=opt.ms_ratio + coarse_nelx = int(nelx/m) + coarse_nely = int(nely/m) + + # './datasets/train/180_60/u_OR_xPhys/mod1.npy' as default + density_load_path = os.path.join(opt.dataroot, opt.phase, str(opt.nelx)+'_'+str(opt.nely), 'xPhys', opt.mod+'.npy') + displace_load_path = os.path.join(opt.dataroot, opt.phase, str(opt.nelx)+'_'+str(opt.nely), 'u', opt.mod+'.npy') + + global_density = np.load(density_load_path) # (nely , nelx) + global_displace = np.load(displace_load_path) # ( (nely+1)*(nelx+1)*2 , 1 ) + + # 有意义的情况: + global_density=global_density.reshape(nely,nelx).T # -> (nelx , nely) + global_displace=global_displace.reshape(nelx+1,nely+1,2) # -> (nelx+1), (nely+1), 2 + print(global_density.shape) + print(global_displace.shape) + + + # Generate coarse mesh density + coarse_density = np.lib.stride_tricks.as_strided( + global_density, + shape=(coarse_nelx, coarse_nely, m, m), # 要输出矩阵的 shape + strides=global_density.itemsize * np.array([nely*m, m, nely, 1]) + ) + print(coarse_density.shape) + + # Generate coarse mesh displacement + coarse_displace= np.lib.stride_tricks.as_strided( + global_displace, + shape=(coarse_nelx, coarse_nely, 2, 2, 2), # 要输出矩阵的 shape + strides=global_displace.itemsize * np.array([(nely+1)*m*2, m*2, (nely+1)*m*2, m*2, 1]) + ) + print(coarse_displace.shape) + + # Generate fine mesh displacement + fine_displace= np.lib.stride_tricks.as_strided( + global_displace, + shape=(coarse_nelx, coarse_nely, m+1, m+1, 2), # 要输出矩阵的 shape + strides=global_displace.itemsize * np.array([(nely+1)*m*2, m*2, (nely+1)*2, 1*2, 1]) + ) + print(fine_displace.shape) + + return global_density, global_displace, coarse_density, coarse_displace, fine_displace + + def data_loader(opt): # Load datasets @@ -49,6 +97,7 @@ def data_loader(opt): return global_density, global_displace, coarse_density, coarse_displace, fine_displace if __name__=='__main__': - from options.train_options import TrainOptions - opt = TrainOptions().parse() - data_loader(opt) \ No newline at end of file + global_density, global_displace, coarse_density, coarse_displace, fine_displace=data_loader_new('datasets/train/180_60/xPhys/mod1.npy', 'datasets/train/180_60/u/mod1.npy') + print(global_displace[:10,:10,0]) + print(fine_displace[33,11,:,:,0]) + print(coarse_displace[33,11,:,:,0]) \ No newline at end of file diff --git a/utils/mesh_reshape.py b/utils/mesh_reshape.py new file mode 100644 index 0000000..55fd649 --- /dev/null +++ b/utils/mesh_reshape.py @@ -0,0 +1,28 @@ +import numpy as np + +def Ms_u_reshape(u_data, coarse_nelx, coarse_nely, m): + nelx=coarse_nelx*m + nely=coarse_nely*m + + u_data = u_data.reshape(coarse_nelx,coarse_nely,m+1,m+1,2) + u_data = u_data.swapaxes(1,2).reshape(coarse_nelx*(m+1), coarse_nely*(m+1), 2) + + idx_x=np.arange(coarse_nelx*(m+1))[::m+1] + idx_x=np.delete(idx_x,0) + idx_x=np.delete(np.arange(coarse_nelx*(m+1)),idx_x) + idx_y=np.arange(coarse_nely*(m+1))[::m+1] + idx_y=np.delete(idx_y,0) + idx_y=np.delete(np.arange(coarse_nely*(m+1)),idx_y) + + return u_data[idx_x.reshape(nelx+1,1),idx_y.reshape(1,nely+1)] + + +if __name__=='__main__': + pred=np.load('results/pred.npy') + u=np.load('datasets/train/180_60/u/mod2.npy') + + print(u.shape) + print(pred.shape) + + recv_u = Ms_u_reshape(pred, 36, 12, 5) + print(recv_u-u.reshape(181,61,2)) diff --git a/utils/topopt_88.py b/utils/topopt_88.py index 10a9e6a..9e12e13 100755 --- a/utils/topopt_88.py +++ b/utils/topopt_88.py @@ -121,16 +121,16 @@ def top88(nelx,nely,volfrac,penal,rmin,ft,mod_idx): loop,obj,(g+volfrac*nelx*nely)/(nelx*nely),change)) - np.save('results/top88_' + mod_idx + '_xPhys_' + str(nelx) + '_' + str(nely) + '.npy', xPhys.reshape((nelx,nely)).T) - np.save('results/top88_' + mod_idx + '_u_' + str(nelx) + '_' + str(nely) + '.npy', u) - plt.savefig('results/top88_' + mod_idx + '_img_' + str(nelx) + '_' + str(nely) + '.jpg') + # np.save('results/top88_' + mod_idx + '_xPhys_' + str(nelx) + '_' + str(nely) + '.npy', xPhys.reshape((nelx,nely)).T) + # np.save('results/top88_' + mod_idx + '_u_' + str(nelx) + '_' + str(nely) + '.npy', u) + # plt.savefig('results/top88_' + mod_idx + '_img_' + str(nelx) + '_' + str(nely) + '.jpg') # plt.show() print(u.reshape(nelx+1,nely+1,2)) # Make sure the plot stays and that the shell remains - np.save('results/top88_' + mod_idx + '_xPhys_' + str(nelx) + '_' + str(nely) + '.npy', xPhys.reshape((nelx,nely)).T) + np.save('results/top88_' + mod_idx + '_xPhys_' + str(nelx) + '_' + str(nely) + '.npy', xPhys) np.save('results/top88_' + mod_idx + '_u_' + str(nelx) + '_' + str(nely) + '.npy', u) plt.savefig('results/top88_' + mod_idx + '_img_' + str(nelx) + '_' + str(nely) + '.jpg') plt.show() @@ -168,9 +168,9 @@ def oc(nelx,nely,x,volfrac,dc,dv,g): # The real main driver if __name__ == "__main__": # Default input parameters - mod_idx='mod4' - nelx=30 - nely=10 + mod_idx='py88' + nelx=180 + nely=60 volfrac=0.4 rmin=5.4 penal=3.0 diff --git a/utils/visualization.py b/utils/visualization.py new file mode 100644 index 0000000..939bffa --- /dev/null +++ b/utils/visualization.py @@ -0,0 +1,35 @@ +from mpl_toolkits.mplot3d import Axes3D +import matplotlib.pyplot as plt +import numpy as np + +def surf_plot(dp,ny,nx,save_path,UorV='sqrt',non_dp=False): + fig = plt.figure() + ax = fig.add_subplot(projection='3d') + + # Make data + # 生成网格数据 + X, Y = np.meshgrid(np.arange(nx), np.arange(ny)) + + if non_dp: + Z = Z_x = Z_y = dp.reshape(ny,nx) + else: + Z = dp.reshape(ny,nx,2) + Z_x = Z[:,:,0].reshape(ny,nx) + Z_y = Z[:,:,1].reshape(ny,nx) + + if UorV == 'u': + ax.plot_surface(X, Y, Z_x, rstride = 1, cstride = 1, cmap='rainbow') + elif UorV == 'v': + ax.plot_surface(X, Y, Z_y, rstride = 1, cstride = 1, cmap='rainbow') + else: + ax.plot_surface(X, Y, Z_x*Z_x+Z_y*Z_y, rstride = 1, cstride = 1, cmap='rainbow') + + plt.savefig(save_path) + plt.show() + + +if __name__=='__main__': + print('nothing') + # surf_plot(global_displace,nely+1,nelx+1,'u') + # surf_plot(global_displace,nely+1,nelx+1,'v') + # surf_plot(global_displace,nely+1,nelx+1,'sqrt') diff --git a/visualization.ipynb b/visualization.ipynb index 38e215a..1312e14 100644 --- a/visualization.ipynb +++ b/visualization.ipynb @@ -10,43 +10,22 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 141, "id": "aef142c9-a3d0-408c-a87f-695167d49dea", "metadata": { "tags": [] }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "(61, 181, 2)\n", - "(60, 180)\n", - "(432, 25)\n", - "(432, 4, 2)\n", - "(432, 72)\n", - "Total loss: 0.03841373324394226\n" + "ename": "TypeError", + "evalue": "data_loader() takes 1 positional argument but 2 were given", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[141], line 22\u001b[0m\n\u001b[1;32m 20\u001b[0m dst_path\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdatasets/top88_\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m+\u001b[39m dataload_mod \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_xPhys_180_60.npy\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 21\u001b[0m U_path\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdatasets/top88_\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m+\u001b[39m dataload_mod \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_u_180_60.npy\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m---> 22\u001b[0m global_density, global_displace, coarse_density, coarse_displace, fine_displace \u001b[38;5;241m=\u001b[39m \u001b[43mdata_loader\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdst_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mU_path\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 23\u001b[0m X \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mhstack((coarse_density[:,:] , coarse_displace[:,:,\u001b[38;5;241m0\u001b[39m] , coarse_displace[:,:,\u001b[38;5;241m1\u001b[39m]))\n\u001b[1;32m 24\u001b[0m Y \u001b[38;5;241m=\u001b[39m fine_displace[:,:]\n", + "\u001b[0;31mTypeError\u001b[0m: data_loader() takes 1 positional argument but 2 were given" ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAHFCAYAAADcytJ5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA6hUlEQVR4nO3deXxU1f3/8fckhCRkY5MlEBZFQYQgi0hEAQWpVFFUvq6ttmoVRdQf7deq1LpUG5e6tQriUtC2irWIxW9BDSqLomUTZRNcEohC2EnCknXO7w/MMHcyN0wWcu/cvJ6PRx4mN3dmPjf3++15c8655/iMMUYAAAAuFON0AQAAAHYIKgAAwLUIKgAAwLUIKgAAwLUIKgAAwLUIKgAAwLUIKgAAwLUIKgAAwLUIKgAAwLUIKoCHzJw5Uz6fTytWrLA9Jy8vTz6fTzNnzmy8wpqAqr/rn/70J6dLATylmdMFAGhcHTt21KeffqoTTjjB6VIA4KgIKkATEx8fryFDhjhdRo0OHjyoFi1aHJP3PnTokBITE4/JewNoeAz9AE1MuKGf+++/Xz6fT+vWrdOVV16ptLQ0tW/fXtddd50KCwstrzfGaOrUqTr11FOVmJioVq1aafz48fruu+8s5+Xk5Oiiiy5S586dlZCQoB49euimm27Srl27LOdVffaqVas0fvx4tWrV6qi9PR9//LGysrKUkJCgTp066d5779VLL70kn8+nvLy8wHndunXTBRdcoLfeekv9+/dXQkKCHnjgAUnSc889p2HDhqldu3ZKSkpS37599dhjj6m8vNzyWSNGjFCfPn20ZMkSDRkyRImJiYHPrKysDFvfk08+qe7duys5OVlZWVn67LPParweAPboUQEQcOmll+ryyy/X9ddfrzVr1ujuu++WJP31r38NnHPTTTdp5syZuu222/Too49qz549evDBB3XGGWfoiy++UPv27SVJ3377rbKysnTDDTcoLS1NeXl5evLJJ3XmmWdqzZo1iouLs3z2JZdcoiuuuEITJkzQgQMHbGv88ssvde655+qkk07SK6+8ohYtWuj555/X3//+97Dnr1q1Shs2bNDvfvc7de/eXUlJSYH6rrrqKnXv3l3NmzfXF198oYcfflhfffWV5XolqaCgQFdccYXuuusuPfjgg/rPf/6jhx56SHv37tWzzz5rOfe5555Tr1699PTTT0uS7r33Xv30pz9Vbm6u0tLSIrgLACwMAM+YMWOGkWSWL19ue05ubq6RZGbMmBE4dt999xlJ5rHHHrOce8stt5iEhATj9/uNMcZ8+umnRpJ54oknLOfl5+ebxMREc+edd4b9TL/fb8rLy83mzZuNJPPvf/+72mf//ve/j+ga/+d//sckJSWZnTt3Bo5VVlaa3r17G0kmNzc3cLxr164mNjbWbNy4scb3rKysNOXl5ebVV181sbGxZs+ePYHfDR8+vFrNxhjzq1/9ysTExJjNmzcbY478Xfv27WsqKioC5y1btsxIMq+//npE1wfAiqEfAAEXXnih5efMzEyVlJRox44dkqT/+7//k8/n089+9jNVVFQEvjp06KB+/fpp4cKFgdfu2LFDEyZMUEZGhpo1a6a4uDh17dpVkrRhw4Zqn33ppZdGVOOiRYt0zjnnqG3btoFjMTExuuyyy8Ken5mZqZNOOqna8c8//1wXXnih2rRpo9jYWMXFxemaa65RZWWlNm3aZDk3JSWl2t/mqquukt/v1+LFiy3Hzz//fMXGxlo+X5I2b94c0fUBsGLoB0BAmzZtLD/Hx8dLOjwBVZK2b98uY0xgeCfU8ccfL0ny+/0aPXq0tm7dqnvvvVd9+/ZVUlKS/H6/hgwZEni/YB07doyoxt27d4f9fLuawr3vli1bdNZZZ6lnz5565pln1K1bNyUkJGjZsmWaOHFitfrCvXeHDh0C9QQ72t8QQO0QVABErG3btvL5fFqyZEmgAQ5WdWzt2rX64osvNHPmTF177bWB33/zzTe27+3z+SKqoU2bNtq+fXu14wUFBRG/79tvv60DBw7orbfeCvTySNLq1avDvkdNnxcaTAA0LIZ+AETsggsukDFGP/zwgwYNGlTtq2/fvpKOhIPQMDN9+vR61zB8+HB9+OGHlqeH/H6/3nzzzYjfI1x9xhi9+OKLYc8vLi7W3LlzLcdee+01xcTEaNiwYbUpH0At0aMCeNCHH35oeUy3yk9/+tN6ve/QoUN144036pe//KVWrFihYcOGKSkpSdu2bdPHH3+svn376uabb1avXr10wgkn6K677pIxRq1bt9Y777yjnJycen2+JE2ZMkXvvPOORo4cqSlTpigxMVHPP/984EmhmJij//vr3HPPVfPmzXXllVfqzjvvVElJiaZNm6a9e/eGPb9Nmza6+eabtWXLFp100kmaN2+eXnzxRd18883q0qVLva8JgD2CCuBBv/3tb8Mez83Nrfd7T58+XUOGDNH06dM1depU+f1+paena+jQoRo8eLAkKS4uTu+8845uv/123XTTTWrWrJlGjRqlBQsW1Lth79evn3JycvSb3/xG11xzjVq1aqWf//znGj58uH77299G9Ahwr169NHv2bP3ud7/TJZdcojZt2uiqq67S5MmTNWbMmGrnd+jQQc8995x+85vfaM2aNWrdurXuueeewJosAI4dnzHGOF0EANTX6NGjlZeXV+2JnfoaMWKEdu3apbVr1zbo+wKIDD0qAKLO5MmT1b9/f2VkZGjPnj36xz/+oZycHL388stOlwaggRFUAESdyspK/f73v1dBQYF8Pp969+6tv/3tb/rZz37mdGkAGhhDPwAAwLV4PBkAALgWQQUAALgWQQUAALhWVE+m9fv92rp1q1JSUiJefhsAADjLGKPi4mKlp6cfdZHGqA4qW7duVUZGhtNlAACAOsjPz1fnzp1rPCeqg0pKSoqkwxeamprqcDUAACASRUVFysjICLTjNYnqoFI13JOamkpQAQAgykQybYPJtAAAwLUIKgAAwLUIKgAAwLUIKgAAwLUIKgAAwLUIKgAAwLUIKgAAwLUIKgAAwLUIKgAAwLUIKgAAwLUIKgAAwLUIKgAAwLUIKjU4VFYpY4zTZQAA0GQRVGxs2X1Q/f/wvu6bu87pUgAAaLIIKjY2bS9WSblfX3xf6HQpAAA0WQQVG4EBH4Z+AABwDEHFRtXcFGIKAADOIajYqAoodKgAAOAcgoqNqoBi6FMBAMAxBBUAAOBaBBVbP85RoUMFAADHEFRsBIZ+CCoAADiGoGLDhPwXAAA0PoKKjSM9KkQVAACcQlABAACuRVCxwWPJAAA4j6Big8m0AAA4j6Bi48hkWpIKAABOIajYCOz1Q04BAMAxBBUAAOBaBJWjoEMFAADnEFRssI4KAADOI6jYqJpES0wBAMA5BBUbhjX0AQBwHEEFAAC4FkHFRmCOirNlAADQpBFUbARGfphMCwCAYwgqNgILvjlcBwAATRlBxcaRHhVHywAAoEkjqAAAANciqNgJTKalSwUAAKcQVGwEFnwjpwAA4BiCio0jS+g7WwcAAE0ZQcUG+QQAAOcRVAAAgGsRVGywezIAAM4jqNhg92QAAJxHULHBZFoAAJznmqCSnZ0tn8+nO+64w+lSJAWtTEufCgAAjnFFUFm+fLleeOEFZWZmOl0KAABwEceDyv79+3X11VfrxRdfVKtWrZwu5wjDgm8AADjN8aAyceJEnX/++Ro1atRRzy0tLVVRUZHl61gxIf8FAACNr5mTHz5r1iytWrVKy5cvj+j87OxsPfDAA8e4qsOYTAsAgPMc61HJz8/X7bffrr///e9KSEiI6DV33323CgsLA1/5+fnHuEqJPhUAAJzjWI/KypUrtWPHDg0cODBwrLKyUosXL9azzz6r0tJSxcbGWl4THx+v+Pj4RqmPhd4AAHCeY0Fl5MiRWrNmjeXYL3/5S/Xq1Uu//e1vq4WUxhaYo0JeAQDAMY4FlZSUFPXp08dyLCkpSW3atKl23AmBOSrOlgEAQJPm+FM/bnWkR4WoAgCAUxx96ifUwoULnS6hGmIKAADOoUfFBj0pAAA4j6ByFOQVAACcQ1CxcWTBN5IKAABOIajYqNo1mZgCAIBzCCoAAMC1CCo2DLsSAgDgOIKKDXIKAADOI6jYYDItAADOI6jYYDItAADOI6gAAADXIqjYODL042wdAAA0ZQSVozAM/gAA4BiCio2qSbT0qAAA4ByCio3A0I+zZQAA0KQRVAAAgGsRVGyYat8AAIDGRlCxcWToh6QCAIBTCCo2Agu+kVMAAHAMQcUGk2kBAHAeQQUAALgWQcVGYPdkxn4AAHAMQcWOYVNCAACcRlCxcaRHxdEyAABo0ggqNggoAAA4j6ACAABci6BiI3ihNybUAgDgDIKKjeBsQk4BAMAZBBUbxuZ7AADQeAgqNqw9KkQVAACcQFABAACuRVCxYZlM62AdAAA0ZQQVO0ymBQDAcQQVG9bJtCQVAACcQFCxETyBlh4VAACcQVABAACuRVCxQS8KAADOI6jYsMxRIbQAAOAIgooNy4JvTKYFAMARBBUb1k0JHSwEAIAmjKACAABci6Biwzr0AwAAnEBQiQCbEgIA4AyCig3Lgm8O1gEAQFNGULHB48kAADiPoAIAAFyLoGLDWHclBAAADiCo2LCso0JSAQDAEQQVG5bHk8kpAAA4gqBig5EfAACcR1ABAACuRVCxYR36oU8FAAAnEFRsseAbAABOI6jYYDItAADOI6jYsG5KSFIBAMAJBBUAAOBaBBUbll4UOlQAAHAEQcWGIacAAOA4gooNdk8GAMB5BBUbTKYFAMB5BBUAAOBaBBUblt2T6VABAMARBBU7TKYFAMBxBBUb1sm0RBUAAJzgaFCZNm2aMjMzlZqaqtTUVGVlZWn+/PlOlhQQHE7IKQAAOMPRoNK5c2c98sgjWrFihVasWKFzzjlHF110kdatW+dkWQAAwCWaOfnhY8eOtfz88MMPa9q0afrss890yimnOFTVYXSiAADgPEeDSrDKykq9+eabOnDggLKyspwuh92TAQBwAceDypo1a5SVlaWSkhIlJydrzpw56t27d9hzS0tLVVpaGvi5qKjomNVlmUxL/woAAI5w/Kmfnj17avXq1frss890880369prr9X69evDnpudna20tLTAV0ZGxjGri8m0AAA4z/Gg0rx5c/Xo0UODBg1Sdna2+vXrp2eeeSbsuXfffbcKCwsDX/n5+Y1crXd8v/egPvlml9NlAABQI8eHfkIZYyzDO8Hi4+MVHx/fOHXYfO8Vt89arZWb92rB5OHq0S7Z6XIAAAjL0aByzz33aMyYMcrIyFBxcbFmzZqlhQsX6t1333WyrMMsk2m9F1V27z8cBvccKHO4EgAA7DkaVLZv366f//zn2rZtm9LS0pSZmal3331X5557rpNlSQrZ68fBOo6VqmvyYggDAHiHo0Hl5ZdfdvLja+T1x5OrrsmDlwYA8BDHJ9PCGf4fk4rfiykMAOAZBBUb1vbbe4154Pq8d2kAAA8hqNiwzFHxcGPu4UsDAHgAQcWGZY6Kc2UcM1WTaL0cwgAA0Y+gYsOyjooHG3N/YDKtBy8OAOAZBJUmqiqg+MkpAAAXI6jYsA79eK81Dzye7MXuIgCAZxBUbHl7Mi0P/QAAogFBxUZTWfCNpAIAcDOCig3rpoTea80NC74BAKIAQaWJOrLXj6NlAABQI4KKjeBJpl5szAPrqDhcBwAANSGo2PB6A87uyQCAaEBQseH1ybR+Pz0qAAD3I6jY8Pxk2qr/ejGFAQA8g6DSVAUWfHO2DAAAakJQseH5ybQh/wUAwI0IKhHwYmPO7skAgGhAULFhnUzrvda8ajNCFnwDALgZQcVG8ARaLzblVdfnxWsDAHgHQaWJYvdkAEA0IKjY8Po6Kh68JACABxFUbFjDifeadSbTAgCiAUHFhmWOigcbc8NkWgBAFCCo2LAM/ThXxjHD7skAgGhAUGmi2D0ZABANCCo2LHv9eLA1Z68fAEA0IKjY8fiCb4HHk50tAwCAGhFUbHh5wTfrPkZeuzoAgJcQVGx4eR0VL18bAMBbCCpNkLH5HgAAtyGo2LA25t5qzv3G22vEAAC8g6Biw3h4IZXgS2PBNwCAmxFUbHh5eMTLE4UBAN5CULHh5QmnxuuLxAAAPIOg0sQRUwAAbkZQscFkWgAAnFenoJKfn6/vv/8+8POyZct0xx136IUXXmiwwhzn4cacybQAgGhRp6By1VVX6aOPPpIkFRQU6Nxzz9WyZct0zz336MEHH2zQAp3i7cm0Qd977eIAAJ5Sp6Cydu1aDR48WJL0z3/+U3369NHSpUv12muvaebMmQ1Znyt4bZl5yxL6DtYBAMDR1CmolJeXKz4+XpK0YMECXXjhhZKkXr16adu2bQ1XnYM8lk0s/B7fcBEA4B11CiqnnHKKnn/+eS1ZskQ5OTk677zzJElbt25VmzZtGrRAp3h6rREPP3oNAPCWOgWVRx99VNOnT9eIESN05ZVXql+/fpKkuXPnBoaEop3x8CQVawjz2MUBADylWV1eNGLECO3atUtFRUVq1apV4PiNN96oFi1aNFhxTrKuoO+txtzLi9kBALylTj0qhw4dUmlpaSCkbN68WU8//bQ2btyodu3aNWiBbuC1xtzDnUUAAI+pU1C56KKL9Oqrr0qS9u3bp9NPP11PPPGExo0bp2nTpjVogU7xcgPOgm8AgGhRp6CyatUqnXXWWZKkf/3rX2rfvr02b96sV199VX/+858btECnGA835iz4BgCIFnUKKgcPHlRKSook6f3339cll1yimJgYDRkyRJs3b27QAt3Aa0251+bcAAC8q05BpUePHnr77beVn5+v9957T6NHj5Yk7dixQ6mpqQ1aoFOMl9ca8fK1AQA8pU5B5fe//71+85vfqFu3bho8eLCysrIkHe5d6d+/f4MW6AZea8r9PPUDAIgSdXo8efz48TrzzDO1bdu2wBoqkjRy5EhdfPHFDVack7w8POLpxewAAJ5Sp6AiSR06dFCHDh30/fffy+fzqVOnTp5Z7E3y9lojTKYFAESLOg39+P1+Pfjgg0pLS1PXrl3VpUsXtWzZUn/4wx/k9/sbukZHmBp+inbsngwAiBZ16lGZMmWKXn75ZT3yyCMaOnSojDH65JNPdP/996ukpEQPP/xwQ9fZ6Lz9eDJDPwCA6FCnoPLKK6/opZdeCuyaLEn9+vVTp06ddMstt3giqATzWmNu6FIBAESJOg397NmzR7169ap2vFevXtqzZ0+9i3IDLzff1jkqztUBAMDR1Cmo9OvXT88++2y1488++6wyMzPrXZQreHkyLbsnAwCiRJ2Gfh577DGdf/75WrBggbKysuTz+bR06VLl5+dr3rx5DV2jI6wb93mrMffyE00AAG+pU4/K8OHDtWnTJl188cXat2+f9uzZo0suuUTr1q3TjBkzGrpGR3h5Mq2fybQAgChR53VU0tPTq02a/eKLL/TKK6/or3/9a70LcxOvNebMpQUARIs69ag0BV5uvz29jxEAwFMIKja83Zgz9AMAiA4EFRtem0AbzNshDADgJbWao3LJJZfU+Pt9+/bVpxZX8fKTMeyeDACIFrXqUUlLS6vxq2vXrrrmmmsifr/s7GyddtppSklJUbt27TRu3Dht3Lix1hdxrHmtdyX4eljwDQDgZrXqUWnoR48XLVqkiRMn6rTTTlNFRYWmTJmi0aNHa/369UpKSmrQz6otL/c0WHqLPBbCAADeUufHkxvCu+++a/l5xowZateunVauXKlhw4Y5VFV1XgstXh7WAgB4i6NBJVRhYaEkqXXr1mF/X1paqtLS0sDPRUVFx6yWprLgGwAAbuaap36MMZo8ebLOPPNM9enTJ+w52dnZljkxGRkZx64em++9hqd+AABu5pqgcuutt+rLL7/U66+/bnvO3XffrcLCwsBXfn5+o9Tmtcac3ZMBANHCFUM/kyZN0ty5c7V48WJ17tzZ9rz4+HjFx8c3Sk0eyyYW7J4MAIgWjgYVY4wmTZqkOXPmaOHCherevbuT5VgYD6/eymRaAEC0cDSoTJw4Ua+99pr+/e9/KyUlRQUFBZIOr9eSmJjoZGnWBtxjjTm7JwMAooWjc1SmTZumwsJCjRgxQh07dgx8vfHGG06WJSl0Mq23mnN2TwYARAvHh36iQZSUGTH2+gEARAvXPPXjNt5uv727RgwAwFsIKras8ziW5e7Rdzv3O1dOA7JsSuixYS0AgLcQVGwE9zTsLC7VFS98qhteXeFcQQ2Ip34AANGCoGIjuP3ec6BMfiPt3l/mWD0NKXheCgu+AQDcjKASgcofW3Ov7JHj5SeaAADeQlCxYe11MD8ec6qahuXlNWIAAN5CULER3H5XBRXP9Kiw4BsAIEoQVGwEZxJPD/145JoAAN5EULER3IBX+g//1ysTT9k9GQAQLQgqETCBOSreaNW9vOEiAMBbCCo2ghvwysAcFWdqaWiWBd88Er4AAN5EULHj5TkqTKYFAEQJgoqNcDsMeySnMJkWABA1CCo2rJNpTdjjUYsl9AEAUYKgEgG/x5acN+yeDACIEgQVG+EWfAv9Plr5/Ue+Zwl9AICbEVRshFvwTfJGUAk3/wYAADciqNgI7mmo9NicDrfunmyM0bMffq2c9dudLgUA4BLNnC7ArSyrt3q4R8VNDygv+XqX/vT+JklS3iPnO1wNAMAN6FGJgOcm0xp3TqYtKCpxugQAgMsQVGxYVqb1Wo9K8FCWc2VU56piAABuQFCxY9m4L6gHwh/m3CjDgm8AgGhBULFhmUzr4R4VLwxlAQC8i6Biw/J4sk3vSrRi92QAQLQgqETArY/z1hW7JwMAogVBxYbdyrReaNi9cA0AgKaBoGLDuinhkeNe6FEJ5oWhLACAdxFUbFh6VIJ3T/bArA7L48kuuhwv/G0BAA2LoGLDOpnWa3NU3LngGwAAoQgqEbCsTOuBpGJd8C36rwcA4F0ElQhYhn480K67dfdkn3yB75nwCwCQCCphhTaS1qGf6G9A3brXj2V9FxfVBQBwDkEljNBG0m956if6W1BLj4pLh3688HcGANQfQSWM0CbSuoR+49ZyLLi1RyWYF/7OAID6I6hEwHsLvgV971wZNaJHBQAgEVTCCg0jfo89nmy36q6buLUuAEDjIqiEUfPQT/Q3oG5d8C2YFwIhAKD+CCphhDbeXgsqlqEsB+sIFfyn9cLfGQBQfwSVMEKfhImGHojasFyCSy/I+I9+DgDA+wgqEfB7bB0VubRHJZgn/s4AgHojqIRRbegnCh7nrQ0m0wIAogVBJQKeW/DNpUNZwRNoK91UGADAMQSVMGrqUfHC0yhu3T3ZrXUBAJxDUAkjdDJtpWVTwuhvQd264Jvx2lwgAEC9EVRqyQs9Ktbdk91zQV7bqgAAUH8ElTBqaru98C99t+71ExxO/CQVAIAIKmHV1ER6I6gEfe+iwR/mqAAAQhFUwqhpOMQLDWhwOHHT9QQHFZ76AQBIBJWwmlaPintYhn488HcGANQfQaWWvDB1wq0LvlmHftxTFwDAOQSVMLw+mdbv0i4V66aEztUBAHAPgko4NTSSXviXvktziud2qQYA1B9BJYyanoTxe2xXXzcFL8vmjx77OwMA6oagEobXh34s66g4WEcoJtMCAEIRVGrJC82ncWkg8DP0AwAIQVAJo6Ym0k1DJXUV3HPhpsuxDP24qC4AgHMIKmHUFEa80IC6d8G34O9dVBgAwDEElTCa0oJvbmJYRwUAEIKgEkbNk2kbr45jxa0LvrF7MgAgFEGllrzwL/1o2D25kqQCABBBJawa11FxU8teR9Gwe7IX/s4AgPojqIRT09CPBxYic+9kWnfWBQBwDkEljKY0mdZNV0OPCgAglKNBZfHixRo7dqzS09Pl8/n09ttvO1lOQE1tpBfaz+BLcNOcG+vjyc7VAQBwD0eDyoEDB9SvXz89++yzTpZRK174l75bh1hYmRYAEKqZkx8+ZswYjRkzxskSwqp5Mm0jFnKsRMPQjyf+0ACA+nI0qNRWaWmpSktLAz8XFRUdk8/x/KaEwd+76HoY+gEAhIqqybTZ2dlKS0sLfGVkZByTz/H6Xj/u3T2ZoR8AgFVUBZW7775bhYWFga/8/Pxj8jk1hREvNJ+WngsXdV0E1+KFQAgAqL+oGvqJj49XfHy8ozW4qWGvK/c+nhz+ewBA0xVVPSqNxft7/bgzqTD0AwAI5WiPyv79+/XNN98Efs7NzdXq1avVunVrdenSxcHK7HmhAXVvjwqbEgIArBwNKitWrNDZZ58d+Hny5MmSpGuvvVYzZ850qCrvL/gWzE3BK3h7Ai8MsQEA6s/RoDJixAhXTpr0+qaErl3wjaEfAEAI5qjUkhf+oR8duyc7WAgAwDUIKmF4f8E3t/aoBH/vosIAAI4hqITh/QXfgr53roxqrENSbqoMAOAUgkoYNTWSXhiSCL4GNwUC1lEBAIQiqIRRUxvpjSEJlw79BKWTSpIKAEAElVrzQvvJ0A8AIFoQVMKoeR2V6G9AjWuHfnjqBwBgRVAJq4ZNCT3QgAY/9eOmQGBZ8M0Lf2gAQL0RVMLw+uPJbgonwehRAQCEIqjUkhca0NCs5ZbhH+aoAABCEVTC8Pw6KiFX6JZLqgyqg6d+AAASQSUsrw/9hCYxt1yRYegHABCCoBJGzZsSNmIhx0ho2HJL+GJTQgBAKIJKGF7vUQm9ArdcUvBTP14YYgMA1B9BpZa80H5Wm0zrksEfnvoBAIQiqIQRzT0qJeWV+vU/v9B/vtxme45re1QY+gEAhCCohFHzHBV3N6B//2yzZq/6XhNfW2V7jluHVSybEtKlAgAQQSWsmntUGq+OuthZXHrUc0Kvzy3hKzicuP3vDABoHASVWnJrb0RtuHUdFYZ+AAChCCq1FPxkihtF0rxXn0zrDpahH7cUBQBwFEEljGieTBsJltAHAEQLgkoYNU2m9ULzWX3BN4cKCWGdo+KSogAAjiKohBHNPSqR9ERUO8MllxQcmCpdPsQGAGgcBJUwat6UsNHKOGaiY8E3d9QEAHAWQaWW3N6ARlae+5/6YY4KAEAiqIRVUyO5Zc9BbSs81IjV1J3domk89QMAiBYElTBqaiM/37JPFz77SbUQ4Pcb7T1QdmwLq6Vym2ep2T0ZABAtCCphHK2N3FlcqrKQ2Z7XvbJc/f+Qow3bio5hZUcXXHpF5eGfPvlml1Zu3hv2HMk9Qz+VrEwLAAhBUAnr6K1kaYU1qCzcuFPS4b12nBQcOioqjfYcKNPVL/1Xl05bGugFcutk2uC62OsHACARVOqs3KXPzwaHjrJKv3bvP7L3T9VQkHsfT2boBwBgRVAJI5I2sqwifFBxunmtGu6RpIqQOSpVNYdOFna65irWoOJgIQAA1yCohBFJG2nXo+J0R0BwXRWV1kGdI0HF+hq39F4E5yoeTwYASASVsOrVo+JwAxs8ybes0m+ps+p37J4MAIgWBJUwIgkboU/9HHltQ1dTO5ahn0pjDS4Vfi39Zpc++Wa35TVuiQQM/QAAQhFU6siuR8VpwUM/5aE9KhV+XfXSf6u9xuleoKoaLHv9uKAmAIDzCCphRNJEBgeA4Ibe6Ud9LXNU/MbyGLVbe4HC1eCG8AQAcB5BJYxI2sjyoCGW4O+dbl+tdVl7VErK3RtUqq2W684OKwBAIyOohBFJr0hZZWXQ90daVafnVtQ09FNcUh72NU73AknVh3qYTAsAkAgq4UX01E9Qz0XwMJDDjX71ybRHAlVxSUXY17ghE1R/ZNqZOgAA7kJQqaPQx4CrBAcFJ1hq8Yf2qNgElWNe1dGF9qAwRwUAIBFUwqrtZFq7751Qbnkc2UQ09OOGYZbQHhSe+gEASASVsCKbTHskAAQ/WVNaURnu9EYTuoR+cG37S9079FPpD52j4lAhAABXIaiEEdFkWptelNBdlRtb6BL6pREM/bhh8Kfa/kNuSE8AAMcRVMKobY9KmU3vihNqWkK/yO6pHxdkgtAeFDcMRwEAnEdQqaPgQFJe6Z45KjUtoW/Xo+KGYZZqQz+sowIAEEElrNrunlwWMkdl7Q+FumfOGu3aX3oMqou8rupP/bh3HZXQoR56VAAAktTM6QLcKKJNCWuYo3LBXz6WJO09UKZpPxvY8AXWVJdlwTfrUz9Fh9w7mTa0V8cNNQEAnEePShi1fTzZ8tRP0DL1a7cWNmRZEamoYQl9Nz/1E9qDwuPJAACJoBJevSbTHnk82Ym21vrUjz9kjop7h36qP57sfE0AAOcRVOrIMsTikgXfjDGq8Af3qBhLcGIJfQBAtCGohBHZOipHzrF7PLmxA0B5yPL9oZNpK2xafzcEFZbQBwCEQ1AJI5I2sszmqR+7MNAYgod9Dv9sIlrXxRVDPzz1AwAIg6ASRkRBJWhIxW64p7F7BaoHFX9EQ1FuyATVHk9mHRUAgAgqYUW2jkr4oR8nVRv6CVnwzY4Lcgor0wIAwiKo1FEkOyY3doCpa4+KG0IBT/0AAMIhqIQR0YJvNo8nByuy3QTw2Ag3RyVahn5CgwlP/QAAJIJKWLVd8M22R6XCb3k8+FgL99RPZJskOp8Kqj+e7HxNAADnsYR+GLXePbmGMFBcUqH45NiGKOuoQntUKlzao3KwrEL/+GyLcncf0NWnd9Ep6WlhHk9u3JoAAO5EUAmr7nv9hCouqVDb5PgGqepoQoNKWcjKtHYae5hlxid5evy9jZKkTQXF+tfNZzBHBQAQFkM/dWTd/M8+DOxvxHkq1Z/6ifTx5MYNBR9s2B74fsXmvfph36FqYSk0uAAAmiaCShgRDf0Eb0RYQ1D57LvduuKFT7X0m10NUVrNNYUO/fgjHPo5VgWFKKvwa96abVq1ZZ8kqWubFpKk//tia7UNE+lQAQBIDP2EFdFk2h9DwcTXVuk/X26zPe/heRskSZ99918t/t+z1eXHxrmuVm7eqxcWf6sHLuyjDmkJgeNFJeWaMmeNtcaKyIZ+jnUo+CJ/n+at3aZ3Vm/V1sISSVKvDim6Jqub7pmzRtnzv1JG60RJ0vHHJem7nQcY+gEASKJHJazIVqb1q6S8ssaQEuq5j74J+gyjf/x3sz7fsrdWtV06baneW7e9Wih5KmeTvt15wHLsYFlkTxwdqyX0yyv9eipnky6ZtlTTF30XCCmSNK5/J106sJNOap8sScrfc0gpCc107/m9JTFHBQBwGD0qYUS0KWGlXxsLii3Hhp90nBZt2lnt3Pap8dpeVKqPv9mlJ97fqDF9Oipv9wFNmbNWkpSb/VP5fL6jfmbwo87rthYFvs/fc1Cvfrq52vkHyiKbH1OVCcoq/Fq/rUj9OqdFVE9Ncncd0P97Y7VW5++TdLgH5biUeN0x6kS1bNFc3dskKSbGp6cuP1W/emWFOqQl6M7zeiktMU4S66gAAA5zPKhMnTpVjz/+uLZt26ZTTjlFTz/9tM466yynyzqqsgq/1m4ttBy76NT0akEls3Oanrmiv87+00L9sO+Q/vLhN5q+6DtddGp64Jzv9x5SRuujDwl9/uPcDkkqKCrR6X9coEcuzdSHG3ao0m/Up1OqBndro+bNYvT8om91oLR2QSV7/gbN+CRP917QW9ef2T2i10qHh5227D4oY6TCQ+ValrdHLy35TgfLKpWa0EwPXdxXF/ZLD/vaU9LTtPTukYGfq8IfuycDACSHg8obb7yhO+64Q1OnTtXQoUM1ffp0jRkzRuvXr1eXLl0cqyuSNtJvpC/zrUGlZYs43TTseL2w5Dv9a8IZkoz6dW6pZrExymidqPw9hyQd7o15c+X3gddlz9+gG4edoFMzWuqbHftV6Tfq2SGl2mcu/Xa35eftRaX65YzlSog7PIJ3z5iTdUaPtlr67S49v+hbbS8qjex6ZVRSXqkZn+RJkv7wf+t19eldlBB3ZP2XkvJKLdq0U+1S4gN1Tnr9c+3aX6a9B8vCPqWTdXwbPXFZP6W3TIyoDkmK+bEjh6d+AACSw0HlySef1PXXX68bbrhBkvT000/rvffe07Rp05Sdne1YXZE2kW+syLf8vKu4THeN6aU7Rp2kxObWRd5SE+IkHQr7PvPWFGj+2gIN7NJKq7bsld9IsTE+dWndQr3TU9W5ZaIKikr079Vbw76+pNyvPp1SlXVCG0lSXKx16lFwSArn8fc26svvraFr3HOfaNTJ7RUT41NB4SF9sGGHdh8o+/FamulgWaUqgsJEqxZxSoyLVYv4ZupxXLJGn9Je407tpJiY2g0hVQ05VVQafb/3YK1eCwBoeIlxsWrTSOuBheNYUCkrK9PKlSt11113WY6PHj1aS5cuDfua0tJSlZYe6SUoKioKe159VQ07pCQ0U3GYdVAS42J1qPzwfJEY35H5FAO7tZLP56sWUqTDw0LrthYpJaGZ0tMStXF7seX9jTm8pkiVSr9R7q4Dyt1lnSCb2TlNQ3u01bSF31qOP3DhKYFGvsdxyUpNaKbySqOLB3TSHSNP1OA/fhA497Zzeuj7fYf01bZird9WZAkpx7dN0pY9B/VVQbG+CpmDkxgXq0pjAnsYnZKeqpEnt1fnlom6dGBnxdYylIRT9RbFpRU689GP6v1+AID6ubBfuv58ZX/HPt+xoLJr1y5VVlaqffv2luPt27dXQUFB2NdkZ2frgQceOOa1JcbFKj0tQQO6ttKwE4/T9/sOaXTv9pq1fIvSWyaqX+eW+vibXUpoFquzTmqrHu2StbO4VCccl2z7ntcN7a7UhDiNPLm92iY31879pUpNiNM9c9bohOOS1blVor7deUD9M1pq4cYd2lZYovEDO+vrHfu1o6hEhYfKtb2oVI9c2lftUxN0Tq92apcSr6cXfK2fDemqgV1bBT6rVVJzrbr3XFUao/hmh0PTjcOO1yff7NLp3dto8uiekqQ3V+Tr5Y9z1apFc53apaV8km45u4dKyyv1wVc7tCx3jxLiYtS6RXMN6NpKQ3u0VeGhcv3t083q2qZFnXpMjqZL6xYa2LWV1v5QePSTAQDHXLPYhv3f+dryGYdmLW7dulWdOnXS0qVLlZWVFTj+8MMP629/+5u++uqraq8J16OSkZGhwsJCpaamNkrdAACgfoqKipSWlhZR++1Yj0rbtm0VGxtbrfdkx44d1XpZqsTHxys+3rlxMgAA0LgcW/CtefPmGjhwoHJycizHc3JydMYZZzhUFQAAcBNHn/qZPHmyfv7zn2vQoEHKysrSCy+8oC1btmjChAlOlgUAAFzC0aBy+eWXa/fu3XrwwQe1bds29enTR/PmzVPXrl2dLAsAALiEY5NpG0JtJuMAAAB3qE37zaaEAADAtQgqAADAtQgqAADAtQgqAADAtQgqAADAtQgqAADAtQgqAADAtQgqAADAtQgqAADAtRxdQr++qhbVLSoqcrgSAAAQqap2O5LF8aM6qBQXF0uSMjIyHK4EAADUVnFxsdLS0mo8J6r3+vH7/dq6datSUlLk8/ka9L2LioqUkZGh/Px89hFyIe6P+3GP3I975G5evj/GGBUXFys9PV0xMTXPQonqHpWYmBh17tz5mH5Gamqq5/4PxEu4P+7HPXI/7pG7efX+HK0npQqTaQEAgGsRVAAAgGsRVGzEx8frvvvuU3x8vNOlIAzuj/txj9yPe+Ru3J/DonoyLQAA8DZ6VAAAgGsRVAAAgGsRVAAAgGsRVAAAgGsRVMKYOnWqunfvroSEBA0cOFBLlixxuqQmY/HixRo7dqzS09Pl8/n09ttvW35vjNH999+v9PR0JSYmasSIEVq3bp3lnNLSUk2aNElt27ZVUlKSLrzwQn3//feNeBXelZ2drdNOO00pKSlq166dxo0bp40bN1rO4R45Z9q0acrMzAwsEJaVlaX58+cHfs+9cZ/s7Gz5fD7dcccdgWPcpxAGFrNmzTJxcXHmxRdfNOvXrze33367SUpKMps3b3a6tCZh3rx5ZsqUKWb27NlGkpkzZ47l94888ohJSUkxs2fPNmvWrDGXX3656dixoykqKgqcM2HCBNOpUyeTk5NjVq1aZc4++2zTr18/U1FR0chX4z0/+clPzIwZM8zatWvN6tWrzfnnn2+6dOli9u/fHziHe+ScuXPnmv/85z9m48aNZuPGjeaee+4xcXFxZu3atcYY7o3bLFu2zHTr1s1kZmaa22+/PXCc+2RFUAkxePBgM2HCBMuxXr16mbvuusuhipqu0KDi9/tNhw4dzCOPPBI4VlJSYtLS0szzzz9vjDFm3759Ji4uzsyaNStwzg8//GBiYmLMu+++22i1NxU7duwwksyiRYuMMdwjN2rVqpV56aWXuDcuU1xcbE488USTk5Njhg8fHggq3KfqGPoJUlZWppUrV2r06NGW46NHj9bSpUsdqgpVcnNzVVBQYLk/8fHxGj58eOD+rFy5UuXl5ZZz0tPT1adPH+7hMVBYWChJat26tSTukZtUVlZq1qxZOnDggLKysrg3LjNx4kSdf/75GjVqlOU496m6qN6UsKHt2rVLlZWVat++veV4+/btVVBQ4FBVqFJ1D8Ldn82bNwfOad68uVq1alXtHO5hwzLGaPLkyTrzzDPVp08fSdwjN1izZo2ysrJUUlKi5ORkzZkzR7179w40YNwb582aNUurVq3S8uXLq/2O/x+qjqAShs/ns/xsjKl2DM6py/3hHja8W2+9VV9++aU+/vjjar/jHjmnZ8+eWr16tfbt26fZs2fr2muv1aJFiwK/5944Kz8/X7fffrvef/99JSQk2J7HfTqCoZ8gbdu2VWxsbLVEumPHjmrpFo2vQ4cOklTj/enQoYPKysq0d+9e23NQf5MmTdLcuXP10UcfqXPnzoHj3CPnNW/eXD169NCgQYOUnZ2tfv366ZlnnuHeuMTKlSu1Y8cODRw4UM2aNVOzZs20aNEi/fnPf1azZs0Cf2fu0xEElSDNmzfXwIEDlZOTYzmek5OjM844w6GqUKV79+7q0KGD5f6UlZVp0aJFgfszcOBAxcXFWc7Ztm2b1q5dyz1sAMYY3XrrrXrrrbf04Ycfqnv37pbfc4/cxxij0tJS7o1LjBw5UmvWrNHq1asDX4MGDdLVV1+t1atX6/jjj+c+hXJmDq97VT2e/PLLL5v169ebO+64wyQlJZm8vDynS2sSiouLzeeff24+//xzI8k8+eST5vPPPw88Hv7II4+YtLQ089Zbb5k1a9aYK6+8Muxje507dzYLFiwwq1atMuecc45nH9trbDfffLNJS0szCxcuNNu2bQt8HTx4MHAO98g5d999t1m8eLHJzc01X375pbnnnntMTEyMef/9940x3Bu3Cn7qxxjuUyiCShjPPfec6dq1q2nevLkZMGBA4NFLHHsfffSRkVTt69prrzXGHH5077777jMdOnQw8fHxZtiwYWbNmjWW9zh06JC59dZbTevWrU1iYqK54IILzJYtWxy4Gu8Jd28kmRkzZgTO4R4557rrrgv8b9dxxx1nRo4cGQgpxnBv3Co0qHCfrHzGGONMXw4AAEDNmKMCAABci6ACAABci6ACAABci6ACAABci6ACAABci6ACAABci6ACAABci6ACAEF8Pp/efvvtWr2mW7duevrppxv8fQEQVABPKSgo0KRJk3T88ccrPj5eGRkZGjt2rD744AOnS/O05cuX68Ybb3S6DMCTmjldAICGkZeXp6FDh6ply5Z67LHHlJmZqfLycr333nuaOHGivvrqq2P22WVlZWrevPkxe3+3O+6445wuAfAselQAj7jlllvk8/m0bNkyjR8/XieddJJOOeUUTZ48WZ999lngvC1btuiiiy5ScnKyUlNTddlll2n79u2B33/77be66KKL1L59eyUnJ+u0007TggULLJ/VrVs3PfTQQ/rFL36htLQ0/epXv1JZWZluvfVWdezYUQkJCerWrZuys7MDryksLNSNN96odu3aKTU1Veecc46++OIL2+vJy8uTz+fTP//5T5111llKTEzUaaedpk2bNmn58uUaNGiQkpOTdd5552nnzp2W186YMUMnn3yyEhIS1KtXL02dOjXwu6PVKUm7du3SxRdfrBYtWujEE0/U3Llza/zbhw79fP311xo2bJgSEhLUu3fvajuyA6gFpzcbAlB/u3fvNj6fz/zxj3+s8Ty/32/69+9vzjzzTLNixQrz2WefmQEDBpjhw4cHzlm9erV5/vnnzZdffmk2bdpkpkyZYhISEgI7WBtjTNeuXU1qaqp5/PHHzddff22+/vpr8/jjj5uMjAyzePFik5eXZ5YsWWJee+21wOcOHTrUjB071ixfvtxs2rTJ/PrXvzZt2rQxu3fvDltrbm6ukWR69epl3n33XbN+/XozZMgQM2DAADNixAjz8ccfm1WrVpkePXqYCRMmBF73wgsvmI4dO5rZs2eb7777zsyePdu0bt3azJw50xhjaqzTmMMbL3bu3Nm89tpr5uuvvza33XabSU5Otq2z6u/x1FNPGWOMqaysNH369DEjRowwn3/+uVm0aJHp37+/kWTmzJlT4/0BUB1BBfCA//73v0aSeeutt2o87/333zexsbGWXVbXrVtnJJlly5bZvq53797mL3/5S+Dnrl27mnHjxlnOmTRpkjnnnHOM3++v9voPPvjApKammpKSEsvxE044wUyfPj3sZ1YFlZdeeilw7PXXXzeSzAcffBA4lp2dbXr27Bn4OSMjwxI8jDHmD3/4g8nKyjpqncYcDiq/+93vAj/v37/f+Hw+M3/+/LDnG2MNKu+9956JjY01+fn5gd/Pnz+foALUEUM/gAeYHzdB9/l8NZ63YcMGZWRkKCMjI3Csd+/eatmypTZs2CBJOnDggO68887A8eTkZH311VfasmWL5b0GDRpk+fkXv/iFVq9erZ49e+q2227T+++/H/jdypUrtX//frVp00bJycmBr9zcXH377bc11pyZmRn4vn379pKkvn37Wo7t2LFDkrRz507l5+fr+uuvt3zOQw89FPicmuoM95lJSUlKSUkJfMbRbNiwQV26dFHnzp0Dx7KysiJ6LYDqmEwLeMCJJ54on8+nDRs2aNy4cbbnGWPChpng4//7v/+r9957T3/605/Uo0cPJSYmavz48SorK7O8JikpyfLzgAEDlJubq/nz52vBggW67LLLNGrUKP3rX/+S3+9Xx44dtXDhwmqf3bJlyxqvLS4uLvB9VY2hx/x+vyQF/vviiy/q9NNPt7xPbGzsUesM95mhn3E0VaEx9PUA6oagAnhA69at9ZOf/ETPPfecbrvttmohYt++fWrZsqV69+6tLVu2KD8/P9Crsn79ehUWFurkk0+WJC1ZskS/+MUvdPHFF0uS9u/fr7y8vIjqSE1N1eWXX67LL79c48eP13nnnac9e/ZowIABKigoULNmzdStW7cGu+5Q7du3V6dOnfTdd9/p6quvrnWdrVu3rncNVX/jrVu3Kj09XZL06aef1vt9gaaKoAJ4xNSpU3XGGWdo8ODBevDBB5WZmamKigrl5ORo2rRp2rBhg0aNGqXMzExdffXVevrpp1VRUaFbbrlFw4cPDwzl9OjRQ2+99ZbGjh0rn8+ne++9N6LehKeeekodO3bUqaeeqpiYGL355pvq0KGDWrZsqVGjRikrK0vjxo3To48+qp49e2rr1q2aN2+exo0bV20YqT7uv/9+3XbbbUpNTdWYMWNUWlqqFStWaO/evZo8eXKNdTaEUaNGqWfPnrrmmmv0xBNPqKioSFOmTGmQ9waaIuaoAB7RvXt3rVq1SmeffbZ+/etfq0+fPjr33HP1wQcfaNq0aZKOrI7aqlUrDRs2TKNGjdLxxx+vN954I/A+Tz31lFq1aqUzzjhDY8eO1U9+8hMNGDDgqJ+fnJysRx99VIMGDdJpp52mvLw8zZs3TzExMfL5fJo3b56GDRum6667TieddJKuuOIK5eXlBeadNJQbbrhBL730kmbOnKm+fftq+PDhmjlzprp3737UOhtCTEyM5syZo9LSUg0ePFg33HCDHn744QZ5b6Ap8plwA6oAAAAuQI8KAABwLYIKAABwLYIKAABwLYIKAABwLYIKAABwLYIKAABwLYIKAABwLYIKAABwLYIKAABwLYIKAABwLYIKAABwLYIKAABwrf8PK4oC6JZrLJgAAAAASUVORK5CYII=", - "text/plain": [ - "<Figure size 640x480 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 1440x480 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ @@ -764,7 +743,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 27, "id": "a2946a86-77ac-466f-8869-aa91f5e2602c", "metadata": {}, "outputs": [ @@ -772,34 +751,77 @@ "name": "stdout", "output_type": "stream", "text": [ - "(13, 37, 2)\n", - "(12, 36)\n" + "(60, 180)\n", + "(22082, 1)\n", + "(10800,)\n", + "(22082, 1)\n" ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ "import numpy as np\n", - "mod_idx='test1'\n", - "nelx=36\n", - "nely=12\n", - "global_density = np.load('results/top88_' + mod_idx + '_xPhys_' + str(nelx) + '_' + str(nely) + '.npy')\n", - "global_displace = np.load('results/top88_' + mod_idx + '_u_' + str(nelx) + '_' + str(nely) + '.npy')\n", - "global_displace = global_displace.reshape(nelx+1,nely+1,2)\n", - "global_displace = np.dstack((global_displace[:,:,0].T, global_displace[:,:,1].T))\n", + "from matplotlib import colors\n", + "import matplotlib.pyplot as plt\n", + "\n", + "mod_idx='mod1'\n", + "nelx=180\n", + "nely=60\n", + "global_density = np.load('datasets/train/180_60/xPhys/mod1.npy')\n", + "global_displace = np.load('datasets/train/180_60/u/mod1.npy')\n", "\n", + "global_density_py = np.load('results/top88_py88_xPhys_180_60.npy')\n", + "global_displace_py = np.load('results/top88_py88_u_180_60.npy')\n", + "\n", + "# global_displace = global_displace.reshape(nelx+1,nely+1,2)\n", + "# global_displace = np.dstack((global_displace[:,:,0].T, global_displace[:,:,1].T))\n", + "\n", + "print(global_density.shape)\n", "print(global_displace.shape)\n", - "print(global_density.shape)\n" + "\n", + "print(global_density_py.shape)\n", + "print(global_displace_py.shape)\n", + "\n", + "fig,ax = plt.subplots()\n", + "im = ax.imshow(-global_density.reshape(nely,nelx), cmap='gray',\\\n", + "interpolation='none',norm=colors.Normalize(vmin=-1,vmax=0))\n", + "fig.show()\n", + "\n", + "fig,ax = plt.subplots()\n", + "im = ax.imshow(-global_density_py.reshape(nelx,nely).T, cmap='gray',\\\n", + "interpolation='none',norm=colors.Normalize(vmin=-1,vmax=0))\n", + "fig.show()\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 29, "id": "9178f774", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAGOCAYAAABbv05eAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9abAdZ37eCf7+75uZZ7k7doIgCIIbuKhUZFWRBKpklSS7ZtRuS7baY7fkUbjd9tg9pXZY4Q/qjvY4otztKIXVbnV9UFvR0sTIGk+rrenpkO0YS7LKY6tUEqvKVSRAgAQIgiB2Yr37PUsu7/ufD3ny1LmXdz3nXFyAzEdRQeHek+fNe07m++R/ex5RVaVEiRIlSpQYIsxOn0CJEiVKlPj4oSSXEiVKlCgxdJTkUqJEiRIlho6SXEqUKFGixNBRkkuJEiVKlBg6SnIpUaJEiRJDR0kuJUqUKFFi6CjJpUSJEiVKDB0luZQoUaJEiaGjJJcSJUqUKDF0lORSokSJEiWGjpJcSpQoUaLE0FGSS4kSJUqUGDpKcilRokSJEkNHSS4lSpQoUWLoKMmlRIkSJUoMHSW5lChRokSJoaMklxIlSpQoMXSU5FKiRIkSJYaOklxKlChRosTQUZJLiRIlSpQYOkpyKVGiRIkSQ0dJLiVKlChRYugoyaVEiRIlSgwdJbmUKFGiRImhoySXEiVKlCgxdJTkUqJEiRIlho6SXEqUKFGixNBRkkuJEiVKlBg6SnIpUaJEiRJDR0kuJUqUKFFi6CjJpUSJEiVKDB0luZQoUaJEiaGjJJcSJUqUKDF0lORSokSJEiWGjpJcSpQoUaLE0BHs9AmU+GRBVXHOEccx1tru/4wpn3NKlPg4oSSXEvcNqkqapmRZRhzH3Z8bYwiCgCAISrIpUeJjAlFV3emTKPHxh3OONE3x3iMiJEmCMQZVRVXx3qOqiAgiUpJNiRIPOUpyKbGtUFWyLCPLMgBEpBvBiMiqry+IpkDxuiiKCMOQIAhWPbZEiRIPDsq0WIltg/e+G60A3aikII4iUumFiGCt7f67IJtvf/vbPPvss0xOTmKMwVq7LLopyaZEiQcLJbmUGDoKQkjTdFmqa+VrNkMIBdkU/7XWdt87SRJEpEs2YRh2X1OSTYkSO4uSXEoMFUXKyzkHsCqx9IPiPdaKbFaSzcqaTUk2JUrcX5TkUmJoKDZ55xzGmKFu6L3ptJU/L8im+L33niRJiOO4JJsSJXYIJbmUGBjF7MrFixepVCocOHBgRzbvYs2SbEqU2HmU5FJiIPSmwebn5xkdHd2WjXqtyGWjY2A52RT/i+OYJEmA1edsSrIpUWIwlORSom8UEYH3HmNMd25lI+zUxt1b/7HWfoRseiObouW5mLEpyaZEia2hJJcSW0aRBiu6wYrNdyvRxVY3634il82851pkMz09zQcffMCnPvWpkmxKlOgDJbmU2BK892RZ1u0G691ot4MA7id6ycYYQ7PZ7EZj7Xa7+5qVMzYl2ZQo8VGU5FJiU9jM7Mp2kstOEVchO9Mb2Xjvu2RTpANLsilRYjlKcimxIVaTcFlt83zYI5eNsFYazXtPHMe02+2SbEqU6KAklxLrond2pSh2r4WPY+SyHlaSbEE2zrmurUBvg0CRThvWYGmJEg8ySnIpsSqKTTLLsm432EYbooh0dcS265weZBSkURBwL9lkWdb9/Wq6aCXZlPi4oSSXEh/BSgmXzaZ1tjtyediwFtlkWdZVhS7IplcXrbQXKPFxQEkuJZbBOUe73e5uilvZ1Lc7dfWgRy4bYSOycc5x584dDh8+XJJNiYce5VVbAvh+0f7evXt84xvf6KsIXUYuW0OvFE0Yhnjvef/998myjGazyeLiIgsLCywtLdFut5fZF5Qo8aCjjFxKLEuDFQTRz2ZeRi6DodeFE74f2fQqPpcunSUeFpTk8glHr/1w4YvS79NxGbkMhpWf3WpptKJ7L03T7mt6yaZ06SzxoKAkl08oVs6uFGmwzeqDrYatyr9sdZ2Pe+SyUcS4GS+bXrIpXTpL7CRKcvkEYqX9cG9apdj0+0mNlZHL4NhqA8VmjNNKl84SO4GSXD5B6N181ppdKf79IJLLJyFyGQSlS2eJBwkluXxCsNnZld78/lbxSSCA7caw3TtL47QSO4WSXD4B2Ir9cG/kslVs54T+J4G4tvPvW8+l8+zZs0RRxOHDh0uyKTE0lOTyMUa/Ei5AXyRRbkKD4359hr1k473vRjmFCGfp0lliUJTk8jFFvxIug6TFjDFl5DIAdurv67VQKAhkI5fOou25VHwusRZKcvkYIssyZmZmqNfrW557GCQtttnjbt++zdmzZ6lWq0xNTTE1NcXExMSyYvQnFTuxURduoivPYy2Xzl7jtNKls8RaKMnlY4RidqXdbvOtb32LH/mRH+mr4wv6S4ttNCPjvef8+fPcuHGDp59+GlVlbm6Os2fPkmUZExMTXbIZGxtbtUX644ydjlzWw2bJpnTpLFGgJJePCVa2GA+Cfjfy9Y5rNpu89dZbqCqvvfYaURThvefgwYOoKs1mk9nZWWZnZ7l69Sqq2iWaqamp7kb2ccdORS79PISsZZxWkk0JKMnlocdq9sNFeqnf+ke/U/prkcvt27c5c+YMBw8e5Nlnn8UY05UvKY4bGRlhZGSEQ4cOoaosLi4yOzvL9PQ0Fy9eBKDVahGGIVNTU9Rqtb7+tgcZD3LkshFKl84SK1GSy0OMlUX73ht8kDRSvy3FK9fsTYO9+OKLHDhwoHveG73P+Pg44+PjPP7443jvu1HPzZs3OX/+PJVKpRvV7Nq1iyiKtny+DyJ2YqMtusWGiZUGaKu5dC4sLBBFEZOTk6VL58cQJbk8pNhodmWQzq1hRC69abDjx48zMjLS17kU51OpVKjX6xw5coQsy5ifn++m0M6ePcvIyMiyNFqhLPww4WGOXDbCaiKc169fZ3x8nEqlsqxbrXTp/Hjg4bsDP+HY7OzKIOQyaM1lZRpsWF1gxTkFQcDu3bvZvXs3AGmadus1Fy9epNVqMTY29lB2oj0sNZdBUaxXeNms59K5Mo1W4uFASS4PEbYyu7ITabFiJuLMmTO88MILPPLII32tv9Y5rYUwDNm3bx/79u0DoN1ud8nm3LlzpGnK+Pg4u3btWrUT7UHBxzlyWQ296bjVIpvSEvrhRkkuDwkKTajNTtrf77RYs9nk3LlzeO/5whe+MFAabC1s9pyq1SqPPPIIjzzyyKY60UZGRh6Y1MsnJXIB1u1s3IhsYHX1gJJsHhyU5PKAo0iDFd1gW5m0v19psSINtnv3btI03RZi6XfzW60TbWlpaVknmrV2WXPATnWifdIil9WGN9fCWmRTKD5DSTYPGkpyeYDhvSfLsi1LuMD9SYv1doO98MIL1Ot13njjjU29/07J+YsIY2NjjI2NcfjwYbz3LCwsMDs7y61bt3jvvfeoVCqMjo52u5oqlcrA627l/O43HoS02FaxGtmULp0PFkpyeQBRPJE1m81lnTRbwXanxVqtFqdOncJ73+0GW1hYeOgGHY0xTE5OMjk5yRNPPIFzjrm5OW7duoVzjj/5kz9Z1ok2OTlJGIbbci6ftMhlGAO/BdbzslmNbEqXzu1HSS4PGIq88vT0NG+99RZf/OIX+7oBBpG/3yhKuHPnDmfOnOHAgQMcO3ase1Nvp0TL/ZJ/sdaye/duwjBkZmaG1157bVknWrPZZHx8fNs60T5JkctW0mJbxXpkMzs7y507d3jqqadKl85tREkuDxBWzq4Mkjbod1YF1iYm7z3vvfce165d48UXX/xIN9jHUf9rs51oRb1mkE60T2Lkcj8tBgqyybKM2dnZZTWbIsVW2gsMDyW5PABYbXYlCIKB5OuHXdDvTYOdOHFi1aL9Vshlp2oug2JlJ1qr1WJmZobZ2VmuXbuGqjI5Odklm612on3cIoj1MMy0WD/rli6d24uSXHYYa82uDOqNMshmvDLqWSsNNsw1H0aICPV6nXq9/pFOtNnZWS5duoQxZlnbc61WW3OD+qRFLjtJar3XcK8mWnFexetKsukfJbnsINabXSk2+H5v/EEjF+/9sjTYCy+8wMGDBzc8brMb5FY30kFqSPcL63Wi3b59u9uJ1ks2KzvRPkk1l/uZFlu57nqkth7ZlC6dm0dJLjuAzcyuFBf/yqeszWJQckmShO985zvrpsFWOw62b7N62KKitTrRihTaSk20LMs+UeSyU5FLUdPcLHrJZjWXzl6yKV06v4+SXO4zNivhMii5DJKiStOUDz74gIMHD/Lcc89tev3tJJePw01adKKtpYnWbDax1nLx4sX7qom2E+RSdG89iJHLRugdDShdOtdGSS73EUW0shkJl15y6Qf9RC5FGmx+fp79+/fz4osvbun4XnLZDjxskctGWNmJdu3aNW7cuEEcx5w7d44kSbrunIN2oq2HnSIX4GPRSFCSzeooyeU+oJhdybIM2NykffH7+0UurVaLt956C+cce/fuZWxsbMtrbie5fJxvwgJBEBBFEc8//3y3E62IbK5fv473vtuJNjU1xejo6FA+l08iuWxnRLge2Vy9epXFxcXujM3H2TitJJdtRq/9MGxe+qR43f3QByu6wfbv389zzz3H2bNn+5bchzJyGQS9KsFFJ9qjjz46cCfaWhikaWQQ9N4P9xv3uwW6954vRg6Kh7+Ps0tnSS7bhN6J4M0qGa/EIIOQm4lcvPdcuHCBq1evLusG65fUtkIu/cy5fNyx3ue2mU60KIq6tgKrdaKtt+YnLXLZKTM559xHBDVXc+lcrfX5YSObkly2AUXR/u2332bXrl0cOHBgx9qJ10KRBsuyjOPHjzM6Orps3TJy2Rls9jrZTCdavV7vks1ammg7RS47Gbk453bMFrsgl16sJsK5kmx++qd/mr/6V/8qP/3TP70Tp90XSnIZMnolXNrtdtfoqB8MKj5ZdKStxMo02GoX+4NGLg/TE1u/GORzW60TbW5ujpmZmW4nWuHOuWvXrm4n2k6SSz+CrMNae6ek+Fcjl5VYjWxu3br10Fl3P1xn+wBjNQmX9Tb4zWBQcll57FppsJUYNC22mWP72VTKyGXzCMOQvXv3snfvXgDiOGZ2dpaZmZllnWgTExPA/f9sd2rGBba/oL8e+omaRIRms0m9Xt+ms9oelOQyBKw1u2KtfWD0wdZLg2107FbX3Q6UkctgqFQqHDhwgAMHDizrRJuengbgW9/61rZ0oq2FnZpxKdZ+mIhNVWk0Gn11cO4kSnIZEOvNrgyqDzasyOXu3bucPn16zTTYasduZyMB0M0nb8WJsIxchrdG0Ym2Z88e7t27x0svvdSt2QyrE2097HRq6mFbu9FobIvD63aiJJc+0Tu7sp6Ey05GLs45zp8/v2EabLVjBznvjUhgdnaWU6dOdVMzu3bt6g4JfhIilLWwE+RZrDk2Nsb4+Hi3E21xcZGZmZllnWhFvWaznWgbrbuT0cODXHNZDUXN7GFCSS59YLP2wztZc3HOMTs7S6vV2jANthLDVFTuhapy5coVLly4wJNPPsnk5CTz8/PMzMxw9epVgGUbWO/Tchm5bA+KGZeVEXdRjyk60YrvqbcTrfiu+nHn/FinxbyHVgtWiTT6IZckSUjTdEv38IOAkly2gN7ZldVuypWw1nan8vtBv+Ry9+5dPvjgA4Ig4Pjx41u+mAc1Glvt2CzLePvtt5mdneWzn/0sY2Nj3RumGBJc+bRcqVS6ROOc+9iTy05FLhtt8tbabnQJ3+9Em52d5YMPPujWA3qtoDe65na67rGda9vf/33cj//4mmtv9X5cWloCKMnl44qVRfvNtFHe77RYbzfYwYMHWVpauu+il6sdu7i4yKlTp6hWq5w4cYJKpfIR0hURxsfHGR8f58iRI925jZmZGa5cudL9W95///1lrbQfN+xU5LIVrNWJNjs7y7vvvrtME21qaorx8fGPbOY7nRbbrmtHbt3CXL2KW+Mz7afmsrS01K2TPUwoyWUTWGk/vJVBt/uVFmu327z11lukacrx48dZXFxkcXGxr3WHKTvz4Ycf8s477/D444/z9NNPb/qzWzm3cfnyZe7cuUOSJF174d56zXZ3N90PPKiRy0ZYqxNtPU20j2taLPyVXyH7y395zd/3kxYr2pB3ioz7RUku62C12ZWt3BDDcJPczPFFN9i+fft4/vnnsdbSaDQG6jQbNHLx3vPuu+9y8+ZNfvAHf7Cr/NsvwjCkUql0RR2bzWZ3buPy5cvd7qbees3Dhp0SkBzmmqtpojUaja4VdNGJVq1WybKMZrM59E60jbBd3WLmm99EZmfxP/AD667dT1psq3bZDwJKclkDqsrc3Bze++5Tw1a/3O2ec/He8/7773PlyhWef/55Hn300e7vBo0+Bjm23W7zne98B1Xl+PHjQwvne6fJR0ZGGBkZ4dChQ8u6m27evMn58+epVqvLdLa2WnD+pGC7CU1EGB0dZXR0dFkn2pUrV2i1WnznO9/pdqIVDweDdqKth+LBZ+jk0mwS/uZvkP3MX9lw7a2Sy8PYhgwluayKwn748uXLiAjPPfdcX++znTWXlWmwlcW+QWdV+j3WOcfZs2c5cODAlozGNsJG3je93U1ZlnXrNZcuXeLtt99mfHx8mfTJg5hi+DhELhuh+K527dqFqvLiiy8yPz/fTaGdO3eu24m2HQ8GxXU91JrLhzeo/P3/G4yM4H70x9Z8WXEvl5HLJxAr7YeH0e21HTWX3jTYc889t6rm0DCn+zcDVeXixYvEccyRI0c4duzYhmtsFZs9pyAI2LNnD3v27AHygvPMzAwzMzO88847ZFnG5ORkt17zMN64w8JO1T6Kgn5vJ9qTTz65rBOteDDYaifaeijuiWE9XMi7Z4n+h3+MNJZI/q9fXve1vaMLW0Gz2Swjl4cZq82uWGuJ47jv9xx2Wmy9NNhKDNrxtZXzTpKE06dPdwuPRcvqMDHIBlipVHjkkUd45JFHujWAol5z6dIlrLXL6jXVanWIZ755fBIilwJrkdp6nWjnz58njmPGx8e739VqnWgbrQvDIRf51jeJ/p+/iTSW8M8dw3/2c+u+vl9yKSKXhw2feHJZb3ZlJ7XBiuOLyGmjNNgw195KWmx+fp6TJ08yPj7O8ePH+e53v/tAS+731gAee+wxvPfdtMyNGzd49913qdVq3Y6mLMseOjXarWAnyWUzm+zKTrR2u91tDig60Yo022Y00XpHCfpGEhP8s1/Hfu97SCMGC+nf+FsbHlYU87e6dqPReOhmXOATTi4r7YdXzq5Ya3dswr73+M2kwYa59maiHlXl2rVrnD9/nqeeeoojR450P7+HySysV0Pr6NGj3bTMrVu3cM7xzW9+c1m9ZqtPylvBJyly6WddEaFWq/Hoo48u60TrjUJFZFlzwMpOtH6N+7rn8P55wv/1NzG3boIK4jKyH/nT6KOHNjy23/maZrNZksvDhN7ZlV7vhF4MgxwGIScRYX5+ntu3b/Pcc89x6NDGF3DvsduVFsuyjLNnz3Lv3j0+85nPLEuDbWXdrd7g92MOpEjLVCoV5ubm+NznPtet19y4cQPv/bLNq16vD72V937iQY9c1sNqUeji4iKzs7PcuXOH999/nzAMl31ffa/bahL8zm9h3nkLmVtCM4dpttCxEdKf/aubeotPkmglfALJZSuzK4NGLoOk1drtNtevXydJEl577bUti9ZtV+SytLTEqVOnCMOQEydOfKQ+sV0aYDtVcK9Wqxw8eJCDBw8u87Gfnp7m4sWL3c1rGIKOD+sQZb/rDjsC7O0aLFQeelOe586do1Kp4L3nzp07m+5EM9/5BvYPfx8zNwuNFHEpZB61Qvqf/p+hsrkaXb+ilUtLSw+daCV8wshlLd+VtbBTqsb37t3j9OnT1Go1RkZG+rqwirpJP5vHWjWXW7ducebMGR577DGeeeaZVTeH7SSXndYWE1nuY9+7eRWCjiMjI8vma7a6mXySIpftlu9ZqYmWZRnXr1/nypUr3U600dHRZVbQveckNy5hf/9/Rz68jl1qo5lHkhi1IabVxD9xFPfFP73p8+mXXBqNBo888siWj9tpfGLIpZhd2UrOdRg1l60MbXnvuXjxIpcvX+7O1ty8ebOvtYu/r9/cdu9G7r3nvffe4/r163zqU59i//79mz7244zV2miL/P97771HHMddja3CUmC96+CTFLl47+/7YGsQBIyOjlKtVnn11VdJkqTbHNDbiba7GnHo9DepXb2ItFOk0QbvkVYMgUWaLTQKSP7G+q3HKzFIzeVh0xWDTwC5rJxd2UoxbxjkApvLLxfdYL1psA8//HCgjq/Nrr0SvTWXlV1qG+V+P86Ry0YIw5B9+/Z1pW5arVa3XnPt2jWAdYvN8MmJXHZKuLL3foiiqNuJBtBaWiL79/8Cc/o7LM0s0IpjQi9URAhsSGgALGKE7Mf+D+ihw1tae5DIpSzoP2DYahpsJQZNixUX0kbvUaTB9uzZw2c+85luN9igdRPo72m4iLimp6d566232LNnD5/97Gc3dWNsJwk86OSyEis7mwqJmrt373LhwgWiKOpGPlNTUzvWLbZTm/yD1Ehgzn2XiW9/HWbnwUbI6AhZtY5bWCB20J6ZxpmQauqQvXtp//hPUt/i9zVIQb8klwcIzjmuX79OvV7v2+FwmJHLalBV3n///W4abGU32KCzKuutvRGcc7z55pscO3aMQ4cObfrz+7gV9IeFtSwFZmdnuXLlCu+88w5hGFKtVpmZmblvlgIPc7fYMNaVW5cJ/uT/i9z+EFopkmZIqw0oYZYR1mtU4wx27yFtxWQ25cKP/jgfnjy5rBNtM8O3g7hQluTyAKB3duXKlSs8+uijjI+P9/VeRStxvzdgMfex2gbfbrc5ffo0cRyv2Q02jMhlq8enacq5c+dQVV555RUmJia2vG4ZuWyMlZYCSZLwzjvvfMRSoLdesx0k8DDNuQwD3bpHc5Hg2/8K+eA9TJJCM0aSBM08oOAEBNQLAqgNiUKHvPYFnvnzf5EnV3SiFcO362mi9VNzKWZ5ylbkHUYxu9IrEDeMtNYgN8Jqsy69abCXX355zaHIQcllqxv9wsICJ0+e7MrV90PKZeTSH6Iool6vMz4+ztGjR5fVa65cuYKIdNNnRb1mGPjERS5Zxu4rJwne/tfIUhObJGjskCxGjUU0RU2IxC00CDHNNmotpt1Gx8fJfuavA6t3oq0USx0dHV0mluqc60vtoWxF3kH0Srj0doMNY04FBvN/6CW4lWmwRx999IFphS4UaY8ePcrBgwf5xje+MZROs2Hi4xS5rIZeS4HCE2WlpcBKC+iCcPrtvPokFfTl2tvs+eN/icxMYys1JG6DWiRtgwmQVodIWm3UGqQdo0bymZbAkPz0fw5rpL5WiqUmSdLtHCw60YIgYGRkhNnZ2S0pc5c1lx3CekX77a6ZbPY9vPebSoOtdeyga6+HQiL/zp07vPTSS+zZs4ckSYD+NvMycukfa230a1kKrFQOLshmKxvXThbW79e6MncL+73fw9y+QTgzg09TxHtQhSRGUDTNEAEcYAQIwWRoUEWyBu4HP4v/1Gc2vWYURezfv7/btt9qtThz5gxZli1T5i5SaGulPQtjvDItdp+xkf3wMMhFRAZ+j9nZWU6ePLlhGmy1Ywd1slxvo282m5w8eRJjDCdOnOimWgbpNBvEaGwjfNwjl81iNUuB4il5paXARmKOH+u0WNzAnPm3mMvnMK0Y02ojSZswyaBWAW9BwNsKJm3hgwqm1cKbENNu441BWi0YGSX9T//zgU6lVqtRqVTYs2cPBw8e7Gqizc7Odn2jeus1haxQu93GOVemxe4XNivhMii5wGD6YEVU9f7773cl8u9nK/R6x9+5c4fTp09z8OBBjh07tryDps9mgN5jh41PcuSyEVYqBzebzW69prAV7q3X9HY1fSzTYj7Dnv9j5MIbSKOJpBmm1UTSGBCMeDSsYZpN1AZIu41aQeI2asgL+0aQDDCQ/NRfgfrgkUOvKvJKTbSlpaVum/r7779PEAT87u/+brehZjvSYr/4i7/If/Pf/Df8nb/zd/ja174G5N/LP/gH/4Bf+7VfY3Z2lldffZX/6X/6n3jhhRe2/P4PHblsZXbFWkuapgOt129TQJEGc87x9NNPb0l0ssAgEi6wehTR6wnz4osvriorUdz0ZeTy8EHk+xbQxca1sLCwzAK66GratWtXV7j1fmNb0mKqmKsn4fy3MPPzmHY7JxQHkjTx0Sh2/i4aVXIisQKZAyuoN4jxqISIjVETIUkbd+xF/GdODOX01qrdGmM+0qa+sLDA7/7u7/Lbv/3bALz88sv86I/+KD/2Yz/Gj/3Yjw3smfTd736XX/u1X+NTn/rUsp//0i/9Er/8y7/MP/2n/5RnnnmGf/gP/yF/5s/8Gc6fP791fcOBzvA+wzlHHMdkWdZVMl7vAt2pyGV6eprXX3+dSqXC+Ph432KGg0QQ8FGNsDiO+d73vsft27c5fvz4mnpFg6bFyppLf9iOKMIYw+TkJEePHuUzn/kMP/RDP8STTz6JiHDx4kWuXbvGvXv3+OCDD5ibm9u2B4OVGHZaTG6fw37z/4558+sE87PYxXlM3ECDCNNeBCOYNEYDi5owbzMOq4CHIEKyDIIQE8dgLNKOYXSE9D/9vwztHDc751KY1331q1/ln/2zf8bo6Cj/+B//Y2q1Gv/df/ff8S/+xb8Y6DyWlpb4K3/lr/Drv/7rTE1NdX+uqnzta1/j7/29v8dP/dRP8eKLL/Kbv/mbNJtNfuu3fmvL6zwUkUvv7MpWJFyGQS5biVxW6wb73ve+1/c59DYU9DN81ZsWm52d5dSpU0xNTW1Y9xk0LbYZcrlz5w4ffvghk5OT7N69e8PW2odB/uVhQBAEy5wez507R7vd7hacvffL6jXbZQE9rLSYzFzDnP8GMnsT02hjXIq0mkjcQCsjmPYSqg6tTkK7SWYslTSB+ggSt8BYiFPEmnzGxQpgwAjpn/2LMNbfjNxq6GeIcmlpidHRUf7cn/tz/MRP/AQweAT/cz/3c/zZP/tn+dN/+k/zD//hP+z+/NKlS9y6dYsvfelL3Z9VKhV++Id/mNdff52/9bc2NkTrxQNPLqvZD29FG2zQJ7HNElQcx7z11lu02+1l3WCDnMOg3WpFiury5ctcuHCBZ555hsOHD2/q8+t3M98oLaaqXLhwgStXrnDw4EHu3LnDhQsXqFary1prP87uj2thJ+of1lpGR0d5+umnuwN7MzMzXUuBIAiW1WsGsRToxaBpMVm8DRe+gb17HZskSKvdmVWJMNMf4kcn0bCOadzB18agtYQEAWQeCS2IQcSgpgLSxNsISVtoUIF2G3/0WdwrPzyUv7VAPw+Jqw1QDvK5/fN//s958803+e53v/uR3926dQvgI8K0+/fv58qVK1te64G9g9ezH94srLVdl8l+sZm0WKHBtXv37o9EBTsp4SIiXLp0iXa7zWc/+9llIfBm1h52WixJEk6fPk2z2eTVV18liqKulXMxgHbx4kVarVbXJ3337t3dNs37GbnsVBpuJ7XFegvNhw8f7lpAF0Zp586dY2RkpEs0k5OTfT8E9B25tOaQ97+JuX0J225hshgyRVwMPsPM3kV8ikZVJG5ApZLPsFTAE2JYwJlaRzrfIu0magzSboMASQLVKulf/ut9/V3roZ95uYJchnFdXLt2jb/zd/4Of/AHf7CuVM3Ktfp96HkgyUVVWVhYYHFxkd27d/dFLDC8yGU9bbCLFy9y6dKlNTW47veUfYHFxUUWFxep1+t8/vOfJ4qiLa89iOjlShTT/2NjYxw/fhxrbXeeZmVr7WpqwmNjYzjnaLfbG2o4Pax40CT3ey2gga6lwOzsLBcuXKDdbncfAjZjKdCLLUcurVnkgz/B3LmMTdpIu41kCQRVxDfACFqZwDTm0WoEtXFYmsXXx/NuMARJ23gRoixDoxBSj1qDOhArqLeIJGQ/+ufQicEK5itRPCwPI3LpF2+88QZ37tzhM5/5/ryOc44/+qM/4ld+5Vc4f/48kEcwvfXYO3furGuzsRYeOHIpopXZ2Vk++OADPv/5z/f9XttZ0I/jmNOnT9NqtdYdihzU6rgfcvrwww955513qFQqPP7441smFhis62vlJlmcz9GjRzl69OiG792rJlxMp9+8eZO5uTm+9a1vUavVlqXQ7ofA4/3Cg6yKvJqlQDFfc/369a4FdPG9rGUBXXRAbmrdeBEuf4vg9vuYOEayGEmTfKpeBLIY6FxLLkWjClodQZIGVGuQJKiASoBYJVODGNAiDWZDJGmjtpJ3lB06QvaFL617Sv2g2AP6qbkMi1x+7Md+jDNnziz72V/7a3+NY8eO8V/9V/8VR48e5cCBA3z961/npZdeAvJswze+8Q3+0T/6R1te74Ehl5WzK2EYDqUYvx0F/enpaU6fPs2uXbt46aWX1k0NDBo9bYVcvPecO3eOW7du8YM/+INcu3at76fhftNivcd57zl//jw3btzg05/+dLeIvNX3KybO79y5w/Hjx5mbm2N6erpryFUUoHft2rXuwOCDjgctctkItVqNWq22zAK6d1YjDMNl9ZriIaf4O9c1TmsvIle/hb1zAZNkmDhPgfmwhmnPYxbu4iYfJfjwDBpEuN1PID4Da9DqBBI389dmzXzKvt0CG2KzFK1V8mJ+ECCtBIxB4hiikPQ/GX46DL6f2u4nchnWjMvY2Bgvvvjisp+NjIywe/fu7s9//ud/nq9+9as8/fTTPP3003z1q1+lXq/zMz/zM1te74Egl9VmV4IgeCDIpTfy2EwabL3j+11/M+TSarU4deoUqsrx48ep1+vcuHFjoJTcIDWXOI45deoUaZpy4sSJVZ30trKpFa8Nw7Db7aSqy1Joly9f7g4MFv8bVgH6fuFhNQsT+b4F9OOPP961gC5Sm2fPnu1aCheCqKut65vzcON1grtXsGmC8Q7TWkCSFriU8O5FJIvzF1uLViodUgkAxdfG83pKWO1EJAbSBDGdbrBAEDVgAfIoxkuAmJj0819C92w9/bMZFPNEW/2s77f0yy/8wi/QarX48pe/3B2i/IM/+IO+FAJ2nFzWsh8eRjF+WJFLMV9TpMFeffXVTSsGG2MGGuTcDLncvXuX06dPc+DAAY4dO9Z9OhqkCN5vWkxEiOOY119/nV27di0zP1sNW9ncVv4tqwk8LiwsMD093RXiLDa0QnPrQU6hPWyRy3pYqRrcK+R44cIFAM6cOdN9zYj1cOt7BNOXCJIEk8Z5sR7BLN7GtObI9j0D8Txu7xFULDjFHXgaMNDutBUTQmCBINcGkwoma+QSL1mLFIvxGRrVOkKVIdJq4/fsx33xzw39cyiwlkTVRihakbcLf/iHf7js3yLCV77yFb7yla8M/N47Ri4b2Q8Xm/qgcvdb8bBfDdZams1md7PcKA222jlsV+TSG0kV8jKbPXYz6/az2RVPq8eOHePxxx9f97vbyne7mdcVA4OTk5NdT/siqik8UnpTaNs1wzEIHtbIZSP0Cjm2221ef/119u7dy/y9y8SXfo/JeJYRNdSNJ9IMYy0+qBPePA0o2cFjqESgir33PtneZ5HWNDq2F00VqVTz6fo4JwzaLSD4fjdY3EaFXGK/VkWSNK/ZpGmeDvvzfy3/9zZhEIvjrXR5PkjYEXLZjIRLsYH3O0DY+x79SuarKvPz88zNzfH8889vyZGxwHbVXHrbetdqKBikKL/VY733nD17lrt37zI5OcmRI0f6Wnc9bJXswjDsbmgrNbc++OCD7gzH7t27mZqa6qvxYZjYichlJ1SRXXqPXeOX2ZPN8ChzVEYEVJDmXbJEydot6q7BwthhGNuLTVrYex+ADRAS/Ngu8AmEYV6Yz1ookhfvjYE0y4ciU4XAgDNgFFWLCkAIkuVRSxbjXv4CevDx7f2b+ySXVqvFY489tg1ntP3YEXIpLub1cpC9Xir9kktBKM65LftdFGmwpaUl9uzZ0/cXvB3ik3Nzc5w6dYqJiQmOHz++5t/Wb/Sx1WOLeg/A0aNHmZub62vN9TDoBrhSc6u3JlDYDPfK1u+EkVVxnvcT9ytySbMZ2u3zpHMfYppN9s7eYsxkGOeI7pxDkgZu8giVuctotUo7fJwoWSKKZ0mkwmz9ECPaxIzVkcoYtjmP1icgS/O6ig8Qm+IJMCbGEyLEqAkwaZIbgbXbOGMwLkWDEGnF6MQU6Y/+1Lb//f0+JC8tLa1ar3wYsGNpsY02r+LmzrKs7yfKfiXzi26wqakpjhw5wsLCQl/rF+cwLHJRVa5du8b58+d56qmnOHLkyLobw6AzNpshl2KAdN++fTz33HN8+OGHD4VZ2MqaQCFbPz09zdtvv91NyV6/fr3r/Ljdm/DHqeYC4H1CI36PdnoDlhaIkozxRoxptBhP56jdvIKv7YbAkE08C50/X1ybCvdwE4fwjYCocZd6LaQ2P0PilphpemqSoFSpaooJqohLUDFIGqMiSJwg1kCc5gKVSYYawaQOGTFIphBY0v/or8B9UIPoN3vysBqFwQNQ0F8LInLfO8ZUlQ8++IAPPvig2w127dq1gclhGDWXwmRoZmaGz3zmM5tSRd3Ogr6qcuXKFS5cuMCxY8e6kd3DKly5Urb+zp07nDt3jrt373LhwoWhOT9uhI9D5NJyt1lKPiBL72GaMZXYU2nGjLkUmyZotkDLBngZw7SmAQgWLpLufg43/ih24QZuZB/B/CUUIdv3LFEQ4YLHMWqY8kKSRWTNFotZiiZLRKHFSkTFGhCLBB7vLWI8SIBIGy8RYiRPh7kE9+yn8UeODfVvXwuD1FxKctkGDLPbayOs1Q02DKvkQcmp1Wrx7W9/mzAMOX78+KYn1AfpVFuPJHqJ7nOf+xyTk5ObOm7l+28V9+vJvuhCs9by0ksv4Zxb5o/em0Ir5GmGkUZ7mCMXrxmz2UXi9DrONwhaEKUxlaWY8SSh2riJbdwiG3uCYOkKFYFs4gk8B5DWAqZxh2DxKqQtsn3H8ihmCQQF386l8YMQlTrWxVTDCtgWXiJ8c4k49aTNBkuZJ0wyTFSloooNK9gkzrvLkhYKmDTJDcC+9NMD/92bRb/k8rC6UMIOksv9VDXe6D1mZmZ46623mJqa+kg32E5M2PciSRIuXbrE448/ztNPP72lTWyQgv5aacvCvTIIAk6cOPGROZKtRC79zLnsBKy17N69m927dwO5V0/RGHD9+nWA7qBgkULrBzshXDnomm1dYM59QCO7RegU2hn1NKW6FDOSpVTjGcLGLXw4TrbrSVRDktoBbOsumIBg/iIA6d5nMVkbO3+VYPEDssmj6MhYTgqVMRDFq81nWCTMJ/ONxWQJJgoJcDAxwWjiyZKYuJXSStqk8w0igUBCrIB2bIyTH/1PoHL/ZIT6qbkUQqIPowslPOCRSxAEQ5l1Wa+Vt0iDPfvsszz22GMfudHu54R9L4rp9oWFBQ4cOMCzzz7b19rDTIsV8zQHDx7k2WefXZXotjsttlPOib2oVqscPHiwO5m+uLjIzMwMt2/f5r333usqPO/evXsgccf7gX4+T0VZ8DeZ9ZfJXAPxGWHsqSYJtUZMNUsZbc9hGjfQ6n7ExVh3F69ZNw3mI0Gtku16CrN4E7EGu/Qh2Z6jSHMR057DjR3Mp+tbCyAReJ8PS/rO+UoA4oAITLtj9NUmrI4SSQtfH0XbLeLU4xpLNGOH4LlZ38VibQ+7OtIq9+N6KmsuDxiGFbmsRlCbHYoc9Bz6iXza7TanTp3COcfevXv7DouHVdDvJeEXXniBgwcPbuq4TwJEZJmLYJZly4YF2+02ExMTy8Qd19rMHvTIxZFxl8ss+Jt438ZkHttOqSSOkThjNGsTtu/lEUzzOl5AwwppbRINahDtRqq7yOIW7VaLqcXL+TmIAWtwo48SLF7FjT6GLF5DzCTqgbCGEiK+nfvbZy3UBJDGIAbSNhhBknzokrSNNyYv6geWmlMYG6diWiwoNL74F5mdneXSpUtdY67tVnQoay73ETtp9rVeGmwlBk1rbTXyKbqv9uzZwwsvvMC5c+fuu4QLfD/qybKM06dPs7i4uCllgk9C5LIeVppx9crTXL16FRFZtpmtrJ89iMKVbZrc5DIt7qHeEXiPbSm1dkotS6glKZWsjXVNMCEexY8dBg9GXe6VkiwgXrGt21igFewlC3ejlV0ohmD+A4xPcaP78ZVxcPvwQQ2y3M+epJ0PQ6ZpPsuS5fM56vLrwTtBhI5dsQEnefFeDRgHPveu//Cpz/L0s89zCLqWArOzs9y4cYN33313mSjqMKPOfsYhirRYWXPZBgxbAmYzabD1ju8HmyUnVeXSpUtcvHhxmW7ZoFP2gxBTu93mW9/6FtVqlePHj2+qJXy7I5eHLSpaTeF5enqaDz/8kPPnz1Ov17ub2f2yGO7FemQ9J7Pc1as0mMeiGOcxsSNqJNRdzEiSUElnMBJgGpdQQGqPoY3cWEprh5DGNRTQ6i5svIgbfYTEBbg4Q8MK0vgQRh5BA0taPwQEiGujlRHUe4x0pPCt5v/l+zMs3oSIi1EbYrIk/3faBhPmLclBCK02mACSmGT3I8w88enu39drKXD06FHSNO02brz//vvLfIWmpqYYHx/vu3Gjn5pLs9lEVcuay3ZgmK3ISZLw1ltv9aUNNoy02Ho3cZqm3YHNV155hYmJiWXH7wS5tNtt7ty5w5EjR3j66ae3JNPyMLYi3w8UCs8TExPdzaxIoZ0/f552u83ly5dptVr3TeF55XWpKHfkNrfkQ5y2EDIsirQzqs2UkSSl7lJC18JqG7UBSoQbPQzqMYTo6KOAIHYUZ58gF4is4sJxxCd4bxjjFtJyaDCCuiZu7DCoIlIBbeLNCCaJUUJwcZ46c0kneukoGadpnhaL8+hGkgTEQpaCAZKe/wYBcyd+EjPbWPOz6BVFhbUtBYrIcy1LgdXQT1qs0cjPtUyLbRH3My22tLTEn/zJn2wqDbba8d77vtMxxQW11vGFidbo6Oiq0UHh1NgP+ukWK2yI5+fn2b9/P88888yW1ywjl82h1x9FVfnOd77D2NgYc3NzXL58edmgZ69k/TBRXJcOx3XzIXflDo6YQD3gsWlG0MoYaSaMkRCms5DNIfES3kRIMIb3LUQMSIh2iEAQyJZQl4BPMRg0mUFQxOzGh0ISTkH1ICZrdc/H+hhvw85UPZA6sAYyyQ3BnHTSXgbEoRpgbP7fIv0FWV6joY0S5AZgP/gFktFdmPnWWh/FR7CWpUBhAR2G4bIU53rfT78ulNbah07Zu8ADHbkMSi7FBTE/P89zzz23qTTYaucA/cs39FoVr7y4CuXeXhOt1Y6/X+KTRXTXbrfZt29fX7neMnLpD0UKdO/evezZs2eZxfBKyfqiHjCM2ZrMei7VPyQOW3hNseoJvIcso9bOGGm0qZuMCimSTaOaEkT7ybIWkBIGI2jzcj4/Un0c385bs031caT1Qb5I7TFoXEWNQWuPoO1FGmaKWnUKo2leU/EZVqp4SRAi1LRRjRAToxphaKESYXw7N/5ynbRYGueS+UmnuJ8lIAYTt3PJlzhBJ/eQvfJn8bdu9f2ZrWUpMDs72/1+RkZGln0/vftFv5HLyMjIjkkRDYoHmlyCICCO476OLYQdl5aW2LdvH4cPH+7rfXrJYVByKeCc4+zZs9y5c4eXXnqpa++71vH3Iy220ob4/PnzfUvul5FLf+j923rrAU8++SRJknQbA86ePUuWZcuemreSogFYkjaX7HVuP7uIDw2RGqx3GOcI4oSRZsyYy4j8AprNgexCbRW1I3mRvP4YqMd5D9X9qHoC34RoAlTBt/DVKRCLFcHXDuQpKztCZjxOHRpU0ayZE5OpoT7Gm4gwjVFjMHGc2xNnST7vkiaotZBmYECyLO8SSz1YgcTnabBU0cB2/m1I/9T/CTr3wrA26t6oslDg7k1xxnG8rEuwH3LZbrn97cbHMi3W2w12+PBh2u12P6fYPQfor9sDlotnwveHEK21fP7zn99w2n7QWZXNHLuaDXG/65aRy2BY6++MomiZPE2j0fhIiqY3hbbWtTojS1wMbrLIIuAI1WF9hvVC1E4ZjTNqcUJIC8muk2iCNZOk6dW8qyvYj/MNRELE1IAENSFGQryPgVEMEepbQA2RCt61wY4gBBiX4kVQsYhPUBEQwHkyYwm95FpgPkCNR8nTXt6HGONQb0HztBfkNRnRNqohIjFKhGgbJARp4Z56Cf/IUWAwhfWNsJoFdG+XYJZlXL16lTiON61V9zB3isEDHrlslVxW6wa7fPlytzDWDwrl5n7Tc70dX3fu3OH06dM8+uijaw4hrsR2Ri7FoOaHH374ERviQczCysilP2xF2WB0dJTR0VEOHz68qsJz0eVUOD/eDhb4wN5hSRpYFKueUD0miwmyhLGmYyTJqJoENU0C6hAdQDXDaoRzLVTbGAHnplGxhPYAzi3l3VhiAQcIIgpiUAUjkqerAMGiJsVL7v7oO68zGuJNDBqCJngJML5TvE9iPDbvClPJi/ud4r1iMGkbb23+747yMcZA0obqCOmJv9D93PodZOwHvV2Cqsof//EfMzIyskyrrog817J7aDabW45IHyTsKLlstBFtpRW5SIM1Go1lHVfbNSuzFYgIH3zwAbdu3eLFF1/kkUce2fSxg7YTr3VsYUOcZVnXFnnlsdsduWyXVMzDjH6bRlYqPBdPzd/88DTziceMCSNRSD0ICQKwPiVyjlqjxZ6oSl3aiGnTdndADdbsQVEwEeIVKnswCGk6jwY1jKmTJTcAMLIHTW4jJkDsGD5byMlGKohv5SrFYjvFfnBYxGSoiUAN6vLhx9A5FMF4ByJIqp30l4KQp8hEcg4zgjhBrUGyjs+X05xYsvz3yav/MYTfL4YPMy22FRTX+aOPPsrY2FhXq252drb7MLCaY+rDnhZ7oCtFm21Fnp2d5U/+5E+w1nLixIllrbz3U/xyNcRxjPeemZkZjh8/viVige0p6M/NzfH6669TrVZ59dVXV/WLeNDSYgXKyGVjRJWIxUMh114K4NO7GN8/RjWwZM0mc/c+ZOnaNfTD29Rn5tjjEio0AZNHBHaMMNxHy98m1iXA4sWhEmCkigRjSDiFsRNoMJpPzJsQpYXTJojFSYqTDDEBTj351Rui0pnGJx9oVASjgorBEJK/0iLqO11eHiUCOsrG6kDC/PcSgnf5TItmeAkgy1AJQDP8I0/in3x52eeyU+RSrF2k5AqtuqeeeopXXnmFL3zhCxw+fJg0TTl37hz/+l//a37kR36E3/7t3ybLsqHMP/3iL/4in/vc5xgbG2Pfvn38+T//5zl//vyy16gqX/nKVzh48CC1Wo0vfvGLvPPOO32v+UCTy0abepEG+973vsfRo0f59Kc//ZFc8zDIpd8NfnZ2ltdffx0R4fnnn+/rKWSYaTFV5erVq3z3u9/liSee4FOf+tSabdmDpMU2c1yz2eSdd97h0qVLLCwsbLixlpHLxnB43g7u8q+jC5wN7pCRYHFUAmGyVmXvRJ0jYxMcrkZM2TYaT1Pb1WQpmafVinHeYuwYQt5W7LWFc/Nk2sJpitc0l10xdVQTCEYx0QGcm8ebAAl3kaU3c5IwNbxbQI2gNkI1xotBJUIk7ThCBqg4EJPXX4zB+CyXbnFpHvG4QuIlzaMSl+RRTZaAEUg6Rf80Nw2TNIGwQvL5v/iRz2enyKWwWl+r3lPU05577jlOnDjBK6+8wo//+I9z+fJl3njjDfbt28df+kt/iV//9V+n2Wz2dQ7f+MY3+Lmf+zm+/e1v8/Wvf50sy/jSl760rGTwS7/0S/zyL/8yv/Irv8J3v/tdDhw4wJ/5M3+GxcXFvtZ84NNiaxHDWmmwrbzHZtFP7afwOnnmmWe4cuVK35vGsCIX5xznzp3jzp07m/KDGSQtthGmp6c5deoUu3fvptFocP36dURkWUF6rd7+MnL5KFI8p+00V80cTlKseEIFi8OSUXUZoUuYSB0Vl0LF4SsRVgNargnG4eIWi02PzwyVihCEo1TsCGl2HYio2im8awABVoKcZDAIIT6o4dViOnUUMRBIgBoLGAwGbwyoYHH5awDweBECBGcNQUZORk4Q41Bnvj/TYqUj4eJydWTj0UwQQ/466cy4mIz0B74II5Mf+Zy899vmw7Meeu3cN4KIcODAAX7hF36BNE25fv06P/dzP8e//bf/ln/+z/85P/uzP9vXOfz+7//+sn//xm/8Bvv27eONN97gT/2pP4Wq8rWvfY2/9/f+Hj/1U7kz52/+5m+yf/9+fuu3fou/9bf+1pbXfOAL+qvVXGZnZzl16hSTk5OcOHFi3QtmWJHLZt8jyzLOnDnD/Px81+ukmO7td+1Bay69NsQnTpzYlB/MIGmx9VSoC9J97rnnusODhbLw9PR0d/ZndHSU3bt3d3PQD2uv/1axlYeQGMdpM8Mlu4BKhsURdIr1RjMi76hkbUZ8Rs21SXQGgMDUCbSG1yZZGjIe7SarzVKrj2BdhTRpkqQxcTpLVA0RHEkyjbUBQoiQgrFAiLoWagOsjJHFN8GGWLsb55qICTGmjncxGIMlxGdNVDzqaygeQ4BqglGLaIrHYjXppMHSnq6yEOPy6Ed8gqogLkPVIi4FGyBZjE7tx734xVU/r+3sFlsPxd7Rz5zL+Pg4x48f5/jx4/z9v//3h3ZO8/PzAN2HzEuXLnHr1i2+9KUvdV9TqVT44R/+YV5//fWPH7kUNZdiirhXf+uZZ57h8OHDm9IGGzRnudn3WFxc5OTJk9RqNU6cONHtANkpCZeCFL/1rW+xb98+nn/++U1v0sMu6DvneOedd5ienuZzn/scExMTXSOzlbIovTMdb7/9Nt777k3Qbrc3bZb2sGGzn3ebjO/ZOa6xgDeOQDwBHovH4oiylJpvM6IZoU8IfRsVQ012scgNKhIRaBUkIMssabRIJgmiI1ibUanVqDGGd0ukronGEamZpRkHSGaoRBCEERUT5IORalCf4hHyOERRE4IEKC5PZyE5sWiCVwgly1uYM4cai01cHsU4hxiDpvmGLFlR3M9TaZL5PI2WZWAFiV0nPZaBsSSv/dSan9v97BZbuW7RNboVLC0trTsD1y9Ulb/7d/8uX/jCF3jxxRcBuHXrFgD79+9f9tr9+/dz5cqVvtbZ8bTYeuidjnfOcebMmVX1tzZ6j/sRuRSzIkeOHOGpp55a9rcNok/WL7kU/u8ATz311JaHSPutuRQ3UK/cTbvd5uTJkwBdJ831NtKVMx1LS0tMT09z9+5d3nzzze4k9O7du7udNR8XrHdPtHD8BzPLVVkCybCihOIJ1WHwRJpSy2JqmlAjQ2kTYsgkjxAyHyMSgEJGCyTAJQE6IniEkBqedidq8GACjNQw0sQTUAlGIVPS1NNoNqjIPGFkCKUGTIMJCe1e1OfqyEaq4NqAx2iI+hbqHd5X8CF5C7IkGA1x1hH4EKSN1wApZlgkRjVATIL6XMolVz6mU/TP8iI/LbKjn0F3HVrz89upmku/EVOz2dyWbrH/8r/8Lzl9+jR//Md//JHfrbz+BlEhf6Ajl+ILmZ6e5uzZs0xMTGyYBlvtPTYSjtzse6wG7z3nzp3j1q1bH5kV6T3+fkYuWZbx9ttvMzs7C8ChQ2vfcOutO0h9o/i85+bmOHnyJHv27OH555/f8k3WK7tx+fJlXn755a4T5Llz50jTtDsvsHv37k0Npz2oWOvzbuL4tsxwyTQw+LymIh6DJ+ikvyLXZgxHKG1C9SgOj2GJWUKpE2qIkxQIcxKRFPVgrKImItBx2swSUMtrJ6QoQsgoCYsgIdVwHLUxUdUyVocsa5JlMWk6TyYOr4YsXSQMAqy1GI1RcQgRWXIPgCCcgvYiaAXIJ+9N1gY1uaSLWEyWS8JIlgBgXD7TIi5vKJC4nafLks4kf9LG10ZJX/qz636+O0Uu/UZM22Fx/Lf/9t/mX/2rf8Uf/dEfLdsXDhw4AOQRTG9H6507dz4SzWwWDzS5FJvEqVOnePbZZzeVBluJQbXBYO0NvqhlqOqqsyIbHb8ZbDWCaDabvPnmm4RhyOc+9zn++I//uK+bqt+0WG/kUtRPnn76aR5//PGhbPrW2mVij8Wk+r1793j//fepVCpdS+IH3QVyNfR+Rg0crzPHZWmCyQjwhAJWPIaMimZUXcyoZtRJcNImJUNFsISEKrSMYhTQPJ0U6ChNZgllhFBC1ApqAiIfkJDgVAgBLwJYUl3AGQgZJfMtjAmwGqLSQgJDPZgis3dAJiCr49ImS+0YTWOqkSeweQrM2M7ciwq+Uxfyagm94kUIPXgxmEzBKJKQT+53ivyk+T0gmcvTYamHTppMjSH9zH8MwfoPnTtZc+ln3WHOuagqf/tv/21+53d+hz/8wz/kiSeeWPb7J554ggMHDvD1r3+dl156Ccibpr7xjW/wj/7RP+przQf2zkuShDNnzgDw4osvrut+uB565Vv6vbBWi1wKy98DBw5w7Nixdd/7ftVc7t69y1tvvdVVACiOG3ZhfqPjAN59911u3brFyy+/3PWeXw1biShXvm61SfWVLpCTk5PdqOZ+Wdr2i+KzaOD4JvNcookRj+nUVCJRLBmRz6j6hBGNCW2KaIoDMoSKVnD5FCFtGiiWiBpOHB4h0IBUBMWgnW4tIxEtvYuVCoHUcWQoEGpEwgJqQkKtoZLk9RVNUTwqQpLNIraKkTqBgbAySs2H+GwOl7WI4wqpX0QJsKpUwxjvBAIQk6soW7Wopgimk/YqpFx6/ksbNREmbeUKyORFftEYv/9J/KEXNvx8dzJy2em02M/93M/xW7/1W/zLf/kvGRsb69ZYJiYmutH+z//8z/PVr36Vp59+mqeffpqvfvWr1Ot1fuZnfqavNR/Imsvs7CxvvfUWExMTRFG0ZkSwGazU9uoHvWktVeX999/n8uXLPP/88zz66KObOodBai5FR9V69rgXL17k0qVLq9oQ91s76YeUiiL97OzsutFcv9iodX3Pnj3dImiz2ezqb126dIkgCLpRzdTU1I60pa6H2Ar/zja4posgjlA8gSjWeAIckU+paMKoptSNI7VLNKTNpBvHiUPU0mSRioxg1ZKKAoIoODEIlpbMADlZOGJUOoOMne4vVDuFeUPMIpl4akziSBACAglxvoEnJdRRvM2AkIAQJUXVY/0iaEZgq9RGI5QqLlFc0qYZJ5gsoekyJE4Jw5BAc6IKsjSX63e5L0vu11L4tAiStPFWkDj3cZE0gSgiefknN/X5PmzkMkxtsV/91V8F4Itf/OKyn//Gb/wG/9l/9p8B8Au/8Au0Wi2+/OUvMzs7y6uvvsof/MEf9G1W9kBFLqrK5cuXef/997uplG9+85sDuVGKyFDcJFcajr322mub/tAHrbnA2iF9mqacOXNmVRvigozul0bY4uIib775JgAvv/zy0Illq1FHvV6nXq9z6NAhvPddl8FLly4t09/avXv3ut722422ev7ILfKNw+PsCmIqIlSMYsQR4gk1peYT6ppSsQnOpHl9A6j5UVLjUCBQRSQEtWTEZHhGmCI1GYIldEomitUQL3nUos7QZgGRkEjH8Ca/16yHlARDkHuxSABYMt/Ck2Ko4WhiTJVAKzhto2QEVHAsIUFIION4jUEhCg0aWsacMJ9NU5GATB3t+SWaOKpqiQJLJCGBCGQKuTULWNC08HHJpWDw+YxL8uyfgvrmjP92qlusH1IrUr7DcqHczL0sInzlK1/hK1/5ylDWfGDIpUiDrewGG6Yb5SDHN5tNXn/9dSYmJjh+/PiWnnoHTYvB6uSytLTEm2++Sb1eX9VorBDdvB9psVu3bnHmzBmOHDnCxYsXty233W+TgTGmO6D51FNPdZsCpqenuXbtWneIs5ituR+I1fPv3RLv0sbjkMATiqNiDEY8FU2JfMwEGVWb0bYLLOGY9KM4SYklpeKiDrEITZkh0hohlkRiUjxeHYLFqKVtFvAYxvx4J7UFxuQkY7WCNx4QjLe0dRbEUpVJvCaoGAIvpMSAEkqQb/IEOE1QUsDgdBGxdQxVvE8AxVLBk2C8watD1RBFlkowgqmk+AxoLRG3U+J4EaeGmgjWRlQMQGfWhQDxMWojJGvhx/fhnvnCpj/vhzFyeZi1xR6ItFhvGmxlN9j9HoJcCVVlYWGBe/fu8cwzz3DkyJEtP+EO4ia5mh8MfH8zf/zxx9e1Ie6X2DabFivShFeuXOFTn/oU+/bt4+LFiw+87H61WuXgwYMcPHgQ7z0LCwtdojl79iz1er0rMDiId/pqSFX5w6TBSW2h1hGJJwqU0DgC4wjJqLqUETJGbIK3GaIGJxBohKKk4hn1o3k6DIMjBQkwGpKRkYkyppM4UiwGxZHisFrFkys9irdQzRAZocoYngRVB5qgAkarHV0xg/WG1M8BQkXGUTIUi1WD0xaqStXUyGfvO/pekoEHo3l6y6gHlMBnuYulOlSECh6t1qiHFbReI20lZGlC3FhkKcsIvRCGISGWMDBIFiPGEH/6J7b0uT9s5LId3WL3EztKLsVQZG8abOUGshVl5LXQb/STZRnvvPMOs7OzTE5OfqTDYrOw1pIkSV/H9nZfFf997733uHbtGp/61Kc2bBPcjkn7AlmWdQ3ZXn311WUh/HbJtGzH+xpjmJycZHJysmvMdePGDS5fvsyZM2dQVaamprpRTb9DnJkq30za/AfXJBNHFHpCPEHgsHhCzajTYMILI4FHTYtFk1DXKm2JccC4VslMSpuUAIuIJVDDolkg0goRAWknarEkWAmwakmkhWKo6wheMrx6vLTwYrHU8aR4UQKtkJo5DHUireWaYJph1KPGYrSCF0UB6wOcmwOxhGYEpymYAKsBmZsHUSKTR0mBM6jJCHyIN2C9Ra0SqMEbh80MudxxQFSByFaQqEKWgWs1abUzkvYiWSZULSSPvIhUd1Hbwuf/MHWLee/LyGUQTE9Pc/Xq1a5MymrYqchlaWmJU6dOEYYhR48eZWZmZqD1B2lFLjb6Xhvi1157bVMX3nb5sjQaDd58802q1SqvvfbaspTcw24YFkURe/bs4fr163zhC1/oStPcvHmT8+fPU6/Xu0SzGbthVeUbScJ3kiZtm2HxVEKXtxYHSiQpFU1xLLHXWExVURUaJqGqEaEaFk2K1RCH70QtI3hxCBATI4SEWiGVjATHiI7gO6mqjISUjIrWyCS/D0INaZpFnLMEEuBIc8JhCUOlk8qKcaSEWiOTBlbqBBrgtY3LEow41FYQwo6Bl0M0wLsFMIaAGniHIHlEhAGf4L0g4oEQfApqMB06ND7N5fo17krBmGqNyCRorYprtkjUcL7+DHPf/jbVarWb7pyamlqz9dx7j6o+NEOUhaDksGouO4EdJZe9e/fyhS98Yd0PfidqLkXK6fDhwzz99NPcvHlz4IaAQSRojDEsLCzw7rvvdms+m53f2I60WNHyfOjQIZ555pmP3LDbKbt/v4UrRYTx8XHGx8d54oknuna209PTy4Y4C7JZ2cTw7VbMN5I2S2TY0FMRRxA6IoHIplRIqWnCaODRUU+7GlMhQkkxagk0oCExGYYJXyOVhJR8ziXAEqplyTQItYLFkEiKqpCSEEiIVUNTGggBIRU8GarQNIugEZIkuJGMTFKqWsWJdshCSSXN51JMgqGC0YBMl1A8oR1FNUEkwHpwPsEDEYCtggaIKp6EQHO5/cCBk45fC4r1GWogSB0eMC7LfVuyNH+oylzu55K6zkyLElZC9FM/wUsHf4Asy7pNGhcvXqTVaq3ZpFHcAzuVFttqZ2JBLmVabABsxOj3U9W4cGa8cePGspTToPpkg9R8Cpw+fZonn3yya0O8WQwzcunt5lut5Xm9Y1d7zVYjkQdhRqXXzrZ3iLNwGKxWq+zevZtbY7v4VhAyG2RERqmE5DWVwFOxGRXJGKHNmPH4KGPJJBgrWA2xGBompaoVBCU2GTUfkZqMRByjroqTDEVoSAMhpOIjUsl7xMY7tRKP0KSJItR0BNf5vwiLEqBqwcYkkmJ9SCYJhhCrIQkLANSk1iWkTJs5SVCDTr1ENMDRQGxIpBHex3lnmipeYwwhiscS4IkJ1eb1HgIQj/UBKglGAzAJuAAj8fclYHyAoeNOKQlu6jDu4A8A+YNnb+t5r7XwtWvXALpRTREB7BS5bDWV2mw2CcNwTXXwhwE7Ti4bYRg1l82QS7vd5tSpUzjnOH78+LInhmF0m/WzwXvveffdd3HOcezYMY4cObLl9xhWzcU5x9tvv83MzMyG2m4fp8hlPawc4syyjDfvzfFPF1p8ODdHYBz1qsXUAyqhoRpAEKSMkDBuHe0oIUPIUOo+YtaAE4hNQkBEpAENaWDUUtWQuBOVJJJhsVgV2gIVDVFRUsmoaIXU5EX+yAsJjpAqopprjKkhkYSACuIUAodXR1VqeEz+/roIIkRax0mGxxP5MDeApEKggtM4933RGCTCaICS5OrHHhwxIgajnVkbl+Q2x5riFaxmeBNiXZr/3qe5xItPcn+WLHetzH1eBGknqLWkL/65Nb+PXmth7z2Li4vMzMxw8+ZN3n33XQAuXrzYVW+4X/WXfmouS0tLD/zQ70Z4ILrF1kMQBMRxPNA6G23u09PTvPXWW+zdu3dV/athpLW2enyvDXGlUlk2v7LdaxfHFRt5q9Xi5MmTGGM4ceLEhk9TD3vNpR/cSBz/+3zCFY2IpiyPRnUMCWQxZC2a04sYm7FnXAnGI2YjZUqrOPHEkuaeJ16IvKFlMqoakEpGJsKYqxAbR5uMCV/pODYKDVnKk10aEZs2CY6qj/BisCo0ZJFAK1Q0IpM2CTEj1FAiRC2xncNbQ1XG8ZqTSIiQGYPV3AHSUUQ1MUYiAg3ItIEXoUoFJUE9ObEAoiHOLyEmIHQhXjJCB2oMNtM8anHF0KTHGwjTzs876a/crhgkE5DC30XInngNrU9u6vvoVdp+4oknWFhY4I033uhmJ+I47qo37Nq1i9HR0W27vvqpuRTk8jDjoYhchpEWWy36KZwsP/jgA44dO8ahQ4dWvcCGMYS5lQ2+8KvZtWsXL774Iq+//vpADQGDSOfPzs5y8uTJLUn2f1IiF4CZ1PG/zaScTVMC64hCJQg9gc2oBUplxFAzAeNmjLZpI2nKUhaTpA7jE6RqGSNEQ4NHaJi85hJpwKJpEGiAEWjj8tSYdGoH6vOJeY06dZiUUTeCE48TB53fWyJSElLJqOlYp8hPpztMwFnAkUneyZXRxkiFQC2pNFCFsBiiVCHTNmLyFFjmGyhKZKqgMZn3BD5DbITxASopxlsgwWC76S8jHunYJwfegiR4b/MGAc0lXVRChBgkxPgWfmSK7OgP9f09GWOw1nLs2DFUdVkK7fLly1hruwKo65nV9YN+hjcL6ZcH+YFqI+w4uWzGjXIYabGVm3Oapt022o3SPIPWTDZ7vKpy7do1zp8/v6w1eyf8YEQE5xzf+973ePbZZ3nssce2pAG22YngrZ7Tg4KWV/63ewlvLKVo6IkiRxQoUeiIoozIpIzahNEQbJBxL2wx6kJsxWIl4JEsoOnaxFnMbBojLbBOcU4xKjRsC8EwohVik9DGU+34zAcqtKRFpBEWaEqa1yxE8ZKnsBJpEVDBKrRNZ5Pv1EmsGhJpYzTCZJ7YpDjvCCVAiBA1JDQRLBWqONPG+4wKlVyVWC3ON0BymX7nGoAnNHUgzYlNM7wKgWZ4BOPzoU1xedrL+Awp7IyxGJfbFps4Rq0gcUe5MkvAWNJj/8fc7rhP9G7wIvIR9YZizqnXrK4gmkFtHfpJizUajaErXNxv7Di5bIRhRS69qbWFhQVOnjzJ6OjopiT8By3ob+Z45xxnz57l7t27H7Ehvp+qypCH8RcvXgTYUHhyrTW3Ky2205GLV+Vf3Uv5d4sZTjJsBFHFUQ08oc2oVTJqts1Y4AiiXG6laVIiH1DHsihtqt7iraKBZV84QVZ3ZGnKYrKIaWUsJLP4EaFGhVbYJjWeSV/DGUeG7xTI8xRVwzQAw4ivkUlCIlleKCci1ICWLAKGGnWcdFqSUUIqOO9xFYdDqTOKl5TMOyJc3gWmIRm5Z3tIHU+C8ykVABMgBDjXQA2EjKA+wWtCpHW8uI7SsRKoogKRFxTFOAUjWEc+rOkB2yk4WZNHU+IAi0iG2/ssfteRwb63dQYoV845pWnajWqKjsBeAdR6vb6lB51+ay4P84wLPATkMuxW5OLJ5OjRo5vuvCrIoV9PmI3IoahpiMiqNsSDRi5b2ZCLWk8hQNmPFMpmSaAfothJcvnGTMa/nE5ZwhGEnjDwRBXHSEWpBAl1GzNa8QSB517UZsJHRHgcyriGLJkEj1DD0pCUirek4klFqdoQSYXJsXGaYy0kA9PKmPdtaHkMCSay1E2FzNJpO47xQM3n8y2xpIz5WkcVGVrSRDHUtEomKYmkjPhqnhJDcNJGECpaw5PiSKlI/ntU0E7qzGqIkuBIiaTW9XoJvEeNYIhQn+BIsCYC7xEnoBmigqonUIOSgQ8QIbc3liS3QnbtXPnYtVEs+DhvPU5jNKyQPPul9b+YTWAr0/lhGLJ//37279+PqnYFUGdmZvjggw8Iw3DZbM1K2aXV1u4ncilrLgNiM2mxYdVczpw5w927d7f8NL6ReORmjl+LHKanpzl16hT79+9fs6Zxv9JiCwsLvPnmm0xOTvIDP/AD/NEf/VFff/PHraD/9rzjf73tuJU5gshRiYooxVOtpkRhzFSghFVPbDyIY9SHVNSwYBKqGuDFk6BMuoiWccR4Ronybi5vSUyGB1LJsCagFoQk4zE1AkbjgJa2aaQxraxJIJa6RGS1jKqpYBFaJiPQkFQyQAg170ILiBD1JJLkhmHkci6RGhJR8BYk/731YYcKlUBDHHlrskHJxOVukuJw6gg1QokRiTBO8ZoCuRqANxC5nODEZyAGdRmKwWpOiOLzdFnkcsKVLEFFIMsQQFXACOmRz0M4eHqo33tXRBgZGWFkZITHHnsM5xzz8/PMzMxw5coV3nnnHcbGxpal0Fbew/2mxUpy2WYMg1yyLGNmZoaxsbFVI4PNnAP0rxG0Ws2ld2bk2LFjPPbYY+sev93kcvPmTd5+++1uRFfUue6nF8xmcD8jl5ks5JfPJ7zdVkzkCCqOqOKoh45KJWE0coyEKVJTMuNwAhWFliiRWhomIcRSU8u8xEQa4ozSEseUr5KIoyUZ4wQYtZgUYuOpaoR24otRreIjh4pln99FpilZmhJrC9f0+HZKa1SQQJhkBLUKKG3ahFSI1NKWRmfWJcBJhqiSEiMaIk6JSTEEhAR5V5gXVPIZlcBbHA2QgEAtmbZyRWJxeQ3EW5w0EVMh9J3usDQ3GwsQ1HhsJnmtx5EPS3ry4UkneBFEDILL5240QyUE38aP7MYd+txQvsthKSJba7tEAnmkXwzVvv3223jvlzUG1Gq1vtZ+2KVf4CEglyAIBiro3759m4sXLxKGIa+88kpfF9ignjAr02qFDfHc3Ny60je9629Xt1ivVtkP/uAPsm/fvu5xxe/7WXM7cL8il6VU+V8uW/6g/SjjbU8YZUSRI6xl1KsZtUrCaOgZqTraVqmqkJJrh3nxWLVEwJIaKmpZMHGnOB+waNoYNXktRjImfBUneS3FVYRQIyIsC6ZNSIBRoSkZkYak4lBjqBJhjBBFIa7epu0TzJJnTmfRCOoaEUQWsZaWNAHLiK+SSUxCkhMWgKZolGKlmg9h0kBVO6mvDPUepJW3IPuAVJZATF7kp41zngopmAi8RTXDYsCkiDMUXWKQYL2gmoI3GKOIdtJfajAu93FB86I+aQLWkDz7Hw3tO90u0cpKpcKBAwc4cOAAqsrS0tKyodpKpYKqMjc3l4tvbnJSv4xchoCNNowictlqvcN7z4ULF7h69SqPP/449+7d6/viGkbHFtDN3548eZIwDDl+/PimWh4HiQTWO++iY67RaHxEq+x+e8FsFtsZuTgPv/uB8u+nHTMKcVUJqxm1apoX6ispY5WMqK4EVmkZiMVjMaQIoyqkkptzzZuUalePWBjxAQsmwSvs0oimSRA1ZOJxQM0blnIvxg4BWUZ8hbaJSfCMUSHDYTy0TEJESIAQB0rN16hOWtrE2BgyF9NstWlkSwRVS4WIdtjCW09d6zmZic+tjzVXUo6lCSJUfA2nCZkm1KSGAqiQagsjYd76TBPwVE0drwneOypqUAWjDu8h8FlnGLKjiEyW+91rjNIhFGOwqUMF1HkMgqpBJCPb+wI6emBo3+39UEQWEcbGxhgbG+Pxxx/HOdeNaK5evcr58+e78jSFasBa59RsNrsPeg8rdpxcNkKRhtpKzjSOY9566y2SJOH48ePEcczt27cHPo9B3CQB7ty5w9tvv921Id7sxb4d3WKFF8zIyMiq/jQr1ZiHseZKOOe2lDLYzsjl29fhd68pd3GkkUOto6YZ4+Mt6tWU0YpjpOppRp4mUBVo4tmlAW3yqLRtQBWqooQaECLMmzZ1DbGiZHhGNaQtGTGOPVrNu7tQmsYhDowKDqFOSGwyWuKY9HVSHG3JqKshIMKqYdE0sARUNSI2cd71FeW0YytCok00BR8nLLgY4wRMhlSgLnWSjlG94lHy93UkOMmoMoLXFEdGRaNOC7Ih800EJaCGJ8aTEVFFyYv2mTgilTztlQlqhMDRGZqETBQceAOBDwCHEmJof39CP6ySHv2xoX6/OyG3b63tjji88sorJEnyEXmalSm0AktLSxw9evS+nu+w8cCTSyHQmGXZpsildwDx5ZdfJggC0jQdirLyoJHLmTNn1tXk2q61VxLEnTt3OH36NI899hjPPPPMqpv2oJHLRpidneXNN9/EOdcVfty9e/eyG2w1DDty+WAafuc8XEmUtOpIohSpZtSrMcY0mRwJGasKLlSWAk+mMIlhnoyKWtpGaYhnN5ZEPSGQ6/lCIo5IAypqmDctQiwBwqJk1H1I3Km5TPiQFBAPi7ZNVSMqKiyaFKMGRUnEM+IjnOQp4lRShIDIh8QmJcEz4XO5loSMqgihqRIaQ1xRKlojiJWWNnHtjCRpYQKDJJBWEsIgAvVkxuXGYZq3Wke+ijP5jErgpdMdVkF9mvvDEKGieXeZOIw3XdHNPC1m8JpgNVc6Rg2B0dzG2MV4MZg0ztNiPp/DSY98Eez6HVhbxU56uRSZj14PIVXtytPcvn2b9957j1qtxsLCArOzs8zPz297Wuyf/JN/wn//3//33Lx5kxdeeIGvfe1r/NAP9T+ouhI7Ti4bbUSFwOFG5NBbIH/mmWc4fPhw973vp/jlShSpJ4BPf/rT7N27d8vvMayCfq8iwYsvvsgjjzyy7rHb5WJZtIM/9dRTjI+PMzMzw507d7hw4QL1er07T7BSzn6YkctsE/7lGTi7CHHkSWopac0RVmPGJtpE0iYLEupj0DSeUJREhTEM8ybDAXUDi+IY94bEdGooarEYqsAijlqnsA+GUZ+3I6cKEYa25Pa+sThEQY1iNSBUw5JJcAi7fJXEpKRkRCIdUUihJQkRAeBpS0bN5zWZRLIeYUslJsaQ+7wklQYhVSajCkm9RavZAutYarQwaYuwDqGtEhnFSQpeAI/HEfgon7gnwjiDw2EkyP1YRAl9fm8YnyICkqV4wLqsMzSZ4gQky1BRAufxxmBdblfsNcSQ4sYewe19cWjfc4EHzculV237yJEjZFnG7Owsv/M7v8P/+D/+j3z44YdcuXKFdrvNl770JV5++eWhkuNv//Zv8/M///P8k3/yT/j85z/P//w//8/8+I//OGfPnuXw4cNDWWPHyWUjiMiGG3vRZjw/P79qgXynPGEWFxc5efJkd+iq34nbYRT0e5sIXn311U1plQ0iernacaraVZ1++eWXmZiYIMuybo666Oqbnp7m7NmzOOe6KYOidXzQyCXN4Pffhv9wAxqhkow4kopDR9qMjSZMVNvURwMWA4VGSFugijArjlE1ZCZvKd6nAU1xJApjIrTxTPqQTDxeYcGkVDSggnAPZUxDEvG0xLPXV0jE0yBlio5NsVfSqiHQAAHaeEZ9RGLy6GbS1zqaxkomMSEhFR+wZBpYtYRY2tImUJOLTYon8nkLtOlM5IOh6iu5cZhAjSppEFMdqSCJI8scSaNNLAlWQqoSopUUI5ZQtDNpb/L5GImIXIiSEngDxmMzRUUwTlDxBM7gxRN6mxMUAU5i0ABVhxAgvoVKgEnbaBCQHh18pmU17FTksllSC4KAvXv38jf/5t/kb/7Nv8mJEyd45ZVXeOONN/ilX/oljh8/zu/93u8N7bx++Zd/mb/+1/86f+Nv/A0Avva1r/Fv/s2/4Vd/9Vf5xV/8xaGs8cCTC6wvAVNs4LVajRMnTqw60GStRVUHusC2OqW/0ob43/27fzdQ9DGITXKr1eI73/kOQRBsuokA+o9cViOlLMt46623aDabvPbaa4yMjHyErIMgWCZnv7S0xPT0NLdu3eK9995DRLh9+zZRFK06T7AR/sN5+PfvwzwQ15R2PSOrtqlMJIyMtpisGaRqaVhPPQuYFUMKNCWj5g01LPeIqaklFmVRHfvJSaONIxQLCFWgqQZRYdrEBGqpqWHepBgVPNBGmfTVvLCOkpoESSGqBCzaJoEGRFhaEmM1t9LyolS9IZUQwdAwLQyWuka0pIUH6hp2fFhMJ4VmcitiEUINycjnTCpaJbaLeFUqVPBRhgkdQSVAtY7GSuoXiZseSYSkCkFgqZsqYvLWaa952g7NMF5AXP5vyTAYIP97hRSMQdIUp0JAhjdCmOVFfZyAUdy+H0RrW1OD2Cz6HSPYqXWdc/zET/wEP/mTP0mWZQPXjHuRJAlvvPEG//V//V8v+/mXvvQlXn/99aGts+PkstkJ+dWihhs3bnD27FmOHDnCU089teZ79TYF9EsuW9EHW82GeBB9skEil3a7ze3btzl06BDHjh3b0t8/SJdaL7k0m03efPNNKpUKr7322qbaMXs7b44cOUKapnzve98jTVPefvttVLUb0WwkNHjpBvz+SeFWorTqEFccca2NTsWMjrWZHFFaVcuHYUoTz261eUcsQh1hQYVQLdM2QdUwrpZZyb3pM5QmnikfkhpFFKZtwqjPC/qxKJPe0hJHW5T9rkpqct+VigSdCXlhgVz9NzYpDukp/Cu7Og6TqkJsHFYNViEVQ6QhLYnxCGO+SiIJGY5RKjhRUEgkn2MxCJlAQAVHQmYUiS0ZGQ5HlQhvMtQrtpIRyEQ+4JktkWUZaVOZYw5rhYqvEAUBdWvy9Bc+n23xnc5Olxt9GedxIkSZ70i9KJkRrAZoIUypbbQyTnrw831da5uB937Lhl3DQD8zLoVPUOFBEwQBjz766NDO6d69ezjnPmKRvn//fm7dujW0dXacXDaDlRIw3nvOnTvHrVu3NlXHKMgly7JNOziu9h4bkcN6NsT3W3yyEMG8efMm4+PjPP/8832tO2jkMjMzw8mTJzl48OCWOuRWojBOOnjwIPv37+9aD9+4cYN3332X0dHRblPA+Pg4IsL8Avzetw3vzyjtmhKPKo1qgu5qUx1vMzXmMVVD00JF4JrPC9OTNqBFCh5ukzKhAaHAkubdYU3jaeA5pBFtcahCQzyhGgIU6w2BGmZsm8Bb6mqYF4f1eetxQi63n9MIzJuEyFlcmtdtKhqgArE4xjpKyC3JmNAIp4JRaEpChRBBO8ObEamkZPh8pqVTpxnRqCPQr2QkmI5zZIYiziImwZERUel4t2RUqeBFwSsZMTaIqNoRXNRCiTAtIfVtGvNLtMRTFUsUWUZMmEvoZ/nUvxTpMG/wZJ12hnbebuxiFDBp3qqcHPohsNu3He1kQb+fyKVQRd5OrHwY71feai08FOTSu7EXOlwAJ06c2LC7CPLNbtCp8Y3SYvPz85w8eXJNG+JBI5etbPLee86ePcudO3c4dOhQVydsqxhUrr8o3K+nQLDV9y9ugF7r4aLFs/DlcU64eudJri7swo1FpCOGZi2jPdkmnGozOhJjRgMaoWEeTx0hAqpqsepZwoMXQjwZhgBhhgxVw5gEzJNhVWh1ZlTGsKQoVoXbts2kRgQCMTChlpZRmuI42Km1OKAljkANEZCqyesiI0KklhENWTLtjrc8tCRj1Ic4PIlkBGq6A5axJISEBJrP3IQakhqHw1PviFmmne40L3k7cVrItvgUbwQjEU5TFE+kEU5SnDiqBTEpONoghtCFmIqnGkXYaopPHD5pkTQT0mwBq4ZaaIhshUgyrFjQBDUWSVM8SqA+X1cDxLTwY4/hp57Z8nW2FTxoBf2NsJ1DlHv27MFa+5Eo5c6dOx+JZgbBQ0MuWZZx9+5dTp8+zYEDB3juuee29CQyDE+WtY4v0nNPPvkkTzzxxJqeMPcjconjmJMnT+K95/jx49y+fZvZ2dm+1h2EkG/dusXS0tK6Om5bJZa1yC6Kou6U9Ftvwb//bsbdpM2CLLHQimnVHOGYsH9vyMgUvB3AKBlTahkRQx1IgFANe42h7ZWqF2bqIaMqRAhzQEhOKIkqeyQkUyUE7pqYKY0QQNQQqrBgHF6FEQKWNC/ux52oZdQHZMYjwKxpM6IRVhUnQlVD2pJ3Wk36Cm2b4BRASMVT8xFecvIQHAFhh+higo4OWIqjorltscNTd9WcMHBYALEEKiTWIZr//xlgNcxFKUWJfITPdQOIiFCx4A25rrFgXEcbzILWqoxFFbyrQ9wmTWJai/M0yagS5S6cptIZyLSIkMvsZ20wAcmjP7Kl66AfPOgF/V4452i1WtsWuURRxGc+8xm+/vWv8xf+wl/o/vzrX/86P/mTPzm0dXacXDZbc7l9+zZzc3M8//zzfeUft8OquLAhvnnzJi+99FLXy3s13I+02Pz8PG+++WbXZMxae18VlSFvvZ6bmwPoFu7vBz68Dn/4h4YbTYirIbIrwI5aKntCopEmjLS5aj1TiynVapURa3gvypskPmNDHMoElgsaM6WWMUAzg7dK20KK4RExZKpU1HLPZoxrgBVFNHd+nLFJx55LmMczqgFt8TTFs19DEs3nX5rG5V7yOCINCdWwaJvYDCKERfFUNSAxGSmeCa0Qd1JekQiZKHUX4kwuwJ+REUhA5A0pCbbTouyAiNxMTIGqVkglBtVc9wuLOCEjyy2LgdzGKxet7CUZh1JVixpHlJEX5J3iBUKXp71CDFqJqAZVpJZACi5uELczkmQaQah6zS0DXIYaS7bnU2h1atuvj2Fpi92PdZeWlgC6NZftwN/9u3+Xn/3Zn+Wzn/0sx48f59d+7de4evUq/8V/8V8MbY0dJ5eNkCQJc3NzeO957bXX+v7Ahx25tNtt3nrrLbIs4/jx4xu2GW83uXz44Ye88847PPXUUxw5cqRL2tupS7YSjUaDN998ExHh0KFDmyIW7313yKyf82kswh/9geHCDWjVlXhMmR9LaByIsbtjKiNKrRJxm5ApgYsdJ8bJZoNHW4oGIe+NeAIMzwURY2pZVMduMRgH+01IBtTUcIeMSfL6S0MhULhrUmpYAhESVSY1oGWUVGGMgKbmsyxFCq2GoGoJFJomo6YhThzWW2wCCyYfOIzUsGRSqp1hy4Q8kolNkqepTEYmnroPyFBUISHFSEDohUwclgDXMQiraEAqcUfAMiQjwasSGMWLUNEQLx2tL++6M/u57L4j9LkisvUGLymBFyCPfDydrjHp/DcfCSWQDBtVGA0qQBXXciTtRbK2MhvPQlTnbvIouxYXt9118WGquTSbuYfOdtZc/vJf/stMT0/z3/63/y03b97kxRdf5Hd/93d5/PHHh7bGA00uc3NznDp1CmMMBw4cGIjJhxG5FMcXKgC7d+/mhRde2NTFs13dYt573nvvPa5fv75qc8Mgqa2tHFtYBzz66KPEcbzhjey972rGFW3Wxpju/9Y6n+7xDr73h8Kp04Z2pLTHlIV6yvTBBNnXZmTc04wsC6Kccil7xPBckOtsTXvHvdFRElWOZh7bSrkeGW4tzRJEEQdCS8sqQarc1JQ9hIyJ4TZgEO4QU9MAgyFRYUItDeNzDTEMi2SMq6UtSks8u9SSoVQVEpNhEdKOGGWEYYk0Vx8OAQx1H7BkE6waAslnXkY0oGXSTo0nIJaUyFsyycjokIxY0Fwevxi2zASsBjjNQCwVDfKZFxVCL3jT0fQil/yPCHAmyTXHfN4sYDXEIKCAzyX98RleIdAMke87ToYul7MxLm+5DiVEpY3RkErg8EFEJXRUa+Pcrn6W+YUlLl+51lUbLrr/ht3Z9TCRS6PRoFKp9N18tFl8+ctf5stf/vK2vf+Ok8tqTyuqytWrV3nvvfd46qmniON4xybsCxhjiOO4K0C3UgVgM+sPO3JJ05RTp07Rbrc5fvz4qpFCvx1fWzm2+Eyee+45Dh06xJkzZ9Y8TlVR1e53EUURzjm8993/FWsX6gy9m4Kq8v6bwnf/yDCbQbuuzNYcdw8kpAdbVHcprchwDs9BhUeNYckHTDvHVXGMiuVxE/ChOhaco1qpIFLhBTwzo1CPHfeyFBs7xtOUey5kQh1LkUKnAO9yM2AaJrdSHEGYQ5nQgLYoTXXsIyRBGfP5TEyqHiO5yVdVoWWEQA0NEkICInUs2TzCaJsUq4ZRH9AwMaFaUsk3/1Gf64iJSqddWqn673eKjWpAKh2dLzK8KpEXnOSimBkJYKliWTSNXO5eISNXc3Ydkqlo0I1kArU4dURKZ9YG1AhhRtdR0hkhdAaVDONzERwRAz5GVRCf4k1uMKkmgNFD7HniBHvIN/75+Xmmp6e5cuUKZ8+eZWxsrEs0RfffINjJgv5m58oKLC0tMTIy8kDZeveDHSeXlciyjHfeeYeZmZmu3e/FixdJkmSg9x2UXESE2dlZ7t279xEb4s1g2GmxYnh0dHR01e60Yay7UVqst+bU+5msN6FfRCuQfyeFAkPxfgXRFEOvxfsZY1i8HfHO70/SSALiEU9z1PPeroTmY01G90FSh2kMj1shyAw3Es9k1bJPLI+HlisuY8RAbBSccswENDX3rPeiVCRgql4hJSXMHInzaAbx0jyNkZAQw0IU4MK8Q2xOM8axtAw0VZkkoIVnkpBEoEnGuFgUYVwtqTi8QlM8gQZUFGKxGBVa1mEyOtIuuVT/UscPJiLvPMubAhJQQxVLQkqAJTMJqjCiuc5YXjn3eYuyDzstxkqAwQm5Lwu5l33ocu0yQwCd11lv83QYmotWiiPwFpWUUC1eMgJncjkYb1GSvGajCSoG4xNUIHAeRbAmBN/ESIShgTOKe/RHl12jU1NTTE3ltZc4jpmenu4KPIpIV6lho5mm9a7VnSro91Nzedjl9uEBIZdiM1paWuLUqVNEUcSJEye6F9FOaoNB3v58/fp1sizjC1/4wpbNxmC4ysa3b9/m9OnTGw6PFsf2G7mslxYroqY4jj9Sc1ptzYJY1qux9KbECoJxztFe8nzvd4TvfvsR7C6L7E14b1yZfrzJ6COeeESoh8K09zS952Bg2S2WyTCvfQjKHeeZNJYJA9POY8UQGiFRoS7KPMKICrE6FGFSDHetpWpDxnftpuESppKUxXYb3/LcMzGtSsBBGxKjTGGJrdIio0pAiuZyMEbJcMQGwFDreL+A0haHIISAUwtOaEnuiWI7o4mhGtqSYLGAQuEiSYpgul1mkVpi8sn8ikLWaXXOJF+t4kOyzuS+UZ+7P6agUT7caFVwgNHcfjgTj/EGcLnUMy4nLc274CBPi1lN8wFFL6gxBJngDVgf4CUnHUlbebdZluCMsmCPUo0m17zuinmmgwcP4r1fNtN07ty57kzTWs6Pq2EnC/r91FzKyGWIKJwQDx8+zNNPP73sQlhP/mWz6LfmUdQSioJjP8QyyPrFscVme/HiRS5dusQP/MAPcODAxn4X29Et1mg0eOONNxgZGeG11177SNS0klx6iaVId21ubXj39wPOfEO5Mj9NPKbc2htx9XCb0SMOxjzNinA7hT0RBM7wRCDECjiPDyRPW1nI1DCGMKsOI8JeKyyqxwq0JReSrAPzqkyJyVNZCE+YkCYeawx2tEagFfZ5ZcmlVJKUe1mLdmjZawxaCZm0OaEk6omMkOIZ14AYj6gntrmR8JgKKZZQc/XklAwjHoOh4oXMKA5PAFgskRcyk+X7u3qMGCrekJq8BqJ4kLwRIJMUQTCq+A4ZuaLITk48Vi1qPV4CAsJuOiwkL8cbDQg7UjWR+lz/LFfLp+J9/lqlW1dBEsRbVGMMFvEpqkrgFW8NptMQ4KTCQvVFNutUYoxhYmKCiYkJjh49uky2vnB+7I1q1pp7e9hqLmXkMgSoKmfPnuXGjRvLnBB7sXJCvx9sNXLpVVkuZmoKD4Z+MOgm75zj1KlTLCwsbKlrbtgF/Xv37vHWW29x6NChdeX6C3Lph1gAPjwlnPz/GO4spdxsz3B5Qrj91AjhsYS9+z23vGF/RZj2yiOBZzHLzzUIoZHB/tDQcILFsyRK0NkdjQpjIix4h6DUjKHpPaMiufoxQkWUJQ8jiaOpHo9yyIQseccIhjSANFB2VyNSrTGVZbRdSrPZJvEZWgnZLYa0GhAYQ1uUNp4pMbTVUVNDYjwJnrDTWjziQuaswaniTD5BP6ohsaQYBWfy8xjxQUc7TMiM67QYB6QmxXohpy6hopZMEqx2fiZC5AOc5OkwowrkIpNe8+gmJE+hCZaKC1BxRB40l5jES0roLUqGVZN3iSF5OkxBNEWNIFlem7FEKC1EAsTHKI7p4HnMAJP4vTNNq+nP1Wq1blQzOTk5FOmnQdAPuSwtLT30FsfwAJBLEQ2cOHFizXbe+50W61UQfuWVV5iYmOD27dsDd5v1OymfJEmu7ZSmHD9+fFVxzrUwSEF/ZQSysnC/3nFFcb74zDZLLI3b8OZvWG5dhfmgzflkmneO1pBjlt1HHVkgzGFRPE0Mznt2Vy0LzvNYKMw7pYqy6IQUx1QoNBWmbNE+rMT5hAcjktdKQhGcUVSFMQMtIMDnWmEiTIrQ7syGBFbxCvs79RVFMGGIjQIOidD0KT5OaLiM1mKbMQWtBkzYkHakOM2Vg5NOA0BTclJIbIYTqGGJcR1J/jxaDzBkOKqad4kJgu20NlfUkpKTjUXRjvVW1hWt1Ny3Xg2ZSUChogYnDq+KGO2Qh8URo3RmW8R1iKnjKaNpbnyvCV4sxiV5vcxlqAiWXAnZaIinjYjFZC285EOliof6QZYWDlAbUrpnpf5coao9MzPDu+++S5qmXTMuVX1ohiiLtNjDjh0nF4Ann3xy3afrYZHLZlJrjUaDkydPEkXRMgXhQSKPQY4vJE0APvvZz275BhlGWqzQcrt9+zaf/exnu4XX9dDbEVZ0fW2EO2/Df/hVSwO4IQ3+f5UlGp+ucvDFgHjEcDdzjEeQethbERadciASGk4ZM8KiCNYrEuQb75QRlpwSoiyS25NMBEILZQShAVgg6ni11AUa6hGUihiWJO8Ea+IRPHVjiIEakIrHABURHMp4R8QykoCwbnDAHvU0XUqWxiwmS2RNGLWGZiWkHgYk1mExuVeMF8KEjgGXkBc4hJq3pCaPFBwOxFB1htQogUr+MwyR5sOQAaYzPqlUvM0jERWEvM5S0QBPigDWAQGIGFQ7tsSdKXyP5iKUgGhe6A+9dggN1BqsM7iOkCaaR0RkMRiwGTgbYDTAuxZYg9n7w/i5G9u2ya9U1W42m0xPT3Pv3j0A3nzzza7+3OTk5La3+kJ/tZ4yLXYfEQTBwDUXay1xHK/7msKhsUj5rKz7bJd8zGpQVa5cucKFCxd46qmnOH/+fF8FvkEL+lmW8cYbb3QtozfjFCki3Llzp+tRsRnvmEv/Vjj5/zY0Ksq/Due5vDdl/8shU/siNILYK1NVQ8MpE1ZpeRgz0FSwSkerCsYDWMIwYTwNEUIEaxxOhXGjLDnFiicx+dzGiIWWdmoN4kFgVAwN7wi8dnqqlFonfVXpvM4CVXIp/CpCKg6DEApkCCNAbKAqITaMcn+VzNFwbVwrZr65hFjLmLHE1XzwMbYgGKqav1/VWzKTYdQQdgQqI29ITIbpzNR7hEgNqWRYb8mrJHm04CU/VjSPsCIvHWKRjqukz1ua1eXUo0IkuddK5KXT8SV4gcgZvGSEBKgmCBbvY4yAcWn+Wm/AKKIhSoxXR6DkDpXjP4CpTKF6/b5EECLCyMgIIyMjPPLII3zzm9/kqaeeYm5ujgsXLtBut5mcnOzO1mxXAb1Mi+0wNvpStzst1lsoX8uGeJCCfHH8ZiMI5xzvvPMO09PTfO5zn6NWq3H+/Pm+QuxBIhfnHFeuXGFqaopXX311wye9Ilp57LHHqNfr3Lt3jzfffBNjDHv27GHPnj3s3r37I+9z5n8xnPv3wrdHPW+OzMOTSzz5wiRLgaFiYckpNQMtn3vXpyL5FHmY/21jobDklQkLTeiIOObkMRZAA5unuzqkUDFColA3SiOvkGMsOBVGDbTwWBQR7QwtGtriibzmmSGUCkIinkjBmVxNOSJPr+XdWpp3c4lHRamq4AJDPagTVvNiPXFCnMWkiw1spy7i2wlJFBAYwXfmaELIW4RVckthyIv0xcQ8OTlUsLkci8+JJW8llrwxQAO8ZN3hSciQVJAgj2gUISJE8QS+M69StBu7vL4iKoimZF6JNANjsI5OOszkpFPYF+MJpIp3S0gwitn1KvB9RYb7ieK+3bt3b7em22w2uym0S5cuEQRBN6qZmpoa2hBnWdB/wFEQwyCS0GsNMRY2xEtLS+sWygcZgtzK8e12u6v6fPz4carVardWcz/J5e7du9y7d4/JyUleeumlDT/33sJ9FEXLWknn5ua4d+8eFy9e5MyZM0xOTnbIZi9n/x+j/N4Z5fVdCY2Di0w+3WZkzy4aFkKBWCDE421eUzBGcV6IQiFTGDXQ9FARpYmiDiohpCqMWmXRK0aVNBRAGLdCQ4SaVzKTd+CNmbymUhVHO7dAyUkBoSZKLGBUUJPXS2oYElEsObEoUBMhFSVSuqKUFXKSqaghkXwyP5BOx5UakmrAqAbYUYjjNsnCEu20RdbICEMhCiNGbUgW5QOXiEcVKlicOIzPfesBqt7g8Z2ZnQwhj3I8eQcakndvRWpQcXnEYhSDIVRLXjXxiFNA0Y68i3bMwLwIFZ+7UQZYVDKsWjxx3lrucuOvvAU5RbCQtfDGEE59FjH5Zr0ThfWC0Hqv4Xq9Tr1e59ChQ91rtCCad955h/Hx8W5UMzY21ve+02/NZSML8ocBDw25QP4UMEw/ll4b4hMnTqz7tDKMtNhGm/zc3BwnT578iKxMcTMOIn+/WWLuTccVg23rHVe8d1HAX1m4N8Z020SfeeYZWq0W9+7d49b1e/y//kHA64GydNhTe6LJnr0B9YlduBCs9zgDKISBkHmohhCrMB7AohfqJt/4UYdYg1dhPISWeqqSuz0CVALINPe8b6AYD2rzmZFxQx6VAE4Er55RY1jIcp/3RBWPZ0SERGBElVQ0j3YMZMAoQiweq0qhklJTITW5x4sXh4gQKjjyzjVnci+XQPLOqgqWOLKMjo8Tek+cJWgrZTZehCVPPQwIKpYxU8UFHlEQyTXAIm9xJsMonRQXHWmYFItg1OeFeg1wnU6zEAeiPVpgBnEGg6LqCQEVxToBS8eqOM7TbKSoB3zamdA3eGMQn0cviicgxIvDVA9gx55bdr3c78hlI0LrvUafeuop2u1218Jh5RDn7t27N91QU4wP9BO5lGmxIWGji60glGGSS2FDvJlBRFhe3O7nyWsjciq8T55++mkef/zxj2zQQF8RSC8x/f/Z+9NYzc7rvhf8refZ0zueqU6NnIoURYqkKE4aKLvjKMG1BNuK3XCnYSc2LAQR4Hj6YiNABiA2IgVBLH+xL5DhgxNf3HTD6I47N7HhtDy0E9uRaYkszvNULNZ4xnfe0/Os/vDs91UVWfNAlny1pAKrzjnvePa7117rP13qNZ6dA/PJT36S48ePX/Qxz24q88e61GO0Wi2Gg1v5X//3Wzm+z5McHtHfO4FImVWecjLA1ilJJ8YpdCKh8NCJlZlC28K4sbovJSQ/ZpGhBLpWmXglQvEWvBeWrDJFaKFUgHeedmwoGlyklEBPDqwpS8cK46ogH0/o9NqB6guUKLGD3HisCpEoNZAhzddYrNFaKpTN13wjlExVKMUFbYhxiIbVWi1K4g2F9ajXwKwSoR1luKWItragriirimpasqkTImPJIkucJGQmarAVAjNMhNjTUIoFUd+sygKFWBrGnEIzQtVAivWCUjZ+YWHisS74tYg3qKsQMVgf1ndWDGoc4iNUC1AXnJa1wpgWrhohNiVa/uz7jrEPY3K5khN8lmXnTN7D4ZDt7e3FZ7TX6y0aTb/fv+DrOZspeSX13ebyAdZ8pL0expPee1577bX3xRBfzu3h6j8cF5pcvPe88sornDhx4oLZJ/PXfy3N5VLPuyxLjhw5snB5brVanDx58qIeYWdbuVzOe3L8JPyv/wGeOu0xt8Lejw0Z+Sm9tR7EMc44xkVJXs3Y3R7RSgxlldJvRcw0IjOB1YV6bBLU9X0rTL0nNQ34rhBFAT/pGGVKAPydDeyrXmSaFViDrShkJjSPjsBunlNMJyz3u0gc07Mwk3BChqA1aWloSomHyijqPamYRbOpxINC0LfLAvC3zBuQ0Gp+LlLCugtIVPHisT6A4HMcxUWWro0hy6ipsLmjdAXlzpBppERxRNcmaGpIfYyXKtyfD1NR1GhSwJAu9CkWTHhPIh9SYLwGarNKjbj5Ko0ghDSQNsmS4sOqTNVgtMKLEpPh3BhMjKmmIIJp34HNztWtfRiU4GtR5xtjWF5eZnl5+RwR59bW1sJDb2VlZaGtOVtkPf+8fndyuYlr7j91rc1lznw6XwzxpWp+cF7t9HS+5lKWJU8//fSCiXUx2/6rxU7mk8TFVmrj8Zgnn3ySfr/Po48+unh9l/IIu1xh5O4u/Lv/KDzxtmdklT2PAsu7TOuC5bUlNIqQOFig9Pptcm2xGjlGRYV1ORujGZEqs1ZMEqd02obKG7qRMlZPKuANeN+wxRS6RilFwXvi2IR1mgkeXVbBh9QsUoFKldgIO9MJRVmwttzHRBGpUQoC5VgsCJYuQokn8oJvpo1MhIIwlZQ24B6xCE58YH41VGJrgkYmU0MhNUYVM8dgvFCEHVnTbITMx9QSmGE02EpLY3xmiIkxbU9d12heMilm+ElFGlniOKZlY3wkDQjfMMj4tsgyaOvBeoNSoyokCopDXcCcvA/OBV5qIrVB64JgcKhArBalQIjwfgbGBOIAYyTqEy996n3HwocB6F/Paem9Is7RaMT29jYnT57klVdeod1un7M+uxLh8Ly+21yuY11uYNi10JFnsxl5nl8whvhSdS2rqfntz26Oo9GIp556in6/zyOPPHLJ53O1zeVSz3tjY4NnnnmG22+//X3rwfNNi++1yL/Y7244gN/634Un3lEG1hPtUw49WDDJx1ROWVpfRo2BBErvkUQoVGnHMPHCcjullIRUHYJjXNRoOeZMoXQjQ5UlxHGESe0CU5kpJNA0FkgsVArtBvCPFKwVaq/0LEwJ+MJgNKT2ngPLS5RWiCX4kilKq/Eg66CUhiBijEI8cccE+xarAiaIJBOvVFYby/vQKOJwCich2K+AkmBw4kl8iChW9QvAP0FwCxHlnAQgePGgglWPE6VtU1zX0CLD1p6iLvCzil2dYDy0opgoiWjblNpUGDFEc1FjDZpWqKYL6rJ42/iaSdM86iaBsm7coBssRi1ec1QssXMoDiMtfDVEopS4cw82ej/j6cOYXG7UKu7suO077riDqqrY2dlha2uLl156iaqqFnHfq6url8x8mtd32WIfcF2LBczx48d54YUXEBEeeuihq9aLXMv0dDZbbI73HD58mLvuuuuyvbauZXJ5723Ptrd54IEHzstOOVvdfzZwPz9BXOh5D4fw//zfDH90csaZByeUn6hhj8fFylFAvWF1mrJcGCoTaLaSCoVT0hhyLySmofMqRJHBY9ibRuRktH1N6SrqqsTPxowjy0piGWYZWWQwkVApYWWGaVhbBBpuFGzqU1FyAIXheBeMYd9yj0pCRFY4/SuZsZQEwD8XxSgkEvQtLTEUjYgwtopTaKulsC6stozHq9LyQmE8sQvrOcWTqaU2LuAjjY1L7IUaT6yCM3VDbwannojQqAxg8WEV1YgkQcLazkAnziCO8bSgqqmqkmIypfAjoigYcWoSkZgIi0fEEKtp8BhDhA9Av7OolKiHeD6peEG1BAzezRAxRJrgdRcxGeLrAOJHSyT9h897bHynTy4XqziOzxFxzi1pNjY2eO2118iybDHVrKysnHddpqpMJpMbmkL5QdV3THO5mhP72Zbw999/P88999w1PYdrNZ90zvHaa6/x9ttvXxHeM7/91TaX9663vPe88MILbG5u8slPfpLl5eUL3va9bLD5cznfCeLUTsFX/2jC8yszqr+m1C0NXlORwTvFh+0MYmCzkzOxFYfrDg7BqZI1OEpiAvhuPCRR0LcsRRoEk3iiyKJRxEonJdcuUlcBgxiPwxQRJ/RTyzhNSIzgmibVsTDzSksCVuLqmmo0xKcJ+3ptKgEhhGdVqvSNYYYjbqxNQMgESgkeZE4CaytGQvwxQm08kQTVvUNJvVI11GTE4zwLDEa8ogIeQ+yhtCGMTMWjjbuxE4eVsMZaNCBhsSrzorScCS7I0DzPgI/UsSONWkiWot6jRU1Zz8gHE4wEvEULh2sVGLXB6BLFqAUC3pJo0OmIN8HWxVhM7UEEJMbVA8TGWEmp6y2wEVnnAUTOf2r5sAD9D/oxRYQkSUjTlIcffpi6rtnd3WVra4tXX32VoihYXl5eYDVnizin0+llTzk3c90UzeVy12JXcmLP85ynn34a59w5a7BrCQ26Fq3L3Gfr5MmTVxXXfL3yYObA/fx9uZjL85xEcDHg/sXRNv+v8YRvbjjGKdQPSbBkr4W2NaRRoPdWWiNxTC1CUXsqEWYtzytuyHqRsiQtSoWkAeZRJYkDU6xlPHmjSLdWcAg9G8wlWyJoGoNa1nvC0NXEVcG4KqlmU9oRmDRlKYvITYQNT42qcpSjAUm7xXInY54WFAs4gbYYphKsWOYssDaBtjw/iSvQxlA0LLDahPe4pVBIEDBWUWhWmUJJwFtKCayttFmVZd4wM+E9toRc+tQHrEaUxkmN4IIsNUYb3INAOa6kXuj1gWAV0xhQmkadH5kIycKqK2pDVRdMd8eUOiUvHCkxSWqJbRIcDcQ3VjE1qmC0QMUiPsLLGDEJ1ivOKEYS8AWOkijaQ9q+74LH1Ie1FvswgsLOftwoihZCYvi2iHNra4s333yTOI4X7uvj8fiGTS5vv/02//yf/3P++I//mFOnTnHw4EF+4id+gn/yT/7JORTrd955h5/92Z/lj//4j2m1Wvydv/N3+NrXvnZFvoY3RXO5nLoSC5jzxRDPb3s1itl5Xe3kMplMFv5gn/70p68q7Oh6hH7NcZ6lpSU+/vGPX/J9mGMuZwP3eZ7zu8U233RTjlbC1gTqKkLE0JkJ/cpwaNXSvSMAyZPJjOlkQn91iSSOUQ2WJTu1442pY7NynLFTtqoZBzRBfTt4e8VhtdWySq6C+EAhnqnQs55cw8GrNtBqO0aYKbSsRZMWfc1IjTKua2wxY3OcI17ppBG1NUTTCfFyj06agAnTWQdhhtAiJDOqKokN+Stz2xdRsDJngdFY6UsYsxDS5mumwUdM87XaBIqvE0UaBpnDBSabOLzXcLIm/HfOOIsbtX+sZ2EwGjQ5sX6bVZZ5i2uYYdqwxVInDVvMLry/YsIqLbYZ1gzpdHvExBT1hLKoKMZTjFVik6KJwVhIyVCjOK2JtcBIgqilrDextoUlmFV68WSdh0IC5QXqw1Lof1iOyBd63LNFnM45BoMBf/iHf8i/+Tf/hrIs+amf+il++Id/mC984Qs8/PDD1+35v/zyy3jv+bf/9t/ykY98hOeff54vf/nLTCYTvva1ry2e9w/+4A+yvr7On/3Zn7G1tcVP/dRPoar8xm/8xmU/1ndMc7mcyUVVOXbs2HljiM8WYl7Lc7jSE/wcMD9w4ADT6fSqdTrXOrlsbm7y+uuvXzbOo6pkWcbm5ib/+S/+guf37+FkH3YjoSgt+SBCJ8JyZViXKLjtdpSlw5BkilfHYDSiqmrW9iyT2BiYB03BXmPYE8PYwzMjxyDyHNcZtizoO0tfO3StoWqEkElkKBQyUaY+uBpncViZLUfKDDB4MIJToWehUOhEEaQ9UhSjJeNZjswmlJFB85wCR5TEdCNLTtDI1CiiQtcYcvUNCB84VoEZ5hcTiAESE1yOO95S2BqrEIlSCXRUKI3DaEhdcQIdjahsYJAZlLwsqIcz0qUU8YGOrKq0GosX4wVMYHklLuS6WD9fnwmZRrhGda84UBP0NM3X0Aqds8Xm6nyCm7FocJlMk4RunOE6JXXtoCiZFTNcAVk8I46FTFpgDF7AuhwkBJopNV4UEy+RtT52/gOqqf+zrMXg8i9krbWsrq7yz/7ZP+Pnf/7nueOOO/iJn/gJ/sf/+B/8q3/1r/jKV77Cz//8z1+X5/SFL3yBL3zhC4t/33nnnbzyyiv863/9rxfN5etf/zovvvgix44dW1hh/dqv/Rpf+tKX+OpXv3pZXoHwV6i5OOd48cUX2djYOG8M8Tz98IMynzwbML///vvZu3cvx44du+oR/Wqbyxwvee2113jwwQcvK2DMe8//2D7O/88MefvBg4wEvAM3UerdiGRiOSAR7UQQK7Tanv4BJe4ChGlnNBhgPOzbs4JK4/KrEGkImlKCI/GSev7aiuVo6Xl96phFnpGvGfsS44V2FXN73GWk0DKBqYQKaQRlo1GZNpqSyAZWVc/A1CuJCGLDSqkjsJFXSFXRW10JynZXMXEV5faESWpIooRuaiGO6UZB4R+wjfC+JxhKgj+Za6jBsUhggalQmJDWGAlNyNZc8xJyZZRA9y2bE7zgmRUFxXBMd7lDksRY9agYrFNcY/ciOJwGvKUyQZQ5X5XFfJt9FrzHCAC9zDGTwG6O1eIIuSuZD07O6gGpQGIiH1MzxRhLy0bUrZpYu8SZoapnVGVF7bZRjUlMShKPEIlITAuvBU6Efvfxy3Jz+G5zuXBNp1MA/sE/+Af8wi/8AlVVXXVUx+XWYDA453z5jW98gwceeOAcj8XPf/7zFEXBk08+yec+97nLut+borlcKxV5Nptx5MgRRITPfvazF8QRrodW5nJu75zj+eefZ3t7e5EHM28M1wM3udzy3vP8889T1zX333//RRvLdDrl/5ic5Jv1lJMCVQRWEqwzZLlgZ0JXDK2exyUerSdIXNFe8aSdlDiJiSWirB2j3V2SOKXb72Ebq5QgQQxNJWp8q4QQrQuewxbuyizHCnhlFphapSp5mvOSzzEe2mroasbeKGOiSssGOxXnPJ3EMFWhI0oJwfbEBMFipo6NyRi8o7+yhLWWVJQytqxIhu+0cXWN1CWD6ZSoqpl1YpLI0ktTaiu0EfI5W6vBbXpqyAm2L2oCGN7VMNnMcRmP0iEkWyY+qNq9eFreMCxmVMMZS6s9bGxJNVjpx96gNsxsWRMOFrmwFvMaAPzKuGDJ0qzKkubvc28xFo3FIxh8QLJIsJSmCPY1CjQrU8cMkRjrLYUOMGLJ6OCiHLXQi/t4dbha0WJC5Qvq0lKyQxTHJHGfVnrPRY/HOW73YbDFPgzM5WpNK1ut1uJ2cRxfNxPN89Ubb7zBb/zGb/Brv/Zri6+dOnXqfWSjlZUVkiTh1KlTl33fN0VzgUtbw1+oucxjiPfv379IjLzYfdxo88l5ozPG8NnPfnaBr8w/UNcadXy5VRQFR44cCeuVVuu8VvmvDTb53ekGL0jNwAIaEZFiVYhnEOWGxAm9Duy5BSIbruSdWpAIV8fURUlRlAwnI9QacJ5WktFb6oAE2u18B6/zPwZElbPDrOa/+cOR4XDLosDEKWNneG4aVjiKY9ePGemYygkdDB1JWEsSZhroxQUaJp5ImaG0nWdjOiIC1pb7wSaGhlZMWFWpMfTSmDKLaEsL7x15WUBRsDmbkYhQZjFxEpOlNggcNTQbaQB/1aC6LySswAKOY8hEKXBIY/uCCqkadqcjqrJkZa1HZKNmogmYjm/oxakaauOC/5d1iBpaKtS2Qnx4P1SlUeKHhiLqUYE0xJ0BgtWwUrNqqMgbO5qEaeSopCaVhPmRVeoQMYZIU2opcVqRaKeZajLSOMabktpHdOw6tZtQVjWnjgtvv/bEOXkp7/0sns02/CDrw5pcrqapjcfjq7L//+Vf/mV+5Vd+5aI/881vfpPHHnts8e8TJ07whS98gb/9t/82f//v//1zfvZ8j3+lvnA3TXO5VEVRdE4ey3tjiC+WjDivaxViXmottrOzw5EjR9i7dy/33XffOQf0XCfzQUwuw+GQp556ipWVFR544AG+8Y1v4L2nqir+v4MT/Gkx4qT1zKwQ2RhTJ7QLS1QLVsG4oK/orXiWV8Oaxza2JQrEBDddFxnSKKPbyZhODePRhChLcVXBzuaMNE2Ik5Q4TbDG0BBoUQIFV/DQsJmARjvuERMuNJassIRwSyvCaUiAVx8otGdqxxtlzUQnzHRM7Qw9EXKv7DEJuYcuEZujEXGSsNRt4cTQRpmJNg7FYUXXQZg1Zo2BKm3Z024z7aT0vVK6kqKs0MGQaWxoG0vUirGxoWciSgJDrDZB/56INFYwSt2s1GIN67NUld3pkNrVrPeX0Ch8rxJ3FjNMSTFhfUawhXESpg4nDsXQMiGdMnGCSgUa5kCv2tCVm9RJQnBZ0JSGHJbYR5Q6QQ2kvo2zHicuhIsZwWi6mHa8ViHrRSJUDOpLvAhiOjjdJkraZFmP2/f9ILu7g3MEhHNNxzzb/kqsgq5nXYsn4bU+7gcVFPZzP/dz/NiP/dhFf+aOO+5Y/P3EiRN87nOf4/HHH+ff/bt/d87P7d+/nyeeeOKcr+3s7FBV1RXJJ75jmsvZK6nzxRBf7n3cqMnl2LFjvPzyy9xzzz3ceuut5+3w18r4upzbnj59mmeffZY777yTO++8k7eHO/x/0oTN6Slm1QnERsQmJvZCrzRERXAWiYwgVdCVdJc8/T3ha5bAnHLNnl8AJ4pXTyRB6T0aT8hnM/asNYwwhLqqKcucMp8wmwyIbESaJGRZShxFhGv+IJegaVphcRbCepmLN8OrxzejjTchJ+WWCA5lFkjCFRXgNTC3vBhG0xFHhxV5P6Yd10xkGh7RGGoMy1hqIG10KwbBNBNIKsE6JkIQC4lN6aUJrtfG1UG8mc9y7KikSCKyOIY0wkpEWwy1+G9Tk5sTfCUO65SdyQAF9vWWqWywkalNcDduq6E0QZPjCI1lIbZUi6hiJKRTqnhSNYgJzdn60NAsFq8VENZrJUWTJ5MENwSFimnIjqkM2q4b1lpEIdMwuZLgNMdRE0uPmiFWMmKNUeNQtcTaIvcDFEs/fYQ4TlhfX2d9fX0hBNza2uL06dO8+uqrtNvtxef0asPrrrY+TMzlSpmh8+ZypZPL2TTnS9Xx48f53Oc+x6OPPsq///f//n3vzeOPP85Xv/pVTp48uRBXf/3rXydNUx599NHLfk43TXO53LXYhWKIL6duRJrkPAL41KlTFzSePPv2N2pyUVXefPNNXnrzTc7ceRv/LZty+vgzTK3HrEW0Y8sSKaY0mDJYvFsDEis2UtJIyPZ62r2AKYgInmA3H8O33ahUSUI0Cs47RsMR3jnW11aIrMXgg2tuKmRJG3pt1DnKoqDMC0a7I4wxJHFCK01J0yT87r2AaEBhVAJCT9MwCE1o3mjmgkIIinYhhF3VUlPjGU1G5JXjjvWUJPOgxbdfgRg0nPPJNJyQK/Gk3uDFYAjMKwQSn+CwhFxFE9In45gqtqzSoaCiKgp8XbE7ymnVnqIdk8YxURLjVZpIZAe1ZzQZYCLLWrtHacLqS0QXAsxSAiEgUwvqib3BNIJNIbg3o4qKDxYu4oOi3wfas8Vg8TirxD6hNlMEQ+oiKilwWpP5FC8G1CAqOHFUWtBGMCQEmoXDGwW1FH4bIwmqBtUKFYMhpfIjaKaZbnrvOceiiNDtdul2u9x+++2LbPszZ84A8Od//ueLqWZtbe2qqPlXUt9JgP6Ntn45ceIEf/2v/3Vuu+02vva1r7GxsbH43hyT/f7v/37uu+8+fvInf5Jf/dVfZXt7m1/6pV/iy1/+8mUzxeAmai6XqiiKyPOcb3zjG+eNIb6cut6AflEUPP3009R1zWc/+9lLRgBfq8L/Qs3liY1j/D9O7HBUarhnncRUtLCkPqFvFZPkdBOl1xZ6qaCRNu62YT2kRlBtBIMoIdi3yfRAG8pqsLn3TRKj1BWjwRBjLSurfWITbNplgawAJoDGYoWknSHtcBKpy5K8zJlNBkwmniSOyZKUNI2RKPxOrYbmpnNLfFFUA0jetLAwiaiGxiOg6inHM0xdcvtanyiJ8OooJVizhGv0sJKraE7kQKtR04f/B/W54oO3mARmVYDmLWXTpAoN7YoocLdaXvDq8FVNVQ8ZupAWOU4MYkHzHNOypLFhy2wjKG21YY2lBoshE4t1BiMOJcQxCx4nPhhHSsi5j7QxoNQmG6ZhrhnVELesBqTGSEKkliIah4sCn+LFARE22BxTSEGPJRwzLDFWY5zkODyJZkxll0gSMjIcBUgIF1OTINJmKX34gmr8ec2z7bvdLhsbGzzyyCNsbW0tzB47nc6i0VzMwv5q6zsNc7mRppVf//rXef3113n99dffByXML+6ttfze7/0eP/MzP8P3fM/3nCOivJL6jmguqsrp06eZTCZ84hOfuOqUtusxucwxmzmusby8fI6T8KUe/3pMLm/tbvF/TLd5pS44I5688qQdz3K7TVuEVgy9WEg7njp2uFFNx1riNjhVlLCXR0KjAG00EGEiCHTYkMYuGnJCXKNST4CyrtkZDEiTmH6v15ysK2K+LRI0vlmhmZCEGDViQEVJsogk6+D6nbBmKkpmbsZoMCQSS5LEJM36zCKBaisQY0CC+NDQiBJNs8dXZTwaU9YVS8s9MhuFVyaWxId1kkr4oFtvUBOA7/D6QiOj+bdo01QxWB8anM5pyRrelAolJ4DouTjEeGbiKKPABgNFtApTl/OYTEgJppY9TelITIRpHIuDGaZ4bdZO8+VgaGmRByehrVk11FKF99FHOBoGmUbUUmHUEgGVlM26sAq/D+LgFYeCg0m5jcQeqxGV5gSytMFRBgsYUmZs440gPqLWMSJRWDvS0JdNRj++/7KP4flJvtfr0ev1FmaP77WwP3uquRJF+MUe98Nii11pU7vR1i9f+tKX+NKXvnTJn7vtttv43d/93Wt6rJu+ucxjiIfDIWmaXlP85/WYXIqi4OTJkzz//PMLXONy96NXuxZ7Z7DD/1sNr2pNdfRZikhp+YTYxHSrgn3WsrzeopVBmkBHLaelYIbSJ6ashSp2iIbMd6PBA8sQtBuuAZ7nYbeuYXnFGHwT4xtpyCKZFDnT0YR+q03cSXES0hYjwhW+qA9eWIbF7RCPC6bBTbPwiDRU2SgiiixtbSOqFHVBURSMd3fBCGmSkMYRWZIGthVBP6ISrthD+iLsjIZ479iztITYEGEpjYo/vIagXgcNYV0Es0cvTT49c9A7vF7T4EvzDZ00ehUaXy/TxBeLCFaj0IA0KPMrcVR4opljPBzQ6XUxxlAVBWVdUvmCWRyTpAlJmhARJg1EglalmVak0e84E7CkoK8JFzepxtQS2GCZRpRS4EXJNCb85pUOGbWUWBJiIhwFtdYUkxk+rUnjFi3tUWsJCMYbauowNfk55qUk0qJiFNwGJMPhQCz96CNYc/k02fNpXOI4Zt++fezbt2/hIrG1tcXx48cXwVxnTzVXQ2P+MBX6/2fNcoGbqLmc76CZxxB3Oh0efPDBhYXK1db1mFwGgwFnzpzhE5/4BHv37r30jd5z+8tpLi/tbPD1fMBrrmALTyEeOkFh3Y8yOqmSWofWA9ZWEmynhROIUDINcr0VjTESVjOlgPFKWxvxnAlNBZQah8E02EBYbMXNSXS+5rIEId50NmM2mrC01CNOU4TGDl6aaF01jRFjgw+ILqajsL4J34uahuAkTE0psmgAXZPSSRJ8T6mrmrosmE2njMdjEmvJ0gTSBGttsETxNTvDAUaFteVl1AScJsY0k1hgwIEu8uZjBKcOLwLqiTCo6MI+ZR7eJVo3yfLf9uyiWdVZbUwmG4ficDvwxofmNykZz8Z0V3p04iwA8GmMqOLqiqIuyfMp08GAKItIkoSWTanjQPc0zb3XzYosNJAQIZxpyowZKkrLp8xk2vxMSkmYQlKNQxMgwqqlZEatFcWghFZFmrRp+S41JWIskUZgSgyCuJRKRngMifYZ6SksMZFGVIxBDFYSluKL61reW5eyfjnbwv7w4cPnBHM988wzi7jhOQPtSuKGv9tcPvi6aZrLe2s+HcxjiCeTyTU1Bri25lJVFcePHyfPcx5//PGrOgDO9/hlWfIn402+NRvzppYMRanwJJKQGMNyHNGNBesKOlLSXUuYTHPyyZS1Xh/NYixCWwPJ1zXrmzZCtZhIPNYFA0mRoOr2EtTSMYB4asKUYSTcRqDJ+ACvynQ4pK4qVtaWiKKoidQNq7KoaST+rJP3t1dsBL2LhIPNanAT1qbxIXMn3rC6mlufxAhxYtGkQ087qHPkVUFRlkxHE2xkiJKYIi9opymdfmeBQXgB8M2kRPN6pIn3DdOKaSYpv5g4Gq8ycc3jz60hg/LdMH99EqahZm0VXJENfo6TeGEyHZPnOcu9JeLYUkvdvJ8mKPYToR23iFptKl9R1hV+WrOju2AhMhFpEmNiQ4Ql8wm1VAiGSC0lgZIfdCs1QhSaOYqRGKMSXkfje1YyodKSIp8SpzFJkmE0DjiWmIaYF7A1r0JkGv8EjYg0oTLgqMh8SqE7iMasmMOIRg3wdHl1pSf59wZzDYfDRa79e6eaXq93wcb13eby4dRN11y897z66qu8++6750wH8xPzlQp5XmHEbbRpYRdrrSut8XjMU089hTGGfr9/1b98NYZnipz/fPod3qjHnFbH1HgiE9OyQsvEHEqFTgRLkSFN5lf3UE08hYPRcIQWFevLy9goIpxQvj1lhDUU1CgRYQVWphHj8ZS6mBFnCT5JyKIEMTSxUMG+xBnFq5IQJhcnHnGeyXCIirC8tkzc7O0XV+8i37ZCUdO4Beu3yQEGUA0gtAlYTqRBROma03fIjQ/Nbn5AagPgx4SJQiKhazN6WQvX90ynE/LxjMgKRZWjuxVZ2sKkMdIwu3yjCYk0rLlc0zStLtQ2Tfb83KpeQ8KkBGDfIMGG3gSxYtQo3n2DK1kf8CCPDyC6wnC6S107VvoraEzDZgsZ9oUJ+Ic0q69CwsmnIy1mKwWWGFMKWlTB16t2JKUlb1sSm5KaBMRjmncp0m83tYSw0gKIECqCPqVFylhnlFVF2/ewnXD7jDaumXJijfEUze8mw8kUsKS0Kc0uoikRKROzEY43hCW555zQuPmfix7/12D9IiIsLS2xtLTEnXfeSVEUi6nm2LFjiMii0ayurp6jav9OAvQnk8n7rKu+U+umaS4ick7s73tjiM82nrwSQdQpZvyOvMtt2qFcK+iOSj6Kb9ZCl64zZ87w7LPPcuutt9Ltdjl27Nhl3W40nfLNYsSz5YSjrmRHajZXYpJsxpJ1tGLLwTiiG0kA3yNZXCkH8/TQVFKCuDAXjy9yYhvRXVvGGCFqOFMBHwkN1zfq93nIlMPTy1p0s5SyKqnygtlwyFSUKI5pxylRGuONIVZBhG8/j9oxGA6wUcRSt9dcpYbnZ5oJxBP0IEZ0oc2ImCcmBqAdQM0cAwnNwqPEapmvq4KN/HySCA1ApME/VBdYkMdTzQrKaU5/qUuWJrjKUVQ502KCH9bEiSXNMuI4IjUx3gS8JA6ddGHeaBdrrYBtWJ1PXEo0d+9agP5+DrkgPjTkOXBv1VBTMZqM8epY6a1Q27Bu9DhijahMjdPQsCwWJ56Cmp6PG0zFUJiC5aiLiyMSWjhXU8Q5uZZMi4K4tESZJbYxXdOiMiEoIPMxxWI11mIsQxyejrYZ6oCqcqS+je0IQow0z5eGkuwavEcb65gGgWqYeAlGLLF2qCnx1OyxH6cV9RYXe2enk849/Ob/PbuupyPyHH89cOAA3nsGgwHb29scPXqUF198kX6/v2g21+KEfi11tSLK704u17l2d3f51re+xdLS0nljf+f/vtLm8tdYp6UR39QBO1mYBI7pG/TFso+Mu2jzMZYCrfWsmutG3nzzTe6//34OHjzI6dOn34eZbIzHPOmmvFbknPAVW1LijZBLTSYRWcuQEXE4ibktHdOOhU43xjd4Q9RoNRxhYggWhOEkbBoarCsr6vEUiYT+Wp8kXJeHk6L6ZnIJFYdTIh4fphgjDfsHOmmMpnFoHVVFUVTMyhluPCKJDVEa6MCpiSnqksFwQCvJ6PbmvHttrvID0hx7CdNPYy8SQrW+vWYyzaqFZjpwDQYSyAGCo27WVcEa3jfNSJg7/jaqi/nqzMN0OmZW5PSXe7SiNGhjEkMSt1lCqH1NURbUs4J8PGJiLUkU00pTJLHNaimcOJ0J2FACOHzQiqjBSkCjACK1OEKksCFYqJRSYRrMKsJSUDIajzAYlrvLOBOaeiU1Hc0YmSlRQC1AlUJKEo2xYhiZGRkJRgw932bbDmlrRqyWzKaIhYiIlk0ZJyNqV1MNKyatUfBII6GIZgBYDFPGOMJqsa4KqqomjhJ6aZeKgtBeUhwhUTImxkn4e6IRXgK4H/sMJzOEmJgOFTOstImx7I8fxBq7OGGfnfkz//u8zp5qbpRppTGGlZUVVlZWuOuuu8jznK2tLba2tjh69CjOOY4ePcq+fftYXV39QNT6qnrVa7G/CimUcBM1l6qquO222zh8+PAF1e3ny3S/VAnCp1jlE7rE70/e4sW6wvuYgcJQc16UMf/FnCJVoS0Rt2qL233G+IWjnNkdsO+hj/JCK+aPdo5zmh3eXY34g903mVGTN/v7VIS0a+hZwx6bEougkjbArC5orpM8XAmrOCKCLsRjmA/wgbWkiGiz5FJcnjMaD0laCdQB/HaNVUisipPwc3Nsw/PtCcE3n+OEZiKAxqxQIY6I4oi+tqi0pihL6rxgNBkzNII6pdfOaHXbIBrMGSHYo6gusJP5CVbngLnOMZdGxT9fQTVMKNM8/2Aj07w7zf2LmGZiC+8DzWszjcniYDLEVY49/WVsFAD7eRKkNihIbAxJ1sJnGU49WtaUdcVoMsQPHGmSBJpzHBF722ATsmCyzWODjVoU14RuSchJQSmlWlyICIaRTiiHOT6D1WSFkZmQYLHYMLE0Fw6Ko60tNu0uiUbEQKopO2ZIqgnSNC3X/K+tWaAWE5FqRG1rYjKiSEkSofAFta9w05oqKjFiafsUlyrWxkSziEk9IMva9Gy38RQLz6luPMeMCjVlM50FESoIqqaZyqJmWLWIJAjKmrmTyJxrDHv2Smwegz3PATo7wbSqqoXTxI1cU2VZxqFDhzh06BDee/7kT/6EKIp48803eeGFF1haWlpMNVejhr+cmr/mq3FF/quQQgk3UXPZu3cvKysrF/2ZawHkU2P5VNVm/zubPLjvVt7RnKF4Zt6F+/SGSktOM+IvB8eobxM69+7htSgnkhLbAltGLHnPWj+0hOZU3uzBDUrDlJpHyDanyohwYhaj2MbDylE36yS/0JgHbXRYI8WqTCZjJsWM1V4fVc9Uc6BhI8mcIqwLlpLxYRKaA+bh1KCLyUUIwLo2ILVvgPYYQ5pl+CxlMhlRTgviLCGvCvLNnDSJSbIkOB+rXTSqqNGEzI0W4wYg9yioEkuDz5yFa8xB/pBtUjdrojANeermJG8WK7BIBe+VwWiIqmNtaRkxYVcV+QabaaajqFGcq0DkDZEYXBoRZ5Yl3w0eYVVOkU+ZDhymZYjjmLZtUcQ1RgSrlsRbxnZMShKyT9QwMTMSjajFkWpCToWphQFTeklGP+1SiSeXkkQ7GG/ZsSOWfJepFOxzq+SmpKCkRUrkYzajHQSDagjxmlFQA4mmTE0RFPfN+o6GKJ75iEIKUpOxJH3KXo7SQnNPSY6bVGgdjrU0zYhs2jRMGyx0mvWXAFZCowmrzPkEA7EmzQRjMAvn5dAw16Nz1fjvrXnTeO9UU9c1Gxsbi9C/i63PrmfNG8fhw4fJsozZbLaYat566y3iOF40mpWVles21Vxtc7mRKZQfdN00zeVy6krSKM9XcxFj21juNe+3WNje3ubIkaM8un8/d3/sHt40U16TEafIcarYyGMjDavqxsbRIAvmUASLtZYhrKtcM0lYBGsAPJEELYjXcNIP0bahqUQEpfjuaIgrK/auLGMiS5HPiJzHNqJB68OZPWAZhkg1rHbQIM4j/HtOF56rFmzTcDBBHGkbIF9VmewOcd6xvLZEZCwWQ+EqiqIgH4+Zek+URMRRTCvNIDLMFeNzKq+FYGopHo/DqkEawkF4j8xZjZHGObl5TQjOeNBgAWNQSl8zGY5DA1zuNu+TJ1JD2ehV/JwOLJZdM6KtKbGxOBw7dsR+t0ZharaiIXXmOeDWmOqUkZ2QzJTppKTuKe0yZtwJJ+4VbXPabJFqQkeXGMiUvbrMluxwQPczkjHelWRRQtrK2DEzUmwTBWwY2pyudhlJWImJGAYyJSIm0YTclOTU9LRFqgmFlIEkgCVvRJIx0jS0MD0lOo80DkLJWuoFuG8ziImZzWbUZU6UxlRVTTUsiVqWOI7o2BaVdQttTt1EsUkzwcyzcry4BeY3X80CrJpbiOTKRI3zddjLL79MURQ89NBDi8/h+dZn879fr3qvE3Or1eKWW25ZJEDOc+1ff/31wPBrcu3X1tZot9tXPdXMX9sHZVx5M9Z3VHO5HiLI8zWnsxMs7733Xm699VYA7qXPvRq8dI4x5Yie4Xm3g2nownM9h218uEKOCBDMVZrVj1AZH9hbDc3WNyJFK+Gk7HUeT+upvWe0OyQSWNqzjJgAJlsjqPWNuM+jVhbU25pGtIdpGlo4NSTNemo+qZj5vzWs0eaTC7VjONiF2LK03CcmTCc1NWlkaUUd6k4WVhx5TVHlbJczIoQsSjGtCIkNmQZV/EhyLIa2xkxMQSWOlsYkatk2YyyWvs+YmZqhTOlri45POB3t0vEZiUSoOLZkTDz02JZh3PZ4rek066ljdod9fomRzOhpm0oqaq3IcezxbcZmysCMWfU9PHDK7pBpwoG6ywm7gwD7/R5cWnO6NWJP0WO7NyLbjCj6JSeTktVpF4kjTsa77HM9Ttlt9rs9vG23aO+ALEWEBVdMWw1bZsg+v4wTjyVmJiUzqTlYr7Fth+Ti2OP7WCzbZhgsXzQJjDMJ/mjLvs+22SUmouMzZqZo1nK2WVvND9rw8wCpWioqZrMZ1bikt9rHGhsIBZ2SsipDhHG9jbGGKIro2ISgfxSsxFTkgJAQU8mMgK/FFM3fDZZ99uJTy/mqrmueeeYZnHM89thj72Nxzddnl0sKuNK62ARhrV00EggrqflU8+abb5IkCXv27GF1dZWVlZUrmkLmYP6VNKe54ed3J5frXJcbGHa9Y4q997z44oucOXOGxx577IKruVtps1bvJX3mFT657zGeMwPeZsy2lI3CXemoUDU+VuBJxTDBYRBaKkyjsG8WgvYiaEQMCUExX1Yl08GQKEvodXsLvKKWgEsYF/CIuS5EmE9GSiwaqL5A0iQWVs3KKVIhNzVWJdBUjaOmUZqXymYxIG3FZO0UBfLmJFYS1l0tIoYyo0+G71gSOuyaEXvyjKqqGfsJvoRuFWETyzAtuMUtM5OaLTOlpTErPmbTjhlJxbpPcAinzJi2xsQacdqOyPEsESKTT9gh2S5E7ZRu0mJCQYuEDTOkpx326jJDmVJLkAo6PAM75ZZ6jV0zZWCmrPtlMh/xbrTFqu81wk3oaQercMLucKjeQ0crNrMxB9wqfgVghi8rttszkpMGDsCuyzEYJkVOVhjqZaGFCe+Vd2ybEfv9MiftDofqdcYyYiYF+/0yE1MykpJV7RFh2TFTpuLC1EJC1ZAHEo0ZmxkiYYWVS96gcgFsrxoqdaYpVbPCSnxEScl0OqUqKpZWlzBWFviaGkOaZvSSHiUFdV2j05phNYaZEktMkeZEUYQIhPZch/WlxJQE4eat8gBWriy0qqqqRbbR+Ug678Vqzv5zIVLAldaVZMjMc+1vvfVWnHPs7OywtbXFq6++SlmWrKysLKjOl8JFrtZy5ruYy4dU15rHcj7jySNHjuC95/HHH7+k8aS1FlVlWWO+T/fyfexlhuMFGfC6jnhWdmlj6Ygl04jTzJjhuIMO44buKU4pxDeThoA0xICiohxPSHttWmlKooaRKYLlhoZV0rirWClZ1pQdmTKRip6PaZNwwk4xCPtdh5GpOWPHrGmbZZfwTjSgqwkdYqY4NsyU/b7LrMzZSHO6JqYVtRHghJmw33eYSEGm4fCo8MykJhVHQsS2GbPX9zEJuMRQmopb8j4Tk7MdF0RTZZCPmPZBjbDkW4xMyUAK1rRDx2e8G+2SELOsbUCYSM1e36egZuJL4omh3WpRJ44BOX3N2DJjln0fQRjKjLFU3O7WGMiMHTNjn1/CC2w3f6+omdmaFb+Mo2JoZqzoEjWOXZNzwK1yxo6o8ay7FTbMkGW/TG4qYhPR9ymT/bA8M+y2JrQ2DWPJmS1HZF6IJCVWZcvOWPU9TtpdDtV7eMduh9+FX8Hh2TAjVrVHrDGoMDI5ERE93w6+ZDSMumYthkJP2+zIAFDWfJ+hmWIxtDRlJrNmhRYoxePpBHXK6tIKagLfOlbbAPfBFLNqWGA2ioj7MYnG1L5GCsjdFF/NiMsE260w1tCWHgO2UHEktDhgrmxqKcuSp556ijRNefDBBy95oj0fKWDeaK5lqnEurAGvdL1lrV3Y2KvqYqrZ2Njgtddeo9VqXTQY7Wrpz9+dXD6kiqLourkaDwYDnnrqKVZXV3nggQcu60CYH0Bn89dbWB7TVR5jlb+tt/E6I16XEX8pm2xJSU8jtinJmjQUVaFUTylBBf6GGQOwZ1KhK23aJiXRiDfskALHKhmpxhxPc3BCSyO2JeeMydnrWvR8yqvRLhHCId+lFMcxO2bVZ6RqeSMaBMW+Js1EMOWA7zAuZ1Szgm6Ushy12JUZIOz1HabUxBpRSjBEPGNGHHB9vCgjKSga0aATx5aZsd8v4RPDTAJIfNB22elMyaOSbKgMiyHDNch8QksThqbAoaz5Fng4Gg3Yo52w+5/WVJFjNesySHLWfBdQBjKjxCNqmUloVIfcCmOp2bJT1l2fSCOORjvsdX0qPDEJop5SanZlxh31HjbsiJlUHPCreMBhWNI2J+2A29w6x+w2HW1h1CEakyFstsb0RwnTtZLerMc4msKusL00pruZUO1xbJgJ+90ytVEyUpa0xWkzYNl3WNE+sUaIwqYdUwMtTRpqdpggM43ITYUlIvUJE5NjGkrGWCaUUmGxpM0EY1RIXMxuvgvAancZZ+ZMt+Bv1lA4gvVOcwynJMF7TJTMtsnbE2JSjDe4bEpFjeKp8hpa4Va3+Aewl3A+PrvyPOepp56i2+3ywAMPXPHEcT5SwNVONdeDmSYidDodOp0Ot912G3VdL6aaCwWjXY3GpSxLqqr6bnO53vVBrsWOHz/Oiy++yEc+8hHuuOOOy76qOftgP+/3Ee6hzz3a5wf1EMeZ8ipDvmm2eJsJq9aytSzAjK5aTpmcuDK0Zp5ef4lNW/COjLnV9/BquUXbbJsZL8uAnksw4xmuJ5ySgltdn6Hk1LagrykrmjCjZtPMOOh6jb28IdKYPT7jtB2T+oR9rsu4mFL6mqifsSQtNmXKHt+hFk+JY8PMuMX3SFTYMBO6vkUlUOLYlIKPuBWqprFERMQaM5CcidQc9D2qSBjZmq5mrLVanGqPUBwMKnbLXQb7YKVMUavMjKejKYmP2SkHVAnsMT1mUU3Pt/AoFY6BlByu15iaik0zZU17RES8a7ZZ9l0slqnULPsuYNg0Yw76FRyObZlxwC8zNCVTqdnvl9mWMYkk9DTjtB1y0K2waaa0NENRJsbRdRmnzDbdoWXUrTlYr/BuO2fJdxgsT9hb9Rgs1cQzAV9xojVkeZqRJBGnkgHrPjTkGEuNa8LVQjNZ9h1mpiBSS6SGwjikEfbOWWsiQtunDMwQj2HZdxiYERGWjsvYLrcxxtDNeo2PWDiOYyyuAetjjakIU4sgzJpVm1OPpcAR6M996TGIKgBWdB/DbBNchExjXv3mu5xZni6u5C9G353NZjz55JOsrKxw3333XRea74Wozpcj4LwRtOcoii4ZjDZP3rySx59MJgDfFVF+GHWta7H5gf7SSy/x0EMPsb6+fsW3vxKtzSHaHKLN5/x+dil5YnSUJ80OZ5YNqz7huKmpIljutHjd5MQq3KF9ptRMpOZNqbnHLdGRklN2Cksxy7Wwlzbv2An7XYuEiJkUvG3H3OGWuMUnbMuUWjxLaljxGcfMmEOui1fPbjFh3FFurfoYDJsyxWAo8KDKKTvjDreMF2VHcnI8+zUjl5oNM2OPtqlRdqQgRznslplIyabJWdYWmSacsEMMlp5mFAam1rPX98h6hlN2SFYJ9aRkUOVM1wwrecqWDklqQ7fbphbYkZxbG3B8y0zZ43uURtk0E7qa0fYp79oBbU1oa4JHmYmjrxmnzIBb3Rq51JwxU/b5JWIfczLa4YBfYsuM2eP61OI5aXY54JZALZVASy0DM+Vgvczb0Q69XcNw2XHILTOzhr7PmJiSrm/hjKFPh9PxEIg4NG2za3KmtkAqmOQz4jh4hGWaMJYZooYl7bBlxgRXuJBc2bj2kPqYSiqsGDIfMzPBFiYGRmYaLHNUGU6HQTyatIg1ppRgOpn6aOGWDCHRMqiRIFFLKWFq7NNhqFvU1HTpsSPbiFoiEgpyYtPGGMvd/Yfof89eNjc32dzc5I033iBJQurknj17zgG6J5MJTz75JHv37uWee+65IfqRC1GdLyTgrOv6hlOdzxeMduzYMfI850//9E8vOxhtPA5bjO9iLjegLieN8lqMJ5999lkAHn300Utqai70/K428GuZhE/kPfpvbXL43rv4o2PP076jx/EVpUfMBgWVKJtasasVd7o+mw3w+67k7K9b1NtDXl8fISLsKVN6kvCaHeFFub3uU4vyrpkAykfdEiMpOWrGtLCIg81qzKwj3F73wBhOmSkFjrv9MlNqTpoJPZ+gCEMp2JWSO90yuXhOmykxESuuxbaZMZSS/b5DjbJpZmRErLg2m3bGhJr9vkvsY96ItulrK1xNG0XFsmo7lEsVQyo6BUyLPPiaxQablwzbFbe6Fbwo22ZGTEy3mb7ABOGnBDJ4X9sMZYYhCEK3zYSOZjhg00xY1jYRhuPRkHXfYywlohGKcKrBQkocE+PpacYpM+SQX2KsFe1dYdRX9vtlKlEMhl0zZdlnlFLR14yj0Q6ZRqy7Lj5TVGq8eA5WHaZRTp7nzAYTJlkgO0hssGKppcTj6PsWuSmwakg1pjSBdmzUNg4MFgRaPmFgapwKdkdxS0JqEhJNySXHIIBpBKrhpB5IACVeA015KtMFPX2XHSrTXPF7iyXFiqWnS03csaFNj73chrSEW2+9dQF0b29vs7m5yUsvvURZlqyurtLr9Xj33Xc5dOgQH/nIR25IYzlfXUrAmef5osnMLw5vZLOZB6NVVYW1lrvuuuuyg9HmNOQPwwftRtRN1VwuVVEUUVXVFd/ubOt+4JpiVa818KsoCp771lN870c/ym2921AHbzPmGbZ5XnbpasymVLzKhI43GLXskYxTNueO1VXKOqc984xswUutkqQW9tcpUWR4Ix7R1ogDvsWOlJy2M/qasj6LeVdGVB3DXt8iIeaoGVKj3O76TMRxwkxIidjnO2ybGZtSsMe38CqcMTOcCodcl4Gp2DA5K9qirynHzQgPrPoWXpQtyVnVNolaTtsJMZaeBjHiUTtkn+8GoSAxsTrcrKDsG1alg5aesZ3hC2VrsgttS95y3FIvs9swrvb7HlYt79gd9vkeBY6utnAok4brtN8vccaMMFg6moJCS1MUYSAFh90ap8yQlqbEajEkxApnzJA9vkdR1wyqGbZt6UvChIKOdtg0Y/b6LmfMiL2+wzE7pOszes39jKRAMKz5NqO0JiGjlRoiB3ldUFUVOqjY7eSYxJBqwkYyJCEixVA2LL05iaOSIOxMfcbUzFAPfuaplwRrg5uB+mADFHQwYeqRBncpGr2MF8VoWJTWVPTpsWPGiBpWdY2ZjLGkxCSUVAT+onCIu3ivLZK19n0roWPHjvHWW28BsLm5CcD6+jpLS0sfWJOZf77mzxGCpdTrr7/O7bffvphs4PpSnS9Uc0D/coPR0jRlPB7fMMeA91ZRFHz605/mmWee4ciRIzz00EOL773zzjv87M/+LH/8x398TgrllQa3fUc1F2steZ5f0W1Onz7Ns88+u7Du/6M/+qNrznS5mturKidOnCDPcx577DH27NkDhOXFnfS40/f4v3I7J5nyrOzynOyCwmsN4L/ftTBYagunesqdbpmirihcyfG4wLiC3sjQskIVed5NCg64DqaoOF6PybsRB1ybvre8Ho0A4aDvEGF5ywzIiNjvMwZSccYUrPoWq67Fu3bMDM8B38ZgOCVTWprQ9ylbUjCWmn2+Q+pj3o4GtDSho8EWdCQV+30Hh2doapa0RYKloGKDnHRQY7oJ66YVyLipYWLgsFtj3C3YTKakE2FnvMNo3dCuYhDYtjOWNCPCMGyuzFMsu2bGQddnIhVjqTjge9Tq2bY5e3yHM2bIftdnKAW5OA74HkPJSVUopSbWmLoqGRUl3ThjmJSs+DTY1ktIbRxLybrvoo2UMWmo1IXxWCyRamBnUaE4uhpT2prEpnTiFq7jyOuS3OXMipwSpbQ1WWkoM4jmoH0DzgdjSY+vPUVV0jdthnaGAqu+x8zMGiV/1DQnWZiJOkIEQ1tTRjKgoiIjZUu3sRoTEVOLC1MLhsxnId8FoUWHdQ5e9Jiem82ePHmSe+65hwMHDrC1tcXm5iZPP/00AGtrawus5myNy42u3d1djhw5wp133sntt9/+vqnmelGdL1TnY4tdKBjt2LFj/OiP/ii9Xm8R5f7pT3/6hppt/sN/+A85ePDg+zKynHP84A/+IOvr6/zZn/0ZW1tb/NRP/RSqym/8xm9c0WPcVM3lctZil4u5qCpvvPEGb731Fh//+MfZv3//4j6ut1bmUjUXko1Go4Uw60J1gDYHtM3/4vaz6wuek11esEMKPK/YMUbhFt8BhNNRSRkrd7tlanHsxjknY0c2G7M6EWbRDMqa2UrMId/G49k1FaKGA03y4yt2RIuYdZ9h1XAi2mXFZ/Q1YceUjKVmv7Zpa8RbDZay7FtYNZwyM9Z8i1gjtk2BU2HZtxAV3oiGrGoLi8GoYWpK9vo2Y0q0rLGFI+10GCcluVdSLBtmzH7fpxRlnDgiiTmU9jmTjTBU2KlnmA+Y7rGsFAmDdEZfWyCwK7NgBknEaTOgry08IVp52bfCOgxLRMxJs8ua7zChoqttPMquTNgzS5mOZ7T6bSZJzYrvMKMiloQtM2Pdh+llxbXZsNNGyGgoG/2JYFjSFmPJGxFkzJaZhslEo0a0KqRxylLUZpzOMFoS57CdTJFciWtLFUXEcUxkI1IiRtWEaV6wlHSZtkoUIdaEUYOXmeY9dhJcqRMfUZoS33yWRmZCQU0tjo6PiSQhImLJ9ykkx5I08ck1qoFhdit3XfK43tzc5Nlnn+Wee+7h0KFDAOfkrwwGAzY3N3n77bcXnl7zRtPtdm/YFfrOzg5HjhzhIx/5CLfddhtwYazmRgk4L0VFfm8w2hNPPMG//Jf/kt/5nd/hh37ohxARPv/5z/O1r32Ngwcv3uSvtH7/93+fr3/96/yn//Sf+P3f//1zvvf1r3+dF198kWPHji0e99d+7df40pe+xFe/+lX6/f5lP85N1VwuVZdLRa7rmueee47hcMhnPvOZc6h916O5XMntp9Ppgu//8Y9//JJpmmfz+3tEfA/rfK/bS4HjZT/iebPLgIpX7IhIhVt9GxSORzNKUT7qelSJZ8OMmWbQd0J/t2bQmpKZmGHi2O87zKQmFkNLI9Z9RiWOY3ZCv2ksRi0nogn7fCdobhqx4gHfJlLhdTukQ0JHU6wKp03Ofu3gUSbiSDWm7RMKqdm2U/b4VrCnmVRMbM1aq8cgLll3fZwoYwlyvUQjplIxlpJDvs9MHANbs9d3aHUt7y6N6JcxlaspRzWbpiKxEaNOzeF6hV0T/LnammBVGJiKZY0YSs5tboVdycOE0YDpFZ6xlGSlZTydoaspqSQMpcSqRbH4Rn9S4FjzXQpRUo0RqcnUMjEFiUZ0NKIQR0SE+GDf71ByKrqaNHRiQ6oRhQSJaywJUTuYmdrI0plF5FqQjwuiShinQu0dabuFROFkpUC/cSGwKrQ0pTIVog2Ib4JA14mnrSnbjKjFseZXmciYmJREY8rGPkYQIiJqCrw4eiyxqhdPWT19+jTPP/88999//+LC7ewSEZaXl1leXuYjH/kIeZ6zubnJxsbGOer3uQL+el2lb29v8/TTT/PRj36UW2655YI/d6MFnFcqojx48CDf+73fy0svvcSf//mf88QTT/D7v//7LC8vX9HjXqpOnz7Nl7/8Zf7zf/7P5yUOfOMb3+CBBx44p6F9/vOfpygKnnzyST73uc9d9mN9RzWXyzmxz0/mSZLw+OOPv29PeLVrrau5/fwKav/+/dx7771MJpOLTj1nUyznjzWvFMsndJlPuGU8ylt+wvNmlzMUPG8HRCrc4ls4D8dkQt0y3F118F3Y0hnDyLGym5OOlI22J7GWcSzs8S3GUtHWiI5PWCJlSsW2mbHmWrQ0JMWctFP2a5iYcvFEWFZ8iwrPu3bKirZI1GIVTtoZ+32bgmBh3/YJxhs26xFqlbW4R2F9yHuX4GCwLTmH3TKVOHZMTk9TWj7mhB3R0piUmFo0GMBHLQZxTlvb2ErZslOSsXB6ts14zYTmI54zUcGqthlJSVdbVCgDk7PuuxQNeTfDMtaCzhha/T6IMJKCvoZJbmIqHErHp+RSkvoYLxAT0XUxOzanJiR6TqVqfN2gQ8KUkoSItiZsmSkpES0VqoY2bDAsacyuBAFsX1vkrYKEFnFmKSYTiqpEjFDtzij7BmJliS5bdkSiESKGqvFiC/YtlpwCh8cSsWV2AxlBI2ocMSlWIzJNF6aVgqGgwEmNo+Yhf3HB5IkTJ3jppZd48MEHL5txmWXZOZ5eOzs7bG5u8sorr1AUBaurq4tmcykx84VqHod89iR1OXUjBJxXGg0C3wb0rbV89rOf5bOf/ewV3f5Spap86Utf4qd/+qd57LHHePvtt9/3M6dOnWLfvn3nfG1lZYUkSTh16tQVPd5N1VwuNSZfai22tbXF008/zcGDB7nnnnvOewB8UGuxd999l5deeol77rlnMZpf7LHPPqAv5UlkEO7SLne5wIc/7XKeM7u8U494Jh1i1HDItRBjOWkmTMXzUdfH9Tw7WjCMKvbsVFjvONOuiKwljzxrmjKUiq7GtICOxgylbDyxWg11Vjlpcg749iJSOSWipzEzKsa2ZlVbjUu0Y9MU7KkzNosRaSXEvQ4qhi2ZcND3MAg7JhAPKpSJBF35Id9h2KzlDvgusRresLvs9x0qPMs+oxKPj6EycGu2ynZriqGEqWNQjXB9S+EKdtsld7hlhlIQgoPD5FKoY6scY0RY6y1xLB6x3/fYkpoV1+a0mbKsLbbMhK4mpI3TQKKWtkZUxtPSiKJxuB5LRaYRPZ9QmhqDIfVhSqmbmISuBpzDICQ+Ymaqps1EzKQMuTGqMC4ofE2vv0RsLIUvwkTjK1w5hiSA9h3NcHH4PYgKuQQZZElNa9681bLHr5LLjIiEpMFaQHB4Eh9uV1KyT/fTZ/mCx96xY8d47bXXeOihhxaeXFda71W/TyYTNjc3OX36NK+88grtdntBdV5aWrqsqWG+orv33nuvaY10pVTnC001V5vlcjWmlb/8y7/Mr/zKr1z0Z775zW/yP//n/2Q4HPKP/tE/uujPnu/cc6UJwHCTNZdL1YVOzqrK0aNHee211/jYxz520XH4WpvLpSYXVeWVV17h+PHjPPLII+d8AOcOse/9RZ0NNF6p2R3APjLMaYt57hifuus2Rncsc0ym/KXdolblgG+BChu2ZCg1d7s+fkkZasHIluzZ9dSu5HRWQmwojWfFZAykpK8pnnDS3JUQEb2nAfcdLqzDfJsSR0ZMrkKqMQMJQHO/ThiMR2gq+KWUtHEYOOiX8CgFNUNq7nLL5FKzTcGyT/Eq7NicniYkGDZNQUtjIiwlFdumZllTds2EQ65PYRxjU7GkLfrdhKPRgNU8TA/ZlmPD7DLtQd+liCgn7ZTW0FN0lQP0GZiatqZUeFKNUAy1BEdrVEi8ZWAKKhRDsPAJMQaGFW2xI1NqPBZhYopm7SakJIwpsBrsZAamINWIRE3j8Bxay6rrcMruEKtFRxVTglLbGBsilK3BSMw+7XMm2SZ2ETKBHTdAphIC0WyKT+chZW22zCZGDV1tU0pJRITBNrYxNR6PxTAwA4omSOxj/oELHmdvv/02b731Fo888sh1W9ecrROZM6rmpIBnnnkGVWVtbY319XXW1tbOy1ja2Njg2Wef5b777uPAgQPX5XnN62ICzrOzat471Vxtc7kaAeXP/dzP8WM/9mMX/Zk77riDr3zlK/zFX/zF+9iyjz32GH/37/5dfuu3fov9+/fzxBNPnPP9nZ0dqqp630RzqfqOai7nw1ycc7zwwgtsbW3xyU9+8pIH/Y2cXObA/XQ65TOf+cz7rkLOPkjPZ21xNY0FAnXw9ddf57777gv7b4XHFX7E38IrMuRtmfAXdosxNftchlFhWwq2bMVdrofvCRMqtkzOwaFQuoIzcYFLLLXxrJiUgQm6jrFUxGrZkpwWEau+hQIVsCUl6z5jJjV9bTHwOdVwStGP2GNaWJVgiyiOQkPU9I4pucV1KcUzbED3Vd9mV3JyVVY0xXjLlh1zwHfCOksMLR9RiqfEA4YZNQ6hpQkT40iIyZKMXJRu2sXVNSMzo97JOR3laAS1GMQaYh9z2uSs+YypVKz7HsMmLbJEWfUtCuNJiFCFtkbsmpy2xnSa6SAhxgE1nlI8mRp6PqYwDosh0ZiBKYMRpSitxuVYMSTeMLA5XoSirjEqtLtdRCyJRhRSBiNJhC2zG+7PRCx1WtQ4fF3j8ppRNaJ2Ho2VKioASyIJHd9epGfOkzSdOiopSTVmasJFw0fd3XR4/5XzPJX12LFjPProo1cE6l5pxXF8DilgOByysbHB0aNHeeGFF+j3+4upptvtsrGxwXPPPccDDzxwxSe/K63LnWpEZKGruZIaj8dX1VzmU+Cl6td//df5yle+svj3iRMn+PznP89v//Zv8+lPfxqAxx9/nK9+9aucPHly0ai//vWvk6Ypjz766BU9r++o5vLexpDnOUeOHAHCm5Jl2YVues59XK1OBS48ucyxnizL+MxnPnNe2uV7LSnmV0Hz713pwei959VXX+X06dPnvZpMMHxcl/m4LvOD/iBHZcLrMuKbdpszUrHqA3A/kpKTUnDYdTDd4LW8ZWYcHFvKuuSMLaiyYGGybFJGtmZZM6ZS01LLtuT0iVnRFBWY4Rm7GXZYYHoZe0za7P0NO2bKgcYGfyQFNYqIpcIxlIpbfJdcHDumoKMpmYs4bqeLqcWq5YyZsqYttsk5WC9RizKUipZPib3lXTtm1beoVOlpaH5FAm1SVjopb0dDelNDFSvJGceZbJe6B+qUlkmYUJNLTVujJuI4BK9FCEvN9DHP7ZlJ3VADgr7ljAkxw11NmZoQhiYYehqxKSWVONZcm7wB9yUEbuJVqb3SH1tkKQGCxqmUIHusRWlrxq7MyIjpaYeiuQ8bJyRRAmJRLchyy8hMkRzq3DFIxiRRjESWCKGkpjQVHZ+xbbYxaunQ5qP+o+87xlSVV199lVOnTvHYY499oNYkIsLS0hJLS0vnkAI2Nzd56623MMZQVRW33377ZZ1cr3ddaKqZTCZMJhOiKKIsy8Vn+1JYzXQ6vaFZLvP1/Lzmv8u77rprse35/u//fu677z5+8id/kl/91V9le3ubX/qlX+LLX/7yFV9U3FTN5XIwl/mVwmAw4MiRI6ytrXH//fdf9gh6I9hiIWTsyEWxHjjX+PJs2vXVuLZWVcVzzz1Hnud86lOfuiQIahAOa5fD2uV/8Qc4Q84rMuJJu8MJKegQkRAxoeaEFNziO8TtsNjZMTMOTCyFK9nUgrxjqbylb1JGUU1fU3JxdJtGk82gLivSbodRXBOp0mk0IssN0C/AjlQcdqE5DKQiISLTiJ2G8dXThMpo8APTdpPLMmFZ00a/ETExrpmIag74DoPmKj9Vg0HYMjkrPmNCzd485WQxhK6h3wn+a3UCVV1BVTEYDCm6lr6LydtKh4SuWjbslBhlxaeLCcY1K6VcKloak6llJo5EI2YNxhICv0J65NSUGCyRCmNTEqnBAJlaxhTkRUmCUC0bUgQ0xEJXEtJNM59wxg4QDJFGVAQvskBLjpjKjJIaI5ZxuyQhI01jEhWKumRUTJAaTFfQREMAmYGIjJSEw+4OMs69OFNVXnrppcVW4MO2JTmbFHDixAlefPFF9uzZw5kzZzh27BgrKyuLq/gP+rnOP9tFUfDcc89x8ODBBaZ0uQLOyWRyw6evS5W1lt/7vd/jZ37mZ/ie7/mec0SUV1o3VXO5VM3ZF/Ngr7vvvpvbb7/9ik7M1wNzOXvyOXbsGC+//PI5IWMXu62IUFXV4qrnatZgs9mMI0eOkGUZn/rUp64qmnUvGXs14/9SrzOm5hUZ8pTd5ZQUWIRMLYV4TkvOus+QlqFFysBM2T+LyOuKHTdi0rUs1YaOSRjHNcxqRupZ7XTZjWvWfSesivDsSMF+OkRq2DE5y5pSoNQ4RuK42/WYiWcoBV1NaGvMcTMhIwpK+iYgK9GIsRRERGTN5NXVBCcwlppWk0m/bQoyjUPmTa3sjEfIUkrXhLyUmSgtYorE0aNFfyXlXRnhZ1DWNZOdAdN2DKlFLUzMnA0mrPoWGybYqWQkjdZFMFjWfcppO6SrKZk3VBJs8C1Cv5k+LAmxN0y1YjyZoJlhKWkzkCmJClljBYOGVRsNrTnBsqQdCsJzAQIYL46p1OzxvQDSaxLA/syF948UqTzDaIS3SrJhyHsVqcakNuMuveOc48N7zwsvvMBwOOSTn/zkZW0FPqg6efIkL7/8Mg899NBiYpmTAjY2NhbmkfNGcz5L/BtR0+mUJ598kn379vHRj3508dm+XAHnB51Ceccdd5xXV3jbbbfxu7/7u9d8/99RzWX+y3r11Vd5+OGHr2oUvh6TS1mWeO955ZVXOHHiBI8++iirq6uXvK2qYozh7bff5uDBgywtLV3x4+/u7vLMM88sDuDr8aHpEvGorvJovUqF53UZ87TZ5XkZUCK0NdCANyWn71N8ammnKSMz42ARMXMlo3zKqCN0KqWfZJQ2TA9jatpEbJmcQ76Pw1PgGVJzu++iwEBquj6hBGY4CoRDPmMkjrHUrGub1Ee8FQ1Y0hBo1teMoYTsz4lU3Op6lOLIpWaPtoiwjKWi5xNG1Qw7run0euzEFS0NyvrTZkZHEwpR9rhWANslptVOaKGUqzVa1lSzCq1mTPqWjsYsSYsiciRqmUiN0SDWtAhtHzGyOQoLy0gviiB0fMYZOwxMOoXK1wzHI6I0ZjXqcsLskBARaUzZ0JVVtLndLorQ9S1mUhKpXZhRDk3BTCp6vsOumdLSFEuECngEh2usZrZwAi3NyFYsWiuurJkeHfGXm3/Jnj17WF9fp9/v8/zzzzObzXjssceuyS7peteJEyd4+eWX+cQnPnEOWWZuiT83j5yTAp577jm89+c4BVypjcnl1NwNeu/evec0FjgXq5lfmJ5PwHnixIkbqsr/oOumai4Xu4ovy3JhKfHwww9fEw2yLMuruu389nVd89RTT5HnOY8//vhljeBz0P6BBx7g9OnTi4S+9fV19u7dy+rq6iUbxalTpxZRAe/dn16vijF8TPt8zPVRpxxlwrN2yPMMGOLYp63GMbkk0YgytrRsi9ORZ3miSBozKwoGFpYLQ2RjZimIFyY4Wlh2Tc4tvksl4NQzoeYu36cUz65UdHwMmEbpbsNKzThqAhNNFN6xU/b5FiWedd9mJsHqJJyAE3ZMQYwln+UwLTGrbaxEOAqWfMq2FMRNLPOKD/hR3WTsCDASh4mElm2xol12yCm0oMxrNsudECOcRqyajM10Sk9TIiwqIGrwEkLSZlIRY0FDNDYYHJBWhp3JkCxNybKEqRRNeqTQ0piqUdujsGNnjbYoEIlrDY3HqjCWnEIqSgKAnGhKpBGZxlRSU+MoqZianEqUVFNW/RKlqbCJIYot33vXwwxWBouT8dx08YM0oLycOn78OK+88goPPfTQRS/moig6x2ZlOByyubnJsWPHePHFF+n3+4tG0+v1rvk1zmYzvvWtb7G+vv6+xvLemn/G3yvg/NM//VOOHDnC3/gbf+OansvNVDdVc7lQjUYjnnrqKfr9PlFjjXG1da2TS13XbGxssLq6ymc+85lLrqTmO9f5Y86bifeenZ0dNjY2FoFD8yvH9/owzdk677zzDh//+MevOCrgaksQ7qDLHa7L3+Igm+Q8a4Y8JwO2qbhTAwtroxijiUX6GV0su1nJQWeZxSVFUTG0Bf0ZaOyZJhG1KDmeVC0DU3HQdyjEk+OY4rnVd5kZx4iavk+IvOGUzWk1qvtalKRJWJzhKETpqmUkjmVtUYoyo8bkjjJ3VGspfYlxqvQ1DUmg4kkIV4ljqehrQo2nrTGRWowEE8xlAp6UEJEZT6+dULYdpvS4omTTTigsSK3EGqY6g2HJp5w2UzoaY4GWxoxMmGjaZcSZYkS31SJNMxIVhhJsXZZ8m5lUoVEpRBjyhgm33/eCswI2mFYizKRmSs1+v8JMClKNsVhq8VQ4cinp+zZnZIuWZnR9m1ICXlPjucvfRhql7N27l5WVFcbjMWmasra2tjiZzxla6+vrH5ix4ntrrq95+OGHr8jR/GxSwF133UVRFAtSwNtvv73Q3Kyvr7O6unrFK+Y8z3nyySfZs2fPVcUMGGN44okn+PEf/3F+/dd/nZ/+6Z++otvfzHXTN5dTp07x3HPPcfjwYe666y7++3//7x+ofcvZtbW1xTvvvEOSJDzyyCOXPJDeq7g/G7g3xiyst++55x5GoxEbGxsLH6aVlZUFt//NN99kd3eXxx577ENNqdtDxt/wGX/D72VCzRPTE/xlvs10b8LtdFAgx1OgWANd02aSVOzzwqxV4YqaQT2jO4IqgTqx5PHcIl6YmJoDvk0hnhmeCmVVM0ZSMaNmXYOP2btmyJJPUCDThEkzE8ykZtllVOqZ4OiUsNxf4V0zwfpgmBlrjCdEN2dYIrVMjaenprGNCUmPSRPxPGjink2Ds5y0Y9oa000SoiTFSoVnRic3DP0UnTokiUjimDKraUlE6iNyU4cVlfPMZjPSVkYSBXbbuJkqBINr/gsQq2VgJw3V2VLhMVhAiH3E0EyYSkivzBvjTYNtMKkZeSPK3LIjWtomIyHVhErKRpNjuNMHltA8ljhJEj7xiU9greXuu+8+h6E1t205X5bLjax33nmHN95447roa9I05dChQxw6dAjvPbu7u4vo4tlstvjcXQ4pIM9zvvWtb7G6usq99957VU33m9/8Jj/6oz/KV77yFX76p3/6ppoUr7VuqubyXmHh66+/zttvv82DDz64YFF80N5g83rnnXd45ZVX2L9/P7PZ7LIbi/f+khTEs03s7rrrLmazGRsbGwvFsjFmQRa4GqXsjajd46fRl1/jp+67j/V6H6/KmOfMgOfMgHXNqFFqlAkOL5ZulFHGjnWFWVRD7th1Be2hY5JOsUnEJKnZQ4YCE6lY1YwSz1TCOqnjIwZSURHsV2JvecsO2adtnMI+1yHXmulkiu8I+1pLDG2FQRp7lYxNk7OkCbVAz6WMpMI0nlx7fJstU9LRCIOhoykbMiUSS8eFBiFqyfGsaAPUq9CWhLwbqMLWAXnNlsyonDKbTBFbESUxpVYkQ0e1FhOTYDCN/xjUOPa7PjNTkWoECqVxFITv3+KWyCW8Fq/KVEompqJEub1eIjcltpnEplIyk4qJFBz0K4wlJ9OkCQurKcUxk4LvqT6OQSiKgqeeeop2u83HP/7xc47V89m2zKftsiwXAsc9e/bcEGzm6NGjvPnmmzz88MPX3WfLGMPq6iqrq6vcc889TKfTc0gBrVZrsT5bWVk5532ZTyyrq6t87GMfu6rP5JEjR/iRH/kR/uk//af8/M///E3xub6edVM1l3nVdc2zzz7LeDw+r/HktaRRXmlz8d7z8ssvL3j+eZ6f15Pn7LpWxX2r1WJ1dZV33nln8cHd2trim9/8JnEcs3fvXtbX1z8wFszZNXebPnbsGA8//PBi932f9rnP9fm/u1s4JjOeNbs8JwP2aEaORwmYS4KlY1Jc27Msnip2RIVn4Cq6mxU76Zgojphmnv0+oUaZiqPrYzyGmZQkWBI1jKWGxhVYgBMyJRvWkBoOSpiAKpRIQyM6YWa01OKBNZcxEYcjWOTHahhKRYEjxdJrqNMqoD4A9oIQN35gQ1OTamCOdUjYlAmZRrRNQtERUvE4KenHGbkrmY3HqCrViiUOwAyxWmZSNVhIzNDkZI2XW0LEjkwaQWqbsVQkNCA+ERtmxEwca67LxAQPMy+QecumGTKRghXtBlNOTZt3yTI2BROZsaw9bvf7F0D08vIy991330WPp/fatozHYzY3Nzl+/DgvvfQSvV5vsWK6HljGW2+9xdtvv80jjzxyVeSXK612u81tt93GbbfdtkiU3Nzc5Pnnn8c5tyAF9Pt9nn32WZaXl6+6sTz33HP8rb/1t/ilX/olfvEXf/GvXGOBm7C5TCaTc8SI72V2fJCTS1VVPP300xRFwWc+8xna7TZnzpy5LPPJa1Hcb21t8eyzz3Lrrbdy1113ISKLK8ft7e2FKllVFx/mtbW1q6IkX0l573nxxRfZ2dnhk5/85HkFdYJwm7a5zbX5IQ6yRbGYaFY0Y0iI4B1Tk6ilJQkmg67UuDQlK5SBVnS2KjaiIVESkWeeW3S+LnNkPuTOb5qCFIsolK7G+ZokjtE0ZiZKWw0lnq5GIbmyyWRBYSQ1fRIcQqoRNUEBr6K0vSWX4IVsNAorKQnWLi2N2JKcjBhtmHSbMqVSUJUGCwFF2Oe7FJlDpkGP0mm12bA5FI7p7oiyNcMkEUWqDbYT/MisN4xNSd5MLV2fBm8yDKIhnXMsFZHGtDVdpE+KKhtmxFhKYixtn+LEL3zHds2EsczwonyyvHfxWduzZ88Vr3VEZBGEdfjwYcqyXKzP3nnnnQVZZc+ePaytrV3x+myOMd5oR4AL1TxRcu/evYvslTkpYDQaEccxaZoyHA7p9/tX9N69+OKLfPGLX+Tnfu7n+Mf/+B//lWwscJM1l6Io+MY3vsEtt9xyQZrt5druX6gu19V4ngfe6XTOAe4vdPv3AvdX21iOHTvGq6++ysc+9rH3GfC9NwVwMBiwsbHB66+/zvPPP8/q6uri+9d7RVFVFc888wzOOT71qU9d9v2vkfLX/V7+ut/LlJoXzZBnZUCE4YwpaKlhSoXVkH8YpYZUDCZNSStl5Etag5qT7BDHMUVbucV3mBlPjqfnY0zuOCMzMpvQbsSkQ6pgSyNK4iMqlBClJVgME/F0G1v8tkbUEhycuy7k2HQ0wgJ7fcYJO2XFp0H/g2VLlFiVWA25BPtOj9DR4MbsAavCjhRI7jCVY72zzE5SoiJ00xbtNUNRleS+hG3HqeWKbh1RG0NiLSWOvAk8m5k65MFoEMOOJfiA7XO9EGLWRAfEwNCURFj2uiXqprHUeKwIuzJDEO6qD9AfJnzryW9x4MAB7r777ms+wSVJwsGDBzl48OA5WMarr75KURTnYBkXE/y+12rmw8QY5zVfW2dZxqlTp9i7d+9im/DUU09hjFlMdJe6yHv11Vf54he/yN/7e3+PX/7lX/4r21jgJmsuWZbxyU9+8qIj8LVOLpfTnOZJerfeeuv7qIXns485n4ndlR40c5uNkydP8sgjj1ySEXN2Xsbdd9/NZDLhzJkzCx1Av99frM+uVZg1F222Wi0efvjhqwZx20Q85ld5jFVqPK/5gNPsiuUtmbJPU0rmTsOeKLZYEWzaIqmUqS9IJ56T1TZRHFN2IJ06NooZLMe0JSH1hqN2Ql8D4L/PtZiII2lA8o6PGUvN/Lez4jOO2SkrmpIgtIg4zYyEiI4GrYxHcaJkPm78z0KC6Jz6DLDXtxmYikyDQDPkqAxp1bDeWaKMAhXZYljyGaV1xDbDY5m1a2KnaK3MJmNGmVC3BS9QKUREQYmPsGFHVCg9TZmbXtZ4YjUct7tEWDqaNc9QKMURqeWE3cGqpactPrKzh29961vcdtttHD58+Lqf4M7GMj760Y8ynU7PwRA7nc45rsfzx5+vXI8fP/6BW81cqsqy5Fvf+ha9Xo8HHngAETmHFLC5uckbb7zBc8899z6ngPnre+ONN/ihH/ohfvzHf5x/8S/+xV/pxgI3WXMBWF5evm5plOeri00uqso777zDq6++yn333XfeTIj3NrcrAe4vVPNws9lsxqc+9amrsq7odDocPnyYw4cPUxQFGxsbbGxs8MYbb9BqtRYTzZXmmg8GA55++mn27dt3VVTLC1V0lp4G4JhMec4MOEXOi2bIAc2ogb7GDKUmjmMUT48W1sGsLohmFcN8hsSNdsQJM+PxTRRA4g3v2imrjfByb4Oz+GaFlfmIsamAoILvacJIygYhIvwcgtcgjpw1NvUeS9+nVI0zctCbVKQNkyt1lnd1gBjotttEaplQUYpnxbeZSkXc6F26mrBjclZsi047Rlow1CkTW7K8DaNoRCIRNrbYONjztEjY47pUpsajzKRkKsEDoKMZS65FZSoqHGPJw+2J6ZGxd9rhrW++uoj/vdElIguB49muxxsbGwvd2vxEvLu7y+nTp3nsscc+UKX6paosS5588km63S7333//+wSSZzfSORlnc3OT119/nWPHjvFnf/ZnfOpTn+LXfu3X+JEf+RG+9rWvfeBY6YdRN11zuVRd61psPnm8l3Xlveell15aHNwXmhzObk7XA1+Zm28mScInP/nJ65IznqbpguEzVytvbGycI9yc8/ovNoXMsZ35iehGXmndqm1udaGpbruS58yAd2TC02bAXk0DCK8pG6ZkxSaUTklmSrvbpVSHuJrBcIiPLFXXYJxSWagJDcKqYUdy+gQMb0ljZibkqpjGwThvmodiSL2lliavRi1TcSRqQIR1n7FhCpY0wQM9TTlmRsGq33m2JmNcV0htTM+nFOKoVClVGyN+aZ4TvGvHJARtTaKWsZTkVkPC54olc0JdVfhpxdZKgXVCUgizqMSIYWZqOppxygzpa4u2xjjjKXCMTM6a77JjJvR8G1Mp1Tc3uPfuey8aS3Ej62zXY+/9YrX78ssvU1UVS0tLbG5uIiIfupcZfLuxtNttHnjggUs2hVartSAFOOd44okn+K//9b/yi7/4i1hreffdd/nN3/xNfuAHfuC6xxffbPUd11ystVRVdU23f2+mylz9X1UVjz/++EV3wvPmdD2s8udTwfr6Ovfee+8NuZo5W608H+HPnDmz+DCvra0tdshnN7a5aO3+++//wM30Vkn4Pr8OrPN/c44XzZDXZcQRs0tXI8bjCXFZMVvNiImpMRwko15WSlcy1orpcEQVCa4b4VyFiVJmRumpNO1DGqaY0PMRW1LSa/T5+33Glinpa3g/VjQNFvxYRJWxqZnP1qlaNkxIksQrk90x2rFopPR80mAyUInnoO8ykZqOxtTiEYGSYOrZ1oicmlwcMxx7fDtYylhBjGHQUhDIqgibewaMcLHgMxjbko5vkRGTaMxIZgzMDN9ELPd9Cy0d7t0JD93+wHXPPLnaMsawvLzM6dOnsdby4IMPLhhor7322mLi/iD9wc6uqqouSNG+nLLWcvjwYV5//XV+8id/kl/4hV/gv/23/8Zv/uZv8tu//dv8wR/8wQ165jdHiV5sB/UhVFVVF2VjvfHGG0wmEx588MGruv+6rvnDP/xD/ubf/JvEccx4POapp56i2+3y4IMPXpJxlec5f/Inf8LnPve5cxxOr7ROnz7NCy+88IFMBeerOZX0zJkzbGxsMB6PF7viOX7z0EMPXXdtwbVUXpX8wdvPcqwPm4daeIEVjYkU3jUz9mlGTchSqURxrmbLlCxvV+QxzLoRe+qYvk05Fs9Y1oSWWhRlw+SsaUqshh1ToCjLmpBpwHBaGrGkMRmGY2ZMqpY1TUFgQ2bUeLobBaadoO2YXVNwm+viRXF4SqmYiKevCalaWioci4YIsOpbtBo35V0zY9W3qcWRaYRHSRTesQN6mrDq26iEkLVdmbA0scFQs1AiY4nSiFFWUeO53a1QSo0vKyazCd8/uY871i4//vdG19x1eXt7m0cfffSci7o5FXi+Ypr7g10sNOx6VlVVPPnkk2RZxoMPPnhVje306dP8wA/8AI888gi/9Vu/dc65pa7rG87u/LDrO+7VXQ+dCwTjuLkJ5G233XZZjJm58WQcx/zlX/7lgqp4JZx+VV0k+j3wwAPs3bv3ql/LtdTZVNK5cPP06dO8/fbblGVJp9Nha2sLay3dbvdDBx/n68NbsowfuPNBbG05LjOek11eMeNG1R7cnE+aGXs0w9iIg0TUa4Jxjik5flxw0k6pOxEzVbrSYhC7b6/PEOZL18AG+/aFTqrBJDPkR4ZV20xqKu+RSYXpZmRZSPA85LsNy8tSA4nGjeGkYBR2pGCmoYF1fMLM1EzFkeObhhKO00iFt+2QlJhMU6waJlIyMAWZptQdWNE2RB7NKzbioCpqjw1jMwWFicv5qD1w0zWWOa39sccee5/r8nupwO8NDVtaWlrQ8K+3Jc18YknT9Koby+bmJl/84hd54IEH+A//4T+8r5H8VW8s8B3YXK4Vc5kzud555x2OHj3K/ffff1m7zzm+IiJ89rOfZXt7mzNnzvCtb32LOI4XnmEXG9/nuM7W1haPPfbYh8Lfv1BZa9nY2KDVavHYY48xHA45c+YMR48evezXd6NqPB5z5MiRhRp6/viHtMUhbfEFD7sEnOZ1GeMIHl5xo4VZ0pjYWvbSQlaFJQ8lM5KRcsYPqBOhbluiylM0F8TB3p8QCqZCRyOKRk1fAYc0IxdPXtUUxrHftkjSBNes3AZS0dGo0cJY3rIj1jQLOhYxDEwdYqA1YDKlekZScZtbppAKwVBSUxuPwdDVlI4mTE3NUCom4lh3nUbHYvAWtvvBg6zvM3pYxsWUKnK4VNj3imFrdet9SvMPo1SVF154gcFgcN7G8t66UGjYxsYGb775JmmaLhrNtb6+qqoWGOgnPvGJq7qvnZ0dfviHf5iPfOQj/Mf/+B+vC476nVg33VqsruuLNo+TJ09y9OhRPvOZz1zV/Xvv+YM/+AOiKOLRRx+9rLXPxYB77/0CMN/Y2FgIG/fu3XuOeGyuE6nrmoceeuimyseYTqccOXKEbrfLAw88cA7If7Zwc2NjA+/9ghDwQQg3d3d3efrpp7nlllsWgtJLVY7jJRnypkx40u6wojGZGibiQkBX49OV4+hqxNSVmLykUIfxStGJWHcJkgTV+5aZsc+3EYECRyk1CRZTOAbljKUkw6WGjkaUeCKEodQsaYygjE3FRGrWfEZfLdumYEtmLGnKXp9RiGMoYRWXYmlrjIonVcObNohPexqTqGXbTNmVglt8D8UTYygIVOsTZsiSZiz7lFk+Y6w5ZVd4eHcv+98IV9N1XZ9j2XKj10vvrXlOzGg04tFHH71mPdb8+Jw3m/nrmzPQruT+527nURQt/NWutAaDAV/84hfZt28fv/M7v3NTxRV80PUd11zOnDnDq6++yvd+7/de8X2XZcmRI0fY3d3lE5/4RMibv0SdnbdwKf2Kqi7EY2fOnKEoioVdxPHjx+l2u3z84x+/qTIb5ifvAwcOXNIu/Gzh5sbGBrPZ7IYKN8+cOcPzzz/P3XfffckgtguVQ3lTxrwhY56w21iEJR/j8OyYgjXNUIVtk9PXBKk9riwYRI50WiNJTNtYqiyiKzFTynBCLyvcZEbcy5gmsNTgM1bhbTtmXTNaGpESGkRXY1Y1Q1Q5YyeUeO7wvabJ1WyaGbf6HnXTnCpqtk2IHFjWlJ5G7MqMLZOTYNjvuqgoJeHYPGMmLGtGVxP8KGcQ5xRtWNKMv5d/khi7UJrPf3/j8ZilpaVFo7nRjsfee55//nkmkwmPPPLIdT9e5jjiHKcZDof0er3F67vY+vp6NJbRaMQP//AP0+/3+S//5b/cVBeQH0Z9xzWXra0tnn/+eb7v+77viu73bNv+0WjEfffdd9GwsbPjSa+GETY/0I8ePcrJkycBFifivXv33hQH3pxUcLX5MJPJZNFI5zYY89d3rTqFd999l1dfffW6s9VOyIzXZMQ3zQ7bUrJXUxIVjpkJa5qRIoyoqURZchZflJzOarJJTeoNLRuz0a5pjWv67S6JjThpZqxrhlWYmpqBVOzVjLa3bJoZI6lY14wVH9T/G2bG6v+/vfMOj6rM2/99ZiaT3sskIRBCIISaiiAoTakBEnEVXBuua1nLioKwdlREQF/ldRUU/a3gy6KsJCJFmkBARS8hPQFCEtIgyUzqZDJ95jy/P+JzdiY904Hzua78wWQyPCeTeb7n+Zb7JuJOAU2waGWomCaBJ+mczncHgwaBEsHEE+5ECBYspMKOThsEgz90AiP0MKJVoIYfce9sKCBu0CpUULrpofEC3CHEHF0sJhh77g4zTS+1tLTA3d2du1GwdfqTZVkUFRVBpVIhJSXFIScmrVbLZRWam5shEonM5PVpADEYDFybfmJiokWBRalUYunSpRCJRDh48KBLzek4C5erufS3gVtSc5HJZCgsLER0dDRGjhyJX3/9tc/X6Dpxb0lHGMMwaG9vh1QqxdixYxEUFMRtxJcvX4avr6/ZBL2jC+bV1dWoqKiwqqnAdDjOdHDzypUr8PDw4K5vMIObpt41g/XuGAiRxBORxBMz2DDIocdlRoEcYSuMEPzh7CiCWqCFGEKIGCFYD08QgRK+3n4QaQ1oYjRgjQBDGLBKHa76a+FJRBAQBu4QoI5RwRMiuBEBDAxBxx9eMD6sGKo/nDUZIkAw6/mHOrERSsYIX9LZMNBZswFq/gh2bn/Mv9QIldATBmHEC3qGQEdYtAq1CGG9oWZ08GHdoFSpwBoNUAUw8CAiDDX6YZyx99N5V8VjuhFT90aaWurapj5YWJZFQUEBtFqtwwIL0DnvZSpJQxWdS0tLodVqERQUhODgYNTX10MkElkcWNRqNe69914AwP79+/nA8gcuF1z6YzDyL7Qzq7y8HOPH/7e/v6/X6OrBYsndG7ULuHr1qplyMB2u0ul0NtmILYEQgtLSUkilUqSkpNhMbdYWg5tUgbqpqalXYUxb4g83TCJBmGQIghZGlDEdyBO0dTpegoEYQjT+oeMlAgO9Tg+NlwA+Qjf4egihZnXQEhZClRZavQFybyH0AiCQiOD+RzOBDgQBRAQw6AwkMCCK9YIGRhjBop3RI5r1hRYsGDBQMnoI0Dm5T31k6gQqqMEikHjAj3WHitGjVaCFhnS+hhcrhkKlBDEYIQ9m4EVECGA9MNEg+UMvun+EQmGP3VnUXyggIMAsfTZQjEYjCgoKoNfrkZKS4rTitql/EiGEa7evqKiAwWCAj48PKisrOZvngX4GNRoN7rvvPqjVahw9etQltNBches2uPTna0ILh01NTbjlllvMNtHegos1aTCK0WhEcXExFAoFbrnllh4/iGKxmDMs6roRU3FK6gxoy9SE0WhEUVERlEolbrnllj6HRa2hp8FN0ylsWlAODQ3lNhuj0YjCwkJOAsfRaUN3CDGe+GO80R+skaCSUXbK0TBaCCGEXq6CUsQCbkJ4EBE83cRQCQhEDBDk7gmWMaCD6AE9AduhQrOHGzo8CMQQItDoDrXAiI4/FABE6DyhKGGEGyuEAkZ4QwQtjPAmYjQI1AhhPTon+QkgF+jhR9zhTzpdMVsZHRSMEaMMAdDBAIVKCZU7C19vT3gSIwJYD/gTd8Sxvad9+6Jrd5appElZWRm8vLy49JK/v3+vf6NGoxH5+fkwGo1ITk52ma4phmHg6emJ1tZWrg7a2tqKpqamQQlRarVaPPjgg2hpacHx48cdYgtwPeFyNReWZfucwNfr9Thx4gTuvPPOPt900z/qrhtVXl4eAgMDMXz4cO4xW0m55OfnQygUIiEhYdDHf3p0p4ONRqPRrPPMms4s2sxA88rO+KD3NLgZEBCAoKAgyGQyCIVCp62tN/R6PU6X5qM2kEHLMB/UC7QYyXpDwxjRyGghADCM9YKC0UMqUMOPFcFHw6Cd6NDmSRCoIPAUiWB0F6JJpMdI1pezIG4QqDGM9e7UMmMABfQwMCw3sS8CwRWhAh4QIZh1hw8RQipQoU2gQzDrAV9WhA6lAioPglChD+RCHQJYdwgAzDAMRSxr25QiALOboaamJgDo0fbBaDQiLy8PhBAkJSW51FwHDXosy3Zbm6kkTVNTE1QqVY/ulHq9Hg899BCqqqpw8uRJBAcHO+tyXJbrLriwLItjx45h1qxZPXabKBQKzvyot86swsJCeHt7IzY2lntNa08sCoWCm8Xoz3RpINDUBN2IaWcWTZ8NJnAplUrk5eXB398f48aNc/qcA0WtVqOurg5VVVVgWRY+Pj7c9dnCbMpaqEMjndIWCoVohx4XBe3IF7ThMtOBGNYLLEOggB4tjA6jWV9oGSNaBFpoYESkxg1Kgw5yNyMYAgQYBBC7iaEQs/CDG1iGwIMIoGAMf3SE6RFA3GCAEXqBEe2MDqGsJ7yJEK0CDZoZDXzghiEGLzQq5dB4AFp3gjDiBTERggGBN3HDffoxdv/9dO0epBtxcHAwGhoauDqGqwUWOhKQnJzc79pM3SlbW1vx/vvvY/jw4aisrERLSwtOnTrltEFoV+e6Cy4AcPToUdx2223dUk4ymQwFBQWIiYnpcyaiuLgYYrEYo0aNMvNgsUQqH/ivwGNMTAyGDx9ul02R5ohlMhkUCgX8/f25HHlf6a3W1lZuTmTkyJFO37BNoR18YWFhiI2NNbsjpoObthiMswSVSoXc3Nw+HRp1YHGZUaBA0IZiQTsC/pCH0YNFPaNGLOsNI0OgYYxoYNSI0XpAbdBBRfTo8GQQqGbgKXIDxELoBSw0DIsgtlNSxp0wqBIoEEo84PWHt8wVoQKeECJM7w5FhwJaLwYqD4KRBj/omE6LsjZGg/t08RhKHJ/7V6lUkEqlqKyshNFo5KT1HVFLHAi0sUCv1w8osHRFr9dj165dePfdd9HQ0ABfX18sXLgQixYtQlpamksNRbsCrnNLMQi6dowRQlBZWYmKigpMmDCh3/kVWnOxReG+pqYGFRUVdhd4NJXU12g0XOdZWVkZvL29uUBjKtXS0NCAkpISjB492mkquL3R0tKCgoICDB8+nAvIERERiIiI4Lza6ZwL7VyyRXpwINCgFx4e3ufsjxgCszpNNZQoFMpRKJDDAyJomU5XlTboEcF6Q+8GiN08IRcwGKYXQyXSQa3ToYMh8NExcHcTgYhY6IQspH/UWTyICEIiwBVhO0REAH+jGMpWBdT+Qqg8CIJZDxgYBgQEzQINollfpwQWoFPxuLGxkQvItNZG07GmbcCOPs3QwKLT6SwKLEDnHnHu3Dl4enqisrISdXV1OHjwIDZv3ozRo0cjOTnZDiu/fnG5kwshBDqdrs/nZGdnIyEhAYGBgTAajSgpKUFLSwuSk5MHdPdA3fFGjx5tcRqMdjY1NjYiMTHRacU8vV6PpqYmyGQyNDU1cbMKRqMR9fX1SEhI6HOexxnQoBcfH9+jZ44pXdODKpXKLD1o60G8trY25OXlITo62iojLRk0KPzD3rmaUWI46w0B0+mQqWM6rZe9IICC0cODFaCD1UGsMUINA8QGQOMrQjARA0IGGgELOaNDqNEdhtYOaH1F6PAg8CNuiDJ6QSnoHMLUwoi/aycijNinUaMvqB6XWCzmUogUU0OtxsZGaDQaro4RGhpq9+YNlmVRWFgIrVZrcWMBy7J4/vnnceLECZw6dcohXjjXO9dlcPnpp58QHx8PPz8/s6LhQP5ICSG4du0a115J7/gH8weu1+tRWFgInU6HxMREu3VdDRaj0ciZFKlUKjPxv/68WxxFTU0NysvLMWHCBISGhg765+05uNnU1ITCwkKrFAF6ogN6FAvaUSSQ4xKjQPQfdRoDWDQyagQSd3iic1BSDxZy6OCrJjDo9RAaWLQEuyFIJwRRaeHh5oZ6Xxa+ECGc9QQLAqlABQ2MmGaUYJHB8ZueTqczq031lwWg72FjYyPkcjl8fHy4U81g/ej7gw5vqtVqi1uhWZbF2rVrceDAAWRnZ2PEiBE2W9+NzHUZXM6ePYvw8HDU1NQgMDCwmx5Wb5gW7nU6HXfH39rayg019rdJqVQq5Ofnw9PTExMmTHCpYiV1tNRoNEhISDBLn+n1eu4DbO1QnCUQQlBWVoa6ujokJSXZ5KSn1Wq597ClpQUeHh5coBlsjr++vh4XLlzAuHHjBiQLZCl6sChlFCgUyFEskCOC9YCW6ZR86Qw0nY0a7hCgg9FBAQM8tAQCpQ4CI4uWMDE8jQxC4QEfRoxqoQJqGBFOPPEX3UgEwLEt3KZmWpZ4nuh0OrMp+sGY2fWHrQLLa6+9hv/85z84deoU4uLiLF7PzYbLBRegc9Poi59//hkqlQqxsbEYMWLEgKTy+yrc00AjlUrR0tICT0/PHuX0B6PD5WhoG7SbmxsmTpxo9kEy1ZSSyWRQKpVmUjT2FtdjWRYXLlxAW1sbkpKS7DLB3LVFlmEYrk7T3yZFjdEmTpzo0BQiAUHVH/bORYwcHhBAAyN8IUI79PCDG1pYDYTtajBeboBYBBUM8FGyIGo9VAEi6MQMgo1ipJAQzGEd62yo1Wo5+9+BuDT2B23Fp+kzOkVviXadqY6ZpaoAhBC8/fbb2LFjB06dOoUxY+zfgXcjcV0FFyoNUl5ejiFDhmD8+PH9vlbXifv+OsLoJiWVSrmupbCwMAiFQlRVVWH06NE2TZnYAipJHxgYOKA2aJVKxdUw5HI5/Pz8zKRobInBYOBSiElJSQ5RiTUd3JTJZNDpdGanNrrRdJWacbYxWhO0XJ1GDh20rBFu7Rq4eXnAT+yOq4wa4cSj07mGEFQLVfBXA25KPVJLdIgK+O8dv7276zQaDXJycuDn52eX9nY6RU/TZ1SEkr6PfbWq2yqwbNq0Cdu2bcPJkycxYcIEay+pR86cOYP33nsPOTk5qK+vx3fffYeMjAzu+71d4+bNm/Hiiy8CAGbOnInTp0+bfX/ZsmX45ptv7LLmgeKSwUWn06Hrsujke2trK7y9vRESEoKYmJg+X8fawUgqp19RUQGFQsFNntO7YVeYF2lubkZhYSGGDRs2oFNcV0w1wZqbm+Hl5cUFGmvz31qtFnl5eXBzc0NCQoJTUoimSrkymYwb3AwNDYVCoUBzczNSUlLsLjUzWGqaGnCisQzKkcGo8zJABAH8iBtEYGCEEbVMp/OmD4QYY/RDYqMb9z4aDAa7pkBpYKFdYY44wdPsAv07dXNzM/NwoSdTQginkJGammpxYPnwww/xwQcf4MSJE0hKSrL15XAcPnwYv/zyC5KTk3H33Xd3Cy4NDQ3dnv/oo4+ivLycq/3MnDkTcXFxeOutt7jneXp6Ol0x4LoILtSFkGEYJCUloaysDO7u7hg1alSvr2GLiXvaiSaXy5GYmAi9Xs/NmhiNRu64HhIS4pRieV1dHS5evIgxY8YMyPCsPwwGg1nnmWlDwGBVcumciCsObspkMs5x08vLi7thcIXBTeC/3XTjx4+HRCKBHkZcZjpQJJCjWNAOHyIEC8AHQujA4lnDKLjjv5trV1l9GkxDQ0O5CXNLUavVyMnJ4YzbnPH7YlnWzAKZSgqFhISgqamJO7FYckomhODjjz/Gxo0bcfToUdxyyy12uIKeYRimW3DpSkZGBhQKBU6cOME9NnPmTCQmJmLLli32X+QgcPngIpfLkZubi+DgYC6ve/HiRTAMg/j4+B5/3hYT91qtFgUFBQCAxMREszsg0/ZYmUwGjUbD3UWZ6mXZC9N0zsSJE+0iPUE/wDR9Rk3Cupqg9YRcLkdeXh4iIyMHZB/tSOiEtk6nw4QJEziBRlcY3ASAa9euobS0tM/6T/UfumdFjBy3ssGYyfY+Ia5Wq81k9b28vLj3cbAnU7VajfPnzyMkJATx8fEu8b6aSgrV1tZCr9fD19cXEolk0IrjhBBs374d69atw+HDhzF16lQ7r96c/oKLVCpFVFQUdu7ciT//+c/c4zNnzkRJSQkIIZBIJFiwYAHeeOMNp4toumRw0ev1YFkWDQ0NKCoqwsiRI80m3y9fvgy9Xo9x48aZ/Vx/hfuBQmsY9Njf10ZqqrBK0y72nMOgVsktLS1ISkpySDqHynzQa9RqtQgODkZYWFg3N0PazhsbG+tyswB6vR75+fkA0E3DrKdg6sjBTQDcQG5CQgKnpG1L6MmUBtPBdGapVCqcP38eYWFhGD16tEsEFgohhGsYoTcMTU1NaG5uhlgsHtANAyEEO3bswEsvvYSDBw9i+vTpDr6K/oPL5s2bsXHjRtTV1ZmNTnz++eeIiYlBeHg4iouL8dJLL2HkyJE4fvy4g1beMy4ZXHQ6HcrKylBZWYmEhIRu2j0VFRXo6OhAQkIC91hXDxZLA0tTUxOKioosrmHQtItMJoNcLh+wTMtAoPM1er3eaVbJPQVTOi/EsiwqKiowduxYzt7AVehJJ6w3HD24CQCVlZWoqqpCcnKyQ3Llpk0PtDPLVK3a9IZBqVQiJycH4eHhLncSJYRwN1upqalmnwlTi25q8WzqUWPa2PHvf/8bq1atwvfff4/Zs2c75Vr6Cy7x8fGYM2cO/vnPf/b5Ojk5OUhNTUVOTo5TVQNcMrjk5OSgubkZycnJPR7tqqqquIl8wLy+wjCMxemM2tpaXL582WabIy2W0zkMKsxIZ2kG8yGldSd3d3dMnDjRZeZraDCtra2FWq2Gl5cXIiIiLLpGezEQnbC+6Dr0Z0ujN+r9U1dX1+vfu73pqTOLDqf6+PigpKQEQ4YMcTltOkIILl26hObm5m6Bpafndq1FHTt2DO7u7vDz88N7772HvXv3Yv78+Q68AnP6Ci4//fQTpk+fjvz8fLOb6p4ghMDd3R3/93//h2XLltlptf3jGjtUF6KiohAXF9drp4eptpgtCvfUQKuhoQEpKSk2a0k1NdAylWmprKzkDMIGkvumiss01+0qxXGg081QrVbDaDQiJSUFGo3G7BotHWq0FQPVCesLU8dNavQmk8k4ozdLr5H+3clkMqSmpjrNwZBhGPj4+MDHxwcxMTHcTVFDQwPKy8shEom4k05f/i2OxDSwpKSk9HuKZxgGfn5+8PPzQ2xsLDQaDcrKyrB9+3ZcvnwZkZGROH78ODw8PHDbbbe5zM0b5f/9v/+HlJSUfgMLAJSUlECv1zs9e+Bav8E/CA4O7tNtUigUwmAw2CSw0Kl2tVqNyZMn203Kxc3NzUyYsbm5GTKZDLm5uWYugF27smgNw56Ky5ZC28M7OjrMzMciIyPNrtHUjdKRbdy20gkzxdTozfQaaS3H9Br7Sr3R2llraysmTZrkMhJCQOdNkb+/P8rLyxETEwM/Pz80NjZyDS49+bc4EhqUm5qakJqaatHvzsPDA0OHDsXVq1exe/dueHl54cCBA1i+fDlWr16N1atX22Hl3eno6EB5eTn378rKSuTn5yMoKAjDhg0DALS3t+Pbb7/F//zP/3T7+YqKCvz73//GwoULERISggsXLmDVqlVISkrCtGnTHHINveGSaTGDwdBncKE+9FOmTOEcKS3ZONRqNfLz8zmxPWeYVNGpZKlUisbGRhBCuA1KrVajrKzMJWsYer0eBQUFYFm2WzddV0z9y2kbt+kchj02KGqDYGudsN7oqYbR0+AmfS4Nyj2Z2Tmb9vZ25ObmckGZ0pN/i+kEvSOugxCCy5cvc6c9S4PykSNH8OCDD+Jf//qXWeqISkM56j3Jzs7GrFmzuj3+8MMPY8eOHQCA7du3Y+XKlaivr+9Wj6utrcUDDzzA/T0NHToUaWlpeOONN+zSFDIYXDK4GI1GGAyGHr9HCEFbWxvOnTuH8PBwrptnsHfCcrkc+fn5XPeLqxz15XI5pFIp6urqYDAYEBgYiKioKLttwpZA6z8DKY53xdSfXSaTQaVSmRWSbVEsd5ROWG/0NbgZHByMsrIyTqHXkiE/e0Jb/+lJuS96qkXR99HU+sFWUH26hoYGpKamWjyzc/LkSSxfvhyffvop7r//fpfKBtxIXFfBxVTKxVTew2AwDHgGA+jsFy8pKUFsbCyGDRvmUn9cLMuipKQEbW1tGD16NNe1ZI0TpS2hbdp0iM7aoNxV5Zh211k68EdVlxMSElzGepYKiEqlUrS2tkIgEGDo0KEIDw93mcFN4L9pRPq5GAw9TdDbcmaINj7U19dbFVjOnDmDe+65B//7v/+LRx55xGV+9zci101wMQ0spmkw07ZRqVTK6UjRGQzTu31qKlZVVWWx5Ls9oakmo9GIxMREs7v4rk6UltoFWAPdfIYOHdqn06elaLVarv23paWlVxO0nqCDpbW1tUhMTHS6TlhX9Ho9pzIRGRmJ5uZmMxUEZw5uAp2OpXl5eTZJI5qavdGZIXo6tUSOxrSjzprGh7Nnz2Lp0qXYvHkznnjiCT6w2BmXDC5drY57CyxdMZ3WlUql3N2+RCLh0hF0+NDZ06tdUavVyMvL46TL+zp90Y4smUyGtrY2m3qa9AZ1hXRUDYN215lOz5tuwqZ/A6ZdV8nJyS6nE2bqd2L63prKmDQ2NjqkFtUTLS0tyM/PR1xcnM0dS03ToI2NjVAqlWZGYf3VTAghqKiowLVr16wKLOfOnUN6ejrefvttPPPMM3xgcQAuHVzoxL2lUi70br+hoQEdHR0QCoUYMWIEIiMjXSrXTes/Eolk0NPPpq2xzc3NAlXyZQAAND1JREFUg7rbHyhXr17F5cuXMX78+G4DrY6ADsPRO2Hgv11ZAQEBuHTpEuRyOVJSUlyq6wrovBHIzc3tV5a+p1qUI4rlzc3NKCgowOjRo/t1BbUFarWaCzRUhJZeY08t+RUVFbh69apV4qJ5eXlYtGgRXn31Vbzwwgt2Cyz9KRyvWLECO3fuNPuZyZMn47fffuP+rdVqsXr1anz99ddQq9W44447sHXrVpezKR8ILhtcdDqdTSbulUoldyIIDAzkhsSckVbqCXoisEX9p6vwpFgs5q7RkjkTUw2zxMREBAYGWrw2W0Hrbaa6biKRCLGxsYiIiHBKx19vUJFHaoUwmN9/V1sEWw5uUmib+5gxY5zSjajX67lW7ubmZgiFQu7kFhQUhOrqatTU1CA1NdXiwFJUVISFCxdi9erV+Mc//mHXE0t/CscrVqyAVCrFl19+yT0mFovNurr+9re/4cCBA9ixYweCg4OxatUqtLS0ICcnxyWcZAeDSwYXg8EAjUbD/dvSPHRLSwsKCgoQFRVlNl3cU1opLCwMEonEoXe+1KRq3LhxkEgkNn3trnf7DMNwgWYguX2WZXHp0iU0NTW5ZKqJerYTQhAcHMyp4QYGBnKbsDNvGqhkikQisdpYjp5OabHc3d2du8aAgACLXpu2ao8dO9YpHXVdMW1Xp63cADBixAhERUVZlGm4cOECFixYgKeffhpvvPGGQ1NhPU3br1ixAm1tbdi3b1+PPyOXyxEaGmo2WV9XV4ehQ4fihx9+wLx58xywctvhksHl4YcfRkVFBTIyMrBkyRIMGTJk0H8YV69eRWlpKeLj4/s87ut0Oi7QmEq0SCQSu9UvTC1/HVF8pjMYXe0CeuuuMxqNKCwshEajQVJSksvNYVCdMGo1TdffVdfNEbWonlAoFMjJyUFUVJTNGx/o4CbdhAFwaaWBdEoCnafloqIiTtLf1bhy5Qqqq6sRHh6O9vZ2KBQK+Pv7c9c5kPeytLQUCxYswCOPPIINGzY4vMbSW3DZt28fxGIxAgICMGPGDLzzzjtcqvnkyZO444470NLSYpYlSEhIQEZGBt58802HXoO1uGRwuXr1Kvbu3YusrCycPXsWqampSE9PR3p6OqKjo/vtGqIb98SJEwc1SKTX683qF9TuWCKR2Kx+QafaFQoFkpOTrfbXGCxdu+vosB/triOEID8/HwzDdFMOdgUGqhNmWoui1tWWSs0PBtpRN3z48H7N7KyFZVlOrdpUfLIntWqKVCpFcXExJkyY4JT6WX9UVVWhqqoKKSkpXNONRqPh0r2mtgGhoaE9pnsrKiowf/58LF++HO+9955TOvB6Ci579uyBj48PoqOjUVlZiddeew0GgwE5OTlwd3fH7t278cgjj3Rz4p07dy5iYmLw2WefOfgqrMMlgwuFEMIVxrKysnDmzBlMnDiRCzRdhfSMRiOKioqgVCqRmJho1d1qT/ULaipl6eak0+nMJN+d3VRABQupOkBHRwcYhoG3tzcSEhJcrjhuqU4Yta6m7yWV27F1+y/tunJUR50ppmrVjY2N3N2+6cwQNSGbOHGiy7XhA0B1dTWuXLmClJQU+Pn59fgc+l7SLkKg8+TW0tKChIQEtLS0YMGCBVi8eDE++ugjp7V2D8T4q76+HtHR0fjmm2+wdOnSXoPLnDlzEBsbi08//dTOq7YtLh1cTCGEoKmpiQs0J0+eRHx8PBdoPDw88OSTT+LFF1/EzJkzbXrHbaoh1djYyG1OEolkwDlvesdNPcddrThHUzn0JGU60GgLuwBraW1tRX5+PoYPH26VxhrN7dP0GTVBs9ZRlNYw4uPjbeIKai10cJPODInFYuh0OsTFxWHo0KEu14pLvWz6CixdoSe3xsZGPProoygsLIRIJMKkSZPw9ddfO6T7rTcGElwAYNSoUfjrX/+KtWvX8mkxV4AQgtbWVuzfvx+ZmZk4evQoWJZFbGwstm/fjpSUFLvdsZiaSslkMjAMg9DQUEgkkl7vgtva2pCfn++SzozAfxsfTDduOtAok8nQ2tpqZhfg6OI+3bhtPYdhqpVFO8968zTpC5pqctUaRm1tLUpLSxEQEACFQgGhUMilCJ05uEmhgcUaL5tr165h9uzZXCPH77//jtTUVGzYsMEp/iwDCS7Nzc0YMmQItm/fjoceeogr6O/atQv33nsvgM7TTVRUFF/Qdwb79u3Dgw8+iLS0NGi1Whw7dgwRERFIT09HRkYGkpKS7BpoaKFcKpWaiU5SvTMqNeOMVMlAoKmSMWPG9HrH3bUWNRi7AGuhOmH23rhNPU26qiD0NexXV1eHS5cuuaTiA/DfGaXExEQEBQWZndzo4Cat0wQHBzu8xlZbW4vy8nKrAotUKsWCBQuQmpqKnTt3QigUQiaT4dChQ5g0aRLGjx9v41X3jKnCcVJSEj744APMmjULQUFBCAoKwrp163D33XcjIiICVVVVePnll1FTU4OLFy9y9aW//e1vOHjwIHbs2IGgoCCsXr0azc3NfCuyoykoKMBtt92Gr776CnfddReAzjf4hx9+QGZmJg4fPoygoCAsWbIEGRkZmDRpkt3eIFPRSZlMBr1eDy8vLyiVSqcJKPZHdXU1Kioq+vRr74rRaDSrRYlEIrO7YFsGGmfqhNF2dTrsR09upqKMtJWcbtyuBl1fUlJSjzNKPU3PO1LlmAa+5ORkizsmm5qasHDhQowdOxa7d+92qrhrXwrH27ZtQ0ZGBvLy8tDW1oaIiAjMmjULb7/9ttlNp0ajwYsvvojdu3ebDVG64o1pf1zXwQXo/AD19otXqVQ4evQoMjMzcejQIXh7e2Px4sXIyMjArbfearc/RCqp3tjYyOW6aUdWaGio09WNTTvqkpKSLL5j7Oo7TwjhrtESpWrT9VGdMGvWZyvoyY0Wkd3d3eHu7g6FQtHrxu1saKopKSlpwBu3SqXiTm6mKsf2cBWlgcWa319LSwvS0tIwYsQI7Nmzx+kNMjzmXPfBZaBoNBr8+OOPyMrKwvfffw+RSITFixfjrrvuwm233WazdADtWFOpVNyMCO3IkslkUCqVXBrCGerGVHVZLpcjKSnJZvMfXSfn9Xq9WYpwoAHV1XXCDAYDSkpKuMYOZ5ig9UdVVRUqKyutSjVRlWOaCnV3dzeT3LEm0Fy7dg2lpaVWBZa2tjYsXrwY4eHhyMrKsolVA49tuWmCiyl6vR6nTp1CZmYm9u3bB6PRiLS0NGRkZGDmzJkW/6FqtVrk5+dDKBQiISGhx4DVVd2YTpSHhYXZ/QNiMBhQUFAAvV6PpKQku/1/1K+cXqdarTYLqL0Fchr42tvbkZyc7PQOta5QoyqpVMrpmNGA2tjYCL1e36sit6Ogqt+D6brqD1sMblJojcqaVGJ7ezsyMjLg5+eH/fv3u9yQL08nN2VwMcVgMODnn3/Gt99+i3379kGpVCItLQ3p6em44447BrzBUZ+TgIAAjBs3bkB3sF0nyv39/SGRSAakFjtYtFot8vLy4ObmhoSEBIdufL0FVNO8vtFoREFBAXQ6nUuaaBFCcOHCBbS2tvYokGkaUE3rF/Q6HXFnTXXgTAcQbU1XLyU6uDmQDrv6+npcvHjRqsDS0dGBpUuXQiwW4+DBg3YdQu5LiFKv1+PVV1/FDz/8gCtXrsDf3x933nknNm7caNYYM3PmTJw+fdrsdZctW4ZvvvnGbut2FW764GKK0WjEr7/+ir179+K7775Da2sr5s+fj/T0dMydO7fXFBJt5bXG56Rr6y8VKpRIJFZ/gKh4p7+//4ADn72gqrimum7BwcGQyWRc4HM1VQBLbIm7mqBR/bqwsDCbb4imNSp7Bpae/t+uHXZUpqXrddLAYk1zhkqlwp/+9CewLIsffvjB7inTvoQo5XI5/vSnP+Gxxx5DQkICWltbsXLlShgMBpw/f557jZkzZyIuLg5vvfUW95inp6fT64iOgA8uvcCyLM6dO8cFmvr6esydOxfp6elYsGAB9wE+cuQIRCIR4uPjbTaD0ZuMPtU7G0zwksvlyMvLc8kZG51Oh7q6Oly5cgVGo7HbLI0rrJXqrFljS6zVas2kaKjMfFhYmNVOlKZGWtbI0tuCroObXl5eCAsLg0AgQGVlJRITEy0OLBqNBsuWLUNHRweOHj1qs5TfQBnI3Mq5c+dwyy23oLq6mnPynDlzJhITE7FlyxbHLNSF4IPLAGBZFvn5+VygqaqqwuzZs2E0GnHmzBkcO3YMycnJdvm/qWkWbf318PDgZGj625iopHpsbCyio6Ptsj5rMNUJi4uLM5Nft9YuwBYYjUbk5+fDaDQiKSnJJieqrrJC1A6YFsoHc6o09ZRPSUlxqDhnf1A5/draWrS1tcHNzY1L+Q628UGr1eL+++9HY2Mjjh075pTuvIEElx9//BFz587lTuRAZ3ApKSkBIQQSiQQLFizAG2+84XJmhfaADy6DhBCCgoICTm4CAGbPno2MjAykpaUhODjYbhshnTGRSqX9+rXU1dXh4sWLLjtj05dOWFe5HYFAMCi7AFtAbYkFAgESExPtUqNiWdasUE6HcAdSKDdtLrDGU96emCoXiEQi7vRmMBjMHDf7Ctp6vR4PPfQQqqurceLECYfPO1H6Cy4ajQa33XYb4uPjsWvXLu7xzz//HDExMQgPD0dxcTFeeukljBw5EsePH3fQyp0HH1wGiUKhwL333otr167h4MGDUKvVyMzMRGZmJgoLC3H77bcjPT0dS5YsQVhYmF0DTUtLCyc6aSrGKJfLUV1djYSEBJcc7huMTlhvWmC92QXYAmpL7O7ujokTJzpkMpoO4dLrpGrVNNiYbsCEEM5rJyUlxSUDC5X17yqS2VPjQ28ePAaDAX/5y19w6dIlnDp1yqkKCH0FF71ej3vuuQc1NTXIzs7uM2WXk5OD1NRU5OTk2C3b4SrwwWWQNDc34+WXX8bmzZvNinK0qJqZmYmsrCycP38eU6dOxZIlS5Ceno7IyEi7BRq6AUulUtTX14NlWYSFhWHIkCEuM3tBsUYnrOsGrNPpzFqcbXG6GKgtsT0hhKCjo4O70+/o6OA24JCQEFRWVqKlpcUlbZ2Bzve4sLBwQLL+dHCzsbERbW1tAIDjx4/jrrvuwueff478/HycOnXK6afv3oKLXq/HvffeiytXruDkyZP9nqwIIXB3dzczBLtR4YOLHSCEoLa2lgs0v/76KyZNmsTJ0FhrZ9wTpj4xI0eO5OYv+jMGcyS21AmjGzANNHQ4lV6rJYV3a2yJ7QntsJNKpWhrawPDMIiOjkZERITLDZnSwGLJe0wtKV5//XX88ssvEAgEeOSRR3D//fdj2rRpTlW26Cm40MBSVlY24JMV9dI5ffo0pk+fbscVOx8+uNgZQgjq6uo4q4CffvoJEydOREZGBtLT023iVKjX65Gfnw9CiJlPDNWOouoApjI0jh7ys7dOGPWcp62/AxGdNIXaEoeFhWH06NEuE1gohBCUlJSgra0NUVFRaGtrc7iIaH80NTWhoKDAqpsHlmWxcuVKHD9+HK+//jrOnj2LAwcOcM0L9nZtNaUvIcrIyEjcfffdyM3NxcGDB82uNygoCGKxGBUVFfj3v/+NhQsXIiQkBBcuXMCqVavg6emJc+fOXXdClIOFDy4OhBACmUyGffv2ISsrC6dOnUJ8fDwXaOLj4we9OWg0GuTl5cHDw6PP+gC906eBZqBT89ZCCEFFRQWuXr3qMJ0w2hLbdWaoN7tj2lwQGRnZzYDOFTCds0lJSeEGMk2Ns2jdzVlS+rQzcezYsRansFiWxZo1a3Dw4EFkZ2djxIgRAP7btZeSkmLLJfdLX0KU69at69Vp9NSpU5g5cyZqa2vxwAMPcO/d0KFDkZaWhjfeeMMla6G2hg8uToJ60nz//ffIzMzEjz/+iBEjRnBWAQMZdqSqAEFBQRgzZsygNhPTlFJHRwc3TW5pSqknaOG5sbHRaTphXTWyqHU1beVub29Hbm6uQ2yJLYFlWU6rLiUlpdf3picpfXpKHYy2myU0NzejoKDA6sDy6quv4ttvv0V2djZGjRpl41XyOBo+uLgIcrkcBw4c4MzPhgwZwgWaxMTEboGDerVbowpA6SmlRGcSLNVtonfbCoXCZXTCTO2O6Z2+Xq9HVFSUS6bCWJZFYWEhNBrNoAY4aTqUXqdarTaTorGltA61dh4zZgwiIiIseg1CCN566y3s3LkT2dnZiI+Pt9n6eJwHH1xcEIVCYeZJExISwik4T5o0Cbt370ZRURGeeeYZm/s8UB8TqVQKuVwOPz8/bmhzoAHC1XXCgP+2yvr5+UGpVHKOoq6ibsyyLAoKCqDVapGSkmJV2rKrtput7KtpYLHG2pkQgo0bN+LTTz/FqVOnHGbsxWN/+ODi4qhUKhw5coTzpAE6U1rPP/88Xn/9dbsWBalsiVQq5QyzaKDpbRrcEcOH1kKH++iAqamjKO2wM218cHThlQZnvV6P5ORkm9bDutajfHx8uKA6GMmd1tZW5OXlWR1YPvzwQ3z44Yc4ceIEEhMTLXqdgdCXCCVdy5tvvont27ejtbUVkydPxieffIJx48Zxz9FqtVi9ejW+/vprMyMvW1pv30jwweU6gRCCV199FR999BGmTZuG33//HWKxmDvRTJs2za6Cj9QwSyqVmumdmW5KtLnA09MTEyZMcMlumP5siU1TSjKZDBqNxiGNDxR7SM70RldpoYF6ttDAMnr0aAwZMsSi/5sQgo8//hibNm3C0aNHMWnSJGsupV/6EqEEgE2bNuGdd97Bjh07EBcXh/Xr1+PMmTMoLS01syA+cOAAduzYgeDgYKxatQotLS3XpQWxI+CDy3XCq6++iq+++gpHjhzB2LFjodPpzDxpWJbFokWLOE8ae6aiqD4WlaHx8PBAYGAgGhsbERwcjLFjxzo9rdQT1PZ3MO3QXRsf7Om/YzQakZeXB0IIkpKSHHrqo4oPtE5D04RUC4xunm1tbcjNzbVoCJZCCMH27dvx5ptv4vDhw7j11ltteSn90nVmhRCCyMhIrFy5EmvXrgXQeUqRSCTYtGkTnnjiCcjlcoSGhpoNP9bV1WHo0KH44YcfMG/ePIdew/UAH1yuEy5dugQfH58eP9AGgwE//fQT50mjVqvNPGnsaaZkNBpx9epVlJeXc9PHdPO11rHQllB3xsHY/nalq/+OLWX0DQYD8vLywDAMkpKSnHonTNOENH1GTdC8vb1RXV2NUaNGWVzrI4Rgx44deOmll3Dw4EGnDBJ2DS5XrlxBbGwscnNzkZSUxD0vPT0dAQEB2LlzJ06ePIk77rgDLS0tZsKZCQkJyMjIwJtvvunoy3B5XC8hztMjfXXQiEQizJo1C7NmzcI///lPnD17Fnv37sXq1avR1taGefPmISMjA3PnzrW5DlV7ezuuXLmCESNGYNiwYdzdb0FBARiGcbjgZFe6ep1YI9Xu6emJ6OhoREdHm8nol5eXc7ULS2wRDAYDcnNzIRQKkZiY6PQUi0AgQFBQEIKCghAXFweFQoHa2lpcuXIFAMxONoM5vRFCsGvXLvzjH//A/v37XWZCvaGhAQC6DX5KJBJUV1dzzxGLxd0UmSUSCffzPOa4bHDZunUr3nvvPdTX12PcuHHYsmULbr/9dmcvy+URCoW4/fbbcfvtt+PDDz/E77//jr179+K1117D448/jjlz5iAjIwPz58+3Wva7J50wmkoxnbsoLi7mFH/p3IUjAg1VDm5oaEBqaqpN52zc3d0RFRWFqKgos9pFVVXVoKbm9Xo9cnNzOaM0ZweWrjAMww3/jh49GiEhIZDJZKivr8elS5e401toaGifkv+EEPznP//BqlWrkJmZ2eNworPp+j4RQvq9SRjIc25WXDK47NmzBytXrsTWrVsxbdo0fPbZZ1iwYAEuXLjAmfDw9I9AIMCUKVMwZcoUbN68GXl5edi7dy82bNiAJ598EnfeeSfS09OxcOHCQXumUEn/3qQ+BAIBgoODERwcjPj4eK4b69KlS5zkukQisZveGSEEFy9eRHNzMyZNmmRX5WA3NzdEREQgIiLCzC6AnkZM04SmQVWv1yMnJwfu7u5ISEhwyToVHTKlJ1MAnJo1Pb01NjaivLycMwcLDQ3tFlS/++47PPPMM9izZ4/L1Sfo4GdDQ4PZrI5MJuP+tsPDw6HT6dDa2mp2epHJZJg6dapjF3yd4JI1l8mTJyM5ORnbtm3jHhszZgwyMjLw7rvvOnFlNwaEEBQXF2Pv3r3IysrC5cuXMWvWLM6TJigoqM9AY41OmGk3llQq5aTlJRKJzfTOWJZFSUkJ2tvbkZKSYteaU3/rMLULMD29+fr6Ii8vD15eXpgwYYLLBpacnBzExMRg+PDhfT63JxO07OxsJCYmwmAw4PHHH8euXbtw1113OWbxfdBbQf/555/HmjVrAHQqO4SFhXUr6O/atQv33nsvgE4h1qioKL6g3wsuF1x0Oh28vLzw7bffmv0hPvfcc8jPz8fp06eduLobD0IISktLOU+aoqIiTJ8+Henp6Vi8eLGZJw3LsqioqMC1a9dsohNmqmwslUq5SXKqDmBJGy6daler1UhOTrZ5R5elmNoFSKVSaDQauLu7Y9SoUTazC7AlCoUCOTk53CllMLAsi5aWFqxZswaHDh1CR0cHZsyYgZUrV9ql7jcQ+hKhHDZsGDZt2oR3330XX375JUaNGoUNGzYgOzu7WyvywYMHsWPHDgQFBWH16tVobm7mW5F7weWCS11dHYYMGYJffvnF7Li5YcMG7Ny5E6WlpU5c3Y0NFZmkVgE5OTmYOnUqlzp7/fXX4enpiffff98uOmF0klwqlVqkd2bP4UNbodVqcf78eXh6esLX1xdNTU1QqVR2k2exBBpYoqOjrdJbO3HiBJYvX45Vq1ZBrVZj3759uHbtGv71r39h+fLlNlxx//QlQrljxw5uiPKzzz4zG6I0VQzQaDR48cUXsXv3brMhSlurZNwouGxwOXv2rFn/+zvvvIP/+7//w6VLl5y4upsHQghqamqQmZmJvXv34rfffoObmxueffZZPProo3bxpDFFrVZzCs6mEvphYWE9prlMW3ldVRlAo9EgJycH/v7+GDduHPf76yrP0t+12pOOjg6cP38ew4YN41SJLeHMmTO455578NFHH2HFihVcY8CFCxcQGBho8VQ/z/WDywUXPi3mWiiVSixduhQNDQ1YtmwZjh8/jp9//pnr709PT8eIESPsGmio3plMJkNbW1u3+RKdToe8vDyX7bgCOq/h/Pnz/RqRdb3W/uwCbElHRwdycnIQFRWF2NhYi1/n7NmzWLp0Kd5//3089thjfDfVTYrLBRegs6CfkpKCrVu3co+NHTsW6enpfEHfwTzxxBMoKyvDvn374OfnB0IIpFIp50mTnZ3NNVukp6fbXV1Yp9Nxm29LSwu8vLyg1+vh4+ODpKQklyyMU4dLao0w0N+PTqfjZmmam5u5bizaEGDL37NSqcT58+cxZMgQjBw50uLX+f3335GRkYH169fj6aef5gPLTYxLBpc9e/bgwQcfxKeffopbb70V27dvx+eff46SkhJER0c7e3k3FVRHrKf0DCEELS0tZp40I0eO5KwC7C0DQ2sDAoEAer2e82qRSCSDEmG0JyqVCjk5OQgNDbUq8PbUjUWvdbBt5F0xDSzW2Dfk5uZi8eLFeO211/D888+7xO+fx3m4ZHABOocoN2/ejPr6eowfPx4ffvihy0z08nSHdkNRT5pjx44hKiqKCzS2nuNQKpXIzc1FSEgI4uPjYTQazTZfsVjMbb7Osv+l1skSiQRxcXE2W0NvOmASiWTQSgh0jREREVa5cBYWFiItLQ0vvvgi1q5d69Df9/Dhw7lJelOeeuopfPLJJ1ixYgV27txp9r3Jkyfjt99+c9QSb0pcNrjYG1tIcPP0jkKhwKFDh5CZmYkjR44gJCQES5YswV133YXU1FSrAg2tDURERGDUqFHdNjLTQUZqCmYqQ+OIjY+eBnpbo63oyS7AVAmhr/qTSqXC+fPnER4ebtUaL1y4gAULFuCZZ57B66+/7vBATp03KcXFxZgzZw5nN7xixQpIpVJ8+eWX3HPEYvFNYTXsTG7a4GILCW6egaFUKnHkyBFkZWXh4MGD8PPzw5IlS5CRkYEpU6YMqgAvl8uRl5eHYcOGISYmpt+NjM5c0M3Xmrv8gUKDn7VppsHSk12AqS+NaWs2TdeFhYVZdaoqLS3FggUL8Oijj2L9+vUukQpbuXIlDh48iLKyMjAMgxUrVqCtrQ379u1z9tJuKm7a4GKKJRLcPJahVqtx/PhxZGVlYf/+/XB3d8fixYuRkZHRrydNa2sr8vPzMWLECItqb6Z3+VKpFCzLcoHGVFbeGmgdaOjQoXbvousLQohZi7Pp3JCvry8KCwutDizl5eVYsGAB7rvvPmzevNklmil0Oh0iIyPxwgsv4OWXXwYArFixAvv27YNYLEZAQABmzJiBd955B2FhYU5e7Y0NH1xgmQQ3j/XodDqcPHmS86QBwHnSzJgxw2yYkJp8WeMjYgqtEdFZGiorT2VoLAk0NLBYOyNiD1QqFRdU29vbIRaLER0dDYlEYpHVcVVVFebPn4+MjAxs2bLFJQILAPznP//Bn//8Z9TU1HCzNHv27IGPjw+io6NRWVmJ1157DQaDgdN147EPfHBB9+By9uxZTJs2DdeuXTMb9nr88cdRXV2No0ePOmmlNy4GgwFnzpzhPGk0Gg0WLVqE9PR0NDQ04N1338Xx48cHLUUyEAghUCgUZtIsvaWTeoPqcA0fPtyqqXZ7QmdtAgIC4O/vj8bGRrS0tMDHx8dslqa/k0xtbS3mzZuH+fPnY+vWrS4TWABg3rx5EIvFOHDgQK/Pqa+vR3R0NL755hssXbrUgau7uXC9MWYXwhIJbh7LEIlEmD17NmbPno2PP/4Yv/zyC/bu3YsnnngCLS0tuOWWW1BQUGATY66uMAwDPz8/+Pn5ITY2FkqlElKpFFVVVSgpKTGzOe5JmkUul3PKwa7aKk8Di+mszdChQzn7aplMhsrKyn7tAurr65GWlobZs2fjk08+canAUl1djR9//BFZWVl9Pi8iIgLR0dEoKytz0MpuTvjg0gMDkeDmsR9CoRDTp09HaWkpdDodPvzwQ9TW1uKVV17BY489hrlz5yIjIwPz5s2zeXMFwzDw8fGBj48PF2hkMhmuXr2KixcvdrM5bmtrQ15eHmJjY13WDoLKzvQ0xOnm5obIyEhERkaatXPn5uZCJBIhNDQUSqUSEyZMQGtrK9LS0nDrrbfi888/dzklhC+//BJhYWFIS0vr83nNzc2ora01+2zz2B4+LQbLJLh57EtJSQmmTZuGAwcOcCZxLMsiNzeXswqora3FnXfeiYyMDCxcuNDu8yxdbY69vb2hVCoxYsQIl6uxUKhQZkBAQJ+yM10x7bJbtmwZN08zceJEHDlyxO5SNIOFZVnExMTgvvvuw8aNG7nHOzo6sG7dOtx9992IiIhAVVUVXn75ZdTU1ODixYt856cduWmDiy0kuHnsS2NjI0JDQ3v8HsuyZp40ZWVlmD17NtLT0wfkSWMtUqkURUVF8PT0hFqtdqgG2EDRarXIycmBn5+fmVDmYJHJZJg1axYYhuGCzsKFC/H3v//dZYyyjh07hnnz5qG0tBRxcXHc42q1GhkZGcjLy0NbWxsiIiIwa9YsvP3227yasZ25aYOLLSS4eVwDQgguXbrEBZri4mLMmDGD86QJDQ21aaBpbm5GQUEB4uPjERkZ2U0DzNvbm1MHGEiB3B7odDqcP3/e6sDS1taGxYsXIyIiAllZWXBzc0N+fj6ysrIwbdo0zJ8/38Yr57lRuGmDizN49913kZWVhUuXLsHT0xNTp07Fpk2bMHr0aO45vDKAdVBPGhpo8vLyOE+aJUuWICIiwqrNvqmpCYWFhRgzZkyPOXu9Xm8mQ0ML5BKJxOZik71BA4uvry/Gjx9v8f/Z3t6OjIwM+Pv74/vvv3eaoyfP9QkfXBzI/PnzsXz5ckyaNAkGgwGvvPIKioqKcOHCBS6VwisD2A5CCKqrq5GZmYnvvvsOv/32G2655Rakp6cjPT0dQ4cOHdTG29jYiKKiIowdO5Zr+ugLWiCXSqU2F5vsDZ1Oh5ycHHh7e2P8+PEWd3N1dHRg6dKlEIvFOHTokEWzMDw3N3xwcSKNjY0ICwvD6dOnMX36dF4ZwI4QQnDt2jVkZWUhKysLv/zyCxITEzmrgP6kZGQyGYqKijB+/HiLOgZNxSZlMpmZ3llAQIBNWnppYPHy8sKECRMsfk2VSoU//elPIITg0KFDdnEd5bnx4YOLEykvL8eoUaO4TYtXBnAM1JPmu+++4zxpxo0bxyk4d5VEqa+vx4ULFzBhwgSbSIawLIvW1lZIpVI0NjaCEMIFmqCgIIuCgl6vR05ODjw9Pa0KLBqNBsuWLeP04Pz8/Cx6HR4e15mAuskghOCFF17AbbfdxjUJNDQ0AEC3O2OJRMJ9j8d6GIZBeHg4/va3v+HYsWOor6/Hs88+i3PnzmHKlCmYPHky1q9fj5KSEnz22WdYunSpzQILAAgEAgQHB2Ps2LGYPn06Z0dw4cIFnD59GsXFxZzC8UCggcXDw8OqwKLVavHAAw9ALpfjhx9+cHhgWbduHRiGMfsyTT8SQrBu3TpERkbC09MTM2fORElJiUPXyDNw+CFKJ/HMM8+gsLAQP//8c7fv8coAjoNhGISEhODRRx/FX/7yF8jlcuzfvx+ZmZl4//33YTAYsGjRItTV1SEkJMTmE+kMwyAwMBCBgYEYPXo02tvbIZVKcfnyZeh0OjMZGpGo+8dVr9cjNzcX7u7umDhxosXr0+l0ePjhh1FfX48TJ04gICDAyiuzjHHjxuHHH3/k/m06qLl582Z88MEHZvXIOXPm8PVIF4UPLk7g2Wefxf79+3HmzBkzEUZeGcC5MAyDgIAAPPTQQzAYDDh58iRefPFFlJaWYu7cuQgLC+M8aVJSUuwSaPz9/eHv749Ro0aho6MDUqkUV65c6SZD4+bmBoPBgLy8PIjFYqvM2PR6Pf7617+isrISJ0+edKrPiUgk6rFZghCCLVu24JVXXuH0wHbu3AmJRILdu3fz9UgXhA8uDoQQgmeffRbfffcdsrOzuwkcxsTEIDw8HMePH+dqLjqdDqdPn8amTZucseSbkp9++gnPPfccDhw4gJkzZwLo9KQ5fPgwsrKysGTJEvj7+3OeNJMnT7a5FArDMPD19YWvry9GjhyJjo4OyGQy1NTU4MKFCwgMDIRarYaHh4dVJxaDwYAnn3wSFy5cwKlTp3odWnUUZWVliIyMhLu7OyZPnowNGzZgxIgRqKysRENDA+bOncs9193dHTNmzMDZs2f54OKC8AV9B/LUU09h9+7d+P77781mW/z9/blWT14ZwPmwLIvLly8jPj6+x++r1WocO3YMWVlZOHDgADw8PMw8aXpKX9kShUKB/Px8GAwGGI1GBAQEcA0Bg5lFMRqNeOaZZ/Drr78iOzvbTAHcGRw+fBgqlQpxcXGQSqVYv349Ll26hJKSEpSWlvJK5dcZfHBxIL3VTb788kusWLECAHhlgOsMnU7HKfF+//33YBgGaWlpuOuuuzB9+vQeVZStgabCBAIBEhMTodfrOasAuVwOPz8/bpamr9kUlmWxcuVKnDp1CqdOnXJJ0U2lUonY2FisWbMGU6ZMwbRp01BXV2eWMn7sscdQW1uLI0eOOHGlPD3BB5ebgG3btmHbtm2oqqoC0Fk0ff3117FgwQIAvCqArdDr9Zwnzffffw+tVou0tDRkZGRg1qxZVk+4G41G5OXlgWEYJCYmdkvFabVaNDY2QiqVorW1FT4+PpBIJN30zliWxZo1a3Do0KEe07OuxJw5czBy5Ei8+OKLfJv+dQbfinwTEBUVhY0bN+L8+fM4f/48J/BI2zhpF87HH3+Mc+fOITw8HHPmzIFCoXDyyq8v3NzccMcdd+DTTz/F1atX8d133yEgIAArV65ETEwM/vKXv2D//v1QqVSDfm0aWAD0GFiAzhpEVFQUUlJSMGPGDAwbNgxtbW349ddfceLECaxevRq//vorXn75Zezfvx8//vijSwcWrVaLixcvIiIiwqweSaH1SFcRz+TpAuG5KQkMDCRffPEFYVmWhIeHk40bN3Lf02g0xN/fn3z66adOXOGNg9FoJL/88gt5/vnnSUxMDPHx8SFLly4lX331FZFKpUSpVPb51d7eTs6cOUOys7NJe3t7v8/v+iWXy8nPP/9MZs2aRYRCIREKheSvf/0r+f333wnLss7+9XCsWrWKZGdnkytXrpDffvuNLFq0iPj6+pKqqipCCCEbN24k/v7+JCsrixQVFZH77ruPREREkPb2dievnKcn+JPLTYbRaMQ333wDpVKJW2+9td8uHB7rEQgEmDp1Kj744AOUl5fj5MmTGDVqFN5++20MHz4cy5cvx9dffw25XA7SJUttNBpRUFAAlmWRlJRkUVeaSCRCYmIipk6disDAQLz//vtQq9W48847MXz4cJcZRLx69Sruu+8+jB49mtM1++233zh3zzVr1mDlypV46qmnkJqaimvXruHYsWN8o4uLwtdcbhKKiopw6623QqPRwMfHB7t378bChQtx9uxZvgvHSbAsi8LCQmRmZiIrKwvl5eW44447sGTJEixatAhisRiPP/447r//fsybN8/iLjRCCD744ANs2bIFJ0+eREJCAoDOtNOJEycwa9YsXpiSx+bwweUmQafToaamBm1tbcjMzMQXX3yB06dPo62tje/CcQEIIbh48SJnFVBSUgIfHx94enri8OHDGDlypEUqDYQQ/POf/8TmzZtx7NgxpKam2mH1PDzd4YPLTcqdd96J2NhYrF27lu/CcTG0Wi0WLlyI0tJShIaGori4GFOnTkVGRgaWLFmC8PDwAQUaQgg+++wzvPXWWzhy5AimTJnigNXz8HTC11xuUggh0Gq1fBeOi2E0GrFs2TLI5XIUFxcjNzcXly9fxuLFi7F3716MHj0ac+fOxccff4za2tpuNRoKIQRffvkl1q1bhwMHDvCBhcfxOKOLgMexvPTSS+TMmTOksrKSFBYWkpdffpkIBAJy7NgxQgjfheNqfPHFF6S5ubnb4yzLkpqaGrJlyxYyffp0IhQKyaRJk8g777xDiouLSUdHB1EqlaSjo4Ns27aN+Pj4kFOnTjl8/Rs2bCCpqanEx8eHhIaGkvT0dHLp0iWz5zz88MMEgNnX5MmTHb5WHvvBp8VuAh599FGcOHEC9fX18Pf3x8SJE7F27VrMmTMHAK8KcD1CCEFDQwPnSXP69GmMHz8e6enpcHd3xzvvvIOsrCyzLkBHMRDH1RUrVkAqleLLL7/kfk4sFjtVNJPHxjg3tvHcTGzYsIEAIM899xz3GMuy5I033iARERHEw8ODzJgxgxQXFztvkdchLMuSxsZG8sUXX5DZs2cTAGTXrl3OXhaHTCYjAMjp06e5xx5++GGSnp7uvEXx2B2+5sLjEM6dO4ft27dj4sSJZo/z6gDWY+pJ8+OPP6K2thb333+/s5fFIZfLAaDbqSQ7OxthYWGIi4vDY489BplM5ozl8dgJPi3GY3c6OjqQnJyMrVu3Yv369UhMTMSWLVtACEFkZCRWrlyJtWvXAujslJJIJNi0aRMvo34DQAhBeno6Wltb8dNPP3GP79mzBz4+PoiOjkZlZSVee+01GAwG5OTkwN3d3Ykr5rEV/MmFx+48/fTTSEtLw5133mn2OK8OcONDHVe//vprs8eXLVuGtLQ0jB8/HosXL8bhw4dx+fJlHDp0yEkr5bE1vFkYj1355ptvkJubi3PnznX7XkNDAwB0c9mUSCSorq52yPp47Edvjqs9ERERgejoaJSVlTlodTz2hg8uPHajtrYWzz33HI4dO9an3HzXgUBCiEXT6DyuAenHcbUnmpubUVtba6YSwXN9w6fFeOxGTk4OZDIZUlJSIBKJIBKJcPr0aXz00UcQiUTciYWeYCgymazbaYbn+uHpp5/Grl27sHv3bvj6+qKhoQENDQ1Qq9UAOmtwVP6/qqoK2dnZWLx4MUJCQnDXXXc5efU8toIPLjx244477kBRURHy8/O5r9TUVNx///3Iz8/HiBEjeHWAG5Bt27ZBLpdj5syZiIiI4L727NkDABAKhSgqKkJ6ejri4uLw8MMPIy4uDr/++iuvcHwDwafFeOyGr69vt0FMb29vBAcHc4+vXLkSGzZswKhRozBq1Chs2LABXl5e+POf/+yMJfPYgP4aUD09PXm17ZsAPrjwOJU1a9ZArVbjqaee4tQBeI8OHp7rH37OheeGZN26dXjzzTfNHpNIJFx9h/whebN9+3YzyZtx48Y5Y7k8PDccfM2F54Zl3LhxqK+v576Kioq47/HKADw89oUPLjw3LCKRCOHh4dxXaGgogM5Ty5YtW/DKK69g6dKlGD9+PHbu3AmVSoXdu3c7edU8PDcGfHDhuWEpKytDZGQkYmJisHz5cly5cgUArwxgLVu3bkVMTAw8PDyQkpJiJuvCw0PhgwvPDcnkyZPx1Vdf4ejRo/j888/R0NCAqVOnorm5uU9lgK4zNzzm7NmzBytXrsQrr7yCvLw83H777ViwYAFqamqcvTQeF4Mv6PPcFCiVSsTGxmLNmjWYMmUKpk2bhrq6OrOJ8Mceewy1tbU4cuSIE1fq2kyePBnJycnYtm0b99iYMWOQkZGBd99914kr43E1+JMLz02Bt7c3JkyYgLKyMoSHhwPglQEGi06nQ05OTjcDsrlz5/LpRJ5u8MGF56ZAq9Xi4sWLiIiIQExMDK8MYAFNTU0wGo18OpFnQPBDlDw3JKtXr8bixYsxbNgwyGQyrF+/Hu3t7Xj44YfBMAyvDGAFvNAoz0DggwvPDcnVq1dx3333oampCaGhoZgyZQp+++03REdHA+CVASwhJCQEQqGQTyfyDAi+oM/DwzNgJk+ejJSUFGzdupV7bOzYsUhPT+cL+jxm8DUXHh47ce3aNTzwwAMIDg6Gl5cXEhMTkZOTw32fEIJ169YhMjISnp6emDlzJkpKSpy44v554YUX8MUXX+Bf//oXLl68iOeffx41NTV48sknnb00HheDT4vx8NiB1tZWTJs2DbNmzcLhw4cRFhaGiooKBAQEcM+hEjQ7duxAXFwc1q9fjzlz5qC0tNRl03PLli1Dc3Mz3nrrLdTX12P8+PH44YcfuHQjDw+FT4vx8NiBf/zjH/jll196nV4nhCAyMhIrV67E2rVrAXR2tEkkEmzatAlPPPGEI5fLw2Nz+LQYD48d2L9/P1JTU3HPPfcgLCwMSUlJ+Pzzz7nv8xI0PDc6fHDh4bEDV65cwbZt2zBq1CgcPXoUTz75JP7+97/jq6++AgBegobnhoevufDw2AGWZZGamooNGzYAAJKSklBSUoJt27bhoYce4p7Hz4zw3KjwJxceHjsQERGBsWPHmj02ZswYTuCRl6DhudHhgwsPjx2YNm0aSktLzR67fPky11XFS9Dw3OjwaTEeHjvw/PPPY+rUqdiwYQPuvfde/P7779i+fTu2b98OALwEDc8ND9+KzMNjJw4ePIiXXnoJZWVliImJwQsvvIDHHnuM+z4hBG+++SY+++wzToLmk08+wfjx4524ah4e28AHFx4eHh4em8PXXHh4eHh4bA4fXHh4eHh4bA4fXHh4eHh4bA4fXHh4eHh4bA4fXHh4eHh4bA4fXHh4eHh4bA4fXHh4eHh4bA4fXHh4eHh4bA4fXHh4eHh4bA4fXHh4eHh4bA4fXHh4eHh4bM7/B3dLxmBhQ/iuAAAAAElFTkSuQmCC", "text/plain": [ "<Figure size 640x480 with 1 Axes>" ] @@ -809,7 +831,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "<Figure size 640x480 with 1 Axes>" ] @@ -819,7 +841,17 @@ }, { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "<Figure size 640x480 with 1 Axes>" ] @@ -835,21 +867,20 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", - "def surf_plot(dp,ny,nx,UorV='sqrt',non_dp=False):\n", + "def surf_plot(dp,x1,x2,UorV='sqrt',non_dp=False):\n", " fig = plt.figure()\n", " ax = fig.add_subplot(projection='3d')\n", "\n", " # Make data\n", " # 生成网格数据\n", - " X, Y = np.meshgrid(np.arange(nx), np.arange(ny))\n", + " X, Y = np.meshgrid(np.arange(x2), np.arange(x1))\n", "\n", " if non_dp:\n", - " Z = Z_x = Z_y = dp.reshape(ny,nx)\n", + " Z = Z_x = Z_y = dp.reshape(x1,x2)\n", " else:\n", - " Z = dp.reshape(ny,nx,2)\n", - " Z_x = Z[:,:,0].reshape(ny,nx)\n", - " Z_y = Z[:,:,1].reshape(ny,nx)\n", - "\n", + " Z = dp.reshape(x1,x2,2)\n", + " Z_x = Z[:,:,0]\n", + " Z_y = Z[:,:,1]\n", "\n", " if UorV == 'u':\n", " ax.plot_surface(X, Y, Z_x, rstride = 1, cstride = 1, cmap='rainbow')\n", @@ -860,10 +891,273 @@ "\n", " plt.show()\n", "\n", - "surf_plot(global_displace,nely+1,nelx+1,'u')\n", - "surf_plot(global_displace,nely+1,nelx+1,'v')\n", - "surf_plot(global_displace,nely+1,nelx+1,'sqrt')\n" + "surf_plot(global_displace,nelx+1,nely+1,'u')\n", + "surf_plot(global_displace_py,nelx+1,nely+1,'u')\n", + "surf_plot(global_displace,nelx+1,nely+1,'v')\n", + "surf_plot(global_displace_py,nelx+1,nely+1,'v')\n" + ] + }, + { + "cell_type": "markdown", + "id": "2d75b669", + "metadata": {}, + "source": [ + "## 网格编号处理例" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "id": "b6cdc698", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 1 2 3 4 5 6 7]\n", + " [ 8 9 10 11 12 13 14]\n", + " [15 16 17 18 19 20 21]\n", + " [22 23 24 25 26 27 28]\n", + " [29 30 31 32 33 34 35]\n", + " [36 37 38 39 40 41 42]\n", + " [43 44 45 46 47 48 49]\n", + " [50 51 52 53 54 55 56]\n", + " [57 58 59 60 61 62 63]\n", + " [64 65 66 67 68 69 70]]\n", + "[[ 1 2 3 4 4 5 6 7]\n", + " [ 8 9 10 11 11 12 13 14]\n", + " [15 16 17 18 18 19 20 21]\n", + " [22 23 24 25 25 26 27 28]\n", + " [22 23 24 25 25 26 27 28]\n", + " [29 30 31 32 32 33 34 35]\n", + " [36 37 38 39 39 40 41 42]\n", + " [43 44 45 46 46 47 48 49]\n", + " [43 44 45 46 46 47 48 49]\n", + " [50 51 52 53 53 54 55 56]\n", + " [57 58 59 60 60 61 62 63]\n", + " [64 65 66 67 67 68 69 70]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "nelx=9\n", + "nely=6\n", + "m=3\n", + "N=(m+1)**2 * 2\n", + "a = np.arange(1, (nelx+1)*(nely+1)+1).reshape(nelx+1, nely+1)\n", + "# a=np.random.rand(nelx+1, nely+1)\n", + "a=np.dstack((a,a))\n", + "a.reshape(nelx+1, nely+1, 2)\n", + "print(a[:,:,0])\n", + "a = np.lib.stride_tricks.as_strided(\n", + " a,\n", + " shape=(int(nelx/m), int(nely/m), m+1, m+1, 2), # 要输出矩阵的 shape\n", + " strides=a.itemsize * np.array([(nely+1)*m*2, m*2, (nely+1)*2, 1*2, 1])\n", + ")\n", + "\n", + "\n", + "aa = a.swapaxes(1,2).reshape(int(nelx/m)*(m+1), int(nely/m)*(m+1), 2) \n", + "print(aa[:,:,0])\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "id": "323fb7b6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0 1 2 3 5 6 7 9 10 11]\n", + "[[ 1 2 3 4 5 6 7]\n", + " [ 8 9 10 11 12 13 14]\n", + " [15 16 17 18 19 20 21]\n", + " [22 23 24 25 26 27 28]\n", + " [29 30 31 32 33 34 35]\n", + " [36 37 38 39 40 41 42]\n", + " [43 44 45 46 47 48 49]\n", + " [50 51 52 53 54 55 56]\n", + " [57 58 59 60 61 62 63]\n", + " [64 65 66 67 68 69 70]]\n" + ] + } + ], + "source": [ + "nelx=9\n", + "nely=6\n", + "c_nelx=3\n", + "c_nely=2\n", + "m=3\n", + "\n", + "\n", + "idx_x=np.arange(c_nelx*(m+1))[::m+1]\n", + "idx_x=np.delete(idx_x,0)\n", + "idx_x=np.delete(np.arange(c_nelx*(m+1)),idx_x)\n", + "idx_y=np.arange(c_nely*(m+1))[::m+1]\n", + "idx_y=np.delete(idx_y,0)\n", + "idx_y=np.delete(np.arange(c_nely*(m+1)),idx_y)\n", + "print(idx_x)\n", + "\n", + "t=aa[idx_x.reshape(nelx+1,1),idx_y.reshape(1,nely+1)]\n", + "print(t[:,:,0])\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "id": "e40e390b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 1 2 3]\n", + " [ 6 7 8]\n", + " [11 12 13]]\n", + "\n", + " [[ 3 4 5]\n", + " [ 8 9 10]\n", + " [13 14 15]]\n", + "\n", + " [[11 12 13]\n", + " [16 17 18]\n", + " [21 22 23]]\n", + "\n", + " [[13 14 15]\n", + " [18 19 20]\n", + " [23 24 25]]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "b = np.arange(1, 26).reshape(5, 5)\n", + "b=np.dstack((b,b))\n", + "b.reshape(5,5,2)\n", + "# print(b)\n", + "b = np.lib.stride_tricks.as_strided(\n", + " b,\n", + " shape=(2, 2, 3, 3, 2), # 要输出矩阵的 shape\n", + " strides=a.itemsize * np.array([10*2, 2*2, 5*2, 1*2, 1])\n", + ")\n", + "\n", + "print(b.reshape(4,3,3,2)[:,:,:,0])" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "id": "0e270641", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.48704171 0.97910573 0.2691312 0.74181994 0.99968776 0.60235797]\n", + " [0.31540146 0.45801118 0.92682537 0.17834175 0.71395762 0.78694709]\n", + " [0.81429157 0.0128919 0.05522511 0.68708901 0.37991832 0.75490116]\n", + " [0.0923656 0.93236976 0.46732656 0.82158008 0.96714427 0.39377232]\n", + " [0.91440505 0.99684034 0.38424708 0.3961644 0.59452613 0.50723417]\n", + " [0.63510107 0.43102241 0.10306139 0.8261425 0.84541232 0.3189449 ]\n", + " [0.50660991 0.73673783 0.08101684 0.46108934 0.93646435 0.72354619]\n", + " [0.13452272 0.40959372 0.96067908 0.50133956 0.73729468 0.8704286 ]\n", + " [0.14745965 0.40101883 0.53223359 0.70898378 0.66795705 0.52147271]]\n", + "[[0.74181994 0.99968776 0.60235797]\n", + " [0.17834175 0.71395762 0.78694709]\n", + " [0.68708901 0.37991832 0.75490116]]\n", + "[[0.50660991 0.73673783 0.08101684]\n", + " [0.13452272 0.40959372 0.96067908]\n", + " [0.14745965 0.40101883 0.53223359]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "nelx=9\n", + "nely=6\n", + "m=3\n", + "\n", + "# a = np.arange(1, (nelx+1)*(nely+1)+1).reshape(nelx+1, nely+1)\n", + "a=np.random.rand(nelx, nely)\n", + "# a=np.dstack((a,a))\n", + "a.reshape(nelx, nely)\n", + "print(a[:,:])\n", + "a = np.lib.stride_tricks.as_strided(\n", + " a,\n", + " shape=(int(nelx/m), int(nely/m), m, m), # 要输出矩阵的 shape\n", + " strides=a.itemsize * np.array([nely*m, m, nely, 1])\n", + ")\n", + "\n", + "print(a[0,1,:,:])\n", + "print(a[2,0,:,:])\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "id": "316ed04a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 1 2 3 4 5 6 7]\n", + " [ 8 9 10 11 12 13 14]\n", + " [15 16 17 18 19 20 21]\n", + " [22 23 24 25 26 27 28]\n", + " [29 30 31 32 33 34 35]\n", + " [36 37 38 39 40 41 42]\n", + " [43 44 45 46 47 48 49]\n", + " [50 51 52 53 54 55 56]\n", + " [57 58 59 60 61 62 63]\n", + " [64 65 66 67 68 69 70]]\n", + "[[ 4 7]\n", + " [25 28]]\n", + "[[43 46]\n", + " [64 67]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "nelx=9\n", + "nely=6\n", + "m=3\n", + "\n", + "a = np.arange(1, (nelx+1)*(nely+1)+1).reshape(nelx+1, nely+1)\n", + "a=np.dstack((a,a))\n", + "a.reshape(nelx+1, nely+1, 2)\n", + "print(a[:,:,0])\n", + "a = np.lib.stride_tricks.as_strided(\n", + " a,\n", + " shape=(int(nelx/m), int(nely/m), 2, 2, 2), # 要输出矩阵的 shape\n", + " strides=a.itemsize * np.array([(nely+1)*m*2, m*2, (nely+1)*m*2, m*2, 1])\n", + ")\n", + "\n", + "print(a[0,1,:,:,0])\n", + "print(a[2,0,:,:,0])\n" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f8094cec", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": {